diff --git a/Cargo.lock b/Cargo.lock
index bc3e11e9b2b..340be45cb90 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -204,6 +204,7 @@ dependencies = [
  "bun_core",
  "bun_dispatch",
  "bun_paths",
+ "bun_perf",
  "bun_ptr",
  "bun_sys",
  "bun_wyhash",
@@ -356,6 +357,7 @@ dependencies = [
  "bstr",
  "bumpalo",
  "bun_alloc",
+ "bun_analytics",
  "bun_ast",
  "bun_base64",
  "bun_collections",
@@ -1590,6 +1592,7 @@ dependencies = [
  "bitflags",
  "bstr",
  "bun_ast",
+ "bun_collections",
  "bun_core",
  "bun_options_types",
  "const_format",
@@ -2041,6 +2044,7 @@ version = "0.0.0"
 dependencies = [
  "bitflags",
  "bstr",
+ "bun_analytics",
  "bun_base64",
  "bun_boringssl",
  "bun_boringssl_sys",
diff --git a/scripts/build/features-json.ts b/scripts/build/features-json.ts
index 5ce60a384c9..6e6b1d823e5 100644
--- a/scripts/build/features-json.ts
+++ b/scripts/build/features-json.ts
@@ -43,17 +43,25 @@ export function parsePackedFeaturesList(cwd: string): string[] {
   const sourcePath = resolve(cwd, "src", "analytics", "lib.rs");
   const source = readFileSync(sourcePath, "utf8");
 
-  const invocation = source.match(/define_features!\s*\{([\s\S]*?)\n\s*\}/);
-  if (invocation === null) {
+  // The macro now recurses internally (`define_features! { @storage ... }`),
+  // so several invocation-shaped blocks exist; the entry list is the one whose
+  // body contains `<index> => (...)` arms. Scan every block and keep the
+  // entries we find — the density check below still rejects partial parses.
+  const invocations = [...source.matchAll(/define_features!\s*\{([\s\S]*?)\n\s*\}/g)];
+  if (invocations.length === 0) {
     throw new BuildError(`Could not find the define_features! invocation in ${sourcePath}`, {
       hint: "parsePackedFeaturesList() in scripts/build/features-json.ts needs updating to match the new shape.",
     });
   }
 
   const entries: { index: number; name: string }[] = [];
-  const entryRe = /(\d+)\s*=>\s*\(\s*\w+\s*,\s*"((?:[^"\\]|\\.)*)"\s*\)/g;
-  for (const m of invocation[1]!.matchAll(entryRe)) {
-    entries.push({ index: Number(m[1]), name: m[2]! });
+  // `<index> => (<rust_ident>, "<feature name>")` with an optional
+  // `, core = IDENT` alias of the bun_core feature static.
+  const entryRe = /(\d+)\s*=>\s*\(\s*\w+\s*,\s*"((?:[^"\\]|\\.)*)"\s*(?:,\s*core\s*=\s*\w+\s*)?\)/g;
+  for (const invocation of invocations) {
+    for (const m of invocation[1]!.matchAll(entryRe)) {
+      entries.push({ index: Number(m[1]), name: m[2]! });
+    }
   }
   if (entries.length === 0) {
     throw new BuildError(`Parsed zero entries from define_features! in ${sourcePath}`, {
diff --git a/src/analytics/lib.rs b/src/analytics/lib.rs
index 4af975b761d..de62f1a76dc 100644
--- a/src/analytics/lib.rs
+++ b/src/analytics/lib.rs
@@ -36,7 +36,6 @@ impl TriState {
     }
 }
 
-// Zig: `pub var enabled: enum { yes, no, unknown } = .unknown;`
 static ENABLED: AtomicU8 = AtomicU8::new(TriState::Unknown as u8);
 
 pub(crate) fn enabled() -> TriState {
@@ -52,9 +51,9 @@ pub fn is_enabled() -> bool {
         TriState::No => false,
         TriState::Unknown => {
             let detected = 'detect: {
-                // PORT NOTE: `env_var::*.get()` returns `Option<ValueType>` in
-                // the Rust port even when a default exists; `DO_NOT_TRACK` has
-                // `default: false` so `.unwrap_or(false)` matches Zig semantics.
+                // `env_var::*.get()` returns `Option<ValueType>` even when a
+                // default exists; `DO_NOT_TRACK` has `default: false`, hence
+                // `.unwrap_or(false)`.
                 if env_var::DO_NOT_TRACK.get().unwrap_or(false) {
                     break 'detect TriState::No;
                 }
@@ -79,38 +78,51 @@ pub fn is_enabled() -> bool {
 
 /// This answers, "What parts of bun are people actually using?"
 ///
-/// PORT NOTE: In Zig this is a `struct` used purely as a namespace of `pub var`
-/// decls, iterated via `@typeInfo` reflection. Rust has no decl reflection, so
-/// the feature list is declared once via `define_features!` and that macro
+/// The feature list is declared once via `define_features!` and that macro
 /// generates the statics, `PACKED_FEATURES_LIST`, `PackedFeatures`,
 /// `packed_features()`, and the `Display` body.
 pub mod features {
     use super::*;
 
-    // PORT NOTE (cyclebreak): the Zig original is
-    // `EnumSet(bun.jsc.ModuleLoader.HardcodedModule)`. That enum lives in
+    // Note (cyclebreak): `bun.jsc.ModuleLoader.HardcodedModule` lives in
     // `bun_resolve_builtins` (T5) and pulling it here would create a forward
     // dep (analytics is T1). The only operations we need are `insert` and
     // ordered iteration of the module *names* for the crash-report formatter,
     // so store the `&'static str` name (= `@tagName(HardcodedModule)`) instead
     // of the enum value. Writers (`runtime/jsc_hooks.rs`) call
     // `BUILTIN_MODULES.lock().insert(<&'static str>::from(hardcoded))`.
-    // PERF(port): Zig used a packed `EnumSet` (bitset); BTreeSet is O(log n)
-    // insert — fine for ≤~80 entries written once each at module-load time.
+    // PERF: BTreeSet is O(log n) insert — fine for ≤~80 entries written once
+    // each at module-load time.
     pub(crate) static BUILTIN_MODULES: bun_core::Mutex<std::collections::BTreeSet<&'static str>> =
         bun_core::Mutex::new(std::collections::BTreeSet::new());
-    // PORT NOTE: Zig used a plain mutable global; wrapped in a Mutex here
-    // because the set is not a single atomic word.
+
+    /// Record a builtin-module load.
+    pub fn insert_builtin_module(name: &'static str) {
+        BUILTIN_MODULES.lock().insert(name);
+    }
 
     macro_rules! define_features {
-        ( $( $(#[$doc:meta])* $idx:literal => ($ident:ident, $name:literal) ),* $(,)? ) => {
+        // Storage for one feature counter. Entries tagged `core = IDENT` alias
+        // the tier-0 `bun_core::Global::features::IDENT` static (the MOVE_DOWN
+        // set written by low-tier crates: dotenv/install/css/todo_panic!/...)
+        // so the crash-report/analytics readers below observe those writes —
+        // a fresh static here would be a split brain that stays forever 0.
+        // Entries with an `export_name` attribute must NOT be `core`-tagged:
+        // the exported symbol has to be the single canonical definition here.
+        (@storage $(#[$doc:meta])* $ident:ident) => {
+            $(#[$doc])*
+            #[allow(non_upper_case_globals)]
+            pub static $ident: AtomicUsize = AtomicUsize::new(0);
+        };
+        (@storage $(#[$doc:meta])* $ident:ident, $core:ident) => {
+            $(#[$doc])*
+            pub use ::bun_core::Global::features::$core as $ident;
+        };
+        ( $( $(#[$doc:meta])* $idx:literal => ($ident:ident, $name:literal $(, core = $core:ident)?) ),* $(,)? ) => {
             $(
-                $(#[$doc])*
-                #[allow(non_upper_case_globals)]
-                pub static $ident: AtomicUsize = AtomicUsize::new(0);
+                define_features! { @storage $(#[$doc])* $ident $(, $core)? }
             )*
 
-            // Zig: `validateFeatureName(decl.name)` per entry at comptime.
             $(
                 const _: () = assert!(
                     super::validate_feature_name($name.as_bytes()),
@@ -118,12 +130,10 @@ pub mod features {
                 );
             )*
 
-            /// Zig: `pub const packed_features_list = brk: { ... }`
             pub const PACKED_FEATURES_LIST: &[&str] = &[ $( $name ),* ];
 
-            // Zig: `pub const PackedFeatures = @Type(.{ .@"struct" = .{ .layout = .@"packed", .backing_integer = u64, ... } })`
             // All fields are `bool` → bitflags over u64.
-            // PORT NOTE: nightly `${index()}` (macro_metavar_expr) is unavailable
+            // Note: nightly `${index()}` (macro_metavar_expr) is unavailable
             // on stable, so each feature carries an explicit `$idx` literal at the
             // call site. The dense-index assertion below catches gaps/duplicates.
             ::bitflags::bitflags! {
@@ -148,7 +158,8 @@ pub mod features {
                 "feature indices must be dense 0..N with no gaps or duplicates"
             );
 
-            /// Zig: `pub fn packedFeatures() PackedFeatures`
+            /// Snapshot of all feature counters as a `PackedFeatures` bitset
+            /// (bit set iff the feature was used at least once).
             pub fn packed_features() -> PackedFeatures {
                 let mut bits = PackedFeatures::empty();
                 $(
@@ -214,73 +225,71 @@ pub mod features {
         };
     }
 
-    // PORT NOTE: Zig identifiers `@"Bun.stderr"` etc. cannot be Rust idents;
-    // renamed to `bun_stderr` etc. The string literal preserves the original
-    // name for output / `PACKED_FEATURES_LIST` (matches `@tagName` semantics).
+    // The string literal is the name used for output / `PACKED_FEATURES_LIST`.
     // The leading integer is the bit index in `PackedFeatures` (must be dense
     // 0..N — asserted at compile time inside the macro).
     define_features! {
-        0 => (bun_stderr, "Bun.stderr"),
-        1 => (bun_stdin, "Bun.stdin"),
-        2 => (bun_stdout, "Bun.stdout"),
-        3 => (web_socket, "WebSocket"),
-        4 => (abort_signal, "abort_signal"),
-        5 => (binlinks, "binlinks"),
-        6 => (bunfig, "bunfig"),
-        7 => (define, "define"),
-        8 => (dotenv, "dotenv"),
-        9 => (debugger, "debugger"),
-        10 => (external, "external"),
-        11 => (extracted_packages, "extracted_packages"),
-        12 => (fetch, "fetch"),
-        13 => (git_dependencies, "git_dependencies"),
-        14 => (html_rewriter, "html_rewriter"),
+        0 => (bun_stderr, "Bun.stderr", core = BUN_STDERR),
+        1 => (bun_stdin, "Bun.stdin", core = BUN_STDIN),
+        2 => (bun_stdout, "Bun.stdout", core = BUN_STDOUT),
+        3 => (web_socket, "WebSocket", core = WEBSOCKET),
+        4 => (abort_signal, "abort_signal", core = ABORT_SIGNAL),
+        5 => (binlinks, "binlinks", core = BINLINKS),
+        6 => (bunfig, "bunfig", core = BUNFIG),
+        7 => (define, "define", core = DEFINE),
+        8 => (dotenv, "dotenv", core = DOTENV),
+        9 => (debugger, "debugger", core = DEBUGGER),
+        10 => (external, "external", core = EXTERNAL),
+        11 => (extracted_packages, "extracted_packages", core = EXTRACTED_PACKAGES),
+        12 => (fetch, "fetch", core = FETCH),
+        13 => (git_dependencies, "git_dependencies", core = GIT_DEPENDENCIES),
+        14 => (html_rewriter, "html_rewriter", core = HTML_REWRITER),
         /// TCP server from `Bun.listen`
-        15 => (tcp_server, "tcp_server"),
+        15 => (tcp_server, "tcp_server", core = TCP_SERVER),
         /// TLS server from `Bun.listen`
-        16 => (tls_server, "tls_server"),
-        17 => (http_server, "http_server"),
-        18 => (https_server, "https_server"),
-        19 => (http_client_proxy, "http_client_proxy"),
+        16 => (tls_server, "tls_server", core = TLS_SERVER),
+        17 => (http_server, "http_server", core = HTTP_SERVER),
+        18 => (https_server, "https_server", core = HTTPS_SERVER),
+        19 => (http_client_proxy, "http_client_proxy", core = HTTP_CLIENT_PROXY),
         /// Set right before JSC::initialize is called
-        20 => (jsc, "jsc"),
+        20 => (jsc, "jsc", core = JSC),
         /// Set when bake.DevServer is initialized
-        21 => (dev_server, "dev_server"),
-        22 => (lifecycle_scripts, "lifecycle_scripts"),
-        23 => (loaders, "loaders"),
-        24 => (lockfile_migration_from_package_lock, "lockfile_migration_from_package_lock"),
-        25 => (text_lockfile, "text_lockfile"),
-        26 => (isolated_bun_install, "isolated_bun_install"),
-        27 => (hoisted_bun_install, "hoisted_bun_install"),
-        28 => (macros, "macros"),
-        29 => (no_avx2, "no_avx2"),
-        30 => (no_avx, "no_avx"),
-        31 => (shell, "shell"),
-        32 => (spawn, "spawn"),
-        33 => (standalone_executable, "standalone_executable"),
-        34 => (standalone_shell, "standalone_shell"),
+        21 => (dev_server, "dev_server", core = DEV_SERVER),
+        22 => (lifecycle_scripts, "lifecycle_scripts", core = LIFECYCLE_SCRIPTS),
+        23 => (loaders, "loaders", core = LOADERS),
+        24 => (lockfile_migration_from_package_lock, "lockfile_migration_from_package_lock", core = LOCKFILE_MIGRATION_FROM_PACKAGE_LOCK),
+        25 => (text_lockfile, "text_lockfile", core = TEXT_LOCKFILE),
+        26 => (isolated_bun_install, "isolated_bun_install", core = ISOLATED_BUN_INSTALL),
+        27 => (hoisted_bun_install, "hoisted_bun_install", core = HOISTED_BUN_INSTALL),
+        28 => (macros, "macros", core = MACROS),
+        29 => (no_avx2, "no_avx2", core = NO_AVX2),
+        30 => (no_avx, "no_avx", core = NO_AVX),
+        31 => (shell, "shell", core = SHELL),
+        32 => (spawn, "spawn", core = SPAWN),
+        33 => (standalone_executable, "standalone_executable", core = STANDALONE_EXECUTABLE),
+        34 => (standalone_shell, "standalone_shell", core = STANDALONE_SHELL),
         /// Set when invoking a todo panic
-        35 => (todo_panic, "todo_panic"),
-        36 => (transpiler_cache, "transpiler_cache"),
-        37 => (tsconfig, "tsconfig"),
-        38 => (tsconfig_paths, "tsconfig_paths"),
-        39 => (virtual_modules, "virtual_modules"),
-        40 => (workers_spawned, "workers_spawned"),
-        41 => (workers_terminated, "workers_terminated"),
+        35 => (todo_panic, "todo_panic", core = TODO_PANIC),
+        36 => (transpiler_cache, "transpiler_cache", core = TRANSPILER_CACHE),
+        37 => (tsconfig, "tsconfig", core = TSCONFIG),
+        38 => (tsconfig_paths, "tsconfig_paths", core = TSCONFIG_PATHS),
+        39 => (virtual_modules, "virtual_modules", core = VIRTUAL_MODULES),
+        40 => (workers_spawned, "workers_spawned", core = WORKERS_SPAWNED),
+        41 => (workers_terminated, "workers_terminated", core = WORKERS_TERMINATED),
         #[unsafe(export_name = "Bun__napi_module_register_count")]
         42 => (napi_module_register, "napi_module_register"),
         #[unsafe(export_name = "Bun__process_dlopen_count")]
         43 => (process_dlopen, "process_dlopen"),
         44 => (postgres_connections, "postgres_connections"),
         45 => (s3, "s3"),
-        46 => (valkey, "valkey"),
+        46 => (valkey, "valkey", core = VALKEY),
         47 => (csrf_verify, "csrf_verify"),
         48 => (csrf_generate, "csrf_generate"),
         49 => (unsupported_uv_function, "unsupported_uv_function"),
-        50 => (exited, "exited"),
-        51 => (yarn_migration, "yarn_migration"),
-        52 => (pnpm_migration, "pnpm_migration"),
-        53 => (yaml_parse, "yaml_parse"),
+        50 => (exited, "exited", core = EXITED),
+        51 => (yarn_migration, "yarn_migration", core = YARN_MIGRATION),
+        52 => (pnpm_migration, "pnpm_migration", core = PNPM_MIGRATION),
+        53 => (yaml_parse, "yaml_parse", core = YAML_PARSE),
         54 => (cpu_profile, "cpu_profile"),
         #[unsafe(export_name = "Bun__Feature__heap_snapshot")]
         55 => (heap_snapshot, "heap_snapshot"),
@@ -290,8 +299,7 @@ pub mod features {
         57 => (webview_webkit, "webview_webkit"),
     }
 
-    // Zig: `comptime { @export(&napi_module_register, .{ .name = "Bun__napi_module_register_count" }); ... }`
-    // PORT NOTE: C++ declares these as `extern "C" size_t Bun__...;` and
+    // C++ declares these as `extern "C" size_t Bun__...;` and
     // reads/increments the value directly, so the exported symbol must BE the
     // `usize` storage (not a pointer to it). `AtomicUsize` is `#[repr(C)]
     // usize`-layout-compatible. Handled via `#[unsafe(export_name = "...")]`
@@ -300,13 +308,11 @@ pub mod features {
     // attached to the single definition.
 }
 
-// Re-exports to mirror Zig's `Features.packedFeatures()` etc. at module scope.
 pub use features::{
     Formatter as FeaturesFormatter, PACKED_FEATURES_LIST, PackedFeatures, packed_features,
 };
 
-/// Zig: `pub fn validateFeatureName(name: []const u8) void` (comptime-only).
-/// In Rust this is enforced at the macro definition site; kept as a `const fn`
+/// Enforced at the macro definition site; kept as a `const fn`
 /// for documentation / debug assertions.
 pub(crate) const fn validate_feature_name(name: &[u8]) -> bool {
     if name.len() > 64 {
@@ -336,11 +342,6 @@ pub enum EventName {
     http_build,
 }
 
-// Zig: `var random: std.rand.DefaultPrng = undefined;`
-// PORT NOTE: declared but never read in analytics.zig — dead code. Dropped
-// rather than gated; if a future schema-encode path needs a PRNG, seed one
-// locally (PORTING.md §Concurrency: OnceLock<...>, no `static mut`).
-
 const PLATFORM_ARCH: analytics::Architecture = {
     #[cfg(target_arch = "aarch64")]
     {
@@ -409,11 +410,8 @@ pub mod generate_header {
         // Linux / Android
         // ──────────────────────────────────────────────────────────────────
 
-        // Zig: `pub var linux_os_name: std.c.utsname = undefined;`
-        // PORT NOTE: Zig's `Environment.isLinux` is true on Android (it checks
-        // the kernel, not the libc target), so all Linux-gated items below are
-        // `any(linux, android)` — `for_linux()` itself branches on Android.
-        // The cached `utsname` itself now lives in T1 at
+        // All Linux-gated items below are `any(linux, android)` —
+        // `for_linux()` itself branches on Android. The cached `utsname` itself now lives in T1 at
         // `bun_core::ffi::cached_uname()` so `bun_sys` feature probes share the
         // same single `uname(2)` syscall.
 
@@ -512,7 +510,6 @@ pub mod generate_header {
         }
         #[cfg(not(any(target_os = "linux", target_os = "android")))]
         pub fn kernel_version() -> semver::Version {
-            // Zig: @compileError("This function is only implemented on Linux")
             unreachable!("kernel_version() is only implemented on Linux");
         }
 
@@ -578,9 +575,6 @@ pub mod generate_header {
         // FreeBSD
         // ──────────────────────────────────────────────────────────────────
 
-        // Zig std's `std.c.utsname` has no FreeBSD branch; use translate-c's.
-        // PORT NOTE: Rust's `libc` crate does provide `utsname`/`uname` on
-        // FreeBSD, so the translate-c indirection is unnecessary here.
         #[cfg(target_os = "freebsd")]
         fn for_freebsd() -> analytics::Platform {
             let name = bun_core::ffi::cached_uname();
@@ -597,5 +591,3 @@ pub use generate_header as GenerateHeader;
 
 pub mod schema;
 pub use schema::{BufReader, Reader, SchemaInt};
-
-// ported from: src/analytics/analytics.zig
diff --git a/src/analytics/schema.rs b/src/analytics/schema.rs
index aa521e7e7d3..62d6be21d8d 100644
--- a/src/analytics/schema.rs
+++ b/src/analytics/schema.rs
@@ -1,6 +1,6 @@
 // GENERATED: re-run the analytics schema generator (peechy) with .rs output
-// source: src/analytics/schema.zig
-// TODO(port): regenerate remaining analytics::* types for Rust
+// Hand-ported subset — the remaining analytics::* types are unused at runtime
+// and come back with the next peechy regen (see the `analytics` mod below).
 
 use bun_core::Error;
 
@@ -8,68 +8,54 @@ use bun_core::Error;
 // Reader / Writer
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig's peechy codec exposes a concrete `Reader` struct and a comptime-generic
-// `Writer(WritableStream)` struct, but every generated `decode`/`encode` takes
-// `reader: anytype` / `writer: anytype` — i.e. structural duck typing. Per
-// PORTING.md §Comptime reflection, `anytype` → trait bound: the *protocol* is
-// the trait, and the Zig `Reader` struct is one concrete impl (`BufReader`
-// below).
-//
-// Only the primitive-int / byte-slice surface is ported. Zig's
-// `readValue(comptime T)` / `writeValue(comptime T, ...)` switch on
-// `@typeInfo(T)` to dispatch to enum/packed-struct/`.decode` paths; that
-// reflection has no Rust equivalent, so per-type `decode`/`encode` impls call
-// the primitive methods directly (which is what the generated schema bodies
-// already do).
-
-/// Zig: `Reader.ReadError = error{EOF}`.
-// PORT NOTE: peechy's two error cases (`EOF`, `InvalidValue`) are folded into
+// The peechy codec protocol is the `Reader` trait below; `BufReader` is one
+// concrete impl. Only the primitive-int / byte-slice surface is implemented;
+// per-type `decode`/`encode` impls call the primitive methods directly
+// (which is what the generated schema bodies already do).
+
+// peechy's two error cases (`EOF`, `InvalidValue`) are folded into
 // the crate-wide `bun_core::Error` so downstream `decode` signatures stay
 // `Result<_, bun_core::Error>` without an extra `From` hop.
-pub(crate) const EOF: Error = Error::TODO; // TODO(port): Error::from_name("EOF") once name→code table lands
+// (`Error::from_name` interns at runtime, so this is a fn, not a const.)
+#[inline]
+pub(crate) fn eof() -> Error {
+    bun_core::err!("EOF")
+}
 
 /// Primitive integers encodable in the peechy wire format (native-endian raw
-/// bytes). Zig handled this via `comptime T` + `std.mem.readIntSliceNative` /
-/// `std.mem.asBytes`; Rust needs an explicit trait bound.
+/// bytes).
 pub use bun_core::NativeEndianInt as SchemaInt;
 
 /// Duck-typed reader protocol for peechy `decode` impls.
-///
-/// Zig: `fn decode(reader: anytype) anyerror!T` — the `anytype` becomes a
-/// `R: Reader` bound on the Rust side.
 pub trait Reader {
-    /// Zig: `fn read(this, count: usize) ![]u8` — borrow `count` bytes,
-    /// advancing the cursor. Errors with `EOF` if fewer than `count` remain.
+    /// Borrow `count` bytes, advancing the cursor. Errors with `EOF` if
+    /// fewer than `count` remain.
     fn read(&mut self, count: usize) -> Result<&[u8], Error>;
 
-    /// Zig: `readByte`
     #[inline]
     fn read_byte(&mut self) -> Result<u8, Error> {
         Ok(self.read(1)?[0])
     }
 
-    /// Zig: `readBool`
     #[inline]
     fn read_bool(&mut self) -> Result<bool, Error> {
         Ok(self.read_byte()? > 0)
     }
 
-    /// Zig: `readInt(comptime T)` — `std.mem.readIntSliceNative`.
     #[inline]
     fn read_int<T: SchemaInt>(&mut self) -> Result<T, Error> {
         let b = self.read(T::SIZE)?;
         Ok(T::from_ne_slice(b))
     }
 
-    /// Zig: `readValue(comptime T)` for the primitive-int arm. Struct/enum
-    /// arms are expressed as per-type `decode(reader)` fns instead (no
-    /// `@typeInfo` in Rust).
+    /// Primitive-int read; struct/enum cases are expressed as per-type
+    /// `decode(reader)` fns instead.
     #[inline]
     fn read_value<T: SchemaInt>(&mut self) -> Result<T, Error> {
         self.read_int::<T>()
     }
 
-    /// Zig: `readByteArray` — `u32` length prefix + raw bytes.
+    /// `u32` length prefix + raw bytes.
     #[inline]
     fn read_byte_array(&mut self) -> Result<&[u8], Error> {
         let len = self.read_int::<u32>()? as usize;
@@ -80,17 +66,12 @@ pub trait Reader {
     }
 }
 
-// peechy `Writer` lives in `bun_options_types::schema::Writer` (the canonical
-// `Vec<u8>`-backed struct port of `schema.zig:169 fn Writer(WritableStream)`).
-// This crate keeps only the read side; encode users depend on options_types
-// directly.
+// peechy `Writer` lives in `bun_options_types::schema::Writer`. This crate
+// keeps only the read side; encode users depend on options_types directly.
 
-/// Concrete buffer-backed reader — direct port of Zig's `pub const Reader = struct`.
+/// Concrete buffer-backed reader.
 ///
-/// PORT NOTE: the Zig struct also carries `std.mem.Allocator param` for
-/// `readArray`'s nested-slice case; per PORTING.md §Allocators (non-AST crate)
-/// the allocator param is dropped — callers that need owned sub-arrays
-/// allocate at the call site.
+/// Callers that need owned sub-arrays allocate at the call site.
 pub struct BufReader<'a> {
     pub buf: &'a [u8],
     pub remain: &'a [u8],
@@ -107,7 +88,7 @@ impl<'a> Reader for BufReader<'a> {
     fn read(&mut self, count: usize) -> Result<&[u8], Error> {
         let read_count = core::cmp::min(count, self.remain.len());
         if read_count < count {
-            return Err(EOF);
+            return Err(eof());
         }
         let (slice, rest) = self.remain.split_at(read_count);
         self.remain = rest;
@@ -122,10 +103,8 @@ impl<'a> Reader for BufReader<'a> {
 // the schema (EventKind, EventListHeader, …) are unused at runtime today and
 // will be filled in by the peechy regen.
 pub mod analytics {
-    /// Zig: `pub const OperatingSystem = enum(u8) { _none, linux, macos, windows, wsl, android, freebsd, _ }`
-    // PORT NOTE: Zig's open enum (`_`) is dropped — Rust enums are closed; the
-    // schema decoder is the only producer of unknown discriminants and it is
-    // not yet ported.
+    // Closed enum: the schema decoder is the only producer of unknown
+    // discriminants and it is not yet implemented.
     #[repr(u8)]
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
     pub enum OperatingSystem {
@@ -144,7 +123,6 @@ pub mod analytics {
         Freebsd,
     }
 
-    /// Zig: `pub const Architecture = enum(u8) { _none, x64, arm, _ }`
     #[repr(u8)]
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
     pub enum Architecture {
@@ -155,7 +133,6 @@ pub mod analytics {
         Arm,
     }
 
-    /// Zig: `pub const Platform = struct { os, arch, version: []const u8 }`
     #[derive(Copy, Clone)]
     pub struct Platform {
         /// os
@@ -166,5 +143,3 @@ pub mod analytics {
         pub version: &'static [u8],
     }
 }
-
-// ported from: src/analytics/schema.zig
diff --git a/src/api/lib.rs b/src/api/lib.rs
index de79a80e96c..b65da42ec2a 100644
--- a/src/api/lib.rs
+++ b/src/api/lib.rs
@@ -2,14 +2,13 @@
 #![warn(unused_must_use)]
 //! `bun.schema.api` namespace.
 //!
-//! Ground truth: `src/options_types/schema.zig` (the `pub const api = struct {…}`
-//! block — generated from `src/api/schema.peechy`). The full peechy → `.rs`
-//! emitter is not landed yet; this crate hand-ports the slice of the schema
-//! that downstream crates name today (`bun_ini`, `bun_install`, `bun_runtime`
+//! Ground truth: `src/api/schema.peechy`. The full peechy → `.rs` emitter is
+//! not landed yet; this crate hand-writes the slice of the schema that
+//! downstream crates name today (`bun_ini`, `bun_install`, `bun_runtime`
 //! bunfig parser) so they can un-gate against real field shapes.
 //!
 //! LAYERING: the actual data shapes (`NpmRegistry`, `NpmRegistryMap`, `Ca`,
-//! `BunInstall`) were originally hand-ported in two places — here *and* in
+//! `BunInstall`) were originally hand-written in two places — here *and* in
 //! `bun_options_types::schema::api`. Downstream crates ended up holding values
 //! of one and passing them to functions typed against the other (e.g.
 //! `bun_options_types::context::install` vs. `bun_ini::load_npmrc_config`),
@@ -34,20 +33,18 @@ pub use bun_options_types::schema::api::{
 // npm_registry  — module path for the nested `NpmRegistry::Parser`
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig nests `pub const Parser = struct {…}` inside `NpmRegistry`. Rust can't
-/// nest a type inside a struct, so it lives in a sibling module and the
-/// canonical path becomes `bun_api::npm_registry::Parser`.
+/// `Parser` lives in a sibling module of `NpmRegistry`; the canonical path
+/// is `bun_api::npm_registry::Parser`.
 pub mod npm_registry {
     use bun_url::URL;
 
     pub use super::NpmRegistry;
 
-    // PORT NOTE: `Parser` stays generic over `L` (Log) / `S` (Source) so this
-    // leaf schema crate doesn't need to name `bun_logger`. The lone live body
-    // (`parse_registry_url_string_impl`) doesn't touch log/source — only the
-    // not-yet-ported `parse_registry_object` / `parse_registry` paths do, and
-    // those need `js_ast::Expr` so they belong upstream in the bunfig parser
-    // anyway.
+    // `Parser` stays generic over `L` (Log) / `S` (Source) so this leaf
+    // schema crate doesn't need to name `bun_logger`. The lone live body
+    // (`parse_registry_url_string_impl`) doesn't touch log/source — only
+    // `parse_registry_object` / `parse_registry` would, and those need
+    // `js_ast::Expr` so they belong upstream in the bunfig parser anyway.
     pub struct Parser<'a, L, S> {
         pub log: &'a mut L,
         pub source: &'a S,
@@ -79,5 +76,3 @@ pub mod npm_registry {
         }
     }
 }
-
-// ported from: src/options_types/schema.zig
diff --git a/src/ast/Cargo.toml b/src/ast/Cargo.toml
index 8ef63ef5259..279f490bb4f 100644
--- a/src/ast/Cargo.toml
+++ b/src/ast/Cargo.toml
@@ -29,4 +29,5 @@ bun_ptr.workspace = true
 bun_paths.workspace = true
 bun_collections.workspace = true
 bun_sys.workspace = true
+bun_perf.workspace = true
 bun_wyhash.workspace = true
diff --git a/src/ast/ast_memory_allocator.rs b/src/ast/ast_memory_allocator.rs
index 536eb987d20..7a8f63c25c7 100644
--- a/src/ast/ast_memory_allocator.rs
+++ b/src/ast/ast_memory_allocator.rs
@@ -7,24 +7,19 @@ use bun_alloc::ast_alloc::{self, AstAllocState};
 use crate::expr;
 use crate::stmt;
 
-// PERF(port): Zig used `std.heap.StackFallbackAllocator(@min(8192, std.heap.page_size_min))`
-// — a small inline stack buffer with heap fallback. `bun_alloc::Arena`
-// (`MimallocArena`) has no stack buffer; instead the owned arena is recycled
+// `bun_alloc::Arena` (`MimallocArena`) has no inline stack buffer with heap
+// fallback; instead the owned arena is recycled
 // per thread via `ARENA_POOL` below so the per-module callers don't pay a fresh
 // `mi_heap_new` + first-segment page faults every file. (The `AstAlloc` side
 // *does* have an inline buffer now — see `bun_alloc::ast_alloc::AstAllocState`.)
 
 // ── Thread-local arena pool ──────────────────────────────────────────────
 //
-// Zig's `ASTMemoryAllocator` was a `StackFallbackAllocator(8192, fallback)`:
-// the 8 KB stack buffer absorbed most per-module AST scratch without touching
-// the heap, and the spill went to a long-lived `fallback` arena whose pages
-// stayed resident across modules. The Rust port collapsed that to one owned
-// `MimallocArena` per `ASTMemoryAllocator`, so a fresh per-module instance
-// (`RuntimeTranspilerStore::run`, `Bun.Transpiler.*`, the dev server) paid a
-// fresh `mi_heap_new` + first-segment page faults every file, and `enter()`'s
-// reset then destroyed-and-recreated that just-created heap before it was even
-// used.
+// With one owned `MimallocArena` per `ASTMemoryAllocator`, a fresh per-module
+// instance (`RuntimeTranspilerStore::run`, `Bun.Transpiler.*`, the dev server)
+// would pay a fresh `mi_heap_new` + first-segment page faults every file, and
+// `enter()`'s reset would then destroy-and-recreate that just-created heap
+// before it was even used.
 //
 // Instead, recycle one `MimallocArena` per thread: `Drop` cleans the arena
 // (`reset()` bulk-frees this module's nodes — leaving it pristine) and parks
@@ -51,8 +46,6 @@ fn return_pooled_arena(arena: Arena) {
 }
 
 pub struct ASTMemoryAllocator {
-    // Zig fields `stack_arena: SFA` + `bump_std.mem.Allocator param` (the vtable into
-    // the SFA) collapse to a single bump arena.
     arena: Arena,
     /// When non-null, allocations route to this caller-owned arena instead of
     /// `self.arena` and `Drop`/`reset` never destroy or pool anything. Must
@@ -229,16 +222,10 @@ impl ASTMemoryAllocator {
     }
 
     pub fn enter(&mut self) -> Scope<'_> {
-        // Zig: this.stack_allocator = SFA{ .fallback_allocator = arena, .. };
-        //      this.bump_allocator = this.stack_allocator.get();
-        // The Zig spec OVERWRITES the entire SFA on every `enter()` (fresh
-        // 8 KB stack buffer + rewired fallback to the per-call arena), so any
-        // bytes bump-allocated by the previous `enter()` are released. The
-        // Rust port collapsed SFA+fallback into a single internal `Arena`
-        // owned by `self`, so the equivalent re-init is `arena.reset()` —
-        // otherwise a thread-local `ASTMemoryAllocator` reused across
-        // `RuntimeTranspilerStore::run()` calls grows unboundedly (one full
-        // AST worth of nodes per import).
+        // `enter()` must release any bytes bump-allocated by the previous
+        // `enter()`, i.e. `arena.reset()` — otherwise a thread-local
+        // `ASTMemoryAllocator` reused across `RuntimeTranspilerStore::run()`
+        // calls grows unboundedly (one full AST worth of nodes per import).
         //
         // ...but a *pristine* arena (fresh from `new()` / the thread-local
         // pool, or just `reset()`) has nothing to discard, so the
@@ -265,8 +252,6 @@ impl ASTMemoryAllocator {
     }
 
     pub fn reset(&mut self) {
-        // Zig rebuilt the SFA against the stored fallback arena; Arena::reset is equivalent.
-        // PERF(port): was stack-fallback — profile
         // Skip the `mi_heap_destroy` + `mi_heap_new` when already pristine.
         if self.arena_dirty {
             // The AST state's spill pointer targets the arena's heap; null it
@@ -352,15 +337,12 @@ impl ASTMemoryAllocator {
 
     #[inline]
     pub fn append<T>(&self, value: T) -> crate::StoreRef<T> {
-        // Zig: `this.bump_allocator.create(ValueType) catch unreachable; ptr.* = value;`
-        // bumpalo's `alloc` aborts on OOM, matching `catch unreachable`.
+        // bumpalo's `alloc` aborts on OOM.
         // SAFETY: bumpalo never returns null.
         crate::StoreRef::from_bump(self.arena().alloc(value))
     }
 
-    /// Zig: `this.stack_allocator.get()` — the `std.mem.Allocator` vtable into
-    /// the stack-fallback buffer. In the Rust port both `stack_allocator` and
-    /// `bump_allocator` collapse to the single `Arena`, so this returns it.
+    /// Returns the single `Arena` backing this allocator.
     #[inline]
     pub fn stack_allocator(&self) -> &Arena {
         self.arena()
@@ -461,8 +443,7 @@ impl<'a> Scope<'a> {
     }
 }
 
-// Zig callers write `defer ast_scope.exit()` immediately after `enter()`;
-// porting that as RAII so `let _scope = alloc.enter();` restores the previous
+// RAII: `let _scope = alloc.enter();` restores the previous
 // `Expr/Stmt.Data.Store.memory_allocator` on every return path. `exit()` is
 // idempotent (guarded by `entered`), so an explicit `.exit()` followed by Drop
 // is harmless.
@@ -471,5 +452,3 @@ impl<'a> Drop for Scope<'a> {
         self.exit();
     }
 }
-
-// ported from: src/js_parser/ast/ASTMemoryAllocator.zig
diff --git a/src/ast/ast_result.rs b/src/ast/ast_result.rs
index 644b5fd49d6..1441338beed 100644
--- a/src/ast/ast_result.rs
+++ b/src/ast/ast_result.rs
@@ -1,4 +1,4 @@
-//! `js_parser/ast/Ast.zig` — the parser-output struct.
+//! The parser-output struct.
 //!
 //! Moved down from `bun_js_parser` so `bun_js_printer` can consume it without
 //! a `bun_js_parser` dep. The previous blocker (`Target`/`ImportRecord` living
@@ -51,9 +51,8 @@ pub struct Ast<'a> {
     /// they can be manipulated efficiently without a full AST traversal
     pub import_records: ImportRecordList<'a>,
 
-    // `hashbang`/`directive` are `[]const u8` slices into source text (not
-    // freed in Zig `deinit`). `StoreStr` records them under the same
-    // lifetime-erased contract as `StoreRef`.
+    // `hashbang`/`directive` are slices into source text. `StoreStr` records
+    // them under the same lifetime-erased contract as `StoreRef`.
     pub hashbang: StoreStr,
     pub directive: Option<StoreStr>,
     pub parts: PartList<'a>,
@@ -76,7 +75,6 @@ pub struct Ast<'a> {
     pub named_exports: NamedExports,
     pub export_star_import_records: AstVec<u32>,
 
-    // arena: std.mem.Allocator,
     pub top_level_symbols_to_parts: TopLevelSymbolToParts,
 
     pub commonjs_named_exports: CommonJSNamedExports,
@@ -96,10 +94,6 @@ pub struct Ast<'a> {
     pub import_meta_ref: Ref,
 }
 
-// PORT NOTE: Zig field defaults reference named constants (`Ref.None`, `logger.Range.None`,
-// `ExportsKind.none`, `Target.browser`) whose equivalence to the Rust types' `Default::default()`
-// is unverified across crates, so spell them out here instead of `#[derive(Default)]`.
-//
 // `parts`/`symbols`/`import_records` are now `ArenaVec`s and need an allocator,
 // so `Default` no longer applies; use `Ast::empty_in(arena)`.
 impl<'a> Ast<'a> {
@@ -186,13 +180,10 @@ impl<'a> Ast<'a> {
         }
     }
 
-    // Zig `deinit` only freed `parts`, `symbols`, `import_records` via `bun.default_allocator`,
-    // and was guarded by "Do not call this if it wasn't globally allocated!".
-    // In Rust those fields own their storage and free on Drop; no explicit body needed.
-    // TODO(port): Vec<T> Drop semantics must distinguish arena-backed vs heap-backed to
-    // preserve the Zig conditional-free behavior. Revisit.
+    // `parts`/`symbols`/`import_records` are `ArenaVec`s (`BabyVec`) whose
+    // `Drop` deallocates through the allocator each instance was constructed
+    // with, so arena-vs-heap conditional-free is encoded in the type — no
+    // explicit body needed.
 }
 
 pub use crate::g::Class;
-
-// ported from: src/js_parser/ast/Ast.zig
diff --git a/src/ast/b.rs b/src/ast/b.rs
index f2d42ba501e..68d4316f2ce 100644
--- a/src/ast/b.rs
+++ b/src/ast/b.rs
@@ -3,7 +3,7 @@ use crate::base::Ref;
 use crate::binding::Binding;
 use crate::expr::Expr;
 use crate::{ExprNodeIndex, flags};
-// Re-exported so callers can spell `js_ast::b::ArrayBinding` (Zig: `B.Array.Item`).
+// Re-exported so callers can spell `js_ast::b::ArrayBinding`.
 pub use crate::ArrayBinding;
 
 /// B is for Binding! Bindings are on the left side of variable
@@ -27,8 +27,8 @@ pub use crate::ArrayBinding;
 ///     ----------------
 ///     B.Object
 /// ```
-// Zig: `union(Binding.Tag)` — tag enum lives on `Binding::Tag`.
-// PORT NOTE: arena values are referenced via `StoreRef<T>` (LIFETIMES.tsv: ARENA)
+// The tag enum lives on `Binding::Tag`.
+// Arena values are referenced via `StoreRef<T>` (LIFETIMES.tsv: ARENA)
 // rather than a threaded `&'bump mut T`.
 #[derive(Copy, Clone, bun_core::EnumTag)]
 #[enum_tag(existing = super::binding::Tag)]
@@ -74,24 +74,23 @@ pub struct Property {
     pub value: Binding,
     pub default_value: Option<Expr>,
 }
-// TODO(port): partial defaults — Zig only defaults `flags`/`default_value`; `key`/`value` have none, so no `impl Default`.
+// No `impl Default` on purpose: only `flags`/`default_value` have sensible
+// defaults; `key`/`value` do not, so every constructor must supply them.
 
 pub struct Object {
     pub properties: crate::StoreSlice<Property>,
     pub is_single_line: bool,
 }
-// Zig: `pub const Property = B.Property;` — inherent associated type alias.
-// TODO(port): inherent associated types are unstable; callers use `B::Property` directly.
-// TODO(port): partial defaults — Zig only defaults `is_single_line`; `properties` has none, so no `impl Default`.
+// No `impl Default` on purpose: only `is_single_line` has a sensible default;
+// `properties` does not, so every constructor must supply it.
 
 pub struct Array {
     pub items: crate::StoreSlice<ArrayBinding>,
     pub has_spread: bool,
     pub is_single_line: bool,
 }
-// Zig: `pub const Item = ArrayBinding;` — inherent associated type alias.
-// TODO(port): inherent associated types are unstable; callers use `ArrayBinding` directly.
-// TODO(port): partial defaults — Zig only defaults `has_spread`/`is_single_line`; `items` has none, so no `impl Default`.
+// No `impl Default` on purpose: only `has_spread`/`is_single_line` have
+// sensible defaults; `items` does not, so every constructor must supply it.
 
 #[derive(Default, Copy, Clone)]
 pub struct Missing {}
@@ -127,18 +126,16 @@ impl B {
     where
         H: bun_core::Hasher + ?Sized,
         S: crate::base::SymbolTable + ?Sized,
-        // PORT NOTE: `symbol_table: anytype` — forwarded to `Ref::get_symbol` and
+        // `symbol_table: anytype` — forwarded to `Ref::get_symbol` and
         // `Expr::Data::write_to_hasher`; bound mirrors `Expr::Data::write_to_hasher`.
     {
-        // Local mirror of `bun.writeAnyToHasher`. Zig fed anonymous tuples
-        // through `std.mem.asBytes`, but Rust tuples have *uninitialized*
-        // padding bytes (e.g. `(Tag /*u8*/, usize)` has 7 on 64-bit), so
-        // forming a `&[u8]` over them is UB. Instead we feed each scalar
-        // field individually and bound on `NoUninit` so the compiler proves
-        // every byte is initialized — same pattern as `expr::Data::write_to_hasher`.
-        // The hash is only used in-process for React Fast Refresh, so the
-        // byte-stream change vs. Zig is immaterial (and the old stream was
-        // nondeterministic anyway).
+        // Local mirror of `bun.writeAnyToHasher`. Rust tuples have
+        // *uninitialized* padding bytes (e.g. `(Tag /*u8*/, usize)` has 7 on
+        // 64-bit), so forming a `&[u8]` over them is UB. Instead we feed each
+        // scalar field individually and bound on `NoUninit` so the compiler
+        // proves every byte is initialized — same pattern as
+        // `expr::Data::write_to_hasher`. The hash is only used in-process for
+        // React Fast Refresh.
         #[inline(always)]
         fn raw<H: bun_core::Hasher + ?Sized, T: bun_core::NoUninit>(h: &mut H, v: T) {
             h.update(bun_core::bytes_of(&v));
@@ -186,5 +183,3 @@ impl B {
 type _BindingTagHost = Binding;
 
 pub use crate::g::Class;
-
-// ported from: src/js_parser/ast/B.zig
diff --git a/src/ast/base.rs b/src/ast/base.rs
index 400ceeecc92..703747c118d 100644
--- a/src/ast/base.rs
+++ b/src/ast/base.rs
@@ -5,20 +5,17 @@ use crate::symbol;
 /// In some parts of Bun, we have many different IDs pointing to different things.
 /// It's easy for them to get mixed up, so we use this type to make sure we don't.
 //
-// Zig: `packed struct(u32) { value: Int }` — single field fills the whole word,
-// so `#[repr(transparent)]` over `u32` is bit-identical. Tuple-struct shape so
-// the (many) bundler call sites that wrote `Index(n)` / `.0` keep compiling;
-// `.value()` is provided for sites that read the Zig field name.
+// `#[repr(transparent)]` over `u32`. Tuple-struct shape so the (many) bundler
+// call sites that write `Index(n)` / `.0` keep compiling; `.value()` is
+// provided for sites that prefer a named accessor.
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct Index(pub IndexInt);
 
-/// Zig: `pub const Int = u32;` (nested in `Index`)
 pub type IndexInt = u32;
 
-/// Zig `anytype` → `@truncate` adaptor for [`Index::source`]/[`Index::part`].
-/// Callers pass both `u32` and `usize`; this truncates wider inputs the way
-/// Zig's `@as(Int, @truncate(num))` does.
+/// Truncating adaptor for [`Index::source`]/[`Index::part`].
+/// Callers pass both `u32` and `usize`; wider inputs are truncated.
 pub trait IntoIndexInt {
     fn into_index_int(self) -> IndexInt;
 }
@@ -47,7 +44,6 @@ impl Index {
         self.0 = val;
     }
 
-    /// Zig field-name accessor (`idx.value`).
     #[inline]
     pub const fn value(self) -> IndexInt {
         self.0
@@ -66,9 +62,8 @@ impl Index {
     pub const BAKE_SERVER_DATA: Index = Index(1);
     pub const BAKE_CLIENT_DATA: Index = Index(2);
 
-    // Zig: `source(num: anytype) Index { .value = @truncate(num) }`
-    // `@truncate` → `as` (intentional wrap). `anytype` callers pass both `u32`
-    // and `usize`; `IntoIndexInt` covers both with truncating semantics.
+    // Callers pass both `u32` and `usize`; `IntoIndexInt` covers both with
+    // truncating (intentional wrap) semantics.
     #[inline]
     pub fn source(num: impl IntoIndexInt) -> Index {
         Index(num.into_index_int())
@@ -79,9 +74,7 @@ impl Index {
         Index(num.into_index_int())
     }
 
-    // Zig: `init(num: anytype)` — `@intCast` (checked narrow). The `@typeInfo ==
-    // .pointer` auto-deref branch is Zig-only reflection; Rust callers pass by
-    // value.
+    // Checked narrowing; callers pass by value.
     #[inline]
     pub fn init<N>(num: N) -> Index
     where
@@ -133,15 +126,9 @@ impl Default for Index {
 /// all inner arrays from all parsed files.
 pub use crate::{Ref, RefInt, RefTag};
 
-// Zig: `comptime { bun.assert(None.isEmpty()); }`
 const _: () = assert!(Ref::NONE.is_empty());
 
-// ─────────────── getSymbol `anytype` dispatch → trait ───────────────
-//
-// Zig switches on `@TypeOf(symbol_table)`:
-//   *const ArrayList(Symbol) | *ArrayList(Symbol) | []Symbol → index by
-//     `ref.innerIndex()` (parser: single flat array, source_index ignored)
-//   *Symbol.Map → `map.get(ref)` (bundler: 2D, both halves used)
+// ─────────────── getSymbol dispatch trait ───────────────
 //
 // Different parts of the bundler use different formats of the symbol table.
 // In the parser you only have one array, and .sourceIndex() is ignored.
@@ -174,5 +161,3 @@ impl Ref {
         symbol_table.get_symbol(self)
     }
 }
-
-// ported from: src/js_parser/ast/base.zig
diff --git a/src/ast/binding.rs b/src/ast/binding.rs
index 889d8bf546e..700333eb006 100644
--- a/src/ast/binding.rs
+++ b/src/ast/binding.rs
@@ -11,23 +11,20 @@ use crate::expr::{Data as ExprData, Expr};
 use crate::{ExprNodeList, flags};
 use crate::{e as E, g as G};
 
-/// Zig: `Binding.Data` is the `union(Tag)` payload. In the Rust port that
-/// union lives at `crate::b::B`; re-export it under the Zig-path name
+/// `Binding`'s payload union lives at `crate::b::B`; re-export it as `Data`
 /// so downstream crates can `use crate::binding::Data`.
 pub use crate::b::B as Data;
 
-// Zig file-as-struct: top-level fields `loc`, `data` define `Binding`.
 #[derive(Copy, Clone, Default)]
 pub struct Binding {
     pub loc: crate::Loc,
     pub data: B,
 }
 
-// Zig: `enum(u5)` — Rust has no u5; use u8 repr (values fit).
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, strum::IntoStaticStr)]
 pub enum Tag {
-    // strum serialize = Zig @tagName output (JSON/snapshot compat).
+    // strum serialize = snake_case tag names (JSON/snapshot compat).
     #[strum(serialize = "b_identifier")]
     BIdentifier,
     #[strum(serialize = "b_array")]
@@ -38,16 +35,14 @@ pub enum Tag {
     BMissing,
 }
 
-// Zig: `pub var icount: usize = 0;` — mutable global counter, never read.
 // Debug-only so release doesn't pay a contended `lock xadd` per Binding.
 #[cfg(debug_assertions)]
 pub(crate) static ICOUNT: AtomicUsize = AtomicUsize::new(0);
 
 // ──────────────────────────────────────────────────────────────────────────
-// `init` / `alloc` — Zig switched on `@TypeOf(t)` to pick the `B` variant.
-// In Rust the comptime type-switch is a pair of small traits implemented for
-// each payload type; `Binding::init` / `Binding::alloc` stay monomorphic
-// per call-site like the Zig original.
+// `init` / `alloc` — a pair of small traits implemented for each payload
+// type pick the `B` variant; `Binding::init` / `Binding::alloc` stay
+// monomorphic per call-site.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait BindingInit {
@@ -128,19 +123,15 @@ impl Binding {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// ToExpr — Zig: `fn ToExpr(comptime expr_type: type, comptime func_type: anytype) type`
-// returns a struct holding `context: *ExprType` + `arena` whose
-// `wrapIdentifier` calls the comptime `func_type`.
-//
-// Rust cannot store `*mut P<'a, const ..>` in a non-generic field nor take a
-// fn item as a const generic, so the wrapper is type-erased: `wrap` is a plain
-// fn pointer that casts the erased `ctx` back to the concrete `P` instantiation.
-// Unlike Zig's struct, the `*ExprType` context is **not** stored — it is
-// supplied at call time (`Binding::to_expr(.., ctx, ..)`) so the raw pointer's
-// Stacked-Borrows tag is a child of the *live* `&mut P` at the call site rather
-// than a stale tag captured during `prepare_for_visit_pass` (which every later
-// `&mut self` retag would invalidate). The struct is `Copy` so the recursive
-// `to_expr` can pass it by value like Zig's `wrapper: anytype`.
+// ToExpr — Rust cannot store `*mut P<'a, const ..>` in a non-generic field
+// nor take a fn item as a const generic, so the wrapper is type-erased:
+// `wrap` is a plain fn pointer that casts the erased `ctx` back to the
+// concrete `P` instantiation. The `*ExprType` context is **not** stored — it
+// is supplied at call time (`Binding::to_expr(.., ctx, ..)`) so the raw
+// pointer's Stacked-Borrows tag is a child of the *live* `&mut P` at the call
+// site rather than a stale tag captured during `prepare_for_visit_pass`
+// (which every later `&mut self` retag would invalidate). The struct is
+// `Copy` so the recursive `to_expr` can pass it by value.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Copy, Clone)]
@@ -163,11 +154,10 @@ impl ToExprWrapper {
         }
     }
 
-    /// Zig: `Context.init(context)` — captures `*ExprType` and its arena.
     /// `ExprType` is erased to `c_void`; callers (P.rs) supply a trampoline
     /// closure that casts back to `*mut P<..>` and dispatches to
     /// `P::wrap_identifier_{namespace,hoisting}`. Non-capturing closures
-    /// coerce to fn pointers, so this stays zero-cost like Zig's comptime fn.
+    /// coerce to fn pointers, so this stays zero-cost.
     /// The `*mut P` itself is passed per-call via `Binding::to_expr`.
     #[inline]
     pub fn new(arena: &Arena, wrap: fn(*mut core::ffi::c_void, crate::Loc, Ref) -> Expr) -> Self {
@@ -193,15 +183,12 @@ impl ToExprWrapper {
     }
 }
 
-/// Zig: `Binding.ToExpr(expr_type, func_type)` returned a *type*; Rust callers
-/// that want the same per-(P, func) nominal type use this alias and construct
-/// via `ToExprWrapper::new`. Kept as a type alias (not a generic struct) so
-/// `P` can store two of these without threading its own generics through.
+/// Alias for `ToExprWrapper`; construct via `ToExprWrapper::new`. Kept as a
+/// type alias (not a generic struct) so `P` can store two of these without
+/// threading its own generics through.
 pub type ToExpr = ToExprWrapper;
 
 impl Binding {
-    /// Zig: `pub fn toExpr(binding: *const Binding, wrapper: anytype) Expr`.
-    ///
     /// `ctx` is the type-erased `*mut P<..>` derived from the *caller's live*
     /// `&mut P` (e.g. `core::ptr::addr_of_mut!(*p) as *mut c_void`). Threading
     /// it per-call keeps the raw pointer's provenance under the active Unique
@@ -290,5 +277,3 @@ impl Binding {
         }
     }
 }
-
-// ported from: src/js_parser/ast/Binding.zig
diff --git a/src/ast/char_freq.rs b/src/ast/char_freq.rs
index e329705ea8e..dca51831233 100644
--- a/src/ast/char_freq.rs
+++ b/src/ast/char_freq.rs
@@ -7,18 +7,13 @@ pub(crate) struct CharAndCount {
     pub index: usize,
 }
 
-// PORT NOTE: Zig `CharAndCount.Array` was an associated type alias; inherent
-// associated types are unstable in Rust, so it's a free alias here.
 pub(crate) type CharAndCountArray = [CharAndCount; CHAR_FREQ_COUNT];
 
-// PERF(port): Zig used `@Vector(CHAR_FREQ_COUNT, i32)` for SIMD adds — profile
+// PERF: candidate for SIMD adds — profile
 type Buffer = [i32; CHAR_FREQ_COUNT];
 
 #[derive(Copy, Clone)]
 pub struct CharFreq {
-    // PORT NOTE: Zig field was `align(1)` (unaligned i32 array). Rust gives natural
-    // alignment; if the packed layout was load-bearing for an FFI/serialized struct,
-    // revisit.
     pub freqs: Buffer,
 }
 
@@ -47,8 +42,7 @@ impl CharFreq {
     }
 
     pub fn include(&mut self, other: &CharFreq) {
-        // https://zig.godbolt.org/z/Mq8eK6K9s
-        // PERF(port): Zig used @Vector SIMD add — profile
+        // PERF: candidate for SIMD add — profile
         for (l, r) in self.freqs.iter_mut().zip(other.freqs.iter()) {
             *l += *r;
         }
@@ -74,16 +68,14 @@ impl CharFreq {
                 };
             }
 
-            // std.sort.pdq → Rust's sort_unstable_by (pattern-defeating quicksort).
-            // PORT NOTE: do NOT route through `CharAndCount::less_than` and map
+            // Do NOT route through `CharAndCount::less_than` and map
             // false→Greater — that comparator never returns `Equal`, which
             // violates `sort_unstable_by`'s total-order contract (Rust 1.81+
             // is permitted to panic on inconsistent comparators). `index` is
             // unique so equality is unreachable in practice, but keep the
             // comparator well-formed regardless.
             arr.sort_unstable_by(|a, b| {
-                // descending by count, then ascending by (index, char) —
-                // matches CharFreq.zig:12 `CharAndCount.lessThan`.
+                // descending by count, then ascending by (index, char).
                 b.count
                     .cmp(&a.count)
                     .then_with(|| a.index.cmp(&b.index))
@@ -108,10 +100,8 @@ impl CharFreq {
         for item in array {
             if item.char < b'0' || item.char > b'9' {
                 minifier.head.push(item.char);
-                // PERF(port): was `catch unreachable` (assume_capacity)
             }
             minifier.tail.push(item.char);
-            // PERF(port): was `catch unreachable` (assume_capacity)
         }
 
         minifier
@@ -119,10 +109,7 @@ impl CharFreq {
 }
 
 fn scan_big(out: &mut Buffer, text: &[u8], delta: i32) {
-    // https://zig.godbolt.org/z/P5dPojWGK
-    // PORT NOTE: Zig copied `out.*` into a stack local and wrote back via `defer` to
-    // avoid unaligned (`align(1)`) loads in the hot loop. We operate on `out` directly;
-    // the field is naturally aligned in Rust.
+    // The field is naturally aligned, so operate on `out` directly.
     let mut deltas: [i32; 256] = [0; 256];
 
     debug_assert!(text.len() >= SCAN_BIG_CHUNK_SIZE);
@@ -131,7 +118,7 @@ fn scan_big(out: &mut Buffer, text: &[u8], delta: i32) {
     let (chunks, remain) = text.split_at(unrolled);
 
     for chunk in chunks.chunks_exact(SCAN_BIG_CHUNK_SIZE) {
-        // PERF(port): Zig used `inline for` to unroll 32 iterations — profile
+        // PERF: candidate for unrolling — profile
         for i in 0..SCAN_BIG_CHUNK_SIZE {
             deltas[chunk[i] as usize] += delta;
         }
@@ -141,20 +128,11 @@ fn scan_big(out: &mut Buffer, text: &[u8], delta: i32) {
         deltas[c as usize] += delta;
     }
 
-    // PORT NOTE — INTENTIONAL SPEC DIVERGENCE: CharFreq.zig:64 writes
-    // `freqs[0..26].* = deltas[...]`, which *overwrites* the accumulator
-    // (`var freqs = out.*` is dead). That is an upstream bug: every ≥32-byte
-    // scan discards all prior counts, so the result is last-big-scan-wins
-    // rather than the histogram the NameMinifier expects. Zig's output is
-    // stable only because its StringHashMap iteration order is deterministic,
-    // so the *same* symbol name overwrites last on every run. The Rust
-    // `scope.members` map is RandomState-seeded, so a faithful overwrite port
-    // is nondeterministic (the observed `OV`/`OU` flap on three.js), and even
-    // a deterministic-iteration port wouldn't reproduce Zig's specific hash
-    // order. We accumulate (`+=`) instead — the algorithm's intent — which
-    // makes the freq table both correct and run-to-run stable. Minified
-    // output therefore differs from Zig by design here (three.js: 2 bytes
-    // smaller); byte-identical-vs-Zig is not a goal for this function.
+    // Accumulate (`+=`) — overwriting the accumulator instead would make
+    // every ≥32-byte scan discard all prior counts (last-big-scan-wins), and
+    // since `scope.members` is a RandomState-seeded map the result would be
+    // nondeterministic (an observed `OV`/`OU` flap on three.js). Accumulating
+    // keeps the freq table both correct and run-to-run stable.
     for i in 0..26 {
         out[i] += deltas[b'a' as usize + i];
     }
@@ -169,16 +147,15 @@ fn scan_big(out: &mut Buffer, text: &[u8], delta: i32) {
 }
 
 fn scan_small(out: &mut Buffer, text: &[u8], delta: i32) {
-    // PORT NOTE: Zig copied `out.*` into a stack local to avoid unaligned (`align(1)`)
-    // RMWs in the loop. The Rust field is naturally aligned, so operate on `out` directly
+    // The field is naturally aligned, so operate on `out` directly
     // (same treatment as `scan_big`).
     for &c in text {
         // Indices follow `NameMinifier::DEFAULT_TAIL` order
         // (`a-zA-Z0-9_$` → 0..63), matching `scan_big` which writes digits
-        // at `out[52 + i]`. The Zig original (`char_freq.zig:79`) used `53`,
-        // which shifted `'0'` to 53 and made `'9'` collide with `'_'` at 62,
-        // leaving slot 52 cold for `<32`-byte inputs and slightly skewing
-        // minified-name ranking when digits/underscores appear.
+        // at `out[52 + i]`. Starting digits at 53 instead would shift `'0'`
+        // to 53 and make `'9'` collide with `'_'` at 62, leaving slot 52 cold
+        // for `<32`-byte inputs and slightly skewing minified-name ranking
+        // when digits/underscores appear.
         let i: usize = match c {
             b'a'..=b'z' => c as usize - b'a' as usize,
             b'A'..=b'Z' => c as usize - (b'A' as usize - 26),
@@ -190,5 +167,3 @@ fn scan_small(out: &mut Buffer, text: &[u8], delta: i32) {
         out[i] += delta;
     }
 }
-
-// ported from: src/js_parser/ast/CharFreq.zig
diff --git a/src/ast/e.rs b/src/ast/e.rs
index d1d101d4fef..8b3326904a8 100644
--- a/src/ast/e.rs
+++ b/src/ast/e.rs
@@ -1,6 +1,4 @@
 //! E — expression node payloads for the JS AST.
-//!
-//! Port of `src/js_parser/ast/E.zig`.
 
 use core::cmp::Ordering;
 use core::fmt;
@@ -16,7 +14,6 @@ use bun_core::strings;
 use crate::{Expr, ExprNodeIndex, ExprNodeList, G, OptionalChain, Ref, StoreRef};
 use bun_alloc::ArenaVecExt as _;
 
-// In Zig: `const string = []const u8;`
 // AST string fields are arena-owned (bulk-freed via Store/arena reset; never
 // individually freed). `StoreStr` is `StoreRef`'s `[u8]` sibling: a thin
 // lifetime-erased pointer with safe construction (no `transmute`) and
@@ -63,9 +60,6 @@ impl Default for Array {
         }
     }
 }
-// TODO(port): Array methods call `Vec::init_capacity(bump, n)`
-// (signature mismatch: Vec takes only `n`; AST-crate variant with bump
-// arena pending) and `Expr::Data::*` deep matches. Un-gate with parser round.
 // Live subset of `Array` accessors needed by downstream crates.
 impl Array {
     pub const EMPTY: Array = Array {
@@ -77,7 +71,6 @@ impl Array {
         close_bracket_loc: crate::Loc::EMPTY,
     };
 
-    /// Zig: `pub fn push(this: *Array, arena, item) !void`.
     /// `Vec::append` uses the global arena; `_bump` is kept
     /// for call-site shape parity and the eventual bump-arena Vec.
     pub fn push(&mut self, _bump: &Bump, item: Expr) -> Result<(), AllocError> {
@@ -98,14 +91,13 @@ impl Array {
         estimated_count: usize,
     ) -> Result<ExprNodeList, AllocError> {
         // This over-allocates a little but it's fine
-        // PERF(port): Zig allocated in arena; this Vec uses the global arena.
-        // `Expr.data` is an enum (validity invariant), so the Zig
-        // `expandToCapacity` + index-walk pattern would form `&mut [Expr]`
+        // `Expr.data` is an enum (validity invariant), so an
+        // expand-to-capacity + index-walk pattern would form `&mut [Expr]`
         // over invalid bit patterns. Push into reserved capacity instead —
         // same allocation profile (one upfront `with_capacity`), no uninit.
         let mut out: ExprNodeList =
             ExprNodeList::init_capacity(estimated_count + self.items.len_u32() as usize);
-        // PORT NOTE: reshaped for borrowck — iterate items via index so the &mut
+        // Reshaped for borrowck — iterate items via index so the &mut
         // borrow of `out` does not overlap a shared borrow of `self`.
         let items_len = self.items.len_u32() as usize;
         for idx in 0..items_len {
@@ -134,8 +126,7 @@ impl Array {
         Ok(out)
     }
 
-    // `pub const toJS = @import("../../js_parser_jsc/expr_jsc.zig").arrayToJS;` — deleted per
-    // PORTING.md (jsc extension trait lives in `js_parser_jsc` crate).
+    // `toJS` lives in the `js_parser_jsc` crate's extension trait.
 
     /// Assumes each item in the array is a string
     pub fn alphabetize_strings(&mut self) {
@@ -265,11 +256,11 @@ pub enum Special {
     HotData,
     /// `import.meta.hot.accept` when HMR is enabled. Truthy.
     HotAccept,
-    /// Converted from `hot_accept` in P.zig's handleImportMetaHotAcceptCall
-    /// when passed strings. Printed as `hmr.acceptSpecifiers`
+    /// Converted from `hot_accept` by the parser's import.meta.hot.accept
+    /// handling when passed strings. Printed as `hmr.acceptSpecifiers`
     HotAcceptVisited,
-    /// Prints the resolved specifier string for an import record.
-    /// Zig: `resolved_specifier_string: ImportRecord.Index` (a `u32`).
+    /// Prints the resolved specifier string for an import record
+    /// (an `ImportRecord` index).
     ResolvedSpecifierString(u32),
 }
 
@@ -315,7 +306,7 @@ impl Call {
     }
 }
 
-#[repr(u8)] // Zig: enum(u2) — Rust has no u2, use u8
+#[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Default)]
 pub enum CallUnwrap {
     #[default]
@@ -327,7 +318,8 @@ pub enum CallUnwrap {
 pub struct Dot {
     // target is Node
     pub target: ExprNodeIndex,
-    // TODO(port): arena-owned slice
+    // Arena-owned slice (`StoreStr`: lifetime-erased arena ownership, bulk-freed
+    // at `Store::reset()` — see `nodes.rs` StoreStr docs).
     pub name: Str,
     pub name_loc: crate::Loc,
     pub optional_chain: Option<OptionalChain>,
@@ -355,9 +347,7 @@ impl Default for Dot {
 }
 impl Dot {
     pub fn has_same_flags_as(&self, b: &Dot) -> bool {
-        // TODO(port): Zig refers to `a.is_direct_eval` which does not exist on Dot;
-        // mirroring the (likely buggy) Zig literally would not compile. Preserving
-        // the three fields that DO exist; revisit.
+        // Compare the three flag fields that exist on Dot.
         self.optional_chain == b.optional_chain
             && self.can_be_removed_if_unused == b.can_be_removed_if_unused
             && self.call_can_be_unwrapped_if_unused == b.call_can_be_unwrapped_if_unused
@@ -385,7 +375,6 @@ pub struct Arrow {
     pub prefer_expr: bool,
 }
 impl Arrow {
-    // Zig `pub const noop_return_undefined: Arrow = .{ .body = .{ .stmts = &.{} } };`
     pub const NOOP_RETURN_UNDEFINED: Arrow = Arrow {
         args: crate::StoreSlice::EMPTY,
         body: G::FnBody {
@@ -419,9 +408,8 @@ pub struct Function {
 /// 8-byte identifier expression payload. The three side-effect flags are packed
 /// into `Ref`'s user-bit lane (bits 28..31, masked out of `Ref` identity) so
 /// this — the most common `expr::Data` variant — fits in a single word, which
-/// is what pulls `expr::Data` down to 16 bytes / `Expr` to 24. The Zig layout
-/// stores them as discrete bools (16B with padding); the Rust port exploits
-/// `noalias` + smaller nodes for the structural perf win.
+/// is what pulls `expr::Data` down to 16 bytes / `Expr` to 24 (vs. 16B with
+/// padding for discrete bools).
 ///
 /// `ref_` remains a public field so the ~100 existing `id.ref_` /
 /// `Identifier { ref_, ..Default::default() }` sites stay untouched; flag
@@ -429,8 +417,8 @@ pub struct Function {
 ///
 /// **Hazard:** assigning a fresh `Ref` to `ref_` *clears the flags*. This is
 /// fine for `visit_expr`'s `e_identifier` (sets `ref_` first then re-derives
-/// the flags), but any port of Zig `id.ref = new_ref` that expects the
-/// surrounding bool fields to survive must instead write
+/// the flags), but any `id.ref_ = new_ref` site that expects the
+/// flags to survive must instead write
 /// `id.ref_ = new_ref.with_user_bits_from(id.ref_)` — see `handle_identifier`.
 #[derive(Clone, Copy)]
 pub struct Identifier {
@@ -485,8 +473,7 @@ impl Identifier {
         self.ref_.set_user_bit(2, v);
     }
 
-    // Builder-style — replaces the Zig `.{ .ref = r, .can_be_removed = true }`
-    // struct-init pattern at the handful of sites that set flags up front.
+    // Builder-style setters for the handful of sites that set flags up front.
     #[inline]
     pub const fn with_must_keep_due_to_with_stmt(self, v: bool) -> Self {
         Self {
@@ -687,8 +674,7 @@ pub enum JSXSpecialProp {
     Any,
 }
 impl JSXSpecialProp {
-    // PERF(port): Zig used `ComptimeStringMap` (length-prefix lookup, all
-    // resolved at comptime). A `phf::Map` here would compute a full SipHash +
+    // PERF: a `phf::Map` here would compute a full SipHash +
     // index + slice compare on every JSX prop name even though the
     // overwhelming majority of inputs (`className`, `onClick`, `style`, ...)
     // miss. With only 4 keys at 3 distinct lengths, a length-gated `match`
@@ -760,7 +746,6 @@ impl Number {
                 }));
             }
 
-            // std.fmt.allocPrint(arena, "{d}", .{@as(i32, @intCast(int_value))}) catch return null
             // i32 fits in 11 bytes ("-2147483648"); format on stack then bump-copy.
             let mut stack = [0u8; 16];
             let Ok(s) = bun_core::fmt::buf_print(&mut stack, format_args!("{}", int_value as i32))
@@ -816,7 +801,6 @@ impl Number {
     }
 
     pub fn to<T: NumberCast>(self) -> T {
-        // @as(T, @intFromFloat(@min(@max(@trunc(self.value), 0), comptime @min(floatMax(f64), maxInt(T)))))
         let clamped = self.value.trunc().max(0.0).min(T::MAX_AS_F64);
         T::from_f64(clamped)
     }
@@ -824,7 +808,7 @@ impl Number {
     // `toJS` alias deleted — lives in `js_parser_jsc` extension trait.
 }
 
-/// Helper trait for `Number::to<T>()` — replaces Zig's `comptime T: type` param.
+/// Helper trait for `Number::to<T>()`.
 pub trait NumberCast: Copy {
     const MAX_AS_F64: f64;
     fn from_f64(v: f64) -> Self;
@@ -843,7 +827,8 @@ macro_rules! impl_number_cast {
 impl_number_cast!(u16, u32, u64, usize);
 
 pub struct BigInt {
-    // TODO(port): arena-owned slice
+    // Arena-owned slice (`StoreStr`: lifetime-erased arena ownership, bulk-freed
+    // at `Store::reset()` — see `nodes.rs` StoreStr docs).
     pub value: Str,
 }
 impl BigInt {
@@ -877,8 +862,7 @@ impl Default for Object {
 /// used in TOML parser to merge properties.
 ///
 /// Node types are lifetime-free, so `next` is a raw `*mut Rope`
-/// into the bump arena (Zig: `next: ?*Rope`). Segments are bulk-freed at
-/// arena reset.
+/// into the bump arena. Segments are bulk-freed at arena reset.
 pub struct Rope {
     pub head: Expr,
     pub next: *mut Rope,
@@ -911,7 +895,7 @@ impl Rope {
     #[inline]
     pub fn next_ref<'a>(&self) -> Option<&'a Rope> {
         // SAFETY: `next` is either null or a bump-arena allocation valid until
-        // arena reset (Zig: `?*Rope`). Read-only borrow; no `&mut` alias is
+        // arena reset. Read-only borrow; no `&mut` alias is
         // outstanding at any caller (the chain is fully built before walking).
         unsafe { self.next.cast_const().as_ref() }
     }
@@ -1012,7 +996,7 @@ impl Object {
     }
 
     /// Walks `rope` segments, creating nested objects as needed, and returns
-    /// the leaf `E.Object` expression (Zig: `getOrPutObject`).
+    /// the leaf `E.Object` expression.
     pub fn get_or_put_object(&mut self, rope: &Rope, _bump: &Bump) -> Result<Expr, SetError> {
         let head_key = match rope.head.data.e_string() {
             Some(s) => s.data,
@@ -1082,8 +1066,7 @@ impl Object {
         if self.has_property(&head_key) {
             return Err(SetError::Clobber);
         }
-        // Zig takes `*const Object` here and mutates through Vec's interior pointer;
-        // in Rust we require `&mut self` so the borrow checker tracks the write.
+        // `&mut self` so the borrow checker tracks the write.
         VecExt::append(
             &mut self.properties,
             G::Property {
@@ -1303,8 +1286,7 @@ fn package_json_sort_is_less_than(lhs: &G::Property, rhs: &G::Property) -> Order
 
     match lhs_key_size.cmp(&rhs_key_size) {
         Ordering::Equal => {
-            // PORT NOTE: Zig `cmpStringsAsc` is `std.mem.order(u8, a, b) == .lt`; lifted to
-            // a full `Ordering` so this is usable with `sort_by`.
+            // Full `Ordering` so this is usable with `sort_by`.
             let a = lhs
                 .key
                 .as_ref()
@@ -1356,7 +1338,8 @@ pub struct EString {
     // A version of this where `utf8` and `value` are stored in a packed union, with len as a single u32 was attempted.
     // It did not improve benchmarks. Neither did converting this from a heap-allocated type to a stack-allocated type.
     // TODO: change this to *const anyopaque and change all uses to either .slice8() or .slice16()
-    // TODO(port): arena-owned slice
+    // Arena-owned slice (`StoreStr`: lifetime-erased arena ownership, bulk-freed
+    // at `Store::reset()` — see `nodes.rs` StoreStr docs).
     pub data: Str,
     pub prefer_template: bool,
 
@@ -1368,7 +1351,7 @@ pub struct EString {
     pub rope_len: u32,
     pub is_utf16: bool,
 }
-// Export under the Zig name `String` as well; `EString` avoids colliding with bun_core::String.
+// Also exported as `String`; `EString` avoids colliding with bun_core::String.
 pub use EString as String;
 
 impl Default for EString {
@@ -1438,9 +1421,9 @@ impl EString {
         }
     }
     /// Construct from a UTF-16 slice (arena-owned). The `data` slice's `.len()`
-    /// stores the **u16 element count** (not byte count) — Zig:
-    /// `@ptrCast(value.ptr)[0..value.len]`. `slice16()` and friends rely on
-    /// this. The pointer is reinterpreted to `*const u8` for storage only.
+    /// stores the **u16 element count** (not byte count); `slice16()` and
+    /// friends rely on this. The pointer is reinterpreted to `*const u8` for
+    /// storage only.
     pub fn init_utf16(data: &[u16]) -> Self {
         // `Str::new` only records `(ptr, len)`; we want the original `*const u16`
         // (reinterpreted as bytes) and the **u16 element count**. Safe-cast the
@@ -1462,8 +1445,8 @@ impl EString {
         if strings::first_non_ascii(utf8).is_none() {
             Self::init(utf8)
         } else {
-            // PERF(port): Zig allocated directly in arena; here we transcode to a
-            // heap Vec then copy into the bump arena — profile.
+            // PERF: transcodes to a heap Vec then copies into the bump
+            // arena — profile.
             let utf16 = strings::to_utf16_alloc_for_real(utf8, false, false).expect("unreachable"); // fail_if_invalid=false → never errors
             let arena_slice: &mut [u16] = bump.alloc_slice_copy(&utf16);
             Self::init_utf16(arena_slice)
@@ -1505,13 +1488,13 @@ impl EString {
         self.len() > 0
     }
 
-    /// Zig `slice8()` alias used by some downstream callers as `.utf8()`.
+    /// Alias for `slice8()` used by some downstream callers.
     #[inline]
     pub fn utf8(&self) -> &[u8] {
         self.slice8()
     }
 
-    /// Zig: `slice(arena)` — flatten any rope and return UTF-8 bytes.
+    /// Flatten any rope and return UTF-8 bytes.
     /// Resolves the rope into the bump arena, then transcodes if UTF-16.
     pub fn slice<'b>(&mut self, bump: &'b Bump) -> &'b [u8] {
         self.resolve_rope_if_needed(bump);
@@ -1569,13 +1552,12 @@ impl EString {
         self.next = None;
     }
 
-    /// Zig `string(arena)` — return UTF-8 bytes, transcoding if UTF-16.
-    /// The transcode allocates via the global arena then copies into
-    /// `bump` (Zig used the passed arena directly).
+    /// Return UTF-8 bytes, transcoding if UTF-16.
+    /// The transcode allocates via the global arena then copies into `bump`.
     pub fn string<'b>(&self, bump: &'b Bump) -> Result<&'b [u8], AllocError> {
         if self.is_utf8() {
-            // `self.data` is arena-owned with the same lifetime as `bump`
-            // (Zig invariant); StoreStr re-borrows under that contract.
+            // `self.data` is arena-owned with the same lifetime as `bump`;
+            // StoreStr re-borrows under that contract.
             Ok(self.data.slice())
         } else {
             let v = strings::to_utf8_alloc(self.slice16());
@@ -1664,7 +1646,7 @@ impl EString {
         Some(self.slice16().len() as u32)
     }
 
-    // Zig `eql(comptime _t: type, other: anytype)` — split by operand type.
+    // `eql`, split by operand type.
     pub fn eql_string(&self, other: &EString) -> bool {
         if self.is_utf8() {
             if other.is_utf8() {
@@ -1689,8 +1671,7 @@ impl EString {
 
     /// Shallow field-wise copy. `EString` is structurally `Copy` (slice ref +
     /// `Option<NonNull>` rope links + scalars) but does not derive it to keep
-    /// rope-ownership intent explicit; Zig sites that did `.* = other.*` use
-    /// this instead.
+    /// rope-ownership intent explicit; use this for field-wise copies.
     #[inline]
     pub fn shallow_clone(&self) -> EString {
         EString {
@@ -1714,7 +1695,7 @@ impl EString {
         }
     }
 
-    /// Zig `E.String.push` — link `other` onto this string's rope tail.
+    /// Link `other` onto this string's rope tail.
     ///
     /// `other` MUST be Store/arena-allocated (callers pass
     /// `Expr::init(EString, ...).data.e_string_mut()` or a freshly
@@ -1732,8 +1713,7 @@ impl EString {
         self.rope_len += other.rope_len;
 
         // Caller contract — `other` lives in the AST Store/arena and outlives
-        // the next reset; capturing its address as a `StoreRef` is the Zig
-        // `*E.String` semantics.
+        // the next reset, so capturing its address as a `StoreRef` is sound.
         let other_ref = StoreRef::from_bump(other);
         if self.next.is_none() {
             self.next = Some(other_ref);
@@ -1784,8 +1764,7 @@ fn array_sorter_is_less_than(lhs: &Expr, rhs: &Expr) -> Ordering {
 
 impl EString {
     pub fn string_z<'b>(&self, bump: &'b Bump) -> Result<&'b bun_core::ZStr, AllocError> {
-        // Zig: `if (self.isUTF8()) self.data else strings.toUTF8AllocZ(...)`, NUL-terminated.
-        // Port: copy into the bump arena with a trailing NUL and wrap as `ZStr`.
+        // Copy into the bump arena with a trailing NUL and wrap as `ZStr`.
         let bytes: &[u8] = if self.is_utf8() {
             &self.data
         } else {
@@ -1851,7 +1830,7 @@ pub struct TemplatePart {
 
 pub struct Template {
     pub tag: Option<ExprNodeIndex>,
-    /// Arena-owned mutable slice (Zig: `[]TemplatePart`). Stored as a
+    /// Arena-owned mutable slice. Stored as a
     /// `StoreSlice` so writers (`substitute_single_use_symbol_in_expr`, the
     /// visit pass, `foldStringAddition`) retain mutable provenance. Use
     /// `parts()` / `parts_mut()` for ergonomic access; never null.
@@ -1891,7 +1870,7 @@ impl TemplateContents {
 }
 
 impl TemplateContents {
-    /// Field-wise copy (Zig: `var part = part.*`). `EString` is structurally
+    /// Field-wise copy. `EString` is structurally
     /// `Copy` but does not derive it; use `shallow_clone` for the cooked arm.
     #[inline]
     pub(crate) fn shallow_clone(&self) -> TemplateContents {
@@ -1909,8 +1888,8 @@ impl Template {
             || (matches!(self.head, TemplateContents::Cooked(_)) && !self.head.cooked().is_utf8())
         {
             // we only fold utf-8/ascii for now
-            // `self` is Store/arena-allocated (Zig: `*Template`); capturing its
-            // address as a `StoreRef` mirrors `.{ .e_template = self }`.
+            // `self` is Store/arena-allocated, so capturing its address as a
+            // `StoreRef` is sound.
             return Expr {
                 data: crate::expr::Data::ETemplate(StoreRef::from_bump(self)),
                 loc,
@@ -1927,7 +1906,7 @@ impl Template {
             bun_alloc::ArenaVec::<TemplatePart>::with_capacity_in(self.parts().len(), bump);
         let mut head = Expr::init(core::mem::take(self.head.cooked_mut()), loc);
         for part_src in self.parts() {
-            // Zig `var part = part.*` — field-wise copy (TemplatePart is not `Copy` only
+            // Field-wise copy (TemplatePart is not `Copy` only
             // because `EString` does not derive it; all fields are structurally `Copy`).
             let mut part = TemplatePart {
                 value: part_src.value,
@@ -2048,12 +2027,10 @@ impl Template {
                             );
                         }
                     } else {
-                        // PERF(port): was appendAssumeCapacity — profile
                         parts.push(part);
                     }
                 }
             } else {
-                // PERF(port): was appendAssumeCapacity — profile
                 parts.push(part);
             }
         }
@@ -2068,7 +2045,7 @@ impl Template {
         }
 
         // Arena-owned mutable slice; `into_bump_slice_mut()` preserves write
-        // provenance for downstream mutators (Zig: `parts.items`).
+        // provenance for downstream mutators.
         Expr::init(
             Template {
                 tag: None,
@@ -2086,7 +2063,8 @@ impl Template {
 }
 
 pub struct RegExp {
-    // TODO(port): arena-owned slice
+    // Arena-owned slice (`StoreStr`: lifetime-erased arena ownership, bulk-freed
+    // at `Store::reset()` — see `nodes.rs` StoreStr docs).
     pub value: Str,
 
     /// This exists for JavaScript bindings
@@ -2172,7 +2150,8 @@ pub struct RequireResolveString {
 
 pub struct InlinedEnum {
     pub value: ExprNodeIndex,
-    // TODO(port): arena-owned slice
+    // Arena-owned slice (`StoreStr`: lifetime-erased arena ownership, bulk-freed
+    // at `Store::reset()` — see `nodes.rs` StoreStr docs).
     pub comment: Str,
 }
 
@@ -2196,7 +2175,6 @@ impl Import {
     }
 
     pub fn import_record_loader(&self) -> Option<crate::Loader> {
-        // This logic is duplicated in js_printer.zig fn parsePath()
         let crate::ExprData::EObject(obj) = &self.options.data else {
             return None;
         };
@@ -2228,5 +2206,3 @@ impl Import {
 }
 
 pub use G::Class;
-
-// ported from: src/js_parser/ast/E.zig
diff --git a/src/ast/expr.rs b/src/ast/expr.rs
index f0980358545..be0f049a8b2 100644
--- a/src/ast/expr.rs
+++ b/src/ast/expr.rs
@@ -1,5 +1,3 @@
-//! Port of `src/js_parser/ast/Expr.zig`.
-//!
 //! AST crate: arena-allocated nodes (`*mut E::*`) live in `Data::Store`
 //! (a typed slab) and are bulk-freed by `Store::reset()`. `Expr` and
 //! `Data` carry the arena lifetime.
@@ -14,8 +12,8 @@ use bun_core::{self};
 
 use crate::{DebugOnlyDisabler, E, G, Op, Ref, S, Stmt};
 use bun_alloc::ArenaVecExt as _;
-// Re-export so downstream crates can name `ast::expr::StoreRef` (the Zig path
-// was `Expr.Data.Store` / `*E.Foo`; some callers route through `expr::`).
+// Re-export so downstream crates can name `ast::expr::StoreRef` (some callers
+// route through `expr::`).
 pub use crate::StoreRef;
 
 use crate::StoreStr as Str;
@@ -93,7 +91,7 @@ impl Expr {
         }
     }
 
-    /// Zig: `Expr.Data.Store.reset()`. Associated wrapper so downstream crates
+    /// Associated wrapper so downstream crates
     /// can call `crate::Expr::data_store_reset()` without naming the
     /// thread-local Store module path.
     #[inline]
@@ -101,22 +99,23 @@ impl Expr {
         data::Store::reset();
     }
 
-    /// Zig: `Expr.Data.Store.create()`.
+    /// Initializes the thread-local expression-data `Store` for the current
+    /// thread; counterpart of `data_store_reset()`.
     #[inline]
     pub fn data_store_create() {
         data::Store::create();
     }
 
-    /// Zig: `Expr.Data.Store.assert()` — debug-only re-entrancy guard.
+    /// Debug-only "Store must be init'd" guard. The re-entrancy `Disabler`
+    /// check lives in `Store::append`.
     #[inline]
     pub fn data_store_assert() {
-        crate::DebugOnlyDisabler::<Expr>::assert();
+        data::Store::assert();
     }
 }
 
 impl Expr {
     pub fn clone_in(&self, bump: &Bump) -> Result<Expr, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Expr {
             loc: self.loc,
             data: Data::clone_in(self.data, bump)?,
@@ -136,7 +135,6 @@ impl Expr {
     }
 
     pub fn wrap_in_arrow(this: Expr, bump: &Bump) -> Result<Expr, bun_core::Error> {
-        // TODO(port): narrow error set
         let stmts: &mut [Stmt] = bump.alloc_slice_fill_with(1, |_| {
             Stmt::alloc(S::Return { value: Some(this) }, this.loc)
         });
@@ -153,7 +151,7 @@ impl Expr {
         ))
     }
 
-    // `Expr::fromBlob` (Zig) is JSC-tier — it parses JSON via `bun_parsers` and
+    // `Expr::fromBlob` is JSC-tier — it parses JSON via `bun_parsers` and
     // reads `jsc::webcore::Blob`. Lives at its sole call site:
     // `bun_js_parser_jsc::macro_::expr_from_blob`.
 }
@@ -194,8 +192,7 @@ impl Expr {
         matches!(self.data, Data::EString(_))
     }
 
-    /// Making this comptime bloats the binary and doesn't seem to impact
-    /// runtime performance.
+    /// Look up `name` among the properties of an object-literal expression.
     pub fn as_property(&self, name: &[u8]) -> Option<Query> {
         let Data::EObject(obj) = &self.data else {
             return None;
@@ -369,8 +366,8 @@ impl Expr {
     /// - `foo[123].bar[456].baz.qux` // etc.
     ///
     /// This is not intended for use by the transpiler, instead by pretty printing JSON.
-    // PORT NOTE: Zig passed `bun.default_allocator` to getByIndex; Rust threads the arena
-    // explicitly because get_by_index allocates an E.String slice into &Bump.
+    // The arena is threaded explicitly because get_by_index allocates an
+    // E.String slice into &Bump.
     pub fn get_path_may_be_index(&self, bump: &Bump, name: &[u8]) -> Option<Expr> {
         if name.is_empty() {
             return None;
@@ -387,7 +384,7 @@ impl Expr {
                     }
 
                     let index_str: &[u8] = &name[idx + 1..end_idx];
-                    // std.fmt.parseInt(u32, index_str, 10) — path segments are bytes, not UTF-8.
+                    // Path segments are bytes, not UTF-8.
                     let index: u32 = bun_core::parse_unsigned(index_str, 10).ok()?;
                     let rest: &[u8] = if name.len() > end_idx {
                         &name[end_idx + 1..]
@@ -568,7 +565,7 @@ impl Expr {
         }
     }
 
-    // PORT NOTE: `Query` holds `expr` by value (Copy). The iterator stores the
+    // `Query` holds `expr` by value (Copy). The iterator stores the
     // `StoreRef<E::Array>` directly (Copy, arena-backed) so no lifetime is tied
     // to a local temporary — `StoreRef::Deref` re-borrows the arena slot on use.
     pub fn get_array(&self, name: &[u8]) -> Option<ArrayIterator> {
@@ -668,7 +665,6 @@ impl Expr {
                 continue;
             }
 
-            // PERF(port): was assume_capacity
             map.insert(key, value);
         }
 
@@ -698,7 +694,7 @@ impl ArrayIterator {
     }
 }
 
-// PORT NOTE: earlier drafts of `as_array`/`is_string`/`as_utf8_string_literal`/
+// Earlier drafts of `as_array`/`is_string`/`as_utf8_string_literal`/
 // `as_string`/`as_string_cloned`/`as_bool`/`as_number` duplicated the live `&self`
 // implementations above (lines ~231-315) with worse signatures (`expr: &Expr`,
 // raw-ptr returns). Those drafts were dropped; only the methods without a live
@@ -746,7 +742,7 @@ impl Expr {
                     return Ok(Some(hash_fn(&str.data)));
                 }
                 let utf8_str = str.string(bump)?;
-                // PERF(port): was arena alloc + free; bump-allocated, freed on reset
+                // bump-allocated, freed on reset
                 Ok(Some(hash_fn(utf8_str)))
             }
             _ => Ok(None),
@@ -769,9 +765,9 @@ impl Expr {
     /// associative. For example, the "-" operator is not associative for
     /// floating-point numbers.
     //
-    // PERF(port): Zig took `comptime op: Op.Code`. `Op::Code` does not derive
-    // `ConstParamTy` (Op.rs owns the enum); pass at runtime here. Revisit once
-    // `Code` gains `ConstParamTy` — call sites are a handful of literal ops.
+    // PERF: `Op::Code` does not derive `ConstParamTy` (Op.rs owns the enum);
+    // pass at runtime here. Revisit once `Code` gains `ConstParamTy` — call
+    // sites are a handful of literal ops.
     pub fn join_with_left_associative_op(op: Op::Code, a: Expr, b: Expr) -> Expr {
         Self::join_with_left_associative_op_with_check(op, a, b, bun_core::StackCheck::init())
     }
@@ -827,9 +823,7 @@ impl Expr {
         )
     }
 
-    // PORT NOTE: Zig threaded `_: std.mem.Allocator` (unused) so the caller's
-    // arena reached `Expr.init`. The Rust port uses the thread-local
-    // `data::Store` and drops the parameter.
+    // Uses the thread-local `data::Store`, so no allocator parameter is needed.
     pub fn join_with_comma(self, b: Expr) -> Expr {
         if self.is_missing() {
             return b;
@@ -862,9 +856,8 @@ impl Expr {
         }
     }
 
-    // PORT NOTE: Zig threaded `ctx: anytype` and called `callback(ctx, ...)` on
-    // each element. Rust passes `ctx` by `&mut` so a single `&mut P` (the parser
-    // state) can be reborrowed for each callback invocation without `Copy`.
+    // `ctx` is passed by `&mut` so a single `&mut P` (the parser state) can be
+    // reborrowed for each callback invocation without `Copy`.
     pub fn join_all_with_comma_callback<C: ?Sized>(
         all: &[Expr],
         ctx: &mut C,
@@ -968,32 +961,24 @@ impl Expr {
 // Static state
 // ───────────────────────────────────────────────────────────────────────────
 
-// Zig: `pub var icount: usize = 0;` — a plain non-atomic global, never read
-// (debug counter). Kept for parity but **debug-only**: in release the
-// `lock xadd` per node was a contended cache line bouncing across the bundler
-// worker pool on every Expr allocation. Zig's increment is a non-atomic store
-// (i.e. racy garbage under threads) so a debug-gated atomic is strictly more
-// faithful than the old unconditional one.
+// Debug-only allocation counter: in release the `lock xadd` per node was a
+// contended cache line bouncing across the bundler worker pool on every Expr
+// allocation.
 #[cfg(debug_assertions)]
 pub(crate) static ICOUNT: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
 
-// PORT NOTE: Zig `expr.zig` declares `true_bool`/`false_bool`/`bool_values`
-// statics but never references them — `E.Boolean` is stored by value in
-// `Data.e_boolean` (both `allocate` and `init` arms), not as a pointer to a
-// pooled singleton. Dropped here; the comment "We don't need to dynamically
-// allocate booleans" already holds because `E::Boolean` is inline in `Data`.
+// We don't need to dynamically allocate booleans: `E::Boolean` is inline in
+// `Data`, not a pointer to a pooled singleton.
 
 // ───────────────────────────────────────────────────────────────────────────
-// Expr::allocate / Expr::init — comptime-type dispatch → trait
+// Expr construction via the IntoExprData trait
 // ───────────────────────────────────────────────────────────────────────────
 
 /// Trait implemented by every `E::*` payload type to construct an `Expr`.
-///
-/// Replaces Zig's `comptime Type: type` switch in `Expr.init` / `Expr.allocate`.
 pub trait IntoExprData: Sized {
-    /// Construct `Data` using the thread-local `Data::Store` arena (Zig: `Expr.init`).
+    /// Construct `Data` using the thread-local `Data::Store` arena.
     fn into_data_store(self) -> Data;
-    /// Construct `Data` using a caller-supplied arena (Zig: `Expr.allocate`).
+    /// Construct `Data` using a caller-supplied arena.
     /// Be careful to free the memory (or use an arena that does it for you).
     fn into_data_alloc(self, bump: &Bump) -> Data;
 }
@@ -1068,8 +1053,8 @@ impl_into_expr_data_inline! {
     RequireString => ERequireString,
 }
 
-// E::Identifier — Zig copies fields explicitly (normalization). With the
-// packed-flag layout the struct is a single `Ref`, so the copy is trivial.
+// E::Identifier — with the packed-flag layout the struct is a single `Ref`,
+// so the copy is trivial.
 impl IntoExprData for E::Identifier {
     #[inline]
     fn into_data_store(self) -> Data {
@@ -1099,8 +1084,7 @@ impl IntoExprData for E::CommonJSExportIdentifier {
     }
     #[inline]
     fn into_data_alloc(self, _bump: &Bump) -> Data {
-        // Packed layout collapses Zig's init()/allocate() distinction — `base`
-        // rides inside `ref_`, so a single-word copy carries both regardless.
+        // `base` rides inside `ref_`, so a single-word copy carries both.
         Data::ECommonjsExportIdentifier(self)
     }
 }
@@ -1129,9 +1113,8 @@ impl IntoExprData for E::EString {
     }
 }
 
-// *E.String — Zig allows passing a pointer to copy from. `EString` derives no
-// `Clone` (rope `next` ptr); Zig copies the struct bytes. Mirror with a
-// shallow field-copy.
+// &E::EString — construct from a pointer to copy from. `EString` derives no
+// `Clone` (rope `next` ptr), so this is a shallow field-copy.
 impl IntoExprData for &E::EString {
     #[inline]
     fn into_data_store(self) -> Data {
@@ -1546,9 +1529,9 @@ impl Expr {
                 // For example, "!(a < b)" is not the same as "a >= b" if a and/or b are
                 // NaN (or undefined, or null, or possibly other problem cases too).
                 //
-                // PORT: Zig captured `*E.Binary` and wrote through it; `StoreRef` is a
-                // `Copy` `NonNull` handle, so copying it out of the (immutable) `Data`
-                // and `DerefMut`-ing reaches the same arena slot.
+                // `StoreRef` is a `Copy` `NonNull` handle, so copying it out of
+                // the (immutable) `Data` and `DerefMut`-ing reaches the same
+                // arena slot.
                 match ex.op {
                     crate::OpCode::BinLooseEq => {
                         // "!(a == b)" => "a != b"
@@ -1692,8 +1675,7 @@ impl PrimitiveType {
 /// Tagged union of expression payloads. Pointer variants are arena-allocated
 /// `StoreRef<E::*>` (thin `NonNull` into `expr::data::Store` / a bump arena);
 /// inline variants are stored by value. `StoreRef` is `Copy` + `Deref`, so
-/// `Data` is `Copy` and `let Data::EBinary(b) = data; b.op` works (matching
-/// Zig's `data.e_binary.op`).
+/// `Data` is `Copy` and `let Data::EBinary(b) = data; b.op` works.
 #[derive(Clone, Copy, bun_core::EnumTag)]
 #[enum_tag(existing = Tag)]
 pub enum Data {
@@ -1756,12 +1738,10 @@ pub enum Data {
 }
 
 // ── Layout guards ─────────────────────────────────────────────────────────
-// Zig: `bun.assert_eql(@sizeOf(Data), 24)` (Expr.zig:2189). Rust packs the
-// identifier-family flags into `Ref`'s spare bits (see `E::Identifier` doc),
-// so every inline payload is ≤ 8 bytes; with the repr(Rust) discriminant
-// that rounds to 16. `Expr` = `Data` (16, align 8) + `Loc` (i32) → 20 → 24
-// after tail padding — 25% smaller than the Zig layout, which is the
-// structural noalias-shrink win this port targets.
+// The identifier-family flags are packed into `Ref`'s spare bits (see
+// `E::Identifier` doc), so every inline payload is ≤ 8 bytes; with the
+// repr(Rust) discriminant that rounds to 16. `Expr` = `Data` (16, align 8) +
+// `Loc` (i32) → 20 → 24 after tail padding.
 //
 // The `Option<Data>` assert proves Rust's niche optimization fires: the enum
 // has spare discriminant values (47 variants < 256, and every pointer variant
@@ -1789,9 +1769,9 @@ const _: () = assert!(core::mem::size_of::<E::RequireString>() <= 8);
 const _: () = assert!(core::mem::size_of::<E::NewTarget>() <= 8);
 const _: () = assert!(core::mem::size_of::<StoreRef<E::Binary>>() == core::mem::size_of::<usize>());
 
-// Zig field-style union accessors (`data.e_string`, `data.e_object`). The
-// match arms in this file use these heavily; keeping them as inherent methods
-// avoids rewriting ~25 sites. Returns `Option<StoreRef<T>>` (Copy).
+// Field-style accessors (`data.e_string()`, `data.e_object()`). The match arms
+// in this file use these heavily; keeping them as inherent methods avoids
+// rewriting ~25 sites. Returns `Option<StoreRef<T>>` (Copy).
 impl Data {
     #[inline]
     pub fn e_string(&self) -> Option<StoreRef<E::EString>> {
@@ -1845,33 +1825,32 @@ impl Data {
     pub fn as_e_string(&self) -> Option<StoreRef<E::EString>> {
         self.e_string()
     }
-    /// Zig: `data.e_array` field-access. Mirrors `e_array()`; provided under
-    /// the `as_*` name for downstream crates ported from `.e_array.*`.
+    /// Mirrors `e_array()`; provided under the `as_*` name for downstream
+    /// crates.
     #[inline]
     pub fn as_e_array(&self) -> Option<StoreRef<E::Array>> {
         self.e_array()
     }
-    /// Zig: `data.e_object` field-access. Panics if not an object — callers
-    /// gate with `is_object()` / `is_e_object()` first (mirrors Zig union
-    /// access).
+    /// Panics if not an object — callers gate with `is_object()` /
+    /// `is_e_object()` first.
     #[inline]
     pub fn as_e_object(&self) -> StoreRef<E::Object> {
         self.e_object()
             .expect("ExprData::as_e_object on non-object")
     }
-    /// Zig: `data.e_object` field-access (mutable).
+    /// Mutable counterpart of `as_e_object()`; panics if not an object.
     #[inline]
     pub fn as_e_object_mut(&mut self) -> &mut E::Object {
         self.e_object_mut()
             .expect("ExprData::as_e_object_mut on non-object")
     }
-    /// Zig: `data == .e_object`.
+    /// True if this is an `EObject`.
     #[inline]
     pub fn is_e_object(&self) -> bool {
         matches!(self, Data::EObject(_))
     }
-    /// Zig: `data.e_number` field-access. `E::Number` is an inline (non-Store)
-    /// payload, so this returns it by value.
+    /// `E::Number` is an inline (non-Store) payload, so this returns it by
+    /// value.
     #[inline]
     pub fn as_e_number(&self) -> Option<E::Number> {
         if let Data::ENumber(n) = *self {
@@ -1880,21 +1859,20 @@ impl Data {
             None
         }
     }
-    /// Zig: `data == .e_string`.
+    /// True if this is an `EString`.
     #[inline]
     pub fn is_e_string(&self) -> bool {
         matches!(self, Data::EString(_))
     }
-    /// Zig: `data == .e_number`.
+    /// True if this is an `ENumber`.
     #[inline]
     pub fn is_e_number(&self) -> bool {
         matches!(self, Data::ENumber(_))
     }
 
     // ── Remaining StoreRef<E::*> field-style accessors ──────────────────
-    // visitExpr / maybe.rs port from Zig's `data.e_dot.*` etc., which are
-    // unchecked union field reads. Rust callers `.unwrap()` (or pattern-match)
-    // — the `Option` is the cheapest sound encoding of Zig's UB-on-mismatch.
+    // Callers `.unwrap()` (or pattern-match) — the `Option` is the cheapest
+    // sound encoding of a tag-mismatch precondition.
     #[inline]
     pub fn e_unary(&self) -> Option<StoreRef<E::Unary>> {
         if let Data::EUnary(v) = *self {
@@ -2276,9 +2254,8 @@ impl Data {
         self.tag().into()
     }
 
-    // Zig: `pub fn as(data: Data, comptime tag: Tag) ?@FieldType(Data, @tagName(tag))`
-    // Rust has no field-by-tag reflection. Per-variant `as_*` accessors live
-    // alongside the enum decl above (`e_string`/`e_object`/...).
+    // Per-variant `as_*` accessors live alongside the enum decl above
+    // (`e_string`/`e_object`/...).
     pub fn as_e_identifier(&self) -> Option<E::Identifier> {
         if let Data::EIdentifier(i) = self {
             Some(*i)
@@ -2300,20 +2277,18 @@ impl Data {
 
 impl Data {
     /// Shallow clone: re-allocate the boxed payload (so the caller owns a fresh
-    /// arena slot) but don't recurse into children. Zig: `Data.clone`.
+    /// arena slot) but don't recurse into children.
     ///
-    /// PORT NOTE: the `E::*` payloads do not derive `Clone` (they hold raw arena
-    /// pointers / `Vec`). Zig copied struct bytes (`el.*`); we mirror that
-    /// with a `core::ptr::read` of the payload, which is sound because every
+    /// The `E::*` payloads do not derive `Clone` (they hold raw arena
+    /// pointers / `Vec`), so this does a `core::ptr::read` of the payload,
+    /// which is sound because every
     /// payload is `Copy`-shaped (no `Drop`, no owned heap state — `Vec`
     /// stores a raw pointer + len/cap into the arena).
     pub fn clone_in(this: Data, bump: &Bump) -> Result<Data, bun_core::Error> {
-        // TODO(port): narrow error set
         macro_rules! shallow {
             ($variant:ident, $el:expr) => {{
                 // SAFETY: `$el` is a `StoreRef<T>` deref to a live arena `T`; `T` is
-                // POD-shaped (no `Drop`). `ptr::read` performs a bitwise copy ==
-                // Zig's `el.*` struct copy.
+                // POD-shaped (no `Drop`). `ptr::read` performs a bitwise copy.
                 let copied = unsafe { core::ptr::read($el.as_ptr()) };
                 let item = bump.alloc(copied);
                 return Ok(Data::$variant(StoreRef::from_bump(item)));
@@ -2396,7 +2371,7 @@ impl Data {
                 Ok(Data::EBinary(StoreRef::from_bump(item)))
             }
             Data::EClass(el) => {
-                // `properties` is an arena-owned `StoreSlice<Property>` (Zig: `[]Property`).
+                // `properties` is an arena-owned `StoreSlice<Property>`.
                 let src_props: &[G::Property] = el.properties.slice();
                 let mut properties = bun_alloc::ArenaVec::with_capacity_in(src_props.len(), bump);
                 for prop in src_props.iter() {
@@ -2529,8 +2504,8 @@ impl Data {
                         None => None,
                     },
                     parts: el.parts,
-                    // `TemplateContents` is POD-shaped; Zig copied `el.head` by
-                    // value. `shallow_clone` is the safe field-wise copy.
+                    // `TemplateContents` is POD-shaped; `shallow_clone` is the
+                    // safe field-wise copy.
                     head: el.head.shallow_clone(),
                 });
                 Ok(Data::ETemplate(StoreRef::from_bump(item)))
@@ -2605,11 +2580,9 @@ impl Data {
     /// `hasher` should be something with `fn update(&[u8])`;
     /// symbol table is passed to serialize `Ref` as identifier names instead of nondeterministic numbers.
     ///
-    /// Port of `Expr.Data.writeToHasher`. Zig fed raw bytes of anonymous tuples
-    /// (`std.mem.asBytes(&.{a, b, c})`) — including padding, which is undefined
-    /// in both languages. The Rust port hashes each scalar individually so the
-    /// output is deterministic (this is only consumed by React Refresh signature
-    /// generation; byte-for-byte parity with Zig is not required, only stability).
+    /// Hashes each scalar individually so the output is deterministic — no
+    /// padding bytes are fed to the hasher (this is only consumed by React
+    /// Refresh signature generation; only stability is required).
     pub fn write_to_hasher<H, S>(&self, hasher: &mut H, symbol_table: &mut S)
     where
         H: bun_core::Hasher + ?Sized,
@@ -2618,8 +2591,7 @@ impl Data {
         // Local mirror of `bun.writeAnyToHasher` for padding-free POD —
         // `bun_core::write_any_to_hasher` is bound by `AsBytes` (ints only) and
         // we cannot extend that trait from this crate-file scope. `NoUninit`
-        // bound lets `bytemuck::bytes_of` view the value's bytes safely
-        // (mirrors Zig `hasher.update(std.mem.asBytes(&thing))`).
+        // bound lets `bytemuck::bytes_of` view the value's bytes safely.
         #[inline(always)]
         fn raw<H: bun_core::Hasher + ?Sized, T: bytemuck::NoUninit>(h: &mut H, v: T) {
             h.update(bytemuck::bytes_of(&v));
@@ -2689,9 +2661,7 @@ impl Data {
                 e.value.data.write_to_hasher(hasher, symbol_table);
             }
             Data::EYield(e) => {
-                // TODO(port): Zig hashed the raw bytes of `.{ e.is_star, e.value }` (the full
-                // `?Expr` optional, including loc/data pointer). Rust `Option<Expr>` layout is
-                // not byte-compatible, so we hash the discriminant here and recurse below.
+                // Hash the `Option` discriminant, then recurse into the value.
                 raw(hasher, e.is_star);
                 raw(hasher, e.value.is_some());
                 if let Some(value) = &e.value {
@@ -2724,9 +2694,7 @@ impl Data {
                 hasher.update(&e.value);
             }
             Data::EString(e) => {
-                // PORT NOTE: Zig declared `var next: ?*E.String = e;` and tested `if (next)`
-                // — i.e. it only ever hashes the *first* rope segment (the `next = current.next`
-                // store is dead). Preserved here.
+                // Only the *first* rope segment is hashed.
                 let current: &E::String = e;
                 if current.is_utf8() {
                     hasher.update(&current.data);
@@ -3148,8 +3116,8 @@ impl EqlKindT for StrictEql {
     const STRICT: bool = true;
 }
 
-/// Minimal parser surface needed by `Data::eql` — Zig wrote `p: anytype` and
-/// touched only `p.arena` + `p.module_ref`. Kept separate from
+/// Minimal parser surface needed by `Data::eql` — only the arena and the
+/// module ref are touched. Kept separate from
 /// `ast::p::ParserLike` so this file does not grow that trait (out of scope);
 /// blanket-impl'd for every `P<...>` instantiation below.
 pub trait EqlParser {
@@ -3278,8 +3246,7 @@ impl Data {
             }
             Data::EString(l) => {
                 // `StoreRef<EString>` is a Copy pointer; rebind mutably so
-                // `DerefMut` gives `&mut EString` for in-place rope flattening
-                // (Zig wrote through `*E.String` here).
+                // `DerefMut` gives `&mut EString` for in-place rope flattening.
                 let mut l = *l;
                 match right {
                     Data::EString(r) => {
@@ -3352,8 +3319,6 @@ impl Data {
 // ───────────────────────────────────────────────────────────────────────────
 
 // `new_store!` emits `pub mod expr_store { pub struct Store; ... }`.
-// Type list mirrors Zig's `Data.Store = NewStore(&.{ E.Array, ... }, 512)`
-// (Expr.zig:2550-2580).
 crate::new_store!(
     expr_store,
     [
@@ -3397,14 +3362,9 @@ pub mod data {
 pub use data::Store;
 
 // ───────────────────────────────────────────────────────────────────────────
-// StoredData / helpers
+// Helpers
 // ───────────────────────────────────────────────────────────────────────────
 
-// Zig: `pub fn StoredData(tag: Tag) type` — comptime type-level function.
-// Rust cannot return types from runtime tags. Callers should match on `Data`
-// directly.
-// TODO(port): if needed, expose as a macro mapping Tag → payload type.
-
 fn string_to_equivalent_number_value(str: &[u8]) -> f64 {
     // +"" -> 0
     if str.is_empty() {
@@ -3413,7 +3373,6 @@ fn string_to_equivalent_number_value(str: &[u8]) -> f64 {
     if !bun_core::is_all_ascii(str) {
         return f64::NAN;
     }
-    // TODO(port): move to *_sys
     unsafe extern "C" {
         // NOT `safe fn`: callee dereferences `ptr` for `len` bytes — caller must
         // guarantee the (ptr,len) pair is a valid readable range.
@@ -3424,5 +3383,3 @@ fn string_to_equivalent_number_value(str: &[u8]) -> f64 {
     // only (no mutation, no retention past return).
     unsafe { JSC__jsToNumber(str.as_ptr(), str.len()) }
 }
-
-// ported from: src/js_parser/ast/Expr.zig
diff --git a/src/ast/fold_string_addition.rs b/src/ast/fold_string_addition.rs
index a578a27ed58..5cab9429868 100644
--- a/src/ast/fold_string_addition.rs
+++ b/src/ast/fold_string_addition.rs
@@ -5,14 +5,14 @@ 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.
+// without touching E.rs.
 
 #[inline]
 fn store_append_string(s: E::EString) -> StoreRef<E::EString> {
     data::Store::append(s)
 }
 
-/// Zig `E.String.push` — link `other` onto `lhs`'s rope tail.
+/// Link `other` onto `lhs`'s rope tail.
 fn estring_push(lhs: &mut E::EString, mut other: StoreRef<E::EString>) {
     debug_assert!(lhs.is_utf8());
     debug_assert!(other.is_utf8());
@@ -41,8 +41,8 @@ fn estring_push(lhs: &mut E::EString, mut other: StoreRef<E::EString>) {
     }
 }
 
-/// Zig `E.String.cloneRopeNodes` — deep-copy the `next` chain into fresh
-/// Store nodes so mutating the result can't alias an inlined-enum's string.
+/// Deep-copy the `next` chain into fresh Store nodes so mutating the result
+/// can't alias an inlined-enum's string.
 fn clone_rope_nodes(s: &E::EString) -> E::EString {
     let mut root = s.shallow_clone();
     if let Some(first) = root.next {
@@ -111,8 +111,8 @@ fn join_strings(
     new
 }
 
-/// `std.mem.concat(arena, E.TemplatePart, &.{a, b})` — concat into the bump
-/// arena. `TemplatePart` is POD-shaped (no Drop) but not `Copy` because
+/// Concat two `TemplatePart` slices into the bump arena.
+/// `TemplatePart` is POD-shaped (no Drop) but not `Copy` because
 /// `EString` opted out; mirror `Template::fold`'s field-wise copy via
 /// `shallow_clone` instead of raw `copy_nonoverlapping`.
 fn concat_parts(
@@ -122,7 +122,7 @@ fn concat_parts(
 ) -> crate::StoreSlice<e::TemplatePart> {
     let mut v = bun_alloc::ArenaVec::<e::TemplatePart>::with_capacity_in(a.len() + b.len(), bump);
     for p in a.iter().chain(b.iter()) {
-        // Zig `var part = part.*` — field-wise copy (all fields structurally `Copy`).
+        // Field-wise copy (all fields structurally `Copy`).
         v.push(e::TemplatePart {
             value: p.value,
             tail_loc: p.tail_loc,
@@ -214,7 +214,7 @@ pub fn fold_string_addition(
                 // "'x' + `y${z}`" => "`xy${z}`"
                 if let Data::ETemplate(t) = rhs.data {
                     if t.tag.is_none() {
-                        // (intentionally empty — matches Zig)
+                        // (intentionally empty)
                     }
                 }
             }
@@ -253,7 +253,6 @@ pub fn fold_string_addition(
                                         right.get(),
                                         matches!(r.data, Data::EInlinedEnum(_)),
                                     ));
-                                    // Zig wrote `left.parts[i].tail = ...` in place.
                                     left.parts_mut()[i].tail = new_tail;
                                     return Some(lhs);
                                 }
@@ -285,7 +284,6 @@ pub fn fold_string_addition(
                                     let new_parts = if right.parts().is_empty() {
                                         left.parts
                                     } else {
-                                        // std.mem.concat → bump-allocated concat
                                         concat_parts(bump, left.parts(), right.parts())
                                     };
                                     left.parts = new_parts;
@@ -323,5 +321,3 @@ pub fn fold_string_addition(
 
     None
 }
-
-// ported from: src/js_parser/ast/foldStringAddition.zig
diff --git a/src/ast/g.rs b/src/ast/g.rs
index 9b557a9405e..c17113ef0b5 100644
--- a/src/ast/g.rs
+++ b/src/ast/g.rs
@@ -7,12 +7,12 @@ use crate::stmt::Stmt;
 use crate::ts as TypeScript;
 use crate::{ExprData, ExprNodeList, LocRef, StmtNodeList, StoreSlice, StoreStr, flags};
 
-/// Zig: `G.Fn.flags: Flags.Function.Set`. Downstream crates address the flag
-/// enum via `G::FnFlags::IsExport` etc.; re-export the enum + set type here.
+/// Downstream crates address the flag enum via `G::FnFlags::IsExport` etc.;
+/// re-export the enum + set type here.
 pub use crate::flags::Function as FnFlags;
 pub use crate::flags::FunctionSet as FnFlagsSet;
 
-// PORT NOTE: all `&'ast mut [T]` arena slices are `StoreSlice<T>` (lifetime-
+// All `&'ast mut [T]` arena slices are `StoreSlice<T>` (lifetime-
 // erased arena-slice newtype). 'ast/'bump can be threaded crate-wide later by
 // adding a `PhantomData<&'arena ()>` to `StoreSlice` in one pass.
 
@@ -22,8 +22,7 @@ pub struct Decl {
     pub value: Option<ExprNodeIndex>,
 }
 
-// Zig: `pub const List = Vec(Decl);` (nested decl) — inherent assoc types
-// are nightly; free alias.
+// Inherent assoc types are nightly; free alias.
 pub type DeclList = Vec<Decl, bun_alloc::AstAlloc>;
 
 pub struct NamespaceAlias {
@@ -155,8 +154,8 @@ pub struct Property {
     pub kind: PropertyKind,
     pub flags: flags::PropertySet,
 
-    // Arena-owned `?*ClassStaticBlock` (Zig). `StoreRef` centralises the
-    // raw-pointer deref so the accessors below stay safe.
+    // Arena-owned. `StoreRef` centralises the raw-pointer deref so the
+    // accessors below stay safe.
     pub class_static_block: Option<crate::StoreRef<ClassStaticBlock>>,
     pub ts_decorators: ExprNodeList,
     // Key is optional for spread
@@ -168,7 +167,6 @@ pub struct Property {
     pub ts_metadata: TypeScript::Metadata,
 }
 
-// Zig: nested `pub const List = Vec(Property);` — free alias.
 pub type PropertyList = Vec<Property, bun_alloc::AstAlloc>;
 
 impl Default for Property {
@@ -224,7 +222,7 @@ impl Property {
             kind: self.kind,
             flags: self.flags,
             class_static_block,
-            // Zig: `try this.ts_decorators.deepClone(arena)` — Vec<Expr> per-element deep clone.
+            // Vec<Expr> per-element deep clone.
             ts_decorators: self
                 .ts_decorators
                 .try_deep_clone_with(|e| e.deep_clone(bump))?,
@@ -241,7 +239,6 @@ impl Property {
     }
 }
 
-// Zig: `enum(u3)` — Rust has no u3, use u8
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
@@ -266,7 +263,6 @@ impl FnBody {
         bump: &bun_alloc::Arena,
         expr: ExprNodeIndex,
     ) -> core::result::Result<FnBody, bun_alloc::AllocError> {
-        // PERF(port): Zig used arena.dupe over a 1-elem array literal; bumpalo equivalent
         let stmts: &mut [Stmt] = bump.alloc_slice_fill_with(1, |_| {
             Stmt::alloc(crate::s::Return { value: Some(expr) }, expr.loc)
         });
@@ -313,7 +309,6 @@ impl Fn {
         &self,
         bump: &bun_alloc::Arena,
     ) -> core::result::Result<Fn, bun_alloc::AllocError> {
-        // PERF(port): Zig arena.alloc + per-index assign; bumpalo equivalent.
         let src_args: &[Arg] = self.args.slice();
         let args: &mut [Arg] = bump.alloc_slice_fill_default::<Arg>(src_args.len());
         for i in 0..args.len() {
@@ -363,7 +358,7 @@ impl Arg {
         bump: &bun_alloc::Arena,
     ) -> core::result::Result<Arg, bun_alloc::AllocError> {
         Ok(Arg {
-            // Zig: `try this.ts_decorators.deepClone(arena)` — Vec<Expr> per-element deep clone.
+            // Vec<Expr> per-element deep clone.
             ts_decorators: self
                 .ts_decorators
                 .try_deep_clone_with(|e| e.deep_clone(bump))?,
@@ -377,5 +372,3 @@ impl Arg {
         })
     }
 }
-
-// ported from: src/js_parser/ast/G.zig
diff --git a/src/ast/import_record.rs b/src/ast/import_record.rs
index 859236a64fe..95c4d2950ae 100644
--- a/src/ast/import_record.rs
+++ b/src/ast/import_record.rs
@@ -1,4 +1,4 @@
-//! `src/options_types/import_record.zig` — `ImportRecord` and friends.
+//! `ImportRecord` and friends.
 //!
 //! Lives in `bun_ast` so `Ast` (which holds `Vec<ImportRecord>`) is
 //! self-contained and `bun_js_printer` can drop its `bun_js_parser` dep.
@@ -9,13 +9,12 @@ use crate::Range;
 use bun_paths::fs::Path;
 
 // Re-exported here (canonical at crate root) so callers that path through
-// `bun_ast::import_record::{ImportKind, Index, Loader}` — mirroring the Zig
-// `import_record.zig` namespace — keep resolving.
+// `bun_ast::import_record::{ImportKind, Index, Loader}` keep resolving.
 pub use crate::{ImportKind, Index, Loader};
 
 pub struct ImportRecord {
     pub range: Range,
-    // TODO(port): lifetime — `bun_paths::fs::Path<'a>` borrows resolver-owned
+    // TODO: lifetime — `bun_paths::fs::Path<'a>` borrows resolver-owned
     // strings. Uses 'static (PORTING.md: no struct lifetime params).
     pub path: Path<'static>,
     pub kind: ImportKind,
@@ -24,18 +23,16 @@ pub struct ImportRecord {
 
     pub source_index: Index,
 
-    /// `js_printer::printBundledImport` reads this. The Zig field was removed
-    /// from `ImportRecord` but the printer body referencing it is dead (never
-    /// analysed by Zig's lazy compilation). Kept here so the eagerly-compiled
-    /// Rust port of that body type-checks; always 0 in practice.
-    // TODO(port): delete once `printBundledImport` is confirmed dead and removed.
+    /// Dead field: the only reader (`js_printer`'s `print_bundled_import`)
+    /// has been deleted. Always 0. Remove together with the `module_id: 0` initializers
+    /// in the parser/bundler/css constructors when those files are next touched.
     pub module_id: u32,
 
     /// The original import specifier as written in source code (e.g., "./foo.js").
     /// This is preserved before resolution overwrites `path` with the resolved path.
     /// Used for metafile generation.
-    // TODO(port): lifetime — Zig `[]const u8` defaulting to "", never freed in this file.
-    // Likely a borrow into parser-owned source text; using &'static [u8] as a placeholder.
+    // TODO: lifetime — likely a borrow into parser-owned source text; using
+    // &'static [u8] as a placeholder.
     pub original_path: &'static [u8],
 
     /// Pack all boolean flags into 2 bytes to reduce padding overhead.
@@ -155,8 +152,6 @@ pub enum PrintMode {
     NapiModule,
 }
 
-// NOTE: no `impl Default for ImportRecord` — Zig gives `range`, `path`, `kind` no defaults,
-// so `.{}` is invalid there. Construction sites must supply required fields explicitly
+// NOTE: no `impl Default for ImportRecord` — `range`, `path`, `kind` have no
+// sensible defaults. Construction sites must supply required fields explicitly
 // (struct-update or a `new(range, path, kind)` helper).
-
-// ported from: src/options_types/import_record.zig
diff --git a/src/ast/known_global.rs b/src/ast/known_global.rs
index d50ac3bdd05..f7e718347e9 100644
--- a/src/ast/known_global.rs
+++ b/src/ast/known_global.rs
@@ -30,10 +30,7 @@ pub enum KnownGlobal {
     RegExp,
 }
 
-// `pub const map = bun.ComptimeEnumMap(KnownGlobal);`
-//
-// PERF(port): Zig's `ComptimeEnumMap` lowers to a comptime-generated switch.
-// An earlier port used `phf::Map<&[u8], _>`, which on every probe computes a 128-bit
+// PERF: an earlier draft used `phf::Map<&[u8], _>`, which on every probe computes a 128-bit
 // SipHash of the name, two modular reductions, a bounds check, and a final
 // slice compare. `minify_global_constructor` calls this for every `new Ident`
 // expression in the input, and the overwhelming majority of probes are
@@ -112,8 +109,7 @@ impl KnownGlobal {
         js_ast::Expr::init(call, loc)
     }
 
-    // PORT NOTE: `_bump` is kept for call-site shape parity with the Zig
-    // `std.mem.Allocator` arg. The `Vec` uses the global arena.
+    // `_bump` is unused; the `Vec` uses the global arena.
     #[inline(never)]
     pub fn minify_global_constructor(
         _bump: &Bump,
@@ -251,7 +247,7 @@ impl KnownGlobal {
                                     let arg_loc = arg.loc;
                                     let mut list = e.args.move_to_list_managed();
                                     list.clear();
-                                    // PERF(port): was bun.handleOom(appendNTimes) — Vec::resize aborts on OOM
+                                    // Vec::resize aborts on OOM
                                     list.resize(
                                         val as usize,
                                         js_ast::Expr {
@@ -550,5 +546,3 @@ mod tests {
         }
     }
 }
-
-// ported from: src/js_parser/ast/KnownGlobal.zig
diff --git a/src/ast/lexer_log.rs b/src/ast/lexer_log.rs
index 29c52666b9c..7346a5ee2ad 100644
--- a/src/ast/lexer_log.rs
+++ b/src/ast/lexer_log.rs
@@ -3,9 +3,8 @@
 //! js_parser, json, and toml lexers each carried a near-identical 50-line block
 //! of `{syntax_error, add_error, add_range_error, add_default_error,
 //! add_syntax_error}` that gate on `is_log_disabled`, dedup against
-//! `prev_error_loc`, push into `Log`, then record the loc. Zig has two copies
-//! (the comptime-generic `NewLexer` covers JS+JSON, toml is hand-duplicated);
-//! Rust grew a third when json was split out. This trait collapses all three.
+//! `prev_error_loc`, push into `Log`, then record the loc. This trait
+//! collapses all three.
 //!
 //! The trait carries a `'s` lifetime so `source()` can hand back the lexer's
 //! stored `&'s Source` *without* borrowing `self` — that is what lets the
diff --git a/src/ast/lexer_tables.rs b/src/ast/lexer_tables.rs
index a7a8487593a..0d4f57158c1 100644
--- a/src/ast/lexer_tables.rs
+++ b/src/ast/lexer_tables.rs
@@ -166,8 +166,8 @@ impl T {
 /// The `N <= 8` branch routes through a `u64` and widens with `as u128` so the
 /// upper half is the *literal* `0` rather than a stack-buffer read — LLVM
 /// InstCombine then narrows the resulting `icmp eq i128 (zext %lo), C` back to
-/// a single `i64` compare. This is the codegen Zig's `ComptimeStringMap` emits
-/// (`mov (%rsi),%rax; movabs $imm,%rcx; cmp %rcx,%rax`). Matching on
+/// a single `i64` compare (`mov (%rsi),%rax; movabs $imm,%rcx; cmp %rcx,%rax`).
+/// Matching on
 /// `&[u8; N]` directly does **not** get this: rustc lowers array patterns to a
 /// per-byte `cmpb`+`jne` decision tree (8 branches for `b"function"`), which
 /// is what the previous revision of `by_len!` produced.
@@ -202,8 +202,8 @@ const fn kw_pack<const N: usize>(arr: &[u8; N]) -> u128 {
 ///
 /// Replaces the `phf::Map` lookup for `KEYWORDS` (which hashes through
 /// SipHash13 and showed up as ~4% self-time under `phf_shared::hash` in
-/// `perf record` on the three.js bundle). Mirrors Zig's `ComptimeStringMap`
-/// strategy: bucket by length, then load the candidate once as a wide integer
+/// `perf record` on the three.js bundle). Strategy: bucket by length, then
+/// load the candidate once as a wide integer
 /// and compare against const-folded immediates — one `cmp` per candidate, no
 /// hash, no bounds checks, no `memcmp`, no per-byte ladder.
 ///
@@ -441,7 +441,7 @@ pub fn is_type_script_accessibility_modifier(s: &[u8]) -> bool {
 
 /// `.rodata` `[&[u8]; T::COUNT]` indexed by [`T`] discriminant. Replaces an
 /// earlier `LazyLock<EnumMap<T, _>>` so lookup is a plain array index with
-/// zero init code (matches Zig `std.EnumArray`).
+/// zero init code.
 #[repr(transparent)]
 pub struct TokenEnumType(pub [&'static [u8]; <T as Enum>::LENGTH]);
 
@@ -454,7 +454,6 @@ impl core::ops::Index<T> for TokenEnumType {
 }
 
 impl TokenEnumType {
-    /// Zig: `tokenToString.get(token)`.
     #[inline]
     pub fn get(&self, t: T) -> &'static [u8] {
         self.0[t as usize]
@@ -897,8 +896,6 @@ pub static JSX_ENTITY: phf::Map<&'static [u8], CodePoint> = phf_map! {
     b"zwnj" => 0x200C,
 };
 
-// ported from: src/js_parser/lexer_tables.zig
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -985,8 +982,7 @@ pub fn is_identifier_continue(codepoint: i32) -> bool {
 pub use bun_core::identifier::{is_identifier, is_identifier_utf16};
 
 pub fn is_latin1_identifier<B: AsRef<[u8]>>(name: B) -> bool {
-    // Zig `isLatin1Identifier(comptime Buffer, name)` is generic over `[]const u8`
-    // and `[]const u16`; the u16 instantiation is [`is_latin1_identifier_u16`].
+    // The UTF-16 counterpart is [`is_latin1_identifier_u16`].
     let name = name.as_ref();
     if name.is_empty() {
         return false;
@@ -1009,9 +1005,8 @@ pub fn is_latin1_identifier<B: AsRef<[u8]>>(name: B) -> bool {
     true
 }
 
-/// `JSLexer.isLatin1Identifier(comptime []const u16, name)` — UTF-16 overload
-/// of [`is_latin1_identifier`]. Walks code units exactly as the Zig generic
-/// does (no narrowing/alloc): any unit `> 0xFF` fails the predicate, otherwise
+/// UTF-16 overload of [`is_latin1_identifier`]. Walks code units directly
+/// (no narrowing/alloc): any unit `> 0xFF` fails the predicate, otherwise
 /// the byte rules apply.
 pub fn is_latin1_identifier_u16(name: &[u16]) -> bool {
     if name.is_empty() {
diff --git a/src/ast/lib.rs b/src/ast/lib.rs
index b2104c4a98b..82c672e5c41 100644
--- a/src/ast/lib.rs
+++ b/src/ast/lib.rs
@@ -2,20 +2,16 @@
 // `#[thread_local]` for the per-node-allocation hot-path TLS
 // (`DATA_STORE_OVERRIDE`, `Expr/Stmt::data::Store::{INSTANCE,
 // MEMORY_ALLOCATOR, DISABLE_RESET}`, `store_ast_alloc_heap::ARENA`): bare
-// `__thread` slot like Zig's `threadlocal var`, vs the `thread_local!`
+// `__thread` slot, vs the `thread_local!`
 // macro's `LocalKey` wrapper. All are `Cell<*mut _>` / `Cell<bool>` (no
 // destructor, const init).
 #![feature(thread_local)]
-//! Port of `src/logger/logger.zig`.
-//!
-//! TODO(port): OWNERSHIP — almost every `[]const u8` field in this module has
-//! mixed/ambiguous ownership in the Zig original (see the comment on
-//! `Location::deinit`: "don't really know what's safe to deinit here!"). Strings
-//! are sometimes literals, sometimes `allocator.dupe` results, sometimes slices
-//! into `Source.contents` or a `StringBuilder` arena. They are kept as
-//! `&'static [u8]` to mirror the Zig `[]const u8` shape without lifetime params;
-//! a real ownership story (likely `bun_core::String` or a `'source` lifetime
-//! threaded through `Location`/`Data`/`Msg`) is still needed.
+//! TODO: OWNERSHIP — almost every byte-slice field in this module has
+//! mixed/ambiguous ownership. Strings are sometimes literals, sometimes heap
+//! copies, sometimes slices into `Source.contents` or a `StringBuilder` arena.
+//! They are kept as `&'static [u8]` to avoid lifetime params; a real ownership
+//! story (likely `bun_core::String` or a `'source` lifetime threaded through
+//! `Location`/`Data`/`Msg`) is still needed.
 
 use core::fmt;
 use std::borrow::Cow;
@@ -24,7 +20,7 @@ use std::borrow::Cow;
 // infallible (`Vec::push` / `io::Write` on `Vec<u8>` cannot fail in Rust).
 use bun_core::Output;
 
-// TODO(port): swap to `bun_core::StringBuilder` once `clone_with_builder` is
+// TODO: swap to `bun_core::StringBuilder` once `clone_with_builder` is
 // reshaped to use `append_raw` (canonical's `append` borrows `&mut self`, which
 // breaks the `'static` slice pass-through this stub fakes).
 #[derive(Default)]
@@ -39,8 +35,7 @@ impl StringBuilder {
     pub fn allocate(&mut self) {}
 }
 
-// Variants mirror src/options_types/import_record.zig:1-25 exactly
-// (discriminants are wire-stable for serialization).
+// Discriminants are wire-stable for serialization.
 #[repr(u8)]
 #[derive(
     Clone, Copy, PartialEq, Eq, Hash, Debug, Default, enum_map::Enum, strum::IntoStaticStr,
@@ -83,9 +78,8 @@ pub enum ImportKind {
     Internal = 11,
 }
 
-// E0015: EnumMap indexing isn't const; Zig's `comptime brk: { ... }` initializer
-// is folded into match arms inside label()/error_label() below — same lookup
-// table, zero runtime init (PORTING.md §Concurrency: prefer no-lock over OnceLock
+// E0015: EnumMap indexing isn't const; the lookup table is folded into match
+// arms inside label()/error_label() below — zero runtime init (PORTING.md §Concurrency: prefer no-lock over OnceLock
 // when the data is pure const).
 //
 // If these are changed, make sure to update
@@ -147,10 +141,9 @@ impl ImportKind {
 
 // ───────────────────────────────────────────────────────────────────────────
 // Ref / Symbol
-// Zig: src/js_parser/ast/{base,Symbol,G}.zig + js_parser.zig (ImportItemStatus).
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Tag bits of `Ref` (Zig: anonymous `enum(u2)` field).
+/// Tag bits of `Ref`.
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
@@ -163,14 +156,11 @@ pub enum RefTag {
 
 /// Packed-u64 symbol reference: `{inner_index: u28, user: u3, tag: u2, source_index: u31}`.
 ///
-/// Layout matches `src/js_parser/ast/base.zig:Ref` LSB-first packing for the
-/// `tag`/`source_index` fields so `as_u64()` hashes identically to the Zig
-/// original for all normally-constructed refs (user bits = 0). The Rust port
-/// steals 3 bits from `inner_index` (Zig u31 → u28, max 268M symbols/file —
+/// LSB-first packing for the `tag`/`source_index` fields, with 3 bits stolen
+/// from `inner_index` (31 → 28 bits, max 268M symbols/file —
 /// three.js peaks at ~50K) so that `E::Identifier` / `E::ImportIdentifier` /
 /// `E::CommonJSExportIdentifier` can pack their boolean side-flags inline,
-/// shrinking `expr::Data` from 24→16 bytes and `Expr` from 32→24. This is the
-/// structural noalias-shrink advantage Rust has over the Zig layout: the
+/// shrinking `expr::Data` from 24→16 bytes and `Expr` from 32→24. The
 /// rarely-set flags (`with`-stmt guard, known-pure-global hints) ride in
 /// otherwise-dead bits instead of forcing 8 bytes of struct padding on every
 /// identifier node.
@@ -185,12 +175,12 @@ pub enum RefTag {
 #[derive(Clone, Copy)]
 pub struct Ref(u64);
 
-/// Zig `Ref.Int = u31`; we mask to 31 bits for `source_index`, 28 for `inner_index`.
+/// We mask to 31 bits for `source_index`, 28 for `inner_index`.
 pub type RefInt = u32;
 
 impl Ref {
     const INNER_MASK: u64 = (1u64 << 31) - 1;
-    /// `inner_index` width — Zig u31, narrowed to u28 to free 3 user bits.
+    /// `inner_index` width — 28 bits, leaving 3 user bits.
     /// `debug_assert!` in `pack()` catches any source large enough to overflow
     /// (would require >268M symbols or a >268MB source-contents-slice offset).
     const INNER_BITS: u64 = (1u64 << 28) - 1;
@@ -306,7 +296,6 @@ impl Ref {
     }
     #[inline]
     pub fn hash64(self) -> u64 {
-        // Zig: `bun.hash(&@as([8]u8, @bitCast(key.asU64())))` — wyhash of the 8 bytes.
         bun_wyhash::hash(&self.as_u64().to_ne_bytes())
     }
 
@@ -346,9 +335,8 @@ impl Ref {
     }
     /// Replace the identity bits with those of `self` while keeping `src`'s
     /// user-bit lane. Used by `handle_identifier`'s `id_clone.ref_ = result.ref`
-    /// port — in Zig the flags are separate struct fields and survive the ref
-    /// assignment; here they ride in `ref_` and would be silently zeroed by a
-    /// whole-word write.
+    /// assignment — the flags ride in `ref_` and would otherwise be silently
+    /// zeroed by a whole-word write.
     #[inline]
     pub const fn with_user_bits_from(self, src: Ref) -> Ref {
         Ref((self.0 & !Self::USER_BITS_MASK) | (src.0 & Self::USER_BITS_MASK))
@@ -412,10 +400,10 @@ impl fmt::Debug for Ref {
     }
 }
 
-// TODO(port): bun_paths must define `PathContentsPair` (TYPE_ONLY from bun_resolver::fs).
-// Local mirror so init_file / init_recycled_file resolve until paths' move-in lands.
+// Local mirror of `bun_resolver::fs`'s path+contents pair (canonical home would
+// be `bun_paths`); defined here so init_file / init_recycled_file resolve.
 // `pub` so `bun_bundler::Transpiler::parse_maybe` can construct it for
-// `Source::init_recycled_file` (transpiler.zig:852).
+// `Source::init_recycled_file`.
 /// A [`Source`]'s path paired with its raw bytes (used by virtual-module
 /// injection: `BundleV2`'s `additional_files`, `Bun.build` inputs).
 #[derive(Clone, Copy)]
@@ -423,21 +411,19 @@ pub struct PathContentsPair {
     pub path: bun_paths::fs::Path<'static>,
     pub contents: &'static [u8],
 }
-// TODO(port): bun_schema::api — `to_api` methods gated behind .
 
-// In Zig: `const string = []const u8;`
 type Str = &'static [u8];
-// TODO(port): lifetime — see module-level note. `Str` is a stand-in for the Zig
-// `[]const u8` struct-field pattern; TODO(port): replace with the real type.
+// `Str` is a lifetime-erased byte-slice alias; see the module-level OWNERSHIP
+// note for the real ownership story.
 
 // ───────────────────────────────────────────────────────────────────────────
-// api — hand-ported slice of `bun.schema.api` (src/options_types/schema.zig
-// :2295–2509) consumed by `Kind/Location/Data/Msg/Log::to_api`. The full
+// api — hand-written slice of `bun.schema.api` consumed by
+// `Kind/Location/Data/Msg/Log::to_api`. The full
 // peechy → .rs codegen (`bun_api`) will supersede this; field shapes are kept
 // faithful so the generated diff stays reviewable. Lives here (not `bun_api`)
 // ───────────────────────────────────────────────────────────────────────────
 pub mod api {
-    /// schema.zig:2295 `MessageLevel` (u32 enum, 1-based; `_none` = 0).
+    /// `MessageLevel` — u32 enum, 1-based; `None` = 0.
     #[repr(u32)]
     #[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
     pub enum MessageLevel {
@@ -450,7 +436,6 @@ pub mod api {
         Debug = 5,
     }
 
-    /// schema.zig:2319 `Location`.
     #[derive(Clone, Default, Debug)]
     pub struct Location {
         pub file: Vec<u8>,
@@ -461,21 +446,18 @@ pub mod api {
         pub offset: u32,
     }
 
-    /// schema.zig:2360 `MessageData`.
     #[derive(Clone, Default, Debug)]
     pub struct MessageData {
         pub text: Option<Vec<u8>>,
         pub location: Option<Location>,
     }
 
-    /// schema.zig:2403 `MessageMeta`.
     #[derive(Clone, Default, Debug)]
     pub struct MessageMeta {
         pub resolve: Option<Vec<u8>>,
         pub build: Option<bool>,
     }
 
-    /// schema.zig:2446 `Message`.
     #[derive(Clone, Default, Debug)]
     pub struct Message {
         pub level: MessageLevel,
@@ -484,7 +466,6 @@ pub mod api {
         pub on: MessageMeta,
     }
 
-    /// schema.zig:2477 `Log`.
     #[derive(Clone, Default, Debug)]
     pub struct Log {
         pub warnings: u32,
@@ -495,8 +476,9 @@ pub mod api {
 
 /// `[]const u8` parameter shim — accepts `&str` / `&[u8]` (any lifetime)
 /// and erases to the crate-wide `Str` (`&'static [u8]`) lie so callers in either
-/// string flavour compile against the same Zig-shaped signatures.
-/// TODO(port): lifetime — remove with `Str` once `'source` is threaded through.
+/// string flavour compile against the same signatures.
+/// Removable together with `Str` once a `'source` lifetime is threaded through
+/// (see the module-level OWNERSHIP note).
 pub trait IntoStr {
     fn into_str(self) -> Str;
 }
@@ -658,8 +640,6 @@ impl Kind {
 // Loc
 // ───────────────────────────────────────────────────────────────────────────
 
-// Do not mark these as packed
-// https://github.com/ziglang/zig/issues/15715
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Loc {
     pub start: i32,
@@ -679,7 +659,6 @@ impl Loc {
         if self.start == -1 { None } else { Some(self) }
     }
 
-    // Zig: `pub const toUsize = i;`
     #[inline]
     pub fn to_usize(self) -> usize {
         self.i()
@@ -712,9 +691,9 @@ pub struct Location {
     // - 4-byte fields last: i32
     // This eliminates padding between differently-sized fields.
     //
-    // PORT NOTE: `file` / `line_text` are `Cow` (not `Str`) because
-    // `Location::clone()` must deep-dupe them (Zig: `allocator.dupe(u8, ..)`,
-    // logger.zig:113) so a `BuildMessage`/`ResolveMessage` that outlives the
+    // `file` / `line_text` are `Cow` (not `Str`) because
+    // `Location::clone()` must deep-dupe them so a
+    // `BuildMessage`/`ResolveMessage` that outlives the
     // `Source.contents` it borrowed from doesn't read poisoned memory. The
     // borrowed arm covers the common case where the slice points into
     // arena-owned source text.
@@ -738,13 +717,12 @@ pub struct Location {
     pub column: i32,
 }
 
-// PORT NOTE: NOT `#[derive(Clone)]`. `file` / `line_text` are
+// NOT `#[derive(Clone)]`. `file` / `line_text` are
 // `Cow<'static, [u8]>` whose `Borrowed` arm may carry a lifetime-erased view
 // into `Source.contents` (see `init_or_null`, `css_parser.rs`, `error.rs`,
 // `JSBundler.rs`). The derived `Cow::clone` would re-borrow that pointer, so a
 // `BuildMessage` cloned via `Option<Location>::clone()` / `Vec<Data>::clone()`
-// could outlive the source buffer and read poisoned memory. Mirror the Zig
-// `Location.clone` (`allocator.dupe`, logger.zig:113) for the trait impl too —
+// could outlive the source buffer and read poisoned memory. Instead,
 // every `Clone` of a `Location` deep-dupes its borrowed bytes.
 impl Clone for Location {
     fn clone(&self) -> Self {
@@ -794,16 +772,14 @@ impl Location {
     }
 
     pub fn clone(&self) -> Location {
-        // Zig (logger.zig:113): `allocator.dupe(u8, this.file)` /
-        // `allocator.dupe(u8, this.line_text.?)` — the duped bytes outlive the
-        // original `Source.contents`. The trait `Clone` impl above does the
-        // deep-dupe; this inherent shim forwards to it.
+        // The trait `Clone` impl above does the deep-dupe (so the duped bytes
+        // outlive the original `Source.contents`); this inherent shim forwards
+        // to it.
         <Self as Clone>::clone(self)
     }
 
     pub fn clone_with_builder(&self, _string_builder: &mut StringBuilder) -> Location {
-        // PORT NOTE: Zig's `string_builder.append` copies into a buffer owned
-        // by the destination `Log`'s allocator (StringBuilder.zig). The local
+        // The local
         // `StringBuilder` stub above is a no-op that returns its input, so a
         // `Cow::Borrowed(append(s))` would alias `self`'s storage and dangle
         // after `self.msgs.clear()` in `append_to_with_recycled`. Deep-copy
@@ -831,9 +807,7 @@ impl Location {
         }
     }
 
-    // don't really know what's safe to deinit here!
-    // Zig: `pub fn deinit(_: *Location, _: std.mem.Allocator) void {}`
-    // → no Drop impl needed.
+    // No Drop impl needed.
 
     pub fn init(
         file: Str,
@@ -906,14 +880,12 @@ impl Location {
                 } else {
                     1
                 },
-                // PORT NOTE: Zig borrows `source.contents` here and relies on the
-                // arena outliving the `Log` (transpiler.zig:853 — `entry.contents`
-                // is arena-allocated and never explicitly freed on `return null`).
-                // Rust's `source_backing` in `Transpiler::parse_*` is RAII and
+                // `source_backing` in `Transpiler::parse_*` is RAII and
                 // drops on the parse-error path *before* `process_fetch_log`
                 // clones the `Msg` into a `BuildMessage`, so own the bytes here
-                // instead. `full_line` is bounded (≤ ~120 bytes) and only
-                // materialized on diagnostic paths.
+                // instead of borrowing `source.contents`. `full_line` is
+                // bounded (≤ ~120 bytes) and only materialized on diagnostic
+                // paths.
                 line_text: Some(Cow::Owned(bun_core::trim_left(full_line, b"\n\r").to_vec())),
                 offset: usize::try_from(r.loc.start.max(0)).expect("int cast"),
             });
@@ -951,10 +923,8 @@ impl Data {
         cost
     }
 
-    // Zig `deinit` frees `text` and calls `location.deinit()` (no-op).
-    // `text` is `Cow<'static, [u8]>`: `Owned` frees on `Drop` (matches Zig
-    // `allocator.free(d.text)`), `Borrowed` is a `&'static` literal — nothing to
-    // free. No explicit `Drop` body needed.
+    // `text` is `Cow<'static, [u8]>`: `Owned` frees on `Drop`, `Borrowed` is a
+    // `&'static` literal — nothing to free. No explicit `Drop` body needed.
 
     pub fn clone_line_text(&self, should: bool) -> Data {
         if !should || self.location.is_none() || self.location.as_ref().unwrap().line_text.is_none()
@@ -962,7 +932,6 @@ impl Data {
             return self.clone();
         }
 
-        // Zig (logger.zig:217): `allocator.dupe(u8, this.location.?.line_text.?)`.
         let new_line_text = self
             .location
             .as_ref()
@@ -982,7 +951,6 @@ impl Data {
     pub fn clone(&self) -> Data {
         Data {
             text: if !self.text.is_empty() {
-                // Zig (logger.zig:231): `try allocator.dupe(u8, this.text)`.
                 // `Cow::clone` only deep-copies the `Owned` arm; force the dupe
                 // so a `Borrowed` `text` (rare today, but the type permits it)
                 // can't alias recycled storage in the cloned `Msg`.
@@ -997,8 +965,7 @@ impl Data {
     pub fn clone_with_builder(&self, builder: &mut StringBuilder) -> Data {
         Data {
             text: if !self.text.is_empty() {
-                // Zig: `builder.append(this.text)` copies into the destination
-                // `Log`'s arena (StringBuilder.zig). The local `StringBuilder`
+                // The local `StringBuilder`
                 // is a no-op stub (returns its input), so a bare `Cow::clone`
                 // would leave a `Borrowed` arm aliasing `self`'s storage and
                 // dangle after `self.msgs.clear()` in
@@ -1040,9 +1007,8 @@ impl Data {
         }
 
         // Local wrapper around `bun_core::pretty_fmt!` so the const-generic
-        // `ENABLE_ANSI_COLORS` selects the right comptime template at each call
+        // `ENABLE_ANSI_COLORS` selects the right compile-time template at each call
         // site (the macro pattern-matches a literal `true`/`false` token).
-        // PERF(port): was comptime bool dispatch — profile.
         macro_rules! pretty_write {
             ($fmt:literal $(, $arg:expr)* $(,)?) => {
                 if ENABLE_ANSI_COLORS {
@@ -1079,7 +1045,6 @@ impl Data {
                     if location.line > -1 {
                         let bold = matches!(kind, Kind::Err | Kind::Warn);
                         // bold the line number for error but dim for the attached note
-                        // PERF(port): was comptime bool dispatch on `bold` — profile
                         if bold {
                             pretty_write!("<b>{} | <r>", location.line)?;
                         } else {
@@ -1150,20 +1115,6 @@ impl Data {
                 } else if location.line > -1 {
                     pretty_write!("<d>:<r><yellow>{}<r>", location.line)?;
                 }
-
-                if cfg!(debug_assertions) {
-                    // TODO(port): the Zig gates this on
-                    // `std.mem.indexOf(u8, @typeName(@TypeOf(to)), "fs.file") != null` —
-                    // i.e. comptime reflection on the writer's type name to detect
-                    // a real file writer (vs Bun.inspect). No Rust equivalent;
-                    // TODO(port): plumb an explicit flag.
-                    if false
-                        && Output::ENABLE_ANSI_COLORS_STDERR
-                            .load(core::sync::atomic::Ordering::Relaxed)
-                    {
-                        pretty_write!(" <d>byte={}<r>", location.offset)?;
-                    }
-                }
             }
         }
 
@@ -1171,7 +1122,6 @@ impl Data {
     }
 }
 
-// Helper: Zig `to.splatByteAll(b, n)`
 fn write_n_bytes(to: &mut impl fmt::Write, b: u8, n: usize) -> fmt::Result {
     for _ in 0..n {
         to.write_char(b as char)?;
@@ -1183,7 +1133,6 @@ fn write_n_bytes(to: &mut impl fmt::Write, b: u8, n: usize) -> fmt::Result {
 // BabyString
 // ───────────────────────────────────────────────────────────────────────────
 
-// Zig: `packed struct(u32) { offset: u16, len: u16 }`
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct BabyString(u32);
@@ -1191,7 +1140,7 @@ pub struct BabyString(u32);
 impl BabyString {
     #[inline]
     pub const fn new(offset: u16, len: u16) -> Self {
-        // Zig packed-struct field order is LSB-first: offset = low 16, len = high 16.
+        // LSB-first packing: offset = low 16 bits, len = high 16.
         BabyString((offset as u32) | ((len as u32) << 16))
     }
 
@@ -1206,8 +1155,13 @@ impl BabyString {
     }
 
     pub fn r#in(parent: &[u8], text: &[u8]) -> BabyString {
-        // TODO(port): bun_core::index_of missing — inline bstr fallback.
-        let off = bstr::ByteSlice::find(parent, text).expect("unreachable");
+        // bun_core::strings::index_of deliberately returns None for an empty
+        // needle, but an empty `text` reaches this path via resolve errors for
+        // `import ""`, so short-circuit it here to offset 0.
+        if text.is_empty() {
+            return BabyString::new(0, 0);
+        }
+        let off = bun_core::strings::index_of(parent, text).expect("unreachable");
         BabyString::new(off as u16, text.len() as u16) // @truncate
     }
 
@@ -1251,8 +1205,7 @@ impl Msg {
         cost
     }
 
-    // Zig: `pub const fromJS/toJS = @import("../logger_jsc/...")`
-    // → deleted; `to_js`/`from_js` live as extension-trait methods in `bun_logger_jsc`.
+    // `to_js`/`from_js` live as extension-trait methods in `bun_logger_jsc`.
 
     pub fn count(&self, builder: &mut StringBuilder) {
         self.data.count(builder);
@@ -1285,8 +1238,6 @@ impl Msg {
                     for (i, note) in self.notes.iter().enumerate() {
                         notes[i] = note.clone_with_builder(builder);
                     }
-                    // TODO(port): lifetime — Zig returns a sub-slice of the
-                    // caller-provided `notes` buffer; with `Box<[Data]>` we copy.
                     break 'brk notes[0..self.notes.len()].to_vec().into_boxed_slice();
                 }
             } else {
@@ -1309,10 +1260,9 @@ impl Msg {
                 resolve: if let Metadata::Resolve(r) = &self.metadata {
                     Some(r.specifier.slice(&self.data.text).to_vec())
                 } else {
-                    // Zig (logger.zig:457): `else ""` — coerces to a NON-NULL
-                    // `?[]const u8`, so peechy `MessageMeta.encode` still emits
-                    // field-ID 1 with an empty string. `None` would skip the
-                    // field entirely on the wire.
+                    // NON-NULL empty string so peechy `MessageMeta.encode`
+                    // still emits field-ID 1; `None` would skip the field
+                    // entirely on the wire.
                     Some(Vec::new())
                 },
                 build: Some(matches!(self.metadata, Metadata::Build)),
@@ -1321,8 +1271,6 @@ impl Msg {
     }
 
     pub fn to_api_from_list(list: &[Msg]) -> Box<[api::Message]> {
-        // PORT NOTE: Zig took `comptime ListType: type, list: ListType` and read
-        // `list.items`; collapsed to `&[Msg]`.
         let mut out_list = Vec::with_capacity(list.len());
         for item in list {
             out_list.push(item.to_api());
@@ -1330,8 +1278,7 @@ impl Msg {
         out_list.into_boxed_slice()
     }
 
-    // Zig `deinit` frees `data`, each `note`, and `notes` slice — all handled by Drop
-    // once ownership is real. No explicit Drop body needed beyond field drops.
+    // No explicit Drop body needed beyond field drops.
 
     pub fn write_format<const ENABLE_ANSI_COLORS: bool>(
         &self,
@@ -1359,7 +1306,6 @@ impl Msg {
     }
 
     pub fn format_writer(&self, writer: &mut impl fmt::Write) -> fmt::Result {
-        // PORT NOTE: Zig had an unused `comptime _: bool` param; dropped.
         if let Some(location) = &self.data.location {
             write!(
                 writer,
@@ -1424,8 +1370,6 @@ impl Default for MetadataResolve {
 // Range
 // ───────────────────────────────────────────────────────────────────────────
 
-// Do not mark these as packed
-// https://github.com/ziglang/zig/issues/15715
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct Range {
     pub loc: Loc,
@@ -1442,31 +1386,78 @@ impl Default for Range {
 }
 
 /// Was `bun_js_parser::lexer::rangeOfIdentifier`.
-/// Moved into logger to break logger→js_parser. Mirrors lexer.zig:3113-3148.
-/// TODO(port): full Unicode `isIdentifierStart/Continue` tables — currently
-/// ASCII + `#`/`\` only; non-ASCII identifiers get a Range with len up to the
-/// first non-ASCII byte (only affects error-highlight width, not correctness).
+/// Moved into logger to break logger→js_parser. Includes the full Unicode
+/// `isIdentifierStart/Continue` tables (via `bun_core::identifier`) and
+/// `\u{...}` escape skipping.
 pub fn range_of_identifier(contents: &[u8], loc: Loc) -> Range {
     if loc.start < 0 || (loc.start as usize) >= contents.len() {
         return Range::NONE;
     }
     let text = &contents[loc.start as usize..];
-    let mut i = 0usize;
-    if text.first() == Some(&b'#') {
-        i = 1;
+    let mut r = Range { loc, len: 0 };
+    if text.is_empty() {
+        return r;
+    }
+    let end = text.len() as u32;
+
+    let iter = bun_core::strings::CodepointIterator::init(text);
+    let mut cursor = bun_core::strings::Cursor::default();
+    if !iter.next(&mut cursor) {
+        return r;
     }
-    let is_start = |c: u8| c.is_ascii_alphabetic() || c == b'_' || c == b'$' || c == b'\\';
-    let is_cont = |c: u8| c.is_ascii_alphanumeric() || c == b'_' || c == b'$' || c == b'\\';
-    if i < text.len() && is_start(text[i]) {
-        i += 1;
-        while i < text.len() && is_cont(text[i]) {
-            i += 1;
+
+    // Handle private names
+    if cursor.c == '#' as i32 {
+        if !iter.next(&mut cursor) {
+            r.len = 1;
+            return r;
         }
     }
-    Range {
-        loc,
-        len: i32::try_from(i).expect("int cast"),
+
+    // Skip over bracketed unicode escapes such as "\u{10000}". The cursor is
+    // positioned on a `\`; advance `cursor.i` one past the closing `}` and
+    // zero `cursor.width` so the next decode starts exactly there (the manual
+    // advance already consumed the backslash's width — leaving `width` set
+    // would skip the byte after `}`).
+    let skip_bracketed_escape = |cursor: &mut bun_core::strings::Cursor| {
+        if cursor.i + 2 < end
+            && text[cursor.i as usize + 1] == b'u'
+            && text[cursor.i as usize + 2] == b'{'
+        {
+            cursor.i += 2;
+            while cursor.i < end {
+                if text[cursor.i as usize] == b'}' {
+                    cursor.i += 1;
+                    break;
+                }
+                cursor.i += 1;
+            }
+            cursor.width = 0;
+        }
+    };
+
+    if bun_core::identifier::is_identifier_start(cursor.c) || cursor.c == '\\' as i32 {
+        // An identifier may *start* with an escape (e.g. `\u{61}bc`); skip it
+        // here too, or the loop below reads the `u`/`{` as ordinary codepoints
+        // and truncates the range at the `{`.
+        if cursor.c == '\\' as i32 {
+            skip_bracketed_escape(&mut cursor);
+        }
+        while iter.next(&mut cursor) {
+            if cursor.c == '\\' as i32 {
+                skip_bracketed_escape(&mut cursor);
+            } else if !lexer_tables::is_identifier_continue(cursor.c) {
+                r.len = i32::try_from(cursor.i).expect("int cast");
+                return r;
+            }
+        }
+
+        // EOF inside the identifier: the cursor holds the *start* offset and
+        // width of the last codepoint read — include that codepoint.
+        r.len = i32::try_from(cursor.i + cursor.width as u32).expect("int cast");
     }
+
+    r
 }
 
 impl Range {
@@ -1501,7 +1492,7 @@ impl Range {
     }
 
     pub fn end_i(self) -> usize {
-        // std.math.lossyCast(usize, ...) — saturates negatives to 0.
+        // Saturates negatives to 0.
         (self.loc.start + self.len).max(0) as usize
     }
 }
@@ -1519,10 +1510,7 @@ pub struct Log {
     pub clone_line_text: bool,
 
     /// Owned backing storage for `Location.{file,line_text}` (and similar)
-    /// that came from transient buffers (e.g. native-plugin C strings). Zig
-    /// `log.msgs.allocator.dupe(u8, …)` allocates from the Log's allocator and
-    /// stores a raw slice in `Location` (logger.zig `Location.deinit` is a
-    /// no-op, so the bytes live as long as the Log). Rust models that as a
+    /// that came from transient buffers (e.g. native-plugin C strings): a
     /// side-vector of `Box<[u8]>` owned by the `Log`; [`Log::dupe`] returns a
     /// lifetime-erased borrow into the just-pushed box. The borrow is valid
     /// for the life of `self` because `Box<[u8]>` is heap-stable across `Vec`
@@ -1557,7 +1545,7 @@ impl Default for Log {
 }
 
 impl Log {
-    /// Port of Zig's `log.msgs.allocator.dupe(u8, s)` pattern: copy `s` into
+    /// Copy `s` into
     /// storage owned by this `Log` and return a `&'static [u8]` view. The
     /// returned slice is valid for as long as `self` lives (the box is never
     /// moved out of `owned_strings`); `'static` is a lifetime erasure matching
@@ -1596,7 +1584,6 @@ impl Level {
         (self as i8) <= (other as i8)
     }
 
-    // Zig: `pub const label: std.EnumArray(Level, string)`
     pub const LABEL: std::sync::LazyLock<enum_map::EnumMap<Level, &'static [u8]>> =
         std::sync::LazyLock::new(|| {
             enum_map::EnumMap::from_fn(|k| match k {
@@ -1608,7 +1595,6 @@ impl Level {
             })
         });
 
-    // Zig: `pub const Map = bun.ComptimeStringMap(Level, ...)`
     pub const MAP: phf::Map<&'static [u8], Level> = phf::phf_map! {
         b"verbose" => Level::Verbose,
         b"debug" => Level::Debug,
@@ -1617,11 +1603,9 @@ impl Level {
         b"error" => Level::Err,
     };
 
-    // Zig: `pub const fromJS = @import("../logger_jsc/...")`
-    // → deleted; lives in `bun_logger_jsc`.
+    // `from_js` lives in `bun_logger_jsc`.
 }
 
-// Zig: `pub var default_log_level = Level.warn;`
 // PORTING.md §Global mutable state: written by CLI startup, read by every
 // `Log::init()` (including from bundler worker threads). `AtomicCell<Level>`
 // — Acquire/Release, no `unsafe` at call sites.
@@ -1703,8 +1687,7 @@ impl Log {
         }
     }
 
-    /// Zig: `pub fn init(std.mem.Allocator param) Log` — Rust callers spell
-    /// this `Log::new()`; the allocator parameter is dropped (global allocator).
+    /// Alias of [`Log::init`].
     #[inline]
     pub fn new() -> Log {
         Log::init()
@@ -1756,8 +1739,7 @@ impl Log {
         }
     }
 
-    // Zig: `pub const toJS/toJSAggregateError/toJSArray = @import("../logger_jsc/...")`
-    // → deleted; live in `bun_logger_jsc`.
+    // `to_js`/`to_js_aggregate_error`/`to_js_array` live in `bun_logger_jsc`.
 
     pub fn clone_to(&mut self, other: &mut Log) {
         let mut notes_count: usize = 0;
@@ -1769,17 +1751,14 @@ impl Log {
         }
 
         if notes_count > 0 {
-            // TODO(port): lifetime — Zig allocates one shared `[Data; notes_count]`
-            // buffer in `other`'s allocator and re-slices each `msg.notes` into it.
-            // With `Box<[Data]>` per-Msg we instead deep-copy each notes slice.
+            // Deep-copy each notes slice (per-Msg `Box<[Data]>` ownership).
             for msg in &mut self.msgs {
                 msg.notes = msg.notes.to_vec().into_boxed_slice();
             }
         }
 
         other.msgs.extend(self.msgs.iter().map(Msg::clone));
-        // PORT NOTE: reshaped for borrowck — Zig appendSlice moves the (now
-        // re-sliced) Msgs; here we clone since `self` retains them.
+        // Clone rather than move — `self` retains its msgs.
         other.warnings += self.warnings;
         other.errors += self.errors;
     }
@@ -1814,8 +1793,8 @@ impl Log {
             let mut notes_buf = vec![Data::default(); notes_count];
             let mut note_i: usize = 0;
 
-            // PORT NOTE: reshaped for borrowck — Zig zips `self.msgs` with the
-            // tail of `other.msgs`; index instead.
+            // Index instead of zipping `self.msgs` with the tail of
+            // `other.msgs` to satisfy borrowck.
             for (k, msg) in self.msgs.iter().enumerate() {
                 let j = dest_start + k;
                 other.msgs[j] =
@@ -1850,9 +1829,8 @@ impl Log {
     }
 }
 
-// PORT NOTE: Zig `Log.deinit` only does `msgs.clearAndFree()` — field-free-only,
-// so per PORTING.md no `impl Drop` is emitted (Vec<Msg> drops automatically).
-// The mid-life semantic operation is exposed as `clear_and_free` above.
+// No `impl Drop` is needed (Vec<Msg> drops automatically). The mid-life
+// semantic operation is exposed as `clear_and_free` above.
 
 impl Log {
     #[cold]
@@ -1884,7 +1862,7 @@ impl Log {
     }
 
     /// Shared, non-generic tail for the `add*Fmt` family. The public wrappers
-    /// are `inline` and only do the per-call-site `allocPrint(fmt, args)`; the
+    /// are `inline` and only do the per-call-site formatting; the
     /// rest (counter bump, rangeData, cloneLineText, addMsg) lives here so it
     /// isn't re-stamped for every distinct format string. ~165 callers of
     /// `addErrorFmt` alone used to duplicate this body.
@@ -1929,9 +1907,8 @@ impl Log {
         err: bun_core::Error,
     ) {
         let text = alloc_print(args);
-        // TODO: fix this. this is stupid, it should be returned in allocPrint.
-        // PORT NOTE: Zig reads `args.@"0"` (first tuple element) for the
-        // specifier; with `fmt::Arguments` that's opaque, so callers must pass
+        // TODO: fix this. this is stupid, the specifier should be returned by
+        // `alloc_print`. `fmt::Arguments` is opaque, so callers must pass
         // `specifier_arg` explicitly.
         let specifier = BabyString::r#in(&text, specifier_arg);
         if IS_ERR {
@@ -1945,7 +1922,6 @@ impl Log {
                 let mut _data = self.tracked_range_data(source, r, text);
                 if let Some(loc) = &mut _data.location {
                     if let Some(_line) = loc.line_text.as_deref() {
-                        // Zig: `try log.msgs.allocator.dupe(u8, line)`.
                         loc.line_text = Some(Cow::Owned(_line.to_vec()));
                     }
                 }
@@ -1956,7 +1932,6 @@ impl Log {
         };
 
         let msg = Msg {
-            // .kind = if (comptime error_type == .err) Kind.err else Kind.warn,
             kind: if IS_ERR { Kind::Err } else { Kind::Warn },
             data,
             metadata: Metadata::Resolve(MetadataResolve {
@@ -2175,8 +2150,8 @@ impl Log {
         let data = Data {
             text: alloc_print(args),
             location: Some(Location {
-                // TODO(port): lifetime — `Location.file` borrows `Str`; thread
-                // real ownership through (see module doc).
+                // `Location.file` borrows the lifetime-erased `Str`; see the
+                // module-level OWNERSHIP note.
                 file: Cow::Borrowed(filepath),
                 line: i32::try_from(line).expect("int cast"),
                 column: i32::try_from(col).expect("int cast"),
@@ -2193,8 +2168,6 @@ impl Log {
         })
     }
 
-    // (Zig has a large commented-out `addWarningFmtLineColWithNote` here — omitted.)
-
     #[inline]
     pub fn add_range_warning_fmt(
         &mut self,
@@ -2391,8 +2364,6 @@ impl Log {
         self.warnings += 1;
         let data = self.tracked_range_data(source, r, text);
         self.add_msg(Msg {
-            // PORT NOTE: Zig has `.kind = .warning` here which doesn't exist in
-            // `Kind`; presumed dead code / typo for `.warn`.
             kind: Kind::Warn,
             data,
             notes,
@@ -2538,12 +2509,11 @@ pub struct AddErrorOptions<'a> {
 }
 
 /// Downstream-compat alias: some callers (`bunfig.rs`, `PnpmMatcher.rs`) spell
-/// the option-struct as `bun_ast::ErrorOpts { .. }` (Zig: `Log.addError*` opts
-/// param). Same layout as `AddErrorOptions`; the canonical name is kept while
-/// the Zig side still calls it `addErrorOpts`.
+/// the option-struct as `bun_ast::ErrorOpts { .. }`. Same layout as
+/// `AddErrorOptions`.
 pub type ErrorOpts<'a> = AddErrorOptions<'a>;
 
-/// Call-site helper that mirrors Zig `allocPrint`: rewrites `<red>..<r>` markup
+/// Call-site helper: rewrites `<red>..<r>` markup
 /// in the *literal* format string via `bun_core::pretty_fmt!` (compile-time),
 /// then formats. Expands to a `fmt::Arguments` so it drops in wherever a
 /// pre-built `fmt::Arguments` was previously passed to `alloc_print`.
@@ -2572,8 +2542,8 @@ macro_rules! alloc_print {
     };
 }
 
-/// `add_error_pretty!(log, source, loc, "<red>...<r>", args..)` — call-site form
-/// of Zig `addErrorFmt`: rewrites `<tag>` markup in the *literal* format string
+/// `add_error_pretty!(log, source, loc, "<red>...<r>", args..)` — call-site
+/// helper that rewrites `<tag>` markup in the *literal* format string
 /// at compile time (via `bun_core::pretty_fmt!`) before interpolation, then
 /// calls `Log::add_error_fmt`. Use this instead of
 /// `add_error_fmt(.., format_args!("<red>..."))` so markup is converted/stripped
@@ -2624,9 +2594,8 @@ macro_rules! add_warning_pretty {
 
 #[inline]
 pub fn alloc_print(args: fmt::Arguments<'_>) -> Cow<'static, [u8]> {
-    // Zig `allocPrint` runs `Output.prettyFmt(fmt, enable_ansi_colors)` at
-    // comptime over the *format-string literal only*, then interpolates args
-    // afterward — interpolated values are never inspected for `<..>` markup.
+    // Markup conversion happens over the *format-string literal only*;
+    // interpolated values are never inspected for `<..>` markup.
     // With `fmt::Arguments` the literal is opaque, so callers that need markup
     // conversion must go through `pretty_format_args!` / `alloc_print!` above
     // (which do the rewrite at the macro call site). The function form here
@@ -2636,9 +2605,8 @@ pub fn alloc_print(args: fmt::Arguments<'_>) -> Cow<'static, [u8]> {
     use std::io::Write;
     let mut v = Vec::new();
     let _ = write!(&mut v, "{}", args);
-    // Zig returns an allocator-owned slice that the Log takes ownership of via
-    // `Data.text` and frees in `Data.deinit`. `Cow::Owned` gives the same
-    // ownership: `Data` (via `Drop`) frees it.
+    // `Cow::Owned`: the `Log` takes ownership via `Data.text` and `Data`'s
+    // `Drop` frees it.
     Cow::Owned(v)
 }
 
@@ -2657,10 +2625,10 @@ pub fn usize2loc(loc: usize) -> Loc {
 pub struct Source {
     pub path: bun_paths::fs::Path<'static>,
 
-    /// PORT NOTE: `Cow` so `source_from_file` / `File::to_source_at` can hand
+    /// `Cow` so `source_from_file` / `File::to_source_at` can hand
     /// back a heap buffer without leaking (PORTING.md §Forbidden). Borrowed
-    /// arm covers the Zig `[]const u8`-field default (parser/transpiler feed
-    /// arena slices via `IntoStr`). Prefer the `.contents()` accessor at
+    /// arm covers parser/transpiler-fed
+    /// arena slices (via `IntoStr`). Prefer the `.contents()` accessor at
     /// call-sites — it derefs to `&[u8]` regardless of arm.
     pub contents: Cow<'static, [u8]>,
     pub contents_is_recycled: bool,
@@ -2668,10 +2636,9 @@ pub struct Source {
     /// Lazily-generated human-readable identifier name that is non-unique
     /// Avoid accessing this directly most of the  time
     ///
-    /// PORT NOTE: `Cow` because the cached value is produced by
-    /// `MutableString::ensure_valid_identifier` (owned `Box<[u8]>`); the Zig
-    /// freed it in `deinit`, so per PORTING.md §Forbidden this cannot be
-    /// `&'static [u8]` + leak.
+    /// `Cow` because the cached value is produced by
+    /// `MutableString::ensure_valid_identifier` (owned `Box<[u8]>`); per
+    /// PORTING.md §Forbidden this cannot be `&'static [u8]` + leak.
     pub identifier_name: Cow<'static, [u8]>,
 
     pub index: Index,
@@ -2897,8 +2864,7 @@ impl Source {
         &self.contents
     }
 
-    /// Owned copy of the source bytes. Mirrors the Zig pattern of
-    /// `allocator.dupe(u8, source.contents)` at call-sites that need to retain
+    /// Owned copy of the source bytes, for call-sites that need to retain
     /// the bytes past the `Source`'s lifetime.
     #[inline]
     pub fn contents_owned(&self) -> Vec<u8> {
@@ -2910,7 +2876,6 @@ impl Source {
     }
 
     pub fn identifier_name(&mut self) -> Result<&[u8], bun_core::Error> {
-        // TODO(port): narrow error set
         if !self.identifier_name.is_empty() {
             return Ok(&self.identifier_name);
         }
@@ -2924,8 +2889,7 @@ impl Source {
     }
 
     pub fn range_of_identifier(&self, loc: Loc) -> Range {
-        // Local impl mirrors src/js_parser/lexer.zig:range_of_identifier — scan from `loc`
-        // while bytes are JS identifier-part.
+        // Scan from `loc` while bytes are JS identifier-part.
         range_of_identifier(&self.contents, loc)
     }
 
@@ -3141,7 +3105,7 @@ pub fn range_data(source: Option<&Source>, r: Range, text: impl IntoText) -> Dat
 
 // ───────────────────────────────────────────────────────────────────────────
 // File → Source helpers — `bun_sys` (T1) cannot name `Source` (this crate),
-// so the body of `src/sys/File.zig:toSourceAt/toSource` lives here as free fns.
+// so the file→Source conversions live here as free fns.
 // ───────────────────────────────────────────────────────────────────────────
 
 #[derive(Default, Clone, Copy)]
@@ -3155,16 +3119,14 @@ pub type ToSourceOpts = ToSourceOptions;
 
 /// Read `path` (rooted at cwd) into memory and wrap it in a `Source`.
 ///
-/// MOVE_DOWN from `bun_sys::File::to_source` (T1 cannot name T2). Zig source:
-/// `src/sys/File.zig:toSource`.
+/// MOVE_DOWN from `bun_sys::File::to_source` (T1 cannot name T2).
 pub fn source_from_file(path: &bun_core::ZStr, opts: ToSourceOptions) -> bun_sys::Maybe<Source> {
     source_from_file_at(bun_sys::Fd::cwd(), path, opts)
 }
 
 /// Read `path` (relative to `dir_fd`) into memory and wrap it in a `Source`.
 ///
-/// MOVE_DOWN from `bun_sys::File::to_source_at`. Zig source:
-/// `src/sys/File.zig:toSourceAt`.
+/// MOVE_DOWN from `bun_sys::File::to_source_at` (T1 cannot name T2).
 pub(crate) fn source_from_file_at(
     dir_fd: bun_sys::Fd,
     path: &bun_core::ZStr,
@@ -3270,7 +3232,7 @@ pub use ts::{TSNamespaceMember, TSNamespaceMemberMap, TSNamespaceScope};
 pub use use_directive::UseDirective;
 
 /// `Part.{SymbolUseMap, SymbolPropertyUseMap, List}` — module-style alias so
-/// `crate::part::{SymbolUseMap, List}` resolves at the Zig nested-decl path.
+/// `crate::part::{SymbolUseMap, List}` resolves.
 pub mod part {
     pub use crate::nodes::{
         Part, PartList as List, PartSymbolPropertyUseMap as SymbolPropertyUseMap,
@@ -3324,8 +3286,6 @@ pub mod flags {
 /// Detected indentation of a [`Source`] (tab vs N-space). The JSON/TOML lexers
 /// record this so a `package.json` round-trip preserves the user's formatting;
 /// `bun_js_printer::Options.indent` consumes it. Default: 2 spaces.
-///
-/// Zig: `src/js_printer/js_printer.zig:434` `Options.Indentation`.
 #[derive(Clone, Copy)]
 pub struct Indentation {
     pub scalar: usize,
@@ -3349,28 +3309,61 @@ pub enum IndentationCharacter {
     Space,
 }
 
-// ported from: src/logger/logger.zig
-
 // ───────────────────────────────────────────────────────────────────────────
 // Store helpers — debug guards + thread-local side-arena lifecycle for the
 // AST `NewStore` slabs.
 // ───────────────────────────────────────────────────────────────────────────
 
-/// `bun.DebugOnlyDisabler(T)` — debug-build re-entrancy guard around Store
-/// access. No-op in release; in debug, asserts `!disabled`.
+/// `DebugOnlyDisabler<T>` — debug-build re-entrancy guard around Store
+/// access. No-op in release; in debug, `assert()` panics while the per-type
+/// disable count is non-zero.
+///
+/// Rust cannot declare a generic `#[thread_local]` static, so the debug
+/// build keeps one thread-local `TypeId` multiset (each `disable()`
+/// pushes `TypeId::of::<T>()`, each `enable()` pops one occurrence; the
+/// membership count is the per-type counter).
 pub struct DebugOnlyDisabler<T>(core::marker::PhantomData<T>);
-impl<T> DebugOnlyDisabler<T> {
+
+#[cfg(debug_assertions)]
+mod debug_disabler_state {
+    std::thread_local! {
+        /// Multiset of currently-disabled store types (one entry per
+        /// outstanding `disable()`); debug builds only.
+        pub(super) static DISABLED: core::cell::RefCell<Vec<core::any::TypeId>> =
+            const { core::cell::RefCell::new(Vec::new()) };
+    }
+}
+
+impl<T: 'static> DebugOnlyDisabler<T> {
     #[inline]
     pub fn assert() {
-        // TODO(port): wire to a thread-local `disabled: bool` if any caller
-        // actually toggles it; Zig sites only call `assert()`.
+        #[cfg(debug_assertions)]
+        debug_disabler_state::DISABLED.with(|d| {
+            assert!(
+                !d.borrow().contains(&core::any::TypeId::of::<T>()),
+                "[{}] called while disabled (did you forget to call enable?)",
+                core::any::type_name::<T>(),
+            );
+        });
     }
     #[inline]
-    pub fn disable() {}
+    pub fn disable() {
+        #[cfg(debug_assertions)]
+        debug_disabler_state::DISABLED.with(|d| d.borrow_mut().push(core::any::TypeId::of::<T>()));
+    }
     #[inline]
-    pub fn enable() {}
-    /// RAII scope: `disable()` now, `enable()` on drop. Replaces the Zig idiom
-    /// `Disabler.disable(); defer Disabler.enable();`.
+    pub fn enable() {
+        #[cfg(debug_assertions)]
+        debug_disabler_state::DISABLED.with(|d| {
+            let mut v = d.borrow_mut();
+            let pos = v
+                .iter()
+                .rposition(|t| *t == core::any::TypeId::of::<T>())
+                .expect("DebugOnlyDisabler::enable without matching disable");
+            v.remove(pos);
+        });
+    }
+    /// RAII scope: `disable()` now, `enable()` on drop.
     #[inline]
     pub fn scope() -> DebugOnlyDisablerScope<T> {
         Self::disable();
@@ -3380,8 +3373,8 @@ impl<T> DebugOnlyDisabler<T> {
 
 /// Guard returned by [`DebugOnlyDisabler::scope`]; re-enables on drop.
 #[must_use = "disabler is re-enabled on drop; bind to a named local"]
-pub struct DebugOnlyDisablerScope<T>(core::marker::PhantomData<T>);
-impl<T> Drop for DebugOnlyDisablerScope<T> {
+pub struct DebugOnlyDisablerScope<T: 'static>(core::marker::PhantomData<T>);
+impl<T: 'static> Drop for DebugOnlyDisablerScope<T> {
     #[inline]
     fn drop(&mut self) {
         DebugOnlyDisabler::<T>::enable();
@@ -3463,7 +3456,7 @@ pub mod store_ast_alloc_heap {
 // ── DATA_STORE_OVERRIDE ────────────────────────────────────────────────────
 // Thread-local override arena for `Expr`/`Stmt` boxed payloads.
 //
-// Zig: `Expr.Data.Store.memory_allocator` — when non-null, `Expr::init`
+// When non-null, `Expr::init`
 // allocates boxed payloads into this arena instead of the long-lived block
 // store, so a scoped caller (YAML/TOML/JSONC parse) can bulk-free the whole
 // tree by dropping the arena. Set/restored by `ASTMemoryAllocator::Scope`.
@@ -3482,8 +3475,7 @@ pub(crate) fn set_data_store_override(p: *const bun_alloc::Arena) {
 
 /// Copy `bytes` into the active AST arena so the slice shares the same
 /// lifetime as the `StoreRef`-backed `Expr` nodes that reference it
-/// (bulk-freed on Store reset). Mirrors Zig call sites that write
-/// `Expr.init(E.String, .{ .data = try allocator.dupe(u8, …) }, …)`: callers
+/// (bulk-freed on Store reset). Callers
 /// building an `EString` from a scratch buffer must intern the bytes here, not
 /// into a function-local bump, or `EString.data` dangles when that bump drops.
 /// The lifetime is erased per the `StoreStr` convention — arena ownership, not
@@ -3559,9 +3551,6 @@ impl Drop for StoreResetGuard {
 /// no-op once the slab (or an `ASTMemoryAllocator` override) is installed,
 /// so no `Once` guard is needed (and a process-global `Once` would be wrong
 /// anyway: the backing `INSTANCE` is `#[thread_local]`).
-///
-/// Zig: open-coded `Expr.Data.Store.create(); Stmt.Data.Store.create();`
-/// at every CLI entry point (transpiler.zig, run_command.zig, …).
 #[inline]
 pub fn initialize_store() {
     expr::data::Store::create();
@@ -3572,8 +3561,6 @@ pub fn initialize_store() {
 /// subsequent call. Maps to `Store::begin()` (create-or-reset) on each
 /// slab, so callers that re-enter — e.g. the install pipeline parsing many
 /// `package.json`s — get a fresh arena each time without re-allocating.
-///
-/// Zig: install.zig `initializeStore()` (`if (initialized_store) reset else create`).
 #[inline]
 pub fn initialize_store_or_reset() {
     expr::data::Store::begin();
@@ -3600,6 +3587,55 @@ impl Drop for DisableStoreReset {
     }
 }
 
+#[cfg(test)]
+mod range_of_identifier_tests {
+    use super::*;
+
+    fn len_of(src: &[u8]) -> i32 {
+        range_of_identifier(src, Loc { start: 0 }).len
+    }
+
+    #[test]
+    fn terminated_identifier() {
+        assert_eq!(len_of(b"foo = 1"), 3);
+        assert_eq!(len_of(b"x;"), 1);
+    }
+
+    #[test]
+    fn identifier_at_eof_includes_last_codepoint() {
+        assert_eq!(len_of(b"foo"), 3);
+        assert_eq!(len_of(b"x"), 1);
+        // Multibyte final codepoint: 'é' is 2 bytes.
+        assert_eq!(len_of("aé".as_bytes()), 3);
+    }
+
+    #[test]
+    fn private_names() {
+        assert_eq!(len_of(b"#"), 1);
+        assert_eq!(len_of(b"#foo = 1"), 4);
+        assert_eq!(len_of(b"#foo"), 4);
+    }
+
+    #[test]
+    fn bracketed_escape_does_not_swallow_terminator() {
+        // `a\u{41}` is 7 bytes; the `.` must terminate the range.
+        assert_eq!(len_of(b"a\\u{41}.x"), 7);
+        assert_eq!(len_of(b"a\\u{41} = 1"), 7);
+    }
+
+    #[test]
+    fn leading_bracketed_escape() {
+        assert_eq!(len_of(b"\\u{61}bc = 1"), 8);
+        assert_eq!(len_of(b"\\u{61}"), 6);
+    }
+
+    #[test]
+    fn non_identifier_start() {
+        assert_eq!(len_of(b"1abc"), 0);
+        assert_eq!(len_of(b" foo"), 0);
+    }
+}
+
 #[cfg(test)]
 mod line_column_tracker_tests {
     use super::*;
diff --git a/src/ast/loader.rs b/src/ast/loader.rs
index 3759ed20baf..646bae167d8 100644
--- a/src/ast/loader.rs
+++ b/src/ast/loader.rs
@@ -1,4 +1,4 @@
-//! `bundler/options.zig` `Loader` + `SideEffects`.
+//! `Loader` + `SideEffects`.
 //!
 //! Data-only enum + pure predicates. `to_api()` / `from_api()` / `API_NAMES` /
 //! `LoaderOptional::from_api` live in `bun_options_types::LoaderExt` (would
@@ -14,8 +14,19 @@ use phf;
 /// - bun-native-bundler-plugin-api/bundler_plugin.h
 /// - src/jsc/bindings/headers-handwritten.h
 #[repr(u8)]
-#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash, Enum, strum::IntoStaticStr)]
-// Zig field names are lower_snake — `@tagName` is exposed to JS (HTMLImportManifest
+#[derive(
+    Copy,
+    Clone,
+    Default,
+    Eq,
+    PartialEq,
+    Debug,
+    Hash,
+    Enum,
+    strum::IntoStaticStr,
+    strum::VariantNames,
+)]
+// The lower_snake names are exposed to JS (HTMLImportManifest
 // `"loader":`, BuildArtifact.loader) so the strum serialization must match exactly.
 #[strum(serialize_all = "snake_case")]
 pub enum Loader {
@@ -24,6 +35,7 @@ pub enum Loader {
     Ts = 2,
     Tsx = 3,
     Css = 4,
+    #[default]
     File = 5,
     Json = 6,
     Jsonc = 7,
@@ -46,7 +58,7 @@ pub enum Loader {
 // `OnBeforeParseArguments` / `OnBeforeParseResult` (`bundler_plugin.h`); lock
 // the discriminant width and the values native plugins observe. NB: the C
 // header's `BUN_LOADER_TOML = 7` etc. predate `Jsonc`'s insertion at 7 and are
-// known-stale — Zig `options.zig` is the source of truth, which Rust matches.
+// known-stale — this enum is the source of truth.
 bun_core::assert_ffi_discr!(
     Loader, u8;
     Jsx = 0, Js = 1, Ts = 2, Tsx = 3, Css = 4, File = 5, Json = 6,
@@ -54,13 +66,6 @@ bun_core::assert_ffi_discr!(
     Text = 13, Bunsh = 14, Sqlite = 15, SqliteEmbedded = 16, Html = 17,
 );
 
-impl Default for Loader {
-    /// Mirrors Zig's `Loader = .file` default field initializer.
-    fn default() -> Self {
-        Loader::File
-    }
-}
-
 /// `Loader.Optional` — `enum(u8) { none = 254, _ }` niche-packed optional.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -75,8 +80,7 @@ impl LoaderOptional {
     }
 
     pub fn unwrap(self) -> Option<Loader> {
-        // Spec options.zig:594-596 uses `@enumFromInt(@intFromEnum(opt))` which is
-        // debug-checked. PORTING.md §Forbidden patterns bars transmute-to-enum;
+        // PORTING.md §Forbidden patterns bars transmute-to-enum;
         // exhaustive match so out-of-range tags are debug-asserted, never UB.
         match self.0 {
             0 => Some(Loader::Jsx),
@@ -221,7 +225,6 @@ impl Loader {
         } else {
             slice_
         };
-        // Zig: names.getWithEql(slice, strings.eqlCaseInsensitiveASCIIICheckLength)
         // phf is case-sensitive, so fall back to a case-insensitive scan over NAMES.entries().
         Self::NAMES.get(slice).copied().or_else(|| {
             Self::NAMES
@@ -246,7 +249,7 @@ impl Loader {
         matches!(self, Loader::Jsx | Loader::Js | Loader::Ts | Loader::Tsx)
     }
 
-    // PORT NOTE: spelling-aliases for the canonical `is_typescript` /
+    // Spelling-aliases for the canonical `is_typescript` /
     // `is_javascript_like*` (acronym-collapsing rule). Hoisted from
     // `bun_bundler::options::LoaderExt` so cross-crate callers (bun_jsc,
     // bun_runtime) resolve them as inherent methods without a trait import.
@@ -293,7 +296,6 @@ impl Loader {
     }
 }
 
-/// `resolver/resolver.zig` `SideEffects`.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
 pub enum SideEffects {
@@ -317,5 +319,3 @@ pub enum SideEffects {
     // /// Removing the import would not call the plugin which is observable.
     // NoSideEffectsPureDataFromPlugin,
 }
-
-// ported from: src/options_types/BundleEnums.zig (Loader, SideEffects)
diff --git a/src/ast/new_store.rs b/src/ast/new_store.rs
index a28ec01048a..39c3c913af0 100644
--- a/src/ast/new_store.rs
+++ b/src/ast/new_store.rs
@@ -10,8 +10,21 @@
 // Scope name distinct from the macro-generated `struct Store`.
 ::bun_core::declare_scope!(STORE_LOG, hidden);
 
-/// Zig: `pub fn NewStore(comptime types: []const type, comptime count: usize) type`
+/// Compile-time membership check for
+/// the type list of a `new_store!`-generated store.
 ///
+/// `new_store!` implements this for every `$T` in its list (with `S` = the
+/// generated `Store` type), and bounds `Store::allocate`/`Store::append` (and
+/// the `thread_local_ast_store!` front-end `append`) on it. Allocating a type
+/// the store was not declared with is therefore a compile error.
+pub trait StoredIn<S>: sealed::Sealed<S> {}
+
+#[doc(hidden)]
+pub mod sealed {
+    /// Sealing supertrait — only `new_store!` expansions implement it.
+    pub trait Sealed<S> {}
+}
+
 /// Rust cannot take a slice of types as a generic parameter, and the body
 /// derives array sizes and alignment from that list (which would require
 /// `generic_const_exprs`). Per PORTING.md this falls under the
@@ -29,13 +42,11 @@ macro_rules! new_store {
             use ::core::mem::{align_of, size_of, MaybeUninit};
             use ::core::ptr::{addr_of_mut, NonNull};
 
-            // Zig: `const largest_size, const largest_align = brk: { ... }`
             const LARGEST_SIZE: usize = {
                 let sizes = [$(size_of::<$T>()),+];
                 let mut largest_size = 0;
                 let mut i = 0;
                 while i < sizes.len() {
-                    // Zig: `@compileError("NewStore does not support 0 size type: " ++ @typeName(T))`
                     assert!(sizes[i] > 0, "NewStore does not support 0 size type");
                     if sizes[i] > largest_size { largest_size = sizes[i]; }
                     i += 1;
@@ -53,19 +64,18 @@ macro_rules! new_store {
                 largest_align
             };
 
-            // Zig: `const backing_allocator = bun.default_allocator;`
-            // (deleted — global mimalloc via #[global_allocator]; Box/alloc use it.)
-
-            // Zig: `const log = Output.scoped(.Store, .hidden);`
-            // (declared once at crate level: `bun_output::declare_scope!(Store, hidden);`)
+            // Allocation goes through the global mimalloc allocator
+            // (#[global_allocator]); Box/alloc use it.
+            // The log scope is declared once at crate level:
+            // `bun_output::declare_scope!(Store, hidden);`
 
             pub struct Store {
                 /// Lazily-allocated head of the block chain — `None` until the
                 /// first [`Store::allocate`]. Owns the entire `Box<Block>`
                 /// `next`-linked list; `Store`'s `Drop` walks it iteratively.
                 ///
-                /// PERF(port): Zig co-allocated `Store` + the first `Block` in a
-                /// single `PreAlloc` so `create()` always paid one `~BLOCK_SIZE`
+                /// An earlier design co-allocated `Store` + the first
+                /// `Block` so `create()` always paid one `~BLOCK_SIZE`
                 /// malloc. Splitting them lets a store that is `create()`d but
                 /// never written to (e.g. the `Stmt` store during
                 /// `Transpiler::configure_defines`, which only emits `E::String`
@@ -81,14 +91,12 @@ macro_rules! new_store {
                 debug_lock: ::core::cell::Cell<bool>,
             }
 
-            /// Zig: `pub const Block = struct { ... }`
-            // PORT NOTE: `buffer` needs `align(LARGEST_ALIGN)` but `#[repr(align(N))]`
+            // `buffer` needs `align(LARGEST_ALIGN)` but `#[repr(align(N))]`
             // requires a literal. Over-approximate with align(16) — every AST payload
             // type is `<= 16` aligned (asserted below). Switch to a
             // `#[repr(C)] union AlignUnion { $($T),+ }` element type if a >16-aligned
             // payload is ever introduced.
             const _: () = assert!(LARGEST_ALIGN <= 16, "NewStore payload type with align>16; bump Block repr(align)");
-            /// Zig: `pub const size = largest_size * count * 2;`
             pub(crate) const BLOCK_SIZE: usize = LARGEST_SIZE * $count * 2;
             #[repr(C, align(16))]
             pub struct Block {
@@ -97,11 +105,19 @@ macro_rules! new_store {
                 next: Option<Box<Block>>,
             }
 
+            // Only the types listed in this `new_store!`
+            // invocation may be allocated from this store. `allocate`/`append`
+            // are bounded on `StoredIn<Store>`, so an unsupported type is a
+            // compile error.
+            $(
+                impl $crate::new_store::sealed::Sealed<Store> for $T {}
+                impl $crate::new_store::StoredIn<Store> for $T {}
+            )+
+
             impl Block {
                 pub const SIZE: usize = BLOCK_SIZE;
 
-                // Zig: `pub const Size = std.math.IntFittingRange(0, size + largest_size);`
-                // PERF(port): was IntFittingRange — picks smallest uN; using u32 (Block::SIZE
+                // PERF: could pick the smallest uN that fits; using u32 (Block::SIZE
                 // for AST node stores fits comfortably). Profile.
 
                 /// Initialize the non-buffer fields without touching the (large,
@@ -119,7 +135,7 @@ macro_rules! new_store {
                 }
 
                 pub fn try_alloc<T>(block: &mut Block) -> Option<NonNull<T>> {
-                    // Zig: `std.mem.alignForward(usize, block.bytes_used, @alignOf(T))`
+                    // Align `bytes_used` forward to `align_of::<T>()`.
                     let start = ((block.bytes_used as usize) + align_of::<T>() - 1)
                         & !(align_of::<T>() - 1);
                     if start + size_of::<T>() > block.buffer.len() {
@@ -133,13 +149,13 @@ macro_rules! new_store {
                         let _ = &block.buffer[block.bytes_used as usize..][..size_of::<T>()];
                     }
 
-                    // Zig: `defer block.bytes_used = @intCast(start + @sizeOf(T));`
                     block.bytes_used =
                         BlockSize::try_from(start + size_of::<T>()).unwrap();
 
                     // SAFETY: `start` is in-bounds (checked above) and aligned for T
                     // (align_forward above). Buffer base alignment must be >= align_of::<T>()
-                    // — see TODO(port) on Block re: LARGEST_ALIGN.
+                    // — guaranteed by `repr(align(16))` on Block plus the
+                    // `LARGEST_ALIGN <= 16` const assert above.
                     Some(unsafe {
                         NonNull::new_unchecked(
                             block.buffer.as_mut_ptr().add(start).cast::<T>(),
@@ -149,7 +165,6 @@ macro_rules! new_store {
 
                 /// Heap-allocate a Block without placing the (large) buffer on the stack.
                 fn new_boxed() -> Box<Block> {
-                    // Zig: `backing_allocator.create(Block)` then `.zero()`
                     let mut b: Box<MaybeUninit<Block>> = Box::new_uninit();
                     Block::zero(&mut b);
                     // SAFETY: `zero` initialized every non-buffer field; `buffer` is
@@ -158,7 +173,6 @@ macro_rules! new_store {
                 }
             }
 
-            // Zig: `pub const Size = std.math.IntFittingRange(0, size + largest_size);`
             type BlockSize = u32;
 
             /// `Store` owns its `Box<Block>` chain (`head` → `next` → …). The
@@ -171,7 +185,6 @@ macro_rules! new_store {
                     while let Some(mut block) = it {
                         #[cfg(debug_assertions)]
                         {
-                            // Zig: `@memset(block.buffer, undefined);`
                             // SAFETY: poisoning a buffer that is being freed.
                             unsafe {
                                 ::core::ptr::write_bytes(
@@ -190,11 +203,10 @@ macro_rules! new_store {
             impl Store {
                 pub fn init() -> *mut Store {
                     /* scoped_log elided — debug_logs feature only */
-                    // PERF(port): the first `Block`'s ~`BLOCK_SIZE` heap buffer
+                    // The first `Block`'s ~`BLOCK_SIZE` heap buffer
                     // is *not* allocated here — only the small `Store` header.
                     // `allocate()` lazily mallocs the first `Block` on the first
-                    // `append()` (see the `head` field doc). Box aborts on OOM
-                    // (matches Zig `bun.handleOom`).
+                    // `append()` (see the `head` field doc). Box aborts on OOM.
                     bun_core::heap::into_raw(Box::new(Store {
                         head: None,
                         current: ::core::ptr::null_mut(),
@@ -230,7 +242,6 @@ macro_rules! new_store {
                         // singly-linked list; walk it via `&mut` reborrows.
                         let mut it: Option<&mut Block> = store.head.as_deref_mut();
                         while let Some(block) = it {
-                            // Zig: `block.bytes_used = undefined; @memset(&block.buffer, undefined);`
                             // SAFETY: poisoning; buffer is MaybeUninit<u8>.
                             unsafe {
                                 ::core::ptr::write_bytes(
@@ -257,10 +268,8 @@ macro_rules! new_store {
                     store.current = head_ptr;
                 }
 
-                fn allocate<T>(store: &mut Store) -> NonNull<T> {
+                fn allocate<T: $crate::new_store::StoredIn<Store>>(store: &mut Store) -> NonNull<T> {
                     debug_assert!(size_of::<T>() > 0); // don't allocate!
-                    // TODO(port): `comptime if (!supportsType(T)) @compileError(...)` —
-                    // enforce via a sealed trait generated over `$($T),+`.
 
                     // Lazily materialise the first `Block` on first use — this is
                     // the only `~BLOCK_SIZE` allocation a never-written store
@@ -304,7 +313,10 @@ macro_rules! new_store {
                 }
 
                 #[inline]
-                pub fn append<T>(store: &mut Store, data: T) -> NonNull<T> {
+                pub fn append<T: $crate::new_store::StoredIn<Store>>(
+                    store: &mut Store,
+                    data: T,
+                ) -> NonNull<T> {
                     let ptr = Store::allocate::<T>(store);
                     /* scoped_log elided — debug_logs feature only */
                     // SAFETY: `allocate` returned aligned, in-bounds, exclusive storage for T.
@@ -332,9 +344,8 @@ macro_rules! new_store {
                     let _ = store;
                 }
 
-                // Zig: `fn supportsType(T: type) bool`
-                // TODO(port): comptime type-list membership check; replace with sealed
-                // trait `Stored` impl'd for each `$($T),+` and bound `allocate<T: Stored>`.
+                // Type-list membership is enforced by the
+                // `StoredIn<Store>` impls generated above `impl Block`.
             }
         }
     };
@@ -348,8 +359,7 @@ macro_rules! new_store {
 // optional `ASTMemoryAllocator` override, `disable_reset` flag) plus the
 // twelve identical accessor/lifecycle fns. The two hand-written copies in
 // expr.rs / stmt.rs were byte-for-byte twins modulo the backing type and the
-// "Expr"/"Stmt" panic-string label — and so are the Zig originals
-// (expr.zig:3117-3196 vs stmt.zig:300-382). This macro stamps out one
+// "Expr"/"Stmt" panic-string label. This macro stamps out one
 // `pub mod Store { … }` per call site so the duplication lives here once.
 //
 // Why a macro and not a generic struct: `#[thread_local] static` cannot be
@@ -375,7 +385,7 @@ macro_rules! thread_local_ast_store {
             // read on every node `alloc` (the hottest TLS in the parser), and
             // the `thread_local!` macro's `LocalKey` wrapper showed up in
             // next-lint profiles. All three are `Cell<ptr|bool>` (no destructor,
-            // const init); matches Zig `threadlocal var`.
+            // const init).
             #[thread_local]
             pub(crate) static INSTANCE: Cell<*mut Backing> = Cell::new(::core::ptr::null_mut());
             /// Back-reference to the `ASTMemoryAllocator` installed by the
@@ -401,8 +411,9 @@ macro_rules! thread_local_ast_store {
             #[inline]
             fn instance_mut<'a>() -> Option<&'a mut Backing> {
                 // SAFETY: `INSTANCE` is thread-local; the `*mut Backing` it holds
-                // is either null or was returned by `Backing::init()` (leaked
-                // `PreAlloc`) and remains valid until `deinit()` clears it.
+                // is either null or was returned by `Backing::init()` (a `Box`
+                // leaked via `bun_core::heap::into_raw`) and remains valid
+                // until `deinit()` clears it.
                 // Single-threaded access — no other `&mut` to the slab is live.
                 unsafe { INSTANCE.get().as_mut() }
             }
@@ -449,7 +460,7 @@ macro_rules! thread_local_ast_store {
                 );
             }
 
-            /// Zig: `Data.Store.disable_reset = b;` — toggled by long-lived
+            /// Toggled by long-lived
             /// callers (transpiler, bundler) that want the Store to persist
             /// across multiple parse calls.
             #[inline]
@@ -481,7 +492,9 @@ macro_rules! thread_local_ast_store {
             }
 
             #[inline]
-            pub fn append<T>(value: T) -> $crate::StoreRef<T> {
+            pub fn append<T: $crate::new_store::StoredIn<Backing>>(
+                value: T,
+            ) -> $crate::StoreRef<T> {
                 if let Some(ma) = MEMORY_ALLOCATOR.get() {
                     // `BackRef<ASTMemoryAllocator>: Deref` — owning scope outlives this call.
                     return ma.append(value);
@@ -497,5 +510,3 @@ macro_rules! thread_local_ast_store {
         }
     };
 }
-
-// ported from: src/js_parser/ast/NewStore.zig
diff --git a/src/ast/nodes.rs b/src/ast/nodes.rs
index c6f67e8f68b..e6deded40dc 100644
--- a/src/ast/nodes.rs
+++ b/src/ast/nodes.rs
@@ -19,17 +19,16 @@ pub use crate::flags as Flags;
 //
 // Thin `NonNull<T>` newtype — `Copy`, `Deref`/`DerefMut`. The pointee lives
 // until the owning Store/arena is `reset()`; callers must not hold a `StoreRef`
-// across that boundary. Matches Zig's `*T` payloads in `Expr.Data`.
+// across that boundary.
 // ───────────────────────────────────────────────────────────────────────────
 
 #[repr(transparent)]
 pub struct StoreRef<T>(NonNull<T>);
 
-// SAFETY: `StoreRef` is a thin pointer into a single-threaded bump arena (Zig
-// `*T`). We assert Send/Sync so payload types embedding `Option<StoreRef<T>>`
-// (e.g. `E::EString::next`) can sit in `static` tables — matches Zig where raw
-// pointers carry no thread-affinity. Callers are responsible for not actually
-// sharing a Store across threads (same contract as the Zig original).
+// SAFETY: `StoreRef` is a thin pointer into a single-threaded bump arena.
+// We assert Send/Sync so payload types embedding `Option<StoreRef<T>>`
+// (e.g. `E::EString::next`) can sit in `static` tables. Callers are
+// responsible for not actually sharing a Store across threads.
 //
 // Bounded on `T` so `StoreRef` cannot launder a `!Send`/`!Sync` payload (e.g.
 // `StoreRef<Cell<_>>`) past auto-trait inference: `Deref` yields `&T` (needs
@@ -58,11 +57,10 @@ impl<T> StoreRef<T> {
     pub fn from_bump(r: &mut T) -> Self {
         StoreRef(NonNull::from(r))
     }
-    /// Consume a `Box<T>` whose payload must outlive every Store reset
-    /// (Zig `deepClone(default_allocator)` semantics). Ownership transfers to
-    /// the returned `StoreRef`; the allocation is process-lifetime by design
-    /// and is never dropped — mirrors `bun.default_allocator.create(T)` with
-    /// no paired `destroy`. Prefer `from_bump` for arena-backed nodes.
+    /// Consume a `Box<T>` whose payload must outlive every Store reset.
+    /// Ownership transfers to the returned `StoreRef`; the allocation is
+    /// process-lifetime by design and is never dropped. Prefer `from_bump`
+    /// for arena-backed nodes.
     #[inline]
     pub fn from_box(b: Box<T>) -> Self {
         StoreRef(bun_core::heap::into_raw_nn(b))
@@ -76,10 +74,9 @@ impl<T> StoreRef<T> {
     #[inline]
     pub const fn from_static(r: &'static T) -> Self {
         // SAFETY: `r` is a non-null, aligned, dereferenceable `'static`
-        // reference. Provenance is shared/read-only: this mirrors Zig
-        // `@constCast` on prefill tables. The pointee is *never* written
-        // through — `DerefMut` on a `StoreRef` produced here is UB and callers
-        // must not do so (audited: only `Deref`/`get()` reads occur).
+        // reference. Provenance is shared/read-only: the pointee is *never*
+        // written through — `DerefMut` on a `StoreRef` produced here is UB and
+        // callers must not do so (audited: only `Deref`/`get()` reads occur).
         StoreRef(unsafe { NonNull::new_unchecked(core::ptr::from_ref(r).cast_mut()) })
     }
     /// Borrow the pointee (explicit form of `Deref`).
@@ -108,8 +105,7 @@ impl<T> DerefMut for StoreRef<T> {
     fn deref_mut(&mut self) -> &mut T {
         // SAFETY: StoreRef invariant. AST nodes are mutated in-place during
         // visiting; no two `StoreRef` to the same node are deref'd `&mut`
-        // simultaneously in single-threaded parser/visitor passes — same
-        // contract as the Zig original.
+        // simultaneously in single-threaded parser/visitor passes.
         unsafe { self.0.as_mut() }
     }
 }
@@ -119,8 +115,7 @@ impl<T> From<NonNull<T>> for StoreRef<T> {
         StoreRef(p)
     }
 }
-/// Pointer-identity comparison (matches the `NonNull<T>`/Zig `*T` semantics
-/// of the field this type replaces).
+/// Pointer-identity comparison.
 impl<T> PartialEq for StoreRef<T> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -162,7 +157,7 @@ pub struct StoreStr {
 }
 
 // SAFETY: same rationale as `StoreRef` — points into a single-threaded bump
-// arena (Zig `[]const u8`). Asserted Send/Sync so payload types can sit in
+// arena. Asserted Send/Sync so payload types can sit in
 // `static` Prefill tables; callers must not actually share a Store across
 // threads (unchanged contract).
 unsafe impl Send for StoreStr {}
@@ -318,8 +313,7 @@ impl core::fmt::Debug for StoreStr {
 // per-node `[Stmt]`/`[Expr]` views, …) that borrow from the parse arena.
 // Same contract as `StoreRef`/`StoreStr`: safe `::new`,
 // raw `NonNull<T>` + `u32` length, `Deref<Target=[T]>`, valid until the
-// owning arena resets. The `u32` length matches Zig's `[]T` (`u32` len under
-// `-Dwasm32` and the AST's practical bounds) and keeps the field at 12 bytes
+// owning arena resets. The `u32` length keeps the field at 12 bytes
 // on 64-bit instead of 16 — relevant for hot AST nodes.
 #[repr(C)]
 pub struct StoreSlice<T> {
@@ -421,8 +415,8 @@ impl<T> StoreSlice<T> {
         unsafe { core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len as usize) }
     }
 
-    /// Shorten the slice in place. Panics if `new_len > len` (mirrors Zig
-    /// `slice[0..new_len]` bounds check). The arena still owns the trailing
+    /// Shorten the slice in place. Panics if `new_len > len`.
+    /// The arena still owns the trailing
     /// elements; they are simply no longer reachable through this view.
     #[inline]
     pub fn truncate(&mut self, new_len: usize) {
@@ -430,8 +424,8 @@ impl<T> StoreSlice<T> {
         self.len = new_len as u32;
     }
 
-    /// Construct from a `BumpVec`/`ArenaVec` by leaking it into the bump arena
-    /// (Zig: `list.items` after `toOwnedSlice`). Convenience for the common
+    /// Construct from a `BumpVec`/`ArenaVec` by leaking it into the bump arena.
+    /// Convenience for the common
     /// `StoreSlice::new_mut(v.into_bump_slice_mut())` pattern.
     #[inline]
     pub fn from_bump<'b>(v: bun_alloc::ArenaVec<'b, T>) -> Self {
@@ -534,7 +528,7 @@ pub type ExprNodeList = Vec<Expr, bun_alloc::AstAlloc>;
 pub type StmtNodeList = StoreSlice<Stmt>;
 pub type BindingNodeList = StoreSlice<Binding>;
 
-#[repr(u8)] // Zig: enum(u2)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum ImportItemStatus {
@@ -545,7 +539,7 @@ pub enum ImportItemStatus {
     Missing,
 }
 
-#[repr(u8)] // Zig: enum(u2)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum AssignTarget {
@@ -614,7 +608,7 @@ impl Default for ClauseItem {
     }
 }
 
-// EnumMap<_, u32>::default() zero-fills (Zig: SlotNamespace.CountsArray.initFill(0)).
+// EnumMap<_, u32>::default() zero-fills.
 #[derive(Copy, Clone, Default)]
 pub struct SlotCounts {
     pub slots: symbol::SlotNamespaceCountsArray,
@@ -688,7 +682,7 @@ impl NameMinifier {
     }
 }
 
-#[repr(u8)] // Zig: enum(u1)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum OptionalChain {
@@ -947,12 +941,10 @@ impl DeclaredSymbolList {
     }
 
     pub fn append_list_assume_capacity(&mut self, other: &DeclaredSymbolList) {
-        // PERF(port): was assume_capacity
         self.entries.append_list_assume_capacity(&other.entries);
     }
 
     pub fn append_assume_capacity(&mut self, entry: DeclaredSymbol) {
-        // PERF(port): was assume_capacity
         self.entries.append_assume_capacity(entry);
     }
 
@@ -1010,7 +1002,6 @@ impl DeclaredSymbol {
         debug_assert_eq!(is_top_level.len(), refs.len());
         for (top, ref_) in is_top_level.iter().zip(refs.iter()) {
             if *top {
-                // PERF(port): was @call(bun.callmod_inline, ...) — relies on inlining.
                 f(ctx, *ref_);
             }
         }
@@ -1045,8 +1036,8 @@ pub type DependencyList = bun_alloc::AstVec<Dependency>;
 pub type ExprList = Vec<Expr>;
 pub type StmtList = Vec<Stmt>;
 pub type BindingList = Vec<Binding>;
-// PERF(port): Zig `std.array_list.Managed` — these may be arena-backed in
-// callers; revisit with bumpalo::collections::Vec if profiling shows churn.
+// PERF: these may be arena-backed in callers; revisit with
+// bumpalo::collections::Vec if profiling shows churn.
 
 /// Each file is made up of multiple parts, and each part consists of one or
 /// more top-level statements. Parts are used for tree shaking and code
@@ -1055,7 +1046,7 @@ pub type BindingList = Vec<Binding>;
 /// splitting.
 pub struct Part {
     pub stmts: StoreSlice<Stmt>,
-    pub scopes: StoreSlice<*mut Scope>, // TODO(port): &'bump mut [&'bump mut Scope]
+    pub scopes: StoreSlice<*mut Scope>, // TODO: &'bump mut [&'bump mut Scope]
 
     /// Each is an index into the file-level import record list
     pub import_record_indices: PartImportRecordIndices,
@@ -1113,8 +1104,6 @@ pub enum PartTag {
     ImportToConvertFromRequire,
 }
 
-// Zig: std.ArrayHashMapUnmanaged(Ref, Symbol.Use, RefHashCtx, false)
-// TODO(port): bun_collections::ArrayHashMap must accept a custom hasher ctx (RefHashCtx).
 pub type PartSymbolUseMap = ArrayHashMap<Ref, symbol::Use, AutoContext, bun_alloc::AstAlloc>;
 pub type PartSymbolPropertyUseMap = ArrayHashMap<
     Ref,
@@ -1158,9 +1147,8 @@ impl StmtOrExpr {
             StmtOrExpr::Expr(expr) => expr,
             StmtOrExpr::Stmt(stmt) => match stmt.data {
                 crate::stmt::Data::SFunction(mut s) => {
-                    // PORT NOTE: Zig moved `func.func` out by value; StoreRef arena
-                    // slot is never individually dropped, so `take` (replace with
-                    // Default) is the safe Rust equivalent.
+                    // The StoreRef arena slot is never individually dropped, so
+                    // `take` (replace with Default) is safe here.
                     let func = core::mem::take(&mut s.func);
                     Expr::init(E::Function { func }, stmt.loc)
                 }
@@ -1224,7 +1212,7 @@ pub struct NamedExport {
     pub alias_loc: crate::Loc,
 }
 
-#[repr(u8)] // Zig: enum(u4)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, strum::IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum StrictModeKind {
@@ -1275,8 +1263,6 @@ impl<T> Batcher<T> {
     where
         T: Default,
     {
-        // TODO(port): bumpalo alloc_slice for uninit T — Zig `arena.alloc(Type, count)`.
-        // PERF(port): Zig left the slice uninitialized; bumpalo requires Default fill.
         let all = bump.alloc_slice_fill_default(count);
         Ok(Self {
             head: StoreSlice::new_mut(all),
@@ -1288,14 +1274,12 @@ impl<T> Batcher<T> {
     }
 
     pub fn eat(&mut self, value: T) -> *mut T {
-        // PORT NOTE: Zig source `@ptrCast(&this.head.eat1(value).ptr)` appears to
-        // intend `this.eat1(value).ptr` cast to *T. Porting the apparent intent.
         self.eat1(value).as_ptr().cast_mut()
     }
 
     pub fn eat1(&mut self, value: T) -> StoreSlice<T> {
-        // `head` has at least 1 element remaining (caller contract — Zig would
-        // panic on bounds); `Batcher` holds the unique view of the allocation.
+        // `head` has at least 1 element remaining (caller contract);
+        // `Batcher` holds the unique view of the allocation.
         let head = self.head.slice_mut();
         let (prev, rest) = head.split_at_mut(1);
         prev[0] = value;
@@ -1314,17 +1298,15 @@ impl<T> Batcher<T> {
         StoreSlice::new_mut(prev)
     }
 }
-// Zig: `pub fn NewBatcher(comptime Type: type) type` → Rust generic struct above.
 pub type NewBatcher<T> = Batcher<T>;
 
 // ═════════════════════════════════════════════════════════════════════════
 // Symbols pulled DOWN from higher-tier
 // crates so lower-tier callers (css, interchange, js_parser itself) can
-// resolve them here without forming a cycle. Ground truth for each port is
-// the named .zig file, NOT the sibling .rs (which may already forward-ref).
+// resolve them here without forming a cycle.
 // ═════════════════════════════════════════════════════════════════════════
 
-// ─── from bun_jsc::math (src/jsc/jsc.zig) ───────────────────────────────────
+// ─── from bun_jsc::math ─────────────────────────────────────────────────────
 pub mod math {
     /// `Number.MAX_SAFE_INTEGER` (2^53 - 1)
     pub const MAX_SAFE_INTEGER: f64 = 9007199254740991.0;
@@ -1332,7 +1314,6 @@ pub mod math {
     pub const MIN_SAFE_INTEGER: f64 = -9007199254740991.0;
 
     unsafe extern "C" {
-        // Zig: `extern "c" fn Bun__JSC__operationMathPow(f64, f64) f64;`
         // Pure FFI (value-type args, no pointers, no errno) → no caller preconditions.
         safe fn Bun__JSC__operationMathPow(x: f64, y: f64) -> f64;
     }
@@ -1344,8 +1325,7 @@ pub mod math {
         Bun__JSC__operationMathPow(x, y)
     }
 }
-// ─── from bun_bundler::v2::MangledProps (src/bundler/bundle_v2.zig) ─────────
-// Zig: `std.AutoArrayHashMapUnmanaged(Ref, []const u8)`
+// ─── from bun_bundler::v2::MangledProps ─────────────────────────────────────
 // LIFETIMES.tsv: value slices point into the parser arena → `StoreStr`
 // (arena-owned, no `'bump` cascade).
 pub type MangledProps = ArrayHashMap<Ref, StoreStr>;
diff --git a/src/ast/op.rs b/src/ast/op.rs
index 62f4f3b4c3e..a860a5b9485 100644
--- a/src/ast/op.rs
+++ b/src/ast/op.rs
@@ -6,7 +6,7 @@ use crate::AssignTarget;
 // If you add a new token, remember to add it to "TABLE" too
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Enum, IntoStaticStr)]
-#[strum(serialize_all = "snake_case")] // match Zig @tagName output (e.g. "bin_add")
+#[strum(serialize_all = "snake_case")]
 pub enum Code {
     // Prefix
     UnPos, // +expr
@@ -150,7 +150,7 @@ impl Code {
     }
 }
 
-#[repr(u8)] // Zig: enum(u6) — Rust has no u6, u8 is the narrowest fit
+#[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum Level {
     Lowest,
@@ -214,8 +214,8 @@ impl Level {
     const fn from_raw(n: u8) -> Level {
         // Callers only pass values derived from a valid `Level` discriminant
         // ±1 (`sub`/`add_f`); decode by exhaustive match so an out-of-range
-        // shift traps in release too (matches Zig's safety-checked
-        // `@enumFromInt`) instead of fabricating an invalid discriminant.
+        // shift traps in release too instead of fabricating an invalid
+        // discriminant.
         match n {
             0 => Level::Lowest,
             1 => Level::Comma,
@@ -263,8 +263,6 @@ impl Default for Op {
 }
 
 impl Op {
-    // PORT NOTE: Zig `init(triple: anytype)` took an anonymous tuple .{text, level, is_keyword}
-    // and accessed .@"0"/.@"1"/.@"2". Flattened to positional params.
     pub const fn init(text: &'static [u8], level: Level, is_keyword: bool) -> Op {
         Op {
             text,
@@ -274,24 +272,19 @@ impl Op {
     }
 }
 
-// Zig: `pub const TableType: std.EnumArray(Op.Code, Op) = undefined;`
-// This declared an `undefined` value (vestigial / used only for @TypeOf at callsites).
-// Ported as a type alias since Rust statics cannot be uninitialized.
 pub type TableType = Table;
 
-/// `.rodata` `[Op; Code::COUNT]` indexed by [`Code`] discriminant. Exposes the
-/// Zig `std.EnumArray` surface (`getPtrConst`/`get`/`[]`) so downstream
-/// callers don't see the raw array.
+/// `.rodata` `[Op; Code::COUNT]` indexed by [`Code`] discriminant. Exposes
+/// `get_ptr_const`/`get`/`[]` accessors so downstream callers don't see the
+/// raw array.
 #[repr(transparent)]
 pub struct Table(pub [Op; <Code as Enum>::LENGTH]);
 
 impl Table {
-    /// Zig: `Op.Table.getPtrConst(code) -> *const Op`.
     #[inline]
     pub fn get_ptr_const(&'static self, code: Code) -> &'static Op {
         &self.0[code as usize]
     }
-    /// Zig: `Op.Table.get(code) -> Op`.
     #[inline]
     pub fn get(&self, code: Code) -> Op {
         self.0[code as usize]
@@ -307,7 +300,7 @@ impl core::ops::Index<Code> for Table {
 }
 
 // Built at const-eval time so it lives in `.rodata` with zero init code on the
-// startup path (matches the Zig `comptime` labeled block).
+// startup path.
 pub static TABLE: Table = Table({
     const NIL: Op = Op::init(b"", Level::Lowest, false);
     let mut t = [NIL; <Code as Enum>::LENGTH];
@@ -379,5 +372,3 @@ pub static TABLE: Table = Table({
 
     t
 });
-
-// ported from: src/js_parser/ast/Op.zig
diff --git a/src/ast/runtime.rs b/src/ast/runtime.rs
index b234450197f..5778804b472 100644
--- a/src/ast/runtime.rs
+++ b/src/ast/runtime.rs
@@ -1,7 +1,7 @@
 #![allow(unexpected_cfgs)] // `bun_codegen_embed` is set via RUSTFLAGS (scripts/build/rust.ts) for release/CI builds.
 
-// REFACTOR_BUN_AST: this module holds only the data-shaped pieces of
-// `runtime.zig` that the AST crate (and `bun_js_printer::Options`) need:
+// REFACTOR_BUN_AST: this module holds only the data-shaped runtime pieces
+// that the AST crate (and `bun_js_printer::Options`) need:
 // `Runtime::source_code`, `Imports`, `ReplaceableExport*`, `ServerComponentsMode`.
 // The `Features` struct (carries `&mut RuntimeTranspilerCache`) and
 // `Fallback` HTML rendering (needs `bun_options_types::schema`, `bun_io`,
@@ -28,13 +28,16 @@ impl Runtime {
     }
 }
 
-/// Zig: `Runtime.Features.ReplaceableExport`
 #[derive(Clone)]
 pub enum ReplaceableExport {
     Delete,
     Replace(Expr),
-    Inject { name: Box<[u8]>, value: Expr },
-    // TODO(port): `name` was `string` (= []const u8). Ownership unclear; using Box<[u8]>.
+    /// Owns the name bytes (constructed from an owned slice in
+    /// `JSTranspiler`; the parser copies into its bump arena when consuming).
+    Inject {
+        name: Box<[u8]>,
+        value: Expr,
+    },
 }
 
 impl ReplaceableExport {
@@ -44,18 +47,14 @@ impl ReplaceableExport {
     }
 }
 
-/// Zig: `bun.StringArrayHashMapUnmanaged(ReplaceableExport)`.
-///
-/// Newtype (not a bare alias) so we can hang `get_ptr` (Zig spelling for
-/// `getPtr`, which borrows immutably) and expose a `.entries` accessor that
-/// satisfies the `replace_exports.entries.len` shape `visitStmt` ported
-/// verbatim from Zig's `ArrayHashMap.entries`.
+/// Newtype (not a bare alias) so we can hang `get_ptr` (which borrows
+/// immutably) and expose a `.entries` accessor that satisfies the
+/// `replace_exports.entries.len` shape used by `visitStmt`.
 #[derive(Default)]
 pub struct ReplaceableExportMap {
-    /// Backing map. Named `entries` so `replace_exports.entries.len()` —
-    /// the literal Zig spelling — resolves (Zig's `ArrayHashMap.entries`
-    /// is a `MultiArrayList` with `.len`; here `StringArrayHashMap` derefs
-    /// to `ArrayHashMap` which has `.len()`).
+    /// Backing map. Named `entries` so `replace_exports.entries.len()`
+    /// resolves (`StringArrayHashMap` derefs to `ArrayHashMap`, which has
+    /// `.len()`).
     pub entries: StringArrayHashMap<ReplaceableExport>,
 }
 
@@ -78,10 +77,8 @@ impl ReplaceableExportMap {
     pub fn count(&self) -> usize {
         self.entries.count()
     }
-    /// Zig `getPtr` returns `?*V` from a `*const Self` — i.e. immutable
-    /// lookup yielding a (logically-mutable) pointer. Rust splits this into
-    /// `get_ptr` (`&V`) and `get_ptr_mut` (`&mut V`); call sites in the
-    /// visitor only read through it.
+    /// Immutable lookup (`&V`); `get_ptr_mut` is the `&mut V` form. Call
+    /// sites in the visitor only read through it.
     #[inline]
     pub fn get_ptr(&self, key: &[u8]) -> Option<&ReplaceableExport> {
         self.entries.get(key)
@@ -96,7 +93,6 @@ impl ReplaceableExportMap {
     }
 }
 
-/// Zig: `Runtime.Features.ServerComponentsMode`
 #[derive(Clone, Copy, PartialEq, Eq, Default)]
 pub enum ServerComponentsMode {
     /// Server components is disabled, strings "use client" and "use server" mean nothing.
@@ -167,7 +163,7 @@ pub struct Imports {
     pub __decoratorMetadata: Option<Ref>,
     pub __runInitializers: Option<Ref>,
     pub __decorateElement: Option<Ref>,
-    /// Zig field name: `@"$$typeof"` (not a valid Rust identifier).
+    /// The `$$typeof` runtime import (`$$typeof` is not a valid Rust identifier).
     pub dollar_dollar_typeof: Option<Ref>,
     pub __using: Option<Ref>,
     pub __callDispose: Option<Ref>,
@@ -204,8 +200,8 @@ impl Imports {
         b"__promiseAll",
     ];
 
-    /// Zig computed this at comptime via `std.sort.pdq`. Rust stable cannot sort in
-    /// `const`; precomputed here and verified by `tests::all_sorted_matches_zig_comptime`.
+    /// Rust stable cannot sort in `const`; precomputed here and verified by
+    /// the test in `tests` below.
     #[cfg_attr(not(test), allow(dead_code))]
     const ALL_SORTED: [&'static [u8]; 25] = [
         b"$$typeof",
@@ -267,7 +263,7 @@ impl Imports {
 
     pub const NAME: &'static [u8] = b"bun:wrap";
 
-    /// Index → field. Expansion of Zig `@field(this, all[i])`.
+    /// Index → field.
     #[inline]
     fn field(&self, i: usize) -> Option<Ref> {
         match i {
@@ -339,9 +335,8 @@ impl Imports {
         }
     }
 
-    /// Zig: `contains(imports, comptime key: string)`.
-    // TODO(port): comptime-string key — Rust callers should access the field directly
-    // (`imports.__foo.is_some()`). Runtime fallback provided for parity.
+    /// Callers that know the key statically can read the field directly
+    /// (`imports.__foo.is_some()`); this is the runtime-keyed equivalent.
     pub fn contains(&self, key: &[u8]) -> bool {
         Self::ALL
             .iter()
@@ -359,8 +354,8 @@ impl Imports {
         false
     }
 
-    /// Zig: `put(imports, comptime key: string, ref: Ref)`.
-    // TODO(port): comptime-string key — Rust callers should assign the field directly.
+    /// Callers that know the key statically can assign the field directly;
+    /// this is the runtime-keyed equivalent.
     pub fn put(&mut self, key: &[u8], ref_: Ref) {
         if let Some(i) = Self::ALL.iter().position(|&k| k == key) {
             if let Some(slot) = self.field_mut(i) {
@@ -369,8 +364,8 @@ impl Imports {
         }
     }
 
-    /// Zig: `at(imports, comptime key: string) ?Ref`.
-    // TODO(port): comptime-string key — Rust callers should read the field directly.
+    /// Callers that know the key statically can read the field directly;
+    /// this is the runtime-keyed equivalent.
     pub fn at(&self, key: &[u8]) -> Option<Ref> {
         Self::ALL
             .iter()
@@ -378,7 +373,7 @@ impl Imports {
             .and_then(|i| self.field(i))
     }
 
-    /// Zig: `get(imports, key: anytype) ?Ref` where `key` is a runtime index.
+    /// Lookup by runtime index.
     pub fn get(&self, key: usize) -> Option<Ref> {
         if key < Self::ALL.len() {
             self.field(key)
@@ -398,7 +393,6 @@ impl Imports {
     }
 }
 
-/// Zig: `Runtime.Imports.Iterator`
 pub struct ImportsIterator<'a> {
     pub i: usize,
     pub runtime_imports: &'a Imports,
@@ -414,7 +408,7 @@ impl ImportsIterator<'_> {
     pub fn next(&mut self) -> Option<ImportsIteratorEntry> {
         while self.i < Imports::ALL.len() {
             let t = self.i;
-            self.i += 1; // Zig: `defer this.i += 1;`
+            self.i += 1;
             if let Some(val) = self.runtime_imports.field(t) {
                 return Some(ImportsIteratorEntry {
                     key: u16::try_from(t).expect("int cast"),
@@ -430,12 +424,10 @@ impl ImportsIterator<'_> {
 mod tests {
     use super::Imports;
 
-    /// Port of the Zig comptime block that derives `all_sorted` / `all_sorted_index`.
-    /// Rust stable cannot sort in `const`, so the tables above are hand-precomputed;
-    /// this test re-derives them at runtime and asserts they match.
+    /// The tables above are hand-precomputed (Rust stable cannot sort in
+    /// `const`); this test re-derives them at runtime and asserts they match.
     #[test]
     fn all_sorted_matches_zig_comptime() {
-        // const all_sorted = brk: { var list = all; std.sort.pdq(...); break :brk list; };
         let mut list = Imports::ALL;
         list.sort_unstable();
         assert_eq!(
@@ -444,7 +436,6 @@ mod tests {
             "ALL_SORTED drifted from sorted(ALL)"
         );
 
-        // pub const all_sorted_index = brk: { for (all) |name, i| for (all_sorted) |cmp, j| ... };
         let mut out = [0usize; Imports::ALL.len()];
         for (i, name) in Imports::ALL.iter().enumerate() {
             for (j, cmp) in list.iter().enumerate() {
@@ -461,5 +452,3 @@ mod tests {
         );
     }
 }
-
-// ported from: src/js_parser/runtime.zig
diff --git a/src/ast/s.rs b/src/ast/s.rs
index a8ce4377c39..9bc85057c2d 100644
--- a/src/ast/s.rs
+++ b/src/ast/s.rs
@@ -309,5 +309,3 @@ pub struct Break {
 pub struct Continue {
     pub label: Option<LocRef>, // = None
 }
-
-// ported from: src/js_parser/ast/S.zig
diff --git a/src/ast/scope.rs b/src/ast/scope.rs
index 74672d9f992..fe626fe87bc 100644
--- a/src/ast/scope.rs
+++ b/src/ast/scope.rs
@@ -10,13 +10,11 @@ use crate::ts::TSNamespaceScope;
 /// Backed by `AstAlloc` so the table allocation *and* the per-key boxes land
 /// in the thread-local AST `mi_heap` and are reclaimed by the same
 /// `mi_heap_destroy` that frees the arena-allocated `Scope` holding the map.
-/// In Zig this was `bun.StringHashMapUnmanaged(Member)` whose backing array
-/// lived in the parser arena; the original Rust port placed both on the
-/// global heap, and since `Scope` itself sits in an arena slot whose `Drop`
-/// never runs, every member map leaked.
+/// `Scope` itself sits in an arena slot whose `Drop` never runs, so a
+/// global-heap-backed map here would leak.
 pub(crate) type MemberHashMap = StringHashMap<Member, AstAlloc>;
 
-// PORT NOTE: Zig `Scope` is a value type — `Ast.module_scope` / `BundledAst.module_scope`
+// `Scope` is a value type — `Ast.module_scope` / `BundledAst.module_scope`
 // hold it by value and `toAST` / `init` bitwise-copy it (`this.module_scope`). Vec no
 // longer derives `Clone` (private `origin` field); callers that need a shallow copy must
 // `core::mem::take` or `core::ptr::read` instead.
@@ -27,12 +25,11 @@ pub struct Scope {
     // back-pointer with safe `Deref`/`DerefMut`) so callers don't open-code
     // `unsafe { &*parent.as_ptr() }` at every walk site.
     pub parent: Option<StoreRef<Scope>>,
-    /// `AstVec` for the same reason as `members` above — Zig's
-    /// `ArrayListUnmanaged(*Scope)` was arena-backed. Elements are `StoreRef`
+    /// `AstVec` for the same reason as `members` above. Elements are `StoreRef`
     /// so iteration yields safe `Deref` instead of `unsafe { child.as_ref() }`.
     pub children: AstVec<StoreRef<Scope>>,
     pub members: MemberHashMap,
-    /// `AstVec`: Zig `ArrayListUnmanaged(Ref)`, arena-backed.
+    /// `AstVec`: arena-backed.
     pub generated: AstVec<Ref>,
 
     // This is used to store the ref of the label symbol for ScopeLabel scopes.
@@ -111,16 +108,16 @@ impl Scope {
         name: &[u8],
         hash_value: u64,
     ) -> bun_collections::array_hash_map::StringHashMapGetOrPut<'_, Member> {
-        // PERF(port): `get_or_put_borrowed` doesn't accept a precomputed hash;
+        // PERF: `get_or_put_borrowed` doesn't accept a precomputed hash;
         // this path is once-per-declared-symbol (not per-scope-per-identifier),
         // so the redundant rehash is left as-is.
         let _ = hash_value;
         // SAFETY: `name` is always a slice into either the source-file contents
         // or the lexer string-table (the only producers of identifier text in
         // the parser). Both outlive the `AstAlloc` arena that owns this
-        // `Scope`, so storing the slice by reference (Zig's
-        // `StringHashMapUnmanaged` semantics) is sound — the map is freed by
-        // the same arena reset that would invalidate the source/string-table.
+        // `Scope`, so storing the slice by reference is sound — the map is
+        // freed by the same arena reset that would invalidate the
+        // source/string-table.
         // This avoids one `mi_heap_malloc` per declared identifier per scope,
         // which profiling showed as the parser's hottest slow-path allocation.
         unsafe { self.members.get_or_put_borrowed(name) }
@@ -268,7 +265,6 @@ pub struct Member {
 impl Member {
     #[inline]
     pub fn eql(a: Member, b: Member) -> bool {
-        // PERF(port): Zig used @call(bun.callmod_inline, Ref.eql, ...) — forced inline.
         a.ref_.eql(b.ref_) && a.loc.start == b.loc.start
     }
 }
@@ -300,5 +296,3 @@ pub enum Kind {
     FunctionBody,
     ClassStaticInit,
 }
-
-// ported from: src/js_parser/ast/Scope.zig
diff --git a/src/ast/server_component_boundary.rs b/src/ast/server_component_boundary.rs
index 9528108ff2e..fd717a21736 100644
--- a/src/ast/server_component_boundary.rs
+++ b/src/ast/server_component_boundary.rs
@@ -55,9 +55,9 @@ pub struct List {
     pub map: Map,
 }
 
-// Zig: `std.ArrayHashMapUnmanaged(void, void, struct {}, true)` — a keyless
-// array-hash-map used purely as an index table; all lookups go through the
-// `Adapter` which hashes/compares against `list.items(.source_index)`.
+// A keyless array-hash-map used purely as an index table; all lookups go
+// through the `Adapter` which hashes/compares against the `source_index`
+// column of `list`.
 type Map = ArrayHashMap<(), ()>;
 
 impl List {
@@ -75,9 +75,8 @@ impl List {
             reference_source_index,
             ssr_source_index,
         })?;
-        // PORT NOTE: reshaped for borrowck — Zig built `Adapter` from
-        // `m.list.slice()` while also borrowing `m.map` mutably. Here we hand
-        // the adapter just the `source_index` column it needs.
+        // For borrowck we hand the adapter just the `source_index` column
+        // it needs.
         let gop = self.map.get_or_put_adapted(
             &source_index,
             &Adapter {
@@ -130,9 +129,6 @@ impl<'a> Slice<'a> {
                 source_indices: self.list.items::<"source_index", IndexInt>(),
             },
         )?;
-        // Zig: `bun.unsafeAssert(l.list.capacity > 0)` — optimization hint for
-        // `MultiArrayList.Slice.items`. The Rust `items()` already short-circuits
-        // on `capacity == 0`, so the assert is dropped.
         Some(self.list.items::<"reference_source_index", IndexInt>()[i])
     }
 
@@ -148,9 +144,8 @@ impl<'a> Slice<'a> {
     }
 }
 
-// PORT NOTE: Zig stored the full `MultiArrayList.Slice` and called
-// `.items(.source_index)` on each compare. The Rust `Slice<T>` is not `Copy`,
-// so we cache just the `source_index` column the adapter actually needs.
+// Caches just the `source_index` column the adapter actually needs
+// (`Slice<T>` is not `Copy`).
 pub(crate) struct Adapter<'a> {
     pub source_indices: &'a [IndexInt],
 }
@@ -165,5 +160,3 @@ impl<'a> ArrayHashAdapter<IndexInt, ()> for Adapter<'a> {
         *a == self.source_indices[b_index]
     }
 }
-
-// ported from: src/js_parser/ast/ServerComponentBoundary.zig
diff --git a/src/ast/stmt.rs b/src/ast/stmt.rs
index defe492bb31..4d6df898f75 100644
--- a/src/ast/stmt.rs
+++ b/src/ast/stmt.rs
@@ -14,24 +14,26 @@ pub struct Stmt {
 pub type Batcher = NewBatcher<Stmt>;
 
 impl Stmt {
-    /// Zig: `Stmt.Data.Store.reset()`. Associated wrapper so downstream crates
-    /// can call `crate::Stmt::data_store_reset()` without naming the
-    /// thread-local Store module path.
+    /// Associated wrapper so downstream crates can call
+    /// `crate::Stmt::data_store_reset()` without naming the thread-local
+    /// Store module path.
     #[inline]
     pub fn data_store_reset() {
         data::Store::reset();
     }
 
-    /// Zig: `Stmt.Data.Store.create()`.
+    /// Initializes the thread-local statement-data `Store` for the current
+    /// thread; counterpart of `data_store_reset()`.
     #[inline]
     pub fn data_store_create() {
         data::Store::create();
     }
 
-    /// Zig: `Stmt.Data.Store.assert()` — debug-only re-entrancy guard.
+    /// Debug-only "Store must be init'd" guard. The re-entrancy `Disabler`
+    /// check lives in `Store::append`.
     #[inline]
     pub fn data_store_assert() {
-        crate::DebugOnlyDisabler::<Stmt>::assert();
+        data::Store::assert();
     }
 
     pub fn assign(a: Expr, b: Expr) -> Stmt {
@@ -82,8 +84,8 @@ impl Stmt {
 }
 
 impl Default for Stmt {
-    /// Zig: `nullStmtData = Stmt.Data{ .s_empty = s_missing }` (P.zig) — used to
-    /// zero-init `loop_body` and bulk-fill stmt slices before population.
+    /// Used to zero-init `loop_body` and bulk-fill stmt slices before
+    /// population.
     #[inline]
     fn default() -> Self {
         Stmt {
@@ -95,25 +97,20 @@ impl Default for Stmt {
 
 const NONE: S::Empty = S::Empty {};
 
-// PORT NOTE: Zig `pub var icount: usize = 0;` is a plain mutable global (not
-// threadlocal), never read. Debug-only here so release doesn't pay a contended
-// `lock xadd` per Stmt across the bundler worker pool.
+// Debug-only so release doesn't pay a contended `lock xadd` per Stmt across
+// the bundler worker pool.
 #[cfg(debug_assertions)]
 pub static ICOUNT: AtomicUsize = AtomicUsize::new(0);
 
-/// Trait absorbing the Zig `switch (comptime StatementType)` tables in
-/// `init` / `alloc` / `allocate`. Each `S::*` payload type implements this to
-/// map itself onto the corresponding `Data` variant.
-///
-/// The Zig used three near-identical 32-arm comptime switches; in Rust the
-/// dispatch is the trait impl and the arm list is the `impl_statement_data!`
-/// invocation below — diff that list against the Zig switch.
+/// Each `S::*` payload type implements this to map itself onto the
+/// corresponding `Data` variant; the arm list is the `impl_statement_data!`
+/// invocation below.
 pub trait StatementData: Sized {
-    /// Wrap an already-allocated payload (Zig `Stmt.init` / `comptime_init`).
+    /// Wrap an already-allocated payload.
     fn wrap_ref(ptr: StoreRef<Self>) -> Data;
-    /// Store-append `self` and wrap (Zig `Stmt.alloc` / `comptime_alloc`).
+    /// Store-append `self` and wrap.
     fn store_alloc(self) -> Data;
-    /// Arena-allocate `self` and wrap (Zig `Stmt.allocate` / `allocateData`).
+    /// Arena-allocate `self` and wrap.
     fn arena_alloc(self, bump: &bun_alloc::Arena) -> Data;
 }
 
@@ -128,8 +125,6 @@ impl Stmt {
         }
     }
 
-    // Zig `comptime_alloc` — folded into `StatementData::store_alloc`; kept as a
-    // private helper for diff parity.
     #[inline]
     fn comptime_alloc<T: StatementData>(orig_data: T, loc: crate::Loc) -> Stmt {
         Stmt {
@@ -138,24 +133,17 @@ impl Stmt {
         }
     }
 
-    // Zig `allocateData` — folded into `StatementData::arena_alloc`.
     fn allocate_data<T: StatementData>(
         bump: &bun_alloc::Arena,
         orig_data: T,
         loc: crate::Loc,
     ) -> Stmt {
-        // `arena.create(@TypeOf(origData)) catch unreachable; value.* = origData;`
-        // → bump.alloc(orig_data), performed inside arena_alloc.
         Stmt {
             loc,
             data: orig_data.arena_alloc(bump),
         }
     }
 
-    // Zig `comptime_init` — `@unionInit(Data, tag_name, origData)`. In Rust the
-    // variant constructor IS the union-init; this helper collapses to identity
-    // and is absorbed by `StatementData::wrap_ref`.
-
     #[inline]
     pub fn alloc<T: StatementData>(orig_data: T, loc: crate::Loc) -> Stmt {
         data::Store::assert();
@@ -194,7 +182,7 @@ impl Stmt {
     }
 }
 
-// ─── StatementData impls (mirrors the 32-arm comptime switches) ────────────
+// ─── StatementData impls ───────────────────────────────────────────────────
 
 macro_rules! impl_statement_data {
     // Pointer-payload variants: stored via Store / arena.
@@ -210,7 +198,10 @@ macro_rules! impl_statement_data {
                 }
                 #[inline]
                 fn arena_alloc(self, bump: &bun_alloc::Arena) -> Data {
-                    // TODO(port): StoreRef vs &'bump — unify the arena ref type.
+                    // `StoreRef::from_bump` is the settled crate-wide arena-ref
+                    // convention (see its docs in nodes.rs); expr.rs
+                    // `arena_alloc` does the same. No separate `&'bump` ref
+                    // type is planned.
                     Data::$variant(StoreRef::from_bump(bump.alloc(self)))
                 }
             }
@@ -359,7 +350,7 @@ pub enum Data {
 }
 
 // ── Layout guards ─────────────────────────────────────────────────────────
-// Zig: `if (@sizeOf(Stmt) > 24) @compileLog(...)` (Stmt.zig:295). Every payload
+// Every payload
 // variant is either a `StoreRef<T>` (`#[repr(transparent)] NonNull<T>`, 8 bytes,
 // niche-carrying) or a ZST, so the union is one pointer word and the repr(Rust)
 // discriminant packs alongside it for `Data` = 16. `Stmt` = `Data` (16, align 8)
@@ -383,9 +374,9 @@ const _: () = assert!(
 );
 const _: () = assert!(core::mem::size_of::<StoreRef<S::SExpr>>() == core::mem::size_of::<usize>());
 
-/// Zig: `std.meta.eql(p.loop_body, stmt.data)` (visitStmt.zig) — tag compare,
-/// then payload compare. Payloads here are arena pointers (`StoreRef<T>`) or
-/// ZSTs, so this is tag + pointer-identity, never a deep structural compare.
+/// Tag compare, then payload compare. Payloads here are arena pointers
+/// (`StoreRef<T>`) or ZSTs, so this is tag + pointer-identity, never a deep
+/// structural compare.
 impl PartialEq for Data {
     fn eq(&self, other: &Self) -> bool {
         use Data::*;
@@ -429,10 +420,9 @@ impl PartialEq for Data {
 }
 impl Eq for Data {}
 
-// Zig field-style union accessors (`data.s_function`, `data.s_local`, …).
-// visitStmt and the printer port from Zig's `data.s_local.*` etc., which are
-// unchecked union field reads. Rust callers `.unwrap()` (or pattern-match) —
-// the `Option` is the cheapest sound encoding of Zig's UB-on-mismatch.
+// Field-style union accessors (`data.s_function()`, `data.s_local()`, …).
+// Callers `.unwrap()` (or pattern-match) — the `Option` is the cheapest
+// sound encoding of a tag mismatch.
 // Mirrors `expr::Data::e_*()`. Returns `Option<StoreRef<T>>` (Copy) for
 // pointer-payload variants and `Option<T>` by value for inline ZST variants.
 impl Data {
@@ -949,7 +939,7 @@ impl Data {
 }
 
 // `new_store!` emits `pub mod stmt_store { pub struct Store; ... }` with
-// `init/append/reset/destroy`. Type list mirrors Zig's `Data.Store = NewStore(&.{...}, 128)`.
+// `init/append/reset/destroy`.
 crate::new_store!(
     stmt_store,
     [
@@ -991,11 +981,6 @@ pub mod data {
     crate::thread_local_ast_store!(stmt_store::Store, "Stmt");
 }
 
-// Zig `pub fn StoredData(tag: Tag) type` — returns the payload type for a tag,
-// dereferencing pointer variants. Rust has no type-returning fns.
-// TODO(port): callers should use the `StatementData` trait or a per-variant
-// associated type; revisit once call sites are known.
-
 impl Stmt {
     pub fn cares_about_scope(&self) -> bool {
         match &self.data {
@@ -1024,5 +1009,3 @@ impl Stmt {
         }
     }
 }
-
-// ported from: src/js_parser/ast/Stmt.zig
diff --git a/src/ast/symbol.rs b/src/ast/symbol.rs
index aef56f39de7..08df9761b9c 100644
--- a/src/ast/symbol.rs
+++ b/src/ast/symbol.rs
@@ -166,11 +166,8 @@ pub struct Symbol {
     pub has_been_assigned_to: bool,
 }
 
-// TODO(port): Zig asserts @sizeOf(Symbol) == 88 and @alignOf(Symbol) == @alignOf([]const u8).
-// Rust default repr reorders fields and Option<NamespaceAlias> niche may differ
-// (likely needs #[repr(C)] or manual packing if the size is load-bearing).
-// const _: () = assert!(core::mem::size_of::<Symbol>() == 88);
-// const _: () = assert!(core::mem::align_of::<Symbol>() == core::mem::align_of::<crate::StoreStr>());
+// The size of `Symbol` is not load-bearing (no FFI, no serialization), so
+// there is intentionally no layout assert here.
 
 const INVALID_CHUNK_INDEX: u32 = u32::MAX;
 pub const INVALID_NESTED_SCOPE_SLOT: u32 = u32::MAX;
@@ -205,7 +202,6 @@ pub enum SlotNamespace {
     MangledProp,
 }
 
-// Zig: `pub const CountsArray = std.EnumArray(SlotNamespace, u32);` (nested decl).
 // Inherent associated types are nightly-only; expose as a free alias.
 pub(crate) type SlotNamespaceCountsArray = enum_map::EnumMap<SlotNamespace, u32>;
 
@@ -251,7 +247,6 @@ impl Symbol {
 
     #[inline]
     pub fn has_link(&self) -> bool {
-        // Zig: `self.link.tag != .invalid`
         self.link.get().is_valid()
     }
 }
@@ -522,8 +517,7 @@ impl Map {
 
     // Returns a raw *mut Symbol because callers (merge/follow/assign_chunk_index/
     // get_with_link) hold aliasing pointers into the NestedList and/or recurse through
-    // &mut self while holding the pointer. Mirrors Zig's `*const Map -> ?*Symbol`
-    // (interior mutability via Vec's raw `[*]T` ptr field).
+    // &mut self while holding the pointer.
     //
     // SOUNDNESS: the *mut is derived directly from `Vec.ptr: NonNull<T>` — a raw
     // pointer field whose provenance is independent of the `&self` borrow used to read
@@ -575,7 +569,6 @@ impl Map {
     }
 
     pub fn init(source_count: usize) -> Map {
-        // Zig: `arena.alloc([]Symbol, sourceCount)` (default_allocator) then NestedList.init.
         let mut v: NestedList = Vec::with_capacity(source_count);
         v.resize_with(source_count, Vec::new);
         Map {
@@ -583,11 +576,9 @@ impl Map {
         }
     }
 
-    // PORT NOTE: Zig aliased the caller's stack `[1]List` slot directly; that's
-    // unsound in Rust (would dangle on return). Take ownership of `list` and
-    // box it into a one-element NestedList instead.
-    // PERF(port): one extra allocation vs Zig — profile (single
-    // caller is the printer one-shot, cold).
+    // Takes ownership of `list` and boxes it into a one-element NestedList.
+    // PERF: one extra allocation — profile if needed (single caller is the
+    // printer one-shot, cold).
     // OWNERSHIP: returned `Map` is *owned*; the `Vec<List>` allocated here leaks if a
     // consumer parks it in `ManuallyDrop` (e.g. renamer.rs `MinifyRenamer.symbols`).
     pub fn init_with_one_list(list: Vec<Symbol>) -> Map {
@@ -633,7 +624,8 @@ impl Map {
     }
 
     pub fn follow_all(&mut self) {
-        // TODO(port): bun_perf::trace("Symbols.followAll") — RAII guard
+        // The returned `Ctx` is RAII and ends the span on drop.
+        let _trace = bun_perf::trace(bun_perf::PerfEvent::SymbolsFollowAll);
         // `link` is `Cell<Ref>`, so we can iterate the table by shared ref and
         // mutate `link` in place; `follow()` only takes `&self` and only touches
         // `link`, so the nested shared borrows coexist.
@@ -650,12 +642,11 @@ impl Map {
 
     /// Equivalent to followSymbols in esbuild.
     ///
-    /// PORT NOTE: Zig's body is naturally recursive (`follow(symbol.link)`).
-    /// Reshaped to an iterative two-phase walk so the per-hop work is just two
-    /// raw pointer adds and a load — no call frame, no `Option` unwrap, no
-    /// repeated tag/null guards. Semantics are identical to Zig's: every node
-    /// on the path from `ref_` to the union-find root has its `link` rewritten
-    /// to the root (full path compression).
+    /// An iterative two-phase walk so the per-hop work is just two raw
+    /// pointer adds and a load — no call frame, no `Option` unwrap, no
+    /// repeated tag/null guards. Every node on the path from `ref_` to the
+    /// union-find root has its `link` rewritten to the root (full path
+    /// compression).
     pub fn follow(&self, ref_: Ref) -> Ref {
         // Entry guard — `ref_` may be `Ref::None` / a SourceContentsSlice ref
         // (callers pass arbitrary Refs read out of AST nodes). After this,
@@ -696,20 +687,17 @@ impl Map {
         }
 
         // Phase 2: path compression. Rewrite `link` on the entry node and every
-        // intermediate node to point directly at `root` (matches the Zig
-        // recursion's post-order `symbol.link = link` writes). The `!=` gate
-        // mirrors Zig's `if (!symbol.link.eql(link))` to avoid a redundant
-        // store when the chain was already length-1. `link` is `Cell<Ref>`, so
-        // writes go through `&Symbol` safely.
+        // intermediate node to point directly at `root`. The `!=` gate avoids
+        // a redundant store when the chain was already length-1. `link` is
+        // `Cell<Ref>`, so writes go through `&Symbol` safely.
         if !link.eql(root) {
             symbol.link.set(root);
             loop {
                 let p = lookup(link);
                 let next = p.link.get();
                 // `next.eql(root)` ⇔ `p.link` already points at root —
-                // mirrors Zig's post-order `if (!symbol.link.eql(link))` gate
-                // and saves a redundant store on the last intermediate plus
-                // the otherwise-wasted lookup of `root` itself.
+                // saves a redundant store on the last intermediate plus the
+                // otherwise-wasted lookup of `root` itself.
                 if next.eql(root) || !next.is_valid() {
                     break;
                 }
@@ -728,7 +716,6 @@ impl Symbol {
         Symbol::is_kind_hoisted(self.kind)
     }
 
-    // Zig: pub const isKindFunction = Symbol.Kind.isFunction; (etc.)
     // Rust cannot alias inherent methods; forward explicitly.
     #[inline]
     pub fn is_kind_function(kind: Kind) -> bool {
@@ -747,5 +734,3 @@ impl Symbol {
         kind.is_private()
     }
 }
-
-// ported from: src/js_parser/ast/Symbol.zig
diff --git a/src/ast/target.rs b/src/ast/target.rs
index 6554d2ffc43..8ed486ed9ea 100644
--- a/src/ast/target.rs
+++ b/src/ast/target.rs
@@ -1,4 +1,4 @@
-//! `bundler/options.zig` `Target` — bundle target platform.
+//! Bundle target platform.
 //!
 //! Data-only enum + pure predicates. `to_api()` / `from(api::Target)` live in
 //! `bun_options_types::TargetExt` (would back-edge into the schema crate).
@@ -6,8 +6,7 @@
 use enum_map::Enum;
 use phf;
 
-/// Zig field default is `.browser` (`Target = .browser` in BundleOptions);
-/// keep `Default` so resolver can field-default it.
+/// Defaults to `Browser`; keep `Default` so resolver can field-default it.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Hash, Enum, strum::IntoStaticStr, Default)]
 pub enum Target {
@@ -74,8 +73,6 @@ impl Target {
     ];
 
     pub fn default_main_fields(self) -> &'static [&'static str] {
-        // Zig: `std.EnumArray(Target, []const string)` initialized at comptime.
-        // See bundler/options.zig for the rationale comments on each ordering.
         const NODE: &[&str] = &[Target::MAIN_FIELD_NAMES[2], Target::MAIN_FIELD_NAMES[1]];
         const BROWSER: &[&str] = &[
             Target::MAIN_FIELD_NAMES[0],
@@ -96,9 +93,8 @@ impl Target {
     }
 
     pub fn default_conditions(self) -> &'static [&'static [u8]] {
-        // PORT NOTE: Zig `default_conditions` is `std.EnumArray(Target, []const string)`
-        // — `string` is `[]const u8`. Callers (`ESMConditions::init`) take byte
-        // slices, so surface bytes directly rather than `&str`.
+        // Callers (`ESMConditions::init`) take byte slices, so surface
+        // bytes directly rather than `&str`.
         match self {
             Target::Node => &[b"node"],
             Target::Browser => &[b"browser", b"module"],
@@ -108,5 +104,3 @@ impl Target {
         }
     }
 }
-
-// ported from: src/options_types/BundleEnums.zig (Target)
diff --git a/src/ast/transpiler_cache.rs b/src/ast/transpiler_cache.rs
index 44d8e998d52..6ed85a06036 100644
--- a/src/ast/transpiler_cache.rs
+++ b/src/ast/transpiler_cache.rs
@@ -1,4 +1,4 @@
-//! `bun.jsc.RuntimeTranspilerCache` (src/jsc/RuntimeTranspilerCache.zig).
+//! Runtime transpiler cache.
 //!
 //! Single canonical struct, lowered to `bun_ast` so both the parser
 //! (`Features.runtime_transpiler_cache`) and the printer
@@ -19,8 +19,8 @@ pub struct RuntimeTranspilerCache {
     pub features_hash: Option<u64>,
     pub exports_kind: ExportsKind,
     /// Set by `put()` / `get()` when a cache hit returns transpiled output.
-    /// Zig: `?bun.String` — bundler/parser only store/read the bytes; T6 owns
-    /// the `bun.String` wrapper when surfacing to JS.
+    /// Bundler/parser only store/read the bytes; T6 owns the string wrapper
+    /// when surfacing to JS.
     pub output_code: Option<Box<[u8]>>,
     /// Opaque storage for `bun_bundler::cache::RuntimeTranspilerCacheEntry` —
     /// the concrete type lives a tier up and is round-tripped via cast.
diff --git a/src/ast/ts.rs b/src/ast/ts.rs
index b528bf9f481..e5ac4cdf55d 100644
--- a/src/ast/ts.rs
+++ b/src/ast/ts.rs
@@ -37,8 +37,8 @@ use crate::e::String as EString;
 /// hierarchical scope-based identifier lookup in JavaScript. Lookup now needs
 /// to search sibling scopes in addition to parent scopes. This is accomplished
 /// by sharing the map of exported members between all matching sibling scopes.
-// PORT NOTE: 'arena lifetime dropped — `EnumString` payload is a `StoreRef<EString>`
-// rather than an arena-borrowed reference (see the TODO on that variant).
+// The `EnumString` payload is a `StoreRef<EString>` (AST-store back-pointer)
+// rather than an arena-borrowed reference, matching the rest of the AST crate.
 pub struct TSNamespaceScope {
     /// This is specific to this namespace block. It's the argument of the
     /// immediately-invoked function expression that the namespace block is
@@ -131,7 +131,6 @@ pub enum Data {
     EnumNumber(f64),
     /// "enum ns { it = 'it' }"
     // LIFETIMES.tsv: ARENA — assigned from Expr.Data.e_string payload (AST Expr store).
-    // TODO(port): &'bump EString once 'bump threaded crate-wide.
     EnumString(crate::nodes::StoreRef<EString>),
     /// "enum ns { it = something() }"
     EnumProperty,
@@ -139,8 +138,6 @@ pub enum Data {
 
 impl Data {
     pub fn is_enum(&self) -> bool {
-        // PORT NOTE: Zig used `inline else` + comptime `@tagName` prefix check ("enum_").
-        // Expanded to an explicit match over the enum_* variants.
         matches!(
             self,
             Data::EnumNumber(_) | Data::EnumString(_) | Data::EnumProperty
@@ -174,9 +171,8 @@ pub enum Metadata {
     MSymbol,
     MPromise,
     MIdentifier(Ref),
-    // TODO(port): Zig used `std.ArrayListUnmanaged(Ref)`. This is an AST crate;
-    // if this list is arena-backed in practice, switch to
-    // `bun_alloc::ArenaVec<'bump, Ref>`.
+    // A heap `Vec` is used here because `Metadata` is lifetime-free.
+    // Decorator metadata is rare and the lists are tiny.
     MDot(Vec<Ref>),
 }
 
@@ -223,7 +219,7 @@ impl Metadata {
                     _ => Metadata::MObject,
                 };
             } else {
-                // PORT NOTE: reshaped for borrowck — copy Ref out before reassigning *result
+                // Reshaped for borrowck — copy Ref out before reassigning *result
                 if let Metadata::MIdentifier(r) = result {
                     let r = *r;
                     if let Metadata::MIdentifier(l) = left {
@@ -282,7 +278,7 @@ impl Metadata {
                     _ => Metadata::MObject,
                 };
             } else {
-                // PORT NOTE: reshaped for borrowck — copy Ref out before reassigning *result
+                // Reshaped for borrowck — copy Ref out before reassigning *result
                 if let Metadata::MIdentifier(r) = result {
                     let r = *r;
                     if let Metadata::MIdentifier(l) = left {
@@ -302,7 +298,4 @@ impl Metadata {
     }
 }
 
-// Zig file ends with `pub const Class = G.Class;` — re-export.
 pub use crate::g::Class;
-
-// ported from: src/js_parser/ast/TS.zig
diff --git a/src/ast/use_directive.rs b/src/ast/use_directive.rs
index d3079854422..4106d784fac 100644
--- a/src/ast/use_directive.rs
+++ b/src/ast/use_directive.rs
@@ -1,6 +1,6 @@
 use bun_core::strings;
 
-#[repr(u8)] // Zig: enum(u2)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum UseDirective {
     // TODO: Remove this, and provide `UseDirective.Optional` instead
@@ -49,5 +49,3 @@ impl UseDirective {
         None
     }
 }
-
-// ported from: src/js_parser/ast/UseDirective.zig
diff --git a/src/ast_jsc/lib.rs b/src/ast_jsc/lib.rs
index 57b5f9fb7ee..d31a6548088 100644
--- a/src/ast_jsc/lib.rs
+++ b/src/ast_jsc/lib.rs
@@ -89,5 +89,3 @@ pub fn log_to_js_array(this: &Log, global: &JSGlobalObject) -> JsResult<JSValue>
     let msgs: &[Msg] = this.msgs.as_slice();
     JSValue::create_array_from_iter(global, msgs.iter(), |msg| msg_to_js(msg.clone(), global))
 }
-
-// ported from: src/logger_jsc/logger_jsc.zig
diff --git a/src/base64/lib.rs b/src/base64/lib.rs
index 55a68d6e6f9..01910dc153e 100644
--- a/src/base64/lib.rs
+++ b/src/base64/lib.rs
@@ -3,10 +3,10 @@ use bun_simdutf_sys::simdutf::{self, SIMDUTFResult};
 pub use zig_base64::STANDARD_ALPHABET_CHARS;
 
 // ASCII control codes used in the ignore set below.
-const VT: u8 = 0x0B; // std.ascii.control_code.vt
-const FF: u8 = 0x0C; // std.ascii.control_code.ff
+const VT: u8 = 0x0B; // vertical tab
+const FF: u8 = 0x0C; // form feed
 
-// PORT NOTE: Zig evaluates this at comptime; const-initialized static lands in `.rodata`
+// Const-initialized static lands in `.rodata`
 // (no `Once` atomic on the `Integrity::parse` hot path).
 static MIXED_DECODER: zig_base64::Base64DecoderWithIgnore = {
     let mut decoder =
@@ -124,7 +124,6 @@ pub fn encode_alloc(source: &[u8]) -> Vec<u8> {
     let len = encode_len(source);
     let mut destination = vec![0u8; len];
     let encoded_len = encode(&mut destination, source);
-    // PORT NOTE: Zig built Vec<u8> from ptr/len/cap; here Vec already carries cap == len.
     destination.truncate(encoded_len);
     destination
 }
@@ -199,8 +198,7 @@ pub const fn url_safe_encode_len(source: &[u8]) -> usize {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// VLQ — moved from bun_sourcemap. Ground truth: src/sourcemap/VLQ.zig.
-// Lives here because the encoding is pure
+// VLQ — moved from bun_sourcemap. Lives here because the encoding is pure
 // base64-alphabet bit-packing with zero sourcemap-specific deps; bun_sourcemap
 // re-exports this for its own consumers.
 // ──────────────────────────────────────────────────────────────────────────
@@ -215,7 +213,6 @@ pub mod vlq {
     #[derive(Copy, Clone)]
     pub struct VLQ {
         pub bytes: [u8; VLQ_MAX_IN_BYTES],
-        /// This is a u8 and not a u4 because non^2 integers are really slow in Zig.
         pub len: u8,
     }
 
@@ -236,8 +233,8 @@ pub mod vlq {
             &self.bytes[0..self.len as usize]
         }
 
-        // PORT NOTE: Zig took `writer: anytype`. `std::io::Write` is used as the
-        // byte-sink trait; base64 stays a tier-0 leaf with no bun_io dep.
+        // `std::io::Write` is used as the byte-sink trait so base64 stays a
+        // tier-0 leaf with no bun_io dep.
         pub fn write_to(self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
             writer.write_all(&self.bytes[0..self.len as usize])?;
             Ok(())
@@ -255,13 +252,12 @@ pub mod vlq {
         }
     }
 
-    // Module-level alias so `bun_base64::vlq::encode(..)` mirrors the Zig file-scope fn.
+    // Module-level alias for `VLQ::encode`.
     #[inline]
     pub const fn encode(value: i32) -> VLQ {
         VLQ::encode(value)
     }
 
-    // PERF(port): was comptime-evaluated table in Zig — Rust const-eval matches.
     const VLQ_LOOKUP_TABLE: [VLQ; 256] = {
         let mut entries = [VLQ {
             bytes: [0; VLQ_MAX_IN_BYTES],
@@ -304,7 +300,6 @@ pub mod vlq {
         };
 
         // source mappings are limited to i32
-        // PERF(port): was `inline for` (unrolled) — profile if hot.
         let mut iter = 0;
         while iter < VLQ_MAX_IN_BYTES {
             let mut digit = vlq & 31;
@@ -336,7 +331,7 @@ pub mod vlq {
 
     const BASE64: &[u8; 64] = &crate::zig_base64::STANDARD_ALPHABET_CHARS;
 
-    /// `std.math.maxInt(u7)` — Rust has no native u7.
+    /// Maximum value of a 7-bit integer (Rust has no native u7).
     const U7_MAX: u8 = 127;
 
     // base64 stores values up to 7 bits
@@ -350,11 +345,10 @@ pub mod vlq {
         bytes
     };
 
-    // Shared body for `decode` / `decode_assume_valid`. The two .zig originals
-    // (src/sourcemap/VLQ.zig:104/135) differ only by two `bun.assert` lines;
-    // const-generic `ASSERT_VALID` is const-folded so codegen matches the
-    // hand-duplicated bodies.
-    // PERF(port): loop was `inline for` (unrolled) — profile if hot.
+    // Shared body for `decode` / `decode_assume_valid` (which differ only by
+    // two asserts); const-generic `ASSERT_VALID` is const-folded so codegen
+    // matches hand-duplicated bodies.
+    // PERF: loop is not unrolled — profile if hot.
     #[inline(always)]
     fn decode_impl<const ASSERT_VALID: bool>(encoded: &[u8], start: usize) -> VLQResult {
         let mut shift: u8 = 0;
@@ -368,7 +362,7 @@ pub mod vlq {
             if ASSERT_VALID {
                 debug_assert!(encoded_[i] < U7_MAX); // invalid base64 character
             }
-            // `@as(u7, @truncate(...))` → mask to 7 bits
+            // mask to 7 bits
             let index = BASE64_LUT[(encoded_[i] & 0x7f) as usize] as u32;
             if ASSERT_VALID {
                 debug_assert!(index != U7_MAX as u32); // invalid base64 character
@@ -467,7 +461,7 @@ pub mod zig_base64 {
     }
 
     /// Standard Base64 codecs, with padding
-    // PORT NOTE: Zig comptime → const-initialized `static` (lives in `.rodata`, no `Once`).
+    // Const-initialized `static` (lives in `.rodata`, no `Once`).
     pub static STANDARD: Codecs = Codecs {
         alphabet_chars: STANDARD_ALPHABET_CHARS,
         pad_char: Some(b'='),
@@ -488,9 +482,6 @@ pub mod zig_base64 {
     pub(crate) const URL_SAFE_ALPHABET_CHARS: [u8; 64] =
         *b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
-    // PORT NOTE: dropped `standard_pad_char`/`standard_encoder`/`standard_decoder`
-    // @compileError deprecation stubs — no Rust equivalent for use-site compile errors.
-
     #[derive(Copy, Clone)]
     pub struct Base64Encoder {
         pub alphabet_chars: [u8; 64],
@@ -544,7 +535,6 @@ pub mod zig_base64 {
         }
 
         pub fn encode_without_size_check(&self, dest: &mut [u8], source: &[u8]) -> usize {
-            // PORT NOTE: Zig used u12/u4; Rust uses u16/u8 with explicit masking.
             let mut acc: u16 = 0;
             let mut acc_len: u8 = 0;
             let mut out_idx: usize = 0;
@@ -641,7 +631,6 @@ pub mod zig_base64 {
             if self.pad_char.is_some() && !source.len().is_multiple_of(4) {
                 return Err(Error::InvalidPadding);
             }
-            // PORT NOTE: Zig used u12/u4; Rust uses u16/u8 with explicit masking.
             let mut acc: u16 = 0;
             let mut acc_len: u8 = 0;
             let mut dest_idx: usize = 0;
@@ -740,11 +729,10 @@ pub mod zig_base64 {
             wrote: &mut usize,
         ) -> Result<(), Error> {
             let decoder = &self.decoder;
-            // PORT NOTE: Zig used u12/u4; Rust uses u16/u8 with explicit masking.
             let mut acc: u16 = 0;
             let mut acc_len: u8 = 0;
-            // PORT NOTE: reshaped `defer { wrote.* = dest_idx; }` into direct mutation
-            // of `*wrote` so it is always current on every return path.
+            // `*wrote` is mutated directly (rather than once before return)
+            // so it is always current on every return path.
             *wrote = 0;
             let mut leftover_idx: Option<usize> = None;
 
@@ -1003,7 +991,7 @@ pub mod zig_base64 {
 // `LinkerContext.rs::css_modules_hash_shim`). `bun_css` re-exports this as
 // `css_modules::hash` for its in-crate callers.
 //
-// Spec: `src/css/css_modules.zig:hash` — wyhash(u64) of the formatted args,
+// Behavior: wyhash(u64) of the formatted args,
 // truncated to u32, url-safe-base64-encoded into a bump-allocated slice. If
 // `at_start` and the first encoded byte is a digit, prefix `_` (CSS idents
 // can't start with a digit).
@@ -1017,10 +1005,8 @@ pub fn wyhash_url_safe<'a>(
 ) -> &'a [u8] {
     use std::io::Write as _;
 
-    // PERF(port): was stack-fallback alloc (StackFallbackAllocator 128B) — profile if hot.
     let mut hasher = bun_wyhash::Wyhash11::init(0);
-    // PORT NOTE: std.fmt.count + allocPrint collapsed; write into a scratch
-    // Vec then hash. Freed immediately (Zig used stack-fallback for this).
+    // Write into a scratch Vec then hash; freed immediately.
     let mut fmt_str: Vec<u8> = Vec::with_capacity(128);
     write!(&mut fmt_str, "{}", args).expect("unreachable");
     hasher.update(&fmt_str);
@@ -1030,9 +1016,8 @@ pub fn wyhash_url_safe<'a>(
 
     let encode_len = simdutf_encode_len_url_safe(h_bytes.len());
 
-    // PORT NOTE: Zig reused fmt_str buffer when encode_len > 128 - at_start; arena makes the
-    // distinction moot (both arms allocate from bump). Always alloc fresh slice here.
-    // PERF(port): was buffer reuse for large encode_len — profile if hot.
+    // Always alloc a fresh slice from the arena.
+    // PERF: no buffer reuse for large encode_len — profile if hot.
     let slice_to_write: &mut [u8] =
         bump.alloc_slice_fill_default(encode_len + usize::from(at_start));
 
@@ -1045,7 +1030,7 @@ pub fn wyhash_url_safe<'a>(
         && base64_encoded_hash[0] >= b'0'
         && base64_encoded_hash[0] <= b'9'
     {
-        // std.mem.copyBackwards: overlapping copy, dest > src → copy_within
+        // Overlapping copy, dest > src → copy_within.
         slice_to_write.copy_within(0..base64_encoded_hash_len, 1);
         slice_to_write[0] = b'_';
         return &slice_to_write[0..base64_encoded_hash_len + 1];
@@ -1053,5 +1038,3 @@ pub fn wyhash_url_safe<'a>(
 
     &slice_to_write[0..base64_encoded_hash_len]
 }
-
-// ported from: src/base64/base64.zig
diff --git a/src/boringssl/lib.rs b/src/boringssl/lib.rs
index 62af27833c7..65852405cf7 100644
--- a/src/boringssl/lib.rs
+++ b/src/boringssl/lib.rs
@@ -1,5 +1,5 @@
 // TODO: move all custom functions from the translated file into this file, then
-// the translated file can be provided by `zig translate-c`
+// the translated file can be generated by bindgen.
 
 #![warn(unused_must_use)]
 use core::ffi::{c_int, c_void};
@@ -10,8 +10,8 @@ pub use bun_boringssl_sys as boring;
 use bun_cares_sys as c_ares;
 use bun_core::strings;
 
-// MOVE_DOWN: ported from `src/runtime/api/bun/x509.zig::isSafeAltName`.
-// Lives here so `boringssl` does not depend on `bun_runtime` (tier-6).
+// MOVE_DOWN: lives here so `boringssl` does not depend on `bun_runtime`
+// (tier-6).
 pub mod x509 {
     /// Returns `true` iff `name` contains no characters that would require
     /// escaping in a subjectAltName entry.
@@ -77,7 +77,7 @@ pub fn load() {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Extra FFI surface not yet exposed by `bun_boringssl_sys` (hand-curated
-// subset). Ground truth: src/boringssl_sys/boringssl.zig + openssl/ssl.h.
+// subset). Ground truth: openssl/ssl.h.
 // Remove once the bindgen pipeline lands these in the sys crate.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -127,16 +127,14 @@ unsafe impl Sync for CtxStore {}
 static CTX_STORE: std::sync::OnceLock<CtxStore> = std::sync::OnceLock::new();
 
 std::thread_local! {
-    // Zig: `threadlocal var auto_crypto_buffer_pool: ?*CRYPTO_BUFFER_POOL = null`
-    // (boringssl.zig:19225). One pool per thread, lazily allocated on first
-    // `SSL_CTX.setup()` call from that thread.
+    // One pool per thread, lazily allocated on the first `ssl_ctx_setup()`
+    // call from that thread.
     static AUTO_CRYPTO_BUFFER_POOL: Cell<*mut CRYPTO_BUFFER_POOL> =
         const { Cell::new(ptr::null_mut()) };
 }
 
-/// Zig: `SSL_CTX.setup(ctx)` (boringssl.zig:19204) — install the per-thread
-/// `CRYPTO_BUFFER_POOL` and set the cipher list to BoringSSL's
-/// `SSL_DEFAULT_CIPHER_LIST` (`"ALL"`).
+/// Install the per-thread `CRYPTO_BUFFER_POOL` and set the cipher list to
+/// BoringSSL's `SSL_DEFAULT_CIPHER_LIST` (`"ALL"`).
 ///
 /// # Safety
 /// `ctx` must be a live `SSL_CTX*`.
@@ -156,9 +154,8 @@ pub unsafe fn ssl_ctx_setup(ctx: *mut boring::SSL_CTX) {
 }
 
 pub fn init_client() -> *mut boring::SSL {
-    // SAFETY: BoringSSL FFI; single-threaded startup assumption (matches Zig).
+    // SAFETY: BoringSSL FFI; single-threaded startup assumption.
     unsafe {
-        // Zig: `if (ctx_store != null) _ = boring.SSL_CTX_up_ref(ctx_store.?);`
         // Bump the refcount on every call after the first; the first call's
         // `SSL_CTX_new` already returns refcount = 1.
         if let Some(stored) = CTX_STORE.get() {
@@ -166,7 +163,7 @@ pub fn init_client() -> *mut boring::SSL {
         }
         let ctx = CTX_STORE
             .get_or_init(|| {
-                // Zig: `SSL_CTX.init()` — see boringssl.zig:19197. Three steps:
+                // Three steps:
                 //   1. SSL_CTX_new(TLS_with_buffers_method())
                 //   2. setCustomVerify(noop_custom_verify) → SSL_CTX_set_custom_verify(ctx, 0, cb)
                 //   3. setup() → CRYPTO_BUFFER_POOL_new + set0_buffer_pool + set_cipher_list("ALL")
@@ -178,9 +175,7 @@ pub fn init_client() -> *mut boring::SSL {
             .0
             .as_ptr();
 
-        // Zig: `SSL.init(ctx)` = `SSL_new(ctx)`
         let ssl = boring::SSL_new(ctx);
-        // Zig: `setIsClient(true)` = `SSL_set_connect_state(ssl)`
         boring::SSL_set_connect_state(ssl);
 
         ssl
@@ -460,9 +455,3 @@ pub fn check_server_identity(ssl_ptr: &mut boring::SSL, hostname: &[u8]) -> bool
     }
     false
 }
-
-// NOTE: `pub const ERR_toJS = @import("../runtime/crypto/boringssl_jsc.zig").ERR_toJS;`
-// is intentionally dropped — *_jsc alias; in Rust the JS conversion lives in the
-// `bun_runtime`/`*_jsc` crate as an extension method.
-
-// ported from: src/boringssl/boringssl.zig
diff --git a/src/boringssl_sys/boringssl.rs b/src/boringssl_sys/boringssl.rs
index ffa1a3ef806..771747b0c54 100644
--- a/src/boringssl_sys/boringssl.rs
+++ b/src/boringssl_sys/boringssl.rs
@@ -1,12 +1,9 @@
 //! Hand-rolled BoringSSL FFI surface.
 //!
-//! Ground truth: `src/boringssl_sys/boringssl.zig` (translate-c output) and
-//! `vendor/boringssl/include/openssl/*.h`. This file exposes only the subset
-//! of symbols Bun's Rust crates actually consume — it is **not** a full
-//! bindgen dump. When the bindgen pipeline lands this module is replaced
-//! wholesale.
-//
-// ported from: src/boringssl_sys/boringssl.zig
+//! Ground truth: `vendor/boringssl/include/openssl/*.h`. This file exposes
+//! only the subset of symbols Bun's Rust crates actually consume — it is
+//! **not** a full bindgen dump. When the bindgen pipeline lands this module
+//! is replaced wholesale.
 
 use core::ffi::{c_char, c_int, c_long, c_uint, c_void};
 
@@ -147,7 +144,7 @@ pub union env_md_ctx_md_data {
 
 /// `struct env_md_ctx_st` — laid out to match
 /// `vendor/boringssl/include/openssl/digest.h` so it can live by-value on the
-/// Rust side (the Zig port stores it inline, not behind `EVP_MD_CTX_new`).
+/// Rust side (stored inline, not behind `EVP_MD_CTX_new`).
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct EVP_MD_CTX {
@@ -439,12 +436,10 @@ unsafe extern "C" {
 // Typed STACK_OF(...) inline wrappers
 //
 // BoringSSL defines these as `static inline` in C, so they have no exported
-// symbol — they bottom out on the untyped `sk_*` ABI above. Mirrors the
-// translate-c bodies in `boringssl.zig`.
+// symbol — they bottom out on the untyped `sk_*` ABI above.
 // ═══════════════════════════════════════════════════════════════════════════
 
-/// Per-stack free callback type used by `sk_GENERAL_NAME_pop_free`
-/// (matches Zig's `stack_GENERAL_NAME_free_func`).
+/// Per-stack free callback type used by `sk_GENERAL_NAME_pop_free`.
 pub(crate) type sk_GENERAL_NAME_free_func = unsafe extern "C" fn(*mut struct_stack_st_GENERAL_NAME);
 
 #[inline]
@@ -570,7 +565,7 @@ pub const RSA_PKCS1_OAEP_PADDING: c_int = 4;
 pub(crate) type CRYPTO_refcount_t = u32;
 
 /// `ossl_ssize_t` — signed counterpart of `size_t` for BoringSSL "length or -1"
-/// parameters. Mirrors the `isize` definition in `boringssl.zig`.
+/// parameters.
 pub(crate) type ossl_ssize_t = isize;
 
 /// `bio_info_cb` — callback type for `BIO_METHOD.callback_ctrl`.
@@ -594,7 +589,7 @@ pub struct BIO_METHOD {
     pub callback_ctrl: Option<unsafe extern "C" fn(*mut BIO, c_int, bio_info_cb) -> c_long>,
 }
 
-/// `struct bio_st` — exposed by-value because the Zig side reaches into
+/// `struct bio_st` — exposed by-value because callers reach into
 /// `flags`/`num`/`ptr` directly when implementing custom BIO backends.
 #[repr(C)]
 #[derive(Copy, Clone)]
diff --git a/src/brotli/lib.rs b/src/brotli/lib.rs
index debf1039bde..636e087a4b0 100644
--- a/src/brotli/lib.rs
+++ b/src/brotli/lib.rs
@@ -23,9 +23,7 @@ pub struct DecoderOptions {
     pub params: DecoderParams,
 }
 
-/// Zig: `std.enums.EnumFieldStruct(c.BrotliDecoderParameter, bool, false)` —
-/// one `bool` per `BrotliDecoderParameter` variant, default `false`.
-// TODO(port): if BrotliDecoderParameter grows more variants, mirror them here.
+/// One `bool` per `BrotliDecoderParameter` variant, default `false`.
 #[derive(Default)]
 pub struct DecoderParams {
     pub large_window: bool,
@@ -49,10 +47,6 @@ impl Default for DecoderOptions {
 
 pub struct BrotliReaderArrayList<'a> {
     pub input: &'a [u8],
-    // PORT NOTE: reshaped for borrowck — Zig kept a by-value copy of the
-    // ArrayListUnmanaged in `list` and wrote it back to `*list_ptr` on every
-    // `readAll` (defer). `Vec<u8>` is not `Copy`, so we operate on `list_ptr`
-    // directly and drop the redundant `list` + `list_allocator` fields.
     pub list_ptr: &'a mut Vec<u8>,
     pub brotli: *mut c::BrotliDecoder,
     pub state: ReaderState,
@@ -69,7 +63,6 @@ pub struct BrotliReaderArrayList<'a> {
 pub use bun_core::compress::State as ReaderState;
 
 impl<'a> BrotliReaderArrayList<'a> {
-    // Zig: `pub const new = bun.TrivialNew(BrotliReaderArrayList);`
     #[inline]
     pub fn new(value: Self) -> Box<Self> {
         Box::new(value)
@@ -98,7 +91,6 @@ impl<'a> BrotliReaderArrayList<'a> {
         list: &'a mut Vec<u8>,
         options: &DecoderOptions,
     ) -> Result<Box<Self>, Error> {
-        // TODO(port): narrow error set
         Ok(Self::new(Self::init_with_options(
             input,
             list,
@@ -117,7 +109,6 @@ impl<'a> BrotliReaderArrayList<'a> {
         finish_flush_op: c::BrotliEncoderOperation,
         full_flush_op: c::BrotliEncoderOperation,
     ) -> Result<Self, Error> {
-        // TODO(port): narrow error set
         if !BrotliDecoder::initialize_brotli() {
             return Err(err!("BrotliFailedToLoad"));
         }
@@ -166,10 +157,6 @@ impl<'a> BrotliReaderArrayList<'a> {
     }
 
     pub fn read_all(&mut self, is_done: bool) -> Result<(), Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig's `defer this.list_ptr.* = this.list;` is gone — we
-        // mutate through `list_ptr` directly (see field note above).
-
         if self.state == ReaderState::End || self.state == ReaderState::Error {
             return Ok(());
         }
@@ -266,8 +253,6 @@ impl<'a> Drop for BrotliReaderArrayList<'a> {
             // Created by BrotliDecoder::create_instance; destroyed exactly once here.
             BrotliDecoder::destroy_instance(self.brotli_mut());
         }
-        // PORT NOTE: Zig's `bun.destroy(this)` is implicit — callers hold a
-        // `Box<Self>` and dropping it frees the allocation.
     }
 }
 
@@ -298,7 +283,6 @@ impl BrotliCompressionStream {
         finish_flush_op: c::BrotliEncoderOperation,
         full_flush_op: c::BrotliEncoderOperation,
     ) -> Result<Self, Error> {
-        // TODO(port): narrow error set
         // SAFETY: brotli FFI constructor; alloc/free are valid extern "C"
         // fns and opaque is null (unused by our allocator).
         let instance = unsafe {
@@ -336,7 +320,6 @@ impl BrotliCompressionStream {
     // next compress_stream/destroy call. Tying it to `&mut self` prevents
     // overlapping calls that would invalidate it.
     pub fn write_chunk(&mut self, input: &[u8], last: bool) -> Result<&[u8], Error> {
-        // TODO(port): narrow error set
         self.total_in += input.len();
         let op = if last {
             self.finish_flush_op
@@ -360,7 +343,6 @@ impl BrotliCompressionStream {
     }
 
     pub fn write(&mut self, input: &[u8], last: bool) -> Result<&[u8], Error> {
-        // TODO(port): narrow error set
         if self.state == CompressionState::End || self.state == CompressionState::Error {
             return Ok(b"");
         }
@@ -369,12 +351,9 @@ impl BrotliCompressionStream {
     }
 
     pub fn end(&mut self) -> Result<&[u8], Error> {
-        // TODO(port): narrow error set
-        // Zig: `defer this.state = .End` — runs on BOTH ok and error paths.
-        // PORT NOTE: reshaped for borrowck — `compress_stream`'s output borrows
-        // `&mut *self.brotli`, so we set `self.state` first and inline
-        // write/write_chunk("", true). Net state matches Zig (defer overrides
-        // any intermediate `Error` back to `End`).
+        // `state` ends up `End` on both ok and error paths; set it before
+        // calling `compress_stream` because its output borrows
+        // `&mut *self.brotli`.
         if matches!(self.state, CompressionState::End | CompressionState::Error) {
             self.state = CompressionState::End;
             return Ok(b"");
@@ -395,8 +374,8 @@ impl BrotliCompressionStream {
         BrotliWriter::init(self, writable)
     }
 
-    // TODO(port): Zig's `writer()` returned a `std.Io.GenericWriter` adapter.
-    // Rust callers should use `writer_context()` directly (it impls Write).
+    // The returned `BrotliWriter` implements `bun_io::Write` itself, so this
+    // is just an alias for `writer_context()`.
     pub fn writer<W: bun_io::Write>(&mut self, writable: W) -> BrotliWriter<'_, W> {
         self.writer_context(writable)
     }
@@ -411,16 +390,12 @@ impl Drop for BrotliCompressionStream {
     }
 }
 
-// Zig: `fn NewWriter(comptime InputWriter: type) type { return struct {...} }`
 pub struct BrotliWriter<'a, W> {
     pub compressor: &'a mut BrotliCompressionStream,
     pub input_writer: W,
 }
 
 impl<'a, W: bun_io::Write> BrotliWriter<'a, W> {
-    // Zig: `WriteError = error{BrotliCompressionError} || InputWriter.Error`
-    // PORT NOTE: error-set union collapsed to `bun_core::Error`.
-
     pub fn init(compressor: &'a mut BrotliCompressionStream, input_writer: W) -> Self {
         Self {
             compressor,
@@ -435,15 +410,24 @@ impl<'a, W: bun_io::Write> BrotliWriter<'a, W> {
     }
 
     pub fn end(&mut self) -> Result<(), Error> {
-        // PORT NOTE: Zig declared `!usize` but the body has no return — the
-        // Zig fn would fail to compile if ever instantiated. Port as `()`.
         let decompressed = self.compressor.end()?;
         self.input_writer.write_all(decompressed)?;
         Ok(())
     }
-
-    // TODO(port): `std.Io.GenericWriter` adapter — provide `impl bun_io::Write`
-    // if any caller needs the trait object.
 }
 
-// ported from: src/brotli/brotli.zig
+impl<W: bun_io::Write> bun_io::Write for BrotliWriter<'_, W> {
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Error> {
+        self.write(buf).map(|_| ())
+    }
+
+    fn flush(&mut self) -> Result<(), Error> {
+        // Drain the encoder first so compressed-so-far bytes reach the sink:
+        // an empty write runs `compress_stream` with the stream's configured
+        // `flush_op` (emits pending output for FLUSH-configured streams; a
+        // no-op for PROCESS). `end()` is still required to finalize.
+        let out = self.compressor.write(b"", false)?;
+        self.input_writer.write_all(out)?;
+        self.input_writer.flush()
+    }
+}
diff --git a/src/brotli_sys/brotli_c.rs b/src/brotli_sys/brotli_c.rs
index a8c78320334..846e7ebede6 100644
--- a/src/brotli_sys/brotli_c.rs
+++ b/src/brotli_sys/brotli_c.rs
@@ -16,9 +16,8 @@ pub const BROTLI_SHARED_DICTIONARY_SERIALIZED: c_int = 1;
 pub type enum_BrotliSharedDictionaryType = c_uint;
 pub type BrotliSharedDictionaryType = enum_BrotliSharedDictionaryType;
 
-// pub extern fn BrotliSharedDictionaryCreateInstance(alloc_func: brotli_alloc_func, free_func: brotli_free_func, opaque: ?*anyopaque) ?*BrotliSharedDictionary;
-// pub extern fn BrotliSharedDictionaryDestroyInstance(dict: ?*BrotliSharedDictionary) void;
-// pub extern fn BrotliSharedDictionaryAttach(dict: ?*BrotliSharedDictionary, type: BrotliSharedDictionaryType, data_size: usize, data: [*]const u8) c_int;
+// Not bound: BrotliSharedDictionaryCreateInstance, BrotliSharedDictionaryDestroyInstance,
+// BrotliSharedDictionaryAttach (unused).
 
 unsafe extern "C" {
     // Opaque handle by reference + scalars only.
@@ -109,7 +108,6 @@ impl BrotliDecoder {
                 decoded_ptr,
             )
         };
-        // PORT NOTE: reshaped for borrowck — Zig mutated `decoded.len` in place via `*[]u8`
         // SAFETY: decoded_ptr points to the same allocation; decoded_size <= original len per brotli contract
         *decoded = unsafe { core::slice::from_raw_parts_mut(decoded_ptr, decoded_size) };
         result
@@ -183,7 +181,7 @@ impl BrotliDecoder {
     }
 }
 
-#[repr(u32)] // Zig: enum(c_uint)
+#[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliDecoderResult {
     err = 0,
@@ -192,14 +190,12 @@ pub enum BrotliDecoderResult {
     needs_more_output = 3,
 }
 
-// NOTE: brotli_c.zig (translate-c output) defines this error-code table three times
-// (loose `BROTLI_DECODER_*` consts, a subset `BrotliDecoderErrorCode` enum, and the
-// full `BrotliDecoderErrorCode2` enum). They are intentionally collapsed here into the
-// single complete enum below; `BrotliDecoderErrorCode` is kept as an alias for FFI
-// signatures. Do not re-add the duplicates on a mechanical re-port.
+// NOTE: the duplicate error-code tables the upstream brotli headers define are
+// intentionally collapsed into the single enum below; `BrotliDecoderErrorCode`
+// is kept as an alias so FFI signatures keep their upstream names.
 pub type BrotliDecoderErrorCode = BrotliDecoderErrorCode2;
 
-#[repr(i32)] // Zig: enum(c_int)
+#[repr(i32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliDecoderErrorCode2 {
     NO_ERROR = 0,
@@ -237,7 +233,7 @@ pub enum BrotliDecoderErrorCode2 {
 pub const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: c_int = 0;
 pub const BROTLI_DECODER_PARAM_LARGE_WINDOW: c_int = 1;
 
-#[repr(u32)] // Zig: enum(c_uint)
+#[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliDecoderParameter {
     DISABLE_RING_BUFFER_REALLOCATION = 0,
@@ -256,7 +252,7 @@ pub const BROTLI_MODE_GENERIC: c_int = 0;
 pub const BROTLI_MODE_TEXT: c_int = 1;
 pub const BROTLI_MODE_FONT: c_int = 2;
 
-#[repr(u32)] // Zig: enum(c_uint)
+#[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliEncoderMode {
     generic = 0,
@@ -280,7 +276,7 @@ pub const BROTLI_PARAM_NPOSTFIX: c_int = 7;
 pub const BROTLI_PARAM_NDIRECT: c_int = 8;
 pub const BROTLI_PARAM_STREAM_OFFSET: c_int = 9;
 
-#[repr(u32)] // Zig: enum(c_uint)
+#[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliEncoderParameter {
     mode = 0,
@@ -363,7 +359,7 @@ bun_opaque::opaque_ffi! {
     pub struct BrotliEncoder;
 }
 
-#[repr(u32)] // Zig: enum(c_uint)
+#[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum BrotliEncoderOperation {
     process = 0,
@@ -389,8 +385,8 @@ impl<'a> Default for CompressionResult<'a> {
     }
 }
 
-// PORT NOTE: Zig's `BrotliEncoder.Operation` flattened to module-level alias
-// (inherent associated types are unstable in Rust).
+// `BrotliEncoder.Operation` is a module-level alias because inherent
+// associated types are unstable in Rust.
 pub type Operation = BrotliEncoderOperation;
 
 impl BrotliEncoder {
@@ -490,5 +486,3 @@ pub const BROTLI_MAX_QUALITY: c_int = 11;
 pub const BROTLI_DEFAULT_QUALITY: c_int = 11;
 pub const BROTLI_DEFAULT_WINDOW: c_int = 22;
 pub const BROTLI_DEFAULT_MODE: c_int = BROTLI_MODE_GENERIC;
-
-// ported from: src/brotli_sys/brotli_c.zig
diff --git a/src/bun.js.rs b/src/bun.js.rs
index 971b9d5d46d..a4d802653ae 100644
--- a/src/bun.js.rs
+++ b/src/bun.js.rs
@@ -1,8 +1,8 @@
-//! Port of src/bun.js.zig — entry point for `bun run <file>` / standalone executables.
+//! Entry point for `bun run <file>` / standalone executables.
 //!
 //! The `Run` struct (the per-process VM driver) is defined once in
 //! `crate::cli::run_command` so the CLI dispatch path can call it directly
-//! without a crate-cycle; this module re-exports it under the Zig namespace
+//! without a crate-cycle; this module re-exports it as
 //! `bun.js.Run` and hosts the handful of helpers that other crates reach for
 //! (`apply_standalone_runtime_flags`, `fail_with_build_error`, the
 //! `Bun__on{Resolve,Reject}EntryPointResult` host fns).
@@ -14,7 +14,6 @@ use bun_standalone_graph::StandaloneModuleGraph::{Flags as GraphFlags, Standalon
 // Thin re-exports (mirrors `pub const X = @import(...)` at file top).
 pub use crate::api;
 pub use crate::webcore;
-pub use bun_jsc as jsc_mod; // TODO(port): naming — Zig exposed this as `bun.js.jsc`
 
 /// Canonical `Run` lives in `cli::run_command`; re-export so callers that
 /// expect `bun.js.Run` resolve to the single definition.
diff --git a/src/bun_alloc/BufferFallbackAllocator.rs b/src/bun_alloc/BufferFallbackAllocator.rs
index 1138e6d7f80..fd8af352912 100644
--- a/src/bun_alloc/BufferFallbackAllocator.rs
+++ b/src/bun_alloc/BufferFallbackAllocator.rs
@@ -1,6 +1,6 @@
 //! An allocator that attempts to allocate from a provided buffer first,
 //! falling back to another allocator when the buffer is exhausted.
-//! Unlike `std.heap.StackFallbackAllocator`, this does not own the buffer.
+//! The buffer is borrowed, not owned.
 
 use core::ffi::c_void;
 
@@ -92,5 +92,3 @@ unsafe fn free(ctx: *mut c_void, buf: &mut [u8], alignment: Alignment, ra: usize
     }
     self_.fallback.raw_free(buf, alignment, ra)
 }
-
-// ported from: src/bun_alloc/BufferFallbackAllocator.zig
diff --git a/src/bun_alloc/MaxHeapAllocator.rs b/src/bun_alloc/MaxHeapAllocator.rs
index 71546a6b600..ed94fcc2cf6 100644
--- a/src/bun_alloc/MaxHeapAllocator.rs
+++ b/src/bun_alloc/MaxHeapAllocator.rs
@@ -6,8 +6,7 @@ use core::ptr::NonNull;
 use crate::MAX_ALIGN_T as MAX_ALIGN;
 use crate::{Alignment, Allocator};
 
-/// Zig backed `array_list` with `std.array_list.AlignedManaged(u8, .of(std.c.max_align_t))`
-/// so the returned pointer is guaranteed aligned to `max_align_t`. Rust `Vec<u8>`
+/// The returned pointer must be aligned to `max_align_t`. Rust `Vec<u8>`
 /// allocates with align 1, which would violate the `alignment <= MAX_ALIGN`
 /// contract. Store a raw `MAX_ALIGN`-aligned buffer instead.
 pub struct MaxHeapAllocator {
@@ -25,12 +24,10 @@ unsafe impl Send for MaxHeapAllocator {}
 unsafe impl Sync for MaxHeapAllocator {}
 
 impl MaxHeapAllocator {
-    /// Zig: `fn alloc(ptr, len, alignment, _) ?[*]u8`
     pub fn alloc(&mut self, len: usize, alignment: Alignment, _ret_addr: usize) -> Option<*mut u8> {
         debug_assert!(alignment.to_byte_units() <= MAX_ALIGN);
-        // Zig: `self.array_list.items.len = 0;` — reuse the existing buffer.
+        // Reuse the existing buffer.
         self.len = 0;
-        // Zig: `ensureTotalCapacity(len) catch return null`
         if self.capacity < len {
             // Grow (or first-allocate) to at least `len`, MAX_ALIGN-aligned.
             let new_layout = Layout::from_size_align(len, MAX_ALIGN).ok()?;
@@ -53,7 +50,6 @@ impl MaxHeapAllocator {
         Some(self.ptr?.as_ptr())
     }
 
-    /// Zig: `fn resize(...) bool { @panic("not implemented") }`
     pub fn resize(
         &mut self,
         _buf: &mut [u8],
@@ -64,7 +60,7 @@ impl MaxHeapAllocator {
         panic!("not implemented");
     }
 
-    /// Zig: `fn free(...) void {}` — no-op (single owned buffer freed on Drop).
+    /// No-op (single owned buffer freed on Drop).
     pub fn free(&mut self, _buf: &mut [u8], _alignment: Alignment, _ret_addr: usize) {}
 
     pub fn reset(&mut self) {
@@ -72,15 +68,13 @@ impl MaxHeapAllocator {
     }
 
     /// Borrow the allocator for a scope; `reset()` is called automatically when
-    /// the returned guard drops. Mirrors Zig's `defer max_heap_allocator.reset()`
-    /// at loop-iteration scope without an ad-hoc `scopeguard`.
+    /// the returned guard drops.
     pub fn scope(&mut self) -> MaxHeapScope<'_> {
         MaxHeapScope { inner: self }
     }
 
-    // PORT NOTE: reshaped out-param constructor. Zig's `init(self: *Self, allocator) -> std.mem.Allocator`
-    // both initialized `self` and returned a vtable+ptr pair. In Rust the caller constructs
-    // `MaxHeapAllocator::init()` and obtains `&dyn Allocator` by borrowing the result.
+    // The caller constructs `MaxHeapAllocator::init()` and obtains
+    // `&dyn Allocator` by borrowing the result.
     pub fn init() -> Self {
         Self {
             ptr: None,
@@ -89,7 +83,6 @@ impl MaxHeapAllocator {
         }
     }
 
-    /// Zig: `pub fn isInstance(allocator) bool { return allocator.vtable == &vtable; }`
     pub fn is_instance(alloc: &dyn Allocator) -> bool {
         alloc.is::<Self>()
     }
@@ -133,7 +126,6 @@ impl Allocator for MaxHeapAllocator {}
 
 impl Drop for MaxHeapAllocator {
     fn drop(&mut self) {
-        // Zig: `pub fn deinit` — freed `array_list`.
         if let Some(ptr) = self.ptr.take() {
             // SAFETY: `ptr`/`capacity` were produced by `alloc`/`realloc` above
             // with `MAX_ALIGN` alignment.
@@ -146,5 +138,3 @@ impl Drop for MaxHeapAllocator {
         }
     }
 }
-
-// ported from: src/bun_alloc/MaxHeapAllocator.zig
diff --git a/src/bun_alloc/MimallocArena.rs b/src/bun_alloc/MimallocArena.rs
index 2b0b1795e1d..84c46d1421e 100644
--- a/src/bun_alloc/MimallocArena.rs
+++ b/src/bun_alloc/MimallocArena.rs
@@ -1,15 +1,13 @@
-//! Port of `src/bun_alloc/MimallocArena.zig`.
-//!
 //! A per-heap mimalloc allocator. Unlike `bumpalo::Bump`, every allocation
 //! made through this arena is individually freeable (via `mi_free`) and
 //! resizable (via `mi_heap_realloc_aligned`), so `Vec<T, &MimallocArena>`
 //! does **not** leak the old buffer on grow. `Drop`/`reset()` bulk-free the
-//! whole heap with `mi_heap_destroy`, matching Zig's `deinit`.
+//! whole heap with `mi_heap_destroy`.
 //
 // PERF NOTE: a previous iteration layered a bump-chunk allocator and a cached
 // `mi_theap_t*` here. Reverted: the theap is per-OS-thread while
 // `MimallocArena: Send`, and the bump layer caused #53599's UAF when mimalloc
-// recycled a destroyed `mi_heap_t*` slot. Zig parity is plain `mi_heap_malloc`.
+// recycled a destroyed `mi_heap_t*` slot. Plain `mi_heap_malloc` is correct.
 // If `_mi_heap_theap` thrash resurfaces in profiles, the supported fix is
 // `mi_heap_set_default(heap)` for the parse scope, not manual theap caching.
 //!
@@ -39,11 +37,11 @@ pub(crate) static HEAP_NEW_COUNT: core::sync::atomic::AtomicUsize =
 pub(crate) static HEAP_DESTROY_COUNT: core::sync::atomic::AtomicUsize =
     core::sync::atomic::AtomicUsize::new(0);
 
-// ── Debug-only thread-ownership guard (Zig: `bun.safety.ThreadLock`) ──────
+// ── Debug-only thread-ownership guard ─────────────────────────────────────
 //
 // `bun_alloc` sits below `bun_core` in the crate graph, so we cannot reuse
-// `bun_core::ThreadLock`. This is the minimal subset needed to mirror Zig's
-// `ci_assert` same-thread check on the `mi_heap_*` allocation paths: a per-
+// `bun_core::ThreadLock`. This is the minimal subset needed for a same-thread
+// check on the `mi_heap_*` allocation paths: a per-
 // thread monotone id stamped at `MimallocArena::new()` and asserted on every
 // alloc/realloc. `mi_free` is documented thread-safe and is left unchecked.
 
@@ -65,7 +63,7 @@ fn debug_thread_stamp() -> u64 {
 }
 
 /// A mimalloc heap. Owns a `mi_heap_t`; all allocations are bulk-freed on
-/// `Drop` (Zig: `MimallocArena.deinit` → `mi_heap_destroy`).
+/// `Drop` via `mi_heap_destroy`.
 ///
 /// Implements [`core::alloc::Allocator`] for `&MimallocArena`, so it can back
 /// `Vec<T, &MimallocArena>` / `Box<T, &MimallocArena>` with real per-allocation
@@ -75,11 +73,11 @@ pub struct MimallocArena {
     /// `true` when `heap` came from `mi_heap_new()` and must be
     /// `mi_heap_destroy`ed on `Drop`/`reset()`. `false` when borrowing the
     /// process-wide `mi_heap_main()` (see [`Self::borrowing_default`]) — Drop
-    /// is then a no-op and allocations live for the process lifetime, matching
-    /// Zig's `default_allocator` shape for callers that just need an `&Arena`
+    /// is then a no-op and allocations live for the process lifetime — for
+    /// callers that just need an `&Arena`
     /// without paying `mi_heap_new` + `mi_heap_destroy`.
     owns: bool,
-    /// Zig: `thread_lock: bun.safety.ThreadLock` (debug-only). Stamped on
+    /// Debug-only thread-ownership stamp. Stamped on
     /// `new()`/`reset()`; asserted on every `mi_heap_*` alloc/realloc path.
     /// Compiles out in release so the struct stays one pointer wide.
     #[cfg(debug_assertions)]
@@ -87,17 +85,17 @@ pub struct MimallocArena {
 }
 
 // SAFETY: mimalloc heaps are not generally thread-safe for allocation from
-// multiple threads, but `mi_free` may be called from any thread, and the
-// Zig original guards same-thread use via `ThreadLock` in debug. We expose
-// `Send` so an arena can be moved into a worker thread (matching Zig's
-// `MimallocArena` being passed to thread-pool workers); concurrent `&self`
-// allocation across threads is the caller's responsibility, same as Zig.
+// multiple threads, but `mi_free` may be called from any thread, and
+// same-thread allocation is enforced by `assert_owning_thread()` in debug
+// builds. We expose `Send` so an arena can be moved into a worker thread
+// (e.g. passed to thread-pool workers); concurrent `&self`
+// allocation across threads is the caller's responsibility.
 unsafe impl Send for MimallocArena {}
 // SAFETY: `Sync` is required because the bundler embeds `&MimallocArena` in
 // `Send + Sync` contexts (worker tasks hold a shared ref for `mi_free` /
 // `owns_ptr`), but `mi_heap_malloc*`/`mi_heap_realloc*` are NOT safe under
 // concurrent `&self`. The contract — enforced by `assert_owning_thread()` in
-// debug builds, mirroring Zig's `ci_assert` `ThreadLock` — is that only the
+// debug builds — is that only the
 // thread that constructed (or last `reset()`) the arena may allocate from it.
 // Cross-thread `deallocate` is permitted (mimalloc `mi_free` is thread-safe).
 unsafe impl Sync for MimallocArena {}
@@ -110,7 +108,6 @@ impl Default for MimallocArena {
 }
 
 impl MimallocArena {
-    /// Zig: `MimallocArena.init()` — `mi_heap_new() orelse bun.outOfMemory()`.
     #[inline]
     pub fn new() -> Self {
         #[cfg(debug_assertions)]
@@ -132,8 +129,8 @@ impl MimallocArena {
     /// `mi_malloc`/`mi_free` and live until individually freed (or process
     /// exit for `into_bump_slice`-style leaks).
     ///
-    /// Use this where Zig threads `bun.default_allocator` through an
-    /// `Allocator`-shaped parameter and the Rust port needs an `&Arena` but
+    /// Use this where a `default_allocator`-shaped parameter needs an
+    /// `&Arena` but
     /// the `mi_heap_new` + `mi_heap_destroy` pair is measurable overhead on a
     /// hot, short-lived path (e.g. `Bunfig::parse` on `bun -e ''` startup).
     #[inline]
@@ -153,7 +150,7 @@ impl MimallocArena {
         }
     }
 
-    /// Zig: `Borrowed.assertThreadLock()` — debug-only check that the calling
+    /// Debug-only check that the calling
     /// thread is the one that constructed (or last `reset()`) this arena.
     /// Guards every `mi_heap_*` allocation path so the over-broad `Sync` impl
     /// cannot silently corrupt mimalloc's per-heap free lists.
@@ -176,13 +173,13 @@ impl MimallocArena {
         }
     }
 
-    /// Alias for [`Self::new`] — matches the Zig spelling.
+    /// Alias for [`Self::new`].
     #[inline]
     pub fn init() -> Self {
         Self::new()
     }
 
-    /// Raw `mi_heap_t*` (Zig: `Borrowed.getMimallocHeap`).
+    /// Raw `mi_heap_t*`.
     ///
     /// This is the sole accessor for the `heap` field. A `&Heap`-returning
     /// accessor is intentionally **not** provided: `mimalloc::Heap` is an
@@ -232,29 +229,22 @@ impl MimallocArena {
         self.heap = NonNull::new(heap).unwrap_or_else(|| crate::out_of_memory());
         // `&mut self` proves exclusive access; re-stamp the debug thread-lock
         // so an arena `Send`-moved to a worker and then reset there may
-        // allocate on that worker (Zig has no equivalent because its
-        // `MimallocArena` is not moved post-init).
+        // allocate on that worker.
         #[cfg(debug_assertions)]
         self.owning_thread
             .store(debug_thread_stamp(), Ordering::Relaxed);
     }
 
-    /// Zig: `std.heap.ArenaAllocator.reset(.{.retain_with_limit = limit})`.
-    ///
     /// Retains the warm heap while its in-use footprint is `<= limit`, and
     /// only then falls back to a full [`Self::reset`] (`mi_heap_destroy` +
     /// `mi_heap_new`). Returns `true` when the heap was retained, `false` when
-    /// it was recycled — mirroring `ArenaAllocator.reset`'s "reuse succeeded"
-    /// boolean.
+    /// it was recycled.
     ///
-    /// **Why this isn't a no-op-or-full-reset.** Zig's `std.heap.ArenaAllocator`
-    /// is a bump allocator: `.retain_with_limit` rewinds the bump cursor to
-    /// offset 0 (logically freeing every allocation) but keeps up to `limit`
-    /// bytes of *backing buffer* committed, so the next cycle's allocations
-    /// reuse those warm pages instead of faulting in (and zeroing) fresh ones.
-    /// A `mi_heap_t` has no "free all blocks but keep the pages" primitive —
+    /// **Why this isn't a no-op-or-full-reset.** The ideal behavior would be
+    /// "free every block but keep the warm pages (up to `limit`)" — but
+    /// a `mi_heap_t` has no "free all blocks but keep the pages" primitive —
     /// the only bulk-free is `mi_heap_destroy`, which also hands the pages back
-    /// to mimalloc (which may purge/decommit them). So the faithful mapping is
+    /// to mimalloc (which may purge/decommit them). So the policy is
     /// "keep the *whole* heap — blocks and all — while it is still small;
     /// recycle it once it grows past `limit`". The retained blocks are dead
     /// (arena callers never `mi_free`; `AstAlloc::deallocate` is a no-op by
@@ -265,13 +255,12 @@ impl MimallocArena {
     /// small cycles. `limit` is the RSS/CPU knob: a tighter cap trades warm
     /// pages for lower steady-state RSS; a looser one does the reverse.
     ///
-    /// (An earlier port made this an unconditional `reset()` on the theory
+    /// (An earlier iteration made this an unconditional `reset()` on the theory
     /// that mimalloc's per-thread segment cache already keeps pages warm
     /// across `mi_heap_destroy`/`mi_heap_new`. In practice, with a lower RSS
     /// ceiling and mimalloc's purge timer, the recycled page is often already
     /// decommitted by the time the next cycle touches it, so the round-trip
-    /// re-commits and re-zeroes it — exactly the cost `.retain_with_limit`
-    /// exists to avoid. Hence the cap-gated retain.)
+    /// re-commits and re-zeroes it. Hence the cap-gated retain.)
     ///
     /// **Why `mi_heap_collect` is not an alternative to the cap.** When the
     /// caller's allocations are individually freed before the cycle ends (most
@@ -309,14 +298,14 @@ impl MimallocArena {
         false
     }
 
-    /// Zig: `MimallocArena.gc()` → `mi_heap_collect(heap, false)`.
+    /// `mi_heap_collect(heap, false)`.
     #[inline]
     pub fn gc(&self) {
         // SAFETY: `self.heap` is a live heap.
         unsafe { mimalloc::mi_heap_collect(self.heap_ptr(), false) };
     }
 
-    /// Zig: `MimallocArena.helpCatchMemoryIssues()` — debug-only collect of
+    /// Debug-only collect of
     /// both this heap and the global mimalloc state to surface UAF early.
     #[inline]
     pub fn help_catch_memory_issues(&self) {
@@ -359,7 +348,7 @@ impl MimallocArena {
         total
     }
 
-    /// Zig: `MimallocArena.ownsPtr()` → `mi_heap_contains(heap, p)`.
+    /// `mi_heap_contains(heap, p)`.
     /// `mi_heap_contains` only tests address-range membership and never
     /// dereferences `addr`, so this takes the address as `usize` (not a raw
     /// pointer — there is no caller precondition to uphold).
@@ -369,7 +358,7 @@ impl MimallocArena {
         unsafe { mimalloc::mi_heap_contains(self.heap_ptr(), core::ptr::without_provenance(addr)) }
     }
 
-    /// Zig: `Borrowed.alignedAlloc` — `mi_heap_malloc[_aligned]` on this
+    /// `mi_heap_malloc[_aligned]` on this
     /// arena's heap.
     #[inline]
     fn aligned_alloc(&self, len: usize, align: usize) -> *mut u8 {
@@ -379,7 +368,7 @@ impl MimallocArena {
         unsafe { heap_alloc_maybe_aligned(self.heap_ptr(), len, align) }
     }
 
-    /// Zig: `vtable_resize` — in-place expand/shrink, no relocation.
+    /// In-place expand/shrink, no relocation.
     /// Returns `true` if the block now has at least `new_len` bytes.
     #[inline]
     pub fn resize_in_place(&self, ptr: NonNull<u8>, _old_len: usize, new_len: usize) -> bool {
@@ -519,17 +508,17 @@ impl MimallocArena {
         unsafe { core::slice::from_raw_parts_mut(dst.as_ptr(), len) }
     }
 
-    // ── StdAllocator vtable bridge (Zig: `heap_allocator_vtable`) ────────
+    // ── StdAllocator vtable bridge ────────────────────────────────────────
 
-    /// Zig: `MimallocArena.arena()` — erase to the fat `{ptr, vtable}`
+    /// Erase to the fat `{ptr, vtable}`
     /// `StdAllocator` so this arena can flow through code that still threads
-    /// the Zig-style allocator handle.
+    /// an allocator handle.
     #[inline]
     pub fn std_allocator(&self) -> crate::StdAllocator {
         // `ctx` is `*const MimallocArena` (not the inner `*mut Heap`) so the
         // vtable thunks can reach `assert_owning_thread()`. They load
-        // `heap_ptr()` from it on every call; this is one extra indirection vs
-        // Zig (`ctx == heap`). The only consumer of `ctx` is this vtable;
+        // `heap_ptr()` from it on every call; this is one extra indirection
+        // vs `ctx == heap`. The only consumer of `ctx` is this vtable;
         // `is_instance()` compares the *vtable* pointer, not `ctx`.
         crate::StdAllocator {
             ptr: ptr::from_ref(self).cast_mut().cast(),
@@ -537,7 +526,7 @@ impl MimallocArena {
         }
     }
 
-    /// Zig: `MimallocArena.isInstance` — does `alloc` dispatch through one of
+    /// Does `alloc` dispatch through one of
     /// this module's vtables (per-heap or process-global mimalloc)?
     #[inline]
     pub fn is_instance(alloc: &crate::StdAllocator) -> bool {
@@ -545,7 +534,7 @@ impl MimallocArena {
             || core::ptr::eq(alloc.vtable, &raw const GLOBAL_MIMALLOC_VTABLE)
     }
 
-    /// Zig: `MimallocArena.getThreadLocalDefault()` — a `StdAllocator` that
+    /// A `StdAllocator` that
     /// routes through the process-wide `mi_malloc`/`mi_free` (no per-heap ctx).
     /// In mimalloc v3 these are already thread-local-fast, so there is no
     /// separate per-thread default heap to cache.
@@ -568,7 +557,7 @@ impl Drop for MimallocArena {
         }
         #[cfg(debug_assertions)]
         HEAP_DESTROY_COUNT.fetch_add(1, Ordering::Relaxed);
-        // Zig: `deinit` → `mi_heap_destroy`. Destroys the heap and bulk-frees
+        // `mi_heap_destroy` destroys the heap and bulk-frees
         // every block still allocated in it without running per-block free.
         // SAFETY: `self.heap` is a live heap obtained from `mi_heap_new` and
         // is destroyed exactly once here.
@@ -668,7 +657,7 @@ unsafe impl Allocator for &MimallocArena {
     }
 }
 
-/// Zig's `Borrowed.alignedAlloc` body — pick `mi_heap_malloc_aligned` only
+/// Pick `mi_heap_malloc_aligned` only
 /// when `align > MI_MAX_ALIGN_SIZE`, otherwise the cheaper `mi_heap_malloc`,
 /// then debug-assert the returned block's usable size covers `len`.
 ///
@@ -695,12 +684,12 @@ unsafe fn heap_alloc_maybe_aligned(heap: *mut mimalloc::Heap, len: usize, align:
     p.cast()
 }
 
-// ── StdAllocator vtable (Zig: `heap_allocator_vtable`) ───────────────────
+// ── StdAllocator vtable (per-arena) ──────────────────────────────────────
 
 unsafe fn vtable_alloc(ctx: *mut c_void, len: usize, a: crate::Alignment, _ra: usize) -> *mut u8 {
     // SAFETY: `ctx` is the `*const MimallocArena` stashed by
     // `std_allocator()`; the `StdAllocator` borrow it was built from is
-    // still live (Zig contract: an `Allocator` does not outlive its backing).
+    // still live (contract: an `Allocator` does not outlive its backing).
     let arena = unsafe { &*ctx.cast::<MimallocArena>() };
     arena.aligned_alloc(len, a.to_byte_units())
 }
@@ -746,7 +735,7 @@ unsafe fn vtable_free(_ctx: *mut c_void, buf: &mut [u8], a: crate::Alignment, _r
     unsafe { crate::basic::mi_free_checked(buf.as_mut_ptr().cast(), buf.len(), a.to_byte_units()) }
 }
 
-/// Zig: `heap_allocator_vtable` — per-arena thunks; `ctx` is the
+/// Per-arena thunks; `ctx` is the
 /// `*const MimallocArena` stashed by `std_allocator()`.
 pub(crate) static HEAP_ALLOCATOR_VTABLE: crate::AllocatorVTable = crate::AllocatorVTable {
     alloc: vtable_alloc,
@@ -755,7 +744,7 @@ pub(crate) static HEAP_ALLOCATOR_VTABLE: crate::AllocatorVTable = crate::Allocat
     free: vtable_free,
 };
 
-// ── Global-mimalloc vtable (Zig: `global_mimalloc_vtable`) ───────────────
+// ── Global-mimalloc vtable ────────────────────────────────────────────────
 // Process-wide `mi_malloc`/`mi_free` — no heap ctx. Used by
 // `get_thread_local_default()` / `Default::allocator()`.
 
@@ -768,7 +757,6 @@ unsafe fn global_vtable_alloc(
     crate::default_alloc::malloc_aligned(len, a.to_byte_units()).cast()
 }
 
-/// Zig: `global_mimalloc_vtable`.
 pub(crate) static GLOBAL_MIMALLOC_VTABLE: crate::AllocatorVTable = crate::AllocatorVTable {
     alloc: global_vtable_alloc,
     resize: crate::basic::MimallocAllocator::resize_with_default_allocator,
@@ -914,5 +902,3 @@ impl<'a, T> ArenaVecExt<'a, T> for crate::BabyVec<'a, T> {
         *self.allocator()
     }
 }
-
-// ported from: src/bun_alloc/MimallocArena.zig
diff --git a/src/bun_alloc/NullableAllocator.rs b/src/bun_alloc/NullableAllocator.rs
index f3ee890f10c..7c3ab364ec7 100644
--- a/src/bun_alloc/NullableAllocator.rs
+++ b/src/bun_alloc/NullableAllocator.rs
@@ -1,13 +1,11 @@
-//! A nullable allocator the same size as `std.mem.Allocator`.
+//! A nullable allocator the same size as `StdAllocator`.
 
 use core::ffi::c_void;
 
 use crate::{Alignment, AllocatorVTable, StdAllocator};
 
-/// PORT NOTE: Zig stored `{ ptr: *anyopaque, vtable: ?*const VTable }` and
-/// recovered the `Allocator` by null-checking the vtable. Rust models the same
-/// thing directly — `vtable: Option<&'static AllocatorVTable>` carries the
-/// niche, so the struct is identical in size to `StdAllocator`.
+/// `vtable: Option<&'static AllocatorVTable>` carries the niche,
+/// so the struct is identical in size to `StdAllocator`.
 #[derive(Clone, Copy)]
 pub struct NullableAllocator {
     ptr: *mut c_void,
@@ -84,9 +82,8 @@ impl NullableAllocator {
     pub fn free(&self, bytes: &[u8]) {
         if let Some(allocator) = self.get() {
             if crate::String::is_wtf_allocator(allocator) {
-                // avoid calling `std.mem.Allocator.free` as it sets the memory to undefined
                 // SAFETY: `bytes` is reborrowed mutably only for the vtable signature; the
-                // WTF deallocator treats it as opaque (Zig passes `[]u8`).
+                // WTF deallocator treats it as opaque and never writes through it.
                 let buf = unsafe {
                     core::slice::from_raw_parts_mut(bytes.as_ptr().cast_mut(), bytes.len())
                 };
@@ -103,5 +100,3 @@ const _: () = assert!(
     core::mem::size_of::<NullableAllocator>() == core::mem::size_of::<StdAllocator>(),
     "Expected the sizes to be the same."
 );
-
-// ported from: src/bun_alloc/NullableAllocator.zig
diff --git a/src/bun_alloc/ast_alloc.rs b/src/bun_alloc/ast_alloc.rs
index dc3e38bca46..894c5913993 100644
--- a/src/bun_alloc/ast_alloc.rs
+++ b/src/bun_alloc/ast_alloc.rs
@@ -2,7 +2,7 @@
 //!
 //! Strategy B for the require-cache ESM leak (docs/BABYLIST_REPLACEMENT.md):
 //! `G::DeclList` / `G::PropertyList` / `ExprNodeList` / `ClassStaticBlock::stmts`
-//! were ported from Zig `BabyList<T>` to global-heap `Vec<T>`. The AST *nodes*
+//! use global-heap `Vec<T>`. The AST *nodes*
 //! that embed those `Vec` headers live in `ASTMemoryAllocator`'s `MimallocArena`
 //! and are bulk-freed (no `Drop`) on `enter()` → `arena.reset()`, so the global
 //! buffers leak — one full AST's worth of `Vec` backing storage per imported
@@ -36,8 +36,8 @@ use core::ptr::NonNull;
 use crate::{MimallocArena, mimalloc};
 
 // The parser builds thousands of tiny `AstVec`s; allocations `<= BUMP_MAX` are
-// carved from a 16 KB buffer stored inline in the state (mirroring Zig's
-// `StackFallbackAllocator`), so the small case never touches mimalloc. The
+// carved from a 16 KB buffer stored inline in the state, so the small case
+// never touches mimalloc. The
 // cursor, the buffer, and the spill target live in one struct, so none of them
 // can outlive the others.
 
@@ -388,8 +388,8 @@ fn heap_alloc(layout: Layout) -> *mut u8 {
 //   the "pointers may be freed by any clone" requirement is satisfied.
 // - `Send + Sync` (auto-derived for a fieldless ZST) is sound: each call reads
 //   the *calling* thread's `AST_ALLOC`, and allocation is gated to that thread
-//   by `ASTMemoryAllocator`'s single-threaded contract (mirrored from Zig's
-//   `ThreadLock`; see `MimallocArena::assert_owning_thread`). The no-op
+//   by `ASTMemoryAllocator`'s single-threaded contract (see
+//   `MimallocArena::assert_owning_thread`). The no-op
 //   `deallocate` removes the only cross-thread hazard a `Vec<_,A>: Send` would
 //   otherwise introduce.
 unsafe impl Allocator for AstAlloc {
@@ -439,8 +439,7 @@ unsafe impl Allocator for AstAlloc {
         // bookkeeping) *without* moving the block — so it stays in whatever heap
         // owns it and never thrashes the `heap → theap` TLS lookup. When it
         // succeeds there is no allocation, no `memcpy`, and no abandoned block,
-        // matching `MimallocArena`'s `resize_in_place` (Zig's arena `remap` is
-        // `mi_expand`-then-`mi_realloc`).
+        // matching `MimallocArena`'s `resize_in_place`.
         //
         // Gated on:
         //  - `old.size() > BUMP_MAX`: smaller blocks may be bump-chunk interior
@@ -512,7 +511,7 @@ impl AstAlloc {
         Vec::with_capacity_in(cap, AstAlloc)
     }
 
-    /// `<[T]>::to_vec` parity (Zig: `BabyList.fromSlice`).
+    /// `<[T]>::to_vec` parity.
     #[inline]
     pub fn vec_from_slice<T: Clone>(items: &[T]) -> AstVec<T> {
         let mut v = Vec::with_capacity_in(items.len(), AstAlloc);
diff --git a/src/bun_alloc/baby_vec.rs b/src/bun_alloc/baby_vec.rs
index 1938e6a824e..4cb2acc0208 100644
--- a/src/bun_alloc/baby_vec.rs
+++ b/src/bun_alloc/baby_vec.rs
@@ -1,10 +1,8 @@
 //! `BabyVec<'a, T>` — arena-backed growable array with `u32` length/capacity.
 //!
-//! Port target: `BabyList(T)` (collections/baby_list.zig) =
-//! `(ptr: [*]T, len: u32, cap: u32)` = 16 B. The Rust port stores the owning
-//! `&'a MimallocArena` inline (lifetime-checked allocator vs Zig passing the
-//! allocator at every `append(allocator, ..)` call site), so 24 B instead of
-//! 16. Still 8 B smaller than `Vec<T, &'a MimallocArena>` (32 B), which
+//! `(ptr: [*]T, len: u32, cap: u32)` plus the owning
+//! `&'a MimallocArena` stored inline (lifetime-checked allocator), so 24 B.
+//! Still 8 B smaller than `Vec<T, &'a MimallocArena>` (32 B), which
 //! matters for AST node lists embedded in `Part` / `BundledAst` columns.
 //!
 //! `len`/`cap` are stored as `u32` (`usize` on the public API for ergonomics).
@@ -304,7 +302,7 @@ impl<'a, T> BabyVec<'a, T> {
 
     /// Drain all elements. Only the full range is supported — the `RangeBounds`
     /// parameter exists for drop-in `ArenaVec` alias parity with `Vec::drain(..)`.
-    /// Zig `BabyList` has no partial drain and no caller needs one.
+    /// No caller needs a partial drain.
     pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> IntoIter<'a, T> {
         use core::ops::Bound::*;
         // Const-folded for `..`; guards release builds against partial ranges.
diff --git a/src/bun_alloc/basic.rs b/src/bun_alloc/basic.rs
index 17f072e7f93..12284df6fb8 100644
--- a/src/bun_alloc/basic.rs
+++ b/src/bun_alloc/basic.rs
@@ -4,10 +4,6 @@ use crate::{default_alloc, mimalloc};
 // TODO(refactor): consider reshaping the vtable struct into `trait Allocator` impls.
 use crate::{Alignment, AllocatorVTable, StdAllocator};
 
-// Zig: `const log = bun.Output.scoped(.mimalloc, .hidden);` — `Output.scoped`
-// lives in `bun_core`, which depends on this crate, so the hidden-scope debug
-// tracing is dropped here rather than re-declared as a no-op stub.
-
 /// # Safety
 /// `ptr` must have been allocated by mimalloc with the given `size`/`align`.
 #[inline(always)]
@@ -204,5 +200,3 @@ pub unsafe fn free_without_size(ptr: *mut c_void) {
     // SAFETY: caller contract — ptr is null or was allocated by mimalloc; mi_free accepts null
     unsafe { mimalloc::mi_free(ptr) }
 }
-
-// ported from: src/bun_alloc/basic.zig
diff --git a/src/bun_alloc/fallback.rs b/src/bun_alloc/fallback.rs
index 43fdd0e6af4..7322bd350e0 100644
--- a/src/bun_alloc/fallback.rs
+++ b/src/bun_alloc/fallback.rs
@@ -4,9 +4,8 @@ use crate::Alignment;
 
 pub mod z;
 
-/// `std.heap.c_allocator` — a `std.mem.Allocator` value backed by libc
-/// malloc/free. Exposed as a ZST with inherent `raw_*` methods mirroring the
-/// Zig vtable so the zeroing wrapper in `z.rs` can layer on top.
+/// An allocator backed by libc malloc/free. Exposed as a ZST with inherent
+/// `raw_*` methods so the zeroing wrapper in `z.rs` can layer on top.
 #[derive(Clone, Copy, Default)]
 pub struct CAllocator;
 
@@ -16,7 +15,7 @@ impl CAllocator {
     #[inline]
     pub fn raw_alloc(&self, len: usize, alignment: Alignment, _ret_addr: usize) -> Option<*mut u8> {
         // libc malloc guarantees alignment to `max_align_t`; for larger
-        // alignments use the aligned variant (Zig's `CAllocator` does the same).
+        // alignments use the aligned variant.
         let align = alignment.to_byte_units();
         // SAFETY: libc malloc/aligned_alloc are sound for any nonzero size.
         let ptr = unsafe {
@@ -48,8 +47,8 @@ impl CAllocator {
         new_len: usize,
         _ret_addr: usize,
     ) -> bool {
-        // Zig `CAllocator.resize`: in-place only — succeed on shrink or if the
-        // backing allocation already has enough usable size; never relocate.
+        // In-place only — succeed on shrink or if the backing allocation
+        // already has enough usable size; never relocate.
         if new_len <= buf.len() {
             return true;
         }
@@ -67,8 +66,7 @@ impl CAllocator {
         }
         #[cfg(windows)]
         {
-            // Zig's `std.heap.CAllocator` probes `_msize` on Windows. Our
-            // over-aligned path uses `_aligned_malloc`, and MSDN forbids
+            // Our over-aligned path uses `_aligned_malloc`, and MSDN forbids
             // `_msize` on those blocks — must use `_aligned_msize` instead.
             unsafe extern "C" {
                 fn _msize(p: *mut c_void) -> usize;
@@ -127,8 +125,6 @@ pub use z::ALLOCATOR as z_allocator;
 /// and must go through [`CAllocator::raw_free`] so `_aligned_free` is used.
 pub unsafe fn free_without_size(ptr: *mut c_void) {
     // SAFETY: caller contract — ptr is null or a plain malloc-family allocation;
-    // libc free accepts null. Same precondition as Zig `std.c.free`.
+    // libc free accepts null.
     unsafe { libc::free(ptr) }
 }
-
-// ported from: src/bun_alloc/fallback.zig
diff --git a/src/bun_alloc/fallback/z.rs b/src/bun_alloc/fallback/z.rs
index 5fae0a21981..7d3f185db88 100644
--- a/src/bun_alloc/fallback/z.rs
+++ b/src/bun_alloc/fallback/z.rs
@@ -2,28 +2,25 @@ use core::ffi::c_void;
 use core::ptr;
 
 use crate::{Alignment, Allocator};
-// `std.heap.c_allocator` — the libc-malloc-backed allocator.
+// The libc-malloc-backed allocator.
 use super::C_ALLOCATOR as c_allocator;
 
 /// A fallback zero-initializing allocator.
 //
-// Zig: `pub const allocator = Allocator{ .ptr = undefined, .vtable = &vtable };`
-// `std.mem.Allocator` is a `{ptr, vtable}` fat struct — the Rust mapping is
-// `&dyn bun_alloc::Allocator`, so the public export is a ZST implementing the
-// trait. Consumers borrow `&ALLOCATOR` (coerces to `&dyn Allocator`).
+// The public export is a ZST implementing the `Allocator` trait. Consumers
+// borrow `&ALLOCATOR` (coerces to `&dyn Allocator`).
 pub static ALLOCATOR: Z = Z;
 
 #[derive(Clone, Copy, Default)]
 pub struct Z;
 
-// `Allocator` is a marker trait carrying `type_id()`; the Zig vtable methods
+// `Allocator` is a marker trait carrying `type_id()`; the allocation methods
 // are inherent on `Z` below.
 impl Allocator for Z {}
 
-// Zig: `const vtable = Allocator.VTable{ .alloc, .resize, .remap = noRemap, .free }`
 impl Z {
     pub fn alloc(
-        &self, // Zig: `_: *anyopaque` (unused vtable ctx)
+        &self,
         len: usize,
         alignment: Alignment,
         return_address: usize,
@@ -35,7 +32,7 @@ impl Z {
     }
 
     pub fn resize(
-        &self, // Zig: `_: *anyopaque`
+        &self,
         buf: &mut [u8],
         alignment: Alignment,
         new_len: usize,
@@ -44,12 +41,9 @@ impl Z {
         if !c_allocator.raw_resize(buf, alignment, new_len, return_address) {
             return false;
         }
-        // PORT NOTE: reshaped for borrowck — capture len before re-deriving the
-        // tail pointer (Zig: `buf.ptr[buf.len..new_len]`).
         let old_len = buf.len();
         // Only zero on grow. On shrink (`new_len < old_len`), `new_len - old_len`
         // would underflow to ~usize::MAX and `write_bytes` would corrupt the heap.
-        // Zig's slice safety check panics in Debug here; preserve that guard.
         if new_len > old_len {
             // SAFETY: `raw_resize` succeeded in-place, so `buf.ptr[old_len..new_len]`
             // is now valid uninitialized memory owned by this allocation.
@@ -69,18 +63,10 @@ impl Z {
         None
     }
 
-    pub fn free(
-        self, // Zig: `_: *anyopaque`
-        buf: &mut [u8],
-        alignment: Alignment,
-        return_address: usize,
-    ) {
+    pub fn free(self, buf: &mut [u8], alignment: Alignment, return_address: usize) {
         c_allocator.raw_free(buf, alignment, return_address);
     }
 }
 
-// `*anyopaque` in the Zig vtable signatures maps to `*mut c_void`, but since the
-// ctx pointer is unused (`.ptr = undefined`) it collapses to `&self` on a ZST.
+// Keeps the `c_void`/`ptr` imports referenced from every cfg combination.
 const _: fn() -> *mut c_void = || ptr::null_mut();
-
-// ported from: src/bun_alloc/fallback/z.zig
diff --git a/src/bun_alloc/hashbrown_bridge.rs b/src/bun_alloc/hashbrown_bridge.rs
index 1694b2f7328..9bef3be0933 100644
--- a/src/bun_alloc/hashbrown_bridge.rs
+++ b/src/bun_alloc/hashbrown_bridge.rs
@@ -65,8 +65,8 @@ macro_rules! bridge_allocator_api2 {
     };
 }
 
-// `crate::DefaultAlloc` is the existing ZST marker for `bun.default_allocator`
-// (Zig); here it gains `core::alloc::Allocator` (forwarding to
+// `crate::DefaultAlloc` is the existing ZST marker for `bun.default_allocator`;
+// here it gains `core::alloc::Allocator` (forwarding to
 // `std::alloc::Global`, since `#[global_allocator] = Mimalloc` makes that the
 // process default) plus the api2 bridge, so a single `A` type can back both a
 // `hashbrown::HashMap<_, _, _, A>` table and its `Box<[u8], A>` keys.
diff --git a/src/bun_alloc/heap_breakdown.rs b/src/bun_alloc/heap_breakdown.rs
index d04b2709245..4ad0fa97cbf 100644
--- a/src/bun_alloc/heap_breakdown.rs
+++ b/src/bun_alloc/heap_breakdown.rs
@@ -7,21 +7,16 @@ use core::ffi::{c_int, c_uint};
 type vm_size_t = usize;
 
 // Environment.allow_assert and Environment.isMac and !Environment.enable_asan
-// TODO(port): `enable_asan` mapped to a cargo feature; verify the build wires this the same way.
+// (`bun_asan` is set via RUSTFLAGS `--cfg=bun_asan` in scripts/build/rust.ts.)
 pub const ENABLED: bool = cfg!(debug_assertions) && cfg!(target_os = "macos") && !cfg!(bun_asan);
 
-/// Zig: `pub fn getZone(comptime name: [:0]const u8) *Zone`
-///
-/// Each comptime instantiation in Zig gets its own `static var zone` + `std.once`.
-/// The faithful Rust translation is the crate-root `get_zone!` macro in lib.rs
-/// that expands a fresh `OnceLock` per call site (per literal name). Not
+/// The crate-root `get_zone!` macro in lib.rs
+/// expands a fresh `OnceLock` per call site (per literal name). Not
 /// duplicated here to avoid path-export collisions on macOS.
 
 /// Runtime `getZone(name)` — looks up (or creates) the per-name zone. The
 /// `get_zone!` macro is the zero-cost form. This runtime path keys a
 /// process-global map for callers that pass a non-literal name.
-// TODO(port): could be replaced with a `#[heap_label]` derive that expands
-// `get_zone!` directly.
 #[allow(clippy::assertions_on_constants)]
 pub fn get_zone(name: &[u8]) -> &'static Zone {
     debug_assert!(
@@ -46,7 +41,7 @@ pub fn get_zone(name: &[u8]) -> &'static Zone {
     if let Some((_, _, z)) = zones.iter().find(|(k, _, _)| k.as_slice() == name) {
         return *z;
     }
-    // `name` verbatim (no prefix — matches Zig `getZone`), NUL-terminated.
+    // `name` verbatim (no prefix), NUL-terminated.
     let mut owned = Vec::with_capacity(name.len() + 1);
     owned.extend_from_slice(name);
     owned.push(0);
@@ -62,29 +57,25 @@ pub fn get_zone(name: &[u8]) -> &'static Zone {
 }
 
 bun_opaque::opaque_ffi! {
-    /// Zig: `pub const Zone = opaque { ... };`
-    ///
     /// Opaque FFI handle for a macOS `malloc_zone_t`.
     ///
     /// The `UnsafeCell` field makes `Zone: !Freeze`, so a `&Zone` does not assert
     /// immutability of the pointee. This is required because every malloc-zone FFI
     /// call (`malloc_zone_memalign`, `malloc_zone_free`, …) mutates the zone's
-    /// internal state, and Zig models the handle as a freely-aliasing `*Zone`.
+    /// internal state.
     /// Without `UnsafeCell`, casting `&Zone as *const _ as *mut _` and writing
     /// through it (via FFI) is UB under Stacked Borrows.
     pub struct Zone;
 }
 
 // SAFETY: `malloc_zone_t` is internally synchronized by libmalloc; sharing
-// `&Zone` across threads is the documented usage (matches Zig `*Zone` via `std.once`).
+// `&Zone` across threads is the documented usage.
 unsafe impl Sync for Zone {}
 // SAFETY: `Zone` is an opaque libmalloc handle with no thread-affine state; the
 // zone API is callable from any thread, so transferring the handle is sound.
 unsafe impl Send for Zone {}
 
 impl Zone {
-    /// Zig: `pub fn init(comptime name: [:0]const u8) *Zone`
-    ///
     /// # Safety
     /// `name` must point to a NUL-terminated C string that remains valid for
     /// the entire process lifetime — `malloc_set_zone_name` stores the pointer
@@ -149,16 +140,6 @@ impl Zone {
         Zone::aligned_alloc(unsafe { &*(zone.cast::<Zone>()) }, len, alignment)
     }
 
-    // Zig exposed a `pub const vtable: std.mem.Allocator.VTable` with
-    // { alloc, resize, remap = noRemap, free }. In Rust the equivalent is an
-    // `impl crate::Allocator for Zone` (see below); the raw vtable struct is a
-    // Zig-ism and is not materialized here, so the `resize`/`free` vtable thunks
-    // (and the `malloc_size` helper they used) are not ported.
-    // TODO(port): if `bun_alloc::Allocator` ever becomes a literal vtable struct
-    // (to match `std.mem.Allocator` ABI), reintroduce a `pub static VTABLE`
-    // along with the `resize`/`raw_free` thunks.
-
-    /// Zig: `pub fn allocator(zone: *Zone) std.mem.Allocator`
     pub fn allocator(&'static self) -> &'static dyn crate::Allocator {
         self
     }
@@ -174,12 +155,11 @@ impl Zone {
     #[inline]
     pub fn try_create<T>(&self, data: T) -> Result<*mut T, crate::AllocError> {
         let alignment = core::mem::align_of::<T>();
-        // TODO(port): Zig passed `@returnAddress()` as the ret_addr hint; Rust has no
-        // stable equivalent. Passing 0 — the macOS zone API ignores it anyway.
+        // Pass 0 as the ret_addr hint — the macOS zone API ignores it anyway.
         let raw = Zone::raw_alloc(
             // SAFETY: vtable context pointer — `as_mut_ptr()` yields the
             // interior-mutable `*mut Zone`, erased to `*mut c_void` to match
-            // the Zig `*anyopaque` allocator-vtable signature.
+            // the allocator-vtable signature.
             self.as_mut_ptr().cast::<c_void>(),
             core::mem::size_of::<T>(),
             alignment,
@@ -201,23 +181,21 @@ impl Zone {
         unsafe { malloc_zone_free(self.as_mut_ptr(), ptr.cast()) };
     }
 
-    /// Zig: `pub fn isInstance(allocator_: std.mem.Allocator) bool`
-    ///
-    /// Zig: `return allocator_.vtable == &vtable;` — implemented as a `TypeId`
+    /// Implemented as a `TypeId`
     /// identity check via the `Allocator::type_id()` hook.
     pub fn is_instance(allocator_: &dyn crate::Allocator) -> bool {
         allocator_.is::<Self>()
     }
 }
 
-// `crate::Allocator` is a marker trait carrying `type_id()`; the Zig vtable
+// `crate::Allocator` is a marker trait carrying `type_id()`; the allocation
 // methods (`alloc`/`resize`/`free`) are inherent on `Zone` above (`raw_alloc`,
 // `resize`, `raw_free`). This impl makes `Zone` usable as `&dyn Allocator`
 // for `is_instance` identity checks.
 impl crate::Allocator for Zone {}
 
-// TODO(port): move to bun_alloc_sys (or keep here gated `#[cfg(target_os = "macos")]`
-// since these are macOS-only libc symbols).
+// macOS-only libmalloc symbols, kept here (gated on `target_os = "macos"`)
+// since heap_breakdown is their only consumer.
 #[cfg(target_os = "macos")]
 unsafe extern "C" {
     /// No preconditions; returns the process default malloc zone.
@@ -286,5 +264,3 @@ mod stubs {
 use stubs::malloc_zone_memalign;
 #[cfg(not(target_os = "macos"))]
 pub use stubs::{malloc_zone_calloc, malloc_zone_free, malloc_zone_malloc};
-
-// ported from: src/bun_alloc/heap_breakdown.zig
diff --git a/src/bun_alloc/lib.rs b/src/bun_alloc/lib.rs
index 4227c90a4b3..8d09e42c23c 100644
--- a/src/bun_alloc/lib.rs
+++ b/src/bun_alloc/lib.rs
@@ -1,4 +1,3 @@
-//! Port of `src/bun_alloc/bun_alloc.zig`.
 // bun_alloc is the T0 foundation crate that bun_threading and bun_collections
 // depend on; importing either to satisfy the disallowed-types lint would create
 // a dependency cycle.
@@ -8,8 +7,7 @@
 // `#[thread_local]` (vs the `thread_local!` macro) compiles to a bare
 // `__thread` slot — single `mov reg, fs:[OFFSET]` access, no `LocalKey`
 // `__getit()` wrapper, no lazy-init flag check, no dtor-registration probe.
-// Used for the per-allocation hot-path TLS in `ast_alloc::AST_ALLOC`; matches
-// Zig's `threadlocal var` semantics exactly.
+// Used for the per-allocation hot-path TLS in `ast_alloc::AST_ALLOC`.
 #![feature(thread_local)]
 
 use core::fmt::Write as _;
@@ -19,16 +17,16 @@ use core::sync::atomic::{AtomicU16, AtomicU32, Ordering};
 use std::collections::HashMap;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Re-exports (thin — match Zig `pub const X = @import(...)` lines)
+// Re-exports
 // ──────────────────────────────────────────────────────────────────────────
 
 pub use bun_mimalloc_sys::mimalloc;
 pub mod c_thunks;
 
-// ── Allocator vtable (mirrors std.mem.Allocator) ──────────────────────────
+// ── Allocator vtable ───────────────────────────────────────────────────────
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
-pub struct Alignment(pub u8); // log2 of byte alignment, like std.mem.Alignment
+pub struct Alignment(pub u8); // log2 of byte alignment
 impl Alignment {
     #[inline]
     pub const fn of<T>() -> Self {
@@ -44,10 +42,10 @@ impl Alignment {
     }
 }
 
-// ── `std.c.max_align_t` alignment ─────────────────────────────────────────
+// ── `max_align_t` alignment ────────────────────────────────────────────────
 // The `libc` crate does not expose `max_align_t` on every target Bun ships
 // (missing on Windows MSVC and on FreeBSD aarch64), so those targets carry a
-// local mirror of the Zig definition. Remaining non-Windows targets keep
+// local mirror of `max_align_t`. Remaining non-Windows targets keep
 // `libc::max_align_t` (which carries `long double`, align 16 on x86_64/aarch64;
 // the {f64,i64,*const ()} fallback would silently downgrade to 8).
 #[cfg(windows)]
@@ -59,7 +57,7 @@ struct MaxAlignT {
 }
 #[cfg(windows)]
 pub const MAX_ALIGN_T: usize = core::mem::align_of::<MaxAlignT>();
-// Zig: `extern struct { a: c_longlong, b: c_longdouble }` — on AArch64
+// On AArch64
 // AAPCS64 `long double` is IEEE binary128, 16-byte aligned. The `libc` crate
 // only defines `max_align_t` for FreeBSD on x86_64, so hardcode the ABI value
 // for the aarch64 port.
@@ -77,9 +75,7 @@ pub struct AllocatorVTable {
 impl AllocatorVTable {
     /// `alloc` impl that always fails. For vtables that only ever `free` an
     /// externally-produced buffer (mmap region, plugin-owned memory, refcounted
-    /// foreign string) and never allocate or grow it. Zig has no `std.mem.
-    /// Allocator.noAlloc`; every Zig site hand-rolls `fn alloc(...) ?[*]u8 {
-    /// return null; }`. This is the Rust-side improvement.
+    /// foreign string) and never allocate or grow it.
     pub const NO_ALLOC: unsafe fn(*mut core::ffi::c_void, usize, Alignment, usize) -> *mut u8 =
         |_, _, _, _| core::ptr::null_mut();
     pub const NO_RESIZE: unsafe fn(
@@ -112,7 +108,7 @@ impl AllocatorVTable {
     }
 }
 
-/// `std.mem.Allocator` — fat (ptr + vtable). Distinct from the `Allocator` trait below.
+/// Fat allocator handle (ptr + vtable). Distinct from the `Allocator` trait below.
 #[derive(Clone, Copy)]
 pub struct StdAllocator {
     pub ptr: *mut core::ffi::c_void,
@@ -121,16 +117,15 @@ pub struct StdAllocator {
 /// Legacy alias for `AllocatorVTable`.
 pub type VTable = AllocatorVTable;
 
-// SAFETY: `ptr` is an opaque tag/context handle (Zig: `*anyopaque`); the
-// vtable is `&'static`. Thread-safety of dispatch is the implementor's
-// concern (mimalloc is thread-safe; FixedBufferAllocator is not — same as Zig).
+// SAFETY: `ptr` is an opaque tag/context handle; the vtable is `&'static`.
+// Thread-safety of dispatch is the implementor's concern (mimalloc is
+// thread-safe; FixedBufferAllocator is not).
 unsafe impl Send for StdAllocator {}
 // SAFETY: see the `Send` impl directly above.
 unsafe impl Sync for StdAllocator {}
 
 impl Default for StdAllocator {
-    /// Zig: `bun.memory.initDefault(std.mem.Allocator)` → `bun.default_allocator`
-    /// (mimalloc-backed `c_allocator`).
+    /// The mimalloc-backed `c_allocator`.
     #[inline]
     fn default() -> Self {
         basic::C_ALLOCATOR
@@ -138,14 +133,12 @@ impl Default for StdAllocator {
 }
 
 impl StdAllocator {
-    /// Zig: `Allocator.rawAlloc`.
     #[inline]
     pub fn raw_alloc(&self, len: usize, alignment: Alignment, ra: usize) -> Option<*mut u8> {
         // SAFETY: vtable invariant — `alloc` callee respects (ptr, len, alignment, ra) contract.
         let p = unsafe { (self.vtable.alloc)(self.ptr, len, alignment, ra) };
         if p.is_null() { None } else { Some(p) }
     }
-    /// Zig: `Allocator.rawResize`.
     #[inline]
     pub fn raw_resize(
         &self,
@@ -157,7 +150,6 @@ impl StdAllocator {
         // SAFETY: see `raw_alloc`.
         unsafe { (self.vtable.resize)(self.ptr, buf, alignment, new_len, ra) }
     }
-    /// Zig: `Allocator.rawRemap`.
     #[inline]
     pub fn raw_remap(
         &self,
@@ -170,27 +162,26 @@ impl StdAllocator {
         let p = unsafe { (self.vtable.remap)(self.ptr, buf, alignment, new_len, ra) };
         if p.is_null() { None } else { Some(p) }
     }
-    /// Zig: `Allocator.rawFree`.
     #[inline]
     pub fn raw_free(&self, buf: &mut [u8], alignment: Alignment, ra: usize) {
         // SAFETY: see `raw_alloc`.
         unsafe { (self.vtable.free)(self.ptr, buf, alignment, ra) }
     }
-    /// Zig: `Allocator.free` — `rawFree` with `ret_addr = 0`, byte-aligned.
+    /// `raw_free` with `ret_addr = 0`, byte-aligned.
     #[inline]
     pub fn free(&self, bytes: &[u8]) {
         if bytes.is_empty() {
             return;
         }
         // SAFETY: `bytes` is reborrowed mutably only for the vtable signature; the
-        // callee treats it as opaque (Zig passes `[]u8`).
+        // callee treats it as opaque.
         let buf =
             unsafe { core::slice::from_raw_parts_mut(bytes.as_ptr().cast_mut(), bytes.len()) };
         self.raw_free(buf, Alignment::from_byte_units(1), 0);
     }
 }
 
-/// `std.heap.FixedBufferAllocator` — bump allocator over a caller-owned buffer.
+/// Bump allocator over a caller-owned buffer.
 pub struct FixedBufferAllocator<'a> {
     end: usize,
     buffer: &'a mut [u8],
@@ -259,9 +250,9 @@ impl<'a> FixedBufferAllocator<'a> {
 }
 
 // PORTING.md §Allocators: AST crates thread an `Arena`; non-AST use Vec/Box
-// (global mimalloc). `Arena` is now the real per-heap `MimallocArena` (matching
-// Zig's `bun.allocators.MimallocArena`) — unlike `bumpalo::Bump`, it supports
-// per-allocation free + realloc, so `ArenaVec` no longer leaks on grow.
+// (global mimalloc). `Arena` is the real per-heap `MimallocArena` — unlike
+// `bumpalo::Bump`, it supports per-allocation free + realloc, so `ArenaVec`
+// no longer leaks on grow.
 //
 // `bumpalo::Bump` is kept as `Bump` for genuinely bump-only scratch (parser
 // node stores that are never resized and where the no-op `deallocate` is the
@@ -272,8 +263,8 @@ pub type Arena = MimallocArena;
 pub type Bump = bumpalo::Bump;
 mod baby_vec;
 pub use baby_vec::BabyVec;
-/// Arena-backed `Vec` with `u32` length/capacity — port of Zig's
-/// `BabyList(T)`. 24 B (vs 32 B for `Vec<T, &'a MimallocArena>`); the
+/// Arena-backed `Vec` with `u32` length/capacity.
+/// 24 B (vs 32 B for `Vec<T, &'a MimallocArena>`); the
 /// allocator handle is kept inline for lifetime checking. Growth/free route
 /// through `<&MimallocArena as Allocator>` (= `mi_heap_realloc_aligned` /
 /// `mi_free`); reclaimed on arena `reset`/`Drop`.
@@ -295,11 +286,6 @@ where
 
 /// Re-tag an [`ArenaVec`]'s allocator handle to `dst` without copying data.
 ///
-/// Zig parity: `BabyList.transferOwnership` (collections/baby_list.zig). Zig's
-/// `BabyList` is allocator-erased — the linker passes a different allocator at
-/// each `append(allocator, ..)` call site; the Rust port stores `&'a Arena` in
-/// the `Vec`, so the equivalent is swapping that field.
-///
 /// Sound because `<&MimallocArena as Allocator>` is heap-agnostic on the
 /// existing buffer:
 /// - `deallocate` → `mi_free(ptr)`: looks up the owning heap from the pointer's
@@ -332,16 +318,11 @@ pub const USE_MIMALLOC: bool = cfg!(not(bun_asan));
 
 // ── Allocator-vtable modules: per-module disposition (PORTING.md §Allocators) ──
 //
-// These modelled Zig's `std.mem.Allocator` vtable. With `#[global_allocator]`
-// + `Arena = bumpalo::Bump`, most callers should drop the allocator param
-// PORTING.md §Forbidden) so the .zig↔.rs diff pass has a real body to compare;
-// callers are migrated incrementally.
-//
 //   MimallocArena            → prefer `bun_alloc::Arena` (= bumpalo::Bump)
 //   NullableAllocator        → prefer `Option<&Arena>` or drop the param
 //   MaxHeapAllocator         → debug-only cap (single-allocation arena)
 //   BufferFallbackAllocator  → PORTING.md "StackFallbackAllocator → just use the heap"
-//   fallback                 → libc-malloc + zeroing wrapper (Zig std.heap.c_allocator)
+//   fallback                 → libc-malloc + zeroing wrapper
 //   maybe_owned              → prefer `std::borrow::Cow` / `bun_ptr::Owned`
 //   heap_breakdown           → macOS malloc_zone_* per-tag heaps (debug builds)
 //   basic                    → `impl GlobalAlloc for Mimalloc` above is the canonical impl
@@ -542,15 +523,14 @@ pub use allocator_api2::alloc::Allocator as HashbrownAllocator;
 // canonical tier-0 definitions, re-exported by higher tiers (`bun_paths::SEP_STR`,
 // `bun_core::strings::trim_right`, `bun_core::strings::trim_right`).
 
-/// Zig: `std.fs.path.sep_str` — `"\\"` on Windows, `"/"` elsewhere.
+/// `"\\"` on Windows, `"/"` elsewhere.
 /// Canonical tier-0 definition; re-exported by `bun_paths::SEP_STR`.
 pub const SEP_STR: &str = if cfg!(windows) { "\\" } else { "/" };
 
-/// Zig: `std.fs.path.sep` — `b'\\'` on Windows, `b'/'` elsewhere.
+/// `b'\\'` on Windows, `b'/'` elsewhere.
 /// Canonical tier-0 definition; re-exported by `bun_paths::SEP` / `bun_core::SEP`.
 pub const SEP: u8 = if cfg!(windows) { b'\\' } else { b'/' };
 
-/// Zig: `std.mem.trimRight(u8, s, chars)`.
 /// Canonical tier-0 definition; re-exported by `bun_core::strings::trim_right`.
 #[inline]
 pub fn trim_right<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
@@ -561,7 +541,6 @@ pub fn trim_right<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
     &s[..end]
 }
 
-/// Zig: `std.mem.trimLeft(u8, s, chars)`.
 /// Canonical tier-0 definition; re-exported by `bun_core::strings::trim_left`.
 #[inline]
 pub fn trim_left<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
@@ -572,7 +551,7 @@ pub fn trim_left<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
     &s[begin..]
 }
 
-/// Zig: `std.mem.trim(u8, s, chars)` — strip `chars` from both ends.
+/// Strip `chars` from both ends.
 /// Canonical tier-0 definition; re-exported by `bun_core::strings::trim`.
 #[inline]
 pub fn trim<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
@@ -586,13 +565,13 @@ pub fn trim<'a>(s: &'a [u8], chars: &[u8]) -> &'a [u8] {
 // `bun_core::strings::copy_lowercase` / `bun_core::immutable::copy_lowercase`
 // keep compiling unchanged.
 
-/// Zig: `strings.copyLowercase` (src/string/immutable.zig). ASCII-lowercase
+/// ASCII-lowercase
 /// `in_` into `out` (which must be at least `in_.len()`), returning the
 /// written prefix. Memcpy-runs + per-uppercase-byte fixup; identical output
 /// to a byte-at-a-time `to_ascii_lowercase` zip.
 pub fn copy_lowercase<'a>(in_: &[u8], out: &'a mut [u8]) -> &'a [u8] {
     let mut in_slice = in_;
-    // PORT NOTE: reshaped for borrowck — track output offset instead of reslicing &mut.
+    // Reshaped for borrowck — track output offset instead of reslicing &mut.
     let mut out_off: usize = 0;
 
     'begin: loop {
@@ -614,7 +593,7 @@ pub fn copy_lowercase<'a>(in_: &[u8], out: &'a mut [u8]) -> &'a [u8] {
     &out[0..in_.len()]
 }
 
-/// Zig: `strings.copyLowercaseIfNeeded` (src/string/immutable.zig:664). If
+/// If
 /// `in_` contains no ASCII uppercase byte, returns `in_` unchanged and leaves
 /// `out` UNTOUCHED. Otherwise identical to [`copy_lowercase`]: writes the
 /// lowercased bytes into `out[..in_.len()]` and returns that prefix. Both
@@ -654,7 +633,7 @@ pub(crate) fn alloc_result<T>(
         .ok_or(core::alloc::AllocError)
 }
 
-/// Port of `std.fmt.count`: number of bytes the formatted args would produce.
+/// Number of bytes the formatted args would produce.
 ///
 /// Drives a discarding `fmt::Write` that only sums `s.len()` — no allocation,
 /// no UTF-8 validation beyond what the formatter already did. Lives here in
@@ -671,8 +650,7 @@ pub fn fmt_count(args: core::fmt::Arguments<'_>) -> usize {
         }
     }
     let mut w = Discarding(0);
-    // Infallible: our `write_str` never errors, mirroring Zig's
-    // `error.WriteFailed => unreachable`.
+    // Infallible: our `write_str` never errors.
     let _ = core::fmt::write(&mut w, args);
     w.0
 }
@@ -680,10 +658,9 @@ pub fn fmt_count(args: core::fmt::Arguments<'_>) -> usize {
 /// `core::fmt::Write` adapter over a borrowed `&mut [u8]` — the engine behind
 /// [`buf_print`] / [`buf_print_len`] (and `bun_core::fmt::buf_print_z`).
 ///
-/// This is the single port of Zig `std.fmt.bufPrint`'s internal cursor. It
-/// lives at T0 so `bun_alloc` itself can use it (`BSSStringList::print`); T1
-/// `bun_core::fmt` re-exports it and adds an `io::Write` impl so the same
-/// struct also serves as Zig's `std.io.fixedBufferStream` for write-only sites.
+/// Lives at T0 so `bun_alloc` itself can use it (`BSSStringList::print`); T1
+/// `bun_core::fmt` re-exports it and adds an `io::Write` impl for write-only
+/// sites.
 pub struct SliceCursor<'a> {
     pub buf: &'a mut [u8],
     pub at: usize,
@@ -708,7 +685,7 @@ impl core::fmt::Write for SliceCursor<'_> {
     }
 }
 
-/// Port of `std.fmt.bufPrint` — render into `buf`, return the written sub-slice.
+/// Render the formatted args into `buf`, returning the written sub-slice.
 /// Fails (`fmt::Error`) when `buf` is too short.
 pub fn buf_print<'a>(
     buf: &'a mut [u8],
@@ -720,7 +697,7 @@ pub fn buf_print<'a>(
     Ok(&c.buf[..len])
 }
 
-/// [`buf_print`] returning only the byte count — `std.fmt.bufPrint(..).len`.
+/// [`buf_print`] returning only the byte count.
 #[inline]
 pub fn buf_print_len(
     buf: &mut [u8],
@@ -732,8 +709,7 @@ pub fn buf_print_len(
 }
 
 // ── RAII Mutex ────────────────────────────────────────────────────────────
-// Zig's `bun.Mutex` exposes bare `lock()`/`unlock()` (no guard). The BSS
-// containers below need to hold the lock across `&mut self` method calls, so
+// The BSS containers below need to hold the lock across `&mut self` method calls, so
 // the returned [`MutexGuard`] deliberately erases its borrow of `self` — it
 // stores the `std::sync::MutexGuard` lifetime-extended to `'static` (lifetimes
 // are erased at codegen, so this is a layout no-op). This is sound because
@@ -785,7 +761,6 @@ impl Default for Mutex {
 pub struct AllocError;
 
 impl AllocError {
-    /// Port of Zig `@errorName(error.OutOfMemory)`.
     #[inline]
     pub const fn name(self) -> &'static str {
         "OutOfMemory"
@@ -794,7 +769,7 @@ impl AllocError {
 
 /// Stamp out `impl From<AllocError> for $t { → $t::OutOfMemory }` for one or
 /// more local error enums. Expansion is byte-identical to the hand-written
-/// 3-line impls this replaces (PORTING.md: Zig `error{OutOfMemory,…}` sets).
+/// 3-line impls this replaces.
 #[macro_export]
 macro_rules! oom_from_alloc {
     ($($t:ty),+ $(,)?) => { $(
@@ -811,7 +786,7 @@ macro_rules! oom_from_alloc {
 /// `#[global_allocator] static ALLOC: bun_alloc::Mimalloc = bun_alloc::Mimalloc;`
 /// must be set at the binary root before any `Box`/`Rc`/`Arc`/`Vec` mapping is valid.
 ///
-/// Mirrors `src/bun_alloc/basic.zig` `c_allocator` vtable, using mimalloc's
+/// Uses mimalloc's
 /// `MI_MAX_ALIGN_SIZE` (16) fast-path: alignments ≤16 go through `mi_malloc`,
 /// larger through `mi_malloc_aligned`. `mi_free` handles both.
 pub struct Mimalloc;
@@ -864,7 +839,7 @@ unsafe impl core::alloc::GlobalAlloc for Mimalloc {
     }
 }
 
-/// `bun.default_allocator.realloc(slice, new_size)` — resize a mimalloc-owned
+/// Resize a mimalloc-owned
 /// byte allocation in place when possible, returning the (possibly moved) slice.
 ///
 /// # Safety
@@ -917,8 +892,6 @@ pub fn usable_size(ptr: *const u8) -> usize {
 // ──────────────────────────────────────────────────────────────────────────
 
 // ── out_of_memory ─────────────────────────────────────────────────────────
-// Source: src/bun.zig `outOfMemory()` → `crash_handler.crashHandler(.out_of_memory, ..)`.
-//
 // `bun_alloc` is T0 and cannot depend on `bun_crash_handler`, so the upward
 // call is routed through a link-time `extern "Rust"` symbol defined by
 // `bun_crash_handler`. Resolved at link time → the target lives in read-only
@@ -947,7 +920,7 @@ pub fn out_of_memory() -> ! {
 }
 
 // ── page_size ─────────────────────────────────────────────────────────────
-// Source: Zig `std.heap.pageSize()` (used by LinuxMemFdAllocator / standalone_graph).
+// Used by LinuxMemFdAllocator / standalone_graph.
 // Cached via OnceLock per PORTING.md §Concurrency (was lazy-init in std).
 
 static PAGE_SIZE: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
@@ -1000,7 +973,6 @@ pub fn page_size() -> usize {
 }
 
 // ── wtf (FastMalloc thread-cache release) ─────────────────────────────────
-// Source: src/jsc/WTF.zig `releaseFastMallocFreeMemoryForThisThread`.
 // MOVE_DOWN from bun_jsc so bun_threading (T2) can call it without a T6 dep.
 pub mod wtf {
     unsafe extern "C" {
@@ -1011,19 +983,17 @@ pub mod wtf {
 
     #[inline]
     pub fn release_fast_malloc_free_memory_for_this_thread() {
-        // Zig: jsc.markBinding(@src()) — debug-only binding marker, dropped at T0.
         WTF__releaseFastMallocFreeMemoryForThisThread()
     }
 }
 
-// ── String (bun.String) — TYPE_ONLY landing ───────────────────────────────
-// Source: src/string/string.zig + src/jsc/ZigString.zig + src/string/wtf.zig.
+// ── String — TYPE_ONLY landing ─────────────────────────────────────────────
 // Layout-only (#[repr(C)]) so T0/T1 crates can name the type; rich methods
 // (toJS, toUTF8, WTF refcounting) remain in bun_str via extension traits.
 // PORTING.md: "#[repr(C)] struct { tag: u8, value: StringValue } — NOT a Rust
 // enum (C++ mutates tag and value independently across FFI)."
 
-/// Port of `bun.String.Tag`.
+/// Discriminant for [`String`]'s representation.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Tag {
@@ -1034,7 +1004,7 @@ pub enum Tag {
     Empty = 4,
 }
 
-// `ZigString` pointer-tag scheme (ZigString.zig:629) — single source of truth.
+// `ZigString` pointer-tag scheme — single source of truth.
 // Flag bits live in the POINTER's high byte; untagging truncates to 53 bits.
 pub const ZS_STATIC_BIT: usize = 1usize << 60;
 pub const ZS_UTF8_BIT: usize = 1usize << 61;
@@ -1042,7 +1012,7 @@ pub const ZS_GLOBAL_BIT: usize = 1usize << 62;
 pub const ZS_16BIT_BIT: usize = 1usize << 63;
 pub const ZS_UNTAG_MASK: usize = (1usize << 53) - 1;
 
-/// Port of `jsc.ZigString` — extern struct `{ ptr: [*]const u8, len: usize }`.
+/// FFI string slice — `{ ptr: *const u8, len: usize }`.
 ///
 /// **Canonical storage layout.** `bun_core::string::ZigString` is a
 /// `#[repr(transparent)]` newtype over this struct (so the FFI layout has ONE
@@ -1148,7 +1118,7 @@ impl ZigString {
             ((self._unsafe_ptr_do_not_use as usize) | ZS_STATIC_BIT) as *const u8;
     }
 
-    /// Zig `untagged`: `@ptrFromInt(@as(u53, @truncate(@intFromPtr(ptr))))`.
+    /// Strip the flag bits — truncate to the low 53 bits.
     #[inline]
     pub fn untagged(ptr: *const u8) -> *const u8 {
         ((ptr as usize) & ZS_UNTAG_MASK) as *const u8
@@ -1160,13 +1130,12 @@ impl ZigString {
         if self.len == 0 {
             return &[];
         }
-        // ZigString.zig:637 — only panics when `len > 0 and is16Bit()`.
         debug_assert!(
             !self.is_16bit(),
             "ZigString::slice() on UTF-16 string; use to_slice()"
         );
-        // SAFETY: constructor stored a valid ptr/len; flag bits stripped. Zig
-        // caps at u32::MAX (ZigString.zig:642).
+        // SAFETY: constructor stored a valid ptr/len; flag bits stripped.
+        // Length is capped at `u32::MAX`.
         unsafe {
             core::slice::from_raw_parts(
                 Self::untagged(self._unsafe_ptr_do_not_use),
@@ -1181,7 +1150,6 @@ impl ZigString {
         if self.len == 0 {
             return &[];
         }
-        // ZigString.zig:436 — only panics when `len > 0 and !is16Bit()`.
         debug_assert!(self.is_16bit());
         // SAFETY: 16-bit-tagged constructor stored a 2-byte-aligned ptr valid
         // for `self.len` u16 units; flag bits stripped via `ZS_UNTAG_MASK`
@@ -1285,8 +1253,8 @@ impl WTFStringImplStruct {
     ///
     /// Cross-language LTO does not inline the `Bun__WTFStringImpl__ref` C++
     /// shim into Rust callers (2151 out-of-line `callq` sites in the release
-    /// binary vs 0 in the Zig build), so the one-instruction body is
-    /// reimplemented here. `Relaxed` matches WebKit's
+    /// binary), so the one-instruction body is reimplemented here.
+    /// `Relaxed` matches WebKit's
     /// `m_refCount.fetch_add(s_refCountIncrement, std::memory_order_relaxed)`.
     #[inline]
     pub fn r#ref(&self) {
@@ -1404,7 +1372,7 @@ unsafe extern "C" {
     // `destroy` path crosses FFI. `*const` + `unsafe`: it frees the
     // allocation backing the pointer.
     pub fn Bun__WTFStringImpl__destroy(this: *const WTFStringImplStruct);
-    // Kept for Zig callers (`src/string/wtf.zig`); Rust no longer calls these.
+    // Rust no longer calls these.
     pub safe fn Bun__WTFStringImpl__ref(this: &WTFStringImplStruct);
     pub fn Bun__WTFStringImpl__deref(this: *const WTFStringImplStruct);
     safe fn WTFStringImpl__isThreadSafe(this: &WTFStringImplStruct) -> bool;
@@ -1416,14 +1384,12 @@ unsafe extern "C" {
     ) -> bool;
 }
 
-/// Port of `bun.String.StringImplAllocator` (src/string/wtf.zig).
-///
-/// A `std.mem.Allocator` vtable whose `ptr` is a `WTFStringImpl`; `alloc` bumps
+/// An [`AllocatorVTable`] whose ctx `ptr` is a `WTFStringImpl`; `alloc` bumps
 /// the refcount, `free` derefs. Hoisted into `bun_alloc` (which already owns
 /// `AllocatorVTable` and the `WTFStringImplStruct` layout) so the
 /// `is_wtf_allocator` vtable-identity check is a local pointer compare — no
 /// upward dependency on `bun_string` and no runtime fn-ptr hook.
-#[allow(non_snake_case)] // Zig namespace `bun.String.StringImplAllocator`
+#[allow(non_snake_case)]
 pub mod StringImplAllocator {
     use super::{Alignment, AllocatorVTable, WTFStringImplStruct};
 
@@ -1449,8 +1415,8 @@ pub mod StringImplAllocator {
         // ctx pointer; `byte_slice`/`byte_length`/`deref` are safe `&self` methods.
         let this = unsafe { &*ptr.cast::<WTFStringImplStruct>() };
         debug_assert!(this.byte_slice().as_ptr() == buf.as_ptr());
-        // Zig: `bun.assert(this.latin1Slice().len == buf.len)` — `latin1Slice().len` is
-        // `byteLength()` (i.e. `m_length * 2` for UTF-16), not the code-unit count.
+        // The buffer length is `byte_length()` (i.e. `m_length * 2` for
+        // UTF-16), not the code-unit count.
         debug_assert!(this.byte_length() == buf.len());
         this.deref();
     }
@@ -1465,7 +1431,7 @@ pub mod StringImplAllocator {
     pub const VTABLE_PTR: &AllocatorVTable = &VTABLE;
 }
 
-/// Port of `bun.String.StringImpl` — `extern union`.
+/// C-layout untagged union over [`String`]'s payload representations.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub union StringImpl {
@@ -1474,9 +1440,9 @@ pub union StringImpl {
     // .StaticZigString aliases .zig_string; .Dead/.Empty are zero-width.
 }
 
-/// Port of `bun.String` (a.k.a. `BunString` in C++).
+/// Known as `BunString` in C++.
 ///
-/// 5-variant tagged union over WTF-backed and Zig-slice-backed strings. NOT a
+/// 5-variant tagged union over WTF-backed and `ZigString`-backed strings. NOT a
 /// Rust `enum` because C++ mutates `tag` and `value` independently across FFI.
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -1488,7 +1454,7 @@ pub struct String {
 impl String {
     pub const NAME: &'static str = "BunString";
 
-    /// Port of `bun.String.isWTFAllocator` — vtable-identity check against
+    /// Vtable-identity check against
     /// [`StringImplAllocator::VTABLE`].
     #[inline]
     pub fn is_wtf_allocator(alloc: StdAllocator) -> bool {
@@ -1562,9 +1528,8 @@ impl String {
         }
     }
 
-    /// Zig `eqlComptime` — compare against a (typically literal) byte slice.
-    /// PERF(port): Zig dispatched to SIMD `bun.strings.eqlComptime*`; this T0
-    /// version uses scalar `==` / widening compare. Re-route to
+    /// Compare against a (typically literal) byte slice.
+    /// PERF: this T0 version uses scalar `==` / widening compare. Re-route to
     /// `bun_core::strings` via inlining if it shows up on a hot path.
     pub fn eql_comptime(&self, other: &[u8]) -> bool {
         let zs = self.to_zig_string();
@@ -1585,9 +1550,8 @@ impl String {
 
 impl core::fmt::Display for String {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // Port of `ZigString.format`: utf8 → write bytes; utf16 → transcode;
+        // utf8 → write bytes; utf16 → transcode;
         // latin1 → widen each byte to a Unicode scalar.
-        // PERF(port): was `bun.fmt.formatUTF16Type` / `formatLatin1` (SIMD).
         let zs = self.to_zig_string();
         if zs.len == 0 {
             return Ok(());
@@ -1598,7 +1562,7 @@ impl core::fmt::Display for String {
             }
             Ok(())
         } else if zs.is_utf8() {
-            // Zig wrote raw bytes; BStr renders them without allocating.
+            // BStr renders raw bytes without allocating.
             write!(f, "{}", bstr::BStr::new(zs.slice()))
         } else {
             for &b in zs.slice() {
@@ -1628,14 +1592,12 @@ pub fn is_slice_in_buffer(slice: &[u8], buffer: &[u8]) -> bool {
     is_slice_in_buffer_t::<u8>(slice, buffer)
 }
 
-/// Zig: `bun.rangeOfSliceInBuffer` (`src/bun.zig`).
 /// Returns `[offset, len]` if `slice` lies within `buffer`, else `None`.
 pub fn range_of_slice_in_buffer(slice: &[u8], buffer: &[u8]) -> Option<[u32; 2]> {
     if !is_slice_in_buffer(slice, buffer) {
         return None;
     }
     let r = [
-        // Zig: `@truncate(@intFromPtr(slice.ptr) -| @intFromPtr(buffer.ptr))`
         (slice.as_ptr() as usize).saturating_sub(buffer.as_ptr() as usize) as u32,
         slice.len() as u32,
     ];
@@ -1643,13 +1605,10 @@ pub fn range_of_slice_in_buffer(slice: &[u8], buffer: &[u8]) -> Option<[u32; 2]>
     Some(r)
 }
 
-/// Zig: `bun.freeSensitive` (`src/bun.zig`).
-///
-/// Zig: `bun.default_allocator.free(slice)` for raw `[]u8` not owned by a
-/// `Vec`/`Box` (e.g. duped via `mi_malloc` on the C side, or via
-/// [`StdAllocator::free`] on the Zig side). With `#[global_allocator] =
-/// Mimalloc` this is `mi_free`; the `len` is accepted for size-asserting
-/// builds and to mirror the Zig signature.
+/// Free a raw `[u8]` allocation not owned by a `Vec`/`Box` (e.g. duped via
+/// `mi_malloc` on the C side, or via [`StdAllocator::free`]). With
+/// `#[global_allocator] = Mimalloc` this is `mi_free`; the `len` is accepted
+/// for size-asserting builds.
 ///
 /// # Safety
 /// `ptr` must be null or point to a live allocation of `len` bytes obtained
@@ -1664,7 +1623,7 @@ pub unsafe fn default_free(ptr: *mut u8, len: usize) {
     basic::C_ALLOCATOR.raw_free(buf, Alignment::from_byte_units(1), 0);
 }
 
-/// Zig: `bun.default_allocator.dupe(u8, src)` for raw `[]u8` not owned by a
+/// Duplicate `src` into a raw allocation not owned by a
 /// `Vec`/`Box` — symmetric with [`default_free`]. Returns a `&'static [u8]`
 /// view onto a fresh mimalloc allocation; caller is responsible for pairing
 /// with `default_free(ptr, len)`.
@@ -1688,7 +1647,7 @@ pub fn default_dupe(src: &[u8]) -> &'static [u8] {
     }
 }
 
-/// Port of `std.crypto.secureZero` — `@memset(@volatileCast(s), 0)`. Zeros
+/// Zeros
 /// `len` bytes at `p` in a way the optimizer cannot elide. Uses bulk
 /// `write_bytes` (lowers to `memset`) instead of a per-byte volatile loop so
 /// debug builds don't pay O(len) iteration overhead — the SSLConfig leak test
@@ -1712,9 +1671,7 @@ pub unsafe fn secure_zero(p: *mut u8, len: usize) {
 /// information kept in memory can be read until the OS decommits it or the
 /// allocator reuses it. Zero it before dropping.
 ///
-/// Zig used `std.crypto.secureZero` then `allocator.free`; Rust drops the
-/// allocator param (global mimalloc) and uses [`secure_zero`] so the zeroing
-/// cannot be elided by the optimizer.
+/// Uses [`secure_zero`] so the zeroing cannot be elided by the optimizer.
 pub fn free_sensitive<T: Copy>(mut slice: Box<[T]>) {
     // SAFETY: `slice` is exclusively owned; writing `size_of_val` zero bytes
     // over its storage is sound for `T: Copy` (no drop glue, no invariants on
@@ -1726,7 +1683,7 @@ pub fn free_sensitive<T: Copy>(mut slice: Box<[T]>) {
     drop(slice);
 }
 
-/// Port of `bun.freeSensitive(bun.default_allocator, slice)` for the C-string
+/// [`free_sensitive`] for the C-string
 /// case used by http SSLConfig. Zeros the allocation before freeing
 /// (defence-in-depth for keys/passphrases).
 ///
@@ -1750,7 +1707,7 @@ pub unsafe fn free_sensitive_cstr(p: *const core::ffi::c_char) {
 
 // ──────────────────────────────────────────────────────────────────────────
 // IndexType — `packed struct(u32) { index: u31, is_overflow: bool = false }`
-// Zig packed-struct fields are LSB-first: bits 0..=30 = index, bit 31 = is_overflow.
+// Bits 0..=30 = index, bit 31 = is_overflow.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[repr(transparent)]
@@ -1787,7 +1744,7 @@ impl IndexType {
 pub const NOT_FOUND: IndexType = IndexType::new(u32::MAX >> 1, false); // maxInt(u31)
 pub const UNASSIGNED: IndexType = IndexType::new((u32::MAX >> 1) - 1, false); // maxInt(u31) - 1
 
-#[repr(u8)] // Zig: enum(u3)
+#[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum ItemStatus {
     Unknown,
@@ -1804,10 +1761,10 @@ pub enum ItemStatus {
 // ──────────────────────────────────────────────────────────────────────────
 
 // ──────────────────────────────────────────────────────────────────────────
-// `bun.allocators` namespace shim
+// `allocators` namespace shim
 //
-// Zig exposed this file as `bun.allocators.*`; downstream crates were ported
-// against that path (`use bun_alloc::allocators;`). Re-export the crate root
+// Downstream crates use the `bun_alloc::allocators` path
+// (`use bun_alloc::allocators;`). Re-export the crate root
 // so `allocators::IndexType`, `allocators::BSSMapInner`, etc. resolve without
 // rewriting every callsite.
 // ──────────────────────────────────────────────────────────────────────────
@@ -1818,8 +1775,7 @@ pub mod allocators {
 // ──────────────────────────────────────────────────────────────────────────
 // Per-monomorphization singleton macros
 //
-// Zig defines `pub var instance: *Self = undefined; pub var loaded = false;`
-// *inside* the generic type, giving one static per instantiation. Rust forbids
+// Each instantiation needs its own singleton. Rust forbids
 // generic statics, so the storage is emitted at the *declare site* instead:
 //
 //   bss_string_list! { pub dirname_store: 4096, 129 }
@@ -1827,27 +1783,26 @@ pub mod allocators {
 //   //   pub fn dirname_store() -> *mut BSSStringList<4096,129>
 //
 // The accessor lazily field-initializes via `init_at` under `std::sync::Once`.
-// Returning `&'static mut` is the same aliasing contract as Zig's global
-// `instance` pointer — callers must not hold overlapping unique borrows.
+// Returning `&'static mut` means callers must not hold overlapping unique
+// borrows.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Emit a process-lifetime singleton accessor for any type with an
 /// `unsafe fn init_at(*mut Self)` in-place initializer. Storage is a single
 /// `AtomicPtr` (8 bytes) per declare site; the value itself is heap-allocated
-/// on first call (Zig spec: `default_allocator.create(Self)`).
+/// on first call.
 #[macro_export]
 macro_rules! bss_singleton {
     ($(#[$m:meta])* $vis:vis fn $name:ident() -> $ty:ty) => {
         $(#[$m])*
         #[inline(always)]
         $vis fn $name() -> *mut $ty {
-            // Zig's spec is `default_allocator.create(Self)` on first access
-            // (heap, process-lifetime). Store an 8-byte heap pointer and
-            // allocate on first call, matching the spec.
+            // Store an 8-byte heap pointer and allocate on first call
+            // (heap, process-lifetime).
             //
             // Hot path: this accessor is hit per-append/get from the resolver
-            // (`DirnameStore::append`, `EntriesMap::get`, …). Zig reads a
-            // plain `*Self` global; the previous `Once::call_once` fast-path
+            // (`DirnameStore::append`, `EntriesMap::get`, …). The previous
+            // `Once::call_once` fast-path
             // is an Acquire load + cmp + branch + Relaxed load that *cannot*
             // inline across crates (it's a call into `std::sys::sync::once`).
             // Open-code the double-checked-init so the post-init path is one
@@ -1887,17 +1842,16 @@ macro_rules! bss_singleton {
 
 /// Heap-allocate a fresh `T` via mimalloc and run its in-place `init_at` initializer.
 ///
-/// Shared body of the `BSSList`/`BSSStringList`/`BSSMapInner`/`BSSMap` `init()` shims —
-/// Zig's `default_allocator.create(Self)` followed by field-init. The once-guard
-/// (Zig's `loaded` flag) is the *caller's* responsibility; use the `bss_*!` macros
+/// Shared body of the `BSSList`/`BSSStringList`/`BSSMapInner`/`BSSMap` `init()` shims.
+/// The once-guard is the *caller's* responsibility; use the `bss_*!` macros
 /// for the canonical per-monomorphization singleton.
 #[doc(hidden)] // Public only for the `bss_singleton!` macro expansion in dependent crates.
 #[inline]
 pub fn bss_heap_init<T>(init_at: unsafe fn(*mut T)) -> NonNull<T> {
     let ptr = bss_lazy_bytes(size_of::<T>(), core::mem::align_of::<T>()).cast::<T>();
     // SAFETY: ptr is a fresh, exclusively-owned, properly-aligned, all-zeros-on-read
-    // allocation; lives for process lifetime (singleton; never freed/unmapped,
-    // matching Zig). `init_at` is therefore free to skip writing any field whose
+    // allocation; lives for process lifetime (singleton; never freed/unmapped).
+    // `init_at` is therefore free to skip writing any field whose
     // all-zeros bit pattern is already a valid initial value (e.g. `OverflowList`'s
     // 32 KiB `[Option<Box<_>>; 4096]` array — `None` is the null niche).
     unsafe { init_at(ptr.as_ptr()) };
@@ -1913,11 +1867,10 @@ pub fn bss_heap_init<T>(init_at: unsafe fn(*mut T)) -> NonNull<T> {
 /// instead of all 130. On Windows this falls back to `mi_zalloc_aligned`
 /// (eager commit, but still all-zeros so callers may rely on that uniformly).
 ///
-/// The mapping is **never freed** — these are Zig-port `.bss`-semantics
+/// The mapping is **never freed** — these are `.bss`-semantics
 /// singletons. Do not call from code paths that need to release the storage.
 ///
-/// **Coalesced arena.** In Zig these singletons are linker-adjacent `.bss`
-/// globals: one VMA, demand-faulted page-by-page. The original Rust port
+/// **Coalesced arena.** An earlier version
 /// `mmap`ed each one separately, costing 6 `mmap` syscalls + 6 VMAs on the
 /// `bun run <npm-script>` path (≈2 MiB total across `entry_store_backing`,
 /// `dirname_store_backing`, `hash_map_instance`, …) before any user code
@@ -2066,7 +2019,7 @@ fn bss_mmap_noreserve(len: usize) -> *mut u8 {
 ///
 /// Returns `NonNull<[MaybeUninit<T>]>`: bytes are zero-on-read but treated as
 /// logically uninitialized — callers must gate reads on a separate `used`
-/// counter (Zig leaves the array `undefined` and never reads past `used`).
+/// counter — never read past `used`.
 #[doc(hidden)]
 #[inline]
 pub fn bss_lazy_slice<T>(count: usize) -> NonNull<[MaybeUninit<T>]> {
@@ -2151,7 +2104,7 @@ macro_rules! get_zone {
 
 type HashKeyType = u64;
 
-/// Zig `IndexMapContext` — identity hash on a u64 key. Keys here are already
+/// Identity hash on a u64 key. Keys here are already
 /// `bun_wyhash` outputs, so rehashing with std's SipHash just costs cycles.
 #[derive(Default, Clone, Copy)]
 pub struct IdentityU64Hasher(u64);
@@ -2206,7 +2159,6 @@ pub trait OverflowBlock {
 
 const OVERFLOW_GROUP_MAX: usize = 4095;
 const OVERFLOW_GROUP_SLOTS: usize = OVERFLOW_GROUP_MAX + 1;
-// Zig: `UsedSize = std.math.IntFittingRange(0, max + 1)` → u13. Rust has no u13; use u16.
 type OverflowUsedSize = u16;
 
 pub struct OverflowGroup<Block> {
@@ -2251,9 +2203,8 @@ impl<Block: OverflowBlock> OverflowGroup<Block> {
 
         if self.allocated <= self.used {
             debug_assert!((self.allocated as usize) < OVERFLOW_GROUP_SLOTS);
-            // Zig: default_allocator.create(Block) catch unreachable
             // SAFETY: Box<MaybeUninit> → zero() initializes the `used` counter; payload array
-            // is `[MaybeUninit<T>; N]` and stays uninit exactly as Zig does.
+            // is `[MaybeUninit<T>; N]` and intentionally stays uninit.
             let mut b: Box<core::mem::MaybeUninit<Block>> = Box::new_uninit();
             // SAFETY: `b.as_mut_ptr()` is a valid, exclusive, aligned `*mut Block`.
             unsafe { Block::zero(b.as_mut_ptr()) };
@@ -2275,14 +2226,12 @@ impl<Block: OverflowBlock> OverflowGroup<Block> {
 // OverflowList<ValueType, COUNT>
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): const-generic arithmetic (`[ValueType; COUNT]` inside a generic struct) requires
-// `feature(generic_const_exprs)` on stable Rust. Pin COUNT per instantiation site
-// or use a heap `Box<[ValueType]>` with debug_assert on len.
+// Const-generic arithmetic (deriving COUNT from another const param) requires
+// `feature(generic_const_exprs)` on stable Rust, so COUNT is pinned per instantiation site.
 
 pub struct OverflowListBlock<ValueType, const COUNT: usize> {
-    // Zig: `SizeType = std.math.IntFittingRange(0, count)`; use u32 here.
     pub used: u32,
-    // Zig leaves `items` undefined and overwrites by raw memcpy (no drop).
+    // Only `[0..used]` is initialized; writes are raw (no drop glue).
     pub items: [MaybeUninit<ValueType>; COUNT],
 }
 
@@ -2295,7 +2244,7 @@ impl<ValueType, const COUNT: usize> OverflowListBlock<ValueType, COUNT> {
     pub fn append(&mut self, value: ValueType) -> &mut ValueType {
         debug_assert!((self.used as usize) < COUNT);
         let index = self.used as usize;
-        // Raw write — slot may be uninit; Zig assignment has no drop glue.
+        // Raw write — slot may be uninit; no drop glue runs.
         self.items[index].write(value);
         self.used = self.used.wrapping_add(1);
         // SAFETY: just initialized on the line above.
@@ -2318,7 +2267,7 @@ impl<ValueType, const COUNT: usize> OverflowBlock for OverflowListBlock<ValueTyp
 
 pub struct OverflowList<ValueType, const COUNT: usize> {
     pub list: OverflowGroup<OverflowListBlock<ValueType, COUNT>>,
-    pub count: u32, // Zig: u31
+    pub count: u32,
 }
 
 impl<ValueType, const COUNT: usize> OverflowList<ValueType, COUNT> {
@@ -2429,40 +2378,41 @@ impl<ValueType, const COUNT: usize> OverflowList<ValueType, COUNT> {
 /// We do keep a pointer to it globally, but because the data is not zero-initialized, it ends up
 /// taking space in the object file. We don't want to spend 1-2 MB on these structs.
 ///
-/// TODO(port): const-generic arithmetic (`COUNT = _COUNT * 2`) and per-monomorphization
-/// a raw mutable INSTANCE static are not expressible on stable Rust. Instantiate per use-site
-/// via `macro_rules!` or pin concrete `COUNT` constants.
+/// Const-generic arithmetic (`COUNT = _COUNT * 2`) and a per-monomorphization
+/// raw mutable INSTANCE static are not expressible on stable Rust; callers
+/// pin concrete `COUNT` constants per use-site.
 ///
 /// `#[repr(C)]` with the small mutated scalars (`mutex`, `head`, `used`,
 /// `tail`'s header) laid out *before* the giant `backing_buf` array. Storage
 /// comes from [`bss_lazy_bytes`] (anonymous mmap, demand-zero), so each page
 /// faults only on first write. With default repr rustc placed `used: u32`
 /// *after* `backing_buf` (~1.2 MB into the largest instantiation), so
-/// `init_at`'s startup writes faulted tail pages Zig never touches. With this
+/// `init_at`'s startup writes faulted tail pages needlessly. With this
 /// layout every startup write lands in page 0 of the mapping; subsequent pages
 /// fault only as `append` actually fills them.
 #[repr(C)]
 pub struct BSSList<ValueType, const COUNT: usize /* = _COUNT * 2 */> {
     pub mutex: Mutex,
     // LIFETIMES.tsv: dual semantics — points at sibling `tail` OR a heap alloc.
-    // TODO(port): lifetime — keep raw NonNull; self-referential when `head == &self.tail`.
+    // Kept as a raw NonNull: self-referential when `head == &self.tail`, so a safe
+    // borrow cannot express it.
     pub head: Option<NonNull<BSSListOverflowBlock<ValueType>>>,
     pub used: u32,
     pub tail: BSSListOverflowBlock<ValueType>,
-    // Zig leaves `backing_buf` undefined; only `[0..used]` is initialized.
+    // Only `[0..used]` is initialized.
     pub backing_buf: [MaybeUninit<ValueType>; COUNT],
 }
 
 // SAFETY: `head` is a self-referential `NonNull` into `self.tail` or a heap block owned by
 // `self`; all mutation goes through `self.mutex`. The raw pointer is the only `!Sync` field;
-// the type is logically a mutex-guarded global (matches Zig's threadsafe singleton).
+// the type is logically a mutex-guarded global singleton.
 unsafe impl<ValueType: Send, const COUNT: usize> Send for BSSList<ValueType, COUNT> {}
 // SAFETY: see the `Send` impl directly above — all access is mutex-serialized.
 unsafe impl<ValueType: Send, const COUNT: usize> Sync for BSSList<ValueType, COUNT> {}
 
 const BSS_LIST_CHUNK_SIZE: usize = 256;
 
-/// Zig's per-store overflow-block size is `count / 4`; this shared constant must
+/// The per-store overflow-block size is `count / 4`; this shared constant must
 /// be >= the largest store's, i.e. the filename store's `8192 / 4`.
 pub const BSS_OVERFLOW_BLOCK_SIZE: usize = 2048;
 
@@ -2474,7 +2424,7 @@ pub const BSS_OVERFLOW_BLOCK_SIZE: usize = 2048;
 pub struct BSSListOverflowBlock<ValueType> {
     pub used: AtomicU16,
     pub prev: Option<Box<BSSListOverflowBlock<ValueType>>>,
-    // Zig leaves `data` undefined; only `[0..used]` is initialized.
+    // Only `[0..used]` is initialized.
     pub data: [MaybeUninit<ValueType>; BSS_LIST_CHUNK_SIZE],
 }
 
@@ -2483,9 +2433,6 @@ impl<ValueType> BSSListOverflowBlock<ValueType> {
     /// SAFETY: `this` must point to writable, properly-aligned storage of `Self`.
     #[inline]
     pub unsafe fn zero(this: *mut Self) {
-        // Avoid struct initialization syntax.
-        // This makes Bun start about 1ms faster.
-        // https://github.com/ziglang/zig/issues/24313
         // SAFETY: caller guarantees `this` points to writable, aligned storage of
         // `Self`. Raw `ptr::write` because `*this` may be uninit — assignment
         // would run drop glue on garbage (`prev: Option<Box<..>>`).
@@ -2500,7 +2447,7 @@ impl<ValueType> BSSListOverflowBlock<ValueType> {
         if index as usize >= BSS_LIST_CHUNK_SIZE {
             return Err(AllocError);
         }
-        // Raw write — slot may be uninit; Zig assignment has no drop glue.
+        // Raw write — slot may be uninit; no drop glue runs.
         self.data[index as usize].write(item);
         // SAFETY: just initialized on the line above.
         Ok(unsafe { self.data[index as usize].assume_init_mut() })
@@ -2528,7 +2475,6 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
     pub const CHUNK_SIZE: usize = BSS_LIST_CHUNK_SIZE;
     const MAX_INDEX: usize = COUNT - 1;
 
-    // Zig: `pub var instance: *Self = undefined; pub var loaded = false;`
     // Rust cannot define generic statics, so the per-monomorphization storage is
     // emitted at the *declare site* via `bss_list! { name: T, N }` (see macro
     // below), which owns a `SyncUnsafeCell<MaybeUninit<Self>>` + `Once` and
@@ -2552,36 +2498,35 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
     /// and the non-zero self-referential `head = &tail`. Both fields lead the
     /// `#[repr(C)]` layout, so every startup write stays within page 0 of the
     /// singleton mapping (see the layout note on [`BSSList`]). `backing_buf`
-    /// and `tail.data` are intentionally left uninitialized (Zig leaves them
-    /// `undefined`); only `[0..used]` is read.
+    /// and `tail.data` are intentionally left uninitialized; only `[0..used]`
+    /// is read.
     pub unsafe fn init_at(slot: *mut Self) {
         // SAFETY: caller contract — `slot` is a valid, exclusive, aligned,
         // all-zeros `*mut Self`.
         unsafe {
             addr_of_mut!((*slot).mutex).write(Mutex::new());
-            // Zig: `instance.head = &instance.tail` — self-referential; raw NonNull.
+            // Self-referential `head = &tail`; raw NonNull.
             let tail_ptr = addr_of_mut!((*slot).tail);
             addr_of_mut!((*slot).head).write(Some(NonNull::new_unchecked(tail_ptr)));
         }
     }
 
-    /// Heap-allocate and initialize a fresh instance. The once-guard (Zig's
-    /// `loaded` flag) is the *caller's* responsibility — use `bss_list!` for
+    /// Heap-allocate and initialize a fresh instance. The once-guard is the
+    /// *caller's* responsibility — use `bss_list!` for
     /// the canonical per-monomorphization singleton.
     pub fn init() -> NonNull<Self> {
         bss_heap_init(Self::init_at)
     }
 
-    // Zig `deinit` → `impl Drop for BSSList` below (PORTING.md: never expose `pub fn deinit`).
-    // The `instance.destroy()` + `loaded = false` half is singleton teardown — the
-    // `bss_list!` singleton wrapper owns that; Drop only frees the heap-allocated head chain.
+    // Singleton teardown belongs to the `bss_list!` singleton wrapper;
+    // Drop only frees the heap-allocated head chain.
 
     pub fn is_overflowing(instance: &Self) -> bool {
         instance.used as usize >= COUNT
     }
 
     pub fn exists(&self, value: &[u8]) -> bool {
-        // Zig: `isSliceInBuffer(value, &instance.backing_buf)` — pointer-range check
+        // Pointer-range check
         // against the backing storage as raw bytes. Done with addresses rather
         // than forming a `&[u8]` over `MaybeUninit<T>` storage (which would
         // assert byte-validity of uninitialized memory).
@@ -2601,8 +2546,7 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
         self.used += 1;
         // SAFETY: head is always non-null after init() (points at self.tail or heap block).
         let mut head_ptr = self.head.unwrap();
-        // Zig: `self.head.append(value) catch { allocate new block; retry }`.
-        // Restructured to check capacity first, allocate the new block if
+        // Check capacity first, allocate the new block if
         // needed, then reserve exactly one slot. Safe under `self.mutex`.
         // SAFETY: `head_ptr` is a valid exclusive ref (mutex held).
         let head_full = unsafe {
@@ -2616,7 +2560,7 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
             unsafe { BSSListOverflowBlock::zero(new_block.as_mut_ptr()) };
             // SAFETY: all non-`MaybeUninit` fields are now initialized.
             let mut new_block = unsafe { new_block.assume_init() };
-            // Preserve the chain (Zig: `new_block.prev = self.head`). The inline `self.tail`
+            // Preserve the chain (`new_block.prev` = old head). The inline `self.tail`
             // is not Boxed, so represent it as `prev = None`; heap heads were
             // `Box::into_raw`'d by an earlier call here and are reclaimed as `Box`.
             let tail_ptr: *const BSSListOverflowBlock<ValueType> = core::ptr::addr_of!(self.tail);
@@ -2642,8 +2586,8 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
     /// accounted in `used`, so leaving it uninitialized is UB on later read.
     ///
     /// This is the slot-reservation primitive: it lets large `ValueType`s be
-    /// constructed directly in the destination, matching Zig's result-location
-    /// semantics. The by-value `append` below forces a stack temporary +
+    /// constructed directly in the destination (result-location
+    /// semantics). The by-value `append` below forces a stack temporary +
     /// memcpy into the slot which Rust does not reliably NRVO across a
     /// non-inlined call boundary; `append_uninit` exposes the slot pointer so
     /// the caller's struct literal lowers straight into it.
@@ -2651,8 +2595,8 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
     /// Takes `*mut Self` (not `&mut self`) so callers can pass the raw
     /// `bss_list!` singleton pointer directly without first materializing a
     /// `&mut Self` — which would be aliased UB if two threads did so
-    /// concurrently *before* reaching the inner `self.mutex.lock()`. This
-    /// matches Zig's `*Self` receiver: the inner mutex is the sole
+    /// concurrently *before* reaching the inner `self.mutex.lock()`. The
+    /// inner mutex is the sole
     /// serialization point, so no caller-side outer lock is needed.
     ///
     /// SAFETY: `this` must point to a live, initialized `BSSList` (typically
@@ -2696,17 +2640,14 @@ impl<ValueType, const COUNT: usize> BSSList<ValueType, COUNT> {
         // this thread (index already bumped under the mutex).
         unsafe { Ok(core::ptr::from_mut((*slot).write(value))) }
     }
-
-    // Zig: `pub const Pair = struct { index: IndexType, value: *ValueType };`
-    // LIFETIMES.tsv: ARENA → *const ValueType. Type appears unused.
 }
 
 impl<ValueType, const COUNT: usize> Drop for BSSList<ValueType, COUNT> {
     fn drop(&mut self) {
-        // Zig `deinit`: `self.head.deinit()` walks `prev` and frees each heap block.
+        // Free the heap-allocated head chain.
         // The inline `self.tail` is not Boxed and must not be Box-dropped; the
         // `prev: Option<Box<..>>` chain stops at `None` before reaching it
-        // (see `append_overflow_uninit`). Singleton `loaded = false` reset belongs to the
+        // (see `append_overflow_uninit`). Singleton teardown belongs to the
         // `bss_list!` singleton wrapper, not here.
         if let Some(head) = self.head.take() {
             let tail_ptr: *const BSSListOverflowBlock<ValueType> = core::ptr::addr_of!(self.tail);
@@ -2733,21 +2674,20 @@ pub struct BSSListPair<ValueType> {
 /// Stores an initial count in .bss section of the object file.
 /// Overflows to heap when count is exceeded.
 ///
-/// TODO(port): same const-generic-arithmetic and per-type-static caveats as `BSSList`.
+/// Same const-generic-arithmetic and per-type-static caveats as `BSSList`.
 pub struct BSSStringList<
     const COUNT: usize,       /* = _COUNT * 2 */
     const ITEM_LENGTH: usize, /* = _ITEM_LENGTH + 1 */
 > {
-    // Zig keeps both arrays *inline* in the struct (`[count*item_length]u8`,
-    // `[count][]const u8`) so they live in the same demand-faulted allocation
-    // as the rest of the singleton and `init()` writes only the four scalar
+    // Inline arrays would live in the same demand-faulted allocation
+    // as the rest of the singleton with `init()` writing only the four scalar
     // fields — pages are committed lazily as `append` writes bytes. Stable
     // Rust can't spell `[u8; COUNT*ITEM_LENGTH]` without `generic_const_exprs`,
     // so we store fat pointers to *separate* `bss_lazy_bytes` mappings instead.
     // Same laziness guarantee (MAP_NORESERVE), same lifetime (process-static,
     // never freed), no eager memset.
     //
-    // `MaybeUninit` because Zig leaves both arrays `undefined`; only
+    // `MaybeUninit` because both arrays are logically uninitialized; only
     // `[..backing_buf_used]` / `[..slice_buf_used]` are ever read.
     pub backing_buf: NonNull<[MaybeUninit<u8>]>, // len == COUNT * ITEM_LENGTH
     pub backing_buf_used: u64,
@@ -2762,7 +2702,7 @@ struct EmptyType {
     len: usize,
 }
 
-/// Trait modeling Zig's `comptime AppendType` switch in `doAppend`.
+/// Byte sources accepted by the `append*` methods.
 pub trait BSSAppendable {
     /// Total byte length (excluding sentinel).
     fn total_len(&self) -> usize;
@@ -2817,11 +2757,9 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
     /// SAFETY: `slot` must point to writable, properly-aligned, uninitialized
     /// storage of `size_of::<Self>()` bytes that lives for `'static`.
     pub unsafe fn init_at(slot: *mut Self) {
-        // Zig (`bun_alloc.zig` BSSStringList.init): writes ONLY `allocator`,
-        // `backing_buf_used = 0`, `slice_buf_used = 0`, `overflow_list.zero()`,
-        // `mutex = .{}` — `backing_buf`/`slice_buf` are left `undefined` so the
-        // ~1.4 MiB of array storage stays unfaulted until `append` writes a byte.
-        // Match that exactly: lazy-map the arrays, write the four scalars, and
+        // `backing_buf`/`slice_buf` are left uninitialized so the
+        // ~1.4 MiB of array storage stays unfaulted until `append` writes a byte:
+        // lazy-map the arrays, write the four scalars, and
         // zero only the three OverflowList counters (its 32 KiB `ptrs` array is
         // already `[None; 4096]` because `slot` came from `bss_heap_init`).
         // SAFETY: caller contract — `slot` is a valid, exclusive, aligned
@@ -2842,7 +2780,7 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
         bss_heap_init(Self::init_at)
     }
 
-    // Zig `deinit`: just frees `instance`. Singleton is process-lifetime; never freed.
+    // Singleton is process-lifetime; never freed.
 
     #[inline]
     pub fn is_overflowing(instance: &Self) -> bool {
@@ -2859,8 +2797,6 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
         base <= p && p + value.len() <= end
     }
 
-    /// Zig `editableSlice(slice: []const u8) []u8 { return @constCast(slice); }`.
-    ///
     /// Rust cannot soundly express `&[u8] -> &mut [u8]` (instant UB under stacked borrows),
     /// so this takes raw parts instead. Callers that held a `&[u8]` must drop that borrow
     /// before calling and pass `(ptr, len)` derived from a `&mut`-provenance pointer.
@@ -2880,7 +2816,7 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
     /// `bss_string_list!` singleton pointer directly without first
     /// materializing a `&mut Self` — which would be aliased UB if two threads
     /// did so concurrently *before* reaching the inner `self.mutex.lock()`.
-    /// Matches Zig's `*Self` receiver: the inner mutex is the sole
+    /// The inner mutex is the sole
     /// serialization point, so no caller-side outer lock is needed.
     ///
     /// SAFETY: `this` must point to a live, initialized `BSSStringList`
@@ -2917,10 +2853,8 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
         this: *mut Self,
         args: core::fmt::Arguments<'_>,
     ) -> core::result::Result<&'a [u8], AllocError> {
-        // Zig's `std.fmt.count` + `std.fmt.bufPrint` are both comptime-expanded
-        // straight-line writes, so the count-then-write double pass is free
-        // there. Rust's `core::fmt::write` drives a `dyn fmt::Write` vtable per
-        // argument piece, so a literal port pays that dispatch *twice* — the
+        // `core::fmt::write` drives a `dyn fmt::Write` vtable per
+        // argument piece, so a count-then-write double pass pays that dispatch *twice* — the
         // dominant cost in `extract_tarball::build_url`, which is called once
         // per lockfile package with 6+ args.
         //
@@ -3040,8 +2974,8 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
     /// Returns `(ptr, len)` of the freshly-appended payload (excluding the trailing NUL),
     /// where `ptr` carries write provenance (`out.as_mut_ptr()`). Callers reconstruct a
     /// `&[u8]` (`append`) or `&mut [u8]` (`append_mutable`) from it; returning raw parts
-    /// avoids the `&self.backing_buf` ↔ `&mut self.slice_buf` borrowck conflict and the
-    /// `&[u8] → &mut [u8]` provenance laundering Zig's `@constCast` would imply.
+    /// avoids the `&self.backing_buf` ↔ `&mut self.slice_buf` borrowck conflict and
+    /// `&[u8] → &mut [u8]` provenance laundering.
     #[inline]
     fn do_append<A: BSSAppendable>(
         &mut self,
@@ -3073,7 +3007,7 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
 
             (out_ptr, out_len) = (dst.as_mut_ptr(), value_len - 1);
         } else {
-            // Zig: `var value_buf = try self.allocator.alloc(u8, value_len)` — propagate OOM.
+            // Propagate OOM.
             let ptr = default_alloc::malloc(value_len).cast::<u8>();
             if ptr.is_null() {
                 return Err(AllocError);
@@ -3100,8 +3034,7 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
         }
 
         // SAFETY: `out_ptr` addresses self.backing_buf or a process-lifetime alloc, both
-        // outliving 'static (singleton). Zig stores it as `[]const u8` with no lifetime
-        // tracking.
+        // outliving 'static (singleton).
         let stored: &'static [u8] = unsafe { core::slice::from_raw_parts(out_ptr, out_len) };
 
         if result.is_overflow() {
@@ -3120,7 +3053,7 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
             // SAFETY: `slice_buf` is a process-lifetime mapping of `COUNT`
             // `&[u8]`-sized slots owned by this singleton; `result.index() <
             // slice_buf_used <= COUNT`; we hold `&mut self`. Raw write — slot
-            // may be uninit (Zig leaves it `undefined`).
+            // may be uninit.
             unsafe {
                 self.slice_buf
                     .as_ptr()
@@ -3137,17 +3070,17 @@ impl<const COUNT: usize, const ITEM_LENGTH: usize> BSSStringList<COUNT, ITEM_LEN
 // BSSMap<ValueType, COUNT, STORE_KEYS, ESTIMATED_KEY_LENGTH, REMOVE_TRAILING_SLASHES>
 // ──────────────────────────────────────────────────────────────────────────
 
-// Zig returns one of two *different* struct types depending on `comptime store_keys: bool`.
+// Two different struct shapes depending on `store_keys`.
 // Rust cannot return different types from one generic; we expose both:
 //   - `BSSMapInner<V, COUNT, RM_SLASH>` (the `store_keys = false` shape)
 //   - `BSSMap<V, COUNT, EST_KEY_LEN, RM_SLASH>` (the `store_keys = true` wrapper)
-// TODO(port): callers that passed `store_keys=false` should name `BSSMapInner` directly.
+// Callers that passed `store_keys=false` should name `BSSMapInner` directly.
 
 pub struct BSSMapInner<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool> {
     pub index: IndexMap,
     pub overflow_list: OverflowList<ValueType, BSS_OVERFLOW_BLOCK_SIZE>,
     pub mutex: Mutex,
-    // Zig leaves `backing_buf` undefined; only `[0..backing_buf_used]` is initialized.
+    // Only `[0..backing_buf_used]` is initialized.
     pub backing_buf: [MaybeUninit<ValueType>; COUNT],
     pub backing_buf_used: u16,
 }
@@ -3167,7 +3100,7 @@ impl<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool>
         // `*mut Self` in all-zeros storage from `bss_heap_init`. The 32 KiB
         // `overflow_list.list.ptrs` array is already `[None; 4096]` (null
         // niche), so write only the three counters; `backing_buf` is
-        // intentionally left uninitialized (Zig: `undefined`).
+        // intentionally left uninitialized.
         unsafe {
             addr_of_mut!((*slot).mutex).write(Mutex::new());
             addr_of_mut!((*slot).index).write(IndexMap::default());
@@ -3182,7 +3115,6 @@ impl<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool>
         bss_heap_init(Self::init_at)
     }
 
-    // Zig `deinit`: `self.index.deinit(allocator)` then free instance.
     // With `IndexMap = HashMap`, Drop frees it; singleton Box drop frees instance.
 
     pub fn is_overflowing(instance: &Self) -> bool {
@@ -3236,7 +3168,7 @@ impl<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool>
 
     pub fn get(&mut self, denormalized_key: &[u8]) -> Option<&mut ValueType> {
         let _key = Self::key_hash(denormalized_key);
-        // Hold the lock across `at_index` (Zig: `defer self.mutex.unlock()` at fn scope) —
+        // Hold the lock across `at_index` —
         // a concurrent `put()` could otherwise mutate `overflow_list`/`backing_buf` while
         // we dereference `index`. `MutexGuard` holds a raw pointer (see [`Mutex`] docs),
         // so it does not conflict with the `&mut self` borrow in `at_index`.
@@ -3295,7 +3227,7 @@ impl<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool>
             }
         } else {
             let idx = result.index.index() as usize;
-            // Raw write — fresh slots are uninit; Zig assignment has no drop glue.
+            // Raw write — fresh slots are uninit; no drop glue runs.
             self.backing_buf[idx].write(value);
             // SAFETY: just initialized on the line above.
             unsafe { self.backing_buf[idx].assume_init_mut() }
@@ -3309,7 +3241,6 @@ impl<ValueType, const COUNT: usize, const REMOVE_TRAILING_SLASHES: bool>
         let _guard = self.mutex.lock();
         let _key = Self::key_hash(denormalized_key);
         self.index.remove(&_key).is_some()
-        // (Zig has commented-out per-slot deinit code here; intentionally not ported.)
     }
 
     pub fn values(&mut self) -> &mut [ValueType] {
@@ -3338,15 +3269,12 @@ pub struct BSSMap<
     // allocator's `dealloc`).
     map: NonNull<BSSMapInner<ValueType, COUNT, REMOVE_TRAILING_SLASHES>>,
     // Same lazy-fault treatment as `BSSStringList::backing_buf` — see the
-    // struct-level comment there. Zig keeps these inline; we map separately
+    // struct-level comment there. Mapped separately
     // because `[u8; COUNT*ESTIMATED_KEY_LENGTH]` needs `generic_const_exprs`.
     pub key_list_buffer: NonNull<[MaybeUninit<u8>]>, // len == COUNT * ESTIMATED_KEY_LENGTH
     pub key_list_buffer_used: usize,
     pub key_list_slices: NonNull<[MaybeUninit<&'static [u8]>]>, // len == COUNT
-    // TODO(port): Zig declares this as `OverflowList([]u8, count / 4)` but then calls
-    // `.items[...]` and `.append(allocator, slice)` on it — those are `std.ArrayListUnmanaged`
-    // methods, NOT `OverflowList` methods. Likely dead code or a latent bug upstream.
-    // Ported as `Vec<&'static [u8]>` to match the *called* API.
+    // Indexed by the *absolute* index (not overflow-relative) in `key_at_index`.
     pub key_list_overflow: Vec<&'static [u8]>,
 }
 
@@ -3395,7 +3323,7 @@ impl<
         unsafe { self.map.as_mut() }
     }
 
-    // Zig `deinit`: `self.map.deinit()` then free instance — process-lifetime; never freed.
+    // Process-lifetime; never freed.
 
     pub fn is_overflowing(instance: &Self) -> bool {
         instance.map().backing_buf_used as usize >= COUNT
@@ -3406,12 +3334,10 @@ impl<
     }
 
     pub fn get(&mut self, key: &[u8]) -> Option<&mut ValueType> {
-        // PERF(port): Zig uses @call(bun.callmod_inline, ...) — profile if hot.
         self.map_mut().get(key)
     }
 
     pub fn at_index(&mut self, index: IndexType) -> Option<&mut ValueType> {
-        // PERF(port): Zig uses @call(bun.callmod_inline, ...) — profile if hot.
         self.map_mut().at_index(index)
     }
 
@@ -3429,7 +3355,7 @@ impl<
                     // a process-lifetime mapping of `COUNT` slots.
                     Some(unsafe { *self.key_list_slices.cast::<&'static [u8]>().as_ptr().add(i) })
                 } else {
-                    // TODO(port): see key_list_overflow note — Zig indexes `.items` here.
+                    // See the `key_list_overflow` field note.
                     Some(self.key_list_overflow[index.index() as usize])
                 }
             }
@@ -3442,8 +3368,8 @@ impl<
         result: &mut Result,
         value: ValueType,
     ) -> core::result::Result<&mut ValueType, AllocError> {
-        // PORT NOTE: reshaped for borrowck — Zig returns `ptr` from map.put then calls put_key;
-        // Rust can't hold &mut ValueType across &mut self.put_key. Stash as raw, re-borrow after.
+        // Reshaped for borrowck — Rust can't hold &mut ValueType across
+        // &mut self.put_key. Stash as raw, re-borrow after.
         let ptr: *mut ValueType = self.map_mut().put(result, value)?;
         if STORE_KEY {
             self.put_key(key, result)?;
@@ -3495,7 +3421,7 @@ impl<
             // SAFETY: points into self.key_list_buffer (singleton-static lifetime).
             slice = unsafe { core::slice::from_raw_parts(dst.as_ptr(), dst.len()) };
         } else {
-            // Zig: `slice = try self.map.allocator.dupe(u8, key);` — propagate OOM. Route
+            // Propagate OOM. Route
             // through mimalloc directly (PORTING.md forbids `Box::leak`) so the
             // size-agnostic `mi_free` below stays valid even after `trim_right` shortens
             // the stored slice.
@@ -3521,7 +3447,7 @@ impl<
             debug_assert!(i < COUNT);
             // SAFETY: `key_list_slices` is a process-lifetime mapping of
             // `COUNT` slots; `i < COUNT`; we hold `&mut self`. Raw write —
-            // slot may be uninit (Zig leaves it `undefined`).
+            // slot may be uninit.
             unsafe {
                 self.key_list_slices
                     .as_ptr()
@@ -3530,12 +3456,12 @@ impl<
                     .write(MaybeUninit::new(slice));
             }
         } else {
-            // TODO(port): see key_list_overflow note above re: `.items` / `.append(alloc, _)`.
+            // See the `key_list_overflow` field note.
             let idx = result.index.index() as usize;
             if self.key_list_overflow.len() > idx {
                 let existing_slice = self.key_list_overflow[idx];
                 if !self.is_key_statically_allocated(existing_slice) {
-                    // Zig: self.map.allocator.free(existing_slice). `mi_free` is
+                    // `mi_free` is
                     // size-agnostic, so a trimmed (shorter) stored slice is fine.
                     // SAFETY: existing_slice was `mi_malloc`'d by a prior put_key call
                     // (the only non-static-buffer source above) and not yet freed.
@@ -3572,8 +3498,8 @@ impl<
 // Allocator-trait surface — OBSOLETE per PORTING.md §Allocators
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig's `std.mem.Allocator` / `GenericAllocator` interface threaded an allocator
-// param through every fn because Zig has no global allocator. Rust does
+// The legacy allocator interface threaded an allocator
+// param through every fn. Rust has a global allocator
 // (`#[global_allocator] = Mimalloc` above), so per PORTING.md:
 //
 //   - Non-AST crates: DELETE the `allocator` param. `Box`/`Vec`/`String` use
@@ -3585,10 +3511,10 @@ impl<
 // it; do not add methods. Callers should be rewritten to drop the param
 // entirely.
 
-/// Marker trait standing in for Zig `std.mem.Allocator`. See module note.
+/// Legacy allocator marker trait. See module note.
 ///
-/// Provides a `type_id()` hook so `is_instance`-style checks (Zig:
-/// `allocator.vtable == &vtable`) can be expressed as concrete-type identity
+/// Provides a `type_id()` hook so `is_instance`-style vtable-identity checks
+/// can be expressed as concrete-type identity
 /// on the trait object — every implementor gets a default `type_id()` that
 /// returns its monomorphized `TypeId`.
 pub trait Allocator: 'static {
@@ -3601,7 +3527,7 @@ pub trait Allocator: 'static {
 impl dyn Allocator {
     /// Is the concrete type behind this `&dyn Allocator` exactly `T`?
     ///
-    /// Zig's `allocator.vtable == &T.vtable` check, expressed as `TypeId`
+    /// A vtable-identity check, expressed as `TypeId`
     /// identity via the trait's `type_id()` hook (dynamic dispatch on the
     /// dyn receiver — NOT `Any::type_id`). All per-type
     /// `Foo::is_instance(alloc)` associated fns delegate here.
@@ -3613,7 +3539,7 @@ impl dyn Allocator {
 
 /// Checks whether `allocator` is the default allocator.
 ///
-/// Zig: `return allocator.vtable == c_allocator.vtable;` — compare identity
+/// Compares identity
 /// against the global mimalloc-backed allocator. With `#[global_allocator] =
 /// Mimalloc`, the Rust default is `DefaultAlloc`; vtable-identity becomes a
 /// `TypeId` comparison.
@@ -3622,7 +3548,7 @@ pub fn is_default(alloc: &dyn Allocator) -> bool {
     alloc.is::<DefaultAlloc>()
 }
 
-/// Legacy ZST naming `bun.default_allocator`. With `#[global_allocator]` set,
+/// Legacy default-allocator ZST. With `#[global_allocator]` set,
 /// this is just a unit marker.
 #[derive(Clone, Copy, Default)]
 pub struct DefaultAlloc;
@@ -3630,7 +3556,7 @@ impl Allocator for DefaultAlloc {}
 
 static DEFAULT_ALLOC: DefaultAlloc = DefaultAlloc;
 
-/// Zig: `bun.default_allocator` — global mimalloc-backed allocator. With
+/// Global mimalloc-backed allocator handle. With
 /// `#[global_allocator] = Mimalloc`, this is a marker handle; callers that
 /// thread it should be rewritten to use `Box`/`Vec` directly. Kept so ported
 /// call sites that still pass an `&dyn Allocator` resolve.
@@ -3640,18 +3566,14 @@ pub fn default_allocator() -> &'static dyn Allocator {
 }
 
 // `GenericAllocator` / `Borrowed<A>` / `Nullable<A>` are dropped — they modelled
-// Zig's allocator-borrowing discipline (avoid double-deinit), which Rust's
-// ownership already enforces. Drafts that referenced them are gated under
-// `` and will be rewritten to drop the param when un-gated.
+// an allocator-borrowing discipline (avoid double-free), which Rust's
+// ownership already enforces.
 
 // ──────────────────────────────────────────────────────────────────────────
 // `basic` module selection
 // ──────────────────────────────────────────────────────────────────────────
 
-// `basic.zig` ported as `impl GlobalAlloc for Mimalloc` above (the real impl).
-// Draft kept for diff-pass only.
+// The real impl is `impl GlobalAlloc for Mimalloc` above.
 #[path = "basic.rs"]
 pub mod basic;
 pub mod memory;
-
-// ported from: src/bun_alloc/bun_alloc.zig
diff --git a/src/bun_alloc/maybe_owned.rs b/src/bun_alloc/maybe_owned.rs
index 65411d46868..88f0f0a4a0b 100644
--- a/src/bun_alloc/maybe_owned.rs
+++ b/src/bun_alloc/maybe_owned.rs
@@ -11,20 +11,15 @@
 //! drop(borrowed_foo); // no-op
 //! ```
 //!
-//! This type is a `GenericAllocator`; see `src/allocators.zig`.
-//!
-//! PORT NOTE: Zig modelled this over `Nullable<A>` / `Borrowed<A>` allocator
-//! adaptors. With `#[global_allocator]`, "owned" reduces to "drop the box,
-//! borrowed = leak"; the generic allocator threading is dropped. The struct
-//! keeps the `Option<A>` shape so callers that pattern-match on
-//! `is_owned()` keep working.
+//! With `#[global_allocator]`, "owned" reduces to "drop the box"; borrowed
+//! drops are a no-op. The struct keeps the `Option<A>` shape so callers that
+//! pattern-match on `is_owned()` keep working.
 
 /// See module docs.
 pub struct MaybeOwned<A> {
     _parent: Option<A>,
 }
 
-// Zig: `pub const Borrowed = MaybeOwned(BorrowedParent);`
 // Rust has no stable inherent associated types, so expose as a free alias.
 // `Borrowed<A>` collapsed to `()` — borrows carry no allocator state.
 pub(crate) type MaybeOwnedBorrowed = MaybeOwned<()>;
@@ -34,7 +29,6 @@ impl<A: Default> MaybeOwned<A> {
     ///
     /// Allocations are forwarded to a default-initialized `A`.
     pub fn init() -> Self {
-        // Zig: `bun.memory.initDefault(Allocator)`
         Self::init_owned(A::default())
     }
 }
@@ -78,9 +72,6 @@ impl<A> MaybeOwned<A> {
     }
 }
 
-// Zig `deinit` only forwarded to `bun.memory.deinit(parent_alloc)` on the owned field.
-// Per PORTING.md (Idiom map: `pub fn deinit`), that is exactly field drop glue on
-// `_parent: Option<A>`, so no explicit `Drop` impl — keeping one would also forbid
-// moving `self._parent` out in `into_parent(self)`.
-
-// ported from: src/bun_alloc/maybe_owned.zig
+// Cleanup is exactly field drop glue on `_parent: Option<A>`, so no explicit
+// `Drop` impl — keeping one would also forbid moving `self._parent` out in
+// `into_parent(self)`.
diff --git a/src/bun_alloc/memory.rs b/src/bun_alloc/memory.rs
index bc97888d15d..860e6919f75 100644
--- a/src/bun_alloc/memory.rs
+++ b/src/bun_alloc/memory.rs
@@ -1,34 +1,5 @@
 //! Basic utilities for working with memory and objects.
 
-// ──────────────────────────────────────────────────────────────────────────────
-// PORT NOTE: `exemptedFromDeinit`, `deinitIsVoid`, and `deinit` are intentionally
-// NOT ported as functions.
-//
-// Zig's `bun.memory.deinit(ptr_or_slice)` walked `@typeInfo` to:
-//   - recurse into slices/arrays/optionals/error-unions,
-//   - call `.deinit()` on struct / tagged-union pointees (unless the type set
-//     `pub const deinit = void;` or was in an exemption list), and
-//   - finally write `undefined` over the memory if the pointer was mutable.
-//
-// Rust's `Drop` already does the recursive part automatically: dropping a value
-// drops every field, every `Vec`/`Box` element, every `Option`/`Result` payload.
-// The "write undefined" poisoning has no safe Rust equivalent (and is a debug aid,
-// not semantics).
-//
-// Call sites:
-//   - `bun.memory.deinit(&x)`       → delete (let `x` drop at scope exit).
-//   - `bun.memory.deinit(slice)`    → delete (slice elements drop with their owner).
-//   - explicit early release        → `drop(x)` or a type-specific `close(self)`.
-//
-// `@typeInfo` has no Rust equivalent (§Comptime reflection), so a faithful generic
-// port is not possible — and per §Idiom map, `deinit` definitions become `impl Drop`
-// on the target type, not a free function here.
-//
-// TODO(port): if any caller relied on the `*x = undefined` poisoning to catch UAF in
-// debug, add `#[cfg(debug_assertions)] unsafe { ptr::write_bytes(p, 0xAA, 1) }` at
-// that call site.
-// ──────────────────────────────────────────────────────────────────────────────
-
 /// Rebase a slice from one memory buffer to another buffer.
 ///
 /// Given a slice which points into a memory buffer with base `old_base`, return a
@@ -65,5 +36,3 @@ pub unsafe fn rebase_slice<'a>(slice: &[u8], old_base: *const u8, new_base: *con
     // `slice.len()` bytes.
     unsafe { core::slice::from_raw_parts(new_base.add(offset), slice.len()) }
 }
-
-// ported from: src/bun_alloc/memory.zig
diff --git a/src/bun_alloc/stack_fallback.rs b/src/bun_alloc/stack_fallback.rs
index 69880418b7b..22427f6a97d 100644
--- a/src/bun_alloc/stack_fallback.rs
+++ b/src/bun_alloc/stack_fallback.rs
@@ -1,16 +1,11 @@
-//! `StackFallback<N, A>` — port of Zig `std.heap.StackFallbackAllocator(N)`
-//! (vendor/zig/lib/std/heap.zig:376-481), inlining `FixedBufferAllocator`
-//! (vendor/zig/lib/std/heap/FixedBufferAllocator.zig). The `&mut [u8]` self-ref
-//! Zig keeps in `fixed_buffer_allocator.buffer` is replaced by computing
-//! `buf.get().cast::<u8>()` on demand, so the Rust struct is **not**
+//! `StackFallback<N, A>` — bump-allocate from an inline stack buffer, spilling
+//! to a fallback allocator on overflow. The buffer base is computed via
+//! `buf.get().cast::<u8>()` on demand, so the struct is **not**
 //! self-referential and may be moved freely until the first `allocate`.
 //!
 //! ### Relationship to `AstAlloc`
 //! `StackFallback` is a **standalone** [`Allocator`]; it is **not** composed
-//! under [`crate::ast_alloc::AstAlloc`]. In Zig, `stackFallback` and
-//! `ASTMemoryAllocator` are orthogonal — none of the 20 `stackFallback`
-//! callsites route AST-node allocation through it (the two `js_parser` uses
-//! pass `bun.default_allocator` as fallback, not the AST arena). `AstAlloc`
+//! under [`crate::ast_alloc::AstAlloc`]. `AstAlloc`
 //! has its own inline-buffer-with-heap-fallback state
 //! ([`crate::ast_alloc::AstAllocState`]). Under this standalone design
 //! `AstVec<T>` stays 24 B; only vecs that explicitly want stack-first storage
@@ -18,8 +13,6 @@
 //!
 //! ### Callsite shape
 //! ```ignore
-//! // Zig:  var sf = std.heap.stackFallback(4096, bun.default_allocator);
-//! //       var list = std.ArrayList(u8).initCapacity(sf.get(), 256);
 //! let sf = StackFallback::<4096>::with_global();
 //! let mut list: Vec<u8, _> = Vec::with_capacity_in(256, sf.get());
 //! // `&sf` borrows ⇒ `sf` is pinned for `list`'s lifetime; `Vec` is 32 B.
@@ -32,8 +25,8 @@ use core::ptr::{self, NonNull};
 
 use crate::{MimallocArena, alloc_result, mimalloc};
 
-/// `std.heap.StackFallbackAllocator(N)` — bump-allocate from an inline
-/// `[u8; N]` stack buffer; spill to `fallback` when it doesn't fit.
+/// Bump-allocate from an inline `[u8; N]` stack buffer; spill to `fallback`
+/// when it doesn't fit.
 /// `deallocate`/`grow` dispatch by address-range check ([`Self::owns`]).
 ///
 /// Lives on the caller's stack frame; single-threaded by construction
@@ -41,14 +34,14 @@ use crate::{MimallocArena, alloc_result, mimalloc};
 /// cross threads with a stack pointer inside it).
 ///
 /// `N` guidance: default to **1024** for "format a small string / build a
-/// short list" (modal Zig choice; well under the 8 KB Windows `__chkstk`
+/// short list" (well under the 8 KB Windows `__chkstk`
 /// threshold). **4096** for path-ish buffers. Cap at **16 KB** — anything
 /// larger should go straight to `MimallocArena`/`Global`.
 #[repr(C)] // keep `buf` at a fixed offset; `align_of::<Self>() == align_of::<A>().max(word)`
 pub struct StackFallback<const N: usize, A: Allocator = std::alloc::Global> {
     /// Bump cursor into `buf`. `Cell` so `Allocator::allocate(&self)` can advance it.
     cur: Cell<usize>,
-    /// `get_called` debug guard (Zig heap.zig:398) — trips on second `get()`
+    /// Debug guard — trips on second `get()`
     /// without an intervening `reset()`, catching the "two Vecs share one
     /// buffer" footgun.
     #[cfg(debug_assertions)]
@@ -60,7 +53,7 @@ pub struct StackFallback<const N: usize, A: Allocator = std::alloc::Global> {
 }
 
 impl<const N: usize, A: Allocator> StackFallback<N, A> {
-    /// Zig: `std.heap.stackFallback(N, fallback)`. `const` — `MaybeUninit<u8>:
+    /// `const` — `MaybeUninit<u8>:
     /// Copy`, so `[MaybeUninit::uninit(); N]` needs no inline-const;
     /// `Cell::new`/`UnsafeCell::new` are `const fn`.
     #[inline]
@@ -74,9 +67,9 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
         }
     }
 
-    /// Zig: `StackFallbackAllocator.get()` — reset the bump region and return
-    /// the allocator handle. Debug-asserts single call (heap.zig:404). In Rust
-    /// the "handle" is just `&self` (blanket `impl Allocator for &Self` below),
+    /// Reset the bump region and return the allocator handle.
+    /// Debug-asserts single call. The "handle" is just `&self`
+    /// (blanket `impl Allocator for &Self` below),
     /// so callers may equivalently write `Vec::new_in(&sf)` directly and skip
     /// this.
     #[inline]
@@ -89,7 +82,6 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
         self
     }
 
-    /// Zig: `fixed_buffer_allocator.reset()` (FixedBufferAllocator.zig:145).
     /// `&mut self` proves no live borrows into `buf`.
     #[inline]
     pub fn reset(&mut self) {
@@ -109,7 +101,6 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
         self.buf.get().cast::<u8>()
     }
 
-    /// Zig: `FixedBufferAllocator.ownsPtr` (FixedBufferAllocator.zig:46).
     /// Integer-address compare (NOT `offset_from` — `p` may belong to
     /// `fallback`, a different allocation).
     #[inline]
@@ -119,14 +110,12 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
         q >= base && q < base.wrapping_add(N)
     }
 
-    /// Zig: `FixedBufferAllocator.isLastAllocation` (FixedBufferAllocator.zig:58).
     #[inline(always)]
     fn is_last(&self, p: *const u8, len: usize) -> bool {
         p.addr().wrapping_add(len) == self.buf_base().addr().wrapping_add(self.cur.get())
     }
 
-    /// Zig: `FixedBufferAllocator.alloc` (FixedBufferAllocator.zig:62) — align
-    /// `cur` up, carve `len` bytes, or `None` if it doesn't fit.
+    /// Align `cur` up, carve `len` bytes, or `None` if it doesn't fit.
     #[inline]
     fn bump(&self, layout: Layout) -> Option<NonNull<u8>> {
         let base = self.buf_base().addr();
@@ -149,7 +138,7 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
     }
 
     /// `bumpalo::Bump::alloc` parity — move `val` into the bump front (or the
-    /// fallback on overflow). Aborts on OOM, matching Zig's `catch unreachable`.
+    /// fallback on overflow). Aborts on OOM.
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn alloc<T>(&self, val: T) -> &mut T {
@@ -167,8 +156,7 @@ impl<const N: usize, A: Allocator> StackFallback<N, A> {
 }
 
 impl<const N: usize> StackFallback<N, std::alloc::Global> {
-    /// `std.heap.stackFallback(N, bun.default_allocator)` — the 90 % case
-    /// (15 of 20 Zig callsites pass `default_allocator`/`bun.default_allocator`).
+    /// `StackFallback` backed by the global allocator — the common case.
     #[inline]
     pub const fn with_global() -> Self {
         Self::new(std::alloc::Global)
@@ -177,8 +165,7 @@ impl<const N: usize> StackFallback<N, std::alloc::Global> {
 
 // Implemented on `&Self` (NOT `Self`) so the buffer cannot be moved into an
 // owning container by value (`Box::new_in(x, sf)` would dangle). Mirrors
-// `unsafe impl Allocator for &MimallocArena` (MimallocArena.rs:652) and Zig's
-// `get()`-returns-borrowing-vtable shape.
+// `unsafe impl Allocator for &MimallocArena` (MimallocArena.rs:652).
 //
 // SAFETY:
 // - `allocate`: returns either (a) a slice of `self.buf` aligned to
@@ -193,11 +180,10 @@ impl<const N: usize> StackFallback<N, std::alloc::Global> {
 // - `grow`/`shrink`: see per-method notes; old block is always either left
 //   valid (returned same ptr) or fully copied-then-deallocated before return.
 // `StackFallback` is `!Sync` (via `Cell`/`UnsafeCell`), enforcing single-
-// thread use of the cursor — same constraint as Zig's SFA.
+// thread use of the cursor.
 unsafe impl<const N: usize, A: Allocator> Allocator for &StackFallback<N, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-        // Zig heap.zig:432 — try fixed buffer, else fallback.
         if let Some(p) = self.bump(layout) {
             return Ok(NonNull::slice_from_raw_parts(p, layout.size()));
         }
@@ -207,7 +193,7 @@ unsafe impl<const N: usize, A: Allocator> Allocator for &StackFallback<N, A> {
     #[inline]
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
         if self.owns(ptr.as_ptr()) {
-            // Zig FixedBufferAllocator.free:125 — rewind only the last alloc.
+            // Rewind only the last alloc.
             if self.is_last(ptr.as_ptr(), layout.size()) {
                 self.cur.set(self.cur.get() - layout.size());
             }
@@ -225,7 +211,7 @@ unsafe impl<const N: usize, A: Allocator> Allocator for &StackFallback<N, A> {
         new: Layout,
     ) -> Result<NonNull<[u8]>, AllocError> {
         if self.owns(ptr.as_ptr()) {
-            // Zig FixedBufferAllocator.resize:86-101 — last-alloc bump-in-place.
+            // Last-alloc bump-in-place.
             if self.is_last(ptr.as_ptr(), old.size()) {
                 let add = new.size() - old.size();
                 if self.cur.get() + add <= N {
@@ -234,7 +220,6 @@ unsafe impl<const N: usize, A: Allocator> Allocator for &StackFallback<N, A> {
                 }
             }
             // Spill: alloc new (stack-or-fallback), memcpy, free old.
-            // Mirrors Zig `Allocator.realloc` slow path after `remap` returns null.
             let newp = self.allocate(new)?;
             // SAFETY: `newp` is fresh ≥`new.size()` bytes; `old.size()` bytes at
             // `ptr` are init per `grow` contract; `old.size() <= new.size()`. If
@@ -260,7 +245,7 @@ unsafe impl<const N: usize, A: Allocator> Allocator for &StackFallback<N, A> {
         new: Layout,
     ) -> Result<NonNull<[u8]>, AllocError> {
         if self.owns(ptr.as_ptr()) {
-            // FixedBufferAllocator.resize:86-94 — last-alloc shrink rewinds
+            // Last-alloc shrink rewinds
             // `cur`; non-last shrink keeps the slot (already holds ≥new bytes
             // at ≥old.align()).
             if self.is_last(ptr.as_ptr(), old.size()) {
@@ -395,9 +380,6 @@ unsafe impl Allocator for ArenaPtr {
     }
 }
 
-// ported from: vendor/zig/lib/std/heap.zig (stackFallback / StackFallbackAllocator)
-// ported from: vendor/zig/lib/std/heap/FixedBufferAllocator.zig (inlined)
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/bun_bin/lib.rs b/src/bun_bin/lib.rs
index 9ec80f18f1d..bb441925155 100644
--- a/src/bun_bin/lib.rs
+++ b/src/bun_bin/lib.rs
@@ -1,11 +1,11 @@
 //! `libbun_rust.a` — the Rust-port staticlib.
 //!
 //! Built by `cargo build -p bun_bin` (emitted from `scripts/build/rust.ts`)
-//! and linked into the final `bun-debug` executable by ninja's link step,
-//! occupying the slot `bun-zig.o` used to. The clang++ driver supplies the
+//! and linked into the final `bun-debug` executable by ninja's link step.
+//! The clang++ driver supplies the
 //! C runtime startup (`_start` → `main`); `main` below is the process entry.
 //!
-//! Init order mirrors `src/main.zig`:
+//! Init order:
 //!   1. crash handler / signal masks
 //!   2. allocator wiring (mimalloc as `#[global_allocator]`)
 //!   3. argv / start-time capture
@@ -45,8 +45,7 @@ use bun_core::Global;
 use bun_core::StackCheck;
 use bun_core::output;
 
-/// mimalloc as the process allocator — matches Zig's `bun.default_allocator`
-/// and the `uv_replace_allocator(mi_*)` call in `main.zig` on Windows.
+/// mimalloc as the process allocator.
 #[cfg(not(bun_asan))]
 #[global_allocator]
 static ALLOC: bun_alloc::Mimalloc = bun_alloc::Mimalloc;
@@ -76,7 +75,7 @@ pub extern "C" fn __asan_default_options() -> *const core::ffi::c_char {
     // detect_leaks=0: off by default (Linux defaults it on); CI opts in via
     //   ASAN_OPTIONS with a suppressions file.
     //
-    // PORT NOTE: matches `src/safety/asan.zig` exactly. Do NOT add `symbolize=0`
+    // Do NOT add `symbolize=0`
     // here — LSAN's function-name suppression matching (`test/leaksan.supp`)
     // requires symbolized stacks; with symbolization disabled every entry like
     // `leak:uws_create_app` silently stops matching and CI reports the
@@ -86,16 +85,12 @@ pub extern "C" fn __asan_default_options() -> *const core::ffi::c_char {
 }
 
 /// LSAN built-in suppressions, merged with whatever `LSAN_OPTIONS=suppressions=`
-/// the CI runner passes (`test/leaksan.supp`). That file's entries were written
-/// against Zig's symbol mangling (`runtime.node.zlib.NativeZlib.Context.init`,
-/// `jsc.web_worker.create`, …); LSAN matches by *substring on a symbolized
-/// frame*, so after the Rust port renamed every frame to `bun_<crate>::<mod>`
-/// none of the Zig-named rules fire and CI reports the same intentionally-
-/// leaked-at-exit allocations the suppressions were authored for. Baking the
-/// Rust spellings into the binary keeps `leaksan.supp` as the C/C++/JSC list
-/// and lets the Rust list ride with the code that produces the symbols.
+/// the CI runner passes (`test/leaksan.supp`). LSAN matches by *substring on a
+/// symbolized frame*; baking the Rust symbol spellings into the binary keeps
+/// `leaksan.supp` as the C/C++/JSC list and lets the Rust list ride with the
+/// code that produces the symbols.
 ///
-/// Also covers one Rust-only false positive that has no Zig analogue:
+/// Also covers one Rust-only false positive:
 /// `std::thread::Builder::spawn` allocates an `Arc<thread::Inner>` that the
 /// detached thread holds in TLS for its lifetime; LSAN does not scan other
 /// threads' TLS roots at exit, so every long-lived detached thread (HTTP
@@ -141,7 +136,7 @@ pub extern "C" fn __lsan_default_suppressions() -> *const core::ffi::c_char {
 }
 
 /// Process entry point. `extern "C"` so the linker resolves crt1.o's
-/// undefined `main` against this symbol — same role as Zig's `pub fn main`.
+/// undefined `main` against this symbol.
 ///
 /// `argc`/`argv` are forwarded to `bun_core::init_argv` immediately: on
 /// glibc/macOS/Windows libstd also captures them via a `.init_array` hook /
@@ -149,8 +144,7 @@ pub extern "C" fn __lsan_default_suppressions() -> *const core::ffi::c_char {
 /// receives no arguments (musl's `__libc_start_main` does not pass
 /// `(argc,argv,envp)` to constructors), so `std::env::args_os()` returns
 /// empty and the binary would see argc=0. Capturing the C-runtime-provided
-/// pair here is the only portable source — same contract as Zig's
-/// `bun.initArgv` wrapping `std.os.argv`.
+/// pair here is the only portable source.
 ///
 /// # Safety
 /// `argv` must point to `argc` valid NUL-terminated C strings that live for
@@ -166,7 +160,7 @@ pub unsafe extern "C" fn main(argc: c_int, argv: *const *const c_char) -> c_int
     // 1. Crash handler first so anything below gets a usable trace.
     bun_crash_handler::init();
 
-    // SIGPIPE/SIGXFSZ → SIG_IGN, like main.zig's posix block.
+    // SIGPIPE/SIGXFSZ → SIG_IGN.
     // SAFETY: `SIGPIPE`/`SIGXFSZ` are valid signal numbers and `SIG_IGN` is a
     // valid disposition; called once on the main thread before any other
     // thread is spawned, so there is no concurrent sigaction.
@@ -176,10 +170,9 @@ pub unsafe extern "C" fn main(argc: c_int, argv: *const *const c_char) -> c_int
         libc::signal(libc::SIGXFSZ, libc::SIG_IGN);
     }
 
-    // main.zig:40-50 — Windows-only startup. Must run BEFORE the first libuv
+    // Windows-only startup. Must run BEFORE the first libuv
     // call (uv allocator) and before anything reads `Bun.env`/`process.env`
-    // (env conversion). The Zig spec orders these between sigaction and
-    // `start_time`/`initArgv`.
+    // (env conversion).
     #[cfg(windows)]
     {
         // SAFETY: mimalloc fns match the libuv allocator signatures; called
@@ -207,7 +200,7 @@ pub unsafe extern "C" fn main(argc: c_int, argv: *const *const c_char) -> c_int
     output::stdio::init();
     let _flush = output::flush_guard();
 
-    // main.zig: `bun_warn_avx_missing(...)` — x86_64 + SIMD + posix only.
+    // `bun_warn_avx_missing(...)` — x86_64 + SIMD + posix only.
     #[cfg(all(target_arch = "x86_64", unix))]
     if bun_core::Environment::ENABLE_SIMD {
         unsafe extern "C" {
@@ -229,8 +222,7 @@ pub unsafe extern "C" fn main(argc: c_int, argv: *const *const c_char) -> c_int
 
     // 6. Push high-tier allocator vtable addresses into the
     //    `bun_safety::alloc::has_ptr` registry so debug-only allocator-mismatch
-    //    checks can identify `LinuxMemFdAllocator`/`MimallocArena` instances
-    //    (Zig: inline `isInstance` chain in `safety/alloc.zig:hasPtr`).
+    //    checks can identify `LinuxMemFdAllocator`/`MimallocArena` instances.
     //    Runs once; reads are lock-free Relaxed.
     bun_runtime::allocators::register_safety_vtables();
 
diff --git a/src/bun_bin/phase_c_exports.rs b/src/bun_bin/phase_c_exports.rs
index 32c96970307..42151cd22b2 100644
--- a/src/bun_bin/phase_c_exports.rs
+++ b/src/bun_bin/phase_c_exports.rs
@@ -1,7 +1,7 @@
 //! PHASE-C link 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` /
+//! Every symbol that used to be stubbed here now has a real home inside
+//! `bun_jsc` / `bun_runtime` /
 //! `bun_http_jsc` / `bun_bundler_jsc`. As of this revision `bun_runtime` (and
 //! transitively `bun_jsc`) is a real dependency of this binary crate, so any
 //! `#[no_mangle]` definition that compiles in either of those crates is now
@@ -10,7 +10,7 @@
 //! What remains is the small set of symbols that are either (a) defined here
 //! directly because this is their proper home, (b) safe-default placeholders
 //! whose real body still depends on a gated crate, or (c) genuinely
-//! unimplemented anywhere (no Zig `export fn`, no C++ body) — those are
+//! unimplemented anywhere (no C++ body) — those are
 //! `unreachable!` so a stray call is loud rather than silent garbage.
 //!
 //! `__wrap_gettid` is NOT here — it lives in `bun_core` (its proper,
@@ -36,7 +36,7 @@ type JSValue = i64; // JSC::EncodedJSValue
 type VirtualMachine = c_void;
 
 // ════════════════════════════════════════════════════════════════════════════
-// Exported variables (Zig: `export var` / `@export(&var, …)`)
+// Exported variables
 // ════════════════════════════════════════════════════════════════════════════
 
 // REAL: now provided by bun_jsc (src/jsc/VirtualMachine.rs).
@@ -61,7 +61,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`
+// PHASE-C: C++ callback
 // REAL: src/main.rs (binary-level export; defined here directly)
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn Bun__panic(msg: *const u8, len: usize) -> ! {
@@ -196,7 +196,7 @@ pub(crate) extern "C" fn Bun__VM__scriptExecutionStatus(_vm: *const VirtualMachi
 // Blob__getSize
 // Bun__Blob__getSizeForBindings
 
-// .classes.ts hooks (build/debug/codegen/ZigGeneratedClasses.zig)
+// .classes.ts hooks
 // REAL: now provided by bun_runtime::generated_classes
 //   (build/debug/codegen/generated_classes.rs via generateRust()).
 // Blob__estimatedSize
@@ -251,7 +251,7 @@ pub(crate) extern "C" fn Bun__VM__scriptExecutionStatus(_vm: *const VirtualMachi
 // zig__renderDiff
 
 // ════════════════════════════════════════════════════════════════════════════
-// Genuinely unimplemented — no Zig `export fn`, no C++ body. Kept so the
+// Genuinely unimplemented — no C++ body. Kept so the
 // extern ref in the rlib resolves; loud crash if ever called.
 // ════════════════════════════════════════════════════════════════════════════
 
@@ -266,7 +266,7 @@ pub(crate) extern "C" fn JSC__JSValue__parseJSON(
     )
 }
 
-// Imported by bun_jsc/bun_sys_jsc as extern but no provider in C++ or Zig.
+// Imported by bun_jsc/bun_sys_jsc as extern but no provider in C++.
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn BunString__toErrorInstance(
     _this: *const c_void,
@@ -276,7 +276,7 @@ pub(crate) extern "C" fn BunString__toErrorInstance(
 }
 
 // Declared `extern` in InspectorLifecycleAgent.cpp:47-48 but never defined in
-// C++ nor Zig (Debugger.zig declares it `extern "c"` too). The agent's
+// C++. The agent's
 // preventExit/stopPreventingExit protocol commands are no-ops in the inspector
 // build today.
 #[unsafe(no_mangle)]
diff --git a/src/bun_core/Global.rs b/src/bun_core/Global.rs
index 1352feac513..e2743eb5fe2 100644
--- a/src/bun_core/Global.rs
+++ b/src/bun_core/Global.rs
@@ -5,9 +5,9 @@ use core::sync::atomic::{AtomicBool, Ordering};
 
 use const_format::{concatcp, formatcp};
 
-use crate::env; // @import("./env.zig")
+use crate::env;
 use crate::env::version_string;
-use crate::output as Output; // @import("./output.zig")
+use crate::output as Output;
 
 use crate::USE_MIMALLOC;
 #[cfg(debug_assertions)]
@@ -61,14 +61,14 @@ pub static WINDOWS_SEGFAULT_HANDLE: core::sync::atomic::AtomicPtr<core::ffi::c_v
 // platform-specific symbolication / SEH bits stay in bun_crash_handler (T>core).
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `std.builtin.StackTrace` — slice of return addresses + cursor.
+/// Slice of return addresses + cursor.
 #[derive(Clone, Copy)]
 pub struct StackTrace<'a> {
     pub index: usize,
     pub instruction_addresses: &'a [usize],
 }
 
-/// Zig: src/crash_handler/crash_handler.zig::StoredTrace — fixed 31-frame buffer.
+/// Fixed 31-frame stack-trace buffer.
 #[derive(Clone, Copy)]
 pub struct StoredTrace {
     pub data: [usize; 31],
@@ -109,7 +109,7 @@ impl StoredTrace {
         };
         let n = crate::capture_stack_trace(begin, &mut stored.data);
         stored.index = n;
-        // Trim trailing nulls (matches Zig loop).
+        // Trim trailing nulls.
         for (i, &addr) in stored.data[..n].iter().enumerate() {
             if addr == 0 {
                 stored.index = i;
@@ -135,7 +135,6 @@ impl StoredTrace {
     }
 }
 
-/// Zig: `WriteStackTraceLimits`.
 #[derive(Copy, Clone, Debug)]
 pub struct DumpStackTraceOptions {
     pub frame_count: usize,
@@ -155,13 +154,13 @@ impl Default for DumpStackTraceOptions {
         }
     }
 }
-/// Zig-spec name (`crash_handler.WriteStackTraceLimits`); also re-exported from `bun_crash_handler`.
+/// Alias for `DumpStackTraceOptions`; also re-exported from `bun_crash_handler`.
 pub type WriteStackTraceLimits = DumpStackTraceOptions;
 
-/// Zig: `crash_handler.dumpStackTrace`. T0 fallback prints raw return
+/// T0 fallback prints raw return
 /// addresses — **no symbolication** (the `backtrace` crate is not a T0 dep,
 /// and `std::backtrace` cannot resolve a stored address list). This is a
-/// deliberate debug-UX downgrade vs the Zig spec for the *stored*-trace path
+/// deliberate debug-UX downgrade for the *stored*-trace path
 /// (ref_count leak reports); the *current*-stack path below
 /// uses `std::backtrace` and stays symbolicated. Crash-report paths that need
 /// llvm-symbolizer / pdb-addr2line call `bun_crash_handler::dump_stack_trace`
@@ -187,9 +186,8 @@ pub fn dump_stack_trace(trace: &StackTrace<'_>, limits: DumpStackTraceOptions) {
 }
 
 /// Capture and dump the current call stack. Dispatches to
-/// `bun_crash_handler::dump_current_stack_trace` (matching Zig
-/// `fd.zig`/`ref_count.zig` which call `bun.crash_handler.dumpCurrentStackTrace`
-/// directly). The upward call is routed through a link-time `extern "Rust"`
+/// `bun_crash_handler::dump_current_stack_trace`.
+/// The upward call is routed through a link-time `extern "Rust"`
 /// symbol defined by `bun_crash_handler` so the function pointer lives in
 /// read-only `.text` instead of a writable `AtomicPtr` slot — memory corruption
 /// cannot redirect it. Under `cfg(test)` (this crate's standalone test binary
@@ -217,7 +215,7 @@ pub fn dump_current_stack_trace(first_address: Option<usize>, limits: DumpStackT
 }
 
 // ─── panicking state (from bun_crash_handler) ─────────────────────────────
-// Zig: `var panicking = std.atomic.Value(u8).init(0)`. Owned here so the
+// Owned here so the
 // crash handler crate writes to `bun_core::PANICKING` (forward dep, allowed).
 pub static PANICKING: core::sync::atomic::AtomicU8 = core::sync::atomic::AtomicU8::new(0);
 
@@ -226,20 +224,18 @@ pub fn is_panicking() -> bool {
     PANICKING.load(Ordering::Relaxed) > 0
 }
 
-/// Zig: crash_handler.sleepForeverIfAnotherThreadIsCrashing.
 pub fn sleep_forever_if_another_thread_is_crashing() {
     if PANICKING.load(Ordering::Acquire) > 0 {
-        // Sleep forever without hammering the CPU. Zig used `bun.Futex.waitForever`;
-        // `std::thread::park()` is the moral equivalent (never unparked).
+        // Sleep forever without hammering the CPU —
+        // `std::thread::park()` is never unparked.
         loop {
             std::thread::park();
         }
     }
 }
 
-// ─── SignalCode — single source of truth (Zig: src/sys/SignalCode.zig) ────
-// Zig declares ONE `enum(u8) { …, _ }` and derives the name table via
-// `@tagName` + `ComptimeEnumMap`. Rust has no enum reflection, so the 31
+// ─── SignalCode — single source of truth ──────────────────────────────────
+// Rust has no enum reflection, so the 31
 // (name,number) pairs live in ONE X-macro below; every consumer — the closed
 // enum here, the open newtype in `bun_sys`, `SIGNAL_NAMES`, `from_raw`,
 // `from_name` — is generated from it. Never re-spell a signal pair elsewhere.
@@ -259,7 +255,7 @@ macro_rules! for_each_signal {
 
 macro_rules! __define_signal_code {
     ($($name:ident = $n:literal),* $(,)?) => {
-        /// `@tagName` surrogate. Index = POSIX signal number; `[0]` is "" sentinel
+        /// Signal name table. Index = POSIX signal number; `[0]` is "" sentinel
         /// (callers range-check `1..=31`). Generated from `for_each_signal!`.
         pub const SIGNAL_NAMES: [&str; 32] = ["", $(stringify!($name),)*];
 
@@ -273,18 +269,18 @@ macro_rules! __define_signal_code {
         impl SignalCode {
             pub const DEFAULT: SignalCode = SignalCode::SIGTERM;
 
-            /// Zig `@enumFromInt` for the closed `1..=31` range; `None` for `0`
-            /// or the open enum's `_` tail.
+            /// Raw signal number → variant for the closed `1..=31` range;
+            /// `None` for `0` or anything outside it.
             #[inline]
             pub const fn from_raw(n: u8) -> Option<SignalCode> {
                 match n { $($n => Some(Self::$name),)* _ => None }
             }
 
-            /// Zig `@tagName` — every variant is named (enum is exhaustive).
+            /// Signal name — every variant is named (enum is exhaustive).
             #[inline]
             pub fn name(self) -> &'static str { SIGNAL_NAMES[self as u8 as usize] }
 
-            /// Zig `bun.ComptimeEnumMap(SignalCode).get` — name-bytes → variant.
+            /// Name-bytes → variant.
             /// 31-arm match; the optimizer turns it into a small string switch.
             #[inline]
             pub fn from_name(s: &[u8]) -> Option<SignalCode> {
@@ -296,8 +292,7 @@ macro_rules! __define_signal_code {
 for_each_signal!(__define_signal_code);
 
 // ─── analytics::features (MOVE_DOWN from bun_analytics) ───────────────────
-// Zig: src/analytics/analytics.zig::Features — bag of `pub var X: usize`.
-// Port as atomic counters so cross-thread `.fetch_add` is sound. Only the
+// Atomic counters so cross-thread `.fetch_add` is sound. Only the
 // counters are tier-0; `builtin_modules` (EnumSet over jsc HardcodedModule)
 // stays in bun_analytics (depends on tier-6).
 pub mod features {
@@ -355,7 +350,7 @@ pub mod features {
         LOCKFILE_MIGRATION_FROM_PACKAGE_LOCK.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
     }
     /// jsc crate calls `bun_core::analytics::Features::jsc_inc()` from
-    /// `initialize()` (spec jsc.zig:251 `bun.analytics.Features.jsc += 1`).
+    /// `initialize()`.
     #[inline]
     pub fn jsc_inc() {
         JSC.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
@@ -369,7 +364,6 @@ pub mod analytics {
 }
 
 // ─── mark_binding! (MOVE_DOWN from bun_jsc, for aio/event_loop/http_jsc) ──
-// Zig: jsc.zig::markBinding(@src()) → scoped_log!(JSC, "{fn} ({file}:{line})").
 // Pure logging; no jsc dep. Declares the JSC scope on first use.
 crate::declare_scope!(JSC, hidden);
 #[macro_export]
@@ -378,8 +372,7 @@ macro_rules! mark_binding {
         $crate::mark_binding!(::core::panic::Location::caller().file())
     };
     ($fn_name:expr) => {
-        // Zig: `Output.scoped(.JSC, .hidden)` (jsc.zig:169) — opt-in via
-        // BUN_DEBUG_JSC=1. The `JSC` scope is owned by bun_core. Gate on
+        // Opt-in via BUN_DEBUG_JSC=1. The `JSC` scope is owned by bun_core. Gate on
         // `debug_assertions` (== `Environment::ENABLE_LOGS`) — never on a Cargo
         // feature, since `cfg!(feature = ..)` is resolved against the *calling*
         // crate and would warn (or silently no-op) in crates without it.
@@ -398,7 +391,7 @@ pub static JSC_SCOPE: crate::output::ScopedLogger =
     crate::output::ScopedLogger::new("JSC", crate::output::Visibility::Hidden);
 
 // ─── debug_flags (MOVE_DOWN from bun_cli, for bun_resolver) ───────────────
-// Zig: src/cli/cli.zig::debug_flags — debug-build-only breakpoint matchers.
+// Debug-build-only breakpoint matchers.
 pub mod debug_flags {
     #[cfg(debug_assertions)]
     pub(crate) static RESOLVE_BREAKPOINTS: crate::Once<&'static [&'static [u8]]> =
@@ -444,8 +437,7 @@ pub const package_json_version: &str = if cfg!(debug_assertions) {
 };
 
 /// `package_json_version` with a trailing `\n` baked in, so
-/// `print_version_and_exit` is a single `write_all` (one syscall) — matches
-/// Zig's `writeAll(version ++ "\n")`.
+/// `print_version_and_exit` is a single `write_all` (one syscall).
 pub const package_json_version_nl: &str = concatcp!(package_json_version, "\n");
 
 /// This is used for `bun` without any arguments, it `package_json_version` but with canary if it is a canary build.
@@ -458,9 +450,6 @@ pub const package_json_version_with_canary: &str = if cfg!(debug_assertions) {
     version_string
 };
 
-// PORT NOTE: Zig sliced `git_sha[0..@min(len, 8)]` inline; we use the
-// pre-computed `GIT_SHA_SHORT` (same value) since const slicing of a const
-// `&str` by a runtime-ish min() is awkward in stable Rust.
 /// The version and a short hash in parenthesis.
 pub const package_json_version_with_sha: &str = if env::GIT_SHA.is_empty() {
     package_json_version
@@ -541,11 +530,12 @@ pub const arch_name: &str = if cfg!(target_arch = "x86_64") {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub fn set_thread_name(name: &ZStr) {
-    // Zig `Environment.isLinux` is true on Android (linux OS + android ABI);
-    // Rust's `target_os = "linux"` is not, so include android explicitly.
+    // Android needs the same path as Linux, but Rust's `target_os = "linux"`
+    // excludes it — include android explicitly.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
-        // SAFETY: PR_SET_NAME takes a NUL-terminated byte string; `name` is `[:0]const u8`.
+        // SAFETY: PR_SET_NAME takes a NUL-terminated byte string; `&ZStr` guarantees
+        // `ptr[len] == 0`.
         unsafe {
             let _ = libc::prctl(libc::PR_SET_NAME, name.as_ptr() as usize);
         }
@@ -581,8 +571,8 @@ pub fn set_thread_name(name: &ZStr) {
 // no memory-safety preconditions, so the call site needs no `unsafe` block.
 pub type ExitFn = extern "C" fn();
 
-// PORT NOTE: Zig used an unsynchronized global `ArrayListUnmanaged`. Registration
-// can happen from any thread (FFI `Bun__atexit`), so guard with a Mutex.
+// Registration can happen from any thread (FFI `Bun__atexit`), so this is
+// guarded with a Mutex.
 static ON_EXIT_CALLBACKS: crate::Mutex<Vec<ExitFn>> = crate::Mutex::new(Vec::new());
 
 #[unsafe(no_mangle)]
@@ -597,9 +587,9 @@ pub fn add_exit_callback(function: ExitFn) {
     Bun__atexit(function);
 }
 
-/// Callbacks `Bun__onExit` runs BEFORE `run_exit_callbacks()`. Spec
-/// `Global.zig:220` hard-codes `bun.jsc.Node.FSEvents.closeAndWait()` ahead of
-/// `runExitCallbacks()`; that crate sits above us, so it pushes its callback
+/// Callbacks `Bun__onExit` runs BEFORE `run_exit_callbacks()`. FSEvents must
+/// close-and-wait ahead of the generic exit-callback list; that crate sits
+/// above us, so it pushes its callback
 /// here at first-loop creation (data moved down — same `Vec<ExitFn>` shape as
 /// `ON_EXIT_CALLBACKS`, no fn-ptr type-erase).
 static PRE_EXIT_CALLBACKS: crate::Mutex<Vec<ExitFn>> = crate::Mutex::new(Vec::new());
@@ -650,7 +640,6 @@ unsafe extern "C" {
 /// Flushes stdout and stderr (in exit/quick_exit callback) and exits with the given code.
 pub fn exit(code: u32) -> ! {
     IS_EXITING.store(true, Ordering::Relaxed);
-    // _ = @atomicRmw(usize, &bun.analytics.Features.exited, .Add, 1, .monotonic);
     // MOVE_DOWN: bun_analytics::features → bun_core (move-in pass).
     crate::features::EXITED.fetch_add(1, Ordering::Relaxed);
 
@@ -689,10 +678,9 @@ pub fn raise_ignoring_panic_handler(sig: crate::SignalCode) -> ! {
     raise_ignoring_panic_handler_raw(sig as c_int)
 }
 
-/// Re-raise `sig` (raw `c_int`) after restoring TTY/crash state. Zig's
-/// `SignalCode` is a *non-exhaustive* `enum(u8)`, so callers may forward any
-/// signal byte (incl. Linux RT signals 32..=64) that has no `crate::SignalCode`
-/// discriminant. Mirrors `raiseIgnoringPanicHandler(@enumFromInt(sig))`.
+/// Re-raise `sig` (raw `c_int`) after restoring TTY/crash state. Callers may
+/// forward any signal byte (incl. Linux RT signals 32..=64) that has no
+/// `crate::SignalCode` discriminant.
 pub fn raise_ignoring_panic_handler_raw(sig: c_int) -> ! {
     Output::flush();
     Output::source::stdio::restore();
@@ -700,8 +688,7 @@ pub fn raise_ignoring_panic_handler_raw(sig: c_int) -> ! {
     // Clear the crash handler's segfault hooks so the re-raised signal goes to
     // SIG_DFL instead of recursing into the panic handler. Storage moved down
     // from `bun_crash_handler` — it sets `CRASH_HANDLER_INSTALLED` on init and
-    // we do the libc reset ourselves (no fn-ptr hook). Mirrors
-    // `crash_handler.zig::resetSegfaultHandler`: skip when ASAN owns the
+    // we do the libc reset ourselves (no fn-ptr hook). Skip when ASAN owns the
     // signals (we never installed over them); on Windows remove the VEH.
     #[cfg(unix)]
     if CRASH_HANDLER_INSTALLED.load(Ordering::Relaxed) && !crate::env::ENABLE_ASAN {
@@ -796,8 +783,7 @@ pub(crate) static Bun__userAgent: SyncCStr =
     SyncCStr(concatcp!(user_agent, "\0").as_ptr().cast::<c_char>());
 
 /// Prevent the linker from dead-code-eliminating `#[no_mangle]` symbols that are
-/// only ever called from C/C++ (so rustc sees no Rust caller). Port of Zig's
-/// `std.mem.doNotOptimizeAway` pattern (Global.zig:224). Expands to one
+/// only ever called from C/C++ (so rustc sees no Rust caller). Expands to one
 /// `core::hint::black_box(f as *const ())` per path — purely a side-effect, so
 /// invoke inside a `fix_dead_code_elimination()` fn wired from `run_command`.
 #[macro_export]
@@ -809,9 +795,8 @@ macro_rules! keep_symbols {
 
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn Bun__onExit() {
-    // `bun.jsc.Node.FSEvents.closeAndWait()` (spec `Global.zig:220`) — runs
-    // BEFORE the generic exit-callback list, matching Zig ordering. fs_events
-    // pushes into `PRE_EXIT_CALLBACKS` on first loop create.
+    // FSEvents close-and-wait runs BEFORE the generic exit-callback list.
+    // fs_events pushes into `PRE_EXIT_CALLBACKS` on first loop create.
     let pre: Vec<ExitFn> = core::mem::take(&mut *PRE_EXIT_CALLBACKS.lock());
     for callback in &pre {
         callback();
@@ -822,5 +807,3 @@ pub(crate) extern "C" fn Bun__onExit() {
 
     Output::source::stdio::restore();
 }
-
-// ported from: src/bun_core/Global.zig
diff --git a/src/bun_core/Progress.rs b/src/bun_core/Progress.rs
index 51dd8d71468..10ec264abe5 100644
--- a/src/bun_core/Progress.rs
+++ b/src/bun_core/Progress.rs
@@ -1,11 +1,8 @@
-//! This is a snapshot of the Zig std.Progress API before it's rewrite in 0.13
-//! We use this API for the progress in Bun install and some other places.
+//! Terminal progress indicator used for Bun install and some other places.
 //!
 //! TODO: It would be worth considering using our own progress indicator for
 //! Bun install, as this bar only shows the most recent action.
 //!
-//! https://github.com/ziglang/zig/blob/0.12.0/lib/std/Progress.zig
-//!
 //! This API is non-allocating, non-fallible, and thread-safe.
 //! The tradeoff is that users of this API must provide the storage
 //! for each `Progress.Node`.
@@ -69,7 +66,7 @@ pub use crate::output::File;
 use crate::output::output_sink;
 
 impl File {
-    /// `std.io.tty.supportsAnsiEscapeCodes()` — on unix this is `isatty()`;
+    /// Whether ANSI escape codes are supported — on unix this is `isatty()`;
     /// on Windows it requires `ENABLE_VIRTUAL_TERMINAL_PROCESSING` (set by
     /// `Output.Source.init`). We route through the sink so the platform check
     /// lives in `bun_sys`.
@@ -77,7 +74,7 @@ impl File {
     pub fn supports_ansi_escape_codes(self) -> bool {
         #[cfg(windows)]
         {
-            // Zig std.fs.File.supportsAnsiEscapeCodes(): query the live console
+            // Query the live console
             // mode for ENABLE_VIRTUAL_TERMINAL_PROCESSING — a *capability*
             // check. Do NOT proxy through ENABLE_ANSI_COLORS_STDERR: that is a
             // color-*preference* flag (NO_COLOR/FORCE_COLOR/tty) and never
@@ -166,23 +163,18 @@ pub struct Progress {
 impl Default for Progress {
     fn default() -> Self {
         Self {
-            // Zig: `= undefined` — overwritten in `start()`
             terminal: None,
             is_windows_terminal: false,
             supports_ansi_escape_codes: false,
             dont_print_on_dumb: false,
-            // Zig: `= undefined` — overwritten in `start()`
             root: Node::default(),
             timer: None,
-            // Zig: `= undefined`
             prev_refresh_timestamp: 0,
-            // Zig: `= undefined`
             output_buffer: [0; 100],
             refresh_rate_ns: 50 * NS_PER_MS,
             initial_delay_ns: 500 * NS_PER_MS,
             done: true,
             update_mutex: Mutex::new(()),
-            // Zig: `= undefined`
             columns_written: 0,
         }
     }
@@ -201,8 +193,10 @@ pub enum Unit {
 pub struct Node {
     pub context: *mut Progress,
     pub parent: *mut Node,
-    // TODO(port): lifetime — caller-borrowed slice, Zig is non-allocating; using
-    // 'static here as a placeholder (callers in install/ pass string literals).
+    // The non-allocating design means `Node` cannot own the bytes. `'static`
+    // is the chosen simplification because all current callers (install/,
+    // cli/) pass string literals; the alternative would be threading a
+    // lifetime through `Node`/`Progress`.
     pub name: &'static [u8],
     pub unit: Unit,
     /// Must be handled atomically to be thread-safe.
@@ -263,9 +257,7 @@ impl Node {
 
     /// Create a new child progress node. Thread-safe.
     /// Call `Node.end` when done.
-    /// TODO solve https://github.com/ziglang/zig/issues/2765 and then change this
-    /// API to set `self.parent.recently_updated_child` with the return value.
-    /// Until that is fixed you probably want to call `activate` on the return value.
+    /// You probably want to call `activate` on the return value.
     /// Passing 0 for `estimated_total_items` means unknown.
     pub fn start(&mut self, name: &'static [u8], estimated_total_items: usize) -> Node {
         Node {
@@ -312,7 +304,7 @@ impl Node {
             }
             parent.complete_one();
         } else {
-            // PORT NOTE: reshaped for borrowck — guard borrows context.update_mutex;
+            // Reshaped for borrowck — guard borrows context.update_mutex;
             // we capture a raw ptr first so the &mut access goes through *mut.
             let ctx_ptr = std::ptr::from_mut::<Progress>(context);
             let _g = context.update_mutex.lock();
@@ -368,9 +360,6 @@ impl Node {
 
     /// Thread-safe.
     pub fn set_unit(&mut self, unit: Unit) {
-        // TODO(port): Zig signature was `unit: []const u8` assigned to an enum field —
-        // dead code in Zig (lazy compilation never type-checked it). Ported with the
-        // enum type to keep it well-typed; revisit if any caller appears.
         let ctx_ptr = self.context_ptr();
         // SAFETY: see `context_ptr` — `&mut Progress` would alias the node tree.
         let progress = unsafe { &mut *ctx_ptr };
@@ -412,12 +401,8 @@ impl Node {
 impl Progress {
     /// Create a new progress node.
     /// Call `Node.end` when done.
-    /// TODO solve https://github.com/ziglang/zig/issues/2765 and then change this
-    /// API to return Progress rather than accept it as a parameter.
     /// `estimated_total_items` value of 0 means unknown.
     pub fn start(&mut self, name: &'static [u8], estimated_total_items: usize) -> &mut Node {
-        // TODO(port): std.fs.File.stderr() / supportsAnsiEscapeCodes() / isTty() —
-        // map to bun_sys::File equivalents.
         let stderr = File::stderr();
         self.terminal = None;
         if stderr.supports_ansi_escape_codes() {
@@ -446,7 +431,6 @@ impl Progress {
         };
         self.columns_written = 0;
         self.prev_refresh_timestamp = 0;
-        // Zig: std.time.Timer.start() catch null — Instant::now() is infallible.
         self.timer = Some(Instant::now());
         self.done = false;
         &mut self.root
@@ -454,9 +438,9 @@ impl Progress {
 
     /// Updates the terminal if enough time has passed since last update. Thread-safe.
     pub fn maybe_refresh(&mut self) {
-        // PORT NOTE: reshaped for borrowck — Instant is Copy, captured by value.
+        // Reshaped for borrowck — Instant is Copy, captured by value.
         if let Some(timer) = self.timer {
-            // PORT NOTE: reshaped for borrowck — capture *mut self before the
+            // Reshaped for borrowck — capture *mut self before the
             // guard borrows update_mutex.
             let ctx_ptr = std::ptr::from_mut::<Self>(self);
             let Some(_g) = self.update_mutex.try_lock() else {
@@ -468,7 +452,6 @@ impl Progress {
     }
 
     fn maybe_refresh_with_held_lock(&mut self, timer: Instant) {
-        // Zig: timer.read() returns ns since start.
         let now = u64::try_from(timer.elapsed().as_nanos()).expect("int cast");
         if now < self.initial_delay_ns {
             return;
@@ -519,7 +502,6 @@ impl Progress {
                 'winapi: {
                     debug_assert!(self.is_windows_terminal);
 
-                    // TODO(port): verify bun_sys::windows::CONSOLE_SCREEN_BUFFER_INFO layout & kernel32 bindings.
                     let mut info: windows::CONSOLE_SCREEN_BUFFER_INFO = crate::ffi::zeroed();
                     if GetConsoleScreenBufferInfo(file.console_handle(), &mut info) != windows::TRUE
                     {
@@ -611,9 +593,7 @@ impl Progress {
                 // and advance `maybe_node` *before* any `self.buf_write` call:
                 // on the first iteration `maybe_node` is `&raw mut self.root`,
                 // and `buf_write`'s `&mut self` reborrow would invalidate any
-                // tag derived from it under Stacked Borrows. (Zig has no
-                // aliasing model, so Progress.zig:313-345 holds `node: *Node`
-                // across `self.bufWrite` freely; Rust must not.)
+                // tag derived from it under Stacked Borrows.
                 unsafe {
                     name = (*maybe_node).name;
                     unit = (*maybe_node).unit;
@@ -647,8 +627,8 @@ impl Progress {
                                 &mut end,
                                 format_args!("[{}/{} files] ", current_item, eti),
                             ),
-                            // TODO(port): Zig `{Bi:.2}` is std.fmt binary-bytes formatter (e.g. "1.50KiB").
-                            // Need a bun_core::fmt::BytesBi helper.
+                            // Raw byte counts are printed until an IEC-units
+                            // (KiB/MiB) formatting helper lands.
                             Unit::Bytes => self
                                 .buf_write(&mut end, format_args!("[{}/{}] ", current_item, eti)),
                         }
@@ -664,7 +644,7 @@ impl Progress {
                             Unit::Files => {
                                 self.buf_write(&mut end, format_args!("[{} files] ", current_item))
                             }
-                            // TODO(port): Zig `{Bi:.2}` binary-bytes formatter.
+                            // Raw byte counts; see the note above.
                             Unit::Bytes => {
                                 self.buf_write(&mut end, format_args!("[{}] ", current_item))
                             }
@@ -693,7 +673,6 @@ impl Progress {
             let _ = File::stderr().write_fmt(args);
             return;
         };
-        // TODO(port): Zig `file.writerStreaming(&.{})` — map to bun_sys::File writer.
         self.refresh();
         if file.write_fmt(args).is_err() {
             self.terminal = None;
@@ -706,13 +685,13 @@ impl Progress {
     /// called. During the lock, the progress information is cleared from the
     /// terminal.
     ///
-    /// PORT NOTE: Zig splits the lock/unlock across fn boundaries.
-    /// `crate::Mutex` (std::sync wrapper) has no raw `unlock()`, and storing a
-    /// guard on `self` is self-referential. There are currently **no callers**
-    /// of `lock_stderr`/`unlock_stderr` in either the Zig or Rust trees, so
-    /// this clears the terminal under a scoped lock and `unlock_stderr` is a
-    /// no-op. If a caller materializes, refactor to return the guard (or move
-    /// `update_mutex` to a raw `bun_threading::Mutex` once layering allows).
+    /// `crate::Mutex` (std::sync wrapper) has no
+    /// raw `unlock()`, and storing a guard on `self` is self-referential. There
+    /// are currently **no callers** of `lock_stderr`/`unlock_stderr`,
+    /// so this clears the terminal under a scoped lock
+    /// and `unlock_stderr` is a no-op. If a caller materializes, refactor to
+    /// return the guard (or move `update_mutex` to a raw `bun_threading::Mutex`
+    /// once layering allows) and route stderr through a shared global mutex.
     pub fn lock_stderr(&mut self) {
         let ctx_ptr = std::ptr::from_mut::<Self>(self);
         let _g = self.update_mutex.lock();
@@ -727,13 +706,11 @@ impl Progress {
                 this.terminal = None;
             }
         }
-        // `_g` drops here; lock is NOT held past return — see PORT NOTE above.
-        // TODO(port): std.debug.getStderrMutex().lock() — need a global stderr mutex in bun_core.
+        // `_g` drops here; lock is NOT held past return — see the doc comment above.
     }
 
     pub fn unlock_stderr(&mut self) {
-        // TODO(port): std.debug.getStderrMutex().unlock() — see lock_stderr.
-        // No-op; see PORT NOTE on `lock_stderr`.
+        // No-op; see the doc comment on `lock_stderr`.
         let _ = self;
     }
 
@@ -807,7 +784,7 @@ mod tests {
             );
             node.activate();
             thread::sleep(Duration::from_nanos(10 * speed_factor));
-            // PORT NOTE: reshaped for borrowck — cannot borrow `progress` while `root_node`
+            // Reshaped for borrowck — cannot borrow `progress` while `root_node`
             // (a &mut into progress.root) is live; refresh via the node's context backref.
             // SAFETY: see `context_ptr` — `&mut Progress` would alias the node tree.
             unsafe { (*node.context_ptr()).refresh() };
@@ -817,5 +794,3 @@ mod tests {
         root_node.end();
     }
 }
-
-// ported from: src/bun_core/Progress.zig
diff --git a/src/bun_core/atomic_cell.rs b/src/bun_core/atomic_cell.rs
index 5a1137b204c..e9deba87e03 100644
--- a/src/bun_core/atomic_cell.rs
+++ b/src/bun_core/atomic_cell.rs
@@ -2,8 +2,7 @@
 //! [`RacyCell`](crate::RacyCell) when state crosses (or is asserted *not* to
 //! cross) a thread boundary.
 //!
-//! `RacyCell` was the mechanical port of Zig's "trust me" globals; it is now
-//! overloaded for three unrelated invariants. This module splits two of them
+//! `RacyCell` is overloaded for three unrelated invariants. This module splits two of them
 //! into types the compiler / debug build can check:
 //!
 //! | Invariant                                      | Type                  |
diff --git a/src/bun_core/bounded_array.rs b/src/bun_core/bounded_array.rs
index 6bc4a06e03c..834633161d9 100644
--- a/src/bun_core/bounded_array.rs
+++ b/src/bun_core/bounded_array.rs
@@ -1,12 +1,7 @@
-//! Removed from the Zig standard library in https://github.com/ziglang/zig/pull/24699/
-//!
-//! Modifications:
-//! - `len` is a field of integer-size instead of usize. This reduces memory usage.
-//!
 //! A structure with an array and a length, that can be used as a slice.
 //!
 //! Useful to pass around small arrays whose exact size is only known at
-//! runtime, but whose maximum size is known at comptime, without requiring
+//! runtime, but whose maximum size is known at compile time, without requiring
 //! an `Allocator`.
 //!
 //! ```ignore
@@ -30,36 +25,32 @@ crate::named_error_set!(OverflowError);
 /// A structure with an array and a length, that can be used as a slice.
 ///
 /// Useful to pass around small arrays whose exact size is only known at
-/// runtime, but whose maximum size is known at comptime, without requiring
+/// runtime, but whose maximum size is known at compile time, without requiring
 /// an `Allocator`.
 pub type BoundedArray<T, const BUFFER_CAPACITY: usize> = BoundedArrayAligned<T, BUFFER_CAPACITY>;
-// PORT NOTE: Zig's `BoundedArray` delegates to `BoundedArrayAligned` with `@alignOf(T)`.
-// In Rust the natural alignment of `[T; N]` is already `align_of::<T>()`, so the alias is
+// The natural alignment of `[T; N]` is already `align_of::<T>()`, so the alias is
 // transparent. The explicit `alignment` const-param is dropped (see below).
 
 /// A structure with an array, length and alignment, that can be used as a
 /// slice.
 ///
 /// Useful to pass around small explicitly-aligned arrays whose exact size is
-/// only known at runtime, but whose maximum size is known at comptime, without
+/// only known at runtime, but whose maximum size is known at compile time, without
 /// requiring an `Allocator`.
-// TODO(port): Zig takes `comptime alignment: Alignment` and applies it via
-// `align(alignment.toByteUnits())` on the buffer field. Stable Rust cannot express
-// `#[repr(align(N))]` with a const-generic `N`. All in-tree callers use the default
-// `@alignOf(T)` via `BoundedArray`, so the param is dropped. Revisit if a
-// caller needs over-alignment (would require a wrapper type per alignment).
+// Stable Rust cannot express
+// `#[repr(align(N))]` with a const-generic `N`. All in-tree callers use the
+// default natural alignment via `BoundedArray`; a caller needing
+// over-alignment would require a wrapper type per alignment.
 pub struct BoundedArrayAligned<T, const BUFFER_CAPACITY: usize> {
     buffer: [MaybeUninit<T>; BUFFER_CAPACITY],
-    // TODO(port): Zig uses `Length = std.math.ByteAlignedInt(std.math.IntFittingRange(0, buffer_capacity))`
-    // (smallest byte-aligned uint that fits `0..=BUFFER_CAPACITY`) to shrink this field.
-    // Stable Rust const generics cannot pick an integer type from a const value without
-    // `generic_const_exprs`. Using `usize` for now.
-    // PERF(port): was size-optimized integer field — profile if it shows up on a hot path
+    // Stable Rust const generics cannot pick a smaller integer type
+    // (the smallest byte-aligned uint that fits `0..=BUFFER_CAPACITY`)
+    // from a const value without `generic_const_exprs`, so `usize` is used.
+    // PERF: could be a size-optimized integer field — profile if it shows up on a hot path
     len: usize,
 }
 
-// `const Length = std.math.ByteAlignedInt(std.math.IntFittingRange(0, buffer_capacity));`
-// — see TODO above; collapsed to `usize`.
+// See the `len` field note above; collapsed to `usize`.
 type Length = usize;
 
 impl<T, const BUFFER_CAPACITY: usize> Default for BoundedArrayAligned<T, BUFFER_CAPACITY> {
@@ -77,8 +68,7 @@ impl<T, const BUFFER_CAPACITY: usize> Drop for BoundedArrayAligned<T, BUFFER_CAP
     }
 }
 
-/// `pub const Buffer = @FieldType(Self, "buffer");` — inherent assoc types are
-/// unstable; only used for introspection in Zig, so expose as a free alias.
+/// Inherent assoc types are unstable, so this is exposed as a free alias.
 pub type BoundedBuffer<T, const N: usize> = [MaybeUninit<T>; N];
 
 impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
@@ -94,8 +84,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
     }
 
     /// View the internal array as a slice whose size was previously set.
-    // PORT NOTE: Zig's `slice(self: anytype)` is mut/const-polymorphic via `@TypeOf`.
-    // Rust splits this into `slice(&mut self)` and `const_slice(&self)`.
+    // Mut/const access is split into `slice(&mut self)` and `const_slice(&self)`.
     pub fn slice(&mut self) -> &mut [T] {
         let len = self.len;
         // SAFETY: elements `[0..len]` are initialized by the public API's invariants.
@@ -138,7 +127,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         list.slice().copy_from_slice(m);
         Ok(list)
     }
-    // TODO(port): Zig `@memcpy` works for non-Copy `T` (bitwise). If a non-`Copy` caller
+    // If a non-`Copy` caller
     // appears, add a `from_slice_clone` or use `ptr::copy_nonoverlapping`.
 
     /// Return the element at index `i` of the slice.
@@ -180,7 +169,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         self.len += 1;
         let i = self.len - 1;
         // SAFETY: index `i` is within `[0..len)`; caller treats the slot as uninitialized
-        // and must write before reading (matches Zig `addOneAssumeCapacity` contract).
+        // and must write before reading.
         unsafe { &mut *self.buffer[i].as_mut_ptr() }
     }
 
@@ -191,7 +180,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         self.resize(self.len + N)?;
         let ptr = self.buffer[prev_len..][..N].as_mut_ptr().cast::<[T; N]>();
         // SAFETY: `[prev_len .. prev_len+N]` is within capacity after resize; caller must
-        // initialize before reading (Zig returns `*[n]T` over undefined storage).
+        // initialize before reading.
         Ok(unsafe { &mut *ptr })
     }
 
@@ -224,8 +213,8 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
     pub fn unused_capacity_slice(&mut self) -> &mut [MaybeUninit<T>] {
         &mut self.buffer[self.len..]
     }
-    // PORT NOTE: returns `&mut [MaybeUninit<T>]` instead of `&mut [T]` because the region is
-    // uninitialized by definition; Zig's `[]T` over undefined memory has no safe Rust equivalent.
+    // Returns `&mut [MaybeUninit<T>]` instead of `&mut [T]` because the region is
+    // uninitialized by definition.
 
     /// Insert `item` at index `i` by moving `slice[n .. slice.len]` to make room.
     /// This operation is O(N).
@@ -234,9 +223,8 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
             return Err(OverflowError::Overflow);
         }
         let _ = self.add_one()?;
-        // PORT NOTE: reshaped for borrowck — Zig aliases `s[i+1..]` and `s[i..len-1]` from one slice.
+        // Reshaped for borrowck.
         let s_len = self.len;
-        // mem.copyBackwards(T, s[i + 1 .. s.len], s[i .. s.len - 1]);
         // SAFETY: ranges are within `[0..len)`; src and dst overlap, hence `ptr::copy` (memmove).
         unsafe {
             let base = self.buffer.as_mut_ptr();
@@ -254,7 +242,6 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
     {
         self.ensure_unused_capacity(items.len())?;
         self.len += Length::try_from(items.len()).expect("int cast");
-        // mem.copyBackwards(T, self.slice()[i + items.len .. self.len], self.constSlice()[i .. self.len - items.len]);
         let len = self.len;
         // SAFETY: ranges are within `[0..len)` after the length bump; overlapping memmove.
         unsafe {
@@ -282,7 +269,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         T: Copy,
     {
         let after_range = start + len;
-        // PORT NOTE: reshaped for borrowck — Zig holds `range` borrow across `insertSlice`.
+        // Reshaped for borrowck.
         let range_len = after_range - start;
 
         if range_len == new_items.len() {
@@ -295,25 +282,23 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         } else {
             self.slice()[start..after_range][..new_items.len()].copy_from_slice(new_items);
             let after_subrange = start + new_items.len();
-            // PORT NOTE: reshaped for borrowck — Zig reads `constSlice()[after_range..]` while
-            // writing `slice()[after_subrange..]` in the same loop body.
+            // Reshaped for borrowck — read and write per element instead of
+            // holding overlapping `const_slice()`/`slice()` borrows.
             let tail_len = self.len - after_range;
             for i in 0..tail_len {
                 let item = self.const_slice()[after_range + i];
                 self.slice()[after_subrange..][i] = item;
             }
             self.len = Length::try_from(self.len - len + new_items.len()).expect("int cast");
-            // PORT NOTE: Zig source had `self.len - len - new_items.len`, which over-shrinks
-            // (and underflows when the replacement is non-empty). Removing `len` items and
-            // inserting `new_items.len()` items yields `self.len - len + new_items.len()`.
+            // Removing `len` items and inserting `new_items.len()` items
+            // yields `self.len - len + new_items.len()`.
         }
         Ok(())
     }
 
     /// Extend the slice by 1 element.
     pub fn append(&mut self, item: T) -> Result<(), OverflowError> {
-        // PORT NOTE: Zig's `new_item_ptr.* = item` is a raw bitwise store. The naive Rust
-        // transliteration `*new_item_ptr = item` would drop the (uninitialized) prior occupant
+        // A plain `*slot = item` write would drop the (uninitialized) prior occupant
         // of the slot first — UB that manifests as a bad free when `T` owns heap memory.
         self.ensure_unused_capacity(1)?;
         self.append_assume_capacity(item);
@@ -327,7 +312,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
         let i = self.len;
         self.len += 1;
         // Write into the `MaybeUninit` slot directly so no drop runs on the previous
-        // (uninitialized) contents — matches Zig's raw `ptr.* = item` semantics.
+        // (uninitialized) contents.
         self.buffer[i].write(item);
     }
 
@@ -344,12 +329,12 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
             return self.pop().unwrap();
         }
         let old_item = self.get(i);
-        // PORT NOTE: reshaped for borrowck — Zig writes through `*b` while calling `self.get()`.
+        // Reshaped for borrowck.
         for j in 0..(newlen - i) {
             let v = self.get(i + 1 + j);
             self.slice()[i + j] = v;
         }
-        // self.set(newlen, undefined); — no-op in Rust (slot is past new len, left as-is)
+        // The slot past the new len is left as-is.
         self.len = newlen;
         old_item
     }
@@ -418,8 +403,7 @@ impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
     }
 }
 
-// Rust-idiom aliases (Vec-like surface) so callers don't need to know the
-// Zig-style names. Thin delegations; no behavior change.
+// Vec-like aliases. Thin delegations; no behavior change.
 impl<T, const BUFFER_CAPACITY: usize> BoundedArrayAligned<T, BUFFER_CAPACITY> {
     #[inline]
     pub fn len(&self) -> usize {
@@ -462,8 +446,7 @@ impl<T, const N: usize> core::ops::DerefMut for BoundedArrayAligned<T, N> {
     }
 }
 
-// `pub const Writer = ... std.io.GenericWriter(*Self, error{Overflow}, appendWrite);`
-// Only defined for `T == u8` (Zig `@compileError`s otherwise).
+// Only defined for `T == u8`.
 impl<const BUFFER_CAPACITY: usize> crate::io::Write for BoundedArrayAligned<u8, BUFFER_CAPACITY> {
     #[inline]
     fn write_all(&mut self, buf: &[u8]) -> Result<(), crate::Error> {
@@ -489,5 +472,3 @@ impl<const BUFFER_CAPACITY: usize> BoundedArrayAligned<u8, BUFFER_CAPACITY> {
         self
     }
 }
-
-// ported from: src/collections/bounded_array.zig
diff --git a/src/bun_core/debug.rs b/src/bun_core/debug.rs
index c1dd9ef92be..eeeb02d04de 100644
--- a/src/bun_core/debug.rs
+++ b/src/bun_core/debug.rs
@@ -1,9 +1,8 @@
-//! Port of the `std.debug` subset Zig used: `SourceLocation`/`SymbolInfo` and
-//! the frame-pointer stack unwinder (`@frameAddress`, `MemoryAccessor`,
-//! `StackIterator`). Lives in `bun_core` (libc/std/bun_alloc only) so the crash
+//! `SourceLocation`/`SymbolInfo` and the frame-pointer stack unwinder
+//! (`MemoryAccessor`, `StackIterator`).
+//! Lives in `bun_core` (libc/std/bun_alloc only) so the crash
 //! handler, `StoredTrace`, and `btjs` can all share one implementation.
 
-/// Zig: `std.debug.SourceLocation`.
 #[derive(Clone)]
 pub struct SourceLocation {
     pub file_name: Box<[u8]>,
@@ -11,7 +10,6 @@ pub struct SourceLocation {
     pub column: u32,
 }
 
-/// Zig: `std.debug.SymbolInfo`.
 pub struct SymbolInfo {
     pub name: Box<[u8]>,
     pub compile_unit_name: Box<[u8]>,
@@ -19,9 +17,8 @@ pub struct SymbolInfo {
 }
 
 // ──────────────────────────────────────────────────────────────────────
-// Frame-pointer stack unwinder (port of the `std.debug` subset Zig used:
-// `@frameAddress`, `MemoryAccessor`, `StackIterator`). The Rust port had
-// briefly routed capture through libc `backtrace()` / `RtlCaptureStackBackTrace`,
+// Frame-pointer stack unwinder. Capture had
+// briefly been routed through libc `backtrace()` / `RtlCaptureStackBackTrace`,
 // which are CFI/unwind-table based — but release builds strip the unwind tables
 // (`-fno-asynchronous-unwind-tables` + `--no-eh-frame-hdr`) and the POSIX
 // signal handler runs on an `SA_ONSTACK` altstack, so those APIs captured only
@@ -30,7 +27,7 @@ pub struct SymbolInfo {
 // the correct mechanism. Lives in `bun_core` (libc/std/bun_alloc only) so the
 // crash handler, `StoredTrace`, and `btjs` can all share one implementation.
 // ──────────────────────────────────────────────────────────────────────
-/// Port of Zig `@frameAddress()`. Reads the frame-pointer register directly.
+/// Reads the frame-pointer register directly.
 #[inline(always)]
 pub fn frame_address() -> usize {
     #[cfg(target_arch = "x86_64")]
@@ -53,7 +50,7 @@ pub fn frame_address() -> usize {
     }
     #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
     {
-        // @frameAddress() — approximate with a stack local's addr on arches
+        // Approximate with a stack local's addr on arches
         // without an asm! mapping yet. fp-walk will fail its alignment sanity
         // check and terminate cleanly.
         let probe = 0u8;
@@ -62,8 +59,7 @@ pub fn frame_address() -> usize {
 }
 
 /// Reads memory from any address of the current process, tolerating unmapped
-/// or corrupt pages so a damaged stack can't fault the walker itself. Port of
-/// `std.debug.MemoryAccessor`.
+/// or corrupt pages so a damaged stack can't fault the walker itself.
 struct MemoryAccessor {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     mem: core::ffi::c_int, // -1 = uninit, -2 = unavailable, else /proc/<pid>/mem fd
@@ -211,7 +207,7 @@ fn is_valid_memory(address: usize) -> bool {
     }
 }
 
-/// Port of `std.debug.StackIterator`. Walks the frame-pointer chain.
+/// Walks the frame-pointer chain.
 pub struct StackIterator {
     pub fp: usize,
     ma: MemoryAccessor,
diff --git a/src/bun_core/deprecated.rs b/src/bun_core/deprecated.rs
index ebb085c7b07..93628795339 100644
--- a/src/bun_core/deprecated.rs
+++ b/src/bun_core/deprecated.rs
@@ -4,9 +4,10 @@ use core::ptr;
 // BufferedReader
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): Zig's `ReaderType` only needs `.read(&mut [u8]) -> Result<usize, Self::Error>`
-// and an associated `Error` type. There is no `bun_io::Read` trait yet; introduce one
-// (or reuse whatever the `std.Io.GenericReader` port lands as) and bound `R` on it.
+// Plain storage for a buffered reader. The only
+// in-tree consumer (`pack_command::BufferedFileReader`) supplies its own read shim
+// over `bun_sys::read`, so this stays a bare struct: no reader trait, no methods.
+// (The dedicated stdin instance lives at `output::BufferedStdin`.)
 pub struct BufferedReader<const BUFFER_SIZE: usize, R> {
     pub unbuffered_reader: R,
     pub buf: [u8; BUFFER_SIZE],
@@ -14,66 +15,6 @@ pub struct BufferedReader<const BUFFER_SIZE: usize, R> {
     pub end: usize,
 }
 
-impl<const BUFFER_SIZE: usize, R> BufferedReader<BUFFER_SIZE, R>
-where
-    // TODO(port): replace with the real reader trait once it exists.
-    R: DeprecatedRead,
-{
-    // Zig: `pub const Error = R.Error;` — inherent assoc types are nightly-only
-    // (E0658). Callers name `R::Error` directly; this alias was sugar.
-    // TODO(port): `pub const Reader = std.Io.GenericReader(*Self, Error, read);` —
-    // depends on the Rust port of `std.Io.GenericReader`. Left unported; `reader()`
-    // below is stubbed accordingly.
-
-    pub fn read(&mut self, dest: &mut [u8]) -> Result<usize, R::Error> {
-        // First try reading from the already buffered data onto the destination.
-        let current = &self.buf[self.start..self.end];
-        if !current.is_empty() {
-            let to_transfer = current.len().min(dest.len());
-            dest[0..to_transfer].copy_from_slice(&current[0..to_transfer]);
-            self.start += to_transfer;
-            return Ok(to_transfer);
-        }
-
-        // If dest is large, read from the unbuffered reader directly into the destination.
-        if dest.len() >= BUFFER_SIZE {
-            return self.unbuffered_reader.read(dest);
-        }
-
-        // If dest is small, read from the unbuffered reader into our own internal buffer,
-        // and then transfer to destination.
-        self.end = self.unbuffered_reader.read(&mut self.buf)?;
-        let to_transfer = self.end.min(dest.len());
-        dest[0..to_transfer].copy_from_slice(&self.buf[0..to_transfer]);
-        self.start = to_transfer;
-        Ok(to_transfer)
-    }
-
-    pub fn reader(&mut self) -> &mut Self {
-        // TODO(port): Zig returned a `std.Io.GenericReader` adapter wrapping `self`.
-        // Until the generic-reader port exists, hand back `&mut Self` (which already
-        // exposes `read`). Wire to the real adapter type once it exists.
-        self
-    }
-}
-
-// TODO(port): placeholder trait standing in for `ReaderType` duck-typing. Remove once
-// the shared reader trait exists and bound `R` on that instead.
-pub trait DeprecatedRead {
-    type Error;
-    fn read(&mut self, dest: &mut [u8]) -> Result<usize, Self::Error>;
-}
-
-pub fn buffered_reader<R: DeprecatedRead>(reader: R) -> BufferedReader<4096, R> {
-    BufferedReader {
-        unbuffered_reader: reader,
-        // PERF(port): Zig left `buf` undefined; zero-init here is an extra 4 KiB memset.
-        buf: [0u8; 4096],
-        start: 0,
-        end: 0,
-    }
-}
-
 // ──────────────────────────────────────────────────────────────────────────
 // SinglyLinkedList
 // ──────────────────────────────────────────────────────────────────────────
@@ -106,7 +47,6 @@ pub struct DoublyLinkedList<T> {
 }
 
 /// Node inside the linked list wrapping the actual data.
-// In Zig this is `DoublyLinkedList(T).Node`.
 pub struct DoublyLinkedNode<T> {
     pub prev: *mut DoublyLinkedNode<T>,
     pub next: *mut DoublyLinkedNode<T>,
@@ -463,5 +403,3 @@ mod tests {
 
     // RapidHash test vectors live alongside the canonical impl in `bun_hash::rapidhash`.
 }
-
-// ported from: src/bun_core/deprecated.zig
diff --git a/src/bun_core/env.rs b/src/bun_core/env.rs
index 85fe5aadd21..4c1f555671f 100644
--- a/src/bun_core/env.rs
+++ b/src/bun_core/env.rs
@@ -1,8 +1,6 @@
 use phf::phf_map;
 
-// PORT NOTE: `build_options` was Zig's build-system-injected module. In Rust it
-// is a generated module (build.rs consts).
-// Zig: `pub const build_options = @import("build_options");` — public re-export.
+// `build_options` is a generated module (build.rs consts), re-exported publicly.
 pub use crate::build_options;
 
 #[repr(u8)]
@@ -30,11 +28,10 @@ pub const IS_WINDOWS: bool = cfg!(windows);
 pub(crate) const IS_POSIX: bool = !IS_WINDOWS && !IS_WASM;
 pub const IS_DEBUG: bool = cfg!(debug_assertions);
 pub(crate) const IS_TEST: bool = cfg!(test);
-// Zig's `Environment.isLinux` is `builtin.target.os.tag == .linux`, which is
-// TRUE on Android (Zig models Android as `os.tag == .linux, abi == .android`).
-// Rust splits them into two `target_os` values, so this const has to OR them
-// to keep the Zig semantics — otherwise `OS` (below) panics at const-eval on
-// the `*-linux-android` cross targets and Linux-only code paths are skipped.
+// Android is a Linux kernel target, but Rust splits the two into separate
+// `target_os` values, so this const has to OR them — otherwise `OS` (below)
+// panics at const-eval on the `*-linux-android` cross targets and Linux-only
+// code paths are skipped.
 pub const IS_LINUX: bool = cfg!(any(target_os = "linux", target_os = "android"));
 pub(crate) const IS_FREEBSD: bool = cfg!(target_os = "freebsd");
 /// kqueue-based event loop (macOS + FreeBSD share most of this path).
@@ -50,8 +47,7 @@ pub const SHOW_CRASH_TRACE: bool = IS_DEBUG || IS_TEST || ENABLE_ASAN;
 
 pub const REPORTED_NODEJS_VERSION: &str = build_options::REPORTED_NODEJS_VERSION;
 pub const BASELINE: bool = build_options::BASELINE;
-/// Zig disabled SIMD under `-Dno_llvm` (self-hosted backend lacked vector
-/// lowering); Rust always uses LLVM, so only `BASELINE` gates it.
+/// Only `BASELINE` gates SIMD.
 pub const ENABLE_SIMD: bool = !BASELINE;
 pub const GIT_SHA: &str = build_options::SHA;
 pub const GIT_SHA_SHORT: &str = if !build_options::SHA.is_empty() {
@@ -102,9 +98,7 @@ pub enum OperatingSystem {
     Wasm,
 }
 
-/// Port of the subset of Zig's `std.Target.Os.Tag` that Bun targets.
-/// Variant names match the Zig stdlib tags (`.macos`, `.linux`, `.freebsd`,
-/// `.windows`) so cross-references in ported code stay 1:1.
+/// OS tag for the targets Bun builds for.
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum StdOsTag {
@@ -257,5 +251,3 @@ const fn const_str_slice(s: &'static str, start: usize, end: usize) -> &'static
         Err(_) => panic!("const_str_slice: not at a UTF-8 boundary"),
     }
 }
-
-// ported from: src/bun_core/env.zig
diff --git a/src/bun_core/env_var.rs b/src/bun_core/env_var.rs
index 84129898328..142987436a4 100644
--- a/src/bun_core/env_var.rs
+++ b/src/bun_core/env_var.rs
@@ -26,14 +26,8 @@
 //!                      everything. This means that we potentially scan through envp a lot of
 //!                      times, even though we could only do it once.
 
-// TODO(port): The Zig original uses comptime type-returning functions (`New`, `PlatformSpecificNew`)
-// that take comptime string keys + option structs and return a unique type per env var with an
-// embedded `static` cache. Rust cannot parameterize a generic type on `&'static str` + a struct
-// value in stable, so this port models `New`/`PlatformSpecificNew` as `macro_rules!` that emit a
-// module per env var. In Zig the declarations come first and the type-generator fns come last;
-// here the macros must be defined (or `#[macro_use]`d) before the declarations. The macro
-// definitions could move into a sibling `env_var_impl.rs` and be `#[macro_use]`d to restore Zig
-// declaration order in this file.
+// `New`/`PlatformSpecificNew` are `macro_rules!` that emit a module per env var; the macros
+// must be defined (or `#[macro_use]`d) before the declarations.
 
 use core::sync::atomic::{AtomicPtr, AtomicU8, AtomicU64, AtomicUsize, Ordering};
 
@@ -74,13 +68,13 @@ new!(pub BUN_DEBUG_QUIET_LOGS: boolean, "BUN_DEBUG_QUIET_LOGS", {});
 new!(pub BUN_DEBUG_TEST_TEXT_LOCKFILE: boolean, "BUN_DEBUG_TEST_TEXT_LOCKFILE", { default: false });
 new!(pub BUN_DEV_SERVER_TEST_RUNNER: string, "BUN_DEV_SERVER_TEST_RUNNER", {});
 // Debug-only: when set, `NumberRenamer` dumps the symbol table before
-// renaming (`src/js_printer/renamer.zig`). Presence-checked, value ignored.
+// renaming (`src/js_printer/renamer.rs`). Presence-checked, value ignored.
 new!(pub BUN_DUMP_SYMBOLS: string, "BUN_DUMP_SYMBOLS", {});
 new!(pub BUN_ENABLE_CRASH_REPORTING: boolean, "BUN_ENABLE_CRASH_REPORTING", {});
 // Opt-in: when truthy, Bun watches its original parent pid and exits as soon
 // as that process dies (even if the parent was SIGKILLed and couldn't forward
 // a signal), and on its own clean exit recursively SIGKILLs every descendant
-// so nothing it spawned outlives it. See `src/ParentDeathWatchdog.zig`.
+// so nothing it spawned outlives it. See `src/io/ParentDeathWatchdog.rs`.
 new!(pub BUN_FEATURE_FLAG_NO_ORPHANS: boolean, "BUN_FEATURE_FLAG_NO_ORPHANS", { default: false });
 new!(pub BUN_FEATURE_FLAG_DUMP_CODE: string, "BUN_FEATURE_FLAG_DUMP_CODE", {});
 // TODO(markovejnovic): It's unclear why the default here is 100_000, but this was legacy behavior
@@ -144,9 +138,9 @@ new!(pub JENKINS_URL: string, "JENKINS_URL", {});
 new!(pub MI_VERBOSE: boolean, "MI_VERBOSE", { default: false });
 new!(pub NO_COLOR: boolean, "NO_COLOR", { default: false });
 new!(pub NODE_CHANNEL_FD: string, "NODE_CHANNEL_FD", {});
-// Set by HostProcess.zig when spawning the WebView host subprocess. The
-// child's cli.zig checks this before anything else and hands off to C++
-// Bun__WebView__hostMain. Never returns — no JSC, no VM.
+// Set by HostProcess.rs when spawning the WebView host subprocess. The
+// child's CLI entrypoint checks this before anything else and hands off to
+// C++ Bun__WebView__hostMain. Never returns — no JSC, no VM.
 new!(pub BUN_INTERNAL_WEBVIEW_HOST: string, "BUN_INTERNAL_WEBVIEW_HOST", {});
 new!(pub NODE_PRESERVE_SYMLINKS_MAIN: boolean, "NODE_PRESERVE_SYMLINKS_MAIN", { default: false });
 new!(pub NODE_USE_SYSTEM_CA: boolean, "NODE_USE_SYSTEM_CA", { default: false });
@@ -157,7 +151,6 @@ new!(pub RUNNER_DEBUG: boolean, "RUNNER_DEBUG", { default: false });
 platform_specific_new!(pub SDKROOT: string, posix = "SDKROOT", windows = None, {});
 platform_specific_new!(pub SHELL: string, posix = "SHELL", windows = None, {});
 // C:\Windows, for example.
-// Note: Do not use this variable directly -- use os.zig's implementation instead.
 platform_specific_new!(pub SYSTEMROOT: string, posix = None, windows = "SYSTEMROOT", {});
 platform_specific_new!(pub TEMP: string, posix = "TEMP", windows = "TEMP", {});
 new!(pub TERM: string, "TERM", {});
@@ -169,7 +162,6 @@ new!(pub TODIUM: string, "TODIUM", {});
 platform_specific_new!(pub USER: string, posix = "USER", windows = "USERNAME", {});
 new!(pub WANTS_LOUD: boolean, "WANTS_LOUD", { default: false });
 // The same as system_root.
-// Note: Do not use this variable directly -- use os.zig's implementation instead.
 // TODO(markovejnovic): Perhaps we could add support for aliases in the library, so you could
 //                      specify both WINDIR and SYSTEMROOT and the loader would check both?
 platform_specific_new!(pub WINDIR: string, posix = None, windows = "WINDIR", {});
@@ -260,7 +252,6 @@ pub(crate) enum CacheOutput<V> {
     Value(V),
 }
 
-// Zig: `fn CacheConfigurationType(comptime CtorOptionsType: type) type`
 pub(crate) struct CacheConfiguration<O> {
     pub var_name: &'static [u8],
     pub opts: O,
@@ -289,18 +280,16 @@ pub(crate) mod kind {
         pub(crate) type ValueType = &'static [u8];
         pub(crate) type Output = CacheOutput<ValueType>;
 
-        // Zig: `fn Cache(comptime ip: Input) type` — `ip` is unused (`_ = ip;`).
-        // Rust: a single Cache struct; per-var uniqueness comes from each var owning its own
+        // A single Cache struct; per-var uniqueness comes from each var owning its own
         // `static CACHE: Cache`.
         pub(crate) struct Cache {
             ptr_value: AtomicPtr<u8>,
             len_value: AtomicUsize,
         }
 
-        type PointerType = *mut u8; // Zig: ?[*]const u8 — AtomicPtr requires *mut
+        type PointerType = *mut u8; // AtomicPtr requires *mut
         type LenType = usize;
 
-        // Zig nested `not_loaded_sentinel` / `not_set_sentinel` constants:
         const NOT_LOADED_PTR: PointerType = core::ptr::null_mut();
         const NOT_LOADED_LEN: LenType = LenType::MAX;
         const NOT_SET_PTR: PointerType = core::ptr::null_mut();
@@ -503,14 +492,10 @@ pub(crate) mod kind {
             }
         }
 
-        // Zig: `fn Cache(comptime ip: Input) type` — Rust: store `ip` (var_name + opts) on the
-        // struct so handle_error can read it. Zig passes it as a comptime param; we pass it at
-        // `const fn new()` time.
+        // `ip` (var_name + opts) lives on the struct so handle_error can read it; it is
+        // passed at `const fn new()` time.
         pub(crate) struct Cache {
             value: AtomicU64,
-            // TODO(port): in Zig `ip` is a comptime param baked into the type; here it lives as
-            // runtime data on the static. The `default_fallback` arm in handle_error was a
-            // `@compileError` when no default was set — that compile-time check is lost.
             ip: Input,
         }
 
@@ -560,8 +545,7 @@ pub(crate) mod kind {
                     }
                 }
 
-                // Zig: `std.fmt.parseInt(u64, raw_env, 10)` — distinguishes Overflow vs
-                // InvalidCharacter. Exact parity incl. '-0'→0, '-N'→Overflow,
+                // Distinguishes Overflow vs InvalidCharacter; '-0'→0, '-N'→Overflow,
                 // leading/trailing-`_` reject.
                 let formatted = match crate::fmt::parse_int::<u64>(raw_env, 10) {
                     Ok(v) => v,
@@ -582,9 +566,6 @@ pub(crate) mod kind {
             }
 
             fn handle_error(&self, raw_env: &[u8], reason: &'static str) -> Option<ValueType> {
-                // Zig built `fmt` at comptime via string concatenation:
-                //   "Environment variable '{s}' has value '{s}' which " ++ reason ++ "."
-                // We pass `reason` as a third argument instead.
                 match self.ip.opts.deser.error_handling {
                     ErrorHandling::DebugWarn => {
                         crate::output::debug_warn(format_args!(
@@ -622,8 +603,6 @@ pub(crate) mod kind {
 /// Technically, none of the operations here are thread-safe, so writing to environment variables
 /// does not guarantee that other threads will see the changes. You should avoid writing to
 /// environment variables.
-// Zig: `fn New(comptime VariantType: type, comptime key: [:0]const u8, comptime opts) type`
-//      → `PlatformSpecificNew(VariantType, key, key, opts)`
 #[macro_export]
 #[doc(hidden)]
 macro_rules! new {
@@ -640,15 +619,12 @@ pub(crate) use new;
 /// If the current platform does not have a key specified, all methods that attempt to read the
 /// environment variable will fail at compile time, except for `platform_get` and `platform_key`,
 /// which will return None instead.
-// Zig: `fn PlatformSpecificNew(comptime VariantType, comptime posix_key: ?[:0]const u8,
-//                              comptime windows_key: ?[:0]const u8, comptime opts) type`
 #[macro_export]
 #[doc(hidden)]
 macro_rules! platform_specific_new {
-    // TODO(port): this macro is a draft of the Zig comptime type-generator. It expands to a
-    // `pub mod $name { pub fn get() / key() / platform_get() / ... }` so call sites read
-    // `env_var::HOME::get()` like Zig's `env_var.HOME.get()`. The opts-parsing arms below cover
-    // exactly the option shapes used in this file; harden / generalize if new shapes appear.
+    // Expands to a `pub mod $name { pub fn get() / key() / platform_get() / ... }` so call
+    // sites read `env_var::HOME::get()`. The opts-parsing arms below cover
+    // exactly the option shapes used in this file; new shapes need new arms.
     (
         $vis:vis $name:ident : $kind:ident,
         posix = $posix:tt, windows = $windows:tt,
@@ -662,17 +638,14 @@ macro_rules! platform_specific_new {
             use $crate::env_var::kind::$kind as K;
             use $crate::env_var::CacheOutput;
 
-            // Zig: `const comptime_key: []const u8 = posix_key orelse windows_key orelse "<unknown>"`
-            // (Compile-error when both null is enforced by having no matching macro arm.)
-            // Zig: `var cache: VariantType.Cache(.{ .var_name = comptime_key, .opts = opts }) = .{};`
+            // (Compile-error when both keys are None is enforced by having no matching macro arm.)
             static CACHE: K::Cache = $crate::env_var::__make_cache!(
                 $kind, $crate::env_var::__first_key!($posix, $windows), { $($opts)* }
             );
 
-            // Zig computed `DefaultType`/`ReturnType` at comptime from whether `opts.default` is
-            // set. We expose the default + a const HAS_DEFAULT and always return Option<ValueType>;
-            // a thin `pub fn get() -> ValueType` wrapper that `.unwrap()`s is added when a default
-            // exists. TODO(port): restore the non-nullable `get()` return type for defaulted vars.
+            // A `macro_rules!` expansion can't vary the return type on an optional opt, so
+            // `get()` always returns `Option<ValueType>` (always `Some` when `DEFAULT` is
+            // `Some`).
             pub(crate) const DEFAULT: Option<K::ValueType> =
                 $crate::env_var::__default_opt!($kind, { $($opts)* });
 
@@ -726,9 +699,8 @@ macro_rules! platform_specific_new {
                 None
             }
 
-            // TODO(port): `getNotEmpty` only makes sense for string-kind vars (it calls `.len`).
-            // In Zig, lazy compilation means it simply isn't instantiated for non-string vars.
-            // Could gate this fn on `$kind == string` via a separate macro arm.
+            // `get_not_empty` only makes sense for string-kind vars (it calls `.len`). The
+            // `HasLen` bound gates this — calls on non-string kinds fail to compile.
             pub fn get_not_empty() -> Option<K::ValueType>
             where
                 K::ValueType: $crate::env_var::HasLen,
@@ -786,11 +758,10 @@ macro_rules! platform_specific_new {
             ///
             /// It is safe to compare the result of .get() to default to test if the variable is set to
             /// its default value.
-            // Zig: `pub const default: DefaultType = if (opts.default) |d| d else {};`
             // Exposed above as `DEFAULT: Option<ValueType>`.
 
-            /// Unit value so call sites read `env_var::FOO.get()` (matching Zig
-            /// `bun.env_var.FOO.get()`). The module-path form `FOO::get()` also works.
+            /// Unit value so call sites read `env_var::FOO.get()`. The module-path form
+            /// `FOO::get()` also works.
             pub struct Accessor;
             impl Accessor {
                 #[inline] pub fn get(&self) -> Option<K::ValueType> { get() }
@@ -802,18 +773,13 @@ macro_rules! platform_specific_new {
             }
 
             fn assert_platform_supported() {
-                // Zig: `@compileError` when the current platform's key is null.
-                // TODO(port): Rust cannot `compile_error!` from inside a const-evaluated `if cfg!`
-                // without separate macro arms per (posix=None / windows=None) combination. Could
-                // split the macro so e.g. `posix = None` emits `#[cfg(unix)] compile_error!`.
+                // A `compile_error!` here would fire unconditionally on the unsupported
+                // platform even when nothing calls `get()`, so this is a debug assertion.
                 debug_assert!(
                     platform_key().is_some(),
-                    concat!(
-                        "Cannot retrieve the value of ",
-                        // TODO(port): COMPTIME_KEY is &[u8]; concat! wants literals
-                        "<env var>",
-                        " since no key is associated with it on this platform."
-                    )
+                    "Cannot retrieve the value of {} since no key is associated with it on this platform.",
+                    ::core::str::from_utf8($crate::env_var::__first_key!($posix, $windows))
+                        .unwrap_or("<env var>")
                 );
             }
         }
@@ -822,8 +788,6 @@ macro_rules! platform_specific_new {
 pub(crate) use platform_specific_new;
 
 // ─── helper macros for platform_specific_new! ───
-// TODO(port): these are scaffolding for the draft macro; could be replaced with a cleaner
-// trait-based design once the call-site shape is settled.
 
 #[doc(hidden)]
 #[macro_export]
@@ -945,8 +909,6 @@ impl HasLen for u64 {
     }
 }
 
-// Zig: `fn newFeatureFlag(comptime env_var: [:0]const u8, comptime opts: FeatureFlagOpts) type`
-//      → `New(kind.boolean, env_var, .{ .default = opts.default })`
 #[macro_export]
 #[doc(hidden)]
 macro_rules! new_feature_flag {
@@ -962,5 +924,3 @@ macro_rules! new_feature_flag {
     };
 }
 pub(crate) use new_feature_flag;
-
-// ported from: src/bun_core/env_var.zig
diff --git a/src/bun_core/external_shared.rs b/src/bun_core/external_shared.rs
index a7650784f2e..5418e4a9851 100644
--- a/src/bun_core/external_shared.rs
+++ b/src/bun_core/external_shared.rs
@@ -2,13 +2,10 @@ use core::ptr::NonNull;
 
 /// Protocol for types whose reference count is managed externally (e.g., by extern functions).
 ///
-/// In Zig this is duck-typed via `T.external_shared_descriptor = struct { ref, deref }`.
-/// In Rust the type implements this trait directly.
-///
 /// # Safety
 /// Implementors guarantee that `ext_ref`/`ext_deref` operate on a valid externally-owned
 /// reference count, and that the pointee remains alive while the count is > 0.
-// PORT NOTE: Zig names are `ref`/`deref`; renamed to avoid the `ref` keyword and
+// Named `ext_ref`/`ext_deref` to avoid the `ref` keyword and
 // `core::ops::Deref::deref` confusion.
 pub unsafe trait ExternalSharedDescriptor {
     unsafe fn ext_ref(this: *mut Self);
@@ -17,11 +14,9 @@ pub unsafe trait ExternalSharedDescriptor {
 
 /// A shared pointer whose reference count is managed externally; e.g., by extern functions.
 ///
-/// `T` must implement [`ExternalSharedDescriptor`] (the Rust equivalent of Zig's
-/// `T.external_shared_descriptor` struct with `ref(*T)` / `deref(*T)`).
+/// `T` must implement [`ExternalSharedDescriptor`].
 #[repr(transparent)]
 pub struct ExternalShared<T: ExternalSharedDescriptor> {
-    // Zig: `#impl: *T` (private, non-null)
     ptr: NonNull<T>,
 }
 
@@ -33,7 +28,8 @@ impl<T: ExternalSharedDescriptor> ExternalShared<T> {
     /// ownership of is being transferred to the returned `ExternalShared`.
     pub unsafe fn adopt(incremented_raw: *mut T) -> Self {
         Self {
-            // SAFETY: Zig `*T` is non-null by construction.
+            // SAFETY: caller contract requires `incremented_raw` to be a valid
+            // (hence non-null) pointer.
             ptr: unsafe { NonNull::new_unchecked(incremented_raw) },
         }
     }
@@ -56,7 +52,8 @@ impl<T: ExternalSharedDescriptor> ExternalShared<T> {
         // SAFETY: caller contract.
         unsafe { T::ext_ref(raw) };
         Self {
-            // SAFETY: Zig `*T` is non-null.
+            // SAFETY: caller contract requires `raw` to be a valid (hence
+            // non-null) pointer.
             ptr: unsafe { NonNull::new_unchecked(raw) },
         }
     }
@@ -108,10 +105,9 @@ impl<T: ExternalSharedDescriptor> Drop for ExternalShared<T> {
     }
 }
 
-/// Optional variant of [`ExternalShared`] (Zig: `ExternalShared(T).Optional`).
+/// Optional variant of [`ExternalShared`].
 #[repr(transparent)]
 pub struct ExternalSharedOptional<T: ExternalSharedDescriptor> {
-    // Zig: `#impl: ?*T = null`
     ptr: Option<NonNull<T>>,
 }
 
@@ -205,5 +201,3 @@ unsafe impl ExternalSharedDescriptor for bun_alloc::WTFStringImplStruct {
 
 /// Behaves like `WTF::Ref<WTF::StringImpl>`.
 pub type WTFString = ExternalShared<bun_alloc::WTFStringImplStruct>;
-
-// ported from: src/ptr/external_shared.zig
diff --git a/src/bun_core/feature_flags.rs b/src/bun_core/feature_flags.rs
index e95397b987b..2015363e3e5 100644
--- a/src/bun_core/feature_flags.rs
+++ b/src/bun_core/feature_flags.rs
@@ -131,5 +131,3 @@ pub fn bake() -> bool {
 /// Additional debugging features for bake.DevServer, such as the incremental visualizer.
 /// To use them, extra flags are passed in addition to this one.
 pub const BAKE_DEBUGGING_FEATURES: bool = env::IS_CANARY || env::IS_DEBUG;
-
-// ported from: src/bun_core/feature_flags.zig
diff --git a/src/bun_core/fmt.rs b/src/bun_core/fmt.rs
index 930c51973cf..5c94c455603 100644
--- a/src/bun_core/fmt.rs
+++ b/src/bun_core/fmt.rs
@@ -1,4 +1,4 @@
-//! Port of src/bun_core/fmt.zig — formatter newtypes and Display impls.
+//! Formatter newtypes and Display impls.
 
 use core::cell::Cell;
 use core::fmt::{self, Display, Formatter, Write as _};
@@ -20,14 +20,14 @@ const SHA512_DIGEST: usize = 64;
 // ════════════════════════════════════════════════════════════════════════════
 
 pub mod js_lexer {
-    /// Zig: js_lexer.isIdentifierStart — ASCII fast path; bun_js_parser extends
-    /// with the full Unicode ID_Start table.
+    /// ASCII fast path; bun_js_parser extends with the full Unicode ID_Start
+    /// table.
     #[inline]
     pub fn is_identifier_start(c: i32) -> bool {
         matches!(c, 0x24 /* $ */ | 0x5F /* _ */)
             || (c >= b'a' as i32 && c <= b'z' as i32)
             || (c >= b'A' as i32 && c <= b'Z' as i32)
-            || c > 0x7F // PERF(port): defer Unicode table to bun_js_parser
+            || c > 0x7F // non-ASCII: the full Unicode table lives in bun_js_parser
     }
     #[inline]
     pub fn is_identifier_continue(c: i32) -> bool {
@@ -38,7 +38,7 @@ pub mod js_lexer {
 pub mod js_printer {
     use super::strings::Encoding;
     use core::fmt;
-    /// Zig: js_printer.writeJSONString — minimal escape set for fmt.rs quoting.
+    /// Minimal escape set for fmt.rs quoting.
     /// bun_js_printer overrides with the full (ctrl-char, \u escape, encoding-aware) impl.
     pub fn write_json_string(input: &[u8], f: &mut impl fmt::Write, enc: Encoding) -> fmt::Result {
         f.write_char('"')?;
@@ -52,18 +52,20 @@ pub mod js_printer {
         input: &[u8],
         f: &mut impl fmt::Write,
         quote: u8,
-        _allow_backtick: bool,
+        ascii_only: bool,
         enc: Encoding,
     ) -> fmt::Result {
-        // TODO(port): full impl in bun_js_printer; this tier only needs the
-        // "already quoted" passthrough for fmt.rs JS-string display.
-        // Zig writePreQuotedString writes the escaped body WITHOUT surrounding
-        // quotes — delegate to the canonical chars-only escaper.
-        let _ = quote;
-        match enc {
-            Encoding::Latin1 => super::encode_json_string_chars_latin1(f, input),
-            _ => super::encode_json_string_chars(f, input),
-        }
+        // Writes the escaped body WITHOUT surrounding quotes. Delegate to the
+        // canonical impl in `string::printer` (a byte-sink writer) and bridge
+        // the result into the `fmt::Write`. In JSON mode (`json = true`) every
+        // non-printable scalar (including lone surrogates) is emitted as an
+        // ASCII escape.
+        let mut buf: Vec<u8> = Vec::with_capacity(input.len() + 8);
+        crate::string::printer::write_pre_quoted_string(
+            input, &mut buf, quote, ascii_only, true, enc,
+        )
+        .map_err(|_| fmt::Error)?;
+        f.write_str(&String::from_utf8_lossy(&buf))
     }
 }
 use strum::IntoStaticStr;
@@ -252,7 +254,7 @@ impl Display for RedactedNpmUrlFormatter<'_> {
 
             // Emit the run of bytes up to the next position where a uuid/npm
             // secret could possibly start, so multi-byte UTF-8 sequences are
-            // written intact (Zig writes raw bytes, not Latin-1→UTF-8 chars).
+            // written intact (raw bytes, not Latin-1→UTF-8 chars).
             let mut next = i + 1;
             while next < self.url.len() {
                 let b = self.url[next];
@@ -292,8 +294,8 @@ impl Display for RedactedSourceFormatter<'_> {
             }
 
             // Batch the non-secret span so multi-byte UTF-8 sequences pass
-            // through intact (Zig writes raw bytes; per-byte `as char` would
-            // re-encode each >=0x80 byte as a 2-byte sequence).
+            // through intact (per-byte `as char` would re-encode each >=0x80
+            // byte as a 2-byte sequence).
             let mut next = i + 1;
             while next < self.text.len()
                 && strings::starts_with_secret(&self.text[next..]).is_none()
@@ -464,7 +466,7 @@ thread_local! {
 /// On construction: takes (or allocates) the buffer and nulls the thread-local
 /// cell so any recursive borrow allocates a fresh one instead of aliasing this
 /// one. On drop: restores the buffer to the cell, or frees it if recursion has
-/// already restored a different buffer (mirrors fmt.zig's `defer` block).
+/// already restored a different buffer.
 struct SharedTempBufferBorrow {
     ptr: NonNull<SharedTempBuffer>,
 }
@@ -719,14 +721,13 @@ pub fn fmt_path(path: &[u8], options: PathFormatOptions) -> FormatUTF8<'_> {
 
 /// Non-validating `Display` adapter for a `&[u8]` known to be valid UTF-8.
 ///
-/// Port of Zig's `{s}` format specifier on a `[]const u8`: Zig writes the bytes
-/// straight through with no codepoint check. `bstr::BStr`'s `Display` impl walks
+/// Writes the bytes straight through with no codepoint check. `bstr::BStr`'s `Display` impl walks
 /// the input via `Utf8Chunks` to substitute U+FFFD on invalid sequences, which
 /// shows up in install-hot-path profiles (registry hosts, package names, semver
 /// pre/build tags — all pre-validated ASCII). Use this where the bytes are
 /// already known-good and you just want `f.write_str` semantics.
 ///
-/// Prefer the [`s`] alias at call sites — it reads like Zig's `{s}`.
+/// Prefer the [`s`] alias at call sites.
 #[derive(Copy, Clone)]
 #[repr(transparent)]
 pub struct Raw<'a>(pub &'a [u8]);
@@ -734,11 +735,11 @@ impl fmt::Display for Raw<'_> {
     #[inline(always)]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // SAFETY: caller contract — `self.0` is valid UTF-8 (in practice ASCII:
-        // npm package names, registry URLs, semver tags). Matches Zig `{s}`.
+        // npm package names, registry URLs, semver tags).
         f.write_str(unsafe { core::str::from_utf8_unchecked(self.0) })
     }
 }
-/// Shorthand constructor for [`Raw`]. Prefer [`s`] (same thing, Zig-style name).
+/// Shorthand constructor for [`Raw`]. Prefer [`s`] (same thing, shorter name).
 #[inline(always)]
 pub const fn raw(bytes: &[u8]) -> Raw<'_> {
     Raw(bytes)
@@ -747,7 +748,7 @@ pub const fn raw(bytes: &[u8]) -> Raw<'_> {
 // Canonical `SliceCursor` / `buf_print` / `buf_print_len` live in T0
 // `bun_alloc` so that crate can use them too; re-exported here for the
 // `bun_core::fmt::` callers and extended with an `io::Write` face so the same
-// struct also serves as Zig's `std.io.fixedBufferStream` for write-only sites.
+// struct also serves as a fixed-buffer write sink for write-only sites.
 pub use bun_alloc::{SliceCursor, buf_print, buf_print_len};
 
 impl crate::io::Write for SliceCursor<'_> {
@@ -767,7 +768,7 @@ impl crate::io::Write for SliceCursor<'_> {
     }
 }
 
-/// Port of `std.fmt.bufPrintZ` — [`buf_print`] then append a NUL terminator and
+/// [`buf_print`] then append a NUL terminator and
 /// return a [`ZStr`](crate::ZStr) borrowing `buf`. Fails if the formatted output
 /// *plus* the trailing NUL doesn't fit.
 pub fn buf_print_z<'a>(
@@ -784,8 +785,7 @@ pub fn buf_print_z<'a>(
     Ok(crate::ZStr::from_buf(c.buf, n))
 }
 
-/// [`buf_print`] that panics on overflow — mirrors Zig's
-/// `std.fmt.bufPrint(buf, fmt, args) catch unreachable`. Use when the
+/// [`buf_print`] that panics on overflow. Use when the
 /// caller-supplied stack buffer is sized so overflow is a programmer error.
 #[inline]
 #[track_caller]
@@ -793,8 +793,7 @@ pub fn buf_print_infallible<'a>(buf: &'a mut [u8], args: core::fmt::Arguments<'_
     buf_print(buf, args).expect("buf_print: buffer too small")
 }
 
-/// [`buf_print_z`] that panics on overflow — mirrors Zig's
-/// `std.fmt.bufPrintZ(buf, fmt, args) catch unreachable`.
+/// [`buf_print_z`] that panics on overflow.
 #[inline]
 #[track_caller]
 pub fn buf_print_z_infallible<'a>(
@@ -811,8 +810,8 @@ pub fn buf_print_z_infallible<'a>(
 /// `core::fmt::Write` adapter for `Vec<u8>`.
 ///
 /// Rust's `Vec<u8>` only implements `std::io::Write` (banned in lower crates
-/// per PORTING.md), not `core::fmt::Write`. This is the port of Zig's
-/// `std.ArrayList(u8).writer()` — infallible (Vec growth aborts on OOM).
+/// per PORTING.md), not `core::fmt::Write`. Infallible (Vec growth aborts on
+/// OOM).
 ///
 /// Both the tuple constructor and `::new()` are public so call sites can pick
 /// whichever reads better: `write!(VecWriter(&mut buf), ...)` or
@@ -834,17 +833,14 @@ impl core::fmt::Write for VecWriter<'_> {
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// std.fmt.parseInt / parseUnsigned — canonical &[u8] integer parsers.
+// parse_int / parse_unsigned — canonical &[u8] integer parsers.
 //
-// Zig has exactly one impl (`std.fmt.parseIntWithSign`, vendor/zig/lib/std/
-// fmt.zig:409) plus thin no-sign wrapper `std.fmt.parseUnsigned` (:488). Every
-// Zig caller invoked those directly on `[]const u8`; the Rust port spawned ~15
-// local digit loops solely to dodge `core::str::from_utf8`. These restore 1:1
-// parity. bun_string re-exports `parse_int` so existing `strings::parse_int`
-// callers keep working. Re-exported via bun_core::lib.rs.
+// Replaces ~15 local digit loops that existed solely to dodge
+// `core::str::from_utf8`. bun_string re-exports `parse_int` so existing
+// `strings::parse_int` callers keep working. Re-exported via bun_core::lib.rs.
 // ════════════════════════════════════════════════════════════════════════════
 
-/// Error from [`parse_int`] / [`parse_unsigned`] (`std.fmt.ParseIntError` port).
+/// Error from [`parse_int`] / [`parse_unsigned`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ParseIntError {
     InvalidCharacter,
@@ -852,7 +848,7 @@ pub enum ParseIntError {
 }
 
 impl ParseIntError {
-    /// Zig `@errorName(e)` — for callers that bubble the tag verbatim
+    /// For callers that bubble the tag verbatim
     /// (e.g. Postgres `CommandTag` Debug fmt).
     #[inline]
     pub const fn name(self) -> &'static str {
@@ -864,9 +860,9 @@ impl ParseIntError {
 }
 
 /// Shared digit loop behind [`parse_int`] / [`parse_unsigned`]. `digits` has
-/// any sign already stripped; `radix` is post-auto-detect (2..=36). Mirrors
-/// `std.fmt.parseIntWithSign` body: skips embedded `_` separators, rejects
-/// leading/trailing `_`, accumulates in `u128` with checked overflow.
+/// any sign already stripped; `radix` is post-auto-detect (2..=36). Skips
+/// embedded `_` separators, rejects leading/trailing `_`, accumulates in
+/// `u128` with checked overflow.
 #[inline]
 fn parse_with_sign(digits: &[u8], radix: u8) -> Result<u128, ParseIntError> {
     debug_assert!((2..=36).contains(&radix));
@@ -897,7 +893,7 @@ fn parse_with_sign(digits: &[u8], radix: u8) -> Result<u128, ParseIntError> {
 }
 
 /// Strip an optional `0x`/`0o`/`0b` prefix when `radix == 0`; otherwise pass
-/// through unchanged. Mirrors `std.fmt.parseIntWithSign` radix-0 branch.
+/// through unchanged.
 #[inline]
 fn auto_radix(digits: &[u8], radix: u8) -> (&[u8], u8) {
     if radix != 0 {
@@ -914,12 +910,12 @@ fn auto_radix(digits: &[u8], radix: u8) -> (&[u8], u8) {
     (digits, 10)
 }
 
-/// `std.fmt.parseInt(T, buf, radix)` — parse an integer of type `T` from `buf`.
+/// Parse an integer of type `T` from `buf`.
 ///
 /// `radix` ∈ 2..=36, or `0` to auto-detect from a `0x`/`0o`/`0b` prefix
 /// (defaulting to 10). Accepts an optional leading `+`/`-`. Embedded `_`
-/// separators are skipped; leading/trailing `_` are rejected. Port keeps Zig's
-/// error set: `Overflow` on range error, `InvalidCharacter` otherwise.
+/// separators are skipped; leading/trailing `_` are rejected. Errors:
+/// `Overflow` on range error, `InvalidCharacter` otherwise.
 ///
 /// Works directly on `&[u8]` so callers never need an intermediate
 /// `core::str::from_utf8` round-trip.
@@ -951,7 +947,7 @@ where
     }
 }
 
-/// `std.fmt.parseUnsigned(T, buf, radix)` — [`parse_int`] without sign
+/// [`parse_int`] without sign
 /// handling: a leading `+`/`-` is `InvalidCharacter`. Use when the grammar
 /// being parsed forbids signs (semver components, HTTP status codes,
 /// content-length, etc.).
@@ -965,10 +961,9 @@ where
     T::try_from(acc).map_err(|_| ParseIntError::Overflow)
 }
 
-/// `std.fmt.parseInt(T, s, 10) catch null` — decimal convenience wrapper over
+/// Decimal convenience wrapper over
 /// [`parse_int`]. Replaces the ~12 file-local
-/// `fn parse_T(s:&[u8])->Option<T>{ parse_int(s,10).ok() }` thin wrappers the
-/// port spawned (Zig calls `std.fmt.parseInt` inline at every site).
+/// `fn parse_T(s:&[u8])->Option<T>{ parse_int(s,10).ok() }` thin wrappers.
 #[inline]
 pub fn parse_decimal<T>(s: &[u8]) -> Option<T>
 where
@@ -978,7 +973,7 @@ where
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// parse_double — `WTF.parseDouble` (src/jsc/WTF.zig:20 / bun.zig:1150)
+// parse_double — `WTF::parseDouble`
 //
 // Partial-match JS-semantics double parse over Latin-1 bytes. Unlike
 // [`parse_f64`] this accepts a numeric *prefix* (`b"1.5x"` → `Ok(1.5)`) and
@@ -986,15 +981,10 @@ where
 //
 // Lives in tier-0 `bun_core` (not `bun_jsc`) so `bun_interchange` (yaml/toml),
 // `bun_js_parser::lexer`, and `bun_install` can call it without taking a
-// `bun_jsc` edge. `bun_core::wtf`, `bun_jsc::wtf`, and `bun::` re-export it
-// to preserve the Zig namespace shape.
-//
-// TODO(port): Zig `bun.parseDouble` falls back to `std.fmt.parseFloat` under
-// `comptime Environment.isWasm` (no WebKit link). Restore when wasm target is
-// brought up.
+// `bun_jsc` edge. `bun_core::wtf`, `bun_jsc::wtf`, and `bun::` re-export it.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Error from [`parse_double`] — Zig `error{InvalidCharacter}`.
+/// Error from [`parse_double`].
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct InvalidCharacter;
 
@@ -1036,14 +1026,13 @@ unsafe extern "C" {
     fn WTF__parseDouble(bytes: *const u8, length: usize, counted: *mut usize) -> f64;
 }
 
-/// `std.fmt.parseFloat(f64, buf)` — full-match parse of `s` as an `f64`.
+/// Full-match parse of `s` as an `f64`.
 /// Returns `None` on empty input, trailing garbage (`b"1.5x"`), or non-numeric
 /// input. Backed by `WTF__parseDouble` (no `&str` round-trip — digits are
 /// ASCII, validation is wasted work).
 ///
 /// `WTF::parseDouble` rejects `inf`/`nan` (JS-number semantics); those are
-/// special-cased here so callers ported from `std.fmt.parseFloat` keep the
-/// same surface.
+/// special-cased here.
 pub fn parse_f64(s: &[u8]) -> Option<f64> {
     if s.is_empty() {
         return None;
@@ -1055,7 +1044,7 @@ pub fn parse_f64(s: &[u8]) -> Option<f64> {
         return Some(res);
     }
     if count == 0 {
-        // WTF__parseDouble doesn't recognise inf/nan; std.fmt.parseFloat does.
+        // WTF__parseDouble doesn't recognise inf/nan; handle them here.
         let (neg, rest) = match s[0] {
             b'-' => (true, &s[1..]),
             b'+' => (false, &s[1..]),
@@ -1076,7 +1065,7 @@ pub fn parse_f64(s: &[u8]) -> Option<f64> {
     None // partial match → trailing garbage
 }
 
-/// `parse_f64` truncated to `f32`. (Zig `std.fmt.parseFloat(f32, ..)`.)
+/// `parse_f64` truncated to `f32`.
 #[inline]
 pub fn parse_f32(s: &[u8]) -> Option<f32> {
     parse_f64(s).map(|v| v as f32)
@@ -1231,8 +1220,7 @@ impl Display for HostFormatter<'_> {
 // FormatValidIdentifier
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Format a string to an ECMAScript identifier.
-/// Unlike the string_mutable.zig version, this always allocate/copy
+/// Format a string to an ECMAScript identifier. Always allocates/copies.
 pub fn fmt_identifier(name: &[u8]) -> FormatValidIdentifier<'_> {
     FormatValidIdentifier { name }
 }
@@ -1457,7 +1445,7 @@ pub fn fmt_java_script(
     QuickAndDirtyJavaScriptSyntaxHighlighter { text, opts }
 }
 
-/// snake_case alias of `fmt_java_script` (Zig: `fmtJavaScript`). Several
+/// snake_case alias of `fmt_java_script`. Several
 /// downstream crates spell it `fmt_javascript`.
 #[inline]
 pub fn fmt_javascript(
@@ -1513,8 +1501,7 @@ impl ColorCode {
 
 #[derive(Clone, Copy, PartialEq, Eq, IntoStaticStr)]
 #[strum(serialize_all = "snake_case")]
-// bun.ComptimeEnumMap(Keyword) — Zig builds a comptime perfect-hash map keyed by @tagName.
-// Mapped to `phf::Map<&'static [u8], Keyword>` in `Keywords::get` below.
+// Perfect-hash map keyed by tag name: `phf::Map<&'static [u8], Keyword>` in `Keywords::get` below.
 pub enum Keyword {
     Abstract,
     As,
@@ -1733,7 +1720,8 @@ pub enum RedactedKeyword {
 
 pub struct RedactedKeywords;
 impl RedactedKeywords {
-    // TODO(port): replace with phf::Map.
+    // 5 entries — a `matches!` chain beats a hash map at this size (the big
+    // keyword table in `Keywords::get` is where `phf` pays off).
     pub fn has(s: &[u8]) -> bool {
         matches!(
             s,
@@ -1780,12 +1768,9 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                     let code = keyword.color_code();
                     write!(
                         writer,
-                        // TODO(port): Output.prettyFmt("<r>{s}{s}<r>", true)
-                        "{}{}{}{}",
-                        Output::RESET,
+                        crate::pretty_fmt!("<r>{s}{s}<r>", true),
                         code.color(),
                         bstr::BStr::new(&text[..i]),
-                        Output::RESET,
                     )?;
                 } else {
                     should_redact_value =
@@ -1797,14 +1782,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                                     prev_keyword = None;
 
                                     if i < text.len() && text[i] == b'(' {
-                                        // TODO(port): Output.prettyFmt("<r><b>{s}<r>", true)
                                         write!(
                                             writer,
-                                            "{}{}{}{}",
-                                            Output::RESET,
-                                            Output::BOLD,
+                                            crate::pretty_fmt!("<r><b>{s}<r>", true),
                                             bstr::BStr::new(&text[..i]),
-                                            Output::RESET,
                                         )?;
                                         break 'write;
                                     }
@@ -1814,15 +1795,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                                 | Keyword::Declare
                                 | Keyword::Type
                                 | Keyword::Interface => {
-                                    // TODO(port): Output.prettyFmt("<r><b><blue>{s}<r>", true)
                                     write!(
                                         writer,
-                                        "{}{}{}{}{}",
-                                        Output::RESET,
-                                        Output::BOLD,
-                                        ColorCode::Blue.color(),
+                                        crate::pretty_fmt!("<r><b><blue>{s}<r>", true),
                                         bstr::BStr::new(&text[..i]),
-                                        Output::RESET,
                                     )?;
                                     prev_keyword = None;
                                     break 'write;
@@ -1887,8 +1863,7 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                                 let end = crate::strings_impl::index_of_char(text, b'\n')
                                     .unwrap_or(text.len());
                                 text = &text[end..];
-                                // TODO(port): Output.prettyFmt("<r><yellow>***<r>", true)
-                                write!(writer, "{}\x1b[33m***{}", Output::RESET, Output::RESET)?;
+                                write!(writer, crate::pretty_fmt!("<r><yellow>***<r>", true))?;
                                 continue;
                             }
 
@@ -1926,13 +1901,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             }
                         }
 
-                        // TODO(port): Output.prettyFmt("<r><yellow>{s}<r>", true)
                         write!(
                             writer,
-                            "{}\x1b[33m{}{}",
-                            Output::RESET,
+                            crate::pretty_fmt!("<r><yellow>{s}<r>", true),
                             bstr::BStr::new(&text[..i]),
-                            Output::RESET,
                         )?;
                         text = &text[i..];
                     }
@@ -1954,13 +1926,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                                         i += 1;
                                     }
 
-                                    // TODO(port): Output.prettyFmt("<r><green>{s}<r>", true)
                                     write!(
                                         writer,
-                                        "{}\x1b[32m{}{}",
-                                        Output::RESET,
+                                        crate::pretty_fmt!("<r><green>{s}<r>", true),
                                         bstr::BStr::new(&text[..curly_start]),
-                                        Output::RESET,
                                     )?;
                                     writer.write_str("${")?;
                                     let mut opts = self.opts;
@@ -1981,13 +1950,7 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                                     text = &text[i..];
                                     i = 0;
                                     if !text.is_empty() && text[0] == char_ {
-                                        // TODO(port): Output.prettyFmt("<r><green>`<r>", true)
-                                        write!(
-                                            writer,
-                                            "{}\x1b[32m`{}",
-                                            Output::RESET,
-                                            Output::RESET
-                                        )?;
+                                        write!(writer, crate::pretty_fmt!("<r><green>`<r>", true))?;
                                         text = &text[1..];
                                         continue 'outer;
                                     }
@@ -2009,8 +1972,11 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             should_redact_value = false;
                             if i > 2 && text[i - 1] == char_ {
                                 let len = i - 2;
-                                // TODO(port): Output.prettyFmt("<r><green>{c}", true)
-                                write!(writer, "{}\x1b[32m{}", Output::RESET, char_ as char)?;
+                                write!(
+                                    writer,
+                                    crate::pretty_fmt!("<r><green>{s}", true),
+                                    char_ as char
+                                )?;
                                 splat_byte_all(writer, b'*', len)?;
                                 write!(writer, "{}{}", char_ as char, Output::RESET)?;
                             } else {
@@ -2125,13 +2091,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             }
 
                             if self.opts.redact_sensitive_information {
-                                // TODO(port): Output.prettyFmt("<r><d>{f}<r>", true)
                                 write!(
                                     writer,
-                                    "{}\x1b[2m{}{}",
-                                    Output::RESET,
+                                    crate::pretty_fmt!("<r><d>{f}<r>", true),
                                     redacted_source(remain_to_print),
-                                    Output::RESET,
                                 )?;
                             } else {
                                 write!(
@@ -2227,8 +2190,7 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             text = &text[len..];
                             continue;
                         }
-                        // TODO(port): Output.prettyFmt("<r><d>;<r>", true)
-                        write!(writer, "{}\x1b[2m;{}", Output::RESET, Output::RESET)?;
+                        write!(writer, crate::pretty_fmt!("<r><d>;<r>", true))?;
                         text = &text[1..];
                     }
                     b'.' => {
@@ -2255,14 +2217,10 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             }
 
                             if i < text.len() && text[i] == b'(' {
-                                // TODO(port): Output.prettyFmt("<r><i><b>{s}<r>", true)
                                 write!(
                                     writer,
-                                    "{}\x1b[3m{}{}{}",
-                                    Output::RESET,
-                                    Output::BOLD,
+                                    crate::pretty_fmt!("<r><i><b>{s}<r>", true),
                                     bstr::BStr::new(&text[..i]),
-                                    Output::RESET,
                                 )?;
                                 text = &text[i..];
                                 continue;
@@ -2292,11 +2250,9 @@ impl Display for QuickAndDirtyJavaScriptSyntaxHighlighter<'_> {
                             }
                             prev_keyword = None;
 
-                            // Zig `while (cond) { i += 1 } else { i = 1; break :jsx; }` — Zig's
-                            // while-else runs the else branch whenever the condition becomes false
-                            // (i.e. on normal loop exit, since the body has no `break`). So the
-                            // else ALWAYS fires here and the code below is dead in Zig too.
-                            // TODO(port): Zig while-else always fires here — likely upstream bug, worth verifying.
+                            // The identifier scan's result is intentionally
+                            // discarded: `i` resets to 1 below, so only the
+                            // leading `<` (or `</`) is emitted by this arm.
                             while i < text.len() && js_lexer::is_identifier_continue(text[i] as i32)
                             {
                                 i += 1;
@@ -2358,7 +2314,7 @@ pub struct EnumTagListFormatter<E: strum::VariantNames, const LIST: bool> {
 
 impl<E: strum::VariantNames, const LIST: bool> Display for EnumTagListFormatter<E, LIST> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        // PERF(port): Zig computed this at comptime as a single &'static str.
+        // PERF: could be precomputed as a single &'static str.
         let names = E::VARIANTS;
         for (i, name) in names.iter().enumerate() {
             if LIST {
@@ -2389,13 +2345,13 @@ pub fn enum_tag_list<E: strum::VariantNames, const LIST: bool>() -> EnumTagListF
 // formatIp
 // ───────────────────────────────────────────────────────────────────────────
 
-// TODO(port): `std.net.Address` — bun_core stays I/O-free; this should accept a
-// bun_sys/bun_net Address type. Logic preserved against a placeholder Display.
+// bun_core stays I/O-free, so this accepts any `Display` (callers pass their
+// own address type).
 pub fn format_ip<'a>(
     address: &impl Display,
     into: &'a mut [u8],
 ) -> Result<&'a mut [u8], crate::Error> {
-    // std.net.Address.format includes `:<port>` and square brackets (IPv6)
+    // The `Display` form includes `:<port>` and square brackets (IPv6)
     //  while Node does neither.  This uses format then strips these to bring
     //  the result into conformance with Node.
     use std::io::Write;
@@ -2403,10 +2359,10 @@ pub fn format_ip<'a>(
     write!(cursor, "{}", address).map_err(|_| crate::err!("NoSpaceLeft"))?;
     let written = cursor.position() as usize;
 
-    // PORT NOTE: reshaped for borrowck — compute (start, end) offsets against
-    // `into` instead of iteratively reborrowing a `result` slice, so the final
+    // Reshaped for borrowck — compute (start, end) offsets against `into`
+    // instead of iteratively reborrowing a `result` slice, so the final
     // returned `&mut into[start..end]` carries the caller's `'a` lifetime
-    // cleanly. Semantics match Zig's `result = result[a..b]` chain exactly.
+    // cleanly.
     let mut start = 0usize;
     let mut end = written;
 
@@ -2423,12 +2379,12 @@ pub fn format_ip<'a>(
 }
 
 // ───────────────────────────────────────────────────────────────────────────
-// count (std.fmt.count)
+// count
 // ───────────────────────────────────────────────────────────────────────────
 
 // ───────────────────────── CountingWriter / Null ─────────────────────────
-// One type subsumes Zig's `std.Io.Writer.Discarding` (null sink) and the
-// removed `std.io.countingWriter(inner)` (forwarding wrapper). Implements
+// One type subsumes a pure discarding sink and a counting forwarding
+// wrapper. Implements
 // `core::fmt::Write` so it can replace the per-crate private `CountingWriter`
 // reinventions (clap). The byte-level `bun_io::Write` counting sink stays in
 // `bun_io::DiscardingWriter` (different trait, sits above bun_core).
@@ -2443,7 +2399,7 @@ impl fmt::Write for Null {
 }
 
 /// Counts every byte written; optionally forwards to a wrapped `fmt::Write`.
-/// `inner: None` ⇒ pure discarding sink (Zig `Writer.Discarding`).
+/// `inner: None` ⇒ pure discarding sink.
 pub struct CountingWriter<'a, W: fmt::Write = Null> {
     inner: Option<&'a mut W>,
     /// Total bytes written so far (counted before forwarding).
@@ -2489,12 +2445,10 @@ impl<W: fmt::Write> fmt::Write for CountingWriter<'_, W> {
     }
 }
 
-/// Port of `std.fmt.count`: number of bytes the formatted args would produce.
+/// Number of bytes the formatted args would produce.
 ///
-/// Zig drives a `Writer.Discarding` (64-byte scratch buffer that drops writes
-/// and tallies length); Rust's `fmt::Arguments` plugs into the same shape via
-/// a `fmt::Write` impl that only sums `s.len()`. No allocation, no UTF-8
-/// validation beyond what the formatter already did.
+/// `fmt::Arguments` drives a `fmt::Write` impl that only sums `s.len()`.
+/// No allocation, no UTF-8 validation beyond what the formatter already did.
 #[inline]
 pub fn count(args: fmt::Arguments<'_>) -> usize {
     // Implementation sunk to T0 so `bun_alloc` (which sits below `bun_core`)
@@ -2510,8 +2464,6 @@ pub fn count(args: fmt::Arguments<'_>) -> usize {
 //   • fast_digit_count(u64)->u64  — Lemire 32-entry table; PANICKED on x ≥ 2³²
 //                                    (table OOB) despite its u64 signature.
 //   • count_int(i64)->usize       — /=10 loop, full i64 incl. MIN, +1 for '-'.
-// Zig has the same split (bun.fmt.fastDigitCount vs std.fmt.count("{d}",..));
-// unifying here improves on the original.
 // ───────────────────────────────────────────────────────────────────────────
 
 /// Decimal digit count of an unsigned 64-bit integer — i.e. the byte length
@@ -2671,7 +2623,7 @@ impl Display for SizeFormatter {
 
         const MAGS_SI: &[u8] = b" KMGTPEZY";
         let log2 = (usize::BITS - 1 - value.leading_zeros()) as usize;
-        // comptime math.log2(1000) == 9 (integer log2)
+        // integer log2(1000) == 9
         let magnitude = (log2 / 9).min(MAGS_SI.len() - 1);
         let new_value = value as f64 / 1000f64.powf(magnitude as f64);
         let suffix = MAGS_SI[magnitude];
@@ -2698,13 +2650,11 @@ impl Display for SizeFormatter {
     }
 }
 
-// TODO(port): Zig `size(bytes: anytype, ...)` switched on @TypeOf(bytes) for
-// f64/f32/f128 (intFromFloat) and i64/isize (intCast). Expose typed helpers.
 pub fn size(bytes: usize, opts: SizeFormatterOptions) -> SizeFormatter {
     SizeFormatter { value: bytes, opts }
 }
-/// Short-name alias of `size(.., default)` for `{B}`-style formatting
-/// (Zig: `bun.fmt.bytes`). Downstream: `bun_fmt::bytes(rss)`.
+/// Short-name alias of `size(.., default)` for `{B}`-style formatting.
+/// Downstream: `bun_fmt::bytes(rss)`.
 #[inline]
 pub fn bytes(n: usize) -> SizeFormatter {
     SizeFormatter {
@@ -2713,8 +2663,8 @@ pub fn bytes(n: usize) -> SizeFormatter {
     }
 }
 
-/// Lowercase hex encode into `out` (must be `2 * input.len()`). Port of
-/// `std.fmt.bytesToHex(.., .lower)` as used by Bun's hash printers.
+/// Lowercase hex encode into `out` (must be `2 * input.len()`). Used by
+/// Bun's hash printers.
 pub fn bytes_to_hex_lower(input: &[u8], out: &mut [u8]) -> usize {
     debug_assert!(out.len() >= input.len() * 2);
     for (i, &b) in input.iter().enumerate() {
@@ -2738,9 +2688,9 @@ pub fn size_f64(bytes: f64, opts: SizeFormatterOptions) -> SizeFormatter {
     }
 }
 pub fn size_i64(bytes: i64, opts: SizeFormatterOptions) -> SizeFormatter {
-    // PORT NOTE: Zig's `@intCast(bytes)` is unchecked in release (UB-wraps negative);
-    // clamp to 0 instead of panicking so release builds never crash on a transiently
-    // negative size, while keeping the safe-build trap via debug_assert.
+    // Clamp to 0 instead of panicking so release builds never crash on a
+    // transiently negative size, while keeping the safe-build trap via
+    // debug_assert.
     debug_assert!(bytes >= 0);
     SizeFormatter {
         value: bytes.max(0) as usize,
@@ -2752,7 +2702,7 @@ pub fn size_i64(bytes: i64, opts: SizeFormatterOptions) -> SizeFormatter {
 // Hex formatters
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Port of Zig `std.fmt`'s `{x}` / `{X}` on a `[]const u8` — prints each byte
+/// Prints each byte
 /// as two hex digits with no separator. `LOWER == true` → lowercase, else
 /// uppercase. Used by `Lockfile::MetaHashFormatter` and tmp-lockfile naming.
 pub struct HexBytes<'a, const LOWER: bool>(pub &'a [u8]);
@@ -2775,16 +2725,14 @@ impl<'a, const LOWER: bool> Display for HexBytes<'a, LOWER> {
     }
 }
 
-/// Ergonomic constructor for the lowercase `HexBytes` Display adapter — port of
-/// Zig `std.fmt.bytesToHex(.., .lower)` at format-arg call sites (`{x}` on
-/// `[]const u8`). Avoids turbofish at every caller.
+/// Ergonomic constructor for the lowercase `HexBytes` Display adapter.
+/// Avoids turbofish at every caller.
 #[inline]
 pub fn hex_lower(bytes: &[u8]) -> HexBytes<'_, true> {
     HexBytes(bytes)
 }
 
-/// Ergonomic constructor for the uppercase `HexBytes` Display adapter — port of
-/// Zig `std.fmt.bytesToHex(.., .upper)` / the `{X}` format spec on `[]const u8`.
+/// Ergonomic constructor for the uppercase `HexBytes` Display adapter.
 /// Pairs with [`hex_lower`]; avoids turbofish at every caller.
 #[inline]
 pub fn hex_upper(bytes: &[u8]) -> HexBytes<'_, false> {
@@ -2821,8 +2769,6 @@ pub const HEX_DECODE_TABLE: [u8; 256] = {
 /// Returns `None` for any other byte. Callers needing a wider int cast with `as u16/u32`
 /// or `.map(u32::from)`; callers needing `Result` use `.ok_or(..)`; callers with a
 /// pre-validated byte use `.unwrap()`.
-///
-/// Zig precedent: `std.fmt.charToDigit(c, 16)` / `bun.strings.toASCIIHexValue`.
 #[inline]
 pub const fn hex_digit_value(b: u8) -> Option<u8> {
     match b {
@@ -2852,8 +2798,6 @@ pub const fn hex_digit_value_u32(c: u32) -> Option<u8> {
 /// Returns `None` if either byte is not `[0-9a-fA-F]`. Callers adapt the
 /// error channel exactly as for [`hex_digit_value`]: `.ok_or(..)?` for
 /// `Result`, `.unwrap()` when pre-validated, `?` in `Option` context.
-///
-/// Zig precedent: inner loop of `std.fmt.hexToBytes`.
 #[inline]
 pub const fn hex_pair_value(hi: u8, lo: u8) -> Option<u8> {
     match (hex_digit_value(hi), hex_digit_value(lo)) {
@@ -2898,9 +2842,6 @@ pub const fn parse_hex4(input: &[u8]) -> Option<u16> {
 /// This is the *prefix* primitive — it never fails. Callers needing exact-N
 /// semantics (e.g. `\uHHHH`) check `digits_consumed == N` afterward; callers
 /// needing a narrower result cast (`value as u8`, `value as i32`).
-///
-/// Zig precedent: none (each module hand-rolls); analogous to a bounded
-/// `std.fmt.parseInt(u32, prefix, 16)` that also reports how much it ate.
 #[inline]
 pub fn parse_hex_prefix(input: &[u8], max_digits: usize) -> (u32, usize) {
     let mut value: u32 = 0;
@@ -2918,9 +2859,8 @@ pub fn parse_hex_prefix(input: &[u8], max_digits: usize) -> (u32, usize) {
 }
 
 /// Decode a `2 * size_of::<T>()`-char ASCII hex slice into `T` via native-endian
-/// byte reinterpretation. Mirrors Zig's `parseHexToInt` (DevServer.zig:961):
-/// `std.fmt.hexToBytes` into `[@sizeOf(T)]u8` then `@bitCast` — i.e. pairwise
-/// hex-decode then `from_ne_bytes`, **not** a big-endian numeric accumulator.
+/// byte reinterpretation — i.e. pairwise hex-decode then `from_ne_bytes`,
+/// **not** a big-endian numeric accumulator.
 /// `"0100000000000000"` → `1u64` on little-endian.
 ///
 /// Returns `None` if `slice.len() != 2 * size_of::<T>()` or any byte is not
@@ -2955,9 +2895,7 @@ pub const fn hex_char_upper(n: u8) -> u8 {
 }
 
 /// Encode a single byte as two lowercase ASCII hex digits `[hi, lo]`.
-/// Port of the open-coded `CHARSET[(b>>4)] / CHARSET[(b&0xF)]` pair found
-/// throughout the Zig sources. For contiguous full-slice output prefer
-/// [`bytes_to_hex_lower`].
+/// For contiguous full-slice output prefer [`bytes_to_hex_lower`].
 #[inline]
 pub const fn hex_byte_lower(b: u8) -> [u8; 2] {
     [
@@ -3024,10 +2962,8 @@ pub const fn hex_u16<const LOWER: bool>(v: u16) -> [u8; 4] {
     ]
 }
 
-// TODO(port): Zig parameterizes on `comptime Int: type` and computes
-// `BufType = [@bitSizeOf(Int) / 4]u8`. Rust const generics can't derive an array
-// length from a type's bit-width. Represent as a generic over u64 with explicit
-// nibble count; add per-width helpers if this shows up on a hot path.
+// Const generics can't derive an array length from a type's bit-width, so
+// this is generic over u64 with an explicit nibble count.
 pub struct HexIntFormatter<const LOWER: bool, const NIBBLES: usize> {
     pub value: u64,
 }
@@ -3040,7 +2976,6 @@ impl<const LOWER: bool, const NIBBLES: usize> HexIntFormatter<LOWER, NIBBLES> {
             &UPPER_HEX_TABLE
         };
         let mut buf = [0u8; NIBBLES];
-        // PERF(port): Zig used `inline for`; plain loop here.
         for (i, c) in buf.iter_mut().enumerate() {
             // value relative to the current nibble
             let shift = ((NIBBLES - i - 1) * 4) as u32;
@@ -3073,8 +3008,7 @@ pub fn hex_int_upper<const NIBBLES: usize>(value: u64) -> HexIntFormatter<false,
 
 /// `{:0N x}` / `{:0N X}` — zero-padded fixed-width hex of a u64 into a stack
 /// buffer. Thin alias over [`HexIntFormatter::get_out_buf`] for callers that
-/// want bytes, not a `Display` adapter. Port of Zig `bun.fmt.hexIntLower` /
-/// `hexIntUpper` when used with `bufPrint`.
+/// want bytes, not a `Display` adapter.
 #[inline]
 pub fn u64_hex_fixed<const LOWER: bool, const N: usize>(v: u64) -> [u8; N] {
     HexIntFormatter::<LOWER, N>::get_out_buf(v)
@@ -3082,8 +3016,7 @@ pub fn u64_hex_fixed<const LOWER: bool, const N: usize>(v: u64) -> [u8; N] {
 
 /// Format a 6-byte MAC address as `xx:xx:xx:xx:xx:xx` (lowercase hex,
 /// colon-separated). Returns a fixed 17-byte ASCII buffer; borrow as `&[u8]`
-/// for `ZigString::init`. Port of the inline `std.fmt.bufPrint(.., "{x:0>2}:..")`
-/// pattern duplicated at `node_os.zig:686` and `:800`.
+/// for `ZigString::init`.
 #[inline]
 pub fn mac_address_lower(mac: [u8; 6]) -> [u8; 17] {
     let mut out = [b':'; 17];
@@ -3097,8 +3030,7 @@ pub fn mac_address_lower(mac: [u8; 6]) -> [u8; 17] {
 }
 
 /// `{:0N}` — zero-padded fixed-width decimal of a `u64` into `[u8; N]`.
-/// Decimal sibling of [`u64_hex_fixed`] / [`hex_byte_upper`]. Port of Zig
-/// `std.fmt.printInt(.., .{.width=N, .fill='0'})`. Caller guarantees
+/// Decimal sibling of [`u64_hex_fixed`] / [`hex_byte_upper`]. Caller guarantees
 /// `val < 10^N`; excess high digits are silently dropped (debug-asserted).
 #[inline(always)]
 pub fn itoa_padded<const N: usize>(mut val: u64) -> [u8; N] {
@@ -3148,9 +3080,8 @@ impl<const PRECISION: usize> Display for TrimmedPrecisionFormatter<PRECISION> {
         let rem = self.num - whole;
         if rem != 0.0 {
             // buf size = "0." + PRECISION digits
-            // PORT NOTE: Zig used `[2 + precision]u8` stack array; Rust const-generic array
-            // length arithmetic is unstable, so use a small fixed upper bound and
-            // const-assert it suffices (matches Zig's compile-time sizing guarantee).
+            // Const-generic array length arithmetic is unstable, so use a small
+            // fixed upper bound and const-assert it suffices.
             const {
                 assert!(
                     PRECISION + 3 <= 32,
@@ -3193,7 +3124,7 @@ use crate::time::{
     NS_PER_DAY, NS_PER_HOUR, NS_PER_MIN, NS_PER_MS, NS_PER_S, NS_PER_US, NS_PER_WEEK,
 };
 
-/// This is copied from std.fmt.formatDuration, except it will only print one decimal instead of three
+/// Format a duration, printing one decimal place instead of three.
 fn format_duration_one_decimal(
     data: FormatDurationData,
     writer: &mut impl fmt::Write,
@@ -3222,7 +3153,6 @@ fn format_duration_one_decimal(
     }
 
     let mut ns_remaining = data.ns;
-    // PERF(port): Zig used `inline for` over a tuple of structs.
     const COARSE: [(u64, u8); 5] = [
         (365 * NS_PER_DAY, b'y'),
         (NS_PER_WEEK, b'w'),
@@ -3296,8 +3226,7 @@ pub enum ConnTimeoutKind {
 /// Render the canonical SQL connection-timeout error message.
 ///
 /// `ms` is converted to nanoseconds with a saturating multiply and rendered
-/// through [`fmt_duration_one_decimal`] (matching the Zig backends' inline
-/// `bun.fmt.fmtDurationOneDecimal(ms * std.time.ns_per_ms)`). `suffix` is
+/// through [`fmt_duration_one_decimal`]. `suffix` is
 /// appended verbatim — used for the per-status `(sent startup message…)` /
 /// `(during authentication)` tails.
 pub fn fmt_conn_timeout(kind: ConnTimeoutKind, ms: u32, suffix: &str) -> impl Display + '_ {
@@ -3327,7 +3256,6 @@ pub fn fmt_slice<'a, T: AsRef<[u8]>>(data: &'a [T], delim: &'static str) -> Form
 
 pub struct FormatSlice<'a, T: AsRef<[u8]>> {
     pub slice: &'a [T],
-    // PERF(port): Zig `delim` was a comptime []const u8 — runtime here.
     pub delim: &'static str,
 }
 
@@ -3360,7 +3288,6 @@ pub struct FormatDouble {
     pub number: f64,
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // `&mut [u8; 124]` is ABI-identical to the C `char *` argument (thin
     // non-null pointer to 124 writable bytes); the type encodes WTF__dtoa's
@@ -3393,17 +3320,16 @@ impl Display for FormatDouble {
 }
 
 /// Downstream alias — several callers (ConsoleObject) refer to this as
-/// `bun_core::fmt::DoubleFormatter` (matching the Zig "formatter" naming
-/// convention rather than the `Format*` struct convention used here).
+/// `bun_core::fmt::DoubleFormatter` (the "formatter" naming convention
+/// rather than the `Format*` struct convention used here).
 pub type DoubleFormatter = FormatDouble;
 
 // ─── Integer → ASCII ───────────────────────────────────────────────────────
 // One path for every base-10 integer write. Backed by the `itoa` crate (LUT
 // 2-digits-at-a-time — same code serde_json/cssparser ship), already in the
-// workspace link graph. Replaces the three competing impls the port grew:
+// workspace link graph. Replaces three competing impls:
 // `core::fmt`-via-SliceCursor (slow + silent-truncate footgun), the hand-
 // rolled `itoa_u64` reverse-fill, and tcc_sys's private `itoa::Buffer` use.
-// Zig has exactly one path (`std.fmt.printInt`); this restores that parity.
 
 /// Stack scratch for [`itoa`]. 40 bytes — fits `i128::MIN`. `::new()` is a
 /// const no-op (uninit array), so declare it inline at the call site.
@@ -3435,7 +3361,7 @@ pub const fn pow10_exp_1e4_to_1e9(val: u64) -> Option<u8> {
     }
 }
 
-/// Port of `std.fmt.printInt(buf, value, 10, .lower, .{})`: format `value`
+/// Format `value`
 /// into `buf` as base-10 ASCII and return the number of bytes written.
 /// Panics if `buf` is too small — callers size the buffer by the type's max
 /// digit count. Use [`itoa`] directly when you can own a fresh [`ItoaBuf`];
@@ -3448,8 +3374,7 @@ pub fn print_int<T: ::itoa::Integer>(buf: &mut [u8], value: T) -> usize {
     s.len()
 }
 
-/// [`print_int`] returning the written sub-slice of `buf` — the moral
-/// equivalent of Zig's `std.fmt.bufPrint(&buf, "{d}", .{v}) catch unreachable`.
+/// [`print_int`] returning the written sub-slice of `buf`.
 /// Use this when the caller wants the bytes; use [`print_int`] directly when
 /// writing at an offset and only the byte-count is needed.
 #[inline]
@@ -3461,8 +3386,7 @@ pub fn int_as_bytes<T: ::itoa::Integer>(buf: &mut [u8], value: T) -> &[u8] {
 /// NUL-terminated decimal `u64` → ASCII into a caller-owned scratch buffer,
 /// returning a [`CStr`] borrowing the head of `buf`.
 ///
-/// This is the Rust analogue of Zig's `std.fmt.bufPrintZ(&buf, "{d}", .{n})`
-/// — used when handing an integer to a C API that wants a `*const c_char`
+/// Used when handing an integer to a C API that wants a `*const c_char`
 /// service/port string (e.g. `getaddrinfo`, `ares_getaddrinfo`). 21 bytes
 /// covers `u64::MAX` (20 digits) + NUL; `u16`/`u32` callers widen via `as u64`.
 #[inline]
@@ -3476,8 +3400,8 @@ pub fn itoa_z(buf: &mut [u8; 21], n: u64) -> &core::ffi::CStr {
     unsafe { core::ffi::CStr::from_bytes_with_nul_unchecked(&buf[..=s.len()]) }
 }
 
-/// Byte length of `n` formatted with the default `{}` Display — moral
-/// equivalent of Zig's `std.fmt.count("{d}", .{n})`. Used by ConsoleObject
+/// Byte length of `n` formatted with the default `{}` Display. Used by
+/// ConsoleObject
 /// width tracking for `%f` substitutions.
 #[inline]
 pub fn count_float(n: f64) -> usize {
@@ -3540,7 +3464,7 @@ fn escape_powershell_impl(str: &[u8], writer: &mut impl fmt::Write) -> fmt::Resu
     write_bytes(writer, remain)
 }
 
-// js_bindings (fmtString for highlighter.test.ts) lives in src/jsc/fmt_jsc.zig
+// js_bindings (fmtString for highlighter.test.ts) lives in src/jsc/fmt_jsc.rs
 // alongside fmt_jsc.bind.ts; bun_core/ stays JSC-free.
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -3703,7 +3627,7 @@ fn truncated_hash32_impl(int: u64, writer: &mut impl fmt::Write) -> fmt::Result
 }
 
 /// Const-fn core of [`truncated_hash32`] / [`TruncatedHash32`]: the 8-byte
-/// base32-ish encoding (native-endian, matches Zig `@bitCast([8]u8, int)`).
+/// base32-ish encoding (native-endian byte reinterpretation).
 /// Exposed so const contexts (e.g. `js_parser::generated_symbol_name!`) can
 /// share the single alphabet table instead of copy-pasting it.
 pub const fn truncated_hash32_bytes(int: u64) -> [u8; 8] {
@@ -3721,8 +3645,8 @@ pub const fn truncated_hash32_bytes(int: u64) -> [u8; 8] {
     ]
 }
 
-/// Zero-validation `&[u8] -> impl Display` adapter — alias of [`raw`] named to
-/// read like Zig's `{s}` specifier at call sites (`bun_fmt::s(name)`).
+/// Zero-validation `&[u8] -> impl Display` adapter — short alias of [`raw`]
+/// for terse call sites (`bun_fmt::s(name)`).
 #[inline(always)]
 pub const fn s(bytes: &[u8]) -> Raw<'_> {
     Raw(bytes)
@@ -3734,7 +3658,7 @@ pub const fn s(bytes: &[u8]) -> Raw<'_> {
 
 #[inline]
 fn write_bytes(w: &mut impl fmt::Write, bytes: &[u8]) -> fmt::Result {
-    // SAFETY: see `s()` above — Zig's `{s}` path, callers feed ASCII/utf8.
+    // SAFETY: see `s()` above — callers feed valid ASCII/UTF-8.
     w.write_str(unsafe { core::str::from_utf8_unchecked(bytes) })
 }
 
@@ -3748,17 +3672,15 @@ fn splat_byte_all(w: &mut impl fmt::Write, byte: u8, count: usize) -> fmt::Resul
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// std.json.encodeJsonString — single canonical port.
-// Zig: vendor/zig/lib/std/json/Stringify.zig:670 (encodeJsonString →
-// encodeJsonStringChars → outputSpecialEscape). Every Rust copy that was
-// hand-ported from a Zig `std.json.fmt(...)` call funnels through here.
+// encode_json_string — single canonical impl.
+// Every duplicated copy of this JSON-string escaping logic funnels through
+// here.
 // ════════════════════════════════════════════════════════════════════════════
 
-/// Port of Zig stdlib `std.json.encodeJsonStringChars` with default options
-/// (`escape_unicode = false`): writes the escaped body of a JSON string
-/// **without** surrounding quotes.
+/// Writes the escaped body of a JSON string **without** surrounding quotes
+/// (`escape_unicode = false` semantics).
 ///
-/// Escape set (matches `outputSpecialEscape` exactly):
+/// Escape set:
 ///   - `\"` `\\` `\b` `\f` `\n` `\r` `\t`
 ///   - other `0x00..=0x1F` → `\u00XX` (lowercase hex)
 ///   - `0x20..=0xFF` → emitted verbatim in run-batched `write_str` calls
@@ -3846,13 +3768,10 @@ pub fn encode_json_string_chars_latin1(w: &mut impl fmt::Write, s: &[u8]) -> fmt
     Ok(())
 }
 
-/// Port of Zig stdlib `std.json.encodeJsonString`: surrounding `"` quotes
-/// around [`encode_json_string_chars`].
+/// Surrounding `"` quotes around [`encode_json_string_chars`].
 #[inline]
 pub fn encode_json_string(w: &mut impl fmt::Write, s: &[u8]) -> fmt::Result {
     w.write_char('"')?;
     encode_json_string_chars(w, s)?;
     w.write_char('"')
 }
-
-// ported from: src/bun_core/fmt.zig
diff --git a/src/bun_core/heap.rs b/src/bun_core/heap.rs
index 304bd155a79..ffc41a79a3b 100644
--- a/src/bun_core/heap.rs
+++ b/src/bun_core/heap.rs
@@ -1,15 +1,13 @@
 //! Centralized heap-pointer round-trip helpers.
 //!
-//! Zig's `bun.TrivialNew(@This())` / `bun.destroy(this)` / `bun.new(T, init)`
-//! pattern was ported file-by-file as open-coded `Box::into_raw(Box::new(..))`
-//! / `drop(Box::from_raw(..))` pairs (~1.8k occurrences). Per
-//! `docs/RUST_PATTERNS.md` §5, every one of those is an unchecked ownership
-//! transfer with the invariant restated in a `// SAFETY:` comment at every
-//! site.
+//! Open-coded `Box::into_raw(Box::new(..))` / `drop(Box::from_raw(..))` pairs
+//! (~1.8k occurrences) are unchecked ownership transfers with the invariant
+//! restated in a `// SAFETY:` comment at every site (per
+//! `docs/RUST_PATTERNS.md` §5).
 //!
 //! These are **thin aliases** — they do not reduce per-site proof
 //! obligations (each `take`/`destroy` is still its own `unsafe { }` block).
-//! They exist for vocabulary consistency with the Zig spelling and as the
+//! They exist for vocabulary consistency and as the
 //! shared primitive *inside* the typed shims; they are NOT the safety
 //! deliverable. The deliverable is the typed `Box<T>`-taking entry points
 //! that own BOTH halves of the round-trip:
@@ -27,9 +25,8 @@
 //! All four are `#[inline(always)]` no-ops — identical machine code to the
 //! open-coded `Box::into_raw`/`from_raw`.
 
-/// Heap-allocate `value` and return the raw pointer (Zig: `bun.new(T, init)` /
-/// `bun.TrivialNew`). Ownership transfers to the caller; pair with [`destroy`]
-/// or [`take`].
+/// Heap-allocate `value` and return the raw pointer.
+/// Ownership transfers to the caller; pair with [`destroy`] or [`take`].
 #[inline(always)]
 pub fn alloc<T>(value: T) -> *mut T {
     Box::into_raw(Box::new(value))
@@ -85,8 +82,7 @@ pub unsafe fn take<T: ?Sized>(ptr: *mut T) -> Box<T> {
     unsafe { Box::from_raw(ptr) }
 }
 
-/// Drop a heap allocation previously produced by [`alloc`] / [`leak`]
-/// (Zig: `bun.destroy(this)` / `bun.TrivialDeinit`).
+/// Drop a heap allocation previously produced by [`alloc`] / [`leak`].
 ///
 /// # Safety
 /// Same as [`take`].
diff --git a/src/bun_core/hint.rs b/src/bun_core/hint.rs
index c299887c813..8ec6e309541 100644
--- a/src/bun_core/hint.rs
+++ b/src/bun_core/hint.rs
@@ -1,7 +1,6 @@
-//! Branch-prediction hints — Rust port of Zig's `@branchHint`.
+//! Branch-prediction hints.
 
-/// Mark the surrounding branch as cold/unlikely. Port of Zig
-/// `@branchHint(.unlikely)` / `@branchHint(.cold)` (docs/PORTING.md:211).
+/// Mark the surrounding branch as cold/unlikely.
 ///
 /// Calling a `#[cold]` callee makes LLVM treat the *call site's* basic block
 /// as cold and lay it out off the hot path. `#[inline(never)]` is required:
diff --git a/src/bun_core/lib.rs b/src/bun_core/lib.rs
index 3f554c8f547..4434af71e54 100644
--- a/src/bun_core/lib.rs
+++ b/src/bun_core/lib.rs
@@ -23,9 +23,7 @@ pub mod util;
 pub use atomic_cell::{Atom, AtomicCell, ThreadCell};
 
 /// Shared state-machine tag for the streaming (de)compressors in
-/// `bun_brotli` / `bun_zlib` / `bun_zstd`. Mirrors the identical
-/// `pub const State = enum { Uninitialized, Inflating, End, Error }`
-/// nested in each Zig reader/compressor struct.
+/// `bun_brotli` / `bun_zlib` / `bun_zstd`.
 pub mod compress {
     #[derive(Clone, Copy, PartialEq, Eq)]
     pub enum State {
@@ -80,8 +78,8 @@ pub use external_shared::{
 pub mod bounded_array;
 pub use bounded_array::{BoundedArray, BoundedArrayAligned};
 
-/// Bit-cast between fn-pointer types. Replaces Zig `@ptrCast` on a function
-/// pointer when erasing only the *pointee type* of one or more thin-pointer
+/// Bit-cast between fn-pointer types — for erasing only the *pointee type*
+/// of one or more thin-pointer
 /// parameters (e.g. `extern "C" fn(*mut Ctx, …)` ↔ `extern "C" fn(*mut c_void,
 /// …)`). Const-generic `transmute` rejects fn types; an as-cast can't change
 /// arity. This stays one audited helper and rejects non-pointer-sized
@@ -105,8 +103,8 @@ pub const unsafe fn cast_fn_ptr<F: Copy, G: Copy>(f: F) -> G {
         assert!(core::mem::align_of::<G>() == core::mem::align_of::<fn()>());
     }
     // SAFETY: caller contract — `F` and `G` are ABI-identical fn pointers.
-    // `read` of a pointer-sized `Copy` value through a same-size cast is the
-    // bitwise reinterpretation `@ptrCast` performs.
+    // `read` of a pointer-sized `Copy` value through a same-size, same-align
+    // cast is a defined bitwise reinterpretation of the fn pointer.
     unsafe { (&raw const f).cast::<G>().read() }
 }
 
@@ -215,7 +213,7 @@ unsafe impl<T: Sync> Send for RawSlice<T> {}
 // SAFETY: same reasoning as the `Send` impl above — `&[T]: Sync ⇔ T: Sync`.
 unsafe impl<T: Sync> Sync for RawSlice<T> {}
 
-/// Port of Zig's `std.os.environ` global (`[][*:0]u8`). On Windows the
+/// Process-global envp slice. On Windows the
 /// startup path `bun_sys::windows::env::convert_env_to_wtf8` overwrites this
 /// with a WTF-8-encoded envp slice; `getenvZ` then reads it via
 /// `os::environ()`. POSIX builds leave it empty and use libc's `environ`.
@@ -224,14 +222,12 @@ pub mod os {
     use core::ffi::c_char;
 
     // Stored as raw (ptr, len) — NOT `&'static mut [_]` — so `environ()` (which
-    // hands out a shared `&[_]`) never aliases a live `&mut`. Zig's
-    // `std.os.environ` is a plain slice global with no exclusivity guarantee;
-    // mirroring that with `&'static mut` would be UB the moment a reader
+    // hands out a shared `&[_]`) never aliases a live `&mut`. A `&'static mut`
+    // global would be UB the moment a reader
     // borrows while a writer holds the swapped-out `&mut`.
     static mut ENVIRON: (*mut *mut c_char, usize) = (core::ptr::null_mut(), 0);
 
-    /// Swap in a new envp slice; returns the previous (ptr, len) pair (Zig:
-    /// `orig_environ = std.os.environ; std.os.environ = new`).
+    /// Swap in a new envp slice; returns the previous (ptr, len) pair.
     /// SAFETY: single-threaded startup only.
     pub unsafe fn take_environ() -> (*mut *mut c_char, usize) {
         // `&raw mut` (no intermediate `&mut`) — `static_mut_refs` is hard-denied
@@ -245,7 +241,7 @@ pub mod os {
             core::ptr::write(&raw mut ENVIRON, (ptr, len));
         }
     }
-    /// Borrowed view of the current envp slice (read side of `std.os.environ`).
+    /// Borrowed view of the current envp slice (read side of the `ENVIRON` global).
     /// SAFETY: caller must not race with `set_environ`.
     pub unsafe fn environ() -> &'static [*mut c_char] {
         unsafe {
@@ -272,7 +268,7 @@ pub mod path_sep {
 
     // ─── u8 const fns (kept const for match-guard / const-eval callers) ─────
 
-    /// Zig: `bun.path.isSepAny` — `/` **or** `\` on every target.
+    /// `/` **or** `\` on every target.
     /// Use for parsing user-supplied / cross-platform path strings (tsconfig,
     /// archive entries, Windows drive prefixes).
     #[inline(always)]
@@ -314,9 +310,9 @@ pub mod path_sep {
         }
     }
 
-    /// Host-OS-native absolute-path predicate (Zig: `std.fs.path.isAbsolute`).
+    /// Host-OS-native absolute-path predicate.
     /// POSIX: leading `/`. Windows: leading `/` or `\`, or 3-byte `X:/`|`X:\`
-    /// — faithful to Zig std: **no** alphabetic gate on the drive byte, and a
+    /// — **no** alphabetic gate on the drive byte, and a
     /// bare `X:` with no trailing separator is **not** absolute.
     ///
     /// Sunk from `bun_paths::is_absolute` so tier-0 (`util::which`) and
@@ -341,8 +337,8 @@ pub mod path_sep {
 }
 
 // ─── libm shims ───────────────────────────────────────────────────────────────
-// Canonical extern for libm's `powf`/`pow` (Zig: `bun.zig` `pub extern "c" fn
-// powf`). Hot CSS color-space conversion paths (gam_srgb, lab, prophoto) call
+// Canonical extern for libm's `powf`/`pow`.
+// Hot CSS color-space conversion paths (gam_srgb, lab, prophoto) call
 // the safe wrapper below; keep `#[inline]` so cross-crate use stays a direct
 // libm call.
 unsafe extern "C" {
@@ -365,9 +361,7 @@ pub mod vec {
     ///
     /// Equivalent to `for i in 0..n { v.push(f(i)) }` but reserves once and
     /// writes through `spare_capacity_mut()` so no per-element capacity check
-    /// or length bump occurs in the hot loop. Replaces the Zig-ported
-    /// `reserve; ptr::write…; set_len` blocks where the fill is a pure
-    /// per-index function (constant, default, or `i`-derived).
+    /// or length bump occurs in the hot loop.
     ///
     /// Panic-safety: if `f` panics at index `k`, `v.len()` is left at its
     /// original value plus `k` — every exposed element is initialized, and the
@@ -395,8 +389,7 @@ pub mod vec {
         unsafe { v.set_len(prev + n) };
     }
 
-    /// Append `n` copies of `value` to `v`. Zig: `std.ArrayList.appendNTimes` —
-    /// `ensureUnusedCapacity(n); @memset(unusedCapacitySlice()[0..n], value); len += n`.
+    /// Append `n` copies of `value` to `v`.
     ///
     /// Unlike `v.extend(repeat_n(value, n))` or a `for _ { v.push(value) }` loop,
     /// this reserves once and fills via `[MaybeUninit<T>]::fill` (lowers to
@@ -416,9 +409,7 @@ pub mod vec {
     /// Extend `v` by `n` `T::default()` elements and return a mutable slice
     /// of the newly-appended tail (`&mut v[prev_len .. prev_len + n]`).
     ///
-    /// Replaces the Zig-ported `reserve(n); set_len(len+n); &mut v[len..]`
-    /// pattern (S022) where the tail is immediately overwritten by a clone/
-    /// fill loop — the default-fill keeps every exposed `T` valid even if the
+    /// The default-fill keeps every exposed `T` valid even if the
     /// caller bails partway through writing.
     #[inline]
     pub fn grow_default<T: Default>(v: &mut Vec<T>, n: usize) -> &mut [T] {
@@ -428,7 +419,7 @@ pub mod vec {
     }
 
     /// Reserve `additional`, advance `len` by `additional`, and return the
-    /// newly-exposed (uninitialized) tail. Zig `ArrayList.addManyAsSlice`.
+    /// newly-exposed (uninitialized) tail.
     /// Generic free-fn form of `bun_collections::VecExt::writable_slice` so
     /// `bun_core::string` can call it without a `bun_collections` edge.
     ///
@@ -445,8 +436,7 @@ pub mod vec {
     }
 
     /// As [`writable_slice`] but skips `reserve`; caller must guarantee
-    /// `len + additional <= capacity` (debug-asserted). Zig:
-    /// `ArrayList.addManyAsSliceAssumeCapacity`.
+    /// `len + additional <= capacity` (debug-asserted).
     ///
     /// # Safety
     /// `v.len() + additional <= v.capacity()`, and the returned slice must be
@@ -469,9 +459,7 @@ pub mod vec {
     ///
     /// `n == 0` is a no-op; `n >= len` degenerates to `clear()` (capacity
     /// retained). All current callers are `Vec<u8>` ring/line buffers
-    /// shifting a consumed prefix down after a partial write/parse — the Zig
-    /// port open-coded `std.mem.copyForwards` + `items.len -= n` at every
-    /// site.
+    /// shifting a consumed prefix down after a partial write/parse.
     #[inline]
     pub fn drain_front<T: Copy, A: core::alloc::Allocator>(v: &mut Vec<T, A>, n: usize) {
         if n == 0 {
@@ -486,10 +474,9 @@ pub mod vec {
         v.truncate(len - n);
     }
 
-    // ── Zig `ArrayList(u8).unusedCapacitySlice()` family ──────────────────
-    // The Zig stdlib has ONE helper and ~30 call sites; the Rust port had
-    // grown 11 hand-rolled `spare_capacity_mut().as_mut_ptr().cast::<u8>()`
-    // + `set_len(len+n)` copies because `spare_capacity_mut` returns
+    // ── Spare-capacity fill helpers ────────────────────────────────────────
+    // Consolidates 11 hand-rolled `spare_capacity_mut().as_mut_ptr().cast::<u8>()`
+    // + `set_len(len+n)` copies: `spare_capacity_mut` returns
     // `MaybeUninit<u8>` and every C-ABI fill site (read/recv/pread, simdutf,
     // zlib, zstd, libdeflate, base64) needs `*mut u8` / `&mut [u8]`.
 
@@ -526,9 +513,8 @@ pub mod vec {
         unsafe { spare_bytes_mut(v) }
     }
 
-    /// View the **entire** allocation `v[0..capacity]` as `&mut [u8]` (Zig:
-    /// `ArrayList.allocatedSlice()`). For the spare-only `[len..capacity]`
-    /// view use [`spare_bytes_mut`].
+    /// View the **entire** allocation `v[0..capacity]` as `&mut [u8]`.
+    /// For the spare-only `[len..capacity]` view use [`spare_bytes_mut`].
     ///
     /// # Safety
     /// Bytes in `[len, capacity)` are uninitialized; treat that tail as
@@ -628,6 +614,9 @@ bun_dispatch::link_interface! {
     pub ErrnoNames[Sys] {
         fn name(errno: i32) -> Option<&'static str>;
         fn max_dense() -> u32;
+        // Raw Win32 `GetLastError()` code → `SystemErrno` tag name.
+        // Always `None` on non-Windows.
+        fn win32_name(code: u32) -> Option<&'static str>;
     }
 }
 
@@ -642,7 +631,7 @@ impl ErrnoNames {
 /// so `$crate::pretty_fmt!` resolves from the wrapper macros in `output.rs`.
 pub use bun_core_macros::{EnumTag, pretty_fmt};
 
-/// Stand-in for Zig's `@import("build_options")`. Values are written at
+/// Build-time configuration values. Written at
 /// configure time by `scripts/build/buildOptionsRs.ts` from the resolved
 /// `Config` and `include!()`'d here; `build.rs` exports `BUN_CODEGEN_DIR`
 /// and fingerprints the file so a sha/version change recompiles this crate.
@@ -669,7 +658,7 @@ pub use util::*;
 
 // ── intrusive-container parent recovery ───────────────────────────────────
 //
-// Port of Zig's parent-from-field intrinsic. Intrusive data structures (task
+// Intrusive data structures (task
 // queues, timer heaps, linked lists) hand callbacks a `*mut Field` and expect
 // the callee to walk back to the owning `*mut Parent`. Earlier ports open-coded
 // this at ~150 sites as `ptr.cast::<u8>().sub(offset_of!(P, f)).cast::<P>()`; the
@@ -748,7 +737,7 @@ macro_rules! from_field_ptr {
     };
 }
 
-/// Stamp `@fieldParentPtr`-style back-reference accessors on a child type that
+/// Stamp container-of-style back-reference accessors on a child type that
 /// is **only ever constructed as the `$field` field of `$Parent`**.
 ///
 /// Five forms (mix-and-match is not supported; pick the one matching the call
@@ -855,9 +844,8 @@ macro_rules! impl_field_parent {
 // ─── IntrusiveField<F> ──────────────────────────────────────────────────────
 
 /// Declares that `Self` embeds exactly one intrusive `F` field at byte
-/// [`OFFSET`](IntrusiveField::OFFSET). This is the single Rust analogue of
-/// Zig's `@fieldParentPtr` builtin: every per-module `const X_OFFSET: usize`
-/// trait the port grew (`TASK_OFFSET`, `MIXIN_OFFSET`,
+/// [`OFFSET`](IntrusiveField::OFFSET). Every per-module `const X_OFFSET: usize`
+/// trait (`TASK_OFFSET`, `MIXIN_OFFSET`,
 /// `CHANNEL_OFFSET`, `LazyBool<_, const OFFSET>`, `from_task`, …) is the same
 /// `(Parent, Field, OFFSET)` triple plus [`container_of`] arithmetic — this
 /// trait is exactly that triple, with both directions provided.
@@ -878,7 +866,7 @@ pub unsafe trait IntrusiveField<F>: Sized {
         unsafe { &mut *core::ptr::from_mut(self).byte_add(Self::OFFSET).cast::<F>() }
     }
 
-    /// `*mut Self` → `*mut self.<field>` (Zig: `&self.<field>` from raw `*Self`).
+    /// `*mut Self` → `*mut self.<field>`.
     ///
     /// # Safety
     /// `this` must point at (or one-past) a valid `Self` allocation so the
@@ -889,8 +877,8 @@ pub unsafe trait IntrusiveField<F>: Sized {
         unsafe { this.byte_add(Self::OFFSET).cast::<F>() }
     }
 
-    /// Recover `*mut Self` from a pointer to its embedded `F` (Zig:
-    /// `@fieldParentPtr`). Thin wrapper over [`container_of`].
+    /// Recover `*mut Self` from a pointer to its embedded `F`. Thin
+    /// wrapper over [`container_of`].
     ///
     /// # Safety
     /// `field` must point at the `<field>` of a live `Self` with
@@ -928,8 +916,8 @@ macro_rules! intrusive_field {
 /// `bun_core::OOM` per PORTING.md type map (`OOM!T` → `Result<T, OOM>`).
 pub type OOM = AllocError;
 
-/// `bun.JSError` — the canonical JS error union (`error{JSError, OutOfMemory, JSTerminated}`
-/// in Zig). Tier-0 so every layer of the runtime can name it directly; `bun_jsc` re-exports
+/// `bun.JSError` — the canonical JS error union. Tier-0 so every layer of
+/// the runtime can name it directly; `bun_jsc` re-exports
 /// it as `bun_jsc::JsError` and `bun_event_loop` re-exports it as `ErasedJsError` for
 /// historical call sites.
 ///
@@ -951,34 +939,31 @@ bun_alloc::oom_from_alloc!(JsError);
 
 impl From<crate::Error> for JsError {
     fn from(_: crate::Error) -> Self {
-        // PORT NOTE: Zig coerces arbitrary `anyerror` into the JS error union by
-        // throwing a generic Error; the throw happens at the call site. Mapping
-        // to `Thrown` here lets `?` propagate while the actual throw is handled
-        // by the host-fn wrapper.
+        // Mapping to `Thrown` here lets `?` propagate while the actual throw
+        // is handled by the host-fn wrapper.
         JsError::Thrown
     }
 }
 
 impl From<JsError> for crate::Error {
     /// Widen a `bun.JSError` value back into the `anyerror` newtype. Preserves
-    /// the exact Zig tag (`@errorName`) so call sites that round-trip through
+    /// the exact tag name so call sites that round-trip through
     /// `bun_core::Error` (e.g. the `bun_bundler::dispatch::DevServerVTable`
     /// boundary) keep `error.OutOfMemory` distinguishable from `error.JSError`.
     #[inline]
     fn from(e: JsError) -> Self {
         match e {
             JsError::OutOfMemory => crate::err!("OutOfMemory"),
-            // `Terminated` is a Rust-port addition (worker shutdown); it has no
-            // distinct Zig `error.` tag, so collapse into `JSError` like every
-            // other thrown JS exception.
+            // `Terminated` (worker shutdown) has no distinct `error.` tag, so
+            // collapse into `JSError` like every other thrown JS exception.
             JsError::Thrown | JsError::Terminated => crate::err!("JSError"),
         }
     }
 }
 
-/// Zig `bun.concat(T, dest, &.{ a, b, ... })` — write `parts` consecutively
+/// Write `parts` consecutively
 /// into `dest` and return the written prefix as a mutable slice. Panics if
-/// `sum(parts.len()) > dest.len()` (matches Zig `@memcpy` length assert).
+/// `sum(parts.len()) > dest.len()`.
 #[inline]
 pub fn concat_into<'b, T: Copy>(dest: &'b mut [T], parts: &[&[T]]) -> &'b mut [T] {
     let mut off = 0;
@@ -989,8 +974,7 @@ pub fn concat_into<'b, T: Copy>(dest: &'b mut [T], parts: &[&[T]]) -> &'b mut [T
     &mut dest[..off]
 }
 
-/// Zig `std.mem.concat(allocator, T, &.{...})` / `bun.strings.concat` — allocate
-/// a fresh `Box<[T]>` holding all `parts` joined. No zero-init: `extend_from_slice`
+/// Allocate a fresh `Box<[T]>` holding all `parts` joined. No zero-init: `extend_from_slice`
 /// is `memcpy`-specialized for `T: Copy`, so no `Default` bound is required.
 #[inline]
 pub fn concat_boxed<T: Copy>(parts: &[&[T]]) -> Box<[T]> {
@@ -1009,13 +993,12 @@ pub fn concat<'b>(buf: &'b mut [u8], parts: &[&[u8]]) -> &'b [u8] {
     concat_into(buf, parts)
 }
 
-/// Zig `union(enum)` field projection — `data.file`, `chunk.content.javascript`.
+/// Tagged-union field projection — `data.file`, `chunk.content.javascript`.
 ///
-/// In safety-checked Zig builds, reading a tagged-union field on the wrong
-/// active variant panics at runtime. The Rust port hand-wrote ~20 identical
+/// Consolidates ~20 identical
 /// `match self { Self::V(x) => x, _ => unreachable!() }` accessors across
-/// `jsc` / `bundler` / `ini` / `resolver` / `ast` / `install`; this macro is
-/// the 1:1 analogue. Invoke it *inside* an `impl Enum { ... }` block:
+/// `jsc` / `bundler` / `ini` / `resolver` / `ast` / `install` into one
+/// macro. Invoke it *inside* an `impl Enum { ... }` block:
 ///
 /// ```ignore
 /// impl Data {
@@ -1075,7 +1058,7 @@ macro_rules! enum_unwrap {
     };
 }
 
-/// Zig: `bun.handleOom(expr)` — unwrap a `Result`, calling `outOfMemory()` on
+/// Unwrap a `Result`, calling `outOfMemory()` on
 /// `Err`. The full multi-arm version (which narrows mixed error sets) lives in
 /// `bun_crash_handler::handle_oom`; that crate sits *above* `bun_core` in the
 /// dep graph, so this tier-0 alias is the OOM-only arm — sufficient for the
@@ -1091,12 +1074,11 @@ pub fn handle_oom<T, E>(r: core::result::Result<T, E>) -> T {
 }
 
 /// Extension-method form of [`handle_oom`]: `.unwrap_or_oom()` on any
-/// `Result<T, E>`. Zig: `expr catch bun.outOfMemory()` — the *loose* idiom
+/// `Result<T, E>`. The *loose* idiom
 /// that panics on **any** `Err`, not just OOM-only error sets. For the
-/// Zig-faithful narrowing version (`bun.handleOom` with comptime error-set
-/// reflection) see `bun_crash_handler::HandleOom`.
+/// narrowing version see `bun_crash_handler::HandleOom`.
 ///
-/// PORT NOTE: this is intentionally a blanket `impl<T, E>` — it matches the
+/// This is intentionally a blanket `impl<T, E>` — it matches the
 /// existing `bun_core::handle_oom` free fn and the two pre-existing local
 /// blanket impls in `run_command.rs` / `valkey.rs`. Callers that want a strict
 /// `error{OutOfMemory}`-only whitelist should use `bun_crash_handler::HandleOom`
@@ -1114,10 +1096,8 @@ impl<T, E> UnwrapOrOom for core::result::Result<T, E> {
     }
 }
 
-/// Zig: `bun.handleErrorReturnTrace(err, @errorReturnTrace())` — captures the
-/// Zig error-return trace for crash reporting. Rust has no `@errorReturnTrace()`
-/// builtin (panics already carry a backtrace), so this tier-0 shim is a no-op
-/// that keeps call-site shape; the real reporter lives above in
+/// No-op tier-0 shim that keeps call-site shape (panics already carry a
+/// backtrace); the real reporter lives above in
 /// `bun_crash_handler::handle_error_return_trace`.
 #[inline(always)]
 pub fn handle_error_return_trace<E>(_err: E) {}
@@ -1125,15 +1105,18 @@ pub fn handle_error_return_trace<E>(_err: E) {}
 // Real `declare_scope!`/`scoped_log!`/`pretty*!`/`warn!`/`note!` are
 // `#[macro_export]`ed from output.rs.
 
-/// Zig: `bun.todoPanic(@src(), fmt, args)`. Intentional *runtime* "feature not
-/// yet implemented" path that the Zig source ships with — distinct from a
-/// porting placeholder. Captures file/line via `file!()`/`line!()` (the
-/// `@src()` equivalent) and routes through `Output::panic`.
-// TODO(port): wire `bun_analytics::Features::todo_panic` once the analytics
-// crate is reachable from bun_core without a dep cycle.
+/// Intentional *runtime* "feature not yet implemented" path — distinct from a
+/// placeholder. Captures file/line via `file!()`/`line!()`
+/// and routes through `Output::panic`.
 #[macro_export]
 macro_rules! todo_panic {
     ($($arg:tt)*) => {{
+        // Recorded in the tier-0 `Global::features` counter (same as
+        // css_parser's todo store). `bun_analytics::features::todo_panic` —
+        // the set the crash report serializes via `packed_features()` — is a
+        // re-export of this same static (see `define_features!`'s `core =`
+        // entries in src/analytics/lib.rs), so the bit reaches crash reports.
+        $crate::Global::features::TODO_PANIC.store(1, ::core::sync::atomic::Ordering::Relaxed);
         $crate::output::panic(::core::format_args!(
             "TODO: {} ({}:{})",
             ::core::format_args!($($arg)*),
@@ -1143,7 +1126,7 @@ macro_rules! todo_panic {
     }};
 }
 
-// `err!(Name)` / `err!("Name")` — Zig `error.Name` literal.
+// `err!(Name)` / `err!("Name")` — interned error-name literal.
 //
 // Expands to a per-site `AtomicU16` slot that interns the stringified name on
 // first hit, then hands back the cached `NonZeroU16` forever after. Two
@@ -1177,7 +1160,6 @@ macro_rules! err {
 // `mark_binding!` and `zstr!` are defined in Global.rs / util.rs respectively.
 
 pub use env as Environment;
-/// Zig: `pub const FeatureFlags = @import("./bun_core/feature_flags.zig")`.
 pub use feature_flags as FeatureFlags;
 /// Process start time in nanoseconds. Written once during single-threaded
 /// startup (`main`/`Cli::start`) and read freely thereafter.
@@ -1191,12 +1173,11 @@ pub fn set_start_time(ns: i128) {
     let _ = START_TIME.set(ns);
 }
 
-/// `bun.Timer` / `std.time.Timer` — minimal monotonic stopwatch. Mirrors Zig's
-/// `std.time.Timer.{start,read}` so callers ported verbatim (e.g.
+/// `bun.Timer` — minimal monotonic stopwatch so callers (e.g.
 /// `Lockfile::clean_with_logger`, `LifecycleScriptSubprocess`) compile against
 /// the tier-0 surface without pulling in `bun_perf`.
 pub mod time {
-    // `std.time.*` — defined in `util::time`; re-exported so `bun_core::time::*` resolves uniformly.
+    // Defined in `util::time`; re-exported so `bun_core::time::*` resolves uniformly.
     pub use crate::util::time::{
         MS_PER_DAY, MS_PER_S, NS_PER_DAY, NS_PER_HOUR, NS_PER_MIN, NS_PER_MS, NS_PER_S, NS_PER_US,
         NS_PER_WEEK, S_PER_DAY, US_PER_MS, US_PER_S, milli_timestamp, nano_timestamp, timestamp,
@@ -1220,7 +1201,7 @@ pub mod time {
     }
 }
 
-/// `bun.schema` — `src/options_types/schema.zig`. The full generated API
+/// `bun.schema`. The full generated API
 /// types live in `bun_api` (tier-2); tier-0 only needs the namespace to
 /// exist so `bun_core::schema::api::StringPointer` etc. resolve as re-exports
 /// once that crate un-gates. For now expose the one type tier-0 itself owns.
@@ -1292,8 +1273,7 @@ pub use crate::fmt::{
 /// have intentionally-different signatures in the two layers.
 pub(crate) mod strings_impl {
     // ─── UTF-16 surrogate-pair encoding (ICU U16_LEAD / U16_TRAIL) ─────────────
-    // Zig parity: src/string/immutable/unicode.zig:1480 `u16Lead`/`u16Trail`,
-    // re-exported as `strings.u16Lead`/`strings.u16Trail`. Defined here in
+    // Defined here in
     // bun_core (not bun_string) so the WTF-8 fallback transcoder below and any
     // other tier-0 caller can use it without a dep cycle.
     //
@@ -1359,9 +1339,9 @@ pub(crate) mod strings_impl {
         ascii_lowercase_buf, copy_lowercase, copy_lowercase_if_needed, trim, trim_left, trim_right,
     };
 
-    /// `std.mem.replacementSize` — byte length of `input` after replacing every
+    /// Byte length of `input` after replacing every
     /// occurrence of `needle` with `replacement`. Empty `needle` ⇒ `input.len()`
-    /// (lenient vs Zig's assert; matches every existing Rust caller's expectation).
+    /// (matches every existing caller's expectation).
     pub fn replacement_size(input: &[u8], needle: &[u8], replacement: &[u8]) -> usize {
         if needle.is_empty() {
             return input.len();
@@ -1375,7 +1355,7 @@ pub(crate) mod strings_impl {
         size
     }
 
-    /// `std.mem.replace` — write `input` into `output` replacing every `needle`
+    /// Write `input` into `output` replacing every `needle`
     /// with `replacement`; returns the number of replacements made. `output`
     /// must be at least [`replacement_size`]`(input, needle, replacement)` bytes.
     pub fn replace(input: &[u8], needle: &[u8], replacement: &[u8], output: &mut [u8]) -> usize {
@@ -1404,7 +1384,7 @@ pub(crate) mod strings_impl {
         }
     }
 
-    /// Allocating replace-all — `std.mem.replacementSize` + `std.mem.replace`
+    /// Allocating replace-all — [`replacement_size`] + [`replace`]
     /// fused. Returns a fresh `Vec` (sized exactly to the result; no realloc).
     pub fn replace_owned(input: &[u8], needle: &[u8], replacement: &[u8]) -> Vec<u8> {
         if needle.is_empty() {
@@ -1420,10 +1400,8 @@ pub(crate) mod strings_impl {
         out.extend_from_slice(&input[i..]);
         out
     }
-    /// Zig: `strings.eqlCaseInsensitiveASCII` (src/string/immutable.zig).
-    /// Spec-faithful port: defers to libc `strncasecmp`/`_strnicmp` for the
-    /// hot path (CSS parser, HTTP header matching). Unlike Zig's NUL-terminated
-    /// literals, Rust slices have no terminator, so a `b` shorter than `a` is
+    /// Defers to libc `strncasecmp`/`_strnicmp` for the
+    /// hot path (CSS parser, HTTP header matching). A `b` shorter than `a` is
     /// rejected instead of read past.
     #[inline]
     pub fn eql_case_insensitive_ascii(a: &[u8], b: &[u8], check_len: bool) -> bool {
@@ -1459,10 +1437,9 @@ pub(crate) mod strings_impl {
             _strnicmp(a.as_ptr().cast(), b.as_ptr().cast(), a.len()) == 0
         }
     }
-    /// Zig: `strings.containsCaseInsensitiveASCII` — naive O(n·m) windowed
-    /// case-insensitive ASCII substring search (matches the Zig scalar impl;
-    /// callers are cold path-lookup on macOS/Windows where the FS is
-    /// case-insensitive).
+    /// Naive O(n·m) windowed
+    /// case-insensitive ASCII substring search (callers are cold path-lookup
+    /// on macOS/Windows where the FS is case-insensitive).
     #[inline]
     pub fn contains_case_insensitive_ascii(haystack: &[u8], needle: &[u8]) -> bool {
         if needle.len() > haystack.len() {
@@ -1477,15 +1454,15 @@ pub(crate) mod strings_impl {
         }
         false
     }
-    /// `bun.strings.isWindowsAbsolutePathMissingDriveLetter` (immutable/paths.zig)
+    /// `bun.strings.isWindowsAbsolutePathMissingDriveLetter`
     /// — true for `\foo`-style absolute paths that lack a `C:` / `\\?\` /
     /// `\\server\` prefix and therefore need the cwd's drive prepended.
-    /// Generic over `u8`/`u16` to mirror the Zig comptime `T: type` param.
+    /// Generic over `u8`/`u16`.
     pub fn is_windows_absolute_path_missing_drive_letter<T: crate::strings::PathByte>(
         chars: &[T],
     ) -> bool {
-        // Zig asserts non-empty + windows-absolute; release-mode callers may
-        // still pass `""`, so bail instead of indexing OOB.
+        // Release-mode callers may still pass `""`, so bail instead of
+        // indexing OOB.
         debug_assert!(!chars.is_empty());
         if chars.is_empty() {
             return false;
@@ -1514,9 +1491,9 @@ pub(crate) mod strings_impl {
             }
         }
 
-        // Zig: `bun.path.windowsFilesystemRootT(T, chars).len == 1`. With
-        // `chars[0]` already known to be a separator, that fn returns len > 1
-        // only via its UNC/device branch (`len >= 5 && sep[0] && sep[1] &&
+        // With `chars[0]` already known to be a separator, the filesystem
+        // root is longer than one char
+        // only via the UNC/device branch (`len >= 5 && sep[0] && sep[1] &&
         // !sep[2]`); every other separator-led path resolves to a single-char
         // root. Inlined here because `bun_paths` would be a tier-0 cycle.
         //
@@ -1526,9 +1503,8 @@ pub(crate) mod strings_impl {
         !(chars.len() >= 5 && sep(chars[1]) && !sep(chars[2]))
     }
     /// `strings.eqlComptimeIgnoreLen` — caller has already checked `a.len() ==
-    /// b.len()` (the "ignore len" means "don't re-check"). PERF(port): the Zig
-    /// version generates length-specialized SWAR loads at comptime; this scalar
-    /// fallback is fine for the only T0/T1 caller (ComptimeStringMap, where
+    /// b.len()` (the "ignore len" means "don't re-check"). This scalar
+    /// path is fine for the only T0/T1 caller (ComptimeStringMap, where
     /// `b` is a small static).
     #[inline]
     pub fn eql_comptime_ignore_len(a: &[u8], b: &'static [u8]) -> bool {
@@ -1539,9 +1515,7 @@ pub(crate) mod strings_impl {
     /// `const fn` byte-slice equality — slice `==` is not `const` on stable, so
     /// const-context callers (clap param-name lookup, MultiArrayList field-name
     /// reflection, host-fn error-set parsing) need the manual len-check + while
-    /// loop. Zig precedent: a single `std.mem.eql(u8, a, b)`; the per-crate
-    /// duplication was a Rust-port artifact, not a design choice. Runtime
-    /// callers should prefer plain `==` (lowers to `memcmp`).
+    /// loop. Runtime callers should prefer plain `==` (lowers to `memcmp`).
     #[inline]
     pub const fn const_bytes_eq(a: &[u8], b: &[u8]) -> bool {
         if a.len() != b.len() {
@@ -1564,7 +1538,7 @@ pub(crate) mod strings_impl {
     }
 
     // ──────────────────────────────────────────────────────────────────────
-    // Transcoding (from src/string/immutable/unicode.zig). Lives in T0 so
+    // Transcoding. Lives in T0 so
     // collections::Vec<u8> can call it without depending on bun_string.
     // Allocator params dropped per PORTING.md §Allocators.
     // ──────────────────────────────────────────────────────────────────────
@@ -1721,8 +1695,7 @@ pub(crate) mod strings_impl {
     }
 
     /// Port of `allocateLatin1IntoUTF8WithList`.
-    /// PERF(port): Zig hand-rolls a SWAR/@Vector ASCII-span scanner; here we use
-    /// `first_non_ascii` (simdutf SIMD) for the span scan — equivalent throughput.
+    /// Uses `first_non_ascii` (simdutf SIMD) for the ASCII-span scan.
     pub fn allocate_latin1_into_utf8_with_list(
         mut list: Vec<u8>,
         offset_into_list: usize,
@@ -2027,7 +2000,7 @@ pub(crate) mod strings_impl {
     }
 
     /// Null-terminated variant of `to_utf8_from_latin1`. Returns `ZBox` so
-    /// `.len()` excludes the sentinel (Zig `[:0]u8` semantics).
+    /// `.len()` excludes the sentinel.
     pub fn to_utf8_from_latin1_z(latin1: &[u8]) -> Option<crate::ZBox> {
         let v = to_utf8_from_latin1(latin1)?;
         Some(crate::ZBox::from_vec_with_nul(v))
@@ -2040,8 +2013,7 @@ pub(crate) mod strings_impl {
     }
 
     /// Port of `firstNonASCII16`: index of the first u16 codeunit `>= 0x80`, or
-    /// `None` if all-ASCII. Single SIMD-upgrade target — Zig uses `@Vector(8,u16)`
-    /// max-reduce + `@ctz` bitmask (immutable.zig:1720); simdutf exposes no
+    /// `None` if all-ASCII. Single SIMD-upgrade target — simdutf exposes no
     /// u16-ASCII-index fn and WTF's `charactersAreAllASCII<UChar>` is bool-only,
     /// so scalar until portable_simd lands.
     #[inline]
@@ -2052,8 +2024,7 @@ pub(crate) mod strings_impl {
     /// Narrow ASCII-only `src` into `dst`. Returns `Some(&mut dst[..src.len()])`
     /// iff every unit is `< 0x80` and `dst.len() >= src.len()`; otherwise `None`
     /// (partial writes to `dst` are not rolled back). Composes `firstNonASCII16`
-    /// + `copyU16IntoU8` — Zig has no single helper and open-codes this per site
-    /// (e.g. string.zig `inMapCaseInsensitive`).
+    /// + `copyU16IntoU8`.
     #[inline]
     pub fn narrow_ascii_u16<'a>(src: &[u16], dst: &'a mut [u8]) -> Option<&'a mut [u8]> {
         let dst = dst.get_mut(..src.len())?;
@@ -2077,9 +2048,9 @@ pub(crate) mod strings_impl {
 
     // Bound relaxed Eq → PartialEq to match core::slice::<[T]>::starts_with /
     // ends_with exactly. Bodies are semantically identical to the stdlib
-    // methods; kept as named free fns so Zig-port call sites that read
-    // `strings::has_prefix_t(a, b)` stay 1:1 with `bun.strings.hasPrefixComptime`
-    // / `std.mem.startsWith`. Rust already lowers slice `==` on integer T to
+    // methods; kept as named free fns so call sites that read
+    // `strings::has_prefix_t(a, b)` keep their shape.
+    // Rust already lowers slice `==` on integer T to
     // memcmp, so the `eql_long`/`reinterpret_to_u8` perf path from
     // immutable.rs is unnecessary.
     #[inline]
@@ -2092,7 +2063,7 @@ pub(crate) mod strings_impl {
         s.len() >= suffix.len() && s[s.len() - suffix.len()..] == *suffix
     }
 
-    /// `std.mem.lastIndexOfScalar(T, slice, value)` — generic reverse scan.
+    /// Generic reverse scan for the last element equal to `c`.
     /// For `T = u8` prefer `bun_core::strings::last_index_of_char` (glibc
     /// `memrchr` on Linux).
     #[inline]
@@ -2115,9 +2086,7 @@ pub(crate) mod strings_impl {
         eql_case_insensitive_ascii(a, b, true)
     }
 
-    /// Zig: open-coded `or`-chains over `eqlCaseInsensitiveASCII` at every site
-    /// (custom.zig:1526, ident.zig:278, WebSocketUpgradeClient.zig:1426 — the
-    /// `css.todo_stuff.match_ignore_ascii_case` markers). Haystacks are 6-12
+    /// Haystacks are 6-12
     /// const literals; `#[inline]` lets LLVM unroll back to the original
     /// short-circuit chain. For key→value dispatch use `in_map_case_insensitive`.
     #[inline]
@@ -2140,8 +2109,8 @@ pub(crate) mod strings_impl {
     }
 
     // ──────────────────────────────────────────────────────────────────────
-    // IP-literal predicates. Spec (immutable.zig:1984-2004) calls
-    // `bun.c_ares.ares_inet_pton`, the vendored c-ares implementation.
+    // IP-literal predicates — backed by `ares_inet_pton`, the vendored
+    // c-ares implementation.
     // Do NOT call the system `inet_pton` here: on Windows that resolves into
     // ws2_32.dll and fails with WSANOTINITIALISED whenever it runs before
     // `WSAStartup()`, which URL/host parsing can. c-ares' impl is pure C, no
@@ -2164,7 +2133,7 @@ pub(crate) mod strings_impl {
     #[cfg(windows)]
     const AF_INET6: core::ffi::c_int = 23; // ws2def.h
 
-    /// Zig: `bun.strings.isIPV6Address` — `ares_inet_pton(AF_INET6, …) > 0`.
+    /// `ares_inet_pton(AF_INET6, …) > 0`.
     /// Must be a strict parse, not a `contains(':')` heuristic: on Windows a
     /// unix-socket path like `C:/Windows/Temp/…` contains a colon and the old
     /// heuristic mis-bracketed it as `unix://[C:/…]`, which fails URL parsing.
@@ -2200,7 +2169,7 @@ pub(crate) mod strings_impl {
         s.len() == 36 && starts_with_uuid(s)
     }
     pub fn starts_with_npm_secret(s: &[u8]) -> usize {
-        // Port of bun.strings.startsWithNpmSecret (immutable.zig): case-insensitive
+        // Case-insensitive
         // `npm`, then `_` or `s_`/`S_`, then 36..=48 alnum. Returns consumed length or 0.
         if s.len() < 3 {
             return 0;
@@ -2335,10 +2304,10 @@ pub(crate) mod strings_impl {
 
     /// Port of `bun.fmt.URLFormatter.findUrlPassword` — returns
     /// `(offset, len)` of the password segment, or None.
-    /// Zig only matches http:// and https:// schemes and rejects empty pw.
+    /// Only matches http:// and https:// schemes and rejects empty pw.
     pub fn find_url_password(s: &[u8]) -> Option<(usize, usize)> {
-        // Zig uses case-sensitive `hasPrefixComptime` and truncates the search
-        // region at the first '\n' before scanning for '@'/':'.
+        // Case-sensitive prefix match; the search region is truncated at the
+        // first '\n' before scanning for '@'/':'.
         let scheme_end = if s.starts_with(b"http://") {
             7
         } else if s.starts_with(b"https://") {
@@ -2368,7 +2337,6 @@ pub(crate) mod strings_impl {
         Utf16,
     }
 
-    /// Port of `bun.strings.utf8ByteSequenceLength` (unicode.zig:1509).
     /// Returns the UTF-8/WTF-8 sequence length implied by a *leading* byte,
     /// or **0** if the byte is not a valid lead (continuation 0x80-0xBF, or 0xF8-0xFF).
     #[inline]
@@ -2382,7 +2350,6 @@ pub(crate) mod strings_impl {
         }
     }
 
-    /// Port of `bun.strings.wtf8ByteSequenceLength` (unicode.zig:1954).
     /// Same table as [`utf8_byte_sequence_length`] but returns **1** for an invalid
     /// lead byte, so callers can always advance ≥1 (replacement-char semantics).
     #[inline]
@@ -2396,7 +2363,7 @@ pub(crate) mod strings_impl {
         }
     }
 
-    /// Zig: `wtf8ByteSequenceLengthWithInvalid` — alias of
+    /// Alias of
     /// [`wtf8_byte_sequence_length`] (kept distinct for spec-faithful naming).
     #[inline]
     pub const fn wtf8_byte_sequence_length_with_invalid(first_byte: u8) -> u8 {
@@ -2463,13 +2430,11 @@ pub(crate) mod strings_impl {
     }
 
     /// `strings.convertUTF16ToUTF8InBuffer` — write UTF-8 into `out`, return
-    /// the written sub-slice. Infallible: Zig's `![]const u8` has an empty
-    /// inferred error set, so every `catch` at call sites is dead code. The
+    /// the written sub-slice. Infallible. The
     /// caller is responsible for sizing `out` for the worst case (≤ 3× input
     /// code units).
     ///
-    /// PORT NOTE: Zig passes `out` straight to simdutf with no bounds check
-    /// (UB if undersized). We assert in release too — one extra SIMD length
+    /// We assert the sizing in release too — one extra SIMD length
     /// scan is cheap, and a panic beats heap corruption if a future caller
     /// gets the sizing wrong. All current callers (~10, Windows wide-path
     /// code) size `out` at `3 * utf16.len()` or `MAX_PATH * 3`, so this never
@@ -2487,7 +2452,7 @@ pub(crate) mod strings_impl {
         let result = simdutf::convert::utf16::to::utf8::le(utf16, out);
         &mut out[..result]
     }
-    // ─── path basename (std.fs.path.basename{Posix,Windows}) ──────────────────
+    // ─── path basename ─────────────────────────────────────────────────────
     // Minimal code-unit trait so the generic basename impls can live at T0
     // without pulling `bun_paths::PathChar` (T1) down. `PathChar` and
     // `PathUnit` both add `: PathByte` as a supertrait and inherit `from_u8`.
@@ -2507,7 +2472,7 @@ pub(crate) mod strings_impl {
         }
     }
 
-    /// `std.fs.path.basenamePosix` — strip trailing `/` then return the final
+    /// Strip trailing `/` then return the final
     /// component. `\` is NOT a separator. Empty / all-`/` input → `&[]`.
     pub fn basename_posix<T: PathByte>(p: &[T]) -> &[T] {
         let mut end = p.len();
@@ -2524,7 +2489,7 @@ pub(crate) mod strings_impl {
         &p[start..end]
     }
 
-    /// `std.fs.path.basenameWindows` — strips trailing `/`/`\`, treats a drive
+    /// Strips trailing `/`/`\`, treats a drive
     /// designator `X:` at index 1 as a root delimiter (`"C:"` → `""`,
     /// `"C:foo"` → `"foo"`, `"C:\\"` → `""`), then returns the final component.
     pub fn basename_windows<T: PathByte>(p: &[T]) -> &[T] {
@@ -2557,8 +2522,8 @@ pub(crate) mod strings_impl {
         &p[start..end]
     }
 
-    /// `bun.strings.basename` — comptime-dispatches to `basenameWindows` on
-    /// Windows and `basenamePosix` elsewhere.
+    /// Dispatches to [`basename_windows`] on Windows and [`basename_posix`]
+    /// elsewhere.
     #[inline]
     pub fn basename(path: &[u8]) -> &[u8] {
         if cfg!(windows) {
@@ -2567,14 +2532,12 @@ pub(crate) mod strings_impl {
             basename_posix(path)
         }
     }
-    /// `bun.strings.removeLeadingDotSlash` (immutable/paths.zig). Hosted at T0
+    /// `bun.strings.removeLeadingDotSlash`. Hosted at T0
     /// so `crate::string` (and `bun_paths::string_paths`) can reach it
     /// without a `bun_paths` edge.
     #[inline(always)]
     pub fn remove_leading_dot_slash(slice: &[u8]) -> &[u8] {
         if slice.len() >= 2 {
-            // PERF(port): Zig bitcast slice[0..2] to u16; direct 2-byte slice
-            // comparison compiles to the same thing.
             if &slice[..2] == b"./" || (cfg!(windows) && &slice[..2] == b".\\") {
                 return &slice[2..];
             }
@@ -2600,12 +2563,12 @@ pub use strings_impl::*;
 ///
 /// NOTE: a handful of names (`index_of_char`, `eql_long`, `first_non_ascii`,
 /// `Encoding`, `CodepointIterator`) have a different signature here than in
-/// `bun_core::immutable`. Callers that need the Zig-spec
+/// `bun_core::immutable`. Callers that need the canonical
 /// `bun.strings.*` form import `bun_core::immutable as strings` instead.
 pub mod strings {
     // `bun_core::strings` is the union of the crate-root surface (`super::*`,
     // which carries the scalar-fallback `strings_impl::*` glob plus every
-    // `bun_core::Foo`) and the full Zig-spec `bun.strings.*` namespace
+    // `bun_core::Foo`) and the full canonical `bun.strings.*` namespace
     // (`string::immutable::*`). Names that exist in BOTH layers — same
     // identifier, different signature — are explicitly disambiguated below
     // in favour of `immutable` (matches every former `bun_core::strings::X`
@@ -2622,9 +2585,9 @@ pub mod strings {
         last_index_of_char_t, remove_leading_dot_slash, starts_with, without_trailing_slash,
     };
     // Disambiguate vs the scalar tier-0 versions in `crate::strings_impl` (now
-    // dedup-hoisted) — `immutable` is the Zig-spec impl callers expect.
+    // dedup-hoisted) — `immutable` is the canonical impl callers expect.
     pub use crate::string::immutable::{ares_inet_pton, copy_lowercase_if_needed};
-    // `index_of_any{,_t}` keep the scalar `Option<usize>` form (Zig-spec
+    // `index_of_any{,_t}` keep the scalar `Option<usize>` form (the canonical
     // `immutable` returns `Option<OptionalUsize>` which no caller wants here).
     pub use crate::strings_impl::{index_of_any, index_of_any_t};
 }
@@ -2654,8 +2617,7 @@ pub mod feature_flag {
         BUN_FEATURE_FLAG_EXPERIMENTAL_BAKE
     );
 }
-/// Port of `bun.linuxKernelVersion()` (src/bun.zig) → `analytics.GeneratePlatform.kernelVersion()`.
-/// Lives in T1 because `bun_sys` calls it from feature probes (copy_file_range,
+/// `bun.linuxKernelVersion()`. Lives in T1 because `bun_sys` calls it from feature probes (copy_file_range,
 /// ioctl_ficlone, RWF_NONBLOCK) and cannot depend on `bun_analytics`. Parses
 /// `uname(2).release` major.minor.patch directly; the full Semver parse with
 /// pre/build tags stays in `bun_analytics`.
@@ -2701,7 +2663,7 @@ pub fn linux_kernel_version() -> Version {
 /// `catch_unwind` always returns `Ok` and the wrapper was dead weight. JSC does
 /// not throw C++ exceptions across its public API, so there is no foreign
 /// unwind to catch either. Macro-generated `extern "C"` thunks now call the
-/// user body directly (same end state as Zig `@panic` → `bun.crash_handler`).
+/// user body directly.
 pub mod ffi {
     // `core`-only primitives shared with the freestanding `bun_shim_impl` PE
     // (which cannot link `bun_core`'s `#[no_mangle]` C-ABI surface). Single
@@ -2714,9 +2676,8 @@ pub mod ffi {
     ///
     /// Single audited wrapper over `CStr::from_ptr` so the ~180 raw call
     /// sites in the tree funnel through one `unsafe` block. Adds a
-    /// `debug_assert!(!p.is_null())` — `CStr::from_ptr(null)` is instant UB
-    /// and the Zig originals (`bun.span`, `std.mem.span`) likewise assume a
-    /// valid sentinel pointer, so a null here is always a caller bug.
+    /// `debug_assert!(!p.is_null())` — `CStr::from_ptr(null)` is instant UB,
+    /// so a null here is always a caller bug.
     ///
     /// # Safety
     /// `p` must be non-null, point to a valid NUL-terminated byte sequence,
@@ -2741,7 +2702,7 @@ pub mod ffi {
         UTSNAME.get_or_init(uname)
     }
 
-    /// Slice up to (excluding) the first NUL byte. Port of Zig `bun.sliceTo(b, 0)`;
+    /// Slice up to (excluding) the first NUL byte;
     /// re-exported as `bun_core::slice_to_nul`.
     #[inline]
     pub fn slice_to_nul(buf: &[u8]) -> &[u8] {
@@ -2809,8 +2770,7 @@ pub mod ffi {
     ///
     /// Single audited wrapper over `core::mem::zeroed()` so libc/uv/c-ares
     /// out-param init sites (`let mut x: libc::sigaction = zeroed();`) don't
-    /// each open-code an `unsafe` block. This is the Rust spelling of Zig's
-    /// `std.mem.zeroes(T)` / `= .{}` for `extern struct`.
+    /// each open-code an `unsafe` block.
     ///
     /// The `T: Zeroable` bound discharges the `mem::zeroed` safety obligation
     /// once per type (at the `unsafe impl`), so callers need no `unsafe`
@@ -3050,7 +3010,7 @@ pub mod ffi {
         unsafe { core::mem::zeroed() }
     }
 
-    /// Pointer to the calling thread's libc `errno` (Zig: `std.c._errno()`).
+    /// Pointer to the calling thread's libc `errno`.
     ///
     /// Single audited cfg-ladder over the per-libc TLS accessor symbol so the
     /// tree has ONE place that knows glibc/musl spell it `__errno_location()`,
@@ -3101,7 +3061,7 @@ pub mod ffi {
         errno_location()
     }
 
-    /// Read the calling thread's libc `errno` (Zig: `std.c._errno().*`).
+    /// Read the calling thread's libc `errno`.
     /// Safe wrapper over `*errno_ptr()`.
     #[inline(always)]
     pub fn errno() -> core::ffi::c_int {
@@ -3112,7 +3072,7 @@ pub mod ffi {
 }
 
 pub mod asan {
-    //! Low-tier mirror of `src/safety/asan.zig`. `bun_safety` depends on
+    //! ASAN/LSAN runtime hooks. `bun_safety` depends on
     //! `bun_core`, so the implementation lives here and `bun_safety::asan`
     //! re-uses the same `cfg(bun_asan)` gate. Callers in `bun_jsc`,
     //! `bun_runtime`, and `bun_collections` reach the real LSAN/ASAN runtime
@@ -3194,7 +3154,7 @@ pub mod asan {
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// glibc-compat / link wraps. Zig: src/workaround_missing_symbols.zig.
+// glibc-compat / link wraps.
 // build.ninja links with `-Wl,--wrap=gettid` so libc/std references land here.
 // ────────────────────────────────────────────────────────────────────────────
 #[cfg(target_os = "linux")]
@@ -3204,7 +3164,7 @@ pub(crate) extern "C" fn __wrap_gettid() -> libc::pid_t {
     unsafe { libc::syscall(libc::SYS_gettid) as libc::pid_t }
 }
 
-/// `bun.getTotalMemorySize()` (bun.zig:3498) — process-wide RAM budget,
+/// `bun.getTotalMemorySize()` — process-wide RAM budget,
 /// cgroup/jetsam-aware. Backed by the linked C++ `Bun__ramSize()`
 /// (src/jsc/bindings/c-bindings.cpp). Lives in `bun_core` so both
 /// `bun_runtime` (node:fs preallocation guard) and the binary root can
@@ -3225,7 +3185,7 @@ pub fn capture_stack_trace(begin: usize, addrs: &mut [usize]) -> usize {
     debug::capture_current(first, addrs)
 }
 
-/// Zig `@returnAddress()`: a PC inside the caller's caller. `#[inline(always)]`
+/// A PC inside the caller's caller. `#[inline(always)]`
 /// so this has no frame of its own — `frame_address()` reads the caller's fp,
 /// and `[fp + PC_OFFSET]` is the caller's saved return address. Used as the
 /// `first_address` trim point for `capture_current` (which falls back to the
diff --git a/src/bun_core/output.rs b/src/bun_core/output.rs
index dbf3b714153..703dc80dcb2 100644
--- a/src/bun_core/output.rs
+++ b/src/bun_core/output.rs
@@ -1,8 +1,6 @@
-//! Port of `src/bun_core/output.zig`.
-//!
-//! Most of the public surface in the Zig original is `(comptime fmt: string, args: anytype)`
-//! printf-style entry points whose format string is rewritten at comptime (`prettyFmt`,
-//! newline appending, tag prefixing). In Rust these collapse into:
+//! Terminal/console output: printf-style entry points whose format string is
+//! rewritten at compile time (`prettyFmt`, newline appending, tag prefixing).
+//! These collapse into:
 //!   * a non-generic `print_to(dest, core::fmt::Arguments)` plumbing layer, and
 //!   * thin `macro_rules!` wrappers (`pretty!`, `pretty_errorln!`, `note!`, …) that perform
 //!     the compile-time format-string rewrite via `pretty_fmt!`.
@@ -45,8 +43,10 @@ pub(crate) fn output_sink() -> OutputSink {
 }
 
 /// Opaque handle to a `bun_sys::file::QuietWriter`. bun_core treats it as a
-/// POD blob; bun_sys casts back to the concrete type.
-/// TODO(port): bun_sys::file::QuietWriter — size/align must match.
+/// POD blob; bun_sys casts back to the concrete type. Contract: bun_sys only
+/// stashes the raw fd in slot 0 (see `qw_fd`/`qw_set_fd` in bun_sys), so the
+/// blob just needs pointer size/alignment — keep `[*mut (); 4]` in sync with
+/// that consumer if either side changes.
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub struct QuietWriter {
@@ -87,7 +87,9 @@ impl core::fmt::Write for QuietWriter {
 // `qw.write_fmt(args)` resolves through `fmt::Write`.
 
 /// Opaque adapter wrapping a QuietWriter and exposing `crate::io::Writer`.
-/// TODO(port): bun_sys::QuietWrite::Adapter — size/align must match.
+/// Layout contract: bun_sys's concrete `SysQuietWriterAdapter` must fit in
+/// these 64 bytes with `io::Writer` as its first field; const-asserted on the
+/// bun_sys side next to that struct.
 #[repr(C, align(8))]
 pub struct QuietWriterAdapter {
     _opaque: [u8; 64],
@@ -132,7 +134,7 @@ impl File {
         output_sink().quiet_writer_from_fd(self.0)
     }
     /// Write all bytes (best-effort; routes through QuietWriter so errors are
-    /// swallowed per Zig `bun.Output` semantics). Progress.rs uses this.
+    /// swallowed). Progress.rs uses this.
     #[inline]
     pub fn write_all(self, bytes: &[u8]) -> Result<(), crate::Error> {
         let mut qw = self.quiet_writer();
@@ -172,12 +174,12 @@ pub fn argv() -> impl Iterator<Item = &'static [u8]> {
 
 /// `bun.Output.debugWarn` — yellow `debug warn:` prefix to stderr in debug
 /// builds, through the Bun output sink (so colour/redirect logic applies),
-/// followed by an explicit flush. Zig output.zig:1189-1194.
+/// followed by an explicit flush.
 ///
 /// Function form takes a single [`PrettyFmtInput`] payload — callers pass
 /// `format_args!("template {}", x)` (the dominant convention across the
 /// codebase) or a bare `&str`. The payload is rendered first, then
-/// `<tag>`-rewritten. For the comptime-literal fast path use the macro form.
+/// `<tag>`-rewritten. For the compile-time-literal fast path use the macro form.
 #[inline]
 pub fn debug_warn(payload: impl PrettyFmtInput) {
     if cfg!(debug_assertions) {
@@ -194,14 +196,14 @@ pub fn warn(payload: impl PrettyFmtInput) {
     pretty_errorln!("<r><yellow>warn<r><d>:<r> {}", buf);
 }
 
-/// `bun.Output.note` — blue `note:` prefix to stderr (output.zig:1179).
+/// `bun.Output.note` — blue `note:` prefix to stderr.
 #[inline]
 pub fn note(payload: impl PrettyFmtInput) {
     let buf = payload.into_pretty_buf(enable_ansi_colors_stderr());
     pretty_errorln!("<blue>note<r><d>:<r> {}", buf);
 }
 
-/// Function-form of `Output.debug` (Zig: `pub fn debug(comptime fmt, args)`).
+/// Function-form of `Output.debug`.
 /// The macro form is `crate::debug!`; this fn variant takes a single
 /// pre-formatted payload for call sites that build the message dynamically.
 #[inline]
@@ -235,7 +237,7 @@ pub fn pretty_error(payload: impl PrettyFmtInput) {
 }
 
 /// Test-harness initializer: configure the output sinks without touching the
-/// real stdio FDs (Zig: `Output.initTest`). Safe to call repeatedly.
+/// real stdio FDs. Safe to call repeatedly.
 pub fn init_test() {
     if SOURCE_SET.get() {
         return;
@@ -250,8 +252,7 @@ pub fn init_test() {
 
 /// `bun.Output.Source.Stdio.restore` — restore terminal to cooked mode on exit.
 /// Thin alias over [`crate::output::stdio::restore`] (the real impl, also in
-/// this crate); the indirection exists only because Zig spells the path both
-/// `Output.Source.Stdio.restore` and `Output.Stdio.restore`.
+/// this crate).
 pub mod source {
     pub mod stdio {
         #[inline]
@@ -314,15 +315,15 @@ pub static TERMINAL_SIZE: crate::AtomicCell<crate::Winsize> =
 #[cfg(not(target_arch = "wasm32"))]
 pub type StreamType = File;
 #[cfg(target_arch = "wasm32")]
-pub type StreamType = io::FixedBufferStream; // TODO(port): FixedBufferStream arrives via bun_io→core move-in.
+pub type StreamType = io::FixedBufferStream; // wasm32 is not built yet; FixedBufferStream is unported.
 
 pub struct Source {
     pub stdout_buffer: [u8; 4096],
     pub stderr_buffer: [u8; 4096],
     pub buffered_stream_backing: QuietWriterAdapter,
     pub buffered_error_stream_backing: QuietWriterAdapter,
-    // Self-referential: point into `*_backing.new_interface`. Replaced with accessor
-    // methods in Rust; raw fields kept to mirror Zig field order.
+    // Self-referential: point into `*_backing.new_interface`. Use the accessor
+    // methods instead of these raw fields.
     // (LIFETIMES.tsv: BORROW_FIELD — self-ref into buffered_*_backing)
     buffered_stream: *mut io::Writer,
     buffered_error_stream: *mut io::Writer,
@@ -335,21 +336,46 @@ pub struct Source {
 
     pub raw_stream: StreamType,
     pub raw_error_stream: StreamType,
-    // Zig: `[]u8 = &([_]u8{})` — borrowed WASM-mode write buffers, never freed by this
-    // file. Not owned → raw fat ptr (BORROW_FIELD-style), not `Box<[u8]>`.
+    // Borrowed WASM-mode write buffers, never freed by this file.
+    // Not owned → raw fat ptr (BORROW_FIELD-style), not `Box<[u8]>`.
     pub out_buffer: *mut [u8],
     pub err_buffer: *mut [u8],
 }
 
 impl Source {
-    // TODO(port): proper zero-init for QuietWriterAdapter / StreamType — currently relies on
-    // `mem::zeroed()` which is only sound if those are `#[repr(C)]` POD with no
-    // `NonNull`/`NonZero`/niche-enum fields. Hand-write `ZEROED`/`Default` once their
-    // layouts are fixed in bun_sys.
-    // SAFETY: byte arrays and raw `*mut` pointers are valid all-zero (null fat ptr =
-    // `(null, 0)`); only read after `init()` overwrites every field. See TODO above for
-    // the adapter/stream caveat.
-    pub const ZEROED: Self = unsafe { crate::ffi::zeroed_unchecked() };
+    // Field-wise placeholder value for the pre-`init()` thread_local slot.
+    // Every field is overwritten by `init()` before use.
+    //
+    // The pre-init stream placeholder is cfg-split because the two
+    // `StreamType` aliases have different const surfaces: native
+    // `File::ZEROED` is `Fd::INVALID`, so a pre-init read fails loudly
+    // instead of aliasing fd 0; `FixedBufferStream` has no `ZEROED` const,
+    // so the wasm32 arm spells out the empty stream field-wise.
+    #[cfg(not(target_arch = "wasm32"))]
+    const ZEROED_STREAM: StreamType = StreamType::ZEROED;
+    #[cfg(target_arch = "wasm32")]
+    const ZEROED_STREAM: StreamType = StreamType {
+        buf: core::ptr::null_mut(),
+        len: 0,
+        pos: 0,
+    };
+
+    pub const ZEROED: Self = Self {
+        stdout_buffer: [0u8; 4096],
+        stderr_buffer: [0u8; 4096],
+        buffered_stream_backing: QuietWriterAdapter::uninit(),
+        buffered_error_stream_backing: QuietWriterAdapter::uninit(),
+        buffered_stream: core::ptr::null_mut(),
+        buffered_error_stream: core::ptr::null_mut(),
+        stream_backing: QuietWriterAdapter::uninit(),
+        error_stream_backing: QuietWriterAdapter::uninit(),
+        stream: core::ptr::null_mut(),
+        error_stream: core::ptr::null_mut(),
+        raw_stream: Self::ZEROED_STREAM,
+        raw_error_stream: Self::ZEROED_STREAM,
+        out_buffer: core::ptr::slice_from_raw_parts_mut(core::ptr::null_mut(), 0),
+        err_buffer: core::ptr::slice_from_raw_parts_mut(core::ptr::null_mut(), 0),
+    };
 
     /// Accessors replacing the self-referential `*std.Io.Writer` fields.
     #[inline]
@@ -369,12 +395,11 @@ impl Source {
         self.error_stream_backing.new_interface()
     }
 
-    // TODO(port): in-place init — `out` is the pre-allocated thread_local slot; PORTING.md
-    // says keep `&mut MaybeUninit<Self>` (or reshape to `-> Self`) for out-param ctors.
+    // The out-param shape is load-bearing: `out` is the pre-allocated
+    // thread_local slot, and the adapters built below capture raw pointers
+    // into `out.stdout_buffer`/`out.stderr_buffer`. Returning `Self` by value
+    // would move the struct after those pointers were captured and dangle them.
     pub fn init(out: &mut Source, stream: StreamType, err_stream: StreamType) {
-        // TODO(port): bun_alloc::USE_MIMALLOC + mimalloc::Option::ShowErrors
-        // are gated in bun_alloc; re-enable once bun_alloc/basic.rs is un-gated.
-
         if cfg!(debug_assertions) && bun_alloc::USE_MIMALLOC && !SOURCE_SET.get() {
             bun_alloc::mimalloc::mi_option_set(bun_alloc::mimalloc::Option::show_errors, 1);
         }
@@ -384,9 +409,8 @@ impl Source {
         out.raw_error_stream = err_stream;
         // stdout_buffer / stderr_buffer left uninitialized (overwritten by adapter writes)
 
-        // PORT NOTE: reshaped for borrowck — the Zig wrote `out.* = .{ ...undefined... }`
-        // then patched the self-referential pointers. In Rust we construct the backings
-        // directly and expose accessors instead of storing interior pointers.
+        // Construct the backings directly and expose accessors instead of
+        // storing interior pointers.
         out.buffered_stream_backing = out
             .raw_stream
             .quiet_writer()
@@ -455,7 +479,7 @@ impl Source {
     }
 
     pub fn is_no_color() -> bool {
-        // Zig output.zig:99 — parsed bool, default false. NO_COLOR=0 → false.
+        // Parsed bool, default false. NO_COLOR=0 → false.
         env_var::NO_COLOR.get().unwrap_or(false)
     }
 
@@ -694,7 +718,6 @@ pub mod windows_stdio {
 pub mod stdio {
     use super::*;
 
-    // TODO(port): move to bun_core_sys
     unsafe extern "C" {
         // Written once by C at process startup before threads; Rust only reads.
         // `[AtomicI32; 3]` has identical layout to C's `int32_t[3]` (`AtomicI32`
@@ -886,11 +909,11 @@ pub static IS_GITHUB_ACTION: AtomicBool = AtomicBool::new(false);
 pub(crate) static STDERR_DESCRIPTOR_TYPE: crate::Once<OutputStreamDescriptor> = crate::Once::new();
 pub(crate) static STDOUT_DESCRIPTOR_TYPE: crate::Once<OutputStreamDescriptor> = crate::Once::new();
 
-/// Downstream alias (Zig: `Output.OutputStreamDescriptor`). Several call sites
+/// Downstream alias. Several call sites
 /// refer to it as `Output::DescriptorType` for brevity.
 pub type DescriptorType = OutputStreamDescriptor;
 
-/// Safe getter (Zig: `Output.stderr_descriptor_type`).
+/// Safe getter for the stderr descriptor type.
 #[inline]
 pub fn stderr_descriptor_type() -> OutputStreamDescriptor {
     STDERR_DESCRIPTOR_TYPE
@@ -898,7 +921,7 @@ pub fn stderr_descriptor_type() -> OutputStreamDescriptor {
         .copied()
         .unwrap_or(OutputStreamDescriptor::Unknown)
 }
-/// Safe getter (Zig: `Output.stdout_descriptor_type`).
+/// Safe getter for the stdout descriptor type.
 #[inline]
 pub fn stdout_descriptor_type() -> OutputStreamDescriptor {
     STDOUT_DESCRIPTOR_TYPE
@@ -943,14 +966,9 @@ pub fn is_ai_agent() -> bool {
         if env_var::REPL_ID.get().unwrap_or(false) {
             return true;
         }
-        // TODO: add environment variable for Gemini
-        // Gemini does not appear to add any environment variables to identify it.
-
-        // TODO: add environment variable for Codex
-        // codex does not appear to add any environment variables to identify it.
-
-        // TODO: add environment variable for Cursor Background Agents
-        // cursor does not appear to add any environment variables to identify it.
+        // Other agents we'd like to detect, but which do not appear to set
+        // any identifying environment variables: Gemini, Codex, Cursor
+        // Background Agents. Add checks here if they ever grow one.
         false
     }
 
@@ -1005,8 +1023,7 @@ pub fn disable_buffering() {
     }
 }
 
-/// RAII: `disable_buffering()` now, `enable_buffering()` on drop. Covers the
-/// Zig `Output.disableBuffering(); defer Output.enableBuffering();` pair used
+/// RAII: `disable_buffering()` now, `enable_buffering()` on drop. Used
 /// around child-process exec where the child writes directly to inherited
 /// stdio and Bun's buffer must not interleave.
 #[must_use = "dropping immediately re-enables buffering; bind to `let _scope = ...`"]
@@ -1031,12 +1048,10 @@ pub fn disable_buffering_scope() -> DisableBufferingScope {
 
 #[cold]
 pub fn panic(args: fmt::Arguments<'_>) -> ! {
-    // PORT NOTE: Zig branched on enable_ansi_colors_stderr to pick the comptime-colored
-    // vs stripped format string. In Rust callers use `panic!(pretty_fmt!(...))` directly;
-    // this fn is kept for non-macro callers and writes the (already-formatted) args.
-    // TODO(port): branch on ENABLE_ANSI_COLORS_STDERR once the colored vs
-    // stripped paths actually differ; callers should wrap fmt in
-    // `pretty_fmt!(.., enable_ansi_colors_stderr)`.
+    // Callers use `panic!(pretty_fmt!(...))`
+    // directly; this fn is kept for non-macro callers and writes the
+    // (already-formatted) args. Callers that want coloring wrap the fmt in
+    // `pretty_fmt!(.., enable_ansi_colors_stderr)` themselves.
     core::panic!("{args}");
 }
 
@@ -1045,12 +1060,13 @@ pub fn raw_error_writer() -> StreamType {
     SOURCE.with_borrow(|s| s.raw_error_stream)
 }
 
-// TODO: investigate migrating this to the buffered one.
+// Possible perf follow-up: migrate callers of these unbuffered accessors to
+// the buffered writer.
 //
-// TODO(port): these accessors hand out a `&'static mut` to a thread-local
-// `Source` field. The Zig original returned `*Writer` and callers used it
-// briefly. Returning `&'static mut` is *unsound* if two are alive at once, but
-// matches the Zig contract until callers migrate to `with_error_writer(|w| ..)`.
+// TODO: these accessors hand out a `&'static mut` to a thread-local
+// `Source` field, and callers only use it briefly. Returning `&'static mut`
+// is *unsound* if two are alive at once — a known-unsound shim until callers
+// migrate to `with_error_writer(|w| ..)`.
 //
 // `source_writer_escape` centralises the escape: one `unsafe` for all five
 // public `*_writer*()` accessors (nonnull-asref reduction: 5 sites → 1).
@@ -1061,7 +1077,7 @@ fn source_writer_escape(project: fn(&mut Source) -> &mut io::Writer) -> &'static
     // SAFETY: pointer escapes the RefCell borrow; the thread-local `Source`
     // backing field has a stable address once `Source::init` has run, and the
     // returned `&'static mut` is used briefly with no two live at once (see
-    // TODO(port) above — known-unsound shim until callers migrate).
+    // TODO above — known-unsound shim until callers migrate).
     unsafe { &mut *p }
 }
 
@@ -1143,9 +1159,8 @@ pub fn flush() {
 
 /// RAII guard that calls [`flush`] on `Drop`.
 ///
-/// This is the Rust spelling of Zig's `defer Output.flush();` — hold one of
-/// these across a scope with early returns to guarantee buffered stdout/stderr
-/// is drained on every exit path.
+/// Hold one of these across a scope with early returns to guarantee buffered
+/// stdout/stderr is drained on every exit path.
 #[must_use = "FlushGuard flushes on Drop; binding to `_` drops it immediately"]
 pub struct FlushGuard(());
 
@@ -1157,7 +1172,7 @@ impl Drop for FlushGuard {
 }
 
 /// Returns a guard that flushes buffered stdout & stderr when it goes out of
-/// scope. Equivalent to Zig's `defer Output.flush();`.
+/// scope.
 #[inline]
 pub fn flush_guard() -> FlushGuard {
     FlushGuard(())
@@ -1179,7 +1194,6 @@ impl fmt::Display for ElapsedFormatter {
         const FAST: u64 = NS_PER_MS * 10;
         const SLOW: u64 = NS_PER_MS * 8_000;
         let ms = self.duration_ns as f64 / NS_PER_MS as f64;
-        // PERF(port): was comptime bool dispatch on `colors` — profile if hot.
         match self.duration_ns {
             0..=FAST => {
                 if self.colors {
@@ -1214,17 +1228,15 @@ impl fmt::Display for ElapsedFormatter {
     }
 }
 
-// PORT NOTE: Zig's `printElapsedToWithCtx` passed the raw `<r><d>[...]<r>`
-// template to a `(comptime fmt, args)` printer (`prettyError`/`pretty`), which
-// then routed through `prettyTo` to branch on `enable_ansi_colors_{stdout,stderr}`.
-// In Rust the `pretty_fmt!` rewrite must happen at the macro call site, so the
+// The `pretty_fmt!` rewrite must happen at the macro call site, so the
 // public entry points (`print_elapsed`/`print_elapsed_stdout` below) inline the
 // match and call `pretty_error!`/`pretty!` directly — those macros emit both the
-// colored and stripped variants and let `pretty_to` pick at runtime. The
-// intermediate helper had no way to defer the color/no-color choice without
-// leaking raw `\x1b[` escapes when colors are disabled, so it was removed.
+// colored and stripped variants and let `pretty_to` pick at runtime. An
+// intermediate `fmt::Arguments`-taking helper had no way to defer the
+// color/no-color choice without leaking raw `\x1b[` escapes when colors are
+// disabled, so it was removed.
 
-// `print_elapsed_to` intentionally removed — see PORT NOTE above. The colored
+// `print_elapsed_to` intentionally removed — see the note above. The colored
 // template can't be deferred through an `fmt::Arguments`-taking printer without
 // either leaking raw escapes or stripping color, so callers must use
 // `print_elapsed` / `print_elapsed_stdout` (or `ElapsedFormatter` directly).
@@ -1279,7 +1291,7 @@ pub fn print_timer(timer: &mut impl ReadTimer) {
 // Print routing
 //
 // `print` / `printError` / `pretty*` are called from thousands of sites with
-// distinct comptime format strings. They used to be `noinline`, which forced
+// distinct format strings. They used to be `noinline`, which forced
 // one ~400-byte function body per (fmt, args-type) pair — about 2,650 of them,
 // or ~1 MB of .text in release builds. The bodies were nearly identical: pick
 // buffered-vs-unbuffered writer, then `Writer.print(fmt, args)`.
@@ -1298,10 +1310,9 @@ pub fn print_timer(timer: &mut impl ReadTimer) {
 /// `write_fmt`, which evaluates user `Display` impls that can re-enter this
 /// module (e.g. `debug_warn` → `print_to`, or `flush()`). If we materialized a
 /// `&mut io::Writer` here, the re-entrant call would produce a second `&mut`
-/// aliasing the first while it is still live — UB. Zig's `destWriter()`
-/// (output.zig:731-737) returns a raw `*std.Io.Writer` with no exclusivity
-/// contract, so callers must do the same and route writes through the vtable
-/// fn pointers directly (see `write_fmt_raw`).
+/// aliasing the first while it is still live — UB. So this hands out a raw
+/// pointer with no exclusivity contract, and callers must route writes
+/// through the vtable fn pointers directly (see `write_fmt_raw`).
 #[inline(never)]
 fn with_dest_writer<R>(dest: Destination, f: impl FnOnce(*mut io::Writer) -> R) -> R {
     debug_assert!(SOURCE_SET.get());
@@ -1373,13 +1384,13 @@ fn write_bytes(dest: Destination, bytes: &[u8]) {
 pub fn print_to(dest: Destination, args: fmt::Arguments<'_>) {
     #[cfg(target_arch = "wasm32")]
     {
-        // TODO(port): wasm console_log/console_error path via root.Uint8Array
+        // wasm32 is not built yet; output is dropped.
         let _ = (dest, args);
         return;
     }
-    // PERF(port): Zig had a comptime `hasNoArgs` fast path that emitted a single
-    // `writeBytes(dest, comptime_str)` per call site. `fmt::Arguments::as_str()` returns
-    // Some only when there are no interpolations, so this preserves the optimization.
+    // PERF: `fmt::Arguments::as_str()` returns Some only when there are no
+    // interpolations, giving a single `write_bytes(dest, str)` fast path per
+    // such call site.
     if let Some(s) = args.as_str() {
         return write_bytes(dest, s.as_bytes());
     }
@@ -1404,8 +1415,7 @@ pub fn print_errorable(args: fmt::Arguments<'_>) -> Result<(), crate::Error> {
 #[macro_export]
 macro_rules! println {
     ($fmt:expr $(, $arg:expr)* $(,)?) => {{
-        // `:expr` (not `:literal`) so `concat!(..)` templates compile —
-        // Zig `comptime fmt: string` accepts `"a" ++ "b"` (output.zig:781).
+        // `:expr` (not `:literal`) so `concat!(..)` templates compile.
         // `concat!` accepts a nested `concat!`, so the trailing-`{}` join works.
         const __NL: &str = $crate::output::_needs_nl($fmt);
         $crate::output::print_to(
@@ -1427,9 +1437,9 @@ macro_rules! debug {
     };
 }
 
-/// NOTE: unlike Zig output.zig:794-797, this fn form cannot inspect the
-/// comptime template and therefore *always* appends `\n`. Callers must NOT
-/// pass a template that already ends in `\n`. Prefer the `debug!` macro.
+/// NOTE: this fn form cannot inspect the template and therefore *always*
+/// appends `\n`. Callers must NOT pass a template that already ends in `\n`.
+/// Prefer the `debug!` macro.
 #[inline]
 pub(crate) fn _debug(args: fmt::Arguments<'_>) {
     debug_assert!(SOURCE_SET.get());
@@ -1485,13 +1495,14 @@ impl Visibility {
 
 /// Runtime state for one scoped logger. One static instance per `declare_scope!`.
 pub struct ScopedLogger {
-    pub tagname: &'static str, // already lowercased
+    // As-declared (`stringify!`) casing; lowered for display via `_LowerTag`,
+    // and env/flag matching is case-insensitive.
+    pub tagname: &'static str,
     really_disable: AtomicBool,
     is_visible_once: std::sync::Once,
     lock: Mutex<()>,
-    out_set: AtomicBool,
-    // TODO(port): per-scope buffered writer (`buffer: [4096]u8` + adapter). For now route
-    // through `scoped_writer()` directly; could reintroduce per-scope buffering.
+    // There is no per-scope `[4096]u8` buffered writer; logs route
+    // through `scoped_writer()` directly (debug-logging perf only).
 }
 
 impl ScopedLogger {
@@ -1501,13 +1512,12 @@ impl ScopedLogger {
             really_disable: AtomicBool::new(matches!(visibility, Visibility::Hidden)),
             is_visible_once: std::sync::Once::new(),
             lock: Mutex::new(()),
-            out_set: AtomicBool::new(false),
         }
     }
 
     fn evaluate_is_visible(&self) {
-        // BUN_DEBUG_<tagname> — Zig builds this with comptime `++` (no length cap),
-        // so size the buffer from the tag instead of a fixed `[u8; 64]`.
+        // BUN_DEBUG_<tagname> — tag length is uncapped, so size the buffer
+        // from the tag instead of a fixed `[u8; 64]`.
         let tag = self.tagname.as_bytes();
         let prefix = b"BUN_DEBUG_";
         let key_len = prefix.len() + tag.len();
@@ -1580,24 +1590,19 @@ impl ScopedLogger {
             return;
         }
 
-        // TODO(port): per-scope `[4096]u8` buffered adapter (`out`/`out_set`/`buffered_writer`)
-        let _ = self.out_set.load(Ordering::Relaxed);
-
         let _lock = self.lock.lock();
 
         let mut out = scoped_writer();
-        // PERF(port): was comptime bool dispatch on use_ansi — profile if hot.
         // The colored/plain selection now happens at the `scoped_log!` call site
         // (single arg evaluation) via `_scoped_use_ansi()`.
         let result = out.write_fmt(args);
         if result.is_err() {
-            // Zig: write failure → disable scope and skip the flush.
+            // Write failure → disable scope and skip the flush.
             self.really_disable.store(true, Ordering::Relaxed);
             return;
         }
-        // TODO(port): Zig also disables on flush failure; QuietWriter::flush()
-        // currently returns () via the SysHooks vtable so flush errors are not
-        // observable here. Surface a Result once bun_sys exposes it.
+        // `QuietWriter::flush()` returns `()` through the OutputSink vtable,
+        // so flush errors are not observable here (debug logging only).
         out.flush();
     }
 }
@@ -1615,7 +1620,8 @@ macro_rules! declare_scope {
         // in downstream crates; allow it at every expansion site.
         #[allow(non_upper_case_globals, unreachable_pub)]
         pub static $name: $crate::output::ScopedLogger = $crate::output::ScopedLogger::new(
-            // TODO(port): lowercase tagname at compile time (Zig did std.ascii.toLower)
+            // Matching is case-insensitive and display lowering happens via
+            // `_LowerTag`.
             stringify!($name),
             $crate::output::Visibility::Hidden,
         );
@@ -1641,9 +1647,8 @@ macro_rules! scoped_log {
         if cfg!(debug_assertions) && $scope.is_visible() {
             const __NL: &str = $crate::output::_needs_nl($crate::pretty_fmt!($fmt, false));
             // Branch on ANSI *before* `format_args!` so each `$arg` evaluates
-            // exactly once (Zig builds the args tuple once — output.zig:922-933).
-            // Prefix `[tag]` is built at runtime from `$scope.tagname` lowercased
-            // (Zig: output.zig:826-835 lowercases via `std.ascii.toLower`).
+            // exactly once.
+            // Prefix `[tag]` is built at runtime from `$scope.tagname` lowercased.
             if $crate::output::_scoped_use_ansi() {
                 $scope.log(::core::format_args!(
                     concat!(
@@ -1701,8 +1706,7 @@ macro_rules! define_scoped_log {
 }
 
 /// `Display` adapter that lowercases an ASCII tag on the fly. Used by
-/// `scoped_log!` so the printed `[tag]` prefix matches Zig's
-/// `std.ascii.toLower`-folded `tagname` (output.zig:826-835) without needing a
+/// `scoped_log!` so the printed `[tag]` prefix is lowercased without needing a
 /// compile-time lowercasing proc-macro.
 #[doc(hidden)]
 pub struct _LowerTag(pub &'static str);
@@ -1742,10 +1746,9 @@ pub fn clear_to_end() {
 // </r> - reset
 // <r> - reset
 
-/// Lowercase lookup wrapper (Zig: `Output.color_map.get(name)`). The table
+/// Lowercase lookup wrapper. The table
 /// itself lives in `bun_output_tags` (shared with the `pretty_fmt!` proc-macro
-/// so there is exactly one copy); this fn-module mirrors the Zig
-/// `ComptimeStringMap` `.get()` surface.
+/// so there is exactly one copy).
 pub mod color_map {
     #[inline]
     pub fn get(name: &[u8]) -> Option<&'static str> {
@@ -1756,10 +1759,10 @@ pub mod color_map {
 pub use ansi::{BOLD, DIM, RESET};
 pub use bun_output_tags::{ansi, ansi_b};
 
-/// `bun.Output.pretty(fmt, args)` — write to stdout with `<tag>` color expansion.
+/// Write to stdout with `<tag>` color expansion.
 /// Function form: performs the `<tag>` → ANSI rewrite at runtime on the rendered
 /// payload (using stdout's colour state). Prefer the `pretty!` macro for literal
-/// templates so the rewrite stays comptime.
+/// templates so the rewrite happens at compile time.
 ///
 /// `inline(always)`: with plain `#[inline]` the `<core::fmt::Arguments>`
 /// monomorphization materializes once in `bun_runtime` and every other crate's
@@ -1774,8 +1777,8 @@ pub fn pretty(payload: impl PrettyFmtInput) {
 
 /// `bun.Output.prettyln(fmt, args)` — `pretty()` with a trailing newline.
 /// Function form: performs the `<tag>` → ANSI rewrite at runtime on the rendered
-/// payload and appends `\n` if the result does not already end in one (matches
-/// Zig output.zig:1090-1093). Prefer the `prettyln!` macro for literal templates.
+/// payload and appends `\n` if the result does not already end in one.
+/// Prefer the `prettyln!` macro for literal templates.
 /// `inline(always)` for the same .text-layout reason as [`pretty`].
 #[inline(always)]
 pub fn prettyln(payload: impl PrettyFmtInput) {
@@ -1788,15 +1791,14 @@ pub fn prettyln(payload: impl PrettyFmtInput) {
 
 /// Compile-time `<tag>` → ANSI escape rewriter.
 ///
-/// In Zig this was a `comptime` function building a `[:0]const u8`. In Rust the
-/// equivalent must be a proc-macro because it consumes a string literal and emits
+/// This must be a proc-macro because it consumes a string literal and emits
 /// a new string literal usable as a `format_args!` template.
 ///
 /// `pretty_fmt!("<red>{s}<r>", true)`  → `"\x1b[31m{}\x1b[0m"`
 /// `pretty_fmt!("<red>{s}<r>", false)` → `"{}"`
 ///
-/// The reference algorithm is `pretty_fmt_runtime` below (kept 1:1 with the Zig
-/// body so the proc-macro can be tested against it).
+/// The reference algorithm is `pretty_fmt_runtime` below (the proc-macro is
+/// tested against it).
 pub use bun_core_macros::pretty_fmt;
 
 /// Input accepted by [`pretty_fmt`]: either a `&str`/`&[u8]` template or a
@@ -1834,8 +1836,8 @@ impl PrettyFmtInput for fmt::Arguments<'_> {
 }
 
 /// `Output.prettyFmt` — runtime `<tag>` → ANSI rewrite. Const-generic
-/// `ENABLE_ANSI_COLORS` mirrors the Zig `comptime is_enabled: bool` parameter
-/// so callers can do `Output::pretty_fmt::<ENABLE_ANSI_COLORS>("…")`.
+/// `ENABLE_ANSI_COLORS` lets callers do
+/// `Output::pretty_fmt::<ENABLE_ANSI_COLORS>("…")`.
 ///
 /// For a runtime bool (e.g. from `enable_ansi_colors_stderr()`), see
 /// [`pretty_fmt_rt`].
@@ -1886,9 +1888,7 @@ impl fmt::Display for PrettyBuf {
 }
 
 // ── FmtTuple ──────────────────────────────────────────────────────────────
-// Zig `fn print(comptime fmt: []const u8, args: anytype)` takes a tuple of
-// arguments and substitutes positionals. The Rust port models `args: anytype`
-// as `impl FmtTuple` so call sites can pass `()`, `(a,)`, `(a, b)`, … or a
+// `impl FmtTuple` lets call sites pass `()`, `(a,)`, `(a, b)`, … or a
 // pre-built `fmt::Arguments<'_>` (treated as a single positional).
 
 /// Positional-argument bundle for runtime template substitution.
@@ -2056,12 +2056,12 @@ pub fn pretty_fmt_args<A: FmtTuple>(
     }
 }
 
-/// Runtime mirror of Zig `prettyFmt` for testing the proc-macro and for the rare
-/// dynamic case. Produces the same byte sequence the Zig comptime version would.
+/// Runtime `<tag>` → ANSI rewriter, used for testing the proc-macro and for
+/// the rare dynamic case.
 ///
 /// Colour table lives in `bun_output_tags`; the state machine is kept duplicated
 /// vs `bun_core_macros::rewrite` because the two intentionally diverge in the
-/// `{` arm (proc-macro rewrites Zig specs `{s}`→`{}`; this side copies braces
+/// `{` arm (proc-macro rewrites specs `{s}`→`{}`; this side copies braces
 /// verbatim) and on unknown tags (proc-macro errors; this side emits `""`).
 pub fn pretty_fmt_runtime(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
     let mut out = Vec::with_capacity(fmt.len() * 4);
@@ -2111,8 +2111,9 @@ pub fn pretty_fmt_runtime(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                         is_reset = true;
                         break 'picker "";
                     } else {
-                        // Zig: @compileError — runtime version returns empty
-                        // TODO(port): proc-macro emits compile_error! here
+                        // Unknown tag: the `pretty_fmt!` proc-macro rejects
+                        // this at its call sites; this runtime path drops the
+                        // tag.
                         break 'picker "";
                     }
                 };
@@ -2142,8 +2143,7 @@ pub fn enable_color_for(dest: Destination) -> bool {
     }
 }
 
-/// Returns `"\n"` if `fmt` does not already end in a newline, else `""`.
-/// Mirrors Zig's `if (fmt.len == 0 or fmt[fmt.len - 1] != '\n')` guard so the
+/// Returns `"\n"` if `fmt` does not already end in a newline, else `""`, so the
 /// `*ln!` macros never emit a double newline when the caller's template already
 /// ends in one.
 #[doc(hidden)]
@@ -2172,9 +2172,7 @@ pub fn _scoped_use_ansi() -> bool {
 
 /// Internal: bind each `$arg` exactly once into a `match` tuple, then dispatch
 /// on the per-destination color flag and call `print_to` with the appropriate
-/// `pretty_fmt!`-expanded template. Mirrors Zig's `prettyTo` which receives the
-/// args tuple already evaluated and only branches on the color flag
-/// (output.zig:1066-1074).
+/// `pretty_fmt!`-expanded template.
 ///
 /// The recursive `@go` arm zips each user arg with a name from `pool` so the
 /// emitted `match (&a, &b, ..)` pattern can rebind them as plain idents — both
@@ -2294,8 +2292,7 @@ macro_rules! prettyln {
 #[macro_export]
 macro_rules! print_errorln {
     ($fmt:expr $(, $arg:expr)* $(,)?) => {{
-        // `:expr` (not `:literal`) so `concat!(..)` templates compile —
-        // Zig `comptime fmt: string` accepts `"a" ++ "b"` (output.zig:1095).
+        // `:expr` (not `:literal`) so `concat!(..)` templates compile.
         const __NL: &str = $crate::output::_needs_nl($fmt);
         $crate::output::print_to(
             $crate::output::Destination::Stderr,
@@ -2329,8 +2326,7 @@ macro_rules! pretty_errorln {
 /// sink, branching on a (possibly const-generic) color flag so each branch gets
 /// the proc-macro-expanded literal template.
 ///
-/// Port of Zig `writer.print(comptime Output.prettyFmt(FMT, enable_ansi_colors), .{args})`
-/// for `writeFormat`-style impls that take `comptime enable_ansi_colors: bool`.
+/// For `writeFormat`-style impls that take an `enable_ansi_colors: bool`.
 /// The `pretty_fmt!` proc-macro requires a `true`/`false` *literal*, so the
 /// const-generic is dispatched here; only one arm executes at runtime, so each
 /// `$arg` evaluates exactly once.
@@ -2347,8 +2343,7 @@ macro_rules! write_pretty {
 
 // ── printCommand ──────────────────────────────────────────────────────────
 
-/// Argument shape accepted by `command`/`commandOut`. Mirrors the Zig `anytype`
-/// switch over `[][]const u8` vs `[]const u8`.
+/// Argument shape accepted by `command`/`commandOut`.
 #[derive(Clone, Copy)]
 pub enum CommandArgv<'a> {
     List(&'a [&'a [u8]]),
@@ -2407,12 +2402,12 @@ pub fn print_error(args: impl core::fmt::Display) {
     print_to(Destination::Stderr, format_args!("{args}"));
 }
 
-/// `Output.printErrorln` — function form (the `print_errorln!` macro at crate
-/// root is the comptime-string variant). Takes anything `Display` so both
+/// Function form (the `print_errorln!` macro at crate
+/// root is the compile-time-string variant). Takes anything `Display` so both
 /// `format_args!(..)` and bare `&str` call sites compile; appends `\n`.
 ///
-/// NOTE: unlike the macro (and Zig output.zig:1095-1098), this fn form cannot
-/// inspect the comptime template and therefore *always* appends `\n`. Callers
+/// NOTE: unlike the macro, this fn form cannot
+/// inspect the template and therefore *always* appends `\n`. Callers
 /// must NOT pass a template that already ends in `\n` or output will contain a
 /// doubled newline. Prefer the `print_errorln!` macro where possible.
 #[inline]
@@ -2421,7 +2416,7 @@ pub fn print_errorln(args: impl core::fmt::Display) {
 }
 
 /// `Output.enable_ansi_colors_stdout` — safe relaxed-load wrapper over the
-/// startup-initialized atomic. Mirrors the Zig public-var read.
+/// startup-initialized atomic.
 #[inline]
 pub fn enable_ansi_colors_stdout() -> bool {
     ENABLE_ANSI_COLORS_STDOUT.load(Ordering::Relaxed)
@@ -2501,24 +2496,22 @@ macro_rules! debug_warn {
     };
 }
 
-/// Print a red error message. The first argument takes an `error_name` value, which can be either
-/// be a Zig error, or a string or enum. The error name is converted to a string and displayed
+/// Print a red error message. The first argument takes an `error_name` value, which can
+/// be an error, a string, or an enum. The error name is converted to a string and displayed
 /// in place of "error:", making it useful to print things like "EACCES: Couldn't open package.json"
 ///
-/// The Zig original switched on `@typeInfo` of `error_name`. The Rust port accepts anything
+/// Accepts anything
 /// implementing `ErrName` (impl'd for `&[u8]`, `&str`, `bun_core::Error`, `bun_sys::Error`,
 /// and any `#[derive(strum::IntoStaticStr)]` enum).
-// TODO(port): the comptime-literal fast path (is_comptime_name) is dropped —
-// could be recovered with a proc-macro overload that detects string literals.
+// Literal tags go through the same runtime rendering as everything else.
 //
 // By-value `error_name` is intentional: callers pass `"EACCES"` / `b"tag"` /
 // `bun_core::Error` (Copy) and `bun_sys::Error` (non-Copy, consumed). Taking
 // `&impl ErrName` would force `&"literal"` at every site.
 #[allow(clippy::needless_pass_by_value)] // by-value for call-site ergonomics; see above
 pub fn err(error_name: impl ErrName, fmt: &str, args: impl FmtTuple) {
-    // Zig concatenates `fmt` into the prettyErrorln template, whose trailing-\n
-    // check then sees the caller's newline. Here `fmt` is rendered into a `{}`
-    // arg, so strip a trailing \n and let pretty_errorln! add exactly one.
+    // `fmt` is rendered into a `{}` arg, so strip a trailing \n and let
+    // pretty_errorln! add exactly one.
     let fmt = fmt.strip_suffix('\n').unwrap_or(fmt);
     let body = pretty_fmt_args(fmt, enable_ansi_colors_stderr(), args);
     if let Some(e) = error_name.as_sys_err_info() {
@@ -2578,7 +2571,7 @@ pub struct SysErrInfo {
     pub syscall: &'static str,
 }
 
-/// Trait abstracting the `@typeInfo` switch in Zig `err()`.
+/// Trait abstracting the error-name shapes accepted by `err()`.
 ///
 /// `as_sys_err_info()` replaces the former `as_sys_error() -> Option<&bun_sys::Error>`:
 /// bun_core (T0) can't name `bun_sys::Error` (T1). bun_sys impls `ErrName` for
@@ -2604,9 +2597,10 @@ impl ErrName for crate::Error {
         (*self).name().as_bytes()
     }
 }
-// TODO(port): `impl ErrName for bun_sys::Error` and `bun_sys::SystemErrno` arrive
-// via move-in pass in bun_sys (orphan rule allows higher tier to impl this trait).
-// TODO(port): blanket impl for `T: Into<&'static str>` (strum enums) once coherence allows.
+// Higher-tier impls live with their types (orphan rule allows it):
+// `bun_sys::Error` (src/sys/Error.rs) and `SystemErrno` (src/errno/lib.rs).
+// A blanket impl for `T: Into<&'static str>` (strum enums) is coherence-blocked;
+// each enum impls `ErrName` explicitly instead.
 
 // ── ScopedDebugWriter ─────────────────────────────────────────────────────
 
@@ -2620,8 +2614,7 @@ pub mod scoped_debug_writer {
         pub(crate) static DISABLE_INSIDE_LOG: Cell<isize> = const { Cell::new(0) };
     }
 
-    /// RAII guard that suppresses scoped logging for the lifetime of the guard
-    /// (Zig: `disable_inside_log += 1; defer disable_inside_log -= 1;`).
+    /// RAII guard that suppresses scoped logging for the lifetime of the guard.
     #[must_use]
     pub(crate) struct DisableGuard(());
 
@@ -2642,11 +2635,9 @@ pub mod scoped_debug_writer {
 }
 
 pub fn disable_scoped_debug_writer() {
-    // Zig: `if (!@inComptime())` — always runtime in Rust.
     scoped_debug_writer::DISABLE_INSIDE_LOG.set(scoped_debug_writer::DISABLE_INSIDE_LOG.get() + 1);
 }
 
-// TODO(port): move to bun_core_sys
 unsafe extern "C" {
     /// No preconditions; returns the calling process's PID.
     safe fn getpid() -> c_int;
@@ -2677,10 +2668,6 @@ pub(crate) fn init_scoped_debug_writer_at_startup() {
                     bstr::BStr::new(path),
                 )),
             };
-            // TODO(port): bun_sys::Fd::truncate (Windows-only); add to OutputSinkVTable.
-            // `create_file` above already opens for writing with truncate, so the explicit
-            // `fd.truncate(0)` from Zig is a no-op here until the vtable entry lands.
-            let _ = &fd; // windows
             // SAFETY: single-threaded startup.
             unsafe {
                 scoped_debug_writer::SCOPED_FILE_WRITER
@@ -2698,11 +2685,9 @@ pub(crate) fn init_scoped_debug_writer_at_startup() {
 }
 
 fn scoped_writer() -> QuietWriter {
-    // Zig used `@compileError` here (output.zig:1320-1325) which is lazy — it
-    // only fires if `scopedWriter()` is referenced, and in release Zig the
-    // `Scoped()` no-op struct never references it. Rust's `compile_error!` is
-    // eager and would break every release build, so assert at runtime instead.
-    // All callers are already gated on `Environment::ENABLE_LOGS`.
+    // Assert at runtime rather than compile time (a `compile_error!` here
+    // would break every release build); all callers are already gated on
+    // `Environment::ENABLE_LOGS`.
     #[cfg(debug_assertions)]
     if !Environment::ENABLE_LOGS {
         unreachable!("scopedWriter() should only be called in debug mode");
@@ -2730,8 +2715,7 @@ pub fn err_fmt(formatter: impl fmt::Display) {
 // ──────────────────────────────────────────────────────────────────────────
 // Stdin readers (CYCLEBREAK §Dispatch cold path)
 //
-// Zig's `bun.Output.buffered_stdin` is a `bun.deprecated.BufferedReader(4096,
-// File.Reader)`. The concrete `File.Reader` lives in bun_sys; bun_core routes
+// The concrete `File.Reader` lives in bun_sys; bun_core routes
 // the underlying `read(2)` through the [`OutputSinkVTable::read`] slot so the
 // `prompt`/`init`/`publish` callers can read stdin without naming bun_sys.
 // ──────────────────────────────────────────────────────────────────────────
@@ -2765,17 +2749,16 @@ pub struct BufferedStdin {
 }
 
 impl BufferedStdin {
-    /// Zig `BufferedReader.reader()` — the std adapter just hands back `&mut
-    /// Self` (which already exposes `read`/`read_byte`).
+    /// Hands back `&mut Self` (which already exposes `read`/`read_byte`).
     #[inline]
     pub fn reader(&mut self) -> &mut Self {
         self
     }
 
-    /// Zig `BufferedReader.read` — fill `dest` from the buffer, refilling from
+    /// Fill `dest` from the buffer, refilling from
     /// the underlying fd until `dest` is full or EOF. Returns `Ok(0)` on EOF.
     ///
-    /// PORT NOTE: matches std `BufferedReader.read` fill-to-completion semantics
+    /// Matches std `BufferedReader.read` fill-to-completion semantics
     /// (loops on the underlying fd), not POSIX partial-read.
     pub fn read(&mut self, dest: &mut [u8]) -> Result<usize, crate::Error> {
         let mut written: usize = 0;
@@ -2811,8 +2794,7 @@ impl BufferedStdin {
         }
     }
 
-    /// Zig `GenericReader.readByte` — `Err` on I/O error *or* EOF (matches
-    /// `error.EndOfStream`).
+    /// Read one byte — `Err` on I/O error *or* EOF (`EndOfStream`).
     pub fn read_byte(&mut self) -> Result<u8, crate::Error> {
         if self.start < self.end {
             let b = self.buf[self.start];
@@ -2826,7 +2808,7 @@ impl BufferedStdin {
         }
     }
 
-    /// Zig `GenericReader.readUntilDelimiterArrayList` — appends bytes (not
+    /// Appends bytes (not
     /// including `delimiter`) into `out`; errors with `StreamTooLong`
     /// semantics if `out.len()` would exceed `max_size`.
     pub fn read_until_delimiter_array_list(
@@ -2849,14 +2831,14 @@ impl BufferedStdin {
     }
 }
 
-/// Unbuffered stdin byte reader (`std.fs.File.stdin().readerStreaming(..)` in
-/// the Zig). Each `take_byte` is a 1-byte blocking read on the process stdin.
+/// Unbuffered stdin byte reader.
+/// Each `take_byte` is a 1-byte blocking read on the process stdin.
 pub struct StdinReader {
     fd: Fd,
 }
 
 impl StdinReader {
-    /// Zig `Reader.takeByte` — `Err` on I/O error *or* EOF.
+    /// Read one byte — `Err` on I/O error *or* EOF.
     #[inline]
     pub fn take_byte(&mut self) -> Result<u8, crate::Error> {
         let mut one = [0u8; 1];
@@ -2872,7 +2854,7 @@ impl StdinReader {
     }
 }
 
-/// `std.fs.File.stdin().readerStreaming(&buf)` — fresh, unbuffered stdin
+/// Fresh, unbuffered stdin
 /// reader. Used by `alert()`/`confirm()` which read a handful of bytes.
 #[inline]
 pub fn stdin_reader() -> StdinReader {
@@ -2892,11 +2874,9 @@ pub fn stdin_reader() -> StdinReader {
 #[inline]
 pub fn buffered_stdin() -> *mut BufferedStdin {
     BUFFERED_STDIN.get()
-    // TODO(port): self-ref pointer escape — see error_writer()
 }
 
-/// `bun.Output.buffered_stdin.reader()` — same accessor as [`buffered_stdin`];
-/// the Zig spelling exposed the static itself and callers chained `.reader()`.
+/// `bun.Output.buffered_stdin.reader()` — same accessor as [`buffered_stdin`].
 #[inline]
 pub fn buffered_stdin_reader() -> *mut BufferedStdin {
     buffered_stdin()
@@ -2947,13 +2927,12 @@ impl Synchronized {
 mod output_macro_tests {
     //! Compile-shape regression tests for the `pretty*!`/`note!`/`warn!`/
     //! `debug!` wrapper macros. These don't drive a live `Source` (no I/O);
-    //! they assert that the macros *expand* for the shapes the Zig originals
-    //! accept and that the `*ln!` newline guard const-evaluates correctly.
+    //! they assert that the macros *expand* for the expected call shapes
+    //! and that the `*ln!` newline guard const-evaluates correctly.
     use super::_needs_nl;
     use bun_core_macros::pretty_fmt;
 
-    /// `note!`/`warn!`/`debug!` must accept a `concat!(..)` template — Zig's
-    /// `note(comptime fmt, args)` is routinely called with `"a" ++ "b"`. The
+    /// `note!`/`warn!`/`debug!` must accept a `concat!(..)` template. The
     /// `:literal` matcher rejected this; `:expr` + proc-macro `concat!`
     /// flattening makes it compile.
     #[test]
@@ -3018,7 +2997,7 @@ mod output_macro_tests {
 #[cfg(test)]
 mod pretty_fmt_tests {
     //! Parity checks between the `pretty_fmt!` proc-macro (compile-time) and
-    //! `pretty_fmt_runtime` (1:1 port of Zig `prettyFmt`). Guards against the
+    //! `pretty_fmt_runtime`. Guards against the
     //! macro leaking raw `<r>`/`<b>` markup into help text.
     use super::{RESET, pretty_fmt_runtime};
     use bun_core_macros::pretty_fmt;
@@ -3111,8 +3090,8 @@ mod pretty_fmt_tests {
 
     #[test]
     fn macro_matches_runtime() {
-        // Spot-check macro output against the runtime reference (which is 1:1
-        // with Zig `prettyFmt`) for the help-text shapes that matter.
+        // Spot-check macro output against the runtime reference for the
+        // help-text shapes that matter.
         macro_rules! check {
             ($s:literal) => {{
                 assert_eq!(
@@ -3137,5 +3116,3 @@ mod pretty_fmt_tests {
         );
     }
 }
-
-// ported from: src/bun_core/output.zig
diff --git a/src/bun_core/result.rs b/src/bun_core/result.rs
index d9d9db3dc14..a7bb932f35b 100644
--- a/src/bun_core/result.rs
+++ b/src/bun_core/result.rs
@@ -1,19 +1,17 @@
-// ─── bun_core::Error — Zig `anyerror` port ────────────────────────────────
+// ─── bun_core::Error — global named-error set ──────────────────────────────
 //
-// Zig's `anyerror` is a global error set: every distinct `error.Foo` name in
-// the program is assigned a unique non-zero u16 at link time, `@intFromError`
-// returns that code, `@errorName` recovers the string, and two `error.Foo`s
-// from different modules compare equal because the *name* is the identity.
+// Every distinct error name in the program is assigned a unique non-zero u16;
+// the *name* is the identity, so two errors with the same name from different
+// modules compare equal.
 //
 // Rust has no link-time global enum, so we intern at runtime: a process-wide
 // append-only `&'static str` table guarded by an RwLock. The `err!()` macro
 // caches each call-site's code in a 2-byte `AtomicU16` slot (zero-init →
 // `.bss`), so the lock is touched once per *name-site*, not once per call —
-// matching Zig's zero-cost comparison (`e == err!(Foo)` is a u16 compare
-// after first use).
+// `e == err!(Foo)` is a zero-cost u16 compare after first use.
 //
 // Layout is `#[repr(transparent)] NonZeroU16`, so `Option<Error>` is one u16
-// and FFI/packed-struct slots that held a Zig `anyerror` keep the same width.
+// and fits FFI/packed-struct slots holding a 16-bit error code.
 
 use crate::RwLock;
 use core::fmt;
@@ -33,8 +31,8 @@ pub struct Error(NonZeroU16);
 /// the `pub const` Errors below. (The errno→name map lives in bun_errno via the
 /// `ErrnoNames` hook; entries here are only fast-path intern hits.)
 const SEED: &[&str] = &[
-    // — well-known Zig error-set members the runtime matches on by value —
-    "Unexpected",      // 1  (Zig's catch-all; also `errno_map` default)
+    // — well-known error names the runtime matches on by value —
+    "Unexpected",      // 1  (catch-all; also `errno_map` default)
     "OutOfMemory",     // 2
     "EndOfStream",     // 3
     "StreamTooLong",   // 4
@@ -143,8 +141,7 @@ impl Error {
     pub const TODO: Self = Self::UNEXPECTED;
 
     /// Intern `name`, returning its process-unique code. Idempotent: the same
-    /// string (by value) always yields the same `Error`. This is the runtime
-    /// half of Zig's link-time `anyerror` assignment.
+    /// string (by value) always yields the same `Error`.
     ///
     /// `#[cold]`: only reached on a per-site cache miss (or `err!(from e)`);
     /// keeps the SEED scan + RwLock probe out of `.text.hot` so
@@ -174,7 +171,7 @@ impl Error {
         Self::intern(name)
     }
 
-    /// Zig: `@errorName(e)`. Never allocates; the table only stores `'static`.
+    /// The error's name. Never allocates; the table only stores `'static`.
     pub fn name(self) -> &'static str {
         let code = self.0.get() as usize;
         if code <= SEED.len() {
@@ -187,13 +184,13 @@ impl Error {
             .unwrap_or("Unexpected")
     }
 
-    /// Zig: `@intFromError(e)`.
+    /// The raw u16 code.
     #[inline]
     pub const fn as_u16(self) -> u16 {
         self.0.get()
     }
 
-    /// Zig: `@errorFromInt(n)`. `0` (the "no error" value Zig forbids) maps to
+    /// `0` (the "no error" value) maps to
     /// `Unexpected` rather than panicking, since callers feed untrusted ints.
     #[inline]
     pub const fn from_raw(code: u16) -> Self {
@@ -203,17 +200,15 @@ impl Error {
         }
     }
 
-    /// Port of `bun.errnoToZigErr`: map a raw OS errno to its named error.
-    /// Unknown errnos collapse to `Unexpected` (matching the Zig `@memset`).
+    /// Map a raw OS errno to its named error.
+    /// Unknown errnos collapse to `Unexpected`.
     pub fn from_errno(errno: i32) -> Self {
-        // Zig builds `errno_map: [max+1]anyerror` at comptime (bun.zig:2841);
-        // we build the equivalent once at first use by interning every
+        // Build the dense errno map once at first use by interning every
         // platform `SystemErrno` tag name. After init, lookup is a plain
-        // bounds-checked array index — same cost as the Zig version.
+        // bounds-checked array index.
         static ERRNO_MAP: crate::Once<Box<[Error]>> = crate::Once::new();
         let map = ERRNO_MAP.get_or_init(|| {
-            // Index 0 ("SUCCESS") is the no-error hole → Unexpected,
-            // matching the Zig `@memset(&map, error.Unexpected)`.
+            // Index 0 ("SUCCESS") is the no-error hole → Unexpected.
             (0..crate::ErrnoNames::SYS.max_dense())
                 .map(|i| match system_errno_name(i as i32) {
                     Some(name) => Error::intern(name),
@@ -222,7 +217,7 @@ impl Error {
                 .collect()
         });
 
-        // Windows libuv errnos are negative; normalise like the Zig original.
+        // Windows libuv errnos are negative; take the absolute value.
         let n = if cfg!(windows) {
             errno.unsigned_abs()
         } else {
@@ -235,8 +230,7 @@ impl Error {
             return e;
         }
         // Windows: fall through to the sparse UV_* range (3000..=4096) so e.g.
-        // `from_errno(-4058)` → `error.UV_ENOENT`, matching Zig's full-width
-        // `errno_map` (bun.zig:2841-2851 sizes it to `max(@intFromEnum)+1`).
+        // `from_errno(-4058)` → `error.UV_ENOENT`.
         #[cfg(windows)]
         if let Some(name) = system_errno_name(errno) {
             return Self::intern(name);
@@ -265,15 +259,16 @@ impl From<std::io::Error> for Error {
             // Windows: `raw_os_error()` returns the raw Win32 `GetLastError()`
             // code (ERROR_ACCESS_DENIED=5, ERROR_SHARING_VIOLATION=32, …),
             // NOT a `SystemErrno`. Routing it through `ErrnoNames::SYS.name()` would
-            // alias garbage (5→EIO, 32→EPIPE). The Zig pipeline first runs
-            // `Win32Error.toSystemErrno()` (windows_errno.zig:290) before any
-            // `errno_map` lookup; that table lives in `bun_errno`, which is
-            // tier-above `bun_core` (dep cycle), so we can't call it here.
-            // Fall back to `Unexpected` rather than return a wrong name.
-            // TODO(port): plumb a Win32→SystemErrno hook (or duplicate the
-            // table) so `?`-propagated `io::Error`s name correctly on Windows.
+            // alias garbage (5→EIO, 32→EPIPE). Translate Win32 → SystemErrno
+            // first; that table lives in `bun_errno`
+            // (tier-above `bun_core`, dep cycle), reached via the `win32_name`
+            // method on the `ErrnoNames` link-interface. Unknown codes still
+            // collapse to `Unexpected` rather than aliasing a wrong name.
             #[cfg(windows)]
-            Some(_code) => Self::UNEXPECTED,
+            Some(code) => match crate::ErrnoNames::SYS.win32_name(code as u32) {
+                Some(name) => Self::intern(name),
+                None => Self::UNEXPECTED,
+            },
             None => Self::UNEXPECTED,
         }
     }
@@ -283,10 +278,9 @@ impl From<bun_alloc::AllocError> for Error {
         Self::OUT_OF_MEMORY
     }
 }
-/// Zig's `std.Io.Writer` error set surfaces as `error.WriteFailed` when
-/// propagated through `try writer.print(…)`; the Rust port routes formatted
-/// output through `core::fmt::Write`, whose only error value is the unit
-/// `fmt::Error`. Map it to the same tag so `?`-propagation matches the spec.
+/// Formatted output routes through `core::fmt::Write`, whose only error value
+/// is the unit `fmt::Error`. Map it to the `WriteFailed` tag so `?`-propagation
+/// yields a named error.
 impl From<core::fmt::Error> for Error {
     fn from(_: core::fmt::Error) -> Self {
         Self::WRITE_FAILED
@@ -295,9 +289,8 @@ impl From<core::fmt::Error> for Error {
 
 /// Extension for `?`-propagating non-`fmt::Error` write failures (e.g.
 /// `std::io::Error` from `write!(&mut Vec<u8>, …)` / `Cursor` / `BufWriter`)
-/// as the spec's `error.WriteFailed` tag. Bare `?` on those would route through
-/// [`From<std::io::Error>`] → errno/`Unexpected`, which diverges from the Zig
-/// `try writer.print(…)` contract. Replaces the open-coded
+/// as the `error.WriteFailed` tag. Bare `?` on those would route through
+/// [`From<std::io::Error>`] → errno/`Unexpected` instead. Replaces the open-coded
 /// `.map_err(|_| err!("WriteFailed"))` pattern at ~20 call sites.
 pub trait OrWriteFailed<T> {
     fn or_write_failed(self) -> core::result::Result<T, Error>;
@@ -343,7 +336,7 @@ macro_rules! named_error_set {
 
 /// Stamp out `impl Display + impl Error` for one or more
 /// `strum::IntoStaticStr`-deriving error enums whose user-facing string is
-/// exactly the variant tag (Zig `@errorName(e)` semantics). Replaces the
+/// exactly the variant tag. Replaces the
 /// hand-rolled 5-line `f.write_str(<&'static str>::from(self))` boilerplate.
 ///
 /// Kept separate from [`named_error_set!`] because not every named error set
@@ -362,13 +355,12 @@ macro_rules! impl_tag_error {
 }
 
 // ─── coreutils_error_map ─────────────────────────────────────────────────
-// Zig builds a comptime `EnumMap<SystemErrno, []const u8>` with a per-OS
-// `switch (Environment.os)` body (src/sys/coreutils_error_map.zig). The full
-// EnumMap lives in `bun_sys::coreutils_error_map`; that crate is tier-above
-// `bun_core`, so for `output.rs`'s integer-errno hot path we keep a parallel
-// table here, keyed by `SystemErrno` *name* and resolved through the per-OS
-// `ErrnoNames` hook — i.e. the same `errno → SystemErrno → message`
-// composition the Zig does, just without the cross-crate enum.
+// The full typed EnumMap lives in `bun_sys::coreutils_error_map`; that crate
+// is tier-above `bun_core`, so for `output.rs`'s integer-errno hot path we
+// keep a parallel table here, keyed by `SystemErrno` *name* and resolved
+// through the per-OS `ErrnoNames` hook — the same
+// `errno → SystemErrno → message` composition, just without the
+// cross-crate enum.
 //
 // Layout: one shared BASE table (the glibc/coreutils strings — used as-is on
 // linux/android/windows/wasm) plus a small per-OS DELTA on macOS/FreeBSD that
@@ -626,7 +618,7 @@ pub mod coreutils_error_map {
     };
 }
 
-/// Zig: `pub fn Result(comptime T: type, comptime E: type) type { return union(enum) { ok: T, err: E, ... } }`
+/// A plain ok/err union.
 pub enum Result<T, E> {
     Ok(T),
     Err(E),
@@ -682,5 +674,3 @@ mod tests {
         assert_ne!(a, Error::TODO);
     }
 }
-
-// ported from: src/bun.zig
diff --git a/src/bun_core/string/HashedString.rs b/src/bun_core/string/HashedString.rs
index bced35f94a1..1f0cbd97d6b 100644
--- a/src/bun_core/string/HashedString.rs
+++ b/src/bun_core/string/HashedString.rs
@@ -46,9 +46,7 @@ impl HashedString {
 
     pub fn str(&self) -> &[u8] {
         // SAFETY: ptr and len were set together from a valid slice in `init`/`init_no_hash`;
-        // caller is responsible for keeping the backing buffer alive (same invariant as Zig).
+        // caller is responsible for keeping the backing buffer alive.
         unsafe { core::slice::from_raw_parts(self.ptr, self.len as usize) }
     }
 }
-
-// ported from: src/string/HashedString.zig
diff --git a/src/bun_core/string/MutableString.rs b/src/bun_core/string/MutableString.rs
index 3a7201e35a5..ea849c64c40 100644
--- a/src/bun_core/string/MutableString.rs
+++ b/src/bun_core/string/MutableString.rs
@@ -4,19 +4,18 @@ use bun_alloc::AllocError;
 /// VTable surface for `bun.ast.E.String` (CYCLEBREAK b0: GENUINE upward dep on
 /// `bun_ast::E::String`). Low tier defines the interface; high tier
 /// (`bun_js_parser`) provides `impl EStringRef for E::String`.
-/// PERF(port): was inline concrete type — cold path (formatter/writer).
+/// Dyn dispatch is acceptable: cold path (formatter/writer).
 pub trait EStringRef {
     fn is_utf8(&self) -> bool;
     fn slice(&mut self) -> &[u8];
     fn slice16(&mut self) -> &[u16];
 }
 
-/// Layout-identical to Zig's `std.posix.iovec_const`
-/// (`extern struct { base: [*]const u8, len: usize }`), which is defined
-/// unconditionally for every target — it does NOT alias `uv_buf_t`/`WSABUF`
-/// on Windows (those have reversed field order and a `u32` len). The Zig
-/// spec `MutableString.toSocketBuffers` returns this shape on all platforms,
-/// so there is no `cfg(windows)` split.
+/// Layout-identical to POSIX `struct iovec` with a const base
+/// (`{ base: *const u8, len: usize }`), used unconditionally on every target —
+/// it does NOT alias `uv_buf_t`/`WSABUF` on Windows (those have reversed field
+/// order and a `u32` len). `to_socket_buffers` returns this shape on all
+/// platforms, so there is no `cfg(windows)` split.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct SocketBuffer {
@@ -24,17 +23,14 @@ pub struct SocketBuffer {
     pub iov_len: usize,
 }
 
-/// A growable byte buffer. In Zig this paired an `Allocator` with an
-/// `ArrayListUnmanaged(u8)`; in Rust the global mimalloc allocator is implicit,
-/// so this is a thin wrapper over `Vec<u8>`.
+/// A growable byte buffer: a thin wrapper over `Vec<u8>` (the global mimalloc
+/// allocator is implicit).
 #[derive(Default, Clone)]
 pub struct MutableString {
-    // Zig field `std.mem.Allocator` param — deleted (global mimalloc).
     pub list: Vec<u8>,
 }
 
-// Zig: `Npm.Registry.BodyPool = ObjectPool(MutableString, MutableString.init2048, true, 8)`
-// (src/install/npm.zig). The `bun_collections::pool::ObjectPoolType` impl
+// The `bun_collections::pool::ObjectPoolType` impl
 // lives in `bun_collections` (trait owner) to avoid a `bun_core →
 // bun_collections` dep cycle now that `MutableString` is in `bun_core`.
 
@@ -54,7 +50,6 @@ impl MutableString {
     }
 
     /// Returns a `std::io::Write` borrow of this buffer.
-    /// Zig: `pub const Writer = std.Io.GenericWriter(*@This(), Allocator.Error, writeAll)`.
     pub fn writer(&mut self) -> &mut Self {
         self
     }
@@ -63,19 +58,16 @@ impl MutableString {
         self.list.is_empty()
     }
 
-    // Zig `deinit` only freed `list`; `Vec<u8>` drops automatically — no `Drop` impl needed.
+    // `Vec<u8>` drops automatically — no `Drop` impl needed.
 
-    /// Zig: `self.list.expandToCapacity()` — set `len = capacity` so callers
+    /// Set `len = capacity` so callers
     /// can index into the spare region (e.g. `read()` into `&mut list[n..]`).
     ///
-    /// Matches Zig semantics: the new tail is left **uninitialized** — callers
-    /// must treat `list[old_len..]` as write-only until overwritten (typically
-    /// by `read()`). The previous port zero-filled here, which memset the
-    /// entire pooled scratch buffer before every `package.json` read.
+    /// Callers must treat `list[old_len..]` as write-only until overwritten
+    /// (typically by `read()`).
     #[inline]
     pub fn expand_to_capacity(&mut self) {
-        // Zero only the spare region so the exposed tail is defined (Zig's
-        // `expandToCapacity` leaves it `undefined` — we don't, to avoid
+        // Zero only the spare region so the exposed tail is defined (avoids
         // CWE-908 uninit-memory exposure if a caller reads before write).
         let old = self.list.len();
         self.list.resize(self.list.capacity(), 0);
@@ -84,7 +76,6 @@ impl MutableString {
     }
 
     pub fn owns(&self, items: &[u8]) -> bool {
-        // Zig: bun.isSliceInBuffer(items, this.list.items.ptr[0..this.list.capacity])
         // Pointer-range check against the full allocation; done with addresses
         // rather than forming a `&[u8]` over `[len..cap)` (uninit) bytes.
         let base = self.list.as_ptr() as usize;
@@ -99,7 +90,9 @@ impl MutableString {
     }
 
     pub fn writable_n_bytes_assume_capacity(&mut self, amount: usize) -> &mut [u8] {
-        // SAFETY: caller fully writes the returned slice (Zig contract).
+        // SAFETY: caller has reserved at least `amount` bytes of spare capacity
+        // (debug-asserted in the callee) and fully writes the returned slice
+        // before reading it.
         unsafe { crate::vec::writable_slice_assume_capacity(&mut self.list, amount) }
     }
 
@@ -120,7 +113,7 @@ impl MutableString {
     pub fn buffered_writer(&mut self) -> BufferedWriter<'_> {
         BufferedWriter {
             context: self,
-            buffer: [0u8; BufferedWriter::MAX], // PERF(port): Zig left this `undefined`
+            buffer: [0u8; BufferedWriter::MAX],
             pos: 0,
         }
     }
@@ -141,7 +134,6 @@ impl MutableString {
 
     #[inline]
     pub fn ensure_unused_capacity(&mut self, amount: usize) -> Result<(), AllocError> {
-        // Zig: `pub const ensureUnusedCapacity = growIfNeeded;`
         self.grow_if_needed(amount)
     }
 
@@ -156,10 +148,9 @@ impl MutableString {
     /// identifier, you're going to potentially cause trouble with non-BMP code
     /// points in target environments that don't support bracketed Unicode escapes.
     pub fn ensure_valid_identifier(str: &[u8]) -> Result<Box<[u8]>, AllocError> {
-        // TODO(port): Zig returned `[]const u8` which could be either the input
-        // borrow or a fresh allocation. Rust cannot express that without a
-        // lifetime + Cow; for now we always return owned `Box<[u8]>` and copy
-        // on the borrow paths. Consider `Cow<'a, [u8]>`.
+        // The result could be either the input borrow or a fresh allocation;
+        // rather than a lifetime + Cow we always return owned `Box<[u8]>` and
+        // copy on the borrow paths.
         if str.is_empty() {
             return Ok(Box::<[u8]>::from(b"_".as_slice()));
         }
@@ -175,7 +166,6 @@ impl MutableString {
             return Ok(Box::<[u8]>::from(b"_".as_slice()));
         }
 
-        // TODO(port): lexer / lexer_tables arrive from move-in (MOVE_DOWN bun_js_parser::{lexer,lexer_tables} → string)
         use crate::string::lexer as js_lexer;
         use crate::string::lexer_tables as js_lexer_tables;
 
@@ -254,11 +244,9 @@ impl MutableString {
         self.list.reserve(str.len().saturating_sub(self.list.len()));
 
         if self.list.is_empty() {
-            // Zig: list.insertSlice(allocator, 0, str)
             self.list.extend_from_slice(str);
         } else {
-            // Zig: list.replaceRange(allocator, 0, str.len, str)
-            // TODO(port): verify Vec::splice matches ArrayList.replaceRange semantics
+            // Overwrite-then-extend replaces the range [0, str.len).
             let n = str.len().min(self.list.len());
             self.list[..n].copy_from_slice(&str[..n]);
             if str.len() > n {
@@ -285,7 +273,6 @@ impl MutableString {
         if items.is_empty() {
             return Ok(());
         }
-        // Zig: ensureTotalCapacityPrecise(len + items.len) → reserve_exact(items.len())
         self.list.reserve_exact(items.len());
         // After `reserve_exact`, `extend_from_slice` is a single memcpy with
         // no further reallocation — same codegen as the raw `set_len` path.
@@ -302,14 +289,13 @@ impl MutableString {
     pub fn reset_to(&mut self, index: usize) {
         debug_assert!(index <= self.list.capacity());
         // SAFETY: index <= capacity asserted; bytes in [len..index] may be
-        // uninitialized — matches Zig semantics. Callers must have previously
+        // uninitialized. Callers must have previously
         // written those bytes (e.g. via writable_n_bytes).
         unsafe { self.list.set_len(index) };
     }
 
     pub fn inflate(&mut self, amount: usize) -> Result<(), AllocError> {
-        // Zig MutableString.inflate: `list.resize(amount)` leaves new bytes
-        // uninitialized. Callers always overwrite the inflated region, so the
+        // Callers always overwrite the inflated region, so the
         // zero-fill here is technically redundant — but it lowers to a single
         // memset and avoids `clippy::uninit_vec` / a `set_len` over uninit bytes.
         self.list.resize(amount, 0);
@@ -318,7 +304,6 @@ impl MutableString {
 
     #[inline]
     pub fn append_char_n_times(&mut self, char: u8, n: usize) -> Result<(), AllocError> {
-        // Zig: list.appendNTimes
         self.list.extend(core::iter::repeat_n(char, n));
         Ok(())
     }
@@ -331,7 +316,6 @@ impl MutableString {
 
     #[inline]
     pub fn append_char_assume_capacity(&mut self, char: u8) {
-        // PERF(port): was assume_capacity
         self.list.push(char);
     }
 
@@ -342,7 +326,7 @@ impl MutableString {
     }
 }
 
-/// Growable string sink. Zig: `MutableString.writer()`.
+/// Growable string sink.
 impl crate::io::Write for MutableString {
     #[inline]
     fn write_all(&mut self, buf: &[u8]) -> Result<(), crate::Error> {
@@ -366,7 +350,6 @@ impl MutableString {
 
     #[inline]
     pub fn append_assume_capacity(&mut self, char: &[u8]) {
-        // PERF(port): was assume_capacity
         self.list.extend_from_slice(char);
     }
 
@@ -380,20 +363,16 @@ impl MutableString {
     }
 
     pub fn to_owned_slice(&mut self) -> Box<[u8]> {
-        // Zig: bun.handleOom(self.list.toOwnedSlice(self.allocator))
         core::mem::take(&mut self.list).into_boxed_slice()
     }
 
     pub fn to_dynamic_owned(&mut self) -> Box<[u8]> {
-        // TODO(port): Zig `DynamicOwned([]u8)` carried its allocator; with the
-        // global allocator this collapses to `Box<[u8]>`. Revisit if a distinct
-        // `bun_ptr::DynamicOwned` type is introduced.
+        // With the global allocator this collapses to `Box<[u8]>`.
         self.to_owned_slice()
     }
 
-    /// `self.allocator` must be `bun.default_allocator`.
+    /// Alias of [`Self::to_owned_slice`]; the global allocator is implicit.
     pub fn to_default_owned(&mut self) -> Box<[u8]> {
-        // Zig asserted allocator == default_allocator; allocator field is gone.
         self.to_owned_slice()
     }
 
@@ -433,9 +412,7 @@ impl MutableString {
     }
 
     pub fn index_of(&self, str: u8) -> Option<usize> {
-        // TODO(port): Zig signature is `str: u8` but body calls
-        // `std.mem.indexOf(u8, items, str)` which expects a slice — looks like
-        // a latent bug in the Zig source. Porting as single-byte search.
+        // Single-byte search (the `str` parameter is one byte despite the name).
         self.list.iter().position(|&b| b == str)
     }
 
@@ -443,14 +420,13 @@ impl MutableString {
         self.list.as_slice() == other
     }
 
-    /// Zig spec: `[count]std.posix.iovec_const` — that struct is
-    /// `{ base: [*]const u8, len: usize }` on every target (including Windows;
+    /// Returns `[SocketBuffer; COUNT]` —
+    /// `{ base: *const u8, len: usize }` on every target (including Windows;
     /// it is NOT `uv_buf_t`). Single implementation, no `cfg(windows)` split.
     pub fn to_socket_buffers<const COUNT: usize>(
         &self,
         ranges: [(usize, usize); COUNT],
     ) -> [SocketBuffer; COUNT] {
-        // PERF(port): Zig used `inline for` (unrolled); plain loop here.
         core::array::from_fn(|i| {
             let r = ranges[i];
             let s = &self.list[r.0..r.1];
@@ -467,9 +443,6 @@ impl MutableString {
     }
 }
 
-// Zig: `MutableString.init2048` is the default `Init` fn passed to
-// (ObjectPoolType impl at L25 — uses init2048() per npm.zig spec.)
-
 impl std::io::Write for MutableString {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         self.list.extend_from_slice(buf);
@@ -491,8 +464,7 @@ pub struct BufferedWriter<'a> {
 impl<'a> BufferedWriter<'a> {
     const MAX: usize = BUFFERED_WRITER_MAX;
 
-    // Zig: `pub const Writer = std.Io.GenericWriter(*BufferedWriter, Allocator.Error, writeAll)`
-    // → `impl std::io::Write for BufferedWriter` below; `writer()` returns `&mut Self`.
+    // `impl std::io::Write for BufferedWriter` below; `writer()` returns `&mut Self`.
 
     pub fn flush(&mut self) -> Result<(), AllocError> {
         let _ = self.context.write_all(&self.buffer[0..self.pos])?;
@@ -513,8 +485,6 @@ impl<'a> BufferedWriter<'a> {
             if pending.len() + self.pos > Self::MAX {
                 self.flush()?;
             }
-            // PORT NOTE: reshaped for borrowck (cannot call self.remain() while
-            // borrowing pending.len() against self.pos).
             let pos = self.pos;
             self.buffer[pos..pos + pending.len()].copy_from_slice(pending);
             self.pos += pending.len();
@@ -543,13 +513,7 @@ impl<'a> BufferedWriter<'a> {
 
         if pending.len() >= Self::MAX {
             self.flush()?;
-            // PORT NOTE: Zig wrote into `this.remain()[0..bytes.len*2]` here,
-            // which after `flush()` is `this.buffer[0..bytes.len*2]` — but
-            // `bytes.len*2 > MAX`, so that indexes past the stack buffer. This
-            // looks like a latent bug in the Zig (should write into
-            // `context.list`). Porting the apparent intent: write into the
-            // freshly-reserved context.list tail.
-            // TODO(port): confirm and fix upstream.
+            // Write into the freshly-reserved context.list tail.
             let old = self.context.list.len();
             // SAFETY: copy_utf16_into_utf8 writes <= bytes.len*2; trimmed below.
             let tail =
@@ -641,5 +605,3 @@ impl<'a> std::io::Write for BufferedWriter<'a> {
         BufferedWriter::flush(self).map_err(|_| std::io::ErrorKind::OutOfMemory.into())
     }
 }
-
-// ported from: src/string/MutableString.zig
diff --git a/src/bun_core/string/SmolStr.rs b/src/bun_core/string/SmolStr.rs
index dade67f31d9..cc2f58eb8c3 100644
--- a/src/bun_core/string/SmolStr.rs
+++ b/src/bun_core/string/SmolStr.rs
@@ -2,14 +2,14 @@ use core::mem;
 
 use bun_alloc::AllocError;
 
-// NOTE: the tag-bit scheme below only works on little-endian systems (matches Zig comment).
+// NOTE: the tag-bit scheme below only works on little-endian systems.
 const _: () = assert!(cfg!(target_endian = "little"));
 // NOTE: the packed layout assumes 64-bit pointers (`__ptr` occupies the upper 64 bits of the u128).
 const _: () = assert!(mem::size_of::<usize>() == 8);
 
 /// This is a string type that stores up to 15 bytes inline on the stack, and heap allocates if it is longer.
 ///
-/// Zig layout (`packed struct(u128)`, little-endian bit order):
+/// Layout (packed u128, little-endian bit order):
 ///   bits   0..32  = `__len: u32`
 ///   bits  32..64  = `cap: u32`
 ///   bits  64..128 = `__ptr: [*]u8`  (bit 127 is the inlined tag)
@@ -24,7 +24,7 @@ impl Clone for SmolStr {
             return SmolStr(self.0);
         }
         // Heap-backed: dupe the bytes into a fresh Vec allocation.
-        // bun.handleOom: panic on OOM (matches Zig allocator semantics).
+        // Panic on OOM.
         SmolStr::from_slice(self.slice()).expect("OOM")
     }
 }
@@ -62,8 +62,6 @@ impl SmolStr {
 
     // ---- public API -------------------------------------------------------
 
-    // TODO(port): Zig `jsonStringify` participates in std.json's structural protocol;
-    // map to bun's JSON-serialize trait once one exists.
     pub fn json_stringify<W>(&self, writer: &mut W) -> Result<(), crate::Error>
     where
         W: JsonWriter,
@@ -140,10 +138,8 @@ impl SmolStr {
 
     pub fn from_slice(values: &[u8]) -> Result<SmolStr, AllocError> {
         if values.len() > Inlined::MAX_LEN {
-            // TODO(port): verify Vec::<u8>::init_capacity / append_slice_assume_capacity API.
             let mut baby_list = Vec::<u8>::with_capacity(values.len());
             baby_list.extend_from_slice(values);
-            // PERF(port): was appendSliceAssumeCapacity — profile if hot.
             return Ok(SmolStr::from_baby_list(baby_list));
         }
 
@@ -168,7 +164,6 @@ impl SmolStr {
             if inlined.len() as usize + 1 > Inlined::MAX_LEN {
                 let mut baby_list = Vec::<u8>::with_capacity(inlined.len() as usize + 1);
                 baby_list.extend_from_slice(inlined.slice());
-                // PERF(port): was appendSliceAssumeCapacity — profile if hot.
                 baby_list.push(char);
                 // Old value is inlined (no heap) so `Drop` is a no-op; plain assign is fine.
                 *self = SmolStr::from_baby_list(baby_list);
@@ -202,7 +197,6 @@ impl SmolStr {
                 let mut baby_list = Vec::<u8>::with_capacity(old_len + values.len());
                 baby_list.extend_from_slice(inlined.slice());
                 baby_list.extend_from_slice(values);
-                // PERF(port): was appendSliceAssumeCapacity — profile if hot.
                 // Old `*self` is inlined (no heap) so `Drop` is a no-op; plain assign is fine.
                 *self = SmolStr::from_baby_list(baby_list);
                 return Ok(());
@@ -234,7 +228,6 @@ impl Drop for SmolStr {
     fn drop(&mut self) {
         if !self.is_inlined() {
             // SAFETY: ptr/len/cap describe a Vec<u8> allocation we own; reconstruct to free.
-            // TODO(port): verify Vec<u8> Drop frees; else dealloc via global allocator directly.
             let list = unsafe {
                 Vec::<u8>::from_raw_parts(
                     self.ptr(),
@@ -247,14 +240,14 @@ impl Drop for SmolStr {
     }
 }
 
-// TODO(port): placeholder for the std.json `writer: anytype` protocol used by json_stringify.
+/// Minimal byte-writer protocol used by `json_stringify`.
 pub trait JsonWriter {
     fn write(&mut self, bytes: &[u8]) -> Result<(), crate::Error>;
 }
 
 // ---------------------------------------------------------------------------
 
-/// Zig layout (`packed struct(u128)`, little-endian bit order):
+/// Layout (packed u128, little-endian bit order):
 ///   bits   0..120 = `data: u120`   (15 inline bytes)
 ///   bits 120..127 = `__len: u7`
 ///   bit  127      = `_tag: u1`
@@ -282,7 +275,6 @@ impl Inlined {
     /// if `str` is longer than `MAX_LEN`
     pub(crate) fn init(str: &[u8]) -> Result<Inlined, InlinedError> {
         if str.len() > Self::MAX_LEN {
-            // PERF(port): @branchHint(.unlikely) — no stable Rust equivalent
             return Err(InlinedError::StringTooLong);
         }
         let mut inlined = Inlined::EMPTY;
@@ -384,12 +376,9 @@ mod tests {
 
     #[test]
     fn inlined_does_not_allocate() {
-        // TODO(port): Zig used std.testing.allocator to assert no allocation; no direct
-        // equivalent here. The is_inlined() check is the observable proxy.
+        // The is_inlined() check is the observable proxy for "no allocation".
         let hello = SmolStr::from_slice(b"hello").unwrap();
         assert_eq!(5, hello.len());
         assert!(hello.is_inlined());
     }
 }
-
-// ported from: src/string/SmolStr.zig
diff --git a/src/bun_core/string/StringBuilder.rs b/src/bun_core/string/StringBuilder.rs
index 38b0f14b48b..d30180c7dc8 100644
--- a/src/bun_core/string/StringBuilder.rs
+++ b/src/bun_core/string/StringBuilder.rs
@@ -9,10 +9,10 @@ use bun_simdutf_sys::simdutf;
 /// append, then `allocate()` once, then `append()` each slice. Returned slices
 /// point into the single backing buffer.
 ///
-// TODO(port): the `append*` methods return `&[u8]` borrowing `self.ptr` while
-// also taking `&mut self`. Zig hands out aliasing slices freely; in Rust this
-// needs either an explicit `'a` on the builder, interior mutability (`Cell<usize>`
-// for len), or callers must use `StringPointer` offsets instead.
+// Note: the `append*` methods return `&[u8]` borrowing `self.ptr` while also
+// taking `&mut self`, so callers cannot hold two returned slices at once.
+// Callers that need to interleave appends
+// use `StringPointer` offsets or the unsafe `append_raw` escape hatch below.
 #[derive(Default)]
 pub struct StringBuilder {
     pub len: usize,
@@ -48,17 +48,15 @@ impl StringBuilder {
     }
 
     pub fn count16_z(&mut self, slice: &[u16]) {
-        // PORT NOTE: WStr has no len method on its DST slice yet; callers pass &[u16].
-        // Zig's `elementLengthUTF16IntoUTF8` is the same simdutf length call when input
-        // is valid; for WTF-16 with lone surrogates the slow path overestimates by 0-1
-        // bytes which is fine for a capacity reservation.
+        // Callers pass &[u16] (WStr has no len method on its DST slice yet).
+        // For WTF-16 with lone surrogates the simdutf length estimate
+        // overestimates by 0-1 bytes, which is fine for a capacity reservation.
         self.cap += simdutf::length::utf8::from::utf16::le(slice) + 1;
     }
 
     pub fn append16(&mut self, slice: &[u16]) -> Option<&mut ZStr> {
-        // PORT NOTE: fallback_allocator param dropped (global mimalloc).
-        // PORT NOTE: borrowck — capture buf ptr, drop the &mut borrow before
-        // mutating self.len, then rebuild ZStr from the raw ptr.
+        // Borrowck: capture buf ptr, drop the &mut borrow before mutating
+        // self.len, then rebuild ZStr from the raw ptr.
         let buf = self.writable();
         let buf_ptr = buf.as_mut_ptr();
         if slice.is_empty() {
@@ -78,8 +76,7 @@ impl StringBuilder {
             Some(unsafe { ZStr::from_raw_mut(buf_ptr, count) })
         } else {
             // Fallback: WTF-16 → WTF-8 via the slow path that handles lone surrogates.
-            // Zig allocated from `fallback_allocator` and handed ownership to the
-            // caller; the Rust signature returns a borrow into `self`, so we copy
+            // The signature returns a borrow into `self`, so we copy
             // the WTF-8 bytes into the builder's reserved buffer (count16_z reserved
             // enough — simdutf's length estimate is an upper bound for WTF-16) and
             // drop the temporary Vec normally. No `mem::forget`.
@@ -135,9 +132,8 @@ impl StringBuilder {
     }
 
     /// Copy `slice` into the reserved buffer and return a borrow of the copied
-    /// bytes with an *unbound* lifetime. Mirrors Zig's untracked `[]const u8`
-    /// return so callers may interleave appends and stash both slices (e.g.
-    /// `picohttp::Header::clone`).
+    /// bytes with an *unbound* lifetime, so callers may interleave appends and
+    /// stash both slices (e.g. `picohttp::Header::clone`).
     ///
     /// # Safety
     /// The returned slice aliases `self.ptr` and is only valid until the
@@ -163,7 +159,6 @@ impl StringBuilder {
     }
 
     pub fn add_concat(&mut self, slices: &[&[u8]]) -> StringPointer {
-        // PORT NOTE: reshaped for borrowck — capture self.len before borrowing alloc.
         let start = self.len;
         let alloc = self.allocated_slice();
         let mut remain = &mut alloc[start..];
@@ -311,8 +306,8 @@ impl StringBuilder {
     /// After calling this, you are responsible for freeing the underlying memory.
     /// This StringBuilder should not be used after calling this function.
     pub fn move_to_slice(&mut self) -> Box<[u8]> {
-        // TODO(port): Zig wrote into `*[]u8` out-param and reset self. Here we
-        // reconstruct the Box (allocated in init_capacity/allocate) and hand it back.
+        // Reconstruct the Box (allocated in init_capacity/allocate) and hand
+        // it back.
         //
         // `take()` first: `*self = Self::default()` drops the old value, and
         // `Drop` frees the buffer when `ptr` is still `Some` — leaving it set
@@ -323,9 +318,9 @@ impl StringBuilder {
         };
         let cap = self.cap;
         *self = Self::default();
-        // SAFETY: ptr came from Box::<[u8]>::new_uninit_slice(cap) leaked above;
-        // all `cap` bytes have been written iff caller appended everything counted.
-        // TODO(port): if not fully written this reads uninit bytes — Zig didn't care.
+        // SAFETY: ptr came from Box::<[u8]>::new_uninit_slice(cap) leaked above.
+        // Caller contract: every counted byte must have been appended — if not
+        // fully written, the returned Box exposes uninit bytes (UB to read).
         unsafe { crate::heap::take(std::ptr::slice_from_raw_parts_mut(ptr.as_ptr(), cap)) }
     }
 }
@@ -345,5 +340,3 @@ impl Drop for StringBuilder {
         }
     }
 }
-
-// ported from: src/string/StringBuilder.zig
diff --git a/src/bun_core/string/StringJoiner.rs b/src/bun_core/string/StringJoiner.rs
index f70c32b7a9d..960ac4ab3f3 100644
--- a/src/bun_core/string/StringJoiner.rs
+++ b/src/bun_core/string/StringJoiner.rs
@@ -5,8 +5,8 @@
 use crate::string::strings;
 use bun_alloc::AllocError;
 
-// PORT NOTE: Zig's `std.mem.Allocator` param field dropped — global mimalloc is used for
-// node and duplicated-string allocations.
+// Node and duplicated-string allocations use the global allocator (mimalloc);
+// there is no per-joiner allocator field.
 #[derive(Default)]
 pub struct StringJoiner<'a> {
     /// Total length of all nodes
@@ -76,10 +76,6 @@ impl<'a> StringJoiner<'a> {
         self.push_owned(Box::from(data));
     }
 
-    // PORT NOTE: Zig signature was `push(data: []const u8, ?Allocator param)`.
-    // The optional allocator only encoded ownership of `data`, which has no Rust
-    // analogue for a borrowed `&[u8]`; callers wanting owned semantics use
-    // `push_owned`/`push_cloned` instead.
     pub fn push(&mut self, data: &'a [u8]) {
         if data.is_empty() {
             return;
@@ -143,8 +139,7 @@ impl<'a> StringJoiner<'a> {
         let len = self.len;
         self.len = 0;
 
-        // Zig: `allocator.alloc(u8, this.len)` — allocates uninitialized.
-        // `Vec::with_capacity` + `extend_from_slice` is also zero-fill-free
+        // `Vec::with_capacity` + `extend_from_slice` is zero-fill-free
         // (each push is a `memcpy` into spare capacity), and since the final
         // `len == capacity` the `into_boxed_slice` is a no-realloc move.
         let mut out = Vec::<u8>::with_capacity(len);
@@ -311,5 +306,3 @@ mod tests {
         assert_eq!(&*detached.done().unwrap(), b"KEY borrowed cloned KEY");
     }
 }
-
-// ported from: src/string/StringJoiner.zig
diff --git a/src/bun_core/string/escapeRegExp.rs b/src/bun_core/string/escapeRegExp.rs
index b78434c016b..950120e5a07 100644
--- a/src/bun_core/string/escapeRegExp.rs
+++ b/src/bun_core/string/escapeRegExp.rs
@@ -2,9 +2,6 @@ use crate::string::strings;
 
 const SPECIAL_CHARACTERS: &[u8] = b"|\\{}()[]^$+*?.-";
 
-// TODO(port): writer trait — Zig uses `*std.Io.Writer` (byte writer). Mapping to
-// `&mut impl std::io::Write` per PORTING.md; swap to the concrete crate-local
-// byte-writer trait once `bun_io` is wired.
 pub fn escape_reg_exp<W: std::io::Write>(
     input: &[u8],
     writer: &mut W,
@@ -57,8 +54,5 @@ pub fn escape_reg_exp_for_package_name_matching<W: std::io::Write>(
     writer.write_all(remain)
 }
 
-// PORT NOTE: the Zig file re-exported `jsEscapeRegExp` / `jsEscapeRegExpForPackageNameMatching`
-// from `../jsc/bun_string_jsc.zig`. Per PORTING.md these `*_jsc` alias lines are deleted —
-// the JS-facing wrappers live in the `*_jsc` crate as extension-trait methods.
-
-// ported from: src/string/escapeRegExp.zig
+// The JS-facing wrappers (`jsEscapeRegExp` / `jsEscapeRegExpForPackageNameMatching`)
+// live in the `*_jsc` crate as extension-trait methods.
diff --git a/src/bun_core/string/identifier.rs b/src/bun_core/string/identifier.rs
index 5819dfabc25..02e7e4aa8a4 100644
--- a/src/bun_core/string/identifier.rs
+++ b/src/bun_core/string/identifier.rs
@@ -22,12 +22,9 @@ use crate::string::strings::{CodePoint, CodepointIterator, Cursor};
 
 /// Whole-string ES identifier check over WTF-8 bytes.
 ///
-/// Port of `js_lexer.isIdentifier` (src/js_parser/lexer.zig:3058). Zig has
-/// exactly one impl; the Rust port had triplicated it across `bun_string`,
-/// `bun_ast`, and `bun_js_parser` during the move-down layering pass. This is
-/// the canonical home: it sits next to the per-codepoint predicates and the
-/// two-stage Unicode tables it bottoms out in, and `CodepointIterator` lives
-/// in this crate.
+/// This is the canonical home: it sits next to the per-codepoint predicates
+/// and the two-stage Unicode tables it bottoms out in, and
+/// `CodepointIterator` lives in this crate.
 pub fn is_identifier(text: &[u8]) -> bool {
     if text.is_empty() {
         return false;
@@ -45,15 +42,14 @@ pub fn is_identifier(text: &[u8]) -> bool {
     true
 }
 
-/// Whole-string ES identifier check over WTF-16. Port of
-/// `src/js_parser/lexer.zig:isIdentifierUTF16`.
+/// Whole-string ES identifier check over WTF-16.
 ///
 /// Surrogate decoding is open-coded on purpose: an unpaired high surrogate
 /// (0xD800..=0xDBFF not followed by a low surrogate) advances ONE unit and is
-/// fed raw to `is_identifier_start/part` — exactly matching Zig
-/// `lexer.zig:3091-3096`. `crate::string::strings::utf16_codepoint` would advance
-/// TWO units in that case (see immutable.rs:1644 PORT NOTE), so do NOT swap it
-/// in here.
+/// fed raw to `is_identifier_start/part`. `crate::string::strings::utf16_codepoint` (defined in
+/// `immutable/unicode.rs`, re-exported through `immutable.rs`) would advance
+/// TWO units in that case — its lead-surrogate arm returns `len: 2` even when
+/// the next unit is not a trail surrogate — so do NOT swap it in here.
 pub fn is_identifier_utf16(text: &[u16]) -> bool {
     let n = text.len();
     if n == 0 {
@@ -78,12 +74,11 @@ pub fn is_identifier_utf16(text: &[u16]) -> bool {
 
 // ──────────────────────────────────────────────────────────────────────────
 // The remainder of this file is auto-generated. Do not edit.
-// TODO(port): re-run the identifier-table generator with .rs output instead
-// of post-processing the .zig; tables below were mechanically transcribed.
+// To regenerate, re-run the identifier-table generator with .rs output.
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: Zig `u21` codepoint type → `u32`. Callers must pass cp <= 0x10FFFF
-// (stage1 tables are sized for that range); out-of-range indexes panic.
+// Callers must pass cp <= 0x10FFFF (stage1 tables are sized for that range);
+// out-of-range indexes panic.
 
 /// isIDStartESNext checks if a codepoint is valid in the isIDStartESNext category
 pub(crate) fn is_id_start_es_next(cp: u32) -> bool {
@@ -1658,5 +1653,3 @@ mod id_continue_es_next {
         281474976710655,
     ];
 }
-
-// ported from: src/js_parser/lexer/identifier.zig
diff --git a/src/bun_core/string/immutable.rs b/src/bun_core/string/immutable.rs
index e4f4549c3ec..5934c92e1aa 100644
--- a/src/bun_core/string/immutable.rs
+++ b/src/bun_core/string/immutable.rs
@@ -1,4 +1,4 @@
-//! Port of `src/string/immutable.zig` — `bun.strings` namespace.
+//! The `bun.strings` namespace:
 //! SIMD-accelerated immutable string utilities operating on `&[u8]` (NOT `&str`).
 
 use core::cmp::Ordering;
@@ -105,8 +105,7 @@ pub mod unicode {
             cp
         }
 
-        /// Zig: `CodepointIterator.needsUTF8Decoding` — true iff any byte in
-        /// `slice` begins a multi-byte WTF-8 sequence.
+        /// True iff any byte in `slice` begins a multi-byte WTF-8 sequence.
         pub fn needs_utf8_decoding(slice: &[u8]) -> bool {
             let mut i = 0usize;
             while i < slice.len() {
@@ -129,12 +128,11 @@ pub mod unicode {
     }
 
     impl<'a> NewCodePointIterator<'a> {
-        /// Zig-style cursor advance. Returns `false` at end.
-        // PERF(port): `#[inline]` alone is hint-only; LLVM declined to inline
+        /// Cursor advance. Returns `false` at end.
+        // PERF: `#[inline]` alone is hint-only; LLVM declined to inline
         // this cross-crate into `bun_js_printer::print_identifier_ascii_only`
         // (the multibyte slow path makes the body look heavy). Called per-byte
-        // of every printed identifier under `ASCII_ONLY=true`. Zig's `iter.next`
-        // lives in the same TU and inlines. Force it.
+        // of every printed identifier under `ASCII_ONLY=true`. Force it.
         #[inline(always)]
         pub fn next(&self, cursor: &mut Cursor) -> bool {
             let bytes = self.bytes;
@@ -148,8 +146,7 @@ pub mod unicode {
             let first = tail[0];
             cursor.i = pos as u32;
             // ASCII fast path — the overwhelmingly common case for JS source
-            // (identifiers, escape-free strings). Matches Zig's per-byte ptr
-            // indexing + 1-arm switch in `decodeWTF8RuneT`.
+            // (identifiers, escape-free strings).
             if first < 0x80 {
                 cursor.c = first as CodePoint;
                 cursor.width = 1;
@@ -172,7 +169,7 @@ pub mod unicode {
         }
     }
 
-    /// Zig: `unicode.zig:containsNonBmpCodePoint` — `true` iff `text` contains any
+    /// `true` iff `text` contains any
     /// codepoint above U+FFFF (i.e. would need a UTF-16 surrogate pair).
     pub fn contains_non_bmp_code_point(text: &[u8]) -> bool {
         let iter = CodepointIterator::init(text);
@@ -185,7 +182,7 @@ pub mod unicode {
         false
     }
 
-    /// Zig: `unicode.zig:containsNonBmpCodePointOrIsInvalidIdentifier` — fused
+    /// Fused
     /// "must I quote this import/export alias?" predicate for `js_printer`.
     ///
     /// Returns `true` if `text` is empty, OR any codepoint is non-BMP (>U+FFFF,
@@ -208,19 +205,15 @@ pub mod unicode {
         false
     }
 
-    /// `toUTF16Literal` — port of `unicode.zig:toUTF16Literal` →
-    /// `std.unicode.utf8ToUtf16LeStringLiteral`. Zig evaluated this at
-    /// `comptime` into a `Holder.value` const yielding `[:0]const u16`; the
-    /// Rust runtime port returns an owned `Box<[u16]>` (no `Box::leak` per
-    /// PORTING.md §Forbidden). Prefer the const `crate::string::w!("…")` macro at call
-    /// sites with literal inputs — this fn exists for the residual runtime
-    /// callers that thread `&[u8]` through.
+    /// `toUTF16Literal` — returns an owned `Box<[u16]>`. Prefer the const
+    /// `crate::string::w!("…")` macro at call sites with literal inputs —
+    /// this fn exists for the residual runtime callers that thread `&[u8]`
+    /// through.
     pub fn to_utf16_literal(s: &[u8]) -> Box<[u16]> {
         if s.is_empty() {
             return Box::new([]);
         }
-        // `std.unicode.utf8ToUtf16LeStringLiteral` requires valid UTF-8 (Zig
-        // would `catch unreachable` at comptime). simdutf gives us the exact
+        // Input must be valid UTF-8. simdutf gives us the exact
         // UTF-16 code-unit length, then a validating convert.
         let out_len = super::simdutf::length::utf16::from::utf8(s);
         let mut out = vec![0u16; out_len].into_boxed_slice();
@@ -238,11 +231,7 @@ pub mod unicode {
 /// (invalid lead byte → 1). Stops early at EOF or a truncated trailing sequence,
 /// returning the slice up to the last complete codepoint boundary.
 ///
-/// Shared body of `js_parser::Lexer::peek` / `toml::Lexer::peek` (Zig:
-/// `js_lexer.zig:267`, `toml/lexer.zig:128`). Unlike the upstream Zig copies —
-/// whose `*const Self` stepper never advances and re-reads the first byte `n`
-/// times — this helper actually advances; the sole live caller passes ASCII so
-/// the fix is unobservable.
+/// Shared body of `js_parser::Lexer::peek` / `toml::Lexer::peek`.
 #[inline]
 pub fn peek_n_codepoints_wtf8(bytes: &[u8], at: usize, n: usize) -> &[u8] {
     let mut end = at;
@@ -261,10 +250,7 @@ pub fn peek_n_codepoints_wtf8(bytes: &[u8], at: usize, n: usize) -> &[u8] {
 
 /// WTF-8 codepoint stepper shared by the JS / JSON / TOML lexers.
 ///
-/// Zig: `js_parser/lexer.zig` `nextCodepointSlice` / `nextCodepoint` (and the
-/// byte-identical copy in `parsers/toml/lexer.zig`). The Rust port grew a
-/// third copy when `json_lexer.rs` was carved out of `js_parser` to break the
-/// `bun_js_parser ↔ bun_interchange` crate cycle; all three call the same
+/// The JS, JSON, and TOML lexers all call the same
 /// `wtf8_byte_sequence_length_with_invalid` / `decode_wtf8_rune_t_multibyte`
 /// pair defined alongside this module, so the stepper belongs here.
 ///
@@ -297,8 +283,7 @@ pub mod lexer_step {
     /// EOF or a truncated trailing multibyte sequence.
     ///
     /// Split into an `#[inline(always)]` ASCII/EOF fast path plus an outlined
-    /// multibyte tail so the hot per-byte loop folds into every `step()` site
-    /// (matches Zig's per-byte `ptr[current]` increment).
+    /// multibyte tail so the hot per-byte loop folds into every `step()` site.
     #[inline(always)]
     pub fn next_codepoint(contents: &[u8], current: &mut usize, end: &mut usize) -> CodePoint {
         let len = contents.len();
@@ -332,8 +317,6 @@ pub mod lexer_step {
         let cp_len = wtf8_byte_sequence_length_with_invalid(first) as usize;
         let avail = len - *current;
 
-        // Zig spec (lexer.zig nextCodepoint): `switch (slice.len) { 0 => -1, 1 => slice[0], else => decode }`
-        // where `slice` is empty when `cp_len + current > len` and `cp_len` bytes otherwise.
         // The ASCII fast path above handled `first < 0x80`; here `first >= 0x80` but `cp_len`
         // may still be 1 for invalid lead bytes (0x80-0xBF, 0xF8-0xFF) — those must yield the
         // raw byte, NOT the EOF sentinel, so the main lex loop falls through to its syntax-error
@@ -341,7 +324,7 @@ pub mod lexer_step {
         let code_point: CodePoint = if cp_len == 1 {
             first as CodePoint
         } else if avail < cp_len {
-            // truncated multibyte at EOF → Zig's empty-slice arm
+            // truncated multibyte at EOF
             -1
         } else {
             let mut quad = [0u8; 4];
@@ -369,8 +352,7 @@ pub mod lexer_step {
     }
 }
 
-/// Strip a leading UTF-8 BOM (`EF BB BF`) if present. Mirrors
-/// `bun.strings.withoutUTF8BOM` (immutable.zig:2332 → unicode.withoutUTF8BOM).
+/// Strip a leading UTF-8 BOM (`EF BB BF`) if present.
 #[inline]
 pub fn without_utf8_bom(bytes: &[u8]) -> &[u8] {
     if bytes.len() >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF {
@@ -382,7 +364,7 @@ pub fn without_utf8_bom(bytes: &[u8]) -> &[u8] {
 
 // Transcoding suite re-exported from bun_core (T0).
 pub use self::unicode::to_utf16_literal;
-/// `bun.strings.w` — comptime UTF-8→UTF-16 literal. In Rust this **must** be a
+/// Compile-time UTF-8→UTF-16 literal. This **must** be a
 /// macro (callers write `bun_core::strings::w!("…")`); a `fn` returning
 /// `&'static [u16]` would require leaking. Re-export of the crate-root `w!`.
 pub use crate::string::w;
@@ -467,7 +449,7 @@ pub fn contains_char(self_: &[u8], char: u8) -> bool {
 
 #[inline]
 pub fn contains_char_t<T: crate::NoUninit + Eq + Into<u32>>(self_: &[T], char: u8) -> bool {
-    // TODO(port): Zig dispatched on T at comptime; in Rust we branch on size_of.
+    // Branch on size_of (const-folded).
     if core::mem::size_of::<T>() == 1 {
         contains_char(reinterpret_to_u8(self_), char)
     } else {
@@ -477,10 +459,8 @@ pub fn contains_char_t<T: crate::NoUninit + Eq + Into<u32>>(self_: &[T], char: u
 
 #[inline]
 pub fn contains(self_: &[u8], str: &[u8]) -> bool {
-    // Zig: containsT(u8) → indexOfT(u8) → indexOf, which routes through
-    // std.mem.indexOf and returns None for empty needle. The generic
-    // index_of_t below returns Some(0) for empty, so dispatch to the
-    // u8-specific index_of (which matches Zig/std.mem semantics).
+    // The generic index_of_t below returns Some(0) for an empty needle, so
+    // dispatch to the u8-specific index_of (which returns None for empty).
     index_of(self_, str).is_some()
 }
 
@@ -493,8 +473,7 @@ pub fn contains_t<T: Eq>(self_: &[T], str: &[T]) -> bool {
 // reach without depending on this crate); re-export to avoid a second copy.
 pub use crate::strings::contains_case_insensitive_ascii;
 
-/// Zig: `std.meta.Int(.unsigned, @bitSizeOf(usize) - 1)` — fits in 63/31 bits so
-/// `?OptionalUsize` is word-sized via niche. Rust `Option<u32>` already niches; keep
+/// `Option<u32>` already niches; keep
 /// `u32` to match call sites that take `u32` indices throughout this module.
 pub type OptionalUsize = u32;
 
@@ -511,11 +490,9 @@ pub fn index_of_any16(self_: &[u16], str: &'static [u16]) -> Option<OptionalUsiz
 }
 
 pub fn index_of_any_t<T: Copy + Eq>(str: &[T], chars: &'static [T]) -> Option<OptionalUsize> {
-    // TODO(port): Zig specialized T==u8 → index_of_any (highway). Rust cannot
-    // dispatch on type identity without specialization; callers with u8 should
-    // call index_of_any directly.
+    // Rust cannot dispatch on type identity without specialization;
+    // callers with u8 should call index_of_any directly (highway-accelerated).
     for (i, c) in str.iter().enumerate() {
-        // PERF(port): was `inline for` over chars — profile if hot.
         for a in chars {
             if *c == *a {
                 return Some(OptionalUsize::try_from(i).unwrap());
@@ -533,8 +510,7 @@ pub fn contains_comptime(self_: &[u8], str: &'static [u8]) -> bool {
         return false;
     };
     let mut remain = &self_[start..];
-    // PERF(port): Zig used a comptime-sized integer bitcast for the comparison.
-    // Use slice equality; LLVM should emit equivalent code for small fixed lengths.
+    // PERF: slice equality; LLVM should emit good code for small fixed lengths.
     while remain.len() >= str.len() {
         if &remain[..str.len()] == str {
             return true;
@@ -572,7 +548,7 @@ pub fn in_map_case_insensitive<V: Copy>(
 
 #[inline]
 pub fn contains_any(in_: &[&[u8]], target: &[u8]) -> bool {
-    // TODO(port): Zig accepted `anytype` and handled both `[]const u8` and `u8` elements.
+    // Callers pass slices — use `contains_char` for single-byte targets.
     for str in in_ {
         if contains(str, target) {
             return true;
@@ -638,8 +614,6 @@ pub fn is_npm_package_name_ignore_length(target: &[u8]) -> bool {
 
 // Secret-redaction scanners are canonical in crate::strings (only callers
 // live in bun_core/fmt.rs). Re-exported here to preserve the bun.strings.* path.
-// NOTE: starts_with_npm_secret now returns usize (was u8 in the Zig-literal port);
-// no external callers depended on the narrow type.
 pub use crate::strings::{
     find_url_password, is_uuid, starts_with_npm_secret, starts_with_secret, starts_with_uuid,
 };
@@ -648,7 +622,6 @@ pub const UUID_LEN: usize = 36;
 
 pub fn index_any_comptime(target: &[u8], chars: &'static [u8]) -> Option<usize> {
     for (i, &parent) in target.iter().enumerate() {
-        // PERF(port): was `inline for` — profile if hot.
         for &char in chars {
             if char == parent {
                 return Some(i);
@@ -660,7 +633,6 @@ pub fn index_any_comptime(target: &[u8], chars: &'static [u8]) -> Option<usize>
 
 pub fn index_any_comptime_t<T: Copy + Eq>(target: &[T], chars: &'static [T]) -> Option<usize> {
     for (i, parent) in target.iter().enumerate() {
-        // PERF(port): was `inline for` — profile if hot.
         for char in chars {
             if *char == *parent {
                 return Some(i);
@@ -680,7 +652,7 @@ pub fn index_equal_any(in_: &[&[u8]], target: &[u8]) -> Option<usize> {
 }
 
 pub fn repeating_alloc(count: usize, char: u8) -> Result<Box<[u8]>, AllocError> {
-    // PORT NOTE: allocator param dropped (global mimalloc).
+    // allocator param dropped (global mimalloc).
     Ok(vec![char; count].into_boxed_slice())
 }
 
@@ -698,8 +670,7 @@ pub fn index_of_char_neg(self_: &[u8], char: u8) -> i32 {
 }
 
 pub fn index_of_signed(self_: &[u8], str: &[u8]) -> i32 {
-    // std.mem.indexOf returns 0 for an empty needle; bun's `index_of` returns
-    // None. Match Zig semantics here (immutable.zig:412).
+    // bun's `index_of` returns None for an empty needle; this fn returns 0.
     if str.is_empty() {
         return 0;
     }
@@ -743,7 +714,7 @@ pub fn last_index_of(self_: &[u8], str: &[u8]) -> Option<usize> {
     bstr::ByteSlice::rfind(self_, str)
 }
 
-/// Generic `std.mem.lastIndexOf(T, haystack, needle)`.
+/// Generic reverse substring search (last occurrence of `needle`).
 /// For `T = u8` prefer [`last_index_of`] (SIMD memmem).
 pub fn last_index_of_t<T: Eq>(haystack: &[T], needle: &[T]) -> Option<usize> {
     if needle.is_empty() {
@@ -773,8 +744,8 @@ pub fn index_of(self_: &[u8], str: &[u8]) -> Option<usize> {
 }
 
 pub fn index_of_t<T: Eq>(haystack: &[T], needle: &[T]) -> Option<usize> {
-    // TODO(port): Zig specialized T==u8 → index_of (memmem). Callers with u8
-    // should call index_of directly; generic path uses naive search.
+    // Callers with u8 should call index_of directly (memmem);
+    // this generic path uses naive search.
     if needle.is_empty() {
         return Some(0);
     }
@@ -832,7 +803,7 @@ impl<'a> SplitIterator<'a> {
 }
 
 pub fn cat(first: &[u8], second: &[u8]) -> Result<Box<[u8]>, AllocError> {
-    // PORT NOTE: allocator param dropped (global mimalloc).
+    // allocator param dropped (global mimalloc).
     let mut out = Vec::with_capacity(first.len() + second.len());
     out.extend_from_slice(first);
     out.extend_from_slice(second);
@@ -843,10 +814,9 @@ pub fn cat(first: &[u8], second: &[u8]) -> Result<Box<[u8]>, AllocError> {
 //
 // PERF NOTE: `remainder_buf` is `MaybeUninit` because `init`/`init_lower_case`
 // only write `[0..len]` (or `[0..16]` for the slice case) and `slice()` only
-// reads `[0..remainder_len]`. Zig leaves the tail `undefined`; the original
-// Rust port zeroed `[0; 31]` on every call which showed up as ~0.45% of cycles
-// in the next-lint profile (~6M calls × ~24B avg waste). Tail bytes have no
-// validity requirement, so we leave them uninit to match Zig.
+// reads `[0..remainder_len]`. Zeroing `[0; 31]` on every call showed up as
+// ~0.45% of cycles in the next-lint profile (~6M calls × ~24B avg waste).
+// Tail bytes have no validity requirement, so we leave them uninit.
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct StringOrTinyString {
@@ -906,9 +876,7 @@ impl StringOrTinyString {
         }
     }
 
-    // PORT NOTE: Zig deinit was a no-op (commented-out free). No Drop impl.
-
-    // PORT NOTE: plain `#[inline]` (not `#[inline(always)]`). These are tiny
+    // plain `#[inline]` (not `#[inline(always)]`). These are tiny
     // generic delegators: a length check plus a tail call into the non-generic
     // `init`/`init_lower_case` or the `Appender` method. `#[inline]` lets the
     // small fast path fold into callers (and lets duplicate `A` instantiations
@@ -993,7 +961,7 @@ impl StringOrTinyString {
             1..=Self::MAX => {
                 // Inline ASCII-lowercase loop (≤31 iters). Avoids forming `&mut [u8]`
                 // over uninit storage that `copy_lowercase` would need; semantics are
-                // identical (Zig's copyLowercase only ASCII-lowercases).
+                // identical (`copy_lowercase` only ASCII-lowercases).
                 let dst = buf.as_mut_ptr().cast::<u8>();
                 for (i, &c) in stringy.iter().enumerate() {
                     // SAFETY: i < stringy.len() <= 31 == MAX.
@@ -1030,7 +998,6 @@ impl StringOrTinyString {
 }
 
 /// Trait for the `Appender` parameter on `StringOrTinyString::init*_append_if_needed`.
-/// Zig used `comptime Appender: type` + duck-typed `.append`/`.appendLowerCase`.
 pub trait Appender {
     fn append(&mut self, s: &[u8]) -> Result<&[u8], AllocError>;
     fn append_lower_case(&mut self, s: &[u8]) -> Result<&[u8], AllocError>;
@@ -1186,7 +1153,6 @@ pub fn quoted_alloc(self_: &[u8]) -> Result<Box<[u8]>, AllocError> {
 }
 
 pub fn eql_any_comptime(self_: &[u8], list: &'static [&'static [u8]]) -> bool {
-    // PERF(port): was `inline for` — profile if hot.
     for item in list {
         if eql_comptime_check_len_with_type::<u8, true>(self_, item) {
             return true;
@@ -1198,8 +1164,7 @@ pub fn eql_any_comptime(self_: &[u8], list: &'static [&'static [u8]]) -> bool {
 /// Count the occurrences of a character in an ASCII byte array
 /// uses SIMD
 pub fn count_char(self_: &[u8], char: u8) -> usize {
-    // PERF(port): Zig used @Vector(16, u8) + @popCount + @reduce. Scalar
-    // count here; consider portable_simd or a highway intrinsic if hot.
+    // PERF: scalar count; consider portable_simd or a highway intrinsic if hot.
     let mut total: usize = 0;
     for &c in self_ {
         total += (c == char) as usize;
@@ -1210,7 +1175,6 @@ pub fn count_char(self_: &[u8], char: u8) -> usize {
 pub fn ends_with_any_comptime(self_: &[u8], str: &'static [u8]) -> bool {
     if str.len() < 10 {
         let last = self_[self_.len() - 1];
-        // PERF(port): was `inline for` — profile if hot.
         for &char in str {
             if char == last {
                 return true;
@@ -1230,7 +1194,7 @@ pub fn eql(self_: &[u8], other: &[u8]) -> bool {
 }
 
 pub fn eql_comptime_t<T: crate::NoUninit + Eq>(self_: &[T], alt: &'static [u8]) -> bool {
-    // TODO(port): Zig dispatched on T at comptime (u16 → eql_comptime_utf16).
+    // Branch on size_of (const-folded): 2-byte T → eql_comptime_utf16.
     if core::mem::size_of::<T>() == 2 {
         // `NoUninit` + size_of::<T>()==2 lets bytemuck prove the &[T]→&[u16]
         // reinterpret is sound (align checked at runtime; T is u16 in practice).
@@ -1248,7 +1212,7 @@ pub fn eql_comptime(self_: &[u8], alt: &'static [u8]) -> bool {
 pub fn eql_comptime_utf16(self_: &[u16], alt: &[u8]) -> bool {
     // Compare bytewise, widening each ASCII byte of `alt` on the fly — avoids
     // materializing (and leaking) a `&'static [u16]`. All call sites pass
-    // ASCII literals (Zig was `comptime`).
+    // ASCII literals.
     debug_assert!(alt.iter().all(|&b| b < 0x80));
     self_.len() == alt.len()
         && self_
@@ -1276,8 +1240,7 @@ pub fn has_prefix_comptime_utf16(self_: &[u16], alt: &'static [u8]) -> bool {
 }
 
 pub fn has_prefix_comptime_type<T: crate::NoUninit + Eq>(self_: &[T], alt: &'static [T]) -> bool {
-    // TODO(port): Zig accepted heterogeneous `alt: anytype` and widened u8→u16 via `w(alt)`.
-    // Rust callers must pass the correctly-typed literal (use `crate::string::w!` for u16).
+    // Callers must pass the correctly-typed literal (use `crate::string::w!` for u16).
     self_.len() >= alt.len()
         && eql_comptime_check_len_with_type::<T, false>(&self_[0..alt.len()], alt)
 }
@@ -1288,16 +1251,15 @@ pub fn has_suffix_comptime(self_: &[u8], alt: &'static [u8]) -> bool {
 }
 
 fn eql_comptime_check_len_u8(a: &[u8], b: &[u8], check_len: bool) -> bool {
-    // PERF(port): Zig unrolled at comptime over b.len in usize/u32/u16/u8 chunks.
-    // Rust cannot iterate a runtime slice at const-eval. Slice equality compiles
-    // to memcmp; for short literals LLVM should emit comparable code.
+    // Slice equality compiles to memcmp; for short literals LLVM emits
+    // unrolled fixed-size compares.
     if check_len {
         return a == b;
     }
     debug_assert!(a.len() >= b.len());
     // SAFETY: when `check_len`, the early-return above gives `a.len()==b.len()`.
-    // When `!check_len`, callers guarantee `a.len() >= b.len()` (mirrors the
-    // Zig `eqlComptimeCheckLenU8` contract). LLVM cannot prove the latter, so
+    // When `!check_len`, callers guarantee `a.len() >= b.len()` (debug-asserted
+    // above). LLVM cannot prove the latter, so
     // a checked slice would emit a real bounds check on this hot path
     // (lexer keyword/prefix matching) — keep the unchecked index.
     unsafe { a.get_unchecked(..b.len()) == b }
@@ -1314,7 +1276,7 @@ fn eql_comptime_check_len_with_known_type<T: crate::NoUninit + Eq, const CHECK_L
     eql_comptime_check_len_u8(reinterpret_to_u8(a), reinterpret_to_u8(b), CHECK_LEN)
 }
 
-/// Check if two strings are equal with one of the strings being a comptime-known value
+/// Check if two strings are equal with one of the strings being a compile-time-known value
 ///
 ///   strings.eql_comptime(input, b"hello world");
 ///   strings.eql_comptime(input, b"hai");
@@ -1322,9 +1284,7 @@ pub fn eql_comptime_check_len_with_type<T: crate::NoUninit + Eq, const CHECK_LEN
     a: &[T],
     b: &[T],
 ) -> bool {
-    // PORT NOTE: Zig coerced array-by-value `b` to a pointer here. The Zig
-    // version's `comptime` literal is unenforceable in Rust, so accept any
-    // slice; callers are still expected to pass literals.
+    // Accepts any slice; callers are still expected to pass literals.
     eql_comptime_check_len_with_known_type::<T, CHECK_LEN>(a, b)
 }
 
@@ -1334,16 +1294,15 @@ pub fn eql_case_insensitive_ascii_ignore_length(a: &[u8], b: &[u8]) -> bool {
 
 pub use crate::strings::eql_case_insensitive_ascii_check_length;
 
-/// Preserves Zig's triple-`i` typo (`eqlCaseInsensitiveASCIIICheckLength`); both
-/// spellings are reachable from ported call sites until the next typo sweep.
+/// The triple-`i` typo spelling is kept deliberately; both spellings are
+/// reachable from existing call sites until the next typo sweep.
 #[inline]
 pub fn eql_case_insensitive_asciii_check_length(a: &[u8], b: &[u8]) -> bool {
     eql_case_insensitive_ascii(a, b, true)
 }
 
-// PORT NOTE: Zig's `comptime check_len: bool` was first ported as a const
-// generic, but the dominant call shape across the tree passes it as a runtime
-// 3rd arg (`eql_case_insensitive_ascii(a, b, true)`). Accept it at runtime —
+// `check_len` is a runtime 3rd arg because that's the dominant call shape
+// across the tree (`eql_case_insensitive_ascii(a, b, true)`) —
 // the branch is trivially predicted/inlined; callers wanting the
 // length-agnostic forms still have the `_check_length` / `_ignore_length`
 // wrappers above.
@@ -1409,9 +1368,8 @@ pub fn eql_long_t<T: crate::NoUninit, const CHECK_LEN: bool>(a_str: &[T], b_str:
     eql_long(reinterpret_to_u8(a_str), reinterpret_to_u8(b_str), false)
 }
 
-// PORT NOTE: same rationale as `eql_case_insensitive_ascii` — Zig's
-// `comptime check_len: bool` becomes a runtime 3rd arg to match the dominant
-// ported call shape (`eql_long(a, b, true)`).
+// same rationale as `eql_case_insensitive_ascii` — `check_len` is a runtime
+// 3rd arg to match the dominant call shape (`eql_long(a, b, true)`).
 #[inline]
 pub fn eql_long(a_str: &[u8], b_str: &[u8], check_len: bool) -> bool {
     let len = b_str.len();
@@ -1427,8 +1385,9 @@ pub fn eql_long(a_str: &[u8], b_str: &[u8], check_len: bool) -> bool {
         debug_assert!(b_str.len() <= a_str.len());
     }
 
-    // SAFETY: a_str.len() >= b_str.len() by contract above; raw-pointer walk
-    // mirrors Zig's word-chunked compare exactly.
+    // SAFETY: a_str.len() >= b_str.len() by contract above (checked when
+    // `check_len`, debug-asserted otherwise), so the word-chunked raw-pointer
+    // walk below never reads past either slice.
     unsafe {
         let end = b_str.as_ptr().add(len);
         let mut a = a_str.as_ptr();
@@ -1495,7 +1454,6 @@ pub fn append(self_: &[u8], other: &[u8]) -> Box<[u8]> {
 
 #[inline]
 pub fn concat_alloc_t<T: Copy>(strs: &[&[T]]) -> Result<Box<[T]>, AllocError> {
-    // PORT NOTE: Zig took `strs: anytype` (tuple) and inline-for'd. Slice-of-slices here.
     let len: usize = strs.iter().map(|s| s.len()).sum();
     let mut buf = Vec::with_capacity(len);
     for s in strs {
@@ -1534,7 +1492,7 @@ pub fn substring(self_: &[u8], start: Option<usize>, stop: Option<usize>) -> &[u
 
 // (UTF16Replacement / utf16_codepoint{,_with_fffd} — deleted; re-exported from unicode_draft above)
 
-/// `w!("foo")` → `&'static [u16]` UTF-16 literal (ASCII-only). Zig's `bun.w`.
+/// `w!("foo")` → `&'static [u16]` UTF-16 literal (ASCII-only). `bun.w`.
 #[macro_export]
 macro_rules! w {
     ($s:literal) => {{
@@ -1544,7 +1502,10 @@ macro_rules! w {
             let mut out = [0u16; __N];
             let mut i = 0;
             while i < __N {
-                debug_assert!(__B[i] < 0x80, "w! is ASCII-only");
+                // Const-evaluated: a non-ASCII byte is a hard compile error in
+                // every profile (`to_utf16_literal!` forwards here, so this
+                // also keeps that alias from silently mis-encoding non-ASCII).
+                assert!(__B[i] < 0x80, "w! is ASCII-only");
                 out[i] = __B[i] as u16;
                 i += 1;
             }
@@ -1555,7 +1516,7 @@ macro_rules! w {
 }
 
 /// Index of first non-ASCII byte. Thin `u32` view over the canonical
-/// `crate::strings_impl::first_non_ascii` (Zig spec `firstNonASCII -> ?u32`).
+/// `crate::strings_impl::first_non_ascii`.
 /// NOTE: must call `strings_impl` directly — `crate::strings::first_non_ascii`
 /// re-exports *this* function (177f671a9046), so routing through it recurses.
 #[inline]
@@ -1563,7 +1524,7 @@ pub fn first_non_ascii(slice: &[u8]) -> Option<u32> {
     crate::strings_impl::first_non_ascii(slice).map(|i| i as u32)
 }
 
-/// `bun.strings.isValidUTF8` — SIMD-validated UTF-8 check (immutable.zig).
+/// `bun.strings.isValidUTF8` — SIMD-validated UTF-8 check.
 /// Wraps `simdutf::validate::utf8`; the gated `unicode_draft` adds a
 /// `bun.FeatureFlags.use_simdutf` toggle + scalar fallback.
 #[inline]
@@ -1616,8 +1577,8 @@ pub fn index_of_space_or_newline_or_non_ascii(slice_: &[u8], offset: u32) -> Opt
     }
 
     let i = highway::index_of_space_or_newline_or_non_ascii(remaining)?;
-    // PORT NOTE: Zig uses @truncate here (immutable.zig:1194); match wrapping semantics
-    // instead of try_from().unwrap() which would panic on >4GB inputs.
+    // Wrapping cast instead of try_from().unwrap(), which would panic on
+    // >4GB inputs.
     Some(i as u32 + offset)
 }
 
@@ -1641,8 +1602,8 @@ pub fn index_of_newline_or_non_ascii_check_start<const CHECK_START: bool>(
     }
 
     let i = highway::index_of_newline_or_non_ascii(remaining)?;
-    // PORT NOTE: Zig uses @truncate here (immutable.zig:1212); match wrapping semantics
-    // instead of try_from().unwrap() which would panic on >4GB inputs.
+    // Wrapping cast instead of try_from().unwrap(), which would panic on
+    // >4GB inputs.
     Some(i as u32 + offset)
 }
 
@@ -1684,8 +1645,7 @@ pub fn index_of_needs_url_encode(slice: &[u8]) -> Option<u32> {
         return Some(0);
     }
 
-    // PERF(port): Zig used @Vector(16,u8) compare + @ctz on bitmask. Scalar loop
-    // here; consider portable_simd or a highway entry point if hot.
+    // PERF: scalar loop; consider portable_simd or a highway entry point if hot.
     for (i, &char) in slice.iter().enumerate() {
         if char > 127
             || char < 0x20
@@ -1700,7 +1660,7 @@ pub fn index_of_needs_url_encode(slice: &[u8]) -> Option<u32> {
             || char == b'|'
             || char == b'~'
         {
-            // PORT NOTE: Zig uses @truncate (immutable.zig:1292); match wrapping semantics.
+            // Wrapping cast.
             return Some(i as u32);
         }
     }
@@ -1709,12 +1669,11 @@ pub fn index_of_needs_url_encode(slice: &[u8]) -> Option<u32> {
 }
 
 pub fn index_of_char_z(slice_z: &crate::string::ZStr, char: u8) -> Option<u64> {
-    // Zig returned ?u63; use u64 in Rust (no u63).
     highway::index_of_char(slice_z.as_bytes(), char).map(|i| i as u64)
 }
 
 pub fn index_of_char(slice: &[u8], char: u8) -> Option<u32> {
-    // PORT NOTE: Zig uses @truncate (immutable.zig:1304); match wrapping semantics.
+    // Wrapping cast.
     index_of_char_usize(slice, char).map(|i| i as u32)
 }
 
@@ -1757,10 +1716,10 @@ pub fn index_of_not_char(slice: &[u8], char: u8) -> Option<u32> {
         return Some(0);
     }
 
-    // PERF(port): Zig used @Vector(16,u8) != splat + @ctz. Scalar loop here.
+    // PERF: scalar loop; consider a SIMD entry point if hot.
     for (i, &current) in slice.iter().enumerate() {
         if current != char {
-            // PORT NOTE: Zig uses @truncate (immutable.zig:1360); match wrapping semantics.
+            // Wrapping cast.
             return Some(i as u32);
         }
     }
@@ -1964,7 +1923,7 @@ pub fn trim_suffix_comptime<'a>(buffer: &'a [u8], suffix: &'static [u8]) -> &'a
     }
 }
 
-/// Non-comptime variants — runtime prefix/suffix may borrow from a non-static
+/// Runtime variants — prefix/suffix may borrow from a non-static
 /// buffer (`hosted_git_info`, `npm-pack-args` parsers).
 #[inline]
 pub fn trim_prefix<'a>(buffer: &'a [u8], prefix: &[u8]) -> &'a [u8] {
@@ -2007,12 +1966,11 @@ pub fn index_of_line_ranges<const LINE_RANGE_COUNT: usize>(
         index_of_newline_or_non_ascii_check_start::<true>(text, 0)
     else {
         if target_line == 0 {
-            // PERF(port): was assume_capacity
             let _ = ranges.push(LineRange {
                 start: 0,
-                // PORT NOTE: Zig uses @truncate(text.len) (immutable.zig:1595); match wrapping semantics.
+                // Wrapping cast.
                 end: text.len() as u32,
-            }); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            }); // OOM/capacity: fire-and-forget
         }
         return ranges;
     };
@@ -2048,13 +2006,13 @@ pub fn index_of_line_ranges<const LINE_RANGE_COUNT: usize>(
         }
         let _ = ranges.push(LineRange {
             start: 0,
-            // PORT NOTE: Zig uses @truncate(text.len) (immutable.zig:1635); match wrapping semantics.
+            // Wrapping cast.
             end: text.len() as u32,
         });
         return ranges;
     };
 
-    let _ = ranges.push(first_newline_range); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+    let _ = ranges.push(first_newline_range); // OOM/capacity: fire-and-forget
 
     if target_line == 0 {
         return ranges;
@@ -2084,7 +2042,7 @@ pub fn index_of_line_ranges<const LINE_RANGE_COUNT: usize>(
                         start: prev_end,
                         end: current_end,
                     };
-                    prev_end = cursor.i; // Zig: `defer prev_end = cursor.i;`
+                    prev_end = cursor.i;
                     r
                 } else {
                     LineRange {
@@ -2098,10 +2056,10 @@ pub fn index_of_line_ranges<const LINE_RANGE_COUNT: usize>(
 
         if ranges.len() == LINE_RANGE_COUNT && current_line <= target_line {
             let mut new_ranges = BoundedArray::<LineRange, LINE_RANGE_COUNT>::default();
-            let _ = new_ranges.extend_from_slice(&ranges.as_slice()[1..]); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = new_ranges.extend_from_slice(&ranges.as_slice()[1..]); // OOM/capacity: fire-and-forget
             ranges = new_ranges;
         }
-        let _ = ranges.push(current_line_range); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = ranges.push(current_line_range); // OOM/capacity: fire-and-forget
 
         if current_line >= target_line {
             return ranges;
@@ -2112,7 +2070,7 @@ pub fn index_of_line_ranges<const LINE_RANGE_COUNT: usize>(
 
     if ranges.len() == LINE_RANGE_COUNT && current_line <= target_line {
         let mut new_ranges = BoundedArray::<LineRange, LINE_RANGE_COUNT>::default();
-        let _ = new_ranges.extend_from_slice(&ranges.as_slice()[1..]); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = new_ranges.extend_from_slice(&ranges.as_slice()[1..]); // OOM/capacity: fire-and-forget
         ranges = new_ranges;
     }
 
@@ -2130,25 +2088,23 @@ pub fn get_lines_in_text<const LINE_RANGE_COUNT: usize>(
     }
     let mut results = BoundedArray::<&[u8], LINE_RANGE_COUNT>::default();
     for range in ranges.as_slice() {
-        let _ = results.push(&text[range.start as usize..range.end as usize]); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = results.push(&text[range.start as usize..range.end as usize]); // OOM/capacity: fire-and-forget
     }
     results.as_mut_slice().reverse();
     Some(results)
 }
 
 pub fn first_non_ascii16(slice: &[u16]) -> Option<u32> {
-    // PERF(port): Zig used @Vector(8,u16) max-reduce + @ctz on bitmask. Scalar
-    // loop here; consider portable_simd or a simdutf utf16 validator if hot.
+    // PERF: scalar loop; consider portable_simd or a simdutf utf16 validator if hot.
     for (i, &char) in slice.iter().enumerate() {
         if char > 127 {
-            // PORT NOTE: Zig uses @truncate(i) (immutable.zig:1766); match wrapping semantics.
+            // Wrapping cast.
             return Some(i as u32);
         }
     }
     None
 }
 
-// this is std.mem.trim except it doesn't forcibly change the slice to be const
 pub use crate::strings::trim;
 
 pub fn trim_spaces(slice: &[u8]) -> &[u8] {
@@ -2181,7 +2137,6 @@ pub fn length_of_leading_whitespace_ascii(slice: &[u8]) -> usize {
 }
 
 pub fn join(slices: &[&[u8]], delimiter: &[u8]) -> Result<Box<[u8]>, AllocError> {
-    // PORT NOTE: std.mem.join — reimplemented over Vec<u8> (no allocator param).
     if slices.is_empty() {
         return Ok(Box::default());
     }
@@ -2197,25 +2152,23 @@ pub fn join(slices: &[&[u8]], delimiter: &[u8]) -> Result<Box<[u8]>, AllocError>
 }
 
 // ── Lexicographic slice ordering ──────────────────────────────────────────
-// Canonical home for what Zig calls `std.mem.order`. The Zig tree had three
-// hand-rolled copies (bun.strings.order, md.entity.orderStrings,
-// ast.e.stringCompareForJavaScript); the Rust port keeps exactly one of each
-// shape here.
+// Canonical home for lexicographic slice ordering; exactly one copy of each
+// shape lives here.
 
 /// Lexicographic byte-slice ordering (memcmp fast path).
-/// Semantically identical to `<[u8] as Ord>::cmp` / Zig `std.mem.order(u8, a, b)`.
+/// Semantically identical to `<[u8] as Ord>::cmp`.
 ///
 /// Delegates to `<[u8] as Ord>::cmp` rather than an extern `libc::memcmp` call:
 /// the std specialisation lowers to the `memcmp` LLVM builtin, so LLVM can
-/// inline the short-string fast path and skip the PLT trampoline — matching
-/// what Zig gets for `bun.c.memcmp` after LTO. `#[inline(always)]` because this
+/// inline the short-string fast path and skip the PLT trampoline.
+/// `#[inline(always)]` because this
 /// sits inside `sort_unstable_by` comparators on the install hot path.
 #[inline(always)]
 pub fn order(a: &[u8], b: &[u8]) -> Ordering {
     a.cmp(b)
 }
 
-/// Generic lexicographic slice ordering — Zig `std.mem.order(T, a, b)`.
+/// Generic lexicographic slice ordering.
 /// For `T = u8` prefer [`order`] (memcmp fast path).
 #[inline]
 pub fn order_t<T: Ord>(a: &[T], b: &[T]) -> Ordering {
@@ -2230,17 +2183,18 @@ pub fn cmp_strings_desc(_: (), a: &[u8], b: &[u8]) -> bool {
     order(a, b) == Ordering::Greater
 }
 
-/// Every time you read a non^2 sized integer, Zig masks off the extra bits.
-/// This is a meaningful performance difference, including in release builds.
+/// `u8` rather than a narrower 3-bit integer type: masking off the extra bits
+/// on every read is a meaningful performance difference, including in release
+/// builds.
 pub type U3Fast = u8;
 
 pub fn sort_asc(in_: &mut [&[u8]]) {
-    // TODO: experiment with simd to see if it's faster
+    // Perf: a SIMD comparator might be faster here; never measured.
     in_.sort_unstable_by(|a, b| order(a, b));
 }
 
 pub fn sort_desc(in_: &mut [&[u8]]) {
-    // TODO: experiment with simd to see if it's faster
+    // Perf: a SIMD comparator might be faster here; never measured.
     in_.sort_unstable_by(|a, b| order(b, a));
 }
 
@@ -2260,12 +2214,11 @@ impl<'a> StringArrayByIndexSorter<'a> {
 
 #[inline]
 pub fn to_ascii_hex_value(character: u8) -> u8 {
-    // Zig parity: bun.strings.toASCIIHexValue (precondition-based, no Option).
+    // Precondition-based (no Option).
     debug_assert!(character.is_ascii_hexdigit());
     crate::fmt::hex_digit_value(character).expect("ascii hex digit")
 }
 
-/// Zig: `fn NewLengthSorter(comptime Type, comptime field) type`.
 /// Rust cannot take a field name as a const param; use an accessor fn.
 pub struct LengthSorter<T, F: Fn(&T) -> &[u8]>(pub F, core::marker::PhantomData<T>);
 impl<T, F: Fn(&T) -> &[u8]> LengthSorter<T, F> {
@@ -2320,10 +2273,9 @@ impl<T, F: Fn(&T) -> &[u8]> GlobLengthSorter<T, F> {
     }
 }
 
-/// Reflection adapter for [`move_all_slices`]. Zig's `moveAllSlices` used
-/// `std.meta.fields(Type)` to enumerate every `[]const u8` field at comptime;
+/// Reflection adapter for [`move_all_slices`].
 /// Rust has no field reflection, so each container type hand-implements this
-/// trait (or, once landed, `#[derive(MoveSlices)]`) to yield the same set of
+/// trait (or, once landed, `#[derive(MoveSlices)]`) to yield its byte-slice
 /// fields as `&mut &'a [u8]` so they can be re-pointed into a new backing
 /// buffer of lifetime `'a` without any unsafe.
 pub trait MoveSlices<'a> {
@@ -2332,8 +2284,7 @@ pub trait MoveSlices<'a> {
 }
 
 /// Update all `&[u8]` fields in `container` that currently point into `from`
-/// to instead point at the same offset within `to`. Port of
-/// `immutable.zig:moveAllSlices`.
+/// to instead point at the same offset within `to`.
 pub fn move_all_slices<'a, T: MoveSlices<'a> + ?Sized>(
     container: &mut T,
     from: &[u8],
@@ -2344,8 +2295,6 @@ pub fn move_all_slices<'a, T: MoveSlices<'a> + ?Sized>(
     container.for_each_byte_slice_field(&mut |field| {
         let slice_start = field.as_ptr() as usize;
         let slice_end = slice_start + field.len();
-        // `if (@intFromPtr(from.ptr) + from.len) >= @intFromPtr(slice.ptr) + slice.len
-        //   and (@intFromPtr(from.ptr) <= @intFromPtr(slice.ptr))`
         if from_end >= slice_end && from_start <= slice_start {
             *field = move_slice(field, from, to);
         }
@@ -2379,7 +2328,7 @@ pub const UNICODE_REPLACEMENT: u32 = 0xFFFD;
 // UTF-8 encoding of U+FFFD
 pub const UNICODE_REPLACEMENT_STR: [u8; 3] = [0xEF, 0xBF, 0xBD];
 
-// Spec (immutable.zig:1990, 2003) calls `bun.c_ares.ares_inet_pton`, the vendored
+// Uses `ares_inet_pton`, the vendored
 // c-ares implementation. Do NOT call the system `inet_pton` here: on Windows that
 // resolves into ws2_32.dll and fails with WSANOTINITIALISED whenever it runs before
 // `WSAStartup()`, which URL/host parsing can. c-ares' impl is pure C, no preconditions.
@@ -2506,7 +2455,7 @@ pub fn concat_if_needed(
     }
 
     if total_length < 1024 {
-        // PERF(port): was stack-fallback allocator. Use a fixed stack buffer.
+        // Use a fixed stack buffer.
         let mut stack_buf = [0u8; 1024];
         let mut off: usize = 0;
         for arg in args {
@@ -2516,9 +2465,8 @@ pub fn concat_if_needed(
         let stack_copy = &stack_buf[0..total_length];
         for &interned in interned_strings_to_check {
             if eql_long(stack_copy, interned, true) {
-                // PERF(port): Zig stored the interned slice directly; with an
-                // owned `Box<[u8]>` dest we copy once. Hit at most once per
-                // JSX config; no leak.
+                // PERF: with an owned `Box<[u8]>` dest we copy once.
+                // Hit at most once per JSX config; no leak.
                 *dest = Box::from(interned);
                 return Ok(());
             }
@@ -2529,7 +2477,7 @@ pub fn concat_if_needed(
         let mut remain: &[u8] = dest;
 
         for arg in args {
-            // PORT NOTE: Zig has `args.len` here (likely a bug); preserved verbatim.
+            // `args.len` (not `arg.len`) is likely a bug; preserved verbatim.
             if args.len() > remain.len() {
                 break 'brk true;
             }
@@ -2591,7 +2539,7 @@ impl Default for QuoteEscapeFormatFlags {
 }
 
 /// usage: print(" string: '{}' ", format_escapes_js("hello'world!"));
-// PERF(port): was comptime monomorphization (Zig `comptime flags: QuoteEscapeFormatFlags`) — profile if hot.
+// PERF: `flags` is a runtime value (not monomorphized) — profile if hot.
 pub fn format_escapes(str: &[u8], flags: QuoteEscapeFormatFlags) -> QuoteEscapeFormat<'_> {
     QuoteEscapeFormat { data: str, flags }
 }
@@ -2603,7 +2551,7 @@ pub struct QuoteEscapeFormat<'a> {
 
 impl core::fmt::Display for QuoteEscapeFormat<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // PERF(port): Zig wrote directly to the writer; here we buffer through
+        // PERF: buffer through
         // a Vec so `write_pre_quoted_string`'s `PrinterWriter` bound is met
         // without an adapter for `core::fmt::Formatter`. Profile if hot.
         let mut buf: Vec<u8> = Vec::with_capacity(self.data.len() + 8);
@@ -2611,7 +2559,7 @@ impl core::fmt::Display for QuoteEscapeFormat<'_> {
             self.data,
             &mut buf,
             self.flags.quote_char,
-            // Zig (immutable.zig:2159) hardcodes `false` here regardless of
+            // Hardcoded `false` regardless of
             // `flags.ascii_only`; the field is dead in QuoteEscapeFormat.
             false,
             self.flags.json,
@@ -2626,7 +2574,7 @@ impl core::fmt::Display for QuoteEscapeFormat<'_> {
 /// Generic. Works on &[u8], &[u16], etc
 #[inline]
 pub fn index_of_scalar<T: crate::NoUninit + Eq>(input: &[T], scalar: T) -> Option<usize> {
-    // TODO(port): Zig specialized T==u8 → index_of_char_usize (highway).
+    // Branch on size_of (const-folded): byte-sized T → index_of_char_usize (highway).
     if core::mem::size_of::<T>() == 1 {
         let scalar_u8 = reinterpret_to_u8(core::slice::from_ref(&scalar))[0];
         return index_of_char_usize(reinterpret_to_u8(input), scalar_u8);
@@ -2733,7 +2681,6 @@ pub fn percent_encode_write(
         writer.reserve(safe.len() + b"%FF".len() * code_point_len);
 
         // Write the safe bytes
-        // PERF(port): was assume_capacity
         writer.extend_from_slice(safe);
 
         // URL encode the code point
@@ -2750,12 +2697,10 @@ pub fn percent_encode_write(
 
 // ───────────── re-exports from sibling modules ─────────────
 
-// Unicode core is re-exported at the top of the file; the remaining submodule
-// re-exports below are still incomplete.
+// Unicode core is re-exported at the top of the file. Further transcoding
+// helpers (unicode_draft) and path helpers (bun_paths) are re-exported on
+// demand as callers need them — see the `crate::strings` re-export block below.
 pub use crate::string::escape_reg_exp::{escape_reg_exp, escape_reg_exp_for_package_name_matching};
-// TODO(port): re-export the rest of the transcoding suite from unicode_draft —
-//   to_utf8_alloc / to_utf16_alloc / convert_* / copy_*_into_* / EncodeIntoResult / BOM / etc.
-// TODO(port): re-export paths::{to_w_path, basename, add_nt_path_prefix, ...}
 
 crate::declare_scope!(STR, hidden);
 // `log` is `bun.Output.scoped(.STR, .hidden)` — use `crate::scoped_log!(STR, ...)`.
@@ -2828,7 +2773,6 @@ impl ANSIIterator {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // `&mut ANSIIterator` is ABI-identical to the C++ `ANSIIterator*` (thin
     // non-null pointer to a `#[repr(C)]` POD struct); C++ reads `input`/
@@ -2855,23 +2799,22 @@ pub fn to_utf8_alloc_with_type(utf16: &[u16]) -> Vec<u8> {
 // ───────────── minimal real impls of submodule fns ─────────────
 // These mirror the same-named fns in `unicode_draft` so dependents can link
 // against `bun_core::strings::*` directly. Each is a thin wrapper over simdutf
-// or the scalar logic from the .zig source.
+// or a scalar fallback.
 
 pub use crate::strings_impl::utf8_byte_sequence_length;
 
-/// `std.mem.trimLeft(u8, str, chars)` — strip leading chars in `values_to_strip`.
+/// Strip leading chars in `values_to_strip`.
 pub use crate::strings::trim_left;
 
-/// `std.mem.trimRight(u8, str, chars)` — strip trailing chars in `values_to_strip`.
+/// Strip trailing chars in `values_to_strip`.
 pub use crate::strings::trim_right;
 
 pub use crate::strings::{replace, replace_owned, replacement_size};
 
-// `std.fmt.parseInt` — moved down to crate::fmt; re-exported for back-compat.
+// Defined in crate::fmt; re-exported here for back-compat.
 pub use crate::fmt::{ParseIntError, parse_int};
 
-/// Compare a UTF-16 string against a UTF-8 string without allocating
-/// (`unicode.zig:utf16EqlString`).
+/// Compare a UTF-16 string against a UTF-8 string without allocating.
 pub fn utf16_eql_string(text: &[u16], str: &[u8]) -> bool {
     if text.len() > str.len() {
         // UTF-16 encoding can never be longer than the UTF-8 encoding.
@@ -2882,8 +2825,8 @@ pub fn utf16_eql_string(text: &[u16], str: &[u8]) -> bool {
     let mut j: usize = 0;
     let mut i: usize = 0;
     while i < n {
-        // Fixes the `|`-precedence bug ported from unicode.zig:1839 — supplementary
-        // code points >= U+20000 mis-decoded with the old open-coded math.
+        // `decode_wtf16_raw` avoids the `|`-precedence bug of the old
+        // open-coded math, which mis-decoded supplementary code points >= U+20000.
         let (cp, adv) = crate::strings::decode_wtf16_raw(&text[i..]);
         i += adv as usize;
         let width = encode_wtf8_rune(&mut temp, cp);
@@ -2900,7 +2843,7 @@ pub fn utf16_eql_string(text: &[u16], str: &[u8]) -> bool {
 
 /// `strings.toUTF16AllocForReal` — like [`to_utf16_alloc`] but **always**
 /// returns a `Vec<u16>` (pure-ASCII inputs are widened 1:1 instead of
-/// returning `None`). Port of `unicode.zig:toUTF16AllocForReal`.
+/// returning `None`).
 pub fn to_utf16_alloc_for_real(
     bytes: &[u8],
     fail_if_invalid: bool,
@@ -2918,7 +2861,7 @@ pub fn to_utf16_alloc_for_real(
     Ok(out)
 }
 
-/// `withoutPrefix` (runtime) — strip `prefix` from `input` if present.
+/// Strip `prefix` from `input` if present.
 /// Unlike `without_prefix_comptime`, this accepts a non-`'static` prefix.
 #[inline]
 pub fn without_prefix<'a>(input: &'a [u8], prefix: &[u8]) -> &'a [u8] {
@@ -2929,26 +2872,23 @@ pub fn without_prefix<'a>(input: &'a [u8], prefix: &[u8]) -> &'a [u8] {
     }
 }
 
-// Zig: `pub const withoutTrailingSlash = paths_.withoutTrailingSlash;`
-// (immutable.zig:2380). The full `paths` submodule now lives in
+// The full `paths` submodule lives in
 // `bun_paths::string_paths` (it depends upward on `bun_paths` resolve/pool
 // helpers and would cycle here). Callers reach the Windows path-shape
 // helpers (`to_nt_path` / `to_kernel32_path` / `from_w_path` / …) via
 // `bun_paths::strings::*`; this module keeps only the re-export of the
 // scalar `without_trailing_slash` already defined in `crate::strings`.
 pub use crate::strings_impl::{remove_leading_dot_slash, without_trailing_slash};
-// Zig: `pub const convertUTF16ToUTF8InBuffer = unicode.convertUTF16ToUTF8InBuffer;`
-// (immutable.zig). Re-export the bun_core implementation so callers can spell
+// Re-export the bun_core implementation so callers can spell
 // `strings::convert_utf16_to_utf8_in_buffer` without reaching into `unicode`.
 pub use crate::strings::convert_utf16_to_utf8_in_buffer;
-// Zig: `pub const convertUTF8toUTF16InBufferZ = unicode.convertUTF8toUTF16InBufferZ;`
-// — re-export the NUL-terminated variant so callers can spell
+// Re-export the NUL-terminated variant so callers can spell
 // `strings::convert_utf8_to_utf16_in_buffer_z` (used by the Windows profilers
 // to widen output paths for `File::write_file_os_path`).
 pub use unicode_draft::convert_utf8_to_utf16_in_buffer_z;
 
 /// `strings.startsWithWindowsDriveLetterT` — true for `[A-Za-z]:` prefix
-/// followed by at least one more byte (Zig: `s.len > 2`).
+/// followed by at least one more byte (`s.len() > 2`).
 #[inline]
 pub fn starts_with_windows_drive_letter_t<T: Copy + Into<u32>>(s: &[T]) -> bool {
     s.len() > 2 && s[1].into() == u32::from(b':') && {
@@ -2962,7 +2902,7 @@ pub fn starts_with_windows_drive_letter_t<T: Copy + Into<u32>>(s: &[T]) -> bool
 /// buffer (capacity ≥ `input.len()` u16). SIMD fast path via simdutf; on invalid
 /// UTF-8 falls back to a scalar WTF-8 decoder that emits U+FFFD for malformed
 /// bytes and passes unpaired surrogates through (so non-empty input never yields
-/// an empty slice — fixes #8197 / the TODO at unicode.zig:1537).
+/// an empty slice — fixes #8197).
 ///
 /// Panics when the output does not fit. Callers that cannot statically size
 /// `buf` for the worst case must use [`try_convert_utf8_to_utf16_in_buffer`].
@@ -3072,24 +3012,21 @@ fn decode_wtf8_one(s: &[u8]) -> (u32, usize) {
 }
 
 /// `strings.toUTF8ListWithType` — append UTF-8 transcoding of `utf16` onto
-/// `list` and return the (possibly-reallocated) list. Port of
-/// `unicode.zig:toUTF8ListWithType` (always uses simdutf path; Bun is built
-/// with `FeatureFlags.use_simdutf = true`).
+/// `list` and return the (possibly-reallocated) list. Always uses the simdutf
+/// path; Bun is built with `FeatureFlags.use_simdutf = true`.
 pub fn to_utf8_list_with_type(mut list: Vec<u8>, utf16: &[u16]) -> Result<Vec<u8>, AllocError> {
     if utf16.is_empty() {
         return Ok(list);
     }
-    // Zig: `list.ensureTotalCapacityPrecise(length + 16)` then `convertUTF16ToUTF8`.
     // `convert_utf16_to_utf8_append` writes directly into `spare_capacity_mut()` and
     // requires the caller to pre-reserve (its doc says so explicitly); without this
     // reserve a fresh `Vec::new()` has a dangling `0x1` spare pointer and simdutf
-    // segfaults writing to it. The +16 padding mirrors Zig's SIMD over-read slack.
+    // segfaults writing to it. The +16 padding gives SIMD over-read slack.
     let length = simdutf::length::utf8::from::utf16::le(utf16);
     list.try_reserve(length + 16).map_err(|_| AllocError)?;
-    // PORT NOTE: Zig's path validates UTF-16 first then falls back to a manual
-    // loop on failure (`toUTF8ListWithTypeBun`). Here we route through
-    // `crate::strings::convert_utf16_to_utf8_append`, which already replaces
-    // unpaired surrogates with U+FFFD — semantically equivalent.
+    // Route through
+    // `crate::strings::convert_utf16_to_utf8_append`, which replaces
+    // unpaired surrogates with U+FFFD.
     crate::strings::convert_utf16_to_utf8_append(&mut list, utf16);
     Ok(list)
 }
@@ -3113,7 +3050,7 @@ impl From<ToUTF16Error> for crate::Error {
 /// any non-ASCII byte; pure-ASCII inputs return `Ok(None)` (caller keeps the
 /// 8-bit form). When `fail_if_invalid` is set, invalid UTF-8 yields
 /// `Err(InvalidByteSequence)`; otherwise invalid sequences are replaced with
-/// U+FFFD (per `unicode.zig:toUTF16Alloc`). When `sentinel` is set the result
+/// U+FFFD. When `sentinel` is set the result
 /// includes a trailing 0 u16.
 pub fn to_utf16_alloc(
     bytes: &[u8],
@@ -3164,9 +3101,9 @@ pub fn to_utf16_alloc(
         // Copy ASCII prefix as-is (one u16 per byte).
         out.extend(remaining[..i].iter().map(|&b| u16::from(b)));
         remaining = &remaining[i..];
-        // Decode one codepoint via the same routine Zig uses
-        // (`convertUTF8BytesIntoUTF16`) so the number/position of U+FFFD
-        // emissions matches: advance by `replacement.len.max(1)`, not 1.
+        // Decode one codepoint via `convert_utf8_bytes_into_utf16` so the
+        // number/position of U+FFFD emissions stays consistent: advance by
+        // `replacement.len.max(1)`, not 1.
         let replacement = unicode_draft::convert_utf8_bytes_into_utf16(remaining);
         remaining = &remaining[(replacement.len as usize).max(1)..];
         push_codepoint_utf16(&mut out, replacement.code_point);
@@ -3181,7 +3118,7 @@ pub fn to_utf16_alloc(
 /// `PATTERN_KEY_COMPARE` from the Node.js ESM resolution spec — the comparator
 /// behind `NewGlobLengthSorter`. Returns an [`Ordering`] suitable for
 /// `slice.sort_by(|a, b| glob_length_compare(a, b))` to sort in **descending
-/// order of specificity** (matches Zig `lessThan` returning `true` ⇒ `Less`).
+/// order of specificity**.
 pub fn glob_length_compare(key_a: &[u8], key_b: &[u8]) -> Ordering {
     let star_a = index_of_char(key_a, b'*');
     let star_b = index_of_char(key_b, b'*');
@@ -3224,5 +3161,3 @@ mod tests {
         assert!(!super::eql_case_insensitive_ascii(b"Ab", b"a", true));
     }
 }
-
-// ported from: src/string/immutable.zig
diff --git a/src/bun_core/string/immutable/exact_size_matcher.rs b/src/bun_core/string/immutable/exact_size_matcher.rs
index b1f31b44e25..3743245d0c0 100644
--- a/src/bun_core/string/immutable/exact_size_matcher.rs
+++ b/src/bun_core/string/immutable/exact_size_matcher.rs
@@ -1,5 +1,3 @@
-//! Port of `src/string/immutable/exact_size_matcher.zig`.
-//!
 //! `ExactSizeMatcher(N)` packs a short byte slice (len ≤ N) into a single
 //! unsigned integer so callers can `match`/`switch` on string literals as
 //! integer constants. Slices longer than N map to `T::MAX` (the "no match"
@@ -8,23 +6,19 @@
 use core::marker::PhantomData;
 
 /// Zero-sized type carrying the `MAX_BYTES` const parameter.
-///
-/// Zig: `pub fn ExactSizeMatcher(comptime max_bytes: usize) type { return struct { ... } }`
 pub struct ExactSizeMatcher<const MAX_BYTES: usize>(PhantomData<[u8; MAX_BYTES]>);
 
-// Compile-time check mirroring Zig's `switch (max_bytes) { 1,2,4,8,12,16 => {}, else => @compileError }`.
-// In Rust this is enforced by only providing `ExactSizeInt` impls for the valid sizes;
+// Only the valid sizes (1, 2, 4, 8, 12, 16) get `ExactSizeInt` impls;
 // any other `MAX_BYTES` fails to satisfy the trait bound at the call site.
 
-/// Maps a `MAX_BYTES` value to its backing unsigned integer type
-/// (`std.meta.Int(.unsigned, max_bytes * 8)` in Zig) and provides the
-/// little-endian read primitive.
+/// Maps a `MAX_BYTES` value to its backing unsigned integer type and provides
+/// the little-endian read primitive.
 pub trait ExactSizeInt<const MAX_BYTES: usize> {
     /// The packed integer type (`u8`/`u16`/`u32`/`u64`/`u128`).
     type T: Copy + Eq + Ord;
     const ZERO: Self::T;
     const MAX: Self::T;
-    /// `std.mem.readInt(T, &buf, .little)`
+    /// Read `Self::T` from `buf` as little-endian.
     fn read_le(buf: &[u8; MAX_BYTES]) -> Self::T;
 }
 
@@ -48,9 +42,9 @@ impl_exact_size_int!(4, u32);
 impl_exact_size_int!(8, u64);
 impl_exact_size_int!(16, u128);
 
-// TODO(port): Zig uses `u96` for MAX_BYTES=12; Rust has no native `u96`.
-// We back it with `u128` and zero-pad the high 4 bytes. `MAX` is the true
-// 96-bit max so the "too long" sentinel is distinct from any 12-byte payload.
+// MAX_BYTES=12 would want a `u96`; Rust has no native `u96`, so we back it
+// with `u128` and zero-pad the high 4 bytes. `MAX` is the true 96-bit max so
+// the "too long" sentinel is distinct from any 12-byte payload.
 impl ExactSizeInt<12> for ExactSizeMatcher<12> {
     type T = u128;
     const ZERO: u128 = 0;
@@ -67,8 +61,6 @@ impl<const MAX_BYTES: usize> ExactSizeMatcher<MAX_BYTES>
 where
     Self: ExactSizeInt<MAX_BYTES>,
 {
-    /// Zig: `pub fn match(str: anytype) T`
-    ///
     /// `r#match` because `match` is a Rust keyword.
     #[inline]
     pub fn r#match(str: &[u8]) -> <Self as ExactSizeInt<MAX_BYTES>>::T {
@@ -90,16 +82,11 @@ where
         }
     }
 
-    /// Zig: `pub fn case(comptime str: []const u8) T`
-    ///
-    /// Runtime variant. For const-position (Zig's comptime use in `switch`
-    /// arms), use the [`exact_case!`] macro below — `const fn` cannot call
-    /// the non-const trait method `read_le` on stable.
+    /// Runtime variant. For const-position use (e.g. in `match` arms), use
+    /// the [`exact_case!`] macro below — `const fn` cannot call the non-const
+    /// trait method `read_le` on stable.
     #[inline(always)]
     pub fn case(str: &'static [u8]) -> <Self as ExactSizeInt<MAX_BYTES>>::T {
-        // if (str.len < max_bytes) { zero-pad } else if (== max_bytes) { read } else { @compileError }
-        // PORT NOTE: reshaped — Zig branches on `<` vs `==` vs `@compileError`;
-        // here we assert `<=` (the compile error) and unify the two valid arms.
         assert!(
             str.len() <= MAX_BYTES,
             "str too long for ExactSizeMatcher::case"
@@ -160,5 +147,3 @@ pub(crate) const fn __pad<const N: usize>(s: &[u8]) -> [u8; N] {
     }
     out
 }
-
-// ported from: src/string/immutable/exact_size_matcher.zig
diff --git a/src/bun_core/string/immutable/unicode.rs b/src/bun_core/string/immutable/unicode.rs
index fffb2df1b99..2ee95cada74 100644
--- a/src/bun_core/string/immutable/unicode.rs
+++ b/src/bun_core/string/immutable/unicode.rs
@@ -1,5 +1,3 @@
-//! Port of `src/string/immutable/unicode.zig`.
-
 use crate::string::WStr;
 use crate::string::immutable::{
     U3Fast, UNICODE_REPLACEMENT as unicode_replacement, eql_comptime_ignore_len as eql_ignore_len,
@@ -44,7 +42,7 @@ fn append_u16_as_u8(dst: &mut Vec<u8>, src: &[u16]) {
     copy_u16_into_u8(unsafe { crate::vec::writable_slice(dst, src.len()) }, src);
 }
 
-// ───── canonical WTF-8 single-rune decode (Zig: unicode.zig decodeWTF8RuneT) ─────
+// ───── canonical WTF-8 single-rune decode ─────
 // Lives in `bun_core::string::immutable::unicode_draft` (this file), re-exported
 // through the inline `pub mod unicode` in immutable.rs and onward as
 // `bun_core::strings::{decode_wtf8_rune_t, decode_wtf8_rune_t_multibyte, codepoint_size}`.
@@ -53,11 +51,11 @@ fn append_u16_as_u8(dst: &mut Vec<u8>, src: &[u16]) {
 // instead of carrying a second body, and so md/glob/parsers can call directly.
 
 /// Integer types usable as the codepoint result of [`decode_wtf8_rune_t`].
-/// Sealed to the two instantiations Zig uses (`i32` aka `CodePoint`, and `u32`);
+/// Sealed to two instantiations (`i32` aka `CodePoint`, and `u32`);
 /// every caller in-tree is one of these. `ZERO_VALUE` is the per-type sentinel
-/// Zig threaded as a `comptime_int` (`-1` for i32, `0` for u32).
+/// (`-1` for i32, `0` for u32).
 ///
-/// PORT NOTE: bounds widened from `From<u8>` to include the bit-ops needed by
+/// Bounds widened from `From<u8>` to include the bit-ops needed by
 /// `decode_wtf8_rune_t_multibyte` plus a `from_u32` constructor (folds in the
 /// previously separate `FromU32`/`FromU32Const` helper traits).
 pub trait CodePointZero:
@@ -133,8 +131,7 @@ pub use crate::strings::codepoint_size;
 //     contract).
 
 /// Returns `Some(u16)` (the trailing lead surrogate) when `SKIP_TRAILING_REPLACEMENT` and a
-/// dangling lead surrogate is at the end; otherwise `None`. When `SKIP_TRAILING_REPLACEMENT` is
-/// false the Zig version returned the list by value — in Rust the caller already owns `list`.
+/// dangling lead surrogate is at the end; otherwise `None`.
 pub fn to_utf8_list_with_type_bun<const SKIP_TRAILING_REPLACEMENT: bool>(
     list: &mut Vec<u8>,
     utf16: &[u16],
@@ -208,7 +205,7 @@ pub fn allocate_latin1_into_utf8(latin1_: &[u8]) -> Result<Vec<u8>, AllocError>
 }
 
 // ─── CANONICAL: UTF-16 codepoint decode ─────────────────────────────────────
-// Faithful port of unicode.zig:569 / :1321 / :1325 / :1361. Re-exported from
+// Re-exported from
 // immutable.rs as `strings::{utf16_codepoint, utf16_codepoint_with_fffd,
 // UTF16Replacement}`; the parallel Utf16CodepointLen + duplicate struct/fns
 // that lived in immutable.rs are deleted in favour of this single source of
@@ -216,7 +213,7 @@ pub fn allocate_latin1_into_utf8(latin1_: &[u8]) -> Result<Vec<u8>, AllocError>
 // TextEncoderStreamEncoder.rs ×1) resolve through the
 // `pub use unicode_draft::{…}` re-export with no source change.
 
-/// `strings.UTF16Replacement` (unicode.zig:569) — decoded UTF-16 codepoint
+/// `strings.UTF16Replacement` — decoded UTF-16 codepoint
 /// with surrogate metadata.
 #[derive(Clone, Copy)]
 pub struct UTF16Replacement {
@@ -494,8 +491,6 @@ pub fn copy_u8_into_u16(output_: &mut [u16], input_: &[u8]) {
     let input = input_;
     debug_assert!(input.len() <= output.len());
 
-    // https://zig.godbolt.org/z/9rTn1orcY
-
     let n = input.len().min(output.len());
     for i in 0..n {
         output[i] = u16::from(input[i]);
@@ -530,10 +525,9 @@ pub fn copy_latin1_into_ascii(dest: &mut [u8], src: &[u8]) {
 
     if to.len() >= 16 && crate::Environment::ENABLE_SIMD {
         const VECTOR_SIZE: usize = 16;
-        // https://zig.godbolt.org/z/qezsY8T3W
         let remain_in_u64_len = remain.len() - (remain.len() % VECTOR_SIZE);
         let to_in_u64_len = to.len() - (to.len() % VECTOR_SIZE);
-        // PORT NOTE: reshaped for borrowck — operate on byte indices instead of bytesAsSlice(u64).
+        // Reshaped for borrowck — operate on byte indices instead of bytesAsSlice(u64).
         let end_vector_len = (remain_in_u64_len / 8).min(to_in_u64_len / 8);
         let mut idx = 0usize;
         // using the pointer instead of the length is super important for the codegen
@@ -638,9 +632,8 @@ impl BOM {
             }
             BOM::Utf16Le => {
                 // `trimmed_bytes` is `&[u8]` at offset 2 of a `Vec<u8>`; alignment is
-                // not guaranteed ≥ 2, so casting to `&[u16]` (the Zig `@alignCast`
-                // port) is UB. Route through the byte-level helper which copies into
-                // an aligned `Vec<u16>` first.
+                // not guaranteed ≥ 2, so casting to `&[u16]` is UB. Route through
+                // the byte-level helper which copies into an aligned `Vec<u16>` first.
                 let trimmed_bytes = &bytes[Self::UTF16_LE_BYTES.len()..];
                 let out = crate::strings::to_utf8_alloc_from_le_bytes(trimmed_bytes);
                 drop(bytes);
@@ -654,7 +647,7 @@ impl BOM {
         }
     }
 
-    /// This is required for fs.zig's `use_shared_buffer` flag. we cannot free that pointer.
+    /// This is required for the fs `use_shared_buffer` flag. we cannot free that pointer.
     /// The returned slice will always point to the base of the input.
     ///
     /// Requires an arraylist in case it must be grown.
@@ -664,7 +657,6 @@ impl BOM {
                 let n = Self::UTF8_BYTES.len();
                 let len = list.len();
                 list.copy_within(n.., 0);
-                // PORT NOTE: Zig returned a subslice without truncating; we mirror by returning a slice.
                 &list[..len - n]
             }
             BOM::Utf16Le => {
@@ -675,7 +667,7 @@ impl BOM {
                 );
                 list.clear();
                 list.extend_from_slice(&out);
-                // TODO(port): Zig returned `out` (the new alloc); returning list slice instead to honor
+                // Return the list slice (not `out`, the new alloc) to honor the
                 // "always points to the base of the input" doc comment.
                 &list[..]
             }
@@ -711,9 +703,6 @@ pub enum ToUTF16Error {
 
 crate::oom_from_alloc!(ToUTF16Error);
 
-// TODO(port): move to *_jsc — `TestingAPIs` re-exported from bun_string_jsc.
-// pub const TestingAPIs = @import("../../jsc/bun_string_jsc.zig").UnicodeTestingAPIs;
-
 pub fn to_utf16_alloc_maybe_buffered<const FAIL_IF_INVALID: bool, const FLUSH: bool>(
     bytes: &[u8],
 ) -> Result<Option<(Vec<u16>, [u8; 3], u8)>, ToUTF16Error> {
@@ -810,7 +799,7 @@ pub fn to_utf16_alloc_maybe_buffered<const FAIL_IF_INVALID: bool, const FLUSH: b
         remaining = &remaining[(converted.len as usize).max(1)..];
 
         // #define U16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
-        push_codepoint_utf16(&mut output, converted.code_point); // PERF(port): was assume_capacity
+        push_codepoint_utf16(&mut output, converted.code_point);
 
         non_ascii = first_non_ascii(remaining);
     }
@@ -890,8 +879,8 @@ pub fn utf16_codepoint(input: &[u16]) -> UTF16Replacement {
                 ..Default::default()
             };
         }
-        // PORT NOTE (unicode.zig:1378): Zig falls through with len=2 even when input[1]
-        // is not a trail surrogate; preserve that iteration behaviour.
+        // Falls through with len=2 even when input[1] is not a trail
+        // surrogate; callers depend on that iteration behaviour.
         UTF16Replacement {
             len: 2,
             code_point: u16_get_supplementary(c0, input[1]),
@@ -912,7 +901,7 @@ pub fn utf16_codepoint(input: &[u16]) -> UTF16Replacement {
     }
 }
 
-/// Zig: `pub fn toUTF16Literal(comptime str) [:0]const u16` → use `$crate::w!("...")` macro.
+/// Alias for the `$crate::w!("...")` macro.
 #[macro_export]
 macro_rules! to_utf16_literal {
     ($s:literal) => {
@@ -920,9 +909,8 @@ macro_rules! to_utf16_literal {
     };
 }
 
-/// Zig: `pub fn literal(comptime T, comptime str) *const [N:0]T`.
-/// In Rust: `b"..."` for u8, `$crate::w!("...")` for u16. No runtime fn possible.
-// TODO(port): callers should use byte/wide literals directly; this is a stub for diff parity.
+/// `b"..."` for u8, `$crate::w!("...")` for u16.
+/// New callers should use byte/wide literals directly.
 #[macro_export]
 macro_rules! literal {
     (u8, $s:literal) => {
@@ -933,8 +921,6 @@ macro_rules! literal {
     };
 }
 
-// `literalLength` is comptime-only and folded into the macros above.
-
 pub(super) use crate::strings::push_codepoint_utf16;
 
 // `unreachable_pub`: these are re-exported externally via the parent's
@@ -1154,8 +1140,7 @@ pub(super) fn copy_utf16_into_utf8_with_buffer_impl<const ALLOW_TRUNCATED_UTF8_S
         }
 
         utf16_remaining = &utf16_remaining[replacement.len as usize..];
-        // Zig does `remaining.ptr[0..4]` (a raw *[4]u8 with no bounds claim) and
-        // encodeWTF8RuneT only writes `width` bytes. In Rust, materializing
+        // `encode_wtf8_rune` only writes `width` bytes, but materializing
         // `&mut [u8; 4]` would assert 4 valid bytes even when remaining.len() < 4,
         // so encode into a stack buffer and copy the `width` bytes that were written.
         let mut four = [0u8; 4];
@@ -1191,9 +1176,8 @@ pub fn element_length_utf8_into_utf16(utf8: &[u8]) -> usize {
 
         utf8_remaining = &utf8_remaining[i..];
 
-        // PORT NOTE: Zig calls `utf16Codepoint` (which takes []const u16) on a []const u8 here —
-        // preserved as a TODO; this branch is dead when use_simdutf is true.
-        // TODO(port): dead non-simdutf path passes wrong slice type in Zig source
+        // Deliberate quirk: `utf16_codepoint` (which takes u16 units) is applied to
+        // raw u8 bytes here. This branch is dead when USE_SIMDUTF is true.
         let replacement = {
             let n = utf8_remaining.len() / 2;
             if n == 0 {
@@ -1298,5 +1282,3 @@ pub fn decode_wtf8_rune_t_multibyte<T: CodePointZero>(p: [u8; 4], len: U3Fast, z
 }
 
 // `from_u32_const` folded into `CodePointZero` trait above.
-
-// ported from: src/string/immutable/unicode.zig
diff --git a/src/bun_core/string/mod.rs b/src/bun_core/string/mod.rs
index acfb82a0429..2d982725cda 100644
--- a/src/bun_core/string/mod.rs
+++ b/src/bun_core/string/mod.rs
@@ -1,10 +1,10 @@
-//! `bun_core::string` (formerly the `bun_string` crate) — port of
-//! `src/string/string.zig` (`bun.String` and friends).
+//! `bun_core::string` (formerly the `bun_string` crate) — `bun.String` and
+//! friends.
 //!
 //! `String` is the FFI-compatible 5-variant tagged union shared with C++
 //! (`BunString` in `src/jsc/bindings/BunString.cpp`). `ZigString` is the
 //! pointer-tagged borrowed view; `ZigStringSlice` is the owned-or-borrowed
-//! UTF-8 byte slice that replaces Zig's allocator-vtable trick.
+//! UTF-8 byte slice.
 //!
 //! Merged into `bun_core` to break the `bun_core ↔ bun_string` dep edge;
 //! the `bun_string` crate is now a thin re-export shim over this module.
@@ -37,7 +37,7 @@ pub use write::Write;
 #[path = "immutable.rs"]
 pub mod immutable;
 
-// Unicode ID-Start/ID-Continue two-stage tables (`js_lexer/identifier_data.zig`).
+// Unicode ID-Start/ID-Continue two-stage tables.
 // Pure data with no upward deps; hosted here so [`lexer`], [`mutable_string`],
 // and [`immutable::unicode`] get full Unicode coverage without depending on
 // `bun_js_parser`. `bun_js_parser::lexer::identifier` re-exports this module.
@@ -49,8 +49,7 @@ pub use wtf::{WTFStringImpl, WTFStringImplExt, WTFStringImplStruct};
 
 // ──────────────────────────────────────────────────────────────────────────
 // `bun.String` — 5-variant tagged WTFString-or-ZigString. extern layout
-// must match Zig `extern struct { tag: Tag, value: StringImpl }` (= C++
-// `BunString` in BunString.cpp), 24 bytes on 64-bit.
+// must match the C++ `BunString` in BunString.cpp, 24 bytes on 64-bit.
 // ──────────────────────────────────────────────────────────────────────────
 // Canonical layout lives in `bun_alloc` (T0 TYPE_ONLY landing for
 // `bun.String`); re-exported so existing `bun_core::{Tag, StringImpl}` paths
@@ -172,8 +171,7 @@ impl String {
         unsafe { self.0.value.wtf_string_impl }
     }
 
-    /// `bun.String.init(anytype)` — polymorphic borrow constructor
-    /// (string.zig:331). Mirrors the Zig `switch (@TypeOf(value))` table via
+    /// `bun.String.init` — polymorphic borrow constructor, expressed via the
     /// `Into<Self>` impls below: `String` is identity, `ZigString` is wrapped,
     /// byte/str slices go through `ZigString::from_bytes`.
     #[inline]
@@ -198,11 +196,10 @@ impl String {
 
     /// `bun.String.static` — `'static` slice; converted to JS via
     /// `WTF::ExternalStringImpl` without copying. Generic over `str`/`[u8]`
-    /// so call sites may pass either `"lit"` or `b"lit"` (Zig's `[:0]const u8`
-    /// literal maps to both in ported code).
+    /// so call sites may pass either `"lit"` or `b"lit"`.
     #[inline]
     pub fn static_<S: ?Sized + AsRef<[u8]>>(s: &'static S) -> Self {
-        // Zig: ZigString.init(input) — no UTF-8 mark on the static path.
+        // No UTF-8 mark on the static path.
         Self(bun_alloc::String {
             tag: Tag::StaticZigString,
             value: StringImpl {
@@ -233,7 +230,7 @@ impl String {
         // SAFETY: s.as_ptr()/len describe a valid byte slice.
         unsafe { BunString__fromLatin1(s.as_ptr(), s.len()) }
     }
-    /// `bun.String.cloneUTF16` — narrows to Latin-1 if all-ASCII (string.zig:207).
+    /// `bun.String.cloneUTF16` — narrows to Latin-1 if all-ASCII.
     pub fn clone_utf16(s: &[u16]) -> Self {
         if s.is_empty() {
             return Self::EMPTY;
@@ -252,7 +249,7 @@ impl String {
         unsafe { BunString__createAtom(s.as_ptr(), s.len()) }
     }
     /// `bun.String.tryCreateAtom` — `None` if `bytes` is non-ASCII or too long
-    /// to atomize (string.zig:270).
+    /// to atomize.
     pub fn try_create_atom(bytes: &[u8]) -> Option<Self> {
         // SAFETY: bytes describes a valid slice.
         let atom = unsafe { BunString__tryCreateAtom(bytes.as_ptr(), bytes.len()) };
@@ -264,7 +261,7 @@ impl String {
     }
     /// `bun.String.createAtomIfPossible` — atomized strings are interned in a
     /// thread-local table; falls back to a regular WTF copy if atomization
-    /// fails. Cannot be used cross-thread (string.zig:278).
+    /// fails. Cannot be used cross-thread.
     pub fn create_atom_if_possible(bytes: &[u8]) -> Self {
         if bytes.is_empty() {
             return Self::EMPTY;
@@ -281,7 +278,7 @@ impl String {
     ///
     /// External strings are WTF strings whose bytes live elsewhere; `bytes` is
     /// borrowed (not copied). If `bytes.len() >= max_length()`, `callback` is
-    /// invoked immediately and a `dead` string is returned (string.zig:404).
+    /// invoked immediately and a `dead` string is returned.
     ///
     /// `Ctx` must be a pointer-sized type (raw pointer or `&T`); enforced by
     /// the const-assert below to keep the C-ABI cast sound.
@@ -292,7 +289,7 @@ impl String {
         callback: ExternalStringImplFreeFunction<Ctx>,
     ) -> Self {
         use core::ffi::c_void;
-        // PORT NOTE: Zig asserted `@typeInfo(Ctx) == .pointer` at comptime.
+        // `Ctx` must be a pointer-sized, pointer-aligned handle.
         struct AssertPtrSized<C>(core::marker::PhantomData<C>);
         impl<C> AssertPtrSized<C> {
             const OK: () = {
@@ -309,11 +306,11 @@ impl String {
             callback(ctx, bytes.as_ptr().cast_mut().cast::<c_void>(), bytes.len());
             return Self::DEAD;
         }
-        // PORT NOTE: Zig asserted `@typeInfo(Ctx) == .pointer` (raw pointer, no
-        // destructor). The Rust const-assert only checks size, so an owning
-        // pointer-sized `Ctx` (e.g. `Box<T>`) would otherwise be dropped here
-        // and later double-freed by the WTF finalizer. Ownership transfers to
-        // the external string; suppress the local drop.
+        // The const-assert above only checks size/alignment, so an owning
+        // pointer-sized `Ctx` (e.g.
+        // `Box<T>`) would otherwise be dropped here and later double-freed by
+        // the WTF finalizer. Ownership transfers to the external string;
+        // suppress the local drop.
         let ctx = core::mem::ManuallyDrop::new(ctx);
         // SAFETY: Ctx is pointer-sized and pointer-aligned (const-asserted
         // above); read the bits as `*mut c_void`.
@@ -343,8 +340,7 @@ impl String {
     }
 
     /// Max `WTF::StringImpl` length (in characters, not bytes).
-    /// Reads the process-wide [`STRING_ALLOCATION_LIMIT`] data slot
-    /// (`jsc::VirtualMachine::string_allocation_limit` in Zig).
+    /// Reads the process-wide [`STRING_ALLOCATION_LIMIT`] data slot.
     #[inline]
     pub fn max_length() -> usize {
         STRING_ALLOCATION_LIMIT.load(Ordering::Relaxed)
@@ -352,7 +348,7 @@ impl String {
 
     /// `bun.String.createStaticExternal` — wraps `bytes` in a
     /// `WTF::ExternalStringImpl` that will **never** be freed. Only use for
-    /// dynamically-allocated data with process lifetime (string.zig:427).
+    /// dynamically-allocated data with process lifetime.
     pub fn create_static_external(bytes: &[u8], is_latin1: bool) -> Self {
         debug_assert!(!bytes.is_empty());
         // SAFETY: bytes describes a valid slice; C++ side stores ptr/len
@@ -360,12 +356,10 @@ impl String {
         unsafe { BunString__createStaticExternal(bytes.as_ptr(), bytes.len(), is_latin1) }
     }
     /// `bun.String.createFormat` — formats `args` into a temporary buffer and
-    /// copies the result into a fresh WTF-backed string. Port collapses Zig's
-    /// `(comptime fmt, args: anytype)` into [`core::fmt::Arguments`].
+    /// copies the result into a fresh WTF-backed string.
     pub fn create_format(args: core::fmt::Arguments<'_>) -> Self {
         use core::fmt::Write;
-        // PORT NOTE: Zig used a 512-byte stackFallback; this is a cold path
-        // (error messages), so a heap buffer is fine.
+        // Cold path (error messages), so a heap buffer is fine.
         if let Some(s) = args.as_str() {
             return Self::clone_utf8(s.as_bytes());
         }
@@ -374,8 +368,8 @@ impl String {
         Self::clone_utf8(buf.as_bytes())
     }
     /// Returns `(String, ptr)` where `ptr` is `len` writable bytes — or
-    /// `(dead, null)` if WTF allocation failed (string.zig:128 checks
-    /// `tag == .Dead` before using the buffer).
+    /// `(dead, null)` if WTF allocation failed (check `tag == .Dead` before
+    /// using the buffer).
     pub fn create_uninitialized_latin1(len: usize) -> (Self, &'static mut [u8]) {
         let s = BunString__fromLatin1Unitialized(len);
         if s.0.tag != Tag::WTFStringImpl {
@@ -384,8 +378,8 @@ impl String {
         debug_assert_eq!(s.as_wtf().ref_count(), 1);
         // SAFETY: WTF tag verified above; impl has a writable latin1 buffer of
         // `len`. `ptr` points at `len` writable bytes owned by the new WTF
-        // impl; the `'static` lifetime mirrors Zig's `[]u8` return (lifetime
-        // is actually tied to `s` — caller must not outlive it).
+        // impl; the `'static` lifetime is actually tied to `s` — caller must
+        // not outlive it.
         let buf = unsafe {
             let ptr = (*s.0.value.wtf_string_impl).m_ptr.latin1.cast_mut();
             core::slice::from_raw_parts_mut(ptr, len)
@@ -420,8 +414,7 @@ impl String {
         // Do NOT call `into_boxed_slice()` — when `len < capacity` it issues a
         // shrink_to_fit realloc. mimalloc's `mi_free` only needs the original
         // base pointer (capacity is recovered from the heap), so leaking the
-        // spare capacity to the ExternalStringImpl finalizer is correct and
-        // matches Zig's `allocator.alloc(u8, n)` → `to[0..wrote]` pattern.
+        // spare capacity to the ExternalStringImpl finalizer is correct.
         let mut bytes = core::mem::ManuallyDrop::new(bytes);
         let (ptr, len) = (bytes.as_mut_ptr(), bytes.len());
         // SAFETY: ownership transferred to WTF::ExternalStringImpl, which frees
@@ -461,7 +454,7 @@ impl String {
     pub fn to_wtf_string(&mut self) {
         BunString__toWTFString(self)
     }
-    /// Zig: `bun.String.init(WTFStringImpl)` / `WTFString.adopt` — wrap a raw
+    /// `bun.String.init(WTFStringImpl)` / `WTFString.adopt` — wrap a raw
     /// `*mut WTFStringImplStruct`, **adopting** the existing +1 ref (no inc).
     /// Inverse of [`leak_wtf_impl`]. Null → `String::EMPTY`.
     #[inline]
@@ -476,7 +469,7 @@ impl String {
             },
         })
     }
-    /// Zig: `bun.String{...}.value.WTFStringImpl` — extract the raw `*mut WTFStringImplStruct`
+    /// Extract the raw `*mut WTFStringImplStruct`
     /// from a WTF-backed string, transferring ownership of the +1 ref to the caller. Returns
     /// null for non-WTF tags. Used by SQL data-cell paths that hand the impl pointer to C++.
     #[inline]
@@ -513,9 +506,7 @@ impl String {
     /// Debug-only guard for the `Send`/`Sync` contract: panics if this
     /// `String` wraps a non-thread-safe `WTF::StringImpl`. Intended for the
     /// hand-off point where a `String` is stored into a value that will cross
-    /// threads (worker task payloads, channel sends, `Arc`-shared state) —
-    /// the Rust spelling of Zig's `bun.assert(str.isThreadSafe())` before a
-    /// thread-pool dispatch.
+    /// threads (worker task payloads, channel sends, `Arc`-shared state).
     #[inline(always)]
     #[track_caller]
     pub fn debug_assert_thread_safe(&self) {
@@ -618,8 +609,7 @@ impl String {
     /// Narrow this string into `dst` iff it is non-empty, fits, and every code
     /// unit is ASCII (`< 0x80`). UTF-16 narrows via
     /// [`strings::narrow_ascii_u16`]; 8-bit copies after rejecting any high
-    /// Latin-1 byte. Returns `Some(&mut dst[..len])` on success. Zig open-codes
-    /// this per call site (e.g. `inMapCaseInsensitive`, `Encoding.from`).
+    /// Latin-1 byte. Returns `Some(&mut dst[..len])` on success.
     pub fn ascii_into<'a>(&self, dst: &'a mut [u8]) -> Option<&'a mut [u8]> {
         let len = self.length();
         if len == 0 || len > dst.len() {
@@ -638,7 +628,7 @@ impl String {
         }
     }
 
-    /// `bun.String.inMapCaseInsensitive` (string.zig) — case-insensitive ASCII
+    /// `bun.String.inMapCaseInsensitive` — case-insensitive ASCII
     /// lookup against a phf map whose keys are lowercase ASCII. UTF-16 inputs
     /// are narrowed (non-ASCII code unit ⇒ miss); 8-bit inputs delegate
     /// straight to [`strings::in_map_case_insensitive`].
@@ -651,21 +641,20 @@ impl String {
         }
     }
 
-    /// `bun.String.trunc` (string.zig:317) — clamp to `len` code units. The
+    /// `bun.String.trunc` — clamp to `len` code units. The
     /// returned `String` borrows the same storage; for `WTFStringImpl` this
     /// downgrades to a `ZigString` view (no ref taken), so the original must
     /// outlive the result.
     pub fn trunc(&self, len: usize) -> String {
         if self.length() <= len {
-            // PORT NOTE: Zig returns `this` by value with no refcount bump;
-            // `String` is `Copy` here (POD #[repr(C)]), so a plain copy
-            // matches the Zig pass-by-value semantics.
+            // No refcount bump: `String` is `Copy` here (POD #[repr(C)]), so a
+            // plain copy preserves the borrow semantics.
             return *self;
         }
         String::init(self.to_zig_string().trunc(len))
     }
 
-    /// `bun.String.substring` (string.zig:669) — borrowed slice from `start_index`
+    /// `bun.String.substring` — borrowed slice from `start_index`
     /// to end. The returned `String` borrows the same underlying storage; for
     /// `WTFStringImpl` this downgrades to a `ZigString` view (no ref taken), so
     /// the original must outlive the result.
@@ -674,7 +663,7 @@ impl String {
         self.substring_with_len(start_index.min(len), len)
     }
 
-    /// `bun.String.substringWithLen` (string.zig:674).
+    /// `bun.String.substringWithLen`.
     pub fn substring_with_len(&self, start_index: usize, end_index: usize) -> String {
         match self.0.tag {
             Tag::ZigString | Tag::StaticZigString => {
@@ -737,7 +726,7 @@ impl String {
         }
     }
     /// Returns `Some(utf8_bytes)` only if this is already valid UTF-8 with no
-    /// transcoding needed (string.zig:571 `asUTF8`).
+    /// transcoding needed.
     pub fn as_utf8(&self) -> Option<&[u8]> {
         match self.0.tag {
             Tag::WTFStringImpl => {
@@ -769,17 +758,17 @@ impl String {
     }
 
     pub fn eql_utf8(&self, other: &[u8]) -> bool {
-        // PORT NOTE: no `as_utf8()` fast-path here — for a 16-bit ZigString,
+        // No `as_utf8()` fast-path here — for a 16-bit ZigString,
         // `as_utf8()` would call `slice()` (which debug-asserts !is_16bit) and
-        // `is_all_ascii` on the wrong byte view. Match Zig's `eqlUTF8` and go
-        // straight through encoding-aware `to_utf8_without_ref`.
+        // `is_all_ascii` on the wrong byte view. Go straight through
+        // encoding-aware `to_utf8_without_ref`.
         self.to_utf8_without_ref().slice() == other
     }
     pub fn eql_comptime<S: ?Sized + AsRef<[u8]>>(&self, lit: &S) -> bool {
         self.eql_utf8(lit.as_ref())
     }
 
-    /// Port of `bun.String.githubAction` (string.zig). Returns a `Display`
+    /// `bun.String.githubAction` — returns a `Display`
     /// formatter that escapes the string for GitHub Actions annotation output
     /// (`%0A` for newlines, ANSI stripped). Encoding-aware: materialises a
     /// UTF-8 view inside `fmt` so 16-bit / WTF-backed strings are handled.
@@ -788,7 +777,7 @@ impl String {
         StringGithubActionFormatter { text: self }
     }
 
-    /// Port of `bun.String.hasPrefixComptime` (string.zig). ASCII-only prefix
+    /// `bun.String.hasPrefixComptime` — ASCII-only prefix
     /// check that avoids materialising the whole UTF-8 view when the
     /// underlying encoding is 8-bit; falls back to `to_utf8_without_ref` for
     /// 16-bit / WTF-backed strings.
@@ -811,7 +800,7 @@ impl String {
     }
 
     /// `bun.String.fromBytes` — borrow `value` without copying or refcounting;
-    /// auto-tags UTF-8 if `value` contains any non-ASCII byte (string.zig:504).
+    /// auto-tags UTF-8 if `value` contains any non-ASCII byte.
     #[inline]
     pub fn from_bytes(value: &[u8]) -> Self {
         Self::init(ZigString::from_bytes(value))
@@ -819,7 +808,7 @@ impl String {
 
     /// `bun.String.clone` — produce an owned, WTF-backed copy of `self`.
     /// WTF-backed inputs just bump the refcount; ZigString inputs are copied
-    /// into a fresh WTF::StringImpl (string.zig:244).
+    /// into a fresh WTF::StringImpl.
     pub fn clone(&self) -> Self {
         if self.0.tag == Tag::WTFStringImpl {
             return self.dupe_ref();
@@ -832,7 +821,7 @@ impl String {
             let (new, chars) = Self::create_uninitialized_utf16(len);
             if new.0.tag != Tag::Dead {
                 // SAFETY: tag ≠ WTFStringImpl is excluded above so
-                // `value.zig` is the active variant.
+                // `value.zig_string` is the active variant.
                 chars.copy_from_slice(self.as_zig().utf16_slice());
             }
             return new;
@@ -849,13 +838,13 @@ impl String {
         }
     }
 
-    /// `bun.String.eql` — encoding-aware equality (string.zig:1014).
+    /// `bun.String.eql` — encoding-aware equality.
     pub fn eql(&self, other: &Self) -> bool {
         self.to_zig_string().eql(other.to_zig_string())
     }
 
     /// `bun.String.utf8ByteLength` — exact number of UTF-8 bytes needed to
-    /// encode `self` (string.zig:292).
+    /// encode `self`.
     pub fn utf8_byte_length(&self) -> usize {
         match self.0.tag {
             Tag::WTFStringImpl => self.as_wtf().utf8_byte_length(),
@@ -865,7 +854,7 @@ impl String {
     }
 
     /// `bun.String.utf16ByteLength` — number of bytes the UTF-16LE encoding of
-    /// `self` would occupy (string.zig:301).
+    /// `self` would occupy.
     pub fn utf16_byte_length(&self) -> usize {
         match self.0.tag {
             Tag::WTFStringImpl => self.as_wtf().utf16_byte_length(),
@@ -875,7 +864,7 @@ impl String {
     }
 
     /// `bun.String.latin1ByteLength` — number of bytes the Latin-1 encoding of
-    /// `self` would occupy (string.zig:309).
+    /// `self` would occupy.
     pub fn latin1_byte_length(&self) -> usize {
         match self.0.tag {
             Tag::WTFStringImpl => self.as_wtf().latin1_byte_length(),
@@ -896,7 +885,7 @@ impl String {
     // would invert the crate graph. See PORTING.md §Dep-cycle.
 
     /// `bun.String.visibleWidthExcludeANSIColors` — terminal column width of
-    /// `self`, treating ANSI escape sequences as zero-width (string.zig).
+    /// `self`, treating ANSI escape sequences as zero-width.
     /// Dispatches on encoding to [`strings::visible::width::exclude_ansi_colors`].
     pub fn visible_width_exclude_ansi_colors(&self, ambiguous_as_wide: bool) -> usize {
         use crate::string::strings::visible::width::exclude_ansi_colors as w;
@@ -911,14 +900,14 @@ impl String {
         w::latin1(self.latin1())
     }
 
-    /// `bun.String.isGlobal` (string.zig:63) — true iff this is a `ZigString`
+    /// `bun.String.isGlobal` — true iff this is a `ZigString`
     /// whose pointer is tagged as globally-allocated (mimalloc heap).
     #[inline]
     pub fn is_global(&self) -> bool {
         self.0.tag == Tag::ZigString && self.as_zig().is_globally_allocated()
     }
 
-    /// `bun.String.createIfDifferent` (string.zig:117) — if `other` already
+    /// `bun.String.createIfDifferent` — if `other` already
     /// holds `utf8_slice` verbatim (and is WTF-backed), return a `dupe_ref`;
     /// otherwise allocate a fresh WTF-backed copy of `utf8_slice`.
     pub fn create_if_different(other: &String, utf8_slice: &[u8]) -> String {
@@ -928,21 +917,21 @@ impl String {
         Self::clone_utf8(utf8_slice)
     }
 
-    /// `bun.String.createAtomASCII` — same as [`create_atom`]; the Zig name
-    /// documents the ASCII-only precondition (string.zig:265).
+    /// `bun.String.createAtomASCII` — same as [`create_atom`]; the name
+    /// documents the ASCII-only precondition.
     #[inline]
     pub fn create_atom_ascii(s: &[u8]) -> Self {
         Self::create_atom(s)
     }
 
     /// `bun.String.initLatin1OrASCIIView` — borrow `value` as a Latin-1/ASCII
-    /// 8-bit `ZigString` view without UTF-8-tagging it (string.zig:491).
+    /// 8-bit `ZigString` view without UTF-8-tagging it.
     #[inline]
     pub fn init_latin1_or_ascii_view(value: &[u8]) -> Self {
         Self::init(ZigString::init(value))
     }
 
-    /// `bun.String.encoding` (string.zig:594) — coarse encoding classifier.
+    /// `bun.String.encoding` — coarse encoding classifier.
     pub fn encoding(&self) -> strings::EncodingNonAscii {
         if self.is_utf16() {
             strings::EncodingNonAscii::Utf16
@@ -953,7 +942,7 @@ impl String {
         }
     }
 
-    /// `bun.String.canBeUTF8` (string.zig:654) — true iff `self`'s 8-bit bytes
+    /// `bun.String.canBeUTF8` — true iff `self`'s 8-bit bytes
     /// are valid UTF-8 (i.e. either UTF-8-tagged or all-ASCII).
     pub fn can_be_utf8(&self) -> bool {
         match self.0.tag {
@@ -973,7 +962,7 @@ impl String {
         }
     }
 
-    /// `bun.String.utf8` (string.zig:646) — raw UTF-8 byte slice. Debug-asserts
+    /// `bun.String.utf8` — raw UTF-8 byte slice. Debug-asserts
     /// `self` is a UTF-8-safe `ZigString`/`StaticZigString` (use [`as_utf8`] for
     /// the checked variant).
     #[inline]
@@ -984,19 +973,18 @@ impl String {
     }
 
     /// `bun.String.toUTF8Owned` — like [`to_utf8_without_ref`] but guarantees
-    /// the returned slice owns its buffer (string.zig:724).
+    /// the returned slice owns its buffer.
     pub fn to_utf8_owned(&self) -> ZigStringSlice {
         self.to_utf8_without_ref().clone_if_borrowed()
     }
 
-    /// `bun.String.toUTF8Bytes` — owned `Vec<u8>` of `self` as UTF-8
-    /// (string.zig:729).
+    /// `bun.String.toUTF8Bytes` — owned `Vec<u8>` of `self` as UTF-8.
     #[inline]
     pub fn to_utf8_bytes(&self) -> Vec<u8> {
         self.to_utf8_owned().into_vec()
     }
 
-    /// `bun.String.toOwnedSliceReturningAllASCII` (string.zig:81) — returns
+    /// `bun.String.toOwnedSliceReturningAllASCII` — returns
     /// `(utf8_bytes, is_all_ascii)`. `false` means at least one non-ASCII byte.
     pub fn to_owned_slice_returning_all_ascii(&self) -> (Vec<u8>, bool) {
         match self.0.tag {
@@ -1021,7 +1009,7 @@ impl String {
         }
     }
 
-    /// `bun.String.toSlice` (string.zig:734) — consume `self` into a
+    /// `bun.String.toSlice` — consume `self` into a
     /// [`SliceWithUnderlyingString`], leaving `self` as [`EMPTY`].
     #[inline]
     pub fn to_slice(&mut self) -> SliceWithUnderlyingString {
@@ -1042,7 +1030,7 @@ impl String {
         }
     }
 
-    /// `bun.String.toThreadSafeSlice` (string.zig:742) — like [`to_slice`] but
+    /// `bun.String.toThreadSafeSlice` — like [`to_slice`] but
     /// guarantees the resulting buffer is safe to send to another thread.
     pub fn to_thread_safe_slice(&mut self) -> SliceWithUnderlyingString {
         if self.0.tag == Tag::WTFStringImpl {
@@ -1060,9 +1048,9 @@ impl String {
             }
             // Thread-safe impl. If `slice` is borrowed (all-ASCII Latin-1),
             // re-use the impl's storage: take a single ref for `underlying` and
-            // hand back a non-owning `WtfBorrowed` view pinned by it. (Zig took
-            // two refs plus a WTF allocator; the second ref was redundant since
-            // `underlying` already keeps the impl alive.)
+            // hand back a non-owning `WtfBorrowed` view pinned by it; a second
+            // ref would be redundant since `underlying` already keeps the impl
+            // alive.
             if let ZigStringSlice::Static(ptr, len) = slice {
                 self.ref_();
                 let string_impl = self.wtf_ptr();
@@ -1088,7 +1076,7 @@ impl String {
         self.to_slice()
     }
 
-    /// `bun.String.charAt` (string.zig:831) — code unit at `index`, widened to
+    /// `bun.String.charAt` — code unit at `index`, widened to
     /// `u16` regardless of encoding. Caller must ensure `index < self.length()`.
     #[inline]
     pub fn char_at(&self, index: usize) -> u16 {
@@ -1107,7 +1095,7 @@ impl String {
         }
     }
 
-    /// `bun.String.indexOfAsciiChar` (string.zig:842).
+    /// `bun.String.indexOfAsciiChar`.
     pub fn index_of_ascii_char(&self, chr: u8) -> Option<usize> {
         debug_assert!(chr < 128);
         if self.is_utf16() {
@@ -1117,14 +1105,14 @@ impl String {
         }
     }
 
-    /// `bun.String.eqlBytes` (string.zig:983) — raw byte-slice equality
+    /// `bun.String.eqlBytes` — raw byte-slice equality
     /// (encoding-unaware).
     #[inline]
     pub fn eql_bytes(&self, value: &[u8]) -> bool {
         strings::eql_long(self.byte_slice(), value, true)
     }
 
-    /// `bun.String.toThreadSafeEnsureRef` (string.zig:1001) — like
+    /// `bun.String.toThreadSafeEnsureRef` — like
     /// [`to_thread_safe`] but leaves the result with one extra ref.
     pub fn to_thread_safe_ensure_ref(&mut self) {
         if self.0.tag == Tag::WTFStringImpl {
@@ -1133,7 +1121,7 @@ impl String {
         }
     }
 
-    /// `bun.String.estimatedSize` (string.zig:1021) — owned allocation size in
+    /// `bun.String.estimatedSize` — owned allocation size in
     /// bytes (not character count). `0` for static/empty/dead.
     pub fn estimated_size(&self) -> usize {
         match self.0.tag {
@@ -1148,7 +1136,7 @@ impl String {
     // free fns / extension trait in `bun_jsc::string` (would otherwise create
     // a `bun_string ↔ bun_jsc` dependency cycle).
 }
-// `bun.String.init(anytype)` dispatch table (string.zig:331) — Rust side is
+// `bun.String.init` dispatch table —
 // expressed as `From` impls feeding `String::init<T: Into<Self>>`. The
 // `String → String` identity case is covered by the std blanket `From<T> for T`.
 impl From<ZigString> for String {
@@ -1164,14 +1152,14 @@ impl From<&ZigString> for String {
     }
 }
 impl From<&[u8]> for String {
-    /// `[]const u8` arm — `ZigString.fromBytes` (auto-marks UTF-8 if non-ASCII).
+    /// Byte-slice arm — `ZigString::from_bytes` (auto-marks UTF-8 if non-ASCII).
     #[inline]
     fn from(s: &[u8]) -> Self {
         Self::from(ZigString::from_bytes(s))
     }
 }
 impl<const N: usize> From<&'static [u8; N]> for String {
-    /// `*const [N:0]u8` arm — Zig string literal (string.zig:340-350): empty
+    /// `&'static [u8; N]` arm — string literal: empty
     /// → `Tag::Empty`, otherwise `String.static(value)` → `Tag::StaticZigString`.
     /// Restricted to `&'static` so the static-tag invariant holds.
     #[inline]
@@ -1190,13 +1178,13 @@ impl From<&str> for String {
     }
 }
 impl From<&[u16]> for String {
-    /// `[]const u16` arm — `ZigString.from16Slice` (sets UTF-16 + global bits).
+    /// `&[u16]` arm — `ZigString::from16_slice` (sets UTF-16 + global bits).
     #[inline]
     fn from(s: &[u16]) -> Self {
         Self::from(ZigString::from16_slice(s))
     }
 }
-/// `WTFStringImpl` arm of `bun.String.init` (string.zig:331) — wrap an existing
+/// `WTFStringImpl` arm of `bun.String.init` — wrap an existing
 /// `*WTFStringImplStruct` without touching its refcount.
 impl From<WTFStringImpl> for String {
     #[inline]
@@ -1235,7 +1223,7 @@ impl Default for String {
 // created thread-safe, so sending/sharing a non-thread-safe impl across
 // threads and then `ref_()`/`deref()`ing it is a data race.
 //
-// We keep the blanket impls to match the Zig `bun.String` / C++ `BunString`
+// We keep the blanket impls to match the C++ `BunString`
 // FFI contract (the type must round-trip by value through `extern "C"` and sit
 // in `Send + Sync` containers), and instead enforce the invariant at the
 // boundary: any code that moves a `String` to another thread MUST first call
@@ -1253,11 +1241,10 @@ unsafe impl Sync for String {}
 // `OwnedString` — RAII `defer s.deref()`.
 //
 // `String` is intentionally `#[derive(Copy)]` so it stays bit-identical to the
-// C++ `BunString` for FFI by-value passing (matching Zig's value-type
-// `bun.String`). That precludes `impl Drop for String`. Instead, sites that
+// C++ `BunString` for FFI by-value passing. That precludes
+// `impl Drop for String`. Instead, sites that
 // receive a +1 ref (any `clone*`/`create*`/`to_bun_string` constructor) wrap
-// it in `OwnedString` to get scope-exit `deref()` — the Rust spelling of Zig's
-// pervasive `defer s.deref()`.
+// it in `OwnedString` to get scope-exit `deref()`.
 //
 // Prefer this over ad-hoc `scopeguard::guard(s, |s| s.deref())` so the
 // pattern is greppable and `?`-early-returns can't skip the release.
@@ -1271,7 +1258,7 @@ impl OwnedString {
         Self(s)
     }
     /// Disarm: return the inner `String` without `deref()`ing it (transfers
-    /// the +1 to the caller — Zig's "no defer, returned by value").
+    /// the +1 to the caller).
     #[inline]
     pub fn into_inner(self) -> String {
         core::mem::ManuallyDrop::new(self).0
@@ -1286,8 +1273,7 @@ impl OwnedString {
     /// `*const BunString` array (e.g. `BunString__createArray`). Sound because
     /// `OwnedString` is `#[repr(transparent)]` over `String`; the borrow keeps
     /// every element alive for the call, and `Drop` still runs on the owning
-    /// slice afterwards — the Rust spelling of Zig's
-    /// `defer { for (items) |s| s.deref(); }` around `toJSArray`.
+    /// slice afterwards.
     #[inline]
     pub fn as_raw_slice(owned: &[OwnedString]) -> &[String] {
         // `#[repr(transparent)]` over `String` ⇒ bytemuck's safe slice peel.
@@ -1330,8 +1316,6 @@ impl Default for OwnedString {
 impl Clone for OwnedString {
     /// Bumps the WTF refcount (or copies a `ZigString` into a fresh
     /// WTF::StringImpl) and wraps the resulting +1 in a new `OwnedString`.
-    /// Mirrors Zig's `s.clone()` followed by an implicit `defer deref` on the
-    /// new value.
     #[inline]
     fn clone(&self) -> Self {
         Self(self.0.clone())
@@ -1380,7 +1364,7 @@ impl core::fmt::Display for ZigStringGithubActionFormatter {
 }
 
 impl core::fmt::Display for ZigString {
-    // ZigString.zig `format()` — encoding-aware `{f}` formatter.
+    // Encoding-aware `Display` formatter.
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         if self.is_utf8() {
             return write!(f, "{}", crate::fmt::s(self.slice()));
@@ -1445,8 +1429,8 @@ impl ZigString {
     pub const fn init(s: &[u8]) -> Self {
         Self(bun_alloc::ZigString::init(s))
     }
-    /// `ZigString.init` for `'static` literals — alias for callers spelling it
-    /// `init_static` (matches Zig `ZigString.init` with comptime-known string).
+    /// [`init`](Self::init) for `'static` literals — alias for callers
+    /// spelling it `init_static`.
     #[inline]
     pub const fn init_static(s: &'static [u8]) -> Self {
         Self(bun_alloc::ZigString::init(s))
@@ -1465,7 +1449,7 @@ impl ZigString {
             // Ownership transferred to JSC: `mark_global()` tags the buffer so
             // `Zig::toString*` adopts it into a WTF string and `mi_free`s it on
             // string death. `heap::release` is the hand-off-to-foreign-owner
-            // spelling (Zig `ZigString.dupeForJS` never frees `utf16` locally).
+            // spelling.
             let leaked: &'static mut [u16] = crate::heap::release(utf16.into_boxed_slice());
             let mut out = ZigString::init_utf16(leaked);
             out.mark_global();
@@ -1493,13 +1477,13 @@ impl ZigString {
     }
 
     /// `ZigString.from16Slice` — wraps a globally-allocated UTF-16 buffer
-    /// (sets both the 16-bit and global ptr-tags). ZigString.zig:533.
+    /// (sets both the 16-bit and global ptr-tags).
     #[inline]
     pub fn from16_slice(slice: &[u16]) -> Self {
         Self::from16(slice.as_ptr(), slice.len())
     }
 
-    /// `ZigString.from16` — globally-allocated memory only (ZigString.zig:547).
+    /// `ZigString.from16` — globally-allocated memory only.
     /// Marks UTF-16 + global; caller must ensure the buffer was allocated by
     /// `bun.default_allocator` (mimalloc) since `deinitGlobal` will free it.
     #[inline]
@@ -1510,15 +1494,14 @@ impl ZigString {
         z
     }
 
-    /// Alias of [`is_16bit`] (Zig spelled it `is16Bit`; per PORTING.md acronym
-    /// rule that becomes `is_16_bit`).
+    /// Alias of [`is_16bit`].
     #[inline]
     pub fn is_16_bit(&self) -> bool {
         self.0.is_16bit()
     }
 
     /// `ZigString.fromBytes` — borrow `slice`; if it contains any non-ASCII
-    /// byte, sets the UTF-8 ptr-tag (ZigString.zig:14).
+    /// byte, sets the UTF-8 ptr-tag.
     #[inline]
     pub fn from_bytes(slice: &[u8]) -> Self {
         if !strings::is_all_ascii(slice) {
@@ -1528,9 +1511,8 @@ impl ZigString {
         }
     }
 
-    /// `ZigString.static` — wraps a `'static` ASCII literal. Zig returned a
-    /// `*const ZigString` to a comptime-interned holder; Rust callers consume
-    /// the value directly (ZigString is `Copy`), so we return by value.
+    /// `ZigString.static` — wraps a `'static` ASCII literal; returns by value
+    /// (`ZigString` is `Copy`).
     /// Generic over `str`/`[u8]` so either `"lit"` or `b"lit"` is accepted.
     #[inline]
     pub fn static_<S: ?Sized + AsRef<[u8]>>(slice: &'static S) -> Self {
@@ -1543,7 +1525,7 @@ impl ZigString {
     }
 
     /// `ZigString.utf8ByteLength` — exact UTF-8 byte length needed to encode
-    /// this string (ZigString.zig:221). UTF-16 → simdutf length; Latin-1
+    /// this string. UTF-16 → simdutf length; Latin-1
     /// → simdutf utf8-from-latin1 length; UTF-8 → `len`.
     pub fn utf8_byte_length(self) -> usize {
         if self.is_utf8() {
@@ -1552,15 +1534,14 @@ impl ZigString {
         if self.is_16bit() {
             return crate::strings::element_length_utf16_into_utf8(self.utf16_slice());
         }
-        // Latin-1 path (ZigString.zig delegates to encoding.byteLengthU8(.utf8),
-        // which is `simdutf.length.utf8.from.latin1` for the latin1 case).
+        // Latin-1 path: simdutf utf8-from-latin1 length.
         let s = self.slice();
         // SAFETY: s describes a valid byte slice.
         unsafe { bun_simdutf_sys::simdutf::simdutf__utf8_length_from_latin1(s.as_ptr(), s.len()) }
     }
 
     /// `ZigString.utf16ByteLength` — number of bytes the UTF-16LE encoding of
-    /// this string would occupy (ZigString.zig:199).
+    /// this string would occupy.
     pub fn utf16_byte_length(self) -> usize {
         if self.is_utf8() {
             let s = self.slice();
@@ -1576,11 +1557,10 @@ impl ZigString {
         self.len * 2
     }
 
-    /// `ZigString.latin1ByteLength` (ZigString.zig:211).
+    /// `ZigString.latin1ByteLength`.
     pub fn latin1_byte_length(self) -> usize {
         if self.is_utf8() {
-            // PORT NOTE: Zig: `@panic("TODO")` — never implemented for UTF-8
-            // sources. Match Zig behaviour.
+            // Never implemented for UTF-8 sources.
             unreachable!("ZigString.latin1ByteLength from UTF-8 — unimplemented in Zig");
         }
         self.len
@@ -1590,7 +1570,7 @@ impl ZigString {
     // `bun_runtime::webcore::encoding::ZigStringEncode` (extension trait); the
     // encoder bodies live in `bun_runtime`.
 
-    /// Port of `ZigString.githubAction` (ZigString.zig). Returns a `Display`
+    /// `ZigString.githubAction` — returns a `Display`
     /// formatter that escapes the string for GitHub Actions annotation output
     /// (`%0A` for newlines, ANSI stripped). Encoding-aware via `to_slice`.
     #[inline]
@@ -1614,10 +1594,9 @@ impl ZigString {
         crate::ZBox::from_vec_with_nul(list)
     }
 
-    /// `ZigString.indexOfAny` (ZigString.zig:89) — first index whose code unit
+    /// `ZigString.indexOfAny` — first index whose code unit
     /// matches any byte in `chars`. The 16-bit branch narrows each unit to the
-    /// Latin-1 range before comparing (mirrors Zig's comptime widening of the
-    /// `[]const u8` needle to `u16` inside `strings.indexOfAny16`).
+    /// Latin-1 range before comparing.
     pub fn index_of_any(self, chars: &'static [u8]) -> Option<usize> {
         if self.is_16bit() {
             self.utf16_slice()
@@ -1629,7 +1608,7 @@ impl ZigString {
     }
 
     /// `ZigString.charAt` — first/nth code unit, widened to `u16` regardless
-    /// of encoding (ZigString.zig:615). Caller must ensure `i < self.len`.
+    /// of encoding. Caller must ensure `i < self.len`.
     #[inline]
     pub fn char_at(self, i: usize) -> u16 {
         debug_assert!(i < self.len);
@@ -1640,26 +1619,23 @@ impl ZigString {
         }
     }
 
-    /// `ZigString.eqlComptime` — encoding-aware equality against a `'static`
-    /// ASCII literal (ZigString.zig:272). UTF-16 inputs go through the
+    /// Encoding-aware equality against a `'static`
+    /// ASCII literal. UTF-16 inputs go through the
     /// per-unit `eql_comptime_utf16` path; 8-bit inputs compare bytes
-    /// directly. The Zig version `@compileError`s on non-ASCII `other`; in
-    /// Rust we cannot enforce that at compile time, so it falls through to
-    /// the byte compare (caller is expected to pass ASCII).
+    /// directly. Non-ASCII `other` is not rejected at compile time; it falls
+    /// through to the byte compare (caller is expected to pass ASCII).
     pub fn eql_comptime<S: ?Sized + AsRef<[u8]>>(self, other: &S) -> bool {
         let other = other.as_ref();
         if self.is_16bit() {
             return strings::eql_comptime_utf16(self.utf16_slice(), other);
         }
-        // PORT NOTE: Zig branched on `comptime strings.isAllASCII(other)`;
-        // demoted to runtime length-check + byte compare.
         if self.len != other.len() {
             return false;
         }
         strings::eql_comptime_ignore_len(self.slice(), other)
     }
 
-    /// `ZigString.eql` — encoding-aware equality (ZigString.zig).
+    /// `ZigString.eql` — encoding-aware equality.
     pub fn eql(self, other: Self) -> bool {
         if self.len == 0 || other.len == 0 {
             return self.len == other.len;
@@ -1672,7 +1648,7 @@ impl ZigString {
         if !l16 && !r16 {
             return self.slice() == other.slice();
         }
-        // Mixed encoding — go through the UTF-8 view (matches Zig's slow path).
+        // Mixed encoding — go through the UTF-8 view.
         self.to_slice().slice() == other.to_slice().slice()
     }
 
@@ -1695,7 +1671,7 @@ impl ZigString {
         strings::is_all_ascii(self.slice())
     }
 
-    /// `ZigString.hasPrefixChar` (ZigString.zig).
+    /// `ZigString.hasPrefixChar`.
     pub fn has_prefix_char(&self, char: u8) -> bool {
         if self.len == 0 {
             return false;
@@ -1719,9 +1695,9 @@ impl ZigString {
     }
 
     /// `ZigString.detectEncoding` — if the (currently-untagged) bytes contain
-    /// any non-ASCII, mark the pointer as UTF-16. Mirrors ZigString.zig's
-    /// `detectEncoding` (which assumes the bytes were sourced from a
-    /// JS-produced 8-bit string and need re-widening on non-ASCII).
+    /// any non-ASCII, mark the pointer as UTF-16 (assumes the bytes were
+    /// sourced from a JS-produced 8-bit string and need re-widening on
+    /// non-ASCII).
     #[inline]
     pub fn detect_encoding(&mut self) {
         if !strings::is_all_ascii(self.slice()) {
@@ -1872,7 +1848,7 @@ impl ZigString {
         // size. Flag bits stripped by `untagged`.
         unsafe { core::slice::from_raw_parts(Self::untagged(self.tagged_ptr()), bytes) }
     }
-    /// `ZigString.substringWithLen` (ZigString.zig:166) — re-wrap a sub-range
+    /// `ZigString.substringWithLen` — re-wrap a sub-range
     /// of the underlying storage, preserving the UTF-8/16-bit/global tag bits.
     pub fn substring_with_len(self, start_index: usize, end_index: usize) -> ZigString {
         if self.is_16bit() {
@@ -1891,12 +1867,12 @@ impl ZigString {
         }
         out
     }
-    /// `ZigString.substring` (ZigString.zig:183).
+    /// `ZigString.substring`.
     #[inline]
     pub fn substring(self, start_index: usize) -> ZigString {
         self.substring_with_len(start_index.min(self.len), self.len)
     }
-    /// `ZigString.trunc` (ZigString.zig:268) — clamp `len`, preserving the
+    /// `ZigString.trunc` — clamp `len`, preserving the
     /// pointer (and its tag bits) verbatim.
     #[inline]
     pub fn trunc(self, len: usize) -> ZigString {
@@ -1927,15 +1903,14 @@ impl ZigString {
     }
 
     /// `ZigString.toOwnedSlice` — allocate a fresh UTF-8 `Vec<u8>` regardless
-    /// of the source encoding (ZigString.zig:239). UTF-16 → transcode; UTF-8 →
+    /// of the source encoding. UTF-16 → transcode; UTF-8 →
     /// copy; Latin-1 → transcode (or copy if all-ASCII).
     ///
     /// The returned buffer is NUL-terminated one byte past `len()` (the
-    /// terminator is *not* included in `len()`), matching ZigString.zig:243-245
-    /// so `sliceZBuf` / C-string consumers can read `as_ptr()` directly.
+    /// terminator is *not* included in `len()`) so `sliceZBuf` / C-string
+    /// consumers can read `as_ptr()` directly.
     pub fn to_owned_slice(&self) -> Vec<u8> {
-        // Write a NUL sentinel at `v[len]` without bumping `len` (mirrors
-        // ZigString.zig:243-245 / `dupeZ`).
+        // Write a NUL sentinel at `v[len]` without bumping `len`.
         #[inline]
         fn with_sentinel(mut v: Vec<u8>) -> Vec<u8> {
             v.reserve_exact(1);
@@ -1947,7 +1922,7 @@ impl ZigString {
         if self.len == 0 {
             return Vec::new();
         }
-        // PORT NOTE: order matches ZigString.zig:233-253 — `isUTF8()` is tested
+        // Order matters — `isUTF8()` is tested
         // before `is16Bit()` so a string with both tags set takes the UTF-8 arm.
         if self.is_utf8() {
             return with_sentinel(self.slice().to_vec());
@@ -1960,12 +1935,12 @@ impl ZigString {
         with_sentinel(crate::strings::to_utf8_from_latin1(bytes).unwrap_or_else(|| bytes.to_vec()))
     }
 
-    /// `ZigString.toSliceClone` — the returned slice is *always* heap-owned
-    /// (ZigString.zig:693). Unlike `to_slice`, this never borrows the source
+    /// `ZigString.toSliceClone` — the returned slice is *always* heap-owned.
+    /// Unlike `to_slice`, this never borrows the source
     /// bytes, so the result outlives a GC'd `JSString` that produced `self`.
     ///
-    /// PORT NOTE: Zig returned `OOM!Slice`; with mimalloc as the global
-    /// allocator OOM aborts the process, so this is infallible.
+    /// Infallible: with mimalloc as the global allocator, OOM aborts the
+    /// process.
     pub fn to_slice_clone(&self) -> ZigStringSlice {
         if self.len == 0 {
             return ZigStringSlice::EMPTY;
@@ -1977,11 +1952,9 @@ impl ZigString {
     /// the end (`slice().as_ptr()` is a valid C string of length `slice().len()`).
     /// `slice()` itself does *not* include the terminator.
     ///
-    /// PORT NOTE: the Zig method this targets was never instantiated (lazy
-    /// compilation); JSString/JSValue callers reached for it but no `.zig`
-    /// caller forced codegen. Semantics here match `toOwnedSliceZ` wrapped in
-    /// a `Slice` so `JSValue::to_slice_z` / `JSString::to_slice_z` get the
-    /// `[:0]` guarantee they document.
+    /// Semantics match `toOwnedSliceZ` wrapped in a `Slice` so
+    /// `JSValue::to_slice_z` / `JSString::to_slice_z` get the `[:0]`
+    /// guarantee they document.
     pub fn to_slice_z(&self) -> ZigStringSlice {
         if self.len == 0 {
             // Static "" already points at a NUL byte.
@@ -1997,8 +1970,8 @@ impl ZigString {
     }
 }
 
-/// `ZigString.Slice` — a borrowed-or-owned UTF-8 byte slice. Replaces the
-/// Zig allocator-vtable trick (`StringImplAllocator` etc.) with explicit ownership.
+/// `ZigString.Slice` — a borrowed-or-owned UTF-8 byte slice with explicit
+/// ownership.
 pub enum ZigStringSlice {
     /// Borrowed; never freed (`fromUTF8NeverFree`).
     Static(*const u8, usize),
@@ -2099,7 +2072,7 @@ impl Drop for ZigStringSlice {
     }
 }
 
-/// `bun.SliceWithUnderlyingString` (string.zig:1035) — a UTF-8 byte view paired
+/// `bun.SliceWithUnderlyingString` — a UTF-8 byte view paired
 /// with the `bun.String` that may back it. `utf8` is either a borrowed/owned
 /// byte slice or empty; `underlying` is the `String` whose ref keeps `utf8`
 /// alive when WTF-backed.
@@ -2142,7 +2115,6 @@ impl SliceWithUnderlyingString {
     }
 
     /// `fromUTF8` — wrap a borrowed UTF-8 slice (caller keeps it alive).
-    /// Zig assumed `default_allocator`; Rust port uses `Static` (no free).
     #[inline]
     pub fn from_utf8(utf8: &[u8]) -> SliceWithUnderlyingString {
         SliceWithUnderlyingString {
@@ -2160,9 +2132,8 @@ impl SliceWithUnderlyingString {
     }
 
     /// `deinit` — release `utf8`'s allocation (if any) and deref `underlying`.
-    /// Explicit for parity with Zig call sites; `Drop` is intentionally not
-    /// implemented because `underlying: String` is `Copy` (matches Zig manual
-    /// `defer .deinit()` pattern).
+    /// `Drop` is intentionally not implemented because `underlying: String`
+    /// is `Copy`.
     pub fn deinit(self) {
         // `utf8` drops via ZigStringSlice::Drop.
         self.underlying.deref();
@@ -2170,7 +2141,7 @@ impl SliceWithUnderlyingString {
 
     /// `toThreadSafe` — if `underlying` is WTF-backed, migrate it to a
     /// thread-safe impl and re-derive `utf8` if it was a ref-counted view
-    /// into the old impl (string.zig:1090).
+    /// into the old impl.
     pub fn to_thread_safe(&mut self) {
         if self.underlying.0.tag == Tag::WTFStringImpl {
             let orig = self.underlying.wtf_ptr();
@@ -2212,17 +2183,16 @@ impl ZigStringSlice {
     }
 
     /// True iff this slice owns a heap allocation that would be freed on
-    /// `Drop`. Replaces the Zig `slice.allocator.get().is_some()` idiom: in
-    /// Rust the allocator is implicit in the variant. `WtfBorrowed` is *not*
+    /// `Drop`. The allocator is implicit in the variant. `WtfBorrowed` is *not*
     /// allocated — it borrows storage pinned by someone else.
     #[inline]
     pub fn is_allocated(&self) -> bool {
         matches!(self, Self::Owned(_) | Self::WTF { .. })
     }
 
-    /// True iff this slice is a view into a `WTF::StringImpl` (the Zig
-    /// `String.isWTFAllocator(slice.allocator)` check) — whether it holds its
-    /// own ref (`WTF`) or is pinned by an `underlying` (`WtfBorrowed`). Used by
+    /// True iff this slice is a view into a `WTF::StringImpl` — whether it
+    /// holds its own ref (`WTF`) or is pinned by an `underlying`
+    /// (`WtfBorrowed`). Used by
     /// [`SliceWithUnderlyingString::to_thread_safe`] to decide whether the view
     /// must be re-derived after a thread-safe migration.
     #[inline]
@@ -2285,13 +2255,13 @@ impl ZigStringSlice {
 pub use crate::{WStr, ZStr};
 
 /// `bun_core::zig_string` — module path so callers can spell `ZigString.Slice`
-/// as `zig_string::Slice` (matches the Zig namespace `ZigString.Slice`).
+/// as `zig_string::Slice`.
 pub mod zig_string {
     pub use super::ZigString;
     pub use super::ZigStringSlice as Slice;
     impl super::ZigStringSlice {
-        /// `ZigString.Slice.empty` — Rust idiom is `EMPTY`, but several
-        /// dependents call `.empty()` (matching Zig's `.empty`).
+        /// `ZigString.Slice.empty` — the idiomatic constant is `EMPTY`, but
+        /// several dependents call `.empty()`.
         #[inline]
         pub const fn empty() -> Self {
             Self::Static(core::ptr::null(), 0)
@@ -2336,7 +2306,7 @@ pub mod encoding {
 }
 pub use encoding::Encoding as NodeEncoding;
 
-// `strings` is the canonical Zig namespace name; alias to the real module.
+// `strings` is the canonical `bun.strings` namespace name; alias to the real module.
 pub use immutable as strings;
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -2427,7 +2397,7 @@ pub mod lexer_tables {
     }
 }
 
-/// `jsc::VirtualMachine::string_allocation_limit` (VirtualMachine.zig:14) —
+/// `jsc::VirtualMachine::string_allocation_limit` —
 /// process-wide WTF::StringImpl character-count cap, exported for C++ as
 /// `Bun__stringSyntheticAllocationLimit`. The value lives here (not `bun_jsc`)
 /// because [`String::max_length`] / `create_external*` need it without an
@@ -2437,7 +2407,7 @@ pub mod lexer_tables {
 pub static STRING_ALLOCATION_LIMIT: AtomicUsize = AtomicUsize::new(u32::MAX as usize);
 
 // ──────────────────────────────────────────────────────────────────────────
-// move-in: printer (MOVE_DOWN ← src/js_printer/js_printer.zig)
+// move-in: printer (MOVE_DOWN ← `bun_js_printer`)
 //
 // Self-contained string-quoting helpers used by `strings::format_escapes`,
 // `bun_sourcemap::Chunk` (JSON serialization), and `bun_ast::Expr`.
@@ -2498,9 +2468,9 @@ pub mod printer {
         }
     }
 
-    /// Port of `js_printer.writePreQuotedString`.
-    /// PERF(port): was comptime-monomorphized over (quote_char, ascii_only, json,
-    /// encoding); demoted to runtime params — profile if it shows up on a hot path.
+    /// Same algorithm as `bun_js_printer::write_pre_quoted_string`.
+    /// PERF: (quote_char, ascii_only, json, encoding) are runtime params —
+    /// profile if it shows up on a hot path.
     pub fn write_pre_quoted_string<W: PrinterWriter + ?Sized>(
         text_in: &[u8],
         writer: &mut W,
@@ -2651,7 +2621,7 @@ pub mod printer {
         bytes: &mut MutableString,
         ascii_only: bool,
     ) -> Result<(), crate::Error> {
-        // PERF(port): Zig pre-grew via estimateLengthForUTF8 — profile if it shows up on a hot path.
+        // PERF: consider pre-growing via an estimated UTF-8 length — profile if it shows up on a hot path.
         bytes.append_char(b'"')?;
         write_pre_quoted_string(text, bytes, b'"', ascii_only, true, StrEncoding::Utf8)?;
         bytes.append_char(b'"').expect("unreachable");
@@ -2661,22 +2631,20 @@ pub mod printer {
 pub use printer::quote_for_json;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Top-level free helpers (move-ins from misc Zig namespaces).
+// Top-level free helpers.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun.sliceTo(buf, 0)` — slice up to (not including) the first NUL byte,
-/// or the whole buffer if none. Port of `std.mem.sliceTo` for `u8`/`0`.
+/// or the whole buffer if none.
 /// Sunk to `crate::ffi` so tier-1 crates (cares_sys, sys) can share it;
 /// re-exported here for the existing `bun_core::slice_to_nul` callers.
 pub use crate::ffi::{slice_to_nul, slice_to_nul_mut};
 
-/// move-in: `cheap_prefix_normalizer` (MOVE_DOWN ← `bundle_v2.zig`).
-///
 /// Pure path-string helper used by the bundler chunk writer and `css::printer`.
 /// Returns `[prefix', suffix']` such that concatenating them produces a
 /// reasonably-normalized path (collapses `./` leading and avoids `//`).
-/// Matches the .zig spec `[2]string` return shape so bundler call-sites can
-/// index it directly.
+/// The two-element-array return shape lets bundler call-sites index it
+/// directly.
 pub fn cheap_prefix_normalizer<'a>(prefix: &'a [u8], suffix: &'a [u8]) -> [&'a [u8]; 2] {
     if prefix.is_empty() {
         let suffix_no_slash = strings::remove_leading_dot_slash(suffix);
@@ -2699,8 +2667,7 @@ pub fn cheap_prefix_normalizer<'a>(prefix: &'a [u8], suffix: &'a [u8]) -> [&'a [
         {
             return [prefix, &suffix[1..]];
         }
-        // It gets really complicated if we try to deal with URLs more than this
-        // (see bundle_v2.zig comment block).
+        // It gets really complicated if we try to deal with URLs more than this.
     }
 
     [prefix, strings::remove_leading_dot_slash(suffix)]
diff --git a/src/bun_core/string/write.rs b/src/bun_core/string/write.rs
index 9a4447106ea..08d04f0262f 100644
--- a/src/bun_core/string/write.rs
+++ b/src/bun_core/string/write.rs
@@ -1,4 +1,4 @@
-//! Canonical byte-oriented `Write` trait — single port of Zig `std.Io.Writer`.
+//! Canonical byte-oriented `Write` trait.
 //!
 //! HOSTED IN `bun_string` so the trait sits *below* every consumer in the dep
 //! DAG: `bun_io → bun_string` already exists, and `bun_string` already depends
diff --git a/src/bun_core/string/wtf.rs b/src/bun_core/string/wtf.rs
index af41a549646..99520ff7043 100644
--- a/src/bun_core/string/wtf.rs
+++ b/src/bun_core/string/wtf.rs
@@ -1,6 +1,5 @@
-use crate::string::strings;
-// TODO(port): ZigString.Slice is a nested type in Zig; in Rust it lives alongside ZigString.
 use crate::string::ZigStringSlice;
+use crate::string::strings;
 
 // Canonical layout lives in `bun_alloc` (lowest-tier crate) so the
 // `is_wtf_allocator` vtable-identity check is a local pointer compare with no
@@ -46,8 +45,7 @@ impl WTFStringImplExt for WTFStringImplStruct {
     fn to_latin1_slice(&self) -> ZigStringSlice {
         self.r#ref();
         let s = self.latin1_slice();
-        // ZigStringSlice::WTF derefs `self` on Drop — replaces the Zig
-        // StringImplAllocator vtable trick with explicit ownership.
+        // ZigStringSlice::WTF derefs `self` on Drop.
         // SAFETY: `self` is a live WTF::StringImpl with refcount just bumped above;
         // we store only a `*const` (never materialize `&mut`) and the matching
         // deref happens via FFI on Drop. Mutation of m_ref_count is C++-side
@@ -112,8 +110,8 @@ impl WTFStringImplExt for WTFStringImplStruct {
         ZigStringSlice::init_owned(strings::to_utf8_alloc(self.utf16_slice()))
     }
 
-    /// Allocates a NUL-terminated UTF-8 copy. Port of `toOwnedSliceZ`.
-    /// `.len()` excludes the sentinel (Zig `[:0]u8` semantics).
+    /// Allocates a NUL-terminated UTF-8 copy.
+    /// `.len()` excludes the sentinel.
     fn to_owned_slice_z(&self) -> crate::ZBox {
         if self.is_8bit() {
             if let Some(utf8) = strings::to_utf8_from_latin1_z(self.latin1_slice()) {
@@ -149,10 +147,7 @@ impl WTFStringImplExt for WTFStringImplStruct {
         if self.is_8bit() {
             let input = self.latin1_slice();
             if !input.is_empty() {
-                // Port: latin1→utf8 length is just elementLengthLatin1IntoUTF8
-                // (each high byte becomes 2 utf8 bytes). The Zig went through
-                // jsc.WebCore.encoding.byteLengthU8 but for Utf8 target that
-                // reduces to the same arithmetic.
+                // latin1→utf8 length: each high byte becomes 2 utf8 bytes.
                 strings::element_length_latin1_into_utf8(input)
             } else {
                 0
@@ -177,14 +172,7 @@ impl WTFStringImplExt for WTFStringImplStruct {
     }
 }
 
-// PORT NOTE: Zig's `StringImplAllocator` was a `std.mem.Allocator` vtable trick
-// (alloc() bumped ref, free() dropped it) so a `ZigString.Slice` would deref the
-// WTFStringImpl when freed. Replaced by `ZigStringSlice::WTF { .. }` explicit
-// ownership variant — see `to_latin1_slice` above. No allocator trait needed.
-
 // `WTF.parseDouble` canonical now lives in bun_core::fmt (tier-0) so
 // `bun_interchange` (yaml/toml) and `bun_js_parser::lexer` can call it without
-// any string/jsc dep. Re-exported here to keep the Zig namespace shape.
+// any string/jsc dep. Re-exported here for back-compat.
 pub use crate::fmt::{InvalidCharacter, parse_double};
-
-// ported from: src/string/wtf.zig
diff --git a/src/bun_core/thread_id.rs b/src/bun_core/thread_id.rs
index 9a1195f6059..252d1005ef3 100644
--- a/src/bun_core/thread_id.rs
+++ b/src/bun_core/thread_id.rs
@@ -2,9 +2,8 @@
 //! for storing in an atomic and printing in panics so it lines up with what a
 //! debugger / `top -H` / Instruments shows.
 //!
-//! Ground truth is Zig's `std.Thread.Id` / `std.Thread.getCurrentId()`
-//! (vendor/zig/lib/std/Thread.zig). This is the single Rust port of that
-//! per-OS ladder; every other crate re-exports or widens from here:
+//! This is the single per-OS ladder; every other crate re-exports or widens
+//! from here:
 //!   * `bun_safety::thread_id`       → `pub use bun_core::thread_id::*;`
 //!   * `bun_threading::current_thread_id` → `current() as u64`
 //!   * `bun_core::util::debug_thread_id`  → `current() as u64` (debug-only)
@@ -13,9 +12,9 @@
 //! process-local monotonic counter (no `MAX`, no atomic repr, not the kernel
 //! TID), whereas every consumer (`CriticalSection`, `ThreadLock`, `ThreadCell`)
 //! needs a plain integer it can store in an atomic and compare against a
-//! sentinel — exactly Zig's semantics.
+//! sentinel.
 
-// ── ThreadId width (mirrors Zig `std.Thread.Id` switch) ───────────────────
+// ── ThreadId width ─────────────────────────────────────────────────────────
 //   linux / *bsd / haiku / wasi / serenity → u32
 //   macOS / iOS / watchOS / tvOS / visionOS → u64
 //   Windows                                → DWORD (u32)
@@ -60,7 +59,7 @@ pub type ThreadId = u64;
 )))]
 pub type ThreadId = usize;
 
-// ── Atomic wrapper (Zig: `std.atomic.Value(Thread.Id)`) ───────────────────
+// ── Atomic wrapper ─────────────────────────────────────────────────────────
 // Width-matched alias so `CriticalSection` can `compare_exchange` on it directly.
 #[cfg(any(
     target_os = "linux",
@@ -103,14 +102,10 @@ pub type AtomicThreadId = core::sync::atomic::AtomicU64;
 pub type AtomicThreadId = core::sync::atomic::AtomicUsize;
 
 /// A value that does not alias any other thread ID.
-/// See `Thread/Mutex/Recursive.zig` in the Zig standard library.
-// Zig: `pub const invalid = std.math.maxInt(std.Thread.Id);`
 pub const INVALID: ThreadId = ThreadId::MAX;
 
-/// Per-thread cache of [`current()`]. Zig's `LinuxThreadImpl.getCurrentId()`
-/// reads a `threadlocal var tls_thread_id` set once at thread start
-/// (vendor/zig/lib/std/Thread.zig:841,885); the Rust port called the syscall
-/// (`gettid`/`pthread_threadid_np`/`GetCurrentThreadId`) on every call. The
+/// Per-thread cache of [`current()`]. Without it, every call paid a syscall
+/// (`gettid`/`pthread_threadid_np`/`GetCurrentThreadId`). The
 /// bundler's `Worker::get(ctx)` calls `current()` once per scheduled task —
 /// parse, line-offset table, quoted source contents, compile-result
 /// generation, link step 5 — so a 19 K-module build paid ~109 K `gettid`
@@ -119,20 +114,17 @@ pub const INVALID: ThreadId = ThreadId::MAX;
 /// `0` is the unset sentinel: kernel TIDs / `pthread_threadid_np` IDs /
 /// Win32 thread IDs are all nonzero. A bare `#[thread_local]` slot (not the
 /// `thread_local!` macro) so this is a single TLS load with no `LocalKey`
-/// initialization-state branch or destructor registration — same as Zig's
-/// `threadlocal var`.
+/// initialization-state branch or destructor registration.
 #[thread_local]
 static TLS_THREAD_ID: core::cell::Cell<ThreadId> = core::cell::Cell::new(0);
 
 /// Returns the platform's notion of the calling thread's ID.
 ///
-/// Port of Zig `std.Thread.getCurrentId()` (`PosixThreadImpl` / `WindowsThreadImpl` /
-/// `LinuxThreadImpl`). Attempts to use OS-specific primitives so the value matches what
+/// Attempts to use OS-specific primitives so the value matches what
 /// debuggers/tracers report; falls back to `pthread_self()` as a `usize` on unknown targets.
 ///
 /// Cached per-thread after the first call (see [`TLS_THREAD_ID`]); subsequent
-/// calls are a single TLS read with no syscall, matching Zig's
-/// `tls_thread_id` slot. Lazy rather than set-at-spawn so threads not started
+/// calls are a single TLS read with no syscall. Lazy rather than set-at-spawn so threads not started
 /// by Bun's pool (FFI callbacks, the main thread) still get a valid ID.
 #[inline]
 pub fn current() -> ThreadId {
@@ -149,7 +141,6 @@ pub fn current() -> ThreadId {
 fn current_uncached() -> ThreadId {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
-        // Zig: `LinuxThreadImpl.getCurrentId()` → `linux.gettid()`.
         // SAFETY: `gettid` takes no arguments and cannot fail.
         return unsafe { libc::gettid() } as ThreadId;
     }
@@ -161,7 +152,6 @@ fn current_uncached() -> ThreadId {
         target_os = "visionos",
     ))]
     {
-        // Zig: `pthread_threadid_np(null, &thread_id)`.
         unsafe extern "C" {
             fn pthread_threadid_np(
                 thread: *mut core::ffi::c_void,
@@ -229,7 +219,6 @@ fn current_uncached() -> ThreadId {
         target_os = "visionos",
     )))]
     {
-        // Zig fallback: `@intFromPtr(c.pthread_self())`.
         unsafe extern "C" {
             // safe: no args; infallible.
             safe fn pthread_self() -> usize;
@@ -237,5 +226,3 @@ fn current_uncached() -> ThreadId {
         return pthread_self() as ThreadId;
     }
 }
-
-// ported from: vendor/zig/lib/std/Thread.zig (Id / getCurrentId)
diff --git a/src/bun_core/tty.rs b/src/bun_core/tty.rs
index 1e0fc8f7d6a..fd86bef2d20 100644
--- a/src/bun_core/tty.rs
+++ b/src/bun_core/tty.rs
@@ -1,7 +1,7 @@
 use core::ffi::c_int;
 
 // ─── MOVE-IN: Winsize (TYPE_ONLY from bun_sys → bun_core) ─────────────────
-// Zig: `std.posix.winsize` — used by output.rs::TERMINAL_SIZE. Field names
+// Used by output.rs::TERMINAL_SIZE. Field names
 // match the move-out forward-ref in output.rs (row/col, not ws_row/ws_col).
 #[repr(C)]
 #[derive(Clone, Copy, Default, Debug)]
@@ -29,8 +29,7 @@ pub fn set_mode(fd: c_int, mode: Mode) -> c_int {
 }
 
 /// RAII guard: sets `fd` to [`Mode::Raw`] on construction and restores
-/// [`Mode::Normal`] on `Drop`. Replaces the Zig
-/// `defer { _ = bun.tty.set_mode(0, .Normal); }` pattern at call sites.
+/// [`Mode::Normal`] on `Drop`.
 pub struct RawModeGuard {
     fd: c_int,
 }
@@ -50,9 +49,6 @@ impl Drop for RawModeGuard {
     }
 }
 
-// TODO(port): move to bun_core_sys (or appropriate *_sys crate)
 unsafe extern "C" {
     safe fn Bun__ttySetMode(fd: c_int, mode: c_int) -> c_int;
 }
-
-// ported from: src/bun_core/tty.zig
diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index bb320020afa..c1606ab207c 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -1,10 +1,9 @@
-// ─── std.mem.bytesAsSlice / sliceAsBytes ─────────────────────────────────────
-/// Zig `std.mem.bytesAsSlice(T, bytes)` for `&mut [u8]` → `&mut [T]`.
+// ─── byte ↔ typed-slice reinterpretation ─────────────────────────────────────
+/// Reinterpret `&mut [u8]` as `&mut [T]`.
 ///
 /// SAFETY (caller-upheld):
-/// * `bytes.as_ptr()` must be aligned to `align_of::<T>()` — Zig spells this
-///   as `@alignCast`, which is a *checked* operation (illegal-behavior trap in
-///   safe builds). We mirror that with a hard `assert!` rather than
+/// * `bytes.as_ptr()` must be aligned to `align_of::<T>()`. We enforce this
+///   with a hard `assert!` rather than
 ///   `debug_assert!`: forming a misaligned `&mut [T]` is instant UB in Rust
 ///   even if never dereferenced, so this must not be silently elided in
 ///   release. The check is a single AND+CMP and every current call site is
@@ -12,7 +11,7 @@
 /// * `T` must be plain-old-data — every byte pattern in `bytes[..len/size]`
 ///   must be a valid `T` (callers use `u16`/`u32` only),
 /// * the trailing `len % size_of::<T>()` bytes are silently dropped from the
-///   reinterpreted view, matching Zig's `bytesAsSlice` semantics.
+///   reinterpreted view.
 #[inline]
 pub unsafe fn bytes_as_slice_mut<T>(bytes: &mut [u8]) -> &mut [T] {
     assert!(
@@ -26,7 +25,7 @@ pub unsafe fn bytes_as_slice_mut<T>(bytes: &mut [u8]) -> &mut [T] {
 }
 
 // ─── Unaligned<T> ─────────────────────────────────────────────────────────────
-/// Port of Zig's `align(1) T` element type. Rust references and slices require
+/// Element wrapper with alignment 1. Rust references and slices require
 /// natural alignment for `T`; producing a `&[u16]` from an odd address is
 /// instant UB even if never dereferenced. `#[repr(packed)]` on this wrapper
 /// drops the alignment requirement to 1, so `&[Unaligned<T>]` is the sound
@@ -58,7 +57,7 @@ impl<T: Copy> Unaligned<T> {
     }
 
     /// Reinterpret `&[Unaligned<T>]` as `&[T]` once the caller has proven
-    /// `ptr` is naturally aligned (Zig `@alignCast`). Panics in debug if not.
+    /// `ptr` is naturally aligned. Panics in debug if not.
     /// Empty slices need no cast: their dangling pointer has align 1, not
     /// `align_of::<T>()`, so they are returned as `&[]` directly.
     #[inline]
@@ -96,16 +95,15 @@ impl<T: Copy> Unaligned<T> {
 // ════════════════════════════════════════════════════════════════════════════
 // Low-tier primitives hoisted into bun_core.
 // Forward-referenced as `crate::X` by Global.rs / output.rs / fmt.rs / env.rs.
-// Source bodies extracted from the corresponding .zig (ground truth).
 // ════════════════════════════════════════════════════════════════════════════
 
 // ─── ZStr / WStr / zstr! (from bun_str) ───────────────────────────────────
-// Zig: `[:0]const u8` / `[:0]const u16` — slice with sentinel. Rust models the
+// NUL-terminated byte / u16 strings. Rust models the
 // borrowed forms as DSTs over the byte/u16 slice (NUL not counted in len).
 // TYPE_ONLY move-down; full impls (from_raw, as_cstr, …) live in bun_str which
 // re-exports these via `pub use bun_core::{ZStr, WStr}`.
 
-/// Borrowed `[:0]const u8` — bytes are valid UTF-8-ish, len excludes the NUL.
+/// Borrowed NUL-terminated byte string — bytes are valid UTF-8-ish, len excludes the NUL.
 #[repr(transparent)]
 pub struct ZStr([u8]);
 
@@ -152,7 +150,7 @@ impl ZStr {
         debug_assert_eq!(buf[len], 0, "ZStr::from_buf: missing NUL at buf[len]");
         // SAFETY: `buf[..=len]` is in-bounds (debug-asserted above; release
         // relies on caller upholding the documented `buf[len] == 0`
-        // precondition, same contract as Zig `[:0]const u8` slicing).
+        // precondition).
         unsafe { Self::from_raw(buf.as_ptr(), len) }
     }
     /// Borrow `buf[..buf.len()-1]` as a `&ZStr`, where the last byte of `buf`
@@ -160,7 +158,7 @@ impl ZStr {
     /// most common call shape: a slice that already includes its trailing NUL
     /// (e.g. a `Vec<u8>` with `0` pushed, or `CStr::to_bytes_with_nul`).
     /// Debug-asserts the trailing NUL; release relies on the documented
-    /// precondition (same contract as Zig `[:0]const u8` slicing).
+    /// precondition.
     #[inline]
     pub fn from_slice_with_nul(buf: &[u8]) -> &ZStr {
         debug_assert!(!buf.is_empty(), "ZStr::from_slice_with_nul: empty slice");
@@ -208,7 +206,7 @@ impl ZStr {
     /// `CStr::from_bytes_with_nul_unchecked` call sites through one audited
     /// `unsafe`. Debug-asserts no interior NUL (CStr's extra invariant over
     /// ZStr); release relies on the construction-site contract (path/host
-    /// bytes never embed NUL — same assumption Zig `[:0]const u8` → C makes).
+    /// bytes never embed NUL).
     #[inline]
     pub fn as_cstr(&self) -> &core::ffi::CStr {
         debug_assert!(
@@ -250,7 +248,7 @@ impl ZStr {
     // The slice metadata of the returned `Box<ZStr>` covers `bytes.len() + 1`
     // (i.e. INCLUDES the trailing NUL) so `Drop` deallocates the full
     // allocation; `as_bytes()` will therefore include the trailing NUL.
-    // TODO(port): retire once all `Box<ZStr>` fields are migrated to `ZBox`.
+    // Retire once all `Box<ZStr>` fields are migrated to `ZBox`.
     pub fn boxed(bytes: &[u8]) -> Box<ZStr> {
         let mut v = Vec::with_capacity(bytes.len() + 1);
         v.extend_from_slice(bytes);
@@ -263,12 +261,11 @@ impl ZStr {
 }
 
 /// Owned, heap-allocated, NUL-terminated byte string. `.len()` / `Deref`
-/// **exclude** the trailing NUL — Zig `[:0]u8` semantics. This is the owned
-/// counterpart of `&ZStr`; use it where Zig returned an allocated `[:0]u8`.
+/// **exclude** the trailing NUL. This is the owned counterpart of `&ZStr`.
 #[derive(Clone)]
 pub struct ZBox(Box<[u8]>); // invariant: last byte == 0
 impl Default for ZBox {
-    /// Zig: `[:0]const u8 = ""` field default — an empty NUL-terminated string.
+    /// An empty NUL-terminated string.
     #[inline]
     fn default() -> Self {
         ZBox(Box::new([0u8; 1]))
@@ -283,8 +280,7 @@ impl ZBox {
         }
         ZBox(v.into_boxed_slice())
     }
-    /// Copy `bytes` into a new NUL-terminated allocation. Port of Zig
-    /// `allocator.dupeZ(u8, bytes)`.
+    /// Copy `bytes` into a new NUL-terminated allocation.
     #[inline]
     pub fn from_bytes(bytes: impl AsRef<[u8]>) -> ZBox {
         let bytes = bytes.as_ref();
@@ -293,8 +289,7 @@ impl ZBox {
         v.push(0);
         ZBox(v.into_boxed_slice())
     }
-    /// Take ownership of `v` and append a trailing NUL. Port of Zig
-    /// `list.toOwnedSliceSentinel(0)`.
+    /// Take ownership of `v` and append a trailing NUL.
     #[inline]
     pub fn from_vec(mut v: Vec<u8>) -> ZBox {
         v.push(0);
@@ -355,8 +350,6 @@ impl core::ops::Deref for ZStr {
 /// `bun.getenvZ` — read an environment variable. Returns the value as borrowed
 /// process-static bytes (env block lives for the process). On POSIX wraps
 /// `libc::getenv`; on Windows scans `environ` case-insensitively.
-///
-/// Port of `bun.zig:getenvZ` / `getenvZAnyCase`.
 pub fn getenv_z(key: &ZStr) -> Option<&'static [u8]> {
     #[cfg(not(any(unix, windows)))]
     {
@@ -371,16 +364,15 @@ pub fn getenv_z(key: &ZStr) -> Option<&'static [u8]> {
             return None;
         }
         // SAFETY: getenv returns a pointer into the process env block, valid for
-        // process lifetime (modulo setenv races — same caveat as Zig original).
+        // process lifetime (modulo setenv races).
         let len = libc::strlen(p);
         return Some(core::slice::from_raw_parts(p.cast::<u8>(), len));
     }
     #[cfg(windows)]
     {
-        // Windows env names are case-insensitive (Zig spec: `getenvZ` on
-        // Windows delegates to `getenvZAnyCase`). Walk the WTF-8 env block
-        // populated at startup by `bun_sys::windows::env::convert_env_to_wtf8`
-        // (main.zig:47). The block is `Box::leak`'d for process lifetime so
+        // Windows env names are case-insensitive. Walk the WTF-8 env block
+        // populated at startup by `bun_sys::windows::env::convert_env_to_wtf8`.
+        // The block is `Box::leak`'d for process lifetime so
         // `'static` borrows here are sound.
         getenv_z_any_case(key)
     }
@@ -463,7 +455,7 @@ pub fn getenv_z_any_case(key: &ZStr) -> Option<&'static [u8]> {
     }
 }
 
-/// Borrowed `[:0]const u16` (Windows wide string).
+/// Borrowed NUL-terminated u16 string (Windows wide string); len excludes the NUL.
 #[repr(transparent)]
 pub struct WStr([u16]);
 
@@ -484,8 +476,8 @@ impl WStr {
     /// form of [`from_raw`] for the dominant call shape: a stack `WPathBuffer`
     /// filled to `len` with a NUL written at `buf[len]`. The slice bound proves
     /// `buf[..=len]` lies in one allocation; the NUL is debug-asserted (release
-    /// relies on the documented `buf[len] == 0` precondition — same contract as
-    /// Zig `[:0]const u16` slicing). Mirrors [`ZStr::from_buf`].
+    /// relies on the documented `buf[len] == 0` precondition). Mirrors
+    /// [`ZStr::from_buf`].
     #[inline]
     pub fn from_buf(buf: &[u16], len: usize) -> &WStr {
         debug_assert!(len < buf.len(), "WStr::from_buf: NUL must lie within buf");
@@ -575,8 +567,7 @@ impl AsRef<[u16]> for WStr {
 }
 
 /// `wstr!("lit")` → `&'static [u16; N+1]` (NUL-terminated). Compile-time
-/// ASCII→UTF-16LE widening for Windows path / API literals; mirrors Zig
-/// `bun.strings.w("lit")` / `std.unicode.utf8ToUtf16LeStringLiteral`.
+/// ASCII→UTF-16LE widening for Windows path / API literals.
 ///
 /// Restricted to ASCII (`debug_assert` in the const evaluator) — every call
 /// site is a hard-coded path component (`"node_modules"`, `".git"`, etc.).
@@ -599,7 +590,7 @@ macro_rules! wstr {
     }};
 }
 
-/// `zstr!("lit")` → `&'static ZStr`. Mirrors Zig `"lit"` which is `*const [N:0]u8`.
+/// `zstr!("lit")` → `&'static ZStr`.
 #[macro_export]
 macro_rules! zstr {
     ($s:literal) => {{
@@ -651,7 +642,7 @@ pub struct Mutex<T>(std::sync::Mutex<T>);
 /// callers can name it in return types (e.g. `rare_data::ProxyEnvStorage::lock`).
 pub type MutexGuard<'a, T> = std::sync::MutexGuard<'a, T>;
 
-/// Zig `Guarded(T)` — same wrapper, different spelling.
+/// Alias for [`Mutex`].
 pub type Guarded<T> = Mutex<T>;
 
 impl<T> Mutex<T> {
@@ -740,17 +731,15 @@ impl<T: Default> Default for RwLock<T> {
 }
 
 // ─── Path primitives (from bun_paths) ─────────────────────────────────────
-// Zig: src/paths/paths.zig lines 13-20.
-// Zig uses `std.fs.max_path_bytes` which is platform-dependent.
 pub const MAX_PATH_BYTES: usize = if cfg!(target_arch = "wasm32") {
     1024
 } else if cfg!(windows) {
-    // std.os.windows.PATH_MAX_WIDE * 3 + 1 (UTF-8 worst-case from UTF-16).
+    // Windows PATH_MAX_WIDE (32767) * 3 + 1 (UTF-8 worst-case from UTF-16).
     32767 * 3 + 1
 } else if cfg!(any(target_os = "linux", target_os = "android")) {
     4096 // Linux libc::PATH_MAX
 } else {
-    // macOS / iOS / FreeBSD / OpenBSD / NetBSD / DragonFly / Solaris (std/c.zig PATH_MAX)
+    // macOS / iOS / FreeBSD / OpenBSD / NetBSD / DragonFly / Solaris PATH_MAX
     1024
 };
 pub const PATH_MAX_WIDE: usize = 32767;
@@ -768,7 +757,7 @@ pub type OSPathSliceZ = ZStr;
 
 pub use bun_alloc::SEP;
 
-/// Zig: `[MAX_PATH_BYTES]u8` stack buffer (`var buf: bun.PathBuffer = undefined`).
+/// `[u8; MAX_PATH_BYTES]` stack buffer for path syscalls.
 ///
 /// Canonical definition; `bun_paths::PathBuffer` re-exports this so the two
 /// crates share ONE nominal type and callers can pass a `bun_paths` buffer to
@@ -777,7 +766,7 @@ pub use bun_alloc::SEP;
 /// NOTE on alignment: `os_path_kernel32` (Windows) reinterprets a
 /// `&mut PathBuffer` as `&mut [u16]` via [`bytes_as_slice_mut`]. The language
 /// only guarantees align=1 for `[u8; N]`, so that reinterpret is guarded by a
-/// hard `assert!` (mirroring Zig `@alignCast`). We do *not* bump this struct
+/// hard `assert!`. We do *not* bump this struct
 /// to `#[repr(align(2))]` because several call sites reinterpret an arbitrary
 /// `&mut [u8]` *as* `PathBuffer`, and raising the nominal alignment would
 /// make *those* casts unsound instead. In practice every `PathBuffer` fed to
@@ -787,21 +776,20 @@ pub use bun_alloc::SEP;
 pub struct PathBuffer(pub [u8; MAX_PATH_BYTES]);
 impl PathBuffer {
     pub const ZEROED: Self = Self([0; MAX_PATH_BYTES]);
-    /// Zig `= undefined`. The bytes are immediately overwritten by the syscall
+    /// The bytes are immediately overwritten by the syscall
     /// that fills it, so the initial contents are never observed.
     ///
     /// On Windows `MAX_PATH_BYTES` is 98 302 (vs 4 096 Linux / 1 024 macOS), so
     /// the previous `Self::ZEROED` body here was a ~100 KB `memset` at every
     /// one of the ~400 call sites — turning hot loops (glob scan, module load,
     /// stack-trace formatting) into multi-GB zero-fill workloads and timing out
-    /// the leak/stress tests. Match the Zig spec and leave the bytes uninit.
+    /// the leak/stress tests. Leave the bytes uninit.
     #[inline]
     #[allow(invalid_value, clippy::uninit_assumed_init)]
     pub fn uninit() -> Self {
         // SAFETY: `PathBuffer` is `repr(transparent)` over `[u8; N]`; every bit
         // pattern is a valid `u8`, and callers treat this as a write-only
-        // scratch buffer (length-tracked) exactly like Zig
-        // `var buf: bun.PathBuffer = undefined`. No byte is read before being
+        // scratch buffer (length-tracked). No byte is read before being
         // written by the consuming syscall / encoder.
         unsafe { core::mem::MaybeUninit::uninit().assume_init() }
     }
@@ -834,12 +822,12 @@ impl core::ops::DerefMut for PathBuffer {
     }
 }
 
-/// Zig: `[PATH_MAX_WIDE]u16`. Same newtype shape as [`PathBuffer`].
+/// `[u16; PATH_MAX_WIDE]` wide path buffer. Same newtype shape as [`PathBuffer`].
 #[repr(transparent)]
 pub struct WPathBuffer(pub [u16; PATH_MAX_WIDE]);
 impl WPathBuffer {
     pub const ZEROED: Self = Self([0; PATH_MAX_WIDE]);
-    /// Zig `= undefined`. See [`PathBuffer::uninit`] — `PATH_MAX_WIDE` is
+    /// See [`PathBuffer::uninit`] — `PATH_MAX_WIDE` is
     /// 32 767 `u16`s (~64 KB), and these are allocated per Windows syscall
     /// for UTF-8→UTF-16 path conversion, so zero-initialising dominated the
     /// hot path on Windows.
@@ -848,8 +836,7 @@ impl WPathBuffer {
     pub fn uninit() -> Self {
         // SAFETY: `repr(transparent)` over `[u16; N]`; every bit pattern is a
         // valid `u16`. Callers treat this as a write-only scratch buffer and
-        // track the written length out-of-band — mirrors Zig
-        // `var wbuf: bun.WPathBuffer = undefined`.
+        // track the written length out-of-band.
         unsafe { core::mem::MaybeUninit::uninit().assume_init() }
     }
     /// Inherent `as_slice` so `wbuf.as_slice()` resolves here instead of the
@@ -887,8 +874,7 @@ pub type OSPathBuffer = WPathBuffer;
 #[cfg(not(windows))]
 pub type OSPathBuffer = PathBuffer;
 
-/// Zig: `bun.Dirname.dirname(u8, path)` → `std.fs.path.dirnamePosix` /
-/// `dirnameWindows`. Faithful port (handles trailing-sep stripping and root).
+/// Directory portion of `path` (handles trailing-sep stripping and root).
 pub fn dirname(path: &[u8]) -> Option<&[u8]> {
     use crate::path_sep::is_sep_native as is_sep;
 
@@ -914,19 +900,17 @@ pub fn dirname(path: &[u8]) -> Option<&[u8]> {
     while i > root_end {
         i -= 1;
         if is_sep(path[i]) {
-            // Zig `std.fs.path.dirnamePosix/Windows` returns up to (excluding)
-            // the separator found — it does NOT collapse a preceding run of
-            // separators, so `/foo//bar` → `/foo/`. Preserve that contract for
-            // re-export parity with `bun_paths::dirname`.
+            // Return up to (excluding) the separator found — do NOT collapse a
+            // preceding run of separators, so `/foo//bar` → `/foo/`. Preserve
+            // that contract for re-export parity with `bun_paths::dirname`.
             return Some(&path[..i]);
         }
     }
     // No separator AFTER root, but content past it (e.g. "/foo", "C:\foo"):
-    // Zig returns the root prefix iff the root itself ends in a separator
+    // return the root prefix iff the root itself ends in a separator
     // (`"/foo"` → `"/"`, `"C:\\foo"` → `"C:\\"`). A bare drive prefix with no
-    // separator (`"C:foo"`, root_end==2) falls through to `None`, matching
-    // `std.fs.path.dirnameWindows`. Root-only inputs ("/", "C:\") have
-    // `end == root_end` and also fall through.
+    // separator (`"C:foo"`, root_end==2) falls through to `None`. Root-only
+    // inputs ("/", "C:\") have `end == root_end` and also fall through.
     if root_end > 0 && end > root_end && is_sep(path[root_end - 1]) {
         return Some(&path[..root_end]);
     }
@@ -938,7 +922,7 @@ pub fn dirname(path: &[u8]) -> Option<&[u8]> {
 // Full method set (close, makeLibUVOwned, …) stays in bun_sys which re-exports
 // `pub use bun_core::Fd as FD;` and adds inherent impls there.
 
-// Zig backing_int (fd.zig:1): c_int on posix, u64 on Windows.
+// Backing int: c_int on posix, u64 on Windows.
 #[cfg(not(windows))]
 type FdBacking = i32;
 #[cfg(windows)]
@@ -948,7 +932,7 @@ type FdBacking = u64;
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct Fd(pub FdBacking);
 
-// Zig packed struct(u64) { value: u63, kind: u1 } — fields are LSB-first, so
+// Packed u64 { value: u63, kind: u1 } — fields are LSB-first, so
 // `value` is bits 0..63, `kind` is bit 63. (.system=0, .uv=1)
 #[cfg(windows)]
 const FD_KIND_BIT: u64 = 1u64 << 63;
@@ -956,14 +940,13 @@ const FD_KIND_BIT: u64 = 1u64 << 63;
 const FD_VALUE_MASK: u64 = FD_KIND_BIT - 1;
 
 impl Fd {
-    /// Zig fd.zig:33-35: { kind=.system, value.as_system = minInt(field_type) }.
     /// posix: minInt(c_int); windows: minInt(u63) = 0, kind=0 → all-zero u64.
     #[cfg(not(windows))]
     pub const INVALID: Fd = Fd(i32::MIN);
     #[cfg(windows)]
     pub const INVALID: Fd = Fd(0);
 
-    /// Zig `bun.invalid_fd` / `FD.invalid` — function form of [`Fd::INVALID`]
+    /// Function form of [`Fd::INVALID`]
     /// for call sites that read better as a constructor (`Fd::invalid()`).
     #[inline]
     pub const fn invalid() -> Fd {
@@ -991,7 +974,6 @@ impl Fd {
     #[inline]
     pub fn from_system(h: *mut core::ffi::c_void) -> Fd {
         // kind=.system (bit 63 = 0); WindowsHandleNumber is u63.
-        // Zig fd.zig:48 asserts `@intFromPtr(value) <= maxInt(u63)`.
         debug_assert!((h as u64) <= FD_VALUE_MASK);
         Fd((h as u64) & FD_VALUE_MASK)
     }
@@ -1186,7 +1168,7 @@ impl Fd {
     pub fn decode_windows(self) -> DecodeWindows {
         match self.kind() {
             FdKind::System => {
-                // Zig `numberToHandle`: `if (handle == 0) return INVALID_HANDLE_VALUE`.
+                // A stored value of 0 decodes to INVALID_HANDLE_VALUE.
                 let n = self.value_as_system();
                 let h = if n == 0 { usize::MAX } else { n as usize };
                 DecodeWindows::Windows(h as *mut core::ffi::c_void)
@@ -1196,12 +1178,12 @@ impl Fd {
         }
     }
 
-    /// Zig `FD.makeLibUVOwned` (`fd.zig`): on Windows, convert a system-kind
+    /// On Windows, convert a system-kind
     /// `Fd` (raw `HANDLE`) into a libuv-kind `Fd` (CRT `_open_osfhandle`-backed
     /// `int`) so libuv `uv_fs_*` APIs can consume it. uv-kind passes through.
     /// On POSIX this is the identity (libuv fd == posix fd).
     ///
-    /// Returns `Err(())` (= Zig's `error.SystemFdQuotaExceeded`) when
+    /// Returns `Err(())` when
     /// `uv_open_osfhandle` returns `-1`; the caller decides whether to close
     /// the original handle (see `make_libuv_owned_for_syscall`).
     #[inline]
@@ -1293,13 +1275,13 @@ impl Fd {
     }
 }
 
-/// `std.posix.fd_t` — `c_int` on POSIX, `HANDLE` (`*anyopaque`) on Windows.
+/// Native file-descriptor type — `c_int` on POSIX, `HANDLE` on Windows.
 #[cfg(not(windows))]
 pub type FdNative = i32;
 #[cfg(windows)]
 pub type FdNative = *mut core::ffi::c_void;
 
-/// Zig `Kind` — tag in bit 63 on Windows, `enum(u0)` (zero-width) on POSIX.
+/// Fd kind — tag in bit 63 on Windows; single-variant on POSIX.
 #[cfg(not(windows))]
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -1351,7 +1333,7 @@ impl Stdio {
     }
 }
 
-/// Niche-packed `Option<Fd>` (`enum(backing_int) { none = @bitCast(invalid), _ }`).
+/// Niche-packed `Option<Fd>`: the invalid-fd bit pattern is the `none` sentinel.
 /// Use instead of encoding the invalid value directly.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -1464,9 +1446,10 @@ pub unsafe fn fd_path_raw(fd: Fd, buf: *mut u8, cap: usize) -> isize {
 }
 
 /// Wide-char fd → path (Windows `GetFinalPathNameByHandleW`). Returns code
-/// units written (>0), <0 on error, 0 on non-Windows. Body is a single
-/// kernel32 call, so it lives at T0 — moved down from `bun_sys` per
-/// PORTING.md (no cross-crate extern).
+/// units written (>0), -1 on lookup failure,
+/// -2 when the buffer is too small, 0 on
+/// non-Windows. Body is a single kernel32 call, so it lives at T0 — moved
+/// down from `bun_sys` per PORTING.md (no cross-crate extern).
 ///
 /// SAFETY: `buf` must be valid for `cap` writable `u16` units.
 pub unsafe fn fd_path_raw_w(fd: Fd, buf: *mut u16, cap: usize) -> isize {
@@ -1483,13 +1466,17 @@ pub unsafe fn fd_path_raw_w(fd: Fd, buf: *mut u16, cap: usize) -> isize {
         // VOLUME_NAME_DOS (0) — matches `bun_sys::windows::GetFinalPathNameByHandle` default.
         // SAFETY: buf has `cap` u16 units; handle from Fd::native().
         let n = unsafe { GetFinalPathNameByHandleW(fd.native(), buf, cap as u32, 0) } as usize;
-        // Zig `bun.windows.GetFinalPathNameByHandle`: `if (return_length >=
-        // out_buffer.len) return error.NameTooLong;` — `>=` because a return
+        // The size check below is `>=` because a return
         // value equal to `cap` is the buffer-too-small sentinel (required size
         // including NUL), not a successful write of `cap` chars.
-        if n == 0 || n >= cap {
+        if n == 0 {
+            // Lookup failure.
             return -1;
         }
+        if n >= cap {
+            // Buffer too small.
+            return -2;
+        }
         // Strip the `\\?\` prefix if present so callers see a plain DOS path
         // (matches `bun_sys::windows::GetFinalPathNameByHandle` post-processing).
         // Work entirely through raw-pointer reads/writes — never form a `&[u16]`
@@ -1566,7 +1553,7 @@ impl core::fmt::Display for Fd {
     }
 }
 
-/// Zig fd.zig module-level statics + Windows libuv/PEB FFI shims (T0 → no
+/// Fd module-level statics + Windows libuv/PEB FFI shims (T0 → no
 /// crate dep, just `extern` symbols; libuv is linked into the final binary).
 pub mod fd {
     use super::Fd;
@@ -1600,9 +1587,8 @@ pub mod fd {
     pub use crate::windows_sys::{STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE};
     #[cfg(windows)]
     pub fn is_stdio_handle(id: u32, handle: *mut c_void) -> bool {
-        // Zig: `const h = std.os.windows.GetStdHandle(id) catch return false;
-        // return handle == h;` — the Zig wrapper maps both NULL and
-        // INVALID_HANDLE_VALUE to an error, so use the Option-returning
+        // The `GetStdHandle` wrapper maps both NULL and
+        // INVALID_HANDLE_VALUE to `None`, so use the Option-returning
         // wrapper here. Without the INVALID_HANDLE_VALUE filter, a detached
         // console (GetStdHandle → INVALID_HANDLE_VALUE) compared against
         // `Fd::INVALID.native()` (= INVALID_HANDLE_VALUE) would spuriously
@@ -1642,9 +1628,7 @@ pub mod fd {
     }
     #[cfg(windows)]
     pub fn windows_current_directory_handle() -> *mut c_void {
-        // Zig spec (`fd.zig:70`): `FD.cwd() = .fromNative(std.fs.cwd().fd)`,
-        // and Zig's `std.fs.cwd()` on Windows reads
-        // `peb().ProcessParameters.CurrentDirectory.Handle`. Offset 0x48 on
+        // Reads `peb().ProcessParameters.CurrentDirectory.Handle`. Offset 0x48 on
         // x64, asserted in `bun_core::windows_sys`. The OS updates this handle
         // on `SetCurrentDirectoryW`, so re-read on every call rather than
         // caching.
@@ -1658,10 +1642,10 @@ pub mod fd {
 }
 
 // ─── FileKind / Mode / kind_from_mode (from bun_sys) ──────────────────────
-// Zig: src/sys/sys.zig — pure S_IFMT arithmetic, no syscalls (libarchive_sys req).
-pub type Mode = u32; // std.posix.mode_t
+// Pure S_IFMT arithmetic, no syscalls (libarchive_sys req).
+pub type Mode = u32; // POSIX `mode_t`
 
-/// `stat` mode-flag constants and predicates (Zig: `std.posix.S`).
+/// `stat` mode-flag constants and predicates.
 ///
 /// Values are POSIX-standard octal — frozen since 1988 and identical across
 /// linux/darwin/freebsd. Typed against the cross-platform `Mode` (= `u32`)
@@ -1821,24 +1805,24 @@ pub mod io {
     }
 
     // ════════════════════════════════════════════════════════════════════════
-    // trait Write — canonical byte-level write sink (port of Zig
-    // `std.Io.Writer`). Lives in `bun_core` (not `bun_io`) so leaf crates
+    // trait Write — canonical byte-level write sink.
+    // Lives in `bun_core` (not `bun_io`) so leaf crates
     // below `bun_io` in the dep graph — `bun_string`, `bun_collections`,
     // `bun_url` — can implement it without an upward dep. `bun_io` re-exports
     // this verbatim as `bun_io::Write`.
     // ════════════════════════════════════════════════════════════════════════
     use core::fmt;
 
-    /// Byte-level write sink — port of Zig `std.Io.Writer`.
+    /// Byte-level write sink.
     ///
     /// Only [`write_all`](Write::write_all) is required; every other method has
     /// a default in terms of it. Object-safe: `&mut dyn Write` works. Generic
     /// helpers that would break object safety carry `where Self: Sized`.
     pub trait Write {
-        /// Write the entire buffer. Zig: `writeAll`.
+        /// Write the entire buffer.
         fn write_all(&mut self, buf: &[u8]) -> Result<(), crate::Error>;
 
-        /// Flush any internal buffer to the underlying sink. Zig: `flush`.
+        /// Flush any internal buffer to the underlying sink.
         /// Unbuffered sinks leave the default no-op.
         #[inline]
         fn flush(&mut self) -> Result<(), crate::Error> {
@@ -1847,8 +1831,7 @@ pub mod io {
 
         /// Total bytes written to this sink so far.
         ///
-        /// Only implemented for in-memory / counting sinks; the default panics,
-        /// matching the Zig `@panic("css: got bad writer type")` fallthrough.
+        /// Only implemented for in-memory / counting sinks; the default panics.
         #[inline]
         fn written_len(&self) -> usize {
             panic!("io::Write::written_len: writer does not track bytes written");
@@ -1856,7 +1839,7 @@ pub mod io {
 
         // ── provided helpers ────────────────────────────────────────────────
 
-        /// Zig: `writeByte`.
+        /// Write a single byte.
         #[inline]
         fn write_byte(&mut self, byte: u8) -> Result<(), crate::Error> {
             self.write_all(core::slice::from_ref(&byte))
@@ -1868,7 +1851,7 @@ pub mod io {
             self.write_all(s.as_bytes())
         }
 
-        /// Write `n` copies of `byte`. Zig: `splatByteAll` / `writeByteNTimes`.
+        /// Write `n` copies of `byte`.
         fn splat_byte_all(&mut self, byte: u8, n: usize) -> Result<(), crate::Error> {
             let chunk = [byte; 256];
             let mut remain = n;
@@ -1880,7 +1863,7 @@ pub mod io {
             Ok(())
         }
 
-        /// Formatted write. Zig: `print(fmt, args)`. Enables `write!(w, ...)`.
+        /// Formatted write. Enables `write!(w, ...)`.
         fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<(), crate::Error> {
             struct Bridge<'a, W: ?Sized> {
                 sink: &'a mut W,
@@ -1908,14 +1891,13 @@ pub mod io {
             }
         }
 
-        /// Alias for [`write_fmt`](Write::write_fmt) under the Zig spelling.
+        /// Alias for [`write_fmt`](Write::write_fmt).
         #[inline]
         fn print(&mut self, args: fmt::Arguments<'_>) -> Result<(), crate::Error> {
             self.write_fmt(args)
         }
 
         /// Write an integer in little-endian byte order.
-        /// Zig: `writeInt(T, val, .little)`.
         #[inline]
         fn write_int_le<I: IntLe>(&mut self, val: I) -> Result<(), crate::Error>
         where
@@ -1970,7 +1952,7 @@ pub mod io {
         }
     }
 
-    /// In-memory growable sink. Zig: `std.Io.Writer.Allocating`.
+    /// In-memory growable sink.
     impl<A: core::alloc::Allocator> Write for Vec<u8, A> {
         #[inline]
         fn write_all(&mut self, buf: &[u8]) -> Result<(), crate::Error> {
@@ -2103,8 +2085,7 @@ impl Version {
 /// (e.g. HTTP-thread-only buffers, main-thread-only CLI state) or externally
 /// synchronized. For anything actually shared across threads, use
 /// `Atomic*` / `OnceLock` / `Mutex` instead — `RacyCell` is the last resort
-/// for scratch buffers and FFI-shaped globals where the Zig already proved
-/// thread-affinity.
+/// for scratch buffers and FFI-shaped globals with proven thread-affinity.
 #[repr(transparent)]
 pub struct RacyCell<T: ?Sized>(core::cell::Cell<T>);
 // SAFETY: by construction, callers promise external synchronization or
@@ -2166,7 +2147,7 @@ impl<T: Default> Default for RacyCell<T> {
 // `locked_at` is `Cell` so `lock()`/`lock_or_assert()` can take `&self`
 // (callers like `RefCount::assert_single_threaded` only have `&self`). The
 // whole point of ThreadLock is asserting single-threaded access, so the
-// unsynchronized write to `locked_at` is exactly the Zig semantics — if two
+// unsynchronized write to `locked_at` is fine — if two
 // threads race here, the `owning_thread.swap` panic fires first.
 pub struct ThreadLock {
     #[cfg(debug_assertions)]
@@ -2196,8 +2177,7 @@ impl ThreadLock {
         s.lock();
         s
     }
-    /// Zig `initLockedIfNonComptime` — Zig comptime evaluation has no thread;
-    /// in Rust there is no comptime execution, so this is just `init_locked`.
+    /// Same as [`Self::init_locked`]; kept under the legacy name.
     #[inline]
     pub fn init_locked_if_non_comptime() -> Self {
         Self::init_locked()
@@ -2212,7 +2192,7 @@ impl ThreadLock {
         self.lock();
         ThreadLockGuard(core::ptr::from_ref::<Self>(self))
     }
-    /// Zig `lockOrAssert` — acquire if unlocked, else assert this thread holds it.
+    /// Acquire if unlocked, else assert this thread holds it.
     #[inline]
     pub fn lock_or_assert(&self) {
         #[cfg(debug_assertions)]
@@ -2258,7 +2238,7 @@ impl ThreadLock {
     pub fn unlock(&self) {
         #[cfg(debug_assertions)]
         {
-            self.assert_locked(); // Zig: assert current thread holds it before reset.
+            self.assert_locked(); // assert current thread holds it before reset.
             self.owning_thread
                 .store(INVALID_THREAD_ID, core::sync::atomic::Ordering::Release);
             // assert_locked above proved we are the unique holder.
@@ -2320,7 +2300,7 @@ fn thread_id() -> u64 {
     crate::thread_id::current() as u64
 }
 
-// ─── StackCheck (from bun.zig) ───────────────────────────────────────────
+// ─── StackCheck ────────────────────────────────────────────────────────────
 // Thin FFI wrapper; configure_thread() is all output.rs needs.
 #[derive(Clone, Copy)]
 pub struct StackCheck {
@@ -2340,7 +2320,7 @@ unsafe extern "C" {
     safe fn clock_gettime(clk_id: libc::clockid_t, tp: &mut libc::timespec) -> core::ffi::c_int;
 }
 impl Default for StackCheck {
-    /// Zig `.{}` — `cached_stack_end` defaults to `0`, so
+    /// `cached_stack_end` defaults to `0`, so
     /// `is_safe_to_recurse()` always reports true until `init`/`update`.
     #[inline]
     fn default() -> Self {
@@ -2365,10 +2345,10 @@ impl StackCheck {
         self.cached_stack_end = Bun__StackCheck__getMaxStack() as usize;
     }
     /// Is there enough stack space to safely recurse?
-    /// Zig: `> 256K` on Windows, `> 128K` elsewhere (bun.zig:3762).
+    /// Threshold: `> 256K` on Windows, `> 128K` elsewhere.
     #[inline]
     pub fn is_safe_to_recurse(self) -> bool {
-        // Zig uses `-|` (saturating sub): if probe < end (already past limit),
+        // Saturating sub: if probe < end (already past limit),
         // result saturates to 0 → "not safe". wrapping_sub would yield a huge
         // positive and incorrectly return true.
         let remaining = Self::frame_address().saturating_sub(self.cached_stack_end);
@@ -2402,8 +2382,8 @@ impl StackCheck {
     /// use-after-return detection is on, which makes the comparison against
     /// `cached_stack_end` useless.
     ///
-    /// Zig uses `@frameAddress()` (rbp/x29), but Zig builds always keep frame
-    /// pointers. Rust release builds omit them, leaving rbp/x29 as a
+    /// Reading the frame pointer (rbp/x29) would not work either:
+    /// Rust release builds omit frame pointers, leaving rbp/x29 as a
     /// general-purpose register with arbitrary contents — reading it there
     /// makes `is_safe_to_recurse()` spuriously fail at depth 0. The stack
     /// pointer is always valid and is what we actually want to measure.
@@ -2436,15 +2416,14 @@ impl StackCheck {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Small helpers from src/bun.zig that downstream crates need.
+// Small helpers that downstream crates need.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig `bun.Generation` (bun.zig:1926) — bumped each rebuild/rescan to
-/// invalidate stale cache entries.
+/// Bumped each rebuild/rescan to invalidate stale cache entries.
 pub type Generation = u16;
 
 // ── Ordinal ───────────────────────────────────────────────────────────────
-// Port of `OrdinalT(c_int)` (bun.zig:3421). ABI-equivalent of WTF::OrdinalNumber:
+// ABI-equivalent of WTF::OrdinalNumber:
 // a zero-based index where -1 means "invalid". Represented as a transparent
 // newtype rather than a Rust enum so the full `c_int` range round-trips across
 // FFI without UB.
@@ -2497,8 +2476,7 @@ impl Default for Ordinal {
 }
 
 // ── Once ──────────────────────────────────────────────────────────────────
-// Port of `bun.Once(f)` (bun.zig:3637). Zig parameterizes over a comptime fn
-// and stores the payload; Rust callers use two shapes:
+// One-shot initialization cell. Callers use two shapes:
 //   * `Once<T>` — fn supplied at `.call(f)` / `.get_or_init(f)` time
 //   * `Once<T, fn(A) -> T>` — fn supplied at construction (PackageManagerDirectories.rs)
 //
@@ -2507,15 +2485,13 @@ impl Default for Ordinal {
 // `OnceLock::initialize` + 30 `LazyLock` monomorphizations (~36.7 KB) whose
 // shared callee `std::sys::sync::once::futex::Once::call` lives in libstd's
 // own CGU — every hot-path `get_or_init` paid a cross-CGU call + futex-aware
-// state machine even when the value was already initialised. The Zig original
-// is a plain `bool` flag + payload; this matches it: post-init reads are one
-// Acquire load + cmp inlined into the caller. Pattern proven at
+// state machine even when the value was already initialised. Here post-init
+// reads are one Acquire load + cmp inlined into the caller. Pattern proven at
 // `bun_alloc/lib.rs::bss_heap_init`'s accessor macro.
 //
 // Contention: startup is single-threaded for every current call site; the
 // rare cross-thread race spins on `yield_now()` (no futex). No poisoning —
-// a panic mid-init resets to UNINIT so the next call retries (Zig has no
-// poisoning either).
+// a panic mid-init resets to UNINIT so the next call retries.
 const ONCE_UNINIT: u8 = 0;
 const ONCE_BUSY: u8 = 1;
 const ONCE_DONE: u8 = 2;
@@ -2600,7 +2576,7 @@ impl<T, F> Once<T, F> {
     fn init_slow(&self, f: impl FnOnce() -> T) -> &T {
         if once_claim_slow(&self.state) {
             // Reset to UNINIT if `f` unwinds so a later retry isn't deadlocked
-            // on a permanently-BUSY slot (Zig has no poisoning; neither do we).
+            // on a permanently-BUSY slot (no poisoning).
             struct Reset<'a>(&'a core::sync::atomic::AtomicU8);
             impl Drop for Reset<'_> {
                 #[inline]
@@ -2712,7 +2688,6 @@ macro_rules! run_once {
 }
 
 // ── Pollable / is_readable / is_writable ──────────────────────────────────
-// Port of `bun.PollFlag` + `bun.isReadable` / `bun.isWritable` (bun.zig:637).
 // Named `Pollable` to match the original draft callers (io/PipeReader.rs).
 // D050 dedup: this is the single canonical copy; `bun::`/`bun_sys::` re-export.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -2721,11 +2696,11 @@ pub enum Pollable {
     NotReady,
     Hup,
 }
-/// Zig `bun.PollFlag` — original name kept as an alias.
+/// Alias for [`Pollable`].
 pub type PollFlag = Pollable;
 
 impl Pollable {
-    /// Zig `@tagName(rc)` — lowercase tag name for the `[sys]` debug log.
+    /// Lowercase tag name for the `[sys]` debug log.
     #[inline]
     pub const fn tag_name(self) -> &'static str {
         match self {
@@ -2736,12 +2711,11 @@ impl Pollable {
     }
 }
 
-// Zig `global_scope_log = sys.syslog` (bun.zig:636) → `Output.scoped(.SYS, .visible)`.
 // bun_core sits below bun_sys, so we re-declare the scope locally instead of
 // pulling `bun_sys::syslog!` (tier inversion). Same `[sys]` tag at runtime.
 crate::declare_scope!(SYS, visible);
 
-/// Non-blocking poll for readability. POSIX-only (Zig panics on Windows).
+/// Non-blocking poll for readability. POSIX-only.
 #[cfg(not(windows))]
 pub fn is_readable(fd: Fd) -> Pollable {
     debug_assert!(fd.is_valid());
@@ -2776,7 +2750,7 @@ pub fn is_readable(fd: Fd) -> Pollable {
 }
 #[cfg(windows)]
 pub fn is_readable(_fd: Fd) -> Pollable {
-    // Zig bun.zig:639 — `@panic("TODO on Windows")`; no callers reach this on Windows.
+    // No callers reach this on Windows.
     panic!("TODO on Windows");
 }
 
@@ -2784,7 +2758,6 @@ pub fn is_readable(_fd: Fd) -> Pollable {
 #[cfg(not(windows))]
 pub fn is_writable(fd: Fd) -> Pollable {
     debug_assert!(fd.is_valid());
-    // bun.zig:692 — POLLOUT | POLLERR | POLLHUP.
     let mut polls = [libc::pollfd {
         fd: fd.native(),
         events: libc::POLLOUT | libc::POLLERR | libc::POLLHUP,
@@ -2816,11 +2789,11 @@ pub fn is_writable(fd: Fd) -> Pollable {
 }
 #[cfg(windows)]
 pub fn is_writable(fd: Fd) -> Pollable {
-    // Zig bun.zig:668-685 — WSAPoll(POLLWRNORM). bun_core can't depend on
+    // bun_core can't depend on
     // bun_sys (tier inversion), so go to bun_windows_sys::ws2_32 directly.
     use bun_windows_sys::ws2_32;
     let mut polls = [ws2_32::WSAPOLLFD {
-        // HANDLE → SOCKET pointer reinterpretation; matches Zig `fd.asSocketFd()`.
+        // HANDLE → SOCKET pointer reinterpretation.
         fd: fd.native() as usize,
         events: ws2_32::POLLWRNORM,
         revents: 0,
@@ -2835,8 +2808,7 @@ pub fn is_writable(fd: Fd) -> Pollable {
         result,
         polls[0].revents
     );
-    // PORT NOTE: faithful port of bun.zig:679 — yes, the `WRNORM`-set branch
-    // returns `.hup` (not `.ready`). Kept verbatim to match upstream behaviour.
+    // Yes, the `WRNORM`-set branch returns `.hup` (not `.ready`); intentional.
     if result && (polls[0].revents & ws2_32::POLLWRNORM) != 0 {
         Pollable::Hup
     } else if result {
@@ -2847,11 +2819,11 @@ pub fn is_writable(fd: Fd) -> Pollable {
 }
 
 // ── csprng ────────────────────────────────────────────────────────────────
-// Zig calls `BoringSSL.c.RAND_bytes` (bun.zig:621). bun_core sits below
+// bun_core sits below
 // boringssl_sys in the crate graph, so we go to the OS CSPRNG directly:
 // getrandom(2) on Linux, SecRandomCopyBytes/getentropy on Darwin,
 // RtlGenRandom on Windows. All are the same entropy source BoringSSL seeds
-// from. PERF(port): if a hot path needs the BoringSSL DRBG, install a
+// from. PERF: if a hot path needs the BoringSSL DRBG, install a
 // vtable hook from bun_runtime at startup.
 pub fn csprng(bytes: &mut [u8]) {
     #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -2905,20 +2877,20 @@ pub fn csprng(bytes: &mut [u8]) {
 }
 
 // ── self_exe_path ─────────────────────────────────────────────────────────
-// Port of `bun.selfExePath` (bun.zig:3011). Memoized into a process-lifetime
+// Memoized into a process-lifetime
 // static buffer; thread-safe via `Once`. Returns a `&'static ZStr`.
 pub fn self_exe_path() -> Result<&'static ZStr, crate::Error> {
     static CELL: Once<Result<ZBox, crate::Error>> = Once::new();
     let r = CELL.get_or_init(|| {
         let path = std::env::current_exe().map_err(crate::Error::from)?;
-        // PORT NOTE: Zig's `std.fs.selfExePath` resolves symlinks. Rust's
-        // `current_exe()` already does on Linux (`readlink /proc/self/exe`),
+        // Symlink resolution: Rust's
+        // `current_exe()` already resolves on Linux (`readlink /proc/self/exe`),
         // but on Darwin it returns the raw `_NSGetExecutablePath` result and on
         // Windows it returns the raw `GetModuleFileNameW` result — neither
         // realpaths, so a symlinked argv0 (Darwin) or an un-normalized
         // `C:\a\.\b\bun.exe` load path (Windows) leaks through to
-        // `process.execPath` / `process.argv[0]`. Zig's Windows impl calls
-        // `realpathW` (GetFinalPathNameByHandle); match that here so parent and
+        // `process.execPath` / `process.argv[0]`. Realpath
+        // (GetFinalPathNameByHandle on Windows) here so parent and
         // child agree on argv[0] regardless of how the binary was invoked
         // (test/js/node/process/process-args.test.js,
         //  test/js/node/test/parallel/test-process-execpath.js).
@@ -2931,17 +2903,16 @@ pub fn self_exe_path() -> Result<&'static ZStr, crate::Error> {
         }
         #[cfg(windows)]
         {
-            // PORT NOTE: Zig stored the WTF-8 form. `into_string()` rejects unpaired
+            // Store the WTF-8 form. `into_string()` rejects unpaired
             // surrogates; fall back to the lossy form (Windows exe paths are valid
             // Unicode in practice).
             let mut s = path
                 .into_os_string()
                 .into_string()
                 .unwrap_or_else(|os| os.to_string_lossy().into_owned());
-            // `canonicalize()` on Windows returns a verbatim `\\?\` path; Zig's
-            // `realpathW` strips that back to a plain DOS path before WTF-8
-            // encoding, so do the same (Node's `process.execPath` is never
-            // verbatim-prefixed).
+            // `canonicalize()` on Windows returns a verbatim `\\?\` path; strip
+            // that back to a plain DOS path before WTF-8 encoding (Node's
+            // `process.execPath` is never verbatim-prefixed).
             if let Some(rest) = s.strip_prefix(r"\\?\UNC\") {
                 s = format!(r"\\{}", rest);
             } else if let Some(rest) = s.strip_prefix(r"\\?\") {
@@ -2957,7 +2928,7 @@ pub fn self_exe_path() -> Result<&'static ZStr, crate::Error> {
 }
 
 // ── get_thread_count ──────────────────────────────────────────────────────
-// Port of `bun.getThreadCount` (bun.zig:3597). Clamped to [2, 1024]; honours
+// Clamped to [2, 1024]; honours
 // UV_THREADPOOL_SIZE / GOMAXPROCS overrides.
 pub fn get_thread_count() -> u16 {
     static CELL: Once<u16> = Once::new();
@@ -2978,7 +2949,7 @@ pub fn get_thread_count() -> u16 {
                 }
                 // Windows: `getenv_z` is currently a no-op (no narrow C
                 // environ to borrow from); honour the override via
-                // `std::env::var` so behaviour matches Zig `bun.getThreadCount`
+                // `std::env::var` so behaviour matches
                 // on all platforms. POSIX keeps the borrow path above.
                 #[cfg(windows)]
                 if let Ok(s) = std::env::var(
@@ -2995,14 +2966,13 @@ pub fn get_thread_count() -> u16 {
             None
         };
         let raw = from_env().unwrap_or_else(|| {
-            // Zig (bun.zig:3621) calls `jsc.wtf.numberOfProcessorCores()` —
             // `WTF::numberOfProcessorCores()` → sysconf(_SC_NPROCESSORS_ONLN)
             // on POSIX / GetSystemInfo on Windows. **Not** the same as
             // `std::thread::available_parallelism()`, which on Linux also
             // consults sched_getaffinity + cgroup cpu.max quota; on
             // cgroup-limited CI runners or P/E-core machines the two diverge,
             // changing bundler `max_threads` (and per-thread mimalloc arena
-            // RSS) vs the Zig binary. Declare the C symbol locally — `jsc`
+            // RSS). Declare the C symbol locally — `jsc`
             // is above `bun_core` in the crate DAG so we can't `use` it, but
             // the symbol is always linked (wtf-bindings.cpp).
             unsafe extern "C" {
@@ -3015,9 +2985,8 @@ pub fn get_thread_count() -> u16 {
 }
 
 // ── errno_to_zig_err ──────────────────────────────────────────────────────
-// Port of `bun.errnoToZigErr` (bun.zig:2854). Zig indexes into a comptime
-// `errno_map: [N]anyerror`; the Rust intern table reproduces that mapping in
-// `Error::from_errno` (errno → tag name → interned code).
+// The intern table maps in `Error::from_errno`
+// (errno → tag name → interned code).
 #[inline]
 pub fn errno_to_zig_err(errno: i32) -> crate::Error {
     debug_assert!(errno != 0);
@@ -3025,9 +2994,7 @@ pub fn errno_to_zig_err(errno: i32) -> crate::Error {
 }
 
 // ── time ──────────────────────────────────────────────────────────────────
-// Port of `std.time` (vendor/zig/lib/std/time.zig:80-107) — the full
-// `comptime_int` constant ladder plus `{nano,milli,}timestamp()`. Zig's
-// `comptime_int` coerces to any numeric type; Rust callers `as`-cast at the
+// Time-unit constants plus `{nano,milli,}timestamp()`. Callers `as`-cast at the
 // use-site (`NS_PER_S as i128`, `MS_PER_S as f64`, …). Every value fits in
 // `u64` (and the ≤per-second constants in `i32`), so all such casts —
 // including to `f64` — are lossless.
@@ -3049,7 +3016,7 @@ pub mod time {
     // s
     pub const S_PER_DAY: u32 = 86_400;
 
-    /// `std.time.nanoTimestamp()` — wall-clock nanoseconds since the Unix epoch.
+    /// Wall-clock nanoseconds since the Unix epoch.
     #[inline]
     pub fn nano_timestamp() -> i128 {
         #[cfg(unix)]
@@ -3070,18 +3037,18 @@ pub mod time {
             }
         }
     }
-    /// `std.time.milliTimestamp()`
+    /// Wall-clock milliseconds since the Unix epoch.
     #[inline]
     pub fn milli_timestamp() -> i64 {
         (nano_timestamp() / NS_PER_MS as i128) as i64
     }
-    /// `std.time.timestamp()` — wall-clock seconds since the Unix epoch.
+    /// Wall-clock seconds since the Unix epoch.
     #[inline]
     pub fn timestamp() -> i64 {
         (nano_timestamp() / NS_PER_S as i128) as i64
     }
 
-    /// `std.time.Timer` — monotonic stopwatch.
+    /// Monotonic stopwatch.
     #[derive(Clone, Copy, Debug)]
     pub struct Timer {
         start: std::time::Instant,
@@ -3112,14 +3079,13 @@ pub mod time {
 }
 
 // ── runtime_embed_file ────────────────────────────────────────────────────
-// Port of `bun.runtimeEmbedFile` (bun.zig:2938). The Zig version comptime-
-// captures `sub_path` to manufacture a per-call-site `static once` cache; Rust
-// can't do that from a plain fn without leaking, so the canonical port is the
+// A per-call-site `static once` cache cannot be manufactured
+// from a plain fn without leaking, so the canonical form is the
 // `runtime_embed_file!` macro below (per-site `OnceLock<String>` — sanctioned
 // by PORTING.md §Forbidden, "true process-lifetime singleton"). The fn form is
 // kept so existing draft callers type-check; it's only reachable when the
-// `codegen_embed` feature is off (debug fast-iteration), where panicking with a
-// migration hint is the same UX as the Zig `Output.panic` on read failure.
+// `codegen_embed` feature is off (debug fast-iteration), where it panics with
+// a migration hint.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum EmbedKind {
     Codegen,
@@ -3160,8 +3126,8 @@ pub fn __runtime_embed_load(kind: EmbedKind, sub: &'static str) -> String {
     })
 }
 
-/// Per-call-site embedded file. `($root, $sub_path)` mirrors the Zig
-/// signature; `$root` must be one of the bare idents `Codegen` /
+/// Per-call-site embedded file.
+/// `$root` must be one of the bare idents `Codegen` /
 /// `CodegenEager` / `Src` / `SrcEager` and `$sub_path` a string literal.
 ///
 /// The `cfg(bun_codegen_embed)` split lives **inside** the macro so call
@@ -3223,12 +3189,11 @@ macro_rules! __runtime_embed_impl {
 }
 
 // ── StringBuilder ─────────────────────────────────────────────────────────
-// Port of src/string/StringBuilder.zig. Count-then-allocate-then-append arena
+// Count-then-allocate-then-append arena
 // for building a single contiguous buffer. Allocator param dropped per
 // PORTING.md §Allocators (always `bun.default_allocator`).
 //
-// PORT NOTE: returned sub-slices borrow `*self`, but in Zig they alias the
-// final `allocated_slice()` and outlive the builder. To keep that pattern
+// Returned sub-slices borrow `*self`. To let spans outlive the builder
 // without self-referential lifetimes, callers stash `(offset, len)` via
 // `StringPointer` (see install/hosted_git_info.rs).
 //
@@ -3286,9 +3251,9 @@ impl<const N: usize> PartialEq<&[u8; N]> for ZStr {
     }
 }
 
-// ── Hasher trait (Zig "anytype with .update([]const u8)") ─────────────────
-// Used by `bun_core::write_any_to_hasher` and bundler/css hashing. Mirrors
-// the minimal Zig hasher protocol — *not* `core::hash::Hasher` because Bun's
+// ── Hasher trait ───────────────────────────────────────────────────────────
+// Used by `bun_core::write_any_to_hasher` and bundler/css hashing.
+// *Not* `core::hash::Hasher` because Bun's
 // hashers (Wyhash, XxHash64, sha1) expose `.update(&[u8])` + `.final()`.
 pub trait Hasher {
     fn update(&mut self, bytes: &[u8]);
@@ -3306,8 +3271,7 @@ impl<H: core::hash::Hasher> Hasher for H {
 /// direct `bytemuck` dep.
 pub use bytemuck::NoUninit;
 
-/// Port of Zig `std.mem.asBytes(&v)`: reinterpret a value's storage as a
-/// borrowed byte slice.
+/// Reinterpret a value's storage as a borrowed byte slice.
 ///
 /// Safe: the [`bytemuck::NoUninit`] bound statically guarantees `T` is `Copy`,
 /// `'static`, and contains no uninitialized (padding) bytes, so every byte of
@@ -3328,20 +3292,16 @@ pub fn bytes_of_mut<T: bytemuck::Pod>(v: &mut T) -> &mut [u8] {
 }
 
 // ─── Slice reinterpretation (canonical) ───────────────────────────────────────
-// Port of Zig `bun.reinterpretSlice` / `std.mem.bytesAsSlice` / `sliceAsBytes`.
-// Zig has ONE polymorphic `reinterpretSlice(comptime T, slice: anytype)` that
-// handles const+mut via comptime; Rust splits by mutability and offers two
-// safety surfaces:
+// Split by mutability, with two safety surfaces:
 //   - `cast_slice` / `cast_slice_mut`  → SAFE, bytemuck-bounded, panics on
 //     misalign or `len % size_of::<B>() != 0`. Use for Pod↔Pod (u8↔u16 etc.).
 //   - `bytes_as_slice_mut`             → UNSAFE escape hatch, unbounded `T`,
-//     TRUNCATES trailing bytes (Zig `@divTrunc`). Use only when `T` is not
+//     TRUNCATES trailing bytes. Use only when `T` is not
 //     `AnyBitPattern` or the input length is intentionally not a multiple.
 // Every current caller targets `u16` over an even-length buffer, so the safe
 // path is the default.
 
-/// Port of Zig `std.mem.sliceAsBytes` / `bun.reinterpretSlice` for the
-/// read-only `&[A]` → `&[B]` direction. Safe: the [`bytemuck::NoUninit`] bound
+/// Read-only `&[A]` → `&[B]` reinterpretation. Safe: the [`bytemuck::NoUninit`] bound
 /// on `A` guarantees every source byte is initialized, and
 /// [`bytemuck::AnyBitPattern`] on `B` guarantees every byte pattern is a valid
 /// `B`. Panics if size/alignment don't divide evenly (same as `bytemuck`).
@@ -3359,7 +3319,7 @@ pub fn cast_slice_mut<A: bytemuck::Pod, B: bytemuck::Pod>(a: &mut [A]) -> &mut [
     bytemuck::cast_slice_mut(a)
 }
 
-/// Port of Zig `std.mem.sliceAsBytes`: reinterpret `&[T]` as `&[u8]`.
+/// Reinterpret `&[T]` as `&[u8]`.
 ///
 /// This is [`cast_slice`] with the output type fixed to `u8`, so callers never
 /// need a `::<_, u8>` turbofish. Safe: [`bytemuck::NoUninit`] guarantees every
@@ -3372,9 +3332,8 @@ pub fn slice_as_bytes<T: bytemuck::NoUninit>(s: &[T]) -> &[u8] {
 }
 
 // ─── extern_union_accessors! ──────────────────────────────────────────────────
-// Zig accesses bare-union fields inline (`this.value.npm`) with no ceremony; the
-// Rust port wraps each read in a tag-asserted `unsafe` accessor so call sites
-// stay safe. Four crates hand-rolled the same accessor shape (Resolution, Bin,
+// Wraps each bare-union field read in a tag-asserted `unsafe` accessor so call
+// sites stay safe. Four crates hand-rolled the same accessor shape (Resolution, Bin,
 // DependencyVersion, PackageManager Task) — this macro is the single definition.
 //
 // Emits, per arm, `pub fn $field(&self) -> &$Ty` and optionally
@@ -3460,8 +3419,8 @@ macro_rules! extern_union_accessors {
     };
 }
 
-/// Port of `bun.writeAnyToHasher`. Zig fed `std.mem.asBytes(&thing)`; Rust
-/// can't take a generic by-value-as-bytes safely without `bytemuck`, so this
+/// Feed a value's raw bytes to a hasher. Taking a generic by-value-as-bytes
+/// safely requires a `bytemuck` bound, so this
 /// accepts anything that is itself viewable as bytes (covers the actual call
 /// sites: `u8` tags, `usize` lengths, `Index` newtypes).
 #[inline]
@@ -3494,9 +3453,9 @@ impl<T: AsBytes> AsBytes for &T {
 }
 
 // ── GenericIndex ──────────────────────────────────────────────────────────
-// Port of `bun.GenericIndex(backing_int, uid)` (bun.zig:3513). Zig used a
-// distinct enum-per-uid for nominal typing; Rust gets that via a phantom
-// marker. `MAX` is reserved as the "none" sentinel for `Optional`.
+// Nominally-typed index newtype; the phantom
+// marker keeps indexes for different containers distinct.
+// `MAX` is reserved as the "none" sentinel for `Optional`.
 //
 // NOTE on const-ness: hand-rolled monomorphic sites used `const fn init/get`.
 // The generic impl cannot be `const fn` on stable (trait-bound `I::NULL_VALUE`
@@ -3569,7 +3528,7 @@ impl<I: GenericIndexInt, M> GenericIndex<I, M> {
         I::to_usize(self.get())
     }
     /// `init()` from a `usize` source (Vec length etc.). Debug-panics on
-    /// truncation, mirroring Zig `@intCast`.
+    /// truncation.
     #[inline]
     pub fn from_usize(n: usize) -> Self {
         Self::init(I::from_usize(n))
@@ -3653,7 +3612,7 @@ impl<I: GenericIndexInt, M> GenericIndexOptional<I, M> {
     }
 }
 
-/// Backing-integer bound for `GenericIndex` (replaces Zig's `comptime backing_int: type`).
+/// Backing-integer bound for `GenericIndex`.
 pub trait GenericIndexInt: Copy + Eq + PartialOrd {
     const NULL_VALUE: Self;
     fn to_usize(self) -> usize;
@@ -3671,9 +3630,9 @@ macro_rules! generic_index_int { ($($t:ty),*) => { $(
 )* } }
 generic_index_int!(u8, u16, u32, u64, usize, i32, i64);
 
-/// Generic-integer bound replacing Zig's `comptime T: type` + `@typeInfo(T).Int`
-/// in `validateIntegerRange` / `validateBigIntRange` / `getInteger`
-/// (src/jsc/JSGlobalObject.zig). Provides the small surface those callers need:
+/// Generic-integer bound used by `validateIntegerRange` /
+/// `validateBigIntRange` / `getInteger`
+/// (JSGlobalObject). Provides the small surface those callers need:
 /// signedness, range as `i128`, and lossy/wrapping casts from the JSC numeric
 /// carriers (i32 / f64 / i64 / u64).
 pub trait Integer: Copy + Default {
@@ -3709,9 +3668,8 @@ impl_integer!(
 
 /// Primitive integers transcodable as native-endian raw bytes.
 ///
-/// Replaces Zig's `comptime T: type` + `std.mem.readIntSliceNative` /
-/// `std.mem.asBytes` / `@bitCast` reflection pattern with an explicit trait
-/// bound. Shared by the peechy wire codec (`bun_analytics::SchemaInt`) and the
+/// Explicit trait
+/// bound shared by the peechy wire codec (`bun_analytics::SchemaInt`) and the
 /// MySQL protocol reader (`bun_sql::ReadableInt`), which re-export this under
 /// their local names.
 pub trait NativeEndianInt: Copy + 'static {
@@ -3742,23 +3700,22 @@ macro_rules! impl_native_endian_int {
 impl_native_endian_int!(u8, i8, u16, i16, u32, i32, u64, i64);
 
 // ── mach_port ─────────────────────────────────────────────────────────────
-// Zig: `if (Environment.isMac) std.c.mach_port_t else u32`.
 #[cfg(target_os = "macos")]
 pub type mach_port = libc::mach_port_t;
 #[cfg(not(target_os = "macos"))]
 pub type mach_port = u32;
 
 // ── rand ──────────────────────────────────────────────────────────────────
-// `std.Random.DefaultPrng` is xoshiro256++ in Zig stdlib. Port the exact
-// algorithm so `bun.fastRandom()` output is reproducible across the rewrite.
+// xoshiro256++; the exact algorithm keeps `bun.fastRandom()` output
+// reproducible.
 pub mod rand {
-    /// xoshiro256++ — `std.Random.DefaultPrng`.
+    /// xoshiro256++ pseudo-random number generator.
     #[derive(Clone, Copy)]
     pub struct DefaultPrng {
         s: [u64; 4],
     }
     impl DefaultPrng {
-        /// Seed via splitmix64 (matches Zig stdlib `Xoshiro256.init`).
+        /// Seed via splitmix64.
         pub fn init(seed: u64) -> Self {
             let mut sm = seed;
             let mut s = [0u64; 4];
@@ -3798,8 +3755,8 @@ pub fn fast_random() -> u64 {
     fn random_seed() -> u64 {
         let mut v = SEED.load(O::Relaxed);
         while v == 0 {
-            // Spec (bun.zig:575) gates on `Environment.isDebug or Environment.is_canary`;
-            // bun_core has no `canary` cargo feature yet, so debug-only for now (no
+            // Should also apply to canary builds, but bun_core has no `canary`
+            // cargo feature yet, so debug-only for now (no
             // regression vs. either pre-dedup copy — tracked separately).
             #[cfg(debug_assertions)]
             if let Some(n) = crate::env_var::BUN_DEBUG_HASH_RANDOM_SEED.get() {
@@ -3832,12 +3789,12 @@ pub fn fast_random() -> u64 {
 // the xxhash64 entry point that ETag/bundler need.
 pub mod hash {
     pub use bun_hash::XxHash64;
-    /// `std.hash.XxHash64.hash(seed, bytes)`.
+    /// One-shot seeded XXH64 over `bytes`.
     #[inline]
     pub fn xxhash64(seed: u64, bytes: &[u8]) -> u64 {
         bun_hash::XxHash64::hash(seed, bytes)
     }
-    /// Wyhash one-shot (Zig `bun.hash`).
+    /// Wyhash one-shot (`bun.hash`).
     #[inline]
     pub fn wyhash(bytes: &[u8]) -> u64 {
         crate::deprecated::RapidHash::hash(0, bytes)
@@ -3845,8 +3802,8 @@ pub mod hash {
 }
 
 // ── base64 ────────────────────────────────────────────────────────────────
-// Thin simdutf-backed encoders + scalar decoder. Port of the subset of
-// `src/base64/base64.zig` that tier-0/1 callers need (npm auth, sourcemaps,
+// Thin simdutf-backed encoders + scalar decoder — the subset
+// tier-0/1 callers need (npm auth, sourcemaps,
 // ansi_renderer). Full URL-safe / streaming variants stay in bun_base64.
 pub mod base64 {
     use bun_simdutf_sys::simdutf;
@@ -3865,13 +3822,13 @@ pub mod base64 {
         simdutf::base64::encode(source, dest, false)
     }
 
-    /// `std.base64.standard.Encoder.calcSize` — alias of `encode_len` taking a length.
+    /// Encoded output size for a standard-base64 input of `source_len` bytes.
     #[inline]
     pub const fn standard_encoder_calc_size(source_len: usize) -> usize {
         source_len.div_ceil(3) * 4
     }
 
-    /// `std.base64.standard.Encoder.encode` returning the written sub-slice.
+    /// Standard-base64 encode, returning the written sub-slice of `dest`.
     pub fn standard_encode<'a>(dest: &'a mut [u8], source: &[u8]) -> &'a [u8] {
         let n = encode(dest, source);
         &dest[..n]
@@ -3884,7 +3841,7 @@ pub mod base64 {
         pub fail: bool,
     }
 
-    /// `bun.base64.decode`. Scalar fallback (PERF(port): simdutf path in
+    /// Scalar fallback base64 decode (the SIMD path lives in
     /// bun_base64). Tolerates missing padding; stops at first invalid char.
     pub fn decode(dest: &mut [u8], source: &[u8]) -> DecodeResult {
         const INV: u8 = 0xFF;
@@ -3971,15 +3928,15 @@ pub fn dupe_z(bytes: &[u8]) -> *const core::ffi::c_char {
 /// case used by http SSLConfig — re-exported from `bun_alloc` so the
 /// secure-zero core stays single-sourced. Pairs with [`dupe_z`].
 pub use bun_alloc::free_sensitive_cstr as free_sensitive;
-/// Port of `std.crypto.secureZero` — re-exported from `bun_alloc`.
+/// Optimization-resistant memory zeroing — re-exported from `bun_alloc`.
 pub use bun_alloc::secure_zero;
 
 // ── argv ──────────────────────────────────────────────────────────────────
 // `bun.argv` — process argv as a slice of NUL-terminated byte strings.
-// Zig: `pub var argv: [][:0]const u8`. The owned `ZBox` backing for the
+// The owned `ZBox` backing for the
 // initial OS argv lives in `ARGV_STORAGE`; `ARGV` is the mutable *view*
 // slice that call sites read (and that `set_argv` swaps for the
-// `--compile` exec-argv splicing path in `cli.zig`). Exposed via a tiny
+// `--compile` exec-argv splicing path). Exposed via a tiny
 // `Argv` wrapper so call sites can use it both as a slice (`.get(0)`,
 // `.iter()`, `.len()`, `.as_slice()`) and as an `IntoIterator<Item = &[u8]>`
 // for `for arg in argv()`.
@@ -3995,8 +3952,7 @@ static ARGV_INIT: std::sync::Once = std::sync::Once::new();
 /// this; on **musl-static** the `.init_array` constructor is invoked with no
 /// arguments (musl's `__libc_start_main` does not forward `(argc,argv,envp)`
 /// to constructors), so `std::env::args_os()` returns empty and we must read
-/// the kernel-provided block ourselves. Zig's `_start` writes `std.os.argv`
-/// directly from the stack — this is the equivalent for a clang-linked
+/// the kernel-provided block ourselves from a clang-linked
 /// `extern "C" fn main`.
 static OS_ARGC: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
 static OS_ARGV: core::sync::atomic::AtomicPtr<*const core::ffi::c_char> =
@@ -4006,9 +3962,6 @@ static OS_ARGV: core::sync::atomic::AtomicPtr<*const core::ffi::c_char> =
 /// the very first call in `main`, before the crash handler (whose panic path
 /// dumps the command line) or anything else that might call [`argv()`].
 ///
-/// Matches Zig `bun.initArgv` which on POSIX wraps `std.os.argv` (set by
-/// Zig's own `_start` from the kernel-provided argv block).
-///
 /// # Safety
 /// `argv` must point to `argc` valid NUL-terminated C strings that live for
 /// the entire process (the kernel/crt argv block does). Calling this after
@@ -4038,9 +3991,9 @@ fn argv_storage() -> &'static [ZBox] {
         // Windows: the CRT-provided `char** argv` captured by `init_argv` is
         // ANSI-encoded (CP_ACP) — `WideCharToMultiByte` lossy-converts the
         // UTF-16 command line, replacing unrepresentable code points with `?`.
-        // Zig's `initArgv` (bun.zig) goes straight to `GetCommandLineW` +
-        // `CommandLineToArgvW` and converts each UTF-16 arg to WTF-8 itself;
-        // do the same here so non-ASCII argv (e.g. `bun -e "🌊 测试"`)
+        // Go straight to `GetCommandLineW` +
+        // `CommandLineToArgvW` and convert each UTF-16 arg to WTF-8 ourselves
+        // so non-ASCII argv (e.g. `bun -e "🌊 测试"`)
         // round-trips. See https://github.com/oven-sh/bun/issues/11610.
         #[cfg(windows)]
         {
@@ -4048,7 +4001,7 @@ fn argv_storage() -> &'static [ZBox] {
             let mut argc: core::ffi::c_int = 0;
             // SAFETY: `GetCommandLineW` returns a process-static buffer;
             // `CommandLineToArgvW` allocates its own array (lifetime managed
-            // by the system per Zig spec — intentionally not `LocalFree`d, the
+            // by the system — intentionally not `LocalFree`d, the
             // argv strings are referenced for the process lifetime).
             let argvw = unsafe { CommandLineToArgvW(GetCommandLineW(), &mut argc) };
             if !argvw.is_null() {
@@ -4066,7 +4019,7 @@ fn argv_storage() -> &'static [ZBox] {
                     .collect();
             }
             // Fall through to `args_os` if `CommandLineToArgvW` failed (OOM /
-            // INVAL) — Zig returns an error there; we degrade to libstd's
+            // INVAL) — degrade to libstd's
             // own `GetCommandLineW`-backed parser instead of aborting.
         }
         #[cfg(not(windows))]
@@ -4097,7 +4050,7 @@ fn argv_view_init() {
     let storage: &'static [ZBox] = argv_storage();
     // ARGV_STORAGE is process-static via `Once`; `as_zstr` borrows for `'static`.
     let mut view: Vec<&'static ZStr> = storage.iter().map(ZBox::as_zstr).collect();
-    // Zig `initArgv`: splice BUN_OPTIONS tokens after argv[0].
+    // Splice BUN_OPTIONS tokens after argv[0].
     if let Some(opts) = crate::env_var::BUN_OPTIONS.get() {
         let original_len = view.len();
         append_options_env::<&'static ZStr>(opts, &mut view);
@@ -4138,7 +4091,7 @@ impl Argv {
             i: 0,
         }
     }
-    /// Borrow the underlying `[&ZStr]` view (Zig: `bun.argv[..]`).
+    /// Borrow the underlying `[&ZStr]` view.
     #[inline]
     pub fn as_slice(&self) -> &'static [&'static ZStr] {
         self.0
@@ -4178,16 +4131,14 @@ pub fn argv() -> Argv {
     Argv(argv_view())
 }
 
-// ─── BUN_OPTIONS argv injection (bun.zig: bun_options_argc / appendOptionsEnv) ──
+// ─── BUN_OPTIONS argv injection ──────────────────────────────────────────────
 /// Number of arguments injected into `argv` by the `BUN_OPTIONS` environment
 /// variable. Set once during single-threaded startup (`init_argv`).
 static BUN_OPTIONS_ARGC: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
 
-/// Zig: `bun.bun_options_argc` — read accessor.
+/// Read accessor for the injected-arg count.
 ///
-/// Forces the lazy `argv_view()` init before reading: in Zig `initArgv()`
-/// runs eagerly in `main()` so `bun.bun_options_argc` is always populated by
-/// the time `cli.zig` reads it; here `argv()` is lazy, so a caller that reads
+/// Forces the lazy `argv_view()` init before reading: `argv()` is lazy, so a caller that reads
 /// `bun_options_argc()` *before* `argv()` (e.g. the standalone-executable
 /// path in `Command::start`) would otherwise see 0 and miscount the
 /// BUN_OPTIONS-injected args when computing the passthrough offset.
@@ -4196,23 +4147,23 @@ pub fn bun_options_argc() -> usize {
     let _ = argv_view();
     BUN_OPTIONS_ARGC.load(core::sync::atomic::Ordering::Relaxed)
 }
-/// Zig: `bun.bun_options_argc = n` — write accessor (single-threaded startup).
+/// Write accessor (single-threaded startup).
 #[inline]
 pub fn set_bun_options_argc(n: usize) {
     BUN_OPTIONS_ARGC.store(n, core::sync::atomic::Ordering::Relaxed);
 }
 
-/// Trait for arg types accepted by [`append_options_env`] (replaces Zig
-/// `comptime ArgType` in `bun.appendOptionsEnv`). Impl'd for `bun_core::String`
+/// Trait for arg types accepted by [`append_options_env`].
+/// Impl'd for `bun_core::String`
 /// and `Box<ZStr>` in their owning crates.
 pub trait OptionsEnvArg {
     fn from_slice(s: &[u8]) -> Self;
     fn from_buf(buf: Vec<u8>) -> Self;
 }
 
-/// Zig `[:0]const u8` arm of `appendOptionsEnv`: `default_allocator.allocSentinel`
-/// + never freed (process-lifetime argv storage). The leaked allocation matches
-/// the Zig alloc/free pairing exactly — argv entries live for the process.
+/// Leaked-allocation arm of `append_options_env` (process-lifetime argv
+/// storage) — argv entries live for the process, so the allocation is
+/// intentionally never freed.
 impl OptionsEnvArg for &'static ZStr {
     fn from_slice(s: &[u8]) -> Self {
         let mut v = Vec::with_capacity(s.len() + 1);
@@ -4244,9 +4195,9 @@ impl OptionsEnvArg for Box<ZStr> {
     }
 }
 
-/// Zig: `bun.appendOptionsEnv` — parse a `BUN_OPTIONS`-style string
+/// Parse a `BUN_OPTIONS`-style string
 /// (`--flag=value --flag2 "quoted value" bare`) and insert each token into
-/// `args` starting at index 1 (Zig callers prepend a placeholder at [0]).
+/// `args` starting at index 1 (callers prepend a placeholder at [0]).
 pub fn append_options_env<A: OptionsEnvArg>(env: &[u8], args: &mut Vec<A>) {
     let mut i: usize = 0;
     let mut offset_in_args: usize = 1;
@@ -4368,8 +4319,7 @@ pub fn append_options_env<A: OptionsEnvArg>(env: &[u8], args: &mut Vec<A>) {
     }
 }
 
-/// `bun.argv = slice` — swap the global argv view. Zig assigns the slice
-/// directly (`bun.argv = full_argv[0..n]`); call sites are single-threaded
+/// Swap the global argv view. Call sites are single-threaded
 /// startup (CLI parsing in the `--compile` path), so this writes the static
 /// without synchronization.
 ///
@@ -4395,8 +4345,8 @@ pub fn intern_argv(v: Vec<&'static ZStr>) -> &'static [&'static ZStr] {
 }
 
 // ── getcwd ────────────────────────────────────────────────────────────────
-/// Port of `bun.getcwd(buf)` → `Maybe([:0]u8)`. Writes into the caller's
-/// `PathBuffer` and returns the NUL-terminated slice on success.
+/// Writes the current working directory into the caller's `PathBuffer` and
+/// returns the NUL-terminated slice on success.
 pub fn getcwd(buf: &mut PathBuffer) -> Result<&ZStr, crate::Error> {
     #[cfg(unix)]
     // SAFETY: `buf` provides `MAX_PATH_BYTES` writable bytes for `getcwd`; on
@@ -4412,8 +4362,8 @@ pub fn getcwd(buf: &mut PathBuffer) -> Result<&ZStr, crate::Error> {
     }
     #[cfg(windows)]
     {
-        // Zig `bun.getcwd` → `std.posix.getcwd`, which on Windows wraps
-        // `kernel32.GetCurrentDirectoryW` and transcodes WTF-16 → WTF-8.
+        // Windows: wrap
+        // `kernel32.GetCurrentDirectoryW` and transcode WTF-16 → WTF-8.
         unsafe extern "system" {
             fn GetCurrentDirectoryW(nBufferLength: u32, lpBuffer: *mut u16) -> u32;
         }
@@ -4427,8 +4377,7 @@ pub fn getcwd(buf: &mut PathBuffer) -> Result<&ZStr, crate::Error> {
             return Err(crate::err!(NameTooLong));
         }
         // WTF-16 → WTF-8 into the caller's `PathBuffer`. Surrogate pairs are
-        // combined; unpaired surrogates are encoded as 3-byte WTF-8 (matches
-        // Zig's `std.unicode.wtf16LeToWtf8`).
+        // combined; unpaired surrogates are encoded as 3-byte WTF-8.
         let src = &wbuf.0[..n];
         let out = &mut buf.0;
         let mut wi = 0usize;
@@ -4502,17 +4451,19 @@ pub fn which<'a>(buf: &'a mut PathBuffer, path: &[u8], cwd: &[u8], bin: &[u8]) -
         }
         #[cfg(not(unix))]
         {
-            // TODO(port): Windows X_OK via GetFileAttributesW; defer to bun_which.
+            // No X_OK probe here: this tier-0 helper is only reached from the
+            // linux/freebsd `spawn_sync_inherit` path. Windows callers resolve
+            // executables via `bun_which` (PATHEXT-aware) instead.
         }
         None
     };
-    // Absolute `bin` → probe it directly without joining `cwd` (which.zig:35-42).
+    // Absolute `bin` → probe it directly without joining `cwd`.
     if crate::path_sep::is_absolute_native(bin) {
         return check(buf, b"", bin).map(|n| ZStr::from_buf(&buf.0, n));
     }
     if has_sep {
-        // Relative with separator → resolve against cwd only. Zig trims
-        // trailing '/' from cwd and strips a leading "./" from bin.
+        // Relative with separator → resolve against cwd only; trim
+        // trailing '/' from cwd and strip a leading "./" from bin.
         let cwd = {
             let mut c = cwd;
             while let [rest @ .., b'/'] = c {
@@ -4523,7 +4474,7 @@ pub fn which<'a>(buf: &'a mut PathBuffer, path: &[u8], cwd: &[u8], bin: &[u8]) -
         let bin = bin.strip_prefix(b"./").unwrap_or(bin);
         return check(buf, cwd, bin).map(|n| ZStr::from_buf(&buf.0, n));
     }
-    // Bare names go straight to PATH (which.zig:44-63) — do NOT consult cwd.
+    // Bare names go straight to PATH — do NOT consult cwd.
     let delim: u8 = if cfg!(windows) { b';' } else { b':' };
     for dir in path.split(|&b| b == delim) {
         if dir.is_empty() {
@@ -4537,7 +4488,7 @@ pub fn which<'a>(buf: &'a mut PathBuffer, path: &[u8], cwd: &[u8], bin: &[u8]) -
 }
 
 // ── auto_reload_on_crash / reload_process group ───────────────────────────
-// Port of `bun.zig:1527-1686`. Full body of `reloadProcess` depends on
+// Full body of `reloadProcess` depends on
 // `bun.spawn` (tier-4); the crash-handler only needs the flag + the
 // thread-coordination helpers + a best-effort POSIX `execve` path.
 use core::sync::atomic::{AtomicBool, Ordering as AOrdering};
@@ -4562,7 +4513,7 @@ pub fn is_process_reload_in_progress_on_another_thread() -> bool {
         && !RELOAD_IN_PROGRESS_ON_CURRENT_THREAD.with(|c| c.get())
 }
 
-/// Zig: `bun.exitThread()` — terminate the current OS thread without unwinding.
+/// Terminate the current OS thread without unwinding.
 /// POSIX `pthread_exit`; Windows `ExitThread`. Called from worker `shutdown()`.
 pub fn exit_thread() -> ! {
     #[cfg(unix)]
@@ -4585,7 +4536,7 @@ pub fn exit_thread() -> ! {
     }
 }
 
-/// Zig: `bun.deleteAllPoolsForThreadExit()` — release thread-local pooled
+/// Release thread-local pooled
 /// buffers (PathBuffer pool, ObjectPool, …) before the thread terminates so
 /// the backing storage is returned to mimalloc rather than leaked with the
 /// TLS block.
@@ -4615,7 +4566,7 @@ pub fn maybe_handle_panic_during_process_reload() {
         crate::output::flush();
         #[cfg(debug_assertions)]
         crate::output::debug_warn("panic() called during process reload, ignoring\n");
-        // Zig: `bun.exitThread()`. POSIX `pthread_exit`; Windows `ExitThread`.
+        // POSIX `pthread_exit`; Windows `ExitThread`.
         exit_thread();
     }
     // Spin if pthread_exit was a no-op (pathological).
@@ -4672,7 +4623,7 @@ pub fn reload_process(clear_terminal: bool, may_return: bool) {
             // memory-safety preconditions.
             safe fn TerminateProcess(h: *mut core::ffi::c_void, code: u32) -> i32;
         }
-        // = 3224497970, bun.windows.watcher_reload_exit (windows.zig). Parent
+        // = 3224497970. Parent
         // watcher-manager compares the child's exit code against exactly this.
         const WATCHER_RELOAD_EXIT: u32 = 0xC031_EF32;
         let rc = TerminateProcess(GetCurrentProcess(), WATCHER_RELOAD_EXIT);
@@ -4706,8 +4657,7 @@ pub fn reload_process(clear_terminal: bool, may_return: bool) {
             on_before_reload_process_linux();
         }
 
-        // We clone argv so that the memory address isn't the same as the libc one
-        // (mirrors Zig `allocator.dupeZ` per entry).
+        // We clone argv so that the memory address isn't the same as the libc one.
         let args = argv_storage();
         let dupe_argv: Vec<ZBox> = args
             .iter()
@@ -4718,7 +4668,7 @@ pub fn reload_process(clear_terminal: bool, may_return: bool) {
         newargv.push(core::ptr::null());
 
         // We clone envp so that the memory address of environment variables isn't
-        // the same as the libc one (mirrors Zig `allocSentinel` + `dupeZ` loop).
+        // the same as the libc one.
         let mut dupe_env: Vec<ZBox> = Vec::new();
         let mut p = c_environ();
         while !p.is_null() && !(*p).is_null() {
@@ -4747,8 +4697,7 @@ pub fn reload_process(clear_terminal: bool, may_return: bool) {
 
     #[cfg(not(any(unix, windows)))]
     {
-        // Zig: `else @compileError("unsupported platform for reloadProcess")`.
-        // Faithful port — Bun only targets POSIX + Windows; any other target
+        // Bun only targets POSIX + Windows; any other target
         // is a build-time error, not a runtime panic.
         let _ = (clear_terminal, may_return);
         compile_error!("unsupported platform for reload_process");
@@ -4803,9 +4752,9 @@ pub mod spawn_ffi {
     /// Matches `bun_spawn_request_file_action_t`.
     ///
     /// ABI: this struct crosses FFI to `posix_spawn_bun` via `*const Action`
-    /// (see [`ActionsList`]) and must match spawn.zig's `extern struct` /
-    /// bun-spawn.cpp's C struct exactly. `path` is `?[*:0]const u8` on the
-    /// Zig/C side — an 8-byte thin nullable pointer — so it MUST be
+    /// (see [`ActionsList`]) and must match
+    /// bun-spawn.cpp's C struct exactly. `path` on the
+    /// C side is an 8-byte thin nullable pointer — so it MUST be
     /// `*const c_char` here, not `Option<CString>` (which is a 16-byte fat
     /// pointer and would shift `fds`/`flags`/`mode`).
     #[repr(C)]
@@ -4881,7 +4830,34 @@ pub mod spawn_ffi {
     }
 }
 
+/// Stdin disposition for [`spawn_sync_inherit`] / [`spawn_sync_inherit_no_stdin`].
+/// The `Ignore` case wires fd 0 to `/dev/null` (`NUL` on Windows) so the
+/// child never blocks on a TTY read.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum StdinBehavior {
+    Inherit,
+    Ignore,
+}
+
+/// Spawn argv, inherit stdout/stderr, **ignore stdin** (fd 0 ← /dev/null),
+/// wait.
+pub fn spawn_sync_inherit_no_stdin(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crate::Error> {
+    spawn_sync_inherit_impl(argv, StdinBehavior::Ignore)
+}
+
 pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crate::Error> {
+    spawn_sync_inherit_impl(argv, StdinBehavior::Inherit)
+}
+
+fn spawn_sync_inherit_impl(
+    argv: &[impl AsRef<[u8]>],
+    stdin: StdinBehavior,
+) -> Result<SpawnStatus, crate::Error> {
+    // Empty argv: fail like the Windows path below instead of panicking on
+    // the `argv[0]` reads in the per-OS unix arms.
+    if argv.is_empty() {
+        return Err(crate::err!("FileNotFound"));
+    }
     #[cfg(unix)]
     // SAFETY: argv strings are owned `ZBox`es (NUL-terminated) kept alive in
     // `cargs` for the duration of the spawn; `ptrs`/`environ` are null-
@@ -4920,12 +4896,24 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
             // dup2(n, n) for fds 0..=2 — posix_spawn_bun's Dup2 same-fd path
             // clears CLOEXEC and bumps the close-range floor past stdio. An
             // empty actions list would start the close-range at fd 1.
-            let inherit_stdio: [spawn_ffi::Action; 3] =
+            // StdinBehavior::Ignore swaps the fd-0 action for an Open of
+            // /dev/null (posix_spawn_bun: open(path, flags, mode) → dup2 onto
+            // fds[0]).
+            let mut inherit_stdio: [spawn_ffi::Action; 3] =
                 core::array::from_fn(|fd| spawn_ffi::Action {
                     kind: spawn_ffi::FileActionType::Dup2,
                     fds: [fd as core::ffi::c_int, fd as core::ffi::c_int],
                     ..Default::default()
                 });
+            if stdin == StdinBehavior::Ignore {
+                inherit_stdio[0] = spawn_ffi::Action {
+                    kind: spawn_ffi::FileActionType::Open,
+                    path: c"/dev/null".as_ptr(),
+                    fds: [0, 0],
+                    flags: libc::O_RDONLY,
+                    mode: 0,
+                };
+            }
             let req = spawn_ffi::BunSpawnRequest {
                 actions: spawn_ffi::ActionsList {
                     ptr: inherit_stdio.as_ptr(),
@@ -4951,15 +4939,42 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
         // for the non-PTY inherit case. PTY spawns go through spawn_sys.
         #[cfg(target_os = "macos")]
         let pid: libc::pid_t = {
+            // StdinBehavior::Ignore → file action opening /dev/null onto fd 0;
+            // stdout/stderr stay inherited.
+            let mut actions: libc::posix_spawn_file_actions_t = core::ptr::null_mut();
+            let actions_ptr: *const libc::posix_spawn_file_actions_t =
+                if stdin == StdinBehavior::Ignore {
+                    let rc = libc::posix_spawn_file_actions_init(&raw mut actions);
+                    if rc != 0 {
+                        return Err(crate::Error::from_errno(rc));
+                    }
+                    let rc = libc::posix_spawn_file_actions_addopen(
+                        &raw mut actions,
+                        0,
+                        c"/dev/null".as_ptr(),
+                        libc::O_RDONLY,
+                        0,
+                    );
+                    if rc != 0 {
+                        libc::posix_spawn_file_actions_destroy(&raw mut actions);
+                        return Err(crate::Error::from_errno(rc));
+                    }
+                    &raw const actions
+                } else {
+                    core::ptr::null()
+                };
             let mut pid: libc::pid_t = 0;
             let rc = libc::posix_spawnp(
                 &raw mut pid,
                 ptrs[0],
-                core::ptr::null(),
+                actions_ptr,
                 core::ptr::null(),
                 ptrs.as_ptr().cast::<*mut core::ffi::c_char>(),
                 environ.cast::<*mut core::ffi::c_char>(),
             );
+            if !actions_ptr.is_null() {
+                libc::posix_spawn_file_actions_destroy(&raw mut actions);
+            }
             if rc != 0 {
                 return Err(crate::Error::from_errno(rc));
             }
@@ -4980,6 +4995,16 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
                 // Child. execvp inherits stdio + environ, which is exactly the
                 // "inherit" contract this helper promises. On failure, _exit
                 // (no destructors / atexit hooks in a forked child).
+                if stdin == StdinBehavior::Ignore {
+                    // StdinBehavior::Ignore: fd 0 ← /dev/null.
+                    let devnull = libc::open(c"/dev/null".as_ptr(), libc::O_RDONLY);
+                    if devnull < 0 || libc::dup2(devnull, 0) < 0 {
+                        libc::_exit(127);
+                    }
+                    if devnull != 0 {
+                        libc::close(devnull);
+                    }
+                }
                 libc::execvp(ptrs[0], ptrs.as_ptr());
                 libc::_exit(127);
             }
@@ -4994,7 +5019,7 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
             target_os = "android",
         )))]
         let pid: libc::pid_t = {
-            let _ = (&ptrs, environ);
+            let _ = (&ptrs, environ, stdin);
             return Err(crate::err!(Unexpected));
         };
 
@@ -5019,11 +5044,8 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
     }
     #[cfg(windows)]
     {
-        // Zig spec call sites (init_command.zig:855, :1237) use
-        // `std.process.Child{.stderr,stdin,stdout = .Inherit}.spawnAndWait()`,
-        // which on Windows is `windowsCreateProcessPathExt` → CreateProcessW
-        // with no event loop. Route through `std::process::Command` (also
-        // CreateProcessW) with inherited stdio — see spawn/lib.rs:307 for the
+        // Route through `std::process::Command` (CreateProcessW, no event
+        // loop) with inherited stdio — see spawn/lib.rs:307 for the
         // PORTING.md rationale on why off-loop spawns may bypass bun_spawn on
         // Windows. Do NOT return `err!(Unexpected)` here: that bubbles up as
         // `error: An unknown error occurred (Unexpected)` and fails every
@@ -5044,7 +5066,11 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
         for arg in iter {
             cmd.arg(to_os(arg.as_ref()));
         }
-        // Inherit stdio + environ (Command default), matching Zig `.Inherit`.
+        // Inherit stdio + environ (Command default).
+        // StdinBehavior::Ignore → NUL device.
+        if stdin == StdinBehavior::Ignore {
+            cmd.stdin(std::process::Stdio::null());
+        }
         let status = cmd.status().map_err(|e| match e.kind() {
             std::io::ErrorKind::NotFound => crate::err!("FileNotFound"),
             std::io::ErrorKind::PermissionDenied => crate::err!("AccessDenied"),
@@ -5055,16 +5081,16 @@ pub fn spawn_sync_inherit(argv: &[impl AsRef<[u8]>]) -> Result<SpawnStatus, crat
     }
     #[cfg(not(any(unix, windows)))]
     {
-        let _ = argv;
+        let _ = (argv, stdin);
         Err(crate::err!(Unexpected))
     }
 }
 
 // ── Timespec ──────────────────────────────────────────────────────────────
-// Port of `bun.timespec` (bun.zig:3257). `extern struct { sec: i64, nsec: i64 }`.
+// `bun.timespec` — `#[repr(C)] { sec: i64, nsec: i64 }`.
 // CANONICAL — the `bun` facade re-exports this as `bun::timespec`; do NOT
 // re-port this struct elsewhere. The two `bun_sys::{linux,posix}::timespec`
-// shims port DIFFERENT Zig types (`std.os.linux.timespec` / `std.posix.timespec`)
+// shims are DIFFERENT types (kernel/libc timespec layouts)
 // for syscall ABI and intentionally do NOT alias this.
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -5078,7 +5104,7 @@ unsafe impl crate::ffi::Zeroable for Timespec {}
 // no interior mutability, `Copy + 'static`. Every byte is initialized.
 unsafe impl bytemuck::NoUninit for Timespec {}
 
-/// Lowercase alias (Zig spells it `bun.timespec`).
+/// Lowercase alias (`bun.timespec`).
 #[allow(non_camel_case_types)]
 pub type timespec = Timespec;
 
@@ -5097,7 +5123,7 @@ impl Timespec {
         self == other
     }
 
-    /// `self - other` (Zig: `duration`). Mimics C wrapping behaviour.
+    /// `self - other`. Mimics C wrapping behaviour.
     pub fn duration(&self, other: &Timespec) -> Timespec {
         let mut sec = self.sec.wrapping_sub(other.sec);
         let mut nsec = self.nsec.wrapping_sub(other.nsec);
@@ -5121,7 +5147,7 @@ impl Timespec {
             return self.nsec.max(0) as u64;
         }
         let s_ns = (self.sec as u64).saturating_mul(Self::NS_PER_S as u64);
-        // Zig-exact (bun.zig:3313 returns maxInt(i64))
+        // Saturates at i64::MAX (not u64::MAX) on overflow.
         s_ns.checked_add(self.nsec.max(0) as u64)
             .unwrap_or(i64::MAX as u64)
     }
@@ -5198,7 +5224,7 @@ impl Timespec {
         if a.order(&b).is_gt() { a } else { b }
     }
 
-    /// `bun.timespec.orderIgnoreEpoch` (bun.zig:3405) — EPOCH = "no timeout", treated as +∞.
+    /// `bun.timespec.orderIgnoreEpoch` — EPOCH = "no timeout", treated as +∞.
     pub fn order_ignore_epoch(a: Timespec, b: Timespec) -> core::cmp::Ordering {
         if a == b {
             return core::cmp::Ordering::Equal;
@@ -5211,7 +5237,7 @@ impl Timespec {
         }
         a.order(&b)
     }
-    /// `bun.timespec.minIgnoreEpoch` (bun.zig:3411).
+    /// `bun.timespec.minIgnoreEpoch`.
     #[inline]
     pub fn min_ignore_epoch(self, b: Timespec) -> Timespec {
         if Self::order_ignore_epoch(self, b).is_lt() {
@@ -5289,9 +5315,9 @@ pub enum TimespecMockMode {
     ForceRealTime,
 }
 
-/// `bun_core::timespec::Mode` namespace shim — Zig nested it under the struct;
-/// Rust can't do inherent associated types stably, so expose a module with the
-/// same path. Callers write `bun_core::timespec_mode::AllowMockedTime` or use
+/// `bun_core::timespec_mode::Mode` namespace shim —
+/// Rust can't do inherent associated types stably, so expose a module
+/// instead. Callers write `bun_core::timespec_mode::AllowMockedTime` or use
 /// the `Timespec::now_allow_mocked_time()` helper.
 pub mod timespec_mode {
     pub use super::TimespecMockMode::*;
@@ -5327,9 +5353,9 @@ pub mod mock_time {
 }
 
 // ── f16 ───────────────────────────────────────────────────────────────────
-// Zig's native `f16` (IEEE-754 binary16). Rust's `f16` is still nightly-only,
+// IEEE-754 binary16. Rust's `f16` is still nightly-only,
 // so model it as a transparent `u16` bit-container with `f64` widening for the
-// one hot caller (ConsoleObject Float16Array printing). PERF(port): scalar
+// one hot caller (ConsoleObject Float16Array printing). PERF: scalar
 // soft-float decode; revisit once `core::f16` stabilizes.
 #[allow(non_camel_case_types)]
 #[repr(transparent)]
@@ -5346,7 +5372,7 @@ impl f16 {
         self.0
     }
 
-    /// Widen to `f64` (exact). Port of Zig `@floatCast(f64, h)`.
+    /// Widen to `f64` (exact).
     pub fn to_f64(self) -> f64 {
         let h = self.0 as u32;
         let sign = (h >> 15) & 1;
@@ -5396,9 +5422,9 @@ impl core::fmt::Display for f16 {
 }
 
 // ── perf ──────────────────────────────────────────────────────────────────
-// Port of `bun.perf` (src/perf/perf.zig). The Linux ftrace backend is
+// `bun.perf`. The Linux ftrace backend is
 // libc-only, so it folds in directly and `bun_core::perf::trace("X")` is real
-// instrumentation on Linux. macOS: the Zig backend wraps `Bun__signpost_emit`
+// instrumentation on Linux. macOS: signposts wrap `Bun__signpost_emit`
 // (c-bindings.cpp) which keys on the codegen `PerfEvent` int — that table
 // lives in `bun_perf` (T2, owns generated_perf_trace_events), so T0 reports
 // disabled on macOS. **No functional divergence today**: `bun_perf`'s Darwin
@@ -5406,7 +5432,7 @@ impl core::fmt::Display for f16 {
 // stub whose `end()` is a no-op, so neither tier emits signposts yet. When
 // `Bun__signpost_emit` is wired, callers above T0 use `bun_perf::trace`; T0
 // callsites (audited r5) are bundler/parser hot paths where Linux ftrace is
-// the profiling target. Windows/other platforms are no-ops in Zig too.
+// the profiling target. Windows/other platforms are no-ops.
 pub mod perf {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     use core::sync::atomic::AtomicBool;
@@ -5530,7 +5556,7 @@ pub mod perf {
             let duration = crate::Timespec::now(crate::TimespecMockMode::ForceRealTime)
                 .ns()
                 .saturating_sub(self.start_time);
-            // Zig passed `@tagName(event).ptr` (NUL-terminated). Build a small
+            // The FFI wants a NUL-terminated name. Build a small
             // stack CString from the &'static str literal.
             let mut buf = [0u8; 96];
             let n = self.name.len().min(buf.len() - 1);
@@ -5548,7 +5574,7 @@ pub mod perf {
     /// Single source of truth for the Linux ftrace FFI decls (defined in
     /// `src/jsc/bindings/linux_perf_tracing.cpp`). Re-exported so `bun_perf`
     /// (the canonical signpost/ftrace entry point) imports these instead of
-    /// re-declaring them — see src/perf/perf.zig:127-129 for the spec.
+    /// re-declaring them.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub mod sys {
         unsafe extern "C" {
@@ -5565,16 +5591,15 @@ pub mod perf {
 }
 
 // ── form_data ─────────────────────────────────────────────────────────────
-// Port of `bun.FormData.{Encoding, AsyncFormData, getBoundary}` (src/runtime/
-// webcore/FormData.zig:16-95). The JSC-touching parts (`toJS`, the field map,
+// `bun.FormData.{Encoding, AsyncFormData, getBoundary}`.
+// The JSC-touching parts (`toJS`, the field map,
 // multipart parser) stay in `bun_runtime::webcore::form_data`; T0 owns only
 // the encoding-detection types so `Request`/`Response`/`Body` can name them
 // without a runtime→core cycle. Per PORTING.md §JSC: `to_js` is an extension
 // method that lives in the higher-tier crate.
 pub mod form_data {
     /// `FormData.Encoding` — `union(enum) { URLEncoded, Multipart: []const u8 }`.
-    /// `Multipart` owns its boundary (Zig `AsyncFormData.init` duped it; here
-    /// the Box moves in directly).
+    /// `Multipart` owns its boundary (the Box moves in directly).
     #[derive(Debug)]
     pub enum Encoding {
         URLEncoded,
@@ -5661,8 +5686,7 @@ pub mod form_data {
     }
 
     /// `FormData.AsyncFormData` — heap-allocated, owns its `Encoding`.
-    /// PORT NOTE: Zig stored `std.mem.Allocator param`; deleted (non-AST
-    /// crate, global mimalloc per §Allocators). `deinit` becomes `Drop` on the
+    /// Cleanup is `Drop` on the
     /// `Box`/`Box<[u8]>` fields — no explicit impl needed.
     #[derive(Debug)]
     pub struct AsyncFormData {
@@ -5672,14 +5696,10 @@ pub mod form_data {
     impl AsyncFormData {
         #[inline]
         pub fn init(encoding: Encoding) -> Box<AsyncFormData> {
-            // Zig duped `encoding.Multipart` here so the struct owned its
-            // boundary; with `Box<[u8]>` ownership has already transferred.
+            // With `Box<[u8]>`, boundary ownership has already transferred.
             Box::new(AsyncFormData { encoding })
         }
     }
 }
-/// Zig `bun.FormData` namespace — capitalized alias for callers that ported
-/// `bun.FormData.AsyncFormData` verbatim.
+/// `bun.FormData` — capitalized namespace alias.
 pub use form_data as FormData;
-
-// ported from: src/bun_core/util.zig
diff --git a/src/bun_core/windows_sys.rs b/src/bun_core/windows_sys.rs
index 06b54e2a9c3..a04d5a7be00 100644
--- a/src/bun_core/windows_sys.rs
+++ b/src/bun_core/windows_sys.rs
@@ -23,8 +23,7 @@ pub(crate) const ENABLE_PROCESSED_OUTPUT: DWORD = 0x0001;
 pub(crate) const ENABLE_WRAP_AT_EOL_OUTPUT: DWORD = 0x0002;
 pub(crate) const ENABLE_VIRTUAL_TERMINAL_PROCESSING: DWORD = 0x0004;
 
-/// Wrapper that returns `None` on `INVALID_HANDLE_VALUE` (matches
-/// `std.os.windows.GetStdHandle` error-union semantics).
+/// Wrapper that returns `None` on `INVALID_HANDLE_VALUE` or a null handle.
 #[inline]
 pub fn GetStdHandle(std_handle: DWORD) -> Option<HANDLE> {
     let h = kernel32::GetStdHandle(std_handle);
@@ -36,7 +35,7 @@ pub fn GetStdHandle(std_handle: DWORD) -> Option<HANDLE> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// PEB access (`std.os.windows.peb()`). `bun_core::output::windows_stdio`
+// PEB access. `bun_core::output::windows_stdio`
 // reads `ProcessParameters.hStd{Input,Output,Error}` to snapshot the console
 // handles before libuv touches them. Canonical structs/asm live in the tier-0
 // `bun_windows_sys` leaf and are re-exported here for the
@@ -56,7 +55,7 @@ unsafe impl crate::ffi::Zeroable for CONSOLE_SCREEN_BUFFER_INFO {}
 // kernel32 externs are owned by the tier-0 leaf `bun_windows_sys`; re-export
 // so existing `crate::windows_sys::kernel32::*` / `c::*` callers resolve.
 pub use bun_windows_sys::kernel32;
-// `c::` alias used by `output.rs` (Zig's `bun.c` namespace).
+// `c::` alias used by `output.rs`.
 pub use kernel32 as c;
 
 /// `bun.windows.libuv` — only `uv_disable_stdio_inheritance` is called from
diff --git a/src/bun_core/wtf.rs b/src/bun_core/wtf.rs
index 37ba8c83210..e38522acc20 100644
--- a/src/bun_core/wtf.rs
+++ b/src/bun_core/wtf.rs
@@ -9,9 +9,9 @@
 //! which forwards to `WTF::parseES5Date` in
 //! vendor/WebKit `Source/WTF/wtf/DateMath.{h,cpp}`.
 //!
-//! PORT NOTE: WTF's `parseES5Date` sets an `isLocalTime` out-param so the JS
+//! Note: WTF's `parseES5Date` sets an `isLocalTime` out-param so the JS
 //! `Date` constructor can later apply the VM's tz offset. The C shim discards
-//! it (matching `src/jsc/WTF.zig`), so local-time inputs return their naive
+//! it, so local-time inputs return their naive
 //! UTC value here too.
 
 unsafe extern "C" {
@@ -65,5 +65,3 @@ pub use crate::string::wtf::{
     InvalidCharacter, RefPtr, StringImpl, WTFString, WTFStringImpl, WTFStringImplExt,
     WTFStringImplStruct, parse_double,
 };
-
-// ported from: src/jsc/WTF.zig
diff --git a/src/bun_core_macros/lib.rs b/src/bun_core_macros/lib.rs
index f4947f4288b..eb54d5f8d3f 100644
--- a/src/bun_core_macros/lib.rs
+++ b/src/bun_core_macros/lib.rs
@@ -1,7 +1,6 @@
 //! Proc-macros for `bun_core`.
 //!
-//! `pretty_fmt!(FMT, true|false)` is the compile-time port of Zig's
-//! `Output.prettyFmt` (`src/bun_core/output.zig`). It rewrites Bun's `<tag>`
+//! `pretty_fmt!(FMT, true|false)` rewrites Bun's `<tag>`
 //! color markup into ANSI escape sequences (or strips them when the second
 //! argument is `false`) and emits a string *literal* so the result is usable as
 //! a `format_args!` / `concat!` template.
@@ -80,12 +79,12 @@ fn eval_literal(expr: &Expr, out: &mut String) -> Result<(), syn::Error> {
 
 use bun_output_tags::{RESET, color_for};
 
-/// 1:1 port of `prettyFmt` from output.zig, plus Zig→Rust format-spec rewrites
+/// Rewrites `<tag>` markup plus legacy format specs
 /// (`{s}`/`{d}` → `{}`, `{any}`/`{?}` → `{:?}`).
 ///
 /// Colour table lives in `bun_output_tags`; the state machine is kept duplicated
 /// vs `bun_core::output::pretty_fmt_runtime` because the two intentionally
-/// diverge in the `{` arm (this side rewrites Zig specs `{s}`→`{}` for the
+/// diverge in the `{` arm (this side rewrites legacy specs `{s}`→`{}` for the
 /// emitted `format_args!` template; runtime copies braces verbatim) and on
 /// unknown tags (this side `Err`→`compile_error!`; runtime emits `""`).
 fn rewrite(fmt: &str, is_enabled: bool) -> Result<String, String> {
@@ -111,11 +110,11 @@ fn rewrite(fmt: &str, is_enabled: bool) -> Result<String, String> {
                 }
             }
             b'>' => {
-                // stray closer — Zig drops it
+                // stray closer — dropped
                 i += 1;
             }
             b'{' => {
-                // copy `{ ... }` verbatim, optionally rewriting Zig-style specs
+                // copy `{ ... }` verbatim, optionally rewriting legacy specs
                 let start = i;
                 while i < bytes.len() && bytes[i] != b'}' {
                     i += 1;
@@ -207,9 +206,8 @@ pub fn pretty_fmt(input: TokenStream) -> TokenStream {
 // There is no type-based fallback. An earlier draft fell back on "the unique
 // field whose type's last path segment is `Cell`", but that matched any
 // `Cell<_>` (e.g. `Cell<bool>`), turning the helpful "no ref_count field
-// found" diagnostic into a buried type-mismatch inside generated code. The
-// Zig spec (`@FieldType(T, "ref_count")` in src/ptr/ref_count.zig) requires
-// the literal name anyway, so rules 1+2 are sufficient and exhaustive.
+// found" diagnostic into a buried type-mismatch inside generated code.
+// Rules 1+2 are sufficient and exhaustive.
 //
 // Custom destructor: `#[ref_count(destroy = Self::deinit)]` on the struct
 // routes the trait's `destroy` to that path instead of the default
@@ -552,9 +550,7 @@ pub fn derive_thread_safe_ref_counted(input: TokenStream) -> TokenStream {
 // #[derive(RefCounted)]  — intrusive single-thread `RefCount<Self>` mixin
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Third sibling of CellRefCounted / ThreadSafeRefCounted. Ports Zig's
-// `bun.ptr.RefCount(@This(), "ref_count", destructor, .{ .debug_name = … })`
-// comptime mixin (src/ptr/ref_count.zig:67) — the form taken by ~17 Rust
+// Third sibling of CellRefCounted / ThreadSafeRefCounted — replaces the ~17
 // hand-rolls that all spell out `type DestructorCtx = (); get_ref_count =
 // &raw mut (*this).ref_count; destructor = drop(heap::take(this))`.
 //
@@ -562,7 +558,6 @@ pub fn derive_thread_safe_ref_counted(input: TokenStream) -> TokenStream {
 //   #[ref_count(destroy = <path>)]      — `unsafe fn(*mut Self)`; default is
 //                                         `drop(::bun_core::heap::take(this))`
 //   #[ref_count(debug_name = "Name")]   — overrides `RefCounted::debug_name()`
-//                                         (Zig `.{ .debug_name = … }` option)
 //
 // Field selection follows the shared `find_ref_count_field` rules (a
 // `#[ref_count]`-annotated field, else a field literally named `ref_count`).
@@ -668,12 +663,10 @@ pub fn derive_ref_counted(input: TokenStream) -> TokenStream {
 // #[derive(EnumTag)]
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Rust port of Zig's `union(Tag)` / `std.meta.Tag(T)` language built-in.
-// Every Zig tagged-union ported to a Rust `enum` lost the implicit
-// data→discriminant projection and grew a hand-written
+// Derives the data→discriminant projection that otherwise needs a
+// hand-written
 // `fn tag(&self) -> Tag { match self { Self::A(..) => Tag::A, … } }` (14
-// copies, 160+ arms total — see ast/expr.rs, ast/stmt.rs, shell_parser, etc.;
-// stmt.rs:466 literally comments "Zig got this for free from `union(Tag)`").
+// copies, 160+ arms total — see ast/expr.rs, ast/stmt.rs, shell_parser, etc.).
 //
 // Two modes:
 //
@@ -745,7 +738,7 @@ pub fn derive_enum_tag(input: TokenStream) -> TokenStream {
         let tag_idents2 = tag_idents.clone();
         return quote! {
             impl #impl_g #name #ty_g #where_g {
-                /// Data → discriminant projection (Zig `union(Tag)` built-in).
+                /// Data → discriminant projection.
                 #[inline]
                 pub const fn tag(&self) -> #tag_path {
                     match self {
@@ -772,7 +765,7 @@ pub fn derive_enum_tag(input: TokenStream) -> TokenStream {
         #[derive(Clone, Copy, PartialEq, Eq, Debug)]
         pub enum #tag_name { #( #tag_variants, )* }
         impl #impl_g #name #ty_g #where_g {
-            /// Data → discriminant projection (Zig `union(Tag)` built-in).
+            /// Data → discriminant projection.
             #[inline]
             pub const fn tag(&self) -> #tag_name {
                 match self {
diff --git a/src/bun_output_tags/lib.rs b/src/bun_output_tags/lib.rs
index 3b5859c4d65..239866f1505 100644
--- a/src/bun_output_tags/lib.rs
+++ b/src/bun_output_tags/lib.rs
@@ -2,17 +2,13 @@
 //! named ANSI escape constants used directly by REPL / diff-printer / multi-run
 //! output. Zero-dep `#![no_std]` leaf so both the proc-macro crate and runtime
 //! crates can import it without a cycle.
-//!
-//! Port of `color_map` from `src/bun_core/output.zig:965-1056`. Zig re-declares
-//! the escapes per-file (repl.zig, printDiff.zig, multi_run.zig); the Rust port
-//! collapses them onto [`ansi`].
 
 #![no_std]
 
 /// Named ANSI SGR escape sequences. One canonical literal per colour/attribute;
 /// every other crate aliases this module rather than re-declaring the bytes.
 ///
-/// `WHITE` is SGR 37 (normal). printDiff.zig:177 uses SGR 97 — that is
+/// `WHITE` is SGR 37 (normal); SGR 97 is
 /// [`BRIGHT_WHITE`], kept distinct so diff output stays byte-identical.
 pub mod ansi {
     pub const RESET: &str = "\x1b[0m";
@@ -94,8 +90,7 @@ pub fn color_for(name: &str) -> Option<&'static str> {
     None
 }
 
-/// Byte-slice form of [`color_for`] for callers working over `&[u8]` templates
-/// (mirrors Zig's `ComptimeStringMap.get`).
+/// Byte-slice form of [`color_for`] for callers working over `&[u8]` templates.
 #[inline]
 pub fn color_for_bytes(name: &[u8]) -> Option<&'static str> {
     for &(k, v) in COLOR_TABLE {
diff --git a/src/bundler/AstBuilder.rs b/src/bundler/AstBuilder.rs
index e728bea1731..6b1a3b1612e 100644
--- a/src/bundler/AstBuilder.rs
+++ b/src/bundler/AstBuilder.rs
@@ -38,7 +38,7 @@ use bun_paths::fs::{Path as FsPath, PathName};
 pub struct AstBuilder<'a, 'bump> {
     pub bump: &'bump Bump,
     pub source: &'a Source,
-    pub source_index: u32, // Zig: u31
+    pub source_index: u32,
     pub stmts: Vec<Stmt>,
     pub scopes: Vec<*mut Scope>,
     pub symbols: Vec<Symbol>,
@@ -58,12 +58,11 @@ pub struct AstBuilder<'a, 'bump> {
 
 // stub fields for ImportScanner duck typing
 //
-// Zig used `comptime` zero-sized fields (`options`, `import_items_for_namespace`)
-// and a `parser_features` decl so `ImportScanner.scan` could duck-type over both
-// the real parser and `AstBuilder`. In Rust this becomes a trait that both impl.
-// TODO(port): define `ImportScannerHost` trait in `bun_js_parser` and impl it here.
+// The scanner transform is open-coded in `to_bundled_ast` for the stmt shapes
+// AstBuilder emits; if `ImportScanner` ever grows a host trait in
+// `bun_js_parser`, these stubs are the surface it would formalize.
 impl<'a, 'bump> AstBuilder<'a, 'bump> {
-    // stub for ImportScanner duck typing — Zig: `comptime import_items_for_namespace: struct { fn get(_, _) ?Map { return null; } }`
+    // stub for ImportScanner duck typing
     pub fn import_items_for_namespace_get(
         &self,
         _ref: Ref,
@@ -94,8 +93,8 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
             export_star_import_records: Vec::new(),
             declared_symbols: Default::default(),
             hot_reloading,
-            module_ref: Ref::NONE,  // overwritten below (Zig: undefined)
-            hmr_api_ref: Ref::NONE, // overwritten below (Zig: undefined)
+            module_ref: Ref::NONE,  // overwritten below
+            hmr_api_ref: Ref::NONE, // overwritten below
         };
         ab.module_ref = ab.new_symbol(SymbolKind::Other, b"module")?;
         ab.hmr_api_ref = ab.new_symbol(SymbolKind::Other, b"hmr")?;
@@ -123,7 +122,6 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         unsafe { &mut *self.current_scope }
     }
 
-    // PORT NOTE: Zig signature lacks `!` but body uses `try` — porting as fallible.
     pub fn push_scope(&mut self, kind: ScopeKind) -> Result<*mut Scope, OOM> {
         self.scopes.reserve(1);
         self.current_scope_mut().children.ensure_unused_capacity(1);
@@ -139,7 +137,6 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
             .children
             .append_assume_capacity(NonNull::new(scope).expect("bump alloc non-null").into());
         self.scopes.push(self.current_scope);
-        // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
         self.current_scope = scope;
         Ok(scope)
     }
@@ -199,14 +196,13 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         let non_unique =
             MutableString::ensure_valid_identifier(path_name.non_unique_name_string_base())?;
         let name = strings::append(b"import_", &non_unique);
-        // PORT NOTE: copy into the arena so the raw `*const [u8]` stored on the
-        // Symbol outlives this stack frame (Zig used the parser arena arena).
+        // Copy into the arena so the raw `*const [u8]` stored on the
+        // Symbol outlives this stack frame.
         let name: &[u8] = self.bump.alloc_slice_copy(&name);
         let namespace_ref = self.new_symbol(SymbolKind::Other, name)?;
 
         let clauses: &mut [ClauseItem] = self.bump.alloc_slice_fill_default(N);
 
-        // Zig: `inline for` — all elements are `[]const u8`, so a plain loop suffices.
         for ((import_id, out_ref), clause) in identifiers_to_import
             .iter()
             .zip(out.iter_mut())
@@ -254,7 +250,6 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
     pub fn append_stmt<T: StatementData>(&mut self, data: T) -> Result<(), OOM> {
         self.stmts.reserve(1);
         self.stmts.push(self.new_stmt(data));
-        // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
         Ok(())
     }
 
@@ -273,7 +268,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         Ok(ref_)
     }
 
-    // PORT NOTE: returns `BundledAst<'static>` (== `JSAst`) directly. The only
+    // Returns `BundledAst<'bump>` (== `JSAst`) directly. The only
     // `'arena`-carrying field, `url_for_css`, is always set to `b""` here, and
     // every other field stores arena data via raw pointers / `StoreSlice`, so
     // nothing borrows `&mut self` past this call.
@@ -286,8 +281,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         let module_scope = self.current_scope;
 
         let mut parts = bun_ast::PartList::with_capacity_in(2, self.bump);
-        // PORT NOTE: Zig grew len then wrote `parts.mut(i).* = ...`, which is a
-        // bitwise store on the SoA slot. In Rust `*parts.mut_(i) = ...` first
+        // `*parts.mut_(i) = ...` on a grown-but-uninitialized slot first
         // *drops* the (uninitialized) prior `Part` — and `Part` carries Drop
         // fields (`Vec`/`HashMap`), so that drop frees garbage and corrupts the
         // heap (observed downstream as `printStmt` reading a junk `Stmt`
@@ -323,12 +317,10 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         let module_scope_ref = unsafe { &*module_scope };
         let generated_len = module_scope_ref.generated.len();
         top_level_symbols_to_parts.ensure_total_capacity(generated_len)?;
-        // PORT NOTE: reshaped — Zig grew `entries` then wrote keys/values columns
-        // in lockstep + `reIndex`. Rust `ArrayHashMap` keeps keys/values in private
-        // `Vec`s and rebuilds hashes on every `put_assume_capacity`, so a plain
-        // pre-reserved insert loop is equivalent (and `re_index` is a no-op here).
-        // Zig shallow-copied a single `Vec(u32){1}`; `Vec` is move-only
-        // in Rust, so allocate a fresh one per key.
+        // `ArrayHashMap` keeps keys/values in private `Vec`s and rebuilds
+        // hashes on every `put_assume_capacity`, so a plain pre-reserved
+        // insert loop suffices (and `re_index` is a no-op here). `Vec` is
+        // move-only, so allocate a fresh one per key.
         for &ref_ in module_scope_ref.generated.slice() {
             top_level_symbols_to_parts
                 .put_assume_capacity(ref_, bun_alloc::AstAlloc::vec_from_slice(&[1]));
@@ -338,22 +330,18 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         // For more details on this section, look at js_parser.toAST
         // This is mimicking how it calls ImportScanner
         //
-        // PORT NOTE: Zig duck-typed `ImportScanner.scan(AstBuilder, ...)` and
-        // `ConvertESMExportsForHmr.{convertStmt,finalize}` over `AstBuilder`
-        // via `anytype`. The Rust `ImportScanner` is currently monomorphized
+        // `ImportScanner` is currently monomorphized
         // over the concrete `P<'_, TS, J, SCAN>` parser only (see
         // ImportScanner.rs:30), so the equivalent transform is open-coded here
         // for the stmt shapes `AstBuilder` callers actually emit (`S.Import`,
         // `S.Local{is_export}`, `S.ExportDefault(expr)`). Without this, the
         // generated server-component proxy keeps raw `export` keywords inside
         // the HMR function wrapper and JSC rejects the chunk with
-        // `SyntaxError: Unexpected keyword 'export'`.
-        // TODO(port): replace with a `ParserLike` trait so the real
-        // `ImportScanner`/`ConvertESMExportsForHmr` can accept `AstBuilder`.
+        // `SyntaxError: Unexpected keyword 'export'`. If `ImportScanner` /
+        // `ConvertESMExportsForHmr` ever grow a `ParserLike` host trait, this
+        // open-coded transform can be replaced by the real implementations.
         //
-        // PORT NOTE: Zig assigned `p.stmts.items` directly — its
-        // `ArrayListUnmanaged` storage is owned by `worker.allocator` and
-        // outlives the `AstBuilder` stack value. Rust's `Vec<Stmt>` would
+        // A `Vec<Stmt>` would
         // drop with `self`, leaving `parts[1].stmts` dangling once the
         // builder goes out of scope (UAF in the printer). Copy the `Copy`
         // `Stmt`s/`*mut Scope`s into the bump arena so the returned
@@ -430,8 +418,8 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
                         // (`registerClientReference(...)`), which is not
                         // `canBeMoved()` — generate a temp const binding and
                         // reference it from `export_props`.
-                        // SAFETY: `StmtOrExpr` lives in the arena; bitwise read
-                        // matches Zig's value copy (no Drop fields touched).
+                        // SAFETY: `StmtOrExpr` lives in the arena and has no
+                        // Drop fields, so a bitwise read is a plain value copy.
                         let value = unsafe { core::ptr::read(&raw const st.value) }.to_expr();
                         let temp_id = self.generate_temp_ref(Some(b"default_export"));
                         parts[1].declared_symbols.append(DeclaredSymbol {
@@ -516,12 +504,12 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         } else {
             // Non-HMR path: mirror `ImportScanner.scan(AstBuilder, p, stmts,
             // false, false, {})` for the stmt shapes AstBuilder callers emit
-            // (`S.Import`, `S.Local{is_export}`, `S.ExportDefault`). The Zig
-            // duck-typed scanner is what populates `named_exports` /
+            // (`S.Import`, `S.Local{is_export}`, `S.ExportDefault`). This
+            // scan is what populates `named_exports` /
             // `named_imports` / `import_records_for_current_part`; without it
             // the linker can't bind imports against this generated module
             // (e.g. `import { ssrManifest } from "bun:bake/server"` →
-            // "No matching export"). See PORT NOTE above re: monomorphization.
+            // "No matching export"). See the note above re: monomorphization.
             let in_stmts = core::mem::take(&mut self.stmts);
             for stmt in in_stmts.iter() {
                 match stmt.data {
@@ -569,7 +557,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         );
 
         // SAFETY: module_scope is a live arena allocation. `Scope` is no-Drop
-        // arena POD; Zig bitwise-copied it (`module_scope.*`).
+        // arena POD, so a bitwise read is a plain value copy.
         let module_scope_value: Scope = unsafe { core::ptr::read(module_scope) };
 
         Ok(crate::BundledAst {
@@ -614,7 +602,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
     pub fn generate_temp_ref(&mut self, name: Option<&[u8]>) -> Ref {
         self.new_symbol(SymbolKind::Other, name.unwrap_or(b"temp"))
             .expect("OOM")
-        // Zig: bun.handleOom — Rust aborts on OOM by default; explicit expect for clarity
+        // Rust aborts on OOM by default; explicit expect for clarity
     }
 
     pub fn record_export(&mut self, _loc: Loc, alias: &[u8], ref_: Ref) -> Result<(), OOM> {
@@ -640,7 +628,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         match binding.data {
             B::BMissing(_) => {}
             B::BIdentifier(ident) => {
-                // PORT NOTE: reshaped for borrowck — capture original_name before calling &mut self method
+                // Reshaped for borrowck — capture original_name before calling &mut self method
                 let original_name = self.symbols[ident.r#ref.inner_index() as usize].original_name;
                 self.record_export(binding.loc, original_name.slice(), ident.r#ref)
                     .expect("unreachable");
@@ -664,7 +652,7 @@ impl<'a, 'bump> AstBuilder<'a, 'bump> {
         Output::panic(args);
     }
 
-    /// Zig: `@"module.exports"` — Rust identifiers can't contain `.`
+    /// Builds the `module.exports` member expression.
     pub fn module_exports(&self, loc: Loc) -> Expr {
         self.new_expr(E::Dot {
             name: b"exports".into(),
@@ -683,5 +671,3 @@ use bun_ast::Ref;
 pub use crate::DeferredBatchTask::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/AstBuilder.zig
diff --git a/src/bundler/BundleThread.rs b/src/bundler/BundleThread.rs
index 5e4c689e785..301468e5ea7 100644
--- a/src/bundler/BundleThread.rs
+++ b/src/bundler/BundleThread.rs
@@ -14,13 +14,11 @@ pub(crate) extern "C" fn timer_callback(_: *mut bun_sys::windows::libuv::Timer)
 
 /// Port of `std.Thread.ResetEvent` — single-shot manual-reset event used to
 /// block `spawn()` until the bundle thread has initialized its `Waker`.
-// PORT NOTE: re-export `bun_threading::ResetEvent` (futex-backed); the local
-// `wait()`/`set()`/`Default` API is identical, and the futex impl preserves
-// the "set-before-wait does not deadlock" property the parking_lot draft had.
+// Re-exports `bun_threading::ResetEvent` (futex-backed); the futex impl
+// preserves the "set-before-wait does not deadlock" property `spawn()` relies on.
 pub use bun_threading::ResetEvent;
 
 /// Result of a `Bun.build` invocation handed back to the JS thread.
-// PORT NOTE: mirrors `BundleV2.JSBundleCompletionTask.Result` (bundle_v2.zig).
 // Defined here (not re-exported from `bundle_v2`) because the un-gated
 // `bundle_v2` module keeps the draft body private; T6 (`bundler_jsc`) consumes
 // this via the `CompletionStruct` trait.
@@ -44,7 +42,7 @@ pub enum BundleV2Result {
 ///
 /// - `configureBundler` is used to configure `Bundler`.
 /// - `completeOnBundleThread` is used to tell the task that it is done.
-// PORT NOTE: trait bound lives on the `impl` (not the struct) so the
+// The trait bound lives on the `impl` (not the struct) so the
 // `singleton` static can name `BundleThread<JSBundleCompletionTask>` before T6
 // provides the `CompletionStruct` impl for the forward-decl.
 pub struct BundleThread<C: Node> {
@@ -56,49 +54,34 @@ pub struct BundleThread<C: Node> {
     pub generation: bun_core::Generation,
 }
 
-/// Trait capturing the interface the Zig `CompletionStruct: type` parameter
-/// must satisfy.
+/// Trait capturing the interface a completion task must satisfy.
 ///
-/// Zig used comptime duck typing and additionally asserted (via `@compileError`)
-/// that the *only* valid instantiation is `BundleV2.JSBundleCompletionTask`.
-/// The body of `generateInNewThread` directly touched JSBundleCompletionTask
-/// fields (`.result`, `.log`, `.plugins`, `.config.files`, `.transpiler`); in
-/// Rust those become trait accessors so the generic `BundleThread<C>` stays
+/// The trait accessors keep the generic `BundleThread<C>`
 /// layout-agnostic. The concrete impl lives in T6 (`bun_bundler_jsc`).
 pub trait CompletionStruct: Node + Send + 'static {
-    /// Zig: `completion.configureBundler(transpiler, arena)` — `arena`
-    /// is the per-build mimalloc heap that backs `transpiler`, so the two
-    /// share lifetime `'a` (option fields like `optimize_imports: &'a StringSet`
-    /// borrow from `bump`).
+    /// `bump` is the per-build mimalloc heap that backs `transpiler`, so the
+    /// two share lifetime `'a` (option fields like `optimize_imports: &'a
+    /// StringSet` borrow from `bump`).
     fn configure_bundler<'a>(
         &mut self,
         transpiler: &mut Transpiler<'a>,
         bump: &'a Arena,
     ) -> Result<(), bun_core::Error>;
-    /// Zig: `completion.completeOnBundleThread()`
     fn complete_on_bundle_thread(&mut self);
-    /// Zig: `completion.result = .{ .err | .value }`
     fn set_result(&mut self, result: BundleV2Result);
-    /// Zig: `completion.log = out_log`
     fn set_log(&mut self, log: bun_ast::Log);
-    /// Zig: `completion.transpiler = this`
     fn set_transpiler(&mut self, this: *mut BundleV2<'_>);
-    /// Zig: `completion.plugins`
     fn plugins(&self) -> Option<NonNull<JSBundlerPlugin>>;
-    /// Zig: `if (completion.config.files.map.count() > 0) &completion.config.files else null`
-    /// — folded into a single accessor so the opaque `FileMap` layout stays in T6.
+    /// Returns the file map if non-empty; a single accessor so the opaque
+    /// `FileMap` layout stays in T6.
     fn file_map(&mut self) -> Option<NonNull<FileMap>>;
-    /// Zig: `switch (CompletionStruct) { BundleV2.JSBundleCompletionTask => completion, … }`
-    /// — the comptime type-switch collapses to a §Dispatch handle (erased
-    /// owner + `&'static` vtable) the impl provides, so the bundler can read
-    /// `result == .err` / `jsc_event_loop.enqueueTaskConcurrent` without
-    /// naming the concrete struct.
+    /// Returns a §Dispatch handle (erased owner + `&'static` vtable) the impl
+    /// provides, so the bundler can read `result == .err` /
+    /// `jsc_event_loop.enqueueTaskConcurrent` without naming the concrete
+    /// struct.
     fn as_js_bundle_completion_task(&mut self) -> dispatch::CompletionHandle;
 
-    /// Zig: `const transpiler = try arena.create(bun.Transpiler);` followed by
-    /// `try completion.configureBundler(transpiler, arena);` — Zig left the
-    /// `Transpiler` `undefined` and let `configureBundler` initialize it in place.
-    /// Rust's `Transpiler<'a>` has borrow-carrying fields (`arena: &'a Arena`,
+    /// `Transpiler<'a>` has borrow-carrying fields (`arena: &'a Arena`,
     /// `resolver: Resolver<'a>`) that cannot be zero-init'd, so the allocate +
     /// configure pair is folded into one trait call returning the
     /// arena-allocated, fully-configured transpiler.
@@ -111,16 +94,10 @@ pub trait CompletionStruct: Node + Send + 'static {
         bump: &'a Arena,
     ) -> Result<&'a mut Transpiler<'a>, bun_core::Error>;
 
-    /// Zig: `try BundleV2.init(transpiler, null, arena, jsc.AnyEventLoop.init(arena),
-    /// false, jsc.WorkPool.get(), heap)` → wire `this.{plugins,completion,file_map}`
-    /// from `self` → `completion.transpiler = this` → `this.runFromJSInNewThread(...)`
-    /// → on success `self.set_result(Value(..))` → `this.deinitWithoutFreeingArena()`;
-    /// on error drain `this.linker.source_maps.*_wait_group` then deinit.
+    /// Constructs the `BundleV2`, wires `plugins`/`completion`/`file_map`,
+    /// and runs the bundle.
     ///
-    /// PORT NOTE: the `BundleV2` impl does not yet expose `init` /
-    /// `run_from_js_in_new_thread` (pending the linker pipeline). The Zig
-    /// `@compileError` already
-    /// proves this body is `JSBundleCompletionTask`-specific, so the
+    /// This body is `JSBundleCompletionTask`-specific, so the
     /// construction + run is delegated to the trait impl in T6, which has
     /// access to the concrete event-loop / work-pool wiring. The shared
     /// scaffolding (arena, AST arena push/pop, log copy,
@@ -138,24 +115,16 @@ pub trait CompletionStruct: Node + Send + 'static {
 
 impl<C: CompletionStruct> BundleThread<C> {
     /// To initialize, put this somewhere in memory, and then call `spawn()`
-    // PORT NOTE: Zig `uninitialized` left `waker` as `undefined`. We can't use
-    // `mem::zeroed()` here — on macOS `Waker` holds a `Box<[u8]>` and on
-    // Windows a `&'static` loop, both of which have a NonNull validity
-    // invariant (zeroing them is *language-level* UB even if never read).
+    // We can't use
+    // `mem::zeroed()` here — the platform `Waker`s hold NonNull-validity
+    // fields (a `Box<[u8]>` on macOS, a niche-optimised `Option<BackRef>` on
+    // Windows), so zeroing them is *language-level* UB even if never read.
     // `placeholder()` yields a fully-initialized inert value instead.
     // `ready_event.wait()` in `spawn()` blocks until `thread_main` overwrites
     // it via `ptr::write`, so the placeholder is never observed live.
     pub fn uninitialized() -> Self {
         Self {
-            #[cfg(unix)]
             waker: Async::Waker::placeholder(),
-            #[cfg(windows)]
-            // TODO(port,windows): `Waker { loop_: &'static _ }` is also
-            // NonNull; provide a `placeholder()` once the Windows event-loop
-            // port lands. Kept as-is here to avoid an untestable change.
-            // SAFETY: see TODO — this is technically invalid_value UB on
-            // Windows; the field is overwritten before any read.
-            waker: unsafe { bun_core::ffi::zeroed_unchecked() },
             queue: UnboundedQueue::new(),
             generation: 0,
             ready_event: ResetEvent::default(),
@@ -168,8 +137,8 @@ impl<C: CompletionStruct> BundleThread<C> {
     /// `*instance`; callers must only touch it via the raw-pointer methods on this
     /// impl (e.g. `enqueue`) and never materialize a `&mut Self`.
     pub unsafe fn spawn(instance: *mut Self) -> std::io::Result<std::thread::JoinHandle<()>> {
-        // PORT NOTE: `std.Thread.spawn(.{}, threadMain, .{instance})` →
-        // `std::thread::Builder` so the spawn error is surfaced (Zig used `try`).
+        // `std::thread::Builder` (not `std::thread::spawn`) so the spawn error
+        // is surfaced to the caller.
         struct SendPtr<T>(*mut T);
         // SAFETY: the pointer is only dereferenced on the bundle thread via raw
         // projections; `BundleThread<C>` itself is never moved across threads.
@@ -225,12 +194,11 @@ impl<C: CompletionStruct> BundleThread<C> {
         // SAFETY: raw-ptr field projection; spawning thread is blocked in `ready_event.wait()`.
         unsafe { (*instance).ready_event.set() };
 
-        // PORT NOTE: libuv Timer lives on stack for the lifetime of this never-returning fn.
+        // The libuv Timer lives on stack for the lifetime of this never-returning fn.
         // It MUST be declared at function scope (not inside the `#[cfg(windows)] { ... }`
         // block below) because `timer.init()`/`timer.start()` register `&timer`'s address
         // into the uv loop's intrusive handle queue / timer min-heap, and `waker.wait()`
-        // (→ `uv_run`) in the `loop {}` below dereferences that address. Matches Zig spec
-        // (BundleThread.zig:77) which hoists `var timer` to `threadMain` scope.
+        // (→ `uv_run`) in the `loop {}` below dereferences that address.
         #[cfg(windows)]
         let mut timer: bun_sys::windows::libuv::Timer = bun_core::ffi::zeroed();
         #[cfg(windows)]
@@ -258,8 +226,8 @@ impl<C: CompletionStruct> BundleThread<C> {
                 // SAFETY: `generation` is only read/written on this (bundle) thread.
                 let generation = unsafe { (*instance).generation };
                 // `panic = "abort"` → a Rust panic on this thread enters the
-                // crash-handler hook and aborts the whole process (matching Zig's
-                // `@panic`). No `catch_unwind` — there is nothing to catch.
+                // crash-handler hook and aborts the whole process.
+                // No `catch_unwind` — there is nothing to catch.
                 match Self::generate_in_new_thread(completion, generation) {
                     Ok(()) => {}
                     Err(err) => {
@@ -290,8 +258,6 @@ impl<C: CompletionStruct> BundleThread<C> {
         completion: &mut C,
         generation: bun_core::Generation,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: `ThreadLocalArena.init()` → `bun_alloc::Arena::new()` (bumpalo
-        // bump arena; `defer heap.deinit()` is handled by Drop).
         let heap = Arena::new();
 
         let bump = &heap;
@@ -300,18 +266,14 @@ impl<C: CompletionStruct> BundleThread<C> {
         ast_memory_store.reset();
         ast_memory_store.push();
 
-        // Zig: `const transpiler = try arena.create(bun.Transpiler);`
-        //      `try completion.configureBundler(transpiler, arena);`
-        // Folded — see `create_and_configure_transpiler` doc.
+        // Allocate + configure folded — see `create_and_configure_transpiler` doc.
         let transpiler = completion.create_and_configure_transpiler(bump)?;
 
         transpiler.resolver.generation = generation;
 
-        // Zig: `const this = try BundleV2.init(transpiler, null, arena,
-        //       jsc.AnyEventLoop.init(arena), false, jsc.WorkPool.get(), heap);`
-        // followed by field wiring + `runFromJSInNewThread`. Delegated — see
+        // Construction + run delegated — see
         // `init_and_run` doc. Reborrow `transpiler` through a raw ptr so
-        // `completion` can be borrowed again below (Zig stored `*Transpiler`).
+        // `completion` can be borrowed again below.
         let transpiler_ptr: *mut Transpiler<'_> = transpiler;
         let run = completion.init_and_run(
             // SAFETY: `transpiler` lives in `bump` for the duration of `heap`.
@@ -322,9 +284,7 @@ impl<C: CompletionStruct> BundleThread<C> {
             std::ptr::from_ref(bun_threading::work_pool::WorkPool::get()).cast_mut(),
         );
 
-        // PORT NOTE: Zig's overlapping `defer { ast_memory_store.pop();
-        // this.deinitWithoutFreeingArena(); }` + `errdefer { wait_groups; copy log }`
-        // captured ≥2 disjoint &mut borrows. Restructured as straight-line: log copy
+        // Straight-line teardown: log copy
         // runs on both paths; `completeOnBundleThread` only on success (the error
         // path's `set_result(Err)` + complete happens in `thread_main`). The
         // `deinitWithoutFreeingArena` + wait-group drain live inside `init_and_run`
@@ -333,7 +293,7 @@ impl<C: CompletionStruct> BundleThread<C> {
         // SAFETY: `transpiler.log` is the arena-allocated `*mut Log` set up by
         // `configure_bundler`; valid for the lifetime of `heap`. Raw deref so the
         // `&'a mut Transpiler` consumed by `init_and_run` above is not reborrowed.
-        let _ = unsafe { (*(*transpiler_ptr).log).append_to_with_recycled(&mut out_log, true) }; // logger OOM-only (Zig: catch unreachable)
+        let _ = unsafe { (*(*transpiler_ptr).log).append_to_with_recycled(&mut out_log, true) }; // logger OOM-only
         completion.set_log(out_log);
 
         if run.is_ok() {
@@ -342,11 +302,9 @@ impl<C: CompletionStruct> BundleThread<C> {
 
         ast_memory_store.pop();
 
-        // Zig allocated `transpiler` / `ast_memory_store` from the arena and
-        // relied on `defer heap.deinit()` to bulk-free them. That works there
-        // because every container they hold (`Resolver` caches, `BundleOptions`
-        // strings, the AST allocator's own `mi_heap` handle, …) is itself
-        // arena-backed. The Rust port replaced those containers with global-heap
+        // `transpiler` / `ast_memory_store` are arena-allocated, but their
+        // containers (`Resolver` caches, `BundleOptions` strings, the AST
+        // allocator's own `mi_heap` handle, …) live on the global heap as
         // `Vec`/`Box`/`HashMap`, so dropping `heap` (`mi_heap_destroy`) reclaims
         // the struct bytes but never runs `Transpiler::drop` /
         // `ASTMemoryAllocator::drop` — leaking the resolver's directory/file
@@ -375,11 +333,10 @@ impl<C: CompletionStruct> BundleThread<C> {
 
 /// Lazily-initialized singleton. This is used for `Bun.build` since the
 /// bundle thread may not be needed.
-// PORT NOTE: Zig had a per-monomorphization `singleton` struct with
-// `static var instance`. Rust forbids generic statics, so the storage is
+// Rust forbids generic statics, so the storage is
 // type-erased (`*mut ()`) and the accessor functions are generic over `C`.
-// The Zig source already `@compileError`s for any `CompletionStruct` other than
-// `JSBundleCompletionTask`, so in practice exactly one `C` is ever used and the
+// In practice exactly one `C` (`JSBundleCompletionTask`) is ever used — see
+// `get`'s safety contract — so the
 // erased static is sound. T6 (`bun_bundler_jsc`) calls these with its concrete
 // completion-task type.
 pub mod singleton {
@@ -422,7 +379,7 @@ pub mod singleton {
 
     /// Returns the raw singleton pointer. The bundle thread runs `thread_main`
     /// against this allocation for the process lifetime, so callers MUST NOT
-    /// materialize `&mut BundleThread` from it (Zig `*Self` aliasing semantics).
+    /// materialize `&mut BundleThread` from it.
     /// Use `BundleThread::enqueue(get(), ...)` instead.
     ///
     /// # Safety
@@ -453,5 +410,3 @@ pub mod singleton {
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/BundleThread.zig
diff --git a/src/bundler/Cargo.toml b/src/bundler/Cargo.toml
index 8da369721f5..9c1828e5dfd 100644
--- a/src/bundler/Cargo.toml
+++ b/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.
diff --git a/src/bundler/Chunk.rs b/src/bundler/Chunk.rs
index cb06d1ec675..5b44fc174a2 100644
--- a/src/bundler/Chunk.rs
+++ b/src/bundler/Chunk.rs
@@ -8,7 +8,7 @@ use bun_ast::{ImportKind, ImportRecord};
 use bun_ast::{Ref, Stmt};
 use bun_collections::{ArrayHashMap, AutoBitSet, VecExt};
 use bun_core::{FeatureFlags, Output};
-// PORT NOTE: `bun.ast.Index` is mirrored as both `crate::Index`
+// Note: `bun.ast.Index` is mirrored as both `crate::Index`
 // (`bun_ast::Index`) and `bun_ast::Index` via a
 // TYPE_ONLY split. `CssImportOrderKind::SourceIndex` carries the js_parser
 // flavor because its sole producer (`findImportedFilesInCSSOrder`) constructs
@@ -36,9 +36,12 @@ pub struct ChunkImport {
     pub import_kind: ImportKind,
 }
 
-// TODO(port): arena lifetime — string/slice fields below borrow from the bundler arena
-// (no deinit in Zig). Currently uses &'static [u8] / Box<[T]> as placeholders;
-// should thread a `'bump` lifetime or use arena slice newtypes.
+// Lifetime note: string/slice fields below conceptually borrow from the
+// bundler arena. The borrow is erased to
+// `&'static [u8]` (the arena is owned by `BundleV2` and outlives every
+// `Chunk`; see the lifetime-erasure note on `LinkerGraph::bump`) or owns a
+// `Box<[T]>` instead of threading a `'bump` lifetime through the chunk
+// pipeline.
 pub struct Chunk {
     /// This is a random string and is used to represent the output path of this
     /// chunk before the final output path has been computed. See OutputPiece
@@ -56,9 +59,7 @@ pub struct Chunk {
     /// We must not keep pointers to this type until all chunks have been allocated.
     pub entry_bits: AutoBitSet,
 
-    /// PORT NOTE: Zig stored this as an arena-owned `[]const u8` (linker arena);
-    /// the Rust `Chunk` owns it as a `Box<[u8]>` so dropping the chunk slice
-    /// frees it (matches `c.arena().dupe(u8, ..)` ownership without leaking).
+    /// Owned as a `Box<[u8]>` so dropping the chunk slice frees it.
     pub final_rel_path: Box<[u8]>,
     /// The path template used to generate `final_rel_path`
     pub template: PathTemplate,
@@ -75,17 +76,15 @@ pub struct Chunk {
     pub intermediate_output: IntermediateOutput,
     pub isolated_hash: u64,
 
-    // TODO(port): was `= undefined` in Zig (set before use). The Zig field is
-    // the `renamer.Renamer` union; the Rust enum borrows from the symbol table
-    // (`Renamer<'r,'src>`), which can't live in a 'static-ish struct yet.
-    // `ChunkRenamer` is an owned-erased placeholder (see `crate::bun_renamer`).
+    // Set before use. The borrowed enum (`Renamer<'r,'src>`)
+    // borrows from the symbol table and so can't live in this owning struct.
+    // `ChunkRenamer` is the owning equivalent (see `crate::bun_renamer`).
     pub renamer: bun_renamer::ChunkRenamer,
 
     pub compile_results_for_chunk: CompileResultSlots,
 
     /// Pre-built JSON fragment for this chunk's metafile output entry.
     /// Generated during parallel chunk generation, joined at the end.
-    /// PORT NOTE: owned `Box<[u8]>` (was arena-owned `[]const u8` in Zig).
     pub metafile_chunk_json: Box<[u8]>,
 
     /// Pack boolean flags to reduce padding overhead.
@@ -113,8 +112,8 @@ impl Default for Content {
 // `computeCrossChunkDependencies`, `generateChunksInParallel`). Raw-pointer
 // fields (`Layers::Borrowed`, `ChunkRenamer` arena)
 // point into bundler-arena storage that outlives the
-// pool join and is only mutated by the owning task. Zig has no Send/Sync
-// distinction; mirror `InputFile`'s blanket impls (bundle_v2.rs).
+// pool join and is only mutated by the owning task; this mirrors
+// `InputFile`'s blanket impls (bundle_v2.rs).
 //
 // CONCURRENCY: during the `generate_compile_result_for_*_chunk` fan-out, many
 // `PendingPartRange` tasks share ONE `*mut Chunk` and each writes a disjoint
@@ -122,10 +121,10 @@ impl Default for Content {
 // (UnsafeCell-per-slot) so the per-task write is routed through interior
 // mutability and never requires an aliased `&mut Chunk` /
 // `&mut [CompileResult]` — see [`Chunk::write_compile_result_slot`].
-// `files_with_parts_in_chunk` values are bumped via atomic RMW (Zig
-// `@atomicRmw`); the renamer is fully populated before fan-out and treated as
+// `files_with_parts_in_chunk` values are bumped via atomic RMW;
+// the renamer is fully populated before fan-out and treated as
 // read-only by the printer.
-// TODO(ub-audit): `Renamer<'r>` still borrows `&'r mut {Number,Minify}Renamer`,
+// Caveat: `Renamer<'r>` still borrows `&'r mut {Number,Minify}Renamer`,
 // so the per-chunk renamer is reborrowed mutably from each part-range task;
 // the printer never writes through it, but the borrow should become `&'r`.
 unsafe impl Send for Chunk {}
@@ -134,11 +133,11 @@ unsafe impl Send for Chunk {}
 // `files_with_parts_in_chunk` atomic counters; the remaining fields are
 // frozen before fan-out and read single-threaded after the pool join —
 // **except** `renamer`, which the per-part-range printer reborrows `&mut`
-// from each worker (read-only in practice). See `TODO(ub-audit)` above:
+// from each worker (read-only in practice). See the renamer caveat above:
 // once `Renamer<'r>` borrows `&'r` instead of `&'r mut`, this caveat (and
 // the matching split-borrow in `generate_compile_result_for_js_chunk`) goes
 // away. Pre-existing; this impl mirrors `unsafe impl Send for Chunk` and
-// the Zig single-pointer fan-out it ports.
+// the single-pointer fan-out the workers use.
 unsafe impl Sync for Chunk {}
 
 /// Disjoint-slot output buffer for [`Chunk::compile_results_for_chunk`].
@@ -182,6 +181,14 @@ impl CompileResultSlots {
         // SAFETY: reads happen only after the pool join; no concurrent writer.
         self.0.iter().map(|c| unsafe { &*c.get() })
     }
+
+    /// Post-join exclusive access to one slot (e.g. to transfer ownership of
+    /// the result out of the chunk). `&mut self` proves no concurrent writer,
+    /// so `UnsafeCell::get_mut` needs no unsafe here.
+    #[inline]
+    pub fn get_mut(&mut self, i: usize) -> &mut CompileResult {
+        self.0[i].get_mut()
+    }
 }
 
 impl core::ops::Index<usize> for CompileResultSlots {
@@ -198,7 +205,6 @@ impl Default for Chunk {
         Chunk {
             unique_key: b"",
             files_with_parts_in_chunk: ArrayHashMap::new(),
-            // Zig: `entry_bits: AutoBitSet = undefined` — static-arm zero init.
             entry_bits: AutoBitSet::init_empty(0).expect("static AutoBitSet"),
             final_rel_path: Box::default(),
             template: PathTemplate::default(),
@@ -293,8 +299,7 @@ impl Chunk {
         // Look up the CSS chunk via the JS chunk's css_chunks indices.
         // This correctly handles deduplicated CSS chunks that are shared
         // across multiple HTML entry points (see issue #23668).
-        // PORT NOTE: reshaped for borrowck — Zig calls getJSChunkForHTML(chunks) and then
-        // indexes into the same `chunks`. Here we scan immutably for the JS chunk, copy the
+        // Note: reshaped for borrowck — we scan immutably for the JS chunk, copy the
         // css-chunk index into a local, drop the borrow, then re-borrow mutably.
         let entry_point_id = self.entry_point.entry_point_id();
         let css_idx: Option<usize> = 'find: {
@@ -347,7 +352,6 @@ impl Order {
     /// equidistant to an entry point, then break the tie by sorting on the
     /// stable source index derived from the DFS over all entry points.
     pub(crate) fn sort(a: &mut [Order]) {
-        // std.sort.pdq → unstable sort
         a.sort_unstable_by(|a, b| {
             if Order::less_than(Order::default(), *a, *b) {
                 core::cmp::Ordering::Less
@@ -385,9 +389,7 @@ pub enum IntermediateOutput {
 /// Owns the joined output buffer alongside the `OutputPiece` slices that
 /// point into it.
 ///
-/// PORT NOTE: In Zig, `breakOutputIntoPieces` calls `j.done(alloc)` with the
-/// per-worker arena, so the joined buffer outlives the chunk by construction
-/// and `OutputPiece.data` stays valid. The Rust `StringJoiner::done()`
+/// Note: `StringJoiner::done()`
 /// returns a `Box<[u8]>`; if that box is dropped at the end of
 /// `break_output_into_pieces`, every piece's `data` slice dangles (ASAN
 /// use-after-poison in `generate_isolated_hash`). Keep the box alive next to
@@ -425,18 +427,16 @@ pub struct CodeResult {
     pub shifts: Vec<source_map::SourceMapShifts>,
 }
 
-// PORT NOTE: Zig used `std.mem.Allocator`; the Rust crate exposes a global
-// mimalloc — we don't need a vtable here yet. `()` is kept as a token so the
-// caller's `Option<&DynAlloc>` plumbing matches the Zig signature; the actual
+// We don't need an allocator vtable here yet. `()` is kept as a token for the
+// caller's `Option<&DynAlloc>` plumbing; the actual
 // allocation goes through `alloc_buf` (global mimalloc) regardless. Real
 // arena threading (page_allocator vs default_allocator) lands when
 // `bun_alloc::Allocator` is a stable trait object.
 type DynAlloc = ();
 
-/// `arena.alloc(u8, n)` — until `DynAlloc` is a real trait object, route
-/// through the global arena. PERF(port): Zig picked page_allocator for
-/// `n >= 512KiB`; mimalloc handles large allocations via mmap already so this
-/// is a behavior match in practice.
+/// Until `DynAlloc` is a real trait object, route
+/// through the global arena; mimalloc handles large allocations via mmap
+/// already.
 #[inline]
 fn alloc_buf(_arena: DynAlloc, n: usize) -> Result<Box<[u8]>, AllocError> {
     // Zero-fill is required for soundness: `set_len` over uninit bytes violates
@@ -449,9 +449,9 @@ fn alloc_buf(_arena: DynAlloc, n: usize) -> Result<Box<[u8]>, AllocError> {
     Ok(v.into_boxed_slice())
 }
 
-/// Extract the `OutputFile` index from a trailing `AdditionalFile` entry.
-/// Zig: `files.last().output_file` (untagged-union field read; bundler always
-/// pushes `.output_file = …` for asset additional-files, see bundle_v2.zig).
+/// Extract the `OutputFile` index from a trailing `AdditionalFile` entry
+/// (the bundler always pushes `.output_file = …` for asset additional-files,
+/// see bundle_v2.rs).
 #[inline]
 fn additional_output_file_index(f: &AdditionalFile) -> usize {
     match *f {
@@ -464,8 +464,8 @@ fn additional_output_file_index(f: &AdditionalFile) -> usize {
 
 impl IntermediateOutput {
     pub fn allocator_for_size(_size: usize) -> &'static DynAlloc {
-        // PERF(port): Zig picks page_allocator for large buffers vs mimalloc default.
-        // TODO(port): expose page_allocator / default_allocator as &'static dyn Allocator
+        // mimalloc serves large allocations via mmap already, so the global
+        // allocator suffices (see `alloc_buf`).
         &()
     }
 
@@ -544,13 +544,13 @@ impl IntermediateOutput {
         parse_graph: &Graph,
         linker_graph: &LinkerGraph<'_>,
         import_prefix: &[u8],
-        // PORT NOTE: Zig passed `*Chunk` / `[]Chunk` (freely aliased — `chunk`
-        // is `&chunks[i]`). The body only reads both, so take `&` to avoid
+        // Note: `chunk` aliases `&chunks[i]`. The body only reads both, so
+        // take `&` to avoid
         // overlapping `&mut Chunk` + `&mut [Chunk]` UB at every call site.
         chunk: &Chunk,
         chunks: &[Chunk],
-        // PORT NOTE: `?*usize` in Zig — accept both `&mut usize` and
-        // `Option<&mut usize>` so call sites that ported either way compile.
+        // Accept both `&mut usize` and
+        // `Option<&mut usize>` so call sites spelled either way compile.
         display_size: impl Into<Option<&'d mut usize>>,
         force_absolute_path: bool,
         enable_source_map_shifts: bool,
@@ -595,11 +595,11 @@ impl IntermediateOutput {
         parse_graph: &Graph,
         linker_graph: &LinkerGraph<'_>,
         import_prefix: &[u8],
-        // See `code()` PORT NOTE — `chunk` aliases `chunks[i]`; body is read-only.
+        // See `code()` note — `chunk` aliases `chunks[i]`; body is read-only.
         chunk: &Chunk,
         chunks: &[Chunk],
-        // PORT NOTE: `?*usize` in Zig — accept both `&mut usize` and
-        // `Option<&mut usize>` so call sites that ported either way compile.
+        // Accept both `&mut usize` and
+        // `Option<&mut usize>` so call sites spelled either way compile.
         display_size: impl Into<Option<&'d mut usize>>,
         force_absolute_path: bool,
         enable_source_map_shifts: bool,
@@ -640,7 +640,7 @@ impl IntermediateOutput {
         graph: &Graph,
         linker_graph: &LinkerGraph<'_>,
         import_prefix: &[u8],
-        // See `code()` PORT NOTE — `chunk` aliases `chunks[i]`; body is read-only.
+        // See `code()` note — `chunk` aliases `chunks[i]`; body is read-only.
         chunk: &Chunk,
         chunks: &[Chunk],
         display_size: Option<&mut usize>,
@@ -671,7 +671,6 @@ impl IntermediateOutput {
                 };
 
                 if ENABLE_SOURCE_MAP_SHIFTS {
-                    // PERF(port): was assume_capacity
                     shifts.push(shift);
                 }
 
@@ -851,7 +850,6 @@ impl IntermediateOutput {
                                             _ => {}
                                         }
                                         shift.after.advance(content);
-                                        // PERF(port): was assume_capacity
                                         shifts.push(shift);
                                     }
                                     // For chunk content, escape closing tags (</script, </style)
@@ -925,7 +923,6 @@ impl IntermediateOutput {
 
                                     if ENABLE_SOURCE_MAP_SHIFTS {
                                         shift.before.advance(chunk.unique_key);
-                                        // PERF(port): was assume_capacity
                                         shifts.push(shift);
                                     }
                                     continue;
@@ -934,8 +931,7 @@ impl IntermediateOutput {
                             };
 
                             // normalize windows paths to '/'
-                            // Zig does `@constCast(file_path)` and mutates the bundler-owned
-                            // storage in place. In Rust the source slices are reachable only
+                            // The source slices are reachable only
                             // through `&Graph` / `&[Chunk]` here; materialising `&mut` from a
                             // shared-provenance pointer is UB regardless of whether the write
                             // happens. Copy into a pooled scratch buffer and normalise that.
@@ -979,7 +975,6 @@ impl IntermediateOutput {
                             }
 
                             if ENABLE_SOURCE_MAP_SHIFTS {
-                                // PERF(port): was assume_capacity
                                 shifts.push(shift);
                             }
                         }
@@ -1026,7 +1021,6 @@ impl IntermediateOutput {
                 let buffer = 'brk: {
                     if ENABLE_SOURCE_MAP_SHIFTS && FeatureFlags::SOURCE_MAP_DEBUG_ID {
                         // This comment must go before the //# sourceMappingURL comment
-                        // TODO(port): graph.heap.arena() — arena arena from Graph
                         let mut debug_id_fmt = Vec::new();
                         write!(
                             &mut debug_id_fmt,
@@ -1037,7 +1031,7 @@ impl IntermediateOutput {
                         )
                         .ok();
 
-                        let _ = arena; // PORT NOTE: StringJoiner::done* allocates from global mimalloc; arena token is plumbing-only.
+                        let _ = arena; // Note: StringJoiner::done* allocates from global mimalloc; arena token is plumbing-only.
                         break 'brk joiner.done_with_end(&debug_id_fmt)?;
                     }
 
@@ -1072,7 +1066,7 @@ impl IntermediateOutput {
 /// An output piece is the concatenation of source code text and an output
 /// path, in that order. An array of pieces makes up an entire file.
 ///
-/// PORT NOTE: Zig split ptr+u32 len to shave 8 bytes. The Rust port stores a
+/// Note: stores a
 /// `RawSlice` (encapsulates the unsafe re-borrow) — the per-chunk piece count
 /// is bounded by the number of unique-key boundaries, so the extra word per
 /// piece is negligible against the safety win.
@@ -1118,8 +1112,8 @@ impl Query {
 
     #[inline]
     pub fn kind(self) -> QueryKind {
-        // Zig `enum(u3)` type-checks the field on assignment so 5..=7 are
-        // unrepresentable; match exhaustively (out-of-range tag would be UB).
+        // Tags 5..=7 are never assigned; match exhaustively
+        // (an out-of-range tag would be a bug, not UB).
         match (self.0 >> 29) as u8 {
             0 => QueryKind::None,
             1 => QueryKind::Asset,
@@ -1181,8 +1175,7 @@ pub(crate) const UNIQUE_KEY_LEN: usize = UNIQUE_KEY_PREFIX_LEN + 1 + 8;
 /// 25-byte unique-key wire format `{hex16(prefix)}{KIND}{index:08}` shared by
 /// every emitter (ParseTask file/napi/sqlite loaders, server-component
 /// boundaries, HTML-import manifest, chunk IDs) and consumed by exactly one
-/// scanner (`LinkerContext::break_output_into_pieces`). Mirrors Zig
-/// `"{f}{LETTER}{d:0>8}"` with `bun.fmt.hexIntLower` byte-for-byte.
+/// scanner (`LinkerContext::break_output_into_pieces`).
 #[derive(Clone, Copy)]
 pub(crate) struct UniqueKey {
     pub prefix: u64,
@@ -1249,7 +1242,6 @@ impl EntryPoint {
         (self.0 >> 63) & 1 != 0
     }
 
-    // Zig callers mutate packed fields directly (e.g. `chunk.entry_point.is_entry_point = true`).
     #[inline]
     pub fn set_source_index(&mut self, v: u32) {
         self.0 = (self.0 & !0xFFFF_FFFF) | (v as u64);
@@ -1279,7 +1271,9 @@ pub struct JavaScriptChunk {
     pub parts_in_chunk_in_order: Box<[PartRange]>,
 
     // for code splitting
-    // TODO(port): Zig uses ArrayHashMapUnmanaged(Ref, string, Ref.ArrayHashCtx, false) — custom hash ctx
+    // The map hashes via `Ref`'s `Hash` impl. Values
+    // are `&'static`-erased slices into bundler-owned storage (see the
+    // lifetime note on `Chunk`).
     pub exports_to_other_chunks: ArrayHashMap<Ref, &'static [u8]>,
     pub imports_from_other_chunks: ImportsFromOtherChunks,
     pub cross_chunk_prefix_stmts: Vec<Stmt>,
@@ -1313,7 +1307,7 @@ pub struct CssChunk {
 
 impl Drop for CssChunk {
     fn drop(&mut self) {
-        // Zig `asts: []BundlerStyleSheet` is an arena slice of bitwise shallow
+        // `asts` is a slice of bitwise shallow
         // copies (see `prepareCssAstsForChunk` `ptr::read`). Multiple slots may
         // alias the same source AST's heap buffers when a file is imported more
         // than once, so element-wise drop would double-free.
@@ -1323,10 +1317,8 @@ impl Drop for CssChunk {
     }
 }
 
-/// Zig: `const CssImportKind = enum { source_index, external_path, import_layers }` is the
-/// (private) tag enum for `CssImportOrder.kind: union(enum) { ... }`. In Rust the tagged
-/// union is `CssImportOrderKind`; callers that switch on `css_import.kind` reference it via
-/// the Zig-spelled name, so re-export it here.
+/// Alias for `CssImportOrderKind`; callers that switch on `css_import.kind`
+/// reference it via this name, so re-export it here.
 pub type CssImportKind = CssImportOrderKind;
 
 pub struct CssImportOrder {
@@ -1364,11 +1356,11 @@ pub enum CssImportOrderKind {
     SourceIndex(Index),
 }
 
-// TODO(port): bun.ptr.Cow(Vec<LayerName>, { copy = deepCloneInfallible, deinit = clearAndFree })
-// LayerName payload allocations live in the arena, so the Zig deinit is a shallow clearAndFree.
-// `std::borrow::Cow<'_, Vec<_>>` requires `Vec: Clone` (not implemented). Port the
-// Zig `bun.ptr.Cow` shape directly: a tag + raw pointer for the borrowed arm. Should
-// thread `'bump` (arena-borrowed) and confirm Clone semantics match deepCloneInfallible.
+// Copy-on-write list of layer names.
+// `std::borrow::Cow<'_, Vec<_>>` requires `Vec: Clone` (not implemented), so this
+// is a hand-rolled Cow: a tag + raw pointer for the borrowed
+// arm. LayerName payload allocations live in the arena, so dropping the owned
+// arm is a shallow free and `to_owned` deep-clones element-wise.
 pub enum Layers {
     /// Borrowed from another `CssImportOrder`'s `Layers` or the parsed stylesheet.
     Borrowed(bun_ptr::BackRef<Vec<bun_css::LayerName>>),
@@ -1384,28 +1376,28 @@ impl Layers {
         }
     }
 
-    /// Zig: `Chunk.CssImportOrder.Layers.borrow(ptr)` — Cow::Borrowed.
+    /// Cow::Borrowed constructor.
     ///
     /// Takes `NonNull` (not `&Vec`) because the sole caller in
     /// `findImportedFilesInCSSOrder.rs` type-puns the lifetime-erased shadow
     /// `crate::bun_css::LayerName` to the real `::bun_css::LayerName` via a
     /// raw-pointer cast — that nominal-type erasure cannot go through `&`.
     /// The pointee is arena-owned storage that outlives the chunk pipeline
-    /// (see TODO(port) above re: `'bump`); `BackRef` encapsulates that
+    /// (see the lifetime note on `Chunk`); `BackRef` encapsulates that
     /// invariant so `inner()`/`to_owned()` deref sites are safe.
     #[inline]
     pub(crate) fn borrow(p: core::ptr::NonNull<Vec<bun_css::LayerName>>) -> Self {
         Layers::Borrowed(bun_ptr::BackRef::from(p))
     }
 
-    /// Zig: `bun.ptr.Cow.replace` — drop owned (arena-backed, so no-op) and
+    /// Drop owned (arena-backed, so no-op) and
     /// install a fresh owned value.
     #[inline]
     pub(crate) fn replace(&mut self, new: Vec<bun_css::LayerName>) {
         *self = Layers::Owned(new);
     }
 
-    /// Zig: `bun.ptr.Cow.toOwned` — if borrowed, deep-clone into an owned
+    /// If borrowed, deep-clone into an owned
     /// list and return `&mut` to it; if already owned, return as-is.
     pub(crate) fn to_owned(&mut self) -> &mut Vec<bun_css::LayerName> {
         if let Layers::Borrowed(p) = *self {
@@ -1422,8 +1414,7 @@ impl CssImportOrder {
     pub(crate) fn hash<H: bun_core::Hasher + ?Sized>(&self, hasher: &mut H) {
         // TODO: conditions, condition_import_records
 
-        // Zig: bun.writeAnyToHasher(hasher, std.meta.activeTag(this.kind)) — feeds the small-int
-        // tag bytes. core::mem::Discriminant is opaque/pointer-sized; hash an explicit u8 instead.
+        // core::mem::Discriminant is opaque/pointer-sized; hash an explicit u8 tag instead.
         let tag: u8 = match &self.kind {
             CssImportOrderKind::Layers(_) => 0,
             CssImportOrderKind::ExternalPath(_) => 1,
@@ -1446,9 +1437,8 @@ impl CssImportOrder {
                 hasher.update(b"\x00");
             }
             CssImportOrderKind::ExternalPath(path) => hasher.update(path.text),
-            // PORT NOTE: `Index` is a `#[repr(transparent)]` u32 newtype but
-            // doesn't impl `AsBytes`; hash the inner u32 (Zig hashed the
-            // `Index.Int` bytes directly).
+            // Note: `Index` is a `#[repr(transparent)]` u32 newtype but
+            // doesn't impl `AsBytes`; hash the inner u32.
             CssImportOrderKind::SourceIndex(idx) => {
                 bun_core::write_any_to_hasher(hasher, idx.get())
             }
@@ -1467,7 +1457,7 @@ impl CssImportOrder {
 #[allow(dead_code)]
 pub(crate) struct CssImportOrderDebug<'a, 'ctx> {
     inner: &'a CssImportOrder,
-    // PORT NOTE: split lifetimes — `LinkerContext<'ctx>` is invariant over `'ctx`,
+    // Note: split lifetimes — `LinkerContext<'ctx>` is invariant over `'ctx`,
     // so coupling the borrow lifetime to the struct param (`&'a LinkerContext<'a>`)
     // forces every caller's `&CssImportOrder` and `&LinkerContext` to share one
     // region. The Display impl only reads `ctx.parse_graph` (a raw `*mut Graph`),
@@ -1623,7 +1613,7 @@ impl Content {
     }
 }
 
-// Re-exports (Zig: pub const X = ...)
+// Re-exports
 pub use crate::DeferredBatchTask::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
@@ -1656,5 +1646,3 @@ pub mod bun_renamer {
         }
     }
 }
-
-// ported from: src/bundler/Chunk.zig
diff --git a/src/bundler/DeferredBatchTask.rs b/src/bundler/DeferredBatchTask.rs
index fb5197da6f2..b5fbbc71dac 100644
--- a/src/bundler/DeferredBatchTask.rs
+++ b/src/bundler/DeferredBatchTask.rs
@@ -17,14 +17,14 @@ pub use crate::bundle_v2::dispatch::CompletionDispatch;
 
 #[derive(Default)]
 pub struct DeferredBatchTask {
-    // Zig: `running: if (Environment.isDebug) bool else u0` — zero-sized in release.
+    // Debug-only flag; zero-sized in release.
     #[cfg(debug_assertions)]
     running: bool,
 }
 
 impl DeferredBatchTask {
     pub fn init(&mut self) {
-        // PORT NOTE: kept as `&mut self` (not `-> Self`) — this struct is embedded
+        // Kept as `&mut self` (not `-> Self`) — this struct is embedded
         // by value in BundleV2 (recovered via container_of in `get_bundle_v2`), so
         // it is reset in place, never separately constructed.
         #[cfg(debug_assertions)]
@@ -35,8 +35,8 @@ impl DeferredBatchTask {
 
     pub fn get_bundle_v2(&mut self) -> &mut BundleV2<'static> {
         // SAFETY: `self` is always the `drain_defer_task` field of a live `BundleV2`;
-        // this struct is never instantiated standalone. Lifetime erased to 'static
-        // (mirrors Zig raw `*BundleV2`); callers must not outlive the owning bundle.
+        // this struct is never instantiated standalone. Lifetime erased to 'static;
+        // callers must not outlive the owning bundle.
         unsafe {
             &mut *bun_core::from_field_ptr!(
                 BundleV2<'static>,
@@ -59,27 +59,24 @@ impl DeferredBatchTask {
             std::ptr::from_mut::<Self>(self).cast::<()>(),
         ));
 
-        // Zig: `getBundleV2().jsLoopForPlugins().enqueueTaskConcurrent(task)`.
         self.get_bundle_v2().enqueue_on_js_loop_for_plugins(task);
     }
 
     pub fn run_on_js_thread(&mut self) {
-        // PORT NOTE: reshaped for borrowck — Zig's `defer this.deinit()` only resets
-        // the debug `running` flag; since nothing follows `drainDeferred`, ignoring
-        // its error and resetting the flag afterwards is equivalent on both paths.
+        // `deinit` only resets
+        // the debug `running` flag; nothing follows `drain_deferred`, so
+        // resetting the flag afterwards covers both paths.
         {
             let bv2 = self.get_bundle_v2();
-            // Zig: `if (bv2.completion) |c| c.result == .err else false`
             let rejected = bv2.completion.map(|c| c.result_is_err()).unwrap_or(false);
-            // Zig: `bv2.plugins.?.drainDeferred(rejected) catch return;`
-            // `catch return` collapses to discarding the void result — see
+            // The void result is discarded — see
             // `Plugin::drain_deferred` for the exception-scope note.
             bv2.plugins_mut().expect("plugins").drain_deferred(rejected);
         }
         self.deinit();
     }
 
-    // PORT NOTE: not `impl Drop` — this struct is an intrusive field of `BundleV2`
+    // Not `impl Drop` — this struct is an intrusive field of `BundleV2`
     // and `deinit` is a debug-flag reset, not resource teardown.
     fn deinit(&mut self) {
         #[cfg(debug_assertions)]
@@ -88,5 +85,3 @@ impl DeferredBatchTask {
         }
     }
 }
-
-// ported from: src/bundler/DeferredBatchTask.zig
diff --git a/src/bundler/Graph.rs b/src/bundler/Graph.rs
index b2f2c3fd9ce..4de30205a97 100644
--- a/src/bundler/Graph.rs
+++ b/src/bundler/Graph.rs
@@ -18,8 +18,8 @@ use bun_ast::Index;
 pub(crate) use crate::IndexInt;
 
 pub struct Graph<'a> {
-    // bundle_v2.zig:992 allocates this from `this.arena()` (the `self.heap` arena) and
-    // bundle_v2.zig:2248 calls `pool.deinit()`, so this is arena-owned but self-referential
+    // `BundleV2::init` allocates this from the `self.heap` arena and
+    // `BundleV2::deinit` calls `pool.deinit()`, so this is arena-owned but self-referential
     // (sibling field). `BackRef` (not raw `NonNull`) so the read accessor `pool()` is
     // safe — the BACKREF invariant (pointee outlives holder) holds for the entire
     // bundle pass.
@@ -27,7 +27,6 @@ pub struct Graph<'a> {
     pub heap: &'a ThreadLocalArena,
 
     /// Mapping user-specified entry points to their Source Index
-    // PERF(port): Zig fed this ArrayList from `self.heap` (self-referential arena).
     pub entry_points: Vec<Index>,
     /// Maps entry point source indices to their original specifiers (for virtual entries resolved by plugins)
     pub entry_point_original_names: IndexStringMap,
@@ -35,8 +34,8 @@ pub struct Graph<'a> {
     pub input_files: MultiArrayList<InputFile>,
     /// Every source index has an associated Ast
     /// When a parse is in progress / queued, it is `Ast.empty`
-    // PORT NOTE: BundledAst<'arena> borrows from self.heap (sibling-field self-ref);
-    // 'static here is a placeholder. TODO(refactor): thread the lifetime via raw ptr or Ouroboros.
+    // `JSAst<'a>` borrows from the arena behind `self.heap`; `'a` ties the AST
+    // entries to that arena's lifetime (sibling-field relationship).
     pub ast: MultiArrayList<JSAst<'a>>,
 
     /// During the scan + parse phase, this value keeps a count of the remaining
@@ -78,7 +77,6 @@ pub struct Graph<'a> {
     /// pre-allocations without re-iterating the file listing.
     pub css_file_count: usize,
 
-    // PERF(port): Zig fed this ArrayList from `self.heap` (self-referential arena).
     pub additional_output_files: Vec<options::OutputFile>,
 
     pub kit_referenced_server_data: bool,
@@ -103,9 +101,8 @@ pub struct InputFile {
     pub secondary_path: AstVec<u8>,
     pub loader: options::Loader,
     pub side_effects: SideEffects,
-    // PORT NOTE: Zig stored `arena: std.mem.Allocator = bun.default_allocator`
-    // here so deinit could free `source`/`secondary_path` with the right alloc.
-    // In Rust the owned fields (Box/Vec) carry their arena; field dropped.
+    // No `arena` field — the owned fields
+    // (Box/Vec) carry their allocator.
     pub additional_files: AstVec<AdditionalFile>,
     pub unique_key_for_additional_file: Box<[u8], AstAlloc>,
     pub content_hash_for_additional_file: u64,
@@ -156,7 +153,7 @@ impl<'a> Graph<'a> {
     pub fn new(heap: &'a ThreadLocalArena) -> Self {
         Self {
             // Self-referential arena pointer; real value wired in
-            // `BundleV2::init` before any use (Graph.zig has `= undefined`).
+            // `BundleV2::init` before any use.
             pool: bun_ptr::BackRef::from(NonNull::<ThreadPool>::dangling()),
             heap,
             entry_points: Vec::new(),
@@ -181,8 +178,8 @@ impl<'a> Graph<'a> {
 impl<'a> Graph<'a> {
     /// Shared borrow of the bundler `ThreadPool`.
     ///
-    /// `pool` is arena-allocated in `BundleV2::init` (bundle_v2.zig:992) and
-    /// torn down in `BundleV2::deinit` (bundle_v2.zig:2248). It is non-null
+    /// `pool` is arena-allocated in `BundleV2::init` and
+    /// torn down in `BundleV2::deinit`. It is non-null
     /// and valid for the entire bundle pass; see LIFETIMES.tsv row 170
     /// (BACKREF). All `ThreadPool` driver methods (`schedule`, `start`,
     /// `worker_pool`, `schedule_inside_thread_pool`) take `&self`, so callers
@@ -237,10 +234,8 @@ impl<'a> Graph<'a> {
     }
 }
 
-// Spec: `side_effects: _resolver.SideEffects` (Graph.zig:74). The resolver
+// The resolver
 // crate re-exports the canonical enum from `bun_options_types`; re-export it
 // here so `InputFile` and the derived `items_side_effects()` SoA accessor share
 // the same type that `LinkerContext::mark_file_live_for_tree_shaking` expects.
 use bun_ast::SideEffects;
-
-// ported from: src/bundler/Graph.zig
diff --git a/src/bundler/HTMLImportManifest.rs b/src/bundler/HTMLImportManifest.rs
index 21b1df4849b..1c0ac0698f0 100644
--- a/src/bundler/HTMLImportManifest.rs
+++ b/src/bundler/HTMLImportManifest.rs
@@ -70,8 +70,6 @@ impl<'a> fmt::Display for HTMLImportManifest<'a> {
             &mut adapter,
         ) {
             Ok(()) => Ok(()),
-            // We use std.fmt.count for this
-            // Zig: error.NoSpaceLeft => unreachable, error.OutOfMemory => return error.OutOfMemory
             Err(_) => Err(fmt::Error),
         }
     }
@@ -97,7 +95,7 @@ fn write_entry_item<W: Write + ?Sized>(
     bun_js_printer::write_json_string::<_, { Encoding::Utf8 }>(path, writer)?;
 
     writer.write_all(b",\"loader\":\"")?;
-    // Zig: @tagName(loader) — strum is configured snake_case to match.
+    // strum is configured snake_case, so this prints the lowercase tag name.
     writer.write_all(<&'static str>::from(loader).as_bytes())?;
     writer.write_all(b"\",\"isEntry\":")?;
     writer.write_all(if kind == OutputKind::EntryPoint {
@@ -136,7 +134,6 @@ pub fn write_escaped_json<W: Write + ?Sized>(
     chunks: &[Chunk],
     writer: &mut W,
 ) -> Result<(), bun_core::Error> {
-    // PERF(port): was stack-fallback (std.heap.stackFallback(4096)).
     let mut bytes: Vec<u8> = Vec::new();
     write(index, graph, linker_graph, chunks, &mut bytes)?;
     bun_js_printer::write_pre_quoted_string::<_, b'"', false, true, { Encoding::Utf8 }>(
@@ -146,7 +143,6 @@ pub fn write_escaped_json<W: Write + ?Sized>(
 }
 
 /// Newtype wrapper produced by [`HTMLImportManifest::format_escaped_json`].
-/// Mirrors Zig's `std.fmt.Alt(HTMLImportManifest, escapedJSONFormatter)`.
 pub struct EscapedJson<'a>(pub HTMLImportManifest<'a>);
 
 impl<'a> fmt::Display for EscapedJson<'a> {
@@ -160,8 +156,6 @@ impl<'a> fmt::Display for EscapedJson<'a> {
             &mut adapter,
         ) {
             Ok(()) => Ok(()),
-            // We use std.fmt.count for this
-            // Zig: error.WriteFailed => unreachable, error.OutOfMemory => return error.WriteFailed
             Err(_) => Err(fmt::Error),
         }
     }
@@ -385,5 +379,3 @@ pub mod html_import_manifest {
         Ok(())
     }
 }
-
-// ported from: src/bundler/HTMLImportManifest.zig
diff --git a/src/bundler/HTMLScanner.rs b/src/bundler/HTMLScanner.rs
index 7d8b17e1e54..e13b69bc61f 100644
--- a/src/bundler/HTMLScanner.rs
+++ b/src/bundler/HTMLScanner.rs
@@ -16,7 +16,7 @@ bun_core::declare_scope!(HTMLScanner, hidden);
 
 pub(crate) struct HTMLScanner<'a> {
     // arena field dropped — global mimalloc (see PORTING.md §Allocators).
-    pub import_records: Vec<ImportRecord>, // Zig: ImportRecord.List
+    pub import_records: Vec<ImportRecord>,
     pub log: &'a mut Log,
     pub source: &'a Source,
 }
@@ -91,8 +91,7 @@ impl<'a> HTMLScanner<'a> {
     }
 
     pub(crate) fn on_html_parse_error(&mut self, message: &[u8]) {
-        // bun.handleOom → Rust Vec/Box allocations abort on OOM; just call.
-        // Zig `Log.addError` dupes via `log.msgs.allocator`; here `IntoText for
+        // Vec/Box allocations abort on OOM; just call. `IntoText for
         // Vec<u8>` → `Cow::Owned`, so the Log owns and drops the copy.
         let _ = self
             .log
@@ -115,15 +114,13 @@ impl<'a> HTMLScanner<'a> {
     }
 }
 
-// Zig: const processor = HTMLProcessor(HTMLScanner, false);
 type Processor<'a> = HTMLProcessor<HTMLScanner<'a>, false>;
 
 // ───────────────────────────────────────────────────────────────────────────
 // HTMLProcessor — generic over visitor `T` and `VISIT_DOCUMENT_TAGS`
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Trait capturing the duck-typed methods Zig's `HTMLProcessor` calls on `T`.
-/// Zig used `anytype`-style structural calls; Rust needs an explicit bound.
+/// Trait capturing the methods `HTMLProcessor` calls on `T`.
 pub(crate) trait HTMLProcessorHandler {
     fn on_tag(
         &mut self,
@@ -135,9 +132,9 @@ pub(crate) trait HTMLProcessorHandler {
     fn on_write_html(&mut self, bytes: &[u8]);
     fn on_html_parse_error(&mut self, message: &[u8]);
 
-    // Only required when VISIT_DOCUMENT_TAGS == true.
-    // TODO(port): split into a separate trait if const-generic specialization
-    // is unwieldy; Zig only references these inside `if (visit_document_tags)`.
+    // Only required when VISIT_DOCUMENT_TAGS == true; `run` only calls
+    // these when visiting document tags, so the defaults are never
+    // reached for handlers that don't visit document tags.
     fn on_body_tag(&mut self, _element: &mut lol::Element) -> bool {
         unreachable!()
     }
@@ -266,10 +263,9 @@ const SELECTOR_CAP: usize = TAG_HANDLERS.len() + 3;
 
 // ── lol-html DirectiveCallback / OutputSink adapters ──────────────────────
 // `lol_html::DirectiveCallback<Container>` allows one impl per (UserData,
-// Container) pair, but Zig registered 16 distinct comptime fn-values against
-// the same `*T`. We instead allocate one user-data record *per selector*
-// holding `(*mut T, tag_index)`; the trait body is `generateHandlerForTag`'s
-// body with `tag_info` looked up at runtime via the index.
+// Container) pair, so we allocate one user-data record *per selector*
+// holding `(*mut T, tag_index)`; the shared trait body looks up
+// `tag_info` at runtime via the index.
 
 struct TagUserData<T> {
     this: *mut T,
@@ -286,7 +282,6 @@ impl<T: HTMLProcessorHandler> lol::DirectiveCallback<lol::Element> for TagUserDa
                 .unwrap_or(false);
             if has {
                 let value = element.get_attribute(tag_info.url_attribute);
-                // Zig: defer value.deinit()
                 let _value_guard = scopeguard::guard(value, |v| v.deinit());
                 if value.len > 0 {
                     bun_core::scoped_log!(
@@ -378,7 +373,6 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
         let this_ptr: *mut T = this;
 
         let builder = lol::HTMLRewriterBuilder::init();
-        // Zig: defer builder.deinit()
         let _builder_guard = scopeguard::guard(builder, |b| {
             // SAFETY: `b` came from `HTMLRewriterBuilder::init()` and has not
             // been freed.
@@ -387,7 +381,6 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
 
         let mut selectors: BoundedArray<*mut lol::HTMLSelector, SELECTOR_CAP> =
             BoundedArray::default();
-        // Zig: defer for (selectors.slice()) |s| s.deinit()
         let mut selectors_guard = scopeguard::guard(
             &mut selectors,
             |selectors: &mut BoundedArray<*mut lol::HTMLSelector, SELECTOR_CAP>| {
@@ -430,7 +423,6 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
         }
 
         if VISIT_DOCUMENT_TAGS {
-            // Zig: inline for (.{ "body", "head", "html" }, &.{ T.onBodyTag, ... })
             for (i, tag) in [b"body" as &[u8], b"head", b"html"].into_iter().enumerate() {
                 let head_selector = lol::HTMLSelector::parse(tag).map_err(lol_err)?;
                 selectors.append_assume_capacity(head_selector);
@@ -454,15 +446,14 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
 
         let mut sink = Sink::<T>(this_ptr);
 
-        // PORT NOTE: Zig `errdefer { ... this.onHTMLParseError(last_error) }`
-        // reshaped — fallible tail wrapped in an inner block so the side effect
-        // runs on error without a scopeguard double-borrowing `this`.
+        // The fallible tail is wrapped in an inner block so the
+        // on-error side effect (`on_html_parse_error`)
+        // runs without a scopeguard double-borrowing `this`.
         let res: Result<(), Error> = (|| {
             // SAFETY: `builder` is a live FFI handle.
             let rewriter = unsafe { &mut *builder }
                 .build(lol::Encoding::UTF8, memory_settings, false, &raw mut sink)
                 .map_err(lol_err)?;
-            // Zig: defer rewriter.deinit()
             let _rewriter_guard = scopeguard::guard(rewriter, |r| {
                 // SAFETY: `r` came from `build` and has not been freed.
                 unsafe { lol::HTMLRewriter::destroy(r) }
@@ -476,7 +467,6 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
 
         if res.is_err() {
             let last_error = lol::HTMLString::last_error();
-            // Zig: defer last_error.deinit()
             let _last_error_guard = scopeguard::guard(last_error, |e| e.deinit());
             if last_error.len > 0 {
                 // The rewriter (sole user of `this_ptr`-derived aliases) was
@@ -489,5 +479,3 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
         res
     }
 }
-
-// ported from: src/bundler/HTMLScanner.zig
diff --git a/src/bundler/IndexStringMap.rs b/src/bundler/IndexStringMap.rs
index 34bd7a3f661..74abab6b897 100644
--- a/src/bundler/IndexStringMap.rs
+++ b/src/bundler/IndexStringMap.rs
@@ -1,6 +1,6 @@
 use bun_collections::ArrayHashMap;
 
-/// `Index.Int` in Zig — the underlying integer repr.
+/// The underlying integer repr of `Index`.
 pub(crate) use crate::IndexInt;
 
 #[derive(Default)]
@@ -8,9 +8,6 @@ pub struct IndexStringMap {
     map: ArrayHashMap<IndexInt, Box<[u8]>>,
 }
 
-// PORT NOTE: `deinit` only freed owned values + the map; with `Box<[u8]>` values and
-// `ArrayHashMap`'s own Drop, no explicit `impl Drop` is needed.
-
 impl IndexStringMap {
     pub fn get(&self, index: IndexInt) -> Option<&[u8]> {
         self.map.get(&index).map(|v| v.as_ref())
@@ -27,5 +24,3 @@ impl IndexStringMap {
         Ok(())
     }
 }
-
-// ported from: src/bundler/IndexStringMap.zig
diff --git a/src/bundler/LinkerContext.rs b/src/bundler/LinkerContext.rs
index dc5971ab2a5..6bb2dec44cb 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -1,5 +1,3 @@
-//! Port of src/bundler/LinkerContext.zig
-
 use crate::mal_prelude::*;
 use core::sync::atomic::{AtomicU32, Ordering};
 
@@ -11,18 +9,17 @@ use bun_core::{MutableString, string_joiner::StringJoiner, strings};
 use bun_sourcemap::{
     self as SourceMap, DebugIDFormatter, LineOffsetTable, SourceMapPieces, SourceMapState,
 };
-// PORT NOTE: alias the *module* (not the `ThreadPool` struct) so
+// Note: alias the *module* (not the `ThreadPool` struct) so
 // `ThreadPoolLib::Task` / `ThreadPoolLib::Batch` resolve as nested items.
+use crate::bake_types as bake;
 use bun_ast::{ImportKind, ImportRecord};
 use bun_threading::{WaitGroup, thread_pool as ThreadPoolLib};
-// TODO(port): bake_types arrives from move-in (TYPE_ONLY → bundler)
-use crate::bake_types as bake;
 
 use crate::BundledAst as JSAst;
 use bun_ast::{
     Binding, DeclaredSymbol, Dependency, ExportsKind, Expr, NamedImport, Part, Ref, Stmt, TlaCheck,
 };
-// PORT NOTE: `crate::Index` (= `bun_ast::Index`) — the
+// Note: `crate::Index` (= `bun_ast::Index`) — the
 // bundler's source-index newtype. `bun_ast::Index` is layout-identical
 // but a distinct type; LinkerGraph/JSMeta/etc. are typed against the crate
 // re-export, so use that here.
@@ -42,7 +39,7 @@ use crate::{
     LinkerGraph, MangledProps, PartRange, StableRef, WrapKind,
 };
 
-/// `bun.jsc.AnyEventLoop` (LinkerContext.zig:28). `bun_event_loop` is a
+/// `bun_event_loop` is a
 /// lower-tier crate, so the bundler can name the real enum (the `Js` arm
 /// holds an erased `*mut jsc::EventLoop` driven through a vtable). Stored as
 /// a pointer because the linker borrows the loop owned by the
@@ -56,7 +53,7 @@ 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.
+// the formatter that knows their layout.
 // ══════════════════════════════════════════════════════════════════════════
 #[cfg(feature = "show_crash_trace")]
 bun_crash_handler::link_impl_BundleGenerateChunkCtx! {
@@ -90,7 +87,7 @@ bun_crash_handler::link_impl_BundleGenerateChunkCtx! {
     }
 }
 
-/// Helper for call-sites that previously wrote `Action::BundleGenerateChunk(.{...})`.
+/// Helper for constructing a crash-trace `Action::BundleGenerateChunk`.
 #[cfg(feature = "show_crash_trace")]
 #[inline]
 pub(crate) fn bundle_generate_chunk_action(
@@ -111,7 +108,7 @@ pub(crate) fn bundle_generate_chunk_action(
     })
 }
 
-// Scoped-log wrappers (LinkerContext.zig:2, :2705); re-exported so `linker_context/*` submodules import directly.
+// Scoped-log wrappers; re-exported so `linker_context/*` submodules import directly.
 bun_core::define_scoped_log!(debug, crate::linker_context_mod::LinkerCtx);
 pub(crate) use debug;
 bun_core::define_scoped_log!(debug_tree_shake, crate::linker_context_mod::TreeShake);
@@ -215,8 +212,7 @@ pub struct LinkerContext<'a> {
 // `SourceMapDataTask`. The raw-pointer fields (`parse_graph`, `resolver`,
 // `r#loop`, `framework`) are backrefs into `BundleV2`/`Transpiler` whose
 // lifetimes strictly outlive every parallel section, and per-thread writes go
-// to disjoint SoA slots (see `compute_line_offsets`). This mirrors Zig's
-// freely-aliased `*LinkerContext`.
+// to disjoint SoA slots (see `compute_line_offsets`).
 unsafe impl<'a> Send for LinkerContext<'a> {}
 // SAFETY: see the `Send` impl above — same backref-lifetime / disjoint-write invariants.
 unsafe impl<'a> Sync for LinkerContext<'a> {}
@@ -249,7 +245,7 @@ impl<'a> Default for LinkerContext<'a> {
 
 impl<'a> LinkerContext<'a> {
     /// container_of: `*LinkerContext` → `*BundleV2` via the embedded `.linker`
-    /// field. Mirrors Zig `@fieldParentPtr("linker", c)`. Returns raw; caller
+    /// field. Returns raw; caller
     /// decides `&*` vs `&mut *` per local aliasing rules (several callers run
     /// on worker-pool threads and MUST NOT materialize `&mut BundleV2`).
     ///
@@ -398,7 +394,6 @@ impl<'a> LinkerContext<'a> {
     }
 
     pub fn mark_pending_task_done(&self) {
-        // Zig: `.monotonic` → Rust `Relaxed` (LLVM `monotonic` == C11 `relaxed`).
         self.pending_task_count.fetch_sub(1, Ordering::Relaxed);
     }
 
@@ -411,10 +406,8 @@ impl<'a> LinkerContext<'a> {
             && record.source_index.get() != source_index
     }
 
-    /// Spec: `LinkerContext.zig:checkForMemoryCorruption`.
-    ///
-    /// PORT NOTE: the Zig body calls `parse_graph.heap.helpCatchMemoryIssues()`
-    /// (a `MimallocArena` debug hook). `Graph.heap` is currently
+    /// Note: this should call a `MimallocArena` debug hook
+    /// (`helpCatchMemoryIssues`), but `Graph.heap` is currently
     /// `bun_alloc::Arena = bumpalo::Bump`, which has no such hook, so this is a
     /// no-op until the arena type is swapped to the real `MimallocArena`. The
     /// call sites are already gated on `FeatureFlags::HELP_CATCH_MEMORY_ISSUES`.
@@ -422,14 +415,14 @@ impl<'a> LinkerContext<'a> {
     pub fn check_for_memory_corruption(&self) {
         // For this to work, you need mimalloc's debug build enabled.
         //    make mimalloc-debug
-        // TODO(port): `unsafe { (*self.parse_graph).heap.help_catch_memory_issues() }`
-        // once `Graph.heap: MimallocArena`.
+        // Becomes `unsafe { (*self.parse_graph).heap.help_catch_memory_issues() }`
+        // if `Graph.heap` ever grows the `MimallocArena` debug hook (see the
+        // doc comment above).
     }
 }
 
 // Local re-exports for the tree-shaking impl below. `EntryPoint::Kind`
-// and `SideEffects` live in sibling modules; code here used to reference them
-// via Zig-style nested paths. Re-export so `EntryPoint::Kind` here is the
+// and `SideEffects` live in sibling modules. Re-export so `EntryPoint::Kind` here is the
 // *same type* `items_entry_point_kind()` returns.
 #[allow(non_snake_case)]
 pub mod EntryPoint {
@@ -441,7 +434,7 @@ type DeclaredSymbolList = bun_ast::DeclaredSymbolList;
 
 impl<'a> LinkerContext<'a> {
     pub fn arena(&self) -> &Bump {
-        // TODO(port): bundler is an AST crate; LinkerGraph owns the arena
+        // LinkerGraph owns (a backref to) the bundle arena; see `LinkerGraph::arena`.
         self.graph.arena()
     }
 
@@ -482,7 +475,7 @@ impl<'a> LinkerContext<'a> {
     }
 
     /// `bundle` is taken as a raw `*mut` because the caller invokes this as
-    /// `self.linker.load(self, …)` (Zig spec bundle_v2.zig:2574) — `self` *is*
+    /// `self.linker.load(self, …)` — `self` *is*
     /// `(*bundle).linker`, so a `&mut BundleV2` here would alias the receiver
     /// under Stacked Borrows. This body only reaches into fields of `*bundle`
     /// that are disjoint from `linker` (`graph`, `transpiler`,
@@ -511,11 +504,11 @@ impl<'a> LinkerContext<'a> {
         // the bundle's lifetime; `resolver`/`log`/`options` are stable fields.
         let transpiler = unsafe { &mut *(*bundle).transpiler };
         self.graph.code_splitting = transpiler.options.code_splitting;
-        // Mirrors Zig's pointer assignment; `transpiler.log` is the canonical
+        // `transpiler.log` is the canonical
         // `*mut Log` (same value aliased into `linker.log` / `resolver.log`).
         self.log = transpiler.log;
 
-        // PORT NOTE: lifetime — `self.resolver` is `ParentRef<Resolver<'a>>`
+        // Note: lifetime — `self.resolver` is `ParentRef<Resolver<'a>>`
         // but `transpiler.resolver` is `Resolver<'_>` (anonymous `bundle`
         // lifetime); erase via a pointer cast (LIFETIMES.tsv: GRAPHBACKED —
         // resolver outlives the link step). Read-only — `from_raw` provenance
@@ -527,9 +520,8 @@ impl<'a> LinkerContext<'a> {
         });
         self.cycle_detector = Vec::new();
 
-        // PORT NOTE: `reachable_files` is `Vec<Index>`; clone the
-        // caller-owned slice into the linker arena. PERF(port): Zig pointed at
-        // the slice in-place; revisit once Vec grows a borrowed-view ctor.
+        // Note: `reachable_files` is `Vec<Index>`; clone the
+        // caller-owned slice into the linker arena.
         self.graph.reachable_files = reachable.to_vec();
 
         // SAFETY: parse_graph is valid backref just assigned above
@@ -543,8 +535,6 @@ impl<'a> LinkerContext<'a> {
             // SAFETY: parse_graph backref
             unsafe { &(*self.parse_graph).entry_point_original_names },
         )?;
-        // PERF(port): was arena bulk-free — `dynamic_import_entry_points` is
-        // now a global-alloc `ArrayHashMap`; clearing drops it.
         dyn_entry_points.clear_retaining_capacity();
 
         let runtime_named_exports =
@@ -572,7 +562,7 @@ impl<'a> LinkerContext<'a> {
         }
 
         if self.options.output_format == Format::Cjs || self.options.output_format == Format::Iife {
-            // PORT NOTE: reshaped for borrowck — `Slice<T>` is a value-type
+            // Note: reshaped for borrowck — `Slice<T>` is a value-type
             // snapshot of column pointers (does not borrow `self.graph.ast`),
             // so `split_mut()` on the local can coexist with the
             // `self.graph.meta` borrow below. The slab does not reallocate for
@@ -612,8 +602,7 @@ impl<'a> LinkerContext<'a> {
         debug_assert!(self.options.source_maps != SourceMapOption::None);
         self.source_maps.line_offset_wait_group = WaitGroup::init_with_count(reachable.len());
         self.source_maps.quoted_contents_wait_group = WaitGroup::init_with_count(reachable.len());
-        // TODO(port): arena alloc of task arrays
-        // PORT NOTE: `SourceMapDataTask` is not `Clone` (embeds an intrusive
+        // Note: `SourceMapDataTask` is not `Clone` (embeds an intrusive
         // `ThreadPoolLib::Task` node); build via iterator instead of `vec![x;n]`.
         self.source_maps.line_offset_tasks = (0..reachable.len())
             .map(|_| SourceMapDataTask::default())
@@ -624,7 +613,7 @@ impl<'a> LinkerContext<'a> {
             .collect::<Vec<_>>()
             .into_boxed_slice();
 
-        // PORT NOTE: erase `'a` → `'static` for the task backref. The tasks are
+        // Note: erase `'a` → `'static` for the task backref. The tasks are
         // joined before `self` is dropped (see `SourceMapData.*_wait_group`).
         // SAFETY: write provenance from `ptr::from_mut`; outlives every task.
         let ctx: Option<bun_ptr::ParentRef<LinkerContext<'static>>> = Some(unsafe {
@@ -681,9 +670,9 @@ impl<'a> LinkerContext<'a> {
         // field of `BundleV2.linker` (= `*self`). The two are disjoint, and no
         // other `&`/`&mut` to `BundleV2.graph` is live for this scope —
         // `self.graph` below is `LinkerGraph`, a distinct allocation.
-        // PORT NOTE: reshaped for borrowck — Zig held overlapping `&`/`&mut`
-        // into `parse_graph.html_imports` and `parse_graph.input_files`; here
-        // we go through raw pointers and reborrow per use.
+        // Note: go through raw pointers and reborrow per use to avoid holding
+        // overlapping `&`/`&mut` into `parse_graph.html_imports` and
+        // `parse_graph.input_files`.
         let parse_graph: *mut Graph<'a> = self.parse_graph;
         // SAFETY: see above; sole accessor of `html_imports` for this scope.
         let server_len = unsafe { (*parse_graph).html_imports.server_source_indices.len() };
@@ -719,8 +708,7 @@ impl<'a> LinkerContext<'a> {
                 };
 
                 // S.LazyExport is a call to __jsonParse. Each accessor returns
-                // `Option`; `.unwrap()` mirrors Zig's untagged-union field
-                // reads (panic on shape mismatch).
+                // `Option`; `.unwrap()` panics on shape mismatch.
                 let original_ref = (*self.graph.ast.items_parts()[html_import as usize][1].stmts)
                     [0]
                 .data
@@ -915,8 +903,8 @@ impl<'a> LinkerContext<'a> {
             self.graph.parts_live = parts_live;
         }
 
-        // PORT NOTE: reshaped for borrowck — these slices alias into self.graph;
-        // Zig held them simultaneously. The SoA columns are physically disjoint
+        // Note: these slices alias into self.graph.
+        // The SoA columns are physically disjoint
         // and the underlying slabs don't reallocate during tree-shaking, so we
         // cache raw column base pointers and reborrow at each recursive call.
         let parts: *mut [bun_ast::PartList<'a>] = self.graph.ast.items_parts_mut();
@@ -1031,7 +1019,7 @@ impl<'a> LinkerContext<'a> {
         let worker = crate::thread_pool::Worker::get(ctx.bundle());
         let mut worker = scopeguard::guard(worker, |w| w.unget());
         let worker: &mut crate::thread_pool::Worker = &mut **worker;
-        // PORT NOTE: dispatch on a discriminant copy so `chunk` isn't borrowed
+        // Note: dispatch on a discriminant copy so `chunk` isn't borrowed
         // across the post-process call (which takes `&mut Chunk`).
         let result = match chunk.content {
             crate::chunk::Content::Javascript(_) => {
@@ -1073,7 +1061,7 @@ impl<'a> LinkerContext<'a> {
         chunk_index: usize,
     ) {
         let _ = chunk_index;
-        // PORT NOTE: reshaped for borrowck — `rename_symbols_in_chunk` needs
+        // Note: reshaped for borrowck — `rename_symbols_in_chunk` needs
         // `&mut Chunk` and a borrow of `chunk.content.javascript.files_in_chunk_order`
         // simultaneously; cache the files slice via raw pointer (it lives in
         // the chunk arena, address-stable for the renamer pass).
@@ -1100,9 +1088,6 @@ impl<'a> LinkerContext<'a> {
     ) -> Result<SourceMapPieces, BunError> {
         let _trace = bun::perf::trace("Bundler.generateSourceMapForChunk");
 
-        // PERF(port): Zig threaded `worker.arena` through StringJoiner /
-        // MutableString; the Rust ports use the global mimalloc, so the joiner
-        // is arena-free here. Revisit when arena threading lands.
         let mut j = StringJoiner::default();
 
         let sources = self.parse_graph().input_files.items_source();
@@ -1118,7 +1103,6 @@ impl<'a> LinkerContext<'a> {
         //    Which source index in the generated sourcemap, referred to
         //    as the "mapping source index" within this function to be distinct.
         let mut source_id_map: ArrayHashMap<u32, i32> = ArrayHashMap::new();
-        // PERF(port): was arena bulk-free — source_id_map drops at scope exit
 
         let source_indices = results.items_source_index();
 
@@ -1129,11 +1113,8 @@ impl<'a> LinkerContext<'a> {
                 let path = &sources[index as usize].path;
                 source_id_map.put_no_clobber(index, 0)?;
 
-                // PORT NOTE: Zig mutated a local copy's `path.pretty` from the
-                // worker arena; we keep the relative path in a local owned
-                // buffer instead (drops at scope exit — same lifetime as the
-                // arena slice).
-                //
+                // Note: the relative path lives in a local owned buffer
+                // (drops at scope exit).
                 let rel_path_storage;
                 let pretty: &[u8] = if path.is_file() {
                     rel_path_storage =
@@ -1145,8 +1126,8 @@ impl<'a> LinkerContext<'a> {
 
                 let mut quote_buf = MutableString::init(pretty.len() + 2)?;
                 js_printer::quote_for_json(pretty, &mut quote_buf, false)?;
-                // PERF(port): was arena-backed; `to_default_owned` moves the
-                // buffer into the joiner (joiner owns it until `done`).
+                // `to_default_owned` moves the buffer into the joiner
+                // (joiner owns it until `done`).
                 j.push_owned(quote_buf.to_default_owned());
             }
 
@@ -1172,7 +1153,7 @@ impl<'a> LinkerContext<'a> {
                 };
 
                 let mut quote_buf = MutableString::init(pretty.len() + ", ".len() + 2)?;
-                quote_buf.append_assume_capacity(b", "); // PERF(port): was assume_capacity
+                quote_buf.append_assume_capacity(b", ");
                 js_printer::quote_for_json(pretty, &mut quote_buf, false)?;
                 j.push_owned(quote_buf.to_default_owned());
             }
@@ -1247,7 +1228,6 @@ impl<'a> LinkerContext<'a> {
 
         if FeatureFlags::SOURCE_MAP_DEBUG_ID {
             j.push_static(b"\",\n  \"debugId\": \"");
-            // TODO(port): allocPrint into arena — using Vec<u8> + write!
             let mut buf = Vec::<u8>::new();
             use std::io::Write;
             write!(&mut buf, "{}", DebugIDFormatter { id: isolated_hash })
@@ -1298,9 +1278,17 @@ pub enum LinkError {
 
 bun_core::oom_from_alloc!(LinkError);
 impl From<BunError> for LinkError {
-    fn from(_: BunError) -> Self {
-        // TODO(port): narrow error set — Zig's `try this.load()` is `!void` (anyerror)
-        LinkError::BuildFailed
+    fn from(e: BunError) -> Self {
+        // OOM keeps its identity through
+        // `load()`, so OOMs travelling as `bun_core::Error` must not be
+        // misreported as build failures. Everything else collapses to
+        // `BuildFailed`; user-facing diagnostics flow through the bundler `Log`,
+        // not this variant.
+        if e == BunError::OUT_OF_MEMORY {
+            LinkError::OutOfMemory
+        } else {
+            LinkError::BuildFailed
+        }
     }
 }
 bun_core::named_error_set!(LinkError);
@@ -1394,7 +1382,6 @@ impl Default for SourceMapDataTask {
         Self {
             ctx: None,
             source_index: 0,
-            // Spec `LinkerContext.zig:101`: default task callback is `&runLineOffset`.
             thread_task: ThreadPoolLib::Task {
                 node: ThreadPoolLib::Node::default(),
                 callback: Self::run_line_offset,
@@ -1474,11 +1461,8 @@ impl SourceMapDataTask {
         // stack traces can show the source code, even after incremental
         // rebuilds occur.
         //
-        // PORT NOTE: Zig branched on `worker.ctx.transpiler.options.dev_server`
-        // to pick `dev.arena()` vs `worker.arena`, but
-        // `computeQuotedSourceContents` discards the arena parameter
-        // (`_: std.mem.Allocator`) — it always allocates via
-        // `bun.default_allocator` internally. The branch is a no-op, so we
+        // Note: `compute_quoted_source_contents` ignores which arena it is
+        // handed (it allocates via the default allocator internally), so we
         // pass the worker arena unconditionally; `DevServerHandle` does not
         // expose an arena accessor (§Dispatch).
         SourceMapData::compute_quoted_source_contents(ctx, worker.arena(), task.source_index);
@@ -1486,14 +1470,11 @@ impl SourceMapDataTask {
     }
 }
 
-// TODO(port): see SourceMapDataTask above.
-
 impl SourceMapData {
     /// Runs concurrently across the worker pool (one task per `source_index`).
     /// Takes [`ParentRef<LinkerContext>`](bun_ptr::ParentRef) (not `&mut`)
-    /// because Zig's `*LinkerContext` freely aliases across threads —
-    /// materializing `&mut LinkerContext` here while peer tasks hold the same
-    /// pointer would be aliased-mut UB. `ParentRef::Deref` yields
+    /// because peer tasks on other threads hold the same pointer —
+    /// materializing `&mut LinkerContext` here would be aliased-mut UB. `ParentRef::Deref` yields
     /// `&LinkerContext` (SharedReadOnly) for all SoA-header reads; each task
     /// writes only `graph.files[source_index].line_offset_table` (disjoint by
     /// `source_index`) via a raw column pointer.
@@ -1546,7 +1527,7 @@ impl SourceMapData {
             *line_offset_table = LineOffsetTable::generate_in::<bun_alloc::AstAlloc>(
                 &source.contents,
                 // We don't support sourcemaps for source files with more than 2^31 lines
-                (approximate_line_count as u32 & 0x7FFF_FFFF) as i32, // @intCast(@truncate to u31)
+                (approximate_line_count as u32 & 0x7FFF_FFFF) as i32,
             )
             .expect("OOM");
         }
@@ -1605,7 +1586,7 @@ impl SourceMapData {
 // other fields are POD.
 #[derive(Clone, Default)]
 pub struct MatchImport {
-    alias: bun_ast::StoreStr, // Zig string borrowed from AST arena
+    alias: bun_ast::StoreStr, // string borrowed from AST arena
     kind: MatchImportKind,
     namespace_ref: Ref,
     source_index: u32,
@@ -1642,10 +1623,10 @@ pub struct ChunkMeta {
 
 pub(crate) type ChunkMetaMap = ArrayHashMap<Ref, ()>;
 
-/// PORT NOTE: raw-pointer fields (was `&'a mut`) because `each_ptr` requires
+/// Note: raw-pointer fields (was `&'a mut`) because `each_ptr` requires
 /// `Ctx: Sync + Copy` and the same context is observed from every worker
 /// thread. Each task only writes to its own `*mut Chunk` slot; reads of
-/// `c`/`chunks` are disjoint or read-only per the Zig spec.
+/// `c`/`chunks` are disjoint or read-only.
 #[derive(Clone, Copy)]
 pub struct GenerateChunkCtx<'a> {
     pub c: bun_ptr::ParentRef<LinkerContext<'a>>,
@@ -1662,7 +1643,8 @@ pub struct GenerateChunkCtx<'a> {
     /// [`bun_ptr::BackRef::as_ptr`], shared reads go through safe `Deref`.
     pub chunk: bun_ptr::BackRef<Chunk>,
 }
-// SAFETY: see PORT NOTE above — mirrors Zig's freely-aliased `*LinkerContext`.
+// SAFETY: see note above — each task writes only its own `*mut Chunk` slot;
+// shared reads are read-only.
 unsafe impl<'a> Send for GenerateChunkCtx<'a> {}
 // SAFETY: see the `Send` impl above — same backref-lifetime / disjoint-write invariants.
 unsafe impl<'a> Sync for GenerateChunkCtx<'a> {}
@@ -1709,13 +1691,12 @@ pub struct PendingPartRange<'a> {
 /// callbacks: recover the intrusive [`PendingPartRange`] from `task`, extract
 /// the raw `*mut LinkerContext` / `*mut Chunk` from its [`GenerateChunkCtx`],
 /// and acquire the per-thread [`Worker`](crate::thread_pool::Worker) (returned
-/// as a scopeguard that calls `unget()` on drop — Zig: `defer worker.unget()`).
+/// as a scopeguard that calls `unget()` on drop).
 ///
 /// `GenerateChunkCtx.{c, chunk}` are raw `*mut T` (Copy), so reading them
 /// through `&GenerateChunkCtx` preserves the mutable provenance they were
-/// constructed with in `generate_chunks_in_parallel`. This mirrors Zig's
-/// `*LinkerContext` / `*Chunk` semantics where many `PendingPartRange` tasks
-/// share one `chunk_ctx` across worker threads.
+/// constructed with in `generate_chunks_in_parallel` — many `PendingPartRange`
+/// tasks share one `chunk_ctx` across worker threads.
 ///
 /// # Safety
 /// `task` must point to the `task` field of a live `PendingPartRange` scheduled
@@ -1796,7 +1777,7 @@ impl<'a> LinkerContext<'a> {
                                 .path_with_pretty_initialized(&source.path, arena)
                                 .expect("OOM");
                         }
-                        // PORT NOTE: `Path::assert_pretty_is_valid` lives on the
+                        // Note: `Path::assert_pretty_is_valid` lives on the
                         // resolver-side `Path<'a>`; the logger `Path` has no
                         // such debug hook yet.
                         debug_assert!(source.path.text.as_ptr() != source.path.pretty.as_ptr());
@@ -1902,8 +1883,7 @@ impl<'a> LinkerContext<'a> {
         meta_flags: &mut [crate::js_meta::Flags],
         ast_import_records: &[bun_ast::import_record::List<'a>],
     ) -> Result<TlaCheck, AllocError> {
-        // PORT NOTE: reshaped for borrowck — Zig held &mut tla_checks[source_index] across recursive
-        // calls that also mutate tla_checks. We re-index after each recursion.
+        // Note: re-index `tla_checks` after each recursion — recursive calls also mutate it.
         if tla_checks[source_index as usize].depth == 0 {
             tla_checks[source_index as usize].depth = 1;
             if tla_keywords[source_index as usize].len > 0 {
@@ -2207,15 +2187,7 @@ impl<'a> LinkerContext<'a> {
         // across `RequireOrImportMetaCallback::init(self)` (`&mut self`) below.
         let parse_graph = unsafe { &*self.parse_graph };
 
-        // PORT NOTE: `Options.arena` / `source_map_allocator` were removed in
-        // the Rust port (printer uses global mimalloc + the explicit `bump`
-        // argument to `print_with_writer`). The dev-server source-map-arena
-        // selection is folded into TODO(port) until arena threading lands.
-        let _ = self.dev_server.is_some()
-            && parse_graph.input_files.items_loader()[source_index.get() as usize]
-                .is_javascript_like();
-
-        // PORT NOTE: reshaped for borrowck — `Options` borrows `ts_enums` /
+        // Note: reshaped for borrowck — `Options` borrows `ts_enums` /
         // `line_offset_tables` / `mangled_props` from `self.graph`, but the
         // `require_or_import_meta_for_source_callback` field below needs
         // `&mut self`. Detach the read-only borrows via raw-pointer round-trip
@@ -2288,29 +2260,25 @@ impl<'a> LinkerContext<'a> {
         };
 
         writer.buffer.reset();
-        // PORT NOTE: Zig moved `*writer` into the printer by value and wrote it
-        // back via `defer writer.* = printer.ctx;`. `BufferWriter` isn't
-        // `Clone`/`Default` in Rust; move it through `mem::replace` with a
-        // freshly-initialized writer instead.
+        // Note: `BufferWriter` isn't `Clone`/`Default`; move it through
+        // `mem::replace` with a freshly-initialized writer.
         let mut printer = js_printer::BufferPrinter::init(core::mem::replace(
             writer,
             js_printer::BufferWriter::init(),
         ));
 
-        // PORT NOTE: Zig's `ast.toAST()` bitwise-copies every field of
-        // `*const BundledAst` into a stack `Ast` that is never deinit'd. The
-        // Rust collections aren't `Copy`, so mirror the Zig shallow copy via
-        // `ptr::read` + `ManuallyDrop` (the resulting `Ast` aliases `ast`'s
-        // storage; dropping it would double-free).
+        // Note: shallow bitwise copy via `ptr::read` + `ManuallyDrop` — the
+        // resulting `Ast` aliases `ast`'s storage; dropping it would
+        // double-free.
         // SAFETY: `ast` is a valid `&BundledAst` for the duration of this call;
         // the read is a bitwise copy whose result is never dropped.
         let printer_ast = core::mem::ManuallyDrop::new(unsafe { core::ptr::read(ast) }.to_ast());
 
-        // PORT NOTE: `print_with_writer<'a>` requires `Renamer<'a,'a>` (the
+        // Note: `print_with_writer<'a>` requires `Renamer<'a,'a>` (the
         // printer struct stores it with a single lifetime), but `Renamer`'s
         // `'src` is invariant behind `&mut`, so the caller's `Renamer<'r,'src>`
         // cannot unify with the local `'a` picked from `alloc`/`mangled_props`.
-        // Zig threads it as a raw pointer (no lifetimes). Rebind via a
+        // Rebind via a
         // lifetime-only cast — sound because the renamer's borrowed data
         // (symbol map, source) strictly outlives this call.
         // SAFETY: lifetime-only erase; layout identical across instantiations.
@@ -2320,7 +2288,6 @@ impl<'a> LinkerContext<'a> {
 
         let enable_source_maps =
             self.options.source_maps != SourceMapOption::None && !source_index.is_runtime();
-        // PERF(port): was comptime bool dispatch — profile if it shows up on a hot path.
         let result = if enable_source_maps {
             js_printer::print_with_writer::<&mut js_printer::BufferPrinter, true>(
                 &mut printer,
@@ -2389,7 +2356,6 @@ impl<'a> LinkerContext<'a> {
         let all_sources: &[Source] = unsafe { (*self.parse_graph).input_files.items_source() };
 
         // Collect all local css names
-        // PERF(port): was stack-fallback alloc
         let mut local_css_names: HashMap<Ref, ()> = HashMap::new();
 
         for (source_index, maybe_css_ast) in all_css_asts.iter().enumerate() {
@@ -2402,8 +2368,6 @@ impl<'a> LinkerContext<'a> {
                     let mut symbol = symbol_;
                     if symbol.kind == bun_ast::symbol::Kind::LocalCss {
                         let r#ref = 'follow: {
-                            // PORT NOTE: Zig set `.tag = .symbol` after `init`;
-                            // `Ref` is packed in Rust — construct via `new`.
                             let mut r#ref = Ref::new(
                                 u32::try_from(inner_index).expect("int cast"),
                                 u32::try_from(source_index).expect("int cast"),
@@ -2427,8 +2391,7 @@ impl<'a> LinkerContext<'a> {
                         // SAFETY: `Symbol.original_name` is a `*const [u8]` arena
                         // pointer; valid for the link step.
                         let original_name: &[u8] = symbol.original_name.slice();
-                        // PERF(port): was stack-fallback alloc. The hash itself
-                        // is short-lived; use a scratch bump.
+                        // The hash itself is short-lived; use a scratch bump.
                         let scratch = ::bun_alloc::Arena::new();
                         let path_hash = ::bun_base64::wyhash_url_safe(
                             &scratch,
@@ -2446,7 +2409,7 @@ impl<'a> LinkerContext<'a> {
                             bstr::BStr::new(path_hash)
                         )
                         .expect("infallible: in-memory write");
-                        // TODO(port): arena() is arena; mangled_props key/value lifetime
+                        // The map owns its boxed values (freed with `mangled_props`).
                         self.mangled_props
                             .put(r#ref, final_generated_name.into_boxed_slice())
                             .expect("OOM");
@@ -2473,7 +2436,7 @@ impl<'a> LinkerContext<'a> {
         chunk_visit_map.set(index as usize);
 
         // Visit the other chunks that this chunk imports before visiting this chunk
-        // PORT NOTE: reshaped for borrowck — collect imports first to avoid aliasing &chunks[index] with recursive &mut chunks
+        // Note: reshaped for borrowck — collect imports first to avoid aliasing &chunks[index] with recursive &mut chunks
         let cross_chunk_imports: Vec<u32> = chunks[index as usize]
             .cross_chunk_imports
             .slice()
@@ -2493,7 +2456,7 @@ impl<'a> LinkerContext<'a> {
         // express cross-chunk dependencies via `cross_chunk_imports` above, but
         // HTML (and CSS) chunks only reference other chunks through pieces, so
         // recurse on those too.
-        // PORT NOTE: reshaped for borrowck — collect piece queries first so the
+        // Note: reshaped for borrowck — collect piece queries first so the
         // `&chunks[index]` borrow is dropped before the recursive `&mut chunks`
         // calls in the Chunk/Scb arms below. `final_rel_path` is re-indexed per
         // Asset arm (not hoisted) because it is now `Box<[u8]>` (not `Copy`).
@@ -2563,7 +2526,6 @@ impl<'a> LinkerContext<'a> {
 
         // Mix in the hash for this chunk
         let chunk = &chunks[index as usize];
-        // PORT NOTE: Zig `std.mem.asBytes(&u64)` → native-endian byte view.
         hash.write(&chunk.isolated_hash.to_ne_bytes());
     }
 
@@ -2575,7 +2537,6 @@ impl<'a> LinkerContext<'a> {
     ) {
         list.clear();
         list.reserve(export_refs.count());
-        // PORT NOTE: Zig set .items.len = count() then indexed; Rust pushes
         for &export_ref in export_refs.keys() {
             #[cfg(debug_assertions)]
             {
@@ -2646,8 +2607,6 @@ pub struct TreeShakeCtx<'a, 'r> {
 
 pub struct CodeSplitCtx<'a, 'r> {
     pub distances: &'r mut [u32],
-    // Spec (LinkerContext.zig:1579) passes `parts: []Vec(Part)` and only
-    // reads it.
     pub parts: &'r [bun_ast::PartList<'a>],
     pub import_records: &'r [bun_ast::import_record::List<'a>],
     pub file_entry_bits: &'r mut [AutoBitSet],
@@ -2771,8 +2730,7 @@ impl<'a> LinkerContext<'a> {
                         .path
                         .pretty
                 ),
-                // PORT NOTE: Zig printed `target.bakeGraph()` (a `bake.Graph` tag);
-                // `bake_graph()` lives in `bun_bake` (tier-6 — would back-edge).
+                // Note: `bake_graph()` lives in `bun_bake` (tier-6 — would back-edge).
                 // The debug log only needs a stable label, so print the `Target`
                 // tag directly via its `IntoStaticStr` derive.
                 <&'static str>::from(parse_graph.ast.items_target()[source_index as usize]),
@@ -2824,7 +2782,7 @@ impl<'a> LinkerContext<'a> {
 
         let part_count = ctx.parts[source_index as usize].len();
         for part_index in 0..part_count {
-            // PORT NOTE: reshaped for borrowck — re-borrow part each iteration since recursion mutates `parts`
+            // Note: reshaped for borrowck — re-borrow part each iteration since recursion mutates `parts`
             let part = &ctx.parts[source_index as usize].as_slice()[part_index];
             let mut can_be_removed_if_unused = part.can_be_removed_if_unused;
 
@@ -2837,8 +2795,7 @@ impl<'a> LinkerContext<'a> {
             // Also include any statement-level imports. Iterate by index so we
             // don't hold a borrow of `part`/`parts` across the recursive call —
             // the recursion never resizes this part's `import_record_indices`,
-            // so re-slicing each iteration is sound and matches Zig's plain
-            // `for (part.import_record_indices.slice())`.
+            // so re-slicing each iteration is sound.
             let import_indices_len = part.import_record_indices.len();
             for ii in 0..import_indices_len {
                 let import_index = ctx.parts[source_index as usize].as_slice()[part_index]
@@ -2932,8 +2889,6 @@ impl<'a> LinkerContext<'a> {
                 } else {
                     Loc::EMPTY.start
                 },
-                // Zig used `@tagName(stmts[0].data)`. `StmtData::tag()` → `StmtTag` which
-                // derives `strum::IntoStaticStr`.
                 if !stmts.is_empty() {
                     <&'static str>::from(stmts[0].data.tag())
                 } else {
@@ -2992,9 +2947,7 @@ impl<'a> LinkerContext<'a> {
 // `scanImportsAndExports.rs` callees.
 //
 // `linker_context/scanImportsAndExports.rs` calls these `LinkerContext`
-// methods inherently. Real ports of the `LinkerContext.zig` /
-// `linker_context/doStep5.zig` / `linker_context/generateCodeForLazyExport.zig`
-// bodies.
+// methods inherently.
 // ══════════════════════════════════════════════════════════════════════════
 
 // Local imports. `AstFlags` / `DeclaredSymbolList`
@@ -3002,13 +2955,13 @@ impl<'a> LinkerContext<'a> {
 use bun_ast::symbol::Use as SymbolUse;
 use bun_ast::{DependencyList, ImportItemStatus, PartSymbolUseMap};
 
-// `bundle_v2.zig:ImportTracker.{Status,Iterator}` — canonical definition lives
-// in `bundle_v2.rs` (matches Zig spec location). Re-exported here so the 30+
+// `ImportTracker::{Status,Iterator}`'s canonical definition lives
+// in `bundle_v2.rs`. Re-exported here so the 30+
 // unqualified uses in `advance_import_tracker` / `match_import_with_export`
 // below resolve unchanged.
 pub use crate::bundle_v2::{ImportTrackerIterator, ImportTrackerStatus};
 
-/// Field-wise eq for `ImportTracker`, matching Zig's `eql(ImportTracker)` shape.
+/// Field-wise eq for `ImportTracker`.
 #[inline]
 fn import_tracker_eq(a: &ImportTracker, b: &ImportTracker) -> bool {
     a.source_index.get() == b.source_index.get()
@@ -3017,32 +2970,32 @@ fn import_tracker_eq(a: &ImportTracker, b: &ImportTracker) -> bool {
 }
 
 impl<'a> LinkerContext<'a> {
-    /// Spec: `LinkerContext.zig:1298 runtimeFunction`.
+    /// Looks up the symbol `Ref` for a named export of the runtime module.
     #[inline]
     pub fn runtime_function(&self, name: &[u8]) -> Ref {
         self.graph.runtime_function(name)
     }
 
-    /// Spec: `LinkerContext.zig:2150 topLevelSymbolsToParts`.
+    /// Returns the part indices within file `id` that declare the
+    /// top-level symbol `ref`.
     #[inline]
     pub fn top_level_symbols_to_parts(&self, id: u32, r#ref: Ref) -> &[u32] {
         self.graph.top_level_symbol_to_parts(id, r#ref)
     }
 
-    /// Spec: `LinkerContext.zig:2154 topLevelSymbolsToPartsForRuntime`.
+    /// Returns the part indices in the runtime module that declare the
+    /// top-level symbol `ref`.
     #[inline]
     pub fn top_level_symbols_to_parts_for_runtime(&self, r#ref: Ref) -> &[u32] {
         self.top_level_symbols_to_parts(Index::RUNTIME.get(), r#ref)
     }
 
-    /// Spec: `LinkerContext.zig:489 source_`.
-    ///
-    /// PORT NOTE: returns `'static` so callers can hold the source across a
+    /// Note: returns `'static` so callers can hold the source across a
     /// `&mut self.log` borrow; the underlying `parse_graph.input_files` slab
     /// is append-only and outlives the link step (LIFETIMES.tsv: GRAPHBACKED).
     #[inline]
     pub fn get_source<I: TryInto<usize>>(&self, index: I) -> &'static Source {
-        // PORT NOTE: Zig spec is `index: anytype`; callers pass both `u32` and
+        // Note: callers pass both `u32` and
         // `usize`. Route through `TryInto<usize>` so the SoA index works for
         // either width without forcing `as`-casts at every call site.
         let index: usize = match index.try_into() {
@@ -3056,8 +3009,6 @@ impl<'a> LinkerContext<'a> {
         unsafe { &*core::ptr::from_ref(&(*self.parse_graph).input_files.items_source()[index]) }
     }
 
-    /// Spec: `LinkerContext.zig:496 scanCSSImports`.
-    ///
     /// `log` is an explicit parameter (not `self.log`) because the dev-server
     /// caller (`finish_from_bake_dev_server`) runs this *before* `load()` has
     /// initialized `self.log`, passing a stack-local `Log` instead.
@@ -3121,12 +3072,13 @@ impl<'a> LinkerContext<'a> {
         }
     }
 
-    /// Spec: `LinkerContext.zig:2158 createWrapperForFile`.
+    /// Creates the synthetic wrapper part (CommonJS or ESM) for a wrapped
+    /// file and records its part index in `wrapper_part_index`.
     pub fn create_wrapper_for_file(
         &mut self,
         wrap: WrapKind,
         wrapper_ref: Ref,
-        // PORT NOTE: `crate::Index` (`bun_ast::Index`),
+        // Note: `crate::Index` (`bun_ast::Index`),
         // not `bun_ast::Index` — the SoA `wrapper_part_index` column is
         // typed via the crate-root re-export.
         wrapper_part_index: &mut crate::Index,
@@ -3151,10 +3103,8 @@ impl<'a> LinkerContext<'a> {
                 let common_js_parts =
                     self.top_level_symbols_to_parts_for_runtime(self.cjs_runtime_ref);
 
-                // PORT NOTE: reshaped for borrowck — Zig held `runtime_parts`
-                // simultaneously with the mutable graph borrows below; the inner
-                // loop is empty (`if r#ref.eql(...) continue;` only) so it's a
-                // no-op kept for parity with the original.
+                // Note: the inner loop is intentionally a no-op
+                // (`if r#ref.eql(...) continue;` only).
                 for &part_id in common_js_parts {
                     let runtime_parts =
                         self.graph.ast.items_parts()[Index::RUNTIME.get() as usize].as_slice();
@@ -3350,12 +3300,11 @@ impl<'a> LinkerContext<'a> {
         }
     }
 
-    /// Spec: `LinkerContext.zig:1710 advanceImportTracker`.
+    /// Follows one step of an import chain: resolves what `tracker`'s import
+    /// points to in the target file and reports the match status.
     pub fn advance_import_tracker(&mut self, tracker: &ImportTracker) -> ImportTrackerIterator {
         let id = tracker.source_index.get();
-        // PORT NOTE: reshaped for borrowck — Zig held `&mut named_imports[id]`
-        // and `&import_records[id]` simultaneously; here we read `named_import`
-        // out first, then borrow the rest.
+        // Note: read `named_import` out first, then borrow the rest.
         let named_import: &NamedImport =
             match self.graph.ast.items_named_imports()[id as usize].get(&tracker.import_ref) {
                 Some(ni) => ni,
@@ -3529,15 +3478,17 @@ impl<'a> LinkerContext<'a> {
         }
     }
 
-    /// Spec: `LinkerContext.zig:1443 matchImportWithExport`.
+    /// Walks an import chain (through re-exports) to its final target and
+    /// returns how the import should be bound, collecting any re-export
+    /// dependencies along the way.
     pub fn match_import_with_export(
         &mut self,
         init_tracker: ImportTracker,
         re_exports: &mut bun_alloc::AstVec<Dependency>,
     ) -> MatchImport {
         let cycle_detector_top = self.cycle_detector.len();
-        // PORT NOTE: Zig's `defer cycle_detector.shrinkRetainingCapacity` is
-        // lowered to an explicit `truncate` after the `'loop_` below — the only
+        // Note: `cycle_detector` is restored by an explicit
+        // `truncate` after the `'loop_` below — the only
         // exits are the three `return`s that follow it, so a single post-loop
         // truncate covers every path. A scopeguard holding a raw `*mut` into
         // `self.cycle_detector` would be invalidated by the `&mut self`
@@ -3842,7 +3793,6 @@ impl<'a> LinkerContext<'a> {
                                 part_index: dep,
                                 source_index: bun_ast::Index::init(tracker.source_index.get()),
                             });
-                            // PERF(port): was assume_capacity
                         }
                     }
 
@@ -3893,25 +3843,24 @@ impl<'a> LinkerContext<'a> {
         result
     }
 
-    /// Spec: `LinkerContext.zig:2471 matchImportsWithExportsForFile`.
+    /// Resolves every named import in one file to its matching export,
+    /// recording the bindings in `imports_to_bind`.
     pub(crate) fn match_imports_with_exports_for_file(
         &mut self,
         named_imports_ptr: *const crate::bundled_ast::NamedImports,
         imports_to_bind: &mut crate::RefImportData,
         source_index: crate::IndexInt,
     ) {
-        // PORT NOTE: Zig clones into a local, sorts, iterates, then writes back.
-        // `ArrayHashMap` has no in-place key sort and `NamedImport` is non-Clone
-        // (owns a `Vec`), so we sort an index vector over the live
+        // Note: `ArrayHashMap` has no in-place key sort and `NamedImport` is
+        // non-Clone (owns a `Vec`), so we sort an index vector over the live
         // keys/values instead — same observable iteration order (ascending
-        // `inner_index`). The write-back is a no-op here since we never mutate
-        // the map.
+        // `inner_index`). We never mutate the map.
         //
-        // The Zig clone existed to break the alias between this parameter and
+        // This parameter aliases
         // `self.graph.ast.named_imports[source_index]`, which
         // `match_import_with_export` re-reads via the SoA column. Taking the
         // parameter as a raw `*const` (no uniqueness assertion) and reading
-        // through it preserves that alias-safety without the clone: no live
+        // through it preserves that alias-safety: no live
         // `&`/`&mut` to the column element spans the `&mut self` call below.
         //
         // SAFETY: `named_imports_ptr` points into the `graph.ast.named_imports`
@@ -4065,11 +4014,8 @@ impl<'a> LinkerContext<'a> {
         }
     }
 
-    /// Spec: `linker_context/generateCodeForLazyExport.zig`.
-    ///
     /// Thin inherent-method shim so callers can write
-    /// `this.generate_code_for_lazy_export(id)` (matches Zig's
-    /// `pub const generateCodeForLazyExport = @import(...)`). The full body —
+    /// `this.generate_code_for_lazy_export(id)`. The full body —
     /// including the CSS-modules `composes`/`local_scope` Visitor — lives in
     /// `linker_context/generateCodeForLazyExport.rs`.
     #[inline]
@@ -4083,7 +4029,8 @@ impl<'a> LinkerContext<'a> {
         )
     }
 
-    /// Spec: `LinkerContext.zig:503 generateNamedExportInFile`.
+    /// Synthesizes a named export symbol in a file (creating a new part for
+    /// it) and returns the symbol's `Ref` and the part index.
     pub fn generate_named_export_in_file(
         &mut self,
         source_index: crate::IndexInt,
@@ -4154,11 +4101,8 @@ impl<'a> LinkerContext<'a> {
             return Ok(crate::chunk::IntermediateOutput::Joiner(core::mem::take(j)));
         }
 
-        // PORT NOTE: Zig had `errdefer j.deinit()` around the initCapacity — Drop handles it.
         let mut pieces: Vec<OutputPiece> = Vec::with_capacity(count as usize);
-        // errdefer pieces.deinit() — Drop handles it
-        // PORT NOTE: Zig used `j.done(alloc)` (worker arena), so the joined
-        // buffer outlived this function. The Rust `StringJoiner::done()`
+        // Note: `StringJoiner::done()`
         // returns a `Box<[u8]>`; we must keep it alive alongside the pieces
         // (each `OutputPiece` stores a raw `*const u8` into it). It is moved
         // into the returned `OutputPieces` below.
@@ -4233,7 +4177,7 @@ impl<'a> LinkerContext<'a> {
                 _ => unreachable!(),
             }
 
-            // PORT NOTE: `Query` is a packed `u32` (`index: u29`, `kind: u3`);
+            // Note: `Query` is a packed `u32` (`index: u29`, `kind: u3`);
             // construct via `new` rather than field-init.
             pieces.push(OutputPiece::init(
                 &output[0..boundary],
@@ -4250,11 +4194,11 @@ impl<'a> LinkerContext<'a> {
     }
 }
 
-// PartialEq for MatchImport (needed for std.meta.eql in match_import_with_export)
+// PartialEq for MatchImport (used by match_import_with_export)
 impl PartialEq for MatchImport {
     fn eq(&self, other: &Self) -> bool {
-        // PORT NOTE: Zig `std.meta.eql` on a slice compares ptr+len, not contents —
-        // compare the raw fat pointer (address + length metadata).
+        // Note: intentionally compares the raw fat pointer
+        // (address + length metadata), not contents.
         std::ptr::eq(self.alias.as_raw(), other.alias.as_raw())
             && self.kind == other.kind
             && self.namespace_ref == other.namespace_ref
@@ -4271,8 +4215,8 @@ impl PartialEq for MatchImport {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct StmtList {
-    // TODO(port): arena field dropped — Vec uses global mimalloc; bundler is AST crate but
-    // these are temporary scratch buffers, not arena-backed in the original (uses generic arena param)
+    // Temporary scratch buffers: plain `Vec`s on the global allocator
+    // (cleared/reused per chunk, freed by Drop).
     pub inside_wrapper_prefix: InsideWrapperPrefix,
     pub outside_wrapper_prefix: Vec<Stmt>,
     pub inside_wrapper_suffix: Vec<Stmt>,
@@ -4304,9 +4248,6 @@ impl InsideWrapperPrefix {
     }
 }
 
-// TODO(port): `Expr`/`Stmt` builder helpers (`E::Call`, `S::SExpr` etc.)
-// — bun_js_parser AST builder surface not yet stable.
-
 impl InsideWrapperPrefix {
     pub(crate) fn append_non_dependency(&mut self, stmt: Stmt) -> Result<(), AllocError> {
         self.stmts.push(stmt);
@@ -4353,9 +4294,9 @@ impl InsideWrapperPrefix {
             return Ok(());
         }
 
-        // PORT NOTE: deep AST mutation chain — `s_expr_mut`/`e_await_mut`/
-        // `e_call_mut`/`e_array_mut` return `Option`; `.unwrap()` mirrors Zig's
-        // untagged-union field reads (panic on shape mismatch).
+        // Note: deep AST mutation chain — `s_expr_mut`/`e_await_mut`/
+        // `e_call_mut`/`e_array_mut` return `Option`; `.unwrap()` panics on
+        // shape mismatch.
         let mut first_dep_call_expr = self.stmts[self.sync_dependencies_end]
             .data
             .s_expr_mut()
@@ -4399,7 +4340,6 @@ impl InsideWrapperPrefix {
 
             let mut items = bun_ast::ExprNodeList::init_capacity(2);
             items.append_slice_assume_capacity(&[first_dep_call_expr, call_expr]);
-            // PERF(port): was assume_capacity
 
             let mut args = bun_ast::ExprNodeList::init_capacity(1);
             args.append_assume_capacity(Expr::init(
@@ -4409,7 +4349,6 @@ impl InsideWrapperPrefix {
                 },
                 Loc::EMPTY,
             ));
-            // PERF(port): was assume_capacity
 
             let promise_all_call = Expr::init(
                 E::Call {
@@ -4484,5 +4423,3 @@ pub enum StmtListWhich {
     InsideWrapperSuffix,
     AllStmts,
 }
-
-// ported from: src/bundler/LinkerContext.zig
diff --git a/src/bundler/LinkerGraph.rs b/src/bundler/LinkerGraph.rs
index 6ab2d8502cd..329a26df380 100644
--- a/src/bundler/LinkerGraph.rs
+++ b/src/bundler/LinkerGraph.rs
@@ -12,10 +12,9 @@ use bun_core::RawSlice;
 use crate::IndexStringMap::IndexStringMap;
 use crate::{ImportTracker, Index, JSAst, Part, Ref, UseDirective, import_record, index, part};
 // `items_<field>()` column accessors — bring the `*ListExt` traits into scope.
-// PORT NOTE: `BundledAstColumns` is emitted by ``
-// on `BundledAst`; un-gating here is paired with that derive landing in
-// `crate::bundled_ast` (same dependency `scanImportsAndExports.rs`
-// already imports as `BundledAstField`).
+// Note: `BundledAstColumns` is emitted by `bun_collections::multi_array_columns!`
+// on `BundledAst` in `crate::bundled_ast` (the same macro output
+// `scanImportsAndExports.rs` already imports as `BundledAstField`).
 bun_core::declare_scope!(LinkerGraph, visible);
 
 pub mod entry_point {
@@ -200,12 +199,12 @@ pub struct LinkerGraph<'a> {
     pub entry_points: entry_point::List,
     pub symbols: symbol::Map,
 
-    // PORT NOTE: lifetime-erased. Zig stores `std.mem.Allocator`; the Rust
+    // Note: lifetime-erased. The
     // arena is owned by `BundleV2` and outlives every `LinkerGraph` — kept as
     // a raw pointer (matching `LinkerContext.parse_graph: *mut Graph`) so the
     // struct stays `'static`-ish and `LinkerContext`/`Chunk` callers don't
-    // grow a `'bump` parameter yet. TODO(refactor): thread `'bump` once `Chunk`
-    // and `html_import_manifest` gain lifetimes.
+    // grow a `'bump` parameter; threading `'bump` would require `Chunk` and
+    // `html_import_manifest` to gain lifetimes first.
     pub bump: bun_ptr::BackRef<Arena>,
 
     pub code_splitting: bool,
@@ -236,7 +235,7 @@ pub struct LinkerGraph<'a> {
 }
 
 // SAFETY: `LinkerGraph` is shared read-mostly across worker threads during
-// linking (matches Zig, which has no Send/Sync). What makes `&LinkerGraph`
+// linking. What makes `&LinkerGraph`
 // sound to hold concurrently:
 //
 // - `bump: *const Arena` is a backref into `BundleV2`; the arena is frozen
@@ -277,7 +276,6 @@ impl<'a> LinkerGraph<'a> {
 
 impl<'a> LinkerGraph<'a> {
     pub fn init(bump: &Arena, file_count: usize) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(LinkerGraph {
             files: FileList::default(),
             files_live: BitSet::init_empty(file_count)?,
@@ -304,8 +302,8 @@ impl Default for LinkerGraph<'_> {
             parts_live: Vec::new(),
             entry_points: entry_point::List::default(),
             symbols: symbol::Map::default(),
-            // PORT NOTE: `bump` is a backref assigned in `init`/`LinkerContext::load`;
-            // dangling sentinel mirrors Zig's `undefined` (never read before assignment).
+            // Note: `bump` is a backref assigned in `init`/`LinkerContext::load`;
+            // dangling sentinel (never read before assignment).
             bump: bun_ptr::BackRef::from(core::ptr::NonNull::dangling()),
             code_splitting: false,
             ast: MultiArrayList::default(),
@@ -345,21 +343,18 @@ pub fn generate_new_symbol(
 ) -> Ref {
     let source_symbols = &mut symbols.symbols_for_source.slice_mut()[source_index as usize];
 
-    // PORT NOTE: Zig built `Ref.init(..)` then assigned `ref.tag = .symbol`.
-    // The Rust `Ref` is a packed `u64` with no public `tag` field, so use
-    // the `Ref::new` constructor that takes the tag explicitly.
     let ref_ = Ref::new(
-        source_symbols.len() as u32, // @truncate (u32 → u31 in pack())
-        source_index,                // @truncate
+        source_symbols.len() as u32, // narrows to u31 in pack()
+        source_index,
         RefTag::Symbol,
     );
 
     // TODO: will this crash on resize due to using threadlocal mimalloc heap?
     source_symbols.push(Symbol {
         kind,
-        // PORT NOTE: `Symbol.original_name` is a `StoreStr` —
-        // arena-owned slice whose lifetime is erased (matches the Zig
-        // `[]const u8`); caller guarantees it outlives the symbol table.
+        // Note: `Symbol.original_name` is a `StoreStr` —
+        // arena-owned slice whose lifetime is erased;
+        // caller guarantees it outlives the symbol table.
         original_name: bun_ast::StoreStr::new(original_name),
         ..Default::default()
     });
@@ -390,18 +385,11 @@ pub(crate) fn add_part_to_file(
     id: u32,
     part: Part,
 ) -> Result<u32, bun_alloc::AllocError> {
-    let part_id = parts[id as usize].len() as u32; // @truncate (u32)
+    let part_id = parts[id as usize].len() as u32;
     parts[id as usize].push(part);
 
-    // PORT NOTE: borrowck reshape. The Zig closure simultaneously holds
-    //   * `&mut parts[part_id].declared_symbols`   (column `parts` of `ast`)
-    //   * `&meta.top_level_symbol_to_parts_overlay[id]` (`meta`)
-    //   * `&ast.top_level_symbols_to_parts[id]`    (another `ast` column)
-    // and additionally caches `*?*TopLevelSymbolToParts` across calls.
-    // The two `ast` columns now arrive pre-split, so no detach/reattach is
-    // needed. The overlay-pointer cache is dropped — re-index `meta` each
-    // call (O(1); the cache was a Zig micro-opt that does not survive
-    // Stacked Borrows).
+    // Note: the two `ast` columns arrive pre-split, so no detach/reattach is
+    // needed; re-index `meta` on each call (O(1)).
     let declared_symbols: &mut DeclaredSymbolList =
         &mut parts[id as usize][part_id as usize].declared_symbols;
 
@@ -447,7 +435,7 @@ pub fn generate_symbol_import_and_use(
     part_index: u32,
     ref_: Ref,
     use_count: u32,
-    // PORT NOTE: callers are split between `crate::Index` (options_types)
+    // Note: callers are split between `crate::Index` (options_types)
     // and the structurally identical `bun_ast::Index` until the two newtypes
     // unify. Accept either via `Into` and normalize once.
     source_index_to_import_from: impl Into<Index>,
@@ -514,11 +502,11 @@ pub fn generate_symbol_import_and_use(
     debug_assert_eq!(part_ids.len(), new_dependencies.len());
     for (part_id, dependency) in part_ids.iter().zip(new_dependencies.iter_mut()) {
         *dependency = Dependency {
-            // PORT NOTE: `Dependency.source_index` is the structurally
+            // Note: `Dependency.source_index` is the structurally
             // identical `bun_ast::Index`; convert by value until the
             // two `Index` newtypes unify.
             source_index: bun_ast::Index::init(source_index_to_import_from.get()),
-            part_index: *part_id, // @truncate (already u32)
+            part_index: *part_id, // already u32
         };
     }
     Ok(())
@@ -663,7 +651,6 @@ impl<'a> LinkerGraph<'a> {
         dynamic_import_entry_points: &[index::Int],
         entry_point_original_names: &IndexStringMap,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let scb = server_component_boundaries.slice();
         self.files.set_capacity(sources.len())?;
         self.files.zero();
@@ -671,7 +658,7 @@ impl<'a> LinkerGraph<'a> {
         // SAFETY: capacity reserved above; columns zeroed by `zero()`.
         unsafe { self.files.set_len(sources.len()) };
 
-        // PORT NOTE: `Slice<T>` caches raw column pointers and does not borrow
+        // Note: `Slice<T>` caches raw column pointers and does not borrow
         // `self.files`, so the `split_mut()` borrows (tied to the local
         // `files_slice`) can stay live across other `&mut self.*` accesses
         // below. The columns are not reallocated during `load`.
@@ -690,9 +677,9 @@ impl<'a> LinkerGraph<'a> {
             // SAFETY: capacity reserved; columns initialized below.
             unsafe { self.entry_points.set_len(entry_points.len()) };
 
-            // PORT NOTE: borrowck reshape — Zig held `source_indices` /
-            // `path_strings` / `output_path_was_auto_generated` simultaneously
-            // (disjoint columns of the same `MultiArrayList`). `split_mut()`
+            // Note: `source_indices` / `path_strings` /
+            // `output_path_was_auto_generated` are disjoint columns of the
+            // same `MultiArrayList`. `split_mut()`
             // hands out all three at once; `self.entry_points` is not
             // reallocated until after `path_strings`/`source_indices` are done
             // with (the next `append_assume_capacity` is within the
@@ -746,12 +733,7 @@ impl<'a> LinkerGraph<'a> {
 
             let import_records_len = self.ast.items_import_records().len();
             self.meta.set_capacity(import_records_len)?;
-            // PORT NOTE: Zig does `meta.len = ast.len; meta.zero()` — a raw
-            // memset(0) is the valid empty state for Zig's unmanaged
-            // containers. Rust `Vec`/`Box` require a non-null dangling
-            // pointer when empty, so zeroed bytes violate their invariants
-            // (`slice::from_raw_parts` null-check trips on first read). Fill
-            // each slot with `Default` instead.
+            // Fill each slot with `Default`.
             let ast_len = self.ast.len();
             debug_assert!(ast_len <= import_records_len);
             for _ in 0..ast_len {
@@ -823,8 +805,7 @@ impl<'a> LinkerGraph<'a> {
         // Setup files
         {
             // set it to max value so that if we access an invalid one, it crashes
-            // PORT NOTE: Zig used `@memset(sliceAsBytes(...), 255)` to fill raw
-            // bytes; here we fill with `Index::INVALID` whose bytes are all
+            // Note: fill with `Index::INVALID` whose bytes are all
             // 0xFF (`#[repr(transparent)]` over `u32::MAX`).
             let stable_source_indices = self
                 .arena()
@@ -842,9 +823,7 @@ impl<'a> LinkerGraph<'a> {
         }
 
         {
-            // PORT NOTE: Zig built a borrowed `Symbol.NestedList` over the
-            // `ast.items(.symbols)` column then `clone`d it (memcpy). The Rust
-            // `Vec::clone` requires `T: Clone` which `Symbol` does not
+            // Note: `Vec::clone` requires `T: Clone` which `Symbol` does not
             // derive (it carries a raw `*const [u8]`), so spell out the
             // bitwise copy explicitly — `Symbol` has no `Drop` impl.
             let src_symbols: &[symbol::List] = self.ast.items_symbols();
@@ -864,25 +843,6 @@ impl<'a> LinkerGraph<'a> {
         }
 
         // TODO: const_values
-        // {
-        //     var const_values = this.const_values;
-        //     var count: usize = 0;
-        //
-        //     for (this.ast.items(.const_values)) |const_value| {
-        //         count += const_value.count();
-        //     }
-        //
-        //     if (count > 0) {
-        //         try const_values.ensureTotalCapacity(this.arena, count);
-        //         for (this.ast.items(.const_values)) |const_value| {
-        //             for (const_value.keys(), const_value.values()) |key, value| {
-        //                 const_values.putAssumeCapacityNoClobber(key, value);
-        //             }
-        //         }
-        //     }
-        //
-        //     this.const_values = const_values;
-        // }
 
         {
             let mut count: usize = 0;
@@ -894,10 +854,7 @@ impl<'a> LinkerGraph<'a> {
                 for ts_enums in self.ast.items_ts_enums().iter() {
                     debug_assert_eq!(ts_enums.keys().len(), ts_enums.values().len());
                     for (key, value) in ts_enums.keys().iter().zip(ts_enums.values().iter()) {
-                        // PERF(port): was assume_capacity_no_clobber
-                        // PORT NOTE: Zig copied the inner `StringHashMap` by
-                        // value (shallow struct copy). Rust clones the backing
-                        // `HashMap`; the per-file maps are not mutated after
+                        // Note: the per-file maps are not mutated after
                         // this point so aliasing is not required.
                         self.ts_enums.put_assume_capacity(*key, value.clone());
                     }
@@ -919,7 +876,6 @@ impl<'a> LinkerGraph<'a> {
                 .expect("unreachable");
             debug_assert_eq!(src.keys().len(), src.values().len());
             for (key, value) in src.keys().iter().zip(src.values().iter()) {
-                // PERF(port): was assume_capacity_no_clobber
                 resolved.put_assume_capacity(
                     key,
                     js_meta::ResolvedExport {
@@ -937,7 +893,7 @@ impl<'a> LinkerGraph<'a> {
         Ok(())
     }
 
-    /// Port of `LinkerGraph.zig:takeAstOwnership`. `clone_ast` left each
+    /// `clone_ast` left each
     /// `PartList`/import-record list with its allocator handle pointing at
     /// the per-worker `mi_heap` that built it; re-tag to `heap` (the
     /// bundle-thread arena) so linker-side `add_part_to_file` pushes call
@@ -945,13 +901,12 @@ impl<'a> LinkerGraph<'a> {
     /// owns `heap`. Zero-copy: only files the linker actually grows pay a
     /// (lazy, mimalloc-internal) cross-heap migration on first realloc.
     ///
-    /// Zig is a release no-op because `BabyList` passes the allocator at each
-    /// `append` call site; the Rust `Vec<T, &Arena>` stores it, so swap here.
-    /// Zig also transfers `part.dependencies` and `symbols`; the Rust port's
+    /// `Vec<T, &Arena>` stores its allocator, so swap it here.
+    /// `part.dependencies` and `symbols` need no transfer:
     /// `DependencyList` is `Vec<_, AstAlloc>` (linker-side grows just route
     /// through whichever thread's `AstAlloc` state is active — `AstAlloc` is a
     /// ZST, so there is nothing to retag) and new symbols feed through
-    /// `self.symbols: symbol::Map` (global) — neither needs transfer here.
+    /// `self.symbols: symbol::Map` (global).
     pub fn take_ast_ownership(&mut self, heap: &'a Arena) {
         for v in self.ast.items_import_records_mut() {
             bun_alloc::transfer_arena(v, heap);
@@ -962,7 +917,6 @@ impl<'a> LinkerGraph<'a> {
     }
 
     pub fn propagate_async_dependencies(&mut self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         struct State<'a> {
             visited: AutoBitSet,
             import_records: &'a [import_record::List<'a>],
@@ -1076,8 +1030,7 @@ impl File {
 impl Default for File {
     fn default() -> Self {
         Self {
-            // PORT NOTE: Zig had `entry_bits: AutoBitSet = undefined` — using an
-            // empty static-arm bitset here; load() overwrites before any read.
+            // Note: empty static-arm bitset; load() overwrites before any read.
             entry_bits: AutoBitSet::init_empty(0).expect("static AutoBitSet"),
             input_file: Index::source(0u32),
             distance_from_entry_point: u32::MAX,
@@ -1102,5 +1055,3 @@ bun_collections::multi_array_columns! {
         quoted_source_contents: Option<bun_alloc::AstVec<u8>>,
     }
 }
-
-// ported from: src/bundler/LinkerGraph.zig
diff --git a/src/bundler/OutputFile.rs b/src/bundler/OutputFile.rs
index c3a1d8fefb0..9aa4f42e4dc 100644
--- a/src/bundler/OutputFile.rs
+++ b/src/bundler/OutputFile.rs
@@ -116,7 +116,6 @@ pub struct BakeExtra {
     pub bake_is_runtime: bool,
 }
 
-// Zig: `pub const Index = bun.GenericIndex(u32, OutputFile);`
 pub type Index = bun_core::GenericIndex<u32, OutputFile>;
 pub type IndexOptional = bun_core::GenericIndexOptional<u32, OutputFile>;
 
@@ -127,8 +126,7 @@ pub type IndexOptional = bun_core::GenericIndexOptional<u32, OutputFile>;
 // We may use a different system call
 #[derive(Clone)]
 pub struct FileOperation {
-    // TODO(port): lifetime — Zig never frees `pathname`; may be borrowed from
-    // `Options.output_path`. Using owned `Box<[u8]>` for now.
+    // Owned copy so the field has a single, obvious lifetime.
     pub pathname: Box<[u8]>,
     pub fd: Fd,
     pub dir: Fd,
@@ -163,9 +161,8 @@ impl FileOperation {
 
     pub fn get_pathname(&self) -> &[u8] {
         if self.is_tmpdir {
-            // PORT NOTE: `resolve_path.joinAbs` writes into a threadlocal buffer in
-            // Zig; the Rust port returns a borrow into that TLS buffer (`'static`),
-            // which coerces to the `&self` lifetime here.
+            // Note: `join_abs` returns a borrow into a threadlocal buffer
+            // (`'static`), which coerces to the `&self` lifetime here.
             return resolve_path::join_abs::<platform::Auto>(RealFS::tmpdir_path(), &self.pathname);
         }
         &self.pathname
@@ -190,19 +187,15 @@ pub enum Value {
     Move(FileOperation),
     Copy(FileOperation),
     Noop,
-    Buffer {
-        // Zig carried `arena: std.mem.Allocator` alongside `bytes`; in Rust the
-        // global mimalloc arena backs `Box<[u8]>`, so the field is dropped.
-        bytes: Box<[u8]>,
-    },
-    // PORT NOTE: boxed to avoid blowing up `Value`'s inline size (`resolver::Result`
+    Buffer { bytes: Box<[u8]> },
+    // Note: boxed to avoid blowing up `Value`'s inline size (`resolver::Result`
     // is several hundred bytes).
     Pending(Box<bun_resolver::Result>),
     Saved(SavedFile),
 }
 
-// Zig `bun.copy(OutputFile, dst, src)` is a bitwise memcpy used to splice
-// finished output files into the final list. The `Pending` arm is never present
+// Cloning is only used to splice finished output files into the final list.
+// The `Pending` arm is never present
 // at that stage (only `buffer`/`copy`/`saved` are produced by `init`), so its
 // clone is intentionally unreachable rather than forcing `resolver::Result` to
 // be `Clone`.
@@ -239,10 +232,8 @@ impl Value {
                 // Use ExternalStringImpl to avoid cloning the string, at
                 // the cost of allocating space to remember the arena.
                 //
-                // Zig boxed a `FreeContext { arena }` and passed an `extern "C"`
-                // callback that frees the slice via that arena then destroys the
-                // context. With the global arena, the context collapses to the
-                // (ptr, len) pair already passed to the callback.
+                // The free callback needs no context beyond the
+                // (ptr, len) pair it is already passed.
                 extern "C" fn on_free(_ctx: *mut c_void, buffer: *mut c_void, len: usize) {
                     // SAFETY: `buffer`/`len` were produced by `heap::alloc` on a
                     // `Box<[u8]>` below; reconstructing and dropping is sound.
@@ -257,7 +248,7 @@ impl Value {
                 // (= `Box::leak`) yields a `&'static mut [u8]` borrow of the
                 // now-JSC-owned allocation; `on_free` reclaims it on GC.
                 let bytes: &'static mut [u8] = bun_core::heap::release(bytes);
-                // latin1 flag = true (matches Zig).
+                // latin1 flag = true.
                 BunString::create_external::<*mut c_void>(
                     bytes,
                     true,
@@ -266,9 +257,8 @@ impl Value {
                 )
             }
             Value::Pending(_) => unreachable!(),
-            // Zig: `else => |tag| bun.todoPanic(@src(), "handle .{s}", .{@tagName(tag)})`
-            // — an intentional shipped runtime panic for `.move`/`.copy`/`.saved`,
-            // not a port placeholder.
+            // An intentional shipped runtime panic for `.move`/`.copy`/`.saved`,
+            // not a placeholder.
             other => bun_core::todo_panic!("handle .{}", <&'static str>::from(other.kind())),
         }
     }
@@ -278,12 +268,9 @@ impl Value {
     /// callback (zero-copy). Caller guarantees `self` outlives every use of the
     /// returned string.
     ///
-    /// This is the faithful port of Zig's `Value.toBunString` as called from
-    /// `bake/production.zig` (`pt.bundled_outputs[i].value.toBunString()`): Zig
-    /// passes the union by value so the slice is aliased in place, and
     /// `PerThread.bundled_outputs` owns the bytes for the entire prerender
     /// phase. The consuming [`Self::to_bun_string`] cannot be used there
-    /// because the Rust `Vec<OutputFile>` is only borrowed.
+    /// because the `Vec<OutputFile>` is only borrowed.
     pub fn to_bun_string_ref(&self) -> BunString {
         match self {
             Value::Noop => BunString::EMPTY,
@@ -292,7 +279,7 @@ impl Value {
                     return BunString::EMPTY;
                 }
                 extern "C" fn noop(_: *mut c_void, _: *mut c_void, _: usize) {}
-                // latin1 = true (matches Zig).
+                // latin1 = true.
                 BunString::create_external::<*mut c_void>(
                     bytes,
                     true,
@@ -317,7 +304,6 @@ impl Value {
     }
 }
 
-/// `OutputFile.zig:SavedFile` (TYPE_ONLY move-in from bundler_jsc).
 #[derive(Default, Clone, Copy)]
 pub struct SavedFile {
     pub byte_size: u64,
@@ -325,8 +311,7 @@ pub struct SavedFile {
 
 impl OutputFile {
     pub fn init_pending(loader: Loader, pending: bun_resolver::Result) -> OutputFile {
-        // PORT NOTE: Zig copied the whole `Fs.Path` struct (`pending.pathConst().?.*`).
-        // The Rust `bun_paths::fs::Path<'static>` and `bun_resolver::fs::Path<'static>` are
+        // Note: `bun_paths::fs::Path<'static>` and `bun_resolver::fs::Path<'static>` are
         // distinct nominal types with identical layout; re-init from `text` (the
         // resolver path borrows arena/static memory, so the `'static` bound holds).
         let src_path = fs::Path::init(pending.path_const().expect("path").text);
@@ -357,9 +342,6 @@ impl OutputFile {
     ) -> OutputFile {
         let mut res = Self::init_file(file, pathname, size);
         if let Value::Copy(op) = &mut res.value {
-            // PORT NOTE: Zig wrote `res.value.copy.dir_handle = .fromStdDir(dir)` but
-            // `FileOperation` has no `dir_handle` field — looks like a latent bug; the
-            // intended field is `dir`.
             op.dir = dir;
         }
         res
@@ -442,7 +424,6 @@ impl OutputFile {
         }
     }
 
-    // TODO(port): narrow error set
     pub fn write_to_disk(&self, root_dir: Fd, root_dir_path: &[u8]) -> Result<(), Error> {
         match &self.value {
             Value::Noop => {}
@@ -453,8 +434,7 @@ impl OutputFile {
                 let mut rel_path: &[u8] = &self.dest_path;
                 if self.dest_path.len() > root_dir_path.len() {
                     rel_path = resolve_path::relative(root_dir_path, &self.dest_path);
-                    // Zig: `std.fs.path.dirname` returns `null` when there's no
-                    // separator; the Rust port returns `b""` instead.
+                    // `dirname` returns `b""` when there's no separator.
                     let parent = resolve_path::dirname::<platform::Auto>(rel_path);
                     if !parent.is_empty() {
                         bun_sys::Dir::borrow(&root_dir).make_path(parent)?;
@@ -465,11 +445,7 @@ impl OutputFile {
                 let _ = bun_sys::write_file_with_path_buffer(
                     &mut path_buf,
                     &bun_sys::WriteFileArgs {
-                        data: bun_sys::WriteFileData::Buffer {
-                            // Zig built a JSC ArrayBuffer view over `bytes` via
-                            // `@constCast`; the Rust side just borrows the slice.
-                            buffer: bytes,
-                        },
+                        data: bun_sys::WriteFileData::Buffer { buffer: bytes },
                         encoding: bun_sys::WriteFileEncoding::Buffer,
                         mode: if self.is_executable { 0o755 } else { 0o644 },
                         dirfd: root_dir,
@@ -488,14 +464,11 @@ impl OutputFile {
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn move_to(&self, _: &[u8], rel_path: &[u8], dir: Fd) -> Result<(), Error> {
         let Value::Move(mv) = &self.value else {
             unreachable!()
         };
-        // Zig: `std.posix.toPosixPath` + `bun.sliceTo(.., 0)` to NUL-terminate both
-        // paths into stack buffers. Mirrored with `resolve_path::z` over two
-        // `PathBuffer`s.
+        // NUL-terminate both paths into stack buffers via `resolve_path::z`.
         let mut src_buf = PathBuffer::uninit();
         let mut dst_buf = PathBuffer::uninit();
         let src = resolve_path::z(mv.get_pathname(), &mut src_buf);
@@ -504,11 +477,7 @@ impl OutputFile {
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn copy_to(&self, _: &[u8], rel_path: &[u8], dir: Fd) -> Result<(), Error> {
-        // PORT NOTE: Zig used `dir.stdDir().createFile(rel_path, .{})` and
-        // `std.fs.cwd().openFile(...)`. Mapped to `bun_sys::openat` (which takes
-        // a NUL-terminated `&ZStr`).
         let mut out_buf = PathBuffer::uninit();
         let fd_out = bun_sys::openat(
             dir,
@@ -538,9 +507,5 @@ impl OutputFile {
     }
 }
 
-// Zig: `pub const toJS = @import("../bundler_jsc/output_file_jsc.zig").toJS;`
-// Zig: `pub const toBlob = @import("../bundler_jsc/output_file_jsc.zig").toBlob;`
-// Deleted per PORTING.md — `to_js` / `to_blob` become extension-trait methods that
+// `to_js` / `to_blob` are extension-trait methods that
 // live in `bun_bundler_jsc`; the base type carries no jsc reference.
-
-// ported from: src/bundler/OutputFile.zig
diff --git a/src/bundler/ParseTask.rs b/src/bundler/ParseTask.rs
index 8795ba98ed5..67402efd94a 100644
--- a/src/bundler/ParseTask.rs
+++ b/src/bundler/ParseTask.rs
@@ -1,5 +1,3 @@
-//! Port of src/bundler/ParseTask.zig
-//!
 //! A `ParseTask` is the unit of work scheduled on the thread pool for each
 //! source file the bundler needs to parse. It carries everything needed to
 //! read the file (or use already-loaded contents), run the JS/CSS/etc. parser,
@@ -16,14 +14,12 @@ use bun_collections::VecExt;
 use bun_core::strings;
 use bun_core::{self, Error as AnyError, FeatureFlags, declare_scope, err, scoped_log};
 use bun_sys::Fd;
-// PORT NOTE: Zig `bun.threading.ThreadPool` is the *module*; the draft used the
-// struct alias which made `ThreadPoolLib::Task` unresolvable. Import the module.
 use bun_threading::thread_pool as ThreadPoolLib;
 
 use bun_ast::Index;
 use bun_ast::{self as ast, E, Expr, G, Part};
 use bun_js_parser as js_parser;
-// PORT NOTE: `BundledAst<'arena>` — the bundler graph stores `'static`-erased
+// `BundledAst<'arena>` — the bundler graph stores `'static`-erased
 // ASTs (arena outlives the link step). Use the crate-level alias so the
 // `Success`/helper signatures don't carry an explicit `'static` everywhere.
 use crate::JSAst;
@@ -44,13 +40,12 @@ use bun_resolver::{self as _resolver, Resolver};
 
 declare_scope!(ParseTask, hidden);
 
-/// `bun.jsc.EventLoopTask` (ParseTask.zig:Result.task). T6 type erased here.
 #[allow(non_snake_case)]
 mod EventLoop {
     pub(super) type Task = bun_event_loop::ConcurrentTask::ConcurrentTask;
 }
 
-// PORT NOTE: the per-file parse arena is held as `bump: &'static Bump` (the
+// the per-file parse arena is held as `bump: &'static Bump` (the
 // worker arena is pinned for the entire bundle pass — see `run_with_source_code`),
 // so `bump.alloc_*` / `ArenaString::into_bump_str` already yield `&'static`
 // borrows directly. No erasure helper is needed; `StoreStr::new` covers the
@@ -60,7 +55,7 @@ mod EventLoop {
 // live on the canonical `impl Plugin` in `bundle_v2.rs::api::JSBundler` next to
 // the other FFI wrappers; `bundler::JSBundlerPlugin` re-exports that type.
 //
-// PORT NOTE: `FileMap::get` now lives on the real `JSBundler::FileMap` in
+// `FileMap::get` now lives on the real `JSBundler::FileMap` in
 // bundle_v2.rs (no longer an opaque forward-decl). The placeholder
 // always-miss `get` shim that used to sit here has been removed so the two
 // inherent impls don't collide.
@@ -73,8 +68,9 @@ mod EventLoop {
 #[enum_tag(existing = ContentsOrFdTag)]
 pub enum ContentsOrFd {
     Fd { dir: Fd, file: Fd },
-    // TODO(port): arena lifetime — contents may be arena-owned, plugin-owned,
-    // or &'static (runtime). Using &'static as a placeholder.
+    // The `'static` is ownership-erased: contents may be arena-owned,
+    // plugin-owned, or truly static (runtime source). The producer keeps the
+    // backing allocation alive for the duration of the bundle pass.
     Contents(&'static [u8]),
 }
 
@@ -89,7 +85,7 @@ pub(crate) enum ContentsOrFdTag {
 // ───────────────────────────────────────────────────────────────────────────
 
 pub struct ParseTask {
-    // PORT NOTE: lifetime-erased `'static` — paths borrow from `DirnameStore`
+    // lifetime-erased `'static` — paths borrow from `DirnameStore`
     // (process-lifetime BSS string pool); see `bun_resolver::fs::Path<'a>`.
     pub path: Fs::Path<'static>,
     pub secondary_path_for_commonjs_interop: Option<Fs::Path<'static>>,
@@ -113,7 +109,7 @@ pub struct ParseTask {
     pub module_type: options::ModuleType,
     pub emit_decorator_metadata: bool,
     pub experimental_decorators: bool,
-    /// BACKREF (LIFETIMES.tsv) — Zig `*BundleV2` is mutable; written through in
+    /// BACKREF (LIFETIMES.tsv) — written through in
     /// `on_complete`. `None` only in the `default()` placeholder; every
     /// scheduled task has it set via `init` / `bundle_v2.rs` write-sites.
     pub ctx: Option<bun_ptr::ParentRef<BundleV2<'static>>>,
@@ -228,7 +224,7 @@ impl ParseTask {
     pub fn init(
         resolve_result: &_resolver::Result,
         source_index: Index,
-        // Zig `ctx: *BundleV2` — take `*mut` so the stored BACKREF retains
+        // Take `*mut` so the stored BACKREF retains
         // write provenance for `on_complete` (a `&BundleV2` param would shrink
         // provenance to read-only, making the later `&mut *ctx` UB).
         ctx: *mut BundleV2<'_>,
@@ -261,7 +257,7 @@ impl ParseTask {
             side_effects: resolve_result.primary_side_effects_data,
             // D042: resolver-side and bundler-side `jsx::Pragma` are the SAME
             // nominal type (`bun_options_types::jsx::Pragma`). Preserves
-            // jsxImportSource/runtime/etc. from tsconfig.json (.zig:122).
+            // jsxImportSource/runtime/etc. from tsconfig.json.
             jsx: resolve_result.jsx.clone(),
             source_index,
             module_type: resolve_result.module_type,
@@ -285,14 +281,11 @@ impl ParseTask {
             stage: ParseTaskStage::NeedsSourceCode,
             tree_shaking: false,
             is_entry_point: false,
-            // TODO(port): Zig struct-field defaults; Rust has no per-field
-            // default syntax. Consider impl Default for ParseTask and use
-            // `..Default::default()` here.
         }
     }
 
     /// Re-export of `parse_worker::get_runtime_source` as an associated fn so
-    /// callers can spell it `ParseTask::get_runtime_source` (matches Zig).
+    /// callers can spell it `ParseTask::get_runtime_source`.
     #[inline]
     pub fn get_runtime_source(target: options::Target) -> RuntimeSource {
         parse_worker::get_runtime_source(target)
@@ -538,10 +531,6 @@ pub mod parse_worker {
                 )
             }
         };
-        // PERF(port): Zig built one comptime string per Target variant via
-        // `inline else`. Here we use `const_format::concatcp!` per arm; the match
-        // itself is runtime but each arm yields a &'static str. Profile if the
-        // extra match matters (it shouldn't — called once).
 
         let parse_task = ParseTask {
             ctx: None,
@@ -576,7 +565,7 @@ pub mod parse_worker {
             is_entry_point: false,
         };
         let source = Source {
-            // PORT NOTE: `bun_ast::Source.path` is `bun_paths::fs::Path<'static>`, distinct
+            // `bun_ast::Source.path` is `bun_paths::fs::Path<'static>`, distinct
             // from `bun_resolver::fs::Path` (TYPE_ONLY mirror). Construct
             // directly rather than `clone()` across the type boundary.
             path: bun_paths::fs::Path {
@@ -587,7 +576,7 @@ pub mod parse_worker {
                 is_symlink: false,
             },
             contents: std::borrow::Cow::Borrowed(runtime_code.as_bytes()),
-            // PORT NOTE: `Source.index` is `bun_ast::Index` (newtype `u32`),
+            // `Source.index` is `bun_ast::Index` (newtype `u32`),
             // distinct from `bun_ast::Index`. Runtime source is index 0.
             index: bun_ast::Index(Index::RUNTIME.get()),
             ..Default::default()
@@ -596,9 +585,6 @@ pub mod parse_worker {
     }
 
     pub fn get_runtime_source(target: options::Target) -> RuntimeSource {
-        // PERF(port): Zig `switch (target) { inline else => |t| comptime ... }`
-        // monomorphized per variant at comptime. Runtime dispatch here is fine
-        // since each arm in `get_runtime_source_comptime` already yields static data.
         get_runtime_source_comptime(target)
     }
 
@@ -610,7 +596,7 @@ pub mod parse_worker {
     // (`Parser::to_lazy_export_ast`); `bun_css::BundlerStyleSheet` (gated
     // upstream); `Expr::init` overload set for arbitrary `E::*` defaults.
 
-    // PORT NOTE: `transpiler: *mut Transpiler` (raw, Zig `*Transpiler`). Callers
+    // `transpiler: *mut Transpiler` stays raw. Callers
     // (`get_ast`, `run_with_source_code`) may also hold a raw pointer to
     // `(*transpiler).resolver`; materializing `&mut Transpiler` here would assert
     // exclusive access to the whole struct and invalidate that sibling pointer.
@@ -662,11 +648,10 @@ pub mod parse_worker {
     // ───────────────────────────────────────────────────────────────────────────
     // CSS Symbol bridge — `bun_ast::Symbol` ↔ `bun_ast::Symbol`
     //
-    // Both port the same Zig `js_ast.Symbol` (Symbol.zig).
     // `StylesheetExtra.symbols` is `Vec<bun_ast::Symbol>`;
     // `new_lazy_export_ast_impl` takes `Vec<bun_ast::Symbol>`. Convert
     // field-by-field so CSS-module local refs (`ref.inner_index()`) index a
-    // populated symbol table (.zig:613).
+    // populated symbol table.
     // ───────────────────────────────────────────────────────────────────────────
 
     fn css_symbols_to_parser_symbols(
@@ -724,8 +709,8 @@ pub mod parse_worker {
     // The signature now names the real `ParserOptions`; body un-gates in lockstep
     // with the above.
 
-    // PORT NOTE: `transpiler`/`resolver` are raw `*mut` (Zig `*Transpiler` /
-    // `*Resolver`). In Zig the caller passes `resolver = &transpiler.resolver`, so
+    // `transpiler`/`resolver` are raw `*mut`. The caller may pass
+    // `resolver = &transpiler.resolver`, so
     // the two may point into the same allocation. Taking `&mut Transpiler` +
     // `&mut Resolver` would be aliased-`&mut` UB. We instead reborrow only the
     // disjoint `(*transpiler).options` field, never the whole struct.
@@ -752,24 +737,18 @@ pub mod parse_worker {
         match loader {
             Loader::Jsx | Loader::Tsx | Loader::Js | Loader::Ts => {
                 let _trace = perf::trace("Bundler.ParseJS");
-                // PORT NOTE: `ParserOptions` is not `Clone` (holds `&'a mut MacroContext`).
-                // Zig (.zig:335-342) passes the *same* `opts` (bitwise copy) to the
-                // empty-AST fallback; since Rust moves `opts` into `.parse()`,
+                // `ParserOptions` is not `Clone` (holds `&'a mut MacroContext`).
+                // The empty-AST fallback needs the same options; since `opts`
+                // moves into `.parse()`,
                 // snapshot a faithful field-by-field copy via
                 // `Options::clone_for_lazy_export` (co-located with the struct so
                 // field drift is a hard error) before the move.
                 let fallback_opts = opts.clone_for_lazy_export();
                 let module_type = opts.module_type;
-                return if let Some(res) = (crate::cache::JavaScript {}).parse(
-                    bump, // TODO(port): zig passed transpiler.arena
-                    opts,
-                    &topts.define,
-                    log,
-                    source,
-                )? {
-                    // PORT NOTE: Zig's `js_parser.Result` is a bare-union whose
-                    // `.ast` field is read unconditionally. The Rust port models it
-                    // as an enum; `Cached`/`AlreadyBundled` are runtime-loader
+                return if let Some(res) =
+                    (crate::cache::JavaScript {}).parse(bump, opts, &topts.define, log, source)?
+                {
+                    // `Cached`/`AlreadyBundled` are runtime-loader
                     // states that never reach the bundler's `getAST`, so unwrap.
                     match res {
                         bun_js_parser::Result::Ast(ast) => Ok(JSAst::init(*ast)),
@@ -783,8 +762,6 @@ pub mod parse_worker {
                 } else {
                     get_empty_ast::<E::Object>(log, transpiler, fallback_opts, bump, source)
                 };
-                // PERF(port): Zig used `switch (bool) { inline else => |as_undefined| ... }`
-                // to monomorphize the RootType. Expanded to two calls.
             }
             Loader::Json | Loader::Jsonc => {
                 let _trace = perf::trace("Bundler.ParseJSON");
@@ -793,7 +770,7 @@ pub mod parse_worker {
                 } else {
                     bun_resolver::tsconfig_json::JsonMode::Json
                 };
-                // SAFETY: `resolver` is a live `*mut Resolver` (Zig `*Resolver`);
+                // SAFETY: `resolver` is a live `*mut Resolver`;
                 // `caches` is disjoint from `(*transpiler).options` reborrowed above.
                 let root: Expr = unsafe { &mut (*resolver).caches.json }
                     .parse_json(log, source, mode, true)?
@@ -814,8 +791,7 @@ pub mod parse_worker {
             Loader::Toml => {
                 let _trace = perf::trace("Bundler.ParseTOML");
                 let mut temp_log = Log::init();
-                // PORT NOTE: Zig `defer { temp_log.cloneToWithRecycled(log, true);
-                // temp_log.msgs.clearAndFree() }` runs on the error path too.
+                // `temp_log` must flush into `log` on the error path too.
                 // scopeguard would alias `log`/`temp_log` (both borrowed mutably
                 // below); reshape as a closure so every `?` exits through one
                 // post-amble that flushes `temp_log`.
@@ -918,7 +894,7 @@ pub mod parse_worker {
                             Some(source),
                             Loc::EMPTY,
                             b"Failed to render markdown to HTML",
-                        ); // logger OOM-only (Zig: catch unreachable)
+                        ); // logger OOM-only
                         return Err(err!("ParserError"));
                     }
                 };
@@ -954,7 +930,7 @@ pub mod parse_worker {
 
             Loader::SqliteEmbedded | Loader::Sqlite => {
                 if !topts.target.is_bun() {
-                    // logger OOM-only (Zig: catch unreachable)
+                    // logger OOM-only
                     let _ = log.add_error(
                         Some(source),
                         Loc::EMPTY,
@@ -1075,7 +1051,7 @@ pub mod parse_worker {
             Loader::Napi => {
                 // (dap-eval-cb "source.contents.ptr")
                 if topts.target == options::Target::Browser {
-                    // logger OOM-only (Zig: catch unreachable)
+                    // logger OOM-only
                     let _ = log.add_error(
                     Some(source),
                     Loc::EMPTY,
@@ -1142,7 +1118,7 @@ pub mod parse_worker {
                 ));
             }
             Loader::Html => {
-                // PORT NOTE: scope the scanner so its `&mut log` / `&source`
+                // scope the scanner so its `&mut log` / `&source`
                 // borrows release before `new_lazy_export_ast` re-borrows them.
                 let import_records = {
                     let mut scanner = HTMLScanner::init(log, source);
@@ -1209,18 +1185,18 @@ pub mod parse_worker {
                 let mut import_records = Vec::<ImportRecord>::default();
                 let source_code = &source.contents;
                 let mut temp_log = Log::init();
-                // PORT NOTE: Zig `defer { temp_log.appendToMaybeRecycled(log, source) }` —
-                // folded into linear control flow (scopeguard would alias `log`/`temp_log`).
+                // `temp_log` is flushed into `log` on every exit path via linear
+                // control flow (scopeguard would alias `log`/`temp_log`).
 
                 const CSS_MODULE_SUFFIX: &[u8] = b".module.css";
                 let enable_css_modules = source.path.pretty.len() > CSS_MODULE_SUFFIX.len()
                     && &source.path.pretty[source.path.pretty.len() - CSS_MODULE_SUFFIX.len()..]
                         == CSS_MODULE_SUFFIX;
-                // PORT NOTE: `parse_bundler` takes `ParserOptions<'static>` (the
+                // `parse_bundler` takes `ParserOptions<'static>` (the
                 // `'a` on `ParserOptions` is PhantomData-only; storage is a raw
                 // `NonNull<Log>`). Construct via `default(None)` to get `'static`,
                 // then poke the logger pointer in directly — `temp_log` outlives
-                // all parsing/minification below (mirrors Zig's `*Log` aliasing).
+                // all parsing/minification below.
                 let parser_options = {
                     let mut parseropts = bun_css::ParserOptions::default(None);
                     parseropts.logger = Some(core::ptr::NonNull::from(&mut temp_log));
@@ -1240,7 +1216,7 @@ pub mod parse_worker {
                 ) {
                     Ok(v) => v,
                     Err(e) => {
-                        // .zig:587 — surface the actual CSS parse diagnostic.
+                        // Surface the actual CSS parse diagnostic.
                         let _ = e.add_to_logger(&mut temp_log, source);
                         let _ = temp_log.append_to_maybe_recycled(log, source);
                         return Err(err!("SyntaxError"));
@@ -1261,7 +1237,7 @@ pub mod parse_worker {
                     },
                     &extra,
                 ) {
-                    // .zig:604 — surface the actual minify diagnostic.
+                    // Surface the actual minify diagnostic.
                     let _ = e.add_to_logger(&mut temp_log, source);
                     let _ = temp_log.append_to_maybe_recycled(log, source);
                     return Err(err!("MinifyError"));
@@ -1271,15 +1247,13 @@ pub mod parse_worker {
                 }
                 // If this is a css module, the final exports object wil be set in `generateCodeForLazyExport`.
                 let root = Expr::init(E::Object::default(), Loc { start: 0 });
-                // PORT NOTE: `StylesheetExtra.symbols` is
+                // `StylesheetExtra.symbols` is
                 // `Vec<bun_ast::Symbol>`; `new_lazy_export_ast_impl` takes
-                // `Vec<bun_ast::Symbol>`. Both port the same Zig
-                // `js_ast.Symbol`; convert field-by-field so CSS-module local refs
-                // index a populated symbol table (.zig:613).
+                // `Vec<bun_ast::Symbol>`. Convert field-by-field so CSS-module local refs
+                // index a populated symbol table.
                 let symbols = css_symbols_to_parser_symbols(&extra.symbols, bump);
-                // PORT NOTE: Zig `defer temp_log.appendToMaybeRecycled(log, source)`
-                // (.zig:564-566) flushes on EVERY exit including this `try`; mirror
-                // by matching explicitly so accumulated CSS-module diagnostics are
+                // `temp_log` flushes into `log` on EVERY exit; match explicitly
+                // so accumulated CSS-module diagnostics are
                 // not dropped on the error path.
                 let lazy = js_parser::new_lazy_export_ast_impl(
                     bump,
@@ -1385,8 +1359,8 @@ pub mod parse_worker {
     // `bake_types::Framework.built_in_modules` value variant carrying `&[u8]` (vs
     // `Box<[u8]>` here) and `resolver.caches.fs.read_file_with_allocator` shape.
 
-    // PORT NOTE: `transpiler`/`resolver` are raw `*mut` (Zig `*Transpiler` /
-    // `*Resolver`). Callers pass `resolver = &mut (*transpiler).resolver`; taking
+    // `transpiler`/`resolver` are raw `*mut`.
+    // Callers pass `resolver = &mut (*transpiler).resolver`; taking
     // `&mut Transpiler` + `&mut Resolver` would be aliased-`&mut` UB. We only
     // touch the disjoint `(*transpiler).fs` and `(*resolver).caches.fs` fields.
     fn get_code_for_parse_task_without_plugins(
@@ -1478,7 +1452,7 @@ pub mod parse_worker {
                     read_arena,
                 ) {
                     Ok(e) => {
-                        // PORT NOTE: `bun_resolver::cache::Entry` ↔ `crate::cache::Entry`
+                        // `bun_resolver::cache::Entry` ↔ `crate::cache::Entry`
                         // are structurally identical twins; convert
                         // by-variant so ownership of `Owned(Vec<u8>)` transfers.
                         use bun_resolver::cache::Contents as RC;
@@ -1501,7 +1475,12 @@ pub mod parse_worker {
                     }
                     Err(e) => {
                         let source = Source::init_empty_file(
-                            // TODO(port): zig duped via log.msgs.arena
+                            // `file_path.text`
+                            // borrows either the process-lifetime DirnameStore
+                            // pool (resolver paths) or, after the
+                            // `BuiltInModule::Import` reassignment above, the
+                            // framework-owned `built_in_modules` storage held by
+                            // the BundleV2 — both outlive the log's consumption.
                             file_path.text,
                         );
                         if e == err!("ENOENT") || e == err!("FileNotFound") {
@@ -1550,7 +1529,7 @@ pub mod parse_worker {
     // `dispatch::PluginVTable` slot). Also calls the gated
     // `get_code_for_parse_task_without_plugins`.
 
-    // PORT NOTE: `transpiler`/`resolver` are raw `*mut` — see
+    // `transpiler`/`resolver` are raw `*mut` — see
     // `get_code_for_parse_task_without_plugins`.
     #[allow(clippy::too_many_arguments)]
     fn get_code_for_parse_task<'b>(
@@ -1618,7 +1597,7 @@ pub mod parse_worker {
     pub struct OnBeforeParsePlugin<'a, 'b: 'a> {
         task: &'a mut ParseTask,
         log: &'a mut Log,
-        // PORT NOTE: raw `*mut` (Zig `*Transpiler` / `*Resolver`). Callers pass
+        // raw `*mut`. Callers pass
         // `resolver = &mut (*transpiler).resolver`; storing `&'a mut Transpiler<'b>`
         // alongside `&'a mut Resolver<'b>` would be aliased-`&mut` UB. The data
         // lifetime `'b` is retained on the pointee for variance only.
@@ -1628,14 +1607,14 @@ pub mod parse_worker {
         file_path: &'a mut Fs::Path<'b>,
         loader: &'a mut Loader,
         deferred_error: Option<AnyError>,
-        // Zig `*i32`. `fetch_source_code` and `OnBeforeParsePlugin__isDone` re-enter
+        // `fetch_source_code` and `OnBeforeParsePlugin__isDone` re-enter
         // via FFI while the outer `run` call has already handed this same i32 to
         // C++, so a `&'a mut i32` here would be aliased-`&mut` UB. `Cell<i32>` is
         // `repr(transparent)` over `UnsafeCell<i32>`; FFI receives `Cell::as_ptr()`
         // (a real `*mut i32`) and Rust callers use safe `.get()/.set()`.
         should_continue_running: &'a core::cell::Cell<i32>,
 
-        // Raw pointer (Zig: `?*OnBeforeParseResult`). Must stay raw — the pointee
+        // Raw pointer. Must stay raw — the pointee
         // is `OnBeforeParseResultWrapper.result`, and `get_wrapper` walks back to
         // the parent via offset_of; a `&mut` here would (a) shrink provenance to
         // the inner field and (b) alias with any `&`/`&mut` to the wrapper.
@@ -1712,11 +1691,10 @@ pub mod parse_worker {
         }
     }
 
-    // Restore the Zig comptime asserts (`ParseTask.zig:808-818`) the port dropped.
     // These structs are passed by-pointer to **third-party** native plugins via
     // `packages/bun-native-bundler-plugin-api/bundler_plugin.h`, so layout drift
     // is a silent ABI break for every plugin in the wild. Literals are the 64-bit
-    // C layout; TODO(port): replace with codegen-probed constants.
+    // C layout from `bundler_plugin.h`.
     bun_core::assert_ffi_layout!(
         OnBeforeParseArguments, 64, 8;
         struct_size @ 0, context @ 8, path_ptr @ 16, path_len @ 24,
@@ -1777,14 +1755,12 @@ pub mod parse_worker {
         }
 
         pub(crate) fn append(&self, log: &mut Log, namespace: &'static [u8]) {
-            // Zig (ParseTask.zig:874-884) passes `this.path()` through and dupes
-            // `source_line_text` via `log.msgs.arena`. `Location.{file,line_text}`
+            // `Location.{file,line_text}`
             // are `&'static [u8]` here; `Log::dupe` copies into Log-owned storage
             // (freed when the Log drops) and returns a lifetime-erased borrow —
             // the "alloc-dupe into the log arena" pattern. We dupe `path` too:
-            // Zig stored it unduped (a raw slice into C-plugin memory that may be
-            // freed after `log_fn` returns — a latent UAF in the spec); duping is
-            // strictly safer and matches the intent.
+            // a raw slice into C-plugin memory may be
+            // freed after `log_fn` returns, so duping is required.
             let source_line_text = self.source_line_text();
             let file = log.dupe(self.path());
             let line_text = if !source_line_text.is_empty() {
@@ -1854,9 +1830,8 @@ pub mod parse_worker {
         pub loader: Loader,
         #[cfg(debug_assertions)]
         pub check: u32, // Value to ensure OnBeforeParseResult is wrapped in this struct
-        // TODO(port): zig used `if (debug) u32 else u0`; in release this field
-        // must be zero-sized to keep extern layout matching headers. Verify
-        // with static_assert against bun.c.
+        // (the `cfg(debug_assertions)` gate
+        // above removes the field entirely in release.)
         pub result: OnBeforeParseResult,
     }
 
@@ -1950,10 +1925,7 @@ pub mod parse_worker {
                     return 1;
                 }
             };
-            // PORT NOTE: in Zig (`.zig:953-975`) `entry.contents` is a slice into
-            // the worker arena (`this.arena`) with no destructor, so storing
-            // `entry.contents.ptr` and letting `entry` go out of scope is sound.
-            // In Rust `Contents::Owned(Vec<u8>)` (the file-read path — see
+            // `Contents::Owned(Vec<u8>)` (the file-read path — see
             // `.rs:1287` / `resolver/lib.rs:2285`) frees on drop, which would
             // leave `result.source_ptr` / `wrapper.original_source` dangling for
             // the native plugin and `OnBeforeParsePlugin::run` to read through.
@@ -2021,8 +1993,8 @@ pub mod parse_worker {
     pub(crate) unsafe extern "C" fn OnBeforeParsePlugin__isDone(
         this: *mut OnBeforeParsePlugin<'_, '_>,
     ) -> i32 {
-        // SAFETY: called from C++ with valid ptr. Read via raw pointers (mirrors
-        // Zig `@fieldParentPtr`) — `wrapper.result` aliases `*result`, so forming
+        // SAFETY: called from C++ with valid ptr. Read via raw pointers
+        // — `wrapper.result` aliases `*result`, so forming
         // overlapping references would be UB, and a `&mut`-derived `*mut` would
         // lack provenance over the enclosing wrapper.
         unsafe {
@@ -2055,7 +2027,6 @@ pub mod parse_worker {
     impl<'a, 'b: 'a> OnBeforeParsePlugin<'a, 'b> {
         pub fn run(
             &mut self,
-            // TODO(port): jsc::api arrives from move-in (TYPE_ONLY → bundler)
             plugin: &bundler::JSBundlerPlugin,
             from_plugin: &mut bool,
         ) -> core::result::Result<CacheEntry, AnyError> {
@@ -2163,7 +2134,7 @@ pub mod parse_worker {
                     // a second `&mut` via `&mut *args.context` while `&mut self`
                     // is live would be aliased-`&mut` UB.
                     self.log.errors += 1;
-                    let _ = self.log.add_msg(msg); // logger OOM-only (Zig: catch unreachable)
+                    let _ = self.log.add_msg(msg); // logger OOM-only
                     return Err(err!("InvalidNativePlugin"));
                 }
 
@@ -2177,7 +2148,7 @@ pub mod parse_worker {
 
                 if !wrapper.result.source_ptr.is_null() {
                     let ptr = wrapper.result.source_ptr;
-                    // PORT NOTE: `ExternalFreeFunction.function` is `Option<unsafe extern "C" fn>`;
+                    // `ExternalFreeFunction.function` is `Option<unsafe extern "C" fn>`;
                     // `OnBeforeParseResult.free_user_context` is `Option<extern "C" fn>` (safe ABI per
                     // the C header). Coerce safe→unsafe via cast.
                     let free_fn = wrapper
@@ -2251,14 +2222,14 @@ pub mod parse_worker {
 
         // `has_created` ⇒ `data`/`transpiler` were initialized in `create()`.
         let data = this.data.as_mut().expect("Worker.data set in create()");
-        // PORT NOTE: `resolver` is a field of `*transpiler` (Zig
-        // `&transpiler.resolver`). Hold both as raw `*mut` and never materialize
+        // `resolver` is a field of
+        // `*transpiler`. Hold both as raw `*mut` and never materialize
         // `&mut Transpiler` while `resolver` is live — the callee chain takes raw
         // pointers and reborrows disjoint fields only.
         // SAFETY: `data.transpiler` is initialized (see above) and pinned for the
         // bundle pass.
         let transpiler: *mut Transpiler<'static> = &raw mut data.transpiler;
-        // PORT NOTE: errdefer transpiler.resetStore() — reshaped: call on the err
+        // errdefer transpiler.resetStore() — reshaped: call on the err
         // path explicitly (scopeguard would alias `transpiler` access below).
         // SAFETY: `transpiler` is live; `resolver` projects a field of it.
         let resolver: *mut Resolver = unsafe { core::ptr::addr_of_mut!((*transpiler).resolver) };
@@ -2307,7 +2278,7 @@ pub mod parse_worker {
         log: &mut Log,
         entry: &mut CacheEntry,
     ) -> core::result::Result<Success, AnyError> {
-        // PORT NOTE: reshaped for borrowck — `transpiler_for_target` borrows `this`
+        // reshaped for borrowck — `transpiler_for_target` borrows `this`
         // mutably; we may need to call it again below (server-components branch),
         // so hold it as a raw pointer and reborrow per use site.
         //
@@ -2317,8 +2288,8 @@ pub mod parse_worker {
         // directly — that retag of the parent `&mut` pops the SharedRW tag chain
         // backing the first `transpiler` (and the `resolver` field-projection
         // derived from it), making the later `(*resolver)` derefs in `get_ast` UB.
-        // Zig (.zig:1124, .zig:1189) rebinds `transpiler` while keeping `resolver`
-        // pointing into the original — valid in Zig (no aliasing model); in Rust
+        // `transpiler` may be rebound below while `resolver` keeps
+        // pointing into the original;
         // both calls' `&mut self` must be children of the same raw so neither pops
         // the other's tag chain.
         let worker_raw: *mut crate::Worker = this;
@@ -2331,14 +2302,14 @@ pub mod parse_worker {
         // SAFETY: `worker_raw` just derived from the live `this: &mut Worker`.
         let mut transpiler: *mut Transpiler<'static> =
             std::ptr::from_mut(unsafe { (*worker_raw).transpiler_for_target(task.known_target) });
-        // PORT NOTE: Zig errdefers (`transpiler.resetStore()` .zig:1123 and
-        // `if (.fd) entry.deinit(arena)` .zig:1148) are reshaped into the
+        // Error-path cleanup (`transpiler.resetStore()` and
+        // `if (.fd) entry.deinit(arena)`) is reshaped into the
         // explicit `match ast_result { Err(e) => ... }` cleanup below — scopeguard
         // would alias the `&mut Transpiler` / `&mut CacheEntry` borrows that
         // follow. There are no other fallible `?` between here and that match.
-        // PORT NOTE: `resolver` is a field of `*transpiler` (Zig
-        // `&transpiler.resolver`). Keep raw — never materialize `&mut Transpiler`
-        // while a `&mut` derived from `resolver` is live. Per Zig, `resolver` is
+        // `resolver` is a field of
+        // `*transpiler`. Keep raw — never materialize `&mut Transpiler`
+        // while a `&mut` derived from `resolver` is live. `resolver` is
         // bound *before* the possible `transpiler` reassignment below and stays
         // pointing into the original target's transpiler.
         // SAFETY: `transpiler` just derived from a live `&mut`.
@@ -2417,10 +2388,10 @@ pub mod parse_worker {
         {
             // separate_ssr_graph makes boundaries switch to client because the server file uses that generated file as input.
             // this is not done when there is one server graph because it is easier for plugins to deal with.
-            // SAFETY: route through `worker_raw` (see top-of-function PORT NOTE)
+            // SAFETY: route through `worker_raw` (see top-of-function note)
             // so this call's `&mut self` is a child of the same raw and does not
             // pop the SharedRW tag backing `resolver` (which still points into the
-            // original target's transpiler per Zig .zig:1189).
+            // original target's transpiler).
             transpiler = std::ptr::from_mut(unsafe {
                 (*worker_raw).transpiler_for_target(options::Target::Browser)
             });
@@ -2432,7 +2403,7 @@ pub mod parse_worker {
         // Allocated in the worker arena so `js_parser::new_lazy_export_ast`'s
         // `&'bump Source` parameter is satisfied (`bump` is the same arena).
         let source: &'static Source = bump.alloc(Source {
-            // PORT NOTE: `Source.path` is `bun_paths::fs::Path<'static>`, distinct from
+            // `Source.path` is `bun_paths::fs::Path<'static>`, distinct from
             // `bun_resolver::fs::Path` (TYPE_ONLY mirror). Construct
             // field-by-field across the type boundary.
             path: bun_paths::fs::Path {
@@ -2443,7 +2414,7 @@ pub mod parse_worker {
                 is_symlink: file_path.is_symlink,
             },
             index: bun_ast::Index(task.source_index.get()),
-            // PORT NOTE: `entry.contents` is owned by `task.stage` (written back by
+            // `entry.contents` is owned by `task.stage` (written back by
             // the caller after parse — see `ParseTask::run`). `Source` is stored in
             // `Success` which lives no longer than the `ParseTask` itself, so this
             // borrow is sound. Routed through the audited `StoreStr` arena-erasure
@@ -2481,7 +2452,7 @@ pub mod parse_worker {
         // D042: `crate::options::jsx::Pragma` IS `bun_js_parser::options::JSX::Pragma`
         // (both re-export `bun_options_types::jsx::Pragma`). `to_parser_jsx_pragma`
         // applies the `_None → Automatic` runtime fold the old `From` bridge did so
-        // parser-side `== Automatic` checks keep their semantics (.zig:1207).
+        // parser-side `== Automatic` checks keep their semantics.
         let mut opts = ParserOptions::init(
             crate::transpiler::to_parser_jsx_pragma(task.jsx.clone()),
             loader,
@@ -2496,8 +2467,8 @@ pub mod parse_worker {
         // `Transpiler.macro_context` is `Option<bun_ast::Macro::MacroContext>`
         // (same nominal type as `ParserOptions.macro_context`'s pointee). Reborrow
         // through the raw `*mut Transpiler` so the `&mut MacroContext` is disjoint
-        // from `topts` (which borrows `(*transpiler).options`). `.unwrap()` mirrors
-        // Zig `transpiler.macro_context.?` — caller (`BundleV2::init`) guarantees
+        // from `topts` (which borrows `(*transpiler).options`). `.unwrap()` is
+        // sound — caller (`BundleV2::init`) guarantees
         // it is set before any ParseTask runs.
         // SAFETY: `transpiler` is live; `macro_context` is a disjoint field.
         // `'static` erasure: the context outlives the parse.
@@ -2517,8 +2488,8 @@ pub mod parse_worker {
         opts.features.trim_unused_imports =
             loader.is_typescript() || topts.trim_unused_imports.unwrap_or(false);
         opts.features.inlining = topts.minify_syntax;
-        // TODO(port): TYPE_ONLY divergence — `bun_options_types::Format` vs
-        // `bun_js_parser::options::Format`. Map by discriminant.
+        // `bun_options_types::Format` and `bun_js_parser::options::Format` are
+        // distinct enums; map explicitly.
         opts.output_format = match output_format {
             options::Format::Esm => js_parser::options::Format::Esm,
             options::Format::Cjs => js_parser::options::Format::Cjs,
@@ -2536,9 +2507,9 @@ pub mod parse_worker {
         opts.features.standard_decorators = !loader.is_typescript()
             || !(task.experimental_decorators || task.emit_decorator_metadata);
         opts.features.unwrap_commonjs_packages = topts.unwrap_commonjs_packages;
-        // PORT NOTE: Zig stores a `*const StringSet` (shared); Rust models it as
+        // Modeled as
         // `Option<Box<StringSet>>` on both sides, so we deep-clone (small —
-        // CLI-supplied flag set). PERF(port): retype
+        // CLI-supplied flag set). PERF: retype
         // `RuntimeFeatures.bundler_feature_flags` to `Option<&'a StringSet>` so
         // this clone disappears.
         opts.features.bundler_feature_flags = topts
@@ -2586,7 +2557,7 @@ pub mod parse_worker {
         // `transpiler.options.framework: Option<&bake_types::Framework>`
         // vs `opts.framework: Option<&js_parser::options::Framework>` — both
         // TYPE_ONLY mirrors of `bake.Framework`. Project the fields the parser
-        // reads (Parser.zig:1415,1433) into the parser-side mirror and bump-alloc
+        // reads into the parser-side mirror and bump-alloc
         // so `opts` can borrow it.
         opts.framework = topts.framework.map(|f| {
             // `Framework` is bump-allocated below, so `Drop` never runs — use arena-owned slices.
@@ -2677,12 +2648,10 @@ pub mod parse_worker {
             } else {
                 get_empty_ast::<E::Object>(log, transpiler, opts, bump, source)
             };
-        // PERF(port): Zig used `switch (bool) { inline else => |as_undefined| ... }`
-        // to monomorphize. Expanded to if/else.
         let mut ast = match ast_result {
             Ok(a) => a,
             Err(e) => {
-                // Zig errdefers (.zig:1123, .zig:1148): reset the AST store
+                // Error-path cleanup: reset the AST store
                 // unconditionally, and free the owned `entry.contents` only when
                 // it was sourced from `.fd` (the `.contents` variant is borrowed —
                 // freeing it would double-free in `BundleV2.deinit`).
@@ -2719,7 +2688,6 @@ pub mod parse_worker {
             ast,
             source: source.clone(),
             log: core::mem::take(log),
-            // PORT NOTE: Zig returned `log.*` by value; here we take ownership.
             use_directive,
             unique_key_for_additional_file: unique_key_for_additional_file.key,
             side_effects: task.side_effects,
@@ -2754,7 +2722,7 @@ pub mod parse_worker {
         // SAFETY: ctx backref valid for the bundle pass (outlives this task).
         let ctx = unsafe { this.ctx() };
         let worker: &mut crate::Worker = crate::Worker::get(ctx);
-        // PORT NOTE: `defer worker.unget()` — handled at function exit (scopeguard
+        // `defer worker.unget()` — handled at function exit (scopeguard
         // would alias the `&mut worker` borrows below).
         scoped_log!(
             ParseTask,
@@ -2801,9 +2769,9 @@ pub mod parse_worker {
                 }
             }
 
-            // PORT NOTE: reshaped for borrowck — `this` and `this.stage.needs_parse`
-            // both borrowed mutably. Zig (.zig:1369) passes `&this.stage.needs_parse`
-            // in-place so the entry's `Contents::Owned` buffer survives in
+            // reshaped for borrowck — `this` and `this.stage.needs_parse`
+            // both borrowed mutably. The entry must live
+            // in-place so its `Contents::Owned` buffer survives in
             // `task.stage` for the bundle's lifetime (Success.source.contents
             // borrows it via the arena-erased `StoreStr` path). Take it out, parse, then *write it
             // back* on every path before `break 'value` so dropping the local
@@ -2852,10 +2820,9 @@ pub mod parse_worker {
 
         let result = Box::new(Result {
             ctx: this.ctx.expect("ParseTask.ctx unset"),
-            // Zig `.task = .{}` (.zig:1407) — default-init, NOT `undefined`.
             task: EventLoop::Task::default(),
             value,
-            // PORT NOTE: `ExternalFreeFunction` is POD in Zig (copied); Rust port
+            // `ExternalFreeFunction`
             // doesn't derive `Copy`, so move it out (task is consumed here).
             external: core::mem::take(&mut this.external_free_function),
             watcher_data: match this.contents_or_fd {
@@ -2871,11 +2838,10 @@ pub mod parse_worker {
         // `ParseTask` is arena-owned (no Drop); `jsx` may hold owned slices from tsconfig.
         drop(core::mem::take(&mut this.jsx));
 
-        // Zig matched `worker.ctx.loop().*` on `AnyEventLoop::{js, mini}`.
         // `worker.ctx` is a `BackRef<BundleV2>` (safe `Deref`); the BACKREF deref
         // of `linker.r#loop` is centralised in `LinkerContext::any_loop_mut`.
         //
-        // Zig `worker.ctx.loop().*` is non-optional (.zig:1416) — `BundleV2::init`
+        // The loop is effectively non-optional — `BundleV2::init`
         // always sets `linker.r#loop` before scheduling any ParseTask. Running
         // `on_complete` inline on the worker thread would violate
         // `BundleV2::on_parse_task_complete`'s threading contract (it mutates the
@@ -2908,7 +2874,7 @@ pub mod parse_worker {
                 }
             }
         }
-        // Zig: `defer worker.unget()` — runs at function exit, i.e. after enqueue.
+        // Runs at function exit, i.e. after enqueue.
         worker.unget();
     }
 
@@ -2924,19 +2890,17 @@ pub mod parse_worker {
 
     fn on_complete_mini(result: *mut Result, ctx: *mut BundleV2<'static>) {
         // SAFETY: callback contract — `result` was heap-allocated above; `ctx` is
-        // the BACKREF stashed in `result.ctx` (Zig passed `BundleV2` as ParentContext).
+        // the BACKREF stashed in `result.ctx`.
         BundleV2::on_parse_task_complete(unsafe { &mut *result }, unsafe { &mut *ctx });
         // SAFETY: `result` is uniquely owned (callback contract).
         drop_result_owned_fields(unsafe { &mut *result });
-        // Zig: `defer bun.default_allocator.destroy(parse_result)` (bundle_v2.zig).
-        // Zig's `destroy` is *struct-only* (no field deinit). 954e9ccb mapped this
-        // to `drop(heap::take(result))`, but that runs full Drop glue:
+        // `drop(heap::take(result))` would run full Drop glue:
         // `on_parse_task_complete` SWAPS `result.value.Success.source` with the
         // graph's placeholder and moves `result.ast` out, so post-swap
         // `result.value` holds the *placeholder* `Source` whose
         // `contents: Cow::Borrowed` may alias plugin-/loader-provided bytes the
         // graph's swapped-in Source still references (asan use-after-poison at
-        // process_files_to_copy:4241 in bundler_loader/_plugin tests). Match Zig:
+        // process_files_to_copy:4241 in bundler_loader/_plugin tests). So:
         // dealloc the box without running Drop.
         // SAFETY: `result` came from `bun_core::heap::into_raw(Box<Result>)`
         // above; uniquely owned. Dealloc with the same layout, no field Drop.
@@ -2973,5 +2937,3 @@ pub use parse_worker::{FileLoaderHash, OnBeforeParsePlugin, get_runtime_source,
 // ───────────────────────────────────────────────────────────────────────────
 
 pub use crate::DeferredBatchTask::DeferredBatchTask;
-
-// ported from: src/bundler/ParseTask.zig
diff --git a/src/bundler/PathToSourceIndexMap.rs b/src/bundler/PathToSourceIndexMap.rs
index e8c04ddf2ce..626c65b08b6 100644
--- a/src/bundler/PathToSourceIndexMap.rs
+++ b/src/bundler/PathToSourceIndexMap.rs
@@ -28,7 +28,7 @@ pub struct PathToSourceIndexMap {
 
 pub type Map = StringHashMap<IndexInt>;
 
-/// Mirrors Zig's `Map.GetOrPutResult` — std `HashMap::entry` doesn't expose
+/// std `HashMap::entry` doesn't expose
 /// `found_existing` + value-ptr together, so we hand-roll a thin shim.
 pub(crate) type GetOrPutResult<'a> = bun_collections::string_hash_map::GetOrPutResult<'a, IndexInt>;
 
@@ -49,11 +49,10 @@ impl PathToSourceIndexMap {
         self.put(path.path_text(), value)
     }
 
-    // Takes `&[u8]` (not `impl AsRef<[u8]>`) to mirror Zig's `text: []const u8`
-    // and to avoid E0283 inference ambiguity at `.into()` call sites in bundle_v2.
+    // Takes `&[u8]` (not `impl AsRef<[u8]>`)
+    // to avoid E0283 inference ambiguity at `.into()` call sites in bundle_v2.
     pub fn put(&mut self, text: &[u8], value: IndexInt) -> Result<(), bun_alloc::AllocError> {
-        // PERF(port): Zig used StringHashMapUnmanaged with arena-borrowed keys (no copy);
-        // bun_collections::StringHashMap is keyed by `Box<[u8]>`, so we dupe here.
+        // PERF: bun_collections::StringHashMap is keyed by `Box<[u8]>`, so we dupe here.
         // Revisit once StringHashMap gains a borrowed-key variant.
         self.map.put(text, value)
     }
@@ -69,7 +68,7 @@ impl PathToSourceIndexMap {
         &mut self,
         text: impl AsRef<[u8]>,
     ) -> Result<GetOrPutResult<'_>, bun_alloc::AllocError> {
-        // PERF(port): see note in `put` re: key duplication.
+        // PERF: see note in `put` re: key duplication.
         self.map.get_or_put(text.as_ref())
     }
 
@@ -81,5 +80,3 @@ impl PathToSourceIndexMap {
         self.remove(path.path_text())
     }
 }
-
-// ported from: src/bundler/PathToSourceIndexMap.zig
diff --git a/src/bundler/ServerComponentParseTask.rs b/src/bundler/ServerComponentParseTask.rs
index 72a46ff7772..e8a51b602cd 100644
--- a/src/bundler/ServerComponentParseTask.rs
+++ b/src/bundler/ServerComponentParseTask.rs
@@ -32,7 +32,7 @@ pub use crate::parse_task::ParseTask;
 pub(crate) struct ServerComponentParseTask {
     pub task: ThreadPoolTask,
     pub data: Data,
-    // BACKREF (LIFETIMES.tsv) — Zig `*BundleV2` is mutable; written through in `on_complete`.
+    // BACKREF (LIFETIMES.tsv) — written through in `on_complete`.
     // `ParentRef` (write-provenance via `NonNull::from(&mut self)` at construction)
     // so deref sites are safe; `None` only for the FRU `Default` placeholder.
     pub ctx: Option<bun_ptr::ParentRef<BundleV2<'static>>>,
@@ -56,7 +56,7 @@ pub struct ReferenceProxy {
 }
 
 pub struct ClientEntryWrapper {
-    // TODO(port): lifetime — Zig `[]const u8` borrowed from caller; never freed in this file.
+    // Owned copy.
     pub path: Box<[u8]>,
 }
 
@@ -82,7 +82,7 @@ fn task_callback_wrap(thread_pool_task: *mut ThreadPoolTask) {
         .ctx
         .expect("ServerComponentParseTask.ctx set at enqueue");
     let worker = Worker::get(ctx.get());
-    // PORT NOTE: `defer worker.unget()` — handled at end of fn (no early returns).
+    // `defer worker.unget()` — handled at end of fn (no early returns).
     let mut log = Log::new();
 
     // SAFETY: `worker.arena` is set in `Worker::create` to point at the
@@ -99,7 +99,7 @@ fn task_callback_wrap(thread_pool_task: *mut ThreadPoolTask) {
         // `ctx` already a `ParentRef<BundleV2>` with write provenance
         // (constructed from `NonNull::from(&mut self)` in `bundle_v2.rs`).
         ctx,
-        // SAFETY: Zig leaves `.task = undefined`; consumer overwrites before read.
+        // Placeholder; consumer overwrites before read.
         task: Default::default(),
         value,
         external: ExternalFreeFunction::NONE,
@@ -107,11 +107,10 @@ fn task_callback_wrap(thread_pool_task: *mut ThreadPoolTask) {
     });
     let result = bun_core::heap::into_raw(result);
 
-    // Zig matched `worker.ctx.loop().*` on `AnyEventLoop::{js, mini}`.
     // `worker.ctx` is a `BackRef<BundleV2>` (safe `Deref`); the BACKREF deref
     // of `linker.r#loop` is centralised in `LinkerContext::any_loop_mut`.
     //
-    // Zig `worker.ctx.loop().*` is non-optional (.zig:52) — `BundleV2::init`
+    // The loop is effectively non-optional — `BundleV2::init`
     // always sets `linker.r#loop` before scheduling any ServerComponentParseTask.
     // Running `on_complete` inline on the worker thread would violate
     // `BundleV2::on_parse_task_complete`'s threading contract (it mutates the
@@ -144,7 +143,7 @@ fn task_callback_wrap(thread_pool_task: *mut ThreadPoolTask) {
             }
         }
     }
-    // Zig: `defer worker.unget()` — runs at function exit, i.e. after enqueue.
+    // Runs at function exit, i.e. after enqueue.
     worker.unget();
 }
 
@@ -165,8 +164,8 @@ fn task_callback(
         .ctx
         .as_deref()
         .expect("ServerComponentParseTask.ctx set at enqueue");
-    // PORT NOTE: `Source` is not `Clone`; the original is consumed here
-    // (Zig copied by value). Take it up-front so `ab`'s borrow of it ends
+    // `Source` is not `Clone`; the original is consumed here.
+    // Take it up-front so `ab`'s borrow of it ends
     // (via NLL) before we move it into `Success`.
     let source = core::mem::take(&mut task.source);
     let mut ab = AstBuilder::init(bump, &source, ctx.transpiler().options.hot_module_reloading)?;
@@ -185,8 +184,7 @@ fn task_callback(
     let hmr_api_ref = ab.hmr_api_ref;
     let mut bundled_ast: JSAst = ab.to_bundled_ast(target)?;
 
-    // `wrapper_ref` is used to hold the HMR api ref (see comment in
-    // `src/ast/Ast.zig`)
+    // `wrapper_ref` is used to hold the HMR api ref.
     bundled_ast.wrapper_ref = hmr_api_ref;
 
     Ok(Success {
@@ -203,8 +201,7 @@ fn task_callback(
 }
 
 impl Default for ServerComponentParseTask {
-    /// Mirrors Zig's `task: ThreadPoolLib.Task = .{ .callback = &taskCallbackWrap }`
-    /// default-field-value. Callers (`bundle_v2.rs`) supply `data`/`ctx`/`source`
+    /// Callers (`bundle_v2.rs`) supply `data`/`ctx`/`source`
     /// via FRU and rely on this for the intrusive `task` link.
     fn default() -> Self {
         Self {
@@ -274,7 +271,6 @@ fn generate_client_reference_proxy(
         if ctx.transpiler().options.has_dev_server() {
             b.bump.alloc_slice_copy(data.other_source.path.pretty)
         } else {
-            // PERF(port): was arena allocPrint — profile if it shows up on a hot path
             let mut buf = bun_alloc::ArenaString::new_in(b.bump);
             write!(
                 &mut buf,
@@ -297,7 +293,6 @@ fn generate_client_reference_proxy(
         // This error message is taken from
         // https://github.com/facebook/react/blob/c5b9375767e2c4102d7e5559d383523736f1c902/packages/react-server-dom-webpack/src/ReactFlightWebpackNodeLoader.js#L323-L354
         let err_msg_string: &[u8] = {
-            // PERF(port): was arena allocPrint — profile if it shows up on a hot path
             let mut buf = bun_alloc::ArenaString::new_in(b.bump);
             if is_default {
                 write!(
@@ -394,5 +389,3 @@ fn generate_client_reference_proxy(
 
     Ok(())
 }
-
-// ported from: src/bundler/ServerComponentParseTask.zig
diff --git a/src/bundler/ThreadPool.rs b/src/bundler/ThreadPool.rs
index 236f17412b9..4db4d57ad31 100644
--- a/src/bundler/ThreadPool.rs
+++ b/src/bundler/ThreadPool.rs
@@ -1,4 +1,4 @@
-//! Port of `src/bundler/ThreadPool.zig` — the bundler-side worker pool that
+//! The bundler-side worker pool that
 //! wraps `bun_threading::thread_pool::ThreadPool` and owns the per-thread
 //! [`Worker`] state (mimalloc arena, per-thread `Transpiler` clone, AST store).
 //!
@@ -11,7 +11,7 @@ use core::mem::{ManuallyDrop, MaybeUninit};
 use core::ptr::{self, NonNull};
 use core::sync::atomic::{AtomicUsize, Ordering};
 
-use bun_alloc::Arena as ThreadLocalArena; // Zig: bun.allocators.MimallocArena
+use bun_alloc::Arena as ThreadLocalArena;
 use bun_collections::{ArrayHashMap, MapEntry};
 use bun_core::{self, env_var, output as Output};
 use bun_sys::Fd;
@@ -19,11 +19,11 @@ use bun_threading::{Mutex, thread_pool as ThreadPoolLib};
 
 use crate::cache::{Contents, Entry as CacheEntry, ExternalFreeFunction};
 use crate::linker_context_mod::StmtList;
-// PORT NOTE: `crate::options::Target` is the lower-tier `bun_options_types`
+// `crate::options::Target` is the lower-tier `bun_options_types`
 // enum (re-exported for downstream crates); `BundleOptions.target` is the
 // file-backed `options_impl::Target`. Compare against the latter so
-// `primary.options.target == target` type-checks. TODO(refactor): collapse
-// the two enums into one (see lib.rs `pub mod options` shadow note).
+// `primary.options.target == target` type-checks. (The two enums could be
+// collapsed into one; see lib.rs `pub mod options` shadow note.)
 use crate::BundleV2;
 use crate::options_impl::Target;
 use crate::parse_task::{ContentsOrFd, ParseTask, ParseTaskStage};
@@ -42,19 +42,18 @@ pub struct ThreadPool {
     /// On Windows, this seemed to be a small performance improvement.
     /// On Linux, this was a performance regression.
     /// In some benchmarks on macOS, this yielded up to a 60% performance improvement in microbenchmarks that load ~10,000 files.
-    // PORT NOTE: Zig left this `undefined` when `!uses_io_pool()`; `Option` makes
-    // that explicit. `ParentRef` (not raw `NonNull`) because the pointee is the
+    // `None` when `!uses_io_pool()`.
+    // `ParentRef` (not raw `NonNull`) because the pointee is the
     // module-static `io_thread_pool::THREAD_POOL`, live while `ref_count > 0`,
     // and all `ThreadPoolLib` driver methods (`schedule`, `warm`,
     // `wake_for_idle_events`) take `&self` — so the safe `Deref` projection is
     // sufficient and the per-read `unsafe { p.as_ref() }` disappears.
     pub io_pool: Option<bun_ptr::ParentRef<ThreadPoolLib::ThreadPool>>,
-    // TODO(port): lifetime — TSV class UNKNOWN. Conditionally owned via
-    // `worker_pool_is_owned`; kept raw so callers (bundle_v2.rs draft) can
-    // dereference for `wake_for_idle_events()` without a borrow on `ThreadPool`.
+    // Conditionally owned via `worker_pool_is_owned`; kept raw so callers
+    // (bundle_v2.rs) can dereference for `wake_for_idle_events()` without a
+    // borrow on `ThreadPool`.
     pub worker_pool: *mut ThreadPoolLib::ThreadPool,
     pub worker_pool_is_owned: bool,
-    // PORT NOTE: Zig had `workers_assignments` + sibling `workers_assignments_lock`.
     // Per PORTING.md §Concurrency ("Mutex<T> owns T"), the lock is folded into
     // the field so `get_worker` can take `&self` — `Worker::get` is entered
     // concurrently from arbitrary worker-pool threads, and a `&mut self` here
@@ -72,8 +71,9 @@ pub struct ThreadPool {
 
 // SAFETY: `ThreadPool` is shared across worker threads; the only mutated
 // field (`workers_assignments`) is guarded by its `bun_threading::Guarded`, and
-// the raw-pointer fields are externally synchronized exactly as in the Zig
-// source.
+// the raw-pointer fields are set during init, before the pool is shared with
+// worker threads, and only read thereafter (mutation in `deinit` happens on the
+// owning thread after the workers are done).
 unsafe impl Send for ThreadPool {}
 // SAFETY: `&ThreadPool` is read concurrently from worker-pool threads via
 // `get_worker(&self)`; the only field mutated under `&self` is
@@ -83,8 +83,7 @@ unsafe impl Sync for ThreadPool {}
 
 impl Default for ThreadPool {
     /// Placeholder so `bundle_v2` can `arena().alloc(ThreadPool::default())`
-    /// before overwriting with [`ThreadPool::init`]. Mirrors Zig's
-    /// `arena.create(ThreadPool)` which yields uninit memory.
+    /// before overwriting with [`ThreadPool::init`].
     fn default() -> Self {
         Self {
             io_pool: None,
@@ -107,9 +106,9 @@ mod io_thread_pool {
         bun_core::RacyCell::new(MaybeUninit::uninit());
     /// Protects initialization and deinitialization of the IO thread pool.
     static MUTEX: Mutex = {
-        // PORT NOTE: `Mutex` derives `Default` but `Default::default()` isn't
-        // `const`. The Zig source used `bun.threading.Mutex{}` (zero-init);
-        // an all-zero `Mutex` is the documented unlocked state on every impl.
+        // `Mutex` derives `Default` but `Default::default()` isn't
+        // `const`. An all-zero `Mutex` is the documented unlocked state on
+        // every impl.
         // SAFETY: `Mutex` is `repr(Rust)` over an atomic / Futex word; zero is
         // the valid initial value (matches `#[derive(Default)]`).
         unsafe { bun_core::ffi::zeroed_unchecked() }
@@ -161,9 +160,8 @@ mod io_thread_pool {
             // 2 means initialized and referenced by one `ThreadPool`.
             REF_COUNT.store(2, Ordering::Release);
         } else {
-            // PORT NOTE: Zig fell through to `return &thread_pool` without
-            // bumping the ref count here, which is a latent bug in the source
-            // (the racing acquirer's reference isn't counted). Mirrored.
+            // NOTE: a racing acquirer that reaches here does not bump the ref
+            // count — a latent under-count, preserved intentionally.
         }
         // Just initialized (or observed initialized) above. `UnsafeCell::get` never returns null.
         NonNull::new(THREAD_POOL.get().cast::<ThreadPoolLib::ThreadPool>())
@@ -200,15 +198,13 @@ mod io_thread_pool {
         unsafe {
             (*THREAD_POOL.get()).assume_init_drop();
         }
-        // PORT NOTE: Zig source falls off the end of a `bool`-returning fn here
-        // (`thread_pool = undefined;` is the last statement). Assuming `true`.
         true
     }
 }
 
 impl ThreadPool {
     /// Inherent associated type so call sites that wrote
-    /// `ThreadPool::Worker::get(ctx)` (matching Zig's `ThreadPool.Worker`)
+    /// `ThreadPool::Worker::get(ctx)`
     /// resolve without a separate module path.
     pub type Worker = Worker;
 
@@ -222,17 +218,13 @@ impl ThreadPool {
         // end-to-end.
         worker_pool: Option<NonNull<ThreadPoolLib::ThreadPool>>,
     ) -> Result<ThreadPool, bun_alloc::AllocError> {
-        // PORT NOTE: Spec ThreadPool.zig:85 allocated via the bundle arena
-        // (`v2.arena().create`), so the `false` ownership flag was
-        // harmless — the arena reclaimed it. Here we `heap::alloc` (global
+        // The pool is `heap::alloc`'d (global
         // heap), so `deinit()` must `heap::take` it back; record ownership.
         let owned = worker_pool.is_none();
         let pool: *mut ThreadPoolLib::ThreadPool = match worker_pool {
             Some(p) => p.as_ptr(),
             None => {
                 let cpu_count = bun_core::get_thread_count();
-                // PERF(port): was `v2.arena().create(ThreadPoolLib)` —
-                // using heap::alloc (global mimalloc).
                 let pool = bun_core::heap::into_raw(Box::new(ThreadPoolLib::ThreadPool::init(
                     ThreadPoolLib::Config {
                         max_threads: u32::from(cpu_count),
@@ -267,7 +259,7 @@ impl ThreadPool {
         }
     }
 
-    /// Explicit teardown — Zig callers spell `pool.deinit()` (no Drop on
+    /// Explicit teardown (no Drop on
     /// `ThreadPool` because `Graph.pool` is `NonNull<ThreadPool>` and the arena
     /// owns the storage).
     pub fn deinit(&mut self) {
@@ -347,8 +339,7 @@ impl ThreadPool {
             let ContentsOrFd::Contents(contents) = parse_task.contents_or_fd else {
                 unreachable!()
             };
-            // PORT NOTE: Zig moved the `[]const u8` slice into the cache entry
-            // by value. `cache::Contents` has no borrowed-slice variant; the
+            // `cache::Contents` has no borrowed-slice variant; the
             // contract (see ParseTask.rs `run_with_source_code` defer) is that
             // `entry.deinit()` is *skipped* when `contents_or_fd == .contents`,
             // so an `External` provenance tag (no-op deinit) is the correct
@@ -396,7 +387,7 @@ impl ThreadPool {
         }
     }
 
-    // PORT NOTE: takes `*mut` (Zig: `*ParseTask`) so callers can pass either a
+    // takes `*mut` so callers can pass either a
     // raw heap pointer (e.g. `load.parse_task`) or a `&mut` (auto-coerces).
     pub fn schedule(&self, parse_task: *mut ParseTask) {
         self.schedule_with_options(parse_task, false);
@@ -406,9 +397,9 @@ impl ThreadPool {
         self.schedule_with_options(parse_task, true);
     }
 
-    // PORT NOTE: returns `&'static mut` — the `Worker` is `heap::alloc`'d
+    // returns `&'static mut` — the `Worker` is `heap::alloc`'d
     // below and lives until `Worker::deinit`; detaching from `&self` lets
-    // callers re-borrow `ThreadPool` while holding the worker (Zig: `*Worker`).
+    // callers re-borrow `ThreadPool` while holding the worker.
     // Takes `&self` (not `&mut`) because this is called concurrently from
     // worker-pool threads via `Worker::get`; mutation goes through the
     // `bun_threading::Guarded` on `workers_assignments`.
@@ -417,9 +408,9 @@ impl ThreadPool {
     // pure `current_thread_id() → *mut Worker` re-read after first touch, so
     // every subsequent call from the same thread for the same pool is a TLS
     // load + pointer compare. The lock is only taken on first touch per
-    // `(thread, pool)` pair. Zig (ThreadPool.zig:180) takes the lock on every
-    // call; on a 19 K-module build that's ~100 K contended acquisitions, which
-    // perf attributes ~97 % of the build's futex traffic to.
+    // `(thread, pool)` pair. Taking the lock on every
+    // call would mean ~100 K contended acquisitions on a 19 K-module build —
+    // ~97 % of the build's futex traffic per perf.
     #[inline]
     pub fn get_worker(&self, id: ThreadId) -> &'static mut Worker {
         let (generation, worker) = TLS_WORKER.get();
@@ -507,17 +498,16 @@ static POOL_GENERATION: core::sync::atomic::AtomicU64 = core::sync::atomic::Atom
 /// `deinit_task`/`arena` fields are self-referential); never moved after
 /// `get_worker` boxes it.
 pub struct Worker {
-    /// Thread-local arena. `None` until [`Worker::create`] runs (Zig wrote
-    /// `undefined`); every read site is post-`has_created`.
+    /// Thread-local arena. `None` until [`Worker::create`] runs;
+    /// every read site is post-`has_created`.
     pub heap: Option<ThreadLocalArena>,
 
     /// Thread-local memory arena
     /// All allocations are freed in `deinit` at the very end of bundling.
-    // PORT NOTE: self-referential borrow of `heap` — `BackRef` (not a real
+    // self-referential borrow of `heap` — `BackRef` (not a real
     // `&'self ThreadLocalArena`) so it can be reseated in `create()` without a
     // self-borrow and so call sites read it via safe `Deref` instead of
-    // open-coding a raw deref. Zig stored the `std.mem.Allocator` vtable; here
-    // it's just `&heap`. Dangling until `create()` runs; every read site is
+    // open-coding a raw deref. Dangling until `create()` runs; every read site is
     // post-`has_created`.
     pub arena: bun_ptr::BackRef<ThreadLocalArena>,
 
@@ -549,7 +539,7 @@ pub struct Worker {
 impl Worker {
     /// Reborrow the self-referential `arena` (= `&self.heap`) as a shared
     /// reference. `BackRef` field, so the deref is encapsulated in
-    /// [`bun_ptr::BackRef::get`]; see PORT NOTE on the field.
+    /// [`bun_ptr::BackRef::get`]; see note on the field.
     ///
     /// `arena` is set to `&self.heap` in [`Worker::create`] before any caller
     /// can observe the `Worker`, and is never dangling after that point. The
@@ -571,13 +561,12 @@ impl Worker {
 }
 
 pub struct WorkerData {
-    // TODO(port): lifetime — TSV class ARENA (`&'arena mut bun_ast::Log`); kept
-    // raw because the arena is the sibling field `Worker.heap`.
+    // Kept raw because the pointee's arena
+    // is the sibling field `Worker.heap`, which Rust cannot express as a borrow.
     pub log: *mut bun_ast::Log,
     pub estimated_input_lines_of_code: usize,
-    // PORT NOTE: lifetime erased to `'static` — the inner `&'a Arena` borrows
-    // `Worker.heap`, which Rust can't express on a sibling field. Zig used
-    // `transpiler: Transpiler` with a copied `std.mem.Allocator`.
+    // lifetime erased to `'static` — the inner `&'a Arena` borrows
+    // `Worker.heap`, which Rust can't express on a sibling field.
     //
     // Owned (no `MaybeUninit`): `Transpiler::for_worker` deep-clones every
     // `Drop`-carrying field, so `WorkerData`'s drop (via
@@ -620,8 +609,8 @@ impl Worker {
             // (the bundler thread running an inline parse). `deinit_soon` is
             // also called from the bundler thread (`deinit_without_freeing_arena`
             // iterates `workers_assignments`), so we are on the owning thread
-            // and can tear down synchronously. Zig spec (ThreadPool.zig:232)
-            // silently no-ops here, leaking the Worker — including its
+            // and can tear down synchronously. Skipping teardown here would
+            // leak the Worker — including its
             // `ast_memory_store` mi_heap (every `AstAlloc` buffer the inline
             // parse produced) and `data.transpiler` per `Bun.build()` call.
             //
@@ -668,10 +657,9 @@ impl Worker {
         // and `create()` may overwrite it
         // via `*ast_memory_store = ...`. Dropped exactly once here, *outside*
         // the `has_created` guard so the default-constructed arena is freed
-        // even when `create()` never ran (Zig left it `undefined`; Rust does
-        // not). Ordered before `heap = None` in case the TODO(port) in
-        // `ASTMemoryAllocator::new` ever threads `arena_ref` (= `&self.heap`)
-        // through.
+        // even when `create()` never ran.
+        // Ordered before `heap = None` in case `ASTMemoryAllocator::new`
+        // ever threads `arena_ref` (= `&self.heap`) through.
         unsafe { ManuallyDrop::drop(&mut worker.ast_memory_store) };
         if worker.has_created {
             worker.heap = None;
@@ -683,9 +671,9 @@ impl Worker {
         unsafe { bun_core::heap::destroy(this) };
     }
 
-    // PORT NOTE: returns `&'static mut` (detached) — the `Worker` is
+    // returns `&'static mut` (detached) — the `Worker` is
     // heap-pinned (heap::alloc in `get_worker`) and outlives any `ctx`
-    // borrow; Zig returned `*Worker`. Tying it to `ctx`'s lifetime would
+    // borrow. Tying it to `ctx`'s lifetime would
     // forbid the `worker` ↔ `ctx` re-borrows in `ParseTask::run_*`.
     pub fn get(ctx: &BundleV2<'_>) -> &'static mut Worker {
         // SAFETY: `ctx` is a BACKREF; `graph.pool` is a `NonNull<ThreadPool>`
@@ -715,7 +703,7 @@ impl Worker {
     }
 
     fn create(&mut self, ctx: &BundleV2<'_>) {
-        // PORT NOTE: `bun_perf::trace` takes a generated `PerfEvent` enum, and
+        // `bun_perf::trace` takes a generated `PerfEvent` enum, and
         // the generator hasn't emitted `Bundler.Worker.create` yet (only
         // `_Stub`). Dropped to avoid mis-attributing the span.
         // let _trace = bun_perf::trace("Bundler.Worker.create");
@@ -734,7 +722,7 @@ impl Worker {
         let arena_ref: &'static ThreadLocalArena =
             unsafe { bun_ptr::detach_lifetime_ref(self.arena.get()) };
 
-        // Zig: `.{ .arena = this.arena }` then `reset()`. The Rust
+        // The
         // ASTMemoryAllocator owns its bump arena internally and ignores the
         // passed fallback (see ASTMemoryAllocator::new doc).
         *self.ast_memory_store = bun_ast::ASTMemoryAllocator::new(arena_ref);
@@ -742,8 +730,7 @@ impl Worker {
 
         let log: *mut bun_ast::Log = arena_ref.alloc(bun_ast::Log::init());
         self.ctx = bun_ptr::BackRef::from(NonNull::from(ctx).cast::<BundleV2<'static>>());
-        // PERF(port): was `bun.ArenaAllocator.init(this.arena)` — using a
-        // fresh Bump (no nested-arena type yet).
+        // Use a fresh Bump (no nested-arena type yet).
         self.temporary_arena = Some(bun_alloc::Arena::new());
         self.stmt_list = Some(StmtList::init());
         let data = self.data.insert(WorkerData {
@@ -759,9 +746,9 @@ impl Worker {
         bun_core::scoped_log!(ThreadPool, "Worker.create()");
     }
 
-    /// Build a per-worker `Transpiler` from `from` (Zig: `transpiler.* = from.*`).
+    /// Build a per-worker `Transpiler` from `from`.
     ///
-    /// PORT NOTE: reshaped for borrowck — associated fn (no `&mut self`) so
+    /// reshaped for borrowck — associated fn (no `&mut self`) so
     /// callers can borrow `self.data.log` disjointly. The returned value is a
     /// fully-owned `Transpiler` whose `Drop` is sound; `wire_after_move` must
     /// be called once it is at its final address.
@@ -813,5 +800,3 @@ impl Worker {
         }
     }
 }
-
-// ported from: src/bundler/ThreadPool.zig
diff --git a/src/bundler/analyze_transpiled_module.rs b/src/bundler/analyze_transpiled_module.rs
index 8c5b6b30821..e01a50021bd 100644
--- a/src/bundler/analyze_transpiled_module.rs
+++ b/src/bundler/analyze_transpiled_module.rs
@@ -25,7 +25,7 @@ pub use bun_js_printer::analyze_transpiled_module::{
 /// `bundler_jsc::analyze_jsc::to_js_module_record`.
 pub type RequestedModuleValue = FetchParameters;
 
-/// Legacy name used by `linker_context::postProcessJSChunk` — the Zig side
+/// Legacy name used by `linker_context::postProcessJSChunk` — the type was
 /// renamed `ImportAttributes` → `FetchParameters` but the bundler call site
 /// still spells `ImportAttributes::None`.
 pub(crate) type ImportAttributes = FetchParameters;
@@ -34,14 +34,14 @@ pub(crate) type ImportAttributes = FetchParameters;
 // RecordKind
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Non-exhaustive `enum(u8)` in Zig — any byte value is representable, so model
+/// Any byte value is representable, so model
 /// as a transparent newtype with associated consts (a `#[repr(u8)] enum` would
 /// be UB for unknown discriminants read out of the serialized buffer).
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct RecordKind(pub u8);
 // SAFETY: `#[repr(transparent)]` over `u8` — no padding, every bit pattern is
-// a valid `u8` (Zig modeled this as a non-exhaustive `enum(u8)`). `Pod` lets
+// a valid `u8`. `Pod` lets
 // `bytemuck::{cast_slice,try_cast_slice}` reinterpret byte buffers and the
 // printer-crate `#[repr(u8)]` enum into `&[RecordKind]` without `unsafe`.
 unsafe impl bytemuck::Zeroable for RecordKind {}
@@ -116,19 +116,17 @@ bitflags::bitflags! {
 }
 
 impl Flags {
-    /// Zig: `Flags.contains_import_meta` packed-struct field. Exposed as a
+    /// Exposed as a
     /// method so downstream callers (e.g. `bundler_jsc::analyze_jsc`) can read
     /// the bit without depending on the bitflags const name.
     #[inline]
     pub const fn contains_import_meta(self) -> bool {
         self.contains(Flags::CONTAINS_IMPORT_META)
     }
-    /// Zig: `Flags.is_typescript` packed-struct field.
     #[inline]
     pub const fn is_typescript(self) -> bool {
         self.contains(Flags::IS_TYPESCRIPT)
     }
-    /// Zig: `Flags.has_tla` packed-struct field.
     #[inline]
     pub const fn has_tla(self) -> bool {
         self.contains(Flags::HAS_TLA)
@@ -154,8 +152,7 @@ bun_core::named_error_set!(ModuleInfoError);
 /// Alignment: the on-disk format pads every multi-byte field to a 4-byte
 /// offset, and [`Self::create`] allocates the backing buffer with 4-byte
 /// alignment ([`MODULE_INFO_ALIGN`]), so every `RawSlice<T>` here is properly
-/// aligned for `T` and `.slice()` is sound. (Zig used `[]align(1) const T`
-/// because its allocator didn't guarantee the base; we do instead.)
+/// aligned for `T` and `.slice()` is sound.
 pub struct ModuleInfoDeserialized {
     pub strings_buf: bun_ptr::RawSlice<u8>,
     pub strings_lens: bun_ptr::RawSlice<u32>,
@@ -232,9 +229,7 @@ impl ModuleInfoDeserialized {
         unsafe {
             match (*this).owner {
                 Owner::ModuleInfo(mi) => {
-                    // PORT NOTE: Zig recovered the parent via
-                    // `@fieldParentPtr("_deserialized", self)`. The Rust port
-                    // stores the `*mut ModuleInfo` directly because the printer
+                    // The `*mut ModuleInfo` is stored directly because the printer
                     // crate's `ModuleInfo` no longer embeds this struct.
                     drop(bun_core::heap::take(mi));
                     drop(bun_core::heap::take(this));
@@ -342,14 +337,12 @@ impl ModuleInfoDeserialized {
     /// cache or standalone module graph). Returns `None` instead of panicking on
     /// corrupt/truncated data.
     pub fn create_from_cached_record(source: &[u8]) -> Option<Box<ModuleInfoDeserialized>> {
-        // PORT NOTE: Zig matched on error.OutOfMemory → bun.outOfMemory(); in
-        // Rust, allocation failure aborts via the global arena, so only
+        // Allocation failure aborts via the global arena, so only
         // BadModuleInfo remains.
         Self::create(source).ok()
     }
 
     pub fn serialize(&self, writer: &mut impl bun_io::Write) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let record_kinds = self.record_kinds();
         writer.write_all(&(record_kinds.len() as u32).to_le_bytes())?;
         writer.write_all(slice_as_bytes(record_kinds))?;
@@ -438,9 +431,7 @@ unsafe fn free_aligned_dup(slice: *mut [u8]) {
 /// or its length is not a multiple of `size_of::<T>()` (i.e. the format's
 /// internal padding was violated).
 ///
-/// (Zig used `std.mem.bytesAsSlice` → `[]align(1) const T`; Rust has no
-/// under-aligned reference type, so we guarantee alignment instead via
-/// `bytemuck::try_cast_slice`, which checks both alignment and size.)
+/// (`bytemuck::try_cast_slice` checks both alignment and size.)
 #[inline]
 fn bytes_as_slice<T: bytemuck::AnyBitPattern>(bytes: &[u8]) -> Result<&[T], ModuleInfoError> {
     bytemuck::try_cast_slice(bytes).map_err(|_| ModuleInfoError::BadModuleInfo)
@@ -470,8 +461,7 @@ pub trait ModuleInfoExt {
     /// `this` must originate from `heap::alloc(ModuleInfo::create(..))`.
     unsafe fn destroy_raw(this: *mut ModuleInfo);
     /// Finalize and box the raw-pointer `ModuleInfoDeserialized` view, taking
-    /// ownership of `self`. Replaces the Zig pattern of writing into the
-    /// embedded `_deserialized` field and handing out a `&mut` to it.
+    /// ownership of `self`.
     fn into_deserialized(self: Box<Self>) -> Box<ModuleInfoDeserialized>;
 }
 
@@ -482,14 +472,13 @@ impl ModuleInfoExt for ModuleInfo {
         drop(unsafe { bun_core::heap::take(this) });
     }
     fn into_deserialized(mut self: Box<Self>) -> Box<ModuleInfoDeserialized> {
-        // PORT NOTE: Zig wrote a self-referential `_deserialized` view inside
-        // `ModuleInfo` during `finalize()`. The Rust printer-crate `ModuleInfo`
-        // exposes a borrowed `as_deserialized()` instead; here we materialise the
+        // The printer-crate `ModuleInfo`
+        // exposes a borrowed `as_deserialized()`; here we materialise the
         // raw-pointer FFI shape and tie its lifetime to the leaked `Box<ModuleInfo>`.
         if !self.finalized {
             let _ = self.finalize();
         }
-        // PORT NOTE: reshaped for borrowck — capture lifetime-erased `RawSlice`
+        // Reshaped for borrowck — capture lifetime-erased `RawSlice`
         // views before `heap::into_raw(self)` consumes the box.
         let (strings_buf, strings_lens, rm_keys, rm_values, rm_phases, buffer, record_kinds, flags);
         {
@@ -533,7 +522,6 @@ impl ModuleInfoExt for ModuleInfo {
 
 // zig__renderDiff, zig__ModuleInfoDeserialized__toJSModuleRecord, and the
 // JSModuleRecord/IdentifierArray opaques: see bun_bundler_jsc::analyze_jsc
-// (Zig `comptime { _ = @import }` force-reference dropped per porting guide.)
 
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn zig__ModuleInfo__destroy(info: *mut ModuleInfo) {
@@ -558,8 +546,5 @@ pub(crate) extern "C" fn zig_log(msg: *const c_char) {
     let msg = unsafe { NonNull::new(msg.cast_mut()).unwrap_unchecked() };
     // SAFETY: `msg` is non-null and points to a NUL-terminated C string per the contract above.
     let bytes = unsafe { bun_core::ffi::cstr(msg.as_ptr()) }.to_bytes();
-    // Zig: `Output.errorWriter().print("{s}\n", .{bytes}) catch {}`.
     bun_core::Output::print_error(format_args!("{}\n", bstr::BStr::new(bytes)));
 }
-
-// ported from: src/bundler/analyze_transpiled_module.zig
diff --git a/src/bundler/barrel_imports.rs b/src/bundler/barrel_imports.rs
index c58fcf28a43..3f7c2f5efe7 100644
--- a/src/bundler/barrel_imports.rs
+++ b/src/bundler/barrel_imports.rs
@@ -52,7 +52,7 @@ impl RequestedExports {
     }
 }
 
-// PORT NOTE: `original_alias` is stored as the raw arena `*const [u8]` (the
+// `original_alias` is stored as the raw arena `*const [u8]` (the
 // `NamedImport.alias` representation) instead of a tied `&'a [u8]` so the BFS
 // loop can hold a `BarrelExportResolution` across a `&mut graph.ast` reborrow
 // without the borrow checker seeing an overlap. The pointee outlives the
@@ -155,7 +155,6 @@ fn apply_barrel_optimization_impl(
 
     // Build the set of needed import_record_indices from already-requested
     // export names. Export * records are always needed.
-    // PERF(port): was stack-fallback (8192) — profile if hot.
     let mut needed_records: ArrayHashMap<u32, ()> = ArrayHashMap::default();
 
     for record_idx in ast.export_star_import_records.iter() {
@@ -181,7 +180,7 @@ fn apply_barrel_optimization_impl(
     // handles the case where file A imports Alpha from the barrel (previous
     // build) and file B adds Beta (current build). Without this, Alpha would
     // be re-deferred because only B's requests are in requested_exports.
-    // PORT NOTE: `DevServerHandle` is `Copy`; copied out so the `&self` borrow
+    // `DevServerHandle` is `Copy`; copied out so the `&self` borrow
     // doesn't conflict with later `&mut this.requested_exports`.
     let dev_handle = this.dev_server_handle().copied();
     if let Some(dev) = dev_handle {
@@ -208,7 +207,6 @@ fn apply_barrel_optimization_impl(
     // import records that share a path with any needed record.
     if dev_handle.is_some() {
         // Collect paths of needed records.
-        // PERF(port): was stack-fallback (4096) — profile if hot.
         let mut needed_paths: StringArrayHashMap<()> = StringArrayHashMap::default();
 
         for rec_idx in needed_records.keys() {
@@ -238,7 +236,7 @@ fn apply_barrel_optimization_impl(
 
     // Mark unneeded named re-export records as is_unused.
     let mut has_deferrals = false;
-    // PORT NOTE: reshaped for borrowck — collect (ref_, import_record_index)
+    // Borrowck: collect (ref_, import_record_index)
     // pairs first so we can mutate `ast.import_records` without aliasing
     // `ast.named_exports`/`ast.named_imports`.
     for i in 0..ast.named_exports.count() {
@@ -303,7 +301,7 @@ fn un_defer_record(import_records: &mut import_record::List, record_idx: u32) ->
 }
 
 /// BFS work queue item: un-defer an export from a barrel.
-// PORT NOTE: 'a borrows arena-backed AST alias strings.
+// `'a` borrows arena-backed AST alias strings.
 struct BarrelWorkItem<'a> {
     barrel_source_index: u32,
     alias: &'a [u8],
@@ -370,10 +368,9 @@ pub(crate) fn schedule_barrel_deferred_imports(
     result_source_index: u32,
     result_ast_target: bun_ast::Target,
 ) -> Result<i32, AllocError> {
-    // PORT NOTE: Zig passed `*ParseTask.Result.Success` and read `result.ast`
-    // after `graph.ast.set(idx, result.ast)` value-copied it. Rust *moves*
-    // `result.ast` into `graph.ast`, so this fn reads the just-written
-    // `graph.ast[result_source_index]` instead. Phase 1/2 only read
+    // `result.ast` is *moved*
+    // into `graph.ast` before this fn runs, so this fn reads the just-written
+    // `graph.ast[result_source_index]`. Phase 1/2 only read
     // `import_records` / `named_imports` for THIS index; the BFS (Phase 3)
     // takes fresh `&mut graph.ast` borrows after these raw reads are dead.
     //
@@ -388,7 +385,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
     let file_named_imports: bun_ptr::BackRef<JSAst::NamedImports> =
         bun_ptr::BackRef::new(&this.graph.ast.items_named_imports()[result_source_index as usize]);
 
-    // PORT NOTE: `DevServerHandle` copied out so `&mut this.*` field borrows
+    // `DevServerHandle` copied out so `&mut this.*` field borrows
     // don't conflict with the `&self` accessor.
     let dev_handle = this.dev_server_handle().copied();
 
@@ -402,7 +399,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
     // barrel optimization requires source_indices to seed requested_exports and to
     // BFS un-defer records. Resolve paths → source_indices here as a fallback.
     //
-    // PORT NOTE: reshaped for borrowck — `path_to_source_index_map` borrows
+    // Borrowck: `path_to_source_index_map` borrows
     // `&mut this.graph`; wrap in `BackRef` so the long-lived read borrow
     // doesn't conflict with `&mut this.requested_exports` /
     // `&mut this.graph.ast` below. The map is not mutated for the duration of
@@ -417,7 +414,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
         None
     };
 
-    // See PORT NOTE above — read-only deref valid through Phase 2.
+    // Read-only deref — valid through Phase 2 (see the raw-read note above).
     let file_import_records = file_import_records.get();
 
     // Build a set of import_record_indices that have named_imports entries,
@@ -451,7 +448,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
         }
     }
 
-    // See PORT NOTE above — read-only deref valid through Phase 2.
+    // Read-only deref — valid through Phase 2 (see the raw-read note above).
     for ni in file_named_imports.values() {
         if ni.import_record_index as usize >= file_import_records.len() {
             continue;
@@ -543,10 +540,9 @@ pub(crate) fn schedule_barrel_deferred_imports(
     // Build work queue from this file's named_imports, then propagate
     // through chains of barrels. Only runs real work when barrels exist
     // (targets with deferred records).
-    // PERF(port): was stack-fallback (8192) — profile if hot.
     let mut queue: Vec<BarrelWorkItem> = Vec::new();
 
-    // See PORT NOTE above — read-only deref valid through Phase 2.
+    // Read-only deref — valid through Phase 2 (see the raw-read note above).
     for ni in file_named_imports.values() {
         if ni.import_record_index as usize >= file_import_records.len() {
             continue;
@@ -661,13 +657,12 @@ pub(crate) fn schedule_barrel_deferred_imports(
     // dedup via requested_exports to prevent cycles.
     let initial_queue_len = queue.len();
 
-    // PERF(port): was stack-fallback (1024) — profile if hot.
     let mut barrels_to_resolve: ArrayHashMap<u32, ()> = ArrayHashMap::default();
 
     let mut newly_scheduled: i32 = 0;
     let mut qi: usize = 0;
     while qi < queue.len() {
-        // PORT NOTE: reshaped for borrowck — copy item fields out before pushing to queue later
+        // Copy item fields out before pushing to `queue` later (borrowck).
         let item_barrel_idx = queue[qi].barrel_source_index;
         let item_alias = queue[qi].alias;
         let item_is_star = queue[qi].is_star;
@@ -705,11 +700,11 @@ pub(crate) fn schedule_barrel_deferred_imports(
 
         // Use a helper to get barrel_ir freshly each time, since
         // resolveBarrelRecords can reallocate graph.ast and invalidate pointers.
-        // PORT NOTE: reshaped for borrowck — re-borrow graph.ast column after each mutation
+        // Re-borrow the `graph.ast` column after each mutation (borrowck).
         let barrel_ir = &mut this.graph.ast.items_import_records_mut()[barrel_idx as usize];
 
         if item_is_star {
-            // PORT NOTE: reshaped for borrowck — read flags by index, then mutate
+            // Read flags by index, then mutate (borrowck).
             let len = barrel_ir.len();
             for idx in 0..len {
                 let flags = barrel_ir.as_slice()[idx].flags;
@@ -733,7 +728,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
         );
         let Some(resolution) = resolution else {
             // Name not in named re-exports — might come from export *.
-            // PORT NOTE: clone the small u32 slice so iterating it doesn't
+            // Clone the small u32 slice so iterating it doesn't
             // alias the mutable `barrel_ir` borrow taken inside the loop.
             let star_records: Vec<u32> =
                 this.graph.ast.items_export_star_import_records()[barrel_idx as usize].to_vec();
@@ -773,7 +768,7 @@ pub(crate) fn schedule_barrel_deferred_imports(
         }
 
         // `original_alias` is an arena-backed `StoreStr` valid for the
-        // bundler-arena lifetime (see `BarrelExportResolution` PORT NOTE).
+        // bundler-arena lifetime (see the comment on `BarrelExportResolution`).
         let propagate_alias: &[u8] = match resolution.original_alias {
             Some(p) => p.slice(),
             None => alias,
@@ -820,5 +815,3 @@ pub(crate) fn schedule_barrel_deferred_imports(
 fn persist_barrel_export(dev: &crate::dispatch::DevServerHandle, barrel_path: &[u8], alias: &[u8]) {
     dev.register_barrel_export(barrel_path, alias)
 }
-
-// ported from: src/bundler/barrel_imports.zig
diff --git a/src/bundler/bundle_v2.rs b/src/bundler/bundle_v2.rs
index 5c73a36ce9a..6c390e509c6 100644
--- a/src/bundler/bundle_v2.rs
+++ b/src/bundler/bundle_v2.rs
@@ -40,7 +40,7 @@ use crate::transpiler::Transpiler;
 use crate::{Index, IndexInt, LinkerContext};
 
 // ── re-exports so callers can reference these via `bundle_v2::…` ──
-/// `BundleThread` (BundleThread.zig) — owns the worker pool + completion
+/// `BundleThread` — owns the worker pool + completion
 /// queue for `BundleV2`. Re-exported so callers reference `bundle_v2::BundleThread`.
 pub use crate::BundleThread::BundleThread;
 pub use crate::ParseTask;
@@ -61,10 +61,9 @@ pub struct PendingImport {
 }
 
 pub struct BundleV2<'a> {
-    // PORT NOTE: Zig stored `*Transpiler` (and aliased the same pointer into
-    // `ssr_transpiler` when SSR graph isn't separate). `ssr_transpiler` stays
-    // `*mut` so the alias is legal; `transpiler` is `&'a mut` for ergonomic
-    // field access throughout the bundler bodies.
+    // `ssr_transpiler` may alias this same transpiler when the SSR graph
+    // isn't separate, so it stays `*mut`; `transpiler` is `&'a mut` for
+    // ergonomic field access throughout the bundler bodies.
     pub transpiler: &'a mut Transpiler<'a>,
     /// When Server Components is enabled, this is used for the client bundles
     /// and `transpiler` is used for the server bundles.
@@ -89,8 +88,7 @@ pub struct BundleV2<'a> {
     /// When Bun Bake is used, the resolved framework is passed here.
     pub framework: Option<bake::Framework>,
     pub graph: Graph<'a>,
-    // `LinkerContext<'a>` borrows the same arena lifetime as `transpiler`
-    // (Zig stored both as raw pointers into the bundler heap).
+    // `LinkerContext<'a>` borrows the same arena lifetime as `transpiler`.
     pub linker: LinkerContext<'a>,
     // The hot reloader (`jsc::hot_reloader::NewHotReloader<BundleV2, …>`) owns the
     // boxed `Watcher`; bundler only ever calls `Watcher::add_file` on it.
@@ -138,7 +136,7 @@ pub struct BundleV2<'a> {
     /// deduplication is free.
     ///
     /// Indexed by `source_index` (dense `0..module_count`); a `Vec<Option<_>>`
-    /// instead of the Zig `AutoArrayHashMap<u32, ...>` because the key space is
+    /// instead of a hash map because the key space is
     /// dense and this is probed once per import in `on_parse_task_complete`
     /// (the main-thread parse-phase throughput limiter).
     pub requested_exports: Vec<Option<RequestedExports>>,
@@ -147,12 +145,10 @@ pub struct BundleV2<'a> {
 bun_core::declare_scope!(Bundle, visible);
 bun_core::declare_scope!(scan_counter, visible);
 
-/// `bundle_v2.zig` `ResolveQueue = std.StringArrayHashMap(*ParseTask)`.
 /// Values are raw `*mut ParseTask` (arena-owned by `graph.heap`); the map only
 /// dedups by path during a single `on_parse_task_complete` pass.
 pub(crate) type ResolveQueue = StringHashMap<*mut ParseTask>;
 
-/// `bundle_v2.zig:BakeOptions`.
 pub struct BakeOptions<'a> {
     pub framework: bake::Framework,
     pub client_transpiler: NonNull<Transpiler<'a>>,
@@ -162,8 +158,8 @@ pub struct BakeOptions<'a> {
 
 impl<'a> BundleV2<'a> {
     // ── raw-ptr accessors ─────────────────────────────────────────────────
-    // PORT NOTE: `transpiler`/`ssr_transpiler` are `*mut` because Zig stored
-    // aliased `*Transpiler` (same pointer in both slots when no SSR graph).
+    // `ssr_transpiler` is `*mut` because it may alias `transpiler`
+    // (same pointer in both slots when no SSR graph).
     // Callers go through these accessors so the unsafe deref is centralized.
     #[inline]
     pub fn transpiler(&self) -> &Transpiler<'a> {
@@ -246,7 +242,7 @@ impl<'a> BundleV2<'a> {
     pub fn transpiler_for_target(&mut self, target: options::Target) -> &mut Transpiler<'a> {
         // SAFETY: all three pointers are live for `'a` (set in `init`); the
         // `client_transpiler` arm is only reached when bake populated it.
-        // bundle_v2.zig:247-263 — outside of server-components / dev-server,
+        // Outside of server-components / dev-server,
         // the only case that doesn't return the main transpiler is a
         // browser-target request from a server-side build, which lazily
         // spins up a client transpiler.
@@ -259,7 +255,6 @@ impl<'a> BundleV2<'a> {
                     // overlapping `client_transpiler_ref()` borrow.
                     return unsafe { p.assume_mut() };
                 }
-                // bundle_v2.zig:250-252 — `client_transpiler orelse initializeClientTranspiler() catch panic`.
                 return self.initialize_client_transpiler().unwrap_or_else(|e| {
                     panic!("Failed to initialize client transpiler: {}", e.name())
                 });
@@ -277,7 +272,7 @@ impl<'a> BundleV2<'a> {
         }
     }
 
-    // PORT NOTE: draft `on_parse_task_complete` / `deinit_without_freeing_arena`
+    // draft `on_parse_task_complete` / `deinit_without_freeing_arena`
     // removed — canonical bodies live in the later impl blocks below.
 }
 // ══════════════════════════════════════════════════════════════════════════
@@ -294,7 +289,6 @@ pub mod bv2_impl {
     //
     // # Memory management
     //
-    // Zig is not a managed language, so we have to be careful about memory management.
     // Manually freeing memory is error-prone and tedious, but garbage collection
     // is slow and reference counting incurs a performance penalty.
     //
@@ -345,6 +339,7 @@ pub mod bv2_impl {
     use crate::{bun_css, import_record};
     use bun_alloc::{AllocError, Arena as ThreadLocalArena};
 
+    use self::bake_types as bake;
     use bun_ast::server_component_boundary;
     use bun_ast::{Binding, E, Expr, G, S};
     use bun_ast::{ImportKind, ImportRecord};
@@ -355,21 +350,17 @@ pub mod bv2_impl {
     use bun_resolver::fs::PathResolverExt as _;
     use bun_resolver::{self as _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)
-    use self::bake_types as bake;
 
     /// CYCLEBREAK(b0) 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 {
-        /// Mirrors src/bake/lib.zig `Side`.
         #[repr(u8)]
         #[derive(Copy, Clone, Eq, PartialEq, Debug, core::marker::ConstParamTy)]
         pub enum Side {
             Client = 0,
             Server = 1,
         }
-        /// Mirrors src/bake/lib.zig `Graph`.
         #[repr(u8)]
         #[derive(Copy, Clone, Eq, PartialEq, Debug)]
         pub enum Graph {
@@ -377,7 +368,7 @@ pub mod bv2_impl {
             Server = 1,
             Ssr = 2,
         }
-        /// Zig `@tagName(graph)` — used for the per-file `// path (target)` comment
+        /// Used for the per-file `// path (target)` comment
         /// in postProcessJSChunk and friends.
         impl From<Graph> for &'static str {
             fn from(g: Graph) -> Self {
@@ -396,7 +387,7 @@ pub mod bv2_impl {
                 }
             }
         }
-        /// Mirrors src/bake/DevServer.zig `FileKind` (the type of `CacheEntry.kind`).
+        /// The type of `CacheEntry.kind`.
         #[repr(u8)]
         #[derive(Copy, Clone, Eq, PartialEq, Debug)]
         pub enum CacheKind {
@@ -409,17 +400,17 @@ pub mod bv2_impl {
         pub struct CacheEntry {
             pub kind: CacheKind,
         }
-        /// Mirrors src/bake/DevServer.zig `ASSET_PREFIX` (= INTERNAL_PREFIX ++ "/asset" = "/_bun/asset").
+        /// INTERNAL_PREFIX ++ "/asset" = "/_bun/asset".
         pub(crate) const ASSET_PREFIX: &str = "/_bun/asset";
 
-        /// Mirrors src/bake/bake.zig:355 `BuiltInModule = union(enum)`. TYPE_ONLY moved
+        /// TYPE_ONLY moved
         /// down to bundler (T5); bake (in runtime, T6) constructs values of this type.
         pub enum BuiltInModule {
             Import(Box<[u8]>),
             Code(Box<[u8]>),
         }
 
-        /// Mirrors src/bake/DevServer.zig `EntryPointList.Flags` (`packed struct(u8)`).
+        /// `EntryPointList` flags.
         #[repr(transparent)]
         #[derive(Copy, Clone, Default, Eq, PartialEq)]
         pub struct EntryPointFlags(pub u8);
@@ -447,7 +438,7 @@ pub mod bv2_impl {
             }
         }
 
-        /// Mirrors src/bake/DevServer.zig `EntryPointList`. TYPE_ONLY moved down; bundler
+        /// TYPE_ONLY moved down; bundler
         /// reads `.set` (count/keys/values) in `enqueue_entry_points_dev_server`.
         #[derive(Default)]
         pub struct EntryPointList {
@@ -461,12 +452,9 @@ pub mod bv2_impl {
             }
         }
 
-        /// Mirrors src/bake/bake.zig `Framework`. TYPE_ONLY subset of the fields
-        /// the bundler/parser actually consult (see ParseTask.zig:1253
-        /// `opts.framework = transpiler.options.framework`); `file_system_router_types`
+        /// TYPE_ONLY subset of the `Framework` fields
+        /// the bundler/parser actually consult; `file_system_router_types`
         /// stays in T6 because only `bake::FrameworkRouter` reads it.
-        // TODO(b0-genuine): remaining Framework field `file_system_router_types`
-        // stays in T6; only bake::FrameworkRouter reads it.
         #[non_exhaustive]
         pub struct Framework {
             pub built_in_modules: bun_collections::StringArrayHashMap<BuiltInModule>,
@@ -480,14 +468,11 @@ pub mod bv2_impl {
             /// `linker_context::generateChunksInParallel` to gate `BakeExtra`.
             pub is_built_in_react: bool,
             /// Read by `entry_points.rs` (FallbackEntryPoint/ClientEntryPoint::generate).
-            /// 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,
         }
         impl Framework {
             /// Construct the bundler-side TYPE_ONLY view. Called from
-            /// `bun_runtime::bake::Framework::init_transpiler_with_options`
-            /// (spec bake.zig:778 `out.options.framework = framework`); the
+            /// `bun_runtime::bake::Framework::init_transpiler_with_options`; the
             /// runtime owns the canonical `bake.Framework` and projects the
             /// fields the bundler reads.
             pub fn new(
@@ -505,7 +490,7 @@ pub mod bv2_impl {
                 }
             }
         }
-        /// Mirrors src/bake/bake.zig `Framework.ServerComponents` — full string
+        /// `Framework.ServerComponents` — full string
         /// surface so the parser-side projection (ParseTask.rs `run_with_source_code`)
         /// can forward user-configured `serverRegisterServerReference` /
         /// `clientRegisterServerReference` instead of hardcoding defaults.
@@ -517,13 +502,12 @@ pub mod bv2_impl {
             pub server_register_server_reference: Box<[u8]>,
             pub client_register_server_reference: Box<[u8]>,
         }
-        /// Mirrors src/bake/bake.zig `Framework.ReactFastRefresh`.
         #[derive(Clone)]
         pub struct ReactFastRefresh {
             pub import_source: Box<[u8]>,
         }
 
-        /// Mirrors src/bake/bake.zig:840 `HmrRuntime`. TYPE_ONLY moved down so the
+        /// TYPE_ONLY moved down so the
         /// linker can splice the runtime preamble without depending on bun_bake.
         #[derive(Clone, Copy)]
         pub struct HmrRuntime {
@@ -533,7 +517,7 @@ pub mod bv2_impl {
         }
         impl HmrRuntime {
             pub const fn init(code: &'static [u8]) -> Self {
-                // const-fn line counter (mirrors `std.mem.count(u8, code, "\n")`).
+                // const-fn newline counter.
                 let mut n: u32 = 0;
                 let mut i = 0usize;
                 while i < code.len() {
@@ -551,7 +535,7 @@ pub mod bv2_impl {
         /// Alias used at the crate root (`crate::HmrRuntimeSide`); identical to `Side`.
         pub type HmrRuntimeSide = Side;
 
-        /// Mirrors src/bake/bake.zig:855 `getHmrRuntime`. MOVE_DOWN bake→bundler:
+        /// MOVE_DOWN bake→bundler:
         /// the codegen'd `bake.client.js` / `bake.server.js` are loaded via
         /// `bun_core::runtime_embed_file!` (same per-site `OnceLock<String>` cache
         /// `js_parser/runtime.rs` uses for `runtime.out.js`), so the storage lives
@@ -559,9 +543,8 @@ pub mod bv2_impl {
         /// own `&'static ZStr` flavour for JSC/C++ handoff; this bundler-side copy
         /// only needs `&[u8]` for the chunk preamble + sourcemap line skip, so the
         /// NUL-termination dance is unnecessary. Per-side `OnceLock<HmrRuntime>`
-        /// memoizes the `\n` count (Zig const-eval'd it on the `@embedFile` arm;
-        /// `runtime_embed_file!` already caches the file load, this caches the
-        /// `init` scan so repeat calls are a `Copy`).
+        /// memoizes the `\n` count (`runtime_embed_file!` already caches the file
+        /// load, this caches the `init` scan so repeat calls are a `Copy`).
         pub fn get_hmr_runtime(side: Side) -> HmrRuntime {
             static CLIENT: std::sync::OnceLock<HmrRuntime> = std::sync::OnceLock::new();
             static SERVER: std::sync::OnceLock<HmrRuntime> = std::sync::OnceLock::new();
@@ -580,14 +563,12 @@ pub mod bv2_impl {
             }
         }
 
-        /// Mirrors src/bake/bake.zig:936 `server_virtual_source` / :942 `client_virtual_source`.
         /// `bun_ast::Source` is not `const`-constructible (owns a `fs::Path`), so these
-        /// are lazy statics. PERF(port): was `pub const` in Zig.
+        /// are lazy statics.
         pub(crate) static SERVER_VIRTUAL_SOURCE: std::sync::LazyLock<bun_ast::Source> =
             std::sync::LazyLock::new(|| {
-                // Port of `Fs.Path.initForKitBuiltIn("bun", "bake/server")` (fs.zig:1992) —
-                // inlined because `bun_paths::fs::Path<'static>` is the local TYPE_ONLY stub and
-                // does not yet expose that constructor.
+                // Inlined because `bun_paths::fs::Path<'static>` is the local TYPE_ONLY stub and
+                // does not expose a built-in-path constructor.
                 bun_ast::Source {
                     path: bun_paths::fs::Path {
                         pretty: b"bun:bake/server",
@@ -613,7 +594,7 @@ pub mod bv2_impl {
                 ..Default::default()
             });
 
-        /// Canonical port of src/bake/production.zig:844 `EntryPointMap`.
+        /// `EntryPointMap`.
         /// Lives in the bundler (lower tier) so both `bun_runtime::bake::production`
         /// and `BundleV2::generate_from_bake_production_cli` share ONE nominal type
         /// (PORTING.md §Layering). Router-integration methods (`InsertionHandler`)
@@ -639,10 +620,9 @@ pub mod bv2_impl {
                 }
             }
 
-            /// `EntryPointMap.InputFile`. Zig packed `Side` into the slice-len word
-            /// for a 16-byte key; the Rust `Hash`/`Eq` impls below are content-based
-            /// (not byte-layout), so that packing is not load-bearing here — store a
-            /// `RawSlice` instead and let `bun_ptr` encapsulate the unsafe re-borrow.
+            /// `EntryPointMap.InputFile`. The `Hash`/`Eq` impls below are content-based
+            /// (not byte-layout) — store a
+            /// `RawSlice` and let `bun_ptr` encapsulate the unsafe re-borrow.
             /// `RawSlice<u8>: Send + Sync`, so no manual auto-trait impls are needed.
             #[derive(Copy, Clone)]
             pub struct InputFile {
@@ -678,7 +658,7 @@ pub mod bv2_impl {
             impl Eq for InputFile {}
 
             /// Value side is `OutputFile.Index` — left as a placeholder until the
-            /// bundle is indexed (Zig leaves it `undefined`); the bundler never reads it.
+            /// bundle is indexed; the bundler never reads it.
             pub use crate::output_file::Index as OutputFileIndex;
 
             pub type EntryPointHashMap = bun_collections::ArrayHashMap<InputFile, OutputFileIndex>;
@@ -689,9 +669,8 @@ pub mod bv2_impl {
                 /// `OpaqueFileId` is the insertion index into this map.
                 pub files: EntryPointHashMap,
                 /// Owned backing storage for the duped path bytes that `InputFile`
-                /// keys point into (raw ptr+len). Mirrors Zig's `map.arena.dupe`
-                /// against `bun.default_allocator` — kept here so the allocations
-                /// drop with the map (PORTING.md §Forbidden: no `Box::leak`).
+                /// keys point into (raw ptr+len) — kept here so the allocations
+                /// drop with the map (no `Box::leak`).
                 pub owned_paths: Vec<Box<[u8]>>,
             }
             impl EntryPointMap {
@@ -707,22 +686,18 @@ pub mod bv2_impl {
                     if let Some(index) = self.files.get_index(&probe) {
                         return Ok(OpaqueFileId::init(index as u32));
                     }
-                    // Zig: `gop.key_ptr.* = InputFile.init(try map.arena.dupe(u8, abs_path), side);`
-                    // The Zig `errdefer map.files.swapRemoveAt(gop.index)` only guards the
-                    // `arena.dupe`, which is infallible in Rust, so no rollback needed.
                     let owned: Box<[u8]> = Box::<[u8]>::from(abs_path);
                     let key = InputFile::init(&owned, side);
                     self.owned_paths.push(owned);
                     let index = self.files.count();
                     // Value is the post-bundle output index; left as a placeholder until
-                    // the bundle is indexed (production.zig:873 leaves it `undefined`).
+                    // the bundle is indexed.
                     self.files.put_no_clobber(key, OutputFileIndex::init(0))?;
                     Ok(OpaqueFileId::init(index as u32))
                 }
             }
         }
     }
-    // TODO(b0): 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
@@ -730,7 +705,7 @@ pub mod bv2_impl {
     /// 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.
     pub mod api {
-        /// Mirrors src/runtime/api/JSBundler.zig:1799 `BuildArtifact.OutputKind`.
+        /// `BuildArtifact.OutputKind`.
         /// Canonical definition lives in `crate::options::OutputKind`; re-exported
         /// here so the documented CYCLEBREAK path `api::build_artifact::OutputKind`
         /// keeps resolving.
@@ -738,7 +713,7 @@ pub mod bv2_impl {
             pub use crate::options::OutputKind;
         }
 
-        /// Mirrors src/runtime/api/JSBundler.zig:3 `JSBundler` — TYPE_ONLY subset.
+        /// `JSBundler` — TYPE_ONLY subset.
         /// Exposed as a module (not a struct) so callers can write
         /// `api::JSBundler::Load` / `api::JSBundler::Resolve::MiniImportRecord`.
         #[allow(non_snake_case)]
@@ -814,11 +789,10 @@ pub mod bv2_impl {
                 ) -> i32;
             }
             impl Plugin {
-                /// `Plugin.drainDeferred` (JSBundler.zig) — resolve every onLoad
-                /// `.defer()` promise. Zig wraps the FFI in `fromJSHostCallGeneric`
-                /// for exception-scope tracking and returns `JSError!void`; the
-                /// only bundler caller (`DeferredBatchTask::run_on_js_thread`) is
-                /// `catch return`, so the void FFI call is the observable
+                /// `Plugin.drainDeferred` — resolve every onLoad
+                /// `.defer()` promise. The
+                /// only bundler caller (`DeferredBatchTask::run_on_js_thread`)
+                /// ignores failures, so the void FFI call is the observable
                 /// behaviour at this tier.
                 pub fn drain_deferred(&mut self, rejected: bool) {
                     JSBundlerPlugin__drainDeferred(self, rejected)
@@ -925,8 +899,8 @@ pub mod bv2_impl {
             }
 
             /// Mirrors `JSBundler.FileMap` — virtual in-memory files for the build.
-            /// The Zig value type is `jsc.Node.BlobOrStringOrBuffer` (T6); bundler
-            /// only ever reads `.slice()`, so the moved-down map stores raw bytes.
+            /// The bundler only ever reads `.slice()`, so the moved-down map
+            /// stores raw bytes.
             /// `bun_runtime`'s `from_js` parses JS values via `BlobOrStringOrBuffer`
             /// in async (owning-copy) mode and inserts the extracted bytes here.
             #[derive(Default)]
@@ -1097,7 +1071,7 @@ pub mod bv2_impl {
                 }
             }
 
-            /// Mirrors `JSBundler.Resolve.MiniImportRecord` (zig:1242).
+            /// Owned snapshot of an import record handed to onResolve plugins.
             #[derive(Clone, Default)]
             pub struct MiniImportRecord {
                 pub kind: ImportKind,
@@ -1134,7 +1108,7 @@ pub mod bv2_impl {
                 }
             }
 
-            /// Mirrors `JSBundler.Resolve` (zig:1234). Both `js_task` and `task`
+            /// Both `js_task` and `task`
             /// are the real lower-tier `bun_event_loop` types, so `dispatch()` /
             /// `run_on_js_thread()` are implemented inherently (no T6 hook).
             pub struct Resolve {
@@ -1160,7 +1134,7 @@ pub mod bv2_impl {
                 pub fn init(bv2: &mut BundleV2<'_>, record: MiniImportRecord) -> Self {
                     Self {
                     // SAFETY: lifetime erased — Resolve is owned by the dispatch
-                    // chain and never outlives `bv2` (mirrors Zig raw `*BundleV2`).
+                    // chain and never outlives `bv2`.
                     bv2: std::ptr::from_mut::<BundleV2<'_>>(bv2).cast::<BundleV2<'static>>(),
                     import_record: record,
                     value: ResolveValue::Pending,
@@ -1169,10 +1143,6 @@ pub mod bv2_impl {
                 }
                 }
                 /// Hops to the JS thread to call the `onResolve` plugin chain.
-                /// Zig spec (JSBundler.zig:1311):
-                ///   `this.js_task = AnyTask.init(this);
-                ///    bv2.jsLoopForPlugins().enqueueTaskConcurrent(
-                ///      jsc.ConcurrentTask.create(this.js_task.task()))`
                 pub fn dispatch(&mut self) {
                     self.js_task = bun_event_loop::AnyTask::AnyTask {
                         ctx: core::ptr::NonNull::new(
@@ -1188,7 +1158,7 @@ pub mod bv2_impl {
                 }
                 pub fn run_on_js_thread(&mut self) {
                     let kind = self.import_record.kind;
-                    // PORT NOTE: reshaped for borrowck — capture the erased self
+                    // reshaped for borrowck — capture the erased self
                     // pointer before borrowing fields immutably for the FFI call.
                     let self_ptr = std::ptr::from_mut::<Self>(self).cast::<core::ffi::c_void>();
                     // SAFETY: `bv2` is a valid backref set by `init`; the plugin
@@ -1238,7 +1208,7 @@ pub mod bv2_impl {
                 }
             }
 
-            /// Mirrors `JSBundler.Load` (zig:1369).
+            /// Task driving an onLoad plugin invocation for one source file.
             pub struct Load {
                 pub bv2: *mut BundleV2<'static>,
                 pub source_index: bun_ast::Index,
@@ -1315,10 +1285,6 @@ pub mod bv2_impl {
                     self.parse_task().known_target.bake_graph()
                 }
                 /// Hops to the JS thread to call the `onLoad` plugin chain.
-                /// Zig spec (JSBundler.zig:1449):
-                ///   `this.js_task = AnyTask.init(this);
-                ///    let concurrent_task = jsc.ConcurrentTask.createFrom(&this.js_task);
-                ///    bv2.jsLoopForPlugins().enqueueTaskConcurrent(concurrent_task)`
                 pub fn dispatch(&mut self) {
                     self.js_task = bun_event_loop::AnyTask::AnyTask {
                         ctx: core::ptr::NonNull::new(
@@ -1337,7 +1303,7 @@ pub mod bv2_impl {
                 pub fn run_on_js_thread(&mut self) {
                     let is_server_side = self.bake_graph() != crate::bake_types::Graph::Client;
                     let default_loader = self.default_loader;
-                    // PORT NOTE: reshaped for borrowck — capture the erased self
+                    // reshaped for borrowck — capture the erased self
                     // pointer before borrowing fields immutably for the FFI call.
                     let self_ptr = std::ptr::from_mut::<Self>(self).cast::<core::ffi::c_void>();
                     // SAFETY: `bv2` is a valid backref set by `init`; the plugin
@@ -1366,8 +1332,7 @@ pub mod bv2_impl {
         }
     }
 
-    /// `SavedFile` is a unit struct in Zig
-    /// (src/bundler_jsc/output_file_jsc.zig:4) — its only member is `toJS`, which
+    /// `SavedFile`'s only member is `toJS`, which
     /// is JSC-bound and stays in T6. The bundler stores it as an `OutputFile` value
     /// tag, so a unit struct here is sufficient.
     pub mod saved_file {
@@ -1451,8 +1416,7 @@ pub mod bv2_impl {
         unsafe extern "Rust" {
             /// Defined `#[no_mangle]` in `bun_jsc::hot_reloader`. Installs a
             /// `NewHotReloader<BundleV2, AnyEventLoop, true>` watcher on the given
-            /// `BundleV2` (Zig: `Watcher.enableHotModuleReloading(this, null)` in
-            /// `BundleV2.init` — bundle_v2.zig:994). The bundler can't name the
+            /// `BundleV2`. The bundler can't name the
             /// reloader generic (T6), so this is a definer-prefixed extern hook.
             /// `'static` matches the impl-side signature; the sole caller
             /// (`bun build --watch`) leaks the `Box<BundleV2>` via
@@ -1477,9 +1441,8 @@ pub mod bv2_impl {
             unsafe { __bun_jsc_enable_hot_module_reloading_for_bundler(bv2) }
         }
 
-        /// Bytecode generation entry point for the linker. Mirrors the Zig
-        /// `jsc.VirtualMachine.is_bundler_thread_for_bytecode_cache = true;
-        ///  jsc.initialize(false); jsc.CachedBytecode.generate(...)` sequence.
+        /// Bytecode generation entry point for the linker: marks the calling
+        /// thread as bundler-for-bytecode-cache, initializes JSC, and generates.
         #[inline]
         pub fn generate_cached_bytecode(
             format: crate::options_impl::Format,
@@ -1489,18 +1452,17 @@ pub mod bv2_impl {
             __bun_jsc_generate_cached_bytecode(format, source, source_provider_url)
         }
 
-        /// CYCLEBREAK GENUINE: `JSBundleCompletionTask` (JSBundler.zig) — the
+        /// CYCLEBREAK GENUINE: `JSBundleCompletionTask` — the
         /// concrete struct lives in `bun_runtime` (its fields name `Config`/
         /// `Plugin`/`HTMLBundle::Route`). The bundler reads exactly two things
-        /// from it (`result == .err` and `jsc_event_loop.enqueueTaskConcurrent`),
-        /// so the high tier hands the bundler an erased owner + `&'static` vtable
-        /// pair (same shape as [`DevServerHandle`]). PERF(port): was direct field
-        /// access in Zig.
+        /// from it (whether the result is an error, and the concurrent-task
+        /// enqueue), so the high tier hands the bundler an erased owner +
+        /// `&'static` vtable pair (same shape as [`DevServerHandle`]).
         pub struct CompletionDispatch {
-            /// Zig: `completion.result == .err`
+            /// Whether the completion result is an error.
             pub result_is_err: unsafe fn(core::ptr::NonNull<super::JSBundleCompletionTask>) -> bool,
-            /// Zig: `completion.jsc_event_loop.enqueueTaskConcurrent(task)` — folds
-            /// the field access + enqueue so the bundler needn't name `*jsc.EventLoop`.
+            /// Folds the event-loop field access + enqueue so the bundler
+            /// needn't name the JSC event-loop type.
             pub enqueue_task_concurrent: unsafe fn(
                 core::ptr::NonNull<super::JSBundleCompletionTask>,
                 *mut bun_event_loop::ConcurrentTask::ConcurrentTask,
@@ -1543,7 +1505,7 @@ pub mod bv2_impl {
     /// (`Option<NonNull<bun_event_loop::AnyEventLoop>>`).
     pub use crate::linker_context_mod::EventLoop;
 
-    // `JSBundleCompletionTask` (JSBundler.zig) — typed-ptr marker for
+    // `JSBundleCompletionTask` — typed-ptr marker for
     // `BundleV2.completion`. The concrete struct lives in `bun_runtime` (its
     // fields name `Config`/`Plugin`/`HTMLBundle::Route`); the bundler only ever
     // holds a `NonNull<JSBundleCompletionTask>` inside [`dispatch::CompletionHandle`]
@@ -1586,11 +1548,9 @@ pub mod bv2_impl {
     pub use super::{BakeOptions, BundleV2, PendingImport};
 
     impl<'a> BundleV2<'a> {
-        /// Zig: `jsLoopForPlugins().enqueueTaskConcurrent(task)`. The Rust port
-        /// folds the lookup + enqueue so the bundler never dereferences
+        /// Folds the JS-loop lookup + enqueue so the bundler never dereferences
         /// `JSBundleCompletionTask` (its layout lives in `bun_runtime`); the
         /// `completion` handle carries the `&'static` vtable.
-        /// PERF(port): was inline `switch (this.loop().*)` + direct field access.
         pub fn enqueue_on_js_loop_for_plugins(
             &mut self,
             task: NonNull<bun_event_loop::ConcurrentTask::ConcurrentTask>,
@@ -1602,7 +1562,7 @@ pub mod bv2_impl {
                 return;
             }
             // From bake where the loop running the bundle is also the loop running
-            // the plugins (Zig: `switch (this.loop().*) { .js => |l| l, .mini => @panic }`).
+            // the plugins.
             // `any_loop_mut` centralises the BACKREF deref of `linker.r#loop`.
             match &*self.any_loop_mut() {
                 bun_event_loop::AnyEventLoop::Js { owner } => {
@@ -1625,11 +1585,7 @@ pub mod bv2_impl {
         }
 
         pub fn initialize_client_transpiler(&mut self) -> Result<&mut Transpiler<'a>, Error> {
-            // bundle_v2.zig:198-241.
-            //
-            // PORT NOTE: Zig does `client_transpiler.* = this_transpiler.*` (bitwise
-            // struct copy into an arena slot — no destructors). The Rust port
-            // builds a fresh owned `Transpiler` via `Transpiler::for_worker`
+            // Builds a fresh owned `Transpiler` via `Transpiler::for_worker`
             // (per-field deep clone), mutates the browser-specific options with
             // ordinary assignment (every field is owned by the clone, so `Drop` on
             // the overwritten value is correct), then boxes it on the global heap
@@ -1688,21 +1644,17 @@ pub mod bv2_impl {
             // deep-cloned `BundleOptions`/`Resolver` fields; `arena.alloc` would
             // leak them (bumpalo never drops).
             let mut boxed: Box<Transpiler<'a>> = Box::new(ct);
-            // Zig: `setLog` / `setAllocator` / `linker.resolver = &resolver` /
-            // `macro_context = MacroContext.init(transpiler)` /
-            // `resolver.caches = CacheSet.init(alloc)` — all handled by
-            // `for_worker` + `wire_after_move`.
+            // Log/allocator/linker-resolver/macro-context/cache wiring is all
+            // handled by `for_worker` + `wire_after_move`.
             boxed.wire_after_move();
 
             // `configure_defines` early-returns on `options.defines_loaded` (cloned
             // as `true`); kept for spec parity.
             boxed.configure_defines()?;
 
-            // Zig: `client_transpiler.resolver.opts = client_transpiler.options;` —
-            // re-project the resolver subset now that `target`/`conditions` etc.
+            // Re-project the resolver subset now that `target`/`conditions` etc.
             // have been overwritten for the browser.
             boxed.sync_resolver_opts();
-            // Zig: `client_transpiler.resolver.env_loader = client_transpiler.env;`
             boxed.resolver.env_loader = NonNull::new(this_env.cast());
 
             // Park the owning Box first, then derive both the published `NonNull`
@@ -1725,7 +1677,7 @@ pub mod bv2_impl {
             bake_graph: bake::Graph,
         ) -> &mut bun_ast::Log {
             if let Some(dev) = self.dev_server_handle() {
-                // CYCLEBREAK GENUINE: DevServer → vtable. PERF(port): was inline switch.
+                // CYCLEBREAK GENUINE: DevServer → vtable.
                 // SAFETY: owner is a live *mut DevServer per handle invariant.
                 return unsafe { &mut *dev.log_for_resolution_failures(abs_path, bake_graph) };
             }
@@ -1742,7 +1694,6 @@ pub mod bv2_impl {
         pub all_loaders: &'a [Loader],
         pub all_urls_for_css: &'a [&'a [u8]],
         pub redirects: &'a [u32],
-        // PORT NOTE: Zig copied the map by value (cheap shallow copy). The Rust
         // `PathToSourceIndexMap` is `!Clone` and the field is unread in `visit`, so
         // store a raw backref to satisfy the struct shape without forcing `Clone`.
         pub redirect_map: *const PathToSourceIndexMap,
@@ -1808,7 +1759,7 @@ pub mod bv2_impl {
             let import_record_list_id = source_index;
             // when there are no import records, v index will be invalid
             if (import_record_list_id.get() as usize) < self.all_import_records.len() {
-                // PORT NOTE: reshaped for borrowck — split borrow of all_import_records
+                // reshaped for borrowck — split borrow of all_import_records
                 let import_records_len =
                     self.all_import_records[import_record_list_id.get() as usize].len() as usize;
                 for ir_idx in 0..import_records_len {
@@ -1821,7 +1772,7 @@ pub mod bv2_impl {
                         while let Some(redirect_id) =
                             get_redirect_id(self.redirects[other_source.get() as usize])
                         {
-                            // PORT NOTE: reshaped for borrowck — copy out the redirect target's
+                            // reshaped for borrowck — copy out the redirect target's
                             // (source_index, path) before re-borrowing `all_import_records` mutably.
                             let (other_src_idx, other_path) = {
                                 let other_import_records =
@@ -1904,8 +1855,8 @@ pub mod bv2_impl {
     }
 
     /// RAII guard returned by [`BundleV2::decrement_scan_counter_on_drop`].
-    /// Decrements the bundle's pending-scan counter when dropped, mirroring Zig's
-    /// `defer this.decrementScanCounter()` without holding a unique borrow across
+    /// Decrements the bundle's pending-scan counter when dropped, without
+    /// holding a unique borrow across
     /// the body. Stores a raw pointer; caller guarantees the `BundleV2` outlives it.
     pub struct ScanCounterGuard {
         bv2: *mut BundleV2<'static>,
@@ -1923,12 +1874,11 @@ pub mod bv2_impl {
 
     impl<'a> BundleV2<'a> {
         pub fn find_reachable_files(&mut self) -> Result<Box<[Index]>, Error> {
-            // RAII guard — `Ctx` ends the span on Drop (Zig: `defer trace.end()`).
+            // RAII guard — `Ctx` ends the span on Drop.
             let _trace = crate::perf::trace("Bundler.findReachableFiles");
 
             // Create a quick index for server-component boundaries.
             // We need to mark the generated files as reachable, or else many files will appear missing.
-            // PERF(port): was stack-fallback
             let scb_bitset = if self.graph.server_component_boundaries.list.len() > 0 {
                 Some(
                     self.graph
@@ -1947,10 +1897,9 @@ pub mod bv2_impl {
 
             self.dynamic_import_entry_points = ArrayHashMap::new();
 
-            // PORT NOTE: reshaped for borrowck — hoist the values that would
+            // reshaped for borrowck — hoist the values that would
             // otherwise re-borrow `self`/`self.graph` while the visitor holds
-            // disjoint column refs (Zig pulled multiple `items(.field)` columns at
-            // once with no aliasing model).
+            // disjoint column refs.
             let redirect_map: *const PathToSourceIndexMap =
                 std::ptr::from_ref(self.path_to_source_index_map(self.transpiler.options.target));
             // Always materialize a valid slice; when the boundary list is empty
@@ -1959,7 +1908,7 @@ pub mod bv2_impl {
             // when `scb_bitset` is `None`).
             let scb_list = self.graph.server_component_boundaries.slice();
 
-            // PORT NOTE: reshaped for borrowck — `Slice<T>` is a value-type
+            // reshaped for borrowck — `Slice<T>` is a value-type
             // snapshot of column pointers (does not borrow `self.graph.ast`), so
             // `split_mut()` on the local can coexist with the shared borrows
             // below. The slab does not resize for the duration of this function.
@@ -2021,12 +1970,12 @@ pub mod bv2_impl {
                 }
             }
 
-            // PORT NOTE: reshaped for borrowck — release the visitor's `&mut`
+            // reshaped for borrowck — release the visitor's `&mut`
             // borrows on the two bitsets and `input_files` columns before the
             // cleanup loop reads them.
             let ReachableFileVisitor { reachable, .. } = visitor;
 
-            // PORT NOTE: reshaped for borrowck — three disjoint mutable SoA
+            // reshaped for borrowck — three disjoint mutable SoA
             // columns via `split_mut()` on a value-type `Slice` snapshot.
             let mut input_files_slice = self.graph.input_files.slice();
             let input_files_cols = input_files_slice.split_mut();
@@ -2057,8 +2006,8 @@ pub mod bv2_impl {
 
             if self.graph.pending_items == 0 {
                 let this: *mut Self = self;
-                // PORT NOTE: reshaped for borrowck — Zig passed `&self.graph` and
-                // `self` to the same call. Take a raw ptr so the two `&mut` don't
+                // reshaped for borrowck — `&self.graph` and
+                // `self` go to the same call. Take a raw ptr so the two `&mut` don't
                 // overlap from rustc's view.
                 // SAFETY: `drain_deferred_tasks` only touches `self.graph.deferred_*`
                 // fields and the `BundleV2` callback surface; no aliasing UB.
@@ -2072,9 +2021,7 @@ pub mod bv2_impl {
         }
 
         pub fn wait_for_parse(&mut self) {
-            // bundle_v2.zig:488-491 — `this.loop().tick(this, &isDone)`.
-            //
-            // PORT NOTE: `tick_raw` (not `tick`) — `is_done` reborrows `*ctx` as
+            // `tick_raw` (not `tick`) — `is_done` reborrows `*ctx` as
             // `&mut BundleV2`, and `BundleV2` (via `linker.r#loop`) owns the
             // `AnyEventLoop` slot, so holding `&mut AnyEventLoop` across the
             // callback would be a Stacked-Borrows violation.
@@ -2085,8 +2032,8 @@ pub mod bv2_impl {
                 .as_ptr();
             // SAFETY: `any_loop` points into `self.linker.r#loop`, valid for the
             // duration of this call; `self_ptr` is the live `&mut self`. The
-            // callback's `'static` lifetime erasure mirrors the Zig
-            // `*anyopaque` cast — `is_done` only touches by-value fields.
+            // callback's `'static` lifetime erasure is storage-only —
+            // `is_done` only touches by-value fields.
             unsafe {
                 bun_event_loop::AnyEventLoop::tick_raw(any_loop, self_ptr.cast(), |ctx| {
                     (*ctx.cast::<BundleV2<'static>>()).is_done()
@@ -2130,8 +2077,8 @@ pub mod bv2_impl {
             // pick the "module" field and the package is imported with "require" then
             // code expecting a function will crash.
             //
-            // PORT NOTE: reshaped for borrowck — Zig pulled the mutable
-            // `import_records` column alongside shared columns. `split_mut()` on a
+            // reshaped for borrowck — the mutable `import_records` column is
+            // needed alongside shared columns. `split_mut()` on a
             // value-type `Slice` snapshot yields the one mutable column without
             // borrowing `self.graph.ast`; read the per-target map through the
             // disjoint `build_graphs` field instead of the `&mut self` accessor.
@@ -2175,11 +2122,13 @@ pub mod bv2_impl {
             import_record: &jsc_api::JSBundler::MiniImportRecord,
             target: options::Target,
         ) {
-            // PORT NOTE: reshaped for borrowck — Zig held a `*Transpiler` raw pointer alongside
-            // other `this.*` accesses. `transpiler_for_target` borrows `&mut self`, so launder
+            // reshaped for borrowck — `transpiler_for_target` borrows `&mut self`, so launder
             // through a raw pointer to keep `*self` available below.
-            // SAFETY: the returned `&mut Transpiler` lives for `'a` (set in `init`), is not
-            // invalidated by anything called here, and Zig aliased it identically.
+            // SAFETY: the returned `&mut Transpiler` lives for `'a` (set in `init`) and is not
+            // invalidated by anything called here. No second `&mut` to the same transpiler is
+            // created while a `&mut` reborrow derived from this raw pointer is live; the later
+            // direct `self.transpiler.options.*` accesses are shared reads that occur after the
+            // last `&mut *transpiler` deref on their control path.
             let transpiler: *mut Transpiler<'a> = self.transpiler_for_target(target);
             let source_dir =
                 Fs::PathName::init(&import_record.source_file).dir_with_trailing_slash();
@@ -2193,7 +2142,7 @@ pub mod bv2_impl {
                 ) {
                     let file_map_result = _file_map_result;
                     let mut path_primary = file_map_result.path_pair.primary;
-                    // PORT NOTE: reshaped for borrowck — `get_or_put` borrows `*self` mutably via
+                    // reshaped for borrowck — `get_or_put` borrows `*self` mutably via
                     // `self.graph`; capture the slot as `*mut u32` so subsequent `self.*` calls
                     // type-check. SAFETY: `path_to_source_index_map(target)` is not mutated again
                     // until after the last `*value_ptr` access below.
@@ -2307,7 +2256,7 @@ pub mod bv2_impl {
                         }
 
                         let handles_import_errors;
-                        // PORT NOTE: reshaped for borrowck — `log_for_resolution_failures` borrows
+                        // reshaped for borrowck — `log_for_resolution_failures` borrows
                         // `&mut self`; the returned log is backed by either a DevServer-owned slot or
                         // `*self.transpiler.log` (both raw-pointer-derived), so detach the lifetime
                         // so `self.graph.*` / `self.transpiler.*` reads below type-check.
@@ -2400,9 +2349,9 @@ pub mod bv2_impl {
 
             let out_source_index: Option<Index>;
 
-            // PORT NOTE(borrowck): Zig held a `*Fs.Path` into `resolve_result` while
-            // also reading other fields and re-borrowing `self`. Rust borrowck rejects
-            // that, so we clone the active path out and operate on an owned value.
+            // borrowck: a `&mut` into `resolve_result` can't be held while
+            // also reading other fields and re-borrowing `self`,
+            // so we clone the active path out and operate on an owned value.
             let mut path: Fs::Path<'static> = match resolve_result.path() {
                 Some(p) => *p,
                 None => {
@@ -2438,7 +2387,7 @@ pub mod bv2_impl {
             path.assert_pretty_is_valid();
             path.assert_file_path_is_absolute();
 
-            // PORT NOTE(borrowck): split Zig's `getOrPut` into get-then-put so the map
+            // borrowck: get-then-put (instead of a single get-or-put) so the map
             // borrow doesn't span `enqueue_parse_task` (which needs `&mut self`).
             if let Some(existing) = self.path_to_source_index_map(target).get(path.text) {
                 out_source_index = Some(Index::init(existing));
@@ -2446,8 +2395,7 @@ pub mod bv2_impl {
                 path = self
                     .path_with_pretty_initialized(&path, target)
                     .expect("oom");
-                // PORT NOTE: Zig wrote through `path.* = …` (a `*Fs.Path` into
-                // `resolve_result.path_pair`); the borrowck-reshape above cloned
+                // The borrowck-reshape above cloned
                 // `path` out, so write the prettified path back so
                 // `ParseTask::init(&resolve_result, ..)` (via `enqueue_parse_task`)
                 // sees the relativized `pretty`.
@@ -2499,7 +2447,7 @@ pub mod bv2_impl {
                 // For example, it is silly to bundle index.css depended on by client+server twice.
                 // It makes sense to separate these for JS because the target affects DCE
                 if self.transpiler.options.server_components && !loader.is_javascript_like() {
-                    // PORT NOTE: reshaped for borrowck — cannot hold two `&mut` into
+                    // reshaped for borrowck — cannot hold two `&mut` into
                     // `self.graph` simultaneously, so re-derive the map per insert.
                     let key_text: Box<[u8]> = path.text.to_vec().into_boxed_slice();
                     let main_target = self.transpiler.options.target;
@@ -2541,7 +2489,7 @@ pub mod bv2_impl {
             target: options::Target,
         ) -> Result<(), Error> {
             // TODO: plugins with non-file namespaces
-            // PORT NOTE(borrowck): split Zig's `getOrPut` into get-then-put so the map
+            // borrowck: get-then-put (instead of a single get-or-put) so the map
             // borrow doesn't span the resolver / `&mut self` calls below.
             if self
                 .path_to_source_index_map(target)
@@ -2566,14 +2514,14 @@ pub mod bv2_impl {
 
             path = self.path_with_pretty_initialized(&path, target)?;
             path.assert_pretty_is_valid();
-            // PORT NOTE: see `enqueue_entry_item` — write the prettified path back
+            // see `enqueue_entry_item` — write the prettified path back
             // into `result` so `ParseTask::init(&result, ..)` reads the relativized
-            // `pretty` (Zig mutated `result.path_pair.primary` in place via `path.*`).
+            // `pretty`.
             result.path_pair.primary = path;
             self.path_to_source_index_map(target)
                 .put(path_slice, source_index.get())
                 .expect("oom");
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
             self.graph.input_files.append(crate::Graph::InputFile {
                 source: bun_ast::Source {
@@ -2586,7 +2534,7 @@ pub mod bv2_impl {
                 side_effects: result.primary_side_effects_data,
                 ..Default::default()
             })?;
-            // Arena-owned (Zig: `arena.create(ParseTask)`); freed on heap reset.
+            // Arena-owned; freed on heap reset.
             let task_val = ParseTask::init(&result, source_index, self);
             // SAFETY: arena outlives the bundle pass; reborrow `*mut` as `&mut`.
             let task: &mut ParseTask = self.arena_create(task_val);
@@ -2628,7 +2576,7 @@ pub mod bv2_impl {
             target: options::Target,
         ) -> Result<Option<IndexInt>, Error> {
             let result = &mut *resolve;
-            // PORT NOTE(borrowck): clone the active path out so we don't hold a `&mut`
+            // borrowck: clone the active path out so we don't hold a `&mut`
             // into `result` across the `&mut self` calls below.
             let mut path: Fs::Path<'static> = match result.path() {
                 Some(p) => *p,
@@ -2636,7 +2584,7 @@ pub mod bv2_impl {
             };
 
             path.assert_file_path_is_absolute();
-            // PORT NOTE(borrowck): split Zig's `getOrPut` into get-then-put.
+            // borrowck: get-then-put instead of a single get-or-put.
             if self
                 .path_to_source_index_map(target)
                 .get(path.text)
@@ -2659,13 +2607,8 @@ pub mod bv2_impl {
                     .into_static()
             };
             path.assert_pretty_is_valid();
-            // PORT NOTE: intern via `dupe_alloc` BEFORE writing back into `result` /
-            // the path-to-source-index map. Zig didn't need this — its dev-server
-            // `EntryPointList` keys borrow `dev.server_graph.bundled_files.keys()`
-            // (DevServer-owned), and `genericPathWithPrettyInitialized` returns the
-            // input `Path` unchanged for `node`-namespace built-ins (e.g.
-            // `bun-framework-react/server.tsx`), so `path.text` stayed a borrow of
-            // long-lived storage. The Rust port rebuilds a fresh
+            // intern via `dupe_alloc` BEFORE writing back into `result` /
+            // the path-to-source-index map. The dev-server path builds a fresh
             // `bake_types::EntryPointList` with `Box<[u8]>` keys (DevServer.rs:3027)
             // that drops as soon as `enqueue_entry_points_dev_server` returns;
             // `resolve_with_framework` then lifetime-erases that key into the
@@ -2675,12 +2618,10 @@ pub mod bv2_impl {
             // 'bun-framework-react/server.tsx'" when the worker can no longer match
             // `built_in_modules`.
             path = path.dupe_alloc(self.arena()).expect("oom");
-            // PORT NOTE: Zig's `var path = result.path()` is a `*Fs.Path` *into*
-            // `result.path_pair`, so the `path.* = pathWithPrettyInitialized(...)`
-            // assignment mutates the resolver result in place. The borrowck-reshape
+            // The borrowck-reshape
             // above cloned `path` out, which left `result.path_pair` with the
             // unrelativized `pretty` — and `ParseTask::init(&result, ..)` reads
-            // exactly that field, so the source comment header lost its
+            // exactly that field, so the source comment header would lose its
             // `top_level_dir`-relative path. Write the prettified path back here.
             if let Some(p) = result.path() {
                 *p = path;
@@ -2688,7 +2629,7 @@ pub mod bv2_impl {
             self.path_to_source_index_map(target)
                 .put(path.text, source_index.get())
                 .expect("oom");
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
             let side_effects = result.primary_side_effects_data;
             self.graph.input_files.append(crate::Graph::InputFile {
@@ -2702,7 +2643,7 @@ pub mod bv2_impl {
                 side_effects,
                 ..Default::default()
             })?;
-            // Arena-owned (Zig: `arena.create(ParseTask)`); freed on heap reset.
+            // Arena-owned; freed on heap reset.
             let task_val = ParseTask::init(result, source_index, self);
             // SAFETY: arena outlives the bundle pass; reborrow `*mut` as `&mut`.
             let task: &mut ParseTask = self.arena_create(task_val);
@@ -2757,7 +2698,7 @@ pub mod bv2_impl {
             thread_pool: Option<NonNull<ThreadPoolLib>>,
             heap: &'a ThreadLocalArena,
         ) -> Result<Box<BundleV2<'a>>, Error> {
-            // TODO(port): arena-allocate self via bump.alloc — Box::new is wrong arena (Zig: arena.create(@This()) on arena)
+            // The Box is heap-owned and dropped by the caller.
             transpiler.env().load_tracy();
 
             transpiler.options.mark_builtins_as_external =
@@ -2765,7 +2706,9 @@ pub mod bv2_impl {
             transpiler.resolver.opts.mark_builtins_as_external =
                 transpiler.options.target.is_bun() || transpiler.options.target == Target::Node;
 
-            // SAFETY: aliased *mut for `ssr_transpiler` (Zig stored both as raw ptrs).
+            // SAFETY: `ssr_transpiler` intentionally aliases `transpiler` via a
+            // raw `*mut` until bake installs a separate SSR transpiler; all
+            // derefs go through the centralized accessors.
             let ssr_alias: *mut Transpiler<'a> = std::ptr::from_mut(transpiler);
             let mut this = Box::new(BundleV2 {
                 transpiler,
@@ -2828,9 +2771,7 @@ pub mod bv2_impl {
                     }
                 }
             }
-            // PORT NOTE: Zig wired `heap.arena()` into `transpiler.arena` /
-            // `resolver.arena` / `linker.arena` / `log.msgs.arena`. The
-            // Rust `Transpiler<'a>`/`Resolver<'a>` store `&'a Arena` and `Log.msgs`
+            // `Transpiler<'a>`/`Resolver<'a>` store `&'a Arena` and `Log.msgs`
             // is a `Vec` (global alloc), so only `linker.graph.bump` needs the
             // backref into the now-stable `this.graph.heap` slot.
             this.linker.graph.bump = bun_ptr::BackRef::new(this.graph.heap);
@@ -2887,7 +2828,7 @@ pub mod bv2_impl {
 
             this.linker.dev_server = this.dev_server;
 
-            // Arena-owned (Zig: `arena.create(ThreadPool)`). Coerce to `*mut`
+            // Arena-owned. Coerce to `*mut`
             // immediately so the `&this` borrow from `arena()` ends before
             // `ThreadPool::init` takes `&mut this`.
             let pool: *mut ThreadPool =
@@ -2903,14 +2844,12 @@ pub mod bv2_impl {
                 bun_ptr::BackRef::from(NonNull::new(pool).expect("arena allocation is non-null"));
             // Install the watcher only after `ThreadPool::init()` has succeeded —
             // the `?` above is the last early-return in this fn, so the watcher's
-            // raw `*mut BundleV2` can't outlive the box it points at. (Zig installs
-            // it before `pool.* = try .init(..)`, but the Rust caller drops the box
-            // on every error path until `generate_from_cli` leaks it.)
+            // raw `*mut BundleV2` can't outlive the box it points at (the caller
+            // drops the box on every error path until `generate_from_cli` leaks it).
             if cli_watch_flag {
                 // CYCLEBREAK GENUINE: hot_reloader is T6; runtime constructs the
                 // `dispatch::WatcherHandle` (erased owner + `&'static WatcherVTable`)
-                // via this extern hook and writes `bun_watcher` (Zig:
-                // `Watcher.enableHotModuleReloading(this, null)` — bundle_v2.zig:994).
+                // via this extern hook and writes `bun_watcher`.
                 dispatch::enable_hot_module_reloading_for_bundler(core::ptr::from_mut(&mut *this));
             }
             // `Graph::pool` wraps the `BackRef` deref; `start()` takes `&self`.
@@ -2923,12 +2862,11 @@ pub mod bv2_impl {
         }
 
         /// Allocate `value` into the bundler's arena (`self.graph.heap`) and return
-        /// a `&'r mut T` whose lifetime is decoupled from `&self`. Mirrors Zig
-        /// `arena.create(T)` — the arena owns the slab and reclaims it on
+        /// a `&'r mut T` whose lifetime is decoupled from `&self`.
+        /// The arena owns the slab and reclaims it on
         /// `deinit_without_freeing_arena` / `heap.reset()`. The unbounded `'r`
         /// releases the `&self` borrow at the call site so callers can immediately
-        /// reborrow `&mut self` (PORTING.md §Allocators: `bump.alloc(init)` →
-        /// `&'bump mut T`).
+        /// reborrow `&mut self`.
         ///
         /// SAFETY (encapsulated): the arena slab is pinned and outlives every
         /// `&mut T` handed out here (freed only at `heap.reset()` after all
@@ -2971,7 +2909,7 @@ pub mod bv2_impl {
             }
         }
 
-        /// RAII form of Zig's `defer this.decrementScanCounter()`. Captures `self` as
+        /// RAII guard that decrements the scan counter on drop. Captures `self` as
         /// a raw pointer so the returned guard does not hold a `&mut` borrow for the
         /// rest of the scope; the caller must ensure `self` outlives the guard.
         pub fn decrement_scan_counter_on_drop(&mut self) -> ScanCounterGuard {
@@ -2980,8 +2918,8 @@ pub mod bv2_impl {
             }
         }
 
-        // PORT NOTE: split because data type varies by variant — cannot express `switch(variant)`-typed param with const-generic enum on stable
-        // TODO(port): comptime variant enum param + dependent data type — split into three monomorphic fns
+        // A const-generic enum param with variant-dependent data cannot be
+        // expressed on stable Rust, so this is split into three monomorphic fns.
         pub fn enqueue_entry_points_normal<P: AsRef<[u8]>>(
             &mut self,
             data: &[P],
@@ -3061,9 +2999,9 @@ pub mod bv2_impl {
             debug_assert_eq!(files.set.keys().len(), files.set.values().len());
             for (abs_path, flags) in files.set.keys().iter().zip(files.set.values().iter()) {
                 // Ensure we have the proper conditions set for client-side entrypoints.
-                // SAFETY: Zig stores `transpiler` as a raw `*Transpiler` across the loop body;
-                // mirror with `*mut` so it doesn't keep `self` borrowed through the plugin
-                // dispatch / dev_server calls below.
+                // SAFETY: hold the transpiler as a `*mut` across the loop body
+                // so it doesn't keep `self` borrowed through the plugin
+                // dispatch / dev_server calls below; the pointee lives for `'a`.
                 let transpiler: *mut Transpiler<'a> =
                     if flags.client() && !flags.server() && !flags.ssr() {
                         std::ptr::from_mut(self.transpiler_for_target(Target::Browser))
@@ -3217,7 +3155,7 @@ pub mod bv2_impl {
             })?;
 
             // try this.graph.entry_points.append(arena, Index.runtime);
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
             self.path_to_source_index_map(self.transpiler.options.target)
                 .put(&b"bun:wrap"[..], Index::RUNTIME.get())
                 .expect("oom");
@@ -3241,7 +3179,6 @@ pub mod bv2_impl {
 
         fn clone_ast(&mut self) -> Result<(), Error> {
             let _trace = crate::perf::trace("Bundler.cloneAST");
-            // TODO(port): bun.safety.alloc.assertEq
             self.linker.graph.ast = self.graph.ast.clone()?;
 
             for module_scope in self.linker.graph.ast.items_module_scope_mut() {
@@ -3335,7 +3272,7 @@ pub mod bv2_impl {
                     // "production build" part of Bake.
 
                     let keys = named_exports_array[*source_id as usize].keys();
-                    // PORT NOTE: `G::Property: !Clone` — build via iterator instead of `vec![v; n]`.
+                    // `G::Property: !Clone` — build via iterator instead of `vec![v; n]`.
                     let mut client_manifest_items: Box<[G::Property]> =
                         (0..keys.len()).map(|_| G::Property::default()).collect();
 
@@ -3531,7 +3468,7 @@ pub mod bv2_impl {
             known_target: options::Target,
         ) -> Result<IndexInt, AllocError> {
             let source_index = Index::init(u32::try_from(self.graph.ast.len()).expect("int cast"));
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
             self.graph.input_files.append(crate::Graph::InputFile {
                 source: core::mem::take(source),
@@ -3539,9 +3476,9 @@ pub mod bv2_impl {
                 side_effects: loader.side_effects(),
                 ..Default::default()
             })?;
-            // PORT NOTE: `ParseTask::init` takes `bun_ast::Index`; both Index newtypes
+            // `ParseTask::init` takes `bun_ast::Index`; both Index newtypes
             // are `repr(transparent)` u32 so reconstruct via `.get()`.
-            // Arena-owned (Zig: `arena.create(ParseTask)`); freed on heap reset.
+            // Arena-owned; freed on heap reset.
             let task_val = ParseTask::init(
                 resolve_result,
                 bun_ast::Index::init(source_index.get()),
@@ -3584,7 +3521,7 @@ pub mod bv2_impl {
             known_target: options::Target,
         ) -> Result<IndexInt, AllocError> {
             let source_index = Index::init(u32::try_from(self.graph.ast.len()).expect("int cast"));
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
             self.graph.input_files.append(crate::Graph::InputFile {
                 source: core::mem::take(source),
@@ -3595,11 +3532,9 @@ pub mod bv2_impl {
             // `core::mem::take` moved the real `Source` into `graph.input_files`,
             // leaving `*source` as `Default`. Read path/contents back from the
             // graph's stored copy (where the data now lives for the rest of the
-            // bundle pass) so the `ParseTask` below sees the actual source bytes —
-            // matches Zig, which copies `source.*` by value and then reads the
-            // still-intact original.
+            // bundle pass) so the `ParseTask` below sees the actual source bytes.
             let stored = &self.graph.input_files.items_source()[source_index.get() as usize];
-            // PORT NOTE: Zig had a single `fs.Path`; Rust split it into
+            // The path type is split into
             // `bun_paths::fs::Path<'static>` (on `Source`) and `bun_resolver::fs::Path`
             // (on `ParseTask`). Convert field-by-field — `pretty`/`namespace` MUST
             // be preserved here (the SCB `separate_ssr_graph=false` caller passes a
@@ -3686,7 +3621,7 @@ pub mod bv2_impl {
             let mut new_source = source_without_index;
             let source_index = self.graph.input_files.len();
             new_source.index = bun_ast::Index(source_index as u32);
-            // PORT NOTE: `bun_ast::Source: !Clone` — manually dup the (all-Clone) fields.
+            // `bun_ast::Source: !Clone` — manually dup the (all-Clone) fields.
             let task_source = bun_ast::Source {
                 path: new_source.path,
                 contents: new_source.contents.clone(),
@@ -3700,14 +3635,14 @@ pub mod bv2_impl {
                 side_effects: bun_ast::SideEffects::HasSideEffects,
                 ..Default::default()
             })?;
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
-            // PORT NOTE: `bun.new(ServerComponentParseTask, …)` — heap-owned by the
+            // `bun.new(ServerComponentParseTask, …)` — heap-owned by the
             // worker pool; freed via `bun.destroy` in `on_complete` after the
             // result posts back to the bundle thread.
             let task = bun_core::heap::into_raw(Box::new(ServerComponentParseTask {
                 data,
-                // Lifetime-erase `'a` → `'static` for the BACKREF (matches Zig `*BundleV2`).
+                // Lifetime-erase `'a` → `'static` for the BACKREF.
                 // `NonNull::from(&mut *self)` carries write provenance for `assume_mut`
                 // in `on_complete`; `ParentRef::from(NonNull)` is the safe wrapper.
                 ctx: Some(bun_ptr::ParentRef::from(
@@ -3746,8 +3681,7 @@ pub mod bv2_impl {
 
     /// Callback contract for [`DependenciesScanner`]. Each call site's local
     /// `Analyzer` struct implements this; [`DependenciesScanner::new`] erases the
-    /// concrete type behind a monomorphized trampoline — Rust's analogue of Zig's
-    /// one-liner `.onFetch = @ptrCast(&Analyzer.onAnalyze)` (bundle_v2.zig:1492).
+    /// concrete type behind a monomorphized trampoline.
     pub trait OnDependenciesAnalyze {
         fn on_analyze(
             &mut self,
@@ -3758,8 +3692,7 @@ pub mod bv2_impl {
     impl DependenciesScanner {
         /// Type-erase `analyzer` into the `(ctx, on_fetch)` pair. The returned
         /// scanner borrows `*analyzer` for its lifetime: caller must keep
-        /// `analyzer` alive and exclusively owned until the scan completes
-        /// (mirrors Zig's stack-local `Analyzer` + `*anyopaque` ctx pattern).
+        /// `analyzer` alive and exclusively owned until the scan completes.
         pub fn new<A: OnDependenciesAnalyze>(
             analyzer: &mut A,
             entry_points: Box<[Box<[u8]>]>,
@@ -3855,7 +3788,7 @@ pub mod bv2_impl {
                     &raw const *this.transpiler.options.entry_points;
                 // SAFETY: `transpiler.options.entry_points` is borrowed only for the duration
                 // of `enqueue_entry_points_normal`, which never frees/reallocates it; raw-ptr
-                // sidestep for the `&mut self` overlap (Zig stored both as raw `*Transpiler`).
+                // sidestep for the `&mut self` overlap.
                 this.enqueue_entry_points_normal(unsafe { &*entry_points })?;
 
                 if this.transpiler.log().has_errors() {
@@ -3891,14 +3824,13 @@ pub mod bv2_impl {
                 // touches fields disjoint from `this.linker` (`graph`, `transpiler`,
                 // `dynamic_import_entry_points`, scalar reads) via `addr_of_mut!`/place
                 // projection, so the `&mut this.linker` receiver and `*bundle_ptr` never produce
-                // overlapping `&mut`. (Zig stored all as raw ptrs — bundle_v2.zig:1939.)
+                // overlapping `&mut`.
                 let mut chunks = unsafe {
                     let bundle_ptr: *mut BundleV2 = &raw mut *this;
                     // `Graph::entry_points: Vec<Index>` and `link()` takes `&[Index]` —
                     // both are `crate::Index` (= `bun_ast::Index`), so no cast is needed.
                     let ep = (*bundle_ptr).graph.entry_points.as_slice();
-                    // Spec passes `this.graph.server_component_boundaries` by value-copy
-                    // (Zig struct copy), leaving the original intact for
+                    // `this.graph.server_component_boundaries` must stay intact for
                     // `StaticRouteVisitor` (generateChunksInParallel) to read via
                     // `parse_graph`. Borrow — do NOT `take`, which would empty the
                     // graph slot and drop the moved-out `MultiArrayList` heap inside
@@ -3928,7 +3860,7 @@ pub mod bv2_impl {
                 )?;
                 this.dump_pool_stats("print");
 
-                // Generate metafile if requested (CLI writes files in build_command.zig)
+                // Generate metafile if requested (the CLI build command writes the files)
                 let metafile: Option<Box<[u8]>> = if this.linker.options.metafile {
                     match crate::linker_context::metafile_builder::generate(
                         &mut this.linker,
@@ -3944,7 +3876,7 @@ pub mod bv2_impl {
                     None
                 };
 
-                // Markdown is generated later in build_command.zig for CLI
+                // Markdown is generated later by the CLI build command
                 Ok(BuildResult {
                     output_files,
                     metafile,
@@ -3954,9 +3886,7 @@ pub mod bv2_impl {
 
             // Under `--watch` the watcher thread holds `*mut BundleV2` (via the
             // reloader's `ctx`) and dereferences it in `on_file_update` after this
-            // function returns. In Zig the `BundleV2` is arena-allocated and the
-            // arena is never freed (the caller diverges into `exitOrWatch`); in
-            // Rust it's `Box`-allocated, so leak it here to match the spec lifetime.
+            // function returns, so leak the Box to keep the pointee alive.
             // Bounded leak: the next file change `execve()`s the process anyway.
             if enable_reloading {
                 let _ = Box::into_raw(this);
@@ -3973,10 +3903,10 @@ pub mod bv2_impl {
         /// test entry points transitively depend on a given set of source files.
         ///
         /// The caller owns the returned BundleV2. Dupe anything needed out of
-        /// the graph and then call `deinit_without_freeing_arena()` — in the
-        /// Rust port the AST columns (`Vec<Symbol>` / `Vec<Part>` / …) live on
+        /// the graph and then call `deinit_without_freeing_arena()` — the
+        /// AST columns (`Vec<Symbol>` / `Vec<Part>` / …) live on
         /// the global heap, not in `graph.heap`, so leaving the bundle alive is
-        /// no longer the bounded arena leak the Zig original described. The
+        /// not a bounded arena leak. The
         /// worker pool is owned (created with `thread_pool: None`), so tearing
         /// it down does not touch the runtime VM's parse threads.
         pub fn scan_module_graph_from_cli(
@@ -4063,7 +3993,7 @@ pub mod bv2_impl {
                 let mut chunks = unsafe {
                     let bundle_ptr: *mut BundleV2 = &raw mut *this;
                     let ep = (*bundle_ptr).graph.entry_points.as_slice();
-                    // Spec: value-copy (original preserved for `StaticRouteVisitor`).
+                    // Value-copy (original preserved for `StaticRouteVisitor`).
                     // Borrow — do NOT `take` (see `generate_from_cli`).
                     let scbs = &(*bundle_ptr).graph.server_component_boundaries;
                     // Project `.linker` via `bundle_ptr` so no second `Box::deref_mut`
@@ -4111,7 +4041,7 @@ pub mod bv2_impl {
                     .zip(scbs.list.items_ssr_source_index().iter())
                 {
                     for idx in [*original_index, *ssr_index] {
-                        self.graph.entry_points.push(bun_ast::Index::init(idx)); // PERF(port): was assume_capacity
+                        self.graph.entry_points.push(bun_ast::Index::init(idx));
                     }
                 }
             }
@@ -4120,14 +4050,12 @@ pub mod bv2_impl {
 
         pub fn process_files_to_copy(&mut self, reachable_files: &[Index]) -> Result<(), Error> {
             if self.graph.estimated_file_loader_count > 0 {
-                // PORT NOTE: Zig per-file `arena` column dropped — Box owns its alloc.
                 // SAFETY: MultiArrayList columns are disjoint backing storage; raw-ptr
                 // sidestep so we can hold several read-only column slices, one mutable
                 // column slice (`additional_files`), and call `transpiler_for_target`
-                // (which needs `&mut self`) inside the loop. Zig accessed all of these
-                // as raw `.items(.field)` slices with no borrow-checking.
+                // (which needs `&mut self`) inside the loop.
                 let self_ptr: *mut Self = self;
-                // SAFETY: see PORT NOTE above — disjoint MultiArrayList columns,
+                // SAFETY: see note above — disjoint MultiArrayList columns,
                 // raw-ptr sidestep for split-borrow against `transpiler_for_target`
                 // inside the loop. All six column derefs share the same invariant.
                 let (
@@ -4221,9 +4149,9 @@ pub mod bv2_impl {
 
                         let loader = loaders[index];
 
-                        // Zig hands the existing `source.contents` buffer to the
-                        // OutputFile (with its allocator) — no copy. Mirror that by
-                        // moving the contents out instead of `to_vec()`-cloning,
+                        // Hand the existing `source.contents` buffer to the
+                        // OutputFile — no copy: move the contents
+                        // out instead of `to_vec()`-cloning,
                         // which is prohibitively expensive for large assets.
                         let contents_len = source.contents.len();
                         let contents = match core::mem::take(&mut source.contents) {
@@ -4261,7 +4189,7 @@ pub mod bv2_impl {
         }
 
         pub fn on_load_async(&mut self, load: &mut jsc_api::JSBundler::Load) {
-            // Dispatch to the loop that *owns* `BundleV2` (Zig: `switch (this.loop().*)`).
+            // Dispatch to the loop that *owns* `BundleV2`.
             // For `Bun.build` this is a Mini loop running on the bundler thread, so
             // `on_load` must land there — not on the JS plugin loop — or it will
             // mutate `graph` / allocate from `graph.heap` off-thread.
@@ -4365,7 +4293,7 @@ pub mod bv2_impl {
                 load.source_index.get(),
                 core::mem::discriminant(&load.value)
             );
-            // PORT NOTE: `helpCatchMemoryIssues` was a mimalloc TLH probe; bumpalo has no equivalent.
+            // `helpCatchMemoryIssues` was a mimalloc TLH probe; bumpalo has no equivalent.
             let _ = FeatureFlags::HELP_CATCH_MEMORY_ISSUES;
             // `log_mut()` returns an unbounded `&mut Log` (backref to the
             // arena/DevServer-owned log) so the `&mut this.graph.*` reborrows
@@ -4453,8 +4381,7 @@ pub mod bv2_impl {
                             // watched files and dirs to their respective dependants.
                             let fd = if bun_watcher::REQUIRES_FILE_DESCRIPTORS {
                                 let mut buf = bun_paths::path_buffer_pool::get();
-                                // PORT NOTE: Zig used `std.posix.toPosixPath` (copy + NUL-
-                                // terminate); on kqueue platforms paths are already
+                                // On kqueue platforms paths are already
                                 // posix-separated so `z()` alone suffices.
                                 match bun_sys::open(
                                     bun_paths::resolve_path::z(load.path.as_ref(), &mut *buf),
@@ -4468,7 +4395,7 @@ pub mod bv2_impl {
                                 bun_sys::Fd::INVALID
                             };
 
-                            // Zig: `_ = this.bun_watcher.?.addFile(...) catch {};`
+                            // Failures to watch are intentionally ignored.
                             let _ = this.bun_watcher_mut().unwrap().add_file::<true>(
                                 fd,
                                 &load.path,
@@ -4533,7 +4460,7 @@ pub mod bv2_impl {
 
     impl<'a> BundleV2<'a> {
         pub fn on_resolve(resolve: &mut jsc_api::JSBundler::Resolve, this: &mut BundleV2) {
-            // Zig: `defer this.decrementScanCounter()`. RAII guard captures `this`
+            // RAII guard captures `this`
             // as a raw pointer so it does not hold a unique borrow across the body.
             let _dec_guard = this.decrement_scan_counter_on_drop();
             // `Resolve` is arena-allocated (no Drop); free its owned heap fields on every exit path.
@@ -4560,7 +4487,7 @@ pub mod bv2_impl {
                 core::mem::discriminant(&resolve.value)
             );
 
-            // PORT NOTE: `helpCatchMemoryIssues` was a mimalloc TLH probe; bumpalo has no equivalent.
+            // `helpCatchMemoryIssues` was a mimalloc TLH probe; bumpalo has no equivalent.
             let _ = FeatureFlags::HELP_CATCH_MEMORY_ISSUES;
 
             match resolve.value.consume() {
@@ -4601,8 +4528,7 @@ pub mod bv2_impl {
                         return;
                     }
 
-                    // SAFETY: Zig's `logForResolutionFailures` returns `*Log` (raw ptr).
-                    // Holding the `&mut bun_ast::Log` borrow would alias `&this.graph`
+                    // SAFETY: Holding the `&mut bun_ast::Log` borrow would alias `&this.graph`
                     // below; detach the lifetime so borrowck releases `this`. The log
                     // lives in `this.transpiler`/`this.framework`, disjoint from
                     // `graph.input_files`.
@@ -4647,8 +4573,7 @@ pub mod bv2_impl {
                         // allocations are moved into `this.free_list` below (in the
                         // `!found_existing` branch) and thus outlive `BundleV2`. Erase
                         // to `'static` so `Fs::Path<'static>` can borrow them across
-                        // `path_with_pretty_initialized` / `ParseTask` (mirrors Zig's
-                        // untracked-slice ownership). In the `found_existing`/`external`
+                        // `path_with_pretty_initialized` / `ParseTask`. In the `found_existing`/`external`
                         // branches `path` is dead before the boxes drop, so the dangling
                         // `'static` is never observed.
                         let (result_path_static, result_ns_static): (&'static [u8], &'static [u8]) = unsafe {
@@ -4691,7 +4616,7 @@ pub mod bv2_impl {
                                     resolve.import_record.original_target,
                                 )
                                 .expect("oom");
-                            // PORT NOTE: `GetOrPutResult` has no `key_ptr` — `get_or_put` already
+                            // `GetOrPutResult` has no `key_ptr` — `get_or_put` already
                             // duped the key into the map (see PathToSourceIndexMap.rs).
 
                             // We need to parse this
@@ -4700,7 +4625,7 @@ pub mod bv2_impl {
                             // SAFETY: map slot from `get_or_put` above; map not mutated since.
                             unsafe { *value_ptr = source_index.get() };
                             out_source_index = Some(source_index);
-                            let _ = this.graph.ast.append(JSAst::empty_in(this.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                            let _ = this.graph.ast.append(JSAst::empty_in(this.graph.heap)); // OOM/capacity: fire-and-forget
                             let loader = path
                                 .loader(&this.transpiler.options.loaders)
                                 .unwrap_or(Loader::File);
@@ -4709,8 +4634,7 @@ pub mod bv2_impl {
                                 .input_files
                                 .append(crate::Graph::InputFile {
                                     source: bun_ast::Source {
-                                        // PORT NOTE: Zig assigned `path` (Fs.Path) directly;
-                                        // shim to the field-identical `bun_paths::fs::Path<'static>`.
+                                        // Shim to the field-identical `bun_paths::fs::Path<'static>`.
                                         path: path_as_static(&path),
                                         contents: std::borrow::Cow::Borrowed(&b""[..]),
                                         index: bun_ast::Index(source_index.get()),
@@ -4748,7 +4672,7 @@ pub mod bv2_impl {
                                 known_target: resolve.import_record.original_target,
                                 ..Default::default()
                             };
-                            // Arena-owned (Zig: `arena.create(ParseTask)`).
+                            // Arena-owned.
                             // SAFETY: arena outlives the bundle pass.
                             let task: &mut ParseTask = this.arena_create(task_val);
                             task.task.node.next = core::ptr::null_mut();
@@ -4775,7 +4699,6 @@ pub mod bv2_impl {
                         } else {
                             // SAFETY: map slot from `get_or_put` above; map not mutated since.
                             out_source_index = Some(Index::init(unsafe { *value_ptr }));
-                            // PORT NOTE: Zig freed result.{namespace,path} here; Rust drops below.
                             drop(result.namespace);
                             drop(result.path);
                         }
@@ -4860,12 +4783,10 @@ pub mod bv2_impl {
                 }
             }
 
-            // Zig spec (bundle_v2.zig:2229): `defer { this.graph.{ast,input_files,
-            // entry_points,entry_point_original_names}.deinit(this.allocator()) }`.
-            // In Zig those `MultiArrayList`s only free their slab — every per-element
+            // Every per-element
             // payload (file contents, quoted source-map JSON, line-offset tables, …)
-            // lives in `this.graph.heap` / a per-worker `mi_heap_t`, so the caller's
-            // `defer heap.deinit()` bulk-frees them. The Rust port now matches that:
+            // lives in `this.graph.heap` / a per-worker `mi_heap_t`, so the
+            // arena teardown bulk-frees them:
             // `LinkerGraph.File.line_offset_table`
             // is `List<AstAlloc>` (slab + `columns_for_non_ascii` payloads in the
             // worker AST heap, see `compute_line_offsets`), and every
@@ -4904,7 +4825,7 @@ pub mod bv2_impl {
             }
 
             // Drop the lazily-created client transpiler (if any) before tearing
-            // down workers — matches the .zig spec ordering where the arena slot
+            // down workers — the slot
             // is invalidated ahead of `pool.workers_assignments` so no worker can
             // observe a half-torn-down transpiler. Clear the `client_transpiler`
             // alias first so it never dangles past the Box drop; in the
@@ -4923,7 +4844,7 @@ pub mod bv2_impl {
                 self.owned_client_transpiler = None;
             }
 
-            // bundle_v2.zig:1426-1437 — worker-assignment teardown.
+            // Worker-assignment teardown.
             let pool = self.graph.pool_mut();
             {
                 let mut assignments = pool.workers_assignments.lock();
@@ -4989,7 +4910,7 @@ pub mod bv2_impl {
             let mut chunks = unsafe {
                 let bundle_ptr: *mut BundleV2 = self;
                 let ep = (*bundle_ptr).graph.entry_points.as_slice();
-                // Spec: value-copy (original preserved for `StaticRouteVisitor`).
+                // Value-copy (original preserved for `StaticRouteVisitor`).
                 // Borrow — do NOT `take` (see `generate_from_cli`).
                 let scbs = &(*bundle_ptr).graph.server_component_boundaries;
                 // Project `.linker` via `bundle_ptr` so no `&mut *self` reborrow
@@ -5083,9 +5004,8 @@ pub mod bv2_impl {
         output_kind: crate::options::OutputKind,
     ) -> Result<(), Error> {
         if !outdir.is_empty() {
-            // Open the output directory and write the metafile relative to it.
-            // PORT NOTE: Zig used `bun.FD.cwd().makeOpenPath()` +
-            // `NodeFS.writeFileWithPathBuffer`. Route through `bun_sys::File`.
+            // Open the output directory and write the metafile relative to it,
+            // routed through `bun_sys::File`.
             let mut buf = bun_paths::path_buffer_pool::get();
             let joined = bun_paths::resolve_path::join_string_buf::<
                 bun_paths::resolve_path::platform::Auto,
@@ -5169,16 +5089,16 @@ pub mod bv2_impl {
             Ok(ctx)
         }
 
-        // TODO(b0-genuine): body has deep DevServer field access (current_bundle.start_data,
-        // css_entry_points, etc.). After tier-6 collapse this fn should be HOISTED into
+        // The 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.
         pub fn finish_from_bake_dev_server(
             &mut self,
             dev_server: &dispatch::DevServerHandle,
         ) -> Result<(), AllocError> {
-            // SAFETY: DevServer guarantees `current_bundle` is Some during finish (DevServer.zig:2237).
-            // The vtable slot returns `*mut ()` derived from `&mut dev.current_bundle.?.start_data`;
+            // SAFETY: DevServer guarantees `current_bundle` is Some during finish.
+            // The vtable slot returns `*mut ()` derived from the current bundle's `start_data`;
             // DevServer holds it exclusively for the duration of finalize, so the `&mut DevServerInput`
             // here is mut-valid and unaliased until this fn returns.
             let start = unsafe {
@@ -5205,7 +5125,7 @@ pub mod bv2_impl {
 
                 let asts = self.graph.ast.slice();
                 let css_asts = asts.items_css();
-                // PORT NOTE: SoA columns are physically disjoint slabs but rustc cannot
+                // SoA columns are physically disjoint slabs but rustc cannot
                 // see that through `&Slice`. Route the two columns we mutate (`parts`,
                 // `import_records`) through `split_raw()` (root-provenance `*mut [T]`,
                 // no `&mut` intermediate) so the per-index `&mut` does not conflict
@@ -5220,11 +5140,10 @@ pub mod bv2_impl {
                 let input_files = self.graph.input_files.slice();
                 let loaders = input_files.items_loader();
                 let sources = input_files.items_source();
-                // TODO(port): multi-zip iteration over MultiArrayList slices [1..]
                 for index in 1..self.graph.ast.len() {
-                    // SAFETY: `index < ast.len()`; see PORT NOTE above for column aliasing.
+                    // SAFETY: `index < ast.len()`; see note above for column aliasing.
                     let part_list = unsafe { &mut *parts_col.add(index) };
-                    // SAFETY: `index < ast.len()`; see PORT NOTE above for column aliasing.
+                    // SAFETY: `index < ast.len()`; see note above for column aliasing.
                     let import_records = unsafe { &mut *import_records_col.add(index) };
                     let maybe_css = &css_asts[index];
                     let target = asts.items_target()[index];
@@ -5238,15 +5157,14 @@ pub mod bv2_impl {
                             // This means the file can become an error after
                             // resolution, which is not usually the case.
                             css_total_files
-                                .push(Index::init(u32::try_from(index).expect("int cast"))); // PERF(port): was assume_capacity
+                                .push(Index::init(u32::try_from(index).expect("int cast")));
                             let mut log = bun_ast::Log::init();
                             if LinkerContext::scan_css_imports(
                                 u32::try_from(index).expect("int cast"),
                                 import_records.as_slice(),
-                                // PORT NOTE: `scan_css_imports` takes the column as a raw
+                                // `scan_css_imports` takes the column as a raw
                                 // `*const` slice (the scanImportsAndExports caller holds raw
-                                // SoA pointers); it only reads via `is_none()`. Zig spec
-                                // (`LinkerContext.zig:496`) types this `[]const ?*...`.
+                                // SoA pointers); it only reads via `is_none()`.
                                 std::ptr::from_ref(css_asts),
                                 sources,
                                 loaders,
@@ -5281,7 +5199,7 @@ pub mod bv2_impl {
                                     (),
                                 )?;
                             } else {
-                                js_files.push(Index::init(u32::try_from(index).expect("int cast"))); // PERF(port): was assume_capacity
+                                js_files.push(Index::init(u32::try_from(index).expect("int cast")));
 
                                 // Part liveness for HMR is seeded after `linker.load`
                                 // (every part of every JS file is marked live).
@@ -5344,7 +5262,6 @@ pub mod bv2_impl {
                     }
                 }
 
-                // TODO(port): leak js_files into arena — Zig returned .items
                 // SAFETY: `alloc_slice_copy` returns into the bundler arena which outlives
                 // this function. Erase the `&self` lifetime via `*const` so the borrow on
                 // `self.arena()` does not extend across the `&mut self` calls below
@@ -5376,7 +5293,7 @@ pub mod bv2_impl {
             unsafe {
                 let bundle_ptr: *mut BundleV2 = self;
                 let ep = (*bundle_ptr).graph.entry_points.as_slice();
-                // Spec: value-copy (original preserved). Borrow — do NOT `take`.
+                // Value-copy (original preserved). Borrow — do NOT `take`.
                 let scbs = &(*bundle_ptr).graph.server_component_boundaries;
                 // Project `.linker` via `bundle_ptr` so no `&mut *self` reborrow
                 // retag invalidates `ep`/`scbs` (SB hygiene).
@@ -5411,7 +5328,6 @@ pub mod bv2_impl {
                 }
             }
             self.linker.compute_data_for_source_map(js_reachable_files);
-            // TODO(port): errdefer { bun.outOfMemory() } — caller cannot recover
 
             /* arena: help_catch_memory_issues — no-op (mimalloc TLH check) */
 
@@ -5431,7 +5347,7 @@ pub mod bv2_impl {
                 };
             }
 
-            // PORT NOTE: `Chunk: !Default` (Vec fields). Allocate via Vec then
+            // `Chunk: !Default` (Vec fields). Allocate via Vec then
             // leak into the arena.
             let mut chunks: Vec<Chunk> =
                 Vec::with_capacity(1 + start.css_entry_points.count() + html_files.count());
@@ -5489,7 +5405,7 @@ pub mod bv2_impl {
                     ..Chunk::default()
                 });
             }
-            // Arena-owned (Zig allocates `chunks` from `this.arena()`); the
+            // Arena-owned; the
             // `DevServerOutput` lifetime is documented as "tied to the bundler's
             // arena". `alloc_slice_fill_iter` moves each `Chunk` into the bump.
             let chunks: *mut [Chunk] =
@@ -5504,7 +5420,6 @@ pub mod bv2_impl {
                 chunks,
             )
             .map_err(|_| AllocError)?;
-            // TODO(port): errdefer { bun.outOfMemory() } — caller cannot recover
 
             /* arena: help_catch_memory_issues — no-op (mimalloc TLH check) */
 
@@ -5529,10 +5444,10 @@ pub mod bv2_impl {
             original_target: options::Target,
         ) -> bool {
             if let Some(plugins) = self.plugins_ref() {
-                // PORT NOTE: `ImportRecord.path` is `bun_paths::fs::Path`; `has_any_matches`
+                // `ImportRecord.path` is `bun_paths::fs::Path`; `has_any_matches`
                 // takes the structurally-identical `bun_resolver::fs::Path`. Rebuild the
-                // resolver-crate variant from the same backing slices (Zig has a single
-                // `Fs.Path` type — the FFI side only reads `.text` / `.namespace`).
+                // resolver-crate variant from the same backing slices (the FFI side
+                // only reads `.text` / `.namespace`).
                 let match_path = Fs::Path::init_with_namespace(
                     import_record.path.text,
                     import_record.path.namespace,
@@ -5547,7 +5462,7 @@ pub mod bv2_impl {
                     );
                     self.increment_scan_counter();
 
-                    // Arena-owned (Zig: `arena.create(Resolve)`); the dispatch
+                    // Arena-owned; the dispatch
                     // chain holds the raw `*mut Resolve` until the JS thread calls
                     // back, at which point the bundle pass is still alive.
                     // SAFETY: arena outlives the bundle pass.
@@ -5590,7 +5505,7 @@ pub mod bv2_impl {
                         bstr::BStr::new(entry_point)
                     );
 
-                    // Arena-owned (Zig: `arena.create(Resolve)`).
+                    // Arena-owned.
                     // SAFETY: arena outlives the bundle pass.
                     let resolve: &mut jsc_api::JSBundler::Resolve =
                         self.arena_create(jsc_api::JSBundler::Resolve::default());
@@ -5633,8 +5548,7 @@ pub mod bv2_impl {
                 let Ok(maybe_decoded) = data_url.decode_data() else {
                     return false;
                 };
-                // Zig: `this.free_list.append(decoded); parse.contents_or_fd = .{ .contents = decoded };`
-                // — the SAME allocation is both tracked for free at `deinit` and
+                // The SAME allocation is both tracked for free at `deinit` and
                 // borrowed as the parse-task contents. `free_list` owns it for the
                 // bundle's lifetime; `ParseTask` is strictly shorter-lived, so the
                 // raw-slice borrow is sound. No clone, no leak.
@@ -5665,7 +5579,7 @@ pub mod bv2_impl {
                         bstr::BStr::new(&parse.path.namespace),
                         bstr::BStr::new(&parse.path.text)
                     );
-                    // Arena-owned (Zig: `arena.create(Load)`); the dispatch
+                    // Arena-owned; the dispatch
                     // chain holds the raw `*mut Load` until the JS thread calls back.
                     let load_val = jsc_api::JSBundler::Load::init(self, parse);
                     // SAFETY: arena outlives the bundle pass.
@@ -5711,9 +5625,9 @@ pub mod bv2_impl {
             self.graph.ast.ensure_unused_capacity(2)?;
             self.graph.input_files.ensure_unused_capacity(2)?;
 
-            // PORT NOTE: Zig copied `bake.server_virtual_source` by value. The Rust
-            // statics are `LazyLock<Source>` and `Source` is not `Clone`, so rebuild
-            // an owned `Source` from the static's clonable fields (`path`, `index`).
+            // The statics are `LazyLock<Source>` and `Source` is not `Clone`, so
+            // rebuild an owned `Source` from the static's clonable fields
+            // (`path`, `index`).
             let server_source = bun_ast::Source {
                 path: bake::SERVER_VIRTUAL_SOURCE.path,
                 index: bake::SERVER_VIRTUAL_SOURCE.index,
@@ -5725,20 +5639,20 @@ pub mod bv2_impl {
                 ..Default::default()
             };
 
-            // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            // OOM/capacity: fire-and-forget
             let _ = self.graph.input_files.append(crate::Graph::InputFile {
                 source: server_source,
                 loader: Loader::Js,
                 side_effects: bun_ast::SideEffects::NoSideEffectsPureData,
                 ..Default::default()
-            }); // PERF(port): was assume_capacity
-            // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            });
+            // OOM/capacity: fire-and-forget
             let _ = self.graph.input_files.append(crate::Graph::InputFile {
                 source: client_source,
                 loader: Loader::Js,
                 side_effects: bun_ast::SideEffects::NoSideEffectsPureData,
                 ..Default::default()
-            }); // PERF(port): was assume_capacity
+            });
 
             debug_assert!(
                 self.graph.input_files.items_source()[Index::BAKE_SERVER_DATA.get() as usize]
@@ -5753,13 +5667,13 @@ pub mod bv2_impl {
                     == Index::BAKE_CLIENT_DATA.get()
             );
 
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // PERF(port): was assume_capacity
-            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // PERF(port): was assume_capacity
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap));
+            let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap));
             Ok(())
         }
 
         // See barrel_imports.rs for barrel optimization implementation.
-        // PORT NOTE: Zig `pub usingnamespace`-style method aliases. `pub use` is not
+        // `pub use` is not
         // permitted in `impl` blocks; the underlying fns live in `barrel_imports` and
         // take `&mut BundleV2` directly — callers reach them as free functions.
         // (was: pub use barrel_imports::{apply_barrel_optimization, schedule_barrel_deferred_imports})
@@ -5913,7 +5827,6 @@ pub mod bv2_impl {
 
                 if let Some(fw) = &self.framework {
                     if fw.server_components.is_some() {
-                        // PERF(port): was comptime bool dispatch — profile if hot.
                         let is_server = ctx.target.is_server_side();
                         let src = if is_server {
                             &bake::SERVER_VIRTUAL_SOURCE
@@ -6012,11 +5925,11 @@ pub mod bv2_impl {
                     continue;
                 }
 
-                // PORT NOTE: borrowck — `transpiler_for_target` returns `&mut Transpiler`
+                // borrowck — `transpiler_for_target` returns `&mut Transpiler`
                 // tied to `&mut self`, but the underlying storage is raw `*mut Transpiler`
                 // backrefs valid for `'a` (see `init`). Compute the raw ptr first, then
                 // deref once, so the `&mut self` borrow doesn't span the rest of the loop
-                // body (Zig held all of these as raw ptrs and aliased freely).
+                // body.
                 let (transpiler_ptr, bake_graph, target): (
                     *mut Transpiler<'a>,
                     bake::Graph,
@@ -6063,7 +5976,7 @@ pub mod bv2_impl {
                         ctx.target,
                     )
                 };
-                // SAFETY: see PORT NOTE above — raw `*mut Transpiler` lives for `'a`.
+                // SAFETY: see note above — raw `*mut Transpiler` lives for `'a`.
                 let transpiler: &mut Transpiler<'a> = unsafe { &mut *transpiler_ptr };
 
                 // Check the FileMap first for in-memory files
@@ -6114,7 +6027,7 @@ pub mod bv2_impl {
                             bstr::BStr::new(&path_primary.text)
                         );
                         file_map_result.path_pair.primary = path_primary;
-                        // Arena-owned (Zig: `arena.create(ParseTask)`).
+                        // Arena-owned.
                         let resolve_task_val =
                             ParseTask::init(&file_map_result, bun_ast::Index::INVALID, self);
                         // SAFETY: arena outlives the bundle pass.
@@ -6146,7 +6059,7 @@ pub mod bv2_impl {
                     ) {
                         Ok(r) => break r,
                         Err(err) => {
-                            // PORT NOTE: borrowck — `log_for_resolution_failures` returns
+                            // borrowck — `log_for_resolution_failures` returns
                             // `&mut Log` tied to `&mut self`, but it's always a raw-ptr
                             // deref (DevServer vtable or `transpiler.log`). Detach via
                             // `*mut` so later `self.*` reads don't conflict.
@@ -6313,13 +6226,12 @@ pub mod bv2_impl {
                     continue;
                 }
 
-                // PORT NOTE: borrowck — Zig `Result.path()` returns `?*Path` (raw),
-                // letting the loop body keep reading other `resolve_result` fields
-                // (`.flags`, `.path_pair`, `.primary_side_effects_data`, `.jsx`).
-                // The Rust port returns `Option<&mut Path>`, which would lock the
-                // whole struct. Detach via raw ptr to mirror the Zig aliasing.
+                // borrowck — `Result.path()` returns `Option<&mut Path>`, which
+                // would lock the whole struct while the loop body still needs to
+                // read other `resolve_result` fields (`.flags`, `.path_pair`,
+                // `.primary_side_effects_data`, `.jsx`). Detach via raw ptr.
                 let path: &mut Fs::Path = match resolve_result.path() {
-                    // SAFETY: `resolve_result` outlives this borrow; see PORT NOTE above.
+                    // SAFETY: `resolve_result` outlives this borrow; see note above.
                     Some(p) => unsafe { bun_ptr::detach_lifetime_mut::<Fs::Path>(p) },
                     None => {
                         import_record.path.is_disabled = true;
@@ -6479,7 +6391,7 @@ pub mod bv2_impl {
                 import_record.path = path_as_static(path);
                 // key already interned by get_or_put — no key_ptr on StringHashMapGetOrPut
                 bun_core::scoped_log!(Bundle, "created ParseTask: {}", bstr::BStr::new(&path.text));
-                // Arena-owned (Zig: `arena.create(ParseTask)`).
+                // Arena-owned.
                 let resolve_task_val =
                     ParseTask::init(&resolve_result, bun_ast::Index::INVALID, self);
                 // SAFETY: arena outlives the bundle pass.
@@ -6531,8 +6443,8 @@ pub mod bv2_impl {
             importer_source_index: IndexInt,
         ) -> i32 {
             let mut diff: i32 = 0;
-            // PORT NOTE: reshaped for borrowck — Zig freely aliased `graph` and the
-            // path map across the loop body. Here we (a) capture a raw self ptr for
+            // reshaped for borrowck — `graph` and the
+            // path map are both needed across the loop body. We (a) capture a raw self ptr for
             // ParseTask.ctx, (b) hoist dev_server check, and (c) scope the map
             // borrow to the get_or_put so later `self.graph.*` writes don't overlap.
             // SAFETY: write provenance from `ptr::from_mut`; outlives every ParseTask.
@@ -6607,7 +6519,7 @@ pub mod bv2_impl {
                         .input_files
                         .append(new_input_file)
                         .expect("unreachable");
-                    let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    let _ = self.graph.ast.append(JSAst::empty_in(self.graph.heap)); // OOM/capacity: fire-and-forget
 
                     if is_html_entrypoint {
                         self.ensure_client_transpiler();
@@ -6647,7 +6559,7 @@ pub mod bv2_impl {
 
                     // ParseTask is arena-allocated; the slab itself is reclaimed on
                     // arena reset, but its heap-owned fields (path/jsx clones) need
-                    // their destructors run now (Zig: `value.deinit()`).
+                    // their destructors run now.
                     // SAFETY: `value` is a live arena slot; not used after this.
                     unsafe { core::ptr::drop_in_place(value) };
                 }
@@ -6693,8 +6605,8 @@ pub mod bv2_impl {
             import_records: &mut import_record::List,
             ctx: PatchImportRecordsCtx,
         ) {
-            // PORT NOTE: Zig aliased `const graph = &this.graph;`. Borrowck rejects
-            // holding that across the `&mut self.graph.build_graphs[...]` borrow
+            // Borrowck rejects holding a `&self.graph` alias
+            // across the `&mut self.graph.build_graphs[...]` borrow
             // below, so address the disjoint `self.graph.*` fields directly instead.
             let input_file_loaders = self.graph.input_files.items_loader();
             let save_import_record_source_index = ctx.force_save
@@ -6733,7 +6645,7 @@ pub mod bv2_impl {
 
                     if let Some(compare) = get_redirect_id(ctx.redirect_import_record_index) {
                         if compare == i as u32 {
-                            let _ = path_to_source_index_map.put(ctx.source_path, source_index); // OOM-only Result (Zig: catch unreachable)
+                            let _ = path_to_source_index_map.put(ctx.source_path, source_index); // OOM-only Result
                         }
                     }
                 }
@@ -6750,7 +6662,7 @@ pub mod bv2_impl {
             // 1. Create the ast right here
             // 2. Create a separate "virutal" module that becomes the manifest later on.
             // 3. Add it to the graph
-            // PORT NOTE: Zig aliased `graph = &this.graph;` — re-borrow `self.graph`
+            // Re-borrow `self.graph`
             // at each use so the `self.*` method calls below don't conflict.
             let heap = self.graph.heap;
             let empty_html_file_source: &mut bun_ast::Source = self.arena_create(bun_ast::Source {
@@ -6822,12 +6734,12 @@ pub mod bv2_impl {
 
             let fake_source_index = fake_input_file.source.index;
             self.graph.input_files.append(fake_input_file)?;
-            let _ = self.graph.ast.append(ast_for_html_entrypoint); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = self.graph.ast.append(ast_for_html_entrypoint); // OOM/capacity: fire-and-forget
 
             import_record.source_index = Index::init(fake_source_index.0);
             let _ = self
                 .path_to_source_index_map(target)
-                .put(path_text, fake_source_index.0); // OOM-only Result (Zig: catch unreachable)
+                .put(path_text, fake_source_index.0); // OOM-only Result
             self.graph
                 .html_imports
                 .server_source_indices
@@ -6850,8 +6762,8 @@ pub mod bv2_impl {
 
         pub fn on_parse_task_complete(parse_result: &mut parse_task::Result, this: &mut BundleV2) {
             let _trace = crate::perf::trace("Bundler.onParseTaskComplete");
-            // PORT NOTE: Zig aliased `const graph = &this.graph;`. Borrowck rejects
-            // holding that across the `this.*` method calls below (each takes
+            // Borrowck rejects holding a `&this.graph` alias
+            // across the `this.*` method calls below (each takes
             // `&mut BundleV2`), so re-borrow `this.graph` at each use site instead.
             if parse_result.external.function.is_some() {
                 let source = match &parse_result.value {
@@ -6860,7 +6772,7 @@ pub mod bv2_impl {
                     parse_task::ResultValue::Success(val) => val.source.index.0,
                 };
                 let loader: Loader = this.graph.input_files.items_loader()[source as usize];
-                // PORT NOTE: `InputFile.arena` column dropped in the Rust port;
+                // `InputFile.arena` column dropped in the Rust port;
                 // stash the finalizer regardless so plugin-owned bytes are freed.
                 let _ = loader;
                 this.finalizers
@@ -6868,11 +6780,10 @@ pub mod bv2_impl {
             }
 
             // defer bun.default_allocator.destroy(parse_result) — caller owns Box and drops at end
-            // TODO(port): parse_result is heap-allocated by worker; reconstruct heap::take at scope exit
 
             let mut diff: i32 = -1;
-            // PORT NOTE: Zig used `defer { graph.pending_items += diff; … }` —
-            // hoisted to tail position (see end of fn) so the closure doesn't
+            // The pending-items adjustment is
+            // hoisted to tail position (see end of fn) so a deferred closure doesn't
             // double-borrow `graph`/`this`.
 
             let mut resolve_queue = ResolveQueue::default();
@@ -6894,14 +6805,14 @@ pub mod bv2_impl {
                         parse_task::ResultValue::Err(data) => data.source_index.get(),
                         parse_task::ResultValue::Success(val) => val.source.index.0,
                     };
-                    // PORT NOTE: borrowck — read source path/loader before
+                    // borrowck — read source path/loader before
                     // `should_add_watcher(&self)` so the column borrow is released.
                     let source_path = this.graph.input_files.items_source()[source_index as usize]
                         .path
                         .text;
                     let loader = this.graph.input_files.items_loader()[source_index as usize];
                     if this.should_add_watcher(source_path) {
-                        // PORT NOTE: const generic `CLONE_FILE_PATH = isWindows`
+                        // const generic `CLONE_FILE_PATH = isWindows`
                         // matches `cfg!(windows)` at compile time.
                         let _ = this
                             .bun_watcher_mut()
@@ -6965,7 +6876,6 @@ pub mod bv2_impl {
                             &mut result.source.contents,
                         );
                     }
-                    // PORT NOTE: Zig kept `source` as a stable pointer into the SoA.
                     // Borrowck forbids holding `&input_files.source[i]` while writing
                     // other `input_files` columns through the MultiArrayList accessor
                     // methods (each takes `&mut input_files`), so copy out the
@@ -7052,7 +6962,7 @@ pub mod bv2_impl {
                     // Set is_export_star_target for barrel optimization.
                     // In dev server mode, source_index is not saved on JS import
                     // records, so fall back to resolving via the path map.
-                    // PORT NOTE: split-borrow `Graph` fields directly so the
+                    // split-borrow `Graph` fields directly so the
                     // `&build_graphs[target]` lookup doesn't lock out
                     // `input_files.items_flags_mut()` (disjoint columns).
                     let result_ast_target = result.ast.target;
@@ -7074,12 +6984,9 @@ pub mod bv2_impl {
                     }
                     result.ast.import_records = import_records;
 
-                    // PORT NOTE: Zig reads `result.ast.named_exports` /
-                    // `result.source` *after* `graph.ast.set(…)` (Zig structs are
-                    // value types so the `set` is a shallow copy). The Rust port
-                    // moves `result.ast` into `graph.ast` and swapped `result.source`
-                    // earlier, so snapshot the data the use-directive block needs
-                    // *before* the move. Only paid for files that hit the SCB gate.
+                    // `result.ast` is moved into `graph.ast` and `result.source` was
+                    // swapped earlier, so snapshot the data the use-directive block
+                    // needs *before* the move. Only paid for files that hit the SCB gate.
                     let named_exports_for_scb = if result.use_directive != crate::UseDirective::None
                         && {
                             let separate = this
@@ -7134,9 +7041,9 @@ pub mod bv2_impl {
                             .unwrap()
                             .separate_ssr_graph;
 
-                        // PORT NOTE: `result.source` was swapped into
-                        // `graph.input_files` earlier; re-borrow it from the SoA.
-                        // `.clone()` materializes the value-copy Zig got for free.
+                        // `result.source` was swapped into
+                        // `graph.input_files` earlier; re-borrow it from the SoA
+                        // and `.clone()` where an owned copy is needed.
                         let source_loader: Loader =
                             this.graph.input_files.items_loader()[result_source_index];
 
@@ -7160,7 +7067,7 @@ pub mod bv2_impl {
 
                             let mut ssr_source =
                                 this.graph.input_files.items_source()[result_source_index].clone();
-                            // PORT NOTE: `path_with_pretty_initialized` takes/returns
+                            // `path_with_pretty_initialized` takes/returns
                             // `Fs::Path` (`bun_resolver::fs::Path`); bridge through
                             // `fs_path_from_logger`/`fs_path_to_logger` until the
                             // three `Path` mirrors unify.
@@ -7250,7 +7157,6 @@ pub mod bv2_impl {
                             err.log
                                 .clone_to_with_recycled(this.transpiler.log_mut(), true);
                         } else {
-                            // PORT NOTE: Zig used `@tagName(err.step)`.
                             let step_name = match err.step {
                                 crate::parse_task::Step::Pending => "pending",
                                 crate::parse_task::Step::ReadFile => "read_file",
@@ -7657,8 +7563,6 @@ pub mod bv2_impl {
         ProbablyTypescriptType,
     }
 
-    /// `bundle_v2.zig:ImportTracker.Iterator`.
-    ///
     /// `import_data` is a raw slice into
     /// `graph.meta[i].resolved_exports[..].potentially_ambiguous_export_star_refs`.
     /// The graph SoA is never reallocated during `match_import_with_export`, so
@@ -7753,7 +7657,7 @@ pub mod bv2_impl {
     }
 
     impl ExternalFreeFunctionAllocator {
-        // TODO(refactor): could implement `bun_alloc::Allocator` instead of the manual vtable.
+        // (Could implement `bun_alloc::Allocator` instead of the manual vtable.)
 
         fn free(ext_free_function: *mut c_void, _: &mut [u8], _: bun_alloc::Alignment, _: usize) {
             // SAFETY: ptr was created by ExternalFreeFunctionAllocator::create
@@ -7767,8 +7671,7 @@ pub mod bv2_impl {
     }
 
     /// `pub` so `bun_runtime::allocators::register_safety_vtables` can push the
-    /// address into the `bun_safety` registry (Zig spec: `bun.bundle_v2.
-    /// allocatorHasPointer` is one of the `safety/alloc.zig:hasPtr` arms).
+    /// address into the `bun_safety` registry.
     pub static EXTERNAL_FREE_VTABLE: bun_alloc::AllocatorVTable = bun_alloc::AllocatorVTable {
         alloc: |_, _, _, _| core::ptr::null_mut(),
         resize: |_, _, _, _, _| false,
@@ -7792,6 +7695,4 @@ pub mod bv2_impl {
     // C++ binding for lazy metafile getter (defined in BundlerMetafile.cpp)
     // Uses jsc.conv (SYSV_ABI on Windows x64) for proper calling convention
     // Sets up metafile object with { json: <lazy parsed>, markdown?: string }
-
-    // ported from: src/bundler/bundle_v2.zig
 }
diff --git a/src/bundler/bundled_ast.rs b/src/bundler/bundled_ast.rs
index 02a103c1daf..849428d03a5 100644
--- a/src/bundler/bundled_ast.rs
+++ b/src/bundler/bundled_ast.rs
@@ -11,7 +11,7 @@
 // erasure that forced every bundler/linker call site to `.cast()` back.
 pub use bun_css::BundlerStyleSheet;
 
-/// Arena-owned handle to a parsed CSS stylesheet (Zig: `*bun.css.BundlerStyleSheet`).
+/// Arena-owned handle to a parsed CSS stylesheet.
 ///
 /// The pointee lives in a per-file `Bump` whose ownership is held by
 /// `Graph.heap` (bumps are `Pin<Box<Bump>>` owned by the
@@ -39,13 +39,9 @@ pub(crate) type NamedExports = bun_ast::ast_result::NamedExports;
 pub(crate) type NamedImports = bun_ast::ast_result::NamedImports;
 pub type TopLevelSymbolToParts = bun_ast::ast_result::TopLevelSymbolToParts;
 
-// PORT NOTE: Zig stores `MultiArrayList(BundledAst)` on `Graph.ast` /
-// `LinkerGraph.ast` and the bundler indexes columns via `.items(.field)`
-// (see `linker_context/scanImportsAndExports.zig`, `LinkerContext.zig`).
-// `` generates the `BundledAstField` enum +
-// `BundledAstColumns`/`BundledAstColumns` (`items_named_imports()`,
-// `items_named_exports()`, …) that those callers expect at
-// `crate::bundled_ast::*`.
+// `multi_array_columns!` generates the `BundledAstField` enum +
+// `BundledAstColumns` (`items_named_imports()`,
+// `items_named_exports()`, …) at `crate::bundled_ast::*`.
 //
 // 26 fields ≤ `multi_array_list::MAX_FIELDS` (32).
 
@@ -59,17 +55,17 @@ pub struct BundledAst<'arena> {
     /// they can be manipulated efficiently without a full AST traversal
     pub import_records: import_record::List<'arena>,
 
-    // PORT NOTE: Ast.hashbang is `StoreStr`; mirror it here so init/to_ast can
+    // Ast.hashbang is `StoreStr`; mirror it here so init/to_ast can
     // round-trip.
     pub hashbang: StoreStr,
     pub parts: part::List<'arena>,
-    // Zig: `?*bun.css.BundlerStyleSheet`. See `CssAstRef` doc for the arena
-    // drop-order invariant that backs the safe `Deref`.
+    // See `CssAstRef` doc for the arena drop-order invariant that backs the
+    // safe `Deref`.
     pub css: CssCol,
     pub url_for_css: &'arena [u8],
     pub symbols: symbol::List<'arena>,
     pub module_scope: Scope,
-    // TODO(port): Zig used `= undefined`; only valid when flags.HAS_CHAR_FREQ is set.
+    // Only meaningful when flags.HAS_CHAR_FREQ is set; zero-initialized otherwise.
     pub char_freq: CharFreq,
     pub exports_ref: Ref,
     pub module_ref: Ref,
@@ -141,7 +137,7 @@ bitflags::bitflags! {
         // closure.
         const USES_EXPORTS_REF = 1 << 0;
         const USES_MODULE_REF = 1 << 1;
-        // const USES_REQUIRE_REF = 1 << 2; (commented out in Zig; bit positions still match field order)
+        // const USES_REQUIRE_REF = 1 << 2;
         const USES_EXPORT_KEYWORD = 1 << 2;
         const HAS_CHAR_FREQ = 1 << 3;
         const FORCE_CJS_TO_ESM = 1 << 4;
@@ -154,10 +150,9 @@ bitflags::bitflags! {
 }
 
 impl<'arena> BundledAst<'arena> {
-    // Zig: `pub const empty = BundledAst.init(Ast.empty)` (comptime). The three `ArenaVec`
-    // fields prevent `const fn` here, but spell out the defaults directly instead of
-    // round-tripping through `Ast::empty_in` + `init` — this runs once per discovered
-    // module on the main thread.
+    // The three `ArenaVec` fields prevent `const fn` here, but spell out the
+    // defaults directly instead of round-tripping through `Ast::empty_in` +
+    // `init` — this runs once per discovered module on the main thread.
     pub fn empty_in(arena: &'arena bun_alloc::Arena) -> Self {
         Self {
             approximate_newline_count: 0,
@@ -189,9 +184,8 @@ impl<'arena> BundledAst<'arena> {
         }
     }
 
-    // PORT NOTE: Zig's `*const BundledAst` bitwise-copies every field; the Rust
-    // collection types aren't Copy, so consume `self` to move them (toAST is a
-    // one-shot conversion back to the fat Ast).
+    // The collection types aren't Copy, so consume `self` to move them (to_ast
+    // is a one-shot conversion back to the fat Ast).
     pub fn to_ast(self) -> Ast<'arena> {
         let arena: &'arena bun_alloc::Arena = *self.parts.allocator();
         Ast {
@@ -303,7 +297,7 @@ impl<'arena> BundledAst<'arena> {
             // This list may be mutated later, so we should store the capacity
             symbols: ast.symbols,
             module_scope: ast.module_scope,
-            // Only read when flags.HAS_CHAR_FREQ is set; Zig used `orelse undefined`.
+            // Only read when flags.HAS_CHAR_FREQ is set.
             char_freq: ast.char_freq.unwrap_or_default(),
             exports_ref: ast.exports_ref,
             module_ref: ast.module_ref,
@@ -368,10 +362,9 @@ impl<'arena> BundledAst<'arena> {
                 let encode_len = bun_base64::encode_len(contents);
                 let data_url_prefix_len = b"data:".len() + mime_type.len() + b";base64,".len();
                 let total_buffer_len = data_url_prefix_len + encode_len;
-                // PERF(port): was arena alloc via `arena.alloc(u8, n)`; using bumpalo here.
                 let encoded: &mut [u8] = bump.alloc_slice_fill_copy(total_buffer_len, 0u8);
-                // PORT NOTE: Zig's std.fmt.bufPrint with `{s}` writes raw bytes; BStr's Display
-                // would emit 3-byte U+FFFD for non-UTF-8 input and overflow the fixed prefix slice.
+                // Write raw bytes directly; BStr's Display would emit 3-byte
+                // U+FFFD for non-UTF-8 input and overflow the fixed prefix slice.
                 encoded[..5].copy_from_slice(b"data:");
                 encoded[5..5 + mime_type.len()].copy_from_slice(mime_type);
                 encoded[5 + mime_type.len()..data_url_prefix_len].copy_from_slice(b";base64,");
@@ -381,5 +374,3 @@ impl<'arena> BundledAst<'arena> {
         }
     }
 }
-
-// ported from: src/js_parser/ast/BundledAst.zig
diff --git a/src/bundler/cache.rs b/src/bundler/cache.rs
index a75ff3c8dd0..aee00128dd5 100644
--- a/src/bundler/cache.rs
+++ b/src/bundler/cache.rs
@@ -25,21 +25,20 @@ use js_parser::defines::Define;
 use bun_ast::RuntimeTranspilerCache;
 
 /// Bump when the cache wire format or parser output changes. Mirrors
-/// `expected_version` in src/jsc/RuntimeTranspilerCache.zig.
+/// `EXPECTED_VERSION` in src/jsc/RuntimeTranspilerCache.rs.
 pub const RUNTIME_TRANSPILER_CACHE_VERSION: u32 = 20;
 
-/// Mirrors the Zig `pub var is_disabled` mutable global — written by T6
-/// (src/runtime/cli/Arguments.zig:1603, src/jsc/VirtualMachine.zig:1383) and
-/// flipped lazily on cache-dir resolution failure. Module-level so those
-/// writers can reach it; `disabled()` reads it.
+/// Written by CLI argument parsing and `VirtualMachine` init, and flipped
+/// lazily on cache-dir resolution failure. Module-level so those writers can
+/// reach it; `disabled()` reads it.
 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
 /// this crate without an orphan-rule violation.
 pub trait RuntimeTranspilerCacheExt {
-    /// Mirrors the Zig `pub var is_disabled` namespaced const — kept as an
-    /// associated fn so call-sites read `RuntimeTranspilerCache::disabled()`.
+    /// Kept as an associated fn so call-sites read
+    /// `RuntimeTranspilerCache::disabled()`.
     fn disabled() -> bool;
     fn set_disabled(v: bool);
 }
@@ -60,12 +59,10 @@ impl RuntimeTranspilerCacheExt for RuntimeTranspilerCache {
     }
 }
 
-/// Mirrors `RuntimeTranspilerCache.Encoding` (RuntimeTranspilerCache.zig:405).
-///
-/// PORT NOTE: this is the on-disk wire enum for `Metadata.output_encoding` —
+/// This is the on-disk wire enum for `Metadata.output_encoding` —
 /// NOT `js_parser::ExportsKind` (an unrelated `#[repr(u8)]` enum that happens
 /// to start at 0). The bundler-side cache loader maps `Latin1`/`Utf16` blobs
-/// into a `bun.String` (RuntimeTranspilerCache.zig:310-318) and only feeds
+/// into a `bun.String` and only feeds
 /// `Utf8` through `cloneUTF8`; callers must dispatch on these discriminants.
 #[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -77,9 +74,7 @@ pub enum CacheEncoding {
     Latin1 = 3,
 }
 
-/// Mirrors `RuntimeTranspilerCache.ModuleType` (RuntimeTranspilerCache.zig:399).
-///
-/// PORT NOTE: NOT `options::ModuleType` — the on-disk wire enum has `Esm`/`Cjs`
+/// On-disk wire enum — NOT `options::ModuleType`: it has `Esm`/`Cjs`
 /// **swapped** relative to the in-memory parser/options enum (`Unknown=0,
 /// Cjs=1, Esm=2`). Comparing `metadata.module_type` against
 /// `options::ModuleType::Cjs as u8` would test for `.esm`.
@@ -124,8 +119,8 @@ pub struct RuntimeTranspilerCacheMetadata {
 }
 
 impl Default for RuntimeTranspilerCacheMetadata {
-    /// Spec (src/jsc/RuntimeTranspilerCache.zig:42) defaults
-    /// `cache_version: u32 = expected_version` — derived `Default` would zero it,
+    /// The wire format defaults `cache_version` to the expected version —
+    /// derived `Default` would zero it,
     /// causing every freshly-written entry to be rejected as `error.StaleCache`
     /// on first read.
     fn default() -> Self {
@@ -156,9 +151,8 @@ pub struct Set {
 }
 
 impl Set {
-    /// Port of `Set.init` (cache.zig:6). PORT NOTE: `arena` is unused —
-    /// `MutableString::init`/`JavaScript::init` source from the global heap in
-    /// the Rust port; param kept so callers match the Zig signature
+    /// `arena` is unused — `MutableString::init`/`JavaScript::init` source
+    /// from the global heap; param kept for caller compatibility
     /// (`crate::cache::Set::init(alloc)`).
     pub fn init(_arena: &Bump) -> Set {
         Set {
@@ -206,8 +200,7 @@ impl Default for Fs {
 // ══════════════════════════════════════════════════════════════════════════
 pub use bun_resolver::cache::{Contents, Entry, ExternalFreeFunction};
 
-/// Legacy alias — several call sites import `crate::cache::CacheEntry`
-/// (mirrors Zig's `bun.transpiler.cache.Fs.Entry` qualified name).
+/// Legacy alias — several call sites import `crate::cache::CacheEntry`.
 pub type CacheEntry = Entry;
 
 impl Fs {
@@ -225,9 +218,9 @@ impl Fs {
     /// When we need to suspend/resume something that has pointers into the shared buffer, we need to
     /// switch out the shared buffer so that it is not in use.
     ///
-    /// Ownership transfer: in Zig (cache.zig:77/79) the field is overwritten WITHOUT freeing
-    /// the old buffer, because the suspended parse keeps pointers into it (see ModuleLoader.zig:488,
-    /// "this shared buffer is about to become owned by the AsyncModule struct"). In Rust, plain
+    /// Ownership transfer: the old buffer must NOT be freed here, because the
+    /// suspended parse keeps pointers into it (the shared buffer becomes owned
+    /// by the AsyncModule struct in the module loader). Plain
     /// field assignment would drop+free the old buffer → use-after-free on resume. So we return
     /// the detached buffer; the caller MUST take ownership of it and keep it alive for as long as
     /// `parse_result.source.contents` may be read.
@@ -241,9 +234,8 @@ impl Fs {
         }
     }
 
-    // TODO(port): Zig `Fs.deinit` references `c.entries` which is not a field on `Fs` —
-    // dead code (Zig lazy compilation never instantiated it). No Drop impl needed beyond
-    // the auto-drop of `shared_buffer` / `macro_shared_buffer`.
+    // No Drop impl needed beyond the auto-drop of `shared_buffer` /
+    // `macro_shared_buffer`.
 }
 
 // File reads route through the canonical `bun_resolver::fs::read_file_contents`
@@ -323,24 +315,20 @@ impl Fs {
         self.read_file_with_allocator(_fs, path, dirname_fd, use_shared_buffer, _file_handle, None)
     }
 
-    /// Port of `Fs.readFileWithAllocator` (cache.zig:146).
-    ///
-    /// PORT NOTE: `comptime use_shared_buffer` is taken at runtime — the live
+    /// `use_shared_buffer` is taken at runtime — the live
     /// callers (`ParseTask::get_code_for_parse_task_without_plugins`,
     /// `Transpiler::parse`) pass a value computed from runtime state, and the
     /// resolver's `FsCache` forward-decl already pinned this shape.
-    /// PERF(port): re-monomorphize once both callers stabilize.
+    /// PERF: re-monomorphize once both callers stabilize.
     ///
-    /// `arena` restores the Zig `allocator` param: when
+    /// `arena`: when
     /// `!use_shared_buffer && arena.is_some()` the file body is read straight
     /// into `arena` (`Contents::Arena`), so the bytes are bulk-freed by
     /// `mi_heap_destroy` when the per-call `MimallocArena` (the per-job arena
     /// from `RuntimeTranspilerStore` / `ParseTask`) drops — instead of round-
     /// tripping through the worker thread's *default* mimalloc heap, which is
     /// never destroyed and retains the fresh page for the process lifetime.
-    /// `None` keeps the global-heap `Contents::Owned(Vec<u8>)` path. Zig:
-    /// `transpiler.zig:838-839` passed `if (use_shared_buffer)
-    /// bun.default_allocator else this_parse.allocator`.
+    /// `None` keeps the global-heap `Contents::Owned(Vec<u8>)` path.
     pub fn read_file_with_allocator(
         &mut self,
         _fs: &mut fs_mod::FileSystem,
@@ -352,9 +340,8 @@ impl Fs {
     ) -> Result<Entry, bun_core::Error> {
         let rfs = &_fs.fs;
 
-        // PORT NOTE: reshaped — Zig declared `file_handle = undefined` then assigned on each
-        // branch; restructured into a single let-expression to avoid `mem::zeroed()` on a
-        // type that may have niche (NonZero) fields.
+        // Single let-expression assigning `file_handle` on each branch, avoiding
+        // `mem::zeroed()` on a type that may have niche (NonZero) fields.
         let mut _owned: Option<bun_sys::File> = None;
         let will_close: bool;
         let fd: Fd = if let Some(f) = _file_handle {
@@ -405,13 +392,12 @@ impl Fs {
             fd
         );
 
-        // PORT NOTE: reshaped for borrowck — capture `stream` scalar before borrowing
+        // Borrowck: capture `stream` scalar before borrowing
         // the shared buffer.
         let stream = self.stream;
 
         let contents = match (use_shared_buffer, arena) {
-            // Zig: `readFileWithHandleAndAllocator(this_parse.allocator, …)` —
-            // read straight into the per-call arena so the source bytes are
+            // Read straight into the per-call arena so the source bytes are
             // reclaimed by `mi_heap_destroy` instead of pinning a fresh page in
             // the worker thread's default heap (one `mi_malloc` + `munmap` pair
             // per transpiled module → one bump allocation in a wholesale-reset
@@ -525,14 +511,13 @@ impl JavaScript {
         let result = match parser.parse() {
             Ok(r) => r,
             Err(err) => {
-                // PORT NOTE: `Parser::parse` consumes `self` (Zig took `*Parser`
-                // — by-ref — but the Rust port owns the inner `P` by value), so
-                // `parser` is gone in this arm. The `&'a mut temp_log` it held
-                // is released, so read `temp_log.errors` directly. The lexer
-                // range is lost; fall back to `Range::None` (Zig used
-                // `parser.lexer.range()`).
-                // TODO(port): thread the failing token range through the
-                // `Err` payload once `_parse` returns a `(Error, Range)` pair.
+                // `Parser::parse` consumes `self`, so `parser` is gone in this
+                // arm. The `&'a mut temp_log` it held is released, so read
+                // `temp_log.errors` directly. The lexer range is lost; fall
+                // back to `Range::None`.
+                // TODO: thread the failing token range through the `Err`
+                // payload (make `_parse` return a `(Error, Range)` pair) so the
+                // diagnostic points at the failing token.
                 if temp_log.errors == 0 {
                     log.add_range_error(Some(source), bun_ast::Range::None, err.name().as_bytes());
                 }
@@ -559,8 +544,8 @@ impl JavaScript {
         }
 
         let mut temp_log = bun_ast::Log::init();
-        // PORT NOTE: reshaped for borrowck — Zig `defer temp_log.appendToMaybeRecycled(log, source)`;
-        // scopeguard cannot capture &mut temp_log while it's used below. Explicit calls at each exit.
+        // scopeguard cannot capture &mut temp_log while it's used below;
+        // explicit `append_to_maybe_recycled` calls at each exit.
 
         let mut parser = match js_parser::Parser::init(opts, &mut temp_log, source, defines, bump) {
             Ok(p) => p,
@@ -581,5 +566,3 @@ impl JavaScript {
 // the resolver already depends on `bun_parsers::json_parser`, so the
 // vtable seam was redundant.
 pub use bun_resolver::tsconfig_json::{JsonCache as Json, JsonMode};
-
-// ported from: src/bundler/cache.zig
diff --git a/src/bundler/defines.rs b/src/bundler/defines.rs
index 125ec1ae115..5560bb3d7a3 100644
--- a/src/bundler/defines.rs
+++ b/src/bundler/defines.rs
@@ -25,14 +25,13 @@ pub use bun_js_parser::defines::{
     UserDefinesArray, are_parts_equal,
 };
 
-/// Alias for `Options` so `options.rs` can write `DefineData::init(DefineDataInit { .. })`
-/// (mirrors Zig's anonymous-struct init).
+/// Alias for `Options` so `options.rs` can write `DefineData::init(DefineDataInit { .. })`.
 pub type DefineDataInit<'a> = Options<'a>;
 /// Alias for `ExprData` so `options.rs` can write `DefineValue::EUndefined(..)`.
 pub(crate) use bun_ast::ExprData as DefineValue;
 
-// `Expr::Data` stores `Number`/`Undefined` inline (not via pointer), so the
-// `_PTR` indirection from Zig disappears.
+// `Expr::Data` stores `Number`/`Undefined` inline (not via pointer), so no
+// pointer indirection is needed for these constants.
 pub struct Globals;
 impl Globals {
     pub const UNDEFINED: bun_ast::E::Undefined = bun_ast::E::Undefined;
@@ -63,13 +62,12 @@ fn defines_path() -> FsPath<'static> {
     p
 }
 
-// Zig: `pub const Data = DefineData;` inside `Define`
 pub type Data = DefineData;
 
 // ══════════════════════════════════════════════════════════════════════════
 // `bun_dotenv::DefineStore` impls. dotenv (T2) calls through the link-interface
 // handle; bundler (T5) owns the concrete `E::String` + `DefineData` construction.
-// Mirrors src/dotenv/env_loader.zig:399 `copyForDefine` — `to_string` is a
+// `to_string` is a
 // `StringHashMap<DefineData>` (= UserDefines), `to_json` is a
 // `StringHashMap<Box<[u8]>>` (= RawDefines / framework defaults).
 // ══════════════════════════════════════════════════════════════════════════
@@ -80,10 +78,9 @@ fn env_string_store_put(
     key: &[u8],
     value: &[u8],
 ) -> Result<(), bun_core::Error> {
-    // Zig (env_loader.zig:461) allocates the `E.String` slab via the passed
-    // `allocator` (= `Transpiler.allocator`), NOT the thread-local
+    // The `E.String` slab must NOT live in the thread-local
     // `Expr.Data.Store` — `configureDefines` resets that store on return, so
-    // the env-define payloads must outlive it. Mirror with `bump` (the
+    // the env-define payloads must outlive it. Allocate from `bump` (the
     // transpiler arena) so the slab is bulk-freed with the `Define` table
     // instead of leaking a `Box` per env var. Value bytes alias the long-lived
     // env-map storage.
@@ -100,7 +97,7 @@ fn env_string_store_put(
     Ok(())
 }
 
-/// Port of `Loader.copyForDefine` (env_loader.zig:399). Moved up from
+/// Moved up from
 /// `bun_dotenv` so it can name `DefineData` / `E::String` directly instead of
 /// dispatching through a vtable — it only reads `loader.map.map.{keys,values}()`,
 /// all of which are public.
@@ -130,18 +127,16 @@ pub fn copy_env_for_define(
         }
     }
 
-    // PORT NOTE: Zig pre-counted `key_buf_len`/`e_strings_to_allocate` to size two bump
-    // allocations, then `iter.reset()` and re-walked. With per-entry copies the pre-sizing
-    // pass is dead — emit directly. PERF(port): was single-buffer key arena; now per-entry Vec reuse.
+    // With per-entry copies no pre-sizing
+    // pass is needed — emit directly. PERF: was single-buffer key arena; now per-entry Vec reuse.
     if behavior != DotEnvBehavior::Disable && behavior != DotEnvBehavior::LoadAllWithoutInlining {
         if behavior == DotEnvBehavior::Prefix {
             debug_assert!(!prefix.is_empty());
         }
 
-        // PORT NOTE: Zig's `if (key_buf_len > 0)` gate (env_loader.zig:455) is behavioral,
-        // not just a sizing optimization — when `behavior == .prefix` and NO env key starts
+        // When `behavior == .prefix` and NO env key starts
         // with `prefix`, the entire second walk (including the framework-hash `else` arm)
-        // is skipped. Mirror that by pre-scanning for a prefix match before emitting.
+        // must be skipped. Pre-scan for a prefix match before emitting.
         let any_prefix_match = if behavior == DotEnvBehavior::Prefix {
             env.map
                 .map
@@ -154,7 +149,7 @@ pub fn copy_env_for_define(
 
         if any_prefix_match {
             let mut key_buf: Vec<u8> = Vec::new();
-            // PORT NOTE: borrowck — iterate parallel slices instead of `iterator()` so the
+            // borrowck — iterate parallel slices instead of `iterator()` so the
             // map borrow stays shared while we write into the define stores.
             let keys = env.map.map.keys();
             let values = env.map.map.values();
@@ -232,17 +227,15 @@ impl DefineExt for Define {
     ) -> Result<(), bun_alloc::AllocError> {
         let key = global[global.len() - 1];
         let parts: Vec<Box<[u8]>> = global.iter().map(|p| Box::<[u8]>::from(*p)).collect();
-        // PORT NOTE: reshaped for borrowck — getOrPut split into entry-style match.
+        // reshaped for borrowck — getOrPut split into entry-style match.
         if let Some(existing) = self.dots.get_mut(key) {
             let mut list: Vec<DotDefine> = Vec::with_capacity(existing.len() + 1);
-            // PERF(port): was appendSliceAssumeCapacity — profile if hot.
             list.extend_from_slice(existing);
-            // PERF(port): was appendAssumeCapacity — profile if hot.
             list.push(DotDefine {
                 parts,
                 data: value_define.clone(),
             });
-            // Zig: define.arena.free(gpe.value_ptr.*); — handled by Vec drop on assign
+            // The old value is freed by Vec drop on assign.
             *existing = list;
         } else {
             let list: Vec<DotDefine> = vec![DotDefine {
@@ -390,7 +383,6 @@ impl DefineDataExt for DefineData {
         log: &mut bun_ast::Log,
         bump: &bun_alloc::Arena,
     ) -> Result<(), bun_core::Error> {
-        // PERF(port): was putAssumeCapacity — profile if hot.
         user_defines.put_assume_capacity(
             key,
             <Self as DefineDataExt>::parse(
@@ -413,7 +405,6 @@ impl DefineDataExt for DefineData {
         log: &mut bun_ast::Log,
         bump: &bun_alloc::Arena,
     ) -> Result<DefineData, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut key_splitter = key.split(|b| *b == b'.');
         while let Some(part) = key_splitter.next() {
             if !js_lexer::is_identifier(part) {
@@ -465,9 +456,9 @@ impl DefineDataExt for DefineData {
 
             return Ok(DefineData {
                 value,
-                // PORT NOTE: upstream `DefineData` now owns `original_name:
-                // Option<Box<[u8]>>` (js_parser/lib.rs:1369) instead of the
-                // borrowed `ptr`/`len` pair (Zig's 48→40-byte packing). Dupe
+                // upstream `DefineData` now owns `original_name:
+                // Option<Box<[u8]>>` (js_parser/lib.rs:1369) instead of a
+                // borrowed `ptr`/`len` pair. Dupe
                 // the value bytes — these are tiny startup-time copies.
                 original_name: if !value_str.is_empty() {
                     Some(Box::<[u8]>::from(value_str))
@@ -512,8 +503,7 @@ impl DefineDataExt for DefineData {
             });
         }
 
-        // Zig parsed against a stack-local `Source` then `Expr.Data.deepClone`d
-        // into the arena. We dupe `value_str` into `bump` first so every string
+        // We dupe `value_str` into `bump` first so every string
         // slice the JSON lexer hands back already points into the long-lived
         // arena (the `E::String.data` bytes survive without per-string dup).
         //
@@ -570,7 +560,7 @@ impl DefineDataExt for DefineData {
         bump: &bun_alloc::Arena,
     ) -> Result<UserDefines, bun_core::Error> {
         let mut user_defines = UserDefines::default();
-        user_defines.reserve((defines.len() + drop.len()) as u32 as usize); // @truncate
+        user_defines.reserve((defines.len() + drop.len()) as u32 as usize);
         for (key, value) in defines.keys().iter().zip(defines.values().iter()) {
             <Self as DefineDataExt>::from_mergeable_input_entry(
                 &mut user_defines,
@@ -601,8 +591,5 @@ impl DefineDataExt for DefineData {
     }
 }
 
-// Zig `deinit` freed `dots` values, cleared maps, and destroyed `self`.
-// In Rust: `dots: StringHashMap<Vec<DotDefine>>` and `identifiers` drop their
+// `dots: StringHashMap<Vec<DotDefine>>` and `identifiers` drop their
 // contents automatically; `Box<Define>` frees `self`. No explicit Drop needed.
-
-// ported from: src/bundler/defines.zig
diff --git a/src/bundler/entry_points.rs b/src/bundler/entry_points.rs
index d345e0d9d67..01d1c7581da 100644
--- a/src/bundler/entry_points.rs
+++ b/src/bundler/entry_points.rs
@@ -10,7 +10,7 @@ use bun_wyhash::{self, Wyhash11};
 use crate::Transpiler;
 use bun_js_parser as js_ast;
 
-// PORT NOTE: `Path`/`PathName` come from the lower-tier `bun_paths::fs` shim
+// `Path`/`PathName` come from the lower-tier `bun_paths::fs` shim
 // (lifetime-erased `'static` slices) so `bun_ast::Source` field types line up;
 // `FileSystem` is the real `bun_resolver::fs` singleton now that
 // `bun_resolver` is in this crate's dep set.
@@ -39,17 +39,12 @@ impl Default for FallbackEntryPoint {
 }
 
 impl FallbackEntryPoint {
-    // TODO(port): crate::options::Framework / ClientCssInJs — `options`
-    // module is still gated; body also touched `bun_resolver::fs` (see
-    // PORTING.md §Forbidden) before un-gating.
     pub fn generate<TranspilerType>(
         entry: &mut FallbackEntryPoint,
         input_path: &[u8],
         transpiler: &mut TranspilerType,
     ) -> Result<(), bun_core::Error>
-    // TODO(port): narrow error set
     where
-        // TODO(port): TranspilerType trait bound — body reads `.options.framework` and `.arena`.
         TranspilerType: TranspilerLike,
     {
         // This is *extremely* naive.
@@ -70,26 +65,23 @@ impl FallbackEntryPoint {
             .client_css_in_js
             != ClientCssInJs::AutoOnImportCss;
 
-        // PORT NOTE: self-referential — when the rendered code fits in
+        // self-referential — when the rendered code fits in
         // `entry.code_buffer` the Source borrows it (disjoint-field write to
         // `entry.source` while `entry.code_buffer` is shared-borrowed). On
-        // overflow the Source owns the bytes via `Cow::Owned` (Zig allocated
-        // from `transpiler.arena`; here the Source owns it directly so Drop
+        // overflow the Source owns the bytes via `Cow::Owned` (so Drop
         // frees it).
-        // PORT NOTE: assemble bytes directly (not `write!`+`BStr`) so a
-        // non-UTF-8 byte in `input_path` is emitted verbatim like Zig `{s}`,
+        // assemble bytes directly (not `write!`+`BStr`) so a
+        // non-UTF-8 byte in `input_path` is emitted verbatim,
         // not lossily replaced with U+FFFD by `BStr as Display`.
         macro_rules! render_into_entry {
             ($prefix:expr, $suffix:expr) => {{
                 let prefix: &[u8] = $prefix;
                 let suffix: &[u8] = $suffix;
-                // PERF(port): was std.fmt.count + bufPrint/allocPrint stack-fallback — profile if hot.
                 let count = prefix.len() + input_path.len() + suffix.len();
                 if count < entry.code_buffer.len() {
                     let buf = &mut entry.code_buffer;
                     buf[..prefix.len()].copy_from_slice(prefix);
-                    buf[prefix.len()..prefix.len() + input_path.len()]
-                        .copy_from_slice(input_path);
+                    buf[prefix.len()..prefix.len() + input_path.len()].copy_from_slice(input_path);
                     buf[prefix.len() + input_path.len()..count].copy_from_slice(suffix);
                     entry.source =
                         bun_ast::Source::init_path_string(input_path, &entry.code_buffer[..count]);
@@ -138,7 +130,7 @@ impl ClientEntryPoint {
         strings::starts_with(b"entry.", extname)
     }
 
-    // PORT NOTE: takes the lifetime-generic `bun_paths::fs::PathName<'_>` (not the
+    // takes the lifetime-generic `bun_paths::fs::PathName<'_>` (not the
     // `'static`-field `bun_paths::fs::PathName<'static>`) so callers with a borrowed path
     // (e.g. `bun_runtime::filesystem_router::get_script_src_string`) needn't forge
     // `'static`. The body only copies `dir`/`base`/`ext` into `outbuffer`.
@@ -151,7 +143,7 @@ impl ClientEntryPoint {
         let mut generated_path =
             Fs::FileSystem::get().abs_buf(&joined_base_and_dir_parts, outbuffer);
 
-        // PORT NOTE: reshaped for borrowck — capture len, drop borrow, re-borrow outbuffer.
+        // reshaped for borrowck — capture len, drop borrow, re-borrow outbuffer.
         let mut len = generated_path.len();
         outbuffer[len..len + b".entry".len()].copy_from_slice(b".entry");
         len += b".entry".len();
@@ -185,9 +177,7 @@ impl ClientEntryPoint {
         original_path: &Fs::PathName,
         client: &[u8],
     ) -> Result<(), bun_core::Error>
-    // TODO(port): narrow error set
     where
-        // TODO(port): TranspilerType trait bound — body reads `.options.framework`.
         TranspilerType: TranspilerLike,
     {
         let entry = self;
@@ -210,8 +200,10 @@ impl ClientEntryPoint {
             .client_css_in_js
             != ClientCssInJs::AutoOnImportCss;
 
-        // TODO(port): self-referential — `code` borrows `entry.code_buffer` and is stored into
-        // `entry.source`. See note in FallbackEntryPoint::generate.
+        // INVARIANT: self-referential — `code` borrows `entry.code_buffer` and is
+        // stored into `entry.source` (lifetime erased), so `entry` must not move
+        // or drop while `entry.source` is in use. See note in
+        // FallbackEntryPoint::generate.
         let code: &[u8] = if disable_css_imports {
             let mut cursor = std::io::Cursor::new(&mut entry.code_buffer[..]);
             write!(
@@ -279,7 +271,6 @@ impl ServerEntryPoint {
         is_hot_reload_enabled: bool,
         path_to_use: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Use the global arena so this buffer's lifetime is decoupled
         // from whichever arena the caller's VM happens to be using; the
         // slice is read later from `getHardcodedModule` which outlives any
@@ -352,7 +343,7 @@ impl ServerEntryPoint {
         };
 
         // Free the previous buffer on regenerate (hot reload) instead of
-        // leaking it. `contents` is either "" or a prior allocPrint result.
+        // leaking it. `contents` is either "" or a previously generated buffer.
         // (Handled implicitly: assigning to `Box<[u8]>` drops the old one.)
         entry.contents = code.into_boxed_slice();
         entry.generated = true;
@@ -395,7 +386,7 @@ impl MacroEntryPoint {
         let hash = hasher.final_();
         let fmt = bun_fmt::hex_int_lower::<16>(hash);
 
-        // PORT NOTE: reshaped for borrowck — capture cursor position, drop &mut
+        // reshaped for borrowck — capture cursor position, drop &mut
         // borrow, then re-borrow `buf` immutably.
         let n = {
             let mut cursor = std::io::Cursor::new(&mut buf[..]);
@@ -415,12 +406,10 @@ impl MacroEntryPoint {
     }
 
     pub fn generate_id_from_specifier(specifier: &[u8]) -> i32 {
-        // Same-size bitcast u32 → i32 (matches Zig `@bitCast`).
+        // Same-size bitcast u32 → i32.
         (bun_wyhash::hash(specifier) as u32) as i32
     }
 
-    // TODO(port): bun_ast::Macro + bun_resolver::fs::PathName —
-    // see `generate_id`.
     pub fn generate(
         entry: &mut MacroEntryPoint,
         _: &mut Transpiler,
@@ -429,13 +418,12 @@ impl MacroEntryPoint {
         macro_id: i32,
         macro_label_: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let dir_to_use: &[u8] = if import_path.dir.is_empty() {
             b""
         } else {
             import_path.dir_with_trailing_slash()
         };
-        // PORT NOTE: reshaped for borrowck — capture the label length, write the
+        // reshaped for borrowck — capture the label length, write the
         // body via a scoped &mut borrow, then re-borrow `code_buffer` immutably
         // for the (label, code) slices passed to `init_path_string`.
         let label_len = macro_label_.len();
@@ -521,9 +509,10 @@ impl MacroEntryPoint {
             cursor.position() as usize
         };
 
-        // TODO(port): self-referential — `macro_label`/`code` borrow `entry.code_buffer`
-        // and are stored into `entry.source` (lifetime erased via `IntoStr`); restructure
-        // so Source owns its bytes (or use a raw-ptr slice).
+        // INVARIANT: self-referential — `macro_label`/`code` borrow
+        // `entry.code_buffer` and are stored into `entry.source` (lifetime erased
+        // via `IntoStr`), so `entry` must not move or drop while `entry.source`
+        // is in use.
         let macro_label: &[u8] = &entry.code_buffer[..label_len];
         let code: &[u8] = &entry.code_buffer[label_len..label_len + code_len];
         entry.source = bun_ast::Source::init_path_string(macro_label, code);
@@ -533,13 +522,10 @@ impl MacroEntryPoint {
     }
 }
 
-// TODO(port): `TranspilerLike` is a placeholder for the duck-typed
-// `comptime TranspilerType: type` param used by FallbackEntryPoint/ClientEntryPoint.
-// Replace with the concrete `Transpiler` type or a real trait.
+// Trait abstraction over the transpiler types used by
+// FallbackEntryPoint/ClientEntryPoint.
 pub trait TranspilerLike {
     fn options(&self) -> &crate::options::Options<'_>;
 }
 
 use crate::options::ClientCssInJs;
-
-// ported from: src/bundler/entry_points.zig
diff --git a/src/bundler/lib.rs b/src/bundler/lib.rs
index 49775a49070..b724ef145fd 100644
--- a/src/bundler/lib.rs
+++ b/src/bundler/lib.rs
@@ -1,6 +1,6 @@
 #![feature(inherent_associated_types)]
 #![feature(adt_const_params, allocator_api, thread_local)]
-#![allow(incomplete_features)] // inherent_associated_types — used only for ThreadPool::Worker path compat with Zig
+#![allow(incomplete_features)] // inherent_associated_types — used only for the ThreadPool::Worker path
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 #![warn(unused_must_use)]
 
@@ -110,14 +110,11 @@ pub mod options_impl;
 pub mod parse_task;
 pub mod transpiler;
 
-/// `linker_context/` submodule directory. Declared inline (no `mod.rs`) so
-/// paths stay 1:1 with the Zig directory.
+/// `linker_context/` submodule directory. Declared inline (no `mod.rs`).
 pub mod linker_context {
     #[path = "scanImportsAndExports.rs"]
     pub mod scan_imports_and_exports;
 
-    // Each module maps 1:1 to a `.zig` of the same basename.
-
     #[path = "computeChunks.rs"]
     pub mod compute_chunks;
 
@@ -188,7 +185,7 @@ pub mod linker_context {
     pub mod static_route_visitor;
 
     // ── Re-exports so `crate::linker_context::{debug, LinkerContext, …}`
-    //    resolves at every submodule call-site (mirrors Zig's `@import("./LinkerContext.zig")`).
+    //    resolves at every submodule call-site.
     pub use crate::linker_context_mod::{
         ChunkMeta, GenerateChunkCtx, LinkerContext, PendingPartRange,
     };
@@ -226,14 +223,12 @@ pub use parse_task::ParseTask;
 pub use thread_pool::{ThreadPool, Worker};
 /// See `transpiler`.
 pub use transpiler::Transpiler;
-/// `bundle_v2.zig:AdditionalFile`.
 pub enum AdditionalFile {
     SourceIndex(u32),
     OutputFile(u32),
 }
 
-/// `bun.ast.Index` — source-index newtype. Re-exported here because every
-/// `*.zig` in this crate aliases it as `pub const Index = bun.ast.Index`.
+/// `bun_ast::Index` — source-index newtype, re-exported for crate-wide use.
 pub(crate) use bun_ast::{Index, IndexInt};
 
 // Re-export the `options` module. `Loader`/`Target` live in
@@ -246,7 +241,7 @@ pub mod options {
     pub use super::options_impl::*;
     pub use super::output_file::BakeExtra;
     pub use super::output_file::IndexOptional;
-    /// `OutputFile.init` argument struct (`options.zig:OutputFile.Options`).
+    /// `OutputFile.init` argument struct.
     pub use super::output_file::Options as OutputFileInit;
     pub use super::output_file::OptionsData as OutputFileData;
     pub use super::output_file::Value as OutputValue;
@@ -256,8 +251,7 @@ pub mod options {
     pub use bun_options_types::schema::api::DotEnvBehavior as EnvBehavior;
     pub type Options<'a> = super::BundleOptions<'a>;
 
-    /// `jsc.API.BuildArtifact.OutputKind` (JSBundler.zig:1799). Re-exported by
-    /// `options.zig` callers via `OutputFile.output_kind`.
+    /// Output kind of a build artifact (`OutputFile.output_kind`).
     ///
     /// `IntoStaticStr` provides the JS-facing tag (`"entry-point"` etc.) so
     /// `bun_runtime::api::BuildArtifact` can spell `<&str>::from(kind)` without
@@ -285,7 +279,6 @@ pub mod options {
     }
 
     impl OutputKind {
-        /// JSBundler.zig:1809.
         pub fn is_file_in_standalone_mode(self) -> bool {
             !matches!(
                 self,
@@ -298,12 +291,12 @@ pub mod options {
         }
     }
 
-    /// `bun.bake.Side` (bake.zig:874) — which graph an output belongs to.
+    /// Which graph an output belongs to.
     /// Re-export of the canonical def in `crate::bake_types` (bundle_v2.rs).
     pub use crate::bake_types::Side;
 
-    /// Legacy `options::Framework` (referenced by `resolver/package_json.zig`'s
-    /// `FrameworkRouterPair`). The full struct is `bun.bake.Framework` which
+    /// Legacy `options::Framework` (referenced by the resolver's
+    /// `FrameworkRouterPair`). The full struct is `bake::Framework` which
     /// lives in a higher-tier crate; minimal real struct lives in `bake_types`.
     pub use crate::bake_types::Framework;
 
@@ -313,7 +306,7 @@ pub mod options {
     // inline shadows produced 4+ incompatible `jsx::Pragma`/`Runtime` types and
     // a `&'static [&'static [u8]]` `factory`/`fragment` that could not hold the
     // heap allocation from `member_list_to_components_if_different`
-    // (options.zig:1296) without `Box::leak` (PORTING.md §Forbidden patterns).
+    // without `Box::leak`.
 }
 
 /// Re-export so `crate::RuntimeTranspilerCache` resolves for `transpiler::ParseOptions`
@@ -340,9 +333,8 @@ pub use bundle_v2::dispatch;
 // ── link-interfaces (must be at crate root so `$crate::__alias` resolves) ──
 // Re-exported through `bundle_v2::dispatch` for existing call sites.
 
-// Erased handle to `bake::DevServer`. PORT NOTE: Zig takes
-// `*const DevServerOutput` but mutates through the `chunks: []Chunk` slice it
-// holds; in Rust the struct stores `&'a mut [Chunk]`, hence `*mut`.
+// Erased handle to `bake::DevServer`. The struct stores a `&'a mut [Chunk]`
+// it mutates through, hence `*mut`.
 bun_dispatch::link_interface! {
     pub DevServerHandle[Bake] {
         fn barrel_needed_exports() -> *mut bun_collections::StringArrayHashMap<bun_collections::StringHashMap<()>>;
@@ -387,8 +379,7 @@ bun_dispatch::link_interface! {
     }
 }
 
-// `OutputFile.Options` defaults (`options.zig:OutputFile.Options` field
-// default-initializers). Kept here rather than in `OutputFile.rs` so the
+// `OutputFile.Options` field defaults. Kept here rather than in `OutputFile.rs` so the
 // derive-free struct stays codegen-friendly while every `init(..)` call site
 // can use struct-update syntax.
 impl Default for output_file::OptionsData {
diff --git a/src/bundler/linker.rs b/src/bundler/linker.rs
index 20c38df88bf..bbbe993f92b 100644
--- a/src/bundler/linker.rs
+++ b/src/bundler/linker.rs
@@ -1,6 +1,4 @@
 // This file is the old linker, used by Bun.Transpiler.
-//
-// Port of `src/bundler/linker.zig`.
 
 use std::io::Write as _;
 
@@ -8,10 +6,10 @@ use bun_ast::Log;
 use bun_ast::{ImportKind, ImportRecord, ImportRecordFlags, ImportRecordTag};
 use bun_collections::HashMap;
 use bun_paths::{self, SEP};
-// PORT NOTE: two `fs` shapes are in play here. `bun_resolver::fs` (`Fs`) holds
+// 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
+// B-3 collapses them. Until then, construct
 // `import_record.path` via `PFs::Path` so the field assignment unifies.
 use bun_core::strings;
 use bun_paths::fs as PFs;
@@ -35,20 +33,19 @@ bun_core::named_error_set!(CSSResolveError);
 
 type HashedFileNameMap = HashMap<u64, &'static [u8]>;
 
-// PORT NOTE: `_transpiler.Transpiler.isCacheEnabled` is gated in the draft body
-// (`transpiler.rs:1111`). The Zig value is a hard `false` (`const isCacheEnabled
-// = false;`); inline it here so `get_hashed_filename` compiles without depending
+// `_transpiler.Transpiler.isCacheEnabled` is gated in the draft body
+// (`transpiler.rs:1111`). The value is a hard `false`;
+// inline it here so `get_hashed_filename` compiles without depending
 // on the gated `Transpiler` impl.
 const IS_CACHE_ENABLED: bool = false;
 
 pub struct Linker {
     // arena field dropped — global mimalloc (callers pass `bun.default_allocator`)
-    // PORT NOTE: Zig stored borrowed `*BundleOptions` / `*Log` / `*Resolver` /
-    // `*ResolveQueue` / `*ResolveResults` / `*FileSystem`. The un-gated
-    // `Transpiler` struct owns those values directly and also owns `linker:
-    // crate::Linker` by value, so storing Rust references here would alias
+    // The un-gated
+    // `Transpiler` struct owns these values directly and also owns `linker:
+    // crate::Linker` by value, so storing references here would alias
     // `&mut self` on every `transpiler.linker.link(...)` call. Use raw
-    // pointers (matching Zig's `*T`) and dereference at use-site; same
+    // pointers and dereference at use-site; same
     // contract as `transpiler::set_log`'s `linker.log = log as *mut _`.
     pub options: *mut BundleOptions<'static>,
     pub fs: *mut Fs::FileSystem,
@@ -77,12 +74,9 @@ pub struct TaggedResolution {
 }
 
 // ── relative_paths_list singleton ────────────────────────────────────────
-// Zig: `const ImportPathsList = allocators.BSSStringList(512, 128);
-//        pub var relative_paths_list: *ImportPathsList = undefined;`
-//
-// `bun_alloc::BSSStringList<COUNT, ITEM_LENGTH>` encodes the Zig generics as
+// `bun_alloc::BSSStringList<COUNT, ITEM_LENGTH>` encodes the parameters as
 // `COUNT = _COUNT * 2`, `ITEM_LENGTH = _ITEM_LENGTH + 1` (see `bun_alloc/lib.rs`).
-// PORT NOTE: `bss_string_list!` would be the canonical declare-site macro but
+// `bss_string_list!` would be the canonical declare-site macro but
 // expands to `core::cell::SyncUnsafeCell`, and `bun_bundler` does not (yet)
 // enable `#![feature(sync_unsafe_cell)]`. Use the heap-allocating `init()`
 // fallback under a `LazyLock` instead — same lifetime semantics
@@ -94,7 +88,7 @@ pub(crate) type ImportPathsList = bun_alloc::BSSStringList<{ 512 * 2 }, { 128 +
 /// it can sit inside a `LazyLock`. The underlying list serializes its own
 /// mutation through an internal `Mutex` (see `BSSStringList::append`), so
 /// sharing the raw pointer across threads is sound; the `&mut self` receiver
-/// on `append` is a Zig-port artifact, not an exclusivity requirement.
+/// on `append` is not an exclusivity requirement.
 struct ImportPathsListPtr(core::ptr::NonNull<ImportPathsList>);
 // SAFETY: `BSSStringList` guards every mutating method with `self.mutex`, and
 // the allocation is process-lifetime (never freed). The pointer is therefore
@@ -146,8 +140,7 @@ mod hardcoded_module {
 /// Intern a byte buffer into the process-lifetime `relative_paths_list`
 /// `BSSStringList` singleton.
 ///
-/// Zig used `linker.arena.dupe(u8, ...)` / `allocPrint` with
-/// `bun.default_allocator` and never frees the result — the linker is a
+/// The linker is a
 /// per-transpile singleton whose output paths flow into `ImportRecord.path:
 /// Path<'static>`. PORTING.md §Forbidden bans `Vec::leak`/`Box::leak` for
 /// fabricating `&'static [u8]`; route through the `relative_paths_list`
@@ -271,10 +264,9 @@ impl Linker {
         resolve_results: *mut ResolveResults,
         fs: *mut Fs::FileSystem,
     ) -> Self {
-        // Zig wrote `relative_paths_list = ImportPathsList.init(arena);`
-        // here; the `LazyLock` accessor handles that lazily on first
-        // `intern_path()` / `relative_paths_list()` call, so no eager poke
-        // is needed (it was startup overhead for non-bundling code paths).
+        // The `LazyLock` accessor initializes `relative_paths_list` lazily on
+        // first `intern_path()` / `relative_paths_list()` call, so no eager
+        // poke is needed (it would be startup overhead for non-bundling code paths).
         Self {
             options,
             fs,
@@ -292,11 +284,10 @@ impl Linker {
     }
 
     /// Re-seat the self-referential back-pointers after the owning
-    /// `Transpiler` has been moved to its final address. Port of the
-    /// post-copy fixups in ThreadPool.zig:310 / bundle_v2.zig:230 — those
-    /// only re-assign the pointer fields and do NOT reset
+    /// `Transpiler` has been moved to its final address. Only re-assigns the
+    /// pointer fields; does NOT reset
     /// `import_counter` / `plugin_runner` / `tagged_resolutions` /
-    /// `any_needs_runtime`, so neither does this. Use instead of `init` from
+    /// `any_needs_runtime`. Use instead of `init` from
     /// `Transpiler::wire_after_move`.
     pub fn reseat_self_refs(
         &mut self,
@@ -315,22 +306,19 @@ impl Linker {
         self.fs = fs;
     }
 
-    /// Accessor for the `relative_paths_list` singleton (Zig:
-    /// `Linker.relative_paths_list`). Returns `*mut` because the Zig contract
-    /// is a global `*Self` pointer — fabricating `&'static mut` here would
-    /// alias on every call.
+    /// Accessor for the `relative_paths_list` singleton. Returns `*mut`
+    /// because the contract is a global pointer — fabricating `&'static mut`
+    /// here would alias on every call.
     #[inline]
     pub fn relative_paths_list() -> *mut ImportPathsList {
         relative_paths_list_ptr()
     }
 
     // ── getModKey / getHashedFilename ────────────────────────────────────
-    // PORT NOTE: Zig's `Fs.FileSystem.RealFS.ModKey` is a nested decl; the
-    // Rust port hoists `ModKey` to module scope (`bun_resolver::fs::ModKey`)
+    // `ModKey` lives at module scope (`bun_resolver::fs::ModKey`)
     // alongside `RealFS`. `file_path` is typed `PFs::Path` (not `Fs::Path`)
     // so `get_hashed_filename` — whose callers all build `PFs::Path` — can
-    // forward directly; only `.text` is read, and both ports define it as
-    // `&[u8]`.
+    // forward directly; only `.text` (a `&[u8]`) is read.
     pub fn get_mod_key(
         &mut self,
         file_path: &PFs::Path<'_>,
@@ -352,7 +340,7 @@ impl Linker {
         };
         let file = bun_sys::File::borrow(&raw_fd);
         Fs::FileSystem::set_max_fd(file.handle().native());
-        // PORT NOTE: spec called `Fs.FileSystem.RealFS.ModKey.generate(&this.fs.fs,
+        // spec called `Fs.FileSystem.RealFS.ModKey.generate(&this.fs.fs,
         // path, file)`; both leading args are unread (fs.rs:1386). The inline
         // `bun_resolver::fs::RealFS` (which `self.fs.fs` is) and the full-port
         // `fs_full::RealFS` are distinct types, so route through the
@@ -374,15 +362,24 @@ impl Linker {
         }
 
         let modkey = self.get_mod_key(file_path, fd)?;
-        // PORT NOTE: `ModKey::hash_name` writes into a 1 KiB threadlocal and
-        // returns a `'static` slice into it (matches Zig's `hash_name_buf`
-        // threadlocal). Spec passes `file_path.text` even though the param is
-        // named `basename`; preserved verbatim.
-        let hash_name = modkey.hash_name(file_path.text)?;
+        // `ModKey::hash_name` writes into a caller-supplied buffer (1 KiB)
+        // and returns a borrow of it; `dupe` copies the bytes into the
+        // process-lifetime interner to satisfy this fn's `'static` return.
+        // Note: `IS_CACHE_ENABLED` is a hard `const false` (see above), so
+        // the `hashed_filenames` cache never dedups — every call interns a
+        // fresh copy for the life of the process. Accepted: the `'static`
+        // return contract forces a copy anyway, and the alternative (the old
+        // threadlocal slice return) was unsound. `dupe` also aborts on OOM
+        // where the old path propagated `?` — consistent with the
+        // `bun.handleOom` idiom for interner allocations.
+        // Spec passes `file_path.text` even though the param is named
+        // `basename`; preserved verbatim.
+        let mut hash_name_buf = [0u8; 1024];
+        let hash_name = dupe(modkey.hash_name(file_path.text, &mut hash_name_buf)?);
 
         if IS_CACHE_ENABLED {
             let hashed = bun_wyhash::hash(file_path.text);
-            self.hashed_filenames.insert(hashed, dupe(hash_name));
+            self.hashed_filenames.insert(hashed, hash_name);
         }
 
         Ok(hash_name)
@@ -391,7 +388,7 @@ impl Linker {
     /// This modifies the Ast in-place! It resolves import records and
     /// generates paths.
     ///
-    /// PORT NOTE: `comptime import_path_format` demoted to a runtime arg —
+    /// `import_path_format` is a runtime arg rather than a const generic —
     /// `options::ImportPathFormat` doesn't derive `ConstParamTy`, and the
     /// crate doesn't enable `adt_const_params`. All callers pass a literal,
     /// and the inner `generate_import_path` body is a single `match` either
@@ -423,10 +420,7 @@ impl Linker {
             | options::Loader::Js
             | options::Loader::Ts
             | options::Loader::Tsx => {
-                // PORT NOTE: reshaped for borrowck — Zig iterated
-                // `result.ast.import_records.slice()` while also reading other
-                // `result.*` fields and (in the not-found branch) borrowing
-                // `&result.source`. Iterate by index, take field-disjoint
+                // Iterate by index, take field-disjoint
                 // borrows (`&result.source` + `&mut result.ast.*`) where
                 // needed, and hoist `is_pending_import` (which borrows the
                 // whole `result`) before any `ast` mut borrow.
@@ -528,8 +522,7 @@ impl Linker {
                             // by the owning `Transpiler` to a live JSC-heap
                             // `PluginRunner`; the transpiler is single-threaded
                             // and holds no other borrow of it for the duration
-                            // of `on_resolve`. Shared access here matches Zig
-                            // `*PluginRunner` (linker.zig:176-193).
+                            // of `on_resolve`, so shared access is sound.
                             let runner = unsafe { &*runner };
                             if let Some(path) = runner.on_resolve(
                                 import_record.path.text,
@@ -567,15 +560,14 @@ impl Linker {
         if had_resolve_errors {
             return Err(bun_core::err!("ResolveMessage"));
         }
-        // PERF(port): Zig clearAndFree; Vec drop at scope end frees.
+        // Vec drop at scope end frees.
         externals.clear();
         let _ = externals;
         Ok(())
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig passed `&mut self` + `&mut
-    // ImportRecord` (a sub-borrow of `result.ast`) + `&mut ParseResult`. In
-    // Rust those overlap; pass the disjoint pieces explicitly.
+    // Takes the disjoint pieces explicitly rather than `&mut self` plus
+    // overlapping sub-borrows of `result`.
     fn when_module_not_found<const IS_BUN: bool>(
         log: &mut Log,
         target: BundleTarget,
@@ -660,11 +652,11 @@ impl Linker {
                 }
 
                 if namespace == b"bun" || namespace == b"file" || namespace.is_empty() {
-                    // PORT NOTE: `linker.fs.relative` is a thin wrapper over
+                    // `linker.fs.relative` is a thin wrapper over
                     // `bun.path.relative`; the inline `bun_resolver::fs`
                     // module doesn't expose it yet, so call the path layer
                     // directly. The threadlocal-buffer result must be
-                    // dup'd to outlive this call (Zig leaked into Path).
+                    // dup'd to outlive this call.
                     let relative_name =
                         dupe(bun_paths::resolve_path::relative(source_dir, source_path));
                     Ok(PFs::Path::init_with_pretty(source_path, relative_name))
@@ -729,8 +721,6 @@ impl Linker {
                         }
                     }
 
-                    // PORT NOTE: `fs.relativeTo(source_path)` ==
-                    // `relative(fs.top_level_dir, source_path)` in Zig.
                     let top_level_dir = self.fs().top_level_dir;
                     let mut base: &[u8] =
                         bun_paths::resolve_path::relative(top_level_dir, source_path);
@@ -780,10 +770,7 @@ impl Linker {
     ) -> Result<bool, bun_core::Error> {
         let hash_key = self.resolve_result_hash_key(&resolve_result);
 
-        // PORT NOTE: Zig `getOrPut` → `HashMap::entry`; `found_existing` is
-        // whether the key was already present. Matches Zig
-        // `linker.resolve_results.getOrPut` / `linker.resolve_queue.writeItem`
-        // (linker.zig:387-390).
+        // `found_existing` is whether the key was already present.
         let found_existing = self.resolve_results_mut().contains_key(&hash_key);
         if !found_existing {
             self.resolve_results_mut().insert(hash_key, ());
@@ -793,5 +780,3 @@ impl Linker {
         Ok(!found_existing)
     }
 }
-
-// ported from: src/bundler/linker.zig
diff --git a/src/bundler/linker_context/MetafileBuilder.rs b/src/bundler/linker_context/MetafileBuilder.rs
index f7ecff60a64..ced1444b4a0 100644
--- a/src/bundler/linker_context/MetafileBuilder.rs
+++ b/src/bundler/linker_context/MetafileBuilder.rs
@@ -396,7 +396,7 @@ pub fn generate(c: &mut LinkerContext, chunks: &mut [Chunk]) -> Result<Box<[u8]>
         first_output = false;
 
         j.push_static(b"\n    ");
-        // PORT NOTE: Zig pushes a borrowed slice; push_static borrows for the
+        // `push_static` borrows for the
         // lifetime of the joiner (`chunk.metafile_chunk_json: Box<[u8]>` outlives `j`).
         j.push_static(&chunk.metafile_chunk_json);
     }
@@ -422,9 +422,8 @@ pub fn generate(c: &mut LinkerContext, chunks: &mut [Chunk]) -> Result<Box<[u8]>
     )?;
 
     // Get final output with all chunk references resolved.
-    // PORT NOTE: Zig passes `&chunks[0]` as the dummy chunk and `chunks` as the
-    // full slice (aliased). `code()` takes both as `&` now, so pass `&chunks[0]`
-    // directly — overlapping shared borrows are fine.
+    // `code()` takes the dummy chunk and the full slice as `&`, so pass
+    // `&chunks[0]` directly — overlapping shared borrows are fine.
     let code_result = intermediate.code(
         None,
         parse_graph,
@@ -449,11 +448,10 @@ fn write_json_string(writer: &mut impl Write, str: &[u8]) -> std::io::Result<()>
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Minimal `std.json.Value`-shaped tree for `generate_markdown`.
+// Minimal dynamic JSON value tree for `generate_markdown`.
 //
-// PORT NOTE: Zig's `generateMarkdown` re-parses the metafile JSON via
-// `std.json.parseFromSlice(std.json.Value, …)` — a generic dynamic-tree parse.
-// The Rust crates available here (`bun_parsers::json`) only expose an
+// `generate_markdown` re-parses the metafile JSON as a dynamic tree.
+// The crates available here (`bun_parsers::json`) only expose an
 // AST-expr parser, so a small self-contained Value/parser is provided below
 // covering exactly the subset the metafile format uses.
 // ──────────────────────────────────────────────────────────────────────────
@@ -711,10 +709,8 @@ impl<'a> JsonParser<'a> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// generate_markdown helper structs (local to the function in Zig; hoisted here)
-// PORT NOTE: lifetime <'a> ties borrowed slices to the parsed JSON value's
-// lifetime. The Zig originals were anonymous structs holding []const u8 that
-// borrowed from the std.json parse arena.
+// generate_markdown helper structs.
+// Lifetime <'a> ties borrowed slices to the parsed JSON value's lifetime.
 // ──────────────────────────────────────────────────────────────────────────
 
 struct InputFileInfo<'a> {
@@ -1627,5 +1623,3 @@ fn strip_parent_refs(path: &[u8]) -> &[u8] {
     }
     result
 }
-
-// ported from: src/bundler/linker_context/MetafileBuilder.zig
diff --git a/src/bundler/linker_context/OutputFileListBuilder.rs b/src/bundler/linker_context/OutputFileListBuilder.rs
index 6632f0ebfb5..e332f4561f4 100644
--- a/src/bundler/linker_context/OutputFileListBuilder.rs
+++ b/src/bundler/linker_context/OutputFileListBuilder.rs
@@ -55,7 +55,6 @@ impl OutputFileList {
         let (length, supplementary_file_count) =
             OutputFileList::calculate_output_file_list_capacity(c, chunks);
         let mut output_files: Vec<options::OutputFile> = Vec::with_capacity(length as usize);
-        // PERF(port): was appendNTimesAssumeCapacity.
         output_files.resize_with(length as usize, OutputFile::zero_value);
 
         Ok(Self {
@@ -64,7 +63,7 @@ impl OutputFileList {
             index_for_sourcemaps_and_bytecode: if supplementary_file_count == 0 {
                 None
             } else {
-                Some(chunks.len() as u32) // @truncate
+                Some(chunks.len() as u32)
             },
             additional_output_files_start: u32::try_from(chunks.len()).expect("int cast")
                 + supplementary_file_count,
@@ -195,8 +194,8 @@ impl OutputFileList {
             self.index_for_sourcemaps_and_bytecode.unwrap_or(0),
             self.additional_output_files_start,
         );
-        // PORT NOTE: Zig did bitwise memcpy (ownership move). `OutputFile` is not
-        // `Clone`, so drain by value into the target window.
+        // Ownership move: `OutputFile` is not `Clone`, so drain by value into
+        // the target window.
         let len = additional_output_files.len();
         let dest = self.get_mutable_additional_output_files();
         for (i, of) in additional_output_files.drain(..).enumerate() {
@@ -221,5 +220,3 @@ impl OutputFileList {
         Some(result)
     }
 }
-
-// ported from: src/bundler/linker_context/OutputFileListBuilder.zig
diff --git a/src/bundler/linker_context/StaticRouteVisitor.rs b/src/bundler/linker_context/StaticRouteVisitor.rs
index d5a63f4238b..cdafe617963 100644
--- a/src/bundler/linker_context/StaticRouteVisitor.rs
+++ b/src/bundler/linker_context/StaticRouteVisitor.rs
@@ -1,7 +1,7 @@
 //! The `is_fully_static(source_index)` function returns whether or not
 //! `source_index` imports a file with `"use client"`.
 //!
-//! TODO: Could we move this into the ReachableFileVisitor inside `bundle_v2.zig`?
+//! TODO: Could we move this into the ReachableFileVisitor inside `bundle_v2.rs`?
 
 use crate::mal_prelude::*;
 use bun_collections::{ArrayHashMap, AutoBitSet};
@@ -16,10 +16,6 @@ pub struct StaticRouteVisitor<'a> {
     pub visited: AutoBitSet,
 }
 
-// PORT NOTE: Zig `deinit` only freed `cache` and `visited` with the default
-// arena. Both are now owned types with `Drop`, so no explicit `impl Drop`
-// is needed.
-
 impl<'a> StaticRouteVisitor<'a> {
     /// This the quickest, simplest, dumbest way I can think of doing this.
     /// Investigate performance. It can have false negatives (it doesn't properly
@@ -33,7 +29,7 @@ impl<'a> StaticRouteVisitor<'a> {
             return false;
         }
 
-        // PORT NOTE: `self.c` is `&'a LinkerContext` (Copy), so these slice
+        // `self.c` is `&'a LinkerContext` (Copy), so these slice
         // borrows are tied to `'a`, not to `&self`, and do not conflict with
         // the `&mut self` call below. `parse_graph()` is the safe backref
         // accessor (one centralized `unsafe`, see `LinkerContext::parse_graph`).
@@ -117,5 +113,3 @@ impl<'a> StaticRouteVisitor<'a> {
         result
     }
 }
-
-// ported from: src/bundler/linker_context/StaticRouteVisitor.zig
diff --git a/src/bundler/linker_context/computeChunks.rs b/src/bundler/linker_context/computeChunks.rs
index 2079e74be18..e0614f8793b 100644
--- a/src/bundler/linker_context/computeChunks.rs
+++ b/src/bundler/linker_context/computeChunks.rs
@@ -31,7 +31,6 @@ fn make_flags(has_html_chunk: bool, is_browser_chunk_from_server_build: bool) ->
     f
 }
 
-// TODO(port): narrow error set
 #[inline(never)]
 pub fn compute_chunks(
     this: &mut LinkerContext,
@@ -41,12 +40,10 @@ pub fn compute_chunks(
 
     debug_assert!(this.dev_server.is_none()); // use
 
-    // PERF(port): was stack-fallback (std.heap.stackFallback(4096, ...)) — profile if hot.
-    // PERF(port): was arena bulk-free — temp allocations freed at end of fn
     let arena = Arena::new();
     let temp = &arena;
 
-    // TODO(port): StringArrayHashMap keyed by arena-allocated &[u8]; using ArrayHashMap<&[u8], Chunk> here.
+    // Keys borrow from `temp`; the map and the arena are both dropped at end of fn.
     let mut js_chunks: ArrayHashMap<&[u8], Chunk> = ArrayHashMap::new();
     js_chunks.reserve(this.graph.entry_points.len());
 
@@ -65,15 +62,15 @@ pub fn compute_chunks(
     let parse_graph = unsafe { &*this.parse_graph };
     // `bump` is a `BackRef` into `BundleV2.graph.arena`, valid for the link step.
     // Hoisted so the loop can hold disjoint &mut borrows into `this.graph`.
-    // PORT NOTE: `BundlerStyleSheet::empty()` no longer takes an arena in Rust; kept for
+    // `BundlerStyleSheet::empty()` no longer takes an arena in Rust; kept for
     // when arena threading lands.
     let _arena: &Arena = this.graph.arena();
 
-    // PORT NOTE: borrowck escape hatch — the SoA column slices below hold disjoint
+    // borrowck escape hatch — the SoA column slices below hold disjoint
     // immutable borrows into `this.graph` while several helpers (and the BundleV2
-    // back-pointer recovery) still want `&mut LinkerContext`. The Zig original
-    // freely aliases; TODO(refactor): thread split borrows through `LinkerGraph`
-    // instead of laundering through a raw pointer.
+    // back-pointer recovery) still want `&mut LinkerContext`. Split borrows
+    // could eventually be threaded through
+    // `LinkerGraph` instead of laundering through a raw pointer.
     let this_ptr: *mut LinkerContext = this;
 
     let entry_source_indices = this.graph.entry_points.items_source_index();
@@ -89,9 +86,9 @@ pub fn compute_chunks(
 
     // Create chunks for entry points
     for (entry_id_, &source_index) in entry_source_indices.iter().enumerate() {
-        let entry_bit = entry_id_ as chunk::EntryPointId; // @truncate
+        let entry_bit = entry_id_ as chunk::EntryPointId;
 
-        // PORT NOTE: reshaped for borrowck — set the bit through a scoped &mut, then keep an
+        // reshaped for borrowck — set the bit through a scoped &mut, then keep an
         // owned clone so the `this.graph.files` borrow does not span the helper calls below
         // that need `&LinkerContext` / `&mut LinkerContext`.
         let entry_bits: AutoBitSet = {
@@ -116,7 +113,7 @@ pub fn compute_chunks(
                     .alloc_slice_copy(entry_point_chunk_bits.bytes(this.graph.entry_points.len()));
             } else {
                 // Force HTML chunks to always be generated, even if there's an identical JS file.
-                // PORT NOTE: Zig used a Formatter struct; build the byte key directly since
+                // Build the byte key directly since
                 // entry_bits is arbitrary bytes (not UTF-8) and cannot go through fmt::Display.
                 let mut v = bun_alloc::ArenaVec::new_in(temp);
                 v.push((!has_html_chunk) as u8);
@@ -145,7 +142,7 @@ pub fn compute_chunks(
         }
 
         if css_asts[source_index as usize].is_some() {
-            // SAFETY: see `this_ptr` PORT NOTE above — the helper only reads from
+            // SAFETY: see `this_ptr` note above — the helper only reads from
             // `this.graph` columns disjoint from the slices we hold here.
             let order = find_imported_files_in_css_order(
                 unsafe { &mut *this_ptr },
@@ -221,7 +218,7 @@ pub fn compute_chunks(
             let css_source_indices =
                 find_imported_css_files_in_js_order(this, temp, Index::init(source_index));
             if css_source_indices.len() > 0 {
-                // SAFETY: see `this_ptr` PORT NOTE above.
+                // SAFETY: see `this_ptr` note above.
                 let order = find_imported_files_in_css_order(
                     unsafe { &mut *this_ptr },
                     temp,
@@ -284,7 +281,7 @@ pub fn compute_chunks(
             }
         }
     }
-    // PORT NOTE: reshaped for borrowck — re-borrow file_entry_bits after the loop above mutated it
+    // reshaped for borrowck — re-borrow file_entry_bits after the loop above mutated it
     let file_entry_bits: &mut [AutoBitSet] = this.graph.files.items_entry_bits_mut();
 
     let css_reprs = this.graph.ast.items_css();
@@ -350,8 +347,7 @@ pub fn compute_chunks(
                             *entry.value_ptr = AtomicUsize::new(0); // Initialize byte count to 0
                         }
                     } else {
-                        // PORT NOTE: Zig used a local `Handler` struct passed to entry_bits.forEach;
-                        // in Rust we pass a context struct + fn pointer.
+                        // Pass a context struct + fn pointer to entry_bits' forEach.
                         struct Handler<'a> {
                             chunks: &'a mut [Chunk],
                             source_id: u32,
@@ -394,7 +390,6 @@ pub fn compute_chunks(
 
         let mut sorted_keys = Vec::<&[u8]>::init_capacity(js_chunks.count());
 
-        // PERF(port): was assume_capacity
         sorted_keys.append_slice_assume_capacity(js_chunks.keys());
 
         // sort by entry_point_id to ensure the main entry point (id=0) comes first,
@@ -443,13 +438,11 @@ pub fn compute_chunks(
 
             if let chunk::Content::Javascript(js) = &chunk.content {
                 if js.css_chunks.len() > 0 {
-                    // PERF(port): was assume_capacity
                     js_chunk_indices_with_css.append_assume_capacity(sorted_chunks.len() as u32);
                 }
             }
 
-            // PERF(port): was assume_capacity
-            // PORT NOTE: `Chunk` is not `Clone` (Zig is move-by-value); take by index.
+            // `Chunk` is not `Clone`; take by index.
             let idx = js_chunks.get_index(&key).expect("unreachable");
             let owned = core::mem::take(&mut js_chunks.values_mut()[idx]);
             let has_html = owned.flags.contains(chunk::Flags::HAS_HTML_CHUNK);
@@ -459,7 +452,6 @@ pub fn compute_chunks(
             if has_html {
                 if let Some(html_idx) = html_chunks.get_index(&key) {
                     let (_, html_chunk) = html_chunks.swap_remove_at(html_idx);
-                    // PERF(port): was assume_capacity
                     sorted_chunks.append_assume_capacity(html_chunk);
                 }
             }
@@ -479,7 +471,6 @@ pub fn compute_chunks(
             for (sorted_index, &key) in (sorted_chunks.len() as usize..).zip(sorted_css_keys.iter())
             {
                 let index = css_chunks.get_index(&key).expect("unreachable");
-                // PERF(port): was assume_capacity
                 let owned = core::mem::take(&mut css_chunks.values_mut()[index]);
                 sorted_chunks.append_assume_capacity(owned);
                 remapped_css_indexes[index] = u32::try_from(sorted_index).expect("int cast");
@@ -503,8 +494,6 @@ pub fn compute_chunks(
         }
 
         break 'sort_chunks sorted_chunks;
-        // TODO(port): return type — Zig returns []Chunk allocated by this.arena(); here we return Box<[Chunk]>.
-        // Confirm ownership of `chunks` slice (sorted_chunks Vec backing storage).
     };
     let chunks: &mut [Chunk] = sorted_chunks.slice_mut();
 
@@ -540,8 +529,8 @@ pub fn compute_chunks(
     let unique_key_item_len = chunk::UNIQUE_KEY_LEN;
     let mut unique_key_builder =
         bun_core::StringBuilder::init_capacity(unique_key_item_len * chunks.len());
-    // PORT NOTE: in Zig `unique_key_buf` aliases the builder's backing buffer and
-    // every `chunk.unique_key` is a slice into it. Mirror that: the builder never
+    // `unique_key_buf` aliases the builder's backing buffer and
+    // every `chunk.unique_key` is a slice into it: the builder never
     // reallocates after `init_capacity`, so each `fmt()` returns a stable subslice
     // that we detach to `&'static [u8]` (BACKREF) and transfer ownership of the
     // single allocation into `this.unique_key_buf` afterwards.
@@ -553,7 +542,7 @@ pub fn compute_chunks(
     let bv2: &mut BundleV2 = unsafe { &mut *LinkerContext::bundle_v2_ptr(this_ptr) };
     let kinds = this.graph.files.items_entry_point_kind();
     let output_paths = this.graph.entry_points.items_output_path();
-    // PORT NOTE: re-borrow after `find_all_imported_parts_in_js_order` released `&mut this`.
+    // re-borrow after `find_all_imported_parts_in_js_order` released `&mut this`.
     let ast_targets = this.graph.ast.items_target();
     for (chunk_id, chunk) in chunks.iter_mut().enumerate() {
         // Assign a unique key to each chunk. This key encodes the index directly so
@@ -692,14 +681,13 @@ pub fn compute_chunks(
     }
 
     // Transfer ownership of the single backing buffer; every `chunk.unique_key`
-    // above borrows into it. (Zig's `errdefer` freed the builder and cleared
-    // `unique_key_buf`; in Rust the builder `Drop`s on error and `unique_key_buf`
+    // above borrows into it. (The builder `Drop`s on error and `unique_key_buf`
     // is only assigned here on success, so no rollback guard is needed.)
     this.unique_key_buf = unique_key_builder.move_to_slice();
 
+    // The caller-owned
+    // `Box<[Chunk]>` transfers the `sorted_chunks` Vec backing storage.
     Ok(sorted_chunks.to_owned_slice())
-    // TODO(port): return type — Zig returns []Chunk allocated by this.arena(); here we return Box<[Chunk]>.
-    // Confirm ownership of `chunks` slice (sorted_chunks Vec backing storage).
 }
 
 pub use crate::DeferredBatchTask;
@@ -709,5 +697,3 @@ pub use crate::ThreadPool;
 // Local type aliases referenced above.
 use crate::chunk;
 use crate::options::{Loader, Target};
-
-// ported from: src/bundler/linker_context/computeChunks.zig
diff --git a/src/bundler/linker_context/computeCrossChunkDependencies.rs b/src/bundler/linker_context/computeCrossChunkDependencies.rs
index 5139e28de46..08738701fa6 100644
--- a/src/bundler/linker_context/computeCrossChunkDependencies.rs
+++ b/src/bundler/linker_context/computeCrossChunkDependencies.rs
@@ -31,8 +31,7 @@ pub fn compute_cross_chunk_dependencies(
     // defer { meta.*.deinit(); free(chunk_metas) } — handled by Drop
 
     {
-        // PORT NOTE: Zig heap-allocated this via c.arena().create() and destroyed it at
-        // scope end; in Rust we construct on the stack and let it drop.
+        // Constructed on the stack and dropped at scope end.
         //
         // `ctx` / `symbols` / `chunks` are stored as raw pointers so the struct does not
         // hold a borrow on `c` or `chunks` across the sequential `walk` loop below.
@@ -47,7 +46,7 @@ pub fn compute_cross_chunk_dependencies(
         // Lifetime-erase the `LinkerContext<'_>` so the struct's `'a` (which
         // ties only the local SoA-column borrows) is not forced to equal the
         // LinkerContext's invariant `'_`. `NonNull::from(&mut *c)` preserves
-        // `c`'s Unique provenance (see PORT NOTE above).
+        // `c`'s Unique provenance (see note above).
         let ctx_ref = bun_ptr::BackRef::from(
             core::ptr::NonNull::from(&mut *c).cast::<LinkerContext<'static>>(),
         );
@@ -86,7 +85,7 @@ pub fn compute_cross_chunk_dependencies(
 
 pub(crate) struct CrossChunkDependencies<'a, 'bump> {
     chunk_meta: &'a mut [ChunkMeta],
-    // PORT NOTE: `BackRef` — the same `[Chunk]` slice is also iterated mutably by
+    // `BackRef` — the same `[Chunk]` slice is also iterated mutably by
     // the caller's sequential `walk` loop; `walk` only reads `chunks[other].unique_key`
     // (disjoint from the per-iteration `&mut Chunk`). The slice outlives the struct
     // (caller stack frame).
@@ -100,8 +99,8 @@ pub(crate) struct CrossChunkDependencies<'a, 'bump> {
     exports_refs: &'a [Ref],
     sorted_and_filtered_export_aliases: &'a [js_meta::SortedAndFilteredExportAliases],
     resolved_exports: &'a [ResolvedExports],
-    // PORT NOTE: `BackRef` — Zig stores `*LinkerContext` / `*Symbol.Map` and freely
-    // aliases `c.graph` columns alongside; borrowck cannot express that split, so
+    // `BackRef` — `walk` aliases `c.graph` columns alongside the
+    // `LinkerContext` / `Symbol.Map`; borrowck cannot express that split, so
     // opt out here via `BackRef` (safe `Deref` at each use site in `walk`). Lifetime
     // erased (`'static`) so the outer `CrossChunkDependencies<'_>` borrow is not tied
     // to the LinkerContext's own invariant lifetime parameter.
@@ -128,7 +127,7 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
     pub(crate) fn walk(&mut self, chunk: &mut Chunk, chunk_index: usize) {
         let deps = self;
         // `ctx` / `chunks` are `BackRef`s into `LinkerContext` / the caller's chunk
-        // slice, valid for the link pass (see PORT NOTE on the struct fields).
+        // slice, valid for the link pass (see note on the struct fields).
         // `chunks` aliases the slice the caller iterates mutably but is only read here.
         let ctx: &LinkerContext<'_> = deps.ctx.get();
         // `BackRef` into `LinkerContext.graph.symbols`, valid for the link
@@ -137,8 +136,7 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
         let symbols: &bun_ast::symbol::Map = deps.symbols.get();
         let _chunks: &[Chunk] = deps.chunks.get();
         let chunk_meta = &mut deps.chunk_meta[chunk_index];
-        // PORT NOTE: reshaped for borrowck — Zig held `&chunk_meta` and `&chunk_meta.imports`
-        // simultaneously; here we go through `chunk_meta.imports` / `chunk_meta.dynamic_imports`.
+        // Go through `chunk_meta.imports` / `chunk_meta.dynamic_imports`.
         let entry_point_chunk_indices = deps.entry_point_chunk_indices;
 
         // Go over each file in this chunk
@@ -172,16 +170,18 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
                     {
                         let other_chunk_index =
                             entry_point_chunk_indices[import_record.source_index.get() as usize];
+                        // Slice copy (fat pointer):
+                        // `path.text` borrows the chunk's
+                        // `unique_key` backing buffer (`LinkerContext.unique_key_buf`),
+                        // which outlives the link pass.
                         import_record.path.text = _chunks[other_chunk_index as usize].unique_key;
-                        // TODO(port): Zig assigns the slice by pointer (no copy); decide
-                        // ownership of `path.text` vs `unique_key`.
                         import_record.source_index = Index::INVALID;
 
                         // Track this cross-chunk dynamic import so we make sure to
                         // include its hash when we're calculating the hashes of all
                         // dependencies of this chunk.
                         if other_chunk_index as usize != chunk_index {
-                            let _ = chunk_meta.dynamic_imports.put(other_chunk_index, ()); // OOM-only Result (Zig: catch unreachable)
+                            let _ = chunk_meta.dynamic_imports.put(other_chunk_index, ()); // OOM-only Result
                         }
                     }
                 }
@@ -249,7 +249,7 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
                     // be moved to a separate chunk than the use of a symbol even if
                     // the definition and use of that symbol are originally from the
                     // same source file.
-                    let _ = chunk_meta.imports.put(ref_to_use, ()); // OOM-only Result (Zig: catch unreachable)
+                    let _ = chunk_meta.imports.put(ref_to_use, ()); // OOM-only Result
                 }
             }
         }
@@ -292,14 +292,14 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
                             debug!("Cross-chunk export: {}", bstr::BStr::new(name),);
                         }
 
-                        let _ = chunk_meta.imports.put(target_ref, ()); // OOM-only Result (Zig: catch unreachable)
+                        let _ = chunk_meta.imports.put(target_ref, ()); // OOM-only Result
                     }
                 }
 
                 // Ensure "exports" is included if the current output format needs it
                 // https://github.com/evanw/esbuild/blob/v0.27.2/internal/linker/linker.go#L1049-L1051
                 if flags.force_include_exports_for_entry_point {
-                    // Zig parity: result intentionally discarded
+                    // result intentionally discarded
                     let _ = chunk_meta.imports.put(
                         deps.exports_refs[chunk.entry_point.source_index() as usize],
                         (),
@@ -309,7 +309,7 @@ impl<'a, 'bump> CrossChunkDependencies<'a, 'bump> {
                 // Include the wrapper if present
                 // https://github.com/evanw/esbuild/blob/v0.27.2/internal/linker/linker.go#L1053-L1056
                 if flags.wrap != WrapKind::None {
-                    // Zig parity: result intentionally discarded
+                    // result intentionally discarded
                     let _ = chunk_meta.imports.put(
                         deps.wrapper_refs[chunk.entry_point.source_index() as usize],
                         (),
@@ -326,9 +326,8 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
     chunk_metas: &mut [ChunkMeta],
 ) -> Result<(), bun_alloc::AllocError> {
     // Mark imported symbols as exported in the chunk from which they are declared
-    // PORT NOTE: reshaped for borrowck — Zig zips (chunks, chunk_metas, 0..) and also indexes
-    // chunk_metas[other_chunk_index] / chunks[other_chunk_index] inside the loop body. We
-    // iterate by index and re-borrow per access.
+    // The loop body also indexes chunk_metas[other_chunk_index] /
+    // chunks[other_chunk_index], so iterate by index and re-borrow per access.
     debug_assert_eq!(chunks.len(), chunk_metas.len());
     for chunk_index in 0..chunks.len() {
         if !matches!(chunks[chunk_index].content, chunk::Content::Javascript(_)) {
@@ -336,10 +335,9 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
         }
 
         // Find all uses in this chunk of symbols from other chunks
-        // PORT NOTE: reshaped for borrowck — collect keys first to avoid holding a borrow on
+        // reshaped for borrowck — collect keys first to avoid holding a borrow on
         // chunk_metas[chunk_index] while mutating chunk_metas[other_chunk_index].
         let import_refs: Vec<Ref> = chunk_metas[chunk_index].imports.keys().to_vec();
-        // PERF(port): was direct iteration over .keys() without copy — profile if it shows up on a hot path
         for import_ref in import_refs {
             let symbol = c.graph.symbols.get_const(import_ref).unwrap();
 
@@ -449,8 +447,6 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
         debug!("Generating cross-chunk exports");
 
         let mut stable_ref_list: Vec<StableRef> = Vec::new();
-        // PERF(port): was arena-backed std.ArrayList — profile if it shows up on a hot path
-        // defer stable_ref_list.deinit() — handled by Drop
 
         debug_assert_eq!(chunks.len(), chunk_metas.len());
         for (chunk, chunk_meta) in chunks.iter_mut().zip(chunk_metas.iter_mut()) {
@@ -469,7 +465,6 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
                             c.arena(),
                         );
                     repr.exports_to_other_chunks.reserve(stable_ref_list.len());
-                    // PERF(port): was ensureUnusedCapacity — profile if it shows up on a hot path
                     r.clear_retaining_capacity();
 
                     for stable_ref in stable_ref_list.iter() {
@@ -507,18 +502,17 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
                             original_name: bun_ast::StoreStr::new(b"" as &[u8]),
                         });
 
-                        // `alias` points into the link-pass arena (see PORT NOTE above),
+                        // `alias` points into the link-pass arena (see note above),
                         // which outlives `exports_to_other_chunks`; `.slice()` re-borrows
                         // under the StoreStr arena contract.
-                        let _ = repr.exports_to_other_chunks.put(ref_, alias.slice()); // OOM-only Result (Zig: catch unreachable)
-                        // PERF(port): was putAssumeCapacity — profile if it shows up on a hot path
+                        let _ = repr.exports_to_other_chunks.put(ref_, alias.slice()); // OOM-only Result
                     }
 
                     if clause_items.len() > 0 {
                         let mut stmts = Vec::<bun_ast::Stmt>::init_capacity(1);
                         let items_ptr =
                             bun_ast::StoreSlice::new_mut(clause_items.into_bump_slice_mut());
-                        // Zig: `c.allocator().create(S.ExportClause)` + struct literal —
+                        // Allocated directly from the arena —
                         // bypasses Stmt.Data.Store (not pushed on this thread here).
                         let export_clause = c.arena().alloc(bun_ast::S::ExportClause {
                             items: items_ptr,
@@ -528,7 +522,6 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
                             bun_ast::StoreRef::from_bump(export_clause),
                             bun_ast::Loc::EMPTY,
                         ));
-                        // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
                         repr.cross_chunk_suffix_stmts = stmts;
                     }
                 }
@@ -544,8 +537,7 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
         debug!("Generating cross-chunk imports");
         let mut list: Vec<CrossChunkImport> = Vec::new();
         // defer list.deinit() — handled by Drop
-        // PORT NOTE: reshaped for borrowck — Zig's `for (chunks) |*chunk|` aliases the same
-        // slice it passes to `sortedCrossChunkImports`. We move the per-chunk fields we
+        // We move the per-chunk fields we
         // mutate (`imports_from_other_chunks`, `cross_chunk_imports`) out via `take`, drop
         // the `chunk` borrow, hand the whole `chunks` slice to `sorted_cross_chunk_imports`
         // (which only reads `chunks[other].exports_to_other_chunks` — disjoint), then write
@@ -562,8 +554,8 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
             );
             let mut cross_chunk_imports =
                 core::mem::take(&mut chunks[chunk_index].cross_chunk_imports);
-            // PORT NOTE: reshaped for borrowck — Zig copies the Vec by value, mutates,
-            // then writes back; we `take` to express the same move-out/move-in.
+            // `take` expresses the move-out/move-in: mutate the Vec, then
+            // write it back at loop end.
             let mut cross_chunk_prefix_stmts = Vec::<bun_ast::Stmt>::default();
 
             CrossChunkImport::sorted_cross_chunk_imports(
@@ -594,7 +586,6 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
                                 alias_loc: bun_ast::Loc::EMPTY,
                                 original_name: bun_ast::StoreStr::new(b"" as &[u8]),
                             });
-                            // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
                         }
 
                         cross_chunk_imports.push(chunk::ChunkImport {
@@ -602,7 +593,7 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
                             chunk_index: cross_chunk_import.chunk_index,
                         });
                         let items_ptr = bun_ast::StoreSlice::new_mut(clauses.into_bump_slice_mut());
-                        // Zig: `c.allocator().create(S.Import)` + struct literal —
+                        // Allocated directly from the arena —
                         // bypasses Stmt.Data.Store (not pushed on this thread here).
                         let import = c.arena().alloc(bun_ast::S::Import {
                             items: items_ptr,
@@ -631,8 +622,6 @@ fn compute_cross_chunk_dependencies_with_chunk_metas(
 
 pub use crate::{DeferredBatchTask, ParseTask, ThreadPool};
 
-// `bun.options.Format` is the bundler output-format enum (Esm/Cjs/Iife/...);
-// alias to keep callsites parallel with the Zig `c.options.output_format`.
+// `Format` is the bundler output-format enum (Esm/Cjs/Iife/...);
+// aliased so callsites read as `c.options.output_format`.
 use crate::options::Format as OutputFormat;
-
-// ported from: src/bundler/linker_context/computeCrossChunkDependencies.zig
diff --git a/src/bundler/linker_context/convertStmtsForChunk.rs b/src/bundler/linker_context/convertStmtsForChunk.rs
index 7b7dbf328bb..71b3c148d5b 100644
--- a/src/bundler/linker_context/convertStmtsForChunk.rs
+++ b/src/bundler/linker_context/convertStmtsForChunk.rs
@@ -178,7 +178,6 @@ pub fn convert_stmts_for_chunk(
                             // Prefix this module with "__reExport(exports, ns, module.exports)"
                             let export_star_ref = c.runtime_function(b"__reExport");
                             let args_len = 2 + usize::from(module_exports_for_export.is_some());
-                            // PERF(port): was arena alloc of [Expr; N] — using Vec→Box
                             let mut args: Vec<Expr> = Vec::with_capacity(args_len);
                             args.push(Expr::init(
                                 E::Identifier {
@@ -196,7 +195,9 @@ pub fn convert_stmts_for_chunk(
                             ));
 
                             if let Some(mod_) = module_exports_for_export {
-                                // TODO(port): Zig writes args[3] which is out-of-bounds (len is 3); preserved as args[2] — verify intent.
+                                // Per the "__reExport(exports, ns, module.exports)"
+                                // call shape above, this is the third argument,
+                                // so append at index 2.
                                 args.push(mod_);
                             }
 
@@ -294,7 +295,6 @@ pub fn convert_stmts_for_chunk(
                             // Prefix this module with "__reExport(exports, require(path), module.exports)"
                             let export_star_ref = c.runtime_function(b"__reExport");
                             let args_len = 2 + usize::from(module_exports_for_export.is_some());
-                            // PERF(port): was arena alloc of [Expr; N] — using Vec→Box
                             let mut args: Vec<Expr> = Vec::with_capacity(args_len);
                             args.push(Expr::init(
                                 E::Identifier {
@@ -408,7 +408,7 @@ pub fn convert_stmts_for_chunk(
                         // Be c areful to not modify the original statement
                         stmt = Stmt::alloc(
                             S::Function {
-                                // SAFETY: shallow bitwise copy of arena-backed G::Fn (matches Zig `s.func`).
+                                // SAFETY: shallow bitwise copy of arena-backed G::Fn.
                                 func: unsafe { core::ptr::read(&raw const s.func) },
                             },
                             stmt.loc,
@@ -428,7 +428,7 @@ pub fn convert_stmts_for_chunk(
                         // Be careful to not modify the original statement
                         stmt = Stmt::alloc(
                             S::Class {
-                                // SAFETY: shallow bitwise copy of arena-backed E::Class (matches Zig `s.class`).
+                                // SAFETY: shallow bitwise copy of arena-backed E::Class.
                                 class: unsafe { core::ptr::read(&raw const s.class) },
                                 is_export: false,
                             },
@@ -441,7 +441,7 @@ pub fn convert_stmts_for_chunk(
                     // Strip the "export" keyword while bundling
                     if should_strip_exports && s.is_export {
                         // Be careful to not modify the original statement
-                        // SAFETY: shallow bitwise copy of arena-backed S::Local (matches Zig `s.*`).
+                        // SAFETY: shallow bitwise copy of arena-backed S::Local.
                         let copied: S::Local = unsafe { core::ptr::read(s.as_ptr()) };
                         stmt = Stmt::alloc(copied, stmt.loc);
                         stmt.data.s_local_mut().unwrap().is_export = false;
@@ -518,7 +518,7 @@ pub fn convert_stmts_for_chunk(
                                         // Be careful to not modify the original statement
                                         stmt = Stmt::alloc(
                                             S::Function {
-                                                // SAFETY: shallow bitwise copy of arena-backed G::Fn (matches Zig `s2.func`).
+                                                // SAFETY: shallow bitwise copy of arena-backed G::Fn.
                                                 func: unsafe {
                                                     core::ptr::read(&raw const s2.func)
                                                 },
@@ -536,7 +536,7 @@ pub fn convert_stmts_for_chunk(
                                         // Be careful to not modify the original statement
                                         stmt = Stmt::alloc(
                                             S::Class {
-                                                // SAFETY: shallow bitwise copy of arena-backed E::Class (matches Zig `s2.class`).
+                                                // SAFETY: shallow bitwise copy of arena-backed E::Class.
                                                 class: unsafe {
                                                     core::ptr::read(&raw const s2.class)
                                                 },
@@ -606,5 +606,3 @@ pub fn convert_stmts_for_chunk(
 pub use crate::DeferredBatchTask::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/convertStmtsForChunk.zig
diff --git a/src/bundler/linker_context/convertStmtsForChunkForDevServer.rs b/src/bundler/linker_context/convertStmtsForChunkForDevServer.rs
index ae25173e490..c0e1898dfde 100644
--- a/src/bundler/linker_context/convertStmtsForChunkForDevServer.rs
+++ b/src/bundler/linker_context/convertStmtsForChunkForDevServer.rs
@@ -183,7 +183,6 @@ pub fn convert_stmts_for_chunk_for_dev_server<'bump>(
                             },
                             default_value: None,
                         });
-                        // PERF(port): was assume_capacity-adjacent (arena append)
                         esm_callbacks.push(Expr::init(E::Arrow::NOOP_RETURN_UNDEFINED, Loc::EMPTY));
                     } else {
                         let binding = Binding::alloc(
@@ -276,7 +275,7 @@ pub fn convert_stmts_for_chunk_for_dev_server<'bump>(
                 Loc::EMPTY,
             ))?;
         // hmr.onUpdate = [ ... ];
-        // PORT NOTE: reshaped for borrowck — capture len before moving esm_callbacks
+        // Capture len before moving `esm_callbacks` (borrowck).
         let callbacks_len = esm_callbacks.len();
         stmts
             .inside_wrapper_prefix
@@ -317,5 +316,3 @@ pub fn convert_stmts_for_chunk_for_dev_server<'bump>(
 pub use crate::DeferredBatchTask::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/convertStmtsForChunkForDevServer.zig
diff --git a/src/bundler/linker_context/doStep5.rs b/src/bundler/linker_context/doStep5.rs
index 1742f67874c..f7fb2a3c802 100644
--- a/src/bundler/linker_context/doStep5.rs
+++ b/src/bundler/linker_context/doStep5.rs
@@ -1,6 +1,4 @@
-//! Port of `src/bundler/linker_context/doStep5.zig`.
-//!
-//! PORT NOTE: like `scanImportsAndExports.rs`, the Zig body holds many
+//! Like `scanImportsAndExports.rs`, this step needs many
 //! overlapping `&mut` column slices out of `LinkerGraph.{ast,meta}` while also
 //! calling `&self` methods. The SoA columns are physically disjoint and never
 //! reallocate during this step, so we cache raw column pointers and deref at
@@ -68,8 +66,8 @@ impl LinkerContext<'_> {
         // form `&mut BundleV2` here (concurrent tasks would alias it).
         let bundle_v2: &BundleV2<'_> = unsafe { &*LinkerContext::bundle_v2_ptr(this) };
         let worker = ThreadPool::Worker::get(bundle_v2);
-        // Zig: `defer worker.unget()`. `Worker::get` returns the thread-local worker
-        // (not RAII), so balance explicitly via scopeguard.
+        // `Worker::get` returns the thread-local worker
+        // (not RAII), so balance with `unget` explicitly via scopeguard.
         let worker = scopeguard::guard(worker, |w| w.unget());
 
         // we must use this arena here
@@ -160,7 +158,6 @@ impl LinkerContext<'_> {
                 re_exports_count += inner_count;
 
                 aliases.push(alias);
-                // PERF(port): was appendAssumeCapacity
             }
         }
         // TODO: can this be u32 instead of a string?
@@ -203,7 +200,7 @@ impl LinkerContext<'_> {
         // Each part tracks the other parts it depends on within this file
         let mut local_dependencies: HashMap<u32, u32> = HashMap::default();
 
-        // PORT NOTE: reshaped for borrowck — multiple `&mut` into graph SoA;
+        // Multiple `&mut` into graph SoA are needed here;
         // raw per-row pointers via `split_raw()` so concurrent tasks never
         // hold overlapping `&mut [T]`.
         let parts_slice: *mut [Part] = row_mut!(ast.parts, bun_ast::PartList, id).as_mut_slice();
@@ -216,11 +213,11 @@ impl LinkerContext<'_> {
         // the lookup entirely for files with no imports (≈ all leaf modules).
         let named_imports_is_empty = unsafe { (*named_imports).is_empty() };
 
-        // PERF(port): hoist this file's two `top_level_symbols_to_parts`
-        // sub-maps. The Zig version reaches them through
-        // `c.topLevelSymbolsToParts(id, ref)` per symbol-use, which is fine
-        // when the underlying ArrayHashMap has its index_header (O(1) get).
-        // In the port, perf showed `find_hash` falling through to the linear
+        // PERF: hoist this file's two `top_level_symbols_to_parts`
+        // sub-maps rather than going through
+        // `c.topLevelSymbolsToParts(id, ref)` per symbol-use — that is fine
+        // when the underlying ArrayHashMap has its index_header (O(1) get),
+        // but perf showed `find_hash` falling through to the linear
         // scan branch here (≈87% of step5 self-time on three.js), so we (a)
         // hoist the per-file column pointer math out of the J×K inner loop
         // and (b) ensure the accelerator index is built on the large
@@ -249,9 +246,9 @@ impl LinkerContext<'_> {
             // Now that all files have been parsed, determine which property
             // accesses off of imported symbols are inlined enum values and
             // which ones aren't
-            // PORT NOTE: reshaped for borrowck — Zig iterates keys()/values() while
-            // holding a mutable getPtr into part.symbol_uses; collect refs first.
-            // PERF(port): the property-use map is empty for the overwhelming
+            // We cannot iterate keys()/values() while
+            // holding a mutable pointer into part.symbol_uses; collect refs first.
+            // PERF: the property-use map is empty for the overwhelming
             // majority of parts (it only fills for `import * as ns`/enum
             // property accesses); skip the `to_vec()` alloc-round-trip in
             // that case.
@@ -304,50 +301,12 @@ impl LinkerContext<'_> {
             // TODO: inline function calls here
 
             // TODO: Inline cross-module constants
-            // if (c.graph.const_values.count() > 0) {
-            //     // First, find any symbol usage that points to a constant value.
-            //     // This will be pretty rare.
-            //     const first_constant_i: ?usize = brk: {
-            //         for (part.symbol_uses.keys(), 0..) |ref, j| {
-            //             if (c.graph.const_values.contains(ref)) {
-            //                 break :brk j;
-            //             }
-            //         }
-            //
-            //         break :brk null;
-            //     };
-            //     if (first_constant_i) |j| {
-            //         var end_i: usize = 0;
-            //         // symbol_uses is an array
-            //         var keys = part.symbol_uses.keys()[j..];
-            //         var values = part.symbol_uses.values()[j..];
-            //         for (keys, values) |ref, val| {
-            //             if (c.graph.const_values.contains(ref)) {
-            //                 continue;
-            //             }
-            //
-            //             keys[end_i] = ref;
-            //             values[end_i] = val;
-            //             end_i += 1;
-            //         }
-            //         part.symbol_uses.entries.len = end_i + j;
-            //
-            //         if (part.symbol_uses.entries.len == 0 and part.can_be_removed_if_unused) {
-            //             part.tag = .dead_due_to_inlining;
-            //             part.dependencies.len = 0;
-            //             continue :outer;
-            //         }
-            //
-            //         part.symbol_uses.reIndex(arena) catch unreachable;
-            //     }
-            // }
             if false {
                 break 'outer;
-            } // this `if` is here to preserve the unused
-            //                          block label from the above commented code.
+            } // this `if` preserves the otherwise-unused block label.
 
             // Now that we know this, we can determine cross-part dependencies
-            // PERF(port): iterate the keys slice directly (the index-based
+            // PERF: iterate the keys slice directly (the index-based
             // form re-loaded `keys.len()` and bounds-checked each access).
             let part_index_u32 = part_index as u32;
             let dependencies = &mut part.dependencies;
@@ -399,12 +358,10 @@ impl LinkerContext<'_> {
         }
     }
 
-    /// Spec: `linker_context/doStep5.zig:createExportsForFile`.
-    ///
     /// WARNING: This method is run in parallel over all files. Do not mutate data
     /// for other files within this method or you will create a data race.
     ///
-    /// PORT NOTE: takes `&self` (read-only) plus the three SoA row cells it
+    /// Takes `&self` (read-only) plus the three SoA row cells it
     /// mutates as explicit `&mut` params, so the parallel `do_step5` dispatch
     /// never forms a concurrent `&mut LinkerContext` / whole-column `&mut [T]`.
     #[allow(clippy::too_many_arguments)]
@@ -420,10 +377,17 @@ impl LinkerContext<'_> {
         ast_flags: &mut AstFlags,
         ast_parts: &mut bun_ast::PartList,
     ) {
-        // PORT NOTE: Zig toggled `Stmt.Disabler`/`Expr.Disabler` (debug-only
-        // re-entrancy guards around the global Store). `Disabler::scope()`
-        // calls `disable()` and re-`enable()`s on drop — currently no-op stubs
-        // until the thread-local toggle lands (`js_parser/ast/mod.rs`).
+        // `Stmt.Disabler`/`Expr.Disabler` are debug-only guards
+        // around the global thread-local block store. `Disabler::scope()`
+        // calls `disable()` and re-`enable()`s on drop. In debug builds the
+        // disabler only fires when `Store::append` falls through to that
+        // global slab — i.e. when no `ASTMemoryAllocator` scope is installed.
+        // Bundler workers always install one (`Worker::get` pushes
+        // `ast_memory_store`), so appends in this step — including
+        // `Stmt::assign` below — route to the worker allocator and bypass the
+        // check entirely. The guard
+        // exists to catch accidental global-slab use if this code ever runs
+        // without that allocator installed.
         let _stmt_guard = bun_ast::stmt::Disabler::scope();
         let _expr_guard = bun_ast::expr::Disabler::scope();
 
@@ -451,8 +415,8 @@ impl LinkerContext<'_> {
             // + 1 if we need to do module.exports = __toCommonJS(exports)
             force_include_exports_for_entry_point as usize;
 
-        // PORT NOTE: Zig used `Stmt.Batcher` (preallocated arena slice +
-        // cursor). `Batcher::<T>::init` requires `T: Default` which `Stmt`
+        // `Batcher::<T>::init` (preallocated arena slice + cursor) requires
+        // `T: Default` which `Stmt`
         // doesn't satisfy, so we hand-roll the same shape: one arena slab of
         // `stmts_count` `MaybeUninit<Stmt>`, sliced front-to-back. `eat1`
         // becomes a `write` + sub-slice carve. The slab is held as a safe
@@ -539,7 +503,6 @@ impl LinkerContext<'_> {
                 )),
                 ..Default::default()
             });
-            // PERF(port): was appendAssumeCapacity
             ns_export_symbol_uses
                 .put_assume_capacity(exp_data.import_ref, SymbolUse { count_estimate: 1 });
 
@@ -562,7 +525,7 @@ impl LinkerContext<'_> {
         let all_export_stmts_len = needs_exports_variable as usize
             + (!properties.is_empty()) as usize
             + force_include_exports_for_entry_point as usize;
-        // PORT NOTE: the trailing `all_export_stmts_len` slots of `stmts_slab`
+        // The trailing `all_export_stmts_len` slots of `stmts_slab`
         // (after the per-export `eat1`s above) are filled below in the order
         // {var exports={}, __export(...), module.exports=__toCommonJS(...)}.
         let all_export_stmts_base = stmts_head;
@@ -602,9 +565,9 @@ impl LinkerContext<'_> {
         let mut export_ref = Ref::NONE;
         if !properties.is_empty() {
             export_ref = self.runtime_function(b"__export");
-            // PORT NOTE: `bumpalo::Vec` → `Vec` via the global heap;
+            // `bumpalo::Vec` → `Vec` via the global heap;
             // `G::PropertyList` is `Vec<Property>` and currently has no
-            // arena-backed `move_from_list`, so re-own. PERF(port).
+            // arena-backed `move_from_list`, so re-own.
             let mut owned_props: Vec<G::Property> = Vec::with_capacity(properties.len());
             owned_props.extend(properties.drain(..));
             emit_export_stmt!(Stmt::allocate(
@@ -724,5 +687,3 @@ impl LinkerContext<'_> {
         }
     }
 }
-
-// ported from: src/bundler/linker_context/doStep5.zig
diff --git a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
index 37e2a974744..e99ce4cb31c 100644
--- a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
+++ b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
@@ -17,7 +17,7 @@ pub fn find_all_imported_parts_in_js_order(
 
     let mut part_ranges_shared: Vec<PartRange> = Vec::new();
     let mut parts_prefix_shared: Vec<PartRange> = Vec::new();
-    // PERF(port): temp_arena dropped — these arena-fed scratch lists could become
+    // PERF: these scratch lists could become
     // `bun_alloc::ArenaVec<'bump, PartRange>` with a threaded `&'bump Bump`
     // (introduces lifetimes on this fn + visitor). Profile if hot.
     for (index, chunk) in chunks.iter_mut().enumerate() {
@@ -47,12 +47,10 @@ pub fn find_imported_parts_in_js_order(
 ) -> Result<(), bun_core::Error> {
     let mut chunk_order_array: Vec<Order> =
         Vec::with_capacity(chunk.files_with_parts_in_chunk.count());
-    // PERF(port): this.arena() dropped — was per-LinkerContext arena; profile if hot.
     {
         let distances = this.graph.files.items_distance_from_entry_point();
         let stable_source_indices = this.graph.stable_source_indices.slice();
         for &source_index in chunk.files_with_parts_in_chunk.keys() {
-            // PERF(port): was appendAssumeCapacity
             chunk_order_array.push(Order {
                 source_index,
                 distance: distances[source_index as usize],
@@ -66,13 +64,13 @@ pub fn find_imported_parts_in_js_order(
     part_ranges_shared.clear();
     parts_prefix_shared.clear();
 
-    // PORT NOTE: reshaped for borrowck — capture before constructing visitor
+    // Capture before constructing the visitor (borrowck).
     let with_code_splitting = this.graph.code_splitting;
     let with_scb = this.graph.is_scb_bitset.bit_length > 0;
 
-    // PORT NOTE: the Zig visitor holds a *LinkerContext alongside SoA column slices
-    // borrowed from it, and mutates one column (`entry_point_chunk_index`). Rust
-    // borrowck forbids the latter through a shared `&LinkerContext`, so cache that
+    // The visitor holds a LinkerContext alongside SoA column slices
+    // borrowed from it, and mutates one column (`entry_point_chunk_index`).
+    // Borrowck forbids the latter through a shared `&LinkerContext`, so cache that
     // single mutable column as a raw `*mut [u32]` (provenance via the
     // `MultiArrayList.bytes: *mut u8` raw-pointer field — see
     // `scanImportsAndExports.rs` for the same pattern). All other `c.*` accesses
@@ -82,7 +80,6 @@ pub fn find_imported_parts_in_js_order(
 
     let (files_in_chunk_order, parts_in_chunk_order) = {
         let mut visitor = FindImportedPartsVisitor {
-            // PERF(port): files/visited were this.arena() arena — profile if hot.
             files: Vec::new(),
             part_ranges: core::mem::take(part_ranges_shared),
             parts_prefix: core::mem::take(parts_prefix_shared),
@@ -97,7 +94,6 @@ pub fn find_imported_parts_in_js_order(
             entry_point_chunk_indices,
         };
 
-        // PERF(port): was comptime bool dispatch (nested `inline else`) — profile if hot.
         match (with_code_splitting, with_scb) {
             (true, true) => run_visits::<true, true>(&mut visitor, &chunk_order_array),
             (true, false) => run_visits::<true, false>(&mut visitor, &chunk_order_array),
@@ -105,15 +101,13 @@ pub fn find_imported_parts_in_js_order(
             (false, false) => run_visits::<false, false>(&mut visitor, &chunk_order_array),
         }
 
-        // PERF(port): was this.arena() arena — profile if hot.
         let mut parts_in_chunk_order: Vec<PartRange> =
             Vec::with_capacity(visitor.part_ranges.len() + visitor.parts_prefix.len());
         // bun.concat: parts_prefix first, then part_ranges
         parts_in_chunk_order.extend_from_slice(&visitor.parts_prefix);
         parts_in_chunk_order.extend_from_slice(&visitor.part_ranges);
 
-        // Zig `defer { part_ranges_shared.* = visitor.part_ranges; ... visitor.visited.deinit(); }`
-        // No fallible ops remain past this point in Rust, so plain move-back is equivalent.
+        // No fallible ops remain past this point, so plain move-back works.
         *part_ranges_shared = visitor.part_ranges;
         *parts_prefix_shared = visitor.parts_prefix;
         // visitor.visited dropped implicitly
@@ -121,7 +115,6 @@ pub fn find_imported_parts_in_js_order(
         (visitor.files, parts_in_chunk_order)
     };
 
-    // PORT NOTE: `chunk.content.javascript` union field access → enum match.
     match &mut chunk.content {
         chunk::Content::Javascript(js) => {
             js.files_in_chunk_order = files_in_chunk_order.into_boxed_slice();
@@ -158,7 +151,7 @@ pub struct FindImportedPartsVisitor<'a, 'ctx> {
     pub entry_point: EntryPoint,
     pub chunk_index: u32,
     /// Raw column pointer into `c.graph.files` for the single mutable write in
-    /// `visit` (see PORT NOTE above).
+    /// `visit` (see the raw-pointer note above).
     entry_point_chunk_indices: *mut [u32],
 }
 
@@ -290,5 +283,3 @@ impl<'a, 'ctx> FindImportedPartsVisitor<'a, 'ctx> {
         }
     }
 }
-
-// ported from: src/bundler/linker_context/findAllImportedPartsInJSOrder.zig
diff --git a/src/bundler/linker_context/findImportedCSSFilesInJSOrder.rs b/src/bundler/linker_context/findImportedCSSFilesInJSOrder.rs
index 722922097c6..5b3caae4a73 100644
--- a/src/bundler/linker_context/findImportedCSSFilesInJSOrder.rs
+++ b/src/bundler/linker_context/findImportedCSSFilesInJSOrder.rs
@@ -30,7 +30,6 @@ pub fn find_imported_css_files_in_js_order(
     _temp: &Arena,
     entry_point: Index,
 ) -> Vec<Index> {
-    // PERF(port): was arena bulk-free (DynamicBitSet now Box<[usize]>-backed).
     let mut visited = BitSet::init_empty(this.graph.files.len()).expect("oom");
     let mut order: Vec<Index> = Vec::new();
 
@@ -38,8 +37,7 @@ pub fn find_imported_css_files_in_js_order(
     let all_loaders = this.parse_graph().input_files.items_loader();
     let all_parts = this.graph.ast.items_parts();
 
-    // Zig uses a local `struct { fn visit }.visit` to get a recursive local fn.
-    // Rust nested `fn` items can recurse directly.
+    // Nested `fn` item so the visitor can recurse directly.
     #[allow(clippy::too_many_arguments)]
     fn visit(
         c: &LinkerContext,
@@ -104,5 +102,3 @@ pub fn find_imported_css_files_in_js_order(
 
     order
 }
-
-// ported from: src/bundler/linker_context/findImportedCSSFilesInJSOrder.zig
diff --git a/src/bundler/linker_context/findImportedFilesInCSSOrder.rs b/src/bundler/linker_context/findImportedFilesInCSSOrder.rs
index f196118950b..9efe3423f9d 100644
--- a/src/bundler/linker_context/findImportedFilesInCSSOrder.rs
+++ b/src/bundler/linker_context/findImportedFilesInCSSOrder.rs
@@ -14,10 +14,9 @@ use crate::linker_context_mod::debug;
 use crate::{Index, LinkerContext};
 use bun_ast::Index as AstIndex;
 
-// PORT NOTE: Zig `entry.*` / `@memcpy` are bitwise copies of arena-backed
-// `CssImportOrder` values (the inner `Vec`s point into bump arenas and are
-// never individually freed). Rust's `Vec` has `Drop`, so a literal `*entry`
-// is not `Copy`. We replicate the Zig bitwise-copy semantics here.
+// `CssImportOrder` values are arena-backed (the inner `Vec`s point into bump
+// arenas and are never individually freed). Rust's `Vec` has `Drop`, so a
+// literal `*entry` is not `Copy`; we duplicate the values bitwise instead.
 // `conditions` slabs come from `deep_clone_conditions`, which allocates them
 // from the `LinkerGraph` arena (`graph.heap`). The `Vec` headers aliasing a
 // slab are `mem::forget`'d everywhere (`CssImportOrder::drop` + the
@@ -28,17 +27,16 @@ use bun_ast::Index as AstIndex;
 unsafe fn bitwise_copy<T>(src: &T) -> T {
     // SAFETY: `src` is a valid aligned `&T`; the `unsafe fn` contract requires
     // the caller to ensure the duplicated value's `Drop` is suppressed (arena
-    // ownership, see PORT NOTE above) so the aliased buffer is never freed twice.
+    // ownership, see the bitwise-copy note above) so the aliased buffer is never freed twice.
     unsafe { core::ptr::read(src) }
 }
 
-/// Zig: `order.len = wip_order.len; @memcpy(order.slice(), wip_order.slice());
-/// wip_order.clearRetainingCapacity();` — bitwise move of arena-backed entries
-/// from `wip` back into `order`'s buffer (which always has `cap >= wip.len`).
+/// Bitwise move of arena-backed entries from `wip` back into `order`'s
+/// buffer (which always has `cap >= wip.len`).
 #[inline]
 fn memcpy_and_reset(order: &mut Vec<CssImportOrder>, wip: &mut Vec<CssImportOrder>) {
     debug_assert!(order.capacity() >= wip.len());
-    // PORT NOTE: do not Drop `order`'s prior entries — they were already
+    // Do not Drop `order`'s prior entries — they were already
     // bitwise-copied into `wip` (see `bitwise_copy` callers above), so dropping
     // here would double-free their `conditions` buffers.
     // SAFETY: `set_len(0)` is unconditionally sound (0 ≤ capacity; shrinking
@@ -46,7 +44,7 @@ fn memcpy_and_reset(order: &mut Vec<CssImportOrder>, wip: &mut Vec<CssImportOrde
     unsafe { order.set_len(0) };
     // `Vec::append` = reserve (no-op given the debug_assert) +
     // `copy_nonoverlapping` into `order[0..]` + `wip.set_len(0)` — exactly the
-    // original `@memcpy` + `clearRetainingCapacity` sequence.
+    // bitwise move described above.
     order.append(wip);
 }
 
@@ -85,8 +83,8 @@ pub fn find_imported_files_in_css_order<'a>(
         css_asts: &'a [crate::bundled_ast::CssCol],
         all_import_records: &'a [bun_ast::import_record::List<'a>],
 
-        // PORT NOTE: Zig's `graph: *LinkerGraph` is never read in `visit()`;
-        // dropped here to avoid an aliasing `&mut this.graph` borrow against
+        // No `graph` field — `visit()` never reads it, and holding one would
+        // create an aliasing `&mut this.graph` borrow against
         // `arena`/`css_asts` (which already borrow `this.graph`).
         // `BackRef` (not `&'a Graph`) so the visitor's `'a` borrow stays
         // disjoint from `LinkerContext` (constructed from the raw `parse_graph`
@@ -156,9 +154,8 @@ pub fn find_imported_files_in_css_order<'a>(
             //     })
             // }
 
-            // PORT NOTE: `defer { _ = visitor.visited.pop(); }` — explicit pop at end.
-            // The defer is registered AFTER the `orelse return` above, so skipping the
-            // pop on that early-return path matches the original semantics.
+            // `visited.pop()` happens at the end of this function; the early
+            // return above intentionally skips it.
 
             // Iterate over the top-level "@import" rules
             let mut import_record_idx: usize = 0;
@@ -237,9 +234,8 @@ pub fn find_imported_files_in_css_order<'a>(
                         } else {
                             self.order.push(CssImportOrder {
                                 kind: CssImportOrderKind::ExternalPath(record.path),
-                                // PORT NOTE: Zig `wrapping_conditions.*` is a bitwise struct copy.
                                 // SAFETY: arena-backed `Vec` header; the pushed
-                                // `CssImportOrder` never drops it (see PORT NOTE at
+                                // `CssImportOrder` never drops it (see the note at
                                 // `bitwise_copy`), so the aliased buffer is freed once
                                 // with the arena.
                                 conditions: unsafe { bitwise_copy(wrapping_conditions) },
@@ -284,25 +280,23 @@ pub fn find_imported_files_in_css_order<'a>(
             }
             // Accumulate imports in depth-first postorder
             self.order.push(CssImportOrder {
-                // PORT NOTE: `crate::Index` (= `bun_ast::Index`) and the
+                // `crate::Index` (= `bun_ast::Index`) and the
                 // `bun_ast::Index` carried by `CssImportOrderKind::SourceIndex`
-                // are TYPE_ONLY mirrors of the same Zig `bun.ast.Index`;
+                // are the same underlying index type;
                 // both are `#[repr(transparent)]` over `u32`.
                 kind: CssImportOrderKind::SourceIndex(AstIndex(source_index.get())),
-                // PORT NOTE: Zig `wrapping_conditions.*` is a bitwise struct copy.
                 // SAFETY: arena-backed `Vec` header; `CssImportOrder` suppresses
-                // `Drop` on it (see PORT NOTE at `bitwise_copy`), so the aliased
+                // `Drop` on it (see the note at `bitwise_copy`), so the aliased
                 // buffer is freed once with the arena.
                 conditions: unsafe { bitwise_copy(wrapping_conditions) },
                 condition_import_records: Vec::new(),
             });
 
-            // PORT NOTE: explicit pop replacing `defer { _ = visitor.visited.pop(); }`
             let _ = self.visited.pop();
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — read MultiArrayList columns before constructing visitor.
+    // Read MultiArrayList columns before constructing the visitor (borrowck).
     let css_asts_slice: &[crate::bundled_ast::CssCol] = this.graph.ast.items_css();
     let all_import_records_slice = this.graph.ast.items_import_records();
     let arena = this.graph.arena();
@@ -387,11 +381,10 @@ pub fn find_imported_files_in_css_order<'a>(
         let mut external_path_duplicates: StringArrayHashMap<Vec<u32>> = StringArrayHashMap::new();
 
         let mut i: u32 = order.len() as u32;
-        // PORT NOTE: reshaped for borrowck — `order.at(i)` and `order.mut_(i)`
+        // Borrowck: `order.at(i)` and `order.mut_(i)`
         // cannot overlap, and `is_conditional_import_redundant` needs to read
         // both `entry.conditions` and `order.at(j).conditions`. Hold raw
-        // pointers into the Vec buffer (Zig used the same pattern via
-        // `*const` slice returns); `order.mut_(i)` only writes `.kind` and
+        // pointers into the Vec buffer; `order.mut_(i)` only writes `.kind` and
         // never reallocates, so the conditions pointer stays valid.
         let order_ptr = order.as_mut_ptr();
         'next_backward: while i != 0 {
@@ -413,7 +406,7 @@ pub fn find_imported_files_in_css_order<'a>(
                             // So we should keep the @layer rules so that the cascade ordering of layers
                             // is preserved
                             //
-                            // PORT NOTE: `crate::bun_css::LayerName` (lifetime-erased
+                            // `crate::bun_css::LayerName` (lifetime-erased
                             // shadow) and `::bun_css::LayerName` are distinct nominal
                             // types until the ungate shadow is removed; cast through
                             // `NonNull` to satisfy `Layers::borrow`.
@@ -458,7 +451,7 @@ pub fn find_imported_files_in_css_order<'a>(
     // copy instead of the last copy like other things in CSS.
     {
         struct DuplicateEntry {
-            // PORT NOTE: lifetime-erased slice header — borrows either
+            // Lifetime-erased slice header — borrows either
             // `css_asts[..].layer_names` (real `::bun_css::LayerName`) or
             // `Layers::inner()` (shadow `LayerName`). Both nominal types should
             // be reconciled; until then we compare via
@@ -564,7 +557,7 @@ pub fn find_imported_files_in_css_order<'a>(
             // layers_post_import
             let layers_key: *const [LayerName] = match &entry.kind {
                 CssImportOrderKind::SourceIndex(idx) => {
-                    // PORT NOTE: see LayerName nominal-type note above.
+                    // See the LayerName nominal-type note above.
                     std::ptr::from_ref::<[_]>(
                         css_asts[idx.get() as usize]
                             .as_deref()
@@ -579,7 +572,7 @@ pub fn find_imported_files_in_css_order<'a>(
             // SAFETY: every match arm yields a pointer to a live slice (`css_asts`
             // arena, `entry.kind`'s `Layers`, or a static empty); the source-index
             // arm is a `*const [_]`-level cast between layout-identical `LayerName`
-            // shadows (see PORT NOTE above). Valid for this loop iteration.
+            // shadows (see the note above). Valid for this loop iteration.
             let layers_key: &[LayerName] = unsafe { &*layers_key };
             let mut index: usize = 0;
             while index < layer_duplicates.len() as usize {
@@ -741,8 +734,6 @@ pub fn find_imported_files_in_css_order<'a>(
     order
 }
 
-/// Zig: `wrapping_conditions.deepCloneInfallible(visitor.arena)`.
-///
 /// The returned list is later bitwise-copied into `CssImportOrder` entries via
 /// `bitwise_copy(wrapping_conditions)`, so callers `mem::forget` the local after
 /// the recursive `visit()` to keep the aliased buffer alive. The slab is
@@ -772,15 +763,13 @@ fn deep_clone_conditions(list: &Vec<ImportConditions>, arena: &Arena) -> Vec<Imp
     }
 }
 
-/// Zig: `bun.handleOom(wrapping_import_records.clone(arena))` — shallow
-/// memcpy of `ImportRecord` values into a fresh allocation.
+/// Shallow copy of `ImportRecord` values into a fresh allocation.
 #[inline]
 fn shallow_clone_records(list: &Vec<ImportRecord>) -> Vec<ImportRecord> {
     let mut out = Vec::<ImportRecord>::init_capacity(list.len() as usize);
     for r in list.slice_const() {
-        // PORT NOTE: `ImportRecord` is plain-old-data in Zig (no destructor);
-        // `Path<'static>` slices borrow resolver storage. Bitwise copy matches
-        // the Zig `clone(arena)` semantics.
+        // `ImportRecord` is plain-old-data; its `Path<'static>` slices borrow
+        // resolver storage.
         // SAFETY: `ImportRecord` is POD (borrowed slices, no owning `Drop`); a
         // bitwise duplicate aliasing the same resolver storage is sound and
         // neither copy frees it.
@@ -919,11 +908,9 @@ impl CssOrderDebugStep {
 }
 
 fn debug_css_order(this: &LinkerContext, order: &Vec<CssImportOrder>, step: CssOrderDebugStep) {
-    // PERF(port): `step` was a comptime enum param; debug-only so demoted to runtime.
+    // `step` is a runtime param; this path is debug-only.
     #[cfg(debug_assertions)]
     {
-        // PORT NOTE: comptime `"BUN_DEBUG_CSS_ORDER_" ++ @tagName(step)` —
-        // runtime concat is fine here (debug-only).
         let tag = step.tag_name();
         let env_var = format!("BUN_DEBUG_CSS_ORDER_{}\0", tag);
         let enable_all = bun_core::env_var::BUN_DEBUG_CSS_ORDER
@@ -1014,5 +1001,3 @@ fn debug_css_order_impl(
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/findImportedFilesInCSSOrder.zig
diff --git a/src/bundler/linker_context/generateChunksInParallel.rs b/src/bundler/linker_context/generateChunksInParallel.rs
index 6a5954e67de..f77ca1dcbb4 100644
--- a/src/bundler/linker_context/generateChunksInParallel.rs
+++ b/src/bundler/linker_context/generateChunksInParallel.rs
@@ -5,8 +5,6 @@ use std::io::Write as _;
 use bun_collections::AutoBitSet;
 use bun_collections::StringArrayHashMap;
 use bun_collections::StringHashMap;
-// PORT NOTE: Zig `bun.threading.ThreadPool` is the *module*; `Batch`/`Task`
-// are free types in that module, not associated types on the struct.
 use bun_core::String as BunString;
 use bun_core::strings;
 use bun_paths as path;
@@ -35,21 +33,18 @@ use crate::linker_context::static_route_visitor::StaticRouteVisitor;
 use crate::linker_context::write_output_files_to_disk::write_output_files_to_disk;
 use crate::linker_context_mod::{GenerateChunkCtx, PendingPartRange};
 
-/// `bun.BYTECODE_EXTENSION` (bun.zig). Local because `bun_core` doesn't
-/// re-export it; matches `bun.rs::bytecode_extension`.
+/// Bytecode output file extension (also defined in `writeOutputFilesToDisk.rs`).
 const BYTECODE_EXTENSION: &str = ".jsc";
 
 bun_core::declare_scope!(PartRanges, hidden);
 
-// PORT NOTE: `Chunk.final_rel_path` / `metafile_chunk_json` are owned
-// `Box<[u8]>` (Zig stored them as linker-arena `[]const u8`); assignments
+// `Chunk.final_rel_path` / `metafile_chunk_json` are owned
+// `Box<[u8]>`; assignments
 // below move the boxed buffer directly — no lifetime promotion needed.
 use crate::linker_context_mod::debug;
 
-// TODO(port): Zig's return type is `!if (is_dev_server) void else ArrayList(OutputFile)`.
-// Rust const generics cannot vary the return type, so we always return
-// `Vec<OutputFile>` and the IS_DEV_SERVER path returns an empty Vec. Could be
-// split into two monomorphized wrappers if the unused Vec matters.
+// Const generics cannot vary the return type, so we always return
+// `Vec<OutputFile>` and the IS_DEV_SERVER path returns an empty Vec.
 pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     c: &mut LinkerContext,
     chunks: &mut [Chunk],
@@ -66,7 +61,6 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     {
         // TODO: instead of running a renamer per chunk, run it per file
         debug!(" START {} renamers", chunks.len());
-        // PORT NOTE: Zig `defer debug(...)` is moved to end-of-scope explicitly below.
         let ctx = GenerateChunkCtx {
             chunk: bun_ptr::BackRef::new_mut(&mut chunks[0]),
             // SAFETY: `c` is the live `&mut LinkerContext` for the link step;
@@ -84,7 +78,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     if c.source_maps.line_offset_tasks.len() > 0 {
         debug!(" START {} source maps (line offset)", chunks.len());
         c.source_maps.line_offset_wait_group.wait();
-        // PORT NOTE: `c.arena().free(...)` + `.len = 0` → Vec drop semantics.
+        // `c.arena().free(...)` + `.len = 0` → Vec drop semantics.
         c.source_maps.line_offset_tasks = Box::default();
         debug!("  DONE {} source maps (line offset)", chunks.len());
     }
@@ -107,7 +101,6 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
             debug!(" START {} prepare CSS ast (total count)", total_count);
 
             let mut batch = ThreadPoolLib::Batch::default();
-            // PERF(port): was c.arena().alloc — using Vec on global mimalloc
             let mut tasks: Vec<PrepareCssAstTask> = Vec::with_capacity(total_count);
             for chunk in chunks.iter_mut() {
                 if chunk.content.is_css() {
@@ -117,7 +110,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                             callback: prepare_css_asts_for_chunk,
                         },
                         chunk: std::ptr::from_mut::<Chunk>(chunk),
-                        // PORT NOTE: `PrepareCssAstTask.linker` is `*mut LinkerContext<'static>`
+                        // `PrepareCssAstTask.linker` is `*mut LinkerContext<'static>`
                         // (raw ptr is invariant); `.cast()` erases the inner `'a` to satisfy it.
                         linker: std::ptr::from_mut::<LinkerContext>(c).cast(),
                     });
@@ -142,14 +135,13 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     }
 
     {
-        // PERF(port): was c.arena().alloc — using Vec on global mimalloc
         let mut chunk_contexts: Vec<GenerateChunkCtx> = Vec::with_capacity(chunks.len());
 
         {
             let mut total_count: usize = 0;
-            // PORT NOTE: `GenerateChunkCtx` fields are raw pointers; capture them
+            // `GenerateChunkCtx` fields are raw pointers; capture them
             // before the `iter_mut()` borrow so the same `*mut [Chunk]` can be
-            // stored in every ctx (Zig stores `[]Chunk` by value).
+            // stored in every ctx.
             // SAFETY: `c` is the live `&mut LinkerContext` for the link step.
             let c_ref =
                 unsafe { bun_ptr::ParentRef::from_raw_mut(std::ptr::from_mut::<LinkerContext>(c)) };
@@ -186,7 +178,6 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
             debug_assert_eq!(chunks.len(), chunk_contexts.len());
 
             debug!(" START {} compiling part ranges", total_count);
-            // PERF(port): was c.arena().alloc — using Vec on global mimalloc.
             // Pre-reserved to `total_count` so pushes never reallocate; the
             // batch holds raw pointers into this buffer.
             let mut combined_part_ranges: Vec<PendingPartRange> = Vec::with_capacity(total_count);
@@ -223,8 +214,8 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                                     node: ThreadPoolLib::Node::default(),
                                     callback: generate_compile_result_for_js_chunk,
                                 },
-                                // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`
-                                // (Zig: `*GenerateChunkCtx`), conflating the borrow with
+                                // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`,
+                                // conflating the borrow with
                                 // LinkerContext's `'a`. Launder via raw ptr so borrowck
                                 // doesn't pin `chunk_contexts` for `'a`; tasks complete
                                 // before `chunk_contexts` drops (we `wait_for_all` below).
@@ -246,8 +237,8 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                                     node: ThreadPoolLib::Node::default(),
                                     callback: generate_compile_result_for_css_chunk,
                                 },
-                                // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`
-                                // (Zig: `*GenerateChunkCtx`), conflating the borrow with
+                                // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`,
+                                // conflating the borrow with
                                 // LinkerContext's `'a`. Launder via raw ptr so borrowck
                                 // doesn't pin `chunk_contexts` for `'a`; tasks complete
                                 // before `chunk_contexts` drops (we `wait_for_all` below).
@@ -268,8 +259,8 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                                 node: ThreadPoolLib::Node::default(),
                                 callback: generate_compile_result_for_html_chunk,
                             },
-                            // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`
-                            // (Zig: `*GenerateChunkCtx`), conflating the borrow with
+                            // SAFETY: `PendingPartRange.ctx` is `&'a GenerateChunkCtx<'a>`,
+                            // conflating the borrow with
                             // LinkerContext's `'a`. Launder via raw ptr so borrowck
                             // doesn't pin `chunk_contexts` for `'a`; tasks complete
                             // before `chunk_contexts` drops (we `wait_for_all` below).
@@ -353,7 +344,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
         // Compute the final hashes of each chunk, then use those to create the final
         // paths of each chunk. This can technically be done in parallel but it
         // probably doesn't matter so much because we're not hashing that much data.
-        // PORT NOTE: reshaped for borrowck — index loop so `chunks` can be passed
+        // Reshaped for borrowck — index loop so `chunks` can be passed
         // whole to `append_isolated_hashes_for_imported_chunks` and then indexed.
         for index in 0..chunks.len() {
             let mut hash = ContentHasher::default();
@@ -368,10 +359,10 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
             chunk.template.placeholder.hash = Some(hash.digest());
 
             let mut rel_path: Vec<u8> = Vec::new();
-            // PORT NOTE: use the byte-writer (`PathTemplate::print`) directly —
+            // Use the byte-writer (`PathTemplate::print`) directly —
             // routing through `Display`/`write!` goes via `from_utf8_lossy`,
             // which would replace non-UTF-8 dir bytes with U+FFFD and corrupt
-            // the output path. Zig's `std.fmt.allocPrint` writes raw bytes.
+            // the output path.
             chunk
                 .template
                 .print(&mut rel_path)
@@ -447,7 +438,6 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
 
             c.log_mut().add_error(None, bun_ast::Loc::EMPTY, msg);
 
-            // PORT NOTE: Zig `inline for` over a homogeneous tuple → const array + plain for.
             for (name, template) in [
                 ("entry", entry_naming),
                 ("chunk", chunk_naming),
@@ -508,7 +498,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                 let mut resolved: Vec<u8> = Vec::new();
                 resolved.extend_from_slice(normalizer[0]);
                 resolved.extend_from_slice(normalizer[1]);
-                let _ = unique_key_to_path.put(ch.unique_key, resolved.into_boxed_slice()); // OOM-only Result (Zig: catch unreachable)
+                let _ = unique_key_to_path.put(ch.unique_key, resolved.into_boxed_slice()); // OOM-only Result
             }
         }
 
@@ -557,14 +547,14 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
             // Free the ModuleInfo now that it's been serialized to bytes.
             // It was allocated with bun.default_allocator (not the arena),
             // so it must be explicitly destroyed.
-            // PORT NOTE: in Rust, dropping the Option<Box<ModuleInfo>> frees it.
+            // In Rust, dropping the Option<Box<ModuleInfo>> frees it.
             js.module_info = None;
         }
     }
 
     // Generate metafile JSON fragments for each chunk (after paths are resolved)
     if c.options.metafile {
-        // PORT NOTE: reshaped for borrowck — `generate_chunk_json` reads all chunks
+        // Reshaped for borrowck — `generate_chunk_json` reads all chunks
         // immutably while we write one chunk's `metafile_chunk_json`; index split.
         for i in 0..chunks.len() {
             let json =
@@ -605,8 +595,8 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     let bundler: &mut BundleV2 =
         unsafe { &mut *LinkerContext::bundle_v2_ptr(std::ptr::from_mut::<LinkerContext>(c)) };
     let mut static_route_visitor = StaticRouteVisitor {
-        // SAFETY: Zig stores `c: *LinkerContext` (raw). Launder via raw ptr so this
-        // long-lived shared borrow doesn't conflict with `c.log_disjoint()` inside
+        // SAFETY: launder via raw ptr so this long-lived
+        // shared borrow doesn't conflict with `c.log_disjoint()` inside
         // the chunk loop below. `c` outlives `static_route_visitor`.
         c: unsafe { bun_ptr::detach_lifetime_ref::<LinkerContext>(c) },
         cache: bun_collections::ArrayHashMap::default(),
@@ -618,16 +608,15 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
     // Closing tag escaping (</script → <\\/script, </style → <\\/style) is handled during
     // the HTML assembly step in codeWithSourceMapShifts, not here.
     //
-    // PORT NOTE: Zig `defer` frees each buffer with `Chunk.IntermediateOutput.allocatorForSize(len)`.
-    // Rust `Vec<Option<Box<[u8]>>>` frees via `Drop` (global mimalloc); if `allocatorForSize`
-    // returns a distinct arena for large buffers, matched-arena dealloc must be
-    // restored here.
+    // Buffers are freed via `Drop` (global mimalloc); if
+    // `Chunk::allocator_for_size` ever becomes size-dependent, matched-arena
+    // dealloc must be restored here.
     let mut standalone_chunk_contents: Option<Vec<Option<Box<[u8]>>>> = None;
 
     if is_standalone {
         let mut scc: Vec<Option<Box<[u8]>>> = vec![None; chunks.len()];
 
-        // PORT NOTE: `IntermediateOutput.code_standalone` reads `&Chunk` /
+        // `IntermediateOutput.code_standalone` reads `&Chunk` /
         // `&[Chunk]` (chunk is `&chunks[ci]`). Take `intermediate_output` out
         // by value so the only `&mut` is disjoint from those shared borrows.
         for ci in 0..chunks.len() {
@@ -675,7 +664,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
         )?;
     } else {
         // In-memory build (also used for standalone mode)
-        // PORT NOTE: `code()` / `code_standalone()` read `chunk` (= `&chunks[i]`)
+        // `code()` / `code_standalone()` read `chunk` (= `&chunks[i]`)
         // and the full `&[Chunk]` slice simultaneously. Iterate by index so both
         // can be safe shared reborrows of `chunks`; the only per-chunk mutation
         // is the `intermediate_output` take/restore, done via `chunks[i]`.
@@ -810,9 +799,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                             + a.len()
                             + b.len()
                             + b"\n".len();
-                        // TODO(port): Zig uses Chunk.IntermediateOutput.allocatorForSize(total_len)
                         let mut buf: Vec<u8> = Vec::with_capacity(total_len);
-                        // PERF(port): was appendSliceAssumeCapacity
                         buf.extend_from_slice(&code_result.buffer);
                         buf.extend_from_slice(source_map_start);
                         buf.extend_from_slice(a);
@@ -849,10 +836,8 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                     let source_map_start = b"//# sourceMappingURL=data:application/json;base64,";
                     let total_len =
                         code_result.buffer.len() + source_map_start.len() + encode_len + 1;
-                    // TODO(port): Zig uses Chunk.IntermediateOutput.allocatorForSize(total_len)
                     let mut buf: Vec<u8> = Vec::with_capacity(total_len);
 
-                    // PERF(port): was appendSliceAssumeCapacity
                     buf.extend_from_slice(&code_result.buffer);
                     buf.extend_from_slice(source_map_start);
 
@@ -970,7 +955,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                             }));
                         } else {
                             // an error
-                            // logger OOM-only (Zig: catch unreachable)
+                            // logger OOM-only
                             // Split-borrow — `static_route_visitor.c` holds a
                             // detached `&LinkerContext`; `log_disjoint` returns the
                             // disjoint `Transpiler.log` backref so no `&mut c` is
@@ -1107,8 +1092,7 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
                         None
                     },
                     referenced_css_chunks: match &chunk.content {
-                        // Zig: `@ptrCast(dupe(u32, js.css_chunks))` — `output_file::Index`
-                        // is `#[repr(transparent)]` over u32.
+                        // `output_file::Index` is `#[repr(transparent)]` over u32.
                         crate::chunk::Content::Javascript(js) => js
                             .css_chunks
                             .iter()
@@ -1164,13 +1148,10 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
         // Deinit dropped items to free their heap allocations (paths, buffers).
         let mut result = output_files.take();
         let mut write_idx: usize = 0;
-        // PORT NOTE: reshaped for borrowck — Zig iterates by pointer and assigns into items[write_idx].
         let len = result.len();
         for i in 0..len {
             if result[i].loader == Loader::Html {
                 result.swap(write_idx, i);
-                // PORT NOTE: Zig copies item then leaves original; using swap keeps semantics
-                // (the slot at `i` will be truncated/dropped below).
                 write_idx += 1;
             }
             // else: item at `i` will be dropped by truncate below (impl Drop handles deinit)
@@ -1184,9 +1165,6 @@ pub fn generate_chunks_in_parallel<const IS_DEV_SERVER: bool>(
 
 pub use crate::ThreadPool;
 
-// TODO(port): narrow error set
 use crate::EntryPoint;
 use crate::options::SourceMapOption;
 use crate::output_file::BakeExtra;
-
-// ported from: src/bundler/linker_context/generateChunksInParallel.zig
diff --git a/src/bundler/linker_context/generateCodeForFileInChunkJS.rs b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
index 72dcd1714bb..5970140bb64 100644
--- a/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
+++ b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
@@ -20,9 +20,6 @@ use bun_js_parser::lexer as js_lexer;
 use super::convert_stmts_for_chunk::convert_stmts_for_chunk;
 use super::convert_stmts_for_chunk_for_dev_server::convert_stmts_for_chunk_for_dev_server;
 
-// PORT NOTE: MultiArrayList column access — Zig `list.items(.field)` is mapped here as
-// `list.items_field()` method calls (codegen'd accessors on the SoA wrappers).
-
 #[allow(clippy::too_many_arguments)]
 pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
     c: &mut LinkerContext,
@@ -40,9 +37,9 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 ) -> js_printer::PrintResult {
     let source_index = part_range.source_index.get() as usize;
 
-    // PORT NOTE: reshaped for borrowck — grab raw pointers to the SoA columns up front so
+    // Grab raw pointers to the SoA columns up front so
     // subsequent `&mut c` borrows (convert_stmts_for_chunk, print_code_for_file_in_chunk_js)
-    // don't conflict. Matches Zig which slices once at the top.
+    // don't conflict.
     // SAFETY: the underlying MultiArrayList storage is not resized for the duration of this
     // function (linking has already sized everything).
     let parts: *mut [Part] = {
@@ -61,7 +58,7 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 
     // referencing everything by array makes the code a lot more annoying :(
     //
-    // PORT NOTE: `MultiArrayList::get` returns `ManuallyDrop<BundledAst>` — the
+    // `MultiArrayList::get` returns `ManuallyDrop<BundledAst>` — the
     // storage retains ownership of every Drop field (`parts`, `symbols`,
     // `named_imports`, …). The local `flags` mutation below is intentional and
     // stays scoped to this read view.
@@ -74,7 +71,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
     if c.options.output_format == OutputFormat::InternalBakeDev {
         'brk: {
             if part_range.source_index.is_runtime() {
-                // PERF(port): was @branchHint(.cold)
                 debug_assert!(c.dev_server.is_none());
                 break 'brk; // this is from `bun build --format=internal_bake_dev`
             }
@@ -96,7 +92,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
             let all_stmts_len = main_stmts_len + stmts.outside_wrapper_prefix.len() + 1;
 
             stmts.all_stmts.reserve(all_stmts_len);
-            // PERF(port): was appendSliceAssumeCapacity
             stmts
                 .all_stmts
                 .extend_from_slice(stmts.inside_wrapper_prefix.stmts.as_slice());
@@ -104,10 +99,10 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                 .all_stmts
                 .extend_from_slice(stmts.inside_wrapper_suffix.as_slice());
 
-            // PORT NOTE: reshaped for borrowck — capture pointer/len now, re-slice after pushes.
+            // Capture pointer/len now, re-slice after pushes (borrowck).
             // SAFETY: `inner` aliases the first `main_stmts_len` elements of `all_stmts`;
             // subsequent pushes only append past this range and capacity was reserved above
-            // so no reallocation occurs. Matches Zig which slices then continues appending.
+            // so no reallocation occurs.
             let inner = bun_ast::StoreSlice::new_mut(
                 &mut stmts.all_stmts.as_mut_slice()[0..main_stmts_len],
             );
@@ -148,7 +143,7 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                 });
             }
 
-            // PERF(port): was temp_arena.dupe — `G::Arg` is not Copy in Rust
+            // `G::Arg` is not `Copy`; duplicate the args element-wise.
             let dup_args: &mut [G::Arg] = {
                 let mut v = bun_alloc::ArenaVec::with_capacity_in(
                     clousure_args.const_slice().len(),
@@ -160,7 +155,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                 v.into_bump_slice_mut()
             };
 
-            // PERF(port): was appendAssumeCapacity
             stmts.all_stmts.push(Stmt::allocate_expr(
                 temp_arena,
                 Expr::init(
@@ -177,7 +171,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                     bun_ast::Loc::EMPTY,
                 ),
             ));
-            // PERF(port): was appendSliceAssumeCapacity
             stmts
                 .all_stmts
                 .extend_from_slice(stmts.outside_wrapper_prefix.as_slice());
@@ -187,8 +180,7 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
             // TODO: there is a weird edge case where the pretty path is not computed
             // it does not reproduce when debugging.
             let source_ref = c.get_source(source_index as u32);
-            // PORT NOTE: reshaped for borrowck — Zig copies the `Source` by value,
-            // mutates `.path`, and passes `&source`. `bun_ast::Source` is not `Clone`
+            // `bun_ast::Source` is not `Clone`
             // (its `Cow` fields would deep-copy `Owned` data); instead, build a
             // borrowed-field shadow only when the path needs fixing.
             let source_storage: bun_ast::Source;
@@ -309,7 +301,7 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 
         match flags.wrap {
             WrapKind::Esm => {
-                // PORT NOTE: reshaped for borrowck — append_slice borrows `stmts` mutably while
+                // Borrowck: `append_slice` borrows `stmts` mutably while
                 // also reading from a sibling field.
                 let suffix = core::mem::take(&mut stmts.inside_wrapper_suffix);
                 stmts.append_slice(StmtListWhich::OutsideWrapperPrefix, suffix.as_slice());
@@ -399,9 +391,8 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 
             // Be careful: the top-level value in a JSON file is not necessarily an object
             if let ExprData::EObject(e_object) = default_expr.data {
-                // PORT NOTE: Zig `properties.clone(temp_arena)` is a memcpy into the
-                // temp arena. `G::Property` is not `Clone` (it embeds a `Vec`), so
-                // mirror the Zig bitwise copy directly. JSON object properties carry no
+                // `G::Property` is not `Clone` (it embeds a `Vec`), so
+                // copy the properties bitwise. JSON object properties carry no
                 // owned heap data (`ts_decorators` is always empty, `class_static_block`
                 // is `None`), so the duplicated bits do not alias any allocation.
                 let src_len = e_object.properties.len();
@@ -519,7 +510,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
     stmts
         .all_stmts
         .reserve(stmts.inside_wrapper_prefix.stmts.len() + stmts.inside_wrapper_suffix.len());
-    // PERF(port): was appendSliceAssumeCapacity
     stmts
         .all_stmts
         .extend_from_slice(stmts.inside_wrapper_prefix.stmts.as_slice());
@@ -557,7 +547,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                     .flags
                     .intersects(AstFlags::USES_MODULE_REF | AstFlags::USES_EXPORTS_REF)
                 {
-                    // PERF(port): was appendAssumeCapacity
                     args.push(G::Arg {
                         binding: Binding::alloc(
                             temp_arena,
@@ -570,7 +559,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                     });
 
                     if ast.flags.contains(AstFlags::USES_MODULE_REF) {
-                        // PERF(port): was appendAssumeCapacity
                         args.push(G::Arg {
                             binding: Binding::alloc(
                                 temp_arena,
@@ -692,7 +680,7 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                 // Hoist all top-level "var" and "function" declarations out of the closure
                 {
                     let mut end: usize = 0;
-                    // PORT NOTE: reshaped for borrowck — iterate by index since we mutate
+                    // Iterate by index since we mutate
                     // `inner_stmts[end]` and call `stmts.append(...)` inside the loop.
                     'hoist: for i in 0..stmts.all_stmts.len() {
                         let stmt = stmts.all_stmts[i];
@@ -751,10 +739,9 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
                                 continue 'hoist;
                             }
                             StmtData::SClass(mut class) => 'stmt: {
-                                // PORT NOTE: `class` is `StoreRef<S::Class>` — an arena-owned pointer.
+                                // `class` is `StoreRef<S::Class>` — an arena-owned pointer.
                                 // `&mut class.class` (via DerefMut) yields a `&mut G::Class` into arena
-                                // memory, so wrapping it in a StoreRef for `EClass` is sound and matches
-                                // Zig's `&class.class`.
+                                // memory, so wrapping it in a StoreRef for `EClass` is sound.
                                 if class.class.can_be_moved() {
                                     stmts.append(StmtListWhich::OutsideWrapperPrefix, stmt);
                                     continue 'hoist;
@@ -1056,8 +1043,6 @@ impl DeclCollector {
         if name.is_empty() {
             return;
         }
-        // Zig: `catch return` — silently drop on alloc failure. With std Vec
-        // push aborts on OOM, so there is nothing to catch.
         self.decls.push(DeclInfo {
             name: name.to_vec().into_boxed_slice(),
             kind,
@@ -1073,7 +1058,7 @@ fn merge_adjacent_local_stmts(stmts: &mut Vec<Stmt>, _arena: &Bump) {
     let mut did_merge_with_previous_local = false;
     let mut end: usize = 1;
 
-    // PORT NOTE: reshaped for borrowck — iterate by index because we read `stmts[i]`
+    // Iterate by index because we read `stmts[i]`
     // and write `stmts[end - 1]` / `stmts[end]` in the same loop body.
     for i in 1..stmts.len() {
         let stmt = stmts[i];
@@ -1092,7 +1077,6 @@ fn merge_adjacent_local_stmts(stmts: &mut Vec<Stmt>, _arena: &Bump) {
 
                         let mut clone =
                             Vec::<G::Decl>::init_capacity(before.decls.len() + after.decls.len());
-                        // PERF(port): was appendSliceAssumeCapacity
                         clone.append_slice_assume_capacity(before.decls.slice());
                         clone.append_slice_assume_capacity(after.decls.slice());
                         // we must clone instead of overwrite in-place incase the same S.Local is used across threads
@@ -1122,10 +1106,8 @@ fn merge_adjacent_local_stmts(stmts: &mut Vec<Stmt>, _arena: &Bump) {
     stmts.truncate(end);
 }
 
-// Type aliases / re-imports for readability of match arms (mirrors Zig naming).
+// Type aliases / re-imports for readability of match arms.
 use bun_ast::LocalKind;
 use bun_ast::binding::Data as BindingData;
 use bun_ast::expr::Data as ExprData;
 use bun_ast::stmt::Data as StmtData;
-
-// ported from: src/bundler/linker_context/generateCodeForFileInChunkJS.zig
diff --git a/src/bundler/linker_context/generateCodeForLazyExport.rs b/src/bundler/linker_context/generateCodeForLazyExport.rs
index cb3d546178d..6311bc6aade 100644
--- a/src/bundler/linker_context/generateCodeForLazyExport.rs
+++ b/src/bundler/linker_context/generateCodeForLazyExport.rs
@@ -37,7 +37,7 @@ pub fn generate_code_for_lazy_export(
     source_index: IndexInt,
 ) -> Result<(), AllocError> {
     let exports_kind = this.graph.ast.items_exports_kind()[source_index as usize];
-    // PORT NOTE: reshaped for borrowck — take `parts` as a raw pointer *before* the
+    // Take `parts` as a raw pointer *before* the
     // long-lived immutable `items_css()` borrow below; re-borrowed again later as needed.
     let parts: *mut [Part] = this.graph.ast.items_parts_mut()[source_index as usize].as_mut_slice();
     // SAFETY: parse_graph backref; raw deref because `all_sources` is held
@@ -100,7 +100,6 @@ pub fn generate_code_for_lazy_export(
 
             struct Visitor<'a> {
                 inner_visited: &'a mut BitSet,
-                // Zig: `std.AutoArrayHashMap(Ref, void)` → `ArrayHashMap` per collections map.
                 composes_visited: &'a mut ArrayHashMap<Ref, ()>,
                 parts: &'a mut Vec<E::TemplatePart>,
                 all_import_records: &'a [bun_ast::import_record::List<'a>],
@@ -111,7 +110,6 @@ pub fn generate_code_for_lazy_export(
                 source_index: IndexInt,
                 log: &'a mut Log,
                 loc: Loc,
-                // PERF(port): was `std.mem.Allocator` (arena) — bundler is an AST crate; thread `&'bump Bump`.
                 arena: &'a Arena,
             }
 
@@ -132,7 +130,6 @@ pub fn generate_code_for_lazy_export(
                     }
 
                     self.visit_composes(ast, ref_, idx);
-                    // PERF(port): was assume-OOM `catch |err| bun.handleOom(err)`; Vec::push aborts on OOM.
                     self.parts.push(E::TemplatePart {
                         value: Expr::init(
                             E::NameOfSymbol {
@@ -170,7 +167,6 @@ pub fn generate_code_for_lazy_export(
                         .unwrap()
                         .loc;
 
-                    // PORT NOTE: was `catch |err| bun.handleOom(err)` — crash on OOM.
                     self.log.add_range_error_fmt_with_note(
                         Some(&self.all_sources[idx as usize]),
                         bun_ast::Range { loc: compose_loc, ..Default::default() },
@@ -306,9 +302,8 @@ pub fn generate_code_for_lazy_export(
                 }
             }
 
-            // PORT NOTE: Zig left `parts: undefined` and rebound per-iteration; Rust
-            // forbids uninit refs, so the Visitor is constructed inside the loop with
-            // a fresh `parts` borrow each time (reshaped for borrowck).
+            // The Visitor is constructed inside the loop with a fresh `parts`
+            // borrow each time (reshaped for borrowck).
             let all_symbols = this.graph.ast.items_symbols();
             // SAFETY: `LinkerContext::arena()` returns a stable `&Arena` valid for the
             // link pass; detach via raw-pointer round-trip so it doesn't hold a `&self`
@@ -319,7 +314,6 @@ pub fn generate_code_for_lazy_export(
                 let ref_ = entry.ref_;
                 debug_assert!(ref_.inner_index() < symbols.len() as u32);
 
-                // PERF(port): was arena-backed ArrayList (no deinit; `.items` moved into E.Template).
                 let mut template_parts: Vec<E::TemplatePart> = Vec::new();
                 let mut value = Expr::init(
                     E::NameOfSymbol {
@@ -355,8 +349,7 @@ pub fn generate_code_for_lazy_export(
                         tail_loc: stmt.loc,
                         tail: E::TemplateContents::Cooked(E::String::init(b"")),
                     });
-                    // PORT NOTE: Zig used an arena-backed ArrayList and moved `.items`
-                    // into `E.Template`; mirror that by moving into the linker arena
+                    // Move the parts into the linker arena
                     // (freed when the linker arena drops).
                     let parts_slice =
                         bun_ast::StoreSlice::new_mut(arena.alloc_slice_fill_iter(template_parts));
@@ -430,16 +423,14 @@ pub fn generate_code_for_lazy_export(
         _ => {
             // Otherwise, generate ES6 export statements. These are added as additional
             // parts so they can be tree shaken individually.
-            // PORT NOTE: Zig `part.stmts.len = 0` truncates the slice.
             part.stmts = bun_ast::StoreSlice::EMPTY;
 
             if let ExprData::EObject(e_object) = &expr.data {
                 for property in e_object.properties.slice() {
                     let _: &G::Property = property;
-                    // PORT NOTE: `Expr`/`ExprData`/`StoreRef<_>` are `Copy`. Copy `key` out so
+                    // `Expr`/`ExprData`/`StoreRef<_>` are `Copy`. Copy `key` out so
                     // `key_str: StoreRef<E::EString>` is a mutable local — `slice()` resolves
-                    // the rope in-place via `DerefMut` into the arena slot (matches Zig's
-                    // `property.key.?.data.e_string.slice(...)` which takes `*String`).
+                    // the rope in-place via `DerefMut` into the arena slot.
                     let Some(key) = property.key else { continue };
                     let ExprData::EString(mut key_str) = key.data else {
                         continue;
@@ -476,7 +467,6 @@ pub fn generate_code_for_lazy_export(
                     // happened yet). So we need to wait until after tree shaking happens.
                     let generated =
                         this.generate_named_export_in_file(source_index, module_ref, name, name)?;
-                    // PERF(port): was `this.arena().alloc(Stmt, 1)` (arena).
                     let new_stmts: &mut [Stmt] =
                         alloc.alloc_slice_fill_iter(core::iter::once(Stmt::alloc(
                             S::Local {
@@ -493,7 +483,7 @@ pub fn generate_code_for_lazy_export(
                             },
                             key.loc,
                         )));
-                    // PORT NOTE: `parts.ptr[generated[1]]` — re-borrow `parts` here for borrowck.
+                    // Re-borrow `parts` here for borrowck.
                     let parts =
                         this.graph.ast.items_parts_mut()[source_index as usize].as_mut_slice();
                     parts[generated.1 as usize].stmts = bun_ast::StoreSlice::new_mut(new_stmts);
@@ -501,7 +491,6 @@ pub fn generate_code_for_lazy_export(
             }
 
             {
-                // PERF(port): was `std.fmt.allocPrint` into arena; building into Vec<u8> then arena-dupe.
                 let mut name_buf: Vec<u8> = Vec::new();
                 write!(
                     &mut name_buf,
@@ -542,5 +531,3 @@ pub fn generate_code_for_lazy_export(
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/generateCodeForLazyExport.zig
diff --git a/src/bundler/linker_context/generateCompileResultForCssChunk.rs b/src/bundler/linker_context/generateCompileResultForCssChunk.rs
index aa6ae59cf0d..72fe9ec8708 100644
--- a/src/bundler/linker_context/generateCompileResultForCssChunk.rs
+++ b/src/bundler/linker_context/generateCompileResultForCssChunk.rs
@@ -77,14 +77,12 @@ fn generate_compile_result_for_css_chunk_impl(
     // borrow via `BackRef::get` is fine. The heap is pinned for the worker's
     // lifetime; see `Worker::arena`.
     let arena = worker.arena.get();
-    // PERF(port): was arena bulk-free (worker.temporary_arena.reset(.retain_capacity)).
     let _arena_reset = scopeguard::guard(&mut worker.temporary_arena, |arena| {
         // temporary_arena is initialized in Worker::create before any task runs.
         if let Some(a) = arena.as_mut() {
             a.reset();
         }
     });
-    // TODO(port): worker.arena threading — css crate is an AST crate and may want &'bump Bump
     let mut allocating_writer: Vec<u8> = Vec::new();
 
     let Content::Css(css_content) = &chunk.content else {
@@ -230,7 +228,7 @@ fn generate_compile_result_for_css_chunk_impl(
             if !output.is_empty() {
                 // CONCURRENCY: key set is frozen before parallel codegen; take a
                 // shared `&AtomicUsize` so concurrent workers updating the same
-                // source counter never alias a `&mut` (Zig: @atomicRmw .Add .monotonic).
+                // source counter never alias a `&mut`.
                 if let Some(bytes) = chunk.files_with_parts_in_chunk.get(&idx.get()) {
                     let _ = bytes.fetch_add(output.len(), Ordering::Relaxed);
                 }
@@ -247,5 +245,3 @@ fn generate_compile_result_for_css_chunk_impl(
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/generateCompileResultForCssChunk.zig
diff --git a/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs b/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
index e8fb88000af..dcd297081a5 100644
--- a/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
+++ b/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
@@ -240,7 +240,6 @@ impl<'a> HTMLLoader<'a> {
         }
         self.added_head_tags = true;
 
-        // PERF(port): was stack-fallback (std.heap.stackFallback(256))
         let slices = self.get_head_tags();
         for slice in slices.as_slice() {
             end_tag.before(slice, true)?;
@@ -255,7 +254,6 @@ impl<'a> HTMLLoader<'a> {
         }
         self.added_body_script = true;
 
-        // PERF(port): was stack-fallback (std.heap.stackFallback(256))
         // SAFETY: `self.chunks` raw `*mut [Chunk]` valid for the link step; sole live `&mut`.
         let chunks = unsafe { &mut *self.chunks };
         if let Some(js_chunk) = self.chunk.get_js_chunk_for_html(chunks) {
@@ -272,7 +270,6 @@ impl<'a> HTMLLoader<'a> {
     }
 
     fn get_head_tags(&self) -> Vec<Vec<u8>> {
-        // PERF(port): was stack-fallback arena; now heap Vec<u8>
         let mut array: Vec<Vec<u8>> = Vec::with_capacity(2);
         // `self.chunk` is a `BackRef` (safe `Deref`).
         let chunk: &Chunk = &self.chunk;
@@ -401,10 +398,11 @@ fn generate_compile_result_for_html_chunk_impl<'a>(
     let import_records = c.graph.ast.items_import_records();
     let source_index = chunk.entry_point.source_index();
 
-    // HTML bundles for dev server must be allocated to it, as it must outlive
-    // the bundle task. See `DevServer.RouteBundle.HTML.bundled_html_text`
-    // TODO(port): Zig used `dev.arena()` vs `worker.arena` to control output ownership.
-    // In Rust with global mimalloc this distinction collapses; verify DevServer ownership.
+    // HTML bundles for the dev server must outlive the bundle task (see
+    // `DevServer.RouteBundle.HTML.bundled_html_text`). The output is built in a
+    // plain `Vec<u8>` and returned as an owned `Box<[u8]>` inside
+    // `CompileResult::Html`, so it lives as long as whoever holds the
+    // `CompileResult` — no arena-lifetime distinction needed.
 
     // `c.log` is now `*mut Log` (raw backref); copy directly. The HTMLLoader.log
     // field is currently dead_code, so no write actually occurs through this
@@ -462,8 +460,7 @@ fn generate_compile_result_for_html_chunk_impl<'a>(
     } else {
         'brk: {
             if !html_loader.added_head_tags || !html_loader.added_body_script {
-                // PERF(port): @branchHint(.cold) — this is if the document is missing all head, body, and html elements.
-                // PERF(port): was stack-fallback (std.heap.stackFallback(256))
+                // Cold path: the document is missing all of the head, body, and html elements.
                 if !html_loader.added_head_tags {
                     let slices = html_loader.get_head_tags();
                     for slice in slices.as_slice() {
@@ -502,5 +499,3 @@ fn generate_compile_result_for_html_chunk_impl<'a>(
 }
 
 pub use crate::{DeferredBatchTask, ParseTask, ThreadPool};
-
-// ported from: src/bundler/linker_context/generateCompileResultForHtmlChunk.zig
diff --git a/src/bundler/linker_context/generateCompileResultForJSChunk.rs b/src/bundler/linker_context/generateCompileResultForJSChunk.rs
index f33d4844344..4d5f83b3db9 100644
--- a/src/bundler/linker_context/generateCompileResultForJSChunk.rs
+++ b/src/bundler/linker_context/generateCompileResultForJSChunk.rs
@@ -34,7 +34,9 @@ pub unsafe fn generate_compile_result_for_js_chunk(task: *mut ThreadPoolLib::Tas
     let (part_range, c_ptr, chunk_ptr, mut worker) =
         unsafe { crate::linker_context_mod::pending_part_range_prologue(task) };
 
-    // TODO(port): Environment.show_crash_trace — exact cfg key TBD; using feature = "show_crash_trace"
+    // Wired as a cargo feature through bun_runtime → bun_bundler →
+    // bun_crash_handler. No build profile enables the feature by
+    // default — it must be opted into explicitly.
     #[cfg(feature = "show_crash_trace")]
     let _crash_guard = {
         // `part_range.ctx.{c,chunk}` are `ParentRef`/`BackRef` — safe shared
@@ -52,7 +54,7 @@ pub unsafe fn generate_compile_result_for_js_chunk(task: *mut ThreadPoolLib::Tas
             [part_range.part_range.source_index.get() as usize]
             .path;
         if bun_core::debug_flags::has_print_breakpoint(&path.pretty, &path.text) {
-            // @breakpoint() in Zig — no stable Rust equivalent; left as no-op
+            // No stable breakpoint intrinsic; left as a no-op.
         }
     }
 
@@ -62,7 +64,8 @@ pub unsafe fn generate_compile_result_for_js_chunk(task: *mut ThreadPoolLib::Tas
         // borrows below are scoped to the impl call so they do not overlap the
         // raw slot write that follows. (Peer tasks still hold their own `&mut`
         // views into the same `LinkerContext`/`Chunk` for read-only printer use —
-        // see TODO(ub-audit) on `unsafe impl Sync for Chunk`.)
+        // see the renamer caveat / SAFETY note on `unsafe impl Sync for
+        // Chunk` in Chunk.rs.)
         let c_mut: &mut LinkerContext = unsafe { &mut *c_ptr };
         // SAFETY: same mutable-provenance / disjoint-write contract as `c_ptr` above.
         let chunk_mut: &mut Chunk = unsafe { &mut *chunk_ptr };
@@ -89,13 +92,11 @@ fn generate_compile_result_for_js_chunk_impl(
     let _trace = bun_core::perf::trace("Bundler.generateCodeForFileInChunkJS");
     // `defer trace.end()` → handled by Drop on _trace
 
-    // Client and server bundles for Bake must be globally allocated, as they
-    // must outlive the bundle task.
-    // TODO(port): runtime arena selection (dev_server vs default) —
-    // `DevServerHandle` does not yet expose an arena handle, and
-    // `BufferWriter::init()` / `DeclCollector.decls` use the global arena
-    // in the Rust port. Once `dispatch::DevServerHandle::arena()` exists,
-    // thread it here so dev-server bundles outlive the worker arena.
+    // Client and server bundles for Bake must outlive the bundle task.
+    // `BufferWriter::init()` output is allocated from the global heap and
+    // `DeclCollector.decls` from the worker heap (`worker.arena`, alive until
+    // bundle teardown) — both outlive the task's CompileResult consumption,
+    // so a per-dev-server arena would only be a perf optimization.
     let _ = c.dev_server;
 
     // temporary_arena / stmt_list are initialized in Worker::create before any task runs.
@@ -104,14 +105,13 @@ fn generate_compile_result_for_js_chunk_impl(
         .as_mut()
         .expect("Worker.temporary_arena set in create()");
     let mut buffer_writer = js_printer::BufferWriter::init();
-    // Zig: `defer _ = arena.reset(.retain_capacity)` on a `std.heap.ArenaAllocator`
-    // (O(1) bump rewind, chunks retained). `temporary_arena` is a `MimallocArena`
+    // `temporary_arena` is a `MimallocArena`
     // here because `temp_arena` flows into `Stmt::allocate`/`Expr::allocate`/
     // `Binding::alloc`/`ArenaVec`, all of which take `&MimallocArena` concretely;
     // a plain `reset()` would be `mi_heap_destroy + mi_heap_new` *per part_range*
-    // (perf-probe: 46× for one elysia build). Use `reset_retain_with_limit` — the
-    // codebase's mapping for Zig's `.retain_*` modes (see `ModuleLoader`'s
-    // `transpile_source_code_arena`): keep the heap warm across part_ranges and
+    // (perf-probe: 46× for one elysia build). Use `reset_retain_with_limit`
+    // (see `ModuleLoader`'s `transpile_source_code_arena`):
+    // keep the heap warm across part_ranges and
     // only pay the destroy+new round-trip once accumulated scratch exceeds the
     // limit. 8 MiB matches the module-arena precedent and comfortably covers a
     // worker's full part_range set for typical bundles, so this is ~one
@@ -151,9 +151,8 @@ fn generate_compile_result_for_js_chunk_impl(
     let collect_decls = c.options.generate_bytecode_cache
         && c.options.output_format == OutputFormat::Esm
         && c.options.compile;
-    // PORT NOTE: Zig threaded `arena` (dev_server or default) into
-    // DeclCollector; the Rust DeclCollector wants `*const Arena`. Use the
-    // worker heap for now (see TODO above re: dev_server arena).
+    // DeclCollector wants `*const Arena` and uses the worker heap (see
+    // the dev-server allocation note above).
     let mut dc = DeclCollector {
         arena: worker.arena.as_ptr(),
         ..Default::default()
@@ -164,8 +163,7 @@ fn generate_compile_result_for_js_chunk_impl(
     // a direct shared borrow is fine. Heap is pinned; see `Worker::arena`.
     let worker_alloc = worker.arena.get();
     // SAFETY: split borrow of `chunk` — `generate_code_for_file_in_chunk_js` never
-    // touches `chunk.renamer` through its `chunk` parameter (Zig passes the renamer
-    // union by value alongside `*Chunk`); take a raw-ptr view so borrowck doesn't
+    // touches `chunk.renamer` through its `chunk` parameter; take a raw-ptr view so borrowck doesn't
     // see two overlapping `&mut chunk` borrows.
     let renamer_ptr: *mut crate::bun_renamer::ChunkRenamer = core::ptr::addr_of_mut!(chunk.renamer);
     let result = generate_code_for_file_in_chunk_js(
@@ -218,5 +216,3 @@ fn generate_compile_result_for_js_chunk_impl(
 
 pub use crate::DeferredBatchTask::DeferredBatchTask;
 pub use crate::ParseTask;
-
-// ported from: src/bundler/linker_context/generateCompileResultForJSChunk.zig
diff --git a/src/bundler/linker_context/postProcessCSSChunk.rs b/src/bundler/linker_context/postProcessCSSChunk.rs
index 39867549c37..a774121cbc3 100644
--- a/src/bundler/linker_context/postProcessCSSChunk.rs
+++ b/src/bundler/linker_context/postProcessCSSChunk.rs
@@ -14,10 +14,8 @@ pub fn post_process_css_chunk(
     worker: &mut thread_pool::Worker,
     chunk: &mut Chunk,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let c = ctx.c();
-    // TODO(port): worker.arena is a per-worker arena — thread `&'bump Bump`.
-    // PORT NOTE: avoid FRU `..Default::default()` — StringJoiner impls Drop (E0509).
+    // Avoid FRU `..Default::default()` — StringJoiner impls Drop (E0509).
     let mut j = StringJoiner::default();
     j.watcher = Watcher {
         input: chunk.unique_key,
@@ -99,7 +97,7 @@ pub fn post_process_css_chunk(
         }
 
         // Save the offset to the start of the stored JavaScript
-        // PORT NOTE: Zig `j.push(.., bun.default_allocator)` — code() borrows from
+        // code() borrows from
         // compile_results which outlives the joiner; treat as static (no copy/free).
         j.push_static(compile_result.code());
 
@@ -110,7 +108,7 @@ pub fn post_process_css_chunk(
                         // SAFETY: bitwise alias of `chunk.compile_results_for_chunk`
                         // (read-only and outlives this fn); see `postProcessJSChunk.rs`.
                         source_map_chunk: unsafe { source_map_chunk.alias() },
-                        // Zig reads `.value` payload directly — guaranteed `Value` here
+                        // Guaranteed `Value` here
                         // because `source_maps != None` implies `line_offset` was
                         // initialised to `Value(_)` above.
                         generated_offset: match line_offset {
@@ -174,5 +172,3 @@ pub fn post_process_css_chunk(
 
     Ok(())
 }
-
-// ported from: src/bundler/linker_context/postProcessCSSChunk.zig
diff --git a/src/bundler/linker_context/postProcessHTMLChunk.rs b/src/bundler/linker_context/postProcessHTMLChunk.rs
index 8841bcf5742..e2166e46663 100644
--- a/src/bundler/linker_context/postProcessHTMLChunk.rs
+++ b/src/bundler/linker_context/postProcessHTMLChunk.rs
@@ -9,7 +9,8 @@ pub fn post_process_html_chunk(
     worker: &mut thread_pool::Worker,
     chunk: &mut Chunk,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set — Zig `!void` but body has zero `try` sites (inferred-empty)
+    // The body has no fallible sites; the Result signature matches the other
+    // `post_process_*_chunk` callees dispatched from `generate_chunk`.
     // This is where we split output into pieces
     let c = ctx.c();
     // E0509: StringJoiner has Drop, so FRU `..Default::default()` is illegal — assign field instead.
@@ -22,8 +23,8 @@ pub fn post_process_html_chunk(
     let compile_results = &chunk.compile_results_for_chunk;
 
     for compile_result in compile_results.iter() {
-        // PORT NOTE: Zig `j.push(.., bun.default_allocator)` — code() borrows from
-        // chunk.compile_results_for_chunk which outlives `j.done()`; arena arg dropped.
+        // code() borrows from
+        // chunk.compile_results_for_chunk which outlives `j.done()`.
         j.push_static(compile_result.code());
     }
 
@@ -41,13 +42,11 @@ pub fn post_process_html_chunk(
         alloc,
         &mut j,
         ctx.chunks.len() as u32, // @truncate
-    )); // Zig: `catch |err| bun.handleOom(err)`
+    ));
 
-    // PORT NOTE: reshaped for borrowck (compute hash before assigning into chunk)
+    // Reshaped for borrowck (compute hash before assigning into chunk)
     let isolated_hash = c.generate_isolated_hash(chunk, alloc);
     chunk.isolated_hash = isolated_hash;
 
     Ok(())
 }
-
-// ported from: src/bundler/linker_context/postProcessHTMLChunk.zig
diff --git a/src/bundler/linker_context/postProcessJSChunk.rs b/src/bundler/linker_context/postProcessJSChunk.rs
index d4d278f6e3f..3413df73a69 100644
--- a/src/bundler/linker_context/postProcessJSChunk.rs
+++ b/src/bundler/linker_context/postProcessJSChunk.rs
@@ -27,9 +27,8 @@ use bun_sourcemap as SourceMap;
 
 use crate::IndexInt;
 
-/// Move the printed code out of a `PrintResult`. Mirrors Zig
-/// `j.push(result.code, worker.allocator)` where the joiner takes ownership of
-/// the slice — the Rust `PrintResultSuccess.code` is a `Box<[u8]>` that would
+/// Move the printed code out of a `PrintResult` so the joiner takes ownership
+/// of the slice — `PrintResultSuccess.code` is a `Box<[u8]>` that would
 /// otherwise drop at end of `post_process_js_chunk` and leave the deferred
 /// `IntermediateOutput::Joiner` path holding freed memory.
 fn print_result_take_code(r: &mut PrintResult) -> Box<[u8]> {
@@ -46,7 +45,6 @@ pub fn post_process_js_chunk(
     chunk: &mut Chunk,
     chunk_index: usize,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let _trace = perf::trace("Bundler.postProcessJSChunk");
 
     let _ = chunk_index;
@@ -63,11 +61,12 @@ pub fn post_process_js_chunk(
     // embedded `Vec<Property>`/`Vec<Expr>` buffers leak from the global heap.
     let _ast_alloc_heap = js_ast::StoreAstAllocHeap::new();
 
-    // TODO(port): `defer chunk.renamer.deinit(bun.default_allocator)` — Zig explicitly
-    // tears down the renamer at end of scope. In Rust this should be handled by Drop on
-    // the renamer field, or an explicit `chunk.renamer.take()` at fn exit. Verify.
+    // The renamer is
+    // not used after this function, so it is reset to `None` before returning
+    // (success path below). `ChunkRenamer`'s variants free their owned storage
+    // via Drop; the `symbols` view inside is `ManuallyDrop` (non-owning), so
+    // graph storage is never freed.
 
-    // PERF(port): was arena bulk-free — profile if hot.
     let arena = Arena::new();
 
     // Also generate the cross-chunk binding code
@@ -103,8 +102,7 @@ pub fn post_process_js_chunk(
     let loader =
         c.parse_graph().input_files.items_loader()[chunk.entry_point.source_index() as usize];
     let is_typescript = loader.is_type_script();
-    // Zig: ModuleInfo.create(bun.default_allocator, ...) returns heap-allocated *ModuleInfo,
-    // later stored on chunk.content.javascript.module_info — OWNED → Box<ModuleInfo>.
+    // Stored on chunk.content.javascript.module_info — owned `Box<ModuleInfo>`.
     let mut module_info: Option<Box<ModuleInfo>> = if generate_module_info {
         Some(ModuleInfo::create(is_typescript))
     } else {
@@ -115,8 +113,7 @@ pub fn post_process_js_chunk(
     let worker_arena: &Arena = worker.arena();
 
     {
-        // PORT NOTE: Zig builds one `print_options` and passes it by-value twice.
-        // Rust `Options` is not `Copy` (holds `&mut ModuleInfo`), and a closure
+        // `Options` is not `Copy` (holds `&mut ModuleInfo`), and a closure
         // taking `&mut ModuleInfo` can't express "output lifetime = input
         // lifetime" — so build a base with `module_info: None` and override it
         // via FRU at each call site.
@@ -139,9 +136,7 @@ pub fn post_process_js_chunk(
 
         let mut cross_chunk_import_records: Vec<ImportRecord> =
             Vec::with_capacity(chunk.cross_chunk_imports.len() as usize);
-        // PERF(port): was initCapacity catch unreachable
         for import_record in chunk.cross_chunk_imports.slice() {
-            // PERF(port): was appendAssumeCapacity
             cross_chunk_import_records.push(ImportRecord {
                 kind: import_record.import_kind,
                 // `ctx.chunks` is a `BackRef<[Chunk]>` (safe `Deref`); chunk_index is
@@ -150,7 +145,7 @@ pub fn post_process_js_chunk(
                     ctx.chunks[import_record.chunk_index as usize].unique_key,
                 ),
                 range: bun_ast::Range::NONE,
-                // Remaining fields take their Zig defaults (no Default impl):
+                // Remaining fields (`ImportRecord` has no `Default` impl):
                 tag: ImportRecordTag::None,
                 loader: None,
                 source_index: Index::INVALID,
@@ -160,7 +155,7 @@ pub fn post_process_js_chunk(
             });
         }
 
-        // PORT NOTE: `MultiArrayList::get` returns `ManuallyDrop<BundledAst>` —
+        // `MultiArrayList::get` returns `ManuallyDrop<BundledAst>` —
         // the storage retains ownership of every Drop field (`named_imports`,
         // `parts`, `top_level_symbols_to_parts`, …), so the gathered struct
         // must NOT run Drop. `to_ast` consumes by value, so unwrap, convert,
@@ -324,7 +319,7 @@ pub fn post_process_js_chunk(
                                 continue;
                             }
                             // Skip barrel-optimized-away imports — marked is_unused by
-                            // barrel_imports.zig. Never resolved (source_index invalid),
+                            // `barrel_imports`. Never resolved (source_index invalid),
                             // and removed by convertStmtsForChunk. Not in emitted code.
                             if record.flags.contains(ImportRecordFlags::IS_UNUSED) {
                                 continue;
@@ -523,7 +518,6 @@ pub fn post_process_js_chunk(
     let is_bun = c.graph.ast.items_target()[chunk.entry_point.source_index() as usize].is_bun();
     if is_bun {
         if c.options.generate_bytecode_cache && output_format == options::OutputFormat::Cjs {
-            // Zig `++` literal concat → single byte literal (concat! yields &str, not &[u8])
             const INPUT: &[u8] =
                 b"// @bun @bytecode @bun-cjs\n(function(exports, require, module, __filename, __dirname) {";
             j.push_static(INPUT);
@@ -602,7 +596,6 @@ pub fn post_process_js_chunk(
     }
 
     {
-        // PORT NOTE: Zig `j.push(code, worker.allocator)` transferred ownership;
         // `cross_chunk_prefix` is a local that drops at fn exit, but the joiner
         // may be stashed on `chunk.intermediate_output` and consumed later
         // (`IntermediateOutput::Joiner` path). Move the Box into the joiner.
@@ -753,10 +746,9 @@ pub fn post_process_js_chunk(
     }
 
     {
-        // PORT NOTE: `entry_point_tail` is a local `CompileResult` whose `code`
-        // is a `Box<[u8]>`; Zig `j.push(tail_code, worker.allocator)` handed
-        // ownership to the joiner. Move it so the deferred-joiner path doesn't
-        // read freed memory after this fn returns.
+        // `entry_point_tail` is a local `CompileResult` whose `code`
+        // is a `Box<[u8]>`. Move it into the joiner so the deferred-joiner
+        // path doesn't read freed memory after this fn returns.
         let tail_code = entry_point_tail.into_code();
         if !tail_code.is_empty() {
             // Stick the entry point tail at the end of the file. Deliberately don't
@@ -768,7 +760,7 @@ pub fn post_process_js_chunk(
 
     // Put the cross-chunk suffix inside the IIFE
     {
-        // PORT NOTE: see cross_chunk_prefix above — move ownership into joiner.
+        // See cross_chunk_prefix above — move ownership into joiner.
         let code = print_result_take_code(&mut cross_chunk_suffix);
         if !code.is_empty() {
             if newline_before_comment {
@@ -801,9 +793,7 @@ pub fn post_process_js_chunk(
                     [chunk.entry_point.source_index() as usize]
                     .path;
                 let mut buf = MutableString::init_empty();
-                // PERF(port): worker.arena is an arena in Zig
                 let _ = js_printer::quote_for_json(input.pretty, &mut buf, true); // fmt::Result into Vec<u8> is infallible
-                // bun.handleOom dropped — Rust aborts on OOM
                 let quoted = buf.take_slice();
                 line_offset.advance(&quoted);
                 j.push_owned(quoted.into_boxed_slice());
@@ -880,6 +870,10 @@ pub fn post_process_js_chunk(
         )?;
     }
 
+    // Free the renamer now that printing is done; nothing reads it after
+    // post-processing.
+    chunk.renamer = Default::default();
+
     Ok(())
 }
 
@@ -914,7 +908,7 @@ fn add_binding_vars_to_module_info(
     }
 }
 
-// PORT NOTE: `js_printer::print` ties bump/Options/import_records/renamer to a
+// `js_printer::print` ties bump/Options/import_records/renamer to a
 // single `'a`, and `Renamer<'r, 'src>` is invariant in `'src` — so the caller's
 // renamer lifetime fixes `'a`. All by-ref params that flow into `print` must
 // share that lifetime.
@@ -923,17 +917,14 @@ pub fn generate_entry_point_tail_js<'a>(
     to_common_js_ref: Ref,
     to_esm_ref: Ref,
     source_index: IndexInt,
-    // bundler is an AST crate: std.mem.Allocator param → &'bump Bump (Arena)
-    // TODO(port): thread &'bump Bump from worker.arena end-to-end.
     arena: &'a Arena,
     temp_arena: &Arena,
     mut r: js_printer::renamer::Renamer<'a, 'a>,
     mut module_info: Option<&'a mut ModuleInfo>,
 ) -> CompileResult {
     let flags: crate::js_meta::Flags = c.graph.meta.items_flags()[source_index as usize];
-    // PERF(port): was arena-backed ArrayList(Stmt) — profile if hot.
     let mut stmts: Vec<Stmt> = Vec::new();
-    // PORT NOTE: `MultiArrayList::get` returns `ManuallyDrop<BundledAst>`; the
+    // `MultiArrayList::get` returns `ManuallyDrop<BundledAst>`; the
     // storage retains ownership of every Drop field, so neither this
     // `BundledAst` nor the `ast_view: Ast` derived from it below may run Drop.
     let ast = c.graph.ast.get(source_index as usize);
@@ -1024,7 +1015,6 @@ pub fn generate_entry_point_tail_js<'a>(
                         // entry point is a CommonJS-style module, since that would generate an ES6
                         // export statement that's not top-level. Instead, we will export the CommonJS
                         // exports as a default export later on.
-                        // PERF(port): was arena-backed ArrayList(ClauseItem) — profile if hot.
                         let mut items: Vec<bun_ast::ClauseItem> = Vec::new();
                         let cjs_export_copies =
                             &c.graph.meta.items_cjs_export_copies()[source_index as usize];
@@ -1032,9 +1022,9 @@ pub fn generate_entry_point_tail_js<'a>(
                         let mut had_default_export = false;
 
                         for (i, alias) in sorted_and_filtered_export_aliases.iter().enumerate() {
-                            // PORT NOTE: Zig `resolved_exports.get(alias).?` returns a by-value
-                            // copy of `ExportData`; only `.data` (an `ImportTracker`, `Copy`) is
-                            // read/mutated below, so copy that field instead of the whole struct.
+                            // Only `.data` (an `ImportTracker`, `Copy`) is
+                            // read/mutated below, so copy that field instead of
+                            // the whole `ExportData`.
                             let mut resolved_export_data =
                                 resolved_exports.get(alias).unwrap().data;
 
@@ -1165,9 +1155,8 @@ pub fn generate_entry_point_tail_js<'a>(
                             }
                         }
 
-                        // PORT NOTE: arena-owned `*mut [ClauseItem]` — move the
-                        // collected Vec into the linker arena (Zig used
-                        // `c.arena().alloc`). The arena slice is also iterated
+                        // arena-owned `*mut [ClauseItem]` — move the
+                        // collected Vec into the linker arena. The arena slice is also iterated
                         // below for the synthetic-default-export path.
                         let items: &mut [bun_ast::ClauseItem] = arena.alloc_slice_fill_iter(items);
                         stmts.push(Stmt::alloc(
@@ -1180,10 +1169,8 @@ pub fn generate_entry_point_tail_js<'a>(
 
                         if flags.needs_synthetic_default_export && !had_default_export {
                             let mut properties = G::PropertyList::init_capacity(items.len());
-                            // PERF(port): was initCapacity catch unreachable
                             let getter_fn_body: &mut [Stmt] =
                                 arena.alloc_slice_fill_default(items.len());
-                            // TODO(port): arena.alloc(Stmt, n) — needs arena slice alloc API
                             let mut remain_getter_fn_body = &mut getter_fn_body[..];
                             for export_item in items.iter() {
                                 let (fn_body, rest) = remain_getter_fn_body.split_at_mut(1);
@@ -1203,7 +1190,6 @@ pub fn generate_entry_point_tail_js<'a>(
                                     },
                                     bun_ast::Loc::EMPTY,
                                 );
-                                // PERF(port): was appendAssumeCapacity
                                 VecExt::append(
                                     &mut properties,
                                     G::Property {
@@ -1325,7 +1311,7 @@ pub fn generate_entry_point_tail_js<'a>(
 
     // Add generated local declarations from entry point tail to module_info.
     // This captures vars like `var export_foo = cjs.foo` for CJS export copies.
-    // PORT NOTE: reshaped for borrowck — reborrow via as_deref_mut so module_info
+    // Reshaped for borrowck — reborrow via as_deref_mut so module_info
     // remains usable for print_options below.
     if let Some(mi) = module_info.as_mut() {
         let mi: &mut ModuleInfo = &mut **mi;
@@ -1408,5 +1394,3 @@ pub fn generate_entry_point_tail_js<'a>(
         decls: Box::default(),
     }
 }
-
-// ported from: src/bundler/linker_context/postProcessJSChunk.zig
diff --git a/src/bundler/linker_context/prepareCssAstsForChunk.rs b/src/bundler/linker_context/prepareCssAstsForChunk.rs
index c473a298841..cbb77689781 100644
--- a/src/bundler/linker_context/prepareCssAstsForChunk.rs
+++ b/src/bundler/linker_context/prepareCssAstsForChunk.rs
@@ -20,8 +20,7 @@ use bun_resolver::DataURL;
 
 use crate::chunk::{Content, CssImportOrderKind};
 
-// PORT NOTE: Zig stores `*Chunk` / `*LinkerContext` (freely-aliasing mutable
-// pointers). We mirror that with raw pointers rather than `&mut` / `&` so that
+// Raw pointers rather than `&mut` / `&` so that
 // (a) the container_of `container_of` recovery of `*mut BundleV2` from
 // `linker` retains write provenance over the whole bundle, and (b) multiple
 // tasks may hold pointers to the same `LinkerContext` concurrently without
@@ -56,8 +55,7 @@ unsafe impl Send for PrepareCssAstTask {}
 pub unsafe fn prepare_css_asts_for_chunk(task: *mut ThreadPoolLib::Task) {
     // SAFETY: `task` points to `PrepareCssAstTask.task` (intrusive thread-pool
     // node); the thread pool hands us exclusive access for the callback's
-    // duration. We only read the two raw-pointer fields, matching Zig's
-    // `*const PrepareCssAstTask`.
+    // duration. We only read the two raw-pointer fields.
     let prepare_css_asts: &PrepareCssAstTask =
         unsafe { &*bun_core::from_field_ptr!(PrepareCssAstTask, task, task) };
     let linker: *mut LinkerContext = prepare_css_asts.linker;
@@ -91,9 +89,7 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
     // Remove duplicate rules across files. This must be done in serial, not
     // in parallel, and must be done from the last rule to the first rule.
     {
-        // PORT NOTE: Zig accesses `chunk.content.css.{imports_in_chunk_in_order,asts}`
-        // through the union field at each use site while also holding `entry` as a raw
-        // pointer into `imports_in_chunk_in_order`. In Rust, every `chunk.content.css.*`
+        // Every `chunk.content.css.*` access
         // re-enters the `Content` enum and re-borrows `chunk.content` as a whole, which
         // would alias the live `&mut entry`. Destructure the variant once so borrowck
         // can split the disjoint `CssChunk` struct fields (`imports_in_chunk_in_order`
@@ -105,16 +101,14 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
         while i != 0 {
             i -= 1;
             let entry = css_chunk.imports_in_chunk_in_order.mut_(i);
-            // PORT NOTE: reshaped for borrowck — match on entry.kind while also touching
+            // Reshaped for borrowck — match on entry.kind while also touching
             // entry.conditions / entry.condition_import_records relies on disjoint field borrows.
             match &mut entry.kind {
                 CssImportOrderKind::Layers(layers) => {
                     let inner = layers.inner();
                     let len = inner.len();
                     let rules = if len > 0 {
-                        // PORT NOTE: Zig `SmallList(LayerName,1).fromBabyListNoDeinit(layers.inner().*)`
-                        // is a bitwise Vec→SmallList header transfer. In Rust the
-                        // `Chunk::Layers` payload is the lifetime-erased shadow
+                        // The `Chunk::Layers` payload is the lifetime-erased shadow
                         // `bun_css::LayerName { v: Vec<Box<[u8]>> }`,
                         // not the real `css_parser::LayerName { v: SmallList<&'static [u8],1> }`,
                         // so the layouts differ. Rebuild the real list element-by-element;
@@ -133,7 +127,7 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                                     shadow.v.slice().iter().map(|seg| {
                                         // `seg` borrows arena-owned bytes that outlive this
                                         // stylesheet; route through `StoreStr` for the lifetime
-                                        // erasure (see layer.rs TODO(port)).
+                                        // erasure (see the corresponding note in layer.rs).
                                         bun_ast::StoreStr::new(seg).slice()
                                     }),
                                 ),
@@ -162,13 +156,11 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                     css_chunk.asts[i] = ast;
                 }
                 CssImportOrderKind::ExternalPath(p) => {
-                    // PORT NOTE: Zig keeps `conditions: ?*ImportConditions` as a raw
-                    // pointer to index 0 while the `while j != 1` loop reads
-                    // `entry.conditions.len` / `.at(j)`. Taking `&mut` at index 0 here
-                    // would exclusively borrow the whole `entry.conditions` Vec for
-                    // the duration, aliasing those reads. The pointer is not actually
-                    // dereferenced until after the loop (.zig:119), so defer acquiring
-                    // the index-0 borrow until `actual_conditions` is built below.
+                    // Taking `&mut` at index 0 here would exclusively borrow
+                    // the whole `entry.conditions` Vec while the `while j != 1`
+                    // loop below still reads `entry.conditions.len` / `.at(j)`.
+                    // The borrow is not actually needed until after the loop, so
+                    // defer acquiring it until `actual_conditions` is built below.
                     let had_conditions = entry.conditions.len() > 0;
                     if had_conditions {
                         entry.condition_import_records.push(ImportRecord {
@@ -195,15 +187,14 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                         while j != 1 {
                             j -= 1;
 
-                            // PORT NOTE: Zig has no destructors, so when `ast_import` falls
-                            // out of scope the bitwise-duplicated `ImportConditions` inside
-                            // it (see `ptr::read` below) is simply abandoned. In Rust,
-                            // dropping `ast_import` would run `Drop` on that aliased
+                            // `ast_import` holds a bitwise-duplicated `ImportConditions`
+                            // (see `ptr::read` below);
+                            // dropping it would run `Drop` on that aliased
                             // `ImportConditions` — freeing Global-backed buffers
                             // (`MediaList.media_queries: Vec`, `SupportsCondition::{Box,Vec}`,
                             // `LayerName.v: SmallList`) that are still owned by
                             // `entry.conditions[j]`, i.e. a double-free / UAF. Wrap in
-                            // `ManuallyDrop` to mirror Zig's leak-on-scope-exit; the rule
+                            // `ManuallyDrop` so the duplicate is abandoned instead; the rule
                             // slab itself is arena-owned so it is reclaimed on arena reset.
                             let ast_import = core::mem::ManuallyDrop::new(BundlerStyleSheet {
                                 options: ParserOptions::default(None),
@@ -218,7 +209,7 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                                         loc: Location::dummy(),
                                         ..Default::default()
                                     };
-                                    // SAFETY: Zig `entry.conditions.at(j).*` — shallow struct
+                                    // SAFETY: shallow struct
                                     // copy. The duplicate is never dropped (`ManuallyDrop`
                                     // above), so the aliased heap stays singly-owned by
                                     // `entry.conditions[j]`.
@@ -283,9 +274,8 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                                 b"text/css",
                                 strings::trim(print_result.code.as_slice(), b" \n\r\t"),
                             );
-                            // PORT NOTE: Zig allocated into the worker arena (`arena`).
                             // `encode_string_as_shortest_data_url` returns a heap `Vec<u8>`;
-                            // copy it into the worker bump so ownership matches Zig (freed
+                            // copy it into the worker bump (freed
                             // at bundle teardown via arena reset). SAFETY: arena outlives
                             // the chunk, so the `'bump → 'static` launder is sound — same
                             // contract as every other CSS slice in this file.
@@ -296,9 +286,8 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                     }
 
                     let mut empty_conditions = ImportConditions::default();
-                    // Index 0 is disjoint from every `at(j)` (j>=1) read above; only
-                    // now do we materialize the exclusive borrow that Zig's raw pointer
-                    // held the whole time.
+                    // Index 0 is disjoint from every `at(j)` (j>=1) read above;
+                    // only now do we materialize the exclusive borrow.
                     let actual_conditions: &mut ImportConditions = if had_conditions {
                         entry.conditions.mut_(0)
                     } else {
@@ -323,7 +312,12 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                                 p.pretty,
                                 entry.condition_import_records.len() as u32,
                             );
-                            // SAFETY: Zig `actual_conditions.*` — shallow struct copy.
+                            // SAFETY: shallow struct copy. The duplicate lives in an
+                            // `ImportRule` inside the `arena_rule_list_one` slab assigned
+                            // to `css_chunk.asts[i]`, whose elements never run `Drop`
+                            // (`CssChunk::Drop` frees the slab via `set_len(0)`), so
+                            // `entry.conditions[0]` / `empty_conditions` remain the sole
+                            // owners of the interior heap.
                             *import_rule.conditions_mut() =
                                 unsafe { core::ptr::read(actual_conditions) };
                             arena_rule_list_one(bump, BundlerCssRule::Import(import_rule))
@@ -348,7 +342,7 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                             [source_index.get() as usize]
                             .as_deref()
                             .expect("css ast present");
-                        // SAFETY: Zig `original_stylesheet.*` — bitwise shallow copy of the
+                        // SAFETY: bitwise shallow copy of the
                         // stylesheet header. All interior allocations are arena-owned and never
                         // freed via this view, so the duplicated `Vec`/`Vec` headers are
                         // sound for read-only / reslice use below.
@@ -405,20 +399,27 @@ fn prepare_css_asts_for_chunk_impl(c: &LinkerContext, chunk: &mut Chunk, bump: &
                                 );
                             for rule in &original_rules[0..prefix_end] {
                                 if matches!(rule, BundlerCssRule::LayerStatement(_)) {
-                                    // SAFETY: Zig by-value copy of arena-backed rule.
+                                    // SAFETY: bitwise duplicate of a rule. The copy goes into
+                                    // an `arena_rule_list` slab installed in `css_chunk.asts[i]`,
+                                    // whose elements never run `Drop` (see `arena_rule_list` /
+                                    // `CssChunk::Drop`), so the rule's interior heap stays
+                                    // singly-owned by the original.
                                     new_rules.push(unsafe { core::ptr::read(rule) });
                                 }
                             }
                             for rule in &original_rules[prefix_end..] {
-                                // SAFETY: Zig by-value copy of arena-backed rule.
+                                // SAFETY: bitwise duplicate of a rule. The copy goes into
+                                // an `arena_rule_list` slab installed in `css_chunk.asts[i]`,
+                                // whose elements never run `Drop` (see `arena_rule_list` /
+                                // `CssChunk::Drop`), so the rule's interior heap stays
+                                // singly-owned by the original.
                                 new_rules.push(unsafe { core::ptr::read(rule) });
                             }
                             // `ast.rules` is the shallow-copied header aliasing the
                             // source stylesheet's arena buffer (see `ptr::read` above).
                             // Dropping it would `drop_in_place` the aliased rules and
-                            // free the shared backing array. Leak the header (Zig
-                            // semantics: bitwise overwrite) before installing the
-                            // freshly-allocated list.
+                            // free the shared backing array. Leak the header
+                            // before installing the freshly-allocated list.
                             let _ = core::mem::ManuallyDrop::new(core::mem::replace(
                                 &mut ast.rules,
                                 arena_rule_list(new_rules),
@@ -478,7 +479,7 @@ fn wrap_rules_with_conditions(
         // Generate "@layer" wrappers. Note that empty "@layer" rules still have
         // a side effect (they set the layer order) so they cannot be removed.
         if let Some(l) = &item.layer {
-            // SAFETY: Zig `const layer = l.v;` — by-value `?LayerName` copy. The
+            // SAFETY: by-value `?LayerName` copy. The
             // `SmallList<&'static [u8],1>` payload is arena-backed and never
             // freed via this view, so the bitwise duplicate is sound (same as
             // every other `ptr::read` shallow-copy in this file).
@@ -493,8 +494,7 @@ fn wrap_rules_with_conditions(
                     // `ast.rules.v` may be the shallow-copied / offset-resliced
                     // header aliasing the source stylesheet's buffer (see the
                     // `ptr::read` / `Vec::from_raw_parts` above) — dropping it
-                    // would free into another allocation. Zig's `= .{}` is a
-                    // bitwise overwrite; mirror that by leaking the header.
+                    // would free into another allocation; leak the header instead.
                     let _ = core::mem::ManuallyDrop::new(core::mem::take(&mut ast.rules.v));
                     do_block_rule = false;
                 }
@@ -559,5 +559,3 @@ fn wrap_rules_with_conditions(
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/prepareCssAstsForChunk.zig
diff --git a/src/bundler/linker_context/renameSymbolsInChunk.rs b/src/bundler/linker_context/renameSymbolsInChunk.rs
index 1d14bde68bc..450e26c382d 100644
--- a/src/bundler/linker_context/renameSymbolsInChunk.rs
+++ b/src/bundler/linker_context/renameSymbolsInChunk.rs
@@ -15,11 +15,6 @@ use crate::{Chunk, LinkerContext, StableRef, WrapKind};
 
 /// TODO: investigate if we need to parallelize this function
 /// esbuild does parallelize it.
-// TODO(port): narrow error set
-// TODO(port): bundler is an AST crate (PORTING.md §Allocators) — verify whether caller passes
-// an arena vs default_allocator for the dropped `arena: std.mem.Allocator` param; if arena,
-// thread `bump: &'bump Bump` and switch working Vecs to bun_alloc::ArenaVec<'bump, T>.
-//
 // CONCURRENCY: called from `LinkerContext::generate_js_renamer` (`each_ptr`
 // callback) — runs on worker threads, one task per chunk. Writes go to
 // `chunk.renamer` (per-chunk disjoint) plus per-`source_index` rows of
@@ -27,9 +22,9 @@ use crate::{Chunk, LinkerContext, StableRef, WrapKind};
 // symbol scope assignment). `files_in_order` is the chunk's own file list;
 // without code-splitting, files are partitioned across chunks so per-row
 // writes are disjoint. With code-splitting a `source_index` may appear in
-// multiple chunks — the Zig original has the same overlap; the writes are
+// multiple chunks; the writes are
 // idempotent (`declared_symbols` flag set, scope-member sort) so the race is
-// benign there but is still a Stacked Borrows hazard here. Mitigation: never
+// benign but is still a Stacked Borrows hazard. Mitigation: never
 // materialize `&mut LinkerContext` (would assert whole-context exclusivity
 // across N tasks); take `*mut LinkerContext` raw, deref to `&LinkerContext`
 // for reads, and access SoA columns via `split_raw()` root-provenance
@@ -105,8 +100,7 @@ pub unsafe fn rename_symbols_in_chunk(
         )
     };
 
-    // PORT NOTE: `symbol::Map` is not `Clone`/`Copy`; Zig passed the struct
-    // (slice header) by value. Build a non-owning shallow view via
+    // `symbol::Map` is not `Clone`/`Copy`. Build a non-owning shallow view via
     // `from_bump_slice` so the renamer's `Map` does not free graph storage on
     // drop.
     // SAFETY: `c.graph.symbols` outlives the returned `ChunkRenamer` (both are
@@ -152,7 +146,6 @@ pub unsafe fn rename_symbols_in_chunk(
             count += item.len() as u32;
         }
 
-        // PERF(port): Zig pre-set len and filled via slice writes; using push() here
         let mut list: Vec<StableRef> = Vec::with_capacity(count as usize);
         let stable_source_indices = c.graph.stable_source_indices.slice();
         for item in imports_from_other_chunks {
@@ -260,7 +253,7 @@ pub unsafe fn rename_symbols_in_chunk(
 
         top_level_symbols.clear();
         for stable_ref in &sorted_imports_from_other_chunks {
-            // PORT NOTE: `StableRef` is `repr(packed)`; copy the field to avoid an unaligned ref.
+            // `StableRef` is `repr(packed)`; copy the field to avoid an unaligned ref.
             let ref_ = { stable_ref.r#ref };
             minify_renamer.accumulate_symbol_use_count(
                 &mut top_level_symbols,
@@ -281,16 +274,15 @@ pub unsafe fn rename_symbols_in_chunk(
 
     let mut r = NumberRenamer::init(make_symbols_view(symbols), &reserved_names)?;
     for stable_ref in &sorted_imports_from_other_chunks {
-        // PORT NOTE: `StableRef` is `repr(packed)`; copy the field to avoid an unaligned ref.
+        // `StableRef` is `repr(packed)`; copy the field to avoid an unaligned ref.
         r.add_top_level_symbol(stable_ref.r#ref);
     }
 
-    // PORT NOTE: Zig used `r.temp_arena` for this list; arena param dropped
     let mut sorted: Vec<u32> = Vec::new();
 
     for &source_index in files_in_order {
         let wrap = all_flags[source_index as usize].wrap;
-        // PORT NOTE: need `&mut [Part]` for `add_top_level_declared_symbols`.
+        // Need `&mut [Part]` for `add_top_level_declared_symbols`.
         let parts: &mut [Part] = all_parts[source_index as usize].as_mut_slice();
 
         match wrap {
@@ -366,7 +358,7 @@ pub unsafe fn rename_symbols_in_chunk(
                         }
                     }
                 }
-                // PORT NOTE: reshaped for borrowck — `&mut r.root` while `r` is the
+                // Reshaped for borrowck — `&mut r.root` while `r` is the
                 // `&mut self` receiver. Take a raw pointer; `assign_names_*` does
                 // not touch `self.root` through `self`.
                 let root: *mut renamer::NumberScope = core::ptr::addr_of_mut!(r.root);
@@ -418,7 +410,6 @@ pub unsafe fn rename_symbols_in_chunk(
                     &mut sorted,
                 );
             }
-            // Zig: `@TypeOf(r.number_scope_pool.hive.used).initEmpty()`.
             r.number_scope_pool.hive.used = bun_collections::hive_array::HiveBitSet::init_empty();
         }
     }
@@ -429,5 +420,3 @@ pub unsafe fn rename_symbols_in_chunk(
 pub use crate::DeferredBatchTask;
 pub use crate::ParseTask;
 pub use crate::ThreadPool;
-
-// ported from: src/bundler/linker_context/renameSymbolsInChunk.zig
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index ab95027391f..c8fe0b91033 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -1,12 +1,10 @@
-//! Port of `src/bundler/linker_context/scanImportsAndExports.zig`.
-//
-// PORT NOTE: the Zig body takes ~20 simultaneous mutable column slices
-// (`this.graph.ast.items(.field)`) and freely interleaves them with
+// This pass works over ~20 simultaneous mutable column slices
+// (`this.graph.ast.items(.field)`) freely interleaved with
 // `&mut LinkerContext` method calls. Rust's borrowck forbids both holding
 // overlapping `&mut [T]` columns from the same `MultiArrayList` and holding
 // any `&mut` column across a `&mut self` call into `this.graph`. The columns
 // are physically disjoint (SoA layout) and the underlying `MultiArrayList`
-// never reallocates inside this function, so this port caches the column
+// never reallocates inside this function, so we cache the column
 // base pointers once via `Slice::items_raw` and dereferences them at each
 // use site through `*mut [T]`. This is the documented escape hatch in
 // `bun_collections::multi_array_list::Slice::items_raw`.
@@ -84,9 +82,8 @@ pub fn scan_imports_and_exports(
     let _outer_trace = perf::trace("Bundler.scanImportsAndExports");
     let output_format = this.options.output_format;
 
-    // PORT NOTE: `reachable_files` is borrowed out of `this.graph` while the
+    // `reachable_files` is borrowed out of `this.graph` while the
     // body also calls `&mut this.graph` methods. Snapshot the indices.
-    // PERF(port): was zero-copy slice; profile.
     let mut reachable: Vec<Index> = this.graph.reachable_files.slice().to_vec();
 
     // ── cache SoA column base pointers ────────────────────────────────────
@@ -115,8 +112,8 @@ pub fn scan_imports_and_exports(
     let module_refs: *mut [Ref] = ast.module_ref;
     let wrapper_refs: *mut [Ref] = ast.wrapper_ref;
     let parts_list: *mut [PartList] = ast.parts;
-    // Zig: `[]?*bun.css.BundlerStyleSheet` — element is a *mutable* nullable
-    // pointer (matches `BundledAst.css: Option<*mut BundlerStyleSheet>`).
+    // Element is a *mutable* nullable
+    // pointer (`BundledAst.css: Option<*mut BundlerStyleSheet>`).
     let css_asts: *mut [CssCol] = ast.css;
 
     let input_files: *mut [Source] = input.source;
@@ -131,9 +128,6 @@ pub fn scan_imports_and_exports(
     let cjs_export_copies: *mut [js_meta::CjsExportCopies] = meta.cjs_export_copies;
     let entry_point_part_indices: *mut [Index] = meta.entry_point_part_index;
 
-    // PORT NOTE: Zig copies `symbols` to a local and `defer`-writes it back.
-    // In Rust `this.graph.symbols` is the same storage, so no copy-back needed.
-
     {
         // Step 1: Figure out what modules must be CommonJS
         for source_index_ in &reachable {
@@ -317,8 +311,6 @@ pub fn scan_imports_and_exports(
                     output_format,
                 }
             };
-            // PORT NOTE: `defer dependency_wrapper.export_star_map.deinit()` → Drop handles it.
-
             for source_index_ in &reachable {
                 let source_index = source_index_.get();
                 let id = source_index as usize;
@@ -363,9 +355,6 @@ pub fn scan_imports_and_exports(
         {
             let mut export_star_ctx: Option<ExportStarContext> = None;
             let _trace = perf::trace("Bundler.ResolveExportStarStatements");
-            // PORT NOTE: `defer { if (export_star_ctx) |*export_ctx| export_ctx.source_index_stack.deinit(); }`
-            // → Drop on `export_star_ctx` handles freeing `source_index_stack: Vec<u32>`.
-
             for source_index_ in &reachable {
                 let source_index = source_index_.get();
                 let id = source_index as usize;
@@ -491,11 +480,9 @@ pub fn scan_imports_and_exports(
         // imported using an import star statement.
         // Note: `do` will wait for all to finish before moving forward
         //
-        // PORT NOTE: Zig dispatched via `worker_pool.each(arena, this,
-        // doStep5, reachable_files)` (parallel fan-out, blocks until done).
         // `do_step5` only touches distinct SoA rows per `source_index` (the
-        // columns are pre-sized and never reallocate during this step),
-        // matching the Zig invariant. We pass `*mut LinkerContext` through a
+        // columns are pre-sized and never reallocate during this step).
+        // We pass `*mut LinkerContext` through a
         // `Sync` wrapper; the callee derefs it to `&LinkerContext` (shared)
         // for reads and writes per-row cells via raw `split_raw()` pointers —
         // mirroring `GenerateChunkCtx` (`generate_js_renamer` likewise never
@@ -528,11 +515,10 @@ pub fn scan_imports_and_exports(
             );
         }
 
-        // Zig calls `takeAstOwnership` here because `doStep5` appends to
-        // `part.dependencies`/`declared_symbols` with the worker allocator.
-        // In the Rust port those are global-allocator `Vec`s (thread-safe to
-        // grow) and `do_step_5` never pushes to the arena-backed `PartList`/
-        // import-record columns, so no transfer is needed.
+        // No post-fan-out ownership transfer is needed: `do_step5` only grows
+        // global-allocator `Vec`s (`part.dependencies`, `declared_symbols`),
+        // which are thread-safe to grow per-row, and never pushes to the
+        // arena-backed `PartList`/import-record columns.
     }
 
     if FeatureFlags::HELP_CATCH_MEMORY_ISSUES {
@@ -607,19 +593,18 @@ pub fn scan_imports_and_exports(
             };
 
             // Allocate the identifier-name buffer from the linker arena so it is
-            // reclaimed when the link pass ends (Zig: `this.arena().alloc(u8, ...)`).
+            // reclaimed when the link pass ends.
             // The slices handed out below are stored in `Symbol.original_name: *const [u8]`,
             // which is arena-lifetime by construction.
             let string_buffer: &mut [u8] = this
                 .graph
                 .arena()
                 .alloc_slice_fill_default::<u8>(string_buffer_len);
-            // PORT NOTE: `StringBuilder::drop` reconstructs a `Box<[u8]>` from
+            // `StringBuilder::drop` reconstructs a `Box<[u8]>` from
             // `ptr`/`cap` and frees it via the global arena. Here the
             // backing buffer is arena-owned (bumpalo), so dropping would hand
             // mimalloc a pointer it never allocated. Wrap in `ManuallyDrop` —
-            // the arena reclaims the storage on reset, matching Zig's implicit
-            // no-destructor semantics.
+            // the arena reclaims the storage on reset.
             let mut builder = core::mem::ManuallyDrop::new(bun_core::StringBuilder {
                 len: 0,
                 cap: string_buffer.len(),
@@ -701,8 +686,8 @@ pub fn scan_imports_and_exports(
                 }
             }
 
-            // PORT NOTE: Zig `defer bun.assert(builder.len == builder.cap)` —
-            // moved to end-of-scope assert (no early returns inside this block).
+            // End-of-scope assert; relies on there being no
+            // early returns inside this block.
             debug_assert!(builder.len == builder.cap);
 
             // Include the "__export" symbol from the runtime if it was used in the
@@ -727,7 +712,7 @@ pub fn scan_imports_and_exports(
             {
                 let imports_to_bind = &col_ref!(imports_to_bind_list)[id];
                 debug_assert_eq!(imports_to_bind.keys().len(), imports_to_bind.values().len());
-                // PORT NOTE: reshaped for borrowck — iterate by index so we can
+                // Iterate by index so we can
                 // re-borrow `parts` after each `top_level_symbol_to_parts` call.
                 for itb_i in 0..imports_to_bind.keys().len() {
                     let r#ref: Ref = col_ref!(imports_to_bind_list)[id].keys()[itb_i];
@@ -820,11 +805,10 @@ pub fn scan_imports_and_exports(
                         this.top_level_symbols_to_parts(target_source_index.get(), target_ref);
                     dependencies.reserve(top_to_parts.len());
                     for part_index in top_to_parts {
-                        // PERF(port): was appendAssumeCapacity
                         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
+                            // `crate::Index` ↔ `bun_ast::Index` are both
+                            // `#[repr(transparent)] u32` newtypes;
+                            // bridge by `.value` until B-3
                             // collapses them to a single re-export.
                             source_index: bun_ast::Index(target_source_index.get()),
                             part_index: *part_index,
@@ -836,7 +820,6 @@ pub fn scan_imports_and_exports(
 
                 // Ensure "exports" is included if the current output format needs it
                 if force_include_exports {
-                    // PERF(port): was appendAssumeCapacity
                     dependencies.push(Dependency {
                         source_index: bun_ast::Index::source(source_index as usize),
                         part_index: bun_ast::NAMESPACE_EXPORT_PART_INDEX,
@@ -845,7 +828,6 @@ pub fn scan_imports_and_exports(
 
                 // Include the wrapper if present
                 if add_wrapper {
-                    // PERF(port): was appendAssumeCapacity
                     dependencies.push(Dependency {
                         source_index: bun_ast::Index::source(source_index as usize),
                         part_index: col_ref!(wrapper_part_indices)[id].get(),
@@ -861,8 +843,6 @@ pub fn scan_imports_and_exports(
                         ..Default::default()
                     },
                 )?;
-                // PORT NOTE: `catch |err| bun.handleOom(err)` dropped — `?` propagates OOM.
-
                 col!(entry_point_part_indices)[id] = Index::part(entry_point_part_index);
 
                 // Pull in the "__toCommonJS" symbol if we need it due to being an entry point
@@ -892,7 +872,7 @@ pub fn scan_imports_and_exports(
                 let mut runtime_require_uses: u32 = 0;
 
                 // Imports of wrapped files must depend on the wrapper
-                // PORT NOTE: iterate by index so each iteration re-borrows
+                // Iterate by index so each iteration re-borrows
                 // `import_records` (the body calls `&mut this.graph` methods).
                 let import_record_indices_len = col_ref!(parts_list)[id].as_slice()[part_index]
                     .import_record_indices
@@ -909,7 +889,7 @@ pub fn scan_imports_and_exports(
                     let other_id = rec_source_index.value() as usize;
 
                     // Don't follow external imports (this includes import() expressions)
-                    // PORT NOTE: short-circuit — `is_external_dynamic_import` indexes by
+                    // Short-circuit: `is_external_dynamic_import` indexes by
                     // `record.source_index`, so it must only run when that index is valid.
                     let is_external_dyn = rec_source_index.is_valid() && {
                         let record = &col_ref!(import_records_list)[id].as_slice()
@@ -1182,7 +1162,7 @@ fn should_call_runtime_require(format: options::Format) -> bool {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// DependencyWrapper — port of the inner Zig struct.
+// DependencyWrapper
 // ──────────────────────────────────────────────────────────────────────────
 struct DependencyWrapper<'a> {
     flags: &'a mut [js_meta::Flags],
@@ -1268,7 +1248,7 @@ impl DependencyWrapper<'_> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// ExportStarContext — port of the inner Zig struct. Holds raw column ptrs.
+// ExportStarContext — holds raw column ptrs.
 // ──────────────────────────────────────────────────────────────────────────
 struct ExportStarContext<'a> {
     import_records_list: *mut [ImportRecordList<'a>],
@@ -1320,9 +1300,8 @@ impl<'a> ExportStarContext<'a> {
                 continue;
             }
 
-            // PORT NOTE: reshaped for borrowck — collect (alias, name) pairs so the
+            // Collect (alias, name) pairs so the
             // loop body can mutably borrow `resolved_exports` / `imports_to_bind`.
-            // PERF(port): was zero-copy `iter()` over StringArrayHashMap; profile.
             let exports_len = col_ref!(self.named_exports)[other_id].keys().len();
             'next_export: for ne_i in 0..exports_len {
                 // `BackRef<[u8]>` — points into the `named_exports` key
@@ -1375,7 +1354,6 @@ impl<'a> ExportStarContext<'a> {
                             },
                         )
                         .expect("oom");
-                    // PORT NOTE: `catch |err| bun.handleOom(err)` dropped — aborts on OOM.
                 } else if gop.value_ptr.data.source_index.get() != other_source_index {
                     // Two different re-exports colliding makes it potentially ambiguous
                     gop.value_ptr
@@ -1388,7 +1366,6 @@ impl<'a> ExportStarContext<'a> {
                             },
                             ..Default::default()
                         });
-                    // PORT NOTE: `catch |err| bun.handleOom(err)` dropped — aborts on OOM.
                 }
             }
 
@@ -1396,8 +1373,7 @@ impl<'a> ExportStarContext<'a> {
             self.add_exports(resolved_exports, target_id, other_source_index);
         }
 
-        // PORT NOTE: Zig `defer this.source_index_stack.shrinkRetainingCapacity(stack_end_pos - 1)`
-        // — inlined at scope end (no early returns after the push).
+        // Scope-end truncation (no early returns after the push).
         self.source_index_stack.truncate(stack_end_pos - 1);
     }
 }
@@ -1413,8 +1389,8 @@ mod __css_validation {
     use bun_ast::Log;
     use bun_collections::{ArrayHashMap, StringArrayHashMap};
 
-    // Zig: `?*bun.css.BundlerStyleSheet` — keep the column element as a raw
-    // `*mut` (matches `BundledAst.css`), so we never launder a `&T` into `&mut T`.
+    // Keep the column element as a raw
+    // `*mut` (`BundledAst.css`), so we never launder a `&T` into `&mut T`.
     use crate::bundled_ast::CssCol;
 
     /// `ArrayHashAdapter` so `LocalScope` (`ArrayHashMap<Box<[u8]>, LocalEntry>`)
@@ -1539,8 +1515,6 @@ mod __css_validation {
             log: &'a mut Log,
         }
 
-        // PORT NOTE: `pub fn deinit` → Drop on `visited` / `properties` handles cleanup.
-
         impl<'a, 'bump> Visitor<'a, 'bump> {
             fn add_property_or_warn(
                 &mut self,
@@ -1619,8 +1593,6 @@ mod __css_validation {
                     ),
                     ..Default::default()
                 });
-                // PORT NOTE: nested `catch |err| bun.handleOom(err)` chain dropped — aborts on OOM.
-
                 // Don't warn more than once
                 entry.value_ptr.source_index = Index::INVALID.get();
             }
@@ -1725,7 +1697,6 @@ mod __css_validation {
             }
         }
 
-        // PERF(port): was stack-fallback arena (1024 bytes) — profile.
         // SAFETY: parse_graph backref valid for link step. Read-only.
         let input = this.parse_graph().input_files.split_raw();
         let mut visitor = Visitor {
@@ -1745,5 +1716,3 @@ mod __css_validation {
         }
     }
 }
-
-// ported from: src/bundler/linker_context/scanImportsAndExports.zig
diff --git a/src/bundler/linker_context/writeOutputFilesToDisk.rs b/src/bundler/linker_context/writeOutputFilesToDisk.rs
index 75aefd5033f..9123b66ff47 100644
--- a/src/bundler/linker_context/writeOutputFilesToDisk.rs
+++ b/src/bundler/linker_context/writeOutputFilesToDisk.rs
@@ -25,7 +25,7 @@ use bun_sys::{
     write_file_with_path_buffer,
 };
 
-/// Zig: `bun.bytecode_extension` (".jsc"). Mirror of `src/bun.zig:bytecode_extension`.
+/// Bytecode output file extension (also defined in `generateChunksInParallel.rs`).
 const BYTECODE_EXTENSION: &str = ".jsc";
 
 pub fn write_output_files_to_disk(
@@ -66,9 +66,8 @@ pub fn write_output_files_to_disk(
         }
     };
     // Optimization: when writing to disk, we can re-use the memory
-    // PERF(port): MaxHeapAllocator reuses the largest allocation between
-    // iterations. Verify bun_alloc::MaxHeapAllocator semantics
-    // match (init/reset/deinit). DynAlloc is currently `()` so the arena
+    // between iterations: MaxHeapAllocator retains the largest allocation.
+    // DynAlloc is currently `()` so the arena
     // handles below are placeholders; allocation routes through global mimalloc.
     let mut max_heap_allocator = MaxHeapAllocator::init();
     let mut _max_heap_allocator_source_map = MaxHeapAllocator::init();
@@ -79,8 +78,8 @@ pub fn write_output_files_to_disk(
     let bv2: &mut BundleV2 =
         unsafe { &mut *LinkerContext::bundle_v2_ptr(std::ptr::from_mut::<LinkerContext>(c)) };
 
-    // PORT NOTE: Zig passes `chunk` (an element of `chunks`) and `chunks`
-    // together into `code()`/`code_standalone()`. The callee now takes
+    // `code()`/`code_standalone()` take both `chunk` (an element of `chunks`)
+    // and `chunks` as
     // `&Chunk` / `&[Chunk]` (read-only), so iterate by index and reborrow
     // shared; the only per-chunk mutation is the `intermediate_output`
     // take/restore done via `chunks[i]`.
@@ -115,7 +114,7 @@ pub fn write_output_files_to_disk(
         }
 
         let _trace2 = bun_core::perf::trace("Bundler.writeChunkToDisk");
-        // PERF(port): Zig `defer max_heap_allocator.reset()` — reset the reusable
+        // Reset the reusable
         // buffer after each chunk. `MaxHeapAllocator::scope()` returns an RAII
         // guard that resets on drop and derefs to the arena, so when
         // `code_allocator` is wired up it can borrow through `_code_allocator`.
@@ -151,7 +150,7 @@ pub fn write_output_files_to_disk(
             &resolver_opts.public_path
         };
 
-        // PORT NOTE: take `intermediate_output` by value so its `&mut self` is
+        // Take `intermediate_output` by value so its `&mut self` is
         // disjoint from the `&chunks[i]` / `&[Chunk]` reads below.
         let mut intermediate_output =
             core::mem::take(&mut chunks[chunk_index_in_chunks_list].intermediate_output);
@@ -235,15 +234,11 @@ pub fn write_output_files_to_disk(
                         + a.len()
                         + b.len()
                         + b"\n".len();
-                    // PERF(port): Zig used Chunk.IntermediateOutput.allocatorForSize(total_len)
-                    // to pick a size-appropriate arena. Using Vec (global mimalloc) here.
                     let mut buf: Vec<u8> = Vec::with_capacity(total_len);
-                    // PERF(port): was appendSliceAssumeCapacity
                     buf.extend_from_slice(&code_result.buffer);
                     buf.extend_from_slice(source_map_start);
                     buf.extend_from_slice(a);
                     buf.extend_from_slice(b);
-                    // PERF(port): was appendAssumeCapacity
                     buf.push(b'\n');
                     code_result.buffer = buf.into_boxed_slice();
                 }
@@ -298,11 +293,8 @@ pub fn write_output_files_to_disk(
 
                 let source_map_start = b"//# sourceMappingURL=data:application/json;base64,";
                 let total_len = code_result.buffer.len() + source_map_start.len() + encode_len + 1;
-                // PERF(port): Zig used `code_with_inline_source_map_allocator` (MaxHeapAllocator)
-                // for this Vec to reuse across iterations.
                 let mut buf: Vec<u8> = Vec::with_capacity(total_len);
 
-                // PERF(port): was appendSliceAssumeCapacity
                 buf.extend_from_slice(&code_result.buffer);
                 buf.extend_from_slice(source_map_start);
 
@@ -310,7 +302,6 @@ pub fn write_output_files_to_disk(
                 buf.resize(old_len + encode_len, 0);
                 let _ = bun_base64::encode(&mut buf[old_len..], &output_source_map);
 
-                // PERF(port): was appendAssumeCapacity
                 buf.push(b'\n');
                 code_result.buffer = buf.into_boxed_slice();
             }
@@ -502,19 +493,20 @@ pub fn write_output_files_to_disk(
                 }
             }),
             entry_point_index: if output_kind == options::OutputKind::EntryPoint {
-                // TODO(port): `bake_types::Framework` is missing
-                // `server_components`; once it lands, restore the
-                // `if c.framework.is_some_and(|fw| fw.server_components.is_some()) { 3 } else { 1 }`
-                // branch.
-                let offset: u32 = 1;
+                // Server-components builds insert 2 extra synthetic sources
+                // before user entry points, so the source-index offset is 3.
+                let offset: u32 = if c.framework.is_some_and(|fw| fw.server_components.is_some()) {
+                    3
+                } else {
+                    1
+                };
                 Some(chunk.entry_point.source_index() - offset)
             } else {
                 None
             },
             referenced_css_chunks: match &chunk.content {
                 Content::Javascript(js) => {
-                    // Zig: `@ptrCast(dupe(u32, js.css_chunks))` — `Index` is
-                    // `#[repr(transparent)]` over u32.
+                    // `Index` is `#[repr(transparent)]` over u32.
                     js.css_chunks
                         .iter()
                         .map(|&i| OutputFileIndex::init(i))
@@ -545,7 +537,7 @@ pub fn write_output_files_to_disk(
     }
 
     {
-        // PORT NOTE: reshaped for borrowck — compute len before mut borrow,
+        // Reshaped for borrowck — compute len before mut borrow,
         // bump `total_insertions`, then take the slice.
         let additional_start = output_files.additional_output_files_start as usize;
         let additional_len = output_files.output_files.len() - additional_start;
@@ -615,5 +607,3 @@ pub fn write_output_files_to_disk(
 }
 
 pub use crate::{DeferredBatchTask, ParseTask, ThreadPool};
-
-// ported from: src/bundler/linker_context/writeOutputFilesToDisk.zig
diff --git a/src/bundler/options.rs b/src/bundler/options.rs
index fa53adadea3..6dc188fc637 100644
--- a/src/bundler/options.rs
+++ b/src/bundler/options.rs
@@ -1,6 +1,7 @@
 //! This file is mostly the API schema but with all the options normalized.
 //! Normalization is necessary because most fields in the API schema are optional
 
+use bun_analytics as analytics;
 use bun_collections::{MultiArrayList, StringArrayHashMap, StringHashMap};
 use bun_core::strings;
 use bun_core::{Global, Output};
@@ -10,26 +11,8 @@ use bun_options_types::schema::api;
 use bun_resolver::fs as Fs;
 use bun_resolver::fs::PathResolverExt as _;
 use bun_resolver::package_json::{MacroMap as MacroRemap, PackageJSON};
-use std::borrow::Cow;
-// TODO(b2-blocked): bun_analytics — Cargo.toml does not yet list the dep
-// (adding it triggers upstream rebuilds with in-progress breakage). The
-// `analytics::features::*` counters are pure telemetry side effects; the
-// increment call-sites below are ``-gated until the dep is wired
-// so the no-op is explicit (PORTING.md §Forbidden patterns: silent no-ops).
-
-mod analytics {
-    #[allow(non_upper_case_globals)]
-    pub(super) mod features {
-        use core::sync::atomic::AtomicUsize;
-        // Zig: `analytics.Features.{define,loaders,macros,external} += n`.
-        // Real statics live in `bun_analytics::features::*` (AtomicUsize).
-        pub(crate) static define: AtomicUsize = AtomicUsize::new(0);
-        pub(crate) static loaders: AtomicUsize = AtomicUsize::new(0);
-        pub(crate) static macros: AtomicUsize = AtomicUsize::new(0);
-        pub(crate) static external: AtomicUsize = AtomicUsize::new(0);
-    }
-}
 use enum_map::EnumMap;
+use std::borrow::Cow;
 
 pub use crate::defines;
 pub use defines::Define;
@@ -39,18 +22,16 @@ pub use defines::Define;
 use crate::defines::{DefineDataExt as _, DefineExt as _};
 pub use bun_options_types::global_cache::GlobalCache;
 
-// ── B-2 type aliases for incomplete lower-tier surfaces ──
-// TODO(b2-blocked): bun_resolver::package_json::ESModule::ConditionsMap — module
-// path doesn't expose this yet; local alias matches Zig `StringArrayHashMap(void)`.
-pub type ConditionsMap = StringArrayHashMap<()>;
+// Canonical alias lives in the resolver.
+pub use bun_resolver::package_json::ConditionsMap;
 // TODO(b2-blocked): bun_sys::Dir — directory handle. Mapped to Fd for now
 // (matches `bun.FD.fromStdDir` pattern).
 pub type Dir = bun_sys::Fd;
-/// `Loader.HashTable` (Zig nested type alias). Unified with the canonical
+/// Unified with the canonical
 /// `bun_ast::LoaderHashTable` so the resolver and
 /// bundler share one nominal map type (PORTING.md crate-tier rule).
 pub(crate) use bun_ast::LoaderHashTable;
-/// `Loader.Map` (Zig nested type alias).
+/// Per-[`Loader`] static byte-string map (e.g. the stdin synthetic file names).
 pub type LoaderEnumMap = EnumMap<Loader, &'static [u8]>;
 
 /// `bun.http.MimeType` lives in `bun_http_types` (lower tier), not `bun_http`.
@@ -60,7 +41,7 @@ mod bun_http {
 /// `bun.StringSet` (re-exported for `BundleOptions.bundler_feature_flags`).
 pub use bun_collections::StringSet;
 
-/// `options.zig:Framework.ClientCssInJs` — TYPE_ONLY moved to top of module so
+/// TYPE_ONLY moved to top of module so
 /// `entry_points.rs` (and the inline `options` mod) can resolve it before the
 /// gated `Framework` impl block below.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -89,9 +70,8 @@ pub fn validate_path(
         return Box::default();
     }
     // TODO: switch to getFdPath()-based implementation
-    // PORT NOTE: Zig used `std.fs.path.resolve(arena, &.{cwd, rel_path})`;
     // `join_abs_string` resolves `.`/`..` against `cwd` into a threadlocal
-    // buffer which is then boxed (matches the arena.dupe in the Zig path).
+    // buffer which is then boxed.
     let _ = path_kind;
     let out =
         bun_paths::resolve_path::join_abs_string::<bun_paths::platform::Auto>(cwd, &[rel_path]);
@@ -110,9 +90,6 @@ pub fn validate_path(
     Box::from(out)
 }
 
-// PORT NOTE: options.zig `stringHashMapFromArrays` — inline the construction
-// (see definesFromTransformOptions / loadersFromTransformOptions below).
-
 // `AllowUnresolved` is defined canonically in
 // `bun_js_parser::options` (lower tier) because the parser is the consumer
 // (`P::should_allow_unresolved_dynamic_specifier`). Re-export here so
@@ -128,7 +105,7 @@ pub use bun_js_parser::options::AllowUnresolved;
 // plain `.clone()`.
 pub use bun_resolver::options::{ExternalModules, WildcardPattern};
 
-/// `options.zig` `ExternalModules.isNodeBuiltin`. Free fn (not an inherent
+/// Free fn (not an inherent
 /// method) because `ExternalModules` is now a foreign type and Rust forbids
 /// inherent impls across crates (E0116).
 pub fn is_node_builtin(str: &[u8]) -> bool {
@@ -151,7 +128,7 @@ fn default_wildcard_patterns() -> Vec<WildcardPattern> {
         .collect()
 }
 
-/// `options.zig` `ExternalModules.init`. Free fn for the same orphan-rule
+/// Free fn for the same orphan-rule
 /// reason as [`is_node_builtin`]; stays at bundler tier because it needs
 /// `Fs`/`logger`/`NODE_BUILTIN_PATTERNS`.
 pub fn init_external_modules(
@@ -178,13 +155,7 @@ pub fn init_external_modules(
                 result.node_modules.insert(pattern).expect("unreachable");
             }
         }
-        Target::Bun => {
-            // // TODO: fix this stupid copy
-            // result.node_modules.hash_map.ensureTotalCapacity(BunNodeBuiltinPatternsCompat.len) catch unreachable;
-            // for (BunNodeBuiltinPatternsCompat) |pattern| {
-            //     result.node_modules.insert(pattern) catch unreachable;
-            // }
-        }
+        Target::Bun => {}
         _ => {}
     }
 
@@ -193,7 +164,6 @@ pub fn init_external_modules(
     }
 
     let mut patterns: Vec<WildcardPattern> = Vec::with_capacity(DEFAULT_WILDCARD_PATTERNS.len());
-    // PERF(port): was appendSliceAssumeCapacity
     patterns.extend(default_wildcard_patterns());
 
     for external in externals {
@@ -251,7 +221,7 @@ pub use bun_options_types::bundle_enums::ModuleType;
 pub static MODULE_TYPE_LIST: phf::Map<&'static [u8], ModuleType> = ModuleType::LIST;
 
 // Re-export of `bun_ast::Target`.
-// Spec options.zig:379 has exactly ONE `Target`; re-export the canonical enum so
+// There is exactly ONE `Target`; re-export the canonical enum so
 // `BundleOptions.target`, `js_printer::Options.target`, the resolver, and css
 // targets all share one nominal type (kills the `to_bundle_enums_target` shim).
 pub(crate) use bun_ast::Target;
@@ -310,8 +280,8 @@ const DEFAULT_MAIN_FIELDS_BUN: &[&[u8]] = &[
 /// `bun_bundler::options` so `use bun_bundler::options::TargetExt;` makes
 /// `.bake_graph()` etc. available on the single canonical type.
 pub trait TargetExt: Copy {
-    // pub const fromJS — deleted: see PORTING.md "*_jsc alias" rule.
-    // TODO(port): move to *_jsc — bun_bundler_jsc::options_jsc::target_from_js
+    // `fromJS` lives in `bun_bundler_jsc::options_jsc::target_from_js`
+    // (PORTING.md "*_jsc alias" rule).
 
     fn bake_graph(self) -> crate::bake_types::Graph;
     fn out_extensions(self) -> StringHashMap<&'static [u8]>;
@@ -344,7 +314,6 @@ pub trait TargetExt: Copy {
 
 impl TargetExt for Target {
     fn bake_graph(self) -> crate::bake_types::Graph {
-        // TODO(b0): bake::Graph arrives from move-in (TYPE_ONLY → bundler)
         match self {
             Target::Browser => crate::bake_types::Graph::Client,
             Target::BakeServerComponentsSsr => crate::bake_types::Graph::Ssr,
@@ -383,7 +352,7 @@ pub use bun_options_types::Format;
 pub use bun_options_types::WindowsOptions;
 
 // Re-export of `bun_ast::Loader`.
-// Spec options.zig:568 has exactly ONE `Loader`; re-export so the bundler's
+// There is exactly ONE `Loader`; re-export so the bundler's
 // `BundleOptions.loaders` and the resolver's `Path::loader()` operate on the
 // same nominal type.
 pub(crate) use bun_ast::Loader;
@@ -399,11 +368,10 @@ pub trait LoaderExt: Copy {
     fn to_mime_type(self, paths: &[&[u8]]) -> bun_http_types::MimeType::MimeType;
     fn from_mime_type(mime_type: bun_http::MimeType) -> Loader;
 
-    // PORT NOTE: `pub type Map` hoisted to module-level `LoaderEnumMap`.
+    // `pub type Map` hoisted to module-level `LoaderEnumMap`.
 
     fn stdin_name_map() -> LoaderEnumMap {
-        let mut map: LoaderEnumMap = EnumMap::from_array([b"" as &[u8]; 21]);
-        // TODO(port): EnumMap::from_array length must match variant count.
+        let mut map: LoaderEnumMap = EnumMap::from_fn(|_| b"" as &[u8]);
         map[Loader::Jsx] = b"input.jsx";
         map[Loader::Js] = b"input.js";
         map[Loader::Ts] = b"input.ts";
@@ -423,10 +391,10 @@ pub trait LoaderExt: Copy {
         map
     }
 
-    // pub const fromJS — deleted: see PORTING.md "*_jsc alias" rule.
-    // TODO(port): move to *_jsc — bun_bundler_jsc::options_jsc::loader_from_js
+    // `fromJS` lives in `bun_bundler_jsc::options_jsc::loader_from_js`
+    // (PORTING.md "*_jsc alias" rule).
 
-    // PORT NOTE: `is_type_script` / `is_java_script_like*` spelling-aliases
+    // `is_type_script` / `is_java_script_like*` spelling-aliases
     // moved to inherent `impl Loader` in `bun_options_types::bundle_enums` so
     // cross-crate callers (bun_jsc / bun_runtime) resolve them without a trait
     // import.
@@ -558,8 +526,6 @@ pub struct LoaderResult<'a> {
     pub package_json: Option<&'a PackageJSON>,
 }
 
-// TODO(b2-blocked): bun_paths::path_literal! + Fs::Path::loader + strings::eql_long
-// arity — body touches VmLoaderCtx vtable which is real but the helper APIs are not.
 pub fn get_loader_and_virtual_source<'a>(
     specifier_str: &'a [u8],
     jsc_vm: &'a VmLoaderCtx,
@@ -578,9 +544,8 @@ pub fn get_loader_and_virtual_source<'a>(
     if let Some(eval_source) = jsc_vm.eval_source() {
         // SAFETY: eval_source outlives jsc_vm
         let eval_source: &'a bun_ast::Source = unsafe { &*eval_source };
-        // Spec: `bun.pathLiteral("/[eval]")` — the eval/stdin entry path is built
-        // via `bun.pathLiteral` (cli.zig / run_command.zig / bun.js.zig), which
-        // rewrites `/` → `\` on Windows, so the suffix uses the platform separator.
+        // The eval/stdin entry path uses the platform path separator
+        // (`/` becomes `\` on Windows), so the suffix is per-platform.
         const EVAL_SUFFIX: &[u8] = if cfg!(windows) {
             b"\\[eval]"
         } else {
@@ -620,8 +585,7 @@ pub fn get_loader_and_virtual_source<'a>(
             if !jsc_vm.blob_needs_read_file(blob) {
                 // SAFETY: `path.text` aliases jsc_vm-owned storage (blob filename
                 // or normalized specifier), which outlives the `virtual_source`
-                // returned to the caller — matches Zig `getLoaderAndVirtualSource`
-                // where `Fs.Path` and `logger.Source.path` share one type.
+                // returned to the caller.
                 let static_text: &'static [u8] = bun_ast::StoreStr::new(path.text).slice();
                 *virtual_source_to_use = Some(bun_ast::Source {
                     path: bun_paths::fs::Path::init(static_text),
@@ -699,9 +663,9 @@ const DEFAULT_LOADERS_POSIX: &[(&[u8], Loader)] = &[
 #[cfg(all(windows, test))]
 const DEFAULT_LOADERS_WIN32_EXTRA: &[(&[u8], Loader)] = &[(b".sh", Loader::Bunsh)];
 
-/// File-extension → default [`Loader`] map (options.zig `defaultLoaders`).
+/// File-extension → default [`Loader`] map.
 ///
-/// PERF(port): was `phf::Map<&[u8], Loader>`. phf hashes the full key (SipHash
+/// PERF: deliberately not a `phf::Map<&[u8], Loader>`. phf hashes the full key (SipHash
 /// over up to 9 bytes) + probes a displacement table + does a final memcmp on
 /// every lookup. With only 22 keys bucketing into 5 distinct lengths
 /// (3/4/5/6/9, all `.`-prefixed), a length-gated `match` is cheaper: one
@@ -774,7 +738,7 @@ impl DefaultLoaders {
 #[test]
 fn default_loaders_match_table() {
     // Guard against drift between the length-gated match and the canonical
-    // tuple list above (Zig source of truth).
+    // tuple list above.
     for (ext, loader) in DEFAULT_LOADERS_POSIX {
         assert_eq!(DEFAULT_LOADERS.get(ext), Some(loader), "ext {:?}", ext);
     }
@@ -824,7 +788,6 @@ impl ESMConditions {
         require_condition_map.reserve(defaults.len() + 2 + addon_extra + conditions.len());
         style_condition_map.reserve(defaults.len() + 2 + conditions.len());
 
-        // PERF(port): was assume_capacity
         import_condition_map.insert(b"import".as_slice(), ());
         require_condition_map.insert(b"require".as_slice(), ());
         style_condition_map.insert(b"style".as_slice(), ());
@@ -863,8 +826,7 @@ impl ESMConditions {
         })
     }
 
-    pub fn clone(&self) -> Result<ESMConditions, bun_core::Error> {
-        // TODO(port): narrow error set
+    pub fn clone(&self) -> Result<ESMConditions, bun_alloc::AllocError> {
         let default = self.default.clone()?;
         let import = self.import.clone()?;
         let require = self.require.clone()?;
@@ -885,7 +847,6 @@ impl ESMConditions {
         self.style.reserve(conditions.len());
 
         for condition in conditions {
-            // PERF(port): was assume_capacity
             self.default.insert(*condition, ());
             self.import.insert(*condition, ());
             self.require.insert(*condition, ());
@@ -928,7 +889,7 @@ pub use default_user_defines as DefaultUserDefines;
 
 pub fn defines_from_transform_options(
     log: &mut bun_ast::Log,
-    // PERF(port): borrowed, not owned — the caller (`load_defines`) holds
+    // PERF: borrowed, not owned — the caller (`load_defines`) holds
     // `transform_options` behind an `Arc`, so taking the `StringMap` by value
     // forced a full deep clone of the `--define` map *every* VM init even though
     // each value gets cloned again below on insert. Reading it through `&` keeps
@@ -948,11 +909,9 @@ pub fn defines_from_transform_options(
         None => (&[], &[]),
     };
 
-    // PORT NOTE: Zig stringHashMapFromArrays — inlined as concrete RawDefines build (over-reserves +4).
     let mut user_defines: defines::RawDefines = defines::RawDefines::default();
     user_defines.reserve(input_keys.len() + 4);
     for (i, key) in input_keys.iter().enumerate() {
-        // PERF(port): was assume_capacity
         user_defines.insert(key.as_ref(), input_values[i].clone());
     }
 
@@ -979,7 +938,7 @@ pub fn defines_from_transform_options(
             break 'load_env;
         }
 
-        // PORT NOTE: flatten `api::StringMap` into parallel borrowed slices.
+        // flatten `api::StringMap` into parallel borrowed slices.
         // `api::DotEnvBehavior` is the same type as `DotEnv::DotEnvBehavior`
         // (re-export), so no conversion needed.
         let api_defaults = framework.to_api().defaults;
@@ -1121,7 +1080,7 @@ impl ResolveFileExtensions {
 }
 
 /// Convert a static `&[&[u8]]` default into an owned `Box<[Box<[u8]>]>`.
-/// PERF(port): the Zig kept these as borrowed `[]const string`; we own them so
+/// We own them so
 /// user-provided lists (e.g. `transform.extension_order`) can be stored without
 /// `Box::leak` (PORTING.md §Forbidden patterns).
 #[inline]
@@ -1174,13 +1133,12 @@ pub fn loaders_from_transform_options(
     let mut loaders = StringArrayHashMap::<Loader>::default();
     loaders.reserve(u32::try_from(total_capacity).expect("int cast") as usize);
     for (i, ext) in input_loaders.extensions.iter().enumerate() {
-        // PERF(port): was assume_capacity
         loaders.insert(ext, loader_values[i]);
     }
 
-    // PORT NOTE: Zig `getOrPutValue` → contains+insert; `Loader` is not `Default`
+    // contains+insert (only when absent); `Loader` is not `Default`
     // so the `V: Default`-gated `StringArrayHashMap::get_or_put_value` does not
-    // apply. Semantics are identical (insert only when absent).
+    // apply.
     for ext in DEFAULT_LOADER_EXT {
         if !loaders.contains(*ext) {
             loaders.insert(*ext, *DEFAULT_LOADERS.get(*ext).unwrap());
@@ -1206,8 +1164,6 @@ pub fn loaders_from_transform_options(
     Ok(loaders)
 }
 
-// PORT NOTE: `Dir` alias hoisted to top of file (= bun_sys::Fd).
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum SourceMapOption {
     #[default]
@@ -1241,7 +1197,7 @@ impl SourceMapOption {
     }
 }
 
-// PORT NOTE: hoisted from `impl SourceMapOption` — Rust forbids `static` in inherent impls.
+// hoisted from `impl SourceMapOption` — Rust forbids `static` in inherent impls.
 pub static SOURCE_MAP_OPTION_MAP: phf::Map<&'static [u8], SourceMapOption> = phf::phf_map! {
     b"none" => SourceMapOption::None,
     b"inline" => SourceMapOption::Inline,
@@ -1271,7 +1227,7 @@ impl PackagesOption {
     }
 }
 
-// PORT NOTE: hoisted from `impl PackagesOption` — Rust forbids `static` in inherent impls.
+// hoisted from `impl PackagesOption` — Rust forbids `static` in inherent impls.
 pub static PACKAGES_OPTION_MAP: phf::Map<&'static [u8], PackagesOption> = phf::phf_map! {
     b"external" => PackagesOption::External,
     b"bundle" => PackagesOption::Bundle,
@@ -1287,10 +1243,8 @@ pub struct BundleOptions<'a> {
     /// Set of enabled feature flags for dead-code elimination via `import { feature } from "bun:bundle"`.
     /// Initialized once from the CLI --feature flags.
     ///
-    /// Zig: `*const bun.StringSet = &Runtime.Features.empty_bundler_feature_flags`.
     /// `None` ≡ the static empty set; `Some` is the owned `Box` returned by
-    /// `Runtime::Features::init_bundler_feature_flags` (freed on Drop, matching
-    /// options.zig:1888-1892 which frees iff distinct from the static empty set).
+    /// `Runtime::Features::init_bundler_feature_flags` (freed on Drop).
     pub bundler_feature_flags: Option<Box<StringSet>>,
     pub loaders: LoaderHashTable,
     pub resolve_dir: Cow<'static, [u8]>,
@@ -1306,9 +1260,8 @@ pub struct BundleOptions<'a> {
     pub hot_module_reloading: bool,
     pub react_fast_refresh: bool,
     pub inject: Option<Box<[Box<[u8]>]>>,
-    // TODO(port): lifetime — `bun_url::URL<'a>` borrows its input string. Zig
-    // stored it borrowing `transform_options.origin` (sibling field). Using the
-    // owned variant so the struct is self-contained.
+    // `bun_url::URL<'a>` borrows its input string; the owned variant keeps the
+    // struct self-contained.
     pub origin: bun_url::OwnedURL,
     pub output_dir_handle: Option<Dir>,
 
@@ -1331,7 +1284,7 @@ pub struct BundleOptions<'a> {
     pub target: Target,
     pub main_fields: Box<[Box<[u8]>]>,
     /// TODO: remove this in favor accessing bundler.log
-    /// PORT NOTE: raw `*mut` (not `&'a mut`) — Zig aliases the same `*Log`
+    /// raw `*mut` (not `&'a mut`) — the same `*Log` is aliased
     /// into `Transpiler.log` / `Resolver.log` / `Linker.log`. A stored
     /// `&'a mut` here would assert uniqueness for `'a` and make every access
     /// through those sibling raw pointers UB under stacked borrows.
@@ -1380,7 +1333,7 @@ pub struct BundleOptions<'a> {
     pub global_cache: GlobalCache,
     pub prefer_offline_install: bool,
     pub prefer_latest_install: bool,
-    /// Spec `options.zig:1753`: `?*const Api.BunInstall`. Stored as a raw
+    /// Stored as a raw
     /// `NonNull` (not `Option<&'a _>`) because every CLI caller borrows the
     /// process-lifetime `ctx.install: Box<BunInstall>` whose lifetime is
     /// unrelated to `'a`; a typed reference forced an `unsafe { &*(p as *const _) }`
@@ -1422,7 +1375,6 @@ pub struct BundleOptions<'a> {
     // directly — all access goes through crate::dispatch::DevServerVTable.
     pub dev_server: *const (),
     /// Set when Bake is bundling. Affects module resolution.
-    // TODO(b0): bake::Framework arrives from move-in (TYPE_ONLY → bundler)
     pub framework: Option<&'a crate::bake_types::Framework>,
 
     pub serve_plugins: Option<Box<[Box<[u8]>]>>,
@@ -1489,8 +1441,7 @@ impl<'a> BundleOptions<'a> {
     /// them on the worker dropped the parent's allocation). Every owned field
     /// is `Clone`d; raw-pointer / `Copy` / `&'a` fields copy directly.
     ///
-    /// PERF(port): Zig's `transpiler.* = from.*` is a shallow struct copy
-    /// (slices alias the parent's arena). The Rust port owns these as `Box`,
+    /// These fields are owned as `Box`,
     /// so a per-worker clone allocates. Profile if it shows up on a hot path;
     /// the hot fields (`define`, `loaders`, `conditions`) are O(dozens) entries.
     pub fn for_worker(&self) -> BundleOptions<'a> {
@@ -1619,8 +1570,9 @@ impl<'a> BundleOptions<'a> {
 
     /// Shared-borrow the per-Transpiler `Log`.
     ///
-    /// SAFETY: `self.log` is non-null once `from_api` / `Transpiler::init` has
-    /// run (Zig spec `options.zig:1714`: `log: *logger.Log`, non-optional).
+    /// SAFETY: `self.log` is non-null: `Transpiler::init_in_place` validates
+    /// the pointer via `NonNull::new(log).expect(..)` before storing it and
+    /// before calling `from_api` (which has no other callers).
     /// The pointee is the caller-owned arena `Log` which outlives `self`. The
     /// same allocation is aliased into `Transpiler.log` / `Resolver.log` /
     /// `Linker.log` as raw `*mut`; a `&` here is sound so long as no caller
@@ -1690,17 +1642,13 @@ impl<'a> BundleOptions<'a> {
         !self.defines_loaded
     }
 
-    // TODO(b2-blocked): defines_from_transform_options (see above) +
-    // api::TransformOptions.define field (peechy `TransformOptions` body still
-    // opaque).
     pub fn load_defines(
         &mut self,
         arena: &bun_alloc::Arena,
         loader_: Option<&mut DotEnv::Loader>,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: spec `loadDefines(..., env: ?*const options.Env)` had its
-        // sole caller pass `&this.options.env` (transpiler.zig:334). Forwarding
-        // that as `Option<&Env>` forced the caller into an aliased-`&mut` UB
+        // Forwarding the env as an `Option<&Env>` parameter forced the
+        // caller into an aliased-`&mut` UB
         // raw-pointer dance under Stacked Borrows. Dropped the param and read
         // `&self.env` here instead — disjoint from the `self.define` /
         // `self.defines_loaded` writes below, so borrowck splits it cleanly.
@@ -1712,7 +1660,7 @@ impl<'a> BundleOptions<'a> {
         if self.defines_loaded {
             return Ok(());
         }
-        // PERF(port): the spec uses borrowed static literals for the three
+        // PERF: borrowed static literals for the three
         // constant cases; only the env-loader case needs an owned copy (it has
         // to outlive the `&mut loader_` we pass below, so it can't stay a borrow
         // into the loader). `Cow` keeps the literals zero-alloc — matters because
@@ -1734,7 +1682,7 @@ impl<'a> BundleOptions<'a> {
 
             Some(Cow::Borrowed(b"\"development\"".as_slice()))
         };
-        // PORT NOTE: reshaped for borrowck — node_env computed before passing self.log
+        // reshaped for borrowck — node_env computed before passing self.log
         self.define = defines_from_transform_options(
             // No other `&mut Log` is live across this call (see `log_mut`
             // caller contract).
@@ -1744,7 +1692,8 @@ impl<'a> BundleOptions<'a> {
             loader_,
             Some(&self.env),
             node_env.as_deref(),
-            // TODO(port): &self.drop is Box<[Box<[u8]>]>, callee wants &[&[u8]]
+            // `&self.drop` is `Box<[Box<[u8]>]>`; the callee wants `&[&[u8]]`,
+            // so re-borrow per call (cold path: once per options build).
             &self.drop.iter().map(|s| s.as_ref()).collect::<Vec<_>>(),
             self.dead_code_elimination && self.minify_syntax,
             arena,
@@ -1780,13 +1729,11 @@ impl<'a> BundleOptions<'a> {
                 .collect::<Vec<&[u8]>>(),
         );
 
-        // TODO(port): many fields below have Zig defaults via `= ...`; in Rust we initialize
-        // each explicitly. Could add a `Default`-ish builder.
         let mut opts = BundleOptions {
             footer: Cow::Borrowed(b""),
             banner: Cow::Borrowed(b""),
             log,
-            // PORT NOTE: `define` is `undefined` in Zig and filled by `loadDefines` later;
+            // `define` is filled by `load_defines` later;
             // initialize empty so the struct is well-formed before `load_defines` runs.
             define: Box::new(defines::Define {
                 identifiers: Default::default(),
@@ -1891,7 +1838,6 @@ impl<'a> BundleOptions<'a> {
             optimize_imports: None,
         };
 
-        // TODO(b2-blocked): bun_analytics dep not yet wired in bundler/Cargo.toml
         {
             analytics::features::define
                 .fetch_add(usize::from(transform.define.is_some()), Ordering::Relaxed);
@@ -1912,9 +1858,7 @@ impl<'a> BundleOptions<'a> {
         opts.env.disable_default_env_files = transform.disable_default_env_files;
 
         if let Some(origin) = &transform.origin {
-            // PORT NOTE: ownership — `URL<'_>` borrows its input. The Zig
-            // `URL.parse` borrowed `transform.origin` (a sibling of
-            // `opts.transform_options`); here `OwnedURL` owns the href and
+            // ownership — `URL<'_>` borrows its input; `OwnedURL` owns the href and
             // callers borrow via `.url()`.
             opts.origin = bun_url::OwnedURL::from_href(origin.clone());
         }
@@ -1991,7 +1935,7 @@ impl<'a> BundleOptions<'a> {
                 .collect();
         }
 
-        // PORT NOTE: Zig passed `log` directly; reborrow the raw `*mut Log`
+        // Reborrow the raw `*mut Log`
         // for the duration of this call only.
         opts.external = init_external_modules(
             &mut fs.fs,
@@ -2024,8 +1968,7 @@ impl<'a> BundleOptions<'a> {
         if opts.write && !opts.output_dir.is_empty() {
             let handle = open_output_dir(&opts.output_dir)?;
             opts.output_dir_handle = Some(handle);
-            // PORT NOTE: Zig `fs.getFdPath(.fromStdDir(handle))` interns into
-            // `dirname_store`; the inline `bun_resolver::fs::FileSystem` does
+            // The inline `bun_resolver::fs::FileSystem` does
             // not yet expose `get_fd_path`, so resolve via `bun_sys` and box.
             let mut buf = bun_paths::PathBuffer::uninit();
             let dir = bun_sys::get_fd_path(handle, &mut buf).map_err(bun_core::Error::from)?;
@@ -2038,7 +1981,6 @@ impl<'a> BundleOptions<'a> {
             opts.tsconfig_override = Some(tsconfig.clone());
         }
 
-        // TODO(b2-blocked): bun_analytics dep not yet wired in bundler/Cargo.toml
         {
             analytics::features::macros.fetch_add(
                 usize::from(opts.target == Target::BunMacro),
@@ -2057,9 +1999,7 @@ impl Drop for BundleOptions<'_> {
     fn drop(&mut self) {
         // self.define dropped automatically (Box<Define>).
         //
-        // bundler_feature_flags: Zig compared the pointer to
-        // `&Runtime.Features.empty_bundler_feature_flags` and freed iff distinct.
-        // In Rust the field is `Option<Box<StringSet>>`; `None` ≡ the static
+        // bundler_feature_flags is `Option<Box<StringSet>>`; `None` ≡ the static
         // empty set (nothing to free), `Some` drops the Box here automatically.
     }
 }
@@ -2099,12 +2039,11 @@ pub mod bundle_options_defaults {
 }
 
 pub fn open_output_dir(output_dir: &[u8]) -> Result<Dir, bun_core::Error> {
-    // PORT NOTE: Zig used `std.fs.cwd().openDir/.makeDir`; routed through
-    // `bun_sys` per CLAUDE.md (never `std::fs`).
+    // Routed through `bun_sys` per CLAUDE.md (never `std::fs`).
     match bun_sys::open_dir_at(bun_sys::Fd::cwd(), output_dir) {
         Ok(d) => Ok(d),
         Err(_) => {
-            // Zig: `std.fs.cwd().makeDir(output_dir)` — single-level mkdir
+            // Single-level mkdir
             // (fails ENOENT if parent missing). Do NOT use `make_path` (the
             // recursive `mkdir -p` variant) here.
             let mut buf = bun_paths::PathBuffer::uninit();
@@ -2138,8 +2077,8 @@ pub fn open_output_dir(output_dir: &[u8]) -> Result<Dir, bun_core::Error> {
     }
 }
 
-/// Port of `fs.zig` `Fs.File` (path + contents pair). `bun_resolver::fs`
-/// does not surface this type yet (TODO(b2-blocked)); local mirror keeps
+/// Path + contents pair. `bun_resolver::fs`
+/// does not surface this type; local mirror keeps
 /// `TransformOptions.entry_point` self-contained.
 pub struct EntryPointFile {
     pub path: bun_paths::fs::Path<'static>,
@@ -2178,7 +2117,6 @@ impl TransformOptions {
         };
 
         let mut _cwd: Box<[u8]> = Box::from(b"/".as_slice());
-        // TODO(port): Environment.isWasi
         #[cfg(any(target_os = "wasi", windows))]
         {
             // `getcwd_alloc` returns a NUL-terminated `ZBox`; strip the NUL
@@ -2190,7 +2128,6 @@ impl TransformOptions {
 
         let mut define = StringHashMap::<Box<[u8]>>::default();
         define.reserve(1);
-        // PERF(port): was assume_capacity
         define.put_assume_capacity(b"process.env.NODE_ENV", b"development".as_slice().into());
 
         let entry_point_name = entry_point.path.name();
@@ -2207,7 +2144,8 @@ impl TransformOptions {
             loader,
             resolve_dir: Box::from(entry_point_name.dir),
             entry_point,
-            // TODO(port): resolve_dir borrows from entry_point in Zig; cloned here
+            // resolve_dir is cloned so
+            // `TransformOptions` stays lifetime-free.
             main_fields: Target::default_main_fields_map()[Target::Browser],
             jsx: if loader.is_jsx() {
                 Some(jsx::Pragma::default())
@@ -2274,7 +2212,7 @@ pub struct EnvEntry {
 
 type EnvList = MultiArrayList<EnvEntry>;
 
-// PORT NOTE: `Debug` derive dropped — `MultiArrayList<T>` is not `Debug`.
+// `Debug` derive dropped — `MultiArrayList<T>` is not `Debug`.
 pub struct Env {
     pub behavior: api::DotEnvBehavior,
     pub prefix: Box<[u8]>,
@@ -2327,7 +2265,6 @@ impl Env {
         self.defaults.ensure_total_capacity(defaults.keys.len())?;
 
         for (i, key) in defaults.keys.iter().enumerate() {
-            // PERF(port): was assume_capacity
             self.defaults.append(EnvEntry {
                 key: key.clone(),
                 value: defaults.values[i].clone(),
@@ -2406,7 +2343,7 @@ impl Env {
     }
 }
 
-// PORT NOTE: `Debug` derive dropped — `Env` is not `Debug` (MultiArrayList).
+// `Debug` derive dropped — `Env` is not `Debug` (MultiArrayList).
 #[derive(Default)]
 pub struct EntryPoint {
     pub path: Box<[u8]>,
@@ -2542,9 +2479,7 @@ pub(crate) fn path_template_needs(data: &[u8], field: PlaceholderField) -> bool
 }
 
 // Shared body for PathTemplate::print / PathTemplateConst::print (D064).
-// PORT NOTE: Zig `format(self, comptime _, _, writer: anytype)` writes raw path bytes via
-// writer.writeAll; mapped to a byte-writer free fn (not `core::fmt::Display`) per
-// PORTING.md "(comptime X: type, arg: X) writer → &mut impl bun_io::Write (bytes)".
+// Writes raw path bytes via a byte-writer free fn (not `core::fmt::Display`).
 pub(crate) fn path_template_print<W: bun_io::Write>(
     writer: &mut W,
     data: &[u8],
@@ -2717,7 +2652,7 @@ pub struct Placeholder {
     pub target: Box<[u8]>,
 }
 
-// PORT NOTE: hoisted from `impl Placeholder` — Rust forbids `static` in inherent impls.
+// hoisted from `impl Placeholder` — Rust forbids `static` in inherent impls.
 pub static PLACEHOLDER_MAP: phf::Map<&'static [u8], PlaceholderField> = phf::phf_map! {
     b"dir" => PlaceholderField::Dir,
     b"name" => PlaceholderField::Name,
@@ -2753,8 +2688,8 @@ impl PlaceholderConst {
 }
 
 impl PathTemplateConst {
-    /// Byte-writer form mirroring [`PathTemplate::print`] (Zig
-    /// `PathTemplate.format`). Kept as an inherent method so callers writing
+    /// Byte-writer form mirroring [`PathTemplate::print`].
+    /// Kept as an inherent method so callers writing
     /// to `Vec<u8>` via `write!(.., "{}", template)` resolve through the
     /// blanket [`core::fmt::Display`] impl below.
     pub fn print<W: bun_io::Write>(&self, writer: &mut W) -> bun_io::Result<()> {
@@ -2804,5 +2739,3 @@ impl From<PathTemplateConst> for PathTemplate {
         }
     }
 }
-
-// ported from: src/bundler/options.zig
diff --git a/src/bundler/transpiler.rs b/src/bundler/transpiler.rs
index 219d05f478a..8b9ed7db971 100644
--- a/src/bundler/transpiler.rs
+++ b/src/bundler/transpiler.rs
@@ -16,15 +16,14 @@ use bun_router::Router;
 
 use crate::options;
 
-/// Port of `transpiler.zig:ResolveResults` — keyed by source path hash.
+/// Keyed by source path hash.
 pub(crate) type ResolveResults = HashMap<u64, ()>;
-/// Port of `transpiler.zig:ResolveQueue` — `std.fifo.LinearFifo(resolver.Result, .Dynamic)`.
-// PORT NOTE: `bun_collections::LinearFifo<T, DynamicBuffer<T>>` would be exact,
+// `bun_collections::LinearFifo<T, DynamicBuffer<T>>` would be exact,
 // but `DynamicBuffer` isn't re-exported from `bun_collections` yet. `VecDeque`
 // is structurally equivalent (growable ring buffer); swap once the re-export lands.
 pub(crate) type ResolveQueue = std::collections::VecDeque<resolver::Result>;
 
-/// Spec `JSGlobalObject.BunPluginTarget` (JSGlobalObject.zig:265). Defined at
+/// Defined at
 /// this tier (lowest crate that needs to name it) and re-exported from
 /// `bun_jsc::BunPluginTarget` so there is exactly one enum (no bridge between
 /// mirror types).
@@ -39,11 +38,11 @@ pub enum BunPluginTarget {
 // Crosses FFI by-value to `JSBundlerPlugin__create` / `Bun__runOn*Plugins`
 // (C++: `typedef uint8_t BunPluginTarget`, `headers-handwritten.h`). NB: the
 // C++ header's *named* constants (`BunPluginTargetBrowser = 1`, `Node = 2`)
-// disagree with Zig `JSGlobalObject.zig:265` (`node = 1`, `browser = 2`); Rust
-// matches the Zig spec. The width (`u8`) is what matters at the ABI.
+// disagree with the Rust enum (`Node = 1`, `Browser = 2`). The width (`u8`)
+// is what matters at the ABI.
 bun_core::assert_ffi_discr!(BunPluginTarget, u8; Bun = 0, Node = 1, Browser = 2);
 
-/// Spec PluginRunner.zig:34 `onResolve` — the JSC-aware resolve hook.
+/// The JSC-aware resolve hook.
 ///
 /// The body calls `JSGlobalObject.runOnResolvePlugins`, so it cannot be
 /// defined at this tier (`bun_jsc` depends on this crate). `bun_jsc` provides
@@ -62,14 +61,15 @@ pub trait PluginResolver {
     ) -> Result<Option<bun_paths::fs::Path<'static>>, bun_core::Error>;
 }
 
-/// Spec PluginRunner.zig — namespace for the static byte-level helpers
+/// Namespace for the static byte-level helpers
 /// (`extractNamespace` / `couldBePlugin`). The stateful struct (with
 /// `global_object`) lives in `bun_jsc::PluginRunner` where `JSGlobalObject` is
 /// nameable; only the JSC-free helpers stay at this tier.
 pub struct PluginRunner;
 
 impl PluginRunner {
-    /// Spec PluginRunner.zig:14 `extractNamespace`.
+    /// Returns the `namespace:` prefix of `specifier`, or `b""` if it has none
+    /// (Windows drive-letter prefixes are not namespaces).
     pub fn extract_namespace(specifier: &[u8]) -> &[u8] {
         let Some(colon) = bun_core::index_of_char(specifier, b':') else {
             return b"";
@@ -87,7 +87,7 @@ impl PluginRunner {
         &specifier[..colon]
     }
 
-    /// Spec PluginRunner.zig:22 `couldBePlugin` — cheap pre-filter that rules
+    /// Cheap pre-filter that rules
     /// out `./` / `../` / absolute paths before hitting the resolve hook.
     pub fn could_be_plugin(specifier: &[u8]) -> bool {
         if let Some(last_dot) = bun_core::last_index_of_char(specifier, b'.') {
@@ -105,11 +105,10 @@ impl PluginRunner {
     }
 }
 
-/// Spec `transpiler.zig:5` — `pub const MacroJSCtx = @import("../bundler_jsc/PluginRunner.zig").MacroJSCtx`.
 /// The canonical newtype lives in `bun_ast::Macro` (the lowest tier that
-/// stores it, in `MacroContext.javascript_object`); re-exported here per spec.
+/// stores it, in `MacroContext.javascript_object`); re-exported here.
 pub use js_ast::Macro::MacroJSCtx;
-/// Spec `transpiler.zig:1433 default_macro_js_value` (= `JSValue.zero`).
+/// The default (zero) macro JS context value.
 #[inline]
 pub const fn default_macro_js_value() -> MacroJSCtx {
     MacroJSCtx::ZERO
@@ -123,18 +122,16 @@ pub const fn default_macro_js_value() -> MacroJSCtx {
 /// on every VM so that the options can be used for transpilation.
 pub struct Transpiler<'a> {
     pub options: options::BundleOptions<'a>,
-    // PORT NOTE: raw ptr — Zig aliased the same `*Log` into `linker.log` and
+    // Raw ptr — the same `*Log` is aliased into `linker.log` and
     // `resolver.log` (see `set_log`). `&'a mut` would forbid that aliasing.
-    // TODO(port): lifetime — restructure once linker/resolver own their logs.
     pub log: *mut bun_ast::Log,
-    // TODO(port): arena — bundler is an AST crate per PORTING.md so we
-    // thread an arena, but callers usually pass `bun.default_allocator`.
-    // Confirm whether this should be removed (global mimalloc) or kept.
+    // Bundler is an AST crate per PORTING.md, so an arena is threaded even
+    // though callers usually pass `bun.default_allocator`.
     pub arena: &'a Arena,
     pub result: options::TransformResult,
     pub resolver: Resolver<'a>,
-    // TODO(port): lifetime — Zig used the global `Fs.FileSystem.instance`
-    // singleton (`&'static mut`). Raw ptr until the singleton accessor lands.
+    // Raw ptr — points at the shared global `FileSystem` singleton; a stored
+    // `&'a mut` would assert uniqueness it cannot have.
     pub fs: *mut Fs::FileSystem,
     pub output_files: Vec<options::OutputFile>,
     pub resolve_results: Box<ResolveResults>,
@@ -149,7 +146,7 @@ pub struct Transpiler<'a> {
     // by `configure_linker` below; `set_log` keeps `linker.log` in sync.
     pub linker: crate::linker::Linker,
     pub timer: SystemTimer,
-    // TODO(port): lifetime — Zig stored `&DotEnv.Loader` (global singleton).
+    // Raw ptr — the global `DotEnv::Loader` singleton.
     pub env: *mut dot_env::Loader<'a>,
 
     pub macro_context: Option<js_ast::Macro::MacroContext>,
@@ -158,25 +155,22 @@ pub struct Transpiler<'a> {
 impl<'a> Transpiler<'a> {
     pub const IS_CACHE_ENABLED: bool = false;
 
-    /// Port of `transpiler.zig:95 setLog`.
-    ///
-    /// PORT NOTE: takes `*mut Log` (not `&'a mut`) because Zig aliased the same
-    /// `*Log` into `linker.log` / `resolver.log`; the un-gated struct field is
+    /// Takes `*mut Log` (not `&'a mut`) because the same
+    /// `*Log` is aliased into `linker.log` / `resolver.log`; the un-gated struct field is
     /// already a raw pointer for that reason.
     pub fn set_log(&mut self, log: *mut bun_ast::Log) {
         self.log = log;
         self.linker.log = log;
         // SAFETY: caller (`ThreadPool::Worker::create`) passes the per-worker
-        // arena-allocated `Log`, which outlives this `Transpiler<'a>`. Zig
-        // aliased the same `*Log` into `resolver.log`.
+        // arena-allocated `Log`, which outlives this `Transpiler<'a>`.
         self.resolver.log = core::ptr::NonNull::new(log).expect("set_log: log is non-null");
     }
 
-    /// Port of `transpiler.zig:102 setAllocator`.
+    /// Replace the transpiler's arena and re-init the macro context against it.
     // TODO: remove this method. it does not make sense
     pub fn set_arena(&mut self, arena: &'a Arena) {
         self.arena = arena;
-        // PORT NOTE: `crate::Linker` is the unit stub — no `.arena` field.
+        // `crate::Linker` is the unit stub — no `.arena` field.
         // `Resolver` dropped its `arena` field (global mimalloc; see
         // resolver/lib.rs `// arena: dropped`), so nothing left to thread.
     }
@@ -196,8 +190,8 @@ impl<'a> Transpiler<'a> {
     /// `&'static mut`. Owned `Transpiler`s from [`Self::for_worker`] must use
     /// normal `Drop` instead.
     pub unsafe fn deinit(&mut self) {
-        // The lazily-created `Box<bun_js_parser_jsc::Macro::MacroContext>` was
-        // intentionally process-lifetime under Zig (`default_allocator`), but
+        // The lazily-created `Box<bun_js_parser_jsc::Macro::MacroContext>` is
+        // process-lifetime by default, but
         // worker VMs run `destroy()` on thread exit and would otherwise strand
         // one box per worker. The box only owns a `MacroMap` and an optional
         // `bun_alloc::Arena` — no JSC handles — so freeing it from either
@@ -260,7 +254,7 @@ impl<'a> Transpiler<'a> {
     /// other `self.*` fields as arguments without a borrow-checker conflict;
     /// callers must not hold two results live at once, nor hold a result
     /// across a `self.{resolver,linker}` call that itself writes to the
-    /// aliased `*mut Log` (see field PORT NOTE — same allocation is threaded
+    /// aliased `*mut Log` (see field comment — same allocation is threaded
     /// into `linker.log` / `resolver.log`).
     #[inline]
     #[allow(clippy::mut_from_ref)]
@@ -289,7 +283,7 @@ impl<'a> Transpiler<'a> {
     /// Reborrow the `DotEnv::Loader`. Returned lifetime is decoupled from
     /// `&self` so call sites in `configure_defines` / `run_env_loader` can
     /// hold it across disjoint `&mut self.options` / `&mut self.resolver`
-    /// borrows (matching Zig's free `this.env.*` access).
+    /// borrows.
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn env_mut(&self) -> &'a mut dot_env::Loader<'a> {
@@ -301,11 +295,9 @@ impl<'a> Transpiler<'a> {
         unsafe { &mut *self.env }
     }
 
-    /// Per-worker / client-transpiler constructor — port of Zig's
-    /// `transpiler.* = from.*` (ThreadPool.zig:308, bundle_v2.zig:204).
+    /// Per-worker / client-transpiler constructor.
     ///
-    /// Zig structs have no destructors, so a bitwise struct copy that aliases
-    /// heap-owning fields is sound there. In Rust the prior bitwise
+    /// The prior bitwise
     /// `ptr::copy_nonoverlapping` aliased every `Box`/`Vec` between parent and
     /// worker; reassigning any of them on the worker (e.g.
     /// `resolver.caches = ...`) ran `Drop` on the parent's allocation. This
@@ -353,8 +345,7 @@ impl<'a> Transpiler<'a> {
             options,
             log,
             arena,
-            // Per-worker scratch — Zig's bitwise copy carried these too, but
-            // workers never read the parent's accumulated state.
+            // Per-worker scratch — workers never read the parent's accumulated state.
             result: options::TransformResult::default(),
             resolver,
             fs: from.fs,
@@ -381,7 +372,7 @@ impl<'a> Transpiler<'a> {
             // SAFETY: lifetime-widen the `Loader<'from>` raw pointer to `'a`
             // (process-lifetime singleton; see fn doc).
             env: from.env.cast(),
-            // Spec ThreadPool.zig:311 `MacroContext.init(transpiler)` takes the
+            // `MacroContext::init(transpiler)` takes the
             // transpiler's *address*; deferred to `wire_after_move`.
             macro_context: None,
         }
@@ -389,22 +380,19 @@ impl<'a> Transpiler<'a> {
 
     /// Wire the self-referential `linker` back-pointers and `macro_context`
     /// after this `Transpiler` has reached its final address (post-move into
-    /// `WorkerData` / arena slot). Port of the post-copy fixups in
-    /// ThreadPool.zig:309-313 / bundle_v2.zig:228-232.
+    /// `WorkerData` / arena slot).
     pub fn wire_after_move(&mut self) {
-        // Spec: `transpiler.setLog(log)` already ran inside `for_worker` via
-        // direct field init; re-thread into `options.log` / `resolver.log` /
+        // `self.log` was already set inside `for_worker` via direct field
+        // init; re-thread into `options.log` / `resolver.log` /
         // `linker.log` here so all four aliases agree.
         let log = self.log;
         self.options.log = log;
         self.resolver.log = core::ptr::NonNull::new(log).expect("wire_after_move: log is non-null");
         self.resolver.fs = self.fs;
-        // Spec ThreadPool.zig:310 `transpiler.linker.resolver = &transpiler.resolver`.
         // Only reseat the back-pointers — do NOT `Linker::init` here: that
         // would clobber `import_counter` / `plugin_runner` /
-        // `tagged_resolutions` / `any_needs_runtime`, which the spec
-        // preserves across the move (bundle_v2.zig:230 only assigns
-        // `linker.resolver`).
+        // `tagged_resolutions` / `any_needs_runtime`, which must be
+        // preserved across the move.
         self.linker.reseat_self_refs(
             log,
             core::ptr::addr_of_mut!(self.resolve_queue),
@@ -413,17 +401,17 @@ impl<'a> Transpiler<'a> {
             core::ptr::addr_of_mut!(*self.resolve_results),
             self.fs,
         );
-        // Spec ThreadPool.zig:311 `transpiler.macro_context = MacroContext.init(transpiler)`.
         self.macro_context = Some(js_ast::Macro::MacroContext::init(self));
     }
 
-    /// Port of `transpiler.zig:91 getPackageManager`.
+    /// Returns the resolver's auto-install package-manager handle.
     #[inline]
     pub fn get_package_manager(&mut self) -> *mut dyn bun_resolver::install_types::AutoInstaller {
         self.resolver.get_package_manager()
     }
 
-    /// Port of `transpiler.zig:358 resetStore`.
+    /// Reset the thread-local AST block stores (`Expr`/`Stmt`) and the side
+    /// `AstAlloc` arena.
     pub fn reset_store(&self) {
         bun_ast::Expr::data_store_reset();
         bun_ast::Stmt::data_store_reset();
@@ -449,7 +437,6 @@ impl<'a> Transpiler<'a> {
         }
     }
 
-    /// Port of `transpiler.zig:108 _resolveEntryPoint`.
     fn _resolve_entry_point(
         &mut self,
         entry_point: &[u8],
@@ -467,12 +454,10 @@ impl<'a> Transpiler<'a> {
                 if !bun_paths::is_absolute(entry_point)
                     && !(entry_point.starts_with(b"./") || entry_point.starts_with(b".\\"))
                 {
-                    // Spec: `strings.append(arena, "./", entry_point)`.
                     let mut prefixed = Vec::with_capacity(2 + entry_point.len());
                     prefixed.extend_from_slice(b"./");
                     prefixed.extend_from_slice(entry_point);
-                    // PORT NOTE: spec leaks the prefixed slice (arena-freed in
-                    // Zig). `Resolver::resolve` interns the path internally,
+                    // `Resolver::resolve` interns the path internally,
                     // so the heap buffer can drop after the call.
                     if let Ok(r) = self.resolver.resolve(
                         top_level_dir,
@@ -488,7 +473,8 @@ impl<'a> Transpiler<'a> {
         }
     }
 
-    /// Port of `transpiler.zig:130 resolveEntryPoint`.
+    /// Resolve an entry-point specifier, busting the directory cache and
+    /// retrying once on failure before reporting the error to the log.
     pub fn resolve_entry_point(
         &mut self,
         entry_point: &[u8],
@@ -499,8 +485,8 @@ impl<'a> Transpiler<'a> {
                 let mut cache_bust_buf = bun_paths::PathBuffer::uninit();
 
                 // Bust directory cache and try again
-                // PORT NOTE: reshaped for borrowck — Zig's labelled-block
-                // returned a slice that aliases either `entry_point` (via
+                // reshaped for borrowck — a single labelled block would
+                // return a slice that aliases either `entry_point` (via
                 // `dirname`) or `cache_bust_buf`. Rust can't unify the two
                 // disjoint mutable borrows of `cache_bust_buf` across `break`,
                 // so compute `busted` directly instead.
@@ -524,7 +510,7 @@ impl<'a> Transpiler<'a> {
                         }
                     }
 
-                    // Spec: `bun.pathLiteral("..")` — `".."` is sep-agnostic.
+                    // `".."` needs no platform separator rewrite.
                     let parts: [&[u8]; 2] = [entry_point, b".."];
                     let top_level_dir = self.fs().top_level_dir;
 
@@ -562,7 +548,8 @@ impl<'a> Transpiler<'a> {
         }
     }
 
-    /// Port of `transpiler.zig:314 configureDefines`.
+    /// Load env files and build `options.define`. Idempotent — a no-op once
+    /// `options.defines_loaded` is set.
     pub fn configure_defines(&mut self) -> Result<(), bun_core::Error> {
         if self.options.defines_loaded {
             return Ok(());
@@ -578,10 +565,8 @@ impl<'a> Transpiler<'a> {
         let env_loader = self.env_mut();
         let mut is_production = env_loader.is_production();
 
-        // PORT NOTE: spec (`transpiler.zig:314`) eagerly did
-        // `Expr.Data.Store.create()` / `Stmt.Data.Store.create()` plus a
-        // `defer Store.reset()` here, purely so `defines.zig`'s `parse_env_json`
-        // had a thread-local AST store to build `E::String` nodes in. That work
+        // `parse_env_json` needs a thread-local AST store to build
+        // `E::String` nodes in. That work
         // is now done lazily inside `DefineData::parse`, only on the JSON-parse
         // slow path — the common case (`bun run` with no user `--define`)
         // resolves every define through the literal fast path and never
@@ -619,9 +604,7 @@ impl<'a> Transpiler<'a> {
         Ok(())
     }
 
-    /// Port of the spec idiom `out.resolver.opts = out.options` (transpiler.zig
-    /// passes the same `BundleOptions` value to both struct fields; bake.zig:788
-    /// re-assigns after mutating `out.options`). In the Rust port the resolver
+    /// The resolver
     /// crate carries a FORWARD_DECL subset of `BundleOptions`, so re-project
     /// rather than `Clone`. Called after `init_transpiler_with_options` mutates
     /// `self.options` so the resolver sees the same conditions/target/public_path.
@@ -629,17 +612,17 @@ impl<'a> Transpiler<'a> {
         self.resolver.opts = resolver_bundle_options_subset(&self.options);
     }
 
-    /// Port of `transpiler.zig:363 dumpEnvironmentVariables`.
+    /// Print the loaded environment variables to stdout as 2-space-indented
+    /// JSON.
     #[cold]
     #[inline(never)]
     pub fn dump_environment_variables(&self) {
         use bun_js_printer::{Encoding, write_json_string};
-        // PORT NOTE: spec uses `std.json.Stringify` (`.whitespace = .indent_2`)
-        // to dump `env.map.*`. The Rust `bun_dotenv::Map` doesn't impl
-        // `serde::Serialize`, so iterate and emit the object by hand. Keys and
-        // values go through `write_json_string` (the same escaper the printer
-        // uses for metafile/HTML-manifest JSON) so `"` / `\` / control bytes
-        // are escaped exactly as `std.json.Stringify` does.
+        // Dump `env.map.*` as 2-space-indented JSON. `bun_dotenv::Map` doesn't
+        // impl `serde::Serialize`, so iterate and emit the object by hand.
+        // Keys and values go through `write_json_string` (the same escaper the
+        // printer uses for metafile/HTML-manifest JSON) so `"` / `\` / control
+        // bytes are escaped as standard JSON requires.
         bun_core::Output::flush();
         let env = self.env_mut();
         let w = bun_core::Output::writer();
@@ -688,19 +671,20 @@ fn merge_tsconfig_jsx_into(tsconfig: &TSConfigJSON, out: &mut crate::options_imp
 }
 
 impl<'a> Transpiler<'a> {
-    /// Port of `transpiler.zig:233 configureLinkerWithAutoJSX`.
+    /// Initialize `self.linker` with back-pointers into this `Transpiler`,
+    /// optionally auto-configuring JSX from the nearest `tsconfig.json`.
     pub fn configure_linker_with_auto_jsx(&mut self, auto_jsx: bool) {
-        // PORT NOTE: `Linker::init` dropped its `arena` arg (linker.rs:172
-        // — global mimalloc). Zig stored borrowed `*T` into the linker; the
-        // un-gated `crate::linker::Linker` mirrors that with raw pointers so
+        // `Linker::init` dropped its `arena` arg (linker.rs:172
+        // — global mimalloc). The
+        // un-gated `crate::linker::Linker` stores raw pointers so
         // `&mut self.options` etc. coerce directly. Self-reference is
         // load-bearing — `linker.link()` reads back through these into the
         // owning `Transpiler` — hence raw `*mut`, not `&'a mut` (would alias
         // `&mut self` on every call).
-        // PORT NOTE: `.cast()` on the `options`/`resolver` pointers erases the
+        // `.cast()` on the `options`/`resolver` pointers erases the
         // `<'a>` lifetime parameter — `Linker` stores them as
         // `*mut BundleOptions` / `*mut Resolver` with an (implicit) distinct
-        // lifetime. Raw-pointer storage is the Zig contract; the linker never
+        // lifetime. The linker never
         // outlives its owning `Transpiler<'a>`.
         self.linker = crate::linker::Linker::init(
             self.log,
@@ -727,18 +711,18 @@ impl<'a> Transpiler<'a> {
         }
     }
 
-    /// Port of `transpiler.zig:259 configureLinker`.
+    /// [`Self::configure_linker_with_auto_jsx`] with `auto_jsx = true`.
     #[inline]
     pub fn configure_linker(&mut self) {
         self.configure_linker_with_auto_jsx(true);
     }
 
-    /// Port of `transpiler.zig:263 runEnvLoader`.
+    /// Load `.env` files into the env loader according to
+    /// `options.env.behavior`.
     pub fn run_env_loader(&mut self, skip_default_env: bool) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         use bun_options_types::schema::api::DotEnvBehavior;
         // Derived once up front; no other live `&mut` to this `Loader` exists
-        // for the duration of this call (Zig accessed `this.env.*` freely).
+        // for the duration of this call.
         let env: &mut dot_env::Loader<'_> = self.env_mut();
 
         match self.options.env.behavior {
@@ -754,7 +738,6 @@ impl<'a> Transpiler<'a> {
                 let has_production_env = env.is_production();
                 if !was_production && has_production_env {
                     self.options.set_production(true);
-                    // Spec transpiler.zig:275 `this.resolver.opts.setProduction(true)`.
                     // The resolver's FORWARD_DECL `BundleOptions` now exposes
                     // `set_production` (flips `production` + `jsx.development`
                     // and self-guards on `force_node_env`; resolver/lib.rs).
@@ -789,10 +772,9 @@ impl<'a> Transpiler<'a> {
                 // sole `&mut` for the call.
                 let dir: &mut bun_resolver::fs::DirEntry = unsafe { &mut *dir };
 
-                // PORT NOTE: `Env.files: Box<[Box<[u8]>]>` but `Loader::load`
+                // `Env.files: Box<[Box<[u8]>]>` but `Loader::load`
                 // wants `&[&[u8]]`. Re-borrow into a small Vec; the explicit
                 // `--env-file` list is bounded (CLI args), not hot-path.
-                // PERF(port): one tiny alloc — Zig passed the slice directly.
                 let env_files: Vec<&[u8]> = self.options.env.files.iter().map(|f| &**f).collect();
 
                 let suffix = if self.options.is_test() || env.is_test() {
@@ -808,7 +790,7 @@ impl<'a> Transpiler<'a> {
                 env.load_process()?;
                 if env.is_production() {
                     self.options.set_production(true);
-                    // Spec transpiler.zig:302 — see note in the `.prefix` arm.
+                    // See note in the `.prefix` arm.
                     self.resolver.opts.set_production(true);
                 }
             }
@@ -838,7 +820,8 @@ use bun_core::strings;
 use bun_resolver::package_json::MacroMap as MacroRemap;
 use bun_sys::Fd as FD;
 
-/// Port of `transpiler.zig:ParseResult.AlreadyBundled` (tagged union).
+/// How a parsed source was found to be pre-bundled (plain source vs. cached
+/// bytecode, ESM vs. CJS).
 #[derive(Default)]
 pub enum AlreadyBundled {
     #[default]
@@ -872,9 +855,10 @@ impl AlreadyBundled {
     }
 }
 
-/// Port of `transpiler.zig:ParseResult`.
-// PORT NOTE: lifetime-free — `runtime_transpiler_cache` is a raw pointer (Zig
-// `?*RuntimeTranspilerCache`) so `AsyncModule.parse_result` / `JSTranspiler`
+/// Output of the transpiler's parse step: the parsed AST plus its source and
+/// loader metadata.
+// lifetime-free — `runtime_transpiler_cache` is a raw pointer
+// so `AsyncModule.parse_result` / `JSTranspiler`
 // can store this by value without threading a borrow lifetime.
 pub struct ParseResult<'a> {
     pub source: bun_ast::Source,
@@ -883,18 +867,17 @@ pub struct ParseResult<'a> {
     pub already_bundled: AlreadyBundled,
     pub input_fd: Option<FD>,
     pub empty: bool,
-    // PORT NOTE: Zig `_resolver.PendingResolution.List` is
-    // `MultiArrayList(PendingResolution)`. `PendingResolution` does not yet
+    // `PendingResolution` does not yet
     // derive `MultiArrayElement` (lives in `bun_resolver`, derive macro is in
     // `bun_collections_macros` — orphan rules forbid impl-ing it here), so the
     // SoA `len()`/column accessors aren't reachable. Use AoS `Vec` for now;
     // `is_pending_import` only scans `import_record_id`, so the layout
     // difference is observable only as a SoA→AoS perf delta.
-    // TODO(b3): switch back to `MultiArrayList<PendingResolution>` once the
-    // derive lands upstream in `bun_resolver`.
+    // Once the `MultiArrayElement` derive lands upstream in `bun_resolver`,
+    // this can switch back to `MultiArrayList<PendingResolution>`.
     pub pending_imports: Vec<resolver::PendingResolution>,
 
-    /// Zig: `?*bun.RuntimeTranspilerCache`. SAFETY: erased — bundler stores it
+    /// SAFETY: erased — bundler stores it
     /// and hands it back to the runtime side; never dereferenced here.
     pub runtime_transpiler_cache: Option<core::ptr::NonNull<RuntimeTranspilerCache>>,
 
@@ -910,15 +893,15 @@ pub struct ParseResult<'a> {
 }
 
 impl<'a> ParseResult<'a> {
-    /// Spec transpiler.zig — `ParseResult` is value-copied (e.g.
+    /// `ParseResult` is value-copied (e.g.
     /// `AsyncModule.resumeLoadingModule` reads/writes `this.parse_result` by
     /// value). `Default` lets the Rust port `mem::take` it across that
     /// boundary; see `AsyncModule::resume_loading_module`.
     pub fn empty(arena: &'a bun_alloc::Arena) -> Self {
         ParseResult {
             source: Default::default(),
-            // PORT NOTE: `options::Loader` has no `Default`; Zig field had no
-            // initializer either. `File` is the resolver's neutral fallback
+            // `options::Loader` has no `Default`.
+            // `File` is the resolver's neutral fallback
             // (BundleEnums.rs:353), and `Default` here exists only for
             // `mem::take` in `AsyncModule::resume_loading_module`.
             loader: options::Loader::File,
@@ -956,8 +939,7 @@ impl<'a> ParseResult<'a> {
     }
 
     pub fn is_pending_import(&self, id: u32) -> bool {
-        // Spec transpiler.zig:43-47: scan `pending_imports.items(.import_record_id)` for `id`.
-        // PORT NOTE: AoS scan (see field comment); SoA column iteration restored
+        // AoS scan (see field comment); SoA column iteration restored
         // when `PendingResolution: MultiArrayElement` lands.
         self.pending_imports
             .iter()
@@ -965,7 +947,7 @@ impl<'a> ParseResult<'a> {
     }
 }
 
-/// Port of `transpiler.zig:Transpiler.ParseOptions`.
+/// Per-file inputs to the transpiler's parse step.
 pub struct ParseOptions<'a, 'b> {
     pub arena: &'a Arena,
     pub dirname_fd: FD,
@@ -983,7 +965,6 @@ pub struct ParseOptions<'a, 'b> {
     pub macro_remappings: MacroRemap,
     pub macro_js_ctx: MacroJSCtx,
     pub virtual_source: Option<&'b bun_ast::Source>,
-    /// Zig: `runtime.Runtime.Features.ReplaceableExport.Map`.
     pub replace_exports: bun_collections::StringArrayHashMap<bun_ast::runtime::ReplaceableExport>,
     pub inject_jest_globals: bool,
     pub set_breakpoint_on_first_line: bool,
@@ -1020,7 +1001,7 @@ use bun_options_types::schema::api;
 // `bun_options_types::jsx::Pragma`). Only the `_None → Automatic` fold is
 // applied so parser-side `== Automatic` checks in visitExpr/parseJSXElement
 // keep their pre-unification semantics (parser only ever sees a resolved
-// runtime; options.zig:1199 default).
+// runtime).
 #[inline]
 pub(crate) fn to_parser_jsx_pragma(
     mut p: crate::options_impl::jsx::Pragma,
@@ -1042,20 +1023,17 @@ fn to_parser_module_type(
     m
 }
 
-/// Spec: `fs.zig:FileSystem.init`.
-///
-/// PORT NOTE: the inline `bun_resolver::fs` module exposes the `FileSystem`
+/// The inline `bun_resolver::fs` module exposes the `FileSystem`
 /// struct + `INSTANCE`/`INSTANCE_LOADED` statics (resolver/lib.rs:120,129) but
 /// not the `init` constructor (that lives in the still-gated file-backed
 /// `resolver/fs.rs`). All fields are `pub` and `EntriesMap`/`Mutex` have
-/// public constructors, so reproduce the singleton-init here. Matches Zig
-/// semantics: first call sets `top_level_dir` (defaulting to getcwd),
+/// public constructors, so reproduce the singleton-init here:
+/// first call sets `top_level_dir` (defaulting to getcwd),
 /// subsequent calls return the existing instance untouched.
 fn init_file_system(
     top_level_dir: Option<&'static [u8]>,
 ) -> Result<*mut Fs::FileSystem, bun_core::Error> {
-    // Spec fs.zig:90-108 — delegate to `FileSystem.init`, which routes through
-    // `Implementation.init` (fs.zig:823-837): that path calls `adjustUlimit()`
+    // `FileSystem` initialization calls `adjustUlimit()`
     // to raise RLIMIT_NOFILE and stores the returned limit in
     // `file_limit`/`file_quota`, and touches the `DirEntry.EntryStore`
     // singleton. The previous hand-built `Implementation { file_limit: 0, .. }`
@@ -1071,18 +1049,16 @@ fn init_file_system(
 /// The two are nominally distinct until MOVE_DOWN to `bun_options_types`
 /// unifies them (resolver/lib.rs `mod options` note).
 ///
-/// Spec transpiler.zig:214 passes the SAME `bundle_options` value to
-/// `Resolver.init1`, so `resolver.opts` must carry user-configured
+/// `resolver.opts` must carry the same user-configured
 /// `--external`, `--conditions`, `--main-fields`, and the extension order.
 /// Every field the resolver reads is now projected (clone of owned data, no
 /// `Box::leak`); the resolver-side FORWARD_DECL types were widened to owned
 /// `Box<[Box<[u8]>]>`/`StringSet`/`StringArrayHashMap` so this is a faithful
 /// value copy rather than a `Default` stub.
 ///
-/// TODO(b3): drop this once `bun_options_types::BundleOptions` exists and both
+/// This projection can be dropped once `bun_options_types::BundleOptions` exists and both
 /// crates re-export it — `Resolver::init1` will then take the canonical type
-/// directly and Zig's `bundle_options` value can flow through unchanged
-/// (transpiler.zig:209 passes the same `options` to both struct fields).
+/// directly.
 ///
 /// `#[cold]`/`#[inline(never)]`: this is a ~100-line struct-construction blob
 /// run exactly once per `Transpiler::init` (i.e. once per VM bring-up). Keeping
@@ -1149,15 +1125,13 @@ pub(crate) fn resolver_bundle_options_subset(
             }
         }),
         global_cache: src.global_cache,
-        // Spec `options.zig:1753`: `?*const Api.BunInstall` — both sides store
+        // Both sides store
         // `Option<NonNull<api::BunInstall>>`, so this is a straight copy.
         install: src.install,
         load_package_json: src.load_package_json,
         load_tsconfig_json: src.load_tsconfig_json,
         main_field_extension_order: ropts::owned_string_list(src.main_field_extension_order),
-        // Spec resolver.zig `auto_main` compares the pointer of
-        // `opts.main_fields` against the per-target default; with owned
-        // storage that pointer test can't hold, so project the predicate as a
+        // `auto_main` is projected as a
         // bool: it's "default" iff the user did not pass `--main-fields`
         // (`from_api` overwrites `main_fields` only when
         // `transform.main_fields` is non-empty — options.rs:2231).
@@ -1172,9 +1146,8 @@ pub(crate) fn resolver_bundle_options_subset(
         production: src.production,
         force_node_env: src.force_node_env,
         // FORWARD_DECL: bundler-only fields read via `c.resolver.opts` in
-        // `linker_context/*` (Zig stores the full `BundleOptions` on the
-        // resolver). Project them so the linker sees the same values it would
-        // have read off the spec's shared struct.
+        // `linker_context/*`. Project them so the linker sees the same values
+        // the bundler configured.
         output_dir: src.output_dir.clone(),
         root_dir: src.root_dir.clone(),
         public_path: src.public_path.clone(),
@@ -1186,15 +1159,13 @@ pub(crate) fn resolver_bundle_options_subset(
 }
 
 impl<'a> Transpiler<'a> {
-    /// Port of `transpiler.zig:Transpiler.init`.
-    ///
-    /// Called by [`init_runtime_state`](../runtime/jsc_hooks.rs) (spec
-    /// `VirtualMachine.zig:1241`) to write `vm.transpiler`. Builds on:
+    /// Called by [`init_runtime_state`](../runtime/jsc_hooks.rs)
+    /// to write `vm.transpiler`. Builds on:
     ///   * [`options::BundleOptions::from_api`] — `bun_bundler::options`
     ///   * [`Resolver::init1`] — `bun_resolver`
     ///
-    /// PORT NOTE: `log` / `env_loader_` are raw pointers (not `&'a mut`) to
-    /// match the un-gated struct field types — Zig aliased the same `*Log`
+    /// `log` / `env_loader_` are raw pointers (not `&'a mut`) to
+    /// match the un-gated struct field types — the same `*Log` is aliased
     /// into `linker.log` / `resolver.log` (see `set_log`).
     pub fn init(
         arena: &'a Arena,
@@ -1230,7 +1201,6 @@ impl<'a> Transpiler<'a> {
         // deref sites below go through `NonNull` rather than the raw argument.
         let log_nn =
             core::ptr::NonNull::new(log).expect("Transpiler::init_in_place: log is non-null");
-        // TODO(port): narrow error set
         bun_ast::expr::data::Store::create();
         bun_ast::stmt::data::Store::create();
         // These two `create()`s are eager (not deferred to the first `parse()`)
@@ -1253,8 +1223,7 @@ impl<'a> Transpiler<'a> {
         // `reset()` branches to `enter()` on null ARENA), so per-file ASTs
         // *do* get the side arena from the first parsed file onward.
 
-        // PORT NOTE: `FileSystem::init` wants `&'static [u8]`; Zig passed a
-        // borrowed slice (transpiler.zig:179). Intern via `DirnameStore`
+        // `FileSystem::init` wants `&'static [u8]`. Intern via `DirnameStore`
         // (the same path `FileSystem::init` already uses for the
         // `None`/getcwd case — fs.rs:222) so the cwd lives in the
         // process-lifetime BSS string store without `Box::leak`. PORTING.md
@@ -1280,9 +1249,6 @@ impl<'a> Transpiler<'a> {
                     // Transfer ownership of both allocations into the global
                     // singleton via `heap::alloc` (the AtomicPtr becomes the
                     // owner; matches `MiniEventLoop::init_global`).
-                    // TODO(port): replace with a `OnceLock`-backed
-                    // `bun_dotenv::instance_or_init()` accessor once
-                    // `bun_dotenv` grows one (PORTING.md §Concurrency).
                     let map: *mut dot_env::Map =
                         bun_core::heap::into_raw(Box::new(dot_env::Map::init()));
                     // SAFETY: `map` is a fresh heap allocation with no other
@@ -1312,7 +1278,7 @@ impl<'a> Transpiler<'a> {
 
         // `log` stays raw — `from_api` stores it in `BundleOptions.log: *mut`
         // and the same pointer is aliased into `Resolver::init1` / `Linker`
-        // / the struct field below (Zig aliased `*Log` everywhere). No `&'a
+        // / the struct field below. No `&'a
         // mut Log` is materialized here, so the sibling raw pointers don't
         // invalidate a long-lived unique borrow under stacked borrows.
         // SAFETY: `fs` is the process-lifetime `Fs::FileSystem` singleton from
@@ -1333,7 +1299,7 @@ impl<'a> Transpiler<'a> {
         // Construct directly into the caller-owned storage instead of building a
         // stack temporary and returning it. All fallible work is done; every
         // field below is written exactly once. `Linker::init` gets null
-        // back-pointers (Zig used `undefined`) — `core::mem::zeroed()` is NOT a
+        // back-pointers — `core::mem::zeroed()` is NOT a
         // valid analogue (`Linker.hashed_filenames: HashMap` carries a `NonNull`
         // niche, so all-zeroes is instant UB); the value fields get their proper
         // defaults and `configure_linker_with_auto_jsx` overwrites the
@@ -1407,10 +1373,8 @@ impl<'a> Transpiler<'a> {
     >(
         &mut self,
         mut this_parse: ParseOptions<'a, '_>,
-        // TODO(port): Zig `anytype` + `@hasField(.., "source")` — only ever
-        // called with `?*EntryPoints.ClientEntryPoint` in this file. If other
-        // callers pass a different type, introduce a `ClientEntryPointLike`
-        // trait with `fn source() -> Option<&Source>`.
+        // The only caller passes `EntryPoints::ClientEntryPoint`, so the
+        // param is typed concretely.
         client_entry_point_: Option<&mut EntryPoints::ClientEntryPoint>,
     ) -> Option<ParseResult<'a>> {
         let arena = this_parse.arena;
@@ -1434,15 +1398,12 @@ impl<'a> Transpiler<'a> {
         // (`Drop` is a no-op).
         let mut source_backing: resolver::cache::Contents = resolver::cache::Contents::Empty;
 
-        // PORT NOTE: Zig `&brk: { ... }` took the address of a temporary; Rust
-        // owns the value and borrows it after the block.
         let source: &'a bun_ast::Source = arena.alloc('brk: {
             if let Some(virtual_source) = this_parse.virtual_source {
                 break 'brk virtual_source.clone();
             }
 
             if let Some(client_entry_point) = client_entry_point_ {
-                // Zig: if (@hasField(Child, "source")) — ClientEntryPoint always has it.
                 break 'brk client_entry_point.source.clone();
             }
 
@@ -1454,7 +1415,7 @@ impl<'a> Transpiler<'a> {
                 break 'brk bun_ast::Source::init_path_string(path.text, b"");
             }
 
-            // Spec transpiler.zig:826-835. The decoded body is owned in
+            // The decoded body is owned in
             // `source_backing` (below) so `source.contents` re-borrows it
             // without leaking; never falls through to `read_file_with_allocator`
             // (which would try to open `data:...` as a filesystem path).
@@ -1501,8 +1462,7 @@ impl<'a> Transpiler<'a> {
                 break 'brk bun_ast::Source::init_path_string(path.text, contents);
             }
 
-            // Zig (`transpiler.zig:838-839`): `if (use_shared_buffer)
-            // bun.default_allocator else this_parse.allocator`. Thread
+            // Thread
             // `this_parse.arena` (the per-call `MimallocArena` from
             // `RuntimeTranspilerStore`) so the source bytes land in the
             // job-scoped heap that `TranspilerJob::run` `mi_heap_destroy`s on
@@ -1533,7 +1493,7 @@ impl<'a> Transpiler<'a> {
             if let Some(file_fd_ptr) = this_parse.file_fd_ptr {
                 *file_fd_ptr = entry.fd;
             }
-            // PORT NOTE: `Source.contents: &'static [u8]` (the AST crate's `Str`
+            // `Source.contents: &'static [u8]` (the AST crate's `Str`
             // convention). The bytes live either in the per-thread shared
             // buffer (`USE_SHARED_BUFFER` → `Contents::SharedBuffer`, no-op
             // drop) or in `this_parse.arena` (`Contents::Arena`, no-op drop —
@@ -1541,9 +1501,7 @@ impl<'a> Transpiler<'a> {
             // recycled). Thread the
             // provenance-tagged backing alongside the `ParseResult` so it
             // drops when the result is recycled — no `mem::forget`
-            // (PORTING.md §Forbidden patterns). Spec transpiler.zig:853 hands
-            // `entry.contents` to `Source.initRecycledFile` by slice; Zig has
-            // no implicit drop, so ownership was already with the caller.
+            // (PORTING.md §Forbidden patterns).
             source_backing = core::mem::take(&mut entry.contents);
             // SAFETY: `source_backing` outlives every read through
             // `source.contents` (it is moved into the returned `ParseResult`,
@@ -1606,7 +1564,7 @@ impl<'a> Transpiler<'a> {
                 jsx.parse = loader.is_jsx();
                 let _ = &this_parse.macro_remappings;
 
-                // PORT NOTE: `ParserOptions::init` is hard-typed
+                // `ParserOptions::init` is hard-typed
                 // `-> Options<'static>` and `Options<'a>` is *invariant* in
                 // `'a` (it holds `Option<&'a mut MacroContext>`), so an
                 // `Options<'static>` cannot be passed to
@@ -1658,8 +1616,7 @@ impl<'a> Transpiler<'a> {
                 opts.features.no_macros = self.options.no_macros;
                 // `bun_ast::RuntimeTranspilerCache` is the single nominal
                 // type on both sides; thread the pointer directly.
-                // Spec transpiler.zig:899/957 copies the same
-                // `?*RuntimeTranspilerCache` raw pointer to BOTH
+                // The same `RuntimeTranspilerCache` raw pointer goes to BOTH
                 // `opts.features` and the returned `ParseResult`. Derive both
                 // from a single reborrow so they share one provenance tag —
                 // re-touching the parent `&mut` after the `*mut` cast would
@@ -1686,12 +1643,10 @@ impl<'a> Transpiler<'a> {
                 opts.features.minify_identifiers = self.options.minify_identifiers;
                 opts.features.dead_code_elimination = self.options.dead_code_elimination;
                 opts.features.remove_cjs_module_wrapper = this_parse.remove_cjs_module_wrapper;
-                // Spec transpiler.zig:925 forwards `transpiler.options
-                // .bundler_feature_flags`. Zig aliased a `*const StringSet`;
                 // `Features.bundler_feature_flags` is currently owned
                 // (`Option<Box<StringSet>>`), so clone by value.
-                // TODO(refactor): change the parser-side field to
-                // `Option<&'a StringSet>` to avoid the clone.
+                // (Changing the parser-side field to `Option<&'a StringSet>`
+                // would avoid the clone.)
                 // The clone drops with `opts` — no leak.
                 opts.features.bundler_feature_flags = self
                     .options
@@ -1705,8 +1660,6 @@ impl<'a> Transpiler<'a> {
                 opts.features.top_level_await = true;
 
                 opts.features.is_macro_runtime = target == crate::options_impl::Target::BunMacro;
-                // Spec transpiler.zig:943: `opts.features.replace_exports =
-                // this_parse.replace_exports`.
                 // `bun_ast::runtime::ReplaceableExport` IS
                 // `js_ast::Runtime::ReplaceableExport`, so the inner
                 // `StringArrayHashMap` moves directly into the newtype.
@@ -1718,7 +1671,7 @@ impl<'a> Transpiler<'a> {
                     let ctx = js_ast::Macro::MacroContext::init(self);
                     self.macro_context = Some(ctx);
                 }
-                // Spec transpiler.zig:938-940: thread the caller-supplied JS
+                // Thread the caller-supplied JS
                 // context into the macro runtime so macros invoked during
                 // runtime transpilation see it (instead of null). Written on
                 // `self.macro_context` before reborrowing into `opts` so the
@@ -1736,8 +1689,7 @@ impl<'a> Transpiler<'a> {
                 // owned by the long-lived `Transpiler`; the parser borrows
                 // them for `'a` (arena lifetime). Erase to `'a` so the
                 // returned `Ast<'a>` is not pinned to the `&mut self` borrow
-                // — neither field is dropped while a parse is in flight
-                // (Zig held `*const Define` / `*MacroContext`).
+                // — neither field is dropped while a parse is in flight.
                 unsafe {
                     let define_ptr: *const js_ast::defines::Define =
                         &raw const *self.options.define;
@@ -1748,7 +1700,7 @@ impl<'a> Transpiler<'a> {
                         .map(|m| &mut *core::ptr::from_mut(m));
                 }
 
-                // PORT NOTE: spec calls `transpiler.resolver.caches.js.parse`.
+                // spec calls `transpiler.resolver.caches.js.parse`.
                 // The resolver-side `cache::JavaScript` is a fieldless
                 // shell with no `parse` body (resolver/lib.rs:1664);
                 // the real `parse` lives on `crate::cache::JavaScript`. Both
@@ -1790,7 +1742,7 @@ impl<'a> Transpiler<'a> {
                             js_ast::AlreadyBundled::BunCjs => AlreadyBundled::SourceCodeCjs,
                             js_ast::AlreadyBundled::BytecodeCjs
                             | js_ast::AlreadyBundled::Bytecode => 'brk: {
-                                // Spec transpiler.zig:971-984: when the parser
+                                // When the parser
                                 // saw `// @bun @bytecode`, attempt to load the
                                 // sidecar `<path>.jsc` cached bytecode. Only
                                 // fall back to re-parsing source on read
@@ -1805,8 +1757,7 @@ impl<'a> Transpiler<'a> {
                                 if this_parse.virtual_source.is_none()
                                     && this_parse.allow_bytecode_cache
                                 {
-                                    // PORT NOTE: `bun.bytecode_extension`
-                                    // (bun.zig:3502) — no Rust const re-export
+                                    // No shared const for the bytecode extension
                                     // in `bun_core` yet, so inline the literal.
                                     const BYTECODE_EXT: &[u8] = b".jsc";
                                     let mut path_buf2 = bun_paths::PathBuffer::uninit();
@@ -1819,7 +1770,7 @@ impl<'a> Transpiler<'a> {
                                     // `path_buf2[total] == 0` already; safe to
                                     // borrow as a NUL-terminated ZStr.
                                     let zpath = bun_core::ZStr::from_buf(&path_buf2[..], total);
-                                    // PORT NOTE: spec calls
+                                    // spec calls
                                     // `bun.sys.File.toSourceAt(...)` which is
                                     // `read_from` + wrap-in-`bun_ast::Source`.
                                     // We only need `.contents`, so call
@@ -1922,11 +1873,7 @@ fn parse_data_loader<'a>(
     log: &mut bun_ast::Log,
     keep_json_and_toml_as_one_statement: bool,
 ) -> Option<ParseResult<'a>> {
-    // PERF(port): was `inline .toml, .yaml, .json, .jsonc, .json5
-    // => |kind|` — comptime monomorphization per loader; profile if it
-    // shows up on a hot path.
-    //
-    // PORT NOTE: `bun_parsers::*` parse into the T2 value AST
+    // `bun_parsers::*` parse into the T2 value AST
     // (`bun_ast::Expr`); lift into the full T4
     // `bun_ast::Expr` via the deep-convert `From` bridge
     // (Expr.rs:1265) so the StoreRef-backed accessors below work.
@@ -1964,8 +1911,7 @@ fn parse_data_loader<'a>(
 
     let mut symbols: Vec<bun_ast::Symbol> = Vec::new();
 
-    // PORT NOTE: reshaped — Zig `arena.alloc(Part, 1)` returned
-    // an arena slice, but `Ast::from_parts` takes `Box<[Part]>`
+    // `Ast::from_parts` takes `Box<[Part]>`
     // (Vec owns its buffer). The single-part array is built on
     // the global heap; `stmts` stays arena-backed (`*mut [Stmt]`).
     let parts: Box<[bun_ast::Part]> = 'parts: {
@@ -1978,7 +1924,6 @@ fn parse_data_loader<'a>(
                 },
                 bun_ast::Loc { start: 0 },
             );
-            // PERF(port): was `arena.alloc(Stmt, 1) catch unreachable`.
             let stmts = bun_ast::StoreSlice::new_mut(arena.alloc_slice_copy(&[stmt]));
             break 'parts Box::new([bun_ast::Part {
                 stmts,
@@ -1990,19 +1935,17 @@ fn parse_data_loader<'a>(
             let properties: &mut [bun_ast::G::Property] = obj.properties.slice_mut();
             if !properties.is_empty() {
                 let n = properties.len();
-                // PORT NOTE: Zig `expandToCapacity()` / `arena.alloc(Symbol, n)`
-                // leave slots uninitialized, which is inert in Zig.
                 // The loop below writes sparsely at index `i` and
                 // `continue`s on `"default"` / duplicate keys, so
                 // some slots are never assigned. In Rust an uninit
                 // live `Vec<T>` element is UB the moment it is
                 // observed (truncate/into_boxed_slice/index-assign),
                 // so pre-fill every slot with `Default` instead of
-                // `set_len`. PERF(port): was `expandToCapacity()`.
+                // `set_len`.
                 let mut decls: Vec<bun_ast::G::Decl> = vec![bun_ast::G::Decl::default(); n];
 
                 symbols.resize_with(n, Default::default);
-                // PORT NOTE: `S::ExportClause.items: *mut [ClauseItem]`
+                // `S::ExportClause.items: *mut [ClauseItem]`
                 // is arena-owned; `ClauseItem: Default` so
                 // `alloc_slice_fill_default` is fine.
                 let export_clauses = arena.alloc_slice_fill_default::<bun_ast::ClauseItem>(n);
@@ -2010,13 +1953,13 @@ fn parse_data_loader<'a>(
                     bun_collections::StringHashMap::default();
                 // duplicate_key_checker drops at end of scope (defer .deinit())
                 let mut count: usize = 0;
-                // PORT NOTE: reshaped for borrowck — cannot zip 4
+                // reshaped for borrowck — cannot zip 4
                 // slices with one mutable borrow into `decls` and
                 // also random-access `decls[prev]`.
                 for i in 0..n {
                     let prop = &mut properties[i];
                     // SAFETY: data-format parsers always emit
-                    // `e_string` keys (Zig `.?.data.e_string`).
+                    // `e_string` keys.
                     let key = prop.key.as_mut().unwrap();
                     let key_loc = key.loc;
                     let name: &[u8] = key
@@ -2038,10 +1981,7 @@ fn parse_data_loader<'a>(
                             Some(prop.value.expect("infallible: prop has value"));
                         continue;
                     }
-                    // PORT NOTE: spec transpiler.zig:1030-1071
-                    // writes at `i` and shrinks to `count`, leaving
-                    // holes when `"default"` / duplicates `continue`
-                    // — a latent spec bug. Write densely at `count`
+                    // Write densely at `count`
                     // (and store `count` in the checker) so
                     // `truncate(count)` / `[..count]` keep the
                     // actually-populated entries.
@@ -2050,9 +1990,7 @@ fn parse_data_loader<'a>(
                     symbols[count] = bun_ast::Symbol {
                         original_name: match bun_core::MutableString::ensure_valid_identifier(name)
                         {
-                            // Spec transpiler.zig:1049 calls
-                            // `MutableString.ensureValidIdentifier(name, arena)`
-                            // — the identifier lives in the
+                            // The identifier lives in the
                             // per-parse arena. Arena-copy the
                             // owned `Box<[u8]>` so it is freed
                             // with the arena instead of leaking
@@ -2183,7 +2121,6 @@ fn parse_text_loader<'a>(
         },
         bun_ast::Loc { start: 0 },
     );
-    // PERF(port): was `arena.alloc(Stmt, 1) catch unreachable`.
     let stmts = bun_ast::StoreSlice::new_mut(arena.alloc_slice_copy(&[stmt]));
     let parts: Box<[bun_ast::Part]> = Box::new([bun_ast::Part {
         stmts,
@@ -2214,7 +2151,7 @@ fn parse_md_loader<'a>(
     log: &mut bun_ast::Log,
 ) -> Option<ParseResult<'a>> {
     let html: &'static [u8] = match bun_md::root::render_to_html(&source.contents) {
-        // Spec transpiler.zig:1162 allocates the rendered HTML via
+        // The rendered HTML is allocated via
         // `arena` (the per-parse arena), so it is freed with the
         // arena. Arena-copy the heap `Box<[u8]>` and let it drop;
         // PORTING.md §Forbidden patterns bars `Box::leak` here.
@@ -2304,7 +2241,7 @@ fn parse_wasm_loader<'a>(
 #[cold]
 #[inline(never)]
 fn parse_unsupported_loader(loader: options::Loader, path: &bun_paths::fs::Path<'static>) -> ! {
-    // Spec transpiler.zig:1216 — programmer-error hard crash, NOT a
+    // Programmer-error hard crash, NOT a
     // silent `None` (PORTING.md §Forbidden: silent no-op).
     bun_core::Output::panic(format_args!(
         "Unsupported loader {:?} for path: {}",
@@ -2318,26 +2255,26 @@ fn parse_unsupported_loader(loader: options::Loader, path: &bun_paths::fs::Path<
 // `ModuleLoader::transpile_source_code` (jsc_hooks.rs spec :525-539); the
 // dispatch shim that `RuntimeTranspilerStore` / `AsyncModule` link against.
 //
-// PORT NOTE: `comptime format: js_printer.Format` demoted to a runtime arg —
+// `format` is a runtime arg rather than a const generic —
 // `bun_js_printer::Format` doesn't derive `ConstParamTy` (and can't be added
 // from this crate). All callers pass a literal anyway; the inner
-// `print_ast::<_, ASCII_ONLY, ENABLE_SOURCE_MAP>` keeps both real comptime
+// `print_ast::<_, ASCII_ONLY, ENABLE_SOURCE_MAP>` keeps both const-generic
 // bools, so codegen monomorphizes the printer body identically.
-// PERF(port): outer `match format` is one extra branch — profile if hot.
+// PERF: outer `match format` is one extra branch — profile if hot.
 // ══════════════════════════════════════════════════════════════════════════
 
 use bun_js_printer as js_printer;
-// PORT NOTE: `module_info` threads the *printer's* `analyze_transpiled_module::ModuleInfo`
+// `module_info` threads the *printer's* `analyze_transpiled_module::ModuleInfo`
 // (the producer), not `crate::analyze_transpiled_module::ModuleInfo` (the
 // richer consumer-side mirror). The print
 // path only ever fills the printer-owned one and hands its serialized bytes to
-// T6, so unify on the printer type here. Spec: transpiler.zig:663.
+// T6, so unify on the printer type here.
 use js_printer::analyze_transpiled_module;
 
 /// Map the bundler-local `Target` (options.rs:489) to the lower-tier
 /// `bun_ast::Target` consumed by `js_printer::Options`.
 /// The two enums are variant-for-variant identical but nominally distinct;
-/// TODO(refactor): collapse them (see lib.rs `pub mod options` shadow note).
+/// they could be collapsed (see lib.rs `pub mod options` shadow note).
 #[inline]
 fn to_bundle_enums_target(t: crate::options_impl::Target) -> bun_ast::Target {
     use bun_ast::Target as T;
@@ -2360,8 +2297,8 @@ pub use js_printer::Format as PrintFormat;
 // `&mut BufferPrinter`. Leaving the public entry points generic forced each
 // downstream crate (bun_runtime / bun_jsc / bun_install / bun_bundler) to stamp
 // out its own copy of the 109-fn `Printer<W,A,B,C,D,E>` recursion tree —
-// `llvm-nm --print-size` showed `bun_js_printer` .text at 1,367 KB vs 594 KB on
-// the Zig build, with both the `_11bun_runtime` and `_7bun_jsc` copies of
+// `llvm-nm --print-size` showed `bun_js_printer` .text at 1,367 KB,
+// with both the `_11bun_runtime` and `_7bun_jsc` copies of
 // `print_expr<…>` live in `perf` and thrashing icache against each other
 // (L1-icache-misses +5.1%, iTLB-misses +13.2%, IPC 1.40 vs 1.50). Pinning `W`
 // to the one concrete type and marking the public entry points
@@ -2378,16 +2315,16 @@ impl<'a> Transpiler<'a> {
         runtime_transpiler_cache: Option<core::ptr::NonNull<RuntimeTranspilerCache>>,
         module_info: Option<*mut analyze_transpiled_module::ModuleInfo>,
     ) -> Result<usize, bun_core::Error> {
-        // TODO(port): narrow error set
-        // TODO(port): `bun.perf.trace("JSPrinter.printWithSourceMap")` /
-        // `("JSPrinter.print")` — `bun_perf::trace` now takes a `PerfEvent`
-        // enum and neither variant is in `generated_perf_trace_events.rs`
-        // yet. Re-add once `scripts/generate-perf-trace-events.sh` runs
-        // against the Rust tree.
-
-        // PORT NOTE: Zig built `Symbol.NestedList.fromBorrowedSliceDangerous(
-        // &.{ast.symbols})` — aliased the stack-one-slice into the map. Rust
-        // can't borrow `ast.symbols` while moving `ast` into `print_ast`, so
+        // Routed through the T0 ftrace subset like the
+        // other bundler spans (`Bundler.computeChunks` etc.) —
+        // `bun_perf::PerfEvent` has no JSPrinter variants yet.
+        let _trace = bun_core::perf::trace(if ENABLE_SOURCE_MAP {
+            "JSPrinter.printWithSourceMap"
+        } else {
+            "JSPrinter.print"
+        });
+
+        // We can't borrow `ast.symbols` while moving `ast` into `print_ast`, so
         // take the column out (the printer never reads `tree.symbols`; it
         // walks `symbols` exclusively — `rg tree.symbols js_printer/lib.rs` is
         // empty). `init_with_one_list` boxes the single inner list.
@@ -2401,16 +2338,16 @@ impl<'a> Transpiler<'a> {
         // `runtime_imports` is now forwarded — after Round-G `Ast.runtime_imports`
         // is the real `parser::Runtime::Imports`, the same type
         // `js_printer::Options.runtime_imports` takes (via `js_ast::runtime`),
-        // so the seam is gone. Spec: zig:593/619/645.
+        // so the seam is gone.
         // `target` is now forwarded via `to_bundle_enums_target` below — it
         // *does* affect the EsmAscii/bun-runtime path (js_printer/lib.rs:6872
         // gates the `var {require}=import.meta;` hoist on `target == Bun`;
         // regression of oven-sh/bun#15738 if left at the `Browser` default).
         // `runtime_transpiler_cache` is now forwarded — js_printer holds the
-        // `NonNull<RuntimeTranspilerCache>` directly. Spec: zig:601/627/662.
+        // `NonNull<RuntimeTranspilerCache>` directly.
         // `module_info` is now forwarded — this fn's parameter is the
         // printer-crate `analyze_transpiled_module::ModuleInfo` (see the `use`
-        // above), so the seam is gone. Spec: zig:663 — EsmAscii arm only.
+        // above), so the seam is gone (EsmAscii arm only).
 
         let exports_kind = ast.exports_kind;
 
@@ -2451,10 +2388,9 @@ impl<'a> Transpiler<'a> {
             ),
 
             js_printer::Format::EsmAscii => {
-                // PORT NOTE: `switch (target.isBun()) { inline else => |is_bun| ... }`
-                // — runtime bool → comptime dispatch. Hoisted into the
-                // `print_ast_esm_ascii` helper so the const-generic IS_BUN can
-                // also drive `module_type`.
+                // Runtime `target.is_bun()` bool → const-generic dispatch,
+                // hoisted into the `print_ast_esm_ascii` helper so the
+                // const-generic IS_BUN can also drive `module_type`.
                 if self.options.target.is_bun() {
                     self.print_ast_esm_ascii::<ENABLE_SOURCE_MAP, true>(
                         print_arena,
@@ -2482,7 +2418,6 @@ impl<'a> Transpiler<'a> {
                 }
             }
 
-            // Spec transpiler.zig:672 `else => unreachable`.
             js_printer::Format::CjsAscii => unreachable!(),
         }
     }
@@ -2608,9 +2543,8 @@ impl<'a> Transpiler<'a> {
         )
     }
 
-    // PORT NOTE: hoisted from `inline else => |is_bun|` arm of
-    // print_with_source_map_maybe to express the comptime bool dispatch as a
-    // const generic.
+    // hoisted out of print_with_source_map_maybe to express the
+    // is-bun bool dispatch as a const generic.
     #[allow(clippy::too_many_arguments)]
     fn print_ast_esm_ascii<const ENABLE_SOURCE_MAP: bool, const IS_BUN: bool>(
         &mut self,
@@ -2624,7 +2558,7 @@ impl<'a> Transpiler<'a> {
         runtime_transpiler_cache: Option<js_printer::RuntimeTranspilerCacheRef>,
         module_info: Option<*mut analyze_transpiled_module::ModuleInfo>,
     ) -> Result<usize, bun_core::Error> {
-        // Spec transpiler.zig:662-663 — both set on this (EsmAscii) arm only.
+        // Both set on this (EsmAscii) arm only.
         // SAFETY: `module_info` is `ModuleInfo::create`'s `heap::alloc` (or
         // null); it is exclusively owned by this print call until T6 reclaims
         // it after `print_with_source_map` returns.
@@ -2655,7 +2589,7 @@ impl<'a> Transpiler<'a> {
             module_info,
             hmr_ref: ast.wrapper_ref,
             mangled_props: None,
-            // Spec transpiler.zig:664. The printer reads `opts.target` at
+            // The printer reads `opts.target` at
             // js_printer/lib.rs:6872 to gate the `var {require}=import.meta;`
             // hoist on `Target::Bun` — defaulting to `Browser` here regressed
             // oven-sh/bun#15738.
@@ -2718,8 +2652,8 @@ impl<'a> Transpiler<'a> {
         handler: js_printer::SourceMapHandler<'_>,
         module_info: Option<*mut analyze_transpiled_module::ModuleInfo>,
     ) -> Result<usize, bun_core::Error> {
-        // PORT NOTE: env_var feature_flag getters return `Option<bool>`
-        // (Some(default) when unset); Zig's `.get()` is plain `bool`.
+        // env_var feature_flag getters return `Option<bool>`
+        // (Some(default) when unset).
         if bun_core::env_var::feature_flag::BUN_FEATURE_FLAG_DISABLE_SOURCE_MAPS
             .get()
             .unwrap_or(false)
@@ -2779,14 +2713,12 @@ impl<'a> Transpiler<'a> {
         )
     }
 
-    /// Port of `transpiler.zig:1225 normalizeEntryPointPath`.
     fn normalize_entry_point_path(&self, _entry: &[u8]) -> &'static [u8] {
         let fs = self.fs();
         let entry = fs.abs(&[_entry]);
 
-        // Spec: `std.fs.accessAbsolute(entry, .{}) catch return _entry` — if the
-        // absolutized path does not exist on disk, return the original input
-        // unchanged so bare specifiers (`react`) and URLs are left alone.
+        // If the absolutized path does not exist on disk, return the original
+        // input unchanged so bare specifiers (`react`) and URLs are left alone.
         if !bun_sys::exists(entry) {
             return crate::linker::dupe(_entry);
         }
@@ -2814,16 +2746,12 @@ impl<'a> Transpiler<'a> {
         crate::linker::dupe(entry)
     }
 
-    /// Port of `transpiler.zig:1254 enqueueEntryPoints`.
-    ///
-    /// PORT NOTE: the Zig version writes the resolved entry results into a
-    /// caller-provided `[]Result` slice; the only caller (`transform`) discards
-    /// that slice immediately, so the Rust port returns only the count and lets
+    /// Returns only the count and lets
     /// `linker.enqueue_resolve_result` push directly onto `resolve_queue`.
     fn enqueue_entry_points<const NORMALIZE_ENTRY_POINT: bool>(&mut self) -> usize {
         let mut entry_point_i: usize = 0;
 
-        // PORT NOTE: snapshot entry points so the `&mut self` resolver call
+        // snapshot entry points so the `&mut self` resolver call
         // does not conflict with the `&self.options` borrow.
         let entries: Vec<Box<[u8]>> = self.options.entry_points.to_vec();
         let top_level_dir = self.fs().top_level_dir;
@@ -2873,7 +2801,6 @@ impl<'a> Transpiler<'a> {
         entry_point_i
     }
 
-    /// Port of `transpiler.zig:1286 transform`.
     pub fn transform(
         &mut self,
         log: *mut bun_ast::Log,
@@ -2947,8 +2874,8 @@ impl<'a> Transpiler<'a> {
         Ok(final_result)
     }
 
-    /// Port of `transpiler.zig:1344 processResolveQueue` (with
-    /// `wrap_entry_point = false`, the only value passed by the in-tree caller).
+    /// `wrap_entry_point` is fixed to `false`, the only value passed by the
+    /// in-tree caller.
     fn process_resolve_queue(
         &mut self,
         import_path_format: options::ImportPathFormat,
@@ -2973,7 +2900,6 @@ impl<'a> Transpiler<'a> {
         Ok(())
     }
 
-    /// Port of `transpiler.zig:380 buildWithResolveResultEager`.
     fn build_with_resolve_result_eager(
         &mut self,
         resolve_result: &resolver::Result,
@@ -2988,7 +2914,7 @@ impl<'a> Transpiler<'a> {
         let Some(file_path_ref) = resolve_result.path_const() else {
             return Ok(None);
         };
-        // PORT NOTE: `resolver::Result.path_pair` carries `bun_resolver::fs::Path<'_>`;
+        // `resolver::Result.path_pair` carries `bun_resolver::fs::Path<'_>`;
         // downstream `linker.link`/`get_hashed_filename` and `OutputFile.src_path`
         // expect `bun_paths::fs::Path<'_>` / `bun_paths::fs::Path<'static>`. Re-init via
         // `text` (the only field both shapes share semantically).
@@ -2996,9 +2922,9 @@ impl<'a> Transpiler<'a> {
         let file_path_ext: &'static [u8] = crate::linker::dupe(file_path_ref.name().ext);
 
         // Step 1. Parse & scan
-        // Spec (transpiler.zig:397) keys the loader on the ORIGINAL resolve
-        // result's extension *before* the `client_entry_point` path override
-        // (line 400). Compute it here, then apply the override.
+        // Key the loader on the ORIGINAL resolve
+        // result's extension *before* the `client_entry_point` path override.
+        // Compute it here, then apply the override.
         let loader = self.options.loader(file_path_ext);
 
         // `client_entry_point_` is always `None` from the only in-tree caller;
@@ -3038,15 +2964,17 @@ impl<'a> Transpiler<'a> {
             | options::Loader::Json5
             | options::Loader::Text
             | options::Loader::Md => {
-                // PORT NOTE: borrowck — `parse` consumes `&mut self`, so capture
+                // borrowck — `parse` consumes `&mut self`, so capture
                 // the option fields needed for `ParseOptions` first.
                 let jsx = jsx_pragma_from_resolver(&resolve_result.jsx);
                 let dirname_fd = resolve_result.dirname_fd;
                 let emit_decorator_metadata = resolve_result.flags.emit_decorator_metadata();
                 let experimental_decorators = resolve_result.flags.experimental_decorators();
-                // TODO(port): `MacroRemap` (StringArrayHashMap of StringArrayHashMap)
-                // has no nested `Clone` impl; the Zig copied it by value. Re-key
-                // shallowly here matching the build-command conversion.
+                // `MacroRemap` (StringArrayHashMap of StringArrayHashMap) has
+                // no nested `Clone` impl (the inner clone is fallible).
+                // Rebuild the outer map, deep-cloning
+                // each inner map (fallible), matching the build-command
+                // conversion.
                 let macro_remappings = {
                     let mut m = MacroRemap::default();
                     for (k, v) in self.options.macro_remap.iter() {
@@ -3215,8 +3143,8 @@ impl<'a> Transpiler<'a> {
         // the CSS AST it backs is dropped before this fn returns
         // (only `result.code: Vec<u8>` escapes, which is
         // global-heap). `'static` matches the crate-wide erasure
-        // on `StyleSheet`/`ParserOptions` (see css_parser.rs
-        // TODO(port): 'bump threading).
+        // on `StyleSheet`/`ParserOptions` (see the css_parser.rs
+        // `'bump`-threading note).
         let alloc: &'static Arena = unsafe { bun_ptr::detach_lifetime_ref::<Arena>(self.arena) };
 
         let (mut sheet, extra) = match bun_css::StyleSheet::<bun_css::DefaultAtRule>::parse(
@@ -3301,14 +3229,11 @@ impl<'a> Transpiler<'a> {
     }
 }
 
-/// Port of the `comptime Outstream: type` parameter to
-/// `processResolveQueue` / `buildWithResolveResultEager` — Zig switched on
-/// `bun.sys.File` vs `std.fs.Dir` at the type level; collapse to a runtime
-/// enum since the only behavioural difference is unused (`_ = outstream`).
+/// Outstream selector for `process_resolve_queue` /
+/// `build_with_resolve_result_eager` — a runtime enum since the only
+/// behavioural difference is unused (`_ = outstream`).
 #[derive(Clone, Copy)]
 enum TransformOutstream {
     Stdout,
     Dir(#[expect(dead_code)] bun_sys::Fd),
 }
-
-// ported from: src/bundler/transpiler.zig
diff --git a/src/bundler_jsc/PluginRunner.rs b/src/bundler_jsc/PluginRunner.rs
index fe427df7100..4395d2d1c0b 100644
--- a/src/bundler_jsc/PluginRunner.rs
+++ b/src/bundler_jsc/PluginRunner.rs
@@ -1,41 +1,38 @@
-//! Runtime plugin host (JS-side `Bun.plugin()` resolve hooks). Moved from
-//! `bundler/transpiler.zig` so `bundler/` is free of `JSValue`/`JSGlobalObject`.
+//! Runtime plugin host (JS-side `Bun.plugin()` resolve hooks). Lives here so
+//! `bundler/` is free of `JSValue`/`JSGlobalObject`.
 
 pub use bun_resolver::fs::Path as FsPath;
 
-/// Spec `PluginRunner.zig:MacroJSCtx` — re-export of the canonical newtype
+/// Re-export of the canonical newtype
 /// (defined at the lowest tier that stores it, `bun_ast::Macro`).
 pub use bun_bundler::transpiler::MacroJSCtx as MacroJsCtx;
 
-/// Spec `PluginRunner.zig:PluginRunner` — re-export of the concrete struct.
+/// Re-export of the concrete struct.
 /// `extract_namespace` / `could_be_plugin` (pure byte parsing) live in
 /// `bun_bundler`; the stateful struct + `on_resolve` body live in
 /// `bun_jsc::plugin_runner`. `on_resolve_jsc` (below) is a free fn because it
 /// only reads the global, not the runner record.
 pub use bun_jsc::plugin_runner::PluginRunner;
 
-/// Spec PluginRunner.zig:14 — re-export for callers that named this module.
+/// Re-export for callers that named this module.
 #[inline]
 pub fn extract_namespace(specifier: &[u8]) -> &[u8] {
     PluginRunner::extract_namespace(specifier)
 }
 
-/// Spec PluginRunner.zig:22 — re-export for callers that named this module.
+/// Re-export for callers that named this module.
 #[inline]
 pub fn could_be_plugin(specifier: &[u8]) -> bool {
     PluginRunner::could_be_plugin(specifier)
 }
 
-// `on_resolve` (the `Log`-reporting variant, PluginRunner.zig:34) lives at
+// `on_resolve` (the `Log`-reporting variant) lives at
 // `bun_jsc::plugin_runner::PluginRunner` as the `PluginResolver` impl —
 // `bun_jsc` is the lowest tier that can name `JSGlobalObject` AND is reachable
 // from `Bun__onDidAppendPlugin`.
 
-/// Spec PluginRunner.zig:121 `onResolveJSC`.
 /// LAYERING: body moved DOWN into `bun_jsc::virtual_machine` so the
 /// VM's `resolve_maybe_needs_trailing_slash` can consult it without a
 /// `bun_jsc → bun_bundler_jsc` cycle. Re-exported here for callers that
 /// still name this module.
 pub use bun_jsc::virtual_machine::plugin_runner_on_resolve_jsc as on_resolve_jsc;
-
-// ported from: src/bundler_jsc/PluginRunner.zig
diff --git a/src/bundler_jsc/analyze_jsc.rs b/src/bundler_jsc/analyze_jsc.rs
index d4313d4eb65..7648b1b3763 100644
--- a/src/bundler_jsc/analyze_jsc.rs
+++ b/src/bundler_jsc/analyze_jsc.rs
@@ -2,7 +2,7 @@
 //! `ModuleInfoDeserialized` into a `JSC::JSModuleRecord`. Aliased back so the
 //! `extern "C"` symbol names are still discoverable from C++.
 //!
-//! Note: the `zig__renderDiff` export from `analyze_jsc.zig` lives in
+//! Note: the `zig__renderDiff` export lives in
 //! `bun_runtime::test_runner::diff_format` instead — `DiffFormatter` is a
 //! higher-tier type this crate cannot depend on, and the C++ caller only needs
 //! the symbol at link time, not a particular crate.
@@ -28,10 +28,9 @@ pub(crate) extern "C" fn zig__ModuleInfoDeserialized__toJSModuleRecord(
     // SourceProvider cache.
 
     // Slice-field validity / alignment caveats are documented on the
-    // `ModuleInfoDeserialized` accessors.
-    // TODO(port): switch element reads to `read_unaligned` per the upstream
-    // note in `analyze_transpiled_module.rs` if a strict-alignment target is
-    // ever added.
+    // `ModuleInfoDeserialized` accessors. If a strict-alignment target is ever
+    // added, switch element reads to `read_unaligned` per the upstream note in
+    // `analyze_transpiled_module.rs`.
     let strings_buf: &[u8] = res.strings_buf();
     let strings_lens: &[u32] = res.strings_lens();
     let requested_modules_keys: &[StringID] = res.requested_modules_keys();
@@ -56,8 +55,8 @@ pub(crate) extern "C" fn zig__ModuleInfoDeserialized__toJSModuleRecord(
     }
 
     let identifiers = IdentifierArray::create(strings_lens.len());
-    // SAFETY: `identifiers` is non-null (returned by `create`); destroyed exactly once at scope exit,
-    // mirroring Zig's `defer identifiers.destroy()` (runs on both success and early-return paths).
+    // SAFETY: `identifiers` is non-null (returned by `create`); the scopeguard destroys it
+    // exactly once at scope exit (on both success and early-return paths).
     let _identifiers_guard = scopeguard::guard(identifiers, |p| unsafe {
         IdentifierArray::destroy(p);
     });
@@ -142,7 +141,6 @@ pub(crate) extern "C" fn zig__ModuleInfoDeserialized__toJSModuleRecord(
             RequestedModuleValue::Json => {
                 module_record.add_requested_module_json(identifiers, reqk, phase_defer)
             }
-            // Zig open-enum tail: `else => |uv| @enumFromInt(@intFromEnum(uv))` —
             // FetchParameters and StringID are both `#[repr(transparent)] u32`, so this
             // is a bitcast of the raw discriminant back into the interned-string index.
             uv => module_record.add_requested_module_host_defined(
@@ -217,7 +215,6 @@ pub(crate) extern "C" fn zig__ModuleInfoDeserialized__toJSModuleRecord(
 }
 
 // ─── opaque FFI types ─────────────────────────────────────────────────────────
-// TODO(port): move to bundler_jsc_sys
 
 bun_opaque::opaque_ffi! { pub struct VariableEnvironment; }
 unsafe extern "C" {
@@ -411,8 +408,7 @@ impl JSModuleRecord {
 }
 
 // Thin method shims over the raw `*mut JSModuleRecord` returned by `create`.
-// These take `*mut Self` because the Zig side calls them as `module_record.addX(...)`
-// on a raw pointer; we keep raw-ptr receivers to avoid materializing `&mut` aliases.
+// These take `*mut Self` raw-ptr receivers to avoid materializing `&mut` aliases.
 trait JSModuleRecordExt {
     fn add_indirect_export(
         self,
@@ -676,5 +672,3 @@ impl JSModuleRecordExt for *mut JSModuleRecord {
         }
     }
 }
-
-// ported from: src/bundler_jsc/analyze_jsc.zig
diff --git a/src/bundler_jsc/lib.rs b/src/bundler_jsc/lib.rs
index 1afeea21373..92966512bd1 100644
--- a/src/bundler_jsc/lib.rs
+++ b/src/bundler_jsc/lib.rs
@@ -16,7 +16,7 @@ pub mod options_jsc;
 #[path = "PluginRunner.rs"]
 pub mod PluginRunner;
 
-// LAYERING: `output_file_jsc` (port of `src/bundler_jsc/output_file_jsc.zig`)
+// LAYERING: `output_file_jsc`
 // constructs `webcore::Blob`/`Store`, `api::BuildArtifact`, and
 // `node::PathOrFileDescriptor`. Those types live in `bun_runtime`, which is
 // not a dependency of this crate. The module has been moved to
diff --git a/src/bundler_jsc/options_jsc.rs b/src/bundler_jsc/options_jsc.rs
index 7fcd92a0b3e..c83418c1c71 100644
--- a/src/bundler_jsc/options_jsc.rs
+++ b/src/bundler_jsc/options_jsc.rs
@@ -80,5 +80,3 @@ pub fn compile_target_from_slice(
 
     Ok(target_parsed)
 }
-
-// ported from: src/bundler_jsc/options_jsc.zig
diff --git a/src/bundler_jsc/source_map_mode_jsc.rs b/src/bundler_jsc/source_map_mode_jsc.rs
index f3841db6ddd..77f025b5b22 100644
--- a/src/bundler_jsc/source_map_mode_jsc.rs
+++ b/src/bundler_jsc/source_map_mode_jsc.rs
@@ -1,6 +1,5 @@
-//! `from_js` for `bun.schema.api.SourceMapMode` — kept out of
-//! `options_types/schema.zig` so that file has no `JSGlobalObject`/`JSValue`
-//! references.
+//! `from_js` for `bun.schema.api.SourceMapMode` — kept here so the schema
+//! module has no `JSGlobalObject`/`JSValue` references.
 
 use crate::{JSGlobalObject, JSValue, JsResult};
 use bun_options_types::schema::api::SourceMapMode;
@@ -27,5 +26,3 @@ pub fn source_map_mode_from_js(
     }
     Ok(None)
 }
-
-// ported from: src/bundler_jsc/source_map_mode_jsc.zig
diff --git a/src/bunfig/arguments.rs b/src/bunfig/arguments.rs
index 5bea346d3e9..a25da143c6d 100644
--- a/src/bunfig/arguments.rs
+++ b/src/bunfig/arguments.rs
@@ -1,5 +1,4 @@
-//! Port of `src/runtime/cli/Arguments.zig` — bunfig-loading subset.
-//!
+//! Bunfig-loading subset of CLI argument handling: these functions
 //! and their private helpers were lifted out of `bun_runtime::cli::Arguments`
 //! so that mid-tier crates (`bun_install`) can call them directly. The
 //! `bun_runtime` crate re-exports these for its own callers.
@@ -62,8 +61,8 @@ fn load_bunfig(
     bun_ast::expr::data::Store::create();
     let _store_reset = bun_ast::StoreResetGuard::new();
 
-    // PORT NOTE: reshaped for borrowck — `defer { ctx.log.level = original }`
-    // would capture `&mut *ctx.log` past the `Bunfig::parse(.., ctx)` reborrow.
+    // A drop-guard borrowing `&mut *ctx.log` would conflict with the
+    // `Bunfig::parse(.., ctx)` reborrow.
     // Route through the raw `*mut Log` (process-lifetime, set in
     // `create_context_data()`); the guard restores `level` on unwind/return.
     let log_ptr: *mut bun_ast::Log = ctx.log;
@@ -100,9 +99,10 @@ pub fn load_config_path(
     config_path: &ZStr,
     ctx: Context<'_>,
 ) -> Result<(), bun_core::Error> {
-    // PORT NOTE: `comptime cmd.readGlobalConfig()` demoted to runtime — see
-    // `parse()` PORT NOTE; `Tag::read_global_config` is a const-ish lookup so
-    // the dead arm is still a single branch.
+    // `cmd.read_global_config()` is evaluated at runtime (see
+    // the note on `Parser::parse` in src/bunfig/bunfig.rs);
+    // `Tag::read_global_config` is a const-ish
+    // lookup so the dead arm is still a single branch.
     if cmd.read_global_config() {
         if let Err(err) = load_global_bunfig(cmd, ctx) {
             if auto_loaded {
@@ -202,7 +202,7 @@ pub fn load_config(
             ctx.args.absolute_working_dir = Some(Box::<[u8]>::from(&secondbuf[..cwd_len]));
         }
 
-        // PORT NOTE: reshaped for borrowck — `join_abs_string_buf` ties the
+        // Reshaped for borrowck: `join_abs_string_buf` ties the
         // returned slice's lifetime to both `cwd` (borrowed from `ctx.args`)
         // and `config_buf`. We only need the length to NUL-terminate and
         // re-wrap, so capture `joined.len()` and drop the `ctx` borrow before
diff --git a/src/bunfig/bunfig.rs b/src/bunfig/bunfig.rs
index 8ed18c0faf5..eca200865bc 100644
--- a/src/bunfig/bunfig.rs
+++ b/src/bunfig/bunfig.rs
@@ -1,4 +1,4 @@
-//! Port of `src/runtime/cli/bunfig.zig`.
+//! Bunfig (configuration file) loading.
 //!
 //! `Bunfig::parse` and the inner `Parser` route through the real
 //! `bun_parsers::{toml,json}` parsers (which produce the value-shaped
@@ -28,7 +28,6 @@ use bun_options_types::schema::api;
 use bun_options_types::command_tag::Tag as CommandTag;
 use bun_options_types::context::ContextData;
 
-// Re-exports (Zig: `pub const OfflineMode = @import("../options_types/OfflineMode.zig").OfflineMode;`)
 pub use bun_options_types::offline_mode::OfflineMode;
 
 // TODO: replace api.TransformOptions with Bunfig
@@ -40,9 +39,8 @@ fn estring_to_owned(s: &E::EString, bump: &Bump) -> Box<[u8]> {
     Box::<[u8]>::from(s.string(bump).expect("OOM"))
 }
 
-/// Port of `resolver/package_json.zig` `PackageJSON.parseMacrosJSON`.
-///
-/// Re-ported here against the value-shaped `bun_ast::Expr` (the
+/// Macro-remap parsing (the `PackageJSON.parseMacrosJSON` shape),
+/// implemented here against the value-shaped `bun_ast::Expr` (the
 /// tree produced by the TOML/JSON parsers) and returning the
 /// `bun_options_types::context::MacroMap` shape so the result slots directly
 /// into `ctx.debug.macros` without crossing the `bun_ast::Expr` /
@@ -136,7 +134,7 @@ fn parse_macros_json(
 
 #[inline]
 fn num_to_u32(n: f64) -> u32 {
-    // Note: Rust `as` saturates on overflow/NaN where Zig @intFromFloat is UB.
+    // Note: Rust `as` saturates on overflow/NaN.
     n as u32
 }
 
@@ -148,9 +146,9 @@ pub(crate) struct Parser<'a> {
     json: Expr,
     source: &'a bun_ast::Source,
     log: &'a mut bun_ast::Log,
-    // PORT NOTE: Zig held both `bunfig: *api.TransformOptions` (= `&ctx.args`)
-    // and `ctx: *Command.Context` simultaneously. Rust forbids the overlapping
-    // borrow, so `bunfig` writes route through `self.ctx.args` directly.
+    // Holding both a `TransformOptions` pointer (= `&ctx.args`) and `ctx`
+    // would be an overlapping borrow, so `bunfig` writes route through
+    // `self.ctx.args` directly.
     ctx: &'a mut ContextData,
     /// Arena backing `EString::string()` UTF-16→UTF-8 transcodes; lifetime
     /// matches the `Expr` tree (same bump used for the TOML/JSON parse).
@@ -232,7 +230,6 @@ impl<'a> Parser<'a> {
 
     fn load_log_level(&mut self, expr: &Expr) -> Result<(), bun_core::Error> {
         self.expect_string(expr)?;
-        // PERF(port): Zig used strings.ExactSizeMatcher(8).
         let level = match expr.as_string(self.bump).unwrap_or(b"") {
             b"debug" => api::MessageLevel::Debug,
             b"error" => api::MessageLevel::Err,
@@ -258,7 +255,6 @@ impl<'a> Parser<'a> {
                     self.expect_string(item)?;
                     if let ExprData::EString(s) = &item.data {
                         if s.len() > 0 {
-                            // PERF(port): was appendAssumeCapacity
                             preloads.push(estring_to_owned(s, self.bump));
                         }
                     }
@@ -348,10 +344,10 @@ impl<'a> Parser<'a> {
         Ok(api::StringMap { keys, values })
     }
 
-    // PORT NOTE: `comptime cmd: Command.Tag` demoted to a runtime arg —
+    // `cmd` is a runtime arg rather than a const generic —
     // `bun_options_types::command_tag::Tag` does not derive `ConstParamTy` (it
-    // already derives `enum_map::Enum`, which conflicts). The Zig original
-    // monomorphised over `cmd` purely to dead-code-eliminate untaken arms; the
+    // already derives `enum_map::Enum`, which conflicts). Monomorphising over
+    // `cmd` would only dead-code-eliminate untaken arms; the
     // runtime branches below are equivalent and the few hot fields are tiny.
     pub(crate) fn parse(&mut self, cmd: CommandTag) -> Result<(), bun_core::Error> {
         bun_analytics::features::bunfig.fetch_add(1, Ordering::Relaxed);
@@ -788,7 +784,7 @@ impl<'a> Parser<'a> {
 
                 if let Some(elide_lines) = run_expr.get(b"elide-lines") {
                     if let Some(n) = elide_lines.as_number() {
-                        // Note: Rust `as` saturates on overflow/NaN where Zig @intFromFloat is UB
+                        // Note: Rust `as` saturates on overflow/NaN
                         self.ctx.bundler_options.elide_lines = Some(n as usize);
                     } else {
                         self.add_error(elide_lines.loc, b"Expected number")?;
@@ -937,7 +933,6 @@ impl<'a> Parser<'a> {
                             self.add_error(key_expr.loc, b"Expected package name")?;
                         }
 
-                        // PERF(port): was putAssumeCapacity
                         self.ctx.debug.package_bundle_map.insert(
                             path,
                             if b.value {
@@ -1120,16 +1115,14 @@ impl Bunfig {
         let log: &mut bun_ast::Log = unsafe { &mut *log_ptr };
         let log_count = log.errors + log.warnings;
 
-        // Zig passes `bun.default_allocator` here — no side `mi_heap`. The Rust
-        // port previously called `Arena::new()` (= `mi_heap_new` +
+        // This previously called `Arena::new()` (= `mi_heap_new` +
         // `mi_heap_destroy` on drop), which perf attributed ~1.6% of
         // `bun -e ''` startup to. Borrow the process default heap instead so
-        // TOML/JSON parse allocations route through plain `mi_malloc`, matching
-        // Zig. Parsed config lives for the process lifetime either way.
+        // TOML/JSON parse allocations route through plain `mi_malloc`.
+        // Parsed config lives for the process lifetime either way.
         let bump = Bump::borrowing_default();
 
         let ext = source.path.name().ext;
-        // Zig: `if (strings.eqlComptime(source.path.name.ext[1..], "toml"))`
         let is_toml = ext.len() > 1 && &ext[1..] == b"toml";
 
         let expr = if is_toml {
@@ -1168,9 +1161,9 @@ impl Bunfig {
             }
         };
 
-        // PORT NOTE: reshaped for borrowck — Zig stored both `&mut ctx` and
-        // `&mut ctx.args` simultaneously inside Parser. In Rust we route bunfig
-        // writes through `self.ctx.args` directly. `log` is derived from the
+        // Parser cannot hold both `&mut ctx` and `&mut ctx.args`
+        // simultaneously, so bunfig
+        // writes route through `self.ctx.args` directly. `log` is derived from the
         // copied raw pointer above so it does not overlap the `&mut ctx` borrow.
         // SAFETY: Parser never reaches `ctx.log` (only `self.log`), so no two
         // live `&mut` to the same `Log` coexist.
@@ -1259,7 +1252,6 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_install(&mut self, install_obj: &Expr) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig held `*BunInstall` and `*Parser` simultaneously.
         // The helper methods (`expect*`, `add_error`, `parse_registry`) take
         // `&mut self`, which under Stacked Borrows would invalidate any
         // long-lived `&mut` derived from `self.ctx.install`. Move the box
@@ -1540,7 +1532,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        // bunfig.zig:824-839 — remap PnpmMatcher errors so callers (and the
+        // Remap PnpmMatcher errors so callers (and the
         // crash handler's `"Invalid Bunfig"` match) see the canonical
         // bunfig error; only OOM passes through unchanged.
         let remap = |e: FromExprError| -> bun_core::Error {
@@ -1680,5 +1672,3 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 }
-
-// ported from: src/runtime/cli/bunfig.zig
diff --git a/src/bunfig/lib.rs b/src/bunfig/lib.rs
index 081e628aabf..12e96c1be16 100644
--- a/src/bunfig/lib.rs
+++ b/src/bunfig/lib.rs
@@ -1,8 +1,8 @@
 //! `bun_bunfig` — bunfig.toml parser and `Arguments::loadConfig` entrypoints.
 //!
-//! that `bun_install::PackageManager::init` can call
-//! `bun.cli.Arguments.loadConfig(_, cli.config, ctx, .InstallCommand)`
-//! (PackageManager.zig:801) without a tier-6 dependency or fn-pointer hook.
+//! Split out so that `bun_install::PackageManager::init` can call
+//! `Arguments::loadConfig`
+//! without a tier-6 dependency or fn-pointer hook.
 //! Every dependency of this crate was already a transitive dependency of
 //! `bun_install` (via `bun_transpiler` → `bun_bundler`), so no cycle is
 //! introduced; this only makes the existing edge direct.
diff --git a/src/c-headers-for-zig.h b/src/c-headers-for-zig.h
index d08b86b7051..29d0b1fb6c2 100644
--- a/src/c-headers-for-zig.h
+++ b/src/c-headers-for-zig.h
@@ -1,14 +1,10 @@
-// This file is run through translate-c and exposed to Zig code
-// under the namespace bun.c (lowercase c). Prefer adding includes
-// to this file instead of manually porting struct definitions
-// into Zig code. By using automatic translation, differences
+// Aggregated C includes for automatic translation into bindings.
+// Prefer adding includes
+// to this file instead of manually porting struct definitions.
+// By using automatic translation, differences
 // between platforms and subtle mistakes can be avoided.
 //
-// One way to locate a definition for a given symbol is to open
-// Zig's `lib` directory and run ripgrep on it. For example,
-// `sockaddr_dl` is in `libc/include/any-macos-any/net/if_dl.h`
-//
-// When Zig is translating this file, it will define these macros:
+// When this file is translated, these macros are defined:
 // - WINDOWS
 // - DARWIN
 // - LINUX
diff --git a/src/cares_sys/c_ares.rs b/src/cares_sys/c_ares.rs
index 06d933ddff8..efdc8ddd315 100644
--- a/src/cares_sys/c_ares.rs
+++ b/src/cares_sys/c_ares.rs
@@ -32,7 +32,7 @@ bun_opaque::opaque_ffi! {
     pub struct struct_apattern;
 }
 
-/// Mirror of `std.posix.AF` in Zig — only the address families c-ares
+/// Only the address families c-ares
 /// actually uses. Kept local so this `*_sys` crate stays leaf-level
 /// (no dependency on `bun_sys`). Canonical: `bun_sys::posix::AF`.
 pub mod AF {
@@ -50,7 +50,7 @@ pub mod AF {
     pub const INET6: c_int = libc::AF_INET6;
 }
 
-/// Mirror of `std.posix.system.EAI` in Zig. The `libc` crate is missing
+/// `EAI_*` getaddrinfo error codes. The `libc` crate is missing
 /// `EAI_ADDRFAMILY` and the glibc-only async-getaddrinfo extensions, so we
 /// hardcode those raw values from `<netdb.h>`.
 #[cfg(not(windows))]
@@ -118,9 +118,9 @@ pub enum NSClass {
     ns_c_max = 65536,
 }
 
-// Zig: `enum(c_int) { ..., _ }` (non-exhaustive). Values are only ever
+// Values are only ever
 // constructed in Rust and passed *to* C, so a plain repr(i32) enum is sound.
-// TODO(port): if c-ares ever returns an NSType, switch to a transparent newtype.
+// If c-ares ever returns an NSType, this must become a transparent newtype.
 #[repr(i32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum NSType {
@@ -305,17 +305,11 @@ pub struct struct_hostent {
     pub h_addr_list: *mut *mut c_char, // NUL-terminated array
 }
 
-// ─── callback-wrapper reshaping note ──────────────────────────────────────
-// Zig: each reply type defines
-//   pub fn Callback(comptime Type) type = fn(*Type, ?Error, i32, ?*Reply) void
-//   pub fn callbackWrapper(comptime lookup_name, comptime Type, comptime fn) ares_callback
-// which monomorphizes a unique `extern "C"` thunk per (Type, fn) pair via the
-// anonymous-struct trick. Rust cannot take a fn pointer as a const generic on
-// stable, so the wrappers below are reshaped to a trait: the implementing
+// ─── callback-wrapper note ─────────────────────────────────────────────────
+// Rust cannot take a fn pointer as a const generic on
+// stable, so the wrappers below are expressed as a trait: the implementing
 // type provides the callback as a trait method, and the `extern "C"` thunk is
 // monomorphized per `T: Trait`.
-// TODO(port): a proc-macro may be cleaner if many callsites need distinct
-// callbacks on the same `Type`.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait HostentHandler: Sized {
@@ -340,7 +334,7 @@ impl struct_hostent {
         this.on_hostent(None, timeouts, hostent);
     }
 
-    // Zig branched on `comptime lookup_name`; split into one thunk per name.
+    // One `extern "C"` thunk per lookup name.
     pub unsafe extern "C" fn callback_wrapper_cname<T: HostentHandler>(
         ctx: *mut c_void,
         status: c_int,
@@ -452,8 +446,7 @@ impl Default for hostent_with_ttls {
 
 pub trait HostentWithTtlsHandler: Sized {
     /// `hostent_with_ttls::parse_a` or `parse_aaaa` — selects the c-ares reply
-    /// parser for [`hostent_with_ttls::callback_wrapper`]. Mirrors the Zig
-    /// `callbackWrapper(comptime lookup_name, ...)` parameterization.
+    /// parser for [`hostent_with_ttls::callback_wrapper`].
     const PARSE: fn(&[u8]) -> Result<Box<hostent_with_ttls>, Error>;
 
     fn on_hostent_with_ttls(
@@ -467,24 +460,6 @@ pub trait HostentWithTtlsHandler: Sized {
 impl hostent_with_ttls {
     // toJSResponse alias deleted — lives in bun_runtime::dns_jsc.
 
-    pub unsafe extern "C" fn host_callback_wrapper<T: HostentWithTtlsHandler>(
-        ctx: *mut c_void,
-        status: c_int,
-        timeouts: c_int,
-        hostent: Option<Box<hostent_with_ttls>>,
-    ) {
-        // TODO(port): Zig declared this as `ares_host_callback` (4th arg
-        // `?*hostent_with_ttls`) but that signature mismatches the C
-        // `ares_host_callback` (`?*struct_hostent`). Appears unused; verify.
-        // SAFETY: ctx was passed as *mut T to the ares call that registered this thunk.
-        let this = unsafe { bun_core::callback_ctx::<T>(ctx) };
-        if status != ARES_SUCCESS {
-            this.on_hostent_with_ttls(Error::get(status), timeouts, None);
-            return;
-        }
-        this.on_hostent_with_ttls(None, timeouts, hostent);
-    }
-
     pub unsafe extern "C" fn callback_wrapper<T: HostentWithTtlsHandler>(
         ctx: *mut c_void,
         status: c_int,
@@ -574,9 +549,8 @@ impl Drop for hostent_with_ttls {
     }
 }
 
-// Per-record-type newtype aliases. Zig instantiated the resolve machinery over
-// the same `struct_hostent` / `hostent_with_ttls` with a comptime `type_name`
-// string; Rust callers (`dns.rs`) need distinct type names to monomorphise the
+// Per-record-type newtype aliases.
+// Callers (`dns.rs`) need distinct type names to monomorphise the
 // `CAresRecordType` cache-field constant per record. For now these are plain
 // aliases — the trait impls live downstream.
 pub type NsHostent = struct_hostent;
@@ -675,17 +649,7 @@ impl AddrInfo {
         unsafe { core::ffi::CStr::from_ptr(self.name_) }.to_bytes()
     }
 
-    #[inline]
-    pub fn cnames(&self) -> &[AddrInfo_node] {
-        // TODO(port): Zig used `bun.span` on a [*c]AddrInfo_cname (sentinel-
-        // terminated linked list), returning `[]const AddrInfo_node` — note
-        // the type mismatch (cname vs node) in the original. This appears
-        // unused; preserving the empty-slice fast path only.
-        if self.cnames_.is_null() {
-            return &[];
-        }
-        &[]
-    }
+    // Consumers walk `cnames_` / `node` pointer chains directly.
 
     pub unsafe extern "C" fn callback_wrapper<T: AddrInfoHandler>(
         ctx: *mut c_void,
@@ -741,7 +705,7 @@ bun_opaque::opaque_ffi! {
 const _: () = assert!(core::mem::size_of::<Channel>() == 0);
 
 /// Implemented by the type that owns a `*mut Channel` and receives socket-
-/// state callbacks. Zig: `Container.onDNSSocketState` + `this.channel = ch`.
+/// state callbacks.
 ///
 /// R-2: methods take `&self`. The c-ares `sock_state_cb` re-enters the
 /// container while a `&self` borrow may already be live in `on_dns_poll`;
@@ -753,9 +717,7 @@ pub trait ChannelContainer: Sized {
 
 /// Trait for `Channel::resolve`: ties a lookup-name string to its NSType and
 /// the `extern "C"` parse-thunk used as the ares_callback.
-/// TODO(port): Zig dispatched via `@field(NSType, "ns_t_" ++ lookup_name)` and
-/// `cares_type.callbackWrapper(lookup_name, Type, callback)`. This trait is the
-/// Rust-side reshaping; the dns_jsc consumer impls it per (T, record-type).
+/// The dns_jsc consumer impls it per (T, record-type).
 pub trait ResolveHandler: Sized {
     const LOOKUP_NAME: &'static [u8];
     const NS_TYPE: NSType;
@@ -841,7 +803,7 @@ impl Channel {
         unsafe { ares_destroy(this) };
     }
 
-    /// See c-ares `ares_getaddrinfo` documentation (mirrored in the Zig source).
+    /// See c-ares `ares_getaddrinfo` documentation.
     pub fn get_addr_info<T: AddrInfoHandler>(
         &mut self,
         host: &[u8],
@@ -1258,7 +1220,7 @@ pub struct struct_ares_addr6ttl {
 }
 
 // SAFETY: `#[repr(C)]` POD — 16-byte byte-array union + `c_int`. All-zero is a
-// valid bit pattern (matches Zig `std.mem.zeroes`) (S021).
+// valid bit pattern (S021).
 unsafe impl bun_core::ffi::Zeroable for struct_ares_addr6ttl {}
 impl Default for struct_ares_addr6ttl {
     #[inline]
@@ -1655,7 +1617,6 @@ impl struct_any_reply {
 
 impl Drop for struct_any_reply {
     fn drop(&mut self) {
-        // Zig: `inline for (@typeInfo(..).fields)` — written out by hand.
         // a_reply / aaaa_reply are Box<hostent_with_ttls>; their Drop frees the
         // inner hostent via ares_free_hostent.
         // SAFETY: each field is either null or a c-ares allocation matching its free fn.
@@ -1972,10 +1933,8 @@ impl Error {
                 EAI::MEMORY => Some(Error::ENOMEM),
                 EAI::SERVICE => Some(Error::ESERVICE),
                 EAI::SYSTEM => Some(Error::ESERVFAIL),
-                _ => {
-                    // TODO(port): bun.todo(@src(), Error.ENOTIMP)
-                    Some(Error::ENOTIMP)
-                }
+                // Any EAI code not mapped above is reported as "not implemented".
+                _ => Some(Error::ENOTIMP),
             }
         }
     }
@@ -2221,9 +2180,10 @@ pub fn get_sockaddr(addr: &[u8], port: u16, sa: &mut sockaddr) -> c_int {
     -1
 }
 
-// Zig: `struct_in_addr = std.posix.sockaddr.in` — note this aliases the full
-// sockaddr_in (not the 4-byte in_addr). Preserved for ABI parity in `Options.servers`.
-// TODO(port): verify against c-ares header; this looks like a Zig-side misnomer.
-type in_addr = sockaddr_in;
-
-// ported from: src/cares_sys/c_ares.zig
+/// The C `struct in_addr` (4-byte IPv4 address), as c-ares' `ares_options.servers`
+/// and the `ares_addr_node`/`ares_addr_port_node` unions declare it.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct in_addr {
+    pub s_addr: u32,
+}
diff --git a/src/clap/args.rs b/src/clap/args.rs
index c35b2147df1..d3d8b8a04e4 100644
--- a/src/clap/args.rs
+++ b/src/clap/args.rs
@@ -1,7 +1,7 @@
 use core::convert::Infallible;
 use std::borrow::Cow;
 
-/// Duck-typed arg-iterator surface (Zig used `anytype`). Implemented by
+/// Arg-iterator surface. Implemented by
 /// `OsIterator` and `SliceIterator`; `ShellIterator` does not fit (fallible,
 /// owned results) and is used standalone.
 pub trait ArgIter<'a> {
@@ -20,7 +20,7 @@ impl ExampleArgIterator {
 }
 
 /// Pop the first element of `remain`, advancing the slice. Shared body for
-/// `SliceIterator::next` / `OsIterator::next` (the .zig spec duplicates them).
+/// `SliceIterator::next` / `OsIterator::next`.
 #[inline]
 fn pop_first<'a>(remain: &mut &'a [&'a [u8]]) -> Option<&'a [u8]> {
     if remain.is_empty() {
@@ -61,8 +61,7 @@ impl<'a> ArgIter<'a> for SliceIterator<'a> {
 /// An argument iterator which wraps the ArgIterator in ::std.
 /// On windows, this iterator allocates.
 pub struct OsIterator {
-    // PORT NOTE: the Zig `arena: bun.ArenaAllocator` field was dropped — non-AST crate,
-    // and `remain` borrows the process-global argv so nothing is allocated per-call.
+    // `remain` borrows the process-global argv, so nothing is allocated per-call.
     pub remain: &'static [&'static [u8]],
 
     /// The executable path (this is the first argument passed to the program)
@@ -81,8 +80,6 @@ impl OsIterator {
         res
     }
 
-    // PORT NOTE: `deinit` dropped — it only freed the arena, which no longer exists.
-
     pub fn next(&mut self) -> Option<&'static [u8]> {
         pop_first(&mut self.remain)
     }
@@ -99,10 +96,8 @@ impl ArgIter<'static> for OsIterator {
     }
 }
 
-/// Process argv as a `&'static` slice of `&'static [u8]`.
-///
-/// Zig: `bun.argv: [][:0]const u8` — the process-global view that includes
-/// `BUN_OPTIONS` injection.
+/// Process argv as a `&'static` slice of `&'static [u8]` — the process-global
+/// view that includes `BUN_OPTIONS` injection.
 ///
 /// This used to project `&ZStr → &[u8]` through a `OnceLock<Vec<&[u8]>>`,
 /// which (a) allocated a Vec on the `--version` startup path and (b) emitted a
@@ -127,8 +122,8 @@ pub enum ShellIteratorError {
     DanglingEscape,
     #[error("QuoteNotClosed")]
     QuoteNotClosed,
-    // PORT NOTE: Zig union included `mem.Allocator.Error` (OutOfMemory). Vec aborts on OOM
-    // under the global mimalloc allocator, so that variant is dropped.
+    // There is no OutOfMemory variant: Vec aborts
+    // on OOM under the global mimalloc allocator.
 }
 
 bun_core::named_error_set!(ShellIteratorError);
@@ -136,7 +131,6 @@ bun_core::named_error_set!(ShellIteratorError);
 /// An argument iterator that takes a string and parses it into arguments, simulating
 /// how shells split arguments.
 pub struct ShellIterator<'a> {
-    // PORT NOTE: the Zig `arena: bun.ArenaAllocator` field was dropped (non-AST crate).
     // Allocated results are returned as `Cow::Owned` instead of arena-backed slices.
     pub str: &'a [u8],
 }
@@ -157,8 +151,6 @@ impl<'a> ShellIterator<'a> {
         ShellIterator { str }
     }
 
-    // PORT NOTE: `deinit` dropped — it only freed the arena, which no longer exists.
-
     pub fn next(&mut self) -> Result<Option<Cow<'a, [u8]>>, ShellIteratorError> {
         // Whenever possible, this iterator will return slices into `str` instead of
         // allocating. Sometimes this is not possible, for example, escaped characters
@@ -167,8 +159,7 @@ impl<'a> ShellIterator<'a> {
         let mut start: usize = 0;
         let mut state = State::SkipWhitespace;
 
-        // PORT NOTE: reshaped for borrowck — copy the slice ref so we can reassign
-        // `self.str` before returning (Zig used `defer iter.str = ...`).
+        // Copy the slice ref so we can reassign `self.str` before returning.
         let s: &'a [u8] = self.str;
 
         for (i, &c) in s.iter().enumerate() {
@@ -284,8 +275,8 @@ impl<'a> ShellIterator<'a> {
                 // The state we end up when after the escape character (`\`). All these
                 // states do is transition back into the previous state.
                 // TODO: Are there any escape sequences that does transform the second
-                //       character into something else? For example, in Zig, `\n` is
-                //       transformed into the line feed ascii character.
+                //       character into something else (e.g. `\n` into the line feed
+                //       ascii character)?
                 State::NoQuoteEscape => {
                     state = State::NoQuote;
                 }
@@ -320,7 +311,6 @@ impl<'a> ShellIterator<'a> {
         // the rest we have to the list and return that.
         if !list.is_empty() {
             list.extend_from_slice(res);
-            // PERF(port): was arena-backed `toOwnedSlice()`.
             return Ok(Some(Cow::Owned(list)));
         }
         Ok(Some(Cow::Borrowed(res)))
@@ -342,17 +332,23 @@ mod tests {
         }
     }
 
-    fn test_shell_iterator_ok(str: &[u8], allocations: usize, expect: &[&[u8]]) {
-        // TODO(port): Zig used `testing.FailingAllocator` to cap/count allocations.
-        // No allocator injection in the Rust port; `allocations` is unused.
-        let _ = allocations;
+    fn test_shell_iterator_ok(str: &[u8], expected_owned_results: usize, expect: &[&[u8]]) {
+        // There is no allocator injection to count raw allocations with,
+        // but every allocating result surfaces as a
+        // `Cow::Owned`, so counting owned results checks the same property: the
+        // borrowed (zero-copy) fast path is taken whenever possible.
+        let mut owned_results: usize = 0;
         let mut it = ShellIterator::init(str);
 
         for e in expect {
             match it.next() {
                 Ok(actual) => {
                     assert!(actual.is_some());
-                    assert_eq!(*e, &*actual.unwrap());
+                    let actual = actual.unwrap();
+                    if matches!(actual, Cow::Owned(_)) {
+                        owned_results += 1;
+                    }
+                    assert_eq!(*e, &*actual);
                 }
                 Err(err) => panic!("expected {:?}, got error {:?}", e, err),
             }
@@ -361,7 +357,7 @@ mod tests {
         match it.next() {
             Ok(actual) => {
                 assert!(actual.is_none());
-                // TODO(port): assert_eq!(allocations, allocator.allocations);
+                assert_eq!(expected_owned_results, owned_results);
             }
             Err(err) => panic!("expected end of iterator, got error {:?}", err),
         }
@@ -433,5 +429,3 @@ mod tests {
         test_shell_iterator_err(b"a\\", ShellIteratorError::DanglingEscape);
     }
 }
-
-// ported from: src/clap/args.zig
diff --git a/src/clap/comptime.rs b/src/clap/comptime.rs
index 66f8257ff0b..345ddad2219 100644
--- a/src/clap/comptime.rs
+++ b/src/clap/comptime.rs
@@ -7,21 +7,20 @@ use crate::streaming::{self, StreamingClap};
 use crate::{Names, Param, ParseOptions, Values};
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Compile-time conversion (Zig parity)
+// Compile-time conversion
 //
-// Zig's `ComptimeClap(Id, params)` is a comptime type-generator: it iterates
-// `params` *at comptime* to (a) re-index every param's `id` to its slot within
-// its category (flag / single / multi) and (b) emit a struct with fixed-size
-// array fields. `findParam` is `inline for`, so every `args.flag("--foo")`
-// compiles to a constant index — zero runtime cost.
+// The param-table conversion can run entirely at compile time: (a) re-index
+// every param's `id` to its slot within
+// its category (flag / single / multi) and (b) emit fixed-size
+// array fields, so every `args.flag("--foo")`
+// lookup folds to a constant index — zero runtime cost.
 //
-// An earlier draft of this port did all of this at runtime: `convert_params` heap-allocated
+// An earlier draft did all of this at runtime: `convert_params` heap-allocated
 // a `Vec<Param<usize>>` on every CLI start, and `find_param` linear-scanned it
 // for every `flag()`/`option()` lookup (~190 lookups × ~100 params on the
-// `bun run` path). perf put this at ~0.25 % of `bun --version` cycles vs ~0 %
-// in Zig.
+// `bun run` path). perf put this at ~0.25 % of `bun --version` cycles.
 //
-// This module restores the comptime semantics on stable Rust:
+// This module does the conversion at compile time on stable Rust:
 //
 //   * `count_flags` / `count_single` / `count_multi` / `convert_params_array`
 //     / `find_param_index` are all `const fn`, so a param table declared with
@@ -29,8 +28,7 @@ use crate::{Names, Param, ParseOptions, Values};
 //     name lookup can be folded to a constant via `const { find_param_index(..) }`.
 //
 //   * `comptime_table!` (in `lib.rs`) packages the const-fn output as a
-//     `&'static ConvertedTable` — the Rust analogue of the Zig comptime
-//     `converted_params` const baked into the generated type.
+//     `&'static ConvertedTable` baked into rodata.
 //
 //   * Every per-subcommand table in `runtime/cli/Arguments.rs` is now a
 //     `pub static *_TABLE: &ConvertedTable = comptime_table!(*_PARAMS)`, and
@@ -48,7 +46,7 @@ const fn is_named<Id>(p: &Param<Id>) -> bool {
     p.names.long.is_some() || p.names.short.is_some()
 }
 
-/// Count flag params (named, `takes_value == None`). Zig: comptime loop arm.
+/// Count flag params (named, `takes_value == None`).
 pub const fn count_flags<Id>(params: &[Param<Id>]) -> usize {
     let mut n = 0;
     let mut i = 0;
@@ -89,8 +87,8 @@ pub const fn count_multi<Id>(params: &[Param<Id>]) -> usize {
     n
 }
 
-/// Compile-time equivalent of the Zig comptime conversion loop (comptime.zig
-/// lines 6–32): re-indexes each param's `id` to its slot within its category.
+/// Compile-time conversion loop:
+/// re-indexes each param's `id` to its slot within its category.
 /// `N` must equal `params.len()` (asserted at const-eval).
 pub const fn convert_params_array<Id, const N: usize>(params: &[Param<Id>]) -> [Param<usize>; N] {
     const DUMMY: Param<usize> = Param {
@@ -137,16 +135,14 @@ pub const fn convert_params_array<Id, const N: usize>(params: &[Param<Id>]) -> [
     out
 }
 
-/// Compile-time name → converted-param index. This is the Rust analogue of
-/// Zig's `inline for` `findParam` and is intended to be called inside a
+/// Compile-time name → converted-param index. Intended to be called inside a
 /// `const { }` block so the loop folds to a literal:
 ///
 /// ```ignore
 /// const IDX: usize = find_param_index(TABLE.converted, b"--help");
 /// ```
 ///
-/// Panics (at const-eval, i.e. a build error) if `name` is not in `converted`
-/// — matching Zig's `@compileError("no param '…'")`.
+/// Panics (at const-eval, i.e. a build error) if `name` is not in `converted`.
 pub(crate) const fn find_param_index(converted: &[Param<usize>], name: &[u8]) -> usize {
     if name.len() > 2 && name[0] == b'-' && name[1] == b'-' {
         let (_, key) = name.split_at(2);
@@ -300,8 +296,8 @@ impl ConvertedTable {
     /// Build a table entirely at compile time. All four arguments come from
     /// the `const fn`s above via [`comptime_table!`](crate::comptime_table),
     /// so the converted param array, category counts, sorted long-name hash
-    /// index, and short-name direct index all land in rodata — full Zig
-    /// `ComptimeClap` parity with zero runtime work.
+    /// index, and short-name direct index all land in rodata —
+    /// zero runtime work.
     pub const fn from_const(
         converted: &'static [Param<usize>],
         n_flags: usize,
@@ -509,17 +505,15 @@ pub fn convert_params<Id>(params: &[Param<Id>]) -> (Vec<Param<usize>>, usize, us
 
 /// Deprecated: Use `parse_ex` instead
 pub struct ComptimeClap<Id> {
-    // Field order matches comptime.zig.
-    // Inner `&'static [u8]` slices borrow argv (process-lifetime); never freed in Zig `deinit`.
+    // Inner `&'static [u8]` slices borrow argv (process-lifetime).
     pub single_options: Box<[Option<&'static [u8]>]>,
     pub multi_options: Box<[Box<[&'static [u8]]>]>,
     pub flags: Box<[bool]>,
     pub pos: Box<[&'static [u8]]>,
     pub passthrough_positionals: Box<[&'static [u8]]>,
-    // `mem.Allocator param` field deleted — global mimalloc (see PORTING.md §Allocators).
 
-    // Zig captures `converted_params` as a comptime const on the returned type. Rust
-    // carries it as a `&'static` table — either rodata (`comptime_table!`) or
+    // The converted params are
+    // carried as a `&'static` table — either rodata (`comptime_table!`) or
     // interned-once via the ptr-keyed registry — so `flag`/`option` resolve via
     // hashed lookup instead of an O(n) scan, and no per-parse `Vec` is allocated.
     table: &'static ConvertedTable,
@@ -560,7 +554,6 @@ impl<Id> ComptimeClap<Id> {
     ) -> Result<Self, bun_core::Error>
     where
         I: ArgIter<'static>,
-        // TODO(port): narrow error set
     {
         // `opt.allocator` dropped — global mimalloc.
         let mut multis: Vec<Vec<&'static [u8]>> = (0..table.n_multi).map(|_| Vec::new()).collect();
@@ -572,8 +565,6 @@ impl<Id> ComptimeClap<Id> {
             vec![None; table.n_single].into_boxed_slice();
         let mut flags: Box<[bool]> = vec![false; table.n_flags].into_boxed_slice();
 
-        // Zig: `StreamingClap(usize, @typeInfo(@TypeOf(iter)).pointer.child)` — the second
-        // type arg is the pointee of `iter`; in Rust that is just `I`.
         let mut stream = StreamingClap::<usize, I> {
             params: table.converted,
             iter,
@@ -588,9 +579,6 @@ impl<Id> ComptimeClap<Id> {
                 pos.push(arg.value.unwrap());
                 if opt.stop_after_positional_at > 0 && pos.len() >= opt.stop_after_positional_at {
                     let mut remaining_ = stream.iter.remain();
-                    // PORT NOTE: Zig called `bun.span` (NUL-scan) on `[:0]const u8` argv
-                    // entries. Our `ArgIter` already yields sized `&[u8]`, so `span` is a
-                    // no-op and is dropped.
                     let first: &[u8] = if !remaining_.is_empty() {
                         remaining_[0]
                     } else {
@@ -626,7 +614,6 @@ impl<Id> ComptimeClap<Id> {
 
         Ok(Self {
             single_options,
-            // PORT NOTE: Zig left these `undefined` and filled them post-loop.
             multi_options: multis.into_iter().map(Vec::into_boxed_slice).collect(),
             flags,
             pos: pos.into_boxed_slice(),
@@ -636,10 +623,7 @@ impl<Id> ComptimeClap<Id> {
         })
     }
 
-    // Zig `deinit` only freed `multi_options[*]` and `pos` (not `passthrough_positionals` —
-    // likely a leak in the deprecated Zig). All are owned here, so `Drop` handles it;
-    // body deleted per PORTING.md §Idiom map (`pub fn deinit` → `impl Drop`, empty body
-    // when it only frees owned fields).
+    // All fields are owned, so `Drop` handles cleanup; no explicit deinit needed.
 
     #[inline]
     pub fn flag(&self, name: &[u8]) -> bool {
@@ -685,7 +669,7 @@ impl<Id> ComptimeClap<Id> {
     }
 
     /// Direct slot accessors — pair with [`find_param_index`] inside
-    /// `const { }` for true Zig-parity zero-cost lookup at the call site.
+    /// `const { }` for zero-cost lookup at the call site.
     #[inline]
     pub fn flag_at(&self, converted_idx: usize) -> bool {
         self.flags[self.table.converted[converted_idx].id]
@@ -707,8 +691,7 @@ impl<Id> ComptimeClap<Id> {
         &self.passthrough_positionals
     }
 
-    /// Zig `hasFlag` is a comptime-only predicate over the captured table.
-    /// `const fn` here so `const { has_flag(PARAMS, b"--foo") }` folds.
+    /// `const fn` so `const { has_flag(PARAMS, b"--foo") }` folds.
     pub const fn has_flag(params: &[Param<Id>], name: &[u8]) -> bool {
         let mut i = 0;
         while i < params.len() {
@@ -745,5 +728,3 @@ impl<Id> ComptimeClap<Id> {
         self.table.find(name)
     }
 }
-
-// ported from: src/clap/comptime.zig
diff --git a/src/clap/lib.rs b/src/clap/lib.rs
index 8c4d38d22d4..768234df2d6 100644
--- a/src/clap/lib.rs
+++ b/src/clap/lib.rs
@@ -19,8 +19,7 @@ pub use streaming::StreamingClap;
 pub use bun_clap_macros::{__parse_param_impl, __parse_params_impl};
 
 /// Parse a single param spec string (e.g. `"-h, --help  Display this help"`)
-/// into a const `Param<Help>` literal at compile time. This is the Rust
-/// equivalent of Zig's comptime `clap.parseParam(...) catch unreachable`.
+/// into a const `Param<Help>` literal at compile time.
 ///
 /// The argument **must** be a string literal; parse errors surface as compile
 /// errors at the call site.
@@ -31,8 +30,7 @@ macro_rules! parse_param {
     };
 }
 
-/// Alias for [`parse_param!`] matching the Zig call-site spelling
-/// (`clap.parseParam` → `clap::param!`).
+/// Alias for [`parse_param!`].
 #[macro_export]
 macro_rules! param {
     ($lit:literal $(,)?) => {
@@ -40,8 +38,8 @@ macro_rules! param {
     };
 }
 
-/// Const-time `Param<Help>` slice concatenation — the Rust analogue of Zig's
-/// comptime `a ++ b ++ c` over param tables. Produces a `&'static [Param<Help>]`
+/// Const-time `Param<Help>` slice concatenation
+/// over param tables. Produces a `&'static [Param<Help>]`
 /// baked into rodata; no `LazyLock`, no heap, no init closure in `.text`.
 ///
 /// Every `$part` must be a `const`-evaluable `&[Param<Help>]` (a `const` item or
@@ -57,8 +55,7 @@ macro_rules! concat_params {
 }
 
 /// Build a `&'static ConvertedTable` from a const-evaluable
-/// `&[Param<Help>]` at compile time — the Rust analogue of Zig's
-/// `ComptimeClap(Id, params)` type-generator. The converted `[Param<usize>; N]`
+/// `&[Param<Help>]` at compile time. The converted `[Param<usize>; N]`
 /// array, the three category counts, the short-name index, *and* the sorted
 /// long-name hash index all land in rodata, so [`parse_with_table`] does no
 /// heap allocation, no sorting, no locking, and `args.flag(b"--foo")`
@@ -206,7 +203,7 @@ pub struct Names {
 }
 
 impl Names {
-    /// `.{ .short = c }`
+    /// A name with only a short flag (`-c`).
     #[inline]
     pub const fn short(c: u8) -> Self {
         Self {
@@ -216,7 +213,7 @@ impl Names {
         }
     }
 
-    /// `.{ .long = name }`
+    /// A name with only a long flag (`--name`).
     #[inline]
     pub const fn long(name: &'static [u8]) -> Self {
         Self {
@@ -245,7 +242,6 @@ impl Names {
     /// long, or any long alias. Shared predicate for `has_flag`/`find_param`.
     pub fn matches(&self, name: &[u8]) -> bool {
         if let Some(s) = self.short {
-            // Zig: mem.eql(u8, name, "-" ++ [_]u8{s})
             if name.len() == 2 && name[0] == b'-' && name[1] == s {
                 return true;
             }
@@ -298,8 +294,6 @@ pub struct Param<Id> {
 
 impl<Id: Default> Default for Param<Id> {
     fn default() -> Self {
-        // SAFETY note: Zig used `std.mem.zeroes(Id)` / `std.mem.zeroes(Names)`.
-        // We require `Id: Default` instead — same effect for the `Help` payload.
         Self {
             id: Id::default(),
             names: Names::default(),
@@ -328,10 +322,10 @@ fn expect_param(expect: Param<Help>, actual: Param<Help>) {
 }
 
 /// Optional diagnostics used for reporting useful errors
-// PORT NOTE: Zig `Diagnostic` borrows `arg`/`name.long` from the arg iterator. Rust
-// can't tie that lifetime through `&mut Diagnostic` without invariance headaches, and
-// this is an error-path-only struct, so it owns its bytes instead. The `name: Names`
-// field is flattened to `short`/`long` because `Names.long` is `&'static`.
+// Borrowing `arg`/`name.long` from the arg iterator would tie
+// that lifetime through `&mut Diagnostic` with invariance headaches, and this is
+// an error-path-only struct, so it owns its bytes instead. The `name: Names` field
+// is flattened to `short`/`long` because `Names.long` is `&'static`.
 #[derive(Default)]
 pub struct Diagnostic {
     pub arg: Vec<u8>,
@@ -349,7 +343,6 @@ impl Diagnostic {
     #[cold]
     #[inline(never)]
     pub fn report<W>(&self, _stream: W, err: bun_core::Error) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut name_buf = [0u8; 1024];
         let name: &[u8] = if let Some(s) = self.short {
             name_buf[0] = b'-';
@@ -394,8 +387,8 @@ impl Diagnostic {
 #[derive(Clone, Copy)]
 pub struct Help {
     /// The description text exactly as written in the param spec — may still
-    /// contain `<tag>` colour markup. Used by [`help`]/[`help_ex`], which (like
-    /// Zig's `clap.help`) emit it verbatim, and as the source for the ANSI form
+    /// contain `<tag>` colour markup. Used by [`help`]/[`help_ex`], which
+    /// emit it verbatim, and as the source for the ANSI form
     /// built lazily by [`pretty_help_desc`] on the `bun --help` colour path.
     pub msg: &'static [u8],
     /// `msg` with `<tag>` colour markup stripped — the non-TTY / piped help form.
@@ -419,8 +412,6 @@ impl Default for Help {
 /// Options that can be set to customize the behavior of parsing.
 #[derive(Default)]
 pub struct ParseOptions<'a> {
-    // PORT NOTE: `mem.Allocator param` field deleted — non-AST crate uses
-    // the global mimalloc.
     pub diagnostic: Option<&'a mut Diagnostic>,
     pub stop_after_positional_at: usize,
 }
@@ -444,9 +435,8 @@ fn get_help_simple(param: &Param<Help>) -> &'static [u8] {
 /// output is actually requested. That `<tag>`→ANSI rewrite only ever runs on
 /// `bun --help` / `bun run --help`; `--print` and ordinary runs never reach this
 /// path, so they pay neither the per-invocation reparse nor the extra rodata a
-/// baked-in `msg_ansi` array would cost on every flag and subcommand. (Zig did
-/// the rewrite at `comptime` via `Output.prettyFmt` inside
-/// `clap.simpleHelpBunTopLevel`; the colour case is rare enough that doing it
+/// baked-in `msg_ansi` array would cost on every flag and subcommand. (The
+/// colour case is rare enough that doing the rewrite
 /// lazily at runtime is the better trade for binary size.)
 #[cold]
 #[inline(never)]
@@ -465,13 +455,7 @@ fn get_value_simple(param: &Param<Help>) -> &'static [u8] {
     param.id.value
 }
 
-// TODO(port): `comptime params: []const Param(Id)` as a type parameter has no
-// stable-Rust equivalent. `params` is carried at runtime; a proc-macro could
-// restore the per-table monomorphization.
 pub struct Args<Id: 'static> {
-    // PORT NOTE: Zig stored `arena: bun.ArenaAllocator` here and `deinit` freed it.
-    // Non-AST crate → arena removed; `ComptimeClap` owns its allocations.
-    // PERF(port): was arena bulk-free — profile if hot.
     pub clap: ComptimeClap<Id>,
     pub exe_arg: Option<&'static [u8]>,
 }
@@ -514,13 +498,9 @@ pub fn parse<Id: 'static>(
     params: &'static [Param<Id>],
     opt: ParseOptions<'_>,
 ) -> Result<Args<Id>, bun_core::Error> {
-    // TODO(port): narrow error set
     let mut iter = args::OsIterator::init();
     let exe_arg = iter.exe_arg;
 
-    // PORT NOTE: Zig reused `iter.arena` as the allocator for `parseEx` and
-    // moved it into `res.arena`. Arena removed in port; ownership flows through
-    // `ComptimeClap` directly.
     let clap = parse_ex::<Id, _>(
         params,
         &mut iter,
@@ -566,7 +546,6 @@ pub fn parse_ex<Id: 'static, I>(
 where
     I: args::ArgIter<'static>,
 {
-    // TODO(port): narrow error set
     ComptimeClap::<Id>::parse(params, iter, opt)
 }
 
@@ -590,7 +569,6 @@ where
     Id: Copy,
     E: Into<bun_core::Error>,
 {
-    // TODO(port): narrow error set
     let max_spacing: usize = 'blk: {
         let mut res: usize = 0;
         for param in params {
@@ -658,7 +636,7 @@ where
 }
 
 /// Shared by `print_param` and `usage_full`: emit the ` <val>` / ` <val>?` /
-/// ` <val>...` suffix for a param's `takes_value`. Mirrors clap.zig:459/672.
+/// ` <val>...` suffix for a param's `takes_value`.
 #[cold]
 #[inline(never)]
 fn write_takes_value_suffix<W, Id, E, C>(
@@ -706,8 +684,6 @@ where
 pub fn help_ex<W, Id>(
     stream: &mut W,
     params: &[Param<Id>],
-    // TODO(port): LIFETIMES.tsv classifies these as `fn(Param<Id>) -> &'static str`;
-    // using `&'static [u8]` to stay consistent with the bytes-not-str rule.
     help_text: fn(&Param<Id>) -> &'static [u8],
     value_text: fn(&Param<Id>) -> &'static [u8],
 ) -> Result<(), bun_core::Error>
@@ -743,7 +719,6 @@ where
 #[cold]
 #[inline(never)]
 pub fn simple_print_param(param: &Param<Help>) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     bun_core::pretty!("\n");
     if let Some(s) = param.names.short {
         if param.takes_value != Values::None && param.names.long.is_none() {
@@ -818,10 +793,7 @@ pub fn simple_help(params: &[Param<Help>]) {
         let spaces_after = vec![b' '; num_spaces_after];
 
         simple_print_param(param).expect("unreachable");
-        // Zig's `Output.pretty("  {s}  {s}", …)` (clap.zig:567) only runs prettyFmt
-        // over the comptime template, so `<tag>` markers inside `desc_text` leak
-        // through verbatim there. That is observably wrong (`bun run --help` prints
-        // literal `<d>$cwd<r>`); `pretty_help_desc` resolves the `<tag>` markup
+        // `pretty_help_desc` resolves the `<tag>` markup
         // (ANSI on a colour TTY, stripped otherwise) so `--help` output is
         // tag-clean regardless of which helper a command uses.
         let desc = pretty_help_desc(param);
@@ -836,22 +808,18 @@ pub fn simple_help(params: &[Param<Help>]) {
 #[cold]
 #[inline(never)]
 pub fn simple_help_bun_top_level(params: &[Param<Help>]) {
-    // TODO(port): Zig evaluates `computed_max_spacing` at `comptime` and emits
-    // `@compileError` on overflow, plus uses `inline for` + comptime string
-    // concat (`space_buf[..n] ++ desc_text`). None of that is const-evaluable
-    // in Rust over a slice param. Runtime equivalent below; could macro-gen.
+    // `computed_max_spacing` is not const-evaluable over a
+    // slice param, so the overflow check is a runtime debug_assert below.
     const MAX_SPACING: usize = 30;
     const SPACE_BUF: &[u8; MAX_SPACING] = b"                              ";
 
     let computed_max_spacing: usize = compute_max_help_spacing(params);
 
-    // Zig: @compileError; here a debug-time assert.
     debug_assert!(
         computed_max_spacing <= MAX_SPACING,
         "a parameter is too long to be nicely printed in `bun --help`"
     );
 
-    // PERF(port): was `inline for` + comptime string concat — profile if hot.
     for param in params {
         if !(param.names.short.is_none() && param.names.long.is_none()) {
             let desc_text = get_help_simple(param);
@@ -861,9 +829,7 @@ pub fn simple_help_bun_top_level(params: &[Param<Help>]) {
                 let total_len = param_display_width(param);
                 let num_spaces_after = MAX_SPACING - total_len;
 
-                // Zig: Output.pretty(space_buf[0..n] ++ desc_text, .{}) — the concat
-                // is the *format string*, so `<tag>` markers inside `desc_text` are
-                // rewritten at `comptime`. Mirror that via `pretty_help_desc`, which
+                // `pretty_help_desc`
                 // resolves the markup (ANSI on a colour TTY, stripped otherwise).
                 let desc = pretty_help_desc(param);
                 bun_core::pretty!(
@@ -901,7 +867,6 @@ where
     Id: Copy,
     E: Into<bun_core::Error>,
 {
-    // TODO(port): narrow error set
     let mut cos = CountingWriter::wrap(stream);
     for param in params {
         let Some(name) = param.names.short else {
@@ -912,8 +877,7 @@ where
         }
 
         if cos.count == 0 {
-            // PORT NOTE: Zig wrote "[-" to `stream` (not `cs`), bypassing the
-            // counter. Preserving that quirk by writing to the inner writer.
+            // "[-" goes to the inner writer (not `cs`), bypassing the counter.
             write!(cos.inner(), "[-")?;
         }
         cos.write_char(name as char)?;
@@ -934,8 +898,7 @@ where
             b"--"
         };
 
-        // Zig had a workaround `@as([*]const u8, @ptrCast(s))[0..1]` for taking
-        // a 1-byte slice of the short char. Rust expresses this as a 1-elem array.
+        // A 1-elem array gives a 1-byte slice of the short char.
         let short_buf;
         let name: &[u8] = if let Some(s) = param.names.short {
             short_buf = [s];
@@ -1190,7 +1153,7 @@ mod tests {
         assert_eq!(MACRO_PARAMS[1].takes_value, Values::OneOptional);
         assert_eq!(MACRO_PARAMS[1].id.value, b"STR");
 
-        // Aliases — proc-macro restores the comptime alias array the runtime parser drops.
+        // Aliases — the proc-macro restores the static alias array the runtime parser drops.
         assert_eq!(
             MACRO_PARAMS[2].names.long,
             Some(b"test-name-pattern" as &[u8])
@@ -1231,5 +1194,3 @@ mod tests {
         assert_eq!(CT_TABLE.converted[CT_CONFIG_IDX].takes_value, Values::One);
     }
 }
-
-// ported from: src/clap/clap.zig
diff --git a/src/clap/streaming.rs b/src/clap/streaming.rs
index 320858f1c5e..28c69bd3b68 100644
--- a/src/clap/streaming.rs
+++ b/src/clap/streaming.rs
@@ -65,8 +65,8 @@ pub struct StreamingClap<'p, 'a, Id, ArgIterator> {
     pub diagnostic: Option<&'p mut clap::Diagnostic>,
 }
 
-// PORT NOTE: ArgIterator was a comptime duck-typed param in Zig; expressed here as
-// the `args::ArgIter<'a>` trait so `next()`/`remain()` resolve.
+// ArgIterator is the
+// `args::ArgIter<'a>` trait so `next()`/`remain()` resolve.
 impl<'p, 'a, Id, ArgIterator> StreamingClap<'p, 'a, Id, ArgIterator>
 where
     ArgIterator: ArgIter<'a>,
@@ -110,7 +110,7 @@ where
                     None
                 };
 
-                // PORT NOTE: reshaped for borrowck — copy slice ref so &mut self is free inside loop.
+                // Copy the slice ref so `&mut self` is free inside the loop.
                 let params = self.params;
                 for param in params {
                     if !param.names.matches_long(name) {
@@ -214,7 +214,7 @@ where
         let index = state.index;
         let next_index = index + 1;
 
-        // PORT NOTE: reshaped for borrowck — copy slice ref so &mut self is free inside loop.
+        // Copy the slice ref so `&mut self` is free inside the loop.
         let params = self.params;
         for param in params {
             let Some(short) = param.names.short else {
@@ -224,9 +224,10 @@ where
                 continue;
             }
 
-            // Before we return, we have to set the new state of the clap
-            // PORT NOTE: Zig `defer` hoisted — every path below returns, and nothing
-            // between here and those returns reads `self.state`.
+            // Before we return, we have to set the new state of the clap.
+            // (Hoisting this above the returns is fine — every path
+            // below returns, and nothing between here and those returns reads
+            // `self.state`.)
             if arg.len() <= next_index || param.takes_value != clap::Values::None {
                 self.state = State::Normal;
             } else {
@@ -331,8 +332,8 @@ where
 
     fn err(&mut self, arg: &[u8], short: Option<u8>, long: Option<&[u8]>, e: ArgError) -> ArgError {
         if let Some(d) = self.diagnostic.as_deref_mut() {
-            // PORT NOTE: Zig assigned borrowed `arg`/`name` slices; Rust `Diagnostic`
-            // owns its bytes (error path only) — see lib.rs.
+            // `Diagnostic` owns
+            // its bytes (error path only) — see lib.rs.
             d.arg = arg.to_vec();
             d.short = short;
             d.long = long.map(|l| l.to_vec());
@@ -398,10 +399,33 @@ mod tests {
                 Ok(Some(_)) => {}
                 Ok(None) => break,
                 Err(_err) => {
-                    // TODO(port): io.fixedBufferStream + diag.report — `Diagnostic::report`
-                    // currently routes through `bun_core::Output` (stderr) and ignores its
-                    // writer arg, so we cannot capture output to compare against `expected`.
-                    let _ = expected;
+                    // Bun's `Diagnostic::report` deliberately ignores its writer arg
+                    // and routes through `bun_core::Output` (stderr),
+                    // so the rendered message can't be captured here.
+                    // Instead, rebuild the flag name the
+                    // same way `report` does from the diagnostic fields and assert
+                    // the expected message names it in quotes.
+                    let mut name_buf = [0u8; 1024];
+                    let captured: &[u8] = if let Some(s) = diag.short {
+                        name_buf[0] = b'-';
+                        name_buf[1] = s;
+                        &name_buf[..2]
+                    } else if let Some(l) = diag.long.as_deref() {
+                        name_buf[0] = b'-';
+                        name_buf[1] = b'-';
+                        name_buf[2..2 + l.len()].copy_from_slice(l);
+                        &name_buf[..2 + l.len()]
+                    } else {
+                        &diag.arg
+                    };
+                    assert!(
+                        expected.windows(captured.len() + 2).any(|w| w[0] == b'\''
+                            && w[w.len() - 1] == b'\''
+                            && &w[1..w.len() - 1] == captured),
+                        "expected message {:?} does not name captured arg {:?}",
+                        bstr::BStr::new(expected),
+                        bstr::BStr::new(captured),
+                    );
                     return;
                 }
             }
@@ -790,5 +814,3 @@ mod tests {
         );
     }
 }
-
-// ported from: src/clap/streaming.zig
diff --git a/src/clap_macros/lib.rs b/src/clap_macros/lib.rs
index a63db6707fe..0969a83031f 100644
--- a/src/clap_macros/lib.rs
+++ b/src/clap_macros/lib.rs
@@ -1,8 +1,8 @@
 //! Proc-macro backend for `bun_clap::parse_param!` / `bun_clap::parse_params!`.
 //!
-//! This is a 1:1 port of the comptime `parseParam` from `src/clap/clap.zig`, lifted into
+//! Param-spec parsing implemented as
 //! a proc-macro so the resulting `Param<Help>` values are fully const and usable in
-//! `static` tables (the Zig original ran at comptime via `@setEvalBranchQuota`).
+//! `static` tables.
 //!
 //! Do **not** call these proc-macros directly — they take a leading crate-path argument
 //! (`$crate`) injected by the `macro_rules!` wrappers in `bun_clap`. Use
@@ -76,10 +76,10 @@ impl ParseParamError {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Parser — direct port of clap.zig `parseParam` / `parseParamRest` / `parseLongNames`
+// Parser — `parse_param` / `parse_param_rest` / `parse_long_names`
 // ─────────────────────────────────────────────────────────────────────────────
 
-/// `std.mem.tokenizeAny` with a `.rest()` that skips leading delimiters.
+/// Delimiter tokenizer with a `.rest()` accessor that skips leading delimiters.
 struct TokenizeAny<'a> {
     buf: &'a [u8],
     index: usize,
@@ -272,8 +272,6 @@ fn byte_str_b(s: &[u8]) -> LitByteStr {
 /// in rodata. The ANSI form is *not* baked in — it is rare (only `bun --help` on
 /// a colour TTY) and would otherwise roughly triple the help-string rodata, so
 /// `bun_clap::pretty_help_desc` derives it from `Help::msg` on demand instead.
-/// (Zig did the equivalent rewrite at `comptime` via `Output.prettyFmt` inside
-/// `clap.simpleHelpBunTopLevel`.)
 fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
     use bun_output_tags::{RESET, color_for_bytes};
     let mut out: Vec<u8> = Vec::with_capacity(fmt.len() * 2);
@@ -322,9 +320,8 @@ fn pretty_rewrite(fmt: &[u8], is_enabled: bool) -> Vec<u8> {
                     is_reset = true;
                     ""
                 } else {
-                    // Unknown tag: Zig's comptime `prettyFmt` would `@compileError`
-                    // here, but `pretty_fmt_runtime` (the path this replaces) drops
-                    // it silently and so does Zig's actual `clap.simpleHelp`. Match
+                    // Unknown tag: `pretty_fmt_runtime` (the path this replaces)
+                    // drops it silently. Match
                     // the lenient runtime behaviour — a compile error would be
                     // stricter than what shipped, and param specs don't carry
                     // unknown tags anyway.
diff --git a/src/codegen/bindgen-lib-internal.ts b/src/codegen/bindgen-lib-internal.ts
index db0e6fb6abc..373bdbb27a5 100644
--- a/src/codegen/bindgen-lib-internal.ts
+++ b/src/codegen/bindgen-lib-internal.ts
@@ -23,7 +23,7 @@ export let structHashToSelf = new Map<string, Struct>();
 export const str = (v: any) => JSON.stringify(v);
 /** Capitalize */
 export const cap = (s: string) => s[0].toUpperCase() + s.slice(1);
-/** Escape a Zig Identifier */
+/** Escape an identifier */
 export const zid = (s: string) => (s.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/) ? s : "@" + str(s));
 /** Snake Case */
 export const snake = (s: string) =>
@@ -39,7 +39,7 @@ export const camel = (s: string) =>
 /** Pascal Case */
 export const pascal = (s: string) => cap(camel(s));
 
-// Return symbol names of extern values (must be equivalent between C++ and Zig)
+// Return symbol names of extern values (must be equivalent on both sides of the FFI boundary)
 
 /** The JS Host function, aka fn (*JSC.JSGlobalObject, *JSC.CallFrame) JSValue.MaybeException */
 export const extJsFunction = (namespaceVar: string, fnLabel: string) =>
@@ -779,7 +779,7 @@ export type ArgStrategyChildItem =
  * In addition to moving a payload over, an additional bit of information
  * crosses the ABI boundary indicating if the function threw an exception.
  *
- * For simplicity, the possibility of any Zig binding returning an error/calling
+ * For simplicity, the possibility of any native binding returning an error/calling
  * `throw` is assumed and there isnt a way to disable the exception check.
  */
 export type ReturnStrategy =
diff --git a/src/codegen/bindgen-lib.ts b/src/codegen/bindgen-lib.ts
index 37a7d6cddb3..40edfd3d52f 100644
--- a/src/codegen/bindgen-lib.ts
+++ b/src/codegen/bindgen-lib.ts
@@ -212,7 +212,6 @@ export namespace t {
    * ```
    *
    * ```zig
-   * // foo.zig
    * pub fn foo(bar: []const u8) void {
    *   // ...
    * }
@@ -288,7 +287,7 @@ export namespace t {
   }
 
   /**
-   * Equivalent to `stringEnum`, but using an enum sourced from the given Zig
+   * Equivalent to `stringEnum`, but using an enum sourced from the given
    * file. Use this to get an enum type that can have functions added.
    */
   export function zigEnum(file: string, impl: string): Type<string, "zigEnum"> {
@@ -322,7 +321,6 @@ interface FuncOptionsWithVariant extends FuncMetadata {
    * ```
    *
    * ```zig
-   * // foo.zig
    * pub fn foo1(a: i32) i32 {
    *    return a;
    * }
diff --git a/src/codegen/bindgen.ts b/src/codegen/bindgen.ts
index e98e23ff8ea..2584f2a3808 100644
--- a/src/codegen/bindgen.ts
+++ b/src/codegen/bindgen.ts
@@ -1,7 +1,7 @@
 // The binding generator to rule them all.
-// Converts binding definition files (.bind.ts) into C++ and Zig code.
+// Converts binding definition files (.bind.ts) into C++ and native binding code.
 //
-// Generated bindings are available in `bun.generated.<basename>.*` in Zig,
+// Generated bindings are available as `bun.generated.<basename>.*` on the native side,
 // or `Generated::<basename>::*` in C++ from including `Generated<basename>.h`.
 import assert from "node:assert";
 import fs from "node:fs";
@@ -60,8 +60,8 @@ function resolveVariantStrategies(vari: Variant, name: string) {
     const abiType = !isNullable && arg.type.canDirectlyMapToCAbi();
     if (abiType) {
       arg.loweringStrategy = {
-        // This does not work in release builds, possibly due to a Zig 0.13 bug
-        // regarding by-value extern structs in C functions.
+        // Passing by-value extern structs in C functions did not work
+        // reliably in release builds.
         // type: cAbiTypeInfo(abiType)[0] > 8 ? "c-abi-pointer" : "c-abi-value",
         // Always pass an argument by-pointer for now.
         type: abiType === "*anyopaque" || abiType === "*JSGlobalObject" ? "c-abi-value" : "c-abi-pointer",
@@ -1376,7 +1376,7 @@ for (const [filename, { functions, typedefs }] of files) {
     cpp.line(`}`);
     cpp.line();
 
-    // Generated Zig dispatch functions
+    // Generated dispatch functions
     variNum = 1;
     for (const vari of fn.variants) {
       const dispatchName = extDispatchVariant(namespaceVar, fn.name, variNum);
diff --git a/src/codegen/bindgenv2/internal/base.ts b/src/codegen/bindgenv2/internal/base.ts
index 4162f711ae1..93732f3fbd5 100644
--- a/src/codegen/bindgenv2/internal/base.ts
+++ b/src/codegen/bindgenv2/internal/base.ts
@@ -27,7 +27,7 @@ export abstract class Type {
     return this.bindgenType + ".ZigType";
   }
 
-  /** This must be overridden if bindgen.zig defines a custom `OptionalZigType`. */
+  /** This must be overridden if a custom `OptionalZigType` is defined. */
   optionalZigType(style?: CodeStyle): string {
     return `?${this.zigType(style)}`;
   }
diff --git a/src/codegen/bindgenv2/internal/dictionary.ts b/src/codegen/bindgenv2/internal/dictionary.ts
index e2a7030c018..47598e9e50c 100644
--- a/src/codegen/bindgenv2/internal/dictionary.ts
+++ b/src/codegen/bindgenv2/internal/dictionary.ts
@@ -19,7 +19,7 @@ export interface DictionaryMember {
   type: Type;
   /** Optional default value to use when this member is missing or undefined. */
   default?: any;
-  /** The name used in generated Zig/C++ code. Defaults to the public JS name. */
+  /** The name used in generated code. Defaults to the public JS name. */
   internalName?: string;
   /** Alternative JavaScript names for this member. */
   altNames?: string[];
@@ -39,7 +39,7 @@ interface DictionaryOptions {
   name: string;
   /** Used in error messages. Defaults to `name`. */
   userFacingName?: string;
-  /** Whether to generate a Zig `fromJS` function. */
+  /** Whether to generate a `fromJS` conversion function. */
   generateConversionFunction?: boolean;
 }
 
diff --git a/src/codegen/bindgenv2/internal/union.ts b/src/codegen/bindgenv2/internal/union.ts
index e452f8b1f08..737f8c4f6f5 100644
--- a/src/codegen/bindgenv2/internal/union.ts
+++ b/src/codegen/bindgenv2/internal/union.ts
@@ -31,7 +31,7 @@ export function union(name: string, alternatives: NamedAlternatives): NamedUnion
 
 /**
  * The order of types in this union is significant. Each type is tried in order, and the first one
- * that successfully converts determines the active field in the corresponding Zig tagged union.
+ * that successfully converts determines the active field in the corresponding native tagged union.
  *
  * This means that it is an error to specify `RawAny` or `StrongAny` as anything other than the
  * last alternative, as conversion to any subsequent types would never be attempted.
diff --git a/src/codegen/class-definitions.ts b/src/codegen/class-definitions.ts
index 8049e12e5ae..86827d34c65 100644
--- a/src/codegen/class-definitions.ts
+++ b/src/codegen/class-definitions.ts
@@ -140,7 +140,7 @@ export class ClassDefinition {
   /**
    * Class constructor needs `this` value.
    *
-   * Makes the code generator call the Zig constructor function **after** the
+   * Makes the code generator call the native constructor function **after** the
    * JSValue is instantiated. Only use this if you must, as it probably isn't
    * good for GC since it means if the constructor throws the GC will have to
    * clean up the object that never reached JS.
diff --git a/src/codegen/cppbind.ts b/src/codegen/cppbind.ts
index 224277697ba..f5b3f479d78 100644
--- a/src/codegen/cppbind.ts
+++ b/src/codegen/cppbind.ts
@@ -1,8 +1,8 @@
 /*
 
-cppbind - C++ to Zig binding generator for Bun
+cppbind - C++ binding generator for Bun
 
-This tool automatically generates Zig bindings for C++ functions marked with [[ZIG_EXPORT(...)]] attributes.
+This tool automatically generates Rust bindings for C++ functions marked with [[ZIG_EXPORT(...)]] attributes.
 It runs automatically when C++ files change during the build process.
 
 To run manually:
@@ -18,7 +18,7 @@ To run manually:
        printf("hello world\n");
    }
    ```
-   Zig usage: `bun.cpp.hello_world();`
+   Rust usage: `bun_jsc::cpp::hello_world();`
 
 2. **zero_is_throw** - Function returns JSValue, where .zero indicates an exception:
    ```cpp
@@ -29,7 +29,7 @@ To run manually:
        return result;
    }
    ```
-   Zig usage: `try bun.cpp.create_object(globalThis);`
+   Rust usage: `bun_jsc::cpp::create_object(global_this)?;`
 
 3. **check_slow** - Function that may throw, performs runtime exception checking:
    ```cpp
@@ -39,7 +39,7 @@ To run manually:
        RETURN_IF_EXCEPTION(scope, );
    }
    ```
-   Zig usage: `try bun.cpp.process_data(globalThis);`
+   Rust usage: `bun_jsc::cpp::process_data(global_this)?;`
 
 ### Parameters
 
@@ -401,7 +401,7 @@ type ExportTag = "check_slow" | "zero_is_throw" | "false_is_throw" | "null_is_th
 
 // ─────────────────────────── Rust output (cpp.rs) ───────────────────────────
 //
-// Mirror of `generateZigFn` for the Rust port: each `[[ZIG_EXPORT(mode)]]` C++
+// Each `[[ZIG_EXPORT(mode)]]` C++
 // function gets a typed `pub fn` in `bun_jsc::cpp` that wraps the raw extern in
 // the appropriate exception scope and converts to `JsResult`. The wrapper opens
 // the scope *before* calling into C++ so the callee's `DECLARE_THROW_SCOPE` dtor
@@ -421,7 +421,7 @@ const rustSharedTypes: Record<string, string> = {
   // Primitives
   "bool": "bool",
   // `char` signedness is platform-dependent (signed on x86_64-linux/windows,
-  // unsigned on aarch64); match Zig's `c_char` so a future by-value return
+  // unsigned on aarch64); use `core::ffi::c_char` so a future by-value return
   // doesn't silently sign-flip.
   "char": "core::ffi::c_char",
   "unsigned char": "u8",
@@ -560,7 +560,7 @@ function generateRustType(type: CppType, parent: CppType | null): string {
     // Unknown opaque — only valid behind a pointer (the per-type shim casts the
     // pointee). Behind a pointer we degrade to c_void; in by-value position that
     // would emit `-> core::ffi::c_void` (a ZST in Rust → silent ABI corruption),
-    // so match the Zig generator and fail loudly at the C++ source location.
+    // so fail loudly at the C++ source location.
     if (parent?.type === "pointer") return "core::ffi::c_void";
     throwError(
       type.position,
@@ -661,7 +661,7 @@ function generateRustFn(fn: CppFn, rustRaw: string[], rustWrap: string[]): void
 
   const globalArg = fn.parameters.find(p => isGlobalObjectPtr(p.type));
   if (!globalArg) {
-    // Same constraint as the Zig generator; emit a stub so the module still
+    // Emit a stub so the module still
     // compiles and the symbol name is greppable.
     rustWrap.push(`// skipped ${fn.name}: ${fn.tag} requires a JSGlobalObject* parameter`);
     return;
@@ -672,8 +672,8 @@ function generateRustFn(fn: CppFn, rustRaw: string[], rustWrap: string[]): void
     // Inline the `top_scope!` body (rather than the `call_check_slow` *function* form,
     // which routes `SourceLocation::from_caller()` → thread-local intern probe per call
     // in debug builds). This is the highest-volume mode — keep it as cheap as the
-    // zero/false/null arms below. `src!()` resolves to the wrapper file/line, matching
-    // Zig's `cpp.zig` (`@src()` inside the wrapper); `#[track_caller]` would be a no-op
+    // zero/false/null arms below. `src!()` resolves to the wrapper file/line;
+    // `#[track_caller]` would be a no-op
     // against a syntactic `file!()`, so don't emit it.
     rustWrap.push(
       `#[inline]`,
@@ -709,7 +709,7 @@ function generateRustFn(fn: CppFn, rustRaw: string[], rustWrap: string[]): void
   } else assertNever(fn.tag);
 
   // `validation_scope!` expands `src!()` syntactically (resolves to this generated
-  // file/line — parity with Zig's `@src()` inside cpp.zig wrappers). `#[track_caller]`
+  // file/line). `#[track_caller]`
   // can't influence a compile-time `file!()`, so don't emit it.
   rustWrap.push(
     `#[inline]`,
diff --git a/src/codegen/generate-classes.ts b/src/codegen/generate-classes.ts
index 09ee612b6ea..b659bb334bf 100644
--- a/src/codegen/generate-classes.ts
+++ b/src/codegen/generate-classes.ts
@@ -2740,7 +2740,7 @@ const rustModuleResolver = (() => {
       // `pub use bun_jsc::{BuildMessage, ResolveMessage};` so route there.
       return `crate::api::${name}`;
     },
-    /** Resolve an absolute `.rs` (or `.zig`) file path to its `crate::…` module path. */
+    /** Resolve an absolute `.rs` file path to its `crate::…` module path. */
     resolveFile(absRs: string): string | null {
       return fileToMod.get(path.resolve(absRs)) ?? null;
     },
@@ -2844,8 +2844,7 @@ function generateRust(
   // ── exported #[no_mangle] thunks ─────────────────────────────────────────
   // Direct dispatch: each thunk calls an *inherent* method on the user's real
   // Rust struct (re-exported as `${typeName}` below). No trait, no opaque
-  // placeholder, no `unimplemented!()` — a missing method is a compile error,
-  // mirroring the Zig path's `@import("…").${T}.${fn}` behaviour.
+  // placeholder, no `unimplemented!()` — a missing method is a compile error.
   const thunks: string[] = [];
   const symbols: string[] = [];
   function thunk(sym: string, sig: string, body: string) {
@@ -3071,9 +3070,9 @@ function generateRust(
   }
 
   // ── C++→Rust extern imports + safe wrappers ──────────────────────────────
-  // Emitted as free functions in a per-class `js_${T}` sub-module (mirrors
-  // Zig's `pub const js = jsc.Codegen.JS${T};`) so they don't collide with
-  // inherent `from_js`/`to_js` already defined on the real struct.
+  // Emitted as free functions in a per-class `js_${T}` sub-module so they
+  // don't collide with inherent `from_js`/`to_js` already defined on the
+  // real struct.
   const cachedExterns = gc_fields
     .map(
       ([name]) =>
@@ -3153,9 +3152,8 @@ ${gcAccessors}
 // ════════════════════════════════════════════════════════════════════════════
 
 /// Native backing type for \`JS${typeName}.m_ctx\`. Re-export of the real
-/// hand-ported struct so the thunks below call its inherent methods directly
-/// (mirrors Zig's \`@import("…").${typeName}.<fn>\`). A missing method is a
-/// compile error — fix it in \`${rustPath}\`, not here.
+/// struct so the thunks below call its inherent methods directly. A missing
+/// method is a compile error — fix it in \`${rustPath}\`, not here.
 pub use ${rustPath} as ${typeName};
 
 ${thunks.join("\n\n")}
@@ -3546,8 +3544,8 @@ function writeCppSerializers() {
 
 // ── Rust output: per-class thunks for `lang === "rust"` (default). ─────────
 // Zig output is still emitted for every class so the C++ side's `extern`
-// declarations stay satisfied during incremental migration; the Zig thunks for
-// rust-lang classes simply go unreferenced once the Rust crate links.
+// declarations stay satisfied; the Zig thunks for rust-lang classes simply go
+// unreferenced once the Rust crate links.
 {
   const rustClasses = classes.filter(a => (a.lang ?? "rust") === "rust");
   let totalSyms = 0;
@@ -3753,8 +3751,8 @@ if (!process.env.ONLY_ZIG) {
 }
 
 /**
- * Generates a basic TypeScript type signature string and corresponding Zig source comment
- * for a given property definition.
+ * Generates a basic TypeScript type signature string for a given property
+ * definition.
  * Returns null if the property should not be included in the types (e.g., private).
  */
 function getPropertySignatureWithComment(
diff --git a/src/codegen/generate-host-exports.ts b/src/codegen/generate-host-exports.ts
index 2529465c25e..05cae8b8c8d 100644
--- a/src/codegen/generate-host-exports.ts
+++ b/src/codegen/generate-host-exports.ts
@@ -379,7 +379,7 @@ function emitThunk(e: Export): string {
   const loc = `${path.relative(repoRoot, e.file)}:${e.line}`;
   // `JsResult<JSValue>` impls need `to_js_host_call` (exception-scope assert +
   // panic barrier + Err→empty mapping). Plain-`JSValue` impls are bare
-  // `callconv(jsc.conv)` bodies in the .zig spec — wrap them and you trip
+  // host-call-ABI bodies (no exception-scope wrapper) — wrap them and you trip
   // `assert_exception_presence_matches(false)` whenever the body legitimately
   // leaves an exception pending while returning non-empty (e.g.
   // `Bun__drainMicrotasksFromJS`). Match `#[bun_jsc::host_call]`: deref + call,
diff --git a/src/codegen/generate-js2native.ts b/src/codegen/generate-js2native.ts
index 0a640d1b644..86bfed72577 100644
--- a/src/codegen/generate-js2native.ts
+++ b/src/codegen/generate-js2native.ts
@@ -254,7 +254,7 @@ export function getJS2NativeZig(gs2NativeZigPath: string) {
 // the C++ side declares in GeneratedJS2Native.h. The C++ output is invariant;
 // only the implementer of the symbol changes.
 //
-// Two ABI shapes (mirroring the Zig output exactly):
+// Two ABI shapes:
 //   • nativeCalls (type "zig")  → `${sym}_workaround(global) -> JSValue`
 //   • wrapperCalls (type "zig") → `${sym}(global, callframe) -> JSValue`
 //
diff --git a/src/codegen/generate-jssink.ts b/src/codegen/generate-jssink.ts
index fc9e87f4745..c047c862e43 100644
--- a/src/codegen/generate-jssink.ts
+++ b/src/codegen/generate-jssink.ts
@@ -1033,16 +1033,14 @@ extern "C" void ${name}__onClose(JSC::EncodedJSValue controllerValue, JSC::Encod
 // `BUN_DECLARE_HOST_FUNCTION(${name}__{construct,write,end,flush,start})` plus
 // the two non-host-fn externs `${name}__getInternalFd` / `${name}__memoryCost`.
 // Each thunk calls an inherent method on the real sink struct in
-// `crate::webcore` (mirroring Zig's `@import("…").${name}.<fn>`); a missing
-// method is a compile error.
+// `crate::webcore`; a missing method is a compile error.
 //
 // Calling convention: `BUN_DECLARE_HOST_FUNCTION` and `endWithSink` use
 // `SYSV_ABI` (= `extern "sysv64"` on win-x64, `"C"` elsewhere) — wrapped in
 // `bun_jsc::jsc_host_abi!`. The remaining `ZIG_DECL` / plain `extern "C"`
 // symbols (finalize/close/updateRef/getInternalFd/memoryCost) stay `extern "C"`.
 function rustSink() {
-  // All sink structs live (or will live) under `crate::webcore`; the Zig
-  // originals are `src/runtime/webcore/streams.zig::${name}`.
+  // All sink structs live (or will live) under `crate::webcore`.
   const sinkPaths: Record<string, string> = {
     ArrayBufferSink: "crate::webcore::array_buffer_sink::ArrayBufferSink",
     FileSink: "crate::webcore::file_sink::FileSink",
diff --git a/src/collections/StaticHashMap.rs b/src/collections/StaticHashMap.rs
index c37c17d0553..4769089f1c2 100644
--- a/src/collections/StaticHashMap.rs
+++ b/src/collections/StaticHashMap.rs
@@ -7,7 +7,7 @@ use core::marker::PhantomData;
 use bun_alloc::AllocError;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Context trait — models Zig's `Context: type` with `.hash(k)` / `.eql(a, b)`
+// Context trait — `.hash(k)` / `.eql(a, b)`
 // ──────────────────────────────────────────────────────────────────────────
 
 // Canonical definitions live in `crate::zig_hash_map`; re-exported here so the
@@ -16,7 +16,7 @@ use bun_alloc::AllocError;
 pub use crate::zig_hash_map::{AutoHashContext as AutoContext, HashContext};
 
 // ──────────────────────────────────────────────────────────────────────────
-// Type aliases (Zig: AutoHashMap)
+// Type aliases
 // ──────────────────────────────────────────────────────────────────────────
 
 pub type AutoHashMap<K, V, const MAX_LOAD_PERCENTAGE: u64> =
@@ -47,12 +47,11 @@ impl<K, V> Entry<K, V> {
         K: Copy + Default,
         V: Copy + Default,
     {
-        // PORT NOTE: Zig used `std.mem.zeroes(K)` / `undefined` — key/value of
-        // an empty entry (hash == EMPTY_HASH) are never read. Rust cannot use
-        // `mem::zeroed()` here: K may be `&[u8]` (or any `Copy` type with a
-        // niche), for which all-zero bytes violate the validity invariant
-        // regardless of whether the value is later read. Use `Default` for the
-        // unread placeholder instead.
+        // Key/value of an empty entry (hash == EMPTY_HASH) are never read.
+        // `mem::zeroed()` cannot be used here: K may be `&[u8]` (or any `Copy`
+        // type with a niche), for which all-zero bytes violate the validity
+        // invariant regardless of whether the value is later read. Use
+        // `Default` for the unread placeholder instead.
         Self {
             hash: EMPTY_HASH,
             key: K::default(),
@@ -74,23 +73,20 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Display for Entry<K, V> {
 pub use crate::hash_map::GetOrPutResult;
 
 // ──────────────────────────────────────────────────────────────────────────
-// comptime helpers (Zig top-of-fn const expressions)
+// const helpers
 // ──────────────────────────────────────────────────────────────────────────
 
 #[inline]
 const fn compute_shift(capacity: u64) -> u8 {
-    // Zig: 63 - math.log2_int(u64, capacity) + 1
     (63 - capacity.ilog2() + 1) as u8
 }
 
 #[inline]
 const fn compute_overflow(capacity: u64, shift: u8) -> u64 {
-    // Zig: capacity / 10 + (63 - @as(u64, shift) + 1) << 1
-    // Zig precedence: `+` binds tighter than `<<`, so this is (a + b) << 1.
     (capacity / 10 + (63 - shift as u64 + 1)) << 1
 }
 
-/// Checked u64→usize narrowing for table indices (Zig indexes by u64 directly).
+/// Checked u64→usize narrowing for table indices.
 #[inline]
 fn to_idx(x: u64) -> usize {
     usize::try_from(x).expect("int cast")
@@ -108,8 +104,8 @@ pub const fn static_slots(capacity: usize) -> usize {
 // StaticHashMap
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: the inline `[Entry; CAPACITY + overflow]` array length depends on
-// a const fn of `CAPACITY`, which requires nightly `feature(generic_const_exprs)`.
+// The inline `[Entry; CAPACITY + overflow]` array length depends on a const fn
+// of `CAPACITY`, which requires nightly `feature(generic_const_exprs)`.
 // Stable workaround (same as ArrayBitSet): callers pass `SLOTS = static_slots(CAPACITY)`
 // as a second const param; a const-assert in `Default::default()` checks they match.
 pub struct StaticHashMap<
@@ -121,7 +117,7 @@ pub struct StaticHashMap<
 > {
     pub entries: [Entry<K, V>; SLOTS],
     pub len: usize,
-    /// Zig `u6`; stored as u8.
+    /// Hash shift; always < 64, stored as u8.
     pub shift: u8,
     // put_probe_count: usize,
     // get_probe_count: usize,
@@ -141,8 +137,6 @@ impl<K: Copy + Default, V: Copy + Default, Ctx, const CAPACITY: usize, const SLO
             );
         };
         Self {
-            // TODO(port): `[Entry::empty(); N]` needs `Entry<K,V>: Copy` const-init;
-            // may need `MaybeUninit` + loop if K/V aren't const-zeroable.
             entries: [Entry::empty(); SLOTS],
             len: 0,
             shift: compute_shift(CAPACITY as u64),
@@ -179,7 +173,7 @@ impl<K: 'static, V: 'static, Ctx, const CAPACITY: usize, const SLOTS: usize> Has
 pub struct HashMap<K, V, Ctx, const MAX_LOAD_PERCENTAGE: u64> {
     pub entries: Box<[Entry<K, V>]>,
     pub len: usize,
-    /// Zig `u6`; stored as u8.
+    /// Hash shift; always < 64, stored as u8.
     pub shift: u8,
     // put_probe_count: usize,
     // get_probe_count: usize,
@@ -222,7 +216,6 @@ impl<
         let overflow = compute_overflow(capacity, shift);
 
         let n = usize::try_from(capacity + overflow).expect("int cast");
-        // Zig: gpa.alloc + @memset(.{})
         let entries = vec![Entry::<K, V>::empty(); n].into_boxed_slice();
 
         Ok(Self {
@@ -257,9 +250,6 @@ impl<
 
         let mut map = Self::init_capacity(capacity * 2)?;
 
-        // PORT NOTE: reshaped for borrowck — Zig walks raw `[*]Entry` pointers
-        // (`src`, `dst`, `end`); here we iterate by index over the old slice and
-        // index into the new boxed slice.
         let mut dst: usize = 0;
         let mut src: usize = 0;
         while src != end {
@@ -270,7 +260,6 @@ impl<
             } else {
                 0
             };
-            // Zig: dst = if (@intFromPtr(p) >= @intFromPtr(dst)) p else dst;
             if i >= dst {
                 dst = i;
             }
@@ -280,7 +269,7 @@ impl<
             dst += 1;
         }
 
-        // Zig: self.deinit(gpa); — old Box drops on assignment below.
+        // Old Box drops on assignment below.
         self.entries = map.entries;
         self.shift = map.shift;
         Ok(())
@@ -314,8 +303,8 @@ impl<
 // HashMapMixin — shared method bodies for StaticHashMap & HashMap
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Mirrors Zig's `fn HashMapMixin(Self, K, V, Context) type`. Implementors
-/// supply the backing storage; default methods provide the Robin-Hood logic.
+/// Implementors supply the backing storage; default methods provide the
+/// Robin-Hood logic.
 pub trait HashMapMixin<K: 'static, V: 'static, Ctx> {
     fn storage(&self) -> &[Entry<K, V>];
     fn storage_mut(&mut self) -> &mut [Entry<K, V>];
@@ -331,11 +320,10 @@ pub trait HashMapMixin<K: 'static, V: 'static, Ctx> {
         *self.len_mut() = 0;
     }
 
-    /// Full backing slice (capacity + overflow). Matches Zig's `slice()`.
+    /// Full backing slice (capacity + overflow).
     fn slice(&mut self) -> &mut [Entry<K, V>] {
-        // Zig recomputes `capacity + overflow` from `shift`; with Box<[T]>/[T; N]
-        // the storage already carries its exact length, so just return it.
-        // PORT NOTE: assert kept for parity with Zig's implicit invariant.
+        // The storage carries its exact length; the assert checks it stays
+        // consistent with the `shift`-derived `capacity + overflow` size.
         let capacity = 1u64 << (63 - self.shift() + 1);
         let overflow = compute_overflow(capacity, self.shift());
         debug_assert_eq!(
@@ -381,9 +369,8 @@ pub trait HashMapMixin<K: 'static, V: 'static, Ctx> {
         V: Copy + Default,
         Ctx: HashContext<K>,
     {
-        // PORT NOTE: Zig left `value = undefined` (never read until the caller
-        // writes via `value_ptr`). Use `Default` for the placeholder — V may
-        // not be zero-valid.
+        // `value` is never read until the caller writes via `value_ptr`. Use
+        // `Default` for the placeholder — V may not be zero-valid.
         let mut it: Entry<K, V> = Entry {
             hash: Ctx::ctx_hash(&key),
             key,
@@ -396,8 +383,8 @@ pub trait HashMapMixin<K: 'static, V: 'static, Ctx> {
 
         let mut inserted_at: Option<usize> = None;
         loop {
-            // PORT NOTE: reshaped for borrowck — copy entry out, drop borrow,
-            // re-borrow mutably for write/return.
+            // Copy the entry out, drop the borrow, re-borrow mutably for
+            // write/return.
             let entry = self.storage()[i];
             if entry.hash >= it.hash {
                 if Ctx::ctx_eql(&entry.key, &key) {
@@ -554,15 +541,84 @@ pub trait HashMapMixin<K: 'static, V: 'static, Ctx> {
 mod tests {
     use super::*;
 
-    // TODO(port): Zig tests use `std.rand.DefaultPrng` (xoshiro256++). Need a
-    // matching PRNG for byte-identical key sequences, or accept any PRNG since
-    // these tests only check sortedness/round-trip, not specific keys.
+    /// xoshiro256++ with the state seeded by splitmix64. `AutoHashContext`
+    /// routes through `bun_wyhash::auto_hash` (mum-mix). The 100%-load probe
+    /// bound of the static test was validated for this hash by exact
+    /// simulation of all 128 seeds: max slot index touched (incl. delete's
+    /// `i + 1` backshift read) is 548 of 632, with no 64-bit hash collisions
+    /// among any seed's 512 keys.
+    struct Xoshiro256PlusPlus {
+        s: [u64; 4],
+    }
+
+    impl Xoshiro256PlusPlus {
+        fn init(seed: u64) -> Self {
+            fn splitmix64(state: &mut u64) -> u64 {
+                *state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
+                let mut z = *state;
+                z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+                z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+                z ^ (z >> 31)
+            }
+            let mut sm = seed;
+            let mut s = [0u64; 4];
+            for slot in s.iter_mut() {
+                *slot = splitmix64(&mut sm);
+            }
+            Self { s }
+        }
+
+        fn next(&mut self) -> u64 {
+            let s = &mut self.s;
+            let result = s[0].wrapping_add(s[3]).rotate_left(23).wrapping_add(s[0]);
+            let t = s[1] << 17;
+            s[2] ^= s[0];
+            s[3] ^= s[1];
+            s[1] ^= s[2];
+            s[0] ^= s[3];
+            s[2] ^= t;
+            s[3] = s[3].rotate_left(45);
+            result
+        }
+    }
 
     #[test]
     fn static_hash_map_put_get_delete_grow() {
-        // TODO(port): blocked on generic_const_exprs for StaticHashMap inline array.
-        // let mut map: StaticHashMap<usize, usize, AutoContext, 512, _> = Default::default();
-        // for seed in 0..128 { ... }
+        const CAP: usize = 512;
+        const SLOTS: usize = static_slots(CAP);
+        // Boxed: ~15 KB of entries is fine on the heap, gratuitous on the stack.
+        let mut map: Box<StaticHashMap<usize, usize, AutoContext, CAP, SLOTS>> =
+            Box::new(Default::default());
+
+        // Miri is ~100× slower; 2 seeds still cover the put/get/delete cycle.
+        const SEEDS: u64 = if cfg!(miri) { 2 } else { 128 };
+        for seed in 0..SEEDS {
+            let mut rng = Xoshiro256PlusPlus::init(seed);
+
+            let keys: Vec<usize> = (0..512).map(|_| rng.next() as usize).collect();
+
+            assert_eq!(map.shift, 55);
+
+            for (i, &key) in keys.iter().enumerate() {
+                map.put_assume_capacity(key, i);
+            }
+            assert_eq!(map.len, keys.len());
+
+            let mut it: u64 = 0;
+            for entry in map.slice().iter() {
+                if !entry.is_empty() {
+                    assert!(it <= entry.hash, "Unsorted");
+                    it = entry.hash;
+                }
+            }
+
+            for (i, &key) in keys.iter().enumerate() {
+                assert_eq!(map.get(key).unwrap(), i);
+            }
+            for (i, &key) in keys.iter().enumerate() {
+                assert_eq!(map.delete(key).unwrap(), i);
+            }
+        }
     }
 
     #[test]
@@ -570,18 +626,11 @@ mod tests {
         // Miri is ~100× slower; 2 seeds still exercises grow (`shift` assert below).
         const SEEDS: u64 = if cfg!(miri) { 2 } else { 128 };
         for seed in 0..SEEDS {
-            // TODO(port): replace with xoshiro256++ to match Zig DefaultPrng.
-            let mut state = seed.wrapping_mul(0x9E37_79B9_7F4A_7C15).wrapping_add(1);
-            let mut next = || {
-                state ^= state << 13;
-                state ^= state >> 7;
-                state ^= state << 17;
-                state
-            };
+            let mut rng = Xoshiro256PlusPlus::init(seed);
 
             let mut keys = vec![0usize; 512];
             for k in keys.iter_mut() {
-                *k = next() as usize;
+                *k = rng.next() as usize;
             }
 
             let mut map = AutoHashMap::<usize, usize, 50>::init_capacity(16).unwrap();
@@ -612,5 +661,3 @@ mod tests {
         }
     }
 }
-
-// ported from: src/collections/StaticHashMap.zig
diff --git a/src/collections/array_hash_map.rs b/src/collections/array_hash_map.rs
index 00084593249..f7a8c3b2948 100644
--- a/src/collections/array_hash_map.rs
+++ b/src/collections/array_hash_map.rs
@@ -1,4 +1,4 @@
-//! Port of Zig's `std.ArrayHashMap` family + Bun's string-keyed wrappers
+//! Insertion-ordered hash maps (`ArrayHashMap`) + Bun's string-keyed wrappers
 //! (`bun.StringArrayHashMap`, `bun.StringHashMap`,
 //! `bun.CaseInsensitiveASCIIStringArrayHashMap`, `bun.StringHashMapUnowned`).
 //!
@@ -10,12 +10,11 @@
 //!   * `getOrPut` hands back a stable `key_ptr` / `value_ptr` / `index` triple
 //!     so callers can fill the slot in-place after the lookup.
 //!
-//! Zig builds a separate `index_header` (open-addressed `hash → entry_index`
-//! table) once `len > 8` so lookups stay O(1). This port mirrors that with a
-//! lazily-built `hashbrown::HashTable<u32>` keyed by the cached u32 hash:
+//! A separate index — a lazily-built `hashbrown::HashTable<u32>` keyed by the
+//! cached u32 hash — is built once `len > 8` so lookups stay O(1):
 //! linear scan below the threshold, indexed lookup above it. Point removals
-//! (`pop`, `swap_remove`) patch the index in place (O(1), matching Zig's
-//! `removeFromIndexByIndex`); wholesale permutations (`sort`,
+//! (`pop`, `swap_remove`) patch the index in place (O(1));
+//! wholesale permutations (`sort`,
 //! `ordered_remove`) drop and immediately rebuild it so lookups never
 //! silently degrade to O(n).
 
@@ -32,38 +31,36 @@ use core::ops::{Deref, DerefMut};
 use bun_alloc::AllocError;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Free functions (Zig: `std.array_hash_map.hashString` / `std.hash_map.hashString`)
+// Free functions
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `std.array_hash_map.hashString` — wyhash(seed=0) truncated to u32.
+/// wyhash(seed=0) truncated to u32.
 #[inline]
 pub fn hash_string(s: &[u8]) -> u32 {
-    bun_wyhash::hash(s) as u32 // @truncate
+    bun_wyhash::hash(s) as u32
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Context traits (Zig: `Context` / `Adapter` duck types)
+// Context traits
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Hash/eql strategy for an `ArrayHashMap<K, _>`.
-/// Zig passes these as `anytype`; here it's a trait so the map can be generic
-/// over the strategy without each method taking a `ctx` argument.
+/// Hash/eql strategy for an `ArrayHashMap<K, _>`. A trait so the map can be
+/// generic over the strategy without each method taking a `ctx` argument.
 pub trait ArrayHashContext<K: ?Sized>: Default {
     fn hash(&self, key: &K) -> u32;
-    /// `b_index` is the index of `b` in the entry array (Zig passes it so
-    /// adapted contexts can look at sibling storage).
+    /// `b_index` is the index of `b` in the entry array (so adapted contexts
+    /// can look at sibling storage).
     fn eql(&self, a: &K, b: &K, b_index: usize) -> bool;
 }
 
 /// Adapted lookup: hash a `Q` and compare it against the stored `K`s without
-/// constructing a `K` first (Zig: `getOrPutAdapted` / `getOrPutContextAdapted`).
+/// constructing a `K` first.
 pub trait ArrayHashAdapter<Q: ?Sized, K> {
     fn hash(&self, key: &Q) -> u32;
     fn eql(&self, a: &Q, b: &K, b_index: usize) -> bool;
 }
 
-/// Default context: `Hash` + `Eq` driven through wyhash, mirroring Zig's
-/// `AutoContext` / `getAutoHashFn`.
+/// Default context: driven through `Hash` + `Eq`.
 #[derive(Default, Clone, Copy)]
 pub struct AutoContext;
 
@@ -72,9 +69,8 @@ impl<K: Hash + Eq + ?Sized> ArrayHashContext<K> for AutoContext {
     fn hash(&self, key: &K) -> u32 {
         // Keys here are small POD (`Ref`, `u32`, indices). FxHash is a single
         // mul+rotate per word — measurably cheaper than wyhash's `mum` fold for
-        // 8-byte keys, and what rustc uses for the same workload shape. The Zig
-        // port used wyhash only because that's what `std.array_hash_map` defaults
-        // to; nothing persists these hashes across runs.
+        // 8-byte keys, and what rustc uses for the same workload shape;
+        // nothing persists these hashes across runs.
         use core::hash::Hasher;
         let mut h = rustc_hash::FxHasher::default();
         key.hash(&mut h);
@@ -86,7 +82,7 @@ impl<K: Hash + Eq + ?Sized> ArrayHashContext<K> for AutoContext {
     }
 }
 
-/// `std.array_hash_map.StringContext` — byte-slice keys hashed with wyhash.
+/// Byte-slice keys hashed with wyhash.
 #[derive(Default, Clone, Copy)]
 pub struct StringContext;
 
@@ -101,8 +97,8 @@ impl ArrayHashContext<[u8]> for StringContext {
     }
 }
 
-/// `bun.CaseInsensitiveASCIIStringContext` (src/bun.zig) — ASCII-lowercased
-/// wyhash + ASCII-case-insensitive equality. Used for env-var maps on Windows.
+/// ASCII-lowercased wyhash + ASCII-case-insensitive equality. Used for
+/// env-var maps on Windows.
 #[derive(Default, Clone, Copy)]
 pub struct CaseInsensitiveAsciiStringContext;
 
@@ -111,7 +107,8 @@ impl CaseInsensitiveAsciiStringContext {
         bun_wyhash::hash_ascii_lowercase(0, s) as u32 // @truncate
     }
 
-    /// `bun.CaseInsensitiveASCIIStringContext.pre` (src/bun.zig:1031).
+    /// Precompute the case-folded hash of `input` so repeated probes against
+    /// the same key skip the lowercasing pass.
     #[inline]
     pub fn pre(input: &[u8]) -> CaseInsensitiveAsciiPrehashed<'_> {
         CaseInsensitiveAsciiPrehashed {
@@ -121,9 +118,8 @@ impl CaseInsensitiveAsciiStringContext {
     }
 }
 
-/// `bun.CaseInsensitiveASCIIStringContext.Prehashed` (src/bun.zig:1035) —
-/// caches the case-folded hash for `input` so repeated probes against the same
-/// key skip the lowercasing pass.
+/// Caches the case-folded hash for `input` so repeated probes against the
+/// same key skip the lowercasing pass.
 pub struct CaseInsensitiveAsciiPrehashed<'a> {
     pub value: u32,
     pub input: &'a [u8],
@@ -187,9 +183,8 @@ impl ArrayHashContext<[u8]> for CaseInsensitiveAsciiStringContext {
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Result of `get_or_put*`. When `found_existing == false`, `*value_ptr` is a
-/// freshly-defaulted slot the caller is expected to overwrite (Zig leaves it
-/// `undefined`; Rust cannot, so the value type carries a `Default` bound on the
-/// inserting paths).
+/// freshly-defaulted slot the caller is expected to overwrite (the value type
+/// carries a `Default` bound on the inserting paths).
 pub struct GetOrPutResult<'a, K, V> {
     pub found_existing: bool,
     pub index: usize,
@@ -197,22 +192,19 @@ pub struct GetOrPutResult<'a, K, V> {
     pub value_ptr: &'a mut V,
 }
 
-/// Zig: `std.ArrayHashMap.KV` — owned key/value pair returned by
-/// `fetchSwapRemove` / `fetchOrderedRemove`.
+/// Owned key/value pair returned by the `fetch_*_remove` methods.
 pub struct KV<K, V> {
     pub key: K,
     pub value: V,
 }
 
-/// Iterator entry — both halves mutable, matching Zig's `Entry { key_ptr: *K,
-/// value_ptr: *V }`.
+/// Iterator entry — both halves mutable.
 pub struct Entry<'a, K, V> {
     pub key_ptr: &'a mut K,
     pub value_ptr: &'a mut V,
 }
 
-/// Insertion-order iterator yielding `Entry`. Resettable (Zig callers do
-/// `it.reset()` to rewind; here `index = 0`).
+/// Insertion-order iterator yielding `Entry`. Resettable via `reset()`.
 pub struct Iter<'a, K, V> {
     keys: *mut K,
     values: *mut V,
@@ -263,10 +255,9 @@ pub trait ArrayHashMapExt {
 // ArrayHashMap<K, V, C>
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig `index_header` threshold: at or below this many entries the
-/// hash-prefiltered linear scan over `hashes` wins (the whole `Vec<u32>` fits
-/// in one cache line); above it we build/maintain the SwissTable index. Same
-/// `linear_scan_max` cut-off as `std/array_hash_map.zig`.
+/// At or below this many entries the hash-prefiltered linear scan over
+/// `hashes` wins (the whole `Vec<u32>` fits in one cache line); above it we
+/// build/maintain the SwissTable index.
 const INDEX_THRESHOLD: usize = 8;
 
 /// Widen the cached `u32` entry hash to the `u64` hashbrown probes with. The
@@ -328,8 +319,7 @@ fn index_insert_unique<A: MapAllocator>(
 /// [`index_insert_unique`] — keep the `reserve_rehash` monomorph in this crate
 /// rather than re-emitting it per `<K,V,C,A>` instantiation. Called from the
 /// `reserve` / `ensure_*_capacity` paths so a caller that pre-sizes the map
-/// (the Zig originals' `ensureTotalCapacityContext`, which also sizes the index
-/// header) pays the SwissTable grow once instead of `O(log n)` times across the
+/// pays the SwissTable grow once instead of `O(log n)` times across the
 /// following `push_entry` loop.
 #[inline(never)]
 fn index_reserve<A: MapAllocator>(
@@ -448,8 +438,8 @@ pub struct ArrayHashMap<K, V, C = AutoContext, A: MapAllocator = Global> {
     /// `INDEX_THRESHOLD` crossover.
     index: Option<Box<hashbrown::HashTable<u32, IndexAlloc<A>>, A>>,
     ctx: C,
-    // Zig `pointer_stability: std.debug.SafetyLock` — debug-only re-entrancy
-    // guard around operations that may invalidate entry pointers. `AtomicBool`
+    // Debug-only re-entrancy guard around operations that may invalidate
+    // entry pointers. `AtomicBool`
     // (not `Cell<bool>`) so the field doesn't strip `Sync` off the map in
     // debug builds — a debug-only diagnostic must not change the type's
     // auto-trait surface vs release (callers store maps in `static LazyLock`,
@@ -465,7 +455,7 @@ impl<K, V, C: Default, A: MapAllocator> Default for ArrayHashMap<K, V, C, A> {
 }
 
 impl<K: Clone, V: Clone, C: Default, A: MapAllocator> ArrayHashMap<K, V, C, A> {
-    /// Zig `clone()` is fallible (OOM); kept as `Result` for API parity.
+    /// Fallible (OOM) clone; kept as `Result` for API stability.
     pub fn clone(&self) -> Result<Self, AllocError> {
         Ok(Self {
             keys: self.keys.clone(),
@@ -517,16 +507,14 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.keys.is_empty()
     }
 
-    /// Zig: `capacity()` — number of entries the backing storage can hold
-    /// without reallocating.
+    /// Number of entries the backing storage can hold without reallocating.
     #[inline]
     pub fn capacity(&self) -> usize {
         self.keys.capacity()
     }
 
-    /// Zig: `pop()` — remove and return the last entry in insertion order, or
-    /// `None` when empty. O(1); patches the index in place (Zig
-    /// `removeFromIndexByIndex`) so subsequent lookups stay O(1).
+    /// Remove and return the last entry in insertion order, or `None` when
+    /// empty. O(1); patches the index in place so subsequent lookups stay O(1).
     pub fn pop(&mut self) -> Option<KV<K, V>> {
         let key = self.keys.pop()?;
         // SAFETY: keys/values/hashes always share the same length.
@@ -536,8 +524,8 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         Some(KV { key, value })
     }
 
-    /// Zig: `clearAndFree(allocator)` — drop every entry and release the
-    /// backing allocations (capacity goes to zero).
+    /// Drop every entry and release the backing allocations (capacity goes to
+    /// zero).
     pub fn clear_and_free(&mut self) {
         self.keys = Vec::new_in(A::default());
         self.values = Vec::new_in(A::default());
@@ -554,10 +542,9 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         Ok(())
     }
 
-    /// Zig: `map.entries.len = n` after `ensureTotalCapacity(n)` — bulk-resize
-    /// the backing columns so callers can `keys_mut().copy_from_slice(...)` /
-    /// `values_mut().copy_from_slice(...)` and then `re_index()`. Mirrors the
-    /// pattern in `lockfile/bun.lockb.zig`'s `Serializer.load`.
+    /// Bulk-resize the backing columns so callers can
+    /// `keys_mut().copy_from_slice(...)` / `values_mut().copy_from_slice(...)`
+    /// and then `re_index()`.
     ///
     /// # Safety
     /// `n` must not exceed reserved capacity, and every element in
@@ -569,7 +556,8 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         debug_assert!(n <= self.keys.capacity());
         debug_assert!(n <= self.values.capacity());
         debug_assert!(n <= self.hashes.capacity());
-        // SAFETY: caller contract above; matches Zig `.entries.len = n`.
+        // SAFETY: caller contract above — `n` is within reserved capacity and
+        // the uninit window is filled before any read.
         unsafe {
             self.keys.set_len(n);
             self.values.set_len(n);
@@ -579,11 +567,9 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.drop_index();
     }
 
-    /// Zig `ensureTotalCapacityContext`: same as `ensure_total_capacity` but
-    /// takes an explicit `ctx` for the stored key type. This port maintains no
-    /// separate index header (lookup scans the cached `hashes` vec), so the
-    /// context is accepted and ignored — capacity reservation is purely a Vec
-    /// operation here.
+    /// Same as `ensure_total_capacity` but takes an explicit `ctx` for the
+    /// stored key type. Capacity reservation is purely a Vec operation here,
+    /// so the context is accepted and ignored.
     #[inline]
     pub fn ensure_total_capacity_context<Ctx>(
         &mut self,
@@ -593,7 +579,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.ensure_total_capacity(n)
     }
 
-    /// Zig `putAssumeCapacityContext`: insert/replace using an externally-supplied
+    /// Insert/replace using an externally-supplied
     /// hash/eql context instead of the stored `C`. Used when `C = AutoContext`
     /// can't satisfy `K: Hash` (e.g. `bun_semver::String`, whose hash needs the
     /// owning `arg_buf`/`existing_buf`). Takes closures rather than an
@@ -612,7 +598,6 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
             self.values[i] = value;
             return;
         }
-        // PERF(port): was assume_capacity — Vec::push is amortized O(1) regardless.
         self.push_entry(key, value, h);
     }
 
@@ -647,12 +632,12 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         }
     }
 
-    /// Zig: `shrinkAndFree(new_len)` — truncate to `new_len` entries (dropping
-    /// any tail) and release excess capacity. Insertion order is preserved, so
-    /// no rehash of the surviving prefix is needed.
+    /// Truncate to `new_len` entries (dropping any tail) and release excess
+    /// capacity. Insertion order is preserved, so no rehash of the surviving
+    /// prefix is needed.
     pub fn shrink_and_free(&mut self, new_len: usize) {
-        // Drop tail index slots first (Zig: removeFromIndexByIndex loop), so
-        // the surviving accelerator stays valid for O(1) lookups.
+        // Drop tail index slots first, so the surviving accelerator stays
+        // valid for O(1) lookups.
         if self.index.is_some() {
             for i in new_len..self.hashes.len() {
                 let h = self.hashes[i];
@@ -739,9 +724,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.index = None;
     }
 
-    /// std-HashMap-compat alias for `clear_retaining_capacity`. Zig callers
-    /// frequently spell this `clearRetainingCapacity()`; ported call sites that
-    /// went through the std-alias path expect bare `clear()`.
+    /// std-HashMap-compat alias for `clear_retaining_capacity`.
     #[inline]
     pub fn clear(&mut self) {
         self.clear_retaining_capacity();
@@ -749,14 +732,13 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
 
     /// std-HashMap-compat: shared iteration over `(key, value)` pairs in
     /// insertion order. Distinct from [`iterator`](Self::iterator) which yields
-    /// mutable `Entry { key_ptr, value_ptr }` (Zig shape) and requires
-    /// `&mut self`.
+    /// mutable `Entry { key_ptr, value_ptr }` and requires `&mut self`.
     #[inline]
     pub fn iter(&self) -> core::iter::Zip<core::slice::Iter<'_, K>, core::slice::Iter<'_, V>> {
         self.keys.iter().zip(self.values.iter())
     }
 
-    /// Zig `getIndexContext` for callers whose context is an inherent-method
+    /// Index lookup for callers whose context is an inherent-method
     /// struct (no `ArrayHashAdapter` impl). Takes the precomputed `u32` hash
     /// plus an `eql` closure so e.g. `bun_semver::String::ArrayHashContext`
     /// (which needs `arg_buf`/`existing_buf`) can drive a `&self` lookup.
@@ -848,7 +830,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
     }
 
     /// Remove the index slot pointing at `tail` (the just-popped last entry).
-    /// O(1); mirrors Zig `removeFromIndexByIndex` for the `pop`/`shrink` path.
+    /// O(1); used for the `pop`/`shrink` path.
     #[inline]
     fn index_remove_tail(&mut self, tail: usize, tail_hash: u32) {
         let Some(index) = self.index.as_deref_mut() else {
@@ -862,7 +844,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
     /// Patch the index after a `Vec::swap_remove(removed)`: drop the slot for
     /// `removed`, then retarget the slot that still says `old_last` (the
     /// pre-swap tail index, == `self.keys.len()` post-swap) to `removed`.
-    /// O(1); mirrors Zig `removeFromIndexByIndex` + `updateEntryIndex`.
+    /// O(1).
     #[inline]
     fn index_swap_remove(&mut self, removed: usize, removed_hash: u32) {
         let Some(index) = self.index.as_deref_mut() else {
@@ -882,7 +864,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         }
     }
 
-    /// Zig `ArrayHashMap.sort` — stable in-place sort of keys/values/hashes by
+    /// Stable in-place sort of keys/values/hashes by
     /// a caller-supplied index comparator. The closure receives borrows of the
     /// key and value slices so it can compare on either without re-borrowing
     /// `self`.
@@ -962,7 +944,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         Some((&mut self.keys[index], &mut self.values[index]))
     }
 
-    /// Zig `swapRemoveAt` — remove the entry at `index` by swapping in the last
+    /// Remove the entry at `index` by swapping in the last
     /// entry. O(1); does not preserve insertion order. Returns the removed pair.
     pub fn swap_remove_at(&mut self, index: usize) -> (K, V) {
         let k = self.keys.swap_remove(index);
@@ -972,7 +954,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         (k, v)
     }
 
-    // ── adapted lookup (Zig: getAdapted / getIndexAdapted) ─────────────────
+    // ── adapted lookup ──────────────────────────────────────────────────────
 
     /// Look up by `key` using `adapter` for hash/eql, without constructing a `K`.
     #[inline]
@@ -993,8 +975,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
             .map(|i| &self.values[i])
     }
 
-    /// Zig `getPtrContext` / `getPtrAdapted` — mutable value lookup using an
-    /// externally-supplied hash/eql adapter.
+    /// Mutable value lookup using an externally-supplied hash/eql adapter.
     #[inline]
     pub fn get_ptr_adapted<Q: ?Sized, Ad>(&mut self, key: &Q, adapter: &Ad) -> Option<&mut V>
     where
@@ -1035,7 +1016,7 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.get_index(key).map(|i| &self.values[i])
     }
 
-    /// Zig `getPtr` — mutable value lookup.
+    /// Mutable value lookup.
     pub fn get_ptr_mut(&mut self, key: &K) -> Option<&mut V> {
         let i = self.get_index(key)?;
         Some(&mut self.values[i])
@@ -1057,8 +1038,7 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
     pub fn put(&mut self, key: K, value: V) -> Result<(), AllocError> {
         let h = self.ctx.hash(&key);
         if let Some(i) = self.find_hash(h, |k, idx| self.ctx.eql(&key, k, idx)) {
-            // Zig putContext (std/array_hash_map.zig:941): only assigns
-            // `result.value_ptr.*`; the original key is preserved.
+            // Only the value is assigned on hit; the original key is preserved.
             self.values[i] = value;
         } else {
             self.push_entry(key, value, h);
@@ -1077,8 +1057,8 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         Ok(())
     }
 
-    /// PERF(port): Zig skips the grow check; this port does too but `Vec::push`
-    /// will still reallocate if the caller lied about capacity.
+    /// PERF: skips the grow check, but `Vec::push` will still reallocate if
+    /// the caller lied about capacity.
     pub fn put_assume_capacity(&mut self, key: K, value: V) {
         let _ = self.put(key, value);
     }
@@ -1087,7 +1067,7 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
     pub fn insert(&mut self, key: K, value: V) -> Option<V> {
         let h = self.ctx.hash(&key);
         if let Some(i) = self.find_hash(h, |k, idx| self.ctx.eql(&key, k, idx)) {
-            // std::HashMap::insert and Zig put: keep the original key on hit.
+            // Like std::HashMap::insert: keep the original key on hit.
             Some(core::mem::replace(&mut self.values[i], value))
         } else {
             self.push_entry(key, value, h);
@@ -1103,15 +1083,15 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         true
     }
 
-    /// Zig: `fetchSwapRemove` — swap-remove returning the removed `(K, V)` pair,
-    /// or `None` if `key` was not present.
+    /// Swap-remove returning the removed `(K, V)` pair, or `None` if `key`
+    /// was not present.
     pub fn fetch_swap_remove(&mut self, key: &K) -> Option<(K, V)> {
         let i = self.get_index(key)?;
         Some(self.swap_remove_at(i))
     }
 
-    /// Zig: `orderedRemove` — preserves insertion order of remaining entries.
-    /// Returns `true` if the key was present (matching Zig's `bool` return).
+    /// Preserves insertion order of remaining entries.
+    /// Returns `true` if the key was present.
     #[inline]
     pub fn ordered_remove(&mut self, key: &K) -> bool {
         self.remove(key).is_some()
@@ -1124,9 +1104,8 @@ impl<K, V, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         self.keys.remove(i);
         self.hashes.remove(i);
         // Ordered remove shifts every index ≥ i; rebuild rather than patching
-        // each slot. Immediate rebuild keeps subsequent lookups O(1) (Zig
-        // patches in place; this is the simpler-correct equivalent for the
-        // rare ordered path).
+        // each slot. Immediate rebuild keeps subsequent lookups O(1) on this
+        // rare path.
         self.drop_index();
         if self.keys.len() > INDEX_THRESHOLD {
             self.rebuild_index();
@@ -1235,7 +1214,7 @@ impl<'a, K, V, C, A: MapAllocator> MapEntry<'a, K, V, C, A> {
 }
 
 impl<K, V: Default, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V, C, A> {
-    /// Zig `getOrPut`: look up `key`; if absent, append it with a defaulted
+    /// Look up `key`; if absent, append it with a defaulted
     /// value slot and return `found_existing = false`.
     pub fn get_or_put(&mut self, key: K) -> Result<GetOrPutResult<'_, K, V>, AllocError> {
         let h = self.ctx.hash(&key);
@@ -1246,20 +1225,20 @@ impl<K, V: Default, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V,
         Ok(self.gop_at(i, false))
     }
 
-    /// Zig `getOrPutAssumeCapacity`: like [`get_or_put`] but skips the grow
+    /// Like [`get_or_put`] but skips the grow
     /// check. Caller must have called `ensure_unused_capacity` first.
     pub fn get_or_put_assume_capacity(&mut self, key: K) -> GetOrPutResult<'_, K, V> {
         let h = self.ctx.hash(&key);
         if let Some(i) = self.find_hash(h, |k, idx| self.ctx.eql(&key, k, idx)) {
             return self.gop_at(i, true);
         }
-        // PERF(port): `push_within_capacity` is unstable; `push` is a no-grow
+        // PERF: `push_within_capacity` is unstable; `push` is a no-grow
         // when the prior `ensure_unused_capacity` reserved the slot.
         let i = self.push_entry(key, V::default(), h);
         self.gop_at(i, false)
     }
 
-    /// Zig `getOrPutValue`: like `get_or_put` but writes `value` when absent.
+    /// Like `get_or_put` but writes `value` when absent.
     pub fn get_or_put_value(
         &mut self,
         key: K,
@@ -1271,8 +1250,8 @@ impl<K, V: Default, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V,
             // through the slot it already points at.
             *gop.value_ptr = value;
         }
-        // PORT NOTE: reshaped — can't return `gop` while it borrows in the
-        // branch above without NLL gymnastics; recompute via index.
+        // Can't return `gop` while it borrows in the branch above without
+        // NLL gymnastics; recompute via index.
         let i = gop.index;
         let found = gop.found_existing;
         Ok(self.gop_at(i, found))
@@ -1280,7 +1259,7 @@ impl<K, V: Default, C: ArrayHashContext<K>, A: MapAllocator> ArrayHashMap<K, V,
 }
 
 impl<K: Default, V: Default, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
-    /// Zig `getOrPutAdapted`: look up by `key` using `adapter` for hash/eql;
+    /// Look up by `key` using `adapter` for hash/eql;
     /// on miss, append a *defaulted* `K`/`V` pair — caller fills both via
     /// `key_ptr` / `value_ptr`.
     pub fn get_or_put_adapted<Q: ?Sized, Ad>(
@@ -1299,9 +1278,9 @@ impl<K: Default, V: Default, C, A: MapAllocator> ArrayHashMap<K, V, C, A> {
         Ok(self.gop_at(i, false))
     }
 
-    /// Zig `getOrPutContextAdapted`: same as `get_or_put_adapted` but takes an
-    /// explicit `ctx` for the *stored* key type. This port does not need `ctx`
-    /// for the index header (none yet), so it is accepted and ignored.
+    /// Same as `get_or_put_adapted` but takes an explicit `ctx` for the
+    /// *stored* key type. The index does not need `ctx`, so it is accepted
+    /// and ignored.
     #[inline]
     pub fn get_or_put_context_adapted<Q: ?Sized, Ad>(
         &mut self,
@@ -1335,9 +1314,7 @@ impl<K, V, C, A: MapAllocator> ArrayHashMapExt for ArrayHashMap<K, V, C, A> {
 /// `std.StringArrayHashMap(V)` / `bun.CaseInsensitiveASCIIStringArrayHashMap(V)`.
 ///
 /// Newtype (not an alias) so `get_or_put` / `get` / `put` can take `&[u8]`
-/// borrows — the Zig API stores `[]const u8` keys and lets the caller decide
-/// whether to dupe them; here keys are `Box<[u8]>` and the borrowing methods
-/// box on insert.
+/// borrows — keys are `Box<[u8]>` and the borrowing methods box on insert.
 pub struct StringArrayHashMap<V, C = StringContext, A: MapAllocator = Global> {
     inner: ArrayHashMap<Box<[u8], A>, V, BoxedSliceContext<C>, A>,
     // The string context is consulted for hash/eql on `[u8]` borrows. The inner
@@ -1346,7 +1323,7 @@ pub struct StringArrayHashMap<V, C = StringContext, A: MapAllocator = Global> {
     ctx: C,
 }
 
-/// Windows env-var map (`src/bun.zig` `CaseInsensitiveASCIIStringArrayHashMap`).
+/// Windows env-var map.
 pub type CaseInsensitiveAsciiStringArrayHashMap<V> =
     StringArrayHashMap<V, CaseInsensitiveAsciiStringContext>;
 
@@ -1360,7 +1337,7 @@ impl<V, C: Default, A: MapAllocator> Default for StringArrayHashMap<V, C, A> {
 }
 
 impl<V: Clone, C: Default, A: MapAllocator> StringArrayHashMap<V, C, A> {
-    /// Zig `clone()` is fallible (OOM); kept as `Result` for API parity.
+    /// Fallible (OOM) clone; kept as `Result` for API stability.
     pub fn clone(&self) -> Result<Self, AllocError> {
         Ok(Self {
             inner: self.inner.clone()?,
@@ -1461,8 +1438,8 @@ impl<V, C: ArrayHashContext<[u8]> + Default, A: MapAllocator> StringArrayHashMap
         true
     }
 
-    /// Zig: `StringArrayHashMap.fetchSwapRemove` — removes the entry (swapping
-    /// the last element into its slot) and returns the owned key/value pair.
+    /// Removes the entry (swapping the last element into its slot) and
+    /// returns the owned key/value pair.
     pub fn fetch_swap_remove(&mut self, key: &[u8]) -> Option<KV<Box<[u8], A>, V>> {
         let i = self.find(key)?;
         let (k, v) = self.inner.swap_remove_at(i);
@@ -1484,7 +1461,7 @@ impl<V, C: ArrayHashContext<[u8]> + Default, A: MapAllocator> StringArrayHashMap
 impl<V: Default, C: ArrayHashContext<[u8]> + Default, A: MapAllocator> StringArrayHashMap<V, C, A> {
     /// See `ArrayHashMap::get_or_put`. The key is boxed on insert; callers that
     /// then write `*gop.key_ptr = Box::from(key)` are doing a redundant alloc —
-    /// harmless, and lets the Zig-shaped call sites compile unchanged.
+    /// harmless.
     pub fn get_or_put(
         &mut self,
         key: &[u8],
@@ -1527,21 +1504,21 @@ impl<V, C, A: MapAllocator> ArrayHashMapExt for StringArrayHashMap<V, C, A> {
 // StringHashMap<V, A> — unordered `[]const u8`-keyed map
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `std.StringHashMap(V)`. Thin newtype over `hashbrown::HashMap` that adds
-/// the Zig `getOrPut` / `getOrPutValue` entry points while keeping the
+/// Thin newtype over `hashbrown::HashMap` that adds
+/// the `get_or_put` / `get_or_put_value` entry points while keeping the
 /// `hashbrown` surface (`.get`, `.contains_key`, `.reserve`, `.insert`, …)
 /// reachable via `Deref`.
 ///
 /// Allocator-generic so AST containers (`Scope::members` &c.) can route both
 /// the table *and* the owned-key boxes through `bun_alloc::AstAlloc`,
-/// matching Zig's `Unmanaged` semantics where the map's backing store lives
+/// so the map's backing store lives
 /// in the same arena as the AST nodes that hold it. The `A = Global` default
 /// keeps every existing `StringHashMap<V>` site source-compatible.
-// Hashed with seed-0 wyhash (matches Zig's `std.hash_map.StringContext`) —
+// Hashed with seed-0 wyhash —
 // deterministic across runs and ~3-5× faster than `RandomState`/SipHash on
 // the short identifier keys the parser/printer/renamer churn.
 //
-// The `A: Default` bound is the substitute for Zig's per-call `Allocator`
+// The `A: Default` bound replaces a per-call allocator
 // parameter: hashbrown's `HashMap<_, _, _, A>` stores the allocator by value,
 // and every key `Box<[u8], A>` needs its own `A` too. For zero-sized
 // allocators (`Global`, `AstAlloc`) `A::default()` is a no-op constant; if a
@@ -1561,14 +1538,12 @@ pub type StringHashMapInner<V, A = DefaultAlloc> =
 /// default produced by `put`/`get_or_put`) or a borrowed `&'static [u8]`
 /// (`Static`, produced by `put_static_key`).
 ///
-/// Zig's `std.StringHashMap` always *borrows* the caller's `[]const u8` key —
-/// the map never copies it. The Rust port originally heap-boxed every key on
-/// `put` for safety, which profiling showed as the dominant cost of
+/// Heap-boxing every key on `put` profiled as the dominant cost of
 /// `DirEntry::add_entry` (the resolver's per-file hot path): the key bytes
 /// there already live in the process-static `FilenameStore`/`EntryStore`, so
 /// the `Box<[u8]>` was a redundant second copy. The `Static` variant lets such
-/// callers store the existing slice directly, matching Zig's zero-copy
-/// behaviour without giving up owned-key safety for everyone else.
+/// callers store the existing slice directly — zero-copy without giving up
+/// owned-key safety for everyone else.
 ///
 /// `Deref<Target = [u8]>` + `Borrow<[u8]>` keep `.get(&[u8])`,
 /// `.contains_key(&[u8])`, and `&**key` working unchanged at every call site,
@@ -1578,7 +1553,7 @@ pub type StringHashMapInner<V, A = DefaultAlloc> =
 /// Packed `(ptr, len | OWNED_BIT)` instead of a 2-variant enum. The enum had
 /// no usable niche (both `Box<[u8]>` and `&[u8]` start with a non-null
 /// pointer), so it was 24 B; folding the owned/borrowed discriminant into the
-/// top bit of `len` brings it to 16 B — same as Zig's `[]const u8`. For
+/// top bit of `len` brings it to 16 B. For
 /// `Scope::members` (`hashbrown::RawTable<(StringHashMapKey, Member)>`) that
 /// shrinks the stored tuple 40 B → 32 B, cutting the module-scope table's
 /// page footprint (and `reserve_rehash` `memcpy` traffic) by ~20 %.
@@ -1835,7 +1810,7 @@ impl<V, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A>
         self.inner.len()
     }
 
-    /// Zig `valueIterator()`. Inherent forwarder so callers can name
+    /// Inherent forwarder so callers can name
     /// `StringHashMap::values` without relying on `Deref` resolution.
     #[inline]
     pub fn values(&self) -> hashbrown::hash_map::Values<'_, StringHashMapKey<A>, V> {
@@ -1864,8 +1839,7 @@ impl<V, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A>
     }
 
     /// Insert `value` under `key` **without copying the key bytes**. This is
-    /// the zero-copy path that matches Zig's `StringHashMap.put` (which always
-    /// borrows). `key` is stored as `StringHashMapKey::Static`, so the caller
+    /// the zero-copy path: `key` is stored as `StringHashMapKey::Static`, so the caller
     /// must guarantee the bytes genuinely live for `'static` — in practice
     /// that means slices into a process-lifetime arena (`FilenameStore`,
     /// `EntryStore`, AST heap) where the `'static` was minted via an explicit
@@ -1928,12 +1902,11 @@ impl<V, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A>
     }
 
     /// Insert `value` under `key` **without copying the key bytes** — the
-    /// arena-lifetime twin of [`put_static_key`]. Zig's
-    /// `StringHashMapUnmanaged.put` stores the caller's `[]const u8` slice by
-    /// value; the safe Rust [`put`] heap-boxes it instead, which profiling
+    /// arena-lifetime twin of [`put_static_key`]. The safe [`put`] heap-boxes
+    /// the key, which profiling
     /// flagged as the dominant `_mi_malloc_generic` caller in the parser
     /// (`Scope::members` takes one box per declared identifier per scope).
-    /// This entry point restores the Zig zero-copy behaviour for callers whose
+    /// This entry point provides zero-copy insertion for callers whose
     /// key bytes already live in an arena that outlives the map.
     ///
     /// # Safety
@@ -1953,29 +1926,29 @@ impl<V, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A>
     }
 
     /// Insert a pre-boxed key without re-allocating it. Uses `try_reserve` so
-    /// OOM surfaces as `Err` instead of aborting (matches Zig `put` returning
-    /// `error.OutOfMemory`); callers can roll back side effects on failure.
+    /// OOM surfaces as `Err` instead of aborting; callers can roll back side
+    /// effects on failure.
     pub fn put_owned(&mut self, key: Box<[u8], A>, value: V) -> Result<(), AllocError> {
         self.inner.try_reserve(1).map_err(|_| AllocError)?;
         self.inner.insert(StringHashMapKey::owned(key), value);
         Ok(())
     }
 
-    /// PERF(port): Zig skips the grow check; std::HashMap cannot, so this is
+    /// PERF: std::HashMap cannot skip the grow check, so this is
     /// just `put` without the `Result`.
     #[inline]
     pub fn put_assume_capacity(&mut self, key: &[u8], value: V) {
         self.inner.insert(owned_key::<A>(key), value);
     }
 
-    /// Zig `putNoClobber` — asserts the key was not already present.
+    /// Asserts the key was not already present.
     pub fn put_no_clobber(&mut self, key: &[u8], value: V) -> Result<(), AllocError> {
         let prev = self.inner.insert(owned_key::<A>(key), value);
         debug_assert!(prev.is_none(), "put_no_clobber: key already present");
         Ok(())
     }
 
-    /// Zig `getAdapted` — look up by `key` using `adapter` for hash/eql.
+    /// Look up by `key` using `adapter` for hash/eql.
     ///
     /// The adapter's precomputed hash is ignored; the lookup falls back to the
     /// normal `get(key)` path (correctness is preserved — `adapter.eql` is byte
@@ -2001,7 +1974,7 @@ impl<V, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A>
 pub use crate::hash_map::GetOrPutResult as StringHashMapGetOrPut;
 
 impl<V: Default, A: Allocator + HashbrownAllocator + Clone + Default> StringHashMap<V, A> {
-    /// PERF(port): the previous shape (`contains_key` + `entry(Box::from(key))`)
+    /// PERF: the previous shape (`contains_key` + `entry(Box::from(key))`)
     /// hashed `key` twice and unconditionally heap-allocated the `Box` even on
     /// hit. `Scope::members` calls this once per declared identifier during
     /// parse, so on three.js that was ~thousands of redundant `Box`
@@ -2019,7 +1992,7 @@ impl<V: Default, A: Allocator + HashbrownAllocator + Clone + Default> StringHash
         Ok(self.inner.entry(owned_key::<A>(key)).or_insert(value))
     }
 
-    /// Zig `getOrPutContextAdapted` on `StringHashMap` — see `get_adapted` for
+    /// See `get_adapted` for
     /// why the adapter's precomputed hash is currently ignored.
     pub fn get_or_put_context_adapted<C>(
         &mut self,
@@ -2073,14 +2046,14 @@ impl<V: Default, A: Allocator + HashbrownAllocator + Clone + Default> StringHash
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// StringHashMapContext + Prehashed adapters (src/bun.zig)
+// StringHashMapContext + Prehashed adapters
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun.StringHashMapContext` — wyhash(seed=0) over byte slices, full 64-bit.
 /// This is the *unordered* map context (vs. `StringContext` above which
 /// truncates to u32 for `ArrayHashMap`).
 ///
-/// PORT NOTE: spelled as a module rather than a unit struct so callers can
+/// Spelled as a module rather than a unit struct so callers can
 /// path-access the nested `Prehashed` / `PrehashedCaseInsensitive` types
 /// (`StringHashMapContext::Prehashed::…`) on stable Rust, which forbids
 /// inherent associated types.
@@ -2103,10 +2076,10 @@ pub mod StringHashMapContext {
     pub use super::string_hash_map::{Prehashed, PrehashedCaseInsensitive, hash};
 }
 
-/// Namespace mirroring `std.hash_map` so call sites can write
+/// String-hash helpers, namespaced so call sites can write
 /// `bun_collections::string_hash_map::{hash, Prehashed, GetOrPutResult}`.
 pub mod string_hash_map {
-    /// `std.hash_map.hashString` — wyhash(seed=0), full u64.
+    /// wyhash(seed=0), full u64.
     #[inline]
     pub fn hash(s: &[u8]) -> u64 {
         bun_wyhash::hash(s)
@@ -2177,7 +2150,7 @@ pub mod string_hash_map {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// StringSet (src/bun.zig) — `StringArrayHashMap<()>` with key-duping insert
+// StringSet — `StringArrayHashMap<()>` with key-duping insert
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun.StringSet` — insertion-ordered set of owned byte-string keys.
@@ -2192,7 +2165,7 @@ impl StringSet {
         Self::default()
     }
 
-    /// Zig `init(allocator)` — allocator dropped (global mimalloc).
+    /// Alias for `new()` (the global allocator is implicit).
     #[inline]
     pub fn init() -> Self {
         Self::default()
@@ -2220,10 +2193,9 @@ impl StringSet {
     }
 
     /// Insert `key`, duping it on miss. Returns `Ok(())` whether or not the key
-    /// was already present (Zig signature).
+    /// was already present.
     pub fn insert(&mut self, key: &[u8]) -> Result<(), AllocError> {
-        // get_or_put already boxes `key` on miss; the Zig second-dupe is
-        // redundant under owned `Box<[u8]>` keys.
+        // get_or_put already boxes `key` on miss.
         let _ = self.map.get_or_put(key)?;
         Ok(())
     }
@@ -2241,7 +2213,7 @@ impl StringSet {
     pub fn clear_and_free(&mut self) {
         // Keys are `Box<[u8]>`; `clear` drops them.
         self.map.clear_retaining_capacity();
-        // PORT NOTE: Zig also freed the backing arrays; Vec keeps capacity here
+        // This does not free the backing arrays; Vec keeps capacity here
         // (callers wanting that can drop the whole `StringSet`).
     }
 
@@ -2249,13 +2221,13 @@ impl StringSet {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// StringHashMapUnowned (src/bun.zig) — pre-hashed string key
+// StringHashMapUnowned — pre-hashed string key
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun.StringHashMapUnowned.Key` — a string identity reduced to `(hash, len)`
 /// so the map never stores the string bytes. Collisions on both fields are
-/// treated as equal (matches the Zig — used for side-effects globs where a
-/// false positive is acceptable).
+/// treated as equal (used for side-effects globs where a false positive is
+/// acceptable).
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StringHashMapUnownedKey {
     pub hash: u64,
@@ -2276,8 +2248,7 @@ impl StringHashMapUnownedKey {
 pub mod string_hash_map_unowned {
     pub use super::StringHashMapUnownedKey as Key;
 
-    /// Adapter feeding `Key.hash` straight through (Zig
-    /// `bun.StringHashMapUnowned.Adapter`).
+    /// Adapter feeding `Key.hash` straight through.
     #[derive(Default, Clone, Copy)]
     pub struct Adapter;
 
@@ -2293,8 +2264,6 @@ pub mod string_hash_map_unowned {
     }
 }
 
-// ported from: vendor/zig/lib/std/array_hash_map.zig
-
 #[cfg(test)]
 mod index_tests {
     use super::*;
diff --git a/src/collections/array_list.rs b/src/collections/array_list.rs
index 4446c5afa8d..510ddce2f96 100644
--- a/src/collections/array_list.rs
+++ b/src/collections/array_list.rs
@@ -1,16 +1,5 @@
 #![forbid(unsafe_code)]
 //! Managed `ArrayList` wrappers.
-//!
-//! PORT NOTE: The Zig original wraps `std.ArrayListAlignedUnmanaged` to add two things:
-//!   1. A stored allocator (managed vs unmanaged split).
-//!   2. "Deep" semantics — `deinit`/`clear`/`shrink`/`replaceRange` call `deinit` on each
-//!      removed item, with `*Shallow` variants that skip that.
-//!
-//! In Rust, (1) disappears entirely — `Vec<T>` uses the global mimalloc allocator and the
-//! `Allocator` type parameter is dropped per §Allocators in PORTING.md. (2) is the *default*
-//! behavior of `Vec<T>`: removing/dropping elements runs their `Drop`. So the "deep" methods
-//! map to ordinary `Vec` operations; the `*Shallow` variants had no in-tree callers and are
-//! not ported.
 
 use core::mem;
 
@@ -20,66 +9,40 @@ use super::vec_ext::VecExt;
 
 /// Managed `ArrayList` using an arbitrary allocator.
 /// Prefer using a concrete type, like `ArrayListDefault`.
-///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
-// PORT NOTE: `std.mem.Allocator` type param dropped — global mimalloc (non-AST crate).
 pub type ArrayList<T> = ArrayListAlignedIn<T>;
 
 /// Managed `ArrayList` using the default allocator. No overhead compared to an unmanaged
 /// `ArrayList`.
-///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
-// PORT NOTE: `bun.DefaultAllocator` type param dropped — global mimalloc.
 pub type ArrayListDefault<T> = ArrayListAlignedIn<T>;
 
 /// Managed `ArrayList` using a specific kind of allocator.
-///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
-// PORT NOTE: `Allocator` type param dropped — global mimalloc.
 pub type ArrayListIn<T> = ArrayListAlignedIn<T>;
 
 /// Managed `ArrayListAligned` using an arbitrary allocator.
-///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
-// TODO(port): const-generic alignment param. Rust `Vec<T>` uses `align_of::<T>()` and has no
-// over-alignment knob; if any caller passes a non-null `alignment`, that call site needs a
-// `#[repr(align(N))]` newtype wrapper around `T` instead.
+// Rust `Vec<T>` uses `align_of::<T>()` and has no over-alignment knob. A call site that needs
+// over-alignment must wrap `T` in a `#[repr(align(N))]` newtype instead.
 pub type ArrayListAligned<T> = ArrayListAlignedIn<T>;
 
 /// Managed `ArrayListAligned` using the default allocator.
-///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
 pub type ArrayListAlignedDefault<T> = ArrayListAlignedIn<T>;
 
 /// Managed `ArrayListAligned` using a specific kind of allocator.
 ///
-/// NOTE: Unlike Zig's `std.ArrayList`, dropping this type runs `Drop` on each of the items.
-// PORT NOTE: Zig's `fn(...) type` factory → generic struct (PORTING.md §Idiom map).
-// Allocator type param dropped; alignment param dropped (see ArrayListAligned TODO above).
+/// NOTE: dropping this type (and the aliases above) runs `Drop` on each of the items.
 #[derive(Default)]
 pub struct ArrayListAlignedIn<T> {
-    /// Zig: `#unmanaged: Unmanaged = .empty`
     unmanaged: Unmanaged<T>,
-    // Zig: `#std.mem.Allocator param` — dropped (global mimalloc).
 }
 
-/// Zig: `Unmanaged = std.ArrayListAlignedUnmanaged(T, alignment)`
 pub(crate) type Unmanaged<T> = Vec<T>;
 
-/// Zig: `Slice = Unmanaged.Slice` (= `[]align(alignment) T`, an owned slice when detached).
-// TODO(port): Zig `Slice` is used both as a borrow (`items()`) and as an owned return
-// (`toOwnedSlice`). Rust splits these: borrows are `&[T]`/`&mut [T]`, owned is `Box<[T]>`.
 pub type Slice<T> = Box<[T]>;
 
-// TODO(port): `SentinelSlice` — sentinel-terminated slices have no std Rust equivalent; only
-// needed if a caller uses `fromOwnedSliceSentinel`. Map to `bun_core::ZStr`/`WStr` at call site.
-
 impl<T> ArrayListAlignedIn<T> {
     pub fn items(&self) -> &[T] {
         self.unmanaged.as_slice()
     }
 
-    // PORT NOTE: Zig `items()` returns a mutable `[]T`; Rust splits const/mut borrows.
     pub fn items_mut(&mut self) -> &mut [T] {
         self.unmanaged.as_mut_slice()
     }
@@ -89,7 +52,6 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn init() -> Self {
-        // Zig: `.initIn(bun.memory.initDefault(Allocator))` — allocator dropped.
         Self::init_in()
     }
 
@@ -104,47 +66,34 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn init_capacity_in(num: usize /* allocator dropped */) -> Result<Self, AllocError> {
-        // Zig: `try .initCapacity(bun.allocators.asStd(allocator_), num)`
-        // PERF(port): Vec::with_capacity aborts on OOM rather than returning Err. Could swap to
+        // Vec::with_capacity aborts on OOM rather than returning Err. Could swap to
         // `Vec::try_with_capacity` (nightly) or a fallible wrapper if OOM recovery matters.
         Ok(Self {
             unmanaged: Vec::with_capacity(num),
         })
     }
 
-    // Zig `pub fn deinit` → `impl Drop` (see below). Body only deinits items + frees backing,
-    // both of which `Vec<T>`'s `Drop` already does, so no explicit `Drop` impl is needed.
-
     pub fn from_owned_slice(slice: Slice<T>) -> Self {
         Self {
             unmanaged: Vec::from(slice),
         }
     }
 
-    // TODO(port): `from_owned_slice_sentinel` — sentinel-terminated owned slices are not a Rust
-    // type. If needed, accept `Box<[T]>` with the sentinel already stripped, or `ZStr`/`WStr`.
+    // Sentinel-terminated owned slices are not a Rust type, so this takes a `Box<[T]>` with
+    // the sentinel already stripped.
     pub fn from_owned_slice_sentinel(/* sentinel: T, */ slice: Slice<T>) -> Self {
         Self {
             unmanaged: Vec::from(slice),
         }
     }
 
-    // TODO(port): `writer()` — Zig returns an `std.io.Writer` that appends bytes. For `T = u8`
-    // this is `impl std::io::Write for Vec<u8>` (already in std). For other `T` there is no
-    // meaningful writer. TODO(port): expose only on `ArrayListAlignedIn<u8>`.
-    pub fn writer(&mut self) -> &mut Vec<T> {
-        &mut self.unmanaged
-    }
-
     /// This method empties `self`.
     pub fn move_to_unmanaged(&mut self) -> Unmanaged<T> {
-        // Zig: `defer self.#unmanaged = .empty; return self.#unmanaged;`
         mem::take(&mut self.unmanaged)
     }
 
     /// Unlike `move_to_unmanaged`, this method *consumes* `self`.
     pub fn into_unmanaged_with_allocator(self) -> (Unmanaged<T>, ()) {
-        // Zig: returns `(Unmanaged, Allocator)`; allocator dropped → unit.
         (self.unmanaged, ())
     }
 
@@ -155,15 +104,10 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn to_owned_slice(self) -> Result<Slice<T>, AllocError> {
-        // Zig: `self.#unmanaged.toOwnedSlice(...)` — shrinks cap→len then returns the slice.
         Ok(self.unmanaged.into_boxed_slice())
     }
 
     /// Creates a copy of this `ArrayList` with copies of its items.
-    ///
-    /// PORT NOTE: Zig makes *bitwise* (shallow) copies regardless of whether `T` has a
-    /// `deinit`. Rust cannot bit-copy a non-`Copy` `T` safely. This is bound on `T: Clone`;
-    /// callers that relied on shallow-copy-then-`deinitShallow` need a redesign.
     pub fn clone(&self) -> Result<Self, AllocError>
     where
         T: Clone,
@@ -187,7 +131,6 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn insert_assume_capacity(&mut self, i: usize, item: T) {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged.insert(i, item);
     }
 
@@ -201,7 +144,6 @@ impl<T> ArrayListAlignedIn<T> {
     where
         T: Clone,
     {
-        // Zig: `addManyAt` reserves `count` uninit slots at `index`, then `@memset(result, value)`.
         self.unmanaged
             .splice(index..index, core::iter::repeat_n(value, count));
         Ok(&mut self.unmanaged[index..index + count])
@@ -212,27 +154,23 @@ impl<T> ArrayListAlignedIn<T> {
     where
         T: Clone,
     {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged
             .splice(index..index, core::iter::repeat_n(value, count));
         &mut self.unmanaged[index..index + count]
     }
 
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items`.
     pub fn insert_slice(&mut self, index: usize, new_items: &[T]) -> Result<(), AllocError>
     where
         T: Clone,
     {
-        // TODO(port): Zig takes `[]const T` and bit-copies, transferring ownership. Rust must
-        // `Clone` from a borrowed slice. If callers own the data, change signature to
-        // `impl IntoIterator<Item = T>` to avoid the clone.
         self.unmanaged
             .splice(index..index, new_items.iter().cloned());
         Ok(())
     }
 
     /// This method `Drop`s the removed items.
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn replace_range(
         &mut self,
         start: usize,
@@ -242,20 +180,18 @@ impl<T> ArrayListAlignedIn<T> {
     where
         T: Clone,
     {
-        // PORT NOTE: Zig deinits `items[start..start+len]` then calls the shallow path.
-        // `Vec::splice` already drops the removed range, so deep == direct splice.
+        // `Vec::splice` drops the removed range.
         self.unmanaged
             .splice(start..start + len, new_items.iter().cloned());
         Ok(())
     }
 
     /// This method `Drop`s the removed items.
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn replace_range_assume_capacity(&mut self, start: usize, len: usize, new_items: &[T])
     where
         T: Clone,
     {
-        // PERF(port): was assume_capacity — profile if hot.
         let _ = self.replace_range(start, len, new_items);
     }
 
@@ -265,7 +201,6 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn append_assume_capacity(&mut self, item: T) {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged.push(item);
     }
 
@@ -277,43 +212,39 @@ impl<T> ArrayListAlignedIn<T> {
         self.unmanaged.swap_remove(i)
     }
 
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn append_slice(&mut self, new_items: &[T]) -> Result<(), AllocError>
     where
         T: Clone,
     {
-        // TODO(port): see `insert_slice` note re: Clone vs ownership transfer.
         self.unmanaged.extend_from_slice(new_items);
         Ok(())
     }
 
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn append_slice_assume_capacity(&mut self, new_items: &[T])
     where
         T: Clone,
     {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged.extend_from_slice(new_items);
     }
 
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn append_unaligned_slice(&mut self, new_items: &[T]) -> Result<(), AllocError>
     where
         T: Clone,
     {
-        // TODO(port): Zig `[]align(1) const T` allows reading T from an under-aligned address.
-        // Rust `&[T]` is always naturally aligned. If a caller truly has unaligned bytes, it
-        // needs `ptr::read_unaligned` at the call site. Treat as aligned here.
+        // Rust `&[T]` is always naturally aligned, so this is identical to `append_slice`; a
+        // caller that truly has unaligned bytes needs `ptr::read_unaligned` at the call site.
         self.unmanaged.extend_from_slice(new_items);
         Ok(())
     }
 
-    /// This method takes ownership of all elements in `new_items`.
+    /// Note that this `Clone`s each element of `new_items` (see `insert_slice`).
     pub fn append_unaligned_slice_assume_capacity(&mut self, new_items: &[T])
     where
         T: Clone,
     {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged.extend_from_slice(new_items);
     }
 
@@ -333,7 +264,6 @@ impl<T> ArrayListAlignedIn<T> {
     where
         T: Clone,
     {
-        // PERF(port): was assume_capacity — profile if hot.
         self.unmanaged.extend(core::iter::repeat_n(value, n));
     }
 
@@ -345,10 +275,6 @@ impl<T> ArrayListAlignedIn<T> {
     where
         T: Clone,
     {
-        // PORT NOTE: Zig calls `resizeWithoutDeinit` first, *then* deinits the tail via a raw
-        // pointer past `len` (`items().ptr[new_len..len]`). That ordering is to avoid a failed
-        // realloc leaving already-deinited items in the list. `Vec::resize` already drops the
-        // truncated tail in the shrink case and never fails, so the ordering concern vanishes.
         self.unmanaged.resize(new_len, init_value);
         Ok(())
     }
@@ -356,7 +282,7 @@ impl<T> ArrayListAlignedIn<T> {
     /// This method `Drop`s the removed items.
     pub fn shrink_and_free(&mut self, new_len: usize) {
         self.prepare_for_deep_shrink(new_len);
-        // PORT NOTE: `prepare_for_deep_shrink` already truncated (dropping items); now free.
+        // `prepare_for_deep_shrink` already truncated (dropping items); now free.
         self.unmanaged.shrink_to_fit();
     }
 
@@ -368,14 +294,12 @@ impl<T> ArrayListAlignedIn<T> {
 
     /// This method `Drop`s all items.
     pub fn clear_retaining_capacity(&mut self) {
-        // Zig: `bun.memory.deinit(self.items()); self.clearRetainingCapacityShallow();`
-        // `Vec::clear` drops all items and retains capacity — exactly the deep semantics.
+        // `Vec::clear` drops all items and retains capacity.
         self.unmanaged.clear();
     }
 
     /// This method `Drop`s all items.
     pub fn clear_and_free(&mut self) {
-        // Zig: `bun.memory.deinit(self.items()); self.clearAndFreeShallow();`
         self.unmanaged = Vec::new();
     }
 
@@ -401,7 +325,6 @@ impl<T> ArrayListAlignedIn<T> {
     {
         let len = self.unmanaged.len();
         let cap = self.unmanaged.capacity();
-        // Zig: `self.#unmanaged.expandToCapacity(); @memset(self.items()[len..], init_value);`
         self.unmanaged
             .extend(core::iter::repeat_n(init_value, cap - len));
         debug_assert_eq!(self.unmanaged.len(), cap);
@@ -412,13 +335,11 @@ impl<T> ArrayListAlignedIn<T> {
     }
 
     pub fn get_last(&self) -> &T {
-        // Zig: `&items_[items_.len - 1]` — panics on empty, same as `[len-1]` here.
+        // Panics on empty.
         let items = self.items();
         &items[items.len() - 1]
     }
 
-    // PORT NOTE: Zig returns `*T` (mutable) from a `*const Self` receiver via interior aliasing.
-    // Rust splits this into `&T` / `&mut T` accessors.
     pub fn get_last_mut(&mut self) -> &mut T {
         let len = self.unmanaged.len();
         &mut self.unmanaged[len - 1]
@@ -442,18 +363,15 @@ impl<T> ArrayListAlignedIn<T> {
             new_len <= items_len,
             "new_len ({new_len}) cannot exceed current len ({items_len})",
         );
-        // Zig: `bun.memory.deinit(items_[new_len..])` — drop the tail in place.
-        // `Vec::truncate` does exactly that and keeps capacity.
+        // `Vec::truncate` drops the tail in place and keeps capacity.
         self.unmanaged.truncate(new_len);
     }
-
-    // Zig `getStdAllocator` — dropped (no allocator field).
 }
 
-// PORT NOTE: Zig `pub fn deinit` → `impl Drop`. The Zig body is
-//   `bun.memory.deinit(self.items()); self.deinitShallow();`
-// i.e. drop every item, then free the backing buffer. `Vec<T>`'s own `Drop` does both, so per
-// PORTING.md ("If the body only frees/deinits owned fields, delete the body entirely") no
-// explicit `impl Drop for ArrayListAlignedIn<T>` is written.
-
-// ported from: src/collections/array_list.zig
+impl ArrayListAlignedIn<u8> {
+    /// Hands out the backing `Vec<u8>`, which already implements `std::io::Write`.
+    /// Only exposed for `T = u8` — there is no meaningful writer for other element types.
+    pub fn writer(&mut self) -> &mut Vec<u8> {
+        &mut self.unmanaged
+    }
+}
diff --git a/src/collections/bit_set.rs b/src/collections/bit_set.rs
index fb2015c0a2f..c1b843e5139 100644
--- a/src/collections/bit_set.rs
+++ b/src/collections/bit_set.rs
@@ -1,8 +1,3 @@
-//! This is a fork of Zig standard library bit_set.zig
-//! - https://github.com/ziglang/zig/pull/14129
-//! - AutoBitset which optimally chooses between a dynamic or static bitset.
-//! Prefer our fork over std.bit_set.
-//!
 //! This file defines several variants of bit sets.  A bit set
 //! is a densely stored set of integers with a known maximum,
 //! in which each integer gets a single bit.  Bit sets have very
@@ -43,22 +38,21 @@ use bun_alloc::AllocError;
 
 // ───────────────────────────── helpers ─────────────────────────────
 
-/// Equivalent to `std.math.boolMask(MaskInt, value)`: returns `~0` if `value`
-/// else `0`, in the requested integer width.
+/// Returns `usize::MAX` if `value`, else `0`.
 #[inline(always)]
 const fn bool_mask_usize(value: bool) -> usize {
     if value { usize::MAX } else { 0 }
 }
 
 /// `1 << (index % usize::BITS)` — selects the bit within a `usize` word.
-/// Shared by `ArrayBitSet` and `DynamicBitSetUnmanaged` (Zig: `maskBit`).
+/// Shared by `ArrayBitSet` and `DynamicBitSetUnmanaged`.
 #[inline(always)]
 const fn word_mask_bit(index: usize) -> usize {
     1usize << ((index as u32) & (usize::BITS - 1)) // @truncate
 }
 
 /// `index / usize::BITS` — selects which `usize` word holds the bit.
-/// Shared by `ArrayBitSet` and `DynamicBitSetUnmanaged` (Zig: `maskIndex`).
+/// Shared by `ArrayBitSet` and `DynamicBitSetUnmanaged`.
 #[inline(always)]
 const fn word_mask_index(index: usize) -> usize {
     index >> usize::BITS.trailing_zeros()
@@ -66,7 +60,7 @@ const fn word_mask_index(index: usize) -> usize {
 
 /// Shared multi-mask implementation of `set_range_value` over `&mut [usize]`
 /// storage. Used by both `ArrayBitSet` and `DynamicBitSetUnmanaged` so the
-/// per-word range masking logic lives in one place (Zig: `setRangeValue`).
+/// per-word range masking logic lives in one place.
 #[inline]
 fn set_range_value_masks(masks: &mut [usize], range: Range, value: bool) {
     const MASK_LEN: u32 = usize::BITS;
@@ -117,13 +111,11 @@ fn set_range_value_masks(masks: &mut [usize], range: Range, value: bool) {
 /// can be copied by value, and does not require deinitialization.
 /// Both possible implementations fulfill the same interface.
 ///
-// TODO(port): Zig's `StaticBitSet(size)` returns `IntegerBitSet(size)` when
-// `size <= @bitSizeOf(usize)` and `ArrayBitSet(usize, size)` otherwise. Stable
-// Rust cannot select a struct definition from a const generic. Callers should
-// pick `IntegerBitSet<N>` or `ArrayBitSet<N>` directly; this alias resolves to
-// the array form (always correct, possibly one word larger than needed for
-// N <= 64).
-pub type StaticBitSet<const SIZE: usize> = IntegerBitSet<SIZE>; // TODO(b2): callers needing >64 bits use ArrayBitSet<SIZE, {num_masks_for(SIZE)}> directly
+// Stable Rust cannot select a struct definition from a const generic, so this
+// alias is the integer form and is only valid for `SIZE <= usize::BITS`
+// (enforced by `IntegerBitSet`'s debug asserts). Callers needing more bits
+// must use `ArrayBitSet<SIZE, { num_masks_for(SIZE) }>` directly.
+pub type StaticBitSet<const SIZE: usize> = IntegerBitSet<SIZE>;
 
 // ───────────────────────────── IntegerBitSet ─────────────────────────────
 
@@ -131,10 +123,8 @@ pub type StaticBitSet<const SIZE: usize> = IntegerBitSet<SIZE>; // TODO(b2): cal
 /// This set is good for sets with a small size, but may generate
 /// inefficient code for larger sets, especially in debug mode.
 ///
-// TODO(port): Zig uses `std.meta.Int(.unsigned, size)` for an exact-width
-// backing integer (u0..u65535). Rust has no arbitrary-width ints; we back with
-// `usize` and rely on `SIZE <= usize::BITS`. Phase B may swap to a trait that
-// picks u8/u16/u32/u64/u128.
+// Backed by `usize`; requires `SIZE <= usize::BITS` (misuse surfaces via
+// `FULL_MASK` saturation + debug asserts).
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct IntegerBitSet<const SIZE: usize> {
@@ -220,12 +210,10 @@ impl<const SIZE: usize> IntegerBitSet<SIZE> {
         let mut mask = bool_mask_usize(true) << start_bit;
         if range.end != Self::BIT_LENGTH {
             let end_bit = u32::try_from(range.end).expect("int cast");
-            // Zig shifts a SIZE-bit MaskInt so `~0 >> (SIZE - end_bit)` yields the
-            // low `end_bit` bits. With a usize backing the shift must be relative
-            // to usize::BITS to get the same low-`end_bit`-bits mask.
+            // `~0 >> (usize::BITS - end_bit)` yields the low `end_bit` bits.
             mask &= bool_mask_usize(true) >> (usize::BITS - end_bit);
         }
-        // also clear bits above SIZE since our backing int is wider than Zig's
+        // also clear bits above SIZE since the backing `usize` may be wider than SIZE bits
         mask &= Self::FULL_MASK;
         self.mask &= !mask;
 
@@ -390,7 +378,7 @@ impl<const SIZE: usize> IntegerBitSet<SIZE> {
     }
 
     /// Iterate indices of set bits in ascending order.
-    /// Convenience wrapper for `iterator::<true, true>()` (Zig's `.iterator(.{ .kind = .set })`).
+    /// Convenience wrapper for `iterator::<true, true>()`.
     #[inline]
     pub fn iter_set(self) -> SingleWordIterator<SIZE, true> {
         self.iterator::<true, true>()
@@ -443,9 +431,6 @@ pub const fn num_masks_for(bit_length: usize) -> usize {
 /// A bit set with static size, which is backed by an array of usize.
 /// This set is good for sets with a larger size, but may use
 /// more bytes than necessary if your set is small.
-///
-// TODO(port): Zig is generic over `MaskIntType`; every in-tree caller uses
-// `usize`. Dropped the type parameter. Phase B can re-generify if needed.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct ArrayBitSet<const SIZE: usize, const NUM_MASKS: usize> {
@@ -760,12 +745,11 @@ impl<const SIZE: usize, const NUM_MASKS: usize> ArrayBitSet<SIZE, NUM_MASKS> {
 /// A bit set with runtime-known size, backed by an allocated slice
 /// of usize.  The allocator must be tracked externally by the user.
 ///
-// TODO(port): the Zig type stores `masks: [*]MaskInt` where `masks[-1]` holds
-// the true allocation length (needed because Zig's allocator API requires the
-// original length on free). The Rust port keeps the same layout because
-// `List` constructs borrowed views into a shared buffer that must look like
-// freestanding `DynamicBitSetUnmanaged`s. Phase B may refactor to `Vec<usize>`
-// once `List` is reworked.
+// Layout invariant: `masks` is a raw pointer where `masks[-1]` holds the true
+// allocation length (needed on free). This layout is load-bearing because
+// `DynamicBitSetList` constructs borrowed views into a shared buffer that must
+// look like freestanding `DynamicBitSetUnmanaged`s — do not swap the storage
+// for `Vec<usize>` without reworking `DynamicBitSetList`.
 pub struct DynamicBitSetUnmanaged {
     /// The number of valid items in this bit set
     pub bit_length: usize,
@@ -775,14 +759,12 @@ pub struct DynamicBitSetUnmanaged {
     pub masks: *mut usize,
     // This pointer is one usize after the actual allocation.
     // That slot holds the size of the true allocation, which
-    // is needed by Zig's allocator interface in case a shrink
-    // fails.
+    // is needed when freeing.
 }
 
 const DYN_MASK_BITS: u32 = usize::BITS;
 
-// Never modified — the Zig comment about needing `static mut` was a Zig
-// limitation (no const-ptr → mut-ptr cast at comptime). All writes through
+// Never modified. All writes through
 // `self.masks` are guarded by `num_masks() > 0`, which is false for the empty
 // sentinel (bit_length == 0). Kept in a `RacyCell` (not `.rodata`) so that
 // forming a `*mut usize` to it remains a legally-mutable pointer target —
@@ -814,10 +796,8 @@ impl Drop for DynamicBitSetUnmanaged {
 }
 
 impl DynamicBitSetUnmanaged {
-    pub const EMPTY: fn() -> Self = Self::default;
-    // TODO(port): Zig has `pub const empty: Self = .{ ... }` as a const value.
-    // Rust can't const-init a static-mut-derived pointer; callers should use
-    // `DynamicBitSetUnmanaged::default()`.
+    // There is no `const` empty value (the empty sentinel pointer is computed at
+    // runtime); use `Self::default()`.
 
     /// Borrow the mask words as a shared slice of length `num_masks(bit_length)`.
     #[inline(always)]
@@ -1381,9 +1361,8 @@ impl Drop for DynamicBitSetList {
 // the owning struct between threads is as safe as moving a `Box<[usize]>`.
 unsafe impl Send for DynamicBitSetList {}
 
-// Raw allocation helpers for DynamicBitSetUnmanaged. These mirror Zig's
-// allocator.alloc/realloc/free with the size-at-[-1] header convention.
-// TODO(port): move to bun_alloc if useful elsewhere.
+// Raw allocation helpers for DynamicBitSetUnmanaged, using the size-at-[-1]
+// header convention.
 
 unsafe fn dyn_free(base: *mut usize, len: usize) {
     if len == 0 {
@@ -1421,7 +1400,7 @@ unsafe fn dyn_realloc(
 
 // ───────────────────────────── AutoBitSet ─────────────────────────────
 
-/// Static arm size: `@bitSizeOf(DynamicBitSetUnmanaged) - 1`.
+/// Static arm size: one less than the bit-size of `DynamicBitSetUnmanaged`.
 pub(crate) const AUTO_STATIC_BITS: usize = mem::size_of::<DynamicBitSetUnmanaged>() * 8 - 1;
 
 pub(crate) type AutoBitSetStatic =
@@ -1433,11 +1412,9 @@ pub enum AutoBitSet {
 }
 
 // ─── two-arm forward helper ────────────────────────────────────────────
-// Zig had `switch (this.*) { inline else => |*b| b.method() }` for the
-// symmetric arms (setAll/count/findFirstSet/Iterator.next). The Rust port
-// regressed those to open-coded matches; this macro restores the collapse
-// and is applied to every method whose Static/Dynamic arms are textually
-// identical. Asymmetric arms (clone, raw_bytes, has_intersection, Drop)
+// This macro forwards a call to whichever arm is active and is applied to
+// every method whose Static/Dynamic arms are textually identical.
+// Asymmetric arms (clone, raw_bytes, has_intersection, Drop)
 // stay open-coded — they genuinely differ.
 macro_rules! auto_forward {
     ($self:expr, |$b:ident| $body:expr) => {
@@ -1504,7 +1481,6 @@ impl AutoBitSet {
     }
 
     pub fn eql(&self, b: &AutoBitSet) -> bool {
-        // TODO(b0): `strings` arrives in bun_core via move-in (was bun_core::strings).
         self.raw_bytes() == b.raw_bytes()
     }
 
@@ -1559,10 +1535,6 @@ impl Drop for AutoBitSet {
 /// A bit set with runtime-known size, backed by an allocated slice
 /// of usize.  Thin wrapper around DynamicBitSetUnmanaged which keeps
 /// track of the allocator instance.
-///
-// TODO(port): in Rust the managed/unmanaged split disappears (global
-// allocator). This wrapper is kept for diff parity; Phase B may collapse it
-// into `DynamicBitSetUnmanaged` and re-export under both names.
 #[derive(Default)]
 pub struct DynamicBitSet {
     /// The number of valid items in this bit set
@@ -1609,7 +1581,7 @@ impl DynamicBitSet {
         self.unmanaged.capacity()
     }
 
-    /// Zig spelling of `capacity()` (`.bit_length`).
+    /// Alias for `capacity()`.
     #[inline(always)]
     pub fn bit_length(&self) -> usize {
         self.unmanaged.capacity()
@@ -1761,9 +1733,7 @@ pub enum IteratorDirection {
 
 // ───────────────────────────── BitSetIterator ─────────────────────────────
 
-// The iterator is reusable between several bit set types
-// TODO(port): Zig is generic over `MaskInt`; fixed to `usize` here since every
-// in-tree caller uses `usize`.
+// The iterator is reusable between several bit set types.
 pub struct BitSetIterator<'a, const KIND_SET: bool, const DIR_FWD: bool> {
     // all bits which have not yet been iterated over
     bits_remain: usize,
@@ -1863,11 +1833,3 @@ pub struct Range {
     /// The index immediately after the last bit of interest.
     pub end: usize,
 }
-
-// ───────────────────────────── Tests ─────────────────────────────
-
-// TODO(port): the Zig source's test helpers (`testEql`, `testBitSet`, …) are
-// dead code carried from the std fork — no `test` block invokes them. They
-// rely on `anytype` duck-typing; re-author against a trait when adding tests.
-
-// ported from: src/collections/bit_set.zig
diff --git a/src/collections/comptime_string_map.rs b/src/collections/comptime_string_map.rs
index 59db5df0222..a2d68d57e4a 100644
--- a/src/collections/comptime_string_map.rs
+++ b/src/collections/comptime_string_map.rs
@@ -1,22 +1,16 @@
 //! Comptime string map optimized for small sets of disparate string keys.
-//! Works by separating the keys by length at comptime and only checking strings of
+//! Works by separating the keys by length up front and only checking strings of
 //! equal length at runtime.
 //!
 //! `kvs` expects a list literal containing list literals or an array/slice of structs
 //! where `.0` is the `&[u8]` key and `.1` is the associated value of type `V`.
-// TODO: https://github.com/ziglang/zig/issues/4335
-
-// PORT NOTE: The Zig original is a `fn(comptime KeyType, comptime V, comptime kvs_list) type`
-// that does heavy comptime work: sorts kvs by (len, bytes), builds a `len_indexes` table,
-// then every lookup is an `inline while` over lengths × `inline for` over same-length keys
-// with `eqlComptime` (length-known SIMD compare). Rust cannot replicate the per-callsite
-// monomorphization without a proc-macro, so this models it as a const-constructed struct
-// holding the precomputed tables plus a `comptime_string_map!` macro that callers use.
-// Runtime loops replace `inline for`/`inline while`; each is tagged `PERF(port)`.
+
+// A struct holding precomputed tables (kvs sorted by (len, bytes), plus a `len_indexes`
+// table), built via the `comptime_string_map!` macro that callers use.
 //
-// Per PORTING.md crate-map, downstream callers of `bun.ComptimeStringMap(V, .{...})` should
-// prefer `phf::phf_map!` directly when they only need `.get()`/`.has()`. This struct exists
-// for the call sites that need `get_with_eql` / `get_any_case` / `index_of` / `get_key`.
+// Downstream callers should prefer `phf::phf_map!` directly when they only need
+// `.get()`/`.has()`. This struct exists for the call sites that need `get_with_eql` /
+// `get_any_case` / `index_of` / `get_key`.
 
 use bun_core::strings;
 
@@ -35,8 +29,7 @@ pub struct ComptimeStringMapWithKeyType<
     const N: usize,
     const LEN_TABLE: usize,
 > {
-    // PORT NOTE: in Zig these were `precomputed.{min_len,max_len,sorted_kvs,len_indexes}`
-    // computed in a `comptime blk:`. Here they are filled by the constructor macro.
+    // Filled by the constructor macro.
     min_len: usize,
     max_len: usize,
     /// Sorted ascending by (key.len, key bytes).
@@ -48,8 +41,7 @@ pub struct ComptimeStringMapWithKeyType<
 pub type ComptimeStringMap<V, const N: usize, const LEN_TABLE: usize> =
     ComptimeStringMapWithKeyType<u8, V, N, LEN_TABLE>;
 
-/// Trait abstracting "has a length" for `get_with_eql` inputs — Zig used
-/// `if (@hasField(Input, "len")) input.len else input.length()`.
+/// Trait abstracting "has a length" for `get_with_eql` inputs.
 pub trait HasLength {
     fn length(&self) -> usize;
 }
@@ -65,7 +57,6 @@ impl<T> HasLength for &[T] {
         (*self).len()
     }
 }
-// TODO(port): `String` arrives in bun_alloc via move-in (was bun_core::String — same-tier cycle).
 impl HasLength for &bun_alloc::String {
     #[inline]
     fn length(&self) -> usize {
@@ -73,9 +64,6 @@ impl HasLength for &bun_alloc::String {
     }
 }
 
-// PORT NOTE: `pub const Value = V;` (inherent assoc type) is nightly-only;
-// callers can write `V` directly.
-
 impl<K, V, const N: usize, const LEN_TABLE: usize> ComptimeStringMapWithKeyType<K, V, N, LEN_TABLE>
 where
     K: Copy + Eq + Ord + 'static,
@@ -83,10 +71,8 @@ where
 {
     /// Builds the precomputed tables. Called by the `comptime_string_map!` macro.
     ///
-    /// Mirrors the `comptime blk:` in the Zig: sort by (len asc, bytes asc), then
-    /// fill `len_indexes[len]` = first index whose key.len >= len.
-    // TODO(port): make this a `const fn` once const-sort is stable, or move to build.rs.
-    // PERF(port): Zig did this at comptime (zero runtime cost); this runs once at init.
+    /// Sorts by (len asc, bytes asc), then fills `len_indexes[len]` = first index whose
+    /// key.len >= len.
     pub fn new(mut sorted_kvs: [KV<K, V>; N]) -> Self {
         // lenAsc comparator
         sorted_kvs.sort_by(|a, b| {
@@ -136,10 +122,6 @@ where
     }
 
     /// Contiguous range in `kvs` whose keys have exactly `len`.
-    ///
-    /// PORT NOTE: the .zig spec open-coded this at every lookup site because `len` was
-    /// `comptime` there and each needed its own `comptime brk:` block. In the Rust port
-    /// `len` is runtime, so the duplication is vestigial — extract once and inline.
     #[inline(always)]
     fn len_bucket(&self, len: usize) -> core::ops::Range<usize> {
         let start = self.len_indexes[len];
@@ -150,18 +132,15 @@ where
         start..end
     }
 
-    // PORT NOTE: `comptime len: usize` → runtime `len: usize`. The Zig used the comptime
-    // value to compute `end` at comptime and `inline for` the range; we loop at runtime.
-    // PERF(port): was comptime monomorphization — profile if hot.
     pub fn get_with_length(&self, str: &[K], len: usize) -> Option<V> {
         let core::ops::Range { start, end } = self.len_bucket(len);
 
         // This benchmarked faster for both small and large lists of strings than using a big switch statement
         // But only so long as the keys are a sorted list.
         for i in start..end {
-            // PERF(port): Zig used `strings.eqlComptimeCheckLenWithType(K, str, kvs[i].key, false)`
-            // (length-known SIMD compare). Plain slice == here; could swap to
-            // `bun_core::strings::eql_comptime_check_len_with_type` if hot.
+            // PERF: plain slice == here; could swap to
+            // `bun_core::strings::eql_comptime_check_len_with_type`
+            // (length-known SIMD compare) if hot.
             if str == self.kvs[i].key {
                 return Some(self.kvs[i].value);
             }
@@ -183,7 +162,6 @@ where
 
         // This benchmarked faster for both small and large lists of strings than using a big switch statement
         // But only so long as the keys are a sorted list.
-        // PERF(port): was `inline for` — profile if hot.
         for i in start..end {
             if eqls(str, self.kvs[i].key) {
                 return Some(self.kvs[i].value);
@@ -198,8 +176,6 @@ where
             return None;
         }
 
-        // PERF(port): Zig `inline while (i <= max_len)` dispatched to a monomorphized
-        // `getWithLength(str, comptime i)`. We call the runtime version directly.
         self.get_with_length(str, str.len())
     }
 
@@ -214,14 +190,11 @@ where
 
         // This benchmarked faster for both small and large lists of strings than using a big switch statement
         // But only so long as the keys are a sorted list.
-        // PERF(port): was `inline for` over comptime range.
         (start..end).find(|&i| str == self.kvs[i].key)
     }
 
-    // TODO(port): move to *_jsc — `fromJS` / `fromJSCaseInsensitive` were thin shims to
-    // `jsc/comptime_string_map_jsc.zig`. In Rust these become extension-trait methods in
-    // `bun_jsc` (e.g. `impl<V> ComptimeStringMapJsc for ComptimeStringMap<V, ..>`).
-    // The base `bun_collections` crate has no JSC dependency.
+    // `fromJS` / `fromJSCaseInsensitive` live in `src/jsc/comptime_string_map_jsc.rs`
+    // (the base `bun_collections` crate has no JSC dependency).
 
     pub fn get_with_eql<I>(&self, input: I, eql: impl Fn(I, &'static [K]) -> bool) -> Option<V>
     where
@@ -232,7 +205,6 @@ where
             return None;
         }
 
-        // PERF(port): was `inline while` dispatch to comptime-len variant.
         self.get_with_length_and_eql(input, length, eql)
     }
 
@@ -243,7 +215,6 @@ where
     where
         V: PartialEq,
     {
-        // PERF(port): was `inline for` — profile if hot.
         for kv in &self.kvs {
             if kv.value == value {
                 return Some(kv.key);
@@ -258,9 +229,8 @@ impl<V, const N: usize, const LEN_TABLE: usize> ComptimeStringMapWithKeyType<u8,
 where
     V: Copy + 'static,
 {
-    // PORT NOTE: Zig `fromString` calls `bun.String.eqlComptime`, which compares against
-    // `[]const u8` — effectively u8-only. Lives in the K=u8 impl, not the generic one.
-    // TODO(port): `String` arrives in bun_alloc via move-in (was bun_core::String).
+    // `bun_alloc::String::eql_comptime` compares against `&[u8]` — effectively u8-only,
+    // so this lives in the K=u8 impl, not the generic one.
     pub fn from_string(&self, str: &bun_alloc::String) -> Option<V> {
         self.get_with_eql(str, bun_alloc::String::eql_comptime)
     }
@@ -279,12 +249,17 @@ where
             return None;
         }
 
-        // PERF(port): Zig built a `[i]u8` stack buffer per comptime length; we use a
-        // bounded stack buffer sized to max_len. Profile if it shows up on a hot path.
-        // TODO(port): if max_len can exceed a small bound at any call site, revisit.
-        let mut buf = [0u8; 256];
-        debug_assert!(length <= buf.len());
-        let lowercased = bun_core::strings::copy_lowercase(input, &mut buf[..length]);
+        // Bounded stack buffer for the common case (every in-tree map has small keys);
+        // fall back to a heap buffer for maps whose keys exceed it.
+        let mut stack_buf = [0u8; 256];
+        let mut heap_buf: Vec<u8>;
+        let buf: &mut [u8] = if length <= stack_buf.len() {
+            &mut stack_buf[..length]
+        } else {
+            heap_buf = vec![0u8; length];
+            &mut heap_buf[..]
+        };
+        let lowercased = bun_core::strings::copy_lowercase(input, buf);
 
         self.get_with_length_and_eql(lowercased, length, eql)
     }
@@ -299,14 +274,12 @@ where
 ///     ...
 /// ]);
 /// ```
-// TODO(port): proc-macro — Zig sorted + built len_indexes at comptime. A `macro_rules!`
-// cannot sort; either (a) require callers pre-sort and compute LEN_TABLE, (b) use a
-// proc-macro, or (c) lazy-init via `once_cell::Lazy` + `ComptimeStringMapWithKeyType::new`.
-// Currently uses (c) for correctness; could upgrade to a proc-macro for true const.
+// A `macro_rules!` cannot sort, so this lazy-inits via `once_cell::Lazy` +
+// `ComptimeStringMapWithKeyType::new` — correct, with a one-time runtime init cost
+// instead of true const construction.
 #[macro_export]
 macro_rules! comptime_string_map {
     ($V:ty, [ $( ($key:expr, $val:expr) ),* $(,)? ]) => {{
-        // PERF(port): was comptime; now lazy runtime init.
         ::once_cell::sync::Lazy::new(|| {
             $crate::comptime_string_map::ComptimeStringMapWithKeyType::<u8, $V, _, _>::new([
                 $( $crate::comptime_string_map::KV { key: $key, value: $val } ),*
@@ -376,8 +349,6 @@ mod tests {
 
     #[test]
     fn comptime_string_map_array_of_structs() {
-        // PORT NOTE: Zig tested that anonymous-struct and named-struct kv inputs both work.
-        // In Rust there is one input shape (`KV`), so this collapses to the same test.
         let map = ComptimeStringMapWithKeyType::<u8, TestEnum, 5, 9>::new([
             KV {
                 key: b"these",
@@ -495,9 +466,7 @@ mod tests {
         test_set(&map);
     }
 
-    // PORT NOTE: `TestEnum2` + its 39-entry `map`/`official` table existed only as a
-    // benchmark fixture against `std.ComptimeStringMap` (no `test` block references it).
+    // `TestEnum2` + its 39-entry `map`/`official` table existed only as a
+    // benchmark fixture (no `test` block references it).
     // Omitted; can re-add as a criterion bench if needed.
 }
-
-// ported from: src/collections/comptime_string_map.zig
diff --git a/src/collections/hive_array.rs b/src/collections/hive_array.rs
index 20761f9a912..4570ebd467a 100644
--- a/src/collections/hive_array.rs
+++ b/src/collections/hive_array.rs
@@ -8,8 +8,6 @@ use bun_core::asan;
 
 /// Fixed-width occupancy bitset for [`HiveArray`].
 ///
-/// PORT NOTE: Zig's `std.bit_set.IntegerBitSet(N)` is backed by an exact-width
-/// `uN` integer (`u128`, `u256`, `u2048`, …). The Rust port's
 /// [`IntegerBitSet`](crate::bit_set::IntegerBitSet) is backed by a single
 /// `usize`, so for `N > 64` it silently held only 64 usable bits — every
 /// `HiveArray<_, 128/256/2048>` pool degraded to 64 effective slots and spilled
@@ -171,8 +169,6 @@ impl<const CAPACITY: usize> HiveBitSetIter<CAPACITY> {
 /// All slot operations take `&self` and the buffer is `UnsafeCell` — slot
 /// pointers come from `UnsafeCell::get()` and so survive `&self` reborrows of
 /// the pool (the `bumpalo` / `typed-arena` shape). `HiveArray` is `!Sync`.
-// PORT NOTE: Zig's `capacity: u16` is widened to `usize` here because Rust array
-// lengths require a `usize` const generic on stable.
 pub struct HiveArray<T, const CAPACITY: usize> {
     buffer: UnsafeCell<[MaybeUninit<T>; CAPACITY]>,
     pub used: HiveBitSet<CAPACITY>,
@@ -181,10 +177,6 @@ pub struct HiveArray<T, const CAPACITY: usize> {
 impl<T, const CAPACITY: usize> HiveArray<T, CAPACITY> {
     pub const SIZE: usize = CAPACITY;
 
-    // PORT NOTE: Zig had `pub var empty: Self` as a mutable static to work around
-    // https://github.com/ziglang/zig/issues/22462 and /21988. Rust has no such
-    // limitation; callers should use `init()` (which is `const`).
-
     pub const fn init() -> Self {
         Self {
             buffer: UnsafeCell::new([const { MaybeUninit::uninit() }; CAPACITY]),
@@ -338,7 +330,7 @@ impl<T, const CAPACITY: usize> HiveArray<T, CAPACITY> {
     /// into this hive, returns `false` and is a no-op. Use when the caller has
     /// already moved the contents out / destructured them, or when `T` is POD
     /// and the slot is being released on an error path before it was fully
-    /// initialized (Zig `value.* = undefined`).
+    /// initialized.
     ///
     /// # Safety
     /// No live token ([`HiveSlot`], [`HiveBox`]) may exist for this slot — once
@@ -403,9 +395,7 @@ impl<T, const CAPACITY: usize> HiveArray<T, CAPACITY> {
         debug_assert!(self.used.is_set(index as usize));
         debug_assert!(self.ptr_at(index as usize).cast_const() == value.cast_const());
 
-        // PORT NOTE: Zig wrote `value.* = undefined;` — Zig has no destructors,
-        // so the slot was simply marked logically uninitialized. In the Rust
-        // port several `T` carry owned heap data (e.g. `NumberScope.name_counts:
+        // Several `T` carry owned heap data (e.g. `NumberScope.name_counts:
         // StringHashMap`, `NetworkTask.url_buf: Box<[u8]>`); drop the slot
         // before recycling so the put/get cycle does not leak it. Callers that
         // pre-clean fields (`PooledSocket::release_parked_refs`) leave only
@@ -589,15 +579,11 @@ impl<T, const CAPACITY: usize> Drop for HiveBox<'_, T, CAPACITY> {
     }
 }
 
-// PORT NOTE: In Zig this was the nested type `HiveArray(T, capacity).Fallback`.
-// Rust cannot nest a generic struct that captures outer generics, so it lives at
-// module scope with the same parameters. The Zig field
-// `hive: if (capacity > 0) Self else void` is always materialized here; the
-// `CAPACITY > 0` checks below preserve the original gating.
-// PERF(port): zero-capacity case carried a zero-size hive in Zig — profile in Phase B.
+// Rust cannot nest a generic struct that captures outer generics, so this lives
+// at module scope with the same parameters as `HiveArray`. The hive is always
+// materialized; the `CAPACITY > 0` checks below gate its use.
 pub struct Fallback<T, const CAPACITY: usize> {
     pub hive: HiveArray<T, CAPACITY>,
-    // PORT NOTE: `std.mem.Allocator param` dropped — global mimalloc.
 }
 
 impl<T, const CAPACITY: usize> Fallback<T, CAPACITY> {
@@ -635,7 +621,7 @@ impl<T, const CAPACITY: usize> Fallback<T, CAPACITY> {
     /// for `MaybeUninit`).
     ///
     /// The returned allocation is leaked — callers stash it in a per-thread
-    /// static for the process lifetime (Zig: `threadlocal var pool`).
+    /// static for the process lifetime.
     #[inline]
     pub fn new_boxed() -> NonNull<Self> {
         let mut boxed = Box::<Self>::new_uninit();
@@ -768,14 +754,12 @@ impl<T, const CAPACITY: usize> Fallback<T, CAPACITY> {
 // HiveRef
 // ──────────────────────────────────────────────────────────────────────────
 //
-// PORT NOTE: ground truth is `bun.HiveRef` in src/bun.zig. It lives here (not
-// in the `bun` crate) because every consumer names it through
+// Lives here (not in the `bun` crate) because every consumer names it through
 // `bun_collections::HiveRef`, and its only collaborator is `Fallback` above.
 //
-// Zig defines `const HiveAllocator = HiveArray(@This(), capacity).Fallback`
-// inside the returned struct; Rust spells the self-referential pool type out
-// as `Fallback<HiveRef<T, CAPACITY>, CAPACITY>`. CAPACITY is `usize` (widened
-// from Zig's `u16`) to line up with `HiveArray`/`Fallback`'s const generic.
+// The self-referential pool type is spelled out as
+// `Fallback<HiveRef<T, CAPACITY>, CAPACITY>`. CAPACITY is `usize` to line up
+// with `HiveArray`/`Fallback`'s const generic.
 
 /// Intrusive ref-counted slot allocated from a `HiveArray::Fallback` pool.
 /// `pool` is a BACKREF (LIFETIMES.tsv class) — the pool strictly outlives
@@ -791,7 +775,8 @@ pub struct HiveRef<T, const CAPACITY: usize> {
 }
 
 impl<T, const CAPACITY: usize> HiveRef<T, CAPACITY> {
-    /// Zig: `pub fn init(value, allocator) !*@This()`.
+    /// Allocate a slot from `pool` (heap fallback when full) and initialize it
+    /// with `value` at refcount 1.
     ///
     /// # Safety
     /// `pool` must be valid for the entire lifetime of the returned
@@ -816,8 +801,8 @@ impl<T, const CAPACITY: usize> HiveRef<T, CAPACITY> {
         self
     }
 
-    /// Zig: `pub fn unref(this) ?*@This()` — returns `None` when the count hit
-    /// zero and the slot was returned to the pool.
+    /// Returns `None` when the count hit zero and the slot was returned to
+    /// the pool.
     ///
     /// # Safety
     /// `this` must point at a live `HiveRef` produced by [`init`](Self::init).
@@ -825,8 +810,7 @@ impl<T, const CAPACITY: usize> HiveRef<T, CAPACITY> {
     pub unsafe fn unref(this: *mut Self) -> Option<*mut Self> {
         // SAFETY: caller contract — `this` is a live `HiveRef` slot, and
         // `(*this).pool` outlives every slot it hands out (`init` contract).
-        // Zig's `if @hasDecl(T, "deinit") this.value.deinit()` maps to `T::drop`,
-        // which `Fallback::put` runs (drops the whole `HiveRef` in place).
+        // `Fallback::put` runs `T::drop` (drops the whole `HiveRef` in place).
         unsafe {
             let ref_count = (*this).ref_count.get();
             (*this).ref_count.set(ref_count - 1);
@@ -941,7 +925,6 @@ mod tests {
         const SIZE: usize = 64;
 
         // Choose an integer with a weird alignment
-        // PORT NOTE: Zig used `u127`; Rust has no arbitrary-width ints. `u128` is the closest.
         type Int = u128;
 
         let a = HiveArray::<Int, SIZE>::init();
@@ -1486,5 +1469,3 @@ mod tests {
         assert!(unsafe { pool.box_at(999) }.is_none());
     }
 }
-
-// ported from: src/collections/hive_array.zig
diff --git a/src/collections/identity_context.rs b/src/collections/identity_context.rs
index 0bfd37eac63..5539c7fab92 100644
--- a/src/collections/identity_context.rs
+++ b/src/collections/identity_context.rs
@@ -1,7 +1,6 @@
 use core::marker::PhantomData;
 
-/// Trait covering the Zig `@typeInfo(Key)` switch in `IdentityContext.hash`:
-/// `.@"enum" => @intFromEnum(key)`, `.int => key`, `else => @compileError(...)`.
+/// Trait for keys usable with `IdentityContext`.
 /// Implement for any int (`self as u64`) or `#[repr(uN)]` enum (`self as uN as u64`).
 pub trait IdentityHash: Copy + Eq {
     fn identity_hash(self) -> u64;
@@ -22,7 +21,6 @@ pub struct IdentityContext<Key>(PhantomData<Key>);
 
 impl<Key: IdentityHash> IdentityContext<Key> {
     pub fn hash(self, key: Key) -> u64 {
-        // Zig: switch (comptime @typeInfo(Key)) { .@"enum" => @intFromEnum(key), .int => key, else => @compileError }
         key.identity_hash()
     }
 
@@ -59,8 +57,8 @@ impl ArrayIdentityContextU64 {
     }
 }
 
-// Zig's `ArrayIdentityContext.U64` nesting — inherent assoc types are unstable,
-// so expose as a free path alias instead. Callers: `identity_context::U64`.
+// Inherent assoc types are unstable, so expose this as a free path alias.
+// Callers: `identity_context::U64`.
 pub type U64 = ArrayIdentityContextU64;
 
 // ArrayHashMap requires `C: ArrayHashContext<K>`, so wire the inherent impls
@@ -88,5 +86,3 @@ impl crate::array_hash_map::ArrayHashContext<u64> for ArrayIdentityContextU64 {
         a == b
     }
 }
-
-// ported from: src/collections/identity_context.zig
diff --git a/src/collections/lib.rs b/src/collections/lib.rs
index 10e8ad091f9..4f24bb75e06 100644
--- a/src/collections/lib.rs
+++ b/src/collections/lib.rs
@@ -1,5 +1,4 @@
-//! bun_collections — crate root.
-//! Thin re-export hub mirroring `src/collections/collections.zig`.
+//! bun_collections — crate root. Thin re-export hub.
 
 #![feature(
     type_info,
@@ -24,9 +23,6 @@ pub use bun_core::bounded_array;
 pub mod identity_context;
 pub mod linear_fifo;
 
-// TODO(b2-large): heavy nightly-feature usage (adt_const_params for enum-typed
-// const generics, generic_const_exprs, inherent assoc types). Rewrite to
-// stable: enum const params → const usize/bool, inherent assoc → free aliases.
 pub mod bit_set;
 pub mod pool;
 pub use pool::{ObjectPool, ObjectPoolTrait, ObjectPoolType, PoolGuard};
@@ -55,16 +51,15 @@ pub use bit_set::{
 // from here); canonical impl lives in `bun_core::strings`.
 pub use bun_core::strings::{const_bytes_eq, const_str_eq};
 
-/// `bun.bit_set` namespace alias (Zig: `bun.bit_set.List`).
+/// Namespace alias for the bit-set types.
 pub mod dynamic_bit_set {
     pub use super::bit_set::DynamicBitSet;
     pub use super::bit_set::DynamicBitSetList as List;
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `PriorityQueue` — port of `std.PriorityQueue(T, Context, lessThan)`.
-// Min-heap backed by a `Vec<T>`; the comparator context is held by value so
-// callers can rebind it (Zig stores `context: Context` directly on the queue).
+// `PriorityQueue` — min-heap backed by a `Vec<T>`; the comparator context is
+// held by value so callers can rebind it.
 // ──────────────────────────────────────────────────────────────────────────
 pub trait PriorityCompare<T> {
     fn compare(&self, a: &T, b: &T) -> core::cmp::Ordering;
@@ -101,7 +96,7 @@ impl<T, C> PriorityQueue<T, C> {
     }
 }
 impl<T: Copy, C: PriorityCompare<T>> PriorityQueue<T, C> {
-    /// Zig: `add(elem) !void` — push and sift-up.
+    /// Push and sift-up.
     pub fn add(&mut self, elem: T) -> Result<(), bun_alloc::AllocError> {
         self.items.push(elem);
         let mut child = self.items.len() - 1;
@@ -120,7 +115,7 @@ impl<T: Copy, C: PriorityCompare<T>> PriorityQueue<T, C> {
         }
         Ok(())
     }
-    /// Zig: `removeOrNull()` — pop min, sift-down; `None` when empty.
+    /// Pop min, sift-down; `None` when empty.
     pub fn remove_or_null(&mut self) -> Option<T> {
         if self.items.is_empty() {
             return None;
@@ -190,10 +185,10 @@ pub use bun_ptr::tagged_pointer::{TaggedPtr as TaggedPointer, TaggedPtrUnion};
 pub use bun_ptr::{RawSlice, detach_lifetime, detach_ref};
 
 // ──────────────────────────────────────────────────────────────────────────
-// SmallList — `bun.SmallList(T, N)` (Zig: src/css/small_list.zig).
+// SmallList
 //
 // Thin `#[repr(transparent)]` newtype over `smallvec::SmallVec<[T; N]>` that
-// preserves the Zig-named API surface (`append`, `slice`, `at`, `len()->u32`,
+// preserves the existing API surface (`append`, `slice`, `at`, `len()->u32`,
 // `init_capacity`, …) so the ~300 CSS-parser call sites stay untouched.
 // Replaces the bespoke ~800-line `Data`/`HeapData` union + raw-ptr container
 // that previously lived in `bun_css::small_list` (which was itself a port of
@@ -337,7 +332,7 @@ impl<T, const N: usize> SmallList<T, N> {
         // invariant of `from_raw_parts` is never exercised.
         Self(unsafe { smallvec::SmallVec::from_raw_parts(slab.as_mut_ptr(), len, len) })
     }
-    /// Zig `fromList` / `fromBabyList` — adopt a `Vec<T>` as the heap buffer
+    /// Adopt a `Vec<T>` as the heap buffer
     /// (O(1) header transfer; no element copy).
     #[inline]
     pub fn from_list(list: Vec<T>) -> Self {
@@ -345,7 +340,7 @@ impl<T, const N: usize> SmallList<T, N> {
     }
 
     // ── access ─────────────────────────────────────────────────────────────
-    /// Zig `len()` returns `u32` (not `usize`); preserved so the ~300 call-site
+    /// Returns `u32` (not `usize`); preserved so the ~300 call-site
     /// integer arithmetic in `bun_css` stays unchanged. Inherent shadows the
     /// `[T]::len()->usize` reachable via `Deref`.
     #[inline]
@@ -460,13 +455,17 @@ impl<T, const N: usize> SmallList<T, N> {
             self.0.reserve_exact(new_capacity as usize - cur);
         }
     }
-    /// Zig `setLen` — exposed as safe for API parity with the previous port
-    /// (whose only external caller shrinks to 0). Growing past the initialised
-    /// region is the caller's responsibility, same as before.
+    /// Exposed as safe: every current external caller only shrinks
+    /// (`new_len <= len`). Growing past the initialised region is the
+    /// caller's responsibility.
     #[inline]
     pub fn set_len(&mut self, new_len: u32) {
-        // SAFETY: matches the previous bun_css::SmallList::set_len contract
-        // (Zig callers treat this as a raw length store).
+        // SAFETY: a raw length store. All current external callers only
+        // shrink (`new_len <= self.len()`), so `[0..new_len]` stays
+        // initialised and `new_len <= capacity`, satisfying
+        // `SmallVec::set_len`'s preconditions (the truncated tail merely
+        // leaks). Any caller that grows takes responsibility for
+        // initialising the exposed region.
         unsafe { self.0.set_len(new_len as usize) }
     }
 
@@ -487,7 +486,7 @@ impl<T, const N: usize> SmallList<T, N> {
         Self(self.0.clone())
     }
 
-    // ── iteration helpers (Zig-named) ──────────────────────────────────────
+    // ── iteration helpers ───────────────────────────────────────────────────
     #[inline]
     pub fn any(&self, predicate: impl Fn(&T) -> bool) -> bool {
         self.0.iter().any(predicate)
@@ -501,12 +500,12 @@ impl<T, const N: usize> SmallList<T, N> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// HashMap — `std.AutoHashMap(K, V)` / `std.HashMap(K, V, Ctx, max_load)`.
+// HashMap
 //
-// Ported linear-probe layout (open-addressing, tombstones, power-of-two cap,
-// 80% load) so iteration order matches Zig exactly — required by callers that
+// Linear-probe layout (open-addressing, tombstones, power-of-two cap,
+// 80% load) with deterministic iteration order — required by callers that
 // snapshot the iteration sequence (lockfile debug stringify, etc.). The `Ctx`
-// type parameter is now load-bearing: `AutoHashContext` wyhashes the key,
+// type parameter is load-bearing: `AutoHashContext` wyhashes the key,
 // `IdentityContext<K>` uses `k as u64` so pre-hashed keys aren't re-hashed.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -526,21 +525,17 @@ pub mod hash_map {
         pub value_ptr: &'a mut V,
     }
 
-    /// Zig `std.HashMap.KV` — owned `{key, value}` pair returned from
-    /// `fetchRemove` / `fetchPut`. Identical to `std.ArrayHashMap.KV`; re-exported
-    /// from `array_hash_map` rather than duplicated.
+    /// Owned `{key, value}` pair returned from `fetchRemove` / `fetchPut`;
+    /// re-exported from `array_hash_map` rather than duplicated.
     pub use crate::array_hash_map::KV;
 }
 
 pub mod array_list;
-// TODO(port): per PORTING.md the managed/unmanaged ArrayList split collapses to
-// `Vec<T>` (global mimalloc) outside AST crates; Phase B may drop most of these
-// aliases once callers are migrated.
-pub use array_list::ArrayList; // any `std.mem.Allocator`
+// All of these aliases collapse to `Vec<T>` (global mimalloc); they exist for
+// back-compat at existing call sites.
+pub use array_list::ArrayList;
 pub use array_list::ArrayListAligned;
 pub use array_list::ArrayListAlignedDefault;
 pub use array_list::ArrayListAlignedIn;
-pub use array_list::ArrayListDefault; // always default allocator (no overhead)
-pub use array_list::ArrayListIn; // specific type of generic allocator
-
-// ported from: src/collections/collections.zig
+pub use array_list::ArrayListDefault;
+pub use array_list::ArrayListIn;
diff --git a/src/collections/linear_fifo.rs b/src/collections/linear_fifo.rs
index 70149dde41e..33ed23d9bdf 100644
--- a/src/collections/linear_fifo.rs
+++ b/src/collections/linear_fifo.rs
@@ -1,6 +1,3 @@
-// clone of zig stdlib
-// except, this one vectorizes
-
 // FIFO of fixed size items
 // Usually used for e.g. byte buffers
 
@@ -10,16 +7,14 @@ use core::ptr;
 
 use bun_alloc::AllocError;
 
-// TODO(port): std.heap.page_size_min — Zig resolves this per-target; 4096 is the
-// conservative minimum on every platform Bun ships on.
+// 4096 is the conservative minimum page size on every platform Bun ships on.
 const PAGE_SIZE_MIN: usize = 4096;
 
-/// Mirrors Zig's `LinearFifoBufferType = union(enum)`.
+/// Selects the fifo's backing-storage strategy.
 ///
-/// In the Zig original this is a *comptime* value that selects a struct layout
-/// (`buf: [N]T` vs `buf: []T`, `std.mem.Allocator` param vs `void`). Rust cannot
-/// branch struct layout on a const-generic enum payload, so dispatch is done
-/// via the [`LinearFifoBuffer`] trait below; this enum is kept for API parity.
+/// Rust cannot branch struct layout on a const-generic enum payload, so
+/// dispatch is done via the [`LinearFifoBuffer`] trait below; this enum is
+/// kept for API parity.
 pub enum LinearFifoBufferType {
     /// The buffer is internal to the fifo; it is of the specified size.
     Static(usize),
@@ -29,12 +24,11 @@ pub enum LinearFifoBufferType {
     Dynamic,
 }
 
-/// Backing-storage abstraction replacing Zig's `comptime buffer_type` switch.
-/// `POWERS_OF_TWO` mirrors the Zig `powers_of_two` const inside the returned
-/// struct; `DYNAMIC` mirrors `buffer_type == .Dynamic`.
-// TODO(port): the Zig fn returns structurally different layouts per variant;
-// trait+assoc-consts is the closest stable-Rust encoding. Phase B: confirm all
-// in-tree callers are covered by the three impls below.
+/// Backing-storage abstraction; `DYNAMIC` is true for the `.Dynamic` variant.
+// Trait + assoc-consts encode the structurally different layouts per
+// variant. No in-tree caller
+// instantiates `SliceBuffer` directly; `threading::Channel::init_slice` wraps
+// it for `.Slice` API parity.
 pub trait LinearFifoBuffer<T> {
     const POWERS_OF_TWO: bool;
     const DYNAMIC: bool;
@@ -61,9 +55,12 @@ pub trait LinearFifoBuffer<T> {
 
 /// Reinterpret `&[MaybeUninit<T>]` as `&[T]`. `MaybeUninit<T>` has identical
 /// layout to `T`; exposing uninitialized bytes as `T` is sound only when any
-/// bit pattern is a valid `T` (in-tree LinearFifo users are byte buffers —
-/// see the `StaticBuffer` TODO below). Centralises the four per-buffer-kind
-/// casts behind one audited block.
+/// bit pattern is a valid `T`. NOT every in-tree element type satisfies this:
+/// besides byte buffers and raw pointers, fifos today store `NonNull`-bearing
+/// enums (`bun_test::RefDataValue`), `JSPromiseStrong`-bearing structs
+/// (`ValkeyCommand::PromisePair`), and the `event_loop::Task` enum — see the
+/// `StaticBuffer` note below for the pending MaybeUninit accessor rework.
+/// Centralises the four per-buffer-kind casts behind one audited block.
 #[inline(always)]
 fn assume_init_slice<T>(s: &[MaybeUninit<T>]) -> &[T] {
     // SAFETY: see fn doc.
@@ -112,10 +109,19 @@ fn poison<T>(slice: &mut [T], n: usize) {
 // ── .Static ───────────────────────────────────────────────────────────────────
 
 /// `buffer_type == .Static` — inline `[T; N]` storage.
-// TODO(port): Zig leaves the array `undefined`; we use MaybeUninit and expose
-// it as &[T] via pointer cast. Sound only for `T` whose any-bit-pattern is
-// valid (in-tree users are byte buffers). Phase B: bound `T: Copy` or rework
-// accessors to MaybeUninit if a non-POD T appears.
+// INVARIANT: storage is MaybeUninit and exposed as &[T] via pointer cast
+// (`assume_init_slice`). The public API
+// (`writable_slice` hands out `&mut [T]` over not-yet-written slots) bakes in
+// the same exposure for every buffer kind. Sound only for `T` whose
+// any-bit-pattern is valid — and in-tree element types ALREADY violate that:
+// `RefDataValue` (NonNull<DescribeScope> payload), `PromisePair`
+// (JSPromiseStrong), and the `Task` enum are stored in fifos today, so
+// materialising `&[T]` over uninitialized slots for those types is latent UB.
+// The fix is reworking the accessors to operate on `&[MaybeUninit<T>]` and
+// only assume-init the logically-written subranges. That cannot be done by
+// touching this file alone — `writable_slice`-family callers in other crates
+// see the signature change — so it is deferred to a dedicated change with
+// Miri coverage for a NonNull-bearing element type.
 pub struct StaticBuffer<T, const N: usize>([MaybeUninit<T>; N]);
 
 impl<T, const N: usize> LinearFifoBuffer<T> for StaticBuffer<T, N> {
@@ -153,10 +159,8 @@ impl<'a, T> LinearFifoBuffer<T> for SliceBuffer<'a, T> {
 
 // ── .Dynamic ──────────────────────────────────────────────────────────────────
 
-/// `buffer_type == .Dynamic` — heap-allocated, growable.
-///
-/// Zig stores `std.mem.Allocator` param + `buf: []T`. Per §Allocators (non-AST
-/// crate) the allocator param is dropped and global mimalloc backs `Box`.
+/// `buffer_type == .Dynamic` — heap-allocated, growable. Global mimalloc
+/// backs the `Box`.
 pub struct DynamicBuffer<T>(Box<[MaybeUninit<T>]>);
 
 impl<T> LinearFifoBuffer<T> for DynamicBuffer<T> {
@@ -173,7 +177,6 @@ impl<T> LinearFifoBuffer<T> for DynamicBuffer<T> {
     }
 
     fn realloc(&mut self, new_size: usize) -> Result<(), AllocError> {
-        // Zig: `self.allocator.realloc(self.buf, size)` preserving prefix.
         let mut new = Box::<[T]>::new_uninit_slice(new_size);
         let n = self.0.len().min(new_size);
         // SAFETY: disjoint allocations; MaybeUninit copy is always sound.
@@ -191,21 +194,16 @@ impl<T> LinearFifoBuffer<T> for DynamicBuffer<T> {
 // ── LinearFifo ────────────────────────────────────────────────────────────────
 
 pub struct LinearFifo<T, B: LinearFifoBuffer<T>> {
-    // Zig field `allocator` is folded into `B` (or dropped) — see DynamicBuffer.
     buf: B,
     head: usize,
     count: usize,
     _marker: PhantomData<T>,
 }
 
-// PORT NOTE: Zig's `SliceSelfArg = if (.Static) *Self else Self` exists because
-// returning a slice into a by-value `Self` would dangle when buf is inline. In
-// Rust every accessor takes `&self`/`&mut self`, so the distinction disappears.
-
-// TODO(port): Reader/Writer std.Io adapters. Zig exposes
-// `pub const Reader = std.Io.GenericReader(*Self, error{}, readFn)` and a
-// matching Writer. Phase B: impl `bun_io::Read`/`bun_io::Write` (and
-// `core::fmt::Write`) on `LinearFifo<u8, B>`.
+// Reader/Writer access is via the impls on `LinearFifo<u8, B>` after the
+// inherent impl below: `bun_core::write::Write` (the canonical byte sink,
+// re-exported as `bun_io::Write`), plus `std::io::Read`, `std::io::Write`,
+// and `core::fmt::Write` for std interop.
 
 impl<T, const N: usize> LinearFifo<T, StaticBuffer<T, N>> {
     /// `init` for `.Static`.
@@ -232,8 +230,7 @@ impl<'a, T> LinearFifo<T, SliceBuffer<'a, T>> {
 }
 
 impl<T> LinearFifo<T, DynamicBuffer<T>> {
-    /// `init` for `.Dynamic`. Zig takes `std.mem.Allocator` param; dropped per
-    /// §Allocators (non-AST crate).
+    /// `init` for `.Dynamic`.
     pub fn init() -> Self {
         Self {
             buf: DynamicBuffer(Box::new([])),
@@ -253,7 +250,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         self.buf.len()
     }
 
-    /// Allocated capacity of the backing buffer (Zig: `fifo.buf.len`).
+    /// Allocated capacity of the backing buffer.
     /// Distinct from [`readable_length`] (live items) and
     /// [`writable_length`] (free slots) — `capacity == readable + writable`.
     /// Used by GC `memoryCost` reporting where the *allocation* size, not the
@@ -265,8 +262,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
 
     /// Rewind `head` to 0 when the queue is empty so the next `write` can use
     /// the full contiguous buffer without wrapping. Perf-only micro-opt; a
-    /// no-op when items remain. Mirrors the `head = 0` post-drain idiom in
-    /// `src/jsc/Task.zig` `tickQueueWithCount`.
+    /// no-op when items remain.
     #[inline]
     pub fn reset_head_if_empty(&mut self) {
         if self.count == 0 {
@@ -285,11 +281,9 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
             unsafe { ptr::copy(buf.as_ptr().add(head), buf.as_mut_ptr(), count) };
             self.head = 0;
         } else {
-            // Zig: `var tmp: [page_size_min / 2 / @sizeOf(T)]T = undefined;`
             // Stable Rust cannot size a stack array by `size_of::<T>()`, so use
-            // a fixed byte scratch and compute the element count at runtime.
-            // PERF(port): was stack array sized by page_size/2/sizeof(T) — same
-            // byte footprint here, no heap.
+            // a fixed byte scratch (page_size/2 bytes, no heap) and compute the
+            // element count at runtime.
             //
             // The scratch is a `[MaybeUninit<u8>; _]` (alignment 1). Reading or
             // writing through it as `*mut T` would violate
@@ -327,7 +321,8 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         {
             let count = self.count;
             let unused = &mut self.buf.as_mut_slice()[count..];
-            // SAFETY: poisoning unused tail; matches Zig `@memset(unused, undefined)`.
+            // SAFETY: the tail past `count` is logically uninitialized; writing
+            // the 0xAA poison pattern there cannot invalidate live items.
             unsafe {
                 ptr::write_bytes(
                     unused.as_mut_ptr().cast::<u8>(),
@@ -352,12 +347,10 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
 
     #[deprecated(note = "deprecated; call `ensure_unused_capacity` or `ensure_total_capacity`")]
     pub fn ensure_capacity(&mut self, _size: usize) {
-        // Zig: `pub const ensureCapacity = @compileError(...)`
         unreachable!("deprecated; call ensure_unused_capacity or ensure_total_capacity");
     }
 
     /// Ensure that the buffer can fit at least `size` items
-    // TODO(port): narrow error set
     pub fn ensure_total_capacity(&mut self, size: usize) -> Result<(), AllocError> {
         if self.buf_len() >= size {
             return Ok(());
@@ -365,12 +358,10 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         if B::DYNAMIC {
             self.realign();
             let new_size = if B::POWERS_OF_TWO {
-                // math.ceilPowerOfTwo(usize, size) catch return error.OutOfMemory
                 size.checked_next_power_of_two().ok_or(AllocError)?
             } else {
                 size
             };
-            // Zig: alloc new, memcpy readableSlice(0) bytes, free old.
             let count = self.count;
             let old = self.buf.alloc_swap(new_size)?;
             if count > 0 {
@@ -447,7 +438,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         #[cfg(debug_assertions)]
         {
             // set old range to undefined. Note: may be wrapped around
-            // PORT NOTE: reshaped for borrowck — capture len, then re-borrow.
+            // reshaped for borrowck — capture len, then re-borrow.
             let slice_len = self.readable_slice_mut(0).len();
             if slice_len >= count {
                 poison(self.readable_slice_mut(0), count);
@@ -497,7 +488,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
             }
             let n = slice.len().min(dst_left.len());
             dst_left[..n].copy_from_slice(&slice[..n]);
-            // PORT NOTE: NLL drops `slice` borrow here before `&mut self`.
+            // NLL drops `slice` borrow here before `&mut self`.
             self.discard(n);
             dst_left = &mut dst_left[n..];
         }
@@ -505,8 +496,6 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         total - dst_left.len()
     }
 
-    // TODO(port): `pub fn reader(self: *Self) Reader` — see Reader/Writer note.
-
     /// Returns number of items available in fifo
     #[inline]
     pub fn writable_length(&self) -> usize {
@@ -535,12 +524,11 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
 
     /// Returns a writable buffer of at least `size` items, allocating memory as needed.
     /// Use `fifo.update` once you've written data to it.
-    // TODO(port): narrow error set
     pub fn writable_with_size(&mut self, size: usize) -> Result<&mut [T], AllocError> {
         self.ensure_unused_capacity(size)?;
 
         // try to avoid realigning buffer
-        // PORT NOTE: reshaped for borrowck — check len, drop borrow, maybe
+        // reshaped for borrowck — check len, drop borrow, maybe
         // realign, then take the final borrow.
         if self.writable_slice(0).len() < size {
             self.realign();
@@ -566,7 +554,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
 
         let mut src_left = src;
         while !src_left.is_empty() {
-            // PORT NOTE: reshaped for borrowck — scoped block drops the
+            // reshaped for borrowck — scoped block drops the
             // `writable` borrow before `self.update`.
             let n = {
                 let writable = self.writable_slice(0);
@@ -581,7 +569,6 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
     }
 
     /// Write a single item to the fifo
-    // TODO(port): narrow error set
     pub fn write_item(&mut self, item: T) -> Result<(), AllocError> {
         self.ensure_unused_capacity(1)?;
         self.write_item_assume_capacity(item);
@@ -596,16 +583,15 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
             tail %= self.buf_len();
         }
         // SAFETY: `tail` is in-bounds (capacity reserved by caller). The slot is
-        // logically uninitialized — `ptr::write` matches Zig assignment semantics
-        // (no drop of the prior bit-pattern), required for non-`Copy` `T` whose
-        // backing storage is `MaybeUninit<T>`.
+        // logically uninitialized — `ptr::write` does not drop the prior
+        // bit-pattern, which is required for non-`Copy` `T` whose backing
+        // storage is `MaybeUninit<T>`.
         unsafe { ptr::write(self.buf.as_mut_slice().as_mut_ptr().add(tail), item) };
         self.update(1);
     }
 
     /// Appends the data in `src` to the fifo.
     /// Allocates more memory as necessary
-    // TODO(port): narrow error set
     pub fn write(&mut self, src: &[T]) -> Result<(), AllocError>
     where
         T: Copy,
@@ -615,8 +601,6 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         Ok(())
     }
 
-    // TODO(port): `pub fn writer(self: *Self) Writer` — see Reader/Writer note.
-
     /// Make `count` items available before the current read location
     fn rewind(&mut self, count: usize) {
         debug_assert!(self.writable_length() >= count);
@@ -632,7 +616,6 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
     }
 
     /// Place data back into the read stream
-    // TODO(port): narrow error set
     pub fn unget(&mut self, src: &[T]) -> Result<(), AllocError>
     where
         T: Copy,
@@ -641,7 +624,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
 
         self.rewind(src.len());
 
-        // PORT NOTE: reshaped for borrowck — copy into first chunk in a scoped
+        // reshaped for borrowck — copy into first chunk in a scoped
         // block, drop borrow, then re-borrow for the wrapped chunk.
         let slice_len = {
             let s = self.readable_slice_mut(0);
@@ -737,9 +720,10 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
     /// Pump data from a reader into a writer
     /// stops when reader returns 0 bytes (EOF)
     /// Buffer size must be set before calling; a buffer length of 0 is invalid.
-    // TODO(port): `src_reader: anytype, dest_writer: *std.Io.Writer`. Phase B:
-    // bind to `bun_io::Read`/`bun_io::Write` (or whatever the byte-stream traits
-    // land as). Stubbed with generic bounds matching the called methods.
+    // The closure bounds encode duck-typed streams:
+    // `src_reader(buf)` ≙ `reader.read(buf)`, `dest_writer(buf)` ≙
+    // `writer.write(buf)`, both returning a count (`Ok(0)` from the reader
+    // means EOF). This keeps `pump` generic over `T`, which `std::io` cannot.
     pub fn pump<R, W, E>(&mut self, mut src_reader: R, dest_writer: &mut W) -> Result<(), E>
     where
         R: FnMut(&mut [T]) -> Result<usize, E>,
@@ -748,7 +732,7 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
         debug_assert!(self.buf_len() > 0);
         loop {
             if self.writable_length() > 0 {
-                // PORT NOTE: reshaped for borrowck.
+                // reshaped for borrowck.
                 let n = {
                     let ws = self.writable_slice(0);
                     src_reader(ws)?
@@ -776,6 +760,61 @@ impl<T, B: LinearFifoBuffer<T>> LinearFifo<T, B> {
     }
 }
 
+// ── Reader/Writer adapters ────────────────────────────────────────────────────
+
+impl<B: LinearFifoBuffer<u8>> std::io::Read for LinearFifo<u8, B> {
+    /// Drains up to `dst.len()` buffered bytes. `Ok(0)` means
+    /// the fifo is empty (EOF, never an error).
+    #[inline]
+    fn read(&mut self, dst: &mut [u8]) -> std::io::Result<usize> {
+        Ok(LinearFifo::read(self, dst))
+    }
+}
+
+impl<B: LinearFifoBuffer<u8>> std::io::Write for LinearFifo<u8, B> {
+    /// Appends the buffer, growing if `.Dynamic`. Fixed-capacity buffers
+    /// follow the `std::io::Write` contract: write what fits and return the
+    /// count (`Ok(0)` when full — `write_all` turns that into `WriteZero`).
+    /// `ErrorKind::OutOfMemory` is reserved for dynamic-growth allocation
+    /// failure.
+    #[inline]
+    fn write(&mut self, src: &[u8]) -> std::io::Result<usize> {
+        let src = if B::DYNAMIC {
+            src
+        } else {
+            &src[..src.len().min(self.writable_length())]
+        };
+        LinearFifo::write(self, src)
+            .map_err(|AllocError| std::io::Error::from(std::io::ErrorKind::OutOfMemory))?;
+        Ok(src.len())
+    }
+
+    #[inline]
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Enables `write!(fifo, ...)`.
+impl<B: LinearFifoBuffer<u8>> core::fmt::Write for LinearFifo<u8, B> {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        LinearFifo::write(self, s.as_bytes()).map_err(|AllocError| core::fmt::Error)
+    }
+}
+
+/// Canonical in-tree byte sink (re-exported as
+/// `bun_io::Write`), so a `LinearFifo<u8, _>` can be passed to every
+/// `impl bun_io::Write` consumer. `written_len` keeps its panicking default:
+/// a fifo drains, so it does not track total bytes written.
+impl<B: LinearFifoBuffer<u8>> bun_core::write::Write for LinearFifo<u8, B> {
+    /// Appends the whole buffer, growing if `.Dynamic`.
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), bun_core::Error> {
+        LinearFifo::write(self, buf)?;
+        Ok(())
+    }
+}
+
 // ── tests ─────────────────────────────────────────────────────────────────────
 
 #[cfg(test)]
@@ -854,45 +893,96 @@ mod tests {
 
         fifo.shrink(0);
 
-        // TODO(port): writer().print / reader().readUntilDelimiterOrEof tests
-        // depend on the std.Io adapter port.
+        {
+            use core::fmt::Write as _;
+            write!(fifo, "{}, {}!", "Hello", "World").unwrap();
+            let mut result = [0u8; 30];
+            let n = fifo.read(&mut result);
+            assert_eq!(b"Hello, World!", &result[..n]);
+            assert_eq!(0usize, fifo.readable_length());
+        }
 
-        // TODO(port): pump test depends on std.io.fixedBufferStream port.
+        {
+            std::io::Write::write_all(&mut fifo, b"This is a test").unwrap();
+            let mut drained = Vec::new();
+            std::io::Read::read_to_end(&mut fifo, &mut drained).unwrap();
+            let words: Vec<&[u8]> = drained.split(|&c| c == b' ').collect();
+            assert_eq!(vec![&b"This"[..], b"is", b"a", b"test"], words);
+        }
+
+        // Pump from an in-memory reader into a fixed output buffer. The
+        // closures play the reader/writer roles.
+        {
+            fifo.ensure_total_capacity(1).unwrap();
+            let input: &[u8] = b"pump test";
+            let mut cursor = 0usize;
+            let mut out: Vec<u8> = Vec::new();
+            fifo.pump(
+                |buf: &mut [u8]| -> Result<usize, ()> {
+                    let n = buf.len().min(input.len() - cursor);
+                    buf[..n].copy_from_slice(&input[cursor..cursor + n]);
+                    cursor += n;
+                    Ok(n)
+                },
+                &mut |bytes: &[u8]| {
+                    out.extend_from_slice(bytes);
+                    Ok(bytes.len())
+                },
+            )
+            .unwrap();
+            assert_eq!(input, &out[..]);
+        }
     }
 
-    // `inline for ([_]type{u1,u8,u16,u64}) |T|` × `inline for (buffer types)`
-    // — expanded for one representative element type; the rest are mechanical.
-    // TODO(port): macro-generate the full T×buffer_type matrix in Phase B.
-    #[test]
-    fn linear_fifo_generic_u8_static() {
-        let mut fifo = LinearFifo::<u8, StaticBuffer<u8, 32>>::init();
+    // Shared body for the T×buffer_type matrix below.
+    fn run_generic_fifo_test<T, B>(mut fifo: LinearFifo<T, B>)
+    where
+        T: Copy + PartialEq + core::fmt::Debug + From<u8>,
+        B: LinearFifoBuffer<T>,
+    {
+        let zero = T::from(0u8);
+        let one = T::from(1u8);
 
-        fifo.write(&[0, 1, 1, 0, 1]).unwrap();
+        fifo.write(&[zero, one, one, zero, one]).unwrap();
         assert_eq!(5usize, fifo.readable_length());
 
         {
-            assert_eq!(0u8, fifo.read_item().unwrap());
-            assert_eq!(1u8, fifo.read_item().unwrap());
-            assert_eq!(1u8, fifo.read_item().unwrap());
-            assert_eq!(0u8, fifo.read_item().unwrap());
-            assert_eq!(1u8, fifo.read_item().unwrap());
+            assert_eq!(zero, fifo.read_item().unwrap());
+            assert_eq!(one, fifo.read_item().unwrap());
+            assert_eq!(one, fifo.read_item().unwrap());
+            assert_eq!(zero, fifo.read_item().unwrap());
+            assert_eq!(one, fifo.read_item().unwrap());
             assert_eq!(0usize, fifo.readable_length());
         }
 
         {
-            fifo.write_item(1).unwrap();
-            fifo.write_item(1).unwrap();
-            fifo.write_item(1).unwrap();
+            fifo.write_item(one).unwrap();
+            fifo.write_item(one).unwrap();
+            fifo.write_item(one).unwrap();
             assert_eq!(3usize, fifo.readable_length());
         }
 
         {
-            let mut read_buf = [0u8; 3];
+            let mut read_buf = [zero; 3];
             let n = fifo.read(&mut read_buf);
             assert_eq!(3usize, n); // NOTE: It should be the number of items.
         }
     }
 
+    // The element types are crossed with all three buffer kinds.
+    #[test]
+    fn linear_fifo_generic_matrix() {
+        macro_rules! per_type {
+            ($($T:ty),* $(,)?) => {$(
+                run_generic_fifo_test(LinearFifo::<$T, StaticBuffer<$T, 32>>::init());
+                run_generic_fifo_test(LinearFifo::<$T, DynamicBuffer<$T>>::init());
+                let mut backing = [<$T>::from(0u8); 32];
+                run_generic_fifo_test(LinearFifo::<$T, SliceBuffer<$T>>::init(&mut backing));
+            )*};
+        }
+        per_type!(u8, u16, u64);
+    }
+
     // 16-slot static buffer: `POWERS_OF_TWO` is true, matching the in-tree
     // `weak_refs` FIFO in the dev server's source-map store (cap 16), the one
     // real caller of `ordered_remove_item`. `i32` elements make every shift
@@ -1028,5 +1118,3 @@ mod tests {
         }
     }
 }
-
-// ported from: src/collections/linear_fifo.zig
diff --git a/src/collections/multi_array_list.rs b/src/collections/multi_array_list.rs
index 43061c51d03..883f3d72888 100644
--- a/src/collections/multi_array_list.rs
+++ b/src/collections/multi_array_list.rs
@@ -1,10 +1,8 @@
-//! Port of `std.MultiArrayList` with the following Bun-specific additions:
+//! A struct-of-arrays `MultiArrayList` with the following Bun-specific additions:
 //!
 //! * `zero` method to zero-initialize memory.
 //! * `memory_cost` method, which returns the memory usage in bytes.
 //!
-//! Synchronized with std as of Zig 0.14.1.
-//!
 //! A MultiArrayList stores a list of a struct type. Instead of storing a
 //! single list of items, MultiArrayList stores separate lists for each field
 //! of the struct. This allows for memory savings if the struct has padding,
@@ -58,7 +56,7 @@ use std::alloc::{Allocator, Global};
 use bun_alloc::AllocError;
 
 /// Declares typed column-accessor extension traits for a `MultiArrayList<$T>`
-/// element struct, mirroring Zig's `list.items(.field)` calling convention.
+/// element struct.
 ///
 /// ```ignore
 /// multi_array_columns! {
@@ -361,7 +359,7 @@ impl<T> Reflected<T> {
         out
     };
 
-    /// Zig `sizes`: `(SIZES_BYTES, SIZES_FIELDS)` — field sizes sorted by
+    /// `(SIZES_BYTES, SIZES_FIELDS)` — field sizes sorted by
     /// alignment descending, paired with the original field index at each
     /// sorted position. Stable sort so equal-alignment fields keep order.
     const SIZES: ([usize; MAX_FIELDS], [usize; MAX_FIELDS]) = {
@@ -539,7 +537,6 @@ impl<'a, F> ColMut<'a, F> {
 }
 
 /// Index-based comparison context for `sort` / `sort_span` / `sort_unstable`.
-/// Zig: `ctx: anytype` with `fn lessThan(ctx, a_index: usize, b_index: usize) bool`.
 pub trait SortContext {
     fn less_than(&self, a_index: usize, b_index: usize) -> bool;
 }
@@ -715,8 +712,7 @@ impl<T> Slice<T> {
     /// The returned value is a **bitwise copy** — the SoA storage retains
     /// ownership of every field. Dropping the gathered struct would free
     /// columns the storage still owns (double-free on next `get` / `Drop`),
-    /// so it is wrapped in `ManuallyDrop`. Zig has no destructors so the
-    /// by-value copy is harmless there.
+    /// so it is wrapped in `ManuallyDrop`.
     pub fn get(&self, index: usize) -> ManuallyDrop<T> {
         assert!(
             index < self.len,
@@ -985,7 +981,7 @@ impl<T, A: Allocator> MultiArrayList<T, A> {
         Ok(())
     }
 
-    /// Alias for [`push`] (Zig: `append`).
+    /// Alias for [`push`].
     #[inline]
     pub fn append(&mut self, elem: T) -> Result<(), AllocError> {
         self.push(elem)
@@ -1278,9 +1274,9 @@ impl<T, A: Allocator> MultiArrayList<T, A> {
 
 impl<T, A: Allocator> Drop for MultiArrayList<T, A> {
     fn drop(&mut self) {
-        // Zig `deinit(self, gpa)`: `gpa.free(self.allocatedBytes())` — slab
-        // only, no per-element destructors. This is **intentionally preserved**:
-        // [`clone`] is a bitwise SoA memcpy (Zig semantics), so two live lists
+        // Frees the slab only — no per-element destructors. This is
+        // **intentionally preserved**:
+        // [`clone`] is a bitwise SoA memcpy, so two live lists
         // can alias the same column heap pointers — see `bundle_v2.rs`
         // `clone_ast` / `deinit_without_freeing_arena`, which drains exactly
         // one alias and relies on the other dropping slab-only. Running
@@ -1296,7 +1292,7 @@ impl<T, A: Allocator> Drop for MultiArrayList<T, A> {
 
 // ───────────────────────────── helpers ─────────────────────────────
 
-/// `std.atomic.cache_line` — **128** on x86_64 and aarch64, all native targets.
+/// Conservative cache-line size — **128** on x86_64 and aarch64, all native targets.
 const CACHE_LINE: usize = 128;
 
 const fn init_capacity<T>() -> usize {
@@ -1565,5 +1561,3 @@ mod tests {
         assert_eq!(list.items::<"c", u64>(), &[0, 10, 20, 30, 40]);
     }
 }
-
-// ported from: src/collections/multi_array_list.zig
diff --git a/src/collections/pool.rs b/src/collections/pool.rs
index f23dde33c12..7fc46c48bd0 100644
--- a/src/collections/pool.rs
+++ b/src/collections/pool.rs
@@ -8,33 +8,20 @@ use bun_core::Error;
 // ──────────────────────────────────────────────────────────────────────────
 // SinglyLinkedList
 // ──────────────────────────────────────────────────────────────────────────
-//
-// PORT NOTE: Zig's `SinglyLinkedList(comptime T: type, comptime Parent: type)`
-// threads `Parent` only so that `Node.release()` can call `Parent.release(node)`.
-// In Rust the only `Parent` is `ObjectPool`, so `Node::release` is provided as
-// an inherent method on `ObjectPool` instead and the `Parent` type param is
-// dropped here. Diff readers: `node.release()` call sites become
-// `ObjectPool::<..>::release(node)`.
 
 /// Node inside the linked list wrapping the actual data.
 #[repr(C)]
 pub struct Node<T> {
-    // INTRUSIVE: pool.zig:7 — next link in singly-linked free list
+    // INTRUSIVE: next link in singly-linked free list
     pub next: *mut Node<T>,
-    // PORT NOTE: Zig stored `std.mem.Allocator param` here so `destroyNode`
-    // could free via the originating allocator. In Rust the global mimalloc
-    // allocator owns every `Box<Node<T>>`, so the field is dropped and
-    // `destroy_node` uses `heap::take`.
-    //
-    // PORT NOTE: `MaybeUninit<T>` not `T` — Zig's `else undefined` (pool.zig:203)
-    // is well-defined-until-read, but Rust's `assume_init()` on uninit bytes is
+    // `MaybeUninit<T>` not `T`: `assume_init()` on uninit bytes is
     // immediate UB for any `T` with validity invariants. Callers that use
     // `INIT == None` write `data` before reading, so we keep the bytes
     // uninitialized and only `assume_init_*` at access sites.
     pub data: MaybeUninit<T>,
 }
 
-// PORT NOTE: `pub const Data = T;` (inherent assoc type) is nightly-only;
+// `pub const Data = T;` (inherent assoc type) is nightly-only;
 // callers can write `T` directly.
 
 impl<T> Node<T> {
@@ -119,14 +106,10 @@ impl<T> Node<T> {
         }
         count
     }
-
-    // PORT NOTE: `pub inline fn release(node: *Node) void { Parent.release(node) }`
-    // is expressed as `ObjectPool::<T, ..>::release(node)` at call sites; see
-    // module-level note above.
 }
 
 pub struct SinglyLinkedList<T> {
-    // INTRUSIVE: pool.zig:59 — list head; popFirst hands node to caller
+    // INTRUSIVE: list head; pop_first hands node to caller
     pub first: *mut Node<T>,
 }
 
@@ -176,8 +159,8 @@ impl<T> SinglyLinkedList<T> {
             // SAFETY: self.first is non-null (else the `==` above would have
             // matched the null `node`, which callers never pass)
             let mut current_elm = self.first;
-            // SAFETY: walk live list nodes; Zig's `.?` would panic on null —
-            // mirror that with an unchecked deref.
+            // SAFETY: `node` is in this list (caller contract), so the walk
+            // visits only live nodes and reaches `node` before hitting null.
             unsafe {
                 while (*current_elm).next != node {
                     current_elm = (*current_elm).next;
@@ -219,35 +202,28 @@ impl<T> SinglyLinkedList<T> {
 
 const LOG_ALLOCATIONS: bool = false;
 
-/// Behavior hooks the Zig version expressed via `comptime Init: ?fn(...)` and
-/// `std.meta.hasFn(Type, "reset")`. Per PORTING.md §Comptime reflection,
-/// optional-decl checks become a trait with default methods.
+/// Behavior hooks for pooled types: optional initialization and per-reuse
+/// reset.
 pub trait ObjectPoolType: Sized {
-    /// Mirrors `comptime Init: ?fn(allocator) anyerror!Type`. `None` ⇒ the
-    /// Zig path that left `data` as `undefined`.
+    /// Optional initializer for freshly allocated nodes. `None` ⇒ `data`
+    /// starts uninitialized.
     const INIT: Option<fn() -> Result<Self, Error>> = None;
 
-    /// Mirrors `if (std.meta.hasFn(Type, "reset")) node.data.reset()`.
-    /// Default is a no-op; types that had `.reset()` in Zig override this.
+    /// Called when a node is reused from the free list. Default is a no-op.
     #[inline]
     fn reset(&mut self) {}
 }
 
-/// Per-pool mutable state. Zig's `DataStruct`.
+/// Per-pool mutable state.
 pub struct DataStruct<T> {
     pub list: SinglyLinkedList<T>,
     pub loaded: bool,
-    // PORT NOTE: Zig used `MaxCountInt = std.math.IntFittingRange(0, max_count)`.
-    // Rust const generics cannot pick an integer type from a const value; use
-    // `usize` and accept the few extra bytes.
-    // PERF(port): was IntFittingRange — narrow if it shows up on a hot path.
     pub count: usize,
 }
 
 impl<T> Default for DataStruct<T> {
     fn default() -> Self {
         Self {
-            // PORT NOTE: Zig had `list: LinkedList = undefined` — we zero it.
             list: SinglyLinkedList::default(),
             loaded: false,
             count: 0,
@@ -268,7 +244,7 @@ pub struct ObjectPool<
     S = UnwiredStorage,
 >(core::marker::PhantomData<(T, S)>);
 
-// PORT NOTE: `pub const List = SinglyLinkedList(T)` / `pub const Node = Node(T)`
+// `pub const List = SinglyLinkedList(T)` / `pub const Node = Node(T)`
 // inherent assoc types are nightly-only; callers write `SinglyLinkedList<T>` /
 // `Node<T>` directly.
 
@@ -309,8 +285,7 @@ impl<T: ObjectPoolType, const TS: bool, const MAX: usize, S> ObjectPoolTrait
 }
 
 /// RAII handle for a pooled `T`. Derefs to the inner value; on `Drop`, the
-/// node is returned to its pool. Replaces the Zig `get()` + `defer release()`
-/// pair.
+/// node is returned to its pool.
 pub struct PoolGuard<'a, T: ObjectPoolType + 'static> {
     node: *mut Node<T>,
     release: unsafe fn(&mut Node<T>),
@@ -365,7 +340,7 @@ where
     // but we don't want to create 3 global variables per pool
     // instead, we create one global variable per pool
     //
-    // PORT NOTE: Rust cannot place a `static` / `thread_local!` inside a
+    // Rust cannot place a `static` / `thread_local!` inside a
     // generic `impl`; storage is supplied via the `S: PoolStorage<T>` type
     // parameter (see `object_pool!` for the usual declaration).
     #[inline]
@@ -385,8 +360,6 @@ where
 
     pub fn push(pooled: T) {
         if cfg!(debug_assertions) {
-            // PORT NOTE: Zig gated on `env.allow_assert`; that is
-            // `Environment.isDebug` ⇒ `cfg!(debug_assertions)`.
             debug_assert!(!Self::full());
         }
 
@@ -424,7 +397,7 @@ where
         unsafe { (*Self::get_node()).data.as_mut_ptr() }
     }
 
-    /// Zig `get()` — pop a node from the free list or allocate a fresh one.
+    /// Pop a node from the free list or allocate a fresh one.
     ///
     /// When `T::INIT == None` and a fresh node is allocated, the returned
     /// node's `data` is **uninitialized**; the caller must write a valid `T`
@@ -450,12 +423,13 @@ where
         }
 
         if LOG_ALLOCATIONS {
-            // PORT NOTE: Zig wrote to stderr via std.fs; banned here. Route
-            // through `bun_core::Output` if this is ever flipped on.
-            // TODO(port): log "Allocate {type_name} - {size} bytes"
+            let _ = bun_core::output::File::stderr().write_fmt(format_args!(
+                "Allocate {} - {} bytes\n",
+                core::any::type_name::<T>(),
+                core::mem::size_of::<T>()
+            ));
         }
 
-        // Matches Zig's `data = if (Init) |i| i(..) else undefined` (pool.zig:203).
         // For `INIT == None` the bytes stay uninitialized; the caller MUST write
         // `data` before any read (and before `release()`, since `destroy_node`
         // assumes it is initialized when dropping).
@@ -508,7 +482,11 @@ where
             let mut d = cell.borrow_mut();
             if MAX_COUNT > 0 && d.count >= MAX_COUNT {
                 if LOG_ALLOCATIONS {
-                    // TODO(port): log "Free {type_name} - {size} bytes"
+                    let _ = bun_core::output::File::stderr().write_fmt(format_args!(
+                        "Free {} - {} bytes\n",
+                        core::any::type_name::<T>(),
+                        core::mem::size_of::<T>()
+                    ));
                 }
                 return true;
             }
@@ -550,12 +528,6 @@ where
     }
 
     fn destroy_node(node: *mut Node<T>) {
-        // TODO(port): Zig special-cased `Type != bun.Vec<u8>` here to skip
-        // `bun.memory.deinit(&node.data)` for `Vec<u8>` (a known leak the Zig
-        // comment calls out). In Rust, dropping `T` is the moral equivalent of
-        // `bun.memory.deinit`. If `Vec<u8>` (the `Vec<u8>` port) must keep
-        // leaking for compat, gate its `Drop` there — not here.
-        //
         // SAFETY: `node` was created via `heap::alloc` in `push`/`get` and
         // is exclusively owned by the caller. `data` is initialized: `destroy_node`
         // is only reached from `release()` (caller had a usable node, so `data`
@@ -584,7 +556,7 @@ where
 /// `pub type $Name = ObjectPool<$T, .., $Storage>` alias. `threadsafe` ⇒
 /// `thread_local!` (one free list per thread); `global` ⇒ a single
 /// process-wide `RefCell` (caller is responsible for not touching it from
-/// multiple threads — matches the Zig `threadsafe = false` mode).
+/// multiple threads).
 #[macro_export]
 macro_rules! object_pool {
     ($vis:vis $name:ident : $ty:ty, threadsafe, $max:expr) => {
@@ -637,11 +609,9 @@ macro_rules! __object_pool_storage {
             fn with<R>(
                 f: impl FnOnce(&::core::cell::RefCell<$crate::pool::DataStruct<$ty>>) -> R,
             ) -> R {
-                // PORT NOTE: Zig's `threadsafe = false` used a plain global
-                // `var data`; Rust forbids non-`Sync` statics, so this still
+                // Rust forbids non-`Sync` statics, so the "global" mode still
                 // expands to a thread-local. Single-threaded callers see the
-                // same one cell; cross-thread callers get per-thread pools
-                // (a slight behaviour difference, but safe).
+                // same one cell; cross-thread callers get per-thread pools.
                 ::std::thread_local! {
                     static __OBJECT_POOL_DATA: ::core::cell::RefCell<
                         $crate::pool::DataStruct<$ty>
@@ -671,8 +641,7 @@ macro_rules! __paste_storage {
 // is in `bun_core` (post `bun_string` merge).
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `Npm.Registry.BodyPool = ObjectPool(MutableString, MutableString.init2048, true, 8)`
-/// (src/install/npm.zig). Init = `init2048`; reuse = `.reset()`.
+/// Init = `init2048`; reuse = `.reset()`.
 impl ObjectPoolType for bun_core::MutableString {
     const INIT: Option<fn() -> Result<Self, Error>> =
         Some(|| bun_core::MutableString::init2048().map_err(Into::into));
@@ -681,5 +650,3 @@ impl ObjectPoolType for bun_core::MutableString {
         bun_core::MutableString::reset(self);
     }
 }
-
-// ported from: src/collections/pool.zig
diff --git a/src/collections/string_map.rs b/src/collections/string_map.rs
index 9f29691412d..bd7ee5dc3de 100644
--- a/src/collections/string_map.rs
+++ b/src/collections/string_map.rs
@@ -1,5 +1,3 @@
-//! Port of `bun.StringMap` (`src/bun.zig`).
-//!
 //! A `StringArrayHashMap<Box<[u8]>>` plus a `dupe_keys` flag controlling
 //! whether `insert` clones the key bytes. Values are always cloned.
 
@@ -19,7 +17,6 @@ impl Default for StringMap {
 }
 
 impl StringMap {
-    /// Zig `init(allocator, dupe_keys)` — allocator dropped (global mimalloc).
     pub fn init(dupe_keys: bool) -> Self {
         Self {
             map: StringArrayHashMap::default(),
@@ -49,20 +46,18 @@ impl StringMap {
         self.map.count()
     }
 
-    /// Zig `insert` / `put`: dupe `value`; dupe `key` only when `dupe_keys`
-    /// and the key is new. (When `dupe_keys == false` Zig stored a borrowed
-    /// slice; here `Box<[u8]>` forces a copy regardless — the flag is kept for
-    /// API parity and to skip the redundant second copy.)
+    /// Dupe `value`; `key` is duped on miss regardless (`Box<[u8]>` forces a
+    /// copy), so the `dupe_keys` flag is kept for API parity only.
     pub fn insert(&mut self, key: &[u8], value: &[u8]) -> Result<(), AllocError> {
         let entry = self.map.get_or_put(key)?;
-        // get_or_put already boxed `key` on miss; the Zig `dupe_keys` branch
-        // would dupe again here — that's the same allocation, so skip it.
+        // get_or_put already boxed `key` on miss; duping again here would be
+        // the same allocation, so skip it.
         let _ = self.dupe_keys;
         *entry.value_ptr = Box::from(value);
         Ok(())
     }
 
-    /// Alias matching Zig `pub const put = insert;`.
+    /// Alias for [`insert`](Self::insert).
     #[inline]
     pub fn put(&mut self, key: &[u8], value: &[u8]) -> Result<(), AllocError> {
         self.insert(key, value)
@@ -72,10 +67,15 @@ impl StringMap {
         self.map.get(key).map(|v| &**v)
     }
 
-    // Zig `sort` takes an `anytype` ctx; defer until a caller needs it.
-    // TODO(port): StringMap::sort — wire once ArrayHashMap::sort lands.
+    /// Forwards to the inner map's order-preserving sort. The closure
+    /// receives the parallel key/value slices plus the two indices so it can
+    /// compare on either column.
+    pub fn sort(
+        &mut self,
+        less_than: impl FnMut(&[Box<[u8]>], &[Box<[u8]>], usize, usize) -> bool,
+    ) {
+        self.map.sort(less_than);
+    }
 
     // `deinit` → Drop on the inner Vecs.
 }
-
-// ported from: src/bun.zig
diff --git a/src/collections/vec_ext.rs b/src/collections/vec_ext.rs
index bd7328df8c3..dc55044075a 100644
--- a/src/collections/vec_ext.rs
+++ b/src/collections/vec_ext.rs
@@ -1,8 +1,8 @@
-//! `VecExt` / `ByteVecExt` — Zig-ported method vocabulary on `Vec<T>`.
+//! `VecExt` / `ByteVecExt` — extension method vocabulary on `Vec<T>`.
 //!
 //! Migration shim from the deleted `BabyList<T>` (see
 //! `docs/BABYLIST_REPLACEMENT.md`): every former `BabyList<T>` site is now a
-//! plain `Vec<T>`, and these traits supply the Zig method names (`.slice()`,
+//! plain `Vec<T>`, and these traits supply the legacy method names (`.slice()`,
 //! `.append()`, `.init_capacity()`, …) so call sites needed only a type-level
 //! rewrite. `Vec` aborts on OOM, so these methods are infallible and return
 //! `T` / `()` directly (the original `Result<_, AllocError>` shim has been
@@ -30,8 +30,7 @@ pub trait VecExt<T>: Sized {
     fn move_from_list(list: Vec<T>) -> Self;
     fn from_owned_slice(items: Box<[T]>) -> Self;
     fn init_with_buffer_vec(buffer: Vec<T>) -> Self;
-    /// Arena-builder → owned `Vec<T>`.  In Zig this was zero-copy (arena ptr
-    /// adopted as `Borrowed`); in the Rust port the linker always called
+    /// Arena-builder → owned `Vec<T>`. The linker always calls
     /// `transfer_ownership` afterwards (full copy), so doing the copy up-front
     /// here is no worse and lets the arena round-trip disappear.
     ///
@@ -131,8 +130,7 @@ pub trait VecExt<T>: Sized {
     unsafe fn writable_slice(&mut self, additional: usize) -> &mut [T];
     /// # Safety
     /// As [`writable_slice`] but skips `reserve`; caller must guarantee
-    /// `len + additional <= capacity` (debug-asserted). Zig:
-    /// `ArrayList.addManyAsSliceAssumeCapacity`.
+    /// `len + additional <= capacity` (debug-asserted).
     unsafe fn writable_slice_assume_capacity(&mut self, additional: usize) -> &mut [T];
     /// # Safety
     /// As [`writable_slice`] but uses `reserve_exact` so the allocation grows
@@ -217,7 +215,7 @@ impl<T, A: Allocator + Default + 'static> VecExt<T> for Vec<T, A> {
     #[inline]
     fn move_from_list(list: Vec<T>) -> Self {
         // Mirror of the `move_to_list` fast-path: when `A == Global` this is a
-        // pointer adopt (Zig `moveFromList`, baby_list.zig:46), not a realloc.
+        // pointer adopt, not a realloc.
         // Hot Global callers: `FileReader`, `ByteStream`, `shell::Cmd`.
         if core::any::TypeId::of::<A>() == core::any::TypeId::of::<std::alloc::Global>() {
             let mut list = core::mem::ManuallyDrop::new(list);
@@ -568,7 +566,7 @@ impl<T, A: Allocator + Default + 'static> VecExt<T> for Vec<T, A> {
     }
 }
 
-/// `Vec<u8>`-only helpers (Zig `Vec(u8)` extension methods).
+/// `Vec<u8>`-only helpers.
 pub trait ByteVecExt {
     fn append_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<(), AllocError>;
     fn write(&mut self, str: &[u8]) -> Result<u32, AllocError>;
@@ -730,9 +728,8 @@ impl OffsetByteList {
 /// [`bun_alloc::ArenaVec`]) does not satisfy. `src` and `dst` may use
 /// distinct allocators.
 ///
-/// Ports the open-coded `reserve → ptr::copy(shift) → copy_nonoverlapping →
-/// set_len` pattern that translated Zig's `bun.copy`/`@memcpy` splice for
-/// non-`Copy` element types.
+/// Implemented as `reserve → ptr::copy(shift) → copy_nonoverlapping →
+/// set_len`, which works for non-`Copy` element types.
 pub fn prepend_from<T, A: Allocator, B: Allocator>(dst: &mut Vec<T, A>, src: &mut Vec<T, B>) {
     let src_len = src.len();
     if src_len == 0 {
diff --git a/src/collections/zig_hash_map.rs b/src/collections/zig_hash_map.rs
index f8753b433a8..f50a7f21a7d 100644
--- a/src/collections/zig_hash_map.rs
+++ b/src/collections/zig_hash_map.rs
@@ -1,15 +1,12 @@
-//! Port of Zig's `std.HashMapUnmanaged` — open-addressing, linear-probe,
-//! tombstone-on-delete, power-of-two capacity, 80% max load. Layout (and
-//! therefore iteration order) must match the Zig spec exactly because callers
-//! snapshot the iteration sequence (e.g. lockfile debug stringify).
+//! Open-addressing hash map — linear-probe, tombstone-on-delete, power-of-two
+//! capacity, 80% max load. Layout (and therefore iteration order) is
+//! load-bearing: callers snapshot the iteration sequence (e.g. lockfile debug
+//! stringify).
 //!
-//! Storage differs from Zig's single-allocation `[Header][meta][keys][values]`:
-//! `Vec<u8>` for metadata + `Vec<Option<(K, V)>>` for slots. This costs an
-//! `Option` discriminant per slot but keeps the implementation in safe Rust;
-//! slot indices and the metadata state machine are bit-identical so iteration
-//! order matches.
-//!
-//! Spec: vendor/zig/lib/std/hash_map.zig
+//! Storage is split: `Vec<u8>` for metadata + `Vec<Option<(K, V)>>` for
+//! slots. This costs an `Option` discriminant per slot but keeps the
+//! implementation in safe Rust; slot indices and the metadata state machine
+//! determine iteration order.
 
 use core::borrow::Borrow;
 use core::hash::Hash;
@@ -18,7 +15,6 @@ use core::marker::PhantomData;
 use crate::identity_context::{IdentityContext, IdentityHash};
 
 // ─── Metadata byte ─────────────────────────────────────────────────────────
-// Zig: `packed struct { fingerprint: u7, used: u1 }` — LSB-first packing, so
 // bit 7 = `used`, bits 0..7 = `fingerprint`.
 const SLOT_FREE: u8 = 0x00; // used=0, fp=0
 const SLOT_TOMBSTONE: u8 = 0x01; // used=0, fp=1
@@ -39,7 +35,7 @@ fn meta_is_tombstone(m: u8) -> bool {
 fn meta_fingerprint(m: u8) -> u8 {
     m & 0x7F
 }
-/// Zig `Metadata.takeFingerprint`: top 7 bits of the 64-bit hash.
+/// Top 7 bits of the 64-bit hash.
 #[inline]
 fn take_fingerprint(hash: u64) -> u8 {
     (hash >> (64 - 7)) as u8
@@ -50,22 +46,20 @@ fn meta_fill(fp: u8) -> u8 {
 }
 
 const MINIMAL_CAPACITY: u32 = 8;
-/// Zig `default_max_load_percentage`. All Bun-side `std.HashMap` instantiations
-/// use 80; the const-generic load-factor parameter is dropped here.
+/// Maximum load percentage before growth. All instantiations use 80, so this
+/// is a const rather than a generic parameter.
 const MAX_LOAD_PERCENTAGE: u64 = 80;
 
 #[inline]
 fn capacity_for_size(size: u32) -> u32 {
-    // Zig: `((size * 100) / max_load + 1).ceilPowerOfTwo()`
     let new_cap = ((size as u64 * 100) / MAX_LOAD_PERCENTAGE + 1) as u32;
     new_cap.next_power_of_two()
 }
 
 // ─── HashContext ───────────────────────────────────────────────────────────
-// Zig threads a `Context` value with `hash(K) -> u64` / `eql(K, K) -> bool`.
-// All Bun contexts are zero-sized, so model as a stateless trait keyed on the
-// marker type. `AutoHashContext` covers `std.AutoHashMap`; `IdentityContext<K>`
-// covers the `hash(k) == k` case used for pre-hashed keys.
+// The hash/eql strategy is a stateless trait keyed on a zero-sized marker
+// type. `AutoHashContext` is the default; `IdentityContext<K>` covers the
+// `hash(k) == k` case used for pre-hashed keys.
 
 /// Hash/eql strategy for [`HashMap`]. Implement on a zero-sized marker type.
 pub trait HashContext<K: ?Sized> {
@@ -80,10 +74,8 @@ pub struct AutoHashContext;
 impl<K: Hash + Eq + ?Sized> HashContext<K> for AutoHashContext {
     #[inline]
     fn ctx_hash(key: &K) -> u64 {
-        // Zig autoHash for unique-repr types is `Wyhash.hash(0, asBytes(&key))`.
-        // Routing through `core::hash::Hash` + wyhash is the closest stable
-        // approximation without per-type byte-layout plumbing; exact AutoContext
-        // bucket order isn't relied on by any test today.
+        // wyhash routed through `core::hash::Hash`; exact bucket order for
+        // this context isn't relied on by any test today.
         bun_wyhash::auto_hash(key)
     }
     #[inline]
@@ -133,7 +125,6 @@ impl<K, V, C> HashMap<K, V, C> {
         Self::default()
     }
 
-    /// Zig `count`/std `len`.
     #[inline]
     pub fn len(&self) -> usize {
         self.size as usize
@@ -151,13 +142,13 @@ impl<K, V, C> HashMap<K, V, C> {
         self.metadata.len()
     }
 
-    /// Zig `deinit` — release storage.
+    /// Release storage.
     #[inline]
     pub fn deinit(&mut self) {
         *self = Self::default();
     }
 
-    /// Zig `clearRetainingCapacity`.
+    /// Clear all entries, retaining capacity.
     pub fn clear(&mut self) {
         if self.metadata.is_empty() {
             return;
@@ -172,12 +163,12 @@ impl<K, V, C> HashMap<K, V, C> {
         self.available = ((self.metadata.len() as u64 * MAX_LOAD_PERCENTAGE) / 100) as u32;
     }
 
-    /// Zig `lockPointers` — debug-mode pointer-stability assertion. No-op stub
-    /// kept so the Zig lock/unlock bracketing translates without `#[cfg]` noise
-    /// at every call site (see `SavedSourceMap`).
+    /// Debug-mode pointer-stability assertion. No-op stub kept so callers can
+    /// keep their lock/unlock bracketing without `#[cfg]` noise at every call
+    /// site (see `SavedSourceMap`).
     #[inline]
     pub fn lock_pointers(&self) {}
-    /// Zig `unlockPointers` — see [`lock_pointers`].
+    /// See [`lock_pointers`](Self::lock_pointers).
     #[inline]
     pub fn unlock_pointers(&self) {}
 
@@ -219,9 +210,8 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         m
     }
 
-    /// Zig `ensureTotalCapacity` — grow so `new_size` elements fit without
-    /// further allocation. `Result` kept for call-site `?` symmetry with the
-    /// Zig OOM-propagating API.
+    /// Grow so `new_size` elements fit without further allocation. `Result`
+    /// kept for call-site `?` symmetry.
     pub fn ensure_total_capacity(&mut self, new_size: usize) -> Result<(), bun_alloc::AllocError> {
         let new_size = new_size as u32;
         if new_size > self.size {
@@ -230,7 +220,6 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         Ok(())
     }
 
-    /// Zig `ensureUnusedCapacity`.
     pub fn ensure_unused_capacity(
         &mut self,
         additional: usize,
@@ -293,8 +282,7 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         *self = map;
     }
 
-    /// Zig `putAssumeCapacityNoClobber` — linear-probe insert assuming key
-    /// absent and `available > 0`.
+    /// Linear-probe insert assuming the key is absent and `available > 0`.
     fn put_assume_capacity_no_clobber(&mut self, key: K, value: V) {
         let cap = self.metadata.len();
         let hash = C::ctx_hash(&key);
@@ -314,7 +302,7 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         self.size += 1;
     }
 
-    /// Zig `getIndex` — probe for `key`, stop on free, skip tombstones.
+    /// Probe for `key`, stop on free, skip tombstones.
     fn get_index<Q>(&self, key: &Q) -> Option<usize>
     where
         K: Borrow<Q>,
@@ -385,13 +373,13 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         self.get_index(key).is_some()
     }
 
-    /// Zig `contains` — `std::HashMap` spells this `contains_key`.
+    /// Alias for [`contains_key`](Self::contains_key).
     #[inline]
     pub fn contains(&self, key: &K) -> bool {
         self.get_index(key).is_some()
     }
 
-    /// Zig `getOrPutAssumeCapacityAdapted` lifted to grow-on-demand. Returns
+    /// Grow-on-demand insert-or-lookup probe. Returns
     /// the slot index and whether it was already occupied; the slot is left
     /// `None` on miss so the caller can write the (K, V) pair.
     fn get_or_put_slot(&mut self, key: &K) -> (usize, bool) {
@@ -428,10 +416,9 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         (idx, false)
     }
 
-    /// Zig `getOrPut`: single-probe insert-or-lookup. On miss the value slot is
-    /// left "undefined" in Zig; Rust cannot expose uninit through a `&mut V`, so
-    /// `V: Default` and the slot is default-initialised — callers overwrite
-    /// `*value_ptr` when `!found_existing`.
+    /// Single-probe insert-or-lookup. Uninit values cannot be exposed through
+    /// a `&mut V`, so `V: Default` and on miss the slot is default-initialised
+    /// — callers overwrite `*value_ptr` when `!found_existing`.
     pub fn get_or_put(
         &mut self,
         key: K,
@@ -450,8 +437,8 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         })
     }
 
-    /// Zig `getOrPutContext` — alias kept for call-site parity; the context is
-    /// already bound by the type parameter.
+    /// Alias of [`get_or_put`](Self::get_or_put) kept for call-site parity;
+    /// the context is already bound by the type parameter.
     #[inline]
     pub fn get_or_put_context<Ctx>(
         &mut self,
@@ -464,7 +451,7 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         self.get_or_put(key)
     }
 
-    /// std `insert` / Zig `fetchPut` — returns the previous value if any.
+    /// std `insert` — returns the previous value if any.
     pub fn insert(&mut self, key: K, value: V) -> Option<V> {
         let (idx, found_existing) = self.get_or_put_slot(&key);
         if found_existing {
@@ -476,14 +463,14 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         }
     }
 
-    /// Zig `put`: insert or overwrite.
+    /// Insert or overwrite.
     #[inline]
     pub fn put(&mut self, key: K, value: V) -> Result<(), bun_alloc::AllocError> {
         self.insert(key, value);
         Ok(())
     }
 
-    /// Zig `putNoClobber`: insert asserting the key is new.
+    /// Insert asserting the key is new.
     pub fn put_no_clobber(&mut self, key: K, value: V) -> Result<(), bun_alloc::AllocError> {
         let prev = self.insert(key, value);
         debug_assert!(prev.is_none(), "putNoClobber: key already present");
@@ -498,7 +485,7 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         kv
     }
 
-    /// std `remove` / Zig `fetchRemove` value half.
+    /// std `remove`.
     pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
     where
         K: Borrow<Q>,
@@ -519,7 +506,7 @@ impl<K, V, C: HashContext<K>> HashMap<K, V, C> {
         self.get_index(key).and_then(|i| self.remove_by_index(i))
     }
 
-    /// Zig `fetchRemove` — remove and return the owned `{key, value}` pair.
+    /// Remove and return the owned `{key, value}` pair.
     pub fn fetch_remove(&mut self, key: &K) -> Option<crate::hash_map::KV<K, V>> {
         self.remove_entry(key)
             .map(|(k, v)| crate::hash_map::KV { key: k, value: v })
@@ -719,5 +706,3 @@ impl<'a, K, V, C: HashContext<K>> VacantEntry<'a, K, V, C> {
         &self.key
     }
 }
-
-// ported from: vendor/zig/lib/std/hash_map.zig
diff --git a/src/crash_handler/CPUFeatures.rs b/src/crash_handler/CPUFeatures.rs
index c9deab1ab63..5736ea90433 100644
--- a/src/crash_handler/CPUFeatures.rs
+++ b/src/crash_handler/CPUFeatures.rs
@@ -1,7 +1,6 @@
 // (no c types needed; kept for FFI clarity)
 use core::fmt;
 
-// TODO(port): move to crash_handler_sys
 unsafe extern "C" {
     safe fn bun_cpu_features() -> u8;
 }
@@ -11,11 +10,8 @@ pub(crate) struct CPUFeatures {
     pub flags: Flags,
 }
 
-// Zig: `packed struct(u8)` per-arch. All semantic fields are `bool`; the trailing
-// `padding: uN = 0` is unused bits. bitflags! models this directly (unknown bits
-// = padding). Bit order matches Zig packed-struct LSB-first layout.
-// PORT NOTE: guide says "bitflags! if every field is bool" — padding is uN, but
-// it is pure padding, so bitflags is the correct shape here.
+// Per-arch packed `u8`. All semantic fields are single bits; bitflags! models
+// this directly (unknown bits = padding). Bit order is LSB-first.
 
 #[cfg(target_arch = "x86_64")]
 bitflags::bitflags! {
@@ -51,8 +47,7 @@ bitflags::bitflags! {
 #[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
 compile_error!("CPUFeatures: unsupported target architecture");
 
-// Zig `inline for (@typeInfo(Flags).@"struct".fields)` — comptime reflection over
-// field names, skipping "none" and "padding". Expanded to a const table per arch.
+// Per-arch const table of flag names, skipping "none" and padding bits.
 #[cfg(target_arch = "x86_64")]
 const NAMED_FLAGS: &[(&str, Flags)] = &[
     ("sse42", Flags::SSE42),
@@ -108,8 +103,6 @@ impl CPUFeatures {
 
         #[cfg(target_arch = "x86_64")]
         {
-            // Zig: bun.analytics.Features.no_avx / no_avx2 are global mutable
-            // counters (`+= usize`). Rust port stores them as `AtomicUsize`.
             use core::sync::atomic::Ordering;
             bun_analytics::features::no_avx
                 .fetch_add(usize::from(!flags.contains(Flags::AVX)), Ordering::Relaxed);
@@ -120,5 +113,3 @@ impl CPUFeatures {
         CPUFeatures { flags }
     }
 }
-
-// ported from: src/crash_handler/CPUFeatures.zig
diff --git a/src/crash_handler/handle_oom.rs b/src/crash_handler/handle_oom.rs
index 4b16c972bdd..ac295d2fc0a 100644
--- a/src/crash_handler/handle_oom.rs
+++ b/src/crash_handler/handle_oom.rs
@@ -1,14 +1,10 @@
 use bun_alloc::AllocError;
 use bun_core::Error;
 
-// fn isOomOnlyError(comptime ErrorUnionOrSet: type) bool
-//
-// Zig's `isOomOnlyError` is pure comptime `@typeInfo` reflection over an
-// error set: it iterates the set's members and checks every name == "OutOfMemory".
-// Rust has no error-set reflection. The equivalent is encoded structurally in
-// the `HandleOom` trait impls below — the `AllocError` impls ARE the
-// "OOM-only" arm (Output = T / Output = !), and the `bun_core::Error` impls
-// ARE the "other errors possible" arm (Output = Result<T, E> / Output = E).
+// "OOM-only" vs "other errors possible" is encoded structurally in the
+// `HandleOom` trait impls below — the `AllocError` impls ARE the "OOM-only"
+// arm (Output = T / Output = !), and the `bun_core::Error` impls ARE the
+// "other errors possible" arm (Output = Result<T, E> / Output = E).
 
 /// If `error_union_or_set` is `error.OutOfMemory`, calls `bun.outOfMemory`. Otherwise:
 ///
@@ -29,7 +25,7 @@ use bun_core::Error;
 /// let thing = match allocate_thing() { Ok(v) => v, Err(err) => bun::handle_oom(err) };
 /// ```
 ///
-/// PORT NOTE: In Rust, `Vec`/`Box` allocation already aborts on OOM via the
+/// In Rust, `Vec`/`Box` allocation already aborts on OOM via the
 /// global allocator's `handle_alloc_error`. Per PORTING.md §Allocators,
 /// callsites of `bun.handleOom(expr)` translate to bare `expr`. This function
 /// remains for the residual cases where a `Result<T, AllocError>` is threaded
@@ -38,10 +34,8 @@ pub fn handle_oom<A: HandleOom>(error_union_or_set: A) -> A::Output {
     error_union_or_set.handle_oom()
 }
 
-/// Encodes Zig's comptime return-type block (`return_type: { ... }`) of
-/// `handleOom`. The Zig branched on `@typeInfo(ArgType)` (error_union vs
-/// error_set) and on `isOomOnlyError(ArgType)`; each impl below is one arm of
-/// that comptime switch.
+/// Output-type selection for [`handle_oom`]: each impl below is one arm of
+/// the input-shape × OOM-only matrix (see the section comments).
 pub trait HandleOom {
     type Output;
     fn handle_oom(self) -> Self::Output;
@@ -69,8 +63,6 @@ impl HandleOom for AllocError {
 }
 
 // ── .error_union, mixed error set → same union with OOM subtracted ───────
-// Zig computed the narrowed type via
-//   `@TypeOf(switch (err) { error.OutOfMemory => unreachable, else => |e| e })`.
 // Rust error enums are nominal, not sets — there is no set subtraction. For
 // the catch-all `bun_core::Error` we compare against the interned tag and
 // return the same type. Per-crate `thiserror` enums that carry an
@@ -97,5 +89,3 @@ impl HandleOom for Error {
         }
     }
 }
-
-// ported from: src/crash_handler/handle_oom.zig
diff --git a/src/crash_handler/lib.rs b/src/crash_handler/lib.rs
index 012fc03799a..0e9e4b57193 100644
--- a/src/crash_handler/lib.rs
+++ b/src/crash_handler/lib.rs
@@ -14,9 +14,6 @@
 //! users from having to download symbols, which can be very large.
 //!
 //! The remapper is open source: https://github.com/oven-sh/bun.report
-//!
-//! A lot of this handler is based on the Zig Standard Library implementation
-//! for std.debug.panicImpl and their code for gathering backtraces.
 
 // The cfg is the union of the two intrinsic call sites: `abort()` on the
 // non-Windows crash path (all profiles) and `breakpoint()` on Windows debug
@@ -34,8 +31,7 @@ pub mod handle_oom;
 
 /// Link-time target for `bun_alloc::out_of_memory()` — declared
 /// `extern "Rust"` in `bun_alloc` (which is below this crate in the dep graph)
-/// and defined here. Mirrors `src/bun.zig:outOfMemory()` →
-/// `crash_handler.crashHandler(.out_of_memory, null, @returnAddress())`.
+/// and defined here.
 /// `pub(crate)` so external callers route through the T0 `bun_alloc` entry
 /// rather than bypassing it.
 #[cold]
@@ -70,9 +66,7 @@ pub use draft::*;
 
 // ──────────────────────────────────────────────────────────────────────────
 // Local shim for `bun_debug` (no such crate exists yet). These are
-// std.debug.* placeholders the Zig side leaned on; the Rust port will replace
-// them with a real debug-info backend in a later pass.
-// TODO(port): bun_debug::SelfInfo / SourceLocation / TtyConfig / capture_stack_trace
+// placeholders to be replaced with a real debug-info backend in a later pass.
 // ──────────────────────────────────────────────────────────────────────────
 pub mod debug {
     use super::draft::StackTrace;
@@ -85,14 +79,14 @@ pub mod debug {
         bun_core::return_address()
     }
 
-    /// Zig: `std.debug.captureStackTrace`. Thin re-export of the canonical safe
+    /// Thin re-export of the canonical safe
     /// wrapper in bun_core so this crate's internal callers don't churn.
     #[inline]
     pub(crate) fn capture_stack_trace(begin: usize, addrs: &mut [usize]) -> usize {
         bun_core::capture_stack_trace(begin, addrs)
     }
 
-    /// Zig: `std.debug.panicImpl` fallback when ENABLE == false.
+    /// Fallback when ENABLE == false.
     pub fn panic_impl(_ert: Option<&StackTrace<'_>>, _begin: Option<usize>, msg: &[u8]) -> ! {
         panic!("{}", bstr::BStr::new(msg))
     }
@@ -100,8 +94,8 @@ pub mod debug {
     pub(crate) const HAVE_ERROR_RETURN_TRACING: bool = false;
     pub(crate) const STRIP_DEBUG_INFO: bool = !cfg!(debug_assertions);
 
-    // ── SelfInfo (vendor/zig/lib/std/debug/SelfInfo.zig) ─────────────────
-    // D104: canonical home for the dladdr-backed `std.debug.SelfInfo` shim.
+    // ── SelfInfo ──────────────────────────────────────────────────────────
+    // D104: canonical home for the dladdr-backed self-debug-info shim.
     // Previously lived in `bun_jsc::btjs::zig_std_debug`; relocated here so the
     // crash handler (lower-tier crate) gets real symbol names in debug builds
     // and `btjs` re-exports from this module.
@@ -118,14 +112,11 @@ pub mod debug {
         address_map: HashMap<usize, Box<Module>>,
     }
 
-    /// Port of `SelfInfo.Module`. On Linux Zig uses `Dwarf.ElfModule`; on Darwin a
-    /// MachO symbol table reader. Both ultimately resolve `address → {name, CU,
-    /// source_location}`. The DWARF/MachO parsers are not ported; `dladdr(3)`
+    /// A loaded module, resolving `address → {name, CU, source_location}`.
+    /// There is no DWARF/MachO parser; `dladdr(3)`
     /// provides the symbol-name half (which is what `btjs` actually consumes for
     /// its `__`/`_llint_call_javascript` prefix checks). `source_location` is left
     /// `None`, which `print_line_info` already handles.
-    // PORT NOTE: full `readElfDebugInfo`/`readMachODebugInfo` (~2k LOC of DWARF) not
-    // ported — `dladdr` is the libc-level equivalent for symbol-name resolution.
     pub struct Module {
         base_address: usize,
         name: Box<[u8]>,
@@ -223,8 +214,7 @@ pub mod debug {
 
         #[cfg(target_vendor = "apple")]
         fn lookup_module_dyld(&mut self, address: usize) -> Result<&mut Module, Error> {
-            // PORT NOTE: Zig walks `_dyld_get_image_header` + LoadCommandIterator. `dladdr`
-            // gives the same `{base_address, fname}` pair on Darwin without the MachO walk.
+            // `dladdr` gives the `{base_address, fname}` pair on Darwin without a MachO walk.
             let mut info: libc::Dl_info = bun_core::ffi::zeroed();
             // SAFETY: dladdr only reads; out-param is a valid Dl_info.
             let rc = unsafe { libc::dladdr(address as *const c_void, &raw mut info) };
@@ -253,12 +243,10 @@ pub mod debug {
         /// Port of `Module.getSymbolAtAddress`.
         #[cfg(windows)]
         pub fn get_symbol_at_address(&mut self, address: usize) -> Result<SymbolInfo, Error> {
-            // TODO(port-windows): SPEC DIVERGENCE — Zig's `std.debug.SelfInfo`
-            // resolves symbols on Windows via the loaded PE's PDB
-            // (`dbghelp.dll` `SymFromAddr`). That path is not yet ported, so
+            // Windows symbol resolution via the loaded PE's PDB
+            // (`dbghelp.dll` `SymFromAddr`) is not implemented yet, so
             // every Windows backtrace currently prints bare addresses even
-            // when a PDB is shipped. This is NOT equivalent to the Zig spec
-            // for symbol-bearing builds; return the default-initialized
+            // when a PDB is shipped. Return the default-initialized
             // `Symbol` (`name = "???"`) so the caller still prints the
             // address line, but the dbghelp lookup must be implemented
             // before Windows crash reports are usable.
@@ -277,7 +265,7 @@ pub mod debug {
             // SAFETY: dladdr only reads; out-param is a valid Dl_info.
             let rc = unsafe { libc::dladdr(address as *const c_void, &raw mut info) };
             if rc == 0 || info.dli_sname.is_null() {
-                // Zig returns a default-initialized `Symbol` (`.{}` — name "???") here
+                // Return a default-initialized `Symbol` (name "???") here
                 // rather than erroring, so the caller still prints the address line.
                 return Ok(SymbolInfo {
                     name: b"???".to_vec().into_boxed_slice(),
@@ -301,7 +289,7 @@ pub mod debug {
             Ok(SymbolInfo {
                 name,
                 compile_unit_name,
-                // PORT NOTE: DWARF line-table lookup not ported; dladdr does not provide
+                // DWARF line-table lookup is not ported; dladdr does not provide
                 // file:line. `print_line_info` handles `None` by printing `???:?:?`.
                 source_location: None,
             })
@@ -327,18 +315,17 @@ pub mod debug {
         Some(bun_paths::basename(name).to_vec().into_boxed_slice())
     }
 
-    // ── std.debug.getSelfDebugInfo ───────────────────────────────────────
+    // ── self debug-info singleton ────────────────────────────────────────
     // PORTING.md §Global mutable state: lazy debug-only singleton. RacyCell —
     // only called from a stopped/crashing process (lldb or the crash handler
     // after `panicking` has serialized), so no concurrent access; callers
     // reborrow the returned `*mut` per-access.
     static SELF_DEBUG_INFO: bun_core::RacyCell<Option<SelfInfo>> = bun_core::RacyCell::new(None);
 
-    /// Port of `std.debug.getSelfDebugInfo`. NOT thread-safe (the Zig original
-    /// has the same `TODO multithreaded awareness` caveat).
+    /// NOT thread-safe.
     pub fn get_self_debug_info() -> Result<*mut SelfInfo, Error> {
-        // SAFETY: Zig's `var self_debug_info: ?SelfInfo = null` is also a plain
-        // mutable global; this is debug-only and invoked from a stopped process.
+        // SAFETY: this is debug-only and invoked from a stopped/crashing
+        // process (see SELF_DEBUG_INFO above), so no concurrent access.
         unsafe {
             let slot = &mut *SELF_DEBUG_INFO.get();
             if let Some(info) = slot {
@@ -348,7 +335,7 @@ pub mod debug {
             Ok(std::ptr::from_mut(slot.as_mut().unwrap()))
         }
     }
-    /// Zig: `std.io.tty.detectConfig(std.io.getStdErr())`.
+    /// Detect whether stderr supports ANSI color escapes.
     #[allow(dead_code)]
     pub(crate) fn detect_tty_config_stderr() -> TtyConfig {
         if bun_core::Output::ENABLE_ANSI_COLORS_STDERR.load(core::sync::atomic::Ordering::Relaxed) {
@@ -357,7 +344,7 @@ pub mod debug {
             TtyConfig::NoColor
         }
     }
-    /// Port of `std.io.tty.Config` (vendor/zig/lib/std/Io/tty.zig). The
+    /// TTY color configuration. A
     /// `windows_api` variant is omitted: every consumer here writes into an
     /// in-memory buffer or raw fd 2, never the live `CONSOLE_SCREEN_BUFFER`, so
     /// `SetConsoleTextAttribute` would colour the wrong stream.
@@ -366,7 +353,7 @@ pub mod debug {
         NoColor,
         EscapeCodes,
     }
-    /// Port of `std.io.tty.Color` — only the variants Bun actually emits.
+    /// Terminal colors — only the variants Bun actually emits.
     #[derive(Clone, Copy, PartialEq, Eq)]
     pub enum Color {
         Bold,
@@ -378,7 +365,7 @@ pub mod debug {
         BrightCyan,
     }
     impl TtyConfig {
-        /// Port of `std.io.tty.Config.setColor`.
+        /// Write the escape sequence for `color` (no-op when colors are disabled).
         pub fn set_color<W: bun_io::Write + ?Sized>(
             self,
             w: &mut W,
@@ -423,8 +410,7 @@ impl Write for StderrWriter {
     fn write_all(&mut self, bytes: &[u8]) -> Result<(), bun_core::Error> {
         #[cfg(windows)]
         {
-            // Zig spec: `std.fs.File.stderr().writerStreaming(&.{})` — on
-            // Windows that is `GetStdHandle(STD_ERROR_HANDLE)` + kernel32
+            // On Windows this is `GetStdHandle(STD_ERROR_HANDLE)` + kernel32
             // `WriteFile`, NOT the CRT. Routing through MSVCRT `_write(2,…)`
             // would (1) text-mode-translate `\n`→`\r\n` and (2) take the CRT
             // per-fd lock, which can self-deadlock when the VEH crash handler
@@ -500,15 +486,15 @@ mod draft {
         e
     }
 
-    /// Zig: `Output.enable_ansi_colors_stderr` — runtime flag, exposed in Rust as an
-    /// `AtomicBool` static. Re-exported here so call sites read like the Zig.
+    /// Runtime flag, exposed as an
+    /// `AtomicBool` static. Re-exported here for shorter call sites.
     use bun_core::output::enable_ansi_colors_stderr;
 
-    /// Zig: `std.posix.abort()`. On POSIX this is `libc::abort()` (async-signal-safe).
-    /// On Windows, Zig's `std.posix.abort()` is *not* MSVCRT `abort()` — it is
-    /// `if (Debug) @breakpoint(); kernel32.ExitProcess(3);`. UCRT `abort()` would
+    /// On POSIX this is `libc::abort()` (async-signal-safe).
+    /// On Windows this is *not* MSVCRT `abort()` — it is
+    /// `if (Debug) breakpoint(); kernel32.ExitProcess(3);`. UCRT `abort()` would
     /// raise SIGABRT, may print `R6010 - abort() has been called` to stderr, and
-    /// can pop a Watson/WER dialog — none of which the Zig spec does.
+    /// can pop a Watson/WER dialog — none of which we want here.
     #[inline(always)]
     fn abort() -> ! {
         #[cfg(windows)]
@@ -526,8 +512,8 @@ mod draft {
     use super::cpu_features::CPUFeatures;
     use super::debug::{Color, SelfInfo, SourceLocation, TtyConfig};
 
-    /// Zig: `bun.fmt.fmtArgv` — print an argv vector as a shell-ish line.
-    /// crash_handler.zig:1024 calls this when the addr2line spawn fails.
+    /// Print an argv vector as a shell-ish line.
+    /// Called when the addr2line spawn fails.
     #[cfg(any(windows, target_os = "linux", target_os = "android"))]
     fn fmt_argv<W: super::Write>(w: &mut W, argv: &[Vec<u8>]) -> Result<(), bun_core::Error> {
         for (i, a) in argv.iter().enumerate() {
@@ -541,10 +527,10 @@ mod draft {
         Ok(())
     }
 
-    // TODO(port): `Cli` arrives from move-in (MOVE_DOWN bun_runtime::cli::Cli → crash_handler).
-    // Only the two bits the crash handler needs — main-thread check and the
-    // one-byte command tag for the trace URL — land here as plain globals that
-    // `bun_runtime` populates at startup.
+    // The two bits of CLI state the crash handler needs — main-thread check and
+    // the one-byte command tag for the trace URL — live here as plain globals
+    // that `bun_runtime` populates at startup (the full `Cli` stays in
+    // `bun_runtime::cli`, a higher-tier crate).
     pub mod cli_state {
         use core::sync::atomic::{AtomicU8, AtomicU64, Ordering};
 
@@ -567,7 +553,7 @@ mod draft {
         }
     }
 
-    // std.builtin.StackTrace lives in bun_core (T0); the debug-info types are local
+    // `StackTrace` lives in bun_core (T0); the debug-info types are local
     // shims (see `super::debug`) until a real bun_debug crate exists.
     pub use bun_core::StackTrace;
 
@@ -584,7 +570,7 @@ mod draft {
 
     /// Non-zero whenever the program triggered a panic.
     /// The counter is incremented/decremented atomically.
-    /// PORT NOTE: shared with bun_core::PANICKING so T0 callers see the same state.
+    /// Shared with bun_core::PANICKING so T0 callers see the same state.
     use bun_core::PANICKING;
     // D131: dedup — these read the shared `PANICKING` atomic and were byte-identical
     // to the bun_core (T0) copies. Re-export so `bun_crash_handler::{is_panicking,
@@ -620,7 +606,7 @@ mod draft {
     // PORTING.md §Concurrency: `bun_threading::Guarded<Vec<..>>` instead of bare Mutex + global Vec.
     // Stores a boxed type-erased closure (not a bare fn pointer) so that
     // `append_pre_crash_handler` can monomorphize a wrapper that actually invokes the
-    // caller's typed handler — mirroring Zig's `comptime handler` trampoline.
+    // caller's typed handler.
     struct CrashHandlerEntry(*mut c_void, Box<dyn Fn(*mut c_void) + Send>);
     // SAFETY: only accessed under the mutex; the opaque ptr is never dereferenced
     // except by the registered callback on the crash thread.
@@ -638,7 +624,6 @@ mod draft {
     pub enum CrashReason {
         /// From @panic()
         Panic(&'static [u8]),
-        // TODO(port): lifetime — Zig holds a borrowed []const u8; using &'static here as a placeholder.
         /// "reached unreachable code"
         Unreachable,
 
@@ -720,7 +705,13 @@ mod draft {
         Parse(&'static [u8]),
         Visit(&'static [u8]),
         Print(&'static [u8]),
-        // TODO(port): lifetime — these slices borrow caller-owned paths; &'static is a placeholder.
+        // These slices are stored in the `CURRENT_ACTION` thread-local, so they
+        // are typed `'static`. Callers pass `Source.path` data whose
+        // `Path<'static>` is itself an upstream `into_static()` lifetime
+        // erasure of arena/resolver-owned bytes (see paths/lib.rs); the data
+        // is not truly `'static`. Correctness relies on the `scoped_action`
+        // RAII guard restoring the thread-local before the owning arena or
+        // resolver storage is freed.
         #[cfg(feature = "show_crash_trace")]
         BundleGenerateChunk(BundleGenerateChunk),
         #[cfg(not(feature = "show_crash_trace"))]
@@ -780,7 +771,7 @@ mod draft {
     }
 
     /// RAII guard returned by [`scoped_action`] / [`set_current_action_resolver`].
-    /// Restores the previous `CURRENT_ACTION` on drop (Zig: `defer current_action = old`).
+    /// Restores the previous `CURRENT_ACTION` on drop.
     pub struct ActionGuard(Option<Action>);
     impl Drop for ActionGuard {
         #[inline]
@@ -791,8 +782,7 @@ mod draft {
 
     /// Scoped `CURRENT_ACTION = action`. Snapshots the previous value, installs
     /// `action`, and returns an [`ActionGuard`] that restores the previous value
-    /// on drop. Zig: `const old = current_action; defer current_action = old;
-    /// current_action = ...;`.
+    /// on drop.
     #[inline]
     #[must_use]
     pub fn scoped_action(action: Action) -> ActionGuard {
@@ -801,13 +791,13 @@ mod draft {
         ActionGuard(prev)
     }
 
-    /// Scoped `CURRENT_ACTION = .resolver{...}`. Zig (resolver.zig:672-679) sets
-    /// this only under `Environment.show_crash_trace` because module resolution is
-    /// extremely hot and has a low crash rate; the cfg-gate here mirrors that.
+    /// Scoped `CURRENT_ACTION = Resolver{...}`. Set
+    /// only under `Environment.show_crash_trace` because module resolution is
+    /// extremely hot and has a low crash rate.
     ///
     /// `source_dir`/`import_path` are caller-interned (DirnameStore / source text)
     /// and outlive the guard; the `&'static` lifetime erasure matches the existing
-    /// `Action::Parse`/`Visit`/`Print` slice fields (see TODO(port) above).
+    /// `Action::Parse`/`Visit`/`Print` slice fields (see the comment on those fields).
     #[inline]
     pub fn set_current_action_resolver(
         source_dir: &[u8],
@@ -841,7 +831,7 @@ mod draft {
         /// pointers from `fp` (POSIX) / RtlCapture and trim by `pc` (Windows). `pc`
         /// becomes frame 0.
         Fault { pc: usize, fp: usize },
-        /// A trace was already captured upstream (Zig error return traces).
+        /// A trace was already captured upstream.
         ErrorReturn(&'a StackTrace<'a>),
         /// Walk the current stack and trim the capture machinery above this PC.
         BeginAddr(usize),
@@ -881,8 +871,8 @@ mod draft {
                     //
                     // Output.errorWriter() is not used here because it may not be configured
                     // if the program crashes immediately at startup.
-                    // TODO(port): std.fs.File.stderr().writerStreaming — local raw StderrWriter (bun_sys
-                    //             FileWriter only impls std::io::Write, not the local byte-Write trait)
+                    // A local raw StderrWriter is used
+                    // because bun_sys's FileWriter only impls std::io::Write, not the local byte-Write trait.
                     let writer = &mut stderr_writer();
 
                     // The format of the panic trace is slightly different in debug
@@ -939,9 +929,10 @@ mod draft {
                             {
                                 abort();
                             }
-                        } else if UNSUPPORTED_UV_FUNCTION.with(|c| c.get()).is_some() {
-                            // TODO(port): bun_analytics::Features::unsupported_uv_function — using
-                            // the threadlocal as a stand-in for the global counter check.
+                        } else if bun_analytics::features::unsupported_uv_function
+                            .load(Ordering::Relaxed)
+                            > 0
+                        {
                             let name: &[u8] = UNSUPPORTED_UV_FUNCTION
                                 .with(|c| c.get())
                                 .map(|p| {
@@ -1045,8 +1036,7 @@ mod draft {
                                             abort();
                                         }
                                         // NOTE: `GetThreadDescription` heap-allocates `name` and the
-                                        // caller is meant to `LocalFree` it. The Zig spec leaks it
-                                        // identically (crash_handler.zig:316-322) — this runs on a
+                                        // caller is meant to `LocalFree` it. This runs on a
                                         // `noreturn` crash path immediately before `ExitProcess(3)`,
                                         // so the leak is intentional.
                                     } else {
@@ -1069,7 +1059,6 @@ mod draft {
                                 target_os = "freebsd"
                             ))]
                             { /* no-op */ }
-                            // TODO(port): wasm @compileError("TODO")
                         }
 
                         if writer.write_all(b": ").is_err() {
@@ -1171,8 +1160,10 @@ mod draft {
                                 "Bun has encountered a crash while running the <red><d>\"{s}\"<r> native plugin.\n\nTo send a redacted crash report to Bun's team,\nplease file a GitHub issue using the link below:\n\n",
                                 true,
                             ), bstr::BStr::new(native_plugin_name)).is_err() { abort(); }
-                            } else if UNSUPPORTED_UV_FUNCTION.with(|c| c.get()).is_some() {
-                                // TODO(port): bun_analytics::Features::unsupported_uv_function
+                            } else if bun_analytics::features::unsupported_uv_function
+                                .load(Ordering::Relaxed)
+                                > 0
+                            {
                                 let name: &[u8] = UNSUPPORTED_UV_FUNCTION
                                     .with(|c| c.get())
                                     .map(|p| {
@@ -1260,7 +1251,7 @@ mod draft {
                 // so that a crash will actually crash. We need this because we want the process to
                 // exit with a signal, and allow tools to be able to gather core dumps.
                 //
-                // This is done so late (in comparison to the Zig Standard Library's panic handler)
+                // This is done this late
                 // because if multiple threads segfault (more often the case on Windows), we don't
                 // want another thread to interrupt the crashing of the first one.
                 reset_segfault_handler();
@@ -1278,7 +1269,6 @@ mod draft {
                     );
                     Output::flush();
 
-                    // TODO(port): comptime assert void == @TypeOf(bun.reloadProcess(...))
                     bun_core::reload_process(false, true);
                 }
             }
@@ -1315,12 +1305,12 @@ mod draft {
         crash();
     }
 
-    /// This is called when `main` returns a Zig error.
+    /// This is called when `main` returns an error.
     /// We don't want to treat it as a crash under certain error codes.
     pub fn handle_root_error(err: bun_core::Error, error_return_trace: Option<&StackTrace>) -> ! {
         use bun_core::{err_generic, pretty_error};
 
-        /// Zig: `std.posix.getrlimit(.NOFILE)`. bun_sys::posix has no rlimit yet —
+        /// bun_sys::posix has no rlimit yet —
         /// thin libc wrapper (POD out-param, never fails on supported targets).
         #[cfg(unix)]
         fn getrlimit_nofile() -> Option<libc::rlimit> {
@@ -1440,7 +1430,7 @@ mod draft {
             }
         } else if err == bun_core::err!("NotOpenForReading") || err == bun_core::err!("Unexpected")
         {
-            // The usage of `unreachable` in Zig's std.posix may cause the file descriptor problem to show up as other errors
+            // The file descriptor problem may show up as other errors
             #[cfg(unix)]
             {
                 // SAFETY: zeroed rlimit is valid POD (integers).
@@ -1497,7 +1487,7 @@ mod draft {
             err_generic!("Bun could not find a package.json file to install from");
             bun_core::note!("Run \"bun init\" to initialize a project");
         } else {
-            // PORT NOTE: Zig picked the format string at comptime; the macros need
+            // The macros need
             // `:literal`, so branch on the const and call separately.
             if Environment::SHOW_CRASH_TRACE {
                 err_generic!(
@@ -1541,7 +1531,6 @@ mod draft {
             if msg == b"reached unreachable code" {
                 CrashReason::Unreachable
             } else {
-                // TODO(port): lifetime — Zig borrows msg; erased to &'static for the noreturn path.
                 // SAFETY: process is about to abort; the borrow is never invalidated.
                 CrashReason::Panic(unsafe { bun_collections::detach_lifetime(msg) })
             },
@@ -1647,7 +1636,7 @@ mod draft {
     #[cfg(unix)]
     extern "C" fn handle_segfault_posix(sig: c_int, info: *mut libc::siginfo_t, ctx: *mut c_void) {
         // SAFETY: kernel provides a valid siginfo_t; `si_addr` reads the per-platform
-        // sigfault address field (Zig: `info.fields.sigfault.addr` / `info.addr`).
+        // sigfault address field.
         let addr: usize = unsafe { (*info).si_addr() as usize };
 
         crash_handler(
@@ -1723,7 +1712,6 @@ mod draft {
         if Environment::ENABLE_ASAN {
             return;
         }
-        // Zig: std.posix.Sigaction{ .handler = .{ .sigaction = handleSegfaultPosix }, ... }.
         // SAFETY: zeroed sigaction is valid POD; we overwrite the fields we need.
         let mut act: libc::sigaction = bun_core::ffi::zeroed();
         act.sa_sigaction = handle_segfault_posix as *const () as usize;
@@ -1768,7 +1756,6 @@ mod draft {
         {
             reset_on_posix();
         }
-        // TODO(port): wasm @compileError("TODO")
 
         install_hooks();
     }
@@ -1783,15 +1770,14 @@ mod draft {
         // (`__bun_crash_handler_out_of_memory` / `__bun_crash_handler_dump_stack_trace`)
         // — no runtime registration needed.
         //
-        // Route Rust `panic!()` through the trace-string + report path. Zig wires
-        // `pub const panic = bun.crash_handler.panic` at the root so every
-        // `@panic()` reports; the Rust port's bare `panic!` was printing the std
-        // default hook + unwinding with no trace string and no upload.
+        // Route Rust `panic!()` through the trace-string + report path. Without
+        // this hook, a bare `panic!` would print the std
+        // default hook + unwind with no trace string and no upload.
         std::panic::set_hook(Box::new(rust_panic_hook));
     }
 
     /// `std::panic` hook: emit the same trace-string + auto-report as the fatal
-    /// `crash_handler()` path, then **abort** (matches Zig's `noreturn` panic).
+    /// `crash_handler()` path, then **abort**.
     /// With `panic = "abort"` no unwind starts after this hook returns, so there
     /// are no `catch_unwind` boundaries to reach.
     #[cold]
@@ -1813,8 +1799,7 @@ mod draft {
         PANIC_STAGE.with(|s| s.set(1));
 
         // Just the panic message — no `(file:line:col)` suffix. The call site is
-        // captured in the backtrace and symbolized there (matching Zig, which
-        // never appended a location to the message). With `-Zlocation-detail=none`
+        // captured in the backtrace and symbolized there. With `-Zlocation-detail=none`
         // in release the location would be `<redacted>:0:0` anyway.
         let mut msg_buf = BoundedArray::<u8, 1024>::default();
         {
@@ -1927,15 +1912,13 @@ mod draft {
 
         // A Rust `panic!` is a bug. The process must not continue — with
         // `panic = "abort"` no unwind starts, so `catch_unwind` boundaries are
-        // unreachable for Rust panics. This matches Zig's
-        // `pub const panic = bun.crash_handler.panic` (which is `noreturn`).
+        // unreachable for Rust panics.
         crash();
     }
 
     /// Adapter for non-fatal `bun_core::dump_current_stack_trace` callers
-    /// (fd.rs EBADF debug-warn, ref_count leak reports). Zig routes these through
-    /// `dumpStackTrace` which on Linux debug spawns `llvm-symbolizer` — but the
-    /// Rust debug binary's .debug_info is large enough that the symbolizer parse
+    /// (fd.rs EBADF debug-warn, ref_count leak reports). The
+    /// debug binary's .debug_info is large enough that an llvm-symbolizer parse
     /// alone costs ~5s, which is unacceptable on a hot non-fatal path
     /// (`closeSync(EBADF)` was timing out fs.test.ts at the 5s budget). For these
     /// advisory dumps we honour `frame_count` and use WTF's dladdr-based printer
@@ -2034,7 +2017,7 @@ mod draft {
             bun_sys::windows::EXCEPTION_ILLEGAL_INSTRUCTION => {
                 // `ExceptionAddress` is the faulting RIP for `STATUS_ILLEGAL_
                 // INSTRUCTION` (winnt.h); avoids depending on the arch-specific
-                // `CONTEXT` layout (Zig reached `ContextRecord.Rip` directly).
+                // `CONTEXT` layout.
                 CrashReason::IllegalInstruction(
                     unsafe { (*info.ExceptionRecord).ExceptionAddress } as usize
                 )
@@ -2089,7 +2072,6 @@ mod draft {
         {
             let cpu_features = CPUFeatures::get();
 
-            // TODO(port): bun_analytics::GenerateHeader::GeneratePlatform
             {
                 #[cfg(any(
                     all(target_os = "linux", target_env = "gnu"),
@@ -2243,7 +2225,7 @@ mod draft {
             )
             .map_err(fmt_err)?;
 
-            // TODO(port): {B:<3.2} byte-size formatting — bun_fmt::bytes() doesn't take width/prec yet
+            // bun_fmt::bytes() — human-readable metadata, not the trace string.
             write!(
                 writer,
                 "RSS: {} | Peak: {} | Commit: {} | Faults: {}",
@@ -2283,7 +2265,6 @@ mod draft {
         if PANICKING.fetch_sub(1, Ordering::SeqCst) != 1 {
             // Another thread is panicking, wait for the last one to finish
             // and call abort()
-            // TODO(port): builtin.single_threaded → unreachable
 
             // Sleep forever without hammering the CPU
             let futex = AtomicU32::new(0);
@@ -2307,10 +2288,8 @@ mod draft {
     impl Platform {
         // Rust cannot concat ident names at const time without a proc-macro; spell out the cfg matrix.
         const CURRENT: u8 = {
-            // Android folds into the Linux variants — Zig's `@tagName(Environment.os)`
-            // (crash_handler.zig:1153) yields `"linux"` for Android because Zig keeps
-            // it under `os.tag == .linux`. bun.report decodes the same single-char
-            // codes; introducing new ones would break older decoders.
+            // Android folds into the Linux variants. bun.report decodes the same
+            // single-char codes; introducing new ones would break older decoders.
             #[cfg(all(
                 any(target_os = "linux", target_os = "android"),
                 target_arch = "x86_64",
@@ -2384,7 +2363,7 @@ mod draft {
     /// '2' - same as '1' but this build is known to be a canary build
     const VERSION_CHAR: &str = if Environment::IS_CANARY { "2" } else { "1" };
 
-    // Zig: `if (git_sha.len > 0) git_sha[0..7] else "unknown"` — the v1/v2 trace-string
+    // The v1/v2 trace-string
     // format encodes exactly 7 hex chars. `Environment::GIT_SHA_SHORT` is 9 chars and would
     // shift every following VLQ byte, making bun.report unable to decode the URL.
     const GIT_SHA: &str = {
@@ -2405,7 +2384,7 @@ mod draft {
         address: i32,
         // None -> from bun.exe
         object: Option<Box<[u8]>>,
-        // TODO(port): Zig stores a borrowed slice into caller's `name_bytes`; using Box<[u8]> here
+        // Box<[u8]> rather than a borrowed slice into caller's `name_bytes`,
         // since the only caller writes into a stack buffer and the value is consumed immediately.
     }
 
@@ -2425,7 +2404,6 @@ mod draft {
 
                 return Some(StackLine {
                     // To remap this, `pdb-addr2line --exe bun.pdb 0x123456`
-                    // Zig: `@intCast(addr - base_address)` — unchecked in ReleaseFast.
                     // Use a wrapping cast so an oversize/underflowed module offset
                     // produces a junk frame instead of panicking *inside* the crash
                     // handler (which would escalate to a double-panic and lose the
@@ -2434,7 +2412,7 @@ mod draft {
 
                     object: if name != image_path.as_slice() {
                         // GetModuleFileNameW output never has a trailing separator
-                        // or bare drive prefix, so the std.fs.path.basenameWindows
+                        // or bare drive prefix, so `basename_windows`'s
                         // stripping is a no-op on this domain.
                         let basename = bun_paths::basename_windows(name);
                         Some(Box::<[u8]>::from(
@@ -2447,8 +2425,6 @@ mod draft {
             }
             #[cfg(target_os = "macos")]
             {
-                // This code is slightly modified from std.debug.DebugInfo.lookupModuleNameDyld
-                // https://github.com/ziglang/zig/blob/215de3ee67f75e2405c177b262cb5c1cd8c8e343/lib/std/debug.zig#L1783
                 let address = if addr == 0 { 0 } else { addr - 1 };
 
                 let image_count = bun_sys::c::_dyld_image_count();
@@ -2531,8 +2507,6 @@ mod draft {
             }
             #[cfg(not(any(windows, target_os = "macos")))]
             {
-                // This code is slightly modified from std.debug.DebugInfo.lookupModuleDl
-                // https://github.com/ziglang/zig/blob/215de3ee67f75e2405c177b262cb5c1cd8c8e343/lib/std/debug.zig#L2024
                 let _ = name_bytes;
                 let address = addr.saturating_sub(1);
                 let m = bun_sys::elf::find_loaded_module(address)?;
@@ -2719,7 +2693,7 @@ mod draft {
         writer: &mut impl Write,
         addr: usize,
     ) -> Result<(), bun_core::Error> {
-        // @bitCast(@as(u32, ...)) → reinterpret u32 as i32
+        // `as u32 as i32` reinterprets the 32-bit halves, preserving bits.
         let first = VLQ::encode((((addr as u64) & 0xFFFFFFFF00000000) >> 32) as u32 as i32);
         let second = VLQ::encode(((addr as u64) & 0xFFFFFFFF) as u32 as i32);
         writer.write_all(first.slice())?;
@@ -2751,9 +2725,8 @@ mod draft {
             return false;
         }
 
-        // Honor DO_NOT_TRACK
-        // TODO(port): bun_analytics::is_enabled
-        if env_var::DO_NOT_TRACK::get() == Some(true) {
+        // Honor DO_NOT_TRACK (and the bunfig telemetry setting)
+        if !bun_analytics::is_enabled() {
             return false;
         }
 
@@ -2809,7 +2782,6 @@ mod draft {
             cmd_line.append_slice_assume_capacity(bun_core::w!(
                 "powershell -ExecutionPolicy Bypass -Command \"try{Invoke-RestMethod -Uri '"
             ));
-            // PERF(port): was assume_capacity
             {
                 // `unused_capacity_slice` is `&mut [MaybeUninit<u16>]`;
                 // `from_raw_parts_mut::<u16>` over that storage would assert the
@@ -2844,7 +2816,7 @@ mod draft {
             // SAFETY: we just wrote a NUL terminator at len-1
             let end = cmd_line.len() - 1;
             let cmd_line_slice = &mut cmd_line.slice()[0..end];
-            // TODO(port): need [:0] sentinel slice — pass raw pointer
+            // Rust has no [:0] sentinel slices — pass the raw pointer instead.
             // SAFETY: all pointer args are either null or point to stack-local buffers/structs valid for the duration of the call; cmd_line is NUL-terminated above
             let spawn_result = unsafe {
                 windows::kernel32::CreateProcessW(
@@ -2864,8 +2836,7 @@ mod draft {
             // we don't care what happens with the process
             // NOTE: on success `CreateProcessW` returns two open kernel handles in
             // `process.hProcess` / `process.hThread` that the caller is meant to
-            // `CloseHandle`. The Zig spec leaks them identically (crash_handler.zig:
-            // 1545-1546 `_ = spawn_result;`); `report()` runs immediately before
+            // `CloseHandle`. `report()` runs immediately before
             // `crash()` → `ExitProcess(3)`, so the kernel reclaims them anyway.
             let _ = spawn_result;
             let _ = url;
@@ -2885,7 +2856,7 @@ mod draft {
             let Ok(cwd) = bun_core::getcwd(&mut buf2) else {
                 return;
             };
-            // PORT NOTE: reshaped for borrowck — capture cwd bytes by value (it
+            // Reshaped for borrowck — capture cwd bytes by value (it
             // borrows buf2, not buf, so no actual overlap; copy len for clarity).
             let cwd_bytes = cwd.as_bytes();
             let Some(curl) = bun_which::which(&mut buf, path_env, cwd_bytes, b"curl") else {
@@ -2933,7 +2904,6 @@ mod draft {
                 _ => {}
             }
         }
-        // TODO(port): wasm @compileError("Not implemented")
         #[cfg(not(unix))]
         let _ = url;
     }
@@ -2944,7 +2914,6 @@ mod draft {
         #[cfg(not(windows))]
         {
             // Install default handler so that the tkill below will terminate.
-            // Zig: std.posix.Sigaction{ .handler = SIG.DFL, .mask = sigemptyset(), .flags = 0 }.
             // bun_sys::posix has no Sigaction yet — use libc directly (async-signal-safe).
             // SAFETY: all-zero is a valid sigaction (handler = SIG_DFL = 0, flags = 0).
             let mut sigact: libc::sigaction = bun_core::ffi::zeroed();
@@ -2975,9 +2944,9 @@ mod draft {
                     libc::sigaction(sig, &raw const sigact, core::ptr::null_mut());
                 }
             }
-            // Zig: `@trap()` — emits ud2 (x86_64 → SIGILL) / brk (aarch64 → SIGTRAP).
-            // `core::intrinsics::abort()` lowers to the same trap instruction, preserving
-            // the Zig exit signal. Do NOT use `libc::abort()` here — that raises SIGABRT
+            // `core::intrinsics::abort()` lowers to a trap instruction —
+            // ud2 (x86_64 → SIGILL) / brk (aarch64 → SIGTRAP).
+            // Do NOT use `libc::abort()` here — that raises SIGABRT
             // (exit 134), which is the *Windows* path's behaviour.
             core::intrinsics::abort();
         }
@@ -2986,9 +2955,8 @@ mod draft {
             // Node.js exits with code 134 (128 + SIGABRT) instead. We use abort() as it
             // includes a breakpoint which makes crashes easier to debug.
             //
-            // Zig spec (crash_handler.zig:1592): the `.windows` arm is literally
-            // `std.posix.abort();` — i.e. our same-module `abort()` helper, which on
-            // Windows is `@breakpoint()` (Debug only) then `kernel32.ExitProcess(3)`.
+            // The same-module `abort()` helper on
+            // Windows is `breakpoint()` (Debug only) then `kernel32.ExitProcess(3)`.
             // Do NOT call MSVCRT `libc::abort()` here — that raises SIGABRT, may print
             // the CRT `abort() has been called` message, and can invoke WER.
             abort()
@@ -3003,7 +2971,8 @@ mod draft {
         err_int_workaround_for_zig_ccall_bug: u16,
         trace: &StackTrace,
     ) {
-        // TODO(port): std.meta.Int(.unsigned, @bitSizeOf(anyerror)) — bun_core::Error is errno-based
+        // bun_core::Error
+        // is errno-based, so the error round-trips through its u16 representation.
         let err = bun_core::Error::from_errno(err_int_workaround_for_zig_ccall_bug as i32);
 
         // The format of the panic trace is slightly different in debug
@@ -3062,8 +3031,8 @@ mod draft {
         err: bun_core::Error,
         maybe_trace: Option<&StackTrace>,
     ) {
-        // TODO(port): builtin.have_error_return_tracing — Rust has no error-return tracing;
-        // decide whether to keep this entire mechanism or strip it.
+        // Rust has no error-return tracing; `HAVE_ERROR_RETURN_TRACING` is const
+        // false, so this path is currently dead.
         if !debug::HAVE_ERROR_RETURN_TRACING {
             return;
         }
@@ -3119,7 +3088,7 @@ mod draft {
                 // SAFETY: lazy debug-only singleton; sole `&mut` for the dump below.
                 Ok(d) => unsafe { &mut *d },
                 Err(err) => {
-                    // Zig: `stderr.print(..) catch return;` — if stderr write fails
+                    // If the stderr write fails
                     // (e.g. broken pipe), bail out entirely; don't fall through.
                     if write!(stderr, "Unable to dump stack trace: Unable to open debug info: {}\nFallback trace:\n", bstr::BStr::new(err.name())).is_err() { return; }
                     break 'attempt_dump;
@@ -3205,7 +3174,6 @@ mod draft {
                 ]
             };
             for &program in programs {
-                // PERF(port): was arena bulk-free + StackFallbackAllocator — using global allocator here.
                 // Only stop once a symbolizer actually ran and exited 0. Any failure
                 // (not found, spawn error, or non-zero exit) tries the next program and
                 // ultimately falls through to the WTF fallback below — a found-but-broken
@@ -3216,8 +3184,7 @@ mod draft {
                 }
             }
             let _ = limits;
-            // INTENTIONAL DIVERGENCE from Zig spec (crash_handler.zig:1749-1760 falls
-            // off the end of the `for (programs)` loop with no further fallback). On
+            // On
             // Windows, `spawn_sync_inherit` is stubbed and `pdb-addr2line` is rarely
             // installed, so without this the user would get *only* "Fallback trace:"
             // and nothing else. Hand the raw addresses to WTF (always linked) so there
@@ -3235,15 +3202,13 @@ mod draft {
         program: &bun_core::ZStr,
         trace: &StackTrace,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut argv: Vec<Vec<u8>> = Vec::new();
         argv.push(program.as_bytes().to_vec());
         argv.push(b"--exe".to_vec());
         argv.push({
             #[cfg(windows)]
             {
-                // `to_utf8_alloc` is infallible (Vec<u8>); the Zig version returned
-                // `![]u8` only for OOM, which Rust handles via abort.
+                // `to_utf8_alloc` is infallible (Vec<u8>); OOM aborts.
                 let image_path = strings::to_utf8_alloc(bun_sys::windows::exe_path_w());
                 let mut s = image_path[0..image_path.len() - 3].to_vec();
                 s.extend_from_slice(b"pdb");
@@ -3305,7 +3270,7 @@ mod draft {
     pub fn suppress_core_dumps_if_necessary() {
         #[cfg(unix)]
         {
-            // Zig: std.posix.getrlimit / setrlimit. bun_sys::posix has no rlimit
+            // bun_sys::posix has no rlimit
             // surface yet — go straight to libc (already a dep, async-signal-safe).
             // SAFETY: all-zero rlimit is valid POD; getrlimit/setrlimit only read/write the struct.
             let mut existing_limit: libc::rlimit = bun_core::ffi::zeroed();
@@ -3347,9 +3312,8 @@ mod draft {
         ptr: *mut T,
         handler: fn(&mut T) -> Result<(), bun_core::Error>,
     ) -> Result<(), bun_alloc::AllocError> {
-        // Zig monomorphizes a `wrap.onCrash` that casts the opaque ptr back to *T and calls
-        // `handler`. Rust can't capture `handler` in a bare `fn` item, so box a closure that
-        // performs the same cast+call. Errors are intentionally swallowed (best-effort dump).
+        // Rust can't capture `handler` in a bare `fn` item, so box a closure that
+        // performs the cast+call. Errors are intentionally swallowed (best-effort dump).
         let on_crash = Box::new(move |opaque_ptr: *mut c_void| {
             // SAFETY: `opaque_ptr` is the `ptr.cast()` stored below; it was a valid *mut T
             // when registered and remove_pre_crash_handler() unregisters it before drop.
@@ -3380,14 +3344,12 @@ mod draft {
         pub source_location: Option<SourceLocation>,
         pub symbol_name: Box<[u8]>,
         pub compile_unit_name: Box<[u8]>,
-        // TODO(port): Zig stores borrowed slices owned by debug_info; using Box<[u8]> here.
     }
 
-    // PORT NOTE: Zig's `SourceAtAddress.deinit` only freed `source_location.file_name`;
-    // `Option<SourceLocation>` owns it as `Box<[u8]>` so Drop handles it — no explicit deinit.
+    // `Option<SourceLocation>` owns its file name as `Box<[u8]>` so Drop handles it — no explicit deinit.
 
     // D130: deduped — canonical def lives in bun_core (T0). Re-export under the
-    // Zig-spec name so internal use-sites and any downstream
+    // old name so internal use-sites and any downstream
     // `bun_crash_handler::WriteStackTraceLimits` importers keep compiling.
     pub use bun_core::DumpStackTraceOptions as WriteStackTraceLimits;
 
@@ -3410,7 +3372,7 @@ mod draft {
             .index
             .min(stack_trace.instruction_addresses.len());
 
-        // PORT NOTE: Zig's `while (...) : ({ frames_left -= 1; frame_index = ... })` continue-expression
+        // The `frames_left -= 1; frame_index = ...` continue-expression
         // is inlined at every `continue` site and at end-of-loop below.
         while frames_left != 0 {
             if frame_index >= limits.frame_count {
@@ -3545,7 +3507,6 @@ mod draft {
         compile_unit_name: &[u8],
         tty_config: TtyConfig,
     ) -> Result<(), bun_core::Error> {
-        // Zig: `Environment.base_path ++ std.fs.path.sep_str` (comptime concat).
         // `Environment::BASE_PATH` is `&[u8]`, which `const_format::concatcp!` cannot
         // ingest. The constant is tiny and this path is debug-only — build it once
         // at runtime in a stack BoundedArray (no heap, async-signal-safe).
@@ -3713,7 +3674,6 @@ mod draft {
                 }
                 break 'read_line;
             }
-            // unreachable in Zig (`return;` after the if/else above)
         }
         let line_without_newline = strings::trim_right(&line_buf[..fbs_len], b"\n");
         if source_location.column as usize > line_without_newline.len() {
@@ -3777,12 +3737,12 @@ mod draft {
     /// `name` must be a valid NUL-terminated C string.
     #[unsafe(no_mangle)]
     pub(crate) unsafe extern "C" fn CrashHandler__unsupportedUVFunction(name: *const c_char) {
-        // TODO(port): bun_analytics::Features::increment_unsupported_uv_function
+        bun_analytics::features::unsupported_uv_function.fetch_add(1, Ordering::Relaxed);
         UNSUPPORTED_UV_FUNCTION.with(|c| c.set(if name.is_null() { None } else { Some(name) }));
         if env_var::feature_flag::BUN_INTERNAL_SUPPRESS_CRASH_ON_UV_STUB::get() == Some(true) {
             suppress_reporting();
         }
-        // SAFETY: name is non-null (Zig dereferences it unconditionally with `.?`)
+        // SAFETY: per the caller contract above, `name` is a valid NUL-terminated C string (non-null).
         let name_bytes = unsafe { bun_core::ffi::cstr(name) }.to_bytes();
         // PORTING.md §Forbidden: no Box::leak. We're on the noreturn path, so a stack
         // buffer suffices — `panic_impl` erases to &'static for the abort path.
@@ -3834,7 +3794,5 @@ mod draft {
     pub fn fix_dead_code_elimination() {
         bun_core::keep_symbols!(CrashHandler__unsupportedUVFunction);
     }
-    // In Zig: comptime { _ = &Bun__crashHandler; ... } — Rust links #[no_mangle] symbols unconditionally.
+    // Rust links #[no_mangle] symbols unconditionally.
 } // end mod draft
-
-// ported from: src/crash_handler/crash_handler.zig
diff --git a/src/csrf/lib.rs b/src/csrf/lib.rs
index 77285aedeae..06ff64b7e17 100644
--- a/src/csrf/lib.rs
+++ b/src/csrf/lib.rs
@@ -17,7 +17,6 @@ pub const DEFAULT_EXPIRATION_MS: u64 = 24 * 60 * 60 * 1000;
 pub const DEFAULT_ALGORITHM: Algorithm = Algorithm::Sha256;
 
 /// Error types for CSRF operations
-// TODO(port): thiserror not in deps — manual Display/Error impl for now
 #[derive(strum::IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Error {
     InvalidToken,
@@ -29,8 +28,8 @@ bun_core::impl_tag_error!(Error);
 
 bun_core::named_error_set!(Error);
 
-/// Options for generating CSRF tokens
-// TODO(port): Zig has per-field defaults; Rust callers must specify all fields
+/// Options for generating CSRF tokens. Defaults are noted on
+/// each field; callers must specify all fields.
 pub struct GenerateOptions<'a> {
     /// Secret key to use for signing
     pub secret: &'a [u8],
@@ -45,8 +44,8 @@ pub struct GenerateOptions<'a> {
     pub algorithm: Algorithm, // = DEFAULT_ALGORITHM
 }
 
-/// Options for validating CSRF tokens
-// TODO(port): Zig has per-field defaults; Rust callers must specify all fields
+/// Options for validating CSRF tokens. Defaults are noted on
+/// each field; callers must specify all fields.
 pub struct VerifyOptions<'a> {
     /// The token to verify
     pub token: &'a [u8],
@@ -162,9 +161,9 @@ pub fn verify(options: &VerifyOptions<'_>) -> bool {
         token = &token[0..token.len() - 1];
     }
 
-    // PORT NOTE: reshaped for borrowck — compute decoded_len, then borrow buf immutably afterward
+    // Reshaped for borrowck — compute decoded_len, then borrow buf immutably afterward
     let decoded_len: usize = match encoding {
-        // shares same decoder but encoder is different see encoding.zig
+        // base64 and base64url share the same decoder, but the encoders differ
         TokenFormat::Base64Url | TokenFormat::Base64 => {
             // do the same as Buffer.from(token, "base64url" | "base64")
             // "\r\n\t " ++ VT (0x0b)
@@ -276,8 +275,4 @@ pub fn verify(options: &VerifyOptions<'_>) -> bool {
     boring::constant_time_eq(received_signature, signature)
 }
 
-// NOTE: the Zig file re-exports csrf__generate / csrf__verify from
-// ../runtime/api/csrf_jsc.zig — per PORTING.md these *_jsc aliases are
-// deleted; JS bindings live in the *_jsc crate as extension methods.
-
-// ported from: src/csrf/csrf.zig
+// NOTE: JS bindings live in the *_jsc crate as extension methods.
diff --git a/src/css/compat.rs b/src/css/compat.rs
index 9626e55d803..2b556c4ddc7 100644
--- a/src/css/compat.rs
+++ b/src/css/compat.rs
@@ -1,5 +1,4 @@
 // This file is autogenerated by build-prefixes.js. DO NOT EDIT!
-// (Rust port: per-browser min-version tables emitted from src/css/compat.zig.)
 
 use crate::targets::Browsers;
 
@@ -5472,8 +5471,8 @@ impl Feature {
     /// Returns whether *any* of the given browser targets supports this
     /// feature natively.
     pub fn is_partially_compatible(self, targets: &Browsers) -> bool {
-        // Generic implementation in terms of `is_compatible`, mirroring
-        // compat.zig:5327-5394 — probe each browser field one at a time.
+        // Generic implementation in terms of `is_compatible` —
+        // probe each browser field one at a time.
         macro_rules! probe {
             ($field:ident) => {
                 if targets.$field.is_some() {
@@ -5497,5 +5496,3 @@ impl Feature {
         false
     }
 }
-
-// ported from: src/css/compat.zig
diff --git a/src/css/context.rs b/src/css/context.rs
index fe7ed8ece08..0c8c53dff0b 100644
--- a/src/css/context.rs
+++ b/src/css/context.rs
@@ -18,8 +18,7 @@ pub struct SupportsEntry {
     pub important_declarations: Vec<css::Property>,
 }
 
-// PORT NOTE: `deinit(this, arena)` deleted — all fields own their storage and drop
-// automatically. `css.deepDeinit` over the Vecs is handled by `Vec<Property>`'s Drop.
+// No explicit deinit — all fields own their storage and drop automatically.
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum DeclarationContext {
@@ -30,7 +29,7 @@ pub enum DeclarationContext {
 }
 
 pub struct PropertyHandlerContext<'a> {
-    // PORT NOTE: `arena` is the parser arena that owns the AST being
+    // `arena` is the parser arena that owns the AST being
     // minified; bound to `'a` alongside the other borrowed inputs.
     pub arena: &'a Bump,
     pub targets: css::targets::Targets,
@@ -135,7 +134,6 @@ impl<'a> PropertyHandlerContext<'a> {
         let mut dest: Vec<css::CssRule<T>> = Vec::with_capacity(self.supports.len());
 
         for entry in &self.supports {
-            // PERF(port): was appendAssumeCapacity
             dest.push(css::CssRule::Supports(css::SupportsRule {
                 condition: entry.condition.deep_clone(self.arena),
                 rules: css::CssRuleList {
@@ -192,8 +190,6 @@ impl<'a> PropertyHandlerContext<'a> {
                             media_type: css::media_query::MediaType::All,
                             condition: Some(MediaCondition::Feature(Box::new_in(
                                 MediaFeature::Plain {
-                                    // TODO(port): verify exact MediaFeatureName / MediaFeatureValue
-                                    // variant shapes from css::media_query once ported.
                                     name: css::media_query::MediaFeatureName::Standard(
                                         MediaFeatureId::PrefersColorScheme,
                                     ),
@@ -233,9 +229,7 @@ impl<'a> PropertyHandlerContext<'a> {
         dest
     }
 
-    // PORT NOTE: reshaped — Zig passed `comptime dir: []const u8` and `comptime decls: []const u8`
-    // and used `@field` to select the Direction variant and the self.ltr/self.rtl Vec by name.
-    // Rust has no @field; pass the Direction value and a borrow of the decls Vec directly.
+    // Takes the Direction value and a borrow of the decls Vec directly.
     pub fn get_additional_rules_helper<T>(
         &self,
         dir: css::selector::parser::Direction,
@@ -267,7 +261,7 @@ impl<'a> PropertyHandlerContext<'a> {
 
 impl<'a> PropertyHandlerContext<'a> {
     pub fn reset(&mut self) {
-        // PORT NOTE: per-element `deinit()` calls dropped — Vec::clear drops each element,
+        // Per-element `deinit()` calls dropped — Vec::clear drops each element,
         // and SupportsEntry / Property own their resources via Drop.
         self.supports.clear();
         self.ltr.clear();
@@ -329,13 +323,13 @@ impl<'a> PropertyHandlerContext<'a> {
         }
 
         let fallbacks = unparsed.value.get_fallbacks(bump, &self.targets);
-        // PORT NOTE: Zig `for (fallbacks.slice()) |c|` copies by value; `SmallList`
+        // `SmallList`
         // has no `IntoIterator`, so spill to a Vec to preserve P3-before-LAB order.
         for condition_and_fallback in fallbacks.to_owned_slice().into_vec() {
             self.add_conditional_property(
                 condition_and_fallback.0,
                 css::Property::Unparsed(UnparsedProperty {
-                    // `PropertyId` is `Copy`; Zig `deepClone` was identity.
+                    // `PropertyId` is `Copy`.
                     property_id: unparsed.property_id,
                     value: condition_and_fallback.1,
                 }),
@@ -343,5 +337,3 @@ impl<'a> PropertyHandlerContext<'a> {
         }
     }
 }
-
-// ported from: src/css/context.zig
diff --git a/src/css/css_modules.rs b/src/css/css_modules.rs
index 1385fa555ea..2fa394cd183 100644
--- a/src/css/css_modules.rs
+++ b/src/css/css_modules.rs
@@ -5,12 +5,11 @@ use bun_alloc::{ArenaVec as BumpVec, ArenaVecExt as _};
 use bun_collections::ArrayHashMap;
 
 use crate as css;
-// TODO(port): narrow error set
 pub use crate::Error;
 
 // ─────────────────────────────────────────────────────────────────────────
-// `reference_dashed`'s `dest.importRecord()` lookup is hoisted to the caller (see PORT NOTE on
-// the method) to satisfy Rust borrowck (caller holds `&mut dest.css_module`).
+// `reference_dashed`'s `dest.importRecord()` lookup is hoisted to the caller (see the comment
+// on the method) to satisfy Rust borrowck (caller holds `&mut dest.css_module`).
 // ─────────────────────────────────────────────────────────────────────────
 pub struct CssModule<'a> {
     pub config: &'a Config,
@@ -36,7 +35,6 @@ impl<'a> CssModule<'a> {
                 let source: &[u8] = 'source: {
                     // Make paths relative to project root so hashes are stable
                     if let Some(root) = project_root {
-                        // Zig: `bun.path.Platform.auto.isAbsolute(root)`
                         if bun_paths::is_absolute(root) {
                             alloced = true;
                             break 'source bump.alloc_slice_copy(
@@ -46,9 +44,8 @@ impl<'a> CssModule<'a> {
                     }
                     break 'source path.as_ref();
                 };
-                // PORT NOTE: Zig `defer if (alloced) arena.free(source);` — arena-allocated, bulk-freed on bump.reset()
+                // `source` is arena-allocated, bulk-freed on bump.reset()
                 let _ = alloced;
-                // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
                 hashes.push(hash(
                     bump,
                     format_args!("{}", bstr::BStr::new(source)),
@@ -59,7 +56,6 @@ impl<'a> CssModule<'a> {
         };
         let exports_by_source_index = 'exports_by_source_index: {
             let mut exports_by_source_index = BumpVec::with_capacity_in(sources.len(), bump);
-            // PERF(port): was appendNTimesAssumeCapacity — profile if it shows up on a hot path
             for _ in 0..sources.len() {
                 exports_by_source_index.push(CssModuleExports::default());
             }
@@ -74,12 +70,9 @@ impl<'a> CssModule<'a> {
         }
     }
 
-    // PORT NOTE: `deinit` was a no-op (`// TODO: deinit`); Drop is implicit. No `impl Drop` needed.
-
     pub fn get_reference(&mut self, bump: &'a Bump, name: &'a [u8], source_index: u32) {
-        // PORT NOTE: Zig `getOrPut` returns an uninitialized value slot;
         // bun_collections::ArrayHashMap::get_or_put requires `V: Default`
-        // (CssModuleExport can't be Default — BumpVec field). Reshaped to the
+        // (CssModuleExport can't be Default — BumpVec field), so use the
         // entry()-API instead.
         use bun_collections::array_hash_map::MapEntry;
         match self.exports_by_source_index[source_index as usize].entry(name) {
@@ -102,8 +95,7 @@ impl<'a> CssModule<'a> {
         }
     }
 
-    // PORT NOTE: Zig `referenceDashed` took `*Printer` so it could read
-    // `dest.arena` and call `dest.importRecord(idx)`. In Rust the only
+    // This does not take `&mut Printer`: the only
     // caller (`DashedIdentReference::to_css`) already holds a `&mut` borrow of
     // `dest.css_module` (which *is* `self`), so threading `&mut Printer` in
     // here would alias. The caller pre-resolves the import-record path and
@@ -134,9 +126,8 @@ impl<'a> CssModule<'a> {
             }
             None => {
                 // Local export. Mark as used.
-                // PORT NOTE: Zig `getOrPut` returns an uninitialized value
-                // slot; `CssModuleExport` cannot be `Default` (BumpVec field),
-                // so reshape to the `entry()` API like `get_reference` above.
+                // `CssModuleExport` cannot be `Default` (BumpVec field),
+                // so use the `entry()` API like `get_reference` above.
                 use bun_collections::array_hash_map::MapEntry;
                 match self.exports_by_source_index[source_index as usize].entry(name) {
                     MapEntry::Occupied(mut o) => {
@@ -173,8 +164,8 @@ impl<'a> CssModule<'a> {
             false,
         );
 
-        // PORT NOTE: std.fmt.allocPrint(arena, "--{s}", .{the_hash}) → bump Vec
-        // (bumpalo::Vec<u8> lacks io::Write; the format string was a pure concat anyway).
+        // Build `--{the_hash}` as a bump Vec — a plain concat
+        // (`bumpalo::Vec<u8>` lacks `io::Write`, and no formatting is needed).
         let mut k = BumpVec::with_capacity_in(2 + the_hash.len(), bump);
         k.extend_from_slice(b"--");
         k.extend_from_slice(the_hash);
@@ -478,10 +469,8 @@ impl<'a> CssModuleReference<'a> {
 /// (a leaf crate) so `bun_bundler::LinkerContext::mangle_local_css` can call
 /// the *same* hasher without depending on `bun_css`. Re-export here so
 /// in-crate callers (`dependencies.rs`, `rules/import.rs`) keep the
-/// `css_modules::hash` path from the Zig spec.
+/// `css_modules::hash` path.
 #[inline]
 pub fn hash<'a>(bump: &'a Bump, args: Arguments<'_>, at_start: bool) -> &'a [u8] {
     bun_base64::wyhash_url_safe(bump, args, at_start)
 }
-
-// ported from: src/css/css_modules.zig
diff --git a/src/css/css_parser.rs b/src/css/css_parser.rs
index 2f1e72e2dd7..cb3a3cb5304 100644
--- a/src/css/css_parser.rs
+++ b/src/css/css_parser.rs
@@ -1,8 +1,7 @@
-//! CSS parser — port of `src/css/css_parser.zig`.
+//! CSS parser.
 //!
 //! This is an AST crate (see PORTING.md §Allocators): allocations are
-//! arena-backed in the Zig original. The Rust port keeps `&'bump Bump`
-//! threading where it matters and drops `Allocator` params elsewhere.
+//! arena-backed, with `&'bump Bump` threaded where it matters.
 
 use bun_alloc::ArenaVecExt as _;
 use core::fmt;
@@ -15,8 +14,7 @@ use bun_core::strings;
 
 // ───────────────────────────── re-exports ─────────────────────────────
 //
-// The Zig css_parser hub re-exports the entire crate surface. The Rust port
-// keeps that shape: cross-module re-exports + parser core live here.
+// Cross-module re-exports + parser core live here.
 
 /// `bun.ast.Index` — bundler source-file index. Hoisted into
 /// `bun_options_types` to keep css below the parser tier.
@@ -90,11 +88,9 @@ pub use crate::values::{
 
 pub use gated_shims::*;
 
-/// Minimal stand-ins for types that live in still-gated sibling *leaf* modules
-/// (rules/{keyframes,page,container,...}, values::{number,string}). The hub
-/// modules above are real; only the per-rule payload types `AtRulePrelude`
-/// reaches into by name remain shimmed here. When a leaf un-gates, delete the
-/// matching shim.
+/// Re-exports of leaf-module payload types `AtRulePrelude` names directly,
+/// plus crate-tier shims for `bun.ast` types that live above this crate's
+/// dependency tier.
 mod gated_shims {
 
     // ── rules/ leaf-module payload re-exports ────────────────────────────
@@ -129,9 +125,6 @@ mod gated_shims {
     }
 }
 
-// `Maybe` in Zig is `bun.jsc.Node.Maybe` — a tagged result. In Rust we use
-// `core::result::Result` directly; callers `.ok()`/`.err()` instead of
-// `.asValue()`/`.asErr()`.
 pub use core::result::Result as Maybe;
 
 // PrintErr is hoisted at crate root (single-variant `to_css` error signal);
@@ -141,9 +134,6 @@ pub use crate::PrintErr;
 #[cold]
 #[inline(never)]
 pub fn oom(_e: bun_core::Error) -> ! {
-    if cfg!(debug_assertions) {
-        // Zig: assert(e == Allocator.Error.OutOfMemory)
-    }
     bun_core::out_of_memory();
 }
 
@@ -206,10 +196,6 @@ impl SourceLocation {
         }
     }
 
-    // PORT NOTE: Zig used `anytype` + `@TypeOf` to dispatch on
-    // `ParserError | BasicParseError | SelectorParseErrorKind`. In Rust this
-    // becomes a trait `IntoParserError` implemented by each live variant
-    // (the `BasicParseError` arm is dead/ill-typed in Zig — see note below).
     pub fn new_custom_error(self, err: impl IntoParserError) -> ParseError<ParserError> {
         ParseError {
             kind: errors_::ParserErrorKind::custom(err.into_parser_error()),
@@ -218,8 +204,7 @@ impl SourceLocation {
     }
 }
 
-/// Dispatch trait for `SourceLocation::new_custom_error` (replaces Zig
-/// `anytype` switch on `@TypeOf`).
+/// Dispatch trait for `SourceLocation::new_custom_error`.
 pub trait IntoParserError {
     fn into_parser_error(self) -> ParserError;
 }
@@ -229,26 +214,19 @@ impl IntoParserError for ParserError {
         self
     }
 }
-// PORT NOTE: Zig's `newCustomError` had a third `@TypeOf` arm for
-// `BasicParseError`, but that arm is dead and ill-typed — it wraps
-// `BasicParseError.intoDefaultParseError(err)` (a `ParseError(ParserError)`)
-// in `.custom`, which expects a `ParserError`. No caller ever passes
-// `BasicParseError`, so Zig's lazy comptime never instantiates it. We
-// intentionally do NOT impl `IntoParserError` for `BasicParseError` here.
+// We intentionally do NOT impl `IntoParserError` for `BasicParseError` here:
+// no caller ever passes one.
 // `SelectorParseErrorKind` is impl'd in `selectors/parser.rs`.
 
 pub type Error = Err<ParserError>;
 
 pub type CssResult<T> = Maybe<T, ParseError<ParserError>>;
-// Zig: `pub fn Result(comptime T: type) type { return Maybe(T, ParseError(ParserError)); }`
-// Rust callers use `CssResult<T>` directly.
 
 pub type PrintResult<T> = Maybe<T, PrinterError>;
 
 #[cold]
 pub fn todo(msg: &str) -> ! {
-    // bun.analytics.Features.todo_panic = 1;
-    // TODO(port): analytics counter
+    bun_core::Global::features::TODO_PANIC.store(1, core::sync::atomic::Ordering::Relaxed);
     panic!("TODO: {msg}");
 }
 
@@ -261,28 +239,21 @@ pub fn void_wrap<T>(
     move |(), p| parsefn(p)
 }
 
-// ───────────────────────── Derive*-style comptime helpers ─────────────────────────
+// ───────────────────────── Derive*-style helpers ─────────────────────────
 //
-// The Zig file defines `DefineListShorthand`, `DefineShorthand`,
-// `DefineRectShorthand`, `DefineSizeShorthand`, `DeriveParse`, `DeriveToCss`,
-// `DefineEnumProperty`, `DeriveValueType` — all of which use `@typeInfo` /
-// `@field` comptime reflection to generate `parse`/`toCss`/etc. for arbitrary
-// types. PORTING.md §Comptime reflection: the protocol becomes a trait
+// PORTING.md §Comptime reflection: each protocol is a trait
 // (`ToCss`, `Parse`, `EnumProperty`, ...) and per-type impls are generated by
 // a `#[derive(...)]` proc-macro. We declare the traits here and stub the
 // helper bodies that callers in other files reference.
 
 /// Shorthand longhand-reconstruction helpers.
 ///
-/// PORT NOTE: Zig's `DefineShorthand` bodies are `@compileError(todo_stuff.depth)`
-/// — i.e. instantiating the comptime fn and reaching any method is a compile
-/// error. The faithful Rust mapping is a trait with **no default bodies**: any
-/// `impl DefineShorthand for T` that omits a method fails at compile time, same
-/// as the Zig. Per-type bodies are emitted by `#[derive(DefineShorthand)]`
-/// using the (currently commented-out) `PropertyFieldMap`/`VendorPrefixMap`
-/// reflection algorithm in `css_parser.zig` lines 316–500.
+/// Note: this trait has **no default bodies**: any `impl DefineShorthand for T`
+/// that omits a method fails at compile time. Per-type bodies are emitted by
+/// `#[derive(DefineShorthand)]` using the (currently commented-out)
+/// `PropertyFieldMap`/`VendorPrefixMap` reflection algorithm.
 pub trait DefineShorthand: Sized {
-    /// The shorthand's own `PropertyIdTag` (Zig: `comptime property_name`).
+    /// The shorthand's own `PropertyIdTag`.
     const PROPERTY_NAME: PropertyIdTag;
 
     /// Returns a shorthand from the longhand properties defined in the given
@@ -319,8 +290,8 @@ pub trait DefineShorthand: Sized {
     fn set_longhand(&mut self, property: &Property) -> bool;
 }
 
-// PORT NOTE: Zig's `DefineListShorthand` / `DefineRectShorthand` /
-// `DefineSizeShorthand` / `DeriveParse` / `DeriveToCss` comptime fns became
+// Note: `DefineListShorthand` / `DefineRectShorthand` / `DefineSizeShorthand`
+// / `DeriveParse` / `DeriveToCss` are
 // proc-macros (`bun_css_derive::*`, re-exported below) plus the
 // `impl_rect_shorthand!` / `impl_size_shorthand!` macros in
 // `properties/margin_padding.rs`. The placeholder trait stubs that previously
@@ -352,12 +323,12 @@ pub mod enum_property_util {
     }
 }
 
-// Derive macros for the comptime helpers above. Re-exported here as well as
-// at crate root because some leaf modules alias `crate::css_parser as css`
-// (Zig's `css.DefineEnumProperty(...)` lived in this file).
+// Derive macros for the helpers above. Re-exported here as well as
+// at crate root because some leaf modules alias `crate::css_parser as css`.
 pub use bun_css_derive::{DefineEnumProperty, Parse, ToCss};
 
-/// Replaces Zig's `DefineEnumProperty` comptime fn.
+/// Keyword-enum CSS properties: case-insensitive parse from an ident plus a
+/// canonical string form.
 pub trait EnumProperty: Sized + Copy + Into<&'static str> {
     fn from_ascii_case_insensitive(ident: &[u8]) -> Option<Self>;
 
@@ -386,15 +357,15 @@ pub trait EnumProperty: Sized + Copy + Into<&'static str> {
     where
         Self: Into<u32>,
     {
-        // TODO(port): Zig hashed the raw enum int bytes.
+        // The hash value never leaves the process, so a fixed u32 tag width is fine.
         let tag: u32 = (*self).into();
         hasher.update(&tag.to_ne_bytes());
     }
 }
 
-/// `DeriveValueType` — maps each enum variant to a `MediaFeatureType` via a
-/// comptime field map.
-/// TODO(port): proc-macro `#[derive(ValueType)]` with attribute annotations.
+/// `DeriveValueType` — maps each enum variant to a `MediaFeatureType`. Impls
+/// are written by hand (see `media_query.rs`, `rules/container.rs`), so no
+/// derive macro is needed.
 pub trait DeriveValueType {
     fn value_type(&self) -> MediaFeatureType;
 }
@@ -406,8 +377,7 @@ pub trait DeriveValueType {
 /// (the block is unclosed).
 #[cold]
 fn consume_until_end_of_block(block_type: BlockType, tokenizer: &mut Tokenizer) -> bool {
-    // PERF(port): was SmallList<BlockType, 16> + appendAssumeCapacity — Vec is
-    // fine for the cold path.
+    // Vec is fine for the cold path.
     let mut stack: Vec<BlockType> = Vec::with_capacity(16);
     stack.push(block_type);
 
@@ -492,7 +462,7 @@ fn parse_custom_at_rule_prelude<T: CustomAtRuleParser>(
         }
     }
 
-    // TODO(port): lifetime — `name` borrows the input arena. The detach is the
+    // TODO: lifetime — `name` borrows the input arena. The detach is the
     // same `'static` erasure already applied to `Token`/`AtRulePrelude::Unknown`.
     // SAFETY: `name` points into the parser's source/arena, which outlives every
     // `AtRulePrelude`/warning produced from this parser (see `src_str`).
@@ -559,13 +529,10 @@ fn parse_until_before<T, C>(
     parse_fn: impl FnOnce(C, &mut Parser) -> CssResult<T>,
 ) -> CssResult<T> {
     let delimiters = parser.stop_before | delimiters_;
-    // PORT NOTE: reshaped for borrowck — Zig held `parser.input` aliased
-    // between the outer Parser and a stack-local "delimited" Parser. In Rust
     // `&'a mut ParserInput<'a>` is invariant and cannot be reborrowed into a
-    // second `Parser<'a>` while the first lives. We instead temporarily swap
+    // second `Parser<'a>` while the first lives, so temporarily swap
     // `stop_before` on the *same* Parser, run the inner parse, and restore.
-    // `at_start_of` is *moved into* the inner parse (Zig moved it into the
-    // delimited Parser and left the outer null) — since we reuse the same
+    // `at_start_of` is moved into the inner parse — since we reuse the same
     // Parser it carries through unchanged, and is consumed/cleared below
     // rather than restored.
     let saved_stop_before = parser.stop_before;
@@ -574,9 +541,7 @@ fn parse_until_before<T, C>(
         let result = parser.parse_entirely(closure, parse_fn);
         if matches!(error_behavior, ParseUntilErrorBehavior::Stop) && result.is_err() {
             parser.stop_before = saved_stop_before;
-            // Match Zig: the delimited parser *moved* `at_start_of` out of the
-            // outer parser (`parser.at_start_of = null;`). Since we reuse the
-            // same Parser, explicitly clear it so the caller doesn't observe a
+            // Explicitly clear `at_start_of` so the caller doesn't observe a
             // stale block-start left behind by the failing inner parse.
             parser.at_start_of = None;
             return result;
@@ -698,7 +663,7 @@ fn parse_nested_block<T>(
         BlockType::SquareBracket => Delimiters::CLOSE_SQUARE_BRACKET,
         BlockType::Parenthesis => Delimiters::CLOSE_PARENTHESIS,
     };
-    // PORT NOTE: reshaped for borrowck — same aliasing as parse_until_before.
+    // Note: reshaped for borrowck — same aliasing as parse_until_before.
     // Swap stop_before/at_start_of in place rather than constructing a second
     // Parser over the invariant `&'a mut ParserInput<'a>`.
     let saved_stop_before = parser.stop_before;
@@ -718,9 +683,6 @@ fn parse_nested_block<T>(
 }
 
 // ───────────────────────── parser-protocol traits ─────────────────────────
-//
-// Zig used `ValidQualifiedRuleParser(T)` etc. as comptime duck-type checks
-// (`@hasDecl`). PORTING.md: trait bounds ARE that check.
 
 /// Qualified rules are rules that apply styles to elements in a document.
 pub trait QualifiedRuleParser {
@@ -795,9 +757,8 @@ pub trait CustomAtRuleParser {
     fn bump_anon_layer_count(this: &mut Self, amount: i32);
 
     /// Move the registered `@layer` names accumulated via `on_layer_rule` out
-    /// of the parser. The Zig spec only populates `StyleSheet.layer_names`
-    /// when `P == BundlerAtRuleParser` (css_parser.zig:3324); Rust can't
-    /// type-specialize at the call site, so this is a trait hook with a
+    /// of the parser. Only `BundlerAtRuleParser` populates
+    /// `StyleSheet.layer_names`; this is a trait hook with a
     /// default no-op for parsers that don't track layers.
     fn take_layer_names(_this: &mut Self) -> Vec<LayerName> {
         Vec::new()
@@ -875,13 +836,11 @@ impl CustomAtRuleParser for DefaultAtRuleParser {
 pub const ENABLE_TAILWIND_PARSING: bool = false;
 
 pub type BundlerAtRule = DefaultAtRule;
-// TODO(port): when ENABLE_TAILWIND_PARSING == true, this is `TailwindAtRule`.
 
 pub struct BundlerAtRuleParser<'a> {
     pub arena: &'a Bump,
     /// Raw pointer aliasing the same `Vec` that `Parser.import_records`
-    /// points to (Zig passes one `*Vec` to both — see `parseBundler`,
-    /// css_parser.zig:3245). Both views are raw pointers sharing a single
+    /// points to. Both views are raw pointers sharing a single
     /// SharedRW provenance (see `parse_bundler`); each materialises a
     /// short-lived `&mut` only at the point of use, so accesses interleave
     /// soundly under Stacked Borrows.
@@ -895,7 +854,6 @@ pub struct BundlerAtRuleParser<'a> {
 }
 
 impl<'a> CustomAtRuleParser for BundlerAtRuleParser<'a> {
-    // TODO(port): when ENABLE_TAILWIND_PARSING, Prelude = enum { Tailwind(TailwindAtRule) }.
     type Prelude = ();
     type AtRule = BundlerAtRule;
 
@@ -905,7 +863,6 @@ impl<'a> CustomAtRuleParser for BundlerAtRuleParser<'a> {
         input: &mut Parser,
         _: &ParserOptions,
     ) -> CssResult<Self::Prelude> {
-        // TODO(port): tailwind branch (gated on ENABLE_TAILWIND_PARSING).
         Err(input.new_error(BasicParseErrorKind::at_rule_invalid(name)))
     }
 
@@ -927,7 +884,6 @@ impl<'a> CustomAtRuleParser for BundlerAtRuleParser<'a> {
         _: &ParserOptions,
         _: bool,
     ) -> Maybe<Self::AtRule, ()> {
-        // TODO(port): tailwind branch.
         Err(())
     }
 
@@ -979,8 +935,8 @@ impl<'a> CustomAtRuleParser for BundlerAtRuleParser<'a> {
                 let mut cloned = LayerName {
                     v: SmallList::default(),
                 };
-                // PERF(port): was appendSliceAssumeCapacity — `SmallList` has no
-                // public `reserve`, so two `append_slice` calls each grow once.
+                // `SmallList` has no public `reserve`, so two `append_slice`
+                // calls each grow once.
                 cloned.v.append_slice(this.enclosing_layer.v.slice());
                 cloned.v.append_slice(layer.v.slice());
                 this.layer_names.append_assume_capacity(cloned);
@@ -1022,9 +978,8 @@ impl<'a> CustomAtRuleParser for BundlerAtRuleParser<'a> {
 
 // ───────────────────────────── AtRulePrelude ─────────────────────────────
 //
-// The few leaf-module payload types not yet exposed by `rules/mod.rs`
-// (KeyframesName, PageSelector, ContainerName, ContainerCondition) come from
-// `gated_shims` above.
+// The leaf-module payload types (KeyframesName, PageSelector, ContainerName,
+// ContainerCondition) are re-exported from `rules/` via `gated_shims` above.
 
 pub enum AtRulePrelude<T> {
     FontFace,
@@ -1032,14 +987,14 @@ pub enum AtRulePrelude<T> {
     FontPaletteValues(DashedIdent),
     CounterStyle(CustomIdent),
     Import {
-        url: &'static [u8], // TODO(port): lifetime — arena-owned slice
+        url: &'static [u8], // TODO: lifetime — arena-owned slice
         media: MediaList,
         supports: Option<SupportsCondition>,
         layer: Option<Option<LayerName>>,
     },
     Namespace {
-        prefix: Option<&'static [u8]>, // TODO(port): lifetime
-        url: &'static [u8],            // TODO(port): lifetime
+        prefix: Option<&'static [u8]>, // TODO: lifetime
+        url: &'static [u8],            // TODO: lifetime
     },
     Charset,
     CustomMedia {
@@ -1053,17 +1008,13 @@ pub enum AtRulePrelude<T> {
     Supports(SupportsCondition),
     Viewport(VendorPrefix),
     Keyframes {
-        // TODO(port): real type is `css_rules::keyframes::KeyframesName` —
-        // leaf module gated in rules/mod.rs.
         name: KeyframesName,
         prefix: VendorPrefix,
     },
-    // TODO(port): real type is `Vec<css_rules::page::PageSelector>` — gated.
     Page(Vec<PageSelector>),
     MozDocument,
     Layer(SmallList<LayerName, 1>),
     Container {
-        // TODO(port): real types in `css_rules::container` — gated.
         name: Option<ContainerName>,
         condition: ContainerCondition,
     },
@@ -1074,7 +1025,7 @@ pub enum AtRulePrelude<T> {
         scope_end: Option<SelectorList>,
     },
     Unknown {
-        name: &'static [u8], // TODO(port): lifetime
+        name: &'static [u8], // TODO: lifetime
         /// The tokens of the prelude
         tokens: TokenList,
     },
@@ -1112,7 +1063,6 @@ pub enum TopLevelState {
 }
 
 pub struct TopLevelRuleParser<'a, AtRuleParserT: CustomAtRuleParser> {
-    // PORT NOTE: Zig threaded `input.arena()` at every call site; the Rust
     // `DeclarationList = bumpalo::Vec<'bump, Property>` needs the arena up
     // front, so cache it here (same `'static`-erased borrow `DeclarationBlock`
     // already uses crate-wide).
@@ -1179,13 +1129,12 @@ pub enum ComposesState {
     DisallowEntirely,
 }
 
-/// Dispatch trait for `parse_declaration_impl` (replaces Zig
-/// `composes_ctx: anytype`). Implemented by `NestedRuleParser`.
+/// Dispatch trait for `parse_declaration_impl`. Implemented by `NestedRuleParser`.
 pub trait ComposesCtx {
     fn composes_state(&self) -> ComposesState;
     fn record_composes(&mut self, composes: &mut Composes);
 }
-/// Unit `ComposesCtx` for callers that don't track `composes:` (Zig `void`).
+/// Unit `ComposesCtx` for callers that don't track `composes:`.
 pub struct NoComposesCtx;
 impl ComposesCtx for NoComposesCtx {
     #[inline]
@@ -1201,7 +1150,7 @@ pub struct NestedRuleParser<'a, T: CustomAtRuleParser> {
     pub options: &'a ParserOptions<'a>,
     pub at_rule_parser: &'a mut T,
     // todo_stuff.think_mem_mgmt
-    // PORT NOTE: `DeclarationList<'bump>` borrows the parser arena. Threading
+    // Note: `DeclarationList<'bump>` borrows the parser arena. Threading
     // `'bump` here cascades into every rule type; deferred (matches
     // `StyleRule`'s `'static` erasure in rules/style.rs).
     pub declarations: DeclarationList<'static>,
@@ -1329,11 +1278,10 @@ mod rule_parsers {
     use super::*;
     use crate::selectors::parser as selector_parser;
 
-    // PORT NOTE: Zig threaded `composes_ctx: anytype` (pointer to the
-    // `NestedRuleParser`) directly into `parse_declaration`. Rust's borrow checker
-    // forbids passing `&mut *this` while also borrowing `this.declarations` /
-    // `this.important_declarations`, so split-borrow the three composes fields
-    // into a small adaptor that implements the `ComposesCtx` dispatch trait.
+    // The borrow checker forbids passing `&mut *this` while also borrowing
+    // `this.declarations` / `this.important_declarations`, so split-borrow the
+    // three composes fields into a small adaptor that implements the
+    // `ComposesCtx` dispatch trait.
     struct NestedComposesCtx<'a> {
         state: ComposesState,
         arena: &'a Bump,
@@ -1366,13 +1314,12 @@ mod rule_parsers {
             input: &mut Parser,
         ) -> CssResult<Self::Prelude> {
             // phf-style dispatch on at-rule name (case-insensitive).
-            // Zig used `bun.ComptimeEnumMap(PreludeEnum)`.
             crate::match_ignore_ascii_case! { name, {
                 b"import" => {
                     if (this.state as u8) > (TopLevelState::Imports as u8) {
                         return Err(input.new_custom_error(ParserError::unexpected_import_rule));
                     }
-                    // TODO(port): lifetime — arena-owned slice; same `'static` erasure
+                    // TODO: lifetime — arena-owned slice; same `'static` erasure
                     // as `Token` payloads.
                     // SAFETY: the returned slice borrows `input.src`/arena, which outlives
                     // the `AtRulePrelude` it is stored in (see `src_str`).
@@ -1633,13 +1580,11 @@ mod rule_parsers {
                 composes_refs: &mut *self.composes_refs,
                 local_properties: &mut *self.local_properties,
             };
-            // PORT NOTE: reshaped for borrowck — Zig held `self.*` aliased. Spell
-            // out the impl with a fresh lifetime so `nested_parser` isn't forced
-            // to borrow `rules` for `'a`.
+            // Spell out the impl with a fresh lifetime so `nested_parser` isn't
+            // forced to borrow `rules` for `'a`.
             let parse_declarations =
                 <NestedRuleParser<'_, T> as RuleBodyItemParser>::parse_declarations(&nested_parser);
             // TODO: think about memory management
-            // PERF(port): was arena bulk-free — profile if hot.
             let mut errors: Vec<ParseError<ParserError>> = Vec::new();
             let mut iter = RuleBodyParser::new(input, &mut nested_parser);
 
@@ -1726,14 +1671,13 @@ mod rule_parsers {
             name: &[u8],
             input: &mut Parser,
         ) -> CssResult<Self::Prelude> {
-            // TODO(port): lifetime — `name` borrows the input arena. Detach to
+            // TODO: lifetime — `name` borrows the input arena. Detach to
             // `'static` to feed `BasicParseErrorKind::at_rule_invalid` (matches the
             // `Token` payload erasure throughout this file).
             // SAFETY: `name` points into the parser's source/arena, which outlives
             // every prelude/error produced from this parser (see `src_str`).
             let name: &'static [u8] = unsafe { src_str(name) };
             let result: Self::Prelude = 'brk: {
-                // Zig `ComptimeEnumMap(PreludeEnum)` ASCII-CI dispatch.
                 crate::match_ignore_ascii_case! { name, {
                     b"media" => break 'brk AtRulePrelude::Media(parse_media_list(input, this.options)?),
                     b"supports" => break 'brk AtRulePrelude::Supports(SupportsCondition::parse(input)?),
@@ -1751,10 +1695,9 @@ mod rule_parsers {
                         break 'brk AtRulePrelude::Keyframes { name: keyframes_name, prefix };
                     },
                     b"page" => {
-                        // Zig: tryParse(parseCommaSeparated(PageSelector.parse)) → on
-                        // .err returns empty list. EOF inside `PageSelector::parse`
+                        // EOF inside `PageSelector::parse`
                         // (e.g. `@page foo` with nothing after) propagates here and is
-                        // swallowed by `try_parse` — matches css_parser.zig:2073.
+                        // swallowed by `try_parse`, yielding an empty list.
                         let selectors: Vec<PageSelector> = input
                             .try_parse(|input2| {
                                 input2.parse_comma_separated(css_rules::page::PageSelector::parse)
@@ -1878,7 +1821,6 @@ mod rule_parsers {
                         let mut decl_parser = css_rules::font_face::FontFaceDeclarationParser;
                         let mut parser = RuleBodyParser::new(input, &mut decl_parser);
                         // todo_stuff.think_mem_mgmt
-                        // PERF(port): was arena bulk-free — profile if hot.
                         let mut properties: Vec<css_rules::font_face::FontFaceProperty> =
                             Vec::new();
                         while let Some(result) = parser.next() {
@@ -1978,7 +1920,6 @@ mod rule_parsers {
                         let mut parser = css_rules::keyframes::KeyframesListParser;
                         let mut iter = RuleBodyParser::new(input, &mut parser);
                         // todo_stuff.think_mem_mgmt
-                        // PERF(port): was arena bulk-free — profile if hot.
                         let mut keyframes: Vec<css_rules::keyframes::Keyframe> = Vec::new();
                         while let Some(result) = iter.next() {
                             if let Ok(keyframe) = result {
@@ -2013,18 +1954,16 @@ mod rule_parsers {
                     Ok(())
                 }
                 AtRulePrelude::Layer(mut layer) => {
-                    // PORT NOTE (css_parser.zig:2393): Zig reads
-                    // `prelude.layer.at(0).*` — a struct copy that leaves the list
-                    // intact — *then* calls `onLayerRule(&prelude.layer)` so the
-                    // hook still observes the 1-element list. Mirror that: clone
-                    // slot 0 for the rule's `name`, fire `on_layer_rule`, then
+                    // Clone slot 0 for the rule's `name` (leaving the list
+                    // intact so the `on_layer_rule` hook still observes the
+                    // 1-element list), fire `on_layer_rule`, then
                     // drain the original into `push_to_enclosing_layer`.
                     let name = if layer.len() == 0 {
                         None
                     } else if layer.len() == 1 {
                         // `LayerName` has no `Clone` impl yet; `deep_clone` is the
                         // arena-threaded shallow copy (segments are arena-borrowed
-                        // `&[u8]`, so this is the same field-walk Zig's `*` did).
+                        // `&[u8]`).
                         Some(layer.at(0).deep_clone(this.arena))
                     } else {
                         return Err(input.new_error(BasicParseErrorKind::at_rule_body_invalid));
@@ -2192,7 +2131,6 @@ mod rule_parsers {
             input: &mut Parser,
         ) -> CssResult<()> {
             let loc = this.get_loc(start);
-            // PORT NOTE: Zig `defer this.composes_refs.clearRetainingCapacity();`.
             // `composes_refs` is `&mut SmallList<..>` borrowed from the parent
             // `TopLevelRuleParser`, so dropping `NestedRuleParser` on an error path
             // does NOT clear the underlying storage. A safe `scopeguard::guard`
@@ -2203,7 +2141,7 @@ mod rule_parsers {
             // `TopLevelRuleParser`) strictly outlives this frame.
             let composes_refs_ptr: *mut SmallList<ast::Ref, 2> = &raw mut *this.composes_refs;
             scopeguard::defer! {
-                // SAFETY: see PORT NOTE above — no aliasing borrow live at drop.
+                // SAFETY: see the note above — no aliasing borrow live at drop.
                 unsafe { (*composes_refs_ptr).clear_retaining_capacity(); }
             }
             // allow composes if:
@@ -2311,7 +2249,7 @@ mod rule_parsers {
         type Declaration = ();
 
         fn parse_value(this: &mut Self, name: &[u8], input: &mut Parser) -> CssResult<()> {
-            // PORT NOTE: split-borrow — see `NestedComposesCtx` above.
+            // Note: split-borrow — see `NestedComposesCtx` above.
             // SAFETY: `input.arena()` re-borrows the parser arena through `&self`;
             // detach that borrow so `input` can be re-borrowed mutably below. The
             // arena outlives the parser (it owns all parsed allocations).
@@ -2333,8 +2271,7 @@ mod rule_parsers {
         }
     }
 
-    /// `MediaList::parse` thunk. The body lives in `media_query.rs` in Zig; the
-    /// Rust port hasn't landed it yet. Kept local so the rule-parser arms above
+    /// `MediaList::parse` thunk. Kept local so the rule-parser arms above
     /// type-check; becomes a one-line `MediaList::parse(input, options)` forwarder
     /// once `media_query::MediaList::parse` un-gates.
     // blocked_on: media_query::{MediaList,MediaQuery}::parse
@@ -2351,7 +2288,7 @@ pub struct ToCssResult {
     pub code: Vec<u8>,
     /// A map of CSS module exports, if the `css_modules` option was enabled
     /// during parsing.
-    // TODO(port): arena lifetime — CssModuleExports/References borrow the
+    // TODO: arena lifetime — CssModuleExports/References borrow the
     // parser arena. `'static` placeholder until `<'bump>` threads.
     pub exports: Option<CssModuleExports<'static>>,
     /// A map of CSS module references, if the `css_modules` config had
@@ -2458,7 +2395,6 @@ impl CssRef {
     }
 
     pub fn to_real_ref(self, source_index: u32) -> bun_ast::Ref {
-        // Spec (css_parser.zig) constructs `Ref{ .tag = .symbol, ... }`.
         bun_ast::Ref::new(self.inner_index(), source_index, bun_ast::RefTag::Symbol)
     }
 }
@@ -2487,7 +2423,7 @@ pub struct ComposesEntry {
 
 pub struct PropertyUsage {
     pub bitset: PropertyBitset,
-    pub custom_properties: Box<[&'static [u8]]>, // TODO(port): lifetime — arena slices
+    pub custom_properties: Box<[&'static [u8]]>, // TODO: lifetime — arena slices
     pub range: bun_ast::Range,
 }
 
@@ -2505,14 +2441,17 @@ impl PropertyUsage {
     #[inline]
     pub fn fill(&mut self, used: &PropertyBitset, custom_properties: &[&'static [u8]]) {
         self.bitset.set_union(used);
-        // TODO(port): lifetime — Zig stored borrowed slice; box for now.
+        // TODO: lifetime — box for now.
         self.custom_properties = custom_properties.to_vec().into_boxed_slice();
     }
 }
 
-// TODO(port): Zig: `std.bit_set.ArrayBitSet(usize, ceilPow2(EnumFields(PropertyIdTag).len))`.
-// Compute the variant count via `strum::EnumCount` instead of hardcoding 1024.
-pub type PropertyBitset = ArrayBitSet<1024, { num_masks_for(1024) }>;
+// `PropertyIdTag` is a dense `repr(u16)` enum with no
+// explicit discriminants whose last variant is `Custom`, so the variant count
+// is `Custom + 1`.
+pub const PROPERTY_BITSET_BITS: usize = (PropertyIdTag::Custom as usize + 1).next_power_of_two();
+pub type PropertyBitset =
+    ArrayBitSet<PROPERTY_BITSET_BITS, { num_masks_for(PROPERTY_BITSET_BITS) }>;
 
 pub fn fill_property_bit_set(
     bitset: &mut PropertyBitset,
@@ -2563,14 +2502,11 @@ pub fn fill_property_bit_set(
 pub struct StyleSheet<AtRule> {
     /// A list of top-level rules within the style sheet.
     pub rules: CssRuleList<AtRule>,
-    // PERF(port): was arena bulk-free (sources / source_map_urls /
-    // license_comments were ArrayList fed input.arena()) — profile if hot.
     pub sources: Vec<Box<[u8]>>,
     pub source_map_urls: Vec<Option<Box<[u8]>>>,
-    pub license_comments: Vec<&'static [u8]>, // TODO(port): lifetime — arena
-    pub options: ParserOptions<'static>,      // TODO(port): lifetime
-    // Zig: `tailwind: if (AtRule == BundlerAtRule) ?*BundlerTailwindState else u0`
-    // TODO(port): conditional field; for now Option<Box<_>> always.
+    pub license_comments: Vec<&'static [u8]>, // TODO: lifetime — arena
+    pub options: ParserOptions<'static>,      // TODO: lifetime
+    // Always `None` for non-bundler sheets.
     pub tailwind: Option<Box<BundlerTailwindState>>,
     pub layer_names: Vec<LayerName>,
 
@@ -2601,16 +2537,14 @@ impl<AtRule> StyleSheet<AtRule> {
 }
 
 // ── StyleSheet behavior (parse/minify/to_css) ────────────────────────────────
-// Method *bodies* are ported with `// PORT NOTE:` borrowck reshapes where Zig
-// aliased pointers.
 mod stylesheet_impl {
     use super::*;
 
     impl<AtRule> StyleSheet<AtRule> {
         /// Minify and transform the style sheet for the provided browser targets.
         ///
-        /// PORT NOTE: `arena` is the arena that owns this stylesheet's AST
-        /// (Zig: `arena: Allocator`). It is threaded into `MinifyContext` so
+        /// Note: `arena` is the arena that owns this stylesheet's AST.
+        /// It is threaded into `MinifyContext` so
         /// downstream `deep_clone` calls allocate alongside the existing tree.
         pub fn minify(
             &mut self,
@@ -2698,7 +2632,7 @@ mod stylesheet_impl {
             local_names: Option<&'a LocalsResultsMap>,
             symbols: &'a bun_ast::symbol::Map,
         ) -> PrintResult<ToCssResultInternal> {
-            // PORT NOTE: PrinterOptions has `&mut SourceMap` and so isn't Copy; capture
+            // Note: PrinterOptions has `&mut SourceMap` and so isn't Copy; capture
             // the lone field we re-read after moving `options` into Printer::new.
             let project_root = options.project_root;
             let mut printer = Printer::new(
@@ -2803,9 +2737,7 @@ mod stylesheet_impl {
         ) -> PrintResult<ToCssResult> {
             // TODO: this is not necessary
             // Make sure we always have capacity > 0: https://github.com/napi-rs/napi-rs/issues/1124.
-            // TODO(port): writer adapter — Zig used std.Io.Writer.Allocating; here we
-            // route through bun_io::Write over Vec<u8> until 'bump dest threads.
-            // blocked_on: bun_io::Write impl for Vec<u8> / dest ownership reshape.
+            // PERF: this always heap-allocates — profile if hot.
             let mut dest: Vec<u8> = Vec::with_capacity(1);
             let result = self.to_css_with_writer(
                 arena,
@@ -2830,9 +2762,7 @@ mod stylesheet_impl {
             import_records: Option<&mut Vec<ImportRecord>>,
             source_index: SrcIndex,
         ) -> Maybe<(StyleSheet<DefaultAtRule>, StylesheetExtra), Err<ParserError>> {
-            // PORT NOTE: Zig instantiated `StyleSheet(DefaultAtRule).parse`; Rust
-            // cannot vary `Self`'s `AtRule` param against `DefaultAtRuleParser`, so
-            // this returns the concrete `StyleSheet<DefaultAtRule>`. Callers that
+            // Returns the concrete `StyleSheet<DefaultAtRule>`. Callers that
             // need a custom at-rule call `parse_with` directly.
             let mut default_at_rule_parser = DefaultAtRuleParser;
             StyleSheet::<DefaultAtRule>::parse_with(
@@ -2846,7 +2776,7 @@ mod stylesheet_impl {
         }
 
         /// Parse a style sheet from a string.
-        // TODO(port): `ParserOptions<'static>` matches the `StyleSheet.options`
+        // TODO: `ParserOptions<'static>` matches the `StyleSheet.options`
         // field's `'static` erasure; re-threads to `<'bump>` alongside the rest of
         // the crate.
         pub fn parse_with<P: CustomAtRuleParser<AtRule = AtRule>>(
@@ -2857,11 +2787,11 @@ mod stylesheet_impl {
             import_records: Option<core::ptr::NonNull<Vec<ImportRecord>>>,
             source_index: SrcIndex,
         ) -> Maybe<(Self, StylesheetExtra), Err<ParserError>> {
-            // TODO(port): 'bump lifetime threading — every arena-backed slice the
+            // TODO: 'bump lifetime threading — every arena-backed slice the
             // parser hands back is currently detached to `'static` (matching the
             // crate-wide erasure on `DeclarationBlock<'static>`/`Token` payloads).
-            // The caller owns the arena (matching Zig's `arena: Allocator`
-            // parameter) so the storage outlives the returned `StyleSheet`.
+            // The caller owns the arena, so the storage outlives the
+            // returned `StyleSheet`.
             // TODO(refactor): re-thread the lifetime through `CssRuleList<'bump, R>`
             // and drop the `'static` bound on `arena`.
             let mut composes = ComposesMap::default();
@@ -2884,7 +2814,6 @@ mod stylesheet_impl {
                 Some(&mut parser_extra),
             );
 
-            // PERF(port): was arena bulk-free — profile if hot.
             let mut license_comments: Vec<&'static [u8]> = Vec::new();
             let mut state = parser.state();
             while let Ok(token) = parser.next_including_whitespace_and_comments() {
@@ -2892,7 +2821,7 @@ mod stylesheet_impl {
                     Token::Whitespace(_) => {}
                     Token::Comment(comment) => {
                         if comment.first() == Some(&b'!') {
-                            // TODO(port): lifetime — arena slice; see erasure note.
+                            // TODO: lifetime — arena slice; see erasure note.
                             // SAFETY: `comment` borrows `parser.src`, which outlives
                             // `license_comments` (consumed before `parser` drops).
                             license_comments.push(unsafe { src_str(comment) });
@@ -2930,9 +2859,7 @@ mod stylesheet_impl {
             let source_map_urls: Vec<Option<Box<[u8]>>> =
                 vec![parser.current_source_map_url().map(Box::<[u8]>::from)];
 
-            // Spec: `.layer_names = if (comptime P == BundlerAtRuleParser)
-            // at_rule_parser.layer_names else .{}` (css_parser.zig:3324). Rust
-            // dispatches through the `CustomAtRuleParser::take_layer_names` hook
+            // Dispatch through the `CustomAtRuleParser::take_layer_names` hook
             // (default = empty; `BundlerAtRuleParser` overrides to move its list
             // out) so the accumulated layer ordering isn't silently dropped.
             let layer_names = P::take_layer_names(at_rule_parser);
@@ -2971,24 +2898,6 @@ mod stylesheet_impl {
             // bun.debugAssert()
         }
 
-        pub fn contains_tailwind_directives(&self) -> bool {
-            // TODO(port): Zig `@compileError` if AtRule != BundlerAtRule.
-            let mut found_import = false;
-            for rule in self.rules.v.iter() {
-                match rule {
-                    CssRule::Custom(_) => return true,
-                    // TODO: layer
-                    CssRule::LayerBlock(_) => {}
-                    CssRule::Import(_) => {
-                        found_import = true;
-                    }
-                    _ => return false,
-                }
-            }
-            let _ = found_import;
-            false
-        }
-
         pub fn new_from_tailwind_imports(
             options: ParserOptions<'static>,
             imports_from_tailwind: CssRuleList<AtRule>,
@@ -3016,13 +2925,10 @@ mod stylesheet_impl {
             out: &mut CssRuleList<AtRule>,
             new_import_records: &mut Vec<ImportRecord>,
         ) {
-            // PORT NOTE: the Zig fn takes `*const @This()` but writes
-            // `rule.* = .ignored;` through it (Zig has no const-transitivity).
-            // Writing through a `*const`-derived pointer is UB in Rust, so the
-            // receiver is reshaped to `&mut self`. The sole caller (Tailwind
+            // The receiver is `&mut self`; the sole caller (Tailwind
             // bundling) owns the stylesheet exclusively at this point.
             //
-            // Zig used a comptime two-pass `inline for` (count, exec). Unroll.
+            // Two passes: count, then exec.
             let mut count: u32 = 0;
             {
                 let mut saw_imports = false;
@@ -3048,7 +2954,6 @@ mod stylesheet_impl {
                 }
             }
             out.v.reserve(count as usize);
-            // PERF(port): was ensureUnusedCapacity — profile if hot.
             let mut saw_imports = false;
             for rule in self.rules.v.iter_mut() {
                 match rule {
@@ -3077,12 +2982,9 @@ mod stylesheet_impl {
                             original_path: b"",
                             flags: Default::default(),
                         });
-                        // PORT NOTE: reshaped for borrowck — Zig did
-                        // `out.v.appendAssumeCapacity(rule.*)` (bitwise copy) then
-                        // `rule.* = .ignored`. Rust moves the rule out via
-                        // `mem::replace` (no `Clone` bound needed) and pushes that.
+                        // Move the rule out via `mem::replace` (no `Clone`
+                        // bound needed) and push that.
                         let old = core::mem::replace(rule, CssRule::Ignored);
-                        // PERF(port): was appendAssumeCapacity
                         out.v.push(old);
                     }
                     CssRule::Unknown(u) => {
@@ -3099,6 +3001,25 @@ mod stylesheet_impl {
         }
     }
 
+    impl StyleSheet<BundlerAtRule> {
+        pub fn contains_tailwind_directives(&self) -> bool {
+            let mut found_import = false;
+            for rule in self.rules.v.iter() {
+                match rule {
+                    CssRule::Custom(_) => return true,
+                    // TODO: layer
+                    CssRule::LayerBlock(_) => {}
+                    CssRule::Import(_) => {
+                        found_import = true;
+                    }
+                    _ => return false,
+                }
+            }
+            let _ = found_import;
+            false
+        }
+    }
+
     impl StyleAttribute {
         pub fn parse(
             arena: &'static Bump,
@@ -3107,7 +3028,7 @@ mod stylesheet_impl {
             import_records: &mut Vec<ImportRecord>,
             source_index: SrcIndex,
         ) -> Maybe<StyleAttribute, Err<ParserError>> {
-            // TODO(port): 'bump lifetime threading — `DeclarationBlock<'static>` in
+            // TODO: 'bump lifetime threading — `DeclarationBlock<'static>` in
             // `StyleAttribute` vs `Parser<'a>` here; `arena: &'static Bump`
             // matches the crate-wide erasure (see `parse_with`).
             let mut parser_extra = ParserExtra {
@@ -3149,8 +3070,6 @@ mod stylesheet_impl {
             // );
 
             let symbols = bun_ast::symbol::Map::init_list(Default::default());
-            // TODO(port): writer adapter — Zig used std.Io.Writer.Allocating; route
-            // through bun_io::Write over Vec<u8> until 'bump dest threads.
             let mut dest: Vec<u8> = Vec::new();
             let mut printer = Printer::new(
                 arena,
@@ -3184,18 +3103,17 @@ mod stylesheet_impl {
             import_records: &mut Vec<ImportRecord>,
             source_index: SrcIndex,
         ) -> Maybe<(Self, StylesheetExtra), Err<ParserError>> {
-            // PORT NOTE: Zig aliased `import_records` into both `BundlerAtRuleParser`
-            // *and* the inner `Parser` (css_parser.zig:3245), and aliased `&options`
-            // into the at-rule parser while also passing `options` by value (struct
-            // copy) to `parseWith`. Rust forbids both overlaps directly:
+            // `import_records` is shared by both `BundlerAtRuleParser` and the
+            // inner `Parser`, and `options` is both borrowed by the at-rule
+            // parser and passed by value:
             // - `import_records`: derive a single raw `NonNull` from the unique
             //   borrow; both the at-rule parser and `Parser::new` store copies of
-            //   that raw pointer (matching Zig's `?*Vec`). Neither holds a
+            //   that raw pointer. Neither holds a
             //   long-lived `&mut`, so interleaved writes from `on_import_rule` and
             //   `add_import_record`/`state`/`reset` each create a fresh short-lived
             //   `&mut` from the shared SharedRW provenance — sound under SB.
-            // - `options`: bitwise-duplicate via `ptr::read` (mirroring Zig's
-            //   by-value struct copy) and wrap the original in `ManuallyDrop` so
+            // - `options`: bitwise-duplicate via `ptr::read` and wrap the
+            //   original in `ManuallyDrop` so
             //   only the moved copy drops — `ParserOptions` transitively owns a
             //   `SmallList` (via `css_modules::Config::pattern`) which has a real
             //   `Drop`, so both copies must not run their destructors.
@@ -3226,7 +3144,7 @@ mod stylesheet_impl {
 // ───────────────────────────── StyleAttribute ─────────────────────────────
 
 pub struct StyleAttribute {
-    // PORT NOTE: `DeclarationBlock<'bump>` borrows the parser arena; lifetime
+    // Note: `DeclarationBlock<'bump>` borrows the parser arena; lifetime
     // erased to `'static` until 'bump threads through the rule tree (matches
     // `StyleRule.declarations` in rules/style.rs).
     pub declarations: DeclarationBlock<'static>,
@@ -3344,7 +3262,7 @@ where
 
 pub struct ParserOptions<'a> {
     /// Filename to use in error messages.
-    pub filename: &'static [u8], // TODO(port): lifetime
+    pub filename: &'static [u8], // TODO: lifetime
     /// Whether to enable [CSS modules](https://github.com/css-modules/css-modules).
     pub css_modules: Option<css_modules::Config>,
     /// The source index to assign to all parsed rules. Impacts the source map
@@ -3354,7 +3272,7 @@ pub struct ParserOptions<'a> {
     pub error_recovery: bool,
     /// A list that will be appended to when a warning occurs.
     ///
-    /// Stored as a raw `NonNull<Log>` (mirrors Zig's `*Log`) so `warn(&self)`
+    /// Stored as a raw `NonNull<Log>` so `warn(&self)`
     /// can soundly write through it. Deriving `&mut Log` from a `&self`-reachable
     /// `&'a mut Log` (the previous representation) is UB under Stacked Borrows
     /// — see PORTING.md §Forbidden patterns. The caller that constructs
@@ -3371,7 +3289,7 @@ impl<'a> ParserOptions<'a> {
         if let Some(lg) = self.logger {
             // SAFETY: `logger` was constructed from a unique `&'a mut Log` (see
             // `default`); the pointee outlives `'a` and no other borrow of the
-            // Log exists for the duration of parsing. Zig mutated through `*Log`.
+            // Log exists for the duration of parsing.
             let lg: &mut Log = unsafe { &mut *lg.as_ptr() };
             lg.add_warning_fmt_line_col(
                 self.filename,
@@ -3471,7 +3389,6 @@ bitflags::bitflags! {
         const CSS_MODULES = 0b1;
     }
 }
-// PORT NOTE: Zig packed struct had `css_modules: bool`. Expose accessor:
 impl ParserOpts {
     #[inline]
     pub fn css_modules(self) -> bool {
@@ -3484,8 +3401,7 @@ pub struct Parser<'a> {
     pub at_start_of: Option<BlockType>,
     pub stop_before: Delimiters,
     pub flags: ParserOpts,
-    /// Stored as a raw `NonNull` (mirrors Zig's `?*Vec(ImportRecord)`,
-    /// css_parser.zig:3808) because `BundlerAtRuleParser` holds an aliasing
+    /// Stored as a raw `NonNull` because `BundlerAtRuleParser` holds an aliasing
     /// raw pointer to the same list. Keeping a long-lived `&'a mut` here would
     /// be invalidated under Stacked Borrows the moment `on_import_rule`
     /// derives its own `&mut` from the sibling raw pointer. Each access site
@@ -3563,8 +3479,7 @@ impl<'a> Parser<'a> {
             let import_records = unsafe { &mut *ptr.as_ptr() };
             let idx = u32::try_from(import_records.len()).unwrap();
             // SAFETY: `url` borrows the parser source / arena which outlives
-            // every `ImportRecord` produced by this parse. `bun.fs.Path` in
-            // the Zig original stores the same borrowed slice; the lifetime
+            // every `ImportRecord` produced by this parse; the lifetime
             // is erased to 'static (see PORTING.md §Lifetimes).
             let url_static: &'static [u8] = unsafe { src_str(url) };
             import_records.push(ImportRecord {
@@ -3693,7 +3608,6 @@ impl<'a> Parser<'a> {
         // capacity 1, so in the somewhat common case of only one item we don't
         // way overallocate.  Note that we always push at least one item if
         // parsing succeeds.
-        // PERF(port): was stack-fallback
         let mut values: Vec<T> = Vec::with_capacity(1);
 
         loop {
@@ -3730,9 +3644,6 @@ impl<'a> Parser<'a> {
         result
     }
 
-    // Zig `tryParseImpl` is the same as `tryParse` with manual args tuple;
-    // collapsed into `try_parse`.
-
     #[inline]
     pub fn parse_nested_block<T>(
         &mut self,
@@ -4309,8 +4220,7 @@ struct UnclosedBlockAtEof {
 
 impl<'a> ParserInput<'a> {
     /// Create a `ParserInput` borrowing `code` and an arena for unescaped
-    /// strings. Matches Zig `ParserInput.new` (css_parser.zig:4549) which
-    /// takes an `Allocator` parameter — the caller owns the arena and it must
+    /// strings. The caller owns the arena and it must
     /// outlive every `Token` produced from this input.
     ///
     /// PORTING.md §Forbidden: do not fabricate `&'a Bump` from a boxed field
@@ -4564,14 +4474,10 @@ pub struct Tokenizer<'a> {
 const FORM_FEED_BYTE: u8 = 0x0C;
 const REPLACEMENT_CHAR: u32 = 0xFFFD;
 const REPLACEMENT_CHAR_UNICODE: [u8; 3] = [0xEF, 0xBF, 0xBD];
-/// UTF-8 encoding of U+0FFD — used by `serializer` where Zig called
-/// `bun.strings.encodeUTF8Comptime(0xFFD)` (css_parser.zig:6747, :6937). The
-/// Zig literal is `0xFFD` (sic — likely a typo for `0xFFFD`), but the spec is
-/// ground truth: encode 0x0FFD → [0xE0, 0xBF, 0xBD] to byte-match.
-/// TODO(port): confirm whether the spec itself needs fixing to 0xFFFD.
-// TODO(port): verify upstream — Zig wrote 0xFFD, comment says "replacement
-// character" which is U+FFFD. Byte-matching the spec (0x0FFD) for now.
-const REPLACEMENT_CHAR_UTF8: &[u8] = &[0xE0, 0xBF, 0xBD];
+/// UTF-8 encoding of U+FFFD REPLACEMENT CHARACTER, written by `serializer`
+/// when escaping a NUL byte (css-syntax requires U+0000 → U+FFFD; upstream
+/// rust-cssparser writes `"\u{FFFD}"`).
+const REPLACEMENT_CHAR_UTF8: &[u8] = &REPLACEMENT_CHAR_UNICODE;
 const MAX_ONE_B: u32 = 0x80;
 const MAX_TWO_B: u32 = 0x800;
 const MAX_THREE_B: u32 = 0x10000;
@@ -4580,12 +4486,11 @@ const MAX_THREE_B: u32 = 0x10000;
 ///
 /// PORTING.md §Forbidden flags this erasure. The proper fix is to thread a
 /// real `'a` lifetime through `Token<'a>` / `Dimension<'a>` / `CachedToken<'a>`
-/// so `slice_from`/`to_slice` return `&'a [u8]` (matching Zig's plain
-/// `[]const u8` borrows in css_parser.zig:5879/6461). That change is blocked
+/// so `slice_from`/`to_slice` return `&'a [u8]`. That change is blocked
 /// on `crate::Token` (defined in `lib.rs`, not this file) gaining `<'a>` —
 /// once `lib.rs` is updated, delete this fn and every call site compiles with
 /// the honest lifetime.
-// TODO(port): delete once `Token<'a>` lands in lib.rs; see verifier bug
+// TODO: delete once `Token<'a>` lands in lib.rs; see verifier bug
 // "src_str / Tokenizer::slice_from / CopyOnWriteStr::to_slice".
 // SAFETY: every call site below feeds either (a) a sub-slice of `self.src`
 // (`&'a [u8]`) or (b) an arena-allocated `CopyOnWriteStr::to_slice()` whose
@@ -4669,7 +4574,7 @@ impl<'a> Tokenizer<'a> {
 
     pub fn see_function(&mut self, name: &[u8]) {
         if self.var_or_env_functions == SeenStatus::LookingForThem {
-            // PORT NOTE: Zig had `and` here (always false); preserved.
+            // Note: this `&&` is always false; kept as-is intentionally.
             if strings::eql_case_insensitive_ascii_check_length(name, b"var")
                 && strings::eql_case_insensitive_ascii_check_length(name, b"env")
             {
@@ -4988,7 +4893,7 @@ impl<'a> Tokenizer<'a> {
         }
 
         let int_value: Option<i32> = if is_integer {
-            // Zig: bun.intFromFloat — saturating cast.
+            // Saturating cast.
             Some(value as i32)
         } else {
             None
@@ -5654,15 +5559,13 @@ fn byte_to_decimal_digit(b: u8) -> Option<u32> {
 }
 
 pub fn split_source_map(contents: &[u8]) -> Option<&[u8]> {
-    // FIXME: Use bun CodepointIterator
-    // TODO(port): Zig used std.unicode.Utf8Iterator. Approximate with byte
-    // scan since the delimiters are all ASCII.
+    // A byte scan suffices: the delimiters are all ASCII and ASCII bytes never
+    // occur inside a multi-byte UTF-8 sequence. The returned slice ends *after*
+    // the matched byte — hence `i + 1`.
     for (i, &c) in contents.iter().enumerate() {
         match c {
             b' ' | b'\t' | FORM_FEED_BYTE | b'\r' | b'\n' => {
                 return Some(&contents[0..i + 1]);
-                // PORT NOTE: Zig returned `[0..iter.i]` where `i` is *after*
-                // the codepoint — preserved.
             }
             _ => {}
         }
@@ -5747,15 +5650,14 @@ impl TokenKind {
 // Data layout hoisted at crate root (lib.rs) so error.rs can name `Token`
 // without the parser hub. Behavior impls (kind/is_parse_error/to_css_generic)
 // live here. TODO: make strings be allocated in string pool.
-// TODO(port): lifetime — every &[u8] payload borrows the arena/source. Uses
+// TODO: lifetime — every &[u8] payload borrows the arena/source. Uses
 // `&'static [u8]` placeholder; thread `<'a>` once payload lifetimes settle.
 pub use crate::Token;
 
 impl Token {
     // blocked_on: generics::CssEql/CssHash blanket impls for Token payload set
     pub fn eql(lhs: &Token, rhs: &Token) -> bool {
-        // TODO(port): Zig used implementEql (comptime field-walk).
-        // Derive PartialEq once payload lifetimes settle.
+        // TODO: derive PartialEq once payload lifetimes settle.
         generic::implement_eql(lhs, rhs)
     }
 
@@ -6005,15 +5907,11 @@ impl Token {
 }
 
 // `impl Display for Token` lives at crate root (lib.rs) — minimal rendering
-// for error messages. The full Zig `Token.format` (CSS-serialization-correct)
-// is `Token::to_css_generic` above; switch lib.rs's impl to delegate once
-// dependents stop relying on the simple form.
-// TODO(port): Zig `format` had subtle differences from `to_css_generic`
-// (quoted_string→serialize_string, idhash→serialize_identifier). Specialize
-// if it matters for diagnostics.
-
-/// Byte-writer trait for `serializer` and `to_css_generic` (replaces Zig
-/// `anytype` writer). Aliased to the canonical `bun_io::Write`; the associated
+// for error messages only. The CSS-serialization-correct form is
+// `Token::to_css_generic` above.
+
+/// Byte-writer trait for `serializer` and `to_css_generic`.
+/// Aliased to the canonical `bun_io::Write`; the associated
 /// `type Error` is dropped — every `Result<(), W::Error>` becomes
 /// `bun_io::Result<()>`. `Vec<u8>` / `ArenaVec<'_, u8>` / `Printer` all
 /// implement it upstream.
@@ -6055,7 +5953,6 @@ impl<'a> CopyOnWriteStr<'a> {
                 let mut list = bun_alloc::ArenaVec::with_capacity_in(b.len() + slice.len(), arena);
                 list.extend_from_slice(b);
                 list.extend_from_slice(slice);
-                // PERF(port): was appendSliceAssumeCapacity
                 *self = CopyOnWriteStr::Owned(list);
             }
             CopyOnWriteStr::Owned(o) => {
@@ -6388,7 +6285,7 @@ pub mod serializer {
         dest: &mut Printer,
     ) -> Result<(), PrintErr> {
         let int_value: Option<i32> = if fract(value) == 0.0 {
-            Some(value as i32) // saturating like Zig bun.intFromFloat
+            Some(value as i32) // saturating cast
         } else {
             None
         };
@@ -6616,9 +6513,6 @@ pub mod to_css {
             local_names,
             symbols,
         );
-        // PORT NOTE: Zig special-cased `T == CSSString` → `CSSStringFns.toCss`;
-        // in Rust the `ToCss` impl on `CSSString` routes there directly, so the
-        // generic dispatch suffices.
         this.to_css(&mut printer)?;
         drop(printer);
         Ok(s)
@@ -6654,7 +6548,7 @@ pub fn parse_important(input: &mut Parser) -> CssResult<()> {
 }
 
 pub mod signfns {
-    /// Spec-faithful port of `css_parser.zig:7086` — note the ±0.0 sign FLIP is
+    /// Note: the ±0.0 sign FLIP is
     /// intentional (do NOT "fix" it). Distinct from `f32::signum` and from
     /// `calc::std_math_sign` / `CSSNumberFns::sign`.
     #[inline]
@@ -6884,5 +6778,3 @@ pub fn f32_length_with_5_digits(n_input: f32) -> usize {
 
     count
 }
-
-// ported from: src/css/css_parser.zig
diff --git a/src/css/declaration.rs b/src/css/declaration.rs
index a537474326a..41b7e5ccce5 100644
--- a/src/css/declaration.rs
+++ b/src/css/declaration.rs
@@ -4,10 +4,12 @@ use bun_alloc::ArenaVecExt as _;
 pub use css::Error;
 use css::{CssResult as Result, PrintErr, Printer};
 
-// PORT NOTE: every leaf property module is currently a `handler_stub!` ZST in
-// properties/mod.rs (no-op `handle_property`/`finalize`). The real handler
-// bodies un-gate per-module as the values/ calc lattice lands; this file
-// composes over whichever surface is live.
+// The `*Handler` types imported below are the real per-shorthand-group
+// implementations from their leaf modules (BackgroundHandler, BoxShadowHandler,
+// BorderRadiusHandler, …). A few leaf modules still keep individual method
+// bodies internally gated until their deps land — see the per-module status
+// notes at the top of properties/mod.rs; this file composes over whichever
+// surface is live.
 use crate::css_properties::align::AlignHandler;
 use crate::css_properties::background::BackgroundHandler;
 use crate::css_properties::border::BorderHandler;
@@ -45,13 +47,12 @@ pub struct DeclarationBlock<'bump> {
 
 pub struct DebugFmt<'a, 'bump>(&'a DeclarationBlock<'bump>);
 
-// blocked_on: Printer::new signature (Zig passes arena + Managed(u8) +
-// writer + options + null + null + &symbols; the Rust ctor shape is unsettled).
+// blocked_on: Printer::new signature (the ctor shape is unsettled).
 
 impl<'a, 'bump> core::fmt::Display for DebugFmt<'a, 'bump> {
     fn fmt(&self, writer: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // PORT NOTE: debug formatter — uses a throwaway local arena for the
-        // printer's scratch buffers (Zig threaded the parser arena).
+        // Debug formatter: uses a throwaway local arena for the printer's
+        // scratch buffers.
         let bump = Bump::new();
         let mut arraylist: Vec<u8> = Vec::new();
         let symbols = bun_ast::symbol::Map::init_list(Default::default());
@@ -103,14 +104,12 @@ impl<'bump> DeclarationBlock<'bump> {
         important_handler: &mut DeclarationHandler<'bump>,
         context: &mut css::PropertyHandlerContext,
     ) {
-        // PORT NOTE: Zig threaded `context.arena` through every append; the
-        // Rust `PropertyHandlerContext` dropped that field, so we recover the
+        // `PropertyHandlerContext` carries no arena field, so we recover the
         // arena from the handler's own bump-backed accumulator instead.
         let bump: &'bump Bump = handler.decls.bump();
 
-        // PORT NOTE: Zig used a local generic `handle` fn with comptime field
-        // name + bool. Unrolled to two calls over a shared inner fn; reshaped
-        // for borrowck (iterate via &mut, move prop out and overwrite slot).
+        // Two calls over a shared inner fn; iterate via &mut, move prop out
+        // and overwrite the slot.
         #[inline]
         fn handle<'bump>(
             decls: &mut DeclarationList<'bump>,
@@ -124,8 +123,7 @@ impl<'bump> DeclarationBlock<'bump> {
                 let handled = hndlr.handle_property(prop, ctx);
 
                 if !handled {
-                    // Zig: `hndlr.decls.append(prop.*); prop.* = .{ .all = .@"revert-layer" }`
-                    // — move the value out and overwrite the slot with a
+                    // Move the value out and overwrite the slot with a
                     // non-allocating placeholder so the source list's drop is a
                     // no-op.
                     hndlr
@@ -145,9 +143,8 @@ impl<'bump> DeclarationBlock<'bump> {
 
         handler.finalize(context);
         important_handler.finalize(context);
-        // PORT NOTE: Zig swapped old lists out, deferred their deinit, then
-        // assigned the handler accumulators. In Rust the old bumpalo Vecs drop
-        // implicitly on overwrite (arena reclaims on reset).
+        // The old bumpalo Vecs drop implicitly on overwrite (arena reclaims
+        // on reset).
         self.important_declarations =
             core::mem::replace(&mut important_handler.decls, DeclarationList::new_in(bump));
         self.declarations = core::mem::replace(&mut handler.decls, DeclarationList::new_in(bump));
@@ -155,7 +152,6 @@ impl<'bump> DeclarationBlock<'bump> {
 }
 
 /// Non-allocating placeholder used by `minify()` to overwrite moved-out slots.
-/// Zig: `css.Property{ .all = .@"revert-layer" }`.
 #[inline(always)]
 fn placeholder_property() -> css::Property {
     css::Property::All(crate::css_properties::CSSWideKeyword::RevertLayer)
@@ -168,7 +164,6 @@ impl<'bump> DeclarationBlock<'bump> {
         let length = self.len();
         let mut i: usize = 0;
 
-        // PORT NOTE: Zig used `inline for` over field names with @field; unrolled to 2 arms.
         for decl in self.declarations.iter() {
             decl.to_css(dest, false)?;
             if i != length - 1 {
@@ -198,7 +193,6 @@ impl<'bump> DeclarationBlock<'bump> {
         let mut i: usize = 0;
         let length = self.len();
 
-        // PORT NOTE: Zig used `inline for` over field names with @field; unrolled to 2 arms.
         for decl in self.declarations.iter() {
             dest.newline()?;
             decl.to_css(dest, false)?;
@@ -224,7 +218,7 @@ impl<'bump> DeclarationBlock<'bump> {
 
 // ─── parse ────────────────────────────────────────────────────────────────
 //
-// PORT NOTE: every consumer (`StyleRule`, `Keyframe`, `PageRule`,
+// Every consumer (`StyleRule`, `Keyframe`, `PageRule`,
 // `StyleAttribute`, `NestedRuleParser`) stores `DeclarationBlock<'static>` —
 // the crate-wide `'bump`-erasure placeholder until `'bump` threads through
 // `CssRule`. `parse()` therefore lives on the `'static` instantiation and
@@ -256,10 +250,8 @@ impl DeclarationBlock<'static> {
                     options.warn(&e);
                     continue;
                 }
-                // errdefer doesn't fire on `return .{ .err = ... }` — Result(T) is a tagged
-                // union, not an error union. Free any declarations accumulated so far.
-                // PORT NOTE: in Rust, `declarations`/`important_declarations` are bumpalo
-                // Vec<Property> and drop on early return; deepDeinit is implicit via Drop.
+                // `declarations`/`important_declarations` are bumpalo Vec<Property> and
+                // drop on this early return; freeing them is implicit via Drop.
                 return Err(e);
             }
         }
@@ -274,8 +266,7 @@ impl DeclarationBlock<'static> {
 // ─── hash / eql / deep_clone (gated) ──────────────────────────────────────
 // blocked_on: properties_generated — `Property` lacks `DeepClone`/`CssEql`
 // derives and `PropertyId` lacks a `hash(&mut Wyhash)` method. The bodies
-// below are the real manual unrolls of Zig's comptime-reflection helpers
-// (`implementEql`/`implementDeepClone`); they un-gate the moment the
+// below un-gate the moment the
 // per-variant trait impls land in `properties_generated.rs`.
 
 impl<'bump> DeclarationBlock<'bump> {
@@ -307,9 +298,6 @@ impl<'bump> DeclarationBlock<'bump> {
     }
 
     pub fn deep_clone(&self, bump: &'bump Bump) -> Self {
-        // PORT NOTE: `css.implementDeepClone` is comptime field reflection;
-        // for a struct it deep-clones each field. `Property::deep_clone` is
-        // the inherent per-variant impl in properties_generated.rs.
         Self {
             important_declarations: bun_alloc::vec_from_iter_in(
                 self.important_declarations
@@ -333,10 +321,6 @@ pub(crate) struct PropertyDeclarationParser<'a, 'bump> {
     pub options: &'a css::ParserOptions<'a>,
 }
 
-// PORT NOTE: Zig's nested AtRuleParser/QualifiedRuleParser/DeclarationParser/
-// RuleBodyItemParser are structural duck-typing namespaces consumed by
-// RuleBodyParser(T) at comptime. In Rust these are trait impls.
-
 impl<'a, 'bump> css::AtRuleParser for PropertyDeclarationParser<'a, 'bump> {
     type Prelude = ();
     type AtRule = ();
@@ -432,10 +416,9 @@ pub fn parse_declaration<'bump>(
     )
 }
 
-// PORT NOTE: Zig `composes_ctx: anytype` — branches on
-// `comptime @TypeOf(composes_ctx) != void`. The Rust shape is a `ComposesCtx`
+// Composes handling dispatches through the `ComposesCtx`
 // trait (defined in `css_parser.rs`); `NoComposesCtx` returns
-// `DisallowEntirely` so the `void` fast-path collapses into the match's
+// `DisallowEntirely` so the no-tracking fast-path collapses into the match's
 // no-op arm.
 pub fn parse_declaration_impl<'bump, C>(
     name: &[u8],
@@ -450,8 +433,7 @@ where
 {
     let property_id = css::PropertyId::from_string(name);
     let mut delimiters = css::Delimiters::BANG;
-    // Zig: `if (property_id != .custom or property_id.custom != .custom)` —
-    // i.e. NOT (tag == .custom AND payload tag == .custom).
+    // NOT (tag == custom AND payload tag == custom).
     if !matches!(
         property_id,
         css::PropertyId::Custom(CustomPropertyName::Custom(_))
@@ -459,9 +441,6 @@ where
         delimiters |= css::Delimiters::CURLY_BRACKET;
     }
     let source_location = input.current_source_location();
-    // PORT NOTE: Zig threaded `&closure` + fn through `parseUntilBefore`; the
-    // Rust method takes a single `FnOnce(&mut Parser)`, so capture by move
-    // (`PropertyId` is `Copy`, `options` is a borrow).
     let mut property = input.parse_until_before(delimiters, |input2: &mut css::Parser| {
         css::Property::parse(property_id, input2, options)
     })?;
@@ -481,8 +460,6 @@ where
                     composes_ctx.record_composes(composes);
                 }
                 css::ComposesState::DisallowNested(info) => {
-                    // PORT NOTE: Zig passed an empty notes slice; `warn_fmt`
-                    // is the no-notes path.
                     options.warn_fmt(
                         format_args!("\"composes\" is not allowed inside nested selectors"),
                         info.line,
@@ -517,9 +494,9 @@ where
 
 /// Per-shorthand-group handler state used by `DeclarationBlock::minify`.
 ///
-/// PORT NOTE: each `*Handler` is a `handler_stub!` ZST until its leaf module
-/// un-gates; `Direction` is the data-only `properties::text` enum. The struct
-/// shape is the real Zig layout — only the handler *bodies* are deferred.
+/// Each `*Handler` is the real implementation from its leaf module (see the
+/// per-module status notes in properties/mod.rs for any internally-gated
+/// bodies); `Direction` is the data-only `properties::text` enum.
 pub struct DeclarationHandler<'bump> {
     pub background: BackgroundHandler,
     pub border: BorderHandler,
@@ -641,5 +618,3 @@ impl<'bump> DeclarationHandler<'bump> {
         }
     }
 }
-
-// ported from: src/css/declaration.zig
diff --git a/src/css/dependencies.rs b/src/css/dependencies.rs
index 5ebca15c04a..dd65a35c4fd 100644
--- a/src/css/dependencies.rs
+++ b/src/css/dependencies.rs
@@ -1,7 +1,6 @@
 //! CSS dependency tracking — `@import` and `url()` references collected during printing.
 
 use crate::SourceLocation;
-// const Location = css.Location; — shadowed by the local `Location` below in Zig too.
 
 /// Options for `analyze_dependencies` in `PrinterOptions`.
 pub struct DependencyOptions {
@@ -33,25 +32,21 @@ impl Location {
             column: loc.column,
         }
     }
-
-    // PORT NOTE: Zig `hash` / `eql` methods called `css.implementHash` / `css.implementEql`
-    // (comptime struct-field reflection). Replaced by `#[derive(Hash, PartialEq, Eq)]` above
-    // per PORTING.md §Comptime reflection.
 }
 
 /// An `@import` dependency.
 pub struct ImportDependency {
     /// The url to import.
-    // TODO(port): lifetime — arena-borrowed from `rule.url` (CSS arena); consider `&'bump [u8]`.
+    // Lifetime: arena-borrowed from `rule.url` (CSS arena); valid until the arena is reset.
     pub url: *const [u8],
     /// The placeholder that the URL was replaced with.
-    // TODO(port): lifetime — arena-allocated by `css_modules::hash`.
+    // Lifetime: arena-allocated by `css_modules::hash`.
     pub placeholder: *const [u8],
     /// An optional `supports()` condition.
-    // TODO(port): lifetime — arena-allocated by `to_css::string`.
+    // Lifetime: arena-allocated by `to_css::string`.
     pub supports: Option<*const [u8]>,
     /// A media query.
-    // TODO(port): lifetime — arena-allocated by `to_css::string`.
+    // Lifetime: arena-allocated by `to_css::string`.
     pub media: Option<*const [u8]>,
     /// The location of the dependency in the source file.
     pub loc: SourceRange,
@@ -109,7 +104,6 @@ impl ImportDependency {
 
         let placeholder = crate::css_modules::hash(
             bump,
-            // PORT NOTE: Zig "{s}_{s}", .{ filename, rule.url } → fmt::Arguments
             format_args!(
                 "{}_{}",
                 bstr::BStr::new(filename),
@@ -119,7 +113,7 @@ impl ImportDependency {
         );
 
         ImportDependency {
-            // TODO(zack): should we clone this? lightningcss does that
+            // lightningcss clones this; we borrow from the arena instead.
             url: std::ptr::from_ref::<[u8]>(rule.url),
             placeholder: std::ptr::from_ref::<[u8]>(placeholder),
             supports,
@@ -130,9 +124,12 @@ impl ImportDependency {
                     line: rule.loc.line + 1,
                     column: rule.loc.column,
                 },
+                // Assumes the `@import "url"` form: 8 = len of `@import `, +2 for the
+                // quotes. The `@import url(...)` form yields a slightly-off range —
+                // a limitation inherited from lightningcss.
                 8,
                 rule.url.len() + 2,
-            ), // TODO: what about @import url(...)?
+            ),
         }
     }
 }
@@ -140,10 +137,10 @@ impl ImportDependency {
 /// A `url()` dependency.
 pub struct UrlDependency {
     /// The url of the dependency.
-    // TODO(port): lifetime — arena-borrowed from `import_records[..].path.pretty`.
+    // Lifetime: arena-borrowed from `import_records[..].path.pretty`.
     pub url: *const [u8],
     /// The placeholder that the URL was replaced with.
-    // TODO(port): lifetime — arena-allocated by `css_modules::hash`.
+    // Lifetime: arena-allocated by `css_modules::hash`.
     pub placeholder: *const [u8],
     /// The location of the dependency in the source file.
     pub loc: SourceRange,
@@ -173,7 +170,7 @@ impl UrlDependency {
 /// Represents the range of source code where a dependency was found.
 pub struct SourceRange {
     /// The filename in which the dependency was found.
-    // TODO(port): lifetime — borrowed from caller (printer's filename); arena/static.
+    // Lifetime: borrowed from the caller (printer's filename); arena- or statically-backed.
     pub file_path: *const [u8],
     /// The starting line and column position of the dependency.
     pub start: Location,
@@ -196,5 +193,3 @@ impl SourceRange {
         }
     }
 }
-
-// ported from: src/css/dependencies.zig
diff --git a/src/css/error.rs b/src/css/error.rs
index 206ca1e44dc..37a850e2ff4 100644
--- a/src/css/error.rs
+++ b/src/css/error.rs
@@ -5,7 +5,6 @@ use crate::{Location, SourceLocation, Token};
 
 // Arena-owned byte slice. CSS is an AST crate (see PORTING.md §Allocators); these
 // slices point into the parser arena / source text and are never individually freed.
-// TODO(port): arena slice lifetime — thread `<'bump>` or switch to StoreRef.
 use crate::Str;
 
 #[inline(always)]
@@ -34,13 +33,11 @@ pub struct Err<T> {
 
 impl<T: fmt::Display> fmt::Display for Err<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Zig: `if (@hasDecl(T, "format"))` → trait bound `T: Display` IS that check.
         self.kind.fmt(f)
     }
 }
 
-// Zig: `pub const toErrorInstance = @import("../css_jsc/error_jsc.zig").toErrorInstance;`
-// Deleted per PORTING.md — `to_error_instance` lives as an extension-trait method in `bun_css_jsc`.
+// `to_error_instance` lives as an extension-trait method in `bun_css_jsc`.
 
 impl Err<ParserError> {
     pub fn from_parse_error(err: ParseError<ParserError>, filename: &[u8]) -> Err<ParserError> {
@@ -194,7 +191,6 @@ impl ErrorLocation {
         &self,
         source: &bun_ast::Source,
     ) -> Result<bun_ast::Location, bun_core::Error> {
-        // TODO(port): narrow error set (Zig narrowed to alloc-only).
         // SAFETY: `'bump`-erasure — `bun_ast::Location.line_text` is `Option<&'static [u8]>`
         // (`Str` placeholder per src/logger/lib.rs); the slice borrows
         // `source.contents` which outlives the diagnostic. Re-thread once
@@ -548,5 +544,3 @@ impl fmt::Display for MinifyErrorKind {
         }
     }
 }
-
-// ported from: src/css/error.zig
diff --git a/src/css/generics.rs b/src/css/generics.rs
index 74f7a4c2760..21aafcde835 100644
--- a/src/css/generics.rs
+++ b/src/css/generics.rs
@@ -1,22 +1,20 @@
 //! Generic trait-based dispatch for CSS value operations.
 //!
-//! The Zig original (`generics.zig`) uses `@typeInfo`/`@hasDecl`/`@field` comptime
-//! reflection to derive `eql`, `hash`, `deepClone`, `toCss`, `parse`, etc. across
-//! every CSS value type. Per PORTING.md §Comptime reflection, that has no Rust
-//! equivalent — the port defines a trait per protocol, provides blanket impls for
-//! the structural cases (Option/Box/slice/Vec/Vec/SmallList/primitives), and
+//! `eql`, `hash`, `deepClone`, `toCss`, `parse`, etc. are dispatched across
+//! every CSS value type via a trait per protocol, with blanket impls for
+//! the structural cases (Option/Box/slice/Vec/Vec/SmallList/primitives);
 //! per-struct/-enum impls come from the `bun_css_derive` proc-macros
 //! (`#[derive(ToCss, DeepClone, CssEql, CssHash)]` etc.).
 //!
 //! Free functions with the original names are kept as thin trait-method wrappers
-//! so call sites in sibling files port 1:1.
+//! for call sites in sibling files.
 
 use core::cmp::Ordering;
 
 use bun_alloc::Arena; // bumpalo::Bump re-export
 use bun_collections::VecExt;
-// Zig `std.hash.Wyhash` (iterative) → `bun_wyhash::Wyhash` (the final4 variant
-// matching upstream `std.hash.Wyhash`; NOT `Wyhash11`, which is a legacy v0.11
+// `bun_wyhash::Wyhash` is the final4 variant
+// (NOT `Wyhash11`, which is a legacy
 // variant kept only for on-disk lockfile compat — different digest).
 // Re-exported `pub` so `#[derive(CssHash)]` (in `bun_css_derive`) can name the
 // hasher type as `::bun_css::generics::Wyhash` without depending on `bun_wyhash`
@@ -37,25 +35,24 @@ use crate::values::rect::Rect;
 use crate::values::size::Size2D;
 use crate::{PrintErr, VendorPrefix};
 
-// `ArrayList(T)` in the Zig is `std.ArrayListUnmanaged(T)` fed the parser arena.
-// In this AST crate that maps to `bun_alloc::ArenaVec<'bump, T>`.
+// In this AST crate, lists map to `bun_alloc::ArenaVec<'bump, T>` fed the
+// parser arena.
 pub type ArrayList<'bump, T> = bun_alloc::ArenaVec<'bump, T>;
 
 // ───────────────────────────────────────────────────────────────────────────────
 // DeepClone
 // ───────────────────────────────────────────────────────────────────────────────
 
-/// Arena-aware deep clone. Equivalent of Zig's `deepClone(T, *const T, Allocator) T`.
+/// Arena-aware deep clone.
 ///
-/// Per-struct/-enum impls come from `#[derive(DeepClone)]`;
-/// the Zig `implementDeepClone` body is the spec for that derive (field-wise /
+/// Per-struct/-enum impls come from `#[derive(DeepClone)]` (field-wise /
 /// variant-wise recursion).
 pub trait DeepClone<'bump>: Sized {
     fn deep_clone(&self, bump: &'bump Arena) -> Self;
 }
 
-/// `#[derive(DeepClone)]` — field-wise / variant-wise port of Zig's
-/// `css.implementDeepClone`. See `src/css_derive/lib.rs` for the expansion
+/// `#[derive(DeepClone)]` — field-wise / variant-wise deep clone.
+/// See `src/css_derive/lib.rs` for the expansion
 /// rules. Re-exported here so `use crate::generics::DeepClone;` brings both
 /// the trait and the derive into scope (same-name trait+derive is the std
 /// idiom, cf. `Clone`).
@@ -66,15 +63,14 @@ pub fn implement_deep_clone<'bump, T: DeepClone<'bump>>(this: &T, bump: &'bump A
     this.deep_clone(bump)
 }
 
-// Alias: in Zig `deepClone` (structural type-dispatch entry) and
-// `implementDeepClone` (field-reflection body) are distinct, but in Rust both
-// collapse to `T::deep_clone` because the structural dispatch lives in the
-// blanket impls below and the field-reflection lives in `#[derive(DeepClone)]`.
+// Alias: structural dispatch lives in the blanket impls below and the
+// field-reflection lives in `#[derive(DeepClone)]`; both collapse to
+// `T::deep_clone`.
 // Kept as a re-export so generated code (`properties_generated.rs`) and
 // hand-written callers can use either name.
 pub use implement_deep_clone as deep_clone;
 
-// Blanket impls covering the structural cases the Zig switch handled inline.
+// Blanket impls covering the structural cases.
 
 impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for Option<T> {
     #[inline]
@@ -86,15 +82,13 @@ impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for Option<T> {
 impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for &'bump T {
     #[inline]
     fn deep_clone(&self, bump: &'bump Arena) -> Self {
-        // Zig: `bun.create(arena, TT, deepClone(TT, this.*, arena))`
         bump.alloc((**self).deep_clone(bump))
     }
 }
 
 impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for &'bump [T] {
     fn deep_clone(&self, bump: &'bump Arena) -> Self {
-        // Zig: alloc slice, then memcpy if simple-copy else element-wise deepClone.
-        // PERF(port): Zig fast-paths `isSimpleCopyType` with @memcpy — profile if hot
+        // PERF: element-wise deep_clone — profile if hot
         // (specialization would let `T: Copy` use `alloc_slice_copy`).
         bump.alloc_slice_fill_iter(self.iter().map(|e| e.deep_clone(bump)))
     }
@@ -103,8 +97,7 @@ impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for &'bump [T] {
 impl<'bump, T: DeepClone<'bump>> DeepClone<'bump> for ArrayList<'bump, T> {
     #[inline]
     fn deep_clone(&self, bump: &'bump Arena) -> Self {
-        // Zig: `css.deepClone(T, arena, this)` → alloc capacity, element-wise deepClone.
-        // PERF(port): Zig fast-paths simple-copy types with @memcpy — profile if hot.
+        // PERF: element-wise deep_clone — profile if hot.
         let mut out = ArrayList::with_capacity_in(self.len(), bump);
         for item in self.iter() {
             out.push(item.deep_clone(bump));
@@ -191,8 +184,8 @@ pub trait CssEql {
     fn eql(&self, other: &Self) -> bool;
 }
 
-/// `#[derive(CssEql)]` — field-wise / variant-wise port of Zig's
-/// `css.implementEql`. See `src/css_derive/lib.rs` for the expansion rules.
+/// `#[derive(CssEql)]` — field-wise / variant-wise equality.
+/// See `src/css_derive/lib.rs` for the expansion rules.
 /// Re-exported here so `use crate::generics::CssEql;` brings both trait and
 /// derive into scope (same-name idiom, cf. `Clone`).
 pub use bun_css_derive::CssEql;
@@ -290,7 +283,7 @@ eql_simple!(f32, f64, i32, u32, i64, u64, usize, isize, u16, bool);
 ///
 /// Exported sibling of `eql_simple!` for crate-defined types whose
 /// inherent `pub fn eql(&self, other) { self == other }` was a pure `PartialEq`
-/// forwarder (Zig `css.implementEql(@This())` leakage).
+/// forwarder.
 ///
 /// Unlike `#[derive(CssEql)]` (field-wise `.eql()` walk), this does **not**
 /// require every field type to itself impl `CssEql`; it bridges
@@ -329,7 +322,7 @@ impl CssEql for str {
 impl<T: CssEql, const N: usize> CssEql for [T; N] {
     #[inline]
     fn eql(&self, other: &Self) -> bool {
-        // Zig: element-wise eql (length is `N` on both sides by type).
+        // Element-wise eql (length is `N` on both sides by type).
         for (a, b) in self.iter().zip(other.iter()) {
             if !a.eql(b) {
                 return false;
@@ -349,7 +342,6 @@ impl<T: CssEql + ?Sized> CssEql for Box<T> {
 impl CssEql for VendorPrefix {
     #[inline]
     fn eql(&self, other: &Self) -> bool {
-        // Zig: `VendorPrefix.eql` is bitwise compare of the packed struct.
         *self == *other
     }
 }
@@ -393,8 +385,7 @@ mod ident_eql {
 // Bridge inherent eql/hash/deep_clone → trait impls
 //
 // Many CSS value types carry hand-rolled inherent `eql`/`hash`/`deep_clone`
-// (ported verbatim from the Zig `implementEql`/`implementHash`/
-// `implementDeepClone` bodies — usually because a field is a raw `*const [u8]`
+// (usually because a field is a raw `*const [u8]`
 // arena slice that the derive can't see through). The `#[derive(CssEql/…)]`
 // expansion on *containing* types dispatches via UFCS trait paths, so those
 // inherent methods alone don't satisfy the bound. These thin forwarding impls
@@ -646,7 +637,7 @@ mod inherent_bridge {
     use crate::properties::border_image::{
         BorderImage, BorderImageRepeat, BorderImageSideWidth, BorderImageSlice,
     };
-    // PORT NOTE: BorderImageRepeat/SideWidth/Slice carry inherent
+    // BorderImageRepeat/SideWidth/Slice carry inherent
     // `deep_clone(&self, &Arena)` / `eql(&self, &Self)` (no `Clone`/`PartialEq`
     // derives — see border_image.rs), so route through bridge_deep_clone/eql.
     bridge_deep_clone!(BorderImageRepeat, BorderImageSideWidth, BorderImageSlice);
@@ -655,8 +646,8 @@ mod inherent_bridge {
     bridge_eql!(BorderImage);
 
     use crate::properties::border_radius::BorderRadius;
-    // PORT NOTE: BorderRadius has inherent deep_clone/eql (Size2D<T> lacks
-    // Clone/PartialEq derives — see border_radius.rs PORT NOTE).
+    // BorderRadius has inherent deep_clone/eql (Size2D<T> lacks
+    // Clone/PartialEq derives — see border_radius.rs).
     bridge_deep_clone!(BorderRadius);
     bridge_eql!(BorderRadius);
 
@@ -865,9 +856,10 @@ mod inherent_bridge {
     bridge_eql_partialeq!(PropertyId);
 }
 
-// TODO(port): Zig also special-cases `@typeInfo(T).struct.layout == .packed` →
-// bitwise `==`. In Rust those are `bitflags!` types implementing `PartialEq`;
-// add `impl<T: BitFlags> CssEql for T` or per-type impls.
+// Packed bitfields are `bitflags!` types whose derived `PartialEq` already
+// compares contents, routed through the per-type `bridge_eql_partialeq!` calls above.
+// (A blanket `impl<T: bitflags::Flags> CssEql for T` would collide with the container
+// blanket impls under coherence, so coverage stays per-type.)
 
 // ───────────────────────────────────────────────────────────────────────────────
 // Hash
@@ -880,8 +872,8 @@ pub trait CssHash {
     fn hash(&self, hasher: &mut Wyhash);
 }
 
-/// `#[derive(CssHash)]` — field-wise / variant-wise port of Zig's
-/// `css.implementHash`. See `src/css_derive/lib.rs` for the expansion rules.
+/// `#[derive(CssHash)]` — field-wise / variant-wise hashing.
+/// See `src/css_derive/lib.rs` for the expansion rules.
 /// Re-exported here so `use crate::generics::CssHash;` brings both trait and
 /// derive into scope.
 pub use bun_css_derive::CssHash;
@@ -916,9 +908,8 @@ impl CssHash for () {
 impl<T: CssHash> CssHash for Option<T> {
     #[inline]
     fn hash(&self, hasher: &mut Wyhash) {
-        // Zig `hash()` dispatcher: Some → hash inner, None → no-op (no prefix).
-        // The "null"/"some" prefixes are from implementHash's dead .optional arm
-        // (guarded by @compileError) — do NOT emit them here.
+        // Some → hash inner, None → no-op. Do NOT emit "null"/"some"
+        // prefixes here.
         if let Some(v) = self {
             v.hash(hasher);
         }
@@ -934,7 +925,7 @@ impl<T: CssHash + ?Sized> CssHash for &T {
 
 impl<T: CssHash> CssHash for [T] {
     fn hash(&self, hasher: &mut Wyhash) {
-        // Zig `hash()` for `.slice` pointers iterates items only — no len prefix.
+        // Iterates items only — no len prefix.
         for item in self {
             item.hash(hasher);
         }
@@ -943,8 +934,8 @@ impl<T: CssHash> CssHash for [T] {
 
 impl<T: CssHash, const N: usize> CssHash for [T; N] {
     fn hash(&self, hasher: &mut Wyhash) {
-        // Zig: `bun.writeAnyToHasher(hasher, list.len)` — feeds the raw bytes
-        // of `usize` into the hasher. `bun_core::write_any_to_hasher` exists
+        // Feed the raw bytes
+        // of the `usize` length into the hasher. `bun_core::write_any_to_hasher` exists
         // but is `H: Hasher`-generic and routes through `Hasher::write`, which
         // for `Wyhash11` calls `update` — so inlining the `usize` byte-feed
         // here is byte-identical and avoids the trait hop.
@@ -983,7 +974,6 @@ macro_rules! hash_simple {
         impl CssHash for $t {
             #[inline]
             fn hash(&self, hasher: &mut Wyhash) {
-                // Zig: `hasher.update(std.mem.asBytes(&this))`
                 hasher.update(&self.to_ne_bytes());
             }
         }
@@ -1023,7 +1013,6 @@ impl<T: CssHash + ?Sized> CssHash for Box<T> {
 impl CssHash for VendorPrefix {
     #[inline]
     fn hash(&self, hasher: &mut Wyhash) {
-        // Zig: `hasher.update(std.mem.asBytes(&this))` on the packed-struct repr.
         hasher.update(&[self.as_bits()]);
     }
 }
@@ -1031,8 +1020,7 @@ impl CssHash for VendorPrefix {
 impl CssHash for bun_ast::Loc {
     #[inline]
     fn hash(&self, hasher: &mut Wyhash) {
-        // Zig `implementHash` doesn't reach `Loc` (callers skip it), but
-        // providing a structural hash here lets `#[derive(CssHash)]` types
+        // Providing a structural hash here lets `#[derive(CssHash)]` types
         // include a `loc` field without `#[css(skip)]` if they want.
         hasher.update(&self.start.to_ne_bytes());
     }
@@ -1108,9 +1096,8 @@ impl<T: IsCompatible + ?Sized> IsCompatible for Box<T> {
 impl<T: IsCompatible> IsCompatible for Option<T> {
     #[inline]
     fn is_compatible(&self, browsers: &crate::targets::Browsers) -> bool {
-        // Zig's `isCompatible` doesn't special-case Optional, but every
-        // hand-written caller treats absent as compatible (no value → no
-        // feature gate to check).
+        // Every hand-written caller treats absent as compatible (no value →
+        // no feature gate to check).
         match self {
             Some(v) => v.is_compatible(browsers),
             None => true,
@@ -1144,7 +1131,7 @@ impl<T: IsCompatible> IsCompatible for Vec<T> {
     }
 }
 
-// The Zig original blanket-impls over "any list container". A Rust blanket
+// A blanket
 // `impl<L: ListContainer>` conflicts with the `&T` impl above (coherence can't
 // prove `&T` never impls `ListContainer`), so spell out the three concrete
 // container types instead.
@@ -1173,8 +1160,7 @@ is_compatible_container!(
 // ───────────────────────────────────────────────────────────────────────────────
 // Parse / ParseWithOptions
 // ───────────────────────────────────────────────────────────────────────────────
-// Zig's `generic.parse(T, input)` / `generic.parseWithOptions(T, input, opts)`
-// dispatch via `@hasDecl(T, "parse"[WithOptions])`. In Rust each leaf value
+// Each leaf value
 // type either hand-writes an inherent `parse(&mut Parser) -> CssResult<Self>`
 // or derives one via `#[derive(Parse)]` / `#[derive(DefineEnumProperty)]`; the
 // trait below is the uniform bound that `Property::parse` and the container
@@ -1182,7 +1168,7 @@ is_compatible_container!(
 //
 // `Parse` is intentionally lifetime-free: every value-type parser takes
 // `&mut Parser<'_>` (the borrowed source slice) and returns an owned value.
-// TODO(refactor): `'bump` arena threading is a follow-up; until then the parser
+// `'bump` arena threading is a follow-up; until then the parser
 // holds the arena and arena-backed lists go through `from_list(Vec)`.
 
 /// `T::parse(&mut Parser) -> CssResult<T>`.
@@ -1192,8 +1178,8 @@ pub trait Parse: Sized {
 
 /// `T::parse_with_options(&mut Parser, &ParserOptions) -> CssResult<T>`.
 ///
-/// Zig falls through to `parse` when a type has no `parseWithOptions` decl.
-/// PORT NOTE: Rust can't express that as a `where Self: Parse` default method
+/// Falling back to `parse` when a type has no `parse_with_options`
+/// can't be expressed as a `where Self: Parse` default method
 /// — the bound becomes part of the *method signature*, so the free
 /// `parse_with_options::<T>` below would require `T: Parse` even for impls
 /// that override the body. Instead the fallthrough lives in
@@ -1249,7 +1235,7 @@ impl<T: Parse> ParseWithOptions for Vec<T> {
     }
 }
 
-// Zig `.pointer` arm (`generics.zig:273-279`): parse the pointee then heap-allocate.
+// Parse the pointee then heap-allocate.
 impl<T: Parse> Parse for Box<T> {
     #[inline]
     fn parse(input: &mut Parser) -> CssResult<Self> {
@@ -1355,7 +1341,7 @@ impl<T: ToCss + ?Sized> ToCss for &T {
     }
 }
 
-// Zig `.pointer` arm (`generics.zig:338-341`): recurse into `*T` pointee.
+// Recurse into the pointee.
 impl<T: ToCss + ?Sized> ToCss for Box<T> {
     #[inline]
     fn to_css(&self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
@@ -1522,11 +1508,11 @@ impl TrySign for CSSNumber {
         Some(CSSNumberFns::sign(*self))
     }
 }
-// TODO(port): Zig fallback `if @hasDecl(T, "sign") T.sign else T.trySign` —
-// model as a trait with default method delegating to `Sign` where available.
+// Each type
+// implements `TrySign` explicitly (delegating to its inherent `sign` where one exists).
 
 pub trait TryMap: Sized {
-    // Zig: `comptime map_fn: *const fn(f32) f32` — generic param preserves monomorphization.
+    // Generic param preserves monomorphization.
     fn try_map(&self, map_fn: impl Fn(f32) -> f32) -> Option<Self>;
 }
 
@@ -1538,7 +1524,7 @@ impl TryMap for CSSNumber {
 }
 
 pub trait TryOpTo: Sized {
-    // Zig: `comptime op_fn: *const fn(...)` — generic param preserves monomorphization.
+    // Generic param preserves monomorphization.
     // `R` is method-generic (not trait-generic) so `TryOpTo` can appear as a
     // supertrait bound without committing to a result type.
     fn try_op_to<R, C>(&self, rhs: &Self, ctx: C, op_fn: impl Fn(C, f32, f32) -> R) -> Option<R>;
@@ -1559,7 +1545,7 @@ impl IsCompatible for CSSNumber {
 }
 
 pub trait TryOp: Sized {
-    // Zig: `comptime op_fn: *const fn(...)` — generic param preserves monomorphization.
+    // Generic param preserves monomorphization.
     fn try_op<C>(&self, rhs: &Self, ctx: C, op_fn: impl Fn(C, f32, f32) -> f32) -> Option<Self>;
 }
 
@@ -1629,5 +1615,3 @@ impl MulF32 for CSSNumber {
         self * rhs
     }
 }
-
-// ported from: src/css/generics.zig
diff --git a/src/css/lib.rs b/src/css/lib.rs
index 101d7f2b906..80da3aa27ac 100644
--- a/src/css/lib.rs
+++ b/src/css/lib.rs
@@ -5,14 +5,12 @@
 // were translated against the crate's public surface and refer to it by name.
 extern crate self as bun_css;
 
-/// Case-insensitive ASCII byte-slice dispatch — the fix for Zig's
-/// `css.todo_stuff.match_ignore_ascii_case` sentinel and a drop-in port of
+/// Case-insensitive ASCII byte-slice dispatch — equivalent to
 /// rust-cssparser's `match_ignore_ascii_case!`.
 ///
 /// Expands to an `if / else if / else` chain over
 /// [`bun_core::strings::eql_case_insensitive_ascii_check_length`] (length-checked,
-/// ASCII-fold only, byte-wise — identical to Zig's
-/// `bun.strings.eqlCaseInsensitiveASCIIICheckLength`). The whole macro is an
+/// ASCII-fold only, byte-wise). The whole macro is an
 /// expression; arms may `return`, `break 'label`, or yield a value.
 ///
 /// Supports `|`-alternation and Rust-style `if` guards on arms; the trailing
@@ -26,7 +24,6 @@ extern crate self as bun_css;
 ///     _                            => Err(location.new_unexpected_token_error(token)),
 /// }}
 /// ```
-// TODO(port): swap body to phf when CI hasher lands.
 #[macro_export]
 macro_rules! match_ignore_ascii_case {
     ($name:expr, { $( $($lit:literal)|+ $(if $guard:expr)? => $arm:expr ,)* _ => $fallback:expr $(,)? }) => {{
@@ -78,9 +75,9 @@ pub mod declaration;
 pub use context::{DeclarationContext, PropertyHandlerContext, SupportsEntry};
 pub use declaration::{DeclarationBlock, DeclarationHandler, DeclarationList};
 
-// Path aliases the ported submodules expect at crate root (Zig's `css.*`
-// namespace was flat; the Rust port re-nests under `values/`/`properties/`
-// but most callers still spell `bun_css::css_values::...`).
+// Path aliases the submodules expect at crate root (the crate re-nests under
+// `values/`/`properties/` but most callers still spell
+// `bun_css::css_values::...`).
 pub use properties as css_properties;
 pub use rules as css_rules;
 pub use selectors::selector;
@@ -94,10 +91,10 @@ pub use css_parser::{
 };
 
 // ─── selectors/ crate-root surface ────────────────────────────────────────
-// The selector grammar references these via `bun_css::*` (Zig's flat `css.*`
-// namespace). `Str` is the arena-borrowed `[]const u8` slice alias; here
-// it's `*const [u8]` (matches `error.rs` / `values::ident` field shape) and
-// becomes `&'bump [u8]` once the arena lifetime is plumbed.
+// The selector grammar references these via `bun_css::*`. `Str` is the
+// arena-borrowed byte-slice alias; here it's `*const [u8]` (matches
+// `error.rs` / `values::ident` field shape) and becomes `&'bump [u8]` once
+// the arena lifetime is plumbed.
 pub(crate) type Str = *const [u8];
 
 /// Dereference an arena-owned [`Str`] into a slice borrow.
@@ -120,23 +117,22 @@ pub(crate) unsafe fn arena_str(p: Str) -> &'static [u8] {
     unsafe { &*p }
 }
 pub use compat::Feature;
-/// `css::ParseErrorKind` — Zig spelling. Alias of `error::ParserErrorKind`.
+/// Alias of `error::ParserErrorKind`.
 pub use error::ParserErrorKind as ParseErrorKind;
 pub use error::ParserErrorKind as ErrorKind;
 pub use properties::custom::{TokenList, TokenListFns};
 pub use values::ident::{CustomIdentFns, DashedIdentFns, IdentFns};
 pub use values::string::{CssString as CSSString, CssStringFns as CSSStringFns};
 
-// `css::generic::*` is the Zig-spelled namespace for the protocol traits +
-// reflection helpers. The Rust module is `generics`; alias both spellings so
-// value/property modules can use `crate::generic::partial_cmp_f32` etc.
+// `css::generic::*` is an alternate spelling of the protocol traits +
+// reflection helpers in `generics`; alias both spellings so value/property
+// modules can use `crate::generic::partial_cmp_f32` etc.
 pub use generics as generic;
 pub use generics::{implement_deep_clone, implement_eql, implement_hash};
 // Same-name trait + derive macro re-export so `#[derive(bun_css::DeepClone)]`
 // (and `use bun_css::DeepClone;` at leaf sites) brings both into scope.
 pub use generics::{CssEql, DeepClone};
-// Keyword-enum / `union(enum)` derive macros (port of Zig's `DefineEnumProperty`
-// / `DeriveParse` / `DeriveToCss` comptime fns). The `EnumProperty` *trait* is
+// Keyword-enum / tagged-union derive macros. The `EnumProperty` *trait* is
 // re-exported above from `css_parser`; the *derive* of the same name lives in
 // the proc-macro crate.
 pub use bun_css_derive::{DefineEnumProperty, Parse, ToCss};
@@ -165,8 +161,6 @@ pub mod values_stub {
     pub mod color {
         pub use crate::values::color::*;
 
-        /// `Result(CssColor)` — Zig: `pub const ParseResult = Result(CssColor);`
-        /// where `Result(T) = Maybe(T, ParseError(ParserError))` (css_parser.zig:278).
         /// `Maybe` is now un-gated as `core::result::Result`, so this is a
         /// straight type alias to the real `values::color::ParseResult`.
         pub type CssColorParseResult = crate::values::color::ParseResult;
@@ -209,7 +203,7 @@ impl core::fmt::Display for PrintErr {
 }
 impl core::error::Error for PrintErr {}
 
-/// `PrintErr!T` return shape (Zig: `PrintErr!void`) used by every `to_css`
+/// Return shape used by every `to_css`
 /// path. Distinct from `css_parser::PrintResult<T> = Maybe<T, PrinterError>`,
 /// which carries the rich `Err<PrinterErrorKind>` — this is just the bubbled
 /// signal (the *kind* lives in `Printer.error_kind`).
@@ -224,8 +218,7 @@ pub use css_parser::{
     ParserOptions, StyleAttribute, StyleSheet, StylesheetExtra, ToCssResult,
 };
 pub use printer::{ImportInfo, Printer, PrinterOptions, PseudoClasses};
-/// Dependent crates name this `ImportRecordHandler` (Zig had a now-removed
-/// union of the same name in css_parser.zig:3783); the surviving type is
+/// Dependent crates name this `ImportRecordHandler`; the surviving type is
 /// `printer::ImportInfo`, exposed under both names.
 pub type ImportRecordHandler<'a> = printer::ImportInfo<'a>;
 pub use values::color::{CssColor, FloatColor, LABColor, LabColor, PredefinedColor, RGBA};
@@ -281,7 +274,7 @@ impl VendorPrefix {
     ];
 
     // NOTE: bitflags 2.x already generates `from_name(&str) -> Option<Self>`;
-    // the Zig `fromName` (panicking) is exposed as `from_name_str`.
+    // the panicking variant is exposed as `from_name_str`.
     #[inline]
     pub fn from_name_str(name: &str) -> VendorPrefix {
         match name {
@@ -307,7 +300,7 @@ impl VendorPrefix {
     }
 
     pub fn difference_(left: Self, right: Self) -> Self {
-        // Zig used arithmetic subtraction on bits; preserve that.
+        // Arithmetic subtraction on bits, not set difference; callers depend on it.
         Self::from_bits_retain(left.bits().wrapping_sub(right.bits()))
     }
 
@@ -387,15 +380,16 @@ pub struct Num {
 pub struct Dimension {
     pub num: Num,
     /// e.g. "px"
-    // TODO(port): arena lifetime — &'static placeholder per PORTING.md §AST crates.
+    // Borrows the parser arena/source; `&'static` placeholder per PORTING.md §AST crates.
     pub unit: &'static [u8],
 }
 
 /// CSS lexer token. Data-only definition hoisted out of `css_parser.rs`; the
 /// `to_css*`/`eql`/`hash` impls stay in `css_parser.rs` (gated) since they
 /// depend on `serializer::*` and `generics`.
-// TODO(port): every &'static [u8] payload borrows the parser arena/source;
-// thread `<'a>` once the bumpalo arena lifetime is plumbed.
+// Every `&'static [u8]` payload actually borrows the parser arena/source text and
+// must not outlive the arena; `&'static` is the crate-wide placeholder until the
+// bumpalo arena lifetime is plumbed through.
 #[derive(Clone, Debug)]
 pub enum Token {
     Ident(&'static [u8]),
@@ -441,8 +435,8 @@ pub enum Token {
 
 impl core::fmt::Display for Token {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // Minimal rendering for error messages. The full Zig `Token.format`
-        // (CSS serialization) lives in `css_parser.rs` via `serializer::*`.
+        // Minimal rendering for error messages. Full CSS serialization
+        // lives in `css_parser.rs` via `serializer::*`.
         use bstr::BStr;
         match self {
             Token::Ident(v)
diff --git a/src/css/logical.rs b/src/css/logical.rs
index 4847ed448d0..a88c79c8683 100644
--- a/src/css/logical.rs
+++ b/src/css/logical.rs
@@ -20,5 +20,3 @@ pub enum LogicalGroup {
     MinSize,
     MaxSize,
 }
-
-// ported from: src/css/logical.zig
diff --git a/src/css/media_query.rs b/src/css/media_query.rs
index 328d6423a18..28b0014fd89 100644
--- a/src/css/media_query.rs
+++ b/src/css/media_query.rs
@@ -1,6 +1,4 @@
 //! CSS [media queries](https://drafts.csswg.org/mediaqueries/).
-//!
-//! Ported from `src/css/media_query.zig`.
 
 use crate as css;
 use crate::css_properties::custom::EnvironmentVariable;
@@ -10,9 +8,8 @@ use bun_alloc::ArenaPtr;
 
 pub use crate::Error;
 
-// TODO(port): the CSS crate borrows strings from parser input with lifetime `'i`
-// (matching lightningcss). This module avoids struct lifetime params; consider
-// threading `'i` through `MediaType::Custom`, `Ident`, `DashedIdent`, etc.
+// Strings here borrow parser input/arena memory but the structs carry no lifetime
+// params (crate-wide `&'static`/raw-slice placeholder convention); see lib.rs.
 
 // ───────────────────────── value-type imports ─────────────────────────
 // Real `values/` payloads — the calc lattice has un-gated, so the local
@@ -30,12 +27,10 @@ type CSSInteger = i32;
 // Selector, Unknown} and its `needs_parens(&Self)` / `b" not "` contract are
 // structurally different and must stay hand-rolled.
 //
-// `deep_clone` is intentionally NOT on this trait. The Zig precedent is ONE
-// reflective `css.implementDeepClone` (generics.zig); the Rust equivalent is
+// `deep_clone` is intentionally NOT on this trait. The single mechanism is
 // `#[derive(DeepClone)]` (generics.rs). The hand-expansions in callers exist
 // only because of derive blockers — fix the derive, not the trait.
 
-/// Trait modeling Zig's `ValidQueryCondition` comptime interface check.
 /// Any type that can appear as a node in a query-condition tree.
 pub trait QueryCondition: Sized + ToCss {
     /// Leaf payload: `QueryFeature<_>` for media/container, `Property` for
@@ -181,13 +176,12 @@ pub enum MediaType {
     /// `screen`.
     Screen,
     /// An unknown / deprecated / custom media type.
-    // TODO(port): arena lifetime — Zig borrowed parser input.
+    // Lifetime: arena-borrowed parser input; valid until the arena is reset.
     Custom(*const [u8]),
 }
 
-// PORT NOTE: hand-rolled — derived PartialEq on `*const [u8]` compares
-// address+len, not byte content. Spec `MediaType.eql` compares slice bytes
-// (via `css.implementEql`); adjacent-@media merging (rules.zig) depends on
+// Hand-rolled — derived PartialEq on `*const [u8]` compares
+// address+len, not byte content. Adjacent-@media merging depends on
 // content equality across distinct arena offsets.
 impl PartialEq for MediaType {
     fn eq(&self, other: &Self) -> bool {
@@ -203,7 +197,6 @@ impl PartialEq for MediaType {
 }
 
 // Flags for `parse_query_condition`.
-// PORT NOTE: Zig `packed struct(u8)` with two bool fields → bitflags!
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct QueryConditionFlags: u8 {
@@ -255,8 +248,7 @@ pub enum MediaFeatureName<FeatureId: FeatureIdTrait> {
     Unknown(Ident),
 }
 
-// PORT NOTE: `eql` was hand-written byte compare on the ident slices; data-only
-// PartialEq derived once `Ident`/`DashedIdent` gain `PartialEq` (values/ un-gate).
+// Data-only PartialEq, derived once `Ident`/`DashedIdent` gained `PartialEq`.
 impl<FeatureId: FeatureIdTrait> PartialEq for MediaFeatureName<FeatureId> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -296,9 +288,9 @@ pub enum QueryFeature<FeatureId: FeatureIdTrait> {
 }
 
 /// Comparison operator in a range media feature.
-// PORT NOTE: discriminants are power-of-two bitflags — Zig media_query.zig
-// bitwise-ORs `@intFromEnum(start_operator) | @intFromEnum(end_operator)` to
-// validate interval operator pairs. Do NOT use implicit 0..=4.
+// Discriminants are power-of-two bitflags — interval-operator-pair
+// validation bitwise-ORs the start/end operator discriminants.
+// Do NOT use implicit 0..=4.
 #[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::IntoStaticStr)]
 pub enum MediaFeatureComparison {
@@ -315,7 +307,7 @@ pub enum MediaFeatureComparison {
 }
 
 /// [media feature value](https://drafts.csswg.org/mediaqueries/#typedef-mf-value).
-// PORT NOTE: `Debug` hand-rolled below — `Length` (calc tree) does not derive
+// `Debug` hand-rolled below — `Length` (calc tree) does not derive
 // `Debug`, but the `MediaCondition`/`QueryFeature` chain wants it for
 // diagnostics.
 #[derive(Clone)]
@@ -355,8 +347,8 @@ impl core::fmt::Debug for MediaFeatureValue {
     }
 }
 
-// PORT NOTE: derive(PartialEq) blocked on `Ident`/`EnvironmentVariable` lacking
-// std `PartialEq`; hand-roll all arms (Zig: `css.implementEql`).
+// derive(PartialEq) blocked on `Ident`/`EnvironmentVariable` lacking
+// std `PartialEq`; hand-roll all arms.
 impl PartialEq for MediaFeatureValue {
     fn eq(&self, other: &Self) -> bool {
         use MediaFeatureValue as V;
@@ -368,8 +360,7 @@ impl PartialEq for MediaFeatureValue {
             (V::Resolution(a), V::Resolution(b)) => a == b,
             (V::Ratio(a), V::Ratio(b)) => a == b,
             (V::Ident(a), V::Ident(b)) => a.v() == b.v(),
-            // Zig: `css.implementEql` recurses into `EnvironmentVariable.eql` —
-            // ported via the `CssEql` derive on `EnvironmentVariable`
+            // `CssEql` derive on `EnvironmentVariable`
             // (name + indices + fallback structural equality).
             (V::Env(a), V::Env(b)) => {
                 use crate::generics::CssEql as _;
@@ -402,7 +393,6 @@ pub enum MediaFeatureType {
 }
 
 impl MediaFeatureType {
-    /// Zig: `MediaFeatureType.allowsRanges`.
     pub fn allows_ranges(self) -> bool {
         use MediaFeatureType as T;
         matches!(
@@ -412,8 +402,7 @@ impl MediaFeatureType {
     }
 }
 
-/// Trait modeling Zig's `MediaFeatureId`-shape comptime interface for the
-/// generic `QueryFeature<FeatureId>`.
+/// Feature-id interface for the generic `QueryFeature<FeatureId>`.
 pub trait FeatureIdTrait: Copy + PartialEq + Eq {
     fn value_type(&self) -> MediaFeatureType;
     fn to_css(&self, dest: &mut Printer) -> core::result::Result<(), PrintErr>;
@@ -554,7 +543,6 @@ pub enum MediaFeatureId {
 }
 
 impl MediaFeatureId {
-    // Zig: `pub const valueType = css.DeriveValueType(@This(), ValueTypeMap).valueType;`
     pub(crate) fn value_type(self) -> MediaFeatureType {
         use MediaFeatureId::*;
         use MediaFeatureType as T;
@@ -602,8 +590,8 @@ impl FeatureIdTrait for MediaFeatureId {
         MediaFeatureId::value_type(*self)
     }
     fn to_css(&self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
-        // Zig: `css.DefineEnumProperty(@This()).toCss` — emits the lowercase
-        // tag name. `strum::IntoStaticStr` already carries those strings.
+        // Emits the lowercase tag name. `strum::IntoStaticStr` already
+        // carries those strings.
         dest.write_str(<&'static str>::from(*self))
     }
     fn to_css_with_prefix(
@@ -612,8 +600,8 @@ impl FeatureIdTrait for MediaFeatureId {
         dest: &mut Printer,
     ) -> core::result::Result<(), PrintErr> {
         match self {
-            // Zig: `-webkit-{s}device-pixel-ratio` — webkit places the
-            // min/max prefix between the vendor prefix and the feature name.
+            // webkit places the min/max prefix between the vendor prefix
+            // and the feature name.
             MediaFeatureId::WebkitDevicePixelRatio => {
                 dest.write_str("-webkit-")?;
                 dest.write_str(prefix)?;
@@ -626,8 +614,8 @@ impl FeatureIdTrait for MediaFeatureId {
         }
     }
     fn from_str(s: &[u8]) -> Option<Self> {
-        // Zig: `css.DefineEnumProperty(@This()).parse` — case-insensitive
-        // ASCII tag-name table. No dependency on the gated `values/` lattice.
+        // Case-insensitive ASCII tag-name table. No dependency on the gated
+        // `values/` lattice.
         use MediaFeatureId::*;
         crate::match_ignore_ascii_case! { s, {
             b"width" => Some(Width),
@@ -762,7 +750,7 @@ impl MediaQuery {
     }
 }
 
-/// Zig: `toCssWithParensIfNeeded` — wraps `v.to_css()` in parentheses when the
+/// Wraps `v.to_css()` in parentheses when the
 /// caller's grammar position requires it.
 pub(crate) fn to_css_with_parens_if_needed<T: ToCss + ?Sized>(
     v: &T,
@@ -779,7 +767,7 @@ pub(crate) fn to_css_with_parens_if_needed<T: ToCss + ?Sized>(
     Ok(())
 }
 
-/// Zig: `operationToCss` — serialize `a OP b OP c ...` with per-child parens.
+/// Serialize `a OP b OP c ...` with per-child parens.
 pub(crate) fn operation_to_css<C: QueryCondition>(
     operator: Operator,
     conditions: &[C],
@@ -868,7 +856,6 @@ impl QueryCondition for MediaCondition {
         }
     }
     fn parse_style_query(input: &mut Parser) -> Result<Self> {
-        // Zig: `return .{ .err = input.newErrorForNextToken() }`
         Err(input.new_error_for_next_token())
     }
     fn needs_parens(
@@ -952,7 +939,6 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
 }
 
 impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
-    /// Zig: `MediaFeatureName.valueType`.
     pub(crate) fn value_type(&self) -> MediaFeatureType {
         match self {
             MediaFeatureName::Standard(standard) => standard.value_type(),
@@ -963,8 +949,6 @@ impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
     pub(crate) fn to_css(&self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
         match self {
             MediaFeatureName::Standard(v) => v.to_css(dest),
-            // PORT NOTE: Zig `DashedIdentFns.toCss` → `dest.writeDashedIdent`
-            // (handles css-module name rewriting).
             MediaFeatureName::Custom(d) => d.to_css(dest),
             MediaFeatureName::Unknown(v) => v.to_css(dest),
         }
@@ -991,8 +975,6 @@ impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
     /// Parses a media feature name. Returns `(name, legacy_comparator)` —
     /// `legacy_comparator` is `Some` when the ident carried a `min-`/`max-`
     /// prefix (lowered to `>=`/`<=`).
-    ///
-    /// Zig: `MediaFeatureName.parse`.
     pub(crate) fn parse(input: &mut Parser) -> Result<(Self, Option<MediaFeatureComparison>)> {
         use bun_core::strings;
         let ident = input.expect_ident_cloned()?;
@@ -1021,13 +1003,9 @@ impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
                 None
             };
 
-        // PORT NOTE: Zig `allocPrint("-webkit-{s}", .{name})` then
-        // `parse_utility.parseString(.., FeatureId.parse)` — the re-tokenize is
-        // only to feed `DefineEnumProperty.parse` an ident token. Here
-        // `FeatureIdTrait::from_str` does the same case-insensitive table lookup
-        // directly, so a stack buffer suffices and the temp string is freed
-        // immediately (Zig asserts `FeatureId` is an enum for the same reason).
-        // PERF: stack buffer here?
+        // `FeatureIdTrait::from_str` does a case-insensitive table lookup
+        // directly, so a stack buffer suffices for re-attaching the
+        // `-webkit-` prefix.
         let mut webkit_buf: [u8; 64] = [0; 64];
         let final_name: &[u8] = if is_webkit {
             let len = 8 + name.len();
@@ -1057,8 +1035,8 @@ impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
 impl MediaFeatureComparison {
     pub(crate) fn to_css(self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
         match self {
-            // PORT NOTE(suspect): Zig emits '-' for `Equal` (media_query.zig:1156),
-            // diverging from the spec `=` and from this enum's strum tag. Ported
+            // Suspect but intentional: emits '-' for `Equal`, diverging from
+            // the spec `=` and from this enum's strum tag. Preserved
             // byte-for-byte; revisit if upstream fixes.
             MediaFeatureComparison::Equal => dest.delim(b'-', true),
             MediaFeatureComparison::GreaterThan => dest.delim(b'>', true),
@@ -1107,11 +1085,10 @@ impl MediaFeatureValue {
         }
     }
 
-    /// Zig: `addF32` — adjust by `other` for strict-inequality → min/max
+    /// Adjust by `other` for strict-inequality → min/max
     /// boundary lowering. Consumes `self`.
     pub(crate) fn add_f32(self, other: f32) -> MediaFeatureValue {
         match self {
-            // Zig: `len.add(arena, Length.px(other))` — calc lattice.
             MediaFeatureValue::Length(len) => MediaFeatureValue::Length(len.add(Length::px(other))),
             MediaFeatureValue::Number(num) => MediaFeatureValue::Number(num + other),
             MediaFeatureValue::Integer(num) => {
@@ -1121,11 +1098,14 @@ impl MediaFeatureValue {
             MediaFeatureValue::Resolution(res) => MediaFeatureValue::Resolution(res.add_f32(other)),
             MediaFeatureValue::Ratio(ratio) => MediaFeatureValue::Ratio(ratio.add_f32(other)),
             MediaFeatureValue::Ident(id) => MediaFeatureValue::Ident(id),
-            MediaFeatureValue::Env(env) => MediaFeatureValue::Env(env), // TODO: calc support
+            // env() values pass through unchanged — the calc-lattice add
+            // (wrapping the env() reference in a calc() to apply the
+            // strict-inequality boundary adjustment) is not implemented, so
+            // range bounds on env() values lose the +/-0.001 nudge.
+            MediaFeatureValue::Env(env) => MediaFeatureValue::Env(env),
         }
     }
 
-    /// Zig: `MediaFeatureValue.valueType`.
     pub(crate) fn value_type(&self) -> MediaFeatureType {
         use MediaFeatureValue as V;
         match self {
@@ -1140,7 +1120,6 @@ impl MediaFeatureValue {
         }
     }
 
-    /// Zig: `MediaFeatureValue.checkType`.
     pub(crate) fn check_type(&self, expected_type: MediaFeatureType) -> bool {
         let vt = self.value_type();
         if expected_type == MediaFeatureType::Unknown || vt == MediaFeatureType::Unknown {
@@ -1212,10 +1191,8 @@ impl MediaFeatureValue {
             return Ok(MediaFeatureValue::Resolution(res));
         }
 
-        // PORT NOTE: Zig `input.tryParse(EnvironmentVariable.parse, .{})` left
-        // `options`/`depth` undefined (tryParse builds `ArgsTuple` and only
-        // fills index 0) — UB. Fixed here by threading the real `ParserOptions`
-        // down from `QueryFeature::parse` and passing `depth = 0`.
+        // The real `ParserOptions` are threaded down from
+        // `QueryFeature::parse`; `depth = 0` since this is a fresh value.
         if let Ok(env) = input.try_parse(|i| EnvironmentVariable::parse(i, options, 0)) {
             return Ok(MediaFeatureValue::Env(env));
         }
@@ -1225,7 +1202,7 @@ impl MediaFeatureValue {
     }
 }
 
-/// Zig: `writeMinMax` — lower a range/interval comparator to legacy
+/// Lower a range/interval comparator to legacy
 /// `min-`/`max-` prefixed plain feature.
 fn write_min_max<FeatureId: FeatureIdTrait>(
     operator: MediaFeatureComparison,
@@ -1249,8 +1226,7 @@ fn write_min_max<FeatureId: FeatureIdTrait>(
 
     dest.delim(b':', false)?;
 
-    // PORT NOTE: Zig deepCloned `value` into `dest.arena` then mutated; here
-    // `MediaFeatureValue: Clone` so we clone-by-value.
+    // `MediaFeatureValue: Clone`, so clone-by-value before adjusting.
     let adjusted: Option<MediaFeatureValue> = match operator {
         MediaFeatureComparison::GreaterThan => Some(value.clone().add_f32(0.001)),
         MediaFeatureComparison::LessThan => Some(value.clone().add_f32(-0.001)),
@@ -1267,19 +1243,18 @@ fn write_min_max<FeatureId: FeatureIdTrait>(
 }
 
 // ───────────────────────── deep_clone ─────────────────────────
-// Arena-aware `deep_clone` — port of Zig's per-type `deepClone(arena)`
-// bodies. Un-gated this round so `rules::dc::{media_list,query_feature}` can
-// route through real impls instead of `#[derive(Clone)]` passthroughs.
+// Arena-aware `deep_clone`. Un-gated this round so
+// `rules::dc::{media_list,query_feature}` can route through real impls
+// instead of `#[derive(Clone)]` passthroughs.
 //
-// PORT NOTE: written as **inherent** methods (not `#[derive(DeepClone)]`) to
-// match the Zig hand-written bodies exactly: Zig copies `name`/`qualifier`/
-// `media_type`/`operator` fields by value (they are `Copy`/arena-slice types
-// under the generics.zig "const strings" rule) and only recurses into the
-// allocating payloads (`Vec`, `Box`, `MediaFeatureValue`). The derive would
+// Written as **inherent** methods (not `#[derive(DeepClone)]`):
+// `name`/`qualifier`/`media_type`/`operator` fields are copied by value
+// (they are `Copy`/arena-slice types) and only the allocating payloads
+// (`Vec`, `Box`, `MediaFeatureValue`) are recursed into. The derive would
 // instead add a spurious `FeatureId: DeepClone<'bump>` where-bound.
 
 impl MediaList {
-    /// Zig: `MediaList.deepClone` — element-wise clone of `media_queries`.
+    /// Element-wise clone of `media_queries`.
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         let mut media_queries =
             Vec::with_capacity_in(self.media_queries.len(), ArenaPtr::new(bump));
@@ -1287,13 +1262,13 @@ impl MediaList {
         Self { media_queries }
     }
 
-    /// Zig: `pub fn clone(this, arena)` — alias for `deepClone`.
+    /// Alias for `deep_clone`.
     #[inline]
     pub fn clone_in(&self, bump: &bun_alloc::Arena) -> Self {
         self.deep_clone(bump)
     }
 
-    /// Zig: `MediaList.cloneWithImportRecords` — `MediaList` carries no
+    /// `MediaList` carries no
     /// `ImportRecord` indices so this is just `deep_clone`.
     #[inline]
     pub fn clone_with_import_records(
@@ -1304,7 +1279,7 @@ impl MediaList {
         self.deep_clone(bump)
     }
 
-    /// Zig: `pub const eql = css.implementEql(@This())` — structural eq.
+    /// Structural eq.
     #[inline]
     pub fn eql(&self, other: &Self) -> bool {
         self == other
@@ -1312,7 +1287,7 @@ impl MediaList {
 }
 
 impl MediaQuery {
-    /// Zig: `MediaQuery.deepClone` — field-wise.
+    /// Field-wise.
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         Self {
             qualifier: self.qualifier,
@@ -1323,8 +1298,7 @@ impl MediaQuery {
 }
 
 impl MediaType {
-    /// Zig: `css.implementDeepClone` — `Custom([]const u8)` is an arena-owned
-    /// slice (identity copy under the generics.zig "const strings" rule).
+    /// `Custom` is an arena-owned slice (identity copy).
     #[inline]
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
         *self
@@ -1332,14 +1306,13 @@ impl MediaType {
 }
 
 impl MediaCondition {
-    /// Zig: `MediaCondition.deepClone` — variant-wise recursion.
+    /// Variant-wise recursion.
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         let alloc = ArenaPtr::new(bump);
         match self {
             MediaCondition::Feature(f) => {
                 MediaCondition::Feature(Box::new_in(f.deep_clone(bump), alloc))
             }
-            // Zig: `bun.create(arena, MediaCondition, c.deepClone(arena))`
             MediaCondition::Not(c) => MediaCondition::Not(Box::new_in(c.deep_clone(bump), alloc)),
             MediaCondition::Operation {
                 operator,
@@ -1357,7 +1330,7 @@ impl MediaCondition {
 }
 
 impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
-    /// Zig: struct-copy (`name = this.plain.name`). All payloads are `Copy` /
+    /// All payloads are `Copy` /
     /// arena-slice idents; `derive(Clone)` is the faithful deep clone.
     #[inline]
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
@@ -1366,7 +1339,7 @@ impl<FeatureId: FeatureIdTrait> MediaFeatureName<FeatureId> {
 }
 
 impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
-    /// Zig: `QueryFeature.deepClone` — variant-wise; `name`/`operator` are
+    /// Variant-wise; `name`/`operator` are
     /// value-copied, `MediaFeatureValue` recurses.
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         match self {
@@ -1404,14 +1377,13 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
 }
 
 impl MediaFeatureValue {
-    /// Zig: `MediaFeatureValue.deepClone` — variant-wise.
+    /// Variant-wise.
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         use MediaFeatureValue as V;
         match self {
-            // Zig: `l.deepClone(arena)` — real `values::length::Length`
-            // owns a calc tree. The local `value_shims::Length` stand-in is a
-            // unit struct, so `Clone` is faithful until the calc lattice
-            // un-gates and the shim is replaced.
+            // The real `values::length::Length` owns a calc tree. The local
+            // `value_shims::Length` stand-in is a unit struct, so `Clone` is
+            // faithful until the calc lattice un-gates and the shim is replaced.
             V::Length(l) => V::Length(l.clone()),
             V::Number(n) => V::Number(*n),
             V::Integer(i) => V::Integer(*i),
@@ -1419,7 +1391,7 @@ impl MediaFeatureValue {
             V::Resolution(r) => V::Resolution(*r),
             V::Ratio(r) => V::Ratio(*r),
             V::Ident(i) => V::Ident(i.deep_clone(bump)),
-            // Zig: `e.deepClone(arena)` — `EnvironmentVariable` carries
+            // `EnvironmentVariable` carries
             // `Vec<CSSInteger>` + `Option<TokenList>`; route through its
             // `#[derive(DeepClone)]` impl.
             V::Env(e) => {
@@ -1477,7 +1449,6 @@ impl MediaList {
             match input.next() {
                 Ok(tok) => {
                     if !matches!(tok, css::Token::Comma) {
-                        // Zig: bun.Output.panic(...) — see media_query.zig:54.
                         unreachable!(
                             "expected a comma after parsing a MediaQuery — bug in CSS parser"
                         );
@@ -1493,7 +1464,6 @@ impl MediaList {
 
 impl MediaQuery {
     pub fn parse(input: &mut Parser, options: &css::ParserOptions) -> Result<MediaQuery> {
-        // Zig: `Fn.tryParseFn` returning `(?Qualifier, ?MediaType)`.
         let (qualifier, explicit_media_type) = input
             .try_parse(|i| -> Result<(Option<Qualifier>, Option<MediaType>)> {
                 let qualifier = i.try_parse(Qualifier::parse).ok();
@@ -1650,8 +1620,6 @@ fn parse_paren_block<C: QueryCondition>(
     flags: QueryConditionFlags,
     options: &css::ParserOptions,
 ) -> Result<C> {
-    // Zig: `Closure { flags }.parseNestedBlockFn` — collapsed to a closure
-    // capturing `flags`/`options` by copy/reborrow.
     input.parse_nested_block(|i| {
         if let Ok(inner) =
             i.try_parse(|i2| parse_query_condition_with_options::<C>(i2, flags, options))
@@ -1665,8 +1633,6 @@ fn parse_paren_block<C: QueryCondition>(
 impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
     /// Parse a media/container feature inside `(` `)`.
     ///
-    /// Zig: `QueryFeature.parse` (media_query.zig:945).
-    ///
     /// Forwarder kept for callers that don't yet thread `ParserOptions`
     /// (e.g. `rules::container::ContainerCondition::parse_feature`).
     #[inline]
@@ -1694,7 +1660,6 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
         }
     }
 
-    /// Zig: `QueryFeature.parseNameFirst`.
     pub(crate) fn parse_name_first(
         input: &mut Parser,
         options: &css::ParserOptions,
@@ -1730,18 +1695,15 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
         }
     }
 
-    /// Zig: `QueryFeature.parseValueFirst`.
     pub(crate) fn parse_value_first(
         input: &mut Parser,
         options: &css::ParserOptions,
     ) -> Result<Self> {
         // We need to find the feature name first so we know the type.
         let start = input.state();
-        // PORT NOTE: Zig loops `MediaFeatureName.parse` then checks
-        // `isExhausted()` — but `expectIdent` does not advance on error, so
-        // the literal Zig body would spin on a non-ident token. The intent
-        // (matching lightningcss) is to *skip* tokens until the name is
-        // found; advance one token per failed attempt.
+        // Skip tokens (matching lightningcss) until the name is found;
+        // advance one token per failed attempt so a non-ident token cannot
+        // cause an infinite loop.
         let name: MediaFeatureName<FeatureId> = loop {
             if let Ok((name, legacy_op)) = input.try_parse(MediaFeatureName::<FeatureId>::parse) {
                 if legacy_op.is_some() {
@@ -1774,8 +1736,8 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
             let start_operator = operator.unwrap();
             let end_operator = end_operator_.unwrap();
             // Start and end operators must be matching.
-            // PORT NOTE: discriminants are bitflags (1/2/4/8/16) — see the
-            // comment on `MediaFeatureComparison`. Zig bitwise-ORs them.
+            // Discriminants are bitflags (1/2/4/8/16) — see the
+            // comment on `MediaFeatureComparison`.
             const GT: u8 = MediaFeatureComparison::GreaterThan as u8;
             const GTE: u8 = MediaFeatureComparison::GreaterThanEqual as u8;
             const LT: u8 = MediaFeatureComparison::LessThan as u8;
@@ -1819,7 +1781,7 @@ impl<FeatureId: FeatureIdTrait> QueryFeature<FeatureId> {
 
 /// Consumes an operation or a colon, or returns an error.
 ///
-/// Zig: `consumeOperationOrColon` (media_query.zig:1103). Returns `Ok(None)`
+/// Returns `Ok(None)`
 /// when a colon was consumed (and `allow_colon`); `Ok(Some(op))` for `<`/`>`/`=`.
 fn consume_operation_or_colon(
     input: &mut Parser,
@@ -1853,5 +1815,3 @@ fn consume_operation_or_colon(
         _ => Err(location.new_unexpected_token_error(css::Token::Delim(first_delim))),
     }
 }
-
-// ported from: src/css/media_query.zig
diff --git a/src/css/prefixes.rs b/src/css/prefixes.rs
index 2fce358a90f..9e9d39324d8 100644
--- a/src/css/prefixes.rs
+++ b/src/css/prefixes.rs
@@ -1,4 +1,4 @@
-// Ported from src/css/prefixes.zig (autogenerated by build-prefixes.js).
+// Autogenerated by build-prefixes.js.
 // DO NOT EDIT BY HAND — regenerate via `build-prefixes.js --rs` when the
 // caniuse tables change.
 
diff --git a/src/css/printer.rs b/src/css/printer.rs
index fdca930e064..42bc1815367 100644
--- a/src/css/printer.rs
+++ b/src/css/printer.rs
@@ -15,8 +15,7 @@ use css_values::ident::DashedIdent;
 
 pub use css::Error;
 
-// TODO(port): move to <area>_sys / clarify which Write trait. Zig used *std.Io.Writer
-// (byte-oriented: writeAll/writeByte/print/splatByteAll). Using a local dyn trait alias.
+// Byte-oriented writer (writeAll/writeByte/print equivalents).
 use bun_io::Write;
 
 /// Options that control how CSS is serialized to a string.
@@ -148,8 +147,9 @@ pub struct Printer<'a> {
     /// from JavaScript. Useful for polyfills, for example.
     pub pseudo_classes: Option<PseudoClasses<'a>>,
     pub indentation_buf: BumpVec<'a, u8>,
-    // TODO(port): lifetime — ctx is set to a stack-local during with_context() and restored
-    // after; `&'a StyleContext<'a>` will not borrow-check there. May need raw `*const StyleContext`.
+    // INVARIANT: `with_context()` points this at a stack-local `StyleContext` (via an
+    // unsafe variance cast — see the SAFETY note there) and always restores the parent
+    // before that frame returns; never stash `ctx` beyond the `with_context` call.
     pub ctx: Option<&'a css::StyleContext<'a>>,
     /// Number of parent-selector substitutions performed for `&` while
     /// serializing the current rule prelude with compiled nesting (targets
@@ -183,7 +183,6 @@ pub struct Printer<'a> {
     pub local_names: Option<&'a css::LocalsResultsMap>,
     /// NOTE This should be the same mimalloc heap arena arena
     pub arena: &'a Bump,
-    // TODO: finish the fields
 }
 
 #[cfg(debug_assertions)]
@@ -221,10 +220,8 @@ impl<'a> Printer<'a> {
         self.lookup_symbol(ident.as_ref().unwrap())
     }
 
-    // Zig checked vtable identity against std.Io.Writer.Allocating and recovered the
-    // backing buffer length via `container_of`; in Rust the trait exposes `written_len()`
-    // directly (Vec<u8> / MutableString / counting sinks override it, others panic — same
-    // contract as Zig's `@panic("css: got bad writer type")` fallthrough).
+    // The `Write` trait exposes `written_len()` directly
+    // (Vec<u8> / MutableString / counting sinks override it, others panic).
     #[inline]
     fn get_written_amt(writer: &dyn Write) -> usize {
         writer.written_len()
@@ -300,7 +297,7 @@ impl<'a> Printer<'a> {
         Err(PrintErr::CSSPrintError)
     }
 
-    // PORT NOTE: deinit() dropped — scratchbuf/indentation_buf/dependencies are arena-backed
+    // deinit() dropped — scratchbuf/indentation_buf/dependencies are arena-backed
     // BumpVec<'a, _>; freed in bulk by `arena.reset()`. No explicit Drop impl needed.
 
     /// If `import_records` is null, then the printer will error when it encounters code that relies on import records (urls())
@@ -341,7 +338,6 @@ impl<'a> Printer<'a> {
                 column: 1,
             },
             symbols,
-            // defaults for fields not set by Zig's `.{}` initializer
             indent_amt: 0,
             line: 0,
             col: 0,
@@ -357,9 +353,8 @@ impl<'a> Printer<'a> {
     }
 
     /// Construct a `Printer` that writes into an in-memory `Vec<u8>` buffer
-    /// using default `PrinterOptions`. Mirrors the Zig pattern of pairing
-    /// `std.Io.Writer.Allocating` with `Printer.new(..., PrinterOptions.default(), ...)`
-    /// for sub-serialization (e.g. `PseudoClass::toCss`, `Selector` debug fmt).
+    /// using default `PrinterOptions`. Used for sub-serialization
+    /// (e.g. `PseudoClass::toCss`, `Selector` debug fmt).
     pub fn new_buffered(
         arena: &'a Bump,
         dest: &'a mut Vec<u8>,
@@ -391,10 +386,10 @@ impl<'a> Printer<'a> {
             let import_record = &info.import_records[import_record_idx as usize];
             let [a, b] =
                 bun_core::cheap_prefix_normalizer(self.public_path, import_record.path.text);
-            // PORT NOTE: reshaped for borrowck — copied (a, b) out before re-borrowing &mut self
+            // Reshaped for borrowck — copied (a, b) out before re-borrowing &mut self
             let a = a.to_vec();
             let b = b.to_vec();
-            // PERF(port): two small heap copies above; Zig borrowed directly. Profile if it shows up on a hot path.
+            // PERF: two small heap copies above; profile if it shows up on a hot path.
             self.write_str(&a)?;
             self.write_str(&b)?;
             return Ok(());
@@ -518,13 +513,22 @@ impl<'a> Printer<'a> {
         Ok(())
     }
 
-    /// Alias of `write_str` for callers that want to be explicit about
-    /// possibly-newline-containing byte content (Zig: `writeBytes`).
+    /// Like `write_str`, but newline-containing byte content is permitted:
+    /// `line`/`col` are tracked across newlines (matching `write_char` applied
+    /// byte-by-byte), whereas `write_str` debug-asserts that no newlines are
+    /// present. Used for raw token round-trip content (whitespace tokens,
+    /// comments, unparsed contents).
     #[inline]
     pub fn write_bytes(&mut self, s: &[u8]) -> PrintResult<()> {
-        // TODO(port): Zig writeBytes did not assert no-newline; tracked
-        // line/col separately. For now route through write_str.
-        self.col += u32::try_from(s.len()).expect("int cast");
+        // Unlike `write_str`, newlines are allowed here; track line/col across them
+        // (matching `write_char` applied byte-by-byte) so source maps stay correct.
+        if let Some(last_newline) = s.iter().rposition(|&b| b == b'\n') {
+            let new_lines = s.iter().filter(|&&b| b == b'\n').count();
+            self.line += u32::try_from(new_lines).expect("int cast");
+            self.col = u32::try_from(s.len() - last_newline - 1).expect("int cast");
+        } else {
+            self.col += u32::try_from(s.len()).expect("int cast");
+        }
         if self.dest.write_all(s).is_err() {
             return Err(self.add_fmt_error());
         }
@@ -569,7 +573,7 @@ impl<'a> Printer<'a> {
                 let Some(symbol) = self.symbols.get_const(ref_) else {
                     return Err(self.add_fmt_error());
                 };
-                // PORT NOTE: copy out the arena slice before re-borrowing &mut self.
+                // Copy out the arena slice before re-borrowing &mut self.
                 let name = symbol.original_name.slice();
                 return self.serialize_identifier(name);
             }
@@ -588,10 +592,8 @@ impl<'a> Printer<'a> {
     pub fn write_ident(&mut self, ident: &'a [u8], handle_css_module: bool) -> PrintResult<()> {
         if handle_css_module {
             if self.css_module.is_some() {
-                // PORT NOTE: borrowck reshape — Zig captured `&mut self` inside the closure
-                // while `css_module` (a field of self) was simultaneously borrowed. We instead
-                // copy the `'a`-lifetime references out of `css_module` up front so the
-                // closure can hold the sole `&mut self`.
+                // Copy the `'a`-lifetime references out of `css_module` up front so
+                // the closure can hold the sole `&mut self`.
                 let source_index = self.loc.source_index as usize;
                 let arena = self.arena;
                 let (config, hash, source): (&'a css::css_modules::Config, &'a [u8], &'a [u8]) = {
@@ -662,7 +664,7 @@ impl<'a> Printer<'a> {
             None => false,
         };
         if dashed_idents {
-            // PORT NOTE: same borrowck reshape as `write_ident`.
+            // Same borrowck reshape as `write_ident`.
             let source_index = self.loc.source_index as usize;
             let arena = self.arena;
             let (config, hash, source): (&'a css::css_modules::Config, &'a [u8], &'a [u8]) = {
@@ -836,9 +838,8 @@ impl<'a> Printer<'a> {
 
         let ctx = css::StyleContext { selectors, parent };
 
-        // TODO(port): lifetime — `&ctx` is stack-local but field type is `&'a StyleContext<'a>`.
-        // Zig relied on restoring `parent` before return. Consider changing the field to raw
-        // `*const StyleContext` or restructuring StyleContext as an explicit stack.
+        // `&ctx` is stack-local but the field type is `&'a StyleContext<'a>`;
+        // soundness relies on restoring `parent` before this frame returns.
         // SAFETY: ctx outlives the call to func; self.ctx is restored to `parent` before return.
         // Inner-lifetime variance cast via raw pointer (`StyleContext<'x>` and
         // `StyleContext<'a>` share layout; only the borrow-checker tag differs).
@@ -892,5 +893,3 @@ impl<'a> Printer<'a> {
 
 // bun.ast.Symbol.Map — lives in bun_logger.
 type SymbolMap = bun_ast::symbol::Map;
-
-// ported from: src/css/printer.zig
diff --git a/src/css/properties/align.rs b/src/css/properties/align.rs
index f812330a582..ec410269047 100644
--- a/src/css/properties/align.rs
+++ b/src/css/properties/align.rs
@@ -17,10 +17,7 @@ use crate::css_properties::flex::{
 // ──────────────────────────────────────────────────────────────────────────────
 
 /// A value for the [align-content](https://www.w3.org/TR/css-align-3/#propdef-align-content) property.
-#[derive(Clone, PartialEq, Eq)]
-// Zig: `css.DeriveParse(@This()).parse` / `css.DeriveToCss(@This()).toCss` —
-// comptime-reflection generators ported as proc-macro derives.
-#[derive(css::Parse, css::ToCss)]
+#[derive(Clone, PartialEq, Eq, css::Parse, css::ToCss)]
 pub enum AlignContent {
     /// Default alignment.
     Normal,
@@ -32,10 +29,9 @@ pub enum AlignContent {
     ContentPosition(AlignContentContentPosition),
 }
 
-// Zig: anonymous payload struct carrying `pub fn __generateToCss() void {}` —
-// the marker telling `DeriveToCss` to auto-generate the field-sequence printer.
-// In Rust the equivalent is `#[derive(css::ToCss)]` on the lifted named-field
-// struct (see `css_derive::expand_derive_to_css` struct branch); the enum arm's
+// `#[derive(css::ToCss)]` + `#[css(generate_to_css)]` on the lifted
+// named-field struct auto-generates the field-sequence printer (see
+// `css_derive::expand_derive_to_css` struct branch); the enum arm's
 // `__inner.to_css(dest)` then resolves to this generated inherent.
 #[derive(Clone, PartialEq, Eq, css::ToCss)]
 #[css(generate_to_css)]
@@ -210,9 +206,7 @@ impl JustifyContent {
 // ──────────────────────────────────────────────────────────────────────────────
 
 /// A value for the [align-self](https://www.w3.org/TR/css-align-3/#align-self-property) property.
-#[derive(Clone, PartialEq, Eq)]
-// Zig: `css.DeriveParse` / `css.DeriveToCss`
-#[derive(css::Parse, css::ToCss)]
+#[derive(Clone, PartialEq, Eq, css::Parse, css::ToCss)]
 pub enum AlignSelf {
     /// Automatic alignment.
     Auto,
@@ -226,7 +220,7 @@ pub enum AlignSelf {
     SelfPosition(AlignSelfSelfPosition),
 }
 
-// Zig: `__generateToCss` marker — see `AlignContentContentPosition` note.
+// See `AlignContentContentPosition` note.
 #[derive(Clone, PartialEq, Eq, css::ToCss)]
 #[css(generate_to_css)]
 pub struct AlignSelfSelfPosition {
@@ -380,9 +374,7 @@ impl JustifySelf {
 // ──────────────────────────────────────────────────────────────────────────────
 
 /// A value for the [align-items](https://www.w3.org/TR/css-align-3/#align-items-property) property.
-#[derive(Clone, PartialEq, Eq)]
-// Zig: `css.DeriveParse` / `css.DeriveToCss`
-#[derive(css::Parse, css::ToCss)]
+#[derive(Clone, PartialEq, Eq, css::Parse, css::ToCss)]
 pub enum AlignItems {
     /// Default alignment.
     Normal,
@@ -394,7 +386,7 @@ pub enum AlignItems {
     SelfPosition(AlignItemsSelfPosition),
 }
 
-// Zig: `__generateToCss` marker — see `AlignContentContentPosition` note.
+// See `AlignContentContentPosition` note.
 #[derive(Clone, PartialEq, Eq, css::ToCss)]
 #[css(generate_to_css)]
 pub struct AlignItemsSelfPosition {
@@ -604,9 +596,7 @@ impl LegacyJustify {
 
 /// A [gap](https://www.w3.org/TR/css-align-3/#column-row-gap) value, as used in the
 /// `column-gap` and `row-gap` properties.
-#[derive(Clone, PartialEq)]
-// Zig: `css.DeriveParse` / `css.DeriveToCss`
-#[derive(css::Parse, css::ToCss)]
+#[derive(Clone, PartialEq, css::Parse, css::ToCss)]
 pub enum GapValue {
     /// Equal to `1em` for multi-column containers, and zero otherwise.
     Normal,
@@ -624,9 +614,6 @@ pub struct Gap {
 }
 
 impl Gap {
-    // TODO(port): PropertyFieldMap was a comptime struct mapping fields → CSS property names
-    // (.row = "row-gap", .column = "column-gap"); could encode as derive attrs.
-
     pub(crate) fn parse(input: &mut Parser) -> CssResult<Self> {
         let row = GapValue::parse(input)?;
         let column = input
@@ -659,9 +646,6 @@ pub struct PlaceItems {
 }
 
 impl PlaceItems {
-    // TODO(port): PropertyFieldMap (.align = "align-items", .justify = "justify-items")
-    // TODO(port): VendorPrefixMap (.align = true)
-
     pub(crate) fn parse(input: &mut Parser) -> CssResult<Self> {
         let align = AlignItems::parse(input)?;
         let justify = match input.try_parse(JustifyItems::parse) {
@@ -724,9 +708,6 @@ pub struct PlaceSelf {
 }
 
 impl PlaceSelf {
-    // TODO(port): PropertyFieldMap (.align = "align-self", .justify = "justify-self")
-    // TODO(port): VendorPrefixMap (.align = true)
-
     pub(crate) fn parse(input: &mut Parser) -> CssResult<Self> {
         let align = AlignSelf::parse(input)?;
         let justify = match input.try_parse(JustifySelf::parse) {
@@ -817,9 +798,6 @@ pub struct PlaceContent {
 }
 
 impl PlaceContent {
-    // TODO(port): PropertyFieldMap (.align = PropertyIdTag::AlignContent, .justify = PropertyIdTag::JustifyContent)
-    // TODO(port): VendorPrefixMap (.align = true, .justify = true)
-
     pub(crate) fn parse(input: &mut Parser) -> CssResult<Self> {
         let align = AlignContent::parse(input)?;
         let justify = match JustifyContent::parse(input) {
@@ -976,12 +954,10 @@ pub struct AlignHandler {
     pub has_any: bool,
 }
 
-// ─── helper macros (Zig used `comptime prop: []const u8` + `@field` / `@unionInit`) ───
+// ─── helper macros ───
 //
-// TODO(port): the Zig source threads field names as comptime strings into helper fns
-// and uses @field/@unionInit for reflection. Rust cannot pass field names as values, so
-// these are macro_rules! that expand at each call site; a small proc-macro could dedupe
-// if maintenance burden is high.
+// Field names cannot be passed as values, so these are macro_rules! that
+// expand at each call site.
 
 macro_rules! handle_property_maybe_flush {
     ($this:expr, $dest:expr, $context:expr, $field:ident, $val:expr, $vp:expr) => {{
@@ -1057,9 +1033,6 @@ macro_rules! flush_legacy_property {
                         prefixes_2009.insert(VendorPrefix::MOZ);
                     }
                     if !prefixes_2009.is_empty() {
-                        // TODO(port): Zig branched on `T == BoxOrdinalGroup` to bypass
-                        // from_standard. Never true at any callsite in this file; preserved
-                        // as a note in case the macro is reused elsewhere.
                         let s = <$ty2009>::from_standard(val);
                         if let Some(a) = s {
                             $dest.push(Property::$variant2009((a, prefixes_2009)));
@@ -1140,9 +1113,6 @@ macro_rules! flush_shorthand_helper {
                         align.clone(),
                         justify_actual.clone(),
                     )));
-                    // TODO(port): Zig built `prop.ty{ .align = ..., .justify = ... }` directly.
-                    // Using a `from_align_justify` ctor here; could inline the struct init.
-
                     *$align_val = None;
                     *$justify_val = None;
                 }
@@ -1160,7 +1130,7 @@ macro_rules! flush_shorthand_helper {
     ) => {{
         if let Some((align, align_prefix)) = &mut *$align_val {
             if let Some(justify) = &mut *$justify_val {
-                // Zig: intersection = align_prefix & align_prefix (justify has no prefix)
+                // justify has no prefix, so the intersection is just align_prefix
                 let intersection = *align_prefix;
                 if intersection.contains(VendorPrefix::NONE) {
                     *align_prefix = $this.flush_prefixes_helper($context, $align_feature);
@@ -1174,8 +1144,6 @@ macro_rules! flush_shorthand_helper {
                         align.clone(),
                         justify.clone(),
                     )));
-                    // TODO(port): see note above re: from_align_justify ctor.
-
                     *$align_val = None;
                     *$justify_val = None;
                 }
@@ -1185,7 +1153,6 @@ macro_rules! flush_shorthand_helper {
 }
 
 // Tiny ctors used by flush_shorthand_helper! above.
-// TODO(port): inline as struct literals once Property variant shapes are settled.
 impl PlaceContent {
     fn from_align_justify(align: AlignContent, justify: JustifyContent) -> Self {
         Self { align, justify }
@@ -1332,8 +1299,8 @@ impl AlignHandler {
             Property::Unparsed(val) => {
                 if is_align_property(&val.property_id) {
                     self.flush(dest, context);
-                    // PORT NOTE: Zig pushed `property.deepClone(context.arena)`. `Property`
-                    // has no blanket `Clone` yet; reconstruct from the matched payload (same as flex.rs).
+                    // `Property` has no blanket `Clone` yet; reconstruct from
+                    // the matched payload (same as flex.rs).
                     let bump = dest.bump();
                     dest.push(Property::Unparsed(val.deep_clone(bump)));
                 } else {
@@ -1471,7 +1438,6 @@ impl AlignHandler {
     }
 
     /// Gets prefixes for standard properties.
-    // PERF(port): was comptime monomorphization (`comptime feature: Feature`) — profile if hot.
     fn flush_prefixes_helper(
         &self,
         context: &PropertyHandlerContext<'_>,
@@ -1509,5 +1475,3 @@ fn is_align_property(property_id: &PropertyId) -> bool {
             | PropertyId::Gap
     )
 }
-
-// ported from: src/css/properties/align.zig
diff --git a/src/css/properties/animation.rs b/src/css/properties/animation.rs
index 6df914f0244..e3c5f3d627b 100644
--- a/src/css/properties/animation.rs
+++ b/src/css/properties/animation.rs
@@ -38,13 +38,9 @@ pub struct Animation {
 }
 
 impl Animation {
-    // TODO(port): PropertyFieldMap / VendorPrefixMap were comptime anonymous-struct
-    // metadata consumed by reflection in the shorthand codegen. Replace these with
-    // a derive macro (e.g. #[derive(Shorthand)]) that emits the field→PropertyIdTag
-    // and field→has-vendor-prefix tables.
-    // PORT NOTE: PropertyFieldMap dropped — `PropertyIdTag::Animation*` variants
-    // are not yet generated (animation longhands are unparsed-only for now), and
-    // the table was unread comptime metadata. Re-add when the variants land.
+    // PropertyFieldMap omitted: `PropertyIdTag::Animation*` variants are not yet
+    // generated (animation longhands are unparsed-only for now). Re-add the
+    // field→PropertyIdTag table once the variants land.
 
     pub const VENDOR_PREFIX_MAP: &'static [(&'static str, bool)] = &[
         ("name", true),
@@ -140,9 +136,8 @@ impl Animation {
     }
 
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PORT NOTE: reshaped `inline .ident, .string => |name|` — Zig's inline
-        // switch monomorphized over two payload types; Rust extracts the inner
-        // string slice up front instead.
+        // Extract the inner string slice up front so both the ident and
+        // string variants share one code path.
         let name_str: Option<&[u8]> = match &self.name {
             AnimationName::None => None,
             AnimationName::Ident(ident) => Some(ident.v()),
@@ -225,7 +220,7 @@ impl Animation {
 }
 
 /// A value for the [animation-name](https://drafts.csswg.org/css-animations/#animation-name) property.
-// PORT NOTE: no `#[derive(PartialEq, Eq, Hash)]` — `CustomIdent`/`CSSString`
+// no `#[derive(PartialEq, Eq, Hash)]` — `CustomIdent`/`CSSString`
 // carry raw `*const [u8]` arena pointers; derived eq/hash would compare by
 // pointer. Hand-written `eql`/`hash` below compare by content.
 #[derive(Clone, Copy)]
@@ -239,9 +234,9 @@ pub enum AnimationName {
 }
 
 impl AnimationName {
-    // PORT NOTE: hand-written (not `#[derive]`) because `CSSString` is a raw
+    // hand-written (not `#[derive]`) because `CSSString` is a raw
     // `*const [u8]` arena pointer — generics blanket impls cover `&[u8]` but
-    // not raw slices. Mirrors Zig `css.implementEql/Hash/DeepClone`.
+    // not raw slices.
     pub fn eql(&self, other: &Self) -> bool {
         match (self, other) {
             (AnimationName::None, AnimationName::None) => true,
@@ -283,15 +278,14 @@ impl AnimationName {
     }
 
     pub fn parse(input: &mut Parser) -> css::Result<Self> {
-        // PORT NOTE: ported from src/css/properties/animation.zig — `none` keyword,
-        // then `<string>`, else `<custom-ident>`.
+        // `none` keyword, then `<string>`, else `<custom-ident>`.
         if input
             .try_parse(|i| i.expect_ident_matching(b"none"))
             .is_ok()
         {
             return Ok(AnimationName::None);
         }
-        // PORT NOTE: `expect_string` returns a slice borrowing `&mut self`, which
+        // `expect_string` returns a slice borrowing `&mut self`, which
         // `try_parse`'s `R` type param can't carry. Erase the lifetime through a
         // raw pointer inside the closure; the slice lives in the input arena and
         // outlives this parse (CSSString = &'static [u8]).
@@ -315,7 +309,7 @@ impl AnimationName {
                 // SAFETY: arena-owned slice valid for 'bump.
                 let name: &[u8] = unsafe { crate::arena_str(s.v) };
                 if css_module_animation_enabled {
-                    // PORT NOTE: reshaped for borrowck — capture arena/source_index
+                    // reshaped for borrowck — capture arena/source_index
                     // before borrowing dest.css_module mutably.
                     let arena = dest.arena;
                     let source_index = dest.loc.source_index;
@@ -329,7 +323,7 @@ impl AnimationName {
                 // SAFETY: arena-owned slice valid for 'bump.
                 let name: &[u8] = unsafe { crate::arena_str(*s) };
                 if css_module_animation_enabled {
-                    // PORT NOTE: reshaped for borrowck
+                    // reshaped for borrowck
                     let arena = dest.arena;
                     let source_index = dest.loc.source_index;
                     if let Some(css_module) = &mut dest.css_module {
@@ -351,8 +345,6 @@ impl AnimationName {
 }
 
 /// A value for the [animation-iteration-count](https://drafts.csswg.org/css-animations/#animation-iteration-count) property.
-// TODO(port): css.DeriveParse / css.DeriveToCss were comptime mixins generating
-// parse()/to_css() from variant shape. Implement as #[derive(Parse, ToCss)].
 #[derive(PartialEq)]
 pub enum AnimationIterationCount {
     /// The animation will repeat the specified number of times.
@@ -479,15 +471,10 @@ pub enum AnimationTimeline {
 }
 
 impl AnimationTimeline {
-    // Port of `css.DeriveParse(@This()).parse` — void variants (`auto`, `none`)
-    // declared first → tried first via ident match; payloads follow in
-    // declaration order (`DashedIdent`, `ScrollTimeline`, `ViewTimeline`).
-    // Upstream `ScrollTimeline` / `ViewTimeline` carry no `parse`, so the Zig
-    // `DeriveParse` instantiation is dead code (`generic.parseFor` would
-    // `@compileError` if compiled — `Animation` is unreferenced in
-    // properties_generated.zig). We stop at `DashedIdent` here; if scroll()/
-    // view() ever become live they need real function-syntax parsing, not the
-    // derived field-sequence fallback.
+    // Void variants (`auto`, `none`) are tried first via ident match;
+    // payloads follow in declaration order. We stop at `DashedIdent`; if
+    // scroll()/view() ever become live they need real function-syntax
+    // parsing, not a derived field-sequence fallback.
     pub fn parse(input: &mut Parser) -> css::Result<Self> {
         let state = input.state();
         if let Ok(ident) = input.expect_ident() {
@@ -504,16 +491,12 @@ impl AnimationTimeline {
         DashedIdent::parse(input).map(AnimationTimeline::DashedIdent)
     }
 
-    // Port of `css.DeriveToCss(@This()).toCss`.
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
         match self {
             AnimationTimeline::Auto => dest.write_str(b"auto"),
             AnimationTimeline::None => dest.write_str(b"none"),
             AnimationTimeline::DashedIdent(d) => d.to_css(dest),
-            // Upstream Zig `ScrollTimeline` / `ViewTimeline` have no `toCss`;
-            // `DeriveToCss` would delegate to `generic.toCss` → `T.toCss` and
-            // `@compileError` if this arm were ever instantiated. Mirror that:
-            // these variants are currently unconstructible via `parse()`, and
+            // These variants are currently unconstructible via `parse()`, and
             // emitting bare space-separated fields here would be wrong CSS
             // (spec syntax is `scroll(...)` / `view(...)`).
             AnimationTimeline::Scroll(_) | AnimationTimeline::View(_) => {
@@ -531,7 +514,7 @@ impl AnimationTimeline {
     }
 }
 
-// PORT NOTE: hand-written `PartialEq` — `DashedIdent` carries a raw
+// hand-written `PartialEq` — `DashedIdent` carries a raw
 // `*const [u8]` arena pointer; derive would compare by pointer, not content.
 impl PartialEq for AnimationTimeline {
     fn eq(&self, other: &Self) -> bool {
@@ -659,5 +642,3 @@ pub enum TimelineRangeName {
     /// Represents the range during which the principal box crosses the start border edge.
     ExitCrossing,
 }
-
-// ported from: src/css/properties/animation.zig
diff --git a/src/css/properties/background.rs b/src/css/properties/background.rs
index de6369e50a1..c96ff47abdd 100644
--- a/src/css/properties/background.rs
+++ b/src/css/properties/background.rs
@@ -14,7 +14,7 @@ use bun_alloc::Arena as Bump;
 use bun_alloc::ArenaVecExt as _;
 
 /// A value for the [background](https://www.w3.org/TR/css-backgrounds-3/#background) shorthand property.
-// PORT NOTE: Clone derive gated on `Image` gaining `Clone` upstream.
+// Clone derive gated on `Image` gaining `Clone` upstream.
 #[cfg_attr(any(), derive(Clone))]
 pub struct Background {
     /// The background image.
@@ -36,8 +36,6 @@ pub struct Background {
 }
 
 impl Background {
-    // Zig `deinit` was a no-op (all allocations in CSS parser are in arena) — Drop handles it.
-
     pub(crate) fn parse(input: &mut Parser) -> css::Result<Self> {
         let mut color: Option<CssColor> = None;
         let mut position: Option<BackgroundPosition> = None;
@@ -244,7 +242,6 @@ impl Background {
 
     #[inline]
     pub(crate) fn deep_clone(&self, arena: &Bump) -> Self {
-        // PORT NOTE: `css.implementDeepClone` reflection — expanded field-wise.
         // `Image` is the only non-`Clone` field; it provides its own `deep_clone`.
         Self {
             image: self.image.deep_clone(arena),
@@ -598,18 +595,16 @@ pub struct BackgroundHandler {
     pub attachments: Option<SmallList<BackgroundAttachment, 1>>,
     pub origins: Option<SmallList<BackgroundOrigin, 1>>,
     pub clips: Option<(SmallList<BackgroundClip, 1>, VendorPrefix)>,
-    // TODO(perf): arena Vec — Zig is `ArrayListUnmanaged(Property)` fed `context.arena`
-    // (CSS arena). Should be `bun_alloc::ArenaVec<'bump, Property>`; threading `'bump`
-    // through BackgroundHandler would avoid the heap alloc.
+    // TODO(perf): should be `bun_alloc::ArenaVec<'bump, Property>`; threading
+    // `'bump` through BackgroundHandler would avoid the heap alloc.
     pub decls: Vec<Property>,
     pub flushed_properties: BackgroundProperty,
     pub has_any: bool,
 }
 
-// PORT NOTE: the Zig uses comptime field-name strings + @field for `flushHelper` /
-// `initSmallListHelper` / `push`. Rust cannot index struct fields by string at runtime;
-// these helpers are expanded into small per-field macros below. A derive macro
-// could replace them.
+// Struct fields cannot be indexed by string at runtime; the `flushHelper` /
+// `initSmallListHelper` / `push` helpers are expanded into small per-field
+// macros below. A derive macro could replace them.
 
 macro_rules! init_small_list_helper {
     ($this:expr, $field:ident, $length:expr) => {{
@@ -699,8 +694,8 @@ impl BackgroundHandler {
             Property::BackgroundClip(x) => {
                 let val: &SmallList<BackgroundClip, 1> = &x.0;
                 let vendor_prefix: VendorPrefix = x.1;
-                // PORT NOTE: reshaped for borrowck — Zig held &mut into self.clips
-                // across self.flush(). Compute the predicate first, then dispatch.
+                // Compute the predicate first, then dispatch (avoids holding
+                // &mut self.clips across self.flush()).
                 let needs_flush = if let Some((clips, vp)) = &self.clips {
                     vendor_prefix != *vp && !SmallList::eql(val, clips)
                 } else {
@@ -737,7 +732,7 @@ impl BackgroundHandler {
                     clips.append_assume_capacity(b.clip);
                 }
                 let mut clips_vp = VendorPrefix::NONE;
-                // PORT NOTE: reshaped for borrowck — drop borrow before calling flush().
+                // Drop the `self.clips` borrow before calling flush().
                 let needs_flush = if let Some((existing_clips, existing_vp)) = &self.clips {
                     clips_vp != *existing_vp && !SmallList::eql(&clips, existing_clips)
                 } else {
@@ -852,7 +847,6 @@ impl BackgroundHandler {
         let mut maybe_origins: Option<SmallList<BackgroundOrigin, 1>> = self.origins.take();
         let mut maybe_clips: Option<(SmallList<BackgroundClip, 1>, VendorPrefix)> =
             self.clips.take();
-        // Zig had `defer { ... deinit }` here — Drop handles cleanup at scope exit.
 
         if let (
             Some(color),
@@ -905,8 +899,7 @@ impl BackgroundHandler {
                 };
 
                 let mut backgrounds: SmallList<Background, 1> = SmallList::init_capacity(len);
-                // PORT NOTE: reshaped for borrowck — Zig zipped 8 slices by value; here we
-                // index by `i` and clone each element to avoid 8 simultaneous borrows.
+                // Index by `i` and clone each element to avoid 8 simultaneous borrows.
                 for i in 0..(len as usize) {
                     backgrounds.append_assume_capacity(Background {
                         color: if i == (len as usize) - 1 {
@@ -930,17 +923,17 @@ impl BackgroundHandler {
                         },
                     });
                 }
-                // Zig: defer { clearRetainingCapacity on each list } — values were moved
-                // by-value into `backgrounds` above, so clearing prevents double-free.
-                // In Rust we cloned, so the originals will Drop normally; no explicit clear
-                // needed for correctness. Leaving as-is.
-                // PERF(port): was arena bulk-free / move-then-clear — profile if hot.
+                // The elements were cloned into `backgrounds` above, so the
+                // originals Drop normally; no explicit clear needed.
+                // PERF: profile the clones if hot.
 
                 if self.flushed_properties.is_empty() {
                     let mut fallbacks =
                         crate::small_list::get_fallbacks(&mut backgrounds, arena, &context.targets);
-                    // PORT NOTE: Vec has no owning iterator; pop in reverse then
-                    // re-reverse via a temp Vec to preserve order.
+                    // Pop in reverse then re-reverse via a temp Vec to
+                    // preserve order while consuming the list. `fallbacks` is
+                    // a plain Vec, so a direct `for fb in fallbacks` would
+                    // also work.
                     let mut tmp: Vec<SmallList<Background, 1>> =
                         Vec::with_capacity(fallbacks.len());
                     while let Some(fb) = fallbacks.pop() {
@@ -1001,8 +994,9 @@ impl BackgroundHandler {
             if !self.flushed_properties.contains(BackgroundProperty::IMAGE) {
                 let mut fallbacks =
                     crate::small_list::get_fallbacks(&mut images, arena, &context.targets);
-                // PORT NOTE: Vec has no owning iterator; pop in reverse then
-                // re-reverse via a temp Vec to preserve order.
+                // Pop in reverse then re-reverse via a temp Vec to preserve
+                // order while consuming the list. `fallbacks` is a plain Vec,
+                // so a direct `for fb in fallbacks` would also work.
                 let mut tmp: Vec<SmallList<Image, 1>> = Vec::with_capacity(fallbacks.len());
                 while let Some(fb) = fallbacks.pop() {
                     tmp.push(fb);
@@ -1042,7 +1036,6 @@ impl BackgroundHandler {
                     y: y.clone(),
                 });
             }
-            // Zig: clearRetainingCapacity on xs/ys after moving values out — Drop handles it.
             push_property!(
                 self,
                 dest,
@@ -1130,7 +1123,7 @@ impl BackgroundHandler {
     }
 
     fn reset(&mut self) {
-        // Zig deinit'd each field then set to null — Drop on assignment handles both.
+        // Drop on assignment frees each field's old value.
         self.color = None;
         self.images = None;
         self.x_positions = None;
@@ -1156,8 +1149,7 @@ impl BackgroundHandler {
 
         let arena = dest.bump();
         for decl in self.decls.drain(..) {
-            // PORT NOTE: Zig was `appendSlice` (bitwise copy of arena-backed
-            // values). `Property` is not `Clone` here, so move out via drain.
+            // `Property` is not `Clone` here, so move out via drain.
             let _ = arena;
             dest.push(decl);
         }
@@ -1167,8 +1159,8 @@ impl BackgroundHandler {
     }
 }
 
-// `Background` participates in `SmallList::get_fallbacks` via the duck-typed
-// `ImageFallback` protocol (Zig dispatched on `@hasDecl(T, "getImage")`).
+// `Background` participates in `SmallList::get_fallbacks` via the
+// `ImageFallback` trait.
 impl crate::small_list::ImageFallback for Background {
     #[inline]
     fn get_image(&self) -> &Image {
@@ -1204,5 +1196,3 @@ fn is_background_property(property_id: PropertyId) -> bool {
             | PropertyId::Background
     )
 }
-
-// ported from: src/css/properties/background.zig
diff --git a/src/css/properties/border.rs b/src/css/properties/border.rs
index f6aa3be4fa1..91efc57db39 100644
--- a/src/css/properties/border.rs
+++ b/src/css/properties/border.rs
@@ -148,7 +148,6 @@ where
 {
     fn get_fallbacks(&mut self, arena: &Bump, targets: &Targets) -> SmallList<Self, 2> {
         let fallbacks = self.color.get_fallbacks(arena, targets);
-        // PERF(port): was arena bulk-free (fallbacks.deinit) — profile if it shows up on a hot path
         let mut out: SmallList<Self, 2> = SmallList::init_capacity(fallbacks.len());
         for color in fallbacks.slice() {
             out.append_assume_capacity(Self {
@@ -166,11 +165,9 @@ where
     }
 
     /// Deep-clone into a `GenericBorder` with a different const-generic
-    /// discriminant `Q`. The fields are identical regardless of `P`; this is
-    /// the Rust equivalent of Zig coercing one anonymous struct literal into
-    /// multiple `Border*` aliases. Needed when one logical value must be
-    /// emitted as two distinct physical `Property` variants (e.g.
-    /// inline-start → BorderLeft + BorderRight).
+    /// discriminant `Q`. The fields are identical regardless of `P`. Needed
+    /// when one logical value must be emitted as two distinct physical
+    /// `Property` variants (e.g. inline-start → BorderLeft + BorderRight).
     pub(crate) fn clone_as<const Q: u8>(&self, arena: &Bump) -> GenericBorder<S, Q> {
         let cloned = self.deep_clone(arena);
         GenericBorder {
@@ -245,17 +242,16 @@ impl BorderSideWidth {
     }
 
     pub fn deep_clone(&self, _arena: &Bump) -> Self {
-        // PORT NOTE: css.implementDeepClone — Length is value-type; Clone suffices.
+        // css.implementDeepClone — Length is value-type; Clone suffices.
         self.clone()
     }
 }
 crate::css_eql_partialeq!(BorderSideWidth);
 
 // ──────────────────────────────────────────────────────────────────────────
-// ImplFallbacks (Zig: `pub fn ImplFallbacks(comptime T: type) type`)
+// impl_fallbacks
 // ──────────────────────────────────────────────────────────────────────────
-// TODO(port): Zig used `inline for (std.meta.fields(T))` reflection. We expand
-// the field list at macro invocation. All fields are `CssColor`.
+// The field list is expanded at macro invocation. All fields are `CssColor`.
 // Hoisted here because `macro_rules!` is order-sensitive.
 macro_rules! impl_fallbacks {
     ($T:ty; $($field:ident),+) => {
@@ -357,15 +353,13 @@ macro_rules! define_size_shorthand {
         }
 
         impl $name {
-            // TODO(port): bring this back
-            // (old using name space) css::DefineShorthand(@This(), PropertyIdTag::$shorthand_id);
-
+            // The table is kept as data for a future shorthand derive to consume.
             pub const PROPERTY_FIELD_MAP: &[(&str, PropertyIdTag)] = &[
                 ("start", PropertyIdTag::$start_id),
                 ("end", PropertyIdTag::$end_id),
             ];
         }
-        // Zig `css.DefineSizeShorthand(@This(), V)` — parse/to_css via `Size2D<V>`.
+        // parse/to_css via `Size2D<V>`.
         // Shared impl macro lives in `properties/mod.rs`.
         impl_size_shorthand!($name, $inner, start, end);
     };
@@ -442,14 +436,12 @@ impl BorderShorthand {
     where
         S: for<'a> css::DeepClone<'a> + Into<LineStyle>,
     {
-        // TODO(port): Zig accepted `anytype`; all callers pass GenericBorder<LineStyle, _>.
         self.width = Some(border.width.deep_clone(arena));
         self.style = Some(border.style.deep_clone(arena).into());
         self.color = Some(border.color.deep_clone(arena));
     }
 
     fn reset(&mut self, _arena: &Bump) {
-        // PERF(port): was arena bulk-free via bun.clear — profile if it shows up on a hot path
         self.width = None;
         self.style = None;
         self.color = None;
@@ -460,8 +452,7 @@ impl BorderShorthand {
     }
 
     /// Generic over the `P` const param so the same `BorderShorthand` data
-    /// can populate any of `BorderTop`/`BorderLeft`/.../`Border` (Zig used a
-    /// single anonymous struct literal that coerced to each alias).
+    /// can populate any of `BorderTop`/`BorderLeft`/.../`Border`.
     fn to_border<const P: u8>(&self, arena: &Bump) -> GenericBorder<LineStyle, P> {
         GenericBorder {
             width: css::generic::deep_clone(&self.width, arena).unwrap(),
@@ -472,7 +463,7 @@ impl BorderShorthand {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// BorderProperty bitflags (Zig: `packed struct(u32)` of all-bool fields)
+// BorderProperty bitflags
 // ──────────────────────────────────────────────────────────────────────────
 
 bitflags::bitflags! {
@@ -555,9 +546,9 @@ bitflags::bitflags! {
 // blocked_on: PropertyIdTag variant name verification (PascalCase mapping)
 impl BorderProperty {
     pub(crate) fn try_from_property_id(property_id: PropertyIdTag) -> Option<Self> {
-        // TODO(port): Zig used `inline for` over PropertyIdTag fields + @hasDecl.
-        // Expanded to an explicit match over every PropertyIdTag whose name
-        // starts with "border" and has a matching const above.
+        // An explicit match over every PropertyIdTag whose name starts
+        // with "border" and has a matching const above — keep in sync when new
+        // Border* PropertyIdTag variants are added.
         use PropertyIdTag as P;
         Some(match property_id {
             P::BorderTopColor => Self::BORDER_TOP_COLOR,
@@ -635,10 +626,9 @@ mod border_handler_body {
     use super::*;
     use crate::generics::{CssEql, DeepClone};
     // ──────────────────────────────────────────────────────────────────────────
-    // FlushContext + flush_category! (Zig: nested struct with inline fns and
-    // extensive comptime string-dispatch)
+    // FlushContext + flush_category!
     // ──────────────────────────────────────────────────────────────────────────
-    // PORT NOTE: hoisted above `impl BorderHandler` — macro_rules! is order-
+    // hoisted above `impl BorderHandler` — macro_rules! is order-
     // sensitive and the flush_category!() callsites in `flush()` need these.
 
     // Route the large `Property` enum construction through a non-inlined
@@ -658,12 +648,12 @@ mod border_handler_body {
     }
 
     struct FlushContext<'a, 'bump, 'ctx> {
-        // PORT NOTE: Zig stored `self: *BorderHandler`; we only need flushed_properties
-        // here because the per-side BorderShorthand pointers are passed separately.
+        // Only flushed_properties is needed here because the per-side
+        // BorderShorthand pointers are passed separately.
         flushed_properties: &'a mut BorderProperty,
         dest: &'a mut DeclarationList<'bump>,
         ctx: &'a mut PropertyHandlerContext<'ctx>,
-        // PORT NOTE: `arena` field dropped from PropertyHandlerContext; the
+        // `arena` field dropped from PropertyHandlerContext; the
         // arena is recovered once via `dest.bump()` and threaded here.
         arena: &'bump Bump,
         logical_supported: bool,
@@ -671,10 +661,10 @@ mod border_handler_body {
     }
 
     // `f.logicalProp(ltr, ltr_key, rtl, rtl_key, val)` — ltr_key/rtl_key were unused.
-    // PORT NOTE: `$val` is evaluated *before* reborrowing `$f` so callers may pass
+    // `$val` is evaluated *before* reborrowing `$f` so callers may pass
     // expressions that read `f.arena` without tripping E0502.
     macro_rules! fc_logical_prop {
-        // PORT NOTE: the `GenericBorder` shorthand pairs carry distinct const-generic
+        // the `GenericBorder` shorthand pairs carry distinct const-generic
         // discriminants per side (BorderLeft = P=3, BorderRight = P=1), so a single
         // `__val` cannot `deep_clone()` into both `Property` variants. Recast via
         // `clone_as::<Q>()` instead. Callers always pass a `to_border()` result here,
@@ -715,8 +705,7 @@ mod border_handler_body {
     }
 
     // `f.push(p, val)`
-    // PORT NOTE: Zig's `@field(BorderProperty, p)` keyed both Property and BorderProperty
-    // off one kebab string. Here `$p` is the PascalCase Property/PropertyIdTag variant;
+    // `$p` is the PascalCase Property/PropertyIdTag variant;
     // the bitflags const is derived via try_from_property_id so a single ident suffices.
     macro_rules! fc_push {
         ($f:expr, $p:ident, $val:expr) => {{
@@ -747,8 +736,7 @@ mod border_handler_body {
         }};
     }
 
-    // `f.prop(prop_name, val)` — comptime string dispatch over prop_name.
-    // In Rust we dispatch on the Property variant ident.
+    // Dispatch on the Property variant ident.
     macro_rules! fc_prop {
         // border-inline-start*
         ($f:expr, BorderInlineStart, $val:expr) => {{
@@ -915,9 +903,8 @@ mod border_handler_body {
         };
     }
 
-    // `flushCategory(...)` — was a fn with comptime string params + nested `State`
-    // struct of inline fns. In Rust we expand it as a macro so the `comptime` prop
-    // names remain compile-time idents and the nested closures become local macros.
+    // `flush_category!` is a macro so the prop names remain
+    // compile-time idents and the nested closures become local macros.
     macro_rules! flush_category {
     (
         $f:expr,
@@ -1235,11 +1222,11 @@ mod border_handler_body {
             dest: &mut DeclarationList,
             context: &mut PropertyHandlerContext,
         ) -> bool {
-            // PORT NOTE: `arena` field dropped from PropertyHandlerContext; the
+            // `arena` field dropped from PropertyHandlerContext; the
             // arena is recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
             let arena = dest.bump();
 
-            // Helper macros — Zig used local comptime closures with @field string access.
+            // Helper macros.
 
             macro_rules! flush_helper {
                 ($key:ident, $prop:ident, $val:expr, $category:expr) => {{
@@ -1522,9 +1509,8 @@ mod border_handler_body {
             let logical_shorthand_supported =
                 !context.should_compile_logical(Feature::LogicalBorderShorthand);
 
-            // PORT NOTE: reshaped for borrowck — Zig stored `self: *BorderHandler` in
-            // FlushContext and accessed self.border_* through it. We instead take
-            // independent &mut borrows of each shorthand, plus &mut self.flushed_properties.
+            // Take independent &mut borrows of each shorthand, plus
+            // &mut self.flushed_properties, instead of one &mut self.
             let arena = dest.bump();
             let mut flctx = FlushContext {
                 flushed_properties: &mut self.flushed_properties,
@@ -1625,16 +1611,15 @@ mod border_handler_body {
             }
 
             macro_rules! prop {
-            ($id:ident) => {{
-                let _ = &dest; // autofix (matches Zig: `_ = d;`)
-                let mut upppppppppp =
-                    unparsed.with_property_id(arena, PropertyId::$id);
-                context.add_unparsed_fallbacks(arena, &mut upppppppppp);
-                self.flushed_properties
-                    .insert(BorderProperty::try_from_property_id(PropertyIdTag::$id).unwrap());
-                // TODO(port): Zig did NOT push to dest here (likely a bug upstream) — preserved.
-            }};
-        }
+                ($id:ident) => {{
+                    let _ = &dest; // autofix
+                    let mut upppppppppp = unparsed.with_property_id(arena, PropertyId::$id);
+                    context.add_unparsed_fallbacks(arena, &mut upppppppppp);
+                    self.flushed_properties
+                        .insert(BorderProperty::try_from_property_id(PropertyIdTag::$id).unwrap());
+                    // Intentionally not pushed to dest (preserves existing behavior; likely a bug).
+                }};
+            }
 
             macro_rules! logical_prop {
                 ($ltr:ident, $rtl:ident) => {{
@@ -1740,6 +1725,4 @@ mod border_handler_body {
                 | P::Border
         )
     }
-
-    // ported from: src/css/properties/border.zig
 } // mod border_handler_body
diff --git a/src/css/properties/border_image.rs b/src/css/properties/border_image.rs
index d79fef7960f..a1bfe1d1a41 100644
--- a/src/css/properties/border_image.rs
+++ b/src/css/properties/border_image.rs
@@ -34,9 +34,7 @@ pub struct BorderImage {
 }
 
 impl BorderImage {
-    // TODO(port): PropertyFieldMap / VendorPrefixMap were comptime anonymous-struct
-    // tables consumed via @field reflection by the shorthand codegen. Replace with
-    // a trait impl (e.g. `impl ShorthandProperty for BorderImage`).
+    // Recorded here for a future shorthand trait/derive to consume.
     // PropertyFieldMap:
     //   source -> PropertyIdTag::BorderImageSource
     //   slice  -> PropertyIdTag::BorderImageSlice
@@ -46,12 +44,9 @@ impl BorderImage {
     // VendorPrefixMap: all fields = true
 
     pub(crate) fn parse(input: &mut css::Parser) -> Result<BorderImage> {
-        // PORT NOTE: Zig passed `{}` ctx + a no-op callback struct; collapsed to a closure.
         Self::parse_with_callback(input, |_: &mut css::Parser| false)
     }
 
-    // PORT NOTE: Zig signature was (input, ctx: anytype, comptime callback: anytype)
-    // where callback(ctx, input) -> bool. Collapsed ctx into the closure capture.
     pub(crate) fn parse_with_callback(
         input: &mut css::Parser,
         mut callback: impl FnMut(&mut css::Parser) -> bool,
@@ -200,22 +195,19 @@ impl BorderImage {
         targets: &css::targets::Targets,
     ) -> SmallList<BorderImage, 6> {
         let fallbacks = self.source.get_fallbacks(arena, targets);
-        // PORT NOTE: `defer fallbacks.deinit(arena)` dropped — SmallList drops at scope exit.
+        // `defer fallbacks.deinit(arena)` dropped — SmallList drops at scope exit.
         let mut res = SmallList::<BorderImage, 6>::init_capacity(fallbacks.len());
-        for fallback in fallbacks.slice() {
-            // TODO(port): Zig moved `fallback` by value; SmallList lacks
-            // by-value drain in Rust port — deep_clone the source image
-            // until SmallList grows IntoIterator.
+        for fallback in fallbacks {
+            // `fallback` is moved into the cloned shorthand.
             let mut clone = self.deep_clone(arena);
-            clone.source = fallback.deep_clone(arena);
+            clone.source = fallback;
             res.append(clone);
         }
         res
     }
 
     pub(crate) fn deep_clone(&self, arena: &Arena) -> Self {
-        // PORT NOTE: Zig css.implementDeepClone iterated @typeInfo fields. Expanded
-        // explicitly here — keep in sync with the BorderImage field list.
+        // Keep in sync with the BorderImage field list.
         BorderImage {
             source: self.source.deep_clone(arena),
             slice: self.slice.deep_clone(arena),
@@ -306,9 +298,8 @@ pub enum BorderImageSideWidth {
 }
 
 impl BorderImageSideWidth {
-    // PORT NOTE: `css.DeriveParse(@This()).parse` / `css.DeriveToCss(@This()).toCss`
-    // were comptime-reflected derives. Hand-expanded — declaration order matches
-    // Zig (Number → LengthPercentage → keyword `auto`).
+    // Hand-expanded — tried in declaration order
+    // (Number → LengthPercentage → keyword `auto`).
     pub(crate) fn parse(input: &mut css::Parser) -> Result<Self> {
         if let Ok(n) = input.try_parse(CSSNumberFns::parse) {
             return Ok(BorderImageSideWidth::Number(n));
@@ -456,11 +447,7 @@ impl BorderImageProperty {
 
     pub(crate) const BORDER_IMAGE: BorderImageProperty = BorderImageProperty::all();
 
-    // PORT NOTE: bitflags provides `is_empty()` already; Zig `isEmpty` maps to it.
-
     pub(crate) fn try_from_property_id(property_id: PropertyIdTag) -> Option<BorderImageProperty> {
-        // PORT NOTE: Zig used `inline for` over struct fields + @field to match
-        // "border-image-" ++ field.name. Unrolled explicitly here.
         match property_id {
             PropertyIdTag::BorderImageSource => Some(BorderImageProperty::SOURCE),
             PropertyIdTag::BorderImageSlice => Some(BorderImageProperty::SLICE),
@@ -494,8 +481,7 @@ impl BorderImageHandler {
     ) -> bool {
         let arena = dest.bump();
 
-        // PORT NOTE: Zig defined `flushHelper`/`propertyHelper` as local struct fns
-        // using @field for comptime field access. Ported as macro_rules! to keep the
+        // `flushHelper`/`propertyHelper` are macro_rules! to keep the
         // per-field name dispatch without reflection.
         macro_rules! flush_helper {
             ($self:expr, $d:expr, $ctx:expr, $name:ident, $val:expr) => {
@@ -570,7 +556,6 @@ impl BorderImageHandler {
                             .unwrap(),
                     );
                     dest.push(Property::Unparsed(unparsed_clone));
-                    // PERF(port): was bun.handleOom(dest.append(arena, ...))
                 } else {
                     return false;
                 }
@@ -645,7 +630,7 @@ impl BorderImageHandler {
                         .prefixes(self.vendor_prefix, css::prefixes::Feature::BorderImage);
                     if self.flushed_properties.is_empty() {
                         let fallbacks = border_image.get_fallbacks(arena, &context.targets);
-                        for fallback in fallbacks.slice() {
+                        for fallback in fallbacks {
                             // Match prefix of fallback. e.g. -webkit-linear-gradient
                             // can only be used in -webkit-border-image, not -moz-border-image.
                             // However, if border-image is unprefixed, gradients can still be.
@@ -653,9 +638,7 @@ impl BorderImageHandler {
                             if p.is_empty() {
                                 p = prefix;
                             }
-                            // TODO(port): Zig moved `fallback` by value; SmallList has no
-                            // by-value drain yet — deep_clone until IntoIterator lands.
-                            dest.push(Property::BorderImage((fallback.deep_clone(arena), p)));
+                            dest.push(Property::BorderImage((fallback, p)));
                         }
                     }
                 }
@@ -669,22 +652,19 @@ impl BorderImageHandler {
                 self.flushed_properties
                     .insert(BorderImageProperty::BORDER_IMAGE);
             }
-            (mut source, slice, width, outset, repeat) => {
-                if let Some(mut_source) = &mut source {
+            (source, slice, width, outset, repeat) => {
+                if let Some(mut mut_source) = source {
                     if !self
                         .flushed_properties
                         .contains(BorderImageProperty::BORDER_IMAGE_SOURCE)
                     {
                         let img_fallbacks = mut_source.get_fallbacks(arena, &context.targets);
-                        for fallback in img_fallbacks.slice() {
-                            // TODO(port): same by-value move note as above.
-                            dest.push(Property::BorderImageSource(fallback.deep_clone(arena)));
+                        for fallback in img_fallbacks {
+                            dest.push(Property::BorderImageSource(fallback));
                         }
                     }
 
-                    dest.push(Property::BorderImageSource(mut_source.deep_clone(arena)));
-                    // TODO(port): Zig pushed `mut_source.*` by value (move). Cloning here to
-                    // avoid partial-move out of `source: Option<Image>`.
+                    dest.push(Property::BorderImageSource(mut_source));
                     self.flushed_properties
                         .insert(BorderImageProperty::BORDER_IMAGE_SOURCE);
                 }
@@ -732,5 +712,3 @@ pub(crate) fn is_border_image_property(property_id: PropertyIdTag) -> bool {
 }
 
 crate::css_eql_partialeq!(BorderImageSideWidth);
-
-// ported from: src/css/properties/border_image.zig
diff --git a/src/css/properties/border_radius.rs b/src/css/properties/border_radius.rs
index bd664d747b8..ad6187f4e0c 100644
--- a/src/css/properties/border_radius.rs
+++ b/src/css/properties/border_radius.rs
@@ -12,8 +12,8 @@ use crate::css_values::size::Size2D;
 use bun_alloc::ArenaVecExt as _;
 
 /// A value for the [border-radius](https://www.w3.org/TR/css-backgrounds-3/#border-radius) property.
-// PORT NOTE: `Size2D<T>` carries no `Clone`/`PartialEq` derives (it exposes
-// inherent `deep_clone`/`eql` instead, matching the Zig protocol surface), so
+// `Size2D<T>` carries no `Clone`/`PartialEq` derives (it exposes
+// inherent `deep_clone`/`eql` instead), so
 // `BorderRadius` can't `#[derive]` them either. The handler below uses
 // `Size2D::deep_clone`/`Size2D::eql` directly.
 pub struct BorderRadius {
@@ -44,11 +44,7 @@ impl BorderRadius {
             && Size2D::eql(&self.bottom_left, &other.bottom_left)
     }
 
-    // (old using name space) css.DefineShorthand(@This(), css.PropertyIdTag.@"border-radius", PropertyFieldMap);
-
-    // TODO(port): PropertyFieldMap / VendorPrefixMap were Zig anonymous-struct decl literals
-    // consumed by comptime DefineShorthand reflection. Represent as assoc consts for now;
-    // wire these into the shorthand trait/derive once it exists.
+    // Kept as assoc consts for a future shorthand trait/derive to consume.
     pub const PROPERTY_FIELD_MAP: [(&'static str, &'static str); 4] = [
         ("top_left", "border-top-left-radius"),
         ("top_right", "border-top-right-radius"),
@@ -69,7 +65,7 @@ impl BorderRadius {
             // errdefer-style cleanup of `widths` is implicit via Drop on the `?` path.
             Rect::<LengthPercentage>::parse_with(input, LengthPercentage::parse)?
         } else {
-            // PORT NOTE: Zig `widths.deepClone(arena)` — `LengthPercentage` is
+            // `LengthPercentage` is
             // `Clone`-via-derive (no arena indirection), so per-field `.clone()` is exact.
             Rect {
                 top: widths.top.clone(),
@@ -100,8 +96,7 @@ impl BorderRadius {
     }
 
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PORT NOTE: Zig built `Rect(*const LengthPercentage)` and reused
-        // `Rect.toCss`. `Rect::<&T>::to_css` would need `&T: ToCss + PartialEq`;
+        // `Rect::<&T>::to_css` would need `&T: ToCss + PartialEq`;
         // inline the 4-side serialization to avoid that bound (logic is identical
         // to `values::rect::Rect::to_css`).
         #[inline]
@@ -154,8 +149,8 @@ impl BorderRadius {
         Ok(())
     }
 
-    // deepClone → #[derive(Clone)] (was css.implementDeepClone comptime field iteration)
-    // eql       → #[derive(PartialEq)] (was css.implementEql comptime field iteration)
+    // deep_clone comes from #[derive(Clone)].
+    // eql comes from #[derive(PartialEq)].
 }
 
 #[derive(Default)]
@@ -168,17 +163,16 @@ pub struct BorderRadiusHandler {
     pub start_end: Option<Property>,
     pub end_end: Option<Property>,
     pub end_start: Option<Property>,
-    // Zig: `= .physical`. derive(Default) is sound here because
+    // derive(Default) is sound here because
     // PropertyCategory::default() == Physical (see src/css/logical.rs).
     pub category: PropertyCategory,
     pub has_any: bool,
 }
 
-// The Zig helpers take `comptime prop: []const u8` and use `@field` / `@unionInit` for
-// token-level field/variant access. Rust has no field-by-name reflection, so these are
+// There is no field-by-name reflection, so these helpers are
 // macro_rules! that paste the field ident and the corresponding Property variant ident.
 
-// PORT NOTE: `Size2D::is_compatible` is bounded on `T: values::protocol::IsCompatible`,
+// `Size2D::is_compatible` is bounded on `T: values::protocol::IsCompatible`,
 // which `LengthPercentage` (= `DimensionPercentage<LengthValue>`) does not yet impl.
 // Hand-roll the per-component check via `LengthPercentage::is_compatible` (inherent
 // method) until that protocol impl lands.
@@ -235,7 +229,7 @@ macro_rules! logical_property_helper {
             $self.flush($d, $ctx);
         }
 
-        // PORT NOTE: Zig stored `property.deepClone(arena)`. `Property` itself
+        // `Property` itself
         // has no blanket `Clone`; callers pass an already-deep_clone'd `Property`.
         $self.$prop = Some($val);
         $self.category = PropertyCategory::Logical;
@@ -300,7 +294,7 @@ impl BorderRadiusHandler {
         context: &mut PropertyHandlerContext,
     ) -> bool {
         let bump = dest.bump();
-        // PORT NOTE: `Property::deep_clone` is still gated; reconstruct the
+        // `Property::deep_clone` is still gated; reconstruct the
         // matched variant directly (Size2D<LP> deep-clones via inherent method).
         match property {
             Property::BorderTopLeftRadius((val, vp)) => {
@@ -563,5 +557,3 @@ pub fn is_logical_border_radius_property(property_id: PropertyIdTag) -> bool {
             | PropertyIdTag::BorderEndStartRadius
     )
 }
-
-// ported from: src/css/properties/border_radius.zig
diff --git a/src/css/properties/box_shadow.rs b/src/css/properties/box_shadow.rs
index 84ba72d9f34..9a4a221ad33 100644
--- a/src/css/properties/box_shadow.rs
+++ b/src/css/properties/box_shadow.rs
@@ -28,8 +28,8 @@ pub struct BoxShadow {
     pub inset: bool,
 }
 
-// PORT NOTE: `SmallList::{deep_clone,eql,is_compatible}` are bounded on the
-// `generics::{DeepClone,CssEql,IsCompatible}` traits. Wire BoxShadow into all
+// `SmallList::{deep_clone,eql,is_compatible}` are bounded on the
+// `generics::{DeepClone,CssEql,IsCompatible}` traits. BoxShadow implements all
 // three so the handler can use `SmallList<BoxShadow,1>` directly without
 // hand-rolling per-field loops.
 impl<'bump> css::generic::DeepClone<'bump> for BoxShadow {
@@ -127,7 +127,6 @@ impl BoxShadow {
         dest.write_char(b' ')?;
         self.y_offset.to_css(dest)?;
 
-        // PORT NOTE: Zig `Length.eql` → Rust `PartialEq` (see values/length.rs).
         if self.blur != Length::zero() || self.spread != Length::zero() {
             dest.write_char(b' ')?;
             self.blur.to_css(dest)?;
@@ -146,8 +145,7 @@ impl BoxShadow {
     }
 
     pub(crate) fn deep_clone(&self, arena: &Arena) -> Self {
-        // PORT NOTE: Zig css.implementDeepClone iterated @typeInfo fields. Expanded
-        // explicitly here — keep in sync with the BoxShadow field list. `Length`
+        // Expanded field-wise — keep in sync with the BoxShadow field list. `Length`
         // has no `DeepClone` trait impl yet but is `Clone` (Box<Calc> deep-clones).
         BoxShadow {
             color: self.color.deep_clone(arena),
@@ -160,8 +158,7 @@ impl BoxShadow {
     }
 
     pub(crate) fn eql(&self, rhs: &Self) -> bool {
-        // PORT NOTE: Zig css.implementEql iterated @typeInfo fields. Expanded
-        // explicitly. `Length` Zig `eql` → Rust `PartialEq` (values/length.rs).
+        // Expanded field-wise — keep in sync with the BoxShadow field list.
         self.color.eql(&rhs.color)
             && self.x_offset == rhs.x_offset
             && self.y_offset == rhs.y_offset
@@ -204,9 +201,9 @@ impl BoxShadowHandler {
                     self.flush(dest, context);
                 }
 
-                // PORT NOTE: reshaped for borrowck — Zig held simultaneous &mut into
-                // self.box_shadows across self.flush(). Compute the predicate first,
-                // then either flush+replace or update in place.
+                // Compute the predicate first, then either flush+replace or
+                // update in place (avoids holding &mut self.box_shadows
+                // across self.flush()).
                 let needs_flush = if let Some(bxs) = &self.box_shadows {
                     !SmallList::eql(&bxs.0, box_shadows) && !bxs.1.contains(prefix)
                 } else {
@@ -273,10 +270,6 @@ impl BoxShadowHandler {
                 fallbacks.insert(shadow.color.get_necessary_fallbacks(&context.targets));
             }
 
-            // PORT NOTE: Zig used `initCapacity(len)` + `setLen(len)` + per-index field
-            // writes via `inline for std.meta.fields(BoxShadow)` skipping `color`. That
-            // pattern would observe partially-uninit `BoxShadow` values in Rust, so we
-            // build each fully-formed `BoxShadow` and `append`. Behavior is identical.
             macro_rules! build_color_fallback {
                 ($conv:ident) => {{
                     let mut out: SmallList<BoxShadow, 1> =
@@ -327,5 +320,3 @@ impl BoxShadowHandler {
         self.flushed = true;
     }
 }
-
-// ported from: src/css/properties/box_shadow.zig
diff --git a/src/css/properties/css_modules.rs b/src/css/properties/css_modules.rs
index c3f02e4a881..00a451be892 100644
--- a/src/css/properties/css_modules.rs
+++ b/src/css/properties/css_modules.rs
@@ -79,7 +79,6 @@ impl Composes {
     }
 
     pub fn deep_clone(&self, bump: &Arena) -> Self {
-        // PORT NOTE: Zig `css.implementDeepClone` is comptime field reflection.
         // `CustomIdent` is `Copy` (arena-ptr payload), so an element-wise copy
         // into a fresh `SmallList` is the deep clone.
         let mut names = CustomIdentList::default();
@@ -95,7 +94,6 @@ impl Composes {
     }
 
     pub fn eql(lhs: &Self, rhs: &Self) -> bool {
-        // PORT NOTE: Zig `css.implementEql` is comptime field reflection.
         if lhs.names.len() != rhs.names.len() {
             return false;
         }
@@ -139,7 +137,6 @@ impl crate::generics::CssEql for Specifier {
 
 impl Specifier {
     pub fn eql(lhs: Self, rhs: Self) -> bool {
-        // PORT NOTE: Zig `css.implementEql` (variant-wise reflection) → hand-match.
         match (lhs, rhs) {
             (Specifier::Global, Specifier::Global) => true,
             (Specifier::ImportRecordIndex(a), Specifier::ImportRecordIndex(b)) => a == b,
@@ -179,12 +176,11 @@ impl Specifier {
     }
 
     pub fn deep_clone(self, _bump: &Arena) -> Self {
-        // PORT NOTE: Zig `css.implementDeepClone` — variants are `Copy`.
+        // Variants are `Copy`; the deep clone is the value itself.
         self
     }
 
     pub fn hash(self, hasher: &mut Wyhash) {
-        // PORT NOTE: Zig `css.implementHash` (variant-wise reflection) → hand-match.
         match self {
             Specifier::Global => hasher.update(&0u32.to_ne_bytes()),
             Specifier::ImportRecordIndex(i) => {
@@ -194,5 +190,3 @@ impl Specifier {
         }
     }
 }
-
-// ported from: src/css/properties/css_modules.zig
diff --git a/src/css/properties/custom.rs b/src/css/properties/custom.rs
index c75e77d7b6d..0c25d607e86 100644
--- a/src/css/properties/custom.rs
+++ b/src/css/properties/custom.rs
@@ -1,6 +1,4 @@
 //! CSS custom properties / `var()` / `env()` / unparsed token lists.
-//!
-//! Ported from `src/css/properties/custom.zig`.
 //
 // `TokenList::{parse, parse_into, parse_with_options, to_css, to_css_raw}`,
 // `UnresolvedColor::{parse, to_css}`, `Variable::{parse, to_css}`,
@@ -79,8 +77,8 @@ mod ext {
     /// Vec<u8>`, which this round adds in css_parser.rs).
     pub(super) fn url_to_css(this: &Url, dest: &mut Printer) -> PrintResult<()> {
         let dep: Option<dependencies::UrlDependency> = if dest.dependencies.is_some() {
-            // PORT NOTE: reshaped for borrowck — `get_import_records` borrows
-            // &mut *dest, so capture arena/filename first.
+            // `get_import_records` borrows &mut *dest, so capture
+            // arena/filename first.
             let arena = dest.arena;
             // SAFETY: filename borrows the printer arena/options which outlive `dest`.
             let filename: &[u8] = unsafe { &*std::ptr::from_ref::<[u8]>(dest.filename()) };
@@ -102,7 +100,6 @@ mod ext {
             dest.write_char(b')')?;
 
             if let Some(dependencies) = &mut dest.dependencies {
-                // PORT NOTE: bun.handleOom dropped — Vec::push aborts on OOM via global arena
                 dependencies.push(crate::Dependency::Url(d));
             }
 
@@ -111,8 +108,8 @@ mod ext {
 
         let import_record = dest.import_record(this.import_record_idx)?;
         let is_internal = import_record.tag.is_internal();
-        // PORT NOTE: reshaped for borrowck — `get_import_record_url` reborrows
-        // &mut *dest, so capture `is_internal` first.
+        // `get_import_record_url` reborrows &mut *dest, so capture
+        // `is_internal` first.
         let url: &'static [u8] = {
             let u = dest.get_import_record_url(this.import_record_idx)?;
             // SAFETY: import-record paths are arena/source-owned and outlive `dest`.
@@ -120,7 +117,6 @@ mod ext {
         };
 
         if dest.minify && !is_internal {
-            // PERF(port): was std.Io.Writer.Allocating with dest.arena — using Vec<u8>; profile if hot.
             let mut buf: Vec<u8> = Vec::new();
             // PERF(alloc) we could use stack fallback here?
             let _ = Token::UnquotedUrl(url).to_css_generic(&mut buf);
@@ -160,7 +156,7 @@ mod ext {
 
     /// Forwarder to `DashedIdentReference::to_css` (now un-gated in
     /// `values/ident.rs`). `CssModule::reference_dashed` is real; the
-    /// CSS-Modules `dashed_idents` remapping path (ident.zig:44-52) is wired.
+    /// CSS-Modules `dashed_idents` remapping path is wired.
     #[inline]
     pub(super) fn dashed_ident_ref_to_css(
         this: &DashedIdentReference,
@@ -274,7 +270,6 @@ impl CssEql for Token {
 impl CssHash for Token {
     fn hash(&self, hasher: &mut Wyhash) {
         use Token::*;
-        // Zig `implementHash`: tag prefix + payload bytes.
         // `Token::kind() as u32` gives a stable per-variant discriminant.
         hasher.update(&(self.kind() as u32).to_ne_bytes());
         match self {
@@ -303,16 +298,14 @@ impl<'bump> DeepClone<'bump> for Token {
     #[inline]
     fn deep_clone(&self, _bump: &'bump Arena) -> Self {
         // All `&'static [u8]` payloads borrow the parser source/arena (`'static`
-        // is a placeholder) — identity copy is correct (matches generics.zig
-        // "const strings" fast-path). `Num`/`Dimension` are POD.
+        // is a placeholder) — identity copy is correct. `Num`/`Dimension` are POD.
         self.clone()
     }
 }
 
-// PERF(port): the token vecs here are plain global-alloc `Vec<TokenOrValue>`;
-// the Zig original was arena-backed. Thread `&'bump Bump` if profiling shows it.
+// PERF: the token vecs here are plain global-alloc `Vec<TokenOrValue>`;
+// Thread `&'bump Bump` if profiling shows it.
 
-/// Zig: `pub fn Result(comptime T: type) type` → `Maybe(T, ParseError(ParserError))`.
 pub use css_parser::CssResult as Result;
 
 /// PERF: nullable optimization
@@ -482,8 +475,7 @@ impl TokenList {
             if tokens[tokens.len() - 1].is_whitespace() {
                 end -= 1;
             }
-            // PORT NOTE: Zig does `insertSlice(0, slice)` (shallow memcpy) then `tokens.deinit()`
-            // (frees only the backing array). `drain` moves the elements out without deep-cloning.
+            // `drain` moves the elements out without deep-cloning.
             let newlist: Vec<TokenOrValue> = tokens.drain(start..end).collect();
             return Ok(TokenList { v: newlist });
         }
@@ -567,7 +559,7 @@ impl TokenList {
             let Ok(tok) = input.next_including_whitespace() else {
                 break;
             };
-            // PORT NOTE: reshaped for borrowck — clone the token so we can call &mut methods on `input` below.
+            // Clone the token so we can call &mut methods on `input` below.
             let tok = tok.clone();
             match &tok {
                 Token::Whitespace(_) | Token::Comment(_) => {
@@ -752,7 +744,6 @@ impl TokenList {
 
         let mut res = css::SmallList::<Fallbacks, 2>::default();
         if fallbacks.contains(ColorFallbackKind::P3) {
-            // PERF(port): was assume_capacity
             res.append((
                 ColorFallbackKind::P3.supports_condition(),
                 self.get_fallback(bump, ColorFallbackKind::P3),
@@ -760,7 +751,6 @@ impl TokenList {
         }
 
         if fallbacks.contains(ColorFallbackKind::LAB) {
-            // PERF(port): was assume_capacity
             res.append((
                 ColorFallbackKind::LAB.supports_condition(),
                 self.get_fallback(bump, ColorFallbackKind::LAB),
@@ -985,7 +975,6 @@ impl UnresolvedColor {
                 })
             }),
             b"light-dark" => return input.parse_nested_block(|input2| {
-                // errdefer doesn't fire on `return .{ .err = ... }` in Zig — but in Rust,
                 // `?` drops `light` automatically on the error path.
                 let light = input2.parse_until_before(Delimiters::COMMA, |i| {
                     TokenListFns::parse(i, options, depth + 1)
@@ -1016,9 +1005,8 @@ impl UnresolvedColor {
 
 // `ComponentParser::parse_relative` is generic over `C: LightDarkOwned` so the
 // `from light-dark(...)` relative-color path can rebuild a `light-dark()` of
-// whatever output type the caller is producing. Zig duck-types this via
-// `lightDarkOwned` on both `CssColor` and `UnresolvedColor`; in Rust the trait
-// lives in `values::color` and we wire `UnresolvedColor` into it here.
+// whatever output type the caller is producing. The trait lives in
+// `values::color` and we wire `UnresolvedColor` into it here.
 impl css_values::color::LightDarkOwned for UnresolvedColor {
     #[inline]
     fn light_dark_owned(light: Self, dark: Self) -> Self {
@@ -1191,9 +1179,7 @@ impl EnvironmentVariableName {
 }
 
 /// A UA-defined environment variable name.
-// PORT NOTE: Zig `css.DefineEnumProperty(@This())` provides eql/hash/parse/
-// to_css/deep_clone via comptime reflection over @tagName. Replaced by an
-// `EnumProperty` impl below (kebab-case match) — same protocol surface.
+// The `EnumProperty` impl below provides parse/to_css via a kebab-case match.
 #[derive(Clone, Copy, PartialEq, Eq, strum::IntoStaticStr, CssHash)]
 pub enum UAEnvironmentVariable {
     /// The safe area inset from the top of the viewport.
@@ -1336,8 +1322,7 @@ impl TokenOrValue {
 // `TokenList` payload, and `media_query::MediaFeatureValue` derives
 // `Debug + Clone` over an `EnvironmentVariable` payload. The leaf value types
 // (`Url`, `CustomIdent`, …) don't all `#[derive(Clone)]` yet, so hand-roll
-// the structural clone here. PORT NOTE: Zig had no `Clone` distinction —
-// shallow struct copy was implicit; arena-slice payloads (`*const [u8]`) are
+// the structural clone here. Arena-slice payloads (`*const [u8]`) are
 // `Copy`, and the only owning fields are `Vec<TokenOrValue>` / `Vec<i32>`.
 
 impl Clone for TokenList {
@@ -1538,7 +1523,7 @@ pub enum CustomPropertyName {
     Unknown(Ident),
 }
 
-// PORT NOTE: `DashedIdent`/`Ident` carry `*const [u8]` arena slices and
+// `DashedIdent`/`Ident` carry `*const [u8]` arena slices and
 // intentionally don't derive `PartialEq` (pointer-eq would be wrong).
 // `PropertyId` derives `PartialEq`, so compare the underlying bytes here.
 impl PartialEq for CustomPropertyName {
@@ -1552,7 +1537,7 @@ impl CustomPropertyName {
     pub fn to_css(&self, dest: &mut Printer) -> PrintResult<()> {
         match self {
             CustomPropertyName::Custom(custom) => {
-                // Spec custom.zig:1496-1501 → DashedIdent.toCss → dest.writeDashedIdent(ident, true),
+                // DashedIdent.toCss → dest.writeDashedIdent(ident, true),
                 // which applies CSS-Modules dashed-ident renaming.
                 dest.write_dashed_ident(custom, true)
             }
@@ -1627,5 +1612,3 @@ pub(crate) fn try_parse_color_token(
 
     None
 }
-
-// ported from: src/css/properties/custom.zig
diff --git a/src/css/properties/display.rs b/src/css/properties/display.rs
index 676843912d5..5b80df0a347 100644
--- a/src/css/properties/display.rs
+++ b/src/css/properties/display.rs
@@ -11,8 +11,8 @@ pub enum Display {
     Pair(DisplayPair),
 }
 
-// PORT NOTE: Zig `DeriveParse`/`DeriveToCss` for a 2-payload union(enum) tries each
-// payload's `parse` in declaration order; `toCss` dispatches to the active payload.
+// Tries each payload's `parse` in declaration order; `to_css` dispatches to
+// the active payload.
 impl Display {
     pub(crate) fn parse(input: &mut Parser) -> css::Result<Self> {
         if let Ok(kw) = input.try_parse(DisplayKeyword::parse) {
@@ -130,7 +130,6 @@ impl DisplayPair {
         let location = input.current_source_location();
         let ident = input.expect_ident_cloned()?;
 
-        // PORT NOTE: Zig used `bun.ComptimeStringMap(..).getASCIIICaseInsensitive`.
         // 8 keys → if-chain over `eql_case_insensitive_ascii::<true>` (phf values
         // would have to be const-eval, and `VendorPrefix` bitflags are not).
         use bun_core::eql_case_insensitive_ascii as eq;
@@ -161,7 +160,6 @@ impl DisplayPair {
     }
 
     pub(crate) fn to_css(self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PORT NOTE: reshaped Zig if-else chain into match for tagged-union payload extraction.
         match (self.outside, &self.inside, self.is_list_item) {
             (DisplayOutside::Inline, DisplayInside::FlowRoot, false) => {
                 return dest.write_str("inline-block");
@@ -243,7 +241,6 @@ impl DisplayInside {
         let location = input.current_source_location();
         let ident = input.expect_ident_cloned()?;
 
-        // PORT NOTE: Zig used `bun.ComptimeStringMap(..).getASCIIICaseInsensitive`.
         // 10 keys → if-chain over `eql_case_insensitive_ascii::<true>`.
         use bun_core::eql_case_insensitive_ascii as eq;
         Ok(if eq(ident, b"flow", true) {
@@ -293,5 +290,3 @@ impl DisplayInside {
         }
     }
 }
-
-// ported from: src/css/properties/display.zig
diff --git a/src/css/properties/effects.rs b/src/css/properties/effects.rs
index c3d71c41cec..8b137891791 100644
--- a/src/css/properties/effects.rs
+++ b/src/css/properties/effects.rs
@@ -1 +1 @@
-// ported from: src/css/properties/effects.zig
+
diff --git a/src/css/properties/flex.rs b/src/css/properties/flex.rs
index 2470c4ab847..78d42b455e0 100644
--- a/src/css/properties/flex.rs
+++ b/src/css/properties/flex.rs
@@ -7,9 +7,8 @@ use css::css_properties::align::{AlignContent, AlignItems, AlignSelf, JustifyCon
 use css::css_values::length::{LengthPercentage, LengthPercentageOrAuto};
 use css::css_values::number::{CSSInteger, CSSNumber, CSSNumberFns};
 use css::prefixes::Feature as PrefixFeature;
-use css::{PrintErr, Printer, VendorPrefix};
-// Zig: `const isFlex2009 = css.prefixes.Feature.isFlex2009;`
 use css::prefixes::is_flex_2009;
+use css::{PrintErr, Printer, VendorPrefix};
 
 /// A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
 /// A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property.
@@ -59,9 +58,7 @@ pub struct FlexFlow {
     pub wrap: FlexWrap,
 }
 
-// (old using name space) css.DefineShorthand(@This(), css.PropertyIdTag.@"flex-flow", PropertyFieldMap);
-// TODO(port): PropertyFieldMap / VendorPrefixMap are comptime shorthand metadata consumed by
-// css::DefineShorthand reflection. Port as part of the shorthand derive.
+// Shorthand metadata recorded here for a future shorthand derive:
 //   PropertyFieldMap = { direction: PropertyIdTag::FlexDirection, wrap: PropertyIdTag::FlexWrap }
 //   VendorPrefixMap  = { direction: true, wrap: true }
 
@@ -122,8 +119,7 @@ pub struct Flex {
     pub basis: LengthPercentageOrAuto,
 }
 
-// (old using name space) css.DefineShorthand(@This(), css.PropertyIdTag.flex, PropertyFieldMap);
-// TODO(port): PropertyFieldMap / VendorPrefixMap shorthand metadata — see FlexFlow note.
+// Shorthand metadata recorded here for a future shorthand derive (see FlexFlow note):
 //   PropertyFieldMap = { grow: PropertyIdTag::FlexGrow, shrink: PropertyIdTag::FlexShrink, basis: PropertyIdTag::FlexBasis }
 //   VendorPrefixMap  = { grow: true, shrink: true, basis: true }
 
@@ -539,8 +535,6 @@ impl FlexHandler {
         dest: &mut css::DeclarationList,
         context: &mut css::PropertyHandlerContext,
     ) -> bool {
-        // TODO(port): Zig used local closures with `@field(self, prop)` comptime reflection.
-        // Ported as macro_rules! token-pasting on field idents.
         macro_rules! maybe_flush {
             ($prop:ident, $val:expr, $vp:expr) => {{
                 // If two vendor prefixes for the same property have different
@@ -558,9 +552,8 @@ impl FlexHandler {
                 maybe_flush!($prop, $val, $vp);
 
                 // Otherwise, update the value and add the prefix
-                // PORT NOTE: Zig threaded `context.arena` into `css.generic.deepClone`;
-                // every payload here is `Clone` (Copy enums / f32 / i32 / LengthPercentageOrAuto),
-                // so `.clone()` is the faithful equivalent.
+                // Every payload here is `Clone` (Copy enums / f32 / i32 /
+                // LengthPercentageOrAuto), so `.clone()` suffices.
                 if let Some(field) = &mut self.$prop {
                     field.0 = ($val).clone();
                     field.1.insert(*$vp);
@@ -645,8 +638,7 @@ impl FlexHandler {
             Property::Unparsed(val) => {
                 if Self::is_flex_property(&val.property_id) {
                     self.flush(dest, context);
-                    // PORT NOTE: Zig pushed `property.deepClone(context.arena)`. `Property`
-                    // has no blanket `deep_clone` yet; reconstruct from the matched payload.
+                    // `Property` has no blanket `deep_clone` yet; reconstruct from the matched payload.
                     let bump = dest.bump();
                     dest.push(Property::Unparsed(val.deep_clone(bump)));
                 } else {
@@ -694,8 +686,6 @@ impl FlexHandler {
         let mut order = self.order.take();
         let mut flex_order = self.flex_order.take();
 
-        // TODO(port): Zig `legacyProperty` / `singleProperty` use `@unionInit(Property, name, ...)`
-        // (comptime token-pasting). Ported as macro_rules! taking the Property variant ident.
         macro_rules! legacy_property {
             ($variant:ident, $key:expr) => {{
                 if let Some(value) = $key {
@@ -704,8 +694,7 @@ impl FlexHandler {
                     if !prefix.is_empty() {
                         dest.push(Property::$variant((val, prefix)));
                     } else {
-                        // css.generic.eql(comptime T: type, lhs: *const T, rhs: *const T)
-                        // css.generic.deinit(@TypeOf(val), &val, ctx.arena);
+                        // No prefix: the value is dropped here.
                     }
                 }
             }};
@@ -744,7 +733,6 @@ impl FlexHandler {
         }
 
         if let (Some(dir_val), Some(wrap_val)) = (&mut direction, &mut wrap) {
-            // PORT NOTE: reshaped for borrowck — Zig took simultaneous &mut into both Options.
             let dir: &FlexDirection = &dir_val.0;
             let dir_prefix: &mut VendorPrefix = &mut dir_val.1;
             let wrapinner: &FlexWrap = &wrap_val.0;
@@ -799,7 +787,6 @@ impl FlexHandler {
             // prop_2012 = Some, prop_2009 = BoxOrdinalGroup special case
             ($variant:ident, $key:expr, prop_2012 = $p2012:ident, prop_2009 = (BoxOrdinalGroup, $v2009:ident), feature = $feature:ident) => {{
                 single_property!(@inner $variant, $key, $feature, |val, _prefix, prefixes_2009: VendorPrefix| {
-                    // Zig: if T == BoxOrdinalGroup -> Some(val as i32)
                     let s: Option<i32> = Some(val);
                     if let Some(v) = s {
                         dest.push(Property::$v2009((v, prefixes_2009)));
@@ -850,10 +837,10 @@ impl FlexHandler {
                 }
             }};
         }
-        // TODO(port): single_property! macro encodes Zig's comptime `prop_2009`/`prop_2012` branches.
-        // The Zig version gates the entire 2009 block on `comptime prop_2009 != null`; here the macro
-        // arms with `prop_2009 = None` pass a no-op closure, so the `prefix.contains(NONE)` check
-        // still runs but has no effect. Verify this matches behavior exactly.
+        // The `prop_2009 = None` arms pass a no-op closure for the 2009 block.
+        // That block has no side effects other than invoking the body (it only
+        // reads `prefix`/`targets` into locals), so running it with a no-op
+        // body is behaviorally identical to skipping it.
 
         single_property!(
             FlexDirection,
@@ -890,7 +877,7 @@ impl FlexHandler {
         }
 
         if let (Some(g_val), Some(s_val), Some(b_val)) = (&mut grow, &mut shrink, &mut basis) {
-            // PORT NOTE: reshaped for borrowck
+            // reshaped for borrowck
             let g = g_val.0;
             let g_prefix: &mut VendorPrefix = &mut g_val.1;
             let s = s_val.0;
@@ -970,5 +957,3 @@ impl FlexHandler {
         )
     }
 }
-
-// ported from: src/css/properties/flex.zig
diff --git a/src/css/properties/font.rs b/src/css/properties/font.rs
index e3202c4d6b0..8669864f637 100644
--- a/src/css/properties/font.rs
+++ b/src/css/properties/font.rs
@@ -1,6 +1,4 @@
 //! CSS font properties.
-//!
-//! Ported from `src/css/properties/font.zig`.
 //
 // The data types (FontWeight / AbsoluteFontWeight / FontSize /
 // AbsoluteFontSize / RelativeFontSize /
@@ -39,7 +37,6 @@ use css::CssResult;
 
 /// A value for the [font-weight](https://www.w3.org/TR/css-fonts-4/#font-weight-prop) property.
 #[derive(Clone, PartialEq)]
-// TODO(port): css.DeriveParse / css.DeriveToCss were comptime-reflection derives; provide proc-macro #[derive(Parse, ToCss)]
 pub enum FontWeight {
     /// An absolute font weight.
     Absolute(AbsoluteFontWeight),
@@ -50,9 +47,8 @@ pub enum FontWeight {
 }
 
 impl FontWeight {
-    // PORT NOTE: Zig `css.DeriveParse(@This()).parse` for a union(enum) with one
-    // payload variant + 2 keyword variants tries the payload first, then matches
-    // the remaining keywords against `expect_ident`.
+    // Tries the payload variant first, then matches the remaining keywords
+    // against `expect_ident`.
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self> {
         if let Ok(v) = input.try_parse(AbsoluteFontWeight::parse) {
             return Ok(FontWeight::Absolute(v));
@@ -86,8 +82,7 @@ impl FontWeight {
         }
     }
 
-    // eql → derived PartialEq
-    // deepClone → derived Clone; TODO(port): arena-aware deep_clone if needed
+    // eql → derived PartialEq; deepClone → derived Clone (no arena-owned data)
 }
 
 /// An [absolute font weight](https://www.w3.org/TR/css-fonts-4/#font-weight-absolute-values),
@@ -105,8 +100,7 @@ pub enum AbsoluteFontWeight {
 }
 
 impl AbsoluteFontWeight {
-    // PORT NOTE: Zig `css.DeriveParse(@This()).parse` — payload (`CSSNumber`) first,
-    // then keyword variants.
+    // Payload (`CSSNumber`) first, then keyword variants.
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self> {
         if let Ok(n) = input.try_parse(CSSNumberFns::parse) {
             return Ok(AbsoluteFontWeight::Weight(n));
@@ -237,8 +231,7 @@ pub enum FontStretch {
 }
 
 impl FontStretch {
-    // PORT NOTE: Zig `css.DeriveParse(@This()).parse` — two payload variants
-    // tried in declaration order.
+    // Two payload variants tried in declaration order.
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self> {
         if let Ok(kw) = input.try_parse(FontStretchKeyword::parse) {
             return Ok(FontStretch::Keyword(kw));
@@ -334,9 +327,11 @@ pub enum FontFamily {
     /// A generic family name.
     Generic(GenericFontFamily),
     /// A custom family name.
-    // TODO(port): arena-backed slice — should be &'bump [u8] once 'bump lifetime is threaded through
-    // PORT NOTE: with *const [u8] derived PartialEq/Eq/Hash would compare by pointer; Zig's custom
-    // HashContext hashes/compares by content (Wyhash over bytes) — provide manual impls below.
+    // Arena-backed slice: the pointer targets bytes owned by the parser arena and is
+    // only valid while that arena is alive (becomes `&'bump [u8]` once the 'bump
+    // lifetime is threaded through these types). With `*const [u8]`, derived
+    // PartialEq/Eq/Hash would compare by pointer; the manual impls below
+    // hash/compare by content (Wyhash over bytes).
     FamilyName(*const [u8]),
 }
 
@@ -433,9 +428,8 @@ impl FontFamily {
     // `CssEql`/`DeepClone` via `bridge_clone_partialeq!` in `generics.rs`.
 }
 
-// PORT NOTE: Zig's `css.implementEql` / `css.implementHash` walked fields by
-// reflection and compared/hashed `[]const u8` by *content*. With `*const [u8]`
-// in Rust, derived `PartialEq`/`Hash` would compare pointers, so hand-roll.
+// With `*const [u8]`, derived `PartialEq`/`Hash` would compare pointers;
+// hand-roll to compare/hash the bytes by *content*.
 impl PartialEq for FontFamily {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -452,9 +446,9 @@ impl Eq for FontFamily {}
 
 impl core::hash::Hash for FontFamily {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        // PORT NOTE: Zig `css.implementHash` hashes the active tag then the
-        // payload bytes. With `*const [u8]` a derived Hash would hash the
-        // pointer address, breaking FontFamilyHashMap dedupe semantics.
+        // Hash the active tag then the payload bytes. With `*const [u8]` a
+        // derived Hash would hash the pointer address, breaking
+        // FontFamilyHashMap dedupe semantics.
         core::mem::discriminant(self).hash(state);
         match self {
             FontFamily::Generic(g) => g.hash(state),
@@ -468,8 +462,8 @@ impl core::hash::Hash for FontFamily {
 
 impl Clone for FontFamily {
     fn clone(&self) -> Self {
-        // PORT NOTE: shallow — arena slice pointers are `Copy`; matches Zig's
-        // implicit struct copy. `deepClone` would re-alloc the slice in 'bump.
+        // shallow — arena slice pointers are `Copy`.
+        // `deepClone` would re-alloc the slice in 'bump.
         match self {
             FontFamily::Generic(g) => FontFamily::Generic(*g),
             FontFamily::FamilyName(n) => FontFamily::FamilyName(*n),
@@ -647,8 +641,7 @@ pub enum LineHeight {
 }
 
 impl LineHeight {
-    // PORT NOTE: Zig `css.DeriveParse(@This()).parse` — keyword variant first
-    // (`normal`), then payload variants in declaration order.
+    // Keyword variant first (`normal`), then payload variants in declaration order.
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self> {
         if input
             .try_parse(|p| p.expect_ident_matching(b"normal"))
@@ -686,10 +679,8 @@ impl LineHeight {
 }
 
 /// A value for the [font](https://www.w3.org/TR/css-fonts-4/#font-prop) shorthand property.
-// PORT NOTE: Zig's `eql`/`deepClone` were reflection-based (`css.implementEql`
-// / `css.implementDeepClone`); the field-wise `#[derive(DeepClone, CssEql)]`
-// is the Rust equivalent — every field type carries the trait via the
-// blankets/bridges in `generics.rs`.
+// Field-wise `#[derive(DeepClone, CssEql)]` — every field type carries the
+// trait via the blankets/bridges in `generics.rs`.
 #[derive(DeepClone, CssEql)]
 pub struct Font {
     /// The font family.
@@ -746,7 +737,7 @@ impl Font {
             }
 
             if variant_caps.is_some() {
-                // PORT NOTE: Zig has `if (variant_caps != null)` here — preserved verbatim (likely upstream bug; should be `== null`)
+                // Intentionally checks `is_some()` to match upstream lightningcss (likely a bug there; should be `is_none()`)
                 if let Ok(value) = input.try_parse(FontVariantCaps::parse_css2) {
                     variant_caps = Some(value);
                     count += 1;
@@ -776,8 +767,6 @@ impl Font {
             None
         };
 
-        // PORT NOTE: Zig `Vec(FontFamily).parse` parsed a comma-separated
-        // list and packed it; route through `parse_comma_separated` + move.
         let family = input
             .parse_comma_separated(FontFamily::parse)
             .map(Vec::<FontFamily>::move_from_list)?;
@@ -878,7 +867,7 @@ impl FontProperty {
     pub(crate) fn try_from_property_id(
         property_id: crate::properties::PropertyIdTag,
     ) -> Option<FontProperty> {
-        // TODO(port): Zig used `inline for` over std.meta.fields + @field; expanded by hand
+        // Keep in sync when new Font* PropertyIdTag variants are added.
         use crate::properties::PropertyIdTag;
         match property_id {
             PropertyIdTag::FontFamily => Some(FontProperty::FONT_FAMILY),
@@ -918,12 +907,12 @@ impl FontHandler {
         context: &mut crate::PropertyHandlerContext<'_>,
     ) -> bool {
         use crate::properties::Property;
-        // PORT NOTE: `arena` field dropped from PropertyHandlerContext; the
+        // `arena` field dropped from PropertyHandlerContext; the
         // arena is recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
         let arena = dest.bump();
 
-        // TODO(port): Zig used `comptime prop: []const u8` + @field for property_helper / flush_helper / push.
-        // No Rust equivalent for field-name reflection — expanded as macro_rules! over (handler_field, Property variant, FontProperty flag).
+        // macro_rules! over (handler_field, Property variant, FontProperty flag)
+        // for property_helper / flush_helper / push.
         macro_rules! flush_helper {
             ($this:expr, $field:ident, $val:expr) => {{
                 if $this.$field.is_some()
@@ -979,7 +968,6 @@ impl FontHandler {
                     self.flush(dest, context);
                     self.flushed_properties
                         .insert(FontProperty::try_from_property_id(val.property_id.tag()).unwrap());
-                    // PERF(port): was dest.append(context.arena, property.*) on arena
                     dest.push(property.deep_clone(arena));
                 } else {
                     return false;
@@ -1011,7 +999,6 @@ impl FontHandler {
 
         macro_rules! push_prop {
             (Font, $val:expr) => {{
-                // PERF(port): was dest.append(ctx.arena, ..) on arena-backed list
                 decls.push(Property::Font($val));
                 self.flushed_properties.insert(FontProperty::FONT);
             }};
@@ -1047,18 +1034,19 @@ impl FontHandler {
         if let Some(f) = family.as_mut() {
             if f.len() > 1 {
                 // Dedupe
-                // PERF(port): was std.heap.stackFallback(664, default_allocator) — profile if it shows up on a hot path
                 let mut seen: FontFamilyHashMap<()> = Default::default();
 
                 let mut i: usize = 0;
                 while i < f.len() {
-                    // TODO(port): seen.getOrPut equivalent — using entry API
-                    let key = f.at(i).clone();
-                    if seen.contains_key(&key) {
-                        let _ = f.ordered_remove(i);
-                    } else {
-                        seen.insert(key, ());
-                        i += 1;
+                    use bun_collections::array_hash_map::MapEntry;
+                    match seen.entry(f.at(i).clone()) {
+                        MapEntry::Occupied(_) => {
+                            let _ = f.ordered_remove(i);
+                        }
+                        MapEntry::Vacant(v) => {
+                            v.insert(());
+                            i += 1;
+                        }
                     }
                 }
             }
@@ -1128,8 +1116,8 @@ impl FontHandler {
     }
 }
 
-// TODO(port): SYSTEM_UI was `const FontFamily = .{ .generic = .system_ui }`; cannot be a `const` here
-// because FontFamily contains a raw pointer. Compare against the Generic variant directly instead.
+// Matched against the Generic variant directly instead of a const
+// (FontFamily holds a raw pointer).
 fn is_system_ui(f: &FontFamily) -> bool {
     matches!(f, FontFamily::Generic(GenericFontFamily::SystemUi))
 }
@@ -1159,11 +1147,10 @@ fn compatible_font_family(
     }
 
     if let Some(families) = family.as_mut() {
-        // PORT NOTE: Zig (font.zig:1029-1035) iterates `families.sliceConst()`
-        // by value while inserting into `families` mid-loop, then `break`s.
-        // In Rust the immutable slice borrow would alias the &mut needed for
-        // `insert` (and `insert` may reallocate, invalidating the iterator).
-        // Reshape: capture the system-ui index first, drop the borrow, then
+        // Iterating the slice while inserting into `families` mid-loop would
+        // alias the &mut needed for `insert` (and `insert` may reallocate,
+        // invalidating the iterator).
+        // Capture the system-ui index first, drop the borrow, then
         // perform the inserts using the captured index.
         if let Some(i) = families.slice_const().iter().position(is_system_ui) {
             for (j, name) in DEFAULT_SYSTEM_FONTS.iter().enumerate() {
@@ -1193,5 +1180,3 @@ fn is_font_property(property_id: &crate::properties::PropertyId) -> bool {
             | PropertyId::Font
     )
 }
-
-// ported from: src/css/properties/font.zig
diff --git a/src/css/properties/generate_properties.ts b/src/css/properties/generate_properties.ts
index 5bda2f67bb5..19fc43ebfc4 100644
--- a/src/css/properties/generate_properties.ts
+++ b/src/css/properties/generate_properties.ts
@@ -1529,14 +1529,14 @@ generateCode({
   // cursor: {
   //   ty: "Cursor",
   // },
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // "caret-color": {
   //   ty: "ColorOrAuto",
   // },
   // "caret-shape": {
   //   ty: "CaretShape",
   // },
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // caret: {
   //   ty: "Caret",
   //   shorthand: true,
@@ -1573,7 +1573,7 @@ generateCode({
     conditional: { css_modules: true },
     parse_dont_make_unparsed: true,
   },
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // fill: {
   //   ty: "SVGPaint",
   // },
@@ -1583,7 +1583,7 @@ generateCode({
   // "fill-opacity": {
   //   ty: "AlphaValue",
   // },
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // stroke: {
   //   ty: "SVGPaint",
   // },
@@ -1752,12 +1752,12 @@ generateCode({
     unprefixed: false,
   },
 
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // filter: {
   //   ty: "FilterList",
   //   valid_prefixes: ["webkit"],
   // },
-  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.zig :)
+  // TODO: Hello future Zack, if you uncomment this, remember to uncomment the corresponding value in FallbackHandler in prefix_handler.rs :)
   // "backdrop-filter": {
   //   ty: "FilterList",
   //   valid_prefixes: ["webkit"],
diff --git a/src/css/properties/grid.rs b/src/css/properties/grid.rs
index 7ea72033c05..b761b969986 100644
--- a/src/css/properties/grid.rs
+++ b/src/css/properties/grid.rs
@@ -9,7 +9,6 @@ use bun_core::strings;
 
 /// A [track sizing](https://drafts.csswg.org/css-grid-2/#track-sizing) value
 /// for the `grid-template-rows` and `grid-template-columns` properties.
-// TODO(port): css.DeriveParse / css.DeriveToCss → #[derive(Parse, ToCss)] proc-macro
 pub enum TrackSizing {
     /// No explicit grid tracks.
     None,
@@ -39,7 +38,6 @@ impl TrackList {
 
             if let Ok(track_size) = input.try_parse(TrackSize::parse) {
                 // TODO: error handling
-                // TODO(port): Zig original omits arena arg here (`items.append(.{...})`); mirroring with input.arena()
                 items.push(TrackListItem::TrackSize(track_size));
             } else if let Ok(repeat) = input.try_parse(TrackRepeat::parse) {
                 // TODO: error handling
@@ -142,7 +140,6 @@ impl TrackSize {
 
         input.expect_function_matching(b"fit-content")?;
 
-        // TODO(port): css.voidWrap(LengthPercentage, LengthPercentage.parse) — wraps a parse fn for parseNestedBlock; using a closure directly
         let len = input.parse_nested_block(|i: &mut Parser| LengthPercentage::parse(i))?;
 
         Ok(TrackSize::FitContent(len))
@@ -289,13 +286,10 @@ impl TrackRepeat {
         input.expect_function_matching(b"repeat")?;
 
         input.parse_nested_block(|i: &mut Parser| -> css::Result<TrackRepeat> {
-            // TODO(port): Zig uses `@call(.auto, @field(RepeatCount, "parse"), .{i})` — direct call here
             let count = RepeatCount::parse(i)?;
 
             i.expect_comma()?;
 
-            // TODO: this code will not compile if used
-            // TODO(port): Zig calls `bun.Vec(T).init(i.arena)` — using default + push(alloc, ..) here
             let mut line_names = Vec::<CustomIdentList>::default();
             let mut track_sizes = Vec::<TrackSize>::default();
 
@@ -305,7 +299,7 @@ impl TrackRepeat {
                     .unwrap_or_else(|_| CustomIdentList::default());
                 line_names.push(line_name);
 
-                // TODO(port): Zig original references outer `input` here (likely a bug); mirroring with `i`
+                // Use the nested parser `i`, not the outer `input`.
                 if let Ok(track_size) = i.try_parse(TrackSize::parse) {
                     // TODO: error handling
                     track_sizes.push(track_size);
@@ -391,7 +385,7 @@ fn parse_line_names(input: &mut Parser) -> css::Result<CustomIdentList> {
     input.parse_nested_block(|i: &mut Parser| -> css::Result<CustomIdentList> {
         let mut values = CustomIdentList::default();
 
-        // TODO(port): Zig original references outer `input` here (likely a bug); mirroring with `i`
+        // Use the nested parser `i`, not the outer `input`.
         while let Ok(ident) = i.try_parse(CustomIdent::parse) {
             values.append(ident);
         }
@@ -404,7 +398,6 @@ fn parse_line_names(input: &mut Parser) -> css::Result<CustomIdentList> {
 /// used in the `repeat()` function.
 ///
 /// See [TrackRepeat](TrackRepeat).
-// TODO(port): css.DeriveParse / css.DeriveToCss → #[derive(Parse, ToCss)] proc-macro
 #[derive(PartialEq, Eq)]
 pub enum RepeatCount {
     /// The number of times to repeat.
@@ -416,8 +409,8 @@ pub enum RepeatCount {
 }
 
 impl RepeatCount {
-    // PORT NOTE: `css.DeriveParse(@This()).parse` — hand-expanded in declaration
-    // order (Number → keyword `auto-fill` → keyword `auto-fit`).
+    // Variants tried in declaration order (Number → keyword `auto-fill` →
+    // keyword `auto-fit`).
     pub fn parse(input: &mut Parser) -> css::Result<Self> {
         if let Ok(n) = input.try_parse(CSSIntegerFns::parse) {
             return Ok(RepeatCount::Number(n));
@@ -433,7 +426,6 @@ impl RepeatCount {
         Err(location.new_unexpected_token_error(css::Token::Ident(ident)))
     }
 
-    // PORT NOTE: `css.DeriveToCss(@This()).toCss` — hand-expanded.
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
         match self {
             RepeatCount::Number(n) => CSSIntegerFns::to_css(*n, dest),
@@ -454,7 +446,7 @@ pub enum GridTemplateAreas {
         columns: u32,
         /// A flattened list of grid area names.
         /// Unnamed areas specified by the `.` token are represented as null.
-        // TODO(port): arena-owned slice lifetime — Zig `?[]const u8` in CSS arena
+        // TODO: arena-owned slice lifetime — should be `Option<&'bump [u8]>`
         areas: SmallList<Option<*const [u8]>, 1>,
     },
 }
@@ -472,7 +464,7 @@ impl GridTemplateAreas {
         let mut row: u32 = 0;
         let mut columns: u32 = 0;
 
-        // PORT NOTE: `expect_string` returns a slice borrowing `&mut self`, which
+        // `expect_string` returns a slice borrowing `&mut self`, which
         // `try_parse`'s `R` type param can't carry. Erase the lifetime through a
         // raw pointer inside the closure; the slice lives in the input arena and
         // outlives this parse.
@@ -483,7 +475,6 @@ impl GridTemplateAreas {
             let parsed_columns = match Self::parse_string(input.arena(), s, &mut tokens) {
                 Ok(v) => v,
                 Err(()) => {
-                    // TODO(port): Zig uses `.{input.newError(.qualified_rule_invalid)}` — anonymous struct shorthand; mapping to Err(..)
                     return Err(input.new_error(css::BasicParseErrorKind::qualified_rule_invalid));
                 }
             };
@@ -529,8 +520,11 @@ impl GridTemplateAreas {
             column += 1;
 
             if strings::starts_with_char(rest, b'.') {
-                // TODO(port): Zig original falls through here without `continue` — likely a bug (the `.` token
-                // is supposed to push None and continue). Mirroring Zig control flow exactly.
+                // TODO: this intentionally falls through without `continue`,
+                // which is likely a bug (per upstream lightningcss, a `.`
+                // null-cell token should push None and continue; as written,
+                // any string containing `.` fails the name-codepoint check
+                // below and the whole value fails to parse).
             }
 
             let starts_with_name_codepoint = 'brk: {
@@ -553,7 +547,7 @@ impl GridTemplateAreas {
                 rest.len()
             };
             let token = &rest[..token_len];
-            // TODO(port): arena-owned slice — Zig stores borrowed slice into SmallList; using raw ptr here
+            // TODO: arena-owned slice — should store a borrowed slice into SmallList; using raw ptr here
             let _ = bump;
             tokens.append(Some(std::ptr::from_ref::<[u8]>(token)));
             string = &rest[token_len..];
@@ -574,5 +568,3 @@ fn is_name_codepoint(c: u8) -> bool {
 }
 
 crate::css_eql_partialeq!(TrackSize, RepeatCount);
-
-// ported from: src/css/properties/grid.zig
diff --git a/src/css/properties/list.rs b/src/css/properties/list.rs
index bbc9f7cc9f0..8b137891791 100644
--- a/src/css/properties/list.rs
+++ b/src/css/properties/list.rs
@@ -1 +1 @@
-// ported from: src/css/properties/list.zig
+
diff --git a/src/css/properties/margin_padding.rs b/src/css/properties/margin_padding.rs
index d335107cb74..44369ee5edd 100644
--- a/src/css/properties/margin_padding.rs
+++ b/src/css/properties/margin_padding.rs
@@ -6,8 +6,7 @@ use crate::properties::{Property, PropertyId, PropertyIdTag};
 use crate::{DeclarationList, PropertyHandlerContext};
 use bun_alloc::ArenaVecExt as _;
 
-// `RectShorthand`/`SizeShorthand` mirror Zig's `css.DefineRectShorthand` /
-// `css.DefineSizeShorthand` comptime mixins. The marker traits stay (some
+// The `RectShorthand`/`SizeShorthand` marker traits stay (some
 // callers name `<T as RectShorthand>::Value`). The rect-shorthand structs
 // below are stamped out by `define_rect_shorthand!` (struct + PROPERTY_FIELD_MAP
 // + deep_clone/eql + parse/to_css + RectShorthand impl); the size-shorthand
@@ -71,11 +70,8 @@ impl_size_shorthand!(
 // Shorthand value types
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig used `css.DefineRectShorthand(@This(), V)` / `css.DefineSizeShorthand(@This(), V)`
-// as comptime mixins that inject `parse` + `toCss`. In Rust those become trait
-// impls (`RectShorthand` / `SizeShorthand`) that provide default `parse`/`to_css`.
-// The trait comes first (PORTING.md §Comptime reflection); a `#[derive]` could
-// replace the manual impls.
+// Trait impls (`RectShorthand` / `SizeShorthand`) provide default
+// `parse`/`to_css`. A `#[derive]` could replace the manual impls.
 //
 // `implementDeepClone` / `implementEql` are field-wise reflection helpers →
 // `#[derive(Clone, PartialEq)]`; the `DeepClone`/`CssEql` trait impls are
@@ -83,8 +79,8 @@ impl_size_shorthand!(
 //
 // `PropertyFieldMap` (an anonymous struct mapping field-name → PropertyIdTag)
 // becomes an associated const slice; consumers that did `@field(map, name)`
-// will look up by name. // TODO(port): if consumers need O(1) by-field access,
-// switch to per-type associated consts.
+// will look up by name. (If consumers ever need O(1) by-field access, this
+// could switch to per-type associated consts.)
 
 define_rect_shorthand! {
     /// A value for the [inset](https://drafts.csswg.org/css-logical/#propdef-inset) shorthand property.
@@ -361,27 +357,19 @@ pub type ScrollMarginHandler = SizeHandler<ScrollMarginSpec>;
 pub type InsetHandler = SizeHandler<InsetSpec>;
 
 // ──────────────────────────────────────────────────────────────────────────
-// NewSizeHandler — Zig `fn(comptime ...) type { return struct { ... } }`
+// SizeHandler
 // ──────────────────────────────────────────────────────────────────────────
 //
-// The Zig generator took 11 `comptime PropertyIdTag` parameters, a
-// `comptime PropertyCategory`, and an optional `{feature, shorthand_feature}`
-// pair, and used `@field` / `@tagName` / `@unionInit` to project in/out of
-// the `Property` tagged union by tag name at compile time.
+// The per-variant projection in/out of the `Property` tagged union lives in
+// a `SizeHandlerSpec` trait. The generic body (`handle_property` / `flush` /
+// helpers) calls through `S::*`. Each concrete handler is a zero-sized
+// marker type implementing the spec.
 //
-// Rust cannot reflect on enum variants by `PropertyIdTag` value, so the
-// per-variant projection is moved into a `SizeHandlerSpec` trait. The
-// generic body (`handle_property` / `flush` / helpers) is preserved 1:1 and
-// calls through `S::*`. Each concrete handler is a zero-sized marker type
-// implementing the spec.
-//
-// TODO(port): a `macro_rules! size_handler_spec!` could generate the four
-// `SizeHandlerSpec` impls from the same 13-argument table the Zig used,
-// eliminating the per-spec extract/construct boilerplate. Left explicit for
-// reviewability.
+// A macro could generate the four `SizeHandlerSpec` impls from a single
+// argument table, eliminating the per-spec extract/construct boilerplate.
+// Left explicit for reviewability.
 
-/// Selector for the four physical slots on `SizeHandler` (Zig used a
-/// `comptime field: []const u8` and `@field(this, field)`).
+/// Selector for the four physical slots on `SizeHandler`.
 #[derive(Copy, Clone)]
 enum PhysicalSlot {
     Top,
@@ -400,12 +388,8 @@ enum LogicalSlot {
 }
 
 /// Compile-time configuration for one `SizeHandler` instantiation.
-///
-/// Replaces the 13 `comptime` parameters of Zig's `NewSizeHandler` and the
-/// `@field(property, @tagName(X_prop))` / `@unionInit(Property, @tagName(X_prop), v)`
-/// reflection it performed.
 pub trait SizeHandlerSpec {
-    // ---- comptime tag parameters ----
+    // ---- tag parameters ----
     const TOP: PropertyIdTag;
     const BOTTOM: PropertyIdTag;
     const LEFT: PropertyIdTag;
@@ -417,7 +401,7 @@ pub trait SizeHandlerSpec {
     const SHORTHAND: PropertyIdTag;
     const BLOCK_SHORTHAND: PropertyIdTag;
     const INLINE_SHORTHAND: PropertyIdTag;
-    // PORT NOTE: `PropertyId` mirrors of TOP/BOTTOM/LEFT/RIGHT for
+    // `PropertyId` mirrors of TOP/BOTTOM/LEFT/RIGHT for
     // `UnparsedProperty::with_property_id`. All margin/padding/inset/scroll-*
     // `PropertyId` variants are payload-free, so these are well-formed consts.
     const TOP_ID: PropertyId;
@@ -425,30 +409,30 @@ pub trait SizeHandlerSpec {
     const LEFT_ID: PropertyId;
     const RIGHT_ID: PropertyId;
     const SHORTHAND_CATEGORY: PropertyCategory;
-    /// `shorthand_extra.?.feature` — `None` ⇔ Zig passed `null`.
+    /// Optional prefix feature for the shorthand.
     const FEATURE: Option<Feature>;
     /// `shorthand_extra.?.shorthand_feature`.
     const SHORTHAND_FEATURE: Option<Feature>;
 
-    // ---- value-type bindings (Zig: `X_prop.valueType()`) ----
+    // ---- value-type bindings ----
     // In every instantiation in this file the longhand value type is
     // `LengthPercentageOrAuto`, so the generic body below uses that
     // concretely. If a future spec needs a different `valueType()`, lift it
     // to an associated type here.
 
-    /// Zig: `shorthand_prop.valueType()` (the 4-field rect struct).
+    /// The 4-field rect struct.
     type Shorthand;
-    /// Zig: `block_shorthand.valueType()` (the 2-field block struct).
+    /// The 2-field block struct.
     type BlockShorthand;
-    /// Zig: `inline_shorthand.valueType()` (the 2-field inline struct).
+    /// The 2-field inline struct.
     type InlineShorthand;
 
     // ---- @field / @unionInit replacements ----
     // Each pair is the Rust spelling of:
     //   `@field(property, @tagName(X_prop))`       → extract_x
     //   `@unionInit(Property, @tagName(X_prop), v)` → make_x
-    // TODO(port): these are pure mechanical pattern-matches over `Property`;
-    // could generate via macro.
+    // These are pure mechanical pattern-matches over `Property`; they could
+    // be generated via macro.
 
     fn extract_top(p: &Property) -> &LengthPercentageOrAuto;
     fn extract_bottom(p: &Property) -> &LengthPercentageOrAuto;
@@ -485,7 +469,7 @@ pub trait SizeHandlerSpec {
         inline_end: LengthPercentageOrAuto,
     ) -> Property;
 
-    // Field accessors on the shorthand value structs (Zig: `val.block_start` etc.).
+    // Field accessors on the shorthand value structs.
     fn shorthand_top(v: &Self::Shorthand) -> &LengthPercentageOrAuto;
     fn shorthand_right(v: &Self::Shorthand) -> &LengthPercentageOrAuto;
     fn shorthand_bottom(v: &Self::Shorthand) -> &LengthPercentageOrAuto;
@@ -497,8 +481,6 @@ pub trait SizeHandlerSpec {
 }
 
 /// Generic margin/padding/inset/scroll-* handler.
-///
-/// Zig: the anonymous `return struct { ... }` inside `NewSizeHandler`.
 pub struct SizeHandler<S: SizeHandlerSpec> {
     pub top: Option<LengthPercentageOrAuto>,
     pub bottom: Option<LengthPercentageOrAuto>,
@@ -531,7 +513,7 @@ impl<S: SizeHandlerSpec> Default for SizeHandler<S> {
     }
 }
 
-// PORT NOTE: `context.arena` was dropped from PropertyHandlerContext; the
+// `context.arena` was dropped from PropertyHandlerContext; the
 // arena is recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
 impl<S: SizeHandlerSpec> SizeHandler<S> {
     // ---- @field(this, field) replacements ----
@@ -574,10 +556,10 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         dest: &mut DeclarationList,
         context: &mut PropertyHandlerContext,
     ) -> bool {
-        // Zig: `switch (@as(PropertyIdTag, property.*))` — the *raw* union
-        // discriminant, ported as `Property::variant_tag()`. The `.unparsed`
-        // arm needs the inner `property_id` to decide whether the unparsed
-        // value belongs to this handler, so it stays a structural match.
+        // Match on the *raw* union discriminant (`Property::variant_tag()`).
+        // The `Unparsed` arm needs the inner `property_id` to decide whether
+        // the unparsed value belongs to this handler, so it stays a
+        // structural match.
         if let Property::Unparsed(unparsed) = property {
             let id = unparsed.property_id.tag();
             if id == S::TOP
@@ -674,8 +656,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
                 dest,
                 context,
             );
-            // PORT NOTE: Zig stored `property.deepClone(arena)`; reconstruct
-            // via the spec's `make_X(extract_X)` pair (same observable shape).
+            // Reconstruct via the spec's `make_X(extract_X)` pair.
             self.logical_property_helper(
                 LogicalSlot::BlockStart,
                 S::make_block_start(S::extract_block_start(property).clone()),
@@ -830,12 +811,11 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         self.flush(dest, context);
     }
 
-    // PORT NOTE: reshaped — Zig's single `flushHelper` (generic over `comptime field: []const u8`
-    // via `@field(this, field)`) is split into `flush_helper_physical` + `flush_helper_logical`
-    // because the physical slots hold `Option<LengthPercentageOrAuto>` and the logical slots hold
-    // `Option<Property>`; Rust cannot express `@field` over heterogeneous Option payloads generically.
+    // The flush helper is split into `flush_helper_physical` + `flush_helper_logical`
+    // because the physical slots hold `Option<LengthPercentageOrAuto>` and the
+    // logical slots hold `Option<Property>`.
 
-    /// Zig `flushHelper` for the four physical slots (`top`/`bottom`/`left`/`right`).
+    /// Flush helper for the four physical slots (`top`/`bottom`/`left`/`right`).
     fn flush_helper_physical(
         &mut self,
         field: PhysicalSlot,
@@ -844,7 +824,6 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         dest: &mut DeclarationList,
         context: &mut PropertyHandlerContext,
     ) {
-        // PERF(port): `category` was comptime monomorphization — profile if hot.
         // If the category changes betweet logical and physical,
         // or if the value contains syntax that isn't supported across all targets,
         // preserve the previous value as a fallback.
@@ -857,7 +836,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         }
     }
 
-    /// Zig `flushHelper` for the four logical slots (`block_start`/.../`inline_end`).
+    /// Flush helper for the four logical slots (`block_start`/.../`inline_end`).
     fn flush_helper_logical(
         &mut self,
         field: LogicalSlot,
@@ -866,7 +845,6 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         dest: &mut DeclarationList,
         context: &mut PropertyHandlerContext,
     ) {
-        // PERF(port): `category` was comptime monomorphization — profile if hot.
         // If the category changes betweet logical and physical,
         // or if the value contains syntax that isn't supported across all targets,
         // preserve the previous value as a fallback.
@@ -887,7 +865,6 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         dest: &mut DeclarationList,
         context: &mut PropertyHandlerContext,
     ) {
-        // PERF(port): `category` was comptime monomorphization — profile if hot.
         self.flush_helper_physical(field, val, category, dest, context);
         *self.physical_slot(field) = Some(val.clone());
         self.category = category;
@@ -908,8 +885,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
             self.flush(dest, context);
         }
 
-        // Zig: `if (@field(this, field)) |*p| p.deinit(context.arena);`
-        // Drop handles deinit; assigning over the Option drops the old value.
+        // Assigning over the Option drops the old value.
         *self.logical_slot(field) = Some(val);
         self.category = PropertyCategory::Logical;
         self.has_any = true;
@@ -998,8 +974,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
                 context,
             );
         } else if inline_start.is_some() || inline_end.is_some() {
-            // Zig: `inline_start.? == @field(Property, @tagName(inline_start_prop))`
-            // — raw union-tag equality, which is `false` for `.unparsed`.
+            // Raw union-tag equality, which is `false` for `Unparsed`.
             let start_matches = inline_start
                 .as_ref()
                 .map(|p| p.variant_tag() == S::INLINE_START)
@@ -1077,7 +1052,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         // _ = this; // autofix
         let bump = dest.bump();
         if let Some(v_) = val.as_ref() {
-            // Zig: `@as(css.PropertyIdTag, _v.*) == logical` — raw discriminant.
+            // Raw discriminant comparison.
             if v_.variant_tag() == logical {
                 let v = extract_logical(v_);
                 context.add_logical_rule(make_ltr(v.clone()), make_rtl(v.clone()));
@@ -1111,8 +1086,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
             LogicalSidePair::Inline => (S::INLINE_START, S::INLINE_END),
         };
 
-        // Zig: `@as(PropertyIdTag, start.*.?) == start_prop` — raw
-        // discriminant. `variant_tag()` keeps `Unparsed` distinct so an
+        // Raw discriminant comparison. `variant_tag()` keeps `Unparsed` distinct so an
         // unparsed longhand falls through to the else branch and is appended
         // as-is, instead of hitting `unreachable!()` in `extract_*`.
         if start
@@ -1125,9 +1099,7 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
                 .unwrap_or(false)
             && shorthand_supported
         {
-            // Zig built `value: ValueType` field-by-field then `@unionInit`.
-            // The Zig also `@compileError`ed if the value type had >2 fields;
-            // that invariant is upheld structurally by `make_*_shorthand`.
+            // The ≤2-field invariant is upheld structurally by `make_*_shorthand`.
             let start_v = match pair {
                 LogicalSidePair::Block => S::extract_block_start(start.as_ref().unwrap()).clone(),
                 LogicalSidePair::Inline => S::extract_inline_start(start.as_ref().unwrap()).clone(),
@@ -1165,11 +1137,10 @@ impl<S: SizeHandlerSpec> SizeHandler<S> {
         let _ = context;
         let bump = dest.bump();
         if let Some(v) = val.as_ref() {
-            // Zig: `@as(css.PropertyIdTag, v.*) == logical` — raw discriminant.
+            // Raw discriminant comparison.
             if v.variant_tag() == logical {
-                // Zig moved the payload (`@field(v, @tagName(logical))`) by value.
-                // PORT NOTE: reshaped for borrowck — clone instead of moving out
-                // of `&Property`; `LengthPercentageOrAuto` is small.
+                // Clone instead of moving out of `&Property`;
+                // `LengthPercentageOrAuto` is small.
                 dest.push(make_physical(extract_logical(v).clone()));
             } else if let Property::Unparsed(u) = v {
                 dest.push(Property::Unparsed(u.with_property_id(bump, physical)));
@@ -1188,11 +1159,9 @@ enum LogicalSidePair {
 // Spec instantiations
 // ──────────────────────────────────────────────────────────────────────────
 //
-// PORT NOTE: the `extract_*` / `make_*` / `shorthand_*` bodies are pure
-// `@field` / `@unionInit` token-pasting in Zig (`NewSizeHandler`).
-// `size_handler_spec_projections!` expands them from the 11 `Property`
-// variant idents + 3 shorthand value-type idents that the Zig
-// `NewSizeHandler(...)` call sites passed positionally.
+// `size_handler_spec_projections!` expands the `extract_*` / `make_*` /
+// `shorthand_*` bodies from the 11 `Property` variant idents + 3 shorthand
+// value-type idents.
 
 macro_rules! size_handler_spec_projections {
     (
@@ -1496,7 +1465,5 @@ impl SizeHandlerSpec for InsetSpec {
     );
 }
 
-// NOTE: Zig also defined `ScrollPadding{,Block,Inline}` value types above but
-// did NOT instantiate a `ScrollPaddingHandler` — matching that here.
-
-// ported from: src/css/properties/margin_padding.zig
+// NOTE: `ScrollPadding{,Block,Inline}` value types are defined above but no
+// `ScrollPaddingHandler` is instantiated.
diff --git a/src/css/properties/masking.rs b/src/css/properties/masking.rs
index 964188074ab..47b56d9bd74 100644
--- a/src/css/properties/masking.rs
+++ b/src/css/properties/masking.rs
@@ -28,8 +28,6 @@ use crate::properties::PropertyIdTag;
 
 /// A [`<geometry-box>`](https://www.w3.org/TR/css-masking-1/#typedef-geometry-box) value
 /// as used in the `mask-clip` and `clip-path` properties.
-// TODO(port): css.DefineEnumProperty(@This()) — comptime-generated eql/hash/parse/toCss/deepClone.
-// In Rust this becomes #[derive] of the css enum-property protocol (kebab-case serialization).
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum GeometryBox {
     /// The painted content is clipped to the content box.
@@ -75,8 +73,7 @@ pub enum BasicShape {
 }
 
 /// An [`inset()`](https://www.w3.org/TR/css-shapes-1/#funcdef-inset) rectangle shape.
-// Zig declares this `const` (file-private) but it's reachable via `pub enum BasicShape::Inset`,
-// so Rust requires `pub` here — Zig has no private-in-public lint.
+// Reachable via `pub enum BasicShape::Inset`, so it must be `pub`.
 pub struct InsetRect {
     /// The rectangle.
     pub rect: Rect<LengthPercentage>,
@@ -107,10 +104,9 @@ pub struct Polygon {
     /// The fill rule used to determine the interior of the polygon.
     pub fill_rule: FillRule,
     /// The points of each vertex of the polygon.
-    // TODO(port): css is an AST crate (§Allocators) — if Polygon is arena-fed this must become
+    // If Polygon ever becomes arena-fed this must become (§Allocators: AST crates are arena-fed)
     // `bun_alloc::ArenaVec<'bump, Point>` and Polygon/BasicShape/ClipPath gain `<'bump>`.
-    // No construction site exists in src/css/*.zig today, so provenance is unconfirmed; keeping
-    // plain Vec<Point> until the arena story is verified.
+    // Keeping plain Vec<Point> until the arena story is verified.
     pub points: Vec<Point>,
 }
 
@@ -136,7 +132,6 @@ pub struct Point {
 }
 
 /// A value for the [mask-mode](https://www.w3.org/TR/css-masking-1/#the-mask-mode) property.
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum MaskMode {
     /// The luminance values of the mask image is used.
@@ -152,11 +147,9 @@ pub enum MaskMode {
 }
 
 /// A value for the [mask-clip](https://www.w3.org/TR/css-masking-1/#the-mask-clip) property.
-// TODO(port): css.DeriveParse / css.DeriveToCss → derive css union-property protocol
 #[derive(Debug, Clone, Copy, PartialEq, Eq, css::Parse, css::ToCss)]
 pub enum MaskClip {
     /// A geometry box.
-    // Zig: @"geometry-box"
     GeometryBox(GeometryBox),
     /// The painted content is not clipped.
     #[css(name = "no-clip")]
@@ -164,7 +157,6 @@ pub enum MaskClip {
 }
 
 /// A value for the [mask-composite](https://www.w3.org/TR/css-masking-1/#the-mask-composite) property.
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum MaskComposite {
     /// The source is placed over the destination.
@@ -183,7 +175,6 @@ pub enum MaskComposite {
 }
 
 /// A value for the [mask-type](https://www.w3.org/TR/css-masking-1/#the-mask-type) property.
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum MaskType {
     /// The luminance values of the mask is used.
@@ -195,7 +186,7 @@ pub enum MaskType {
 }
 
 /// A value for the [mask](https://www.w3.org/TR/css-masking-1/#the-mask) shorthand property.
-// PORT NOTE: Debug/Clone/PartialEq derives gated on `Image`/`Position`/
+// Debug/Clone/PartialEq derives gated on `Image`/`Position`/
 // `BackgroundSize`/`BackgroundRepeat` gaining those derives upstream.
 #[cfg_attr(any(), derive(Debug, Clone, PartialEq))]
 #[derive(DeepClone, CssEql)]
@@ -219,9 +210,7 @@ pub struct Mask {
 }
 
 impl Mask {
-    // TODO(port): PropertyFieldMap was a Zig anon-struct const consumed by comptime
-    // reflection in shorthand handlers. Represented as an assoc const slice; could
-    // be replaced with a trait/derive.
+    // Shorthand field→property map, consumed by shorthand handlers.
     pub const PROPERTY_FIELD_MAP: &'static [(&'static str, PropertyIdTag)] = &[
         ("image", PropertyIdTag::MaskImage),
         ("position", PropertyIdTag::MaskPosition),
@@ -233,8 +222,7 @@ impl Mask {
         ("mode", PropertyIdTag::MaskMode),
     ];
 
-    // TODO(port): VendorPrefixMap was a Zig anon-struct const of bools consumed by
-    // comptime reflection. Represented as a field-name slice; could be replaced with trait/derive.
+    // Field names that carry a vendor prefix.
     pub const VENDOR_PREFIX_MAP: &'static [&'static str] =
         &["image", "position", "size", "repeat", "clip", "origin"];
 
@@ -373,7 +361,6 @@ impl Mask {
 }
 
 /// A value for the [mask-border-mode](https://www.w3.org/TR/css-masking-1/#the-mask-border-mode) property.
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum MaskBorderMode {
     /// The luminance values of the mask image is used.
@@ -386,7 +373,7 @@ pub enum MaskBorderMode {
 }
 
 /// A value for the [mask-border](https://www.w3.org/TR/css-masking-1/#the-mask-border) shorthand property.
-// PORT NOTE: Debug/Clone/PartialEq derives gated on `Image`/`Rect<_>` gaining
+// Debug/Clone/PartialEq derives gated on `Image`/`Rect<_>` gaining
 // those derives upstream.
 #[cfg_attr(any(), derive(Debug, Clone, PartialEq))]
 #[derive(DeepClone, CssEql)]
@@ -408,7 +395,7 @@ pub struct MaskBorder {
 impl MaskBorder {
     // (old using name space) css.DefineShorthand(@This(), css.PropertyIdTag.@"mask-border", PropertyFieldMap);
 
-    // TODO(port): PropertyFieldMap — see note on Mask::PROPERTY_FIELD_MAP
+    // See the PropertyFieldMap note on Mask::PROPERTY_FIELD_MAP.
     pub const PROPERTY_FIELD_MAP: &'static [(&'static str, PropertyIdTag)] = &[
         ("source", PropertyIdTag::MaskBorderSource),
         ("slice", PropertyIdTag::MaskBorderSlice),
@@ -431,7 +418,7 @@ impl MaskBorder {
         });
 
         if border_image.is_ok() || mode.is_some() {
-            // PERF(port): Zig used `comptime BorderImage.default()` — could const-eval the default
+            // PERF: could const-eval the default
             let bi = border_image.unwrap_or_else(|_| BorderImage::default());
             Ok(MaskBorder {
                 source: bi.source,
@@ -474,7 +461,6 @@ impl MaskBorder {
 /// property.
 ///
 /// See also [MaskComposite](MaskComposite).
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum WebKitMaskComposite {
     #[css(name = "clear")]
@@ -513,7 +499,6 @@ pub enum WebKitMaskComposite {
 /// property.
 ///
 /// See also [MaskMode](MaskMode).
-// TODO(port): css.DefineEnumProperty(@This()) → derive css enum-property protocol
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, css::Parse, css::ToCss)]
 pub enum WebKitMaskSourceType {
     /// Equivalent to `match-source` in the standard `mask-mode` syntax.
@@ -529,8 +514,6 @@ pub enum WebKitMaskSourceType {
 
 // blocked_on: PropertyId::WebKitMaskComposite variant name (codegen spelling is `WebKitMaskComposite`)
 pub fn get_webkit_mask_property(property_id: &PropertyId) -> Option<PropertyId> {
-    // TODO(port): PropertyId variant naming — Zig uses kebab-case @"mask-border-source" etc.
-    // Mapping to PascalCase variants here; verify exact PropertyId enum shape.
     match property_id {
         PropertyId::MaskBorderSource => Some(PropertyId::MaskBoxImageSource(VendorPrefix::WEBKIT)),
         PropertyId::MaskBorderSlice => Some(PropertyId::MaskBoxImageSlice(VendorPrefix::WEBKIT)),
@@ -543,5 +526,3 @@ pub fn get_webkit_mask_property(property_id: &PropertyId) -> Option<PropertyId>
         _ => None,
     }
 }
-
-// ported from: src/css/properties/masking.zig
diff --git a/src/css/properties/mod.rs b/src/css/properties/mod.rs
index 85ee46adb5f..b0013bfafa1 100644
--- a/src/css/properties/mod.rs
+++ b/src/css/properties/mod.rs
@@ -1,6 +1,4 @@
 //! CSS property definitions.
-//!
-//! Ported from `src/css/properties/properties.zig`.
 
 #![warn(unused_must_use)]
 
@@ -14,22 +12,8 @@
 // `PropertyId::set_prefixes_for_targets` / `from_name_and_prefix` and the
 // `Property` payloads that name `css_values::*` resolve directly.
 
-/// Declares a property-handler ZST with the `handle_property` / `finalize`
-/// surface that `DeclarationHandler` (declaration.rs) composes over. The
-/// real handler bodies live in the gated leaf .rs files; until those
-/// un-gate, these no-op stubs keep `DeclarationHandler` compiling against
-/// the now-real `Property` enum.
-///
-/// PORT NOTE: Zig handlers are plain structs with `handleProperty(*Self,
-/// *const Property, *DeclarationList, *PropertyHandlerContext) bool` +
-/// `finalize(*Self, *DeclarationList, *PropertyHandlerContext) void`. Same
-/// shape here; lifetimes on `DeclarationList<'bump>` / context are erased
-/// behind anonymous lifetimes since the stub bodies touch neither.
-
 // ─── Rect / Size shorthand impl + define macros ────────────────────────────
-// Shared by `border.rs` and `margin_padding.rs`. These are the Rust port of
-// Zig's `css.DefineRectShorthand` / `css.DefineSizeShorthand` comptime mixins
-// (src/css/css_parser.zig:502 / :532).
+// Shared by `border.rs` and `margin_padding.rs`.
 //
 // `impl_rect_shorthand!` / `impl_size_shorthand!` stamp out the inherent
 // `parse`/`to_css` pair (and the `generic::{Parse,ToCss}` forwarders) for a
@@ -95,8 +79,7 @@ macro_rules! define_rect_shorthand {
         }
 
         impl $name {
-            // TODO(port): bring this back
-            // (old using name space) css::DefineShorthand(@This(), PropertyIdTag::$shorthand_id);
+            // `PROPERTY_FIELD_MAP` records the shorthand field→property map.
 
             pub const PROPERTY_FIELD_MAP: &[(&str, $crate::properties::PropertyIdTag)] = &[
                 ("top", $crate::properties::PropertyIdTag::$top_id),
@@ -108,7 +91,7 @@ macro_rules! define_rect_shorthand {
         impl $crate::properties::margin_padding::RectShorthand for $name {
             type Value = $inner;
         }
-        // Zig `css.DefineRectShorthand(@This(), V)` — parse/to_css via `Rect<V>`.
+        // parse/to_css via `Rect<V>`.
         impl_rect_shorthand!($name, $inner);
     };
 }
@@ -140,7 +123,6 @@ macro_rules! impl_size_shorthand {
 }
 
 // ─── Submodule declarations ────────────────────────────────────────────────
-// (Zig: `pub const X = @import("./X.zig");`)
 //
 pub mod align;
 // `animation`: un-gated — real AnimationName / Animation / AnimationIterationCount /
@@ -174,7 +156,7 @@ pub mod font;
 pub mod grid;
 // `list`: un-gated — real ListStyleType / CounterStyle / Symbols / Symbol
 // live in `list.rs`. PredefinedCounterStyle / SymbolsType / ListStylePosition /
-// ListStyle / MarkerSide are uninhabited (Zig source is `@compileError`).
+// ListStyle / MarkerSide are uninhabited.
 pub mod list;
 pub mod margin_padding;
 pub mod masking;
@@ -215,8 +197,7 @@ pub use self::custom::CustomPropertyName;
 pub use self::properties_generated::{Property, PropertyId, PropertyIdTag};
 
 /// A [CSS-wide keyword](https://drafts.csswg.org/css-cascade-5/#defaulting-keywords).
-// Zig: `css.DefineEnumProperty(@This())` provides eql/hash/parse/toCss/deepClone via
-// comptime reflection over @tagName. The Rust derive emits `EnumProperty` +
+// The `DefineEnumProperty` derive emits `EnumProperty` +
 // `From<Self> for &'static str` + inherent `parse`/`to_css`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, crate::DefineEnumProperty)]
 pub enum CSSWideKeyword {
@@ -413,12 +394,3 @@ mod generic_registrations {
     }
 }
 pub(crate) use generic_registrations::GenericBorderImpl;
-
-// ─── Dead code (not ported) ────────────────────────────────────────────────
-// The original Zig file contains ~1800 lines of commented-out code (lines 60–1876)
-// implementing the old `DefineProperties(...)` comptime-reflection approach that
-// predates `properties_generated.zig`. It is dead reference material and is
-// intentionally omitted here. See `src/css/properties/properties.zig` for the
-// historical block; the live definitions come from `properties_generated`.
-
-// ported from: src/css/properties/properties.zig
diff --git a/src/css/properties/outline.rs b/src/css/properties/outline.rs
index 9f42cdc663a..746cb7af0c1 100644
--- a/src/css/properties/outline.rs
+++ b/src/css/properties/outline.rs
@@ -4,9 +4,6 @@ use super::border::{GenericBorder, LineStyle};
 pub(crate) type Outline = GenericBorder<OutlineStyle, 11>;
 
 /// A value for the [outline-style](https://drafts.csswg.org/css-ui/#outline-style) property.
-// `DeriveParse`/`DeriveToCss` in Zig are comptime-reflection helpers that iterate variants
-// to implement the domain protocol — in Rust the protocol is a trait and we derive it.
-// `implementEql`/`implementDeepClone` are field-iteration eq/clone → `#[derive(PartialEq, Clone)]`.
 #[derive(Clone, PartialEq, Eq, crate::Parse, crate::ToCss)]
 pub enum OutlineStyle {
     /// The `auto` keyword.
@@ -20,5 +17,3 @@ impl Default for OutlineStyle {
         OutlineStyle::LineStyle(LineStyle::None)
     }
 }
-
-// ported from: src/css/properties/outline.zig
diff --git a/src/css/properties/overflow.rs b/src/css/properties/overflow.rs
index f6613e7c245..5fa4e16ced0 100644
--- a/src/css/properties/overflow.rs
+++ b/src/css/properties/overflow.rs
@@ -29,8 +29,6 @@ impl Overflow {
 
 /// An [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) keyword
 /// as used in the `overflow-x`, `overflow-y`, and `overflow` properties.
-// PORT NOTE: css.DefineEnumProperty(@This()) — comptime mixin providing
-// eql/hash/parse/to_css/deep_clone from @tagName.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, crate::DefineEnumProperty)]
 pub enum OverflowKeyword {
     /// Overflowing content is visible.
@@ -53,5 +51,3 @@ pub enum TextOverflow {
     /// Overflowing text is truncated with an ellipsis.
     Ellipsis,
 }
-
-// ported from: src/css/properties/overflow.zig
diff --git a/src/css/properties/position.rs b/src/css/properties/position.rs
index 944b2bc6d9e..6fb463a7517 100644
--- a/src/css/properties/position.rs
+++ b/src/css/properties/position.rs
@@ -28,8 +28,7 @@ enum PositionKeyword {
 }
 
 fn lookup_keyword(ident: &[u8]) -> Option<PositionKeyword> {
-    // ≤8 entries → plain match per PORTING.md (Zig: `bun.ComptimeEnumMap` +
-    // `getASCIIICaseInsensitive`).
+    // ≤8 entries → plain match.
     use bun_core::eql_case_insensitive_ascii_check_length as eq;
     Some(if eq(ident, b"static") {
         PositionKeyword::Static
@@ -80,5 +79,3 @@ impl Position {
         }
     }
 }
-
-// ported from: src/css/properties/position.zig
diff --git a/src/css/properties/prefix_handler.rs b/src/css/properties/prefix_handler.rs
index e3bebada314..77b8be3291b 100644
--- a/src/css/properties/prefix_handler.rs
+++ b/src/css/properties/prefix_handler.rs
@@ -9,7 +9,7 @@ use bun_alloc::ArenaVecExt as _;
 pub struct FallbackHandler {
     pub color: Option<usize>,
     pub text_shadow: Option<usize>,
-    // TODO: add these back plz
+    // The remaining fallback fields are not implemented yet.
     // filter: Option<usize>,
     // backdrop_filter: Option<usize>,
     // fill: Option<usize>,
@@ -25,22 +25,15 @@ impl FallbackHandler {
         dest: &mut css::DeclarationList,
         context: &mut css::PropertyHandlerContext,
     ) -> bool {
-        // The Zig source does `inline for (std.meta.fields(FallbackHandler))` and uses
-        // `@field` / `@unionInit` keyed on the field name. Rust has no field reflection,
-        // so we expand each (field, Property variant, has_vendor_prefix) pair via macro.
-        // TODO(port): proc-macro — if the field list grows, generate these arms from a
-        // single source of truth shared with `Property`/`PropertyIdTag`.
+        // Each (field, Property variant, has_vendor_prefix) pair is expanded via macro.
 
         let arena = dest.bump();
 
-        // PORT NOTE: Zig's `inline for` over `std.meta.fields(FallbackHandler)` dispatched
-        // each (field, Property variant) pair via a single generic body using `@field` /
-        // `@unionInit` + `css.generic.{deepClone,isCompatible,hasGetFallbacks}`. Rust has
-        // no field reflection and the generic-trait surface (`DeepClone`/`IsCompatible`/
-        // `get_fallbacks` on `SmallList<TextShadow,1>`) is still partially gated, so we
-        // expand each pair via a macro that takes per-type closures for those three ops.
-        // This keeps the *control flow* identical while letting each payload type use its
-        // own inherent methods until the trait lattice un-gates.
+        // The generic-trait surface (`DeepClone`/`IsCompatible`/`get_fallbacks`
+        // on `SmallList<TextShadow,1>`) is still partially gated, so each
+        // (field, Property variant) pair is expanded via a macro that takes
+        // per-type closures for those three ops. This lets each payload type
+        // use its own inherent methods until the trait lattice un-gates.
         macro_rules! handle_unprefixed {
             (
                 $self_field:ident,
@@ -53,7 +46,7 @@ impl FallbackHandler {
                     let mut val = ($dc)(payload, arena);
 
                     if $self_field.is_none() {
-                        // PORT NOTE: `has_fallbacks` only used in the vendor-prefixed branch in Zig.
+                        // `has_fallbacks` is only consulted in the vendor-prefixed branch.
                         ($fb)(&mut val, arena, &context.targets, dest);
                     }
 
@@ -66,7 +59,7 @@ impl FallbackHandler {
                     } else if let Some(index) = *$self_field {
                         dest[index] = Property::$Variant(val);
                     } else {
-                        // val dropped — Rust Drop handles cleanup (Zig: val.deinit(context.arena))
+                        // val dropped — Drop handles cleanup
                         drop(val);
                     }
 
@@ -75,7 +68,7 @@ impl FallbackHandler {
             };
         }
 
-        // PORT NOTE: reshaped for borrowck — pre-borrow each self.<field> as &mut so the
+        // Reshaped for borrowck — pre-borrow each self.<field> as &mut so the
         // macro body can both read and assign it without re-borrowing `self`.
         let this = &mut *self;
         let color = &mut this.color;
@@ -138,11 +131,7 @@ impl FallbackHandler {
                 return false;
             };
 
-            // TODO(port): re-enable once `PropertyHandlerContext::add_unparsed_fallbacks`
-            // un-gates (blocked on `SupportsCondition::eql` in context.rs).
-
             context.add_unparsed_fallbacks(arena, &mut unparsed);
-            let _ = &mut unparsed;
             if let Some(i) = *index {
                 dest[i] = Property::Unparsed(unparsed);
             } else {
@@ -161,10 +150,7 @@ impl FallbackHandler {
         _dest: &mut css::DeclarationList,
         _context: &mut css::PropertyHandlerContext,
     ) {
-        // Zig: inline for (std.meta.fields(FallbackHandler)) |f| @field(this, f.name) = null;
         self.color = None;
         self.text_shadow = None;
     }
 }
-
-// ported from: src/css/properties/prefix_handler.zig
diff --git a/src/css/properties/properties_generated.rs b/src/css/properties/properties_generated.rs
index 9777c271783..11121aae21f 100644
--- a/src/css/properties/properties_generated.rs
+++ b/src/css/properties/properties_generated.rs
@@ -1,9 +1,9 @@
-// This file is autogenerated by generate_properties.ts. DO NOT EDIT!
-// (Rust emitter: generated from src/css/properties/properties_generated.zig)
+// Hand-maintained. Note: generate_properties.ts (`bun run css-properties`)
+// does not write this file — edits here are safe and will not be clobbered.
 //
-// PORT NOTE: type paths below resolve against `super::*` (the leaf property
+// Type paths below resolve against `super::*` (the leaf property
 // modules — currently data-only stub bodies in `mod.rs`) and
-// `crate::css_values`, matching the Zig prelude in properties_generated.zig.
+// `crate::css_values`.
 
 #![allow(non_camel_case_types)]
 
@@ -41,7 +41,7 @@ use super::transform;
 use super::transition;
 use super::ui;
 
-/// Discriminant-only tag for [`Property`] / [`PropertyId`] (Zig: `enum(u16)`).
+/// Discriminant-only tag for [`Property`] / [`PropertyId`].
 #[repr(u16)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum PropertyIdTag {
@@ -298,7 +298,7 @@ pub enum PropertyIdTag {
 
 impl PropertyIdTag {
     /// Whether the corresponding `Property` payload carries a `VendorPrefix`
-    /// (i.e. is a `(T, VendorPrefix)` tuple in the Zig union).
+    /// (i.e. is a `(T, VendorPrefix)` tuple).
     pub const fn has_vendor_prefix(self) -> bool {
         matches!(
             self,
@@ -423,7 +423,7 @@ impl PropertyIdTag {
         })
     }
 
-    /// Kebab-case CSS property name (Zig: `@tagName(PropertyIdTag)`).
+    /// Kebab-case CSS property name.
     pub const fn name(self) -> &'static [u8] {
         match self {
             PropertyIdTag::BackgroundColor => b"background-color",
@@ -682,8 +682,8 @@ impl PropertyIdTag {
 /// A known CSS property name + (for prefixable properties) the vendor
 /// prefix it was parsed with. Variants without payload are unprefixed.
 //
-// PORT NOTE: do NOT `#[derive(PartialEq, Eq)]` here — the spec-correct
-// equality (Zig `PropertyId.eql`, properties_generated.zig:9195) ignores the
+// Do NOT `#[derive(PartialEq, Eq)]` here — the spec-correct
+// equality ignores the
 // `Custom(CustomPropertyName)` payload and is hand-written below. A derived
 // impl would (a) conflict (E0119) and (b) diverge by comparing custom-name
 // bytes.
@@ -940,15 +940,14 @@ pub enum PropertyId {
     Custom(CustomPropertyName),
 }
 
-// PORT NOTE: Zig `PropertyId.eql()` (properties_generated.zig:9195) compares the
-// tag, then *only* compares the payload when its type is `VendorPrefix` — for
-// `.custom` (whose payload is `CustomPropertyName`) and all unit/void variants
-// it returns `true` on tag match alone. A derived `PartialEq` would compare the
-// `CustomPropertyName` bytes, diverging from the spec (observable in
-// `rules/style.zig:isDuplicate`). `prefix()` already returns the `VendorPrefix`
-// payload for the 65 prefixed variants and `VendorPrefix::empty()` for every
-// other variant (including `Custom`/`All`/`Unparsed`), so `tag` + `prefix`
-// equality is exactly the Zig semantics.
+// `PropertyId` equality compares the tag, then *only* compares the payload
+// when its type is `VendorPrefix` — for `Custom` (whose payload is
+// `CustomPropertyName`) and all unit variants it returns `true` on tag match
+// alone. A derived `PartialEq` would compare the `CustomPropertyName` bytes,
+// diverging from the duplicate-detection semantics in `rules/style.rs`.
+// `prefix()` already returns the `VendorPrefix` payload for the 65 prefixed
+// variants and `VendorPrefix::empty()` for every other variant (including
+// `Custom`/`All`/`Unparsed`), so `tag` + `prefix` equality is exactly that.
 impl PartialEq for PropertyId {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -958,8 +957,8 @@ impl PartialEq for PropertyId {
 
 impl Eq for PropertyId {}
 
-// PORT NOTE: Zig `PropertyId.hash()` (properties_generated.zig:9209) hashes only
-// the tag discriminant so PropertyId can key a hash map consistent with `eql`.
+// Hash only the tag discriminant so PropertyId can key a hash map
+// consistent with `eq`.
 impl core::hash::Hash for PropertyId {
     #[inline]
     fn hash<H: core::hash::Hasher>(&self, h: &mut H) {
@@ -1223,9 +1222,6 @@ impl PropertyId {
     }
 
     /// Returns the property name, without any vendor prefixes.
-    ///
-    /// Mirrors Zig `PropertyId.name()` (properties_generated.zig:7674), which is
-    /// literally `if (.custom) return custom.asStr(); return @tagName(this.*);`.
     pub fn name(&self) -> &[u8] {
         match self {
             PropertyId::Custom(c) => c.as_str(),
@@ -1347,8 +1343,8 @@ impl PropertyId {
     /// isn't allowed for that property.
     pub fn from_name_and_prefix(name: &[u8], pre: VendorPrefix) -> Option<PropertyId> {
         use bun_core::strings;
-        // PORT NOTE: Zig used a comptime perfect-hash map; linear scan here is
-        // a placeholder — replace with a phf / match-on-len when un-gated.
+        // PERF: the linear scan here is correct but slow — a phf /
+        // match-on-len would be an optimization.
         if strings::eql_case_insensitive_ascii_check_length(name, b"background-color") {
             let allowed: VendorPrefix = VendorPrefix::NONE;
             if allowed.intersects(pre) {
@@ -3133,7 +3129,7 @@ impl PropertyId {
 
 /// A parsed CSS declaration value, tagged by [`PropertyIdTag`]. Prefixed
 /// properties carry `(value, VendorPrefix)`.
-// PORT NOTE: no `#[derive(Clone)]` — several `css_values::*` payloads
+// No `#[derive(Clone)]` — several `css_values::*` payloads
 // (Image, Size2D, Rect, SmallList) intentionally lack `Clone` and use
 // `deep_clone(&Arena)` instead. `Property::deep_clone` is the public API.
 pub enum Property {
@@ -6194,21 +6190,13 @@ impl Property {
 
     /// Returns the given longhand property for a shorthand.
     ///
-    /// PORT NOTE: in Zig (`properties_generated.zig:7087-7160`) each arm
-    /// dispatches to `v.longhand(property_id)` where the per-type `longhand`
-    /// is provided by `DefineShorthand`, whose body is
-    /// `@compileError(todo_stuff.depth)`. Zig only instantiates
-    /// `Property.longhand` when referenced (it isn't), so the @compileError
-    /// never fires. Rust type-checks eagerly, so the per-arm dispatch is
-    /// routed through a no-op `lh!` that mirrors the Zig fallthrough
-    /// (`return null`) until the `DefineShorthand` derive is ported. There
-    /// are no callers.
-    // blocked_on: shorthand_handler_port — leaf shorthand types lack `.longhand()` (Zig body is `@compileError(todo_stuff.depth)`, .zig:7087-7160)
+    /// Per-type `longhand` is not implemented yet, so the per-arm dispatch is
+    /// routed through a no-op `lh!` (`return None`) until the
+    /// `DefineShorthand` derive exists. There are no callers.
+    // blocked_on: shorthand_handler_port — leaf shorthand types lack `.longhand()`
     pub fn longhand(&self, property_id: &PropertyId) -> Option<Property> {
         #[inline(always)]
         fn lh<T: ?Sized>(_v: &T, _id: &PropertyId) -> Option<Property> {
-            // PORT NOTE: per-type `v.longhand(property_id)` is
-            // `@compileError(todo_stuff.depth)` in Zig and never instantiated.
             // Trip in debug so callers can't accidentally rely on the
             // always-`None` placeholder before `DefineShorthand::longhand`
             // is ported.
@@ -6303,7 +6291,7 @@ impl Property {
         }
     }
 
-    // blocked_on: leaf_value_traits — un-gate once every payload type impls `generics::DeepClone` (.zig:6307-6558)
+    // blocked_on: leaf_value_traits — un-gate once every payload type impls `generics::DeepClone`
     pub fn deep_clone(&self, arena: &bun_alloc::Arena) -> Property {
         match self {
             Property::BackgroundColor(v) => {
@@ -6880,7 +6868,7 @@ impl Property {
         }
     }
 
-    // blocked_on: leaf_value_traits — un-gate once every payload type impls `generics::CssEql` (.zig:7162-7415)
+    // blocked_on: leaf_value_traits — un-gate once every payload type impls `generics::CssEql`
     pub fn eql(&self, other: &Property) -> bool {
         match (self, other) {
             (Property::BackgroundColor(a), Property::BackgroundColor(b)) => css::generic::eql(a, b),
@@ -7411,15 +7399,14 @@ impl Property {
     }
 }
 
-// PORT NOTE: `declaration::placeholder_property()` (the moved-out slot
-// sentinel in `DeclarationBlock::minify`) is `Property{ .all = .revert-layer }`
-// in Zig. Expose it via `Default` so the un-gated stub branch in
-// `declaration.rs` keeps compiling against the real enum.
+// `declaration::placeholder_property()` (the moved-out slot
+// sentinel in `DeclarationBlock::minify`) is
+// `Property::All(CSSWideKeyword::RevertLayer)`. Expose it via `Default` so
+// the un-gated stub branch in `declaration.rs` keeps compiling against the
+// real enum.
 impl Default for Property {
     #[inline]
     fn default() -> Self {
         Property::All(CSSWideKeyword::RevertLayer)
     }
 }
-
-// ported from: src/css/properties/properties_generated.zig
diff --git a/src/css/properties/properties_impl.rs b/src/css/properties/properties_impl.rs
index aa1295dd1a5..f3c05519931 100644
--- a/src/css/properties/properties_impl.rs
+++ b/src/css/properties/properties_impl.rs
@@ -15,8 +15,8 @@ impl Property {
     /// an `Unparsed` declaration always returns `PropertyIdTag::Unparsed`, and
     /// a `Custom` declaration always returns `PropertyIdTag::Custom`.
     ///
-    /// This mirrors Zig's `@as(PropertyIdTag, property.*)` (a raw union-tag
-    /// coercion). Handlers that switch on the discriminant to project a parsed
+    /// This is a raw discriminant lookup.
+    /// Handlers that switch on the discriminant to project a parsed
     /// payload — e.g. `SizeHandler` in `margin_padding.rs` — must use this so
     /// an unparsed `margin-top: var(--x)` does not route into the parsed
     /// `MarginTop` arm and panic in `extract_top`.
@@ -32,10 +32,10 @@ impl Property {
     }
 }
 
-/// Ordered single-bit prefix flags for the `inline for (VendorPrefix.FIELDS)`
-/// Zig idiom. The crate-root `VendorPrefix::FIELDS` is a `&[&str]` name list;
-/// the to_css loops here need the bitflag values directly, in Zig declaration
-/// order (webkit, moz, ms, o, none).
+/// Ordered single-bit prefix flags. The crate-root `VendorPrefix::FIELDS` is
+/// a `&'static [VendorPrefix]` with the same values in the same declaration
+/// order (webkit, moz, ms, o, none); kept duplicated here as a fixed-size
+/// array for the to_css loops.
 pub(super) const PREFIX_FLAGS: [VendorPrefix; 5] = [
     VendorPrefix::WEBKIT,
     VendorPrefix::MOZ,
@@ -51,9 +51,8 @@ pub(super) mod property_id_mixin {
         let name = this.name();
         let prefix_value = this.prefix().or_none();
 
-        // PORT NOTE: Zig `inline for (VendorPrefix.FIELDS) |field|` + `@field` iterates each
-        // bitflag field and tests it. `PREFIX_FLAGS` is the same set in the same order;
-        // `contains` replaces the `@field` test.
+        // `PREFIX_FLAGS` matches `VendorPrefix::FIELDS` — same set, same
+        // order; serialization order of prefixed names depends on it.
         dest.write_comma_separated(
             PREFIX_FLAGS
                 .iter()
@@ -67,8 +66,6 @@ pub(super) mod property_id_mixin {
     }
 
     pub(crate) fn parse(input: &mut css::Parser) -> css::Result<PropertyId> {
-        // PORT NOTE: `css::Result<T>` is assumed to alias `Result<T, css::ParserError>`;
-        // the Zig `.result`/`.err` switch collapses to `?`.
         let name = input.expect_ident()?;
         Ok(from_string(name))
     }
@@ -101,7 +98,6 @@ pub(super) mod property_mixin {
         }
         let (name, prefix) = this.__to_css_helper();
 
-        // PORT NOTE: see property_id_mixin::to_css for the `inline for` + `@field` mapping.
         dest.write_separated(
             PREFIX_FLAGS.iter().copied().filter(|p| prefix.contains(*p)),
             |d| {
@@ -122,5 +118,3 @@ pub(super) mod property_mixin {
         )
     }
 }
-
-// ported from: src/css/properties/properties_impl.zig
diff --git a/src/css/properties/shape.rs b/src/css/properties/shape.rs
index 17615dce199..e184b566492 100644
--- a/src/css/properties/shape.rs
+++ b/src/css/properties/shape.rs
@@ -4,9 +4,7 @@ pub use crate::css_parser as css;
 /// determine the interior of a `polygon()` shape.
 ///
 /// See [Polygon](Polygon).
-// TODO(port): Zig source is `css.DefineEnumProperty(@compileError(css.todo_stuff.depth))` —
-// a placeholder that compile-errors on use. Left as an uninhabited stub until the
-// CSS shapes module is actually implemented.
+// Uninhabited placeholder until the CSS shapes module is actually implemented.
 pub enum FillRule {}
 
 /// A CSS [`<alpha-value>`](https://www.w3.org/TR/css-color-4/#typedef-alpha-value),
@@ -16,5 +14,3 @@ pub enum FillRule {}
 pub struct AlphaValue {
     pub v: f32,
 }
-
-// ported from: src/css/properties/shape.zig
diff --git a/src/css/properties/size.rs b/src/css/properties/size.rs
index 70fa24529e1..828c5f73c90 100644
--- a/src/css/properties/size.rs
+++ b/src/css/properties/size.rs
@@ -25,9 +25,8 @@ pub enum BoxSizing {
     /// Include the padding and border (but not the margin) in the width and height.
     BorderBox,
 }
-// PORT NOTE: css::DefineEnumProperty(@This()) — provided eql/hash/parse/toCss/deepClone via
-// comptime reflection over @tagName. Hand-written here (only two variants) so the inherent
-// `parse`/`to_css` participate in `impl_parse_tocss_via_inherent!` without a derive-coherence clash.
+// Hand-written (only two variants) so the inherent `parse`/`to_css` participate in
+// `impl_parse_tocss_via_inherent!` without a derive-coherence clash.
 impl BoxSizing {
     pub(crate) fn parse(input: &mut css::Parser) -> css::Result<BoxSizing> {
         let location = input.current_source_location();
@@ -70,9 +69,8 @@ pub enum Size {
 }
 
 /// Case-insensitive keyword dispatch for `Size`/`MaxSize` parse bodies.
-/// PORT NOTE: Zig used `bun.ComptimeStringMap(..).getASCIIICaseInsensitive` —
-/// expanded as an `if`-chain over `eql_case_insensitive_ascii::<true>` (≤14 keys;
-/// per PORTING.md a phf table is overkill at this size).
+/// An `if`-chain over `eql_case_insensitive_ascii::<true>` (≤14 keys;
+/// a phf table is overkill at this size).
 macro_rules! size_ident_match {
     ($ident:expr, { $($lit:literal => $val:expr,)+ } else $err:expr) => {{
         let __ident: &[u8] = $ident;
@@ -153,7 +151,7 @@ impl Size {
     }
 }
 
-// PORT NOTE: split out of `impl Size` above — these don't depend on
+// Split out of `impl Size` above — these don't depend on
 // `parse`/`to_css` surface and are needed by `SizeHandler`.
 impl Size {
     pub(crate) fn is_compatible(&self, browsers: &css::targets::Browsers) -> bool {
@@ -184,13 +182,11 @@ impl Size {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // TODO(port): css.implementDeepClone — comptime field-walk; `Size` carries
-        // only `LengthPercentage`/`VendorPrefix` payloads, both `Clone`-via-derive.
+        // `Size` carries only `LengthPercentage`/`VendorPrefix` payloads, both `Clone`-via-derive.
         self.clone()
     }
 
     pub(crate) fn eql(lhs: &Self, rhs: &Self) -> bool {
-        // TODO(port): css.implementEql — comptime field-walk; #[derive(PartialEq)] above covers it.
         lhs == rhs
     }
 }
@@ -291,7 +287,7 @@ impl MaxSize {
     }
 }
 
-// PORT NOTE: split out of `impl MaxSize` above — these don't depend on
+// Split out of `impl MaxSize` above — these don't depend on
 // `parse`/`to_css` surface and are needed by `SizeHandler`.
 impl MaxSize {
     pub(crate) fn is_compatible(&self, browsers: &css::targets::Browsers) -> bool {
@@ -322,8 +318,7 @@ impl MaxSize {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // TODO(port): css.implementDeepClone — comptime field-walk; `MaxSize` carries
-        // only `LengthPercentage`/`VendorPrefix` payloads, both `Clone`-via-derive.
+        // `MaxSize` carries only `LengthPercentage`/`VendorPrefix` payloads, both `Clone`-via-derive.
         self.clone()
     }
 
@@ -375,7 +370,7 @@ impl AspectRatio {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // PORT NOTE: css.implementDeepClone — `Ratio` is two `f32`s; #[derive(Clone)] is exact.
+        // `Ratio` is two `f32`s; #[derive(Clone)] is exact.
         *self
     }
 
@@ -410,8 +405,6 @@ bitflags::bitflags! {
 
 impl SizeProperty {
     pub(crate) fn try_from_property_id_tag(property_id: PropertyIdTag) -> Option<SizeProperty> {
-        // TODO(port): Zig used `inline for (std.meta.fields(@This()))` to compare each
-        // bitfield name against PropertyIdTag's @tagName. Expanded explicitly here.
         match property_id {
             PropertyIdTag::Width => Some(SizeProperty::WIDTH),
             PropertyIdTag::Height => Some(SizeProperty::HEIGHT),
@@ -449,17 +442,11 @@ pub struct SizeHandler {
     pub category: PropertyCategory,
 }
 
-// PORT NOTE: `context.arena` was dropped from PropertyHandlerContext; the
+// `context.arena` was dropped from PropertyHandlerContext; the
 // arena is recovered via `dest.bump()`.
 use css::compat::Feature;
 
-// ─── helper macros (Zig used `inline fn` + `comptime []const u8` field names + @field/@unionInit) ───
-//
-// TODO(port): the following four macros replace Zig's `propertyHelper`, `logicalUnparsedHelper`,
-// `flushPrefixHelper`, `flushPropertyHelper`, `flushLogicalHelper`. The Zig code passes field
-// names as comptime strings and uses @field/@unionInit/@tagName to splice them into struct/enum
-// accesses. Rust has no equivalent reflection — macro_rules! is the closest 1:1 mapping.
-// PERF(port): was comptime monomorphization.
+// ─── helper macros ───
 
 macro_rules! property_helper {
     ($this:expr, $field:ident, $ty:ty, $value:expr, $category:expr, $dest:expr, $context:expr) => {{
@@ -487,8 +474,7 @@ macro_rules! logical_unparsed_helper {
             $this.flushed_properties.insert(
                 SizeProperty::try_from_property_id_tag($unparsed.property_id.tag()).unwrap(),
             );
-            // PORT NOTE: Zig pushed `property.deepClone(arena)`; the matched
-            // payload is `Unparsed`, so reconstruct directly.
+            // The matched payload is `Unparsed`, so reconstruct directly.
             $dest.push(Property::Unparsed($unparsed.deep_clone(bump)));
         } else {
             $dest.push(Property::Unparsed(
@@ -506,7 +492,7 @@ macro_rules! flush_prefix_helper {
                 .targets
                 .prefixes(VendorPrefix::NONE, css::prefixes::Feature::$feature)
                 .difference(VendorPrefix::NONE);
-            // TODO(port): `inline for (css.VendorPrefix.FIELDS)` — iterate set bits.
+            // Iterate set bits.
             for prefix in prefixes.iter() {
                 $dest.push(Property::$prop_variant($size_ty::$size_variant(prefix)));
             }
@@ -966,5 +952,3 @@ impl SizeHandler {
         self.flushed_properties = SizeProperty::empty();
     }
 }
-
-// ported from: src/css/properties/size.zig
diff --git a/src/css/properties/svg.rs b/src/css/properties/svg.rs
index ad3c0402af0..8b137891791 100644
--- a/src/css/properties/svg.rs
+++ b/src/css/properties/svg.rs
@@ -1 +1 @@
-// ported from: src/css/properties/svg.zig
+
diff --git a/src/css/properties/text.rs b/src/css/properties/text.rs
index 0e737247e74..2e008a39479 100644
--- a/src/css/properties/text.rs
+++ b/src/css/properties/text.rs
@@ -126,13 +126,11 @@ impl TextShadow {
             && self.spread.is_compatible(browsers)
     }
 
-    // Zig: `pub fn eql` via `css.implementEql(@This(), ...)` — field-wise equality.
-    // Ported as `#[derive(PartialEq)]` above; callers use `==`.
-
     pub(crate) fn deep_clone(&self, alloc: &bun_alloc::Arena) -> Self {
-        // TODO(port): Zig used reflection-based `css.implementDeepClone`. Fields here
-        // are value types, so a plain Clone is equivalent; arena param retained for
-        // signature compatibility with the CSS deep_clone protocol.
+        // Fields deep-clone via `#[derive(Clone)]` (`CssColor`/`Length`
+        // `Box`-carrying variants clone deeply onto the global heap), so a
+        // plain Clone is equivalent; arena param retained for signature
+        // compatibility with the CSS deep_clone protocol.
         let _ = alloc;
         self.clone()
     }
@@ -149,7 +147,6 @@ impl css::generics::IsCompatible for TextShadow {
 }
 
 /// A value for the [direction](https://drafts.csswg.org/css-writing-modes-3/#direction) property.
-// Zig wires eql/hash/parse/toCss/deepClone via `css.DefineEnumProperty(@This())`.
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, Hash, crate::DefineEnumProperty, crate::generics::CssHash,
 )]
@@ -159,5 +156,3 @@ pub enum Direction {
     /// This value sets inline base direction (bidi directionality) to line-right-to-line-left.
     Rtl,
 }
-
-// ported from: src/css/properties/text.zig
diff --git a/src/css/properties/transform.rs b/src/css/properties/transform.rs
index 0ddb169af13..61852727f7a 100644
--- a/src/css/properties/transform.rs
+++ b/src/css/properties/transform.rs
@@ -13,21 +13,22 @@ use crate::{
 };
 
 /// A value for the [transform](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#propdef-transform) property.
-// PORT NOTE: was `BumpVec<'bump, Transform>`; downgraded to `Vec` so the
-// `Property` enum (properties_generated.rs) stays lifetime-free. Re-thread
-// `'bump` through `Property<'a>` crate-wide in a later pass (see line :1096).
+// Was `BumpVec<'bump, Transform>` in an earlier port iteration; uses `Vec` so
+// the `Property` enum (properties_generated.rs) stays lifetime-free.
+// Re-threading `'bump` through `Property<'a>` crate-wide is deferred work
+// (see /tmp/todo-fix/complex/mk04-repair.md; also TransformHandler below).
 #[derive(Clone, PartialEq, Default)]
 pub struct TransformList {
     pub v: Vec<Transform>,
 }
 
-// PORT NOTE: split out of the parse/to_css `impl TransformList` below —
+// Split out of the parse/to_css `impl TransformList` below —
 // `TransformHandler` only needs deep_clone/eql.
 impl TransformList {
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // TODO(port): css.implementDeepClone reflection — `Transform`/`TransformList`
-        // are `Clone`-via-derive (Vec + POD payloads); an arena-aware DeepClone
-        // trait should land crate-wide.
+        // `Transform`/`TransformList` deep-clone via `#[derive(Clone)]`: payloads
+        // with heap variants (`LengthPercentage`/`Length` `Calc(Box<..>)`) clone
+        // deeply onto the global heap.
         self.clone()
     }
 }
@@ -63,10 +64,7 @@ impl TransformList {
 
         // TODO: Re-enable with a better solution
         //       See: https://github.com/parcel-bundler/lightningcss/issues/288
-        // PORT NOTE: Zig's minify branch built a sub-`Printer` writing into a temp
-        // buffer then `dest.writeStr(base)` — observably identical to writing
-        // directly into `dest` while `dest.minify` is set (the original
-        // lightningcss size-comparison was already disabled upstream). Collapsed.
+        // (The original lightningcss size-comparison was already disabled upstream.)
         self.to_css_base(dest)
     }
 
@@ -148,8 +146,6 @@ impl Transform {
     pub(crate) fn parse(input: &mut Parser) -> Result<Transform> {
         let function = input.expect_function_cloned()?;
 
-        // PORT NOTE: Zig used a Closure struct + nested anon-struct fn passed to
-        // parseNestedBlock; Rust closures capture `function` directly.
         input.parse_nested_block(|i| -> Result<Transform> {
             let location = i.current_source_location();
             crate::match_ignore_ascii_case! { function, {
@@ -241,8 +237,7 @@ impl Transform {
                         let y = NumberOrPercentage::parse(i)?;
                         Ok(Transform::Scale { x, y })
                     } else {
-                        // PORT NOTE: Zig `x.deepClone(arena)` — `NumberOrPercentage`
-                        // is POD; `clone()` is exact.
+                        // `NumberOrPercentage` is POD.
                         let y = x.clone();
                         Ok(Transform::Scale { x, y })
                     }
@@ -574,7 +569,9 @@ impl Transform {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // TODO(port): css.implementDeepClone reflection — payload types may need bump-aware clone
+        // All payload types deep-clone via `#[derive(Clone)]` — `Calc` variants
+        // of `LengthPercentage`/`Length` are `Box`ed and clone deeply onto the
+        // global heap.
         self.clone()
     }
 }
@@ -612,8 +609,6 @@ pub struct Matrix3d<T> {
 }
 
 /// A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property.
-// TODO(port): css.DefineEnumProperty reflection → crate-wide #[derive(EnumProperty)] providing
-// parse/to_css/eql/hash/deep_clone from kebab-case variant names.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, crate::DefineEnumProperty)]
 pub enum TransformStyle {
     #[css("flat")]
@@ -726,8 +721,8 @@ impl Translate {
     }
 }
 
-// PORT NOTE: split out of the parse/to_css `impl Translate` above — these
-// don't depend on Parser/Printer surface and are needed by `TransformHandler`.
+// Split out of the parse/to_css `impl Translate` above — these don't depend
+// on Parser/Printer surface and are needed by `TransformHandler`.
 impl Translate {
     pub(crate) fn to_transform(&self, _bump: &Bump) -> Transform {
         match self {
@@ -745,7 +740,7 @@ impl Translate {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Bump) -> Self {
-        // TODO(port): css.implementDeepClone — arena-aware clone for LengthPercentage
+        // `LengthPercentage` is `Clone`-via-derive; a plain clone suffices.
         self.clone()
     }
 }
@@ -846,7 +841,7 @@ impl Rotate {
     }
 }
 
-// PORT NOTE: split out of the parse/to_css `impl Rotate` above — needed by
+// Split out of the parse/to_css `impl Rotate` above — needed by
 // `TransformHandler`.
 impl Rotate {
     /// Converts the rotation to a transform function.
@@ -930,7 +925,7 @@ impl Scale {
     }
 }
 
-// PORT NOTE: split out of the parse/to_css `impl Scale` above — needed by
+// Split out of the parse/to_css `impl Scale` above — needed by
 // `TransformHandler`.
 impl Scale {
     pub(crate) fn to_transform(&self, _bump: &Bump) -> Transform {
@@ -962,9 +957,10 @@ crate::css_eql_partialeq!(
     Scale
 );
 
-// PORT NOTE: was `TransformHandler<'bump>` holding `TransformList<'bump>`; the
-// `Property` enum is lifetime-free (see TransformList above), so the handler
-// is too. Re-thread `'bump` crate-wide in a later pass.
+// Was `TransformHandler<'bump>` holding `TransformList<'bump>` in an earlier
+// port iteration; the `Property` enum is lifetime-free (see TransformList
+// above), so the handler is too. Re-threading `'bump` crate-wide is deferred
+// work (see /tmp/todo-fix/complex/mk04-repair.md).
 #[derive(Default)]
 pub struct TransformHandler {
     pub transform: Option<(TransformList, VendorPrefix)>,
@@ -974,8 +970,8 @@ pub struct TransformHandler {
     pub has_any: bool,
 }
 
-// PORT NOTE: `context.arena` was dropped from PropertyHandlerContext, so the
-// arena is recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
+// `context.arena` does not exist on PropertyHandlerContext; the arena is
+// recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
 impl TransformHandler {
     pub(crate) fn handle_property(
         &mut self,
@@ -984,7 +980,6 @@ impl TransformHandler {
         context: &mut PropertyHandlerContext,
     ) -> bool {
         let bump = dest.bump();
-        // PORT NOTE: Zig used a local fn with `comptime field: []const u8` + `@field(self, field)`.
         // Rust cannot index struct fields by string at runtime; use a macro to paste the ident.
         macro_rules! individual_property {
             ($field:ident, $val:expr) => {{
@@ -1004,8 +999,8 @@ impl TransformHandler {
 
                 // If two vendor prefixes for the same property have different
                 // values, we need to flush what we have immediately to preserve order.
-                // PORT NOTE: reshaped for borrowck — Zig held &self.transform across
-                // self.flush(); compute the predicate first, then act.
+                // Compute the predicate first, then act, so no borrow of
+                // self.transform is held across self.flush().
                 let needs_flush = if let Some(current) = &self.transform {
                     current.0 != *transform_val && !current.1.contains(vp)
                 } else {
@@ -1046,8 +1041,7 @@ impl TransformHandler {
                             prefixes::Feature::Transform,
                         ))
                     } else {
-                        // PORT NOTE: Zig pushed `property.deepClone(arena)`; the
-                        // matched payload is `Unparsed`, so reconstruct directly.
+                        // The matched payload is `Unparsed`, so reconstruct directly.
                         Property::Unparsed(unparsed.deep_clone(bump))
                     };
                     dest.push(prop);
@@ -1099,5 +1093,3 @@ impl TransformHandler {
         }
     }
 }
-
-// ported from: src/css/properties/transform.zig
diff --git a/src/css/properties/transition.rs b/src/css/properties/transition.rs
index 10e61d8d012..0b38853346a 100644
--- a/src/css/properties/transition.rs
+++ b/src/css/properties/transition.rs
@@ -33,14 +33,13 @@ pub struct Transition {
 
 impl Transition {
     pub(crate) fn eql(&self, rhs: &Self) -> bool {
-        // Zig: css.implementEql(@This(), lhs, rhs) — field-by-field reflection.
         self == rhs
     }
 
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // Zig: css.implementDeepClone(@This(), this, arena) — field-by-field
-        // reflection. All four fields are POD/Copy or `Clone`-via-derive with no
-        // arena indirections; #[derive(Clone)] is exact.
+        // All four fields deep-clone via `#[derive(Clone)]` with no
+        // arena indirections (any heap-carrying variants of `PropertyId`/
+        // `EasingFunction` clone deeply onto the global heap), so Clone is exact.
         self.clone()
     }
 
@@ -119,11 +118,9 @@ pub struct TransitionHandler {
     pub has_any: bool,
 }
 
-// PORT NOTE: Zig's `property`/`maybeFlush` took `comptime prop: []const u8` and used
-// `@field(this, prop)` + `val: anytype` for comptime field dispatch. Rust has no
-// `@field`, and passing both `&mut self` and `&mut self.<field>` to a generic fn
-// trips borrowck (because `flush` needs `&mut self`). Macros expand at the call
-// site exactly like the Zig comptime dispatch did.
+// Passing both `&mut self` and `&mut self.<field>` to a generic fn trips
+// borrowck (because `flush` needs `&mut self`), so macros expand the field
+// dispatch at the call site instead.
 macro_rules! handler_maybe_flush {
     ($this:expr, $dest:expr, $context:expr, $field:ident, $val:expr, $vp:expr) => {{
         // If two vendor prefixes for the same property have different
@@ -166,8 +163,8 @@ mod transition_handler_body {
             dest: &mut DeclarationList,
             context: &mut PropertyHandlerContext,
         ) -> bool {
-            // PORT NOTE: `arena` field dropped from PropertyHandlerContext; the
-            // arena is recovered via `dest.bump()` (DeclarationList = bumpalo::Vec).
+            // PropertyHandlerContext carries no arena; it is recovered via
+            // `dest.bump()` (DeclarationList = bumpalo::Vec).
             let arena = dest.bump();
             match prop {
                 Property::TransitionProperty(x) => {
@@ -480,29 +477,17 @@ mod transition_handler_body {
                 delay,
                 timing_function,
             };
-            let mut cloned = false;
-
             let prefix_to_iter = property_id.prefix().or_none();
             // Expand vendor prefixes into multiple transitions.
-            // PORT NOTE: Zig used `inline for (VendorPrefix.FIELDS)` over packed-struct
-            // bool fields. With bitflags, iterate the individual flag bits.
-            // PERF(port): was comptime-unrolled inline-for — profile if it shows up on a hot path.
+            // Cloning for every iteration costs at most one extra clone of a
+            // small value.
             for &prefix_flag in VendorPrefix::FIELDS {
                 if prefix_to_iter.contains(prefix_flag) {
-                    let mut t = if cloned {
-                        transition.deep_clone(arena)
-                    } else {
-                        // TODO(port): Zig moved `transition` here on first iteration; Rust
-                        // can't move out of a value that may be reused next iteration.
-                        // Clone unconditionally for now.
-                        transition.deep_clone(arena)
-                    };
-                    cloned = true;
+                    let mut t = transition.deep_clone(arena);
                     t.property = property_id.with_prefix(prefix_flag);
                     transitions.append(t);
                 }
             }
-            let _ = cloned;
         }
         transitions
     }
@@ -830,6 +815,4 @@ mod transition_handler_body {
                 | PropertyId::Transition(..)
         )
     }
-
-    // ported from: src/css/properties/transition.zig
 } // mod transition_handler_body
diff --git a/src/css/properties/ui.rs b/src/css/properties/ui.rs
index 900222e9617..5272f703740 100644
--- a/src/css/properties/ui.rs
+++ b/src/css/properties/ui.rs
@@ -18,7 +18,6 @@ bitflags::bitflags! {
         const DARK  = 1 << 1;
         /// Forbids the user agent from overriding the color scheme for the element.
         const ONLY  = 1 << 2;
-        // Zig: __unused: u5 = 0  (padding — bitflags handles this implicitly)
     }
 }
 
@@ -83,8 +82,7 @@ impl ColorScheme {
     }
 }
 
-// Zig: `const Map = bun.ComptimeEnumMap(enum { normal, only, light, dark });`
-// ≤8 entries → plain match on bytes (per PORTING.md).
+// ≤8 entries → plain match on bytes.
 #[derive(Clone, Copy)]
 enum ColorSchemeKeyword {
     Normal,
@@ -104,15 +102,13 @@ fn color_scheme_map_get(ident: &[u8]) -> Option<ColorSchemeKeyword> {
 }
 
 /// A value for the [resize](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#resize) property.
-// TODO(port): Zig source is `css.DefineEnumProperty(@compileError(css.todo_stuff.depth))` — intentionally unimplemented upstream.
+// Intentionally unimplemented upstream, so this stays a unit placeholder.
 pub struct Resize;
 
 #[derive(Default)]
 pub struct ColorSchemeHandler;
 
-// PORT NOTE: `context.arena` was dropped from PropertyHandlerContext;
-// `define_var` no longer needs an arena because `TokenList.v` is a std
-// `Vec<TokenOrValue>` (LIFETIMES.tsv classification).
+// `define_var` needs no arena because `TokenList.v` is a std `Vec<TokenOrValue>`.
 impl ColorSchemeHandler {
     pub(crate) fn handle_property(
         &mut self,
@@ -146,8 +142,7 @@ impl ColorSchemeHandler {
                         dest.push(define_var(b"--buncss-dark", css::Token::Ident(b"initial")));
                     }
                 }
-                // PORT NOTE: Zig pushed `property.deepClone(arena)`; ColorScheme is
-                // `Copy` (bitflags u8), so reconstruct the variant directly.
+                // ColorScheme is `Copy` (bitflags u8), so reconstruct the variant directly.
                 dest.push(Property::ColorScheme(color_scheme));
                 true
             }
@@ -164,9 +159,9 @@ impl ColorSchemeHandler {
 }
 
 fn define_var(name: &'static [u8], value: css::Token) -> Property {
-    // PORT NOTE: `name` is `&'static [u8]` because all call sites pass byte-string literals.
+    // `name` is `&'static [u8]` because all call sites pass byte-string literals.
     // `TokenList.v` is `Vec<TokenOrValue>` (std Vec — see custom.rs:320), so no arena
-    // threading is needed here despite Zig's `ArrayList(TokenOrValue)`.
+    // threading is needed here.
     Property::Custom(css::css_properties::custom::CustomProperty {
         name: css::css_properties::custom::CustomPropertyName::Custom(DashedIdent { v: name }),
         value: css::TokenList {
@@ -174,5 +169,3 @@ fn define_var(name: &'static [u8], value: css::Token) -> Property {
         },
     })
 }
-
-// ported from: src/css/properties/ui.zig
diff --git a/src/css/rules/container.rs b/src/css/rules/container.rs
index f97c5e1d3f4..17de7df9b96 100644
--- a/src/css/rules/container.rs
+++ b/src/css/rules/container.rs
@@ -19,8 +19,6 @@ impl ContainerName {
 impl ContainerName {
     #[inline]
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk — `CustomIdent`
-        // identity-copy (arena-owned slice pointer).
         Self {
             v: self.v.deep_clone(bump),
         }
@@ -67,11 +65,9 @@ pub enum ContainerSizeFeatureId {
 
 // `QueryFeature<FeatureId>` requires `FeatureId: FeatureIdTrait` at the type
 // level, so this impl must be present for `ContainerSizeFeature` to resolve.
-// `value_type` inlines the Zig `DeriveValueType` reflection; `to_css`/`from_str`
-// delegate to `enum_property_util` (driven by the `EnumProperty` derive).
+// `to_css`/`from_str` delegate to `enum_property_util` (driven by the
+// `EnumProperty` derive).
 impl crate::media_query::FeatureIdTrait for ContainerSizeFeatureId {
-    // Zig: pub const valueType = css.DeriveValueType(@This(), ValueTypeMap).valueType;
-    // PORT NOTE: DeriveValueType is comptime reflection over ValueTypeMap; expanded inline.
     fn value_type(&self) -> MediaFeatureType {
         match self {
             Self::Width => MediaFeatureType::Length,
@@ -105,8 +101,7 @@ pub enum StyleQuery {
         /// The operator for the conditions.
         operator: Operator,
         /// The conditions for the operator.
-        // PERF(port): was ArrayListUnmanaged fed input.arena() (parser arena);
-        // could use bun_alloc::ArenaVec<'bump, _> instead of global Vec — profile if hot.
+        // PERF: could use bun_alloc::ArenaVec<'bump, _> instead of global Vec — profile if hot.
         conditions: Vec<StyleQuery>,
     },
 }
@@ -153,8 +148,8 @@ impl QueryCondition for StyleQuery {
         let property_id = crate::properties::PropertyId::parse(input)?;
         input.expect_colon()?;
         input.skip_whitespace();
-        // PORT NOTE: Zig threaded `(input.arena(), null)` here; re-thread
-        // `&Bump` once `ParserOptions` carries the arena.
+        // The arena gets re-threaded as part of the crate-wide `'bump`
+        // lifetime work (see css_parser.rs).
         let opts = css::ParserOptions::default(None);
         let feature = StyleQuery::Feature(Box::new(Property::parse(property_id, input, &opts)?));
         let _ = input.try_parse(css::css_parser::parse_important);
@@ -170,7 +165,6 @@ impl QueryCondition for StyleQuery {
         }
     }
     fn parse_style_query(input: &mut css::Parser) -> css::Result<Self> {
-        // Zig: `return .{ .err = input.newErrorForNextToken() }`
         Err(input.new_error_for_next_token())
     }
     fn needs_parens(&self, parent_operator: Option<Operator>, _targets: &css::Targets) -> bool {
@@ -184,9 +178,8 @@ impl QueryCondition for StyleQuery {
 
 impl StyleQuery {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk. `Operator` is `Copy`;
-        // `Property` routes through `dc::property` until the per-variant
-        // `DeepClone` derives land in `properties_generated.rs`.
+        // `Operator` is `Copy`; `Property` routes through `dc::property` until
+        // the per-variant `DeepClone` derives land in `properties_generated.rs`.
         match self {
             Self::Feature(p) => Self::Feature(Box::new(super::dc::property(p, bump))),
             Self::Not(c) => Self::Not(Box::new(c.deep_clone(bump))),
@@ -211,8 +204,7 @@ pub enum ContainerCondition {
         /// The operator for the conditions.
         operator: Operator,
         /// The conditions for the operator.
-        // PERF(port): was ArrayListUnmanaged fed input.arena() (parser arena);
-        // could use bun_alloc::ArenaVec<'bump, _> instead of global Vec — profile if hot.
+        // PERF: could use bun_alloc::ArenaVec<'bump, _> instead of global Vec — profile if hot.
         conditions: Vec<ContainerCondition>,
     },
     /// A style query.
@@ -283,7 +275,6 @@ impl QueryCondition for ContainerCondition {
     }
     fn parse_style_query(input: &mut css::Parser) -> css::Result<Self> {
         use crate::media_query::QueryConditionFlags;
-        // Zig defined a local `Fns` struct with two callbacks; in Rust pass closures.
         input.parse_nested_block(|i| {
             if let Ok(res) = i.try_parse(|i2| {
                 media_query::parse_query_condition::<StyleQuery>(i2, QueryConditionFlags::ALLOW_OR)
@@ -305,9 +296,8 @@ impl QueryCondition for ContainerCondition {
 
 impl ContainerCondition {
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk. `QueryFeature<F>`
-        // routes through `dc::query_feature` (Clone is faithful — see note
-        // there); `Operator` is `Copy`.
+        // `QueryFeature<F>` routes through `dc::query_feature` (Clone is
+        // faithful — see note there); `Operator` is `Copy`.
         match self {
             Self::Feature(f) => Self::Feature(Box::new(super::dc::query_feature(f, bump))),
             Self::Not(c) => Self::Not(Box::new(c.deep_clone(bump))),
@@ -359,7 +349,6 @@ impl<R> ContainerRule<R> {
 
         // Don't downlevel range syntax in container queries.
         let exclude = dest.targets.exclude;
-        // Zig: bun.bits.insert(css.targets.Features, &dest.targets.exclude, .media_queries);
         dest.targets.exclude.insert(css::Features::MEDIA_QUERIES);
         self.condition.to_css(dest)?;
         dest.targets.exclude = exclude;
@@ -376,7 +365,6 @@ impl<R> ContainerRule<R> {
     where
         R: css::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             name: self.name.as_ref().map(|n| n.deep_clone(bump)),
             condition: self.condition.deep_clone(bump),
@@ -385,5 +373,3 @@ impl<R> ContainerRule<R> {
         }
     }
 }
-
-// ported from: src/css/rules/container.zig
diff --git a/src/css/rules/counter_style.rs b/src/css/rules/counter_style.rs
index 9f4ea2e2a77..789a3555aa9 100644
--- a/src/css/rules/counter_style.rs
+++ b/src/css/rules/counter_style.rs
@@ -7,8 +7,8 @@ pub struct CounterStyleRule {
     /// The name of the counter style to declare.
     pub name: CustomIdent,
     /// Declarations in the `@counter-style` rule.
-    // PORT NOTE: `DeclarationBlock<'bump>` borrows the parser arena; lifetime
-    // erased to `'static` here per the rules/mod.rs `CssRule<R>` PORT NOTE.
+    // `DeclarationBlock<'bump>` borrows the parser arena; lifetime erased to
+    // `'static` here per the rules/mod.rs `CssRule<R>` lifetime-erasure note.
     pub declarations: DeclarationBlock<'static>,
     /// The location of the rule in the source file.
     pub loc: Location,
@@ -27,7 +27,6 @@ impl CounterStyleRule {
 
 impl CounterStyleRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             name: self.name.deep_clone(bump),
             declarations: super::dc::decl_block_static(&self.declarations, bump),
@@ -35,5 +34,3 @@ impl CounterStyleRule {
         }
     }
 }
-
-// ported from: src/css/rules/counter_style.zig
diff --git a/src/css/rules/custom_media.rs b/src/css/rules/custom_media.rs
index 07b63c6902c..73393ec924a 100644
--- a/src/css/rules/custom_media.rs
+++ b/src/css/rules/custom_media.rs
@@ -34,5 +34,3 @@ impl CustomMediaRule {
         Ok(())
     }
 }
-
-// ported from: src/css/rules/custom_media.zig
diff --git a/src/css/rules/document.rs b/src/css/rules/document.rs
index b2949793101..8d766340523 100644
--- a/src/css/rules/document.rs
+++ b/src/css/rules/document.rs
@@ -29,12 +29,9 @@ impl<R> MozDocumentRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             rules: self.rules.deep_clone(bump),
             loc: self.loc,
         }
     }
 }
-
-// ported from: src/css/rules/document.zig
diff --git a/src/css/rules/font_face.rs b/src/css/rules/font_face.rs
index f0200635845..b26d7f28e05 100644
--- a/src/css/rules/font_face.rs
+++ b/src/css/rules/font_face.rs
@@ -40,7 +40,6 @@ pub enum FontFaceProperty {
 
 impl FontFaceProperty {
     pub(crate) fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // Local helpers mirroring the Zig `Helpers.writeProperty` with `comptime multi: bool`.
         macro_rules! write_property_single {
             ($d:expr, $prop:expr, $value:expr) => {{
                 $d.write_str($prop)?;
@@ -89,7 +88,6 @@ impl FontFaceProperty {
     }
 
     pub(crate) fn deep_clone(&self, arena: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: Zig `css.implementDeepClone` field-walk, hand-expanded.
         match self {
             FontFaceProperty::Source(v) => {
                 FontFaceProperty::Source(v.iter().map(|s| s.deep_clone(arena)).collect())
@@ -228,7 +226,7 @@ impl UnicodeRange {
 
     fn parse_tokens(input: &mut css::Parser) -> css::Result<()> {
         let tok = input.next_including_whitespace()?.clone();
-        // TODO(port): verify exact `Token` variant shapes (Dimension/Number payloads).
+        // Tag-only matches on `Dimension`/`Number` — payloads are never inspected.
         match tok {
             css::Token::Dimension { .. } => return Self::parse_question_marks(input),
             css::Token::Number { .. } => {
@@ -279,7 +277,6 @@ impl UnicodeRange {
         }
     }
 
-    // PORT NOTE: Zig `css.Maybe(UnicodeRange, void)` carries no error payload → `Option<UnicodeRange>`.
     fn parse_concatenated(text_: &[u8]) -> Option<UnicodeRange> {
         let mut text = if !text_.is_empty() && text_[0] == b'+' {
             &text_[1..]
@@ -334,8 +331,8 @@ impl UnicodeRange {
     }
 
     fn consume_hex(text: &mut &[u8]) -> (u32, usize) {
-        // Cap at 8: caller validates `<= 6` post-hoc; the unbounded Zig original
-        // panic-overflows u32 in debug on >8 hex chars (malformed input).
+        // Cap at 8: caller validates `<= 6` post-hoc; an unbounded parse
+        // would overflow u32 on >8 hex chars (malformed input).
         let (value, n) = bun_core::fmt::parse_hex_prefix(text, 8);
         *text = &text[n..];
         (value, n)
@@ -426,7 +423,7 @@ pub enum FontFormat {
     /// An SVG font.
     Svg,
     /// An unknown format.
-    // PORT NOTE: arena-owned slice from parser input; TODO(refactor): thread `'i`.
+    // Arena-owned slice from parser input; TODO(refactor): thread `'i`.
     String(&'static [u8]),
 }
 
@@ -464,7 +461,7 @@ impl FontFormat {
     }
 
     pub(crate) fn deep_clone(&self, _arena: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk. All payloads are
+        // `css.implementDeepClone` variant-walk. All payloads are
         // `Copy` / arena-slice idents → identity copy.
         match self {
             FontFormat::Woff => FontFormat::Woff,
@@ -501,7 +498,6 @@ impl Source {
         match input.try_parse(UrlSource::parse) {
             Ok(url) => return Ok(Source::Url(url)),
             Err(e) => {
-                // Zig: `e.kind == .basic and e.kind.basic == .at_rule_body_invalid`
                 if matches!(
                     e.kind,
                     css::ParseErrorKind::basic(css::BasicParseErrorKind::at_rule_body_invalid)
@@ -529,7 +525,7 @@ impl Source {
     }
 
     pub fn deep_clone(&self, arena: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk, hand-expanded.
+        // `css.implementDeepClone` variant-walk, hand-expanded.
         match self {
             Source::Url(u) => Source::Url(u.deep_clone(arena)),
             Source::Local(l) => Source::Local(l.deep_clone(arena)),
@@ -638,7 +634,7 @@ impl UrlSource {
     }
 
     pub(crate) fn deep_clone(&self, arena: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk, hand-expanded.
+        // `css.implementDeepClone` field-walk, hand-expanded.
         Self {
             url: self.url.deep_clone(arena),
             format: self.format.as_ref().map(|f| f.deep_clone(arena)),
@@ -684,7 +680,7 @@ impl FontFaceRule {
 
 impl FontFaceRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `FontFaceProperty`'s
+        // `css.implementDeepClone` field-walk. `FontFaceProperty`'s
         // variant-walk lands when its enum body un-gates (properties::{font,
         // custom}); the gated stub above panics with the blocker named.
         Self {
@@ -700,11 +696,6 @@ impl FontFaceRule {
 
 pub(crate) struct FontFaceDeclarationParser;
 
-// PORT NOTE: Zig modeled `AtRuleParser` / `QualifiedRuleParser` /
-// `DeclarationParser` / `RuleBodyItemParser` as nested namespaces with
-// associated consts + fns. In Rust these are trait impls on
-// `FontFaceDeclarationParser`.
-//
 // blocked_on: css::{AtRuleParser,QualifiedRuleParser,DeclarationParser,
 // RuleBodyItemParser} trait signatures, properties::font::* +
 // properties::custom::CustomProperty, Size2D::parse, Parser surface,
@@ -831,5 +822,3 @@ const _: () = {
         }
     }
 };
-
-// ported from: src/css/rules/font_face.zig
diff --git a/src/css/rules/font_palette_values.rs b/src/css/rules/font_palette_values.rs
index 47093fb15f5..45258ff8c98 100644
--- a/src/css/rules/font_palette_values.rs
+++ b/src/css/rules/font_palette_values.rs
@@ -53,7 +53,6 @@ impl FontPaletteValuesRule {
         while let Some(result) = parser.next() {
             if let Ok(decl) = result {
                 properties.push(decl);
-                // PERF(port): was `append(input.arena(), decl) catch unreachable`
             }
         }
 
@@ -81,9 +80,9 @@ pub enum FontPaletteValuesProperty {
 
 impl FontPaletteValuesRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `FontPaletteValuesProperty`'s
-        // variant-walk lands when its enum body un-gates (properties::{font,
-        // custom}); the gated stub above panics with the blocker named.
+        // `FontPaletteValuesProperty`'s variant-walk lands when its enum body
+        // un-gates (properties::{font, custom}); the gated stub above panics
+        // with the blocker named.
         Self {
             name: self.name.deep_clone(bump),
             properties: self.properties.iter().map(|p| p.deep_clone(bump)).collect(),
@@ -119,7 +118,6 @@ impl FontPaletteValuesProperty {
     }
 
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk.
         match self {
             Self::FontFamily(f) => Self::FontFamily(f.deep_clone(bump)),
             Self::BasePalette(b) => Self::BasePalette(b.deep_clone(bump)),
@@ -222,7 +220,6 @@ impl BasePalette {
     }
 
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` — `Copy` payload (u16).
         match self {
             Self::Light => Self::Light,
             Self::Dark => Self::Dark,
@@ -233,9 +230,6 @@ impl BasePalette {
 
 pub(crate) struct FontPaletteValuesDeclarationParser {}
 
-// PORT NOTE: Zig models these as nested namespace structs (`DeclarationParser`,
-// `RuleBodyItemParser`, `AtRuleParser`, `QualifiedRuleParser`) duck-typed by
-// `RuleBodyParser`. In Rust these are trait impls.
 const _: () = {
     use crate::css_properties::custom::{CustomProperty, CustomPropertyName};
     use crate::css_properties::font::FontFamily;
@@ -281,7 +275,6 @@ const _: () = {
             }}
 
             input.reset(&state);
-            // PERF(port): Zig passed `input.arena()` + `null` here.
             let opts = ParserOptions::default(None);
             let custom = CustomProperty::parse(CustomPropertyName::from_str(name), input, &opts)?;
             Ok(FontPaletteValuesProperty::Custom(custom))
@@ -350,5 +343,3 @@ const _: () = {
         }
     }
 };
-
-// ported from: src/css/rules/font_palette_values.zig
diff --git a/src/css/rules/import.rs b/src/css/rules/import.rs
index d25a5e8b81a..9f0cf3f7180 100644
--- a/src/css/rules/import.rs
+++ b/src/css/rules/import.rs
@@ -8,10 +8,8 @@ use crate::{PrintErr, Printer};
 use bun_alloc::Arena;
 use bun_ast::ImportRecord;
 
-/// Named replacement for the Zig anonymous `struct { v: ?LayerName }` used in
-/// both `ImportConditions.layer` and `ImportRule.layer`. The two Zig anonymous
-/// structs are layout-identical (the code `@ptrCast`s between the parents), so
-/// we use a single Rust type for both.
+/// Layer slot used in both `ImportConditions.layer` and `ImportRule.layer`.
+/// The two uses are layout-identical, so a single type serves both.
 #[repr(C)]
 #[derive(Default)]
 pub struct Layer {
@@ -164,7 +162,7 @@ impl ImportConditions {
 #[repr(C)]
 pub struct ImportRule {
     /// The url to import.
-    // TODO(port): arena lifetime — `&'bump [u8]` once crate-wide thread lands.
+    // TODO: arena lifetime — `&'bump [u8]` once crate-wide thread lands.
     pub url: &'static [u8],
 
     /// An optional cascade layer name, or `None` for an anonymous layer.
@@ -227,11 +225,15 @@ impl ImportRule {
     pub fn conditions(&self) -> &ImportConditions {
         // SAFETY: ImportConditions is #[repr(C)] with fields {layer, supports, media}
         // laid out identically to the {layer, supports, media} field run of ImportRule
-        // (also #[repr(C)]). The Zig code relies on this same layout pun via @ptrCast.
+        // (also #[repr(C)]).
         // The pointer is derived from `self` (not `&self.layer`) so its provenance
         // covers all three fields — going through a field reference would narrow
         // provenance to just `layer` and make sibling-field reads UB under SB.
-        // TODO(port): replace with an actual `conditions: ImportConditions` field on ImportRule
+        //
+        // Long-term, the pun should be replaced with an actual
+        // `conditions: ImportConditions` field on `ImportRule` (see the struct
+        // doc on `ImportConditions`); that touches every `.layer`/`.supports`/
+        // `.media` access crate-wide, so it is deferred.
         unsafe {
             &*std::ptr::from_ref(self)
                 .byte_add(core::mem::offset_of!(Self, layer))
@@ -278,9 +280,8 @@ impl ImportRule {
     }
 
     pub fn deep_clone(&self, bump: &Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `url: &'static [u8]`
-        // is an arena-owned slice → identity copy (generics.zig "const
-        // strings" rule); `media` routes through `dc::media_list` until
+        // `url: &'static [u8]` is an arena-owned slice → identity copy;
+        // `media` routes through `dc::media_list` until
         // `MediaList` gains an arena-aware `deep_clone`.
         Self {
             url: self.url,
@@ -316,7 +317,6 @@ impl ImportRule {
             dest.serialize_string(placeholder)?;
 
             if let Some(deps) = &mut dest.dependencies {
-                // PERF(port): was `catch unreachable` (alloc cannot fail under arena)
                 deps.push(css::Dependency::Import(d));
             }
         } else {
@@ -368,5 +368,3 @@ const _: () = {
 };
 
 // silence unused-import warnings on the gated bodies' deps
-
-// ported from: src/css/rules/import.zig
diff --git a/src/css/rules/keyframes.rs b/src/css/rules/keyframes.rs
index 0f75617789d..06751a4ee89 100644
--- a/src/css/rules/keyframes.rs
+++ b/src/css/rules/keyframes.rs
@@ -13,9 +13,8 @@ use super::ArrayList;
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `<keyframes-name> = <custom-ident> | <string>`
-// PORT NOTE: Zig threaded the parser-input lifetime; this stores
-// `&'static [u8]` per PORTING.md §AST crates and the rules/mod.rs
-// `CssRule<R>` lifetime-erasure note.
+// Stores `&'static [u8]` per the rules/mod.rs `CssRule<R>` lifetime-erasure
+// note (mod.rs:37-41).
 // TODO(refactor): re-thread `'bump` here.
 pub enum KeyframesName {
     /// `<custom-ident>` of a `@keyframes` name.
@@ -24,14 +23,12 @@ pub enum KeyframesName {
     Custom(&'static [u8]),
 }
 
-// Zig: `pub fn HashMap(comptime V: type) type { return std.ArrayHashMapUnmanaged(...) }`
-// → a generic type alias keyed by `KeyframesName` with the custom hash/eq below.
+// A generic type alias keyed by `KeyframesName` with the custom hash/eq below.
 pub type KeyframesNameHashMap<V> = bun_collections::ArrayHashMap<KeyframesName, V>;
 
 impl Hash for KeyframesName {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        // Matches Zig: hash only the underlying string bytes; variant tag does NOT
-        // participate (Zig's `hash` switches and calls `hashString` on the slice).
+        // Hash only the underlying string bytes; the variant tag does NOT participate.
         match self {
             KeyframesName::Ident(ident) => state.write(ident.v()),
             KeyframesName::Custom(s) => state.write(s),
@@ -94,8 +91,7 @@ impl KeyframesName {
 
 impl KeyframesName {
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk. `Custom(&'static [u8])`
-        // is an arena-owned slice → identity copy (generics.zig "const strings").
+        // `Custom(&'static [u8])` is an arena-owned slice → identity copy.
         match self {
             Self::Ident(i) => Self::Ident(i.deep_clone(bump)),
             Self::Custom(s) => Self::Custom(s),
@@ -167,8 +163,6 @@ impl KeyframeSelector {
 
 impl KeyframeSelector {
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` variant-walk. `Percentage` is
-        // `Copy` (`{ v: f32 }`) → identity.
         match self {
             Self::Percentage(p) => Self::Percentage(*p),
             Self::From => Self::From,
@@ -178,13 +172,11 @@ impl KeyframeSelector {
 }
 
 // ─── KeyframeSelector parse ───────────────────────────────────────────────
-// blocked_on: css::derive_parse (DeriveParse comptime macro replacement).
+// blocked_on: css::derive_parse (DeriveParse).
 
 impl KeyframeSelector {
-    // Zig: `pub const parse = css.DeriveParse(@This()).parse;`
-    // PORT NOTE: `DeriveParse` is a comptime type-generator producing `parse` from
-    // variant introspection. Expanded by hand here: try the tuple variant
-    // (`Percentage`) first, then fall back to keyword idents (`from`/`to`).
+    // Try the tuple variant (`Percentage`) first, then fall back to keyword
+    // idents (`from`/`to`).
     pub(crate) fn parse(input: &mut css::Parser) -> css::Result<KeyframeSelector> {
         if let Ok(p) = input.try_parse(Percentage::parse) {
             return Ok(KeyframeSelector::Percentage(p));
@@ -212,7 +204,7 @@ pub struct Keyframe {
     /// A list of keyframe selectors to associate with the declarations in this keyframe.
     pub selectors: ArrayList<KeyframeSelector>,
     /// The declarations for this keyframe.
-    // PORT NOTE: lifetime erased to `'static` per rules/mod.rs `CssRule<R>` note.
+    // Lifetime erased to `'static` per rules/mod.rs `CssRule<R>` note.
     pub declarations: DeclarationBlock<'static>,
 }
 
@@ -225,7 +217,6 @@ impl Keyframe {
 
 impl Keyframe {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             selectors: self.selectors.iter().map(|s| s.deep_clone(bump)).collect(),
             declarations: super::dc::decl_block_static(&self.declarations, bump),
@@ -256,9 +247,8 @@ impl KeyframesRule {
 
         let mut first_rule = true;
 
-        // Zig: `inline for (.{ "webkit", "moz", "ms", "o", "none" }) |prefix_name|` with
-        // `@field(this.vendor_prefix, prefix_name)`. VendorPrefix is a packed-bool struct
-        // (→ `bitflags!`), so iterate the flag constants directly and use `.contains()`.
+        // VendorPrefix is `bitflags!`, so iterate the flag constants directly
+        // and use `.contains()`.
         const PREFIXES: [VendorPrefix; 5] = [
             VendorPrefix::WEBKIT,
             VendorPrefix::MOZ,
@@ -311,8 +301,6 @@ impl KeyframesRule {
 
 impl KeyframesRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `VendorPrefix` is a
-        // `Copy` bitflag (generics.zig "simple copy types" → identity).
         Self {
             name: self.name.deep_clone(bump),
             keyframes: self.keyframes.iter().map(|k| k.deep_clone(bump)).collect(),
@@ -328,10 +316,6 @@ impl KeyframesRule {
 
 pub(crate) struct KeyframesListParser;
 
-// PORT NOTE: in Zig these are nested `pub const DeclarationParser = struct { ... }`
-// namespaces that the css parser duck-types via `@hasDecl`. In Rust they become
-// trait impls on `KeyframesListParser`.
-//
 // blocked_on: css::{DeclarationParser, AtRuleParser, QualifiedRuleParser,
 // RuleBodyItemParser} trait signatures (css_parser.rs round-5 surface),
 // Parser::parse_comma_separated, DeclarationBlock::parse, ParserOptions::default
@@ -428,5 +412,3 @@ const _: () = {
         }
     }
 };
-
-// ported from: src/css/rules/keyframes.zig
diff --git a/src/css/rules/layer.rs b/src/css/rules/layer.rs
index 023179aa803..40894b2a3e6 100644
--- a/src/css/rules/layer.rs
+++ b/src/css/rules/layer.rs
@@ -12,20 +12,21 @@ use crate::{PrintErr, Printer, SmallList};
 /// notation (`a.b.c`) creates sublayers.
 #[derive(Default)]
 pub struct LayerName {
-    // TODO(port): arena lifetime — Zig `[]const u8` segments borrow the parser
-    // arena. Thread `'bump` once `CssRuleList` re-gains its arena lifetime;
-    // until then segments are laundered through `&'static [u8]` like every
-    // other CSS slice in this crate.
+    // TODO: arena lifetime — segments borrow the parser arena. Thread
+    // `'bump` once `CssRuleList` re-gains its arena lifetime; until then
+    // segments are laundered through `&'static [u8]` like every other CSS
+    // slice in this crate.
     pub v: SmallList<&'static [u8], 1>,
 }
 
 // The inline hash/eql context is replaced by `Hash`/`PartialEq` impls on `LayerName` below.
-// TODO(port): ArrayHashMap must use wyhash (u32-truncated) to match Zig iteration order.
+// Iteration order is insertion order (collections/array_hash_map.rs)
+// regardless of hash function.
 pub type LayerNameHashMap<V> = ArrayHashMap<LayerName, V>;
 
 impl core::hash::Hash for LayerName {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        // Mirrors the Zig ArrayHashMap context: Wyhash(seed=0) over each part's bytes.
+        // Hash each part's bytes.
         for part in self.v.slice() {
             state.write(part);
         }
@@ -39,7 +40,7 @@ impl PartialEq for LayerName {
 }
 impl Eq for LayerName {}
 
-// PORT NOTE: trait `Clone` (not just inherent `deep_clone`) so the bundler's
+// Trait `Clone` (not just inherent `deep_clone`) so the bundler's
 // `Chunk::Layers::to_owned` can `deep_clone_with(|l| l.clone())`. Segments are
 // arena-borrowed `&'static [u8]` (Copy), so this is the same shallow
 // `SmallList` copy as `deep_clone` / `clone_with_import_records`.
@@ -51,9 +52,9 @@ impl Clone for LayerName {
 
 impl LayerName {
     pub fn clone_with_import_records(&self, bump: &Arena, _: &mut Vec<ImportRecord>) -> Self {
-        // `[]const u8` segments are arena-borrowed, not owned, so the Zig
-        // `deepClone` here was a shallow `SmallList` copy. No import records to
-        // rewrite — layer names contain no URLs.
+        // Segments are arena-borrowed, not owned, so this is a shallow
+        // `SmallList` copy. No import records to rewrite — layer names
+        // contain no URLs.
         //
         // Allocate the segment-pointer slab from `bump` (not the global
         // allocator): callers store the result in arena-owned `ImportConditions`
@@ -83,7 +84,6 @@ impl LayerName {
         parts.append(ident);
 
         loop {
-            // Zig: `const Fn = struct { pub fn tryParseFn(...) ... }`
             let try_parse_fn =
                 |i: &mut css::css_parser::Parser<'_>| -> css::css_parser::CssResult<&'static [u8]> {
                     let start_location = i.current_source_location();
@@ -116,9 +116,8 @@ impl LayerName {
     }
 
     pub fn deep_clone(&self, _bump: &Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` — `[]const u8` segments are
-        // arena-owned (identity copy per generics.zig "const strings"). Same
-        // body as `clone_with_import_records` above.
+        // Segments are arena-owned (identity copy). Same body as
+        // `clone_with_import_records` above.
         LayerName { v: self.v.clone() }
     }
 }
@@ -130,7 +129,6 @@ impl css::generics::ToCss for LayerName {
     }
 }
 
-// Zig: `pub fn format(self, writer: *std.Io.Writer) !void` → `impl Display`
 impl fmt::Display for LayerName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut first = true;
@@ -163,7 +161,7 @@ impl<R> LayerBlockRule<R> {
     where
         R: css::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
+        // `css.implementDeepClone` field-walk.
         Self {
             name: self.name.as_ref().map(|n| n.deep_clone(bump)),
             rules: self.rules.deep_clone(bump),
@@ -200,7 +198,7 @@ pub struct LayerStatementRule {
 
 impl LayerStatementRule {
     pub fn deep_clone(&self, bump: &Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
+        // `css.implementDeepClone` field-walk.
         let mut names = SmallList::<LayerName, 1>::default();
         for n in self.names.slice() {
             names.append(n.deep_clone(bump));
@@ -223,5 +221,3 @@ impl LayerStatementRule {
         }
     }
 }
-
-// ported from: src/css/rules/layer.zig
diff --git a/src/css/rules/media.rs b/src/css/rules/media.rs
index 29ec17f97ae..e5200de2dcf 100644
--- a/src/css/rules/media.rs
+++ b/src/css/rules/media.rs
@@ -13,10 +13,8 @@ pub struct MediaRule<R> {
 }
 
 // ─── behavior bodies ──────────────────────────────────────────────────────
-// PORT NOTE: `minify` lives in `rules/mod.rs` (hoisted next to `CssRuleList::
-// minify` so the dispatch can call it without re-exporting `MinifyContext`
-// here). `to_css` un-gated this round — `MediaList::{always_matches,to_css}`
-// and `CssRuleList::to_css` are both real now.
+// `minify` lives in `rules/mod.rs` (hoisted next to `CssRuleList::minify` so
+// the dispatch can call it without re-exporting `MinifyContext` here).
 impl<R> MediaRule<R> {
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
         if dest.minify && self.query.always_matches() {
@@ -40,7 +38,6 @@ impl<R> MediaRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             query: super::dc::media_list(&self.query, bump),
             rules: self.rules.deep_clone(bump),
@@ -48,5 +45,3 @@ impl<R> MediaRule<R> {
         }
     }
 }
-
-// ported from: src/css/rules/media.zig
diff --git a/src/css/rules/mod.rs b/src/css/rules/mod.rs
index 5780f930222..d5040fbdb9d 100644
--- a/src/css/rules/mod.rs
+++ b/src/css/rules/mod.rs
@@ -4,7 +4,7 @@ use css::PrintErr;
 use css::Printer;
 use css::error::MinifyErr;
 
-// PERF(port): heap-backed shim — Zig used arena-backed `std.ArrayListUnmanaged`.
+// PERF: heap-backed shim.
 // TODO(refactor): thread `'bump` and replace this with `crate::generics::ArrayList<'bump, T>`
 // (= `bun_alloc::ArenaVec`) crate-wide in one pass.
 pub(super) type ArrayList<T> = Vec<T>;
@@ -32,10 +32,8 @@ pub mod unknown;
 pub mod viewport;
 
 // ─── CssRule / CssRuleList ─────────────────────────────────────────────────
-// Zig: pub fn CssRule(comptime Rule: type) type { return union(enum) { ... } }
-//
-// PORT NOTE: the original port threaded a `'bump` arena lifetime through every
-// rule (matching Zig's `ArrayListUnmanaged`-backed AST). That cascades into
+// An earlier iteration threaded a `'bump` arena lifetime through every
+// rule. That cascades into
 // every leaf module signature; while those leaves are gated, `CssRule<R>` is
 // kept lifetime-free here (the gated bodies re-introduce `'bump` when they
 // un-gate alongside `bumpalo::collections::Vec` storage).
@@ -44,7 +42,7 @@ pub mod viewport;
 // Single source of truth for the 20 typed at-rule payloads. Adding a new
 // at-rule = one line here; the enum variant + `to_css` arm + `deep_clone`
 // arm are generated. `Unknown`/`Custom`/`Ignored` stay a fixed tail because
-// their `to_css` arms are special-cased (see PORT NOTE on `Custom`).
+// their `to_css` arms are special-cased (see the note on `Custom`).
 macro_rules! css_rule_variants {
     ( $( $(#[$doc:meta])* $Variant:ident($Payload:ty) ),+ $(,)? ) => {
         /// A single CSS rule (at-rule or style rule).
@@ -63,33 +61,25 @@ macro_rules! css_rule_variants {
                 match self {
                     $( CssRule::$Variant(x) => x.to_css(dest), )+
                     CssRule::Unknown(x) => x.to_css(dest),
-                    // Zig: `.custom => |x| x.toCss(dest) catch return dest.addFmtError()`.
-                    //
-                    // PORT NOTE (incomplete): the spec has TWO concrete `R` types —
-                    // `DefaultAtRule` (whose `toCss` errors unconditionally) and
-                    // `TailwindAtRule` (src/css/rules/tailwind.zig:14-19, used via
-                    // `BundlerAtRule` when `ENABLE_TAILWIND_PARSING`), whose `toCss`
-                    // SUCCEEDS and writes `@tailwind <name>;`. This arm therefore
-                    // diverges from the spec for `R = TailwindAtRule`: it fails
-                    // serialization where the spec round-trips.
-                    //
-                    // The correct port threads a `ToCss`-style bound (or per-`R`
-                    // vtable) so `Custom(x)` dispatches to `x.to_css(dest)` and only
-                    // maps the error path via `add_fmt_error()`. That bound cascades
-                    // through every nested `CssRuleList<R>` printer (media, supports,
-                    // layer, document, nesting, starting_style, style, scope,
-                    // container) — deferred to the patch that un-gates
-                    // `BundlerAtRule = TailwindAtRule`.
-                    // TODO(port): dispatch to `x.to_css(dest)` once `R: ToCss` (or
-                    // equivalent) is threaded; current behavior is only spec-correct
-                    // for `R = DefaultAtRule`.
+                    // There are TWO concrete `R` types — `DefaultAtRule` (whose
+                    // `to_css` errors unconditionally) and `TailwindAtRule`,
+                    // whose `to_css` succeeds and writes `@tailwind <name>;`.
+                    // Tailwind parsing is disabled (`ENABLE_TAILWIND_PARSING =
+                    // false`, `BundlerAtRule = DefaultAtRule` in css_parser.rs),
+                    // so erroring here is correct for every `R` that is
+                    // actually instantiated. If
+                    // `TailwindAtRule` is ever un-gated, thread a `ToCss`-style bound
+                    // (or per-`R` vtable) so `Custom(x)` dispatches to
+                    // `x.to_css(dest)` and only the error path maps through
+                    // `add_fmt_error()`; that bound cascades through every nested
+                    // `CssRuleList<R>` printer (media, supports, layer, document,
+                    // nesting, starting_style, style, scope, container).
                     CssRule::Custom(_x) => Err(dest.add_fmt_error()),
                     CssRule::Ignored => Ok(()),
                 }
             }
 
-            /// Zig: `css.implementDeepClone(@This(), this, arena)` — variant-wise
-            /// dispatch to each leaf rule's `deep_clone`. Hand-written (not
+            /// Variant-wise dispatch to each leaf rule's `deep_clone`. Hand-written (not
             /// `#[derive(DeepClone)]`) because the leaf payloads expose `deep_clone`
             /// as **inherent** methods rather than `DeepClone` trait impls;
             /// method-syntax dispatch here picks up either.
@@ -157,17 +147,16 @@ css_rule_variants! {
 // `bun_alloc::ArenaVec<'bump, T>` (raw `NonNull<T>` + `&Bump`) deep in
 // leaf rule payloads, both of which suppress the auto-traits. Those containers
 // uniquely own their storage exactly like `Vec<T>`, and post-parse the tree is
-// shared read-only across the bundler thread pool (mirrors Zig, which freely
-// hands the arena-backed AST between threads). Thread-safety therefore follows
-// `R`'s auto-traits.
+// shared read-only across the bundler thread pool. Thread-safety therefore
+// follows `R`'s auto-traits.
 unsafe impl<R: Send> Send for CssRule<R> {}
 // SAFETY: see the `Send` impl above — uniquely-owned storage; `Sync` follows `R: Sync`.
 unsafe impl<R: Sync> Sync for CssRule<R> {}
 
-/// Zig: pub fn CssRuleList(comptime AtRule: type) type { return struct { ... } }
+/// Ordered list of CSS rules, generic over the custom at-rule type `R`.
 pub struct CssRuleList<R> {
-    // PERF(port): was `bun_alloc::ArenaVec<'bump, CssRule<'bump, R>>`;
-    // arena threading restored when leaf rules un-gate.
+    // PERF: re-thread to `bun_alloc::ArenaVec<'bump, CssRule<'bump, R>>`
+    // when leaf rules un-gate.
     pub v: Vec<CssRule<R>>,
 }
 
@@ -191,7 +180,7 @@ impl<R> Default for CssRuleList<R> {
 // wise / variant-wise port of `css.implementDeepClone`. `CssRule::deep_clone`
 // (below) dispatches via method-syntax so it picks up the inherent impl.
 //
-// PORT NOTE: most leaf rules can't use `#[derive(DeepClone)]` directly yet
+// Most leaf rules can't use `#[derive(DeepClone)]` directly yet
 // because two field types still lack an arena-aware `deep_clone(&self,
 // &Arena) -> Self`: `SelectorList` (selectors/parser.rs uses no-arg
 // `deep_clone()`) and `Property` (properties_generated.rs — per-variant body
@@ -210,7 +199,7 @@ pub(super) mod dc {
     /// through `dc::property` so the only remaining bottleneck is the
     /// per-variant `Property::deep_clone` body.
     ///
-    /// PORT NOTE: threads the real `'bump` lifetime instead of fabricating
+    /// Threads the real `'bump` lifetime instead of fabricating
     /// `'static` (PORTING.md §Forbidden: `unsafe { &*(p as *const _) }` to
     /// extend a lifetime). Callers whose storage is still pinned to
     /// `DeclarationBlock<'static>` must fix that storage type — the lie
@@ -239,7 +228,7 @@ pub(super) mod dc {
     ///
     /// SAFETY: `DeclarationBlock<'static>` is the crate-wide `'bump`-erasure
     /// placeholder until `CssRule<'bump, R>` re-threads the arena lifetime
-    /// (see `style.rs` struct PORT NOTE). `bumpalo::Vec` is invariant in
+    /// (see the note on `StyleRule.declarations` in `style.rs`). `bumpalo::Vec` is invariant in
     /// `'bump`, so any `DeclarationBlock<'static>` constructor must observe a
     /// `&'static Arena`. The arena outlives every rule that borrows it (it
     /// owns them); lifetimes re-thread together when the rule structs grow a
@@ -261,11 +250,10 @@ pub(super) mod dc {
         decl_block(this, unsafe { arena_static(bump) })
     }
 
-    /// Empty `DeclarationBlock<'static>` — Zig spec writes `css.DeclarationBlock{}`.
+    /// Empty `DeclarationBlock<'static>`.
     ///
-    /// Exists so call-sites that need an empty block (rules.zig:363
-    /// `nested_rule.declarations = .{}`) route through ONE centralized
-    /// erasure helper. Delete with `decl_block_static` once
+    /// Exists so call-sites that need an empty block route through ONE
+    /// centralized erasure helper. Delete with `decl_block_static` once
     /// `CssRule<'bump, R>` re-threads the arena lifetime.
     #[inline]
     pub(crate) fn decl_block_empty_static(bump: &Arena) -> crate::DeclarationBlock<'static> {
@@ -275,8 +263,8 @@ pub(super) mod dc {
 
     /// `'bump`-erasure adaptor for `&mut DeclarationHandler<'_>`.
     ///
-    /// SAFETY: `DeclarationBlock<'static>` on `StyleRule` (see style.rs struct
-    /// PORT NOTE) forces `DeclarationBlock::minify` to expect
+    /// SAFETY: `DeclarationBlock<'static>` on `StyleRule` (see the note on
+    /// `StyleRule.declarations` in style.rs) forces `DeclarationBlock::minify` to expect
     /// `DeclarationHandler<'static>`; the handlers in `MinifyContext` carry the
     /// real `'bump`. Both reference the same arena. Centralized here so the
     /// erasure lives in ONE place; collapses together with `decl_block_static`
@@ -325,8 +313,7 @@ pub(super) mod dc {
     }
 
     /// `Property::deep_clone` — routes to the real inherent
-    /// `Property::deep_clone` in properties_generated.rs (faithful per-variant
-    /// port of .zig:6307-6558).
+    /// `Property::deep_clone` in properties_generated.rs.
     #[inline]
     pub(crate) fn property(
         this: &crate::properties::Property,
@@ -339,7 +326,6 @@ pub(super) mod dc {
 // `Location` is plain `Copy` data; the derive expands to field-wise
 // `u32::deep_clone` (identity). Doubles as the in-tree smoke test that the
 // `#[derive(DeepClone)]` proc-macro round-trips through a real CSS type.
-// (The Zig `implementDeepClone` returns `this.*` for simple-copy types.)
 
 // ─── shared serialization helpers for leaf rules ──────────────────────────
 // Several leaf-rule `to_css` bodies bottom out on helpers whose canonical
@@ -349,8 +335,8 @@ pub(super) mod dc {
 // 12 leaf rules can serialize for real. Once the upstream gates drop, callers
 // switch back and these are deleted.
 
-/// Port of `DeclarationBlock.toCssBlock` (declaration.zig). The real impl is
-/// gated in `declaration.rs`; `Property::to_css` is un-gated so the body is
+/// `DeclarationBlock` block serialization. The real impl is gated in
+/// `declaration.rs`; `Property::to_css` is un-gated so the body is
 /// trivially inlinable here.
 pub(super) fn decl_block_to_css(
     decls: &css::DeclarationBlock<'_>,
@@ -362,7 +348,6 @@ pub(super) fn decl_block_to_css(
 
     let length = decls.len();
     let mut i: usize = 0;
-    // Zig: `inline for (.{"declarations","important_declarations"}) |field|` — unrolled.
     for decl in decls.declarations.iter() {
         dest.newline()?;
         decl.to_css(dest, false)?;
@@ -385,7 +370,7 @@ pub(super) fn decl_block_to_css(
     dest.write_char(b'}')
 }
 
-/// Port of `VendorPrefix.toCss` (css_parser.zig:182). Lives here because the
+/// `VendorPrefix` serialization. Lives here because the
 /// canonical `impl VendorPrefix` block in lib.rs hasn't grown a `to_css` yet
 /// and `rules/` is the only un-gated caller.
 #[inline]
@@ -445,7 +430,7 @@ pub(super) fn dashed_ident_to_css(
 /// rule should be dropped. NOTE: `never_matches()` is a *drop condition*, not
 /// merely an optimization — omitting it diverges output (e.g. `@media not all
 /// { a{color:red} }` must be removed). `MediaList::never_matches` is un-gated,
-/// so call it here to match the spec (`media.zig:19-23`).
+/// so call it here.
 impl<R> media::MediaRule<R> {
     pub fn minify(
         &mut self,
@@ -563,16 +548,15 @@ impl<R> CssRuleList<R> {
 
         for rule in self.v.iter_mut() {
             // NOTE Anytime you push `rule` into `rules`, set `moved_rule = true`
-            // so the source slot is replaced with `Ignored` (mirrors Zig's
-            // `defer if (moved_rule) rule.* = .ignored`).
+            // so the source slot is replaced with `Ignored`.
             let mut moved_rule = false;
 
             'arm: {
                 match rule {
                     CssRule::Keyframes(_keyframez) => {
-                        // TODO(port): KeyframesRule minify (unused-symbol drop +
-                        // same-name merge + vendor-prefix downlevel + fallbacks).
-                        // Zig leaves this as a debug-TODO fallthrough today.
+                        // KeyframesRule minify (unused-symbol drop + same-name
+                        // merge + vendor-prefix downlevel + fallbacks) is
+                        // not implemented; fall through.
                     }
                     CssRule::CustomMedia(_) => {
                         if context.custom_media.is_some() {
@@ -599,7 +583,7 @@ impl<R> CssRuleList<R> {
                         if let Some(CssRule::Supports(last_rule)) = rules.last_mut()
                             && last_rule.condition.eql(&supp.condition)
                         {
-                            // Zig drops the duplicate-condition rule outright.
+                            // Drop the duplicate-condition rule outright.
                             break 'arm;
                         }
                         supp.minify(context, parent_is_unused)?;
@@ -623,7 +607,7 @@ impl<R> CssRuleList<R> {
                         }
                     }
                     CssRule::LayerStatement(_lay) => {
-                        // TODO(port): LayerStatementRule minify — Zig fallthrough.
+                        // LayerStatementRule minify is not implemented; fall through.
                     }
                     CssRule::MozDocument(doc) => {
                         // See `Container` above: recurse so nested style rules
@@ -648,7 +632,7 @@ impl<R> CssRuleList<R> {
                             break 'arm;
                         }
                     }
-                    CssRule::CounterStyle(_) => { /* TODO(port): Zig fallthrough */ }
+                    CssRule::CounterStyle(_) => {}
                     CssRule::Scope(scpe) => {
                         // See `Container` above: recurse so nested style rules
                         // count against the selector-expansion cap.
@@ -676,8 +660,8 @@ impl<R> CssRuleList<R> {
                         // count against the selector-expansion cap.
                         rl.rules.minify(context, parent_is_unused)?;
                     }
-                    CssRule::FontPaletteValues(_) => { /* TODO(port): Zig fallthrough */ }
-                    CssRule::Property(_) => { /* TODO(port): Zig fallthrough */ }
+                    CssRule::FontPaletteValues(_) => {}
+                    CssRule::Property(_) => {}
                     _ => {}
                 }
 
@@ -699,13 +683,11 @@ impl<R> CssRuleList<R> {
             }
         }
 
-        // Zig: css.deepDeinit(CssRule(AtRule), context.arena, &this.v);
-        // Rust drops the old Vec on assignment.
+        // The old Vec is dropped on assignment.
         self.v = rules;
         Ok(())
     }
 
-    /// Zig: `css.implementDeepClone(@This(), this, arena)`.
     pub fn deep_clone<'bump>(&self, bump: &'bump bun_alloc::Arena) -> Self
     where
         R: css::generics::DeepClone<'bump>,
@@ -846,8 +828,8 @@ fn minify_style_arm<R: for<'b> css::generics::DeepClone<'b>>(
     {
         let mut rulesss = CssRuleList::<R>::default();
         core::mem::swap(&mut sty.rules, &mut rulesss);
-        // Zig: `.declarations = css.DeclarationBlock{}` — empty block. Route
-        // through the centralized `'bump`-erasure helper instead of fabricating
+        // Empty block: route through the centralized `'bump`-erasure helper
+        // instead of fabricating
         // `&'static Arena` here (PORTING.md §Forbidden).
         Some(style::StyleRule {
             selectors: sty.selectors.deep_clone(),
@@ -914,9 +896,8 @@ fn minify_style_arm<R: for<'b> css::generics::DeepClone<'b>>(
 /// duplicates. It stores an index into the live `rules` Vec plus a
 /// pre-computed hash for fast lookups.
 ///
-/// PORT NOTE: the Zig spec (`rules.zig:StyleRuleKey`) additionally stores
-/// `list: *const ArrayList(CssRule(R))` and dereferences it inside `eql()`.
-/// That pattern is unsound in Rust under Stacked/Tree Borrows — keys persist
+/// NOTE: storing a `*const Vec<CssRule<R>>` in the key and dereferencing it
+/// during equality would be unsound under Stacked/Tree Borrows — keys persist
 /// in the dedup map across iterations of `minify_style_arm`, and between
 /// iterations the same `Vec` is written through fresh `&mut` reborrows
 /// (`rules.push`, `rules[i] = Ignored`), invalidating any previously-derived
@@ -939,21 +920,20 @@ impl StyleRuleKey {
     }
 }
 
-/// Dedup table for [`StyleRuleKey`]s — the Rust-side equivalent of Zig's
-/// `StyleRuleKey(R).HashMap(usize)`.
+/// Dedup table for [`StyleRuleKey`]s.
 ///
 /// Buckets keyed by the pre-computed `StyleRule::hash_key()` hold indices into
 /// the caller's `rules` Vec; equality (`StyleRule::is_duplicate`) is evaluated
 /// against an explicitly-passed `&[CssRule<R>]` so we never smuggle a stale
-/// raw pointer across `&mut rules` writes (see PORT NOTE on `StyleRuleKey`).
+/// raw pointer across `&mut rules` writes (see the note on `StyleRuleKey`).
 #[derive(Default)]
 pub(crate) struct StyleRuleKeyMap {
     buckets: bun_collections::HashMap<u64, Vec<usize>>,
 }
 
 impl StyleRuleKeyMap {
-    /// Zig `style_rules.fetchSwapRemove(key)` — find and remove an earlier
-    /// index whose rule `is_duplicate` of `rules[key.index]`.
+    /// Find and remove an earlier index whose rule `is_duplicate` of
+    /// `rules[key.index]`.
     pub(crate) fn remove_duplicate<R>(
         &mut self,
         rules: &[CssRule<R>],
@@ -964,8 +944,7 @@ impl StyleRuleKeyMap {
             return None;
         };
         let pos = bucket.iter().position(|&other_idx| {
-            // Mirrors `StyleRuleKey.eql` from rules.zig: bounds-check + .style
-            // tag-check + `isDuplicate`.
+            // Bounds-check + Style tag-check + `is_duplicate`.
             match rules.get(other_idx) {
                 Some(CssRule::Style(other_rule)) => rule.is_duplicate(other_rule),
                 _ => false,
@@ -974,7 +953,7 @@ impl StyleRuleKeyMap {
         Some(bucket.swap_remove(pos))
     }
 
-    /// Zig `style_rules.put(ctx.arena, key, idx)`.
+    /// Record the rule's index under its style-rule key for later dedup lookups.
     pub(crate) fn insert(&mut self, key: StyleRuleKey) {
         self.buckets.entry(key.hash).or_default().push(key.index);
     }
@@ -1044,8 +1023,8 @@ pub(crate) fn merge_style_rules<R>(
         if sty.is_compatible(context.targets) && last_style_rule.is_compatible(context.targets) {
             let moved = core::mem::take(&mut sty.selectors.v);
             // `reserve` (not `ensure_total_capacity`) so capacity grows
-            // super-linearly across repeated merges — matches .zig
-            // `appendSlice` and keeps the N-way merge amortized O(N).
+            // super-linearly across repeated merges, keeping the N-way merge
+            // amortized O(N).
             last_style_rule.selectors.v.reserve(moved.len());
             for sel in moved {
                 last_style_rule.selectors.v.append_assume_capacity(sel);
@@ -1065,9 +1044,8 @@ pub(crate) fn merge_style_rules<R>(
 
 // ─── Location / StyleContext / MinifyContext ──────────────────────────────
 
-// Zig spec: `css.Location = css_rules.Location` is a TYPE ALIAS (one nominal
-// type). Re-export the crate-root struct so `css_rules::Location` and
-// `crate::Location` are interchangeable.
+// Re-export the crate-root struct so `css_rules::Location` and
+// `crate::Location` are interchangeable (one nominal type).
 pub use crate::Location;
 
 /// Printer's nesting cursor — linked list of parent selector lists used to
@@ -1094,10 +1072,9 @@ pub const MAX_SELECTOR_EXPANSION: u32 = 65_536;
 /// Per-stylesheet minification state threaded through `CssRuleList::minify`
 /// and every leaf rule's `minify`.
 ///
-/// PORT NOTE: Zig carried `arena: std.mem.Allocator` for the AST arena;
-/// here that is `&'a Arena` (bumpalo). All sub-allocations during minify go
+/// All sub-allocations during minify go
 /// through it so the whole transformed tree is bulk-freed with the arena.
-// PORT NOTE: split lifetimes — `'bump` is the parser arena (long), `'a` is the
+// Split lifetimes — `'bump` is the parser arena (long), `'a` is the
 // per-minify borrow scope (short). `&'a mut DeclarationHandler<'a>` would force
 // the handler borrow to outlive the arena (invariance via `bumpalo::Vec`),
 // making `Stylesheet::minify`'s stack-local handlers unusable.
@@ -1109,7 +1086,6 @@ pub struct MinifyContext<'a, 'bump> {
     pub important_handler: &'a mut css::DeclarationHandler<'bump>,
     pub handler_context: css::PropertyHandlerContext<'bump>,
     /// Class/id names known to be unused (tree-shaking input).
-    // PORT NOTE: Zig `*const std.StringArrayHashMapUnmanaged(void)`.
     // `selector::is_unused` currently borrows `&ArrayHashMap<&[u8], ()>`; the
     // owning `MinifyOptions` stores `Box<[u8]>` keys — reconcile when
     // `style.rs::minify` un-gates (single key type, `Borrow<[u8]>` lookup).
@@ -1119,7 +1095,7 @@ pub struct MinifyContext<'a, 'bump> {
         Option<bun_collections::ArrayHashMap<Box<[u8]>, custom_media::CustomMediaRule>>,
     pub extra: &'a css::StylesheetExtra,
     pub css_modules: bool,
-    /// First minification error encountered (Zig surfaced this out-of-band).
+    /// First minification error encountered (surfaced out-of-band).
     pub err: Option<css::error::MinifyError>,
     /// How many copies of the current rule's selectors compiling the enclosing
     /// nesting for the targets will produce — the product of the enclosing
@@ -1129,5 +1105,3 @@ pub struct MinifyContext<'a, 'bump> {
     /// will expand to, checked against [`MAX_SELECTOR_EXPANSION`].
     pub selector_expansion_total: u32,
 }
-
-// ported from: src/css/rules/rules.zig
diff --git a/src/css/rules/namespace.rs b/src/css/rules/namespace.rs
index babca2d32a8..45f38e6ab1a 100644
--- a/src/css/rules/namespace.rs
+++ b/src/css/rules/namespace.rs
@@ -29,9 +29,8 @@ impl NamespaceRule {
     }
 
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `CssString` is
-        // `*const [u8]` (arena-owned slice → identity copy per generics.zig
-        // "const strings" rule); `Ident::deep_clone` is the same identity copy.
+        // `CssString` is `*const [u8]` (arena-owned slice → identity copy);
+        // `Ident::deep_clone` is the same identity copy.
         Self {
             prefix: self.prefix.as_ref().map(|p| p.deep_clone(bump)),
             url: self.url,
@@ -39,5 +38,3 @@ impl NamespaceRule {
         }
     }
 }
-
-// ported from: src/css/rules/namespace.zig
diff --git a/src/css/rules/nesting.rs b/src/css/rules/nesting.rs
index 2617e20dfa6..db99c278929 100644
--- a/src/css/rules/nesting.rs
+++ b/src/css/rules/nesting.rs
@@ -28,12 +28,9 @@ impl<R> NestingRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             style: self.style.deep_clone(bump),
             loc: self.loc,
         }
     }
 }
-
-// ported from: src/css/rules/nesting.zig
diff --git a/src/css/rules/page.rs b/src/css/rules/page.rs
index 275c7e3b802..1e1e059661a 100644
--- a/src/css/rules/page.rs
+++ b/src/css/rules/page.rs
@@ -10,9 +10,9 @@ use super::ArrayList;
 /// Either a name or at least one pseudo class is required.
 pub struct PageSelector {
     /// An optional named page type.
-    // PORT NOTE: arena-owned slice borrowed from parser input; `&'static` per
-    // PORTING.md §AST crates / rules/mod.rs lifetime-erasure note.
-    // TODO(port): re-thread `'bump`.
+    // Arena-owned slice borrowed from parser input; `&'static` per the
+    // rules/mod.rs lifetime-erasure note.
+    // TODO: re-thread `'bump`.
     pub name: Option<&'static [u8]>,
     /// A list of page pseudo classes.
     pub pseudo_classes: ArrayList<PagePseudoClass>,
@@ -34,9 +34,7 @@ impl PageSelector {
 
 impl PageSelector {
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `name: Option<&'static
-        // [u8]>` is an arena-owned slice → identity copy; `PagePseudoClass` is
-        // `Copy`.
+        // `name` is an arena-owned slice → identity copy; `PagePseudoClass` is `Copy`.
         Self {
             name: self.name,
             pseudo_classes: self
@@ -82,7 +80,7 @@ pub struct PageMarginRule {
     /// The margin box identifier for this rule.
     pub margin_box: PageMarginBox,
     /// The declarations within the rule.
-    // PORT NOTE: lifetime erased to `'static` per rules/mod.rs `CssRule<R>` note.
+    // Lifetime erased to `'static` per the rules/mod.rs `CssRule<R>` note.
     pub declarations: DeclarationBlock<'static>,
     /// The location of the rule in the source file.
     pub loc: Location,
@@ -101,7 +99,6 @@ impl PageMarginRule {
 
 impl PageMarginRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `PageMarginBox` is `Copy`.
         Self {
             margin_box: self.margin_box,
             declarations: super::dc::decl_block_static(&self.declarations, bump),
@@ -115,7 +112,7 @@ pub struct PageRule {
     /// A list of page selectors.
     pub selectors: ArrayList<PageSelector>,
     /// The declarations within the `@page` rule.
-    // PORT NOTE: lifetime erased to `'static` per rules/mod.rs `CssRule<R>` note.
+    // Lifetime erased to `'static` per the rules/mod.rs `CssRule<R>` note.
     pub declarations: DeclarationBlock<'static>,
     /// The nested margin rules.
     pub rules: ArrayList<PageMarginRule>,
@@ -144,8 +141,7 @@ impl PageRule {
         let mut i: usize = 0;
         let len = self.declarations.len() + self.rules.len();
 
-        // PORT NOTE: Zig used `inline for` over field-name tuple + @field reflection.
-        // Unrolled to a 2-tuple of (slice, important) since both fields are property lists.
+        // Both declaration fields are property lists; iterate as (slice, important) pairs.
         let decls_groups: [(&[crate::css_parser::Property], bool); 2] = [
             (self.declarations.declarations.as_slice(), false),
             (self.declarations.important_declarations.as_slice(), true),
@@ -187,7 +183,6 @@ impl PageRule {
 
 impl PageRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             selectors: self.selectors.iter().map(|s| s.deep_clone(bump)).collect(),
             declarations: super::dc::decl_block_static(&self.declarations, bump),
@@ -258,7 +253,7 @@ pub enum PagePseudoClass {
 impl PagePseudoClass {
     #[inline]
     pub(crate) fn deep_clone(self, _bump: &bun_alloc::Arena) -> Self {
-        // `Copy` enum (generics.zig "simple copy types" → identity).
+        // `Copy` enum → identity.
         self
     }
 }
@@ -310,10 +305,7 @@ pub(crate) struct PageRuleParser<'a> {
     pub options: &'a css::ParserOptions<'a>,
 }
 
-// PORT NOTE: Zig modeled DeclarationParser/AtRuleParser/QualifiedRuleParser/
-// RuleBodyItemParser as nested `pub const Foo = struct { ... }` namespaces with
-// methods taking `*This`. In Rust these become trait impls on PageRuleParser;
-// associated `pub const X = T` → `type X = T`.
+// Parser trait impls for `@page` rule bodies.
 const _: () = {
     use css::css_parser::{
         AtRuleParser, DeclarationParser, QualifiedRuleParser, RuleBodyItemParser,
@@ -413,5 +405,3 @@ const _: () = {
         }
     }
 };
-
-// ported from: src/css/rules/page.zig
diff --git a/src/css/rules/property.rs b/src/css/rules/property.rs
index 8388e17eb41..4c4f105d40b 100644
--- a/src/css/rules/property.rs
+++ b/src/css/rules/property.rs
@@ -61,12 +61,8 @@ impl PropertyRule {
 
 impl PropertyRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `SyntaxString` has an
-        // inherent `deep_clone(&self, &Arena)`. While `ParsedComponent` is
-        // ``-gated to `()`, `Option<()>` is `Copy` → identity;
-        // once it un-gates, swap to `self.initial_value.as_ref().map(|v|
-        // v.deep_clone(bump))` (values/syntax.rs already provides the
-        // inherent impl).
+        // `SyntaxString` and `ParsedComponent` provide inherent
+        // `deep_clone(&self, &Arena)` impls.
         Self {
             name: self.name.deep_clone(bump),
             syntax: self.syntax.deep_clone(bump),
@@ -92,8 +88,8 @@ impl PropertyRule {
             initial_value: None,
         };
 
-        // PORT NOTE: split the borrows — `RuleBodyParser` borrows `input`+`p`;
-        // we re-borrow `input` after dropping `decl_parser`.
+        // `RuleBodyParser` borrows `input`+`p`; re-borrow `input` after
+        // dropping `decl_parser`.
         {
             let mut decl_parser = RuleBodyParser::new(input, &mut p);
             while let Some(decl) = decl_parser.next() {
@@ -156,18 +152,16 @@ impl PropertyRule {
     }
 }
 
-// PORT NOTE: borrows the parser input buffer for `initial_value` (arena-backed
-// in CSS crate). Kept as `&'static [u8]` per PORTING.md §AST crates;
-// TODO(refactor): re-thread `'i`.
+// Borrows the parser input buffer for `initial_value` (arena-backed in the
+// CSS crate). Kept as `&'static [u8]` per the rules/mod.rs lifetime-erasure
+// note; TODO(refactor): re-thread `'i`.
 pub(crate) struct PropertyRuleDeclarationParser {
     pub syntax: Option<SyntaxString>,
     pub inherits: Option<bool>,
     pub initial_value: Option<&'static [u8]>,
 }
 
-// PORT NOTE: Zig's nested `pub const DeclarationParser = struct { ... }`
-// namespaces are structural duck-typing for RuleBodyParser; in Rust these
-// become trait impls.
+// Parser trait impls for `@property` rule bodies.
 const _: () = {
     use css::css_parser::{
         AtRuleParser, DeclarationParser, QualifiedRuleParser, RuleBodyItemParser,
@@ -177,8 +171,6 @@ const _: () = {
     impl DeclarationParser for PropertyRuleDeclarationParser {
         type Declaration = ();
 
-        // TODO(port): the Zig defines a ComptimeStringMap over FieldEnum but never uses it
-        // (usage is commented out). Preserved the active if/else-if chain instead.
         fn parse_value(
             this: &mut Self,
             name: &[u8],
@@ -273,5 +265,3 @@ const _: () = {
         }
     }
 };
-
-// ported from: src/css/rules/property.zig
diff --git a/src/css/rules/scope.rs b/src/css/rules/scope.rs
index 63f9fc7d35b..cf880646bf4 100644
--- a/src/css/rules/scope.rs
+++ b/src/css/rules/scope.rs
@@ -33,7 +33,7 @@ impl<R> ScopeRule<R> {
         if let Some(scope_start) = &self.scope_start {
             dest.write_char(b'(')?;
             // scope_start.to_css(dest)?;
-            // PORT NOTE: read `dest.ctx` directly (Copy) — `Printer::context()`
+            // Read `dest.ctx` directly (Copy) — `Printer::context()`
             // ties the borrow to `&self`, which conflicts with `&mut dest`.
             let ctx = dest.ctx;
             serialize_selector_list(scope_start.v.slice(), dest, ctx, false)?;
@@ -48,7 +48,6 @@ impl<R> ScopeRule<R> {
             // <scope-start> is treated as an ancestor of scope end.
             // https://drafts.csswg.org/css-nesting/#nesting-at-scope
             if let Some(scope_start) = &self.scope_start {
-                // PORT NOTE: Zig passed an anon-struct fn pointer; the Rust
                 // `Printer::with_context` carries the captured state as the
                 // first closure arg (no `&self` capture across `&mut dest`).
                 dest.with_context(
@@ -85,9 +84,9 @@ impl<R> ScopeRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `SelectorList::
-        // deep_clone()` intentionally drops the `&Arena` (selectors/parser.rs
-        // — every payload is arena-static); routed via `dc::selector_list`.
+        // `SelectorList::deep_clone()` intentionally drops the `&Arena`
+        // (selectors/parser.rs — every payload is arena-static); routed via
+        // `dc::selector_list`.
         Self {
             scope_start: self
                 .scope_start
@@ -102,5 +101,3 @@ impl<R> ScopeRule<R> {
         }
     }
 }
-
-// ported from: src/css/rules/scope.zig
diff --git a/src/css/rules/starting_style.rs b/src/css/rules/starting_style.rs
index ef368fd10db..f7a2ee60916 100644
--- a/src/css/rules/starting_style.rs
+++ b/src/css/rules/starting_style.rs
@@ -27,12 +27,9 @@ impl<R> StartingStyleRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             rules: self.rules.deep_clone(bump),
             loc: self.loc,
         }
     }
 }
-
-// ported from: src/css/rules/starting_style.zig
diff --git a/src/css/rules/style.rs b/src/css/rules/style.rs
index f507372492e..8474c12b251 100644
--- a/src/css/rules/style.rs
+++ b/src/css/rules/style.rs
@@ -5,12 +5,12 @@ use crate::error::MinifyErr;
 use crate::selectors::selector;
 use crate::{PrintErr, Printer, VendorPrefix};
 
-// `fn StyleRule(comptime R: type) type { return struct {...} }` → generic struct.
+// `StyleRule` is generic over the custom at-rule type `R`.
 //
-// PORT NOTE: `DeclarationBlock<'bump>` borrows the parser arena (bumpalo Vecs).
+// `DeclarationBlock<'bump>` borrows the parser arena (bumpalo Vecs).
 // Threading `'bump` here cascades into `CssRule<'bump, R>` / `CssRuleList<'bump, R>`
-// (rules/mod.rs PORT NOTE) which is deferred until the leaf rules un-gate
-// together; for now the lifetime is erased to `'static`.
+// (see the rules/mod.rs lifetime-erasure note); for now the lifetime is erased
+// to `'static`.
 pub struct StyleRule<R> {
     /// The selectors for the style rule.
     pub selectors: selector::parser::SelectorList,
@@ -36,13 +36,11 @@ impl<R> StyleRule<R> {
     /// Returns a hash of this rule for use when deduplicating.
     /// Includes the selectors and properties.
     pub fn hash_key(&self) -> u64 {
-        // std.hash.Wyhash.init(0) — same algorithm as bun.hash
+        // Wyhash seeded with 0 — same algorithm as bun.hash
         let mut hasher = bun_wyhash::Wyhash::init(0);
         self.selectors.hash(&mut hasher);
-        // PORT NOTE: `DeclarationBlock::hash_property_ids` is still
-        // ``-gated in declaration.rs; inline its body here. The
-        // Zig `PropertyId.hash` is `hasher.update(asBytes(&@intFromEnum(self)))`
-        // — i.e. just the u16 tag bytes.
+        // Inlined `DeclarationBlock::hash_property_ids`: hash just the u16
+        // property-id tag bytes.
         for decl in self.declarations.declarations.iter() {
             let tag = decl.property_id().tag() as u16;
             hasher.update(&tag.to_ne_bytes());
@@ -175,7 +173,7 @@ impl<R> StyleRule<R> {
             //   #[cfg(feature = "sourcemap")]
             //   dest.add_mapping(self.loc);
 
-            // PORT NOTE: `dest.context()` borrows `dest`; copy the (Copy) raw
+            // `dest.context()` borrows `dest`; copy the (Copy) raw
             // ctx field out so it doesn't conflict with the `&mut *dest` below.
             let ctx = dest.ctx;
             // Each rule prelude gets its own budget for `&` substitutions when
@@ -192,8 +190,8 @@ impl<R> StyleRule<R> {
             dest.indent();
 
             let mut i: usize = 0;
-            // Zig: inline for (.{"declarations", "important_declarations"}) — @field reflection.
-            // Unrolled into a pair of (slice, important) tuples; same iteration order.
+            // A pair of (slice, important) tuples; declarations first, then
+            // important declarations.
             let decls_groups: [(&[Property], bool); 2] = [
                 (self.declarations.declarations.as_slice(), false),
                 (self.declarations.important_declarations.as_slice(), true),
@@ -211,10 +209,8 @@ impl<R> StyleRule<R> {
                         }
 
                         if dest.css_module.is_some() {
-                            // PORT NOTE: reshaped for borrowck — Zig
-                            // `if (dest.css_module) |*css_module|
-                            //     css_module.handleComposes(dest, ...)` overlaps
-                            // `&mut dest.css_module` with `&mut *dest`. Move the
+                            // `handle_composes` needs `&mut dest` while the
+                            // module also lives in `dest.css_module`. Move the
                             // module out for the duration of the call, then put
                             // it back before any `dest.new_error` early return.
                             let mut cm = dest.css_module.take();
@@ -250,7 +246,6 @@ impl<R> StyleRule<R> {
             }
         }
 
-        // Zig: local `Helpers` struct with two fns. Rust: nested fn items (no capture needed).
         fn helpers_newline<R>(
             self_: &StyleRule<R>,
             d: &mut Printer,
@@ -303,8 +298,7 @@ impl<R> StyleRule<R> {
                 helpers_newline(self, dest, supports_nesting, len)?;
             }
             dest.skip_prefixed_nested_rules = skip_prefixed_nested;
-            // Zig: dest.withContext(&this.selectors, this, struct { fn toCss(...) }.toCss)
-            // Rust `with_context` keeps the (closure-data, fn) split so the
+            // `with_context` keeps the (closure-data, fn) split so the
             // `Printer` reborrow lives only inside `func`.
             let result =
                 dest.with_context(&self.selectors, &self.rules, |rules, d| rules.to_css(d));
@@ -327,13 +321,6 @@ impl<R> StyleRule<R> {
         use css::context::DeclarationContext;
 
         let mut unused = false;
-        // TODO(port): blocked_on key-type mismatch — `selector::is_unused` takes
-        // `&ArrayHashMap<&[u8], ()>` but `MinifyContext.unused_symbols` is
-        // `&ArrayHashMap<Box<[u8]>, ()>` (rules/mod.rs PORT NOTE: "reconcile when
-        // style.rs::minify un-gates — single key type, Borrow<[u8]> lookup").
-        // The reconciliation lives in rules/mod.rs + selectors/selector.rs, not
-        // here; gate the body until those agree.
-
         if context.unused_symbols.count() > 0 {
             if selector::is_unused(
                 self.selectors.v.slice(),
@@ -368,7 +355,7 @@ impl<R> StyleRule<R> {
         // }
 
         context.handler_context.context = DeclarationContext::StyleRule;
-        // PORT NOTE: `DeclarationBlock<'static>` (struct PORT NOTE above) forces
+        // `DeclarationBlock<'static>` (see the struct-level note above) forces
         // `minify` to want `DeclarationHandler<'static>`; route through the
         // single centralized `'bump`-erasure helper instead of open-coding the
         // lifetime cast. Collapses when `CssRule<'bump, R>`
@@ -484,13 +471,12 @@ impl<R> StyleRule<R> {
                     .declarations
                     .len()
                     .min(other.declarations.declarations.len());
-                // for (a, b) |*a, *b| → zip; Zig asserts equal length but here len is @min so truncation is intended.
+                // len is the min of the two lengths, so truncation is intended.
                 for (a, b) in self.declarations.declarations[..len]
                     .iter()
                     .zip(&other.declarations.declarations[..len])
                 {
-                    // PORT NOTE: Zig `PropertyId.eql` == tag+prefix compare;
-                    // that's exactly the `PartialEq` impl on `PropertyId`.
+                    // `PropertyId`'s `PartialEq` is a tag+prefix compare.
                     if a.property_id() != b.property_id() {
                         break 'brk false;
                     }
@@ -519,10 +505,10 @@ impl<R> StyleRule<R> {
     where
         R: crate::generics::DeepClone<'bump>,
     {
-        // css is an AST crate (PORTING.md §Allocators): std.mem.Allocator → &'bump Bump, threaded.
-        // PORT NOTE: `css.implementDeepClone` field-walk. `declarations` routes
-        // through `dc::decl_block` until `DeclarationBlock::deep_clone` un-gates
-        // (declaration.rs — bottoms out on `Property: DeepClone`).
+        // css is an AST crate (PORTING.md §Allocators): the allocator is &'bump Bump, threaded.
+        // `declarations` routes through `dc::decl_block` until
+        // `DeclarationBlock::deep_clone` un-gates (declaration.rs — bottoms out
+        // on `Property: DeepClone`).
         Self {
             selectors: self.selectors.deep_clone(),
             vendor_prefix: self.vendor_prefix,
@@ -532,5 +518,3 @@ impl<R> StyleRule<R> {
         }
     }
 }
-
-// ported from: src/css/rules/style.zig
diff --git a/src/css/rules/supports.rs b/src/css/rules/supports.rs
index c4c5c7cf50f..ff8920f725f 100644
--- a/src/css/rules/supports.rs
+++ b/src/css/rules/supports.rs
@@ -7,8 +7,8 @@ use bun_alloc::ArenaPtr;
 
 /// A [`<supports-condition>`](https://drafts.csswg.org/css-conditional-3/#typedef-supports-condition),
 /// as used in the `@supports` and `@import` rules.
-// PORT NOTE: Zig threaded the parser-input lifetime (`[]const u8` slices borrow
-// the source). Currently uses `&'static [u8]` per PORTING.md §AST crates;
+// String payloads borrow the parser input/arena; currently `&'static [u8]`
+// per the rules/mod.rs lifetime-erasure note.
 // TODO(refactor): re-thread `'i` once `PropertyId<'i>` and the parser arena are real.
 pub enum SupportsCondition {
     /// A `not` expression.
@@ -30,8 +30,8 @@ pub enum SupportsCondition {
     Unknown(&'static [u8]),
 }
 
-// PORT NOTE: Zig used an anonymous inline struct for the `.declaration` payload;
-// hoisted to a named type because Rust enum variants cannot carry inherent methods.
+// Named payload type for `SupportsCondition::Declaration` (enum variants
+// cannot carry inherent methods).
 pub struct Declaration {
     /// The property id for the declaration.
     pub property_id: PropertyId,
@@ -44,9 +44,7 @@ pub struct Declaration {
 
 impl Declaration {
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `PropertyId` is `Copy`;
-        // `value: &'static [u8]` is an arena-owned slice → identity copy
-        // (generics.zig "const strings" rule).
+        // `PropertyId` is `Copy`; `value` is an arena-owned slice → identity copy.
         Self {
             property_id: self.property_id,
             value: self.value,
@@ -56,7 +54,6 @@ impl Declaration {
 
 impl Declaration {
     pub(crate) fn eql(&self, other: &Self) -> bool {
-        // PORT NOTE: Zig `css.implementEql` field-walk, hand-expanded.
         // `PropertyId` carries its own tag+prefix `PartialEq` (see
         // properties_generated.rs `impl PartialEq for PropertyId`); `value` is
         // byte-slice equality.
@@ -74,7 +71,7 @@ impl SupportsCondition {
     }
 
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> SupportsCondition {
-        // PORT NOTE: `css.implementDeepClone` variant-walk (hand-rolled —
+        // Hand-rolled variant-walk —
         // `#[derive(DeepClone)]` can't be used while `Selector`/`Unknown`
         // carry `&'static [u8]`; the blanket `&'bump [u8]` impl doesn't unify
         // with a fresh `'__bump`).
@@ -107,10 +104,9 @@ impl SupportsCondition {
     // `impl CssHash for PropertyId` then swap to `#[derive(CssHash)]`.
 
     pub fn hash(&self, hasher: &mut bun_wyhash::Wyhash) {
-        // PORT NOTE: Zig `css.implementHash` variant-walk, hand-expanded because
-        // `#[derive(CssHash)]` would require `PropertyId: CssHash` (it only
-        // provides `core::hash::Hash`). Semantics match the Zig reflection:
-        // hash the discriminant, then field-wise structural hash.
+        // Hand-expanded because `#[derive(CssHash)]` would require
+        // `PropertyId: CssHash` (it only provides `core::hash::Hash`).
+        // Hash the discriminant, then field-wise structural hash.
         use core::hash::{Hash, Hasher};
         core::mem::discriminant(self).hash(hasher);
         match self {
@@ -130,10 +126,9 @@ impl SupportsCondition {
     }
 
     pub fn eql(&self, other: &SupportsCondition) -> bool {
-        // PORT NOTE: Zig `css.implementEql` variant-walk, hand-expanded because
-        // `#[derive(CssEql)]` would require `PropertyId: CssEql` (it only
-        // provides the custom tag+prefix `PartialEq`). Semantics match the Zig
-        // reflection: tag mismatch → false, then field-wise structural eq.
+        // Hand-expanded because `#[derive(CssEql)]` would require
+        // `PropertyId: CssEql` (it only provides the custom tag+prefix
+        // `PartialEq`). Tag mismatch → false, then field-wise structural eq.
         match (self, other) {
             (Self::Not(a), Self::Not(b)) => a.eql(b),
             (Self::And(a), Self::And(b)) | (Self::Or(a), Self::Or(b)) => {
@@ -155,10 +150,6 @@ impl crate::generics::CssEql for SupportsCondition {
 }
 
 impl SupportsCondition {
-    // PORT NOTE: `pub fn deinit` dropped — body only freed Box/Vec payloads which Rust
-    // drops automatically. Input-slice variants (`Declaration`/`Selector`/`Unknown`)
-    // were no-ops in Zig as well (arena/input-owned).
-
     fn needs_parens(&self, parent: &SupportsCondition) -> bool {
         match self {
             SupportsCondition::Not(_) => true,
@@ -233,11 +224,8 @@ impl SupportsCondition {
         }
 
         let name = property_id.name();
-        // PORT NOTE: `inline for (css.VendorPrefix.FIELDS) |field| { if @field(prefix, field) ... }`
-        // iterates the packed-struct bool fields at comptime. VendorPrefix ports to
-        // bitflags!; iterate the ordered single-bit table directly (same pattern as
-        // rules/style.rs). The Zig also builds `var p = VendorPrefix{}; @field(p, field) = true;`
-        // but never reads it — dead store dropped.
+        // Iterate the ordered single-bit VendorPrefix table directly (same
+        // pattern as rules/style.rs).
         dest.write_separated(
             css::VendorPrefix::FIELDS
                 .iter()
@@ -283,14 +271,12 @@ impl SupportsCondition {
         let mut expected_type: Option<i32> = None;
         let mut conditions: Vec<SupportsCondition, ArenaPtr> =
             Vec::new_in(ArenaPtr::new(input.arena()));
-        // PORT NOTE: Zig used std.ArrayHashMap with an inline custom hash/eql context;
-        // SeenDeclKey below carries equivalent Hash/Eq impls.
+        // `SeenDeclKey` below carries the custom Hash/Eq impls for this map.
         let mut seen_declarations: ArrayHashMap<SeenDeclKey, usize> = ArrayHashMap::new();
 
         loop {
-            // PORT NOTE: reshaped for borrowck — Zig threaded `*?i32` through a
-            // local `Closure` struct (LIFETIMES.tsv: BORROW_PARAM); a Rust closure
-            // capturing `&mut expected_type` is the direct equivalent.
+            // A closure capturing `&mut expected_type` threads the expected
+            // type through the parse attempt.
             let _condition =
                 input.try_parse(|i: &mut css::Parser| -> css::Result<SupportsCondition> {
                     let location = i.current_source_location();
@@ -421,16 +407,14 @@ impl SupportsCondition {
     }
 }
 
-// PORT NOTE: Zig `SeenDeclKey` was a tuple struct with an inline hash-map context
-// providing custom hash/eql. Ported as a tuple struct with manual Hash/PartialEq
-// matching the Zig context exactly (wrapping_add of string hash and enum int).
+// Dedup key for `@supports` declaration conditions; manual Hash/PartialEq
+// (wrapping_add of string hash and enum int).
 struct SeenDeclKey(PropertyId, &'static [u8]);
 
 impl core::hash::Hash for SeenDeclKey {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        // TODO(port): Zig used std.array_hash_map.hashString (wyhash, 32-bit) +% @intFromEnum.
-        // bun_collections::ArrayHashMap is wyhash-backed; confirm hasher parity.
-        // PORT NOTE: hash_string returns u32 directly (mirrors Zig hashString) — no narrowing cast.
+        // wyhash of the value bytes +% the property-id tag.
+        // `hash_string` returns u32 directly — no narrowing cast.
         let h: u32 = bun_collections::array_hash_map::hash_string(self.1);
         state.write_u32(h.wrapping_add(self.0.tag() as u32));
     }
@@ -438,7 +422,7 @@ impl core::hash::Hash for SeenDeclKey {
 
 impl PartialEq for SeenDeclKey {
     fn eq(&self, other: &Self) -> bool {
-        // Zig: tag-only equality + slice byte equality.
+        // Tag-only equality + slice byte equality.
         self.0.tag() as u16 == other.0.tag() as u16 && self.1 == other.1
     }
 }
@@ -494,7 +478,6 @@ impl<R> SupportsRule<R> {
     where
         R: css::generics::DeepClone<'bump>,
     {
-        // PORT NOTE: `css.implementDeepClone` field-walk.
         Self {
             condition: self.condition.deep_clone(bump),
             rules: self.rules.deep_clone(bump),
@@ -502,5 +485,3 @@ impl<R> SupportsRule<R> {
         }
     }
 }
-
-// ported from: src/css/rules/supports.zig
diff --git a/src/css/rules/tailwind.rs b/src/css/rules/tailwind.rs
index 78686113eb4..b7427b0608a 100644
--- a/src/css/rules/tailwind.rs
+++ b/src/css/rules/tailwind.rs
@@ -46,5 +46,3 @@ pub enum TailwindStyleName {
     /// your stylesheet by default.
     Variants,
 }
-
-// ported from: src/css/rules/tailwind.zig
diff --git a/src/css/rules/unknown.rs b/src/css/rules/unknown.rs
index a8a934d5414..bac6abcaaf7 100644
--- a/src/css/rules/unknown.rs
+++ b/src/css/rules/unknown.rs
@@ -5,7 +5,7 @@ use crate::{PrintErr, Printer};
 /// An unknown at-rule, stored as raw tokens.
 pub struct UnknownAtRule {
     /// The name of the at-rule (without the @).
-    // TODO(port): arena lifetime — Zig `[]const u8` backed by parser arena.
+    // TODO: arena lifetime — slice backed by parser arena.
     pub name: &'static [u8],
     /// The prelude of the rule.
     pub prelude: TokenList,
@@ -40,9 +40,8 @@ impl UnknownAtRule {
 
     pub fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
         use crate::generics::DeepClone as _;
-        // PORT NOTE: `css.implementDeepClone` field-walk. `name: &'static [u8]`
-        // is an arena-owned slice → identity copy (generics.zig "const strings"
-        // rule); `TokenList` carries `#[derive(DeepClone)]`.
+        // `name` is an arena-owned slice → identity copy; `TokenList`
+        // carries `#[derive(DeepClone)]`.
         Self {
             name: self.name,
             prelude: self.prelude.deep_clone(bump),
@@ -51,5 +50,3 @@ impl UnknownAtRule {
         }
     }
 }
-
-// ported from: src/css/rules/unknown.zig
diff --git a/src/css/rules/viewport.rs b/src/css/rules/viewport.rs
index 445fe43d4dc..8e1514c964b 100644
--- a/src/css/rules/viewport.rs
+++ b/src/css/rules/viewport.rs
@@ -6,8 +6,8 @@ pub struct ViewportRule {
     /// The vendor prefix for this rule, e.g. `@-ms-viewport`.
     pub vendor_prefix: VendorPrefix,
     /// The declarations within the `@viewport` rule.
-    // PORT NOTE: `DeclarationBlock<'bump>` borrows the parser arena; lifetime
-    // erased to `'static` here per the rules/mod.rs `CssRule<R>` PORT NOTE
+    // `DeclarationBlock<'bump>` borrows the parser arena; the lifetime is
+    // erased to `'static` here, matching `CssRule<R>` in rules/mod.rs
     // (the `'bump` arena lifetime is re-threaded crate-wide in one pass).
     pub declarations: DeclarationBlock<'static>,
     /// The location of the rule in the source file.
@@ -27,8 +27,6 @@ impl ViewportRule {
 
 impl ViewportRule {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: `css.implementDeepClone` field-walk. `VendorPrefix` is a
-        // `Copy` bitflag (generics.zig "simple copy types" → identity).
         Self {
             vendor_prefix: self.vendor_prefix,
             declarations: super::dc::decl_block_static(&self.declarations, bump),
@@ -36,5 +34,3 @@ impl ViewportRule {
         }
     }
 }
-
-// ported from: src/css/rules/viewport.zig
diff --git a/src/css/selectors/builder.rs b/src/css/selectors/builder.rs
index 35969127a18..2960324c722 100644
--- a/src/css/selectors/builder.rs
+++ b/src/css/selectors/builder.rs
@@ -86,9 +86,8 @@ impl<Impl: ValidSelectorImpl> SelectorBuilder<Impl> {
     /// by the given combinator.
     #[inline]
     pub(crate) fn push_combinator(&mut self, combinator: Combinator) {
-        // PORT NOTE: `SmallList::append/insert` no longer take an arena —
-        // it owns its spill buffer (global arena). The `bump` field is
-        // retained for `BuildResult.components` (BumpVec) only.
+        // `SmallList` owns its spill buffer (global arena); the `bump` field
+        // is retained for `BuildResult.components` (BumpVec) only.
         self.combinators.append((combinator, self.current_len));
         self.current_len = 0;
     }
@@ -105,9 +104,8 @@ impl<Impl: ValidSelectorImpl> SelectorBuilder<Impl> {
         self.simple_selectors.insert(0, GenericComponent::Nesting);
     }
 
-    // PORT NOTE: Zig `deinit` only freed `simple_selectors` and `combinators`.
-    // In Rust, `SmallList` owns its spill buffer and frees on `Drop`, so no
-    // explicit `Drop` impl is needed here.
+    // `SmallList` owns its spill buffer and frees on `Drop`, so no explicit
+    // `Drop` impl is needed here.
 
     /// Consumes the builder, producing a Selector.
     ///
@@ -129,10 +127,9 @@ impl<Impl: ValidSelectorImpl> SelectorBuilder<Impl> {
         if parsed_part {
             flags |= SelectorFlags::HAS_PART;
         }
-        // `build_with_specificity_and_flags()` will
-        // PORT NOTE: Zig had `defer this.deinit()` here to free SmallList capacity
-        // after building. In Rust, `Drop` on `SelectorBuilder` handles this when the
-        // builder goes out of scope; the call below already drains the contents.
+        // `build_with_specificity_and_flags()` drains the contents; `Drop` on
+        // `SelectorBuilder` frees the SmallList capacity when the builder goes
+        // out of scope.
         self.build_with_specificity_and_flags(SpecificityAndFlags { specificity, flags })
     }
 
@@ -151,8 +148,7 @@ impl<Impl: ValidSelectorImpl> SelectorBuilder<Impl> {
         &mut self,
         spec: SpecificityAndFlags,
     ) -> BuildResult<Impl> {
-        // PORT NOTE: reshaped for borrowck — capture combinators.len()
-        // before borrowing simple_selectors.slice().
+        // Capture combinators.len() before borrowing simple_selectors.slice().
         let combinators_len = self.combinators.len();
 
         let (rest, current) = split_from_end::<GenericComponent<Impl>>(
@@ -170,7 +166,6 @@ impl<Impl: ValidSelectorImpl> SelectorBuilder<Impl> {
 
         loop {
             if current_simple_selectors_i < current_simple_selectors.len() {
-                // PORT NOTE: Zig copies the component by value here (struct copy).
                 // `GenericComponent<Impl>` is not `Copy`; we bitwise-move it out
                 // via `ptr::read` — sound because every element of
                 // `simple_selectors` is consumed exactly once across the loop,
@@ -222,5 +217,3 @@ pub(crate) fn split_from_end<T>(s: &[T], at: usize) -> (&[T], &[T]) {
     let midpoint = s.len() - at;
     (&s[0..midpoint], &s[midpoint..])
 }
-
-// ported from: src/css/selectors/builder.zig
diff --git a/src/css/selectors/mod.rs b/src/css/selectors/mod.rs
index 4f5433deff0..6e80b609962 100644
--- a/src/css/selectors/mod.rs
+++ b/src/css/selectors/mod.rs
@@ -13,8 +13,7 @@
 //! the two serializer namespaces (`serialize::*`, `tocss_servo::*`).
 //! `builder.rs` carries `SelectorBuilder`.
 //!
-//! The `impl_::Selectors` marker (Rust trait-based reshaping of Zig's
-//! `selector.impl.Selectors.SelectorImpl` type-alias namespace) lives here in
+//! The `impl_::Selectors` marker lives here in
 //! the hub so the parser↔selector cycle has a single anchor; both files reach
 //! it via `bun_css::selector::impl_` / `super::impl_`.
 
@@ -25,9 +24,9 @@ pub mod selector;
 
 pub use parser::{Component, PseudoClass, PseudoElement, Selector, SelectorList};
 
-/// Our implementation of the `SelectorImpl` interface — the Rust-shaped
-/// equivalent of Zig's `selector.impl.Selectors`. Defined in the hub (not in
-/// `selector.rs`) to break the parser↔selector dependency cycle: `parser.rs`
+/// Our implementation of the `SelectorImpl` interface. Defined in the hub
+/// (not in `selector.rs`) to break the parser↔selector dependency cycle:
+/// `parser.rs`
 /// needs `impl_::Selectors` to instantiate `Component`/`Selector`/
 /// `SelectorList`, and `selector.rs` needs those instantiations.
 pub mod impl_ {
@@ -48,7 +47,7 @@ pub mod impl_ {
         type LocalIdentifier = IdentOrRef;
         type LocalName = Ident;
         type NamespacePrefix = Ident;
-        // TODO(port): lifetime — Zig `[]const u8` type alias borrowing input.
+        // TODO: lifetime — should borrow the parser input.
         type NamespaceUrl = &'static [u8];
         type BorrowedNamespaceUrl = &'static [u8];
         type BorrowedLocalName = Ident;
diff --git a/src/css/selectors/parser.rs b/src/css/selectors/parser.rs
index 49bffbe820d..f82080fb625 100644
--- a/src/css/selectors/parser.rs
+++ b/src/css/selectors/parser.rs
@@ -1,4 +1,4 @@
-//! CSS selector parser — ported from `src/css/selectors/parser.zig`.
+//! CSS selector parser.
 //! Originally derived from servo/lightningcss selector parsing.
 
 use core::fmt;
@@ -23,11 +23,10 @@ pub use bun_css::Printer as PrinterRe; // re-export parity (Printer/PrintErr wer
 /// `css::Result<T>` — the CSS parser result type (`Ok(T)` / `Err(css::ParseError)`).
 type CResult<T> = css::Result<T>;
 
-// TODO(port): arena lifetimes. The Zig code threads `parser.arena` / `input.arena()`
-// (a bump arena) through every allocation. The Rust port uses `Vec`/`Box` and a `Str` alias for
-// source-borrowed byte slices; re-thread `'bump` and switch to
-// `bun_alloc::ArenaVec<'bump, T>` / `&'bump [u8]` per PORTING.md §Allocators (AST crates).
-// PERF(port): was arena bulk-free — profile if it shows up on a hot path.
+// Arena lifetimes: this module uses `Vec`/`Box` and a `Str`
+// alias for source-borrowed byte slices until the crate-wide `'bump` re-threading
+// (`bun_alloc::ArenaVec<'bump, T>` / `&'bump [u8]` per PORTING.md §Allocators
+// (AST crates)) lands.
 //
 // NOTE: `Str` is `&'static [u8]` here (not `crate::Str = *const [u8]`) to match
 // `crate::Token`'s payload shape (`Token::Ident(&'static [u8])` etc.) — every
@@ -37,8 +36,7 @@ type CResult<T> = css::Result<T>;
 type Str = &'static [u8]; // arena-backed `[]const u8` source slice
 
 // ─── Protocol traits ─────────────────────────────────────────────────────────
-// Zig's `implementEql` / `implementHash` / `implementDeepClone` are comptime
-// field/variant reflection over `@typeInfo(T)` — in Rust this is the body of
+// `eql` / `hash` / `deep_clone` are field/variant reflection, provided by
 // `#[derive(CssEql, CssHash, DeepClone)]` (`bun_css_derive`). Non-generic
 // grammar types below carry the derive directly; the `<Impl: SelectorImpl>`-
 // generic types hand-write bodies (the derive's `where Impl: CssEql` bound is
@@ -50,7 +48,7 @@ use css::generics::{CssEql, CssHash};
 
 /// Drain a `SmallList<T, N>` into a `Box<[T]>`. `SmallList` has no `into_vec`;
 /// this bitwise-moves each element out and `set_len(0)`s the source so its
-/// `Drop` doesn't double-free. Mirrors Zig `toOwnedSlice`.
+/// `Drop` doesn't double-free.
 fn small_list_into_box<T, const N: usize>(mut sl: SmallList<T, N>) -> Box<[T]> {
     let len = sl.len() as usize;
     let mut v: Vec<T> = Vec::with_capacity(len);
@@ -67,13 +65,11 @@ fn small_list_into_box<T, const N: usize>(mut sl: SmallList<T, N>) -> Box<[T]> {
 }
 
 /// Allocate an ASCII-lowercased copy of `name` in the parse-session bump arena.
-/// Zig used `parser.arena().alloc(u8, n)` (the bump arena owns the buffer
-/// for the parse session and frees it on arena reset). Returns a raw arena
+/// Returns a raw arena
 /// pointer (`*const [u8]`) — `Ident.v`'s field type — so we don't fabricate a
 /// `'static` lifetime (PORTING.md §Forbidden: never `Box::leak` to satisfy
 /// `&'static`). Re-threading `&'bump Bump` would widen `Ident.v` to
 /// `&'bump [u8]`.
-// PERF(port): was arena alloc — profile if it shows up on a hot path.
 #[inline]
 fn arena_lowercase(bump: &Bump, name: &[u8]) -> *const [u8] {
     let buf = bump.alloc_slice_fill_copy(name.len(), 0u8);
@@ -123,13 +119,12 @@ pub const SELECTOR_WHITESPACE: &[u8] = &[b' ', b'\t', b'\n', b'\r', 0x0C];
 /// Compile-time check that `T` satisfies the `SelectorImpl` trait shape.
 /// In Rust this is expressed as a trait bound; this fn is kept for diff parity.
 pub fn valid_selector_impl<T: SelectorImpl>() {
-    // Zig used `_ = T.SelectorImpl.X;` to force decl resolution; in Rust the trait
-    // bound `T: SelectorImpl` is the check.
+    // The trait bound `T: SelectorImpl` is the check.
 }
 
-/// The `SelectorImpl` shape (Zig validated via `ValidSelectorImpl`). Implemented
+/// The `SelectorImpl` shape. Implemented
 /// by `impl_::Selectors` in `bun_css::selector::impl_`.
-// PORT NOTE: `PartialEq + Clone` bounds dropped — the concrete assoc types
+// `PartialEq + Clone` bounds dropped — the concrete assoc types
 // (`values::ident::{Ident,IdentOrRef}`, `*const [u8]`) implement structural
 // equality via the `CssEql` protocol (`generics::implement_eql`), not
 // `core::cmp::PartialEq`. Every `eql`/`deep_clone`/`hash` callsite in this
@@ -152,9 +147,8 @@ pub trait SelectorImpl: Sized {
 
 /// Constrained `SelectorImpl` with the concrete assoc-type bundle Bun uses.
 ///
-/// PORT NOTE: in Zig the `parse_*` functions were `comptime Impl: type` generics
-/// but every body assumed the concrete `selector.impl.Selectors` shapes (it was
-/// the only instantiation). Rust can't see through the open `Impl::LocalName`
+/// Every `parse_*` body assumes the concrete `selector.impl.Selectors` shapes
+/// (the only instantiation). Rust can't see through the open `Impl::LocalName`
 /// to `Ident`, so the parse functions bound on this sub-trait instead — the
 /// associated-type equality clauses make `Impl::LocalName == Ident` etc.
 /// visible to the body without monomorphizing the signature.
@@ -328,7 +322,7 @@ pub mod attrs {
         },
     }
 
-    // PORT NOTE: implemented for the concrete `AttrValue = css::CSSString`
+    // Implemented for the concrete `AttrValue = css::CSSString`
     // (= `*const [u8]`) only — the sole `BunSelectorImpl` instantiation.
     impl ParsedAttrSelectorOperation<css::CSSString> {
         pub fn deep_clone(&self) -> Self {
@@ -559,7 +553,10 @@ fn compute_simple_selector_specificity<Impl: BunSelectorImpl>(
             // Does not affect specificity
         }
         C::Nesting => {
-            // TODO
+            // No specificity contribution here. Whether `&` should
+            // contribute specificity at this point is unresolved;
+            // nesting substitution happens at print time, after
+            // specificity is computed.
         }
     }
 }
@@ -623,7 +620,7 @@ fn parse_selector<Impl: BunSelectorImpl>(
                     any_whitespace = true;
                     continue;
                 }
-                // PORT NOTE: `Token::Delim` carries `u32` codepoint; cast to
+                // `Token::Delim` carries `u32` codepoint; cast to
                 // `u8` for ASCII match (all CSS combinator delims are ASCII).
                 Token::Delim(d) => match u8::try_from(*d).ok() {
                     Some(b'>') => {
@@ -736,7 +733,6 @@ fn parse_compound_selector<Impl: BunSelectorImpl>(
     }
 
     if parse_type_selector::<Impl>(parser, input, *state, builder).is_ok() {
-        // Note: Zig `.asValue()` here means "if Ok"; the bool result is unused.
         empty = false;
     }
 
@@ -874,7 +870,6 @@ fn parse_relative_selector<Impl: BunSelectorImpl>(
         selector
             .components
             .push(GenericComponent::Combinator(wombo_combo));
-        // PERF(port): was assume_capacity (catch unreachable on arena)
         selector.components.push(scope);
     }
 
@@ -884,20 +879,18 @@ fn parse_relative_selector<Impl: BunSelectorImpl>(
 /// Compile-time validation of the `SelectorParser` shape. In Rust the methods are
 /// inherent on `SelectorParser`; this is a no-op kept for diff parity.
 pub fn valid_selector_parser<T>() {
-    // Zig: `_ = T.SelectorParser.parseSlotted;` etc. — structural duck-typing check.
-    // In Rust these are inherent methods on `SelectorParser`; nothing to validate at runtime.
+    // These are inherent methods on `SelectorParser`; nothing to validate at runtime.
 }
 
 /// The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
-// Re-export of the canonical `{ltr, rtl}` enum from `properties::text` — both Zig
-// specs (selectors/parser.zig:700, properties/text.zig:251) define the same
-// `DefineEnumProperty` shape, so the Rust port shares one definition. The
+// Re-export of the canonical `{ltr, rtl}` enum from `properties::text` — the
+// selector and property grammars share one definition. The
 // `#[derive(DefineEnumProperty)]` on the canonical provides `parse`/`to_css`/
 // `as_str`; `CssEql`/`CssHash`/`DeepClone` come from `generics::inherent_bridge`.
 pub use css::css_properties::text::Direction;
 
 /// A pseudo class.
-// PORT NOTE: `PartialEq` derive dropped — `Local`/`Global` carry
+// `PartialEq` derive dropped — `Local`/`Global` carry
 // `Box<Selector>` and `CustomFunction` carries `TokenList`, neither of which
 // implements `PartialEq`. Equality goes through `eql()` (CssEql protocol).
 #[derive(Clone, CssEql, CssHash)]
@@ -907,7 +900,6 @@ pub enum PseudoClass {
     Lang {
         /// A list of language codes.
         languages: Vec<Str>,
-        // PERF(port): was arena ArrayList — profile if it shows up on a hot path.
     },
     /// The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class.
     Dir {
@@ -1078,12 +1070,9 @@ impl PseudoClass {
     }
 
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PERF(alloc): I don't like making these little allocations
-        // PORT NOTE: Zig builds a fresh `Printer` over an allocating writer,
-        // calls `serialize::serializePseudoClass`, then writes the buffer to
-        // `dest`. The buffered indirection only matters for length-dependent
-        // minification decisions made by callers (none here), so write
-        // directly to `dest` until `Printer::new_buffered` lands.
+        // A buffered intermediate `Printer` would only matter for
+        // length-dependent minification decisions made by callers (none
+        // here), so write directly to `dest`.
         serialize::serialize_pseudo_class(self, dest, None)
     }
 
@@ -1206,14 +1195,12 @@ impl WebKitScrollbarPseudoElement {
 pub struct SelectorParser<'a> {
     pub is_nesting_allowed: bool,
     pub options: &'a ParserOptions<'a>,
-    // `arena: Allocator` dropped — arena threaded via `input.arena()` in Zig.
-    // PERF(port): was arena bulk-free — re-thread `&'bump Bump` to restore.
+    // PERF: re-thread `&'bump Bump` here to restore arena allocation.
 }
 
-// Zig: `pub const Impl = impl_.Selectors;` lived inside the struct for
-// `ValidSelectorParser`'s comptime decl-probe. Rust inherent associated types
-// are unstable (rust#8995); the equivalent contract is the `BunSelectorImpl`
-// blanket impl above, so expose the alias at module scope instead.
+// Rust inherent associated types are unstable (rust#8995); the equivalent
+// contract is the `BunSelectorImpl` blanket impl above, so expose the alias
+// at module scope instead.
 pub type SelectorParserImpl = impl_::Selectors;
 
 impl<'a> SelectorParser<'a> {
@@ -1259,13 +1246,11 @@ impl<'a> SelectorParser<'a> {
         name: Str,
         input: &mut CssParser,
     ) -> CResult<PseudoElement> {
-        // Spec parity: parser.zig:1054 uses `ComptimeEnumMap.get(name)` which is
-        // CASE-SENSITIVE (`ComptimeStringMap.get`, not `getAnyCase`/`getASCIIICaseInsensitive`).
-        // `::CUE(..)` / `::View-Transition-Group(..)` therefore fall through to
-        // `CustomFunction` in the spec — match that here by looking up `name`
-        // verbatim with no case folding.
+        // This lookup is intentionally CASE-SENSITIVE: `::CUE(..)` /
+        // `::View-Transition-Group(..)` fall through to `CustomFunction`,
+        // so look up `name` verbatim with no case folding.
         //
-        // PERF(port): 6 entries with near-unique lengths (3/10/19/19/21/26) —
+        // PERF: 6 entries with near-unique lengths (3/10/19/19/21/26) —
         // a length-gated `match` rejects the overwhelmingly-common miss path
         // (unknown `::-webkit-foo(...)` etc.) on a single `usize` compare,
         // versus phf's hash + 2 table loads + slice compare. Only len==19 has
@@ -1351,9 +1336,6 @@ impl<'a> SelectorParser<'a> {
     ) -> CResult<PseudoClass> {
         // @compileError(css.todo_stuff.match_ignore_ascii_case);
         let pseudo_class: PseudoClass = 'pseudo_class: {
-            // TODO(port): phf custom hasher — Zig used `ComptimeStringMap.getAnyCase`
-            // (ASCII case-insensitive). Generate a case-folded phf or use a
-            // `match` over the lowercased name.
             if let Some(pseudo) = lookup_non_ts_pseudo_class(name) {
                 break 'pseudo_class pseudo;
             }
@@ -1386,7 +1368,7 @@ impl<'a> SelectorParser<'a> {
     ) -> CResult<PseudoClass> {
         let pseudo_class = crate::match_ignore_ascii_case! { name, {
             b"lang" => {
-                // PORT NOTE: `expect_ident_or_string` returns `&'_ [u8]`
+                // `expect_ident_or_string` returns `&'_ [u8]`
                 // (lifetime-tied to `&mut self`), which can't satisfy
                 // `parse_comma_separated`'s HRTB. Clone the token to extract
                 // the underlying `&'static [u8]` payload directly.
@@ -1466,7 +1448,6 @@ impl<'a> SelectorParser<'a> {
         loc: css::SourceLocation,
         name: Str,
     ) -> CResult<PseudoElement> {
-        // TODO(port): phf custom hasher — Zig used `ComptimeStringMap.getCaseInsensitiveWithEql`.
         let pseudo_element = lookup_pseudo_element(name).unwrap_or_else(|| {
             if !strings::starts_with_char(name, b'-') {
                 self.options.warn(&loc.new_custom_error(
@@ -1481,7 +1462,6 @@ impl<'a> SelectorParser<'a> {
 }
 
 /// Case-insensitive lookup table for `parse_non_ts_pseudo_class`.
-/// Mirrors the `ComptimeStringMap` at parser.zig:1120.
 fn lookup_non_ts_pseudo_class(name: &[u8]) -> Option<PseudoClass> {
     use PseudoClass as P;
     use WebKitScrollbarPseudoClass as WS;
@@ -1571,7 +1551,6 @@ fn lookup_non_ts_pseudo_class(name: &[u8]) -> Option<PseudoClass> {
 }
 
 /// Case-insensitive lookup table for `parse_pseudo_element`.
-/// Mirrors the `ComptimeStringMap` at parser.zig:1333.
 fn lookup_pseudo_element(name: &[u8]) -> Option<PseudoElement> {
     use PseudoElement as PE;
     use WebKitScrollbarPseudoElement as WS;
@@ -1649,7 +1628,9 @@ impl<Impl: SelectorImpl> GenericSelectorList<Impl> {
 /// `DebugFmt` wrapper — implements `Display` over a borrowed list (debug builds only).
 pub struct SelectorListDebugFmt<'a, Impl: SelectorImpl>(pub &'a GenericSelectorList<Impl>);
 
-impl<'a, Impl: BunSelectorImpl> fmt::Display for SelectorListDebugFmt<'a, Impl> {
+// Concrete `impl_::Selectors` only — `sel.debug()` formatting requires the
+// concrete `Display` impl on `SelectorDebugFmt` (see the comment there).
+impl<'a> fmt::Display for SelectorListDebugFmt<'a, impl_::Selectors> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if !cfg!(debug_assertions) {
             return Ok(());
@@ -1757,13 +1738,11 @@ impl<Impl: BunSelectorImpl> GenericSelectorList<Impl> {
         nesting_requirement: NestingRequirement,
     ) -> CResult<Self> {
         let original_state = *state;
-        // TODO: Think about deinitialization in error cases
         let mut values: SmallList<GenericSelector<Impl>, 1> = SmallList::default();
 
         loop {
-            // PORT NOTE: reshaped for borrowck — Zig used a `Closure` struct capturing
-            // `&mut state` and `&mut parser`; Rust captures a local `saw_nesting` flag
-            // and applies it to `state` after the closure returns (no raw `*mut`).
+            // For borrowck, the closure captures a local `saw_nesting` flag
+            // and applies it to `state` after it returns (no raw `*mut`).
             let mut saw_nesting = false;
             let selector =
                 input.parse_until_before(css::Delimiters::COMMA, |input2: &mut CssParser| {
@@ -1787,7 +1766,6 @@ impl<Impl: BunSelectorImpl> GenericSelectorList<Impl> {
             match selector {
                 Ok(sel) => {
                     values.append(sel);
-                    // PERF(port): was arena append — profile if it shows up on a hot path.
                 }
                 Err(e) => match recovery {
                     ParseErrorRecovery::DiscardList => return Err(e),
@@ -1806,8 +1784,8 @@ impl<Impl: BunSelectorImpl> GenericSelectorList<Impl> {
         }
     }
 
-    // TODO: this looks exactly the same as `parse_with_state()` except it uses
-    // `parse_relative_selector()` instead of `parse_selector()`
+    // Same shape as `parse_with_state()` but parses each item with
+    // `parse_relative_selector()` instead of `parse_selector()`.
     pub fn parse_relative_with_state(
         parser: &mut SelectorParser,
         input: &mut CssParser,
@@ -1816,11 +1794,10 @@ impl<Impl: BunSelectorImpl> GenericSelectorList<Impl> {
         nesting_requirement: NestingRequirement,
     ) -> CResult<Self> {
         let original_state = *state;
-        // TODO: Think about deinitialization in error cases
         let mut values: SmallList<GenericSelector<Impl>, 1> = SmallList::default();
 
         loop {
-            // PORT NOTE: reshaped for borrowck — capture a local flag instead of a
+            // Reshaped for borrowck — capture a local flag instead of a
             // raw `*mut SelectorParsingState`, then fold into `state` after return.
             let mut saw_nesting = false;
             let selector =
@@ -1926,16 +1903,47 @@ pub struct GenericSelector<Impl: SelectorImpl> {
 
 pub struct SelectorDebugFmt<'a, Impl: SelectorImpl>(pub &'a GenericSelector<Impl>);
 
-impl<'a, Impl: SelectorImpl> fmt::Display for SelectorDebugFmt<'a, Impl> {
+// Implemented for the concrete `impl_::Selectors` only (the crate's sole
+// `SelectorImpl`): `tocss_servo::to_css_selector` serializes the concrete
+// `Selector`, not a generic `GenericSelector<Impl>`.
+impl<'a> fmt::Display for SelectorDebugFmt<'a, impl_::Selectors> {
+    // `IN_DEBUG_FMT` only exists under `#[cfg(debug_assertions)]`
+    // (printer.rs), so the whole serialization body is compiled out of
+    // release builds rather than gated at runtime.
+    #[cfg(not(debug_assertions))]
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Ok(())
+    }
+
+    #[cfg(debug_assertions)]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if !cfg!(debug_assertions) {
-            return Ok(());
+        // Serialize through a buffered
+        // `Printer` over an empty symbol map. `IN_DEBUG_FMT` makes
+        // `lookup_ident_or_ref` fall back to `debug_ident` instead of
+        // consulting the (empty) symbol table.
+        let arena = Bump::new();
+        let mut buf: Vec<u8> = Vec::new();
+        let symbols = bun_ast::symbol::Map::default();
+        // Unwind-safe reset of the flag:
+        // Debug formatting commonly runs while building panic messages, so a
+        // panic inside `to_css_selector` must not leak the flag thread-wide.
+        struct InDebugFmtGuard;
+        impl Drop for InDebugFmtGuard {
+            fn drop(&mut self) {
+                crate::printer::IN_DEBUG_FMT.with(|flag| flag.set(false));
+            }
+        }
+        crate::printer::IN_DEBUG_FMT.with(|flag| flag.set(true));
+        let result = {
+            let _guard = InDebugFmtGuard;
+            let mut printer = Printer::new_buffered(&arena, &mut buf, None, None, &symbols);
+            css::selector::tocss_servo::to_css_selector(self.0, &mut printer)
+        };
+        write!(f, "Selector(")?;
+        match result {
+            Ok(()) => write!(f, "{}", bstr::BStr::new(&buf)),
+            Err(e) => writeln!(f, "<error writing selector: {}>", e.name()),
         }
-        // TODO(port): the Zig builds a fresh `Printer` and calls
-        // `tocss_servo::to_css_selector` into a buffer, then writes the buffer.
-        // blocked_on: `Printer::new_buffered` + `SymbolMap::default` (debug-
-        // only path; serialization body lives in `selector::tocss_servo`).
-        write!(f, "Selector(<{} components>)", self.0.components.len())
     }
 }
 
@@ -2233,7 +2241,7 @@ impl<Impl: BunSelectorImpl> GenericComponent<Impl> {
     }
 
     pub fn deep_clone(&self) -> Self {
-        // PORT NOTE: hand-written variant-walk (Zig `implementDeepClone`).
+        // Hand-written variant-walk.
         // Every borrowed payload (`Str`, `Ident.v`, `IdentOrRef`) is an
         // arena-static identity copy; owning containers (`Vec`/`Box`) recurse.
         use GenericComponent as C;
@@ -2422,11 +2430,11 @@ impl<Impl: BunSelectorImpl> GenericComponent<Impl> {
 
     pub fn hash(&self, hasher: &mut Wyhash) {
         use GenericComponent as C;
-        // Zig `implementHash`: `bun.writeAnyToHasher(@intFromEnum(this))` then payload.
+        // Hash a variant tag, then the payload.
         // SAFETY: `GenericComponent` is `#[repr(Rust)]`; reading the discriminant
         // via `core::mem::discriminant` is stable but not byte-hashable. Use a
-        // per-arm tag instead (CSS hashing is in-process dedup only — self-
-        // consistency, not Zig-byte-identity, is the contract).
+        // per-arm tag instead (CSS hashing is in-process dedup only —
+        // self-consistency is the contract).
         macro_rules! tag {
             ($n:expr) => {
                 hasher.update(&($n as u32).to_ne_bytes())
@@ -2567,14 +2575,41 @@ impl<Impl: BunSelectorImpl> CssHash for GenericComponent<Impl> {
 
 impl<Impl: BunSelectorImpl> fmt::Display for GenericComponent<Impl> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO(port): Zig matches on a few variants and falls through to `@tagName`.
-        // Rust enums need `strum::IntoStaticStr` for the tag name.
+        // A few variants get detail, the rest print
+        // their tag name. `BunSelectorImpl`
+        // pins `PseudoElement`/`LocalIdentifier` to the concrete types, whose
+        // `Display` impls handle the payloads.
         match self {
             Self::LocalName(ln) => write!(f, "local_name={}", bstr::BStr::new(ln.name.v())),
             Self::Combinator(c) => write!(f, "combinator='{}'", c),
-            Self::PseudoElement(_) => write!(f, "pseudo_element=<..>"),
-            Self::Class(_) => write!(f, "class=<..>"),
-            _ => write!(f, "<component>"),
+            Self::PseudoElement(pe) => write!(f, "pseudo_element={}", pe),
+            Self::Class(c) => write!(f, "class={}", c),
+            Self::ExplicitAnyNamespace => f.write_str("explicit_any_namespace"),
+            Self::ExplicitNoNamespace => f.write_str("explicit_no_namespace"),
+            Self::DefaultNamespace(_) => f.write_str("default_namespace"),
+            Self::Namespace { .. } => f.write_str("namespace"),
+            Self::ExplicitUniversalType => f.write_str("explicit_universal_type"),
+            Self::Id(_) => f.write_str("id"),
+            Self::AttributeInNoNamespaceExists { .. } => {
+                f.write_str("attribute_in_no_namespace_exists")
+            }
+            Self::AttributeInNoNamespace { .. } => f.write_str("attribute_in_no_namespace"),
+            Self::AttributeOther(_) => f.write_str("attribute_other"),
+            Self::Negation(_) => f.write_str("negation"),
+            Self::Root => f.write_str("root"),
+            Self::Empty => f.write_str("empty"),
+            Self::Scope => f.write_str("scope"),
+            Self::Nth(_) => f.write_str("nth"),
+            Self::NthOf(_) => f.write_str("nth_of"),
+            Self::NonTsPseudoClass(_) => f.write_str("non_ts_pseudo_class"),
+            Self::Slotted(_) => f.write_str("slotted"),
+            Self::Part(_) => f.write_str("part"),
+            Self::Host(_) => f.write_str("host"),
+            Self::Where(_) => f.write_str("where"),
+            Self::Is(_) => f.write_str("is"),
+            Self::Any { .. } => f.write_str("any"),
+            Self::Has(_) => f.write_str("has"),
+            Self::Nesting => f.write_str("nesting"),
         }
     }
 }
@@ -2984,8 +3019,8 @@ impl SelectorParseErrorKind {
     }
 
     pub fn into_selector_error(self) -> css::SelectorError {
-        // PORT NOTE: `error.rs::SelectorError` variants are snake_case
-        // (`#[allow(non_camel_case_types)]` Zig-tagName parity).
+        // `error.rs::SelectorError` variants are snake_case
+        // (`#[allow(non_camel_case_types)]`).
         use SelectorParseErrorKind as K;
         use css::SelectorError as S;
         match self {
@@ -3044,7 +3079,7 @@ pub enum SimpleSelectorParseResult<Impl: SelectorImpl> {
 }
 
 /// A pseudo element.
-// PORT NOTE: see PseudoClass — `PartialEq` derive dropped (Box<Selector>/TokenList).
+// See PseudoClass — `PartialEq` derive dropped (Box<Selector>/TokenList).
 #[derive(Clone, CssEql, CssHash)]
 pub enum PseudoElement {
     /// The [::after](https://drafts.csswg.org/css-pseudo-4/#selectordef-after) pseudo element.
@@ -3201,17 +3236,37 @@ impl PseudoElement {
     }
 
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PERF(alloc): I don't like making small allocations here for the string.
-        // PORT NOTE: see PseudoClass::to_css — write directly until
-        // `Printer::new_buffered` lands.
+        // See PseudoClass::to_css — write directly to `dest`; no caller makes
+        // length-dependent minification decisions here.
         serialize::serialize_pseudo_element(self, dest, None)
     }
 }
 
 impl fmt::Display for PseudoElement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO(port): @tagName — needs strum::IntoStaticStr.
-        write!(f, "<pseudo_element>")
+        f.write_str(match self {
+            Self::After => "after",
+            Self::Before => "before",
+            Self::FirstLine => "first_line",
+            Self::FirstLetter => "first_letter",
+            Self::Selection(_) => "selection",
+            Self::Placeholder(_) => "placeholder",
+            Self::Marker => "marker",
+            Self::Backdrop(_) => "backdrop",
+            Self::FileSelectorButton(_) => "file_selector_button",
+            Self::WebkitScrollbar(_) => "webkit_scrollbar",
+            Self::Cue => "cue",
+            Self::CueRegion => "cue_region",
+            Self::CueFunction { .. } => "cue_function",
+            Self::CueRegionFunction { .. } => "cue_region_function",
+            Self::ViewTransition => "view_transition",
+            Self::ViewTransitionGroup { .. } => "view_transition_group",
+            Self::ViewTransitionImagePair { .. } => "view_transition_image_pair",
+            Self::ViewTransitionOld { .. } => "view_transition_old",
+            Self::ViewTransitionNew { .. } => "view_transition_new",
+            Self::Custom { .. } => "custom",
+            Self::CustomFunction { .. } => "custom_function",
+        })
     }
 }
 
@@ -3325,7 +3380,6 @@ pub fn parse_type_selector<Impl: BunSelectorImpl>(
         sink.push_simple_selector(GenericComponent::LocalName(LocalName {
             lower_name: {
                 // PERF: check if it's already lowercase
-                // PERF(port): was arena alloc — profile if hot (see `arena_lowercase`).
                 Ident {
                     v: arena_lowercase(input.arena(), name),
                 }
@@ -3427,7 +3481,6 @@ pub fn parse_one_simple_selector<Impl: BunSelectorImpl>(
                         let names = input.parse_nested_block(
                             |input2: &mut CssParser| -> CResult<Box<[Impl::Identifier]>> {
                                 // todo_stuff.think_about_mem_mgmt
-                                // PERF(port): was arena ArrayList with capacity 1 — profile if hot.
                                 let mut result: Vec<Impl::Identifier> = Vec::with_capacity(1);
 
                                 result.push(Ident {
@@ -3464,8 +3517,6 @@ pub fn parse_one_simple_selector<Impl: BunSelectorImpl>(
                     input.parse_nested_block(|i: &mut CssParser| {
                         parser.parse_functional_pseudo_element(name, i)
                     })?
-                    // TODO(port): `Impl::PseudoElement` is `PseudoElement` for the concrete
-                    // `impl_::Selectors`; the generic path would need a `From`/trait bound.
                 } else {
                     parser.parse_pseudo_element(location, name)?
                 };
@@ -3571,7 +3622,6 @@ pub fn parse_attribute_selector<Impl: BunSelectorImpl>(
             Ok(v) => v.clone(),
             Err(_) => {
                 // [foo]
-                // PERF(port): was arena alloc — profile if hot (see `arena_lowercase`).
                 let local_name_lower: *const [u8] = arena_lowercase(input.arena(), local_name);
                 if let Some(ns) = namespace {
                     let x = attrs::AttrSelectorWithOptionalNamespace::<Impl> {
@@ -3618,7 +3668,7 @@ pub fn parse_attribute_selector<Impl: BunSelectorImpl>(
         ));
     };
 
-    // PORT NOTE: `expect_ident_or_string` returns `&'_ [u8]` (lifetime-tied to
+    // `expect_ident_or_string` returns `&'_ [u8]` (lifetime-tied to
     // `&mut *input`); `parse_attribute_flags(input)` below needs `input` again.
     // Clone the token so the borrow is released before we re-borrow.
     let value_str: Str = {
@@ -3657,7 +3707,6 @@ pub fn parse_attribute_selector<Impl: BunSelectorImpl>(
         };
         if let Some(first_uppercase) = first_uppercase {
             let str_ = &local_name[first_uppercase..];
-            // PERF(port): was arena alloc — profile if hot (see `arena_lowercase`).
             let lowered: *const [u8] = arena_lowercase(input.arena(), str_);
             break 'brk (Ident { v: lowered }, false);
         } else {
@@ -3776,8 +3825,6 @@ pub fn parse_functional_pseudo_class<Impl: BunSelectorImpl>(
     let result = parser.parse_non_ts_functional_pseudo_class(name, input)?;
 
     Ok(GenericComponent::NonTsPseudoClass(result))
-    // TODO(port): `Impl::NonTSPseudoClass` is `PseudoClass` for the concrete impl;
-    // generic path would need a `From` bound.
 }
 
 pub fn parse_simple_pseudo_class<Impl: BunSelectorImpl>(
@@ -3930,8 +3977,7 @@ where
 
     let selector_slice = inner.into_boxed_selectors();
 
-    // PORT NOTE: Zig threaded extra `args_` through an ArgsTuple to `func`; in Rust
-    // the closure captures extras directly (e.g. `prefix` for `:any()`).
+    // The closure captures extra args directly (e.g. `prefix` for `:any()`).
     let result = func(selector_slice);
 
     Ok(result)
@@ -4069,7 +4115,7 @@ pub fn parse_qualified_name<Impl: BunSelectorImpl>(
                         );
                     }
                 }
-                // PORT NOTE: reshaped for borrowck — clone token before reset.
+                // Reshaped for borrowck — clone token before reset.
                 let result_cloned = result.cloned();
                 input.reset(&after_star);
                 if in_attr_selector {
@@ -4195,8 +4241,7 @@ impl AttributeFlags {
 /// explicit `s`/`i` flag is given on the attribute selector.
 /// <https://html.spec.whatwg.org/multipage/#selectors>
 ///
-/// PERF(port): Zig used `ComptimeEnumMap.has` (zero-cost membership at
-/// comptime). An earlier `phf::Set` port paid, on every
+/// PERF: an earlier `phf::Set` implementation paid, on every
 /// `[attr=val]` selector, a 32-bit FNV-ish hash over the name plus a
 /// bounds check, indirect load, and full key compare — measurable in CSS
 /// bundling profiles where the dominant inputs (`class`, `href`, `data-*`,
@@ -4286,7 +4331,7 @@ pub enum ViewTransitionPartName {
 
 impl ViewTransitionPartName {
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
-        // PORT NOTE: `CustomIdentFns::to_css` is ``-gated on
+        // `CustomIdentFns::to_css` is CSS-modules-gated via
         // `Printer::{css_module,write_ident}`; inline the
         // `write_ident(v, false)` body (CSS-modules custom-ident scoping is a
         // serializer concern, not a grammar concern — the gated impl just
@@ -4371,5 +4416,3 @@ pub fn parse_attribute_flags(input: &mut CssParser) -> CResult<AttributeFlags> {
 }
 
 crate::css_eql_partialeq!(NthSelectorData, SpecificityAndFlags, Combinator);
-
-// ported from: src/css/selectors/parser.zig
diff --git a/src/css/selectors/selector.rs b/src/css/selectors/selector.rs
index 1f5068221a9..f86a31e12e4 100644
--- a/src/css/selectors/selector.rs
+++ b/src/css/selectors/selector.rs
@@ -21,9 +21,8 @@ pub use parser::SelectorList;
 
 /// Our implementation of the `SelectorImpl` interface — the trait-based
 /// `impl_::Selectors` marker lives in the hub (`super::impl_`) so the
-/// parser↔selector cycle has a single anchor. This module is the literal
-/// Zig-shaped namespace (`selector.impl.Selectors.SelectorImpl.*` type
-/// aliases) kept for diff parity with `selector.zig`.
+/// parser↔selector cycle has a single anchor. This module holds the
+/// `SelectorImpl` type aliases.
 pub use super::impl_;
 pub mod r#impl {
     use super::*;
@@ -175,7 +174,6 @@ pub(crate) fn downlevel_component<'bump>(
             // https://drafts.csswg.org/selectors/#specificity-rules
             if selectors.len() > 1 && targets.should_compile_same(Feature::NotSelectorList) {
                 let is: Selector = Selector::from_component(Component::Is({
-                    // PERF(port): was arena bulk-alloc — profile if hot.
                     // `Component::Is` carries `Box<[Selector]>` (heap, not arena);
                     // could re-thread `&'bump [Selector]` once the arena lifetime is plumbed.
                     let mut new_selectors: Vec<Selector> = Vec::with_capacity(selectors.len());
@@ -184,7 +182,6 @@ pub(crate) fn downlevel_component<'bump>(
                     }
                     new_selectors.into_boxed_slice()
                 }));
-                // PERF(port): was appendAssumeCapacity
                 *component = Component::Negation(vec![is].into_boxed_slice());
 
                 if targets.should_compile_same(Feature::IsSelector) {
@@ -214,7 +211,6 @@ fn downlevel_dir<'bump>(bump: &'bump Bump, dir: parser::Direction, targets: &Tar
     // otherwise, use :is/:not, which may be further downleveled to e.g. :-webkit-any.
     if !targets.should_compile_same(Feature::LangSelectorList) {
         let c = Component::NonTsPseudoClass(PseudoClass::Lang {
-            // PERF(port): was appendSliceAssumeCapacity (arena) — could re-thread bump.
             languages: RTL_LANGS.to_vec(),
         });
         if dir == parser::Direction::Ltr {
@@ -230,14 +226,12 @@ fn downlevel_dir<'bump>(bump: &'bump Bump, dir: parser::Direction, targets: &Tar
 }
 
 fn lang_list_to_selectors<'bump>(_bump: &'bump Bump, langs: &[&'static [u8]]) -> Box<[Selector]> {
-    // PORT NOTE: Zig returned `[]Selector` (mutable arena slice). Here
-    // `Component::Is`/`Negation` carry `Box<[Selector]>`; could re-thread
-    // `&'bump [Selector]` once the arena lifetime is plumbed.
+    // `Component::Is`/`Negation` carry `Box<[Selector]>`; this could become
+    // `&'bump [Selector]` once the arena lifetime is plumbed through.
     let mut selectors: Vec<Selector> = Vec::with_capacity(langs.len());
     for lang in langs {
         selectors.push(Selector::from_component(Component::NonTsPseudoClass(
             PseudoClass::Lang {
-                // PERF(port): was appendAssumeCapacity (arena)
                 languages: vec![*lang],
             },
         )));
@@ -519,7 +513,7 @@ pub fn is_compatible(selectors: &[parser::Selector], targets: &Targets) -> bool
 /// A selector is considered unused if it contains a class or id component that exists in the set of unused symbols.
 pub fn is_unused(
     selectors: &[parser::Selector],
-    unused_symbols: &ArrayHashMap<Box<[u8]>, ()>, // Zig `std.StringArrayHashMapUnmanaged(void)`
+    unused_symbols: &ArrayHashMap<Box<[u8]>, ()>,
     symbols: &SymbolList,
     parent_is_unused: bool,
 ) -> bool {
@@ -545,8 +539,8 @@ fn is_selector_unused(
     for component in selector.components.iter() {
         match component {
             Component::Class(ident) | Component::Id(ident) => {
-                // PORT NOTE: `IdentOrRef::as_original_string` is
-                // ``-gated (blocked_on bun_ast::symbol::List::at
+                // `IdentOrRef::as_original_string` is
+                // gated (blocked_on bun_ast::symbol::List::at
                 // + Symbol.original_name). Inline the ident arm; the ref arm
                 // (CSS-modules symbol-table lookup) is unreachable until
                 // `Parser::add_symbol_for_name` un-gates (see
@@ -559,9 +553,8 @@ fn is_selector_unused(
                         continue; // blocked_on: as_original_string ref arm
                     }
                 };
-                // PORT NOTE: Zig `unused_symbols.contains(actual_ident)` —
-                // adapted lookup to compare the borrowed `&[u8]` against
-                // owned `Box<[u8]>` keys without allocating.
+                // Look up the borrowed `&[u8]` against the map's owned
+                // `Box<[u8]>` keys without allocating.
                 struct SliceAdapter;
                 impl bun_collections::array_hash_map::ArrayHashAdapter<[u8], Box<[u8]>> for SliceAdapter {
                     #[inline]
@@ -865,9 +858,8 @@ pub mod serialize {
                     let mut id: Vec<u8> = Vec::new();
                     let _ = css::serializer::serialize_identifier(value_bytes, &mut id);
 
-                    // PORT NOTE: Zig routed through `css.to_css.string(CSSString, ...)`, which
-                    // dispatches to `CSSStringFns.toCss` → `serialize_string`. Inline that here
-                    // since `CssString` (`*const [u8]`) does not implement `generic::ToCss`.
+                    // `serialize_string` is called directly here since `CssString`
+                    // (`*const [u8]`) does not implement `generic::ToCss`.
                     let mut s: Vec<u8> = Vec::new();
                     let _ = css::serializer::serialize_string(value_bytes, &mut s);
 
@@ -1822,15 +1814,10 @@ impl<'a> CompoundSelectorIter<'a> {
     /// The iterator would return:
     /// ```
     /// First slice:
-    /// .{
-    ///   .{ .local_name = "div" }
-    /// }
+    ///   [ LocalName("div") ]
     ///
     /// Second slice:
-    /// .{
-    ///   .{ .local_name = "p" },
-    ///   .{ .class = "class" }
-    /// }
+    ///   [ LocalName("p"), Class("class") ]
     /// ```
     ///
     /// BUT, the selectors are stored in reverse order, so this code needs to split the components backwards.
@@ -1874,5 +1861,3 @@ impl<'a> CompoundSelectorIter<'a> {
         None
     }
 }
-
-// ported from: src/css/selectors/selector.zig
diff --git a/src/css/small_list.rs b/src/css/small_list.rs
index f1b3c57201d..6749f308823 100644
--- a/src/css/small_list.rs
+++ b/src/css/small_list.rs
@@ -2,7 +2,7 @@
 // The container itself now lives in `bun_collections::SmallList` (a thin
 // `#[repr(transparent)]` newtype over `smallvec::SmallVec<[T; N]>`). This file
 // keeps only the CSS-domain pieces that depend on `bun_css` types — the
-// `ImageFallback` protocol and the two `getFallbacks` comptime branches —
+// `ImageFallback` protocol and the two `get_fallbacks` flavors —
 // which the orphan rule prevents from living on the foreign `SmallList` type
 // as inherent methods.
 //
@@ -17,7 +17,6 @@
 // `grow_capacity`, manual `Drop`, and `SmallListIntoIter` (~800 lines of
 // `unsafe`) were a direct port of servo/rust-smallvec; that loop is now closed
 // back onto the upstream crate.
-// ported from: src/css/small_list.zig
 
 pub use bun_collections::SmallList;
 
@@ -28,11 +27,8 @@ pub use bun_collections::SmallList;
 // trait at the call site instead.)
 
 // ─── getFallbacks ──────────────────────────────────────────────────────────
-// The Zig version uses `@hasDecl(T, "getImage")` and `T == TextShadow` comptime
-// dispatch with a comptime-computed return type. In Rust this becomes a trait
-// with associated type for the return.
 
-/// Duck-typed protocol from the Zig source (`@hasDecl(T, "getImage")`): any
+/// Protocol for any
 /// value type that carries an `Image` and can produce color/prefix fallbacks
 /// of itself. Implemented by `values::image::Image` and
 /// `properties::background::Background`.
@@ -53,8 +49,8 @@ pub trait ImageFallback: Sized {
 // `ImageFallback for Image` is implemented alongside the type in
 // `crate::values::image` to avoid a duplicate impl here.
 
-/// Port of Zig `SmallList(T, N).getFallbacks` for the `@hasDecl(T, "getImage")`
-/// branch. The TextShadow branch is `get_fallbacks_text_shadow`.
+/// `getFallbacks` for `ImageFallback` element types.
+/// The TextShadow variant is `get_fallbacks_text_shadow`.
 ///
 /// Free-standing (was an inherent on `SmallList<T,1>`) so it can live in this
 /// crate now that `SmallList` is foreign. The lone caller threads `self`
@@ -75,7 +71,6 @@ pub mod fallbacks_gated {
     use crate::css_parser as css;
     use crate::properties::text::TextShadow;
 
-    // TODO(port): trait bound placeholder — any T with getImage()/withImage()/getFallback()/getNecessaryFallbacks()
     pub fn get_fallbacks_image<T>(
         this: &mut SmallList<T, 1>,
         arena: &bun_alloc::Arena,
diff --git a/src/css/sourcemap.rs b/src/css/sourcemap.rs
index 1f217c1c858..154ab560710 100644
--- a/src/css/sourcemap.rs
+++ b/src/css/sourcemap.rs
@@ -1,11 +1,17 @@
 pub struct SourceMap {
-    // TODO(port): []const u8 struct field in CSS (arena crate) — using raw slice ptr per PORTING.md; revisit ownership
+    // Arena-owned `[]const u8` erased to a raw slice pointer per PORTING.md
+    // §Allocators (AST crates); becomes `&'bump [u8]` once the CSS crate
+    // threads the arena lifetime.
     pub project_root: *const [u8],
     pub inner: SourceMapInner,
 }
 
 pub struct SourceMapInner {
-    // PERF(port): ArrayListUnmanaged in CSS arena crate — using Vec<T>; may want bun_alloc::ArenaVec<'bump, T> if hot
+    // PERF: using Vec<T>; may want bun_alloc::ArenaVec<'bump, T> if hot
+    // The `*const [u8]` elements of `sources`/`sources_content`/`names` are
+    // arena-owned slices erased to raw pointers per PORTING.md §Allocators
+    // (AST crates) — never dereferenced after the arena resets; they become
+    // `&'bump [u8]` once the CSS crate threads the arena lifetime.
     pub sources: Vec<*const [u8]>,
     pub sources_content: Vec<*const [u8]>,
     pub names: Vec<*const [u8]>,
@@ -29,5 +35,3 @@ pub struct OriginalLocation {
     pub source: u32,
     pub name: Option<u32>,
 }
-
-// ported from: src/css/sourcemap.zig
diff --git a/src/css/targets.rs b/src/css/targets.rs
index 15a73a4404f..3d0463d1853 100644
--- a/src/css/targets.rs
+++ b/src/css/targets.rs
@@ -77,8 +77,6 @@ impl Targets {
         {
             let mut browsers = Browsers::default();
             let mut has_any = false;
-            // PORT NOTE: Zig used `inline for (std.meta.fields(Browsers))` reflection.
-            // Expanded manually per field.
             macro_rules! check_field {
                 ($field:ident, $env:literal) => {
                     if let Some(val) = bun_core::getenv_z_any_case(bun_core::zstr!($env)) {
@@ -137,9 +135,8 @@ impl Targets {
     }
 
     pub fn should_compile_same(&self, compat_feature: css::compat::Feature) -> bool {
-        // PERF(port): was comptime enum param — demoted to runtime (const-generic
+        // PERF: runtime dispatch (a const-generic param
         // would need #[derive(ConstParamTy)] on compat::Feature).
-        // Zig: comptime construct a Features with @field(feature, @tagName(compat_feature)) = true.
         let target_feature: Features = Features::from_compat(compat_feature);
         self.should_compile(compat_feature, target_feature)
     }
@@ -185,8 +182,7 @@ pub struct Browsers {
     pub samsung: Option<u32>,
 }
 
-// Zig: `pub const browserDefault = convertFromString(&.{...}) catch unreachable;`
-// convert_from_string is not const-evaluable in Rust; compute once lazily.
+// convert_from_string is not const-evaluable; compute once lazily.
 static BROWSER_DEFAULT: std::sync::LazyLock<Browsers> = std::sync::LazyLock::new(|| {
     Browsers::convert_from_string(&[
         b"es2020", // support import.meta.url
@@ -213,13 +209,14 @@ impl Browsers {
                 }
 
                 let number_part = &str[2..];
-                // Zig: `try std.fmt.parseInt(u16, number_part, 10)` — propagates
-                // error.InvalidCharacter / error.Overflow. Preserve the tag for
-                // @errorName snapshot compat (do NOT collapse to UnsupportedCSSTarget).
-                // TODO(port): narrow error set (InvalidCharacter | Overflow)
-                let year = strings::parse_int::<u16>(number_part, 10)
-                    .ok()
-                    .ok_or_else(|| bun_core::err!("InvalidCharacter"))?;
+                // Propagates InvalidCharacter / Overflow. Preserve the tag for
+                // error-name snapshot compat (do NOT collapse to UnsupportedCSSTarget).
+                let year = strings::parse_int::<u16>(number_part, 10).map_err(|e| match e {
+                    strings::ParseIntError::Overflow => bun_core::err!("Overflow"),
+                    strings::ParseIntError::InvalidCharacter => {
+                        bun_core::err!("InvalidCharacter")
+                    }
+                })?;
                 match year {
                     // https://caniuse.com/?search=es2015
                     2015 => {
@@ -320,7 +317,6 @@ impl Browsers {
                         break 'entries_without_es &entries_buf[0..4];
                     }
                     _ => {
-                        // Zig had `if (@inComptime()) @compileLog(...)` here — no equivalent.
                         return Err(bun_core::err!("UnsupportedCSSTarget"));
                     }
                 }
@@ -390,8 +386,6 @@ impl Browsers {
                     };
 
                     let version: u32 = ((major as u32) << 16) | ((minor as u32) << 8);
-                    // Zig: `switch (browser.?) { inline else => |b| @field(browsers, @tagName(b)) ... }`
-                    // PORT NOTE: reflection expanded into a direct match yielding a field ref.
                     let slot: &mut Option<u32> = match browser {
                         Browser::Chrome => &mut browsers.chrome,
                         Browser::Edge => &mut browsers.edge,
@@ -439,7 +433,6 @@ bitflags::bitflags! {
         const DOUBLE_POSITION_GRADIENTS      = 1 << 17;
         const VENDOR_PREFIXES                = 1 << 18;
         const LOGICAL_PROPERTIES             = 1 << 19;
-        // __unused: u12 padding in Zig
 
         const SELECTORS = Self::NESTING.bits()
             | Self::NOT_SELECTOR_LIST.bits()
@@ -469,9 +462,7 @@ impl Default for Features {
 impl Features {
     /// Map a `compat::Feature` enum variant to the same-named `Features` bitflag.
     ///
-    /// Zig did this via `@field(feature, @tagName(compat_feature)) = true` reflection
-    /// inside `shouldCompileSame` (a `comptime` parameter, so a non-matching variant
-    /// was a compile error). Rust takes the variant at runtime, so the table is
+    /// The variant is taken at runtime, so the table is
     /// hand-written: every `compat::Feature` whose snake_case tag matches a
     /// `Features` field gets an arm; any other variant is a programmer error.
     pub fn from_compat(compat_feature: css::compat::Feature) -> Features {
@@ -495,9 +486,8 @@ impl Features {
             Feature::SpaceSeparatedColorNotation => Features::SPACE_SEPARATED_COLOR_NOTATION,
             Feature::FontFamilySystemUi => Features::FONT_FAMILY_SYSTEM_UI,
             Feature::DoublePositionGradients => Features::DOUBLE_POSITION_GRADIENTS,
-            // Zig: `@field` on a tag with no matching `Features` field is a
-            // *compile* error; in Rust the equivalent guard is a runtime
-            // unreachable since `compat_feature` is no longer `comptime`.
+            // A tag with no matching `Features` field is a programmer error,
+            // guarded by a runtime unreachable.
             _ => unreachable!(
                 "compat::Feature::{:?} has no same-named targets::Features flag",
                 compat_feature
@@ -505,5 +495,3 @@ impl Features {
         }
     }
 }
-
-// ported from: src/css/targets.zig
diff --git a/src/css/values/alpha.rs b/src/css/values/alpha.rs
index 2113b195d0f..ad1b35ed634 100644
--- a/src/css/values/alpha.rs
+++ b/src/css/values/alpha.rs
@@ -13,8 +13,6 @@ pub struct AlphaValue {
 
 impl AlphaValue {
     pub(crate) fn parse(input: &mut Parser) -> Result<AlphaValue> {
-        // For some reason NumberOrPercentage.parse makes zls crash, using this instead.
-        // PORT NOTE: the Zig used `@call(.auto, @field(...))` as a zls workaround; direct call in Rust.
         let val: NumberOrPercentage = NumberOrPercentage::parse(input)?;
         let final_ = match val {
             NumberOrPercentage::Percentage(percent) => AlphaValue { v: percent.v },
@@ -26,9 +24,12 @@ impl AlphaValue {
     pub(crate) fn to_css(self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
         CSSNumberFns::to_css(self.v, dest)
     }
-
-    // TODO(port): css.implementHash (comptime field reflection) — wires once
-    // generics::CssHash blanket impl covers f32-payload structs.
 }
 
-// ported from: src/css/values/alpha.zig
+impl crate::generics::CssHash for AlphaValue {
+    /// Field-wise: hash the single `f32` payload.
+    #[inline]
+    fn hash(&self, hasher: &mut crate::generics::Wyhash) {
+        crate::generics::CssHash::hash(&self.v, hasher);
+    }
+}
diff --git a/src/css/values/angle.rs b/src/css/values/angle.rs
index d200a55940f..f62cb9c17b3 100644
--- a/src/css/values/angle.rs
+++ b/src/css/values/angle.rs
@@ -198,7 +198,6 @@ impl Angle {
 
     pub(crate) fn op<C>(self, other: Angle, ctx: C, op_fn: fn(C, f32, f32) -> f32) -> Angle {
         // PERF: not sure if this is faster
-        // PORT NOTE: reshaped for borrowck — Zig used packed-tag bit-twiddling switch; Rust match on (tag, tag) is equivalent.
         match (self, other) {
             (Angle::Deg(a), Angle::Deg(b)) => Angle::Deg(op_fn(ctx, a, b)),
             (Angle::Rad(a), Angle::Rad(b)) => Angle::Rad(op_fn(ctx, a, b)),
@@ -206,7 +205,6 @@ impl Angle {
             (Angle::Turn(a), Angle::Turn(b)) => Angle::Turn(op_fn(ctx, a, b)),
             _ => Angle::Deg(op_fn(ctx, self.to_degrees(), other.to_degrees())),
         }
-        // PERF(port): was comptime monomorphization (fn-ptr arg) — profile if it shows up on a hot path.
     }
 
     pub(crate) fn sign(self) -> f32 {
@@ -224,7 +222,6 @@ impl Angle {
 impl crate::generics::CssEql for Angle {
     #[inline]
     fn eql(&self, other: &Self) -> bool {
-        // Spec angle.zig:200-202 — `lhs.toDegrees() == rhs.toDegrees()`.
         // NOT structural variant comparison: Deg(180) eql Rad(PI) eql Turn(0.5).
         self.to_degrees() == other.to_degrees()
     }
@@ -233,5 +230,3 @@ impl crate::generics::CssEql for Angle {
 /// A CSS [`<angle-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-angle-percentage) value.
 /// May be specified as either an angle or a percentage that resolves to an angle.
 pub(crate) type AnglePercentage = DimensionPercentage<Angle>;
-
-// ported from: src/css/values/angle.zig
diff --git a/src/css/values/calc.rs b/src/css/values/calc.rs
index 3c15de0172e..1c6fec6b392 100644
--- a/src/css/values/calc.rs
+++ b/src/css/values/calc.rs
@@ -39,11 +39,10 @@ pub enum CalcUnit {
 }
 
 impl CalcUnit {
-    /// Zig: `bun.ComptimeEnumMap(CalcUnit).getAnyCase(f)`
-    // TODO(port): phf custom hasher — case-insensitive lookup over &[u8].
+    /// Case-insensitive lookup of a `CalcUnit` by its function name.
     pub fn get_any_case(f: &[u8]) -> Option<Self> {
-        // PERF(port): Zig used a comptime perfect hash; this is a linear match on a
-        // stack-lowercased byte slice. TODO(perf): use a phf_map! over &[u8].
+        // PERF: linear match on a
+        // stack-lowercased byte slice. Profile before swapping in a phf.
         // §Strings: source bytes are &[u8], never &str/String — no from_utf8/to_ascii_lowercase().
         let (buf, len) = bun_core::strings::ascii_lowercase_buf::<5>(f)?;
         match &buf[..len] {
@@ -115,7 +114,6 @@ pub enum Calc<V> {
 }
 
 // ───────────────────────────── CalcValue trait ─────────────────────────────
-// Replaces the Zig `switch (V)` / `@hasDecl(V, ...)` comptime-type dispatch.
 // Every type that can appear inside `Calc<V>` implements this.
 //
 // The numeric protocol (`mul_f32`/`try_sign`/`try_map`/`try_op`/`try_op_to`/
@@ -139,9 +137,9 @@ pub trait CalcValue:
     + protocol::IsCompatible
 {
     fn add_internal(self, rhs: Self) -> Self;
-    /// Wrap a value as a `Calc<Self>` (Zig: `intoCalc`).
+    /// Wrap a value as a `Calc<Self>`.
     fn into_calc(self) -> Calc<Self>;
-    /// Convert a `Calc<Self>` into `Self` if representable (Zig: `intoValue`).
+    /// Convert a `Calc<Self>` into `Self` if representable.
     fn from_calc(c: Calc<Self>, input: &mut css::Parser) -> CssResult<Self>;
     fn eql(&self, other: &Self) -> bool;
 }
@@ -194,8 +192,7 @@ impl<V> Calc<V> {
     {
         match self {
             Calc::Value(v) => {
-                // Zig: if (needs_deepclone) v.deepClone(arena) else v.*
-                // Rust: V: Clone covers both — V's Clone impl is the deep clone.
+                // V's Clone impl is the deep clone.
                 Calc::Value(Box::new((**v).clone()))
             }
             Calc::Number(n) => Calc::Number(*n),
@@ -218,7 +215,7 @@ impl<V> Calc<V> {
         Box::new(self.deep_clone())
     }
 
-    // Zig `deinit` only freed owned Box fields → handled by Drop on Box<V>/Box<Calc<V>>/
+    // Cleanup is handled by Drop on Box<V>/Box<Calc<V>>/
     // Box<MathFunction<V>>. No explicit Drop impl needed.
 
     pub fn eql(&self, other: &Self) -> bool
@@ -259,32 +256,25 @@ impl<V> Calc<V> {
 
 impl<V: CalcValue> Calc<V> {
     fn mul_value_f32(lhs: V, rhs: f32) -> V {
-        // Zig: `f32 => lhs * rhs, else => lhs.mulF32(...)` — folded into trait.
         lhs.mul_f32(rhs)
     }
 
-    // TODO: addValueOwned
     pub fn add_value(lhs: V, rhs: V) -> V {
-        // Zig: `f32 => lhs + rhs, else => lhs.addInternal(...)` — folded into trait.
         lhs.add_internal(rhs)
     }
 
-    // TODO: intoValueOwned
     pub fn into_value(self, input: &mut css::Parser) -> CssResult<V> {
-        // Zig comptime type switch on V → trait method `V::from_calc`.
         V::from_calc(self, input)
     }
 
     pub fn into_calc(val: V) -> Self {
-        // Zig: `f32 => .{ .value = box(val) }, else => val.intoCalc()` — folded into trait.
         val.into_calc()
     }
 
-    // TODO: change to addOwned()
     pub fn add(self, rhs: Self, input: &mut css::Parser) -> CssResult<Self> {
         if let (Calc::Value(_), Calc::Value(_)) = (&self, &rhs) {
             // PERF: we can reuse the allocation here
-            // PORT NOTE: reshaped for borrowck — clone out of boxes then drop originals.
+            // Reshaped for borrowck — clone out of boxes then drop originals.
             let (a, b) = match (self, rhs) {
                 (Calc::Value(a), Calc::Value(b)) => (*a, *b),
                 _ => unreachable!(),
@@ -323,8 +313,6 @@ impl<V: CalcValue> Calc<V> {
         Ok(Self::into_calc(Self::add_value(this_value, rhs_value)))
     }
 
-    // TODO: users of this and `parseWith` don't need the pointer and often throwaway heap allocated values immediately
-    // use temp arena or something?
     pub fn parse(input: &mut css::Parser) -> CssResult<Self> {
         fn parse_with_fn<V>(_: (), _: &[u8]) -> Option<Calc<V>> {
             None
@@ -338,7 +326,7 @@ impl<V: CalcValue> Calc<V> {
         parse_ident: F,
     ) -> CssResult<Self> {
         let location = input.current_source_location();
-        // PORT NOTE: clone the token before reborrowing `input` so the function
+        // Clone the token before reborrowing `input` so the function
         // name slice is owned by the cloned `Token` (whose payload already
         // carries the parser's arena lifetime) instead of being laundered to
         // `'static` here.
@@ -353,8 +341,7 @@ impl<V: CalcValue> Calc<V> {
             other => return Err(location.new_unexpected_token_error(other)),
         };
 
-        // PORT NOTE: Zig used explicit `Closure` structs because Zig lacks closures.
-        // Rust closures capture `ctx` + `parse_ident` directly.
+        // The closures capture `ctx` + `parse_ident` directly.
         match unit {
             CalcUnit::Calc => {
                 let calc = input.parse_nested_block(|i| Self::parse_sum(i, ctx, parse_ident))?;
@@ -457,7 +444,7 @@ impl<V: CalcValue> Calc<V> {
                     i,
                     (),
                     |_, a, b| {
-                        // Zig `@mod(a, b)`: floored modulo, result takes sign of divisor.
+                        // Floored modulo: result takes the sign of the divisor.
                         // Equivalent to `a - b * floor(a / b)`. Rust `%` is truncated (sign of
                         // dividend) and `rem_euclid` is non-negative, so neither matches for
                         // negative `b` — use the explicit floor formula.
@@ -476,9 +463,13 @@ impl<V: CalcValue> Calc<V> {
                     i,
                     (),
                     |_, a, b| {
-                        // return ((a % b) + b) % b;
-                        // TODO(port): Zig used nested `@mod`; using Rust `%` per the commented
-                        // formula. Verify edge cases (negative b, NaN).
+                        // Floored modulo (result takes the sign of the divisor):
+                        // `((a % b) + b) % b` over Rust's truncated `%` gets the
+                        // sign right for NaN/inf and ordinary finite inputs.
+                        // Note: this double-wrap formula applies a different rounding
+                        // sequence than the explicit `a - b * floor(a / b)`, so results
+                        // can differ by ~|b| near exact multiples of the divisor
+                        // (e.g. f32 `mod(-3e-8, 1)` -> 0.99999994 vs 0.0).
                         ((a % b) + b) % b
                     },
                     |_, a, b| MathFunction::Mod {
@@ -561,7 +552,6 @@ impl<V: CalcValue> Calc<V> {
         ctx: C,
         parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
     ) -> CssResult<Self> {
-        // PERF(port): was comptime monomorphization on `op` — profile if hot.
         input.parse_nested_block(|i| {
             let v = Self::parse_numeric(i, ctx, parse_ident)?;
             Ok(Calc::Number(match op {
@@ -724,7 +714,7 @@ impl<V: CalcValue> Calc<V> {
         }
 
         let location = input.current_source_location();
-        // PORT NOTE: reshaped for borrowck — clone the next token inside the
+        // Reshaped for borrowck — clone the next token inside the
         // try-parse so the ident slice is owned by the cloned `Token` rather
         // than laundered to `'static` from the `&mut Parser` borrow.
         if let Ok(ident) = input.try_parse(|p| {
@@ -751,7 +741,6 @@ impl<V: CalcValue> Calc<V> {
         ctx: C,
         parse_ident: impl Fn(C, &[u8]) -> Option<Self> + Copy,
     ) -> CssResult<Self> {
-        // PERF(port): was comptime monomorphization on `trig_fn_kind` — profile if hot.
         let trig_fn = move |x: f32| -> f32 {
             match trig_fn_kind {
                 TrigFnKind::Sin => x.sin(),
@@ -764,8 +753,8 @@ impl<V: CalcValue> Calc<V> {
         };
 
         input.parse_nested_block(|i| {
-            // PORT NOTE: Zig wrapped `parse_ident` to project `Calc<V>::Number` into
-            // `Calc<Angle>::Number`. Rust closure does the same.
+            // Wrap `parse_ident` to project `Calc<V>::Number` into
+            // `Calc<Angle>::Number`.
             let parse_ident_fn = |_self: (), ident: &[u8]| -> Option<Calc<Angle>> {
                 let v = parse_ident(ctx, ident)?;
                 if let Calc::Number(n) = v {
@@ -774,8 +763,9 @@ impl<V: CalcValue> Calc<V> {
                     None
                 }
             };
-            // TODO(port): Zig passed `&closure` (a *@This()) as ctx; here we use `()` and
-            // capture `ctx` via the outer closure. Verify `Calc<Angle>::parse_sum` signature.
+            // ctx is `()` and the
+            // outer closure captures `ctx`/`parse_ident` (both `Copy`, satisfying
+            // `parse_sum`'s `C: Copy` / `F: Fn(C, &[u8]) -> Option<Self> + Copy`).
             let v = Calc::<Angle>::parse_sum(i, (), parse_ident_fn)?;
 
             let rad: f32 = 'rad: {
@@ -863,8 +853,8 @@ impl<V: CalcValue> Calc<V> {
 
         // blocked_on: values/length.rs un-gate — until Length is real,
         // `atan2(10px, 5px)` (and any other length-dimension pair) falls
-        // through to the CSSNumber path below and errors with `invalid_value`,
-        // diverging from Zig (`Angle::Rad(atan2(10,5))`). Tracked as a known
+        // through to the CSSNumber path below and errors with `invalid_value`
+        // instead of producing `Angle::Rad(atan2(10,5))`. Tracked as a known
         // incompleteness; no behaviour stub is added because a partial
         // dimension matcher would mis-reduce mixed-unit lengths.
         if let Ok(v) = try_parse_atan2_args::<C, Length>(input, ctx) {
@@ -934,7 +924,6 @@ impl<V: CalcValue> Calc<V> {
         Ok(val)
     }
 
-    // PERF(port): `args` was arena bulk-free (ArrayList fed input.arena()) — profile if hot
     pub fn parse_hypot(args: &mut [Self]) -> CssResult<Option<Self>> {
         if args.len() == 1 {
             let v = core::mem::replace(&mut args[0], Calc::Number(0.0));
@@ -1104,7 +1093,6 @@ impl<V: CalcValue> Calc<V> {
     /// I don't like how this function requires allocating a second ArrayList
     /// I am pretty sure we could do this reduction in place, or do it as the
     /// arguments are being parsed.
-    // PERF(port): `args`/`reduced` were arena bulk-free (ArrayList fed input.arena()) — profile if hot
     fn reduce_args(args: &mut Vec<Self>, order: Ordering) {
         // Reduces the arguments of a min() or max() expression, combining compatible values.
         // e.g. min(1px, 1em, 2px, 3in) => min(1px, 1em)
@@ -1129,7 +1117,7 @@ impl<V: CalcValue> Calc<V> {
                 }
             }
 
-            // PORT NOTE: reshaped for borrowck — Zig stored `?*This`; Rust stores index.
+            // For borrowck, `found` stores an index rather than a pointer.
             if let Some(maybe_idx) = found {
                 if let Some(idx) = maybe_idx {
                     reduced[idx] = core::mem::replace(arg, Calc::Number(420.0));
@@ -1137,14 +1125,13 @@ impl<V: CalcValue> Calc<V> {
                 }
             } else {
                 reduced.push(core::mem::replace(arg, Calc::Number(420.0)));
-                // PERF(port): was assume_capacity-free append
                 continue;
             }
-            // arg dropped here (Zig: arg.deinit + dummy)
+            // arg dropped here
             *arg = Calc::Number(420.0);
         }
 
-        // Zig: css.deepDeinit(This, arena, args) — Rust: Drop on replace handles it.
+        // Drop on replace frees the old args.
         *args = reduced;
     }
 
@@ -1194,10 +1181,8 @@ pub enum MathFunction<V> {
     /// The `calc()` function.
     Calc(Calc<V>),
     /// The `min()` function.
-    // PERF(port): was arena bulk-free (ArrayList fed input.arena()) — profile if hot
     Min(Vec<Calc<V>>),
     /// The `max()` function.
-    // PERF(port): was arena bulk-free (ArrayList fed input.arena()) — profile if hot
     Max(Vec<Calc<V>>),
     /// The `clamp()` function.
     Clamp {
@@ -1220,7 +1205,6 @@ pub enum MathFunction<V> {
     /// The `sign()` function.
     Sign(Calc<V>),
     /// The `hypot()` function.
-    // PERF(port): was arena bulk-free (ArrayList fed input.arena()) — profile if hot
     Hypot(Vec<Calc<V>>),
 }
 
@@ -1392,7 +1376,7 @@ impl<V> MathFunction<V> {
         }
     }
 
-    // Zig `deinit` only freed owned Vec/Calc fields → handled by Drop. No explicit impl.
+    // Owned Vec/Calc fields are freed by Drop. No explicit impl.
 
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr>
     where
@@ -1540,7 +1524,6 @@ pub enum RoundingStrategy {
 }
 
 fn arr2<T>(a: T, b: T) -> Vec<T> {
-    // PERF(port): was arena bulk-free (ArrayList fed input.arena()) — profile if hot
     vec![a, b]
 }
 
@@ -1566,7 +1549,7 @@ fn sqrtf32(v: f32) -> f32 {
     v.sqrt()
 }
 
-/// Zig `std.math.sign` — returns -1.0, 0.0, or 1.0 (NOT Rust's `f32::signum`, which
+/// Returns -1.0, 0.0, or 1.0 (NOT Rust's `f32::signum`, which
 /// returns ±1.0 for ±0.0).
 fn std_math_sign(v: f32) -> f32 {
     if v > 0.0 {
@@ -1615,7 +1598,7 @@ fn absf(a: f32) -> f32 {
 // numeric-protocol surface (`mul_f32`/`try_sign`/`try_map`/`try_op{,_to}`/
 // `partial_cmp`/`try_from_angle`/`parse`/`to_css`/`is_compatible`) is
 // satisfied via `crate::values::protocol::*` supertraits; only the
-// calc-specific Zig `switch (V)` arms (`intoValue` / `addValue` / `intoCalc`
+// calc-specific methods (`intoValue` / `addValue` / `intoCalc`
 // / `eql`) live here.
 //
 // Any type whose protocol impls don't already exist elsewhere gets them
@@ -1668,9 +1651,7 @@ impl CalcValue for Angle {
 // ─────────────────────────────────────────────────────────────────────────────
 // `protocol::*` forwarder stamper for `CalcValue` leaf types.
 //
-// Rust analogue of Zig's single comptime dispatcher in `src/css/generics.zig`
-// (`tryFromAngle`/`trySign`/`tryMap`/`tryOp`/`tryOpTo`/`partialCmp`, lines
-// ~489-570), which duck-types via `@hasDecl(T, "sign")` etc. Here each leaf
+// Each leaf
 // opts in per-trait; only the listed arms are stamped — `Parse`/`ToCss`/
 // `IsCompatible` already supplied by `impl_parse_tocss_via_inherent!` /
 // `bridge_is_compatible!` stay out of the invocation.
@@ -1799,7 +1780,6 @@ impl CalcValue for Percentage {
     fn from_calc(c: Calc<Self>, _input: &mut css::Parser) -> CssResult<Self> {
         match c {
             Calc::Value(v) => Ok(*v),
-            // Zig: else → Percentage { v: NaN }
             _ => Ok(Percentage { v: f32::NAN }),
         }
     }
@@ -1888,7 +1868,6 @@ impl CalcValue for Length {
         Length::into_calc(self)
     }
     fn from_calc(c: Calc<Self>, _input: &mut css::Parser) -> CssResult<Self> {
-        // Zig: Length { .calc = Box::new(self) }
         Ok(Length::Calc(Box::new(c)))
     }
     #[inline]
@@ -1949,5 +1928,3 @@ macro_rules! dim_pct_protocol {
 }
 dim_pct_protocol!(LengthValue);
 dim_pct_protocol!(Angle, parse_to_css: forward,);
-
-// ported from: src/css/values/calc.zig
diff --git a/src/css/values/color.rs b/src/css/values/color.rs
index ba92a1ae9ec..fd3f599a467 100644
--- a/src/css/values/color.rs
+++ b/src/css/values/color.rs
@@ -17,7 +17,7 @@ use bun_alloc::Arena;
 use bun_core::strings;
 
 // ───────────────────────── colorspace structs ────────────────────────────
-// Field layout matches `color.zig`; every space is 3 channels + alpha.
+// Every space is 3 channels + alpha.
 
 /// A color with red, green, blue, and alpha components, in a byte each.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -86,20 +86,19 @@ impl RGBA {
         }
     }
 
-    /// Zig: `rgba.into(.HSL)` — routes RGBA → SRGB → HSL.
+    /// Routes RGBA → SRGB → HSL.
     #[inline]
     pub fn into_hsl(self) -> HSL {
         HSL::from_rgba(self)
     }
 
-    /// Zig: `rgba.into(.LAB)` — routes RGBA → SRGB → LAB.
+    /// Routes RGBA → SRGB → LAB.
     #[inline]
     pub fn into_lab(self) -> LAB {
         LAB::from_rgba(self)
     }
 
     /// Convert any `CssColor` into `RGBA` by routing through `SRGB`.
-    /// Zig: `ColorspaceConversions(@This()).tryFromCssColor`.
     #[inline]
     pub fn try_from_css_color(color: &CssColor) -> Option<RGBA> {
         Some(SRGB::try_from_css_color(color)?.into_rgba())
@@ -122,8 +121,7 @@ impl RGBA {
 ///
 /// NaN → 0 (clamp passes NaN through; `NaN as u8` saturates to 0).
 ///
-/// NOTE: this *rounds*. Do **not** use for thumbhash, whose spec truncates
-/// (`thumbhash.zig:256` `@intFromFloat`).
+/// NOTE: this *rounds*. Do **not** use for thumbhash, whose spec truncates.
 #[inline]
 pub(crate) fn clamp_unit_f32(val: f32) -> u8 {
     (val * 255.0).round().clamp(0.0, 255.0) as u8
@@ -165,11 +163,8 @@ pub enum FloatColor {
 // Variant dispatch — single source of truth for (Variant ↔ Payload type ↔
 // css-name ↔ hash-ordinal). Every match-over-all-variants in this file is
 // driven from the three `impl_variant_dispatch!` invocations below; do NOT
-// hand-roll a new copy.
-//
-// Mirrors Zig's `switch (color.*) { inline else => |*v| v.into(T) }` shape
-// (color.zig:3213 `ColorspaceConversions`) which the original Rust port
-// regressed into 14 textual copies inside `define_colorspace!`.
+// hand-roll a new copy (an earlier version
+// regressed into 14 textual copies inside `define_colorspace!`).
 //
 // ROW ORDER IS LOAD-BEARING: ordinals feed `CssColor::hash` (Wyhash).
 // css-name is NOT derivable from the ident: `XyzD65` serializes as `"xyz"`
@@ -392,7 +387,7 @@ pub enum CssColor {
     System(SystemColor),
 }
 
-/// `Result(CssColor)` — Zig: `pub const ParseResult = Result(CssColor);`
+/// `Result(CssColor)`.
 pub type ParseResult = css::CssResult<CssColor>;
 
 impl Default for CssColor {
@@ -403,8 +398,6 @@ impl Default for CssColor {
 }
 
 impl CssColor {
-    // TODO(port): move to *_jsc — `pub const jsFunctionColor = @import("../../css_jsc/color_js.zig").jsFunctionColor;`
-
     /// Parse a CSS `<color>` from the parser cursor.
     pub fn parse(input: &mut css::Parser) -> CssResult<CssColor> {
         let location = input.current_source_location();
@@ -583,14 +576,12 @@ impl CssColor {
         let mut res = crate::SmallList::<CssColor, 2>::default();
 
         if fallbacks.contains(ColorFallbackKind::RGB) {
-            // PERF(port): was assume_capacity
             if let Some(rgb) = self.to_rgb() {
                 res.append(rgb);
             }
         }
 
         if fallbacks.contains(ColorFallbackKind::P3) {
-            // PERF(port): was assume_capacity
             if let Some(p3) = self.to_p3() {
                 res.append(p3);
             }
@@ -881,7 +872,6 @@ impl CssColor {
     }
 
     pub fn hash(&self, hasher: &mut bun_wyhash::Wyhash) {
-        // PORT NOTE: Zig `css.implementHash` — variant-tag prefix + payload fields.
         // Hash the discriminant + the active variant's f32 components explicitly;
         // never reinterpret a `repr(Rust)` enum as raw bytes (unspecified layout /
         // padding → UB and non-deterministic hashes).
@@ -935,8 +925,8 @@ impl crate::generics::ToCss for CssColor {
     }
 }
 
-// `light_dark` payload helpers (Zig anonymous struct methods)
-// `takeLightFreeDark` / `takeDarkFreeLight` — in Rust, taking ownership of one
+// `light_dark` payload helpers
+// `takeLightFreeDark` / `takeDarkFreeLight` — taking ownership of one
 // `Box` and dropping the other is just destructuring; provided as free fns.
 #[inline]
 pub(crate) fn take_light_free_dark(light: Box<CssColor>, dark: Box<CssColor>) -> Box<CssColor> {
@@ -997,15 +987,11 @@ impl ColorFallbackKind {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Colorspace traits (replaces Zig comptime mixins: DefineColorspace,
-// BoundedColorGamut, UnboundedColorGamut, HslHwbColorGamut, DeriveInterpolate,
-// RecangularPremultiply, PolarPremultiply, AdjustPowerlessLAB/LCH,
-// ColorspaceConversions, ColorIntoMixin, ImplementIntoCssColor)
+// Colorspace traits
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Trait every colorspace implements. The Zig used `@field(this, "x")` over the
-/// first three struct fields plus `alpha`; here we expose them by index.
-/// `// TODO(port): could be derived with a proc-macro.`
+/// Trait every colorspace implements. The
+/// first three struct fields plus `alpha` are exposed by index.
 pub trait Colorspace: Copy + Sized + FromAnyColorspace {
     const CHANNEL_NAMES: (&'static [u8], &'static [u8], &'static [u8]);
     const CHANNEL_TYPES: (ChannelType, ChannelType, ChannelType);
@@ -1081,8 +1067,7 @@ pub trait Colorspace: Copy + Sized + FromAnyColorspace {
     fn into_css_color(self) -> CssColor;
 }
 
-/// Gamut behavior — replaces UnboundedColorGamut / BoundedColorGamut /
-/// HslHwbColorGamut comptime mixins.
+/// Gamut behavior — in-gamut check and clipping per color space.
 pub trait ColorGamut: Sized + Copy {
     fn in_gamut(&self) -> bool;
     fn clip(&self) -> Self;
@@ -1251,7 +1236,6 @@ pub fn parse_hslhwb_components<T>(
     parser: &mut ComponentParser,
     allows_legacy: bool,
 ) -> CssResult<(f32, f32, f32, bool)> {
-    // Zig name: parseHSLHWBComponents — acronym run collapses to one segment
     let _ = core::marker::PhantomData::<T>; // autofix
     let h = parse_angle_or_number(input, parser)?;
     let is_legacy_syntax = allows_legacy
@@ -1508,18 +1492,18 @@ impl LABColor {
     }
 
     pub fn new_oklab(l: f32, a: f32, b: f32, alpha: f32) -> LABColor {
-        // PORT NOTE: Zig had `LABColor{ .lab = OKLAB.new(...) }` which looks like a bug;
-        // mirrored as Lab variant for behavioral parity.
+        // Intentionally the `Lab` variant (sic) — kept for behavioral
+        // compatibility.
         LABColor::Lab(LAB { l, a, b, alpha })
     }
 
     pub fn new_lch(l: f32, a: f32, b: f32, alpha: f32) -> LABColor {
-        // PORT NOTE: Zig had `LABColor{ .lab = LCH.new(...) }` (likely bug); mirrored.
+        // Intentionally the `Lab` variant (sic) — kept for behavioral compatibility.
         LABColor::Lab(LAB { l, a, b, alpha })
     }
 
     pub fn new_oklch(l: f32, a: f32, b: f32, alpha: f32) -> LABColor {
-        // PORT NOTE: Zig had `LABColor{ .lab = LCH.new(...) }` (likely bug); mirrored.
+        // Intentionally the `Lab` variant (sic) — kept for behavioral compatibility.
         LABColor::Lab(LAB { l, a, b, alpha })
     }
 
@@ -1559,8 +1543,7 @@ impl FloatColor {
 // Colorspace structs (LAB, SRGB, HSL, HWB, SRGBLinear, P3, A98, ProPhoto,
 // Rec2020, XYZd50, XYZd65, LCH, OKLAB, OKLCH)
 //
-// In Zig each struct manually wires `pub const X = mixin.X` for ~12 mixin
-// items. In Rust the trait impls below cover that surface; the per-type
+// The trait impls below cover the shared surface; the per-type
 // declarations collapse into a `define_colorspace!` macro invocation.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -1777,8 +1760,8 @@ define_colorspace! {
     premultiply = rectangular;
     powerless = none;
     into_css = |srgb: &SRGB| {
-        // TODO: should we serialize as color(srgb, ...)?
-        // would be more precise than 8-bit color.
+        // Serializes through 8-bit RGBA, matching upstream lightningcss
+        // (`color(srgb, ...)` would be more precise but would change output).
         CssColor::Rgba(RGBA::from(*srgb))
     };
 }
@@ -1813,8 +1796,8 @@ define_colorspace! {
 define_colorspace! {
     /// A color in the [`sRGB-linear`](https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear) color space.
     SRGBLinear { r, g, b }
-    // PORT NOTE: Zig had `.r = ChannelType{ .angle = true }` for SRGBLinear which looks like a bug;
-    // mirrored for parity.
+    // `r` intentionally uses the angle channel type (sic) — kept for
+    // behavioral compatibility.
     types = (CT_ANG, CT_PCT, CT_PCT);
     gamut = bounded;
     premultiply = rectangular;
@@ -2069,7 +2052,7 @@ impl ComponentParser {
 }
 
 /// Helper trait so `parse_from` can build a light-dark wrapper for the result
-/// type `C`. (Zig used `C.lightDarkOwned`.)
+/// type `C`.
 pub(crate) trait LightDarkOwned: Sized {
     fn light_dark_owned(light: Self, dark: Self) -> Self;
 }
@@ -2141,9 +2124,7 @@ impl RelativeComponentParser {
             return Ok(css::color::AngleOrNumber::Number { value });
         }
 
-        // PORT NOTE: Zig threads a stack `Angle` through `Calc(Angle).parseWith`
-        // via a closure that returns `Calc{ .value = &t.angle }` (raw stack
-        // pointer). Rust `Calc::Value` is `Box<V>`, so box the temporary.
+        // `Calc::Value` is `Box<V>`, so box the temporary `Angle`.
         if let Ok(value) = input.try_parse(|i| {
             match Calc::<Angle>::parse_with(i, this, |ctx, ident| {
                 let value = ctx.get_ident(ident, allowed)?;
@@ -2309,7 +2290,6 @@ impl RelativeComponentParser {
 
 bitflags::bitflags! {
     /// A channel type for a color space.
-    /// TODO(zack): why tf is this bitflags?
     #[derive(Clone, Copy, PartialEq, Eq)]
     pub struct ChannelType: u8 {
         /// Channel represents a percentage.
@@ -2337,7 +2317,7 @@ pub fn parse_predefined(
             None
         };
 
-        // PORT NOTE: reshaped for borrowck — detach the slice from the
+        // Reshaped for borrowck — detach the slice from the
         // `&mut self` borrow so `i` is reusable below.
         let colorspace = i.expect_ident_cloned()?;
 
@@ -2402,7 +2382,7 @@ pub fn parse_predefined_relative(
         b"srgb" => PredefinedColor::Srgb(SRGB { r: a, g: b, b: c, alpha }),
         b"srgb-linear" => PredefinedColor::SrgbLinear(SRGBLinear { r: a, g: b, b: c, alpha }),
         b"display-p3" => PredefinedColor::DisplayP3(P3 { r: a, g: b, b: c, alpha }),
-        // PORT NOTE: Zig has "a99-rgb" here (typo?); mirrored for behavioral parity.
+        // "a99-rgb" (sic) — kept for behavioral compatibility.
         b"a99-rgb" => PredefinedColor::A98(A98 { r: a, g: b, b: c, alpha }),
         b"prophoto-rgb" => PredefinedColor::Prophoto(ProPhoto { r: a, g: b, b: c, alpha }),
         b"rec2020" => PredefinedColor::Rec2020(Rec2020 { r: a, g: b, b: c, alpha }),
@@ -2501,7 +2481,7 @@ pub fn parse_color_mix(input: &mut css::Parser) -> CssResult<CssColor> {
         ColorSpaceName::Xyz | ColorSpaceName::XyzD65 => {
             first_color.interpolate::<XYZd65>(p1, &second_color, p2, hue_method)
         }
-        // PORT NOTE: Zig used XYZd65 for xyz-d50 too (likely bug); mirrored for parity.
+        // Intentionally XYZd65 for xyz-d50 too (sic) — kept for behavioral compatibility.
         ColorSpaceName::XyzD50 => {
             first_color.interpolate::<XYZd65>(p1, &second_color, p2, hue_method)
         }
@@ -2583,7 +2563,6 @@ fn rectangular_to_polar(l: f32, a: f32, b: f32) -> (f32, f32, f32) {
         h += 360.0;
     }
 
-    // PERF: Zig does not have Rust's f32::powi
     let c = (a.powi(2) + b.powi(2)).sqrt();
 
     h = h.rem_euclid(360.0);
@@ -2782,14 +2761,9 @@ const D50: [f32; 3] = [
 ];
 
 // ──────────────────────────────────────────────────────────────────────────
-// Handwritten conversions (Zig `color_conversions` namespace).
+// Handwritten conversions.
 //
-// In Zig, `ColorIntoMixin(T, .Space).into(target)` looked up `intoXXX` in
-// (a) handwritten `color_conversions.convert_<Space>`, then
-// (b) generated `generated_color_conversions.convert_<Space>`, then
-// (c) the type itself.
-//
-// In Rust we express each conversion as `impl From<Src> for Dst`. The
+// Each conversion is an `impl From<Src> for Dst`. The
 // handwritten ones are below; generated ones live in `color_generated.rs`.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -3332,7 +3306,8 @@ impl From<XYZd50> for ProPhoto {
             // convert linear-light prophoto-rgb  in the range 0.0-1.0
             // to gamma corrected form
             // Transfer curve is gamma 1.8 with a small linear portion
-            // TODO for negative values, extend linear portion on reflection of axis, then add pow below that
+            // For negative values, the linear portion is extended on
+            // reflection of axis, with pow applied beyond it (csswg conversions.js).
             const ET: f32 = 1.0 / 512.0;
             let abs = c.abs();
             if abs >= ET {
@@ -3637,15 +3612,10 @@ impl From<OKLCH> for OKLAB {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// ConvertTo (kept for parity; in Rust the `.into()` dispatch above replaces
-// `ColorIntoMixin(T, .Space).into(target)`).
+// ConvertTo (kept for parity with the `.into()` dispatch above).
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: `ColorIntoMixin` resolved conversions at comptime via @hasDecl
-// across handwritten + generated tables. In Rust this is the union of the
-// `impl From<Src> for Dst` blocks above plus `color_generated.rs`; the
-// generated file fills the transitive gaps the macro requires.
+// Conversions are the union of the `impl From<Src> for Dst` blocks above
+// plus `color_generated.rs`; the generated file fills the transitive gaps.
 
 crate::css_eql_partialeq!(CssColor);
-
-// ported from: src/css/values/color.zig
diff --git a/src/css/values/color_generated.rs b/src/css/values/color_generated.rs
index 43823af928d..b2d7629fd8b 100644
--- a/src/css/values/color_generated.rs
+++ b/src/css/values/color_generated.rs
@@ -1,17 +1,14 @@
 //! This file is generated by `color_via.ts`. Do not edit it directly!
 //!
-//! Ported from `src/css/values/color_generated.zig` (946 lines).
-//!
-//! Each `convert_<Src>.into<Dst>` in the Zig becomes an `impl From<Src> for Dst`
-//! here. The Zig comptime mixin `ColorIntoMixin(T, .Space).into(target)` searched
-//! handwritten conversions first, then this generated table; in Rust both are
+//! Generated colorspace conversions: each is an `impl From<Src> for Dst`.
+//! Handwritten conversions and this generated table are both
 //! flattened into the global `From`/`Into` trait graph, so any pair already
 //! defined by a handwritten impl in `color.rs` is *omitted* below to avoid the
 //! overlapping-impl error (Rust forbids duplicate `From` impls).
 //!
 //! Omitted (handwritten in `color.rs::gated_full_impl` takes precedence):
-//!   - `From<HSL> for RGBA`  (Zig: `convert_HSL.intoRGBA`)
-//!   - `From<HWB> for RGBA`  (Zig: `convert_HWB.intoRGBA`)
+//!   - `From<HSL> for RGBA`
+//!   - `From<HWB> for RGBA`
 
 use super::color::{
     A98, HSL, HWB, LAB, LCH, OKLAB, OKLCH, P3, ProPhoto, RGBA, Rec2020, SRGB, SRGBLinear, XYZd50,
@@ -248,5 +245,3 @@ convert_via!(OKLCH => XYZd65 => Rec2020);
 convert_via!(OKLCH => XYZd65 => HSL);
 convert_via!(OKLCH => XYZd65 => HWB);
 convert_via!(OKLCH => SRGB   => RGBA);
-
-// ported from: src/css/values/color_generated.zig
diff --git a/src/css/values/css_string.rs b/src/css/values/css_string.rs
index cbb4bed93bb..960cd50e69c 100644
--- a/src/css/values/css_string.rs
+++ b/src/css/values/css_string.rs
@@ -27,5 +27,3 @@ impl CssStringFns {
         dest.serialize_string(s)
     }
 }
-
-// ported from: src/css/values/css_string.zig
diff --git a/src/css/values/easing.rs b/src/css/values/easing.rs
index 30981e81a0d..df2154dba9c 100644
--- a/src/css/values/easing.rs
+++ b/src/css/values/easing.rs
@@ -52,9 +52,9 @@ enum EasingKeyword {
     StepEnd,
 }
 
-/// Zig: `Map.getASCIIICaseInsensitive(ident)`.
+/// ASCII-case-insensitive keyword lookup.
 ///
-/// PERF(port): was `phf::Map<&[u8], _>` + lowercase-into-stack-buf + `get`.
+/// PERF: chosen over `phf::Map<&[u8], _>` + lowercase-into-stack-buf + `get`.
 /// 7 keys with near-unique lengths (only len 8 collides: `ease-out` /
 /// `step-end`), so a length-gated byte match is cheaper than phf's
 /// hash+displace+verify — one `usize` compare rejects almost every miss
@@ -85,7 +85,7 @@ fn easing_map_get_any_case(ident: &[u8]) -> Option<EasingKeyword> {
 
 impl EasingFunction {
     pub fn parse(input: &mut css::Parser) -> Result<EasingFunction> {
-        // PORT NOTE: reshaped for borrowck — `try_parse(|i| i.expect_ident())`
+        // Reshaped for borrowck — `try_parse(|i| i.expect_ident())`
         // ties the returned slice to the closure's `&mut Parser` borrow, so the
         // ident can't escape. Read the next token by value (Token slices are
         // `'static` placeholders for the not-yet-threaded `'bump`) and dispatch
@@ -258,10 +258,10 @@ enum StepPositionKeyword {
     JumpEnd,
 }
 
-/// Zig: `Map.getASCIIICaseInsensitive(ident)` — lowercase into a stack buffer,
+/// ASCII-case-insensitive keyword lookup — lowercase into a stack buffer,
 /// then a length-gated byte match.
 ///
-/// PERF(port): was `phf::Map<&[u8], _>` (6 keys). phf hashes the whole slice
+/// PERF: chosen over `phf::Map<&[u8], _>` (6 keys). phf hashes the whole slice
 /// before a single bucket compare; with 6 keys spread across 5 distinct
 /// lengths (3/5/8/9/9/10), gating on `len()` rejects every miss with one
 /// `usize` compare and resolves every hit with at most one slice compare
@@ -285,8 +285,7 @@ fn step_position_map_get_any_case(ident: &[u8]) -> Option<StepPositionKeyword> {
 }
 
 impl StepPosition {
-    // TODO(port): Zig used `css.DeriveToCss(@This()).toCss` — reflection-derived serializer.
-    // Replace with `#[derive(ToCss)]` once the trait/derive exists.
+    /// Hand-written keyword serializer.
     pub fn to_css(self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
         dest.write_str(<&'static str>::from(self))
     }
@@ -313,5 +312,3 @@ impl StepPosition {
         Ok(keyword)
     }
 }
-
-// ported from: src/css/values/easing.zig
diff --git a/src/css/values/gradient.rs b/src/css/values/gradient.rs
index 17631e82381..dbc501a9a2f 100644
--- a/src/css/values/gradient.rs
+++ b/src/css/values/gradient.rs
@@ -35,8 +35,7 @@ pub trait GradientPosition: Sized + Clone + PartialEq {
 
 // Only two `D` instantiations exist (`LengthValue` / `Angle`); both already
 // satisfy `DimensionPercentage<D>: CalcValue` in `calc.rs`. A blanket impl
-// would need to re-state that bound; concrete impls are simpler and match
-// the Zig monomorphization sites exactly.
+// would need to re-state that bound; concrete impls are simpler.
 macro_rules! impl_gradient_position {
     ($ty:ty) => {
         impl GradientPosition for $ty {
@@ -1455,8 +1454,6 @@ pub fn parse_items<D: GradientPosition>(input: &mut css::Parser) -> Result<Vec<G
     let mut seen_stop = false;
 
     loop {
-        // PORT NOTE: reshaped for borrowck — Zig used a Closure { items: *ArrayList, seen_stop: *bool }
-        // captured into parseUntilBefore; here we close over &mut locals directly.
         input.parse_until_before(
             css::Delimiters::COMMA,
             |i: &mut css::Parser| -> Result<()> {
@@ -1577,5 +1574,3 @@ pub(crate) fn convert_stops_to_webkit(
 
     Some(stops)
 }
-
-// ported from: src/css/values/gradient.zig
diff --git a/src/css/values/ident.rs b/src/css/values/ident.rs
index 21108d8cf37..84a44d90e77 100644
--- a/src/css/values/ident.rs
+++ b/src/css/values/ident.rs
@@ -20,8 +20,9 @@ macro_rules! arena_slice_newtype {
         $(#[$meta])*
         #[derive(Debug, Clone, Copy)]
         pub struct $name {
-            // TODO(port): arena lifetime — CSS parser slices are arena-owned; thread a `'bump`
-            // lifetime through instead of erasing to a raw pointer.
+            // CSS parser slices are arena-owned; the borrow is erased to a raw
+            // pointer until the crate threads a `'bump` lifetime (see
+            // PORTING.md §Allocators). Never dereferenced after arena reset.
             pub v: *const [u8],
         }
 
@@ -41,20 +42,18 @@ macro_rules! arena_slice_newtype {
             #[inline]
             pub fn v(&self) -> &[u8] {
                 // SAFETY: arena-owned, never null, immutable for the parse session
-                // (see field-level TODO(port) on `'bump` threading).
+                // (see the field-level comment on `'bump` threading).
                 unsafe { crate::arena_str(self.v) }
             }
 
             pub fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-                // PORT NOTE: Zig `css.implementDeepClone` — field-wise. The
-                // `*const [u8]` slice is arena-owned (never mutated, freed on
-                // arena reset), so identity copy is correct (matches generics.zig
-                // "const strings" fast-path).
+                // The `*const [u8]` slice is arena-owned (never mutated, freed
+                // on arena reset), so identity copy is correct.
                 *self
             }
 
             pub fn hash(&self, hasher: &mut Wyhash) {
-                // PORT NOTE: Zig `css.implementHash` (comptime field-walk) → arena slice bytes.
+                // Hash the arena slice bytes.
                 hasher.update(self.v());
             }
 
@@ -73,7 +72,7 @@ macro_rules! arena_slice_newtype {
 // `from` field below uses it directly. `parse_with_options` honors
 // `ParserOptions.css_modules.dashed_idents`. `to_css` resolves the
 // import-record path up front and hands it to `CssModule::reference_dashed`
-// (borrowck — see PORT NOTE on that method).
+// (borrowck — see the comment on that method).
 
 /// A CSS [`<dashed-ident>`](https://www.w3.org/TR/css-values-4/#dashed-idents) reference.
 ///
@@ -93,9 +92,7 @@ pub struct DashedIdentReference {
 
 impl DashedIdentReference {
     pub(crate) fn eql(&self, rhs: &Self) -> bool {
-        // PORT NOTE: Zig `css.implementEql` — field-wise. `from` is a CSS-modules
-        // resolution hint, not part of value identity, so compare on `ident` only
-        // (matches Zig `Specifier`-less comparison in the dashed-ident dedup path).
+        // Field-wise over `ident` and `from`.
         use crate::generics::CssEql;
         self.ident.eql(&rhs.ident) && self.from.eql(&rhs.from)
     }
@@ -149,11 +146,10 @@ impl DashedIdentReference {
             let ident_v = unsafe { crate::arena_str(self.ident.v) };
             let source_index = dest.loc.source_index;
             let bump = dest.arena;
-            // PORT NOTE: Zig `referenceDashed` took `*Printer` and called
-            // `dest.importRecord()` internally. Rust borrowck forbids handing
+            // Borrowck forbids handing
             // `dest` to a method on `dest.css_module`, so resolve the path
-            // here and pass the slice down. The `?` preserves the Zig
-            // `try dest.importRecord(...)` error path.
+            // here and pass the slice down. The `?` propagates the
+            // `import_record` error path.
             use crate::properties::css_modules::Specifier;
             let specifier_path: Option<&[u8]> = match &self.from {
                 Some(Specifier::ImportRecordIndex(idx)) => {
@@ -187,13 +183,26 @@ arena_slice_newtype! {
     DashedIdent
 }
 
-// TODO(port): Zig `pub fn HashMap(comptime V: type) type` returned an
-// ArrayHashMapUnmanaged with a custom string-hash context. Inherent assoc
-// type aliases are unstable in Rust; expose as a free type alias instead.
-// bun_collections::ArrayHashMap is wyhash-keyed; verify the hasher matches
-// std.array_hash_map.hashString or supply a custom Hash impl.
-// blocked_on: bun_collections::ArrayHashMap surface
-pub type DashedIdentHashMap<V> = bun_collections::ArrayHashMap<DashedIdent, V>;
+/// Hash/eql context for [`DashedIdentHashMap`]: keys hash their string bytes
+/// (wyhash seed 0, truncated to u32) and compare by byte equality.
+#[derive(Default, Clone, Copy)]
+pub struct DashedIdentContext;
+
+impl bun_collections::array_hash_map::ArrayHashContext<DashedIdent> for DashedIdentContext {
+    #[inline]
+    fn hash(&self, key: &DashedIdent) -> u32 {
+        bun_collections::array_hash_map::hash_string(key.v())
+    }
+
+    #[inline]
+    fn eql(&self, a: &DashedIdent, b: &DashedIdent, _b_index: usize) -> bool {
+        a.v() == b.v()
+    }
+}
+
+/// Inherent assoc type aliases
+/// are unstable in Rust, so this is a free type alias instead.
+pub type DashedIdentHashMap<V> = bun_collections::ArrayHashMap<DashedIdent, V, DashedIdentContext>;
 
 impl DashedIdent {
     pub fn parse(input: &mut Parser) -> CssResult<DashedIdent> {
@@ -248,7 +257,7 @@ impl Ident {
 #[derive(Clone, Copy, Default)]
 pub struct IdentOrRef(u128);
 
-// Zig packed struct(u128) field layout, LSB-first:
+// Packed u128 field layout, LSB-first:
 //   __ptrbits: u63  -> bits  0..63
 //   __ref_bit: bool -> bit   63
 //   __len:     u64  -> bits 64..128
@@ -303,7 +312,8 @@ impl IdentOrRef {
 
     #[cfg(debug_assertions)]
     pub fn debug_ident(self) -> &'static [u8] {
-        // TODO(port): lifetime — returns arena-borrowed slice; `'static` is a placeholder.
+        // Returns an arena-borrowed slice; `'static` is a placeholder for the
+        // not-yet-threaded `'bump` lifetime.
         if self.ref_bit() {
             let ptr = self.ptrbits() as usize as *const *const [u8];
             // SAFETY: in debug builds, `ptrbits` stores a valid arena-allocated `*const *const [u8]`
@@ -315,15 +325,14 @@ impl IdentOrRef {
         }
     }
 
-    // NOTE: no `#[cfg(not(debug_assertions))]` variant. Zig's `@compileError` is lazy (fires only
-    // if the body is analyzed); Rust's `compile_error!` fires at expansion and would break every
-    // release build. Omitting the fn in release yields a name-resolution error at the call site,
-    // which is the closest Rust equivalent.
+    // NOTE: no `#[cfg(not(debug_assertions))]` variant. `compile_error!` fires at expansion and
+    // would break every release build. Omitting the fn in release yields a name-resolution error
+    // at the call site, which is the intent: this is debug-only.
 
     pub fn from_ident(ident: Ident) -> Self {
         let s = ident.v();
         let (ptr, len) = (s.as_ptr() as usize as u64, s.len() as u64);
-        // @intCast(@intFromPtr(...)) — narrowing usize→u63 is checked in debug
+        // narrowing usize→u63 is checked in debug
         debug_assert!(ptr & (1u64 << 63) == 0);
         Self::pack(ptr, false, len)
     }
@@ -387,7 +396,8 @@ impl IdentOrRef {
         map: &bun_ast::symbol::Map,
         local_names: Option<&css::LocalsResultsMap>,
     ) -> Option<&'static [u8]> {
-        // TODO(port): lifetime — returns arena/symbol-table borrow; `'static` is a placeholder.
+        // Returns an arena/symbol-table borrow; `'static` is a placeholder for
+        // the not-yet-threaded `'bump` lifetime.
         if self.is_ident() {
             // SAFETY: arena slice reconstructed from packed ptr/len
             return Some(unsafe { crate::arena_str(self.as_ident().unwrap().v) });
@@ -416,9 +426,9 @@ impl IdentOrRef {
         if let Some(ident) = self.as_ident() {
             hasher.update(ident.v());
         } else {
-            // SAFETY: self is #[repr(transparent)] u128; reading first 2 bytes matches Zig's
-            // `slice_u8[0..2]` (which is almost certainly a Zig bug — hashes 2 bytes, not 16).
-            // TODO(port): verify upstream intent; preserving behavior verbatim.
+            // SAFETY: self is #[repr(transparent)] u128 (16 bytes), so reading the first 2
+            // bytes is in-bounds. Hashing only 2 of the 16 bytes (sic) is preserved for
+            // behavioral compatibility; PR #30784 hashes the full identity.
             let bytes = unsafe {
                 core::slice::from_raw_parts(std::ptr::from_ref::<Self>(self).cast::<u8>(), 2)
             };
@@ -521,5 +531,3 @@ impl CustomIdent {
 
 /// A list of CSS [`<custom-ident>`](https://www.w3.org/TR/css-values-4/#custom-idents) values.
 pub type CustomIdentList = SmallList<CustomIdent, 1>;
-
-// ported from: src/css/values/ident.zig
diff --git a/src/css/values/image.rs b/src/css/values/image.rs
index 719c062717e..ae5f54c5f16 100644
--- a/src/css/values/image.rs
+++ b/src/css/values/image.rs
@@ -11,8 +11,6 @@ use bun_alloc::Arena;
 use bun_ast::ImportKind;
 
 /// A CSS [`<image>`](https://www.w3.org/TR/css-images-3/#image-values) value.
-// TODO(port): `parse`/`to_css` were `css.DeriveParse(@This()).parse` / `css.DeriveToCss(@This()).toCss`
-// — comptime-reflection derives. Hand-expanded below until the proc-macro lands.
 #[derive(Default)]
 pub enum Image {
     /// The `none` keyword.
@@ -21,14 +19,12 @@ pub enum Image {
     /// A `url()`.
     Url(Url),
     /// A gradient.
-    // PERF(port): arena-allocated in Zig (bun.create); LIFETIMES.tsv → Box<Gradient>
     Gradient(Box<Gradient>),
     /// An `image-set()`.
     ImageSet(ImageSet),
 }
 
 impl Image {
-    // NOTE: `pub fn deinit` was a no-op in Zig (all CSS parser memory is arena-owned).
     // No `Drop` impl needed — Box/Vec fields drop automatically.
 
     pub fn is_compatible(&self, browsers: &css::targets::Browsers) -> bool {
@@ -67,7 +63,6 @@ impl Image {
 
     pub fn get_prefixed(&self, arena: &Arena, prefix: css::VendorPrefix) -> Image {
         match self {
-            // PERF(port): was arena bulk-free — profile if hot
             Image::Gradient(grad) => Image::Gradient(Box::new(grad.get_prefixed(arena, prefix))),
             Image::ImageSet(image_set) => Image::ImageSet(image_set.get_prefixed(arena, prefix)),
             _ => self.deep_clone(arena),
@@ -109,8 +104,6 @@ impl Image {
 
     #[inline]
     pub fn eql(&self, other: &Image) -> bool {
-        // TODO(port): was `css.implementEql(@This(), this, other)` (comptime field-walk).
-        // Hand-expanded; replace with `#[derive(PartialEq)]` once `Url: PartialEq`.
         match (self, other) {
             (Image::None, Image::None) => true,
             (Image::Url(a), Image::Url(b)) => a.import_record_idx == b.import_record_idx,
@@ -121,7 +114,6 @@ impl Image {
     }
 
     pub fn deep_clone(&self, arena: &Arena) -> Self {
-        // TODO(port): was `css.implementDeepClone(@This(), this, arena)` (comptime field-walk).
         match self {
             Image::None => Image::None,
             Image::Url(u) => Image::Url(Url {
@@ -138,12 +130,9 @@ impl Image {
     /// May return an error in case the gradient cannot be converted.
     pub fn get_legacy_webkit(&self, arena: &Arena) -> Option<Image> {
         match self {
-            Image::Gradient(gradient) => {
-                // PERF(port): was arena bulk-free — profile if hot
-                Some(Image::Gradient(Box::new(
-                    gradient.get_legacy_webkit(arena)?,
-                )))
-            }
+            Image::Gradient(gradient) => Some(Image::Gradient(Box::new(
+                gradient.get_legacy_webkit(arena)?,
+            ))),
             _ => Some(self.deep_clone(arena)),
         }
     }
@@ -169,8 +158,8 @@ impl Image {
         let prefix_image: &Image = if let Some(r) = &rgb { r } else { &*self };
 
         // Legacy -webkit-gradient()
-        // PORT NOTE: Zig's `and`/`if-else` precedence here is preserved verbatim:
-        // `if (targets.browsers) |b| isWebkitGradient(b) else (false and prefix_image.* == .gradient)`
+        // The `false && ...` else branch is intentional (sic) — kept for
+        // behavioral compatibility.
         if prefixes.contains(VendorPrefix::WEBKIT)
             && if let Some(browsers) = targets.browsers {
                 css::prefixes::Feature::is_webkit_gradient(&browsers)
@@ -223,7 +212,6 @@ impl Image {
 
     pub fn get_fallback(&self, arena: &Arena, kind: ColorFallbackKind) -> Image {
         match self {
-            // PERF(port): was arena bulk-free — profile if hot
             Image::Gradient(grad) => Image::Gradient(Box::new(grad.get_fallback(arena, kind))),
             _ => self.deep_clone(arena),
         }
@@ -236,11 +224,7 @@ impl Image {
         }
     }
 
-    // TODO(port): `css.DeriveParse(@This()).parse` — hand-expanded: try each
-    // variant in Zig field order (none/url/gradient/image-set).
-    // blocked_on: `Url::parse` (gated on `Parser::add_import_record`). The
-    // gradient/image-set arms are real; the url arm un-gates with url.rs.
-
+    // Variants are tried in declaration order: none, url, gradient, image-set.
     pub fn parse(input: &mut css::Parser) -> Result<Image> {
         if input
             .try_parse(|i| i.expect_ident_matching(b"none"))
@@ -257,7 +241,6 @@ impl Image {
         ImageSet::parse(input).map(Image::ImageSet)
     }
 
-    // PORT: `css.DeriveToCss(@This()).toCss` — hand-expanded over enum variants.
     pub fn to_css(&self, dest: &mut css::Printer) -> core::result::Result<(), css::PrintErr> {
         match self {
             Image::None => dest.write_str(b"none"),
@@ -293,7 +276,6 @@ impl crate::small_list::ImageFallback for Image {
 /// display the most appropriate resolution or file type that it supports.
 pub struct ImageSet {
     /// The image options to choose from.
-    // PERF(port): was ArrayListUnmanaged fed arena — profile if hot
     pub options: Vec<ImageSetOption>,
 
     /// The vendor prefix for the `image-set()` function.
@@ -345,14 +327,12 @@ impl ImageSet {
     /// Returns the `image-set()` value with the given vendor prefix.
     pub(crate) fn get_prefixed(&self, arena: &Arena, prefix: css::VendorPrefix) -> ImageSet {
         ImageSet {
-            // TODO(port): was `css.deepClone(ImageSetOption, arena, &this.options)` (comptime helper)
             options: self.options.iter().map(|o| o.deep_clone(arena)).collect(),
             vendor_prefix: prefix,
         }
     }
 
     pub(crate) fn eql(&self, other: &ImageSet) -> bool {
-        // TODO(port): was `css.implementEql(@This(), this, other)` — derive PartialEq instead.
         self.vendor_prefix == other.vendor_prefix
             && self.options.len() == other.options.len()
             && self
@@ -363,7 +343,6 @@ impl ImageSet {
     }
 
     pub(crate) fn deep_clone(&self, arena: &Arena) -> Self {
-        // TODO(port): was `css.implementDeepClone(@This(), this, arena)` — derive Clone instead.
         ImageSet {
             options: self.options.iter().map(|o| o.deep_clone(arena)).collect(),
             vendor_prefix: self.vendor_prefix,
@@ -390,7 +369,8 @@ pub struct ImageSetOption {
     /// The resolution of the image.
     pub resolution: Resolution,
     /// The mime type of the image.
-    // TODO(port): arena-borrowed slice from tokenizer input; revisit ownership.
+    // Arena-borrowed slice from the tokenizer input; the parser arena outlives
+    // this value (see SAFETY notes at the use sites).
     pub file_type: Option<*const [u8]>,
 }
 
@@ -398,7 +378,7 @@ impl ImageSetOption {
     pub(crate) fn parse(input: &mut css::Parser) -> Result<ImageSetOption> {
         let start_position = input.input.tokenizer.get_position();
         let loc = input.current_source_location();
-        // PORT NOTE: `expect_url_or_string` returns a borrow of the parser, so
+        // `expect_url_or_string` returns a borrow of the parser, so
         // it can't be used as a `try_parse` callback directly (the result type
         // `R` may not borrow the closure arg). Erase the borrow via `*const`
         // — token slices are arena-static (see `css_parser::src_str`).
@@ -413,7 +393,6 @@ impl ImageSetOption {
                 loc: css::dependencies::Location::from_source_location(loc),
             })
         } else {
-            // For some reason, `Image.parse` made zls crash; the Zig used `@call(.auto, ...)`.
             Image::parse(input)?
         };
 
@@ -446,7 +425,7 @@ impl ImageSetOption {
                 unreachable!()
             };
             let dep_: Option<UrlDependency> = if dest.dependencies.is_some() {
-                // PORT NOTE: hoist `get_import_records` (mut borrow) out of the
+                // Hoist `get_import_records` (mut borrow) out of the
                 // arg list so `filename()` (shared borrow) can run; result is `&'a _`.
                 let import_records = dest.get_import_records()?;
                 Some(UrlDependency::new(
@@ -464,7 +443,7 @@ impl ImageSetOption {
                 let placeholder = unsafe { crate::arena_str(dep.placeholder) };
                 dest.serialize_string(placeholder)?;
                 if let Some(dependencies) = &mut dest.dependencies {
-                    // PERF(port): was `catch |err| bun.handleOom(err)` — Vec::push aborts on OOM by default
+                    // Vec::push aborts on OOM by default.
                     dependencies.push(css::Dependency::Url(dep));
                 }
             } else {
@@ -497,7 +476,6 @@ impl ImageSetOption {
         if let Some(file_type) = self.file_type {
             dest.write_str(" type(")?;
             // SAFETY: file_type points into the arena-owned parser input which outlives printing.
-            // TODO(port): replace raw slice with proper arena-lifetime borrow.
             let file_type_slice = unsafe { crate::arena_str(file_type) };
             dest.serialize_string(file_type_slice)?;
             dest.write_char(b')')?;
@@ -507,7 +485,6 @@ impl ImageSetOption {
     }
 
     pub(crate) fn deep_clone(&self, arena: &Arena) -> Self {
-        // TODO(port): was `css.implementDeepClone(@This(), this, arena)` — derive Clone instead.
         ImageSetOption {
             image: self.image.deep_clone(arena),
             resolution: self.resolution,
@@ -516,7 +493,6 @@ impl ImageSetOption {
     }
 
     pub(crate) fn eql(&self, rhs: &ImageSetOption) -> bool {
-        // TODO(port): was `css.implementEql(@This(), lhs, rhs)` — derive PartialEq instead.
         self.image.eql(&rhs.image)
             && self.resolution == rhs.resolution
             && match (self.file_type, rhs.file_type) {
@@ -531,9 +507,8 @@ impl ImageSetOption {
 fn parse_file_type(input: &mut css::Parser) -> Result<*const [u8]> {
     input.expect_function_matching(b"type")?;
     input.parse_nested_block(|i: &mut css::Parser| {
-        // TODO(port): expect_string returns arena-borrowed &[u8]; coerced to raw ptr to avoid struct lifetime
+        // expect_string returns an arena-borrowed &[u8]; coerced to a raw ptr to
+        // avoid a struct lifetime (token slices outlive the parse session).
         i.expect_string().map(std::ptr::from_ref::<[u8]>)
     })
 }
-
-// ported from: src/css/values/image.zig
diff --git a/src/css/values/length.rs b/src/css/values/length.rs
index 504bf05ed39..3ebd9bd285b 100644
--- a/src/css/values/length.rs
+++ b/src/css/values/length.rs
@@ -37,9 +37,6 @@ impl Default for LengthOrNumber {
     }
 }
 
-// Zig `deinit` only freed the owned `calc` Box inside Length — handled by Drop now.
-// Zig `eql` → derive(PartialEq); Zig `deepClone` → derive(Clone).
-
 pub(crate) type LengthPercentage = DimensionPercentage<LengthValue>;
 
 /// Either a [`<length-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-length-percentage), or the `auto` keyword.
@@ -62,8 +59,6 @@ impl LengthPercentageOrAuto {
     }
 }
 
-// Zig `eql` → derive(PartialEq); Zig `deepClone` → derive(Clone).
-
 const PX_PER_IN: f32 = 96.0;
 const PX_PER_CM: f32 = PX_PER_IN / 2.54;
 const PX_PER_MM: f32 = PX_PER_CM / 10.0;
@@ -74,15 +69,13 @@ const PX_PER_PC: f32 = PX_PER_IN / 6.0;
 // ──────────────────────────────────────────────────────────────────────────
 // LengthValue
 //
-// The Zig original is a `union(enum)` with ~50 variants, each carrying a single
-// `CSSNumber` (f32). Nearly every method iterates `std.meta.fields(@This())` /
-// `bun.meta.EnumFields(@This())` to dispatch by tag — Zig comptime reflection.
+// An enum with ~50 variants, each carrying a single `CSSNumber` (f32).
 //
 // Per PORTING.md §"Comptime reflection": >8 variants → small macro generator.
 // `define_length_units!` generates the enum plus the handful of per-variant
 // dispatch helpers (`value()`, `unit()`, `from_unit_ci()`, `map_value()`,
 // `try_same_unit_op()`, `feature()`); all higher-level methods are then written
-// in terms of those, keeping the logic 1:1 with the Zig.
+// in terms of those.
 // ──────────────────────────────────────────────────────────────────────────
 
 macro_rules! define_length_units {
@@ -138,7 +131,7 @@ macro_rules! define_length_units {
                 }
             }
 
-            /// Compat-feature gate for this unit (the Zig `FeatureMap`).
+            /// Compat-feature gate for this unit.
             #[inline]
             fn feature(&self) -> Option<Feature> {
                 match self { $( Self::$variant(_) => $feature, )* }
@@ -268,8 +261,7 @@ define_length_units! {
     Cqmax: b"cqmax" => Some(Feature::ContainerQueryLengthUnits),
 }
 
-// The Zig `comptime { ... }` block at :253-262 statically asserts that
-// `FeatureMap` covers every variant. The macro above guarantees this by
+// The macro above guarantees feature coverage of every variant by
 // construction (one `=> $feature` per variant), so no separate assert needed.
 
 impl LengthValue {
@@ -351,7 +343,6 @@ impl LengthValue {
     }
 
     pub(crate) fn map(self, map_fn: impl FnOnce(f32) -> f32) -> LengthValue {
-        // PERF(port): was comptime monomorphization (`comptime map_fn: *const fn`).
         self.map_value(map_fn)
     }
 
@@ -397,7 +388,7 @@ impl LengthValue {
 impl PartialEq for LengthValue {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        // Zig `eql`: same tag AND equal payload (f32 `==`).
+        // Same tag AND equal payload (f32 `==`).
         core::mem::discriminant(self) == core::mem::discriminant(other)
             && self.value() == other.value()
     }
@@ -422,8 +413,6 @@ impl Length {
         self.clone()
     }
 
-    // Zig `deinit` → Drop on Box<Calc<Length>> handles this.
-
     pub(crate) fn parse(input: &mut Parser) -> CssResult<Length> {
         if let Ok(calc_value) = input.try_parse(Calc::<Length>::parse) {
             // PERF: I don't like this redundant allocation
@@ -440,8 +429,6 @@ impl Length {
     // to_css — provided by #[derive(css::ToCss)] (Box<Calc<Length>> auto-derefs
     // to Calc::<V: CalcValue>::to_css inherent). parse KEPT (custom Calc::Value unwrap).
 
-    // Zig `eql` → derive(PartialEq).
-
     pub(crate) fn px(p: CSSNumber) -> Length {
         Self::Value(LengthValue::Px(p))
     }
@@ -526,8 +513,7 @@ impl Length {
                 right: Box::new(b.into_calc()),
             })),
         }
-        // PORT NOTE: reshaped for borrowck — Zig matched on tags then accessed
-        // `a.calc.value` / `b.calc.value` while both were still bound; Rust needs
+        // For borrowck this needs
         // to move out of the Box, so the conditions are folded into match guards.
     }
 
@@ -557,9 +543,8 @@ impl Length {
                 }
                 _ => return None,
             }
-            // TODO(port): the Zig builds `Length{ .calc = s.left }` without
-            // cloning (alias of the same heap node). With `Box` ownership we
-            // must clone here; revisit if Calc nodes become arena-backed refs.
+            // `Box` ownership requires cloning the sub-nodes here (no aliasing
+            // of the same heap node).
         }
 
         if let Self::Calc(c) = other {
@@ -596,8 +581,7 @@ impl Length {
             },
             _ => length,
         }
-        // PORT NOTE: reshaped for borrowck — Zig rebinds `c` while reading `c.*`;
-        // Rust moves out of the Box once and rebuilds.
+        // For borrowck, this moves out of the Box once and rebuilds.
     }
 
     pub(crate) fn try_sign(&self) -> Option<f32> {
@@ -699,7 +683,7 @@ impl protocol::TryMap for LengthValue {
 impl protocol::TryOp for LengthValue {
     #[inline]
     fn try_op<C>(&self, rhs: &Self, ctx: C, f: impl Fn(C, f32, f32) -> f32) -> Option<Self> {
-        // PORT NOTE: `LengthValue::try_op` takes a 2-arg closure (ctx folded
+        // `LengthValue::try_op` takes a 2-arg closure (ctx folded
         // in by caller); the `protocol::TryOp` shape passes `C` by-value with
         // no `Copy` bound, so we can't capture `ctx` in an `Fn` closure that
         // might be called more than once. Inline the same-unit + px-convert
@@ -708,8 +692,8 @@ impl protocol::TryOp for LengthValue {
             let v = f(ctx, self.value(), rhs.value());
             return Some(self.map_value(|_| v));
         }
-        // PORT NOTE: Zig calls `this.toPx()` for BOTH operands here (length.zig:447) —
-        // preserving that behavior verbatim; likely an upstream bug.
+        // Intentionally calls `self.to_px()` for BOTH operands (sic) — kept
+        // for behavioral compatibility.
         if let (Some(a), Some(b)) = (self.to_px(), self.to_px()) {
             return Some(LengthValue::Px(f(ctx, a, b)));
         }
@@ -722,8 +706,8 @@ impl protocol::TryOpTo for LengthValue {
         if core::mem::discriminant(self) == core::mem::discriminant(rhs) {
             return Some(f(ctx, self.value(), rhs.value()));
         }
-        // PORT NOTE: Zig calls `this.toPx()` for BOTH operands here (length.zig:473) —
-        // preserving that behavior verbatim; likely an upstream bug.
+        // Intentionally calls `self.to_px()` for BOTH operands (sic) — kept
+        // for behavioral compatibility.
         if let (Some(a), Some(b)) = (self.to_px(), self.to_px()) {
             return Some(f(ctx, a, b));
         }
@@ -799,9 +783,8 @@ impl protocol::TryMap for Angle {
 impl protocol::TryOp for Angle {
     #[inline]
     fn try_op<C>(&self, rhs: &Self, ctx: C, f: impl Fn(C, f32, f32) -> f32) -> Option<Self> {
-        // PORT NOTE: `Angle::op` takes a `fn(C, f32, f32)` pointer (Zig
-        // `comptime`-monomorphized fn arg), so we can't pass the generic
-        // closure through it. Inline the per-variant dispatch here instead.
+        // `Angle::op` takes a `fn(C, f32, f32)` pointer, so we can't pass the
+        // generic closure through it. Inline the per-variant dispatch here instead.
         Some(match (self, rhs) {
             (Angle::Deg(a), Angle::Deg(b)) => Angle::Deg(f(ctx, *a, *b)),
             (Angle::Rad(a), Angle::Rad(b)) => Angle::Rad(f(ctx, *a, *b)),
@@ -847,5 +830,3 @@ impl protocol::IsCompatible for Angle {
         true
     }
 }
-
-// ported from: src/css/values/length.zig
diff --git a/src/css/values/mod.rs b/src/css/values/mod.rs
index eee401eb419..00652cfa40b 100644
--- a/src/css/values/mod.rs
+++ b/src/css/values/mod.rs
@@ -34,10 +34,9 @@ pub mod position;
 pub mod rect;
 pub mod size;
 pub mod syntax;
-// `color_generated.rs` is the codegen'd named-color tables (47KB). Its parent
-// in Zig was `color.zig`'s `pub usingnamespace`; here it's a sibling module
-// re-exported through `color::*` so the stub-set re-export at crate root
-// (`pub use values::color::{CssColor, RGBA, ...}`) keeps resolving.
+// `color_generated.rs` is the codegen'd named-color tables (47KB). It's a
+// sibling module re-exported through `color::*` so the stub-set re-export at
+// crate root (`pub use values::color::{CssColor, RGBA, ...}`) keeps resolving.
 #[path = "color_generated.rs"]
 pub mod color_generated;
 pub mod ident;
@@ -52,5 +51,3 @@ pub mod protocol {
         TryMap, TryOp, TryOpTo, TrySign, Zero,
     };
 }
-
-// ported from: src/css/values/values.zig
diff --git a/src/css/values/number.rs b/src/css/values/number.rs
index ba32d31d773..e1e141b3591 100644
--- a/src/css/values/number.rs
+++ b/src/css/values/number.rs
@@ -25,7 +25,6 @@ impl CSSNumberFns {
         let number: f32 = this;
         if number != 0.0 && number.abs() < 1.0 {
             let mut dtoa_buf: [u8; 129] = [0; 129];
-            // PERF(port): Zig left dtoa_buf uninitialized — profile if hot.
             let (str, _) = css::dtoa_short(&mut dtoa_buf, number, 6);
             if number < 0.0 {
                 dest.write_char(b'-')?;
@@ -44,7 +43,7 @@ impl CSSNumberFns {
 
     pub fn sign(this: CSSNumber) -> f32 {
         if this == 0.0 {
-            // Spec-faithful (number.zig:45): ±0.0 both map to +0.0 — do NOT
+            // Spec-faithful: ±0.0 both map to +0.0 — do NOT
             // collapse with `signfns::sign_f32` / `calc::std_math_sign`.
             return 0.0;
         }
@@ -68,5 +67,3 @@ impl CSSIntegerFns {
         css::to_css::integer(this, dest)
     }
 }
-
-// ported from: src/css/values/number.zig
diff --git a/src/css/values/percentage.rs b/src/css/values/percentage.rs
index 9bcaa8eac5d..ecc68059285 100644
--- a/src/css/values/percentage.rs
+++ b/src/css/values/percentage.rs
@@ -30,7 +30,6 @@ impl Percentage {
     pub(crate) fn to_css(self, dest: &mut Printer) -> Result<(), PrintErr> {
         let x = self.v * 100.0;
         let int_value: Option<i32> = if (x - x.trunc()) == 0.0 {
-            // PORT NOTE: Rust `as` saturates on overflow/NaN where Zig is UB.
             Some(self.v as i32)
         } else {
             None
@@ -152,15 +151,10 @@ impl<D: PartialEq + Clone> PartialEq for DimensionPercentage<D> {
 }
 
 // `Zero`/`MulF32`/`TryAdd`/`Parse` protocol traits live in
-// `crate::values::protocol` until `generics::parse_tocss_numeric_gated`
-// un-gates. The bound set below mirrors the full Zig comptime-method surface
-// on `D`; per-method `where` clauses narrow further so plain
-// `DimensionPercentage<D>` (no behavior) needs only `D: Clone`.
-impl<D> DimensionPercentage<D>
-where
-    // TODO(port): narrow these bounds; mirroring methods called on D below.
-    D: Clone,
-{
+// `crate::values::protocol`. Bounds on `D` are expressed via per-method
+// `where` clauses, so plain `DimensionPercentage<D>` (no behavior) needs no
+// bounds at all.
+impl<D> DimensionPercentage<D> {
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self>
     where
         Self: crate::values::calc::CalcValue,
@@ -170,7 +164,6 @@ where
             if let Calc::Value(v) = calc_value {
                 return Ok(*v);
             }
-            // PERF(port): was arena alloc (bun.create with input.arena()) — profile if hot.
             return Ok(Self::Calc(Box::new(calc_value)));
         }
 
@@ -209,19 +202,20 @@ where
         }
     }
 
-    pub(crate) fn deep_clone(&self) -> Self {
+    pub(crate) fn deep_clone(&self) -> Self
+    where
+        D: Clone,
+    {
         match self {
-            // PORT NOTE: Zig branched on `comptime needs_deepclone` to avoid cloning POD types.
-            // In Rust, D: Clone covers both — Copy types' clone is a bitwise copy.
+            // D: Clone covers POD types too — Copy types' clone is a bitwise copy.
             Self::Dimension(d) => Self::Dimension(d.clone()),
             Self::Percentage(p) => Self::Percentage(*p),
-            // PERF(port): was arena alloc (bun.create) — profile if hot.
             Self::Calc(calc) => Self::Calc(Box::new(calc.deep_clone())),
         }
     }
 
-    // PORT NOTE: `deinit` dropped — Box<Calc<...>> frees via Drop; D's Drop (if any) runs
-    // automatically. Zig body only freed owned fields, so no explicit `impl Drop` needed.
+    // No explicit `impl Drop` needed — Box<Calc<...>> frees via Drop; D's Drop
+    // (if any) runs automatically.
 
     pub(crate) fn zero() -> Self
     where
@@ -256,7 +250,6 @@ where
         match self {
             Self::Dimension(d) => Self::Dimension(Self::mul_value_f32(d, other)),
             Self::Percentage(p) => Self::Percentage(p.mul_f32(other)),
-            // PERF(port): was arena alloc (bun.create) — profile if hot.
             Self::Calc(c) => Self::Calc(Box::new(c.mul_f32(other))),
         }
     }
@@ -289,9 +282,9 @@ where
             (Self::Calc(this_calc), _) => match this_calc.as_ref() {
                 Calc::Value(v) => return v.add_recursive(other),
                 Calc::Sum { left, right } => {
-                    // PORT NOTE: reshaped for borrowck — Zig wrapped sum.left/right (raw ptrs)
-                    // directly in This{.calc = ...}. Here we deep_clone since Box is owning.
-                    // TODO(port): lifetime — sum.left/right ownership semantics need review.
+                    // With owning Boxes we deep_clone the sum operands. The values
+                    // are only read during this computation, so the clone is
+                    // semantically equivalent (just extra allocation).
                     let left_calc = Self::Calc(left.deep_clone_boxed());
                     if let Some(res) = left_calc.add_recursive(other) {
                         return Some(res.add_impl(Self::Calc(right.deep_clone_boxed())));
@@ -361,13 +354,10 @@ where
                 };
                 a.add_impl(*v)
             }
-            (a, b) => {
-                // PERF(port): was arena alloc (bun.create) — profile if hot.
-                Self::Calc(Box::new(Calc::Sum {
-                    left: Box::new(a.into_calc()),
-                    right: Box::new(b.into_calc()),
-                }))
-            }
+            (a, b) => Self::Calc(Box::new(Calc::Sum {
+                left: Box::new(a.into_calc()),
+                right: Box::new(b.into_calc()),
+            })),
         }
     }
 
@@ -438,7 +428,6 @@ where
     pub(crate) fn into_calc(self) -> Calc<DimensionPercentage<D>> {
         match self {
             Self::Calc(calc) => *calc,
-            // PERF(port): was arena alloc (bun.create) — profile if hot.
             other => Calc::Value(Box::new(other)),
         }
     }
@@ -454,9 +443,8 @@ pub enum NumberOrPercentage {
 }
 
 impl NumberOrPercentage {
-    // PORT NOTE: Zig used `css.DeriveParse(@This()).parse` / `css.DeriveToCss(@This()).toCss`
-    // (comptime reflection derives). Hand-rolled here as the trivial two-variant
-    // try-parse cascade so `AlphaValue::parse` doesn't panic at runtime.
+    // Hand-rolled as the trivial two-variant try-parse cascade so
+    // `AlphaValue::parse` doesn't panic at runtime.
     pub(crate) fn parse(input: &mut css::Parser) -> CssResult<NumberOrPercentage> {
         if let Ok(n) = input.try_parse(crate::values::number::CSSNumberFns::parse) {
             return Ok(NumberOrPercentage::Number(n));
@@ -497,5 +485,3 @@ impl PartialEq for Percentage {
 }
 
 crate::css_eql_partialeq!(NumberOrPercentage);
-
-// ported from: src/css/values/percentage.zig
diff --git a/src/css/values/position.rs b/src/css/values/position.rs
index c455bc3e579..e3fccdd9988 100644
--- a/src/css/values/position.rs
+++ b/src/css/values/position.rs
@@ -148,8 +148,6 @@ impl Position {
     }
 
     pub(crate) fn to_css(&self, dest: &mut css::Printer) -> Result<(), css::PrintErr> {
-        // PORT NOTE: reshaped for borrowck — Zig used tag-then-payload-access (`this.x == .side and this.x.side.side != .left`);
-        // Rust uses if-let pattern matching to bind payloads.
         if let (PositionComponent::Side(xs), PositionComponent::Length(yl)) = (&self.x, &self.y) {
             if xs.side != HorizontalPositionKeyword::Left {
                 self.x.to_css(dest)?;
@@ -312,9 +310,8 @@ pub enum PositionComponent<S> {
     Side(PositionComponentSide<S>),
 }
 
-// PORT NOTE: Zig used duck-typed `S.parse`/`S.toCss`; Rust bounds on the
-// values-local `protocol::{Parse,ToCss}` shapes until `generics::Parse`
-// un-gates.
+// `S` is bounded on the values-local `protocol::{Parse,ToCss}` shapes until
+// `generics::Parse` un-gates.
 impl<S: protocol::Parse + protocol::ToCss + Clone + PartialEq> PositionComponent<S> {
     pub(crate) fn is_zero(&self) -> bool {
         if let PositionComponent::Length(l) = self {
@@ -420,5 +417,3 @@ impl VerticalPositionKeyword {
 
 pub(crate) type HorizontalPosition = PositionComponent<HorizontalPositionKeyword>;
 pub(crate) type VerticalPosition = PositionComponent<VerticalPositionKeyword>;
-
-// ported from: src/css/values/position.zig
diff --git a/src/css/values/ratio.rs b/src/css/values/ratio.rs
index 5d15f69c423..c78f40063ba 100644
--- a/src/css/values/ratio.rs
+++ b/src/css/values/ratio.rs
@@ -44,7 +44,6 @@ impl Ratio {
         Ok(())
     }
 
-    // PORT NOTE: dropped unused `std.mem.Allocator` param (was `_` in Zig).
     pub(crate) fn add_f32(self, other: f32) -> Ratio {
         Ratio {
             numerator: self.numerator + other,
@@ -52,5 +51,3 @@ impl Ratio {
         }
     }
 }
-
-// ported from: src/css/values/ratio.zig
diff --git a/src/css/values/rect.rs b/src/css/values/rect.rs
index 7a8c585a8ee..ccaf32c9d33 100644
--- a/src/css/values/rect.rs
+++ b/src/css/values/rect.rs
@@ -3,11 +3,9 @@ use crate::css_parser::{CssResult as Result, PrintErr, Printer};
 use crate::targets::Browsers;
 use crate::values::protocol::{IsCompatible, Parse, ToCss};
 
-// PORT NOTE: the Zig `needsDeinit(comptime T: type) bool` switch and the
-// `deinit(this, arena)` method are dropped entirely. They existed to
-// thread per-field `arena.free` through a comptime type table; in Rust,
-// `T: Drop` on the four fields handles this automatically (and arena-owned
-// payloads in `bun_css` are bulk-freed by the bump, never per-value).
+// No `deinit` is needed: `T: Drop` on the four fields handles cleanup
+// automatically (and arena-owned payloads in `bun_css` are bulk-freed by the
+// bump, never per-value).
 
 /// A generic value that represents a value for four sides of a box,
 /// e.g. border-width, margin, padding, etc.
@@ -40,11 +38,8 @@ impl<T> Rect<T> {
     where
         T: Clone,
     {
-        // PORT NOTE: Zig branched on `comptime needs_deinit` to decide between
-        // bitwise copy and per-field `.deepClone(arena)`. In Rust this is
-        // just the `DeepClone`/`Clone` trait on `T` — the cheap-copy types
+        // The `Clone` trait on `T` covers everything — the cheap-copy types
         // (`f32`, `NumberOrPercentage`, `LineStyle`) impl it as a bit copy.
-        // TODO(port): narrow trait bound once css::generic::DeepClone lands.
         Self {
             top: self.top.clone(),
             right: self.right.clone(),
@@ -163,5 +158,3 @@ impl<T: IsCompatible> IsCompatible for Rect<T> {
             && self.left.is_compatible(browsers)
     }
 }
-
-// ported from: src/css/values/rect.zig
diff --git a/src/css/values/resolution.rs b/src/css/values/resolution.rs
index 52d102f23c3..8a9bbee8917 100644
--- a/src/css/values/resolution.rs
+++ b/src/css/values/resolution.rs
@@ -87,5 +87,3 @@ impl Resolution {
         }
     }
 }
-
-// ported from: src/css/values/resolution.zig
diff --git a/src/css/values/size.rs b/src/css/values/size.rs
index 6caed113cf9..f3df7adc690 100644
--- a/src/css/values/size.rs
+++ b/src/css/values/size.rs
@@ -10,13 +10,9 @@ pub struct Size2D<T> {
     pub b: T,
 }
 
-// PORT NOTE: Zig's `switch (T) { f32 => ..., LengthPercentage => ..., else => T.parse }`
-// is comptime type dispatch. In Rust this is expressed via trait bounds — `f32` and
-// `LengthPercentage` must impl the same `Parse`/`ToCss`/`Eql` traits as other CSS value
-// types (the `f32` impls delegate to `CSSNumberFns`). The per-type `switch` arms are
-// therefore collapsed into trait method calls below.
-// TODO(port): confirm trait names match the crate API once `generics::
-// parse_tocss_numeric_gated` un-gates; for now bound on `values::protocol`.
+// Per-type dispatch is expressed via trait bounds — `f32` and
+// `LengthPercentage` impl the same `Parse`/`ToCss` traits as other CSS value
+// types (the `f32` impls delegate to `CSSNumberFns`).
 impl<T> Size2D<T>
 where
     T: Clone + PartialEq,
@@ -25,7 +21,7 @@ where
     where
         T: Parse,
     {
-        // PORT NOTE: f32 → CSSNumberFns::parse, LengthPercentage → LengthPercentage::parse,
+        // f32 → CSSNumberFns::parse, LengthPercentage → LengthPercentage::parse,
         // else → T::parse — all unified under the `Parse` trait in Rust.
         T::parse(input)
     }
@@ -60,14 +56,12 @@ where
     where
         T: ToCss,
     {
-        // PORT NOTE: f32 → CSSNumberFns::to_css, else → val.to_css — unified under `ToCss` trait.
+        // f32 → CSSNumberFns::to_css, else → val.to_css — unified under `ToCss` trait.
         val.to_css(dest)
     }
 
     pub(crate) fn deep_clone(&self, _bump: &Arena) -> Self {
-        // TODO(port): css::implement_deep_clone is @typeInfo-based reflection in Zig;
-        // replace with #[derive(DeepClone)] or arena-aware deep_clone.
-        // For now `T: Clone` covers it (Box payloads deep-clone via their Clone impls).
+        // `T: Clone` covers this (Box payloads deep-clone via their Clone impls).
         Size2D {
             a: self.a.clone(),
             b: self.b.clone(),
@@ -76,19 +70,16 @@ where
 
     #[inline]
     pub(crate) fn val_eql(lhs: &T, rhs: &T) -> bool {
-        // PORT NOTE: f32 → `lhs.* == rhs.*`, else → `lhs.eql(rhs)` — unified under PartialEq.
+        // f32 → `lhs.* == rhs.*`, else → `lhs.eql(rhs)` — unified under PartialEq.
         lhs == rhs
     }
 
     #[inline]
     pub(crate) fn eql(lhs: &Self, rhs: &Self) -> bool {
-        // PORT NOTE: preserved verbatim from Zig — compares lhs.a against rhs.b only
-        // (not a/a && b/b). Suspect upstream bug, but ported faithfully.
+        // Note: compares lhs.a against rhs.b only (not a/a && b/b).
         lhs.a == rhs.b
     }
 }
 
 // Keep references to the f32/LengthPercentage special-case helpers so trait
 // impls can be wired up later if they don't already exist.
-
-// ported from: src/css/values/size.zig
diff --git a/src/css/values/syntax.rs b/src/css/values/syntax.rs
index 864842a06cd..00e93951a56 100644
--- a/src/css/values/syntax.rs
+++ b/src/css/values/syntax.rs
@@ -20,14 +20,13 @@ const SPACE_CHARACTERS: &[u8] = &[0x20, 0x09];
 
 /// A CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings)
 /// used to define the grammar for a registered custom property.
-// PORT NOTE: the Zig source comments note "Zig doesn't have lifetimes, so 'i is omitted" —
-// upstream lightningcss Rust threaded `'i`, but the port uses `&'static [u8]` /
+// Upstream lightningcss Rust threaded `'i`, but the port uses `&'static [u8]` /
 // `*const [u8]` placeholders for arena-borrowed slices (matching `Token` /
-// `ident.rs`). TODO(refactor): thread `'bump` and restore the lifetime.
+// `ident.rs`); `'bump` threading would restore the lifetime.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SyntaxString {
     /// A list of syntax components.
-    // PERF(port): was arena ArrayList — `Vec` until `'bump` is threaded into BumpVec.
+    // PERF: `Vec` until `'bump` is threaded into BumpVec.
     Components(Vec<SyntaxComponent>),
     /// The universal syntax definition.
     Universal,
@@ -35,8 +34,7 @@ pub enum SyntaxString {
 
 impl SyntaxString {
     pub(crate) fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // TODO(port): css.implementDeepClone is comptime field reflection — replace with
-        // a `DeepClone` trait/derive. For now defer to Clone.
+        // `Clone` covers this — every payload owns its data.
         self.clone()
     }
 
@@ -104,8 +102,6 @@ impl SyntaxString {
         match self {
             SyntaxString::Universal => Ok(ParsedComponent::TokenList(TokenList::parse(
                 input,
-                // PORT NOTE: Zig passes `ParserOptions.default(input.arena(), null)`;
-                // Rust's signature drops the arena param (global-alloc port).
                 &ParserOptions::default(None),
                 0,
             )?)),
@@ -293,11 +289,11 @@ pub enum SyntaxComponentKind {
     /// A `<custom-ident>` component.
     CustomIdent,
     /// A literal component.
-    // PORT NOTE: PORTING.md §Forbidden bans laundering a parser-borrowed slice to
-    // `&'static`. Zig's arena keeps the source alive for the AST's lifetime; Rust
-    // would need a `'bump` lifetime threaded through `SyntaxString`. The port owns
-    // the bytes instead — `Box<[u8]>` per §Forbidden ("the field should be
-    // `Box<[T]>` … not `&'static [T]`"). May swap for `&'bump [u8]` later.
+    // PORTING.md §Forbidden bans laundering a parser-borrowed slice to
+    // `&'static`; that would need a `'bump` lifetime threaded through
+    // `SyntaxString`. We own the bytes instead — `Box<[u8]>` per §Forbidden
+    // ("the field should be `Box<[T]>` … not `&'static [T]`"). May swap for
+    // `&'bump [u8]` later.
     Literal(Box<[u8]>),
 }
 
@@ -385,9 +381,9 @@ fn is_name_code_point(c: u8) -> bool {
 // ─── ParsedComponent ──────────────────────────────────────────────────────
 // `ParsedComponent` is the materialized form of a `SyntaxComponentKind` and
 // carries `Image` / `CssColor` / `Transform{,List}` / `TokenList` payloads.
-// PORT NOTE: no `#[derive]` — payload types lack a common Debug/Clone/PartialEq
+// No `#[derive]` — payload types lack a common Debug/Clone/PartialEq
 // surface (Image: none; TokenList: Default-only; Ident/CustomIdent: no Eq;
-// Transform: no Debug). Zig has only `deepClone` + `toCss`, mirrored below.
+// Transform: no Debug). Only `deep_clone` + `to_css` are provided below.
 pub enum ParsedComponent {
     /// A `<length>` value.
     Length(Length),
@@ -400,9 +396,9 @@ pub enum ParsedComponent {
     /// A `<color>` value.
     Color(CssColor),
     /// An `<image>` value.
-    Image(Image), // Zig doesn't have lifetimes, so 'i is omitted.
+    Image(Image),
     /// A `<url>` value.
-    Url(Url), // Lifetimes are omitted in Zig.
+    Url(Url),
     /// An `<integer>` value.
     Integer(CSSInteger),
     /// An `<angle>` value.
@@ -414,9 +410,9 @@ pub enum ParsedComponent {
     /// A `<transform-function>` value.
     TransformFunction(Transform),
     /// A `<transform-list>` value.
-    // PORT NOTE: `TransformList<'bump>` borrows the parser arena. The port uses
-    // `'static` placeholders (matching `Token`/`Ident`). TODO(refactor): thread
-    // `'bump` through `ParsedComponent<'a>`.
+    // `TransformList<'bump>` borrows the parser arena. The port uses
+    // `'static` placeholders (matching `Token`/`Ident`); `'bump` threading
+    // through `ParsedComponent<'a>` would restore the lifetime.
     TransformList(TransformList),
     /// A `<custom-ident>` value.
     CustomIdent(CustomIdent),
@@ -431,7 +427,7 @@ pub enum ParsedComponent {
 /// A repeated component value.
 pub struct Repeated {
     /// The components to repeat.
-    // PERF(port): was arena ArrayList — `Vec` until `'bump` is threaded into BumpVec.
+    // PERF: `Vec` until `'bump` is threaded into BumpVec.
     pub components: Vec<ParsedComponent>,
     /// A multiplier describing how the components repeat.
     pub multiplier: Multiplier,
@@ -439,7 +435,7 @@ pub struct Repeated {
 
 impl Repeated {
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: hand-expanded `css.implementDeepClone` (field-wise reflection):
+        // Hand-expanded `css.implementDeepClone` (field-wise reflection):
         // ArrayList → Vec deep-cloned per element; `Multiplier` is `Copy`.
         Repeated {
             components: self.components.iter().map(|c| c.deep_clone(bump)).collect(),
@@ -480,11 +476,9 @@ impl ParsedComponent {
     }
 
     pub(crate) fn deep_clone(&self, bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: hand-expanded `css.implementDeepClone` (variant-wise reflection).
         // Payload signatures aren't yet uniform across the crate (some `deep_clone()`
         // take no arena, some take `&Arena`, some are `Copy`), so the `#[derive(DeepClone)]`
-        // macro can't cover this enum until the signatures are unified. Match-arm dispatch
-        // mirrors the Zig comptime switch exactly.
+        // macro can't cover this enum until the signatures are unified.
         match self {
             ParsedComponent::Length(v) => ParsedComponent::Length(v.deep_clone()),
             ParsedComponent::Number(v) => ParsedComponent::Number(*v),
@@ -525,5 +519,3 @@ pub enum Multiplier {
     /// The component may repeat one or more times, separated by commas.
     Comma,
 }
-
-// ported from: src/css/values/syntax.zig
diff --git a/src/css/values/time.rs b/src/css/values/time.rs
index 1ba1b1a4e47..e6c150ba5b6 100644
--- a/src/css/values/time.rs
+++ b/src/css/values/time.rs
@@ -26,7 +26,6 @@ pub enum Time {
     Milliseconds(CSSNumber) = 2,
 }
 
-// Mirrors Zig's nested `Tag = enum(u8) { seconds = 1, milliseconds = 2 }`.
 const TAG_SECONDS: u16 = 1;
 const TAG_MILLISECONDS: u16 = 2;
 
@@ -54,8 +53,6 @@ impl Time {
             Ok(vv) => match vv {
                 Calc::Value(v) => {
                     let ret: Time = *v;
-                    // redundant allocation
-                    // Zig: vvv.deinit(input.arena()) — Drop handles this; line deleted.
                     return Ok(ret);
                 }
                 // Time is always compatible, so they will always compute to a value.
@@ -139,7 +136,6 @@ impl Time {
     }
 
     pub fn mul_f32(self, other: f32) -> Time {
-        // Zig arena param dropped (unused).
         match self {
             Time::Seconds(s) => Time::Seconds(s * other),
             Time::Milliseconds(ms) => Time::Milliseconds(ms * other),
@@ -147,18 +143,14 @@ impl Time {
     }
 
     pub fn add_internal(self, other: Time) -> Time {
-        // Zig arena param dropped (forwarded but ultimately unused).
         self.add(other)
     }
 
     pub fn into_calc(self) -> Calc<Time> {
-        // PERF(port): was arena alloc (bun.create) — Calc<V>::Value now owns Box<V>.
         Calc::Value(Box::new(self))
     }
 
     pub fn add(self, other: Self) -> Time {
-        // Zig arena param dropped (unused).
-        // PORT NOTE: Zig passes `void` ctx + free fn; Rust closure captures nothing.
         self.op(other, |a, b| a + b)
     }
 
@@ -167,7 +159,6 @@ impl Time {
     }
 
     pub fn map(self, map_fn: impl Fn(f32) -> f32) -> Time {
-        // PERF(port): was comptime fn-pointer monomorphization — profile if hot.
         match self {
             Time::Seconds(s) => Time::Seconds(map_fn(s)),
             Time::Milliseconds(ms) => Time::Milliseconds(map_fn(ms)),
@@ -182,10 +173,6 @@ impl Time {
     }
 
     pub fn op(self, other: Time, op_fn: impl Fn(f32, f32) -> f32) -> Time {
-        // PORT NOTE: Zig uses `ctx: anytype` + comptime fn-pointer (its closure idiom).
-        // Rust closures capture ctx directly, so the `ctx` param is dropped.
-        // PORT NOTE: reshaped bit-packed `switch_val` into an exhaustive tuple match;
-        // semantics are identical, `unreachable` arm is unnecessary.
         let _ = (self.tag(), TAG_SECONDS, TAG_MILLISECONDS); // keep tag consts referenced
         match (self, other) {
             (Time::Seconds(a), Time::Seconds(b)) => Time::Seconds(op_fn(a, b)),
@@ -196,7 +183,6 @@ impl Time {
     }
 
     pub fn op_to<R>(self, other: Time, op_fn: impl Fn(f32, f32) -> R) -> R {
-        // PORT NOTE: see `op` — ctx param folded into closure; bit-packed switch reshaped.
         match (self, other) {
             (Time::Seconds(a), Time::Seconds(b)) => op_fn(a, b),
             (Time::Milliseconds(a), Time::Milliseconds(b)) => op_fn(a, b),
@@ -205,5 +191,3 @@ impl Time {
         }
     }
 }
-
-// ported from: src/css/values/time.zig
diff --git a/src/css/values/url.rs b/src/css/values/url.rs
index 1c324e7af3d..be98d342e43 100644
--- a/src/css/values/url.rs
+++ b/src/css/values/url.rs
@@ -67,7 +67,7 @@ impl Url {
     pub fn to_css(&self, dest: &mut Printer) -> Result<(), PrintErr> {
         use crate::dependencies::UrlDependency;
         let dep: Option<UrlDependency> = if dest.dependencies.is_some() {
-            // PORT NOTE: hoist `get_import_records` (mut borrow) out of the arg
+            // `get_import_records` (mut borrow) is hoisted out of the arg
             // list so `filename()` (shared borrow) can run; result is `&'a _`.
             let import_records = dest.get_import_records()?;
             Some(UrlDependency::new(
@@ -90,7 +90,6 @@ impl Url {
             dest.write_char(b')')?;
 
             if let Some(dependencies) = &mut dest.dependencies {
-                // PORT NOTE: bun.handleOom dropped — Vec::push aborts on OOM via global arena
                 dependencies.push(crate::Dependency::Url(d));
             }
 
@@ -108,12 +107,11 @@ impl Url {
         let url: &[u8] = unsafe { bun_collections::detach_lifetime(url) };
 
         if dest.minify && !is_internal {
-            // PERF(port): was std.Io.Writer.Allocating with dest.arena — using Vec<u8>; profile if hot
             let mut buf: Vec<u8> = Vec::new();
             // PERF(alloc) we could use stack fallback here?
-            // PORT NOTE: inlined `Token::to_css_generic(UnquotedUrl(url))` —
+            // `Token::to_css_generic(UnquotedUrl(url))` is inlined here —
             // `Token` payloads are `&'static [u8]` placeholders and we only
-            // have `&'a [u8]` here.
+            // have `&'a [u8]`.
             use css::WriteAll;
             if buf
                 .write_all(b"url(")
@@ -148,8 +146,6 @@ impl Url {
     }
 
     pub fn deep_clone(&self, _bump: &bun_alloc::Arena) -> Self {
-        // PORT NOTE: Zig `css.implementDeepClone` is field-wise reflection; both
-        // fields (`u32`, `dependencies::Location`) are `Copy`, so identity copy.
         Url {
             import_record_idx: self.import_record_idx,
             loc: self.loc,
@@ -165,11 +161,8 @@ impl Url {
     // TODO: dedupe import records??
     // This might not fucking work
     pub fn hash(&self, hasher: &mut bun_wyhash::Wyhash) {
-        // PORT NOTE: Zig `css.implementHash` is field-wise reflection. Only
-        // `import_record_idx` participates in identity (matches `eql` above);
-        // `loc` is presentation metadata.
+        // Only `import_record_idx` participates in identity (matches `eql`
+        // above); `loc` is presentation metadata.
         hasher.update(&self.import_record_idx.to_ne_bytes());
     }
 }
-
-// ported from: src/css/values/url.zig
diff --git a/src/css_derive/lib.rs b/src/css_derive/lib.rs
index f4c64574d46..eecdada879a 100644
--- a/src/css_derive/lib.rs
+++ b/src/css_derive/lib.rs
@@ -1,11 +1,7 @@
 //! Proc-macro derives for `bun_css`.
 //!
-//! `#[derive(DeepClone)]` is the compile-time port of Zig's
-//! `css.implementDeepClone(@This(), this, allocator)` (`src/css/generics.zig`).
-//! The Zig original is `@typeInfo(T)` reflection that walks struct fields /
-//! union variants and calls `.deepClone(allocator)` on each. Rust has no
-//! reflection, so the derive emits the equivalent field-wise / variant-wise
-//! recursion as an `impl bun_css::generics::DeepClone<'bump> for T`.
+//! `#[derive(DeepClone)]` emits field-wise / variant-wise recursion as an
+//! `impl bun_css::generics::DeepClone<'bump> for T`.
 //!
 //! The generated body uses **UFCS** dispatch
 //! (`::bun_css::generics::DeepClone::deep_clone(&field, bump)`), so the call
@@ -43,10 +39,8 @@ use syn::{
 //
 // The five derives below already exist (entry points: `DeepClone`, `CssEql`,
 // `IsCompatible`, `Parse`, `ToCss`) and already emit exactly the per-variant
-// dispatch the hand-expansions at the listed sites spell out by hand. They are
-// the direct Rust port of Zig's `css.DeriveParse` / `css.DeriveToCss` /
-// `css.implementDeepClone` / `css.implementEql` / `comptime is_compatible`
-// field-walks. Nothing is added here; this comment is the contract surface the
+// dispatch the hand-expansions at the listed sites spell out by hand.
+// Nothing is added here; this comment is the contract surface the
 // `css-value-enum-to_css-deep_clone-hand-dispatch` migration relies on.
 
 #[proc_macro_derive(DeepClone)]
@@ -61,21 +55,15 @@ pub fn derive_deep_clone(input: TokenStream) -> TokenStream {
 // `CssEql` / `CssHash`
 // ════════════════════════════════════════════════════════════════════════════
 //
-// Port of `implementEql` / `implementHash` in `src/css/generics.zig`.
-//
-// Zig's `implementEql` / `implementHash` use `@typeInfo(T)` to walk struct
-// fields or `union(enum)` variants and recurse via `eql(field.type, …)` /
-// `hash(field.type, …)`, which in turn dispatch to `T.eql` / `T.hash` if the
-// type `@hasDecl`s one. The derives below emit **UFCS** calls
+// The derives below emit **UFCS** calls
 // (`::bun_css::generics::CssEql::eql(&field, other)`,
 //  `::bun_css::generics::CssHash::hash(&field, hasher)`) so dispatch is
 // *always* through the trait — an inherent `eql`/`hash` on a field type is
 // ignored and never shadows. Every field type reached by the derive must
 // therefore carry a real `CssEql`/`CssHash` impl (blanket or derived).
 //
-// Unions: Zig prefixes the hash with `bun.writeAnyToHasher(@intFromEnum(this))`.
-// The derive feeds the variant index as a `u32` (CSS hashing is in-process
-// dedup only — self-consistency, not Zig-byte-identity, is the contract).
+// Enums: the derive feeds the variant index into the hash as a `u32` (CSS
+// hashing is in-process dedup only — self-consistency is the contract).
 
 #[proc_macro_derive(CssEql, attributes(css))]
 pub fn derive_css_eql(input: TokenStream) -> TokenStream {
@@ -94,9 +82,9 @@ pub fn derive_css_hash(input: TokenStream) -> TokenStream {
 }
 
 /// `#[css(skip)]` on a field (or variant) excludes it from the derived
-/// `eql` / `hash` / `is_compatible` body. Mirrors the Zig pattern where some
-/// struct fields (e.g. `loc: bun.logger.Loc`, `vendor_prefix: VendorPrefix`)
-/// are not part of value identity / browser-compat.
+/// `eql` / `hash` / `is_compatible` body. Used for struct fields (e.g.
+/// `loc`, `vendor_prefix: VendorPrefix`) that are not part of value
+/// identity / browser-compat.
 fn has_css_skip(attrs: &[Attribute]) -> bool {
     for attr in attrs {
         if !attr.path().is_ident("css") {
@@ -227,8 +215,7 @@ fn expand_css_eql(input: &DeriveInput) -> syn::Result<TokenStream2> {
                     }
                 }
             });
-            // Zig: `if (@intFromEnum(this) != @intFromEnum(other)) return false;`
-            // — i.e. mismatched tags are simply unequal.
+            // Mismatched tags are simply unequal.
             quote! {
                 match (self, __other) {
                     #(#arms)*
@@ -288,7 +275,6 @@ fn expand_css_hash(input: &DeriveInput) -> syn::Result<TokenStream2> {
             let arms = e.variants.iter().enumerate().map(|(i, v)| {
                 let vname = &v.ident;
                 let disc = i as u32;
-                // Zig: `bun.writeAnyToHasher(hasher, @intFromEnum(this))`.
                 let tag = quote! { __hasher.update(&(#disc as u32).to_ne_bytes()); };
                 match &v.fields {
                     Fields::Unit => quote! {
@@ -357,11 +343,8 @@ fn expand_css_hash(input: &DeriveInput) -> syn::Result<TokenStream2> {
 // `IsCompatible`
 // ════════════════════════════════════════════════════════════════════════════
 //
-// Port of `isCompatible` in `src/css/generics.zig`. The Zig dispatches via
-// `@hasDecl(T, "isCompatible")` for leaf types, dereferences pointers, and
-// iterates list containers — anything else is a `@compileError`. The trait
-// blanket impls in `bun_css::generics` cover refs/containers; this derive
-// handles the *compound* shapes the Zig leaves to per-type `isCompatible`
+// The trait blanket impls in `bun_css::generics` cover refs/containers; this
+// derive handles the *compound* shapes that need per-type `is_compatible`
 // methods:
 //
 //   * structs → AND of every (non-`#[css(skip)]`) field's `.is_compatible(b)`
@@ -590,19 +573,8 @@ fn expand_deep_clone(input: &DeriveInput) -> syn::Result<TokenStream2> {
 // `DefineEnumProperty` / `DeriveParse` / `DeriveToCss`
 // ════════════════════════════════════════════════════════════════════════════
 //
-// Port of `src/css/css_parser.zig`:
-//
-//   pub fn DefineEnumProperty(comptime T: type) type {
-//       const fields = std.meta.fields(T);
-//       return struct {
-//           pub fn parse(input)  → expectIdent → eqlCaseInsensitiveASCII vs field.name
-//           pub fn toCss(this)   → dest.writeStr(@tagName(this.*))
-//           pub fn eql / hash / deepClone …
-//       };
-//   }
-//
-// Zig's `@tagName` yields the literal field identifier (`@"table-row-group"`),
-// so the CSS keyword is encoded directly in the variant name. Rust variant
+// `DefineEnumProperty`: for a unit-only enum, the CSS keyword is encoded
+// in the variant name. Rust variant
 // names are PascalCase, so the derive maps `TableRowGroup → "table-row-group"`
 // by default and accepts an explicit `#[css(name = "…")]` / `#[css("…")]`
 // override where the kebab-case mapping doesn't round-trip (e.g.
@@ -612,14 +584,12 @@ fn expand_deep_clone(input: &DeriveInput) -> syn::Result<TokenStream2> {
 //   * `impl From<T> for &'static str` — satisfies `EnumProperty: Into<&'static str>`
 //   * `impl bun_css::EnumProperty for T { fn from_ascii_case_insensitive }`
 //   * inherent `T::as_str` / `T::parse` / `T::to_css` so call-sites needn't
-//     import the trait (mirrors Zig's `pub const parse = css_impl.parse;`)
+//     import the trait
 //
-// `Parse` / `ToCss` (port of Zig's `DeriveParse` / `DeriveToCss`) handle
-// `union(enum)`-shaped Rust enums: unit variants serialize as keywords,
-// single-payload tuple variants delegate to the payload's own
-// `parse` / `to_css`. Ordering follows the Zig `generateCode` contract: void
-// and payload variants must each be contiguous; whichever group is declared
-// first is attempted first.
+// `Parse` / `ToCss` handle payload-carrying enums: unit variants serialize as
+// keywords, single-payload tuple variants delegate to the payload's own
+// `parse` / `to_css`. Void and payload variants must each be contiguous;
+// whichever group is declared first is attempted first.
 
 /// Convert a Rust `PascalCase` identifier to a CSS kebab-case keyword.
 /// `TableRowGroup` → `table-row-group`, `RunIn` → `run-in`, `Nowrap` → `nowrap`.
@@ -779,7 +749,7 @@ fn expand_enum_property(input: &DeriveInput) -> syn::Result<TokenStream2> {
         #[automatically_derived]
         #[allow(dead_code)]
         impl #name {
-            /// CSS keyword for this variant (Zig: `@tagName`).
+            /// CSS keyword for this variant.
             #[inline]
             pub const fn as_str(&self) -> &'static str {
                 match *self { #(#to_str_arms)* }
@@ -831,9 +801,8 @@ enum VariantShape<'a> {
         ident: &'a syn::Ident,
         ty: &'a syn::Type,
     },
-    /// `Foo { f1, f2, … }` — inline struct payload. Direct Rust analogue of the
-    /// Zig `union(enum)` arm carrying an anonymous `struct { … __generateToCss }`;
-    /// the printer is the field sequence (see [`gen_field_seq_to_css`]).
+    /// `Foo { f1, f2, … }` — inline struct payload; the printer is the field
+    /// sequence (see [`gen_field_seq_to_css`]).
     NamedFields {
         ident: &'a syn::Ident,
         fields: &'a syn::FieldsNamed,
@@ -895,8 +864,8 @@ fn has_css_flag(attrs: &[Attribute], flag: &str) -> bool {
 /// Emit the `__generateToCss` field-sequence body shared by the struct branch
 /// and named-field enum variants: each field is `to_css`'d in declaration
 /// order, `Option<_>` fields are unwrapped, and a single space is written
-/// between fields (unconditionally — matching the Zig, which does not elide the
-/// separator when an optional field is `None`).
+/// between fields (unconditionally — the separator is not elided when an
+/// optional field is `None`).
 ///
 /// `access` maps a field ident to the expression that reads it (`self.f` for
 /// a struct, the binding name for a destructured enum variant).
@@ -930,7 +899,7 @@ fn gen_field_seq_to_css<'a>(
 
 /// `true` when `ty` is spelled `Option<…>` (any path ending in `Option` with one
 /// generic argument). Used by the struct branch of `expand_derive_to_css` to
-/// mirror Zig's `@typeInfo(field.type) == .optional` unwrap.
+/// unwrap optional fields.
 fn is_option_type(ty: &syn::Type) -> bool {
     let syn::Type::Path(tp) = ty else {
         return false;
@@ -957,16 +926,11 @@ fn expand_derive_to_css(input: &DeriveInput) -> syn::Result<TokenStream2> {
 
     let body = match &input.data {
         // ── Struct branch ──────────────────────────────────────────────────
-        // Port of the `__generateToCss` auto-serializer in Zig's
-        // `DeriveToCss` (`src/css/css_parser.zig:821-843`): for a payload
-        // struct whose Zig original carried `pub fn __generateToCss() void {}`,
-        // the printer is the field sequence, space-separated, with optionals
-        // unwrapped (and the inter-field space emitted unconditionally — that
-        // is what the Zig does, so we do not second-guess it here).
+        // Auto-serializer for a payload struct: the printer is the field
+        // sequence, space-separated, with optionals unwrapped (and the
+        // inter-field space emitted unconditionally).
         //
-        // The Zig dispatched this from inside the *enum*'s `toCss` via
-        // `@typeInfo` reflection on the payload type. Rust proc-macros cannot
-        // see through a type name, so the equivalent is deriving `ToCss`
+        // Proc-macros cannot see through a type name, so `ToCss` is derived
         // directly on the payload struct; the enum arm's
         // `__inner.to_css(__dest)` then resolves to this generated impl.
         Data::Struct(s) => {
@@ -978,8 +942,8 @@ fn expand_derive_to_css(input: &DeriveInput) -> syn::Result<TokenStream2> {
                 ));
             };
             // `#[css(generate_to_css)]` is accepted (and recommended) as an
-            // explicit opt-in marker mirroring Zig's `pub fn __generateToCss()`,
-            // but the behaviour is identical with or without it — deriving
+            // explicit opt-in marker, but the behaviour is identical with or
+            // without it — deriving
             // `ToCss` on a named-field struct always emits the field-sequence
             // printer. The flag exists so the port can record intent at the
             // declaration site without a doc-comment.
@@ -995,10 +959,10 @@ fn expand_derive_to_css(input: &DeriveInput) -> syn::Result<TokenStream2> {
                     quote! { #name::#ident => __dest.write_str(#kw), }
                 }
                 VariantShape::Payload { ident, .. } => {
-                    // The payload type is opaque to a proc-macro, so we delegate. If
-                    // the payload is a ported "anonymous struct" (Zig
-                    // `__generateToCss`), give it `#[derive(ToCss)]` — the struct
-                    // branch above generates the matching field-sequence printer.
+                    // The payload type is opaque to a proc-macro, so we delegate.
+                    // If the payload is a field-sequence struct, give it
+                    // `#[derive(ToCss)]` — the struct branch above generates the
+                    // matching printer.
                     quote! { #name::#ident(__inner) => __inner.to_css(__dest), }
                 }
                 VariantShape::NamedFields { ident, fields } => {
@@ -1073,10 +1037,9 @@ fn expand_derive_parse(input: &DeriveInput) -> syn::Result<TokenStream2> {
     let shapes = classify(data)?;
     let (_, ty_g, _) = input.generics.split_for_impl();
 
-    // Zig `DeriveParse` requires void variants and payload variants to each be
-    // contiguous, and tries them in declaration-block order. We honour the same
-    // contract: split into the two contiguous groups and emit whichever is
-    // declared first, first.
+    // Void variants and payload variants must each be contiguous, and are
+    // tried in declaration-block order: split into the two contiguous groups
+    // and emit whichever is declared first, first.
     let mut units: Vec<(&syn::Ident, String)> = Vec::new();
     let mut payloads: Vec<(&syn::Ident, &syn::Type)> = Vec::new();
     let units_first = matches!(shapes.first(), Some(VariantShape::Unit { .. }));
@@ -1085,12 +1048,10 @@ fn expand_derive_parse(input: &DeriveInput) -> syn::Result<TokenStream2> {
             VariantShape::Unit { ident, keyword } => units.push((ident, keyword.clone())),
             VariantShape::Payload { ident, ty } => payloads.push((ident, ty)),
             VariantShape::NamedFields { ident, .. } => {
-                // Zig `DeriveParse` only dispatches on void variants and
-                // payload types that themselves expose `parse`; the inline
-                // `__generateToCss` structs in align.zig each hand-write
-                // `parse`. The Rust port lifts those into named structs with a
-                // `parse` inherent and wraps them in a single-field tuple
-                // variant, so this arm is unreachable for any faithful port.
+                // The derive only dispatches on void variants and payload
+                // types that themselves expose `parse`; inline named-field
+                // payloads are lifted into named structs with a `parse`
+                // inherent and wrapped in a single-field tuple variant.
                 return Err(syn::Error::new_spanned(
                     ident,
                     "#[derive(Parse)] does not support named-field variants; lift the \
@@ -1104,8 +1065,7 @@ fn expand_derive_parse(input: &DeriveInput) -> syn::Result<TokenStream2> {
     // Build the unit-variant matcher as a closure body. When this is the *last*
     // attempted group it is invoked directly (its error propagates); when a
     // payload group follows, it is wrapped in `try_parse` so the cursor rewinds
-    // on no-match (Zig: `input.tryParse(Parser.expectIdent, .{})` then
-    // `input.reset(&state)`).
+    // on no-match.
     let unit_matcher = {
         let arms = units.iter().map(|(ident, kw)| {
             let kw = syn::LitByteStr::new(kw.as_bytes(), ident.span());
@@ -1132,8 +1092,8 @@ fn expand_derive_parse(input: &DeriveInput) -> syn::Result<TokenStream2> {
     };
 
     // Payload block builder. `terminal` controls whether the *last* payload
-    // propagates its error (Zig: `i == last_payload_index && last > void_index`)
-    // or is `try_parse`d like the others so a following unit block can run.
+    // propagates its error or is `try_parse`d like the others so a following
+    // unit block can run.
     let payload_block = |terminal: bool| -> TokenStream2 {
         if payloads.is_empty() {
             return quote! {};
@@ -1196,7 +1156,7 @@ fn expand_derive_parse(input: &DeriveInput) -> syn::Result<TokenStream2> {
     // Emit the body in the **trait** impl so `css::generic::parse[_with_options]`
     // (bounded on `T: generics::Parse[WithOptions]`) resolves. An inherent
     // `parse` is kept as a thin forwarder for call sites that don't import the
-    // trait. `ParseWithOptions` ignores options (Zig fallthrough) — types that
+    // trait. `ParseWithOptions` ignores options — types that
     // genuinely consume options hand-write their own impl instead of deriving.
     let bounded = with_trait_bounds(input, &quote!(::bun_css::generics::Parse));
     let (b_impl_g, _, b_where_g) = bounded.split_for_impl();
diff --git a/src/css_jsc/color_js.rs b/src/css_jsc/color_js.rs
index 23a982a57d3..f38fa8c9206 100644
--- a/src/css_jsc/color_js.rs
+++ b/src/css_jsc/color_js.rs
@@ -16,16 +16,16 @@ pub(crate) enum OutputColorFormat {
     Ansi256,
     Css,
     Hex,
-    HexUpper, // Zig: `HEX`
+    HexUpper,
     Hsl,
     Lab,
     Number,
     Rgb,
     Rgba,
-    RgbArray,   // Zig: `@"[rgb]"`
-    RgbaArray,  // Zig: `@"[rgba]"`
-    RgbObject,  // Zig: `@"{rgb}"`
-    RgbaObject, // Zig: `@"{rgba}"`
+    RgbArray,
+    RgbaArray,
+    RgbObject,
+    RgbaObject,
 }
 
 impl bun_jsc::FromJsEnum for OutputColorFormat {
@@ -164,8 +164,8 @@ pub mod ansi256 {
 
     pub(crate) type Buffer = [u8; 24];
 
-    /// Zig signature took `RGBA`; here we take the channels directly so the
-    /// pure escape-sequence builder doesn't depend on `bun_css::values::color`.
+    /// Takes the channels directly so the pure escape-sequence builder
+    /// doesn't depend on `bun_css::values::color`.
     pub(crate) fn from(red: u8, green: u8, blue: u8, buf: &mut Buffer) -> &[u8] {
         let val = get(red as u32, green as u32, blue as u32);
         // 0x1b is the escape character
@@ -221,7 +221,7 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
     let parsed_color: css::CssColorParseResult = 'brk: {
         if args[0].is_number() {
             let number: i64 = args[0].to_int64();
-            // Zig: packed struct(u32) { blue: u8, green: u8, red: u8, alpha: u8 }
+            // u32 bit layout, LSB-first: blue, green, red, alpha (one byte each).
             let int: u32 = number.rem_euclid(u32::MAX as i64).unsigned_abs() as u32;
             let blue = (int & 0xff) as u8;
             let green = ((int >> 8) & 0xff) as u8;
@@ -307,8 +307,8 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
 
         input = args[0].to_slice(global)?;
 
-        // Zig used ArenaAllocator + stackFallback(4096) (free init); MimallocArena::new()
-        // calls mi_heap_new(), so defer creation to the paths that actually allocate.
+        // MimallocArena::new() calls mi_heap_new(), so defer creation to the
+        // paths that actually allocate.
         let arena = Arena::new();
         let mut parser_input = css::ParserInput::new(input.slice(), &arena);
         let mut parser = css::Parser::new(
@@ -326,10 +326,14 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
                 return Ok(JSValue::NULL);
             }
 
-            // TODO(port): Zig used `@tagName(err.basic().kind)`; `BasicParseErrorKind`
-            // currently lacks `IntoStaticStr` in bun_css — falls back to Display until
-            // the derive lands.
-            return Err(global.throw(format_args!("color() failed to parse {}", err.basic().kind)));
+            let kind_name = match err.basic().kind {
+                css::BasicParseErrorKind::unexpected_token(_) => "unexpected_token",
+                css::BasicParseErrorKind::end_of_input => "end_of_input",
+                css::BasicParseErrorKind::at_rule_invalid(_) => "at_rule_invalid",
+                css::BasicParseErrorKind::at_rule_body_invalid => "at_rule_body_invalid",
+                css::BasicParseErrorKind::qualified_rule_invalid => "qualified_rule_invalid",
+            };
+            return Err(global.throw(format_args!("color() failed to parse {}", kind_name)));
         }
         Ok(result) => {
             let format: OutputColorFormat = if unresolved_format == OutputColorFormat::Ansi {
@@ -368,14 +372,10 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
                             let srgba: SRGB = match &result {
                                 CssColor::Float(float) => match &**float {
                                     css::FloatColor::Rgb(rgb) => *rgb,
-                                    // TODO(port): inline else over FloatColor variants → trait `IntoColor<SRGB>`
                                     other => other.into_srgb(),
                                 },
                                 CssColor::Rgba(rgba) => rgba.into_srgb(),
-                                CssColor::Lab(lab) => {
-                                    // TODO(port): inline else over LabColor variants → trait `IntoColor<SRGB>`
-                                    lab.into_srgb()
-                                }
+                                CssColor::Lab(lab) => lab.into_srgb(),
                                 _ => break 'formatted,
                             };
                             let rgba = srgba.into_rgba();
@@ -541,14 +541,10 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
                             let hsl: HSL = match &result {
                                 CssColor::Float(float) => match &**float {
                                     css::FloatColor::Hsl(hsl) => *hsl,
-                                    // TODO(port): inline else over FloatColor variants → trait `IntoColor<HSL>`
                                     other => other.into_hsl(),
                                 },
                                 CssColor::Rgba(rgba) => rgba.into_hsl(),
-                                CssColor::Lab(lab) => {
-                                    // TODO(port): inline else over LabColor variants → trait `IntoColor<HSL>`
-                                    lab.into_hsl()
-                                }
+                                CssColor::Lab(lab) => lab.into_hsl(),
                                 _ => break 'formatted,
                             };
 
@@ -559,13 +555,9 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
                         }
                         OutputColorFormat::Lab => {
                             let lab: LAB = match &result {
-                                CssColor::Float(float) => {
-                                    // TODO(port): inline else over FloatColor variants → trait `IntoColor<LAB>`
-                                    float.into_lab()
-                                }
+                                CssColor::Float(float) => float.into_lab(),
                                 CssColor::Lab(lab) => match &**lab {
                                     css::LabColor::Lab(lab_) => *lab_,
-                                    // TODO(port): inline else over LabColor variants → trait `IntoColor<LAB>`
                                     other => other.into_lab(),
                                 },
                                 CssColor::Rgba(rgba) => rgba.into_lab(),
@@ -588,7 +580,6 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
             let mut dest: Vec<u8> = Vec::new();
 
             let symbols = SymbolMap::init_list(Default::default());
-            // TODO(port): css::Printer::new signature — Zig passes (allocator, ArrayList, writer, opts, null, null, &symbols)
             let mut printer = css::Printer::new(
                 &arena,
                 bun_alloc::ArenaVec::<u8>::new_in(&arena),
@@ -608,5 +599,3 @@ pub fn js_function_color(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
         }
     }
 }
-
-// ported from: src/css_jsc/color_js.zig
diff --git a/src/css_jsc/css_internals.rs b/src/css_jsc/css_internals.rs
index 0b81579ae03..2cf9edafb1b 100644
--- a/src/css_jsc/css_internals.rs
+++ b/src/css_jsc/css_internals.rs
@@ -6,9 +6,8 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue};
 
 use crate::JsResult;
 
-// PORTING.md §Dispatch: Zig used `comptime test_kind: enum {...}` — Rust
-// `adt_const_params` is unstable, so the enum is passed as a runtime value
-// (the bodies branch on it anyway; no codegen difference for this fn).
+// `adt_const_params` is unstable, so the test kind is passed as a runtime
+// value (the bodies branch on it anyway; no codegen difference for this fn).
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub(crate) enum TestKind {
     Normal,
@@ -24,9 +23,9 @@ pub(crate) enum TestCategory {
     ParserOptions,
 }
 
-// `#[bun_jsc::host_fn]` proc-macro not yet available; wrappers are plain fns
-// for now and re-gain the attribute when bun_jsc::host_fn lands.
-// TODO(port): bun_jsc::host_fn (proc-macro attribute)
+// These test-only wrappers are consumed as plain safe fns through
+// `dispatch_js2native.rs` re-exports, so they don't use the
+// `#[bun_jsc::host_fn]` C-ABI shim.
 
 pub fn minify_error_test_with_options(
     global: &JSGlobalObject,
@@ -99,11 +98,11 @@ pub(crate) fn testing_impl(
     use bun_jsc::{LogJsc as _, StringJsc as _};
 
     let arena = Arena::new();
-    // PERF(port): was arena bulk-free — CSS parser allocates into this bump
+    // The CSS parser allocates into this bump arena; freed when it drops.
     //
     // SAFETY: `StyleSheet::parse` requires `&'static Bump` / `ParserOptions<'static>`
-    // because the rule tree stores lifetime-erased refs (see css_parser.rs PORT
-    // NOTE on `'bump` threading). The arena strictly outlives every value parsed
+    // because the rule tree stores lifetime-erased refs (see the css_parser.rs
+    // notes on `'bump` threading). The arena strictly outlives every value parsed
     // out of it below.
     let alloc: &'static Arena = unsafe { bun_ptr::detach_lifetime_ref(&arena) };
 
@@ -240,7 +239,7 @@ fn parser_options_from_js(
         if val.is_array() {
             let mut iter = val.array_iterator(global)?;
             while let Some(item) = iter.next()? {
-                // Zig: `defer bunstr.deref()` — release the +1 ref each iteration.
+                // `OwnedString` releases the +1 ref at the end of each iteration.
                 let bunstr = OwnedString::new(item.to_bun_string(global)?);
                 let str = bunstr.to_utf8();
                 if str.slice() == b"DEEP_SELECTOR_COMBINATOR" {
@@ -274,9 +273,8 @@ fn parser_options_from_js(
 fn targets_from_js(global: &JSGlobalObject, jsobj: JSValue) -> JsResult<Browsers> {
     let mut targets = Browsers::default();
 
-    // Zig spec (css_internals.zig:188-256) unrolls this 9×; collapse to a
-    // table-driven loop. Key order preserved so JS getter/exception ordering
-    // matches the spec exactly.
+    // Table-driven loop. Key order matters: it determines JS getter/exception
+    // ordering.
     for (key, slot) in [
         ("android", &mut targets.android),
         ("chrome", &mut targets.chrome),
@@ -291,7 +289,7 @@ fn targets_from_js(global: &JSGlobalObject, jsobj: JSValue) -> JsResult<Browsers
         if let Some(val) = jsobj.get_truthy(global, key)? {
             if val.is_int32() {
                 if let Some(value) = val.get_number() {
-                    // note: Rust `as` saturates on overflow/NaN where Zig is UB
+                    // `as` saturates on overflow/NaN
                     *slot = Some(value as u32);
                 }
             }
@@ -309,12 +307,12 @@ pub fn attr_test(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue
     use bun_jsc::{LogJsc as _, StringJsc as _};
 
     let arena = Arena::new();
-    // PERF(port): was arena bulk-free — StyleAttribute::parse allocates its
+    // StyleAttribute::parse allocates its
     // AST into this bump; freed when `arena` drops at end of scope.
     //
     // SAFETY: `StyleAttribute` stores `DeclarationBlock<'static>` (lifetime
-    // erased crate-wide until 'bump threads through the rule tree — see
-    // css_parser.rs PORT NOTE). The arena strictly outlives the parsed
+    // erased crate-wide until 'bump threads through the rule tree — see the
+    // css_parser.rs notes). The arena strictly outlives the parsed
     // `stylesheet` below.
     let alloc: &'static Arena = unsafe { bun_ptr::detach_lifetime_ref(&arena) };
 
@@ -373,8 +371,7 @@ pub fn attr_test(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue
             ) {
                 Ok(r) => r,
                 Err(_e) => {
-                    // Zig: bun.handleErrorReturnTrace(e, @errorReturnTrace()); return .js_undefined;
-                    // TODO(port): handleErrorReturnTrace — debug-only error trace dump; no Rust equivalent yet
+                    // The error is intentionally swallowed here.
                     return Ok(JSValue::UNDEFINED);
                 }
             };
@@ -389,5 +386,3 @@ pub fn attr_test(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue
         }
     }
 }
-
-// ported from: src/css_jsc/css_internals.zig
diff --git a/src/css_jsc/error_jsc.rs b/src/css_jsc/error_jsc.rs
index 16f2dac19a4..09e85ff7050 100644
--- a/src/css_jsc/error_jsc.rs
+++ b/src/css_jsc/error_jsc.rs
@@ -7,13 +7,13 @@ use bun_core::String as BunString;
 use bun_jsc::{JSGlobalObject, JSValue};
 
 /// `this` is `&css::Err<T>` for any `T`; only `.kind` is accessed.
-// Zig `!JSValue` (inferred set) — only fallible call is `create_format` (OOM), so AllocError.
+// Only fallible call is `create_format` (OOM), so AllocError.
 pub(crate) fn to_error_instance<T>(
     this: &bun_css::Err<T>,
     global_this: &JSGlobalObject,
 ) -> Result<JSValue, AllocError>
 where
-    // The Zig formats `this.kind` with `{f}`; in Rust the kind type must be `Display`.
+    // `this.kind` is formatted, so the kind type must be `Display`.
     T: Display,
 {
     let str = BunString::create_format(format_args!("{}", this.kind));
@@ -23,5 +23,3 @@ where
     let js = bun_jsc::bun_string_jsc::to_error_instance(&str, global_this);
     Ok(js)
 }
-
-// ported from: src/css_jsc/error_jsc.zig
diff --git a/src/dispatch/lib.rs b/src/dispatch/lib.rs
index 6add8fcec16..5072eb77718 100644
--- a/src/dispatch/lib.rs
+++ b/src/dispatch/lib.rs
@@ -4,8 +4,7 @@
 //! higher-tier crates, without a vtable. Dispatch is `match kind { … }` over
 //! per-variant `extern "Rust"` direct calls; under `-Clinker-plugin-lto` the
 //! whole thing inlines to the same code an in-crate enum would. Think
-//! `enum_dispatch` where the impls don't have to be in the declaring crate —
-//! the cross-crate Rust spelling of Zig's `union(enum)` switch.
+//! `enum_dispatch` where the impls don't have to be in the declaring crate.
 //!
 //! `link_interface!` in the low-tier crate emits the handle type **and** a
 //! `link_impl_<Iface>!` macro (re-exported at that crate's root) which the
diff --git a/src/dns/lib.rs b/src/dns/lib.rs
index 227e0c6e6a1..02b79ef172e 100644
--- a/src/dns/lib.rs
+++ b/src/dns/lib.rs
@@ -5,9 +5,8 @@ use std::io::Write as _;
 
 use bun_alloc::AllocError;
 use bun_core::String as BunString;
-// Zig used `std.hash.Wyhash`; bun_wyhash exports `Wyhash11` (same iterative
-// init/update/final_ surface). Hash is in-memory dedupe only — algorithm
-// identity is not load-bearing.
+// `bun_wyhash` exports `Wyhash11` (iterative init/update/final_ surface).
+// Hash is in-memory dedupe only — algorithm identity is not load-bearing.
 use bun_wyhash::Wyhash11 as Wyhash;
 
 // `libc` does not expose winsock types/constants on Windows; route every
@@ -30,8 +29,8 @@ mod sock {
     pub use bun_windows_sys::ws2_32::{addrinfo, freeaddrinfo};
     // Windows SDK ships <afunix.h> (SOCKADDR_UN) since win10_rs4 but neither
     // windows-sys nor bun_windows_sys export it. Mirror the on-the-wire layout
-    // here so address_to_string stays cfg-free below — matches Zig std's
-    // `std.os.windows.ws2_32.sockaddr_un { family: u16, path: [108]u8 }`.
+    // (`{ family: u16, path: [108]u8 }`) here so address_to_string stays
+    // cfg-free below.
     #[repr(C)]
     pub(crate) struct sockaddr_un {
         pub sun_family: u16,
@@ -95,11 +94,10 @@ impl GetAddrInfo {
     }
 }
 
-// TODO(port): Zig is `packed struct(u64)` — bit layout: family:2, socktype:2,
-// protocol:2, backend:2, flags:32 (std.c.AI), _:24. Represented here as a plain
-// struct because every use site reads fields by name; only `hash()` cared about
-// the raw bytes (handled via `to_packed_bytes`). Decide if a true
-// `#[repr(transparent)] u64` newtype is needed.
+// Hashed as a packed u64 — bit layout: family:2, socktype:2, protocol:2,
+// backend:2, flags:32 (AI_*), _:24. Represented here as a plain struct
+// because every use site reads fields by name; only `hash()` cares about
+// the raw bytes, which `to_packed_bytes` reconstructs in that exact layout.
 #[derive(Clone, Copy)]
 pub struct Options {
     pub family: Family,
@@ -111,7 +109,7 @@ pub struct Options {
     pub socktype: SocketType,
     pub protocol: Protocol,
     pub backend: Backend,
-    pub flags: c_int, // std.c.AI packed flags
+    pub flags: c_int, // AI_* packed flags
 }
 
 impl Default for Options {
@@ -145,7 +143,7 @@ impl Options {
         Some(hints)
     }
 
-    /// Reconstructs the Zig `packed struct(u64)` byte layout for hashing.
+    /// Reconstructs the packed u64 byte layout for hashing.
     fn to_packed_bytes(self) -> [u8; 8] {
         let low: u8 = (self.family as u8 & 0b11)
             | ((self.socktype as u8 & 0b11) << 2)
@@ -159,24 +157,16 @@ impl Options {
     }
 }
 
-// TODO(port): FromJSError types are only consumed by the *_jsc extension fns;
-// consider moving these to bun_runtime::dns_jsc.
-// TODO(port): thiserror not in deps — dropped Error derive
+// Only consumed by the *_jsc extension fns; messages come from
+// `strum::IntoStaticStr` (variant name == message).
 #[derive(Debug, strum::IntoStaticStr)]
 pub enum OptionsFromJsError {
-    //     #[error("InvalidFamily")]
     InvalidFamily,
-    //     #[error("InvalidSocketType")]
     InvalidSocketType,
-    //     #[error("InvalidProtocol")]
     InvalidProtocol,
-    //     #[error("InvalidBackend")]
     InvalidBackend,
-    //     #[error("InvalidFlags")]
     InvalidFlags,
-    //     #[error("InvalidOptions")]
     InvalidOptions,
-    //     #[error("JSError")]
     JSError,
 }
 
@@ -339,7 +329,6 @@ impl GetAddrInfoResult {
             // SAFETY: addr is non-null, points into the getaddrinfo result chain
             let a = unsafe { &*addr };
             if let Some(r) = Self::from_addr_info(a) {
-                // PERF(port): was assume_capacity
                 list.push(r);
             }
             addr = a.ai_next;
@@ -367,7 +356,7 @@ impl GetAddrInfoResult {
 }
 
 pub fn address_to_string(address: &Address) -> Result<BunString, AllocError> {
-    // PORT NOTE: reshaped — bun_sys::net::Address exposes family()/as_in4()/
+    // Reshaped — bun_sys::net::Address exposes family()/as_in4()/
     // as_in6() rather than .in/.in6/.un union views.
     match address.family() {
         sock::AF_INET => {
@@ -380,13 +369,10 @@ pub fn address_to_string(address: &Address) -> Result<BunString, AllocError> {
         }
         sock::AF_INET6 => {
             let v6 = address.as_in6().unwrap(); // family() just checked
-            // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
-            // PORT NOTE: Zig formatted via std.net.Address Display ("[addr%scope]:port")
-            // then sliced the brackets/port off ("TODO: this is a hack"). Here we
-            // render the bare address directly via ares_inet_ntop, then re-append
-            // the `%scope_id` suffix that std.net.Ip6Address.format emits for
-            // nonzero scope (e.g. fe80:: link-local from getaddrinfo) — ntop
-            // only sees the 16 raw addr bytes and cannot emit it itself.
+            // Render the bare address directly via ares_inet_ntop, then
+            // re-append the `%scope_id` suffix for nonzero scope (e.g. fe80::
+            // link-local from getaddrinfo) — ntop only sees the 16 raw addr
+            // bytes and cannot emit it itself.
             let mut buf = [0u8; 64]; // >= INET6_ADDRSTRLEN (46) + "%4294967295" (11)
             // SAFETY: sin6_addr is a valid in6_addr; buf len fits INET6_ADDRSTRLEN.
             let n = match unsafe {
@@ -407,8 +393,8 @@ pub fn address_to_string(address: &Address) -> Result<BunString, AllocError> {
             Ok(BunString::clone_latin1(&buf[..len]))
         }
         sock::AF_UNIX => {
-            // Zig spec gates this on `comptime std.net.has_unix_sockets`, which is
-            // true on every target Bun ships (Windows 10 rs4+ included), so no cfg.
+            // Unix sockets exist on every target Bun ships (Windows 10 rs4+
+            // included), so no cfg.
             // SAFETY: family() == AF_UNIX; sockaddr_storage is >= sizeof(sockaddr_un).
             let un = unsafe { &*address.as_sockaddr().cast::<sock::sockaddr_un>() };
             // SAFETY: reinterpreting [c_char; N] as [u8; N] (same size/align).
@@ -436,8 +422,8 @@ pub fn addr_info_count(addrinfo: &sock::addrinfo) -> u32 {
 // ──────────────────────────────────────────────────────────────────────────
 // Order — DNS result ordering (verbatim/ipv4first/ipv6first).
 //
-// Moved down from `bun_runtime::api::dns::Resolver::Order` (src/runtime/
-// dns_jsc/dns.zig): `cli` (repl_command, Arguments)
+// Moved down from `bun_runtime::api::dns::Resolver::Order`: `cli`
+// (repl_command, Arguments)
 // needs `Order::from_string_or_die` to parse `--dns-result-order` before the
 // runtime exists. The `toJS` method stays in tier-6 (`bun_runtime::dns_jsc`)
 // as an extension; only the pure enum + string parsing live here.
@@ -479,7 +465,7 @@ impl Order {
     }
 }
 
-/// Zig: `pub const internal = bun.api.dns.internal;` — the process-wide DNS
+/// The process-wide DNS
 /// cache lives in `bun_runtime` (it owns libinfo/libuv worker threads + JSC
 /// stat counters). Lower-tier crates (`bun_http`, `bun_install`) reach it via
 /// the link-time `Bun__addrinfo_*` family — same mechanism usockets C uses —
@@ -533,5 +519,3 @@ pub mod internal {
         unsafe { Bun__addrinfo_registerQuic(request, pc) }
     }
 }
-
-// ported from: src/dns/dns.zig
diff --git a/src/dotenv/env_loader.rs b/src/dotenv/env_loader.rs
index c6225c7d15f..22ec9a62c56 100644
--- a/src/dotenv/env_loader.rs
+++ b/src/dotenv/env_loader.rs
@@ -26,15 +26,14 @@ pub enum DotEnvFileSuffix {
 pub type Kind = DotEnvFileSuffix;
 pub type Mode = DotEnvFileSuffix;
 
-/// Port of the `*FileSystem.DirEntry` parameter to `Loader::load`
-/// (env_loader.zig). `bun_dotenv` sits below `bun_resolver` in the crate
-/// graph, so the concrete `bun_resolver::fs::DirEntry` is taken generically;
-/// the only operation `load_default_files` performs is `hasComptimeQuery`
-/// (fs.zig:305) — fast O(1) lookup of a known-at-compile-time filename in the
-/// directory's entry map. Implemented for `bun_resolver::fs::DirEntry`.
+/// Directory-entry probe used by `Loader::load`. `bun_dotenv` sits below
+/// `bun_resolver` in the crate graph, so the concrete
+/// `bun_resolver::fs::DirEntry` is taken generically; the only operation
+/// `load_default_files` performs is a fast O(1) lookup of a
+/// known-at-compile-time filename in the directory's entry map. Implemented
+/// for `bun_resolver::fs::DirEntry`.
 pub trait DirEntryProbe {
-    /// Zig: `DirEntry.hasComptimeQuery(comptime query)`. The argument MUST
-    /// already be ASCII-lowercase (Zig lowercases at comptime; fs.zig:305-310).
+    /// The argument MUST already be ASCII-lowercase.
     fn has_comptime_query(&self, query_lower: &'static [u8]) -> bool;
 }
 
@@ -43,7 +42,7 @@ pub trait DirEntryProbe {
 // is provided there — see src/resolver/lib.rs. No impl here; that would be a
 // dep-cycle.
 
-/// schema.peechy / schema.zig:1172 — `enum(u32)`. Canonical definition; re-exported as
+/// schema.peechy — `enum(u32)`. Canonical definition; re-exported as
 /// `bun_options_types::schema::api::DotEnvBehavior` for higher tiers.
 #[repr(u32)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
@@ -68,8 +67,8 @@ impl DotEnvBehavior {
     pub const LoadAll: Self = Self::load_all;
     pub const LoadAllWithoutInlining: Self = Self::load_all_without_inlining;
 
-    /// String-branch classifier shared by `bunfig.zig:988-1018` (serve.env) and
-    /// `JSBundler.zig:603-630` (Bun.build env). Only the *string* arm is common to
+    /// String-branch classifier shared by bunfig (serve.env) and
+    /// JSBundler (Bun.build env). Only the *string* arm is common to
     /// both specs — the surrounding null/bool/number dispatch and the error
     /// reporting intentionally diverge per call site, so they stay inline there.
     ///
@@ -98,7 +97,6 @@ impl DotEnvBehavior {
 /// this T2 crate names no `bun_s3_signing` types — see PORTING.md §Dispatch (cold-path,
 /// upward dep). The high-tier caller constructs the real refcounted `S3Credentials` from
 /// this POD at the call site.
-// TODO(port): once bun_s3_signing TYPE_ONLY move-down lands ≤T2, re-export that struct here.
 #[derive(Clone, Default)]
 pub struct S3Credentials {
     pub access_key_id: Box<[u8]>,
@@ -135,21 +133,18 @@ pub struct Loader<'a> {
     aws_credentials: Option<S3Credentials>,
 }
 
-// Module-level mutable statics from the Zig (`var` decls inside `Loader`).
 static DID_LOAD_CCACHE_PATH: AtomicBool = AtomicBool::new(false);
-// Zig: `var node_path_to_use_set_once: []const u8 = ""` — overwritten on every
-// `loadNodeJSConfig` call (env_loader.zig:344). NOT set-once despite the name,
-// so RwLock<Option> (not OnceLock) — a 2nd call with an override must update the cache.
+// Overwritten on every `load_node_js_config` call. NOT set-once despite the
+// name, so RwLock<Option> (not OnceLock) — a 2nd call with an override must update the cache.
 static NODE_PATH_TO_USE_SET_ONCE: bun_core::RwLock<Option<Box<[u8]>>> = bun_core::RwLock::new(None);
 
-// Zig: `pub var has_no_clear_screen_cli_flag: ?bool = null;`
 // PORTING.md §Concurrency: OnceLock — set once from CLI flag, read many.
 pub static HAS_NO_CLEAR_SCREEN_CLI_FLAG: OnceLock<bool> = OnceLock::new();
 
 impl<'a> Loader<'a> {
     /// Shared "empty-ish" predicate for proxy env vars: an unset/empty value,
     /// or a literal empty-quote pair left over from shell `export FOO=""` /
-    /// `export FOO=''`. Mirrors Zig env_loader.zig getHttpProxy/getNoProxy.
+    /// `export FOO=''`.
     #[inline]
     fn is_emptyish(v: &[u8]) -> bool {
         v.is_empty() || v == b"\"\"" || v == b"''"
@@ -176,13 +171,13 @@ impl<'a> Loader<'a> {
         let Some(value) = self.get(input) else {
             return false;
         };
-        // NOTE: intentionally stricter than `is_emptyish` — also rejects "0"/"false"
-        // per Zig `Loader.has` spec; do not collapse the extra terms.
+        // NOTE: intentionally stricter than `is_emptyish` — also rejects
+        // "0"/"false"; do not collapse the extra terms.
         !Self::is_emptyish(value) && value != b"0" && value != b"false"
     }
 
     /// `BUN_ENV` with fallback to `NODE_ENV` — Bun's env precedence for
-    /// production/test detection. Mirrors Zig `isProduction`/`isTest` lookup.
+    /// production/test detection.
     pub fn get_node_env(&self) -> Option<&[u8]> {
         self.get(b"BUN_ENV").or_else(|| self.get(b"NODE_ENV"))
     }
@@ -239,10 +234,9 @@ impl<'a> Loader<'a> {
 
     pub fn get_s3_credentials(&mut self) -> &S3Credentials {
         if self.aws_credentials.is_none() {
-            // PORT NOTE: reshaped for borrowck — Zig stored borrowed `[]const u8` slices into
-            // the env map; here we copy to `Box<[u8]>` so the cached struct owns its bytes and
-            // we can release the `&self` borrow before writing `&mut self.aws_credentials`.
-            // PERF(port): one-shot, cached — copies are negligible.
+            // Copy to `Box<[u8]>` so the cached struct owns its bytes and we
+            // can release the `&self` borrow before writing `&mut self.aws_credentials`.
+            // One-shot and cached — copies are negligible.
             let access_key_id: Box<[u8]> = self
                 .get(b"S3_ACCESS_KEY_ID")
                 .or_else(|| self.get(b"AWS_ACCESS_KEY_ID"))
@@ -343,11 +337,9 @@ impl<'a> Loader<'a> {
         // `Box<[u8]>`-owned by `*self.map: Map`, which is borrowed for `'a`
         // (`map: &'a mut Map`). The boxed allocations are address-stable
         // across rehashes and Bun never removes/overwrites the proxy env vars
-        // after they are read here, so the slices are valid for `'a`. This is
-        // the same contract Zig `getHttpProxy` (env_loader.zig:174) relies on
-        // by returning `[]const u8` borrowing the loader's map. Encapsulating
-        // the extension here keeps every caller (PackageManager, fetch,
-        // upgrade, create) free of `transmute` (PORTING.md §Forbidden).
+        // after they are read here, so the slices are valid for `'a`.
+        // Encapsulating the extension here keeps every caller (PackageManager,
+        // fetch, upgrade, create) free of `transmute` (PORTING.md §Forbidden).
         let extend = |s: &[u8]| -> &'a [u8] {
             // SAFETY: `s` points into a `Box<[u8]>` owned by `*self.map`, which is
             // borrowed for `'a`; the boxed allocation is address-stable and never
@@ -473,7 +465,7 @@ impl<'a> Loader<'a> {
             Some(p) => p,
             None => return Ok(()),
         };
-        // PORT NOTE: borrowck — `path` borrows `self.map`; `which` writes into `buf` and
+        // borrowck — `path` borrows `self.map`; `which` writes into `buf` and
         // returns a borrow of `buf`. Copy the result before mutating `self.map`.
         let ccache_path: Box<[u8]> = which(&mut buf, path, fs.top_level_dir(), b"ccache")
             .map(|z| Box::<[u8]>::from(z.as_bytes()))
@@ -504,7 +496,7 @@ impl<'a> Loader<'a> {
         Ok(())
     }
 
-    /// Port of `loadNodeJSConfig` (env_loader.zig:332). Populates `NODE` /
+    /// Populates `NODE` /
     /// `npm_node_execpath` with the resolved node binary path. Returns `false`
     /// only when no node could be discovered and no override was supplied.
     pub fn load_node_js_config(
@@ -528,13 +520,11 @@ impl<'a> Loader<'a> {
                 let Some(node) = self.get_node_path(fs, &mut buf) else {
                     return Ok(false);
                 };
-                // PORT NOTE: Zig used `fs.dirname_store.append` (interning arena
-                // returning 'static slice). RwLock owns a Box; just box here.
                 Box::from(node.as_bytes())
             }
         };
-        // Zig order (env_loader.zig:344-346): cache to `node_path_to_use_set_once`
-        // first, then `map.put` (which dupes the bytes).
+        // Cache to `NODE_PATH_TO_USE_SET_ONCE` first, then `map.put` (which
+        // dupes the bytes).
         *NODE_PATH_TO_USE_SET_ONCE.write() = Some(node_path_to_use.clone());
         self.map.put(b"NODE", &node_path_to_use)?;
         self.map.put(b"npm_node_execpath", &node_path_to_use)?;
@@ -647,8 +637,7 @@ impl<'a> Loader<'a> {
         &mut self,
         str: &[u8],
     ) -> Result<(), AllocError> {
-        // PORT NOTE: Zig built a `logger.Source` here; the only field `Parser`
-        // reads is `.contents`, so go straight to `parse_bytes` and avoid the
+        // Go straight to `parse_bytes` to avoid the
         // `Source.contents: &'static [u8]` lifetime constraint (callers like
         // `node:util.parseEnv` pass JS-owned non-'static buffers).
         let mut value_buffer: Vec<u8> = Vec::new();
@@ -662,14 +651,10 @@ impl<'a> Loader<'a> {
         suffix: DotEnvFileSuffix,
         skip_default_env: bool,
     ) -> Result<(), bun_core::Error> {
-        // PERF(port): SUFFIX was `comptime DotEnvFileSuffix` — demoted to runtime arg
-        // (avoids unstable adt_const_params; cold path). Argument order matches the Zig
-        // signature (`dir, env_files, comptime suffix, skip_default_env`) so high-tier
-        // callers (transpiler/install/lockfile) need no shim.
+        // `suffix` is a runtime arg (avoids unstable adt_const_params; cold path).
         let start = bun_core::time::nano_timestamp();
 
         // Create a reusable buffer for parsing multiple files.
-        // PERF(port): Zig used a 4 KiB stack-fallback allocator; plain Vec here.
         let mut value_buffer: Vec<u8> = Vec::new();
 
         if !env_files.is_empty() {
@@ -728,10 +713,9 @@ impl<'a> Loader<'a> {
     ) -> Result<(), bun_core::Error> {
         let dir_handle = bun_sys::Fd::cwd();
 
-        // PORT NOTE: Zig calls `dir.hasComptimeQuery(...)` on a
-        // `*FileSystem.DirEntry` (env_loader.zig). `bun_dotenv` sits below
-        // `bun_resolver` in the crate graph, so the directory entry is taken
-        // generically — `bun_resolver::fs::DirEntry` impls `DirEntryProbe`.
+        // `bun_dotenv` sits below `bun_resolver` in the crate graph, so the
+        // directory entry is taken generically — `bun_resolver::fs::DirEntry`
+        // impls `DirEntryProbe`.
         match suffix {
             DotEnvFileSuffix::Development => {
                 self.try_load_default(dir, dir_handle, b".env.development.local", value_buffer)?
@@ -765,8 +749,7 @@ impl<'a> Loader<'a> {
 
     /// Probe `dir` for a known `.env*` filename and, if present, load it into
     /// its dedicated slot and bump the analytics counter. Shared body for the
-    /// eight unrolled call sites in `load_default_files` (Zig unrolled them for
-    /// `hasComptimeQuery`'s comptime-string requirement, which Rust lacks).
+    /// eight call sites in `load_default_files`.
     #[inline]
     fn try_load_default<D: DirEntryProbe + ?Sized>(
         &mut self,
@@ -834,7 +817,7 @@ impl<'a> Loader<'a> {
             }
         }
 
-        // PORT NOTE: `iterator()` requires `&mut self`; iterate `keys()` slice instead.
+        // `iterator()` requires `&mut self`; iterate `keys()` slice instead.
         for k in self.custom_files_loaded.keys() {
             loaded_i += 1;
             if count == 1 || (loaded_i >= count && count > 1) {
@@ -848,8 +831,7 @@ impl<'a> Loader<'a> {
         Output::flush();
     }
 
-    /// Helper: maps a comptime `.env*` filename to its `Option<Source>` field.
-    /// Replaces Zig `@field(this, base)`.
+    /// Helper: maps a known `.env*` filename to its `Option<Source>` field.
     fn default_file_slot(&mut self, base: &'static [u8]) -> &mut Option<bun_ast::Source> {
         match base {
             b".env.local" => &mut self.env_local,
@@ -874,11 +856,8 @@ impl<'a> Loader<'a> {
             return Ok(());
         }
 
-        // PORT NOTE: Zig used `std.fs.Dir.openFile` whose error set names
-        // (`error.FileNotFound`, `error.FileBusy`, …) don't map 1:1 to errno.
-        // `bun_sys` is errno-based, so the match arms below approximate the Zig
-        // error groups by errno. Any errno not listed propagates (matches the
-        // Zig `else => return err`).
+        // `bun_sys` is errno-based; the match arms below group the recoverable
+        // errnos. Any errno not listed propagates.
         let file =
             match bun_sys::File::openat(dir, base, bun_sys::O::RDONLY | bun_sys::O::CLOEXEC, 0) {
                 Ok(file) => file,
@@ -925,12 +904,10 @@ impl<'a> Loader<'a> {
             }
         }
 
-        // TODO(port): Zig retained the file buffer in `Source.contents`; here we
-        // drop it after parsing because `bun_ast::Source.contents` is
-        // `&'static [u8]` and §Forbidden bans `Box::leak`. The stored `Source`
-        // is only ever checked for `.is_some()` / its path printed, so dropping
-        // the bytes is observationally identical. Revisit once `bun_logger`
-        // grows an owning `contents`.
+        // The file buffer is dropped after parsing because
+        // `bun_ast::Source.contents` is `&'static [u8]` and §Forbidden bans
+        // `Box::leak`. The stored `Source` is only ever checked for
+        // `.is_some()` / its path printed, so dropping the bytes is fine.
         *self.default_file_slot(base) = Some(bun_ast::Source::init_path_string(base, b""));
         Ok(())
     }
@@ -948,7 +925,7 @@ impl<'a> Loader<'a> {
             Ok(f) => f,
             Err(_) => {
                 // prevent retrying
-                // PORT NOTE: `Source::init_path_string` requires a `'static` path; the
+                // `Source::init_path_string` requires a `'static` path; the
                 // map key already carries `file_path` (boxed), and the value is never
                 // read for its path/contents — only `.contains()` and key iteration —
                 // so an empty placeholder is observationally identical.
@@ -974,8 +951,8 @@ impl<'a> Loader<'a> {
             }
         }
 
-        // TODO(port): see `load_env_file` — `Source.contents` not retained
-        // pending the `bun_logger` owning-`Str` rework.
+        // See `load_env_file` — `Source.contents` is not retained; only
+        // `.contains()` / key iteration are ever observed.
         self.custom_files_loaded
             .put(file_path, bun_ast::Source::default())?;
         Ok(())
@@ -985,8 +962,8 @@ impl<'a> Loader<'a> {
 /// Shared post-open tail of `load_env_file` / `load_env_file_dynamic`:
 /// `File::read_to_end` (fstat-presized) with the recoverable-errno filter.
 /// The two callers differ in their open path, open-error handling, and the
-/// memo slot they write — those stay in the callers (see env_loader.zig
-/// :784 vs :874). Only the byte-identical read tail is factored here.
+/// memo slot they write — those stay in the callers. Only the shared read
+/// tail is factored here.
 enum ReadEnvFile {
     /// Zero-length — caller marks the slot and returns.
     Empty,
@@ -1149,7 +1126,7 @@ impl<'a> Parser<'a> {
                         return Ok(Some(self.value_buffer.as_slice()));
                     }
                     self.pos = start;
-                    // PORT NOTE: fallthrough to outer loop's `end += 1` (Zig switch fallthrough)
+                    // fallthrough to outer loop's `end += 1`
                 }
                 _ => {}
             }
@@ -1165,7 +1142,7 @@ impl<'a> Parser<'a> {
         if end >= self.src.len() {
             return Ok(&self.src[self.src.len()..]);
         }
-        // PORT NOTE: reshaped for borrowck — `parse_quoted` returns a borrow of
+        // reshaped for borrowck — `parse_quoted` returns a borrow of
         // `self.value_buffer`; capture only its length, then re-borrow the buffer
         // after the match so the unquoted fallthrough can re-borrow `self`.
         let quoted_len: Option<usize> = match self.src[end] {
@@ -1206,7 +1183,7 @@ impl<'a> Parser<'a> {
         loop {
             if value[pos] == b'$' {
                 if pos > 0 && value[pos - 1] == b'\\' {
-                    // PERF(port): insertSlice(0, ..) is O(n); same as Zig
+                    // PERF: splice at the front is O(n)
                     self.value_buffer
                         .splice(0..0, value[pos..last].iter().copied());
                     pos -= 1;
@@ -1279,7 +1256,7 @@ impl<'a> Parser<'a> {
                 continue;
             };
             let value = self.parse_value::<IS_PROCESS>()?;
-            // PORT NOTE: reshaped for borrowck — value borrows self.value_buffer; copy before map mut.
+            // reshaped for borrowck — value borrows self.value_buffer; copy before map mut.
             let value_owned: Box<[u8]> = Box::from(value);
             let entry = map.map.get_or_put(key)?;
             if entry.found_existing {
@@ -1298,10 +1275,10 @@ impl<'a> Parser<'a> {
             };
         }
         if !IS_PROCESS && EXPAND {
-            // PORT NOTE: borrowck — Zig iterates `map` while calling `map.get` inside expandValue.
-            // Reshaped to index-based iteration: clone the value bytes, run expansion against an
-            // immutable `&Map`, then write back via `values_mut()`. The clone matches the Zig:
-            // values are dupe'd by `_parse` above, so length is bounded by file size.
+            // borrowck — index-based iteration: clone the value bytes, run
+            // expansion against an immutable `&Map`, then write back via
+            // `values_mut()`. Values are dupe'd by `_parse` above, so length
+            // is bounded by file size.
             let total = map.map.count();
             let mut idx = count;
             while idx < total {
@@ -1323,8 +1300,6 @@ impl<'a> Parser<'a> {
     /// Same as [`parse`] but takes the source bytes directly. Exists so
     /// `load_env_file*` can parse a transient `Vec<u8>` without constructing a
     /// `bun_ast::Source` (whose `contents` field is currently `&'static [u8]`).
-    // PORT NOTE: Zig built a `logger.Source` and passed `&source` — the only
-    // field `Parser` reads is `.contents`, so this is observationally identical.
     pub(crate) fn parse_bytes<const OVERRIDE: bool, const IS_PROCESS: bool, const EXPAND: bool>(
         src: &[u8],
         map: &mut Map,
@@ -1347,8 +1322,8 @@ pub type Value = HashTableValue;
 
 #[derive(Default, Clone)]
 pub struct HashTableValue {
-    // TODO(port): Zig stored borrowed `[]const u8`; values are sometimes allocator.dupe'd, sometimes
-    // borrowed from environ. Using Box<[u8]> here for owned-by-default; may want Cow if the copies matter.
+    // `Box<[u8]>` is owned-by-default, trading some copies for uniform
+    // ownership.
     pub value: Box<[u8]>,
     pub conditional: bool,
 }
@@ -1357,7 +1332,6 @@ pub struct HashTableValue {
 // An issue with this exact implementation is unicode characters can technically appear in these
 // keys, and we use a simple toLowercase function that only applies to ascii, so this will make
 // some strings collide.
-// Spec: env_loader.zig:1220 — `bun.CaseInsensitiveASCIIStringArrayHashMap` on Windows.
 #[cfg(not(windows))]
 pub type HashTable = bun_collections::StringArrayHashMap<HashTableValue>;
 #[cfg(windows)]
@@ -1376,7 +1350,6 @@ impl Default for Map {
 impl Map {
     /// Builds a NULL-terminated `K=V\0` envp array. Returns an owning struct so
     /// dropping it frees the joined buffers (PORTING.md §Forbidden: no Box::leak).
-    /// Zig used an arena; here the struct *is* the arena.
     pub fn create_null_delimited_env_map(&mut self) -> Result<NullDelimitedEnvMap, AllocError> {
         let envp_count = self.map.count();
         let mut storage: Vec<Box<[u8]>> = Vec::with_capacity(envp_count);
@@ -1403,11 +1376,10 @@ impl Map {
         })
     }
 
-    /// Returns a wrapper around the std.process.EnvMap that does not duplicate the memory of
+    /// Returns a wrapper around the env map that does not duplicate the memory of
     /// the keys and values, but instead points into the memory of the bun env map.
-    // TODO(refactor): `bun_sys::EnvMap` is `HashMap<String, String>`, which copies and is
-    // UTF-8-lossy. Zig's `std.process.EnvMap` stored `[]const u8` borrows. Replace
-    // `bun_sys::EnvMap` with a `&[u8]`-keyed map and drop the lossy round-trip here.
+    // `bun_sys::EnvMap` is `HashMap<String, String>`, which copies and is
+    // UTF-8-lossy; the lossy round-trip is accepted here.
     #[allow(clippy::disallowed_methods)] // lossy round-trip documented above
     pub fn std_env_map(&mut self) -> Result<StdEnvMapWrapper, AllocError> {
         let mut env_map = bun_sys::EnvMap::default();
@@ -1468,9 +1440,8 @@ impl Map {
     }
 
     /// Shared-borrow iteration over `(key, value)` pairs in insertion order.
-    /// Zig: `pub fn iterator(this: *const Map) HashTable.Iterator` — Zig's
-    /// iterator does not require exclusive access; this is the `&self`
-    /// surface for callers (e.g. shell `EnvMapIter`) that only read entries.
+    /// This is the `&self` surface for callers (e.g. shell `EnvMapIter`) that
+    /// only read entries.
     #[inline]
     pub fn iter(
         &self,
@@ -1479,7 +1450,7 @@ impl Map {
         self.map.iter()
     }
 
-    /// Zig: `this.map.map.unmanaged.entries.len`.
+    /// Number of entries in the env map.
     #[inline]
     pub fn count(&self) -> usize {
         self.map.count()
@@ -1516,7 +1487,6 @@ impl Map {
         {
             debug_assert!(strings::index_of_char(key, b'\x00').is_none());
         }
-        // PERF(port): was assume_capacity
         self.map.put_assume_capacity(
             key,
             HashTableValue {
@@ -1541,16 +1511,14 @@ impl Map {
 
     #[inline]
     pub fn put_alloc_key(&mut self, key: &[u8], value: &[u8]) -> Result<(), AllocError> {
-        // TODO(port): Zig stored borrowed `value` here without dupe; Box<[u8]> forces a copy.
-        // If `HashTableValue.value` ever becomes `Cow`/borrowed storage, re-diverge from
+        // `Box<[u8]>` storage forces a copy, making this equivalent to
         // `put_alloc_key_and_value` (which dupes both key and value).
         self.put_alloc_key_and_value(key, value)
     }
 
     #[inline]
     pub fn put_alloc_value(&mut self, key: &[u8], value: &[u8]) -> Result<(), AllocError> {
-        // Zig diverged from `put` only by `allocator.dupe(value)` vs borrowed; the Rust
-        // `HashTableValue { value: Box<[u8]> }` storage forces a copy either way, so this is
+        // `HashTableValue { value: Box<[u8]> }` storage forces a copy, so this is
         // equivalent to `put`. Kept as a thin wrapper to preserve call-site alloc intent
         // should storage ever change to `Cow`/borrowed.
         self.put(key, value)
@@ -1565,7 +1533,7 @@ impl Map {
     }
 
     pub fn json_stringify(&self, writer: &mut impl core::fmt::Write) -> core::fmt::Result {
-        // PORT NOTE: `iterator()` requires `&mut self`; iterate parallel slices instead.
+        // `iterator()` requires `&mut self`; iterate parallel slices instead.
         let count = self.map.count();
         writer.write_str("{")?;
         for (i, (k, v)) in self
@@ -1605,7 +1573,7 @@ impl Map {
 
     #[inline]
     pub fn get_or_put(&mut self, key: &[u8], value: &[u8]) -> Result<(), AllocError> {
-        // Spec-level alias of `put_default` (env_loader.zig:1393/1400 both call `getOrPutValue`).
+        // Alias of `put_default`.
         self.put_default(key, value)
     }
 
@@ -1621,9 +1589,8 @@ impl Map {
     }
 }
 
-/// Owns the `K=V\0` strings backing a `[*:null]?[*:0]const u8` envp array.
-/// Replaces the Zig arena passed to `createNullDelimitedEnvMap`; dropping this
-/// frees every entry (PORTING.md §Forbidden: no Box::leak).
+/// Owns the `K=V\0` strings backing a NULL-terminated envp array.
+/// Dropping this frees every entry (PORTING.md §Forbidden: no Box::leak).
 ///
 /// LAYOUT NOTE: `envp` stores raw `*const c_char` (with a trailing
 /// `ptr::null()` sentinel), **not** `Option<*const c_char>`. Raw pointers are
@@ -1631,8 +1598,8 @@ impl Map {
 /// 2-word `(tag, ptr)` pair. Casting `*const Option<*const c_char>` to
 /// `*const *const c_char` for `execve()` interleaves `Some`-discriminant
 /// `0x1` words between the real pointers and the kernel faults with `EFAULT`.
-/// Zig's `?[*:0]const u8` *is* a single nullable thin pointer; the Rust
-/// equivalent for FFI is `*const c_char`, not `Option<*const c_char>`.
+/// The correct FFI representation is `*const c_char`, not
+/// `Option<*const c_char>`.
 pub struct NullDelimitedEnvMap {
     _storage: Vec<Box<[u8]>>,
     envp: Box<[*const c_char]>,
@@ -1663,9 +1630,9 @@ impl StdEnvMapWrapper {
 
 // Drop replaces deinit (only frees hash_map storage; Rust does this automatically)
 
-// Zig: `pub var instance: ?*Loader = null;` — global mutable raw pointer, freely re-assignable.
-// PORT NOTE: Loader is !Sync (holds `&mut Map`); same single-thread invariant the Zig had.
-// We store a raw `*mut` in an AtomicPtr (overwritable, matches `pub var` semantics) and hand
+// Global singleton. Loader is !Sync (holds `&mut Map`); it is only installed
+// and used under a single-thread (CLI-init) invariant.
+// We store a raw `*mut` in an AtomicPtr (overwritable) and hand
 // the raw pointer back to callers so the no-alias `&mut` proof obligation lives at the *call
 // site*, not here — manufacturing `&'static mut` inside an accessor is aliased-&mut UB the
 // moment two callers hold results simultaneously (PORTING.md §Forbidden: lifetime-extension
@@ -1673,19 +1640,18 @@ impl StdEnvMapWrapper {
 pub static INSTANCE: AtomicPtr<Loader<'static>> = AtomicPtr::new(core::ptr::null_mut());
 
 /// Read the global singleton as a raw pointer — `Some(ptr)` once `set_instance` has been called.
-/// Callers must `unsafe { &mut *ptr }` at point of use under the same single-thread CLI-init
-/// invariant the Zig `var instance: ?*Loader` had (mirrors raw `*Loader` deref in Zig).
+/// Callers must `unsafe { &mut *ptr }` at point of use under the single-thread
+/// CLI-init invariant: the loader is only installed and dereferenced on the
+/// main thread, so no two `&mut` borrows can be live at once.
 #[inline]
 pub fn instance() -> Option<*mut Loader<'static>> {
     let ptr = INSTANCE.load(Ordering::Acquire);
     if ptr.is_null() { None } else { Some(ptr) }
 }
 
-/// Install the global singleton. Overwrites any previous value (matches Zig `pub var` re-assign
-/// semantics — test harnesses / worker re-init may call this more than once).
+/// Install the global singleton. Overwrites any previous value (test harnesses
+/// / worker re-init may call this more than once).
 #[inline]
 pub fn set_instance(loader: *mut Loader<'static>) {
     INSTANCE.store(loader, Ordering::Release);
 }
-
-// ported from: src/dotenv/env_loader.zig
diff --git a/src/errno/darwin_errno.rs b/src/errno/darwin_errno.rs
index cbc60ddc899..87c532f1d8b 100644
--- a/src/errno/darwin_errno.rs
+++ b/src/errno/darwin_errno.rs
@@ -149,5 +149,3 @@ pub mod uv_e {
 // kernel entry goes through libc, so all widths — including `usize` — route to
 // the thread-local `__error()` slot via the shared macro.
 impl_get_errno_libc!(i32, u32, isize, usize, i64);
-
-// ported from: src/errno/darwin_errno.zig
diff --git a/src/errno/freebsd_errno.rs b/src/errno/freebsd_errno.rs
index 35522f8af04..5d94073ed8f 100644
--- a/src/errno/freebsd_errno.rs
+++ b/src/errno/freebsd_errno.rs
@@ -152,5 +152,3 @@ pub use uv_e as UV_E;
 // `usize`); every kernel entry goes through libc, so all widths route to the
 // thread-local `__error()` slot.
 impl_get_errno_libc!(i32, u32, isize, usize, i64);
-
-// ported from: src/errno/freebsd_errno.zig
diff --git a/src/errno/lib.rs b/src/errno/lib.rs
index 38209edd667..5706e9ce423 100644
--- a/src/errno/lib.rs
+++ b/src/errno/lib.rs
@@ -2,8 +2,8 @@
 #![warn(unused_must_use)]
 
 // Shared by Linux/Darwin/FreeBSD: libc syscall wrappers signal failure with the
-// same-width all-ones sentinel (`-1` signed / `MAX` unsigned — Zig's
-// `@bitCast(...) == -1`) and stash the real errno in a thread-local. Only the
+// same-width all-ones sentinel (`-1` signed / `MAX` unsigned) and stash the
+// real errno in a thread-local. Only the
 // per-OS INVOCATION lists differ: notably Linux keeps a bespoke `usize` impl
 // that decodes raw-syscall `-errno`-in-retval and MUST NOT route through this.
 // Declared before the `mod` lines so textual-order macro visibility reaches them.
@@ -13,7 +13,6 @@ macro_rules! impl_get_errno_libc {
         impl $crate::GetErrno for $t {
             #[inline]
             fn get_errno(self) -> $crate::E {
-                // Zig bitcasts unsigned → SAME-width signed before `== -1`.
                 // `as i64` would zero-extend u32, never matching -1. Compare
                 // against the type's own all-ones value instead (== -1 for
                 // signed, == MAX for unsigned — both are libc's failure rc).
@@ -32,9 +31,8 @@ macro_rules! impl_get_errno_libc {
 //
 // Each per-OS errno module invokes this once with `(IDENT = value => "DISPLAY")`
 // rows. The macro emits BOTH directions:
-//   • forward  : `pub const IDENT: i32 = value;`   (Zig: `UV_E` namespace struct)
+//   • forward  : `pub const IDENT: i32 = value;`
 //   • reverse  : `pub fn name(neg_uv_err) -> Option<&'static str>`
-//                (Zig: hand-written if-chain in node_util_binding.zig:1-98)
 //
 // The reverse map additionally hard-codes the libuv-synthetic codes that are
 // target-INDEPENDENT and have no `uv_e::*` const today (`EOF`, `UNKNOWN`,
@@ -97,15 +95,14 @@ macro_rules! __decl_uv_e {
 // `$id`/`$e`/`$uv` are passed as **literal** tokens (never captured as
 // `:ident`), so the per-OS `$cb` can override individual rows by literal-token
 // match — e.g. `(CHARSET, $e:tt, $uv:tt) => { -::bun_libuv_sys::$uv }` — while
-// a final `($i:tt, $e:tt, $uv:tt)` arm handles the native default. Row order
-// mirrors the original Zig `UV_E` struct (node_util_binding.zig).
+// a final `($i:tt, $e:tt, $uv:tt)` arm handles the native default.
 // ──────────────────────────────────────────────────────────────────────────
 #[macro_export]
 #[doc(hidden)]
 macro_rules! __uv_e_rows {
     ($cb:ident) => {
         $crate::__decl_uv_e! {
-            // Zig `@"2BIG"` — Rust idents can't start with a digit → `_2BIG`.
+            // Rust idents can't start with a digit → `_2BIG`.
             _2BIG          = $cb!(_2BIG,          E2BIG,           UV_E2BIG)           => "E2BIG",
             ACCES          = $cb!(ACCES,          EACCES,          UV_EACCES)          => "EACCES",
             ADDRINUSE      = $cb!(ADDRINUSE,      EADDRINUSE,      UV_EADDRINUSE)      => "EADDRINUSE",
@@ -189,7 +186,7 @@ pub mod freebsd_errno;
 pub use freebsd_errno::*;
 // Android shares the Linux kernel errno space (bionic copies <asm/errno.h>),
 // so it uses the same per-errno enum. Rust splits `target_os` into
-// `linux`/`android` (Zig keeps both as `os.tag == .linux`), so list both.
+// `linux`/`android`, so list both.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub mod linux_errno;
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -200,9 +197,9 @@ pub mod windows_errno;
 pub use windows_errno::{posix, *};
 
 // ──────────────────────────────────────────────────────────────────────────
-// posix — MOVE_DOWN landing for std.posix.{mode_t,E,S} + std.c._errno()
+// posix — mode_t, the errno enum, S_* mode bits, and the C errno accessor
 //
-// Ground truth: Zig `std.posix` / `std.c` re-exports. Landed here so the errno
+// Landed here so the errno
 // crate stays leaf (T0) and bun_sys (T≥1) imports forward. Windows keeps its
 // own divergent `mod posix` in windows_errno.rs (no `errno()` fn, unprefixed
 // `E`); this block is the shared POSIX-target definition.
@@ -217,15 +214,13 @@ pub mod posix {
     #[cfg(any(target_os = "macos", target_os = "freebsd"))]
     pub type mode_t = u16;
 
-    /// Kernel errno enum. Zig's `std.posix.E` and Bun's `SystemErrno` share the
-    /// exact same discriminant space on each POSIX target; alias rather than
-    /// duplicate. Resolves to the per-OS `SystemErrno` via the glob re-export
-    /// above. TODO(port): Zig's `E` uses unprefixed variant names (`PERM`,
-    /// `NOENT`); `SystemErrno` uses `EPERM`, `ENOENT`. Callers matching on
-    /// `E::PERM` must migrate to `E::EPERM` (or this becomes a distinct enum).
+    /// Kernel errno enum. `E` and `SystemErrno` share the exact same
+    /// discriminant space on each POSIX target; alias rather than duplicate.
+    /// Resolves to the per-OS `SystemErrno` via the glob re-export above.
+    /// Variant names are prefixed (`EPERM`, `ENOENT`) — callers spell `E::EPERM`.
     pub type E = crate::SystemErrno;
 
-    /// `stat` mode-flag constants and predicates (Zig: `std.posix.S`).
+    /// `stat` mode-flag constants and predicates.
     /// Values are POSIX-standard octal; identical across linux/darwin/freebsd.
     /// Constants are typed `u32` (== `bun_core::Mode`); on Darwin/FreeBSD the
     /// kernel `mode_t` is u16 so the upper 16 bits are always zero — every call
@@ -233,14 +228,13 @@ pub mod posix {
     /// harmless, and on Linux `mode_t` == `u32` so it's a drop-in re-export.
     pub use bun_core::S;
 
-    /// Read the thread-local libc errno (Zig: `std.c._errno().*`).
+    /// Read the thread-local libc errno.
     /// Canonical impl lives in `bun_core::ffi` (single target_os→symbol ladder).
     pub use bun_core::ffi::errno;
 }
 
-/// Zig's `getErrno(rc: anytype)` switches on `@TypeOf(rc)` to pick the errno
-/// extraction strategy. Rust has no type-switch, so we model it as a trait with
-/// per-type impls — call as `rc.get_errno()` or `get_errno(rc)`.
+/// Errno extraction strategy, modeled as a trait with per-type impls — call
+/// as `rc.get_errno()` or `get_errno(rc)`.
 ///
 /// The trait declaration is target-independent; each per-OS module supplies its
 /// own `impl GetErrno for {i32,u32,isize,usize,...}` (Linux decodes raw-syscall
@@ -250,7 +244,7 @@ pub trait GetErrno: Copy {
     fn get_errno(self) -> E;
 }
 
-// Free-function shim mirroring Zig's `getErrno(rc)` call shape. POSIX-only:
+// Free-function shim over the trait method. POSIX-only:
 // Windows defines its own divergent `get_errno<T>(_rc)` (no trait bound, reads
 // GetLastError/WSAGetLastError) in windows_errno.rs.
 #[cfg(not(windows))]
@@ -259,13 +253,11 @@ pub fn get_errno<T: GetErrno>(rc: T) -> E {
     rc.get_errno()
 }
 
-/// Zig: `SystemError.getErrno` — `@enumFromInt(this.errno * -1)`.
-///
 /// Decode a Node-style **negated** errno (`c_int`, as written by
 /// `Error::to_system_error`) back into an `E`. The input crosses FFI
 /// (BunObject.cpp `SystemError__*`) and is NOT trusted to be a declared
-/// discriminant: Zig `@enumFromInt` is unchecked, but in Rust an out-of-range
-/// `#[repr(u16)]` enum value is immediate UB. Validate via the checked
+/// discriminant: an out-of-range `#[repr(u16)]` enum value is immediate UB.
+/// Validate via the checked
 /// constructor and fall back to `SUCCESS` for unmapped values.
 #[inline]
 pub fn e_from_negated(errno: core::ffi::c_int) -> E {
@@ -284,7 +276,7 @@ pub fn e_from_negated(errno: core::ffi::c_int) -> E {
 }
 
 impl SystemErrno {
-    /// Zig: `@enumFromInt(n)`. Unchecked discriminant cast.
+    /// Unchecked discriminant cast.
     ///
     /// On POSIX the enum is dense `0..MAX`, so we debug-assert `n < MAX`.
     /// On Windows the enum is **sparse** (dense `0..=137` plus isolated `UV_E*`
@@ -297,7 +289,7 @@ impl SystemErrno {
         #[cfg(not(windows))]
         debug_assert!((n as usize) < (Self::MAX as usize));
         // SAFETY: caller guarantees `n` is a declared `#[repr(u16)]` discriminant
-        // of `SystemErrno` (Zig `@enumFromInt` precondition). The enum is NOT
+        // of `SystemErrno`. The enum is NOT
         // contiguous on Windows; do not assume `n < MAX` implies validity there.
         unsafe { core::mem::transmute::<u16, SystemErrno>(n) }
     }
@@ -305,9 +297,7 @@ impl SystemErrno {
 
 #[cfg(not(windows))]
 impl SystemErrno {
-    // TODO(port): Zig `anytype` accepted any integer width (signed or unsigned).
-    // i64 covers every concrete call site (errno-range values); revisit if a
-    // caller passes u64/usize directly.
+    // `i64` covers every concrete call site (errno-range values).
     //
     // Windows defines its own `init<C: SystemErrnoInit>` (typed dispatch over
     // DWORD/c_int/Win32Error) in windows_errno.rs, so this impl is POSIX-only.
@@ -332,10 +322,9 @@ impl bun_core::output::ErrName for SystemErrno {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// system_errno_name — single source of truth for errno → "@tagName"
+// system_errno_name — single source of truth for errno → variant name string
 //
-// Mirrors Zig `@tagName(SystemErrno)` (bun.zig:2841-2851 builds `errno_map`
-// by iterating `std.enums.values(sys.SystemErrno)`). The strum::IntoStaticStr
+// The strum::IntoStaticStr
 // derive on each per-OS `SystemErrno` IS the table; no hand-written `&[&str]`
 // duplicate exists anywhere. bun_core (T0) consumes this through the
 // `ErrnoNames` link-interface below — bun_errno already depends on bun_core,
@@ -356,8 +345,8 @@ pub(crate) fn system_errno_name(errno: i32) -> Option<&'static str> {
     }
     #[cfg(windows)]
     {
-        // Windows libuv errnos arrive negated; abs-normalise like the Zig
-        // `errno_map[@abs(uv_code)]` lookup. `from_repr` (strum::FromRepr)
+        // Windows libuv errnos arrive negated; abs-normalise before the
+        // lookup. `from_repr` (strum::FromRepr)
         // covers BOTH the dense 0..=137 range and the sparse UV_* tags.
         let n = errno.unsigned_abs();
         if n == 0 {
@@ -370,21 +359,41 @@ pub(crate) fn system_errno_name(errno: i32) -> Option<&'static str> {
     }
 }
 
-/// Length of the dense `0..MAX` prefix of `SystemErrno` (i.e. the size Zig's
-/// comptime `errno_map` would have on POSIX, or the dense head on Windows
-/// before the sparse UV_* range). Exposed so bun_core can pre-seed its
+/// Length of the dense `0..MAX` prefix of `SystemErrno` (on Windows, the
+/// dense head before the sparse UV_* range). Exposed so bun_core can pre-seed its
 /// interned `ERRNO_MAP` without a second hand-written per-OS length table.
 #[inline]
 pub(crate) const fn system_errno_max_dense() -> u32 {
     SystemErrno::MAX as u32
 }
 
+/// Raw Win32 `GetLastError()` code → `SystemErrno` tag name, via the
+/// `Win32Error` mapping table. Restores `error.code` fidelity (ENOENT,
+/// EACCES, ...) for `?`-propagated `std::io::Error`s on Windows. Exists on all
+/// platforms because the `ErrnoNames` link-interface is platform-independent;
+/// always `None` off Windows.
+#[inline]
+pub(crate) fn win32_errno_name(code: u32) -> Option<&'static str> {
+    #[cfg(windows)]
+    {
+        let code = u16::try_from(code).ok()?;
+        SystemErrno::init_win32_error(windows_errno::Win32Error::from_raw(code))
+            .map(<&'static str>::from)
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = code;
+        None
+    }
+}
+
 // Wire the above into bun_core's `ErrnoNames` hook. `()` owner — pure
 // stateless functions; the handle is the const `ErrnoNames::SYS`.
 bun_core::link_impl_ErrnoNames! {
     Sys for () => |_this| {
         name(errno) => system_errno_name(errno),
         max_dense() => system_errno_max_dense(),
+        win32_name(code) => win32_errno_name(code),
     }
 }
 
@@ -420,8 +429,7 @@ mod errno_name_tests {
     }
 
     /// Exhaustive: every dense slot in the per-platform enum round-trips through
-    /// `system_errno_name → from_errno → name()` and matches the strum table,
-    /// covering the full Zig `SystemErrno` range.
+    /// `system_errno_name → from_errno → name()` and matches the strum table.
     #[test]
     fn errno_table_full_range() {
         // Slot 0 is the SUCCESS hole.
@@ -435,13 +443,13 @@ mod errno_name_tests {
         #[cfg(not(windows))]
         assert_eq!(Error::from_errno(max as i32), Error::UNEXPECTED);
 
-        // Spot-check the last entry on each platform against the Zig source.
+        // Spot-check the last entry on each platform.
         #[cfg(any(target_os = "linux", target_os = "android", target_family = "wasm"))]
         assert_eq!(system_errno_name(133), Some("EHWPOISON"));
         #[cfg(windows)]
         {
             assert_eq!(system_errno_name(137), Some("EFTYPE"));
-            // Sparse UV_* range round-trips (bun.zig errno_map covers 0..=4096).
+            // Sparse UV_* range round-trips.
             assert_eq!(Error::from_errno(-4058).name(), "UV_ENOENT");
             assert_eq!(Error::from_errno(-4092).name(), "UV_EACCES");
             assert_eq!(Error::from_errno(-4095).name(), "UV_EOF");
@@ -455,6 +463,27 @@ mod errno_name_tests {
         assert_eq!(system_errno_name(97), Some("EINTEGRITY"));
     }
 
+    /// `win32_errno_name` translation contract: known `GetLastError()` codes
+    /// map to POSIX names on Windows, unmapped/out-of-range codes are `None`,
+    /// and the helper is a constant `None` off Windows.
+    #[test]
+    fn win32_errno_names() {
+        #[cfg(windows)]
+        {
+            // ERROR_FILE_NOT_FOUND / ERROR_ACCESS_DENIED.
+            assert_eq!(win32_errno_name(2), Some("ENOENT"));
+            assert_eq!(win32_errno_name(5), Some("EPERM"));
+            // Unmapped Win32 code and the `u16::try_from` overflow fallback.
+            assert_eq!(win32_errno_name(0), None);
+            assert_eq!(win32_errno_name(u32::MAX), None);
+        }
+        #[cfg(not(windows))]
+        {
+            assert_eq!(win32_errno_name(2), None);
+            assert_eq!(win32_errno_name(u32::MAX), None);
+        }
+    }
+
     #[test]
     fn coreutils_map() {
         assert_eq!(
diff --git a/src/errno/linux_errno.rs b/src/errno/linux_errno.rs
index ae4af879062..ad43842a23b 100644
--- a/src/errno/linux_errno.rs
+++ b/src/errno/linux_errno.rs
@@ -151,8 +151,8 @@ impl SystemErrno {
     pub const MAX: u16 = 134;
 
     /// On Linux `EOPNOTSUPP` and `ENOTSUP` share value 95; the enum defines
-    /// only `ENOTSUP`. Provide this alias so cross-platform call sites that
-    /// match Zig's `.OPNOTSUPP` (npm.zig, copy_file) compile against one name.
+    /// only `ENOTSUP`. Provide this alias so cross-platform call sites
+    /// compile against one name.
     pub const EOPNOTSUPP: SystemErrno = SystemErrno::ENOTSUP;
 }
 
@@ -176,12 +176,12 @@ pub mod uv_e {
 
 use super::GetErrno;
 
-// raw system calls from std.os.linux.* will return usize
+// raw Linux syscalls return usize
 // the errno is stored in this value
 impl GetErrno for usize {
     #[inline]
     fn get_errno(self) -> E {
-        // `as` between same-width usize/isize is a bit-reinterpretation (Zig: @bitCast)
+        // `as` between same-width usize/isize is a bit-reinterpretation
         let signed = self as isize;
         let int = if signed > -4096 && signed < 0 {
             -signed
@@ -198,7 +198,4 @@ impl GetErrno for usize {
 //
 // TODO: the inclusion of  'u32' and 'isize' seems suspicious
 impl_get_errno_libc!(i32, u32, isize, i64);
-// c_int == i32 on all our targets; Zig listed both explicitly but Rust impl coherence forbids the duplicate.
-// may need to drop one or cfg-gate it. Zig listed both explicitly.
-
-// ported from: src/errno/linux_errno.zig
+// c_int == i32 on all our targets; impl coherence forbids listing the duplicate.
diff --git a/src/errno/windows_errno.rs b/src/errno/windows_errno.rs
index 6a3f62ac140..252ce56bf16 100644
--- a/src/errno/windows_errno.rs
+++ b/src/errno/windows_errno.rs
@@ -16,8 +16,8 @@ use bun_libuv_sys as uv;
 // UV_* errno X-macro
 //
 // Single source of truth for the 86 UV_* variants that form the tail of BOTH
-// `enum E` and `enum SystemErrno`. Zig keeps two literal enum tails; Rust
-// drives both from this one list so they cannot drift. (The UV_*→E* fold-down
+// `enum E` and `enum SystemErrno`. Both enum tails are
+// driven from this one list so they cannot drift. (The UV_*→E* fold-down
 // lives in `bun_libuv_sys::uv_err_to_e_discriminant`.)
 //
 // Entry shape:
@@ -105,7 +105,7 @@ pub enum E {
     INTR = 4,
     IO = 5,
     NXIO = 6,
-    // Zig: @"2BIG" — Rust identifiers cannot start with a digit.
+    // Rust identifiers cannot start with a digit.
     #[strum(serialize = "2BIG")]
     _2BIG = 7,
     NOEXEC = 8,
@@ -249,12 +249,12 @@ impl E {
         // generates a `const fn from_repr` matching every declared variant.
         debug_assert!(Self::from_repr(n).is_some(), "invalid E discriminant");
         // SAFETY: caller guarantees `n` is a declared `#[repr(u16)]` discriminant
-        // of `E` (Zig `@enumFromInt` precondition). Debug-asserted above; for
+        // of `E`. Debug-asserted above; for
         // untrusted input use `try_from_raw` instead.
         unsafe { core::mem::transmute::<u16, E>(n) }
     }
 
-    /// Checked discriminant lookup. Port of Zig `std.meta.intToEnum(E, n)` —
+    /// Checked discriminant lookup —
     /// returns `None` for any `n` that is not a declared variant. The `E` enum
     /// is sparse (dense 0..=137, then isolated UV_* values in the 3000–4095
     /// range), so a `< UV_ERRNO_MAX` range check is NOT sufficient.
@@ -338,10 +338,10 @@ impl E {
 pub mod posix {
     pub type mode_t = i32;
 
-    /// Zig: `std.posix.E` — alias to the platform errno enum so cross-platform
+    /// Alias to the platform errno enum so cross-platform
     /// `posix::E::FOO` paths resolve on Windows too.
     pub type E = super::E;
-    /// Zig: `std.posix.S` — file-mode bits. Re-export the canonical module so
+    /// File-mode bits. Re-export the canonical module so
     /// `posix::S::IFDIR` / `posix::S::ISREG(m)` resolve identically to POSIX.
     pub use super::s as S;
 }
@@ -364,7 +364,7 @@ macro_rules! impl_win_get_errno {
 impl_win_get_errno!(i8, i16, i32, i64, isize, u8, u16, u32, u64, usize);
 
 // ──────────────────────────────────────────────────────────────────────────
-// S — file mode bits (Zig namespace struct → Rust module)
+// S — file mode bits
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Lowercase alias kept for path stability; canonical defs live in `bun_core::S`.
@@ -376,18 +376,17 @@ pub use bun_core::S as s;
 // getErrno
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `getErrno(rc)` — `rc` is ignored, mirroring Zig's non-NTSTATUS branch;
+/// `get_errno(rc)` — `rc` is ignored;
 /// NTSTATUS callers use `windows::translate_ntstatus_to_errno` directly.
 pub fn get_errno<T>(_rc: T) -> E {
     if let Some(sys) = Win32Error::get().to_system_errno() {
         return sys.to_e();
     }
 
-    // Zig: `if (bun.windows.WSAGetLastError()) |wsa| return wsa.toE();` where
-    // `WSAGetLastError()` is `?SystemErrno` (already routed through the
-    // Win32Error→errno switch). An unmapped non-zero WSA code yields `null`
-    // there and falls through to `.SUCCESS` — it must NOT surface as
-    // `E::UNKNOWN` (which `Win32ErrorExt::to_e`'s `unwrap_or` would do).
+    // `wsa_get_last_error()` returns `Option<SystemErrno>` (already routed
+    // through the Win32Error→errno switch). An unmapped non-zero WSA code
+    // yields `None` there and falls through to `SUCCESS` — it must NOT surface
+    // as `E::UNKNOWN` (which `Win32ErrorExt::to_e`'s `unwrap_or` would do).
     if let Some(wsa) = windows::wsa_get_last_error() {
         return wsa.to_e();
     }
@@ -559,7 +558,7 @@ pub enum SystemErrno {
 }
 }} // ← UV_* tail appended by `for_each_uv_errno!`
 
-/// Type-dispatch shim for `SystemErrno::init` (Zig: `init(code: anytype)`).
+/// Type-dispatch shim for `SystemErrno::init`.
 /// Covers every concrete type the codebase actually passes — `i64` (shared
 /// `Error.rs` paths), `u32`/`DWORD` (`GetLastError()`), `c_int` (libuv rc),
 /// `u16`, and `Win32Error`.
@@ -569,13 +568,10 @@ pub trait SystemErrnoInit {
 impl SystemErrnoInit for i64 {
     #[inline]
     fn into_system_errno(self) -> Option<SystemErrno> {
-        // Zig `init(anytype)` only enters the Win32/uv mapping branch when
-        // `@TypeOf(code) == u16` or `(@TypeOf(code) == c_int and code > 0)`.
-        // For every other signed width (i64 here) it falls through to
-        // `if (code < 0) return init(-code); return @enumFromInt(code);` — a
-        // direct discriminant cast, NOT the Win32Error mapper. Routing i64
-        // through `init_c_int` would mis-map e.g. 13 → EINVAL (Win32
-        // ERROR_INVALID_DATA) instead of EACCES (discriminant 13).
+        // Only `u16` / positive `c_int` inputs enter the Win32/uv mapping
+        // branch; `i64` is a direct discriminant cast, NOT the Win32Error
+        // mapper. Routing i64 through `init_c_int` would mis-map e.g. 13 →
+        // EINVAL (Win32 ERROR_INVALID_DATA) instead of EACCES (discriminant 13).
         //
         // CHECKED, not `from_raw`: the Rust i64 impl is a cross-platform shim
         // and some Windows-reachable callers (`Listener.rs`, `udp_socket.rs`)
@@ -602,8 +598,7 @@ impl SystemErrnoInit for u32 {
     fn into_system_errno(self) -> Option<SystemErrno> {
         // GetLastError()/WSAGetLastError() return DWORD; HRESULT-shaped facility
         // codes and some installer/WinHTTP errors exceed 0xFFFF. Those are
-        // intentionally unmapped → None (matches Zig peer-widening, which would
-        // also fall through every range check). Codes that DO fit u16 route via
+        // intentionally unmapped → None. Codes that DO fit u16 route via
         // the Win32Error→errno table.
         u16::try_from(self).ok().and_then(SystemErrno::init_u16)
     }
@@ -635,21 +630,16 @@ impl SystemErrno {
     }
 
     /// Cross-platform `SystemErrno::init` — POSIX targets define a single
-    /// `init(i64)`; Windows split it into typed entry points (`init_u16` /
-    /// `init_c_int` / `init_win32_error`) because Zig's `anytype` dispatch has
-    /// no stable-Rust equivalent. Re-unified here behind `SystemErrnoInit` so
+    /// `init(i64)`; Windows splits it into typed entry points (`init_u16` /
+    /// `init_c_int` / `init_win32_error`). Re-unified here behind `SystemErrnoInit` so
     /// shared call sites can keep writing `SystemErrno::init(code)`.
     #[inline]
     pub fn init<C: SystemErrnoInit>(code: C) -> Option<SystemErrno> {
         code.into_system_errno()
     }
 
-    /// Zig: `pub fn toError(self) Error` — the local `Error` enum + 137-row
-    /// `ERROR_MAP` were a hand-typed identity bijection over the same tag names
-    /// `bun_core::Error::from_errno` already interns via the `ErrnoNames` link
-    /// hook this crate populates. POSIX targets always went through `from_errno`;
-    /// Windows now does too. (`from_error` — the inverse — had zero callers and
-    /// was deleted outright.)
+    /// Routes through `bun_core::Error::from_errno`, which interns tag names
+    /// via the `ErrnoNames` link hook this crate populates.
     #[inline]
     pub fn to_error(self) -> bun_core::Error {
         bun_core::Error::from_errno(self as u16 as i32)
@@ -663,9 +653,8 @@ impl SystemErrno {
     /// `init(code: c_int)` — same as u16 path for positives; negatives are negated and retried.
     pub fn init_c_int(code: c_int) -> Option<SystemErrno> {
         if code > 0 {
-            // Zig compared the c_int against u16 constants via peer-type widening, so any
-            // code > u16::MAX would simply fail every range check and return null. Avoid a
-            // truncating `as u16` (which could wrap into a valid Win32/uv code) by gating here.
+            // Any code > u16::MAX is unmapped. Avoid a truncating `as u16`
+            // (which could wrap into a valid Win32/uv code) by gating here.
             let Ok(code) = u16::try_from(code) else {
                 return None;
             };
@@ -695,7 +684,7 @@ impl SystemErrno {
         None
     }
 
-    /// `init(code: Win32Error)` (also covers `std.os.windows.Win32Error`).
+    /// Maps a `Win32Error` code to the corresponding `SystemErrno`.
     pub fn init_win32_error(code: Win32Error) -> Option<SystemErrno> {
         use Win32Error as W;
         Some(match code {
@@ -805,7 +794,6 @@ impl SystemErrno {
     }
 }
 
-/// Port of Zig `bun.windows.libuv.translateUVErrorToE` (libuv.zig:2776).
 /// Thin typed adapter over the canonical row table in `bun_libuv_sys`.
 pub fn translate_uv_error_to_e(code: c_int) -> E {
     uv::uv_err_to_e_discriminant(code)
@@ -818,12 +806,11 @@ pub fn translate_uv_error_to_e(code: c_int) -> E {
         .unwrap_or(E::UNKNOWN)
 }
 
-// Zig: `inline for (@typeInfo(SystemErrno).@"enum".fields) |field| { if startsWith "UV_" && @hasField(stripped) ... }`
 // Thin adapter over the canonical row table in `bun_libuv_sys::uv_err_to_e_discriminant`.
 #[inline]
 fn uv_code_to_system_errno(mag: u16) -> Option<SystemErrno> {
     let d = uv::uv_err_to_e_discriminant(-c_int::from(mag))?;
-    // UV_EAI_* (≥3000) / UV_UNKNOWN have no non-UV_ counterpart (Zig @hasField was false).
+    // UV_EAI_* (≥3000) / UV_UNKNOWN have no non-UV_ counterpart.
     if d >= 3000 || d == SystemErrno::EUNKNOWN as u16 {
         return None;
     }
@@ -831,7 +818,7 @@ fn uv_code_to_system_errno(mag: u16) -> Option<SystemErrno> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// UV_E (Zig namespace struct → Rust module)
+// UV_E
 // ──────────────────────────────────────────────────────────────────────────
 
 pub mod uv_e {
@@ -845,8 +832,6 @@ pub mod uv_e {
     crate::__uv_e_rows!(__v);
 }
 
-// ported from: src/errno/windows_errno.zig
-
 // ──────────────────────────────────────────────────────────────────────────
 // `windows` — Win32Error / NTSTATUS / kernel32 surface moved DOWN from
 // `bun_sys::windows` (cycle-break per PORTING.md §Dep-cycle fixes). Only the
@@ -868,19 +853,15 @@ pub mod windows {
     use bun_windows_sys::ws2_32::WSAGetLastError;
 
     /// Extension trait for `Win32Error` → `SystemErrno`/`E` mapping.
-    /// `bun_windows_sys` is tier-0 and cannot name `SystemErrno`, so the
-    /// inherent `to_system_errno()` from the Zig API surfaces here instead.
+    /// `bun_windows_sys` is tier-0 and cannot name `SystemErrno`, so
+    /// `to_system_errno()` surfaces here as an extension method instead.
     pub trait Win32ErrorExt: Copy {
         fn to_system_errno(self) -> Option<SystemErrno>;
         /// Convenience: Win32 error → `E`, falling back to `E::UNKNOWN` for
         /// codes not in the Win32→errno table.
         ///
-        /// **Spec note:** Zig's `Win32Error` has `toSystemErrno()` only — no
-        /// `toE()`. This helper ports the *call-site* idiom from
-        /// `bun.windows.getLastErrno()` (windows.zig:3010), which spells out
-        /// `Win32Error.get().toSystemErrno() orelse SystemErrno.EUNKNOWN`.
-        /// It is NOT appropriate where Zig spec falls through to `.SUCCESS`
-        /// on unmapped codes (e.g. the WSA path of `getErrno`); those callers
+        /// **Note:** NOT appropriate where unmapped codes must fall through
+        /// to `SUCCESS` (e.g. the WSA path of `get_errno`); those callers
         /// must use `to_system_errno()` and choose their own fallback.
         #[inline]
         fn to_e(self) -> E {
@@ -896,10 +877,7 @@ pub mod windows {
         }
     }
 
-    /// Port of `bun.windows.WSAGetLastError() ?SystemErrno` (windows.zig:3303).
-    ///
-    /// Zig: `return SystemErrno.init(@intFromEnum(ws2_32.WSAGetLastError()));`
-    /// — feeds the raw WSA code (`c_int`) through the Win32→errno switch.
+    /// Feeds the raw WSA code (`c_int`) through the Win32→errno switch.
     /// Returns `Some(SUCCESS)` for `0` and `None` for any non-zero code with
     /// no mapping (e.g. `WSANOTINITIALISED`/`WSAEDISCON`); callers that need
     /// a success-on-unmapped fallthrough (`getErrno`) rely on that `None`.
@@ -908,8 +886,7 @@ pub mod windows {
         SystemErrno::init_c_int(WSAGetLastError())
     }
 
-    /// `bun.windows.translateNTStatusToErrno` (windows.zig) — moved DOWN so
-    /// `bun_errno` owns the only NTSTATUS→`E` mapping (cycle-break).
+    /// Moved DOWN so `bun_errno` owns the only NTSTATUS→`E` mapping (cycle-break).
     pub fn translate_ntstatus_to_errno(err: NTSTATUS) -> E {
         match err {
             NTSTATUS::SUCCESS => E::SUCCESS,
diff --git a/src/event_loop/AnyEventLoop.rs b/src/event_loop/AnyEventLoop.rs
index b7a3ac61752..98b75524e59 100644
--- a/src/event_loop/AnyEventLoop.rs
+++ b/src/event_loop/AnyEventLoop.rs
@@ -13,10 +13,8 @@ use crate::{JsEventLoop, JsEventLoopKind};
 // JS-event-loop arm of `AnyEventLoop` / `EventLoopHandle`.
 //
 // LAYERING: `bun_event_loop` is a lower tier than `bun_jsc`, so it cannot name
-// `jsc::EventLoop` / `jsc::VirtualMachine` directly. Zig has no crate
-// boundaries and just calls `this.js.tick()` etc. inline (see
-// `src/event_loop/AnyEventLoop.zig` / `src/jsc/EventLoopHandle.zig`). To match
-// that — direct calls, no runtime registration — the concrete bodies live in
+// `jsc::EventLoop` / `jsc::VirtualMachine` directly. To keep
+// direct calls with no runtime registration, the concrete bodies live in
 // `bun_jsc::event_loop` as `#[no_mangle]` Rust-ABI functions and are declared
 // here as `extern "Rust"`. The linker resolves them at link time, so there is
 // no vtable, no `AtomicPtr`, and no init-order hazard.
@@ -32,7 +30,7 @@ unsafe extern "Rust" {
     pub(crate) safe fn __bun_js_event_loop_current() -> *mut ();
 }
 
-/// Wrap an erased `*mut jsc::EventLoop` (Zig `vm.eventLoop()`) in a
+/// Wrap an erased `*mut jsc::EventLoop` in a
 /// [`JsEventLoop`] handle. The pointer is stored opaquely — never dereferenced
 /// here — and the back-reference invariant (owner outlives every dispatch) is
 /// documented on the public callers ([`AnyEventLoop::js`],
@@ -49,7 +47,7 @@ fn jsc_event_loop_handle(js_event_loop: *mut ()) -> JsEventLoop {
 
 /// Useful for code that may need an event loop and could be used from either JavaScript or directly without JavaScript.
 /// Unlike jsc.EventLoopHandle, this owns the event loop when it's not a JavaScript event loop.
-// PORT NOTE: Zig `union(EventLoopKind)` — variant order/discriminant must match `crate::EventLoopKind`.
+// Variant order/discriminant must match `crate::EventLoopKind`.
 pub enum AnyEventLoop<'a> {
     Js {
         /// Typed handle wrapping the erased `*mut jsc::EventLoop`. The
@@ -60,8 +58,7 @@ pub enum AnyEventLoop<'a> {
     Mini(Box<MiniEventLoop<'a>>),
 }
 
-// PORT NOTE: Zig had `pub const Task = AnyTaskWithExtraContext;` as an associated decl.
-// Inherent associated types are unstable in Rust, so expose at module level.
+// Inherent associated types are unstable in Rust, so this is exposed at module level.
 pub type Task = AnyTaskWithExtraContext;
 
 impl<'a> Default for AnyEventLoop<'a> {
@@ -83,26 +80,22 @@ impl<'a> AnyEventLoop<'a> {
     }
 
     /// Convert to an owned [`EventLoopHandle`]. Thin alias for
-    /// [`EventLoopHandle::from_any`] kept for Zig-shape parity — callers that
-    /// were `jsc.EventLoopHandle.init(any_loop)` in Zig spell it
-    /// `AnyEventLoop::as_handle(any_loop)` in Rust.
+    /// [`EventLoopHandle::from_any`].
     #[inline]
     pub fn as_handle(this: &mut AnyEventLoop<'static>) -> EventLoopHandle {
         EventLoopHandle::from_any(this)
     }
 
     pub fn init() -> AnyEventLoop<'a> {
-        // PORT NOTE: Zig took `std.mem.Allocator param`; dropped per §Allocators (non-AST crate).
         AnyEventLoop::Mini(Box::new(MiniEventLoop::init()))
     }
 
     /// Construct the `Js` variant wrapping a specific erased
-    /// `*mut jsc::EventLoop`. Mirrors Zig's `.{ .js = vm.eventLoop() }`
-    /// literal — callers that already hold a VM pointer use this instead of
+    /// `*mut jsc::EventLoop` — callers that already hold a VM pointer use this instead of
     /// the thread-local lookup in [`js_current`].
     ///
-    /// `js_event_loop` is a live erased `*mut jsc::EventLoop` (Zig
-    /// `vm.eventLoop()`) that outlives every dispatch through the returned
+    /// `js_event_loop` is a live erased `*mut jsc::EventLoop`
+    /// that outlives every dispatch through the returned
     /// `AnyEventLoop`. The pointer is not dereferenced here — it's stored
     /// opaquely in [`JsEventLoop`] and only dereferenced at dispatch sites.
     #[inline]
@@ -121,9 +114,8 @@ impl<'a> AnyEventLoop<'a> {
         }
     }
 
-    // PORT NOTE: Zig `context: anytype` + `@ptrCast(isDone)` erases the fn-ptr
-    // type at the call into `mini.tick(ctx, *const fn(*anyopaque) bool)`. All
-    // callers pass a pointer, so we take the erased form directly; callers cast.
+    // All callers pass a pointer, so we take the erased fn-ptr form directly;
+    // callers cast.
     pub fn tick(
         &mut self,
         context: *mut core::ffi::c_void,
@@ -148,8 +140,7 @@ impl<'a> AnyEventLoop<'a> {
     /// case is UB under Stacked Borrows — the callback's whole-struct Unique
     /// retag pops the field borrow. This variant reborrows `*this`
     /// per-iteration *after* `is_done` returns, so no `&mut Self` is live
-    /// while the callback runs. Zig spec (`jsc.EventLoop.tick`) has no such
-    /// constraint because Zig `*T` is non-exclusive.
+    /// while the callback runs.
     ///
     /// # Safety
     /// `this` must be valid for `&mut` access for the duration of the call,
@@ -176,8 +167,7 @@ impl<'a> AnyEventLoop<'a> {
                     // `MiniEventLoop::tick` here because that would hold
                     // `&mut mini` across `is_done`. A single `tick_once`
                     // borrow ends at the bottom of this match arm before the
-                    // next `is_done` reborrow. Spec: MiniEventLoop.zig `tick`
-                    // loop body.
+                    // next `is_done` reborrow.
                     mini.tick_once(context);
                 }
             }
@@ -197,34 +187,24 @@ impl<'a> AnyEventLoop<'a> {
 
     /// # Safety
     /// `ctx` must be a live `*mut Context` with an embedded
-    /// `AnyTaskWithExtraContext` at `field_offset` (Zig `comptime field:
-    /// std.meta.FieldEnum(Context)`).
+    /// `AnyTaskWithExtraContext` at `field_offset`.
     pub unsafe fn enqueue_task_concurrent<Context, ParentContext>(
         &mut self,
         ctx: *mut Context,
         callback: fn(*mut Context, *mut ParentContext),
-        // Zig param `comptime field: std.meta.FieldEnum(Context)` — replaced per
-        // PORTING.md (§reflection) with a caller-supplied byte offset to the
-        // embedded `AnyTaskWithExtraContext` (`core::mem::offset_of!(Context, field)`).
+        // Caller-supplied byte offset to the embedded
+        // `AnyTaskWithExtraContext` (`core::mem::offset_of!(Context, field)`).
         field_offset: usize,
     ) {
         match self {
             AnyEventLoop::Js { .. } => {
                 let _ = (ctx, callback, field_offset);
-                // Zig: `bun.todoPanic(@src(), "AnyEventLoop.enqueueTaskConcurrent", .{});`
-                // — intentionally unreachable in Zig too.
+                // Intentionally unreachable.
                 unreachable!("AnyEventLoop.enqueueTaskConcurrent");
-                // const TaskType = AnyTask.New(Context, Callback);
-                // @field(ctx, field) = TaskType.init(ctx);
-                // var concurrent = bun.default_allocator.create(ConcurrentTask) catch unreachable;
-                // _ = concurrent.from(jsc.Task.init(&@field(ctx, field)));
-                // concurrent.auto_delete = true;
-                // this.virtual_machine.jsc.enqueueTaskConcurrent(concurrent);
             }
             AnyEventLoop::Mini(mini) => {
                 // SAFETY: `ctx` is a live `*mut Context` with an embedded
-                // `AnyTaskWithExtraContext` at `field_offset` (caller invariant
-                // — Zig `comptime field: std.meta.FieldEnum(Context)`).
+                // `AnyTaskWithExtraContext` at `field_offset` (caller invariant).
                 unsafe {
                     mini.enqueue_task_concurrent_with_extra_ctx::<Context, ParentContext>(
                         ctx,
@@ -245,14 +225,13 @@ impl<'a> AnyEventLoop<'a> {
 // instantiation in the tree is already `'static` (verified: install, patch,
 // build_command, ChangedFilesFilter, `js()`/`js_current()`).
 impl AnyEventLoop<'static> {
-    // PORT NOTE: renamed via raw identifier — `loop` is a Rust keyword.
     #[inline]
     pub fn r#loop(&mut self) -> *mut UwsLoop {
         EventLoopHandle::from_any(self).r#loop()
     }
 
     /// Alias for [`r#loop`](Self::r#loop) so callers spell `event_loop.loop_()`
-    /// (Zig: `eventLoop().loop()`) without the raw-identifier escape.
+    /// without the raw-identifier escape.
     #[inline]
     pub fn loop_(&mut self) -> *mut UwsLoop {
         self.r#loop()
@@ -271,8 +250,8 @@ impl AnyEventLoop<'static> {
         unsafe { (*self.r#loop()).wakeup() };
     }
 
-    /// Returns the FilePoll store as a raw pointer (mirrors Zig
-    /// `*FilePoll.Store`). See [`EventLoopHandle::file_polls`] for the aliasing
+    /// Returns the FilePoll store as a raw pointer.
+    /// See [`EventLoopHandle::file_polls`] for the aliasing
     /// contract — callers deref locally for the brief region they need `&mut`.
     #[inline]
     pub fn file_polls(&mut self) -> *mut bun_io::file_poll::Store {
@@ -284,8 +263,8 @@ impl AnyEventLoop<'static> {
         EventLoopHandle::from_any(self).put_file_poll(poll)
     }
 
-    /// Returns the shared pipe-read scratch buffer as a raw fat ptr (mirrors
-    /// Zig `[]u8`). See [`EventLoopHandle::pipe_read_buffer`].
+    /// Returns the shared pipe-read scratch buffer as a raw fat ptr.
+    /// See [`EventLoopHandle::pipe_read_buffer`].
     #[inline]
     pub fn pipe_read_buffer(&mut self) -> *mut [u8] {
         EventLoopHandle::from_any(self).pipe_read_buffer()
@@ -293,7 +272,7 @@ impl AnyEventLoop<'static> {
 }
 
 // ─────────────────────────── EventLoopHandle ───────────────────────────────
-// MOVE-IN: relocated from `bun_jsc::EventLoopHandle` (src/jsc/EventLoopHandle.zig)
+// MOVE-IN: relocated from `bun_jsc::EventLoopHandle`.
 // Non-owning reference to either the JS event
 // loop or the mini event loop. The `.js` arm holds a `JsEventLoop` handle
 // (link-time-resolved dispatch; impls in `bun_jsc`).
@@ -306,9 +285,9 @@ pub enum EventLoopHandle {
         /// `Copy`.
         owner: JsEventLoop,
     },
-    // PORT NOTE: `BackRef<MiniEventLoop>` (not `&mut`) because the handle is
-    // `Copy` and stored in `uws::InternalLoopData` as a non-owning backref —
-    // matches Zig `*MiniEventLoop`. The pointee is the per-thread singleton
+    // `BackRef<MiniEventLoop>` (not `&mut`) because the handle is `Copy` and
+    // stored in `uws::InternalLoopData` as a non-owning backref.
+    // The pointee is the per-thread singleton
     // (`init_global`) or an `AnyEventLoop::Mini`-owned loop, both of which
     // strictly outlive every `EventLoopHandle` derived from them — the
     // [`BackRef`] invariant. Read-only sites use safe `Deref`; the few
@@ -335,14 +314,14 @@ fn mini_mut<'a>(mini: &'a mut BackRef<MiniEventLoop<'static>>) -> &'a mut MiniEv
 }
 
 /// Untagged pointer to either kind of concurrent task. Tag is the surrounding
-/// `EventLoopHandle` discriminant — Zig `EventLoopTaskPtr` was an untagged union.
+/// `EventLoopHandle` discriminant.
 #[derive(Copy, Clone)]
 pub union EventLoopTaskPtr {
     pub js: *mut ConcurrentTask,
     pub mini: *mut AnyTaskWithExtraContext,
 }
 
-/// Owned storage for either kind of concurrent task (Zig `EventLoopTask`).
+/// Owned storage for either kind of concurrent task.
 pub enum EventLoopTask {
     Js(ConcurrentTask),
     Mini(AnyTaskWithExtraContext),
@@ -378,12 +357,9 @@ impl Drop for EnteredEventLoop {
 }
 
 impl EventLoopHandle {
-    /// Wrap an erased `*mut jsc::EventLoop`.
-    // PORT NOTE: Zig `init(anytype)` dispatched on `@TypeOf` over five input
-    // types. Rust splits by overload: `init` (jsc::EventLoop), `init_mini`,
-    // `from_any`, plus the trivial `EventLoopHandle → EventLoopHandle` is
-    // identity. The `*VirtualMachine` overload moves to bun_runtime (it must
-    // call `vm.eventLoop()`).
+    /// Wrap an erased `*mut jsc::EventLoop`. (Sibling constructors:
+    /// `init_mini`, `from_any`; the `*VirtualMachine` form lives in
+    /// bun_runtime since it must call `vm.eventLoop()`.)
     ///
     /// `js_event_loop` is a live erased `*mut jsc::EventLoop` whose owner
     /// outlives every dispatch through the returned handle. The pointer is not
@@ -431,8 +407,7 @@ impl EventLoopHandle {
     }
 
     /// Erase to the `(tag, ptr)` pair stored in `uws::InternalLoopData`
-    /// (`parent_tag` / `parent_ptr`). Tag 1 = JS, tag 2 = mini — matches Zig
-    /// `setParentEventLoop`.
+    /// (`parent_tag` / `parent_ptr`). Tag 1 = JS, tag 2 = mini.
     #[inline]
     pub fn into_tag_ptr(self) -> (core::ffi::c_char, *mut core::ffi::c_void) {
         match self {
@@ -442,7 +417,7 @@ impl EventLoopHandle {
     }
 
     /// Inverse of [`into_tag_ptr`] — recover from the `(tag, ptr)` pair stored
-    /// in `uws::InternalLoopData` (Zig: `loop.internal_loop_data.getParent()`).
+    /// in `uws::InternalLoopData`.
     ///
     /// `(tag, ptr)` must have been produced by [`into_tag_ptr`] on a still-live
     /// event loop (i.e. read from `internal_loop_data` while the loop is alive).
@@ -485,7 +460,6 @@ impl bun_uws::ParentEventLoopHandle for EventLoopHandle {
 }
 
 impl EventLoopHandle {
-    /// Zig: `loop.internal_loop_data.setParentEventLoop(jsc.EventLoopHandle.init(..))`.
     /// Convenience wrapper so callers don't need both `bun_uws::InternalLoopDataExt`
     /// (the trait) and the `*mut Loop` deref dance in scope. `uws_loop` is the
     /// process-global loop returned by `AnyEventLoop::r#loop()` — never null.
@@ -562,7 +536,7 @@ impl EventLoopHandle {
         self.enter();
         EnteredEventLoop(self)
     }
-    /// Returns the FilePoll store as a raw pointer (mirrors Zig `*FilePoll.Store`).
+    /// Returns the FilePoll store as a raw pointer.
     /// `EventLoopHandle` is `Copy`; promoting to `&'static mut` would let two
     /// calls produce aliased exclusive references (UB). Callers deref locally
     /// for the brief region they need `&mut`.
@@ -629,7 +603,7 @@ impl EventLoopHandle {
     }
 
     /// Alias for [`r#loop`](Self::r#loop) so callers spell `handle.loop_()`
-    /// without the raw-identifier escape (Zig: `handle.loop()`).
+    /// without the raw-identifier escape.
     #[inline]
     pub fn loop_(self) -> *mut UwsLoop {
         self.r#loop()
@@ -652,8 +626,8 @@ impl EventLoopHandle {
         self.native_loop()
     }
 
-    /// Returns the shared pipe-read scratch buffer as a raw fat ptr (mirrors
-    /// Zig `[]u8`). Same `Copy`-handle aliasing concern as [`file_polls`].
+    /// Returns the shared pipe-read scratch buffer as a raw fat ptr.
+    /// Same `Copy`-handle aliasing concern as [`file_polls`].
     pub fn pipe_read_buffer(self) -> *mut [u8] {
         match self {
             EventLoopHandle::Js { owner } => owner.pipe_read_buffer(),
@@ -676,10 +650,9 @@ impl EventLoopHandle {
     pub fn env(self) -> *mut DotEnvLoader<'static> {
         match self {
             EventLoopHandle::Js { owner } => owner.env(),
-            // Zig unwraps `mini.env.?` — caller invariant. `env_ptr()` takes
+            // `env` must be set — caller invariant. `env_ptr()` takes
             // `&self` and returns `Option<NonNull<DotEnvLoader>>` (mutable
-            // provenance; Zig field is `?*DotEnvLoader`). Safe via
-            // `BackRef: Deref`.
+            // provenance). Safe via `BackRef: Deref`.
             EventLoopHandle::Mini(mini) => mini
                 .env_ptr()
                 .expect("MiniEventLoop.env unset")
@@ -705,8 +678,8 @@ impl EventLoopHandle {
         match self {
             EventLoopHandle::Js { owner } => owner.create_null_delimited_env_map(),
             EventLoopHandle::Mini(mini) => {
-                // `env_ptr()` takes `&self` — safe via `BackRef: Deref`. Zig
-                // unwraps `mini.env.?` (caller invariant).
+                // `env_ptr()` takes `&self` — safe via `BackRef: Deref`.
+                // `env` must be set (caller invariant).
                 let env = mini.env_ptr().expect("MiniEventLoop.env unset");
                 // SAFETY: `env` is a `NonNull<DotEnvLoader>` backref; the
                 // loader is a thread-/process-lifetime singleton (see
@@ -715,10 +688,4 @@ impl EventLoopHandle {
             }
         }
     }
-
-    // PORT NOTE: Zig `cast(tag)` returned `tag.Type()` at comptime — no Rust
-    // equivalent. Callers should pattern-match the enum directly.
-    // PORT NOTE: Zig `allocator()` dropped per §Allocators (non-AST crate).
 }
-
-// ported from: src/event_loop/AnyEventLoop.zig
diff --git a/src/event_loop/AnyTask.rs b/src/event_loop/AnyTask.rs
index 5b88cde42cd..8663f8f7bf1 100644
--- a/src/event_loop/AnyTask.rs
+++ b/src/event_loop/AnyTask.rs
@@ -11,7 +11,7 @@ use crate::Task;
 /// split exists only to keep call sites compiling.
 pub use bun_core::JsError as ErasedJsError;
 
-/// `bun.JSError!T` for tier-3 callbacks. Same type as `bun_jsc::JsResult<T>`; kept as a
+/// Result alias for tier-3 callbacks. Same type as `bun_jsc::JsResult<T>`; kept as a
 /// local alias so `AnyTask`/`ManagedTask` signatures don't take an upward dep.
 pub type JsResult<T> = core::result::Result<T, ErasedJsError>;
 
@@ -22,8 +22,8 @@ pub struct AnyTask {
 
 impl Default for AnyTask {
     fn default() -> Self {
-        // Zig: field defaults to `= undefined`; provide a sentinel that panics
-        // if run before being overwritten.
+        // Provide a sentinel callback that panics if run before being
+        // overwritten.
         Self {
             ctx: None,
             callback: |_| unreachable!("AnyTask.callback was undefined"),
@@ -37,8 +37,6 @@ impl AnyTask {
     }
 
     pub fn run(&mut self) -> JsResult<()> {
-        // Zig: @setRuntimeSafety(false) — no Rust equivalent; bounds/overflow checks
-        // are already off in release and the body has none anyway.
         let callback = self.callback;
         let ctx = self.ctx;
         callback(ctx.expect("ctx").as_ptr())
@@ -46,11 +44,8 @@ impl AnyTask {
 }
 
 impl AnyTask {
-    /// Zig: `AnyTask.New(T, Callback).init(ctx)`.
-    ///
     /// Builds an [`AnyTask`] from a typed `*mut T` context and a typed
-    /// callback, erasing both to `c_void` in one place. This is the direct
-    /// stable-Rust analogue of Zig's `comptime Callback` generator: instead of
+    /// callback, erasing both to `c_void` in one place. Instead of
     /// monomorphising a `wrap` shim per `(Type, Callback)` pair, the typed
     /// `fn` pointer itself is reinterpreted as the erased one — `*mut T` and
     /// `*mut c_void` are ABI-identical for all `T: Sized`, so
@@ -72,5 +67,3 @@ impl AnyTask {
         }
     }
 }
-
-// ported from: src/event_loop/AnyTask.zig
diff --git a/src/event_loop/AnyTaskWithExtraContext.rs b/src/event_loop/AnyTaskWithExtraContext.rs
index d9738880207..354111513e9 100644
--- a/src/event_loop/AnyTaskWithExtraContext.rs
+++ b/src/event_loop/AnyTaskWithExtraContext.rs
@@ -14,7 +14,6 @@ pub struct AnyTaskWithExtraContext {
 
 impl Default for AnyTaskWithExtraContext {
     fn default() -> Self {
-        // Zig: ctx/callback default to `undefined`, next defaults to `null`.
         Self {
             ctx: None,
             callback: |_, _| unreachable!("callback was undefined"),
@@ -27,10 +26,6 @@ impl AnyTaskWithExtraContext {
     /// Heap-allocates a wrapper around `ptr`, returns a pointer to the embedded
     /// `AnyTaskWithExtraContext`. When `run` fires, it calls `callback(ptr, extra)`
     /// and then frees the wrapper.
-    ///
-    /// Zig signature: `fn fromCallbackAutoDeinit(ptr: anytype, comptime fieldName: [:0]const u8) *AnyTaskWithExtraContext`
-    /// where `fieldName` names a decl on `@TypeOf(ptr).*`. Rust cannot look up a
-    /// method by comptime string, so callers pass the function directly.
     pub fn from_callback_auto_deinit<T>(
         ptr: *mut T,
         callback: fn(*mut T, *mut c_void),
@@ -38,13 +33,12 @@ impl AnyTaskWithExtraContext {
         #[repr(C)]
         struct Wrapper<T> {
             any_task: AnyTaskWithExtraContext,
-            // TODO(port): LIFETIMES.tsv classifies this as BORROW_PARAM (&'a mut T),
-            // but Wrapper is Box'd and escapes the call frame, so a borrow lifetime
-            // cannot be expressed. Kept as raw; caller guarantees `ptr` outlives the task.
+            // Raw on purpose: Wrapper is Box'd and escapes the call frame, so
+            // a borrow lifetime cannot be expressed. Caller guarantees `ptr`
+            // outlives the task.
             wrapped: *mut T,
-            // Extra field vs Zig: Zig monomorphized the callback into `Wrapper.function`
-            // via `comptime fieldName`. Stable Rust has no const fn-pointer generics,
-            // so we store it here instead.
+            // Stable Rust has no const fn-pointer generics,
+            // so the callback is stored here instead.
             callback: fn(*mut T, *mut c_void),
         }
 
@@ -74,22 +68,16 @@ impl AnyTaskWithExtraContext {
         }
     }
 
-    /// Zig signature: `fn from(this: *@This(), of: anytype, comptime field: []const u8) *@This()`
-    /// — initializes `this` in place to call `@TypeOf(of).field(of, extra)` with
-    /// `ContextType = void`.
-    // PORT NOTE: Zig used `@field(T, field)` comptime decl lookup; Rust callers
-    // pass the fn pointer directly.
-    // TODO(port): Zig passes `ContextType = void` (the unit type, NOT `anyopaque`);
-    // `*void` is zero-bit so the callee is effectively `fn(*T)` only. Mapped here
-    // to `*mut ()` — could be `fn(*mut T)` with the second arg dropped.
-    // PORT NOTE: name kept as `from` to match Zig; not the `From` trait.
+    /// Initializes `self` in place to call `callback(of, extra)`.
+    // The unit context means the callee is effectively `fn(*T)` only; mapped
+    // to `*mut ()` to keep the two-arg stored ABI uniform.
+    // Named `from` for historical reasons; not the `From` trait.
     pub fn from<T>(&mut self, of: *mut T, callback: fn(*mut T, *mut ())) -> *mut Self {
         *self = New::<T, ()>::init(of, callback);
         std::ptr::from_mut::<Self>(self)
     }
 
     pub fn run(&mut self, extra: *mut c_void) {
-        // Zig: @setRuntimeSafety(false) — no-op in Rust release; debug keeps the unwrap check.
         let callback = self.callback;
         let ctx = self.ctx;
         // SAFETY: caller contract — `ctx` was set by `init`/`from*` to a live pointer.
@@ -97,21 +85,16 @@ impl AnyTaskWithExtraContext {
     }
 }
 
-/// Zig: `fn New(comptime Type: type, comptime ContextType: type, comptime Callback: anytype) type`
-///
 /// Stable Rust cannot take a fn value as a const generic, so `Callback` moves to
 /// a runtime argument on `init` and is type-erased (ABI-identical: both forms
 /// are thin fn pointers taking two thin data pointers).
-// TODO(port): if a zero-storage comptime form is ever needed, switch to a
-// `trait TaskCallback<C> { fn call(&mut self, extra: *mut C); }` bound on `T`.
 pub struct New<T, C>(PhantomData<(*mut T, *mut C)>);
 
 impl<T, C> New<T, C> {
     pub fn init(ctx: *mut T, callback: fn(*mut T, *mut C)) -> AnyTaskWithExtraContext {
         AnyTaskWithExtraContext {
             // SAFETY: `fn(*mut T, *mut C)` and `fn(*mut (), *mut ())` have identical
-            // ABI (single code pointer, two pointer-sized args). This is the moral
-            // equivalent of Zig's `wrap` thunk that `@ptrCast`/`@alignCast`s the args.
+            // ABI (single code pointer, two pointer-sized args).
             callback: unsafe {
                 bun_ptr::cast_fn_ptr::<fn(*mut T, *mut C), fn(*mut (), *mut ())>(callback)
             },
@@ -119,14 +102,4 @@ impl<T, C> New<T, C> {
             next: bun_threading::Link::new(),
         }
     }
-
-    // TODO(port): Zig's `New(...).wrap(this: ?*anyopaque, extra: ?*anyopaque)` was
-    // the type-erasing thunk stored in `.callback = wrap`. Because stable Rust
-    // can't take `Callback` as a const generic, `init` erases the typed fn
-    // pointer directly instead — so `wrap` is folded into that cast and
-    // intentionally omitted here. If this ever switches to a `TaskCallback<C>`
-    // trait bound on `T`, reintroduce `wrap` as the 2-arg stored thunk.
-    // PERF(port): Zig used `@call(bun.callmod_inline, Callback, ...)` — profile if hot.
 }
-
-// ported from: src/event_loop/AnyTaskWithExtraContext.zig
diff --git a/src/event_loop/AutoFlusher.rs b/src/event_loop/AutoFlusher.rs
index fda8bb215bb..d7638f703ed 100644
--- a/src/event_loop/AutoFlusher.rs
+++ b/src/event_loop/AutoFlusher.rs
@@ -3,25 +3,23 @@ use core::ptr::NonNull;
 
 use crate::DeferredTaskQueue::{DeferredRepeatingTask, DeferredTaskQueue};
 
-/// Zig file-level struct: `src/event_loop/AutoFlusher.zig`
+/// Tracks whether a flushable type is registered with the deferred task queue.
 #[derive(Debug, Default)]
 pub struct AutoFlusher {
     pub registered: bool,
 }
 
-/// Zig's free functions take `(comptime Type: type, this: *Type)` and duck-type
-/// on `this.auto_flusher` + `Type.onAutoFlush`. In Rust that contract is a trait.
+/// Contract for types that own an [`AutoFlusher`] and can be flushed via a
+/// deferred-task callback.
 pub trait HasAutoFlusher: Sized {
     fn auto_flusher(&mut self) -> &mut AutoFlusher;
-    /// Zig: `Type.onAutoFlush` — the deferred-task callback. Signature matches
-    /// `DeferredRepeatingTask` after the `@ptrCast` erasure at `postTask`:
-    /// `fn(*anyopaque) bool` ↔ `fn(*mut c_void) -> bool`.
+    /// The deferred-task callback. Signature matches
+    /// `DeferredRepeatingTask` after erasure: `fn(*mut c_void) -> bool`.
     fn on_auto_flush(this: *mut Self) -> bool;
 }
 
 /// Erase a typed `T::on_auto_flush` to the `DeferredRepeatingTask` ABI
-/// (`unsafe extern "C" fn(*mut c_void) -> bool`). Mirrors Zig's
-/// `@ptrCast(&Type.onAutoFlush)` at the `postTask` call site, but via a
+/// (`unsafe extern "C" fn(*mut c_void) -> bool`) via a
 /// monomorphic `extern "C"` trampoline rather than a fn-ptr cast so the
 /// calling convention is honest.
 #[inline]
@@ -38,10 +36,10 @@ pub(crate) fn erase_flush_callback<T: HasAutoFlusher>() -> DeferredRepeatingTask
     trampoline::<T>
 }
 
-// PORT NOTE (b0): Zig passed `*jsc.VirtualMachine` and reached
-// `vm.event_loop().deferred_tasks`. To break the event_loop→jsc upward edge,
-// callers now pass the `DeferredTaskQueue` directly (it lives in this crate).
-// Higher-tier call sites do `&mut vm.event_loop().deferred_tasks` themselves.
+// To avoid an event_loop→jsc upward edge, callers pass the
+// `DeferredTaskQueue` directly (it lives in this crate) rather than a VM
+// pointer. Higher-tier call sites do `&mut vm.event_loop().deferred_tasks`
+// themselves.
 pub(crate) fn register_deferred_microtask_with_type<T: HasAutoFlusher>(
     this: &mut T,
     deferred: &mut DeferredTaskQueue,
@@ -67,8 +65,8 @@ pub(crate) fn unregister_deferred_microtask_with_type_unchecked<T: HasAutoFlushe
     deferred: &mut DeferredTaskQueue,
 ) {
     debug_assert!(this.auto_flusher().registered);
-    // PORT NOTE: Zig `bun.assert(expr)` evaluates `expr` unconditionally; the
-    // *check* is debug-only but the side effect must run in release too.
+    // The *check* is debug-only but the `unregister_task` side effect must
+    // run in release too — don't fold this into the debug_assert.
     let removed =
         deferred.unregister_task(NonNull::new(std::ptr::from_mut::<T>(this).cast::<c_void>()));
     debug_assert!(removed);
@@ -89,9 +87,8 @@ pub(crate) fn register_deferred_microtask_with_type_unchecked<T: HasAutoFlusher>
 }
 
 // ─── associated-fn facade ─────────────────────────────────────────────────
-// Zig call sites read `AutoFlusher.registerDeferredMicrotaskWithType(Self, this, vm)`
-// — i.e. namespaced on the struct. Mirror that as inherent associated fns so
-// callers can write `AutoFlusher::register_deferred_microtask_with_type::<T>(…)`.
+// Inherent associated fns so callers can write
+// `AutoFlusher::register_deferred_microtask_with_type::<T>(…)`.
 // These are the *lower-tier* signatures (queue passed directly); the higher-tier
 // `vm`-taking wrappers live in `bun_runtime::webcore` to avoid the
 // event_loop→jsc upward dependency.
@@ -128,5 +125,3 @@ impl AutoFlusher {
         unregister_deferred_microtask_with_type_unchecked(this, deferred);
     }
 }
-
-// ported from: src/event_loop/AutoFlusher.zig
diff --git a/src/event_loop/ConcurrentTask.rs b/src/event_loop/ConcurrentTask.rs
index d51fcc0416f..46ee11ebc2f 100644
--- a/src/event_loop/ConcurrentTask.rs
+++ b/src/event_loop/ConcurrentTask.rs
@@ -13,8 +13,7 @@ use bun_threading::UnboundedQueue;
 use bun_threading::unbounded_queue::{Link, Linked};
 
 // ─── Module-level constructor forwarders ────────────────────────────────────
-// Zig spelled these as namespace calls (`ConcurrentTask.createFrom(...)`,
-// `ConcurrentTask.fromCallback(...)`). Several Rust callers import this file
+// Several callers import this file
 // as a *module* (`use bun_jsc::ConcurrentTask;`) rather than the struct, so
 // `ConcurrentTask::create_from(x)` resolves as a free-function lookup, not an
 // inherent-method call. Provide thin module-level forwarders so both spellings
@@ -43,13 +42,12 @@ pub fn from_callback<T>(
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct TaskTag(pub u8);
 
-/// Tag constants for `Task` — one per variant of Zig's `jsc.Task`
-/// `TaggedPointerUnion` (src/jsc/Task.zig). Values are sequential by source
+/// Tag constants for `Task` — one per dispatchable task type. Values are
+/// sequential by source
 /// order; `bun_runtime::dispatch::run_task` matches on these. Both sides MUST
 /// agree — adding a variant requires updating both this list and the runtime
 /// match arm.
-// PORT NOTE: Zig `TaggedPointerUnion` derived tags from a comptime type list;
-// Rust splits the table (here) from the type→arm mapping (runtime tier-6).
+// The tag table (here) is split from the type→arm mapping (runtime tier-6).
 #[allow(non_upper_case_globals)]
 pub mod task_tag {
     use super::TaskTag;
@@ -175,9 +173,7 @@ pub struct Task {
 }
 
 /// Type → tag binding for [`Task`]. Implement on every type that can be
-/// enqueued; the impl lives in whatever crate owns the type (mirrors Zig's
-/// comptime `TaggedPointerUnion` type-list lookup, where the tag was derived
-/// from `@typeName(std.meta.Child(@TypeOf(ptr)))`).
+/// enqueued; the impl lives in whatever crate owns the type.
 ///
 /// ```ignore
 /// impl bun_event_loop::Taskable for FetchTasklet {
@@ -207,14 +203,9 @@ impl Task {
         Task { tag, ptr }
     }
 
-    /// Zig: `TaggedPointerUnion.init(_ptr: anytype)` — `@typeInfo` asserted
-    /// `_ptr` was a pointer, then `@intFromEnum(@field(Tag, @typeName(Child)))`
-    /// resolved the tag from the comptime type list. Rust expresses the
-    /// type→tag table as the [`Taskable`] trait; the per-type impl supplies
-    /// `T::TAG` and the body is the Zig `TaggedPointer.init(ptr, tag)`.
-    // PORT NOTE: Zig accepted `anytype` and reflected on `@TypeOf`; Rust takes
-    // `*mut T` directly (the only shape Zig admitted). `&mut T` coerces at
-    // call sites.
+    /// The type→tag table is the [`Taskable`] trait; the per-type impl
+    /// supplies `T::TAG`.
+    // Takes `*mut T` directly; `&mut T` coerces at call sites.
     #[inline]
     pub fn init<T: Taskable>(ptr: *mut T) -> Task {
         Task::new(T::TAG, ptr.cast::<()>())
@@ -229,9 +220,8 @@ impl Task {
         Task::new(T::TAG, bun_core::heap::into_raw(task).cast::<()>())
     }
 
-    /// Zig: `TaggedPointerUnion.initWithType(comptime Type, _ptr)` — for the
-    /// rare case where the pointer's static type differs from the variant
-    /// (Zig used this when `_ptr` was `*anyopaque`).
+    /// For the rare case where the pointer's static type differs from the
+    /// variant (e.g. when `ptr` is already erased).
     #[inline]
     pub fn init_with_type<T: Taskable>(ptr: *mut ()) -> Task {
         Task::new(T::TAG, ptr)
@@ -263,7 +253,8 @@ pub struct ConcurrentTask {
 impl Default for ConcurrentTask {
     fn default() -> Self {
         Self {
-            // SAFETY: matches Zig `task: Task = undefined` — caller must set before use.
+            // SAFETY: all-zero is a valid bit pattern for `Task` (plain tag
+            // byte + raw pointer); caller must set a real task before use.
             task: unsafe { bun_core::ffi::zeroed_unchecked() },
             next: Link::new(),
             auto_delete: false,
@@ -271,10 +262,10 @@ impl Default for ConcurrentTask {
     }
 }
 
-// PORT NOTE: Zig packs `auto_delete` into bit 0 of `next` (`PackedNextPtr`) to
-// keep `ConcurrentTask` at 16 bytes. The Rust port deliberately splits it back
-// out: `Task` is already two words here (tag is not packed into the pointer),
-// so the struct was never 16B, and profiling (build/create-next benches) showed
+// `auto_delete` is deliberately its own field rather than packed into bit 0
+// of `next`: `Task` is already two words here (tag is not packed into the
+// pointer), so the struct was never 16B, and profiling (build/create-next
+// benches) showed
 // the packed form costs a Relaxed load + OR on every `atomic_store_next` —
 // turning the MPSC enqueue's single release-store into a load-then-store on a
 // cache line that is bouncing between producer threads and the JS-thread
@@ -306,14 +297,14 @@ pub enum AutoDeinit {
 }
 
 impl ConcurrentTask {
-    /// `bun.TrivialNew(@This())` — heap-allocate a ConcurrentTask and return a raw pointer.
+    /// Heap-allocate a ConcurrentTask and return a raw pointer.
     /// The pointer is intrusive (linked into `Queue`), so we use `heap::alloc` rather than `Box<T>`.
     #[inline]
     pub fn new(init: ConcurrentTask) -> *mut ConcurrentTask {
         bun_core::heap::into_raw(Box::new(init))
     }
 
-    /// `bun.TrivialDeinit(@This())` — free a ConcurrentTask previously returned by `new`.
+    /// Free a ConcurrentTask previously returned by `new`.
     ///
     /// # Safety
     /// `this` must have been produced by `ConcurrentTask::new` and not yet freed.
@@ -334,9 +325,7 @@ impl ConcurrentTask {
     }
 
     pub fn create_from<T: Taskable>(task: *mut T) -> core::ptr::NonNull<ConcurrentTask> {
-        // TODO(port): re-enable once `mark_binding!` macro arity matches
-        // `ScopedLogger::log` (concurrent bun_core edit changed it to 1-arg).
-        // bun_core::mark_binding!();
+        bun_core::mark_binding!();
         Self::create(Task::init(task))
     }
 
@@ -349,16 +338,13 @@ impl ConcurrentTask {
         Self::create(Task::from_boxed(task))
     }
 
-    // PORT NOTE: callback returns `JsResult<()>` to match `ManagedTask::new`'s stored ABI;
-    // Zig accepted both `fn(*T) void` and `fn(*T) JSError!void` via comptime — Rust callers
-    // that have a `fn(*mut T)` should wrap it as `|p| { f(p); Ok(()) }` at the call site.
+    // callback returns `JsResult<()>` to match `ManagedTask::new`'s stored ABI;
+    // callers that have a `fn(*mut T)` should wrap it as `|p| { f(p); Ok(()) }` at the call site.
     pub fn from_callback<T>(
         ptr: *mut T,
         callback: fn(*mut T) -> crate::JsResult<()>,
     ) -> core::ptr::NonNull<ConcurrentTask> {
-        // TODO(port): re-enable once `mark_binding!` macro arity matches
-        // `ScopedLogger::log` (concurrent bun_core edit changed it to 1-arg).
-        // bun_core::mark_binding!();
+        bun_core::mark_binding!();
         Self::create(ManagedTask::ManagedTask::new(ptr, callback))
     }
 
@@ -367,9 +353,7 @@ impl ConcurrentTask {
         of: *mut T,
         auto_deinit: AutoDeinit,
     ) -> &mut ConcurrentTask {
-        // TODO(port): re-enable once `mark_binding!` macro arity matches
-        // `ScopedLogger::log` (concurrent bun_core edit changed it to 1-arg).
-        // bun_core::mark_binding!();
+        bun_core::mark_binding!();
         *self = ConcurrentTask {
             task: Task::init(of),
             next: Link::new(),
@@ -384,5 +368,3 @@ impl ConcurrentTask {
         self.auto_delete
     }
 }
-
-// ported from: src/event_loop/ConcurrentTask.zig
diff --git a/src/event_loop/DeferredTaskQueue.rs b/src/event_loop/DeferredTaskQueue.rs
index ce28e712f26..c5b50ac21f7 100644
--- a/src/event_loop/DeferredTaskQueue.rs
+++ b/src/event_loop/DeferredTaskQueue.rs
@@ -31,7 +31,7 @@ use core::ptr::NonNull;
 
 use bun_collections::ArrayHashMap;
 
-// PORT NOTE: Zig `*const fn(*anyopaque) bool`. Declared `extern "C"` so the
+// Declared `extern "C"` so the
 // same fn-pointer type can flow across the FFI boundary (e.g.
 // `Bun__VM__postDeferredTask`) without an ABI-crossing fn-ptr cast. All in-tree
 // producers go through monomorphic `extern "C"` trampolines (see
@@ -45,9 +45,8 @@ pub struct DeferredTaskQueue {
 
 impl DeferredTaskQueue {
     pub fn post_task(&mut self, ctx: Option<NonNull<c_void>>, task: DeferredRepeatingTask) -> bool {
-        // Zig: `getOrPutValue(ctx, task).found_existing`.
-        // PORT NOTE: `ArrayHashMap` is currently aliased to std `HashMap`; the
-        // entry API gives the same semantics (insert-if-absent + report-existing).
+        // `ArrayHashMap` is currently aliased to std `HashMap`; the entry API
+        // gives insert-if-absent + report-existing semantics.
         match self.map.entry(ctx) {
             bun_collections::hash_map::Entry::Occupied(_) => true,
             bun_collections::hash_map::Entry::Vacant(v) => {
@@ -58,19 +57,18 @@ impl DeferredTaskQueue {
     }
 
     pub fn unregister_task(&mut self, ctx: Option<NonNull<c_void>>) -> bool {
-        // Zig: `swapRemove(ctx) -> bool`. Order is irrelevant for this map's
-        // contract (see file doc — "order may not particularly matter"), so
-        // plain `remove().is_some()` is equivalent.
+        // Order is irrelevant for this map's contract (see file doc — "order
+        // may not particularly matter"), so plain `remove().is_some()` works.
         self.map.remove(&ctx).is_some()
     }
 
     pub fn run(&mut self) {
-        // PORT NOTE: Zig used `swapRemoveAt(i)` (O(1) by index). The current
-        // `ArrayHashMap` exposes `keys()/values()` slices and `swap_remove(&K)`
-        // (O(n) hash lookup) but not `swap_remove_at`. Keys here are `Copy`
-        // pointers, so copy the key out and remove by key — semantically
-        // identical (keys are unique), just an extra hash per removal.
-        // PERF(port): swap_remove(&K) re-hashes; restore swap_remove_at when
+        // The current `ArrayHashMap` exposes `keys()/values()` slices and
+        // `swap_remove(&K)` (hash lookup) but not `swap_remove_at` (O(1) by
+        // index). Keys here are `Copy` pointers, so copy the key out and
+        // remove by key — semantically identical (keys are unique), just an
+        // extra hash per removal.
+        // PERF: swap_remove(&K) re-hashes; restore swap_remove_at when
         // bun_collections::ArrayHashMap grows it.
         let mut i: usize = 0;
         let mut last = self.map.len();
@@ -82,12 +80,12 @@ impl DeferredTaskQueue {
                 continue;
             };
 
-            // PORT NOTE: reshaped for borrowck — copy fn ptr out before calling
+            // Copy the fn ptr out before calling (borrowck).
             let task = self.map.values()[i];
             // SAFETY: `nn` is the live `*mut T` registered by the caller; the
-            // callback contract (Zig `Type.onAutoFlush`) is that `task` may be
-            // invoked with exactly that pointer until it returns `false` or is
-            // explicitly unregistered.
+            // callback contract (`HasAutoFlusher::on_auto_flush`) is that
+            // `task` may be invoked with exactly that pointer until it returns
+            // `false` or is explicitly unregistered.
             if !unsafe { task(nn.as_ptr()) } {
                 self.map.swap_remove(&key);
                 last = self.map.len();
@@ -97,7 +95,3 @@ impl DeferredTaskQueue {
         }
     }
 }
-
-// Zig `deinit` only freed the map's backing storage; `ArrayHashMap: Drop` handles that.
-
-// ported from: src/event_loop/DeferredTaskQueue.zig
diff --git a/src/event_loop/EventLoopTimer.rs b/src/event_loop/EventLoopTimer.rs
index 45c3e96b1e5..c6ea31db0ba 100644
--- a/src/event_loop/EventLoopTimer.rs
+++ b/src/event_loop/EventLoopTimer.rs
@@ -21,12 +21,11 @@ const NS_PER_MS: i64 = bun_core::time::NS_PER_MS as i64;
 // intrusive heap node; the `match tag { … container_of … }` dispatch lives in
 // `bun_runtime::dispatch` because it names ~20 high-tier container types.
 //
-// LAYERING: Zig has no crate split here — `EventLoopTimer.fire` calls each
-// container directly. Rather than a runtime-registered fn-ptr (init-order
+// LAYERING: rather than a runtime-registered fn-ptr (init-order
 // hazard), the bodies are declared `extern "Rust"` and defined `#[no_mangle]`
 // in `bun_runtime`; the linker resolves them. No `AtomicPtr`, no registration.
 //
-// PERF(port): was inline switch — `__bun_js_timer_epoch` sits on the
+// PERF: `__bun_js_timer_epoch` sits on the
 // heap-compare path. Consider denormalizing `epoch` into `EventLoopTimer`
 // to drop the cross-crate call if profiling shows it matters.
 unsafe extern "Rust" {
@@ -121,9 +120,10 @@ impl EventLoopTimer {
                     // b. If the distance from a to b is large (greater than half the u25 range),
                     // it's more likely that b is older than a so the true distance is from b to a.
                     //
-                    // Zig epoch is `u25` so `-%` wraps mod 2^25. Rust stores it in a wider int,
-                    // so we mask the wrapping_sub result to 25 bits to preserve that semantics.
-                    // TODO(port): confirm Rust `epoch` field is masked to 25 bits on write too.
+                    // The epoch is logically a u25, stored in a wider int,
+                    // so we mask the wrapping_sub result to 25 bits to wrap mod 2^25.
+                    // (`TimerFlags::epoch`/`set_epoch` below mask to 25 bits on both read
+                    // and write, so both operands here are already < 2^25.)
                     const U25_MAX: u32 = (1 << 25) - 1;
                     return (b_epoch.wrapping_sub(a_epoch) & U25_MAX) < U25_MAX / 2;
                 }
@@ -135,9 +135,9 @@ impl EventLoopTimer {
     /// If self was created by set{Immediate,Timeout,Interval}, return its
     /// JS-timer epoch (used for stable ordering of equal-deadline timers).
     ///
-    /// PORT NOTE (b0): Zig `jsTimerInternalsFlags` did `@fieldParentPtr` into
+    /// The container_of dispatch into
     /// `TimeoutObject`/`ImmediateObject`/`AbortSignalTimeout` (all tier-6
-    /// runtime types). The container_of dispatch lives in
+    /// runtime types) lives in
     /// `bun_runtime::dispatch::__bun_js_timer_epoch` (link-time extern).
     /// Returns `None` for non-JS timer tags.
     #[inline]
@@ -149,13 +149,13 @@ impl EventLoopTimer {
 
     /// Fire the timer's callback.
     ///
-    /// PORT NOTE (b0): the `match self.tag { … container_of … }` body was
+    /// The `match self.tag { … container_of … }` body is
     /// hot-dispatch over ~20 tier-6 variant types (Subprocess, DevServer,
     /// PostgresSQLConnection, …). That match lives in
     /// `bun_runtime::dispatch::__bun_fire_timer` (link-time extern). `vm` is
     /// the erased `*mut VirtualMachine`.
     ///
-    /// PORT NOTE (noalias re-entrancy): takes `this: *mut Self`, NOT
+    /// Deliberately takes `this: *mut Self`, NOT
     /// `&mut self`. `__bun_fire_timer` dispatches via container_of into a
     /// tier-6 timer object whose JS callback can re-enter and re-derive a
     /// `&mut EventLoopTimer` to *this same node* (e.g. `clearTimeout()` →
@@ -221,15 +221,14 @@ impl Tag {
 
 pub struct TimerCallback {
     pub callback: fn(*mut TimerCallback),
-    // TODO(port): lifetime — opaque user ctx, no init/deinit found in src/event_loop/
+    // Opaque user ctx; ownership stays with whoever installs the callback.
     pub ctx: Option<NonNull<c_void>>,
     pub event_loop_timer: EventLoopTimer,
 }
 
 /// Stamp out one `unsafe fn $method(*const EventLoopTimer) -> *mut Self` per
 /// `(method => field)` pair: each recovers the embedding owner from a pointer
-/// to the named intrusive [`EventLoopTimer`] slot — Rust's typed analogue of
-/// Zig's inline `@fieldParentPtr("$field", t)`.
+/// to the named intrusive [`EventLoopTimer`] slot (typed container_of).
 ///
 /// The accessor layer exists only as a cross-crate visibility shim: the
 /// `__bun_fire_timer` tag-dispatch in `bun_runtime` cannot name private timer
@@ -294,7 +293,7 @@ pub enum State {
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `setTimeout` / `setInterval` / `setImmediate` discriminant stored in the
-/// `Flags` bitfield. Zig: `enum(u2)`.
+/// `Flags` bitfield (2 bits).
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Kind {
@@ -305,7 +304,7 @@ pub enum Kind {
 
 impl Kind {
     /// Widen to the `u32`-repr [`KindBig`] used in [`ID`](Timer::ID) so the
-    /// `{i32, u32}` pair `bitcast`s to a `u64` async-id. Zig: `Kind.big()`.
+    /// `{i32, u32}` pair `bitcast`s to a `u64` async-id.
     #[inline]
     pub fn big(self) -> KindBig {
         match self {
@@ -317,7 +316,7 @@ impl Kind {
 }
 
 /// Same variants as [`Kind`] but `#[repr(u32)]` so `ID { i32, KindBig }`
-/// is exactly one pointer / `u64`. Zig: `Kind.Big = enum(u32)`.
+/// is exactly one pointer / `u64`.
 #[repr(u32)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum KindBig {
@@ -333,7 +332,7 @@ impl From<Kind> for KindBig {
     }
 }
 
-/// Packed per-JS-timer state. Zig: `packed struct(u32)`. Layout (LSB→MSB):
+/// Packed per-JS-timer state in a `u32`. Layout (LSB→MSB):
 ///   epoch:u25, kind:u2, has_cleared_timer:1, is_keeping_event_loop_alive:1,
 ///   has_accessed_primitive:1, has_js_ref:1, in_callback:1
 ///
@@ -453,5 +452,3 @@ impl TimerFlags {
         }
     }
 }
-
-// ported from: src/event_loop/EventLoopTimer.zig
diff --git a/src/event_loop/ManagedTask.rs b/src/event_loop/ManagedTask.rs
index adc19341d50..669ab516fef 100644
--- a/src/event_loop/ManagedTask.rs
+++ b/src/event_loop/ManagedTask.rs
@@ -7,7 +7,7 @@ use core::ptr::NonNull;
 use crate::{JsResult, Task};
 
 pub struct ManagedTask {
-    // TODO(port): lifetime — opaque userdata pointer round-tripped through `new`/`run`
+    // Opaque userdata pointer round-tripped through `new`/`run`; raw by design.
     pub ctx: Option<NonNull<c_void>>,
     pub callback: fn(*mut c_void) -> JsResult<()>,
     pub cleanup: Option<fn(*mut c_void)>,
@@ -15,22 +15,17 @@ pub struct ManagedTask {
 
 impl ManagedTask {
     pub fn task(this: *mut ManagedTask) -> Task {
-        // PORT NOTE: Zig `Task.init(this)` mapped variant type → tag at comptime.
         // Per §Dispatch (tag+ptr), name the tag explicitly.
         Task::new(crate::task_tag::ManagedTask, this.cast())
     }
 
     /// # Safety
-    /// `this` must be the live `*mut ManagedTask` returned by `heap::alloc` in
-    /// `new()`; ownership transfers — `this` is freed (via `heap::take`) before
-    /// return on both Ok and Err paths.
+    /// `this` must be the live `*mut ManagedTask` embedded in a `Task` returned
+    /// by `new()`/`new_owned()`; ownership transfers — `this` is freed (via
+    /// `heap::take`) before return on both Ok and Err paths.
     pub unsafe fn run(this: *mut ManagedTask) -> JsResult<()> {
-        // Zig: @setRuntimeSafety(false) — no Rust equivalent; bounds/overflow checks
-        // are already off in release and there is nothing to elide here.
-
-        // SAFETY: `this` was produced by `heap::alloc` in `new` (Zig:
-        // `bun.default_allocator.create`). Reconstituting the Box here mirrors
-        // Zig's `defer bun.default_allocator.destroy(this)` — it drops at scope
+        // SAFETY: `this` was produced by `heap::into_raw` in `new`/`new_owned`
+        // (caller contract). Reconstituting the Box here frees it at scope
         // exit on both the Ok and Err paths.
         let this = unsafe { bun_core::heap::take(this) };
         let callback = this.callback;
@@ -45,14 +40,8 @@ impl ManagedTask {
         self.callback = noop;
     }
 
-    // PORT NOTE: reshaped for borrowck / const-generics limitation.
-    // Zig `pub fn New(comptime Type, comptime Callback) type { return struct { init, wrap } }`
-    // cannot be expressed in stable Rust because a fn value is not a valid const-generic
-    // parameter. The `wrap` trampoline (which `@ptrCast`/`@alignCast` the opaque ctx back
-    // to `*Type` and `@call(bun.callmod_inline, Callback, ...)`) is folded away by storing
+    // A per-(Type, Callback) trampoline is folded away by storing
     // the type-erased fn pointer directly — `fn(*mut T)` and `fn(*mut c_void)` share ABI.
-    // Callers: `ManagedTask.New(T, cb).init(ctx)` → `ManagedTask::new(ctx, cb)`.
-    // PERF(port): was comptime monomorphization (callmod_inline).
     pub fn new<T>(ctx: *mut T, callback: fn(*mut T) -> JsResult<()>) -> Task {
         let managed = bun_core::heap::into_raw(Box::new(ManagedTask {
             // SAFETY: `fn(*mut T) -> R` and `fn(*mut c_void) -> R` have identical
@@ -87,5 +76,3 @@ impl ManagedTask {
         ManagedTask::task(managed)
     }
 }
-
-// ported from: src/event_loop/ManagedTask.zig
diff --git a/src/event_loop/MiniEventLoop.rs b/src/event_loop/MiniEventLoop.rs
index d5a31fd9046..4c7446ce1ac 100644
--- a/src/event_loop/MiniEventLoop.rs
+++ b/src/event_loop/MiniEventLoop.rs
@@ -34,26 +34,25 @@ use crate::AnyTaskWithExtraContext::{AnyTaskWithExtraContext, New};
 // MOVE-IN: EventLoopHandle relocated from bun_jsc — see AnyEventLoop.rs.
 use crate::EventLoopHandle;
 
-/// The platform's native event loop type. Zig: `jsc.PlatformEventLoop`.
+/// The platform's native event loop type.
 #[cfg(not(windows))]
 pub type PlatformEventLoop = UwsLoop;
 #[cfg(windows)]
 pub type PlatformEventLoop = bun_sys::windows::libuv::Loop;
 
 // ─── Upward link-time externs (LAYERING) ────────────────────────────────────
-// Zig has no crate split here — `MiniEventLoop` reached `Blob.Store` /
-// `VirtualMachine.get()` directly. The bodies live in `bun_runtime` (which
+// The bodies live in `bun_runtime` (which
 // owns `webcore::Blob` / `jsc::VirtualMachine`) as `#[no_mangle]` Rust-ABI
 // fns; the linker resolves them. No `AtomicPtr`, no init-order hazard.
 unsafe extern "Rust" {
-    /// Constructs a `webcore::blob::Store` for stdout/stderr/stdin (Zig
-    /// rare_data.zig:551 inline `Blob.Store` ctor). Return value is an erased
+    /// Constructs a `webcore::blob::Store` for stdout/stderr/stdin.
+    /// Return value is an erased
     /// `*mut blob::Store` with intrusive refcount = 2; this crate only
     /// stores/forwards it. Defined in `bun_runtime::webcore::blob`.
     /// No caller-side preconditions (by-value args, allocates fresh).
     pub safe fn __bun_stdio_blob_store_new(fd: Fd, is_atty: bool, mode: Mode) -> *mut ();
-    /// Returns the thread's `*mut jsc::VirtualMachine` (Zig:
-    /// `jsc.VirtualMachine.get()`). Backs `JsKind::get_vm()`. Defined in
+    /// Returns the thread's `*mut jsc::VirtualMachine`.
+    /// Backs `JsKind::get_vm()`. Defined in
     /// `bun_runtime::jsc_hooks`. No caller-side preconditions (reads a
     /// thread-local; wrong-thread is a logic error, not UB).
     safe fn __bun_js_vm_get() -> *mut ();
@@ -76,7 +75,6 @@ unsafe impl bun_threading::Linked for AnyTaskWithExtraContext {
 }
 
 /// FIFO of raw task pointers (tasks are intrusive nodes; the queue does not own them).
-/// Zig: `bun.LinearFifo(*AnyTaskWithExtraContext, .Dynamic)`.
 type Queue = LinearFifo<*mut AnyTaskWithExtraContext, DynamicBuffer<*mut AnyTaskWithExtraContext>>;
 
 pub type Task = AnyTaskWithExtraContext;
@@ -84,42 +82,41 @@ pub type Task = AnyTaskWithExtraContext;
 pub struct MiniEventLoop<'a> {
     pub tasks: Queue,
     pub concurrent_tasks: ConcurrentTaskQueue,
-    // PORT NOTE: Zig `*uws.Loop` — raw pointer because the loop is C-owned
+    // Raw pointer because the loop is C-owned
     // (created by `uws_get_loop`/`us_create_loop`) and outlives this struct.
     pub loop_: *mut UwsLoop,
-    // PORT NOTE: `std.mem.Allocator param` field dropped — non-AST crate uses global mimalloc.
     pub file_polls_: Option<Box<FilePollStore>>,
-    /// Zig: `env: ?*bun.DotEnv.Loader` — mutable; callers (shell spawn,
+    /// Mutable; callers (shell spawn,
     /// `createNullDelimitedEnvMap`) write through it. Stored as `NonNull`
     /// (BACKREF) so [`EventLoopHandle::env`] can hand out a `*mut` with
     /// mutable provenance. `'a` is preserved via PhantomData below.
     pub env: Option<NonNull<DotEnvLoader<'a>>>,
-    // PORT NOTE: Zig field is `[]const u8` with mixed provenance (literal "", borrowed `cwd`
-    // param, or `allocator.dupe`). Never freed in `deinit`. Use Box<[u8]> and dupe on assign.
+    // Never freed in `deinit`. Use Box<[u8]> and dupe on assign.
     pub top_level_dir: Box<[u8]>,
-    // TODO(port): lifetime — opaque ctx assigned externally, only read/cleared here.
+    // Opaque ctx assigned externally; only read/cleared here.
     pub after_event_loop_callback_ctx: Option<NonNull<c_void>>,
     pub after_event_loop_callback: Option<unsafe extern "C" fn(*mut c_void)>,
     pub pipe_read_buffer: Option<Box<PipeReadBuffer>>,
     // SAFETY: erased `*mut webcore::blob::Store` (tier-6). Constructed via
-    // `__bun_stdio_blob_store_new`; intrusive-refcounted on the runtime side.
-    // TODO(port): Blob.Store uses intrusive ref_count (constructed with ref_count=2);
-    // LIFETIMES.tsv classifies as Arc but IntrusiveArc<BlobStore> may be required for FFI compat.
+    // `__bun_stdio_blob_store_new` with ref_count=2: one owning intrusive ref
+    // held by this MiniEventLoop (intentionally never released — the
+    // MiniEventLoop is a never-freed thread-lifetime singleton),
+    // one for the eventual Blob consumer. If a teardown path is ever added it
+    // must release via `__bun_stdio_blob_store_deinit`, as `rare_data.rs` does.
     pub stdout_store: Option<NonNull<()>>,
     pub stderr_store: Option<NonNull<()>>,
 }
 
 thread_local! {
     pub static GLOBAL_INITIALIZED: Cell<bool> = const { Cell::new(false) };
-    // PORT NOTE: Zig `threadlocal var global: *MiniEventLoop = undefined;` — raw pointer
-    // because the global is heap-allocated once (heap::alloc) and lives for the
-    // thread's lifetime (a true thread-lifetime singleton; never freed in Zig either).
+    // Raw pointer because the global is heap-allocated once (heap::alloc) and lives
+    // for the thread's lifetime (a true thread-lifetime singleton; never freed).
     pub static GLOBAL: Cell<*mut MiniEventLoop<'static>> = const { Cell::new(core::ptr::null_mut()) };
 }
 
-/// Returns the thread-local `*mut MiniEventLoop` (Zig: `*MiniEventLoop`).
+/// Returns the thread-local `*mut MiniEventLoop`.
 ///
-/// PORT NOTE (aliasing): Zig's `*T` aliases freely; returning `&'static mut`
+/// Returning `&'static mut`
 /// here would let two calls (or `init_global` + `MiniKind::get_vm`) hold
 /// overlapping `&mut` to the same allocation — UB. Return the raw pointer;
 /// callers reborrow `&mut` for the scope they need.
@@ -133,10 +130,9 @@ pub fn init_global(
         return GLOBAL.with(|g| g.get());
     }
     let loop_ = MiniEventLoop::init();
-    // PORT NOTE: §Forbidden bans `Box::leak` for `&'static`; this is a
+    // §Forbidden bans `Box::leak` for `&'static`; this is a
     // thread-lifetime singleton, so use `heap::alloc` (intrusive ownership)
-    // and store the raw pointer in the thread-local — same as Zig
-    // `bun.default_allocator.create` + `threadlocal var global: *MiniEventLoop`.
+    // and store the raw pointer in the thread-local.
     let global_ptr: *mut MiniEventLoop<'static> = bun_core::heap::into_raw(Box::new(loop_));
     // SAFETY: `global_ptr` was just allocated via `heap::alloc`; this thread
     // holds the only reference for the duration of first-init. The `GLOBAL`
@@ -147,9 +143,9 @@ pub fn init_global(
     // raw ptr.
     let global = unsafe { &mut *global_ptr };
 
-    // PORT NOTE: `InternalLoopData::set_parent_event_loop` (typed) lives in a
+    // `InternalLoopData::set_parent_event_loop` (typed) lives in a
     // higher tier; the sys-level API is `set_parent_raw(tag, ptr)`. Tag 1 = JS,
-    // tag 2 = mini (matches Zig `EventLoopHandle` discriminant + 1).
+    // tag 2 = mini (`EventLoopHandle` discriminant + 1).
     {
         let (tag, ptr) = EventLoopHandle::init_mini(global_ptr).into_tag_ptr();
         // SAFETY: see `loop_ptr()` invariant.
@@ -160,8 +156,7 @@ pub fn init_global(
         };
     }
 
-    // PORT NOTE: Zig `bun.DotEnv.instance` is a `?*Loader` global. The Rust
-    // port stores it as `AtomicPtr<Loader<'static>>`.
+    // The process-global loader is stored as `AtomicPtr<Loader<'static>>`.
     global.env = env.map(NonNull::from).or_else(|| {
         NonNull::new(
             dotenv::INSTANCE
@@ -170,9 +165,9 @@ pub fn init_global(
         )
     });
     if global.env.is_none() {
-        // Thread-lifetime singletons (matches Zig `bun.default_allocator.create`).
+        // Thread-lifetime singletons.
         let map: *mut dotenv::Map = bun_core::heap::into_raw(Box::new(dotenv::Map::init()));
-        // SAFETY: `map` lives for the thread (singleton); never freed (Zig parity).
+        // SAFETY: `map` lives for the thread (singleton); never freed.
         let loader =
             bun_core::heap::into_raw_nn(Box::new(DotEnvLoader::init(unsafe { &mut *map })));
         global.env = Some(loader);
@@ -180,7 +175,7 @@ pub fn init_global(
 
     // Set top_level_dir from provided cwd or get current working directory
     if let Some(dir) = cwd {
-        // PORT NOTE: Zig borrowed `dir`; we dupe to keep Box<[u8]> ownership uniform.
+        // Dupe to keep Box<[u8]> ownership uniform.
         global.top_level_dir = Box::<[u8]>::from(dir);
     } else if global.top_level_dir.is_empty() {
         let mut buf = bun_paths::PathBuffer::uninit();
@@ -206,7 +201,7 @@ pub fn init_global(
 }
 
 impl<'a> MiniEventLoop<'a> {
-    /// Raw `*mut uws::Loop` (Zig: `this.loop`).
+    /// Raw `*mut uws::Loop`.
     ///
     /// This is the sole accessor for the `loop_` field. A `&mut UwsLoop`-
     /// returning accessor is intentionally **not** provided: `UwsLoop::tick()`
@@ -224,7 +219,7 @@ impl<'a> MiniEventLoop<'a> {
         self.loop_
     }
 
-    /// Raw pointer to the `DotEnv::Loader` backref (Zig: `this.env.?`).
+    /// Raw pointer to the `DotEnv::Loader` backref.
     ///
     /// Returns `None` until [`init_global`] populates it. Neither a `&`- nor
     /// a `&mut`-returning accessor is provided: the loader may be shared via
@@ -238,8 +233,7 @@ impl<'a> MiniEventLoop<'a> {
     /// own SAFETY contract instead (mirrors [`loop_ptr`](Self::loop_ptr)).
     ///
     /// SAFETY (invariant): when `Some`, points to a thread-/process-lifetime
-    /// loader set in `init_global` that outlives `self` (never freed — Zig
-    /// parity).
+    /// loader set in `init_global` that outlives `self` (never freed).
     #[inline]
     pub fn env_ptr(&self) -> Option<NonNull<DotEnvLoader<'a>>> {
         self.env
@@ -269,7 +263,7 @@ impl<'a> MiniEventLoop<'a> {
             self.after_event_loop_callback = None;
             self.after_event_loop_callback_ctx = None;
             // SAFETY: `cb` is a C-ABI callback registered by the owner of `ctx`; the owner
-            // guarantees `ctx` is valid until the callback fires (Zig invariant).
+            // guarantees `ctx` is valid until the callback fires.
             unsafe { cb(ctx.map_or(core::ptr::null_mut(), |p| p.as_ptr())) };
         }
     }
@@ -339,20 +333,16 @@ impl<'a> MiniEventLoop<'a> {
 
         let mut iter = concurrent.iterator();
         let start_count = self.tasks.readable_length();
-        // Zig resets `self.tasks.head = 0` when `start_count == 0` so
-        // `writableSlice(0)` spans the whole buffer. That reset is
-        // load-bearing: `ensure_unused_capacity` early-returns without
-        // realigning when capacity is already sufficient, and
-        // `writable_slice(0)` only yields the first contiguous segment
-        // `buf[head+count..]` — so an empty fifo with `head > 0` would yield a
-        // short slice and the loop would `break` early, silently dropping
-        // tasks already popped from `concurrent`. Use `writable_with_size`,
-        // which realigns when the contiguous slice is too short, so the
-        // returned slice is always `>= count` long.
+        // `ensure_unused_capacity` early-returns without realigning when
+        // capacity is already sufficient, and `writable_slice(0)` only yields
+        // the first contiguous segment `buf[head+count..]` — so an empty fifo
+        // with `head > 0` would yield a short slice and the loop would `break`
+        // early, silently dropping tasks already popped from `concurrent`. Use
+        // `writable_with_size`, which realigns when the contiguous slice is
+        // too short, so the returned slice is always `>= count` long.
         //
-        // PORT NOTE: reshaped for borrowck — Zig held `writable` (&mut into self.tasks) while
-        // bumping `self.tasks.count` per-iteration (overlapping &mut). Fill the writable slice
-        // first, track items written in a local, then commit via `update()` after the borrow ends.
+        // Fill the writable slice first, track items written in a local, then
+        // commit via `update()` after the borrow ends.
         let mut written: usize = 0;
         {
             let mut writable = self.tasks.writable_with_size(count).expect("unreachable");
@@ -383,7 +373,6 @@ impl<'a> MiniEventLoop<'a> {
                 (*self.loop_ptr()).tick();
                 (*self.loop_ptr()).dec();
             }
-            // PORT NOTE: Zig `defer this.onAfterEventLoop()` was block-scoped to this `if`.
             self.on_after_event_loop();
         }
 
@@ -408,7 +397,6 @@ impl<'a> MiniEventLoop<'a> {
                 break;
             }
         }
-        // PORT NOTE: Zig `defer this.onAfterEventLoop()` at fn scope; no early returns above.
         self.on_after_event_loop();
     }
 
@@ -416,25 +404,16 @@ impl<'a> MiniEventLoop<'a> {
     where
         F: Fn(*mut c_void) -> bool,
     {
-        // PERF(port): Zig `comptime isDone: *const fn` monomorphized per callsite; generic `F`
-        // here also monomorphizes — should match. `tick_once` is `#[inline]` so codegen is
+        // Generic `F` monomorphizes per callsite. `tick_once` is `#[inline]` so codegen is
         // identical to the previously hand-inlined body.
         while !is_done(context) {
             self.tick_once(context);
         }
     }
 
-    /// Zig: `enqueueTask(comptime Context, ctx, comptime Callback, comptime field)`.
-    ///
-    /// `comptime field: std.meta.FieldEnum(Context)` + `@field(ctx, name)` is replaced
-    /// per PORTING.md (§reflection) with a caller-supplied `field_offset =
-    /// core::mem::offset_of!(C, <field>)` into the embedded `AnyTaskWithExtraContext`.
-    ///
-    /// PORT NOTE: the Zig body is dead code — it calls `Task.New(Context, Callback)`
-    /// (wrong arity; `New` takes 3 type args) and `this.enqueueJSCTask(...)` (no such
-    /// decl). Zig's lazy analysis lets this compile because no caller exists. The
-    /// faithful port writes to `self.tasks` (the local non-concurrent FIFO), which is
-    /// the only plausible target for a `*JSCTask` push on a MiniEventLoop.
+    /// The caller supplies `field_offset = core::mem::offset_of!(C, <field>)` of the
+    /// embedded `AnyTaskWithExtraContext`; the task is written there and pushed onto
+    /// `self.tasks` (the local non-concurrent FIFO).
     ///
     /// # Safety
     /// `field_offset == offset_of!(C, <field>)` where `<field>: AnyTaskWithExtraContext`,
@@ -447,10 +426,8 @@ impl<'a> MiniEventLoop<'a> {
     ) {
         // SAFETY: caller contract — see fn `# Safety`.
         let task = unsafe { ctx.byte_add(field_offset).cast::<AnyTaskWithExtraContext>() };
-        // Zig: `@field(ctx, name) = TaskType.init(ctx);`
         // SAFETY: `task` points at a properly aligned `AnyTaskWithExtraContext` field of `*ctx`.
         unsafe { task.write(New::<C, ()>::init(ctx, callback)) };
-        // Zig: `this.enqueueJSCTask(&@field(ctx, name))` — see PORT NOTE above.
         self.tasks.write_item(task).expect("unreachable");
     }
 
@@ -462,12 +439,8 @@ impl<'a> MiniEventLoop<'a> {
         unsafe { (*self.loop_ptr()).wakeup() };
     }
 
-    /// Zig: `enqueueTaskConcurrentWithExtraCtx(comptime Context, comptime ParentContext,
-    /// ctx, comptime Callback, comptime field)`.
-    ///
-    /// `comptime field: std.meta.FieldEnum(Context)` + `@field(ctx, name)` is replaced
-    /// per PORTING.md (§reflection) with a caller-supplied `field_offset =
-    /// core::mem::offset_of!(C, <field>)` into the embedded `AnyTaskWithExtraContext`.
+    /// The caller supplies `field_offset = core::mem::offset_of!(C, <field>)` of the
+    /// embedded `AnyTaskWithExtraContext`.
     ///
     /// # Safety
     /// `field_offset == offset_of!(C, <field>)` where `<field>: AnyTaskWithExtraContext`,
@@ -479,10 +452,8 @@ impl<'a> MiniEventLoop<'a> {
         callback: fn(*mut C, *mut P),
         field_offset: usize,
     ) {
-        // Zig: jsc.markBinding(@src()) — debug-only source marker; no Rust equivalent needed.
         // SAFETY: caller contract — see fn `# Safety`.
         let task = unsafe { ctx.byte_add(field_offset).cast::<AnyTaskWithExtraContext>() };
-        // Zig: `@field(ctx, name) = TaskType.init(ctx);`
         // SAFETY: `task` points at a properly aligned `AnyTaskWithExtraContext` field of `*ctx`.
         unsafe { task.write(New::<C, P>::init(ctx, callback)) };
 
@@ -495,8 +466,7 @@ impl<'a> MiniEventLoop<'a> {
     }
 
     /// Lazy-init helper shared by [`stderr`]/[`stdout`]: `fstat → __bun_stdio_blob_store_new → cache`.
-    /// Zig builds Blob.Store with intrusive `ref_count = 2` and
-    /// `.data = .file{ pathlike = .{ .fd }, is_atty, mode }`.
+    /// The store is built with intrusive `ref_count = 2`.
     #[inline]
     fn lazy_stdio_store(slot: &mut Option<NonNull<()>>, fd: Fd, is_atty: bool) -> *mut () {
         if slot.is_none() {
@@ -512,7 +482,7 @@ impl<'a> MiniEventLoop<'a> {
 
     /// Returns an erased `*mut webcore::blob::Store`. Callers in tier-6 cast back.
     pub fn stderr(&mut self) -> *mut () {
-        // NB: spec (MiniEventLoop.zig:243) deliberately uses `FD.fromUV(2)` here, not
+        // NB: deliberately uses `Fd::from_uv(2)` here, not
         // `Fd::stderr()` — Windows uv-fd vs native-handle distinction. Do not "tidy".
         Self::lazy_stdio_store(
             &mut self.stderr_store,
@@ -573,7 +543,7 @@ impl<'a> MiniEventLoop<'a> {
 
 impl<'a> Drop for MiniEventLoop<'a> {
     fn drop(&mut self) {
-        // PORT NOTE: `tasks.deinit()` is implicit via Queue's Drop.
+        // `tasks.deinit()` is implicit via Queue's Drop.
         debug_assert!(self.concurrent_tasks.is_empty());
     }
 }
@@ -581,10 +551,10 @@ impl<'a> Drop for MiniEventLoop<'a> {
 // ───────────────────────────── MiniVM ─────────────────────────────
 
 pub struct MiniVM<'a> {
-    // PORT NOTE: LIFETIMES.tsv classifies this BORROW_PARAM `&'a`, but `file_polls()`
+    // LIFETIMES.tsv classifies this BORROW_PARAM `&'a`, but `file_polls()`
     // mutates the loop (lazy-inits the store). Hold `&'a mut` instead of
     // casting `&T`→`&mut T` (UB, and forbidden by PORTING.md "no raw pointers to silence
-    // borrowck"). Zig's `*MiniEventLoop` was always mutable.
+    // borrowck").
     pub mini: &'a mut MiniEventLoop<'a>,
 }
 
@@ -605,9 +575,7 @@ impl<'a> MiniVM<'a> {
 
     #[inline]
     pub fn increment_pending_unref_counter(&self) {
-        // Zig spec body: `_ = this; @panic("FIXME TODO");` — MiniEventLoop has no
-        // pending_unref_counter (only `jsc.VirtualMachine` does). This is the REAL
-        // ported body, not a stub.
+        // MiniEventLoop has no pending_unref_counter (only `jsc.VirtualMachine` does).
         let _ = self;
         panic!("FIXME TODO");
     }
@@ -646,28 +614,26 @@ impl EventLoopKindT for JsKind {
 
 impl EventLoopKindT for MiniKind {
     type Loop = MiniEventLoop<'static>;
-    // PORT NOTE (aliasing): Zig `refType() = *MiniEventLoop` is a freely-aliasing
-    // pointer. Returning `&'static mut` would let two `get_vm()` calls (or
+    // Returning `&'static mut` would let two `get_vm()` calls (or
     // `get_vm()` + `init_global()`) hold overlapping `&mut` — UB. Return the raw
     // pointer (matches `JsKind::Ref = *mut ()`); callers reborrow scoped `&mut`.
     type Ref = *mut MiniEventLoop<'static>;
     fn get_vm() -> Self::Ref {
-        // Caller must have called `init_global()` first (Zig invariant: `global`
-        // is set). No `&mut` materialized here — raw-ptr-only access.
+        // Caller must have called `init_global()` first.
+        // No `&mut` materialized here — raw-ptr-only access.
         GLOBAL.with(|g| g.get())
     }
 }
 
 // ───────────────────────────── AbstractVM ─────────────────────────────
 
-/// Zig `AbstractVM(inner: anytype)` dispatches on `@TypeOf(inner)` to wrap either a
-/// `*VirtualMachine` or a `*MiniEventLoop`. Rust models this as a trait implemented for both.
+/// Wraps either a `*VirtualMachine` or a `*MiniEventLoop`: a trait implemented for both.
 pub trait AbstractVM<'a> {
     type Wrapped;
     fn abstract_vm(self) -> Self::Wrapped;
 }
 
-// PORT NOTE (b0): `impl AbstractVM for &VirtualMachine` cannot live here
+// `impl AbstractVM for &VirtualMachine` cannot live here
 // without naming the tier-6 `VirtualMachine` type. The impl moves to
 // `bun_runtime` (move-in pass), which constructs `JsVM { vm, vtable }`.
 
@@ -677,5 +643,3 @@ impl<'a> AbstractVM<'a> for &'a mut MiniEventLoop<'a> {
         MiniVM::init(self)
     }
 }
-
-// ported from: src/event_loop/MiniEventLoop.zig
diff --git a/src/event_loop/SpawnSyncEventLoop.rs b/src/event_loop/SpawnSyncEventLoop.rs
index 23a05c6975a..ab44c222ad1 100644
--- a/src/event_loop/SpawnSyncEventLoop.rs
+++ b/src/event_loop/SpawnSyncEventLoop.rs
@@ -37,10 +37,9 @@ pub type VmEventLoopHandle = Option<NonNull<uws::Loop>>;
 pub type VmEventLoopHandle = Option<NonNull<libuv::Loop>>;
 
 // LAYERING: `bun_event_loop` sits below `bun_jsc`, so it cannot name
-// `jsc::EventLoop` / `jsc::VirtualMachine`. Zig (`SpawnSyncEventLoop.zig`) did
-// inline field access. The bodies live in `bun_jsc` as `#[no_mangle]` Rust-ABI
-// fns, declared here as `extern "Rust"` and resolved at link time — no vtable,
-// no `AtomicPtr`, no init-order hazard. PERF(port): was inline field access —
+// `jsc::EventLoop` / `jsc::VirtualMachine`. The bodies live in `bun_jsc` as
+// `#[no_mangle]` Rust-ABI fns, declared here as `extern "Rust"` and resolved
+// at link time — no vtable, no `AtomicPtr`, no init-order hazard.
 // spawnSync is per-process-spawn, not per-tick, so the cross-crate call is fine.
 // All bodies are defined as safe `pub fn` in `bun_jsc::event_loop` (the impl
 // encapsulates the erased-pointer derefs), so the declarations are `safe fn` —
@@ -62,8 +61,7 @@ unsafe extern "Rust" {
 }
 
 /// RAII scope that sets `vm.suppress_microtask_drain = true` for its lifetime
-/// and restores the prior value on drop (mirrors Zig's
-/// `defer vm.suppress_microtask_drain = prev`).
+/// and restores the prior value on drop.
 struct SuppressMicrotaskDrain {
     vm: *mut (),
     prev: bool,
@@ -97,7 +95,7 @@ pub struct SpawnSyncEventLoop {
     vm: *mut (),
 
     /// Completely separate uws.Loop instance - critical for avoiding recursive event loop execution
-    // TODO(port): lifetime — FFI-owned handle created via `uws::Loop::create`, freed in Drop via
+    // FFI-owned handle created via `uws::Loop::create`, freed in Drop via
     // `Loop::deinit`. Kept as raw because `uws::Loop` is an opaque C type and its address is
     // stored back into `internal_loop_data` (self-referential w.r.t. `event_loop`).
     uws_loop: NonNull<uws::Loop>,
@@ -110,7 +108,7 @@ pub struct SpawnSyncEventLoop {
     uv_timer: Option<NonNull<libuv::Timer>>,
     // ALIASING: `Cell` because on Windows the libuv timer callback (`on_uv_timer`) writes this
     // field re-entrantly from inside `tick_with_timeout`'s uws tick while that frame still holds
-    // `&mut self` (LLVM `noalias`). Zig's `*T` freely aliases; in Rust the field must be
+    // `&mut self` (LLVM `noalias`). The field must be
     // interior-mutable so the re-entrant write is sound under Stacked Borrows.
     did_timeout: Cell<bool>,
 }
@@ -133,8 +131,7 @@ mod handler {
         // No-op: no post-tick work needed for spawnSync
     }
 
-    /// Adapter for `uws::Loop::create<H: LoopHandler>()` — Zig's
-    /// `comptime Handler` with `wakeup`/`pre`/`post` decls maps to a trait
+    /// Adapter for `uws::Loop::create<H: LoopHandler>()` — a trait
     /// with associated `const fn`-ptr slots.
     pub(super) struct Handler;
     impl uws::LoopHandler for Handler {
@@ -145,16 +142,15 @@ mod handler {
 }
 
 impl SpawnSyncEventLoop {
-    // TODO(port): in-place init — `self.event_loop` is captured by
-    // `setParentEventLoop` below, so `Self` must not move after `init` returns.
-    // Zig caller passes `undefined` storage, hence `MaybeUninit<Self>` (out-param ctor exception).
-    // TODO(refactor): consider `Pin<&mut Self>` or document the no-move invariant at the caller.
+    // In-place init: `self.event_loop` is captured by `setParentEventLoop`
+    // below, so `Self` MUST NOT move after `init` returns (no-move invariant
+    // upheld by the caller). The caller provides uninitialized storage, hence
+    // `MaybeUninit<Self>` (out-param ctor exception).
     pub fn init(
         this: &mut core::mem::MaybeUninit<Self>,
         vm: *mut (), /* SAFETY: erased *mut VirtualMachine */
     ) {
-        // PORT NOTE: Zig passes a comptime `Handler` type with wakeup/pre/post decls.
-        // The Rust wrapper takes a `LoopHandler` impl with associated-const fn ptrs.
+        // `uws::Loop::create` takes a `LoopHandler` impl with associated-const fn ptrs.
         let loop_ = uws::Loop::create::<handler::Handler>();
 
         let loop_ =
@@ -166,7 +162,7 @@ impl SpawnSyncEventLoop {
 
         this.write(Self {
             uws_loop: loop_,
-            original_event_loop_handle: None, // = undefined in Zig; overwritten in `prepare`
+            original_event_loop_handle: None, // overwritten in `prepare`
             #[cfg(windows)]
             uv_timer: None,
             did_timeout: Cell::new(false),
@@ -177,7 +173,7 @@ impl SpawnSyncEventLoop {
         // Set up the loop's internal data to point to this isolated event loop
         // SAFETY: `this` was fully written immediately above so `assume_init_mut` is sound.
         let this = unsafe { this.assume_init_mut() };
-        // PORT NOTE: sys-level API is `set_parent_raw(tag, ptr)`; the typed
+        // sys-level API is `set_parent_raw(tag, ptr)`; the typed
         // `set_parent_event_loop` lives in a higher tier. Tag 1 = JS, tag 2 = mini.
         // `this.event_loop` is the live heap-owned `*mut jsc::EventLoop`
         // returned by `__bun_spawn_sync_create_event_loop` immediately above —
@@ -192,8 +188,7 @@ impl SpawnSyncEventLoop {
     /// Erased `*mut bun_jsc::event_loop::EventLoop` (heap-owned via
     /// `__bun_spawn_sync_create_event_loop`). `bun_event_loop` sits below
     /// `bun_jsc` so the concrete type is opaque here; callers in higher tiers
-    /// cast back. See `js_bun_spawn_bindings::spawn_maybe_sync` (Zig:
-    /// `&jsc_vm.rareData().spawnSyncEventLoop(jsc_vm).event_loop`).
+    /// cast back. See `js_bun_spawn_bindings::spawn_maybe_sync`.
     ///
     /// Intentionally raw-ptr (no `&`-returning variant): the pointee type is
     /// erased at this layer, and the `jsc::EventLoop` is mutated across the
@@ -295,7 +290,7 @@ impl Drop for SpawnSyncEventLoop {
             }
         }
 
-        // PORT NOTE: Zig order was `event_loop.deinit()` then `uws_loop.deinit()`.
+        // Destroy the event loop before the uws loop.
         __bun_spawn_sync_destroy_event_loop(self.event_loop);
         // SAFETY: uws_loop was returned by `us_create_loop` in `init` and not yet freed.
         unsafe { uws::Loop::destroy(self.uws_loop.as_ptr()) };
@@ -354,8 +349,7 @@ extern "C" fn on_uv_timer(timer_: *mut libuv::Timer) {
     //
     // ALIASING: this callback fires re-entrantly from inside `tick_with_timeout`'s uws tick
     // (uv_run) while that frame still holds `&mut self` (LLVM `noalias`) AND a live
-    // `&mut uws::Loop` (Loop::tick_with_timeout takes `&mut self`). Zig's `*T` freely aliases,
-    // but in Rust we must not:
+    // `&mut uws::Loop` (Loop::tick_with_timeout takes `&mut self`). We must not:
     //   (a) materialize a second `&mut SpawnSyncEventLoop` here, nor
     //   (b) read `(*this).uws_loop` — the outer frame's `&mut self` access to `uws_loop` at the
     //       tick call popped the raw `*mut Self`'s Stacked-Borrows tag at those bytes, and the
@@ -425,7 +419,6 @@ impl SpawnSyncEventLoop {
         // On POSIX, the uws tick only polls I/O; callbacks are dispatched later
         // via the task queue, but we set the flag here uniformly for safety.
         let _suppress = SuppressMicrotaskDrain::new(self.vm);
-        // PORT NOTE: Zig `defer` restores at scope exit; RAII Drop mirrors that.
 
         // Tick the isolated uws loop with the specified timeout
         // This will only process I/O related to this subprocess
@@ -497,5 +490,3 @@ impl SpawnSyncEventLoop {
         self.uws_loop().is_active()
     }
 }
-
-// ported from: src/event_loop/SpawnSyncEventLoop.zig
diff --git a/src/event_loop/lib.rs b/src/event_loop/lib.rs
index e970c9fa131..8a9a5dab864 100644
--- a/src/event_loop/lib.rs
+++ b/src/event_loop/lib.rs
@@ -12,9 +12,9 @@ pub mod ManagedTask;
 // AnyEventLoop / SpawnSyncEventLoop / MiniEventLoop.
 // `InternalLoopData::set_parent_event_loop`
 // is reached via the lower-tier `set_parent_raw(tag, ptr)` +
-// `EventLoopHandle::into_tag_ptr()`. Windows-only `MiniVM::platform_event_loop`
-// (`uws::Loop::uv_loop`) remains `#[cfg(windows)]`-guarded with a
-// `TODO(port)` marker; the POSIX build is gate-free.
+// `EventLoopHandle::into_tag_ptr()`. The Windows-only `uv_loop` projection
+// lives on `EventLoopHandle::uv_loop` (`#[cfg(windows)]`); the POSIX build is
+// gate-free.
 // ────────────────────────────────────────────────────────────────────────────
 
 #[path = "MiniEventLoop.rs"]
diff --git a/src/exe_format/elf.rs b/src/exe_format/elf.rs
index 9efb66f9644..2c9bd199ca0 100644
--- a/src/exe_format/elf.rs
+++ b/src/exe_format/elf.rs
@@ -90,7 +90,7 @@ impl ElfFile {
                 return;
             }
 
-            // PORT NOTE: reshaped for borrowck — compute replacement under an
+            // reshaped for borrowck — compute replacement under an
             // immutable borrow, then take a mutable borrow for the writes.
             let replacement: &'static [u8] = {
                 let interp_region = &self.data[interp_offset..][..interp_filesz];
@@ -169,7 +169,7 @@ impl ElfFile {
         if strtab_end > self.data.len() as u64 {
             return;
         }
-        // PORT NOTE: reshaped for borrowck — copy strtab bounds out so we can
+        // reshaped for borrowck — copy strtab bounds out so we can
         // re-borrow self.data mutably below.
         let strtab_off = usize::try_from(strtab_shdr.sh_offset).expect("int cast");
         let strtab_len = usize::try_from(strtab_shdr.sh_size).expect("int cast");
@@ -254,7 +254,7 @@ impl ElfFile {
         // Place the new data at a page-aligned virtual address past every
         // existing mapping. page_size is ≥ 128 so this also guarantees the
         // 128-byte alignment that JSC's bytecode cache requires — see
-        // `target_mod = 120` in StandaloneModuleGraph.zig, which assumes the
+        // `target_mod = 120` in StandaloneModuleGraph.rs, which assumes the
         // payload starts on a 128-byte boundary so bytecode at payload-offset
         // 120 lands 128-aligned once the 8-byte `[u64 size]` header is
         // accounted for. A non-page-aligned `new_vaddr` (e.g. one inheriting
@@ -309,9 +309,8 @@ impl ElfFile {
 
         let total_new_size: u64 = move_dst_end;
 
-        // PERF(port): Zig used ensureTotalCapacity + raw len bump leaving the
-        // new region uninitialized; resize() zero-fills. The explicit @memset
-        // calls below become partially redundant but stay for parity.
+        // resize() zero-fills, so the explicit zero-fills below are
+        // partially redundant but harmless.
         let total_new_size_usz = usize::try_from(total_new_size).expect("int cast");
         self.data
             .reserve(total_new_size_usz.saturating_sub(self.data.len()));
@@ -430,8 +429,6 @@ impl ElfFile {
     }
 
     pub fn write(&self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig used `writer: anytype` (`std.Io.Writer`); std::io::Write
-        // is the canonical Rust equivalent. bun_io has no Write trait.
         writer.write_all(&self.data)?;
         Ok(())
     }
@@ -501,9 +498,6 @@ impl ElfFile {
     }
 }
 
-// `deinit` in Zig only freed `data` and destroyed `self` — both handled by
-// `Drop` on `Vec<u8>` / `Box<ElfFile>`. No explicit `Drop` impl needed.
-
 struct BunSectionInfo {
     /// File offset of the .bun section's data (sh_offset).
     file_offset: u64,
@@ -578,7 +572,7 @@ fn host_uses_nix_store_interpreter() -> bool {
             // Test-only override: lets #29290's regression test force the
             // Nix-host branch without mutating `/etc/NIXOS` on the shared
             // rootfs (which would poison concurrent test workers).
-            // PORT NOTE: env_var .get() returns Option<bool> (nullability
+            // env_var .get() returns Option<bool> (nullability
             // collapsed in the macro port); default-false makes None ≡ false.
             if env_var::BUN_DEBUG_FORCE_NIX_HOST.get() == Some(true) {
                 return true;
@@ -610,7 +604,7 @@ fn host_uses_nix_store_interpreter() -> bool {
                 Ok(fd) => fd,
                 Err(_) => return false,
             };
-            // PORT NOTE: close moved up; fd not needed after read (was `defer fd.close()`).
+            // close moved up; fd not needed after read (was `defer fd.close()`).
             let n = match bun_sys::read(fd, &mut buf) {
                 Ok(n) => n,
                 Err(_) => {
@@ -662,8 +656,7 @@ fn host_uses_nix_store_interpreter() -> bool {
     }
 }
 
-// --- ELF definitions (from Zig std.elf; defined locally for cross-platform use) ---
-// TODO(port): consider moving to a shared bun_exe_format::elf_defs module.
+// --- ELF definitions (defined locally for cross-platform use) ---
 
 const EI_CLASS: usize = 4;
 const EI_DATA: usize = 5;
@@ -740,11 +733,9 @@ pub(crate) struct Elf64_Shdr {
     pub sh_entsize: u64,
 }
 
-// --- byte helpers (Zig std.mem.writeInt) ---
+// --- byte helpers ---
 
 #[inline]
 fn write_u64_le(bytes: &mut [u8], value: u64) {
     bytes[..8].copy_from_slice(&value.to_le_bytes());
 }
-
-// ported from: src/exe_format/elf.zig
diff --git a/src/exe_format/lib.rs b/src/exe_format/lib.rs
index c3f013b9cf2..5897c753d62 100644
--- a/src/exe_format/lib.rs
+++ b/src/exe_format/lib.rs
@@ -5,7 +5,7 @@ pub mod macho;
 pub mod macho_types;
 pub mod pe;
 
-// --- byte helpers (Zig std.mem.bytesAsValue / asBytes) ---
+// --- byte helpers ---
 //
 // Shared by `elf.rs` and `macho.rs` for unaligned in-place read/modify/write of
 // `#[repr(C)]` POD header structs (Elf64_*, mach-o load commands) that live at
diff --git a/src/exe_format/macho.rs b/src/exe_format/macho.rs
index 5020f3a057e..7a68eabf0bf 100644
--- a/src/exe_format/macho.rs
+++ b/src/exe_format/macho.rs
@@ -40,8 +40,7 @@ pub struct MachoFile {
     pub section: macho::section_64,
 }
 
-/// Port of Zig `Shifter.shift(value, comptime fields)` — `inline for` + `@field` over a
-/// comptime field-name list. Expands to one `shift_one` call per named field.
+/// Expands to one `shift_one` call per named field.
 macro_rules! shift_fields {
     ($shifter:expr, $value:expr, $($field:ident),+ $(,)?) => {{
         $( $shifter.shift_one(&mut $value.$field)?; )+
@@ -71,8 +70,6 @@ impl MachoFile {
         }))
     }
 
-    // Zig `deinit` only frees `data` and destroys self — both handled by Drop on Vec/Box.
-
     pub fn write_section(&mut self, data: &[u8]) -> Result<(), MachoError> {
         let blob_alignment: u64 = 16 * 1024;
         const PAGE_SIZE: u64 = 1 << 12;
@@ -94,7 +91,7 @@ impl MachoFile {
 
         let mut found_bun = false;
 
-        // PORT NOTE: reshaped for borrowck — capture base ptr as usize before iterating so we can
+        // reshaped for borrowck — capture base ptr as usize before iterating so we can
         // compute byte offsets without holding a borrow of self.data across the mutable writes below.
         let base_addr = self.data.as_ptr() as usize;
         let mut iter = self.iterator();
@@ -473,8 +470,6 @@ impl MachoFile {
     }
 
     pub fn build(&self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig used `writer: anytype`; std::io::Write is the canonical
-        // Rust equivalent (bun_io has no Write trait).
         writer.write_all(&self.data)?;
         Ok(())
     }
@@ -498,8 +493,10 @@ impl MachoFile {
         Ok(())
     }
 
+    // Returns `bun_core::Error` (the repo-wide union type) rather than a bespoke
+    // `MachoError | io::Error` enum: `From<MachoError>` routes through
+    // `Error::from_name`, so variant names survive into the caller's `e.name()`.
     pub fn build_and_sign(&self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if self.header.cputype == macho::CPU_TYPE_ARM64
             && feature_flag::BUN_NO_CODESIGN_MACHO_BINARY.get() != Some(true)
         {
@@ -641,8 +638,6 @@ impl MachoSigner {
         }))
     }
 
-    // Zig `deinit` only frees `data` and destroys self — both handled by Drop on Vec/Box.
-
     const IDENTIFIER: &'static [u8] = b"a.out\x00";
     const SIGNATURE_PAGE_SIZE: usize = 1 << 12;
     const SIGNATURE_HASH_SIZE: usize = 32; // SHA256 = 32 bytes
@@ -664,8 +659,8 @@ impl MachoSigner {
         super_blob_header_size + blob_index_size + code_dir_length
     }
 
+    // `bun_core::Error` union return — see the note on `build_and_sign`.
     pub(crate) fn sign(&mut self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         const PAGE_SIZE: usize = MachoSigner::SIGNATURE_PAGE_SIZE;
         const HASH_SIZE: usize = MachoSigner::SIGNATURE_HASH_SIZE;
 
@@ -739,8 +734,7 @@ impl MachoSigner {
             b.write(0);
         }
 
-        // Position writer at signature offset
-        // (Zig used `self.data.writer()`; here we extend the Vec directly.)
+        // Position writer at signature offset; extend the Vec directly.
 
         // Write signature components — SuperBlob / BlobIndex / CodeDirectory are
         // `NoUninit` (#[repr(C)] POD, no padding); byte-serialized verbatim into
@@ -751,7 +745,7 @@ impl MachoSigner {
         self.data.extend_from_slice(id);
 
         // Hash and write pages
-        // PORT NOTE: reshaped for borrowck — index instead of slicing self.data while pushing.
+        // reshaped for borrowck — index instead of slicing self.data while pushing.
         let mut off: usize = 0;
         let end = self.sig_off;
         while end - off >= PAGE_SIZE {
@@ -819,5 +813,3 @@ fn sha256_hash(bytes: &[u8], out: &mut [u8; 32]) {
     // SAFETY: engine is null (default).
     unsafe { bun_sha_hmac::sha::SHA256::hash(bytes, out, core::ptr::null_mut()) };
 }
-
-// ported from: src/exe_format/macho.zig
diff --git a/src/exe_format/macho_types.rs b/src/exe_format/macho_types.rs
index 5aa664a5748..27d789027bd 100644
--- a/src/exe_format/macho_types.rs
+++ b/src/exe_format/macho_types.rs
@@ -1,13 +1,11 @@
-//! Port of the subset of Zig `std.macho` (vendor/zig/lib/std/macho.zig) needed
-//! by `macho.rs`. All structs are `#[repr(C)]` POD matching the on-disk Mach-O
-//! format so they can be read/written via unaligned `ptr::{read,write}_unaligned`
-//! exactly like Zig's `*align(1) const T` casts.
+//! Mach-O type definitions needed by `macho.rs`. All structs are `#[repr(C)]`
+//! POD matching the on-disk Mach-O format so they can be read/written via
+//! unaligned `ptr::{read,write}_unaligned`.
 //!
 //! `LoadCommandIterator` deliberately stores a raw `*const u8` rather than a
 //! borrowed `&'a [u8]`: macho.rs interleaves iterator reads with in-place
-//! mutation of the same backing `Vec<u8>` (matching the Zig original, which
-//! has no borrow checker). Holding a Rust borrow across that mutation would
-//! force a structural rewrite; raw pointers preserve the Zig semantics.
+//! mutation of the same backing `Vec<u8>`. Holding a Rust borrow across that
+//! mutation would force a structural rewrite; raw pointers avoid that.
 //! SAFETY contract: callers must not reallocate or shrink the backing buffer
 //! while a `LoadCommandIterator` derived from it is live.
 
@@ -27,8 +25,8 @@ pub(crate) const S_ATTR_NO_DEAD_STRIP: u32 = 0x1000_0000;
 
 pub(crate) const LC_REQ_DYLD: u32 = 0x8000_0000;
 
-/// Zig `std.macho.LC` is a non-exhaustive `enum(u32)`. On-disk load commands
-/// can carry arbitrary tag values, so model it as bare `u32` constants instead
+/// On-disk load commands
+/// can carry arbitrary tag values, so model them as bare `u32` constants instead
 /// of a Rust `enum` (which would make `read_unaligned` of unknown discriminants
 /// instant UB).
 pub mod LC {
@@ -140,7 +138,7 @@ pub(crate) struct dyld_info_command {
 
 // ── code-signing blobs ────────────────────────────────────────────────────
 
-/// Tailored at version 0x20400 (matches Zig's std.macho.CodeDirectory).
+/// Tailored at version 0x20400.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub(crate) struct CodeDirectory {
diff --git a/src/exe_format/pe.rs b/src/exe_format/pe.rs
index 4b514ad1952..fced8951d11 100644
--- a/src/exe_format/pe.rs
+++ b/src/exe_format/pe.rs
@@ -90,8 +90,7 @@ pub struct PEFile {
 
 // PE/COFF on-disk header structs are byte-packed (no padding) per spec, and may
 // live at arbitrary byte offsets inside a `Vec<u8>` image, so `align_of` must be 1
-// for it to be sound to materialize references/pointers to them from the buffer
-// (the Zig original used `*align(1) const T`).
+// for it to be sound to materialize references/pointers to them from the buffer.
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub(crate) struct DOSHeader {
@@ -203,8 +202,7 @@ const BUN_SECTION_NAME: [u8; 8] = [b'.', b'b', b'u', b'n', 0, 0, 0, 0];
 
 // Safe access helpers for unaligned views.
 // All header structs are `#[repr(C, packed)]` (align 1), so a bounds-checked byte
-// pointer into the image can be cast and dereferenced directly — equivalent to the
-// Zig original's `*align(1) const T`.
+// pointer into the image can be cast and dereferenced directly.
 fn view_at_const<T>(buf: &[u8], off: usize) -> Result<*const T, Error> {
     if off + size_of::<T>() > buf.len() {
         return Err(Error::OutOfBounds);
@@ -335,7 +333,6 @@ impl PEFile {
         // 5. Read optional header
         let size_of_optional_header = pe_header.size_of_optional_header;
         let number_of_sections = pe_header.number_of_sections;
-        // PORT NOTE: reshaped for borrowck — drop pe_header borrow before re-borrowing data
         let optional_header = view_at_mut::<OptionalHeader64>(&mut data, optional_header_offset)?;
         // SAFETY: validated bounds above
         let optional_header = unsafe { &mut *optional_header };
@@ -565,7 +562,7 @@ impl PEFile {
         // 2. Re-read PE/Optional (pointers may have moved due to resize in strip)
         let opt = self.get_optional_header_mut()?;
         // SAFETY: opt points into self.data at validated offset
-        // PORT NOTE: reshaped for borrowck — capture needed scalars from opt before re-borrowing self.data
+        // Capture the needed scalars from opt before re-borrowing self.data below.
         let file_alignment = unsafe { (*opt).file_alignment };
         // SAFETY: opt points into self.data at the offset validated by get_optional_header_mut
         let section_alignment = unsafe { (*opt).section_alignment };
@@ -778,8 +775,6 @@ impl PEFile {
 
     /// Write the modified PE file
     pub fn write(&self, writer: &mut impl std::io::Write) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig used `writer: anytype` (`std.Io.Writer`); std::io::Write
-        // is the canonical Rust equivalent. bun_io has no Write trait.
         writer.write_all(&self.data)?;
         Ok(())
     }
@@ -888,5 +883,3 @@ unsafe extern "C" {
     pub fn Bun__getStandaloneModuleGraphPELength() -> u64;
     pub fn Bun__getStandaloneModuleGraphPEData() -> *mut u8;
 }
-
-// ported from: src/exe_format/pe.zig
diff --git a/src/glob/GlobWalker.rs b/src/glob/GlobWalker.rs
index 580fe9b099b..86db8834376 100644
--- a/src/glob/GlobWalker.rs
+++ b/src/glob/GlobWalker.rs
@@ -24,10 +24,10 @@
 use bun_alloc::AllocError;
 use bun_collections::AutoBitSet;
 use bun_core::Error;
+use bun_core::ZStr;
 use bun_core::define_scoped_log;
 use bun_core::env::IS_WINDOWS;
 use bun_core::strings;
-use bun_core::{String as BunString, ZStr};
 use bun_paths::{MAX_PATH_BYTES, PathBuffer, resolve_path};
 use bun_sys::dir_iterator as DirIterator;
 use bun_sys::{self as Syscall, E, Error as SysError, Fd, FdExt, O, Result as Maybe, S, Stat};
@@ -36,7 +36,6 @@ use bun_sys::{self as Syscall, E, Error as SysError, Fd, FdExt, O, Result as May
 
 define_scoped_log!(log, Glob, visible);
 
-// PORT NOTE: Zig's `CodepointIterator.Cursor.CodePointType` is `u32` (UnsignedCodepointIterator).
 // The bun_string Cursor stores `c: i32`; cast at the assignment sites.
 type Codepoint = u32;
 fn dummy_filter_false(_val: &[u8]) -> bool {
@@ -46,11 +45,9 @@ fn dummy_filter_false(_val: &[u8]) -> bool {
 #[cfg(windows)]
 pub fn statat_windows(fd: Fd, path: &ZStr) -> Maybe<Stat> {
     use bun_paths::resolve_path::{self, platform};
-    // Zig uses a SINGLE stack `bun.PathBuffer` for both `getFdPath` and
-    // `joinZBuf` (the join assembles parts into a temp scratch first, so the
-    // in/out alias is benign there). Rust's `&mut`/`&` aliasing rules forbid
+    // Rust's `&mut`/`&` aliasing rules forbid
     // passing the same buffer as both `join_z_buf`'s output and an input part,
-    // so we still need two buffers — but on Windows `PathBuffer` is ~96 KB,
+    // so we need two buffers — but on Windows `PathBuffer` is ~96 KB,
     // and this is called from deep inside `Iterator::next()` (via `lstatat`
     // for `FileKind::Unknown`), so two stack `PathBuffer`s (~192 KB, zero-
     // initialized by `PathBuffer::uninit()`) risk overflowing the smaller
@@ -70,7 +67,7 @@ pub fn statat_windows(_fd: Fd, _path: &ZStr) -> Maybe<Stat> {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Accessor trait — Zig passed `comptime Accessor: type` and duck-typed on it.
+// Accessor trait
 // ─────────────────────────────────────────────────────────────────────────────
 
 pub trait AccessorHandle: Copy {
@@ -217,16 +214,12 @@ impl Accessor for SyscallAccessor {
 // GlobWalker_
 // ─────────────────────────────────────────────────────────────────────────────
 
-// Zig: fn GlobWalker_(comptime ignore_filter_fn, comptime Accessor: type, comptime sentinel: bool) type
-//
 // `ignore_filter_fn` is lowered to a runtime fn-pointer field because Rust
 // const-generic fn pointers are unstable.
-// PERF(port): was comptime monomorphization (ignore_filter_fn) — profile if hot.
 //
 // `MatchedPath` was `[]const u8` or `[:0]const u8` depending on `sentinel`.
 // Without the arena, matched paths are heap-owned; we use `Box<[u8]>` and
 // include a trailing NUL byte when `SENTINEL == true`.
-// TODO(port): MatchedPath sentinel typing — consider a dedicated owned ZStr type.
 pub type MatchedPath = Box<[u8]>;
 
 pub type IgnoreFilterFn = fn(&[u8]) -> bool;
@@ -241,9 +234,8 @@ pub type IgnoreFilterFn = fn(&[u8]) -> bool;
 pub type ComponentSet = AutoBitSet;
 
 pub struct GlobWalker<A: Accessor, const SENTINEL: bool> {
-    // PERF(port): was arena bulk-free — Zig used std.heap.ArenaAllocator for all
-    // per-walk allocations (paths, workbuf, matchedPaths). The Rust port uses
-    // the global allocator; profile if hot.
+    // PERF: per-walk allocations (paths, workbuf, matchedPaths) use the
+    // global allocator; an arena could bulk-free them — profile if hot.
     /// not owned by this struct
     pub pattern: Box<[u8]>,
 
@@ -279,12 +271,7 @@ pub type Result_ = Maybe<()>;
 /// Array hashmap used as a set (values are the keys)
 /// to store matched paths and prevent duplicates
 ///
-/// BunString is used so that we can call BunString.toJSArray()
-/// on the result of `.keys()` to give the result back to JS
-///
-/// The only type of string impl we use is ZigString since
-/// all matched paths are UTF-8 (DirIterator converts them on
-/// windows) and allocated on the arena
+/// All matched paths are UTF-8 (DirIterator converts them on windows)
 ///
 /// Multiple patterns are not supported so right now this is
 /// only possible when running a pattern like:
@@ -292,35 +279,20 @@ pub type Result_ = Maybe<()>;
 /// `foo/**/*`
 ///
 /// Use `.keys()` to get the matched paths
-// PORT NOTE: Zig keys this on `BunString` so `.keys()` can hand a slice
-// straight to `BunString.toJSArray`. `to_js_array` lives in a `*_jsc` crate
+// `to_js_array` lives in a `*_jsc` crate
 // (per PORTING.md §Strings, `.toJS` is only callable there), so the JS-array
 // fast path moves up-tier anyway and there's no win keeping `BunString` keys
 // here. Use `StringArrayHashMap<()>` (boxed `[u8]` keys); the JSC consumer
-// rebuilds `BunString`s from `.keys()`.
-// TODO(refactor): wire `MatchedMapContext` as a `StringArrayHashMap`
-// custom context once SENTINEL-aware hashing matters (currently the trailing
-// NUL is part of the key so dedupe is still exact).
+// rebuilds `BunString`s from `.keys()`. Default hashing includes the trailing
+// NUL when `SENTINEL == true`. For keys produced by `join` (the
+// `prepare_matched_path` path) probe and stored key both carry the NUL, so
+// dedupe is exact there. The symlink path is the exception:
+// `prepare_matched_path_symlink` probes with `ZStr::as_bytes()` (NUL-less)
+// while its stored keys come from `dupe_z` (NUL included), so in SENTINEL
+// mode symlink-match probes never hit and symlink dedupe silently misses —
+// a known quirk deliberately left as-is.
 pub type MatchedMap = bun_collections::StringArrayHashMap<()>;
 
-pub struct MatchedMapContext;
-// TODO(port): ArrayHashMap context trait shape — wire the actual trait.
-impl MatchedMapContext {
-    pub fn hash(&self, this: &BunString) -> u32 {
-        debug_assert!(this.tag() == bun_core::Tag::ZigString);
-        let slice = this.byte_slice();
-        // For SENTINEL the slice includes trailing NUL; hash excludes it.
-        // TODO(port): const-generic SENTINEL not reachable here; Zig branched at comptime.
-        // Thread `SENTINEL` through `MatchedMapContext` (or strip the NUL at
-        // insert time so the key never carries it).
-        bun_collections::array_hash_map::hash_string(slice)
-    }
-
-    pub fn eql(&self, this: &BunString, other: &BunString, _idx: usize) -> bool {
-        this.eql(other)
-    }
-}
-
 /// The glob walker references the .directory.path so its not safe to
 /// copy/move this
 pub enum IterState<A: Accessor> {
@@ -349,9 +321,8 @@ pub struct Directory<A: Accessor> {
     pub fd: A::Handle,
     pub iter: A::DirIter,
     pub path: Box<PathBuffer>,
-    // Zig: `dir_path: [:0]const u8` is a slice into `path` (self-referential).
+    // The dir path is a prefix of `path` (self-referential).
     // Store the length and reconstruct on demand.
-    // TODO(port): self-referential dir_path; may need Pin or raw-ptr slice.
     pub dir_path_len: usize,
 
     /// Active component indices. Multiple indices mean one readdir
@@ -385,7 +356,7 @@ pub struct Iterator<'a, A: Accessor, const SENTINEL: bool> {
     #[cfg(debug_assertions)]
     pub fds_open: usize,
     #[cfg(not(debug_assertions))]
-    pub fds_open: u8, // u0 in Zig; smallest Rust int
+    pub fds_open: u8, // unused in release; smallest Rust int
 
     #[cfg(windows)]
     pub nt_filter_buf: [u16; 256],
@@ -460,8 +431,7 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
                 //
                 // In that case we don't need to do any walking and can just open up the FS entry
                 if starting_component_idx as usize >= self.walker.pattern_components.len() {
-                    // Matched-path payload must respect SENTINEL (Zig: MatchedPath
-                    // = if (sentinel) [:0]const u8 else []const u8). The open()
+                    // Matched-path payload must respect SENTINEL. The open()
                     // probe always needs a NUL — use a separate dupeZ for it so
                     // SENTINEL=false matched paths don't carry a spurious 0x00.
                     let path = dupe_matched::<SENTINEL>(path_without_special_syntax);
@@ -506,7 +476,7 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
             )
         };
 
-        // PORT NOTE: reshaped for borrowck — `path_buf` aliases `self.walker.path_buf`;
+        // Note: reshaped for borrowck — `path_buf` aliases `self.walker.path_buf`;
         // capture the raw ptr+len up front so the &mut borrow ends before
         // `handle_sys_err_with_path` re-borrows `self.walker`.
         let root_path = &root_work_item.path;
@@ -602,9 +572,8 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
         // NUL in their `.len()`; the logical path drops it (see `work_item_logical_path`).
         let work_item_path: &[u8] = work_item_logical_path(&work_item.path);
         log!("transition => {}", bstr::BStr::new(work_item_path));
-        // PORT NOTE: reshaped for borrowck — Zig set `iter_state = .{ .directory = .{...} }`
-        // up front and then mutated `this.iter_state.directory.*` while also borrowing
-        // `this.walker`. Build the Directory in a local and assign at the end.
+        // Build the Directory in a local and assign at the end (borrowck:
+        // mutating `iter_state` in place would overlap the `self.walker` borrow).
         let mut dir_path_buf = Box::new(PathBuffer::uninit());
         let mut dir_path_len: usize = 'dir_path: {
             if ROOT {
@@ -708,10 +677,9 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
             if idx as usize == self.walker.pattern_components.len().saturating_sub(1)
                 && self.walker.pattern_components[idx as usize].syntax_hint == SyntaxHint::Literal
             {
-                // Zig: `defer this.closeDisallowingCwd(fd)` — covered explicitly on
+                // `close_disallowing_cwd(fd)` is covered explicitly on
                 // both exit paths below (Err arm and post-Ok); no `?` between here
                 // and those calls, so a scopeguard is unnecessary.
-                // PERF(port): was stack-fallback (stackFallback(256, arena))
                 let pat_slice = self.walker.pattern_components[idx as usize]
                     .pattern_slice(&self.walker.pattern)
                     .to_vec();
@@ -831,7 +799,7 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
 
     pub fn next(&mut self) -> Result<Maybe<Option<MatchedPath>>, Error> {
         'outer: loop {
-            // PORT NOTE: reshaped for borrowck — take/replace iter_state where needed.
+            // Note: reshaped for borrowck — take/replace iter_state where needed.
             match &mut self.iter_state {
                 IterState::Matched(_) => {
                     let IterState::Matched(path) =
@@ -868,13 +836,11 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
                                 )
                                 .with_path(work_item_path)));
                             }
-                            // PORT NOTE: reshaped for borrowck — Zig used `self.path_buf`
-                            // both as the scratch buffer here and from inside
-                            // `collapseDots`/`handleSysErrWithPath`. In Rust we split-borrow
+                            // Note: we split-borrow
                             // `path_buf` and `pattern_components` (disjoint fields) for the
                             // write+normalize, then drop the &mut and read via `self.walker`.
                             let mut symlink_full_path_len = work_item_path.len();
-                            // PORT NOTE: reshaped for borrowck — entry_name is a sub-slice
+                            // Note: reshaped for borrowck — entry_name is a sub-slice
                             // of symlink_full_path; capture range and re-slice later.
                             let entry_start = work_item.entry_start as usize;
 
@@ -1004,7 +970,7 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
                             let dir_fd = dir.fd;
                             let at_cwd = dir.at_cwd;
                             let dir_path = dir.dir_path();
-                            // PORT NOTE: reshaped for borrowck
+                            // Note: reshaped for borrowck
                             let err = self.walker.handle_sys_err_with_path(&err, dir_path);
                             if !at_cwd {
                                 self.close_disallowing_cwd(dir_fd);
@@ -1114,7 +1080,6 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
                                 continue;
                             }
 
-                            // PERF(port): was stack-fallback (stackFallback(256, arena))
                             let name_z = dupe_z(entry_name);
                             // SAFETY: dupe_z NUL-terminates
                             let name_z_ref = ZStr::from_slice_with_nul(&name_z[..]);
@@ -1205,7 +1170,6 @@ impl<'a, A: Accessor, const SENTINEL: bool> Iterator<'a, A, SENTINEL> {
 
 impl<'a, A: Accessor, const SENTINEL: bool> Drop for Iterator<'a, A, SENTINEL> {
     fn drop(&mut self) {
-        // Zig: pub fn deinit(this: *Iterator)
         self.close_cwd_fd();
         if let IterState::Directory(dir) = &self.iter_state {
             if !dir.iter_closed {
@@ -1232,7 +1196,6 @@ impl<'a, A: Accessor, const SENTINEL: bool> Drop for Iterator<'a, A, SENTINEL> {
 // ─────────────────────────────────────────────────────────────────────────────
 
 pub struct WorkItem<A: Accessor> {
-    // Zig: `path: []const u8` — arena-owned slice. Now heap-owned.
     pub path: Box<[u8]>,
     /// Bitmask of active component indices.
     pub active: ComponentSet,
@@ -1353,7 +1316,7 @@ impl SyntaxHint {
 
 impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
     /// The arena parameter is dereferenced and copied if all allocations go well and nothing goes wrong
-    // PORT NOTE: out-param constructor reshaped to return Self.
+    // Note: out-param constructor reshaped to return Self.
     pub fn init(
         pattern: &[u8],
         dot: bool,
@@ -1399,7 +1362,7 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
 
     /// `cwd` should be allocated with the arena
     /// The arena parameter is dereferenced and copied if all allocations go well and nothing goes wrong
-    // PORT NOTE: out-param constructor reshaped to return Self.
+    // Note: out-param constructor reshaped to return Self.
     pub fn init_with_cwd(
         pattern: &[u8],
         cwd: &[u8],
@@ -1440,7 +1403,6 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
         )?;
 
         // copy arena after all allocations are successful
-        // PERF(port): was arena bulk-free — arena field removed.
 
         if cfg!(debug_assertions) {
             this.debug_pattern_components();
@@ -1456,8 +1418,8 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
         // `self.path_buf` (e.g. Iterator::init error path, next() symlink
         // openat error path). When src and dst alias the same range,
         // `copy_from_slice` is UB (its safety contract requires
-        // non-overlapping). Zig's `bun.copy` is memmove. Match that:
-        // short-circuit identical-range, otherwise use overlap-safe ptr::copy.
+        // non-overlapping).
+        // Short-circuit identical-range, otherwise use overlap-safe ptr::copy.
         let dst = self.path_buf.as_mut_ptr();
         if src.as_ptr() != dst.cast_const() {
             // SAFETY: copy_len ≤ both src and dst capacity; ptr::copy is memmove
@@ -1492,8 +1454,8 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
         Ok(Ok(()))
     }
 
-    // PORT NOTE: associated fn taking `pattern_components` so callers can
-    // split-borrow it from `&mut self.path_buf` (Zig freely aliased; Rust
+    // Note: associated fn taking `pattern_components` so callers can
+    // split-borrow it from `&mut self.path_buf` (Rust
     // forbids `&mut self` + `&mut self.path_buf`). Error path builds SysError
     // directly from `path_buf` (which is already `self.path_buf` for the
     // symlink caller) instead of routing through `handle_sys_err_with_path`.
@@ -1751,7 +1713,6 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
 
     /// Create an empty ComponentSet sized for this pattern.
     fn make_set(&self) -> ComponentSet {
-        // Zig wrapped in handleOom; Rust aborts on OOM.
         ComponentSet::init_empty(self.pattern_components.len())
             .expect("OOM: ComponentSet::init_empty")
     }
@@ -1846,7 +1807,7 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
         &mut self,
         symlink_full_path: &[u8],
     ) -> Result<Option<MatchedPath>, AllocError> {
-        // PERF(port): was getOrPut single-probe — two lookups here; profile if hot.
+        // PERF: two lookups here (contains_key + insert); profile if hot.
         if self.matched_paths.contains_key(symlink_full_path) {
             log!(
                 "(dupe) prepared match: {}",
@@ -1871,7 +1832,7 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
     ) -> Result<Option<MatchedPath>, AllocError> {
         let subdir_parts: &[&[u8]] = &[&dir_name[0..dir_name.len()], entry_name];
         let name_matched_path = self.join(subdir_parts)?;
-        // PERF(port): was getOrPutValue single-probe — two lookups here; profile if hot.
+        // PERF: two lookups here (contains_key + insert); profile if hot.
         if self.matched_paths.contains_key(&name_matched_path) {
             log!(
                 "(dupe) prepared match: {}",
@@ -2053,11 +2014,8 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
         let mut width: u32 = 0;
         while (i as usize) < pattern.len() {
             let c = pattern[i as usize];
-            // PORT NOTE: Zig calls bun.strings.utf8ByteSequenceLength; same table as wtf8.
             width = u32::from(strings::wtf8_byte_sequence_length(c));
 
-            // PORT NOTE: GlobWalker.zig duplicates this block across the '\\' (Windows) and '/'
-            // arms because Zig has no or-pattern with a comptime guard; merged here.
             if bun_core::path_sep::is_sep_native(c) {
                 let mut end_byte = i;
                 // is last char
@@ -2115,9 +2073,7 @@ impl<A: Accessor, const SENTINEL: bool> GlobWalker<A, SENTINEL> {
     }
 }
 
-/// NOTE This also calls deinit on the arena, if you don't want to do that then
-// Zig: pub fn deinit(this: *GlobWalker, comptime clear_arena: bool)
-// PERF(port): was arena bulk-free — Drop frees Vec/Box fields automatically.
+// Drop frees Vec/Box fields automatically.
 impl<A: Accessor, const SENTINEL: bool> Drop for GlobWalker<A, SENTINEL> {
     fn drop(&mut self) {
         log!("GlobWalker.deinit");
@@ -2150,7 +2106,7 @@ pub fn match_wildcard_literal(literal: &[u8], path: &[u8]) -> bool {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Port helpers (no Zig equivalent — replaces arena.dupeZ / std/bun join dispatch)
+// Helpers
 // ─────────────────────────────────────────────────────────────────────────────
 
 /// `allocator.dupeZ(u8, s)` — returns owned bytes with trailing NUL included
@@ -2162,8 +2118,7 @@ fn dupe_z(s: &[u8]) -> Box<[u8]> {
 }
 
 /// Allocate a matched-path payload: when `SENTINEL` is true the box has a
-/// trailing NUL at `len()-1` (Zig `[:0]const u8`); when false it does not (Zig
-/// `[]const u8`). Mirrors `MatchedPath = if (sentinel) [:0]const u8 else []const u8`.
+/// trailing NUL at `len()-1`; when false it does not.
 #[inline]
 fn dupe_matched<const SENTINEL: bool>(s: &[u8]) -> Box<[u8]> {
     if SENTINEL {
@@ -2187,12 +2142,11 @@ fn matched_as_slice<const SENTINEL: bool>(p: &[u8]) -> &[u8] {
 /// The logical path stored in a [`WorkItem`], excluding any trailing NUL.
 ///
 /// For `SENTINEL == true`, `MatchedPath` boxes produced by [`GlobWalker::join`]
-/// carry a trailing NUL inside their `.len()` — Zig models the same value as
-/// `[:0]const u8`, which coerces to a `[]const u8` whose `.len` *excludes* the
-/// NUL. Root `WorkItem`s (and `SENTINEL == false` walks) instead hold a plain
+/// carry a trailing NUL inside their `.len()`.
+/// Root `WorkItem`s (and `SENTINEL == false` walks) instead hold a plain
 /// path with no NUL. A real filesystem path can never contain (let alone end
 /// in) a NUL byte, so a single trailing NUL is unambiguously the sentinel; we
-/// strip it here to recover the logical length, mirroring the Zig coercion.
+/// strip it here to recover the logical length.
 /// Without this, the NUL would be copied into the directory-path buffer and end
 /// up *embedded* in every path joined onto it (e.g. `assets/*` matching as
 /// `assets\0/file-1`, which truncates to `assets` when used as a C string).
@@ -2210,7 +2164,7 @@ fn bun_join<const SENTINEL: bool>(parts: &[&[u8]]) -> Box<[u8]> {
     use bun_paths::platform;
     if SENTINEL {
         let s = resolve_path::join_z::<platform::Auto>(parts);
-        // include trailing NUL in the owned box (Zig: out[0..out.len-1 :0])
+        // include trailing NUL in the owned box
         let mut v = s.as_bytes().to_vec();
         v.push(0);
         v.into_boxed_slice()
@@ -2221,7 +2175,7 @@ fn bun_join<const SENTINEL: bool>(parts: &[&[u8]]) -> Box<[u8]> {
 
 impl AccessorDirEntry for DirIterator::IteratorResult {
     fn name_slice(&self) -> &[u8] {
-        // Zig `entry.name.slice()` is always `[]const u8`: on Windows the `.u8`
+        // On Windows the `.u8`
         // NewWrappedIterator transcodes via `strings.fromWPath` at iteration
         // time. `Name::slice_u8()` exposes that cached transcode (or the native
         // slice on POSIX) so this is uniformly `&[u8]`.
@@ -2231,5 +2185,3 @@ impl AccessorDirEntry for DirIterator::IteratorResult {
         self.kind
     }
 }
-
-// ported from: src/glob/GlobWalker.zig
diff --git a/src/glob/lib.rs b/src/glob/lib.rs
index 1b20e24ff83..1c6aae4e172 100644
--- a/src/glob/lib.rs
+++ b/src/glob/lib.rs
@@ -1,4 +1,3 @@
-// Port of src/glob/glob.zig
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 #![warn(unused_must_use)]
 #[path = "GlobWalker.rs"]
@@ -10,9 +9,8 @@ pub use crate::glob_walker as walk;
 pub use crate::matcher::{MatchResult, r#match};
 pub use walk::GlobWalker;
 
-// PORT NOTE: Zig passes `null` as the first comptime arg to `GlobWalker_(null, Accessor, sentinel)`.
-// In the port, `ignore_filter_fn` is a runtime fn-pointer field (const-generic fn ptrs are
-// unstable), so the first param is dropped from the type and supplied at `init()`.
+// `ignore_filter_fn` is a runtime fn-pointer field supplied at `init()` rather than a type
+// parameter (const-generic fn ptrs are unstable).
 pub type BunGlobWalker = walk::GlobWalker<walk::SyscallAccessor, false>;
 pub type BunGlobWalkerZ = walk::GlobWalker<walk::SyscallAccessor, true>;
 
@@ -29,7 +27,6 @@ pub fn detect_glob_syntax(potential_pattern: &[u8]) -> bool {
     // In descending order of how popular the token is
     const SPECIAL_SYNTAX: [u8; 4] = *b"*{[?";
 
-    // PERF(port): was `inline for` (unrolled at comptime).
     for &token in SPECIAL_SYNTAX.iter() {
         let mut slice = potential_pattern;
         while !slice.is_empty() {
@@ -56,5 +53,3 @@ pub fn detect_glob_syntax(potential_pattern: &[u8]) -> bool {
 
     false
 }
-
-// ported from: src/glob/glob.zig
diff --git a/src/glob/matcher.rs b/src/glob/matcher.rs
index f768fa0facf..5b0cbfb7f67 100644
--- a/src/glob/matcher.rs
+++ b/src/glob/matcher.rs
@@ -43,7 +43,7 @@ type BraceStack = BoundedArray<Brace, 10>;
 /// alternatives. Patterns that exceed this budget fail to match.
 const BRACE_BRANCH_BUDGET: u32 = 10_000;
 
-// PORT NOTE: made `pub` — Zig leaks this private type through `pub fn match`; Rust forbids private-in-public.
+// `pub` because it appears in the signature of `pub fn match` (private-in-public is forbidden).
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum MatchResult {
     NoMatch,
@@ -145,7 +145,6 @@ pub fn r#match(glob: &[u8], path: &[u8]) -> MatchResult {
         state.glob_index += 1;
     }
 
-    // PORT NOTE: `BraceStack.init(0) catch unreachable` — zero-length init cannot fail.
     let mut brace_stack = BraceStack::default();
     let mut brace_budget = BRACE_BRANCH_BUDGET;
     let matched = glob_match_impl(
@@ -177,7 +176,7 @@ pub fn r#match(glob: &[u8], path: &[u8]) -> MatchResult {
 
 // `glob_start` is the index where the glob pattern starts
 #[inline(always)]
-// PERF(port): Zig `inline fn` on a fn that recurses through match_brace_branch — profile if hot.
+// PERF: `inline(always)` on a fn that recurses through match_brace_branch — profile if hot.
 fn glob_match_impl(
     state: &mut State,
     glob: &[u8],
@@ -603,8 +602,6 @@ fn unescape(c: &mut u8, glob: &[u8], glob_index: &mut u32) -> bool {
 }
 
 /// Decodes the WTF-8 codepoint at `bytes[idx]`, returning `(codepoint, byte_len)`.
-///
-/// Mirrors the open-coded triple in matcher.zig (`wtf8ByteSequenceLength` + `decodeWTF8RuneT`).
 #[inline(always)]
 fn decode_wtf8_rune_at(bytes: &[u8], idx: usize) -> (u32, u8) {
     let len = strings::wtf8_byte_sequence_length(bytes[idx]);
@@ -626,8 +623,7 @@ fn get_unicode(c: &mut u32, clen: &mut u8, glob: &[u8], glob_index: &mut u32) ->
     debug_assert!(*clen == 1);
     const BACKSLASH: u32 = b'\\' as u32;
     match *c {
-        // ascii range excluding backslash
-        // PORT NOTE: Zig `0x0...('\\'-1), '\\'+1...0x7F` — 0x5C is '\\'
+        // ascii range excluding backslash (0x5C)
         0x00..=0x5B | 0x5D..=0x7F => {
             return true;
         }
@@ -679,5 +675,3 @@ fn skip_globstars(glob: &[u8], glob_index: &mut u32) {
 
     *glob_index -= 2;
 }
-
-// ported from: src/glob/matcher.zig
diff --git a/src/hash/adler32.rs b/src/hash/adler32.rs
index 2851a85c2a6..0b88c5f1ddd 100644
--- a/src/hash/adler32.rs
+++ b/src/hash/adler32.rs
@@ -1,9 +1,8 @@
 //! Adler-32 checksum.
 //!
-//! Ported from `vendor/zig/lib/std/hash/Adler32.zig` (which itself follows
-//! https://tools.ietf.org/html/rfc1950#section-9 and zlib's `adler32.c`).
+//! Follows https://tools.ietf.org/html/rfc1950#section-9 and zlib's `adler32.c`.
 //!
-//! `HashObject.zig` exposes this via `hashWrap(std.hash.Adler32)`, which calls
+//! `HashObject.rs` exposes this via `hash_wrap::<Adler32>`, which calls
 //! the single-argument `hash(input)` (no seed) — the JS-side seed argument is
 //! ignored for Adler32.
 
@@ -57,7 +56,7 @@ impl Adler32 {
             while i + Self::NMAX <= input.len() {
                 let mut rounds: usize = 0;
                 while rounds < N {
-                    // Zig: `inline while (j < 16)` — rely on the optimizer to unroll.
+                    // Rely on the optimizer to unroll.
                     for j in 0..16usize {
                         s1 = s1.wrapping_add(input[i + j] as u32);
                         s2 = s2.wrapping_add(s1);
diff --git a/src/hash/cityhash.rs b/src/hash/cityhash.rs
index 884a072e5b2..38613835aff 100644
--- a/src/hash/cityhash.rs
+++ b/src/hash/cityhash.rs
@@ -1,9 +1,8 @@
 //! CityHash32 / CityHash64.
 //!
-//! Ported from `vendor/zig/lib/std/hash/cityhash.zig` (which itself follows
-//! Google's reference implementation / Abseil).
+//! Follows Google's reference implementation / Abseil.
 //!
-//! `HashObject.zig` exposes:
+//! `HashObject.rs` exposes:
 //!   * `cityHash32` → `CityHash32::hash(input)` (no seed; the JS seed is ignored)
 //!   * `cityHash64` → `CityHash64::hash_with_seed(input, seed)`
 
@@ -65,7 +64,7 @@ impl CityHash32 {
         let mut b: u32 = 0;
         let mut c: u32 = 9;
         for &v in str {
-            // Zig: @bitCast(@intCast(@bitCast(v) as i8) as i32) — i.e. sign-extend the byte.
+            // Sign-extend the byte.
             b = b
                 .wrapping_mul(Self::C1)
                 .wrapping_add((v as i8 as i32) as u32);
diff --git a/src/hash/lib.rs b/src/hash/lib.rs
index 2affd9edbd7..fc556e5801f 100644
--- a/src/hash/lib.rs
+++ b/src/hash/lib.rs
@@ -1,10 +1,9 @@
 //! Non-cryptographic hash functions for `Bun.hash` (`HashObject`).
 //!
-//! Each algorithm is a 1:1 port of the version Bun's Zig runtime uses
-//! (`std.hash.*` from `vendor/zig/lib/std/hash/` plus `bun.deprecated.RapidHash`),
-//! so JS-visible output stays bit-identical across the Zig→Rust boundary.
+//! JS-visible output is bit-identical to the reference implementation of each
+//! algorithm.
 //!
-//! Surface mirrored from `src/runtime/api/HashObject.zig`:
+//! Surface exposed by `src/runtime/api/HashObject.rs`:
 //!
 //! | JS name        | Rust entry point                              | seed → output |
 //! |----------------|-----------------------------------------------|---------------|
@@ -34,11 +33,9 @@ pub use murmur::{Murmur2_32, Murmur2_64, Murmur3_32};
 pub use rapidhash::RapidHash;
 pub use xxhash::{XxHash3, XxHash32, XxHash64, XxHash64Streaming};
 
-// ported from: src/runtime/api/HashObject.zig
-
 #[cfg(test)]
 pub(crate) mod verify {
-    //! SMHasher verification routine — mirrors `vendor/zig/lib/std/hash/verify.zig`.
+    //! SMHasher verification routine.
     //!
     //! Fill `buf[i] = i`; hash each prefix with `seed = 256 - i`; concat the
     //! little-endian bytes; hash the concat with `seed = 0`; truncate to u32.
diff --git a/src/hash/murmur.rs b/src/hash/murmur.rs
index 18bcd6cab66..af4c377f033 100644
--- a/src/hash/murmur.rs
+++ b/src/hash/murmur.rs
@@ -1,13 +1,12 @@
 //! MurmurHash family.
 //!
-//! Ported from `vendor/zig/lib/std/hash/murmur.zig`. `HashObject.zig` exposes
-//! these via `hashWrap`, which dispatches to `hashWithSeed(str, seed)` (the
+//! `HashObject.rs` exposes
+//! these via `hash_wrap`, which dispatches to `hash_with_seed(str, seed)` (the
 //! `(bytes, seed)` argument order — note the seed comes *second*, unlike
 //! XxHash). The default seed is `0xc70f6907`.
 //!
-//! The Zig version reads `len` as `@truncate(str.len)` (a `u32` truncation) for
-//! the 32-bit variants; we preserve that quirk so > 4 GiB inputs hash
-//! identically.
+//! `len` is read as a `u32` truncation of `str.len()` for the 32-bit variants
+//! — a deliberate quirk so > 4 GiB inputs keep hashing the way they always have.
 
 const DEFAULT_SEED: u32 = 0xc70f6907;
 
@@ -145,9 +144,7 @@ impl Murmur2_64 {
         let rest = str.len() & 7;
         let offset = str.len() - rest;
         if rest > 0 {
-            // Zig: @memcpy into the low bytes of a u64 then read native-endian,
-            // byte-swapping on big-endian — i.e. a little-endian load of `rest`
-            // bytes zero-extended to u64.
+            // Little-endian load of `rest` bytes zero-extended to u64.
             let mut buf = [0u8; 8];
             buf[..rest].copy_from_slice(&str[offset..]);
             let k1 = u64::from_le_bytes(buf);
diff --git a/src/hash/rapidhash.rs b/src/hash/rapidhash.rs
index e469fcc2b5b..1d10b6325a6 100644
--- a/src/hash/rapidhash.rs
+++ b/src/hash/rapidhash.rs
@@ -1,8 +1,7 @@
 //! RapidHash.
 //!
-//! Ported from `src/bun_core/deprecated.zig` (`bun.deprecated.RapidHash`).
-//! `HashObject.zig` exposes this via `hashWrap(bun.deprecated.RapidHash)`,
-//! which calls `hash(seed: u64, input: []const u8) -> u64`.
+//! `HashObject.rs` exposes this via `hash_wrap::<RapidHash>`,
+//! which calls `hash(seed: u64, input: &[u8]) -> u64`.
 
 pub struct RapidHash;
 
@@ -35,7 +34,6 @@ impl RapidHash {
                 is[1] = is[0];
                 is[2] = is[0];
                 while remain >= 96 {
-                    // PERF(port): was `inline for (0..6)` — rely on optimizer.
                     for i in 0..6usize {
                         let m1 = Self::r64(&k[8 * i * 2..]);
                         let m2 = Self::r64(&k[8 * (i * 2 + 1)..]);
@@ -45,7 +43,6 @@ impl RapidHash {
                     remain -= 96;
                 }
                 if remain >= 48 {
-                    // PERF(port): was `inline for (0..3)` — rely on optimizer.
                     for i in 0..3usize {
                         let m1 = Self::r64(&k[8 * i * 2..]);
                         let m2 = Self::r64(&k[8 * (i * 2 + 1)..]);
@@ -105,7 +102,6 @@ impl RapidHash {
 mod tests {
     use super::RapidHash;
 
-    /// Mirrors the `RapidHash.hash` test in `src/bun_core/deprecated.zig`.
     #[test]
     fn vectors() {
         // "abcdefgh" ** 128
diff --git a/src/hash/xxhash.rs b/src/hash/xxhash.rs
index 3ae4ac9f4f7..a1d387e6516 100644
--- a/src/hash/xxhash.rs
+++ b/src/hash/xxhash.rs
@@ -4,11 +4,11 @@
 //! `src/jsc/bindings/xxhash3.cpp` (exposed by `bun_highway`). XXH3's long-input
 //! stripe loop is runtime-dispatched to the widest SIMD ISA the CPU supports;
 //! XXH32/XXH64 are scalar (no SIMD form exists in the reference). Output is
-//! bit-identical to `std.hash.XxHash{32,64,3}` in Zig and to the xxHash
+//! bit-identical to the xxHash
 //! reference test vectors — verified against the reference (and across every
 //! dispatch target) by `test/js/bun/util/hash.test.js`, which runs in CI.
 //!
-//! `HashObject.zig` exposes these via `hashWrap` with a `(seed, bytes)`
+//! `HashObject.rs` exposes these via `hash_wrap` with a `(seed, bytes)`
 //! signature (seed first, unlike Murmur/CityHash).
 
 pub struct XxHash32;
@@ -29,11 +29,11 @@ impl XxHash64 {
     }
 }
 
-/// Streaming `std.hash.XxHash64` — used by the bundler's `ContentHasher`
+/// Streaming XxHash64 — used by the bundler's `ContentHasher`
 /// (length-prefixed chunk hashing across many `update()` calls before a single
 /// `digest()`), plus the dev-server source-map hash and the resolver stat hash.
 /// Wraps `bun_highway::XxHash64State` so the workspace has exactly one xxhash
-/// implementation; output is bit-identical to Zig's `std.hash.XxHash64`.
+/// implementation; output is bit-identical to the xxHash reference.
 pub struct XxHash64Streaming(bun_highway::XxHash64State);
 
 impl XxHash64Streaming {
diff --git a/src/highway/lib.rs b/src/highway/lib.rs
index 11427306ebd..ab1dbb9280a 100644
--- a/src/highway/lib.rs
+++ b/src/highway/lib.rs
@@ -288,12 +288,12 @@ pub fn index_of_any_char(haystack: &[u8], chars: &[u8]) -> Option<usize> {
     Some(result)
 }
 
-// TODO(port): Zig accepts `[]align(1) const u16` (unaligned). Rust `&[u16]` requires
-// 2-byte alignment; callers passing unaligned data must go through the raw extern.
+// `&[u16]` requires
+// 2-byte alignment. Callers with unaligned data must go through the raw extern.
 #[inline(always)]
 pub fn copy_u16_to_u8(input: &[u16], output: &mut [u8]) {
     // SAFETY: input.ptr/len readable, output.ptr writable for at least input.len() bytes
-    // (caller contract matches Zig: output.len >= input.len()).
+    // (caller contract: output.len() >= input.len()).
     unsafe { highway_copy_u16_to_u8(input.as_ptr(), input.len(), output.as_mut_ptr()) }
 }
 
@@ -394,11 +394,10 @@ pub fn fill_with_skip_mask(mask: [u8; 4], output: &mut [u8], input: &[u8], skip_
 
 /// In-place variant of [`fill_with_skip_mask`] for `output == input`.
 ///
-/// The Zig caller (`Mask.fill`) routinely passes the same buffer for both;
-/// the safe wrapper above can't express that without violating `&mut`/`&`
-/// aliasing. The C++ kernel reads-before-writes per lane (it's `dst[i] =
-/// src[i] ^ mask[i&3]`), so feeding it `src == dst` is sound — that's exactly
-/// what the Zig build does.
+/// Callers routinely pass the same buffer for both; the safe wrapper above
+/// can't express that without violating `&mut`/`&` aliasing. The C++ kernel
+/// reads-before-writes per lane (it's `dst[i] = src[i] ^ mask[i&3]`), so
+/// feeding it `src == dst` is sound.
 #[inline(always)]
 pub fn fill_with_skip_mask_inplace(mask: [u8; 4], buf: &mut [u8], skip_mask: bool) {
     if buf.is_empty() {
@@ -480,8 +479,8 @@ pub fn xxhash3_64(seed: u64, input: &[u8]) -> u64 {
     unsafe { highway_xxhash3_64(input.as_ptr(), input.len(), seed) }
 }
 
-/// XxHash32 one-shot. Bit-identical to the xxHash reference / Zig
-/// `std.hash.XxHash32`. Scalar (XXH32 has no SIMD form); lives in the same C++
+/// XxHash32 one-shot. Bit-identical to the xxHash reference.
+/// Scalar (XXH32 has no SIMD form); lives in the same C++
 /// TU as the XXH3 kernel.
 #[inline(always)]
 pub fn xxhash32(seed: u32, input: &[u8]) -> u32 {
@@ -490,8 +489,7 @@ pub fn xxhash32(seed: u32, input: &[u8]) -> u32 {
     unsafe { highway_xxhash32(input.as_ptr(), input.len(), seed) }
 }
 
-/// XxHash64 one-shot. Bit-identical to the xxHash reference / Zig
-/// `std.hash.XxHash64`.
+/// XxHash64 one-shot. Bit-identical to the xxHash reference.
 #[inline(always)]
 pub fn xxhash64(seed: u64, input: &[u8]) -> u64 {
     // SAFETY: `input.ptr/len` are a valid readable range; read-only, and the
@@ -502,8 +500,8 @@ pub fn xxhash64(seed: u64, input: &[u8]) -> u64 {
 /// Streaming XxHash64 state. Mirrors the C++ `XXH64State` POD (80 bytes,
 /// 8-aligned; a compile-time `static_assert` on the C++ side keeps them in
 /// sync). `reset` → any number of `update(chunk)` → `digest()`; the result
-/// equals `xxhash64` of the concatenation. Bit-identical to Zig
-/// `std.hash.XxHash64` streaming.
+/// equals `xxhash64` of the concatenation. Bit-identical to the xxHash
+/// reference streaming API.
 #[repr(C, align(8))]
 pub struct XxHash64State {
     // 10 u64 == 80 bytes. Opaque storage; only the C kernel interprets it.
@@ -539,5 +537,3 @@ impl XxHash64State {
         unsafe { highway_xxhash64_digest(self._storage.as_ptr().cast()) }
     }
 }
-
-// ported from: src/highway/highway.zig
diff --git a/src/http/AsyncHTTP.rs b/src/http/AsyncHTTP.rs
index c078b223c99..a127c5a3d5b 100644
--- a/src/http/AsyncHTTP.rs
+++ b/src/http/AsyncHTTP.rs
@@ -33,10 +33,9 @@ pub struct AsyncHTTP<'a> {
     pub response: Option<picohttp::Response<'static>>,
     pub request_headers: headers::EntryList,
     pub response_headers: headers::EntryList,
-    // TODO(port): lifetime — caller-owned response buffer; never freed here.
+    // Caller-owned response buffer (raw pointer, lifetime-erased); never freed here.
     pub response_buffer: *mut MutableString,
     pub request_body: HTTPRequestBody<'a>,
-    // PORT NOTE: `std.mem.Allocator param` field dropped — global mimalloc is used everywhere.
     pub request_header_buf: &'a [u8],
     pub method: Method,
     pub url: URL<'a>,
@@ -105,8 +104,7 @@ const fn noop_callback() -> HTTPClientResultCallback {
 ///
 /// # Safety
 /// `href` must have been allocated via the global allocator as a `Box<[u8]>`
-/// and ownership ceded to this module via `is_url_owned = true`. Mirrors Zig
-/// `bun.default_allocator.free(url.href)`.
+/// and ownership ceded to this module via `is_url_owned = true`.
 #[inline]
 unsafe fn free_owned_href(href: &'static [u8]) {
     if !href.is_empty() {
@@ -119,21 +117,18 @@ unsafe fn free_owned_href(href: &'static [u8]) {
 }
 
 /// Read the HTTP-thread monotonic timer in nanoseconds.
-/// Mirrors Zig `http_thread.timer.read()`.
 #[inline]
 fn http_thread_timer_read() -> u64 {
     crate::http_thread().timer.elapsed().as_nanos() as u64
 }
 
 /// Build the `Proxy-Authorization: Basic <b64(user[:pass])>` header value.
-/// Returns `None` (and logs) if percent-decoding fails — Zig swallowed the
-/// error and continued without proxy auth.
+/// Returns `None` (and logs) if percent-decoding fails.
 fn build_proxy_authorization(proxy: &URL<'_>) -> Option<Vec<u8>> {
     if proxy.username.is_empty() {
         return None;
     }
 
-    // PERF(port): was stack-fallback (4096) — profile if hot
     let username = match PercentEncoding::decode_alloc(proxy.username) {
         Ok(u) => u,
         Err(err) => {
@@ -143,7 +138,6 @@ fn build_proxy_authorization(proxy: &URL<'_>) -> Option<Vec<u8>> {
     };
 
     let auth: Vec<u8> = if !proxy.password.is_empty() {
-        // PERF(port): was stack-fallback (4096) — profile if hot
         let password = match PercentEncoding::decode_alloc(proxy.password) {
             Ok(p) => p,
             Err(err) => {
@@ -192,7 +186,7 @@ fn make_client<'a>(
         url,
         connected_url: URL::default(),
         verbose: HTTPVerboseLevel::None,
-        // PORT NOTE: DEFAULT_REDIRECT_COUNT (= 127) is crate-private in lib.rs;
+        // Note: DEFAULT_REDIRECT_COUNT (= 127) is crate-private in lib.rs;
         // duplicated as a literal here.
         remaining_redirect_count: 127,
         allow_retry: false,
@@ -228,8 +222,7 @@ fn make_client<'a>(
 
 pub fn load_env(logger: &mut Log, env: &DotEnvLoader) {
     if let Some(max_http_requests) = env.get(b"BUN_CONFIG_MAX_HTTP_REQUESTS") {
-        // PORT NOTE: env vars are bytes — never round-trip through &str. Zig used std.fmt.parseInt
-        // on []const u8 directly; map to the byte-slice parser in bun_core::strings.
+        // Note: env vars are bytes — never round-trip through &str.
         let max: u16 = match bun_core::parse_int::<u16>(max_http_requests, 10) {
             Ok(v) => v,
             Err(_) => {
@@ -267,7 +260,6 @@ pub fn load_env(logger: &mut Log, env: &DotEnvLoader) {
 pub struct Options<'a> {
     pub http_proxy: Option<URL<'a>>,
     pub proxy_headers: Option<Headers>,
-    // PORT NOTE: Zig had `?[]u8` (mutable slice); only ever read, so `&[u8]` here.
     pub hostname: Option<&'a [u8]>,
     pub signals: Option<Signals>,
     pub unix_socket_path: Option<ZigStringSlice>,
@@ -294,9 +286,8 @@ impl<'a> AsyncHTTP<'a> {
             .cast::<AsyncHTTP<'static>>()
     }
 
-    /// Accessor for the global concurrent-request cap (Zig:
-    /// `AsyncHTTP.max_simultaneous_requests`). Returned as a static so callers
-    /// can `.load()` / `.store()` directly.
+    /// Accessor for the global concurrent-request cap. Returned as a static
+    /// so callers can `.load()` / `.store()` directly.
     #[inline]
     pub fn max_simultaneous_requests() -> &'static core::sync::atomic::AtomicUsize {
         &MAX_SIMULTANEOUS_REQUESTS
@@ -320,9 +311,7 @@ impl<'a> AsyncHTTP<'a> {
 
     /// Copy HTTP-thread progress state into the JS-thread "real" instance.
     ///
-    /// Port of Zig `task.http.?.* = async_http.*` — Zig bitwise-copies the
-    /// whole struct, which Rust can't do (`HTTPClient: Drop`, owned `Vec`s).
-    /// Instead, copy exactly the fields the JS side observes between progress
+    /// Copy exactly the fields the JS side observes between progress
     /// callbacks: the post-redirect `url`, response/timing fields written by
     /// `on_async_http_callback`, and the `client` flags/counters used for
     /// shutdown decisions and error formatting. Owned allocations stay with
@@ -344,11 +333,11 @@ impl<'a> AsyncHTTP<'a> {
     }
 
     pub fn clear_data(&mut self) {
-        // PORT NOTE: `response_headers.deinit(allocator)` becomes drop-in-place via assignment.
+        // Note: `response_headers.deinit(allocator)` becomes drop-in-place via assignment.
         self.response_headers = headers::EntryList::default();
         self.request = None;
         self.response = None;
-        // PORT NOTE: ZigString.Slice ownership — Drop releases WTF/owned variants;
+        // Note: `ZigStringSlice` Drop releases WTF/owned variants;
         // assigning EMPTY runs Drop on the old value.
         self.client.unix_socket_path = ZigStringSlice::EMPTY;
     }
@@ -359,9 +348,8 @@ impl<'a> AsyncHTTP<'a> {
 // ──────────────────────────────────────────────────────────────────────────
 
 struct Preconnect {
-    // TODO(port): self-referential — `async_http.response_buffer` borrows
-    // `self.response_buffer`. Zig relied on stable heap addresses from
-    // `bun.TrivialNew`. `Option` so we can write the field after the heap
+    // Self-referential — `async_http.response_buffer` borrows
+    // `self.response_buffer`. `Option` so we can write the field after the heap
     // address is fixed (late-init); `None` is never observed after `preconnect()`
     // populates it.
     async_http: Option<AsyncHTTP<'static>>,
@@ -381,8 +369,6 @@ impl Preconnect {
                 .as_mut()
                 .expect("Preconnect.async_http set in preconnect()")
                 .clear_data();
-            // PORT NOTE: Zig `async_http.client.deinit()` — handled by Drop when
-            // the Box is reclaimed below.
             if (*this).is_url_owned {
                 // SAFETY: `is_url_owned` is the caller's promise that `url.href`
                 // is a global-allocator `Box<[u8]>` we now own.
@@ -473,15 +459,11 @@ impl<'a> AsyncHTTP<'a> {
         let signals = options.signals.unwrap_or_default();
         let http_proxy = options.http_proxy.clone();
 
-        // PORT NOTE: reshaped for borrowck — Zig wrote `this.* = .{ .client = undefined, ... }`
-        // then `this.client = .{...}`. Rust has no `undefined`; build the client first and move
-        // it into the AsyncHTTP literal.
         let client = make_client(
             method,
             url.clone(),
-            // PORT NOTE: Zig stored the same `headers` value in both `AsyncHTTP.request_headers`
-            // and `client.header_entries` (shallow copy of the MultiArrayList header → shared
-            // backing storage). `MultiArrayList` in Rust owns its allocation, so clone here.
+            // Note: the same `headers` value goes in both `AsyncHTTP.request_headers`
+            // and `client.header_entries`; `MultiArrayList` owns its allocation, so clone here.
             headers.clone().expect("OOM"),
             headers_buf,
             options.hostname,
@@ -564,7 +546,7 @@ impl<'a> AsyncHTTP<'a> {
     /// `hostname`) are tied to lifetime `'a` and must outlive the returned
     /// value — in practice they live on the calling stack frame and the
     /// request is driven to completion via `send_sync` before that frame
-    /// returns (mirrors Zig `AsyncHTTP.initSync`).
+    /// returns.
     pub fn init_sync(
         method: Method,
         url: URL<'a>,
@@ -583,7 +565,6 @@ impl<'a> AsyncHTTP<'a> {
             headers_buf,
             response_buffer,
             request_body,
-            // PORT NOTE: Zig passed `undefined` for callback in sync mode.
             noop_callback(),
             redirect_type,
             Options {
@@ -605,7 +586,7 @@ impl<'a> AsyncHTTP<'a> {
 // ──────────────────────────────────────────────────────────────────────────
 
 // 32 pointers much cheaper than 1000 pointers
-// PORT NOTE: `bun_threading::Channel` requires `T: Copy`, which
+// Note: `bun_threading::Channel` requires `T: Copy`, which
 // `HTTPClientResult` is not. `send_sync` is a one-shot blocking handoff, so a
 // Guarded<Option<T>>+Condvar is the exact semantics needed.
 pub struct SingleHTTPChannel {
@@ -647,9 +628,7 @@ fn send_sync_callback(
     // SAFETY: `async_http` is the HTTP-thread copy (inside ThreadlocalAsyncHTTP)
     // and `real` was set to the caller's stack/heap AsyncHTTP before scheduling.
     let async_http = unsafe { &mut *async_http };
-    // PORT NOTE: Zig did `async_http.real.?.* = async_http.*` (whole-struct
-    // bitwise copy back into the original) then re-seated `response_buffer`.
-    // `AsyncHTTP` is not `Copy`/`Clone` in Rust and a raw `ptr::read`/`ptr::write`
+    // Note: `AsyncHTTP` is not `Copy`/`Clone` and a raw `ptr::read`/`ptr::write`
     // would duplicate owned fields that are later dropped on both sides; instead
     // enumerate every field `on_async_http_callback` (and the client path) writes
     // and that callers of `send_sync` can observe, moving owned values out of
@@ -682,8 +661,8 @@ impl<'a> AsyncHTTP<'a> {
     pub fn send_sync(&mut self) -> Result<picohttp::Response<'static>, bun_core::Error> {
         crate::http_thread::init(&Default::default());
 
-        // PORT NOTE: Zig leaked `ctx` (never destroyed). `Box::leak` is forbidden
-        // (PORTING.md §Forbidden); allocate via `heap::alloc` and reclaim once
+        // Note: `Box::leak` is forbidden (PORTING.md §Forbidden);
+        // allocate via `heap::alloc` and reclaim once
         // the single sync callback has fired and we've read the result.
         let ctx = bun_core::heap::into_raw_nn(Box::new(SingleHTTPChannel::init()));
         self.result_callback =
@@ -706,9 +685,8 @@ impl<'a> AsyncHTTP<'a> {
         }
         debug_assert!(result.metadata.is_some());
         // The returned `Response` borrows `metadata.owned_buf` (status text +
-        // header slices). Zig's `sendSync` returns `result.metadata.?.response`
-        // and never `deinit`s the metadata; mirror that by suppressing Drop so
-        // the borrowed buffer outlives the call. `send_sync` is one-shot CLI.
+        // header slices); suppress Drop so the borrowed buffer outlives the
+        // call. `send_sync` is one-shot CLI.
         let metadata = core::mem::ManuallyDrop::new(result.metadata.unwrap());
         Ok(metadata.response)
     }
@@ -724,7 +702,7 @@ impl<'a> AsyncHTTP<'a> {
         async_http: *mut AsyncHTTP<'static>,
         result: HTTPClientResult<'_>,
     ) {
-        // PORT NOTE: kept as raw `*mut` throughout — `this == async_http` (set in
+        // Note: kept as raw `*mut` throughout — `this == async_http` (set in
         // `on_start`) and the `!has_more` branch frees that allocation, so a
         // `&mut self` would be left dangling across the tail of the function
         // (UB under stacked borrows).
@@ -751,20 +729,30 @@ impl<'a> AsyncHTTP<'a> {
                 (*this).state.store(State::Fail, Ordering::Relaxed);
             }
 
-            // PORT NOTE: Zig logged `socket_async_http_abort_tracker.count()` here
-            // and did `tracker.shrinkAndFree(count)` when `capacity()>10_000 &&
-            // count()<100`. `bun_collections::ArrayHashMap` does not yet expose
-            // `capacity()`/`shrink_and_free()`.
-            // TODO(port): wire `bun_collections::ArrayHashMap::{capacity,shrink_and_free}` once they exist and call them under the same guard.
+            // Log the tracker count, then shrink
+            // the abort tracker back down once it has drained from a
+            // high-water mark (capacity > 10_000 entries but fewer than 100
+            // live), so long-lived heavy-fetch processes don't pin the peak
+            // allocation forever. HTTP-thread-only access to the global.
+            {
+                let tracker = crate::abort_tracker();
+                let count = tracker.count();
+                if count > 0 {
+                    bun_core::scoped_log!(
+                        AsyncHTTP,
+                        "socket_async_http_abort_tracker count: {}",
+                        count
+                    );
+                }
+                if tracker.capacity() > 10_000 && count < 100 {
+                    tracker.shrink_and_free(count);
+                }
+            }
 
             let has_more = result.has_more;
             if has_more {
                 callback.run(async_http, result);
             } else {
-                // PORT NOTE: Zig `this.client.deinit()` runs BEFORE the user
-                // callback, then `threadlocal_http.deinit()` (a `TrivialDeinit`
-                // — frees the box, NO field destructors) runs after.
-                //
                 // The threadlocal `AsyncHTTP` was created by a bitwise
                 // `core::ptr::read` of the JS-thread original
                 // (`start_queued_task`), so any owned field that was already
@@ -818,12 +806,10 @@ impl<'a> AsyncHTTP<'a> {
                         in_flight.swap_remove(i);
                     }
                 }
-                // PORT NOTE: Zig `defer threadlocal_http.deinit()` is
-                // `bun.TrivialDeinit` — it frees the heap slot WITHOUT running
-                // any field destructors. Reclaiming as `Box<_>` here would
-                // drop the bitwise-shared fields enumerated above and
-                // double-free with the JS-thread original; deallocate the
-                // storage directly instead.
+                // Note: reclaiming as `Box<_>` here would drop the
+                // bitwise-shared fields enumerated above and double-free with
+                // the JS-thread original; deallocate the storage directly
+                // instead.
                 std::alloc::dealloc(
                     threadlocal_http.cast::<u8>(),
                     std::alloc::Layout::new::<ThreadlocalAsyncHTTP>(),
@@ -884,9 +870,6 @@ impl<'a> AsyncHTTP<'a> {
         );
 
         self.elapsed = http_thread_timer_read();
-        // PORT NOTE: Zig reassigned `response_buffer.allocator = bun.http.default_allocator`
-        // when capacity was 0. MutableString in Rust uses the global allocator
-        // unconditionally; nothing to do.
 
         // `response_buffer` was set in `init()` to a caller-owned MutableString
         // that outlives this request — the very buffer `start()` records as
@@ -896,8 +879,8 @@ impl<'a> AsyncHTTP<'a> {
             NonNull::new(self.response_buffer).expect("response_buffer set in init"),
         );
 
-        // PORT NOTE: `HTTPRequestBody` is not `Clone` (the `Stream` arm holds an
-        // intrusive refcount). Zig passed it by value (shallow copy). Move owned
+        // Note: `HTTPRequestBody` is not `Clone` (the `Stream` arm holds an
+        // intrusive refcount). Move owned
         // payloads into the client and leave a detached placeholder so Drop on
         // `self.request_body` is a no-op.
         let body = core::mem::replace(&mut self.request_body, HTTPRequestBody::Bytes(b""));
@@ -909,7 +892,6 @@ impl<'a> AsyncHTTP<'a> {
 // HTTPCallbackPair / HTTPChannel / HTTPChannelContext
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: `HTTPCallbackPair` was Zig anonymous tuple `.{ *AsyncHTTP, HTTPClientResult }`.
 // `bun_threading::Channel` requires `T: Copy`, which `HTTPClientResult` is not, so the
 // `HTTPChannel` here boxes the pair and ships the pointer (which IS `Copy`) through
 // a static-buffer channel. The receiver takes ownership of the Box.
@@ -922,9 +904,8 @@ pub type HTTPChannel = bun_threading::Channel<
 
 pub struct HTTPChannelContext<'a> {
     pub http: AsyncHTTP<'a>,
-    // TODO(port): lifetime — no init/assignment found in src/http/; appears unused.
     // BACKREF: set once by the owner before scheduling; the channel outlives
-    // every callback dispatched through it (Zig dereferenced unconditionally).
+    // every callback dispatched through it.
     pub channel: Option<bun_ptr::BackRef<HTTPChannel>>,
 }
 
@@ -980,5 +961,3 @@ impl AtomicState {
         }
     }
 }
-
-// ported from: src/http/AsyncHTTP.zig
diff --git a/src/http/CertificateInfo.rs b/src/http/CertificateInfo.rs
index 0a7382f02a4..1b50b633b30 100644
--- a/src/http/CertificateInfo.rs
+++ b/src/http/CertificateInfo.rs
@@ -6,9 +6,5 @@ pub struct CertificateInfo {
     pub hostname: Box<[u8]>,
 }
 
-// PORT NOTE: Zig `deinit` took an allocator and freed `cert`, `cert_error.code`,
-// `cert_error.reason`, and `hostname`. In Rust these are `Box<[u8]>` (here and
-// in `HTTPCertError`) and drop automatically at scope exit — no explicit `Drop`
-// impl needed. The allocator param is deleted per §Allocators.
-
-// ported from: src/http/CertificateInfo.zig
+// All owned fields are `Box<[u8]>` (here and in `HTTPCertError`) and drop
+// automatically — no explicit `Drop` impl needed.
diff --git a/src/http/Decompressor.rs b/src/http/Decompressor.rs
index 6c550c9c20e..6959313529e 100644
--- a/src/http/Decompressor.rs
+++ b/src/http/Decompressor.rs
@@ -6,11 +6,9 @@ use bun_brotli::BrotliReaderArrayList;
 use bun_zlib::ZlibReaderArrayList;
 use bun_zstd::ZstdReaderArrayList;
 
-// PORT NOTE: the `*ReaderArrayList<'a>` types carry a `&'a mut Vec<u8>` borrow
-// of the output buffer (and a `&'a [u8]` of the input). The Zig held them by
-// value with the `ArrayListUnmanaged` aliased into the reader (raw ptr/len/cap
-// triple). In Rust we erase the borrow to `'static` and uphold the same
-// invariant the Zig code relied on: the reader never outlives the
+// Note: the `*ReaderArrayList<'a>` types carry a `&'a mut Vec<u8>` borrow
+// of the output buffer (and a `&'a [u8]` of the input). We erase the borrow
+// to `'static` and uphold the invariant that the reader never outlives the
 // `body_out_str`/`buffer` it was constructed with — both are owned by the
 // surrounding `HTTPClient` request lifecycle and the `Decompressor` is dropped
 // (or reset to `None`) in `InternalState::deinit` before either buffer is
@@ -60,12 +58,10 @@ unsafe fn seat<'a>(input: &'a [u8], out: &'a mut Vec<u8>) -> (&'static [u8], &'s
 const MAX_DECOMPRESSED_BODY_SIZE: usize = 1024 * 1024 * 1024;
 
 impl Decompressor {
-    // PORT NOTE: Zig `deinit` called `that.deinit()` on the active reader and
-    // reset to `.none`. The boxed readers' `Drop` impls call `end()`, so an
+    // Note: the boxed readers' `Drop` impls call `end()`, so an
     // explicit `Drop` is unnecessary. Callers that want a mid-lifecycle reset
     // assign `*self = Decompressor::None`.
 
-    // TODO(port): narrow error set
     pub fn update_buffers(
         &mut self,
         encoding: Encoding,
@@ -85,8 +81,6 @@ impl Decompressor {
                     let mut reader = ZlibReaderArrayList::init_with_options_and_list_allocator(
                         input,
                         out,
-                        // PORT NOTE: Zig passed `body_out_str.allocator` and
-                        // `bun.http.default_allocator`; dropped per §Allocators.
                         bun_zlib::Options {
                             // zlib.MAX_WBITS = 15
                             // to (de-)compress deflate format, use wbits = -zlib.MAX_WBITS
@@ -107,23 +101,14 @@ impl Decompressor {
                     return Ok(());
                 }
                 Encoding::Brotli => {
-                    let mut reader = BrotliReaderArrayList::new_with_options(
-                        input,
-                        out,
-                        // PORT NOTE: Zig passed `body_out_str.allocator`; dropped per §Allocators.
-                        &Default::default(),
-                    )?;
+                    let mut reader =
+                        BrotliReaderArrayList::new_with_options(input, out, &Default::default())?;
                     reader.max_output_size = MAX_DECOMPRESSED_BODY_SIZE;
                     *self = Decompressor::Brotli(reader);
                     return Ok(());
                 }
                 Encoding::Zstd => {
-                    let mut reader = ZstdReaderArrayList::init_with_list_allocator(
-                        input,
-                        out,
-                        // PORT NOTE: Zig passed `body_out_str.allocator` and
-                        // `bun.http.default_allocator`; dropped per §Allocators.
-                    )?;
+                    let mut reader = ZstdReaderArrayList::init_with_list_allocator(input, out)?;
                     reader.max_output_size = MAX_DECOMPRESSED_BODY_SIZE;
                     *self = Decompressor::Zstd(reader);
                     return Ok(());
@@ -139,9 +124,8 @@ impl Decompressor {
                 reader.zlib.avail_in = buffer.len() as u32;
 
                 let initial = body_out_str.list.len();
-                // PORT NOTE: Zig `expandToCapacity()` set `len = capacity` so the
-                // zlib output pointers could write into the spare region while
-                // `read_all` later truncated back to `total_out`. `read_all`'s
+                // Note: the zlib output pointers write into the spare region
+                // while `read_all` later truncates back to `total_out`. `read_all`'s
                 // grow-on-avail_out==0 path reads `list_ptr.len()` to compute the
                 // resume offset, so this `set_len(capacity)` is load-bearing —
                 // skipping it leaves `len == initial` and the next grow rewinds
@@ -152,9 +136,8 @@ impl Decompressor {
                 if body_out_str.list.capacity() == initial {
                     body_out_str.list.reserve(4096);
                 }
-                // PORT NOTE: Zig `reader.list = body_out_str.list` aliased the
-                // ArrayListUnmanaged header by value. The Rust reader keeps a
-                // `&mut Vec<u8>` instead; re-seat it in case the response buffer
+                // Note: the reader keeps a `&mut Vec<u8>`;
+                // re-seat it in case the response buffer
                 // was swapped between chunks. After re-seating, derive
                 // `next_out`/`avail_out` from `reader.list_ptr` (NOT
                 // `body_out_str.list`) — taking a fresh `&mut body_out_str.list`
@@ -178,7 +161,6 @@ impl Decompressor {
                 let (input, out) = unsafe { seat(buffer, &mut body_out_str.list) };
                 reader.input = input;
                 reader.total_in = 0;
-                // PORT NOTE: Zig aliased the ArrayList header; re-seat list_ptr instead.
                 reader.list_ptr = out;
                 reader.total_out = initial;
             }
@@ -188,7 +170,6 @@ impl Decompressor {
                 let (input, out) = unsafe { seat(buffer, &mut body_out_str.list) };
                 reader.input = input;
                 reader.total_in = 0;
-                // PORT NOTE: Zig aliased the ArrayList header; re-seat list_ptr instead.
                 reader.list_ptr = out;
                 reader.total_out = initial;
             }
@@ -200,7 +181,6 @@ impl Decompressor {
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn read_all(&mut self, is_done: bool) -> Result<(), bun_core::Error> {
         match self {
             Decompressor::Zlib(zlib) => zlib.read_all(is_done)?,
@@ -211,5 +191,3 @@ impl Decompressor {
         Ok(())
     }
 }
-
-// ported from: src/http/Decompressor.zig
diff --git a/src/http/H2Client.rs b/src/http/H2Client.rs
index 2c780fc0e43..6ff04646c28 100644
--- a/src/http/H2Client.rs
+++ b/src/http/H2Client.rs
@@ -12,8 +12,7 @@ use core::sync::atomic::AtomicI32;
 
 /// Advertised as SETTINGS_INITIAL_WINDOW_SIZE; replenished via WINDOW_UPDATE
 /// once half has been consumed.
-// PORT NOTE: Zig type was `u31` (HTTP/2 window sizes are 31-bit); Rust has no
-// `u31`, so widen to `u32`. Value `1 << 24` is well within range.
+// HTTP/2 window sizes are 31-bit on the wire; `1 << 24` is well within range.
 pub(crate) const LOCAL_INITIAL_WINDOW_SIZE: u32 = 1 << 24;
 
 /// Advertised as SETTINGS_MAX_HEADER_LIST_SIZE and enforced as a hard cap on
@@ -37,10 +36,9 @@ pub const WRITE_BUFFER_CONTROL_LIMIT: usize = 1024 * 1024;
 /// Live-object counters for the leak test in fetch-http2-leak.test.ts.
 /// Incremented at allocation, decremented in deinit. Read from the JS thread
 /// via TestingAPIs.liveCounts so they must be atomic.
-// PORT NOTE: Zig names are `live_sessions`/`live_streams` (snake_case module
-// vars). Kept verbatim so cross-crate readers (`bun_http_jsc`) and the gated
-// submodules see the same identifier the Zig uses; SCREAMING_SNAKE aliases
-// preserved for the existing internal references.
+// Lower-case names kept so cross-crate readers (`bun_http_jsc`) and the gated
+// submodules share one identifier; SCREAMING_SNAKE aliases preserved for the
+// existing internal references.
 #[allow(non_upper_case_globals)]
 pub static live_sessions: AtomicI32 = AtomicI32::new(0);
 #[allow(non_upper_case_globals)]
@@ -66,10 +64,6 @@ pub use client_session::ClientSession;
 pub use pending_connect::PendingConnect;
 pub use stream::Stream;
 
-// PORT NOTE: Zig had `pub const TestingAPIs = @import("../http_jsc/headers_jsc.zig").H2TestingAPIs;`
-// — a `*_jsc` alias. Deleted per PORTING.md: `to_js`/host-fn surfaces live in the
-// `*_jsc` crate via extension traits; the base crate has no mention of jsc.
-
 // ═══════════════════════════════════════════════════════════════════════
 // Thin `h2_*` forwarders on HTTPClient / HTTPContext that the h2_client
 // modules call. The real bodies live in lib.rs
@@ -136,9 +130,8 @@ pub(crate) mod bridge {
             // slices point only at (a) the thread-local
             // `SHARED_REQUEST_HEADERS_BUF` static and (b) `self.header_buf`,
             // which is itself `&'static [u8]` — neither is tied to the `&mut
-            // self` borrow. Erasing to `'static` matches the Zig
-            // `buildRequest` (returns slices into module-static storage) and
-            // lets `ClientSession::attach` re-borrow `client` while the
+            // self` borrow. Erasing to `'static` lets
+            // `ClientSession::attach` re-borrow `client` while the
             // `Request` is still live. Same pattern as lib.rs `on_writable`.
             unsafe { self.build_request(body_len).detach_lifetime() }
         }
@@ -151,5 +144,3 @@ pub(crate) mod bridge {
         }
     }
 }
-
-// ported from: src/http/H2Client.zig
diff --git a/src/http/H3Client.rs b/src/http/H3Client.rs
index 9acb9922725..384647ff5bf 100644
--- a/src/http/H3Client.rs
+++ b/src/http/H3Client.rs
@@ -32,10 +32,9 @@ pub mod pending_connect;
 #[path = "h3_client/Stream.rs"]
 pub mod stream;
 
-// Single `Output.scoped(.h3_client, .hidden)` for the whole module tree. Zig
-// comptime-deduplicates per tag, so the four submodules share one
-// `really_disable`/`is_visible_once`/lock; declaring it once here and importing
-// in each child preserves that behavior.
+// Single `Output.scoped(.h3_client, .hidden)` for the whole module tree:
+// the submodules share one `really_disable`/`is_visible_once`/lock by
+// declaring it once here and importing it in each child.
 bun_core::declare_scope!(h3_client, hidden);
 
 pub use client_context::ClientContext;
@@ -46,10 +45,9 @@ pub use stream::Stream;
 /// Live-object counters for the leak test in fetch-http3-client.test.ts.
 /// Incremented at allocation, decremented in deinit. Read from the JS thread
 /// via TestingAPIs.quicLiveCounts so they must be atomic.
-// PORT NOTE: Zig names are `live_sessions`/`live_streams` (snake_case module
-// vars). Kept verbatim so cross-crate readers (`bun_http_jsc`) and the gated
-// submodules see the same identifier the Zig uses; SCREAMING_SNAKE aliases
-// preserved for the existing internal references.
+// Lower-case names kept so cross-crate readers (`bun_http_jsc`) and the gated
+// submodules share one identifier; SCREAMING_SNAKE aliases preserved for the
+// existing internal references.
 #[allow(non_upper_case_globals)]
 pub static live_sessions: AtomicU32 = AtomicU32::new(0);
 #[allow(non_upper_case_globals)]
@@ -57,8 +55,5 @@ pub static live_streams: AtomicU32 = AtomicU32::new(0);
 pub use live_sessions as LIVE_SESSIONS;
 pub use live_streams as LIVE_STREAMS;
 
-// Zig: pub const TestingAPIs = @import("../http_jsc/headers_jsc.zig").H3TestingAPIs;
-// Deleted per PORTING.md — *_jsc aliases are dropped; H3TestingAPIs lives in
-// bun_http_jsc and is accessed via the extension-trait pattern there.
-
-// ported from: src/http/H3Client.zig
+// H3TestingAPIs lives in bun_http_jsc and is accessed via the
+// extension-trait pattern there.
diff --git a/src/http/HTTPCertError.rs b/src/http/HTTPCertError.rs
index ae3dd64e7c4..9a955fb5741 100644
--- a/src/http/HTTPCertError.rs
+++ b/src/http/HTTPCertError.rs
@@ -2,9 +2,10 @@ use bun_core::ZStr;
 
 pub struct HTTPCertError {
     pub error_no: i32,
-    // TODO(port): CertificateInfo.deinit frees code/reason — ownership unclear
-    // (borrowed in onHandshake, owned via dupeZ in CertificateInfo / http.zig:115).
-    // May need owned NUL-terminated type (Box<ZStr> / ZString) instead of &'static.
+    // `code`/`reason` borrow process-lifetime static string tables (uSockets'
+    // verify-error strings and BoringSSL's `X509_verify_cert_error_string`
+    // literals — see the SAFETY note in `from_verify_error`), so nothing owns
+    // or frees them here.
     pub code: &'static ZStr,
     pub reason: &'static ZStr,
 }
@@ -26,13 +27,13 @@ impl HTTPCertError {
     /// (outer-TLS in `HTTPContext::Handler::on_handshake`, inner-TLS in
     /// `ProxyTunnel::on_handshake`) doesn't repeat the raw deref.
     ///
-    /// Mirrors http.zig: `reason` is gated on `code` being non-null (the
+    /// `reason` is gated on `code` being non-null (the
     /// uSockets API populates both together or neither).
     pub fn from_verify_error(ssl_error: bun_uws::us_bun_verify_error_t) -> Self {
         /// Borrow a NUL-terminated C string from uSockets as `&'static ZStr`.
-        /// The string is owned by the long-lived SSL session and outlives the
-        /// `on_handshake` dispatch; widened to `'static` to match the field
-        /// type (see TODO above re: ownership).
+        /// Both sources are process-lifetime static string tables (see the
+        /// SAFETY note below), so the `'static` widen is genuine, not a
+        /// convenience.
         #[inline]
         fn zstr(p: *const core::ffi::c_char) -> &'static ZStr {
             // SAFETY: (`bun_ptr::Interned`-style audit — Population A,
@@ -58,5 +59,3 @@ impl HTTPCertError {
         }
     }
 }
-
-// ported from: src/http/HTTPCertError.zig
diff --git a/src/http/HTTPContext.rs b/src/http/HTTPContext.rs
index ef19a9a2a26..f62929bf2bc 100644
--- a/src/http/HTTPContext.rs
+++ b/src/http/HTTPContext.rs
@@ -19,12 +19,8 @@ bun_core::declare_scope!(HTTPContext, hidden);
 const POOL_SIZE: usize = 64;
 const MAX_KEEPALIVE_HOSTNAME: usize = 128;
 
-/// Zig: `fn NewHTTPContext(comptime ssl: bool) type { return struct { ... } }`
 /// The const-generic `SSL` is load-bearing for monomorphization (gates hot
 /// inner-loop branches); do not demote to a runtime bool.
-// PORT NOTE: renamed NewHTTPContext→HTTPContext — `New` is a Zig type-factory
-// naming convention, not part of the type's identity; LIFETIMES.tsv already
-// aliases `*NewHTTPContext(true)` as `HttpsContext`.
 #[derive(bun_ptr::CellRefCounted)]
 pub struct HTTPContext<const SSL: bool> {
     /// Heap-allocated custom-SSL contexts only. The cache entry in
@@ -46,21 +42,21 @@ pub struct HTTPContext<const SSL: bool> {
     pub secure: Option<*mut SSL_CTX>,
     /// HTTP/2 sessions with at least one active stream, available for
     /// concurrent attachment if `hasHeadroom()`.
-    // TODO(port): lifetime — Zig stores `*H2.ClientSession` with manual
-    // `.ref()`/`.deref()`. Kept as raw pointers; ref/deref is intrusive.
+    // Raw pointers; the intrusive refcount (bumped on insert, dropped on
+    // removal) is what keeps each session alive while listed here.
     pub active_h2_sessions: Vec<*mut h2::ClientSession>,
     /// HTTPClients whose fresh TLS connect is in flight and whose request
     /// is h2-capable. Subsequent h2-capable requests to the same origin
     /// coalesce onto the first one's session once ALPN resolves rather
     /// than each opening its own socket.
-    // TODO(port): lifetime — owned Box<PendingConnect>; `pc.deinit()` in Drop.
-    // The `Box` is load-bearing: `client.pending_h2` holds `NonNull<PendingConnect>`
+    // Owned Box<PendingConnect>; `pc.deinit()` runs in Drop. The `Box` is
+    // load-bearing: `client.pending_h2` holds `NonNull<PendingConnect>`
     // into the box interior; unboxing would dangle it on `Vec` realloc.
     #[expect(clippy::vec_box)]
     pub pending_h2_connects: Vec<Box<h2::PendingConnect>>,
 }
 
-// Intrusive refcount: Zig `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`.
+// Intrusive refcount:
 // `*T` crosses FFI (group.ext) and is recovered from socket ext, so per
 // PORTING.md this stays intrusive rather than `Rc<T>`. Derived via
 // `#[derive(CellRefCounted)]` above; default `destroy` (`heap::take`) applies
@@ -79,8 +75,7 @@ pub(crate) type ActiveSocket<const SSL: bool> = TaggedPtrUnion<ActiveSocketTypes
 /// is foreign even when every element is local).
 pub(crate) struct ActiveSocketTypes<const SSL: bool>;
 
-// PORT NOTE: tags assigned 1024 - i to match Zig's `TagTypeEnumWithTypeMap`
-// (`@typeName(Types[0])` → 1024, descending).
+// Note: tags assigned 1024 - i, descending.
 impl<const SSL: bool> bun_ptr::tagged_pointer::TypeList for ActiveSocketTypes<SSL> {
     const LEN: usize = 4;
     const MIN_TAG: bun_ptr::tagged_pointer::TagType = 1024 - 3;
@@ -253,7 +248,7 @@ impl<const SSL: bool> PooledSocket<SSL> {
     /// Centralises the intrusive-rc `deref` so each caller doesn't repeat the
     /// pair of `unsafe { …::deref(nn.as_ptr()) }`.
     fn release_parked_refs(&mut self) {
-        // Not gated on `comptime ssl` — an HTTP-proxy-to-HTTPS tunnel pools in
+        // Cleared even for the non-SSL context — an HTTP-proxy-to-HTTPS tunnel pools in
         // the non-SSL context but still stores the inner-TLS tls_props here for
         // pool-key matching.
         self.ssl_config = None;
@@ -292,11 +287,10 @@ impl<const SSL: bool> ExistingSocket<SSL> {
     }
 }
 
-/// `dispatch.zig` reaches `Handler` via this name. The ext stores
-/// `*anyopaque` (the `ActiveSocket` tagged pointer), so dispatch reads
-/// it as `**anyopaque` and `Handler` decodes the tag.
-// PORT NOTE: was `pub type ActiveSocketHandler = Handler<SSL>;` (inherent
-// associated type — unstable). Hoisted to a free alias.
+/// The ext stores `*anyopaque` (the `ActiveSocket` tagged pointer), so
+/// dispatch reads it as `**anyopaque` and `Handler` decodes the tag.
+// Note: a `pub type ActiveSocketHandler = Handler<SSL>;` inherent
+// associated type is unstable, so this is a free alias.
 pub type ActiveSocketHandler<const SSL: bool> = Handler<SSL>;
 
 impl<const SSL: bool> HTTPContext<SSL> {
@@ -409,7 +403,7 @@ impl<const SSL: bool> HTTPContext<SSL> {
         if s.registry_index() != u32::MAX {
             return;
         }
-        // PORT NOTE: `session.ref()` — intrusive refcount bump.
+        // Note: `session.ref()` — intrusive refcount bump.
         s.ref_();
         s.set_registry_index(u32::try_from(self.active_h2_sessions.len()).expect("int cast"));
         self.active_h2_sessions.push(session);
@@ -490,9 +484,8 @@ impl<const SSL: bool> HTTPContext<SSL> {
         &mut self,
         client: &mut HTTPClient,
     ) -> Result<(), InitError> {
-        // TODO(port): `if (!comptime ssl) @compileError("ssl only")` — Rust
-        // cannot @compileError on a const-generic bool branch without nightly;
-        // debug_assert until the SSL/non-SSL impls are split.
+        // Rust cannot reject a const-generic bool branch at compile time on
+        // stable, so this is a debug_assert.
         debug_assert!(SSL, "ssl only");
         let opts = client
             .tls_props
@@ -843,7 +836,6 @@ impl<const SSL: bool> HTTPContext<SSL> {
         client: &mut HTTPClient,
         socket_path: &[u8],
     ) -> Result<Option<HTTPSocket<SSL>>, Error> {
-        // TODO(port): narrow error set
         client.connected_url = client
             .http_proxy
             .clone()
@@ -872,7 +864,6 @@ impl<const SSL: bool> HTTPContext<SSL> {
         hostname_: &[u8],
         port: u16,
     ) -> Result<Option<HTTPSocket<SSL>>, Error> {
-        // TODO(port): narrow error set
         let hostname: &[u8] =
             if FeatureFlags::HARDCODE_LOCALHOST_TO_127_0_0_1 && hostname_ == b"localhost" {
                 b"127.0.0.1"
@@ -884,9 +875,8 @@ impl<const SSL: bool> HTTPContext<SSL> {
             .http_proxy
             .clone()
             .unwrap_or_else(|| client.url.clone());
-        // TODO(port): URL.hostname is a borrowed slice — assigning a local
-        // overwrites lifetime. Preserved as-is via raw lifetime erasure matching
-        // the Zig pointer assignment semantics.
+        // URL.hostname is a borrowed slice — assigning a local would not
+        // satisfy the field's lifetime, so this uses raw lifetime erasure.
         client.connected_url.hostname =
             // SAFETY: hostname borrows either a static literal or `client.url`/
             // `client.http_proxy` which outlive `connected_url` for the
@@ -989,7 +979,7 @@ impl<const SSL: bool> HTTPContext<SSL> {
                 client.allow_retry = true;
                 if let Some(session) = found.h2_session {
                     if SSL {
-                        // PORT NOTE: `session.socket = sock` — direct field
+                        // Note: `session.socket = sock` — direct field
                         // write; ClientSession.socket is `HTTPSocket<true>`.
                         // Re-derive `&mut` at each step (via the accessor)
                         // rather than holding one across `register_h2` — that
@@ -1099,19 +1089,19 @@ impl<const SSL: bool> Drop for HTTPContext<SSL> {
             }
         }
 
-        // PORT NOTE: Vec drop subsumes `active_h2_sessions.deinit()`.
-        // PORT NOTE: Box<PendingConnect> Drop subsumes `pc.deinit()`; Vec drop
+        // Note: Vec drop subsumes `active_h2_sessions.deinit()`.
+        // Note: Box<PendingConnect> Drop subsumes `pc.deinit()`; Vec drop
         // subsumes `pending_h2_connects.deinit()`.
 
         // `init_with_opts` can fail before `group.init()` runs (HTTPThread
-        // cache-miss error path frees the half-init context). Spec
-        // HTTPThread.zig:277 raw-frees without `deinit`; tolerate that here
-        // by skipping group teardown when it was never linked into the loop.
+        // cache-miss error path frees the half-init context); tolerate that
+        // here by skipping group teardown when it was never linked into the
+        // loop.
         if !self.group.loop_.is_null() {
             // Force-close any remaining sockets before unlinking the group so
             // the loop never dereferences a freed `*Context` via `group->ext`.
             self.group.close_all();
-            // PORT NOTE: SocketGroup deinit must run before the embedding struct
+            // Note: SocketGroup deinit must run before the embedding struct
             // is freed (it unlinks from the loop's group list).
             // SAFETY: group was init()'d in `init`/`init_with_opts`; HTTP-thread-only.
             unsafe { uws::SocketGroup::destroy(&raw mut self.group) };
@@ -1122,13 +1112,12 @@ impl<const SSL: bool> Drop for HTTPContext<SSL> {
                 unsafe { bun_boringssl_sys::SSL_CTX_free(c) };
             }
         }
-        // PORT NOTE: `bun.default_allocator.destroy(this)` is the Box drop
+        // Note: `bun.default_allocator.destroy(this)` is the Box drop
         // performed by IntrusiveRc when refcount hits 0; not repeated here.
     }
 }
 
-/// Named so `dispatch.zig` can `vtable.make` it. Ext is the
-/// `ActiveSocket` tagged-pointer word.
+/// Ext is the `ActiveSocket` tagged-pointer word.
 pub struct Handler<const SSL: bool>;
 
 impl<const SSL: bool> Handler<SSL> {
@@ -1373,14 +1362,11 @@ pub(crate) struct DeadSocket {
     garbage: u8,
 }
 
-// TODO(port): Zig used `pub var dead_socket align(@alignOf(usize)) = .{}` and
-// a module-level `var dead_socket = &DeadSocket.dead_socket`. Using a static
-// + accessor; revisit if `&'static mut` is needed for TaggedPtrUnion::init.
+// A shared static + accessor; the pointer is only ever compared, never
+// written through.
 static DEAD_SOCKET: DeadSocket = DeadSocket { garbage: 0 };
 
 #[inline]
 fn dead_socket() -> *const DeadSocket {
     &raw const DEAD_SOCKET
 }
-
-// ported from: src/http/HTTPContext.zig
diff --git a/src/http/HTTPRequestBody.rs b/src/http/HTTPRequestBody.rs
index a58cb794d8e..13f00a5808d 100644
--- a/src/http/HTTPRequestBody.rs
+++ b/src/http/HTTPRequestBody.rs
@@ -4,9 +4,9 @@ use crate::ThreadSafeStreamBuffer;
 /// Request body payload. Parameterized over `'a` so callers can hand in
 /// stack-/arena-borrowed bytes without erasing the lifetime to `&'static`
 /// at every `AsyncHTTP::init` call site.
-// PORT NOTE: no `Owned(Vec<u8>)` variant — the body is bitwise-copied across
-// threads via `core::ptr::read` in `start_queued_task`, so every arm must be
-// trivially-droppable. Zig has only `bytes` / `sendfile` / `stream`.
+// No `Owned(Vec<u8>)` variant — the body is bitwise-copied across threads via
+// `core::ptr::read` in `start_queued_task`, so every arm must be
+// trivially-droppable.
 pub enum HTTPRequestBody<'a> {
     /// Borrowed bytes — caller guarantees they outlive the request.
     Bytes(&'a [u8]),
@@ -15,10 +15,10 @@ pub enum HTTPRequestBody<'a> {
 }
 
 pub struct Stream {
-    // PORT NOTE: ThreadSafeStreamBuffer carries an *intrusive* atomic refcount and
-    // is round-tripped as a raw pointer between the main thread and the HTTP
-    // thread, so per §Pointers we keep the intrusive form (raw `*mut T` + manual
-    // ref/deref) instead of `Arc<T>`.
+    // ThreadSafeStreamBuffer carries an *intrusive* atomic refcount and is
+    // round-tripped as a raw pointer between the main thread and the HTTP
+    // thread, so we keep the intrusive form (raw pointer + manual ref/deref)
+    // instead of `Arc<T>`.
     pub buffer: Option<core::ptr::NonNull<ThreadSafeStreamBuffer>>,
     pub ended: bool,
 }
@@ -40,7 +40,7 @@ impl Stream {
 
     pub fn detach(&mut self) {
         if let Some(buffer) = self.buffer.take() {
-            // matches Zig `buffer.deref()` — intrusive refcount decrement.
+            // Intrusive refcount decrement.
             // `buffer` is a live `ThreadSafeStreamBuffer::new` heap allocation;
             // this side holds the intrusive ref taken at attach, released here.
             ThreadSafeStreamBuffer::deref(buffer);
@@ -50,8 +50,8 @@ impl Stream {
 
 // No `Drop` for `Stream`: the body is bitwise-copied across threads
 // (`core::ptr::read` in `start_queued_task`), so auto-dropping the
-// JS-thread original would over-deref the shared buffer. Mirrors Zig,
-// where `HTTPRequestBody.deinit()` is explicit.
+// JS-thread original would over-deref the shared buffer;
+// `HTTPRequestBody::deinit()` is explicit instead.
 
 impl<'a> HTTPRequestBody<'a> {
     pub const EMPTY: HTTPRequestBody<'static> = HTTPRequestBody::Bytes(b"");
@@ -86,5 +86,3 @@ impl<'a> HTTPRequestBody<'a> {
         }
     }
 }
-
-// ported from: src/http/HTTPRequestBody.zig
diff --git a/src/http/HTTPThread.rs b/src/http/HTTPThread.rs
index 04230f29954..ad7ede90683 100644
--- a/src/http/HTTPThread.rs
+++ b/src/http/HTTPThread.rs
@@ -15,10 +15,10 @@ use crate::proxy_tunnel::ProxyTunnel;
 use crate::ssl_config::{self, SSLConfig};
 use crate::{AsyncHttp, HTTPContext, HttpClient, InitError, NewHttpContext, h3};
 
+// The scope registry keys on name, so the two visibilities (.hidden +
+// .visible) are split into two scope names.
 bun_core::declare_scope!(HTTPThread, hidden); // threadlog
 bun_core::declare_scope!(HTTPThread_log, visible); // log
-// TODO(port): Zig had two `Output.scoped(.HTTPThread, ...)` with different visibilities (.hidden + .visible).
-// Rust scope registry keys on name; pick one visibility or split scope names.
 
 /// SSL context cache keyed by interned SSLConfig pointer.
 /// Since configs are interned via SSLConfig.GlobalRegistry, pointer equality
@@ -61,7 +61,7 @@ impl SslContextCacheEntry {
     }
 }
 const SSL_CONTEXT_CACHE_MAX_SIZE: usize = 60;
-const SSL_CONTEXT_CACHE_TTL_NS: u64 = 30 * (60 * 1_000_000_000); // 30 * std.time.ns_per_min
+const SSL_CONTEXT_CACHE_TTL_NS: u64 = 30 * (60 * 1_000_000_000); // 30 minutes
 
 // PORTING.md §Global mutable state: only ever accessed from the single HTTP
 // client thread after `on_start`. RacyCell — thread affinity is the contract.
@@ -85,9 +85,7 @@ use bun_event_loop::MiniEventLoop::MiniEventLoop;
 
 pub struct HttpThread {
     /// Per-thread `MiniEventLoop` singleton — published by
-    /// `MiniEventLoop::init_global()` in [`on_start`]; outlives the thread
-    /// (Zig: `bun.http.http_thread.loop = bun.jsc.MiniEventLoop.initGlobal(null, null)`,
-    /// HTTPThread.zig:228+235).
+    /// `MiniEventLoop::init_global()` in [`on_start`]; outlives the thread.
     pub loop_: *const MiniEventLoop<'static>,
     /// The raw uSockets loop inside `loop_.loop` — split out so HTTPContext
     /// can `SocketGroup::init` without naming MiniEventLoop.
@@ -150,10 +148,9 @@ pub struct HttpThread {
 }
 
 impl HttpThread {
-    /// Mirror of Zig `initOnce`'s `bun.http.http_thread = .{ ... }` field-init
-    /// list (HTTPThread.zig:195-206). `loop_`/`uws_loop` are filled in by
+    /// `loop_`/`uws_loop` are filled in by
     /// `on_start` on the spawned thread; `timer` is started on the calling
-    /// thread per spec.
+    /// thread.
     fn new() -> Self {
         Self {
             loop_: core::ptr::null(),
@@ -198,8 +195,7 @@ impl HttpThread {
 
 pub struct HeapRequestBodyBuffer {
     pub buffer: [u8; 512 * 1024],
-    // TODO(port): was `std.heap.FixedBufferAllocator` borrowing `buffer` —
-    // self-referential. Use bun_alloc::FixedBufferAllocator or just a cursor.
+    // Plain write cursor into `buffer`.
     pub cursor: usize,
 }
 
@@ -208,7 +204,6 @@ unsafe impl bun_core::Zeroable for HeapRequestBodyBuffer {}
 
 impl HeapRequestBodyBuffer {
     pub fn init() -> Box<Self> {
-        // TODO(port): self-referential init; FixedBufferAllocator borrows this.buffer.
         bun_core::boxed_zeroed()
     }
 
@@ -228,8 +223,7 @@ impl HeapRequestBodyBuffer {
 pub enum RequestBodyBuffer {
     // Option<> so Drop can `.take()` the Box and hand it to `put()` (which consumes by value).
     Heap(Option<Box<HeapRequestBodyBuffer>>),
-    // PERF(port): was std.heap.StackFallbackAllocator(32KB) — inline stack buffer with heap fallback.
-    // TODO(port): bun_alloc::StackFallbackAllocator<REQUEST_BODY_SEND_STACK_BUFFER_SIZE>
+    // Inline stack buffer with a heap fallback.
     Stack(Box<[u8; REQUEST_BODY_SEND_STACK_BUFFER_SIZE]>),
 }
 
@@ -252,10 +246,9 @@ impl RequestBodyBuffer {
     }
 
     pub(crate) fn to_array_list(&mut self) -> Vec<u8> {
-        // TODO(port): Zig built an ArrayList over self.arena()/self.allocated_slice() with len=0.
-        // Rust Vec cannot adopt a foreign allocator+buffer; expose a cursor type instead.
-        // PERF(port): was FixedBufferAllocator/StackFallback (allocator() accessor
-        // dropped per PORTING.md non-AST rule; callers should write into allocated_slice() directly).
+        // A `Vec` cannot adopt a foreign allocator+buffer, so this
+        // allocates a fresh Vec of the same capacity.
+        // Callers that can should write into allocated_slice() directly instead.
         let mut arraylist = Vec::with_capacity(self.allocated_slice().len());
         arraylist.clear();
         arraylist
@@ -267,7 +260,7 @@ pub struct WriteMessage {
     pub kind: WriteMessageType,
 }
 
-#[repr(u8)] // Zig: enum(u2)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum WriteMessageType {
     Data = 0,
@@ -320,11 +313,12 @@ pub const REQUEST_BODY_SEND_STACK_BUFFER_SIZE: usize = 32 * 1024;
 pub(crate) type Queue = UnboundedQueue<AsyncHttp<'static>>;
 
 // Clone: bitwise OK for the `*const c_void` CA-string pointers — they borrow
-// caller-owned config (Zig `[]stringZ`), not heap we free. The `Vec` itself
+// caller-owned config, not heap we free. The `Vec` itself
 // deep-clones its slot list.
 #[derive(Clone)]
 pub struct InitOpts {
-    // TODO(port): lifetime — Zig `[]stringZ` borrowed from caller config; copied into spawned thread.
+    // NUL-terminated C strings borrowed from caller config; the pointers are
+    // copied into the spawned thread and only read there (see the Send SAFETY note).
     pub ca: Vec<*const c_void>, // *const [*:0]const u8
     pub abs_ca_file_name: &'static [u8],
     pub for_install: bool,
@@ -332,8 +326,8 @@ pub struct InitOpts {
     pub on_init_error: fn(err: InitError, opts: &InitOpts) -> !,
 }
 
-// SAFETY: `ca` holds borrowed `[*:0]const u8` C-string pointers from caller
-// config (Zig `[]stringZ`). They are copied into the spawned HTTP thread and
+// SAFETY: `ca` holds borrowed NUL-terminated C-string pointers from caller
+// config. They are copied into the spawned HTTP thread and
 // only read there; no shared mutable state crosses the thread boundary.
 unsafe impl Send for InitOpts {}
 
@@ -351,7 +345,7 @@ impl Default for InitOpts {
 fn on_init_error_noop(err: InitError, opts: &InitOpts) -> ! {
     match err {
         InitError::LoadCAFile => {
-            // SAFETY: `abs_ca_file_name` is Zig `stringZ` (`[:0]const u8`) by
+            // SAFETY: `abs_ca_file_name` is NUL-terminated by
             // contract — already passed as a C string to BoringSSL via
             // `init_with_thread_opts`, so `ptr[len] == 0` holds.
             let path = unsafe {
@@ -413,8 +407,8 @@ impl HttpThread {
         unsafe { &mut *self.uws_loop }
     }
 
-    /// Zig `timer.read()` returns u64 ns directly; Rust `Instant::elapsed().as_nanos()` is u128.
-    /// Checked narrow — overflows only after ~584 years of process uptime.
+    /// `Instant::elapsed().as_nanos()` is u128; checked narrow to u64 —
+    /// overflows only after ~584 years of process uptime.
     #[inline]
     fn timer_read(&self) -> u64 {
         u64::try_from(self.timer.elapsed().as_nanos()).expect("int cast")
@@ -434,7 +428,6 @@ impl HttpThread {
 
             return RequestBodyBuffer::Heap(self.lazy_request_body_buffer.take());
         }
-        // PERF(port): was std.heap.stackFallback(REQUEST_BODY_SEND_STACK_BUFFER_SIZE, default_allocator)
         RequestBodyBuffer::Stack(Box::new([0u8; REQUEST_BODY_SEND_STACK_BUFFER_SIZE]))
     }
 
@@ -453,7 +446,7 @@ impl HttpThread {
     }
 
     pub fn context<const IS_SSL: bool>(&mut self) -> &mut NewHttpContext<IS_SSL> {
-        // PORT NOTE: const-generic dispatch over two distinct fields — `NewHttpContext<true>`
+        // Note: const-generic dispatch over two distinct fields — `NewHttpContext<true>`
         // and `NewHttpContext<IS_SSL>` are the same type when IS_SSL, just spelled
         // differently. Route through a raw-pointer `.cast()` (identity).
         if IS_SSL {
@@ -468,8 +461,7 @@ impl HttpThread {
     /// One-shot lazy init of the default HTTPS context. See
     /// [`HttpThread::lazy_https_init`] for rationale. Called on the HTTP
     /// thread from [`HttpThread::connect`]`::<true>` only; the `Option::take`
-    /// is the once-guard. On failure, `on_init_error` diverges (matching the
-    /// eager-init crash semantics from Zig `onStart`).
+    /// is the once-guard. On failure, `on_init_error` diverges.
     #[inline]
     fn ensure_https_context_init(&mut self) {
         if let Some(opts) = self.lazy_https_init.take() {
@@ -487,9 +479,7 @@ impl HttpThread {
     pub fn connect<const IS_SSL: bool>(
         &mut self,
         client: &mut HttpClient,
-    ) -> Result<Option<crate::HTTPSocket<IS_SSL>>, bun_core::Error>
-// TODO(port): narrow error set
-    {
+    ) -> Result<Option<crate::HTTPSocket<IS_SSL>>, bun_core::Error> {
         if IS_SSL {
             // First SSL connect: materialize the default HTTPS `SSL_CTX` +
             // socket group now (deferred from `on_start`). Runs once; every
@@ -497,7 +487,7 @@ impl HttpThread {
             // funnels through here before touching `https_context.{group,secure}`.
             self.ensure_https_context_init();
         }
-        // PORT NOTE: borrowck — `slice()` borrows `client`; capture into a
+        // Note: borrowck — `slice()` borrows `client`; capture into a
         // `bun_ptr::RawSlice` (encapsulated outlives-holder invariant) so the
         // borrow of `client` ends before we hand `&mut client` to
         // `connect_socket`. Backing storage is `client.unix_socket_path`, which
@@ -535,7 +525,7 @@ impl HttpThread {
                         let (hn, pt) = (client.url.hostname, client.url.get_port_auto());
                         ctx.connect(client, hn, pt)
                     }
-                    // PORT NOTE: NewHttpContext<true> == NewHttpContext<IS_SSL> here (IS_SSL branch).
+                    // Note: NewHttpContext<true> == NewHttpContext<IS_SSL> here (IS_SSL branch).
                     .map(|o| o.map(|s| s.cast_ssl::<IS_SSL>()));
                 }
 
@@ -549,9 +539,8 @@ impl HttpThread {
                     pending_h2_connects: Vec::new(),
                 }));
                 if let Err(err) = custom_context.init_with_client_config(client) {
-                    // Spec HTTPThread.zig:277 raw-frees without `deinit` here
-                    // because `initWithOpts` fails before `group.init()` runs.
-                    // `impl Drop for HTTPContext` now tolerates an
+                    // `init_with_client_config` fails before `group.init()` runs.
+                    // `impl Drop for HTTPContext` tolerates an
                     // uninitialized group (skips close_all/destroy when
                     // `group.loop_` is null), so reclaiming the Box is safe.
                     // SAFETY: custom_context was just Box::leak'd above and
@@ -602,7 +591,7 @@ impl HttpThread {
                     let (hn, pt) = (client.url.hostname, client.url.get_port_auto());
                     custom_context.connect(client, hn, pt)
                 };
-                // PORT NOTE: NewHttpContext<true> == NewHttpContext<IS_SSL> here (IS_SSL branch).
+                // Note: NewHttpContext<true> == NewHttpContext<IS_SSL> here (IS_SSL branch).
                 return result.map(|o| o.map(|s| s.cast_ssl::<IS_SSL>()));
             }
         }
@@ -1164,7 +1153,7 @@ fn start_queued_task(
 ) {
     // SAFETY: http points to a live AsyncHttp queued by the caller thread.
     let cloned = crate::ThreadlocalAsyncHttp::new(unsafe { core::ptr::read(http) });
-    // PORT NOTE: Zig used struct copy `http.*`; AsyncHttp is byte-copied here
+    // Note: AsyncHttp is byte-copied here
     // since the original stays valid (real owner is `http`, copy is the
     // HTTP-thread working set).
     let cloned = bun_core::heap::release(cloned);
@@ -1189,12 +1178,10 @@ fn abort_tracker() -> &'static mut ArrayHashMap<u32, uws::AnySocket> {
 use core::cell::Cell;
 
 // ═══════════════════════════════════════════════════════════════════════════
-// init / on_start / process_events — depends on `bun_event_loop::MiniEventLoop`
-// (higher-tier) for `loop_.loop_.{tick,inc,dec,num_polls}`. The wakeup path
-// above uses the raw `*mut uws::Loop` directly so the rest of the thread
-// machinery compiles; the actual event-loop drive stays gated until the tier
-// boundary is resolved.
-// TODO(port): MiniEventLoop is in bun_event_loop (not in bun_http deps).
+// init / on_start / process_events — uses `bun_event_loop::MiniEventLoop`
+// for `loop_.loop_.{tick,inc,dec,num_polls}` (`on_start` calls
+// `mini_event_loop::init_global` and drives the thread's event loop). The
+// wakeup path above still uses the raw `*mut uws::Loop` directly.
 // ═══════════════════════════════════════════════════════════════════════════
 
 mod _event_loop_draft {
@@ -1202,8 +1189,7 @@ mod _event_loop_draft {
     use std::sync::Once;
 
     static INIT_ONCE: Once = Once::new();
-    // PORT NOTE: Zig `std.Thread.spawn` + `.detach()` allocates nothing on the
-    // heap. Rust's `Builder::spawn` allocates an `Arc<thread::Inner>` (48 B)
+    // Note: `Builder::spawn` allocates an `Arc<thread::Inner>` (48 B)
     // shared between the `JoinHandle` and the new thread's TLS `current()`.
     // Dropping the handle leaves the only strong ref inside the spawned
     // thread's TLS, which LSAN does not scan as a root — so when the main
@@ -1211,7 +1197,7 @@ mod _event_loop_draft {
     // that TLS slot, LSAN reports the Arc as a direct leak and (with CI's
     // `abort_on_error=1`) the process SIGABRTs (exit 134). Park the handle in
     // a process-lifetime static so the Arc is always reachable from a global
-    // root, matching the Zig semantics of "detach" without the false positive.
+    // root, keeping detach semantics without the false positive.
     static HTTP_THREAD_HANDLE: std::sync::OnceLock<std::thread::JoinHandle<()>> =
         std::sync::OnceLock::new();
 
@@ -1220,7 +1206,7 @@ mod _event_loop_draft {
     }
 
     fn init_once(opts: &InitOpts) {
-        // Spec HTTPThread.zig:195-206 — initialize the global (with timer
+        // Initialize the global (with timer
         // started on the calling thread) BEFORE spawning, so `on_start`'s
         // `crate::http_thread_mut()` finds `Some(..)` and can fill in
         // `loop_`/`uws_loop`/contexts.
@@ -1246,7 +1232,6 @@ mod _event_loop_draft {
 
     pub(super) fn on_start(opts: InitOpts) {
         Output::Source::configure_named_thread(bun_core::zstr!("HTTP Client"));
-        // PERF(port): was MimallocArena bulk-free for bun.http.default_allocator.
 
         // uSockets' long-timeout counter is `% 240` minutes (see
         // `us_socket_long_timeout` in packages/bun-usockets/src/socket.c), so
@@ -1270,8 +1255,7 @@ mod _event_loop_draft {
             core::sync::atomic::Ordering::Relaxed,
         );
 
-        // Zig: `const loop = bun.jsc.MiniEventLoop.initGlobal(null, null)`
-        // (HTTPThread.zig:228). Critical side effect: `init_global` calls
+        // Critical side effect: `init_global` calls
         // `internal_loop_data.set_parent_raw(2 /* mini */, mini_ptr)` on this
         // thread's uSockets loop. Without it, the macOS DNS cache-miss path
         // (`dns::getaddrinfo` → `(*loop).internal_loop_data.get_parent()`)
@@ -1292,8 +1276,7 @@ mod _event_loop_draft {
             // `GetEnvironmentVariableW`, which expects a NUL-terminated LPCWSTR.
             // `bun_core::w!` does NOT append a sentinel on its own (see
             // src/sys/windows/mod.rs WATCHER_CHILD_ENV_Z note), so embed `\0`
-            // in the literal — Zig's `bun.strings.w("SystemRoot")` returns
-            // `[:0]const u16`, this matches that spec (HTTPThread.zig:231).
+            // in the literal.
             if bun_sys::windows::getenv_w(bun_core::w!("SystemRoot\0")).is_none() {
                 Output::err_generic(
                     "The %SystemRoot% environment variable is not set. Bun needs this set in order for network requests to work.",
@@ -1476,5 +1459,3 @@ pub fn shutdown_for_exit() {
 pub fn init(opts: &InitOpts) {
     _event_loop_draft::init(opts)
 }
-
-// ported from: src/http/HTTPThread.zig
diff --git a/src/http/HeaderBuilder.rs b/src/http/HeaderBuilder.rs
index 125e34e5c3c..77e12449528 100644
--- a/src/http/HeaderBuilder.rs
+++ b/src/http/HeaderBuilder.rs
@@ -19,7 +19,6 @@ impl HeaderBuilder {
 
     pub fn allocate(&mut self) -> Result<(), AllocError> {
         self.content.allocate()?;
-        // TODO(port): narrow error set
         self.entries
             .ensure_total_capacity(self.header_count as usize)?;
         Ok(())
@@ -40,7 +39,6 @@ impl HeaderBuilder {
             length: value.len() as u32,
         };
         let _ = self.content.append(value);
-        // PERF(port): was assume_capacity
         self.entries.append_assume_capacity(Entry {
             name: name_ptr,
             value: value_ptr,
@@ -81,7 +79,7 @@ impl HeaderBuilder {
 
         let _ = self.content.append(name);
 
-        // PORT NOTE: reshaped for borrowck — `fmt` returns a borrow into the
+        // Note: reshaped for borrowck — `fmt` returns a borrow into the
         // builder buffer; capture its length, then re-read `content.len`.
         let value_len = self.content.fmt(args).len();
 
@@ -90,7 +88,6 @@ impl HeaderBuilder {
             length: value_len as u32,
         };
 
-        // PERF(port): was assume_capacity
         self.entries.append_assume_capacity(Entry {
             name: name_ptr,
             value: value_ptr,
@@ -99,9 +96,9 @@ impl HeaderBuilder {
 
     pub fn apply(&mut self, client: &mut crate::HTTPClient) {
         client.header_entries = core::mem::take(&mut self.entries);
-        // TODO(port): lifetime — header_buf borrows from self.content's allocation; in Zig this
-        // is a non-owning slice into the StringBuilder's buffer. Decide whether
-        // HttpClient should take ownership of the buffer or borrow it.
+        // header_buf is a non-owning slice into self.content's
+        // allocation; the builder's owner must
+        // keep `self.content` alive for as long as the client uses the slice.
         // SAFETY: content.ptr was set by allocate() and exactly content.len bytes have been written.
         // Cannot use `written_slice()` here — the borrow must outlive `&self` (`HTTPClient<'a>`
         // holds it past this call); the lifetime is intentionally unbound.
@@ -109,5 +106,3 @@ impl HeaderBuilder {
             unsafe { bun_core::ffi::slice(self.content.ptr.unwrap().as_ptr(), self.content.len) };
     }
 }
-
-// ported from: src/http/HeaderBuilder.zig
diff --git a/src/http/HeaderValueIterator.rs b/src/http/HeaderValueIterator.rs
index f25ef090a0f..cbdc3becfee 100644
--- a/src/http/HeaderValueIterator.rs
+++ b/src/http/HeaderValueIterator.rs
@@ -1,9 +1,8 @@
 use bun_core::strings;
 
-// PORT NOTE: Zig stored a `std.mem.TokenIterator(u8, .scalar)` field. The Rust
-// equivalent (`slice::Split<'_, u8, _>` + `.filter(..)`) has an unnameable
-// closure type, so we store the remaining input slice and inline the
-// tokenize-by-',' logic in `next()`. Behavior is identical.
+// Stores the remaining input slice and inlines the tokenize-by-',' logic in
+// `next()` — the std iterator equivalent (`slice::Split` + `.filter(..)`) has
+// an unnameable closure type that can't be stored as a field.
 pub struct HeaderValueIterator<'a> {
     remaining: &'a [u8],
 }
@@ -11,7 +10,6 @@ pub struct HeaderValueIterator<'a> {
 impl<'a> HeaderValueIterator<'a> {
     pub fn init(input: &'a [u8]) -> HeaderValueIterator<'a> {
         HeaderValueIterator {
-            // std.mem.tokenizeScalar(u8, std.mem.trim(u8, input, " \t"), ',')
             remaining: strings::trim(input, b" \t"),
         }
     }
@@ -40,5 +38,3 @@ impl<'a> HeaderValueIterator<'a> {
         Some(slice)
     }
 }
-
-// ported from: src/http/HeaderValueIterator.zig
diff --git a/src/http/Headers.rs b/src/http/Headers.rs
index 7c15779cc64..fac9f12bd1d 100644
--- a/src/http/Headers.rs
+++ b/src/http/Headers.rs
@@ -23,8 +23,7 @@ pub use bun_http_types::Method::HeaderName;
 // `bun_jsc::FetchHeaders`).
 pub use bun_http_types::ETag::{HeaderEntry as Entry, HeaderEntryList as EntryList, Headers};
 
-// PORT NOTE: `pub const toFetchHeaders = @import("../http_jsc/headers_jsc.zig").toFetchHeaders;`
-// deleted — to_fetch_headers lives as an extension-trait method in bun_http_jsc.
+// to_fetch_headers lives as an extension-trait method in bun_http_jsc.
 
 /// Extension constructors for `Headers` that depend on T5 crates
 /// (`bun_picohttp`). Kept as a trait so callers can keep writing
@@ -34,7 +33,6 @@ pub trait HeadersExt {
 }
 
 impl HeadersExt for Headers {
-    // PORT NOTE: was `!Headers`; all fallible calls were bun.handleOom-wrapped allocations.
     fn from_pico_http_headers(headers: &[picohttp::Header]) -> Headers {
         let header_count = headers.len();
         let mut result = Headers {
@@ -49,21 +47,19 @@ impl HeadersExt for Headers {
         result
             .entries
             .ensure_total_capacity(header_count)
-            .expect("OOM"); // Zig: bun.handleOom
+            .expect("OOM");
         result.buf.reserve_exact(buf_len);
         for header in headers {
             let name = header.name();
             let value = header.value();
-            // PORT NOTE: Zig used `@truncate` for offsets/lengths; mirror with `as u32`
+            // Note: `as u32` truncates offsets/lengths
             // (silent wrap on >4GiB aggregate headers) rather than `try_from().unwrap()`.
             let name_offset = result.buf.len() as u32;
             result.buf.extend_from_slice(name);
             let value_offset = result.buf.len() as u32;
             result.buf.extend_from_slice(value);
 
-            // PORT NOTE: Zig pre-set `entries.len = headers.len` then `set(i, ..)`.
-            // Rust `MultiArrayList` lacks `set_len`; capacity was reserved above
-            // so use `append_assume_capacity` which is equivalent.
+            // Capacity was reserved above so `append_assume_capacity` is safe.
             result.entries.append_assume_capacity(Entry {
                 name: api::StringPointer {
                     offset: name_offset,
@@ -79,14 +75,12 @@ impl HeadersExt for Headers {
     }
 }
 
-// PORT NOTE: `pub fn deinit` only freed `entries` and `buf`; both are Drop types now — no explicit Drop impl needed.
+// `entries` and `buf` are both Drop types — no explicit Drop impl needed.
 
 /// Compute the ETag for `bytes` (xxhash64, hex-lowered, quoted) and append it as
 /// an `etag` header. Re-exported from `bun_http_types` now that `Headers` is
 /// the same type in both crates.
 #[inline]
 pub fn append_etag(bytes: &[u8], headers: &mut Headers) {
-    let _ = bun_http_types::ETag::append_to_headers(bytes, headers);
+    bun_http_types::ETag::append_to_headers(bytes, headers);
 }
-
-// ported from: src/http/Headers.zig
diff --git a/src/http/InitError.rs b/src/http/InitError.rs
index d64d2759f63..831691b8d31 100644
--- a/src/http/InitError.rs
+++ b/src/http/InitError.rs
@@ -11,5 +11,3 @@ pub enum InitError {
 }
 
 bun_core::named_error_set!(InitError);
-
-// ported from: src/http/InitError.zig
diff --git a/src/http/InternalState.rs b/src/http/InternalState.rs
index 07d404b059f..4daf7442d72 100644
--- a/src/http/InternalState.rs
+++ b/src/http/InternalState.rs
@@ -3,10 +3,7 @@ use core::ptr::NonNull;
 use bun_core::MutableString;
 use bun_core::{Error, Output};
 
-use crate::{
-    CertificateInfo, Decompressor, EXTREMELY_VERBOSE, Encoding, HTTPRequestBody,
-    HTTPResponseMetadata,
-};
+use crate::{CertificateInfo, Decompressor, Encoding, HTTPRequestBody, HTTPResponseMetadata};
 
 bun_core::define_scoped_log!(log, HTTPInternalState, hidden);
 
@@ -33,8 +30,8 @@ pub struct InternalState<'a> {
     pub chunked_decoder: bun_picohttp::phr_chunked_decoder,
     pub decompressor: Decompressor,
     pub stage: Stage,
-    /// This is owned by the user and should not be freed here
-    // TODO(port): lifetime — user-owned back-reference; no LIFETIMES.tsv row, kept as raw NonNull
+    /// This is owned by the user and should not be freed here.
+    /// Non-owning back-reference, kept as a raw `NonNull` (BACKREF per PORTING.md).
     pub body_out_str: Option<NonNull<MutableString>>,
     pub compressed_body: MutableString,
     pub content_length: Option<usize>,
@@ -51,9 +48,9 @@ pub struct InternalState<'a> {
     pub certificate_info: Option<CertificateInfo>,
 }
 
-// PORT NOTE: was a `packed struct(u8)` in Zig. Kept as a struct-of-bools so the
+// Struct-of-bools so the
 // HTTPClient state machine in lib.rs can use field syntax (`flags.allow_keepalive
-// = true`) directly; restore packing if size ever matters.
+// = true`) directly; pack into a bitfield if size ever matters.
 #[derive(Clone, Copy)]
 pub struct InternalStateFlags {
     pub allow_keepalive: bool,
@@ -80,7 +77,7 @@ pub struct InternalStateFlags {
 }
 
 impl InternalStateFlags {
-    /// Zig's field defaults: `allow_keepalive = true`, rest false.
+    /// Field defaults: `allow_keepalive = true`, rest false.
     pub(crate) const fn new() -> Self {
         Self {
             allow_keepalive: true,
@@ -96,7 +93,7 @@ impl InternalStateFlags {
 }
 
 impl Default for InternalStateFlags {
-    /// Matches Zig `InternalStateFlags{}` (allow_keepalive defaults to true).
+    /// `allow_keepalive` defaults to true.
     fn default() -> Self {
         Self::new()
     }
@@ -150,7 +147,7 @@ impl<'a> InternalState<'a> {
     }
 
     pub fn reset(&mut self) {
-        // PORT NOTE: allocator param dropped (global mimalloc).
+        // allocator param dropped (global mimalloc).
         self.compressed_body = MutableString::init_empty();
         self.response_message_buffer = MutableString::init_empty();
 
@@ -158,9 +155,9 @@ impl<'a> InternalState<'a> {
         if let Some(body) = body_msg {
             crate::body_out::as_mut(body).reset();
         }
-        // PORT NOTE: Zig calls `this.decompressor.deinit()` here. The boxed
+        // The boxed
         // Zlib/Brotli/Zstd readers all impl Drop calling end()/destroy_instance
-        // (see Decompressor.rs PORT NOTE), so the `*self = ...` assignment below
+        // (see the note in Decompressor.rs), so the `*self = ...` assignment below
         // frees the FFI handle via drop glue — no explicit reset needed.
 
         // just in case we check and free to avoid leaks
@@ -236,7 +233,6 @@ impl<'a> InternalState<'a> {
         self.flags.received_last_chunk
     }
 
-    // TODO(port): narrow error set
     pub fn decompress_bytes(
         &mut self,
         buffer: &[u8],
@@ -252,15 +248,9 @@ impl<'a> InternalState<'a> {
             return Ok(());
         }
 
-        // PORT NOTE: Zig `defer this.compressed_body.reset()` runs on every exit. scopeguard would
+        // `self.compressed_body.reset()` must run on every exit. scopeguard would
         // hold &mut self.compressed_body across the body and conflict with &mut self.decompressor,
-        // so each early-return below calls `self.compressed_body.reset()` explicitly.
-        let mut gzip_timer: Option<std::time::Instant> = None;
-
-        if EXTREMELY_VERBOSE {
-            gzip_timer = Some(std::time::Instant::now());
-        }
-
+        // so each early-return below calls it explicitly.
         let mut still_needs_to_decompress = true;
 
         if bun_core::feature_flags::is_libdeflate_enabled() {
@@ -329,7 +319,6 @@ impl<'a> InternalState<'a> {
                     body_out_str
                         .list
                         .reserve_exact(result.written.saturating_sub(body_out_str.list.len()));
-                    // PERF(port): was appendSliceAssumeCapacity
                     body_out_str
                         .list
                         .extend_from_slice(&deflater.shared_buffer[0..result.written]);
@@ -380,31 +369,20 @@ impl<'a> InternalState<'a> {
             }
         }
 
-        if EXTREMELY_VERBOSE {
-            // TODO(port): `gzip_elapsed` is not a field on InternalState in the Zig source either —
-            // this looks like dead code referencing a removed field. Preserved as a no-op read.
-            let _ = gzip_timer.map(|t| t.elapsed());
-        }
-
         self.compressed_body.reset();
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn decompress(
         &mut self,
         buffer: &MutableString,
         body_out_str: &mut MutableString,
         is_final_chunk: bool,
     ) -> Result<(), Error> {
-        // PORT NOTE: reshaped for borrowck — Zig passed MutableString by value; we borrow the inner slice.
         self.decompress_bytes(buffer.list.as_slice(), body_out_str, is_final_chunk)
     }
 
-    // TODO(port): narrow error set
-    // PORT NOTE: Zig takes `buffer: MutableString` BY VALUE (a shallow struct copy whose
-    // `.list.items` aliases the same allocation). Every caller passes `getBodyBuffer().*`,
-    // so `buffer` is always the current body buffer's bytes. To avoid aliased &mut/& under
+    // `buffer` is always the current body buffer's bytes. To avoid aliased &mut/& under
     // Stacked Borrows (decompress_bytes mutates `self.compressed_body`; the uncompressed
     // path materialises `&mut *body_out_str`), callers `mem::take` the body buffer's `list`
     // and pass it here as an owned Vec — no `&` into `self` survives across `&mut self`.
@@ -415,12 +393,12 @@ impl<'a> InternalState<'a> {
     ) -> Result<bool, Error> {
         if self.flags.is_redirect_pending {
             // Caller moved the bytes out of the body buffer; put them back so the
-            // take is a no-op (Zig's by-value copy left the original untouched).
+            // take is a no-op.
             self.get_body_buffer().list = buffer;
             return Ok(false);
         }
 
-        // PORT NOTE: not `self.body_out_mut()` — `decompress_bytes` below takes
+        // not `self.body_out_mut()` — `decompress_bytes` below takes
         // `&mut self` alongside `body_out_str`; the accessor would tie the
         // borrow to `self`. The free `body_out::as_mut` yields an unbounded
         // `&mut` to the disjoint caller-owned allocation.
@@ -429,15 +407,14 @@ impl<'a> InternalState<'a> {
         match self.encoding {
             Encoding::Brotli | Encoding::Gzip | Encoding::Deflate | Encoding::Zstd => {
                 self.decompress_bytes(&buffer, body_out_str, is_final_chunk)?;
-                // Zig's `defer compressed_body.reset()` retained capacity; mirror that by
+                // Retain capacity by
                 // returning the (cleared) allocation to compressed_body instead of dropping it.
                 buffer.clear();
                 self.compressed_body.list = buffer;
             }
             _ => {
                 // Uncompressed: caller took `buffer` from `body_out_str.list`, leaving it
-                // empty — move the bytes back (Zig's `owns()` check skipped the append
-                // because the by-value copy aliased body_out_str). If body_out_str is
+                // empty — move the bytes back. If body_out_str is
                 // somehow non-empty, fall back to append.
                 if body_out_str.list.is_empty() {
                     body_out_str.list = buffer;
@@ -485,9 +462,7 @@ pub enum Stage {
     Fail,
 }
 
-// Aliases used by the HTTPClient state machine: the Zig side has separate
-// `request_stage` / `response_stage` fields but they share one HTTPStage enum.
+// Aliases used by the HTTPClient state machine: `request_stage` /
+// `response_stage` are separate fields but share one HTTPStage enum.
 pub(crate) type RequestStage = HTTPStage;
 pub(crate) type ResponseStage = HTTPStage;
-
-// ported from: src/http/InternalState.zig
diff --git a/src/http/ProxyTunnel.rs b/src/http/ProxyTunnel.rs
index 4c4cc9c997c..5f8a09fc415 100644
--- a/src/http/ProxyTunnel.rs
+++ b/src/http/ProxyTunnel.rs
@@ -38,10 +38,8 @@ pub(crate) fn raw_as_mut<'a>(ptr: *mut ProxyTunnel) -> &'a mut ProxyTunnel {
 type ProxyTunnelWrapper = SSLWrapper<*mut HTTPClient<'static>>;
 
 /// active socket is the socket that is currently being used
-// PORT NOTE: Zig used `NewHTTPContext(B).HTTPSocket`; inherent associated types
-// are unstable in Rust, so the free `HTTPSocket<SSL>` alias from http_context
-// is used instead. `HTTPSocket<B>` = `uws::SocketHandler<B>` = `NewSocketHandler<B>`,
-// so the canonical 3-arm enum lives in `bun_uws` next to its payload type.
+// `HTTPSocket<B>` = `uws::SocketHandler<B>` = `NewSocketHandler<B>`, so the
+// canonical 3-arm enum lives in `bun_uws` next to its payload type.
 pub use bun_uws::MaybeAnySocket as Socket;
 
 #[derive(bun_ptr::CellRefCounted)]
@@ -83,8 +81,8 @@ impl Default for ProxyTunnel {
 
 impl Drop for ProxyTunnel {
     fn drop(&mut self) {
-        // Zig: ProxyTunnel.deinit — wrapper.deinit() / write_buffer.deinit()
-        // are handled by their own Drop impls; just clear the socket tag.
+        // `wrapper` / `write_buffer` are handled by their own Drop impls;
+        // just clear the socket tag.
         self.socket = Socket::None;
     }
 }
@@ -150,8 +148,6 @@ impl ProxyTunnel {
     /// without one. This is the same shared-read-of-a-Copy-field-while-a-
     /// `&mut SSLWrapper`-is-live pattern the pre-refactor inline call sites
     /// used: read-only, single-threaded, never retained past this expression.
-    /// The Zig original (`proxy.wrapper.?.ssl`) has no exclusive-alias rule so
-    /// this was never modelled there.
     #[inline]
     fn wrapper_ssl(this: NonNull<Self>) -> Option<NonNull<bun_boringssl_sys::SSL>> {
         // SAFETY: `this` is live; transient shared read of a Copy field. See
@@ -224,8 +220,7 @@ fn client_from_ctx<'a, 'c>(ctx: *mut HTTPClient<'c>) -> &'a mut HTTPClient<'c> {
 // memory that overlaps the caller's `&mut SSLWrapper` — UB under Stacked
 // Borrows. Callbacks therefore never materialise `&mut ProxyTunnel`; they
 // access individual fields through raw `addr_of!`/`addr_of_mut!` projections so
-// each borrow covers only memory disjoint from `wrapper`. The Zig original
-// (ProxyTunnel.zig) has no exclusive-alias rule so this was never modelled.
+// each borrow covers only memory disjoint from `wrapper`.
 
 fn on_open(ctx: *mut HTTPClient) {
     // HTTPClient owns ProxyTunnel only by `NonNull` pointer, so the borrow
@@ -244,8 +239,6 @@ fn on_open(ctx: *mut HTTPClient) {
     if let Some(ssl_ptr) = ProxyTunnel::wrapper_ssl(proxy_nn) {
         let _hostname = this.hostname.unwrap_or(this.url.hostname);
 
-        // PORT NOTE: Zig `configureHTTPClient` is `configureHTTPClientWithALPN(ssl, host, .h1)`;
-        // the Rust port already exposes the ALPN form in `crate::configure_http_client_with_alpn`.
         // SAFETY: `ssl_ptr` is the live SSL handle from the tunnel's SSLWrapper.
         let ssl = unsafe { &mut *ssl_ptr.as_ptr() };
         if bun_core::is_ip_address(_hostname) {
@@ -400,9 +393,7 @@ fn on_handshake(
             }
 
             // if checkServerIdentity returns false, we dont call open this means that the connection was rejected
-            // Zig: `const ssl_ptr = proxy.wrapper.?.ssl orelse return;` —
-            // `.?` asserts wrapper-is-Some; `orelse return` silently bails if
-            // ssl is None. Mirror that split: assert the wrapper, then return
+            // Assert the wrapper is Some, then silently return
             // (no debug_assert) on the ssl-None sub-case.
             // SAFETY: `proxy_nn` is live (ref-guarded above). Transient shared
             // read of the `wrapper` discriminant only — same caveat as
@@ -537,7 +528,7 @@ fn on_close(ctx: *mut HTTPClient) {
     let proxy_ptr = proxy_nn.as_ptr();
     // close_raw still holds `&mut SSLWrapper` on `(*proxy_ptr).wrapper`, so
     // bump refcount via the disjoint Cell projection.
-    // PORT NOTE: not a ScopedRef — the matching deref is deferred via
+    // Not a ScopedRef — the matching deref is deferred via
     // `schedule_proxy_deref` to avoid freeing within the callback.
     {
         let rc = ProxyTunnel::ref_count_of(proxy_nn);
@@ -650,8 +641,7 @@ impl ProxyTunnel {
             }
         }
         // Move the sole strong ref (refcount == 1 from `ProxyTunnel::default`)
-        // into the client field; no bump (matches the bare `this.proxy_tunnel =
-        // tunnel` in http.zig — Zig's `RefPtr.create` returns the owned ref).
+        // into the client field; no bump.
         // SAFETY: `proxy_nn` is the fresh `heap::into_raw` allocation above with
         // `ref_count == 1`; `adopt_ref` takes ownership of that sole +1.
         this.proxy_tunnel = Some(unsafe { RefPtr::adopt_ref(proxy_nn.as_ptr()) });
@@ -720,9 +710,9 @@ impl ProxyTunnel {
         let self_nn = NonNull::from(&mut *self);
         let self_ptr = self_nn.as_ptr();
         let _guard = Self::ref_scope(self_nn);
-        // PORT NOTE: Zig `defer wrapper.flush()` runs AFTER the body but BEFORE
-        // `defer deref()` (LIFO). We mirror that order explicitly at the single
-        // exit. flush() → handle_traffic → write_encrypted reenters and touches
+        // flush() must run AFTER the body but BEFORE the guard's deref; that
+        // order is written out explicitly at the single exit below.
+        // flush() → handle_traffic → write_encrypted reenters and touches
         // `write_buffer`/`socket` via raw projection; we must not hold a
         // `&mut ProxyTunnel` (or any borrow overlapping those fields) across it.
         {
@@ -745,7 +735,7 @@ impl ProxyTunnel {
             // Cycle to through the SSL state machine
             let _ = wrapper.flush();
         }
-        // _guard derefs here (Zig LIFO `defer deref()`).
+        // _guard derefs here.
     }
 
     pub fn receive(&mut self, buf: &[u8]) {
@@ -760,7 +750,7 @@ impl ProxyTunnel {
         if let Some(wrapper) = ProxyTunnel::wrapper_mut(self_nn.as_ptr()) {
             wrapper.receive_data(buf);
         }
-        // _guard derefs here (Zig LIFO `defer deref()`); `self_ptr` provenance
+        // _guard derefs here; `self_ptr` provenance
         // intact because `self` was never reborrowed after capture.
     }
 
@@ -781,7 +771,7 @@ impl ProxyTunnel {
     }
 
     pub fn detach_and_deref(&mut self) {
-        // Zig: detachSocket() BEFORE deref() — if refcount > 1 the tunnel
+        // detach_socket() BEFORE deref() — if refcount > 1 the tunnel
         // outlives this call and must not retain a dangling socket handle.
         self.detach_socket();
         // SAFETY: `&mut self` was derived (transitively) from the `heap::alloc`
@@ -835,8 +825,8 @@ impl ProxyTunnel {
         self.socket = Socket::from_generic::<IS_SSL>(socket);
         // SAFETY: `self` was created by `start` (heap::alloc) and is live; we
         // transfer the pool's strong ref to the client WITHOUT bumping it
-        // (`from_raw` == `take_ref`), matching `existingSocket` in
-        // HTTPContext.zig which moves the parked ref into the new client.
+        // (`from_raw` == `take_ref`) — the parked ref moves into the new
+        // client.
         client.proxy_tunnel = Some(unsafe { RefPtr::from_raw(core::ptr::from_mut(&mut *self)) });
         client.flags.proxy_tunneling = false;
         // Restore the cert-error flag captured in detachOwner() — no handshake
@@ -848,5 +838,3 @@ impl ProxyTunnel {
         client.state.request_sent_len = 0;
     }
 }
-
-// ported from: src/http/ProxyTunnel.zig
diff --git a/src/http/SendFile.rs b/src/http/SendFile.rs
index 983d5a848a1..81df95dbed8 100644
--- a/src/http/SendFile.rs
+++ b/src/http/SendFile.rs
@@ -22,21 +22,18 @@ impl SendFile {
         url.is_http() && url.href.len() > 0
     }
 
-    // PORT NOTE: reshaped — Zig took `NewHTTPContext(false).HTTPSocket` and only ever
-    // called `socket.fd()` on it. `NewHTTPContext` is part of the still-gated
-    // mutually-recursive cluster, so accept the resolved fd directly. Callers pass
+    // Takes the resolved fd directly rather than the socket; callers pass
     // `socket.fd()`.
     pub fn write(&mut self, socket_fd: Fd) -> Status {
-        // Zig u63 max == i64::MAX. Clamp `remain` so the signed sendfile count cannot overflow.
+        // Clamp `remain` so the signed sendfile count cannot overflow.
         let adjusted_count_temporary: u64 = (self.remain as u64).min(i64::MAX as u64);
-        // TODO we should not need this int cast; improve the return type of `@min`
-        let adjusted_count: u64 = adjusted_count_temporary; // was @intCast to u63
+        let adjusted_count: u64 = adjusted_count_temporary;
 
         // Android: same kernel `sendfile(2)` ABI, dispatched via `bun_sys::linux`'s
         // raw-syscall thunk (no libc difference matters here).
         #[cfg(any(target_os = "linux", target_os = "android"))]
         {
-            let _ = adjusted_count; // unused on Linux path (matches Zig)
+            let _ = adjusted_count; // unused on Linux path
             let mut signed_offset: i64 = i64::try_from(self.offset).expect("int cast");
             let begin = self.offset;
             // this does the syscall directly, without libc
@@ -69,8 +66,8 @@ impl SendFile {
 
         #[cfg(target_os = "freebsd")]
         {
-            let mut sbytes: i64 = 0; // std.posix.off_t
-            // Same-width signedness flip (Zig `@bitCast`); `as` is a bit-reinterpret here.
+            let mut sbytes: i64 = 0; // C off_t
+            // Same-width signedness flip; `as` is a bit-reinterpret here.
             let signed_offset: i64 = self.offset as u64 as i64;
             // FreeBSD: sendfile(fd, s, offset, nbytes, hdtr, *sbytes, flags)
             // SAFETY: fds valid; sbytes is a live stack local; hdtr is null (no headers).
@@ -102,8 +99,8 @@ impl SendFile {
             not(target_os = "freebsd")
         ))]
         {
-            let mut sbytes: i64 = i64::try_from(adjusted_count).expect("int cast"); // std.posix.off_t
-            // Zig: `@as(i64, @bitCast(self.offset))` — same-width `as` is the bitcast.
+            let mut sbytes: i64 = i64::try_from(adjusted_count).expect("int cast"); // C off_t
+            // Same-width signedness flip; `as` is a bit-reinterpret here.
             let signed_offset: i64 = self.offset as u64 as i64;
             // SAFETY: fds valid; sbytes is a live stack local; hdtr is null (no headers).
             let errcode = bun_sys::get_errno(unsafe {
@@ -142,5 +139,3 @@ pub enum Status {
     Err(bun_core::Error),
     Again,
 }
-
-// ported from: src/http/SendFile.zig
diff --git a/src/http/Signals.rs b/src/http/Signals.rs
index 80ad7ea740f..7ab91b78927 100644
--- a/src/http/Signals.rs
+++ b/src/http/Signals.rs
@@ -3,8 +3,8 @@ use core::sync::atomic::{AtomicBool, Ordering};
 
 #[derive(Default, Clone, Copy)]
 pub struct Signals {
-    // TODO(port): lifetime — these are non-owning pointers into a `Store` held by the caller.
-    // LIFETIMES.tsv had no entry; classified as BACKREF (raw) per PORTING.md.
+    // Non-owning pointers into a `Store` held by the caller (BACKREF per
+    // PORTING.md); the `Store` outlives every `Signals` derived from it.
     pub header_progress: Option<NonNull<AtomicBool>>,
     pub response_body_streaming: Option<NonNull<AtomicBool>>,
     pub aborted: Option<NonNull<AtomicBool>>,
@@ -45,15 +45,12 @@ impl Signals {
         Some(bun_ptr::BackRef::from(ptr))
     }
 
-    // PERF(port): was `comptime field: std.meta.FieldEnum(Signals)` + `@field` reflection —
-    // demoted to a runtime match; profile if it shows up on a hot path.
     pub fn get(self, field: Field) -> bool {
-        // Zig .monotonic == LLVM monotonic == Rust Relaxed
         self.slot(field).is_some_and(|a| a.load(Ordering::Relaxed))
     }
 
     /// Store `value` into the named signal slot if present. No-op when the
-    /// slot is `None` (matches Zig `if (this.signals.<field>) |p| p.store(..)`).
+    /// slot is `None`.
     pub fn store(self, field: Field, value: bool, ordering: Ordering) {
         if let Some(a) = self.slot(field) {
             a.store(value, ordering);
@@ -93,7 +90,7 @@ impl Store {
     }
 }
 
-/// Mirrors `std.meta.FieldEnum(Signals)`.
+/// Selects one of the atomic flag fields of `Signals`.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Field {
     HeaderProgress,
@@ -102,5 +99,3 @@ pub enum Field {
     CertErrors,
     Upgraded,
 }
-
-// ported from: src/http/Signals.zig
diff --git a/src/http/ThreadSafeStreamBuffer.rs b/src/http/ThreadSafeStreamBuffer.rs
index dd24f413fd4..53124fa1cbc 100644
--- a/src/http/ThreadSafeStreamBuffer.rs
+++ b/src/http/ThreadSafeStreamBuffer.rs
@@ -22,9 +22,9 @@ pub struct Callback {
 impl Callback {
     pub fn init<T>(callback: fn(*mut T), context: *mut T) -> Self {
         Self {
-            // SAFETY: fn(*mut T) and fn(*mut c_void) have identical ABI; the
-            // Zig side uses @ptrCast on a comptime fn param. `context` is only
-            // ever passed back to this callback, which knows its real type.
+            // SAFETY: fn(*mut T) and fn(*mut c_void) have identical ABI;
+            // `context` is only ever passed back to this callback, which
+            // knows its real type.
             callback: unsafe { bun_ptr::cast_fn_ptr::<fn(*mut T), fn(*mut c_void)>(callback) },
             context: context.cast::<c_void>(),
         }
@@ -82,10 +82,9 @@ impl ThreadSafeStreamBuffer {
 
     pub fn acquire(&mut self) -> &mut StreamBuffer {
         self.mutex.lock();
-        // PORT NOTE: reshaped for borrowck — Zig returns &this.buffer while the
-        // mutex stays locked until `release()`. Prefer `lock()` (RAII guard) for
-        // simple critical sections; this split form remains for callers that
-        // interleave release with disjoint `self` access.
+        // The mutex stays locked until `release()`. Prefer `lock()` (RAII
+        // guard) for simple critical sections; this split form remains for
+        // callers that interleave release with disjoint `self` access.
         &mut self.buffer
     }
 
@@ -124,8 +123,7 @@ impl ThreadSafeStreamBuffer {
 }
 
 /// RAII guard returned by [`ThreadSafeStreamBuffer::lock`]. Derefs to the
-/// protected `StreamBuffer` and releases the mutex on `Drop` (Zig:
-/// `const buf = sb.acquire(); defer sb.release();`).
+/// protected `StreamBuffer` and releases the mutex on `Drop`.
 pub struct StreamBufferGuard<'a>(&'a mut ThreadSafeStreamBuffer);
 
 impl core::ops::Deref for StreamBufferGuard<'_> {
@@ -149,5 +147,3 @@ impl Drop for StreamBufferGuard<'_> {
         self.0.mutex.unlock();
     }
 }
-
-// ported from: src/http/ThreadSafeStreamBuffer.zig
diff --git a/src/http/h2_client/ClientSession.rs b/src/http/h2_client/ClientSession.rs
index bfaf125bf68..d798f4276a6 100644
--- a/src/http/h2_client/ClientSession.rs
+++ b/src/http/h2_client/ClientSession.rs
@@ -1,6 +1,5 @@
 //! One TCP+TLS connection running the HTTP/2 protocol for `fetch()`. Owns the
 //! socket, the connection-scoped HPACK tables, and a map of active `Stream`s.
-//! See `src/http/H2Client.zig` for the module-level overview.
 
 use core::cell::Cell;
 use core::ptr::NonNull;
@@ -26,7 +25,7 @@ pub type Socket = HTTPSocket<true>;
 
 const LOCAL_INITIAL_WINDOW_SIZE: u32 = super::LOCAL_INITIAL_WINDOW_SIZE;
 
-// PORT NOTE: Zig `u31`/`u24` widened to u32; range asserts at use sites.
+// 31-/24-bit wire fields stored as u32; range asserts at use sites.
 #[allow(non_camel_case_types)]
 type u31 = u32;
 #[allow(non_camel_case_types)]
@@ -189,7 +188,7 @@ fn drop_stream(stream: *mut Stream) {
 impl ClientSession {
     /// Bump the refcount and return a guard that releases it on Drop, so
     /// reentrant callbacks (delivering bodies, failing clients) cannot free
-    /// `*self` mid-call. Zig: `this.ref(); defer this.deref();`.
+    /// `*self` mid-call.
     ///
     /// Captures a raw pointer (not a borrow) so the guard does not borrow the
     /// session — the guarded scope may freely take fresh `&mut self`, and the
@@ -553,7 +552,8 @@ impl ClientSession {
     /// end-of-body) are available in the ThreadSafeStreamBuffer.
     pub fn stream_body_by_http_id(&mut self, async_http_id: u32, ended: bool) {
         let _guard = self.ref_scope();
-        // PORT NOTE: reshaped for borrowck — collect target stream ptr before mutating self.
+        // Collect the target stream ptr first so no borrow of `self.streams`
+        // is held while mutating `self` below.
         let mut target: Option<*mut Stream> = None;
         for &stream in self.streams.values() {
             let Some(client) = stream_mut(stream).client_mut() else {
@@ -599,7 +599,7 @@ impl ClientSession {
             self.write_window_update(0, self.conn_unacked_bytes);
             self.conn_unacked_bytes = 0;
         }
-        // PORT NOTE: reshaped for borrowck — collect (id, unacked) pairs before mutating self.
+        // Collect (id, unacked) pairs before mutating self.
         let mut updates: Vec<(u32, u32)> = Vec::new();
         for &s in self.streams.values() {
             let s = stream_mut(s);
@@ -611,14 +611,14 @@ impl ClientSession {
         for (id, unacked) in updates {
             self.write_window_update(id, unacked);
         }
-        // PERF(port): Zig iterated and wrote in one pass; profile if extra Vec matters.
+        // PERF: could iterate and write in one pass; profile if extra Vec matters.
     }
 
     pub fn flush(&mut self) -> Result<bool, Error> {
-        // PORT NOTE: reshaped for borrowck — capture as `bun_ptr::RawSlice`
-        // (encapsulated outlives-holder invariant) so the loop can borrow
-        // `self.socket` while still subslicing `write_buffer`. The buffer is
-        // not reallocated until `wrote()` after the loop.
+        // Captured as `bun_ptr::RawSlice` (encapsulated outlives-holder
+        // invariant) so the loop can borrow `self.socket` while still
+        // subslicing `write_buffer`. The buffer is not reallocated until
+        // `wrote()` after the loop.
         let pending = bun_ptr::RawSlice::new(self.write_buffer.slice());
         if pending.is_empty() {
             return Ok(false);
@@ -658,11 +658,10 @@ impl ClientSession {
             }
         } else {
             self.read_buffer.extend_from_slice(incoming);
-            // PORT NOTE: reshaped for borrowck — `parse_frames` takes
-            // `&mut self` plus a view into `self.read_buffer`. Capture as
-            // `bun_ptr::RawSlice`: read_buffer is not reallocated during
-            // parse_frames (only consumed), so the outlives-holder invariant
-            // holds for the call.
+            // `parse_frames` takes `&mut self` plus a view into
+            // `self.read_buffer`, so capture the view as `bun_ptr::RawSlice`:
+            // read_buffer is not reallocated during parse_frames (only
+            // consumed), so the outlives-holder invariant holds for the call.
             let buf = bun_ptr::RawSlice::new(self.read_buffer.as_slice());
             let consumed = dispatch::parse_frames(self, buf.slice());
             self.read_buffer.drain_front(consumed);
@@ -821,9 +820,9 @@ impl ClientSession {
     /// Called from the HTTP thread's shutdown queue when a fetch on this
     /// session is aborted. RST_STREAMs that one request; siblings continue.
     pub fn abort_by_http_id(&mut self, async_http_id: u32) {
-        // PORT NOTE: reshaped for borrowck — find index via raw-ptr field read
-        // first, then swap_remove, so no `&mut HTTPClient` is held across the
-        // Vec mutation and no `&mut` is materialised during iteration.
+        // Find the index via a raw-ptr field read first, then swap_remove, so
+        // no `&mut HTTPClient` is held across the Vec mutation and no `&mut`
+        // is materialised during iteration.
         let found = self
             .pending_attach
             .iter()
@@ -835,7 +834,8 @@ impl ClientSession {
             self.maybe_release();
             return;
         }
-        // PORT NOTE: reshaped for borrowck — find target before detaching.
+        // Find the target before detaching so no borrow of `self.streams` is
+        // held across the mutation.
         let mut target: Option<*mut Stream> = None;
         for &e in self.streams.values() {
             if stream_ref(e)
@@ -981,8 +981,8 @@ impl ClientSession {
                 }
             };
             // handleResponseMetadata set is_redirect_pending. The doRedirect
-            // contract assumes the caller already detached the stream
-            // (http.zig:1062). Detach + RST here unconditionally so the
+            // contract assumes the caller already detached the stream.
+            // Detach + RST here unconditionally so the
             // header_progress path below can never re-enter doRedirect via
             // progressUpdate while the old Stream still points at this
             // client — that path would attach a second Stream to the same
@@ -1013,7 +1013,7 @@ impl ClientSession {
                 return self.finish_stream(stream, client);
             }
             client.h2_clone_metadata();
-            // Mirror the h1 path (http.zig handleOnDataHeaders): deliver headers
+            // Mirror the h1 path: deliver headers
             // to JS now so `await fetch()` resolves and `getReader()` can enable
             // response_body_streaming. Without this, a content-length response
             // buffers the entire body before the Response promise settles.
@@ -1121,5 +1121,3 @@ impl Drop for ClientSession {
         // bun.destroy(this) — handled by heap::take in `deref`.
     }
 }
-
-// ported from: src/http/h2_client/ClientSession.zig
diff --git a/src/http/h2_client/PendingConnect.rs b/src/http/h2_client/PendingConnect.rs
index edc8a884258..8da7f521d03 100644
--- a/src/http/h2_client/PendingConnect.rs
+++ b/src/http/h2_client/PendingConnect.rs
@@ -14,7 +14,7 @@ use crate::ssl_config::SSLConfig;
 pub struct PendingConnect {
     pub hostname: Box<[u8]>,
     pub port: u16,
-    // TODO(port): lifetime — compared by pointer identity only, never derefed/freed here
+    // Compared by pointer identity only, never derefed/freed here; lifetime-erased.
     pub ssl_config: Option<NonNull<SSLConfig>>,
     /// Whether the client that initiated this in-flight TLS connect requested
     /// `rejectUnauthorized`. The eventual `ClientSession` records this as
@@ -28,7 +28,6 @@ pub struct PendingConnect {
 }
 
 impl PendingConnect {
-    /// Zig: `pub const new = bun.TrivialNew(@This());`
     pub fn new(init: Self) -> Box<Self> {
         Box::new(init)
     }
@@ -63,19 +62,16 @@ impl PendingConnect {
     /// `Box<Self>` back to the caller. Associated fn (not `&mut self`) because
     /// the list owns `Box<Self>` — `swap_remove` would otherwise drop the very
     /// allocation `&mut self` borrows from (UAF). Caller holds the returned
-    /// Box until scope exit (Zig: `defer pc.deinit()`).
+    /// Box until scope exit.
     pub fn unregister_from(this: *const Self, ctx: &mut NewHTTPContext<true>) -> Option<Box<Self>> {
         let list = &mut ctx.pending_h2_connects;
-        // PORT NOTE: reshaped for borrowck (was `for + swapRemove + return`)
+        // reshaped for borrowck (was `for + swapRemove + return`)
         list.iter()
             .position(|p| core::ptr::eq(&raw const **p, this))
             .map(|i| list.swap_remove(i))
     }
 
-    // Zig `deinit` freed `hostname`, deinited `waiters`, and `bun.destroy(this)`.
-    // In Rust all three are handled by dropping `Box<PendingConnect>` — `Box<[u8]>`
+    // Cleanup is handled by dropping `Box<PendingConnect>` — `Box<[u8]>`
     // and `Vec<_>` fields free themselves, and the Box frees the allocation.
     // No explicit `Drop` impl needed.
 }
-
-// ported from: src/http/h2_client/PendingConnect.zig
diff --git a/src/http/h2_client/Stream.rs b/src/http/h2_client/Stream.rs
index f835c4e3b30..e9dc4ad1b9b 100644
--- a/src/http/h2_client/Stream.rs
+++ b/src/http/h2_client/Stream.rs
@@ -9,16 +9,16 @@ use core::sync::atomic::Ordering;
 use bun_core::Error;
 use bun_picohttp as picohttp;
 
-// `H2Client.zig` is the parent module of `h2_client/`; `live_streams` lives there.
+// `live_streams` lives in the parent module of `h2_client/`.
 use super::client_session::ClientSession;
 use crate::HTTPClient;
 
-// `pub const new = bun.TrivialNew(@This());` — see `Stream::new` below, which fills the
-// Zig field defaults and returns a Box. The Box is owned by `ClientSession.streams`;
+// See `Stream::new` below, which fills the
+// field defaults and returns a Box. The Box is owned by `ClientSession.streams`;
 // Drop runs when removed from the map.
 
 pub struct Stream {
-    // PORT NOTE: was u31 (HTTP/2 stream IDs are 31-bit); top bit must stay clear.
+    // HTTP/2 stream IDs are 31-bit; the top bit must stay clear.
     pub id: u32,
     // BACKREF: this Stream is owned by `session.streams`; raw ptr per LIFETIMES class BACKREF.
     pub session: *mut ClientSession,
@@ -98,7 +98,7 @@ impl Stream {
 /// RFC 9113 §5.1. A `Stream` is created by sending HEADERS, so it starts
 /// `.open`; `idle`/`reserved` are never represented as objects. END_STREAM
 /// half-closes one side; both, or any RST_STREAM, transitions to `.closed`.
-#[repr(u8)] // PORT NOTE: was enum(u2)
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum State {
     Open,
@@ -111,17 +111,15 @@ pub enum State {
 
 impl Drop for Stream {
     fn drop(&mut self) {
-        // Zig .monotonic == LLVM monotonic == Rust Relaxed.
         let _ = super::LIVE_STREAMS.fetch_sub(1, Ordering::Relaxed);
         // header_block / body_buffer / decoded_bytes / decoded_headers: Vec<_> drops automatically.
-        // bun.destroy(this): freeing the Box is the caller's drop; nothing to do here.
+        // Freeing the Box is the caller's drop; nothing to do here.
     }
 }
 
 impl Stream {
-    /// Mirrors `bun.TrivialNew(@This())` + Zig struct field defaults: callers in Zig
-    /// write `Stream.new(.{ .id, .session, .client, .send_window })` and the rest
-    /// default to `.{}` / `0` / `false` / `""`.
+    /// Callers pass `id`, `session`, `client`, `send_window`; the rest of the
+    /// fields get their defaults.
     pub fn new(
         id: u32,
         session: *mut ClientSession,
@@ -150,8 +148,8 @@ impl Stream {
         })
     }
 
-    // PORT NOTE: Stream.zig:rst() re-entered the session via the `session`
-    // backref. In Rust that autorefs a second `&mut ClientSession` while
+    // No `rst()` here: re-entering the session via the `session` backref
+    // would autoref a second `&mut ClientSession` while
     // `parse_frames`' `&mut ClientSession` is still live (Stacked-Borrows UB),
     // so RST is routed through `ClientSession::rst_stream` instead — the
     // session `&mut` is already in scope at every call site.
@@ -185,5 +183,3 @@ impl Stream {
         self.state == State::HalfClosedRemote || self.state == State::Closed
     }
 }
-
-// ported from: src/http/h2_client/Stream.zig
diff --git a/src/http/h2_client/dispatch.rs b/src/http/h2_client/dispatch.rs
index f632f15f900..e0b19b2a4bc 100644
--- a/src/http/h2_client/dispatch.rs
+++ b/src/http/h2_client/dispatch.rs
@@ -64,7 +64,7 @@ pub fn parse_frames(session: &mut ClientSession, buf: &[u8]) -> usize {
     consumed
 }
 
-// PORT NOTE: Zig's `wire.FrameType` is non-exhaustive (any u8 valid). A
+// Frame types are non-exhaustive on the wire (any u8 is valid). A
 // `#[repr(u8)]` Rust enum is UB for unknown discriminants, so dispatch on the
 // raw u8.
 const FT_DATA: u8 = wire::FrameType::HTTP_FRAME_DATA as u8;
@@ -140,7 +140,7 @@ pub(crate) fn dispatch_frame(
                     &payload[i..i + wire::SettingsPayloadUnit::BYTE_SIZE],
                     0,
                 );
-                // PORT NOTE: brace-expr copies of packed fields (unaligned-safe).
+                // Brace-expr copies of packed fields (unaligned-safe).
                 let utype = { unit.type_ };
                 let uvalue = { unit.value };
                 match utype {
@@ -543,7 +543,6 @@ pub(crate) fn dispatch_frame(
 /// Feed an orphaned (untracked-stream) header block through the HPACK
 /// decoder purely to keep the dynamic table in sync, then discard.
 pub fn decode_discard_orphan(session: &mut ClientSession) {
-    // PORT NOTE: reshaped for borrowck (was `defer .clearRetainingCapacity()`).
     let mut offset: usize = 0;
     while offset < session.orphan_header_block.len() {
         // Disjoint field borrows: `hpack` (mut) vs `orphan_header_block` (shared).
@@ -565,8 +564,7 @@ pub fn decode_discard_orphan(session: &mut ClientSession) {
 /// HEADERS frames arrive in one read. 1xx and trailers are decoded then
 /// dropped; the final response is stored on the stream for delivery.
 pub fn decode_header_block(session: &mut ClientSession, stream: &mut Stream) {
-    // PORT NOTE: reshaped for borrowck (was `defer stream.header_block.clearRetainingCapacity()`)
-    // — `.clear()` is inlined before each return below.
+    // `stream.header_block.clear()` is inlined before each return below.
     let mut status: u32 = 0;
     let mut bounds: Vec<[u32; 3]> = Vec::new();
     let start_len = stream.decoded_bytes.len();
@@ -705,7 +703,7 @@ pub fn decode_header_block(session: &mut ClientSession, stream: &mut Stream) {
             .saturating_sub(stream.decoded_headers.capacity()),
     );
     for b in &bounds {
-        // PORT NOTE: self-referential — decoded_headers stores raw-ptr slices
+        // Self-referential — decoded_headers stores raw-ptr slices
         // borrowing stream.decoded_bytes. picohttp::Header stores raw ptrs so
         // this is sound as long as decoded_bytes is not reallocated before
         // delivery (it isn't — only ever appended to once per END_HEADERS).
@@ -715,7 +713,6 @@ pub fn decode_header_block(session: &mut ClientSession, stream: &mut Stream) {
         // SAFETY: b[1] <= b[2] <= decoded_bytes.len(); bytes is decoded_bytes.as_ptr() with no realloc since.
         let value =
             unsafe { bun_core::ffi::slice(bytes.add(b[1] as usize), (b[2] - b[1]) as usize) };
-        // PERF(port): was appendAssumeCapacity.
         stream
             .decoded_headers
             .push(picohttp::Header::new(name, value));
@@ -762,7 +759,6 @@ pub(crate) fn is_malformed_response_field(name: &[u8]) -> bool {
             _ => return true,
         }
     }
-    // PORT NOTE: Zig used a comptime string set; small enough to open-code.
     matches!(
         name,
         b"connection"
@@ -783,7 +779,7 @@ pub fn is_malformed_response_value(value: &[u8]) -> bool {
 }
 
 pub fn error_code_for(err: bun_core::Error) -> wire::ErrorCode {
-    // PORT NOTE: bun_core::Error is a NonZeroU16 interned tag; `err!()` yields
+    // bun_core::Error is a NonZeroU16 interned tag; `err!()` yields
     // a const Error per name once the link-time table lands. Until then all
     // arms compare equal to `Error::TODO`, so this degrades to the first arm —
     // no worse than the prior unconditional INTERNAL_ERROR, and correct once
@@ -799,5 +795,3 @@ pub fn error_code_for(err: bun_core::Error) -> wire::ErrorCode {
         _ => wire::ErrorCode::INTERNAL_ERROR,
     }
 }
-
-// ported from: src/http/h2_client/dispatch.zig
diff --git a/src/http/h2_client/encode.rs b/src/http/h2_client/encode.rs
index 413d85014cb..e8554c0dc72 100644
--- a/src/http/h2_client/encode.rs
+++ b/src/http/h2_client/encode.rs
@@ -65,8 +65,8 @@ enum RequestHeader {
     Sensitive,
 }
 
-// PORT NOTE: Zig used a comptime case-insensitive map. The first pass below
-// pre-lowercases the probe so a case-sensitive match suffices.
+// The match is case-sensitive; the first pass below pre-lowercases the probe
+// so that suffices (header name matching must be case-insensitive).
 fn classify_request_header(name: &[u8]) -> Option<RequestHeader> {
     Some(match name {
         b"connection" => RequestHeader::Drop,
@@ -91,7 +91,7 @@ pub fn write_request(
     stream: &mut Stream,
     request: &picohttp::Request<'_>,
 ) -> Result<(), bun_core::Error> {
-    // PORT NOTE: reshaped for borrowck — `encode_scratch` is borrowed mutably
+    // `encode_scratch` would be borrowed mutably
     // alongside `&mut *session` below; pull the Vec out, push it back at the end.
     let mut encoded = core::mem::take(&mut session.encode_scratch);
     encoded.clear();
@@ -370,8 +370,8 @@ pub(crate) fn drain_send_bodies(session: &mut ClientSession) {
     let slice: usize = session.remote_max_frame_size as usize;
     while session.conn_send_window > 0 && session.write_buffer.size() < WRITE_BUFFER_HIGH_WATER {
         let mut progressed = false;
-        // PORT NOTE: reshaped for borrowck — Zig iterates `session.streams.values()`
-        // while passing `session` mutably to `drain_send_body`. Iterate by index
+        // Iterating `session.streams.values()` while passing `session` mutably
+        // to `drain_send_body` would conflict; iterate by index
         // and re-borrow each pass.
         let mut i = 0usize;
         while i < session.streams.count() {
@@ -403,8 +403,7 @@ pub(crate) fn encode_header(
     let required = encoded.len() + name.len() + value.len() + 32;
     encoded.reserve(required.saturating_sub(encoded.len()));
     let len = encoded.len();
-    // Zig passed `encoded.allocatedSlice()` (ptr[0..capacity]) + current len as
-    // offset; mirror with the raw buffer and set_len after.
+    // Write through the raw buffer and set_len after.
     // SAFETY: `hpack.encode` writes only into `[len..len+written]`, which is
     // within the just-reserved capacity; bytes in `[0..len]` are initialized.
     let buf = unsafe { bun_core::vec::allocated_bytes_mut(encoded) };
@@ -422,20 +421,14 @@ pub(crate) fn encode_header(
 /// at least 6 bytes of capacity (max for a u32).
 pub(crate) fn encode_hpack_table_size_update(encoded: &mut Vec<u8>, value: u32) {
     if value < 31 {
-        // PERF(port): was assume_capacity
         encoded.push(0x20 | u8::try_from(value).expect("int cast"));
         return;
     }
-    // PERF(port): was assume_capacity
     encoded.push(0x20 | 31);
     let mut rest = value - 31;
     while rest >= 128 {
-        // PERF(port): was assume_capacity
         encoded.push((rest as u8) | 0x80);
         rest >>= 7;
     }
-    // PERF(port): was assume_capacity
     encoded.push(rest as u8);
 }
-
-// ported from: src/http/h2_client/encode.zig
diff --git a/src/http/h3_client/AltSvc.rs b/src/http/h3_client/AltSvc.rs
index 3dcb713e9d4..334baafca3b 100644
--- a/src/http/h3_client/AltSvc.rs
+++ b/src/http/h3_client/AltSvc.rs
@@ -131,7 +131,7 @@ struct Record {
     expires_at: i64,
 }
 
-// PORT NOTE: module-level mutable state. Zig used a plain `var`; safe because
+// module-level mutable state; safe because
 // every access is on the single HTTP thread (see module doc).
 // PORTING.md §Global mutable state: HTTP-thread-only map → RacyCell.
 static CACHE: bun_core::RacyCell<Option<StringHashMap<Record>>> = bun_core::RacyCell::new(None);
@@ -155,40 +155,24 @@ const MAX_ENTRIES: usize = 256;
 
 fn key<'a>(buf: &'a mut [u8], hostname: &[u8], port: u16) -> &'a [u8] {
     // Callers guard `hostname.len > 256` against a `256+8` buffer, and a u16
-    // port is at most 5 digits + ':' — bufPrint cannot overflow.
+    // port is at most 5 digits + ':' — the write cannot overflow.
     use std::io::Write;
     let mut cursor: &mut [u8] = buf;
-    // Zig `{s}` writes raw bytes; bstr Display would lossy-expand invalid UTF-8
+    // bstr Display would lossy-expand invalid UTF-8
     // (1 byte → 3-byte U+FFFD) and could overflow the bound above. Write the
     // hostname verbatim, then format only the port.
     cursor.write_all(hostname).expect("unreachable");
     write!(cursor, ":{}", port).expect("unreachable");
-    // PORT NOTE: reshaped for borrowck — capture remaining len before reborrowing buf.
+    // reshaped for borrowck — capture remaining len before reborrowing buf.
     let remaining = cursor.len();
     let written = buf.len() - remaining;
     &buf[..written]
 }
 
 fn sweep_expired(now: i64) {
-    let cache = cache();
-    // Unmanaged hash-map iteration is not removal-safe; restart after each removal.
-    // TODO(port): `StringHashMap` API — assumes `iter()` yielding `(&Box<[u8]>, &Record)`
-    // and `remove(&[u8])` that drops the owned key. Adjust to actual bun_collections API.
-    'outer: loop {
-        let mut to_remove: Option<Box<[u8]>> = None;
-        for (k, v) in cache.iter() {
-            if now >= v.expires_at {
-                to_remove = Some(Box::<[u8]>::from(&**k));
-                break;
-            }
-        }
-        match to_remove {
-            Some(k) => {
-                cache.remove(&k[..]);
-            }
-            None => break 'outer,
-        }
-    }
+    // `retain` (hashbrown, via DerefMut) is removal-safe during iteration;
+    // dropping each removed entry frees its owned key.
+    cache().retain(|_, v| now < v.expires_at);
 }
 
 /// Remember (or refresh / clear) the h3 alternative for `origin_host:origin_port`
@@ -221,7 +205,7 @@ pub(crate) fn record(origin_host: &[u8], origin_port: u16, field_value: &[u8]) {
             return;
         }
     }
-    // PORT NOTE: `StringHashMap::put` dupes the key on insert (matches Zig getOrPut).
+    // `StringHashMap::put` dupes the key on insert.
     let _ = cache().put(
         k,
         Record {
@@ -254,7 +238,3 @@ pub(crate) fn lookup(origin_host: &[u8], origin_port: u16) -> Option<u16> {
     }
     Some(rec.h3_port)
 }
-
-// ─── helpers ──────────────────────────────────────────────────────────────
-
-// ported from: src/http/h3_client/AltSvc.zig
diff --git a/src/http/h3_client/ClientContext.rs b/src/http/h3_client/ClientContext.rs
index ccac4fdc6e3..0bae72b83ad 100644
--- a/src/http/h3_client/ClientContext.rs
+++ b/src/http/h3_client/ClientContext.rs
@@ -87,8 +87,8 @@ impl ClientContext {
         let qctx = NonNull::new(qctx).expect("us_create_quic_socket_context returned null");
 
         // Process-lifetime singleton — published into `INSTANCE` below and
-        // never torn down (the lsquic engine outlives every request, same as
-        // `h3_client.zig`'s process-global `var instance`). `alloc_nn` is the
+        // never torn down (the lsquic engine outlives every request).
+        // `alloc_nn` is the
         // `Box::into_raw`-as-`NonNull` spelling of that one-time hand-off.
         let self_ = bun_core::heap::alloc_nn(ClientContext {
             qctx,
@@ -123,11 +123,11 @@ impl ClientContext {
             }
         }
 
-        // Zig: `dupeZ` — owned NUL-terminated buffer. `dupeZ` copies bytes
-        // verbatim (interior NUL allowed) then appends a sentinel; lsquic reads
-        // it as a C string so an interior NUL truncates on the C side. Mirror
-        // that here instead of `CString::new`, which would reject interior NUL
-        // and diverge by returning `false` where Zig proceeds.
+        // Owned NUL-terminated buffer: copy the bytes
+        // verbatim (interior NUL allowed) then append a sentinel; lsquic reads
+        // it as a C string so an interior NUL truncates on the C side. This is
+        // deliberately not `CString::new`, which would reject interior NUL
+        // and diverge by returning `false`.
         let mut host_buf = hostname.to_vec();
         host_buf.push(0);
         let host_z = std::ffi::CStr::from_bytes_until_nul(&host_buf).expect("nul appended above");
@@ -225,5 +225,3 @@ impl ClientContext {
         }
     }
 }
-
-// ported from: src/http/h3_client/ClientContext.zig
diff --git a/src/http/h3_client/ClientSession.rs b/src/http/h3_client/ClientSession.rs
index 096b75e4c9a..2a490435d91 100644
--- a/src/http/h3_client/ClientSession.rs
+++ b/src/http/h3_client/ClientSession.rs
@@ -1,8 +1,7 @@
 //! One QUIC connection to an origin. Owns its UDP endpoint via quic.c and
 //! multiplexes `Stream`s, each bound 1:1 to an `HTTPClient`. The `qsocket`
 //! pointer becomes dangling after `callbacks.onConnClose`, so every accessor
-//! checks `closed` first. See `src/http/H3Client.zig` for the module-level
-//! overview.
+//! checks `closed` first.
 
 use core::cell::Cell;
 use core::ptr::NonNull;
@@ -174,7 +173,7 @@ impl ClientSession {
     }
 
     pub fn fail(&mut self, stream: *mut Stream, err: bun_core::Error) {
-        // PORT NOTE: reshaped for borrowck — capture client ptr before detach() invalidates stream.
+        // Capture the client ptr before detach() invalidates `stream`.
         let client = stream_mut(stream).client;
         stream_mut(stream).abort();
         self.detach(stream);
@@ -191,7 +190,7 @@ impl ClientSession {
     /// port-reuse race where a pooled session goes stale between the
     /// `matches()` check and the first stream open.
     pub fn retry_or_fail(&mut self, stream: *mut Stream, err: bun_core::Error) {
-        // PORT NOTE: reshaped for Stacked Borrows like `fail` below — `detach()`
+        // Shaped for Stacked Borrows like `fail` below — `detach()`
         // re-derives `&mut HTTPClient` from the same raw ptr to null `h3`, which
         // would invalidate any `&mut HTTPClient` held across it. Hold the raw
         // `client_ptr` across `detach` and only form `&mut` afterward.
@@ -234,10 +233,9 @@ impl ClientSession {
     }
 
     pub fn abort_by_http_id(&mut self, async_http_id: u32) -> bool {
-        // PORT NOTE: Zig iterates `pending.items` and calls `this.fail` (which
-        // mutates `pending`) mid-loop. Rust borrowck forbids reborrowing
-        // `&mut self` while the iterator holds `&self.pending`, and only one
-        // entry can match — so locate first via raw-ptr reads, then act.
+        // `fail` mutates `pending`, so it cannot be called while the iterator
+        // holds `&self.pending`, and only one entry can match — so locate
+        // first via raw-ptr reads, then act.
         let mut found: *mut Stream = core::ptr::null_mut();
         for &stream_ptr in self.pending.iter() {
             // pending entries are live until detach(); `stream_ref` reads the
@@ -475,5 +473,3 @@ impl Drop for ClientSession {
         // `bun.destroy(this)` is handled by `deref()` via heap::take.
     }
 }
-
-// ported from: src/http/h3_client/ClientSession.zig
diff --git a/src/http/h3_client/PendingConnect.rs b/src/http/h3_client/PendingConnect.rs
index ffbaca890ad..7c0c0df2a8b 100644
--- a/src/http/h3_client/PendingConnect.rs
+++ b/src/http/h3_client/PendingConnect.rs
@@ -80,7 +80,6 @@ impl PendingConnect {
     pub unsafe fn on_dns_resolved(this: *mut PendingConnect) {
         // SAFETY: `this` was heap-allocated in `register`; reclaim it so the Box drops at
         // end of scope — `Drop` derefs `session` and the allocation is freed.
-        // (Zig: defer { session.deref(); bun.destroy(this); })
         let this = unsafe { bun_core::heap::take(this) };
         let session = this.session;
 
@@ -159,7 +158,6 @@ impl PendingConnect {
                 super::client_session::client_mut(cl).fail_from_h2(err);
             }
         }
-        // Zig .monotonic == LLVM monotonic == Rust Relaxed
         let _ = super::LIVE_SESSIONS.fetch_sub(1, Ordering::Relaxed);
         // SAFETY: `s` refers to a live heap-allocated ClientSession (caller holds
         // an intrusive ref for the duration); this drops the connection-alive ref.
@@ -188,5 +186,3 @@ unsafe impl Send for Resolved {}
 /// dedicated `Sync` static sidesteps that without weakening the singleton
 /// accessor's `&mut` contract.
 static RESOLVED: Guarded<Vec<Resolved>> = Guarded::new(Vec::new());
-
-// ported from: src/http/h3_client/PendingConnect.zig
diff --git a/src/http/h3_client/Stream.rs b/src/http/h3_client/Stream.rs
index c14ec66cd19..d0b99863331 100644
--- a/src/http/h3_client/Stream.rs
+++ b/src/http/h3_client/Stream.rs
@@ -39,7 +39,6 @@ pub struct Stream {
 }
 
 impl Stream {
-    /// Zig: `pub const new = bun.TrivialNew(@This());`
     /// Heap-allocates a `Stream` and returns the raw pointer; ownership is held
     /// by `ClientSession.pending` until `ClientSession::detach` reclaims it via
     /// `heap::take`.
@@ -97,10 +96,6 @@ impl Stream {
 impl Drop for Stream {
     fn drop(&mut self) {
         // `decoded_headers` / `body_buffer` are Vec — freed automatically.
-        // Zig `.monotonic` == LLVM monotonic == Rust `Relaxed`.
         h3::LIVE_STREAMS.fetch_sub(1, Ordering::Relaxed);
-        // Zig: `bun.destroy(this)` — the Box deallocation happens at the drop site.
     }
 }
-
-// ported from: src/http/h3_client/Stream.zig
diff --git a/src/http/h3_client/callbacks.rs b/src/http/h3_client/callbacks.rs
index 08b2e85da76..941b4f4d5a0 100644
--- a/src/http/h3_client/callbacks.rs
+++ b/src/http/h3_client/callbacks.rs
@@ -232,7 +232,6 @@ extern "C" fn on_stream_headers(s: *mut quic::Stream) {
             session.fail(stream, err!(HTTP3ProtocolError));
             return;
         }
-        // PERF(port): was appendAssumeCapacity — Vec::push amortizes.
         stream
             .decoded_headers
             .push(picohttp::Header::new(name, value));
@@ -283,5 +282,3 @@ extern "C" fn on_stream_close(s: *mut quic::Stream) {
     );
     stream.session_mut().deliver(stream, true);
 }
-
-// ported from: src/http/h3_client/callbacks.zig
diff --git a/src/http/h3_client/encode.rs b/src/http/h3_client/encode.rs
index 605ad7234cb..bba6f0979ae 100644
--- a/src/http/h3_client/encode.rs
+++ b/src/http/h3_client/encode.rs
@@ -27,7 +27,7 @@ pub fn write_request(
     };
     // `stream.client` is a live backref while attached — see `client_mut` doc.
     let client: &mut HTTPClient = super::client_session::client_mut(client_ptr);
-    // PORT NOTE: reshaped for borrowck — `build_request` returns a `Request<'_>`
+    // `build_request` returns a `Request<'_>`
     // that mutably borrows `client`; capture every field we need first.
     let verbose = client.verbose;
     let href: &[u8] = client.url.href;
@@ -54,7 +54,6 @@ pub fn write_request(
         );
     }
 
-    // PERF(port): was stack-fallback (std.heap.stackFallback(2048)).
     let mut headers: Vec<quic::Header> = Vec::with_capacity(request.headers.len() + 4);
 
     // Names not in the QPACK static table get lowercased into one
@@ -212,5 +211,3 @@ pub(crate) fn drain_send_body(stream: &mut Stream, qs: &mut quic::Stream) {
         qs.want_write(true);
     }
 }
-
-// ported from: src/http/h3_client/encode.zig
diff --git a/src/http/lib.rs b/src/http/lib.rs
index 8d0f9f5033a..6ef0b843b58 100644
--- a/src/http/lib.rs
+++ b/src/http/lib.rs
@@ -1,7 +1,4 @@
-//! HTTP client (port of `src/http/http.zig`).
-//! The Zig file is `const HTTPClient = @This();` — the whole module IS the
-//! `HTTPClient` struct. In Rust the struct is named explicitly and free
-//! functions become inherent methods on it.
+//! HTTP client.
 
 #![warn(unused_must_use)]
 #[path = "AsyncHTTP.rs"]
@@ -69,14 +66,14 @@ pub use thread_safe_stream_buffer::ThreadSafeStreamBuffer;
 #[path = "ssl_config.rs"]
 pub mod ssl_config;
 pub use ssl_config::SSLConfig;
-// PORT NOTE: SSLWrapper was MOVE_DOWN to bun_uws (tier 4); re-export here so
+// SSLWrapper was MOVE_DOWN to bun_uws (tier 4); re-export here so
 // `crate::ssl_wrapper::SSLWrapper` resolves for ProxyTunnel/HTTPContext.
 pub use bun_uws::ssl_wrapper;
 pub use bun_uws::ssl_wrapper::SSLWrapper;
 
 // ── naming aliases ──
-// Submodules use both `HTTPClient`/`HttpClient` and the Zig type-factory
-// name `NewHTTPContext`; alias all spellings to the canonical types so submodules
+// Submodules use both `HTTPClient`/`HttpClient` and the older name
+// `NewHTTPContext`; alias all spellings to the canonical types so submodules
 // resolve without churn.
 pub use h2_client as h2;
 pub use h2_client as H2;
@@ -118,12 +115,12 @@ pub use bun_http_types::Encoding::Encoding;
 pub use header_value_iterator::HeaderValueIterator;
 pub use init_error::InitError;
 
-/// Zig: `pub const extremely_verbose = false;` — compile-time switch.
+/// Compile-time verbosity switch.
 pub const EXTREMELY_VERBOSE: bool = false;
 
 /// Cloned response metadata (headers + url + status). Ownership transfers to
 /// the user once the headers phase completes.
-// PORT NOTE: hoisted so `InternalState` can name it.
+// hoisted so `InternalState` can name it.
 // The `picohttp::Response<'static>` borrows into `owned_buf`.
 pub struct HTTPResponseMetadata {
     // Borrows `owned_buf` (sibling field) — `RawSlice` carries the
@@ -144,7 +141,7 @@ impl Default for HTTPResponseMetadata {
 }
 
 impl Drop for HTTPResponseMetadata {
-    // Port of Zig `HTTPResponseMetadata.deinit`: `owned_buf` is freed by
+    // `owned_buf` is freed by
     // `Box`'s own Drop; `response.headers.list` was `Box::leak`'d in
     // `clone_metadata` and must be reclaimed here. `Default` / zero-header
     // responses have an empty static slice, guarded by the len check.
@@ -180,10 +177,9 @@ pub enum HTTPUpgradeState {
     Upgraded = 2,
 }
 
-// PORT NOTE: was `packed struct(u32)` with mixed bool + 2-bit enum fields.
+// was `packed struct(u32)` with mixed bool + 2-bit enum fields.
 // Kept as a plain struct since it never crosses FFI; restore packing
 // if the 32-byte vs 4-byte size difference shows up in profiling.
-// PERF(port): was packed struct(u32) — profile if hot.
 #[derive(Clone, Copy)]
 pub struct Flags {
     pub disable_timeout: bool,
@@ -252,7 +248,7 @@ pub static EXPERIMENTAL_HTTP3_CLIENT_FROM_CLI: AtomicBool = AtomicBool::new(fals
 
 const MAX_REDIRECT_URL_LENGTH: usize = 128 * 1024;
 
-/// Mirrors Zig's `bun.http.max_http_header_size`. The static is exported to
+/// The static is exported to
 /// C++ via `BUN_DEFAULT_MAX_HTTP_HEADER_SIZE`; `AtomicUsize` has the same
 /// size/alignment as `usize` so the symbol layout is unchanged.
 #[unsafe(export_name = "BUN_DEFAULT_MAX_HTTP_HEADER_SIZE")]
@@ -307,7 +303,7 @@ const PREALLOCATE_MAX: usize = 1024 * 1024 * 256;
 
 #[inline]
 pub fn cleanup(_force: bool) {
-    // PERF(port): was MimallocArena bulk-free — profile if hot.
+    // No-op: nothing thread-local to clean up.
 }
 
 /// Whether the experimental Alt-Svc-driven HTTP/3 upgrade is enabled at all
@@ -511,8 +507,7 @@ impl HTTPClientResultCallback {
         (self.function)(self.ctx, async_http, result);
     }
 
-    // PORT NOTE: `Callback.New(comptime Type, comptime callback)` was a
-    // type-returning fn that wrapped a typed callback in *anyopaque erasure.
+    // Type-erases a typed callback behind a raw context pointer.
     pub fn new<T>(
         this: *mut T,
         callback: fn(*mut T, *mut AsyncHTTP<'static>, HTTPClientResult<'_>),
@@ -564,8 +559,8 @@ pub trait SocketTimeout {
 
 // lowercase hash header names so that we can be sure
 pub fn hash_header_name(name: &[u8]) -> u64 {
-    // Also fixes the Wyhash11→Wyhash port bug noted in the deleted TODO; safe —
-    // `hash_header_const` at :809 is computed by this same fn at runtime, no
+    // Uses the std Wyhash algorithm; safe —
+    // every comparison hash is computed by this same fn at runtime, no
     // persisted hashes.
     bun_wyhash::hash_ascii_lowercase(0, name)
 }
@@ -610,7 +605,8 @@ pub struct HTTPClient<'a> {
     /// until `do_redirect` has released the socket, so it is freed there rather
     /// than at the assignment site. Also freed in `Drop` for error paths.
     pub prev_redirect: Vec<u8>,
-    // TODO(port): lifetime — &mut Progress::Node owned by caller; raw to avoid <'a>
+    // Non-owning back-reference to a `Progress::Node` owned by the caller;
+    // raw to avoid threading another lifetime param.
     pub progress_node: Option<NonNull<bun_core::Progress::Node>>,
 
     pub flags: Flags,
@@ -698,8 +694,8 @@ impl Drop for HTTPClient<'_> {
         // proxy_authorization: Option<Vec<u8>> — dropped automatically.
         // proxy_headers: Option<Headers> — dropped automatically.
         // tunnel was created by ProxyTunnel::new (heap::alloc) and refcounted;
-        // close_proxy_tunnel releases this client's strong ref (no shutdown —
-        // matches Zig deinit which only detach+derefs).
+        // close_proxy_tunnel releases this client's strong ref (detach+deref
+        // only, no shutdown).
         self.close_proxy_tunnel(false);
         // The session detaches `h2` before any terminal callback, so this should
         // be None by the time the result callback's deinit path runs.
@@ -717,7 +713,7 @@ impl Drop for HTTPClient<'_> {
 // `MaybeUninit` (not `Option`) so the static const-evals to all-zero bytes and
 // lands in `.bss`. `Option<HTTPThread>::None` has a non-zero niche value, which
 // forced the entire ~27 KB struct into `.data` and thus into startup RSS for
-// every process — Zig's `var http_thread: HTTPThread = undefined` is pure BSS.
+// every process.
 //
 // `ThreadCell` (not `RacyCell`) to encode "HTTP-thread-only after init" in the
 // type. `claim()` is invoked from `HTTPThread::on_start`. JS-side callers that
@@ -774,13 +770,10 @@ use bun_collections::{ArrayHashMap, VecExt};
 use bun_core::StringBuilder;
 use bun_core::{FeatureFlags, Global, Output, err};
 use bun_core::{OwnedString, String as BunString, Tag as BunStringTag, immutable as strings};
-use bun_uws as uws;
-// TODO(port): spec http.zig:829 uses `std.hash.Wyhash` (NOT Wyhash11 — see
-// PORTING.md §Crate-map). bun_wyhash currently only exports Wyhash11; swap
-// once `bun_wyhash::Wyhash` (std algorithm) lands so proxy_auth_hash() and
-// header-name hashing match any component still computing the Zig hash.
 use bun_http_types::ETag::StringPointer;
-use bun_wyhash::Wyhash11 as Wyhash;
+use bun_uws as uws;
+// the std Wyhash algorithm, not Wyhash11.
+use bun_wyhash::Wyhash;
 
 use crate::http_context::HTTPSocket as HttpSocket;
 use crate::internal_state::{RequestStage, ResponseStage, Stage};
@@ -827,11 +820,11 @@ fn get_user_agent_header() -> picohttp::Header {
 }
 
 // ── header-hash constants ───────────────────────────────────────────────
-// PORT NOTE: Zig computed these at comptime via `Wyhash + lowerString`.
-// Wyhash11 is not yet `const fn`, so use a runtime alias of `hash_header_name`
-// and cache the three values that are looked up on every request via
-// `LazyLock`. The per-header `match` arms inside `build_request` /
-// `handle_response_metadata` already call `hash_header_const` at runtime.
+// `Wyhash` is not
+// `const fn`, so use a runtime alias of `hash_header_name` and cache the three
+// values that are looked up on every request via `LazyLock`. The per-header
+// `match` arms inside `build_request` / `handle_response_metadata` already
+// call `hash_header_const` at runtime.
 #[inline(always)]
 fn hash_header_const(name: &[u8]) -> u64 {
     hash_header_name(name)
@@ -899,9 +892,8 @@ mod scratch {
 pub use scratch::temp_hostname;
 
 // ── ALPN offer enum ─────────────────────────────────────────────────────
-// PORT NOTE: Zig used `boringssl.SSL.AlpnOffer`; bun_boringssl doesn't yet
-// expose one, so define it locally and TODO(port) wire through to
-// `configure_http_client_with_alpn` once that lands.
+// bun_boringssl doesn't expose an ALPN-offer enum, so
+// one is defined locally next to `configure_http_client_with_alpn`.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum AlpnOffer {
     H1,
@@ -909,7 +901,6 @@ pub enum AlpnOffer {
     H1OrH2,
 }
 
-/// Port of `BoringSSL.SSL.configureHTTPClientWithALPN` (boringssl.zig:19066).
 /// Sets SNI (when `hostname` is non-empty), the legacy-server-connect option,
 /// the ALPN protocol list for `offer`, and enables SCT/OCSP stapling. Called
 /// from `on_open` for every TLS socket — must run even when the hostname is an
@@ -1036,7 +1027,7 @@ struct InitialRequestPayloadResult {
 /// is identical for both CONNECT tunnels and absolute-form forward requests.
 ///
 /// NOTE: this precedence is the *opposite* of the WebSocket upgrade client's
-/// CONNECT builder, which is intentional per the .zig specs — do not unify.
+/// CONNECT builder, which is intentional — do not unify.
 fn write_proxy_auth_and_headers(writer: &mut Vec<u8>, client: &HTTPClient) {
     // Check if user provided Proxy-Authorization in custom headers
     let user_provided_proxy_auth = client
@@ -1174,7 +1165,6 @@ pub fn print_request(
         Protocol::Http2 => "HTTP/2",
         Protocol::Http3 => "HTTP/3",
     };
-    // TODO(port): pretty_fmt prefix elided pending Output::error_writer() in bun_core.
     bun_core::pretty_errorln!("> {} {} {}", ver, BStr::new(request.method), BStr::new(url));
     for header in request.headers {
         bun_core::pretty_errorln!("> {}", header);
@@ -1228,12 +1218,12 @@ fn write_to_socket_with_buffer_fallback<const IS_SSL: bool>(
 //    and ProxyTunnel.rs.
 // ────────────────────────────────────────────────────────────────────────
 
-/// Zig: `BoringSSL.getCertErrorFromNo(error_no)` — maps an X509 verify code
-/// onto a `bun_core::Error` whose name is the upper-snake Zig error-set tag
+/// Maps an X509 verify code
+/// onto a `bun_core::Error` whose name is the upper-snake error tag
 /// (e.g. `CERT_HAS_EXPIRED`). JS-side `error.code` matches on this exact
 /// string, so do NOT substitute `X509_verify_cert_error_string` output here.
-// PORT NOTE: constants are the BoringSSL `X509_V_ERR_*` values from
-// `<openssl/x509.h>` (see boringssl.zig:17302-17370). Inlined as literals so
+// constants are the BoringSSL `X509_V_ERR_*` values from
+// `<openssl/x509.h>`. Inlined as literals so
 // this file doesn't grow a dep on a header-generated const set.
 pub(crate) fn get_cert_error_from_no(error_no: i32) -> bun_core::Error {
     let name: &'static str = match error_no {
@@ -1309,9 +1299,8 @@ pub(crate) fn get_cert_error_from_no(error_no: i32) -> bun_core::Error {
 }
 
 // ── HTTPClient field accessors ──────────────────────────────────────────
-// The Zig struct stored raw pointers (`*MutableString`, `*ProxyTunnel`); the
-// Rust struct uses `Option<NonNull<_>>`. These helpers centralize the unsafe
-// deref so the state-machine bodies stay readable.
+// These helpers centralize the unsafe deref of the `Option<NonNull<_>>`
+// fields so the state-machine bodies stay readable.
 impl<'a> HTTPClient<'a> {
     #[inline]
     fn request_body(&self) -> &[u8] {
@@ -1354,7 +1343,7 @@ impl<'a> HTTPClient<'a> {
     /// every fail site.
     fn dispatch_result_and_reset(&mut self, clear_proxy_tunneling: bool) {
         let callback = self.result_callback;
-        // PORT NOTE: reshaped for borrowck — `to_result()`'s `body` field is a
+        // reshaped for borrowck — `to_result()`'s `body` field is a
         // `&mut MutableString` derived from a NonNull (caller-owned, disjoint
         // from `self`'s storage), but its lifetime is tied to `&mut self`.
         // Detach so the `state.reset()` reborrow below compiles.
@@ -1363,7 +1352,7 @@ impl<'a> HTTPClient<'a> {
         // that same allocation (`(*body_out_str).reset()`, InternalState.rs)
         // while `result.body` is a live `&'static mut` to it — this overlap is
         // pre-existing (the old open-coded `(*this_ptr).state.reset()` did the
-        // same) and matches the Zig sequencing; the callback observes the
+        // same); the callback observes the
         // post-reset (empty) buffer. Do not read this comment as asserting
         // `result.body` and `state.reset()` are disjoint.
         let result = unsafe { self.to_result().detach_lifetime() };
@@ -1422,15 +1411,13 @@ pub(crate) mod body_out {
     pub(super) fn opt_mut<'a>(p: Option<NonNull<MutableString>>) -> Option<&'a mut MutableString> {
         p.map(as_mut)
     }
-    /// Snapshot the body buffer's contents by value (http.zig
-    /// `const body = out_str.*`) so a following `state.reset()` doesn't
-    /// deliver an empty body.
+    /// Snapshot the body buffer's contents by value so a following
+    /// `state.reset()` doesn't deliver an empty body.
     #[inline]
     pub(super) fn take_list(p: Option<NonNull<MutableString>>) -> Option<Vec<u8>> {
         p.map(|p| core::mem::take(&mut as_mut(p).list))
     }
-    /// Restore the body bytes that `state.reset()` cleared (http.zig
-    /// `result.body.?.* = body`).
+    /// Restore the body bytes that `state.reset()` cleared.
     #[inline]
     pub(super) fn restore_list(p: Option<NonNull<MutableString>>, v: Option<Vec<u8>>) {
         if let (Some(p), Some(v)) = (p, v) {
@@ -1603,7 +1590,7 @@ impl<'a> HTTPClient<'a> {
                 // Build a NUL-terminated SNI string only when the hostname is not an
                 // IP literal (RFC 6066 forbids IP SNI). ALPN/SCT/OCSP must still be
                 // configured regardless, so the helper is called unconditionally
-                // below with `null` SNI in the IP case (http.zig:186-207).
+                // below with `null` SNI in the IP case.
                 let mut owned: Vec<u8>; // drops on scope exit
                 let host_z: *const core::ffi::c_char = if !strings::is_ip_address(raw_hostname) {
                     // SAFETY: TEMP_HOSTNAME only accessed from HTTP thread
@@ -1750,8 +1737,8 @@ impl<'a> HTTPClient<'a> {
             };
             if alpn == b"h2" {
                 bun_core::scoped_log!(fetch, "ALPN negotiated h2 {}", BStr::new(self.url.href));
-                // PORT NOTE: `comptime is_ssl` made this arm `HttpSocket<true>`; in
-                // Rust the const-generic isn't unified, so rebuild from the InternalSocket.
+                // This arm needs HttpSocket<true>, but the const-generic isn't
+                // unified here, so rebuild from the InternalSocket.
                 let tls_socket = uws::SocketTLS::from_any(socket.socket);
                 let ctx = self.get_ssl_ctx::<true>();
                 // SAFETY: `create` returns a freshly-boxed session with refcount 1,
@@ -1890,7 +1877,6 @@ impl<'a> HTTPClient<'a> {
             return;
         }
         bun_core::scoped_log!(fetch, "Timeout  {}\n", BStr::new(self.url.href));
-        // PORT NOTE: reshaped for borrowck — Zig used `defer terminateSocket(socket)`
         self.fail(err!(Timeout));
         GenHttpContext::<IS_SSL>::terminate_socket(socket);
     }
@@ -1944,7 +1930,7 @@ impl<'a> HTTPClient<'a> {
     ///
     /// target_hostname in the pool stores url.hostname (the CONNECT TCP target
     /// at writeProxyConnect line 346). But the inner TLS SNI/cert verification
-    /// uses hostname orelse url.hostname (ProxyTunnel.zig:44). If a Host header
+    /// uses `hostname`, falling back to url.hostname. If a Host header
     /// override sets hostname != url.hostname, two requests to different IPs
     /// with the same Host header must NOT share a tunnel — they're physically
     /// connected to different servers. Hashing hostname here catches that.
@@ -2023,8 +2009,7 @@ impl<'a> HTTPClient<'a> {
     /// Returns the SSL context for this client - either the custom context
     /// (for mTLS/custom TLS) or the default global context.
     pub fn get_ssl_ctx<const IS_SSL: bool>(&self) -> *mut GenHttpContext<IS_SSL> {
-        // TODO(refactor): returns raw ptr because the global/Arc lifetimes differ;
-        // unify behind a borrow.
+        // Returns a raw ptr because the global/Arc lifetimes differ.
         if IS_SSL {
             if let Some(ctx) = self.custom_ssl_ctx.as_ref() {
                 return ctx.as_ptr().cast::<GenHttpContext<IS_SSL>>();
@@ -2058,7 +2043,7 @@ impl<'a> HTTPClient<'a> {
 
     pub fn set_custom_ssl_ctx(&mut self, ctx: NonNull<HttpsContext>) {
         // Intrusive-refcounted: this fn takes ownership of one strong ref by
-        // bumping it here (matches http.zig:821-825). Callers do NOT pre-bump.
+        // bumping it here. Callers do NOT pre-bump.
         // SAFETY: ctx points at a live HttpsContext.
         let new_ref = unsafe { http_context::HTTPContextRc::<true>::init_ref(ctx.as_ptr()) };
         if let Some(old) = self.custom_ssl_ctx.replace(new_ref) {
@@ -2131,7 +2116,6 @@ impl<'a> HTTPClient<'a> {
                 }
                 h if h == hash_header_const(b"if-modified-since") => {
                     if self.flags.force_last_modified && self.if_modified_since.is_empty() {
-                        // TODO(port): lifetime — borrows self.header_buf
                         // SAFETY: header_str() returns a slice into self.header_buf which outlives
                         // this client; lifetime is erased here only because we don't yet thread
                         // struct lifetime params. The borrow is valid for the life of `self`.
@@ -2240,9 +2224,8 @@ impl<'a> HTTPClient<'a> {
                     header_count += 1;
                 }
             } else {
-                // Zig http.zig:1051 — `std.fmt.bufPrint(&buf, "{d}", .{body_len}) catch "0"`.
                 // 11-byte buf vs 64-bit usize: must fall back to "0" on
-                // overflow (same latent bug as Zig), NOT panic.
+                // overflow, NOT panic.
                 let value: &[u8] = match bun_core::fmt::buf_print(
                     &mut self.request_content_len_buf,
                     format_args!("{body_len}"),
@@ -2299,10 +2282,7 @@ impl<'a> HTTPClient<'a> {
             self.flags.is_streaming_request_body = false;
         }
 
-        // PORT NOTE: Zig deinit'd then assigned `.empty` here; the bitwise
-        // `task.http.?.* = async_http.*` copy-back later overwrote the
-        // JS-thread original's slice with `.empty`, so the buffer was freed
-        // exactly once. The Rust port has no struct copy-back
+        // There is no struct copy-back
         // (`sync_progress_from` skips owned fields) and the original retains
         // its own `Owned(Vec)` aliasing the same allocation (the HTTP-thread
         // clone was created via `ptr::read`). Dropping it here would
@@ -2323,9 +2303,8 @@ impl<'a> HTTPClient<'a> {
 
         self.state.response_message_buffer = MutableString::default();
 
-        // PORT NOTE: copy the NonNull, do NOT `.take()` — http.zig:1098 reads
-        // `this.state.body_out_str.?` without clearing it, so the
-        // TooManyRedirects `fail()` below still sees a populated body pointer.
+        // copy the NonNull, do NOT `.take()` — the
+        // TooManyRedirects `fail()` below still needs a populated body pointer.
         let body_out_str = self.state.body_out_str.unwrap();
         self.remaining_redirect_count = self.remaining_redirect_count.saturating_sub(1);
         self.flags.redirected = true;
@@ -2412,7 +2391,6 @@ impl<'a> HTTPClient<'a> {
     }
 
     pub fn start(&mut self, body: HTTPRequestBody<'a>, body_out_str: &mut MutableString) {
-        // TODO(port): body_out_str ownership — Zig stores *MutableString in state
         body_out_str.reset();
 
         debug_assert!(self.state.response_message_buffer.list.capacity() == 0);
@@ -2431,9 +2409,9 @@ impl<'a> HTTPClient<'a> {
         // mark that we are connecting
         self.flags.defer_fail_until_connecting_is_complete = true;
         // this will call .fail() if the connection fails in the middle of the function avoiding UAF with can happen when the connection is aborted
-        // PORT NOTE: Zig `defer this.completeConnectingProcess()` cannot be a Drop guard here
+        // `complete_connecting_process()` cannot be a Drop guard here
         // (it needs `&mut self`, which would alias every other `self.*` call in the body),
-        // so it is reshaped as an explicit `self.complete_connecting_process()` before each return.
+        // so it is called explicitly before each return.
 
         // Aborted before connecting
         if self.signals.get(signals::Field::Aborted) {
@@ -2443,7 +2421,7 @@ impl<'a> HTTPClient<'a> {
         }
 
         // protocol: "http2" is documented as HTTPS-only (h2c is out of scope).
-        // Every consumer of force_http2 is gated on `comptime is_ssl`, so without
+        // Every consumer of force_http2 is gated on the SSL const-generic, so without
         // this an http:// request would silently fall through to HTTP/1.1.
         if !IS_SSL {
             if self.flags.force_http2 {
@@ -2548,7 +2526,6 @@ impl<'a> HTTPClient<'a> {
                 return;
             }
             Err(err) => {
-                // TODO(port): bun.handleErrorReturnTrace(err) — error traces not yet wired in Rust
                 self.fail(err);
                 self.complete_connecting_process();
                 return;
@@ -2598,9 +2575,9 @@ impl<'a> HTTPClient<'a> {
         socket: HttpSocket<IS_SSL>,
     ) -> Result<InitialRequestPayloadResult, bun_core::Error> {
         let mut request_body_buffer = self.get_request_body_send_buffer();
-        // PORT NOTE: request_body_buffer drops at scope exit (was `defer .deinit()`)
+        // request_body_buffer drops at scope exit (was `defer .deinit()`)
         let mut temporary_send_buffer = request_body_buffer.to_array_list();
-        // PORT NOTE: temporary_send_buffer drops at scope exit
+        // temporary_send_buffer drops at scope exit
 
         let writer = &mut temporary_send_buffer; // Vec<u8> impls bun_io::Write
 
@@ -2631,7 +2608,6 @@ impl<'a> HTTPClient<'a> {
             let wrote = spare.min(self.request_body().len());
             debug_assert!(wrote > 0);
             temporary_send_buffer.extend_from_slice(&self.request_body()[0..wrote]);
-            // PERF(port): was raw ptr write into spare capacity + len bump
         }
 
         let to_send = &temporary_send_buffer[self.state.request_sent_len..];
@@ -2705,7 +2681,7 @@ impl<'a> HTTPClient<'a> {
             if amount < to_send_len {
                 // we could not send all pending data so we need to buffer the extra data
                 if !data.is_empty() {
-                    let _ = buffer.write(data); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    let _ = buffer.write(data); // OOM/capacity: fire-and-forget
                 }
                 // failed to send everything so we have backpressure
                 return Ok(true);
@@ -2729,7 +2705,7 @@ impl<'a> HTTPClient<'a> {
 
     pub fn write_to_stream<const IS_SSL: bool>(&mut self, socket: HttpSocket<IS_SSL>, data: &[u8]) {
         bun_core::scoped_log!(fetch, "flushStream");
-        // PORT NOTE: reshaped for borrowck — copy out the Copy bits we need
+        // reshaped for borrowck — copy out the Copy bits we need
         // (`upgrade_state`, the stream-buffer NonNull, `ended`) so the
         // `&mut self.state.original_request_body` borrow is dropped before any
         // call that takes `&mut self`. The stream is re-borrowed only at the
@@ -2938,7 +2914,7 @@ impl<'a> HTTPClient<'a> {
                             );
                         }
 
-                        // PORT NOTE: sendfile.write() takes the raw fd, not the socket handle.
+                        // sendfile.write() takes the raw fd, not the socket handle.
                         match sendfile.write(socket.fd()) {
                             crate::send_file::Status::Done => {
                                 self.state.request_stage = RequestStage::Done;
@@ -2949,7 +2925,7 @@ impl<'a> HTTPClient<'a> {
                                 return;
                             }
                             crate::send_file::Status::Again => {
-                                // PORT NOTE: mark_needs_more_for_sendfile is `const SSL=false`-only;
+                                // mark_needs_more_for_sendfile is `const SSL=false`-only;
                                 // this arm is unreachable for SSL (panic above).
                                 uws::SocketTCP::from_any(socket.socket)
                                     .mark_needs_more_for_sendfile();
@@ -3003,7 +2979,6 @@ impl<'a> HTTPClient<'a> {
                     // `proxy_tunnel::raw_as_mut` INVARIANT).
                     let proxy = proxy_tunnel::raw_as_mut(proxy_ptr);
                     self.set_timeout(&socket);
-                    // PERF(port): was stack-fallback alloc (16KB) — profile if hot.
                     let mut temporary_send_buffer: Vec<u8> = Vec::with_capacity(16 * 1024);
                     let writer = &mut temporary_send_buffer;
 
@@ -3021,7 +2996,6 @@ impl<'a> HTTPClient<'a> {
                         let wrote = spare.min(self.request_body().len());
                         debug_assert!(wrote > 0);
                         temporary_send_buffer.extend_from_slice(&self.request_body()[0..wrote]);
-                        // PERF(port): was raw ptr write into spare capacity + len bump
                     }
 
                     let to_send = &temporary_send_buffer[self.state.request_sent_len..];
@@ -3160,7 +3134,7 @@ impl<'a> HTTPClient<'a> {
             let to_copy = incoming_data;
             if !to_copy.is_empty() {
                 // this one will probably be another chunk, so we leave a little extra room
-                let _ = self.state.response_message_buffer.append(to_copy); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = self.state.response_message_buffer.append(to_copy); // OOM/capacity: fire-and-forget
             }
         }
 
@@ -3178,7 +3152,7 @@ impl<'a> HTTPClient<'a> {
             "handleOnDataHeader data: {}",
             BStr::new(incoming_data)
         );
-        // PORT NOTE: reshaped for borrowck — `to_read` aliases either
+        // reshaped for borrowck — `to_read` aliases either
         // `incoming_data` or `self.state.response_message_buffer`; hold it as a
         // `RawSlice` (encapsulated outlives-holder backref, safe `.slice()`)
         // so subsequent `&mut self` calls don't trip the checker.
@@ -3542,9 +3516,9 @@ impl<'a> HTTPClient<'a> {
     // We have to clone metadata immediately after use
     pub fn clone_metadata(&mut self) {
         debug_assert!(self.state.pending_response.is_some());
-        // PORT NOTE: `Response<'static>` is `Copy`; bind by value so no borrow
+        // `Response<'static>` is `Copy`; bind by value so no borrow
         // of `self.state` is held across the `pending_response = None` write
-        // below (Zig nulls it mid-block, which would trip borrowck on a `&`).
+        // below.
         if let Some(response) = self.state.pending_response {
             if let Some(old) = self.state.cloned_metadata.take() {
                 drop(old); // deinit
@@ -3554,11 +3528,10 @@ impl<'a> HTTPClient<'a> {
             builder.count(self.url.href);
             let _ = builder.allocate();
             // headers_buf is owned by the cloned_response (aka cloned_response.headers)
-            // PORT NOTE: `Response::clone` ties its return lifetime to
+            // `Response::clone` ties its return lifetime to
             // `headers: &'a mut [Header]`; leak the box to obtain `'static` so
             // the cloned response can be stored in `HTTPResponseMetadata`.
-            // Reclaimed by `Drop for HTTPResponseMetadata` (mirrors Zig
-            // `deinit` freeing `response.headers.list`).
+            // Reclaimed by `Drop for HTTPResponseMetadata`.
             let headers_buf = bun_core::heap::release(
                 vec![picohttp::Header::ZERO; response.headers.list.len()].into_boxed_slice(),
             );
@@ -3640,7 +3613,7 @@ impl<'a> HTTPClient<'a> {
         if self.flags.protocol != Protocol::Http1_1 {
             return self.send_progress_update_multiplexed();
         }
-        // PORT NOTE: reshaped for borrowck — `to_result()` returns an
+        // reshaped for borrowck — `to_result()` returns an
         // `HTTPClientResult<'_>` whose lifetime is tied to `&mut self` (via the
         // `body: &mut MutableString` borrow). Holding that result across the
         // `is_done` mutations below would require a second live `&mut Self`,
@@ -3649,11 +3622,9 @@ impl<'a> HTTPClient<'a> {
         // `self` directly, then rebuild a fresh `HTTPClientResult` for the
         // callback from the snapshotted fields + the restored body.
         let body = self.state.body_out_str;
-        // Snapshot the body buffer's CONTENTS by value (http.zig:2238-2239
-        // `const body = out_str.*`) so that `state.reset()` — which calls
-        // `body.reset()` and clears the list — doesn't deliver an empty body
-        // when `is_done`. Restored below before the callback (http.zig:2307
-        // `result.body.?.* = body`).
+        // Snapshot the body buffer's CONTENTS by value so that `state.reset()`
+        // — which calls `body.reset()` and clears the list — doesn't deliver
+        // an empty body when `is_done`. Restored below before the callback.
         let body_snapshot = body_out::take_list(body);
         let callback = self.result_callback;
 
@@ -3708,7 +3679,7 @@ impl<'a> HTTPClient<'a> {
                 true
             };
 
-            // PORT NOTE (diverges from Zig): the same early-reply hazard
+            // The same early-reply hazard
             // described above for tunnels applies to direct connections — a
             // server may answer (200, Content-Length: 0) before a large PUT
             // body has finished writing (e.g. S3 multipart UploadPart against
@@ -3720,7 +3691,7 @@ impl<'a> HTTPClient<'a> {
             // completion path. `request_stage` alone is insufficient because
             // a fully-sent small request parks at `.body` (see on_writable),
             // so for byte-buffer bodies check the unsent slice instead.
-            // Stream/Sendfile are left at Zig parity (they don't track an
+            // Stream/Sendfile are left as-is (they don't track an
             // unsent slice here).
             let request_side_drained = match &self.state.original_request_body {
                 HTTPRequestBody::Bytes(_) => self.state.request_body.is_empty(),
@@ -3786,7 +3757,7 @@ impl<'a> HTTPClient<'a> {
             bun_core::scoped_log!(fetch, "done");
         }
 
-        // Restore the body bytes that `state.reset()` cleared (http.zig:2307).
+        // Restore the body bytes that `state.reset()` cleared.
         body_out::restore_list(body, body_snapshot);
         let async_http = self.parent_async_http();
         // Rebuild the result from snapshotted fields now that all `&mut self`
@@ -3809,7 +3780,7 @@ impl<'a> HTTPClient<'a> {
             if i.is_multiple_of(PRINT_EVERY) {
                 bun_core::prettyln!("Heap stats for HTTP thread\n");
                 Output::flush();
-                // PERF(port): MimallocArena dump_thread_stats — dropped (no DEFAULT_ARENA in Rust)
+                // Per-thread allocator stats are no longer collected here.
                 PRINT_EVERY_I.store(0, Ordering::Relaxed);
             }
         }
@@ -3820,15 +3791,14 @@ impl<'a> HTTPClient<'a> {
     /// transport, so there is no `ctx`/`socket` to hand back to the pool here.
     fn send_progress_update_multiplexed(&mut self) {
         debug_assert!(self.flags.protocol != Protocol::Http1_1);
-        // PORT NOTE: reshaped for borrowck — `to_result()` ties `result`'s
+        // reshaped for borrowck — `to_result()` ties `result`'s
         // lifetime to `&mut self`, so holding it across the `is_done` mutations
         // would require a second live `&mut Self` (aliased UB). Instead snapshot
         // every owned/Copy field out of the result, drop it, mutate `self`
         // directly, then rebuild a fresh `HTTPClientResult` for the callback.
         // See send_progress_update_without_stage_check for the same pattern.
         let body = self.state.body_out_str;
-        // Snapshot the body buffer's CONTENTS by value (http.zig:2326-2327
-        // `const body = out_str.*`); restored below (http.zig:2340).
+        // Snapshot the body buffer's CONTENTS by value; restored below.
         let body_snapshot = body_out::take_list(body);
         let callback = self.result_callback;
 
@@ -3864,7 +3834,7 @@ impl<'a> HTTPClient<'a> {
             self.state.stage = Stage::Done;
             self.flags.proxy_tunneling = false;
         }
-        // Restore the body bytes that `state.reset()` cleared (http.zig:2340).
+        // Restore the body bytes that `state.reset()` cleared.
         body_out::restore_list(body, body_snapshot);
         let async_http = self.parent_async_http();
         // Rebuild the result from snapshotted fields now that all `&mut self`
@@ -3916,9 +3886,8 @@ impl<'a> HTTPClient<'a> {
             b""
         };
         self.state.response_message_buffer = MutableString::default();
-        // PORT NOTE: copy the NonNull, do NOT `.take()` — http.zig:2360 reads
-        // `this.state.body_out_str.?` without clearing it, so the
-        // TooManyRedirects `fail()` below still sees a populated body pointer.
+        // copy the NonNull, do NOT `.take()` — the
+        // TooManyRedirects `fail()` below still needs a populated body pointer.
         let body_out_str = self.state.body_out_str.unwrap();
         self.remaining_redirect_count = self.remaining_redirect_count.saturating_sub(1);
         self.flags.redirected = true;
@@ -4106,7 +4075,6 @@ impl<'a> HTTPClient<'a> {
                 self.state.total_body_received
             );
         }
-        // PORT NOTE: Zig `defer` block moved to end of fn (no early returns after this point that skip it)
         // we can ignore the body data in redirects
         if !self.state.flags.is_redirect_pending {
             if self.state.encoding.is_compressed() {
@@ -4140,7 +4108,7 @@ impl<'a> HTTPClient<'a> {
         &mut self,
         incoming_data: &[u8],
     ) -> Result<bool, bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — get_body_buffer() may return
+        // reshaped for borrowck — get_body_buffer() may return
         // `&mut self.state.compressed_body`, so its borrow must be scoped
         // tightly and not held across other `self.state.*` accesses (would be
         // aliased `&mut`). Read the Copy fields first, then borrow the buffer
@@ -4181,8 +4149,7 @@ impl<'a> HTTPClient<'a> {
             || content_length.is_none()
         {
             let is_final_chunk = is_done;
-            // PORT NOTE: Zig passes `buffer.*` BY VALUE (http.zig:2614). Mirror that by
-            // moving the body buffer's bytes out — process_body_buffer takes `&mut self.state`
+            // Move the body buffer's bytes out — process_body_buffer takes `&mut self.state`
             // and may mutate `compressed_body` (via decompress_bytes' reset) or `body_out_str`,
             // so any `&` into `self.state` held across the call would be aliased UB.
             let buffer_snap = core::mem::take(&mut self.state.get_body_buffer().list);
@@ -4217,12 +4184,11 @@ impl<'a> HTTPClient<'a> {
         &mut self,
         incoming_data: &[u8],
     ) -> Result<bool, bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — `chunked_decoder` and the body
+        // reshaped for borrowck — `chunked_decoder` and the body
         // buffer (`compressed_body` / `body_out_str`) are disjoint fields of
         // `self.state`, so borrow them once together via the split accessor and
-        // operate on safe references. The Zig `var buffer = buffer_ptr.*` was a
-        // shallow struct copy that aliased the same allocation; deep-cloning
-        // here would diverge (mutations from process_body_buffer would be lost).
+        // operate on safe references. Deep-cloning the buffer here would
+        // diverge (mutations from process_body_buffer would be lost).
         let (decoder, body_buf) = self.state.chunked_decoder_and_body_buffer();
         body_buf.append_slice(incoming_data)?;
 
@@ -4268,7 +4234,7 @@ impl<'a> HTTPClient<'a> {
                 if self.signals.get(signals::Field::ResponseBodyStreaming) {
                     // If we're streaming, we cannot use the libdeflate fast path
                     self.state.flags.is_libdeflate_fast_path_disabled = true;
-                    // PORT NOTE: Zig passes the by-value struct copy (http.zig:2681). Move the
+                    // Move the
                     // bytes out so no `&` into self.state aliases the `&mut self.state` call.
                     let buffer_snap = core::mem::take(&mut self.state.get_body_buffer().list);
                     return self.state.process_body_buffer(buffer_snap, false);
@@ -4279,7 +4245,7 @@ impl<'a> HTTPClient<'a> {
             // Done
             _ => {
                 self.state.flags.received_last_chunk = true;
-                // PORT NOTE: Zig passes the by-value struct copy (http.zig:2689). Move the
+                // Move the
                 // bytes out so no `&` into self.state aliases the `&mut self.state` call.
                 let buffer_snap = core::mem::take(&mut self.state.get_body_buffer().list);
                 let _ = self.state.process_body_buffer(buffer_snap, true)?;
@@ -4307,8 +4273,8 @@ impl<'a> HTTPClient<'a> {
         let buffer: &mut [u8] = if self.state.response_message_buffer.owns(incoming_data) {
             // if we've already copied the buffer once, we can avoid copying it again.
             // SAFETY: `incoming_data` is a subslice of `response_message_buffer.list`
-            // (`owns` just verified). Zig does `@constCast(incoming_data)` (http.zig:2727),
-            // but `incoming_data.as_ptr() as *mut u8` would carry SharedReadOnly provenance
+            // (`owns` just verified).
+            // `incoming_data.as_ptr() as *mut u8` would carry SharedReadOnly provenance
             // (it came from a `&[u8]`) and writing through it is UB. Derive the mutable
             // slice from the owning Vec instead so the write has Unique provenance.
             let base = self.state.response_message_buffer.list.as_mut_ptr();
@@ -4355,7 +4321,7 @@ impl<'a> HTTPClient<'a> {
                     // If we're streaming, we cannot use the libdeflate fast path
                     self.state.flags.is_libdeflate_fast_path_disabled = true;
 
-                    // PORT NOTE: Zig passes `body_buffer.*` BY VALUE (http.zig:2763). Move
+                    // Move
                     // the bytes out so no `&` into self.state aliases the `&mut self.state`
                     // taken by process_body_buffer (which mutates compressed_body/body_out_str).
                     let buffer_snap = core::mem::take(&mut self.state.get_body_buffer().list);
@@ -4631,7 +4597,6 @@ impl<'a> HTTPClient<'a> {
                         let is_same_origin;
 
                         {
-                            // PERF(port): was ArenaAllocator + stackFallback(4096) — profile if hot.
                             if let Some(i) = strings::index_of(location, b"://") {
                                 let mut string_builder = StringBuilder::default();
 
@@ -4864,7 +4829,7 @@ impl<'a> HTTPClient<'a> {
                                 name: &'static [u8],
                                 hash: u64,
                             }
-                            // PORT NOTE: was a `const` table in Zig; LazyLock hashes
+                            // LazyLock hashes
                             // aren't const, so build at runtime.
                             let headers_to_remove: [H; 4] = [
                                 H {
diff --git a/src/http/lshpack.rs b/src/http/lshpack.rs
index 2d42a58cdd9..772c7287a06 100644
--- a/src/http/lshpack.rs
+++ b/src/http/lshpack.rs
@@ -30,7 +30,7 @@ pub struct HPACK {
 }
 
 pub struct DecodeResult {
-    // TODO(port): lifetime — name/value point into an FFI thread_local shared buffer,
+    // TODO: lifetime — name/value point into an FFI thread_local shared buffer,
     // valid only until the next decode/encode call. Consider `DecodeResult<'a>`.
     pub name: &'static [u8],
     pub value: &'static [u8],
@@ -49,26 +49,11 @@ pub enum HpackError {
     #[error("UnableToEncode")]
     UnableToEncode,
 }
-// TODO(port): impl From<HpackError> for bun_core::Error
+bun_core::named_error_set!(HpackError);
 
 impl HPACK {
     pub const LSHPACK_MAX_HEADER_SIZE: usize = 65536;
 
-    pub fn init(max_capacity: u32) -> *mut HPACK {
-        // `lshpack_wrapper_init` is `safe fn`: its only precondition is non-null
-        // alloc/free callbacks, which the bare (non-Option) fn-ptr types enforce.
-        let ptr = lshpack_wrapper_init(
-            bun_alloc::mimalloc::mi_malloc,
-            bun_alloc::mimalloc::mi_free,
-            max_capacity as usize,
-        );
-        if ptr.is_null() {
-            bun_core::out_of_memory();
-        }
-        ptr
-        // TODO(port): wrap in an owning newtype with Drop instead of returning a raw *mut HPACK
-    }
-
     /// DecodeResult name and value uses a thread_local shared buffer and should be copy/cloned before the next decode/encode call
     pub fn decode(&mut self, src: &[u8]) -> Result<DecodeResult, HpackError> {
         let mut header = lshpack_header::default();
@@ -131,7 +116,6 @@ impl HPACK {
                 dst_buffer_offset,
             )
         };
-        // PORT NOTE: Zig compared `offset <= 0` on a usize; only `== 0` is reachable.
         if offset == 0 {
             return Err(HpackError::UnableToEncode);
         }
@@ -146,14 +130,14 @@ impl HPACK {
         lshpack_wrapper_enc_set_max_capacity(self, max_capacity as c_uint);
     }
 
-    // PORT NOTE: Zig `destroy` (raw `*mut HPACK` teardown) is subsumed by the
-    // safe [`HpackHandle`] RAII wrapper below — every Rust owner holds an
+    // Raw `*mut HPACK` teardown is subsumed by the
+    // safe [`HpackHandle`] RAII wrapper below — every owner holds an
     // `HpackHandle`, so the raw destructor is private to `HpackHandle::drop`.
 }
 
-/// Owning handle for an `HPACK` instance returned by [`HPACK::init`].
+/// Owning handle for an `HPACK` instance.
 ///
-/// `HPACK::init` allocates via the C wrapper (`lshpack_wrapper_init`, which
+/// The instance is allocated via the C wrapper (`lshpack_wrapper_init`, which
 /// `mi_malloc`s the struct and `lshpack_{enc,dec}_init`s its internals). The
 /// matching teardown is `lshpack_wrapper_deinit`, which runs the lshpack
 /// cleanup hooks before freeing — **not** a bare `mi_free`. Wrapping the raw
@@ -164,11 +148,17 @@ pub struct HpackHandle(core::ptr::NonNull<HPACK>);
 impl HpackHandle {
     #[inline]
     pub fn new(max_capacity: u32) -> Self {
-        // `HPACK::init` already panics (out_of_memory) on null.
-        Self(
-            core::ptr::NonNull::new(HPACK::init(max_capacity))
-                .expect("lshpack_wrapper_init returned null"),
-        )
+        // `lshpack_wrapper_init` is `safe fn`: its only precondition is non-null
+        // alloc/free callbacks, which the bare (non-Option) fn-ptr types enforce.
+        let ptr = lshpack_wrapper_init(
+            bun_alloc::mimalloc::mi_malloc,
+            bun_alloc::mimalloc::mi_free,
+            max_capacity as usize,
+        );
+        let Some(ptr) = core::ptr::NonNull::new(ptr) else {
+            bun_core::out_of_memory();
+        };
+        Self(ptr)
     }
 }
 
@@ -192,8 +182,8 @@ impl core::ops::DerefMut for HpackHandle {
 impl Drop for HpackHandle {
     #[inline]
     fn drop(&mut self) {
-        // SAFETY: `self.0` came from `lshpack_wrapper_init` (via `HPACK::init`)
-        // and `HpackHandle` is its unique owner, so this is the first and only
+        // SAFETY: `self.0` came from `lshpack_wrapper_init` and `HpackHandle`
+        // is its unique owner, so this is the first and only
         // teardown — runs `lshpack_{enc,dec}_cleanup` then frees.
         unsafe { lshpack_wrapper_deinit(self.0.as_ptr()) };
     }
@@ -213,7 +203,6 @@ unsafe impl Send for HpackHandle {}
 type LshpackWrapperAlloc = extern "C" fn(size: usize) -> *mut c_void;
 type LshpackWrapperFree = unsafe extern "C" fn(ptr: *mut c_void);
 
-// TODO(port): move to bun_http_sys
 unsafe extern "C" {
     safe fn lshpack_wrapper_init(
         alloc: LshpackWrapperAlloc,
@@ -251,5 +240,3 @@ unsafe extern "C" {
         buffer_offset: usize,
     ) -> usize;
 }
-
-// ported from: src/http/lshpack.zig
diff --git a/src/http/ssl_config.rs b/src/http/ssl_config.rs
index 9ff070f0d08..d351b38baa4 100644
--- a/src/http/ssl_config.rs
+++ b/src/http/ssl_config.rs
@@ -1,5 +1,4 @@
 //! MOVE-IN: ssl_config (MOVE_DOWN bun_runtime::socket::SSLConfig → bun_http)
-//! Ground truth: src/runtime/socket/SSLConfig.zig
 //! JSC-dependent constructors (from_js / from_generated / read_from_blob /
 //! handle_path / handle_file*) stay in bun_runtime (tier-6, Pass C).
 
@@ -8,15 +7,15 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Weak};
 
 use bun_uws as uws;
-// Zig: `std.hash.Wyhash` (final4 variant). NOT `Wyhash11`.
+// Wyhash final4 variant. NOT `Wyhash11`.
 use bun_threading::Guarded as Mutex;
 use bun_wyhash::Wyhash;
 
-/// Owned, NUL-terminated C-string slice (`?[*:0]const u8` in Zig). The
+/// Owned, NUL-terminated C-string slice. The
 /// pointer is heap-owned (allocated via `dupeZ`); freed via
 /// `free_sensitive` in `deinit`.
 type CStrPtr = *const c_char;
-/// Owned slice of owned C strings (`?[][*:0]const u8` in Zig).
+/// Owned slice of owned C strings.
 type CStrSlice = Option<Box<[CStrPtr]>>;
 
 pub struct SSLConfig {
@@ -46,8 +45,7 @@ pub struct SSLConfig {
     pub low_memory_mode: bool,
     /// Memoized `content_hash()`. Interior-mutable because it's lazily filled
     /// through `Arc<SSLConfig>` (shared ref) by the intern registry's hash
-    /// context. Zig used a plain `u64` mutated via `*SSLConfig` (Zig pointers
-    /// freely alias); Rust needs `UnsafeCell`-backed storage here.
+    /// context.
     pub cached_hash: AtomicU64,
 }
 
@@ -56,8 +54,7 @@ pub type SslConfig = SSLConfig;
 
 /// Atomic shared pointer with weak support. Refcounting and allocation are
 /// managed non-intrusively by `Arc`; the `SSLConfig` struct itself has no
-/// refcount field. Mirrors `bun.ptr.shared.WithOptions(*SSLConfig,
-/// .{ .atomic = true, .allow_weak = true })`.
+/// refcount field.
 #[derive(Clone)]
 #[repr(transparent)]
 pub struct SharedPtr(Arc<SSLConfig>);
@@ -381,8 +378,9 @@ impl SSLConfig {
         }
         let p = core::mem::replace(&mut self.protos, core::ptr::null());
         let bytes = cstr_bytes(p);
-        // TODO(port): bun.memory.dropSentinel — reuses the allocation in
-        // place; here we copy. PERF(port).
+        // Copy rather than reuse the allocation in place:
+        // `Box<[u8]>` must own a global-allocator allocation of exactly `len`
+        // bytes, which the NUL-terminated `dupe_z` allocation is not.
         let owned = bytes.to_vec().into_boxed_slice();
         // SAFETY: `p` was `dupe_z`-allocated when this config was built and
         // taken (replaced with null) above — sole owner, NUL-terminated.
@@ -517,16 +515,14 @@ fn clone_string(s: CStrPtr) -> CStrPtr {
 pub mod global_registry {
     use super::*;
 
-    // PORT NOTE: Zig used `ArrayHashMapUnmanaged<*SSLConfig, WeakPtr, MapContext>`
-    // where `MapContext` hashes/compares by *content* through the raw-pointer
-    // key. That shape is UB in Rust: when an interned `Arc`'s strong count hits
+    // The registry must not hash/compare by *content* through a raw-pointer
+    // key: that shape is UB. When an interned `Arc`'s strong count hits
     // 0, std `Arc` materializes a `&mut SSLConfig` (via `drop_in_place`)
     // *before* `Drop::drop` reaches `remove()`'s mutex; a concurrent `intern()`
     // probing the map would then form a `&SSLConfig` to the same allocation via
-    // the raw key, aliasing that live `&mut`. Zig's model tolerates
-    // read-while-deinit-blocked (.zig:336-341/.zig:356); Rust's does not.
+    // the raw key, aliasing that live `&mut`.
     //
-    // The Rust shape stores `(u64 content_hash, Weak)` and probes by:
+    // So the registry stores `(u64 content_hash, Weak)` and probes by:
     //   1. fast u64 hash filter,
     //   2. `Weak::upgrade()` (so the comparand is a fresh strong `Arc`),
     //   3. `is_same()` on the upgraded value.
@@ -535,7 +531,6 @@ pub mod global_registry {
     // Backed by a flat `Vec` (linear scan): the number of distinct SSL configs
     // per process is tiny (typically <16) and `ArrayHashMap` is also linear
     // for `eql` collisions, so this is the same complexity class.
-    // PERF(port): was ArrayHashMapUnmanaged.
     static REGISTRY: Mutex<Vec<(u64, WeakPtr)>> = Mutex::new(Vec::new());
 
     /// Takes a by-value SSLConfig, wraps it in a `SharedPtr` (strong=1), and
@@ -552,13 +547,12 @@ pub mod global_registry {
         let mut dispose_new: Option<SharedPtr> = None;
         let mut dispose_old_weak: Option<WeakPtr> = None;
 
-        // PORT NOTE: reshaped for borrowck — Zig returned directly while holding
-        // the mutex, then ran `defer`s. We compute `result` in a block, drop
+        // Compute `result` in a block, drop
         // the guard, then dispose deferred values.
         let result = {
             let mut configs = REGISTRY.lock();
 
-            // Zig: `getOrPutContext` — probe by content hash + content equality.
+            // Probe by content hash + content equality.
             let mut found_idx: Option<usize> = None;
             for (i, (h, weak)) in configs.iter().enumerate() {
                 if *h != hash {
@@ -620,7 +614,7 @@ pub mod global_registry {
         if configs.is_empty() {
             return;
         }
-        // Zig: `getIndexContext` then pointer-identity check. We never
+        // We never
         // dereference stored weaks here — only compare `Weak::as_ptr`.
         let Some(idx) = configs.iter().position(|(h, weak)| {
             // Hash filter only applies if this config was hashed (interned
@@ -632,13 +626,11 @@ pub mod global_registry {
             return;
         };
         let (_, weak) = configs.swap_remove(idx);
-        // Drop the weak after unlock isn't strictly necessary (Weak::drop
-        // doesn't re-enter), but matches Zig ordering.
+        // Dropping the weak after unlock isn't strictly necessary (Weak::drop
+        // doesn't re-enter).
         drop(configs);
         drop(weak);
     }
 }
 
 pub use global_registry as GlobalRegistry;
-
-// ported from: src/runtime/socket/SSLConfig.zig
diff --git a/src/http/websocket.rs b/src/http/websocket.rs
index 621686f3248..8e19630d1da 100644
--- a/src/http/websocket.rs
+++ b/src/http/websocket.rs
@@ -3,7 +3,7 @@
 
 use core::mem::size_of;
 
-// Zig: enum(u4). Rust has no u4 repr; values are 0x0..=0xF so u8 is layout-safe.
+// Logically a u4; values are 0x0..=0xF so u8 is layout-safe.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum Opcode {
@@ -30,7 +30,7 @@ impl Opcode {
         (self as u8) & 0x8 != 0
     }
 
-    /// Zig `@enumFromInt(@as(u4, n))`. Caller must guarantee `n <= 0xF`;
+    /// Caller must guarantee `n <= 0xF`;
     /// debug-asserted. Public so call sites that already range-check the raw
     /// nibble (e.g. the WS client's extern-C `op: u8` entry points) don't have
     /// to repeat the `unsafe` block.
@@ -62,8 +62,8 @@ impl Opcode {
     }
 }
 
-// Zig: packed struct(u16) with non-bool fields → #[repr(transparent)] u16 + manual shift accessors.
-// Zig packed-struct field order is LSB-first:
+// A packed u16 bitfield: #[repr(transparent)] u16 + manual shift accessors.
+// Field order is LSB-first:
 //   bits 0..=6   len: u7
 //   bit  7       mask: bool
 //   bits 8..=11  opcode: Opcode (u4)
@@ -85,7 +85,7 @@ impl WebsocketHeader {
     const COMPRESSED_SHIFT: u32 = 14;
     const FINAL_SHIFT: u32 = 15;
 
-    /// Construct with the same defaults as the Zig packed struct
+    /// Construct with the standard defaults
     /// (`rsv = 0`, `compressed = false`, `final = true`).
     pub const fn new(len: u8, mask: bool, opcode: Opcode) -> WebsocketHeader {
         let mut bits: u16 = 0;
@@ -161,9 +161,6 @@ impl WebsocketHeader {
         self.0 = (self.0 & !(1u16 << Self::FINAL_SHIFT)) | ((v as u16) << Self::FINAL_SHIFT);
     }
 
-    // PORT NOTE: Zig `writer: anytype` called `writeInt(u16, ..)`. The byte-level
-    // `bun_io::Write` trait is not yet defined; use `std::io::Write` —
-    // `write_all` over a 2-byte big-endian buffer is identical.
     pub fn write_header(self, writer: &mut impl std::io::Write, n: usize) -> std::io::Result<()> {
         // packed structs are sometimes buggy
         // lets check it worked right
@@ -216,5 +213,3 @@ impl WebsocketHeader {
         WebsocketHeader(u16::from_be_bytes(bytes))
     }
 }
-
-// ported from: src/http/websocket.zig
diff --git a/src/http/websocket_http_client.rs b/src/http/websocket_http_client.rs
index 9f3d08ba6d1..718269042da 100644
--- a/src/http/websocket_http_client.rs
+++ b/src/http/websocket_http_client.rs
@@ -1,3 +1 @@
 // (intentionally empty)
-
-// ported from: src/http/websocket_http_client.zig
diff --git a/src/http/zlib.rs b/src/http/zlib.rs
index 61a61cbb9c6..152eada5bea 100644
--- a/src/http/zlib.rs
+++ b/src/http/zlib.rs
@@ -1,7 +1,6 @@
 use bun_core::MutableString;
 
-// PORT NOTE: Zig used `bun.ObjectPool(MutableString, initMutableString, false, 4)` and
-// recovered the node via `container_of`. `MutableString` is a foreign type so we
+// `MutableString` is a foreign type so we
 // cannot impl `ObjectPoolType` for it directly (orphan rule); a `#[repr(transparent)]`
 // newtype lets us cast `*mut PooledMutableString` ↔ `*mut MutableString` at the API
 // boundary.
@@ -21,13 +20,12 @@ mod buffer_pool {
         }
     }
 
-    // Zig: `ObjectPool(MutableString, initMutableString, false, 4)` —
-    // `threadsafe = false` ⇒ `global` storage mode.
+    // Not threadsafe ⇒ `global` storage mode.
     bun_collections::object_pool!(pub BufferPool: PooledMutableString, global, 4);
 
     pub fn get() -> *mut MutableString {
-        // TODO(port): Zig returns `*MutableString` borrowed from a pool node; consider an RAII
-        // guard so callers don't hand-pair get/put.
+        // Callers hand-pair get/put: the pointer is
+        // stored in long-lived struct fields, so a scoped RAII guard does not fit.
         // SAFETY: `first()` returns a valid `*mut PooledMutableString` whose data is initialized
         // (INIT is Some); #[repr(transparent)] makes the cast to `*mut MutableString` sound.
         BufferPool::first().cast::<MutableString>()
@@ -43,5 +41,3 @@ mod buffer_pool {
     }
 }
 pub use buffer_pool::{get, put};
-
-// ported from: src/http/zlib.zig
diff --git a/src/http_jsc/fetch_enums_jsc.rs b/src/http_jsc/fetch_enums_jsc.rs
index 09cc3ff286c..39e0a22ec83 100644
--- a/src/http_jsc/fetch_enums_jsc.rs
+++ b/src/http_jsc/fetch_enums_jsc.rs
@@ -36,5 +36,3 @@ pub fn fetch_cache_mode_to_js(this: FetchCacheMode, global: &JSGlobalObject) ->
     // `as_mut_ptr` routes through `UnsafeCell::get` for sound interior mutability.
     unsafe { Bun__FetchCacheMode__toJS(this as u8, global.as_mut_ptr()) }
 }
-
-// ported from: src/http_jsc/fetch_enums_jsc.zig
diff --git a/src/http_jsc/headers_jsc.rs b/src/http_jsc/headers_jsc.rs
index fa257b57cba..2e1283c63ce 100644
--- a/src/http_jsc/headers_jsc.rs
+++ b/src/http_jsc/headers_jsc.rs
@@ -9,7 +9,7 @@ use bun_http::Headers;
 use bun_http::headers::{EntryList, api};
 use bun_jsc::{CallFrame, FetchHeaders, HTTPHeaderName, JSGlobalObject, JSValue, JsResult};
 
-/// Port of `Headers.from` (Headers.zig). Moved up from `bun_http` so it can
+/// Moved up from `bun_http` so it can
 /// name `FetchHeaders` directly instead of dispatching through a vtable.
 ///
 /// `body_content_type` is `Some(ct)` only when the body has a *user-set*
@@ -19,7 +19,7 @@ pub fn from_fetch_headers(
     fetch_headers: Option<&FetchHeaders>,
     body_content_type: Option<&[u8]>,
 ) -> Headers {
-    // PORT NOTE: `FetchHeaders::{count,fast_has_,copy_to}` take `&mut self` but
+    // `FetchHeaders::{count,fast_has_,copy_to}` take `&mut self` but
     // are read-only FFI shims; cast through `*mut` (matching the prior
     // `link_interface!` impl which did `from_ref(h).cast_mut()`).
     let h_ptr: Option<*mut FetchHeaders> = fetch_headers.map(|h| core::ptr::from_ref(h).cast_mut());
@@ -62,8 +62,7 @@ pub fn from_fetch_headers(
     headers.buf.reserve_exact(buf_len as usize);
     // SAFETY: capacity reserved above; bytes are fully initialized by copyTo / the copy below.
     unsafe { headers.buf.set_len(buf_len as usize) };
-    // PORT NOTE: reshaped for borrowck — Zig took two column slices off one `sliced` view.
-    // The Rust `Slice::items` returns `&mut [F]` from `&self`; the two columns are
+    // `Slice::items` returns `&mut [F]` from `&self`; the two columns are
     // disjoint allocations so simultaneous access is sound, but borrowck can't see
     // that. Take raw column pointers up front and slice in scoped blocks.
     let sliced = headers.entries.slice();
@@ -107,7 +106,7 @@ pub fn from_fetch_headers(
 
 /// Build a `WebCore::FetchHeaders` from `bun.http.Headers` storage.
 ///
-/// PORT NOTE: `FetchHeaders` (opaque C++ handle) was moved into `bun_jsc`, so
+/// `FetchHeaders` (opaque C++ handle) was moved into `bun_jsc`, so
 /// the prior dep-cycle on `bun_runtime` no longer applies. The C++ side
 /// receives raw `StringPointer` column pointers; `bun_http_types` and
 /// `bun_string` both re-export the canonical `bun_core::StringPointer`, so no
@@ -127,11 +126,11 @@ pub fn to_fetch_headers(
     // entries; C++ reads exactly `count_` of each and does not retain the pointers.
     FetchHeaders::create(
         global,
-        // PORT NOTE: C++ side reads only; cast_mut() is safe (no mutation).
+        // C++ side reads only; cast_mut() is safe (no mutation).
         names.as_ptr().cast_mut(),
         values.as_ptr().cast_mut(),
-        // Spec headers_jsc.zig:12 uses `ZigString.fromBytes` (scans for
-        // non-ASCII and tags UTF-8); `init` would leave the buffer Latin-1
+        // `from_bytes` scans for
+        // non-ASCII and tags UTF-8; `init` would leave the buffer Latin-1
         // and mojibake any UTF-8 header value bytes ≥0x80.
         &ZigString::from_bytes(this.buf.as_slice()),
         this.entries.len() as u32,
@@ -142,13 +141,11 @@ pub fn to_fetch_headers(
 pub(crate) struct H2TestingAPIs;
 
 impl H2TestingAPIs {
-    // Zig source has no attribute — generate-js2native.ts scans by signature shape.
-    // TODO(port): once a `#[bun_jsc::host_fn]` proc-macro lands, annotate this so the
-    // extern "C" thunk is emitted (currently no proc-macro crate exists).
+    // No attribute needed — generate-js2native.ts scans by signature shape.
     pub(crate) fn live_counts(global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
         use bun_http::h2_client;
         let obj = JSValue::create_empty_object(global, 2);
-        // PORT NOTE: Zig `.jsNumber(i32)` → `js_number_from_int32`; h2 atomics
+        // h2 atomics
         // are `AtomicI32` (signed) so no widening.
         obj.put(
             global,
@@ -168,17 +165,15 @@ pub(crate) struct H3TestingAPIs;
 
 impl H3TestingAPIs {
     /// Named distinctly from H2's `live_counts` because generate-js2native.ts
-    /// mangles `[^A-Za-z]` to `_`, so `H2Client.zig` and `H3Client.zig` produce
+    /// mangles `[^A-Za-z]` to `_`, so the H2 and H3 client paths produce
     /// the same path prefix and the function name has to differ.
-    // TODO(port): once a `#[bun_jsc::host_fn]` proc-macro lands, annotate this so the
-    // extern "C" thunk is emitted (currently no proc-macro crate exists).
     pub(crate) fn quic_live_counts(
         global: &JSGlobalObject,
         _frame: &CallFrame,
     ) -> JsResult<JSValue> {
         use bun_http::h3_client;
         let obj = JSValue::create_empty_object(global, 2);
-        // PORT NOTE: h3 atomics are `AtomicU32`; widen to u64 for `js_number_from_uint64`.
+        // h3 atomics are `AtomicU32`; widen to u64 for `js_number_from_uint64`.
         obj.put(
             global,
             b"sessions",
@@ -208,5 +203,3 @@ pub fn h2_live_counts(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JS
 pub fn h3_quic_live_counts(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     H3TestingAPIs::quic_live_counts(global, frame)
 }
-
-// ported from: src/http_jsc/headers_jsc.zig
diff --git a/src/http_jsc/method_jsc.rs b/src/http_jsc/method_jsc.rs
index 7b4f09b8088..4bed2d4b580 100644
--- a/src/http_jsc/method_jsc.rs
+++ b/src/http_jsc/method_jsc.rs
@@ -12,8 +12,7 @@ unsafe extern "C" {
     safe fn Bun__HTTPMethod__toJS(method: Method, global_object: &JSGlobalObject) -> JSValue;
 }
 
-/// Port of Zig `Method.fromJS` (= `Map.fromJS`, the `ComptimeStringMap` JSC
-/// bridge in `src/jsc/comptime_string_map_jsc.zig`). Converts a JS string
+/// Converts a JS string
 /// value to UTF-8 and looks it up in the static method table.
 ///
 /// Lives here (not in `bun_http_types`) so the base crate stays JSC-free.
@@ -22,8 +21,7 @@ pub fn from_js(global_this: &JSGlobalObject, input: JSValue) -> JsResult<Option<
     // +1 ref from `BunString::from_js` in `OwnedString` to release it on scope exit.
     let str = OwnedString::new(BunString::from_js(input, global_this)?);
     debug_assert!(str.tag() != bun_core::Tag::Dead);
-    // PORT NOTE: Zig used `Map.getWithEql(str, bun.String.eqlComptime)`; the
-    // Rust phf table is keyed on `&[u8]`, so materialize UTF-8 and call the
+    // The phf table is keyed on `&[u8]`, so materialize UTF-8 and call the
     // existing `Method::which` (which wraps the same map lookup).
     let utf8 = str.to_utf8();
     Ok(Method::which(utf8.slice()))
@@ -41,5 +39,3 @@ impl MethodJsc for Method {
         Bun__HTTPMethod__toJS(self, global)
     }
 }
-
-// ported from: src/http_jsc/method_jsc.zig
diff --git a/src/http_jsc/websocket_client.rs b/src/http_jsc/websocket_client.rs
index d17eb74b970..23aa399797a 100644
--- a/src/http_jsc/websocket_client.rs
+++ b/src/http_jsc/websocket_client.rs
@@ -44,7 +44,7 @@ bun_core::define_scoped_log!(log, WebSocketClient, visible);
 bun_core::declare_scope!(alloc, hidden);
 
 // ──────────────────────────────────────────────────────────────────────────
-// NewWebSocketClient(comptime ssl: bool) → WebSocket<const SSL: bool>
+// WebSocket<const SSL: bool>
 // ──────────────────────────────────────────────────────────────────────────
 
 pub type Socket<const SSL: bool> = NewSocketHandler<SSL>;
@@ -93,7 +93,7 @@ pub struct WebSocket<const SSL: bool> {
     pub payload_length_frame_bytes: [u8; 8],
     pub payload_length_frame_len: u8,
 
-    // TODO(port): lifetime — managed by microtask queue, not deinit
+    // Non-owning; the allocation is managed by the microtask queue, not deinit.
     pub initial_data_handler: Option<NonNull<InitialDataHandler<SSL>>>,
     pub event_loop: &'static EventLoop,
     pub deflate: Option<Box<WebSocketDeflate>>,
@@ -113,7 +113,7 @@ pub struct WebSocket<const SSL: bool> {
     /// When set, all I/O goes through the tunnel (TLS encryption/decryption).
     /// The tunnel handles the TLS layer, so this is used with ssl=false.
     ///
-    /// PORT NOTE: intrusive refcount is hand-rolled on `WebSocketProxyTunnel`
+    /// intrusive refcount is hand-rolled on `WebSocketProxyTunnel`
     /// (`ref_()`/`deref()`); stored as `NonNull` rather than `RefPtr` because
     /// the tunnel does not (yet) implement `bun_ptr::RefCounted`. Ownership
     /// semantics match `RefPtr`: assigning here implies a held ref, released
@@ -122,7 +122,7 @@ pub struct WebSocket<const SSL: bool> {
 }
 
 impl<const SSL: bool> WebSocket<SSL> {
-    /// Zig `@typeName(@This())` — tests grep for this exact shape under `BUN_DEBUG_alloc=1`.
+    /// Tests grep for this exact shape under `BUN_DEBUG_alloc=1`.
     const ALLOC_TYPE_NAME: &'static str = if SSL {
         "http.websocket_client.NewWebSocketClient(true)"
     } else {
@@ -132,9 +132,9 @@ impl<const SSL: bool> WebSocket<SSL> {
     #[inline]
     fn vm_loop_ctx(global_this: &JSGlobalObject) -> bun_io::EventLoopCtx {
         // SAFETY: `EventLoopCtx.owner` is a type-erased `*mut ()` slot. Source
-        // it from `bun_vm_ptr()` (FFI `*mut VirtualMachine`, see
-        // `JSGlobalObject.zig:617`) rather than `bun_vm()`'s `&VirtualMachine`
-        // so the stored pointer carries write provenance instead of being
+        // it from `bun_vm_ptr()` (the FFI `*mut VirtualMachine`) rather than
+        // `bun_vm()`'s `&VirtualMachine`, so the stored pointer carries write
+        // provenance instead of being
         // laundered through a shared-ref `*const _ as *mut` hop — the vtable
         // slots (`file_polls`, `set_after_event_loop_callback`) write through
         // it.
@@ -160,7 +160,7 @@ impl<const SSL: bool> WebSocket<SSL> {
         true
     }
 
-    // Handler set referenced by `dispatch.zig` (kind = `.ws_client[_tls]`).
+    // Handler set referenced by the socket dispatch table (kind = `.ws_client[_tls]`).
     // Replaces the C++→`register()`→`us_socket_context_on_*` round-trip.
     // In Rust: these are aliased via the dispatch table; expose the handle_* fns directly.
     // pub const onClose = handleClose; → see handle_close
@@ -355,9 +355,9 @@ impl<const SSL: bool> WebSocket<SSL> {
     }
 
     fn clear_receive_buffers(&mut self, free: bool) {
-        // PORT NOTE: Zig poked `head = 0; count = 0` directly; LinearFifo's
-        // fields are private in Rust so discard everything readable instead
-        // (same observable state — empty, head realigned to 0).
+        // LinearFifo's
+        // fields are private so discard everything readable
+        // (empty, head realigned to 0).
         self.receive_buffer
             .discard(self.receive_buffer.readable_length());
 
@@ -370,7 +370,7 @@ impl<const SSL: bool> WebSocket<SSL> {
     }
 
     fn clear_send_buffers(&mut self, free: bool) {
-        // PORT NOTE: see clear_receive_buffers — discard instead of poking
+        // see clear_receive_buffers — discard instead of poking
         // private `head`/`count`.
         self.send_buffer.discard(self.send_buffer.readable_length());
         if free {
@@ -386,7 +386,7 @@ impl<const SSL: bool> WebSocket<SSL> {
 
         // Decompress the data
         let mut decompressed = deflate.rare_data.array_list();
-        // PORT NOTE: `defer decompressed.deinit()` → Drop on Vec
+        // `defer decompressed.deinit()` → Drop on Vec
 
         if let Err(err) = deflate.decompress(data, &mut decompressed) {
             let error_code = match err {
@@ -398,7 +398,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             return;
         }
 
-        // PORT NOTE: reshaped for borrowck — drop deflate borrow before re-borrowing self
+        // reshaped for borrowck — drop deflate borrow before re-borrowing self
         let items = decompressed.as_slice();
         self.dispatch_data(items, kind);
     }
@@ -429,8 +429,8 @@ impl<const SSL: bool> WebSocket<SSL> {
                     // `clone=false` and the global tag set, `Zig::toString`
                     // adopts the allocation into a `WTF::ExternalStringImpl`
                     // which `mi_free`s it later. Dropping the Vec here would
-                    // be a UAF + double-free. Mirrors websocket_client.zig
-                    // which never frees `utf16` locally.
+                    // be a UAF + double-free, so `utf16` must never be freed
+                    // locally.
                     let utf16 = core::mem::ManuallyDrop::new(utf16);
                     outstring = ZigString::from16_slice(&utf16);
                     outstring.mark_global();
@@ -483,7 +483,7 @@ impl<const SSL: bool> WebSocket<SSL> {
                 self.receive_body_remain = 0;
                 if is_final {
                     // Decompress the complete message
-                    // PORT NOTE: take ownership of the fifo so the readable
+                    // take ownership of the fifo so the readable
                     // slice does not alias `&mut self` while dispatching
                     // (PORTING.md §Forbidden: aliased-&mut). `dispatch_*` may
                     // call `terminate → clear_data → clear_receive_buffers(true)`
@@ -515,7 +515,7 @@ impl<const SSL: bool> WebSocket<SSL> {
                 self.message_is_compressed = false;
                 return data.len();
             } else if data.is_empty() {
-                // PORT NOTE: take ownership of the fifo so the readable slice
+                // take ownership of the fifo so the readable slice
                 // does not alias `&mut self` while dispatching (PORTING.md
                 // §Forbidden: aliased-&mut).
                 let buf = core::mem::replace(
@@ -548,7 +548,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             self.receive_pending_chunk_len = 0;
             self.receive_body_remain = 0;
             if is_final {
-                // PORT NOTE: take ownership of the fifo so the readable slice
+                // take ownership of the fifo so the readable slice
                 // does not alias `&mut self` while dispatching (PORTING.md
                 // §Forbidden: aliased-&mut).
                 let buf = core::mem::replace(
@@ -568,16 +568,16 @@ impl<const SSL: bool> WebSocket<SSL> {
         data.len()
     }
 
-    // PORT NOTE: takes a raw `*mut Self` instead of `&mut self` because
+    // takes a raw `*mut Self` instead of `&mut self` because
     // `handle_without_deinit()` re-enters this very function on the same
-    // allocation (spec .zig:398-402 / 1242-1253). A live outer `&mut self`
+    // allocation. A live outer `&mut self`
     // across that re-entry would yield two `&mut WebSocket` to one allocation
     // (Stacked-Borrows UB), so the preamble works through `this_ptr` and only
     // materializes `&mut *this_ptr` once re-entry is no longer possible.
     //
-    // The Zig `socket` parameter is dropped: every caller passed `this.tcp`
-    // (the dispatch thunk wraps the same `us_socket_t*` that `adopt_group`
-    // stored into `self.tcp`), so the parse loop reads `self.tcp` directly.
+    // There is no `socket` parameter: the dispatch thunk wraps the same
+    // `us_socket_t*` that `adopt_group` stored into `self.tcp`, so the parse
+    // loop reads `self.tcp` directly.
     //
     /// # Safety
     /// `this_ptr` must point to a live `WebSocket<SSL>` allocated via
@@ -636,8 +636,7 @@ impl<const SSL: bool> WebSocket<SSL> {
         let mut is_final = self.receiving_is_final;
         let mut last_receive_data_type = receiving_type;
 
-        // Zig `defer { if terminated ... else ... }` → run at end of fn
-        // PORT NOTE: implemented as explicit epilogue after the loop below.
+        // Cleanup runs as an explicit epilogue after the loop below.
 
         let mut header_bytes = [0u8; size_of::<usize>()];
 
@@ -881,7 +880,7 @@ impl<const SSL: bool> WebSocket<SSL> {
                         break;
                     }
 
-                    // PORT NOTE: copy the ≤125-byte payload to a stack array so
+                    // copy the ≤125-byte payload to a stack array so
                     // the slice does not alias `&mut self` across `dispatch_data`
                     // (PORTING.md §Forbidden: aliased-&mut). `dispatch_data` may
                     // call `terminate → clear_data` which mutates `ping_frame_bytes`'
@@ -930,7 +929,7 @@ impl<const SSL: bool> WebSocket<SSL> {
                         break;
                     }
 
-                    // PORT NOTE: copy the ≤125-byte payload to a stack array so
+                    // copy the ≤125-byte payload to a stack array so
                     // the slice does not alias `&mut self` across `dispatch_data`
                     // (PORTING.md §Forbidden: aliased-&mut).
                     let mut pong_data_buf = [0u8; 125];
@@ -1002,7 +1001,7 @@ impl<const SSL: bool> WebSocket<SSL> {
 
                         self.close_received = true;
                         let ping_len = self.ping_len as usize;
-                        // PORT NOTE: copy close_data out to avoid borrowck conflict with &mut self below
+                        // copy close_data out to avoid borrowck conflict with &mut self below
                         let mut close_data_buf = [0u8; 125];
                         close_data_buf[..ping_len]
                             .copy_from_slice(&self.ping_frame_bytes[6..][..ping_len]);
@@ -1039,7 +1038,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             }
         }
 
-        // Zig `defer { ... }` epilogue
+        // epilogue
         if terminated {
             self.close_received = true;
         } else {
@@ -1055,8 +1054,8 @@ impl<const SSL: bool> WebSocket<SSL> {
         self.send_close_with_body(1000, Some(1005), None, 0);
     }
 
-    // PORT NOTE: Zig passed `socket` by value (a copy of `this.tcp`). Every
-    // Rust caller would have passed `self.tcp`, and threading a `&Socket<SSL>`
+    // Takes no `socket` parameter: every
+    // caller would have passed `self.tcp`, and threading a `&Socket<SSL>`
     // alongside `&mut self` is a Stacked-Borrows hazard (the receiver retag
     // covers `self.tcp` and invalidates any prior `&self.tcp`-derived pointer
     // before the argument is even retagged). Read `self.tcp` directly instead.
@@ -1115,8 +1114,8 @@ impl<const SSL: bool> WebSocket<SSL> {
         if should_compress {
             // For compressed messages, we need to compress the content first
             let temp_buffer: Option<Vec<u8>>;
-            // PORT NOTE: Zig used deflate.rare_data.arena(); in Rust we use global mimalloc.
-            // PERF(port): was rare_data arena allocator
+            // Uses global mimalloc rather than a pooled arena
+            // (potential perf gap).
             let content_to_compress: &[u8] = match bytes {
                 Copy::Utf16(utf16) => 'brk: {
                     // Convert UTF16 to UTF8 for compression
@@ -1153,7 +1152,8 @@ impl<const SSL: bool> WebSocket<SSL> {
             {
                 // Compress the content
                 let mut compressed: Vec<u8> = Vec::new();
-                // PERF(port): was rare_data allocator
+                // Allocated from the global allocator rather than a pooled
+                // arena (potential perf gap).
 
                 if self
                     .deflate
@@ -1232,13 +1232,12 @@ impl<const SSL: bool> WebSocket<SSL> {
         true
     }
 
-    // PORT NOTE: renamed from `sendBuffer` to avoid clash with `send_buffer`
-    // field. Reshaped to take no slice argument: every caller in the Zig
-    // passed `this.send_buffer.readableSlice(0)`, and laundering that slice
+    // renamed from `sendBuffer` to avoid clash with `send_buffer`
+    // field. Takes no slice argument: every caller would pass
+    // the send buffer's readable slice, and laundering that slice
     // through `from_raw_parts` while holding `&mut self` is aliased-&mut UB
     // (PORTING.md §Forbidden). Instead, take ownership of the fifo, write its
-    // readable region, then restore. The Zig pointer-equality check becomes
-    // unconditional `discard`.
+    // readable region, then restore and `discard` unconditionally.
     fn send_buffer_out(&mut self) -> bool {
         let mut buf = core::mem::replace(
             &mut self.send_buffer,
@@ -1296,7 +1295,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             return false;
         }
 
-        // PORT NOTE: Zig `@bitCast(@as(u16, 0))`; WebsocketHeader has no public
+        // WebsocketHeader has no public
         // raw-bits ctor, so build the all-zero header via from_slice.
         let mut header = WebsocketHeader::from_slice([0, 0]);
         header.set_final(true);
@@ -1310,7 +1309,7 @@ impl<const SSL: bool> WebSocket<SSL> {
 
         let ping_len = self.ping_len as usize;
         if ping_len > 0 {
-            // PORT NOTE: reshaped for borrowck — Mask::fill needs disjoint borrows of ping_frame_bytes
+            // reshaped for borrowck — Mask::fill needs disjoint borrows of ping_frame_bytes
             let (head, tail) = self.ping_frame_bytes.split_at_mut(6);
             let mask_buf: &mut [u8; 4] = (&mut head[2..6])
                 .try_into()
@@ -1318,7 +1317,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             let to_mask = &mut tail[..ping_len];
             // SAFETY: input and output point to the same memory; Mask::fill supports in-place
             Mask::fill_in_place(&self.global_this, mask_buf, to_mask);
-            // PORT NOTE: copy the ≤(6+125)-byte frame to a stack array so the
+            // copy the ≤(6+125)-byte frame to a stack array so the
             // slice does not alias `&mut self` across `enqueue_encoded_bytes`
             // (PORTING.md §Forbidden: aliased-&mut). `enqueue_encoded_bytes`
             // may call `terminate → clear_data` while the laundered slice into
@@ -1364,7 +1363,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             }
         }
         let mut final_body_bytes = [0u8; 128 + 8];
-        // PORT NOTE: Zig `@bitCast(@as(u16, 0))`; WebsocketHeader has no public
+        // WebsocketHeader has no public
         // raw-bits ctor, so build the all-zero header via from_slice.
         let mut header = WebsocketHeader::from_slice([0, 0]);
         header.set_final(true);
@@ -1516,7 +1515,7 @@ impl<const SSL: bool> WebSocket<SSL> {
         let opcode = Opcode::from_raw(op);
 
         // Cast the JSValue to a Blob.
-        // PORT NOTE: `bun_jsc::webcore::Blob` is an opaque C-ABI shim (real
+        // `bun_jsc::webcore::Blob` is an opaque C-ABI shim (real
         // layout lives in `bun_runtime::webcore::Blob`, a higher-tier crate).
         // `from_js`/`shared_view` trampoline through extern fns to avoid the
         // dep cycle — see `bun_jsc::webcore::Blob` impl block.
@@ -1668,10 +1667,9 @@ impl<const SSL: bool> WebSocket<SSL> {
         // SAFETY: reason is null or a valid *const ZigString from C++
         if let Some(str) = unsafe { reason.as_ref() } {
             'inner: {
-                // Zig: FixedBufferAllocator + allocPrint("{f}", .{str}) — the
-                // `{f}` formatter writes the string in UTF-8 regardless of
+                // The reason must be written in UTF-8 regardless of
                 // backing encoding. `ZigString` has no `Display` impl yet, so
-                // replicate the encoding switch directly: 8-bit copies bytes,
+                // handle the encoding switch directly: 8-bit copies bytes,
                 // 16-bit transcodes via `to_owned_slice()` (UTF-16 → UTF-8).
                 use std::io::Write;
                 let mut cursor = std::io::Cursor::new(&mut close_reason_buf[..]);
@@ -1688,16 +1686,15 @@ impl<const SSL: bool> WebSocket<SSL> {
                         break 'inner;
                     }
                 } else {
-                    // 8-bit Latin-1. Spec websocket_client.zig:1224 routes
-                    // through `ZigString.format` → `bun.fmt.formatLatin1`,
-                    // transcoding Latin-1 → UTF-8. Writing raw Latin-1 bytes
+                    // 8-bit Latin-1: transcode Latin-1 → UTF-8.
+                    // Writing raw Latin-1 bytes
                     // here would fail the UTF-8 check in `send_close_with_body`
                     // and terminate(InvalidUtf8) instead of sending the frame.
                     let pos = cursor.position() as usize;
                     let dst = &mut cursor.get_mut()[pos..];
                     let result = strings::copy_latin1_into_utf8(dst, str.slice());
                     if (result.read as usize) < str.slice().len() {
-                        // Mirrors Zig `error.NoSpaceLeft` from FixedBufferAllocator.
+                        // Out of buffer space.
                         break 'inner;
                     }
                     cursor.set_position((pos + result.written as usize) as u64);
@@ -1756,7 +1753,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             payload_length_frame_bytes: [0u8; 8],
             payload_length_frame_len: 0,
             initial_data_handler: None,
-            // PORT NOTE: reshaped for borrowck — `vm.event_loop()` returns a
+            // reshaped for borrowck — `vm.event_loop()` returns a
             // `&'static`-tied borrow that would lock `vm` for the rest of the
             // fn; re-derive from `global_this` so `vm` stays usable below.
             // SAFETY: bun_vm() never returns null; event_loop ptr is live for VM lifetime.
@@ -1782,10 +1779,9 @@ impl<const SSL: bool> WebSocket<SSL> {
             }
         }
 
-        // PORT NOTE: Zig `adoptGroup(tcp, group, kind, "tcp", ws)` reflected on
-        // the field name; Rust port takes a closure to write the new socket.
+        // `adopt_group` takes a closure to write the new socket.
         let group = {
-            // PORT NOTE: reshaped for borrowck — `rare_data()` borrows `vm`
+            // reshaped for borrowck — `rare_data()` borrows `vm`
             // mutably and `ws_client_group` also wants a `vm` reference.
             let vm_ptr: *mut _ = vm;
             // SAFETY: `rare_data()` returns `&mut RareData` reached through
@@ -1809,7 +1805,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             ws,
             // SAFETY: `owner == ws` is a valid live allocation; raw-ptr field
             // write avoids materializing a second `&mut` that would alias
-            // `ws_ref` above (Zig's `@field(owner, "tcp") = ...` equivalent).
+            // `ws_ref` above.
             |owner, sock| unsafe { core::ptr::addr_of_mut!((*owner).tcp).write(sock) },
         ) {
             // SAFETY: `ws` is the `heap::alloc` allocation just created
@@ -1824,10 +1820,9 @@ impl<const SSL: bool> WebSocket<SSL> {
 
         if buffered_data_len > 0 {
             // SAFETY: buffered_data/len from C++; caller guarantees validity.
-            // The upgrade client allocated this buffer via `bun.default_allocator`
-            // (mimalloc) and transfers ownership to us — Zig's
-            // `InitialDataHandler.deinit` frees it with `bun.default_allocator.free`.
-            // The Rust global allocator is also mimalloc, so `heap::take`
+            // The upgrade client allocated this buffer via mimalloc
+            // and transfers ownership to us.
+            // The global allocator is also mimalloc, so `heap::take`
             // adopts the original allocation (no copy) and `Drop` will `mi_free` it.
             let buffered_slice: Box<[u8]> = unsafe {
                 bun_core::heap::take(std::ptr::slice_from_raw_parts_mut(
@@ -1851,7 +1846,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             ws_ref.initial_data_handler = NonNull::new(initial_data);
 
             // Use a higher-priority callback for the initial onData handler
-            // PORT NOTE: `queue_microtask_callback` takes an erased
+            // `queue_microtask_callback` takes an erased
             // `(*mut c_void, unsafe extern "C" fn(*mut c_void))`; cast both.
             global_this.queue_microtask_callback(
                 initial_data.cast::<c_void>(),
@@ -1877,9 +1872,8 @@ impl<const SSL: bool> WebSocket<SSL> {
         deflate_params: Option<&websocket_deflate::Params>,
     ) -> *mut c_void {
         // SAFETY: tunnel_ptr is a valid *WebSocketProxyTunnel from C++ with an
-        // intrusive refcount. The caller retains its own ref; we bump to take
-        // ownership (Zig: tunnel.ref()).
-        // PORT NOTE: Zig `tunnel.ref()` then store — bump the intrusive count
+        // intrusive refcount. The caller retains its own ref; we bump the
+        // intrusive count to take ownership
         // and store the raw owning handle (released in `clear_data`).
         let tunnel_owned: NonNull<WebSocketProxyTunnel> = {
             let p = tunnel_ptr.cast::<WebSocketProxyTunnel>();
@@ -1919,7 +1913,7 @@ impl<const SSL: bool> WebSocket<SSL> {
             payload_length_frame_bytes: [0u8; 8],
             payload_length_frame_len: 0,
             initial_data_handler: None,
-            // PORT NOTE: reshaped for borrowck — `vm.event_loop()` returns a
+            // reshaped for borrowck — `vm.event_loop()` returns a
             // `&'static`-tied borrow that would lock `vm` for the rest of the
             // fn; re-derive from `global_this` so `vm` stays usable below.
             // SAFETY: bun_vm() never returns null; event_loop ptr is live for VM lifetime.
@@ -1963,7 +1957,7 @@ impl<const SSL: bool> WebSocket<SSL> {
                 ws: NonNull::new(outgoing).map(|p| unsafe { CppWebSocketRef::new(p) }),
             }));
             ws_ref.initial_data_handler = NonNull::new(initial_data);
-            // PORT NOTE: `queue_microtask_callback` takes an erased
+            // `queue_microtask_callback` takes an erased
             // `(*mut c_void, unsafe extern "C" fn(*mut c_void))`; cast both.
             global_this.queue_microtask_callback(
                 initial_data.cast::<c_void>(),
@@ -2051,13 +2045,13 @@ impl<const SSL: bool> WebSocket<SSL> {
         }
     }
 
-    // PORT NOTE: `deinit` is the IntrusiveRc destructor callback; not `impl Drop` because
+    // `deinit` is the IntrusiveRc destructor callback; not `impl Drop` because
     // self is heap-allocated via heap::alloc and crosses FFI as *mut c_void.
     unsafe fn deinit(this: *mut Self) {
         // SAFETY: called once when ref_count hits zero
         let this_ref = unsafe { &mut *this };
         this_ref.clear_data();
-        // deflate already dropped in clear_data; this is defensive parity with Zig
+        // deflate already dropped in clear_data; this is defensive
         this_ref.deflate = None;
         if let Some(handler) = this_ref.initial_data_handler.take() {
             // SAFETY: the handler box was allocated via `heap::into_raw` in
@@ -2092,11 +2086,10 @@ impl<const SSL: bool> WebSocket<SSL> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// exportAll() — comptime @export with name concat
+// exportAll()
 // ──────────────────────────────────────────────────────────────────────────
-// PORT NOTE: avoids the `paste` crate by passing the nine fully-qualified
-// `#[no_mangle]` idents at the call site (declare-site macro). Zig's
-// comptime `++` concat has no Rust equivalent for `#[no_mangle]` literals.
+// avoids the `paste` crate by passing the nine fully-qualified
+// `#[no_mangle]` idents at the call site (declare-site macro).
 macro_rules! export_websocket_client {
     (
         $ssl:expr,
@@ -2233,14 +2226,14 @@ impl<const SSL: bool> InitialDataHandler<SSL> {
             return;
         };
         let ws_ptr = this_socket_ptr.as_ptr();
-        // PORT NOTE: this fn is reachable re-entrantly from
+        // this fn is reachable re-entrantly from
         // `WebSocket::handle_data` while that frame may later form its own
         // `&mut *ws_ptr`, so never materialize a `&mut WebSocket` here —
         // touch fields via raw projection only.
         // SAFETY: `adopted` is a backref to a live WebSocket (heap::alloc
         // provenance); raw field write of a `Copy`-sized `Option<NonNull<_>>`.
         unsafe { core::ptr::addr_of_mut!((*ws_ptr).initial_data_handler).write(None) };
-        // Zig: `defer ws.unref()` — RAII: take the owned ref so it drops at
+        // RAII: take the owned ref so it drops at
         // scope exit. Paired with the `adopted.take()` above so the ref is
         // released exactly once even when this fn is later re-called with
         // `adopted == None` (early return leaves `ws` already `None`).
@@ -2341,9 +2334,9 @@ impl Mask {
         Self::fill_with_skip_mask(mask, output, input, skip_mask);
     }
 
-    /// In-place variant for when output and input alias the same buffer.
-    /// PORT NOTE: Zig's `fill` allowed output==input; Rust borrowck forbids
-    /// `&mut [u8]` + `&[u8]` aliasing. Callers that masked in-place use this.
+    /// In-place variant for when output and input alias the same buffer
+    /// (borrowck forbids `&mut [u8]` + `&[u8]` aliasing in `fill`).
+    /// Callers that mask in-place use this.
     pub(crate) fn fill_in_place(
         global_this: &JSGlobalObject,
         mask_buf: &mut [u8; 4],
@@ -2542,7 +2535,7 @@ impl<'a> Copy<'a> {
         // 4 byte mask
         // 0, 2, 8 byte length
 
-        // PORT NOTE: Zig `@bitCast(@as(u16, 0))`; WebsocketHeader has no public
+        // WebsocketHeader has no public
         // raw-bits ctor, so build the all-zero header via from_slice.
         let mut header = WebsocketHeader::from_slice([0, 0]);
 
@@ -2564,9 +2557,9 @@ impl<'a> Copy<'a> {
             buf.len()
         );
 
-        // PORT NOTE: reshaped for borrowck — split `buf` into three disjoint
+        // reshaped for borrowck — split `buf` into three disjoint
         // regions (header bytes / 4-byte mask / payload) so `write_header` and
-        // `Mask::fill*` don't alias. Zig wrote through one pointer.
+        // `Mask::fill*` don't alias.
         let (head, to_mask_full) = buf.split_at_mut(content_offset);
         let (header_part, mask_part) = head.split_at_mut(mask_offset);
         let mask_buf: &mut [u8; 4] = (&mut mask_part[..4])
@@ -2583,8 +2576,6 @@ impl<'a> Copy<'a> {
                 header.set_len(WebsocketHeader::pack_length(
                     encode_into_result.written as usize,
                 ));
-                // TODO(port): Zig used std.io.fixedBufferStream + header.writeHeader.
-                // WebsocketHeader::write_header should write into &mut head[..2+len_int].
                 header
                     .write_header(
                         &mut &mut header_part[..],
@@ -2648,7 +2639,7 @@ impl<'a> Copy<'a> {
             _ => unreachable!(),
         }
 
-        // PORT NOTE: Zig `@bitCast(@as(u16, 0))`; WebsocketHeader has no public
+        // WebsocketHeader has no public
         // raw-bits ctor, so build the all-zero header via from_slice.
         let mut header = WebsocketHeader::from_slice([0, 0]);
 
@@ -2663,7 +2654,7 @@ impl<'a> Copy<'a> {
             buf.len()
         );
 
-        // PORT NOTE: reshaped for borrowck — three disjoint regions (see `copy`).
+        // reshaped for borrowck — three disjoint regions (see `copy`).
         let (head, to_mask_full) = buf.split_at_mut(content_offset);
         let (header_part, mask_part) = head.split_at_mut(mask_offset);
         let mask_buf: &mut [u8; 4] = (&mut mask_part[..4])
@@ -2678,5 +2669,3 @@ impl<'a> Copy<'a> {
         Mask::fill(global_this, mask_buf, to_mask, compressed_data);
     }
 }
-
-// ported from: src/http_jsc/websocket_client.zig
diff --git a/src/http_jsc/websocket_client/CppWebSocket.rs b/src/http_jsc/websocket_client/CppWebSocket.rs
index 602428111bd..cb3fec21054 100644
--- a/src/http_jsc/websocket_client/CppWebSocket.rs
+++ b/src/http_jsc/websocket_client/CppWebSocket.rs
@@ -63,7 +63,7 @@ unsafe extern "C" {
     fn WebSocket__setProtocol(websocket_context: &CppWebSocket, protocol: *mut BunString);
 }
 
-// PORT NOTE: receivers are `&self` (not `&mut self`) because `CppWebSocket` is
+// Receivers are `&self` (not `&mut self`) because `CppWebSocket` is
 // an opaque C++ handle with no Rust-visible state; mutation happens entirely on
 // the C++ side. Callers hold `NonNull<CppWebSocket>` and dispatch via shared
 // borrows (often while `&mut WebSocket<SSL>` is also live), so `&mut self`
@@ -176,7 +176,6 @@ impl CppWebSocket {
 }
 
 impl CppWebSocket {
-    // PORT NOTE: `ref` is a Rust keyword; using raw identifier to match Zig fn name.
     pub(crate) fn r#ref(&self) {
         bun_jsc::mark_binding!();
         WebSocket__incrementPendingActivity(self);
@@ -197,9 +196,8 @@ impl CppWebSocket {
 /// RAII owner of one pending-activity ref on a C++ `WebCore::WebSocket`.
 ///
 /// Construction calls [`CppWebSocket::r#ref`]; `Drop` calls
-/// [`CppWebSocket::unref`]. Replaces the Zig `ws.ref(); defer ws.unref();`
-/// pattern when the ref must outlive the constructing scope (e.g. stored on a
-/// queued task).
+/// [`CppWebSocket::unref`]. For when the ref must outlive the constructing
+/// scope (e.g. stored on a queued task).
 pub struct CppWebSocketRef(core::ptr::NonNull<CppWebSocket>);
 
 impl CppWebSocketRef {
@@ -219,5 +217,3 @@ impl Drop for CppWebSocketRef {
         CppWebSocket::opaque_ref(self.0.as_ptr()).unref();
     }
 }
-
-// ported from: src/http_jsc/websocket_client/CppWebSocket.zig
diff --git a/src/http_jsc/websocket_client/WebSocketDeflate.rs b/src/http_jsc/websocket_client/WebSocketDeflate.rs
index e88488a808d..0589c159197 100644
--- a/src/http_jsc/websocket_client/WebSocketDeflate.rs
+++ b/src/http_jsc/websocket_client/WebSocketDeflate.rs
@@ -36,8 +36,8 @@ impl Params {
 pub struct RareData {
     libdeflate_compressor: Cell<Option<*mut libdeflate_sys::Compressor>>,
     libdeflate_decompressor: Cell<Option<*mut libdeflate_sys::Decompressor>>,
-    // PERF(port): was StackFallbackAllocator(128 * 1024) — profile if hot.
-    // Zig kept a 128KB inline buffer reused as scratch for (de)compression output.
+    // PERF: a 128KB inline buffer reused as scratch for (de)compression
+    // output could avoid per-call allocation — profile if hot.
 }
 
 impl Default for RareData {
@@ -53,14 +53,12 @@ impl RareData {
     pub const STACK_BUFFER_SIZE: usize = 128 * 1024;
 
     pub fn array_list(&self) -> Vec<u8> {
-        // PERF(port): Zig handed back an ArrayList aliasing the 128KB stack_fallback
-        // buffer (zero-alloc). Allocates a fresh heap Vec per call — profile if hot.
+        // PERF: allocates a fresh heap Vec per call — profile if hot.
         Vec::with_capacity(Self::STACK_BUFFER_SIZE)
     }
 
-    // Zig `allocator()` returned the stack-fallback allocator. Allocator params are
+    // Allocator params are
     // dropped in non-AST crates; callers use the global allocator.
-    // PERF(port): was stack-fallback
 
     pub fn decompressor(&self) -> *mut libdeflate_sys::Decompressor {
         match self.libdeflate_decompressor.get() {
@@ -95,7 +93,7 @@ impl Drop for RareData {
             // SAFETY: allocated by libdeflate_alloc_decompressor, freed exactly once here.
             unsafe { libdeflate_sys::Decompressor::destroy(d) };
         }
-        // Zig: bun.destroy(this) — handled by Box<RareData> drop at the owner.
+        // Deallocation is handled by Box<RareData> drop at the owner.
     }
 }
 
@@ -109,13 +107,11 @@ pub struct PerMessageDeflate {
     pub compress_stream: zlib::z_stream,
     pub decompress_stream: zlib::z_stream,
     pub params: Params,
-    // PORT NOTE: Zig borrowed `&RareData` from VM `bun_jsc::RareData` (pooled
-    // libdeflate handles, shared across connections). `bun_jsc::RareData::
-    // websocket_deflate()` currently returns an opaque placeholder (the real
-    // type is *this* `RareData`, which would be a dep cycle), so own a
-    // per-connection instance instead.
-    // PERF(port): per-connection libdeflate alloc — restore VM-pooled instance
-    // once `bun_jsc::rare_data::WebSocketDeflateRareData` is wired to this type.
+    // VM `bun_jsc::RareData` would be the natural owner (pooled libdeflate
+    // handles, shared across connections), but `bun_jsc::RareData::websocket_deflate()`
+    // returns an opaque placeholder (the real type is *this* `RareData`, which
+    // would be a dep cycle), so each connection owns a fresh instance instead —
+    // a per-connection libdeflate allocation, not a correctness divergence.
     pub rare_data: RareData,
 }
 
@@ -159,16 +155,14 @@ impl PerMessageDeflate {
         params: Params,
         rare_data: &mut JscRareData,
     ) -> Result<Box<Self>, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut self_ = Box::new(Self {
             params,
             compress_stream: bun_core::ffi::zeroed::<zlib::z_stream>(),
             decompress_stream: bun_core::ffi::zeroed::<zlib::z_stream>(),
-            // TODO(port): bun_jsc::rare_data::WebSocketDeflateRareData —
             // `rare_data.websocket_deflate()` returns an opaque `{ _opaque: () }`
-            // placeholder in bun_jsc; the real type is `self::RareData` (this
-            // module), which bun_jsc cannot import without a dep cycle. Until a
-            // re-export shim lands, fall back to a fresh per-connection instance.
+            // placeholder in bun_jsc (the real type is `self::RareData`, which
+            // bun_jsc cannot import without a dep cycle), so use a fresh
+            // per-connection instance — see the `rare_data` field note.
             rare_data: {
                 let _ = rare_data;
                 RareData::default()
@@ -354,8 +348,6 @@ impl Drop for PerMessageDeflate {
             zlib::deflateEnd(&raw mut self.compress_stream);
             zlib::inflateEnd(&raw mut self.decompress_stream);
         }
-        // Zig: self.allocator.destroy(self) — handled by Box drop at the owner.
+        // Deallocation is handled by Box drop at the owner.
     }
 }
-
-// ported from: src/http_jsc/websocket_client/WebSocketDeflate.zig
diff --git a/src/http_jsc/websocket_client/WebSocketProxy.rs b/src/http_jsc/websocket_client/WebSocketProxy.rs
index 062f7b042a4..d67d4651588 100644
--- a/src/http_jsc/websocket_client/WebSocketProxy.rs
+++ b/src/http_jsc/websocket_client/WebSocketProxy.rs
@@ -14,13 +14,13 @@ pub(crate) struct WebSocketProxy {
     /// WebSocket upgrade request to send after CONNECT succeeds
     websocket_request_buf: Box<[u8]>,
     /// TLS tunnel for wss:// through HTTP proxy
-    // TODO(port): lifetime — intrusive refcount (Drop calls shutdown()+deref()); not in LIFETIMES.tsv
+    // Holds one intrusive ref; Drop calls shutdown()+deref().
     tunnel: Option<NonNull<WebSocketProxyTunnel>>,
 }
 
 impl WebSocketProxy {
     /// Initialize a new WebSocketProxy
-    // PORT NOTE: params are owned (Zig caller transfers allocator ownership; freed in deinit)
+    // params are owned (caller transfers ownership; freed in deinit)
     pub(crate) fn init(
         target_host: Box<[u8]>,
         target_is_https: bool,
@@ -75,5 +75,3 @@ impl Drop for WebSocketProxy {
         }
     }
 }
-
-// ported from: src/http_jsc/websocket_client/WebSocketProxy.zig
diff --git a/src/http_jsc/websocket_client/WebSocketProxyTunnel.rs b/src/http_jsc/websocket_client/WebSocketProxyTunnel.rs
index 9e9a3406ad0..43a08045973 100644
--- a/src/http_jsc/websocket_client/WebSocketProxyTunnel.rs
+++ b/src/http_jsc/websocket_client/WebSocketProxyTunnel.rs
@@ -28,8 +28,7 @@
 //! - The `*mut SSL` needed by `on_handshake` is snapshotted into `self.ssl` in
 //!   `start()` so it can be read without going through `wrapper`.
 //!
-//! This mirrors the Zig spec, which freely aliases `*WebSocketProxyTunnel` across
-//! callbacks.
+//! `*WebSocketProxyTunnel` is freely aliased across callbacks.
 
 use core::cell::Cell;
 use core::ptr;
@@ -151,7 +150,7 @@ impl WebSocketProxyTunnel {
         sni_hostname: &[u8],
         reject_unauthorized: bool,
     ) -> Result<NonNull<WebSocketProxyTunnel>, bun_alloc::AllocError> {
-        // PORT NOTE: const-generic bool → variant selection. The pointer cast is
+        // const-generic bool → variant selection. The pointer cast is
         // identity when SSL matches the alias (HttpUpgradeClient = NewHttpUpgradeClient<false>,
         // etc); `assume_ssl`/`assume_tcp` rebuild the handler around the same
         // `InternalSocket` so no `unsafe` is needed.
@@ -196,7 +195,6 @@ impl WebSocketProxyTunnel {
         ssl_options: &SslConfig,
         initial_data: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Allow handshake to complete so we can access peer certificate for manual
         // hostname verification in onHandshake(). The actual reject_unauthorized
         // check uses self.reject_unauthorized field.
@@ -235,7 +233,7 @@ impl WebSocketProxyTunnel {
 
         // Configure SNI with hostname.
         //
-        // PORT NOTE: the Zig spec does this inside `onOpen`, which `SslWrapper::start()`
+        // This could live inside `onOpen`, which `SslWrapper::start()`
         // invokes immediately before `handle_traffic()`. We hoist it here because
         // `start()` holds `&mut SslWrapper` across the `on_open` dispatch, and any
         // read of `(*ctx).wrapper` from inside the callback would invalidate that
@@ -247,12 +245,10 @@ impl WebSocketProxyTunnel {
                 if !strings::is_ip_address(hostname) {
                     // Set SNI hostname
                     let hostname_z = bun_core::ZBox::from_vec_with_nul(hostname.to_vec());
-                    // Zig `ssl_ptr.configureHTTPClient(host)` =
-                    // SNI + verify-hostname. The boringssl-crate ext-method
-                    // hasn't landed yet; route through bun_http's
+                    // Route through bun_http's
                     // tier-neutral helper which does SNI + ALPN(h1) (no
                     // verify-hostname — that is checked manually in
-                    // `on_handshake`, matching the Zig path).
+                    // `on_handshake`).
                     // `hostname_z` is a NUL-terminated owned buffer in scope.
                     bun_http::configure_http_client_with_alpn(
                         // SAFETY: `ssl_ptr` is the live SSL handle from the wrapper.
@@ -292,7 +288,7 @@ impl WebSocketProxyTunnel {
         let _guard = unsafe { bun_ptr::ScopedRef::new(this) };
         bun_core::scoped_log!(WebSocketProxyTunnel, "onOpen");
         // SNI configuration is done in `start()` before the wrapper is driven;
-        // see PORT NOTE there. This callback intentionally does not touch
+        // see the note there. This callback intentionally does not touch
         // `(*this).wrapper` — the caller (`SslWrapper::start`) holds `&mut self`
         // over those bytes.
         let _ = this;
@@ -512,7 +508,7 @@ impl WebSocketProxyTunnel {
         unsafe {
             let to_send = (*this).write_buffer.slice();
             if !to_send.is_empty() {
-                // PORT NOTE: reshaped for borrowck — capture len before re-borrowing write_buffer
+                // reshaped for borrowck — capture len before re-borrowing write_buffer
                 let to_send_len = to_send.len();
                 let written = (*this).socket.write(to_send);
                 if written < 0 {
@@ -569,7 +565,6 @@ impl WebSocketProxyTunnel {
     /// which forms `&mut *ctx`; this function therefore accesses `wrapper` via raw
     /// projection and never holds a `&mut Self` across the call.
     pub(crate) unsafe fn write(this: *mut Self, data: &[u8]) -> Result<usize, bun_core::Error> {
-        // TODO(port): narrow error set
         // SAFETY: caller contract — `this` is live; projection covers only `wrapper`.
         let wrapper_ptr = unsafe { ptr::addr_of_mut!((*this).wrapper) };
         // SAFETY: deref of field projection; `this` is live.
@@ -605,7 +600,7 @@ impl WebSocketProxyTunnel {
 impl Drop for WebSocketProxyTunnel {
     fn drop(&mut self) {
         // Field cleanup is automatic: wrapper (Option<SslWrapper>), write_buffer (StreamBuffer),
-        // sni_hostname (Option<Box<[u8]>>) all impl Drop. The Zig deinit's `bun.destroy(this)`
+        // sni_hostname (Option<Box<[u8]>>) all impl Drop. Deallocation
         // is handled by IntrusiveRc / `deref()` via heap::take.
     }
 }
@@ -624,5 +619,3 @@ pub(crate) extern "C" fn WebSocketProxyTunnel__setConnectedWebSocket(
     let tunnel = unsafe { &mut *tunnel };
     tunnel.set_connected_web_socket(ws);
 }
-
-// ported from: src/http_jsc/websocket_client/WebSocketProxyTunnel.zig
diff --git a/src/http_jsc/websocket_client/WebSocketUpgradeClient.rs b/src/http_jsc/websocket_client/WebSocketUpgradeClient.rs
index 349de5853bb..a3f83798204 100644
--- a/src/http_jsc/websocket_client/WebSocketUpgradeClient.rs
+++ b/src/http_jsc/websocket_client/WebSocketUpgradeClient.rs
@@ -52,7 +52,6 @@ use crate::websocket_client::ErrorCode;
 use bun_http::ssl_config::SSLConfig;
 
 bun_core::define_scoped_log!(log, WebSocketUpgradeClient, visible);
-// Zig: `bun.new`/`bun.destroy` log under `.alloc` (hidden, BUN_DEBUG_alloc=1).
 bun_core::declare_scope!(alloc, hidden);
 
 /// Local `VirtualMachine → EventLoopCtx` adapter for `KeepAlive::{ref,unref}`.
@@ -88,9 +87,30 @@ enum State {
     Done,
 }
 
-/// `NewHTTPUpgradeClient(comptime ssl: bool) type` — generic over `SSL`.
+/// Owned +1 reference to a `us_ssl_ctx_t` (`SSL_CTX*`); releases the ref via
+/// `SSL_CTX_free` on drop (BoringSSL decrements its internal refcount).
+/// Either dropped here, or transferred to the connected `WebSocket` via
+/// `into_raw()` after the upgrade completes.
+struct SslCtxOwned(*mut SslCtx);
+
+impl SslCtxOwned {
+    /// Transfer ownership of the retained ref to the caller without freeing.
+    fn into_raw(self) -> *mut SslCtx {
+        core::mem::ManuallyDrop::new(self).0
+    }
+}
+
+impl Drop for SslCtxOwned {
+    fn drop(&mut self) {
+        // SAFETY: `self.0` is an owned retained ref (returned with +1 by
+        // `ssl_ctx_cache_get_or_create`) that has not been transferred out.
+        unsafe { boringssl::c::SSL_CTX_free(self.0) };
+    }
+}
+
+/// WebSocket HTTP upgrade client, generic over `SSL`.
 ///
-/// `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})` — intrusive single-thread
+/// Intrusive single-thread
 /// refcount; `ref_count` field below, `ref()`/`deref()` inherent methods, `deinit`
 /// runs when count hits 0.
 #[derive(bun_ptr::CellRefCounted)]
@@ -101,9 +121,8 @@ pub struct HTTPClient<const SSL: bool> {
     outgoing_websocket: Option<*mut CppWebSocket>,
     /// Owned request bytes. Freed via `clear_input`.
     input_body_buf: Vec<u8>,
-    // PORT NOTE: reshaped for borrowck — Zig `to_send: []const u8` is always a
-    // suffix of `input_body_buf`; stored here as the suffix length so we don't
-    // hold a self-referential slice.
+    // The unsent bytes are always a suffix of `input_body_buf`; stored here as
+    // the suffix length so we don't hold a self-referential slice.
     to_send_len: usize,
     headers_buf: [picohttp::Header; 128],
     body: Vec<u8>,
@@ -122,11 +141,8 @@ pub struct HTTPClient<const SSL: bool> {
     /// `us_ssl_ctx_t` built from `ssl_config` when it carries a custom CA.
     /// Heap-allocated because ownership transfers to the connected
     /// `WebSocket` after the upgrade completes (so the `SSL_CTX` outlives
-    /// this struct).
-    // TODO(port): Zig held a strong `SslCtxRef` (RAII over `SSL_CTX_up_ref`/
-    // `SSL_CTX_free`). No such wrapper exists in `bun_uws` yet; store the raw
-    // retained pointer and release in `clear_data`/Drop callers.
-    secure: Option<*mut SslCtx>,
+    /// this struct). RAII: dropping the wrapper releases the retained ref.
+    secure: Option<SslCtxOwned>,
 
     /// Expected Sec-WebSocket-Accept value for handshake validation per RFC 6455 §4.2.2.
     /// This is base64(SHA-1(Sec-WebSocket-Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")).
@@ -139,35 +155,19 @@ pub struct HTTPClient<const SSL: bool> {
     offered_permessage_deflate: bool,
 }
 
-// Handler set referenced by `dispatch.zig` (kind = `.ws_client_upgrade[_tls]`).
+// Handler set referenced by the dispatch table (kind = `.ws_client_upgrade[_tls]`).
 // The `register()` C++ round-trip that previously installed these on a
 // shared `us_socket_context_t` is gone — sockets are stamped with the
-// kind at connect time and routed here statically.
-//
-// TODO(port): expose these as a `uws::SocketHandlerSet` const for the dispatch
-// table; in Zig these were `pub const onOpen = handleOpen;` etc.
+// kind at connect time and routed via the `RawSocketEvents<SSL>` impl in
+// `bun_runtime::socket::uws_handlers`, which forwards to the `pub
+// handle_*` methods below.
 //
-// These take `*mut Self` (not `&mut Self`) because uSockets dispatches them
-// from the raw userdata pointer and several of them can free `Self` (via
+// The handlers take `*mut Self` (not `&mut Self`) because uSockets dispatches
+// them from the raw userdata pointer and several of them can free `Self` (via
 // `deref` reaching zero) or be re-entered synchronously by `tcp.close()` /
 // C++ callbacks. Holding a `&mut Self` function-argument across either of
 // those is UB under Stacked Borrows (argument protectors / aliased `&mut`).
 impl<const SSL: bool> HTTPClient<SSL> {
-    pub const ON_OPEN: unsafe fn(*mut Self, Socket<SSL>) = Self::handle_open;
-    pub const ON_CLOSE: unsafe fn(*mut Self, Socket<SSL>, c_int, *mut c_void) = Self::handle_close;
-    pub const ON_DATA: unsafe fn(*mut Self, Socket<SSL>, &[u8]) = Self::handle_data;
-    pub const ON_WRITABLE: unsafe fn(*mut Self, Socket<SSL>) = Self::handle_writable;
-    pub const ON_TIMEOUT: unsafe fn(*mut Self, Socket<SSL>) = Self::handle_timeout;
-    pub const ON_LONG_TIMEOUT: unsafe fn(*mut Self, Socket<SSL>) = Self::handle_timeout;
-    pub const ON_CONNECT_ERROR: unsafe fn(*mut Self, Socket<SSL>, c_int) =
-        Self::handle_connect_error;
-    pub const ON_END: unsafe fn(*mut Self, Socket<SSL>) = Self::handle_end;
-    pub const ON_HANDSHAKE: unsafe fn(*mut Self, Socket<SSL>, i32, uws::us_bun_verify_error_t) =
-        Self::handle_handshake;
-}
-
-impl<const SSL: bool> HTTPClient<SSL> {
-    /// Zig: `meta.typeName(T)` keeps the full path because the name contains `(`.
     const TYPE_NAME: &'static str = if SSL {
         "http.websocket_client.WebSocketUpgradeClient.NewHTTPUpgradeClient(true)"
     } else {
@@ -282,7 +282,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
         // Build proxy state if using proxy.
         // The CONNECT request is built using local variables for proxy_authorization and proxy_headers
         // which are freed immediately after building the request (not stored on the client).
-        // Ownership of `body` moves into the proxy (matching Zig); the CONNECT
+        // Ownership of `body` moves into the proxy; the CONNECT
         // request becomes the initial input_body_buf instead.
         let (proxy_state, input_body_buf): (Option<WebSocketProxy>, Vec<u8>) = if using_proxy {
             // Parse proxy authorization (temporary, freed after building CONNECT request)
@@ -332,7 +332,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
             let mut subprotocols = StringSet::new();
             let mut it = HeaderValueIterator::init(protocol_for_subprotocols);
             while let Some(protocol) = it.next() {
-                let _ = subprotocols.insert(protocol); // OOM-only Result (Zig: catch unreachable)
+                let _ = subprotocols.insert(protocol); // OOM-only Result
             }
             subprotocols
         };
@@ -360,7 +360,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
         // used only for pre-connect setup and MUST NOT span any
         // `Socket::connect_*_group` call below — those install `client` as
         // socket userdata and may synchronously dispatch
-        // `handle_connect_error(*mut Self)` (see .zig:1152), which would
+        // `handle_connect_error(*mut Self)`, which would
         // alias this borrow under Stacked Borrows. A fresh `&mut *client` is
         // re-derived after each connect call returns.
         let client_ref = unsafe { &mut *client };
@@ -391,7 +391,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
             using_proxy
         );
 
-        // PORT NOTE: reshaped for borrowck — `rare_data()` borrows `vm` mutably and
+        // Reshaped for borrowck — `rare_data()` borrows `vm` mutably and
         // `ws_upgrade_group` also wants a `vm` reference. See websocket_client.rs.
         let group = {
             // SAFETY: `rare_data()` returns `&mut RareData` reached through a
@@ -445,8 +445,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
                         };
                         // Owned ref; transferred to the connected WebSocket on
                         // upgrade, freed in `deinit` if we never get that far.
-                        client_ref.secure = Some(ctx);
-                        break 'brk client_ref.secure;
+                        client_ref.secure = Some(SslCtxOwned(ctx));
+                        break 'brk Some(ctx);
                     }
                 }
                 // SAFETY: `vm_ptr` is the live per-thread VM; JS thread.
@@ -591,14 +591,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
         }
         // ssl_config: Option<Box<SSLConfig>> — Drop runs SSLConfig::deinit + frees the box.
         self.ssl_config = None;
-        // secure: raw retained `SSL_CTX*` (no RAII wrapper yet — see field
-        // TODO(port)). Release the ref taken in `connect`.
-        if let Some(s) = self.secure.take() {
-            // SAFETY: `s` was returned by `create_ssl_client_context_for`
-            // (one owned ref) and has not been freed; SSL_CTX_free decrements
-            // BoringSSL's internal refcount.
-            unsafe { boringssl::c::SSL_CTX_free(s) };
-        }
+        // secure: Option<SslCtxOwned> — Drop releases the ref taken in `connect`.
+        self.secure = None;
     }
 
     /// # Safety
@@ -856,7 +850,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
     }
 
     pub fn is_same_socket(&self, socket: Socket<SSL>) -> bool {
-        // PORT NOTE: `InternalSocket` has no `PartialEq`; compare native handles.
+        // `InternalSocket` has no `PartialEq`; compare native handles.
         socket.get_native_handle() == self.tcp.get_native_handle()
     }
 
@@ -899,8 +893,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
             return;
         }
         // Bumps the intrusive refcount and derefs on Drop at every return path
-        // below (Zig: `self.ref(); defer self.deref();`). No `&`/`&mut Self` is
-        // live when the guard drops.
+        // below. No `&`/`&mut Self` is live when the guard drops.
         let _guard = this.ref_guard();
 
         debug_assert!(this.is_same_socket(socket));
@@ -973,9 +966,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
         };
 
         let bytes_read = usize::try_from(response.bytes_read).expect("int cast");
-        // PORT NOTE: reshaped for borrowck — copy remain_buf out before mutating self.
+        // Reshaped for borrowck — copy remain_buf out before mutating self.
         let remain_buf: Vec<u8> = body[bytes_read..].to_vec();
-        // PERF(port): was zero-copy slice into self.body.
         // SAFETY: `me`'s last use is the `body` slice above (now copied out);
         // no `&mut Self` spans this call.
         unsafe { Self::process_response(this.as_ptr(), response, &remain_buf) };
@@ -1052,9 +1044,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
         log!("Proxy tunnel established");
 
         let bytes_read = usize::try_from(response.bytes_read).expect("int cast");
-        // PORT NOTE: reshaped for borrowck — copy remain_buf before clearing self.body.
+        // Reshaped for borrowck — copy remain_buf before clearing self.body.
         let remain_buf: Vec<u8> = body[bytes_read..].to_vec();
-        // PERF(port): was zero-copy slice.
 
         // SAFETY: re-derive a fresh `&mut` after the `body` borrow above.
         let me = unsafe { &mut *this };
@@ -1161,7 +1152,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
             return;
         }
 
-        // PORT NOTE: reshaped for borrowck — re-borrow proxy after uses above.
+        // Reshaped for borrowck — re-borrow proxy after uses above.
         // SAFETY: re-derive a fresh `&mut`.
         let me = unsafe { &mut *this };
         let Some(p) = &mut me.proxy else {
@@ -1283,9 +1274,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
         };
 
         let bytes_read = usize::try_from(response.bytes_read).expect("int cast");
-        // PORT NOTE: reshaped for borrowck — copy remain_buf out before mutating self.
+        // Reshaped for borrowck — copy remain_buf out before mutating self.
         let remain_buf: Vec<u8> = body[bytes_read..].to_vec();
-        // PERF(port): was zero-copy slice.
         // SAFETY: `me`'s last use is the `body` slice above (now copied out);
         // no `&mut Self` spans this call.
         unsafe { Self::process_response(this, response, &remain_buf) };
@@ -1404,8 +1394,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
                                 let mut protocol_str = BunString::clone_latin1(protocol);
                                 CppWebSocket::opaque_ref(ws).set_protocol(&mut protocol_str);
                                 // `BunString` is `Copy`; explicitly drop the
-                                // ref taken by `clone_latin1` (Zig: `defer
-                                // protocol_str.deref()`).
+                                // ref taken by `clone_latin1`.
                                 protocol_str.deref();
                             }
                             true
@@ -1584,8 +1573,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
         let overflow_ptr: *mut u8 = if overflow_len > 0 {
             let mut v: Vec<u8> = Vec::new();
             if v.try_reserve_exact(overflow_len).is_err() {
-                // Spec .zig:1020 — OOM here terminates with `invalid_response`
-                // rather than aborting the process.
+                // OOM here terminates with `invalid_response` rather than
+                // aborting the process.
                 // SAFETY: no `&mut Self` is live across this call.
                 unsafe { Self::terminate(this, ErrorCode::InvalidResponse) };
                 return;
@@ -1693,8 +1682,9 @@ impl<const SSL: bool> HTTPClient<SSL> {
                         } else {
                             None
                         },
-                        // ownership transferred; suppress the drop above
-                        saved_secure.take().map(|p| &mut *p),
+                        // ownership transferred; `into_raw` suppresses the
+                        // RAII release at fn end.
+                        saved_secure.take().map(|s| &mut *s.into_raw()),
                     )
                 };
             } else {
@@ -1717,14 +1707,9 @@ impl<const SSL: bool> HTTPClient<SSL> {
             // No `&mut Self` spans this call (handle_close reenters).
             tcp.close(uws::CloseCode::Failure);
         }
-        // Zig: `defer if (saved_secure) |s| bun.BoringSSL.c.SSL_CTX_free(s);`
         // Any arm above that didn't transfer ownership to `did_connect` left
-        // the retained `SSL_CTX*` in `saved_secure`; release it now.
-        if let Some(s) = saved_secure {
-            // SAFETY: `s` is the owned ref taken out of `self.secure` above;
-            // not aliased after this point.
-            unsafe { boringssl::c::SSL_CTX_free(s) };
-        }
+        // the retained ref in `saved_secure`; RAII drop releases it now.
+        drop(saved_secure);
     }
 
     pub fn memory_cost(&self) -> usize {
@@ -1759,7 +1744,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
                     return;
                 }
                 // Bumps the intrusive refcount and derefs on Drop at every
-                // return path below (Zig: `self.ref(); defer self.deref();`).
+                // return path below.
                 let _guard = this.ref_guard();
                 // SAFETY: `p` holds a live ref on `tunnel`.
                 let wrote =
@@ -1785,7 +1770,7 @@ impl<const SSL: bool> HTTPClient<SSL> {
         }
 
         // Bumps the intrusive refcount and derefs on Drop at every return path
-        // below (Zig: `self.ref(); defer self.deref();`).
+        // below.
         let _guard = this.ref_guard();
 
         let wrote = socket.write(this.to_send());
@@ -1850,9 +1835,8 @@ impl<const SSL: bool> HTTPClient<SSL> {
 /// (no allocation) or allocates a UTF-8 copy. The resulting slices are stored
 /// here so build_request_body / build_connect_request can index them by &[u8].
 ///
-// PORT NOTE: reshaped for borrowck — Zig stored parallel `name_slices` /
-// `value_slices` arrays of `[]const u8` borrowing into `slices`. That is
-// self-referential in Rust; instead store only the `Utf8Slice` array (len =
+// Storing parallel `name_slices` / `value_slices` arrays borrowing into
+// `slices` would be self-referential; instead store only the `Utf8Slice` array (len =
 // 2*count, names at even indices, values at odd) and yield pairs via `iter()`.
 struct Headers8Bit<'a> {
     slices: Vec<Utf8Slice>,
@@ -1898,7 +1882,6 @@ impl<'a> Headers8Bit<'a> {
         let mut headers = Headers::default();
         for (name, value) in self.iter() {
             headers.append(name, value);
-            // PERF(port): Zig `try headers.append` — alloc errors abort in Rust.
         }
         headers
     }
@@ -2192,11 +2175,20 @@ fn compute_accept_value(key: &[u8]) -> [u8; 28] {
 
 // ──────────────────────────────────────────────────────────────────────────
 // extern "C" export shims for the generic `connect`/`cancel`/`memoryCost`.
-// Zig's `exportAll()` does `@export(&connect, .{ .name = ... })` per `ssl`.
 // Rust cannot `#[no_mangle]` a generic, so monomorphize both here.
-// TODO(port): full C-ABI parameter mapping for `connect` (Option<&T> niche,
-// Option<Box<T>> niche, raw `*const BunString` arrays). Verify against the
-// C++ caller in JSWebSocket.cpp / WebSocket.cpp.
+//
+// C-ABI mapping (verified against the declarations in
+// src/jsc/bindings/headers.h and the call sites in WebSocket.cpp):
+//   - non-null `const BunString*` params (host/path/protocols) → `&BunString`;
+//   - nullable `const BunString*` params (proxyHost/proxyAuthorization/
+//     targetAuthorization/unixSocketPath, passed as `nullptr` or `&local`)
+//     → `Option<&BunString>` (guaranteed null-pointer niche);
+//   - `BunString*` array + `size_t` count pairs → `*const BunString` + `usize`
+//     (count may be 0 with a dangling/null begin(); never dereferenced then);
+//   - `void* sslConfig` (ownership transferred, boxed by
+//     `Bun__WebSocket__parseSSLConfig`) → `Option<Box<SSLConfig>>`
+//     (null-pointer niche; Box matches the transferred ownership).
+// Keep these signatures in sync with headers.h if either side changes.
 // ──────────────────────────────────────────────────────────────────────────
 
 macro_rules! export_http_client {
@@ -2275,7 +2267,7 @@ macro_rules! export_http_client {
         };
     };
 }
-// PORT NOTE: `${concat(...)}` metavar-expr is unstable; hand-expand the two
+// `${concat(...)}` metavar-expr is unstable; hand-expand the two
 // instantiations by passing the pre-concatenated idents.
 
 export_http_client!(
@@ -2291,9 +2283,7 @@ export_http_client!(
     Bun__WebSocketHTTPSClient__memoryCost
 );
 
-/// Aliases for `WebSocketProxyTunnel` (matches Zig `HTTPClient` / `HTTPSClient`).
+/// Aliases for `WebSocketProxyTunnel`.
 pub type NewHttpUpgradeClient<const SSL: bool> = HTTPClient<SSL>;
 pub(crate) type HttpUpgradeClient = HTTPClient<false>;
 pub(crate) type HttpsUpgradeClient = HTTPClient<true>;
-
-// ported from: src/http_jsc/websocket_client/WebSocketUpgradeClient.zig
diff --git a/src/http_types/ETag.rs b/src/http_types/ETag.rs
index 24222cac362..2933c152f9d 100644
--- a/src/http_types/ETag.rs
+++ b/src/http_types/ETag.rs
@@ -1,6 +1,5 @@
 use bun_core::strings;
 
-// PORT NOTE: Zig anonymous return struct `{ tag: []const u8, is_weak: bool }`.
 // Borrows from the input slice; not a persistent heap struct.
 struct Parsed<'a> {
     tag: &'a [u8],
@@ -16,8 +15,8 @@ fn parse(tag_str: &[u8]) -> Parsed<'_> {
     if str.starts_with(b"W/") {
         is_weak = true;
         str = &str[2..];
-        // PORT NOTE: Zig `std.mem.trimLeft(u8, str, " \t")` — bun_string has no
-        // multi-char trim_left; inline it (trailing was already stripped above).
+        // bun_string has no multi-char trim_left; inline it (trailing
+        // whitespace was already stripped above).
         while let [b' ' | b'\t', rest @ ..] = str {
             str = rest;
         }
@@ -39,27 +38,24 @@ fn weak_match(tag1: &[u8], is_weak1: bool, tag2: &[u8], is_weak2: bool) -> bool
     tag1 == tag2
 }
 
-pub fn append_to_headers(bytes: &[u8], headers: &mut Headers) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
+pub fn append_to_headers(bytes: &[u8], headers: &mut Headers) {
     let hash: u64 = xxhash64(0, bytes);
 
     let mut etag_buf = [0u8; 40];
     let len = {
         use std::io::Write;
         let mut cursor = &mut etag_buf[..];
-        // Zig's `bun.fmt.hexIntLower(u64)` always emits exactly 16 hex chars
-        // (zero-padded). `{:x}` alone is variable-width.
+        // Always emit exactly 16 hex chars (zero-padded); `{:x}` alone is
+        // variable-width.
         write!(cursor, "\"{:016x}\"", hash).expect("unreachable");
         40 - cursor.len()
     };
     let etag_str = &etag_buf[..len];
     headers.append(b"etag", etag_str);
-    Ok(())
 }
 
 #[inline]
 fn xxhash64(seed: u64, bytes: &[u8]) -> u64 {
-    // Zig: `std.hash.XxHash64.hash(0, bytes)`.
     bun_core::hash::xxhash64(seed, bytes)
 }
 
@@ -94,7 +90,6 @@ pub fn if_none_match(
 
 // ═══════════════════════════════════════════════════════════════════════
 // Headers — moved from bun_http.
-// Source: src/http/Headers.zig
 //
 // Core struct + tier-safe methods only. The following stay in `bun_http`
 // (T5) as they pull in higher-tier or sibling deps that http_types (T3)
@@ -119,7 +114,6 @@ pub type HeaderEntryList = bun_collections::MultiArrayList<HeaderEntry>;
 
 /// Column accessors for `HeaderEntry` MultiArrayList storage.
 ///
-/// `header_entries.slice().items_name()` was a Zig MultiArrayList convenience.
 /// Returns a normal `&self`-tied borrow; `StringPointer` is `Copy` so callers
 /// that need to mutate `header_entries` afterwards copy the index out first.
 pub trait HeaderEntryColumns {
@@ -151,12 +145,11 @@ impl HeaderEntryColumns for HeaderEntryList {
 pub struct Headers {
     pub entries: HeaderEntryList,
     pub buf: Vec<u8>,
-    // PORT NOTE: Zig stored `std.mem.Allocator param`; non-AST crate →
-    // global mimalloc, field dropped (PORTING.md §allocators).
+    // No allocator field: non-AST crate → global mimalloc (PORTING.md §allocators).
 }
 
 impl Clone for Headers {
-    // PORT NOTE: Zig `!Headers`; only fallible calls were allocations — abort on OOM.
+    // The only fallible calls are allocations — abort on OOM.
     fn clone(&self) -> Headers {
         Headers {
             entries: self
@@ -185,7 +178,7 @@ impl Headers {
         None
     }
 
-    // PORT NOTE: was `!void`; only `try` sites were allocations — abort on OOM.
+    // The only fallible calls are allocations — abort on OOM.
     pub fn append(&mut self, name: &[u8], value: &[u8]) {
         let mut offset: u32 = u32::try_from(self.buf.len()).unwrap();
         self.buf.reserve(name.len() + value.len());
@@ -193,7 +186,6 @@ impl Headers {
             offset,
             length: u32::try_from(name.len()).unwrap(),
         };
-        // PERF(port): was appendSliceAssumeCapacity.
         self.buf.extend_from_slice(name);
         offset = u32::try_from(self.buf.len()).unwrap();
         self.buf.extend_from_slice(value);
@@ -210,8 +202,6 @@ impl Headers {
             .unwrap_or_else(|_| bun_alloc::out_of_memory());
     }
 
-    // PORT NOTE: Zig `deinit()` — handled by Drop on Vec/MultiArrayList.
-
     pub fn get_content_disposition(&self) -> Option<&[u8]> {
         self.get(b"content-disposition")
     }
@@ -232,9 +222,8 @@ impl Headers {
 }
 
 // ═══════════════════════════════════════════════════════════════════════
-// wtf::writeHTTPDate — moved from bun_jsc.
-// Source: src/jsc/WTF.zig (writeHTTPDate only — the rest of `wtf` is
-// string-builder/date-parse machinery that stays jsc-side).
+// wtf::writeHTTPDate — moved from bun_jsc (writeHTTPDate only — the rest of
+// `wtf` is string-builder/date-parse machinery that stays jsc-side).
 // ═══════════════════════════════════════════════════════════════════════
 
 pub mod wtf {
@@ -265,5 +254,3 @@ pub mod wtf {
         &buffer[..res as usize]
     }
 }
-
-// ported from: src/http_types/ETag.zig
diff --git a/src/http_types/Encoding.rs b/src/http_types/Encoding.rs
index 427e950cd04..9100bcc6f11 100644
--- a/src/http_types/Encoding.rs
+++ b/src/http_types/Encoding.rs
@@ -20,5 +20,3 @@ impl Encoding {
         )
     }
 }
-
-// ported from: src/http_types/Encoding.zig
diff --git a/src/http_types/FetchCacheMode.rs b/src/http_types/FetchCacheMode.rs
index b4433738819..a8d1fd3d9d5 100644
--- a/src/http_types/FetchCacheMode.rs
+++ b/src/http_types/FetchCacheMode.rs
@@ -1,5 +1,5 @@
 /// https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
-#[repr(u8)] // Zig: enum(u3) — Rust has no u3, u8 is the smallest repr
+#[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, strum::IntoStaticStr)]
 pub enum FetchCacheMode {
     #[strum(serialize = "default")]
@@ -25,8 +25,5 @@ impl FetchCacheMode {
         b"force-cache" => FetchCacheMode::ForceCache,
         b"only-if-cached" => FetchCacheMode::OnlyIfCached,
     };
-    // Zig `pub const toJS = @import("../http_jsc/fetch_enums_jsc.zig").fetchCacheModeToJS;`
-    // deleted — to_js lives as an extension-trait method in bun_http_jsc (see PORTING.md §Idiom map).
+    // to_js lives as an extension-trait method in bun_http_jsc (see PORTING.md §Idiom map).
 }
-
-// ported from: src/http_types/FetchCacheMode.zig
diff --git a/src/http_types/FetchRedirect.rs b/src/http_types/FetchRedirect.rs
index 8ab07d5aa00..6d4b7bcb08c 100644
--- a/src/http_types/FetchRedirect.rs
+++ b/src/http_types/FetchRedirect.rs
@@ -1,4 +1,4 @@
-#[repr(u8)] // Zig: enum(u2) — Rust has no u2, smallest repr is u8
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, strum::IntoStaticStr)]
 pub enum FetchRedirect {
     Follow,
@@ -6,7 +6,6 @@ pub enum FetchRedirect {
     Error,
 }
 
-// Zig: pub const Map = bun.ComptimeStringMap(FetchRedirect, .{...})
 // ≤8 entries — per PORTING.md a plain match is fine, but keep a phf::Map to
 // preserve the `FetchRedirect.Map.get(...)` call shape for external callers.
 pub static MAP: phf::Map<&'static [u8], FetchRedirect> = phf::phf_map! {
@@ -15,13 +14,11 @@ pub static MAP: phf::Map<&'static [u8], FetchRedirect> = phf::phf_map! {
     b"error"  => FetchRedirect::Error,
 };
 
-// Zig: pub const toJS = @import("../http_jsc/fetch_enums_jsc.zig").fetchRedirectToJS;
-// Deleted per PORTING.md — `to_js` is an extension-trait method living in
+// Per PORTING.md, `to_js` is an extension-trait method living in
 // `bun_http_jsc`; the base type carries no jsc reference.
 
 // ═══════════════════════════════════════════════════════════════════════
 // CommonAbortReason — moved from bun_jsc.
-// Source: src/jsc/CommonAbortReason.zig
 //
 // `enum(u8)` discriminant crosses the FFI boundary to
 // `WebCore__CommonAbortReason__toJS` and `WebCore__AbortSignal__signal`.
@@ -36,5 +33,3 @@ pub enum CommonAbortReason {
     UserAbort = 2,
     ConnectionClosed = 3,
 }
-
-// ported from: src/http_types/FetchRedirect.zig
diff --git a/src/http_types/FetchRequestMode.rs b/src/http_types/FetchRequestMode.rs
index fad58948f5e..55aae1300d5 100644
--- a/src/http_types/FetchRequestMode.rs
+++ b/src/http_types/FetchRequestMode.rs
@@ -1,5 +1,5 @@
 /// https://developer.mozilla.org/en-US/docs/Web/API/Request/mode
-#[repr(u8)] // Zig: enum(u2) — Rust has no u2; u8 is the smallest repr
+#[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum FetchRequestMode {
     SameOrigin,
@@ -15,9 +15,6 @@ impl FetchRequestMode {
         b"cors" => FetchRequestMode::Cors,
         b"navigate" => FetchRequestMode::Navigate,
     };
-    // `pub const toJS = @import("../http_jsc/fetch_enums_jsc.zig").fetchRequestModeToJS;`
-    // → deleted: `to_js` is provided as an extension-trait method in `bun_http_jsc`
-    //   (see PORTING.md §Idiom map, *_jsc alias rule).
+    // `to_js` is provided as an extension-trait method in `bun_http_jsc`
+    // (see PORTING.md §Idiom map, *_jsc alias rule).
 }
-
-// ported from: src/http_types/FetchRequestMode.zig
diff --git a/src/http_types/Method.rs b/src/http_types/Method.rs
index 9f02d2335c0..4ccba030493 100644
--- a/src/http_types/Method.rs
+++ b/src/http_types/Method.rs
@@ -14,7 +14,6 @@ pub enum Method {
     HEAD = 7,
     LINK = 8,
     LOCK = 9,
-    /// Zig: `@"M-SEARCH"`
     M_SEARCH = 10,
     MERGE = 11,
     MKACTIVITY = 12,
@@ -44,20 +43,13 @@ pub enum Method {
     UNSUBSCRIBE = 35,
 }
 
-// Zig: `pub const fromJS = Map.fromJS;` and `pub const toJS = @import("../http_jsc/method_jsc.zig").toJS;`
-// Deleted per PORTING.md — to_js/from_js live as extension-trait methods in the `bun_http_jsc` crate.
+// Per PORTING.md, to_js/from_js live as extension-trait methods in the `bun_http_jsc` crate.
 
 pub type Set = EnumSet<Method>;
 
-// PORT NOTE: Zig's private `with_body`/`with_request_body` EnumSet consts are
-// folded directly into `has_body()`/`has_request_body()` as `matches!` —
-// `EnumSet::remove` is not const on stable, and the consts were never read
-// outside those two predicates.
-
 impl Method {
-    /// Port of Zig `@tagName(method)` — uppercase HTTP method token. `M_SEARCH`
-    /// renders as `"M-SEARCH"` (the wire form, matching the Zig enum name
-    /// `@"M-SEARCH"`).
+    /// Uppercase HTTP method token. `M_SEARCH` renders as `"M-SEARCH"` (the
+    /// wire form).
     pub const fn as_str(self) -> &'static str {
         match self {
             Method::ACL => "ACL",
@@ -131,17 +123,15 @@ impl Method {
         Self::which(str)
     }
 
-    /// Port of Zig `bun.ComptimeStringMap(Method, …).get`: length-gated, then a
-    /// flat byte-pattern match on the entries of that exact length. Zig builds
-    /// the dispatch at `comptime`; the previous Rust port used a `phf::Map`,
+    /// Length-gated, then a flat byte-pattern match on the entries of that
+    /// exact length. The previous implementation used a `phf::Map`,
     /// which costs a SipHash13 round per lookup (`phf_shared::hash` ≈ 0.6 %
     /// self-time in a Bun.serve hello-world profile, called twice per request).
     /// The wire form is RFC 9110 case-sensitive uppercase, so the per-request
     /// hot path takes the upper arm; the all-lower entries exist only for
-    /// `new Request("get", …)` JS-side convenience and match the Zig table
-    /// exactly (mixed-case still rejects).
+    /// `new Request("get", …)` JS-side convenience (mixed-case still rejects).
     ///
-    /// `#[inline]`: the Zig `ComptimeStringMapWithKeyType` lookup is fully
+    /// `#[inline]`: this lookup should be fully
     /// inlined into `NodeHTTPResponse.createForJS` (no separate symbol in the
     /// release binary). Without the hint LLVM keeps this as a ~600-byte
     /// out-of-line call because the full match tree looks heavy, even though
@@ -266,8 +256,7 @@ impl Optional {
 /// `str` must point to `len` initialised bytes for the duration of the call.
 pub(crate) unsafe extern "C" fn Bun__HTTPMethod__from(str: *const u8, len: usize) -> i16 {
     // SAFETY: genuine FFI boundary — C++ caller passes a non-null, byte-aligned
-    // pointer to `len` initialised bytes (Zig signature `[*]const u8`, which is
-    // non-null by construction). The (ptr,len) pair cannot be a `&[u8]` across
+    // pointer to `len` initialised bytes. The (ptr,len) pair cannot be a `&[u8]` across
     // the C ABI, so `from_raw_parts` is irreducible here; the borrow does not
     // outlive this stack frame.
     let slice = unsafe { core::slice::from_raw_parts(str, len) };
@@ -277,11 +266,8 @@ pub(crate) unsafe extern "C" fn Bun__HTTPMethod__from(str: *const u8, len: usize
     method as i16
 }
 
-// Zig `comptime { _ = Bun__HTTPMethod__from; }` force-reference dropped — Rust links what's `pub`.
-
 // ═══════════════════════════════════════════════════════════════════════
 // HTTPHeaderName — moved from bun_runtime::webcore::FetchHeaders.
-// Source: src/jsc/FetchHeaders.zig
 //
 // `enum(u8)` discriminant crosses the FFI boundary to
 // `WebCore__FetchHeaders__put`/`fastHas`/`fastGet` — order MUST match
@@ -388,8 +374,6 @@ pub enum HeaderName {
     XXSSProtection,
 }
 
-// ported from: src/http_types/Method.zig
-
 #[cfg(test)]
 mod tests {
     use super::Method;
@@ -407,7 +391,7 @@ mod tests {
             let lower = upper.to_ascii_lowercase();
             assert_eq!(Method::which(lower.as_bytes()), Some(m), "lower {lower}");
         }
-        // Mixed case must reject (Zig table has only all-upper / all-lower).
+        // Mixed case must reject (only all-upper / all-lower are accepted).
         assert_eq!(Method::which(b"Get"), None);
         assert_eq!(Method::which(b"OPtions"), None);
         // Out-of-range lengths and unknown tokens.
diff --git a/src/http_types/MimeType.rs b/src/http_types/MimeType.rs
index 0d0434a56b6..24ce6013eb0 100644
--- a/src/http_types/MimeType.rs
+++ b/src/http_types/MimeType.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use bun_core::strings;
 
-// PORT NOTE (cyclebreak): `by_loader` needs `bun_ast::Loader`, but
+// Cyclebreak: `by_loader` needs `bun_ast::Loader`, but
 // adding that dep creates a cargo cycle
 // (http_types → options_types → zlib → io → uws_sys → http_types). The Loader
 // enum is `#[repr(u8)]` with stable discriminants (pinned by
@@ -21,16 +21,17 @@ mod loader_disc {
 // ───────────────────────────────────────────────────────────────────────────
 // `Table` (= generated `mime_type_list_enum::MimeTypeList`). The Rust side is a
 // hand-rolled stand-in (`&'static str` newtype) until
-// `src/codegen/generate-compact-string-table.ts` emits `.rs`. See PERF(port)
+// `src/codegen/generate-compact-string-table.ts` emits `.rs`. See the
 // note at the top of `mime_type_list_enum.rs`.
 // ───────────────────────────────────────────────────────────────────────────
 pub use super::mime_type_list_enum::MimeTypeList as Table;
 use bun_collections::StringHashMap;
 
-// PORT NOTE: `Table` variant names in Zig are raw MIME-type strings
-// (e.g. `@"application/json"`), which are not valid Rust identifiers.
-// `mime_type_list_enum.rs` exposes `const fn from_mime_literal(&'static str)`;
-// `t!("...")` resolves to the corresponding `Table` value at compile time.
+// `mime_type_list_enum.rs` exposes `const fn from_mime_literal(&'static str)`,
+// an UNCHECKED literal wrapper: a typo'd literal still compiles and simply
+// never matches anything at runtime (comparison is string equality, not an
+// enum compare). The checked, packed-enum form is pending the codegen `.rs`
+// backend — see the header of `mime_type_list_enum.rs`.
 macro_rules! t {
     ($s:literal) => {
         Table::from_mime_literal($s)
@@ -39,7 +40,6 @@ macro_rules! t {
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct MimeType {
-    // Zig `deinit` frees `value` via allocator → owning type per §Type-map.
     // `Cow` so the `pub const` items below stay `Borrowed` and const-constructible.
     pub value: Cow<'static, [u8]>,
     pub category: Category,
@@ -68,8 +68,8 @@ impl Compact {
             <&'static str>::from(self.value),
         );
 
-        // TODO(port): Zig matches on `Table` enum variants directly; we compare against
-        // `t!` placeholders because variant idents are not yet defined (see top-of-file note).
+        // `t!` wraps an unchecked `&'static str` literal and the compares are
+        // runtime string equality (see the macro definition above for the caveats).
         let v = self.value;
         if v == t!("application/webassembly") {
             return WASM;
@@ -115,7 +115,6 @@ impl Compact {
 pub fn create_hash_table() -> Result<Map, bun_alloc::AllocError> {
     let mut map = Map::default();
     map.reserve(Table::ALL.len() as u32 as usize);
-    // PERF(port): was put_assume_capacity_no_clobber + borrowed-key map — Rust
     // `StringHashMap` boxes the key.
     for entry in Table::ALL {
         assert!(
@@ -158,7 +157,6 @@ pub enum Category {
 
 impl Category {
     pub fn from_table(entry: Table) -> Category {
-        // TODO(port): see top-of-file note re: Table variant idents.
         if entry == t!("text/javascript")
             || entry == t!("application/javascript")
             || entry == t!("application/javascript; charset=utf-8")
@@ -338,8 +336,6 @@ impl MimeType {
     }
 
     pub fn init(str_: &[u8], dupe: bool, allocated: Option<&mut bool>) -> MimeType {
-        // PORT NOTE: Zig signature is `(str_, ?Allocator param, allocated: ?*bool)`.
-        // Allocator presence == "dupe the input"; replaced with `dupe: bool` (see §Allocators).
         let mut str = str_;
         if let Some(slash) = str.iter().position(|&b| b == b'/') {
             let category_ = &str[0..slash];
@@ -474,20 +470,16 @@ impl MimeType {
     }
 
     #[inline]
-    fn maybe_dupe(s: &[u8], dupe: bool) -> Cow<'static, [u8]> {
-        if dupe {
-            Cow::Owned(s.to_vec())
-        } else {
-            // TODO(port): Zig borrows the input slice here (zero-copy). A non-'static
-            // borrow would need a struct lifetime param — copying for now.
-            // PERF(port): was zero-copy borrow
-            Cow::Owned(s.to_vec())
-        }
+    fn maybe_dupe(s: &[u8], _dupe: bool) -> Cow<'static, [u8]> {
+        // Borrowing the input slice in the no-dupe case (zero-copy) would need
+        // a lifetime parameter on `MimeType`, so
+        // both cases copy here; never launder the borrow to 'static instead.
+        Cow::Owned(s.to_vec())
     }
 }
 
 // TODO: improve this
-// PORT NOTE (cyclebreak): takes the `#[repr(u8)]` discriminant of
+// Cyclebreak: takes the `#[repr(u8)]` discriminant of
 // `bun_ast::Loader` to avoid a same-tier cargo cycle (see
 // `loader_disc` at top of file). Callers: `by_loader(loader as u8, ext)`.
 pub fn by_loader(loader: u8, ext: &[u8]) -> MimeType {
@@ -513,15 +505,15 @@ pub fn by_extension_no_default(ext_without_leading_dot: &[u8]) -> Option<MimeTyp
 // this is partially auto-generated
 pub use super::mime_type_list_enum::ALL;
 
-// TODO: do a comptime static hash map for this
+// TODO: use a precomputed static hash map for this
 // its too many branches to use ComptimeStringMap
 pub fn by_name(name: &[u8]) -> MimeType {
     MimeType::init(name, false, None)
 }
 
-// PORT NOTE: phf_map! rejects duplicate keys at compile time. The Zig source
-// contained duplicate entries for "tsx", "yaml", "yml" (Zig ComptimeStringMap
-// silently kept the first occurrence) — later duplicates dropped below.
+// phf_map! rejects duplicate keys at compile time. The original table
+// contained duplicate entries for "tsx", "yaml", "yml" — only the first
+// occurrence is kept; later duplicates dropped below.
 pub(crate) static EXTENSIONS: phf::Map<&'static [u8], Table> = phf::phf_map! {
     b"123" => t!("application/vnd.lotus-1-2-3"),
     b"1km" => t!("application/vnd.1000minds.decision-model+xml"),
@@ -1492,7 +1484,7 @@ pub(crate) static EXTENSIONS: phf::Map<&'static [u8], Table> = phf::phf_map! {
     b"tsx" => t!("application/javascript"),
     b"tsd" => t!("application/timestamped-data"),
     b"tsv" => t!("text/tab-separated-values"),
-    // (dup "tsx" dropped — phf rejects, Zig kept first occurrence above)
+    // (dup "tsx" dropped — phf rejects; first occurrence above wins)
     b"ttc" => t!("font/collection"),
     b"ttf" => t!("font/ttf"),
     b"ttl" => t!("text/turtle"),
@@ -1692,10 +1684,10 @@ pub(crate) static EXTENSIONS: phf::Map<&'static [u8], Table> = phf::phf_map! {
     b"xwd" => t!("image/x-xwindowdump"),
     b"xyz" => t!("chemical/x-xyz"),
     b"xz" => t!("application/x-xz"),
-    // (dup "yaml" dropped — phf rejects, Zig kept first occurrence above)
+    // (dup "yaml" dropped — phf rejects; first occurrence above wins)
     b"yang" => t!("application/yang"),
     b"yin" => t!("application/yin+xml"),
-    // (dup "yml" dropped — phf rejects, Zig kept first occurrence above)
+    // (dup "yml" dropped — phf rejects; first occurrence above wins)
     b"ymp" => t!("text/x-suse-ymp"),
     b"z1" => t!("application/x-zmachine"),
     b"z2" => t!("application/x-zmachine"),
@@ -1729,7 +1721,6 @@ pub fn sniff(bytes: &[u8]) -> Option<MimeType> {
         return None;
     }
 
-    // PERF(port): was `inline for` over heterogeneous-length tuples
     for (header, table) in IMAGES_HEADERS {
         if bytes.len() >= header.len() && &bytes[0..header.len()] == *header {
             return Some(Compact::from(*table).to_mime_type());
@@ -1737,5 +1728,3 @@ pub fn sniff(bytes: &[u8]) -> Option<MimeType> {
     }
     None
 }
-
-// ported from: src/http_types/MimeType.zig
diff --git a/src/http_types/URLPath.rs b/src/http_types/URLPath.rs
index 9e377b8dea4..9669ef1cb1d 100644
--- a/src/http_types/URLPath.rs
+++ b/src/http_types/URLPath.rs
@@ -1,9 +1,9 @@
 use bun_core::strings;
 use bun_url::PercentEncoding;
 
-// TODO(port): lifetime — every `&'static [u8]` field below actually borrows from
+// TODO: lifetime — every `&'static [u8]` field below actually borrows from
 // either the `parse()` input slice or, when the input was percent-encoded, from
-// `_decoded_storage`. Zig has no lifetimes so this is implicit there. Add a
+// `_decoded_storage`. Add a
 // lifetime param to `URLPath` so the input-borrow case is checked.
 #[derive(Default)]
 pub struct URLPath {
@@ -19,7 +19,7 @@ pub struct URLPath {
     /// Owned backing storage for the slice fields when `parse()` had to
     /// percent-decode. Heap-stable: the slice fields above point into this
     /// allocation, which is never resized and lives exactly as long as `self`.
-    /// Replaces the Zig threadlocal scratch buffers — owning the decode buffer
+    /// Owning the decode buffer
     /// per-URLPath removes the use-after-free that a shared growable buffer
     /// would introduce on the next `parse()` call.
     ///
@@ -40,23 +40,19 @@ impl URLPath {
     }
 }
 
-// PORT NOTE: Zig uses two threadlocal fixed `[1024]u8`/`[16384]u8` buffers and
-// decodes in-place via `fixedBufferStream`, then returns slices into that
-// threadlocal storage. A growable shared buffer cannot uphold that contract in
-// Rust (the next `parse()` may reallocate it and dangle every prior URLPath),
+// Design note: a growable shared (e.g. threadlocal) decode buffer cannot work
+// here — the next `parse()` may reallocate it and dangle every prior URLPath —
 // so instead each URLPath that needs decoding owns its decode buffer in
 // `_decoded_storage`. This costs one small allocation only on the
 // percent-encoded path, which is the rare case.
-// PERF(port): was zero-alloc fixed buffers — profile if it shows up on a hot path.
 
-pub fn parse(possibly_encoded_pathname_: &[u8]) -> Result<URLPath, bun_core::Error> {
-    // TODO(port): narrow error set
+pub fn parse(possibly_encoded_pathname_: &[u8]) -> Result<URLPath, bun_url::DecodeError> {
     let mut decoded_pathname: &[u8] = possibly_encoded_pathname_;
     let mut decoded_storage: Option<Box<[u8]>> = None;
     let mut needs_redirect = false;
 
     if strings::index_of_char(decoded_pathname, b'%').is_some() {
-        // Zig caps the in-place buffer at 16384; preserve that bound on input.
+        // The in-place decode buffer is capped at 16384 bytes of input.
         let capped = &possibly_encoded_pathname_[..possibly_encoded_pathname_.len().min(16384)];
 
         let mut buf: Vec<u8> = Vec::with_capacity(capped.len());
@@ -156,7 +152,7 @@ pub fn parse(possibly_encoded_pathname_: &[u8]) -> Result<URLPath, bun_core::Err
         }
     }
 
-    // TODO(port): lifetime — see struct-level note. `extend` launders the borrow
+    // TODO: lifetime — see struct-level note. `extend` launders the borrow
     // to `'static` to match the field type; remove once URLPath gains a
     // proper lifetime parameter for the input-borrow case.
     #[inline(always)]
@@ -191,5 +187,3 @@ pub fn parse(possibly_encoded_pathname_: &[u8]) -> Result<URLPath, bun_core::Err
         _decoded_storage: decoded_storage,
     })
 }
-
-// ported from: src/http_types/URLPath.zig
diff --git a/src/http_types/h2.rs b/src/http_types/h2.rs
index 18ae4f984d9..47b3162f084 100644
--- a/src/http_types/h2.rs
+++ b/src/http_types/h2.rs
@@ -4,11 +4,6 @@
 //!   • `bun_runtime` (node:http2 bindings)   — `pub use`d into its
 //!     `h2_frame_parser` module, which layers `WireWriter`-based `write()`
 //!     and `to_js()` on top as local extension traits.
-//!
-//! The Zig tree carries TWO copies of these types (`src/http/H2FrameParser.zig`
-//! and a private duplicate inside `src/runtime/api/bun/h2_frame_parser.zig`);
-//! the http copy's own doc-comment already promised this dedup. This module is
-//! that promise kept on the Rust side.
 #![allow(non_camel_case_types, non_upper_case_globals)]
 
 // ─── connection / sizing constants ──────────────
@@ -17,18 +12,17 @@ pub const CLIENT_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
 
 pub const MAX_WINDOW_SIZE: u32 = i32::MAX as u32;
 pub const MAX_STREAM_ID: u32 = i32::MAX as u32;
-/// `std.math.maxInt(u24)`
+/// Maximum 24-bit value.
 pub const MAX_FRAME_SIZE: u32 = 0x00FF_FFFF;
 pub const DEFAULT_WINDOW_SIZE: u32 = u16::MAX as u32;
-/// PORT NOTE: Zig type was `u24`; Rust has no `u24`, so widened to `u32`.
 pub const DEFAULT_MAX_FRAME_SIZE: u32 = 16384;
 
 // ─── frame type / flags ─────────────────────────
 //
-// PORT NOTE: Zig `enum(u8) { …, _ }` is non-exhaustive (any u8 is a valid
-// value). A `#[repr(u8)]` Rust enum is UB for unknown discriminants received
-// off the wire, so callers dispatch on the raw `u8` (`FrameHeader.type_`) and
-// only ever use this enum for *outbound* frame construction (`X as u8`).
+// Frame types are non-exhaustive on the wire (any u8 is a valid value). A
+// `#[repr(u8)]` Rust enum is UB for unknown discriminants received off the
+// wire, so callers dispatch on the raw `u8` (`FrameHeader.type_`) and only
+// ever use this enum for *outbound* frame construction (`X as u8`).
 
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -80,7 +74,7 @@ pub enum SettingsFlags {
 
 // ─── error / setting codes ──────────────────────
 //
-// Non-exhaustive in Zig (`_` catch-all). Newtype-over-int instead of
+// Newtype-over-int instead of
 // `#[repr]` enums so any value off the wire is well-defined; consumers match
 // on `.0` or the associated consts.
 
@@ -128,14 +122,9 @@ pub fn u32_from_bytes(src: &[u8]) -> u32 {
     u32::from_be_bytes([src[0], src[1], src[2], src[3]])
 }
 
-/// Zig: `packed struct(u32) { reserved: bool = false, uint31: u31 = 0 }`.
-///
-/// PORT NOTE (intentional divergence): Zig's `toUInt32()` is `@bitCast` of
-/// `packed struct(u32){ reserved: bool, uint31: u31 }`, which on little-endian
-/// places `reserved` in bit 0 and yields `(uint31 << 1) | reserved`. That is a
-/// latent RFC 7540 §6.3 bug in Zig's deprecated PRIORITY path — the wire
-/// format wants the reserved/E bit at bit 31. We keep the RFC-compliant
-/// `(reserved << 31) | uint31` layout here, which already matches
+/// A 31-bit value with a reserved high bit. The RFC 7540 §6.3 wire format
+/// wants the reserved/E bit at bit 31, so the layout is the RFC-compliant
+/// `(reserved << 31) | uint31`, which matches
 /// `from_bytes`/`encode_into` and the on-wire `StreamPriority.stream_identifier`.
 #[repr(transparent)]
 #[derive(Copy, Clone, Default, PartialEq, Eq)]
@@ -177,10 +166,9 @@ impl UInt31WithReserved {
 // `StreamPriority`, `SettingsPayloadUnit` and `FullSettingsPayload` are
 // `#[repr(C, packed)]` with integer-only fields and therefore have no padding
 // bytes and no niches. They implement `bytemuck::Pod`, so the per-`from()`
-// byte-view that the Zig parser did via `@ptrCast` is the safe
-// `bytemuck::bytes_of_mut`.
+// byte-view is the safe `bytemuck::bytes_of_mut`.
 
-/// Zig: `packed struct(u40) { streamIdentifier: u32 = 0, weight: u8 = 0 }`.
+/// 5-byte PRIORITY payload: BE stream identifier + weight.
 #[repr(C, packed)]
 #[derive(Copy, Clone, Default)]
 pub struct StreamPriority {
@@ -200,8 +188,8 @@ impl StreamPriority {
     #[inline]
     pub fn from(dst: &mut StreamPriority, src: &[u8]) {
         bytemuck::bytes_of_mut(dst).copy_from_slice(src);
-        // std.mem.byteSwapAllFields(StreamPriority, dst) — `weight: u8` is a no-op.
-        // PORT NOTE: brace-expr `{packed.field}` performs an unaligned copy;
+        // Byte-swap each field; `weight: u8` is a no-op.
+        // Brace-expr `{packed.field}` performs an unaligned copy;
         // assignment to a packed field is an unaligned store. No `unsafe`.
         dst.stream_identifier = u32::swap_bytes(dst.stream_identifier);
     }
@@ -214,8 +202,6 @@ impl StreamPriority {
     }
 }
 
-/// Zig: `packed struct(u72) { length: u24, type: u8, flags: u8, streamIdentifier: u32 }`.
-///
 /// NOT `#[repr(packed)]` — the `u24` length is widened to a native `u32`
 /// in-memory; wire encoding is handled in `decode()`/`encode_into()` instead
 /// of by punning the struct bytes. Callers assemble the 9 raw wire bytes on
@@ -254,7 +240,7 @@ impl FrameHeader {
 
     #[inline]
     pub fn encode_into(&self, dst: &mut [u8; Self::BYTE_SIZE]) {
-        // std.mem.byteSwapAllFields on `packed struct(u72)` — emit BE manually.
+        // Emit the packed 9-byte frame header big-endian manually.
         dst[0] = ((self.length >> 16) & 0xFF) as u8;
         dst[1] = ((self.length >> 8) & 0xFF) as u8;
         dst[2] = (self.length & 0xFF) as u8;
@@ -264,7 +250,7 @@ impl FrameHeader {
     }
 }
 
-/// Zig: `packed struct(u48) { type: u16, value: u32 }`.
+/// 6-byte SETTINGS entry: BE u16 type + BE u32 value.
 #[repr(C, packed)]
 #[derive(Copy, Clone, Default)]
 pub struct SettingsPayloadUnit {
@@ -287,7 +273,7 @@ impl SettingsPayloadUnit {
         let bytes = bytemuck::bytes_of_mut(dst);
         bytes[offset..src.len() + offset].copy_from_slice(src);
         if END {
-            // std.mem.byteSwapAllFields(SettingsPayloadUnit, dst)
+            // Byte-swap each field.
             dst.type_ = u16::swap_bytes(dst.type_);
             dst.value = u32::swap_bytes(dst.value);
         }
@@ -300,7 +286,7 @@ impl SettingsPayloadUnit {
     }
 }
 
-/// Zig: `packed struct(u336)` — 7 × (`u16` type + `u32` value) = 42 bytes.
+/// 7 × (`u16` type + `u32` value) = 42 bytes.
 #[repr(C, packed)]
 #[derive(Copy, Clone)]
 pub(crate) struct FullSettingsPayload {
@@ -350,5 +336,3 @@ impl Default for FullSettingsPayload {
 impl FullSettingsPayload {
     pub(crate) const BYTE_SIZE: usize = 42;
 }
-
-// ported from: src/http/H2FrameParser.zig + src/runtime/api/bun/h2_frame_parser.zig (wire types)
diff --git a/src/http_types/lib.rs b/src/http_types/lib.rs
index e98d526372b..c55a0aab07c 100644
--- a/src/http_types/lib.rs
+++ b/src/http_types/lib.rs
@@ -12,17 +12,16 @@ pub mod mime_type_list_enum;
 pub use ETag::wtf;
 
 // `mime_type_list_enum::MimeTypeList` is a hand-generated `&'static str`
-// newtype (PERF(port) stand-in for the Zig packed-u14 table), so
+// newtype (PERF: stand-in for a packed-u14 table), so
 // `Table`/`Compact`/`EXTENSIONS`/`sniff`/`from_table`/`create_hash_table`/`ALL`
 // all compile. Only `by_loader` remains gated
 // (same-tier `bun_ast::Loader`, intra-tier edge avoided).
 pub mod MimeType;
 
-/// `std.fmt.parseInt(usize, value, 10) catch 0` — RFC 9110 Content-Length is
+/// RFC 9110 Content-Length is
 /// `1*DIGIT`, so any parse failure (empty / non-digit / overflow) maps to 0.
-/// Zig has no dedicated helper (http.zig:2800, server.zig:2442, etc. all inline
-/// the `catch 0`); this wrapper gives the Rust port ONE call shape across
-/// bun_http / bun_runtime::server / s3. Backed by the std.fmt.parseInt port.
+/// This wrapper gives ONE call shape across
+/// bun_http / bun_runtime::server / s3.
 #[inline]
 pub fn parse_content_length(value: &[u8]) -> usize {
     bun_core::parse_int::<usize>(value, 10).unwrap_or(0)
diff --git a/src/http_types/mime_type_list_enum.rs b/src/http_types/mime_type_list_enum.rs
index b3eae5ed6fb..ea5ecb1c833 100644
--- a/src/http_types/mime_type_list_enum.rs
+++ b/src/http_types/mime_type_list_enum.rs
@@ -1,24 +1,22 @@
 //! Generated from `mime_type_list.txt` (hand-rolled stand-in until
 //! `src/codegen/generate-compact-string-table.ts` learns `.rs` output).
 //!
-//! PERF(port): Zig emits a packed `enum(u14)` (length-group:7 + position:7)
-//! indexing into one contiguous byte blob - 2 bytes/entry. This stand-in
+//! PERF: a packed `enum(u14)` (length-group:7 + position:7)
+//! indexing into one contiguous byte blob would be 2 bytes/entry. This stand-in
 //! stores a `&'static str` per entry (16 bytes on 64-bit). Swap for the
 //! packed encoding when the codegen script grows a Rust backend.
 //
-// To regenerate: see `src/http_types/mime_type_list_enum.zig` header for the
-// canonical command; the `.rs` path is not wired into codegen yet.
+// The `.rs` path is not wired into codegen yet.
 
 /// Compact handle to one of the 2310 known MIME-type strings.
 ///
-/// Zig: `enum(u14)` with `@"<mime>"` variant idents. Rust idents cannot
+/// Rust idents cannot
 /// contain `/`, so we wrap the literal instead and compare by string.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct MimeTypeList(pub &'static str);
 
 impl MimeTypeList {
-    /// Const-construct from a MIME-type string literal. Mirrors
-    /// Zig `.@"<mime>"` variant syntax (used by the `t!` macro).
+    /// Const-construct from a MIME-type string literal (used by the `t!` macro).
     #[inline]
     pub const fn from_mime_literal(s: &'static str) -> Self {
         MimeTypeList(s)
diff --git a/src/ini/lib.rs b/src/ini/lib.rs
index 078753188a5..bbd76e39d2a 100644
--- a/src/ini/lib.rs
+++ b/src/ini/lib.rs
@@ -1,8 +1,9 @@
 #![warn(unused_must_use)]
 // ──────────────────────────────────────────────────────────────────────────
-// Pieces that transitively need the JS-AST (`Expr`/`E::Object`/`Rope`) or the
-// schema (`BunInstall`/`NpmRegistry`) are gated behind `// TODO(port):`
-// markers pointing at the missing lower-tier symbol.
+// The remaining `'static` lifetime erasures and raw-pointer borrow splits in
+// this file are documented at each site; removing them is tracked by the
+// bun_ini Parser lifetime-restructure work item (external arena, split `env`
+// lifetime, `Source` lifetime threading in bun_ast).
 // ──────────────────────────────────────────────────────────────────────────
 use core::fmt;
 
@@ -29,7 +30,7 @@ impl Default for Options {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Pure-byte helpers (lifted from `Parser` so they compile without the
-// Expr-carrying struct). The Zig has these as methods on `Parser` but they
+// Expr-carrying struct). They
 // touch no parser state — exposing them as free fns lets the logic stay
 // un-gated and unit-testable while the AST-dependent body is blocked.
 // ──────────────────────────────────────────────────────────────────────────
@@ -269,15 +270,14 @@ mod draft {
         pub env: &'a mut DotEnvLoader<'a>,
     }
 
-    // PORT NOTE: Zig `prepareStr` switches its *return type* on a comptime enum
-    // param (`.section -> *Rope`, `.key -> []const u8`, `.value -> Expr`). Rust
+    // The result type depends on the usage (`.section -> *Rope`, `.key ->
+    // bytes`, `.value -> Expr`). Rust
     // const generics cannot select a return type, so we keep a single
-    // `prepare_str::<USAGE>()` body for diffability and wrap the result in
+    // `prepare_str::<USAGE>()` body and wrap the result in
     // `PrepareResult`. Callers unwrap with `.into_*()`.
     //
-    // PORT NOTE: `#[derive(ConstParamTy)]` requires nightly `adt_const_params`.
+    // `#[derive(ConstParamTy)]` requires nightly `adt_const_params`.
     // Dropped to a runtime arg (the body never uses USAGE in a type position).
-    // PERF(port): was comptime monomorphization.
     #[derive(PartialEq, Eq, Clone, Copy)]
     enum Usage {
         Section,
@@ -299,7 +299,7 @@ mod draft {
 
     impl<'a> Parser<'a> {
         pub fn init(path: &[u8], src: &'a [u8], env: &'a mut DotEnvLoader<'a>) -> Parser<'a> {
-            // TODO(port): bun_ast::Source<'bump> — `Source::init_path_string`
+            // TODO: bun_ast::Source<'bump> — `Source::init_path_string`
             // currently takes `Str = &'static [u8]`; once the lower tier threads a
             // lifetime through `Source`, pass `path`/`src` directly. They outlive
             // the `Parser` and its `Source`/`Expr` tree (arena-freed in lockstep),
@@ -320,11 +320,11 @@ mod draft {
         // deinit -> Drop: `logger` and `arena` are owned and drop automatically.
 
         pub fn parse(&mut self, bump: &'a Arena) -> OOM<()> {
-            // TODO(port): borrowck — in Zig, `arena_allocator` is `self.arena.arena()`;
-            // here it is passed separately to avoid overlapping &mut self borrows.
+            // borrowck — `arena_allocator` is passed separately (rather than
+            // read off `self.arena`) to avoid overlapping &mut self borrows.
             let src = self.src;
             let mut iter = src.split(|&b| b == b'\n');
-            // TODO(port): borrowck — `head` aliases into `self.out.data.e_object` while
+            // TODO: borrowck — `head` aliases into `self.out.data.e_object` while
             // `self` is also borrowed mutably for prepare_str(). Kept as raw `*mut`
             // (the underlying `E::Object` lives in the Expr Store, not on `self`).
             let mut head: *mut E::Object = std::ptr::from_mut::<E::Object>(
@@ -334,10 +334,6 @@ mod draft {
                     .expect("Parser.out is E.Object"),
             );
 
-            // var duplicates = bun.StringArrayHashMapUnmanaged(u32){};
-            // defer duplicates.deinit(allocator);
-
-            // PERF(port): was stack-fallback (sizeOf(Rope)*6) over arena — using bump directly.
             let ropealloc = bump;
 
             let mut skip_until_next_section = false;
@@ -359,10 +355,9 @@ mod draft {
                     'treat_as_key: {
                         skip_until_next_section = false;
                         let Some(close_bracket_idx) = line.iter().position(|&b| b == b']') else {
-                            // Zig: `orelse continue` — skip the whole line
+                            // Skip the whole line: treat_as_key stays false and
+                            // we fall through to `continue` below.
                             break 'treat_as_key;
-                            // PORT NOTE: reshaped — Zig `continue` from inside labeled block;
-                            // we set treat_as_key=false and fall through to `continue` below.
                         };
                         // Make sure the rest is just whitespace
                         if close_bracket_idx + 1 < line.len() {
@@ -385,7 +380,6 @@ mod draft {
                                 offset,
                             )?
                             .into_section();
-                        // PERF(port): was `rope_stack.fixed_buffer_allocator.reset()` here.
                         // SAFETY: `self.out` was constructed as `E.Object` in `init()`.
                         let root = self
                             .out
@@ -563,7 +557,7 @@ mod draft {
             usage: Usage,
             bump: &'a Arena,
             ropealloc: &'a Arena,
-            val_: &[u8],
+            val_: &'a [u8],
             offset_: i32,
         ) -> OOM<PrepareResult<'a>> {
             let mut offset = offset_;
@@ -633,10 +627,9 @@ mod draft {
                     }
 
                     if usage == Usage::Value {
-                        // Spec ini.zig:247: `if (comptime usage == .value) return json_val;`
-                        // — the parsed Expr is returned as-is, preserving
+                        // The parsed Expr is returned as-is, preserving
                         // `E.Array`/`E.Object` tags so downstream `.e_array`/
-                        // `.e_object` checks (e.g. ini.zig:178/192, loadNpmrc
+                        // `.e_object` checks (e.g. loadNpmrc
                         // `ca`/`omit`/`include`) fire. `json_val` was lifted to T4
                         // at the parse site above.
                         return Ok(PrepareResult::Value(Expr {
@@ -664,7 +657,7 @@ mod draft {
                             return Ok(PrepareResult::Key(b"[Object object]"));
                         }
                         _ => {
-                            // PERF(port): was std.fmt.allocPrint into arena. Cold
+                            // Cold
                             // npm-quirk path (JSON array/number used as a section
                             // header or key); format to a temp `String` then copy
                             // into the arena.
@@ -684,7 +677,6 @@ mod draft {
                 // walk the val to find the first non-escaped comment character (; or #)
                 let mut did_any_escape = false;
                 let mut esc = false;
-                // PERF(port): was stack-fallback(STACK_BUF_SIZE) over arena
                 let mut unesc = ArenaVec::<u8>::with_capacity_in(STACK_BUF_SIZE, bump);
 
                 // RopeT is *Rope when usage==Section, else unit. In Rust we just
@@ -875,9 +867,9 @@ mod draft {
                 )));
             }
             if usage == Usage::Key {
-                // TODO(port): lifetime — `val` borrows `val_` (caller line slice);
-                // Zig returns it directly. Dupe into the bump for now.
-                return Ok(PrepareResult::Key(bump.alloc_slice_copy(val)));
+                // `val` is a subslice of `val_: &'a [u8]`; return the borrow
+                // directly.
+                return Ok(PrepareResult::Key(val));
             }
             Ok(PrepareResult::Section(Self::str_to_rope(ropealloc, val)?))
         }
@@ -889,11 +881,11 @@ mod draft {
         /// - ${VAR} - if VAR is undefined, leave as "${VAR}" (no expansion)
         /// - ${VAR?} - if VAR is undefined, expand to empty string
         /// - Backslash escaping is already handled by JSON parsing
-        fn expand_env_vars(&mut self, bump: &'a Arena, val: &[u8]) -> OOM<&'a [u8]> {
+        fn expand_env_vars(&mut self, bump: &'a Arena, val: &'a [u8]) -> OOM<&'a [u8]> {
             // Quick check if there are any env vars to expand
             if bun_core::index_of(val, b"${").is_none() {
-                // TODO(port): lifetime — Zig returns `val` directly (arena-borrowed).
-                return Ok(bump.alloc_slice_copy(val));
+                // Nothing to expand: return the borrow directly.
+                return Ok(val);
             }
 
             let mut result = ArenaVec::<u8>::with_capacity_in(val.len(), bump);
@@ -1167,9 +1159,8 @@ mod draft {
             if let Some(keyexpr) = prop.key {
                 if let Some(key) = keyexpr.as_utf8_string_literal() {
                     if bun_core::has_prefix(key, b"//") {
-                        // PORT NOTE: Zig builds this list at comptime by reversing
-                        // `std.meta.fieldNames(Item.Opt)` so that `_authToken` is
-                        // matched before `_auth`. We hard-code the reversed order.
+                        // Order matters: `_authToken` must be
+                        // matched before `_auth`.
                         const OPTNAMES: &[(&[u8], ConfigOpt)] = &[
                             (b"keyfile", ConfigOpt::Keyfile),
                             (b"certfile", ConfigOpt::Certfile),
@@ -1192,7 +1183,6 @@ mod draft {
                                 if let Some(value_expr) = prop.value {
                                     if let Some(value) = value_expr.as_utf8_string_literal() {
                                         return Some(IniOption::Some(ConfigItem {
-                                            // PERF(port): Zig borrowed arena slices here; we box.
                                             registry_url: Box::<[u8]>::from(url_part),
                                             value: Box::<[u8]>::from(value),
                                             optname: opt,
@@ -1255,7 +1245,6 @@ mod draft {
                                 return Ok(Some(IniOption::None));
                             };
                             return Ok(Some(IniOption::Some(ScopeItem {
-                                // PERF(port): Zig borrowed arena slice here; we box.
                                 scope: Box::<[u8]>::from(&key[1..key.len() - b":registry".len()]),
                                 registry,
                             })));
@@ -1337,7 +1326,7 @@ mod draft {
         source: &Source,
         configs: &mut Vec<ConfigItem>,
     ) -> OOM<()> {
-        // TODO(port): lifetime — `Parser<'a>` ties `src` and `env: &'a mut DotEnvLoader<'a>`
+        // TODO: lifetime — `Parser<'a>` ties `src` and `env: &'a mut DotEnvLoader<'a>`
         // to a single invariant `'a`; threading that through this fn signature poisons
         // the `load_npmrc_config` loop (env borrowed-for-'a across iterations). The
         // local `parser` is dropped before this fn returns, so erase both to a fresh
@@ -1350,7 +1339,7 @@ mod draft {
             &mut *std::ptr::from_mut::<DotEnvLoader<'_>>(env).cast::<DotEnvLoader<'static>>()
         };
         let mut parser = Parser::init(npmrc_path.as_bytes(), contents, env);
-        // TODO(port): borrowck — `parser.arena` is borrowed while `parser` is `&mut`.
+        // TODO: borrowck — `parser.arena` is borrowed while `parser` is `&mut`.
         // TODO(refactor): restructure Parser so the bump is passed externally or split borrows.
         let bump_ptr: *const Arena = &raw const parser.arena;
         // SAFETY: arena outlives all bump-allocated slices used below.
@@ -1563,10 +1552,9 @@ mod draft {
                 count
             };
 
-            // PORT NOTE: Zig's `defer install.scoped = registry_map;` is a shallow
-            // write-back at scope end while later code keeps mutating `registry_map`.
-            // Reshaped for borrowck: the single write-back happens at the bottom of
-            // `load_npmrc` after the registry-configuration block.
+            // The single `install.scoped = registry_map` write-back happens at
+            // the bottom of `load_npmrc` after the registry-configuration
+            // block has finished mutating `registry_map`.
             registry_map.scopes.ensure_unused_capacity(scope_count)?;
 
             iter.prop_idx = 0;
@@ -1600,9 +1588,9 @@ mod draft {
                 break 'out;
             }
 
-            // PORT NOTE: `URL<'a>` borrows its input. The Zig `default_registry_url`
-            // points into `install.default_registry.url` while the loop below
-            // mutates that same field; copy the two fields we compare against so
+            // `URL<'a>` borrows its input; a borrow of
+            // `install.default_registry.url` would conflict with the loop below
+            // mutating that same field. Copy the two fields we compare against so
             // the borrow ends before the `install.default_registry` mutation.
             let (default_registry_host, default_registry_pathname): (Box<[u8]>, Box<[u8]>) = 'brk: {
                 if let Some(dr) = &install.default_registry {
@@ -1630,7 +1618,7 @@ mod draft {
             // The line that sets the auth token should only apply to the @myorg scope
             // The line that sets the username would apply to both @myorg and @another
             let url_map = {
-                // PERF(port): was StringArrayHashMap<URL> on parser.arena. `URL<'a>`
+                // `URL<'a>`
                 // borrows `v.url` (inside `registry_map.scopes`), which would alias the
                 // `values_mut()` iteration below. Store the owned URL bytes instead and
                 // re-parse per lookup (URL::parse is a cheap slice scan).
@@ -1741,10 +1729,10 @@ mod draft {
                     }
                 }
 
-                // PORT NOTE: Zig iterated `registry_map.scopes` and looked up `url_map[k]`
-                // by key. In Rust `keys()`/`values_mut()` on the same map alias; since
+                // `keys()`/`values_mut()` on the same map alias; since
                 // `url_map` was filled in lockstep with `registry_map.scopes` (same
-                // ArrayHashMap insertion order), zip its values directly instead.
+                // ArrayHashMap insertion order), zip its values directly instead
+                // of looking each one up by key.
                 for (url_bytes, v) in url_map
                     .values()
                     .iter()
@@ -1800,9 +1788,10 @@ mod draft {
             drop(url_map);
         }
 
-        // TODO(port): Zig's `defer install.scoped = registry_map;` (in the scope-processing
-        // block) writes back the *final* registry_map after the registry-configuration block
-        // mutates it. Mirror that here.
+        // The single write-back happens here, after the registry-config loop
+        // has finished mutating the scope *values* in place. (An
+        // OOM `?` above leaves `install.scoped` as `None`, which is moot — install
+        // aborts on OOM.)
         install.scoped = Some(registry_map);
 
         Ok(())
@@ -1813,7 +1802,7 @@ mod draft {
         PnpmMatcher, create_matcher,
     };
 
-    /// Port of `PnpmMatcher.fromExpr` (src/install/PnpmMatcher.zig) operating on
+    /// `PnpmMatcher.fromExpr` operating on
     /// `bun_ast::Expr` instead of the lower-tier `bun_ast::Expr`.
     ///
     /// `bun_install_types` (T2) cannot depend on `bun_js_parser` (T4),
@@ -1993,5 +1982,3 @@ mod draft {
         Ok(())
     }
 } // mod draft
-
-// ported from: src/ini/ini.zig
diff --git a/src/install/ConfigVersion.rs b/src/install/ConfigVersion.rs
index 053e2844695..52d58e93ff6 100644
--- a/src/install/ConfigVersion.rs
+++ b/src/install/ConfigVersion.rs
@@ -1,4 +1,4 @@
-// PORT NOTE: the install crate's JSON layer routes through `bun_ast::js_ast`
+// The install crate's JSON layer routes through `bun_ast::js_ast`
 // (see `crate::bun_json`), not the full `bun_js_parser` AST. `from_expr` is
 // only ever fed nodes from the lockfile JSON parse, so type against that.
 use bun_ast::{Expr, ExprData};
@@ -50,5 +50,3 @@ impl ConfigVersion {
         }
     }
 }
-
-// ported from: src/install/ConfigVersion.zig
diff --git a/src/install/ExternalSlice.rs b/src/install/ExternalSlice.rs
index 118ffe64e89..1f0418e7d48 100644
--- a/src/install/ExternalSlice.rs
+++ b/src/install/ExternalSlice.rs
@@ -6,5 +6,3 @@
 pub use bun_install_types::resolver_hooks::{
     ExternalPackageNameHashList, ExternalSlice, ExternalStringList, ExternalStringMap, VersionSlice,
 };
-
-// ported from: src/install/ExternalSlice.zig
diff --git a/src/install/NetworkTask.rs b/src/install/NetworkTask.rs
index 26b2faff448..e89078efa2c 100644
--- a/src/install/NetworkTask.rs
+++ b/src/install/NetworkTask.rs
@@ -20,8 +20,7 @@ use crate::npm::{self as npm, PackageManifest};
 use crate::{ExtractTarball, PackageManager, PatchTask, TarballStream, Task};
 
 // Adapter so `StringOrTinyString::init_append_if_needed` can intern overflow
-// names into the resolver's filename arena (Zig: `*FileSystem.FilenameStore`,
-// fs.zig:77). The bun_sys-level `FilenameStore` exposes `append` /
+// names into the resolver's filename arena. The bun_sys-level `FilenameStore` exposes `append` /
 // `append_lower_case` but doesn't itself implement `strings::Appender` (that
 // impl lives in `bun_resolver`, which this crate can't reach without a cycle).
 pub struct FilenameStoreAppender<'a>(pub &'a FilenameStore);
@@ -34,9 +33,7 @@ impl strings::Appender for FilenameStoreAppender<'_> {
     }
 }
 
-/// Convenience: returns an `Appender` over the global filename store, matching
-/// Zig `*FileSystem.FilenameStore` callsites in `runTasks.zig` /
-/// `PackageManagerEnqueue.zig`.
+/// Convenience: returns an `Appender` over the global filename store.
 #[inline]
 pub(crate) fn filename_store_appender() -> FilenameStoreAppender<'static> {
     FilenameStoreAppender(FileSystem::instance().filename_store())
@@ -46,11 +43,10 @@ pub struct NetworkTask {
     // Self-referential: borrows `url_buf` / leaked header content owned by
     // sibling fields, so the lifetime is erased to `'static`.
     //
-    // PORT NOTE: `MaybeUninit` because the slot comes from `HiveArrayFallback`
+    // `MaybeUninit` because the slot comes from `HiveArrayFallback`
     // as *uninitialized* memory (often zero-page on first mmap, but not
     // guaranteed — `get()`'s heap fallback is `Box::new_uninit()`) and is
-    // overwritten by plain `=` in `for_manifest`/`for_tarball`. Zig has no
-    // destructors so the `= undefined` field was simply overwritten;
+    // overwritten by plain `=` in `for_manifest`/`for_tarball`.
     // `MaybeUninit<T>` is the spec-correct mapping for that semantic — unlike
     // `ManuallyDrop<T>`, it suppresses `T`'s validity invariant, so
     // materializing `&mut NetworkTask` after `write_init` (which leaves this
@@ -63,11 +59,11 @@ pub struct NetworkTask {
     pub unsafe_http_client: MaybeUninit<AsyncHTTP<'static>>,
     pub response: HTTPClientResult<'static>,
     pub task_id: crate::package_manager_task::Id,
-    // TODO(port): owned in `for_manifest` (toOwnedSlice) but borrowed from
-    // `tarball.url` in `for_tarball`; Zig leaks/aliases — verify ownership in Phase B.
+    // Owned in both `for_manifest` (toOwnedSlice) and `for_tarball`. Aliasing
+    // `tarball.url` in the latter would be a self-reference
+    // into `callback`; owning avoids that at the cost of one copy per tarball download.
     pub url_buf: Box<[u8]>,
     pub retried: u16,
-    // Zig: `std.mem.Allocator param` — dropped (global mimalloc); see §Allocators.
     pub request_buffer: MutableString,
     pub response_buffer: MutableString,
     // BACKREF: PackageManager owns this task via `preallocated_network_tasks`.
@@ -76,7 +72,7 @@ pub struct NetworkTask {
     pub package_manager: bun_ptr::ParentRef<PackageManager>,
     pub callback: Callback,
     /// Key in patchedDependencies in package.json
-    // PORT NOTE: `'static` because NetworkTask is stored lifetime-less in
+    // `'static` because NetworkTask is stored lifetime-less in
     // `PreallocatedNetworkTasks`; PatchTask's `'a` is a BACKREF on
     pub apply_patch_task: Option<Box<PatchTask>>,
     pub next: bun_threading::Link<NetworkTask>,
@@ -87,7 +83,7 @@ pub struct NetworkTask {
     pub tarball_stream: Option<Box<TarballStream>>,
     /// Extract `Task` pre-created on the main thread so the HTTP thread can
     /// schedule it on the worker pool as soon as the first body chunk arrives.
-    // PORT NOTE: `'static` matches `PreallocatedTaskStore =
+    // `'static` matches `PreallocatedTaskStore =
     // HiveArrayFallback<Task<'static>, 64>` which this slot is borrowed from
     // and returned to (`discard_unused_streaming_state`).
     pub streaming_extract_task: *mut Task<'static>,
@@ -96,7 +92,7 @@ pub struct NetworkTask {
     /// `async_network_task_queue` — the extract Task published by
     /// `TarballStream.finish()` owns the NetworkTask's lifetime instead
     /// (its `resolve_tasks` handler returns it to the pool). Also read by
-    /// the main-thread fallback / retry paths in `runTasks.zig` to assert
+    /// the main-thread fallback / retry paths in `run_tasks` to assert
     /// the stream was never started.
     pub streaming_committed: bool,
     /// Backing store for the streaming signal the HTTP client polls.
@@ -104,8 +100,7 @@ pub struct NetworkTask {
 }
 
 // SAFETY: `next` is the sole intrusive link and is only ever read/written via
-// these accessors by `UnboundedQueue<NetworkTask>`. Mirrors Zig's
-// `@field(item, "next")` over `bun.UnboundedQueue(NetworkTask, .next)`.
+// these accessors by `UnboundedQueue<NetworkTask>`.
 unsafe impl bun_threading::Linked for NetworkTask {
     #[inline]
     unsafe fn link(item: *mut Self) -> *const bun_threading::Link<Self> {
@@ -114,9 +109,9 @@ unsafe impl bun_threading::Linked for NetworkTask {
     }
 }
 
-/// Zig: `union(Task.Tag)` — tag type is `Task.Tag`.
-// TODO(port): ensure discriminants match `crate::task::Tag` ordering for any
-// code that transmutes between them.
+/// Variants mirror `crate::package_manager_task::Tag`
+/// in the same order. Nothing transmutes between the two (all consumers
+/// `match` on this enum), so the ordering is documentation, not an invariant.
 pub enum Callback {
     PackageManifest {
         loaded_manifest: Option<PackageManifest>,
@@ -133,11 +128,21 @@ pub enum Callback {
 pub struct DedupeMapEntry {
     pub is_required: bool,
 }
-// Zig: `std.HashMap(Task.Id, DedupeMapEntry, IdentityContext(Task.Id), 80)`
-// TODO(port): IdentityContext (hash = value bits) + 80% load factor — verify
-// `bun_collections::HashMap` exposes an identity hasher, or newtype `task::Id`
-// with a pass-through `Hash` impl.
-pub(crate) type DedupeMap = HashMap<crate::package_manager_task::Id, DedupeMapEntry>;
+/// `Id` is already a wyhash output, so identity hashing
+/// (hash = value bits) avoids re-hashing.
+impl bun_collections::IdentityHash for crate::package_manager_task::Id {
+    #[inline]
+    fn identity_hash(self) -> u64 {
+        self.get()
+    }
+}
+
+// `bun_collections::HashMap` uses the same 80% max load factor for all maps.
+pub(crate) type DedupeMap = HashMap<
+    crate::package_manager_task::Id,
+    DedupeMapEntry,
+    bun_collections::IdentityContext<crate::package_manager_task::Id>,
+>;
 
 impl NetworkTask {
     /// Access the HTTP client after `for_manifest`/`for_tarball` (or `notify`'s
@@ -177,7 +182,7 @@ impl NetworkTask {
         unsafe { self.package_manager.assume_mut() }
     }
 
-    // PORT NOTE: signature matches `HTTPClientResultCallback::new::<NetworkTask>`'s
+    // Signature matches `HTTPClientResultCallback::new::<NetworkTask>`'s
     // `fn(*mut T, *mut AsyncHTTP, HTTPClientResult<'_>)` shape so it can be
     // installed directly without a separate trampoline.
     fn notify(
@@ -213,7 +218,7 @@ impl NetworkTask {
             // status *and* the tarball is large enough to be worth the
             // overhead. For small bodies, or any 4xx/5xx / transport error,
             // fall back to the buffered path so the existing retry and
-            // error-reporting code in runTasks.zig keeps working.
+            // error-reporting code in `run_tasks` keeps working.
             let ok_status = stream.status_code >= 200 && stream.status_code <= 299;
             let big_enough = match result.body_size {
                 http::BodySize::ContentLength(len) => len >= TarballStream::min_size(),
@@ -239,8 +244,8 @@ impl NetworkTask {
                         this.streaming_committed = true;
                         // SAFETY: `stream` is the live heap-allocated
                         // `TarballStream` owned by this task. `on_chunk`
-                        // takes `*mut Self` (Zig: freely-aliasing
-                        // `*TarballStream`) because a worker may be inside
+                        // takes `*mut Self` (freely-aliasing) because a
+                        // worker may be inside
                         // `drain()` concurrently; coercing the `&mut` to a
                         // raw pointer here matches that contract.
                         unsafe { TarballStream::on_chunk(stream, chunk, false, None) };
@@ -259,8 +264,8 @@ impl NetworkTask {
                 // handles it.
                 if committed {
                     // SAFETY: see the `on_chunk` call above — `stream` is
-                    // live and `on_chunk` takes `*mut Self` to match Zig's
-                    // freely-aliasing `*TarballStream` contract.
+                    // live and `on_chunk` takes `*mut Self` per its
+                    // freely-aliasing contract.
                     unsafe { TarballStream::on_chunk(stream, chunk, true, result.fail) };
                     // Do NOT touch `this` — or anything it owns — after
                     // this point: `on_chunk(…, true, …)` sets `closed` and
@@ -284,7 +289,7 @@ impl NetworkTask {
             }
             // Fall through to the normal completion path for anything that
             // did not commit: the buffered extractor / retry logic in
-            // runTasks.zig handles it exactly as it would without
+            // `run_tasks` handles it exactly as it would without
             // streaming support.
         }
 
@@ -295,11 +300,11 @@ impl NetworkTask {
         // `wake_raw` path, mirroring `TarballStream::finish` /
         // `isolated_install::Installer::Task::callback`.
         let pm = this.package_manager.as_mut_ptr();
-        // Zig: `defer this.package_manager.wake();` — moved to end of fn (no
+        // The wake happens at the end of the fn (no
         // early returns past this point).
 
         // SAFETY: `real` is set by the HTTP thread before invoking the
-        // completion callback; Zig unwraps with `.?`.
+        // completion callback.
         unsafe {
             let real = async_http.real.expect("unreachable").as_ptr();
             ptr::write(real, ptr::read(async_http));
@@ -311,7 +316,7 @@ impl NetworkTask {
         // SAFETY: `result.body` (the only borrowed field) points at
         // `this.response_buffer`, which `this` owns and outlives the stored
         // `HTTPClientResult`; erase the callback-scoped `'_` to `'static` to
-        // match the field type (Zig stores it lifetime-less).
+        // match the field type.
         this.response = unsafe { result.detach_lifetime() };
         if this.response.metadata.is_none() {
             this.response.metadata = saved_metadata;
@@ -346,8 +351,7 @@ const DEFAULT_HEADERS_BUF: &str = concat!(
 const EXTENDED_HEADERS_BUF: &str = concat!("Accept", "application/json, */*");
 
 fn append_auth(header_builder: &mut HeaderBuilder, scope: &npm::registry::Scope) {
-    // PORT NOTE: Zig `appendFmt("Authorization", "Bearer {s}", .{scope.token})`
-    // writes raw bytes; routing through `format_args!`/`BStr` Display would be
+    // Routing through `format_args!`/`BStr` Display would be
     // lossy for non-UTF-8 tokens (U+FFFD expands 1→3 bytes) and overrun the
     // exact byte count reserved by `count_auth`. Use raw-byte append.
     if !scope.token.is_empty() {
@@ -411,7 +415,7 @@ impl NetworkTask {
     ) -> Result<(), ForManifestError> {
         let pm = self.pm_mut();
         // SAFETY: `pm.log` is the long-lived `*mut Log` the package manager
-        // was constructed with; Zig dereferences `this.package_manager.log`.
+        // was constructed with.
         let log = pm.log_mut();
 
         self.url_buf = 'blk: {
@@ -419,7 +423,6 @@ impl NetworkTask {
             // registry.npmjs.org supports both "@storybook%2Faddons" and "@storybook/addons"
             // Other registries like AWS codeartifact only support the former.
             // "npm" CLI requests the manifest with the encoded name.
-            // PERF(port): was ArenaAllocator + stackFallback(512) — profile in Phase B
             let encoded_name_storage;
             let encoded_name: &[u8] = if strings::index_of_char(name, b'/').is_some() {
                 encoded_name_storage = name.replace(b"/", b"%2f");
@@ -428,8 +431,8 @@ impl NetworkTask {
                 name
             };
 
-            // `OwnedString` derefs the WTF-backed result on scope exit (Zig:
-            // `defer tmp.deref()`, NetworkTask.zig:216) — covers both the
+            // `OwnedString` derefs the WTF-backed result on scope exit —
+            // covers both the
             // success path and the InvalidURL early returns below.
             let tmp = bun_core::OwnedString::new(bun_url::join(
                 &bun_core::String::borrow_utf8(scope.url.href()),
@@ -576,7 +579,7 @@ impl NetworkTask {
                 // SAFETY: lifetime extension — the appended slice points into
                 // `header_builder.content`'s heap buffer, which is moved into
                 // `self.unsafe_http_client.request_header_buf` below and
-                // outlives the request (Zig leaks it). Detach the borrow so
+                // outlives the request. Detach the borrow so
                 // `header_builder.content` can be read again for `headers_buf`.
                 last_modified = unsafe { bun_ptr::detach_lifetime(appended) };
             }
@@ -611,8 +614,7 @@ impl NetworkTask {
         // SAFETY: lifetime extension — `url_buf` and the header content buffer
         // are heap allocations owned by / leaked into `*self`, which outlives
         // the HTTP request. `AsyncHTTP::init` demands `'static` borrows
-        // because the HTTP thread reads them concurrently; the Zig source
-        // passes raw slices under the same ownership contract. See the
+        // because the HTTP thread reads them concurrently. See the
         // identical pattern in `s3/simple_request.rs`.
         let url = URL::parse(unsafe { bun_ptr::detach_lifetime(&self.url_buf) });
         let http_proxy = pm.http_proxy(&url);
@@ -621,14 +623,13 @@ impl NetworkTask {
         // HTTP client below (`ManuallyDrop`), so it genuinely outlives this frame.
         let headers_buf: &'static [u8] =
             unsafe { bun_ptr::detach_lifetime(header_builder.content.written_slice()) };
-        // PORT NOTE: Zig has no destructors — `header_builder.content` is
-        // intentionally leaked (ownership transfers to the HTTP client).
-        // Forget it so `StringBuilder::drop` doesn't free the buffer that
-        // `headers_buf` / `last_modified` now alias.
+        // `header_builder.content` is intentionally leaked (ownership
+        // transfers to the HTTP client). Forget it so
+        // `StringBuilder::drop` doesn't free the buffer that `headers_buf` /
+        // `last_modified` now alias.
         let _ = ManuallyDrop::new(core::mem::take(&mut header_builder.content));
         let completion_callback = self.get_completion_callback();
-        // TODO(port): narrow error set
-        // PORT NOTE: MaybeUninit overwrite — see field doc; old slot value is
+        // MaybeUninit overwrite — see field doc; old slot value is
         // either uninitialized (fresh hive slot) or a stale bitwise copy from
         // `notify`, neither of which is safe/meaningful to drop.
         self.unsafe_http_client = MaybeUninit::new(AsyncHTTP::init(
@@ -676,8 +677,7 @@ impl NetworkTask {
             // the leaked `header_builder.content` buffer (reassigned above) or
             // into the manifest's `string_buf`, which is the same allocation
             // referenced by the `PackageManifest` we just cloned into
-            // `self.callback`. Both outlive the HTTP request; Zig stores the
-            // raw slice under the same contract.
+            // `self.callback`. Both outlive the HTTP request.
             self.http_mut().client.if_modified_since =
                 unsafe { bun_ptr::detach_lifetime(last_modified) };
         }
@@ -686,9 +686,8 @@ impl NetworkTask {
     }
 
     pub fn get_completion_callback(&mut self) -> HTTPClientResultCallback {
-        // PORT NOTE: Zig `Callback.New(*NetworkTask, notify).init(this)` is a
-        // comptime type-erased thunk generator. `HTTPClientResultCallback::new`
-        // performs the same erasure over a `fn(*mut T, *mut AsyncHTTP, _)`.
+        // `HTTPClientResultCallback::new`
+        // performs type erasure over a `fn(*mut T, *mut AsyncHTTP, _)`.
         HTTPClientResultCallback::new::<NetworkTask>(self, Self::notify)
     }
 
@@ -746,8 +745,8 @@ impl NetworkTask {
                 pm.lockfile.buffers.string_bytes.as_slice(),
             )?)
         } else {
-            // TODO(port): Zig aliases `tarball.url` here without copying;
-            // `url_buf: Box<[u8]>` forces an allocation. Revisit ownership.
+            // Owning the copy (rather than aliasing `tarball.url`)
+            // avoids a self-reference into `callback` (see `url_buf` field doc).
             Box::<[u8]>::from(tarball_url)
         };
         self.callback = Callback::Extract(tarball_);
@@ -757,8 +756,7 @@ impl NetworkTask {
 
         if !(self.url_buf.starts_with(b"https://") || self.url_buf.starts_with(b"http://")) {
             // SAFETY: `pm.log` is the long-lived `*mut Log` the package
-            // manager was constructed with; Zig dereferences
-            // `this.package_manager.log`.
+            // manager was constructed with.
             pm.log_mut().add_error_fmt(
                 None,
                 bun_ast::Loc::EMPTY,
@@ -816,16 +814,15 @@ impl NetworkTask {
             header_buf =
                 unsafe { bun_ptr::detach_lifetime(header_builder.content.written_slice()) };
         }
-        // PORT NOTE: Zig has no destructors — `header_builder.content` is
-        // intentionally leaked (ownership transfers to the HTTP client).
-        // Forget it so `StringBuilder::drop` doesn't free the buffer that
-        // `header_buf` now aliases.
+        // `header_builder.content` is intentionally leaked (ownership
+        // transfers to the HTTP client). Forget it so
+        // `StringBuilder::drop` doesn't free the buffer that `header_buf` now
+        // aliases.
         let _ = ManuallyDrop::new(core::mem::take(&mut header_builder.content));
 
         // SAFETY: lifetime extension — `url_buf` is a heap allocation owned by
         // `*self`, which outlives the HTTP request. `AsyncHTTP::init` demands a
-        // `'static` borrow because the HTTP thread reads it concurrently; the
-        // Zig source passes a raw slice under the same ownership contract. See
+        // `'static` borrow because the HTTP thread reads it concurrently. See
         // the identical pattern in `for_manifest` above.
         let url = URL::parse(unsafe { bun_ptr::detach_lifetime(&self.url_buf) });
 
@@ -865,7 +862,7 @@ impl NetworkTask {
         }
 
         let completion_callback = self.get_completion_callback();
-        // PORT NOTE: MaybeUninit overwrite — see field doc; old slot value is
+        // MaybeUninit overwrite — see field doc; old slot value is
         // either uninitialized (fresh hive slot) or a stale bitwise copy from
         // `notify`, neither of which is safe/meaningful to drop.
         self.unsafe_http_client = MaybeUninit::new(AsyncHTTP::init(
@@ -922,9 +919,7 @@ impl NetworkTask {
         self.response = HTTPClientResult::default();
     }
 
-    /// Initialize a freshly-vended pool slot in place, mirroring Zig's
-    /// `network_task.* = .{ .task_id = …, .callback = undefined, .allocator = …,
-    /// .package_manager = …, .apply_patch_task = … }` — a full struct overwrite
+    /// Initialize a freshly-vended pool slot in place — a full struct overwrite
     /// that resets every other field to its struct default. The slot may be
     /// uninitialized heap memory (from `HiveArrayFallback::get()`'s
     /// `Box::new_uninit()` fallback) or stale (reused hive slot whose prior
@@ -932,7 +927,7 @@ impl NetworkTask {
     /// written via `addr_of_mut!().write()` without dropping the previous
     /// value — the slot is freshly poisoned/uninit from `get()`.
     ///
-    /// Fields that are `= undefined` in Zig (`unsafe_http_client`, `callback`,
+    /// Caller-initialized fields (`unsafe_http_client`, `callback`,
     /// `request_buffer`, `response_buffer`) are written here with drop-safe
     /// placeholders so subsequent `=` assignments in `for_manifest`/
     /// `for_tarball` do not drop uninitialized memory. `unsafe_http_client`
@@ -943,7 +938,7 @@ impl NetworkTask {
     /// # Safety
     /// `slot` must be the unique handle to a `HiveArrayFallback<NetworkTask>`
     /// slot returned by `get()`; its prior contents are treated as garbage
-    /// (matches Zig — no destructors run).
+    /// (no destructors run).
     pub unsafe fn write_init(
         slot: *mut NetworkTask,
         task_id: crate::package_manager_task::Id,
@@ -962,7 +957,7 @@ impl NetworkTask {
             addr_of_mut!((*slot).package_manager)
                 .write(bun_ptr::ParentRef::from_raw_mut(package_manager));
             addr_of_mut!((*slot).apply_patch_task).write(apply_patch_task);
-            // Struct-default fields (Zig: `= .{}` / `= 0` / `= null` / `= &[_]u8{}`).
+            // Struct-default fields.
             addr_of_mut!((*slot).response).write(HTTPClientResult::default());
             addr_of_mut!((*slot).url_buf).write(Box::default());
             addr_of_mut!((*slot).retried).write(0);
@@ -971,7 +966,7 @@ impl NetworkTask {
             addr_of_mut!((*slot).streaming_extract_task).write(ptr::null_mut());
             addr_of_mut!((*slot).streaming_committed).write(false);
             addr_of_mut!((*slot).signal_store).write(http::signals::Store::default());
-            // Zig-`undefined` fields: write drop-safe placeholders so the
+            // Caller-initialized fields: write drop-safe placeholders so the
             // plain `=` in `for_manifest`/`for_tarball` drops a valid value.
             // (`unsafe_http_client` is `MaybeUninit` — left uninitialized.)
             addr_of_mut!((*slot).request_buffer).write(MutableString::init_empty());
@@ -980,5 +975,3 @@ impl NetworkTask {
         }
     }
 }
-
-// ported from: src/install/NetworkTask.zig
diff --git a/src/install/PackageInstall.rs b/src/install/PackageInstall.rs
index e03ffc64510..1fae5ab34ac 100644
--- a/src/install/PackageInstall.rs
+++ b/src/install/PackageInstall.rs
@@ -20,10 +20,6 @@ use crate::{
     TruncatedPackageNameHash, bun_fs, bun_json, buntaghashbuf_make, initialize_store, resolution,
 };
 
-// TODO(port): `std.fs.Dir` is used pervasively here; Zig has a TODO to switch to `bun.FD.Dir`.
-// Mapped to `bun_sys::Dir` (an Fd-backed dir handle). Method names (.close(), .fd,
-// .makeOpenPath, .deleteTree, .realpath, .makeDirZ) are assumed on that type.
-
 bun_output::declare_scope!(install, hidden);
 
 pub struct PackageInstall<'a> {
@@ -32,12 +28,11 @@ pub struct PackageInstall<'a> {
     /// short-lived `Dir` held by the caller — `PackageInstall` never closes it.
     pub cache_dir: Fd,
     pub cache_dir_subpath: &'a ZStr,
-    // TODO(port): `destination_dir_subpath` aliases into `destination_dir_subpath_buf`;
+    // TODO: `destination_dir_subpath` aliases into `destination_dir_subpath_buf`;
     // borrowck will reject simultaneous &ZStr + &mut [u8]. Consider storing only the len.
     pub destination_dir_subpath: &'a ZStr,
     pub destination_dir_subpath_buf: &'a mut [u8],
 
-    // std.mem.Allocator param — deleted (global mimalloc)
     pub progress: Option<&'a mut Progress>,
 
     pub package_name: SemverString,
@@ -158,8 +153,7 @@ impl Method {
     pub(crate) fn is_supported(self) -> bool {
         #[cfg(target_os = "macos")]
         return Self::macos()[self];
-        // PORT NOTE: Zig `Environment.isLinux` (os.tag == .linux) includes the Android ABI,
-        // whereas Rust's `target_os = "linux"` does not — list `android` explicitly.
+        // Android is listed explicitly: `target_os = "linux"` does not cover the Android ABI.
         #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
         return Self::linux()[self];
         #[cfg(windows)]
@@ -260,9 +254,8 @@ pub(crate) static SUPPORTED_METHOD: AtomicU8 = AtomicU8::new(if cfg!(target_os =
 });
 
 impl PackageInstall<'_> {
-    /// Read accessor for the [`SUPPORTED_METHOD`] global (Zig:
-    /// `PackageInstall.supported_method`). Associated fn so cross-module
-    /// callers keep the `PackageInstall::supported_method()` call shape.
+    /// Read accessor for the [`SUPPORTED_METHOD`] global. Associated fn so
+    /// cross-module callers keep the `PackageInstall::supported_method()` call shape.
     #[inline]
     pub fn supported_method() -> Method {
         Method::from_u8(SUPPORTED_METHOD.load(Ordering::Relaxed))
@@ -280,11 +273,10 @@ impl PackageInstall<'_> {
 
 struct InstallDirState {
     cached_package_dir: Dir,
-    // PORT NOTE: `Walker` has no `Default`; Zig used `undefined`. Wrap in Option.
+    // `Walker` has no `Default`; wrap in Option.
     walker: Option<Walker>,
     subdir: Dir,
-    // PORT NOTE: Zig's `buf: bun.windows.WPathBuffer = undefined` is in-place
-    // (result-location, no zero-fill). A by-value `WPathBuffer` here would
+    // A by-value `WPathBuffer` here would
     // memset+move ~128 KB through `Default::default()` per package. Use the
     // thread-local pool guard (heap-backed, uninit) so construction is O(1)
     // and the struct stays small enough to return by value.
@@ -292,9 +284,8 @@ struct InstallDirState {
     buf: bun_paths::w_path_buffer_pool::Guard,
     #[cfg(windows)]
     buf2: bun_paths::w_path_buffer_pool::Guard,
-    // PORT NOTE: Zig kept `to_copy_buf: []u16` as a self-referential slice into
-    // `buf`. The Rust port only ever read its `.len()` to recover the offset, so
-    // store the offset directly — no self-referential raw fat pointer needed.
+    // Store the copy-target offset directly instead of a self-referential
+    // slice into `buf` — no self-referential raw fat pointer needed.
     #[cfg(windows)]
     to_copy_buf_off: usize, // offset into `buf` where the copy-target tail starts
     #[cfg(windows)]
@@ -324,9 +315,7 @@ impl Default for InstallDirState {
 
 // ───────────────────────────── helpers ─────────────────────────────
 
-/// Zig: `node_fs_for_package_installer().mkdirRecursiveOSPathImpl(void, {}, fullpath, 0, false)`.
-///
-/// Port of the NodeFS recursive-mkdir algorithm (node_fs.zig:4080) restricted to the
+/// Recursive mkdir following the NodeFS algorithm, restricted to the
 /// `Ctx == void, return_path = false` instantiation used here. The previous routing to
 /// `bun_sys::make_path_w` was wrong: that helper transcodes to UTF-8, strips the `\\?\`
 /// prefix and forward-iterates components via `mkdirat(Fd::cwd(), comp)`, so the first
@@ -338,7 +327,6 @@ impl Default for InstallDirState {
 fn mkdir_recursive_os_path(fullpath: &bun_core::WStr) -> sys::Maybe<()> {
     use sys::E;
     let path = fullpath.as_slice();
-    // u16 to mirror Zig's `@truncate(path.len)`.
     let len = path.len() as u16;
 
     // First, attempt to create the desired directory.
@@ -359,9 +347,7 @@ fn mkdir_recursive_os_path(fullpath: &bun_core::WStr) -> sys::Maybe<()> {
         },
     }
 
-    // Zig routes through `node_fs_for_package_installer()`, whose `working_mem`
-    // is `&this.sync_error_buf` — a buffer in the threadlocal NodeFS struct,
-    // not stack. Use the thread-local WPathBuffer pool so we don't add 64 KB
+    // Use the thread-local WPathBuffer pool so we don't add 64 KB
     // of stack on ThreadPool worker threads (HardLinkWindowsInstallTask::run).
     let mut working_mem = bun_paths::w_path_buffer_pool::get();
     working_mem[..usize::from(len)].copy_from_slice(path);
@@ -382,7 +368,7 @@ fn mkdir_recursive_os_path(fullpath: &bun_core::WStr) -> sys::Maybe<()> {
                 Err(err) => {
                     match err.get_errno() {
                         E::EEXIST => {
-                            // node_fs.zig:4159-4172 — on Windows, if the existing
+                            // On Windows, if the existing
                             // entry is a *file*, bail with ENOTDIR instead of
                             // forward-walking under it. `parent` is still
                             // NUL-terminated (separator not yet restored).
@@ -422,7 +408,7 @@ fn mkdir_recursive_os_path(fullpath: &bun_core::WStr) -> sys::Maybe<()> {
         i += 1;
     }
 
-    // Final component (no trailing sep case — Zig's `first_match + 1 != len` check).
+    // Final component (no trailing sep case).
     working_mem[usize::from(len)] = 0;
     let leaf = bun_core::WStr::from_buf(&working_mem[..], usize::from(len));
     match sys::mkdir_w(leaf) {
@@ -434,7 +420,7 @@ fn mkdir_recursive_os_path(fullpath: &bun_core::WStr) -> sys::Maybe<()> {
     }
 }
 
-/// Zig: `bun.openDir(dir, subpath)` — open a directory handle relative to `dir`.
+/// Open a directory handle relative to `dir`.
 #[inline]
 fn open_dir(dir: Fd, subpath: &ZStr) -> Result<Dir, bun_core::Error> {
     sys::open_dir_at(dir, subpath.as_bytes())
@@ -442,7 +428,7 @@ fn open_dir(dir: Fd, subpath: &ZStr) -> Result<Dir, bun_core::Error> {
         .map_err(Into::into)
 }
 
-/// Zig: `bun.openDirA(dir, subpath)` — non-Z-terminated variant.
+/// Non-Z-terminated variant of [`open_dir`].
 #[inline]
 fn open_dir_a(dir: Fd, subpath: &[u8]) -> Result<Dir, bun_core::Error> {
     sys::open_dir_at(dir, subpath)
@@ -451,9 +437,8 @@ fn open_dir_a(dir: Fd, subpath: &[u8]) -> Result<Dir, bun_core::Error> {
 }
 
 // macOS clonefileat(2) — routed through the safe `sys::clonefileat` wrapper
-// (takes `Fd`/`&ZStr`, returns `Maybe<()>`). The Zig source matched on the raw
-// `int` return + thread-local errno; the wrapper preserves the errno via
-// `Error::get_errno()`, so the per-errno branching below is unchanged.
+// (takes `Fd`/`&ZStr`, returns `Maybe<()>`). The wrapper preserves the errno
+// via `Error::get_errno()` for the per-errno branching below.
 
 // ───────────────────────────── NewTaskQueue ─────────────────────────────
 
@@ -542,8 +527,7 @@ impl HardLinkWindowsInstallTask {
         // whose internal Release/Acquire on the task queue is what publishes the
         // first-call `MaybeUninit::write` below.
         //
-        // PORT NOTE: Zig re-assigns the whole struct each call (`queue = Queue{...}`).
-        // We must NOT do that: even though `copy()` always reaches `queue.wait()`
+        // We must NOT re-assign the whole struct each call: even though `copy()` always reaches `queue.wait()`
         // before returning (see the loop_err handling there), `WaitGroup::wait()` can
         // return while the last worker is still inside `WaitGroup::finish()` *after*
         // its `fetch_sub` — touching `mutex`/`cond` for the lock-unlock-signal dance.
@@ -614,8 +598,8 @@ impl HardLinkWindowsInstallTask {
             // SAFETY: self_ was heap-allocated in init(); reclaim ownership now.
             let boxed = unsafe { bun_core::heap::take(self_) };
             // First-write-wins: keep only the first error. Any later failing task
-            // simply drops its Box here (the Zig original leaks the loser; in Rust
-            // that would also leak the inner `Box<[u16]>` per failed file).
+            // simply drops its Box here (leaking it would also leak the inner
+            // `Box<[u16]>` per failed file).
             let mut slot = queue.errored_task.lock();
             if slot.is_none() {
                 *slot = Some(boxed);
@@ -706,9 +690,8 @@ impl UninstallTask {
         // SAFETY: task points to the `task` field of an UninstallTask.
         let uninstall_task: *mut Self = unsafe { bun_core::from_field_ptr!(Self, task, task) };
 
-        // PORT NOTE: declared *before* the Box is reclaimed so it drops *after* the
-        // Box — Rust drops locals in reverse declaration order. Zig's `defer task.deinit()`
-        // runs before `defer { decrementPendingTasks(); wake() }`, i.e. the task is freed
+        // declared *before* the Box is reclaimed so it drops *after* the
+        // Box — Rust drops locals in reverse declaration order. The task must be freed
         // before the main thread can observe pending_tasks==0.
         scopeguard::defer! {
             let pm = crate::package_manager::get();
@@ -814,7 +797,7 @@ impl<'a> PackageInstall<'a> {
     fn verify_git_resolution(&mut self, repo: &Repository, root_node_modules_dir: &Dir) -> bool {
         let dest_len = self.destination_dir_subpath.len();
         let suffix: &[u8] = &[SEP, b'.', b'b', b'u', b'n', b'-', b't', b'a', b'g'];
-        // PORT NOTE: reshaped for borrowck — write into buf via raw indices.
+        // Reshaped for borrowck — write into buf via raw indices.
         self.destination_dir_subpath_buf[dest_len..dest_len + suffix.len()].copy_from_slice(suffix);
         self.destination_dir_subpath_buf[dest_len + SEP_STR.len() + b".bun-tag".len()] = 0;
         // SAFETY: NUL written above.
@@ -830,7 +813,6 @@ impl<'a> PackageInstall<'a> {
             // dest_len < buf capacity (was the prior NUL position).
             move |p| unsafe { *p.add(dest_len) = 0 },
         );
-        // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
 
         let Ok(bun_tag_file) = self
             .node_modules
@@ -895,8 +877,7 @@ impl<'a> PackageInstall<'a> {
         mutable.expand_to_capacity();
 
         let dest_len = self.destination_dir_subpath.len();
-        // Zig: `bun.copy(u8, buf[len..], sep_str ++ "package.json")` — write the
-        // literal directly into the path buffer; no intermediate Vec.
+        // Write the literal directly into the path buffer; no intermediate Vec.
         let suffix: &[u8] = &[
             SEP, b'p', b'a', b'c', b'k', b'a', b'g', b'e', b'.', b'j', b's', b'o', b'n',
         ];
@@ -934,7 +915,7 @@ impl<'a> PackageInstall<'a> {
             total += read;
 
             mutable.expand_to_capacity();
-            // PORT NOTE: reshaped for borrowck — recompute remain after grow.
+            // Reshaped for borrowck — recompute remain after grow.
             remain = &mut mutable.list[total..];
 
             if remain.len() < 1024 {
@@ -972,8 +953,6 @@ impl<'a> PackageInstall<'a> {
         root_node_modules_dir: &Dir,
         resolution_tag: resolution::Tag,
     ) -> bool {
-        // Zig: `var body_pool = BodyPool.get(); var mutable = body_pool.data;
-        //        defer { body_pool.data = mutable; BodyPool.release(body_pool); }`
         let mut body_pool = Npm::Registry::BodyPool::get();
         let mutable: &mut MutableString = &mut body_pool;
 
@@ -993,11 +972,10 @@ impl<'a> PackageInstall<'a> {
 
         initialize_store();
 
-        // PORT NOTE: Zig passed `allocator` (= `bun.default_allocator`, the global
-        // mimalloc heap). `Arena::new()` here was creating + destroying a fresh
+        // `Arena::new()` here was creating + destroying a fresh
         // `mi_heap` per package — measurable on no-op installs (~390× heap churn
         // on create-next/elysia). `borrowing_default()` wraps `mi_heap_main()`
-        // with a no-op Drop, matching the Zig semantics exactly. The lexer
+        // with a no-op Drop. The lexer
         // scratch frees its own buffers on `Lexer::deinit()` via the checker's
         // Drop, so nothing leaks.
         let bump = bun_alloc::Arena::borrowing_default();
@@ -1009,7 +987,7 @@ impl<'a> PackageInstall<'a> {
         if package_json_checker.parse_expr().is_err() {
             return false;
         }
-        // PORT NOTE: reshaped for borrowck — `log` is exclusively borrowed by the
+        // Reshaped for borrowck — `log` is exclusively borrowed by the
         // checker's lexer; route the read through `lexer.log_mut()` (single
         // provenance chain, see PackageJSONVersionChecker doc).
         if package_json_checker.lexer.log_mut().errors > 0 || !package_json_checker.has_found_name {
@@ -1080,7 +1058,6 @@ impl<'a> PackageInstall<'a> {
         walker_.resolve_unknown_entry_types = true;
 
         fn copy(destination_dir_: &Dir, walker: &mut Walker) -> Result<u32, bun_core::Error> {
-            // TODO(port): narrow error set
             let mut real_file_count: u32 = 0;
             let mut stackpath = [0u8; path::MAX_PATH_BYTES];
             while let Some(entry) = walker.next()? {
@@ -1212,7 +1189,7 @@ impl<'a> PackageInstall<'a> {
             Err(err) => return InstallResult::fail(err, Step::OpeningCacheDir, None),
         };
 
-        // PORT NOTE: `bun.OSPathLiteral("node_modules")` — u8 on posix / u16 on windows.
+        // `bun.OSPathLiteral("node_modules")` — u8 on posix / u16 on windows.
         #[cfg(windows)]
         const NODE_MODULES_LIT: &OSPathSlice = &[
             b'n' as u16,
@@ -1260,10 +1237,8 @@ impl<'a> PackageInstall<'a> {
             ) {
                 Ok(d) => d,
                 Err(err) => {
-                    // PORT NOTE: Zig closed cached_package_dir/walker explicitly here because the
-                    // caller's `defer state.deinit()` is placed AFTER the `is_fail()` early-return.
-                    // In Rust, Drop on the caller's `state` runs unconditionally on that early
-                    // return, so explicit close here would double-close. Drop handles it.
+                    // Drop on the caller's `state` runs unconditionally on this early
+                    // return, so an explicit close here would double-close. Drop handles it.
                     return InstallResult::fail(err, Step::OpeningDestDir, None);
                 }
             };
@@ -1293,7 +1268,7 @@ impl<'a> PackageInstall<'a> {
                 } else {
                     bun_core::err!("NameTooLong")
                 };
-                // PORT NOTE: Drop on caller's `state` closes cached_package_dir; explicit close
+                // Drop on caller's `state` closes cached_package_dir; explicit close
                 // here would double-close (see posix branch above for full rationale).
                 return InstallResult::fail(err, Step::OpeningDestDir, None);
             }
@@ -1332,12 +1307,11 @@ impl<'a> PackageInstall<'a> {
                 } else {
                     bun_core::err!("NameTooLong")
                 };
-                // PORT NOTE: Drop on caller's `state` closes cached_package_dir; explicit close
+                // Drop on caller's `state` closes cached_package_dir; explicit close
                 // here would double-close (see posix branch above for full rationale).
                 return InstallResult::fail(err, Step::CopyingFiles, None);
             }
-            // PORT NOTE: borrowck — Zig held `cache_path = buf2[0..len]` while mutating
-            // buf2; index by `cache_path_length` directly so no shared borrow is live.
+            // borrowck — index by `cache_path_length` directly so no shared borrow is live.
             state.to_copy_buf2_off = if state.buf2[cache_path_length - 1] != u16::from(b'\\') {
                 state.buf2[cache_path_length] = u16::from(b'\\');
                 cache_path_length + 1
@@ -1364,10 +1338,10 @@ impl<'a> PackageInstall<'a> {
         #[cfg(not(windows))]
         type WinOffset = ();
 
-        // PORT NOTE: reshaped for borrowck — Zig passed two overlapping slices into the
-        // same buffer (`head` is the whole buffer, `to_copy_into` is its tail). Creating
-        // two live `&mut [u16]` that alias is UB in Rust, so pass head buffer + tail
-        // offset and reslice inside.
+        // Two overlapping slices into the same buffer (`head` is the whole
+        // buffer, `to_copy_into` is its tail) would be two live aliasing
+        // `&mut [u16]`, which is UB — pass head buffer + tail offset and
+        // reslice inside.
         fn copy(
             destination_dir_: &Dir,
             walker: &mut Walker,
@@ -1377,7 +1351,6 @@ impl<'a> PackageInstall<'a> {
             to_copy_into2_offset: WinOffset,
             head2: WinSlice<'_>,
         ) -> Result<u32, bun_core::Error> {
-            // TODO(port): narrow error set
             #[cfg(not(windows))]
             let mut real_file_count: u32 = 0;
             #[cfg(windows)]
@@ -1494,8 +1467,7 @@ impl<'a> PackageInstall<'a> {
                         destination_dir_.fd(),
                         bstr::BStr::new(entry.path.as_bytes())
                     );
-                    // Zig: `std.fs.Dir.createFile(dir, path, .{})` — open O_WRONLY|O_CREAT|O_TRUNC,
-                    // mode = std.fs.File.default_mode (0o666).
+                    // Open O_WRONLY|O_CREAT|O_TRUNC, mode 0o666.
                     let create = |path: &ZStr| {
                         sys::openat(
                             destination_dir_.fd(),
@@ -1546,7 +1518,7 @@ impl<'a> PackageInstall<'a> {
                         };
                         // `sys::fchmod` is the safe by-value-fd wrapper (kernel
                         // validates the fd; no memory-safety preconditions).
-                        // Result intentionally ignored to match Zig's `_ = c.fchmod(...)`.
+                        // Result intentionally ignored.
                         let _ = sys::fchmod(outfile, stat.st_mode as bun_sys::Mode);
                     }
 
@@ -1620,10 +1592,10 @@ impl<'a> PackageInstall<'a> {
         #[cfg(not(windows))]
         type WinOffset = ();
 
-        // PORT NOTE: reshaped for borrowck — Zig passed two overlapping slices into the
-        // same buffer (`head` is the whole buffer, `to_copy_into` is its tail). Creating
-        // two live `&mut [u16]` that alias is UB in Rust, so pass head buffer + tail
-        // offset and reslice inside.
+        // Two overlapping slices into the same buffer (`head` is the whole
+        // buffer, `to_copy_into` is its tail) would be two live aliasing
+        // `&mut [u16]`, which is UB — pass head buffer + tail offset and
+        // reslice inside.
         fn copy(
             destination_dir: &Dir,
             walker: &mut Walker,
@@ -1632,7 +1604,6 @@ impl<'a> PackageInstall<'a> {
             to_copy_into2_offset: WinOffset,
             head2: WinSlice<'_>,
         ) -> Result<u32, bun_core::Error> {
-            // TODO(port): narrow error set
             let mut real_file_count: u32 = 0;
             #[cfg(not(windows))]
             let _ = (to_copy_into1_offset, head1, to_copy_into2_offset, head2);
@@ -1640,7 +1611,7 @@ impl<'a> PackageInstall<'a> {
             let _ = destination_dir;
             #[cfg(windows)]
             let queue = HardLinkWindowsInstallTask::init_queue();
-            // PORT NOTE: on Windows, tasks already pushed to `queue` are running on
+            // on Windows, tasks already pushed to `queue` are running on
             // worker threads; an early `?` here would return before `queue.wait()`,
             // letting the caller re-enter `init_queue()` and reset the WaitGroup
             // while workers are still inside `complete_one()` (data race on the
@@ -1676,9 +1647,9 @@ impl<'a> PackageInstall<'a> {
                                 destination_dir.fd(),
                                 entry.path,
                             ) {
-                                // Map raw errno to the Zig error names std.posix.linkatZ would
-                                // produce, so the caller's `NotSameFileSystem` / `ENXIO` checks
-                                // (and the copyfile fallback in `install()`) actually fire.
+                                // Map raw errno to the error names the caller's
+                                // `NotSameFileSystem` / `ENXIO` checks (and the
+                                // copyfile fallback in `install()`) expect.
                                 match err.get_errno() {
                                     sys::E::EEXIST => {
                                         let _ = sys::unlinkat(destination_dir, entry.path);
@@ -1782,8 +1753,6 @@ impl<'a> PackageInstall<'a> {
         self.file_count = match result {
             Ok(n) => n,
             Err(err) => {
-                // bun.handleErrorReturnTrace — debug-only diagnostics in Zig; no-op here.
-
                 #[cfg(windows)]
                 {
                     if err == bun_core::err!("FailedToCopyFile") {
@@ -1841,10 +1810,10 @@ impl<'a> PackageInstall<'a> {
         #[cfg(not(windows))]
         type Head2Char = u8;
 
-        // PORT NOTE: reshaped for borrowck — Zig passed two overlapping slices into the
-        // same buffer (`head` is the whole buffer, `to_copy_into` is its tail). Creating
-        // two live `&mut` that alias is UB in Rust, so pass head buffer + tail offset
-        // and reslice inside.
+        // Two overlapping slices into the same buffer (`head` is the whole
+        // buffer, `to_copy_into` is its tail) would be two live aliasing
+        // `&mut`, which is UB — pass head buffer + tail offset and reslice
+        // inside.
         fn copy(
             destination_dir: &Dir,
             walker: &mut Walker,
@@ -1853,7 +1822,6 @@ impl<'a> PackageInstall<'a> {
             to_copy_into2_offset: usize,
             head2: &mut [Head2Char],
         ) -> Result<u32, bun_core::Error> {
-            // TODO(port): narrow error set
             #[cfg(not(windows))]
             let mut real_file_count: u32 = 0;
             #[cfg(windows)]
@@ -2168,8 +2136,7 @@ impl<'a> PackageInstall<'a> {
             self.uninstall_before_install(destination_dir);
         }
 
-        // PORT NOTE: Zig `std.fs.path.dirname` returns null when there is no directory
-        // component; mirror that with an Option around resolve_path::dirname.
+        // `None` when there is no directory component.
         let dirname_slice =
             path::resolve_path::dirname::<path::platform::Auto>(dest_path.as_bytes());
         let subdir: Option<&[u8]> = (!dirname_slice.is_empty()
@@ -2180,14 +2147,12 @@ impl<'a> PackageInstall<'a> {
         // cache_dir_subpath in here is actually the full path to the symlink pointing to the linked package
         let symlinked_path = self.cache_dir_subpath;
         let mut to_buf = PathBuffer::uninit();
-        // Zig: `this.cache_dir.realpath(symlinked_path, &to_buf)` — open the target relative
-        // to cache_dir, then resolve its canonical path.
-        // PORT NOTE: reshaped from an IIFE — returning a borrow of `to_buf` from an
-        // `FnMut` closure is rejected by borrowck, so inline the open/getFdPath/close.
-        // PORT NOTE: Zig `std.fs.Dir.realpath` returns std-style error names
-        // (`error.FileNotFound`, `error.AccessDenied`, …), not raw errno tags.
-        // `bun_sys::Error::into()` would yield `ENOENT`/`EACCES`, so map the
-        // openat errno to the std name to preserve the user-visible error tag
+        // Open the target relative to cache_dir, then resolve its canonical path.
+        // Returning a borrow of `to_buf` from an `FnMut` closure is rejected by
+        // borrowck, so inline the open/getFdPath/close.
+        // `bun_sys::Error::into()` would yield raw errno tags (`ENOENT`/`EACCES`),
+        // so map the openat errno to the named error tag to preserve the
+        // user-visible error tag
         // (test/cli/install/bun-link.test.ts asserts on `FileNotFound:`).
         let realpath_err = |e: bun_sys::Error| -> bun_core::Error {
             use sys::E;
@@ -2202,13 +2167,12 @@ impl<'a> PackageInstall<'a> {
             }
         };
         let to_path: &[u8] = {
-            // Zig: `std.fs.Dir.realpath` opens with `.filter = .any` (Windows) /
-            // `O_PATH` (Linux). `symlinked_path` is always a package *directory*;
+            // `symlinked_path` is always a package *directory*;
             // bare `O::RDONLY` on Windows routes to the file-open NtCreateFile arm
             // which requests `FILE_WRITE_ATTRIBUTES` (may be denied on RO dirs).
             // `O::DIRECTORY` routes to `open_dir_at_windows_nt_path`
-            // (`FILE_LIST_DIRECTORY | SYNCHRONIZE`), matching the spec's directory
-            // open, then `get_fd_path` resolves via `GetFinalPathNameByHandleW`.
+            // (`FILE_LIST_DIRECTORY | SYNCHRONIZE`),
+            // then `get_fd_path` resolves via `GetFinalPathNameByHandleW`.
             let fd = match sys::openat(
                 self.cache_dir,
                 symlinked_path,
@@ -2338,8 +2302,8 @@ impl<'a> PackageInstall<'a> {
             };
 
             let target = path::resolve_path::relative(dest_dir_path, to_path);
-            // PORT NOTE: `symlinkat` takes `&ZStr` for both target and dest; build NUL-terminated
-            // copies in stack buffers (Zig used `std.posix.symlinkat` which does this internally).
+            // `symlinkat` takes `&ZStr` for both target and dest; build NUL-terminated
+            // copies in stack buffers.
             let mut target_buf = PathBuffer::uninit();
             target_buf[..target.len()].copy_from_slice(target);
             target_buf[target.len()] = 0;
@@ -2388,8 +2352,14 @@ impl<'a> PackageInstall<'a> {
                 if self.patch.is_none() {
                     let exists = match resolution_tag {
                         resolution::Tag::Npm => 'package_json_exists: {
-                            // SAFETY: thread-local PathBuffer; this is the only borrower on
-                            // this thread for the duration of the block (Zig: `var buf = ...`).
+                            // SAFETY: `buf` and `self.cache_dir_subpath` both derive from the
+                            // same thread-local `cached_package_folder_name_buf` raw pointer
+                            // (the debug_assert below checks the subpath aliases this buffer),
+                            // so there is no cross-thread access. No other `&mut` into the
+                            // buffer is created while `buf` is live, and the only writes are
+                            // at indices >= `subpath_len` — past the subpath's contents — with
+                            // the NUL terminator restored by the scopeguard before the borrow
+                            // ends.
                             let buf: &mut [u8] = unsafe {
                                 (*crate::package_manager::cached_package_folder_name_buf())
                                     .as_mut_slice()
@@ -2433,8 +2403,7 @@ impl<'a> PackageInstall<'a> {
                     });
                 let cache_dir_subpath_without_patch_hash =
                     &self.cache_dir_subpath.as_bytes()[..idx];
-                // PORT NOTE: Zig wrote into the global `bun.path.join_buf` thread-local; use a
-                // stack PathBuffer here instead (same size, no shared state).
+                // Use a stack PathBuffer (no shared state).
                 let mut join_buf = PathBuffer::uninit();
                 join_buf[..cache_dir_subpath_without_patch_hash.len()]
                     .copy_from_slice(cache_dir_subpath_without_patch_hash);
@@ -2586,8 +2555,4 @@ impl<'a> PackageInstall<'a> {
     }
 }
 
-// ───────────────────────────── imports note ─────────────────────────────
-// Walker: src/sys/walker_skippable.zig
 type Walker = walker_skippable::Walker;
-
-// ported from: src/install/PackageInstall.zig
diff --git a/src/install/PackageInstaller.rs b/src/install/PackageInstaller.rs
index 6db646995ee..6533c9e3caa 100644
--- a/src/install/PackageInstaller.rs
+++ b/src/install/PackageInstaller.rs
@@ -16,7 +16,7 @@ use crate::bun_fs::FileSystem;
 use crate::bun_progress::{Node as ProgressNode, Progress};
 
 use crate::lifecycle_script_runner::LifecycleScriptSubprocess;
-// PORT NOTE: `Lockfile` here is the in-crate `crate::lockfile::Lockfile` (the
+// `Lockfile` here is the in-crate `crate::lockfile::Lockfile` (the
 // struct `PackageManager.lockfile` actually carries). `lockfile_real` is still
 // imported for `tree::Id` / `Tree` / `DependencySlice` / `package::*`, all of
 // which are the same types re-exported through `crate::lockfile`.
@@ -49,18 +49,18 @@ pub struct PendingLifecycleScript {
 }
 
 pub struct PackageInstaller<'a> {
-    /// Zig: `*PackageManager` — BACKREF into the singleton. Raw pointer (not
+    /// BACKREF into the singleton. Raw pointer (not
     /// `&'a mut`) because the install loop also re-borrows the same object
     /// via the caller's `this`/`mgr_ptr` (e.g. `run_tasks(this, &mut installer)`
     /// in `hoisted_install`); a `&'a mut` here would assert exclusivity that
     /// the call shape contradicts. Never null. Access via `manager()` /
     /// `manager_mut()`.
     pub manager: *mut PackageManager,
-    /// Zig: `*Lockfile` — BACKREF into `(*manager).lockfile`. Same aliasing
+    /// BACKREF into `(*manager).lockfile`. Same aliasing
     /// rationale as `manager`; the column-slice fields below also point into
     /// it. Never null. Access via `lockfile()` / `lockfile_mut()`.
     pub lockfile: *mut Lockfile,
-    /// Zig: `*Progress` — BACKREF into `(*manager).progress`. Never null.
+    /// BACKREF into `(*manager).progress`. Never null.
     pub progress: *mut Progress,
 
     /// relative paths from `next` will be copied into this list.
@@ -71,8 +71,7 @@ pub struct PackageInstaller<'a> {
     pub force_install: bool,
     pub root_node_modules_folder: Dir,
     pub summary: &'a mut package_install::Summary,
-    // PORT NOTE: Zig also stored `options: *const Options` (a BACKREF into
-    // `(*manager).options`). Dropped — every caller reads via
+    // No `options` backref field — every caller reads via
     // `self.manager().options` so the shared borrow stays a child of the live
     // `&mut PackageManager` Unique tag rather than a sibling raw.
     // The following slice fields alias into `self.lockfile.packages` (BACKREF).
@@ -81,9 +80,8 @@ pub struct PackageInstaller<'a> {
     // and are only ever *grown*, never freed; `fix_cached_lockfile_package_slices`
     // re-snapshots after a grow. `RawSlice` carries no lifetime, so the
     // assignment sites do not need a `&'a → &'a` lifetime-detach round-trip.
-    // `resolutions` was `&'a mut [Resolution]` in the Zig spec but every Rust
-    // call site is a read (`&raw const self.resolutions[i]`), so it is also
-    // `RawSlice` here.
+    // Every `resolutions` call site is a read (`&raw const self.resolutions[i]`),
+    // so it is also `RawSlice` here.
     pub metas: bun_ptr::RawSlice<Package::Meta>,
     pub names: bun_ptr::RawSlice<String>,
     pub pkg_dependencies: bun_ptr::RawSlice<DependencySlice>,
@@ -179,10 +177,9 @@ impl NodeModulesFolder {
         root_node_modules_dir: &Dir,
         file_path: &ZStr,
     ) -> Result<bun_sys::file::ReadToEndResult, bun_core::Error> {
-        // TODO(port): narrow error set
         let file = self.open_file(root_node_modules_dir, file_path)?;
         let res = file.read_to_end_small();
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
         Ok(match res {
             Ok(bytes) => bun_sys::file::ReadToEndResult { bytes, err: None },
             Err(e) => bun_sys::file::ReadToEndResult {
@@ -197,7 +194,6 @@ impl NodeModulesFolder {
         root_node_modules_dir: &Dir,
         file_path: &ZStr,
     ) -> Result<bun_sys::File, bun_core::Error> {
-        // TODO(port): narrow error set
         if self.path.len() + file_path.len() * 2 < MAX_PATH_BYTES {
             // If we do not run the risk of ENAMETOOLONG, then let's just avoid opening the extra directories altogether.
             match self.open_file_without_opening_directories(root_node_modules_dir, file_path) {
@@ -221,10 +217,9 @@ impl NodeModulesFolder {
     }
 
     pub(crate) fn open_dir(&self, root: &Dir) -> Result<Dir, bun_core::Error> {
-        // TODO(port): narrow error set
         #[cfg(unix)]
         {
-            // PORT NOTE: std.posix.toPosixPath — copies into a NUL-terminated PathBuffer
+            // Copy into a NUL-terminated PathBuffer.
             let mut path_buf = PathBuffer::uninit();
             let path_z = bun_paths::resolve_path::z(self.path.as_slice(), &mut path_buf);
             return root
@@ -250,7 +245,6 @@ impl NodeModulesFolder {
     }
 
     pub(crate) fn make_and_open_dir(&mut self, root: &Dir) -> Result<Dir, bun_core::Error> {
-        // TODO(port): narrow error set
         let out = 'brk: {
             #[cfg(unix)]
             {
@@ -303,7 +297,7 @@ pub struct TreeContext {
 
 pub(crate) type TreeContextId = lockfile::tree::Id;
 
-// PORT NOTE: TreeContext::deinit dropped — Vec and Bin::PriorityQueue impl Drop.
+// TreeContext::deinit dropped — Vec and Bin::PriorityQueue impl Drop.
 
 pub(crate) enum LazyPackageDestinationDir<'a> {
     /// Non-owning view of a directory handle the caller owns.
@@ -322,7 +316,6 @@ pub(crate) enum LazyPackageDestinationDir<'a> {
 impl<'a> LazyPackageDestinationDir<'a> {
     #[allow(dead_code)]
     pub(crate) fn get_dir(&mut self) -> Result<Fd, bun_core::Error> {
-        // TODO(port): narrow error set
         match self {
             LazyPackageDestinationDir::Dir(fd) => Ok(*fd),
             LazyPackageDestinationDir::Owned(dir) => Ok(dir.fd()),
@@ -432,9 +425,8 @@ impl<'a> PackageInstaller<'a> {
 
     /// Increments the number of installed packages for a tree id and runs available scripts
     /// if the tree is finished.
-    // PORT NOTE: Zig parametrised this on `comptime should_install_packages: bool`.
-    // Rust can't pass `!CONST_PARAM` as a const-generic arg on stable, and the
-    // bool only gates a single call below, so it's a runtime arg here.
+    // `should_install_packages` only gates a single call below, so it's a
+    // runtime arg rather than a const generic.
     pub(crate) fn increment_tree_install_count(
         &mut self,
         should_install_packages: bool,
@@ -482,7 +474,7 @@ impl<'a> PackageInstaller<'a> {
             let mut link_target_buf = PathBuffer::uninit();
             let mut link_dest_buf = PathBuffer::uninit();
             let mut link_rel_buf = PathBuffer::uninit();
-            // PORT NOTE: reshaped for borrowck — pass tree_id, re-borrow tree inside.
+            // reshaped for borrowck — pass tree_id, re-borrow tree inside.
             self.link_tree_bins(
                 tree_id,
                 link_target_buf.as_mut_slice(),
@@ -501,8 +493,8 @@ impl<'a> PackageInstaller<'a> {
 
     pub(crate) fn link_tree_bins(
         &mut self,
-        // PORT NOTE: zig passes `tree: *TreeContext` + `tree_id`; reshaped to take only
-        // `tree_id` and re-borrow `&mut self.trees[tree_id]` to satisfy borrowck.
+        // Takes only `tree_id` and re-borrows `&mut self.trees[tree_id]` to
+        // satisfy borrowck.
         tree_id: TreeContextId,
         link_target_buf: &mut [u8],
         link_dest_buf: &mut [u8],
@@ -514,7 +506,7 @@ impl<'a> PackageInstaller<'a> {
         let string_buf = lockfile.buffers.string_bytes.as_slice();
         let mut node_modules_path: AbsPath =
             AbsPath::from(self.node_modules.path.as_slice()).unwrap_or_oom();
-        // PORT NOTE: `defer node_modules_path.deinit()` — AbsPath impls Drop.
+        // `defer node_modules_path.deinit()` — AbsPath impls Drop.
 
         let pkgs = lockfile.packages.slice();
         let pkg_name_hashes = pkgs.items_name_hash();
@@ -539,7 +531,7 @@ impl<'a> PackageInstaller<'a> {
             let mut target_package_name = package_name_;
             let mut can_retry_without_native_binlink_optimization = false;
             let target_node_modules_path_opt: Option<AbsPath> = None;
-            // PORT NOTE: `defer if (target_node_modules_path_opt) |*path| path.deinit()` — Option<AbsPath> drops.
+            // `defer if (target_node_modules_path_opt) |*path| path.deinit()` — Option<AbsPath> drops.
 
             'native_binlink_optimization: {
                 if !manager.postinstall_optimizer.is_native_binlink_enabled() {
@@ -602,12 +594,12 @@ impl<'a> PackageInstaller<'a> {
             };
 
             loop {
-                // PORT NOTE: reshaped for borrowck — Zig aliases the same `*AbsPath` for
-                // both `node_modules_path` (mut) and `target_node_modules_path` (read-only)
-                // when no replacement is set. Derive both from a single `*mut` so the
-                // read pointer shares the write reference's provenance (a `*const` taken
-                // from `&node_modules_path` would be popped by the later `&mut` reborrow
-                // under stacked-borrows).
+                // `node_modules_path` (mut) and `target_node_modules_path`
+                // (read-only) refer to the same buffer when no replacement is
+                // set. Derive both from a single `*mut` so the read pointer
+                // shares the write reference's provenance (a `*const` taken
+                // from `&node_modules_path` would be popped by the later
+                // `&mut` reborrow under stacked-borrows).
                 // SAFETY: `bin::Linker::link` only reads `target_node_modules_path` and
                 // never writes through it while `node_modules_path` is borrowed.
                 let nm_ptr: *mut AbsPath = &raw mut node_modules_path;
@@ -684,7 +676,7 @@ impl<'a> PackageInstaller<'a> {
 
         let trees_len = self.trees.len();
         for tree_id in 0..trees_len {
-            // PORT NOTE: reshaped for borrowck — index instead of `for (self.trees, 0..) |*tree, tree_id|`.
+            // reshaped for borrowck — index instead of `for (self.trees, 0..) |*tree, tree_id|`.
             if self.trees[tree_id].binaries.count() > 0 {
                 self.seen_bin_links.clear();
                 self.node_modules.path.truncate(
@@ -697,7 +689,7 @@ impl<'a> PackageInstaller<'a> {
                     self.lockfile().buffers.trees.as_slice(),
                     self.lockfile().buffers.dependencies.as_slice(),
                     self.lockfile().buffers.string_bytes.as_slice(),
-                    // PERF(port): `tree_id` ranges over `0..self.trees.len()`
+                    // `tree_id` ranges over `0..self.trees.len()`
                     // and tree IDs are u32 by construction; avoid the
                     // `try_from` panic-format path on this per-tree loop.
                     tree_id as u32,
@@ -728,7 +720,7 @@ impl<'a> PackageInstaller<'a> {
             let optional = self.pending_lifecycle_scripts[i].optional;
             if self.can_run_scripts(tree_id) {
                 let entry = self.pending_lifecycle_scripts.swap_remove(i);
-                // PORT NOTE: reshaped for borrowck — `package_name` is `Box<[u8]>`;
+                // reshaped for borrowck — `package_name` is `Box<[u8]>`;
                 // clone it for the error message since `entry.list` is moved into `spawn`.
                 let name: Box<[u8]> = entry.list.package_name.clone();
                 let output_in_foreground = false;
@@ -785,22 +777,20 @@ impl<'a> PackageInstaller<'a> {
         &mut self,
         log_level: Options::LogLevel,
     ) {
-        // TODO(refactor): defer save/restore of self.node_modules / self.current_tree_id.
-        // Zig does a struct-copy of NodeModulesFolder (ptr+len+cap) and restores on scope
-        // exit. In Rust this needs `core::mem::take` + scopeguard, but scopeguard cannot
-        // capture `&mut self` alongside the loop body's `&mut self`. Could hoist into
-        // a helper that takes the saved values by move and restores after the loop.
+        // Manual save/restore of self.node_modules / self.current_tree_id:
+        // a guard cannot capture `&mut self` alongside the loop body's
+        // `&mut self`. The function is infallible and its single exit below restores.
         let prev_node_modules = core::mem::take(&mut self.node_modules);
         let prev_tree_id = self.current_tree_id;
 
         let trees_len = self.trees.len();
         for i in 0..trees_len {
-            // PORT NOTE: reshaped for borrowck — index instead of iter_mut.
+            // reshaped for borrowck — index instead of iter_mut.
             if FORCE
                 || Self::can_install_package_for_tree(
                     &self.completed_trees,
                     self.lockfile().buffers.trees.as_slice(),
-                    // PERF(port): `i` ranges over `0..self.trees.len()`; tree
+                    // `i` ranges over `0..self.trees.len()`; tree
                     // IDs are u32 by construction.
                     i as u32,
                 )
@@ -810,7 +800,7 @@ impl<'a> PackageInstaller<'a> {
                 // going up ensures we will reach any trees that will be able to install
                 // packages upon completing the current tree
                 //
-                // PORT NOTE: spec iterates `tree.pending_installs.items` by struct
+                // spec iterates `tree.pending_installs.items` by struct
                 // copy (each `context.path` is the same allocation that lives in
                 // `pending_installs`) and `defer clearRetainingCapacity()` at the end.
                 // Drain by move (`mem::take`) to transfer ownership without the
@@ -849,9 +839,8 @@ impl<'a> PackageInstaller<'a> {
     }
 
     pub(crate) fn complete_remaining_scripts(&mut self, log_level: Options::LogLevel) {
-        // PORT NOTE: reshaped for borrowck — drain by move since loop body needs `&mut
-        // self.manager` and `spawn_package_lifecycle_scripts` consumes the list. Zig
-        // iterated by struct copy and never re-read `pending_lifecycle_scripts` after.
+        // reshaped for borrowck — drain by move since loop body needs `&mut
+        // self.manager` and `spawn_package_lifecycle_scripts` consumes the list.
         for entry in core::mem::take(&mut self.pending_lifecycle_scripts) {
             let package_name: Box<[u8]> = entry.list.package_name.clone();
             // .monotonic is okay because this value isn't modified from any other thread.
@@ -944,7 +933,7 @@ impl<'a> PackageInstaller<'a> {
 
     /// A tree can start installing packages when the parent has installed all its packages. If the parent
     /// isn't finished, we need to wait because it's possible a package installed in this tree will be deleted by the parent.
-    // PORT NOTE: free fn (not `&self`) so callers can pass disjoint borrows
+    // free fn (not `&self`) so callers can pass disjoint borrows
     // (`&self.completed_trees` + `&self.lockfile().buffers.trees`) without
     // tripping borrowck on the whole-`self` reborrow.
     pub(crate) fn can_install_package_for_tree(
@@ -963,7 +952,7 @@ impl<'a> PackageInstaller<'a> {
         true
     }
 
-    // PORT NOTE: `pub fn deinit` dropped. All owned fields (`pending_lifecycle_scripts: Vec`,
+    // `pub fn deinit` dropped. All owned fields (`pending_lifecycle_scripts: Vec`,
     // `completed_trees: Bitset`, `trees: Box<[TreeContext]>`, `tree_ids_to_trees_the_id_depends_on`,
     // `node_modules`, `trusted_dependencies_from_update_requests`) impl Drop. Borrowed fields
     // (`manager`, `lockfile`, etc.) are not freed.
@@ -992,7 +981,7 @@ impl<'a> PackageInstaller<'a> {
             let new = Bitset::init_empty(self.lockfile().packages.len()).unwrap_or_oom();
             let old = core::mem::replace(&mut self.successfully_installed, new);
             old.copy_into(&mut self.successfully_installed);
-            // PORT NOTE: `defer old.deinit(bun.default_allocator)` — Bitset impls Drop.
+            // `defer old.deinit(bun.default_allocator)` — Bitset impls Drop.
         }
     }
 
@@ -1033,10 +1022,11 @@ impl<'a> PackageInstaller<'a> {
 
         if let Some(removed) = self.manager_mut().task_queue.fetch_remove(&task_id) {
             let callbacks = removed.value;
-            // PORT NOTE: `defer callbacks.deinit(this.manager.allocator)` — Vec drops.
+            // `defer callbacks.deinit(this.manager.allocator)` — Vec drops.
 
-            // TODO(port): defer save/restore of self.node_modules / self.current_tree_id.
-            // See install_available_packages for the same issue.
+            // Manual save/restore of self.node_modules / self.current_tree_id
+            // (see install_available_packages). Infallible body — both exit
+            // paths below restore the saved values.
             let prev_node_modules = core::mem::take(&mut self.node_modules);
             let prev_tree_id = self.current_tree_id;
 
@@ -1061,7 +1051,6 @@ impl<'a> PackageInstaller<'a> {
                 let callback_package_id =
                     self.lockfile().buffers.resolutions.as_slice()[context.dependency_id as usize];
                 self.node_modules.tree_id = context.tree_id;
-                // PORT NOTE: zig assigns `context.path` (ArrayList struct copy).
                 // `DependencyInstallContext.path: Vec<u8>` — clone since `cb` is `&`.
                 self.node_modules.path.clone_from(&context.path);
                 self.current_tree_id = context.tree_id;
@@ -1116,7 +1105,7 @@ impl<'a> PackageInstaller<'a> {
             let mut temp = PackageScripts::default();
             let mut temp_lockfile = Lockfile::default();
             temp_lockfile.init_empty();
-            // PORT NOTE: `defer temp_lockfile.deinit()` — Lockfile impls Drop.
+            // `defer temp_lockfile.deinit()` — Lockfile impls Drop.
             let mut string_builder = temp_lockfile.string_builder();
             let log = self.manager().log_mut();
             if let Err(err) = temp.fill_from_package_json(&mut string_builder, log, folder_path) {
@@ -1142,14 +1131,12 @@ impl<'a> PackageInstaller<'a> {
 
         match resolution_tag {
             resolution::Tag::Git | resolution::Tag::Github | resolution::Tag::Root => {
-                // PORT NOTE: zig `inline for (Lockfile.Scripts.names) |hook| { @field(...) }`.
                 // The `FIELD_NAMES` table lists each script field accessor.
                 for &(_, accessor) in PackageScripts::FIELD_NAMES.iter() {
                     count += (!accessor(&scripts).is_empty()) as usize;
                 }
             }
             _ => {
-                // PORT NOTE: zig `inline for (.{"preinstall","install","postinstall"})` over @field.
                 count += (!scripts.preinstall.is_empty()) as usize;
                 count += (!scripts.install.is_empty()) as usize;
                 count += (!scripts.postinstall.is_empty()) as usize;
@@ -1182,10 +1169,10 @@ impl<'a> PackageInstaller<'a> {
         pkg_name: String,
         resolution: &Resolution,
     ) {
-        // PORT NOTE: reshaped for borrowck — `string_bytes` is not mutated during install,
+        // reshaped for borrowck — `string_bytes` is not mutated during install,
         // so capture a raw slice once to avoid repeatedly re-borrowing `self.lockfile`
-        // across `&mut self` method calls below (Zig accessed `lockfile.buffers.string_bytes`
-        // freely inline). SAFETY: `buffers.string_bytes` is append-only and never freed
+        // across `&mut self` method calls below.
+        // SAFETY: `buffers.string_bytes` is append-only and never freed
         // for the lifetime of this `PackageInstaller`.
         let string_buf_ptr =
             bun_ptr::RawSlice::new(self.lockfile().buffers.string_bytes.as_slice());
@@ -1215,9 +1202,9 @@ impl<'a> PackageInstaller<'a> {
             return;
         }
 
-        // PORT NOTE: `PackageInstall` stores both `destination_dir_subpath: &mut ZStr`
-        // and `destination_dir_subpath_buf: &mut [u8]` aliasing the same bytes (Zig
-        // slices don't enforce noalias). Derive BOTH from a single `*mut PathBuffer`
+        // `PackageInstall` stores both `destination_dir_subpath: &mut ZStr`
+        // and `destination_dir_subpath_buf: &mut [u8]` aliasing the same bytes.
+        // Derive BOTH from a single `*mut PathBuffer`
         // so neither `&mut` invalidates the other under stacked-borrows.
         let subpath_buf_ptr: *mut PathBuffer = &raw mut self.destination_dir_subpath_buf;
         let destination_dir_subpath: &mut ZStr = {
@@ -1268,7 +1255,6 @@ impl<'a> PackageInstaller<'a> {
             {
                 break 'brk (None, None, None, false);
             }
-            // PERF(port): was stack-fallback
             let mut name_and_version: Vec<u8> = Vec::new();
             use std::io::Write;
             write!(
@@ -1307,12 +1293,12 @@ impl<'a> PackageInstaller<'a> {
             );
         };
 
-        // PORT NOTE: reshaped for borrowck — `PackageInstall` borrows several `self.*`
+        // reshaped for borrowck — `PackageInstall` borrows several `self.*`
         // fields while subsequent code also accesses `self.manager` / `self.node_modules`
-        // / `self.lockfile` mutably (Zig aliased freely). Detach the borrows via a
+        // / `self.lockfile` mutably. Detach the borrows via a
         // `ParentRef` so `installer`'s lifetime is independent of `&mut self`.
         // BACKREF — none of these fields are dropped, moved, or resized while
-        // `installer` is alive (matches Zig invariant; see `PackageInstaller` field docs).
+        // `installer` is alive (see `PackageInstaller` field docs).
         let node_modules_ref = bun_ptr::ParentRef::<NodeModulesFolder>::new(&self.node_modules);
         let mut installer = PackageInstall {
             progress: if self.manager().options.log_level.show_progress() {
@@ -1326,7 +1312,6 @@ impl<'a> PackageInstaller<'a> {
             // field outlives `installer`. `destination_dir_subpath` above derives from the
             // same raw pointer, so this `&mut` does not invalidate it under stacked-borrows.
             destination_dir_subpath_buf: unsafe { (*subpath_buf_ptr).as_mut_slice() },
-            // PORT NOTE: zig `arena: this.lockfile.allocator` dropped — global mimalloc.
             package_name: pkg_name,
             patch: patch_patch.map(|_| package_install::Patch {
                 contents_hash: patch_contents_hash.unwrap(),
@@ -1542,7 +1527,7 @@ impl<'a> PackageInstaller<'a> {
                     }
                     resolution::Tag::Github => {
                         let url = self.manager_mut().alloc_github_url(resolution.github());
-                        // PORT NOTE: `defer this.manager.allocator.free(url)` — url: Vec<u8> drops.
+                        // `defer this.manager.allocator.free(url)` — url: Vec<u8> drops.
                         match package_manager::enqueue_tarball_for_download(
                             self.manager_mut(),
                             dependency_id,
@@ -1823,7 +1808,7 @@ impl<'a> PackageInstaller<'a> {
                     {
                         let mut folder_path =
                             AutoAbsPath::from(self.node_modules.path.as_slice()).unwrap_or_oom();
-                        // PORT NOTE: `defer folder_path.deinit()` — AbsPath impls Drop.
+                        // `defer folder_path.deinit()` — AbsPath impls Drop.
                         folder_path
                             .append(alias.slice(string_buf!()))
                             .unwrap_or_oom();
@@ -1972,8 +1957,7 @@ impl<'a> PackageInstaller<'a> {
                         // - Access Denied because this specific package is unwritable
                         // in the case of the former, the logs are extremely noisy, so we
                         // will exit early, otherwise set a flag to not re-stat
-                        // PORT NOTE: zig fn-local `const Singleton = struct { var node_modules_is_ok = false; }`
-                        // — translated to a module-level static since Rust lacks fn-local mutable statics.
+                        // Static flag since Rust lacks fn-local mutable statics.
                         static NODE_MODULES_IS_OK: core::sync::atomic::AtomicBool =
                             core::sync::atomic::AtomicBool::new(false);
                         if !NODE_MODULES_IS_OK.load(Ordering::Relaxed) {
@@ -2091,7 +2075,7 @@ impl<'a> PackageInstaller<'a> {
                     .unwrap_or_oom();
             }
 
-            // PORT NOTE: reshaped for borrowck — `LazyPackageDestinationDir` borrows
+            // reshaped for borrowck — `LazyPackageDestinationDir` borrows
             // `&self.node_modules`, but this else-branch never reads `destination_dir`
             // (it only `close()`s it at the end, which is a no-op for `NodeModulesPath`).
             // Detach via raw ptr so subsequent `&mut self` calls type-check.
@@ -2101,7 +2085,7 @@ impl<'a> PackageInstaller<'a> {
                 root_node_modules_dir: self.root_node_modules_folder.fd(),
             };
 
-            // PORT NOTE: `defer { destination_dir.close(); }` + `defer increment_tree_install_count`.
+            // `defer { destination_dir.close(); }` + `defer increment_tree_install_count`.
             // No early returns in this branch, so manual calls at end are equivalent.
 
             let dep = &self.lockfile().buffers.dependencies.as_slice()[dependency_id as usize];
@@ -2202,7 +2186,7 @@ impl<'a> PackageInstaller<'a> {
                 }
             }
 
-            // PORT NOTE: `destination_dir` is `LazyPackageDestinationDir::NodeModulesPath`
+            // `destination_dir` is `LazyPackageDestinationDir::NodeModulesPath`
             // holding `&self.node_modules`. `increment_tree_install_count` takes
             // `&mut self` and (via `link_tree_bins`) reads `self.node_modules.path`,
             // which would alias the borrow held by `destination_dir`. Close it first
@@ -2354,5 +2338,3 @@ impl<'a> PackageInstaller<'a> {
         );
     }
 }
-
-// ported from: src/install/PackageInstaller.zig
diff --git a/src/install/PackageManager.rs b/src/install/PackageManager.rs
index 15cfcdcc836..6402ee6d70d 100644
--- a/src/install/PackageManager.rs
+++ b/src/install/PackageManager.rs
@@ -24,18 +24,16 @@ use bun_paths::{DELIMITER, PathBuffer, SEP, SEP_STR};
 use bun_semver as Semver;
 use bun_sys::{self, Fd};
 use bun_threading::{ThreadPool, UnboundedQueue, thread_pool};
-use bun_transpiler::{self as transpiler, Transpiler};
+use bun_transpiler as transpiler;
 use bun_url::URL;
 
-/// Port of `bun.LazyBool` (bun.zig:2234) — caches the result of a getter the
-/// first time `get()` is called. Zig used `@fieldParentPtr` to recover the
-/// containing struct from the field address; Rust has no field-parent-pointer
-/// so the getter receives `&mut PackageManager` explicitly and the caller
+/// Caches the result of a getter the first time `get()` is called.
+/// The getter receives `&mut PackageManager` explicitly and the caller
 /// passes `self` (the field is always read via `self.ci_mode.get(self)` in
 /// PackageManager — see `is_continuous_integration`). Because the field lives
 /// inside the parent and we'd otherwise need a simultaneous `&mut self.ci_mode`
 /// + `&self` borrow, model the cache as a `Cell<Option<bool>>` and read the
-/// parent through a raw pointer (mirrors Zig's non-exclusive `*Parent`).
+/// parent through a raw pointer.
 pub struct LazyBool<F> {
     value: core::cell::Cell<Option<bool>>,
     getter: F,
@@ -65,13 +63,11 @@ impl LazyBool<fn(&PackageManager) -> bool> {
 // `bun_runtime::api::bun::process` and *reads* the same flag.
 use bun_spawn::process::WaiterThread;
 
-// TODO(b0): RunCommand arrives from move-in (bun_runtime::cli::RunCommand → install).
 use crate::RunCommand;
 
-/// `Command::Context` shim — Zig's `Command.Context` (= `*ContextData`) lives in
-/// `bun_runtime::cli::Command`; the option-carrying `ContextData` shape was lifted
+/// `Command::Context` shim — the option-carrying `ContextData` shape was lifted
 /// into `bun_options_types::context` so install can reference it without the CLI
-/// tier. Re-export under the Zig path so `init()` / `install_with_manager()` /
+/// tier. Re-export here so `init()` / `install_with_manager()` /
 /// `setup_global_dir()` etc. keep their `Command::Context` signatures.
 #[allow(non_snake_case)]
 pub mod Command {
@@ -84,8 +80,8 @@ pub mod Command {
     pub(crate) static GLOBAL_CTX: core::sync::atomic::AtomicPtr<ContextData> =
         core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
 
-    /// Returns the raw process-global `*mut ContextData` (Zig: `Command.get()
-    /// -> *ContextData`). Returns a raw pointer rather than `&'static mut`
+    /// Returns the raw process-global `*mut ContextData`.
+    /// Returns a raw pointer rather than `&'static mut`
     /// because callers (e.g. `update_package_json_and_install`) already hold a
     /// live `ctx: &mut ContextData` to the same allocation — materializing a
     /// second `&mut` here would alias and is UB. Callers must deref at point
@@ -100,8 +96,8 @@ pub mod Command {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Sub-module declarations — Zig basenames preserved per PORTING.md, hence
-// explicit #[path] attrs for PascalCase / camelCase file names.
+// Sub-module declarations — explicit #[path] attrs for PascalCase /
+// camelCase file names.
 // ──────────────────────────────────────────────────────────────────────────
 #[path = "PackageManager/CommandLineArguments.rs"]
 pub mod command_line_arguments;
@@ -212,12 +208,6 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.
     }
 }
 
-// `bun.resolver.DirInfo` — only stored as a raw pointer in
-// `ScriptRunEnvironment.root_dir_info`. `bun_resolver` is a lower tier than
-// `bun_install` (already a transitive dep via `bun_transpiler` → `bun_bundler`),
-// so import the real type directly instead of an opaque ZST stub.
-use bun_resolver::dir_info::DirInfo;
-
 use crate::lockfile_real::package as Package;
 use crate::package_manager_task as Task;
 use crate::resolvers::folder_resolver::FolderResolution;
@@ -235,7 +225,7 @@ use bun_install::{
 pub use self::command_line_arguments as command_line_arguments_mod;
 pub use self::command_line_arguments::CommandLineArguments;
 pub use self::package_manager_options::Options;
-// Zig's `PackageJSONEditor` is a file-level namespace (no struct) — re-export
+// `PackageJSONEditor` is a module-level namespace (no struct) — re-export
 // the module itself so `PackageJSONEditor::edit(...)` resolves to the free fns.
 pub use self::install_with_manager::install_with_manager;
 pub use self::package_json_editor as PackageJSONEditor;
@@ -322,8 +312,6 @@ type PreallocatedNetworkTasks = HiveArrayFallback<NetworkTask, 128>;
 type ResolveTaskQueue = UnboundedQueue<Task::Task<'static> /* , .next */>;
 
 type RepositoryMap = HashMap<Task::Id, Fd /* , IdentityContext<Task::Id>, 80 */>;
-/// Zig: `FolderResolution.Map` (resolvers/folder_resolver.zig) =
-/// `std.HashMap(u64, FolderResolution, IdentityContext(u64), 80)`.
 pub(crate) type FolderResolutionMap =
     HashMap<u64, FolderResolution /* , IdentityContext<u64>, 80 */>;
 pub(crate) type NpmAliasMap =
@@ -360,11 +348,11 @@ pub struct PackageManager {
     // handful of sites that allocated AST nodes via `Expr.allocate(manager.allocator, …)`
     // — i.e. nodes that must outlive `Expr.Data.Store.reset()` across workspace
     // iterations — use `ast_arena` instead. The manager is a leaked singleton, so
-    // this arena has process lifetime, matching the Zig allocator's semantics.
+    // this arena has process lifetime.
     pub ast_arena: bun_alloc::Arena,
-    // TODO(port): lifetime — LIFETIMES.tsv classifies this BORROW_PARAM → `&'a mut bun_ast::Log`
-    // (struct gets `<'a>`). Kept as raw ptr because PackageManager is a leaked singleton stored
-    // in a `static`; threading `<'a>` through the global holder is a TODO(refactor).
+    // Raw ptr rather than `&'a mut bun_ast::Log`: PackageManager is a leaked singleton
+    // stored in a `static`, which cannot carry a lifetime parameter. Invariant: the
+    // pointed-to Log must outlive every use of the singleton.
     pub log: *mut bun_ast::Log,
     pub resolve_tasks: ResolveTaskQueue,
     pub timestamp_for_manifest_cache_control: u32,
@@ -377,7 +365,7 @@ pub struct PackageManager {
     pub env: Option<bun_ptr::BackRef<dot_env::Loader<'static>>>,
     pub progress: Progress,
     pub downloads_node: Option<*mut ProgressNode>, // BORROW_FIELD — points into self.progress
-    pub scripts_node: Option<NonNull<ProgressNode>>, // UNKNOWN — points to caller stack-local // TODO(port): lifetime
+    pub scripts_node: Option<NonNull<ProgressNode>>, // points to a caller stack-local Progress node; only valid while that caller frame is live
     pub progress_name_buf: [u8; 768],
     pub progress_name_buf_dynamic: Vec<u8>,
     pub cpu_count: u32,
@@ -439,8 +427,6 @@ pub struct PackageManager {
 
     pub node_gyp_tempdir_name: Box<[u8]>,
 
-    pub env_configure: Option<ScriptRunEnvironment>,
-
     pub lockfile: Box<Lockfile>, // OWNED
 
     pub options: Options,
@@ -516,7 +502,7 @@ impl RootPackageId {
 /// Corresponds to possible commands from the CLI.
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, strum::IntoStaticStr)]
-#[strum(serialize_all = "snake_case")] // @tagName compat: Zig tags are lowercase ("install", "update", ...)
+#[strum(serialize_all = "snake_case")] // serialized names are lowercase ("install", "update", ...)
 pub enum Subcommand {
     Install,
     Update,
@@ -644,11 +630,6 @@ pub enum TrackInstalledBin {
     Basename(Box<[u8]>),
 }
 
-pub struct ScriptRunEnvironment {
-    pub root_dir_info: Option<NonNull<DirInfo>>, // UNKNOWN — struct appears unused // TODO(port): lifetime
-    pub transpiler: Transpiler<'static>,
-}
-
 // MOVE_DOWN: data struct + accessors live in `bun_install_types::WakeHandler`
 // (single definition the resolver also stores). The `handler` second arg is
 // erased to `*mut c_void` there because that crate cannot name
@@ -659,7 +640,7 @@ pub use bun_install_types::resolver_hooks::WakeHandler;
 // Globals / statics
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Port of Zig `pub var verbose_install: bool`. Set once during
+/// Set once during
 /// single-threaded CLI startup (`PackageManagerOptions::load`) and read on
 /// both the main thread and ThreadPool workers thereafter — `AtomicBool` with
 /// `Relaxed` is sufficient (no ordering against other state; the write
@@ -668,8 +649,7 @@ pub(crate) static VERBOSE_INSTALL: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
 
 impl PackageManager {
-    /// Port of Zig `pub var verbose_install: bool` (PackageManager.zig) — read
-    /// as `PackageManager.verbose_install` throughout the install pipeline.
+    /// Read as `PackageManager::verbose_install()` throughout the install pipeline.
     #[inline]
     pub fn verbose_install() -> bool {
         VERBOSE_INSTALL.load(core::sync::atomic::Ordering::Relaxed)
@@ -689,10 +669,9 @@ impl PackageManager {
     ///
     /// The returned lifetime is **decoupled** from `&self`: callers routinely
     /// hold a borrow into `self.lockfile`/`self.options` while appending an
-    /// error, and the `Log` is a disjoint allocation. This mirrors Zig's
-    /// `*PackageManager` field-aliasing; it is the caller's responsibility not
-    /// to alias the returned `&mut Log` (single-threaded by construction —
-    /// only the main install loop touches `log`).
+    /// error, and the `Log` is a disjoint allocation. It is the caller's
+    /// responsibility not to alias the returned `&mut Log` (single-threaded by
+    /// construction — only the main install loop touches `log`).
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn log_mut<'a>(&self) -> &'a mut bun_ast::Log {
@@ -741,10 +720,8 @@ impl PackageManager {
         Some(unsafe { p.as_mut() })
     }
 
-    /// Port of Zig `pub fn get() *PackageManager` (PackageManager.zig:442) —
-    /// the global singleton accessor. Associated-fn spelling that forwards to
-    /// the free [`get`] so callers can write `PackageManager::get()` (the Zig
-    /// `PackageManager.get()` call shape).
+    /// The global singleton accessor. Associated-fn spelling that forwards to
+    /// the free [`get`] so callers can write `PackageManager::get()`.
     ///
     /// Returns `&'static` (shared) — NOT `&'static mut`. Thread-pool workers
     /// (`Repository` git ops, npm `SaveTask`, `UninstallTask::run`) call this
@@ -755,16 +732,14 @@ impl PackageManager {
     #[inline]
     pub fn get() -> &'static PackageManager {
         // SAFETY: `holder::RAW_PTR` is written once on the main thread by
-        // `allocate_package_manager()` before any caller of `get()` (asserted
-        // by Zig's `Holder.ptr = undefined` → init ordering); the singleton
-        // lives for the process. Shared `&` aliases freely across threads.
+        // `allocate_package_manager()` before any caller of `get()`; the
+        // singleton lives for the process. Shared `&` aliases freely across
+        // threads.
         unsafe { &*get() }
     }
 
-    /// Port of `PackageManager.init` (src/install/PackageManager.zig:568).
     /// Associated-fn spelling that forwards to the free [`init`] so callers
-    /// can write `PackageManager::init(ctx, cli, subcommand)` (the Zig
-    /// `PackageManager.init` call shape).
+    /// can write `PackageManager::init(ctx, cli, subcommand)`.
     #[inline]
     pub fn init(
         ctx: Command::Context,
@@ -775,10 +750,8 @@ impl PackageManager {
     }
 }
 
-// Zig: `const TimePasser = struct { pub var last_time: u64 = 0; };` — a one-field
-// namespace whose only consumer is `hasEnoughTimePassedBetweenWaitingMessages`.
-// PORTING.md §Global mutable state: counter → Atomic. Main-thread-only so
-// `Relaxed` matches the Zig non-atomic read/write.
+// Only consumer is `hasEnoughTimePassedBetweenWaitingMessages`.
+// Main-thread-only, so `Relaxed` suffices.
 static TIME_PASSER_LAST_TIME: core::sync::atomic::AtomicU64 = core::sync::atomic::AtomicU64::new(0);
 
 thread_local! {
@@ -806,11 +779,8 @@ mod holder {
     use super::PackageManager;
     use bun_dotenv as dot_env;
     // OWNED — global singleton, leaked.
-    // PORT NOTE: LIFETIMES.tsv prescribes `OnceLock<Box<PackageManager>>` for Holder.ptr, but
-    // Zig uses `var ptr: *PackageManager = undefined` then assigns via allocatePackageManager()
-    // and later writes `manager.* = ...` in-place. OnceLock<Box<T>> can't express
-    // allocate-then-fill (no `&mut` after set). Keep a raw ptr for now.
-    // TODO(port): in-place init — reconcile with OnceLock<Box<PackageManager>>.
+    // OnceLock<Box<PackageManager>> can't express allocate-then-fill
+    // (no `&mut` after set), so a raw ptr is used instead.
     // PORTING.md §Global mutable state: ptr written once on main thread, read
     // from worker threads → AtomicPtr (Release/Acquire pairs the publish).
     pub(super) static RAW_PTR: core::sync::atomic::AtomicPtr<PackageManager> =
@@ -821,10 +791,9 @@ mod holder {
 
     // Process-lifetime env storage for `init()`. `dot_env::Loader<'a>` borrows `&'a mut Map`,
     // so the pair is self-referential and cannot live in `OnceLock<T>` (which only yields `&T`).
-    // Mirrors Zig's `ctx.allocator.create(dot_env::Map)` / `create(dot_env::Loader)` — owned by
-    // the singleton, never freed. Avoids `Box::leak` per PORTING.md §Forbidden.
-    // TODO(port): retype `dot_env::Loader.map` to `Box<Map>` so this becomes an owned field
-    // (`Box<dot_env::Loader>`) on `PackageManager` and these statics disappear.
+    // Owned by the singleton, never freed. Avoids `Box::leak` per PORTING.md §Forbidden.
+    // (These statics could go away if `dot_env::Loader.map` were retyped to an owned
+    // `Box<Map>`, making this an owned `Box<dot_env::Loader>` field on `PackageManager`.)
     // Write-once during single-threaded init; never read afterwards (kept only
     // to anchor the allocation). `AtomicCell<*mut T>` — payload is `Copy` and
     // pointer-sized, so `.store()` is a safe Release write (no `RacyCell`
@@ -834,13 +803,12 @@ mod holder {
     pub(super) static ENV_LOADER: bun_core::AtomicCell<*mut dot_env::Loader<'static>> =
         bun_core::AtomicCell::new(core::ptr::null_mut());
 
-    /// Process-lifetime storage for `http::http_thread::InitOpts.abs_ca_file_name`
-    /// (Zig: `allocator.dupeZ` into a leaked singleton field). `OnceLock` per
-    /// PORTING.md §Forbidden — never `Box::leak` to mint `&'static`.
+    /// Process-lifetime storage for `http::http_thread::InitOpts.abs_ca_file_name`.
+    /// `OnceLock` per PORTING.md §Forbidden — never `Box::leak` to mint `&'static`.
     pub(super) static ABS_CA_FILE_NAME: std::sync::OnceLock<Box<[u8]>> = std::sync::OnceLock::new();
 
     /// Process-lifetime storage for `http::http_thread::InitOpts.ca` C-strings
-    /// (Zig: `manager.allocator.dupeZ` per entry, never freed). The HTTP thread
+    /// (never freed). The HTTP thread
     /// reads these asynchronously after `init()` returns, so they must outlive
     /// the local that builds them.
     pub(super) static CA: std::sync::OnceLock<Vec<bun_core::ZBox>> = std::sync::OnceLock::new();
@@ -868,11 +836,9 @@ impl PackageManager {
         self.update_requests = Box::default();
     }
 
-    /// Zig: `pm.lockfile.loadFromCwd(pm, allocator, log, attempt_loading_from_other_lockfile)`.
-    ///
-    /// PORT NOTE: reshaped for borrowck — the Zig call passes `pm` as a separate
-    /// argument while the receiver borrows `pm.lockfile`, which is a
-    /// self-referential split borrow in Rust. Encapsulated here so callers stay
+    /// Reshaped for borrowck — `Lockfile::load_from_cwd` takes the manager as
+    /// a separate argument while the receiver borrows `self.lockfile`, which
+    /// is a self-referential split borrow. Encapsulated here so callers stay
     /// in safe code: the returned `LoadResult` mutably borrows `self` for its
     /// lifetime, after which `self.lockfile` holds the loaded data.
     pub fn load_lockfile_from_cwd<const ATTEMPT_OTHER: bool>(
@@ -896,8 +862,8 @@ impl PackageManager {
         if self.options.log_level != package_manager_options::LogLevel::Silent {
             // SAFETY: `self.log` points to a separate `bun_ast::Log` allocation (borrowed from
             // `ctx.log`) that outlives the singleton. `&mut self` only covers the pointer field,
-            // not the pointee. `bun_ast::Log::print` takes `&self` (Zig spec `*const Log`,
-            // logger.zig:1204), so we only need a shared borrow here — the sole invariant is
+            // not the pointee. `bun_ast::Log::print` takes `&self`,
+            // so we only need a shared borrow here — the sole invariant is
             // that no `&mut bun_ast::Log` to the pointee is live, which holds on this path.
             // `IntoLogWrite` is impl'd for `*mut io::Writer`, not `&mut`.
             let _ = self
@@ -924,8 +890,7 @@ impl PackageManager {
         ctx: Command::Context,
         log_level: package_manager_options::LogLevel,
     ) -> Result<&mut transpiler::Transpiler<'static>, Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig `bun.once` caches the `Transpiler` value and returns it on
+        // Compute once and return the cached value on
         // subsequent calls. `Transpiler` is non-`Copy` (and self-referential via
         // `linker.options = &options`), so cache by pointer in a process-static.
         // SAFETY: `PackageManager` is a leaked singleton; main-thread-only call site.
@@ -960,9 +925,8 @@ impl PackageManager {
 
     #[inline]
     pub fn is_continuous_integration(&mut self) -> bool {
-        // PORT NOTE: Zig `LazyBool.get` recovers `*PackageManager` via
-        // `@fieldParentPtr("ci_mode", self)`. Rust has no field-parent-pointer,
-        // so pass the parent explicitly. `ci_mode.value` is a `Cell` so a
+        // `LazyBool::get` needs the parent struct, so pass it
+        // explicitly. `ci_mode.value` is a `Cell` so a
         // shared `&self` projection suffices — both the receiver `&self.ci_mode`
         // and the `&PackageManager` arg are shared reborrows of `*self` and may
         // freely overlap.
@@ -1001,8 +965,8 @@ impl PackageManager {
     /// `isolated_install::Installer::Task::callback`). Never materializes
     /// `&mut PackageManager`, so two task threads finishing simultaneously do
     /// not hold aliased exclusive borrows. `on_wake` is read-only; the handler
-    /// receives the raw `*mut` (Zig's `*PackageManager` carries no exclusivity
-    /// contract); `event_loop.wakeup()` is the cross-thread signal and is
+    /// receives the raw `*mut`;
+    /// `event_loop.wakeup()` is the cross-thread signal and is
     /// internally synchronized — we reach it via `addr_of_mut!` so the `&mut`
     /// covers only the event-loop field, never the whole `PackageManager`.
     ///
@@ -1024,15 +988,12 @@ impl PackageManager {
         }
     }
 
-    /// Spec: PackageManager.zig:424 `sleepUntil(this, closure, isDoneFn)`.
-    ///
     /// Associated fn taking `*mut PackageManager` (NOT `&mut self`): every
     /// `is_done_fn` body in this crate reborrows the *whole* `PackageManager`
     /// from a raw pointer stashed in `C` (`&mut *closure.manager`). If this
     /// were a `&mut self` method, that whole-struct Unique retag would pop
     /// `self`'s tag (and the `&mut self.event_loop` borrow `tick` holds) under
-    /// Stacked Borrows, making the next loop-iteration deref UB. Zig spec has
-    /// no such constraint because Zig `*T` is non-exclusive.
+    /// Stacked Borrows, making the next loop-iteration deref UB.
     ///
     /// SAFETY: `this` must be valid for `&mut` access between callback
     /// invocations; while `is_done_fn` runs, the callback owns the unique
@@ -1043,8 +1004,7 @@ impl PackageManager {
         is_done_fn: fn(&mut C) -> bool,
     ) {
         Output::flush();
-        // PORT NOTE: Zig `sleepUntil(closure: anytype, isDoneFn)` passes a `*Closure` and
-        // a fn-pointer that mutates it. `AnyEventLoop::tick_raw` takes the type-erased
+        // `AnyEventLoop::tick_raw` takes the type-erased
         // `(*mut c_void, fn(*mut c_void) -> bool)`; trampoline through a small wrapper so
         // `is_done_fn` receives `&mut C` and can drive `run_tasks` / record `err`.
         struct Erased<C> {
@@ -1086,10 +1046,9 @@ impl PackageManager {
     }
 
     pub fn ensure_temp_node_gyp_script(&mut self) -> Result<(), Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig `bun.once` caches the `()` result. The body itself is
+        // The body is
         // already idempotent (early-returns when `node_gyp_tempdir_name` is
-        // non-empty), so a simple `AtomicBool` ran-flag matches semantics.
+        // non-empty), so a simple `AtomicBool` ran-flag suffices.
         // NB: not `bun_core::run_once!` — body is fallible and the contract is
         // "2nd call = Ok(()) regardless of 1st outcome" (D006).
         if ENSURE_TEMP_NODE_GYP_SCRIPT_ONCE.swap(true, Ordering::AcqRel) {
@@ -1125,11 +1084,11 @@ impl PackageManager {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// bun.once wrappers
+// run-once wrappers
 // ──────────────────────────────────────────────────────────────────────────
 
 // `Transpiler` is non-`Copy` and self-referential, so cache
-// a process-static raw pointer (mirrors Zig `var ..: Transpiler = undefined;`).
+// a process-static raw pointer.
 // PORTING.md §Global mutable state: init-once ptr → AtomicPtr.
 static CONFIGURE_ENV_FOR_SCRIPTS_ONCE: core::sync::atomic::AtomicPtr<
     transpiler::Transpiler<'static>,
@@ -1144,13 +1103,12 @@ fn configure_env_for_scripts_run(
     // to do that, we re-use the code from bun run
     // this is expensive, it traverses the entire directory tree going up to the root
     // so we really only want to do it when strictly necessary
-    // PORT NOTE: `var this_transpiler: Transpiler = undefined` — Zig leaves it uninit and
-    // RunCommand.configureEnvForRun fully initializes via out-param. Transpiler is NOT
+    // `RunCommand::configure_env_for_run` fully initializes the slot via out-param.
+    // Transpiler is NOT
     // all-zero-valid POD, so `zeroed()` is wrong; use MaybeUninit and assume_init after fill.
     let mut this_transpiler_slot =
         core::mem::MaybeUninit::<transpiler::Transpiler<'static>>::uninit();
-    // Zig spec PackageManager.zig:322 passes `this.env` (a `*DotEnv.Loader`).
-    // `self.env` is `Option<BackRef<Loader>>` here; pass the raw pointer so
+    // `self.env` is `Option<BackRef<Loader>>`; pass the raw pointer so
     // the shim's `Transpiler::init` reuses the manager's loader instead of
     // allocating a fresh singleton.
     let env_ptr: Option<*mut dot_env::Loader<'static>> = this.env.map(|p| p.as_ptr());
@@ -1163,8 +1121,7 @@ fn configure_env_for_scripts_run(
     )?;
     // SAFETY: the install-tier `RunCommand::configure_env_for_run` shim
     // (lib.rs) `.write()`s the slot via `Transpiler::init` before returning
-    // `Ok` — same contract as the runtime impl (run_command.rs:628) and the
-    // Zig spec (run_command.zig:780 `this_transpiler.* = try Transpiler.init(...)`).
+    // `Ok` — same contract as the runtime impl (run_command.rs:628).
     let this_transpiler = unsafe { this_transpiler_slot.assume_init() };
 
     let init_cwd_entry = this.env_mut().map.get_or_put_without_value(b"INIT_CWD")?;
@@ -1177,7 +1134,7 @@ fn configure_env_for_scripts_run(
         };
     }
 
-    // Zig passes `this_transpiler.fs` (`*Fs.FileSystem`); the resolver-tier
+    // The resolver-tier
     // `FileSystem` mirrors `bun_paths::fs::FileSystem` for `top_level_dir`.
     let paths_fs = bun_paths::fs::FileSystem::instance();
     this.env_mut().load_ccache_path(paths_fs);
@@ -1268,9 +1225,8 @@ fn ensure_temp_node_gyp_script_run(manager: &mut PackageManager) -> Result<(), E
     #[cfg(not(windows))]
     const MODE: u32 = 0o755;
 
-    // Zig: `node_gyp_tempdir.createFile(file_name, .{ .mode = mode })`.
-    // `bun_sys::Dir` has no `create_file`; route through `File::openat` with the
-    // same flags `std.fs.Dir.createFile` uses (`O_WRONLY|O_CREAT|O_TRUNC`).
+    // `bun_sys::Dir` has no `create_file`; route through `File::openat` with
+    // create-file flags (`O_WRONLY|O_CREAT|O_TRUNC`).
     let node_gyp_file = match bun_sys::File::openat(
         node_gyp_tempdir.fd,
         FILE_NAME.as_bytes(),
@@ -1309,7 +1265,6 @@ fn ensure_temp_node_gyp_script_run(manager: &mut PackageManager) -> Result<(), E
     );
 
     if let Err(e) = node_gyp_file.write_all(CONTENT.as_bytes()) {
-        // Zig: "..." ++ file_name ++ " file" — comptime concat, no runtime alloc
         bun_core::pretty_errorln!(
             "<r><red>error<r>: <b><red>{}<r> writing to {} file",
             bstr::BStr::new(e.name()),
@@ -1358,7 +1313,7 @@ fn ensure_temp_node_gyp_script_run(manager: &mut PackageManager) -> Result<(), E
 }
 
 fn http_thread_on_init_error(err: http::InitError, opts: &http::http_thread::InitOpts) -> ! {
-    // `opts.abs_ca_file_name` is Zig `stringZ` (`[:0]const u8`) by contract —
+    // `opts.abs_ca_file_name` is NUL-terminated by contract —
     // populated in `init()` from a `ZBox` via `into_vec_with_nul()`, so the
     // stored slice length INCLUDES the trailing NUL. Re-derive the `&ZStr`
     // (NUL-stripped) once and use it for both the path resolver and the error
@@ -1410,8 +1365,7 @@ fn http_thread_on_init_error(err: http::InitError, opts: &http::http_thread::Ini
 // ──────────────────────────────────────────────────────────────────────────
 
 pub(crate) fn allocate_package_manager() {
-    // Zig: `bun.handleOom(bun.default_allocator.create(PackageManager))` — uninitialized
-    // memory, abort-on-OOM. The init() functions below write the full struct via
+    // Uninitialized memory, abort-on-OOM. The init() functions below write the full struct via
     // `core::ptr::write` (no Drop on the uninit bytes).
     let ptr =
         bun_core::heap::into_raw(Box::<PackageManager>::new_uninit()).cast::<PackageManager>();
@@ -1436,10 +1390,10 @@ extern "C" fn deinit_caches_at_exit() {
     unsafe { (*ptr).deinit_caches() };
 }
 
-/// Returns the raw singleton pointer (Zig: `pub fn get() *PackageManager`).
+/// Returns the raw singleton pointer.
 ///
-/// Intentionally returns `*mut` rather than `&'static mut`: Zig's `*T` freely
-/// aliases, and this accessor is invoked from thread-pool workers
+/// Intentionally returns `*mut` rather than `&'static mut`: this accessor is
+/// invoked from thread-pool workers
 /// (`UninstallTask::run`, npm `SaveTask`, `Repository` git ops) concurrently
 /// with the main thread holding the `&mut PackageManager` returned by `init()`.
 /// Materializing `&'static mut` here would create aliased mutable references
@@ -1458,7 +1412,7 @@ pub fn get() -> *mut PackageManager {
 
 /// Returns `&'static mut PackageManager` — the process-singleton (held in
 /// `holder::RAW_PTR`) is leaked for the process lifetime and `init()` is called
-/// exactly once on the single CLI dispatch thread (PackageManager.zig:568). Every
+/// exactly once on the single CLI dispatch thread. Every
 /// CLI command immediately reborrows the result as `&mut` for the command's
 /// duration; centralising the deref here removes a dozen identical
 /// `unsafe { &mut *ptr }` blocks at call sites.
@@ -1473,9 +1427,8 @@ pub fn init(
     cli: CommandLineArguments,
     subcommand: Subcommand,
 ) -> Result<(&'static mut PackageManager, Box<[u8]>), Error> {
-    // TODO(port): narrow error set
     if cli.global {
-        // Zig: `if (ctx.install) |opts|` — non-consuming peek. `ctx.install` is
+        // Non-consuming peek: `ctx.install` is
         // `Option<Box<BunInstall>>` borrowed via `&mut ContextData`; reborrow with
         // `as_deref()` so the boxed config remains in `ctx` for the
         // `get_or_insert_with` calls below (npmrc loading).
@@ -1484,11 +1437,10 @@ pub fn init(
             explicit_global_dir = opts.global_dir.as_deref().unwrap_or(explicit_global_dir);
         }
         let global_dir = package_manager_options::open_global_dir(explicit_global_dir)?;
-        // Zig: `global_dir.setAsCwd()` → `fchdir`.
         bun_sys::fchdir(global_dir)?;
     }
 
-    // Zig: `Fs.FileSystem.init(null)` — registers the resolver-tier singleton
+    // Registers the resolver-tier singleton
     // and seeds `top_level_dir` from `getcwd`.
     bun_resolver::fs::FileSystem::init(None)?;
     let fs = FileSystem::instance();
@@ -1519,7 +1471,7 @@ pub fn init(
         let _ = cwd_ptr;
     }
 
-    // Zig: comptime `sep_str ++ "package.json"` — per-cfg const literal, no runtime alloc.
+    // Per-cfg const literal, no runtime alloc.
     #[cfg(windows)]
     const SEP_PACKAGE_JSON: &[u8] = b"\\package.json";
     #[cfg(not(windows))]
@@ -1527,7 +1479,6 @@ pub fn init(
 
     let mut original_package_json_path_buf: Vec<u8> =
         Vec::with_capacity(top_level_dir_no_trailing_slash.len() + SEP_PACKAGE_JSON.len() + 1);
-    // PERF(port): was assume_capacity
     original_package_json_path_buf.extend_from_slice(top_level_dir_no_trailing_slash);
     original_package_json_path_buf.extend_from_slice(SEP_PACKAGE_JSON);
     original_package_json_path_buf.push(0);
@@ -1615,8 +1566,7 @@ pub fn init(
                         Global::crash();
                     }
                     Err(e) => {
-                        // Zig: `Output.err(err, "could not open \"{s}\"", .{path})` —
-                        // `bun.Output.err` accepts an error value directly.
+                        // `Output::err` accepts an error value directly.
                         Output::err(
                             &e,
                             "could not open \"{s}\"",
@@ -1631,10 +1581,8 @@ pub fn init(
                 if cli.positionals.len() > 1 {
                     // this is `bun add <package>`.
                     //
-                    // create the package json instead of return error. this works around
-                    // a zig bug where continuing control flow through a catch seems to
-                    // cause a segfault the second time `PackageManager.init` is called after
-                    // switching to the add command.
+                    // create the package.json instead of returning an error so that
+                    // `bun add <pkg>` works in an empty directory.
                     this_cwd = original_cwd;
                     created_package_json = true;
                     break 'child attempt_to_create_package_json_and_open()?;
@@ -1649,7 +1597,6 @@ pub fn init(
             true,
         ));
         original_package_json_path_buf.truncate(this_cwd.len());
-        // PERF(port): was assume_capacity
         original_package_json_path_buf.push(SEP);
         original_package_json_path_buf.extend_from_slice(b"package.json");
         original_package_json_path_buf.push(0);
@@ -1659,7 +1606,6 @@ pub fn init(
         original_package_json_path =
             ZStr::from_buf(&original_package_json_path_buf[..], new_path_len);
         let child_cwd = &original_package_json_path.as_bytes()[..this_cwd.len()];
-        // PORT NOTE: reshaped — Zig uses withoutSuffixComptime(.., sep_str ++ "package.json")
 
         // Check if this is a workspace; if so, use root package
         if subcommand.should_chdir_to_root() {
@@ -1702,7 +1648,6 @@ pub fn init(
                     let json_source =
                         bun_ast::Source::init_path_string(&*json_path, &json_buf[..json_len]);
                     initialize_store();
-                    // Zig threads `ctx.allocator`; the Rust JSON parser takes a bump arena.
                     let json_arena = bun_alloc::Arena::new();
                     // SAFETY: `ctx.log` is a borrow of the CLI's `Log`; valid for the
                     // duration of `init()` (set by `Command::create()` before any install
@@ -1784,7 +1729,6 @@ pub fn init(
                             let maybe_workspace_path = child_path;
 
                             if strings::eql_long(maybe_workspace_path, path_, true) {
-                                // Zig: `fs.top_level_dir = try allocator.dupeZ(u8, parent)`.
                                 // Intern via the resolver's DirnameStore so the slice is
                                 // process-lifetime (`set_top_level_dir` requires `'static`).
                                 fs.set_top_level_dir(fs.dirname_store().append(parent)?);
@@ -1807,18 +1751,14 @@ pub fn init(
             }
         }
 
-        // Zig: `fs.top_level_dir = try allocator.dupeZ(u8, child_cwd)`.
         // Intern via DirnameStore so the slice is process-lifetime.
         fs.set_top_level_dir(fs.dirname_store().append(child_cwd)?);
         break 'root_package_json_file child_json;
     };
 
-    // Zig: `try bun.sys.chdir(fs.top_level_dir, fs.top_level_dir).unwrap()` —
-    // `bun_sys::chdir` takes a single `&ZStr` in the Rust port.
     let top_level_dir_z = ZBox::from_bytes(fs.top_level_dir());
     bun_sys::chdir(&top_level_dir_z)?;
-    // Zig: `try bun.cli.Arguments.loadConfig(ctx.allocator, cli.config, ctx, .InstallCommand);`
-    // (PackageManager.zig:801). `loadConfig` was moved down into `bun_bunfig`
+    // `loadConfig` was moved down into `bun_bunfig`
     // (MOVE_DOWN b0) so install can call it directly — no fn-pointer hook.
     // (`::`-qualified because `crate::bun_bunfig` is a legacy local shim mod.)
     ::bun_bunfig::arguments::load_config(
@@ -1832,13 +1772,12 @@ pub fn init(
         let cwd = &mut *CWD_BUF.get();
         cwd[..tld.len()].copy_from_slice(tld);
         cwd[tld.len()] = 0;
-        // Zig: `fs.top_level_dir = cwd_buf[0..len :0]` (PackageManager.zig:776).
         // Route through the FsVTable setter so the resolver's cached cwd is
         // rebound to the process-lifetime CWD_BUF (it was a transient slice
         // until now). The slice excludes the NUL — `top_level_dir` is `[]u8`.
         // PathBuffer is repr(transparent) over [u8; N], so the raw cast is sound.
         fs.set_top_level_dir(bun_core::ffi::slice(CWD_BUF.get().cast::<u8>(), tld.len()));
-        // Zig: `bun.getFdPathZ(file, &buf)` — bun_sys exposes the non-Z form;
+        // bun_sys exposes the non-Z `get_fd_path`;
         // append the NUL ourselves so the static `&ZStr` invariant holds.
         let root_buf = &mut *ROOT_PACKAGE_JSON_PATH_BUF.get();
         let p = bun_sys::get_fd_path(root_package_json_file.handle, root_buf)?;
@@ -1847,8 +1786,7 @@ pub fn init(
         ROOT_PACKAGE_JSON_PATH.write(ZStr::from_raw(root_buf.as_ptr(), plen));
     }
 
-    // Zig: `try fs.fs.readDirectory(fs.top_level_dir, null, 0, true)`
-    // (PackageManager.zig:779). Returns the resolver's BSSMap-owned
+    // Returns the resolver's BSSMap-owned
     // `*EntriesOption` slot.
     let entries_option = match fs.read_directory(fs.top_level_dir(), 0, true)? {
         fs::EntriesOption::Entries(e) => {
@@ -1863,7 +1801,7 @@ pub fn init(
     // SAFETY: `init()` runs once on the main thread before any other access to the singleton.
     // `dot_env::Loader<'a>` borrows `&'a mut Map`, so the pair is self-referential; allocate
     // both into process-lifetime statics (same allocate-then-fill pattern as `holder::RAW_PTR`)
-    // instead of `Box::leak`. Zig: `ctx.allocator.create(dot_env::Map)` + `create(dot_env::Loader)`.
+    // instead of `Box::leak`.
     let env: &mut dot_env::Loader = unsafe {
         let map_ptr = bun_core::heap::alloc(dot_env::Map::init());
         holder::ENV_MAP.store(map_ptr);
@@ -1874,8 +1812,7 @@ pub fn init(
     };
 
     env.load_process()?;
-    // Zig: `try env.load(entries_option.entries, &[_][]u8{}, .production, false)`
-    // (PackageManager.zig:794). Reborrow the BSSMap-owned `*DirEntry` for the
+    // Reborrow the BSSMap-owned `*DirEntry` for the
     // call; `env.load` only reads it (`hasComptimeQuery` lookups for `.env*`).
     env.load(
         // SAFETY: see `entries_option` above — single-threaded init, BSSMap-owned.
@@ -1895,8 +1832,8 @@ pub fn init(
         let parts = [b"./.npmrc" as &[u8]];
 
         let install_ref = ctx.install.get_or_insert_with(|| {
-            // `Api::BunInstall` derives `Default` (all fields `None`/empty), matching
-            // Zig's `std.mem.zeroes(Api.BunInstall)`. Own via `Box` — never `Box::leak`.
+            // `Api::BunInstall` derives `Default` (all fields `None`/empty).
+            // Own via `Box` — never `Box::leak`.
             Box::new(Api::BunInstall::default())
         });
         let npmrc_local = ZBox::from_bytes(b".npmrc");
@@ -1911,8 +1848,8 @@ pub fn init(
         );
     } else {
         let install_ref = ctx.install.get_or_insert_with(|| {
-            // `Api::BunInstall` derives `Default` (all fields `None`/empty), matching
-            // Zig's `std.mem.zeroes(Api.BunInstall)`. Own via `Box` — never `Box::leak`.
+            // `Api::BunInstall` derives `Default` (all fields `None`/empty).
+            // Own via `Box` — never `Box::leak`.
             Box::new(Api::BunInstall::default())
         });
         let npmrc_local = ZBox::from_bytes(b".npmrc");
@@ -1966,9 +1903,8 @@ pub fn init(
     // `HiveArrayFallback` pools inline (`NetworkTask` × 128 ≈ 395 KB,
     // `Task` × 64 ≈ 39 KB). The by-value form was measured at a 911 KB stack
     // frame (objdump: `subq $0xde000,%r11` probe loop, ≈220 page faults) plus
-    // a ≈443 KB memcpy into the singleton. Zig's `manager.* = .{...}` writes
-    // fields directly to the heap (RLS); per-field placement mirrors that and
-    // keeps the frame under 16 KB.
+    // a ≈443 KB memcpy into the singleton. Per-field placement writes fields
+    // directly to the heap and keeps the frame under 16 KB.
     unsafe {
         let p = manager_ptr;
         macro_rules! wr {
@@ -1994,9 +1930,8 @@ pub fn init(
             crate::lifecycle_script_runner::List {
                 root: core::ptr::null_mut(),
                 // `lifecycle_script_runner::List`'s heap comparator never
-                // dereferences its Zig `*PackageManager` context arg, so the
-                // Rust port models it as a ZST (`StartedAtCtx`) instead of
-                // threading a back-pointer.
+                // dereferences its context arg, so it is modeled as a ZST
+                // (`StartedAtCtx`) instead of threading a back-pointer.
                 context: crate::lifecycle_script_runner::StartedAtCtx,
             }
         );
@@ -2005,10 +1940,9 @@ pub fn init(
         wr!(log, ctx.log);
         wr!(root_dir, entries_option);
         wr!(ast_arena, bun_alloc::Arena::new());
-        // PORT NOTE: reborrow `&mut *env` so the local stays usable for
+        // reborrow `&mut *env` so the local stays usable for
         // the post-construction `BUN_MANIFEST_CACHE` / `options.load`
-        // reads (Zig PackageManager.zig:910 keeps using `env` after
-        // storing it in the struct). `BackRef` stores a raw pointer —
+        // reads. `BackRef` stores a raw pointer —
         // ending the reborrow here does not alias the later uses.
         wr!(env, Some(bun_ptr::BackRef::new_mut(&mut *env)));
         wr!(cpu_count, cpu_count);
@@ -2020,9 +1954,7 @@ pub fn init(
             })
         );
         wr!(resolve_tasks, ResolveTaskQueue::default());
-        // Zig: `.lockfile = undefined` (uninit `*Lockfile`), then
-        // `manager.lockfile = try allocator.create(Lockfile)` immediately after the
-        // struct literal. `Lockfile` contains `HashMap`/`Vec`/`NonNull` fields, so a
+        // `Lockfile` contains `HashMap`/`Vec`/`NonNull` fields, so a
         // zero-bit pattern is UB; allocate the real (empty) lockfile here directly.
         // `Lockfile::default()` ≡ `Lockfile::init_empty()`.
         wr!(lockfile, Box::new(Lockfile::default()));
@@ -2077,7 +2009,6 @@ pub fn init(
         wr!(total_scripts, 0);
         wr!(root_lifecycle_scripts, None);
         wr!(node_gyp_tempdir_name, Box::default());
-        wr!(env_configure, None);
         wr!(preinstall_state, Vec::new());
         wr!(postinstall_optimizer, Default::default());
         wr!(global_link_dir, None);
@@ -2102,16 +2033,14 @@ pub fn init(
     }
     holder::INITIALIZED.store(true, core::sync::atomic::Ordering::Release);
     // The per-field placement above fully initialized the singleton; the
-    // `&mut PackageManager` validity invariant now holds (Zig PackageManager.zig:850
-    // onward). We do NOT bind a long-lived `&'static mut` here: `http::HTTPThread::init`
+    // `&mut PackageManager` validity invariant now holds.
+    // We do NOT bind a long-lived `&'static mut` here: `http::HTTPThread::init`
     // below spawns workers that deref `get()` concurrently, which would alias such a
     // borrow under Stacked Borrows. Instead each statement forms its own narrowly-scoped
     // reborrow via `unsafe { &mut *manager_ptr }`, dropped before the next raw-ptr use.
     {
         // SAFETY: singleton fully initialized; main thread, no workers yet.
         let manager = unsafe { &mut *manager_ptr };
-        // Zig: `manager.event_loop.loop().internal_loop_data.setParentEventLoop(
-        //     jsc.EventLoopHandle.init(&manager.event_loop))` (PackageManager.zig:883).
         // `r#loop()` returns the process-global `*mut uws::Loop`; build the
         // handle from `&mut manager.event_loop` and write it back as the loop's
         // parent so uSockets timers / lifecycle subprocess waiters can find the
@@ -2122,14 +2051,13 @@ pub fn init(
         let uws_loop = unsafe { &mut *uws_loop };
         EventLoopHandle::from_any(&mut manager.event_loop).set_as_parent_of(uws_loop);
     }
-    // PORT NOTE: Zig `manager.lockfile = try ctx.allocator.create(Lockfile)` —
-    // folded into the struct literal above (`Box::new(Lockfile::default())`) so
-    // we never construct a zeroed `Lockfile` only to drop it.
+    // The lockfile allocation is folded into the struct literal above
+    // (`Box::new(Lockfile::default())`) so we never construct a zeroed
+    // `Lockfile` only to drop it.
 
     {
         // make sure folder packages can find the root package without creating a new one
-        // Zig: `var normalized: AbsPath(.{ .sep = .posix }) = .from(root_package_json_path)`
-        // (PackageManager.zig:888). `AbsPath(.{.sep=.posix}).from` posix-normalizes the
+        // Posix-normalize the
         // separators before hashing; `FolderResolution.hash` is always fed `/`-separated
         // bytes by every resolver-side caller. On Windows `getFdPath` yields `\`, so
         // hashing the raw bytes would seed a key the resolver never looks up — copy into
@@ -2148,15 +2076,14 @@ pub fn init(
         // normalized.deinit() → Drop (stack buffer)
     }
 
-    // Zig: `jsc.MiniEventLoop.global = &manager.event_loop.mini` — set the
-    // thread-local global to point at the embedded mini loop. The Rust port
-    // stores it in `bun_event_loop::mini_event_loop::GLOBAL`.
+    // Set the thread-local global to point at the embedded mini loop
+    // (`bun_event_loop::mini_event_loop::GLOBAL`).
     {
         // SAFETY: singleton fully initialized; main thread, no workers yet.
         let evl = unsafe { &mut (*manager_ptr).event_loop };
         if let AnyEventLoop::Mini(mini) = evl {
             let mini_ptr: *mut MiniEventLoop<'static> = &raw mut **mini;
-            // Zig spec (PackageManager.zig:893) sets ONLY `MiniEventLoop.global`,
+            // Set ONLY `MiniEventLoop.global`,
             // NOT `globalInitialized`. The distinction is load-bearing: a later
             // `initGlobal(env, top_level_dir)` (e.g. from `bun pm pack` /
             // `pm version` lifecycle scripts → RunCommand::run_package_script_*)
@@ -2256,7 +2183,6 @@ pub fn init(
             }
 
             // If any HTTP proxy is set, use a diferent limit
-            // (env_loader.zig:167 hasHTTPProxy — PackageManager.zig open-codes this)
             if env.has_http_proxy() {
                 break 'brk DEFAULT_MAX_SIMULTANEOUS_REQUESTS_FOR_BUN_INSTALL_FOR_PROXIES;
             }
@@ -2268,8 +2194,8 @@ pub fn init(
 
     // `InitOpts.ca: Vec<*const c_void>` (erased `[*:0]const u8`). The HTTP
     // thread reads these asynchronously after `init` returns, so park the
-    // owning `ZBox`es in `holder::CA` for process lifetime (Zig: `dupeZ`,
-    // never freed) and project the pointers from there.
+    // owning `ZBox`es in `holder::CA` for process lifetime (never freed)
+    // and project the pointers from there.
     let ca_ptrs: Vec<*const c_void> = if ca.is_empty() {
         Vec::new()
     } else {
@@ -2280,7 +2206,7 @@ pub fn init(
             .unwrap_or_default()
     };
     // `InitOpts.abs_ca_file_name: &'static [u8]` — process-lifetime config
-    // string (Zig: `allocator.dupeZ` into a leaked singleton field). Park it in
+    // string. Park it in
     // `holder::ABS_CA_FILE_NAME: OnceLock<Box<[u8]>>` per PORTING.md §Forbidden
     // (never `Box::leak` to mint `&'static`). `init()` runs once on
     // the main thread, so `.set()` cannot race; ignore the already-set case for
@@ -2302,7 +2228,7 @@ pub fn init(
     let timestamp_for_manifest_cache_control: u32 = 'brk: {
         if cfg!(debug_assertions) {
             if let Some(cache_control) = env.get(b"BUN_CONFIG_MANIFEST_CACHE_CONTROL_TIMESTAMP") {
-                // env-var bytes are not guaranteed UTF-8; parse on bytes directly (Zig: std.fmt.parseInt)
+                // env-var bytes are not guaranteed UTF-8; parse on bytes directly
                 if let Ok(int) = bun_core::parse_int::<u32>(cache_control, 10) {
                     break 'brk int;
                 }
@@ -2330,8 +2256,7 @@ pub fn init(
 
 pub(crate) fn init_with_runtime(
     log: &mut bun_ast::Log,
-    // Spec PackageManager.zig:983 `bun_install: ?*Api.BunInstall` — used read-only
-    // (PackageManagerOptions.zig:load lines 224-380 only ever reads `config.*`).
+    // Used read-only (`Options::load` only ever reads `config.*`).
     // Upstream storage is `Option<NonNull<api::BunInstall>>` (bundler + resolver
     // opts); taking `&mut` here would force a const→mut provenance launder at
     // the resolver call site.
@@ -2363,14 +2288,12 @@ pub(crate) fn init_with_runtime_once(
     // (`Box`, `Vec`, `Option<NonNull<_>>`, `ZStr`) for which the uninit bit
     // pattern is an invalid value, so materializing a reference is instant UB.
     // Work through the raw pointer until `ptr::write` below has fully
-    // initialized it (Zig PackageManager.zig:1013 `const manager = get()`
-    // yields a raw `*PackageManager` with no validity invariant).
+    // initialized it.
     let manager_ptr: *mut PackageManager =
         holder::RAW_PTR.load(core::sync::atomic::Ordering::Acquire);
-    // Zig: `FileSystem.instance.fs.readDirectory(top_level_dir, null, 0, true)`
-    // (PackageManager.zig:1014). Returns the resolver's BSSMap-owned
-    // `*EntriesOption` slot. On error Zig calls `Output.err` then `@panic`
-    // (lines 1019-1022) — match that: this is the runtime auto-install path
+    // Returns the resolver's BSSMap-owned
+    // `*EntriesOption` slot. On error, `Output::err` then panic:
+    // this is the runtime auto-install path
     // where the resolver already opened `top_level_dir`, so failure is a
     // programmer-error / fs-disappeared edge.
     let fs_instance = FileSystem::instance();
@@ -2418,8 +2341,8 @@ pub(crate) fn init_with_runtime_once(
     // field-by-field via `addr_of_mut!((*p).field).write(..)`. See the PERF
     // NOTE in `init()` above — building `PackageManager` by value and
     // `ptr::write`ing it materialized a ≈911 KB stack frame because of the
-    // two inline `HiveArrayFallback` pools; per-field placement mirrors Zig's
-    // result-location semantics and writes directly to the heap singleton.
+    // two inline `HiveArrayFallback` pools; per-field placement writes
+    // directly to the heap singleton.
     unsafe {
         let p = manager_ptr;
         macro_rules! wr {
@@ -2458,10 +2381,9 @@ pub(crate) fn init_with_runtime_once(
         wr!(log, std::ptr::from_mut(log));
         wr!(root_dir, root_dir);
         wr!(ast_arena, bun_alloc::Arena::new());
-        // PORT NOTE: reborrow `&mut *env` so the local stays usable for
+        // reborrow `&mut *env` so the local stays usable for
         // the post-construction `BUN_MANIFEST_CACHE` / `options.load`
-        // reads (Zig PackageManager.zig:1072 keeps using `env` after
-        // storing it in the struct). `BackRef` stores a raw pointer —
+        // reads. `BackRef` stores a raw pointer —
         // ending the reborrow here does not alias the later uses.
         wr!(env, Some(bun_ptr::BackRef::new_mut(&mut *env)));
         wr!(cpu_count, cpu_count);
@@ -2472,12 +2394,11 @@ pub(crate) fn init_with_runtime_once(
                 ..Default::default()
             })
         );
-        // Zig: `.lockfile = undefined` then `manager.lockfile = try allocator.create(Lockfile)`
-        // immediately after. `Lockfile` holds `HashMap`/`Vec`/`NonNull` (zero-bit pattern is
+        // `Lockfile` holds `HashMap`/`Vec`/`NonNull` (zero-bit pattern is
         // UB), so allocate the real empty lockfile here directly instead of a zeroed placeholder.
         wr!(lockfile, Box::new(Lockfile::default()));
-        // Zig leaves `.root_package_json_file = undefined` (never read in the runtime
-        // path). Use the explicit invalid-fd sentinel rather than `mem::zeroed()` —
+        // `.root_package_json_file` is never read in the runtime
+        // path. Use the explicit invalid-fd sentinel rather than `mem::zeroed()` —
         // on posix `Fd(0)` is stdin, not the invalid marker.
         wr!(
             root_package_json_file,
@@ -2531,7 +2452,6 @@ pub(crate) fn init_with_runtime_once(
         wr!(total_scripts, 0);
         wr!(root_lifecycle_scripts, None);
         wr!(node_gyp_tempdir_name, Box::default());
-        wr!(env_configure, None);
         wr!(preinstall_state, Vec::new());
         wr!(postinstall_optimizer, Default::default());
         wr!(global_link_dir, None);
@@ -2562,10 +2482,10 @@ pub(crate) fn init_with_runtime_once(
     holder::INITIALIZED.store(true, core::sync::atomic::Ordering::Release);
     // SAFETY: per-field placement above fully initialized the PackageManager;
     // the `&mut PackageManager` validity invariant now holds for the post-init
-    // body (Zig PackageManager.zig:1031 onward).
+    // body.
     let manager = unsafe { &mut *manager_ptr };
-    // PORT NOTE: Zig `manager.lockfile = try allocator.create(Lockfile)` —
-    // folded into the struct literal above (`Box::new(Lockfile::default())`).
+    // The lockfile allocation is folded into the struct literal above
+    // (`Box::new(Lockfile::default())`).
 
     if Output::enable_ansi_colors_stderr() {
         manager.progress = Progress::default();
@@ -2615,17 +2535,15 @@ pub(crate) fn init_with_runtime_once(
             // When using bun, we only do staleness checks once per day
             .saturating_sub(bun_core::time::S_PER_DAY);
 
-    // Zig (PackageManager.zig:1111): `if (root_dir.entries.hasComptimeQuery("bun.lockb"))`
-    // — gate the disk load on the cached dir listing so the runtime auto-install
-    // path doesn't open()/read() a lockfile that isn't there. The Zig
-    // `manager.lockfile = load.lockfile` self-assignment is a no-op in the Rust
-    // shape (`load_from_cwd` mutates `*manager.lockfile` in place and returns a
-    // borrow of it), so `Ok` keeps the loaded value as-is.
-    // PORT NOTE: Zig calls `manager.lockfile.loadFromCwd(manager, …)` — a
+    // Gate the disk load on the cached dir listing so the runtime auto-install
+    // path doesn't open()/read() a lockfile that isn't there.
+    // `load_from_cwd` mutates `*manager.lockfile` in place and returns a
+    // borrow of it, so `Ok` keeps the loaded value as-is.
+    // `Lockfile::load_from_cwd(manager, …)` is a
     // self-aliasing receiver+argument pair Rust forbids. Split-borrow by
     // temporarily moving the boxed lockfile out so the `&mut PackageManager`
     // passed in does not alias the `&mut Lockfile` receiver.
-    // PORT NOTE: `root_dir` was moved into `*manager` above (the field is
+    // `root_dir` was moved into `*manager` above (the field is
     // an unbounded `&mut DirEntry`, so the local reborrow is for `'static` and the
     // original binding is dead). Read it back through `manager.root_dir`.
     if manager.root_dir.has_comptime_query(b"bun.lockb") {
@@ -2639,5 +2557,3 @@ pub(crate) fn init_with_runtime_once(
         manager.lockfile.init_empty();
     }
 }
-
-// ported from: src/install/PackageManager.zig
diff --git a/src/install/PackageManager/CommandLineArguments.rs b/src/install/PackageManager/CommandLineArguments.rs
index 7bfdaac38c7..91f10e1d562 100644
--- a/src/install/PackageManager/CommandLineArguments.rs
+++ b/src/install/PackageManager/CommandLineArguments.rs
@@ -11,23 +11,21 @@
 //! - bun audit
 
 use crate::package_install;
+use crate::package_manager_real::PackageManagerCommand;
 use crate::package_manager_real::Subcommand;
 use bun_clap as clap;
 use bun_core::strings;
 use bun_core::{Global, Output};
 use bun_install::npm as Npm;
 use bun_paths::{self as Path, PathBuffer};
-// TODO(port): PackageManagerCommand arrives from move-in
-// (bun_runtime::cli::package_manager_command::PackageManagerCommand → install::PackageManager::CommandLineArguments).
-use crate::package_manager_real::PackageManagerCommand;
 
 use std::sync::OnceLock;
 
 use super::package_manager_options as Options;
 
 /// `Output.pretty(text, .{})` — runtime `<tag>` → ANSI rewrite of a help-text
-/// literal then write to stdout. The Zig version did this at comptime; here the
-/// help strings are runtime `&str`s so we use the runtime expander.
+/// literal then write to stdout. The help strings are runtime `&str`s so we
+/// use the runtime expander.
 #[inline]
 #[allow(clippy::disallowed_methods)] // template is a runtime &str parameter
 fn pretty_help(text: &str) {
@@ -39,16 +37,13 @@ fn pretty_help(text: &str) {
 
 type ParamType = clap::Param<clap::Help>;
 
-// Zig `++` does comptime array concatenation. `bun_clap::concat_params!` is a
-// const-fn slice concat over `Param<Help>`, so combined tables
+// `bun_clap::concat_params!` is a const-fn slice concat over `Param<Help>`, so combined tables
 // (`INSTALL_PARAMS`, …) are baked into rodata with zero runtime init.
 use bun_clap::concat_params;
 
-// PORT NOTE: Zig builds the `--backend` param spec via comptime string `++` against
-// `platform_specific_backend_label`. `clap::param!` is a proc-macro that requires a
+// `clap::param!` is a proc-macro that requires a
 // *literal* token (it parses the spec at compile time), so `const_format::concatcp!`
-// can't feed it. Instead we cfg-select the fully-expanded literal per platform —
-// semantically identical to the Zig comptime concat.
+// can't feed it. Instead we cfg-select the fully-expanded literal per platform.
 #[cfg(target_os = "macos")]
 const BACKEND_PARAM: ParamType = clap::param!(
     "--backend <STR>                       Platform-specific optimizations for installing dependencies. Possible values: \"clonefile\" (default), \"hardlink\", \"symlink\", \"copyfile\""
@@ -354,10 +349,10 @@ static WHY_PARAMS: &[ParamType] = concat_params![
 
 // NOTE: `string` (= `[]const u8`) fields here are slices into process argv (owned by `clap::Args`
 // which itself lives for the program duration). They are never freed. Mapped to `&'static [u8]`
-// per PORTING.md (no `deinit`, never `allocator.free`d). TODO(refactor): thread an explicit
-// lifetime if `clap::Args` ever becomes scoped.
+// per PORTING.md (no `deinit`, never `allocator.free`d). An explicit lifetime would only
+// become necessary if `clap::Args` ever becomes scoped.
 //
-// `Clone` mirrors Zig value-copy semantics — `updatePackageJSONAndInstall`
+// `Clone` is needed because `updatePackageJSONAndInstall`
 // passes `cli` by value into `PackageManager.init` while retaining its own
 // copy.
 #[derive(Clone)]
@@ -974,9 +969,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/pm#scan<r>.
         }
     }
 
-    // TODO(port): narrow error set
     pub fn parse(subcommand: Subcommand) -> Result<CommandLineArguments, bun_core::Error> {
-        // PERF(port): was comptime monomorphization on `subcommand` — profile if hot
         Output::set_is_verbose(Output::is_verbose());
 
         let params: &'static [ParamType] = match subcommand {
@@ -1003,12 +996,11 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/pm#scan<r>.
 
         let mut diag = clap::Diagnostic::default();
 
-        // PORT NOTE: Zig kept `args` (and its arena) alive for the program duration —
+        // `args` must stay alive for the program duration —
         // `cli` stores slices into it. Park the parsed `Args` in a process-global
         // `OnceLock` so outer slice borrows (`positionals()`, `options()`) are
         // `'static`; inner `&[u8]` are argv-backed and already `'static`. CLI args
-        // are parsed exactly once per process, so this is the semantic equivalent
-        // of the Zig arena that was never `deinit`'d.
+        // are parsed exactly once per process.
         static PARSED_ARGS: OnceLock<clap::Args<clap::Help>> = OnceLock::new();
         let args: &'static clap::Args<clap::Help> = match clap::parse::<clap::Help>(
             params,
@@ -1461,5 +1453,3 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/pm#scan<r>.
         Ok(cli)
     }
 }
-
-// ported from: src/install/PackageManager/CommandLineArguments.zig
diff --git a/src/install/PackageManager/PackageJSONEditor.rs b/src/install/PackageManager/PackageJSONEditor.rs
index e442503f521..9ed87945fee 100644
--- a/src/install/PackageManager/PackageJSONEditor.rs
+++ b/src/install/PackageManager/PackageJSONEditor.rs
@@ -42,8 +42,7 @@ fn arena_dup<'a>(arena: &'a bun_alloc::Arena, bytes: &[u8]) -> &'a [u8] {
 /// Shallow-copy a `G::Property` for the JSON-editing path. Only `key`/`value`
 /// (both `Option<Expr>`, `Copy`) are populated by the JSON parser; the rest
 /// (`ts_decorators`, `class_static_block`, …) are always default for parsed
-/// `package.json` and would be discarded by Zig's bitwise `@memcpy` + arena
-/// reset anyway.
+/// `package.json`.
 #[inline]
 fn copy_property(p: &G::Property) -> G::Property {
     G::Property {
@@ -64,8 +63,7 @@ pub(crate) fn edit_patched_dependencies(
     let mut patched_dependencies = E::Object::default();
     if let Some(query) = package_json.as_property(b"patchedDependencies") {
         if let bun_ast::ExprData::EObject(obj) = &query.expr.data {
-            // Zig dereferences `query.expr.data.e_object.*` to bit-copy the whole
-            // E.Object — preserve the formatting fields so the printed
+            // Preserve the formatting fields so the printed
             // `patchedDependencies` keeps its original single-line / brace layout.
             patched_dependencies.is_single_line = obj.is_single_line;
             patched_dependencies.close_brace_loc = obj.close_brace_loc;
@@ -252,9 +250,9 @@ pub(crate) fn edit_update_no_args(
     // is to always avoid the store
     let _guard = ExprDisabler::scope();
 
-    // Zig: `const allocator = manager.allocator;` — process-lifetime arena for AST
+    // Process-lifetime arena for AST
     // nodes that must outlive `Expr.Data.Store.reset()`. See `PackageManager.ast_arena`.
-    // PORT NOTE: reshaped for borrowck — `arena` is a disjoint-field borrow held across
+    // `arena` is a disjoint-field borrow held across
     // the `&mut manager.updating_packages` accesses below.
     let arena = &manager.ast_arena;
 
@@ -318,7 +316,7 @@ pub(crate) fn edit_update_no_args(
                         }
 
                         let key_str = key.as_utf8_string_literal().expect("unreachable");
-                        // PORT NOTE: reshaped for borrowck — capture the literal as an owned
+                        // Capture the literal as an owned
                         // copy before borrowing `manager.updating_packages` mutably.
                         let version_literal_owned = Box::<[u8]>::from(version_literal);
                         let entry = manager.updating_packages.get_or_put(key_str)?;
@@ -535,7 +533,7 @@ pub(crate) fn edit_update_no_args(
 /// if options.add_trusted_dependencies is true, gets list from PackageManager.trusted_deps_to_add_to_package_json
 pub(crate) fn edit(
     manager: &mut PackageManager,
-    // Zig `*[]UpdateRequest` — pointer-to-slice whose `.len` is shrunk in place.
+    // Pointer-to-slice whose `.len` is shrunk in place.
     updates: &mut &mut [UpdateRequest],
     current_package_json: &mut Expr,
     dependency_list: &[u8],
@@ -546,9 +544,9 @@ pub(crate) fn edit(
     // is to always avoid the store
     let _guard = ExprDisabler::scope();
 
-    // Zig: `const allocator = manager.allocator;` — process-lifetime arena for AST
+    // Process-lifetime arena for AST
     // nodes that must outlive `Expr.Data.Store.reset()`. See `PackageManager.ast_arena`.
-    // PORT NOTE: reshaped for borrowck — `arena` is a disjoint-field borrow held across
+    // `arena` is a disjoint-field borrow held across
     // the `&mut manager.{updating_packages,trusted_deps_to_add_to_package_json}` accesses below.
     let arena = &manager.ast_arena;
 
@@ -573,7 +571,6 @@ pub(crate) fn edit(
                         for item in arr.items.slice() {
                             if let bun_ast::ExprData::EString(s) = &item.data {
                                 if s.eql_bytes(trusted_package_name) {
-                                    // PORT NOTE: reshaped for borrowck — drop return value (was allocator.free)
                                     let _ =
                                         manager.trusted_deps_to_add_to_package_json.swap_remove(i);
                                     break;
@@ -619,7 +616,7 @@ pub(crate) fn edit(
                                                     break 'add_packages_to_update;
                                                 }
 
-                                                // PORT NOTE: reshaped for borrowck — capture an
+                                                // Capture an
                                                 // owned copy of the literal before borrowing
                                                 // `manager.updating_packages` mutably.
                                                 let version_literal_owned =
@@ -632,13 +629,10 @@ pub(crate) fn edit(
                                                     break 'add_packages_to_update;
                                                 }
 
-                                                // PORT NOTE: Zig leaves `entry.value_ptr.*`
-                                                // undefined across the `npm:`-alias bailout
-                                                // below (Zig:435), which is later read by
-                                                // `fetchSwapRemove` — UB. `get_or_put` here
-                                                // already default-initializes the slot, so
-                                                // `found_existing` semantics match Zig and the
-                                                // bailout path is well-defined.
+                                                // `get_or_put` default-initializes the slot,
+                                                // so the `npm:`-alias bailout path below
+                                                // (later read by `fetchSwapRemove`) is
+                                                // well-defined.
                                                 let mut is_alias = false;
                                                 if strings::trim(
                                                     &version_literal_owned,
@@ -687,7 +681,7 @@ pub(crate) fn edit(
                                             if i < last {
                                                 updates.swap(i, last);
                                             }
-                                            // Zig: `updates.*.len -= 1;` — shrink the slice header.
+                                            // Shrink the slice header.
                                             *updates = &mut core::mem::take(updates)[..last];
                                             remaining -= 1;
                                             continue 'loop_;
@@ -846,7 +840,7 @@ pub(crate) fn edit(
                         // Duplicate dependency (e.g., "react" in both "dependencies" and
                         // "optionalDependencies"). Remove the old dependency.
                         new_dependencies[k] = G::Property::default();
-                        // Zig: `items.len -= 1` (no shift) — drop the trailing slot.
+                        // Drop the trailing slot (no shift).
                         let new_len = new_dependencies.len() - 1;
                         new_dependencies.truncate(new_len);
                     }
@@ -881,9 +875,9 @@ pub(crate) fn edit(
                 break;
             }
 
-            // Zig:545 `defer ... bun.assert(request.e_string != null)` — there are no early-exit
-            // paths between the top of this `for` body and here, so a plain post-loop assert is
-            // equivalent to the deferred one (and avoids a `scopeguard` borrow conflict on
+            // There are no early-exit
+            // paths between the top of this `for` body and here, so a plain post-loop assert
+            // suffices (and avoids a `scopeguard` borrow conflict on
             // `request.e_string`).
             #[cfg(debug_assertions)]
             debug_assert!(request.e_string.is_some());
@@ -1087,7 +1081,7 @@ pub(crate) fn edit(
             //       loop) — backed by `manager.ast_arena`, which is process-lifetime; or
             //   (b) a pre-existing slot from the parsed `current_package_json` input tree
             //       (`value.expr.data.e_string()` / `v.data.e_string()` in the earlier
-            //       dependency-group scan; Zig:447 / Zig:467) — backed by the thread-local Expr
+            //       dependency-group scan) — backed by the thread-local Expr
             //       Store, which the *caller* guarantees stays live for the duration of `edit`
             //       (it owns the parsed tree).
             // Note: `ExprDisabler::scope()` at function entry is a debug guard that *forbids*
@@ -1096,8 +1090,7 @@ pub(crate) fn edit(
             // above only overwrite a Copy `Expr` handle; they never reset either arena. The Expr
             // tree references the slot via `StoreRef` (a Copy `NonNull`) and no `&`/`&mut`
             // derived from a `StoreRef` to the same `E::EString` is live inside this loop body,
-            // so this is the sole mutable borrow — matches the Zig original which stores
-            // `?*E.String` for this deferred-write pattern.
+            // so this is the sole mutable borrow.
             let e_string = unsafe { &mut *e_string };
             if request.package_id as usize >= resolutions.len()
                 || resolutions[request.package_id as usize].tag == resolution::Tag::Uninitialized
@@ -1139,10 +1132,6 @@ pub(crate) fn edit(
                             if let Some(entry) =
                                 manager.updating_packages.fetch_swap_remove(request.name)
                             {
-                                // Zig declares `alias_at_index` here and assigns it inside the
-                                // `version_literal` block but never reads it afterwards (dead
-                                // store, vestigial from the earlier `editUpdateNoArgs` copy).
-                                // The Rust port omits the variable entirely.
                                 let new_version: Vec<u8> = 'new_version: {
                                     let version_fmt = resolutions[request.package_id as usize]
                                         .npm()
@@ -1233,7 +1222,6 @@ pub(crate) fn edit(
                                     write!(&mut v, "^{}", version_fmt)
                                         .expect("infallible: in-memory write");
                                 }
-                                // PERF(port): was comptime bool dispatch — profile if hot
                                 v
                             };
 
@@ -1271,5 +1259,3 @@ pub(crate) fn edit(
 }
 
 const TRUSTED_DEPENDENCIES_STRING: &[u8] = b"trustedDependencies";
-
-// ported from: src/install/PackageManager/PackageJSONEditor.zig
diff --git a/src/install/PackageManager/PackageManagerDirectories.rs b/src/install/PackageManager/PackageManagerDirectories.rs
index 48ab3bcd668..632dc57d07c 100644
--- a/src/install/PackageManager/PackageManagerDirectories.rs
+++ b/src/install/PackageManager/PackageManagerDirectories.rs
@@ -22,7 +22,7 @@ use super::options::{self, Enable, LogLevel};
 use super::{Command, Options, PackageManager, ProgressStrings, Subcommand};
 
 // ───────────────────────────── method wrappers ───────────────────────────────
-// Thin `&mut self` shims so call sites can use Zig's method-style spelling
+// Thin `&mut self` shims so call sites can use method-style spelling
 // (`pm.getCacheDirectory()` / `pm.getTemporaryDirectory()`). The bodies live
 // in the free functions below to keep them callable without an `impl` path.
 
@@ -40,12 +40,10 @@ impl PackageManager {
     /// `PackageManifestMap::by_name_hash_allow_expired`'s disk-fallback path
     /// reads. Captured by value so the loop body can hold `&mut self.manifests`
     /// alongside `&self.lockfile` / `&self.options` without aliasing the whole
-    /// `&mut self` (Stacked-Borrows UB the Zig `*PackageManager` pattern is
-    /// immune to).
+    /// `&mut self` (which would be Stacked-Borrows UB).
     ///
     /// The cache directory is opened lazily here only when
-    /// `options.enable.manifest_cache` is set (the only branch that reads it),
-    /// matching the Zig `byNameHashAllowExpired` gating.
+    /// `options.enable.manifest_cache` is set (the only branch that reads it).
     pub fn manifest_disk_cache_ctx(&mut self) -> crate::package_manifest_map::DiskCacheCtx {
         let enable_manifest_cache = self.options.enable.manifest_cache();
         crate::package_manifest_map::DiskCacheCtx {
@@ -181,7 +179,7 @@ pub fn get_cache_directory_and_abs_path(this: &mut PackageManager) -> (Fd, AbsPa
 
 #[inline]
 pub fn get_temporary_directory(this: &mut PackageManager) -> &'static TemporaryDirectory {
-    // PORT NOTE: Zig used `bun.once(...)`; `bun_core::Once<T, fn(A)->T>` can't
+    // `bun_core::Once<T, fn(A)->T>` can't
     // accept a non-`'static` `&mut PackageManager` argument, so use `OnceLock`
     // directly and split get/set so the closure doesn't need to capture `this`.
     if let Some(td) = GET_TEMPORARY_DIRECTORY_ONCE.get() {
@@ -247,7 +245,6 @@ fn get_temporary_directory_run(manager: &mut PackageManager) -> TemporaryDirecto
     let tmpname =
         FileSystem::tmpname(b"hm", &mut tmpbuf, bun_core::fast_random()).expect("unreachable");
 
-    // TODO(port): std.time.Timer — using bun_core::time::Timer placeholder
     let mut timer = if manager.options.log_level != LogLevel::Silent {
         Some(bun_core::time::Timer::start().expect("unreachable"))
     } else {
@@ -298,7 +295,7 @@ fn get_temporary_directory_run(manager: &mut PackageManager) -> TemporaryDirecto
                 Global::crash();
             }
         };
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
 
         match sys::renameat_z(tempdir.fd(), tmpname, cache_directory.fd(), tmpname) {
             Ok(()) => {}
@@ -488,8 +485,7 @@ pub fn fetch_cache_directory_path(env: &mut DotEnvLoader, options: Option<&Optio
 
 // ─────────────────────── cached folder name printers ──────────────────────────
 //
-// PERF(port): the Zig originals lean on `std.fmt.bufPrint{,Z}`, which the
-// straight port mapped to `core::fmt::write` over a `format_args!` of
+// PERF: an earlier version used `core::fmt::write` over a `format_args!` of
 // `bun_fmt::s` / `CacheVersionFormatter` / `PatchHashFmt` / `hex_int_*`
 // pieces. In Rust that is *dynamic* dispatch — every `{}` argument is a
 // `&dyn Display` whose vtable lives in `.data.rel.ro`, and every
@@ -707,7 +703,7 @@ pub fn cached_npm_package_folder_name_print<'a>(
         cached_npm_package_folder_print_basename(buf, name, version, None, include_version_number)
             .as_bytes()
             .len();
-    // PORT NOTE: reshaped for borrowck — resume the cursor at the basename's
+    // reshaped for borrowck — resume the cursor at the basename's
     // tail instead of holding the returned `&ZStr` across the re-borrow.
     let scope_url = scope.url.url();
     let mut w = ByteCursor {
@@ -914,7 +910,6 @@ pub fn path_for_cached_npm_path<'a>(
     package_name: &[u8],
     version: Semver::Version,
 ) -> Result<&'a mut [u8], Error> {
-    // TODO(port): narrow error set
     let mut cache_path_buf = PathBuffer::uninit();
 
     let cache_path = cached_npm_package_folder_name_print(
@@ -925,7 +920,7 @@ pub fn path_for_cached_npm_path<'a>(
         None,
     );
     let cache_path_len = cache_path.as_bytes().len();
-    // PORT NOTE: reshaped for borrowck — drop borrow before mutating buffer
+    // reshaped for borrowck — drop borrow before mutating buffer
 
     if cfg!(debug_assertions) {
         debug_assert!(cache_path_buf[package_name.len()] == b'@');
@@ -975,13 +970,12 @@ pub fn path_for_resolution<'a>(
     resolution: &Resolution,
     buf: &'a mut PathBuffer,
 ) -> Result<&'a mut [u8], Error> {
-    // TODO(port): narrow error set
     // const folder_name = this.cachedNPMPackageFolderName(name, version);
     match resolution.tag {
         ResolutionTag::Npm => {
             let npm = *resolution.npm();
             let package_name_ = this.lockfile.packages.items_name()[package_id as usize];
-            // PORT NOTE: borrowck — `path_for_cached_npm_path` reborrows `this`
+            // borrowck — `path_for_cached_npm_path` reborrows `this`
             // mutably (for `get_cache_directory`), so the `&this.lockfile`
             // borrow can't be held across it. Copy the name out first.
             let package_name = this.lockfile.str(&package_name_).to_vec();
@@ -1069,7 +1063,7 @@ pub fn compute_cache_dir_and_subpath<'a>(
         ResolutionTag::Symlink => {
             let directory = global_link_dir(manager);
 
-            // PORT NOTE: borrowck — `global_link_dir_path` below reborrows
+            // borrowck — `global_link_dir_path` below reborrows
             // `manager` mutably, so copy the symlink target out of the lockfile
             // string buffer first instead of holding a slice across that call.
             let folder = resolution
@@ -1110,7 +1104,6 @@ pub fn compute_cache_dir_and_subpath<'a>(
 // ─────────────────────────── package.json / lockfile ──────────────────────────
 
 pub fn attempt_to_create_package_json_and_open() -> Result<File, Error> {
-    // TODO(port): narrow error set
     let package_json_file = match Dir::cwd().create_file_z(
         z_static(b"package.json\0"),
         sys::CreateFlags {
@@ -1131,9 +1124,8 @@ pub fn attempt_to_create_package_json_and_open() -> Result<File, Error> {
 }
 
 pub fn attempt_to_create_package_json() -> Result<(), Error> {
-    // TODO(port): narrow error set
     let file = attempt_to_create_package_json_and_open()?;
-    let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+    let _ = file.close(); // close error is non-actionable
     Ok(())
 }
 
@@ -1142,7 +1134,7 @@ pub fn save_lockfile(
     load_result: &LoadResult,
     save_format: LockfileFormat,
     had_any_diffs: bool,
-    // TODO(dylan-conway): this and `packages_len_before_install` can most likely be deleted
+    // NOTE(dylan-conway): this and `packages_len_before_install` can most likely be deleted
     // now that git dependnecies don't append to lockfile during installation.
     lockfile_before_install: &Lockfile,
     packages_len_before_install: usize,
@@ -1199,10 +1191,10 @@ pub fn save_lockfile(
         return Ok(());
     }
 
-    // PORT NOTE: Zig held `*Progress.Node` across the body; `Progress::start`
+    // `Progress::start`
     // returns `&mut Node` borrowing `this.progress`, which would conflict with
-    // the `&mut this` reborrows below. Stash as a raw pointer (mirrors Zig's
-    // non-exclusive `*Node`; the node lives inside `this.progress.root`).
+    // the `&mut this` reborrows below. Stash as a raw pointer
+    // (the node lives inside `this.progress.root`).
     let mut save_node: *mut ProgressNode = core::ptr::null_mut();
 
     if log_level.show_progress() {
@@ -1263,12 +1255,10 @@ pub fn save_lockfile(
 
 pub fn update_lockfile_if_needed(
     manager: &mut PackageManager,
-    // PORT NOTE: Zig passed `Lockfile.LoadResult` by value (large structs are
-    // passed by const-ref under Zig's ABI). The Rust caller continues using
+    // The caller continues using
     // `load_result` after this call, so take it by shared reference.
     load_result: &LoadResult,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     if let LoadResult::Ok(ok) = load_result {
         if ok.serializer_result.packages_need_update {
             let mut slice = manager.lockfile.packages.slice();
@@ -1283,12 +1273,9 @@ pub fn update_lockfile_if_needed(
 }
 
 pub fn write_yarn_lock(this: &mut PackageManager) -> Result<(), Error> {
-    // TODO(port): narrow error set
-
     let mut tmpname_buf = [0u8; 512];
     tmpname_buf[0..8].copy_from_slice(b"tmplock-");
-    // PORT NOTE: `FileSystem.RealFS.Tmpfile` (fs.zig) — POSIX path never used
-    // its `*RealFS` arg; Windows opens via `get_default_temp_dir`.
+    // Windows opens via `get_default_temp_dir`.
     let mut tmpfile = bun_resolver::fs::RealFsTmpfile::default();
     let mut secret = [0u8; 32];
     secret[0..8].copy_from_slice(
@@ -1299,8 +1286,7 @@ pub fn write_yarn_lock(this: &mut PackageManager) -> Result<(), Error> {
     let mut base64_bytes = [0u8; 64];
     bun_core::csprng(&mut base64_bytes);
 
-    // Zig `std.fmt.bufPrint(buf, "{x}", .{&base64_bytes})` on a `*[64]u8` formats
-    // each byte as zero-padded 2-char lower hex (128 chars total).
+    // Format each byte as zero-padded 2-char lower hex (128 chars total).
     let tmpname_len = {
         let mut cursor = &mut tmpname_buf[8..];
         let initial_len = cursor.len();
@@ -1323,12 +1309,10 @@ pub fn write_yarn_lock(this: &mut PackageManager) -> Result<(), Error> {
             lockfile: &this.lockfile,
             options: &this.options,
             successfully_installed: None,
-            // PORT NOTE: Zig leaves `.updates` at its default `&.{}`. `Yarn::print`
-            // never reads `updates`, but pass an empty slice to match the spec
-            // exactly rather than `&this.update_requests`.
+            // `Yarn::print` never reads `updates`; pass an empty slice.
             updates: &[],
         };
-        // PORT NOTE: Zig used `file.writerStreaming(&[4096]u8)`. `bun_sys::File`
+        // `bun_sys::File`
         // has no `bun_io::Write` impl (and `bun_sys` ⊥ `bun_io`), so buffer the
         // entire output in a `Vec<u8>` (impls `bun_io::Write`) and flush once.
         let mut buf: Vec<u8> = Vec::with_capacity(4096);
@@ -1384,8 +1368,7 @@ impl fmt::Display for PatchHashFmt {
     }
 }
 
-// PORTING.md §Global mutable state: bool flag → AtomicBool. Set once during
-// the (Once-guarded) temp-dir probe; never read today but kept for Zig parity.
+// Set once during the (Once-guarded) temp-dir probe; never read today.
 static USING_FALLBACK_TEMP_DIR: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
 
@@ -1398,9 +1381,8 @@ fn verbose_install() -> bool {
     PackageManager::verbose_install()
 }
 
-/// Thread-local cached folder-name buffer accessor. Zig used a plain
-/// `threadlocal var [bun.MAX_PATH_BYTES]u8`. PORTING.md §Global mutable state:
-/// single-threaded install, non-reentrant scratch — the `&'static mut [u8]`
+/// Thread-local cached folder-name buffer accessor.
+/// Single-threaded install, non-reentrant scratch — the `&'static mut [u8]`
 /// is the unique live borrow at every call site. Callers must not hold the
 /// result across a call that re-enters this accessor (per-statement reborrow
 /// shape — same contract the prior `*mut [u8]` API imposed, now centralized
@@ -1409,7 +1391,7 @@ fn verbose_install() -> bool {
 fn cached_package_folder_name_buf() -> &'static mut [u8] {
     // SAFETY: single-threaded usage (install runs on one thread); the
     // thread-local cell outlives all callers and only one `&mut` is taken at a
-    // time per call site (Zig also reused this buffer non-reentrantly).
+    // time per call site (the buffer is reused non-reentrantly).
     unsafe { (*super::cached_package_folder_name_buf()).as_mut_slice() }
 }
 
@@ -1419,5 +1401,3 @@ const fn z_static(bytes_with_nul: &'static [u8]) -> &'static ZStr {
     // `from_static` is the const-eval-safe form of `from_slice_with_nul`.
     ZStr::from_static(bytes_with_nul)
 }
-
-// ported from: src/install/PackageManager/PackageManagerDirectories.zig
diff --git a/src/install/PackageManager/PackageManagerEnqueue.rs b/src/install/PackageManager/PackageManagerEnqueue.rs
index 4c30e0a030f..913dd266d0f 100644
--- a/src/install/PackageManager/PackageManagerEnqueue.rs
+++ b/src/install/PackageManager/PackageManagerEnqueue.rs
@@ -38,9 +38,8 @@ use bun_install::{
     invalid_package_id,
 };
 
-// PORT NOTE: Zig accesses `PackageManager.verbose_install` (a `pub var`); the
-// Rust port stores it as a process-global. The associated fn lives on the real
-// `PackageManager` impl; pull it into scope as a free name so the comptime-ish
+// `verbose_install` is a process-global. The associated fn lives on the real
+// `PackageManager` impl; pull it into scope as a free name so the
 // `verbose_install()` call sites read the same.
 #[inline]
 fn verbose_install() -> bool {
@@ -48,7 +47,7 @@ fn verbose_install() -> bool {
     PackageManager::verbose_install()
 }
 
-// PORT NOTE: `PatchTask.callback` discriminant — routed to the real
+// `PatchTask.callback` discriminant — routed to the real
 // `patch_install::Callback` enum (CalcHash / Apply).
 
 // `SuccessFn` / `FailFn` are bare `fn(&mut PackageManager, ...)` pointers; the
@@ -60,7 +59,7 @@ const assign_root_resolution: SuccessFn = PackageManager::assign_root_resolution
 #[allow(non_upper_case_globals)]
 const fail_root_resolution: FailFn = PackageManager::fail_root_resolution;
 
-// Zig: `const debug = PackageManager.debug;` — the `use package_manager_real::PackageManager`
+// The `use package_manager_real::PackageManager`
 // above already pulls the `declare_scope!`-generated `static PackageManager: ScopedLogger`
 // (value namespace) alongside the struct (type namespace), so re-declaring it here
 // would collide. `scoped_log!(PackageManager, ...)` below resolves to that import.
@@ -109,7 +108,7 @@ pub fn enqueue_dependency_list(
     // through "dependencies", skip it
     if end - begin > 1 && lockfile.buffers.dependencies[0].behavior.is_peer() {
         let mut peer_i: usize = 0;
-        // PORT NOTE: reshaped for borrowck — index into the slice instead of holding &mut across loop
+        // reshaped for borrowck — index into the slice instead of holding &mut across loop
         while lockfile.buffers.dependencies[peer_i].behavior.is_peer() {
             let mut dep_i: usize = (end - 1) as usize;
             let mut dep = lockfile.buffers.dependencies[dep_i].clone();
@@ -143,7 +142,7 @@ pub fn enqueue_dependency_list(
                 dependency::version::Tag::Folder => bun_fmt::PathSep::Auto,
                 _ => bun_fmt::PathSep::Any,
             };
-            // PORT NOTE: `format_args!` borrows temporaries — bind the
+            // `format_args!` borrows temporaries — bind the
             // formatter first so it outlives the macro expansion.
             let realname = dependency.realname();
             let path_fmt = bun_fmt::fmt_path_u8(
@@ -153,7 +152,6 @@ pub fn enqueue_dependency_list(
                     escape_backslashes: false,
                 },
             );
-            // TODO(port): logger note API — Zig passes (fmt, args) tuple separately
             let log = this.log_mut();
             if dependency.behavior.is_optional() || dependency.behavior.is_peer() {
                 log.add_warning_with_note(
@@ -212,7 +210,7 @@ pub fn enqueue_tarball_for_download(
         patch_name_and_version_hash,
         crate::network_task::Authorization::NoAuthorization,
     )? {
-        // PORT NOTE: reshaped for borrowck — `task: &mut NetworkTask` borrows
+        // reshaped for borrowck — `task: &mut NetworkTask` borrows
         // `*this` (pool slot); reborrow as raw so `this.network_tarball_batch`
         // is reachable.
         let task: *mut NetworkTask = task;
@@ -233,10 +231,10 @@ pub fn enqueue_tarball_for_reading(
     resolution: &Resolution,
     task_context: TaskCallbackContext,
 ) {
-    // PORT NOTE: reshaped for borrowck — `path` borrows
+    // reshaped for borrowck — `path` borrows
     // `this.lockfile.buffers.string_bytes`; detach the slice lifetime so the
     // `&mut PackageManager` reborrow for `enqueue_local_tarball` below does
-    // not conflict (Zig passes the aliased `*PackageManager` freely).
+    // not conflict.
     // SAFETY: caller passes `resolution.tag == LocalTarball`; the
     // `local_tarball` arm is the active union field. `string_bytes` is not
     // resized in this fn — `enqueue_local_tarball` copies `path` into the
@@ -249,7 +247,6 @@ pub fn enqueue_tarball_for_reading(
     }
 
     task_queue.value_ptr.push(task_context);
-    // PERF(port): was assume-capacity append via ArrayList — profile in Phase B
 
     if task_queue.found_existing {
         return;
@@ -281,10 +278,10 @@ pub fn enqueue_git_for_checkout(
     // active union field. Copy out so the value no longer borrows
     // `*resolution` while `*this` is mutably reborrowed below.
     let repository: Repository = *resolution.git();
-    // PORT NOTE: reshaped for borrowck — `url`/`resolved` borrow
+    // reshaped for borrowck — `url`/`resolved` borrow
     // `this.lockfile.buffers.string_bytes`; detach the slice lifetimes so the
     // `&mut PackageManager` reborrows for the enqueue callees below do not
-    // conflict (Zig passes the aliased `*PackageManager` freely).
+    // conflict.
     // SAFETY: the enqueue callees copy these slices into the filename store
     // and never resize `string_bytes` while they are live.
     let url = this.lockfile.str_detached(&repository.repo);
@@ -419,7 +416,7 @@ pub fn enqueue_package_for_download(
         patch_name_and_version_hash,
         crate::network_task::Authorization::AllowAuthorization,
     )? {
-        // PORT NOTE: reshaped for borrowck — see `enqueue_tarball_for_download`.
+        // reshaped for borrowck — see `enqueue_tarball_for_download`.
         let task: *mut NetworkTask = task;
         // SAFETY: `task` is the unique handle to a freshly-vended pool slot.
         unsafe { (*task).schedule(&mut this.network_tarball_batch) };
@@ -512,11 +509,9 @@ pub fn enqueue_dependency_to_root(
         id if id == invalid_package_id => 'brk: {
             this.drain_dependency_list();
 
-            // https://github.com/ziglang/zig/issues/19586 — Zig needed a workaround fn-returning-type;
-            // in Rust we just declare the closure struct directly.
             struct Closure {
                 err: Option<bun_core::Error>,
-                // PORT NOTE: raw `*mut` (Zig `*PackageManager`) — `sleep_until`
+                // raw `*mut` — `sleep_until`
                 // also receives this pointer, so `&mut` here would alias.
                 manager: *mut PackageManager,
             }
@@ -527,9 +522,8 @@ pub fn enqueue_dependency_to_root(
                     // this callback, so this is the unique live borrow.
                     let manager = unsafe { &mut *self.manager };
                     if manager.pending_task_count() > 0 {
-                        // Zig: `runTasks(void, {}, .{ .onExtract = {}, ... }, false, log_level)`
-                        // — all callbacks `void`. `VoidRunTasksCallbacks` (below)
-                        // mirrors that with `Ctx = ()` and every `HAS_* = false`.
+                        // All callbacks void: `VoidRunTasksCallbacks` (below)
+                        // has `Ctx = ()` and every `HAS_* = false`.
                         let log_level = manager.options.log_level;
                         if let Err(err) = run_tasks::run_tasks::<VoidRunTasksCallbacks>(
                             manager,
@@ -595,9 +589,9 @@ pub fn enqueue_dependency_to_root(
     }
 }
 
-/// Mirrors Zig's `runTasks(void, {}, .{ all-void callbacks }, ...)` shape used
-/// by `enqueueDependencyToRoot` and `runAndWaitFn`: `Ctx = void`, every `on*`
-/// is `{}` so the `HAS_*` const-gates compile out the callback paths.
+/// All-void callback set used by `enqueueDependencyToRoot` and `runAndWaitFn`:
+/// `Ctx = ()`, no callbacks, so the `HAS_*` const-gates compile out the
+/// callback paths.
 pub(crate) struct VoidRunTasksCallbacks;
 impl run_tasks::RunTasksCallbacks for VoidRunTasksCallbacks {
     type Ctx = ();
@@ -608,7 +602,6 @@ pub fn enqueue_network_task(this: &mut PackageManager, task: *mut NetworkTask) {
         this.flush_network_queue();
     }
 
-    // PERF(port): was writeItemAssumeCapacity — profile in Phase B
     this.network_task_fifo.write_item_assume_capacity(task);
 }
 
@@ -627,7 +620,6 @@ pub unsafe fn enqueue_patch_task(this: &mut PackageManager, task: *mut PatchTask
         this.flush_patch_task_queue();
     }
 
-    // PERF(port): was writeItemAssumeCapacity — profile in Phase B
     this.patch_task_fifo.write_item_assume_capacity(task);
 }
 
@@ -649,7 +641,6 @@ pub unsafe fn enqueue_patch_task_pre(this: &mut PackageManager, task: *mut Patch
         this.flush_patch_task_queue();
     }
 
-    // PERF(port): was writeItemAssumeCapacity — profile in Phase B
     this.patch_task_fifo.write_item_assume_capacity(task);
     let _ = this.pending_pre_calc_hashes.fetch_add(1, Ordering::Relaxed);
 }
@@ -663,18 +654,15 @@ pub fn enqueue_dependency_with_main_and_success_fn(
     dependency: &Dependency,
     resolution: PackageID,
     install_peer: bool,
-    // PERF(port): was comptime monomorphization (successFn/failFn) — profile in Phase B
     success_fn: SuccessFn,
     fail_fn: Option<FailFn>,
-    // Zig: `comptime if (successFn == assignRootResolution)`. The Zig check is a
-    // compile-time identity comparison; in Rust the two `SuccessFn` candidates
+    // The two `SuccessFn` candidates
     // (`assign_resolution` / `assign_root_resolution`) have byte-identical
     // bodies in release builds, so Apple ld64 (which ignores `.llvm_addrsig`)
     // folds them and a runtime fn-pointer address comparison is unsound. Thread
     // an explicit flag instead.
     is_root: bool,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     if dependency.behavior.is_optional_peer() {
         return Ok(());
     }
@@ -1000,11 +988,10 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                             );
                         }
                     } else if version.tag.is_npm() {
-                        // PORT NOTE: reshaped for borrowck — `name_str` borrows
+                        // reshaped for borrowck — `name_str` borrows
                         // `this.lockfile.buffers.string_bytes`. Route the whole
                         // branch through a raw root so the slice and the
-                        // `&mut PackageManager` calls below can coexist (Zig
-                        // passes the aliased `*PackageManager` freely).
+                        // `&mut PackageManager` calls below can coexist.
                         // Snapshot the manifest disk-cache scalars while we
                         // still hold `&mut this` exclusively — taking it via
                         // `&mut *this_ptr` after `name_str`/`scope` exist
@@ -1110,7 +1097,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                                                         return Ok(());
                                                     }
                                                 }
-                                                // PORT NOTE: reshaped for borrowck — `find_result`
+                                                // reshaped for borrowck — `find_result`
                                                 // borrows `loaded_manifest`; route the manifest
                                                 // through a `BackRef` so the `&mut PackageManager`
                                                 // call below doesn't conflict. `loaded_manifest`
@@ -1167,9 +1154,9 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                                 // free to reborrow `&mut`.
                                 let network_task = this.get_network_task();
                                 // SAFETY: `network_task` is the unique handle to a
-                                // freshly-vended pool slot. Zig's `network_task.* = .{ ... }`
-                                // resets every defaulted field; `write_init` mirrors that
-                                // (callback is `= undefined` and overwritten by `for_manifest`).
+                                // freshly-vended pool slot. `write_init` resets every
+                                // defaulted field (callback is uninitialized and
+                                // overwritten by `for_manifest`).
                                 unsafe {
                                     NetworkTask::write_init(network_task, task_id, this_ptr, None);
                                 }
@@ -1219,7 +1206,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                 return Ok(());
             }
 
-            // PORT NOTE: reshaped for borrowck — `alias`/`url` borrow
+            // reshaped for borrowck — `alias`/`url` borrow
             // `this.lockfile.buffers.string_bytes`; detach the slice
             // lifetimes so the `&mut PackageManager` reborrows for the
             // enqueue callees below do not conflict.
@@ -1330,7 +1317,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
             }
 
             let url = this.alloc_github_url(dep);
-            // url is Box<[u8]>; dropped at scope end (Zig had `defer allocator.free(url)`)
+            // url is Box<[u8]>; dropped at scope end
             let task_id = Task::Id::for_tarball(&url);
 
             if cfg!(debug_assertions) {
@@ -1350,7 +1337,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
             } else {
                 TaskCallbackContext::Dependency(id)
             };
-            // PORT NOTE: reshaped for borrowck — `entry` mutably borrows
+            // reshaped for borrowck — `entry` mutably borrows
             // `this.task_queue`; scope it tightly so the calls below can
             // reborrow `*this`.
             {
@@ -1386,15 +1373,13 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                 None,
                 crate::network_task::Authorization::NoAuthorization,
             )? {
-                // PORT NOTE: reshaped for borrowck — see `enqueue_tarball_for_download`.
+                // reshaped for borrowck — see `enqueue_tarball_for_download`.
                 let nt: *mut NetworkTask = network_task;
                 enqueue_network_task(this, nt);
             }
             Ok(())
         }
         dependency::version::Tag::Symlink | dependency::version::Tag::Workspace => {
-            // PORT NOTE: Zig used `inline .symlink, .workspace => |dependency_tag|` to capture
-            // the comptime tag; we check `version.tag` at runtime instead.
             let dependency_tag = version.tag;
 
             let _result = match get_or_put_resolved_package(
@@ -1414,26 +1399,6 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                 Err(err) => return Err(err),
             };
 
-            const WORKSPACE_NOT_FOUND_FMT: &str = concat!(
-                "Workspace dependency \"{name}\" not found\n",
-                "\n",
-                "Searched in <b>{search_path}<r>\n",
-                "\n",
-                "Workspace documentation: https://bun.com/docs/install/workspaces\n",
-                "\n",
-            );
-            const LINK_NOT_FOUND_FMT: &str = concat!(
-                "Package \"{name}\" is not linked\n",
-                "\n",
-                "To install a linked package:\n",
-                "   <cyan>bun link my-pkg-name-from-package-json<r>\n",
-                "\n",
-                "Tip: the package name is from package.json, which can differ from the folder name.\n",
-                "\n",
-            );
-            // TODO(port): named-argument format strings — Zig used `{[name]s}` / `{[search_path]f}`;
-            // logger API in Rust may need positional args instead.
-
             if let Some(result) = _result {
                 // First time?
                 if result.is_first_time {
@@ -1483,7 +1448,6 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                             None,
                             bun_ast::Loc::EMPTY,
                             format_args!(
-                                // TODO(port): WORKSPACE_NOT_FOUND_FMT with named args
                                 "Workspace dependency \"{}\" not found\n\nSearched in <b>{}<r>\n\nWorkspace documentation: https://bun.com/docs/install/workspaces\n\n",
                                 bstr::BStr::new(this.lockfile.str(&name)),
                                 PackageWorkspaceSearchPathFormatter { manager: this, version, quoted: true },
@@ -1495,7 +1459,6 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                             None,
                             bun_ast::Loc::EMPTY,
                             format_args!(
-                                // TODO(port): LINK_NOT_FOUND_FMT with named args
                                 "Package \"{}\" is not linked\n\nTo install a linked package:\n   <cyan>bun link my-pkg-name-from-package-json<r>\n\nTip: the package name is from package.json, which can differ from the folder name.\n\n",
                                 bstr::BStr::new(this.lockfile.str(&name)),
                             ),
@@ -1525,7 +1488,6 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                         );
                 }
             }
-            let _ = (WORKSPACE_NOT_FOUND_FMT, LINK_NOT_FOUND_FMT);
             Ok(())
         }
         dependency::version::Tag::Tarball => {
@@ -1545,7 +1507,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                 return Ok(());
             }
 
-            // PORT NOTE: reshaped for borrowck — `url` borrows `string_bytes`;
+            // reshaped for borrowck — `url` borrows `string_bytes`;
             // detach the slice lifetime so the `&mut PackageManager` reborrows
             // for the enqueue callees below do not conflict.
             // SAFETY: the enqueue callees copy `url` into the filename store
@@ -1575,7 +1537,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
             } else {
                 TaskCallbackContext::Dependency(id)
             };
-            // PORT NOTE: reshaped for borrowck — scope `entry` tightly.
+            // reshaped for borrowck — scope `entry` tightly.
             {
                 let entry = this
                     .task_queue
@@ -1616,7 +1578,7 @@ pub fn enqueue_dependency_with_main_and_success_fn(
                     this.task_batch.push(ThreadPool::Batch::from(task));
                 }
                 dependency::tarball::Uri::Remote(_) => {
-                    // PORT NOTE: `generate_network_task_for_tarball` returns
+                    // `generate_network_task_for_tarball` returns
                     // `&'a mut NetworkTask` tied to `this`; coerce to `*mut`
                     // immediately so the `&mut *this` borrow ends before
                     // `enqueue_network_task(this, …)` reborrows it (NLL).
@@ -2033,11 +1995,9 @@ fn get_or_put_resolved_package_with_find_result(
     manifest: &Npm::PackageManifest,
     find_result: Npm::FindResult,
     install_peer: bool,
-    // PERF(port): was comptime monomorphization — profile in Phase B
     success_fn: SuccessFn,
 ) -> Result<Option<ResolvedPackageResult>, bun_core::Error> {
-    // TODO(port): narrow error set
-    // PORT NOTE: reshaped for borrowck — `is_root_dependency(&self, &mut PackageManager, …)`
+    // reshaped for borrowck — `is_root_dependency(&self, &mut PackageManager, …)`
     // borrows `this.lockfile` and `this` at once. Split via raw root.
     let should_update = {
         let this_ptr: *mut PackageManager = this;
@@ -2057,11 +2017,11 @@ fn get_or_put_resolved_package_with_find_result(
 
     // Was this package already allocated? Let's reuse the existing one.
     //
-    // PORT NOTE (determinism): Zig passes `version` here unconditionally, so a
-    // peer like `>= 1.0.2` can collapse onto whichever sibling-appended entry
+    // Determinism: passing `version` here unconditionally lets a
+    // peer like `>= 1.0.2` collapse onto whichever sibling-appended entry
     // (e.g. `1.0.9`) happens to be highest in the index *at this instant* — a
     // network-order artefact that the `^1.0.2` peer-hoisting test already
-    // todoIf's on macOS. The Rust port's floor guard in `get_package_id` was
+    // todoIf's on macOS. The floor guard in `get_package_id` was
     // meant to close that, but its exact-pinned/same-major exemptions reopen
     // it when *every* candidate is an exact-pinned same-major sibling
     // (`uses-a-dep-1..10`). For deferred peers, suppress the satisfies-
@@ -2097,12 +2057,11 @@ fn get_or_put_resolved_package_with_find_result(
     }
 
     // appendPackage sets the PackageID on the package
-    // PORT NOTE: reshaped for borrowck — `from_npm` takes both `&mut PackageManager`
-    // and `&mut Lockfile`, which alias through `this.lockfile`. Split via raw root
-    // (Zig passes both freely).
+    // reshaped for borrowck — `from_npm` takes both `&mut PackageManager`
+    // and `&mut Lockfile`, which alias through `this.lockfile`. Split via raw root.
     let this_ptr: *mut PackageManager = this;
     // SAFETY: `from_npm` reads `pm` fields disjoint from `pm.lockfile` (options /
-    // updating_packages); the raw split mirrors Zig's aliased `*PackageManager`.
+    // updating_packages), so the raw-pointer split does not alias.
     let package = unsafe { &mut *(*this_ptr).lockfile }.append_package(&Package::from_npm(
         unsafe { &mut *this_ptr },
         unsafe { &mut *(*this_ptr).lockfile },
@@ -2125,7 +2084,7 @@ fn get_or_put_resolved_package_with_find_result(
         // by-value above).
         unsafe { &mut *(*this_ptr).lockfile }.mark_exact_pin(package.meta.id);
     }
-    // PORT NOTE: Zig used `defer successFn(...)`. Use scopeguard so success_fn runs on every
+    // Use scopeguard so success_fn runs on every
     // return below (including the `?` paths). The guard owns the raw pointer so the
     // `this` reborrow below doesn't conflict with the closure capture.
     let mut guard = scopeguard::guard((this_ptr, package.meta.id), |(this_ptr, pkg_id)| {
@@ -2135,7 +2094,7 @@ fn get_or_put_resolved_package_with_find_result(
     });
     // SAFETY: see above — sole live `&mut PackageManager` until scope exit.
     let this: &mut PackageManager = unsafe { &mut *guard.0 };
-    // PORT NOTE: Zig `defer` (not errdefer) — scopeguard runs on ALL exits, never disarmed.
+    // The scopeguard runs on ALL exits, never disarmed.
 
     // non-null if the package is in "patchedDependencies"
     let mut name_and_version_hash: Option<u64> = None;
@@ -2238,10 +2197,8 @@ fn get_or_put_resolved_package(
     dependency_id: DependencyID,
     resolution: PackageID,
     install_peer: bool,
-    // PERF(port): was comptime monomorphization — profile in Phase B
     success_fn: SuccessFn,
 ) -> Result<Option<ResolvedPackageResult>, bun_core::Error> {
-    // TODO(port): narrow error set
     if install_peer && behavior.is_peer() {
         if let Some(index) = this.lockfile.package_index.get(&name_hash) {
             let resolutions = this.lockfile.packages.items_resolution();
@@ -2409,9 +2366,9 @@ fn get_or_put_resolved_package(
             }
 
             // Resolve the version from the loaded NPM manifest
-            // PORT NOTE: reshaped for borrowck — `name_str`/`manifest` borrow
+            // reshaped for borrowck — `name_str`/`manifest` borrow
             // `*this`; route through a raw root so the `&mut PackageManager`
-            // calls below can coexist (Zig passes the aliased `*PackageManager`).
+            // calls below can coexist.
             // Snapshot the disk-fallback scalars *before* establishing
             // `this_ptr`: `manifest_disk_cache_ctx` takes `&mut self`, and
             // materializing `&mut *this_ptr` after `name_str`/`scope` are
@@ -2573,7 +2530,7 @@ fn get_or_put_resolved_package(
                 }
             };
 
-            // PORT NOTE: reshaped for borrowck — `manifest`/`find_result`
+            // reshaped for borrowck — `manifest`/`find_result`
             // borrow `this.manifests`; detach via `BackRef` so the `&mut *this`
             // call can proceed (`this.manifests` is not mutated by the callee).
             let manifest_ref: bun_ptr::BackRef<Npm::PackageManifest> =
@@ -2599,7 +2556,7 @@ fn get_or_put_resolved_package(
             let res: FolderResolutionValue = 'res: {
                 if this.lockfile.is_workspace_dependency(dependency_id) {
                     // relative to cwd
-                    // PORT NOTE: reshaped for borrowck — `folder_path` borrows
+                    // reshaped for borrowck — `folder_path` borrows
                     // `string_bytes`; detach the slice lifetime so the
                     // `&mut PackageManager` reborrow for `get_or_put` below
                     // does not conflict.
@@ -2623,11 +2580,6 @@ fn get_or_put_resolved_package(
                         // );
                     };
 
-                    // if (strings.eqlLong(strings.withoutTrailingSlash(folder_path_abs), strings.withoutTrailingSlash(FileSystem.instance.top_level_dir), true)) {
-                    //     successFn(this, dependency_id, 0);
-                    //     return .{ .package = this.lockfile.packages.get(0) };
-                    // }
-
                     break 'res FolderResolution::get_or_put(
                         GlobalOrRelative::Relative(dependency::version::Tag::Folder),
                         version,
@@ -2645,7 +2597,7 @@ fn get_or_put_resolved_package(
 
                 {
                     // only need name and path
-                    // PORT NOTE: copy the two slices out of `string_bytes`
+                    // copy the two slices out of `string_bytes`
                     // before creating the builder — `StringBuilder::allocate`
                     // may grow the buffer and invalidate borrows into it, so
                     // owned copies are required regardless of borrowck.
@@ -2705,7 +2657,7 @@ fn get_or_put_resolved_package(
                 .get(&name_hash)
                 .copied()
                 .unwrap_or_else(|| *version.workspace());
-            // PORT NOTE: reshaped for borrowck — `workspace_path` may borrow
+            // reshaped for borrowck — `workspace_path` may borrow
             // `string_bytes`; detach the slice lifetime so the
             // `&mut PackageManager` reborrow for `get_or_put` below does not
             // conflict.
@@ -2750,7 +2702,7 @@ fn get_or_put_resolved_package(
             }
         }
         dependency::version::Tag::Symlink => {
-            // PORT NOTE: reshaped for borrowck — `link_dir` / `symlink_path`
+            // reshaped for borrowck — `link_dir` / `symlink_path`
             // borrow into `*this`; detach their lifetimes so the
             // `&mut PackageManager` reborrow for `get_or_put` does not
             // conflict.
@@ -2821,10 +2773,8 @@ fn resolution_satisfies_dependency(
 // ──────────────────────────────────────────────────────────────────────────
 // `impl PackageManager` — inherent-method facade over the free fns above.
 //
-// Zig mounts this file via `usingnamespace`, so `pkg_manager.enqueueX(...)`
-// resolves to these free fns by first-arg-is-`*Self` UFCS. Rust has no
-// `usingnamespace`; sibling files (PackageManagerLifecycle, …Directories,
-// runTasks) all expose an `impl PackageManager` block instead. Match that
+// Sibling files (PackageManagerLifecycle, …Directories,
+// runTasks) all expose an `impl PackageManager` block. Match that
 // pattern here so cross-file callers can keep the `.method()` shape.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -3034,5 +2984,3 @@ impl PackageManager {
         )
     }
 }
-
-// ported from: src/install/PackageManager/PackageManagerEnqueue.zig
diff --git a/src/install/PackageManager/PackageManagerLifecycle.rs b/src/install/PackageManager/PackageManagerLifecycle.rs
index e4c9398fcba..776bdb49c69 100644
--- a/src/install/PackageManager/PackageManagerLifecycle.rs
+++ b/src/install/PackageManager/PackageManagerLifecycle.rs
@@ -35,7 +35,6 @@ pub struct LifecycleScriptTimeLog {
 }
 
 pub struct LifecycleScriptTimeLogEntry {
-    // PORT NOTE: Zig borrowed the lockfile string buffer (`string`). The Rust
     // `LifecycleScriptSubprocess.package_name` is owned (`Box<[u8]>`) and freed
     // on `destroy`, so the log entry must own its copy to avoid a dangling
     // borrow. The list is at most a few dozen entries per install.
@@ -48,7 +47,6 @@ pub struct LifecycleScriptTimeLogEntry {
 impl LifecycleScriptTimeLog {
     pub fn append_concurrent(&mut self, entry: LifecycleScriptTimeLogEntry) {
         self.mutex.lock();
-        // TODO(port): consider `Mutex<Vec<Entry>>` so the guard scopes the borrow
         self.list.push(entry);
         self.mutex.unlock();
     }
@@ -100,14 +98,13 @@ impl PackageManager {
         // expandToCapacity + @memset(.., .unknown)
         self.preinstall_state
             .resize(self.preinstall_state.capacity(), PreinstallState::Unknown);
-        let _ = offset; // PORT NOTE: resize already fills [offset..] with Unknown
+        let _ = offset; // resize already fills [offset..] with Unknown
     }
 
-    /// PORT NOTE: Zig `setPreinstallState(this, package_id, lockfile, value)` — the
-    /// separate `lockfile` parameter only feeds `lockfile.packages.len` into
-    /// `ensurePreinstallStateListCapacity`. Every Rust caller passes
-    /// `self.lockfile` (or an alias of it), which would alias `&mut self`; the
-    /// parameter is dropped here and `self.lockfile` is read directly to keep
+    /// A separate `lockfile` parameter would only feed `lockfile.packages.len` into
+    /// `ensurePreinstallStateListCapacity`. Every caller passes
+    /// `self.lockfile` (or an alias of it), which would alias `&mut self`;
+    /// `self.lockfile` is read directly instead to keep
     /// borrowck happy.
     pub fn set_preinstall_state(&mut self, package_id: PackageID, value: PreinstallState) {
         let count = self.lockfile.packages.len();
@@ -122,9 +119,8 @@ impl PackageManager {
         self.preinstall_state[package_id as usize]
     }
 
-    /// PORT NOTE: Zig `determinePreinstallState(manager, pkg, lockfile, …)` — the
-    /// separate `lockfile` parameter is always `manager.lockfile` at every call
-    /// site in the Rust port; collapsed onto `self.lockfile` to avoid the
+    /// A separate `lockfile` parameter would always be `manager.lockfile` at every call
+    /// site; collapsed onto `self.lockfile` to avoid the
     /// `&mut self` / `&self.lockfile` aliasing borrowck rejects.
     pub fn determine_preinstall_state(
         &mut self,
@@ -145,7 +141,6 @@ impl PackageManager {
                     if self.lockfile.patched_dependencies.len() == 0 {
                         break 'brk None;
                     }
-                    // PERF(port): was stack-fallback (std.heap.stackFallback(1024, ...))
                     let mut name_and_version: Vec<u8> = Vec::new();
                     write!(
                         &mut name_and_version,
@@ -169,8 +164,7 @@ impl PackageManager {
                     else {
                         break 'brk None;
                     };
-                    // Zig: `defer out_name_and_version_hash.* = name_and_version_hash;`
-                    // Runs on every exit path after this point.
+                    // `*out_name_and_version_hash` is set on every exit path after this point.
                     if patched_dep.patchfile_hash_is_null {
                         *out_name_and_version_hash = Some(name_and_version_hash);
                         self.set_preinstall_state(pkg.meta.id, PreinstallState::CalcPatchHash);
@@ -246,7 +240,7 @@ impl PackageManager {
                                  Bun. Please file a GitHub issue."
                             )
                         });
-                    // Zig: `allocator.dupeZ(u8, folder_path[..idx])` — owned NUL-terminated copy.
+                    // Owned NUL-terminated copy.
                     let non_patched_path = ZBox::from_bytes(&folder_path.as_bytes()[..idx]);
                     if directories::is_folder_in_cache(self, &non_patched_path) {
                         self.set_preinstall_state(pkg.meta.id, PreinstallState::ApplyPatch);
@@ -271,7 +265,7 @@ impl PackageManager {
     }
 
     pub fn tick_lifecycle_scripts(&mut self) {
-        // PORT NOTE: reshaped for borrowck — `self.event_loop.tick_once(self)`
+        // reshaped for borrowck — `self.event_loop.tick_once(self)`
         // would borrow `self` twice. Erase `self` to a raw context pointer
         // first; `tick_once` only forwards it opaquely to task callbacks.
         let ctx = std::ptr::from_mut::<PackageManager>(self).cast::<core::ffi::c_void>();
@@ -281,7 +275,7 @@ impl PackageManager {
     pub fn sleep(&mut self) {
         self.report_slow_lifecycle_scripts();
         Output::flush();
-        // PORT NOTE: see `tick_lifecycle_scripts` — `is_done` callback reborrows
+        // see `tick_lifecycle_scripts` — `is_done` callback reborrows
         // `self` (the struct that owns `event_loop`), so use the raw-pointer
         // `tick_raw` variant which only holds `&mut event_loop` between
         // `is_done` calls.
@@ -365,7 +359,7 @@ impl PackageManager {
         // need to clone because this is a copy before Lockfile.cleanWithLogger
         let name = root_package.name.slice(buf);
 
-        // Zig: `bun.AbsPath(.{ .sep = .auto })` — `AutoAbsPath` is the SEP=auto alias.
+        // `AutoAbsPath` is the SEP=auto alias.
         let mut top_level_dir = AutoAbsPath::init_top_level_dir();
         // `defer top_level_dir.deinit()` — handled by Drop
 
@@ -405,7 +399,6 @@ impl PackageManager {
         foreground: bool,
         install_ctx: Option<InstallCtx<'_>>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let log_level = self.options.log_level;
         let mut any_scripts = false;
         for maybe_item in list.items.iter() {
@@ -420,7 +413,7 @@ impl PackageManager {
 
         self.ensure_temp_node_gyp_script()?;
 
-        // PORT NOTE: `list` is moved into `spawn_package_scripts` below; copy
+        // `list` is moved into `spawn_package_scripts` below; copy
         // `cwd` out so the PATH builder can borrow it independently.
         let cwd_owned: Vec<u8> = list.cwd.as_bytes().to_vec();
         let cwd: &[u8] = &cwd_owned;
@@ -430,11 +423,11 @@ impl PackageManager {
         let mut script_env = env_loader.map.clone_with_allocator()?;
         // `defer script_env.map.deinit()` — handled by Drop
 
-        // PORT NOTE: `script_env.put` below needs `&mut`; copy PATH out so the
+        // `script_env.put` below needs `&mut`; copy PATH out so the
         // shared borrow does not span it.
         let original_path: Vec<u8> = script_env.get(b"PATH").unwrap_or(b"").to_vec();
 
-        // Zig: `bun.EnvPath(.{})` — `EnvPathOptions` is currently fieldless.
+        // `EnvPathOptions` is currently fieldless.
         let mut path = EnvPath::init_capacity(
             original_path.len() + 1 + b"node_modules/.bin".len() + cwd.len() + 1,
         )?;
@@ -454,9 +447,7 @@ impl PackageManager {
         path.append(original_path.as_slice())?;
         script_env.put(b"PATH", path.slice())?;
 
-        // Zig: `try script_env.createNullDelimitedEnvMap(this.allocator)` —
-        // allocated with the manager-lifetime allocator and never freed in this
-        // scope; ownership transfers to `LifecycleScriptSubprocess`, which
+        // Ownership transfers to `LifecycleScriptSubprocess`, which
         // re-uses it across every `spawn_next_script` in the chain. Move the
         // owning `NullDelimitedEnvMap` by value so its `K=V\0` buffers outlive
         // this stack frame (freed by the subprocess's `Drop`).
@@ -573,9 +564,8 @@ fn add_dependencies_to_set(
 use bun_install::LogLevel;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Free-function re-export surface — Zig declares these at file scope with an
-// explicit `*PackageManager` first param. The `impl PackageManager` bodies
-// above are the canonical port; these thin shims keep the
+// Free-function re-export surface. The `impl PackageManager` bodies
+// above are canonical; these thin shims keep the
 // `pub use lifecycle::{...}` re-exports in `PackageManager.rs` resolving the
 // same way `PackageManagerDirectories.rs` / `PackageManagerEnqueue.rs` do.
 // ──────────────────────────────────────────────────────────────────────────
@@ -652,5 +642,3 @@ pub fn find_trusted_dependencies_from_update_requests(
 ) -> ArrayHashMap<TruncatedPackageNameHash, Box<[u8]>> {
     this.find_trusted_dependencies_from_update_requests()
 }
-
-// ported from: src/install/PackageManager/PackageManagerLifecycle.zig
diff --git a/src/install/PackageManager/PackageManagerOptions.rs b/src/install/PackageManager/PackageManagerOptions.rs
index 76b01df8f74..22ae9329658 100644
--- a/src/install/PackageManager/PackageManagerOptions.rs
+++ b/src/install/PackageManager/PackageManagerOptions.rs
@@ -1,18 +1,16 @@
+use crate::bun_schema::api as Api;
 use bun_core::ZStr;
 use bun_core::{Output, env_var};
 use bun_paths::PathBuffer;
-// TODO(port): move to <area>_sys / verify crate path for schema API
-use crate::bun_schema::api as Api;
 
 use super::Subcommand;
 use super::command_line_arguments::{self, CommandLineArguments};
 use bun_dotenv::Loader as DotEnvLoader;
 use bun_install::{Features, Npm};
 
-// PORT NOTE: `string` fields are `[]const u8` borrowed from CLI args / bunfig config,
+// `string` fields are `[]const u8` borrowed from CLI args / bunfig config,
 // which live for the process lifetime. There is no `deinit` on Options. Mapped to
 // `&'static [u8]` per PORTING.md (no lifetime params on structs).
-// TODO(port): lifetime — if any source is not truly 'static, add a lifetime parameter.
 
 pub struct Options {
     pub log_level: LogLevel,
@@ -103,7 +101,7 @@ impl Default for Options {
             explicit_global_directory: b"",
             bin_path: bun_paths::path_literal!("node_modules/.bin"),
             did_override_default_scope: false,
-            // PORT NOTE: Zig had `= undefined`; always assigned in `load()` before read.
+            // Always assigned in `load()` before read.
             scope: Npm::registry::Scope::default(),
             registries: Npm::registry::Map::default(),
             cache_directory: b"",
@@ -131,7 +129,8 @@ impl Default for Options {
             json_output: false,
             max_retry_count: 5,
             min_simultaneous_requests: 4,
-            // TODO(port): no default in Zig — caller must supply at construction
+            // Placeholder only — every constructor supplies the real value
+            // (`cli.concurrent_scripts` or `cpu_count * 2`).
             max_concurrent_lifecycle_scripts: 0,
             publish_config: PublishConfig::default(),
             ca: Box::default(),
@@ -158,7 +157,6 @@ impl Default for Options {
     }
 }
 
-// PORT NOTE: was an anonymous `union(enum)` field type in Zig.
 pub enum PatchFeatures {
     Nothing,
     Patch,
@@ -181,7 +179,7 @@ pub enum Access {
 }
 
 impl Access {
-    // PORT NOTE: was `bun.ComptimeEnumMap(Access)`; ≤8 entries → plain match on &[u8].
+    // was `bun.ComptimeEnumMap(Access)`; ≤8 entries → plain match on &[u8].
     pub fn from_str(str: &[u8]) -> Option<Access> {
         match str {
             b"public" => Some(Access::Public),
@@ -190,7 +188,7 @@ impl Access {
         }
     }
 
-    /// Port of Zig `@tagName(access)` — lower-case tag name as written into the
+    /// Lower-case tag name as written into the
     /// publish JSON body and summary output.
     #[inline]
     pub const fn as_str(self) -> &'static str {
@@ -208,7 +206,7 @@ pub enum AuthType {
 }
 
 impl AuthType {
-    // PORT NOTE: was `bun.ComptimeEnumMap(AuthType)`; ≤8 entries → plain match on &[u8].
+    // was `bun.ComptimeEnumMap(AuthType)`; ≤8 entries → plain match on &[u8].
     pub fn from_str(str: &[u8]) -> Option<AuthType> {
         match str {
             b"legacy" => Some(AuthType::Legacy),
@@ -217,7 +215,7 @@ impl AuthType {
         }
     }
 
-    /// Port of Zig `@tagName(auth_type)` — lower-case tag name as used by
+    /// Lower-case tag name as used by
     /// `npm-auth-type` header in `npm.whoami`.
     #[inline]
     pub const fn as_str(self) -> &'static str {
@@ -282,9 +280,7 @@ pub struct Update {
     pub peer: bool,
 }
 
-// PORT NOTE: `std.fs.cwd().makeOpenPath` → `bun_sys::Dir::cwd().make_open_path()`
-// (mkdir -p + open dir). Return type was `!std.fs.Dir`; callers store the raw
-// `Fd` (`options.global_bin_dir: Fd`), so unwrap to `.fd`.
+// mkdir -p + open the dir. Callers store the raw `Fd` (`options.global_bin_dir: Fd`).
 pub fn open_global_dir(explicit_global_dir: &[u8]) -> Result<bun_sys::Fd, bun_core::Error> {
     use bun_paths::{platform, resolve_path::join_abs_string_buf};
     use bun_sys::{Dir, OpenDirOptions};
@@ -373,11 +369,9 @@ pub(crate) fn open_global_bin_dir(
     ))
 }
 
-// PORT NOTE: Zig borrowed `[]const u8` from `Api.BunInstall` (process-lifetime
-// arena). Rust `BunInstall` owns `Box<[u8]>`; Options stores `&'static [u8]`
-// per the "no struct lifetime params" porting convention. Park a clone for the
-// lifetime of the install command (matches Zig's never-reset config arena) via
-// the named hand-off helper.
+// `BunInstall` owns `Box<[u8]>`; Options stores `&'static [u8]`
+// (no struct lifetime params). Park a clone for the
+// lifetime of the install command via the named hand-off helper.
 #[inline]
 fn leak_static(s: &[u8]) -> &'static [u8] {
     bun_core::heap::release(s.to_vec().into_boxed_slice())
@@ -389,15 +383,13 @@ impl Options {
         log: &mut bun_ast::Log,
         env: &mut DotEnvLoader,
         maybe_cli: Option<CommandLineArguments>,
-        // Spec PackageManagerOptions.zig:224 `bun_install_: ?*Api.BunInstall` —
-        // every access below is a read of `config.*`; no field is ever written.
+        // Every access below is a read of `config.*`; no field is ever written.
         // Taking `&` (not `&mut`) keeps provenance coherent with the bundler/
         // resolver storage (`Option<NonNull<api::BunInstall>>`).
         bun_install_: Option<&Api::BunInstall>,
         subcommand: Subcommand,
     ) -> Result<(), bun_alloc::AllocError> {
         let mut base = Api::NpmRegistry::default();
-        // PORT NOTE: reshaped for borrowck — Zig captures `*Api.BunInstall` twice via `if (bun_install_) |config|`.
         let bun_install_ref = bun_install_;
         if let Some(config) = bun_install_ref {
             if let Some(registry) = &config.default_registry {
@@ -411,10 +403,10 @@ impl Options {
         if base.url.is_empty() {
             base.url = Npm::registry::DEFAULT_URL.as_bytes().into();
         }
-        // PORT NOTE: Zig passes `base` by-value (struct copy); clone so the
+        // Clone so the
         // `base.url` fallback below in the scoped-registry loop stays valid.
         self.scope = Npm::registry::Scope::from_api(b"", base.clone(), env)?;
-        // PORT NOTE: Zig `defer { this.did_override_default_scope = ... }` moved to end of fn;
+        // `did_override_default_scope` is set at the end of this fn;
         // on the OOM error path the field is irrelevant (process aborts).
 
         if let Some(config) = bun_install_ref {
@@ -442,7 +434,7 @@ impl Options {
                         self.ca.clone_from(ca_list);
                     }
                     Api::Ca::Str(ca_str) => {
-                        // Zig `&.{ca_str}` — single-element slice; own it (no `Box::leak`).
+                        // Single-element slice; own it (no `Box::leak`).
                         self.ca = vec![ca_str.clone()].into_boxed_slice();
                     }
                 }
@@ -586,7 +578,7 @@ impl Options {
             ];
             let mut did_set = false;
 
-            // PORT NOTE: was `inline for`; homogeneous elements → plain for.
+            // was `inline for`; homogeneous elements → plain for.
             for registry_key in REGISTRY_KEYS {
                 if !did_set {
                     if let Some(registry_) = env.get(registry_key) {
@@ -605,8 +597,7 @@ impl Options {
                             } else {
                                 Box::default()
                             };
-                            // PORT NOTE: was `std.mem.zeroes(Api.NpmRegistry)`; zeroed slices are
-                            // invalid in Rust — use Default (empty strings) which is semantically equivalent.
+                            // Default (empty strings) is the zero value for Api::NpmRegistry.
                             let api_registry = Api::NpmRegistry {
                                 url: registry_.into(),
                                 token,
@@ -628,7 +619,7 @@ impl Options {
             ];
             let mut did_set = false;
 
-            // PORT NOTE: was `inline for`; homogeneous elements → plain for.
+            // was `inline for`; homogeneous elements → plain for.
             for registry_key in TOKEN_KEYS {
                 if !did_set {
                     if let Some(registry_) = env.get(registry_key) {
@@ -648,7 +639,6 @@ impl Options {
         }
 
         if let Some(retry_count) = env.get(b"BUN_CONFIG_HTTP_RETRY_COUNT") {
-            // PORT NOTE: Zig `parseInt(u16, str, 10) catch null` — `Result` → `.ok()`.
             if let Ok(int) = bun_core::parse_int::<u16>(retry_count, 10) {
                 self.max_retry_count = int;
             }
@@ -778,7 +768,7 @@ impl Options {
                 } else {
                     LogLevel::Verbose
                 };
-                // SAFETY: main-thread CLI option load — single writer (Zig: `verbose_install = true`).
+                // SAFETY: main-thread CLI option load — single writer.
                 super::PackageManager::set_verbose_install(true);
             } else if cli.silent {
                 self.log_level = LogLevel::Silent;
@@ -804,7 +794,7 @@ impl Options {
             }
 
             if let Some(backend) = cli.backend {
-                // Zig: `PackageInstall.supported_method = backend` — atomic store,
+                // Atomic store,
                 // main-thread CLI option load (single writer).
                 crate::package_install::SUPPORTED_METHOD
                     .store(backend as u8, core::sync::atomic::Ordering::Relaxed);
@@ -904,7 +894,7 @@ impl Options {
             self.enable.set(Enable::FORCE_SAVE_LOCKFILE, false);
         }
 
-        // PORT NOTE: moved from `defer { ... }` after scope assignment (see note above).
+        // moved from `defer { ... }` after scope assignment (see note above).
         self.did_override_default_scope = self.scope.url_hash != *Npm::registry::DEFAULT_URL_HASH;
 
         Ok(())
@@ -978,7 +968,7 @@ impl Default for Enable {
     }
 }
 
-// Field-style accessors for Zig parity (`options.do.save_lockfile = false` /
+// Field-style accessors (`options.do.save_lockfile = false` /
 // `if options.do.install_packages { ... }`). The bitflags struct is `Copy`,
 // so getters return by value and setters take `&mut self`.
 impl Do {
@@ -1096,7 +1086,7 @@ impl Do {
     }
 }
 
-// Field-style accessors for Zig parity (`options.enable.cache = false` /
+// Field-style accessors (`options.enable.cache = false` /
 // `if options.enable.manifest_cache { ... }`). The bitflags struct is `Copy`,
 // so getters return by value and setters take `&mut self`.
 impl Enable {
@@ -1153,5 +1143,3 @@ impl Enable {
         self.contains(Enable::GLOBAL_VIRTUAL_STORE)
     }
 }
-
-// ported from: src/install/PackageManager/PackageManagerOptions.zig
diff --git a/src/install/PackageManager/PackageManagerResolution.rs b/src/install/PackageManager/PackageManagerResolution.rs
index e40202bae7f..acd304efc70 100644
--- a/src/install/PackageManager/PackageManagerResolution.rs
+++ b/src/install/PackageManager/PackageManagerResolution.rs
@@ -18,8 +18,7 @@ use super::PackageManager;
 use super::options::LogLevel;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Free-function re-export surface — Zig declares these at file scope with an
-// explicit `*PackageManager` first param. Thin shims over the
+// Free-function re-export surface. Thin shims over the
 // `impl PackageManager` bodies below so `pub use resolution::{...}` in
 // `PackageManager.rs` resolves (matching the directories/enqueue pattern).
 // ──────────────────────────────────────────────────────────────────────────
@@ -90,8 +89,7 @@ impl PackageManager {
         name_hash: PackageNameHash,
         resolution: &Resolution,
     ) -> Option<semver::version::Formatter<'_, u64>> {
-        // Zig forwards `package_name` → `scopeForPackageName` → `byNameHash`,
-        // but the `.load_from_memory` arm never reads scope; keep the param for
+        // The `.load_from_memory` arm never reads scope; keep the param for
         // signature parity.
         let _ = package_name;
         match resolution.tag {
@@ -102,9 +100,9 @@ impl PackageManager {
                     return None;
                 }
 
-                // PORT NOTE: reshaped for borrowck — Zig calls
-                // `this.manifests.byNameHash(this, …, .load_from_memory, …)`,
-                // which in Rust would require simultaneous `&mut self.manifests`
+                // reshaped for borrowck —
+                // `this.manifests.byNameHash(this, …, .load_from_memory, …)`
+                // would require simultaneous `&mut self.manifests`
                 // (receiver) and `&mut self` (arg). The memory-only path touches
                 // nothing on `PackageManager` besides the map, so use the
                 // disjoint-borrow helper and read `self.options` / `self.lockfile`
@@ -145,9 +143,7 @@ impl PackageManager {
         tags_buf: &mut Vec<u8>,
         package_name: &[u8],
     ) -> Result<Vec<semver::Version>, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut list: Vec<semver::Version> = Vec::new();
-        // Zig: `getCacheDirectory().openDir(package_name, .{ .iterate = true })`.
         let cache_dir = super::get_cache_directory(self);
         let dir = match bun_sys::Dir::borrow(&cache_dir)
             .open_at(package_name)
@@ -190,7 +186,6 @@ impl PackageManager {
             let mut version = parsed.version.min();
             let total = (version.tag.build.len() + version.tag.pre.len()) as usize;
             if total > 0 {
-                // PERF(port): was ensureUnusedCapacity — profile if hot
                 let len_before = tags_buf.len();
                 // `clone_into` writes exactly `total` bytes (build.len + pre.len)
                 // into `available` and advances it; zero-fill the tail first so
@@ -203,7 +198,6 @@ impl PackageManager {
             }
 
             list.push(version);
-            // PERF(port): was `catch unreachable` on append — Vec::push aborts on OOM
         }
 
         Ok(list)
@@ -220,8 +214,6 @@ impl PackageManager {
             return None;
         }
 
-        // PERF(port): was arena bulk-free (bun.ArenaAllocator + stackFallback(4096)) —
-        // profile if hot. Allocator params dropped; Vec uses global mimalloc.
         let mut tags_buf: Vec<u8> = Vec::new();
         let mut installed_versions =
             match self.get_installed_versions_from_disk_cache(&mut tags_buf, package_name) {
@@ -238,8 +230,7 @@ impl PackageManager {
         // TODO: make this fewer passes
         {
             let tags_slice: &[u8] = tags_buf.as_slice();
-            // Zig: `std.sort.pdq(..., sortGt)` — `sortGt` is `order == .gt`, so
-            // pdq sorts descending. Use the total-order helper with swapped args
+            // Sort descending. Use the total-order helper with swapped args
             // (`b.order(a)`) so equal keys yield `Equal`; a two-way Less/Greater
             // closure is not antisymmetric and may panic since Rust 1.81.
             installed_versions.sort_by(|a, b| semver::Version::order_fn(tags_slice, *b, *a));
@@ -306,7 +297,7 @@ impl PackageManager {
     }
 
     pub fn assign_resolution(&mut self, dependency_id: DependencyID, package_id: PackageID) {
-        // PORT NOTE: reshaped for borrowck — capture lengths before mutable borrows.
+        // reshaped for borrowck — capture lengths before mutable borrows.
         if cfg!(debug_assertions) {
             debug_assert!(
                 (dependency_id as usize) < self.lockfile.buffers.resolutions.as_slice().len()
@@ -327,7 +318,7 @@ impl PackageManager {
     }
 
     pub fn assign_root_resolution(&mut self, dependency_id: DependencyID, package_id: PackageID) {
-        // PORT NOTE: reshaped for borrowck — capture lengths before mutable borrows.
+        // reshaped for borrowck — capture lengths before mutable borrows.
         if cfg!(debug_assertions) {
             debug_assert!(
                 (dependency_id as usize) < self.lockfile.buffers.resolutions.as_slice().len()
@@ -425,5 +416,3 @@ impl PackageManager {
         }
     }
 }
-
-// ported from: src/install/PackageManager/PackageManagerResolution.zig
diff --git a/src/install/PackageManager/PopulateManifestCache.rs b/src/install/PackageManager/PopulateManifestCache.rs
index 3e437f62e5d..78df4289355 100644
--- a/src/install/PackageManager/PopulateManifestCache.rs
+++ b/src/install/PackageManager/PopulateManifestCache.rs
@@ -10,7 +10,7 @@ use crate::PackageID;
 use crate::Resolution;
 use crate::dependency::Behavior;
 use crate::invalid_package_id;
-// `Task::Id` is a namespaced type in Zig (`PackageManagerTask.Id`); import the
+// Import the
 // *module* under the `Task` name so `Task::Id` resolves as a path (matches
 // `runTasks.rs` / `PackageManagerEnqueue.rs`).
 use super::PackageManager;
@@ -51,7 +51,7 @@ fn start_manifest_task(
     needs_extended_manifest: bool,
 ) -> Result<(), StartManifestTaskError> {
     let task_id = Task::Id::for_manifest(pkg_name);
-    // PORT NOTE: Zig passes the *raw packed-struct bit* `dep.behavior.optional`
+    // Read the *raw* OPTIONAL bit
     // — not `Behavior.isOptional()` (which is `optional && !peer`). For
     // optional-peer deps the raw bit is `true` but `is_optional()` is `false`,
     // which would flip both the dedupe-map `is_required` bookkeeping and
@@ -63,24 +63,20 @@ fn start_manifest_task(
     }
     manager.start_progress_bar_if_none();
 
-    // PORT NOTE: reshaped for borrowck — Zig writes the whole struct via `.* = .{}`
-    // and reads `manager` again for `scopeForPackageName`. `get_network_task()`
+    // reshaped for borrowck — `get_network_task()`
     // borrows `&mut manager.preallocated_network_tasks`, so compute everything
     // that needs `&manager` *before* taking that borrow, then populate the pool
     // slot through a raw pointer (matches `runTasks::generate_network_task_for_tarball`).
     let scope = bun_ptr::BackRef::new(manager.scope_for_package_name(pkg_name));
     // Backref address only — stored, not dereffed in this function.
-    // TODO(port): lifetime — BACKREF.
     let manager_backref: *mut PackageManager = manager;
 
     // Take the pool slot as a raw pointer so borrowck releases `manager` for the
     // `enqueue_network_task` tail.
     let net_ptr: *mut NetworkTask = run_tasks::get_network_task(manager);
-    // Zig: `task.* = .{ .package_manager = manager, .callback = undefined,
-    //                   .task_id = task_id, .allocator = manager.allocator };`
-    // — full struct overwrite that resets every other field to its struct
-    // default. The slot may be uninitialized (heap fallback) or stale (reused
-    // hive slot).
+    // `write_init` is a full struct overwrite that resets every other field to
+    // its struct default. The slot may be uninitialized (heap fallback) or
+    // stale (reused hive slot).
     // SAFETY: `net_ptr` is the unique handle to a freshly-vended pool slot; no
     // other alias exists until we hand it to `enqueue_network_task`.
     unsafe { NetworkTask::write_init(net_ptr, task_id, manager_backref, None) };
@@ -108,7 +104,7 @@ pub enum Packages<'a> {
 }
 
 /// `RunTasksCallbacks` impl for the void-callback `runTasks` call in
-/// `populateManifestCache` (Zig passed an anonymous struct with `void` hooks).
+/// `populateManifestCache`.
 struct ManifestsOnlyCallbacks;
 impl RunTasksCallbacks for ManifestsOnlyCallbacks {
     type Ctx = ();
@@ -123,11 +119,10 @@ pub fn populate_manifest_cache(
     manager: &mut PackageManager,
     packages: Packages<'_>,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let log_level = manager.options.log_level;
 
-    // PORT NOTE: heavy borrowck overlap — Zig holds slices into
-    // `manager.lockfile` while the loop body calls `&mut`-taking methods on
+    // heavy borrowck overlap — slices into
+    // `manager.lockfile` are held while the loop body calls `&mut`-taking methods on
     // `manager`. The lockfile lives in `Box<Lockfile>` (stable address) and is
     // not resized by anything below, so derive the slices through a raw
     // provenance root and reborrow `manager` per-call.
@@ -283,7 +278,6 @@ pub fn populate_manifest_cache(
 
     if run_tasks::pending_task_count(manager) > 0 {
         struct RunClosure {
-            // PORT NOTE: Zig stores `*PackageManager` non-exclusively;
             // `sleep_until` also receives this raw pointer, so storing
             // `&mut PackageManager` here would alias under Stacked Borrows.
             manager: *mut PackageManager,
@@ -296,10 +290,9 @@ pub fn populate_manifest_cache(
                 // callback, so this is the unique live borrow.
                 let manager = unsafe { &mut *closure.manager };
                 let log_level = manager.options.log_level;
-                // PORT NOTE: void RunTasksCallbacks — `extract_ctx` is unit. Do NOT pass
-                // `manager` as both receiver and ctx (aliased &mut). Zig passed
-                // `(comptime *PackageManager, closure.manager)`; the generic context
-                // pair collapses to `&mut ()` in Rust.
+                // void RunTasksCallbacks — `extract_ctx` is unit. Do NOT pass
+                // `manager` as both receiver and ctx (aliased &mut); the generic
+                // context collapses to `&mut ()`.
                 if let Err(err) = run_tasks::run_tasks::<ManifestsOnlyCallbacks>(
                     manager,
                     &mut (),
@@ -341,5 +334,3 @@ pub fn populate_manifest_cache(
 
     Ok(())
 }
-
-// ported from: src/install/PackageManager/PopulateManifestCache.zig
diff --git a/src/install/PackageManager/ProgressStrings.rs b/src/install/PackageManager/ProgressStrings.rs
index 1f34b41cada..4d6865c1d91 100644
--- a/src/install/PackageManager/ProgressStrings.rs
+++ b/src/install/PackageManager/ProgressStrings.rs
@@ -10,8 +10,8 @@ use super::PackageManager;
 pub struct ProgressStrings;
 
 impl ProgressStrings {
-    // PORT NOTE: base *_NO_EMOJI_ / *_EMOJI consts stay &str because concatcp! requires str
-    // inputs; derived consts and fn returns are &[u8] per type-map ([]const u8 → &[u8]).
+    // The base *_NO_EMOJI_ / *_EMOJI consts stay &str because concatcp! requires str
+    // inputs; derived consts and fn returns are &[u8].
     pub const DOWNLOAD_NO_EMOJI_: &'static str = "Resolving";
     const DOWNLOAD_NO_EMOJI: &'static [u8] =
         concatcp!(ProgressStrings::DOWNLOAD_NO_EMOJI_, "\n").as_bytes();
@@ -114,8 +114,8 @@ impl PackageManager {
         // SAFETY: `node` is `self.downloads_node` / `self.scripts_node`, both of
         // which point at storage owned by (or outliving) this `PackageManager`
         // singleton; `progress_name_buf` is an inline field of that same
-        // singleton, so erasing the slice lifetime to `'static` matches Zig's
-        // raw-pointer aliasing (`node.name = this.progress_name_buf[..]`).
+        // singleton, so the buffer outlives every node that references it and
+        // erasing the slice lifetime to `'static` is sound.
         unsafe {
             let len = if Output::enable_ansi_colors_stderr() {
                 if IS_FIRST {
@@ -139,7 +139,7 @@ impl PackageManager {
 
     pub fn start_progress_bar(&mut self) {
         self.progress.supports_ansi_escape_codes = Output::enable_ansi_colors_stderr();
-        // PORT NOTE: `Progress::start` returns `&mut Node` borrowing `self.progress`;
+        // `Progress::start` returns `&mut Node` borrowing `self.progress`;
         // decay to a raw ptr immediately so the exclusive borrow ends before we
         // re-borrow `&mut self` for `set_node_name` / `progress.refresh()`.
         let node: *mut ProgressNode = self.progress.start(ProgressStrings::download(), 0);
@@ -176,8 +176,7 @@ impl PackageManager {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Free-function re-export surface — Zig declares these at file scope with an
-// explicit `*PackageManager` first param. Thin shims over the
+// Free-function re-export surface. Thin shims over the
 // `impl PackageManager` bodies above so `pub use progress_mod::{...}` in
 // `PackageManager.rs` resolves (matching the directories/enqueue pattern).
 // ──────────────────────────────────────────────────────────────────────────
@@ -206,5 +205,3 @@ pub fn start_progress_bar(manager: &mut PackageManager) {
 pub fn end_progress_bar(manager: &mut PackageManager) {
     manager.end_progress_bar()
 }
-
-// ported from: src/install/PackageManager/ProgressStrings.zig
diff --git a/src/install/PackageManager/UpdateRequest.rs b/src/install/PackageManager/UpdateRequest.rs
index 41d512c8dbf..5f00bcf1a4f 100644
--- a/src/install/PackageManager/UpdateRequest.rs
+++ b/src/install/PackageManager/UpdateRequest.rs
@@ -12,9 +12,10 @@ use bun_install::{
     Dependency, INVALID_PACKAGE_ID, Lockfile, PackageID, PackageManager, PackageNameHash,
 };
 // `lockfile.packages.items_name()` is provided by an extension trait on
-// `MultiArrayList<Package>` (Zig: `lockfile.packages.items(.name)`).
+// `MultiArrayList<Package>`.
 pub struct UpdateRequest {
-    // TODO(port): lifetime — Zig leaks these (no deinit); using &'static for now
+    // CLI positionals are
+    // process-lifetime, hence `&'static`.
     pub name: &'static [u8],
     pub name_hash: PackageNameHash,
     pub version: dependency::Version,
@@ -32,8 +33,9 @@ pub struct UpdateRequest {
     pub package_id: PackageID,
     pub is_aliased: bool,
     pub failed: bool,
-    /// This must be cloned to handle when the AST store resets
-    // TODO(port): lifetime — ARENA-owned (AST Expr.Data store); raw ptr per LIFETIMES.tsv
+    /// This must be cloned to handle when the AST store resets.
+    /// ARENA-owned (AST `Expr.Data` store) — raw pointer per LIFETIMES.tsv;
+    /// only valid while the store that allocated it is alive.
     pub e_string: Option<*mut js_ast::E::String>,
 }
 
@@ -126,8 +128,7 @@ impl UpdateRequest {
         }
     }
 
-    // NOTE: `pub const fromJS = @import("../../install_jsc/update_request_jsc.zig").fromJS;`
-    // deleted — in Rust, `from_js` lives on an extension trait in the `*_jsc` crate.
+    // NOTE: `from_js` lives on an extension trait in the `*_jsc` crate.
 
     pub fn parse<'a>(
         pm: Option<&mut PackageManager>,
@@ -139,8 +140,6 @@ impl UpdateRequest {
         Self::parse_with_error(pm, log, positionals, update_requests, subcommand, true)
             .unwrap_or_else(|_| Global::crash())
     }
-
-    // TODO(port): narrow error set — only `UnrecognizedDependencyFormat` is returned
     pub fn parse_with_error<'a>(
         mut pm: Option<&mut PackageManager>,
         log: &mut Log,
@@ -159,7 +158,7 @@ impl UpdateRequest {
                 // buffer of `input.len` bytes is always sufficient. Previously this was a
                 // fixed `[2048]u8` stack array which overflowed for longer positionals.
                 let mut temp = vec![0u8; input.len()];
-                // std.mem.replace(u8, input, "\\\\", "/", temp) — returns replacement count
+                // `strings::replace` returns the replacement count.
                 let len = strings::replace(&input, b"\\\\", b"/", &mut temp);
                 let new_len = input.len() - len;
                 let input2 = &mut temp[..new_len];
@@ -232,7 +231,6 @@ impl UpdateRequest {
 
                 return Err(bun_core::err!("UnrecognizedDependencyFormat"));
             };
-            // TODO(port): Dependency.Version tag/value layout — Zig uses separate .tag + .value union
             if alias.is_some() && version.tag == dependency::version::Tag::Git {
                 if let Some(ver) = Dependency::parse_with_optional_tag(
                     placeholder,
@@ -302,5 +300,3 @@ impl UpdateRequest {
 pub use super::Subcommand;
 pub use bun_install::package_manager::Options;
 pub use bun_install::package_manager::command_line_arguments as CommandLineArguments;
-
-// ported from: src/install/PackageManager/UpdateRequest.zig
diff --git a/src/install/PackageManager/WorkspacePackageJSONCache.rs b/src/install/PackageManager/WorkspacePackageJSONCache.rs
index f2cfaa3bbdf..e861062df2d 100644
--- a/src/install/PackageManager/WorkspacePackageJSONCache.rs
+++ b/src/install/PackageManager/WorkspacePackageJSONCache.rs
@@ -24,16 +24,13 @@ pub struct MapEntry {
     pub root: Expr,
     pub source: Source,
     pub indentation: Indentation,
-    /// Owns the path bytes that `source.path.{text,pretty,name.*}` borrow.
-    /// In Zig the duped path is stored as `entry.key_ptr.*` and `toSource`
-    /// is called on that same allocation, so the source's path slices stay
-    /// valid for the entry's lifetime. `StringHashMap` boxes its own key,
-    /// so keep the `dupeZ` alive here instead.
+    /// Owns the path bytes that `source.path.{text,pretty,name.*}` borrow,
+    /// so the source's path slices stay valid for the entry's lifetime.
+    /// `StringHashMap` boxes its own key, so keep the duped copy alive here.
     _path_storage: bun_core::ZBox,
     /// Owns the arena that backs decoded string bytes inside `root`.
-    /// Zig passes `bun.default_allocator` to the JSON parser so escape-decoded
-    /// `E.String.data` slices live forever; `deepClone` does *not* dupe them.
-    /// In Rust the parser takes a `&Arena`, so the arena must outlive the
+    /// `deepClone` does *not* dupe escape-decoded `E.String.data` slices.
+    /// The parser takes a `&Arena`, so the arena must outlive the
     /// cached AST — hold it here so it drops with the entry.
     ///
     /// Public so editors that splice new `Expr` nodes into `root`
@@ -76,12 +73,10 @@ impl MapEntry {
 
 pub type Map = StringHashMap<MapEntry>;
 
-// PORT NOTE: Zig `JSON.parsePackageJSONUTF8WithOpts` takes `comptime opts:
-// js_lexer.JSONOptions`; the Rust port (`bun_parsers::json`) spells those
+// `bun_parsers::json` spells the JSON options
 // out as 8 const-generic bools. The only field this module varies at runtime
-// is `guess_indentation` (because `GetJSONOptions` was demoted from comptime
-// to runtime), so dispatch on that one bool here and keep the rest fixed to
-// match the Zig call sites (.is_json/.allow_comments/.allow_trailing_commas
+// is `guess_indentation`, so dispatch on that one bool here and keep the rest
+// fixed (is_json/allow_comments/allow_trailing_commas
 // = true, others default false).
 fn parse_package_json(
     source: &Source,
@@ -137,7 +132,6 @@ pub enum GetResult<'a> {
 
 impl<'a> GetResult<'a> {
     pub fn unwrap(self) -> Result<&'a mut MapEntry, Error> {
-        // TODO(port): narrow error set
         match self {
             GetResult::Entry(entry) => Ok(entry),
             GetResult::ReadErr(err) => Err(err),
@@ -159,7 +153,6 @@ impl WorkspacePackageJSONCache {
         &mut self,
         log: &mut Log,
         abs_package_json_path: &[u8],
-        // PERF(port): was comptime monomorphization — profile if hot
         opts: GetJSONOptions,
     ) -> GetResult<'_> {
         debug_assert!(is_absolute(abs_package_json_path));
@@ -177,16 +170,15 @@ impl WorkspacePackageJSONCache {
             &buf[..abs_package_json_path.len()]
         };
 
-        // PORT NOTE: reshaped for borrowck — Zig `getOrPut` reserves a slot
-        // first and `remove`s on failure while still holding `entry.value_ptr`.
-        // Rust cannot hold the entry borrow across `self.map.remove`, so check
+        // reshaped for borrowck — we cannot hold an entry borrow across
+        // `self.map.remove`, so check
         // membership up front and only insert into the map after a successful
         // read+parse. Net map state is identical on every path.
         if self.map.contains_key(path) {
             return GetResult::Entry(self.map.get_mut(path).unwrap());
         }
 
-        // Zig: `allocator.dupeZ(u8, path)` — owned NUL-terminated copy reused
+        // Owned NUL-terminated copy reused
         // both as the map key and the path handed to `File.toSource`. The
         // returned `Source` *borrows* its `path` slices from this allocation,
         // so it must outlive the cached `MapEntry` (stored as
@@ -210,7 +202,6 @@ impl WorkspacePackageJSONCache {
         let parsed = match parse_package_json(&source, log, &json_bump, opts.guess_indentation) {
             Ok(p) => p,
             Err(err) => {
-                // Zig: `bun.handleErrorReturnTrace(err, @errorReturnTrace())` — no Rust equivalent.
                 return GetResult::ParseErr(err);
             }
         };
@@ -238,7 +229,6 @@ impl WorkspacePackageJSONCache {
         &mut self,
         log: &mut Log,
         source: &Source,
-        // PERF(port): was comptime monomorphization — profile if hot
         opts: GetJSONOptions,
     ) -> GetResult<'_> {
         debug_assert!(is_absolute(source.path.text()));
@@ -255,7 +245,7 @@ impl WorkspacePackageJSONCache {
             &buf[..text.len()]
         };
 
-        // PORT NOTE: reshaped for borrowck — see `get_with_path` above.
+        // reshaped for borrowck — see `get_with_path` above.
         if self.map.contains_key(path) {
             return GetResult::Entry(self.map.get_mut(path).unwrap());
         }
@@ -288,5 +278,3 @@ impl WorkspacePackageJSONCache {
         GetResult::Entry(entry.value_ptr)
     }
 }
-
-// ported from: src/install/PackageManager/WorkspacePackageJSONCache.zig
diff --git a/src/install/PackageManager/install_with_manager.rs b/src/install/PackageManager/install_with_manager.rs
index dae6ffbad2a..d1ab3976fe4 100644
--- a/src/install/PackageManager/install_with_manager.rs
+++ b/src/install/PackageManager/install_with_manager.rs
@@ -18,7 +18,7 @@ use crate::{
     invalid_package_id,
 };
 // Bring the typed `items_<field>()` column accessors into scope for
-// `MultiArrayList<Package>` / `Slice<Package>` (Zig: `packages.items(.field)`).
+// `MultiArrayList<Package>` / `Slice<Package>`.
 use super::Command;
 use crate::PackageManager;
 use crate::config_version::ConfigVersion;
@@ -32,10 +32,8 @@ use crate::package_manager::Options::Enable;
 use crate::package_manager::{Options, WorkspaceFilter};
 use bun_install_types::NodeLinker::NodeLinker;
 
-// Free-function "methods" on `*PackageManager` that the Zig source calls via
-// UFCS (`manager.foo(...)`) but which the Rust port hosts in sibling modules
-// to avoid one giant `impl PackageManager` block. Import them under their Zig
-// names so the body reads the same as the spec.
+// Free-function "methods" on `PackageManager` hosted in sibling modules
+// to avoid one giant `impl PackageManager` block.
 use crate::package_manager_real::run_tasks::{RunTasksCallbacks, run_tasks};
 use crate::package_manager_real::{
     enqueue_dependency_list, enqueue_dependency_with_main, enqueue_patch_task_pre, save_lockfile,
@@ -50,7 +48,6 @@ pub fn install_with_manager(
     root_package_json_path: &ZStr,
     original_cwd: &[u8],
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let log_level = manager.options.log_level;
 
     // Start resolving DNS for the default registry immediately.
@@ -59,7 +56,6 @@ pub fn install_with_manager(
         // And don't try to resolve DNS if it's an IP address.
         let scope_url = manager.options.scope.url.url();
         if !scope_url.hostname.is_empty() && !scope_url.is_ip_address() {
-            // PERF(port): was stack-fallback alloc — profile if hot
             bun_dns::internal::prefetch(
                 manager.event_loop.loop_(),
                 scope_url.hostname,
@@ -68,8 +64,8 @@ pub fn install_with_manager(
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig passes `manager`, `manager.lockfile`,
-    // and `manager.log` to `loadFromCwd` simultaneously. Route through a single
+    // reshaped for borrowck — `loadFromCwd` needs `manager`, `manager.lockfile`,
+    // and `manager.log` simultaneously. Route through a single
     // raw provenance root so the three reborrows share a tag.
     let load_result: lockfile::LoadResult = if manager.options.do_.load_lockfile() {
         let mgr: *mut PackageManager = manager;
@@ -181,16 +177,16 @@ pub fn install_with_manager(
                     }
                 };
 
-                // PORT NOTE: Zig copies `Source` by value; in Rust it's not `Copy`, so
+                // `Source` is not `Copy`, so
                 // clone it (cheap — `Source` is a few `Box<[u8]>` handles) so the
                 // `&mut *mgr` reborrow below doesn't conflict with the cache borrow.
                 let source_copy = root_package_json_entry.source.clone();
 
                 let mut resolver: () = ();
-                // PORT NOTE: Zig passes `manager`, `manager.log` and a fresh
+                // `parse` needs `manager`, `manager.log` and a fresh
                 // stack `lockfile` simultaneously. Route through raw ptrs so
                 // borrowck doesn't see overlapping `&mut PackageManager` /
-                // `&mut Lockfile` (Zig `*T` semantics).
+                // `&mut Lockfile`.
                 {
                     // `log_mut()` reads the BACKREF `self.log: *mut Log` and
                     // returns the disjoint CLI `Log` allocation (lifetime
@@ -214,9 +210,10 @@ pub fn install_with_manager(
                     .into_boxed_slice();
                 // @memset already done via vec! init
 
-                // PORT NOTE: Zig passes `manager`, `manager.log`, `manager.lockfile` and a
+                // `Diff::generate` (in lockfile_real::package) needs `manager`,
+                // `manager.log`, `manager.lockfile` and a
                 // fresh `lockfile` simultaneously. Route through raw ptrs to satisfy
-                // borrowck; `Diff::generate` is ported in lockfile_real::package.
+                // borrowck.
                 manager.summary = {
                     // `log_mut()` returns the disjoint CLI `Log` allocation
                     // (BACKREF field, lifetime decoupled from `&self`); read it
@@ -352,8 +349,8 @@ pub fn install_with_manager(
                         builder,
                     )?;
 
-                    // PORT NOTE: `ArrayHashMap::clone()` is an inherent fallible method (Zig:
-                    // `try trusted_dependencies.clone(allocator)`), not the `Clone` trait, so
+                    // `ArrayHashMap::clone()` is an inherent fallible method,
+                    // not the `Clone` trait, so
                     // `Option::clone` won't see it — map by hand.
                     *lf.trusted_dependencies = match &lockfile.trusted_dependencies {
                         Some(td) => Some(td.clone()?),
@@ -363,15 +360,14 @@ pub fn install_with_manager(
                     lf.dependencies.reserve(len as usize);
                     lf.resolutions.reserve(len as usize);
 
-                    // PORT NOTE: copy `old_resolutions` to a temporary Vec —
+                    // copy `old_resolutions` to a temporary Vec —
                     // the slice indexes into `buffers.resolutions`, which we're
                     // about to grow via spare-capacity writes / `set_len` below.
                     let old_resolutions: Vec<PackageID> =
                         old_resolutions_list.get(lf.resolutions).to_vec();
 
-                    // PORT NOTE: Zig slices raw spare capacity via `.items.ptr[off .. off + len]`,
-                    // `@memset`s it (no drop), then extends `.items.len`. `extend_from_fn`
-                    // mirrors that: writes into `spare_capacity_mut()` then bumps `len`, so we
+                    // `extend_from_fn`
+                    // writes into `spare_capacity_mut()` then bumps `len`, so we
                     // never form `&mut [T]` over uninitialized storage and never drop garbage.
                     debug_assert_eq!(lf.dependencies.len(), off as usize);
                     debug_assert_eq!(lf.resolutions.len(), off as usize);
@@ -408,7 +404,6 @@ pub fn install_with_manager(
                             // The string offsets will be wrong so fix them
                             let path = value.slice(&lockfile.buffers.string_bytes);
                             let str = builder.append::<SemverString>(path);
-                            // PERF(port): was assume_capacity
                             lf.workspace_paths.insert(*key, str);
                         }
                     }
@@ -421,7 +416,6 @@ pub fn install_with_manager(
                         for (key, value) in lockfile.workspace_versions.iter() {
                             // Copy version string offsets
                             let version = value.append(&lockfile.buffers.string_bytes, builder);
-                            // PERF(port): was assume_capacity
                             lf.workspace_versions.insert(*key, version);
                         }
                     }
@@ -432,10 +426,10 @@ pub fn install_with_manager(
                             let pkg_name_and_version_hash = *key;
                             debug_assert!(value.patchfile_hash_is_null);
                             let gop = lf.patched_dependencies.entry(pkg_name_and_version_hash);
-                            // PORT NOTE: ArrayHashMap getOrPut semantics → entry API approximation
+                            // ArrayHashMap getOrPut semantics → entry API approximation
                             match gop {
                                 bun_collections::array_hash_map::MapEntry::Vacant(v) => {
-                                    // PORT NOTE: `PatchedDep` has private padding/hash fields,
+                                    // `PatchedDep` has private padding/hash fields,
                                     // so the `..Default::default()` struct-update form is rejected
                                     // outside its module. Build via `default()` + field stores.
                                     let mut new = crate::lockfile_real::PatchedDep::default();
@@ -603,9 +597,9 @@ pub fn install_with_manager(
     manager.log_mut().reset();
 
     // This operation doesn't perform any I/O, so it should be relatively cheap.
-    // PORT NOTE: Zig copies the `*Lockfile` pointer, leaving `manager.lockfile` intact so both
-    // old and new lockfiles are live for the later `eql(lockfile_before_clean, ...)` checks.
-    // In Rust `manager.lockfile: Box<Lockfile>` would move; compute the new lockfile first, then
+    // Both old and new lockfiles must stay live for the later
+    // `eql(lockfile_before_clean, ...)` checks, but `manager.lockfile: Box<Lockfile>`
+    // would move; compute the new lockfile first, then
     // `mem::replace` so `lockfile_before_clean` owns the old box and `manager.lockfile` the new.
     let new_lockfile = {
         let mgr: *mut PackageManager = manager;
@@ -649,7 +643,6 @@ pub fn install_with_manager(
 
     // append scripts to lockfile before generating new metahash
     manager.load_root_lifecycle_scripts(&root);
-    // Zig: `defer { if (root_lifecycle_scripts) |s| allocator.free(s.package_name) }`.
     // `List.package_name` is `Box<[u8]>`, so dropping the whole `Option<List>`
     // at scope exit frees it. Route through a raw provenance root because
     // `manager: &mut` is reborrowed many times below; the guard fires once on
@@ -667,8 +660,8 @@ pub fn install_with_manager(
         root_scripts.append_to_lockfile(&mut manager.lockfile);
     }
     {
-        // PORT NOTE: reshaped for borrowck — Zig holds shared slices into
-        // `packages.items(.resolution/.meta/.scripts)` while pushing into
+        // reshaped for borrowck — shared slices into the
+        // resolution/meta/scripts columns are held while pushing into
         // `manager.lockfile.scripts`. Field-level split borrow keeps the two
         // disjoint columns alive simultaneously without raw-pointer routing.
         let lockfile = &mut *manager.lockfile;
@@ -693,12 +686,10 @@ pub fn install_with_manager(
                 debug_assert!(first_index != -1);
             }
 
-            // Zig's two arms differ only in whether the `first_index != -1`
-            // guard wraps the inner loop; in the `add_node_gyp` arm the
-            // assert already guarantees it, so a single guarded loop matches
+            // In the `add_node_gyp` arm the assert already guarantees
+            // `first_index != -1`, so a single guarded loop covers
             // both paths exactly.
             if first_index != -1 {
-                // PERF(port): was `inline for` over comptime entries — profile if hot
                 for (i, maybe_entry) in entries.into_iter().enumerate() {
                     if let Some(entry) = maybe_entry {
                         lockfile_scripts.hook_mut(i).push(entry);
@@ -776,14 +767,13 @@ pub fn install_with_manager(
 
     let (workspace_filters, install_root_dependencies) =
         get_workspace_filters(manager, original_cwd)?;
-    // `workspace_filters` drops at end of scope (Zig had `defer manager.allocator.free(workspace_filters)`)
+    // `workspace_filters` drops at end of scope
 
     let install_summary: PackageInstallSummary = 'install_summary: {
         if !manager.options.do_.install_packages() {
             break 'install_summary PackageInstallSummary::default();
         }
 
-        // Zig `linker: switch` with `continue :linker` — emulate with a small loop.
         let mut linker = manager.options.node_linker;
         loop {
             match linker {
@@ -823,7 +813,6 @@ pub fn install_with_manager(
                         &workspace_filters,
                         None,
                     )?;
-                    // PERF(port): was bun.handleOom — install_isolated_packages aborts on OOM internally now
                 }
             }
         }
@@ -911,12 +900,11 @@ pub fn install_with_manager(
 }
 
 // ─── runAndWaitFn closure family ──────────────────────────────────────────
-// Zig: `fn runAndWaitFn(comptime check_peers: bool, comptime only_pre_patch: bool) *const fn(*PackageManager) anyerror!void`
-// Ported as a const-generic struct + three thin wrapper fns.
+// A const-generic struct + three thin wrapper fns.
 
 /// `RunTasksCallbacks` impl for the void-callback `runTasks` call inside
-/// `runAndWaitFn::isDone` (Zig passed an anonymous struct with `void` hooks
-/// and `progress_bar = true`). Only the comptime flags differ from the default.
+/// `runAndWaitFn::isDone` (no hooks, `progress_bar = true`). Only these
+/// flags differ from the default.
 struct InstallWaitCallbacks;
 impl RunTasksCallbacks for InstallWaitCallbacks {
     type Ctx = ();
@@ -924,12 +912,12 @@ impl RunTasksCallbacks for InstallWaitCallbacks {
 }
 
 struct RunAndWaitClosure<const CHECK_PEERS: bool, const ONLY_PRE_PATCH: bool> {
-    // PORT NOTE: Zig stores `*PackageManager` here while the caller also holds the same
+    // The caller also holds the same
     // pointer to call `sleepUntil`. Storing `&mut PackageManager` would alias the outer
     // borrow in `run_and_wait`. Keep a raw pointer; `run_and_wait` derives this pointer
     // first and then reborrows *through it* for the `sleep_until` receiver, so both the
-    // receiver and the callback's reborrow share the same raw provenance root (Zig `*T`
-    // semantics). See `run_and_wait` for the remaining `tick`/`event_loop` overlap note.
+    // receiver and the callback's reborrow share the same raw provenance root.
+    // See `run_and_wait` for the remaining `tick`/`event_loop` overlap note.
     manager: *mut PackageManager,
     err: Option<bun_core::Error>,
 }
@@ -954,8 +942,7 @@ impl<const CHECK_PEERS: bool, const ONLY_PRE_PATCH: bool>
 
         this.drain_dependency_list();
 
-        // PORT NOTE: void RunTasksCallbacks — Zig passes an anon struct with
-        // `void` hooks and `progress_bar = true`. The Rust trait dispatch needs a
+        // void RunTasksCallbacks — the trait dispatch needs a
         // concrete `RunTasksCallbacks` impl; `extract_ctx` collapses to `()` so we
         // do NOT pass `this` as both receiver and ctx (would alias `&mut`).
         let log_level = this.options.log_level;
@@ -1119,11 +1106,11 @@ fn print_summary_tree(
     install_summary: &PackageInstallSummary,
     log_level: Options::LogLevel,
 ) -> Result<(), bun_core::Error> {
-    // PORT NOTE: reshaped for borrowck — Zig builds `Printer` borrowing
-    // `this.lockfile` / `this.options` while also passing `this` (the
-    // PackageManager) to `Tree::print`. Route through a single `*mut
+    // reshaped for borrowck — `Printer` borrows
+    // `this.lockfile` / `this.options` while `this` (the
+    // PackageManager) is also passed to `Tree::print`. Route through a single `*mut
     // PackageManager` provenance root and reborrow disjoint fields
-    // through it (Zig `*T` semantics): `Tree::print` only reads
+    // through it: `Tree::print` only reads
     // `manager.{updating_packages, workspace_name_hash}` and writes
     // `manager.track_installed_bin`, none of which overlap `lockfile` /
     // `options` / `update_requests`.
@@ -1150,7 +1137,7 @@ fn print_summary_tree(
     // We deliberately do not disable it after this.
     Output::enable_buffering();
     let writer = Output::writer_buffered();
-    // Runtime bool → comptime dispatch (Zig `switch (b) { inline else => |c| ... }`).
+    // Runtime bool → const-generic dispatch.
     if Output::enable_ansi_colors_stdout() {
         LockfilePrinter::Tree::print::<_, true>(
             &printer,
@@ -1348,8 +1335,8 @@ fn add_dependency_error(
     dependency: &Dependency,
     err: bun_core::Error,
 ) {
-    // PORT NOTE: reshaped for borrowck — capture the realname slice before
-    // taking `&mut` on `manager.log` (Zig held both via shared `*` pointers).
+    // reshaped for borrowck — capture the realname slice before
+    // taking `&mut` on `manager.log`.
     let realname = dependency.realname();
     let path = manager.lockfile.str(&realname).to_vec();
     let path_fmt = bun_core::fmt::fmt_path(
@@ -1444,7 +1431,7 @@ fn report_lockfile_load_error(
 #[inline(never)]
 fn record_updating_package_versions(manager: &mut PackageManager) {
     // existing lockfile, get the original version is updating
-    // PORT NOTE: reshaped for borrowck — Zig holds `*Lockfile` while
+    // reshaped for borrowck — the lockfile is read while
     // also mutating `manager.updating_packages`. Field-level split
     // borrow keeps the disjoint columns alive without raw pointers.
     let lockfile: &Lockfile = &manager.lockfile;
@@ -1729,7 +1716,7 @@ fn run_security_scanner(manager: &mut PackageManager, ctx: Command::Context, ori
             Global::exit(1);
         }
         Ok(Some(results)) => {
-            // `results` drops at end of scope (Zig had `defer results_mut.deinit()`)
+            // `results` drops at end of scope
             security_scanner::print_security_advisories(manager, &results);
 
             if results.has_fatal_advisories() {
@@ -1805,8 +1792,7 @@ fn write_yarn_lock_with_progress(
     manager: &mut PackageManager,
     log_level: Options::LogLevel,
 ) -> Result<(), bun_core::Error> {
-    // PORT NOTE: reshaped for borrowck — Zig holds `*Progress.Node` (returned by
-    // `progress.start`) across `writeYarnLock(manager)`. `Progress::start` returns
+    // reshaped for borrowck — `Progress::start` returns
     // `&mut self.root`, so re-access it via `manager.progress.root` after the
     // `&mut manager` borrow ends instead of keeping a live `&mut Node`.
     let mut node_started = false;
@@ -1852,10 +1838,8 @@ fn run_root_lifecycle_scripts(
         // have finished, and lockfiles have been saved
         let optional = false;
         let output_in_foreground = true;
-        // PORT NOTE: Zig passes `scripts.*` (deref-copy of the List).
         // `spawn_package_lifecycle_scripts` consumes by-value; `.take()`
-        // moves it out (Zig only frees `package_name` afterwards, which is
-        // owned by the List in Rust and drops with it).
+        // moves it out (`package_name` is owned by the List and drops with it).
         manager.spawn_package_lifecycle_scripts(
             ctx,
             scripts,
@@ -1877,5 +1861,3 @@ fn run_root_lifecycle_scripts(
     }
     Ok(())
 }
-
-// ported from: src/install/PackageManager/install_with_manager.zig
diff --git a/src/install/PackageManager/patchPackage.rs b/src/install/PackageManager/patchPackage.rs
index 4a87fdd677c..93903e0e56e 100644
--- a/src/install/PackageManager/patchPackage.rs
+++ b/src/install/PackageManager/patchPackage.rs
@@ -51,7 +51,6 @@ pub fn do_patch_commit(
     let mut folder_path_buf = PathBuffer::uninit();
     let mut lockfile: Box<Lockfile> = Box::default();
     let log = manager.log_mut();
-    // TODO(port): narrow error set
     match lockfile.load_from_cwd::<true>(Some(manager), log) {
         lockfile::LoadResult::NotFound => {
             Output::err_generic(
@@ -101,7 +100,7 @@ pub fn do_patch_commit(
         .root_package_id
         .get(&lockfile, manager.workspace_name_hash);
     let not_in_workspace_root = workspace_package_id != 0;
-    // PORT NOTE: reshaped for borrowck — owned buffer kept separately so `argument` can borrow it
+    // reshaped for borrowck — owned buffer kept separately so `argument` can borrow it
     let argument_owned: Option<Box<[u8]>>;
     let argument: &[u8] = if arg_kind == PatchArgKind::Path
         && not_in_workspace_root
@@ -141,7 +140,7 @@ pub fn do_patch_commit(
 
     let mut iterator = tree::Iterator::<{ tree::IteratorPathStyle::NodeModules }>::init(&lockfile);
     let mut resolution_buf = [0u8; 1024];
-    // PORT NOTE: reshaped for borrowck — `compute_cache_dir_and_subpath` borrows
+    // reshaped for borrowck — `compute_cache_dir_and_subpath` borrows
     // `manager` mutably while the package name/resolution borrow `lockfile`
     // (which itself sometimes aliases `manager.lockfile`). Clone the slice/
     // resolution out first, then compute, then assemble the result tuple.
@@ -437,7 +436,7 @@ pub fn do_patch_commit(
             }
             break 'has_bun_patch_tag Some(patch_tag);
         };
-        // PORT NOTE: deferred restore — one-off rename-back logic on every exit
+        // deferred restore — one-off rename-back logic on every exit
         // path of `'brk`. Captures borrow into stack buffers.
         scopeguard::defer! {
             if has_nested_node_modules || bun_patch_tag.is_some() {
@@ -629,7 +628,7 @@ pub fn do_patch_commit(
     }
 
     let mut patch_key = Vec::new();
-    // PORT NOTE: re-slice instead of reusing `resolution_label` so its borrow ends
+    // re-slice instead of reusing `resolution_label` so its borrow ends
     // before the `.patch` suffix write above; the prefix bytes are unchanged.
     write!(
         &mut patch_key,
@@ -680,8 +679,7 @@ fn escape_patch_filename(name: &[u8]) -> Option<Box<[u8]>> {
         }
     }
 
-    // PORT NOTE: Zig built this table via @typeInfo reflection over single-char enum field names.
-    // Rust has no equivalent; the table is filled by hand with the same entries.
+    // The table is filled by hand.
     const ESCAPE_TABLE: [EscapeVal; 256] = {
         let mut table = [EscapeVal::Other; 256];
         table[b'/' as usize] = EscapeVal::Slash;
@@ -736,7 +734,7 @@ pub fn prepare_patch(manager: &mut PackageManager) -> Result<(), bun_core::Error
         .root_package_id
         .get(&manager.lockfile, workspace_name_hash);
     let not_in_workspace_root = workspace_package_id != 0;
-    // PORT NOTE: reshaped for borrowck — owned buffer kept so `argument` can borrow it.
+    // reshaped for borrowck — owned buffer kept so `argument` can borrow it.
     let argument_owned: Option<Box<[u8]>>;
     let argument: &[u8] = if arg_kind == PatchArgKind::Path
         && not_in_workspace_root
@@ -808,7 +806,7 @@ pub fn prepare_patch(manager: &mut PackageManager) -> Result<(), bun_core::Error
                 let mut resolver: () = ();
                 let mut package = Package::default();
                 let log = manager.log_mut();
-                // PORT NOTE: borrowck — `parse_with_json` needs `&mut Lockfile` and
+                // borrowck — `parse_with_json` needs `&mut Lockfile` and
                 // `&mut PackageManager` simultaneously, but the lockfile here is
                 // `manager.lockfile`. Temporarily move the Box out so the two
                 // borrows are disjoint; `parse_with_json` never reads `pm.lockfile`
@@ -864,7 +862,6 @@ pub fn prepare_patch(manager: &mut PackageManager) -> Result<(), bun_core::Error
 
                 let name = lockfile.str(&package.name).to_vec();
                 let existing_patchfile_hash: Option<u64> = 'existing_patchfile_hash: {
-                    // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
                     let mut name_and_version = Vec::new();
                     write!(
                         &mut name_and_version,
@@ -922,7 +919,6 @@ pub fn prepare_patch(manager: &mut PackageManager) -> Result<(), bun_core::Error
                 let pkg_name = pkg.name.slice(strbuf).to_vec();
 
                 let existing_patchfile_hash: Option<u64> = 'existing_patchfile_hash: {
-                    // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
                     let mut name_and_version = Vec::new();
                     write!(
                         &mut name_and_version,
@@ -1144,7 +1140,7 @@ fn overwrite_package_in_node_modules_folder(
     // FileCopier's path fields are `.unit = .os` (u16 on Windows). `Path::from`
     // is generic over the *input* width and converts internally, so accepting
     // `&[u8]` and producing `Path<OSPathChar>` is intentional. `.sep = .auto`
-    // (Zig spec) is required so `/` is normalized to `\` on Windows — the inputs
+    // is required so `/` is normalized to `\` on Windows — the inputs
     // here arrive posix-normalized and are later passed to Win32 APIs.
     let dest_subpath = bun_paths::Path::<
         bun_paths::OSPathChar,
@@ -1206,7 +1202,7 @@ fn overwrite_package_in_node_modules_folder(
 
 type NodeModulesIterator<'a> = tree::Iterator<'a, { tree::IteratorPathStyle::NodeModules }>;
 
-// PORT NOTE: reshaped for borrowck — `tree::Iterator::next` returns an
+// reshaped for borrowck — `tree::Iterator::next` returns an
 // `IteratorNext<'_>` borrowing the iterator's internal `path_buf`, so we
 // cannot return it from inside a `while let` (borrowck rejects the next
 // iteration's reborrow even though it's unreachable). Callers only need
@@ -1253,7 +1249,6 @@ fn pkg_info_for_name_and_version(
     name: &[u8],
     version: Option<&[u8]>,
 ) -> (PackageID, Vec<u8>) {
-    // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
     let mut pairs: Vec<IdPair> = Vec::with_capacity(8);
 
     let name_hash = string_hash(name);
@@ -1419,7 +1414,7 @@ fn pkg_info_for_name_and_version(
     Global::crash();
 }
 
-// PORT NOTE: takes `workspace_package_id` directly instead of `&mut PackageManager` —
+// takes `workspace_package_id` directly instead of `&mut PackageManager` —
 // both callers already compute it via `root_package_id.get()` immediately before, and
 // passing `manager` here would alias `&manager.lockfile` in `prepare_patch`.
 fn path_argument_relative_to_root_workspace_package(
@@ -1449,14 +1444,11 @@ impl PatchArgKind {
         if strings::contains(argument, b"node_modules/") {
             return PatchArgKind::Path;
         }
-        // PORT NOTE: spec asymmetry — Zig (patchPackage.zig:1028) uses `hasPrefix`
-        // for the Windows-backslash arm but `contains` for the posix arm above.
-        // Match the spec exactly; if this is a Zig bug, fix both sides separately.
+        // Intentional asymmetry — the Windows-backslash arm uses `has_prefix`
+        // while the posix arm above uses `contains`.
         if cfg!(windows) && strings::has_prefix(argument, b"node_modules\\") {
             return PatchArgKind::Path;
         }
         PatchArgKind::NameAndVersion
     }
 }
-
-// ported from: src/install/PackageManager/patchPackage.zig
diff --git a/src/install/PackageManager/processDependencyList.rs b/src/install/PackageManager/processDependencyList.rs
index 86b2be564d3..9fbbd4b114d 100644
--- a/src/install/PackageManager/processDependencyList.rs
+++ b/src/install/PackageManager/processDependencyList.rs
@@ -30,7 +30,7 @@ pub struct GitResolver<'a> {
     pub resolved: &'a [u8],
     pub resolution: &'a Resolution,
     pub dep_id: DependencyID,
-    /// Zig: `new_name: []u8 = ""` — owned scratch buffer that
+    /// Owned scratch buffer that
     /// `Package::parse_with_json` may assign when the package.json `name`
     /// field is missing (see `ResolverContext::set_new_name`).
     pub new_name: Vec<u8>,
@@ -52,8 +52,6 @@ impl<'a> ResolverContext for GitResolver<'a> {
         builder: &mut StringBuilder<'_>,
         _json: &Expr,
     ) -> Result<ResolutionType<u64>, bun_core::Error> {
-        // Zig: `var resolution = this.resolution.*;
-        //       resolution.value.github.resolved = builder.append(String, this.resolved);`
         // `git` and `github` share the `Repository` payload in the value union,
         // so writing through `.github` is correct for both tags.
         // SAFETY: caller guarantees `tag` is `.git` or `.github` (see
@@ -200,7 +198,6 @@ impl PackageManager {
                         let mut builder = self.lockfile.string_builder();
 
                         builder.count(&new_name);
-                        // Zig passed `undefined` for the unused `JSAst.Expr` arg.
                         resolver.count(&mut builder, &Expr::default());
 
                         bun_core::handle_oom(builder.allocate());
@@ -303,7 +300,7 @@ impl PackageManager {
                         &bun_ast::Source::init_path_string(&json.path[..], &json.buf[..]);
                     initialize_store();
                     // SAFETY: `self.log` is set once by `PackageManager::init()` and
-                    // never null while tasks run (mirrors Zig's non-optional `*logger.Log`).
+                    // never null while tasks run.
                     let log = self.log_mut();
                     let bump = bun_alloc::Arena::new();
                     let json_root = match json::parse_package_json_utf8(
@@ -324,15 +321,13 @@ impl PackageManager {
                             Global::crash();
                         }
                     };
-                    // PORT NOTE (spec parity): Zig writes
-                    //   var scripts = manager.lockfile.packages.items(.scripts)[package_id.*];
-                    // which COPIES the `Scripts` struct into a local; the
-                    // subsequent `parseAlloc` / `.filled = true` mutate the
-                    // local and are never stored back, so
-                    // `lockfile.packages[id].scripts` is not updated. This is
-                    // a latent dead-store bug in processDependencyList.zig,
-                    // but we match it exactly so .rs/.zig observable behavior
-                    // agree. The `builder` appends still land in
+                    // Intentional dead store: `scripts` is a local copy of
+                    // `lockfile.packages[id].scripts`, and the `parse_alloc` /
+                    // `.filled = true` mutations are never stored back, so
+                    // `lockfile.packages[id].scripts` is not updated. The
+                    // original implementation had this same latent dead-store
+                    // bug, and we match it exactly so observable behavior
+                    // agrees. The `builder` appends still land in
                     // `lockfile.buffers.string_bytes`, preserving that side
                     // effect. (Hoisted above `string_builder()` for borrowck —
                     // `parse_count`/`allocate` don't touch `packages`.)
@@ -360,8 +355,8 @@ impl PackageManager {
     ) -> Result<(), bun_core::Error> {
         match *item {
             TaskCallbackContext::Dependency(dependency_id) => {
-                // PORT NOTE: reshaped for borrowck — clone the dependency row
-                // out of the buffer before re-borrowing `self` for enqueue.
+                // Clone the dependency row out of the buffer before
+                // re-borrowing `self` for enqueue.
                 let dependency = Clone::clone(
                     &self.lockfile.buffers.dependencies.as_slice()[dependency_id as usize],
                 );
@@ -408,8 +403,8 @@ impl PackageManager {
 
     pub fn process_peer_dependency_list(&mut self) -> Result<(), bun_core::Error> {
         while let Some(peer_dependency_id) = self.peer_dependencies.read_item() {
-            // PORT NOTE: reshaped for borrowck — clone the dependency row out
-            // of the buffer before re-borrowing `self` for enqueue.
+            // Clone the dependency row out of the buffer before re-borrowing
+            // `self` for enqueue.
             let dependency = Clone::clone(
                 &self.lockfile.buffers.dependencies.as_slice()[peer_dependency_id as usize],
             );
@@ -427,10 +422,6 @@ impl PackageManager {
         Ok(())
     }
 
-    /// Zig: `callbacks` was `comptime anytype` with a
-    /// `@TypeOf(callbacks) != void and @TypeOf(callbacks.onResolve) != void`
-    /// check. Modeled as `Option<impl FnOnce(C)>` — only `onResolve` is ever
-    /// read, and the void path is `None`.
     pub fn process_dependency_list<C>(
         &mut self,
         dep_list: TaskCallbackList,
@@ -459,8 +450,7 @@ impl PackageManager {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Free-function re-export surface — Zig declares these at file scope with an
-// explicit `*PackageManager` first param. Thin shims over the
+// Free-function re-export surface — thin shims over the
 // `impl PackageManager` bodies above so `pub use process_dependency_list::{…}`
 // in `PackageManager.rs` resolves (matching the directories/enqueue pattern).
 // ──────────────────────────────────────────────────────────────────────────
diff --git a/src/install/PackageManager/runTasks.rs b/src/install/PackageManager/runTasks.rs
index b7952a25722..cc6b53c3a3e 100644
--- a/src/install/PackageManager/runTasks.rs
+++ b/src/install/PackageManager/runTasks.rs
@@ -17,8 +17,7 @@ use bun_install::{
     DependencyID, ExtractTarball, INVALID_PACKAGE_ID, NetworkTask, PackageID, PackageManifestError,
     Repository,
 };
-// `Task::Id` etc. are namespaced types in Zig (`PackageManagerTask.Id`); import
-// the *module* under the `Task` name so `Task::Id` resolves as a path.
+// Import the *module* under the `Task` name so `Task::Id` resolves as a path.
 use super::{
     Command, PackageInstaller, PackageManager, ProgressStrings, Subcommand, TaskCallbackList,
 };
@@ -32,8 +31,7 @@ use crate::package_manifest_map::Value as ManifestEntry;
 use bun_core::fmt::PathSep;
 use bun_install::lockfile::Package;
 use bun_install::package_manager_task as Task;
-// `Options::LogLevel` etc. are namespaced types in Zig (`PackageManager.Options.LogLevel`);
-// import the *module* under the `Options` name so `Options::LogLevel` resolves as a path
+// Import the *module* under the `Options` name so `Options::LogLevel` resolves as a path
 // (matches the `Task` module-alias pattern above and `CommandLineArguments.rs`).
 use super::package_manager_options as Options;
 use super::package_manager_options::{Do, Enable};
@@ -43,15 +41,14 @@ use crate::isolated_install::store as Store;
 // Callbacks trait
 // ──────────────────────────────────────────────────────────────────────────
 //
-// The Zig `runTasks` takes `comptime Ctx: type` + `comptime callbacks: anytype`
-// and branches on `@TypeOf(callbacks.onExtract) != void`, `Ctx == *PackageInstaller`,
-// etc. Rust models this as a single trait with associated consts gating the
+// A single trait with associated consts gating the
 // optional hooks (default-unreachable bodies), plus associated-const tags for
-// the `Ctx` identity checks. Phase B should revisit whether the call sites can
-// be split into 2–3 concrete impls instead of const-gated branches.
-//
-// TODO(port): callbacks trait — comptime duck-typing reshape; verify against
-// the three call sites (`PackageInstaller`, `Store.Installer`, void) in Phase B.
+// the `Ctx` identity checks. The trait branches on three `Ctx` identities
+// (`PackageInstaller`, `Store.Installer`, neither), but there are six impls
+// across four `Ctx` shapes: `PackageInstaller` (`HoistedRunTasksCallbacks`),
+// `Store::Installer` (`StoreRunTasksCallbacks`), unit
+// (`VoidRunTasksCallbacks`, `ManifestsOnlyCallbacks`, `InstallWaitCallbacks`),
+// and `Queue` (`QueueRunTasksCallbacks` in `src/jsc/AsyncModule.rs`).
 pub trait RunTasksCallbacks {
     /// Mirrors `Ctx` (the `extract_ctx` value type).
     type Ctx;
@@ -78,11 +75,11 @@ pub trait RunTasksCallbacks {
         unreachable!()
     }
 
-    // PORT NOTE: Zig calls `onPackageDownloadError` with two distinct shapes
-    // depending on the comptime `Ctx`: `task.task_id: Task.Id` for
-    // `*Store.Installer`, `package_id: PackageID` otherwise. Model the
-    // comptime branch as static dispatch via two trait methods so impls
-    // receive the correctly-typed id without a `Task::Id` round-trip pun.
+    // `onPackageDownloadError` is called with two distinct shapes depending
+    // on the `Ctx`: `task.task_id: Task::Id` for the store installer,
+    // `package_id: PackageID` otherwise. Static dispatch via two trait
+    // methods lets impls receive the correctly-typed id without a
+    // `Task::Id` round-trip pun.
     fn on_package_download_error_store(
         _ctx: &mut Self::Ctx,
         _task_id: Task::Id,
@@ -122,16 +119,14 @@ pub trait RunTasksCallbacks {
     }
 
     /// Reinterpret `&mut Self::Ctx` as `&mut PackageInstaller` — only valid
-    /// when `IS_PACKAGE_INSTALLER` is true (Zig: `Ctx == *PackageInstaller`
-    /// comptime check). Default body is unreachable; the `PackageInstaller`
+    /// when `IS_PACKAGE_INSTALLER` is true. Default body is unreachable; the `PackageInstaller`
     /// impl overrides it with an identity cast.
     fn as_package_installer<'a>(_ctx: &'a mut Self::Ctx) -> &'a mut PackageInstaller<'a> {
         unreachable!()
     }
 
     /// Reinterpret `&mut Self::Ctx` as `&mut Store::Installer` — only valid
-    /// when `IS_STORE_INSTALLER` is true (Zig: `Ctx == *Store.Installer`
-    /// comptime check). Default body is unreachable; the `Store::Installer`
+    /// when `IS_STORE_INSTALLER` is true. Default body is unreachable; the `Store::Installer`
     /// impl overrides it with an identity cast.
     fn as_store_installer<'a>(_ctx: &'a mut Self::Ctx) -> &'a mut Store::Installer<'a> {
         unreachable!()
@@ -152,11 +147,10 @@ pub fn run_tasks<C: RunTasksCallbacks>(
 
     let mut timestamp_this_tick: Option<u32> = None;
 
-    // Zig: `defer { manager.drainDependencyList(); ... progress update ... }`
-    // PORT NOTE: scopeguard captures `manager` via raw pointer because the loop
+    // scopeguard captures `manager` via raw pointer because the loop
     // body holds `&mut` to it for the function's duration; `has_updated_this_run`
     // is a `Cell<bool>` so the guard captures it by shared ref. The guard runs
-    // on every exit (incl. `?` early-returns), matching Zig `defer` semantics.
+    // on every exit (incl. `?` early-returns).
     //
     // Stacked Borrows: the raw pointers must remain the provenance root for all
     // body accesses, otherwise the first direct use of the `&mut` fn params
@@ -207,7 +201,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
         // SAFETY: `next()` returned non-null; node is exclusively owned by this
         // batch. `ptask_ptr` was produced by `heap::alloc` in `PatchTask::new_*`
         // — reclaim ownership exactly once here so the `Box` drops at end of
-        // iteration on every path (Zig: `defer ptask.deinit();`).
+        // iteration on every path.
         let mut ptask = unsafe { bun_core::heap::take(ptask_ptr) };
         if cfg!(debug_assertions) {
             debug_assert!(manager.pending_task_count() > 0);
@@ -221,13 +215,10 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                         // autofix
                     } else if C::IS_PACKAGE_INSTALLER {
                         if let Some(ctx) = apply.install_context.as_mut() {
-                            // Zig: `Ctx == *PackageInstaller` so `extract_ctx`
-                            // *is* the installer.
+                            // `extract_ctx` *is* the installer here.
                             let installer: &mut PackageInstaller =
                                 C::as_package_installer(extract_ctx);
                             let path = core::mem::take(&mut ctx.path);
-                            // Zig: `ctx.path = std.array_list.Managed(u8).init(bun.default_allocator);`
-                            // → `Vec::new()` via `mem::take` above.
                             installer.node_modules.path = path;
                             installer.current_tree_id = ctx.tree_id;
                             let pkg_id = apply.pkg_id;
@@ -252,9 +243,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
     }
 
     if C::IS_STORE_INSTALLER {
-        // PORT NOTE: reshaped for borrowck — Zig writes `const installer:
-        // *Store.Installer = extract_ctx;` and freely aliases
-        // `installer.manager` with the outer `manager`. Here we obtain the
+        // We obtain the
         // installer via the trait downcast and access PackageManager only
         // through `installer.manager` for the duration of this block, never
         // via the function-scope `manager` shadow, so the two `&mut` do not
@@ -294,13 +283,12 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     // SAFETY: `list` is the per-entry scripts slot owned by
                     // `store.entries.items_scripts()[entry_id]`; this Task is
                     // its sole consumer (see Installer.rs Yield::RunScripts).
-                    // Zig: `list.*` — by-value copy of the List.
                     let list_val = unsafe { (*list).clone() };
-                    // PORT NOTE: reshaped for borrowck — `Command::Context<'a>`
+                    // reshaped for borrowck — `Command::Context<'a>`
                     // is `&'a mut ContextData`; reborrow instead of moving the
                     // field out of `*installer`.
                     let command_ctx: Command::Context<'_> = &mut *installer.command_ctx;
-                    // PORT NOTE: `installer.manager == manager` (same allocation,
+                    // `installer.manager == manager` (same allocation,
                     // see fn-signature note); call via the body shadow which is a
                     // reborrow of `manager_ptr` — no extra unsafe alias needed.
                     let spawn_res = manager.spawn_package_lifecycle_scripts(
@@ -360,7 +348,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                 name,
                 is_extended_manifest,
             } => {
-                // PORT NOTE: reshaped for borrowck — capture the name's slice
+                // reshaped for borrowck — capture the name's slice
                 // pointer (`StringOrTinyString` is self-referential and not
                 // `Clone`) so the loop body can read `name` after the
                 // `&mut task.callback` borrow ends.
@@ -555,11 +543,10 @@ pub fn run_tasks<C: RunTasksCallbacks>(
 
                         manifest.pkg.public_max_age = timestamp_this_tick.unwrap();
 
-                        // PORT NOTE: reshaped for borrowck — Zig writes through
-                        // the `getOrPut` slot then re-reads it for `saveAsync`.
+                        // reshaped for borrowck —
                         // `bun_collections::HashMap` lacks `get_or_put` for
                         // non-`Default` values, so insert by-value (overwriting
-                        // any prior entry, matching Zig semantics) and reborrow.
+                        // any prior entry) and reborrow.
                         let name_hash = manifest.pkg.name.hash;
                         manager
                             .manifests
@@ -567,7 +554,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                             .insert(name_hash, ManifestEntry::Manifest(manifest));
 
                         if manager.options.enable.contains(Enable::MANIFEST_CACHE) {
-                            // PORT NOTE: reshaped for borrowck — compute the
+                            // reshaped for borrowck — compute the
                             // `&mut`-taking directory accessors first so the
                             // shared `scope_for_package_name` / `manifests`
                             // borrows below do not overlap them. `save_async`
@@ -611,7 +598,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     }
                 }
 
-                // PORT NOTE: reshaped — `enqueue_parse_npm_package` takes
+                // reshaped — `enqueue_parse_npm_package` takes
                 // `StringOrTinyString` by value; reconstruct from the slice we
                 // captured (the original lives in `task.callback`, which the
                 // enqueued resolve Task takes ownership of via `network`).
@@ -620,7 +607,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     &mut crate::network_task::filename_store_appender(),
                 )
                 .expect("unreachable");
-                // PORT NOTE: reshaped for borrowck — split the nested `&mut
+                // reshaped for borrowck — split the nested `&mut
                 // manager` borrows (`task_batch.push` vs. `enqueue_*`).
                 // SAFETY: `task_ptr` is non-null (checked by the iterator loop guard)
                 // and exclusively owned by this batch; `manager` is the live PackageManager.
@@ -630,7 +617,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                 manager.task_batch.push(ThreadPoolBatch::from(queued));
             }
             NetworkTaskCallback::Extract(extract) => {
-                // PORT NOTE: reshaped for borrowck — `extract` borrows
+                // reshaped for borrowck — `extract` borrows
                 // `task.callback`; the body also calls `&mut self` methods on
                 // `task` (`reset_streaming_for_retry`,
                 // `discard_unused_streaming_state`) which only touch disjoint
@@ -911,7 +898,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     }
                 }
 
-                // PORT NOTE: reshaped for borrowck — split nested `&mut manager`.
+                // reshaped for borrowck — split nested `&mut manager`.
                 let queued = enqueue::enqueue_extract_npm_package(manager, &*extract, task_ptr);
                 manager.task_batch.push(ThreadPoolBatch::from(queued));
             }
@@ -929,8 +916,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
         if cfg!(debug_assertions) {
             debug_assert!(manager.pending_task_count() > 0);
         }
-        // Zig: `defer manager.preallocated_resolve_tasks.put(task);`
-        // PORT NOTE: raw-ptr capture — borrowck would reject overlapping `&mut`
+        // raw-ptr capture — borrowck would reject overlapping `&mut`
         // with the loop body. Guard runs on every `continue`/`?`/fallthrough.
         // Phase B: have the iterator yield a pool guard that puts back on Drop.
         // SAFETY: `task_ptr` non-null per loop guard; node exclusively owned by this batch.
@@ -953,8 +939,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
         if !task.log.msgs.is_empty() {
             // `IntoLogWrite` is implemented for `*mut bun_core::io::Writer`,
             // not `&mut Writer` (the underlying `Writer` is the FFI shape).
-            // Zig: `try task.log.print(Output.errorWriter())` — propagate the
-            // write error (WriteFailed) out of `runTasks`.
+            // Propagate the write error (WriteFailed) out of `run_tasks`.
             task.log.print(std::ptr::from_mut(Output::error_writer()))?;
             if task.log.errors > 0 {
                 manager.any_failed_to_install = true;
@@ -964,8 +949,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
 
         match task.tag {
             Task::Tag::PackageManifest => {
-                // Zig: `defer manager.preallocated_network_tasks.put(task.request.package_manifest.network);`
-                // PORT NOTE: capture the `*mut NetworkTask` up front — the
+                // capture the `*mut NetworkTask` up front — the
                 // `&'a mut NetworkTask` field can't be moved out through
                 // `ManuallyDrop`'s immutable `Deref` inside the defer body.
                 let net_ptr: *mut NetworkTask = {
@@ -1049,8 +1033,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                 }
             }
             Task::Tag::Extract | Task::Tag::LocalTarball => {
-                // Zig: `defer { switch (task.tag) { .extract => preallocated_network_tasks.put(...), else => {} } }`
-                // PORT NOTE: capture the `*mut NetworkTask` up front (only for the
+                // capture the `*mut NetworkTask` up front (only for the
                 // Extract arm) so the defer body need not move the `&mut` out
                 // through `ManuallyDrop`'s immutable `Deref`.
                 let net_ptr: *mut NetworkTask = if task.tag == Task::Tag::Extract {
@@ -1174,7 +1157,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     } else if C::IS_STORE_INSTALLER {
                         C::on_extract_store_installer(extract_ctx, task.id);
                     } else {
-                        // Zig: @compileError("unexpected context type")
                         unreachable!("unexpected context type");
                     }
                 } else if let Some(pkg) = manager.process_extracted_tarball_package(
@@ -1199,7 +1181,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                             core::mem::take(entry)
                         };
 
-                        // Zig: `defer { dependency_list.deinit(); if (any_root) callbacks.onResolve(extract_ctx); }`
                         scopeguard::defer! {
                             if C::HAS_ON_RESOLVE && any_root.get() {
                                 // SAFETY: `extract_ctx_ptr` is the function-scope provenance
@@ -1239,7 +1220,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                                 _ => {
                                     // if it's a node_module folder to install, handle that after we process all the dependencies within the onExtract callback.
                                     manager.task_queue.get_mut(&task.id).unwrap().push(dep);
-                                    // PERF(port): was `catch unreachable` — Vec::push aborts on OOM
                                 }
                             }
                         }
@@ -1254,7 +1234,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     // Peer dependencies do not initiate any downloads of their own, thus need to be resolved here instead
                     let dependency_list = core::mem::take(dependency_list_entry);
 
-                    // Zig passes `void, {}, {}` for Ctx/ctx/callbacks here.
                     manager.process_dependency_list(
                         dependency_list,
                         (),
@@ -1367,8 +1346,8 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     // this dependency might be something other than a git dependency! only need the name and
                     // behavior, use the resolution from the task.
                     let dep_id = clone.dep_id;
-                    // PORT NOTE: reshaped for borrowck — Zig copies `dep` by
-                    // value. Copy the small `String` handles + behavior bit so
+                    // reshaped for borrowck — copy the small `String` handles
+                    // + behavior bit so
                     // the `&manager.lockfile` borrow doesn't extend across the
                     // `&mut manager` calls (`has_created_network_task`,
                     // `enqueue_git_checkout`) below; detach the slice backing
@@ -1382,8 +1361,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     // enqueued for git resolutions; `value.git` is the active arm.
                     let git = *clone.res.git();
                     // SAFETY: `string_bytes` lives as long as `manager.lockfile`
-                    // and is not reallocated while resolve tasks are draining
-                    // (Zig: same buffer is read after `enqueueGitCheckout`).
+                    // and is not reallocated while resolve tasks are draining.
                     let string_buf = unsafe {
                         bun_ptr::detach_lifetime(manager.lockfile.buffers.string_bytes.as_slice())
                     };
@@ -1407,7 +1385,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                         continue;
                     }
 
-                    // PORT NOTE: reshaped for borrowck — split nested `&mut manager`.
+                    // reshaped for borrowck — split nested `&mut manager`.
                     let queued = enqueue::enqueue_git_checkout(
                         manager,
                         checkout_id,
@@ -1503,7 +1481,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                     } else if C::IS_STORE_INSTALLER {
                         C::on_extract_store_installer(extract_ctx, task.id);
                     } else {
-                        // Zig: @compileError("unexpected context type")
                         unreachable!("unexpected context type");
                     }
                 } else if let Some(pkg) = manager.process_extracted_tarball_package(
@@ -1525,7 +1502,6 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                             core::mem::take(entry)
                         };
 
-                        // Zig: `defer { dependency_list.deinit(); if (any_root) callbacks.onResolve(extract_ctx); }`
                         scopeguard::defer! {
                             if C::HAS_ON_RESOLVE && any_root.get() {
                                 // SAFETY: `extract_ctx_ptr` is the function-scope provenance
@@ -1546,7 +1522,8 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                                             .value
                                             .git
                                     };
-                                    // SAFETY: `pkg.resolution.value` is a Zig `extern union`;
+                                    // SAFETY: `pkg.resolution.value` is an untagged union
+                                    // discriminated by `pkg.resolution.tag`;
                                     // `Tag::Git` was checked when the resolution was set.
                                     repo.resolved = pkg.resolution.git().resolved;
                                     repo.package_name = pkg.name;
@@ -1563,8 +1540,7 @@ pub fn run_tasks<C: RunTasksCallbacks>(
                             }
                         }
 
-                        // Zig: `if (@TypeOf(callbacks.onExtract) != void) @compileError("ctx should be void");`
-                        // — compile-time invariant: this branch only reachable when !HAS_ON_EXTRACT.
+                        // Invariant: this branch only reachable when !HAS_ON_EXTRACT.
                         debug_assert!(!C::HAS_ON_EXTRACT, "ctx should be void");
                     }
                 }
@@ -1697,7 +1673,6 @@ pub fn schedule_tasks(manager: &mut PackageManager) -> usize {
         .network_resolve_batch
         .push(core::mem::take(&mut manager.network_tarball_batch));
     http::HTTPThread::schedule(core::mem::take(&mut manager.network_resolve_batch));
-    // Zig resets these to `.{}` after passing by-value; `mem::take` above already did that.
     count
 }
 
@@ -1706,7 +1681,7 @@ pub fn drain_dependency_list(this: &mut PackageManager) {
     flush_dependency_queue(this);
 
     // SAFETY: `VERBOSE_INSTALL` is only mutated during single-threaded options
-    // parsing; reads here are race-free in practice (Zig: plain `pub var`).
+    // parsing; reads here are race-free in practice.
     if PackageManager::verbose_install() {
         Output::flush();
     }
@@ -1791,8 +1766,8 @@ pub fn generate_network_task_for_tarball<'a>(
         return Ok(None);
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig writes the whole struct via `.* = .{}`.
-    // All `&mut this` uses (patch-task alloc, cache/temp dir, pool slot) happen
+    // reshaped for borrowck —
+    // all `&mut this` uses (patch-task alloc, cache/temp dir, pool slot) happen
     // first; the immutable `pkg_name`/`scope` borrows are taken afterwards and
     // live only through `for_tarball`, leaving `this` free for the streaming
     // tail.
@@ -1831,14 +1806,13 @@ pub fn generate_network_task_for_tarball<'a>(
     let temp_dir = directories::get_temporary_directory(this).handle.fd();
     // Backref address only — stored, not dereffed in this function. The tag is
     // immediately popped by the next `this` use; that's fine for a stored
-    // back-pointer (TODO(port): lifetime — BACKREF).
+    // back-pointer.
     let this_backref: *mut PackageManager = this;
 
     // Take the pool slot as a raw pointer so borrowck releases `this` for the
     // streaming-setup tail. Reborrowed `&mut` per-statement below.
     let net_ptr: *mut NetworkTask = get_network_task(this);
-    // Zig: `network_task.* = .{ .task_id, .callback = undefined, .allocator,
-    // .package_manager, .apply_patch_task }` — full struct overwrite that resets
+    // Full struct overwrite that resets
     // every other field (`retried`, `response`, `streaming_committed`,
     // `tarball_stream`, `streaming_extract_task`, `next`, `url_buf`,
     // `signal_store`) to its struct default. The slot may be uninitialized
@@ -1922,7 +1896,7 @@ pub fn generate_network_task_for_tarball<'a>(
 
 // ──────────────────────────────────────────────────────────────────────────
 // `impl PackageManager` — method-syntax shims over the free functions above so
-// callers (incl. this file) can write `manager.foo()` matching the Zig spec.
+// callers (incl. this file) can write `manager.foo()`.
 // ──────────────────────────────────────────────────────────────────────────
 impl PackageManager {
     #[inline]
@@ -1964,8 +1938,8 @@ impl PackageManager {
 }
 
 /// Adapter wrapping the existing `PackageManager::process_dependency_list` so
-/// it can be driven by a `RunTasksCallbacks` impl (Zig: passes `extract_ctx`
-/// + `callbacks` and dispatches `onResolve` if any root dep changed).
+/// it can be driven by a `RunTasksCallbacks` impl, dispatching `on_resolve`
+/// if any root dep changed.
 fn process_dependency_list_for_ctx<C: RunTasksCallbacks>(
     manager: &mut PackageManager,
     dependency_list: TaskCallbackList,
@@ -1988,5 +1962,3 @@ fn process_dependency_list_for_ctx<C: RunTasksCallbacks>(
         install_peer,
     )
 }
-
-// ported from: src/install/PackageManager/runTasks.zig
diff --git a/src/install/PackageManager/security_scanner.rs b/src/install/PackageManager/security_scanner.rs
index 37a4684a6e2..c88b8d0e66d 100644
--- a/src/install/PackageManager/security_scanner.rs
+++ b/src/install/PackageManager/security_scanner.rs
@@ -5,7 +5,7 @@ use std::io::Write as _;
 
 use bstr::BStr;
 
-// PORT NOTE: `BufferedReaderParent::loop_` is typed `*mut bun_uws::Loop` (the
+// `BufferedReaderParent::loop_` is typed `*mut bun_uws::Loop` (the
 // uws wrapper — `WindowsLoop` on Windows, `PosixLoop` on POSIX), not
 // `bun_io::Loop` is the trait's nominal: `us_loop_t` on POSIX, `uv_loop_t`
 // on Windows. The inherent `loop_()` projects `.uv_loop` from the uws wrapper
@@ -39,7 +39,7 @@ use crate::isolated_install as IsolatedInstall;
 use crate::package_manager_real::install_with_manager as InstallWithManager;
 use crate::package_manager_real::package_manager_options::Do;
 
-/// Zig `@tagName(sig)` for `bun.SignalCode` (non-exhaustive `enum(u8)`).
+/// Signal name for a raw signal byte.
 /// `Status::Signaled` carries the raw byte; named range 1..=31 maps via
 /// `SignalCode::name()`, RT/out-of-range values fall back to "UNKNOWN".
 #[inline]
@@ -72,13 +72,11 @@ pub struct SecurityScanResults {
     pub warn_count: usize,
     pub packages_scanned: usize,
     pub duration_ms: i64,
-    // TODO(port): Zig borrows this from manager.options.security_scanner; using Box<[u8]> to avoid
-    // a struct lifetime. Revisit if the copy matters.
+    // Owned copy of `manager.options.security_scanner`;
+    // owning avoids a struct lifetime and the copy is tiny.
     pub security_scanner: Box<[u8]>,
 }
 
-// Zig `deinit` only freed owned fields; Rust drops Box fields automatically — no explicit Drop.
-
 impl SecurityScanResults {
     pub fn has_fatal_advisories(&self) -> bool {
         self.fatal_count > 0
@@ -100,7 +98,6 @@ pub(crate) fn do_partial_install_of_security_scanner(
     security_scanner_pkg_id: PackageID,
     original_cwd: &[u8],
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let (workspace_filters, install_root_dependencies) =
         InstallWithManager::get_workspace_filters(manager, original_cwd)?;
     // `defer manager.allocator.free(workspace_filters)` — workspace_filters is now owned, drops at scope exit.
@@ -496,8 +493,6 @@ impl<'a> PackageCollector<'a> {
         }
     }
 
-    // Zig `deinit` only freed owned fields; Rust drops them automatically.
-
     pub(crate) fn collect_all_packages(&mut self) -> Result<(), Error> {
         let pkgs = self.manager.lockfile.packages.slice();
         let pkg_dependencies = pkgs.items_dependencies();
@@ -714,9 +709,9 @@ impl<'a> JSONBuilder<'a> {
         json_buf.extend_from_slice(b"[\n");
 
         let mut first = true;
-        // PORT NOTE: `ArrayHashMap::iterator()` takes `&mut self`, but we only
+        // `ArrayHashMap::iterator()` takes `&mut self`, but we only
         // need shared access. Iterate by index over the parallel key/value
-        // slices instead (insertion-ordered, matches Zig's `iterator()`).
+        // slices instead (insertion-ordered).
         let path_keys = self.collector.package_paths.keys();
         let path_values = self.collector.package_paths.values();
         for (i, pkg_id) in path_keys.iter().enumerate() {
@@ -849,7 +844,7 @@ fn attempt_security_scan_with_retry(
     let json_data = json_builder.build_package_json()?;
     // `defer manager.allocator.free(json_data)` — Box<[u8]> drops at scope exit.
 
-    // PORT NOTE: destructure `collector` here to release its `&PackageManager`
+    // destructure `collector` here to release its `&PackageManager`
     // borrow before constructing `SecurityScanSubprocess` (which needs `&mut`).
     // Only `package_paths` is read past this point.
     let PackageCollector { package_paths, .. } = collector;
@@ -878,7 +873,7 @@ fn attempt_security_scan_with_retry(
             b"false"
         });
         new_code.extend_from_slice(&temp_source[index + suppress_placeholder.len()..]);
-        // PORT NOTE: reshaped for borrowck — drop borrow of `code` (via `temp_source`) before reassigning.
+        // reshaped for borrowck — drop borrow of `code` (via `temp_source`) before reassigning.
         code = new_code;
     }
 
@@ -902,8 +897,7 @@ fn attempt_security_scan_with_retry(
 
     scanner.spawn()?;
 
-    // PORT NOTE: Zig used a local `struct { scanner, isDone }` closure for sleepUntil.
-    // `sleep_until` now takes `*mut PackageManager` + `fn(&mut C) -> bool`; pass the
+    // `sleep_until` takes `*mut PackageManager` + `fn(&mut C) -> bool`; pass the
     // boxed scanner as the closure context and a fn pointer that probes `is_done`.
     fn scanner_is_done(scanner: &mut Box<SecurityScanSubprocess>) -> bool {
         scanner.is_done()
@@ -935,7 +929,7 @@ pub struct SecurityScanSubprocess<'a> {
     event_loop_handle: EventLoopHandle,
     code: Box<[u8]>,
     json_data: Box<[u8]>,
-    /// Intrusive `*mut Process` (Zig `?*Process`). `Process` is
+    /// Intrusive `*mut Process`. `Process` is
     /// `ThreadSafeRefCounted` and Box-allocated by `to_process`; wrapping in
     /// `Arc` would be UB (no `ArcInner` header). We hold one ref and `deref()`
     /// it in `Drop`.
@@ -947,14 +941,13 @@ pub struct SecurityScanSubprocess<'a> {
     has_received_ipc: bool,
     exit_status: Option<Status>,
     remaining_fds: i8,
-    /// Intrusive `RefPtr` (Zig `?*StaticPipeWriter`). `StaticPipeWriter<P>` is
+    /// Intrusive `RefPtr`. `StaticPipeWriter<P>` is
     /// `RefCounted`; `Rc` would double-count against the embedded refcount.
     json_writer: Option<RefPtr<StaticPipeWriter>>,
 }
 
-// Zig: `pub const StaticPipeWriter = jsc.Subprocess.NewStaticPipeWriter(@This());`
-// The comptime type generator is the generic `subprocess::StaticPipeWriter<P>`;
-// monomorphize on `'static` because the writer stores `*mut P` (raw backref —
+// The generic `subprocess::StaticPipeWriter<P>` is
+// monomorphized on `'static` because the writer stores `*mut P` (raw backref —
 // lifetime is erased anyway) and the type alias must name a concrete `P`.
 pub(crate) type StaticPipeWriter = subprocess::StaticPipeWriter<SecurityScanSubprocess<'static>>;
 
@@ -993,10 +986,9 @@ impl<'a> Drop for SecurityScanSubprocess<'a> {
             }
         }
         if let Some(w) = self.json_writer.take() {
-            // Zig `deinit` only ran via `attemptSecurityScanWithRetry`'s
-            // `defer scanner.deinit()`, which set `json_writer = null` first via
-            // `onCloseIO`. Guard for parity: `RefPtr` has no auto-`Drop`, so
-            // explicit `deref()` matches Zig `deref()`.
+            // `on_close_io` normally takes the field first; guard for the case
+            // where it didn't run. `RefPtr` has no auto-`Drop`, so the ref we
+            // hold must be released with an explicit `deref()`.
             w.deref();
         }
         // code, json_data drop automatically (Box<[u8]>)
@@ -1039,9 +1031,9 @@ impl<'a> SecurityScanSubprocess<'a> {
 
         let exec_path = bun_core::self_exe_path()?;
 
-        // Zig: `try allocator.dupeZ(u8, exec_path)` / `dupeZ(u8, code)`. Build
+        // Build
         // owned NUL-terminated buffers so the pointers stay valid across the
-        // `spawn_process` FFI boundary; `defer free` ≡ Vec drop.
+        // `spawn_process` FFI boundary.
         let mut argv0_buf: Vec<u8> = exec_path.as_bytes().to_vec();
         argv0_buf.push(0);
         let mut argv3_buf: Vec<u8> = self.code.to_vec();
@@ -1076,7 +1068,7 @@ impl<'a> SecurityScanSubprocess<'a> {
 
     /// Posix fd 4: .buffer stdio creates a nonblocking socketpair inside the
     /// spawn machinery. The child's end is dup'd to fd 4 and closed in the
-    /// parent by spawn's to_close_at_end list (process.zig:1460). The parent's
+    /// parent by spawn's to_close_at_end list. The parent's
     /// end comes back via spawned.extra_pipes.
     #[cfg(unix)]
     fn spawn_posix(
@@ -1098,7 +1090,6 @@ impl<'a> SecurityScanSubprocess<'a> {
             ..Default::default()
         };
 
-        // Zig: `try (try spawnProcess(...)).unwrap()` — propagate both layers silently.
         // SAFETY: `argv` is a local null-terminated C-string array with a
         // non-null argv[0]; `environ_ptr()` is the process environ block.
         let mut spawned = unsafe {
@@ -1124,7 +1115,7 @@ impl<'a> SecurityScanSubprocess<'a> {
     }
 
     /// Windows fd 4: .buffer stdio for extra_fds sets UV_OVERLAPPED_PIPE on the
-    /// child's handle (process.zig:1702), which breaks sync reads in the child.
+    /// child's handle, which breaks sync reads in the child.
     /// Instead, create the pipe ourselves with asymmetric flags so only the
     /// parent's write end is overlapped. Child inherits the non-overlapped read
     /// end via .pipe (inherit_fd); parent wraps the overlapped write end in a
@@ -1144,8 +1135,7 @@ impl<'a> SecurityScanSubprocess<'a> {
         // Use the translating overlay (`ReturnCodeExt::err_enum_e`) — the inherent
         // `ReturnCode::err_enum()` returns the raw |uv_code| (e.g. 4071 for
         // UV_EINVAL on Windows) without mapping to POSIX `bun.sys.E`, which would
-        // make `errno_to_zig_err` index the wrong table. Zig's `rc.errEnum()`
-        // (libuv.zig) routes through `translateUVErrorToE`; this matches it.
+        // make `errno_to_zig_err` index the wrong table.
         if let Some(e) = pipe_rc.err_enum_e() {
             ipc_output_fds[0].close();
             ipc_output_fds[1].close();
@@ -1176,7 +1166,7 @@ impl<'a> SecurityScanSubprocess<'a> {
         // errdefer pipe.closeAndDestroy() — guard owns the raw Box ptr; libuv's
         // close callback frees the heap allocation, so do NOT re-box on the
         // cleanup path (would double-free). Disarmed only after finish_spawn
-        // succeeds, matching the Zig errdefer scope exactly: it must stay armed
+        // succeeds: it must stay armed
         // across `ipc_reader.start()` inside finish_spawn (the pre-writer error
         // window) so a registered-but-unowned uv handle is never leaked.
         let mut pipe = scopeguard::guard(pipe_ptr, |p| {
@@ -1215,7 +1205,6 @@ impl<'a> SecurityScanSubprocess<'a> {
             ..Default::default()
         };
 
-        // Zig: `try (try spawnProcess(...)).unwrap()` — propagate both layers silently.
         // SAFETY: `argv` is a local null-terminated C-string array with a
         // non-null argv[0]; `environ_ptr()` is the process environ block.
         let mut spawned = unsafe {
@@ -1240,12 +1229,11 @@ impl<'a> SecurityScanSubprocess<'a> {
         // raw `*mut uv::Pipe` (Copy, no Drop) and reconstitutes the Box at the
         // exact `StaticPipeWriter::create` call site inside `finish_spawn`. If
         // `finish_spawn` errors before that point (`ipc_reader.start()`), the
-        // closure drops as a no-op and the still-armed errdefer guard performs
-        // `close_and_destroy` — matching Zig, where `errdefer pipe.closeAndDestroy()`
-        // covers the entire `try finishSpawn(...)` call. After the writer takes
+        // closure drops as a no-op and the still-armed cleanup guard performs
+        // `close_and_destroy`. After the writer takes
         // the pipe, post-create errors leave the writer leaked at refcount >= 1
         // (RefPtr has no Drop), so the Box is never auto-freed and the guard's
-        // `close_and_destroy` remains the sole cleanup, again matching Zig.
+        // `close_and_destroy` remains the sole cleanup.
         self.finish_spawn(&mut spawned, ipc_output_fds[0], move || {
             // SAFETY: `pipe_ptr` is the same allocation produced by
             // heap::alloc above and has not been freed; ownership transfers
@@ -1265,12 +1253,9 @@ impl<'a> SecurityScanSubprocess<'a> {
     /// start the fd 4 JSON writer, and begin watching for exit.
     fn finish_spawn(
         &mut self,
-        // PORT NOTE: Zig `spawned: anytype` — concrete type is the platform-dependent
-        // SpawnResult; Rust uses the unified `spawn::SpawnResult`.
         spawned: &mut spawn::SpawnResult,
         ipc_read_fd: Fd,
-        // Deferred constructor: Zig passes `json_stdio_result` by value (a tagged
-        // union holding a raw `*uv.Pipe` on Windows — inert on drop). Rust's
+        // Deferred constructor: a by-value
         // `WindowsStdioResult::Buffer(Box<uv::Pipe>)` would auto-free the
         // allocation without `uv_close()` if `ipc_reader.start()` below failed,
         // leaking a registered libuv handle. Taking a thunk and calling it only
@@ -1290,12 +1275,11 @@ impl<'a> SecurityScanSubprocess<'a> {
         // isDone() returns true, otherwise we risk freeing this struct while
         // StaticPipeWriter still holds a pointer to it (child crash case).
         self.remaining_fds = 2;
-        // Zig: `try this.ipc_reader.start(ipc_read_fd, true).unwrap()` — propagate silently.
         self.ipc_reader
             .start(ipc_read_fd, true)
             .map_err(|e| e.to_zig_err())?;
 
-        // PORT NOTE: `to_process` consumes `SpawnResult` by value on POSIX (and
+        // `to_process` consumes `SpawnResult` by value on POSIX (and
         // `&mut self` on Windows); take ownership of the result and let the
         // moved-from `*spawned` drop empty (`extra_pipes` already read).
         let event_loop = EventLoopHandle::from_any(&mut self.manager.event_loop);
@@ -1315,8 +1299,7 @@ impl<'a> SecurityScanSubprocess<'a> {
             (*parent).process = Some(process);
         }
 
-        // Zig: `this.json_writer = StaticPipeWriter.create(...)` — assign the
-        // field BEFORE `start()`. `start()` may complete the write synchronously
+        // Assign the field BEFORE `start()`. `start()` may complete the write synchronously
         // (small JSON fits the 64KB pipe buffer on POSIX) and re-enter
         // `on_close_io` via the `parent` backref; that callback must observe
         // `json_writer.is_some()` to decrement `remaining_fds`, otherwise
@@ -1329,9 +1312,8 @@ impl<'a> SecurityScanSubprocess<'a> {
         // SAFETY: see `parent` note above.
         unsafe { (*parent).json_writer = Some(writer) };
 
-        // errdefer if (this.json_writer) |w| { w.source.detach(); w.deref(); this.json_writer = null; }
-        // PORT NOTE: guard mirrors the Zig errdefer over the FIELD (not a local),
-        // including its `if (this.json_writer)` check — `start()` may already
+        // Error-cleanup guard over the FIELD (not a local),
+        // including a presence check on it — `start()` may already
         // have re-entered and nulled it. State is the `parent` backref; disarmed
         // via `into_inner` on the success path.
         let guard = scopeguard::guard(parent, |parent| {
@@ -1415,8 +1397,7 @@ impl<'a> SecurityScanSubprocess<'a> {
     }
 
     pub fn get_read_buffer(&mut self) -> &mut [core::mem::MaybeUninit<u8>] {
-        // PORT NOTE: Zig returns `unusedCapacitySlice()` (uninitialized spare
-        // capacity as `[]u8`); Rust forbids `&mut [u8]` over uninit bytes, so
+        // Rust forbids `&mut [u8]` over uninit bytes, so
         // expose `&mut [MaybeUninit<u8>]`. Caller (BufferedReader) only writes
         // into this region, never reads uninit bytes.
         // Vec::reserve already amortises by doubling; the explicit cap+4096 dance is unnecessary.
@@ -1433,8 +1414,8 @@ impl<'a> SecurityScanSubprocess<'a> {
         self.exit_status = Some(status);
 
         if !self.has_received_ipc {
-            // PORT NOTE (intentional divergence from Zig spec): the spec tears
-            // down `ipc_reader` here unconditionally. That races process-exit
+            // Do not tear
+            // down `ipc_reader` here unconditionally: that races process-exit
             // against fd-3-readable: `ipc_reader.start()` only registers a
             // poll on POSIX (no sync read), and `MiniEventLoop::tick_once`
             // skips the uws tick whenever a concurrent task (the WaiterThread
@@ -1480,7 +1461,7 @@ impl<'a> SecurityScanSubprocess<'a> {
                             }
                             Err(e) => match e.get_errno() {
                                 // macOS `bun_sys::read` is single-shot
-                                // (`read$NOCANCEL`, sys.zig:2138); WaiterThread
+                                // (`read$NOCANCEL`); WaiterThread
                                 // + PTY matrix arms can land signals mid-drain.
                                 bun_sys::E::EINTR => continue,
                                 bun_sys::E::EAGAIN => {
@@ -1969,5 +1950,3 @@ fn parse_security_advisories_from_expr(
 
     Ok(advisories_list.into_boxed_slice())
 }
-
-// ported from: src/install/PackageManager/security_scanner.zig
diff --git a/src/install/PackageManager/updatePackageJSONAndInstall.rs b/src/install/PackageManager/updatePackageJSONAndInstall.rs
index 4ba026d30e3..bf38804aeb7 100644
--- a/src/install/PackageManager/updatePackageJSONAndInstall.rs
+++ b/src/install/PackageManager/updatePackageJSONAndInstall.rs
@@ -14,15 +14,13 @@ use bun_js_printer as js_printer;
 use bun_paths::{self, PathBuffer};
 use bun_sys::{self, Fd, File};
 
+use super::command_line_arguments::CommandLineArguments;
+use super::package_json_editor as PackageJSONEditor;
+use super::update_request::Array as UpdateRequestArray;
 use super::{
     Command, PackageManager, PatchCommitResult, Subcommand, UpdateRequest,
     attempt_to_create_package_json, install_with_manager, patch_package,
 };
-// Zig's `PackageJSONEditor` is a file-namespace struct; the Rust port exposes
-// its functions directly on the `package_json_editor` module.
-use super::command_line_arguments::CommandLineArguments;
-use super::package_json_editor as PackageJSONEditor;
-use super::update_request::Array as UpdateRequestArray;
 
 pub fn update_package_json_and_install_with_manager(
     manager: &mut PackageManager,
@@ -53,7 +51,7 @@ pub fn update_package_json_and_install_with_manager(
         }
     }
 
-    // PORT NOTE: `manager.options.positionals` is `&'static [&'static [u8]]` so the
+    // `manager.options.positionals` is `&'static [&'static [u8]]` so the
     // sub-slice does not borrow `*manager` and can flow alongside `&mut manager`.
     let positionals: &'static [&'static [u8]] = &manager.options.positionals[1..];
     update_package_json_and_install_with_manager_with_updates_and_update_requests(
@@ -72,12 +70,11 @@ fn update_package_json_and_install_with_manager_with_updates_and_update_requests
     positionals: &[&[u8]],
     update_requests: &mut UpdateRequestArray,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let subcommand = manager.subcommand;
     if subcommand != Subcommand::PatchCommit && subcommand != Subcommand::Patch {
-        // PORT NOTE: reshaped for borrowck — `parse` returns a `&mut [UpdateRequest]`
+        // reshaped for borrowck — `parse` returns a `&mut [UpdateRequest]`
         // sub-slice of `update_requests`; we take its length and truncate the Vec so
-        // the next call can take the Vec by value (Zig threaded `*[]UpdateRequest`).
+        // the next call can take the Vec by value.
         let len = UpdateRequest::parse(
             // `dependency::parse_with_tag` is the only consumer of `pm`; it inserts
             // into `pm.known_npm_aliases` for `npm:`-aliased positionals.
@@ -106,9 +103,9 @@ fn update_package_json_and_install_with_manager_with_updates_and_update_requests
 fn update_package_json_and_install_with_manager_with_updates(
     manager: &mut PackageManager,
     ctx: Command::Context,
-    // PORT NOTE: reshaped for borrowck — Zig was `*[]UpdateRequest`. Taking by
-    // value lets us hand ownership to `manager.update_requests` (which the Rust
-    // port types as `Box<[UpdateRequest]>`) and re-borrow afterwards without
+    // reshaped for borrowck — taking by
+    // value lets us hand ownership to `manager.update_requests` (typed
+    // `Box<[UpdateRequest]>`) and re-borrow afterwards without
     // aliasing `&mut manager`.
     mut updates: Vec<UpdateRequest>,
     subcommand: Subcommand,
@@ -124,12 +121,11 @@ fn update_package_json_and_install_with_manager_with_updates(
         Global::crash();
     }
 
-    // PORT NOTE: reshaped for borrowck — `get_with_path` returns `&mut MapEntry`
+    // reshaped for borrowck — `get_with_path` returns `&mut MapEntry`
     // borrowed from `manager.workspace_package_json_cache`, but we then need
     // `&mut *manager` for `PackageJSONEditor::edit` / `do_patch_commit` while still
-    // holding the entry. Zig held `*MapEntry` and `*PackageManager` simultaneously
-    // (no aliasing rules); mirror that by demoting to `*mut MapEntry` and re-
-    // borrowing at point of use. The cache map is not mutated again until the
+    // holding the entry. Demote to `*mut MapEntry` and re-
+    // borrow at point of use. The cache map is not mutated again until the
     // next `get_with_path` call below, so the pointer remains valid.
     let current_package_json_ptr: *mut MapEntry =
         match manager.workspace_package_json_cache.get_with_path(
@@ -165,7 +161,7 @@ fn update_package_json_and_install_with_manager_with_updates(
             }
             GetResult::Entry(entry) => core::ptr::from_mut(entry),
         };
-    // SAFETY: see PORT NOTE above — pointer into `manager.workspace_package_json_cache`,
+    // SAFETY: see note above — pointer into `manager.workspace_package_json_cache`,
     // valid until the next `get_with_path`. No `&mut manager.workspace_package_json_cache`
     // is taken across this borrow; `PackageJSONEditor` and `do_patch_commit` touch only
     // disjoint manager fields.
@@ -236,7 +232,6 @@ fn update_package_json_and_install_with_manager_with_updates(
             // if we're removing, they don't have to specify where it is installed in the dependencies list
             // they can even put it multiple times and we will just remove all of them
             for request in updates.iter() {
-                // PERF(port): was `inline for` — profile if hot
                 const LISTS: [&[u8]; 4] = [
                     b"dependencies",
                     b"devDependencies",
@@ -246,20 +241,20 @@ fn update_package_json_and_install_with_manager_with_updates(
                 for list in LISTS {
                     if let Some(query) = current_package_json_root.as_property(list) {
                         if query.expr.data.is_e_object() {
-                            // PORT NOTE: reshaped for borrowck — Zig held `data.e_object` (a
-                            // `*E.Object`) across writes to both the inner list and the parent
-                            // object. `StoreRef<E::Object>` is `Copy` and derefs to a raw arena
-                            // pointer, so taking it once mirrors that exactly.
+                            // reshaped for borrowck —
+                            // `StoreRef<E::Object>` is `Copy` and derefs to a raw arena
+                            // pointer, so taking it once works across writes to both the
+                            // inner list and the parent object.
                             let mut e_object = query.expr.data.as_e_object();
                             let dependencies = e_object.properties.slice_mut();
                             let mut i: usize = 0;
                             let mut new_len = dependencies.len();
-                            // PORT NOTE: Zig copies `dependencies[i] = dependencies[new_len - 1]`
-                            // and iterates to the original length. `G::Property` is not `Copy` in
-                            // Rust, so we `swap` instead — but the swapped-out matched element
+                            // `G::Property` is not `Copy`,
+                            // so we `swap` instead of copy-from-tail — but the swapped-out
+                            // matched element
                             // lands in the truncated tail and MUST NOT be revisited (it would
                             // match again and over-truncate). Bounding by `new_len` yields the
-                            // same result as Zig for the unique-key case package.json guarantees.
+                            // correct result for the unique-key case package.json guarantees.
                             while i < new_len {
                                 let key = dependencies[i].key.unwrap();
                                 if key.data.is_e_string() {
@@ -323,7 +318,7 @@ fn update_package_json_and_install_with_manager_with_updates(
                         ..Default::default()
                     },
                 )?;
-                // `edit` may shrink the slice (Zig `updates.* = updates.*[0..n]`).
+                // `edit` may shrink the slice.
                 let new_len = updates_slice.len();
                 updates.truncate(new_len);
             } else if subcommand == Subcommand::Update {
@@ -363,8 +358,7 @@ fn update_package_json_and_install_with_manager_with_updates(
 
     manager.to_update = subcommand == Subcommand::Update;
 
-    // PORT NOTE: reshaped for borrowck — Zig stored a slice header (`manager.update_requests
-    // = updates.*`) so both names alias the same backing array; the Rust field is owning
+    // reshaped for borrowck — the field is owning
     // (`Box<[UpdateRequest]>`), so we transfer ownership here and re-borrow from
     // `manager.update_requests` after `install_with_manager` (which is the only writer).
     manager.update_requests = updates.into_boxed_slice();
@@ -408,14 +402,12 @@ fn update_package_json_and_install_with_manager_with_updates(
         .ctx
         .written_without_trailing_zero()
         .to_vec();
-    // Zig: `manager.allocator.dupe(u8, …)` — heap-owned, never freed (process-lifetime).
     // The cache entry (`Cow<'static, [u8]>`) outlives this stack frame, and
     // `new_package_json_source` is reassigned below on the add/update/link path, so we
-    // must store an *owning* copy to avoid a dangling borrow. PERF(port): one extra
-    // alloc+copy vs Zig's single dupe — profile if hot.
+    // must store an *owning* copy to avoid a dangling borrow.
     current_package_json.source.contents = Cow::Owned(new_package_json_source.clone());
-    // PORT NOTE: Zig edited `current_package_json.root` in place above; the Rust
-    // port edited a promoted copy (`current_package_json_root`), so re-parse the
+    // The edits above went into a promoted copy
+    // (`current_package_json_root`), so re-parse the
     // printed source so the cached AST (consumed by `FolderResolver` for workspace
     // members during `install_with_manager`) reflects the new dependency list.
     if let Err(err) = current_package_json.reparse_root(manager.log_mut()) {
@@ -441,7 +433,7 @@ fn update_package_json_and_install_with_manager_with_updates(
 
         // The lifetime of this pointer is only valid until the next call to `getWithPath`, which can happen after this scope.
         // https://github.com/oven-sh/bun/issues/12288
-        // PORT NOTE: reshaped for borrowck — see `current_package_json_ptr` above.
+        // reshaped for borrowck — see `current_package_json_ptr` above.
         let root_package_json_ptr: *mut MapEntry =
             match manager.workspace_package_json_cache.get_with_path(
                 manager.log_mut(),
@@ -530,9 +522,9 @@ fn update_package_json_and_install_with_manager_with_updates(
 
     install_with_manager::install_with_manager(manager, ctx, root_package_json_path, original_cwd)?;
 
-    // PORT NOTE: reshaped for borrowck — see assignment above. `install_with_manager`
+    // reshaped for borrowck — see assignment above. `install_with_manager`
     // is the only writer to `manager.update_requests` between the assignment and
-    // here, so taking it back yields exactly the slice Zig observed via `updates.*`.
+    // here, so taking it back yields exactly the slice assigned above.
     let mut updates: Box<[UpdateRequest]> = core::mem::take(&mut manager.update_requests);
 
     if subcommand == Subcommand::Update
@@ -666,7 +658,7 @@ fn update_package_json_and_install_with_manager_with_updates(
             .pwrite_all(source, 0)
             .map_err(Error::from)?;
         let _ = bun_sys::ftruncate(workspace_package_json_file.handle, source.len() as i64);
-        let _ = workspace_package_json_file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = workspace_package_json_file.close(); // close error is non-actionable
 
         if subcommand == Subcommand::Remove {
             if !any_changes {
@@ -755,7 +747,6 @@ pub fn update_package_json_and_install_and_cli(
     subcommand: Subcommand,
     cli: CommandLineArguments,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let (manager_ptr, original_cwd) = 'brk: {
         match super::init(ctx, cli.clone(), subcommand) {
             Ok(v) => v,
@@ -789,12 +780,11 @@ pub fn update_package_json_and_install_and_cli(
     let _original_cwd_owner: Box<[u8]> = original_cwd;
     let original_cwd: &[u8] = &_original_cwd_owner;
     // SAFETY: `super::init` returns a `*mut PackageManager` to the process-static
-    // singleton (Zig `*PackageManager`). We are on the single CLI thread; no worker
+    // singleton. We are on the single CLI thread; no worker
     // threads deref `get()` until `install_with_manager` spawns the HTTP thread.
     let manager: &mut PackageManager = &mut *manager_ptr;
 
     if manager.options.should_print_command_name() {
-        // Zig: `"..." ++ Global.package_json_version_with_sha ++ "..."` (comptime concat).
         // `concatcp!` yields `&'static str`, but `format_args!` requires a string *literal*
         // for its template. Splice the version as a runtime arg instead — this matches the
         // approach taken by every other CLI subcommand banner (see e.g. `outdated_command.rs`,
@@ -987,5 +977,3 @@ use super::TrackInstalledBin;
 use super::options::{Do, LogLevel, PatchFeatures};
 use super::package_json_editor::EditOptions;
 use super::workspace_package_json_cache::{GetJSONOptions, GetResult, MapEntry};
-
-// ported from: src/install/PackageManager/updatePackageJSONAndInstall.zig
diff --git a/src/install/PackageManagerTask.rs b/src/install/PackageManagerTask.rs
index 150d0b8b29e..6d8d4a751ae 100644
--- a/src/install/PackageManagerTask.rs
+++ b/src/install/PackageManagerTask.rs
@@ -19,10 +19,8 @@ use crate::{
 
 use bun_dotenv as dot_env;
 
-/// File-level struct in Zig (`@This()` == `Task`).
-///
 /// `'a` is forced by LIFETIMES.tsv (BORROW_PARAM on `Request::*.network`).
-/// // TODO(port): lifetime — Task lives in an intrusive cross-thread queue
+/// TODO: lifetime — Task lives in an intrusive cross-thread queue
 /// (`next`, `package_manager` BACKREF). A `&'a mut NetworkTask` cannot soundly
 /// cross that boundary; Phase B should likely demote to `*mut NetworkTask`.
 pub struct Task<'a> {
@@ -47,15 +45,13 @@ pub struct Task<'a> {
     pub next: bun_threading::Link<Task<'a>>,
 }
 
-/// Zig: struct field defaults (`status = .waiting`, `threadpool_task = .{ .callback = &callback }`,
-/// `err = null`, `apply_patch_task = null`, `next = null`) with the remaining fields left
-/// `= undefined`. Callers MUST overwrite `tag`, `request`, `id`, `package_manager` before
+/// Callers MUST overwrite `tag`, `request`, `id`, `package_manager` before
 /// the task is observed. Exposed as a module-level fn so call sites that import this
 /// module as `Task` can write `..Task::uninit()` in struct-update position.
 #[inline]
 pub(crate) fn uninit() -> Task<'static> {
     Task {
-        // Overwritten by every caller; zero/garbage matches Zig `undefined`.
+        // Overwritten by every caller; placeholder value.
         tag: Tag::PackageManifest,
         // SAFETY: untagged unions of `ManuallyDrop<_>` — any bit pattern is
         // valid storage and is never read before the caller overwrites it.
@@ -63,7 +59,6 @@ pub(crate) fn uninit() -> Task<'static> {
         // SAFETY: untagged unions of `ManuallyDrop<_>` — any bit pattern is
         // valid storage and is never read before the caller overwrites it.
         data: unsafe { bun_core::ffi::zeroed_unchecked() },
-        // Every Zig caller passes `logger.Log.init(allocator)` for this field.
         // `Log` contains `Vec<Msg>` (NonNull invariant) so it cannot be
         // `mem::zeroed()`; and struct-update `..Task::uninit()` *drops* the
         // base value's `log` when the caller supplies their own, so this must
@@ -71,7 +66,6 @@ pub(crate) fn uninit() -> Task<'static> {
         log: Log::default(),
         id: Id(0),
         package_manager: None,
-        // Real Zig field defaults:
         status: Status::Waiting,
         threadpool_task: thread_pool::Task {
             node: Default::default(),
@@ -84,7 +78,7 @@ pub(crate) fn uninit() -> Task<'static> {
 }
 
 // SAFETY: `next` is the sole intrusive link for `UnboundedQueue<Task>`;
-// `link()` always projects to it. Mirrors Zig's `@field(item, "next")`.
+// `link()` always projects to it.
 unsafe impl<'a> bun_threading::Linked for Task<'a> {
     #[inline]
     unsafe fn link(item: *mut Self) -> *const bun_threading::Link<Self> {
@@ -100,7 +94,7 @@ pub struct Id(u64);
 
 impl core::fmt::Display for Id {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // Zig: `enum(u64)` — printed as its raw integer in `{}` debug logs.
+        // Printed as its raw integer in `{}` debug logs.
         self.0.fmt(f)
     }
 }
@@ -116,7 +110,7 @@ impl Id {
         hasher.update(b"npm-package:");
         hasher.update(package_name);
         hasher.update(b"@");
-        // SAFETY: reading raw bytes of a POD value for hashing (matches Zig `std.mem.asBytes`)
+        // SAFETY: reading raw bytes of a POD value for hashing
         hasher.update(unsafe {
             bun_core::ffi::slice(
                 (&raw const package_version).cast::<u8>(),
@@ -129,8 +123,8 @@ impl Id {
     pub fn for_bin_link(package_id: PackageID) -> Id {
         let mut hasher = Wyhash11::init(0);
         hasher.update(b"bin-link:");
-        // `PackageID` is `u32`: `bytemuck::bytes_of` gives the same
-        // native-endian byte view as Zig `std.mem.asBytes`.
+        // `PackageID` is `u32`: `bytemuck::bytes_of` gives the
+        // native-endian byte view.
         hasher.update(bytemuck::bytes_of(&package_id));
         Id(hasher.final_())
     }
@@ -256,12 +250,12 @@ impl<'a> Task<'a> {
         // through raw-ptr/shared accessors below; the few callees whose
         // signatures still take `&mut PackageManager` (`get_cache_directory`,
         // `get_package_metadata`) are dereferenced inline at the call boundary
-        // only — same race as the Zig spec's freely-aliased `*PackageManager`.
+        // only.
         let manager_ref = this.package_manager.expect("Task.package_manager unset");
         let manager: *mut PackageManager = manager_ref.as_mut_ptr();
 
-        // Body of the switch; every Zig `return;` becomes `break 'body;` so the
-        // trailing `defer` block (patch + push + wake) and `Output.flush()` run
+        // Body of the switch; arms exit via `break 'body;` so the
+        // trailing block (patch + push + wake) and `Output::flush()` run
         // unconditionally afterwards.
         'body: {
             match this.tag {
@@ -269,11 +263,11 @@ impl<'a> Task<'a> {
                     // SAFETY: tag == PackageManifest discriminates the union
                     let manifest = unsafe { &mut *this.request.package_manifest };
 
-                    // PORT NOTE: split-borrow `manifest.network` so the mutable
+                    // split-borrow `manifest.network` so the mutable
                     // `response_buffer` borrow doesn't overlap the immutable
                     // `response`/`callback` reads below.
                     let network = &mut *manifest.network;
-                    // Zig: `defer body.deinit()` — take ownership so the
+                    // Take ownership so the
                     // multi-MB manifest buffer drops on every exit of this arm
                     // instead of staying live on the NetworkTask until recycle.
                     let mut body = core::mem::take(&mut network.response_buffer);
@@ -301,8 +295,6 @@ impl<'a> Task<'a> {
                         break 'body;
                     };
 
-                    // PORT NOTE: Zig accessed the bare-union field
-                    // `network.callback.package_manifest.*` directly; in Rust
                     // `Callback` is a tagged enum, so destructure the variant.
                     // SAFETY: tag == PackageManifest ⇒ the network task was
                     // built by `NetworkTask::for_manifest` with this variant.
@@ -337,13 +329,12 @@ impl<'a> Task<'a> {
                         loaded_manifest,
                         // SAFETY: see `manager` decl — short-lived `&mut` at call
                         // boundary only (callee touches `cache_directory_` /
-                        // `temporary_directory` lazily; same race as Zig spec).
+                        // `temporary_directory` lazily).
                         unsafe { &mut *manager },
                         is_extended_manifest,
                     ) {
                         Ok(v) => v,
                         Err(err) => {
-                            // bun.handleErrorReturnTrace — debug-only Zig diagnostics; no-op in Rust.
                             this.err = Some(err);
                             this.status = Status::Fail;
                             this.data = Data {
@@ -393,14 +384,13 @@ impl<'a> Task<'a> {
 
                     // SAFETY: tag == Extract discriminates the union
                     let extract = unsafe { &mut *this.request.extract };
-                    // Zig: `defer buffer.deinit()` — take ownership so the
+                    // Take ownership so the
                     // tarball body drops on every exit of this arm.
                     let mut buffer = core::mem::take(&mut extract.network.response_buffer);
 
                     let result = match extract.tarball.run(&mut this.log, buffer.slice()) {
                         Ok(v) => v,
                         Err(err) => {
-                            // bun.handleErrorReturnTrace — debug-only Zig diagnostics; no-op in Rust.
                             this.err = Some(err);
                             this.status = Status::Fail;
                             this.data = Data {
@@ -545,7 +535,6 @@ impl<'a> Task<'a> {
                     ) {
                         Ok(v) => v,
                         Err(err) => {
-                            // bun.handleErrorReturnTrace — debug-only Zig diagnostics; no-op in Rust.
                             this.err = Some(err);
                             this.status = Status::Fail;
                             this.data = Data {
@@ -563,12 +552,11 @@ impl<'a> Task<'a> {
             }
         }
 
-        // Zig `defer` block (lines 77-91) — runs after switch on all paths.
+        // Runs after the switch on all paths.
         if this.status == Status::Success {
             if let Some(mut pt) = this.apply_patch_task.take() {
                 // `defer pt.deinit()` → Box<PatchTask> drops at end of this block
                 pt.apply().expect("OOM"); // bun.handleOom → panic on OOM
-                // PORT NOTE: Zig accessed bare-union field `pt.callback.apply`;
                 // `apply_patch_task` is only ever populated with the Apply
                 // variant (see `new_apply_patch_hash`), so destructure it.
                 let crate::patch_install::Callback::Apply(apply) = &mut pt.callback else {
@@ -578,7 +566,6 @@ impl<'a> Task<'a> {
                 };
                 if apply.logger.errors > 0 {
                     // `defer pt.callback.apply.logger.deinit()` → `Log` drops with `pt`.
-                    // this.log.addErrorFmt(null, logger.Loc.Empty, bun.default_allocator, "failed to apply patch: {}", .{e}) catch unreachable;
                     let _ = apply
                         .logger
                         .print(std::ptr::from_mut(Output::error_writer()));
@@ -588,7 +575,7 @@ impl<'a> Task<'a> {
         let task = core::ptr::NonNull::from(this).cast::<Task<'static>>();
         // SAFETY: `Task<'a>` is layout-identical for all `'a` (the lifetime is
         // a phantom on `&mut NetworkTask` borrows that the queue never reads
-        // through); erasing to `'static` matches Zig's lifetime-less queue.
+        // through); erasing to `'static` is sound for the queue.
         // `UnboundedQueue::push` takes `&self` (lock-free), so reach it via a
         // shared raw deref — no `&mut PackageManager` is formed.
         unsafe {
@@ -596,7 +583,6 @@ impl<'a> Task<'a> {
             PackageManager::wake_raw(manager);
         }
 
-        // Zig `defer Output.flush()` — outermost defer, runs last.
         Output::flush();
     }
 }
@@ -607,15 +593,13 @@ fn read_and_extract(
     normalize: bool,
     log: &mut Log,
 ) -> Result<ExtractData, bun_core::Error> {
-    // TODO(port): narrow error set
     let bytes = if normalize {
-        // Zig `File.readFromUserInput(std.fs.cwd(), tarball_path, allocator)` resolves
+        // Resolves
         // a user-provided relative path against `bun.fs.FileSystem.instance.top_level_dir`
         // (the absolute project root cached at startup — NOT the live process cwd).
-        // The Rust `bun_sys::File::read_from_user_input` was reshaped to take that base
+        // `bun_sys::File::read_from_user_input` takes that base
         // explicitly (T1 `bun_sys` cannot depend on T5 `bun_resolver::fs`), so thread it
         // through here from the install crate's `FileSystem` shim.
-        // Zig `try X.unwrap()` on Maybe(T) → plain `?` on bun_sys::Result<T>.
         File::read_from_user_input(
             Fd::cwd(),
             crate::bun_fs::FileSystem::instance().top_level_dir(),
@@ -628,7 +612,6 @@ fn read_and_extract(
     tarball.run(log, &bytes)
 }
 
-// Zig: `enum(u3)` — Rust has no u3, use u8.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Tag {
@@ -646,9 +629,7 @@ pub enum Status {
     Fail,
 }
 
-/// Bare Zig `union` (untagged). Discriminated externally by `Task.tag`.
-/// // TODO(port): Phase B — consider folding `Tag` + `Request` + `Data` into a
-/// single Rust `enum` (one discriminant instead of tag + 2 untagged unions).
+/// Untagged union. Discriminated externally by `Task.tag`.
 pub union Data {
     pub package_manifest: ManuallyDrop<npm::PackageManifest>,
     pub extract: ManuallyDrop<ExtractData>,
@@ -656,7 +637,7 @@ pub union Data {
     pub git_checkout: ManuallyDrop<ExtractData>,
 }
 
-/// Bare Zig `union` (untagged). Discriminated externally by `Task.tag`.
+/// Untagged union. Discriminated externally by `Task.tag`.
 pub union Request<'a> {
     /// package name
     // todo: Registry URL
@@ -670,13 +651,13 @@ pub union Request<'a> {
 pub struct PackageManifestRequest<'a> {
     pub name: StringOrTinyString,
     // BORROW_PARAM per LIFETIMES.tsv
-    // TODO(port): lifetime — see note on `Task<'a>`; likely `*mut NetworkTask` in Phase B.
+    // TODO: lifetime — see note on `Task<'a>`; likely should demote to `*mut NetworkTask`.
     pub network: &'a mut NetworkTask,
 }
 
 pub struct ExtractRequest<'a> {
     // BORROW_PARAM per LIFETIMES.tsv
-    // TODO(port): lifetime — see note on `Task<'a>`; likely `*mut NetworkTask` in Phase B.
+    // TODO: lifetime — see note on `Task<'a>`; likely should demote to `*mut NetworkTask`.
     pub network: &'a mut NetworkTask,
     pub tarball: ExtractTarball,
 }
@@ -684,9 +665,8 @@ pub struct ExtractRequest<'a> {
 pub struct GitCloneRequest {
     pub name: StringOrTinyString,
     pub url: StringOrTinyString,
-    // PORT NOTE: Zig stores `DotEnv.Map` by value (handle copy of the global
-    // `Repository.shared_env`). Rust's `Map` owns its storage; store a
-    // `&'static` into the global instead — see `SharedEnv::get`.
+    // `Map` owns its storage; store a
+    // `&'static` into the global `Repository.shared_env` instead — see `SharedEnv::get`.
     pub env: &'static dot_env::Map,
     pub dep_id: DependencyID,
     pub res: Resolution,
@@ -699,7 +679,7 @@ pub struct GitCheckoutRequest {
     pub url: StringOrTinyString,
     pub resolved: StringOrTinyString,
     pub resolution: Resolution,
-    // See PORT NOTE on `GitCloneRequest.env`.
+    // See the note on `GitCloneRequest.env`.
     pub env: &'static dot_env::Map,
 }
 
@@ -716,5 +696,3 @@ pub struct LocalTarballRequest {
     /// cwd. When false, it is already an absolute path.
     pub normalize: bool,
 }
-
-// ported from: src/install/PackageManagerTask.zig
diff --git a/src/install/PackageManifestMap.rs b/src/install/PackageManifestMap.rs
index f30e0499385..550058630db 100644
--- a/src/install/PackageManifestMap.rs
+++ b/src/install/PackageManifestMap.rs
@@ -20,11 +20,9 @@ pub enum Value {
 }
 
 impl Value {
-    // Zig: `entry.value_ptr.manifest` field projection on the `.manifest` arm.
     bun_core::enum_unwrap!(pub Value, Manifest => fn manifest / manifest_mut -> npm::PackageManifest);
 }
 
-// Zig: `std.HashMap(PackageNameHash, Value, IdentityContext(PackageNameHash), 80)`.
 type ManifestHashMap =
     HashMap<PackageNameHash, Value, bun_collections::IdentityContext<PackageNameHash>>;
 
@@ -37,7 +35,7 @@ pub enum CacheBehavior {
 /// By-value snapshot of the `PackageManager` fields the disk-fallback path of
 /// [`PackageManifestMap::by_name_hash_allow_expired`] reads.
 ///
-/// Zig threads `pm: *PackageManager` and reads these directly. In Rust every
+/// Every
 /// caller is `pm.manifests.by_name…(pm, …)`, so accepting `&mut PackageManager`
 /// (or `&mut *raw`) would alias the `&mut self` receiver — Stacked-Borrows UB
 /// regardless of which fields the body touches. Capturing the four scalars by
@@ -113,10 +111,9 @@ impl PackageManifestMap {
         )
     }
 
-    /// Memory-only lookup — equivalent to Zig
-    /// `byNameHash(this, pm, scope, hash, .load_from_memory, _)` with
-    /// `is_expired = null`, but without the `ctx`/`scope` parameters: the
-    /// `.load_from_memory` arm never reads them. Exposed separately so callers
+    /// Memory-only lookup — equivalent to `by_name_hash` with
+    /// `CacheBehavior::LoadFromMemory`, but without the `ctx`/`scope`
+    /// parameters: the memory-only arm never reads them. Exposed separately so callers
     /// holding `&mut PackageManager` can borrow only the disjoint
     /// `pm.manifests` field.
     pub fn by_name_hash_in_memory(
@@ -148,13 +145,11 @@ impl PackageManifestMap {
         )
     }
 
-    /// Zig: `byNameHashAllowExpired(this, pm: *PackageManager, ...)`.
-    ///
-    /// PORT NOTE: reshaped for borrowck — Zig passes `pm` and reads
-    /// `pm.options.enable.*`, `pm.getCacheDirectory()`, and
-    /// `pm.timestamp_for_manifest_cache_control` on the disk-fallback arm.
-    /// Those scalars are hoisted into [`DiskCacheCtx`] so callers never hold
-    /// `&mut pm.manifests` and a `PackageManager` borrow simultaneously.
+    /// The `PackageManager` scalars read on the disk-fallback arm
+    /// (`options.enable.*`, the cache directory, and
+    /// `timestamp_for_manifest_cache_control`) are hoisted into
+    /// [`DiskCacheCtx`] so callers never hold `&mut pm.manifests` and a
+    /// `PackageManager` borrow simultaneously.
     pub fn by_name_hash_allow_expired(
         &mut self,
         ctx: DiskCacheCtx,
@@ -180,14 +175,11 @@ impl PackageManifestMap {
             };
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig's `getOrPut` returns `{ found_existing, value_ptr }`;
-        // Rust splits into Occupied/Vacant arms.
         match self.hash_map.entry(name_hash) {
             Entry::Occupied(occ) => {
                 let value_ptr = occ.into_mut();
-                // PORT NOTE: reshaped for borrowck — Zig mutated `value_ptr.*` in
-                // place from `.manifest` to `.expired`. Compute the demote decision
-                // first without holding a borrow that escapes the fn.
+                // Compute the demote decision first without holding a borrow
+                // that escapes the fn.
                 let demote = matches!(
                     value_ptr,
                     Value::Manifest(m)
@@ -265,5 +257,3 @@ impl PackageManifestMap {
         }
     }
 }
-
-// ported from: src/install/PackageManifestMap.zig
diff --git a/src/install/TarballStream.rs b/src/install/TarballStream.rs
index 60528ed98ff..75492719dbb 100644
--- a/src/install/TarballStream.rs
+++ b/src/install/TarballStream.rs
@@ -46,7 +46,6 @@ type Task = crate::package_manager_task::Task<'static>;
 
 bun_output::declare_scope!(TarballStream, hidden);
 
-// Zig: `[:0]const bun.OSPathChar` / `[:0]bun.OSPathChar` / `bun.OSPathSliceZ`.
 type OSPathZ<'a> = &'a OSPathSliceZ;
 type OSPathZMut<'a> = &'a mut OSPathSliceZ;
 
@@ -61,13 +60,12 @@ enum Phase {
     Done,
 }
 
-// PORT NOTE: `extract_task` / `package_manager` are raw pointers, not
-// `&'a mut` / `&'a`. The Zig original stores `*Task` / `*PackageManager`
-// (freely-aliasing). This struct is heap-allocated (`heap::alloc`),
+// `extract_task` / `package_manager` are raw pointers, not
+// `&'a mut` / `&'a`. This struct is heap-allocated (`heap::alloc`),
 // crosses threads via `drain_task`, and self-destroys in `finish()`, so a
 // borrowed lifetime cannot be sound. Holding `&'a mut Task` here while
 // `populate_result` materialises another `&mut Task` from a raw copy of it
-// would be aliased UB; raw pointers match the Zig aliasing contract.
+// would be aliased UB; raw pointers avoid forming aliased references.
 pub struct TarballStream {
     // ---------------------------------------------------------------------
     // Cross-thread producer state (HTTP → worker)
@@ -130,8 +128,7 @@ pub struct TarballStream {
     /// touches the filesystem.
     dest: Option<Fd>,
     /// Owned copy of the temp-directory name.
-    // Zig `[:0]const u8` field freed via `allocator.free`. `ZBox` is the
-    // owned NUL-terminated counterpart of `&ZStr` (port of `dupeZ`).
+    // `ZBox` is the owned NUL-terminated counterpart of `&ZStr`.
     tmpname: ZBox,
 
     /// Incremental SHA over the *compressed* bytes, matching
@@ -176,8 +173,8 @@ impl TarballStream {
     /// state machine is only worth its per-chunk overhead for tarballs that
     /// would otherwise consume a noticeable amount of memory.
     pub(crate) fn min_size() -> usize {
-        // env_var.get() returns Option<u64> in the Rust port even when a default
-        // is configured (Zig collapses it at comptime); the var has a 2 MiB
+        // env_var.get() returns Option<u64> even when a default
+        // is configured; the var has a 2 MiB
         // default so unwrap is infallible here.
         usize::try_from(env_var::BUN_INSTALL_STREAMING_MIN_SIZE.get().unwrap()).expect("int cast")
     }
@@ -188,13 +185,13 @@ impl TarballStream {
         manager: *mut PackageManager,
     ) -> *mut TarballStream {
         // Caller guarantees `extract_task` is live for the lifetime of this
-        // stream (it is published back to the main thread only in `finish()`);
-        // see Zig `init` which takes `*Task`. Wrapped once as `ParentRef` so
+        // stream (it is published back to the main thread only in `finish()`).
+        // Wrapped once as `ParentRef` so
         // the union read goes through the centralised tag-checked
         // `request_extract()` accessor; `extract` is the active `Request`
         // variant for streaming tarballs (set by `enqueueExtractNPMPackage`,
         // `tag == Tag::Extract`). Safe `From<NonNull>` construction — caller
-        // passes a non-null `*mut Task` (Zig `*Task`).
+        // passes a non-null `*mut Task`.
         let extract_task = bun_ptr::ParentRef::<Task>::from(
             core::ptr::NonNull::new(extract_task).expect("extract_task non-null (Zig *Task)"),
         );
@@ -270,7 +267,7 @@ impl TarballStream {
     /// `this` must be the live pointer returned by `init()`. Runs on the
     /// HTTP thread concurrently with `drain()` on a worker, so this never
     /// materialises `&mut TarballStream` — all access is via raw-ptr field
-    /// projection (Zig spec: freely-aliasing `*TarballStream`).
+    /// projection.
     pub(crate) unsafe fn on_chunk(
         this: *mut Self,
         chunk: &[u8],
@@ -440,8 +437,7 @@ impl TarballStream {
     /// `this` must be live. Called both from `drain()` and re-entrantly
     /// from inside libarchive's read callback (while `step()` is on the
     /// stack), so this must NOT materialise `&mut TarballStream` — all
-    /// access is via raw-ptr field projection (matches Zig's freely-
-    /// aliasing `*TarballStream`). Producer fields (`pending`/`closed`)
+    /// access is via raw-ptr field projection. Producer fields (`pending`/`closed`)
     /// are synchronised by `mutex`; drain-side fields (`reading`/
     /// `read_pos`/`hasher`) are owned by the single active drain task.
     unsafe fn take_pending(this: *mut Self) -> bool {
@@ -955,8 +951,7 @@ impl TarballStream {
     /// `this` must be the live pointer returned by `init()`. Frees `*this`
     /// — caller must not touch it after return. Takes a raw pointer (not
     /// `&mut self`) so no Rust reference dangles across the
-    /// `heap::take` self-destruction (Zig spec: `this.deinit()` with a
-    /// freely-aliasing `*TarballStream`).
+    /// `heap::take` self-destruction.
     // The `&(&(*task).request.extract)` wrappers below are deliberate — they
     // sidestep `dangerous_implicit_autorefs` by making the ref explicit before
     // the union deref. `needless_borrow` flags them as redundant but they are not.
@@ -966,7 +961,7 @@ impl TarballStream {
         // are live raw pointers; this fn is the sole owner. After
         // `heap::take(this)` nothing touches `this`.
         unsafe {
-            // Fields are already raw pointers (see struct PORT NOTE), so copying
+            // Fields are already raw pointers (see the struct-level note), so copying
             // them out before `heap::take(this)` is just a pointer copy — no
             // reborrow of `&mut Task` is ever materialised from a stored `&mut`.
             let task: *mut Task = (*this).extract_task.as_mut_ptr();
@@ -1034,7 +1029,7 @@ impl TarballStream {
             // thread may immediately recycle it *and* the NetworkTask it
             // references, so nothing below this line may touch either.
             // SAFETY: manager/task outlive this stream by construction; manager
-            // is `*mut` (Zig spec: mutable `*PackageManager`) and shared across
+            // is `*mut` and shared across
             // threads, so we mutate via raw-ptr deref without forming a
             // long-lived `&mut PackageManager`.
             (*manager)
@@ -1046,7 +1041,7 @@ impl TarballStream {
 
     /// # Safety
     /// `task` must be live and exclusively owned by this drain. Takes a raw
-    /// pointer (Zig: freely-aliasing `*Task`) so `tarball` (a borrow into
+    /// pointer so `tarball` (a borrow into
     /// `task.request`) can coexist with writes to `task.log`/`task.data`.
     // The `&(&(*task).request.extract)` wrapper below sidesteps
     // `dangerous_implicit_autorefs`; `needless_borrow` is wrong here.
@@ -1245,8 +1240,7 @@ extern "C" fn archive_read_callback(
     // unchanged. `step()`/`open_archive()` take `*mut Self` (not
     // `&mut self`) precisely so this pointer's provenance survives every
     // re-entry — see `step()` # Safety. We keep `this` as a raw pointer and
-    // access fields through it directly (Zig: freely-aliasing
-    // `*TarballStream`); no `&mut TarballStream` is live anywhere on the
+    // access fields through it directly; no `&mut TarballStream` is live anywhere on the
     // call stack while libarchive runs. All fields touched here (`reading`,
     // `read_pos`, `mutex`, `pending`, `closed`, `hasher`) are drain-side /
     // mutex-guarded and are not accessed by `step()` across the FFI call
@@ -1506,12 +1500,9 @@ fn apply_windows_npm_path_escapes(path: OSPathZMut) {
     }
 }
 
-// `std.mem.tokenizeScalar(OSPathChar, s, '/')` followed by one `next()` then
-// `.rest()`: Zig's `TokenIterator.rest()` first SKIPS any delimiters at the
-// current index (vendor/zig/lib/std/mem.zig) before returning
-// `buffer[index..]`, so for `"package/index.js"` the result is `"index.js"`
+// Skips any leading `/` delimiters, then returns everything after the first
+// path component, so for `"package/index.js"` the result is `"index.js"`
 // (no leading `/`).
-// TODO(port): Phase B — hoist into bun_str or bun_paths if reused elsewhere.
 fn tokenize_rest_after_first(s: &[OSPathChar]) -> &[OSPathChar] {
     let mut i = 0;
     while i < s.len() && s[i] == ('/' as OSPathChar) {
@@ -1530,5 +1521,3 @@ fn tokenize_rest_after_first(s: &[OSPathChar]) -> &[OSPathChar] {
 // discriminant; Data/Status live on PackageManagerTask.
 use crate::package_manager_task::{Data as TaskData, Status as TaskStatus};
 use crate::resolution::Tag as ResolutionTag;
-
-// ported from: src/install/TarballStream.zig
diff --git a/src/install/auto_installer.rs b/src/install/auto_installer.rs
index c18688447a1..1423b40c439 100644
--- a/src/install/auto_installer.rs
+++ b/src/install/auto_installer.rs
@@ -67,8 +67,8 @@ const _: () = {
 
 #[inline]
 fn tag_to_hooks(t: resolution::Tag) -> hooks::ResolutionTag {
-    // `resolution::Tag` is a `#[repr(transparent)]` u8 newtype (Zig
-    // `enum(u8) { ..., _ }` — non-exhaustive; lockfile bytes may carry any
+    // `resolution::Tag` is a `#[repr(transparent)]` u8 newtype
+    // (non-exhaustive; lockfile bytes may carry any
     // value). `hooks::ResolutionTag` is a closed `#[repr(u8)] enum`. A blind
     // transmute would produce an invalid enum discriminant (UB) for any byte
     // outside the named set, so map explicitly and saturate unknowns to
@@ -171,8 +171,6 @@ impl hooks::AutoInstaller for PackageManager {
         name: &[u8],
         version: &hooks::DependencyVersion,
     ) -> Option<PackageID> {
-        // Zig: `manager.lockfile.resolve(name, dependency_version)`
-        // (resolver.zig:2028) → `Lockfile.resolvePackageFromNameAndVersion`.
         self.lockfile
             .resolve_package_from_name_and_version(name, version)
     }
@@ -197,12 +195,12 @@ impl hooks::AutoInstaller for PackageManager {
         package_json: &dyn hooks::PackageJsonView,
         features: Features,
     ) -> Result<PackageID, bun_core::Error> {
-        // Port of `Package.fromPackageJSON` + `lockfile.appendPackage`
-        // (resolver.zig:2064-2073), driven entirely off the
+        // Builds a `Package` from a package.json and appends it to the
+        // lockfile, driven entirely off the
         // `PackageJsonView` interface so this impl does not need to name
         // `bun_resolver::PackageJSON` directly.
 
-        // PORT NOTE: reshaped for borrowck — `string_builder!` borrows
+        // Reshaped for borrowck — `string_builder!` borrows
         // `self.lockfile` mutably while `dep.clone_in` needs `&mut self`.
         // Use a raw pointer for the disjoint reborrow (same approach as
         // `Package::from_package_json`).
@@ -243,9 +241,7 @@ impl hooks::AutoInstaller for PackageManager {
         let dep_start = dependencies_list.len();
         debug_assert!(dependencies_list.len() == resolutions_list.len());
 
-        // Zig writes through `items.ptr[len..total_len]` and only bumps
-        // `.items.len` after the last fallible point (Package.zig:265-296).
-        // Mirror that by default-filling the tail now and `truncate`-ing back
+        // Default-fill the tail now and `truncate` back
         // to `dep_start` on the error path so a failed `clone_in` leaves both
         // buffer lengths consistent.
         let mut dependencies: &mut [dependency::Dependency] =
@@ -261,7 +257,7 @@ impl hooks::AutoInstaller for PackageManager {
             match dep.clone_in(pm_ref, source_buf, &mut string_builder) {
                 Ok(cloned) => dependencies[0] = cloned,
                 Err(e) => {
-                    // Zig: `defer string_builder.clamp()` — must run on the
+                    // `string_builder.clamp()` must run on the
                     // error path too. `truncate` drops the default-filled tail
                     // (and any already-written deps) before restoring length.
                     dependencies_list.truncate(dep_start);
@@ -278,9 +274,8 @@ impl hooks::AutoInstaller for PackageManager {
 
         package.meta.arch = package_json.arch();
         package.meta.os = package_json.os();
-        // Zig: `package.meta.setHasInstallScript(package.scripts.hasAny())`
-        // (resolver.zig:2390). `fromPackageJSON` leaves `scripts` zero-init, so
-        // `hasAny()` is always false here.
+        // `scripts` is left zero-init by this path, so
+        // has-install-script is always false here.
         package.meta.set_has_install_script(false);
 
         package.dependencies = crate::lockfile::DependencySlice::new(
@@ -305,9 +300,6 @@ impl hooks::AutoInstaller for PackageManager {
     }
 
     fn lockfile_append_root_stub(&mut self) -> Result<PackageID, bun_core::Error> {
-        // Zig: `try manager.lockfile.appendPackage(.{ .name = String.init("", ""),
-        //   .resolution = .{ .value = .{ .root = {} }, .tag = .root } })`
-        // (resolver.zig:2082).
         let pkg = Package {
             resolution: resolution::Resolution::init(resolution::TaggedValue::Root),
             ..Default::default()
@@ -356,7 +348,7 @@ impl hooks::AutoInstaller for PackageManager {
         patch_name_and_version_hash: Option<u64>,
     ) -> Result<(), bun_core::Error> {
         let r = resolution_from_hooks(resolution);
-        // Zig: resolver.zig:2123 — only the npm arm reaches this enqueue.
+        // Only the npm arm reaches this enqueue.
         // Caller passes a `Resolution` whose tag was already checked == Npm by
         // the resolver (`resolution.tag == .npm`); the field-copy bridge
         // preserves the tag/union pairing.
@@ -414,8 +406,8 @@ impl hooks::AutoInstaller for PackageManager {
         sliced: &SlicedString,
         log: Option<&mut bun_ast::Log>,
     ) -> Option<hooks::DependencyVersion> {
-        // Zig threads `pm` so `parse_with_tag` can record `npm:` aliases into
-        // `pm.known_npm_aliases` (dependency.zig:905).
+        // `pm` is threaded so `parse_with_tag` can record `npm:` aliases into
+        // `pm.known_npm_aliases`.
         dependency::parse(name, name_hash, version, sliced, log, Some(self))
     }
 
@@ -446,12 +438,6 @@ impl hooks::AutoInstaller for PackageManager {
 
 // ─── Lazy factory (resolver → install link-time hook) ─────────────────────
 //
-// Port of resolver.zig:538 `getPackageManager`'s `orelse` arm:
-//
-//     bun.HTTPThread.init(&.{});
-//     const pm = PackageManager.initWithRuntime(
-//         this.log, this.opts.install, bun.default_allocator, .{}, this.env_loader.?);
-//
 // `bun_resolver` cannot name `PackageManager` (it would create a dep cycle),
 // so it declares this `extern "Rust"` and we provide the body here. The
 // returned pointer is the process-static `PackageManager` singleton (`get()`),
@@ -464,15 +450,14 @@ impl hooks::AutoInstaller for PackageManager {
 //     the CLI-owned `Box<BunInstall>` (process-lifetime), read-only.
 //   • `env` is the resolver's unwrapped `env_loader` (Transpiler-owned,
 //     process-lifetime). `init_with_runtime` stores it as
-//     `NonNull<Loader<'static>>`; the `'static` lifetime matches Zig's
-//     untracked `*DotEnv.Loader`.
+//     `NonNull<Loader<'static>>`.
 #[unsafe(no_mangle)]
 pub(crate) unsafe fn __bun_resolver_init_package_manager(
     mut log: core::ptr::NonNull<bun_ast::Log>,
     install: Option<core::ptr::NonNull<crate::bun_schema::api::BunInstall>>,
     mut env: core::ptr::NonNull<bun_dotenv::Loader<'static>>,
 ) -> core::ptr::NonNull<dyn hooks::AutoInstaller> {
-    // Zig: `bun.HTTPThread.init(&.{})` — idempotent.
+    // Idempotent.
     bun_http::http_thread::init(&Default::default());
 
     // SAFETY: when `Some`, `install` points at a live `Api::BunInstall`
diff --git a/src/install/bin.rs b/src/install/bin.rs
index 8013ec5afb1..39655707bda 100644
--- a/src/install/bin.rs
+++ b/src/install/bin.rs
@@ -142,16 +142,11 @@ impl Bin {
         }
     }
 
-    /// Zig: `Bin.clone(buf, prev_external_strings, all_extern_strings,
-    /// extern_strings_slice, Builder, builder)`.
-    ///
-    /// PORT NOTE: the Zig API takes both the full `all_extern_strings` buffer
-    /// and a writable tail subslice into the **same** buffer — the full slice
-    /// is only used by `ExternalStringList::init` to compute the tail's
-    /// offset. In Rust those two views alias (`&[T]` overlapping `&mut [T]` is
-    /// UB under Stacked Borrows), so callers pass the precomputed offset
-    /// instead and we build the `ExternalStringList` directly. Renamed
-    /// `clone` → `clone_with_buffers` to avoid shadowing `Clone::clone`.
+    /// Callers pass the precomputed offset of the writable tail within
+    /// `all_extern_strings` (a full-buffer view would alias the writable
+    /// tail, which is UB under Stacked Borrows) and we build the
+    /// `ExternalStringList` directly. Named `clone_with_buffers` to avoid
+    /// shadowing `Clone::clone`.
     pub fn clone_with_buffers<B: StringBuilder>(
         &self,
         buf: &[u8],
@@ -247,13 +242,9 @@ impl Bin {
                             (current_len + num_props).saturating_sub(extern_strings.len()),
                         )
                         .map_err(|_| AllocError)?;
-                    // PORT NOTE: reshaped for borrowck — Zig bumped `items.len += num_props`
-                    // up-front and wrote into the spare-capacity region by raw pointer
-                    // (leaving partially-init slots on mid-loop bailout); here we push
-                    // incrementally so a bailout leaves only the slots actually written.
-                    // The returned `Bin` is `Tag::None` on bailout so the slots are never
-                    // indexed either way — strictly safer/less wasteful, no caller-visible
-                    // divergence.
+                    // Push incrementally so a bailout leaves only the slots
+                    // actually written. The returned `Bin` is `Tag::None` on
+                    // bailout so the slots are never indexed either way.
                     let mut i: usize = 0;
                     for bin_prop in props {
                         let Some(key_str) =
@@ -471,7 +462,7 @@ pub enum ToJsonStyle {
     MultiLine,
 }
 
-// `comptime StringBuilder: type` param maps onto the canonical
+// The canonical
 // `bun_semver::StringBuilder` trait (count + append<T> + provided
 // append_string/append_external_string wrappers). Re-exported so
 // `bin_real::StringBuilder` paths still resolve.
@@ -593,8 +584,8 @@ pub struct NamesIterator<'a> {
     pub dir_iterator: Option<sys::dir_iterator::WrappedIterator>,
     pub package_name: String,
     /// Borrowed view of the destination `node_modules` directory fd; the
-    /// caller owns the underlying `Dir`. Default is `Fd::INVALID` (Zig:
-    /// `bun.invalid_fd.stdDir()`), which `next_in_dir()` never reaches.
+    /// caller owns the underlying `Dir`. Default is `Fd::INVALID`, which
+    /// `next_in_dir()` never reaches.
     pub destination_node_modules: Fd,
     pub buf: PathBuffer,
     pub string_buffer: &'a [u8],
@@ -692,13 +683,11 @@ impl<'a> NamesIterator<'a> {
     }
 }
 
-// PORT NOTE: BACKREF — Zig stores `*const ArrayList(Dependency)` /
-// `*const ArrayList(u8)` (non-exclusive). `PackageInstaller` holds a
+// BACKREF — `PackageInstaller` holds a
 // `&mut Lockfile` alongside a `Box<[TreeContext]>` whose `binaries` queues
 // alias into `lockfile.buffers`; a `&'a Vec<_>` borrow here would force the
 // `TreeContext.binaries` field to carry an unsatisfiable `'static` (the
 // installer outlives no concrete lifetime for its own self-borrowed buffers).
-// `BackRef<Vec<_>>` mirrors the Zig ownership model exactly.
 pub struct PriorityQueueContext {
     pub dependencies: bun_ptr::BackRef<Vec<Dependency>>,
     pub string_buf: bun_ptr::BackRef<Vec<u8>>,
@@ -731,7 +720,6 @@ impl bun_collections::PriorityCompare<DependencyID> for PriorityQueueContext {
 // Min-heap keyed by `PriorityQueueContext::less_than` (string-order of dep names).
 pub(crate) type PriorityQueue = bun_collections::PriorityQueue<DependencyID, PriorityQueueContext>;
 
-// PORT NOTE: Zig's `Bin.PriorityQueue.Context` is an inherent associated type;
 // `inherent_associated_types` is unstable, so callers use `Bin::PriorityQueueContext`.
 pub type Context = PriorityQueueContext;
 
@@ -805,8 +793,8 @@ pub struct Linker<'a> {
     /// Usually will be the same as `node_modules_path`.
     /// Used to support native bin linking.
     ///
-    /// PORT NOTE: Zig uses `*bun.AbsPath(.{})` and intentionally aliases this
-    /// with `node_modules_path` (the common case). A `&'a AbsPath` would
+    /// This intentionally may alias `node_modules_path` (the common
+    /// case). A `&'a AbsPath` would
     /// conflict with the `&'a mut AbsPath` borrow on `node_modules_path`, so
     /// keep it as a raw pointer; the only read site dereferences it under a
     /// SAFETY note in `build_target_package_dir`.
@@ -922,8 +910,7 @@ impl<'a> Linker<'a> {
         }
 
         if let Some(seen) = self.seen.as_deref_mut() {
-            // PORT NOTE: StringHashMap::get_or_put boxes the key on insert; the
-            // Zig wrote `entry.key_ptr.* = dupe(abs_dest)` which is implicit here.
+            // StringHashMap::get_or_put boxes the key on insert.
             let _ = seen.get_or_put(abs_dest.as_bytes());
         }
 
@@ -1021,7 +1008,7 @@ impl<'a> Linker<'a> {
             return;
         }
 
-        // PORT NOTE: reshaped for borrowck — bind the owned buffer first, then
+        // reshaped for borrowck — bind the owned buffer first, then
         // borrow `content` from it (or fall back to the stack `chunk`).
         let content_to_free: Box<[u8]>;
         let content: &[u8] = if chunk.len() >= shebang_buf.len() {
@@ -1116,12 +1103,10 @@ impl<'a> Linker<'a> {
         abs_dest: &ZStr,
         global: bool,
     ) {
-        // PORT NOTE: Zig declares `var shim_buf: [65536]u8` and later
-        // `@ptrCast(@alignCast(...))`s it to `[*]u16` inside encode_into. In Zig
-        // `@alignCast` is a *runtime safety check* (panics in safe builds on
-        // misalignment), but in Rust constructing a `&mut [u16]` from a pointer
-        // that is not 2-aligned is *immediate language UB* — the reference
-        // validity invariant requires alignment even if never dereferenced.
+        // `encode_into` reinterprets this byte buffer as `[u16]`.
+        // Constructing a `&mut [u16]` from a pointer that is not 2-aligned is
+        // *immediate language UB* — the reference validity invariant requires
+        // alignment even if never dereferenced.
         // `[u8; N]` has `align_of == 1`, so the compiler is free to place it at
         // an odd address. Force 2-byte alignment at the declaration site so the
         // `*mut u16` slice construction in `encode_into` is provably sound.
@@ -1158,9 +1143,6 @@ impl<'a> Linker<'a> {
                         return;
                     }
 
-                    // PORT NOTE: borrowck — Zig's `save()`/`defer restore()` returns a
-                    // `ResetScope` holding `&mut Path`, which would keep
-                    // `node_modules_path` exclusively borrowed across `append()`.
                     // Snapshot the length and restore via `set_length` after.
                     let node_modules_path_save = self.node_modules_path.len();
                     let _ = self.node_modules_path.append(b".bin");
@@ -1197,8 +1179,9 @@ impl<'a> Linker<'a> {
 
         let shebang = 'shebang: {
             let first_content_chunk: Option<&[u8]> = 'contents: {
-                // TODO(port): target.stdFile().readerStreaming(&.{}) + readVec
-                let read = match target.read(&mut read_in_buf) {
+                // Loop-fill via `read_all` so a short read can't truncate the
+                // shebang sniff.
+                let read = match target.read_all(&mut read_in_buf) {
                     sys::Result::Ok(n) => n,
                     sys::Result::Err(_) => break 'contents None,
                 };
@@ -1266,7 +1249,7 @@ impl<'a> Linker<'a> {
 
     #[cfg(not(windows))]
     fn create_symlink(&mut self, abs_target: &ZStr, abs_dest: &ZStr, global: bool) {
-        // PORT NOTE: hoisted from `defer { if (this.err == null) chmod }` — scopeguard
+        // hoisted from `defer { if (this.err == null) chmod }` — scopeguard
         // cannot capture `&mut self.err` without conflicting with the body's writes,
         // so each return path calls `Self::chmod_on_ok` explicitly instead.
 
@@ -1292,9 +1275,7 @@ impl<'a> Linker<'a> {
                         return;
                     }
 
-                    // PORT NOTE: reshaped for borrowck — Zig's `var s = path.save();
-                    // defer s.restore();` returns a `ResetScope` holding `&mut Path`;
-                    // capture `len()` and restore via `set_length()` so the path
+                    // Capture `len()` and restore via `set_length()` so the path
                     // can be re-borrowed for `append`/`slice` in between.
                     let node_modules_path_save = self.node_modules_path.len();
                     let _ = self.node_modules_path.append(b".bin");
@@ -1313,8 +1294,6 @@ impl<'a> Linker<'a> {
                             return;
                         }
                     }
-                    // NOTE: unreachable in Zig too — the third symlink call below the
-                    // switch in the original is dead code (both arms above return).
                 }
 
                 // beyond this error can only be `.EXIST`
@@ -1336,7 +1315,7 @@ impl<'a> Linker<'a> {
 
     #[cfg(not(windows))]
     fn chmod_on_ok(err: Option<Error>, abs_target: &ZStr) {
-        // PORT NOTE: hoisted from `defer` block in create_symlink
+        // hoisted from `defer` block in create_symlink
         if err.is_none() {
             let mode = 0o777 & !(UMASK.load(Ordering::Acquire) as Mode);
             let _ = sys::lchmod(abs_target, mode);
@@ -1348,7 +1327,7 @@ impl<'a> Linker<'a> {
         // SAFETY: `target_node_modules_path` is set at construction to either
         // a caller-owned `AbsPath` or the same buffer as `node_modules_path`;
         // both outlive `self` and are not mutated for the duration of this
-        // read (mirrors Zig's aliasing `*AbsPath`).
+        // read.
         let dest_dir_without_trailing_slash =
             strings::without_trailing_slash(unsafe { (*self.target_node_modules_path).slice() });
         let package_name = self.target_package_name.slice();
@@ -1467,8 +1446,7 @@ impl<'a> Linker<'a> {
     ///
     /// Falls through to (1) when nothing exists so the existing
     /// `skipped_due_to_missing_bin` retry-without-redirect path still fires.
-    // PORT NOTE: reshaped for borrowck — Zig took `*const Linker` but only read
-    // `is_native_binlink_redirect()`. Hoist that bool to a parameter so the
+    // `is_native_binlink_redirect()` is hoisted to a parameter so the
     // caller can drop its `&self` borrow before mutably calling
     // `link_bin_or_create_shim`. Result borrows the threadlocal join buffer
     // (lifetime tied to `package_dir` per `join_abs_string_z`'s signature).
@@ -1506,11 +1484,11 @@ impl<'a> Linker<'a> {
         // SAFETY: `target_node_modules_path` is set at construction to either
         // a caller-owned `AbsPath` or the same buffer as `node_modules_path`;
         // both outlive `self` and are not mutated for the duration of this
-        // read (mirrors Zig's aliasing `*AbsPath`).
+        // read.
         let dest_dir_without_trailing_slash =
             strings::without_trailing_slash(unsafe { (*self.target_node_modules_path).slice() });
 
-        // PORT NOTE: reshaped for borrowck — track offset instead of remain.ptr arithmetic
+        // reshaped for borrowck — track offset instead of remain.ptr arithmetic
         let mut off: usize = 0;
         let buf = &mut *self.abs_target_buf;
 
@@ -1531,8 +1509,8 @@ impl<'a> Linker<'a> {
 
     /// Returns the offset into `self.abs_dest_buf` where the destination dir ends
     /// (i.e. where the bin name should be written).
-    // PORT NOTE: reshaped — Zig returned a `[]u8` view (remain) into abs_dest_buf;
-    // returning an offset avoids overlapping &mut borrows of self.
+    // Returning an offset (rather than a slice into abs_dest_buf) avoids
+    // overlapping &mut borrows of self.
     pub fn build_destination_dir(&mut self, global: bool) -> usize {
         let dest_dir_without_trailing_slash =
             strings::without_trailing_slash(self.node_modules_path.slice());
@@ -1570,11 +1548,10 @@ impl<'a> Linker<'a> {
 
         debug_assert!(self.bin.tag != Tag::None);
 
-        // PORT NOTE: reshaped for borrowck — `link_bin_or_create_shim(&mut self, ..)`
+        // `link_bin_or_create_shim(&mut self, ..)`
         // is called while `abs_target` / `abs_dest` borrow `self.abs_target_buf`
-        // / `self.abs_dest_buf`. The Zig holds raw `[]u8` views (no exclusivity
-        // implied) and `link_bin_or_create_shim` never reads or writes those two
-        // buffers (it only touches `rel_buf`, `node_modules_path`, `seen`, `err`,
+        // / `self.abs_dest_buf`. `link_bin_or_create_shim` never reads or writes
+        // those two buffers (it only touches `rel_buf`, `node_modules_path`, `seen`, `err`,
         // `skipped_due_to_missing_bin`). Detach the `abs_dest` borrow via a raw
         // pointer so borrowck allows the disjoint access; the SAFETY invariant
         // is that `abs_dest_buf` is not aliased mutably for the lifetime of the
@@ -1625,7 +1602,7 @@ impl<'a> Linker<'a> {
                     dest_off += unscoped_package_name.len();
                     self.abs_dest_buf[dest_off] = 0;
                     let abs_dest_len = dest_off;
-                    // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see PORT NOTE.
+                    // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see note above.
                     let abs_dest = ZStr::from_raw(abs_dest_buf_ptr, abs_dest_len);
 
                     self.link_bin_or_create_shim(
@@ -1670,7 +1647,7 @@ impl<'a> Linker<'a> {
                     dest_off += normalized_name.len();
                     self.abs_dest_buf[dest_off] = 0;
                     let abs_dest_len = dest_off;
-                    // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see PORT NOTE.
+                    // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see note above.
                     let abs_dest = ZStr::from_raw(abs_dest_buf_ptr, abs_dest_len);
 
                     self.link_bin_or_create_shim(
@@ -1725,7 +1702,7 @@ impl<'a> Linker<'a> {
                         dest_off += normalized_bin_dest.len();
                         self.abs_dest_buf[dest_off] = 0;
                         let abs_dest_len = dest_off;
-                        // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see PORT NOTE.
+                        // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see note above.
                         let abs_dest = ZStr::from_raw(abs_dest_buf_ptr, abs_dest_len);
 
                         self.link_bin_or_create_shim(
@@ -1754,7 +1731,7 @@ impl<'a> Linker<'a> {
                         // SAFETY: `join_abs_string_z` writes into the thread-local
                         // `PARSER_JOIN_INPUT_BUFFER`; result does not borrow
                         // `package_dir`. Detached so `abs_target_buf` can be
-                        // reused inside the loop body (see Zig comment below).
+                        // reused inside the loop body (see the SAFETY note below).
                         ZStr::from_raw(r.as_bytes().as_ptr(), r.len())
                     };
 
@@ -1791,8 +1768,7 @@ impl<'a> Linker<'a> {
                                     // SAFETY: result lives in `self.abs_target_buf`, which
                                     // `link_bin_or_create_shim` does not write to (only
                                     // `rel_buf`/`node_modules_path`/`seen`/`err`/
-                                    // `skipped_due_to_missing_bin` are touched). Mirrors
-                                    // the Zig aliasing.
+                                    // `skipped_due_to_missing_bin` are touched).
                                     ZStr::from_raw(r.as_bytes().as_ptr(), r.len())
                                 };
 
@@ -1808,7 +1784,7 @@ impl<'a> Linker<'a> {
                                 dest_off += entry_name.len();
                                 self.abs_dest_buf[dest_off] = 0;
                                 let abs_dest_len = dest_off;
-                                // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see PORT NOTE.
+                                // SAFETY: abs_dest_buf[abs_dest_len] == 0 written above; see note above.
                                 let abs_dest = ZStr::from_raw(abs_dest_buf_ptr, abs_dest_len);
 
                                 self.link_bin_or_create_shim(
@@ -1832,7 +1808,7 @@ impl<'a> Linker<'a> {
 
         debug_assert!(self.bin.tag != Tag::None);
 
-        // PORT NOTE: see `link()` — detach abs_target_buf borrow via raw ptr.
+        // see `link()` — detach abs_target_buf borrow via raw ptr.
         let abs_target_buf_ptr: *const u8 = self.abs_target_buf.as_ptr();
         // SAFETY: abs_target_buf is not written between here and use.
         let package_dir = unsafe { bun_core::ffi::slice(abs_target_buf_ptr, package_dir_len) };
@@ -1965,5 +1941,3 @@ impl<'a> Linker<'a> {
         }
     }
 }
-
-// ported from: src/install/bin.zig
diff --git a/src/install/build.rs b/src/install/build.rs
index bd249a65c5c..b987126a62b 100644
--- a/src/install/build.rs
+++ b/src/install/build.rs
@@ -7,10 +7,8 @@
 //! Generates the sorted `DEFAULT_TRUSTED_DEPENDENCIES_LIST` slice from
 //! `default-trusted-dependencies.txt`.
 //!
-//! Zig builds this at comptime via `@embedFile` + tokenize + sort
-//! (see `src/install/lockfile.zig`). Rust cannot tokenize/sort at const time
-//! without a build script, so we emit a `&[&[u8]]` literal here and `include!`
-//! it from `lockfile.rs`.
+//! Rust cannot tokenize/sort at const time without a build script, so we
+//! emit a `&[&[u8]]` literal here and `include!` it from `lockfile.rs`.
 
 use std::env;
 use std::fmt::Write as _;
@@ -27,14 +25,12 @@ fn main() {
     let data = fs::read_to_string(&txt)
         .unwrap_or_else(|e| panic!("failed to read {}: {e}", txt.display()));
 
-    // Zig: std.mem.tokenizeAny(u8, data, " \r\n\t")
     let mut names: Vec<&str> = data
         .split([' ', '\r', '\n', '\t'])
         .filter(|s| !s.is_empty())
         .collect();
 
-    // Zig: alphabetical sort so `bun pm trusted --default` doesn't need to sort.
-    // std.mem.order(u8, ..) == .lt  ↔  byte-wise ordering.
+    // Alphabetical byte-wise sort so `bun pm trusted --default` doesn't need to sort.
     names.sort_unstable_by(|a, b| a.as_bytes().cmp(b.as_bytes()));
 
     assert!(
diff --git a/src/install/dependency.rs b/src/install/dependency.rs
index aaaf57fca8a..0f3dcd83f1c 100644
--- a/src/install/dependency.rs
+++ b/src/install/dependency.rs
@@ -13,7 +13,7 @@ use crate::{PackageManager, PackageNameHash};
 // NpmAliasRegistry — exposes only the one `PackageManager` method `parse`
 // actually touches (`known_npm_aliases.put`) so `parse_with_tag` can take an
 // `Option<&mut dyn NpmAliasRegistry>` and stay decoupled from the full
-// `PackageManager` surface (Zig threads `*PackageManager` directly).
+// `PackageManager` surface.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait NpmAliasRegistry {
@@ -23,7 +23,6 @@ pub trait NpmAliasRegistry {
 impl NpmAliasRegistry for PackageManager {
     #[inline]
     fn record_npm_alias(&mut self, hash: PackageNameHash, version: &Version) {
-        // Zig: `pm.known_npm_aliases.put(hash, result)`.
         self.known_npm_aliases.insert(hash, Clone::clone(version));
     }
 }
@@ -110,20 +109,19 @@ pub trait DependencyExt {
 }
 
 impl DependencyExt for Dependency {
-    /// Forwards to the module-level `is_tarball` (Zig: `Dependency.isTarball`).
+    /// Forwards to the module-level `is_tarball`.
     #[inline]
     fn is_tarball(dependency: &[u8]) -> bool {
         is_tarball(dependency)
     }
 
-    /// Forwards to the module-level free fn (Zig file-struct method:
-    /// `Dependency.splitNameAndMaybeVersion`).
+    /// Forwards to the module-level `split_name_and_maybe_version`.
     #[inline]
     fn split_name_and_maybe_version(str: &[u8]) -> (&[u8], Option<&[u8]>) {
         split_name_and_maybe_version(str)
     }
 
-    /// Zig: `Dependency.unscopedPackageName`. Strips a leading `@scope/` if present.
+    /// Strips a leading `@scope/` if present.
     fn unscoped_package_name(name: &[u8]) -> &[u8] {
         if name.is_empty() || name[0] != b'@' {
             return name;
@@ -135,13 +133,11 @@ impl DependencyExt for Dependency {
         }
     }
 
-    /// Forwards to the module-level `parse_with_optional_tag`
-    /// (Zig: `Dependency.parseWithOptionalTag`).
+    /// Forwards to the module-level `parse_with_optional_tag`.
     ///
     /// `alias_hash`, `log`, and `package_manager` accept either the bare value
-    /// (`u64` / `&mut Log` / `&mut PackageManager`) or `Option<_>` — Zig callers
-    /// pass both forms (`null` vs pointer) and the port keeps that ergonomics
-    /// via `impl Into<Option<_>>`.
+    /// (`u64` / `&mut Log` / `&mut PackageManager`) or `Option<_>` via
+    /// `impl Into<Option<_>>`.
     #[inline]
     fn parse_with_optional_tag<'a, 'b>(
         alias: String,
@@ -179,9 +175,8 @@ impl DependencyExt for Dependency {
         strings::cmp_strings_asc((), lhs_name, rhs_name)
     }
 
-    /// Total-order comparator for `slice::sort_by` (Zig's `std.sort.pdq`
-    /// accepts a strict-weak `lessThan`; Rust's sort requires a full
-    /// `Ordering`). Same key as `is_less_than`: behavior group, then name ASC.
+    /// Total-order comparator for `slice::sort_by`. Same key as
+    /// `is_less_than`: behavior group, then name ASC.
     fn cmp(string_buf: &[u8], lhs: &Dependency, rhs: &Dependency) -> Ordering {
         let behavior = lhs.behavior.cmp(rhs.behavior);
         if behavior != Ordering::Equal {
@@ -204,7 +199,7 @@ impl DependencyExt for Dependency {
         self.count_with_different_buffers(buf, buf, builder);
     }
 
-    /// Zig: `Dependency.clone`. Renamed to `clone_in` so it doesn't shadow
+    /// Named `clone_in` so it doesn't shadow
     /// `std::clone::Clone::clone` (callers in `migration.rs` / `PackageManager.rs`
     /// rely on the trait method for shallow copy).
     fn clone_in<SB: StringBuilderLike, PM: NpmAliasRegistry>(
@@ -213,7 +208,6 @@ impl DependencyExt for Dependency {
         buf: &[u8],
         builder: &mut SB,
     ) -> Result<Dependency, bun_core::Error> {
-        // TODO(port): narrow error set
         self.clone_with_different_buffers(package_manager, buf, buf, builder)
     }
 
@@ -224,10 +218,8 @@ impl DependencyExt for Dependency {
         version_buf: &[u8],
         builder: &mut SB,
     ) -> Result<Dependency, bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: reshaped for borrowck — Zig captured `out_slice` first, but
-        // `append_string` may reallocate `string_bytes`, invalidating the slice.
-        // Append first, then borrow the (now-stable) buffer.
+        // `append_string` may reallocate `string_bytes`, invalidating any
+        // prior slice. Append first, then borrow the (now-stable) buffer.
         let new_literal = builder.append_string(self.version.literal.slice(version_buf));
         let new_name = builder.append_string(self.name.slice(name_buf));
         let out_slice = builder.string_bytes();
@@ -292,7 +284,7 @@ impl DependencyExt for Dependency {
     /// (`bun_install_jsc`) keep type-checking.
     ///
     /// `alias_hash`, `log`, and `manager` accept either bare values or
-    /// `Option<_>` (Zig callers pass both `null` and concrete pointers).
+    /// `Option<_>`.
     #[inline]
     fn parse<'a, 'b>(
         alias: String,
@@ -306,22 +298,19 @@ impl DependencyExt for Dependency {
     }
 }
 
-// `comptime StringBuilder: type` param maps onto `bun_semver::StringBuilder`
+// Uses the `bun_semver::StringBuilder` trait
 // (count / append<T> / append_string). The only extra method needed here is
-// access to the FULL backing buffer (Zig: `builder.lockfile.buffers
-// .string_bytes.items`), which is intentionally NOT on the base trait since
+// access to the FULL backing buffer, which is intentionally NOT on the base trait since
 // `semver_string::Builder`'s isolated Box<[u8]> would be wrong for callers
 // that need the lockfile's full string_bytes.
 pub trait StringBuilderLike: bun_semver::StringBuilder {
-    /// Full backing string buffer (Zig: `builder.lockfile.buffers.string_bytes.items`).
+    /// Full backing string buffer.
     fn string_bytes(&self) -> &[u8];
 }
 
-// PORT NOTE: single-impl monomorphization is intentional. Every Zig call site
-// of `Dependency.count`/`clone`/`*WithDifferentBuffers` passes
-// `*Lockfile.StringBuilder` (Package.zig, OverrideMap.zig, CatalogMap.zig,
-// install_with_manager.zig) — `semver_string::Builder` is never used here, and
-// its isolated Box<[u8]> can't satisfy `builder.lockfile.buffers.string_bytes`.
+// single-impl monomorphization is intentional — `semver_string::Builder` is
+// never used here, and its isolated Box<[u8]> can't satisfy
+// `builder.lockfile.buffers.string_bytes`.
 impl<'a> StringBuilderLike for crate::lockfile_real::StringBuilder<'a> {
     #[inline]
     fn string_bytes(&self) -> &[u8] {
@@ -463,8 +452,8 @@ pub(crate) fn is_remote_tarball(dependency: &[u8]) -> bool {
 // ──────────────────────────────────────────────────────────────────────────
 // Compat aliases: dependents reference `dependency::version::Tag`,
 // `dependency::VersionTag`, `Dependency::is_remote_tarball`, and a `tarball`
-// submodule. The Zig nests `Tag` under `Dependency.Version`, but here it's
-// flattened to top-level — keep both paths so dependents type-check.
+// submodule. `Tag` lives at top level here — keep both paths so dependents
+// type-check.
 // ──────────────────────────────────────────────────────────────────────────
 pub use Tag as VersionTag;
 pub mod version {
@@ -634,22 +623,17 @@ pub trait VersionExt {
 }
 
 impl VersionExt for Version {
-    // Zig: `pub const zeroed = Version{};` — a const value. Rust can't const-init
-    // (Default::default() isn't const), so callers should use `Version::zeroed()`
-    // or `Version::default()` instead.
     #[inline]
     fn zeroed() -> Version {
         Version::default()
     }
 
-    /// Zig: `Version.clone`. Renamed to `clone_in` so it doesn't shadow
-    /// `std::clone::Clone::clone`.
+    /// Named `clone_in` so it doesn't shadow `std::clone::Clone::clone`.
     fn clone_in<SB: StringBuilderLike>(
         &self,
         buf: &[u8],
         builder: &mut SB,
     ) -> Result<Version, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Version {
             tag: self.tag,
             literal: builder.append_string(self.literal.slice(buf)),
@@ -771,7 +755,7 @@ impl VersionExt for Version {
 // Version::Tag
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: Zig `Tag.map = bun.ComptimeStringMap(Tag, ...)`. Was a `phf::Map`
+// Was a `phf::Map`
 // in an earlier draft; rewritten as a length-gated match (cf. 12577e958d71
 // clap::find_param) — 9 entries with near-unique lengths, so a single `usize`
 // compare rejects almost every miss before touching bytes, and hits resolve in
@@ -825,8 +809,8 @@ impl TagExt for Tag {
         }
 
         if strings::starts_with_windows_drive_letter_t(dependency)
-            // PORT NOTE: Zig `std.fs.path.isSep` — platform-native separator only
-            // (`/` on POSIX, `/` or `\` on Windows). NOT `isSepAny`.
+            // Platform-native separator only
+            // (`/` on POSIX, `/` or `\` on Windows).
             && {
                 #[cfg(windows)]
                 { matches!(dependency[2], b'/' | b'\\') }
@@ -840,8 +824,6 @@ impl TagExt for Tag {
             return Tag::Folder;
         }
 
-        // PERF(port): was stack-fallback allocator (1024B); now uses global mimalloc — profile if it shows up on a hot path.
-
         match dependency[0] {
             // =1
             // >1.2
@@ -919,7 +901,7 @@ impl TagExt for Tag {
                         match url[0] {
                             b':' => {
                                 // TODO(markovejnovic): This check for testing whether the URL
-                                // is a Git URL shall be moved to npm_package_arg.zig when that
+                                // is a Git URL shall be moved to npm_package_arg when that
                                 // is implemented.
                                 if url.starts_with(b"://") {
                                     url = &url[b"://".len()..];
@@ -1049,7 +1031,7 @@ impl TagExt for Tag {
                             url = &url[b"git@".len()..];
                         }
 
-                        let _ = url; // PORT NOTE: Zig mutates `url` but doesn't use it after this point
+                        let _ = url; // not used after this point
 
                         if let Ok(Some(info)) = hosted_git_info::HostedGitInfo::from_url(dependency)
                         {
@@ -1334,7 +1316,6 @@ pub fn parse_with_tag(
 
             if is_alias {
                 if let Some(pm) = package_manager {
-                    // Zig: `pm.known_npm_aliases.put(alias_hash.?, result)`.
                     pm.record_npm_alias(alias_hash.unwrap(), &result);
                 }
             }
@@ -1724,5 +1705,3 @@ fn hgi_to_tag(info: &hosted_git_info::HostedGitInfo) -> Tag {
         | hosted_git_info::HostProvider::Sourcehut => Tag::Git,
     }
 }
-
-// ported from: src/install/dependency.zig
diff --git a/src/install/extract_tarball.rs b/src/install/extract_tarball.rs
index 30d8e7ac138..57b64e6c4cb 100644
--- a/src/install/extract_tarball.rs
+++ b/src/install/extract_tarball.rs
@@ -21,8 +21,6 @@ use bun_libarchive::{ArchiveAppender, ExtractOptions};
 use bun_resolver::fs::FileSystem;
 #[cfg(windows)]
 use bun_sys::FdDirExt;
-
-// TODO(port): narrow error set
 type Error = bun_core::Error;
 
 const MAX_DECOMPRESSED_TARBALL_SIZE: usize = 2 * 1024 * 1024 * 1024;
@@ -96,15 +94,12 @@ pub(crate) fn build_url(
         full_name_,
         version,
         string_buf,
-        // Zig: `FileSystem.DirnameStore.print(fmt, args)` — format directly into
-        // the store's tail; no intermediate `String`.
+        // Format directly into the store's tail; no intermediate `String`.
         |args| FileSystem::instance().dirname_store().print(args),
     )
 }
 
-/// Generic URL builder. The Zig version threads `comptime PrinterContext`,
-/// `comptime ReturnType`, `comptime ErrorType` and a comptime `print` fn; in
-/// Rust the closure carries its own context and the generics collapse to `R, E`.
+/// Generic URL builder; the closure carries its own context.
 pub(crate) fn build_url_with_printer<R, E>(
     registry_: &[u8],
     full_name_: &StringOrTinyString,
@@ -125,7 +120,7 @@ pub(crate) fn build_url_with_printer<R, E>(
     // default_format = "{s}/{s}/-/"
     // `bun_fmt::s` writes bytes straight through — registry hosts, package names
     // and semver tags are pre-validated ASCII, so we don't need `bstr::BStr`'s
-    // Utf8Chunks scan (Zig `{s}` parity).
+    // Utf8Chunks scan.
     let registry = s(registry);
     let full_name = s(full_name);
     let name = s(name);
@@ -235,9 +230,8 @@ impl ExtractTarball {
         let _tracer = bun_core::perf::trace("ExtractTarball.extract");
 
         let tmpdir = Dir::borrow(&self.temp_dir);
-        // Zig: `var tmpname_buf: [bun.MAX_PATH_BYTES]u8` — UTF-8 on every
-        // platform; the Windows tmpdir path is converted to wide at the
-        // `open_dir_at_windows_a` boundary, not here.
+        // UTF-8 on every platform; the Windows tmpdir path is converted to
+        // wide at the `open_dir_at_windows_a` boundary, not here.
         let mut tmpname_buf = PathBuffer::uninit();
         let (name, basename) = self.name_and_basename();
         let truncated_basename = &basename[0..basename.len().min(32)];
@@ -413,8 +407,6 @@ impl ExtractTarball {
                         outdirname: &mut resolved,
                     };
 
-                    // PERF(port): was comptime bool dispatch on verbose_install — folded into
-                    // `ExtractOptions::log` (runtime) — profile if hot.
                     let _ = Archiver::extract_to_dir(
                         &zlib_pool.list,
                         extract_destination.fd(),
@@ -432,7 +424,7 @@ impl ExtractTarball {
                     // installed from GitHub. package.json version becomes sort of
                     // meaningless in cases like this.
                     if !resolved.is_empty() {
-                        // `std.fs.Dir.createFileZ(".bun-tag", .{ .truncate = true })` + write
+                        // Create/truncate `.bun-tag`, then write the resolved tag.
                         if sys::File::openat(
                             extract_destination.fd(),
                             ZStr::from_static(b".bun-tag\0"),
@@ -453,8 +445,6 @@ impl ExtractTarball {
                     }
                 }
                 _ => {
-                    // PERF(port): was comptime bool dispatch on verbose_install — folded into
-                    // `ExtractOptions::log` (runtime) — profile if hot.
                     let _ = Archiver::extract_to_dir(
                         &zlib_pool.list,
                         extract_destination.fd(),
@@ -509,8 +499,7 @@ impl ExtractTarball {
 
         let tmpdir = Dir::borrow(&self.temp_dir);
         TL_BUFS.with_borrow_mut(|bufs| {
-            // PORT NOTE: reshaped for borrowck — Zig grabbed a raw `*TlBufs` from TLS;
-            // here the entire body lives inside the thread_local borrow closure.
+            // The entire body lives inside the thread_local borrow closure.
             let folder_name: &[u8] = match self.resolution.tag {
                 ResolutionTag::Npm => {
                     if !bun_install::dependency::is_safe_install_folder_name(name) {
@@ -920,5 +909,3 @@ impl ExtractTarball {
         })
     }
 }
-
-// ported from: src/install/extract_tarball.zig
diff --git a/src/install/hoisted_install.rs b/src/install/hoisted_install.rs
index 30e6ef9d3e8..86206cbe894 100644
--- a/src/install/hoisted_install.rs
+++ b/src/install/hoisted_install.rs
@@ -16,7 +16,7 @@ use crate::bun_progress::{Node as ProgressNode, Progress};
 use crate::lockfile::tree;
 use crate::{DependencyID, ExtractData, PackageID};
 // Bring the `items_<field>{,_mut}()` column accessors for
-// `MultiArrayList::Slice<Package>` into scope (Zig: `slice.items(.field)`).
+// `MultiArrayList::Slice<Package>` into scope.
 use crate::PackageManager;
 use crate::bin_real as bin;
 use crate::package_install;
@@ -26,9 +26,8 @@ use crate::package_manager_real::ProgressStrings;
 use crate::package_manager_real::run_tasks;
 use crate::package_manager_task as Task;
 
-/// `RunTasksCallbacks` impl for the hoisted-install loop. Mirrors the Zig
-/// anonymous-struct call shape `{ .onExtract = installEnqueuedPackagesAfterExtraction,
-/// .onResolve = {}, ... }` with `Ctx == *PackageInstaller`.
+/// `RunTasksCallbacks` impl for the hoisted-install loop, with
+/// `Ctx == PackageInstaller`.
 pub(crate) struct HoistedRunTasksCallbacks<'a>(core::marker::PhantomData<&'a mut ()>);
 
 impl<'a> run_tasks::RunTasksCallbacks for HoistedRunTasksCallbacks<'a> {
@@ -56,7 +55,6 @@ impl<'a> run_tasks::RunTasksCallbacks for HoistedRunTasksCallbacks<'a> {
     }
 }
 
-// TODO(port): narrow error set
 pub(crate) fn install_hoisted_packages(
     this: &mut PackageManager,
     ctx: Command::Context,
@@ -67,7 +65,7 @@ pub(crate) fn install_hoisted_packages(
 ) -> Result<package_install::Summary, bun_core::Error> {
     analytics::features::hoisted_bun_install.fetch_add(1, Ordering::Relaxed);
 
-    // PORT NOTE: `defer { restore buffers }` (Zig:16) — side-effecting rollback,
+    // Restore-buffers guard — side-effecting rollback,
     // not a free. Captures `*mut PackageManager` so the guard can write back
     // through the same provenance root the body uses (see `mgr_ptr` below).
     let mgr_ptr: *mut PackageManager = this;
@@ -78,10 +76,8 @@ pub(crate) fn install_hoisted_packages(
 
     let original_trees = core::mem::take(&mut this.lockfile.buffers.trees);
     let original_tree_dep_ids = core::mem::take(&mut this.lockfile.buffers.hoisted_dependencies);
-    // Put them back immediately — Zig's `const original_* = buffers.*` is a
-    // by-value copy of the ArrayList header (ptr/len/cap), leaving the buffer
-    // live. Rust `Vec` can't alias like that, so the rollback below restores
-    // the *taken* originals; `filter()` repopulates the live ones in-place.
+    // Put them back immediately — the rollback below restores the *taken*
+    // originals; `filter()` repopulates the live ones in-place.
     this.lockfile.buffers.trees.clone_from(&original_trees);
     this.lockfile
         .buffers
@@ -89,8 +85,7 @@ pub(crate) fn install_hoisted_packages(
         .clone_from(&original_tree_dep_ids);
 
     {
-        // PORT NOTE: reshaped for borrowck — Zig passes `this.log, this` (two
-        // borrows of `this`). `lockfile` is `Box<Lockfile>` so the heap object
+        // `lockfile` is `Box<Lockfile>` so the heap object
         // is disjoint from the `PackageManager` struct; snapshot raw `*mut
         // Lockfile` and `*mut Log` first so `filter` can hold `&mut Lockfile`
         // and `&mut PackageManager` simultaneously through `mgr_ptr`'s
@@ -99,8 +94,8 @@ pub(crate) fn install_hoisted_packages(
         // SAFETY: `mgr_ptr` is the provenance root; `lockfile` is heap-owned
         // via `Box`, so `*mut Lockfile` does not overlap `*mut PackageManager`.
         let lockfile_ptr: *mut crate::lockfile::Lockfile = unsafe { &raw mut *(*mgr_ptr).lockfile };
-        // SAFETY: `log` is the always-live logger backref (Zig: `*Log`, never
-        // null); `mgr_ptr` see shadow-reborrow above.
+        // SAFETY: `log` is the always-live logger backref (never null);
+        // `mgr_ptr` see shadow-reborrow above.
         unsafe {
             (*lockfile_ptr).filter(
                 &mut *log,
@@ -149,13 +144,15 @@ pub(crate) fn install_hoisted_packages(
         download_node = root_node.start(ProgressStrings::download(), 0);
         install_node = root_node.start(ProgressStrings::install(), hoisted_len);
         scripts_node = root_node.start(ProgressStrings::script(), 0);
+        // The stored pointers target stack locals in this frame; they are
+        // cleared by `_end_progress` below before the frame returns, so
+        // `scripts_node_mut()` / `downloads_node_mut()` never observe a
+        // dangling pointer outside this call.
         this.downloads_node = Some(core::ptr::addr_of_mut!(download_node));
         this.scripts_node = NonNull::new(&raw mut scripts_node);
-        // TODO(port): storing pointers to stack locals into `this` — reshape so the
-        // nodes live in PackageManager or thread lifetimes through.
     }
 
-    // PORT NOTE: `defer { progress.root.end(); progress = .{} }`
+    // `defer { progress.root.end(); progress = .{} }`
     let _end_progress = scopeguard::guard(log_level, move |log_level| {
         if log_level.show_progress() {
             // SAFETY: `mgr_ptr` provenance — see `_restore_buffers` note.
@@ -229,16 +226,15 @@ pub(crate) fn install_hoisted_packages(
     let mut summary = package_install::Summary::default();
 
     {
-        // PORT NOTE: BACKREF — `Tree::Iterator` borrows the four buffer slices,
+        // BACKREF — `Tree::Iterator` borrows the four buffer slices,
         // and `PackageInstaller` simultaneously holds `&mut Lockfile` (plus
-        // `&[T]` column aliases into `lockfile.packages`). Zig stores
-        // non-exclusive `*const Lockfile` in the iterator. Snapshot raw `*const
+        // `&[T]` column aliases into `lockfile.packages`). Snapshot raw `*const
         // Vec<_>` headers here so the iterator's slice borrows are derived
         // through `mgr_ptr` (the same provenance root as `installer.lockfile`),
         // not through a `&this.lockfile.buffers.X` that the installer's `&mut
         // Lockfile` would invalidate.
         // SAFETY: `mgr_ptr` is the provenance root; `lockfile` is heap-owned
-        // via `Box` (Zig: `*Lockfile`), so deref the Box for the heap addr.
+        // via `Box`, so deref the Box for the heap addr.
         // Each buffer lives at a fixed offset within it for the install pass —
         // wrap them as `BackRef` once under a single SAFETY obligation.
         let (lockfile_ptr, buf_trees, buf_hoisted, buf_deps, buf_strings): (
@@ -343,10 +339,7 @@ pub(crate) fn install_hoisted_packages(
             // so we want to make sure they're not accessible to the rest of this function
             // to make mistakes harder
             //
-            // PORT NOTE: BACKREF — Zig's `var parts = packages.slice()` is a
-            // by-value `MultiArrayList.Slice` (raw ptr+len per column), so
-            // `parts.items(.field)` yields independent `[]T` regardless of
-            // mutability. The `PackageInstaller` slice fields are
+            // BACKREF — the `PackageInstaller` slice fields are
             // `bun_ptr::RawSlice<T>` (raw `*const [T]`, no lifetime), so
             // wrapping each column with `RawSlice::new` stores the (ptr, len)
             // without keeping a borrow live — no `&'a → &'a` detach
@@ -374,7 +367,7 @@ pub(crate) fn install_hoisted_packages(
             let trusted_deps = this.find_trusted_dependencies_from_update_requests();
 
             // `PackageInstaller.{manager,lockfile,progress}` are BACKREF raw
-            // pointers (Zig: non-exclusive `*PM` / `*Lockfile`); copying
+            // pointers; copying
             // `mgr_ptr` into them does not move `this`, so the body below
             // keeps using `this` for `pending_task_count` / `run_tasks` /
             // lifecycle ticks via the same provenance root.
@@ -448,7 +441,6 @@ pub(crate) fn install_hoisted_packages(
             const UNROLL_COUNT: usize = 64 / core::mem::size_of::<PackageID>();
 
             while remaining.len() > UNROLL_COUNT {
-                // PERF(port): was `inline while` manual unroll — profile if hot.
                 let mut i: usize = 0;
                 while i < UNROLL_COUNT {
                     installer.install_package(remaining[i], log_level);
@@ -495,7 +487,7 @@ pub(crate) fn install_hoisted_packages(
             struct Closure<'a, 'b> {
                 installer: &'a mut PackageInstaller<'b>,
                 err: Option<bun_core::Error>,
-                // PORT NOTE: raw `*mut` (Zig `*PackageManager`) — `sleep_until`
+                // raw `*mut` — `sleep_until`
                 // also receives this pointer, so `&mut` here would alias.
                 manager: *mut PackageManager,
             }
@@ -541,7 +533,7 @@ pub(crate) fn install_hoisted_packages(
 
             // Derive the raw provenance root *before* building the closure so
             // both `sleep_until`'s `this` arg and `closure.manager` share the
-            // same SRW tag (Zig spec stores `*PackageManager` non-exclusively).
+            // same SRW tag.
             let mgr: *mut PackageManager = mgr_ptr;
             let mut closure = Closure {
                 installer: &mut installer,
@@ -562,14 +554,11 @@ pub(crate) fn install_hoisted_packages(
                 return Err(err);
             }
         }
-        // PORT NOTE: Zig `while ... else { ... }` — else runs when the condition becomes false (no break in body).
         this.tick_lifecycle_scripts();
         this.report_slow_lifecycle_scripts();
 
-        // PORT NOTE: reshaped for borrowck — Zig iterates `installer.trees`
-        // by value while calling `installer.installAvailablePackages` (which
-        // also touches `installer.trees`); index instead of `.iter()` so the
-        // immutable borrow doesn't overlap `&mut self`.
+        // Index instead of `.iter()` so the immutable borrow of
+        // `installer.trees` doesn't overlap `&mut self`.
         for tree_idx in 0..installer.trees.len() {
             if cfg!(debug_assertions) {
                 debug_assert!(installer.trees[tree_idx].pending_installs.len() == 0);
@@ -595,8 +584,7 @@ pub(crate) fn install_hoisted_packages(
             return Err(bun_core::err!("InstallFailed"));
         }
 
-        // PORT NOTE: Zig copies the bitset header (`summary.* = installer.*`);
-        // Rust moves. `replace` with a fresh empty so `installer` stays whole
+        // `replace` with a fresh empty so `installer` stays whole
         // for the `link_remaining_bins` / `complete_remaining_scripts` calls
         // below. Route through `installer.summary` because `summary` itself is
         // exclusively borrowed by `installer` for this scope.
@@ -631,5 +619,3 @@ pub(crate) fn install_hoisted_packages(
 
     Ok(summary)
 }
-
-// ported from: src/install/hoisted_install.zig
diff --git a/src/install/hosted_git_info.rs b/src/install/hosted_git_info.rs
index 1a535e9ae09..ec7713dcdd8 100644
--- a/src/install/hosted_git_info.rs
+++ b/src/install/hosted_git_info.rs
@@ -120,11 +120,10 @@ pub enum Representation {
 // HostedGitInfo
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: reshaped for borrowck. The Zig stores `committish`/`project`/`user`
-// as `[]const u8` slices that alias into `_memory_buffer` (a single owned
-// allocation). Rust can't express that self-reference safely without lifetimes
-// on the struct. We store byte ranges into `_memory_buffer` instead and expose
-// slice accessors.
+// `committish`/`project`/`user` conceptually alias into `_memory_buffer` (a
+// single owned allocation), but Rust can't express that self-reference safely
+// without lifetimes on the struct. Store byte ranges into `_memory_buffer`
+// instead and expose slice accessors.
 pub struct HostedGitInfo {
     committish: Option<Range<usize>>,
     project: Range<usize>,
@@ -160,7 +159,7 @@ impl HostedGitInfo {
     /// Therefore, we use this function to first take a URL string, encode it into a *jsc.URL and
     /// then decode it back to a normal string. Kind of a lot of work, but it works.
     ///
-    /// PORT NOTE: returns a `Range<usize>` into the StringBuilder's allocated buffer
+    /// Returns a `Range<usize>` into the StringBuilder's allocated buffer
     /// instead of a borrowed slice (see struct-level note).
     fn decode_and_append(
         sb: &mut StringBuilder,
@@ -168,8 +167,6 @@ impl HostedGitInfo {
     ) -> Result<Range<usize>, HostedGitInfoError> {
         let start = sb.len;
         let writable = sb.writable();
-        // PORT NOTE: Zig `PercentEncoding.decode(Writer, writer, input)` ported via the
-        // fixed-buffer `decode_into(out, input) -> Result<u32, _>` overload in bun_url.
         let decoded_len = PercentEncoding::decode_into(writable, input)
             .map_err(|_| HostedGitInfoError::InvalidURL)? as usize;
         sb.len += decoded_len;
@@ -236,22 +233,15 @@ impl HostedGitInfo {
         }
     }
 
-    // PORT NOTE: `pub fn deinit` → `impl Drop`. Body only freed `_memory_buffer`;
-    // `Box<[u8]>` drops automatically, so no explicit Drop impl is needed.
-
-    // PORT NOTE: `pub const toJS = @import("../install_jsc/...")` deleted —
     // `to_js` is an extension-trait method living in `bun_install_jsc`.
 
-    // PORT NOTE: `pub const StringPair` was a Zig-nested struct; hoisted to module
-    // scope below (Rust forbids struct defs inside `impl`).
-
     /// Given a URL-like (including shortcuts) string, parses it into a HostedGitInfo structure.
     /// The HostedGitInfo is valid only for as long as `git_url` is valid.
     pub fn from_url(git_url: &[u8]) -> Result<Option<Self>, HostedGitInfoError> {
         // git_url_mut may carry two ownership semantics:
         //  - It aliases `git_url`, in which case it must not be freed.
         //  - It actually points to a new allocation, in which case it must be freed.
-        // PORT NOTE: modeled as Cow-like local; Drop handles the owned case.
+        // Modeled as a Cow-like local; Drop handles the owned case.
         let git_url_owned: Option<Box<[u8]>>;
         let mut git_url_mut: &[u8] = git_url;
 
@@ -347,12 +337,9 @@ impl HostedGitInfo {
     }
 }
 
-// PORT NOTE: Zig nested `pub const StringPair = struct {...}` inside HostedGitInfo;
-// Rust can't nest struct defs inside `impl`, so it lives at module scope but is
-// re-exported through the type's namespace conceptually.
 pub struct StringPair {
-    // PORT NOTE: Zig `[]const u8` aliasing-semantics. No constructor in this module
-    // (consumed by install_jsc), so own the buffers — callers allocate per use.
+    // No constructor in this module (consumed by install_jsc), so own the
+    // buffers — callers allocate per use.
     pub save_spec: Box<[u8]>,
     pub fetch_spec: Option<Box<[u8]>>,
 }
@@ -380,8 +367,7 @@ impl Drop for OwnedJscUrl {
     }
 }
 
-// PORT NOTE: anonymous return struct in Zig → named struct here.
-// `url` is OWNED per LIFETIMES.tsv (jsc.URL.fromString creates; caller deinits).
+// `url` is owned: `jsc.URL.fromString` creates it and the holder deinits.
 pub struct ParsedUrl<'a> {
     pub url: OwnedJscUrl,
     pub proto: UrlProtocol<'a>,
@@ -451,8 +437,8 @@ pub enum WellDefinedProtocol {
 
 /// Buffer type for holding a protocol string with colon (e.g., "git+rsync:").
 /// Sized to hold the longest protocol name plus one character for the colon.
-// PORT NOTE: hoisted from `impl WellDefinedProtocol` — inherent associated types
-// are unstable (E0658).
+// Lives at module scope (not inside `impl WellDefinedProtocol`) because
+// inherent associated types are unstable (E0658).
 pub(crate) type StringWithColonBuffer = [u8; WellDefinedProtocol::MAX_PROTOCOL_LENGTH + 1];
 
 impl WellDefinedProtocol {
@@ -475,7 +461,6 @@ impl WellDefinedProtocol {
         b"ssh" => WellDefinedProtocol::Ssh,
     };
 
-    // PORT NOTE: Zig `strings.getKey(self)` did reverse lookup; provide explicit map.
     fn protocol_str(self) -> &'static [u8] {
         match self {
             Self::Bitbucket => b"bitbucket",
@@ -509,8 +494,8 @@ impl WellDefinedProtocol {
     }
 
     /// Maximum length of any protocol string in the strings map (computed at compile time).
-    // PORT NOTE: Zig computed this with a comptime loop over `strings.kvs`. The
-    // longest keys ("git+https", "git+rsync", "sourcehut", "bitbucket") are 9 bytes.
+    // The longest keys in `STRINGS` ("git+https", "git+rsync", "sourcehut",
+    // "bitbucket") are 9 bytes.
     pub(crate) const MAX_PROTOCOL_LENGTH: usize = 9;
 
     /// Get the protocol string with colon (e.g., "https:") for a given protocol enum.
@@ -631,8 +616,8 @@ pub(crate) fn is_github_shorthand(npa_str: &[u8]) -> bool {
             }
             _ => {
                 // Implement spaceOnlyAfterHash
-                // PORT NOTE: match Zig std.ascii.isWhitespace exactly (includes VT 0x0B and FF 0x0C;
-                // Rust u8::is_ascii_whitespace excludes VT).
+                // The whitespace set deliberately includes VT 0x0B and FF 0x0C;
+                // Rust's `u8::is_ascii_whitespace` excludes VT, so spell it out.
                 if matches!(c, b' ' | b'\t' | b'\n' | b'\r' | 0x0B | 0x0C) && pound_idx.is_none() {
                     return false;
                 }
@@ -655,8 +640,8 @@ pub(crate) fn is_github_shorthand(npa_str: &[u8]) -> bool {
 // UrlProtocol / UrlProtocolPair
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: Zig `union(enum) { custom: []const u8 }` borrowed the input `npa_str`.
-// Carries a BORROW_PARAM lifetime; lives only for the duration of `parse_url`.
+// The `Custom` variant borrows the input `npa_str`; this type lives only for
+// the duration of `parse_url`.
 #[derive(Debug, Clone, Copy)]
 pub enum UrlProtocol<'a> {
     WellFormed(WellDefinedProtocol),
@@ -679,8 +664,6 @@ impl<'a> UrlProtocol<'a> {
     }
 }
 
-// PORT NOTE: `url: union(enum) { managed: {buf, allocator}, unmanaged: []const u8 }`
-// → enum with `Managed(Box<[u8]>)` / `Unmanaged(&'a [u8])`. Allocator dropped.
 pub(crate) enum UrlProtocolPairUrl<'a> {
     Managed(Box<[u8]>),
     Unmanaged(&'a [u8]),
@@ -699,14 +682,11 @@ impl<'a> UrlProtocolPair<'a> {
         }
     }
 
-    // PORT NOTE: `deinit` → Drop; `Managed(Box<[u8]>)` frees automatically.
-
     /// Given a protocol pair, create a jsc.URL if possible. May allocate, but owns its memory.
     fn to_url(&self) -> Option<OwnedJscUrl> {
         // Ehhh.. Old IE's max path length was 2K so let's just use that. I searched for a
         // statistical distribution of URL lengths and found nothing.
         const _LONG_URL_THRESH: usize = 2048;
-        // PERF(port): was stack-fallback (std.heap.stackFallback) — profile if it shows up on a hot path
 
         let mut protocol_buf: StringWithColonBuffer =
             [0u8; WellDefinedProtocol::MAX_PROTOCOL_LENGTH + 1];
@@ -731,7 +711,7 @@ impl<'a> UrlProtocolPair<'a> {
 
     fn concat_parts_to_url(parts: &[&[u8]]) -> Option<OwnedJscUrl> {
         // TODO(markovejnovic): There is a sad unnecessary allocation here that I don't know how to
-        // get rid of -- in theory, URL.zig could allocate once.
+        // get rid of -- in theory, the URL layer could allocate once.
         let new_str = strings::concat(parts);
         // Drop handles `defer allocator.free(new_str)`.
         JscUrl::from_utf8(&new_str).map(OwnedJscUrl)
@@ -904,8 +884,8 @@ pub(crate) fn correct_url<'a>(
     }
 
     if col_idx == -1 && matches!(url_proto_pair.protocol, UrlProtocol::Unknown) {
-        // PORT NOTE: Zig copies `url_proto_pair.url` (a tagged union) by value. Here
-        // we know `normalize_protocol` only ever returns `Unmanaged`, so re-borrow.
+        // `normalize_protocol` only ever returns `Unmanaged` here, so re-borrow
+        // rather than move; the `Managed` arm clones for completeness.
         return Ok(UrlProtocolPair {
             url: match &url_proto_pair.url {
                 UrlProtocolPairUrl::Unmanaged(s) => UrlProtocolPairUrl::Unmanaged(s),
@@ -983,9 +963,7 @@ impl HostProvider {
     ///
     /// The second parameter allows you to declare whether the given string includes the protocol:
     /// colon or not.
-    // PERF(port): was comptime monomorphization — profile if it shows up on a hot path
     fn from_shortcut(shortcut_str: &[u8], with_colon: bool) -> Option<HostProvider> {
-        // PORT NOTE: Zig used `inline for (std.meta.fields(Self))` (comptime reflection).
         for provider in Self::ALL {
             let shortcut_matches = if with_colon {
                 provider.shortcut() == shortcut_str
@@ -1003,7 +981,6 @@ impl HostProvider {
 
     /// Find the appropriate host provider by its domain (e.g. "github.com").
     fn from_domain(domain_str: &[u8]) -> Option<HostProvider> {
-        // PORT NOTE: Zig used `inline for (std.meta.fields(Self))` (comptime reflection).
         Self::ALL
             .into_iter()
             .find(|&provider| provider.domain() == domain_str)
@@ -1024,7 +1001,6 @@ impl HostProvider {
     /// Given a URL, use the domain in the URL to find the appropriate host provider.
     fn from_url_domain(url: &JscUrl) -> Option<HostProvider> {
         const _MAX_HOSTNAME_LEN: usize = 253;
-        // PERF(port): was stack-fallback (FixedBufferAllocator) — profile if it shows up on a hot path
 
         let hostname_str = OwnedString::new(url.hostname());
 
@@ -1055,8 +1031,8 @@ pub struct Config {
     pub format_extract: formatters::extract::Type,
 }
 
-// PORT NOTE: `ExtractResult` corresponds to `Config.formatters.extract.Result`.
-// Reshaped to use `Range<usize>` into `_owned_buffer` (see HostedGitInfo note).
+// Uses `Range<usize>` into `_owned_buffer` rather than self-referential
+// slices (see the HostedGitInfo struct-level note).
 pub struct ExtractResult {
     pub user: Option<Range<usize>>,
     pub project: Range<usize>,
@@ -1065,8 +1041,6 @@ pub struct ExtractResult {
 }
 
 impl ExtractResult {
-    // PORT NOTE: `deinit` → Drop; `Option<Box<[u8]>>` frees automatically.
-
     /// Return the buffer which owns this Result and the allocator responsible for
     /// freeing it.
     ///
@@ -1399,9 +1373,8 @@ pub mod formatters {
                 }
             }
 
-            // PORT NOTE: in Zig the `committish` borrow from `fragment_utf8` is freed
-            // before being copied into the StringBuilder. We hold the owned fragment
-            // here to keep the borrow valid until copied.
+            // Hold the owned fragment here so the `committish` borrow stays
+            // valid until it's copied into the StringBuilder.
             let fragment_utf8;
             let committish: Option<&[u8]> = if type_part.is_none() {
                 let fragment_str = OwnedString::new(url.fragment_identifier());
@@ -1682,8 +1655,8 @@ pub mod formatters {
                 return Ok(None);
             };
 
-            // PORT NOTE: Zig inlines PercentEncoding.decode here instead of calling
-            // decodeAndAppend (returns null instead of erroring on decode failure).
+            // Inline percent-decode rather than `decode_and_append`: this path
+            // returns None instead of erroring on decode failure.
             let user_slice = 'blk: {
                 let start = sb.len;
                 let writable = sb.writable();
@@ -1798,11 +1771,10 @@ pub mod formatters {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// configs (std.enums.EnumArray)
+// configs
 // ──────────────────────────────────────────────────────────────────────────
 
-// PERF(port): was `std.enums.EnumArray(Self, Config).init(.{...})` (comptime
-// dense array indexed by enum). `enum_map::EnumMap` can't be const-initialized
+// `enum_map::EnumMap` can't be const-initialized
 // with fn pointers, so this uses a `OnceLock` static — flatten into a
 // `match`-based accessor if it shows up on a hot path.
 fn configs() -> &'static EnumMap<HostProvider, Config> {
@@ -1911,10 +1883,7 @@ fn configs() -> &'static EnumMap<HostProvider, Config> {
 // TestingAPIs
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE (layering): `pub const X = @import("../install_jsc/...")` aliases deleted —
-// `js_parse_url` / `js_from_url` live in `bun_install_jsc` (higher tier). Re-exporting
-// them here would re-introduce the install ↔ jsc cycle. Module kept as a marker so
-// Zig grep for `TestingAPIs` still lands here.
+// Layering: `js_parse_url` / `js_from_url` live in `bun_install_jsc` (higher
+// tier). Re-exporting them here would re-introduce the install ↔ jsc cycle.
+// Module kept as a marker for the original `TestingAPIs` namespace.
 pub mod testing_apis {}
-
-// ported from: src/install/hosted_git_info.zig
diff --git a/src/install/integrity.rs b/src/install/integrity.rs
index 9daf4fd081c..6e1b93fb58b 100644
--- a/src/install/integrity.rs
+++ b/src/install/integrity.rs
@@ -4,7 +4,7 @@ use bun_base64::zig_base64::STANDARD_NO_PAD as base64;
 use bun_core::strings;
 use bun_sha_hmac::sha as Crypto;
 
-// Digest lengths (bytes). Mirrors std.crypto.hash.* digest_length.
+// Digest lengths (bytes).
 const SHA1_DIGEST_LEN: usize = 20;
 const SHA256_DIGEST_LEN: usize = 32;
 const SHA384_DIGEST_LEN: usize = 48;
@@ -48,7 +48,6 @@ pub(crate) const DIGEST_BUF_LEN: usize = {
 };
 
 impl Integrity {
-    // TODO(port): narrow error set (Zig: `!Integrity` inferred — only error.InvalidCharacter)
     pub fn parse_sha_sum(buf: &[u8]) -> Result<Integrity, bun_core::Error> {
         if buf.is_empty() {
             return Ok(Integrity {
@@ -116,7 +115,7 @@ impl Integrity {
         }
 
         let input = {
-            // std.mem.trimRight(u8, buf[offset..], "=")
+            // trim trailing '=' padding
             let s = &buf[offset..];
             let mut end = s.len();
             while end > 0 && s[end - 1] == b'=' {
@@ -180,7 +179,6 @@ impl Integrity {
 
     #[inline]
     pub fn verify(&self, bytes: &[u8]) -> bool {
-        // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
         Self::verify_by_tag(self.tag, bytes, &self.value)
     }
 
@@ -255,10 +253,9 @@ impl fmt::Display for Integrity {
     }
 }
 
-// PORT NOTE: Zig `enum(u8) { ..., _ }` is non-exhaustive (any u8 is a valid bit
-// pattern, since this is read from on-disk lockfiles). A Rust `#[repr(u8)] enum`
-// would be UB for unknown discriminants, so we use a transparent newtype with
-// associated consts instead.
+// Any u8 must be a valid bit pattern, since this is read from on-disk
+// lockfiles. A `#[repr(u8)] enum` would be UB for unknown discriminants, so we
+// use a transparent newtype with associated consts instead.
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Tag(pub u8);
@@ -283,8 +280,6 @@ impl Tag {
     }
 
     pub fn parse(buf: &[u8]) -> (Tag, usize) {
-        // PORT NOTE: Zig used strings.ExactSizeMatcher(8); a byte-slice match is
-        // equivalent and const-propagated.
         let Some(i) = strings::index_of_char(&buf[0..buf.len().min(7)], b'-') else {
             return (Tag::UNKNOWN, 0);
         };
@@ -436,7 +431,7 @@ impl Streaming {
     }
 }
 
-// Zig had a `comptime` block asserting Integrity::default().value is all-zero.
+// Assert Integrity::default().value is all-zero.
 const _: () = {
     let buf = EMPTY_DIGEST_BUF;
     let mut i = 0;
@@ -445,5 +440,3 @@ const _: () = {
         i += 1;
     }
 };
-
-// ported from: src/install/integrity.zig
diff --git a/src/install/isolated_install.rs b/src/install/isolated_install.rs
index 18efbceff8d..40d22bd7e0b 100644
--- a/src/install/isolated_install.rs
+++ b/src/install/isolated_install.rs
@@ -1,6 +1,6 @@
 // ───────────────────────────────────────────────────────────────────────────
-// Submodules — Zig basenames preserved per PORTING.md, hence #[path] attrs.
-// These are the install-to-disk primitives the Installer state machine drives.
+// Submodules — these are the install-to-disk primitives the Installer state
+// machine drives.
 // ───────────────────────────────────────────────────────────────────────────
 #[path = "isolated_install/FileCloner.rs"]
 pub mod file_cloner;
@@ -57,8 +57,7 @@ bun_output::define_scoped_log!(log, IsolatedInstall, visible);
 
 // ───────────────────────────────────────────────────────────────────────────
 // Inner helper types (hoisted from fn body — Rust does not allow local
-// struct decls that borrow outer locals via closures the same way; field
-// order matches the Zig declarations).
+// struct decls that borrow outer locals via closures the same way).
 // ───────────────────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy)]
@@ -133,10 +132,8 @@ impl<'a> std::io::Write for WyhashWriter<'a> {
     }
 }
 
-/// `RunTasksCallbacks` impl for the isolated-install loop. Mirrors the Zig
-/// anonymous-struct call shape `{ .onExtract = onPackageExtracted, .onResolve = {},
-/// .onPackageManifestError = {}, .onPackageDownloadError = onPackageDownloadError,
-/// .progress_bar = false, .manifests_only = false }` with `Ctx == *Store.Installer`.
+/// `RunTasksCallbacks` impl for the isolated-install loop, with
+/// `Ctx == store::Installer`.
 pub(crate) struct StoreRunTasksCallbacks<'a>(core::marker::PhantomData<&'a mut ()>);
 
 impl<'a> run_tasks::RunTasksCallbacks for StoreRunTasksCallbacks<'a> {
@@ -226,9 +223,8 @@ pub(crate) fn install_isolated_packages(
 ) -> Result<crate::package_install::Summary, AllocError> {
     analytics::features::isolated_bun_install.fetch_add(1, Ordering::Relaxed);
 
-    // PORT NOTE: reshaped for borrowck — Zig holds `*Lockfile` while also
-    // passing `*PackageManager` (which owns it); take a raw pointer so column
-    // borrows below don't tie up `&mut manager`.
+    // Take a raw pointer so column borrows below don't tie up `&mut manager`
+    // (which owns the lockfile).
     let lockfile: *mut Lockfile = &raw mut *manager.lockfile;
     // SAFETY: `lockfile` was just derived from `&raw mut *manager.lockfile`;
     // `manager` outlives this function and no other `&mut Lockfile` is formed
@@ -418,8 +414,7 @@ pub(crate) fn install_isolated_packages(
             'check_cycle: {
                 // check for cycles
                 let mut nodes_slice = nodes.slice();
-                // PORT NOTE: Zig grabbed multiple mutable column views from one
-                // Slice; `split_mut()` yields disjoint `&mut [_]` per column.
+                // `split_mut()` yields disjoint `&mut [_]` per column.
                 let store::node::NodeColumnsMut {
                     pkg_id: node_pkg_ids,
                     dep_id: node_dep_ids,
@@ -438,7 +433,6 @@ pub(crate) fn install_isolated_packages(
                         if dep_id == invalid_dependency_id && entry.dep_id == invalid_dependency_id
                         {
                             node_nodes[entry.parent_id.get() as usize].push(curr_id);
-                            // PERF(port): was appendAssumeCapacity — profile if hot.
                             continue 'next_node;
                         }
 
@@ -460,7 +454,6 @@ pub(crate) fn install_isolated_packages(
                             curr_dep.behavior.is_workspace() == entry_dep.behavior.is_workspace()
                         {
                             node_nodes[entry.parent_id.get() as usize].push(curr_id);
-                            // PERF(port): was appendAssumeCapacity — profile if hot.
                             continue 'next_node;
                         }
                     }
@@ -493,7 +486,7 @@ pub(crate) fn install_isolated_packages(
 
                 'dont_dedupe: {
                     let mut nodes_slice = nodes.slice();
-                    // PORT NOTE: disjoint-column views via `split_mut`.
+                    // disjoint-column views via `split_mut`.
                     let store::node::NodeColumnsMut {
                         nodes: node_nodes,
                         dep_id: node_dep_ids,
@@ -594,7 +587,7 @@ pub(crate) fn install_isolated_packages(
                             string_buf,
                             pkg_names,
                         };
-                        // PORT NOTE: reshaped for borrowck — clone the dedupe peers slice
+                        // Reshaped for borrowck — clone the dedupe peers slice
                         // before mutating node_peers.
                         let dedupe_peers: Vec<_> =
                             node_peers[dedupe_node_id.get() as usize].list.clone();
@@ -614,7 +607,6 @@ pub(crate) fn install_isolated_packages(
                         }
 
                         node_nodes[entry.parent_id.get() as usize].push(dedupe_node_id);
-                        // PERF(port): was appendAssumeCapacity — profile if hot.
                         continue 'next_node;
                     }
 
@@ -640,7 +632,7 @@ pub(crate) fn install_isolated_packages(
             })?;
 
             let mut nodes_slice = nodes.slice();
-            // PORT NOTE: disjoint-column views via `split_mut`.
+            // disjoint-column views via `split_mut`.
             let store::node::NodeColumnsMut {
                 parent_id: node_parent_ids,
                 dependencies: node_dependencies,
@@ -651,7 +643,6 @@ pub(crate) fn install_isolated_packages(
 
             if let Some(parent_id) = entry.parent_id.try_get() {
                 node_nodes[parent_id as usize].push(node_id);
-                // PERF(port): was appendAssumeCapacity — profile if hot.
             }
 
             if skip_dependencies {
@@ -665,7 +656,6 @@ pub(crate) fn install_isolated_packages(
             for _dep_id in pkg_deps.begin()..pkg_deps.end() {
                 let dep_id: DependencyID = _dep_id;
                 dep_ids_sort_buf.push(dep_id);
-                // PERF(port): was appendAssumeCapacity — profile if hot.
             }
 
             // TODO: make this sort in an order that allows peers to be resolved last
@@ -699,7 +689,6 @@ pub(crate) fn install_isolated_packages(
                                 if package_to_install == pkg_id {
                                     node_dependencies[node_id.get() as usize]
                                         .push(store::node::DependencyIds { dep_id, pkg_id });
-                                    // PERF(port): was appendAssumeCapacity — profile if hot.
                                     node_queue.push(QueuedNode {
                                         parent_id: node_id,
                                         dep_id,
@@ -738,7 +727,6 @@ pub(crate) fn install_isolated_packages(
                         // - queue it
                         node_dependencies[node_id.get() as usize]
                             .push(store::node::DependencyIds { dep_id, pkg_id });
-                        // PERF(port): was appendAssumeCapacity — profile if hot.
                         node_queue.push(QueuedNode {
                             parent_id: node_id,
                             dep_id,
@@ -877,7 +865,6 @@ pub(crate) fn install_isolated_packages(
                         dep_id: peer_dep_id,
                         pkg_id: resolved_pkg_id,
                     });
-                    // PERF(port): was appendAssumeCapacity — profile if hot.
                     node_queue.push(QueuedNode {
                         parent_id: node_id,
                         dep_id: peer_dep_id,
@@ -967,7 +954,7 @@ pub(crate) fn install_isolated_packages(
                         // dedupe! depend on the already created entry
 
                         let mut entries = store_entries.slice();
-                        // PORT NOTE: disjoint-column views via `split_mut`.
+                        // disjoint-column views via `split_mut`.
                         let store::entry::EntryColumnsMut {
                             dependencies: entry_dependencies,
                             parents: entry_parents,
@@ -1166,7 +1153,7 @@ pub(crate) fn install_isolated_packages(
     let global_store_path: Option<Vec<u8>> = if manager.options.enable.global_virtual_store() {
         'global_store_path: {
             let mut entries = store.entries.slice();
-            // PORT NOTE: disjoint-column views via `split_mut`.
+            // disjoint-column views via `split_mut`.
             let store::entry::EntryColumnsMut {
                 entry_hash: entry_hashes,
                 node_id: entry_node_ids,
@@ -1214,7 +1201,7 @@ pub(crate) fn install_isolated_packages(
 
                 while !stack.is_empty() {
                     let top_idx = stack.len() - 1;
-                    // PORT NOTE: reshaped for borrowck — re-borrow `top` after each
+                    // Reshaped for borrowck — re-borrow `top` after each
                     // potential `stack.push()` realloc.
                     let id = stack[top_idx].id;
                     let idx = id.get() as usize;
@@ -1487,7 +1474,7 @@ pub(crate) fn install_isolated_packages(
                                 }
                                 unreachable!();
                             };
-                            // PORT NOTE: reshaped for borrowck — copy members to
+                            // Reshaped for borrowck — copy members to
                             // avoid holding a borrow into scc_stack while mutating.
                             let members: Vec<u32> = scc_stack[start..].to_vec();
                             for &m in &members {
@@ -1663,8 +1650,7 @@ pub(crate) fn install_isolated_packages(
             if cache_dir_path.is_empty() {
                 break 'global_store_path None;
             }
-            // PORT NOTE: Zig allocated a `[:0]u8` via `joinAbsStringBufZ`; here
-            // we own a Vec<u8> with a trailing NUL so it can be re-borrowed as
+            // Own a Vec<u8> with a trailing NUL so it can be re-borrowed as
             // a `&ZStr` for `Installer.global_store_path` below.
             let joined = paths::resolve_path::join_abs_string::<paths::platform::Auto>(
                 cache_dir_path,
@@ -1681,12 +1667,11 @@ pub(crate) fn install_isolated_packages(
 
     // setup node_modules/.bun
     let is_new_bun_modules: bool = 'is_new_bun_modules: {
-        // Zig: `bun.OSPathLiteral(...)` — but `sys::mkdirat` is `&ZStr`-only
-        // (it widens to NT path internally on Windows), so use `path_literal!`
-        // here to keep the call-site cross-platform without a `&WStr` overload.
+        // `sys::mkdirat` is `&ZStr`-only (it widens to NT path internally on
+        // Windows), so use `path_literal!` here to keep the call-site
+        // cross-platform without a `&WStr` overload.
         let node_modules_path = paths::path_literal!("node_modules");
-        // Zig: `bun.OSPathLiteral("node_modules/" ++ Store.modules_dir_name)`.
-        // Rust `concat!` can't take a `&[u8]` const, so spell the literal —
+        // `concat!` can't take a `&[u8]` const, so spell the literal —
         // matches `Installer::NODE_MODULES_BUN`.
         let bun_modules_path = paths::path_literal!("node_modules/.bun");
 
@@ -1709,11 +1694,9 @@ pub(crate) fn install_isolated_packages(
                     // 2. for each entry in 'node_modules' rename into 'node_modules/.old_modules-{hex}'
                     // 3. for each workspace 'node_modules' rename into 'node_modules/.old_modules-{hex}/old_{basename}_modules'
 
-                    // PORT NOTE: Zig builds a separate `RelPath(.{.unit=.u16})`
-                    // for `mkdirat` because Zig's `sys.mkdirat` on Windows takes
-                    // `[:0]const u16`. The Rust `sys::mkdirat`/`renameat` take
-                    // `&ZStr` (u8) and widen internally, so a single u8
-                    // `AutoRelPath` covers both the mkdir and rename targets.
+                    // `sys::mkdirat`/`renameat` take `&ZStr` (u8) and widen
+                    // internally, so a single u8 `AutoRelPath` covers both the
+                    // mkdir and rename targets.
                     let mut rename_path = AutoRelPath::from(b"node_modules").assume_ok();
                     let rand = fast_random();
                     rename_path
@@ -1733,10 +1716,8 @@ pub(crate) fn install_isolated_packages(
                         break 'is_new_bun_modules true;
                     };
                     // Windows HANDLE-leak audit: `Fd` is `Copy` (no Drop) and the
-                    // `WrappedIterator` from `sys::iterate_dir` does not own/close it.
-                    // The Zig spec (isolated_install.zig:1299) likewise lacks a
-                    // `defer node_modules.close()`, so this leak is pre-existing in
-                    // the spec — fixed in both per the audit. The guard fires on
+                    // `WrappedIterator` from `sys::iterate_dir` does not own/close it,
+                    // so close explicitly. The guard fires on
                     // normal fall-through to step 3 and on every
                     // `break 'is_new_bun_modules true` early exit.
                     let _close_node_modules = scopeguard::guard(node_modules, |fd| {
@@ -1759,8 +1740,7 @@ pub(crate) fn install_isolated_packages(
                             continue;
                         }
 
-                        // PORT NOTE: reshaped for borrowck — Zig `save()/restore()`
-                        // holds `*Path`; capture lengths and truncate manually so
+                        // Capture lengths and truncate manually so
                         // the paths stay unborrowed across the loop body.
                         let entry_path_save = entry_path.len();
                         entry_path.append(entry.name.slice()).assume_ok();
@@ -1785,14 +1765,13 @@ pub(crate) fn install_isolated_packages(
                             AutoRelPath::from(workspace_path.slice(&lockfile.buffers.string_bytes))
                                 .assume_ok();
 
-                        // PORT NOTE: reshaped for borrowck — clone basename before
-                        // mutating `workspace_node_modules` (Zig held a slice into
-                        // the buffer across an append-with-separator).
+                        // Clone basename before mutating
+                        // `workspace_node_modules`.
                         let basename = workspace_node_modules.basename().to_vec();
 
                         workspace_node_modules.append(b"node_modules").assume_ok();
 
-                        // PORT NOTE: reshaped for borrowck — capture length instead
+                        // Reshaped for borrowck — capture length instead
                         // of `save()` so `rename_path` stays unborrowed.
                         let rename_path_save = rename_path.len();
                         rename_path
@@ -1896,15 +1875,13 @@ pub(crate) fn install_isolated_packages(
                             AutoRelPath::from(workspace_path.slice(&lockfile.buffers.string_bytes))
                                 .assume_ok();
 
-                        // PORT NOTE: reshaped for borrowck — clone basename before
-                        // mutating `workspace_node_modules` (Zig held a slice into
-                        // the buffer across an append-with-separator).
+                        // Clone basename before mutating
+                        // `workspace_node_modules`.
                         let basename = workspace_node_modules.basename().to_vec();
 
                         workspace_node_modules.append(b"node_modules").assume_ok();
 
-                        // PORT NOTE: reshaped for borrowck — Zig `save()/restore()`
-                        // holds a `*Path`; capture the length and truncate manually
+                        // Capture the length and truncate manually
                         // so `rename_path` stays unborrowed between save/restore.
                         let rename_path_save = rename_path.len();
 
@@ -1940,15 +1917,14 @@ pub(crate) fn install_isolated_packages(
     };
 
     {
-        // TODO(port): Progress.Node locals are conditionally initialized in Zig;
-        // model with Option.
+        // Conditionally initialized (only when progress is shown); definite-
+        // initialization analysis guarantees no use before assignment.
         let mut download_node: ProgressNode;
         let mut install_node: ProgressNode = ProgressNode::default();
         let mut scripts_node: ProgressNode;
         let progress: *mut Progress = &raw mut manager.progress;
         // SAFETY: `progress` aliases `manager.progress`; reborrows below are
-        // disjoint from the other `manager.*` field accesses (Zig holds the
-        // same two pointers freely).
+        // disjoint from the other `manager.*` field accesses.
         let progress = unsafe { &mut *progress };
 
         if manager.options.log_level.show_progress() {
@@ -1977,8 +1953,7 @@ pub(crate) fn install_isolated_packages(
         let entry_dependencies = entries.items_dependencies();
         let entry_hoisted = entries.items_hoisted();
 
-        // PORT NOTE: reshaped for borrowck — Zig holds `*Lockfile` (mut) while
-        // also keeping immutable column slices into it. Reborrow through a
+        // Reborrow through a
         // `BackRef` so `string_buf` / `pkgs` don't tie up `&mut lockfile` for
         // the `Installer { lockfile, .. }` move below. `BackRef` is the
         // canonical non-owning back-pointer wrapper; the lockfile lives for
@@ -2002,9 +1977,6 @@ pub(crate) fn install_isolated_packages(
         // TODO: delete
         let mut seen_workspace_ids: HashMap<PackageID, ()> = HashMap::default();
 
-        // PORT NOTE: reshaped — Zig does `allocator.alloc(Task, n)` then
-        // `task.* = .{..}` in-place, which is safe because Zig has no drop
-        // glue and no validity invariants on uninit memory. In Rust,
         // `installer::Task` carries `result: Result` (Drop via `TaskError`
         // payloads) and a non-nullable fn-ptr in `thread_pool::Task`, so
         // `assume_init()` on uninit memory is instant UB and a subsequent
@@ -2086,8 +2058,7 @@ pub(crate) fn install_isolated_packages(
         // per-statement instead.
         // (Drop handles installer.deinit())
 
-        // PORT NOTE: reshaped for borrowck — Zig writes `installer: &installer`
-        // into `installer.tasks[i]`; in Rust the back-pointer is taken before
+        // The back-pointer is taken before
         // the `tasks` borrow. `Task.installer` is typed
         // `BackRef<Installer<'static>>` (raw back-ref, no real `'static` data),
         // so erase the lifetime via a void-pointer cast — `*mut T` is invariant
@@ -2100,12 +2071,11 @@ pub(crate) fn install_isolated_packages(
             task.installer = installer_backref;
         }
 
-        // PORT NOTE: hoisted — Zig lazily calls `globalLinkDirPath()` inside
-        // `appendStorePath` (worker threads, via `*const Installer`). Rust
-        // can't take `&mut PackageManager` from `&self` there, so ensure the
+        // `append_store_path` runs on worker threads via `&Installer` and
+        // can't take `&mut PackageManager` there, so ensure the
         // global link dir once on the main thread before any `.symlink`
         // resolution can be reached by a task. Guarded so installs without
-        // `link:` deps don't touch the global dir (matches Zig laziness).
+        // `link:` deps don't touch the global dir.
         if pkg_resolutions
             .iter()
             .any(|r| r.tag == ResolutionTag::Symlink)
@@ -2212,10 +2182,9 @@ pub(crate) fn install_isolated_packages(
                 | ResolutionTag::Github
                 | ResolutionTag::LocalTarball
                 | ResolutionTag::RemoteTarball => {
-                    // PORT NOTE: Zig used `inline ... => |pkg_res_tag|` to monomorphize the
-                    // body per-tag. Rust collapses to a single arm with a runtime
-                    // `pkg_res.tag` re-match where the body branches. // PERF(port): was
-                    // comptime monomorphization — profile if hot.
+                    // A single arm with a runtime `pkg_res.tag` re-match where
+                    // the body branches. // PERF: could monomorphize per-tag —
+                    // profile if hot.
                     let pkg_res_tag = pkg_res.tag;
 
                     let patch_info =
@@ -2282,8 +2251,7 @@ pub(crate) fn install_isolated_packages(
                                     .unwrap_or(false);
                             }
                             installer.append_real_store_path(&mut store_path, entry_id, installer::Which::Final);
-                            // PORT NOTE: reshaped for borrowck — Zig `save()` returns a
-                            // `ResetScope` holding `*Path`; capture the length instead so
+                            // Capture the length instead of a `ResetScope` so
                             // `store_path` stays unborrowed.
                             let scope_for_patch_tag_path = store_path.len();
                             if pkg_res_tag == ResolutionTag::Npm {
@@ -2375,7 +2343,7 @@ pub(crate) fn install_isolated_packages(
 
                     let (cache_dir, cache_dir_path) =
                         installer.manager_mut().get_cache_directory_and_abs_path();
-                    let _ = &cache_dir_path; // dropped at scope exit (Zig: defer cache_dir_path.deinit())
+                    let _ = &cache_dir_path; // dropped at scope exit
 
                     let missing_from_cache = match installer.manager().get_preinstall_state(pkg_id)
                     {
@@ -2384,7 +2352,7 @@ pub(crate) fn install_isolated_packages(
                             if matches!(patch_info, installer::PatchInfo::None) {
                                 let exists = match pkg_res_tag {
                                     ResolutionTag::Npm => {
-                                        // PORT NOTE: reshaped for borrowck — capture length
+                                        // Reshaped for borrowck — capture length
                                         // instead of `save()` so the path stays unborrowed.
                                         let cache_dir_path_save = pkg_cache_dir_subpath.len();
                                         pkg_cache_dir_subpath.append(b"package.json").assume_ok();
@@ -2488,10 +2456,9 @@ pub(crate) fn install_isolated_packages(
                             );
                         }
                         ResolutionTag::Github => {
-                            // Zig (isolated_install.zig:1759) reads `pkg_res.value.git` here as
-                            // a raw union pun (`git`/`github` arms share `Repository` layout);
-                            // Rust's `.git()` accessor adds a `debug_assert_eq!(tag, Git)` that
-                            // fires under `Github`, so use the tag-correct `.github()` instead.
+                            // The `.git()` accessor has a `debug_assert_eq!(tag, Git)` that
+                            // fires under `Github`, so use the tag-correct `.github()`
+                            // (the two arms share `Repository` layout).
                             let url = installer.manager().alloc_github_url(pkg_res.github());
                             // (Drop frees url)
                             match installer.manager_mut().enqueue_tarball_for_download(
@@ -2677,5 +2644,3 @@ pub(crate) fn install_isolated_packages(
 
 use crate::dependency::VersionTag;
 use crate::resolution::Tag as ResolutionTag;
-
-// ported from: src/install/isolated_install.zig
diff --git a/src/install/isolated_install/FileCloner.rs b/src/install/isolated_install/FileCloner.rs
index d2bfcbcbd2f..5009b59cbc8 100644
--- a/src/install/isolated_install/FileCloner.rs
+++ b/src/install/isolated_install/FileCloner.rs
@@ -4,15 +4,15 @@ use bun_sys::{self as sys, Errno, Fd, FdDirExt, FdExt};
 
 // macOS clonefileat only
 
-// PORT NOTE: reshaped — Zig owns `cache_dir_subpath: bun.AutoRelPath` by struct
-// copy; Rust borrows mutably so the caller's path survives a clonefile→hardlink
-// fallback (`continue 'backend` in `Installer::Task::run`). The borrow must be
-// `&mut` because `Path::slice_z` writes the NUL terminator into the pooled buf.
+// `cache_dir_subpath` is borrowed mutably (rather than owned) so the caller's
+// path survives a clonefile→hardlink fallback (`continue 'backend` in
+// `Installer::Task::run`). The borrow must be `&mut` because `Path::slice_z`
+// writes the NUL terminator into the pooled buf.
 #[allow(dead_code)]
 pub(crate) struct FileCloner<'a> {
     pub cache_dir: Fd,
     pub cache_dir_subpath: &'a mut AutoRelPath,
-    /// `bun.Path(.{ .sep = .auto, .unit = .os })` — `.unit = .os` is `u8` on
+    /// The OS path unit is `u8` on
     /// macOS (the only platform `clonefileat` exists on), so the unit param is
     /// spelled `u8` to keep this module compiling on Windows where `OSPathChar`
     /// would be `u16` and `slice_z()` would yield a `WStr`.
@@ -59,5 +59,3 @@ impl FileCloner<'_> {
         }
     }
 }
-
-// ported from: src/install/isolated_install/FileCloner.zig
diff --git a/src/install/isolated_install/FileCopier.rs b/src/install/isolated_install/FileCopier.rs
index e5d4a6cdca7..a923af4d93c 100644
--- a/src/install/isolated_install/FileCopier.rs
+++ b/src/install/isolated_install/FileCopier.rs
@@ -8,10 +8,9 @@ use bun_core::{Global, fmt as bun_fmt};
 use bun_paths::{self, OSPathChar, OSPathSlice};
 use bun_sys::{self as sys, Dir, E, EntryKind, Fd, walker_skippable, walker_skippable::Walker};
 
-// `bun.AbsPath(.{ .sep = .auto, .unit = .os })` / `bun.Path(...)` are
-// comptime-configured path-builder types. `.unit = .os` means u8 on POSIX,
+// The path-builder types here use the OS path unit: u8 on POSIX,
 // u16 on Windows — encoded via `OSPathChar` so `slice()`/`slice_z()` produce
-// the platform-native width. `.sep = .auto` normalizes `/` → `\` on Windows
+// the platform-native width. The auto separator mode normalizes `/` → `\` on Windows
 // during `from`/`append`, which is load-bearing for the Win32 calls below.
 type AbsPathAutoOs =
     bun_paths::AbsPath<OSPathChar, { bun_paths::path_options::PathSeparators::AUTO }>;
@@ -50,15 +49,13 @@ impl FileCopier {
         })
     }
 
-    // Zig `deinit` only called `this.walker.deinit()`; `Walker` owns its
-    // resources and drops automatically, so no explicit `Drop` impl is needed.
+    // `Walker` owns its resources and drops automatically, so no explicit
+    // `Drop` impl is needed.
 
     pub fn copy(&mut self) -> sys::Result<()> {
-        // Zig: `bun.MakePath.makeOpenPath(FD.cwd().stdDir(), this.dest_subpath.sliceZ(), .{})`.
         // `make_open_path` is u8-only; on Windows the OS-unit path is u16 so
         // narrow it via the same infallible `from_w_path` transcode that
-        // `bun_sys::make_path_w` uses (bun.zig:2319). Zig stays in u16 the
-        // whole way and has no error path here, so don't synthesise EINVAL on
+        // `bun_sys::make_path_w` uses. Don't synthesise EINVAL on
         // conversion — store paths are built from UTF-8 package names and are
         // always WTF-8 round-trippable. On POSIX `OSPathChar == u8` and
         // `slice_z()` already yields `&ZStr`, so deref-coerce to `&[u8]`.
@@ -79,7 +76,7 @@ impl FileCopier {
             Err(e) => {
                 // TODO: remove the need for this and implement openDir makePath makeOpenPath in bun
                 let errno: E = {
-                    // `@as(anyerror, err)` → match against interned bun_core::Error tags.
+                    // Match against interned bun_core::Error tags.
                     let e: Error = e;
                     if e == err!("AccessDenied") {
                         E::EPERM
@@ -153,12 +150,10 @@ impl FileCopier {
                     _ => continue,
                 }
 
-                // PORT NOTE: reshaped for borrowck — Zig's `var s = path.save();
-                // defer s.restore();` returns a `ResetScope` that holds
-                // `&mut Path`, which would keep `self.src_path` /
-                // `self.dest_subpath` exclusively borrowed for the rest of the
-                // iteration. Capture the saved length and restore via
-                // `set_length` after the body.
+                // A `path.save()` ResetScope would hold `&mut Path` and keep
+                // `self.src_path` / `self.dest_subpath` exclusively borrowed
+                // for the rest of the iteration. Capture the saved length and
+                // restore via `set_length` after the body instead.
                 let src_saved_len = self.src_path.len();
                 let _ = self.src_path.append(entry.path.as_slice());
 
@@ -293,5 +288,3 @@ impl FileCopier {
         sys::Result::Ok(())
     }
 }
-
-// ported from: src/install/isolated_install/FileCopier.zig
diff --git a/src/install/isolated_install/Hardlinker.rs b/src/install/isolated_install/Hardlinker.rs
index 5decd6898f6..ffe891fbeac 100644
--- a/src/install/isolated_install/Hardlinker.rs
+++ b/src/install/isolated_install/Hardlinker.rs
@@ -3,8 +3,7 @@ use bun_alloc::AllocError;
 use bun_sys::FdDirExt;
 use bun_sys::walker_skippable::Walker;
 use bun_sys::{self as sys, EntryKind, Fd, FdExt};
-// `bun.AbsPath(.{ .sep = .auto, .unit = .os })` / `bun.Path(.{ .sep = .auto, .unit = .os })`
-// take a comptime config struct in Zig. `.unit = .os` means u8 on POSIX, u16
+// OS-unit paths are u8 on POSIX, u16
 // on Windows — encoded here via the `OSPathChar` type alias so the struct's
 // `slice()`/`slice_z()` produce the platform-native width without per-field
 // `#[cfg]` divergence.
@@ -63,10 +62,7 @@ impl Hardlinker {
         #[cfg(windows)]
         {
             let mut cwd_buf = bun_paths::w_path_buffer_pool::get();
-            // PORT NOTE: Zig spelt `FD.cwd().getFdPathW(buf)`; the Rust `Fd`
-            // newtype lives in `bun_core` and has no sys-layer methods, so call
-            // the free fn.
-            // PORT NOTE: `get_fd_path_w` writes the raw `\\?\C:\...` result into
+            // `get_fd_path_w` writes the raw `\\?\C:\...` result into
             // `cwd_buf` and returns a SUB-SLICE (offset 4, or 6 for UNC) after
             // stripping the long-path prefix. We can't keep that slice borrowed
             // across the loop (borrowck vs `cwd_buf`), so capture both its start
@@ -101,16 +97,15 @@ impl Hardlinker {
                     sys::Result::Err(err) => return Ok(sys::Result::Err(err)),
                 };
 
-                // PORT NOTE: reshaped for borrowck — Zig's `var s = path.save();
-                // defer s.restore();` returns a `ResetScope` that holds `&mut Path`,
-                // which would keep `self.src`/`self.dest` exclusively borrowed for
-                // the rest of the iteration. Capture the saved length directly and
-                // restore via `set_length` after the body (and before any error
-                // return) so the truncation happens on every exit, matching `defer`.
+                // A `path.save()` ResetScope would hold `&mut Path` and keep
+                // `self.src`/`self.dest` exclusively borrowed for the rest of
+                // the iteration. Capture the saved length directly and restore
+                // via `set_length` after the body (and before any error return)
+                // so the truncation happens on every exit.
                 let src_saved_len = self.src.len();
                 // `OsAbsPath`/`OsPath` use `CheckLength::ASSUME`, so `append`'s
-                // `Err(MaxPathExceeded)` arm is statically unreachable (Zig returns
-                // `void` here) -- see `path_options::AssumeOk`.
+                // `Err(MaxPathExceeded)` arm is statically unreachable -- see
+                // `path_options::AssumeOk`.
                 self.src.append(entry.path.as_slice()).assume_ok();
 
                 let dest_saved_len = self.dest.len();
@@ -130,11 +125,8 @@ impl Hardlinker {
                             // `dest` may already be absolute (global virtual store
                             // entries live under the cache, not cwd); only prefix the
                             // working-directory path when it's project-relative.
-                            // PORT NOTE: borrowck — Zig held both `dest_cwd` and
-                            // `self.dest.slice()` simultaneously; here `dest_cwd`
-                            // borrows `cwd_buf` and `self.dest.slice()` borrows
-                            // `self`, which is fine, but stash the dest slice once
-                            // so the borrow doesn't span the buffer-mut below.
+                            // Stash the dest slice once so the `&self` borrow
+                            // doesn't span the buffer-mut below.
                             let dest_slice: &[u16] = self.dest.slice();
                             let dest_parts: &[&[u16]] = if !dest_slice.is_empty()
                                 && bun_paths::Platform::Windows.is_absolute_t::<u16>(dest_slice)
@@ -156,9 +148,6 @@ impl Hardlinker {
                                 joined,
                             );
 
-                            // Zig allocated `srcfile_path_buf` here but never used it;
-                            // dropped in the port (dead code in the original).
-
                             match sys::link_w(self.src.slice_z(), destfile_path) {
                                 sys::Result::Ok(()) => {}
                                 sys::Result::Err(link_err1) => match link_err1.get_errno() {
@@ -254,13 +243,12 @@ impl Hardlinker {
                     sys::Result::Err(err) => return Ok(sys::Result::Err(err)),
                 };
 
-                // PORT NOTE: reshaped for borrowck — Zig's `var s = dest.save();
-                // defer s.restore();` returns a `ResetScope` holding `&mut Path`,
-                // which would keep `self.dest` exclusively borrowed across the
-                // body. Capture `len()` and restore via `set_length()` after the
-                // body so the truncation runs on every exit, matching `defer`.
+                // A `dest.save()` ResetScope would hold `&mut Path` and keep
+                // `self.dest` exclusively borrowed across the body. Capture
+                // `len()` and restore via `set_length()` after the body so the
+                // truncation runs on every exit.
                 let dest_saved_len = self.dest.len();
-                let _ = self.dest.append(entry.path.as_bytes()); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = self.dest.append(entry.path.as_bytes()); // OOM/capacity: fire-and-forget
 
                 let err: Option<sys::Error> = 'body: {
                     match entry.kind {
@@ -328,5 +316,3 @@ impl Hardlinker {
         }
     }
 }
-
-// ported from: src/install/isolated_install/Hardlinker.zig
diff --git a/src/install/isolated_install/Installer.rs b/src/install/isolated_install/Installer.rs
index 6f30c3c8d04..3240437bca3 100644
--- a/src/install/isolated_install/Installer.rs
+++ b/src/install/isolated_install/Installer.rs
@@ -25,7 +25,7 @@ use crate::{
     Resolution, TaskCallbackContext, TruncatedPackageNameHash, bin, invalid_dependency_id,
 };
 // Bring `items_<field>()` column accessors into scope for
-// `MultiArrayList<Package>` / `Slice<Package>` (Zig: `.items(.field)`).
+// `MultiArrayList<Package>` / `Slice<Package>`.
 #[cfg(target_os = "macos")]
 use super::file_cloner::FileCloner;
 use super::file_copier::FileCopier;
@@ -38,30 +38,24 @@ use crate::lockfile_real::package::PackageColumns as _;
 use crate::package_manager_real::directories;
 use crate::package_manager_real::package_manager_options::Do;
 
-/// Zig: `Resolution.Tag` — Rust can't nest a type inside a struct, so the
-/// enum lives at module level in `crate::resolution`.
+/// The enum lives at module level in `crate::resolution`.
 type ResolutionTag = resolution::Tag;
 
 type Bitset = DynamicBitSet;
 type ProgressNode = crate::bun_progress::Node;
 
-// ── Store id aliases (Zig: `Store.Entry.Id` / `Store.Node.Id`) ────────────
+// ── Store id aliases ───────────────────────────────────────────────────────
 type StoreEntryId = store::entry::Id;
 type StoreNodeId = store::node::Id;
 
 // ── Path option presets ───────────────────────────────────────────────────
 use paths::path_options::{AssumeOk as _, Kind as PathKind, PathSeparators};
-/// `bun.Path(.{ .sep = .auto })`
 type AutoPath = paths::Path<u8, { PathKind::ANY }, { PathSeparators::AUTO }>;
-/// `bun.AbsPath(.{ .unit = .os, .sep = .auto })`
 type OsAutoAbsPath = AbsPath<paths::OSPathChar, { PathSeparators::AUTO }>;
-/// `bun.Path(.{ .unit = .os, .sep = .auto })`
 type OsAutoPath = paths::Path<paths::OSPathChar, { PathKind::ANY }, { PathSeparators::AUTO }>;
-/// `bun.AbsPath(.{})` — all-default options.
 type DefaultAbsPath = AbsPath<u8>;
-/// `node_modules/.bun` — Zig used `Store.modules_dir_name` in compile-time
-/// concat; the Rust `MODULES_DIR_NAME` const is `&[u8]` and not usable in
-/// `const_format::concatcp!`, so spell the literal.
+/// `node_modules/.bun` — the `MODULES_DIR_NAME` const is `&[u8]` and not
+/// usable in `const_format::concatcp!`, so spell the literal.
 const NODE_MODULES_BUN: &str = "node_modules/.bun";
 
 bun_output::declare_scope!(IsolatedInstaller, hidden);
@@ -71,7 +65,7 @@ macro_rules! debug {
 
 pub struct Installer<'a> {
     pub trusted_dependencies_mutex: Mutex,
-    /// Zig: `*Lockfile` — BACKREF. Raw pointer (not `&'a mut`) for the same
+    /// BACKREF. Raw pointer (not `&'a mut`) for the same
     /// reason as `manager`: `Task::run` executes concurrently on the thread
     /// pool and each task derefs this field; a `&'a mut` would assert
     /// exclusivity every concurrent task violates. Mutated only for
@@ -79,10 +73,10 @@ pub struct Installer<'a> {
     /// narrowed via `addr_of_mut!`). Never null. Read via `lockfile()`.
     pub lockfile: *mut Lockfile,
 
-    pub summary: InstallSummary, // = .{ .successfully_installed = .empty }
+    pub summary: InstallSummary,
     pub installed: Bitset,
     pub install_node: Option<&'a mut ProgressNode>,
-    /// Mirrors Zig's `?*Progress.Node`. Stored as `NonNull` (not `&mut`)
+    /// Stored as `NonNull` (not `&mut`)
     /// because `PackageManager.scripts_node` already holds a raw pointer to the
     /// same stack local; materializing a second long-lived `&mut` here would
     /// invalidate that pointer's provenance under Stacked Borrows. Currently
@@ -90,7 +84,7 @@ pub struct Installer<'a> {
     pub scripts_node: Option<core::ptr::NonNull<ProgressNode>>,
     pub is_new_bun_modules: bool,
 
-    /// Zig: `*PackageManager` — BACKREF. Raw pointer (not `&'a mut`) because
+    /// BACKREF. Raw pointer (not `&'a mut`) because
     /// `Task::run`/`Task::callback` execute concurrently on the thread pool
     /// and each derefs this field; a `&'a mut` here would assert exclusivity
     /// every concurrent task violates. Never null. Access via `manager()` /
@@ -103,7 +97,7 @@ pub struct Installer<'a> {
     pub task_queue: UnboundedQueue<Task>, // intrusive via .next
     pub tasks: Box<[Task]>,
 
-    /// Zig: `std.atomic.Value(PackageInstall.Method)`. Stable Rust has no
+    /// Stable Rust has no
     /// generic atomic-enum, so store the `#[repr(u8)]` discriminant and
     /// round-trip via `Method::from_u8` at the load sites below.
     pub supported_backend: AtomicU8,
@@ -199,8 +193,7 @@ impl<'a> Installer<'a> {
             let pkg_resolutions = pkgs.items_resolution();
 
             for install_ctx in removed.as_slice() {
-                // Zig: `install_ctx.isolated_package_install_context` (union field
-                // access). Rust models `TaskCallbackContext` as an enum, so destructure.
+                // `TaskCallbackContext` is an enum, so destructure.
                 let &TaskCallbackContext::IsolatedPackageInstallContext(entry_id) = install_ctx
                 else {
                     continue;
@@ -250,8 +243,7 @@ impl<'a> Installer<'a> {
 
             let entry_steps = self.store.entries.items_step();
             for install_ctx in callbacks.as_slice() {
-                // Zig: `install_ctx.isolated_package_install_context` (union field
-                // access). Rust models `TaskCallbackContext` as an enum, so destructure.
+                // `TaskCallbackContext` is an enum, so destructure.
                 let &TaskCallbackContext::IsolatedPackageInstallContext(entry_id) = install_ctx
                 else {
                     continue;
@@ -300,7 +292,7 @@ impl<'a> Installer<'a> {
             patch.name_and_version_hash,
         );
         // SAFETY: `new_apply_patch_hash` returns a freshly Box-allocated PatchTask;
-        // sole ownership lives in this scope. Mirrors Zig `defer patch_task.deinit()`.
+        // sole ownership lives in this scope.
         struct PatchTaskGuard(*mut install::PatchTask);
         impl Drop for PatchTaskGuard {
             fn drop(&mut self) {
@@ -422,7 +414,7 @@ impl<'a> Installer<'a> {
             | ResolutionTag::Folder => {
                 let mut store_path = AutoRelPath::init();
 
-                // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                // OOM/capacity: fire-and-forget
                 let _ = store_path.append_fmt(format_args!(
                     "node_modules/{}",
                     store::entry::fmt_store_path(entry_id, self.store, self.lockfile()),
@@ -649,7 +641,11 @@ pub enum Result {
     None,
     Err(TaskError),
     Blocked,
-    RunScripts(*mut package::scripts::List), // TODO(port): LIFETIMES.tsv=BORROW_FIELD &'a mut package::scripts::List — kept raw for borrowck (owned by store.entries.items(.scripts)[entry_id])
+    // Kept raw (semantically `&mut package::scripts::List`): the pointee is
+    // owned by `store.entries.items(.scripts)[entry_id]`, which outlives every
+    // task; threading `'a` here is blocked by the `Installer<'static>` BackRef
+    // the queued `Task` already carries.
+    RunScripts(*mut package::scripts::List),
     Done,
 }
 
@@ -675,12 +671,16 @@ impl TaskError {
             TaskError::Binaries(err) => TaskError::Binaries(*err),
             TaskError::RunScripts(err) => TaskError::RunScripts(*err),
             TaskError::Patching(_log) => {
-                // TODO(port): `bun_ast::Log` is non-Clone; the only caller of
-                // `TaskError::clone()` is `Yield::failure` which never receives a
-                // `Patching` payload (Patching is only constructed on the main
-                // thread via `on_package_extracted`, never passed through the
-                // task-thread `Yield::Fail` path). Preserve a fresh Log so we
-                // don't UAF a borrowed one.
+                // `bun_ast::Log` is non-Clone; the only caller of
+                // `TaskError::clone()` is the `Result::Err(err) => err.clone()`
+                // task-batch drain in PackageManager/runTasks.rs, and
+                // `Task::result` is only set to `Result::Err` from the
+                // `Yield::Fail` arm in `Task::run`. No `Yield::Fail` /
+                // `Yield::failure` site ever constructs `TaskError::Patching` —
+                // it is built only for direct `on_task_fail` calls (Installer.rs
+                // and isolated_install.rs patch paths), so this arm is
+                // unreachable in practice. Preserve a fresh Log so we don't UAF
+                // a borrowed one.
                 TaskError::Patching(Log::init())
             }
             TaskError::Download(dl) => TaskError::Download(DownloadError {
@@ -716,7 +716,6 @@ pub enum Step {
 }
 
 impl From<Step> for &'static str {
-    /// Zig `@tagName(step)`.
     fn from(s: Step) -> &'static str {
         match s {
             Step::LinkPackage => "link_package",
@@ -756,7 +755,9 @@ impl Step {
 
 pub enum Yield {
     Yield,
-    RunScripts(*mut package::scripts::List), // TODO(port): LIFETIMES.tsv=BORROW_PARAM &'a mut package::scripts::List — kept raw for borrowck (borrow of entry_scripts)
+    // Kept raw (semantically `&mut package::scripts::List`): borrow of
+    // `entry_scripts`, owned by the store entry — see `Result::RunScripts`.
+    RunScripts(*mut package::scripts::List),
     Done,
     Blocked,
     Fail(TaskError),
@@ -770,7 +771,6 @@ impl Yield {
 
 impl Task {
     /// Called from task thread
-    // PERF(port): was comptime enum monomorphization — profile if hot.
     fn next_step(&self, current_step: Step) -> Step {
         let next_step: Step = match current_step {
             Step::LinkPackage => Step::SymlinkDependencies,
@@ -808,8 +808,7 @@ impl Task {
         // SAFETY: installer outlives all tasks (BACKREF). `run()` executes on the
         // thread pool concurrently across many `Task`s that all share the same
         // `*mut Installer`, and `next_step()` re-derefs `self.installer` mid-loop —
-        // materializing `&mut Installer` here would alias both (Zig's `*Installer`
-        // is freely shared). Instead:
+        // materializing `&mut Installer` here would alias both. Instead:
         //   * `installer` is a shared `&Installer`; every Installer method called
         //     below takes `&self`.
         //   * `manager_ptr` / `lockfile_ptr` are reached by raw-reading their
@@ -817,8 +816,7 @@ impl Task {
         //     they do not overlap `installer`. They stay RAW for the whole body —
         //     binding a function-scoped `&mut PackageManager` / `&mut Lockfile`
         //     here would mean every concurrent task thread holds an aliased
-        //     `&mut` to the same object (UB regardless of mutex discipline; Zig's
-        //     `*PackageManager` / `*Lockfile` carry no exclusivity contract).
+        //     `&mut` to the same object (UB regardless of mutex discipline).
         //     Per-site reborrows below are `&*manager_ptr` for read-only access,
         //     and mutation is narrowed via `addr_of_mut!` to the single field
         //     being written while `trusted_dependencies_mutex` is held.
@@ -1203,7 +1201,7 @@ impl Task {
                         let _ = Fd::cwd().delete_tree(staging.slice());
                     }
 
-                    // PORT NOTE: reshaped for borrowck — `defer if (cached_package_dir) |d| d.close()`
+                    // reshaped for borrowck — `defer if (cached_package_dir) |d| d.close()`
                     // becomes a guard that *owns* the `Option<Fd>` so the loop body can reassign
                     // through `*cached_package_dir` without an outstanding closure borrow.
                     let mut cached_package_dir = scopeguard::guard(None::<Fd>, |dir| {
@@ -1218,10 +1216,8 @@ impl Task {
                     let mut backend =
                         InstallMethod::from_u8(installer.supported_backend.load(Ordering::Relaxed));
                     'backend: loop {
-                        // PORT NOTE: reshaped for borrowck — Zig builds `dest_subpath` once
-                        // before the labeled-switch and passes it by-value (struct copy)
-                        // into each backend's helper. Rust moves it, so rebuild per
-                        // iteration; this only re-runs once on an EXDEV/OPNOTSUPP retry.
+                        // Rebuild `dest_subpath` per iteration; this only
+                        // re-runs once on an EXDEV/OPNOTSUPP retry.
                         let mut dest_subpath = OsAutoPath::init();
                         installer.append_real_store_path(
                             &mut dest_subpath,
@@ -1319,7 +1315,7 @@ impl Task {
 
                                 let mut src = OsAutoAbsPath::from_long_path(cache_dir_path.slice())
                                     .assume_ok();
-                                let _ = src.append_join(pkg_cache_dir_subpath.slice()); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                                let _ = src.append_join(pkg_cache_dir_subpath.slice()); // OOM/capacity: fire-and-forget
 
                                 let mut hardlinker = Hardlinker::init(
                                     cached_package_dir.unwrap(),
@@ -1391,7 +1387,7 @@ impl Task {
 
                                 let mut src_path =
                                     OsAutoAbsPath::from(cache_dir_path.slice()).assume_ok();
-                                let _ = src_path.append(pkg_cache_dir_subpath.slice()); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                                let _ = src_path.append(pkg_cache_dir_subpath.slice()); // OOM/capacity: fire-and-forget
 
                                 let mut file_copier = FileCopier::init(
                                     cached_package_dir.unwrap(),
@@ -1446,7 +1442,7 @@ impl Task {
                             Which::Staging,
                         );
 
-                        let _ = dest.append(dep_name); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                        let _ = dest.append(dep_name); // OOM/capacity: fire-and-forget
 
                         if let Some(entry_node_modules_name) = installer
                             .entry_store_node_modules_package_name(
@@ -1456,8 +1452,8 @@ impl Task {
                             if strings::eql_long(dep_name, entry_node_modules_name, true) {
                                 // nest the dependency in another node_modules if the name is the same as the entry name
                                 // in the store node_modules to avoid collision
-                                let _ = dest.append(b"node_modules"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-                                let _ = dest.append(dep_name); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                                let _ = dest.append(b"node_modules"); // OOM/capacity: fire-and-forget
+                                let _ = dest.append(dep_name); // OOM/capacity: fire-and-forget
                             }
                         }
 
@@ -1491,11 +1487,9 @@ impl Task {
                             installer.append_store_path(&mut dep_store_path, dep.entry_id);
                         }
 
-                        // PORT NOTE: reshaped for borrowck — Zig's
-                        // `const dest_save = dest.save(); defer dest_save.restore();`
-                        // can't coexist with `dest.undo()/dest.relative()` because
-                        // the `ResetScope` guard holds `&mut dest`. Capture the
-                        // length and restore manually.
+                        // A `dest.save()` `ResetScope` guard would hold `&mut dest`,
+                        // which can't coexist with `dest.undo()/dest.relative()`.
+                        // Capture the length and restore manually.
                         let dest_saved_len = dest.len();
                         let target = {
                             dest.undo(1);
@@ -1826,10 +1820,10 @@ impl Task {
                         );
                     }
 
-                    // PORT NOTE: `target_node_modules_path` intentionally aliases
+                    // `target_node_modules_path` intentionally aliases
                     // `node_modules_path` in the common (no-replacement) case —
-                    // mirrors the Zig `*AbsPath` aliasing. The Linker field is a
-                    // raw `*const AbsPath` for exactly this reason.
+                    // the Linker field is a raw `*const AbsPath` for exactly
+                    // this reason.
                     let target_nm_ptr: *const DefaultAbsPath =
                         match target_node_modules_path.as_ref() {
                             Some(p) => p,
@@ -1961,9 +1955,8 @@ impl Task {
         // both are reached through a shared `&Installer`. `manager.wake()` is the
         // cross-thread wakeup: route through `PackageManager::wake_raw` which never
         // forms `&mut PackageManager`, so two threads finishing simultaneously do
-        // not hold aliased exclusive borrows (Zig's `*PackageManager` carries no
-        // exclusivity contract; "deref it fresh per call" alone would not prevent
-        // the `&mut` lifetimes from overlapping).
+        // not hold aliased exclusive borrows ("deref it fresh per call" alone
+        // would not prevent the `&mut` lifetimes from overlapping).
         let installer_ptr = this.installer;
         let installer = installer_ptr.get();
         let manager_ptr: *mut PackageManager = installer.manager;
@@ -2052,7 +2045,7 @@ pub struct PatchInfoRemove {
 
 pub struct PatchInfoPatch {
     pub name_and_version_hash: u64,
-    pub patch_path: Box<[u8]>, // TODO(port): lifetime — slices into lockfile string_buf
+    pub patch_path: Box<[u8]>, // owned copy of the lockfile string_buf slice
     pub contents_hash: u64,
 }
 
@@ -2151,7 +2144,7 @@ impl<'a> Installer<'a> {
 
         let mut hidden_hoisted_node_modules = AutoPath::init();
 
-        // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        // OOM/capacity: fire-and-forget
         let _ = hidden_hoisted_node_modules.append(
             // "node_modules" + sep + ".bun" + sep + "node_modules"
             const_format::concatcp!(
@@ -2163,16 +2156,16 @@ impl<'a> Installer<'a> {
             )
             .as_bytes(),
         );
-        let _ = hidden_hoisted_node_modules.append(pkg_name.slice(string_buf)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = hidden_hoisted_node_modules.append(pkg_name.slice(string_buf)); // OOM/capacity: fire-and-forget
 
         let mut target = AutoRelPath::init();
 
-        let _ = target.append(b".."); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = target.append(b".."); // OOM/capacity: fire-and-forget
         if strings::index_of_char(pkg_name.slice(string_buf), b'/').is_some() {
-            let _ = target.append(b".."); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = target.append(b".."); // OOM/capacity: fire-and-forget
         }
 
-        // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        // OOM/capacity: fire-and-forget
         let _ = target.append_fmt(format_args!(
             "{}/node_modules/{}",
             store::entry::fmt_store_path(entry_id, self.store, self.lockfile()),
@@ -2255,7 +2248,6 @@ impl<'a> Installer<'a> {
         &self,
         parent_entry_id: StoreEntryId,
     ) -> core::result::Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let lockfile = self.lockfile();
         let store = self.store;
 
@@ -2330,8 +2322,8 @@ impl<'a> Installer<'a> {
                 );
             }
 
-            // PORT NOTE: see the matching note in `Step::LinkBinaries` — Zig
-            // aliases `target_node_modules_path` with `node_modules_path` and
+            // see the matching note in `Step::LinkBinaries` —
+            // `target_node_modules_path` may alias `node_modules_path` and
             // the Linker field is a raw `*const AbsPath` to permit that.
             let target_nm_ptr: *const DefaultAbsPath = match target_node_modules_path.as_ref() {
                 Some(p) => p,
@@ -2454,8 +2446,8 @@ impl<'a> Installer<'a> {
                 // discard ours.
                 if self.manager().options.enable.force_install() {
                     let mut old = AutoAbsPath::init();
-                    let _ = old.append(self.global_store_path.as_ref().unwrap().as_bytes()); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-                    // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    let _ = old.append(self.global_store_path.as_ref().unwrap().as_bytes()); // OOM/capacity: fire-and-forget
+                    // OOM/capacity: fire-and-forget
                     let _ = old.append_fmt(format_args!(
                         "{}.old-{:x}",
                         store::entry::fmt_global_store_path(entry_id, self.store, self.lockfile()),
@@ -2527,7 +2519,7 @@ impl<'a> Installer<'a> {
             #[cfg(windows)]
             {
                 // `target_abs` is already absolute, so the junction fallback
-                // can reuse it directly (Zig: passes the same `target` pointer).
+                // can reuse it directly.
                 return sys::symlink_or_junction(d, t, None);
             }
             #[cfg(not(windows))]
@@ -2713,9 +2705,9 @@ impl<'a> Installer<'a> {
                 buf.append(pkg_res.workspace().slice(string_buf));
             }
             ResolutionTag::Symlink => {
-                // PORT NOTE: reshaped — Zig `globalLinkDirPath()` lazily ensures
-                // the dir and mutates `*PackageManager`. `append_store_path` is
-                // `&self` (matching Zig `*const Installer`) and may run on worker
+                // Lazily ensuring the global link dir would mutate
+                // `*PackageManager`, but `append_store_path` is
+                // `&self` and may run on worker
                 // threads, so the lazy init is hoisted to the main-thread caller
                 // (`isolated_install::install_packages`, before any `start_task`).
                 // Reading the cached field here is then equivalent.
@@ -2797,5 +2789,3 @@ fn is_rename_collision(err: &sys::Error) -> bool {
         _ => false,
     }
 }
-
-// ported from: src/install/isolated_install/Installer.zig
diff --git a/src/install/isolated_install/Store.rs b/src/install/isolated_install/Store.rs
index 3ab61e923d7..9dd1dc99f96 100644
--- a/src/install/isolated_install/Store.rs
+++ b/src/install/isolated_install/Store.rs
@@ -28,9 +28,9 @@ pub struct Store {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// NewId<T> — Zig: `fn NewId(comptime T: type) type { return enum(u32) { root=0, invalid=max, _ } }`
+// NewId<T>
 // Rust generic newtypes are nominally distinct, so `NewId<Entry> != NewId<Node>` holds by
-// construction (the Zig `comptime { bun.assert(NewId(Entry) != NewId(Node)) }` block is a no-op).
+// construction.
 // ──────────────────────────────────────────────────────────────────────────
 #[repr(transparent)]
 pub struct NewId<T>(u32, PhantomData<fn() -> T>);
@@ -53,8 +53,7 @@ impl<T> core::hash::Hash for NewId<T> {
     }
 }
 impl<T> Default for NewId<T> {
-    // Zig leaves this undefined; pick the sentinel so accidental use trips
-    // the debug_assert in `get()`.
+    // Pick the sentinel so accidental use trips the debug_assert in `get()`.
     fn default() -> Self {
         Self::INVALID
     }
@@ -121,7 +120,6 @@ impl Store {
         let mut i: usize = 0;
         let mut len: usize;
 
-        // Zig `.items(.parents)` → derive(MultiArrayElement)-generated `.items_parents()`.
         let entry_parents = self.entries.items_parents();
 
         for &parent_id in entry_parents[id.get() as usize].as_slice() {
@@ -131,12 +129,12 @@ impl Store {
             if parent_id == maybe_parent_id {
                 return true;
             }
-            let _ = parent_dedupe.put(parent_id, ()); // OOM-only Result (Zig: catch unreachable)
+            let _ = parent_dedupe.put(parent_id, ()); // OOM-only Result
         }
 
         len = parent_dedupe.len();
         while i < len {
-            // PORT NOTE: reshaped for borrowck — capture key before mutating `parent_dedupe`.
+            // Capture key before mutating `parent_dedupe`.
             let key = parent_dedupe.keys()[i];
             for &parent_id in entry_parents[key.get() as usize].as_slice() {
                 if parent_id == entry::Id::INVALID {
@@ -145,7 +143,7 @@ impl Store {
                 if parent_id == maybe_parent_id {
                     return true;
                 }
-                let _ = parent_dedupe.put(parent_id, ()); // OOM-only Result (Zig: catch unreachable)
+                let _ = parent_dedupe.put(parent_id, ()); // OOM-only Result
                 len = parent_dedupe.len();
             }
             i += 1;
@@ -156,12 +154,11 @@ impl Store {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// OrderedArraySet<T> — Zig: `fn OrderedArraySet(comptime T, comptime Ctx) type`.
-// PORT NOTE: the `Ctx` type param is dropped from the struct; ctx is passed per-call as
-// `&impl OrderedArraySetCtx<T>`. In Zig the Ctx param only contributed comptime method
-// lookup; in Rust the two instantiations (`Dependencies`, `Peers`) are already distinct
-// via `T`. Ctx structs carry borrowed slices, so binding their lifetime into the
-// container type would infect stored fields.
+// OrderedArraySet<T>
+// The ctx is passed per-call as `&impl OrderedArraySetCtx<T>` rather than as a
+// type param on the struct; the two instantiations (`Dependencies`, `Peers`)
+// are already distinct via `T`. Ctx structs carry borrowed slices, so binding
+// their lifetime into the container type would infect stored fields.
 // ──────────────────────────────────────────────────────────────────────────
 pub(crate) trait OrderedArraySetCtx<T: Copy> {
     fn eql(&self, l: T, r: T) -> bool;
@@ -278,12 +275,10 @@ pub mod entry {
         pub node_id: super::node::Id,
         // parent_id: Id,
         pub dependencies: Dependencies,
-        // Zig default: `.empty`
         pub parents: Vec<Id>,
-        // Zig default: `.init(.link_package)`
-        // PORT NOTE: `std.atomic.Value(Installer.Task.Step)` → `AtomicU32` storing
-        // the `#[repr(u8)]` discriminant. Loads/stores go through `Step as u32` /
-        // `Step::from_u32` (see Installer.rs); no atomic-enum wrapper exists.
+        // `AtomicU32` storing the `#[repr(u8)]` `Step` discriminant. Loads and
+        // stores go through `Step as u32` / `Step::from_u32` (see Installer.rs);
+        // no atomic-enum wrapper exists.
         pub step: core::sync::atomic::AtomicU32,
 
         // if true this entry gets symlinked to `node_modules/.bun/node_modules`
@@ -298,13 +293,11 @@ pub mod entry {
         /// hash differs and a new global-store entry is created. Computed after the
         /// store is built (see `computeEntryHashes`). 0 means "do not use global store"
         /// (root, workspace, folder, symlink, patched).
-        // Zig default: `0`
         pub entry_hash: u64,
 
-        // Zig default: `null`
-        // PORT NOTE: `Cell` because `Installer::Task::run` writes this slot
+        // `Cell` because `Installer::Task::run` writes this slot
         // from a task thread through `&Store` (each Task is the sole writer for
-        // its own `entry_id`; see Installer.zig:541/1161). Without interior
+        // its own `entry_id`; see Installer.rs). Without interior
         // mutability the only access path is `&Store → &[Option<_>]` and the
         // per-entry write would mutate through shared-reference provenance.
         // Raw `*mut` instead of `Box` so reads don't move out of the cell.
@@ -332,15 +325,12 @@ pub mod entry {
             Self {
                 node_id: super::node::Id::INVALID,
                 dependencies: Dependencies::EMPTY,
-                // Zig default: `.empty`
                 parents: Vec::new(),
-                // Zig default: `.init(.link_package)` — `Step::LinkPackage as u32 == 0`.
+                // `Step::LinkPackage as u32 == 0`.
                 step: core::sync::atomic::AtomicU32::new(0),
                 hoisted: false,
                 peer_hash: PeerHash::NONE,
-                // Zig default: `0`
                 entry_hash: 0,
-                // Zig default: `null`
                 scripts: core::cell::Cell::new(None),
             }
         }
@@ -426,7 +416,6 @@ pub mod entry {
             }
 
             if peer_hash != PeerHash::NONE {
-                // Zig `bun.fmt.hexIntLower(u64)` zero-pads to 16 nibbles.
                 write!(f, "+{:016x}", peer_hash.cast())?;
             }
 
@@ -454,7 +443,6 @@ pub mod entry {
     impl<'a> fmt::Display for GlobalStorePathFormatter<'a> {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             self.inner.fmt(f)?;
-            // Zig `bun.fmt.hexIntLower(u64)` zero-pads to 16 nibbles.
             write!(f, "-{:016x}", self.entry_hash)
         }
     }
@@ -474,8 +462,6 @@ pub mod entry {
     }
 
     pub(crate) fn debug_gather_all_parents(entry_id: Id, store: &Store) -> Vec<Id> {
-        // PORT NOTE: reshaped — Zig leaked the local map and returned its keys slice;
-        // Rust returns an owned Vec instead.
         let mut i: usize = 0;
         let mut len: usize;
 
@@ -488,18 +474,18 @@ pub mod entry {
             if parent_id == Id::INVALID {
                 continue;
             }
-            let _ = parents.put(parent_id, ()); // OOM-only Result (Zig: catch unreachable)
+            let _ = parents.put(parent_id, ()); // OOM-only Result
         }
 
         len = parents.len();
         while i < len {
-            // PORT NOTE: reshaped for borrowck — capture key before mutating `parents`.
+            // Capture key before mutating `parents`.
             let key = parents.keys()[i];
             for &parent_id in entry_parents[key.get() as usize].as_slice() {
                 if parent_id == Id::INVALID {
                     continue;
                 }
-                let _ = parents.put(parent_id, ()); // OOM-only Result (Zig: catch unreachable)
+                let _ = parents.put(parent_id, ()); // OOM-only Result
                 len = parents.len();
             }
             i += 1;
@@ -582,8 +568,8 @@ pub mod node {
     pub type Id = NewId<Node>;
     pub type List = MultiArrayList<Node>;
     pub(crate) type Peers = OrderedArraySet<TransitivePeer>;
-    /// Zig: `Node.dependencies: ArrayList(Ids)` — re-exported under a
-    /// disambiguating name for callers building the dependency vec.
+    /// Re-exported under a disambiguating name for callers building the
+    /// dependency vec.
     pub use super::Ids as DependencyIds;
 
     pub struct Node {
@@ -591,13 +577,10 @@ pub mod node {
         pub pkg_id: PackageID,
         pub parent_id: Id,
 
-        // Zig default: `.empty`
         pub dependencies: Vec<Ids>,
-        // Zig default: `.empty`
         pub peers: Peers,
 
         // each node in this list becomes a symlink in the package's node_modules
-        // Zig default: `.empty`
         pub nodes: Vec<Id>,
     }
 
@@ -632,8 +615,6 @@ pub mod node {
         pub auto_installed: bool,
     }
 
-    // Zig: `TransitivePeer.OrderedArraySetCtx` — Rust can't nest a type inside a struct,
-    // so expose a snake_case module mirroring the Zig namespace for callers.
     pub mod transitive_peer {
         pub use super::TransitivePeerOrderedArraySetCtx as OrderedArraySetCtx;
     }
@@ -701,5 +682,3 @@ pub mod node {
 
 pub use node::Node;
 pub use node::NodeColumns;
-
-// ported from: src/install/isolated_install/Store.zig
diff --git a/src/install/isolated_install/Symlinker.rs b/src/install/isolated_install/Symlinker.rs
index 6d7cae62897..f11adc64ce5 100644
--- a/src/install/isolated_install/Symlinker.rs
+++ b/src/install/isolated_install/Symlinker.rs
@@ -3,20 +3,18 @@ use bun_paths;
 use bun_sys::{self, Errno, Fd, FdDirExt, FdExt};
 
 pub struct Symlinker {
-    // TODO(port): bun.Path/RelPath/AbsPath are comptime-config generic (`.{ .sep = .auto }`);
-    // mapped to non-generic bun_paths types here — may need a `<const SEP: Sep>` param.
     pub dest: bun_paths::Path,
     pub target: bun_paths::RelPath,
     pub fallback_junction_target: bun_paths::AbsPath,
 }
 
 impl Symlinker {
-    // PORT NOTE: `&mut self` (vs Zig `*const`) because `Path::slice_z()` writes
+    // `&mut self` because `Path::slice_z()` writes
     // the trailing NUL into its pooled buffer and so requires `&mut`.
     pub fn symlink(&mut self) -> bun_sys::Result<()> {
         #[cfg(windows)]
         {
-            // PORT NOTE: borrowck — `slice_z()` mut-borrows each path to write
+            // borrowck — `slice_z()` mut-borrows each path to write
             // the trailing NUL; bind the fallback first so all three borrows
             // are live disjointly when passed to `symlink_or_junction`.
             let fallback = self.fallback_junction_target.slice_z();
@@ -172,5 +170,3 @@ pub enum Strategy {
     ExpectMissing,
     IgnoreFailure,
 }
-
-// ported from: src/install/isolated_install/Symlinker.zig
diff --git a/src/install/lib.rs b/src/install/lib.rs
index 29f47ff7b4c..f79d4534b73 100644
--- a/src/install/lib.rs
+++ b/src/install/lib.rs
@@ -61,8 +61,7 @@ use core::cell::Cell;
 use core::fmt;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Module declarations — Zig basenames preserved per PORTING.md, hence
-// explicit #[path] attrs for PascalCase files.
+// Module declarations — explicit #[path] attrs for PascalCase files.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub mod npm;
@@ -137,7 +136,7 @@ pub mod lockfile {
     pub use crate::lockfile_real::LockfileFormat as Format;
     pub use crate::lockfile_real::Serializer::SerializerLoadResult;
     pub use crate::lockfile_real::package_index::Entry as PackageIndexEntry;
-    /// Zig callers spell `.root` (a `Resolution.Tag` literal) when invoking
+    /// Callers pass a `Resolution.Tag` literal when invoking
     /// `Scripts.createList` for the root package; alias the tag enum here so
     /// `lockfile::ScriptsListKind::Root` resolves.
     pub use crate::resolution::Tag as ScriptsListKind;
@@ -179,8 +178,8 @@ pub mod package_manager {
     #[allow(non_snake_case)]
     pub mod Options {
         pub use crate::package_manager_real::package_manager_options::*;
-        // `open_global_dir` lives in PackageManagerOptions.rs (`options::`
-        // namespace in Zig); re-export so `Options::open_global_dir` resolves.
+        // `open_global_dir` lives in PackageManagerOptions.rs; re-export so
+        // `Options::open_global_dir` resolves.
         pub use crate::package_manager_real::package_manager_options::open_global_dir;
     }
 
@@ -191,8 +190,7 @@ pub mod package_manager {
         MapEntry as WorkspacePackageJsonCacheEntry, WorkspacePackageJSONCache,
     };
 
-    /// `populateManifestCache` `Packages` union
-    /// (src/install/PackageManager/PopulateManifestCache.zig).
+    /// `populateManifestCache` `Packages` union.
     pub enum ManifestCacheOptions<'a> {
         Ids(&'a [crate::PackageID]),
         Names(&'a [&'a [u8]]),
@@ -220,24 +218,23 @@ pub mod package_manager {
 
 /// `crate::install::…` shim — Phase-A drafts (bin.rs, repository.rs,
 /// migration.rs, resolvers/folder_resolver.rs) were written against a
-/// `bun_install::install` submodule path mirroring `install.zig`. The crate
-/// root *is* that file now, so re-export everything under both names.
+/// `bun_install::install` submodule path. The crate root *is* that module
+/// now, so re-export everything under both names.
 pub(crate) mod install {
     pub(crate) use crate::*;
 }
 
-/// `windows-shim/BinLinkingShim.zig` — `.bunx` shim encoder consumed by
+/// `.bunx` shim encoder consumed by
 /// `bin::Linker` (Windows only at runtime, but the encoder types are
 /// referenced unconditionally so the module must exist on all targets).
-// PORT NOTE: `#[path]` inside an inline `mod {}` resolves relative to the
+// `#[path]` inside an inline `mod {}` resolves relative to the
 // synthetic `windows_shim/` directory, which doesn't exist on disk. Hoist the
 // file-backed module to crate level with an absolute-ish path and re-export
 // through the inline mod so `windows_shim::bin_linking_shim` keeps resolving.
 #[path = "windows-shim/BinLinkingShim.rs"]
 pub mod _bin_linking_shim;
-// `bun_shim_impl` is a *freestanding Windows PE* (no CRT, raw NT syscalls) —
-// in Zig it is a separate `exe` artifact whose output is `@embedFile`d above.
-// Unlike Zig the Rust port also compiles as a library `mod` (Windows-only) so
+// `bun_shim_impl` is a *freestanding Windows PE* (no CRT, raw NT syscalls)
+// that also compiles as a library `mod` (Windows-only) so
 // `run_command.rs` can call `try_startup_from_bun_js` / `FromBunRunContext`
 // directly — the standalone PE entrypoint is gated behind
 // `feature = "shim_standalone"` inside the file, and there is no
@@ -337,10 +334,8 @@ pub use package_manager_real::{
 pub type PackageManagerDoStub = package_manager_real::package_manager_options::Do;
 pub use package_manager_real::package_manager_options::{Access, AuthType};
 
-/// Port of the anonymous `comptime callbacks: anytype` struct passed to
-/// `PackageManager.runTasks` (src/install/PackageManager/runTasks.zig). Zig
-/// duck-types `@TypeOf(callbacks.onExtract) != void` etc.; the Rust shape is
-/// generic over each slot so call sites can pass `()` for unused hooks and a
+/// Callback bundle passed to `PackageManager.runTasks`. Generic over each
+/// slot so call sites can pass `()` for unused hooks and a
 /// fn item for active ones. The trait-based dispatch lives in
 /// `package_manager_real::run_tasks::RunTasksCallbacks`; this value-level
 /// struct is only the call-site spelling.
@@ -349,9 +344,7 @@ pub struct RunTasksCallbacks<E = (), R = (), M = (), D = ()> {
     pub on_resolve: R,
     pub on_package_manifest_error: M,
     pub on_package_download_error: D,
-    /// Zig: `comptime callbacks.progress_bar` (defaults absent → false).
     pub progress_bar: bool,
-    /// Zig: `comptime callbacks.manifests_only` (defaults absent → false).
     pub manifests_only: bool,
 }
 impl<E: Default, R: Default, M: Default, D: Default> Default for RunTasksCallbacks<E, R, M, D> {
@@ -384,11 +377,13 @@ pub struct PackageJSON {
     pub dependencies: PackageJSONDependencyMap,
 }
 
-/// Port of `bun.PackageJSON.DependencyMap` (src/resolver/package_json.zig).
 #[derive(Default)]
 pub struct PackageJSONDependencyMap {
     pub map: bun_collections::ArrayHashMap<bun_semver::String, Dependency>,
-    // TODO(port): lifetime — borrows the package.json source contents
+    // Erased borrow of the package.json source contents (mirrors
+    // `bun_resolver::package_json::DependencyMap::source_buf`, which is
+    // likewise `'static`-erased); kept alive by the originating
+    // `PackageJSON::source_contents` for the lifetime of the map.
     pub source_buf: &'static [u8],
 }
 
@@ -399,8 +394,7 @@ pub struct PackageJSONDependencyMap {
 /// when set (the same fallback `npm-registry-fetch` uses) and `None` otherwise.
 pub mod ci_info {
     pub(crate) fn detect_ci_name() -> Option<&'static [u8]> {
-        // Port of the trailing fallback in `ci_info.zig:detectCiName` —
-        // the per-vendor probes live in `bun_runtime` (T6) and are wired in
+        // The per-vendor probes live in `bun_runtime` (T6) and are wired in
         // there; install only needs *some* answer for the user-agent string.
         if bun_core::env_var::CI::get().is_some() {
             return Some(b"ci");
@@ -411,7 +405,7 @@ pub mod ci_info {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Only the `Shell` enum (variant detection) is consumed here — the embedded
-// completion script bodies stay in bun_cli (they pull in @embedFile assets).
+// completion script bodies stay in bun_cli (they pull in embedded script assets).
 // ──────────────────────────────────────────────────────────────────────────
 #[allow(non_snake_case)]
 pub mod ShellCompletions {
@@ -427,9 +421,6 @@ pub mod ShellCompletions {
     }
 
     impl Shell {
-        /// Port of `Shell.fromEnv` (src/cli/shell_completions.zig). The Zig version was
-        /// generic over the string type purely so it could accept both `[]const u8` and
-        /// `[:0]const u8`; in Rust both coerce to `&[u8]`.
         pub fn from_env(shell: &[u8]) -> Shell {
             use bun_core::strings;
             let basename = bun_paths::basename(shell);
@@ -457,8 +448,8 @@ pub mod ShellCompletions {
 // ──────────────────────────────────────────────────────────────────────────
 pub struct RunCommand;
 
-/// Canonical `PRETEND_TO_BE_NODE` flag (port of `Cli.pretend_to_be_node`,
-/// src/cli.zig). Set once during single-threaded startup by `Command::which()`
+/// Canonical `PRETEND_TO_BE_NODE` flag.
+/// Set once during single-threaded startup by `Command::which()`
 /// in `bun_runtime::cli` when argv[0] basename == "node"; read by both the
 /// runtime CLI and the install-tier `RunCommand` helpers below. Lives in
 /// `bun_install` (not `bun_runtime`) so both crates can address the SAME
@@ -480,7 +471,7 @@ impl RunCommand {
     /// therefore re-points a stale link on EEXIST instead of trusting it.
     #[cfg(not(windows))]
     pub const BUN_NODE_DIR: &'static str = {
-        // PORT NOTE: Zig used comptime `++`; `const_format::concatcp!` cannot host
+        // `const_format::concatcp!` cannot host
         // `if` expressions inline, so split into helper consts.
         use const_format::concatcp;
         const TMP: &str = if cfg!(target_os = "macos") {
@@ -562,8 +553,7 @@ impl RunCommand {
         .as_deref()
     }
 
-    /// Port of `RunCommand.createFakeTemporaryNodeExecutable`
-    /// (src/cli/run_command.zig). Symlinks/hardlinks the running bun binary as
+    /// Symlinks/hardlinks the running bun binary as
     /// `node` + `bun` inside a temp dir and prepends that dir to `path`.
     ///
     /// `#[cold]`: only reached on the `bun run <script>` / lifecycle-script
@@ -594,29 +584,25 @@ impl RunCommand {
                 argv0
             } else if optional_bun_path.is_empty() {
                 // otherwise, ask the OS for the absolute path
-                // Zig: `try bun.selfExePath()` — propagate the error.
                 let self_path = bun_core::self_exe_path()?;
                 if !self_path.as_bytes().is_empty() {
                     *optional_bun_path = self_path.as_bytes();
                     self_path
                 } else {
-                    // Zig: trailing `if (optional_bun_path.len == 0) argv0 = bun.argv[0];`
                     argv0
                 }
             } else {
-                // Zig: `var argv0 = @ptrCast(optional_bun_path.ptr)` — when argv[0] is
+                // When argv[0] is
                 // not absolute and the caller pre-supplied a path, that path is the
-                // symlink target (NOT bun.argv[0]).
+                // symlink target (NOT argv[0]).
                 // SAFETY: callers pass a slice borrowed from a `ZStr` (argv[0] /
-                // self_exe_path / static literal), so `ptr[len] == 0` holds — same
-                // precondition Zig's `@ptrCast` relies on.
+                // self_exe_path / static literal), so `ptr[len] == 0` holds.
                 unsafe { ZStr::from_raw(optional_bun_path.as_ptr(), optional_bun_path.len()) }
             };
 
             #[cfg(debug_assertions)]
             {
-                // Zig: `std.fs.deleteTreeAbsolute(BUN_NODE_DIR) catch {}` —
-                // debug-only cleanup; failures are ignored. The EEXIST branch
+                // Debug-only cleanup; failures are ignored. The EEXIST branch
                 // below already handles a stale dir.
                 let _ = bun_sys::delete_tree_absolute(Self::BUN_NODE_DIR.as_bytes());
             }
@@ -712,15 +698,14 @@ impl RunCommand {
                 )
             } as usize;
             if len == 0 {
-                // Zig: `Output.debug(...)` — non-fatal; fall through and leave
+                // Non-fatal; fall through and leave
                 // PATH unmodified. (No `RUN` scope is declared in this crate.)
                 return Ok(());
             }
 
             target_path_buffer[..prefix.len()].copy_from_slice(prefix);
 
-            // Zig: `comptime bun.strings.w("bun-node-" ++ git_sha_short)` —
-            // the dir name is ASCII-only, so widen the const `&str` byte-by-
+            // The dir name is ASCII-only, so widen the const `&str` byte-by-
             // byte into a small stack buffer at runtime (Rust macros require a
             // single string *literal* token, which `concatcp!` doesn't yield).
             let dir_name_str: &str = if cfg!(debug_assertions) {
@@ -741,14 +726,12 @@ impl RunCommand {
 
             #[cfg(debug_assertions)]
             {
-                // Zig: `std.fs.deleteTreeAbsolute(dir_slice_u8) catch {};
-                //       std.fs.makeDirAbsolute(dir_slice_u8) catch @panic("huh?");`
                 // Debug builds wipe and recreate the bun-node temp dir so the
                 // ALREADY_EXISTS short-circuit below never reuses a stale
                 // hardlink at a previous debug binary.
                 //
-                // PORT NOTE: Zig's `@panic("huh?")` assumes the wipe always
-                // leaves the path absent. `bun-run.test.ts` now uses
+                // The wipe does not always leave the path absent:
+                // `bun-run.test.ts` uses
                 // `describe.concurrent`, so multiple debug processes race on
                 // this shared dir and `make_dir` can legitimately observe
                 // `PathAlreadyExists` after a sibling re-created it. Swallow
@@ -764,8 +747,8 @@ impl RunCommand {
             let image_path = win::exe_path_w();
             for name in [strings::w!("\\node.exe\0"), strings::w!("\\bun.exe\0")] {
                 target_path_buffer[dir_slice_len..][..name.len()].copy_from_slice(name);
-                // PORT NOTE: Zig held a `[]const u16` into `target_path_buffer`
-                // across in-place mutation (the dir-NUL/backslash toggle below).
+                // `target_path_buffer` is mutated in place between FFI calls
+                // (the dir-NUL/backslash toggle below).
                 // Under Stacked Borrows a `*const` derived via `Deref::deref`
                 // is invalidated by the intervening `&mut` from `IndexMut`, so
                 // re-derive `as_ptr()` at each FFI call site instead of caching.
@@ -832,13 +815,10 @@ fn install_runner_arena() -> &'static bun_alloc::Arena {
 }
 
 impl RunCommand {
-    /// Port of `RunCommand.configureEnvForRun` (src/cli/run_command.zig:780).
-    ///
-    /// DEP-CYCLE NOTE: the full Zig body walks `bun_resolver::DirInfo` and
-    /// reads `package.json` via the resolver — T6 work that lives in
+    /// DEP-CYCLE NOTE: the full implementation walks `bun_resolver::DirInfo`
+    /// and reads `package.json` via the resolver — T6 work that lives in
     /// `bun_runtime::cli::RunCommand::configure_env_for_run`. The install
     /// tier needs the *Transpiler-initialisation* half of that contract
-    /// (run_command.zig:780 `this_transpiler.* = try Transpiler.init(...)`)
     /// because callers (`configure_env_for_scripts_run`) `assume_init()` the
     /// out-param. This shim performs the init + the env-var seeding that has
     /// no T6 dependency; the `*mut ()` return stands in for `*mut DirInfo`
@@ -853,7 +833,6 @@ impl RunCommand {
         use bun_core::Global;
 
         let args = ctx.args.clone();
-        // Spec run_command.zig:780: `this_transpiler.* = try Transpiler.init(ctx.allocator, ctx.log, args, env)`.
         this_transpiler.write(bun_transpiler::Transpiler::init(
             install_runner_arena(),
             ctx.log,
@@ -868,8 +847,7 @@ impl RunCommand {
         this_transpiler.resolver.care_about_scripts = true;
         this_transpiler.resolver.store_fd = store_root_fd;
 
-        // Re-derive per-use rather than holding a long-lived `&mut` (matches
-        // Zig's per-statement `this_transpiler.env` deref and avoids
+        // Re-derive per-use rather than holding a long-lived `&mut` (avoids
         // Stacked-Borrows overlap with `run_env_loader`).
         let env_loader = this_transpiler.env_mut();
 
@@ -924,8 +902,7 @@ pub(crate) const BUN_HASH_TAG: &[u8] = b".bun-tag-";
 
 /// Length of `u64::MAX` formatted as lowercase hex (`ffffffffffffffff`).
 pub(crate) const MAX_HEX_HASH_LEN: usize = {
-    // Zig computed this with std.fmt.bufPrint at comptime; u64::MAX in hex is
-    // always 16 nibbles.
+    // u64::MAX in hex is always 16 nibbles.
     let mut n = u64::MAX;
     let mut len = 0usize;
     while n != 0 {
@@ -941,7 +918,6 @@ pub(crate) type BuntagHashBuf = [u8; MAX_BUNTAG_HASH_BUF_LEN];
 
 pub(crate) fn buntaghashbuf_make(buf: &mut BuntagHashBuf, patch_hash: u64) -> &mut [u8] {
     buf[0..BUN_HASH_TAG.len()].copy_from_slice(BUN_HASH_TAG);
-    // std.fmt.bufPrint(buf[bun_hash_tag.len..], "{x}", .{patch_hash})
     let mut tmp = [0u8; 16];
     let digits = bun_core::fmt::u64_hex_var_lower(&mut tmp, patch_hash);
     buf[BUN_HASH_TAG.len()..BUN_HASH_TAG.len() + digits.len()].copy_from_slice(digits);
@@ -955,7 +931,7 @@ pub struct StorePathFormatter<'a> {
 }
 
 impl<'a> StorePathFormatter<'a> {
-    /// Spec install.zig:31-37 — `for (this.str) |c| writer.writeByte(c)` emits raw bytes
+    /// Emits raw bytes
     /// verbatim (mapping `/` and `\` to `+`). This is the byte-faithful sink; callers that
     /// need an on-disk store path (legal non-UTF-8 on Linux) must use this, not `Display`.
     pub fn write_to<W: std::io::Write>(&self, w: &mut W) -> std::io::Result<()> {
@@ -975,8 +951,8 @@ impl<'a> StorePathFormatter<'a> {
 
 impl<'a> fmt::Display for StorePathFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // PORT NOTE: `core::fmt` cannot emit non-UTF-8 bytes. The Zig spec writes raw
-        // bytes via `writer.writeByte(c)`; routing through `to_str_lossy()` here was wrong
+        // `core::fmt` cannot emit non-UTF-8 bytes, but the store path must be
+        // emitted byte-faithfully; routing through `to_str_lossy()` here was wrong
         // (it silently expanded each invalid byte to U+FFFD = 3 bytes, changing on-disk
         // store directory names). We now build the raw byte sequence via `write_to` and
         // pass it through only when it is already valid UTF-8 — otherwise we surface
@@ -1017,8 +993,6 @@ pub(crate) fn initialize_mini_store() {
     INSTANCE.with(|instance| {
         if instance.get().is_none() {
             let heap = Arena::new();
-            // Zig threads `heap.arena()` into the AST allocator; in Rust
-            // the Bump (`Arena`) is passed by reference.
             let memory_store = bun_ast::ASTMemoryAllocator::new(&heap);
             let mini_store = bun_core::heap::into_raw(Box::new(MiniStore { heap, memory_store }));
             // SAFETY: just allocated, non-null, thread-local exclusive access
@@ -1031,16 +1005,11 @@ pub(crate) fn initialize_mini_store() {
             // SAFETY: pointer was heap-allocated on this thread in the branch above and is
             // never freed; INSTANCE is thread-local and `Cell::get` copies the raw pointer
             // out (no borrow of the Cell is held), so this `&mut` is the sole live reference
-            // to the allocation for its entire scope — no aliasing. Mirrors Zig's
-            // `threadlocal var instance: ?*MiniStore` single-owner deref.
+            // to the allocation for its entire scope — no aliasing.
             let mini_store = unsafe { &mut *instance.get().unwrap() };
-            // PORT NOTE: Zig checked `stack_allocator.fixed_buffer_allocator.end_index >=
-            // buffer.len() - 1` to decide whether to recycle the heap arena. The Rust
             // `ASTMemoryAllocator` collapses SFA+fallback into a single bumpalo arena,
             // so there is no stack-buffer watermark to inspect — `reset()` already
-            // releases all bump allocations.
-            // Spec checks `stack_allocator.fixed_buffer_allocator.end_index >=
-            // buffer.len() - 1`; the equivalent size gate is
+            // releases all bump allocations. The size gate is
             // `reset_retain_with_limit` — only pay `mi_heap_destroy + mi_heap_new`
             // once accumulated bytes exceed 8 MiB. The `AstAlloc` state stays
             // installed across the re-arm (`push()` without `pop()`), so
@@ -1061,7 +1030,7 @@ pub use bun_install_types::{
     DependencyID, INVALID_DEPENDENCY_ID, INVALID_PACKAGE_ID, PackageID, PackageNameHash,
     TruncatedPackageNameHash,
 };
-// Phase-A drafts use the Zig field-style lowercase names; alias both spellings.
+// Phase-A drafts use the field-style lowercase names; alias both spellings.
 pub(crate) const invalid_package_id: PackageID = INVALID_PACKAGE_ID;
 pub(crate) const invalid_dependency_id: DependencyID = INVALID_DEPENDENCY_ID;
 pub const bun_hash_tag: &[u8] = BUN_HASH_TAG;
@@ -1082,8 +1051,8 @@ impl Aligner {
     }
 
     /// Runtime-alignment variant of [`Aligner::write`] for call sites that
-    /// compute `align_of::<T>()` at the caller (Zig passed `comptime Type`;
-    /// Rust callers without a nameable `T` pass the alignment as a value).
+    /// compute `align_of::<T>()` at the caller (callers without a nameable
+    /// `T` pass the alignment as a value).
     pub(crate) fn write_with_align<W: bun_io::Write>(
         align: usize,
         writer: &mut W,
@@ -1105,7 +1074,6 @@ impl Aligner {
 
     #[inline]
     pub(crate) fn skip_amount_with_align(align: usize, pos: usize) -> usize {
-        // std.mem.alignForward(usize, pos, align) - pos
         pos.next_multiple_of(align) - pos
     }
 }
@@ -1142,12 +1110,10 @@ pub struct ExtractData {
     pub integrity: Integrity,
 }
 
-/// Port of `DependencyInstallContext` (src/install/install.zig:213). Zig stores
-/// `path: std.array_list.Managed(u8) = .init(bun.default_allocator)` — an
-/// owned, growable buffer. Earlier port modelled this as a borrowed `*const
-/// [u8]` raw slice with `Copy` semantics, which broke ownership: Zig callers
-/// push into this buffer; the raw-ptr version cannot grow and aliases caller
-/// memory with no lifetime. Own the buffer.
+/// `path` is an owned, growable buffer. An earlier draft modelled it as a
+/// borrowed `*const [u8]` raw slice with `Copy` semantics, which broke
+/// ownership: callers push into this buffer; the raw-ptr version cannot grow
+/// and aliases caller memory with no lifetime. Own the buffer.
 #[derive(Clone, Default)]
 pub struct DependencyInstallContext {
     pub tree_id: lockfile::tree::Id,
@@ -1183,5 +1149,3 @@ pub(crate) enum PackageManifestError {
 bun_core::impl_tag_error!(PackageManifestError);
 
 bun_core::named_error_set!(PackageManifestError);
-
-// ported from: src/install/install.zig
diff --git a/src/install/lifecycle_script_runner.rs b/src/install/lifecycle_script_runner.rs
index 3d44a4562d0..7cd18648678 100644
--- a/src/install/lifecycle_script_runner.rs
+++ b/src/install/lifecycle_script_runner.rs
@@ -21,7 +21,7 @@ use bun_spawn::SpawnResultExt as _;
 use bun_spawn::{Process, ProcessExit, ProcessExitKind, Rusage, SpawnOptions, Status};
 #[cfg(unix)]
 use bun_sys::Fd;
-// PORT NOTE: `BufferedReaderParent::loop_` is typed `*mut bun_uws::Loop` (the
+// `BufferedReaderParent::loop_` is typed `*mut bun_uws::Loop` (the
 // `bun_io::Loop` is the trait's nominal: `us_loop_t` on POSIX, `uv_loop_t`
 // on Windows. `AnyEventLoop::native_loop()` projects through the uws wrapper
 // (`WindowsLoop::uv_loop`) on Windows so both paths hand back the same shape
@@ -43,10 +43,8 @@ const BUN_BIN_NAME: &[u8] = if cfg!(debug_assertions) {
 // `BUN_BIN_NAME ++ " run"` / `" x "` — kept as separate writes below since
 // const byte concat is awkward in Rust.
 
-/// Yarn built-in subcommands (union of v1 + v2.3 sets).
-/// Port of `src/cli/list-of-yarn-commands.zig::all_yarn_commands` (deduped).
-// PERF(port): Zig used `bun.ComptimeStringMap(void, .{...})` (length-bucketed,
-// comptime-sorted). The Rust `comptime_string_map!` macro currently returns a
+/// Yarn built-in subcommands (union of v1 + v2.3 sets, deduped).
+// PERF: the `comptime_string_map!` macro currently returns a
 // Lazy with inferred const generics that can't be named in a `static` item, so
 // use a sorted slice + binary_search for now. ~50 entries → <7 comparisons.
 struct YarnCommands;
@@ -119,8 +117,6 @@ impl YarnCommands {
 /// / `bun x` so that lifecycle scripts re-enter Bun instead of spawning
 /// another package manager.
 ///
-/// Port of `RunCommand.replacePackageManagerRun` (src/cli/run_command.zig).
-///
 /// `#[cold]`: only reached when actually executing a package.json script /
 /// lifecycle script — never on plain `bun foo.js` startup. Forcing it into
 /// `.text.unlikely.*` keeps the byte-scanning loop out of the hot
@@ -260,20 +256,19 @@ pub struct LifecycleScriptSubprocess<'a> {
     pub current_script_index: u8,
 
     pub remaining_fds: i8,
-    /// Zig: `?*Process`. `Process` is intrusively ref-counted (`bun_ptr::ThreadSafeRefCount`),
+    /// `Process` is intrusively ref-counted (`bun_ptr::ThreadSafeRefCount`),
     /// so it lives behind a raw pointer and is dropped via `process.close(); process.deref()`
-    /// in `reset_polls` (mirrors Zig `process.close(); process.deref();`). Null = none.
+    /// in `reset_polls`. Null = none.
     pub process: *mut Process,
     pub stdout: OutputReader,
     pub stderr: OutputReader,
     pub has_called_process_exit: bool,
-    /// Zig: `manager: *PackageManager`. Stored as `BackRef` (not `&'a`) so
+    /// Stored as `BackRef` (not `&'a`) so
     /// callbacks may mutate manager state (`active_lifecycle_scripts`,
     /// `progress`, `scripts_node`) through the long-lived backref without
     /// asserting unique-borrow over the whole `PackageManager`.
     pub manager: bun_ptr::BackRef<PackageManager>,
-    /// Zig: `envp: [:null]?[*:0]const u8` — allocated with `manager.allocator`
-    /// (manager-lifetime) and never freed there. Ownership is moved into this
+    /// Owned by this
     /// struct so the `K=V\0` buffers stay alive across every async
     /// `spawn_next_script` for the script chain; freed by `Drop`/`destroy`.
     pub envp: bun_dotenv::NullDelimitedEnvMap,
@@ -294,7 +289,7 @@ pub struct LifecycleScriptSubprocess<'a> {
 
 pub struct InstallCtx<'a> {
     pub entry_id: entry::Id,
-    /// Zig: `installer: *Installer`. Raw `*mut` for the same reason as
+    /// Raw `*mut` for the same reason as
     /// `LifecycleScriptSubprocess::manager` — `on_task_complete`/`start_task`
     /// mutate Installer state from inside an exit-handler callback.
     pub installer: *mut Installer<'a>,
@@ -316,10 +311,9 @@ impl<'a> InstallCtx<'a> {
     }
 }
 
-// PORT NOTE: Zig's `Intrusive(T, Context, less)` takes the comparator as a comptime
-// fn-pointer. The Rust `io_heap::Intrusive` folds it into `HeapContext::less` on the
-// `Context` type instead, so `sort_by_started_at` is provided via a trait impl on a
-// ZST `StartedAtCtx` (the Zig context arg `*PackageManager` is unused by `less`).
+// `io_heap::Intrusive` takes the comparator via `HeapContext::less` on the
+// `Context` type, so `sort_by_started_at` is provided via a trait impl on a
+// ZST `StartedAtCtx`.
 #[derive(Default, Clone, Copy)]
 pub struct StartedAtCtx;
 pub type List<'a> = io_heap::Intrusive<LifecycleScriptSubprocess<'a>, StartedAtCtx>;
@@ -349,7 +343,7 @@ pub(crate) const MIN_MILLISECONDS_TO_LOG: u64 = 500;
 pub(crate) static ALIVE_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 impl<'a> LifecycleScriptSubprocess<'a> {
-    /// Zig: `LifecycleScriptSubprocess.alive_count` static decl. Returns the
+    /// Returns the
     /// global atomic so callers can write
     /// `LifecycleScriptSubprocess::alive_count().load(..)`.
     #[inline]
@@ -366,23 +360,23 @@ pub type OutputReader = BufferedReader;
 pub(crate) type Timer = bun_core::time::Timer;
 
 impl<'a> LifecycleScriptSubprocess<'a> {
-    /// `bun.TrivialNew(@This())` — heap-allocate and return a raw pointer; this type is
-    /// intrusive (heap field, OutputReader parent backrefs), so it lives behind `*mut Self`.
+    /// Heap-allocate and return a raw pointer; this type is intrusive (heap field,
+    /// OutputReader parent backrefs), so it lives behind `*mut Self`.
     pub fn new(init: Self) -> *mut Self {
         bun_core::heap::into_raw(Box::new(init))
     }
 
     #[inline]
     fn manager(&self) -> &PackageManager {
-        // `manager` is non-null and outlives every subprocess (Zig
-        // `*PackageManager` is the singleton install-loop owner).
+        // `manager` is non-null and outlives every subprocess (the
+        // `PackageManager` is the singleton install-loop owner).
         self.manager.get()
     }
 
     /// # Safety
-    /// See [`Self::manager`]. Mutable access is sound because Zig's
-    /// `*PackageManager` is a non-exclusive pointer; no `&PackageManager`
-    /// outlives the brief field accesses below on the install thread.
+    /// See [`Self::manager`]. Mutable access is sound because callers run on
+    /// the single install thread and no `&PackageManager`
+    /// outlives the brief field accesses below.
     #[inline]
     unsafe fn manager_mut(&mut self) -> &mut PackageManager {
         // SAFETY: see fn doc.
@@ -452,8 +446,8 @@ impl<'a> LifecycleScriptSubprocess<'a> {
             let flags = bun_sys::get_fcntl_flags(fd).expect("Failed to get fcntl flags");
             debug_assert!(flags & bun_sys::O::NONBLOCK as isize != 0);
 
-            let _stat = bun_sys::fstat(fd).expect("Failed to fstat");
-            // TODO(port): `bun.S.ISSOCK(stat.mode)` once bun_sys exposes `S::ISSOCK`.
+            let stat = bun_sys::fstat(fd).expect("Failed to fstat");
+            debug_assert!(bun_sys::S::ISSOCK(stat.st_mode as _));
         }
         let _ = fd;
     }
@@ -498,7 +492,6 @@ impl<'a> LifecycleScriptSubprocess<'a> {
         this: *mut Self,
         next_script_index: u8,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         bun_core::analytics::Features::LIFECYCLE_SCRIPTS.fetch_add(1, Ordering::Relaxed);
 
         // SAFETY: `this` is non-null and uniquely accessed (caller contract).
@@ -511,11 +504,9 @@ impl<'a> LifecycleScriptSubprocess<'a> {
             }
         }
 
-        // errdefer { decrement alive_count; ensure_not_in_heap }
-        // PORT NOTE: Zig's `errdefer` is modeled by splitting the fallible body into
-        // `spawn_next_script_inner` and running the cleanup on the error branch. Both
-        // functions take the allocation-rooted `*mut Self` (mirroring Zig's
-        // `*LifecycleScriptSubprocess` receiver) so that backrefs stored into the
+        // The fallible body is split into
+        // `spawn_next_script_inner` with the cleanup running on the error branch. Both
+        // functions take the allocation-rooted `*mut Self` so that backrefs stored into the
         // readers / intrusive heap / process exit handler retain valid Stacked Borrows
         // provenance after we return — deriving them from a `&mut self` reborrow would
         // leave dead tags once that borrow is popped by subsequent `self` uses, and the
@@ -619,10 +610,7 @@ impl<'a> LifecycleScriptSubprocess<'a> {
                 core::mem::size_of::<[*const c_char; 4]>() == 4 * core::mem::size_of::<usize>()
             );
 
-            // PORT NOTE / OWNERSHIP: Zig allocates the libuv pipes
-            // (`bun.new(uv.Pipe, zeroes)`), stashes the *non-owning* `*uv.Pipe`
-            // in `this.stdout.source.?.pipe`, and reuses the same heap pointer for
-            // `SpawnOptions.{stdout,stderr} = .{ .buffer = pipe }`. In Rust,
+            // OWNERSHIP:
             // `bun_io::Source::Pipe` owns a `Box<uv::Pipe>` AND
             // `spawn_process_windows` does `heap::take(ptr)` on the
             // `Stdio::Buffer` pointer to produce a SECOND `Box<uv::Pipe>` in
@@ -715,11 +703,9 @@ impl<'a> LifecycleScriptSubprocess<'a> {
                         // stays with the caller. `WindowsStdio` has no `Drop`, so reclaim
                         // and `uv_close`+free them explicitly here — otherwise the heap
                         // `uv::Pipe`s leak (and, if already `uv_pipe_init`'d, remain
-                        // linked in the libuv loop's handle queue forever). Zig avoided
-                        // this by stashing the pipes in `this.{stdout,stderr}.source`
-                        // BEFORE building `SpawnOptions` (lifecycle_script_runner.zig:190);
-                        // the Rust ordering moved allocation inline (see PORT NOTE above)
-                        // and must therefore handle the error path explicitly.
+                        // linked in the libuv loop's handle queue forever). Allocation
+                        // happens inline (see OWNERSHIP note above), so the error
+                        // path must be handled explicitly.
                         let mut spawn_options = spawn_options;
                         spawn_options.stdout.deinit();
                         spawn_options.stderr.deinit();
@@ -818,12 +804,12 @@ impl<'a> LifecycleScriptSubprocess<'a> {
     pub fn print_output(&mut self) {
         if !self.manager().options.log_level.is_verbose() {
             // Reuse the memory
-            // PORT NOTE: reshaped for borrowck — Zig evaluated all three clauses
-            // (`stdout.len==0 && stdout.cap>0 && stderr.buffer().cap==0`) before
-            // the swap, holding two `*ArrayList(u8)` simultaneously. Evaluate
+            // Reshaped for borrowck — evaluate
             // the stderr-capacity check first (immutable), then take the
             // disjoint `stdout` mutable borrow, so `core::mem::take` only fires
-            // when the full Zig guard would — otherwise stdout's buffer is left
+            // when all three clauses
+            // (`stdout.len==0 && stdout.cap>0 && stderr.buffer().cap==0`)
+            // hold — otherwise stdout's buffer is left
             // in place for the `stdout.items.len +| stderr.items.len` check.
             if self.stderr.buffer().capacity() == 0 {
                 let stdout = self.stdout.final_buffer();
@@ -922,19 +908,15 @@ impl<'a> LifecycleScriptSubprocess<'a> {
                     } else {
                         // .monotonic because this is what `completeOne` does. This is the same
                         // as `completeOne` but doesn't update the parent.
-                        // TODO(port): Zig used `@atomicRmw(usize, &node.unprotected_completed_items, .Add, 1, .monotonic)`;
-                        // the stub `bun_progress::Node` is non-atomic & has no parent, so the
-                        // detached-parent path collapses to `complete_one()` until the real
-                        // `std.Progress` port lands.
-                        scripts_node.complete_one();
+                        scripts_node
+                            .unprotected_completed_items
+                            .fetch_add(1, Ordering::Relaxed);
                     }
                 }
 
                 if let Some(nanos) = maybe_duration {
                     if nanos > MIN_MILLISECONDS_TO_LOG * bun_core::time::NS_PER_MS {
-                        // PORT NOTE: Zig passed `manager.lockfile.allocator`; allocator param
-                        // dropped per §Allocators (non-AST crate). Zig borrowed the lockfile
-                        // string buffer for `package_name`; we own a `Box<[u8]>` that drops on
+                        // `package_name` is a `Box<[u8]>` that drops on
                         // `destroy`, so the log entry takes its own owned copy.
                         let entry = LifecycleScriptTimeLogEntry {
                             package_name: self.package_name.clone(),
@@ -1035,8 +1017,7 @@ impl<'a> LifecycleScriptSubprocess<'a> {
 
                 // `Status::signal_code()` range-checks 1..=31 (`bun_core::SignalCode` is
                 // exhaustive); RT signals (>31) fall back to SIGTERM so the diverging
-                // `raise_ignoring_panic_handler` path is preserved. Zig's `SignalCode` is a
-                // non-exhaustive `enum(u8)` so it had no such constraint.
+                // `raise_ignoring_panic_handler` path is preserved.
                 Global::raise_ignoring_panic_handler(
                     Status::Signaled(signal)
                         .signal_code()
@@ -1120,7 +1101,7 @@ impl<'a> LifecycleScriptSubprocess<'a> {
     pub unsafe fn destroy(this: *mut Self) {
         // SAFETY: caller contract — `this` came from `heap::alloc` in `Self::new` and is
         // uniquely owned here. Dropping the Box runs `Drop` (reset_polls + ensure_not_in_heap)
-        // then frees the allocation (Zig: `this.* = undefined; bun.destroy(this);`).
+        // then frees the allocation.
         drop(unsafe { bun_core::heap::take(this) });
     }
 
@@ -1137,8 +1118,7 @@ impl<'a> LifecycleScriptSubprocess<'a> {
                 break 'try_delete_dir;
             };
             let basename = bun_paths::basename(self.scripts.cwd.as_bytes());
-            // PORT NOTE: Zig (lifecycle_script_runner.zig:533-534) leaks this fd
-            // too — fixed here since this path returns to the install loop without
+            // Close this fd: this path returns to the install loop without
             // exiting, so the HANDLE/fd would otherwise persist for the rest of
             // the install on every failed optional-dependency lifecycle script.
             let Ok(dir) = bun_sys::Dir::open(dirname) else {
@@ -1161,7 +1141,6 @@ impl<'a> LifecycleScriptSubprocess<'a> {
         foreground: bool,
         ctx: Option<InstallCtx<'a>>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let package_name = list.package_name.clone();
         let lifecycle_subprocess = Self::new(LifecycleScriptSubprocess {
             manager: bun_ptr::BackRef::new_mut(manager),
@@ -1251,7 +1230,7 @@ bun_spawn::link_impl_ProcessExit! {
 // `on_reader_done`/`on_reader_error` via the type-erased vtable.
 // ──────────────────────────────────────────────────────────────────────────
 
-// Zig: no `onReadChunk` decl — output is consumed only in `final_buffer`.
+// No `on_read_chunk` — output is consumed only in `final_buffer`.
 // `manager.event_loop` is an `AnyEventLoop`; convert through
 // `EventLoopHandle::from_any` so the by-value `EventLoopCtx` carries the right
 // `kind`.
@@ -1274,5 +1253,3 @@ impl Drop for LifecycleScriptSubprocess<'_> {
         unsafe { Self::ensure_not_in_heap(std::ptr::from_mut::<Self>(self)) };
     }
 }
-
-// ported from: src/install/lifecycle_script_runner.zig
diff --git a/src/install/lockfile.rs b/src/install/lockfile.rs
index 8bf1175ef33..7bf934cf81e 100644
--- a/src/install/lockfile.rs
+++ b/src/install/lockfile.rs
@@ -1,6 +1,4 @@
 //! Lockfile — in-memory representation of bun.lock / bun.lockb
-//!
-//! Ported from src/install/lockfile.zig
 
 use core::cmp::Ordering;
 use core::fmt;
@@ -43,8 +41,8 @@ use crate::{
 };
 
 // ────────────────────────────────────────────────────────────────────────────
-// Sub-module declarations — Zig basenames preserved per PORTING.md, hence
-// explicit #[path] attrs for PascalCase / dotted file names.
+// Sub-module declarations — explicit #[path] attrs for PascalCase / dotted
+// file names.
 // ────────────────────────────────────────────────────────────────────────────
 
 #[path = "lockfile/Buffers.rs"]
@@ -85,9 +83,7 @@ pub use crate::padding_checker::assert_no_uninitialized_padding;
 // `MultiArrayList<Package>`, `PackageColumns` for `Slice<Package>`) into scope.
 use self::package::PackageColumns as _;
 
-// Zig path-style associated types (`Dependency.Version`, `Resolution.Tag`,
-// `String.Buf`/`String.Builder`) are module-level types in the Rust port.
-// Alias them locally so the body reads like the spec.
+// Local aliases for module-level types.
 type DependencyVersion = dependency::Version;
 type ResolutionTag = resolution::Tag;
 type SemverStringBuf<'a> = bun_semver::semver_string::Buf<'a>;
@@ -120,15 +116,13 @@ pub(crate) type PatchedDependenciesMap =
     ArrayHashMap<PackageNameAndVersionHash, PatchedDep, ArrayIdentityContextU64>;
 
 pub(crate) type StringPool = bun_semver::string::StringPool;
-// Zig: `String.Builder.StringPool` — `bun_semver::semver_string::StringPool`.
 
 pub(crate) type MetaHash = [u8; 32]; // Sha512T256.digest_length
 pub(crate) const ZERO_HASH: MetaHash = [0u8; 32];
 
 /// Result of `maybe_clone_filtering_root_packages`: either the input lockfile was
 /// returned unchanged (borrowed), or a freshly-allocated cleaned lockfile is returned
-/// (owned). Spec lockfile.zig returns a `*Lockfile` in both cases; Rust distinguishes
-/// ownership so the caller can drop the `Box` when done.
+/// (owned), so the caller can drop the `Box` when done.
 pub enum Cleaned<'a> {
     /// No changes needed — caller's lockfile is returned as-is.
     Same(&'a mut Lockfile),
@@ -136,19 +130,20 @@ pub enum Cleaned<'a> {
     New(Box<Lockfile>),
 }
 
-// TODO(port): std.io.FixedBufferStream([]u8) — replace with cursor over &mut [u8]
+// The stream owns its backing `Vec<u8>` — every load path hands the file
+// contents to the stream anyway,
+// which avoids threading a `&mut [u8]` lifetime through the load call graph.
 pub type Stream = bun_io::FixedBufferStream<Vec<u8>>;
 
 /// Duck-typed surface that `Buffers::write_array`/`save` and
-/// `Package::Serializer::save` expect of their `stream` parameter — Zig passes
-/// `anytype` (lockfile/Buffers.zig:142, bun.lockb.zig). Expressed as a trait so
-/// the Rust port can stay generic over the borrowck-reshaped `StreamType` in
+/// `Package::Serializer::save` expect of their `stream` parameter. Expressed
+/// as a trait to stay generic over the borrowck-reshaped `StreamType` in
 /// `bun.lockb.rs` (which collapses stream + writer into one `&mut`).
 pub trait PositionalStream {
-    /// Zig: `try stream.getPos()` — current write position.
+    /// Current write position.
     fn get_pos(&self) -> Result<usize, BunError>;
-    /// Zig: `stream.pwrite(bytes, index)` — positional write, returns bytes
-    /// written (always `data.len()` for in-memory buffers).
+    /// Positional write — returns bytes written (always `data.len()` for
+    /// in-memory buffers).
     fn pwrite(&mut self, data: &[u8], index: usize) -> usize;
 }
 
@@ -182,7 +177,6 @@ pub struct Lockfile {
     /// Not for iterating.
     pub package_index: PackageIndexMap,
     pub string_pool: StringPool,
-    // std.mem.Allocator param — dropped per PORTING.md (global mimalloc)
     pub scratch: Scratch,
 
     pub scripts: Scripts,
@@ -221,7 +215,6 @@ pub struct Lockfile {
     pub exact_pinned: DynamicBitSet,
 }
 
-/// Zig: `Lockfile.Package.List` — `MultiArrayList(Package)`.
 pub(crate) type PackageList = self::package::List<u64>;
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -275,8 +268,7 @@ impl Scripts {
         "postprepare",
     ];
 
-    /// Indexed mutable access matching `NAMES` order — replaces Zig
-    /// `@field(lockfile.scripts, Lockfile.Scripts.names[i])`.
+    /// Indexed mutable access matching `NAMES` order.
     pub fn hook_mut(&mut self, i: usize) -> &mut Vec<Box<[u8]>> {
         match i {
             0 => &mut self.preinstall,
@@ -290,7 +282,7 @@ impl Scripts {
     }
 
     /// (name, &entries) in `NAMES` order — single source of truth for the name half.
-    /// Rust has no `@field(self, name)`; the field-ref half stays hand-listed,
+    /// The field-ref half stays hand-listed (no field-by-name reflection),
     /// but the string half is derived from `NAMES` so the literals exist exactly once.
     fn fields(&self) -> [(&'static str, &Vec<Box<[u8]>>); 6] {
         [
@@ -466,7 +458,6 @@ impl<'a> LoadResult<'a> {
         }
     }
 
-    // Zig: `load_lockfile.ok` field projection (src/install/lockfile.zig).
     // Callers reach this only after `handleLoadLockfileErrors` has exited on
     // the `NotFound`/`Err` arms, so the variant is known-`Ok`.
     bun_core::enum_unwrap!(pub LoadResult, Ok => fn ok / ok_mut -> LoadResultOk<'a>);
@@ -497,11 +488,9 @@ impl Lockfile {
     pub fn load_from_dir<'a, const ATTEMPT_LOADING_FROM_OTHER_LOCKFILE: bool>(
         &'a mut self,
         dir: Fd,
-        manager: Option<&mut PackageManager>,
+        mut manager: Option<&mut PackageManager>,
         log: &mut bun_ast::Log,
     ) -> LoadResult<'a> {
-        // Zig: `bun.assert(FileSystem.instance_loaded);`
-        // SAFETY: read of a process-global flag; matches Zig's bare global read.
         debug_assert!(Fs::INSTANCE_LOADED.load(core::sync::atomic::Ordering::Relaxed));
 
         let mut lockfile_format = LockfileFormat::Text;
@@ -534,9 +523,7 @@ impl Lockfile {
 
                             if ATTEMPT_LOADING_FROM_OTHER_LOCKFILE {
                                 if let Some(pm) = manager {
-                                    // Zig assigns `lockfile_format = .text` on `.ok` here,
-                                    // but the local is dead past `return migrate_result` —
-                                    // the format is carried inside the `LoadResult` itself.
+                                    // The format is carried inside the `LoadResult` itself.
                                     return migration::detect_and_load_other_lockfile(
                                         self, dir, pm, log,
                                     );
@@ -550,8 +537,7 @@ impl Lockfile {
             }
         };
 
-        // Zig: `file.readToEnd(allocator).unwrap() catch |err| ...`.
-        // The live `bun_sys::File::read_to_end` returns `Maybe<Vec<u8>>`
+        // `bun_sys::File::read_to_end` returns `Maybe<Vec<u8>>`
         // (fstat-presized, pread-from-0); map the error arm to `.read_file`.
         let buf = match file.read_to_end() {
             Ok(bytes) => bytes,
@@ -610,16 +596,70 @@ impl Lockfile {
             });
         }
 
-        // TODO(port): borrowck — `self` is reborrowed inside `result` via &'a mut Lockfile.
-        // PORT NOTE: reshaped for borrowck — the debug round-trip block below mutates `self`
-        // through `result.ok.lockfile` which already holds the &mut. The `BUN_DEBUG_TEST_
-        // TEXT_LOCKFILE` round-trip path (lockfile.zig:364-406) needs simultaneous access
-        // to `manager` (already moved into the call above for `Option<&mut PackageManager>`)
-        // and the `&mut Lockfile` inside `result`. Restoring it requires the
-        // `manager.as_deref_mut()` reborrow which today's `Option<&mut PackageManager>`
-        // surface forbids. Until reconciler-6, the debug round-trip is omitted.
-        // TODO(port): re-enable BUN_DEBUG_TEST_TEXT_LOCKFILE round-trip once borrowck reshape lands.
-        self.load_from_bytes(manager, buf, log)
+        let mut result = self.load_from_bytes(manager.as_deref_mut(), buf, log);
+
+        // When BUN_DEBUG_TEST_TEXT_LOCKFILE is set, convert
+        // the freshly loaded binary lockfile into a text lockfile in memory,
+        // then parse it back into a binary lockfile, so the two codepaths
+        // cross-check each other in tests.
+        if bun_core::env_var::BUN_DEBUG_TEST_TEXT_LOCKFILE
+            .get()
+            .unwrap_or(false)
+        {
+            if let (LoadResult::Ok(ok), Some(manager)) = (&mut result, manager) {
+                let mut writer_buf: Vec<u8> = Vec::new();
+                // `save_from_binary` reads only `loaded_from_binary_lockfile()`
+                // from its `load_result` parameter. `result` itself cannot be
+                // passed while `ok.lockfile` is mutably borrowed, so hand it
+                // a stand-in that answers
+                // `format == Binary` the same way the real `Ok` result does.
+                let binary_origin = LoadResult::Err(LoadResultErr {
+                    step: LoadStep::ParseFile,
+                    value: err!("DebugTextLockfileRoundTrip"),
+                    lockfile_path: zstr!("bun.lockb"),
+                    format: LockfileFormat::Binary,
+                });
+                if let Err(e) = TextLockfile::Stringifier::save_from_binary(
+                    &mut *ok.lockfile,
+                    &binary_origin,
+                    &manager.options,
+                    &mut writer_buf,
+                ) {
+                    Output::panic(format_args!(
+                        "failed to convert binary lockfile to text lockfile: {}",
+                        e.name()
+                    ));
+                }
+
+                let source = bun_ast::Source::init_path_string(b"bun.lock", writer_buf.as_slice());
+                initialize_store();
+                let bump = bun_alloc::Arena::new();
+                let json = match JSON::parse_package_json_utf8(&source, log, &bump) {
+                    Ok(j) => j,
+                    Err(e) => Output::panic(format_args!(
+                        "failed to print valid json from binary lockfile: {}",
+                        e.name()
+                    )),
+                };
+
+                if let Err(e) = TextLockfile::parse_into_binary_lockfile(
+                    &mut *ok.lockfile,
+                    json,
+                    &source,
+                    log,
+                    Some(manager),
+                ) {
+                    Output::panic(format_args!(
+                        "failed to parse text lockfile converted from binary lockfile: {}",
+                        <&'static str>::from(e)
+                    ));
+                }
+
+                bun_core::analytics::Features::text_lockfile_inc();
+            }
+        }
+
+        result
     }
 
     pub fn load_from_bytes<'a>(
@@ -696,13 +736,12 @@ impl Lockfile {
         exact_versions: bool,
         log_level: LogLevel,
     ) -> Result<Cleaned<'a>, BunError> {
-        // TODO(port): narrow error set
         let old_packages = old.packages.slice();
         let old_dependencies_lists = old_packages.items_dependencies();
         let old_resolutions_lists = old_packages.items_resolutions();
         let old_resolutions = old_packages.items_resolution();
         let mut any_changes = false;
-        let end: PackageID = old.packages.len() as PackageID; // @truncate
+        let end: PackageID = old.packages.len() as PackageID;
 
         // set all disabled dependencies of workspaces to `invalid_package_id`
         for package_id in 0..end as usize {
@@ -747,7 +786,6 @@ impl Lockfile {
         updates: &mut [UpdateRequest],
         exact_versions: bool,
     ) -> Result<(), BunError> {
-        // TODO(port): narrow error set
         let workspace_package_id = manager
             .root_package_id
             .get(old, manager.workspace_name_hash);
@@ -755,7 +793,7 @@ impl Lockfile {
             old.packages.items_dependencies()[workspace_package_id as usize];
 
         if (root_deps_list.off as usize) < old.buffers.dependencies.len() {
-            // PORT NOTE: split-borrow — `string_builder!` only takes
+            // Split-borrow: `string_builder!` only takes
             // `old.buffers.string_bytes` + `old.string_pool`, leaving
             // `old.packages` / `old.buffers.{dependencies,resolutions}` free.
             let mut string_builder = string_builder!(old);
@@ -787,8 +825,6 @@ impl Lockfile {
 
                                 // TODO(dylan-conway): this will need to handle updating dependencies (exact, ^, or ~) and aliases
 
-                                // PORT NOTE: Zig's `switch (exact_versions) { else => |exact| ... }` is just a
-                                // way to capture a comptime-ish bool; in Rust we use it directly.
                                 let npm_ver = res.npm().version;
                                 let len = bun_core::fmt::count(format_args!(
                                     "{}{}",
@@ -806,8 +842,8 @@ impl Lockfile {
             }
 
             string_builder.allocate()?;
-            // Spec lockfile.zig:507 is `defer string_builder.clamp();` — runs once after the
-            // entire second loop completes. A scopeguard would mutably capture
+            // `string_builder.clamp()` must run once after the entire second
+            // loop completes. A scopeguard would mutably capture
             // `string_builder`, conflicting with the `append` calls below. Call `clamp()`
             // explicitly at the end of this block instead (the inner loop has no `?` exits;
             // the only fallible call above is `allocate()`, which precedes this point).
@@ -856,7 +892,6 @@ impl Lockfile {
                                     )
                                     .is_err()
                                     {
-                                        // Zig: `catch break` — breaks the inner for-loop.
                                         break;
                                     }
                                     let written = start_len - cursor.len();
@@ -896,7 +931,6 @@ impl Lockfile {
         exact_versions: bool,
         log_level: LogLevel,
     ) -> Result<Box<Lockfile>, BunError> {
-        // TODO(port): narrow error set
         // This is wasteful, but we rarely log anything so it's fine.
         let mut log = bun_ast::Log::init();
         // defer { for (...) item.deinit(); log.deinit(); } — handled by Drop
@@ -922,7 +956,7 @@ impl Lockfile {
 
     /// Is this a direct dependency of the workspace the install is taking place in?
     pub fn is_root_dependency(&self, manager: &mut PackageManager, id: DependencyID) -> bool {
-        // Zig: `manager: *PackageManager` — `RootPackageId::get` caches into `manager`.
+        // `RootPackageId::get` caches into `manager`.
         let root_id = manager
             .root_package_id
             .get(self, manager.workspace_name_hash);
@@ -1001,13 +1035,9 @@ impl Lockfile {
         exact_versions: bool,
         log_level: LogLevel,
     ) -> Result<Box<Lockfile>, BunError> {
-        // TODO(port): narrow error set
-        // Zig names the receiver `old`; alias `self` so the body reads
-        // identically to the spec (lockfile.zig:637).
         let old: &mut Lockfile = self;
-        // Zig: `var timer: std.time.Timer = undefined;` — model the
-        // uninitialized sentinel with `Option`. Outlined cold: the verbose arm
-        // is debug-only and drags in `Timer`/clock-syscall error formatting.
+        // Outlined cold: the verbose arm is debug-only and drags in
+        // `Timer`/clock-syscall error formatting.
         let timer: Option<Timer> = if log_level.is_verbose() {
             Some(clean_verbose_timer_start()?)
         } else {
@@ -1032,9 +1062,8 @@ impl Lockfile {
             clean_preprocess_update_requests_cold(old, manager, updates, exact_versions)?;
         }
 
-        // Spec lockfile.zig:669: `var new = try old.allocator.create(Lockfile)` — caller owns
-        // and later frees via `deinit`. PORTING.md §Forbidden patterns bans `Box::leak` to
-        // satisfy a lifetime; return `Box<Lockfile>` so Drop reclaims it.
+        // Caller owns the new lockfile; return `Box<Lockfile>` so Drop reclaims
+        // it (never `Box::leak` to satisfy a lifetime).
         let mut new: Box<Lockfile> = Box::default();
         new.string_pool
             .ensure_total_capacity(old.string_pool.capacity())?;
@@ -1045,18 +1074,14 @@ impl Lockfile {
         new.patched_dependencies
             .ensure_total_capacity(old.patched_dependencies.count())?;
 
-        // Zig: `old.scratch.dependency_list_queue.head = 0;` — reset the FIFO read
-        // cursor without discarding capacity. `LinearFifo::head` is private; the
-        // queue is always drained to empty before reuse here, so a `discard(count)`
-        // resets `head` to 0 with the same observable effect (lockfile.zig:681).
+        // Reset the FIFO read cursor without discarding capacity.
+        // `LinearFifo::head` is private; the queue is always drained to empty
+        // before reuse here, so a `discard(count)` resets `head` to 0.
         let queued = old.scratch.dependency_list_queue.readable_length();
         old.scratch.dependency_list_queue.discard(queued);
 
         {
-            // PORT NOTE: reshaped for borrowck. Zig holds `&old.overrides` /
-            // `&old.catalogs` while also passing `*Lockfile old` and
-            // `*Lockfile new` (the latter aliased again inside `builder`).
-            // The Rust signatures take `&Lockfile` for `old` and read `new`
+            // The signatures take `&Lockfile` for `old` and read `new`
             // through `builder.lockfile`, so the only conflict left is the
             // field-assign on `new.*` while `builder` borrows `new` — store
             // the results in temps and assign after `builder` drops.
@@ -1074,7 +1099,7 @@ impl Lockfile {
 
         let mut package_id_mapping = vec![invalid_package_id; old.packages.len()];
         let clone_queue_ = PendingResolutions::new();
-        // PORT NOTE: explicit `&mut *` reborrows so `old`/`manager`/`new` are
+        // Explicit `&mut *` reborrows so `old`/`manager`/`new` are
         // released back to this scope once `cloner` is dropped.
         let mut cloner = Cloner {
             old: &mut *old,
@@ -1091,7 +1116,7 @@ impl Lockfile {
         // try clone_queue.ensureUnusedCapacity(root.dependencies.len);
         let _ = root.clone(&mut cloner)?;
 
-        // PORT NOTE: between here and `cloner.flush()`, `old`/`new`/`manager`
+        // Between here and `cloner.flush()`, `old`/`new`/`manager`
         // are live inside `cloner`. Reach them via `cloner.old` /
         // `cloner.lockfile` so borrowck sees disjoint field paths.
         {
@@ -1109,10 +1134,9 @@ impl Lockfile {
                 let mut workspace_paths_builder = string_builder!(new);
 
                 // Sort by name for determinism
-                // PORT NOTE: Zig defines a local `WorkspacePathSorter` struct; in Rust we use a closure.
                 {
                     let string_buf = old.buffers.string_bytes.as_slice();
-                    // `ArrayHashMap::sort` mirrors Zig's `entries.sort(ctx)` —
+                    // `ArrayHashMap::sort` comparator is
                     // `(keys, values, a, b) -> bool` (less-than).
                     old.workspace_paths.sort(|_keys, values, a, b| {
                         let left = values[a];
@@ -1135,7 +1159,7 @@ impl Lockfile {
 
                 // SAFETY: capacity reserved by `ensure_total_capacity` above; every
                 // slot in `0..old.count()` is overwritten by the copy/zip loops below
-                // before `re_index()` reads them. Mirrors Zig `entries.len = n`.
+                // before `re_index()` reads them.
                 unsafe {
                     new.workspace_paths
                         .set_entries_len(old.workspace_paths.count())
@@ -1161,7 +1185,7 @@ impl Lockfile {
                 new.workspace_versions
                     .ensure_total_capacity(old.workspace_versions.count())?;
                 // SAFETY: capacity reserved immediately above; every slot is filled by
-                // the zip loop below before `re_index()`. Mirrors Zig `entries.len = n`.
+                // the zip loop below before `re_index()`.
                 unsafe {
                     new.workspace_versions
                         .set_entries_len(old.workspace_versions.count())
@@ -1328,8 +1352,8 @@ impl<'a> fmt::Display for MetaHashFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let remain: &[u8] = &self.meta_hash[..];
 
-        // {X}-{x}-{X}-{x} — Zig's `{X}` on a slice prints uppercase hex, `{x}` lowercase.
-        // TODO(port): verify byte-slice hex formatting matches Zig std.fmt exactly.
+        // Alternating uppercase/lowercase hex groups; `HexBytes` emits two
+        // digits per byte, contiguous, no separators.
         write!(
             f,
             "{}-{}-{}-{}",
@@ -1434,9 +1458,8 @@ impl Lockfile {
     pub fn hoist<const METHOD: tree::BuilderMethod>(
         &mut self,
         log: &mut bun_ast::Log,
-        // PORT NOTE: Zig used `comptime method` to make these params `void` for
-        // non-`.filter` builds. `tree::Builder` stores them unconditionally
-        // (Option/slice), so accept the concrete shapes for all `METHOD`s.
+        // `tree::Builder` stores these unconditionally (Option/slice), so
+        // accept the concrete shapes for all `METHOD`s.
         manager: Option<&PackageManager>,
         install_root_dependencies: bool,
         workspace_filters: &[WorkspaceFilter],
@@ -1444,7 +1467,7 @@ impl Lockfile {
     ) -> Result<(), tree::SubtreeError> {
         let slice = self.packages.slice();
 
-        // PORT NOTE: `tree::Builder` stores `lockfile: ParentRef<Lockfile>` so
+        // `tree::Builder` stores `lockfile: ParentRef<Lockfile>` so
         // the `&mut buffers.resolutions` split-borrow below can coexist with
         // the read-only lockfile view inside the builder (see Tree.rs note).
         // `ParentRef::new` captures `SharedReadOnly` provenance from `&*self`,
@@ -1466,17 +1489,18 @@ impl Lockfile {
             list: Default::default(),
             sort_buf: Default::default(),
         };
-        // TODO(port): Tree::Builder field set may differ; verify against the Zig.
 
         Tree::default().process_subtree(tree::ROOT_DEP_ID, tree::INVALID_ID, &mut builder)?;
 
         // This goes breadth-first
         while let Some(item) = builder.queue.read_item() {
             use tree::BuilderEntryColumns as _;
-            // PORT NOTE: reshaped for borrowck — Zig indexes builder.list while passing &mut builder.
+            // Copy the element out of `builder.list` rather than indexing
+            // in-place: `process_subtree` only reads `this.id`
+            // (before appending to `builder.list`, which may reallocate), so the
+            // copy is equivalent — and avoids the dangling-element hazard.
             let tree = builder.list.items_tree()[item.tree_id as usize];
             tree.process_subtree(item.dependency_id, item.hoist_root_id, &mut builder)?;
-            // TODO(port): `tree` may need to be a reference into builder.list, not a copy.
         }
 
         let cleaned = builder.clean()?;
@@ -1516,10 +1540,9 @@ impl Lockfile {
         }
 
         let cache_ctx = manager.manifest_disk_cache_ctx();
-        // PORT NOTE: heavy borrowck overlap — Zig calls
-        // `manager.manifests.byNameHash(manager, …)` (manifests is a field of
-        // manager) and then opens a `string_builder` on `manager.lockfile`
-        // while still holding `&manifest`. Route the `manifests` projection
+        // `manifests` is a field of `manager`, and a `string_builder` is
+        // opened on `manager.lockfile` while `&manifest` is still held.
+        // Route the `manifests` projection
         // through a raw root so it can coexist with the lockfile borrows;
         // lockfile fields are taken from `self` (== `manager.lockfile`), never
         // re-derived via `manager_ptr`. BACKREF `mgr_ref` wraps the same root
@@ -1532,9 +1555,8 @@ impl Lockfile {
         let mut pkgs = self.packages.slice();
         let len = pkgs.len();
 
-        // PORT NOTE: Zig takes `pkgs.items(.bin)` / `pkgs.items(.meta)` as
-        // simultaneous mutable column views; `split_mut()` yields disjoint
-        // `&mut [_]` per column from one `&mut Slice` borrow.
+        // `split_mut()` yields disjoint `&mut [_]` per column from one
+        // `&mut Slice` borrow.
         let self::package::PackageColumnsMut {
             name: pkg_names,
             name_hash: pkg_name_hashes,
@@ -1543,9 +1565,8 @@ impl Lockfile {
             meta,
             ..
         } = pkgs.split_mut();
-        // PORT NOTE: Zig has two near-identical loops gated by `update_os_cpu`;
-        // collapse to one loop and bind `pkg_metas` as an empty slice when the
-        // const generic is false (Zig left it `undefined`).
+        // One loop serves both modes: bind `pkg_metas` as an empty slice
+        // when the const generic is false.
         let pkg_metas: &mut [self::package::meta::Meta] =
             if UPDATE_OS_CPU { meta } else { &mut [] };
 
@@ -1581,8 +1602,7 @@ impl Lockfile {
                         continue;
                     };
 
-                    // PORT NOTE: Zig opens the builder on `manager.lockfile`,
-                    // which is the same `*Lockfile` as `this`/`self`. Re-deriving a
+                    // `manager.lockfile` is the same `Lockfile` as `self`. Re-deriving a
                     // whole `&mut Lockfile` from `manager_ptr` here would create a
                     // second mutable reference aliasing `self` (UB) — go through
                     // `self` so the field-level borrows below stay disjoint from the
@@ -1599,11 +1619,10 @@ impl Lockfile {
                     );
 
                     builder.allocate()?;
-                    // Spec: `defer builder.clamp()` — call explicitly at end of block (no `?`
+                    // `builder.clamp()` is called explicitly at end of block (no `?`
                     // exits between here and the clamp below).
 
                     let extern_strings_list = &mut self.buffers.extern_strings;
-                    // PERF(port): was ensureUnusedCapacity
                     let start = extern_strings_list.len();
                     // Default-fill the tail so it is valid before `bin.clone`
                     // overwrites it (replaces `reserve` + raw `set_len`).
@@ -1613,11 +1632,9 @@ impl Lockfile {
                     );
                     let new_len = extern_strings_list.len();
 
-                    // PORT NOTE: Zig passes both `extern_strings_list.items` (full slice)
-                    // and a tail subslice to `bin.clone()`; the full slice is only used to
-                    // compute the tail's offset for `ExternalStringList::init`. In Rust the
-                    // two views would alias, so `Bin::clone_with_buffers` takes the offset
-                    // directly.
+                    // A full slice and a tail subslice would alias, so
+                    // `Bin::clone_with_buffers` takes the tail's offset for
+                    // `ExternalStringList::init` directly.
                     let extern_strings_slice = &mut extern_strings_list[start..new_len];
 
                     *pkg_bin = pkg.package.bin.clone_with_buffers(
@@ -1652,7 +1669,6 @@ impl Lockfile {
 // Printer
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Port of `Lockfile.Printer` (src/install/lockfile.zig).
 pub struct Printer<'a> {
     pub lockfile: &'a Lockfile,
     pub options: &'a PackageManagerOptions,
@@ -1677,8 +1693,6 @@ impl<'a> Printer<'a> {
         input_lockfile_path: &[u8],
         format: PrinterFormat,
     ) -> Result<(), BunError> {
-        // TODO(port): narrow error set
-
         // We truncate longer than allowed paths. We should probably throw an error instead.
         let path = &input_lockfile_path[..input_lockfile_path.len().min(MAX_PATH_BYTES)];
 
@@ -1691,17 +1705,15 @@ impl<'a> Printer<'a> {
         // `output[..n].copy_from_slice(input)` (→ `ptr::copy_nonoverlapping`);
         // passing a slice of `bufN` as `input` while taking `&mut bufN` as
         // `output` is UB on overlapping ranges and would also corrupt
-        // `lockfile_path` (printed in the NotFound arm). Zig's
-        // `bun.sys.chdir("", dirname)` accepts a non-sentinel slice directly,
-        // so it never re-buffers — the hazard is Rust-port-specific.
+        // `lockfile_path` (printed in the NotFound arm).
         let mut path_in_buf2 = false;
 
         if !bun_paths::is_absolute(path) {
-            // Zig `bun.getcwd` returns the slice; the Rust `bun_sys::getcwd`
-            // returns the length written into the caller-owned buffer.
+            // `bun_sys::getcwd` returns the length written into the
+            // caller-owned buffer.
             let cwd_len = bun_sys::getcwd(&mut lockfile_path_buf1[..])?;
             let parts = [path];
-            // PORT NOTE: reshaped for borrowck — copy `cwd` out of `buf1` so the
+            // Copy `cwd` out of `buf1` so the
             // join can write into `buf2` while `cwd` borrows `buf1` only.
             let cwd = &lockfile_path_buf1[..cwd_len];
             let lockfile_path__len = resolve_path::join_abs_string_buf::<platform::Auto>(
@@ -1725,8 +1737,6 @@ impl<'a> Printer<'a> {
         }
 
         if !lockfile_path.as_bytes().is_empty() && lockfile_path.as_bytes()[0] == SEP {
-            // Zig `bun.sys.chdir("", dirname)` — first arg is error-context
-            // path; the Rust `bun_sys::chdir` takes the destination only.
             let dir = bun_paths::dirname(lockfile_path.as_bytes()).unwrap_or(SEP_STR.as_bytes());
             // NUL-terminate into the buffer that does NOT back `lockfile_path`
             // (see `path_in_buf2` note above). `buf1`'s cwd contents are dead
@@ -1739,8 +1749,8 @@ impl<'a> Printer<'a> {
             let _ = sys::chdir(dir_z);
         }
 
-        // Zig: `_ = try FileSystem.init(null);` — bootstraps the resolver FS
-        // singleton. `Printer::print` is an entry point (`bun bun.lockb`), so
+        // Bootstrap the resolver FS singleton. `Printer::print` is an entry
+        // point (`bun bun.lockb`), so
         // the singleton may not exist yet.
         let _ = FileSystem::init(None)?;
 
@@ -1803,9 +1813,8 @@ impl<'a> Printer<'a> {
         format: PrinterFormat,
         writer: W,
     ) -> Result<(), BunError> {
-        // TODO(port): narrow error set
         // `FileSystem::init` ran in the caller (`Printer::print`); this is the
-        // process-static singleton (Zig `&FileSystem.instance`). Single-threaded
+        // process-static singleton. Single-threaded
         // CLI path, no concurrent access.
         let fs = FileSystem::instance();
         let mut options = PackageManagerOptions {
@@ -1813,7 +1822,7 @@ impl<'a> Printer<'a> {
             ..Default::default()
         };
 
-        // PORT NOTE: reshaped for borrowck — capture the `'static` cwd slice
+        // Capture the `'static` cwd slice
         // before borrowing `fs.fs` mutably.
         let top_level_dir = fs.top_level_dir;
         let entries_option = fs.fs.read_directory(top_level_dir, None, 0, true)?;
@@ -1823,7 +1832,7 @@ impl<'a> Printer<'a> {
         };
 
         // PORTING.md §Forbidden patterns: never `Box::leak` — own `map`/`loader` as locals;
-        // they live for the function scope (one-shot CLI path, matches lockfile.zig:1179-1183).
+        // they live for the function scope (one-shot CLI path).
         let mut map = DotEnv::Map::init();
         let mut env_loader = DotEnv::Loader::init(&mut map);
         env_loader.quiet = true;
@@ -1869,7 +1878,6 @@ impl<'a> Printer<'a> {
 
 impl Lockfile {
     pub fn verify_data(&self) -> Result<(), BunError> {
-        // TODO(port): narrow error set
         debug_assert!(self.format == FormatVersion::current());
         let mut i: usize = 0;
         while i < self.packages.len() {
@@ -1924,8 +1932,6 @@ impl Lockfile {
                 );
                 Global::crash();
             }
-            // Zig: `bun.assert(FileSystem.instance_loaded);`
-            // SAFETY: read of a process-global flag; matches Zig's bare global read.
             debug_assert!(Fs::INSTANCE_LOADED.load(core::sync::atomic::Ordering::Relaxed));
         }
 
@@ -1939,7 +1945,7 @@ impl Lockfile {
                     options,
                     &mut writer_buf,
                 ) {
-                    // error.WriteFailed -> OOM in Zig (Allocating writer)
+                    // The only write failure on an allocating writer is OOM.
                     bun_core::out_of_memory();
                 }
 
@@ -1991,7 +1997,6 @@ impl Lockfile {
             let written = start_len - cursor.len();
             ZStr::from_buf(&tmpname_buf, written - 1)
         };
-        // TODO(port): Zig `{x}` on `&[8]u8` formats as lowercase hex of bytes; verify HexBytes matches.
 
         let file = match File::openat(Fd::cwd(), tmpname, sys::O::CREAT | sys::O::WRONLY, 0o777) {
             sys::Result::Err(e) => {
@@ -2007,7 +2012,7 @@ impl Lockfile {
 
         match file.write_all(&bytes) {
             sys::Result::Err(e) => {
-                let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+                let _ = file.close(); // close error is non-actionable
                 let _ = sys::unlink(tmpname);
                 Output::err(e, "failed to write lockfile", format_args!(""));
                 Global::crash();
@@ -2024,7 +2029,7 @@ impl Lockfile {
             }
             match sys::fchmod(file.handle, filemode) {
                 sys::Result::Err(e) => {
-                    let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+                    let _ = file.close(); // close error is non-actionable
                     let _ = sys::unlink(tmpname);
                     Output::err(e, "failed to change lockfile permissions", format_args!(""));
                     Global::crash();
@@ -2058,8 +2063,6 @@ impl Lockfile {
 
     #[inline]
     pub fn str<'a, T: bun_semver::Slicable>(&'a self, slicable: &'a T) -> &'a [u8] {
-        // PORT NOTE: Zig had compile-time guards rejecting by-value String/ExternalString.
-        // In Rust we just take &T; the temporary-pointer hazard does not exist.
         slicable.slice(self.buffers.string_bytes.as_slice())
     }
 
@@ -2067,15 +2070,14 @@ impl Lockfile {
     ///
     /// The install pipeline frequently needs to read a string out of
     /// `buffers.string_bytes` and then call back into `&mut PackageManager`
-    /// (which owns the `Lockfile`). Zig's `[]const u8` carries no lifetime so
-    /// the borrow conflict does not exist there; in Rust the caller would
-    /// otherwise have to write `unsafe { detach_lifetime(self.str(x)) }` at
+    /// (which owns the `Lockfile`). The caller would otherwise have to write
+    /// `unsafe { detach_lifetime(self.str(x)) }` at
     /// every site. Consolidating that here keeps the SAFETY argument in one
     /// place.
     ///
     /// SAFETY (internal): `string_bytes` is append-only for the lifetime of a
     /// resolve/enqueue pass and is never reallocated while a detached slice is
-    /// live (Zig invariant). The returned slice must not outlive the
+    /// live. The returned slice must not outlive the
     /// `Lockfile`.
     #[inline]
     pub fn str_detached<'a, T: bun_semver::Slicable>(&self, slicable: &T) -> &'a [u8] {
@@ -2084,7 +2086,7 @@ impl Lockfile {
         unsafe { bun_ptr::detach_lifetime(slicable.slice(self.buffers.string_bytes.as_slice())) }
     }
 
-    /// Construct an empty Lockfile value (in-place equivalent of Zig `initEmpty`).
+    /// Construct an empty Lockfile value in place.
     pub fn init_empty(&mut self) {
         *self = Self::init_empty_value();
     }
@@ -2155,7 +2157,7 @@ impl Lockfile {
         let resolutions: &[Resolution] = self.packages.items_resolution();
         // Borrow the `npm` arm's `Semver::Group` (not `Copy` — owns a linked
         // list head). `version` is held by-value for the whole fn body so the
-        // borrow is sound; Zig's by-value copy is replaced with a `&Group`.
+        // borrow is sound.
         let npm_version = match version {
             Some(v) if v.tag == dependency::Tag::Npm => Some(&v.npm().version),
             _ => None,
@@ -2256,10 +2258,8 @@ impl Lockfile {
 
     /// Appends `pkg` to `this.packages`, and adds to `this.package_index`.
     ///
-    /// PORT NOTE: Zig takes `string_buf: []const u8` as a separate parameter
-    /// (always `lockfile.buffers.string_bytes.items`). In Rust that aliases the
-    /// `&mut self` borrow, so read it from `self` and split borrows at the
-    /// field level (`package_index` / `packages` / `buffers.string_bytes` are
+    /// The string buffer is read from `self`, splitting borrows at the field
+    /// level (`package_index` / `packages` / `buffers.string_bytes` are
     /// disjoint).
     pub fn append_package_dedupe(&mut self, pkg: &mut Package) -> Result<PackageID, AllocError> {
         let entry = self.package_index.get_or_put(pkg.name_hash)?;
@@ -2403,7 +2403,7 @@ impl Lockfile {
     }
 
     pub fn append_package(&mut self, package_: &Package) -> Result<Package, AllocError> {
-        let id: PackageID = self.packages.len() as PackageID; // @truncate
+        let id: PackageID = self.packages.len() as PackageID;
         self.append_package_with_id(package_, id)
     }
 
@@ -2412,7 +2412,7 @@ impl Lockfile {
         package_: &Package,
         id: PackageID,
     ) -> Result<Package, AllocError> {
-        // Zig's `defer` reads `package_` (the original arg) for the assertion.
+        // Captured for the assertion at the end of the function.
         let name_hash = package_.name_hash;
         let resolution = package_.resolution;
 
@@ -2488,7 +2488,6 @@ impl Lockfile {
             bytes: &mut self.buffers.string_bytes,
             pool: &mut self.string_pool,
         }
-        // TODO(port): String.Buf API in bun_semver — Zig also passed `allocator`.
     }
 }
 
@@ -2516,7 +2515,6 @@ impl Scratch {
 
 impl Default for Scratch {
     fn default() -> Self {
-        // Zig field defaults are `undefined`; we initialize properly.
         Self::init()
     }
 }
@@ -2551,11 +2549,10 @@ pub struct LockfileFields<'a> {
 // StringBuilder
 // ────────────────────────────────────────────────────────────────────────────
 
-/// PORT NOTE: Zig stored `lockfile: *Lockfile` and reached `.buffers.string_bytes`
-/// / `.string_pool` through it. In Rust that coarse `&mut Lockfile` borrow
-/// blocks every caller from touching disjoint fields (`packages`, `buffers
-/// .dependencies`, …) while a builder is alive. Hold the two fields the
-/// builder actually mutates so callers can split-borrow at the field level.
+/// Holds the two fields the builder actually mutates (rather than a whole
+/// `&mut Lockfile`, which would block every caller from touching disjoint
+/// fields like `packages` / `buffers.dependencies` while a builder is alive)
+/// so callers can split-borrow at the field level.
 pub struct StringBuilder<'a> {
     pub len: usize,
     pub cap: usize,
@@ -2585,7 +2582,7 @@ macro_rules! string_builder {
 }
 
 /// Trait implemented by `String` and `ExternalString` to support generic `append*`.
-/// Replaces Zig's `comptime Type: type` switch. Canonical def lives in
+/// Canonical def lives in
 /// `bun_semver::semver_string`; re-exported under the local name so generic
 /// bounds in this module (`append<T: StringBuilderType>`) are unchanged.
 pub use bun_semver::semver_string::BuilderStringType as StringBuilderType;
@@ -2738,7 +2735,7 @@ impl<'a> StringBuilder<'a> {
 //
 // Several callees (`Version::count`/`append`, `Dependency::count`/`clone`,
 // `Bin::count`/`clone`, `Scripts::clone`/`count`) accept the builder via a
-// duck-typed trait that mirrors Zig's `comptime StringBuilder: type`. Wire
+// duck-typed trait. Wire
 // `lockfile::StringBuilder` into each so `Package` can pass `&mut builder`
 // straight through.
 
@@ -2767,8 +2764,8 @@ impl<'a> bun_semver::StringBuilder for StringBuilder<'a> {
 pub mod package_index {
     use super::*;
 
+    // `bun_collections::HashMap` hard-codes an 80% max load factor.
     pub type Map = BunHashMap<PackageNameHash, Entry, IdentityContext<PackageNameHash>>;
-    // TODO(port): Zig uses load factor 80; bun_collections::HashMap should match.
 
     #[repr(u8)]
     pub enum Tag {
@@ -2782,7 +2779,6 @@ pub mod package_index {
     }
 
     impl Default for Entry {
-        /// Zig: `union(PackageIndex.Tag) { id, ids }` zero-initialises to `.id = 0`.
         /// `HashMap::get_or_put` needs a `Default` to fill the value slot before
         /// the caller writes the real `Entry::Id(..)` / `Entry::Ids(..)`.
         #[inline]
@@ -2799,8 +2795,8 @@ pub use package_index::Map as PackageIndexMap;
 // FormatVersion
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Spec lockfile.zig: `enum(u32) { v0, v1, v2, v3, _ }` — non-exhaustive. The binary
-/// lockfile serializer reads this u32 directly from disk; an exhaustive Rust enum would
+/// The binary lockfile serializer reads this u32 directly from disk; an
+/// exhaustive Rust enum would
 /// make deserializing a future v4+ lockfile instant UB (transmute-to-enum with an
 /// invalid discriminant). PORTING.md §Forbidden patterns: never transmute disk data
 /// into an exhaustive enum. Represent as a transparent u32 with associated consts so
@@ -2866,8 +2862,6 @@ impl<'a> EqlSorter<'a> {
 impl Lockfile {
     /// `cut_off_pkg_id` should be removed when we stop appending packages to lockfile during install step
     pub fn eql(&self, r: &Lockfile, cut_off_pkg_id: usize) -> Result<bool, AllocError> {
-        // Zig names the receiver `l`; alias `self` so the body matches the
-        // spec verbatim (lockfile.zig:1798).
         let l: &Lockfile = self;
         let l_hoisted_deps = l.buffers.hoisted_dependencies.as_slice();
         let r_hoisted_deps = r.buffers.hoisted_dependencies.as_slice();
@@ -2884,7 +2878,6 @@ impl Lockfile {
         let mut sort_buf: Vec<PathToId> = Vec::with_capacity(l_len + r_len);
 
         let mut path_buf = PathBuffer::uninit();
-        // Zig: `var depth_buf: Tree.DepthBuf = undefined;`
         let mut depth_buf: tree::DepthBuf = tree::depth_buf_uninit();
 
         // Track owned tree-path allocations so they outlive the sort and are freed at scope end.
@@ -3032,7 +3025,6 @@ impl Lockfile {
         print_name_version_string: bool,
         packages_len: usize,
     ) -> Result<bool, BunError> {
-        // TODO(port): narrow error set
         let previous_meta_hash = self.meta_hash;
         self.meta_hash = self.generate_meta_hash(print_name_version_string, packages_len)?;
         Ok(!strings::eql_long(
@@ -3047,7 +3039,6 @@ impl Lockfile {
         print_name_version_string: bool,
         packages_len: usize,
     ) -> Result<MetaHash, BunError> {
-        // TODO(port): narrow error set
         if packages_len <= 1 {
             return Ok(ZERO_HASH);
         }
@@ -3066,10 +3057,8 @@ impl Lockfile {
             let mut i: usize = 1;
 
             while i + 16 < packages_len {
-                // PORT NOTE: Zig used `inline while` to unroll 16 iterations. Plain loop here.
-                // PERF(port): was comptime-unrolled inner loop — profile if it shows up on a hot path.
                 for j in 0..16usize {
-                    alphabetized_names[(i + j) - 1] = (i + j) as PackageID; // @truncate
+                    alphabetized_names[(i + j) - 1] = (i + j) as PackageID;
                     // posix path separators because we only use posix in the lockfile
                     string_builder.fmt_count(format_args!(
                         "{}@{}\n",
@@ -3081,7 +3070,7 @@ impl Lockfile {
             }
 
             while i < packages_len {
-                alphabetized_names[i - 1] = i as PackageID; // @truncate
+                alphabetized_names[i - 1] = i as PackageID;
                 // posix path separators because we only use posix in the lockfile
                 string_builder.fmt_count(format_args!(
                     "{}@{}\n",
@@ -3189,7 +3178,7 @@ impl Lockfile {
             dependency::Tag::Npm => {
                 // SAFETY: tag checked == .npm above; `npm` is the active
                 // `dependency::Value` union field. Same for `Resolution.value`
-                // below — Zig reads `.npm` unconditionally on this path.
+                // below — `.npm` is read unconditionally on this path.
                 let npm_group = &version.npm().version;
                 match entry {
                     PackageIndexEntry::Id(id) => {
@@ -3233,21 +3222,17 @@ const MAX_DEFAULT_TRUSTED_DEPENDENCIES: usize = 512;
 
 /// Sorted list of default trusted dependency names.
 ///
-/// Zig builds this at comptime from `default-trusted-dependencies.txt` via
-/// `@embedFile` + tokenize + sort. Rust cannot tokenize/sort at const time, so
-/// we embed the file with `include_str!` and build the sorted slice on first
-/// access. Kept alphabetical so `bun pm trusted --default` need not re-sort.
+/// Embeds `default-trusted-dependencies.txt` with `include_str!` and builds
+/// the sorted slice on first access. Kept alphabetical so `bun pm trusted
+/// --default` need not re-sort.
 pub static DEFAULT_TRUSTED_DEPENDENCIES_LIST: std::sync::LazyLock<Vec<&'static [u8]>> =
     std::sync::LazyLock::new(|| {
-        // Zig: @embedFile("./default-trusted-dependencies.txt")
         const DATA: &str = include_str!("default-trusted-dependencies.txt");
-        // Zig: std.mem.tokenizeAny(u8, data, " \r\n\t")
         let mut names: Vec<&'static [u8]> = DATA
             .split([' ', '\r', '\n', '\t'])
             .filter(|s| !s.is_empty())
             .map(str::as_bytes)
             .collect();
-        // Zig: std.sort.pdq with std.mem.order(u8, ..) == .lt
         names.sort_unstable();
         debug_assert!(
             names.len() <= MAX_DEFAULT_TRUSTED_DEPENDENCIES,
@@ -3259,10 +3244,9 @@ pub static DEFAULT_TRUSTED_DEPENDENCIES_LIST: std::sync::LazyLock<Vec<&'static [
 
 /// The default list of trusted dependencies is a static hashmap.
 ///
-/// Zig builds a comptime `StaticHashMap` keyed by truncated-u32 string-hash.
-/// Rust populates the same `StaticHashMap` lazily on first access from the
-/// build.rs-generated list. The hash is `String.Builder.stringHash(s) as u32`
-/// so entries match `Lockfile.trusted_dependencies` keys.
+/// A `StaticHashMap` keyed by truncated-u32 string-hash, populated lazily on
+/// first access. The hash is the truncated string hash so entries match
+/// `Lockfile.trusted_dependencies` keys.
 pub mod default_trusted_dependencies {
     use super::{
         DEFAULT_TRUSTED_DEPENDENCIES_LIST, MAX_DEFAULT_TRUSTED_DEPENDENCIES, SemverStringBuilder,
@@ -3306,19 +3290,16 @@ pub mod default_trusted_dependencies {
         map
     });
 
-    /// Iterate populated entries (Zig: `default_trusted_dependencies.entries`).
+    /// Iterate populated entries.
     pub(crate) fn entries() -> impl Iterator<Item = &'static Entry<&'static [u8], ()>> {
         MAP.entries.iter().filter(|e| !e.is_empty())
     }
 
-    /// Zig: `default_trusted_dependencies.hasWithHash`.
     #[inline]
     pub(crate) fn has_with_hash(hash: u64) -> bool {
         MAP.has_with_hash(hash)
     }
 
-    /// Zig: `default_trusted_dependencies.has(name)`.
-    ///
     /// Open-coded `hasContext` so the lookup key can borrow with any lifetime,
     /// not just `'static`.
     pub(crate) fn has(name: &[u8]) -> bool {
@@ -3450,7 +3431,7 @@ impl Default for PatchedDep {
 }
 
 impl PatchedDep {
-    /// Construct with just `path` set (Zig: `.{ .path = path }`). Exists because
+    /// Construct with just `path` set. Exists because
     /// the explicit-padding / private-hash fields make the `..Default::default()`
     /// struct-update form unusable from sibling modules.
     pub fn with_path(path: SemverString) -> Self {
@@ -3473,5 +3454,3 @@ impl PatchedDep {
         }
     }
 }
-
-// ported from: src/install/lockfile.zig
diff --git a/src/install/lockfile/Buffers.rs b/src/install/lockfile/Buffers.rs
index fc6460e8e7a..5cb0e3e4d11 100644
--- a/src/install/lockfile/Buffers.rs
+++ b/src/install/lockfile/Buffers.rs
@@ -4,9 +4,9 @@ use bun_collections::DynamicBitSet as Bitset;
 #[cfg(debug_assertions)]
 use bun_core::strings;
 
-// PORT NOTE: `use super::{self as lockfile, ...}` and bare `use super as lockfile;`
-// are both rejected by rustc (E0432: "no `super` in the root" — rust-lang/rust#48067),
-// so the parent-module alias is spelled via its crate path instead.
+// `use super::{self as lockfile, ...}` and bare `use super as lockfile;` are both
+// rejected by rustc (E0432: "no `super` in the root" — rust-lang/rust#48067), so the
+// parent-module alias is spelled via its crate path instead.
 use super::{
     DependencyIDList, DependencyList, ExternalStringBuffer, Lockfile, PackageIDList, Stream,
     StringBuffer, Tree, assert_no_uninitialized_padding, tree,
@@ -30,12 +30,11 @@ pub struct Buffers {
     pub string_bytes: StringBuffer,
 }
 
-// PORT NOTE: Zig `deinit` only freed owned ArrayListUnmanaged fields; in Rust the
-// Vec-backed field types drop automatically, so no explicit `Drop` impl is needed.
+// The Vec-backed field types drop automatically; no explicit `Drop` impl is
+// needed.
 
 impl Buffers {
     pub fn preallocate(&mut self, that: &Buffers) -> Result<(), bun_alloc::AllocError> {
-        // TODO(port): narrow error set
         self.trees
             .reserve(that.trees.len().saturating_sub(self.trees.len()));
         self.resolutions.reserve(
@@ -63,37 +62,25 @@ impl Buffers {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `sizes` — comptime field-order table
+// `sizes` — serialized field-order table
 //
-// PORT NOTE: the Zig computed this with `std.meta.fields` + an insertion sort
-// by descending `@alignOf(field.type)`. Every field is an `ArrayListUnmanaged`,
-// whose alignment is `@alignOf(usize)`, so the stable sort is a no-op and the
-// result is declaration order. We hard-code that order here. `types[0]` (used
-// only for `Aligner.write`) was `Tree.List.Slice` i.e. `[]Tree`; Zig's
-// `@alignOf([]Tree)` is the alignment of the SLICE fat-pointer (ptr+len), i.e.
-// `@alignOf(usize)`, NOT the element alignment — so we keep that as
-// `ALIGN_TYPE_0`.
+// Array payloads are written in field declaration order, each aligned to
+// `ALIGN_TYPE_0` (pointer alignment, NOT the element alignment).
 // ──────────────────────────────────────────────────────────────────────────
 mod sizes {
     use super::*;
 
-    /// Alignment used by `Aligner::write` for every array payload (Zig: `sizes.types[0]`).
+    /// Alignment used by `Aligner::write` for every array payload.
     ///
-    /// `sizes.types[0]` in Zig is `[]Tree` (a slice type), and `@alignOf([]Tree)` is the
-    /// alignment of the slice descriptor (a `(*T, usize)` fat pointer) — i.e. `@alignOf(usize)`,
-    /// not `@alignOf(Tree)`. This 8-byte boundary is load-bearing for on-disk parity AND for
+    /// This is the alignment of a slice descriptor (a `(*T, usize)` fat
+    /// pointer) — i.e. pointer alignment, not element alignment. This 8-byte
+    /// boundary is load-bearing for on-disk parity AND for
     /// `read_array::<ExternalString>` (which has a `u64` field) to produce an aligned `&[T]`.
     pub(super) const ALIGN_TYPE_0: usize = align_of::<usize>();
     const _: () = assert!(ALIGN_TYPE_0 == align_of::<&[Tree]>());
-
-    // `sizes.bytes` was never read in the Zig; omitted.
-    // TODO(port): if another file reads `Buffers.sizes.bytes`, add it back.
 }
 
 pub fn read_array<T: Copy>(stream: &mut Stream) -> Result<Vec<T>, bun_core::Error> {
-    // TODO(port): narrow error set (CorruptLockfile | OOM)
-    // PORT NOTE: Zig went through `stream.reader()`; `FixedBufferStream` exposes
-    // `read_int_le` directly, so the intermediate reader handle is elided.
     let start_pos = stream.read_int_le::<u64>()?;
 
     // If its 0xDEADBEEF, then that means the value was never written in the lockfile.
@@ -142,8 +129,7 @@ pub fn read_array<T: Copy>(stream: &mut Stream) -> Result<Vec<T>, bun_core::Erro
     if byte_len == 0 {
         // Empty arrays are written by `write_array`'s else-branch without an
         // `Aligner::write_with_align` pad, so their recorded start offset need not
-        // be aligned. Match Zig's `readArray`, which returns the empty slice
-        // before any alignment checks.
+        // be aligned.
         return Ok(Vec::new());
     }
 
@@ -154,8 +140,7 @@ pub fn read_array<T: Copy>(stream: &mut Stream) -> Result<Vec<T>, bun_core::Erro
     let start_pos = start_pos as usize;
     let end_pos = end_pos as usize;
     // SAFETY: `start_pos..end_pos` is in-bounds (checked above) and the lockfile
-    // writer aligned the payload to `align_of::<T>()` via `Aligner::write`. Zig
-    // used `@alignCast` here with the same precondition.
+    // writer aligned the payload to `align_of::<T>()` via `Aligner::write`.
     let misaligned: &[T] = unsafe {
         bun_core::ffi::slice(
             stream.buffer.as_ptr().add(start_pos).cast::<T>(),
@@ -172,20 +157,20 @@ pub fn write_array<S, T>(
     prefix: &'static str,
 ) -> Result<(), bun_core::Error>
 where
-    // PORT NOTE: Zig threaded a separate `stream` (anytype) and `writer` over the
-    // same buffer. Two `&mut` to one object is UB in Rust regardless of access
-    // order, so the port collapses both roles onto one type — `StreamType` impls
-    // both `PositionalStream` (get_pos/pwrite) and `bun_io::Write` (append).
+    // One type plays both the positional-stream and append-writer roles —
+    // `StreamType` impls both `PositionalStream` (get_pos/pwrite) and
+    // `bun_io::Write` (append) — so there are never two `&mut` to one buffer.
     S: lockfile::PositionalStream + bun_io::Write,
-    // TODO(port): narrow error set
 {
-    // TODO(port): comptime `assertNoUninitializedPadding(@TypeOf(array))` — needs
-    // a const-eval padding check on `T`; could add a `const _: () = assert!(...)`
-    // per call site or a `NoPadding` marker trait.
+    // This call is a zero-cost intent marker only — it carries no trait bound (see the
+    // doc comment on `assert_no_uninitialized_padding`). The actual compile-time
+    // enforcement is the per-type `const` field-offset asserts and the
+    // `layout_asserts` size/align pins in src/install/padding_checker.rs; any new
+    // `T` serialized through here must be added to that audit.
     assert_no_uninitialized_padding(array);
 
-    // SAFETY: `T` has no uninitialized padding (asserted above in Zig); reading
-    // its bytes is sound. Matches `std.mem.sliceAsBytes`.
+    // SAFETY: `T` has no uninitialized padding (audited via the per-type layout
+    // asserts in padding_checker.rs); reading its bytes is sound.
     let bytes: &[u8] =
         unsafe { bun_core::ffi::slice(array.as_ptr().cast::<u8>(), core::mem::size_of_val(array)) };
 
@@ -193,12 +178,10 @@ where
     stream.write_int_le::<u64>(0xDEAD_BEEF)?;
     stream.write_int_le::<u64>(0xDEAD_BEEF)?;
 
-    // PORT NOTE: Zig built this with `std.fmt.comptimePrint` over
-    // `@typeName/@sizeOf/@alignOf(std.meta.Child(ArrayList))`. The reader skips
-    // this prefix by absolute offset so it is semantically inert, but we emit the
-    // exact bytes Zig produces so that re-saving an unchanged lockfile is a byte
-    // no-op across the Zig→Rust migration. Call sites pass the verbatim Zig
-    // `@typeName` string (including its sizeof/alignof suffix) as a literal.
+    // The reader skips this prefix by absolute offset so it is semantically
+    // inert, but we emit the exact historical bytes so that re-saving an
+    // unchanged lockfile is a byte no-op. Call sites pass the verbatim
+    // type-name string (including its sizeof/alignof suffix) as a literal.
     stream.write_all(prefix.as_bytes())?;
 
     if !bytes.is_empty() {
@@ -210,7 +193,7 @@ where
         let real_end_pos = stream.get_pos()? as u64;
         let positioned: [u64; 2] = [real_start_pos, real_end_pos];
         // `[u64; 2]` and `[u8; 16]` are both `Pod` of equal size — `bytemuck`
-        // gives the same `std.mem.asBytes` view without `unsafe`.
+        // gives the byte view without `unsafe`.
         let positioned_bytes: &[u8; 16] = bytemuck::cast_ref(&positioned);
         let mut written: usize = 0;
         while written < 16 {
@@ -220,7 +203,7 @@ where
         let real_end_pos = stream.get_pos()? as u64;
         let positioned: [u64; 2] = [real_end_pos, real_end_pos];
         // `[u64; 2]` and `[u8; 16]` are both `Pod` of equal size — `bytemuck`
-        // gives the same `std.mem.asBytes` view without `unsafe`.
+        // gives the byte view without `unsafe`.
         let positioned_bytes: &[u8; 16] = bytemuck::cast_ref(&positioned);
         let mut written: usize = 0;
         while written < 16 {
@@ -236,28 +219,22 @@ pub fn save<S>(
     stream: &mut S,
 ) -> Result<(), bun_core::Error>
 where
-    // PORT NOTE: see `write_array` — Zig's separate stream/writer aliased one
-    // buffer; collapsed to a single bound to avoid two `&mut` to the same object.
+    // See `write_array` — a single bound avoids two `&mut` to the same object.
     S: lockfile::PositionalStream + bun_io::Write,
 {
     let buffers = &lockfile.buffers;
 
-    // PORT NOTE: Zig used `inline for (sizes.names) |name|` + `@field(buffers, name)`.
-    // Rust has no field-name reflection, so the loop is unrolled in declaration
-    // order (see `sizes` module note — the comptime sort was a no-op).
+    // The fields are saved unrolled in declaration order (see `sizes` module
+    // note).
 
     macro_rules! save_generic_field {
         ($field:ident, $name:literal, $elem:ty, $prefix:literal) => {{
             if options.log_level.is_verbose() {
                 bun_core::pretty_errorln!("Saving {} {}", buffers.$field.len(), $name);
             }
-            // PORT NOTE: the Zig had `if (comptime Type == Tree)` here, but `Type`
-            // was `@TypeOf(list.items)` i.e. `[]Elem`, never `Tree`, so that arm
-            // was dead. We port only the live `else` arm.
             // We duplicate it here so that alignment bytes are zeroed out
             let mut clone: Vec<$elem> = Vec::with_capacity(buffers.$field.len());
             clone.extend_from_slice(buffers.$field.as_slice());
-            // PERF(port): was appendSliceAssumeCapacity
             write_array(stream, clone.as_slice(), $prefix)?;
             #[cfg(debug_assertions)]
             {
@@ -271,14 +248,10 @@ where
         if options.log_level.is_verbose() {
             bun_core::pretty_errorln!("Saving {} {}", buffers.trees.len(), "trees");
         }
-        // PORT NOTE: Zig's `if (comptime Type == Tree)` arm (Buffers.zig:248)
-        // never fires because `Type` is `[]Tree`, so Zig writes raw `Tree`
-        // bytes — which works only because Zig's auto-layout for `Tree` happens
-        // to match the `[id|dep_id|parent|off|len]` encoding that `load`
-        // decodes via `Tree.toTree`. We instead write the explicit
-        // `Tree.External` form so the on-disk layout is independent of
-        // `repr(Rust)` field order. This is byte-identical to what Zig emits
-        // (both are 20 bytes/tree, same field order).
+        // Write the explicit `Tree.External` form so the on-disk layout is
+        // independent of `repr(Rust)` field order: 20 bytes/tree, fields in
+        // the `[id|dep_id|parent|off|len]` order that `load` decodes via
+        // `Tree.toTree`.
         let mut clone: Vec<tree::External> = Vec::with_capacity(buffers.trees.len());
         for &item in buffers.trees.as_slice() {
             clone.push(Tree::to_external(item));
@@ -286,10 +259,9 @@ where
         write_array(
             stream,
             clone.as_slice(),
-            // Verbatim Zig `@typeName(Tree)` output. Zig writes raw `Tree` (the
-            // `Type == Tree` branch is dead — see PORT NOTE above), so it reports
-            // `4 alignof` even though we serialize `tree::External` (`[u8;20]`,
-            // align 1). The reader ignores this string; we match Zig's bytes.
+            // Verbatim historical type-name string. It reports `4 alignof` even
+            // though we serialize `tree::External` (`[u8;20]`, align 1). The
+            // reader ignores this string; only the exact bytes matter.
             "\n<install.lockfile.Tree> 20 sizeof, 4 alignof\n",
         )?;
         #[cfg(debug_assertions)]
@@ -370,13 +342,11 @@ where
         let mut to_clone: Vec<dependency::External> = Vec::with_capacity(remaining.len());
         for dep in remaining {
             to_clone.push(dependency::to_external(dep));
-            // PERF(port): was appendAssumeCapacity
         }
 
         write_array(
             stream,
             to_clone.as_slice(),
-            // Zig: `@typeName(Dependency.External)` where `External = [26]u8`.
             "\n<[26]u8> 26 sizeof, 1 alignof\n",
         )?;
 
@@ -415,8 +385,8 @@ impl Buffers {
             0 => return Ok(tree::ROOT_DEP_ID),
             id if id == invalid_package_id => return Ok(invalid_package_id),
             _ => {
-                // PORT NOTE: reshaped for borrowck — `dependency_visited` is
-                // captured once outside the loop instead of re-matched per iter.
+                // `dependency_visited` is captured once outside the loop
+                // instead of re-matched per iteration (borrowck).
                 let mut visited = dependency_visited;
                 for (dep_id, &pkg_id) in self.resolutions.iter().enumerate() {
                     if pkg_id == package_id {
@@ -443,7 +413,8 @@ pub(crate) fn load(
     let mut this = Buffers::default();
     let external_dependency_list_: Vec<dependency::External>;
 
-    // PORT NOTE: Zig `inline for (sizes.names)` unrolled — see `sizes` module note.
+    // The fields are loaded unrolled in declaration order (see `sizes` module
+    // note).
 
     macro_rules! load_generic_field {
         ($field:ident, $name:literal, $elem:ty) => {{
@@ -467,10 +438,8 @@ pub(crate) fn load(
         let _pos: usize = stream.pos;
 
         let tree_list: Vec<tree::External> = read_array(stream)?;
-        // PORT NOTE: Zig did `initCapacity` + `items.len = N` + write each slot.
-        // In Rust, `set_len` then `iter_mut()` would form `&mut Tree` to
-        // uninitialized memory (UB), so we push into the reserved capacity
-        // instead — same allocation pattern, no uninit reads.
+        // `set_len` then `iter_mut()` would form `&mut Tree` to uninitialized
+        // memory (UB), so we push into the reserved capacity instead.
         this.trees = tree::List::with_capacity(tree_list.len());
         for from in &tree_list {
             this.trees.push(Tree::to_tree(*from));
@@ -518,14 +487,9 @@ pub(crate) fn load(
         buffer: string_buf,
         package_manager: pm_,
     };
-    // TODO(port): `Dependency::Context` borrows `log`, `string_buf`, and `pm_`
-    // simultaneously with `&mut this`; may need to restructure borrows.
-
-    // PORT NOTE: Zig did `expandToCapacity` + `items.len = N` then wrote each
-    // slot via `*dep = ...`. In Rust, `set_len` then `as_mut_slice()` would form
-    // `&mut Dependency` to uninitialized memory (UB even when write-only), so we
-    // push into the reserved capacity instead — same single allocation, same
-    // element order, no uninit references.
+    // `set_len` then `as_mut_slice()` would form `&mut Dependency` to
+    // uninitialized memory (UB even when write-only), so we push into the
+    // reserved capacity instead.
     for ext in external_dependency_list {
         this.dependencies
             .push(dependency::to_dependency(*ext, &mut extern_context));
@@ -535,7 +499,7 @@ pub(crate) fn load(
     // Legacy tree structure stores package IDs instead of dependency IDs
     if !this.trees.is_empty() && this.trees[0].dependency_id != tree::ROOT_DEP_ID {
         let mut visited = Bitset::init_empty(this.dependencies.len())?;
-        // PORT NOTE: reshaped for borrowck — iterate by index so
+        // Iterate by index so
         // `legacy_package_to_dependency_id` can borrow `&self` while we hold
         // `&mut this.trees[i]`.
         for i in 0..this.trees.len() {
@@ -560,5 +524,3 @@ pub(crate) fn load(
 
     Ok(this)
 }
-
-// ported from: src/install/lockfile/Buffers.zig
diff --git a/src/install/lockfile/CatalogMap.rs b/src/install/lockfile/CatalogMap.rs
index c364a746e3a..621b9db1f9b 100644
--- a/src/install/lockfile/CatalogMap.rs
+++ b/src/install/lockfile/CatalogMap.rs
@@ -7,11 +7,11 @@ use bun_collections::array_hash_map::ArrayHashAdapter;
 use bun_install::dependency::DependencyExt as _;
 use bun_install::lockfile::{Buffers, StringBuilder};
 use bun_install::{Dependency, Lockfile, PackageManager};
-// PORT NOTE (layering): Zig `bun.ast.Expr` resolves to the full T4 parser AST,
-// but every install-side caller (Package.rs / pnpm.rs) parses JSON/YAML into
-// the lower-tier `bun_ast::js_ast` shape (re-exported via `crate::bun_json`).
-// Importing `bun_js_parser` here forced a higher-tier dep and produced
-// distinct-`Expr`-type errors at every call site, so use the T2 type directly.
+// Layering: every install-side caller (Package.rs / pnpm.rs) parses JSON/YAML
+// into the lower-tier `bun_ast::js_ast` shape (re-exported via
+// `crate::bun_json`). Importing `bun_js_parser` here would force a higher-tier
+// dep and produce distinct-`Expr`-type errors at every call site, so use the
+// T2 type directly.
 use crate::bun_json::{E, Expr, ExprData};
 use bun_ast::{Log, Source};
 use bun_semver::String;
@@ -29,8 +29,8 @@ pub struct CatalogMap {
     pub groups: ArrayHashMap<String, Map>,
 }
 
-/// Zig `String.arrayHashContext(lockfile, null)` — convenience constructor that
-/// reads the lockfile's string buffer for both arg & existing sides. Lives here
+/// Convenience constructor that reads the lockfile's string buffer for both
+/// arg & existing sides. Lives here
 /// (not on `bun_semver::String`) to avoid a `bun_semver → bun_install` back-edge.
 #[inline]
 fn ctx(buf: &[u8]) -> ArrayHashContext<'_> {
@@ -68,8 +68,8 @@ impl CatalogMap {
         group.get_adapted(&dep_name, &ctx(buf)).cloned()
     }
 
-    /// PORT NOTE: Zig took `lockfile: *Lockfile` but only reads its string
-    /// buffer for the hash context. Narrow to `buf: &[u8]` so callers can hold
+    /// Takes `buf: &[u8]` (the lockfile's string buffer, used for the hash
+    /// context) rather than the whole `Lockfile` so callers can hold
     /// `&mut lockfile.catalogs` while only borrowing `buffers.string_bytes`
     /// (disjoint field), instead of forcing a whole-`Lockfile` borrow that
     /// conflicts with the `&mut self` receiver.
@@ -110,8 +110,7 @@ impl CatalogMap {
         )
     }
 
-    // PORT NOTE: Zig took `lockfile: *Lockfile` only for `.allocator` (dropped
-    // per global-mimalloc rule). Removing it lets `lockfile.catalogs.parse_count`
+    // Deliberately takes no `Lockfile` param so `lockfile.catalogs.parse_count`
     // call sites avoid the `&mut self` vs `&mut Lockfile` self-alias.
     pub fn parse_count(&mut self, expr: Expr, builder: &mut StringBuilder) {
         if let Some(default_catalog) = expr.get(b"catalog") {
@@ -165,11 +164,9 @@ impl CatalogMap {
         }
     }
 
-    /// PORT NOTE: Zig threaded `lockfile: *Lockfile` for `.allocator` and
-    /// `.buffers.string_bytes`. The allocator is dropped (global mimalloc) and
-    /// `builder` already holds `&mut string_bytes`, so read the buffer through
-    /// `builder` and drop the `lockfile` param — otherwise call sites would
-    /// alias `&mut lockfile.catalogs` against `&mut lockfile`.
+    /// `builder` already holds `&mut string_bytes`, so the string buffer is
+    /// read through it rather than taking a `lockfile` param — otherwise call
+    /// sites would alias `&mut lockfile.catalogs` against `&mut lockfile`.
     pub fn parse_append(
         &mut self,
         pm: &mut PackageManager,
@@ -300,12 +297,12 @@ impl CatalogMap {
         Ok(found_any)
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig threads `*Lockfile` through, but
-    // the only field this body touches is `lockfile.catalogs`, and the call
-    // site in `pnpm.rs` must simultaneously hold `&mut StringBuf` (which
-    // already borrows `lockfile.buffers.string_bytes` + `lockfile.string_pool`).
-    // Taking `&mut Lockfile` here would alias those borrows, so narrow to
-    // `&mut CatalogMap` and let the caller split the disjoint fields.
+    // The only lockfile field this body touches is `lockfile.catalogs`, and
+    // the call site in `pnpm.rs` must simultaneously hold `&mut StringBuf`
+    // (which already borrows `lockfile.buffers.string_bytes` +
+    // `lockfile.string_pool`). Taking `&mut Lockfile` here would alias those
+    // borrows, so narrow to `&mut CatalogMap` and let the caller split the
+    // disjoint fields.
     pub fn from_pnpm_lockfile(
         catalogs: &mut CatalogMap,
         log: &mut Log,
@@ -339,11 +336,11 @@ impl CatalogMap {
         Ok(())
     }
 
-    // PORT NOTE: Zig took `lockfile: *const Lockfile` but only reads its
-    // string buffer. Narrow to `buffers: &Buffers` so the call site can hold
-    // `&mut lockfile.catalogs` while only borrowing `lockfile.buffers`
-    // immutably (disjoint fields), instead of forcing a whole-`Lockfile`
-    // shared borrow that conflicts with the `&mut self` receiver.
+    // Takes `buffers: &Buffers` rather than the whole `Lockfile` so the call
+    // site can hold `&mut lockfile.catalogs` while only borrowing
+    // `lockfile.buffers` immutably (disjoint fields), instead of forcing a
+    // whole-`Lockfile` shared borrow that conflicts with the `&mut self`
+    // receiver.
     pub fn sort(&mut self, buffers: &Buffers) {
         let buf = buffers.string_bytes.as_slice();
         let dep_less_than = |_: &[String], deps: &[Dependency], l: usize, r: usize| -> bool {
@@ -362,15 +359,15 @@ impl CatalogMap {
             });
     }
 
-    // Zig `deinit(allocator)` deleted: `Map` and `ArrayHashMap<String, Map>` are owned
+    // No explicit `deinit`: `Map` and `ArrayHashMap<String, Map>` are owned
     // collections whose `Drop` recursively frees the nested maps.
 
-    /// PORT NOTE: Zig took `*const Lockfile` but only ever read
-    /// `lockfile.buffers.string_bytes` — accept the slice directly so callers
-    /// can split-borrow the lockfile alongside a live `StringBuilder`.
+    /// Accepts `lockfile.buffers.string_bytes` directly (rather than the whole
+    /// `Lockfile`) so callers can split-borrow the lockfile alongside a live
+    /// `StringBuilder`.
     pub fn count(&self, string_bytes: &[u8], builder: &mut StringBuilder) {
         let buf = string_bytes;
-        // PORT NOTE: `ArrayHashMap::iterator()` requires `&mut`; iterate the
+        // `ArrayHashMap::iterator()` requires `&mut`; iterate the
         // `keys()`/`values()` slices instead so `count` can stay `&self`.
         for (dep_name, dep) in self.default.keys().iter().zip(self.default.values()) {
             builder.count(dep_name.slice(buf));
@@ -387,9 +384,9 @@ impl CatalogMap {
         }
     }
 
-    /// PORT NOTE: Zig also passed `*Lockfile new`, but `builder` already
-    /// borrows `new.buffers.string_bytes` — read the new-side buffer through
-    /// it instead so the call site doesn't alias `&mut new` twice.
+    /// `builder` already borrows the new lockfile's `buffers.string_bytes`, so
+    /// the new-side buffer is read through it instead of taking a separate
+    /// `new: &mut Lockfile` param that would alias `&mut new` twice.
     /// `pm` is generic over `NpmAliasRegistry` (was `&mut PackageManager`) so a
     /// caller already holding `&mut manager.lockfile` can pass
     /// `&mut manager.known_npm_aliases` instead of the whole manager.
@@ -405,10 +402,8 @@ impl CatalogMap {
             .default
             .ensure_total_capacity(self.default.count())?;
 
-        // Zig re-reads `new.buffers.string_bytes.items` at every
-        // `putAssumeCapacityContext` call. Mirror that here: per insert,
-        // finish the `&mut builder` appends FIRST, then snapshot the buffer
-        // for the hash/eql closures. Snapshotting once up-front would freeze
+        // Per insert, finish the `&mut builder` appends FIRST, then snapshot
+        // the buffer for the hash/eql closures. Snapshotting once up-front would freeze
         // the slice length pre-append and OOB-panic on any non-inline key.
         for (dep_name, dep) in self.default.keys().iter().zip(self.default.values()) {
             let new_key = builder.append::<String>(dep_name.slice(old_buf));
@@ -523,5 +518,3 @@ fn put_entries_from_pnpm_lockfile(
     }
     Ok(())
 }
-
-// ported from: src/install/lockfile/CatalogMap.zig
diff --git a/src/install/lockfile/OverrideMap.rs b/src/install/lockfile/OverrideMap.rs
index 15a1f2a9d3e..5c4835c34ff 100644
--- a/src/install/lockfile/OverrideMap.rs
+++ b/src/install/lockfile/OverrideMap.rs
@@ -14,15 +14,13 @@ use super::{StringBuilder, package::Package};
 // LAYERING NOTE: package.json is parsed by `bun_parsers::json` which
 // produces the T2 value-shaped `bun_ast::Expr` (aliased as
 // `crate::bun_json::Expr`), NOT the full T4 `bun_ast::Expr`. JSON parse
-// is always UTF-8, so `as_utf8_string_literal()` is the allocator-free port of
-// Zig's `asString(lockfile.allocator)`.
+// is always UTF-8, so `as_utf8_string_literal()` needs no allocator.
 use crate::bun_json::{Expr, ExprData};
 
 declare_scope!(OverrideMap, visible);
 
 #[derive(Default)]
 pub struct OverrideMap {
-    // Zig used ArrayIdentityContext.U64 (identity hash on u64 key); the Rust
     // `ArrayHashMap` defaults to identity hashing for integer keys.
     pub map: ArrayHashMap<PackageNameHash, Dependency>,
 }
@@ -42,27 +40,27 @@ impl OverrideMap {
         self.map.get(&name_hash).map(|dep| dep.version.clone())
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig took `*const Lockfile` but every
-    // caller already holds `&mut self` on `lockfile.overrides`, so accept just
-    // the string buffer (the only field `sort` reads).
+    // Every caller already holds `&mut self` on `lockfile.overrides`, so
+    // accept just the string buffer (the only lockfile field `sort` reads)
+    // rather than the whole `Lockfile`.
     pub(crate) fn sort(&mut self, string_bytes: &[u8]) {
         self.map.sort(|_, deps: &[Dependency], l, r| {
             deps[l].name.order(deps[r].name, string_bytes, string_bytes) == Ordering::Less
         });
     }
 
-    /// PORT NOTE: Zig took `*const Lockfile` but only ever read
-    /// `lockfile.buffers.string_bytes` — accept the slice directly so callers
-    /// can split-borrow the lockfile alongside a live `StringBuilder`.
+    /// Accepts `lockfile.buffers.string_bytes` directly (rather than the whole
+    /// `Lockfile`) so callers can split-borrow the lockfile alongside a live
+    /// `StringBuilder`.
     pub(crate) fn count(&self, string_bytes: &[u8], builder: &mut StringBuilder) {
         for dep in self.map.values() {
             dep.count(string_bytes, builder);
         }
     }
 
-    /// PORT NOTE: Zig also passed `*Lockfile new`, but it was unused —
-    /// the new-side buffer lives inside `new_builder`. Dropped to avoid the alias.
-    /// `pm` is generic over `NpmAliasRegistry` (was `&mut PackageManager`) so a
+    /// The new-side buffer lives inside `new_builder`, so no separate
+    /// `new: &mut Lockfile` param is taken — that would alias the borrow.
+    /// `pm` is generic over `NpmAliasRegistry` (not `&mut PackageManager`) so a
     /// caller already holding `&mut manager.lockfile` can pass
     /// `&mut manager.known_npm_aliases` instead of the whole manager.
     pub(crate) fn clone<PM: crate::dependency::NpmAliasRegistry>(
@@ -75,7 +73,6 @@ impl OverrideMap {
         new.map.ensure_total_capacity(self.map.count())?;
 
         for (k, v) in self.map.keys().iter().zip(self.map.values()) {
-            // PERF(port): was ensureTotalCapacity + putAssumeCapacity — profile if hot
             new.map
                 .put_assume_capacity(*k, v.clone_in(pm, old_string_bytes, new_builder)?);
         }
@@ -85,10 +82,9 @@ impl OverrideMap {
 
     // the rest of this struct is expression parsing code:
 
-    // PORT NOTE: Zig passed `lockfile: *Lockfile` solely for `lockfile.allocator`
-    // (string transcode); JSON strings are already UTF-8 here, so the parameter
-    // is dropped — also avoids the `&mut lockfile.overrides` / `&mut lockfile`
-    // alias at the only call site.
+    // No `lockfile` param: JSON strings are already UTF-8 here, and omitting
+    // it avoids the `&mut lockfile.overrides` / `&mut lockfile` alias at the
+    // only call site.
     pub(crate) fn parse_count(&mut self, expr: Expr, builder: &mut StringBuilder) {
         if let Some(overrides) = expr.as_property(b"overrides") {
             let ExprData::EObject(obj) = &overrides.expr.data else {
@@ -419,14 +415,13 @@ impl OverrideMap {
     }
 }
 
-// PERF(port): was comptime monomorphization (`comptime field: []const u8`).
-// Only used in warning-message formatting, so runtime &'static str is fine.
+// `field` is only used in warning-message
+// formatting, so a runtime `&'static str` is fine.
 pub fn parse_override_value(
     field: &'static str,
-    // PORT NOTE: Zig took `*Lockfile` but only read `buffers.dependencies` and
-    // `buffers.string_bytes`. Callers hold a live `StringBuilder` (which owns
-    // `&mut string_bytes`), so accept the dependency slice directly and read
-    // string-bytes through `builder.string_bytes`.
+    // Callers hold a live `StringBuilder` (which owns `&mut string_bytes`), so
+    // accept the dependency slice directly and read string-bytes through
+    // `builder.string_bytes` instead of taking the whole `Lockfile`.
     lockfile_dependencies: &[Dependency],
     package_manager: &mut PackageManager,
     root_package: &Package,
@@ -508,5 +503,3 @@ pub fn parse_override_value(
         behavior: Behavior::default(),
     }))
 }
-
-// ported from: src/install/lockfile/OverrideMap.zig
diff --git a/src/install/lockfile/Package.rs b/src/install/lockfile/Package.rs
index 75a1928c4ec..e532f984701 100644
--- a/src/install/lockfile/Package.rs
+++ b/src/install/lockfile/Package.rs
@@ -22,7 +22,7 @@ use crate::{
 // `Package.rs` is mounted as `crate::lockfile_real::package`; the parent module
 // (`super`) is the real `lockfile.rs`, distinct from the `crate::lockfile`
 // stub that lib.rs exposes for downstream crates during the staged port.
-// PORT NOTE: bare `use super as lockfile;` fails when this file is reached via
+// bare `use super as lockfile;` fails when this file is reached via
 // `#[path]` from a non-module context (rust-lang/rust#48067). Name the parent
 // module by its absolute crate path instead.
 use crate::lockfile_real as lockfile;
@@ -50,7 +50,7 @@ trait ExprStr {
     fn as_utf8<'b>(&self, bump: &'b bun_alloc::Arena) -> Option<&'b [u8]>;
 }
 impl ExprStr for Expr {
-    // Zig `Expr.asString` (expr.zig:477) — transparently transcodes UTF-16
+    // Transparently transcodes UTF-16
     // `EString`s. The earlier `is_utf8()` guard returned `None` for keys the
     // lexer stored as UTF-16 (e.g. `\u`-escaped non-ASCII), tripping the
     // `expect("unreachable")` callers below.
@@ -63,16 +63,14 @@ impl ExprStr for Expr {
     }
 }
 
-// Zig: `pub fn Package(comptime SemverIntType: type) type { return extern struct { ... } }`
-// Defaulted to `u64` so bare `Package` matches Zig's primary `Package(u64)`
-// instantiation (the only one the lockfile/PM call sites name unqualified).
+// `SemverIntType` defaults to `u64`, the only instantiation the lockfile/PM
+// call sites name unqualified.
 //
-// PORT NOTE: `` cannot be used here — the derive
+// `#[derive(MultiArrayElement)]` cannot be used here — the derive
 // emits a `PackageField` enum with snake_case variants and an inherent
 // `__MAL_SIZES` const that fail to const-eval through the defaulted
 // `SemverIntType` param. The trait impl, field enum, and `PackageColumns` /
-// `PackageColumns` accessor traits are therefore expanded by hand below
-// (mirroring Zig's `MultiArrayList(Package).items(.field)`).
+// `PackageColumns` accessor traits are therefore expanded by hand below.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct Package<SemverIntType: VersionInt = u64> {
@@ -118,37 +116,27 @@ pub type Resolution<SemverIntType> = ResolutionType<SemverIntType>;
 
 // ─── ResolverContext ─────────────────────────────────────────────────────────
 //
-// Zig used `comptime ResolverContext: type` for `parse`/`parseWithJSON` and
-// branched on `ResolverContext == void` / `== PackageManager.GitResolver` at
-// comptime. Rust models this as a trait with associated consts; concrete
-// resolvers (folder/cache/git) override what they need. The `()` impl gives
-// the `void` semantics.
+// Trait with associated consts; concrete resolvers (folder/cache/git)
+// override what they need. The `()` impl is the no-op resolver.
 pub trait ResolverContext {
-    /// Zig: `comptime ResolverContext == void`.
     const IS_VOID: bool = false;
-    /// Zig: `comptime ResolverContext == PackageManager.GitResolver`.
     const IS_GIT_RESOLVER: bool = false;
 
-    /// Zig: `ResolverContext.checkBundledDependencies()`.
     fn check_bundled_dependencies() -> bool {
         false
     }
 
-    /// Zig: `resolver.count(builder, json)` — counts strings to be appended by
-    /// `resolve`. Default no-op for void/folder resolvers that don't need it.
+    /// Counts strings to be appended by `resolve`. Default no-op for
+    /// void/folder resolvers that don't need it.
     fn count(&mut self, _builder: &mut StringBuilder<'_>, _json: &Expr) {}
 
-    /// Zig: `resolver.resolve(builder, json)` — produces the package's
-    /// `Resolution`. Only called when `!IS_VOID`.
+    /// Produces the package's `Resolution`. Only called when `!IS_VOID`.
     ///
-    /// No default body: Zig enforced this at comptime (a non-void resolver
-    /// without `resolve` failed to compile). Each concrete resolver supplies
-    /// its own body; `()` returns the zero-value `Resolution` to mirror Zig's
-    /// "void leaves `package.resolution` uninitialized" path.
+    /// No default body: each concrete resolver supplies its own; `()` returns
+    /// the zero-value `Resolution`.
     ///
-    /// Zig threaded `comptime IntType` through `parseWithJSON`, but the only
-    /// instantiation is `u64` (`Package.resolution: ResolutionType<u64>`), so
-    /// the trait method is monomorphic — keeps `CacheFolderResolver::resolve`
+    /// The only instantiation is `u64` (`Package.resolution: ResolutionType<u64>`),
+    /// so the trait method is monomorphic — keeps `CacheFolderResolver::resolve`
     /// free of an identity `transmute`.
     fn resolve(
         &mut self,
@@ -157,8 +145,7 @@ pub trait ResolverContext {
     ) -> Result<ResolutionType<u64>, bun_core::Error>;
 
     // ── GitResolver-only surface ────────────────────────────────────────────
-    // Zig accessed `resolver.resolved`, `resolver.new_name`, `resolver.dep_id`
-    // directly when `ResolverContext == GitResolver`. Trait methods so non-git
+    // Trait methods so non-git
     // resolvers don't need the fields; default impls are dead code (gated on
     // `IS_GIT_RESOLVER`). The bodies here are never executed — calls are
     // statically guarded by `if R::IS_GIT_RESOLVER` — so a debug assertion
@@ -196,10 +183,8 @@ impl ResolverContext for () {
         _builder: &mut StringBuilder<'_>,
         _json: &Expr,
     ) -> Result<ResolutionType<u64>, bun_core::Error> {
-        // Zig: `if (comptime ResolverContext != void) { … }` — the void
-        // resolver never assigned `package.resolution`, so it kept its
-        // zero-initialized value. The call site still gates on `!IS_VOID`,
-        // but provide the equivalent behavior for trait completeness.
+        // The call site gates on `!IS_VOID`; return the zero value for
+        // trait completeness.
         Ok(ResolutionType::default())
     }
 }
@@ -291,7 +276,7 @@ impl<R: ResolverContext> ResolverContextDyn for R {
 /// once instead of per-`R`).
 #[inline]
 fn dep_sort_cmp(buf: &[u8], a: &Dependency, b: &Dependency) -> core::cmp::Ordering {
-    // Zig used `std.sort.pdq` with a `<` predicate. `slice::sort_by` requires
+    // `slice::sort_by` requires
     // a total order (and panics since 1.81 when violated), so derive
     // `Ordering::Equal` from the predicate symmetrically.
     if Dependency::is_less_than(buf, a, b) {
@@ -405,20 +390,17 @@ impl<SemverIntType: VersionInt> Package<SemverIntType> {
     }
 }
 
-// PORT NOTE: `clone` / `from_package_json` / `from_npm` / `parse*` all interact
+// `clone` / `from_package_json` / `from_npm` / `parse*` all interact
 // with `Lockfile`, whose package list is concretely `MultiArrayList<Package<u64>>`.
-// Zig's `Package(SemverIntType)` is only ever instantiated at `u64` for these
+// `Package<SemverIntType>` is only ever instantiated at `u64` for these
 // paths (the `u32` instantiation is migration-only and routed through
 // `Serializer::load`). Binding the impl to `u64` avoids spurious
 // `Package<SemverIntType>` ≠ `Package<u64>` mismatches at every Lockfile call
 // site.
 impl Package<u64> {
     pub fn clone(&self, cloner: &mut Cloner) -> Result<PackageID, bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig passes (`pm`, `old`, `new`, `package_id_mapping`,
-        // `cloner`) separately, but `cloner` already owns `&mut` to all four.
-        // Rust borrowck rejects the redundant aliasing at the call site, so
-        // route everything through `cloner`'s disjoint fields here instead.
+        // `cloner` already owns `&mut` to `pm`, `old`, `new`, and
+        // `package_id_mapping`; route everything through its disjoint fields.
         // `old`/`new`/`mapping` are reborrowed for the whole body (disjoint
         // from `cloner.clone_queue` / `.trees_count` / `.old_preinstall_state`);
         // `manager` is accessed via `cloner.manager` at each use so the borrow
@@ -428,7 +410,7 @@ impl Package<u64> {
         let package_id_mapping = &mut *cloner.mapping;
         let old_string_buf = old.buffers.string_bytes.as_slice();
         let old_extern_string_buf = old.buffers.extern_strings.as_slice();
-        // PORT NOTE: `string_builder!` split-borrows only `new.buffers
+        // `string_builder!` split-borrows only `new.buffers
         // .string_bytes` + `new.string_pool`, leaving sibling buffer fields
         // (`dependencies`, `resolutions`, `extern_strings`, `packages`) free
         // for the disjoint borrows below.
@@ -493,17 +475,14 @@ impl Package<u64> {
         // Default-fill the tail so it is valid before `bin.clone` overwrites
         // it (replaces `reserve` + raw `set_len`).
         bun_core::vec::grow_default(&mut new.buffers.extern_strings, new_extern_string_count);
-        // PORT NOTE: Zig passes both `new.buffers.extern_strings.items` (full slice) and a
-        // tail subslice into `bin.clone`; the full slice is only used to compute the tail's
-        // offset for `ExternalStringList::init`. In Rust those two views would alias, so
-        // `Bin::clone_with_buffers` takes the precomputed offset directly.
+        // Passing both the full `extern_strings` slice and a tail subslice into
+        // `bin.clone` would alias, so `Bin::clone_with_buffers` takes the
+        // precomputed tail offset directly.
         let new_extern_strings_start = new.buffers.extern_strings.len() - new_extern_string_count;
 
         let id = new.packages.len() as PackageID;
 
-        // PORT NOTE: Zig calls `appendPackageWithID` mid-body while still
-        // holding live slices into `new.buffers` and the `builder`. Rust can't
-        // express that (the method borrows `&mut Lockfile` whole), so build the
+        // `appendPackageWithID` borrows `&mut Lockfile` whole, so build the
         // `Package` value and clone the dependency strings *first* (only needs
         // disjoint buffer fields), drop the builder, then append, then write
         // resolutions. `appendPackageWithID` touches `packages` /
@@ -592,12 +571,11 @@ impl Package<u64> {
     ) -> Result<Self, bun_core::Error> {
         #[allow(non_snake_case)]
         let FEATURES = features;
-        // TODO(port): narrow error set
         let mut package = Self::default();
 
         // var string_buf = package_json;
 
-        // PORT NOTE: split-borrow `string_bytes`/`string_pool` so the disjoint
+        // split-borrow `string_bytes`/`string_pool` so the disjoint
         // `lockfile.buffers.dependencies/resolutions` borrows below pass.
         let mut string_builder = crate::string_builder!(lockfile);
 
@@ -644,7 +622,6 @@ impl Package<u64> {
             }
 
             let dep_start = dependencies_list.len();
-            // Zig: `@memset(items.ptr[len..total_len], .{})` then bump `.items.len`.
             bun_core::vec::extend_from_fn(
                 dependencies_list,
                 total_dependencies_count as usize,
@@ -709,12 +686,10 @@ impl Package<u64> {
     ) -> Result<Self, bun_core::Error> {
         #[allow(non_snake_case)]
         let FEATURES = features;
-        // TODO(port): narrow error set
         let mut package = Self::default();
 
         let package_version = *package_version_ptr;
 
-        // PERF(port): was comptime-computed array — profile if hot.
         let dependency_groups: &[DependencyGroup] = &{
             let mut out: Vec<DependencyGroup> = Vec::with_capacity(4);
             if FEATURES.dependencies {
@@ -732,7 +707,7 @@ impl Package<u64> {
             out
         };
 
-        // PORT NOTE: split-borrow so `lockfile.buffers.dependencies/resolutions
+        // split-borrow so `lockfile.buffers.dependencies/resolutions
         // /extern_strings` below are disjoint from the builder's `string_bytes`.
         let mut string_builder = crate::string_builder!(lockfile);
 
@@ -744,10 +719,7 @@ impl Package<u64> {
             string_builder.count(manifest.name());
             version.count(&manifest.string_buf, &mut string_builder);
 
-            // PERF(port): was `inline for` — profile if hot.
             for group in dependency_groups {
-                // Zig uses `@field(package_version, group.field)` reflection;
-                // ported as `PackageVersion::dep_group(field) -> ExternalStringMap`.
                 let map: ExternalStringMap = package_version.dep_group(group.field);
                 let keys = map.name.get(&manifest.external_strings);
                 let version_strings = map.value.get(&manifest.external_strings_for_versions);
@@ -805,7 +777,6 @@ impl Package<u64> {
             }
 
             let dep_start = dependencies_list.len();
-            // Zig: `@memset(items.ptr[len..total_len], .{})` then bump `.items.len`.
             bun_core::vec::extend_from_fn(
                 dependencies_list,
                 total_dependencies_count as usize,
@@ -815,7 +786,6 @@ impl Package<u64> {
             let dependencies = &mut dependencies_list[dep_start..total_len];
 
             total_dependencies_count = 0;
-            // PERF(port): was `inline for` — profile if hot.
             for group in dependency_groups {
                 let map: ExternalStringMap = package_version.dep_group(group.field);
                 let keys = map.name.get(&manifest.external_strings);
@@ -1013,7 +983,7 @@ impl DiffSummary {
 }
 
 impl Diff {
-    // PORT NOTE: Zig's `Package` here is the canonical `Package(u64)` (the only
+    // `Package` here is the canonical `Package<u64>` (the only
     // instantiation `Lockfile` ever holds). Dropping the generic avoids a
     // spurious `Package<I>` ≠ `Package<u64>` mismatch on the recursive call
     // through `from_lockfile.packages.get(...)`.
@@ -1027,12 +997,10 @@ impl Diff {
         update_requests: Option<&[UpdateRequest]>,
         mut id_mapping: Option<&mut [PackageID]>,
     ) -> Result<DiffSummary, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut summary = DiffSummary::default();
         let is_root = id_mapping.is_some();
-        // PORT NOTE: Zig held `to_deps` as a mutable slice binding and reassigned
-        // it after `parseWithJSON` (which may grow `to_lockfile.buffers
-        // .dependencies` and invalidate the old slice). Mirror that with raw fat
+        // `parseWithJSON` may grow `to_lockfile.buffers.dependencies` and
+        // invalidate the old slice, so `to_deps` is re-derived after it. Held as raw fat
         // pointers so the `&mut to_lockfile`/`&mut from_lockfile` reborrows below
         // (sort, recursive `generate`) don't conflict with these read views; the
         // recursive call only sorts `overrides`/`catalogs` and never reallocates
@@ -1055,7 +1023,7 @@ impl Diff {
             .resolutions
             .get(from_lockfile.buffers.resolutions.as_slice())
             .into();
-        // See PORT NOTE above — `from_lockfile.buffers` is not reallocated for
+        // See note above — `from_lockfile.buffers` is not reallocated for
         // the lifetime of these references.
         let (from_deps, from_resolutions) = (from_deps.slice(), from_resolutions.slice());
         let mut to_i: usize = 0;
@@ -1067,8 +1035,6 @@ impl Diff {
                 bun_core::pretty_errorln!("Overrides changed since last install");
             }
         } else {
-            // PORT NOTE: reshaped for borrowck — Zig passed `from_lockfile`
-            // twice (once as `&mut self` via `.overrides`, once as `lockfile`).
             // `OverrideMap::sort` only reads `lockfile.buffers.string_bytes`,
             // so split the borrow at the field.
             lockfile::OverrideMap::sort(
@@ -1122,7 +1088,7 @@ impl Diff {
                     break 'catalogs;
                 }
 
-                // PORT NOTE: reshaped for borrowck — see `overrides.sort` note above.
+                // Reshaped for borrowck — see `overrides.sort` note above.
                 lockfile::CatalogMap::sort(&mut from_lockfile.catalogs, &from_lockfile.buffers);
                 lockfile::CatalogMap::sort(&mut to_lockfile.catalogs, &to_lockfile.buffers);
 
@@ -1466,13 +1432,12 @@ impl Diff {
                         let mut package_json_path: AutoAbsPath = AutoAbsPath::init_top_level_dir();
                         // defer package_json_path.deinit(); — Drop handles it
 
-                        // OOM/capacity: Zig aborts; port keeps fire-and-forget
                         let _ = package_json_path.append(
                             workspace_path.slice(to_lockfile.buffers.string_bytes.as_slice()),
                         );
-                        let _ = package_json_path.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                        let _ = package_json_path.append(b"package.json");
 
-                        // PORT NOTE: `bun.sys.File.toSource` was removed from
+                        // `bun.sys.File.toSource` was removed from
                         // T1 (`bun_sys`) because `bun_ast::Source` lives in T2.
                         // Route through the workspace cache's path-based getter
                         // instead, which both reads and parses.
@@ -1512,7 +1477,7 @@ impl Diff {
                         )?;
 
                         // `parse_with_json` may have grown `to_lockfile.buffers
-                        // .dependencies` — re-derive the slice (Zig did the same).
+                        // .dependencies` — re-derive the slice.
                         to_deps = to
                             .dependencies
                             .get(to_lockfile.buffers.dependencies.as_slice())
@@ -1612,7 +1577,6 @@ impl Diff {
             as u32;
 
         if from.resolution.tag != ResolutionTag::Root {
-            // PERF(port): was `inline for` over Lockfile.Scripts.names — profile if hot.
             for (to_hook, from_hook) in to.scripts.hooks().iter().zip(from.scripts.hooks().iter()) {
                 if !String::eql(
                     **to_hook,
@@ -1653,9 +1617,8 @@ impl Package<u64> {
         resolver: &mut R,
         features: Features,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         initialize_store();
-        // Zig threaded `lockfile.allocator` for the JSON arena. The returned
+        // The returned
         // `Expr` tree only needs to live until `parse_with_json` finishes, so
         // a function-local arena is sufficient (matches Scripts.rs / lockfile.rs
         // call sites) and avoids leaking.
@@ -1677,9 +1640,9 @@ impl Package<u64> {
     }
 
     /// Borrow-splitting bridge for `PackageManager` callers
-    /// (`processDependencyList`, `folder_resolver`). Zig passes
-    /// `manager.lockfile`, `manager`, `manager.log` as three separate args;
-    /// Rust borrowck rejects the overlap on `&mut self`, so split via raw
+    /// (`processDependencyList`, `folder_resolver`). Borrowck rejects passing
+    /// `manager.lockfile`, `manager`, `manager.log` as three separate args
+    /// overlapping `&mut self`, so split via raw
     /// pointer here once instead of at every call site.
     ///
     /// # Safety
@@ -1706,10 +1669,7 @@ impl Package<u64> {
         self.parse(lockfile, pm, log, source, resolver, features)
     }
 
-    // Zig: `comptime group: DependencyGroup`, `comptime features: Features`, `comptime tag: ?Dependency.Version.Tag`
-    // PERF(port): was comptime monomorphization on `group`/`tag` — profile if hot.
-    //
-    // PORT NOTE: Zig took `lockfile: *Lockfile`, but the live `StringBuilder`
+    // The live `StringBuilder`
     // (also passed) already holds `&mut lockfile.buffers.string_bytes`. The
     // body only otherwise touches `workspace_paths` / `workspace_versions`,
     // so accept those two maps directly and read `string_bytes` via the
@@ -1733,7 +1693,6 @@ impl Package<u64> {
         key_loc: bun_ast::Loc,
         value_loc: bun_ast::Loc,
     ) -> Result<Option<Dependency>, bun_core::Error> {
-        // TODO(port): narrow error set
         #[cfg(windows)]
         let external_version = 'brk: {
             match tag.unwrap_or_else(|| dependency::version::Tag::infer(version)) {
@@ -1880,7 +1839,7 @@ impl Package<u64> {
                             Some(&mut *pm),
                         ) {
                             // Whole-struct move so `Drop` frees the old npm
-                            // chain; keep the existing `literal` (Zig parity).
+                            // chain; keep the existing `literal`.
                             dep.literal = dependency_version.literal;
                             dependency_version = dep;
                         }
@@ -1961,15 +1920,13 @@ impl Package<u64> {
                                     );
                                 #[cfg(windows)]
                                 {
-                                    // Zig spec (Package.zig:1175-1178) converts
-                                    // `relative_to_common_path_buf()[0..rel.len]` in place but then
-                                    // returns `rel`. With ALWAYS_COPY=false, `rel` may instead borrow
+                                    // With ALWAYS_COPY=false, `rel` may borrow
                                     // RELATIVE_TO_BUF (resolve_path.rs early returns at L450/457/500/
                                     // 522) or be `b""`. Re-deriving a slice of the common-path buf
                                     // would yield stale bytes in those cases. Copy `rel` into the
                                     // common-path scratch when it isn't already there, then convert
-                                    // and return that — preserving the spec's "return `rel`'s bytes"
-                                    // contract while avoiding aliasing UB.
+                                    // and return that — returning `rel`'s bytes
+                                    // while avoiding aliasing UB.
                                     let len = rel.len();
                                     let common_raw = path::relative_to_common_path_buf();
                                     // `PathBuffer` is `repr(transparent)` over `[u8; N]`, so the
@@ -2071,7 +2028,6 @@ impl Package<u64> {
             && !group.behavior.is_peer()
             && !group.behavior.is_workspace()
         {
-            // PERF(port): was assume_capacity
             let entry = duplicate_checker_map.get_or_put(external_alias.hash)?;
             if entry.found_existing {
                 // duplicate dependencies are allowed in optionalDependencies
@@ -2151,12 +2107,10 @@ impl Package<u64> {
     ) -> Result<(), bun_core::Error> {
         #[allow(non_snake_case)]
         let FEATURES = features;
-        // TODO(port): narrow error set
-        // Zig threads `allocator` for `asString` transcoding; the Rust signature
-        // dropped it, so use a function-local arena (transcoded strings are only
-        // borrowed until `string_builder.append` copies them).
+        // Function-local arena for `asString` transcoding (transcoded strings
+        // are only borrowed until `string_builder.append` copies them).
         let bump = bun_alloc::Arena::new();
-        // PORT NOTE: split-borrow `string_bytes`/`string_pool` so the dozens of
+        // split-borrow `string_bytes`/`string_pool` so the dozens of
         // disjoint `lockfile.{buffers.*, overrides, catalogs, workspace_*, …}`
         // accesses below pass borrowck. Reads of `lockfile.buffers.string_bytes`
         // must go through `string_builder.string_bytes` while it's live.
@@ -2270,7 +2224,6 @@ impl Package<u64> {
             resolver.count(&mut string_builder, &json);
         }
 
-        // PERF(port): was comptime-computed array — profile if hot.
         let dependency_groups: Vec<DependencyGroup> = {
             let mut out: Vec<DependencyGroup> = Vec::with_capacity(5);
             if FEATURES.workspaces {
@@ -2329,7 +2282,6 @@ impl Package<u64> {
                                 .expect("infallible: prop has key")
                                 .as_utf8(&bump)
                                 .expect("unreachable");
-                            // PERF(port): was assume_capacity
                             optional_peer_dependencies.put_assume_capacity(
                                 semver::string::Builder::string_hash(key),
                                 key,
@@ -2346,7 +2298,6 @@ impl Package<u64> {
             }
         }
 
-        // PERF(port): was `inline for` — profile if hot.
         for group in &dependency_groups {
             if let Some(dependencies_q) = json.as_property(group.prop) {
                 'brk: {
@@ -2387,7 +2338,6 @@ impl Package<u64> {
                                         let _ = log.add_error_fmt(
                                             source,
                                             packages_expr.loc,
-                                            // TODO: what if we could comptime call the syntax highlighter
                                             format_args!(
                                                 "\"workspaces.packages\" expects an array of strings, e.g.\n  \"workspaces\": {{\n    \"packages\": [\n      \"path/to/package\"\n    ]\n  }}"
                                             ),
@@ -2425,7 +2375,6 @@ impl Package<u64> {
                                         log,
                                         source,
                                         item.value.expect("infallible: prop has value").loc,
-                                        // TODO: what if we could comptime call the syntax highlighter
                                         "{0} expects a map of specifiers, e.g.\n  <r><green>\"{0}\"<r>: {{\n    <green>\"bun\"<r>: <green>\"latest\"<r>\n  }}",
                                         bstr::BStr::new(group.prop)
                                     );
@@ -2452,7 +2401,6 @@ impl Package<u64> {
                                     log,
                                     source,
                                     dependencies_q.loc,
-                                    // TODO: what if we could comptime call the syntax highlighter
                                     "\"workspaces\" expects an array of strings, e.g.\n  <r><green>\"workspaces\"<r>: [\n    <green>\"path/to/package\"<r>\n  ]"
                                 );
                             } else {
@@ -2494,7 +2442,6 @@ impl Package<u64> {
                                 );
                                 return Err(bun_core::err!("InvalidPackageJSON"));
                             };
-                            // PERF(port): was assume_capacity
                             lockfile
                                 .trusted_dependencies
                                 .as_mut()
@@ -2557,9 +2504,7 @@ impl Package<u64> {
             );
         }
 
-        // PORT NOTE: Zig slices `lockfile.buffers.dependencies.items.ptr[off..total_len]`
-        // — i.e. into reserved-but-uncommitted capacity *without* bumping `items.len`.
-        // Mirroring that here matters: `parse_dependency` can return early with an error
+        // `parse_dependency` can return early with an error
         // (e.g. `InstallFailed` for a non-matching `workspace:` range), and the caller
         // may swallow it and re-enter for the next package. If we eagerly grow
         // `dependencies` and then bail, `dependencies.len() != resolutions.len()` on the
@@ -2570,8 +2515,8 @@ impl Package<u64> {
         // assignment would drop garbage), build into a local `Vec` and `append` into the
         // lockfile buffer once all `?`-points are past. On early error the local vec is
         // dropped and `lockfile.buffers.dependencies.len()` is left untouched, preserving
-        // the `== resolutions.len()` invariant exactly as the Zig spare-capacity write
-        // did. Capacity for the final `append` was reserved above so it does not realloc.
+        // the `== resolutions.len()` invariant. Capacity for the final `append`
+        // was reserved above so it does not realloc.
         let mut package_dependencies: Vec<Dependency> = Vec::with_capacity(total_len - off);
 
         'name: {
@@ -2616,7 +2561,6 @@ impl Package<u64> {
                     let key = prop.key.expect("infallible: prop has key");
                     let value = prop.value.expect("infallible: prop has value");
                     if key.is_string() && value.is_string() {
-                        // PERF(port): was stack-fallback
                         let keyhash =
                             semver::string::Builder::string_hash(key.as_utf8(&bump).unwrap());
                         let patch_path =
@@ -2698,10 +2642,9 @@ impl Package<u64> {
                                 if cfg!(debug_assertions) {
                                     debug_assert!(i == extern_strings.len());
                                 }
-                                // PORT NOTE: Zig passed the full extern_strings
-                                // buffer + tail subslice; `init` only needs the
-                                // tail's offset, so construct directly to avoid
-                                // the aliasing borrow.
+                                // `init` only needs the tail's offset, so
+                                // construct directly to avoid an aliasing
+                                // borrow of the full extern_strings buffer.
                                 self.bin = Bin {
                                     tag: bin::Tag::Map,
                                     value: bin::Value {
@@ -2797,7 +2740,6 @@ impl Package<u64> {
 
         total_dependencies_count = 0;
 
-        // PERF(port): was `inline for` — profile if hot.
         for group in &dependency_groups {
             if group.behavior.is_workspace() {
                 let mut seen_workspace_names: ArrayHashMap<
@@ -2820,8 +2762,8 @@ impl Package<u64> {
                         // but this is ok because the install is going to fail anyways, so this
                         // has zero effect on the happy path.
                         let mut cwd_buf = PathBuffer::uninit();
-                        // Zig `bun.getcwd` returned the slice; Rust port returns
-                        // the byte length — slice the buffer ourselves.
+                        // `bun_sys::getcwd` returns the byte length — slice
+                        // the buffer ourselves.
                         let cwd_len = bun_sys::getcwd(&mut cwd_buf.0[..])?;
                         let cwd: &[u8] = &cwd_buf.0[..cwd_len];
 
@@ -2868,8 +2810,7 @@ impl Package<u64> {
                                     // `note_src.path.text`, which itself borrows
                                     // `note_abs_path`; both drop before the log is
                                     // printed. `Location::clone` deep-copies `file`
-                                    // into a `Cow::Owned`, matching the Zig
-                                    // `allocator.dupeZ` lifetime.
+                                    // into a `Cow::Owned`.
                                     notes.push(bun_ast::Data {
                                         text: b"Package name is also declared here".to_vec().into(),
                                         location: bun_ast::Location::init_or_null(
@@ -3154,38 +3095,29 @@ pub type List<SemverIntType> = MultiArrayList<Package<SemverIntType>>;
 pub mod serializer {
     use super::*;
 
-    /// Number of columns in the on-disk package table. Zig: `sizes.Types.len`.
+    /// Number of columns in the on-disk package table.
     pub(crate) const FIELD_COUNT: usize = PackageField::ALL.len();
 
-    // which is unused on the load/save paths we port.)
     pub struct Sizes {
         pub bytes: [usize; FIELD_COUNT],
         pub fields: [usize; FIELD_COUNT],
     }
 
-    // Zig: `const FieldsEnum = @typeInfo(List.Field).@"enum";`
-    // → `PackageField::ALL` (declaration order, same as the MultiArrayList
-    //    field enum Zig reflects over).
-
-    // Zig: `const AlignmentType = sizes.Types[sizes.fields[0]];`
-    // Unused by save/load (the live aligner uses `@TypeOf(list.bytes)`), so
-    // it is intentionally not ported.
-
     pub fn save<SemverIntType: VersionInt, S>(
         list: &List<SemverIntType>,
         stream: &mut S,
     ) -> Result<(), bun_core::Error>
     where
-        // PORT NOTE: Zig threaded a separate `stream` (anytype) and `writer` over
-        // the same buffer. Two `&mut` to one object is UB in Rust regardless of
-        // access order, so the port collapses both roles onto one type —
-        // `Serializer::StreamType` impls both `PositionalStream` and
-        // `bun_io::Write`.
+        // A separate `stream` and `writer` over the same buffer would be two
+        // `&mut` to one object — UB regardless of access order — so both
+        // roles collapse onto one type: `Serializer::StreamType` impls both
+        // `PositionalStream` and `bun_io::Write`.
         S: PositionalStream + bun_io::Write,
     {
-        // TODO(port): narrow error set
         stream.write_int_le::<u64>(list.len() as u64)?;
-        // TODO(port): @alignOf(@TypeOf(list.bytes)) — needs concrete type from MultiArrayList.
+        // The on-disk format records the alignment of the MultiArrayList
+        // bytes *pointer* itself (not the pointee), which is exactly
+        // `align_of::<*mut u8>()` on every supported target.
         stream.write_int_le::<u64>(mem::align_of::<*mut u8>() as u64)?;
         stream.write_int_le::<u64>(FIELD_COUNT as u64)?;
         let begin_at = stream.get_pos()?;
@@ -3193,14 +3125,14 @@ pub mod serializer {
         let end_at = stream.get_pos()?;
         stream.write_int_le::<u64>(0)?;
 
-        // TODO(port): Aligner.write needs the bytes-pointer alignment type.
+        // `*mut u8` carries the pointer alignment, matching the
+        // `@alignOf(@TypeOf(list.bytes))` value serialized above.
         let pos = stream.get_pos()? as u64;
         let _ = Aligner::write::<*mut u8, _>(&mut *stream, pos)?;
 
         let really_begin_at = stream.get_pos()?;
         let mut sliced = list.slice();
 
-        // PERF(port): was `inline for (FieldsEnum.fields)` — profile if hot.
         for field in PackageField::ALL {
             // SAFETY: each `PackageField` discriminant corresponds to a column
             // whose element size matches `SIZES_BYTES[field as usize]`; we
@@ -3225,17 +3157,17 @@ pub mod serializer {
                     bytes.len(),
                 );
             }
-            // TODO(port): assert_no_uninitialized_padding once a typed accessor
-            // is exposed; for now `Package`'s field types are all `#[repr(C)]`
-            // with explicit padding zeroed by their `Default`/`init` paths.
+            // No uninitialized padding: `Package`'s field types are all
+            // `#[repr(C)]` with explicit padding zeroed by their
+            // `Default`/`init` paths.
             if matches!(field, PackageField::Resolution) {
                 // copy each resolution to make sure the union is zero initialized
                 let resolutions: &[Resolution<SemverIntType>] =
                     sliced.items::<"resolution", Resolution<SemverIntType>>();
                 for val in resolutions {
                     // `ResolutionType::copy` builds a fresh zero-initialised
-                    // `Resolution` and writes only the active union member,
-                    // matching Zig `val.copy()`. A bare `*val` would serialise
+                    // `Resolution` and writes only the active union member.
+                    // A bare `*val` would serialise
                     // garbage in the inactive union bytes (non-deterministic
                     // lockfile output).
                     let copy = val.copy();
@@ -3265,7 +3197,7 @@ pub mod serializer {
         pub needs_update: bool,
     }
 
-    // PORT NOTE: Zig parameterised on `SemverIntType`, but the v2-migration arm
+    // The v2-migration arm
     // below hard-codes `u32 → u64` (`VersionedURL.migrate()` returns `<u64>`).
     // The only caller (`bun.lockb.rs`) instantiates at `u64`, so bind concretely
     // instead of carrying a phantom generic that can't typecheck the migrate arm.
@@ -3275,7 +3207,6 @@ pub mod serializer {
         migrate_from_v2: bool,
     ) -> Result<PackagesLoadResult<u64>, bun_core::Error> {
         type SemverIntType = u64;
-        // TODO(port): narrow error set
         let reader = stream.reader();
 
         let list_len = reader.read_int_le::<u64>()?;
@@ -3289,7 +3220,8 @@ pub mod serializer {
 
         let mut list = List::<SemverIntType>::default();
 
-        // TODO(port): @alignOf(@TypeOf(list.bytes)) — needs MultiArrayList bytes ptr type.
+        // The recorded alignment is that of the MultiArrayList bytes
+        // *pointer* itself, i.e. pointer alignment.
         let expected_alignment = mem::align_of::<*mut u8>() as u64;
         if expected_alignment != input_alignment {
             return Err(bun_core::err!(
@@ -3385,7 +3317,6 @@ pub mod serializer {
                     },
                 };
 
-                // PERF(port): was assume_capacity
                 list.append(new)?;
             }
         } else {
@@ -3403,11 +3334,9 @@ pub mod serializer {
         list: &mut List<SemverIntType>,
         needs_update: &mut bool,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let _n = list.len();
         let mut sliced = list.slice();
 
-        // PERF(port): was `inline for (FieldsEnum.fields)` — profile if hot.
         for field in PackageField::ALL {
             let sz = bun_collections::multi_array_list::Slice::<Package<SemverIntType>>::field_size(
                 field as usize,
@@ -3421,7 +3350,6 @@ pub mod serializer {
                     sliced.column_bytes_mut(field as usize)
                 }
             };
-            // TODO(port): assert_no_uninitialized_padding once a typed accessor lands.
             let end_pos = stream.pos + bytes.len();
             if end_pos as u64 <= end_at {
                 let src = &stream.buffer[stream.pos..stream.pos + bytes.len()];
@@ -3507,5 +3435,3 @@ pub mod serializer {
 }
 
 pub use serializer as Serializer;
-
-// ported from: src/install/lockfile/Package.zig
diff --git a/src/install/lockfile/Package/Meta.rs b/src/install/lockfile/Package/Meta.rs
index ed0b68f12cc..b2dc06922c9 100644
--- a/src/install/lockfile/Package/Meta.rs
+++ b/src/install/lockfile/Package/Meta.rs
@@ -85,10 +85,9 @@ impl Meta {
         self.has_install_script == HasInstallScript::Old
     }
 
-    // PORT NOTE: Zig used `comptime StringBuilderType: type` duck-typing for the
-    // builder param. The only concrete instantiation in install is
-    // `*Lockfile.StringBuilder`, so we take it directly here instead of a
-    // placeholder trait that nothing implements.
+    // The only concrete builder type used in install is the lockfile
+    // `StringBuilder`, so take it directly instead of a placeholder trait that
+    // nothing implements.
     pub fn count(&self, buf: &[u8], builder: &mut LockfileStringBuilder<'_>) {
         builder.count(self.man_dir.slice(buf));
     }
@@ -98,7 +97,7 @@ impl Meta {
     }
 
     /// Named `clone_into` (not `clone`) to avoid shadowing `Clone::clone` now
-    /// that `Meta: Clone + Copy`. Mirrors Zig `Meta.clone(id, buf, Builder, builder)`.
+    /// that `Meta: Clone + Copy`.
     pub fn clone_into(
         &self,
         id: PackageID,
@@ -117,5 +116,3 @@ impl Meta {
         }
     }
 }
-
-// ported from: src/install/lockfile/Package/Meta.zig
diff --git a/src/install/lockfile/Package/Scripts.rs b/src/install/lockfile/Package/Scripts.rs
index dd02cbcfad7..5ccaae504de 100644
--- a/src/install/lockfile/Package/Scripts.rs
+++ b/src/install/lockfile/Package/Scripts.rs
@@ -11,8 +11,7 @@ use bun_semver::String as SemverString;
 use bun_sys::{self, Fd};
 
 use crate::bun_json::{self, Expr};
-// PORT NOTE: Zig used `comptime Builder: type` duck-typing for the builder
-// param. The only concrete instantiation in install is `*Lockfile.StringBuilder`,
+// The only concrete builder instantiation in install is the lockfile's,
 // so we take `crate::lockfile_real::StringBuilder` directly (matches Meta.rs).
 use crate::lockfile_real::{Lockfile as RealLockfile, StringBuilder as LockfileStringBuilder};
 
@@ -33,8 +32,8 @@ pub struct Scripts {
 }
 
 impl Scripts {
-    /// (name, getter) table mirroring Zig `inline for (std.meta.fieldNames(Lockfile.Scripts))`.
-    /// Used by debug JSON serialization in place of comptime field reflection.
+    /// (name, getter) table used by debug JSON serialization in place of
+    /// field reflection.
     pub const FIELD_NAMES: &'static [(&'static str, fn(&Scripts) -> &SemverString)] = &[
         (LockfileScripts::NAMES[0], |s| &s.preinstall),
         (LockfileScripts::NAMES[1], |s| &s.install),
@@ -45,8 +44,7 @@ impl Scripts {
     ];
 
     /// Helper: indexed access matching `Lockfile.Scripts.names` order.
-    /// Zig used `@field(this, hook)` over `Lockfile.Scripts.names`; Rust has no
-    /// field-by-name reflection, so we tabulate the 6 hooks explicitly.
+    /// The 6 hooks are tabulated explicitly (no field-by-name reflection).
     #[inline]
     pub fn hooks(&self) -> [&SemverString; SCRIPT_NAMES_LEN] {
         [
@@ -59,7 +57,7 @@ impl Scripts {
         ]
     }
 
-    /// Alias of [`hooks`] for callers porting Zig `inline for (Scripts.names)`.
+    /// Alias of [`hooks`].
     #[inline]
     pub fn iter_all(&self) -> [&SemverString; SCRIPT_NAMES_LEN] {
         self.hooks()
@@ -87,7 +85,6 @@ impl Scripts {
     }
 
     /// Named `clone_into` (not `clone`) to avoid shadowing `Clone::clone`.
-    /// Mirrors Zig `Scripts.clone(buf, Builder, builder)`.
     pub fn clone_into(&self, buf: &[u8], builder: &mut LockfileStringBuilder<'_>) -> Scripts {
         if !self.filled {
             return Scripts::default();
@@ -99,7 +96,6 @@ impl Scripts {
         for (dst, src) in scripts.hooks_mut().into_iter().zip(self.hooks()) {
             *dst = builder.append::<SemverString>(src.slice(buf));
         }
-        // PERF(port): was `inline for` over comptime name list — profile if hot.
         scripts
     }
 
@@ -107,7 +103,6 @@ impl Scripts {
         for hook in self.hooks() {
             builder.count(hook.slice(buf));
         }
-        // PERF(port): was `inline for` over comptime name list — profile if hot.
     }
 
     pub fn has_any(&self) -> bool {
@@ -120,10 +115,8 @@ impl Scripts {
     }
 
     /// return: (first_index, total, entries)
-    /// PORT NOTE: Zig also passed `*const Lockfile` (for `allocator`); the
-    /// allocator is gone in Rust and the parameter was already unused — drop
-    /// it so callers can split-borrow `lockfile.{packages, scripts}` while
-    /// this only reads `lockfile_buf`.
+    /// Takes only `lockfile_buf` (not the whole `Lockfile`) so callers can
+    /// split-borrow `lockfile.{packages, scripts}`.
     pub fn get_script_entries(
         &self,
         lockfile_buf: &[u8],
@@ -171,7 +164,6 @@ impl Scripts {
                 }
                 script_index += 1;
             }
-            // PERF(port): was `inline for` over tuple — profile if hot.
         }
 
         match resolution_tag {
@@ -189,7 +181,6 @@ impl Scripts {
                     }
                     script_index += 1;
                 }
-                // PERF(port): was `inline for` over tuple — profile if hot.
             }
             ResolutionTag::Workspace => {
                 script_index += 1;
@@ -235,10 +226,9 @@ impl Scripts {
                     break 'brk cwd_.slice();
                 };
                 // Resolve the canonical path, then close the directory HANDLE.
-                // (Zig spec at Scripts.zig:209-210 leaks `cwd_handle`; we fix
-                // that here rather than faithfully porting the leak — `Fd` is
-                // `Copy` with no `Drop`, so without this explicit close one
-                // kernel directory HANDLE leaks per script-bearing package.)
+                // (`Fd` is `Copy` with no `Drop`, so without this explicit
+                // close one kernel directory HANDLE leaks per script-bearing
+                // package.)
                 let path = bun_sys::get_fd_path(cwd_handle, &mut cwd_buf);
                 let _ = bun_sys::close(cwd_handle);
                 match path {
@@ -251,7 +241,7 @@ impl Scripts {
                 items: scripts,
                 first_index: u8::try_from(first_index).expect("int cast"),
                 total,
-                // Zig `allocator.dupeZ(u8, cwd)` — owned NUL-terminated copy.
+                // Owned NUL-terminated copy.
                 cwd: ZBox::from_bytes(cwd),
                 package_name: Box::<[u8]>::from(package_name),
             });
@@ -260,17 +250,15 @@ impl Scripts {
         None
     }
 
-    // Zig: `comptime Builder: type, builder: Builder` — duck-typed over any
-    // builder with `.count` / `.append`. Generic over `bun_semver::StringBuilder`
+    // Generic over `bun_semver::StringBuilder`
     // so both `lockfile_real::StringBuilder` and `bun_semver::semver_string::Builder`
     // are accepted (both impl the trait).
-    // PORT NOTE: `json` is `Copy` (matches Zig by-value `Expr`).
     pub fn parse_count<B: bun_semver::StringBuilder>(builder: &mut B, json: Expr) {
         if let Some(scripts_prop) = json.as_property(b"scripts") {
             if scripts_prop.expr.is_object() {
                 for script_name in LockfileScripts::NAMES {
                     if let Some(script) = scripts_prop.expr.get(script_name.as_bytes()) {
-                        // PORT NOTE: Zig `script.asString(allocator)` — JSON parser
+                        // The JSON parser
                         // produces UTF-8 `EString`s, so the alloc-free literal accessor
                         // is sufficient here.
                         if let Some(input) = script.as_utf8_string_literal() {
@@ -278,7 +266,6 @@ impl Scripts {
                         }
                     }
                 }
-                // PERF(port): was `inline for` over comptime name list — profile if hot.
             }
         }
     }
@@ -294,7 +281,6 @@ impl Scripts {
                         }
                     }
                 }
-                // PERF(port): was `inline for` + `@field` — profile if hot.
             }
         }
     }
@@ -307,7 +293,6 @@ impl Scripts {
         folder_name: &[u8],
         resolution: &Resolution,
     ) -> Result<Option<List>, bun_core::Error> {
-        // TODO(port): narrow error set
         if self.has_any() {
             let add_node_gyp_rebuild_script =
                 if lockfile.has_trusted_dependency(folder_name, folder_name, resolution)
@@ -317,7 +302,7 @@ impl Scripts {
                     // `defer save.restore()` — `save()` returns an RAII guard that
                     // restores the path length on Drop and derefs to the path.
                     let mut save = folder_path.save();
-                    let _ = save.append(b"binding.gyp"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    let _ = save.append(b"binding.gyp");
 
                     bun_sys::exists(save.slice())
                 } else {
@@ -351,8 +336,7 @@ impl Scripts {
         log: &mut bun_ast::Log,
         folder_path: &mut bun_paths::AutoAbsPath,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig threaded `allocator` for JSON parsing; the Rust JSON
+        // The JSON
         // parser uses a bump arena. Scoped here since the AST is consumed
         // immediately into the string builder. `json_buf` is hoisted so the
         // source bytes outlive the parsed `Expr` (which may borrow them).
@@ -362,7 +346,7 @@ impl Scripts {
             // `defer save.restore()` — `save()` returns an RAII guard that
             // restores the path length on Drop and derefs to the path.
             let mut save = folder_path.save();
-            let _ = save.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = save.append(b"package.json");
 
             json_buf = bun_sys::File::read_from(Fd::cwd(), save.slice_z())?;
             let json_src = bun_ast::Source::init_path_string(save.slice(), json_buf.as_slice());
@@ -386,8 +370,6 @@ impl Scripts {
         folder_name: &[u8],
         resolution_tag: ResolutionTag,
     ) -> Result<Option<List>, bun_core::Error> {
-        // TODO(port): narrow error set
-        // Zig: `var tmp: Lockfile = undefined; tmp.initEmpty(allocator)`.
         let mut tmp = RealLockfile::init_empty_value();
         // `defer tmp.deinit()` — `tmp` stays empty (only `string_builder` borrows it), so field
         // auto-drop suffices; Lockfile has no `impl Drop`.
@@ -398,7 +380,7 @@ impl Scripts {
             // `defer save.restore()` — `save()` returns an RAII guard that
             // restores the path length on Drop and derefs to the path.
             let mut save = folder_path.save();
-            let _ = save.append(b"binding.gyp"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = save.append(b"binding.gyp");
 
             bun_sys::exists(save.slice())
         } else {
@@ -425,8 +407,7 @@ pub enum PrintFormat {
     Untrusted,
 }
 
-// PORT NOTE: `Clone` — Zig had borrowed slices so `list.*` was a shallow
-// pointer copy. The Rust port owns `cwd`/`package_name`/`items`, but
+// `Clone` — `List` owns `cwd`/`package_name`/`items`, but
 // `runTasks.rs` (`.run_scripts` arm) and `lifecycle_script_runner` need a
 // by-value copy while the original allocation in `Store.entries.scripts`
 // must stay live for the post-install pass, so a deep clone is required.
@@ -435,8 +416,7 @@ pub struct List {
     pub items: [Option<Box<[u8]>>; SCRIPT_NAMES_LEN],
     pub first_index: u8,
     pub total: u8,
-    // Zig `stringZ` ([:0]const u8) owned via `allocator.dupeZ`; (commented-out)
-    // deinit frees it → owned NUL-terminated heap string, not a borrow.
+    // Owned NUL-terminated heap string, not a borrow.
     pub cwd: ZBox,
     pub package_name: Box<[u8]>,
 }
@@ -448,7 +428,6 @@ impl List {
         resolution_buf: &[u8],
         format_type: PrintFormat,
     ) {
-        // PERF(port): was comptime enum param — profile if hot.
         let needle = bun_paths::NODE_MODULES_NEEDLE;
         if let Some(i) = strings::index_of(self.cwd.as_bytes(), needle) {
             bun_core::pretty!(
@@ -498,16 +477,7 @@ impl List {
         self.items[self.first_index as usize].as_ref().unwrap()
     }
 
-    // pub fn deinit(this: Package.Scripts.List, std.mem.Allocator param) void {
-    //     for (this.items) |maybe_item| {
-    //         if (maybe_item) |item| {
-    //             allocator.free(item);
-    //         }
-    //     }
-    //
-    //     allocator.free(this.cwd);
-    // }
-    // (Commented out in Zig too; Box<[u8]> fields drop automatically.)
+    // No manual deinit: `Box<[u8]>` fields drop automatically.
 
     pub fn append_to_lockfile(&self, lockfile: &mut Lockfile) {
         for (i, maybe_script) in self.items.iter().enumerate() {
@@ -519,15 +489,11 @@ impl List {
                     BStr::new(&self.package_name),
                     BStr::new(self.cwd.as_bytes()),
                 );
-                // Zig: `@field(lockfile.scripts, Lockfile.Scripts.names[i]).append(...)`
                 lockfile
                     .scripts
                     .hook_mut(i)
                     .push(script.to_vec().into_boxed_slice());
-                // PERF(port): was `inline for` + appendAssumeCapacity-style — profile if hot.
             }
         }
     }
 }
-
-// ported from: src/install/lockfile/Package/Scripts.zig
diff --git a/src/install/lockfile/Package/WorkspaceMap.rs b/src/install/lockfile/Package/WorkspaceMap.rs
index 34e45fb3006..4bd32b90655 100644
--- a/src/install/lockfile/Package/WorkspaceMap.rs
+++ b/src/install/lockfile/Package/WorkspaceMap.rs
@@ -54,7 +54,7 @@ impl WorkspaceMap {
     }
 
     pub(crate) fn insert(&mut self, key: &[u8], value: Entry) -> Result<(), bun_alloc::AllocError> {
-        // Zig has a debug-only `bun.sys.exists(key)` check here, but `key` is
+        // No `bun.sys.exists(key)` debug check here: `key` is
         // relative to the workspace root while `exists` resolves against process
         // cwd — false positive whenever the two differ (e.g. `bun unlink` from a
         // workspace package). Existence is already verified by the caller via
@@ -93,7 +93,7 @@ fn process_workspace_name(
         )
         .unwrap()?;
 
-    // Scratch arena for `as_string_cloned` (Zig threaded the heap allocator);
+    // Scratch arena for `as_string_cloned`;
     // results are immediately boxed so the bump can drop at scope exit.
     let scratch = Arena::new();
 
@@ -146,10 +146,10 @@ impl WorkspaceMap {
 
         let mut workspace_globs: Vec<Box<[u8]>> = Vec::new();
         let mut filepath_buf_os: Box<PathBuffer> = Box::new(PathBuffer::uninit());
-        // PERF(port): Zig used allocator.create(PathBuffer) to avoid large stack frame
+        // Boxed to avoid a large stack frame.
         let filepath_buf: &mut [u8] = &mut filepath_buf_os.0[..];
 
-        // Scratch arena for `as_string_z` (Zig threaded the heap allocator).
+        // Scratch arena for `as_string_z`.
         let scratch = Arena::new();
 
         for item in arr.slice() {
@@ -291,13 +291,11 @@ impl WorkspaceMap {
 
         if workspace_globs.len() > 0 {
             let mut arena = Arena::new();
-            // PERF(port): was arena bulk-free per-iteration via reset(.retain_capacity)
             for (i, user_pattern) in workspace_globs.iter().enumerate() {
-                // PORT NOTE: Zig `defer arena.reset()` ran *after* iter.deinit()/walker.deinit() at
-                // end of each iter. In Rust, walker/iter borrow `&arena` and Drop at scope exit,
+                // walker/iter borrow `&arena` and Drop at scope exit,
                 // so resetting here (top of next iter) ensures they drop before invalidation.
                 // Last iter's allocs are freed when `arena` itself drops after the loop.
-                // Spec is `.reset(.retain_capacity)` — keep the `mi_heap` warm
+                // Capacity is retained to keep the `mi_heap` warm
                 // across glob patterns × matched dirs.
                 arena.reset_retain_with_limit(8 * 1024 * 1024);
                 let glob_pattern: &[u8] = if user_pattern.len() == 0 {
@@ -311,9 +309,9 @@ impl WorkspaceMap {
                 if cwd.is_empty() {
                     cwd = bun_resolver::fs::FileSystem::instance().top_level_dir();
                 }
-                // PORT NOTE: GlobWalker::init_with_cwd is now an associated constructor
+                // GlobWalker::init_with_cwd is now an associated constructor
                 // returning `Result<Maybe<Self>>`; arena param dropped (heap-backed),
-                // ignore filter supplied as final arg (was comptime fn param in Zig).
+                // ignore filter supplied as final arg.
                 let mut walker = match GlobWalker::init_with_cwd(
                     glob_pattern,
                     cwd,
@@ -338,8 +336,8 @@ impl WorkspaceMap {
                         return Err(bun_core::err!("GlobError"));
                     }
                 };
-                // walker dropped at end of loop iter (Drop impl handles deinit(false))
-                // TODO(port): GlobWalker::deinit(false) — Drop cannot take params; assume default Drop matches `false`
+                // walker dropped at end of loop iter; GlobWalker is heap-backed with no
+                // arena, and its Drop only logs + frees owned Vec/Box fields.
 
                 let mut iter = glob::walk::Iterator::new(&mut walker);
                 if let Err(e) = iter.init()? {
@@ -520,8 +518,7 @@ impl WorkspaceMap {
         }
 
         // Sort the names for determinism
-        // PORT NOTE: reshaped for borrowck — Zig captured `values()` slice in sort ctx;
-        // here ArrayHashMap::sort provides values internally to the comparator.
+        // ArrayHashMap::sort provides values internally to the comparator.
         workspace_names
             .map
             .sort(|_keys, values: &[Entry], a: usize, b: usize| {
@@ -543,10 +540,7 @@ fn ignored_workspace_paths(path: &[u8]) -> bool {
     false
 }
 
-// PORT NOTE: Zig `glob.GlobWalker(ignoredWorkspacePaths, glob.walk.SyscallAccessor, false)` —
-// the comptime ignore-filter fn param was lowered to a runtime fn-pointer field on
+// The ignore-filter is a runtime fn-pointer field on
 // `bun_glob::GlobWalker` (const-generic fn ptrs are unstable). Supplied via
 // `init_with_cwd(..., Some(ignored_workspace_paths))`.
 type GlobWalker = glob::GlobWalker<glob::walk::SyscallAccessor, false>;
-
-// ported from: src/install/lockfile/Package/WorkspaceMap.zig
diff --git a/src/install/lockfile/Tree.rs b/src/install/lockfile/Tree.rs
index d6f2863a166..4f867c8e83f 100644
--- a/src/install/lockfile/Tree.rs
+++ b/src/install/lockfile/Tree.rs
@@ -18,7 +18,7 @@ use crate::{
 // Tree
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: `#[repr(C)]` pins field order to declaration order so the raw
+// `#[repr(C)]` pins field order to declaration order so the raw
 // in-memory bytes match the `[u8; 20]` `External` encoding read by
 // `Buffers::load` (which decodes via `to_tree` assuming
 // id|dep_id|parent|off|len). Under `repr(Rust)` rustc may reorder fields and
@@ -72,10 +72,10 @@ pub(crate) const MAX_DEPTH: usize = (MAX_PATH_BYTES / b"node_modules".len()) + 1
 
 pub(crate) type DepthBuf = [Id; MAX_DEPTH];
 
-/// Zig `var depth_buf: Tree.DepthBuf = undefined;` — write-only scratch buffer
+/// Write-only scratch buffer
 /// for [`relative_path_and_depth`]. Every slot is written before it is read
 /// (index 0 unconditionally, indices `1..depth_buf_len` in the parent-walk
-/// loop), so leaving the ~1.4 KB array uninitialised matches the spec and
+/// loop), so leaving the ~1.4 KB array uninitialised is sound and
 /// avoids a `memset` per tree in the `--frozen-lockfile` no-change path.
 /// Same shape/contract as [`bun_core::PathBuffer::uninit`].
 #[inline]
@@ -176,7 +176,7 @@ pub enum IteratorPathStyle {
     PkgPath,
 }
 
-// PORT NOTE: reshaped — Zig stores `lockfile: *const Lockfile`; here we store
+// Stores
 // the four buffer slices the iterator actually reads so callers from both
 // `crate::lockfile` (stub) and `crate::lockfile_real` can drive the same
 // iterator without a unified `Lockfile` type (reconciler-6).
@@ -234,7 +234,6 @@ impl<'a, const PATH_STYLE: IteratorPathStyle> Iterator<'a, PATH_STYLE> {
             dependencies,
             string_bytes,
             path_buf: PathBuffer::uninit(),
-            // Zig: `depth_stack: DepthBuf = undefined` (Tree.zig:94)
             depth_stack: depth_buf_uninit(),
         };
         if PATH_STYLE == IteratorPathStyle::NodeModules {
@@ -247,8 +246,7 @@ impl<'a, const PATH_STYLE: IteratorPathStyle> Iterator<'a, PATH_STYLE> {
         self.tree_id = 0;
     }
 
-    // TODO(port): Zig signature varies `completed_trees` type by `path_style` (void when .pkg_path).
-    // Here we accept `Option<&mut DynamicBitSet>` unconditionally; callers with PkgPath must pass None.
+    // `Option<&mut DynamicBitSet>` is accepted unconditionally; callers with PkgPath must pass None.
     pub fn next(
         &mut self,
         completed_trees: Option<&mut DynamicBitSet>,
@@ -259,7 +257,7 @@ impl<'a, const PATH_STYLE: IteratorPathStyle> Iterator<'a, PATH_STYLE> {
             return None;
         }
 
-        // PORT NOTE: reshaped for borrowck — cannot mutably borrow completed_trees in loop while moved.
+        // reshaped for borrowck — cannot mutably borrow completed_trees in loop while moved.
         let mut completed_trees = completed_trees;
 
         while trees[self.tree_id as usize].dependencies.len == 0 {
@@ -306,7 +304,7 @@ pub fn folder_name_is_safe(name: &[u8]) -> bool {
 }
 
 /// Returns relative path and the depth of the tree
-// PORT NOTE: reshaped — Zig takes `*const Lockfile`; here we take the three
+// Takes the three
 // buffer slices directly so callers from both `crate::lockfile` (stub) and
 // `crate::lockfile_real` can use this without a shared `Lockfile` type.
 pub(crate) fn relative_path_and_depth<'b, const PATH_STYLE: IteratorPathStyle>(
@@ -385,7 +383,6 @@ pub(crate) fn relative_path_and_depth<'b, const PATH_STYLE: IteratorPathStyle>(
             path_written = name_end;
 
             if PATH_STYLE == IteratorPathStyle::NodeModules {
-                // Zig: std.fs.path.sep_str ++ "node_modules" (always 13 bytes)
                 if path_written + b"/node_modules".len() >= MAX_PATH_BYTES {
                     path_too_long();
                 }
@@ -421,23 +418,20 @@ pub enum BuilderMethod {
     Filter,
 }
 
-// TODO(port): Zig conditionally typed `manager`/`workspace_filters`/`install_root_dependencies`/
-// `packages_to_install` as `void` when method != .filter. Rust const generics cannot vary field
-// types; using Option<_>/empty defaults instead. TODO(refactor): split into two structs or use a
-// trait-associated type if the size matters.
+// Const generics cannot vary field
+// types, so `manager`/`workspace_filters`/`install_root_dependencies`/`packages_to_install`
+// are `Option<_>`/empty defaults and only meaningful when `METHOD == .Filter`.
 pub struct Builder<'a, const METHOD: BuilderMethod> {
-    // PORT NOTE: Zig `std.mem.Allocator` param field dropped. Sole construction site is
-    // `Lockfile.hoist()` (src/install/lockfile.zig) which passes `lockfile.allocator` — the
-    // lockfile's persistent allocator (bun.default_allocator via PackageManager/CLI ctx), not an
-    // arena. Global mimalloc is correct here; no `&'bump Bump` threading needed.
+    // No allocator field: the sole construction site is `Lockfile.hoist()`,
+    // whose allocations are persistent, not arena-scoped. Global mimalloc is
+    // correct here; no `&'bump Bump` threading needed.
     pub list: MultiArrayList<BuilderEntry>,
     pub resolutions: &'a mut [PackageID],
     pub dependencies: &'a [Dependency],
     pub resolution_lists: &'a [DependencyIDSlice],
     pub queue: TreeFiller,
     pub log: &'a mut bun_ast::Log,
-    /// PORT NOTE: Zig stores `*Lockfile` alongside `&mut buffers.resolutions`
-    /// (an aliased subslice of the same struct). Stored as `ParentRef` (raw
+    /// Stored as `ParentRef` (raw
     /// non-null backref) so the construction site (`Lockfile::hoist`) can
     /// split-borrow `resolutions` mutably without borrowck rejecting the
     /// overlap; reads go through [`Builder::lockfile()`] which never touches
@@ -501,10 +495,6 @@ impl<'a, const METHOD: BuilderMethod> Builder<'a, METHOD> {
     pub(crate) fn clean(&mut self) -> Result<CleanResult, AllocError> {
         let mut total: u32 = 0;
 
-        // TODO(port): Zig captured `list.bytes` raw pointer to reuse the MultiArrayList backing
-        // allocation for the output `trees` slice. That optimization depends on MultiArrayList
-        // internal layout. Porting the straightforward path (fresh Vec<Tree>) instead.
-        // PERF(port): was MultiArrayList buffer reuse — profile if hot.
         let mut slice = self.list.to_owned_slice();
         let mut trees: Vec<Tree> = slice.items_tree().to_vec();
         let dependencies: &mut [DependencyIDList] = slice.items_dependencies_mut();
@@ -519,7 +509,7 @@ impl<'a, const METHOD: BuilderMethod> Builder<'a, METHOD> {
         for (tree, child) in trees.iter_mut().zip(dependencies.iter_mut()) {
             let child = core::mem::take(child);
 
-            // PERF(port): `dep_ids` is pre-reserved to `total` (sum of all
+            // `dep_ids` is pre-reserved to `total` (sum of all
             // `tree.dependencies.len: u32`), so `len()` is provably < 2^32.
             // Avoid the `try_from` panic-format path on this per-tree hot loop.
             let off: u32 = dep_ids.len() as u32;
@@ -530,7 +520,6 @@ impl<'a, const METHOD: BuilderMethod> Builder<'a, METHOD> {
                     continue;
                 }
 
-                // PERF(port): was assume_capacity
                 dep_ids.push(dep_id);
             }
             let len: u32 = dep_ids.len() as u32 - off;
@@ -540,7 +529,7 @@ impl<'a, const METHOD: BuilderMethod> Builder<'a, METHOD> {
         }
 
         // queue / sort_buf / pending_optional_peers freed by Drop; explicit deinit removed.
-        // TODO(port): if Builder outlives clean(), explicitly clear these fields here.
+        // The sole caller (`Lockfile::hoist`) drops the Builder immediately after clean().
 
         slice.deinit_owned();
 
@@ -552,10 +541,9 @@ impl<'a, const METHOD: BuilderMethod> Builder<'a, METHOD> {
 // is_filtered_dependency_or_workspace
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: reshaped — Zig reads `lockfile.buffers.resolutions[dep_id]` directly,
-// but `Builder` holds a live `&mut [PackageID]` over that buffer (see `Builder.lockfile`
-// safety contract), so callers must thread `resolutions` explicitly to avoid an
-// aliasing read through the shared `&Lockfile`.
+// `Builder` holds a live `&mut [PackageID]` over the resolutions buffer (see
+// `Builder.lockfile` safety contract), so callers must thread `resolutions`
+// explicitly to avoid an aliasing read through the shared `&Lockfile`.
 pub(crate) fn is_filtered_dependency_or_workspace(
     dep_id: DependencyID,
     parent_pkg_id: PackageID,
@@ -639,7 +627,7 @@ pub(crate) fn is_filtered_dependency_or_workspace(
     let mut workspace_matched = workspace_filters.is_empty();
 
     for filter in workspace_filters {
-        // bun.AbsPath(.{ .sep = .posix }) — separator is a const generic on `bun_paths::AbsPath`.
+        // Separator is a const generic on `bun_paths::AbsPath`.
         let mut filter_path = bun_paths::AbsPath::<
             u8,
             { bun_paths::path_options::PathSeparators::POSIX },
@@ -720,7 +708,7 @@ impl Tree {
             dependencies: DependencyIDList::default(),
         })?;
 
-        // PORT NOTE: reshaped for borrowck.
+        // reshaped for borrowck.
         let next_id = (builder.list.len() - 1) as Id;
 
         // Copy the `ParentRef` out (it's `Copy`) so the resulting `&Lockfile`
@@ -730,7 +718,7 @@ impl Tree {
         let lockfile: &Lockfile = lockfile_ref.get();
         let pkgs = lockfile.packages.slice();
         let pkg_resolutions = pkgs.items_resolution();
-        // PORT NOTE: reshaped for borrowck — copy the `&'a [Dependency]` out of
+        // reshaped for borrowck — copy the `&'a [Dependency]` out of
         // `builder` so `&dependencies[i]` does not keep `builder` borrowed.
         let dependencies: &[Dependency] = builder.dependencies;
 
@@ -738,14 +726,13 @@ impl Tree {
         builder.sort_buf.reserve(resolution_list.len as usize);
 
         for dep_id in resolution_list.begin()..resolution_list.end() {
-            // PERF(port): was assume_capacity. `resolution_list` bounds are u32
+            // `resolution_list` bounds are u32
             // (`ExternalSlice<u32>`); the range value is already u32-ranged.
             builder.sort_buf.push(dep_id);
         }
 
         {
             let sorter = DepSorter { lockfile };
-            // PERF(port): Zig used std.sort.pdq; Rust slice::sort_unstable_by is also pdqsort.
             builder.sort_buf.sort_unstable_by(|a, b| {
                 if DepSorter::is_less_than(&sorter, *a, *b) {
                     core::cmp::Ordering::Less
@@ -757,7 +744,7 @@ impl Tree {
             });
         }
 
-        // PORT NOTE: reshaped for borrowck — iterate over a snapshot of sort_buf indices since
+        // reshaped for borrowck — iterate over a snapshot of sort_buf indices since
         // builder is mutably borrowed inside the loop.
         let sort_buf_len = builder.sort_buf.len();
         'dep: for sort_idx in 0..sort_buf_len {
@@ -946,8 +933,7 @@ impl Tree {
                 }
                 HoistDependencyResult::Placement(dest) => {
                     {
-                        // PORT NOTE: reshaped for borrowck — Zig held both `items(.dependencies)`
-                        // and `items(.tree)` mutably from one slice; here we go through ListExt
+                        // Go through ListExt
                         // accessors sequentially so the &mut borrows do not overlap.
                         // bun.handleOom -> push (aborts on OOM via global allocator)
                         builder.list.items_dependencies_mut()[dest.id as usize].push(dep_id);
@@ -970,7 +956,7 @@ impl Tree {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — re-read `next` via index.
+        // reshaped for borrowck — re-read `next` via index.
         let next: Tree = builder.list.items_tree()[next_id as usize];
         if next.dependencies.len == 0 {
             if cfg!(debug_assertions) {
@@ -987,9 +973,7 @@ impl Tree {
     // 2 (return id) - move the package to the top directory
     // 3 (return dependency_loop) - leave the package at the same (relative) directory
     //
-    // PORT NOTE: reshaped for borrowck — Zig passed `&mut self` (an element of `trees`) plus
-    // `trees: &mut [Tree]`, `dependency_lists: &mut [...]`, and `builder: &mut Builder`
-    // simultaneously, which overlaps mutable borrows. The body never mutates `self`, `trees`,
+    // The body never mutates the tree, `trees`,
     // or `dependency_lists`, so we take `self_id: Id` by value and re-derive read-only views
     // from `builder.list` on each access. `dependency` is passed by id and re-derived from
     // `builder.dependencies` (a `&'a [Dependency]` field, copied out so the borrow detaches
@@ -1007,7 +991,7 @@ impl Tree {
 
         // Tree is Copy — snapshot the fields we need so we don't hold a borrow of builder.list.
         let this: Tree = builder.list.items_tree()[self_id as usize];
-        // Hoist the dep-id slice once (Zig: `this.dependencies.get(dependency_lists[this.id].items)`).
+        // Hoist the dep-id slice once.
         // `builder.list` is not mutated for the duration of this loop (the recursive call happens
         // *after* it), so the slice is stable; detach to raw ptr/len so the loop body can freely
         // take `&builder` / `&mut builder.log` without borrowck re-deriving the view per iteration.
@@ -1023,8 +1007,8 @@ impl Tree {
             // SAFETY: `i < this_deps_len` and `builder.list` is not mutated until after this loop
             // (see invariant above), so `this_deps_ptr[0..this_deps_len)` remains valid.
             let dep_id: DependencyID = unsafe { *this_deps_ptr.add(i) };
-            // SAFETY: `dep_id` was produced by the same lockfile that produced `deps`;
-            // Zig release builds have no bounds check here.
+            // SAFETY: `dep_id` was produced by the same lockfile that produced `deps`,
+            // so it is always in bounds.
             let dep = unsafe { deps.get_unchecked(dep_id as usize) };
             if dep.name_hash != target_name_hash {
                 continue;
@@ -1093,7 +1077,7 @@ impl Tree {
             }
 
             if AS_DEFINED && !dep.behavior.is_peer() {
-                // PORT NOTE: reshaped for borrowck — `maybe_report_error` takes
+                // reshaped for borrowck — `maybe_report_error` takes
                 // `&mut self` but the format args borrow `&self` (via
                 // `package_name`/`package_version`/`buf`). Inline against split
                 // field borrows: copy the `ParentRef` out so the `&Lockfile` is
@@ -1164,9 +1148,6 @@ pub struct FillItem {
     pub hoist_root_id: Id,
 }
 
-// bun.LinearFifo(FillItem, .Dynamic) — std.fifo.LinearFifo wrapper.
-// Mapped to bun_collections::LinearFifo<T, DynamicBuffer<T>> (dynamic, heap-backed ring buffer).
+// Dynamic, heap-backed ring buffer.
 pub(crate) type TreeFiller =
     bun_collections::LinearFifo<FillItem, bun_collections::linear_fifo::DynamicBuffer<FillItem>>;
-
-// ported from: src/install/lockfile/Tree.zig
diff --git a/src/install/lockfile/bun.lock.rs b/src/install/lockfile/bun.lock.rs
index 9661811ab25..2792159180a 100644
--- a/src/install/lockfile/bun.lock.rs
+++ b/src/install/lockfile/bun.lock.rs
@@ -1,4 +1,4 @@
-//! Port of `src/install/lockfile/bun.lock.zig` — text lockfile (bun.lock) stringifier and parser.
+//! Text lockfile (bun.lock) stringifier and parser.
 
 use bun_collections::VecExt;
 use core::fmt::Write as _;
@@ -37,7 +37,7 @@ use crate::npm::Negatable;
 use crate::package_manager_real::Options as PackageManagerOptions;
 use crate::repository::RepositoryExt as _;
 use bun_install_types::DependencyVersionTag;
-// PORT NOTE: this file is `crate::lockfile_real::bun_lock`; `super` is the
+// this file is `crate::lockfile_real::bun_lock`; `super` is the
 // real `Lockfile` module, distinct from the `crate::lockfile` stub.
 use super::PackageIDSlice;
 use super::package::{Meta, PackageColumns as _};
@@ -48,8 +48,7 @@ use super::{
 
 use bun_io::AsFmt;
 
-/// `Bin::to_json` indent callback typed against `AsFmt` (Zig passed
-/// `Stringifier.writeIndent` directly; here the writer types differ).
+/// `Bin::to_json` indent callback typed against `AsFmt`.
 fn write_indent_fmt(w: &mut AsFmt<'_>, indent: &mut u32) -> core::fmt::Result {
     for _ in 0..*indent {
         w.write_str("  ")?;
@@ -57,7 +56,7 @@ fn write_indent_fmt(w: &mut AsFmt<'_>, indent: &mut u32) -> core::fmt::Result {
     Ok(())
 }
 
-/// Zig `String.arrayHashContext(lockfile, null)` — both arg and existing keys
+/// Both arg and existing keys
 /// resolve against the lockfile's string buffer.
 #[inline]
 fn string_array_hash_context(buf: &[u8]) -> bun_semver::string::ArrayHashContext<'_> {
@@ -77,9 +76,8 @@ pub(crate) fn url_is_under_registry(url: &[u8], registry: &[u8]) -> bool {
         && (url.len() == registry.len() || url[registry.len()] == b'/')
 }
 
-// PORT NOTE: reshaped for borrowck. Zig keeps a single `var string_buf =
-// lockfile.stringBuf()` for the whole parser, but in Rust that locks out every
-// other `lockfile.*` access (the `string_buf()` method borrows the whole
+// A single `lockfile.string_buf()` held for the whole parser would lock out
+// every other `lockfile.*` access (the `string_buf()` method borrows the whole
 // receiver). Construct a fresh `Buf` at each append site so the disjoint
 // `buffers.string_bytes` / `string_pool` borrows end immediately and the
 // borrow checker can see that catalog/workspace/package mutations touch
@@ -93,9 +91,7 @@ macro_rules! sbuf {
     };
 }
 
-// TODO(port): narrow to a concrete byte-writer trait once bun_io stabilizes.
-// PERF(port): anytype → dyn dispatch (Zig used `writer: anytype`; PORTING.md
-// prefers `impl Trait`, but the trait shape is unsettled so dyn for now).
+// Dyn dispatch for now — the trait shape is unsettled.
 type Writer = dyn bun_io::Write;
 // `bun_io::Write` returns `core::result::Result<_, bun_core::Error>` (see
 // `bun_io::write::Result`), so the writer error is just the global `bun_core::Error`.
@@ -299,14 +295,11 @@ impl Stringifier {
         options: &PackageManagerOptions,
         writer: &mut Writer,
     ) -> Result<(), WriteError> {
-        // TODO(port): narrow error set
         let buf = lockfile.buffers.string_bytes.as_slice();
         let extern_strings = lockfile.buffers.extern_strings.as_slice();
         let deps_buf = lockfile.buffers.dependencies.as_slice();
         let resolution_buf = lockfile.buffers.resolutions.as_slice();
         let pkgs = lockfile.packages.slice();
-        // PORT NOTE: Zig `pkgs.items(.field)` → derive(MultiArrayElement)-generated
-        // `items_<field>()` column accessors on `Slice<Package>`.
         let pkg_dep_lists: &[DependencySlice] = pkgs.items_dependencies();
         let pkg_resolutions: &[Resolution] = pkgs.items_resolution();
         let pkg_names: &[String] = pkgs.items_name();
@@ -328,7 +321,7 @@ impl Stringifier {
 
         let mut pkg_map: PkgMap<()> = PkgMap::init();
 
-        // PORT NOTE: `from_slices` (vs `init(lockfile)`) is used so the iterator
+        // `from_slices` (vs `init(lockfile)`) is used so the iterator
         // borrows only `buffers.{trees,hoisted_dependencies,dependencies,string_bytes}`;
         // `overrides`/`catalogs` are mutated below while the iterator is still live.
         let mut pkgs_iter = tree::Iterator::<'_, { tree::IteratorPathStyle::PkgPath }>::from_slices(
@@ -420,7 +413,6 @@ impl Stringifier {
                     let r_res = &pkg_resolutions[r as usize];
                     l_res.workspace().order(*r_res.workspace(), buf, buf)
                 });
-                // PERF(port): std.sort.pdq — Rust sort_by is also pattern-defeating quicksort
 
                 for &workspace_pkg_id in &workspace_sort_buf {
                     let res = &pkg_resolutions[workspace_pkg_id as usize];
@@ -537,7 +529,6 @@ impl Stringifier {
             pkgs_iter.reset();
 
             tree_sort_buf.sort_by(tree_sort_is_less_than);
-            // PERF(port): std.sort.pdq
 
             if found_trusted_dependencies.len() > 0 {
                 Self::write_indent(writer, *indent)?;
@@ -686,7 +677,6 @@ impl Stringifier {
                             core::cmp::Ordering::Equal
                         }
                     });
-                    // PERF(port): std.sort.pdq with isLessThan
                 }
 
                 for &dep_id in &tree_deps_sort_buf {
@@ -757,7 +747,6 @@ impl Stringifier {
                     pkg_deps_sort_buf.reserve(pkg_deps_list.len as usize);
                     for pkg_dep_id in pkg_deps_list.begin()..pkg_deps_list.end() {
                         pkg_deps_sort_buf.push(pkg_dep_id);
-                        // PERF(port): was assume_capacity
                     }
 
                     // there might be duplicate names due to dependency behaviors,
@@ -1072,8 +1061,7 @@ impl Stringifier {
         relative_path: &[u8],
         path_buf: &mut [u8],
     ) -> Result<(), WriteError> {
-        // TODO(port): narrow error set to { OutOfMemory, WriteFailed }
-        // PORT NOTE: Zig `defer optional_peers_buf.clearRetainingCapacity()` moved to fn tail.
+        // `optional_peers_buf` is cleared at the fn tail.
         // Error path (`?` on writer) aborts the whole save in the caller, so skipping the
         // clear on early-return cannot leak stale entries into a subsequent call.
 
@@ -1081,7 +1069,6 @@ impl Stringifier {
 
         let mut any = false;
         for &(group_name, group_behavior) in WORKSPACE_DEPENDENCY_GROUPS.iter() {
-            // PERF(port): was `inline for` — profile if it shows up on a hot path
             let mut first = true;
             for &dep_id in pkg_dep_ids {
                 let dep = &deps_buf[dep_id as usize];
@@ -1250,8 +1237,7 @@ impl Stringifier {
         relative_path: &[u8],
         path_buf: &mut [u8],
     ) -> Result<(), WriteError> {
-        // TODO(port): narrow error set to { OutOfMemory, WriteFailed }
-        // PORT NOTE: Zig `defer optional_peers_buf.clearRetainingCapacity()` moved to fn tail.
+        // `optional_peers_buf` is cleared at the fn tail.
         // Error path (`?` on writer) aborts the whole save in the caller, so skipping the
         // clear on early-return cannot leak stale entries into a subsequent call.
 
@@ -1320,7 +1306,6 @@ impl Stringifier {
         }
 
         for &(group_name, group_behavior) in WORKSPACE_DEPENDENCY_GROUPS.iter() {
-            // PERF(port): was `inline for` — profile if it shows up on a hot path
             let mut first = true;
             for dep in pkg_deps[pkg_id as usize].get(deps_buf) {
                 if !dep.behavior.intersects(group_behavior) {
@@ -1494,8 +1479,8 @@ pub(crate) enum ResolveError {
 }
 
 impl<T> PkgMap<T> {
-    // PORT NOTE: Zig `pub const Entry = T;` — inherent associated types are
-    // unstable in Rust; callers name `T` directly.
+    // No `Entry` alias — inherent associated types are
+    // unstable; callers name `T` directly.
 
     pub(crate) fn init() -> Self {
         Self {
@@ -1623,7 +1608,6 @@ pub fn parse_into_binary_lockfile(
                         break 'err;
                     }
 
-                    // std.math.divExact(f64, num.value, 1) catch break :err
                     if num.value.fract() != 0.0 {
                         break 'err;
                     }
@@ -2181,7 +2165,7 @@ pub fn parse_into_binary_lockfile(
 
     if lockfile_version != Version::V0 {
         // these are the `workspaceOnly` packages
-        // PORT NOTE: snapshot the workspace-path handles up front so the loop
+        // snapshot the workspace-path handles up front so the loop
         // body can take `&mut *lockfile` (`parse_append_dependencies`,
         // `append_package_dedupe`) without conflicting with the
         // `workspace_paths.values()` iterator borrow. `String` is `Copy`.
@@ -2786,7 +2770,6 @@ pub fn parse_into_binary_lockfile(
                 .len()
                 .saturating_sub(lockfile.buffers.resolutions.len()),
         );
-        // Zig: ensureTotalCapacityPrecise → expandToCapacity → @memset(invalid_package_id).
         lockfile
             .buffers
             .resolutions
@@ -2797,9 +2780,7 @@ pub fn parse_into_binary_lockfile(
         // is chosen (dev -> optional -> prod -> peer)
         let mut seen_deps: bun_collections::StringArrayHashMap<()> = Default::default();
 
-        // PORT NOTE: Zig grabs `pkgs.items(.meta)` / `.items(.resolution)` as
-        // mutable column slices, writes index 0, then keeps the resolution slice
-        // for read-only lookups. In Rust the two `[0]` writes are done first via
+        // The two `[0]` writes are done first via
         // sequential `&mut` accessors so the loops can take all column views
         // immutably without overlapping exclusive borrows or `unsafe`.
         lockfile.packages.items_resolution_mut()[0] =
@@ -2813,8 +2794,7 @@ pub fn parse_into_binary_lockfile(
 
         // Disjoint-field split of `lockfile.buffers` so each loop body can hold
         // `&mut dependencies[i]` and `&mut resolutions[i]` together with a shared
-        // `string_bytes` view (Zig's `*Dependency` / `lockfile.buffers.*.items`
-        // accesses freely alias the same struct).
+        // `string_bytes` view.
         let buffers = &mut lockfile.buffers;
         let string_buf: &[u8] = buffers.string_bytes.as_slice();
         let dependencies: &mut [Dependency] = buffers.dependencies.as_mut_slice();
@@ -3009,9 +2989,9 @@ pub fn parse_into_binary_lockfile(
     Ok(())
 }
 
-// PORT NOTE: Zig signature takes `*BinaryLockfile` plus a `*Dependency` that
-// points into `lockfile.buffers.dependencies` — fine in Zig, illegal aliasing in
-// Rust. The function only touches `buffers.resolutions[dep_id]` and reads
+// Taking `&mut BinaryLockfile` plus a `&mut Dependency` that
+// points into `lockfile.buffers.dependencies` would be illegal aliasing.
+// The function only touches `buffers.resolutions[dep_id]` and reads
 // `text_lockfile_version`, so accept those disjoint pieces directly and let the
 // caller split-borrow `lockfile.buffers`.
 fn map_dep_to_pkg(
@@ -3086,10 +3066,9 @@ fn dependency_resolution_failure(
     Ok(())
 }
 
-// PORT NOTE: Zig threaded `string_buf: *String.Buf` separately from `lockfile`.
-// In Rust the `Buf` borrows the same `lockfile.buffers.string_bytes` /
-// `string_pool` fields, so the two parameters alias. The `buf` parameter is
-// dropped and each append constructs a fresh `sbuf!(lockfile)` so the borrow
+// A separate `string_buf` parameter would borrow the same
+// `lockfile.buffers.string_bytes` / `string_pool` fields and alias `lockfile`.
+// Instead each append constructs a fresh `sbuf!(lockfile)` so the borrow
 // checker can see the disjoint field accesses against `buffers.dependencies`
 // and `workspace_paths`.
 fn parse_append_dependencies<const CHECK_FOR_BUNDLED: bool, const IS_ROOT: bool>(
@@ -3098,14 +3077,14 @@ fn parse_append_dependencies<const CHECK_FOR_BUNDLED: bool, const IS_ROOT: bool>
     log: &mut bun_ast::Log,
     source: &bun_ast::Source,
     optional_peers_buf: &mut HashMap<u64, ()>,
-    // Zig: `if (check_for_bundled) string else void` → carried as Option, gated by const generic
+    // Only meaningful when `CHECK_FOR_BUNDLED`; carried as Option.
     pkg_path: Option<&[u8]>,
     bundled_pkgs: Option<&PkgPathSet>,
     workspaces_obj: Option<&Expr>,
 ) -> Result<(u32, u32), ParseError> {
-    // PORT NOTE: defer optional_peers_buf.clearRetainingCapacity() moved to fn tail
-    // (and to each early-return path implicitly via clear-on-next-call semantics in caller).
-    // TODO(port): if exact defer semantics matter on error paths, wrap in scopeguard.
+    // Clearing on entry is equivalent to clearing on every exit path for all
+    // callers (none read the buf between calls) and also covers early-error exits.
+    optional_peers_buf.clear();
 
     if let Some(optional_peers) = obj.get(b"optionalPeers") {
         if !optional_peers.is_array() {
@@ -3137,7 +3116,6 @@ fn parse_append_dependencies<const CHECK_FOR_BUNDLED: bool, const IS_ROOT: bool>
 
     let off = lockfile.buffers.dependencies.len();
     for &(group_name, group_behavior) in WORKSPACE_DEPENDENCY_GROUPS.iter() {
-        // PERF(port): was `inline for` — profile if it shows up on a hot path
         if let Some(deps) = obj.get(group_name.as_bytes()) {
             if !deps.is_object() {
                 log.add_error(Some(source), deps.loc, b"Expected an object");
@@ -3285,8 +3263,7 @@ fn parse_append_dependencies<const CHECK_FOR_BUNDLED: bool, const IS_ROOT: bool>
 
     {
         let bytes = lockfile.buffers.string_bytes.as_slice();
-        // Zig: `std.sort.pdq(..., Dependency.isLessThan)`. `slice::sort_by` is
-        // also pattern-defeating quicksort; `Dependency::cmp` is the
+        // `slice::sort_by` is pattern-defeating quicksort; `Dependency::cmp` is the
         // total-order form of `isLessThan` (behavior group, then name ASC).
         lockfile.buffers.dependencies[off..].sort_by(|a, b| Dependency::cmp(bytes, a, b));
     }
@@ -3298,5 +3275,3 @@ fn parse_append_dependencies<const CHECK_FOR_BUNDLED: bool, const IS_ROOT: bool>
         u32::try_from(end - off).expect("int cast"),
     ))
 }
-
-// ported from: src/install/lockfile/bun.lock.zig
diff --git a/src/install/lockfile/bun.lockb.rs b/src/install/lockfile/bun.lockb.rs
index 826bda09c35..6dc55dca00e 100644
--- a/src/install/lockfile/bun.lockb.rs
+++ b/src/install/lockfile/bun.lockb.rs
@@ -1,12 +1,11 @@
 //! Binary lockfile (bun.lockb) serializer/deserializer.
-//! Port of `src/install/lockfile/bun.lockb.zig` (`const Serializer = @This();`).
 
 use crate::lockfile::package::PackageColumns as _;
 use core::mem::{align_of, size_of};
 
 use bun_core::Error;
 use bun_io::Write as _;
-// PORT NOTE: `Lockfile`/`Stream`/`StringPool`/`package_index` live in the parent
+// `Lockfile`/`Stream`/`StringPool`/`package_index` live in the parent
 // `lockfile_real` module (this file is `lockfile_real::bun_lockb`). The
 // `bun_install::lockfile::*` path is the stub surface and lacks these items.
 use super::PatchedDep;
@@ -24,16 +23,14 @@ use bun_core::strings;
 use bun_install::{PackageID, PackageManager, PackageNameAndVersionHash, PackageNameHash};
 use bun_semver::{self as semver, String as SemverString};
 
-// TODO(port): z_allocator is a zeroing allocator (bun.z_allocator). In Rust,
-// the equivalent is a wrapper that zeroes allocations. Provide
-// `bun_alloc::ZAllocator` or ensure padding bytes are zeroed via
-// `#[derive(zeroize)]` / explicit zeroing on the serialized structs.
+// Serialized padding bytes must be deterministic; the per-field
+// save path zeroes padding explicitly (see the note in `save` and the
+// `assert_no_uninitialized_padding` invariant in `Package::Serializer`).
 
 pub const VERSION: &[u8] = b"bun-lockfile-format-v0\n";
-// PORT NOTE: Zig: "#!/usr/bin/env bun\n" ++ version
 const HEADER_BYTES: &[u8] = b"#!/usr/bin/env bun\nbun-lockfile-format-v0\n";
 
-// `@bitCast(@as([8]u8, "...".*))` → native-endian reinterpretation of 8 bytes as u64.
+// Native-endian reinterpretation of 8 bytes as u64.
 const HAS_PATCHED_DEPENDENCIES_TAG: u64 = u64::from_ne_bytes(*b"pAtChEdD");
 const HAS_WORKSPACE_PACKAGE_IDS_TAG: u64 = u64::from_ne_bytes(*b"wOrKsPaC");
 const HAS_TRUSTED_DEPENDENCIES_TAG: u64 = u64::from_ne_bytes(*b"tRuStEDd");
@@ -46,9 +43,9 @@ const HAS_CONFIG_VERSION_TAG: u64 = u64::from_ne_bytes(*b"cNfGvRsN");
 /// (`get_pos`/`pwrite`) and append semantics (`write_all`/`write_int_*`) for
 /// `Lockfile.Package.Serializer.save` / `Lockfile.Buffers.save`.
 ///
-/// PORT NOTE: reshaped for borrowck — Zig held a separate `stream` and `writer`
-/// over the same `bytes` simultaneously (legal in Zig, aliased `&mut` in Rust).
-/// Collapsed into a single type so callers pass exactly one `&mut StreamType`.
+/// A separate `stream` and `writer` over the same `bytes` would be two
+/// aliased `&mut`s, so both roles are collapsed into a single type and
+/// callers pass exactly one `&mut StreamType`.
 ///
 /// LIFETIMES.tsv: `bytes` is BORROW_PARAM → `&'a mut Vec<u8>`.
 pub(crate) struct StreamType<'a> {
@@ -90,15 +87,15 @@ fn write_array<T>(
     buffers::write_array(stream, array, prefix)
 }
 
-// Section header strings, byte-for-byte as Zig's `@typeName`/`@sizeOf`/`@alignOf`
-// emit them. The reader skips these by absolute offset (see `buffers::read_array`),
-// so they are semantically inert; we match Zig's bytes only so that re-saving an
-// unchanged lockfile is a no-op across the Zig→Rust migration.
+// Section header strings, byte-for-byte as historical writers emitted them.
+// The reader skips these by absolute offset (see `buffers::read_array`),
+// so they are semantically inert; we match the historical bytes only so that
+// re-saving an unchanged lockfile is a no-op.
 //
 // Primitive-type tags (`u64`, `u32`, `[26]u8`) are stable. Struct-type tags have
-// already drifted across Zig versions in this repo (`src.install.lockfile.Tree`
+// already drifted across format revisions (`src.install.lockfile.Tree`
 // → `install.lockfile.Tree`), so for `Version`/`String`/`PatchedDep` — which no
-// checked-in fixture exercises — we emit the current Zig decl path; the const
+// checked-in fixture exercises — we emit the most recent decl path; the const
 // asserts below catch any size/align drift even if the name is later wrong.
 const PREFIX_U64: &str = "\n<u64> 8 sizeof, 8 alignof\n";
 const PREFIX_U32: &str = "\n<u32> 4 sizeof, 4 alignof\n";
@@ -174,18 +171,11 @@ pub fn save(
     total_size: &mut usize,
     end_pos: &mut usize,
 ) -> Result<(), Error> {
-    // we clone packages with the z_allocator to make sure bytes are zeroed.
-    // TODO: investigate if we still need this now that we have `padding_checker.zig`
-    // TODO(port): z_allocator clone — `MultiArrayList::clone` requires
-    // `Package: MultiArrayElement` (not yet derived). The Zig path only exists
-    // to zero padding bytes for byte-exact serialization; the per-field writers
-    // below already zero-pad via `assert_no_uninitialized_padding`, so skipping
-    // the clone is a no-op for correctness. Revisit once the derive lands.
-    // let old_packages_list = core::mem::replace(&mut this.packages, this.packages.clone_zeroed()?);
-    // drop(old_packages_list);
-
-    // PORT NOTE: reshaped for borrowck — Zig holds `writer` and `stream` over
-    // the same `bytes` simultaneously; collapsed into a single `StreamType`.
+    // No defensive clone of `packages` is needed for byte-exact serialization:
+    // the per-field writers below already zero-pad via the
+    // `assert_no_uninitialized_padding` invariant.
+
+    // `writer` and `stream` roles are collapsed into a single `StreamType`.
     let mut stream = StreamType { bytes };
 
     stream.write_all(HEADER_BYTES)?;
@@ -231,12 +221,10 @@ pub fn save(
         }
     }
 
-    // PORT NOTE: Zig passes `StreamType` (type) + `stream` (value) +
-    // `@TypeOf(writer)` + `writer` as separate comptime/runtime args. In Rust the
-    // callees take a single `&mut S: PositionalStream + bun_io::Write` (both
+    // The callees take a single `&mut S: PositionalStream + bun_io::Write` (both
     // roles collapsed onto `StreamType`) — two `&mut` aliases of one object would
     // be UB regardless of access order.
-    // PORT NOTE: turbofish — `this.packages` is `PackageList = List<u64>`, but
+    // turbofish — `this.packages` is `PackageList = List<u64>`, but
     // inference through `MultiArrayList<Package<_>>` is brittle when sibling
     // generic types in the crate have errors. Pin SemverIntType explicitly.
     package::serializer::save::<u64, _>(&this.packages, &mut stream)?;
@@ -279,7 +267,6 @@ pub fn save(
         stream.write_all(&HAS_OVERRIDES_TAG.to_ne_bytes())?;
 
         write_array::<PackageNameHash>(&mut stream, this.overrides.map.keys(), PREFIX_U64)?;
-        // PERF(port): Zig uses z_allocator + initCapacity then sets items.len directly.
         let mut external_overrides: Vec<dependency::External> =
             Vec::with_capacity(this.overrides.map.count());
         for src in this.overrides.map.values() {
@@ -318,7 +305,6 @@ pub fn save(
             PREFIX_SEMVER_STRING,
         )?;
 
-        // PERF(port): Zig uses z_allocator + initCapacity then sets items.len directly.
         let mut external_deps_buf: Vec<dependency::External> =
             Vec::with_capacity(this.catalogs.default.count());
         for src in this.catalogs.default.values() {
@@ -338,8 +324,7 @@ pub fn save(
             write_array::<SemverString>(&mut stream, catalog_deps.keys(), PREFIX_SEMVER_STRING)?;
 
             external_deps_buf.reserve(catalog_deps.count().saturating_sub(external_deps_buf.len()));
-            // PORT NOTE: Zig sets `items.len = count` then writes each slot via `dest.* = ...`.
-            // Reshape: push into the cleared Vec instead.
+            // Push into the cleared Vec.
             for src in catalog_deps.values() {
                 external_deps_buf.push(dependency::to_external(src));
             }
@@ -376,10 +361,8 @@ pub(crate) fn load(
     log: &mut Log,
     mut manager: Option<&mut PackageManager>,
 ) -> Result<SerializerLoadResult, Error> {
-    // TODO(port): narrow error set
     let mut res = SerializerLoadResult::default();
-    // PORT NOTE: Zig's `var reader = stream.reader();` is a thin view over the
-    // same buffer. `FixedBufferStream` exposes the read methods directly, so we
+    // `FixedBufferStream` exposes the read methods directly, so we
     // call them on `stream` to avoid holding a long-lived `&mut` borrow that
     // would conflict with the `stream.pos` / `stream.buffer` accesses below.
     let mut header_buf_: [u8; HEADER_BYTES.len()] = [0; HEADER_BYTES.len()];
@@ -406,7 +389,7 @@ pub(crate) fn load(
     }
 
     lockfile.format = FormatVersion::current();
-    // PORT NOTE: `lockfile.allocator = allocator;` dropped — global mimalloc.
+    // `lockfile.allocator = allocator;` dropped — global mimalloc.
 
     let _ = stream.read_all(&mut lockfile.meta_hash)?;
 
@@ -470,17 +453,15 @@ pub(crate) fn load(
                         let mut versions_list: Vec<semver::Version> =
                             Vec::with_capacity(old_versions_list.len());
                         for old_version in &old_versions_list {
-                            // PERF(port): was assume_capacity
                             versions_list.push(old_version.migrate());
                         }
 
                         break 'workspace_versions_list versions_list;
                     };
 
-                    // TODO(port): comptime type assertion that VersionHashMap key/value types
-                    // match PackageNameHash / Semver.Version. Rust cannot express this as a
-                    // const block without specialization; rely on type-checked
-                    // `ensure_total_capacity` + slice copy below to enforce it.
+                    // VersionHashMap key/value types matching PackageNameHash /
+                    // Semver.Version is enforced by the type-checked
+                    // `ensure_total_capacity` + slice copy below.
 
                     if workspace_package_name_hashes.len() != workspace_versions_list.len() {
                         return Err(bun_core::err!("InvalidLockfile"));
@@ -577,15 +558,13 @@ pub(crate) fn load(
             if next_num == HAS_OVERRIDES_TAG {
                 let overrides_name_hashes: Vec<PackageNameHash> = buffers::read_array(stream)?;
 
-                // PORT NOTE: Zig: `var map = lockfile.overrides.map; defer lockfile.overrides.map = map;`
-                // is a move-out/move-back pattern. In Rust we mutate in place.
                 lockfile
                     .overrides
                     .map
                     .ensure_total_capacity(overrides_name_hashes.len())?;
                 let override_versions_external: Vec<dependency::External> =
                     buffers::read_array(stream)?;
-                // PORT NOTE: reshaped for borrowck — `Context.buffer` borrows
+                // reshaped for borrowck — `Context.buffer` borrows
                 // `lockfile.buffers.string_bytes` while we also need
                 // `&mut lockfile.overrides`. Split the disjoint fields up front so
                 // borrowck sees sibling borrows (no raw-ptr provenance laundering).
@@ -606,7 +585,6 @@ pub(crate) fn load(
                         buffer: string_bytes,
                         package_manager: manager.as_deref_mut(),
                     };
-                    // PERF(port): was assume_capacity
                     overrides.map.put_assume_capacity(
                         *name,
                         dependency::to_dependency(*value, &mut context),
@@ -627,7 +605,6 @@ pub(crate) fn load(
                 let patched_dependencies_name_and_version_hashes: Vec<PackageNameAndVersionHash> =
                     buffers::read_array(stream)?;
 
-                // PORT NOTE: Zig: `var map = lockfile.patched_dependencies; defer lockfile.patched_dependencies = map;`
                 let map = &mut lockfile.patched_dependencies;
 
                 map.ensure_total_capacity(patched_dependencies_name_and_version_hashes.len())?;
@@ -642,7 +619,6 @@ pub(crate) fn load(
                     .iter()
                     .zip(patched_dependencies_paths.iter())
                 {
-                    // PERF(port): was assume_capacity
                     map.put_assume_capacity(*name_hash, patch_path.to_patched_dep()?);
                 }
             } else {
@@ -663,7 +639,7 @@ pub(crate) fn load(
 
                 let default_deps: Vec<dependency::External> = buffers::read_array(stream)?;
 
-                // PORT NOTE: reshaped for borrowck — `dependency::Context` /
+                // reshaped for borrowck — `dependency::Context` /
                 // `ArrayHashContext` borrow `lockfile.buffers.string_bytes` while
                 // we also need `&mut lockfile.catalogs`. Split the disjoint
                 // fields up front so borrowck sees sibling borrows (no raw-ptr
@@ -676,8 +652,8 @@ pub(crate) fn load(
 
                 catalogs.default.ensure_total_capacity(default_deps.len())?;
 
-                // Zig `String.arrayHashContext(lockfile, null)` →
-                // `{ .arg_buf = lockfile.buffers.string_bytes.items, .existing_buf = same }`.
+                // Both arg and existing keys resolve against the lockfile's
+                // string buffer.
                 let str_ctx = semver::string::ArrayHashContext {
                     arg_buf: string_bytes,
                     existing_buf: string_bytes,
@@ -691,7 +667,6 @@ pub(crate) fn load(
                         package_manager: manager.as_deref_mut(),
                     };
                     let value = dependency::to_dependency(*dep, &mut context);
-                    // PERF(port): was assume_capacity
                     catalogs.default.put_assume_capacity_context(
                         *dep_name,
                         value,
@@ -709,7 +684,7 @@ pub(crate) fn load(
 
                     let catalog_deps: Vec<dependency::External> = buffers::read_array(stream)?;
 
-                    // PORT NOTE: `CatalogMap::get_or_put_group` currently takes the
+                    // `CatalogMap::get_or_put_group` currently takes the
                     // stub `bun_install::lockfile::Lockfile`; inline its body here
                     // against the split `catalogs` borrow to avoid the type
                     // mismatch and the simultaneous `&mut lockfile` self-borrow.
@@ -736,7 +711,6 @@ pub(crate) fn load(
                             package_manager: manager.as_deref_mut(),
                         };
                         let value = dependency::to_dependency(*dep, &mut context);
-                        // PERF(port): was assume_capacity
                         group.put_assume_capacity_context(
                             *dep_name,
                             value,
@@ -773,8 +747,6 @@ pub(crate) fn load(
         .package_index
         .ensure_total_capacity(lockfile.packages.len())?;
 
-    // PORT NOTE: reshaped for borrowck — Zig holds `slice.items(.name_hash)` /
-    // `slice.items(.resolution)` across `lockfile.getOrPutID(&mut self, …)`.
     // `get_or_put_id` only mutates `package_index` (and reads `packages` /
     // `buffers.string_bytes`), and `workspace_paths.put` only mutates
     // `workspace_paths`, so re-reading the columns by index each iteration is
@@ -825,8 +797,5 @@ pub(crate) fn load(
         debug_assert!(stream.pos as u64 == total_buffer_size);
     }
 
-    // const end = try reader.readInt(u64, .little);
     Ok(res)
 }
-
-// ported from: src/install/lockfile/bun.lockb.zig
diff --git a/src/install/lockfile/lockfile_json_stringify_for_debugging.rs b/src/install/lockfile/lockfile_json_stringify_for_debugging.rs
index 8b4358ceabe..9088b0722fd 100644
--- a/src/install/lockfile/lockfile_json_stringify_for_debugging.rs
+++ b/src/install/lockfile/lockfile_json_stringify_for_debugging.rs
@@ -15,17 +15,9 @@ use super::package::scripts::Scripts as PackageScripts;
 use super::tree::{DepthBuf, IteratorPathStyle, MAX_DEPTH};
 use super::{FormatVersion, Lockfile, Package, package_index, tree};
 
-// TODO(refactor): `w: anytype` is a `std.json.WriteStream`-shaped writer. Introduce a
-// `JsonWriter` trait in bun_core (or bun_collections) with the methods used below:
-// begin_object/end_object/begin_array/end_array/object_field/write/write_null/print.
-// `write` is generic over JSON-encodable scalars (bool, integers, &[u8]).
-//
-// PORT NOTE: Zig used `defer w.endObject() catch {}` so that closing braces are emitted
-// on both success and error paths (with the close error swallowed). In Rust the `?`
-// early-return drops the borrow on `w`, and a scopeguard would need a second `&mut w`.
 // Since this output is debug-only and an error mid-stream already yields malformed JSON,
-// the port emits the matching `end_*` call at the natural end of each scope and swallows
-// its error with `let _ = ...;`. The error-path close is intentionally dropped.
+// the matching `end_*` call is emitted at the natural end of each scope and its error
+// swallowed with `let _ = ...;`. The error-path close is intentionally dropped.
 
 fn json_stringify_dependency<W>(
     this: &Lockfile,
@@ -34,7 +26,6 @@ fn json_stringify_dependency<W>(
     dep: &Dependency,
     res: PackageID,
 ) -> Result<(), bun_core::Error>
-// TODO(port): narrow error set
 where
     W: JsonWriter,
 {
@@ -86,8 +77,6 @@ where
             w.begin_object()?;
 
             let info: TarballInfo = *dep.version.tarball();
-            // Zig: `@tagName(info.uri)` then `switch (info.uri) { inline else => |s| s.slice(sb) }`
-            // — every TarballURI variant payload has `.slice(sb)`.
             let (uri_tag, uri_slice): (&'static str, &[u8]) = match info.uri {
                 URI::Local(ref s) => ("local", s.slice(sb)),
                 URI::Remote(ref s) => ("remote", s.slice(sb)),
@@ -174,9 +163,6 @@ where
     {
         w.begin_object()?;
 
-        // Zig iterated `@typeInfo(Behavior).@"struct".fields[1..len-1]` (skips
-        // the leading `_unused_first` and trailing `_padding` bool/padding fields).
-        // The Rust port iterates `Behavior::NAMED_FLAGS` — a flat (name, fn) table.
         for (name, getter) in Behavior::NAMED_FLAGS {
             if getter(&dep.behavior) {
                 w.object_field(name.as_bytes())?;
@@ -195,7 +181,6 @@ where
 }
 
 pub fn json_stringify<W>(this: &Lockfile, w: &mut W) -> Result<(), bun_core::Error>
-// TODO(port): narrow error set
 where
     W: JsonWriter,
 {
@@ -206,7 +191,6 @@ where
     w.write(format_version_name(this.format).as_bytes())?;
     w.object_field(b"meta_hash")?;
     {
-        // std.fmt.bytesToHex(.., .lower)
         let mut hex = [0u8; 64];
         let n = bun_fmt::bytes_to_hex_lower(&this.meta_hash, &mut hex);
         w.write(&hex[..n])?;
@@ -379,7 +363,6 @@ where
                 w.object_field(b"arch")?;
                 w.begin_array()?;
 
-                // Zig: `Npm.Architecture.NameMap.kvs` — ComptimeStringMap kv array.
                 for (key, value) in Npm::Architecture::NAME_MAP_KVS {
                     if pkg.meta.arch.has(*value) {
                         w.write(*key)?;
@@ -463,9 +446,6 @@ where
                 w.object_field(b"scripts")?;
                 w.begin_object()?;
 
-                // Zig: `inline for (comptime std.meta.fieldNames(Lockfile.Scripts))` —
-                // tabulated explicitly via `Package::Scripts::FIELD_NAMES` since
-                // Rust has no field-by-name reflection.
                 for (field_name, getter) in PackageScripts::FIELD_NAMES {
                     let script = getter(&pkg.scripts).slice(sb);
                     if !script.is_empty() {
@@ -499,7 +479,6 @@ where
             .iter()
             .zip(this.workspace_paths.values())
         {
-            // std.fmt.printInt(&buf, k, 10, .lower, .{})
             let len = {
                 use std::io::Write;
                 let cap = buf.len();
@@ -545,7 +524,7 @@ where
     Ok(())
 }
 
-/// Mirrors Zig `@tagName(this.format)` for the non-exhaustive `FormatVersion`.
+/// Tag name for the non-exhaustive `FormatVersion`.
 fn format_version_name(v: FormatVersion) -> &'static str {
     match v {
         FormatVersion::V0 => "v0",
@@ -556,7 +535,6 @@ fn format_version_name(v: FormatVersion) -> &'static str {
     }
 }
 
-/// Mirrors Zig `@tagName(pkg.meta.origin)`.
 fn origin_name(o: Origin) -> &'static str {
     match o {
         Origin::Local => "local",
@@ -565,10 +543,9 @@ fn origin_name(o: Origin) -> &'static str {
     }
 }
 
-/// Port of the `w: anytype` `std.json.WriteStream` protocol used by
-/// `Lockfile.jsonStringify`. `write` is bounded over [`JsonScalar`] so the
-/// concrete [`WriteStream`] impl can encode bool / integer / byte-string
-/// uniformly (Zig's `WriteStream.write` switches on `@TypeOf` at comptime).
+/// JSON writer protocol used by the lockfile debug stringifier. `write` is
+/// bounded over [`JsonScalar`] so the concrete [`WriteStream`] impl can encode
+/// bool / integer / byte-string uniformly.
 pub trait JsonWriter {
     fn begin_object(&mut self) -> Result<(), bun_core::Error>;
     fn end_object(&mut self) -> Result<(), bun_core::Error>;
@@ -577,14 +554,13 @@ pub trait JsonWriter {
     fn object_field(&mut self, name: &[u8]) -> Result<(), bun_core::Error>;
     fn write<T: JsonScalar>(&mut self, value: T) -> Result<(), bun_core::Error>;
     fn write_null(&mut self) -> Result<(), bun_core::Error>;
-    /// Zig: `WriteStream.print` — emits the formatted bytes verbatim as a
-    /// complete value (caller is responsible for any quoting / escaping).
+    /// Emits the formatted bytes verbatim as a complete value (caller is
+    /// responsible for any quoting / escaping).
     fn print(&mut self, args: core::fmt::Arguments<'_>) -> Result<(), bun_core::Error>;
 }
 
-/// Dispatch trait standing in for Zig's `@TypeOf` switch inside
-/// `std.json.WriteStream.write`. Each impl emits the JSON encoding of `self`
-/// into `out` (no leading/trailing separator — the writer handles that).
+/// Each impl emits the JSON encoding of `self` into `out` (no leading/trailing
+/// separator — the writer handles that).
 pub trait JsonScalar {
     fn write_json(&self, out: &mut Vec<u8>, opts: WriteStreamOptions);
 }
@@ -602,8 +578,8 @@ macro_rules! json_scalar_uint {
             #[inline]
             fn write_json(&self, out: &mut Vec<u8>, opts: WriteStreamOptions) {
                 use std::io::Write as _;
-                // Zig std.json: `.emit_nonportable_numbers_as_strings` quotes any
-                // integer outside ±2^53 so JS `JSON.parse` round-trips exactly.
+                // `.emit_nonportable_numbers_as_strings` quotes any integer
+                // outside ±2^53 so JS `JSON.parse` round-trips exactly.
                 let v = *self as u64;
                 if opts.emit_nonportable_numbers_as_strings && v > (1u64 << 53) {
                     let _ = write!(out, "\"{}\"", v);
@@ -628,10 +604,10 @@ impl<const N: usize> JsonScalar for &[u8; N] {
     }
 }
 
-/// Zig: `std.json.encodeJsonString` — quote + escape the minimal RFC-8259 set
-/// (`"`, `\`, U+0000..U+001F). Input is treated as already-valid UTF-8/WTF-8;
-/// the lockfile string buffer never carries lone control bytes outside that
-/// range, so the high-bit passthrough matches Zig's behaviour.
+/// Quote + escape the minimal RFC-8259 set (`"`, `\`, U+0000..U+001F). Input is
+/// treated as already-valid UTF-8/WTF-8; the lockfile string buffer never
+/// carries lone control bytes outside that range, so high-bit bytes pass
+/// through unescaped.
 fn encode_json_string(s: &[u8], out: &mut Vec<u8>) {
     out.push(b'"');
     for &c in s {
@@ -651,25 +627,21 @@ fn encode_json_string(s: &[u8], out: &mut Vec<u8>) {
     out.push(b'"');
 }
 
-/// Options mirroring `std.json.StringifyOptions`. Only the three fields the
-/// lockfile binding sets are modelled; the rest of std.json's surface is unused
-/// here.
+/// JSON stringify options. Only the three fields the lockfile binding sets
+/// are modelled.
 #[derive(Clone, Copy)]
 pub struct WriteStreamOptions {
     /// `.whitespace = .indent_N` — number of spaces per nesting level. `0`
     /// would be `.minified`; the binding always passes `2`.
     pub indent: usize,
     pub emit_nonportable_numbers_as_strings: bool,
-    // `emit_null_optional_fields` is consumed by Zig's reflection-based
-    // `stringify`, not by `WriteStream` itself; `jsonStringify` is hand-rolled
-    // and emits `write_null()` explicitly, so the flag is a no-op here. Kept
-    // for spec parity with the call site in `install_binding.zig`.
+    // `emit_null_optional_fields` is a no-op here: the stringifier is
+    // hand-rolled and emits `write_null()` explicitly.
     pub emit_null_optional_fields: bool,
 }
 
-/// Port of `std.json.WriteStream` over an in-memory `Vec<u8>`, sufficient for
-/// `std.json.fmt(lockfile, opts)` → `allocPrint` as used by
-/// `bun_install_js_bindings::jsParseLockfile` (install_binding.zig).
+/// JSON write stream over an in-memory `Vec<u8>`, sufficient for
+/// `bun_install_js_bindings::jsParseLockfile`.
 pub struct WriteStream {
     pub out: Vec<u8>,
     opts: WriteStreamOptions,
@@ -784,5 +756,3 @@ impl JsonWriter for WriteStream {
         Ok(())
     }
 }
-
-// ported from: src/install/lockfile/lockfile_json_stringify_for_debugging.zig
diff --git a/src/install/lockfile/printer/Yarn.rs b/src/install/lockfile/printer/Yarn.rs
index a0c0c17f85c..f17a07d42f1 100644
--- a/src/install/lockfile/printer/Yarn.rs
+++ b/src/install/lockfile/printer/Yarn.rs
@@ -11,23 +11,29 @@ use bun_install::PackageID;
 use bun_install::Resolution;
 use bun_install::dependency::{self, Behavior, VersionExt as _};
 use bun_install::lockfile::package;
-// PORT NOTE: `lockfile.packages.slice()` returns
+// `lockfile.packages.slice()` returns
 // `bun_collections::multi_array_list::Slice<Package<_>>`; the `items_<field>()`
-// column accessors are an extension trait (Zig's `slice.items(.field)` is
-// comptime-dispatched, Rust models it as a hand-expanded trait per Package.rs).
+// column accessors are an extension trait (hand-expanded per Package.rs).
 use crate::integrity;
 use crate::lockfile_real::Printer;
 
-// TODO(port): narrow error set (only writer + alloc errors are produced)
 pub fn print(this: &mut Printer, writer: &mut impl bun_io::Write) -> Result<(), bun_core::Error> {
     // internal for debugging, print the lockfile as custom json
     // limited to debug because we don't want people to rely on this format.
     #[cfg(debug_assertions)]
-    {
-        // TODO(port): std.process.hasEnvVarConstant("JSON") + std.json.Stringify
-        // have no direct equivalent here; wire up bun_core::env_var + a JSON
-        // serializer for Lockfile if this debug path is still wanted.
-        let _ = &this.lockfile;
+    if bun_core::getenv_z(bun_core::zstr!("JSON")).is_some() {
+        use crate::lockfile_real::lockfile_json_stringify_for_debugging::{
+            WriteStream, WriteStreamOptions,
+        };
+        let mut stream = WriteStream::new(WriteStreamOptions {
+            indent: 2,
+            emit_null_optional_fields: true,
+            emit_nonportable_numbers_as_strings: true,
+        });
+        crate::lockfile_real::json_stringify(this.lockfile, &mut stream)?;
+        writer.write_all(&stream.into_bytes())?;
+        writer.write_all(b"\n")?;
+        return Ok(());
     }
 
     writer.write_all(
@@ -52,14 +58,12 @@ fn packages(this: &mut Printer, writer: &mut impl bun_io::Write) -> Result<(), b
     let resolutions_buffer: &[PackageID] = this.lockfile.buffers.resolutions.as_slice();
     let dependencies_buffer: &[Dependency] = this.lockfile.buffers.dependencies.as_slice();
 
-    // Zig: std.HashMap(PackageID, []Dependency.Version, IdentityContext(PackageID), 80)
-    // PORT NOTE: reshaped for borrowck — store (start, len) into
-    // `all_requested_versions_buf` instead of overlapping &mut [Version] slices.
+    // Store (start, len) into `all_requested_versions_buf` instead of
+    // overlapping &mut [Version] slices.
     let mut requested_versions: HashMap<PackageID, (usize, usize)> = HashMap::default();
 
-    // PERF(port): Zig was raw `allocator.alloc(Dependency.Version, resolutions_buffer.len)` of
-    // uninit memory + cursor slicing. We push into a pre-reserved Vec instead — set_len would
-    // drop uninit tail elements (and index-assign would drop uninit old values). Profile if hot.
+    // We push into a pre-reserved Vec — set_len would drop uninit tail elements
+    // (and index-assign would drop uninit old values). Profile if hot.
     let mut all_requested_versions_buf: Vec<dependency::Version> =
         Vec::with_capacity(resolutions_buffer.len());
 
@@ -91,7 +95,6 @@ fn packages(this: &mut Printer, writer: &mut impl bun_io::Write) -> Result<(), b
 
             let dependency_versions = &mut all_requested_versions_buf[requested_version_start..];
             if dependency_versions.len() > 1 {
-                // PERF(port): was std.sort.insertion — profile if it shows up on a hot path.
                 dependency_versions.sort_by(|a, b| {
                     if dependency::Version::is_less_than_with_tag(string_buf, a, b) {
                         Ordering::Less
@@ -114,7 +117,6 @@ fn packages(this: &mut Printer, writer: &mut impl bun_io::Write) -> Result<(), b
             buf: string_buf.into(),
             resolutions: resolved.into(),
         };
-        // PERF(port): std.sort.pdq → sort_unstable_by (Rust uses pdqsort internally)
         alphabetized_names.sort_unstable_by(|&a, &b| alphabetizer.order(a, b));
     }
 
@@ -288,5 +290,3 @@ fn packages(this: &mut Printer, writer: &mut impl bun_io::Write) -> Result<(), b
 
     Ok(())
 }
-
-// ported from: src/install/lockfile/printer/Yarn.zig
diff --git a/src/install/lockfile/printer/tree_printer.rs b/src/install/lockfile/printer/tree_printer.rs
index 2e42c74d635..dc784a915d7 100644
--- a/src/install/lockfile/printer/tree_printer.rs
+++ b/src/install/lockfile/printer/tree_printer.rs
@@ -2,22 +2,18 @@ use bun_collections::{DynamicBitSet, HashMap};
 use bun_io::Write;
 use bun_semver as semver;
 
+use crate::lockfile_real::package::PackageColumns as _;
+use crate::package_manager_real::TrackInstalledBin;
 use bun_core::fmt::PathSep;
 use bun_install::lockfile::{Printer, package::Meta as PackageMeta};
 use bun_install::{
     self as install, Bin, Dependency, DependencyID, INVALID_PACKAGE_ID, PackageID, PackageManager,
     PackageNameHash, Resolution, bin, resolution,
 };
-// PORT NOTE: Zig `slice.items(.field)` → trait-provided `items_<field>()`
-// accessors on `MultiArrayList<Package>` / its `Slice`.
-use crate::lockfile_real::package::PackageColumns as _;
-use crate::package_manager_real::TrackInstalledBin;
 use bun_sys::Fd;
 
 type Bitset = DynamicBitSet;
 
-// PORT NOTE: `comptime print_section_header: enum(u1) { print_section_header, dont_print_section_header }`
-// is a two-state comptime flag; mapped to `const PRINT_SECTION_HEADER: bool`.
 fn print_installed_workspace_section<
     W,
     const ENABLE_ANSI_COLORS: bool,
@@ -34,13 +30,11 @@ fn print_installed_workspace_section<
 where
     W: Write,
 {
-    // TODO(port): narrow error set
     let lockfile = &this.lockfile;
     let string_buf = lockfile.buffers.string_bytes.as_slice();
     let packages_slice = lockfile.packages.slice();
     let resolutions = lockfile.buffers.resolutions.as_slice();
     let dependencies = lockfile.buffers.dependencies.as_slice();
-    // PORT NOTE: Zig `slice.items(.field)` → derive(MultiArrayElement)-generated `items_<field>()`.
     let workspace_res = &packages_slice.items_resolution()[workspace_package_id as usize];
     let names = packages_slice.items_name();
     let pkg_metas = packages_slice.items_meta();
@@ -56,7 +50,7 @@ where
     // While both are technically installed, only one was chosen and should be printed.
     let mut dep_dedupe: HashMap<PackageNameHash, ()> = HashMap::new();
 
-    // PORT NOTE: reshaped for borrowck — `id_map` is reborrowed per call below.
+    // Reshaped for borrowck — `id_map` is reborrowed per call below.
     let mut id_map = id_map;
 
     // find the updated packages
@@ -250,7 +244,6 @@ fn print_updated_package<W, const ENABLE_ANSI_COLORS: bool>(
 where
     W: Write,
 {
-    // TODO(port): narrow error set
     let string_buf = this.lockfile.buffers.string_bytes.as_slice();
     let dependency =
         &this.lockfile.buffers.dependencies.as_slice()[update_info.dependency_id as usize];
@@ -289,7 +282,6 @@ fn print_installed_package<W, const ENABLE_ANSI_COLORS: bool>(
 where
     W: Write,
 {
-    // TODO(port): narrow error set
     let string_buf = this.lockfile.buffers.string_bytes.as_slice();
     let packages_slice = this.lockfile.packages.slice();
     let resolution: Resolution = packages_slice.items_resolution()[package_id as usize];
@@ -353,7 +345,6 @@ pub fn print<W, const ENABLE_ANSI_COLORS: bool>(
 where
     W: Write,
 {
-    // TODO(port): narrow error set
     writer.write_str("\n")?;
     // `allocator` param dropped — global mimalloc.
     let slice = this.lockfile.packages.slice();
@@ -536,8 +527,7 @@ where
                     done: false,
                     dir_iterator: None,
                     package_name: name,
-                    // PORT NOTE: Zig default `bun.invalid_fd.stdDir()` — never read on
-                    // the .map/.file/.named_file paths this arm covers.
+                    // Never read on the .map/.file/.named_file paths this arm covers.
                     destination_node_modules: Fd::INVALID,
                     buf: bun_paths::PathBuffer::uninit(),
                     string_buffer: string_buf,
@@ -556,9 +546,8 @@ where
 
                 {
                     if matches!(manager.track_installed_bin, TrackInstalledBin::Pending) {
-                        // PORT NOTE: `iterator.next()` returns `Result<Option<&[u8]>, E>` (Zig `!?[]const u8`);
-                        // `catch null` → `.unwrap_or(None)`. Reshaped for borrowck — `bin_name`'s
-                        // borrow of `iterator.buf` must end before the loop's `iterator.next()`.
+                        // `bin_name`'s borrow of `iterator.buf` must end before
+                        // the loop's `iterator.next()`.
                         if let Some(bin_name) = iterator.next().unwrap_or(None) {
                             let owned = Box::<[u8]>::from(bin_name);
 
@@ -594,5 +583,3 @@ where
 
     Ok(())
 }
-
-// ported from: src/install/lockfile/printer/tree_printer.zig
diff --git a/src/install/migration.rs b/src/install/migration.rs
index 06062c2c57d..dd7a17191ce 100644
--- a/src/install/migration.rs
+++ b/src/install/migration.rs
@@ -235,7 +235,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
     data: &[u8],
     abs_path: &[u8],
 ) -> Result<LoadResult<'a>, Error> {
-    // TODO(port): narrow error set
     debug!("begin lockfile migration");
 
     this.init_empty();
@@ -309,7 +308,7 @@ pub(crate) fn migrate_npm_lockfile<'a>(
             let json_array = match &wksp.data {
                 ExprData::EArray(arr) => *arr,
                 ExprData::EObject(obj) => {
-                    // PORT NOTE: `StoreRef::get` shadows `E::Object::get`; deref-coerce.
+                    // `StoreRef::get` shadows `E::Object::get`; deref-coerce.
                     let obj: &E::Object = obj;
                     if let Some(packages) = obj.get(b"packages") {
                         match &packages.data {
@@ -368,7 +367,7 @@ pub(crate) fn migrate_npm_lockfile<'a>(
         else {
             return Err(err!("InvalidNPMLockfile"));
         };
-        // PORT NOTE: `StoreRef::get` shadows `E::Object::get`; deref-coerce.
+        // `StoreRef::get` shadows `E::Object::get`; deref-coerce.
         let pkg: &E::Object = pkg;
 
         if pkg.get(b"link").is_some() {
@@ -503,7 +502,7 @@ pub(crate) fn migrate_npm_lockfile<'a>(
 
     // dependency on `resolved`, a dependencies version tag might change, requiring
     // new strings to be allocated.
-    // PORT NOTE: reshaped for borrowck — `string_buf()` borrows `this` mutably,
+    // Reshaped for borrowck — `string_buf()` borrows `this` mutably,
     // so we re-acquire it locally where needed instead of holding it across
     // other `this.*` mutations.
 
@@ -522,7 +521,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
             let mut sb = this.string_buf();
             let appended = sb.append(k)?;
             this.workspace_paths.insert(name_hash, appended);
-            // PERF(port): was assume_capacity
 
             if let Some(version_string) = &v.version {
                 let sliced_version = SlicedString::init(version_string, version_string);
@@ -530,7 +528,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
                 if result.valid && result.wildcard == Wildcard::None {
                     this.workspace_versions
                         .insert(name_hash, result.version.min());
-                    // PERF(port): was assume_capacity
                 }
             }
         }
@@ -549,7 +546,7 @@ pub(crate) fn migrate_npm_lockfile<'a>(
         else {
             unreachable!("npm lockfile: non-object Expr from JSON parser")
         };
-        // PORT NOTE: `StoreRef::get` shadows `E::Object::get`; deref-coerce.
+        // `StoreRef::get` shadows `E::Object::get`; deref-coerce.
         let pkg: &E::Object = pkg;
 
         let pkg_path = entry
@@ -706,7 +703,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
                     let ev = sb.append_external(script_value)?;
                     this.buffers.extern_strings.push(ek);
                     this.buffers.extern_strings.push(ev);
-                    // PERF(port): was assume_capacity
                 }
 
                 #[cfg(debug_assertions)]
@@ -839,36 +835,11 @@ pub(crate) fn migrate_npm_lockfile<'a>(
         debug_assert!(this.packages.len() == package_idx as usize);
     }
 
-    // ignoring length check because we pre-allocated it. the length may shrink later
-    // so it's faster if we ignore the underlying length buffer and just assign it at the very end.
-    // PORT NOTE: reshaped for borrowck — track cursor indices into reserved capacity instead of
-    // shrinking slices via pointer arithmetic.
-    let dependencies_base: *mut Dependency = this.buffers.dependencies.as_mut_ptr();
-    let resolutions_base: *mut PackageID = this.buffers.resolutions.as_mut_ptr();
-    let mut deps_cursor: usize = 0;
-    let mut res_cursor: usize = 0;
-    // TODO(port): Stacked-Borrows audit — these raw ptrs into
-    // `buffers.{dependencies,resolutions}` and the `packages` columns below are
-    // held across `&mut self` calls to `string_buf()` / `get_or_put_id()`. The
-    // fields actually touched are disjoint (string_bytes/string_pool resp.
-    // package_index + read of resolutions), so this is sound under Tree
-    // Borrows and matches the Zig spec, but SB retags through `Unique<T>`.
-    // Fix by split-borrowing the disjoint fields (see the `bin` path above) or
-    // by setting Vec lengths up-front and indexing safely.
-
-    // pre-initialize the dependencies and resolutions to `unset_package_id`
-    #[cfg(debug_assertions)]
-    {
-        // SAFETY: capacity reserved above for num_deps
-        unsafe {
-            for i in 0..(num_deps as usize) {
-                core::ptr::write(dependencies_base.add(i), Dependency::default());
-                core::ptr::write(resolutions_base.add(i), UNSET_PACKAGE_ID);
-            }
-        }
-    }
+    // Both buffers are filled by pushing into the pre-reserved Vecs: capacity
+    // for `num_deps` was reserved above so pushes never reallocate, and no raw
+    // pointers are held across `&mut self` calls.
 
-    // PORT NOTE: MultiArrayList column access — re-borrow the (disjoint) `resolution`,
+    // MultiArrayList column access — re-borrow the (disjoint) `resolution`,
     // `meta`, `dependencies` and `resolutions` columns of `this.packages` at each use
     // site via the generated `items_*` / `items_*_mut` accessors. Capacity is fixed
     // (no further append until end of fn), so the slices stay valid; re-acquiring per
@@ -910,7 +881,7 @@ pub(crate) fn migrate_npm_lockfile<'a>(
         else {
             unreachable!("npm lockfile: non-object Expr from JSON parser")
         };
-        // PORT NOTE: `StoreRef::get` shadows `E::Object::get`; deref-coerce.
+        // `StoreRef::get` shadows `E::Object::get`; deref-coerce.
         let pkg: &E::Object = pkg;
 
         if pkg.get(b"link").is_some() || is_skipped_pkg(pkg) {
@@ -924,26 +895,28 @@ pub(crate) fn migrate_npm_lockfile<'a>(
             .as_string(&arena)
             .unwrap();
 
-        let dependencies_start = deps_cursor;
-        let resolutions_start = res_cursor;
+        let dependencies_start = this.buffers.dependencies.len();
+        let resolutions_start = this.buffers.resolutions.len();
 
-        // PORT NOTE: Zig used `defer` here to write dependencies_list/resolution_list and
-        // increment package_idx at every loop exit. Reshaped for borrowck — inlined as
-        // `finalize_pkg!` at the one early-continue and at natural end-of-loop.
+        // `finalize_pkg!` writes dependencies_list/resolution_list and
+        // increments package_idx; invoked at the one early-continue and at
+        // natural end-of-loop.
         macro_rules! finalize_pkg {
             () => {{
                 // package_idx < pkg_count; columns re-borrowed disjointly per statement.
-                if dependencies_start == deps_cursor {
+                if dependencies_start == this.buffers.dependencies.len() {
                     this.packages.items_dependencies_mut()[package_idx as usize] =
                         ExternalSlice::default();
                     this.packages.items_resolutions_mut()[package_idx as usize] =
                         ExternalSlice::default();
                 } else {
-                    let len: u32 = (res_cursor - resolutions_start) as u32;
+                    let len: u32 = (this.buffers.resolutions.len() - resolutions_start) as u32;
                     #[cfg(debug_assertions)]
                     {
                         debug_assert!(len > 0);
-                        debug_assert!(len == (deps_cursor - dependencies_start) as u32);
+                        debug_assert!(
+                            len == (this.buffers.dependencies.len() - dependencies_start) as u32
+                        );
                     }
                     this.packages.items_dependencies_mut()[package_idx as usize] =
                         ExternalSlice::new(dependencies_start as u32, len);
@@ -996,27 +969,19 @@ pub(crate) fn migrate_npm_lockfile<'a>(
                     let mut sb = this.string_buf();
                     let wksp_name = sb.append(&value.name)?;
                     let wksp_path = sb.append(key)?;
-                    // SAFETY: deps_cursor < num_deps; capacity reserved above
-                    unsafe {
-                        core::ptr::write(
-                            dependencies_base.add(deps_cursor),
-                            Dependency {
-                                name: wksp_name,
-                                name_hash,
-                                version: DepVersion {
-                                    tag: DepTag::Workspace,
-                                    literal: wksp_path,
-                                    value: DepValue {
-                                        workspace: wksp_path,
-                                    },
-                                },
-                                behavior: Behavior::WORKSPACE,
+                    this.buffers.dependencies.push(Dependency {
+                        name: wksp_name,
+                        name_hash,
+                        version: DepVersion {
+                            tag: DepTag::Workspace,
+                            literal: wksp_path,
+                            value: DepValue {
+                                workspace: wksp_path,
                             },
-                        );
-                        core::ptr::write(resolutions_base.add(res_cursor), entry1.new_package_id);
-                    }
-                    deps_cursor += 1;
-                    res_cursor += 1;
+                        },
+                        behavior: Behavior::WORKSPACE,
+                    });
+                    this.buffers.resolutions.push(entry1.new_package_id);
                 }
             }
         }
@@ -1154,12 +1119,10 @@ pub(crate) fn migrate_npm_lockfile<'a>(
 
                             let behavior = dep_key.behavior;
 
-                            // PORT NOTE: capture tag and git/github owner before moving
-                            // `version` into the buffer (Zig copies the struct by value; Rust
-                            // moves it). The owner is needed when `version.tag` is git/github
-                            // but the package's `resolved` URL infers as something else, in
-                            // which case Zig reads `res_version.value.{git,github}.owner` from
-                            // the original parsed dependency version.
+                            // Capture tag and git/github owner before moving
+                            // `version` into the buffer. The owner is needed when
+                            // `version.tag` is git/github but the package's `resolved`
+                            // URL infers as something else.
                             let version_tag = version.tag;
                             let version_git_owner = match version_tag {
                                 DepTag::Git => version.git().owner,
@@ -1167,21 +1130,13 @@ pub(crate) fn migrate_npm_lockfile<'a>(
                                 _ => SemverString::default(),
                             };
 
-                            // SAFETY: cursor < num_deps; capacity reserved
-                            unsafe {
-                                core::ptr::write(
-                                    dependencies_base.add(deps_cursor),
-                                    Dependency {
-                                        name: dep_name,
-                                        name_hash,
-                                        version,
-                                        behavior,
-                                    },
-                                );
-                                core::ptr::write(resolutions_base.add(res_cursor), id);
-                            }
-                            deps_cursor += 1;
-                            res_cursor += 1;
+                            this.buffers.dependencies.push(Dependency {
+                                name: dep_name,
+                                name_hash,
+                                version,
+                                behavior,
+                            });
+                            this.buffers.resolutions.push(id);
 
                             // If the package resolution is not set, resolve the target package
                             // using the information we have from the dependency declaration.
@@ -1473,24 +1428,15 @@ pub(crate) fn migrate_npm_lockfile<'a>(
                                             };
                                             if b.value {
                                                 let behavior = Behavior::OPTIONAL | Behavior::PEER;
-                                                // SAFETY: cursor < num_deps; capacity reserved
-                                                unsafe {
-                                                    core::ptr::write(
-                                                        dependencies_base.add(deps_cursor),
-                                                        Dependency {
-                                                            name: dep_name,
-                                                            name_hash,
-                                                            version,
-                                                            behavior,
-                                                        },
-                                                    );
-                                                    core::ptr::write(
-                                                        resolutions_base.add(res_cursor),
-                                                        Install::INVALID_PACKAGE_ID,
-                                                    );
-                                                }
-                                                deps_cursor += 1;
-                                                res_cursor += 1;
+                                                this.buffers.dependencies.push(Dependency {
+                                                    name: dep_name,
+                                                    name_hash,
+                                                    version,
+                                                    behavior,
+                                                });
+                                                this.buffers
+                                                    .resolutions
+                                                    .push(Install::INVALID_PACKAGE_ID);
                                                 continue 'dep_loop;
                                             }
                                         }
@@ -1516,17 +1462,10 @@ pub(crate) fn migrate_npm_lockfile<'a>(
         finalize_pkg!();
     }
 
-    // SAFETY: res_cursor elements written above into reserved capacity
-    unsafe {
-        this.buffers.resolutions.set_len(res_cursor);
-        this.buffers.dependencies.set_len(res_cursor);
-    }
-
-    // In allow_assert, we prefill this buffer with uninitialized values that we can detect later
     // It is our fault if we hit an error here, making it safe to disable in release.
     #[cfg(debug_assertions)]
     {
-        debug_assert!(this.buffers.dependencies.len() == deps_cursor);
+        debug_assert!(this.buffers.dependencies.len() == this.buffers.resolutions.len());
         debug_assert!(this.buffers.dependencies.len() <= num_deps as usize);
         let mut crash = false;
         for (i, r) in this.buffers.dependencies.iter().enumerate() {
@@ -1578,12 +1517,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
 
     this.resolve(log)?;
 
-    // if (Environment.isDebug) {
-    //     const dump_file = try std.fs.cwd().createFileZ("after-clean.json", .{});
-    //     defer dump_file.close();
-    //     try std.json.stringify(this, .{ .whitespace = .indent_2 }, dump_file.writer());
-    // }
-
     #[cfg(debug_assertions)]
     {
         this.verify_data()?;
@@ -1593,7 +1526,6 @@ pub(crate) fn migrate_npm_lockfile<'a>(
 
     Ok(LoadResult::Ok(LoadResultOk {
         lockfile: this,
-        // TODO(port): lifetime — LoadResult holds &mut Lockfile in Zig; verify Rust ownership
         migrated: Migrated::Npm,
         loaded_from_binary_lockfile: false,
         serializer_result: Default::default(),
@@ -1635,5 +1567,3 @@ fn package_name_from_path(pkg_path: &[u8]) -> &[u8] {
 fn string_hash(s: &[u8]) -> u64 {
     Semver::semver_string::Builder::string_hash(s)
 }
-
-// ported from: src/install/migration.zig
diff --git a/src/install/npm.rs b/src/install/npm.rs
index 452a088a415..3c605272205 100644
--- a/src/install/npm.rs
+++ b/src/install/npm.rs
@@ -4,7 +4,7 @@ use std::io::Write as _;
 use crate::bun_json as JSON;
 use crate::bun_schema::api;
 use bun_alloc::AllocError;
-use bun_collections::{HashMap, StringSet};
+use bun_collections::{HashMap, IdentityContext, StringSet};
 use bun_core::{Error, Global, Output, err, fmt as bun_fmt};
 use bun_core::{MutableString, strings};
 use bun_dotenv::Loader as DotEnv;
@@ -142,9 +142,8 @@ pub fn whoami(manager: &mut PackageManager) -> Result<Vec<u8>, WhoamiError> {
     let mut response_buf = MutableString::init(1024)?;
 
     // `print_buf` stays live on this frame until after `req.send_sync()`
-    // returns (Zig: `defer print_buf.deinit()`, npm.zig:25). `init_sync`
-    // borrows the URL/header buffers for the duration of the synchronous
-    // request only.
+    // returns. `init_sync` borrows the URL/header buffers for the duration of
+    // the synchronous request only.
     let url = URL::parse(&print_buf);
 
     // `headers.allocate()` set `content.ptr` to a valid `content.len`-byte
@@ -282,7 +281,6 @@ pub mod registry {
     pub static DEFAULT_URL_HASH: std::sync::LazyLock<u64> =
         std::sync::LazyLock::new(bun_install_types::NodeLinker::npm::Registry::default_url_hash);
 
-    // Zig: `ObjectPool(MutableString, MutableString.init2048, true, 8)`.
     // `MutableString: ObjectPoolType` (init = init2048) is provided in
     // bun_string; the `object_pool!` macro generates the per-monomorphization
     // thread-local storage so `BodyPool::get()` doesn't hit `UnwiredStorage`'s
@@ -342,10 +340,9 @@ pub mod registry {
                 }
             }
 
-            // PORT NOTE: Zig's `URL.parse(registry.url)` borrows the input
-            // `[]const u8`; here `url` borrows the owned `registry_url` buffer
-            // for the duration of parsing. The final href is moved into
-            // `Scope.url: OwnedURL` (owned `Box<[u8]>`).
+            // `url` borrows the owned `registry_url` buffer for the duration
+            // of parsing. The final href is moved into `Scope.url: OwnedURL`
+            // (owned `Box<[u8]>`).
             let registry_url: Box<[u8]> = core::mem::take(&mut registry.url);
             let mut url = URL::parse(&registry_url);
             let mut auth: &[u8] = b"";
@@ -353,7 +350,7 @@ pub mod registry {
             let mut needs_normalize = false;
 
             // Backing storage for `user`/`auth` when synthesized from
-            // username:password (Zig used a single `default_allocator.alloc`).
+            // username:password.
             let mut output_buf_owned: Box<[u8]> = Box::default();
 
             if registry.token.is_empty() {
@@ -453,8 +450,8 @@ pub mod registry {
                             }
                         }
 
-                        // PORT NOTE: reshaped for borrowck — Zig's `defer { url.pathname = pathname; url.path = pathname; }`
-                        // is applied at every `break 'outer` above and once more here at fallthrough.
+                        // The pathname write-back is applied at every `break 'outer`
+                        // above and once more here at fallthrough.
                         url.pathname = pathname;
                         url.path = pathname;
                     }
@@ -494,7 +491,7 @@ pub mod registry {
             let final_href: Box<[u8]> = if needs_normalize {
                 url.href_without_auth()
             } else {
-                // PORT NOTE: reshaped for borrowck — `url` (borrowing
+                // reshaped for borrowck — `url` (borrowing
                 // `registry_url`) is dead on this branch (every path that
                 // mutated `url.pathname` also set `needs_normalize = true`).
                 registry_url
@@ -513,8 +510,8 @@ pub mod registry {
         }
     }
 
-    // TODO(port): Zig used `IdentityContext(u64)` hasher; std HashMap is fine for now.
-    pub type Map = HashMap<u64, Scope>;
+    // Keys are pre-hashed (`Scope::hash`), so don't re-hash them.
+    pub type Map = HashMap<u64, Scope, bun_collections::IdentityContext<u64>>;
 
     pub(crate) enum PackageVersionResponse {
         Cached(PackageManifest),
@@ -532,7 +529,6 @@ pub mod registry {
         package_manager: &mut PackageManager,
         is_extended_manifest: bool,
     ) -> Result<PackageVersionResponse, Error> {
-        // TODO(port): narrow error set
         match response.status_code {
             400 => return Err(err!("BadRequest")),
             429 => return Err(err!("TooManyRequests")),
@@ -628,14 +624,14 @@ pub use bun_install_types::resolver_hooks::{
     Architecture, Libc, Negatable, NegatableEnum, NegatableExt, OperatingSystem,
 };
 
-/// Port of `Negatable(T).fromJson` (src/install/npm.zig). Lives here (not in
-/// `bun_install_types`) because `bun_ast::Expr` is not reachable from that crate.
+/// Lives here (not in `bun_install_types`) because `bun_ast::Expr` is not
+/// reachable from that crate.
 pub(crate) fn negatable_from_json<T: NegatableEnum>(expr: &JSON::Expr) -> Result<T, AllocError> {
     let mut this = T::NONE.negatable();
     if let JSON::ExprData::EArray(a) = &expr.data {
         for item in a.items.slice() {
             // JSON parsed via `parse_utf8` always yields UTF-8 EStrings,
-            // so no transcode allocator is needed (Zig: asString(allocator)).
+            // so no transcode allocator is needed.
             if let Some(value) = item.as_utf8_string_literal() {
                 this.apply(value);
             }
@@ -751,8 +747,7 @@ impl PackageVersion {
         self.bundled_dependencies.is_invalid()
     }
 
-    /// Port of Zig's `@field(package_version, group.field)` reflection used by
-    /// `Package.fromNPM` to walk dependency groups by name.
+    /// Used by `Package.fromNPM` to walk dependency groups by name.
     pub(crate) fn dep_group(&self, field: &[u8]) -> ExternalStringMap {
         match field {
             b"dependencies" => self.dependencies,
@@ -764,12 +759,11 @@ impl PackageVersion {
     }
 }
 
-// Layout pin (mirrors Zig `comptime { if (@sizeOf(Npm.PackageVersion) != 240) @compileError(...) }`).
-// `PackageVersion` is `std.mem.sliceAsBytes`-serialised into the on-disk
-// `.npm` manifest cache, so its size and field offsets are an ABI contract
-// with every Zig-built Bun that wrote a cache entry. A mismatch here means a
-// cross-runtime cache read will mis-slice — fail loudly at compile time
-// instead. (Full per-type asserts live in `padding_checker::layout_asserts`.)
+// Layout pin. `PackageVersion` is byte-serialised into the on-disk `.npm`
+// manifest cache, so its size and field offsets are an ABI contract with
+// every previously released Bun that wrote a cache entry. A mismatch here
+// means a cross-version cache read will mis-slice — fail loudly at compile
+// time instead. (Full per-type asserts live in `padding_checker::layout_asserts`.)
 const _: () = assert!(
     core::mem::size_of::<PackageVersion>() == 240,
     "Npm.PackageVersion layout drifted from Zig spec (expected 240 bytes); \
@@ -914,9 +908,8 @@ pub mod package_manifest {
         const HEADER_BYTES: &'static str =
             concat!("#!/usr/bin/env bun\n", "bun-npm-manifest-cache-v0.0.7\n");
 
-        // TODO(port): `sizes` was a comptime block iterating PackageManifest's fields by alignment.
-        // Rust cannot reflect struct fields. Hardcode the field order produced by the Zig sort
-        // (descending alignment); re-verify against the Zig output if the layout changes.
+        // Field order is hardcoded (descending alignment). Re-verify if the
+        // layout changes.
         pub const SIZES_FIELDS: &'static [&'static str] = &[
             "pkg",
             "string_buf",
@@ -1000,8 +993,8 @@ pub mod package_manifest {
 
             pos += 128 / 8;
 
-            // TODO(port): inline-for over SIZES_FIELDS — unrolled by hand. Verify field
-            // order matches Zig comptime sort (descending alignment) if the layout changes.
+            // Verify field order matches SIZES_FIELDS (descending alignment)
+            // if the layout changes.
             {
                 // "pkg"
                 // SAFETY: NpmPackage is `#[repr(C)]`, `Copy`, and has **no
@@ -1041,13 +1034,11 @@ pub mod package_manifest {
             outpath: &bun_core::ZStr,
         ) -> Result<(), Error> {
             // 64 KB sounds like a lot but when you consider that this is only about 6 levels deep in the stack, it's not that much.
-            // PERF(port): was stack-fallback alloc — profile if hot.
             let mut buffer: Vec<u8> = Vec::with_capacity(this.byte_length(scope) + 64);
             Serializer::write(this, scope, &mut buffer)?;
             // --- Perf Improvement #1 ----
             // Do not forget to buffer writes!
             //
-            // (benchmark output elided — see npm.zig)
             // --- Perf Improvement #2 ----
             // GetFinalPathnameByHandle is very expensive if called many times
             // We skip calling it when we are giving an absolute file path.
@@ -1140,10 +1131,10 @@ pub mod package_manifest {
                         &mut realpath2_buf[..],
                         &[cache_dir_abs, outpath.as_bytes()],
                     );
-                // Zig spec discards the close error too — the renameat
-                // immediately below surfaces a usable error if the temp
-                // file is in a bad state, and on POSIX the close cannot
-                // fail for a regular-file fd we just wrote.
+                // The close error is discarded — the renameat immediately
+                // below surfaces a usable error if the temp file is in a
+                // bad state, and on POSIX the close cannot fail for a
+                // regular-file fd we just wrote.
                 let _ = file.close();
                 bun_sys::renameat(
                     Fd::cwd(),
@@ -1179,10 +1170,9 @@ pub mod package_manifest {
                             let _ = bun_sys::unlinkat(tmpdir, tmp_path);
                         }
 
-                        // Zig (npm.zig:1128) matches `.OPNOTSUPP`, which on
-                        // Darwin is errno **45** (collapsed with NOTSUP). The
-                        // Rust `Errno::EOPNOTSUPP` resolves to 102 on Darwin,
-                        // so match `ENOTSUP` as well to keep the macOS
+                        // On Darwin `Errno::EOPNOTSUPP` resolves to 102 while
+                        // the kernel reports errno **45** (ENOTSUP), so match
+                        // `ENOTSUP` as well to keep the macOS
                         // `renameat2(.exchange)` fallback reachable. On
                         // Linux/FreeBSD the two names alias the same value,
                         // so compare by equality (a `matches!` pattern would
@@ -1235,19 +1225,21 @@ pub mod package_manifest {
                 Batch as PoolBatch, Node as PoolNode, Task as PoolTask,
             };
 
-            pub(crate) struct SaveTask<'a> {
+            pub(crate) struct SaveTask {
                 manifest: PackageManifest,
-                scope: &'a registry::Scope,
+                // Owned: the thread-pool task can outlive the caller's borrow
+                // of the Registry.Scope, so it owns a clone.
+                scope: registry::Scope,
                 tmpdir: Fd,
                 cache_dir: Fd,
 
                 task: PoolTask,
             }
 
-            bun_threading::intrusive_work_task!(['a] SaveTask<'a>, task);
+            bun_threading::intrusive_work_task!(SaveTask, task);
 
-            impl<'a> SaveTask<'a> {
-                pub(crate) fn new(init: SaveTask<'a>) -> Box<SaveTask<'a>> {
+            impl SaveTask {
+                pub(crate) fn new(init: SaveTask) -> Box<SaveTask> {
                     Box::new(init)
                 }
 
@@ -1269,7 +1261,7 @@ pub mod package_manifest {
 
                     if let Err(err) = Serializer::save(
                         &save_task.manifest,
-                        save_task.scope,
+                        &save_task.scope,
                         save_task.tmpdir,
                         save_task.cache_dir,
                     ) {
@@ -1285,11 +1277,9 @@ pub mod package_manifest {
                 }
             }
 
-            // TODO(port): lifetime — `scope` is borrowed across a thread boundary; Zig assumed
-            // the Registry.Scope outlives the threadpool task. Prove or change to owned.
             let task = bun_core::heap::into_raw(SaveTask::new(SaveTask {
                 manifest: this.clone(),
-                scope,
+                scope: scope.clone(),
                 tmpdir,
                 cache_dir,
                 task: PoolTask {
@@ -1398,7 +1388,6 @@ pub mod package_manifest {
                 return Ok(None);
             }
 
-            // TODO(port): manifest borrows `bytes` in Zig; here read_all copies into Box<[T]>.
             Ok(Some(manifest))
         }
 
@@ -1424,9 +1413,8 @@ pub mod package_manifest {
                 return Ok(None);
             }
 
-            // TODO(port): inline-for over SIZES_FIELDS — unrolled by hand
+            // Keep the order in sync with `Serializer::write` and SIZES_FIELDS.
             {
-                // std.mem.alignForward(usize, pos, alignOf(NpmPackage))
                 pkg_stream.pos = pkg_stream
                     .pos
                     .next_multiple_of(core::mem::align_of::<NpmPackage>());
@@ -1942,8 +1930,8 @@ impl PackageManifest {
     }
 }
 
-// TODO(port): Zig used `IdentityContext(u64)` hasher; std HashMap is fine for now.
-type ExternalStringMapDeduper = HashMap<u64, ExternalStringList>;
+// Keys are pre-hashed string hashes, so don't re-hash them.
+type ExternalStringMapDeduper = HashMap<u64, ExternalStringList, IdentityContext<u64>>;
 
 use bun_install_types::DependencyGroup;
 /// Abbreviated registry metadata never carries `devDependencies` — keep this 3-wide intentionally.
@@ -1965,19 +1953,16 @@ impl PackageManifest {
         public_max_age: u32,
         is_extended_manifest: bool,
     ) -> Result<Option<PackageManifest>, Error> {
-        // TODO(port): narrow error set
         // `bun_ast::Source::init_path_string` accepts borrowed `&[u8]` via
         // `IntoStr`; the Source only lives for the duration of this function,
         // so pass the caller's buffers through directly without manufacturing
         // `'static` references here (PORTING.md §Forbidden lifetime extension).
         let source = bun_ast::Source::init_path_string(expected_name, json_buffer);
         initialize_store();
-        // TODO(port): bun.ast.Stmt.Data.Store.memory_allocator.?.pop() — Zig
-        // pushed/popped the AST arena around the parse so the JSON AST is
-        // bulk-freed on return. `initialize_mini_store` already does the push;
-        // the pop is handled by resetting on the next call. Wire an explicit
-        // RAII guard once `ASTMemoryAllocator::pop` is exposed.
-        // PERF(port): was arena bulk-free — profile if hot.
+        // `initialize_mini_store` deliberately keeps the allocator pushed
+        // across calls (the AstAlloc state stays installed for the re-arm) and
+        // bulk-frees via `reset_retain_with_limit` on the next call — see
+        // `initialize_mini_store` in lib.rs for why.
         let bump = bun_alloc::Arena::new();
         let json = match JSON::parse_utf8(&source, log, &bump) {
             Ok(j) => j,
@@ -2001,8 +1986,10 @@ impl PackageManifest {
             }
         }
 
+        // For cache determinism the serialized `NpmPackage` has explicit
+        // `_padding_*` fields zeroed by `Default`, so plain `default()` is
+        // already deterministic here.
         let mut result: PackageManifest = PackageManifest::default();
-        // TODO(port): bun.serializable() — zero-init for serialization determinism
 
         let mut all_extern_strings_dedupe_map = ExternalStringMapDeduper::default();
         let mut version_extern_strings_dedupe_map = ExternalStringMapDeduper::default();
@@ -2209,7 +2196,6 @@ impl PackageManifest {
                 }
 
                 for pair in &DEPENDENCY_GROUPS {
-                    // PERF(port): was comptime monomorphization — profile if hot.
                     if let Some(versioned_deps) = prop
                         .value
                         .as_ref()
@@ -2348,11 +2334,10 @@ impl PackageManifest {
             vec![PackageNameHash::default(); bundled_deps_count].into_boxed_slice();
         let mut bundled_deps_offset: usize = 0;
 
-        // PORT NOTE: Zig manually @memset zeroed the buffers; Default::default() above achieves
-        // the same determinism for these POD types.
+        // Default::default() above zeroes the buffers for determinism.
 
-        // PORT NOTE: reshaped for borrowck — Zig used overlapping mutable subslices into the
-        // same allocation. Rust uses index cursors instead and re-slices on demand.
+        // Index cursors are used instead of overlapping mutable subslices into
+        // the same allocation; re-slice on demand.
         let mut versioned_package_releases_start: usize = 0;
         let all_versioned_package_releases_range = 0..release_versions_len;
         let mut versioned_package_prereleases_start: usize = release_versions_len;
@@ -2376,13 +2361,11 @@ impl PackageManifest {
 
         string_builder.allocate()?;
 
-        // PORT NOTE: Zig zeroed the freshly allocated buffer for determinism;
-        // `Builder::allocate` already produces a zeroed `Box<[u8]>`.
+        // `Builder::allocate` produces a zeroed `Box<[u8]>` for determinism.
         //
-        // Zig kept a single `string_buf` slice over the builder's backing
-        // allocation for the rest of the function. In Rust that would alias a
-        // `&[u8]` across the `&mut self` borrows taken by every `append` below
-        // (Stacked Borrows UB even though the allocation never moves). Instead
+        // A single `&[u8]` over the builder's backing allocation held across
+        // the `&mut self` borrows taken by every `append` below would be
+        // Stacked Borrows UB (even though the allocation never moves). Instead
         // we re-borrow `string_builder.allocated_slice()` at each read site —
         // `Builder::append*` only writes in-place and never grows/replaces
         // `ptr`, so the slice contents are stable, and NLL releases each
@@ -2414,7 +2397,8 @@ impl PackageManifest {
                 bin: Bin::init(),
                 ..PackageVersion::default()
             };
-            // TODO(port): bun.serializable() on empty_version
+            // PackageVersion's explicit `_padding_*` fields are zeroed by
+            // `Default`, so no separate padding scrub is needed.
 
             for prop in versions {
                 let Some(version_name) = prop
@@ -2568,13 +2552,12 @@ impl PackageManifest {
                                         };
                                         let mut group_i: u32 = 0;
 
-                                        // PORT NOTE: Zig wrote through a raw `*[len]ExternalString`
-                                        // sub-pointer. The boxed slice is fully initialised
+                                        // The boxed slice is fully initialised
                                         // (`vec![Default; n].into_boxed_slice()` in the counting
                                         // pass) and `ExternalString: Copy`, so plain absolute
-                                        // indexing at `group_start + group_i` is the safe
-                                        // equivalent — no `from_raw_parts`/`.add()` needed, and
-                                        // the `prev` read at a disjoint index needs no split.
+                                        // indexing at `group_start + group_i` works — no
+                                        // `from_raw_parts`/`.add()` needed, and the `prev` read
+                                        // at a disjoint index needs no split.
                                         for bin_prop in obj.properties.slice() {
                                             let Some(k) = bin_prop
                                                 .key
@@ -2762,7 +2745,6 @@ impl PackageManifest {
 
                 let mut non_optional_peer_dependency_offset: usize = 0;
 
-                // PERF(port): was comptime monomorphization (`inline for`) — profile if hot.
                 for (group_idx, pair) in DEPENDENCY_GROUPS.iter().enumerate() {
                     let is_peer = pair.prop == b"peerDependencies";
                     // For peer deps, fall through with an empty `items`
@@ -2775,7 +2757,7 @@ impl PackageManifest {
                     // iteration's slice of `bundled_deps_buf`, so an
                     // unconditional empty pass would clobber the value the
                     // `dependencies` iteration just produced.
-                    // PORT NOTE: hoist `versioned_deps` so the borrowed
+                    // hoist `versioned_deps` so the borrowed
                     // `obj.properties.slice()` outlives the labelled block.
                     let versioned_deps = prop
                         .value
@@ -2806,7 +2788,7 @@ impl PackageManifest {
                             }
                         };
                     if items.len() > 0 || has_meta_only_peers {
-                        // PORT NOTE: reshaped for borrowck — index into all_extern_strings / version_extern_strings
+                        // reshaped for borrowck — index into all_extern_strings / version_extern_strings
                         let names_base = dependency_names_cursor;
                         let values_base = dependency_values_cursor;
 
@@ -2825,7 +2807,6 @@ impl PackageManifest {
                                 if let JSON::ExprData::EObject(obj) = &meta.expr.data {
                                     let meta_props = obj.properties.slice();
                                     optional_peer_dep_names.reserve(meta_props.len());
-                                    // PERF(port): was assume_capacity
                                     for meta_prop in meta_props {
                                         if let Some(optional) = meta_prop
                                             .value
@@ -3101,10 +3082,83 @@ impl PackageManifest {
                             _ => unreachable!("non-value Expr from JSON parser"),
                         }
 
-                        // TODO(port): debug-assertions block (Zig lines 2478-2522) elided —
-                        // it re-reads `this_names`/`this_versions` via `mut()` after dedupe.
-                        // Re-add with cursor-based slicing if needed.
-                        let _ = (this_names, this_versions);
+                        // The dedupe must hand back
+                        // lists resolving to identical contents. The string
+                        // pool dedupes equal strings to equal offsets, so
+                        // field equality holds even when `name_list` points
+                        // at an earlier entry's region.
+                        #[cfg(debug_assertions)]
+                        {
+                            let dependencies_list = map;
+                            debug_assert!(
+                                (dependencies_list.name.off as usize) < all_extern_strings.len()
+                            );
+                            debug_assert!(
+                                (dependencies_list.value.off as usize) < all_extern_strings.len()
+                            );
+                            debug_assert!(
+                                dependencies_list.name.off as usize
+                                    + (dependencies_list.name.len as usize)
+                                    < all_extern_strings.len()
+                            );
+                            debug_assert!(
+                                dependencies_list.value.off as usize
+                                    + (dependencies_list.value.len as usize)
+                                    < all_extern_strings.len()
+                            );
+
+                            let name_dependencies = dependencies_list.name.get(&all_extern_strings);
+                            let value_dependencies =
+                                dependencies_list.value.get(&version_extern_strings);
+
+                            // Element-wise field equality.
+                            debug_assert!(name_dependencies.len() == this_names.len());
+                            debug_assert!(value_dependencies.len() == this_versions.len());
+                            for (a, b) in name_dependencies.iter().zip(this_names.iter()) {
+                                debug_assert!(a.hash == b.hash && a.value == b.value);
+                            }
+                            for (a, b) in value_dependencies.iter().zip(this_versions.iter()) {
+                                debug_assert!(a.hash == b.hash && a.value == b.value);
+                            }
+
+                            // Per-element string-content checks against the
+                            // source JSON. Skipped when meta-only
+                            // optional peers may have been synthesised, since
+                            // `items[j]` correspondence no longer holds then.
+                            if !is_peer || optional_peer_dep_names.is_empty() {
+                                let string_buf: &[u8] = string_builder.allocated_slice();
+                                for (j, dep_name) in name_dependencies.iter().enumerate() {
+                                    debug_assert!(
+                                        dep_name.value.slice(string_buf)
+                                            == this_names[j].value.slice(string_buf)
+                                    );
+                                    debug_assert!(
+                                        dep_name.value.slice(string_buf)
+                                            == items[j]
+                                                .key
+                                                .as_ref()
+                                                .expect("infallible: prop has key")
+                                                .as_string(&bump)
+                                                .expect("dependency key must be a string")
+                                    );
+                                }
+                                for (j, dep_version) in value_dependencies.iter().enumerate() {
+                                    debug_assert!(
+                                        dep_version.value.slice(string_buf)
+                                            == this_versions[j].value.slice(string_buf)
+                                    );
+                                    debug_assert!(
+                                        dep_version.value.slice(string_buf)
+                                            == items[j]
+                                                .value
+                                                .as_ref()
+                                                .expect("infallible: prop has value")
+                                                .as_string(&bump)
+                                                .expect("dependency value must be a string")
+                                    );
+                                }
+                            }
+                        }
                     }
                 }
 
@@ -3133,7 +3187,6 @@ impl PackageManifest {
 
             extern_strings_consumed = dependency_names_cursor;
             // version_extern_strings trimmed below
-            // PORT NOTE: Zig: version_extern_strings = version_extern_strings[0 .. len - dependency_values.len]
         }
         let version_extern_strings_len = dependency_values_cursor;
 
@@ -3192,8 +3245,23 @@ impl PackageManifest {
                     ),
                 };
 
-                if cfg!(debug_assertions) {
-                    // TODO(port): std.meta.eql sanity checks elided
+                #[cfg(debug_assertions)]
+                {
+                    // Round-trip check of the just-initialized slices. `init`
+                    // is a pointer-offset round-trip, so slice identity
+                    // (ptr + len) implies element equality.
+                    let tags_rt = result.pkg.dist_tags.tags.get(&all_extern_strings);
+                    debug_assert!(core::ptr::eq(
+                        tags_rt.as_ptr(),
+                        all_extern_strings[extern_strings_slice_start..].as_ptr()
+                    ));
+                    debug_assert!(tags_rt.len() == dist_tag_i);
+                    let versions_rt = result.pkg.dist_tags.versions.get(&all_semver_versions);
+                    debug_assert!(core::ptr::eq(
+                        versions_rt.as_ptr(),
+                        all_semver_versions[dist_tag_versions_start..].as_ptr()
+                    ));
+                    debug_assert!(versions_rt.len() == dist_tag_i);
                 }
 
                 extern_strings_cursor += dist_tag_i;
@@ -3261,7 +3329,7 @@ impl PackageManifest {
             }
         };
 
-        // PERF(port): was comptime monomorphization over Int width — using a macro to expand
+        // A macro expands
         // the 1..=8 byte cases. Could collapse to a single usize path if profiling allows.
         macro_rules! sort_with_int {
             ($Int:ty) => {{
@@ -3283,11 +3351,10 @@ impl PackageManifest {
                     let cloned_versions = &mut all_cloned_versions[..len];
                     // `ExternalSlice` offsets index into `versioned_packages` /
                     // `all_semver_versions`, both fully-initialised `Box<[T]>`s
-                    // (created via `vec![Default; n].into_boxed_slice()` above) —
-                    // safe slice indexing replaces the `from_raw_parts_mut`
-                    // reconstruction Zig's `@constCast(release.values.get(..))`
-                    // forced. The two boxes are distinct allocations so the two
-                    // `&mut` borrows do not overlap.
+                    // (created via `vec![Default; n].into_boxed_slice()` above),
+                    // so safe slice indexing suffices. The two boxes are
+                    // distinct allocations so the two `&mut` borrows do not
+                    // overlap.
                     let versioned_packages_ =
                         &mut versioned_packages[release.values.off as usize..][..len];
                     let semver_versions_ =
@@ -3307,9 +3374,6 @@ impl PackageManifest {
                             string_bytes,
                         )
                     });
-                    // PORT NOTE: Zig sorted indices against semver_versions_ (which is unmutated
-                    // until after sort) — equivalent to sorting against cloned_versions.
-
                     debug_assert_eq!(indices.len(), versioned_packages_.len());
                     debug_assert_eq!(indices.len(), semver_versions_.len());
                     for ((i, pkg), version) in indices
@@ -3353,17 +3417,15 @@ impl PackageManifest {
         if extern_strings_remaining + tarball_urls_count > 0 {
             let src_len = tarball_url_strings_cursor;
             if src_len > 0 {
-                // `ExternalString` is `Copy` POD — Zig used `@memcpy` over
-                // `sliceAsBytes` views here; an element-wise `copy_from_slice`
-                // is bit-identical and lets us drop the `from_raw_parts`
-                // byte-view reconstruction over the same boxed slices.
+                // `ExternalString` is `Copy` POD — an element-wise
+                // `copy_from_slice` suffices.
                 debug_assert!(all_extern_strings.len() - extern_strings_cursor >= src_len);
                 all_extern_strings[extern_strings_cursor..extern_strings_cursor + src_len]
                     .copy_from_slice(&all_tarball_url_strings[..src_len]);
             }
 
             // all_extern_strings = all_extern_strings[0 .. len - extern_strings_remaining]
-            // PORT NOTE: trim by truncating the boxed slice via Vec round-trip
+            // trim by truncating the boxed slice via Vec round-trip
             let new_len = all_extern_strings.len() - extern_strings_remaining;
             let mut v = core::mem::take(&mut all_extern_strings).into_vec();
             v.truncate(new_len);
@@ -3394,9 +3456,6 @@ impl PackageManifest {
         result.pkg.has_extended_manifest = is_extended_manifest;
 
         if let Some(buf) = string_builder.ptr.take() {
-            // TODO(port): string_builder owns this allocation; copy out the
-            // written prefix. Add a `Builder::into_owned()` that yields
-            // `Box<[u8]>` without the truncate copy.
             let mut v = buf.into_vec();
             v.truncate(string_builder.len);
             result.string_buf = v.into_boxed_slice();
@@ -3407,5 +3466,3 @@ impl PackageManifest {
         Ok(Some(result))
     }
 }
-
-// ported from: src/install/npm.zig
diff --git a/src/install/padding_checker.rs b/src/install/padding_checker.rs
index 894340bd691..424912e1c5a 100644
--- a/src/install/padding_checker.rs
+++ b/src/install/padding_checker.rs
@@ -1,4 +1,4 @@
-//! In some parts of lockfile serialization, Bun will use the equivalent of `std.mem.sliceAsBytes` to convert a
+//! In some parts of lockfile serialization, Bun will convert a
 //! struct into raw bytes to write. This makes lockfile serialization/deserialization much simpler/faster, at the
 //! cost of not having any pointers within these structs.
 //!
@@ -31,50 +31,38 @@
 //! There is one other way to introduce undefined memory into a struct, which this does not check for, and that is
 //! a union with unequal size fields.
 
-// TODO(port): The Zig implementation is pure `comptime` reflection over `@typeInfo(T)` —
-// it walks struct/union/array/optional/pointer field trees, recurses into children, and
-// `@compileError`s on any gap between `@offsetOf(T, field) + @sizeOf(field)` and the next
-// field's offset (and between the last field's end and `@sizeOf(T)`).
-//
-// Rust has no `@typeInfo` equivalent. TODO(port): provide this as a proc-macro derive
-// (`#[derive(AssertNoUninitializedPadding)]`) that emits the `const _: () = assert!(...)`
-// checks below per-field, plus a marker trait so `assert_no_uninitialized_padding::<T>()`
-// is bounded on it. The free function here is kept as the call-site-compatible entry point.
+// Per-field `const _: () = assert!(offset_of!...)` proofs live next to each serialized
+// struct (e.g. `NpmPackage` / `PackageVersion` in npm.rs), and the `layout_asserts`
+// module below pins every serialized type's size/align against the on-disk spec.
+// The free function here is kept as the call-site-compatible entry point.
 
 /// Marker trait asserting that `Self` is `#[repr(C)]` (or `#[repr(transparent)]`/packed),
 /// contains no pointer fields, and has no implicit padding bytes anywhere in its layout
-/// (recursively). Implemented by `#[derive(AssertNoUninitializedPadding)]`.
+/// (recursively).
 ///
 /// # Safety
-/// Implementing this by hand asserts the layout invariants above without the derive's
-/// compile-time checks. Only do so for primitives and manually-audited `#[repr(C)]` types.
+/// Implementing this by hand asserts the layout invariants above without compile-time
+/// checks. Only do so for primitives and manually-audited `#[repr(C)]` types whose
+/// explicit `_padding_*` fields are proven gap-free by `const` offset asserts.
 pub unsafe trait AssertNoUninitializedPadding {}
 
 /// Assertion that `T` has no uninitialized padding. See module docs.
 ///
-/// In Zig this walked `@typeInfo(T)` at comptime and emitted `@compileError` on gaps,
-/// with an `else => return` arm that silently accepted any non-aggregate type and a
-/// `.pointer => |ptr| assertNoUninitializedPadding(ptr.child)` arm so callers could
-/// pass `@TypeOf(slice)` directly.
-///
-/// In Rust the actual layout checking lives in `#[derive(AssertNoUninitializedPadding)]`
-/// on each serialized struct; this function is a zero-cost call-site marker that
-/// documents intent. It takes a type-witness value so call sites can mirror the Zig
-/// `assertNoUninitializedPadding(@TypeOf(value))` pattern (pass any value of `T` —
+/// The actual layout checking lives in the per-struct `const` offset asserts
+/// and `layout_asserts` pins; this function is a zero-cost call-site marker that
+/// documents intent. It takes a type-witness value (pass any value of `T` —
 /// or name `T` explicitly via turbofish and reference the fn item without calling).
 ///
-/// The trait bound is intentionally *not* applied here: Zig's `else => return` accepts
-/// all leaf types, and bounding the generic would force every `write_array<T>` caller
-/// to propagate `T: AssertNoUninitializedPadding` before the derive exists.
+/// The trait bound is intentionally *not* applied here: bounding the generic
+/// would force every `write_array<T>` caller to propagate
+/// `T: AssertNoUninitializedPadding`.
 #[inline(always)]
 #[allow(dropping_copy_types, clippy::needless_pass_by_value)]
 pub fn assert_no_uninitialized_padding<T>(_type_witness: T) {
-    // Body intentionally empty — the derive on `T` is the check. Matches Zig's
-    // runtime behaviour (the Zig version is `comptime`-only and codegens nothing).
+    // Body intentionally empty — the per-type `const` layout asserts are the check.
 }
 
-// TODO(port): proc-macro — the derive should expand roughly to the following per type
-// (shown as a declarative helper for reference; not invoked anywhere yet):
+// Reference: what a manual padding audit of a serialized type must establish:
 //
 // For each adjacent field pair (prev, field) in declaration order:
 //   const _: () = assert!(
@@ -101,17 +89,16 @@ pub fn assert_no_uninitialized_padding<T>(_type_witness: T) {
 //       ),
 //   );
 //
-// Recursion rules (mirroring the Zig `switch (@typeInfo(...))`):
+// Recursion rules:
 //   - struct / union field  → require `FieldTy: AssertNoUninitializedPadding`
 //   - [T; N] field          → require `T: AssertNoUninitializedPadding`
 //   - Option<T> field       → require `T: AssertNoUninitializedPadding`
 //   - pointer field         → compile_error!("Expected no pointer types in ...")
 //   - anything else         → ok
 //
-// Unions: recurse into field types but skip the offset-gap scan (matches Zig's
-// `if (info_ == .@"union") return;` before the offset loop).
+// Unions: recurse into field types but skip the offset-gap scan.
 
-// Blanket impls for leaf types the Zig version's `else => return` arm accepted.
+// Blanket impls for leaf types.
 // SAFETY: u8 is a single value byte; no padding by definition.
 unsafe impl AssertNoUninitializedPadding for u8 {}
 // SAFETY: u16 is a fixed-width integer; all 2 bytes are value bytes, no padding.
@@ -135,7 +122,6 @@ unsafe impl AssertNoUninitializedPadding for isize {}
 // SAFETY: bool occupies exactly one byte (value 0 or 1); no padding.
 unsafe impl AssertNoUninitializedPadding for bool {}
 
-// Arrays: Zig's `.array => |a| assertNoUninitializedPadding(a.child)`.
 // SAFETY: `[T; N]` has no inter-element padding when `T` itself has none
 // (array stride == size_of::<T>() always; any tail padding would be inside T and
 // already rejected by T's own impl).
@@ -145,21 +131,20 @@ unsafe impl<T: AssertNoUninitializedPadding, const N: usize> AssertNoUninitializ
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Cross-runtime layout pins
+// Cross-version layout pins
 //
-// Every type below is `std.mem.sliceAsBytes`-serialised into either `bun.lockb`
-// (the binary lockfile) or the `.npm` manifest cache. Their sizes/alignments
-// are therefore an ABI contract with Zig-built Bun: a Zig-written lockfile
-// must round-trip through this build and vice versa. The expected values are
-// computed by hand from the `extern struct` declarations in the corresponding
-// `.zig` files (no `@typeInfo` available in Rust). If any assert fires the
-// on-disk format has drifted — either fix the Rust `#[repr(C)]` layout or
-// bump the relevant format version (`bun.lockb` `format_version` /
+// Every type below is byte-serialised into either `bun.lockb` (the binary
+// lockfile) or the `.npm` manifest cache. Their sizes/alignments are
+// therefore an ABI contract with previously released Bun versions: an
+// older-written lockfile must round-trip through this build and vice versa.
+// The expected values are computed by hand. If any assert fires the on-disk
+// format has drifted — either fix the Rust `#[repr(C)]` layout or bump the
+// relevant format version (`bun.lockb` `format_version` /
 // `PackageManifest::Serializer::VERSION`).
 //
 // The asserts are gated to 64-bit little-endian targets because that is the
-// only ABI the binary formats are defined for (Zig hard-codes `.little` and
-// `@alignOf([*]u8) == 8` in the lockfile header).
+// only ABI the binary formats are defined for (the lockfile header hard-codes
+// little-endian and 8-byte pointer alignment).
 // ──────────────────────────────────────────────────────────────────────────
 #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
 pub mod layout_asserts {
@@ -214,5 +199,3 @@ pub mod layout_asserts {
     pin!(crate::npm::PackageVersion, size = 240, align = 8);
     pin!(crate::npm::NpmPackage, size = 120, align = 8);
 }
-
-// ported from: src/install/padding_checker.zig
diff --git a/src/install/patch_install.rs b/src/install/patch_install.rs
index 2ba8e53b0ca..ddc9e0eb742 100644
--- a/src/install/patch_install.rs
+++ b/src/install/patch_install.rs
@@ -21,16 +21,7 @@ use crate::{
     resolution::Resolution,
 };
 
-// Thin re-exports (mirroring Zig `pub const X = @import(...)` lines).
 pub use crate::lockfile::PatchedDep;
-pub use crate::resolution::Resolution as ResolutionExport;
-pub use crate::{
-    DependencyID as DependencyIDExport, PackageID as PackageIDExport,
-    PackageInstall as PackageInstallExport, bun_hash_tag as bun_hash_tag_export,
-};
-// TODO(port): the Zig file re-exports these under the same names; Rust cannot re-export and `use`
-// the same identifier twice in one module without aliasing. Collapse the duplicate
-// `*Export` aliases above once module layout is settled.
 
 bun_output::declare_scope!(InstallPatch, visible);
 
@@ -39,13 +30,13 @@ pub(crate) const MAX_HEX_HASH_LEN: usize = const_format::formatcp!("{:x}", u64::
 pub(crate) const MAX_BUNTAG_HASH_BUF_LEN: usize = MAX_HEX_HASH_LEN + bun_hash_tag.len() + 1;
 pub(crate) type BuntagHashBuf = [u8; MAX_BUNTAG_HASH_BUF_LEN];
 
-// `std.fs.Dir` aliases on `PatchTask`/`ApplyPatch` are *borrowed views* of the
+// The directory handles on `PatchTask`/`ApplyPatch` are *borrowed views* of the
 // `PackageManager`-owned cache/temp directory descriptors. Store the raw `Fd`
 // so the task's drop never closes a descriptor it doesn't own. Use
 // `Dir::borrow(&fd)` where a `&Dir` is needed.
 
 pub struct PatchTask {
-    /// BACKREF (Zig: `*PackageManager`). Stored as `BackRef` because the task
+    /// BACKREF. Stored as `BackRef` because the task
     /// is held via raw pointer through the intrusive thread-pool queue while
     /// the manager is concurrently borrowed `&mut` on the main thread; a `&`
     /// reference here would alias that exclusive borrow under Stacked Borrows.
@@ -82,7 +73,6 @@ pub enum Callback {
 }
 
 impl Callback {
-    /// Zig: `@tagName(self.callback)`.
     #[inline]
     pub(crate) fn tag_name(&self) -> &'static str {
         <&'static str>::from(self)
@@ -95,7 +85,7 @@ impl Callback {
     pub(crate) fn is_apply(&self) -> bool {
         matches!(self, Callback::Apply(_))
     }
-    /// Zig: `&self.callback.apply`. Panics if the active variant is not `Apply`.
+    /// Panics if the active variant is not `Apply`.
     #[inline]
     pub(crate) fn apply_mut(&mut self) -> &mut ApplyPatch {
         match self {
@@ -152,18 +142,15 @@ impl PatchTask {
     /// Destroy a heap-allocated `PatchTask` previously created by
     /// `new_calc_patch_hash` / `new_apply_patch_hash`.
     ///
-    /// PORT NOTE: Zig `deinit` freed each owned field then `bun.destroy(this)`. In Rust the
-    /// owned fields (`Box<[u8]>`, `Vec<u8>`, `Log`, `Option<...>`) drop automatically, so no
-    /// `impl Drop` body is needed. Per PORTING.md, `deinit` is never exposed as the public API;
-    /// because `PatchTask` is held via raw pointer through the intrusive `next`/thread-pool
-    /// queue, the named reclaim point is `unsafe fn destroy`. Cross-file callers map
-    /// `pt.deinit()` → `unsafe { PatchTask::destroy(pt) }`.
+    /// The owned fields (`Box<[u8]>`, `Vec<u8>`, `Log`, `Option<...>`) drop automatically, so no
+    /// `impl Drop` body is needed. Because `PatchTask` is held via raw pointer through the
+    /// intrusive `next`/thread-pool queue, the named reclaim point is `unsafe fn destroy`.
     ///
     /// # Safety
     /// `this` must have been produced by `heap::alloc` in the `new_*` constructors below and
     /// ownership must be returned here exactly once.
     pub unsafe fn destroy(this: *mut Self) {
-        // TODO: how to deinit `this.callback.calc_hash.network_task` (carried over from Zig)
+        // TODO: how to deinit `this.callback.calc_hash.network_task`
         // SAFETY: caller contract — `this` was produced by `heap::into_raw` in
         // `new_calc_patch_hash`/`new_apply_patch_hash` and is reclaimed exactly once.
         drop(unsafe { bun_core::heap::take(this) });
@@ -188,15 +175,15 @@ impl PatchTask {
             "runFromThreadPoolImpl {}",
             <&'static str>::from(&self.callback)
         );
-        // PORT NOTE: Zig used nested `defer { defer wake(); push(this); }`. There are no early
-        // returns in the body, so the equivalent ordering (body → push → wake) is inlined below.
+        // There are no early returns in the body, so the ordering
+        // (body → push → wake) is inlined below.
         match &mut self.callback {
             Callback::CalcHash(_) => {
                 let result = self.calc_hash();
                 if let Callback::CalcHash(ch) = &mut self.callback {
                     ch.result = result;
                 }
-                // PORT NOTE: reshaped for borrowck — `calc_hash` borrows `&mut self`, so we
+                // Reshaped for borrowck — `calc_hash` borrows `&mut self`, so we
                 // cannot hold a `&mut ch` across the call.
             }
             Callback::Apply(_) => {
@@ -205,7 +192,7 @@ impl PatchTask {
             }
         }
         let mgr = self.manager.as_ptr();
-        // SAFETY: `self.manager` is a long-lived BACKREF (Zig `*PackageManager`);
+        // SAFETY: `self.manager` is a long-lived BACKREF;
         // the worker thread only touches the lock-free `patch_task_queue` and the
         // event-loop wake atomics, neither of which alias data the main thread
         // holds an exclusive borrow on.
@@ -222,7 +209,6 @@ impl PatchTask {
         manager: &mut PackageManager,
         log_level: LogLevel,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         bun_output::scoped_log!(
             InstallPatch,
             "runFromThreadMainThread {}",
@@ -264,11 +250,6 @@ impl PatchTask {
             let _ = apply
                 .logger
                 .print(std::ptr::from_mut(Output::error_writer()));
-            // PORT NOTE: Zig called `apply.logger.deinit()` here under `defer`. The `Log` is a
-            // field and will be dropped with the task; explicit early drop is skipped to avoid
-            // double-drop. If `Log::deinit` is reset-to-empty (idempotent), an explicit
-            // `apply.logger.clear()` could be restored here.
-            // TODO(port): confirm Log drop semantics
         }
     }
 
@@ -277,7 +258,6 @@ impl PatchTask {
         manager: &mut PackageManager,
         log_level: LogLevel,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // TODO only works for npm package
         // need to switch on version.tag and handle each case appropriately
         let Callback::CalcHash(calc_hash) = &mut self.callback else {
@@ -317,9 +297,8 @@ impl PatchTask {
             let dep_id = state.dependency_id;
 
             let pkg: Package = *manager.lockfile.packages.get(pkg_id as usize);
-            // PORT NOTE: `Package` is not `Copy` in the Rust port; capture the
-            // scalar fields we need after `determine_preinstall_state` consumes
-            // it (Zig's `packages.get()` returns by-value-copy).
+            // `Package` is not `Copy`; capture the scalar fields we need
+            // after `determine_preinstall_state` consumes it.
             let pkg_meta_id = pkg.meta.id;
             let pkg_name = pkg.name;
             let pkg_resolution_tag = pkg.resolution.tag;
@@ -348,10 +327,14 @@ impl PatchTask {
                         BStr::new(pkg_name.slice(&manager.lockfile.buffers.string_bytes))
                     );
 
-                    // SAFETY: this arm is the `.npm` extract path; the
-                    // resolution union's active variant is `npm` (see the
-                    // `pkg_resolution_tag` switch below — Zig only reads
-                    // `pkg.resolution.value.npm.version` here, line 183).
+                    // SAFETY: every `Resolution` `Value` payload is `Copy`
+                    // POD and the union is zero-initialized (see the union
+                    // accessors in resolution.rs), so reading `.npm.version`
+                    // yields initialized bytes even when the active variant
+                    // is not `npm` — possibly stale, never uninit. This arm
+                    // is reachable for non-npm resolutions too (git/github/
+                    // tarball; see the TODO below), which then read garbage
+                    // version bytes into the task id, not UB.
                     let pkg_npm_version = unsafe {
                         manager.lockfile.packages.items_resolution()[pkg_id as usize]
                             .value
@@ -447,8 +430,6 @@ impl PatchTask {
                     return Ok(());
                 }
             };
-        // PORT NOTE: `defer this.manager.allocator.free(patchfile_txt)` — `patchfile_txt` is owned
-        // (`Vec<u8>`/`Box<[u8]>`) and drops at end of scope.
         let patchfile = match bun_patch::parse_patch_file(&patchfile_txt) {
             Ok(p) => p,
             Err(e) => {
@@ -459,7 +440,6 @@ impl PatchTask {
                 return Ok(());
             }
         };
-        // PORT NOTE: `defer patchfile.deinit(bun.default_allocator)` — handled by Drop.
 
         // 2. Create temp dir to do all the modifications
         let mut tmpname_buf = [0u8; 1024];
@@ -481,9 +461,9 @@ impl PatchTask {
 
         let (resolution_label, resolution_tag) = {
             // TODO: fix this threadsafety issue.
-            // PORT NOTE: not `self.manager()` — `&mut self.callback` is live.
+            // Not `self.manager()` — `&mut self.callback` is live.
             // BACKREF; the lockfile is read-only while apply tasks run
-            // off-thread (same contract as the Zig pointer dereference here).
+            // off-thread.
             let manager = self.manager.get();
             let resolution: &Resolution =
                 &manager.lockfile.packages.items_resolution()[patch.pkg_id as usize];
@@ -500,25 +480,23 @@ impl PatchTask {
             .expect("OOM");
             (label, resolution.tag)
         };
-        // PORT NOTE: `defer allocator.free(resolution_label)` — Vec drops at scope end.
 
         // 3. copy the unpatched files into temp dir
         let cache_dir_subpath_z: &ZStr = patch.cache_dir_subpath_without_patch_hash.as_zstr();
-        // PORT NOTE: borrowck — `tempdir_name` borrows `tmpname_buf` mutably, but
+        // Borrowck — `tempdir_name` borrows `tmpname_buf` mutably, but
         // `PackageInstall` also wants `&mut tmpname_buf[..]` for
-        // `destination_dir_subpath_buf`. Zig aliased the two; `PackageInstall`
-        // assumes `destination_dir_subpath` is a prefix slice *into*
+        // `destination_dir_subpath_buf`. `PackageInstall` assumes
+        // `destination_dir_subpath` is a prefix slice *into*
         // `destination_dir_subpath_buf` (see `verifyGitResolution` /
-        // `verifyPackageJSONNameAndVersion`). Rust can't express that aliasing
-        // with `&ZStr` + `&mut [u8]`, so use a separate buffer but mirror the
-        // prefix bytes so the invariant holds for any future call that reaches
-        // those paths.
+        // `verifyPackageJSONNameAndVersion`), and that aliasing can't be
+        // expressed with `&ZStr` + `&mut [u8]`, so use a separate buffer but
+        // mirror the prefix bytes so the invariant holds for any future call
+        // that reaches those paths.
         let mut dest_subpath_buf = [0u8; 1024];
         dest_subpath_buf[..tempdir_name.len() + 1]
             .copy_from_slice(tempdir_name.as_bytes_with_nul());
-        // PORT NOTE: not `self.manager()` — `&mut self.callback` is live.
-        // BACKREF — read-only lockfile access; same contract as the Zig
-        // pointer dereference here.
+        // Not `self.manager()` — `&mut self.callback` is live.
+        // BACKREF — read-only lockfile access while the task runs off-thread.
         let lockfile = &self.manager.get().lockfile;
         let mut pkg_install = PackageInstall {
             cache_dir: patch.cache_dir,
@@ -662,9 +640,8 @@ impl PatchTask {
         let stat: sys::Stat = match sys::stat(absolute_patchfile_path) {
             sys::Result::Err(e) => {
                 if e.get_errno() == sys::Errno::ENOENT {
-                    // PORT NOTE: not `self.manager()` — `&mut self.callback` is live.
-                    // BACKREF — read-only lockfile access on the worker thread;
-                    // same contract as the Zig pointer dereference here.
+                    // Not `self.manager()` — `&mut self.callback` is live.
+                    // BACKREF — read-only lockfile access on the worker thread.
                     let manager = self.manager.get();
                     log.add_error_fmt(
                         None,
@@ -755,9 +732,9 @@ impl PatchTask {
     }
 
     pub fn notify(&mut self) {
-        // PORT NOTE: Zig `defer this.manager.wake()` then `push`. No early returns; inline order.
+        // Push, then wake. No early returns.
         let mgr = self.manager.as_ptr();
-        // SAFETY: `self.manager` is a long-lived BACKREF (Zig `*PackageManager`);
+        // SAFETY: `self.manager` is a long-lived BACKREF;
         // only touches the lock-free queue and event-loop wake atomics.
         unsafe {
             (*mgr)
@@ -783,8 +760,8 @@ impl PatchTask {
             .unwrap_or_else(|| panic!("This is a bug"));
         let patchfile_path: Box<[u8]> =
             Box::from(patchdep.path.slice(&manager.lockfile.buffers.string_bytes));
-        // TODO(port): Zig used `dupeZ` (NUL-terminated). The field is typed `[]const u8` and only
-        // used as a byte slice, so `Box<[u8]>` without trailing NUL should be equivalent. Verify.
+        // The field is only ever consumed as a byte slice (`join_z_buf` input,
+        // log formatting), so no trailing NUL is needed.
 
         let tempdir = manager.get_temporary_directory().handle.fd();
         let pt = Box::new(PatchTask {
@@ -817,13 +794,13 @@ impl PatchTask {
     ) -> *mut PatchTask {
         let pkg_name = pkg_manager.lockfile.packages.items_name()[pkg_id as usize];
 
-        // PORT NOTE: borrowck — `compute_cache_dir_and_subpath` borrows `&mut PackageManager`
+        // Borrowck — `compute_cache_dir_and_subpath` borrows `&mut PackageManager`
         // while `pkg_name.slice(..)` and `resolution` borrow `pkg_manager.lockfile` immutably.
         // Clone the slice/resolution out first.
         let pkg_name_slice = pkg_name
             .slice(&pkg_manager.lockfile.buffers.string_bytes)
             .to_vec();
-        // PORT NOTE: `Resolution` is `Copy`; copy out so the lockfile borrow ends
+        // `Resolution` is `Copy`; copy out so the lockfile borrow ends
         // before `compute_cache_dir_and_subpath` reborrows `pkg_manager` mutably.
         let resolution_clone: Resolution =
             pkg_manager.lockfile.packages.items_resolution()[pkg_id as usize];
@@ -893,5 +870,3 @@ use crate::network_task::Authorization;
 use crate::package_install::{InstallResult, Method as InstallMethod};
 use crate::package_manager::Options::LogLevel;
 use crate::package_manager_task::Id as TaskId;
-
-// ported from: src/install/patch_install.zig
diff --git a/src/install/pnpm.rs b/src/install/pnpm.rs
index edff063b931..bef2780a10f 100644
--- a/src/install/pnpm.rs
+++ b/src/install/pnpm.rs
@@ -20,10 +20,9 @@ use crate::npm::{self};
 use crate::resolution::{self, Resolution, TaggedValue};
 use crate::{DependencyID, INVALID_PACKAGE_ID, PackageID, PackageManager};
 
-// PORT NOTE: reshaped for borrowck. Zig keeps a single `var string_buf =
-// lockfile.stringBuf()` for the whole function, but in Rust that locks out
-// every other `lockfile.*` access. Construct a fresh `Buf` per append so the
-// mutable borrow ends immediately.
+// A single long-lived `Buf` for the whole function would lock out every other
+// `lockfile.*` access. Construct a fresh `Buf` per append so the mutable
+// borrow ends immediately.
 macro_rules! sbuf {
     ($lockfile:expr) => {
         semver::string::Buf {
@@ -33,12 +32,11 @@ macro_rules! sbuf {
     };
 }
 
-// PORT NOTE: Zig freely passes `lockfile.buffers.string_bytes.items` alongside
-// `&mut lockfile`. In Rust we keep the borrows field-disjoint instead — every
-// concurrent mutation in this file touches `buffers.dependencies`,
-// `buffers.resolutions`, `packages`, etc., never `string_bytes` itself, so a
-// plain `lockfile.buffers.string_bytes.as_slice()` at the use site is sound
-// and checked. The one exception (`append_package_dedupe` taking `&mut self`)
+// Borrows are kept field-disjoint — every concurrent mutation in this file
+// touches `buffers.dependencies`, `buffers.resolutions`, `packages`, etc.,
+// never `string_bytes` itself, so a plain
+// `lockfile.buffers.string_bytes.as_slice()` at the use site is sound and
+// checked. The one exception (`append_package_dedupe` taking `&mut self`)
 // reads the slice from `self` internally.
 macro_rules! string_bytes {
     ($lockfile:expr) => {
@@ -144,8 +142,8 @@ bun_core::oom_from_alloc!(MigratePnpmLockfileError);
 
 impl From<bun_core::Error> for MigratePnpmLockfileError {
     fn from(e: bun_core::Error) -> Self {
-        // Preserve the variants Zig's error-set union carried through; only
-        // collapse genuinely-unknown tags to InvalidPnpmLockfile.
+        // Preserve the known error variants; only collapse genuinely-unknown
+        // tags to InvalidPnpmLockfile.
         if e == bun_core::err!(OutOfMemory) {
             Self::OutOfMemory
         } else if e == bun_core::err!(DependencyLoop) {
@@ -220,8 +218,8 @@ fn e_object_mut(expr: &mut Expr) -> &mut E::Object {
     }
 }
 
-/// Shallow struct copy (Zig copies `G.Property` by value freely; the Rust
-/// `G::Property` lacks `Clone` because of its `Vec`/`NonNull` fields).
+/// Shallow struct copy (`G::Property` lacks `Clone` because of its
+/// `Vec`/`NonNull` fields).
 fn shallow_clone_prop(p: &G::Property) -> G::Property {
     G::Property {
         key: p.key,
@@ -245,9 +243,8 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
     // `Store` (via `Expr::init`). Later `workspace_package_json_cache.get_with_path`
     // calls (with default `init_reset_store: true`) invoke `initialize_store()`,
     // which `Store::reset()`s — invalidating every `StoreRef` in the parsed
-    // YAML tree. Mirror Zig's `deepClone(allocator)`: clone the tree out of
-    // the Store into `yaml_arena` (which lives for the whole function) so
-    // `root` survives those resets.
+    // YAML tree. Clone the tree out of the Store into `yaml_arena` (which
+    // lives for the whole function) so `root` survives those resets.
     let yaml_source = bun_ast::Source::init_path_string(b"pnpm-lock.yaml", data);
     let yaml_arena = bun_alloc::Arena::new();
     let _root: Expr = match bun_parsers::yaml::YAML::parse(&yaml_source, log, &yaml_arena) {
@@ -441,8 +438,8 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
             }
 
             let mut pkg_json_path = bun_paths::AutoAbsPath::init_top_level_dir();
-            let _ = pkg_json_path.append(importer_path); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-            let _ = pkg_json_path.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = pkg_json_path.append(importer_path); // OOM/capacity error is non-actionable here
+            let _ = pkg_json_path.append(b"package.json"); // OOM/capacity error is non-actionable here
 
             let importer_pkg_json = match manager
                 .workspace_package_json_cache
@@ -496,7 +493,7 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
 
         {
             let mut pkg_json_path = bun_paths::AutoAbsPath::init_top_level_dir();
-            let _ = pkg_json_path.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = pkg_json_path.append(b"package.json"); // OOM/capacity error is non-actionable here
 
             let pkg_json = match manager
                 .workspace_package_json_cache
@@ -564,9 +561,9 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
                 };
 
                 let mut path_buf = bun_paths::AutoAbsPath::init_top_level_dir();
-                let _ = path_buf.append(path); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = path_buf.append(path); // OOM/capacity error is non-actionable here
                 let abs_path: Box<[u8]> = Box::from(path_buf.slice());
-                let _ = path_buf.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = path_buf.append(b"package.json"); // OOM/capacity error is non-actionable here
 
                 let workspace_pkg_json = match manager
                     .workspace_package_json_cache
@@ -577,7 +574,7 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
                     Err(_) => return Err(invalid_pnpm_lockfile()),
                 };
 
-                // PORT NOTE: copy `Expr` out by value so the `&mut manager`
+                // Copy `Expr` out by value so the `&mut manager`
                 // borrow held by `workspace_pkg_json` ends here — `manager`
                 // is reborrowed below for `parse_append_importer_dependencies`.
                 let workspace_root: Expr = workspace_pkg_json.root;
@@ -640,7 +637,7 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
         for _pkg_id in 0..workspace_pkgs_end {
             let pkg_id: PackageID = u32::try_from(_pkg_id).expect("int cast");
 
-            // PORT NOTE: own the bytes — the `'next_dep` loop body mutates
+            // Own the bytes — the `'next_dep` loop body mutates
             // `lockfile.buffers.string_bytes` (via `sbuf!`) and takes
             // `&mut *lockfile` (`append_package_dedupe`), so a borrow that
             // spans the loop would conflict.
@@ -685,13 +682,13 @@ pub(crate) fn migrate_pnpm_lockfile<'a>(
                             if dep.version.tag == dependency::VersionTag::Workspace {
                                 let mut link_path_buf =
                                     bun_paths::AutoAbsPath::init_top_level_dir();
-                                let _ = link_path_buf.append(workspace_path); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                                let _ = link_path_buf.append(workspace_path); // OOM/capacity error is non-actionable here
                                 let _ = link_path_buf.join(&[link_path]); // path-buffer overflow unreachable for bounded inputs
 
                                 for existing_workspace_path in lockfile.workspace_paths.values() {
                                     let mut workspace_path_buf =
                                         bun_paths::AutoAbsPath::init_top_level_dir();
-                                    // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                                    // OOM/capacity error is non-actionable here
                                     let _ = workspace_path_buf.append(
                                         existing_workspace_path.slice(string_bytes!(lockfile)),
                                     );
@@ -1496,9 +1493,9 @@ fn parse_append_importer_dependencies(
                 if strings::has_prefix(specifier_str, b"catalog:") {
                     let catalog_group_name_str = &specifier_str[b"catalog:".len()..];
                     let catalog_group_name = sbuf!(lockfile).append(catalog_group_name_str)?;
-                    // PORT NOTE: reshaped for borrowck — `CatalogMap::get` needs
-                    // both `&mut self.catalogs` and `&self`; temporarily move
-                    // catalogs out so the disjoint fields can be borrowed.
+                    // `CatalogMap::get` needs both `&mut self.catalogs` and
+                    // `&self`; temporarily move catalogs out so the disjoint
+                    // fields can be borrowed.
                     let catalogs = core::mem::take(&mut lockfile.catalogs);
                     let dep_result = catalogs.get(lockfile, catalog_group_name, name.value);
                     lockfile.catalogs = catalogs;
@@ -1528,10 +1525,6 @@ fn parse_append_importer_dependencies(
                 let behavior: dependency::Behavior = group_behavior;
 
                 // TODO: find peerDependencies from package.json
-                if group_behavior.is_prod() {
-                    // PERF(port): was comptime branch
-                }
-
                 let dep = Dependency {
                     name: name.value,
                     name_hash: name.hash,
@@ -1565,8 +1558,8 @@ fn parse_append_importer_dependencies(
                 }
 
                 let mut path_buf = bun_paths::AutoAbsPath::init_top_level_dir();
-                let _ = path_buf.append(path); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-                let _ = path_buf.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = path_buf.append(path); // OOM/capacity error is non-actionable here
+                let _ = path_buf.append(b"package.json"); // OOM/capacity error is non-actionable here
 
                 let workspace_pkg_json = match manager
                     .workspace_package_json_cache
@@ -1622,7 +1615,7 @@ fn update_package_json_after_migration(
     patches: &StringArrayHashMap<Box<[u8]>>,
 ) -> Result<(), AllocError> {
     let mut pkg_json_path = bun_paths::AutoAbsPath::init_top_level_dir();
-    let _ = pkg_json_path.append(b"package.json"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+    let _ = pkg_json_path.append(b"package.json"); // OOM/capacity error is non-actionable here
 
     let bump = bun_alloc::Arena::new();
 
@@ -1792,15 +1785,12 @@ fn update_package_json_after_migration(
 
     match sys::File::read_from(Fd::cwd(), b"pnpm-workspace.yaml") {
         Ok(contents) => 'read_pnpm_workspace_yaml: {
-            // Zig: `readFrom(..., allocator)` heap-allocates with the long-
-            // lived default allocator and never frees, so YAML scalar
-            // `EString.data` slices that borrow from these source bytes stay
-            // valid for the rest of the program. The Rust `Vec<u8>` would drop
-            // at the end of this arm while the `Expr`s it backs (catalog/
-            // catalogs/overrides/patchedDependencies below) escape into `json`
-            // and the `workspace_package_json_cache`. Intern the bytes into
-            // the same thread-local `DATA_STORE` that owns the surrounding
-            // `Expr` nodes — arena ownership, not a leak (bulk-freed on
+            // The `Vec<u8>` would drop at the end of this arm while the
+            // `Expr`s it backs (catalog/catalogs/overrides/patchedDependencies
+            // below) escape into `json` and the
+            // `workspace_package_json_cache`. Intern the bytes into the same
+            // thread-local `DATA_STORE` that owns the surrounding `Expr`
+            // nodes — arena ownership, not a leak (bulk-freed on
             // `Expr::data_store_reset`).
             let contents: &'static [u8] = js_ast::data_store_dupe_str(&contents);
             let yaml_source = bun_ast::Source::init_path_string(b"pnpm-workspace.yaml", contents);
@@ -2032,8 +2022,7 @@ fn update_package_json_after_migration(
                     bstr::BStr::new(&**res_str)
                 )
                 .map_err(|_| AllocError)?;
-                // Zig: `allocator.dupe(u8, join_buf.items)` with the long-lived
-                // default allocator. The rewritten key ends up inside
+                // The rewritten key ends up inside
                 // `root_pkg_json.root` (Store-backed, cached in
                 // `workspace_package_json_cache`), so it must outlive this
                 // function — intern into the thread-local `DATA_STORE` that
@@ -2106,5 +2095,3 @@ fn update_package_json_after_migration(
 
     Ok(())
 }
-
-// ported from: src/install/pnpm.zig
diff --git a/src/install/postinstall_optimizer.rs b/src/install/postinstall_optimizer.rs
index 20f8fe02d04..18eae828f73 100644
--- a/src/install/postinstall_optimizer.rs
+++ b/src/install/postinstall_optimizer.rs
@@ -1,8 +1,8 @@
 use bun_collections::VecExt;
 use std::sync::LazyLock;
 
-use bun_collections::ArrayHashMap;
-// PORT NOTE: `Expr` here is the T2 `bun_ast::Expr` (re-exported via
+use bun_collections::{ArrayHashMap, ArrayIdentityContextU64};
+// `Expr` here is the T2 `bun_ast::Expr` (re-exported via
 // `crate::bun_json`), not the T4 `bun_ast::Expr`. The sole caller
 // (`lockfile::Package::parse_with_json`) holds a JSON-parsed `bun_json::Expr`,
 // so binding to the lower-tier type avoids a cross-tier mismatch.
@@ -20,8 +20,9 @@ pub enum PostinstallOptimizer {
     Ignore,
 }
 
-// TODO(port): was comptime in Zig — verify `string_hash` can be `const fn` and
-// switch to `const` array if so.
+// `string_hash` is `Wyhash11` (not `const fn`; only the std-Wyhash final4
+// variant has a const implementation), so this is a `LazyLock` rather than a
+// `const` array.
 static DEFAULT_NATIVE_BINLINKS_NAME_HASHES: LazyLock<[PackageNameHash; 2]> = LazyLock::new(|| {
     [
         semver::string::Builder::string_hash(b"esbuild"),
@@ -34,8 +35,7 @@ struct DefaultIgnore {
     minimum_version: semver::Version,
 }
 
-// TODO(port): was comptime in Zig — `Version::parse_utf8` is unlikely to be `const fn`; keep
-// LazyLock unless a const path is found.
+// `Version::parse_utf8` is not `const fn`, so this is a `LazyLock`.
 static DEFAULT_IGNORE: LazyLock<[DefaultIgnore; 1]> = LazyLock::new(|| {
     [DefaultIgnore {
         name_hash: semver::string::Builder::string_hash(b"sharp"),
@@ -49,9 +49,8 @@ impl PostinstallOptimizer {
         expr: &js_ast::Expr,
         value: PostinstallOptimizer,
     ) -> Result<bool, bun_alloc::AllocError> {
-        // PORT NOTE: Zig `expr.asArray()` returns null for both non-array AND empty
-        // array, so the `items.len == 0` check below is dead in Zig too — preserved
-        // for diff parity.
+        // `expr.as_array()` returns `None` for both non-array AND empty
+        // array, so the `items.len == 0` check below is dead.
         let Some(mut array) = expr.as_array() else {
             return Ok(false);
         };
@@ -60,20 +59,29 @@ impl PostinstallOptimizer {
         }
 
         while let Some(entry) = array.next() {
-            if entry.is_string() {
-                // PORT NOTE: Zig `asString(allocator)` would convert UTF-16→UTF-8; JSON
-                // string literals are always UTF-8/non-rope, so `as_utf8_string_literal`
-                // suffices and avoids threading a bump arena.
-                // TODO(port): if a UTF-16 EString ever reaches here, route a `&Bump`.
-                let Some(str) = entry.as_utf8_string_literal() else {
-                    continue;
-                };
+            let js_ast::ExprData::EString(s) = &entry.data else {
+                continue;
+            };
+            // JSON parsing never folds strings into ropes (same invariant
+            // `as_utf8_string_literal` asserted before this was inlined).
+            debug_assert!(s.next.is_none());
+            // The JSON lexer emits UTF-16 `EString`s for non-ASCII
+            // package.json strings, so both representations must hash the same
+            // UTF-8 bytes.
+            let hash = if s.is_utf8() {
+                let str = s.slice8();
                 if str.is_empty() {
                     continue;
                 }
-                let hash = semver::string::Builder::string_hash(str);
-                list.dynamic.put(hash, value)?;
-            }
+                semver::string::Builder::string_hash(str)
+            } else {
+                let utf8 = bun_core::strings::to_utf8_alloc(s.slice16());
+                if utf8.is_empty() {
+                    continue;
+                }
+                semver::string::Builder::string_hash(&utf8)
+            };
+            list.dynamic.put(hash, value)?;
         }
 
         Ok(true)
@@ -107,8 +115,8 @@ impl PostinstallOptimizer {
         target_os: npm::OperatingSystem,
     ) -> Option<PackageID> {
         // Windows needs file extensions.
-        // Zig: `@enumFromInt(Npm.OperatingSystem.win32)` — wrap the raw bit in the
-        // newtype since `WIN32` is exported as the underlying `u16` repr, not `Self`.
+        // Wrap the raw bit in the newtype since `WIN32` is exported as the
+        // underlying `u16` repr, not `Self`.
         if target_os.is_match(npm::OperatingSystem(npm::OperatingSystem::WIN32)) {
             return None;
         }
@@ -132,11 +140,9 @@ impl PostinstallOptimizer {
     }
 }
 
-// TODO(port): Zig used `std.ArrayHashMapUnmanaged(PackageNameHash, PostinstallOptimizer,
-// install.ArrayIdentityContext.U64, false)` — i.e. an *identity* hash context (key is already
-// a hash). `bun_collections::ArrayHashMap` should be configured for identity hashing on u64 keys,
-// or expose a `ArrayHashMap<K, V, IdentityU64>` variant.
-pub type Map = ArrayHashMap<PackageNameHash, PostinstallOptimizer>;
+// The key is already a hash, so use the identity context rather than
+// re-hashing it.
+pub type Map = ArrayHashMap<PackageNameHash, PostinstallOptimizer, ArrayIdentityContextU64>;
 
 #[derive(Default)]
 pub struct List {
@@ -172,8 +178,8 @@ impl List {
             }
         }
 
-        // Zig: feature flag has `default: false` and returns bool directly; the Rust
-        // env_var port returns `Option<bool>`. unwrap_or(false) preserves the default.
+        // The feature flag defaults to false; `env_var` returns `Option<bool>`,
+        // so unwrap_or(false) preserves the default.
         if bun_core::env_var::feature_flag::BUN_FEATURE_FLAG_DISABLE_NATIVE_DEPENDENCY_LINKER
             .get()
             .unwrap_or(false)
@@ -193,7 +199,7 @@ impl List {
         target_os: npm::OperatingSystem,
         tree_id: Option<TreeId>,
     ) -> bool {
-        // Zig: feature flag has `default: false`; see note on the binlinker flag above.
+        // The feature flag defaults to false; see note on the binlinker flag above.
         if bun_core::env_var::feature_flag::BUN_FEATURE_FLAG_DISABLE_IGNORE_SCRIPTS
             .get()
             .unwrap_or(false)
@@ -278,5 +284,3 @@ impl List {
         None
     }
 }
-
-// ported from: src/install/postinstall_optimizer.zig
diff --git a/src/install/repository.rs b/src/install/repository.rs
index bdf49e1c534..4b44a91daa7 100644
--- a/src/install/repository.rs
+++ b/src/install/repository.rs
@@ -13,11 +13,12 @@ use crate::dependency as Dependency;
 use crate::hosted_git_info;
 use crate::install::{self as Install, ExtractData, PackageManager};
 
-// TODO(port): bun.ThreadlocalBuffers — Zig returns a raw pointer into thread-local
-// storage so callers can return slices that outlive the access. Rust thread_local!
-// closures cannot express this without unsafe. TODO(refactor): either (a) make
-// try_ssh/try_https take an out-buffer, or (b) wrap in a type that hands out
-// a raw `*mut PathBuffer` via UnsafeCell with documented single-use invariant.
+// Thread-local scratch buffers. Callers return slices that outlive the access
+// (`try_ssh`/`try_https` hand a slice straight to `download`). `thread_local!`
+// closures cannot express that without unsafe, so this is a leaked per-thread
+// allocation with per-field projection accessors and a documented
+// single-use-per-field invariant (see `tl_bufs()` / the `TlBufs` accessor docs
+// below).
 struct TlBufs {
     final_path_buf: PathBuffer,
     ssh_path_buf: PathBuffer,
@@ -38,22 +39,20 @@ fn tl_bufs() -> *mut TlBufs {
     // - `TL_BUFS` is thread-local `Cell<*mut TlBufs>`: no cross-thread sharing; the
     //   pointer is `Copy` so `.get()/.set()` are zero-unsafe. The payload itself is a
     //   leaked heap alloc (lazy-init below), so the `*mut` stays valid for thread life.
-    // - Zig's `bun.ThreadlocalBuffers(T).get()` returns `*T` (a freely-aliasing raw
-    //   ptr), and `&tl_bufs.get().folder_name_buf` in Zig is raw-ptr field projection
-    //   that never asserts uniqueness over sibling buffers. We mirror that exactly:
-    //   this function returns `*mut TlBufs`, and call sites project a SINGLE field via
+    // - This function returns `*mut TlBufs` (a freely-aliasing raw ptr) and never
+    //   asserts uniqueness over sibling buffers: call sites project a SINGLE field via
     //   raw-ptr place expr `unsafe { &mut (*tl_bufs()).<field> }` so only that one
     //   field is retagged Unique under Stacked Borrows.
-    // - This is load-bearing: per the .zig spec callers (PackageManagerTask.zig:179,206),
-    //   `try_https`/`try_ssh` return a slice into `final_path_buf`/`ssh_path_buf` which
-    //   is then passed straight into `download(..., url, ...)`. `download` itself
+    // - This is load-bearing: `try_https`/`try_ssh` return a slice into
+    //   `final_path_buf`/`ssh_path_buf` which is then passed straight into
+    //   `download(..., url, ...)`. `download` itself
     //   borrows `folder_name_buf`. Materializing `&mut TlBufs` over the WHOLE struct
     //   here would create a fresh Unique tag that invalidates the live `url` slice — UB.
     //   The invariant is therefore disjoint-FIELD access, not whole-struct uniqueness.
     // - The raw pointer is valid for the lifetime of the current thread (thread-local
     //   outlives all in-thread borrows; `TlBufs` has no `Drop`). Callers reborrow into
     //   a raw `*mut PathBuffer` per field as a deliberate escape hatch so
-    //   `try_ssh`/`try_https` can return slices into the buffer, mirroring the Zig API.
+    //   `try_ssh`/`try_https` can return slices into the buffer.
     //   Callers must not retain a slice into a given field across a subsequent reborrow
     //   of that SAME field.
     TL_BUFS.with(|c| {
@@ -125,7 +124,6 @@ impl SloppyGlobalGitConfig {
         let config_file_path = bun_paths::resolve_path::join_abs_string_buf_z::<
             bun_paths::platform::Auto,
         >(home_dir, &mut config_file_path_buf, &[b".gitconfig"]);
-        // PERF(port): was stack-fallback alloc (4096)
         // MOVE_DOWN: `File::toSource` lives in `bun_logger` (T1→T2 cyclebreak).
         let Ok(source) = bun_ast::to_source(
             config_file_path,
@@ -138,7 +136,7 @@ impl SloppyGlobalGitConfig {
         let mut remaining = strings::split(source.contents(), b"\n");
         let mut found_askpass = false;
         let mut found_ssh_command = false;
-        let mut in_core = false; // Zig: `@"[core]"`
+        let mut in_core = false;
         while let Some(line_) = remaining.next() {
             if found_askpass && found_ssh_command {
                 break;
@@ -230,23 +228,21 @@ pub(crate) struct SharedEnv {
     env: Option<bun_dotenv::Map>,
 }
 
-// PORT NOTE: Zig's `pub var shared_env` is a process-global anon-struct whose
-// `get()` lazily clones `other.map` once and returns the `DotEnv.Map` handle by
-// value (Zig struct copy — both copies alias the same backing storage). Rust's
-// `Map` owns its storage and is not `Copy`, so we hand out a `&'static Map` into
-// the global instead; callers (`GitCloneRequest.env`, `GitCheckoutRequest.env`)
-// store the reference. The map is written exactly once on first call from the
-// main install thread and never freed, matching Zig's lifetime.
-// PORTING.md §Global mutable state: lazy-init on the install main thread,
-// then `&'static`-read from worker threads. RacyCell — the install enqueue
-// path is single-threaded at the write point (Zig parity).
+// Process-global env map. `get()` lazily clones `other.map` once; `Map` owns
+// its storage and is not `Copy`, so we hand out a `&'static Map` into the
+// global; callers (`GitCloneRequest.env`, `GitCheckoutRequest.env`) store the
+// reference. The map is written exactly once on first call from the main
+// install thread and never freed.
+// Lazy-init on the install main thread, then `&'static`-read from worker
+// threads. RacyCell — the install enqueue path is single-threaded at the
+// write point.
 pub(crate) static SHARED_ENV: bun_core::RacyCell<SharedEnv> =
     bun_core::RacyCell::new(SharedEnv { env: None });
 
 impl SharedEnv {
     pub(crate) fn get(other: &mut bun_dotenv::Loader) -> &'static bun_dotenv::Map {
         // SAFETY: `SHARED_ENV` is only initialised from the main install thread
-        // during enqueue (single-threaded at that point in Zig too). Once
+        // during enqueue (single-threaded at that point). Once
         // `env` is `Some` it is never reassigned, so the returned `&'static`
         // remains valid for the program lifetime.
         unsafe {
@@ -284,7 +280,7 @@ impl SharedEnv {
     }
 }
 
-/// Zig: `Repository.Hosts` (a `ComptimeStringMap`). Length-gated match beats
+/// Length-gated match beats
 /// `phf::Map` for 3 entries — phf hashes the full key + does a confirming
 /// memcmp; this rejects on a single `usize` compare for everything that isn't
 /// 6 or 9 bytes (the common case: real hostnames like `git.company.io`).
@@ -365,19 +361,15 @@ pub trait RepositoryExt: Sized {
     ) -> Result<ExtractData, Error>;
 }
 
-/// Zig: `Repository.exec` (private associated fn). Lifted to a module-level
-/// free fn because trait methods cannot be private; called only from this
-/// file's `download`/`find_commit`/`checkout`.
+/// A module-level free fn because trait methods cannot be private; called only
+/// from this file's `download`/`find_commit`/`checkout`.
 fn exec(env: &bun_dotenv::Map, argv: &[&[u8]]) -> Result<Vec<u8>, Error> {
-    // PORT NOTE: Zig passed `DotEnv.Map` by struct-copy (shallow). Rust's
     // `Map` is move-only; clone via `clone_with_allocator` so callers can
     // hand us a shared `&Map` (matches `PackageManagerTask` call sites).
     let mut env = bun_core::handle_oom(env.clone_with_allocator());
     let std_map = env.std_env_map()?;
-    // TODO(port): narrow error set
 
-    // Zig used `std.process.Child.run` on both Windows and POSIX (identical
-    // arms). `bun_spawn::run` is its Rust port — POSIX argv/envp marshalling
+    // `bun_spawn::run` does POSIX argv/envp marshalling
     // + `process::sync::spawn`. On Windows it supplies the thread's
     // `MiniEventLoop` (idempotent `init_global` — same handle PackageManager
     // already published) so `spawn_process_windows` has a real `uv_loop_t*`.
@@ -491,8 +483,7 @@ impl RepositoryExt for Repository {
         string_buf: &[u8],
         dep: &Install::Dependency,
     ) -> Vec<u8> {
-        // PORT NOTE: Zig took `*Lockfile` and indexed `buffers.dependencies[dep_id]`
-        // / `string_bytes`. Callers (`parse_with_json`) hold a split `StringBuilder`
+        // Callers (`parse_with_json`) hold a split `StringBuilder`
         // borrow on `string_bytes`, so accept the two pieces directly.
         let buf = string_buf;
         let repo_name = repository.repo;
@@ -558,7 +549,8 @@ impl RepositoryExt for Repository {
     }
 
     fn try_ssh(url: &[u8]) -> Option<&[u8]> {
-        // TODO(port): lifetime — returns slice into thread-local buffer; see tl_bufs().
+        // May return a slice into the thread-local `ssh_path_buf` (see `tl_bufs()`);
+        // it is only valid until the next `try_ssh` call on this thread.
         let ssh_path_buf = TlBufs::ssh_path_buf();
         // Do not cast explicit http(s) URLs to SSH
         if url.starts_with(b"http") {
@@ -628,7 +620,9 @@ impl RepositoryExt for Repository {
     }
 
     fn try_https(url: &[u8]) -> Option<&[u8]> {
-        // TODO(port): lifetime — returns slice into thread-local buffer; see tl_bufs().
+        // May return a slice into the thread-local `final_path_buf` (see `tl_bufs()`);
+        // it is only valid until the next use of `TlBufs::final_path_buf()` on this
+        // thread (another `try_https` call, or `checkout`'s `get_fd_path`).
         let final_path_buf = TlBufs::final_path_buf();
         if url.starts_with(b"http") {
             return Some(url);
@@ -687,8 +681,9 @@ impl RepositoryExt for Repository {
         bun_analytics::features::git_dependencies
             .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         // Per-field accessor — retags only `folder_name_buf`, leaving any live
-        // shared borrow of `final_path_buf`/`ssh_path_buf` (the `url` argument,
-        // per PackageManagerTask.zig:179,206) valid under Stacked Borrows.
+        // shared borrow of `final_path_buf`/`ssh_path_buf` (the `url` argument
+        // handed over by `try_https`/`try_ssh` callers) valid under Stacked
+        // Borrows.
         let folder_name_buf = TlBufs::folder_name_buf();
         let folder_name = {
             use std::io::Write;
@@ -700,7 +695,6 @@ impl RepositoryExt for Repository {
                 bun_core::fmt::hex_int_lower::<16>(task_id.get())
             )
             .map_err(|_| err!("NoSpaceLeft"))?;
-            // TODO(port): narrow error set
             let written = total - cursor.len() - 1;
             bun_core::ZStr::from_buf(&folder_name_buf[..], written)
         };
@@ -779,7 +773,6 @@ impl RepositoryExt for Repository {
                 bun_core::fmt::hex_int_lower::<16>(task_id.get())
             )
             .map_err(|_| err!("NoSpaceLeft"))?;
-            // TODO(port): narrow error set
             let written = total - cursor.len();
             &folder_name_buf[..written]
         };
@@ -825,9 +818,8 @@ impl RepositoryExt for Repository {
             }
         };
 
+        // The trimmed bytes are copied so the return value owns its storage.
         Ok(strings::trim(&out, b" \t\r\n").to_vec())
-        // TODO(port): Zig returned a slice into `exec`'s allocation without trimming
-        // in-place; here we own `out` and copy the trimmed slice. Revisit ownership.
     }
 
     fn checkout(
@@ -944,7 +936,7 @@ impl RepositoryExt for Repository {
                         if git_tag.write_all(resolved).is_err() {
                             let _ = dir.delete_file_z(bun_core::zstr!(".bun-tag"));
                         }
-                        let _ = git_tag.close(); // close error is non-actionable (Zig parity: discarded)
+                        let _ = git_tag.close(); // close error is non-actionable
                     }
                 }
 
@@ -992,18 +984,17 @@ impl RepositoryExt for Repository {
                         err.name()
                     ),
                 );
-                let _ = json_file.close(); // close error is non-actionable (Zig parity: discarded)
+                let _ = json_file.close(); // close error is non-actionable
                 package_dir.close();
                 return Err(err!("InstallFailed"));
             }
         };
 
-        // Zig defers `json_file.close()` / `package_dir.close()` across the
-        // `try ...append(json_path)` below. `json_path` lives in the thread-local
+        // `json_path` lives in the thread-local
         // `json_path_buf` (not in `json_file`), and `json_buf` is an owned alloc,
         // so both fds are dead here — close before the fallible append so the
         // `?`-propagation path doesn't leak them.
-        let _ = json_file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = json_file.close(); // close error is non-actionable
         package_dir.close();
 
         let ret_json_path = bun_resolver::fs::FileSystem::instance()
@@ -1109,5 +1100,3 @@ impl<'a> fmt::Display for Formatter<'a> {
         Ok(())
     }
 }
-
-// ported from: src/install/repository.zig
diff --git a/src/install/resolution.rs b/src/install/resolution.rs
index 07f14a45a7b..dcf72fa421f 100644
--- a/src/install/resolution.rs
+++ b/src/install/resolution.rs
@@ -4,10 +4,9 @@ use core::fmt;
 use bstr::BStr;
 
 use bun_core::fmt::{PathFormatOptions, PathSep, fmt_path_u8 as fmt_path};
+use bun_core::strings;
 use bun_semver as semver;
 use bun_semver::String;
-// PORT NOTE: Zig `String.Buf` → `bun_semver::string::Buf<'_>`.
-use bun_core::strings;
 use bun_semver::string::Buf as StringBuf;
 use bun_semver::version::VersionInt;
 
@@ -72,7 +71,7 @@ impl<SemverInt: VersionInt> ResolutionType<SemverInt> {
         value: Value { uninitialized: () },
     };
 
-    /// Use like Resolution.init(.{ .npm = VersionedURL{ ... } })
+    /// Construct from a tagged value, e.g. `Resolution::init(TaggedValue::Npm(...))`.
     #[inline]
     pub fn init(value: TaggedValue<SemverInt>) -> Self {
         Self {
@@ -82,13 +81,13 @@ impl<SemverInt: VersionInt> ResolutionType<SemverInt> {
         }
     }
 
-    /// Port of `Resolution.init(.{ .root = {} })` — convenience constructor.
+    /// Convenience constructor for a root resolution.
     #[inline]
     pub fn init_root() -> Self {
         Self::init(TaggedValue::Root)
     }
 
-    /// Port of `Resolution.init(.{ .symlink = s })` — convenience constructor.
+    /// Convenience constructor for a symlink resolution.
     #[inline]
     pub fn init_symlink(s: String) -> Self {
         Self::init(TaggedValue::Symlink(s))
@@ -283,7 +282,7 @@ impl<SemverInt: VersionInt> ResolutionType<SemverInt> {
             }
             dependency::VersionTag::Npm => {
                 let version_literal = string_buf.append(res_str)?;
-                // PORT NOTE: this fn returns `Resolution` (= `ResolutionType<u64>`),
+                // This fn returns `Resolution` (= `ResolutionType<u64>`),
                 // not `Self`, so parse at `u64` regardless of the impl's SemverInt.
                 let parsed =
                     semver::Version::parse(version_literal.sliced(string_buf.bytes.as_slice()));
@@ -363,8 +362,7 @@ impl<SemverInt: VersionInt> ResolutionType<SemverInt> {
     }
 
     /// Named `clone_into` (not `clone`) to avoid shadowing `Clone::clone` now
-    /// that `ResolutionType: Clone + Copy`. Mirrors Zig
-    /// `Resolution.clone(buf, Builder, builder)`.
+    /// that `ResolutionType: Clone + Copy`.
     pub fn clone_into<B>(&self, buf: &[u8], builder: &mut B) -> Self
     where
         B: StringBuilderLike,
@@ -494,9 +492,8 @@ impl<SemverInt: VersionInt> ResolutionType<SemverInt> {
     }
 }
 
-// PORT NOTE: the duck-typed `Builder` Zig comptime param maps to the
-// `bun_semver::StringBuilder` trait (`count` + `append<T>`); local alias kept
-// so dependents that named `resolution::StringBuilderLike` still resolve.
+// Local alias for the `bun_semver::StringBuilder` trait (`count` + `append<T>`),
+// kept so dependents that named `resolution::StringBuilderLike` still resolve.
 pub use bun_semver::StringBuilder as StringBuilderLike;
 
 pub struct StorePathFormatter<'a, SemverInt: VersionInt> {
@@ -552,14 +549,12 @@ pub struct URLFormatter<'a, SemverInt: VersionInt> {
 }
 
 impl<'a, SemverInt: VersionInt> URLFormatter<'a, SemverInt> {
-    /// Byte-exact port of Zig `URLFormatter.format` (`writer.writeAll` / `{s}`).
-    ///
     /// Prefer this over the `Display` impl whenever the output is persisted to
     /// disk (yarn.lock, lockfile JSON): `core::fmt::Display` routes through
     /// `&str` and the `BStr` adapter is *lossy* on non-UTF-8 bytes (a Linux
     /// folder/tarball path under a Latin-1 directory would emit U+FFFD instead
-    /// of the original byte). `write_to` mirrors Zig's `writeAll(slice)` and
-    /// pushes the lockfile string-buffer bytes through unchanged.
+    /// of the original byte). `write_to` pushes the lockfile string-buffer
+    /// bytes through unchanged.
     pub(crate) fn write_to<W>(&self, writer: &mut W) -> Result<(), bun_core::Error>
     where
         W: bun_core::io::Write + ?Sized,
@@ -581,7 +576,7 @@ impl<'a, SemverInt: VersionInt> URLFormatter<'a, SemverInt> {
             ),
             Tag::Folder => writer.write_all(res.folder().slice(buf)),
             Tag::RemoteTarball => writer.write_all(res.remote_tarball().slice(buf)),
-            // PORT NOTE: `Repository::format_as` still goes through `fmt::Write`
+            // `Repository::format_as` still goes through `fmt::Write`
             // (and uses `BStr` internally); git/github URLs are ASCII in
             // practice so byte-exactness is preserved. A follow-up shard owns
             // `repository.rs` if that ever needs a byte-level path too.
@@ -604,7 +599,7 @@ impl<'a, SemverInt: VersionInt> URLFormatter<'a, SemverInt> {
     }
 }
 
-// PORT NOTE: kept for the ~dozen call sites that interpolate into
+// Kept for the ~dozen call sites that interpolate into
 // `format_args!` for terminal/log output (Output::err, pretty_errorln, …),
 // where lossy U+FFFD on the rare non-UTF-8 byte is acceptable. File-producing
 // callers MUST use [`URLFormatter::write_to`] instead.
@@ -653,10 +648,9 @@ pub struct Formatter<'a, SemverInt: VersionInt> {
 }
 
 impl<'a, SemverInt: VersionInt> Formatter<'a, SemverInt> {
-    /// Byte-exact port of Zig `Formatter.format`. See [`URLFormatter::write_to`]
-    /// for rationale — `Display` is lossy on non-UTF-8 path bytes; this writes
-    /// the lockfile string-buffer slices verbatim via `write_all`, matching
-    /// Zig's `writer.writeAll` / `{s}`.
+    /// See [`URLFormatter::write_to`] for rationale — `Display` is lossy on
+    /// non-UTF-8 path bytes; this writes the lockfile string-buffer slices
+    /// verbatim via `write_all`.
     pub fn write_to<W>(&self, writer: &mut W) -> Result<(), bun_core::Error>
     where
         W: bun_core::io::Write + ?Sized,
@@ -727,7 +721,7 @@ impl<'a, SemverInt: VersionInt> Formatter<'a, SemverInt> {
     }
 }
 
-// PORT NOTE: kept for terminal/log call sites (Output::err, tree printer, …).
+// Kept for terminal/log call sites (Output::err, tree printer, …).
 // Persisted-to-disk callers (Yarn.rs) MUST use [`Formatter::write_to`].
 impl<'a, SemverInt: VersionInt> fmt::Display for Formatter<'a, SemverInt> {
     fn fmt(&self, writer: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -878,9 +872,9 @@ pub(crate) fn value_init<SemverInt: VersionInt>(field: TaggedValue<SemverInt>) -
     value
 }
 
-// Zig `enum(u8) { ..., _ }` is non-exhaustive — values outside the named set are
-// valid (lockfile bytes may carry unknown tags, and every `switch` has an `else`
-// arm). A `#[repr(u8)] enum` would be UB for such values, so Tag is a transparent
+// Tag is non-exhaustive — values outside the named set are valid (lockfile
+// bytes may carry unknown tags, and every match has a fallback arm).
+// A `#[repr(u8)] enum` would be UB for such values, so Tag is a transparent
 // u8 newtype with associated consts. Const patterns (structural `PartialEq`) keep
 // `match tag { Tag::Npm => ... }` working, and the `_` arms in callers stay live.
 #[repr(transparent)]
@@ -946,8 +940,8 @@ impl Tag {
             || self == Tag::Github
     }
 
-    /// Mirrors `bun.tagName(Tag, tag)` — returns the Zig snake_case tag name,
-    /// or `None` for an unnamed (non-exhaustive) value.
+    /// Returns the snake_case tag name, or `None` for an unnamed
+    /// (non-exhaustive) value.
     pub fn name(self) -> Option<&'static str> {
         Some(match self {
             Tag::Uninitialized => "uninitialized",
@@ -991,5 +985,3 @@ pub enum FromPnpmLockfileError {
 bun_core::oom_from_alloc!(FromPnpmLockfileError);
 
 bun_core::named_error_set!(FromPnpmLockfileError);
-
-// ported from: src/install/resolution.zig
diff --git a/src/install/resolvers/folder_resolver.rs b/src/install/resolvers/folder_resolver.rs
index 400afa4a925..076f1dd93c8 100644
--- a/src/install/resolvers/folder_resolver.rs
+++ b/src/install/resolvers/folder_resolver.rs
@@ -26,8 +26,7 @@ pub enum FolderResolution {
     NewPackageId(PackageID),
 }
 
-// Zig: `pub const Tag = enum { package_id, err, new_package_id };`
-// In Rust the enum discriminant serves as the tag; expose an alias for parity.
+// The enum discriminant serves as the tag; expose an alias for it.
 pub type Tag = core::mem::Discriminant<FolderResolution>;
 
 pub(crate) struct PackageWorkspaceSearchPathFormatter<'a> {
@@ -39,10 +38,8 @@ pub(crate) struct PackageWorkspaceSearchPathFormatter<'a> {
 impl<'a> fmt::Display for PackageWorkspaceSearchPathFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut joined = [0u8; MAX_PATH_BYTES + 2];
-        // Zig: `getPtr(@truncate(String.Builder.stringHash(...)))` — key type is
-        // `PackageNameHash` (u64), so the @truncate is identity.
         // Caller constructs this formatter only when
-        // `self.version.tag == .workspace` (Zig: `formatter.version.value.workspace`).
+        // `self.version.tag == .workspace`.
         let workspace = self.version.workspace();
         let str_to_use = self
             .manager
@@ -76,8 +73,7 @@ impl<'a> fmt::Display for PackageWorkspaceSearchPathFormatter<'a> {
             let quoted = QuotedFormatter { text: paths.rel };
             fmt::Display::fmt(&quoted, f)
         } else {
-            // Zig: `writer.writeAll(paths.rel)` writes raw bytes. `fmt::Formatter`
-            // only accepts `&str`, so non-UTF-8 path bytes are emitted lossily
+            // `fmt::Formatter` only accepts `&str`, so non-UTF-8 path bytes are emitted lossily
             // (U+FFFD) via `bstr::BStr`'s Display. Both current callers pass
             // `quoted = true`, so this branch is unreached today; if a future
             // caller needs byte-exact output it must use an `io::Write` sink.
@@ -86,8 +82,7 @@ impl<'a> fmt::Display for PackageWorkspaceSearchPathFormatter<'a> {
     }
 }
 
-// Zig: std.HashMapUnmanaged(u64, FolderResolution, IdentityContext(u64), 80)
-// PORT NOTE: bun_collections::HashMap currently ignores the context/load-factor
+// bun_collections::HashMap currently ignores the context/load-factor
 // type params (backed by std HashMap); identity hashing is a TODO(perf).
 pub type Map = HashMap<u64, FolderResolution, IdentityContext<u64>>;
 
@@ -99,9 +94,8 @@ pub fn hash(normalized_path: &[u8]) -> u64 {
     bun_wyhash::hash(normalized_path)
 }
 
-// ── NewResolver(comptime tag: Resolution.Tag) type ────────────────────────
-// PORT NOTE: `Resolution.Tag` (Zig nested decl) is `crate::resolution::Tag`;
-// const-generic requires `#[derive(ConstParamTy)]` (already on `Tag`).
+// ── NewResolver ───────────────────────────────────────────────────────────
+// The const-generic tag requires `#[derive(ConstParamTy)]` (already on `Tag`).
 pub struct NewResolver<'a, const TAG: ResolutionTag> {
     pub folder_path: &'a [u8],
 }
@@ -120,7 +114,6 @@ impl<'a, const TAG: ResolutionTag> ResolverContext for NewResolver<'a, TAG> {
         builder: &mut StringBuilder<'_>,
         _json: &Expr,
     ) -> Result<ResolutionType<u64>, bun_core::Error> {
-        // Zig: @unionInit(Resolution.Value, @tagName(tag), builder.append(String, this.folder_path))
         let appended = builder.append::<SemverString>(self.folder_path);
         Ok(ResolutionType::<u64>::init(match TAG {
             ResolutionTag::Folder => TaggedValue::Folder(appended),
@@ -161,9 +154,8 @@ impl ResolverContext for CacheFolderResolver {
 }
 
 /// Unifies `NewResolver<TAG>` and `CacheFolderResolver` for
-/// `read_package_json_from_disk` (Zig: `comptime ResolverType: type`). The
-/// associated const `IS_WORKSPACE` replaces the
-/// `if (comptime ResolverType == WorkspaceResolver)` check.
+/// `read_package_json_from_disk`; the associated const `IS_WORKSPACE`
+/// distinguishes the workspace resolver.
 pub(crate) trait FolderResolverImpl: ResolverContext {
     const IS_WORKSPACE: bool;
 }
@@ -201,7 +193,6 @@ fn normalize_package_json_path<'a>(
         let mut tempcat = PathBuffer::uninit();
 
         tempcat[..normalized.len()].copy_from_slice(normalized);
-        // (std.fs.path.sep_str ++ "package.json")
         tempcat[normalized.len()] = SEP;
         tempcat[normalized.len() + 1..normalized.len() + PACKAGE_JSON_LEN]
             .copy_from_slice(b"package.json");
@@ -242,7 +233,7 @@ fn normalize_package_json_path<'a>(
         remain[normalized.len() + 1..normalized.len() + PACKAGE_JSON_LEN]
             .copy_from_slice(b"package.json");
         let remain_after = remain.len() - (normalized.len() + PACKAGE_JSON_LEN);
-        // PORT NOTE: reshaped for borrowck — compute abs len from remaining capacity
+        // Compute abs len from remaining capacity.
         let abs_len = joined_len - remain_after;
         abs = &joined[0..abs_len];
         // We store the folder name without package.json
@@ -265,7 +256,6 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
     abs: &ZStr,
     version: &dependency::Version,
     features: Features,
-    // PERF(port): was comptime monomorphization (features + ResolverType) — profile if hot
     resolver: &mut R,
 ) -> Result<LockfilePackage, bun_core::Error> {
     let mut body = npm::Registry::BodyPool::get();
@@ -273,8 +263,8 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
 
     let mut package: LockfilePackage = Default::default();
 
-    // PORT NOTE: Zig passed `manager.lockfile`, `manager`, `manager.log` as
-    // three separate args; Rust borrowck rejects the overlap on `&mut self`,
+    // Borrow splitting: `manager.lockfile`, `manager`, and `manager.log` are
+    // needed simultaneously; borrowck rejects the overlap on `&mut self`,
     // so split via raw pointer once here. `lockfile` and `log` are disjoint
     // fields of `PackageManager`, and `parse{,_with_json}` only reaches
     // `manager` through the `pm` argument (no re-entrant access to
@@ -293,8 +283,9 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
             bun_perf::trace(bun_perf::PerfEvent::FolderResolverReadPackageJSONFromDiskWorkspace);
 
         // SAFETY: `manager_ptr` was just derived from the live `&mut PackageManager`
-        // argument; `log` points into a separate `Log` allocation (see PORT NOTE
-        // above), so this `&mut` reborrow aliases no other live reference.
+        // argument; `log` points into a separate `Log` allocation (see the
+        // borrow-splitting comment above), so this `&mut` reborrow aliases no
+        // other live reference.
         let json = unsafe { &mut *manager_ptr }
             .workspace_package_json_cache
             .get_with_path(log, abs.as_bytes(), Default::default())
@@ -305,7 +296,7 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
         let root: Expr = json.root;
         let source: *const bun_ast::Source = &raw const json.source;
 
-        // SAFETY: see PORT NOTE above on borrow splitting.
+        // SAFETY: see the borrow-splitting comment above.
         unsafe {
             let lockfile: *mut Lockfile = &raw mut *(*manager_ptr).lockfile;
             package.parse_with_json::<R>(
@@ -326,8 +317,6 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
             let file = File::openat(Fd::cwd(), abs.as_bytes(), O::RDONLY, 0)?;
             // defer file.close()
             body.reset();
-            // PORT NOTE: toManaged/moveToUnmanaged dance is a no-op in Rust
-            // (Vec owns its allocator).
             let read_result = file
                 .read_to_end_with_array_list(&mut body.list, bun_sys::SizeHint::ProbablySmall)
                 .map(|_| ());
@@ -337,7 +326,7 @@ fn read_package_json_from_disk<R: FolderResolverImpl>(
             bun_ast::Source::init_path_string(abs.as_bytes(), body.list.as_slice())
         };
 
-        // SAFETY: see PORT NOTE above on borrow splitting.
+        // SAFETY: see the borrow-splitting comment above.
         unsafe {
             let lockfile: *mut Lockfile = &raw mut *(*manager_ptr).lockfile;
             package.parse::<R>(
@@ -401,13 +390,11 @@ pub fn get_or_put(
     // replace before getting hash. rel may or may not be contained in abs
     #[cfg(windows)]
     let (abs, rel): (&ZStr, &[u8]) = {
-        // Zig (folder_resolver.zig:249-252) does `@constCast(abs)` /
-        // `@constCast(rel)` and mutates in place — well-defined in Zig, which
-        // has no provenance-based aliasing model. In Rust, writing through
-        // `(&ZStr).as_ptr().cast_mut()` / `(&[u8]).as_ptr().cast_mut()` is UB
-        // under Stacked/Tree Borrows: those pointers carry read-only
-        // provenance, and the optimizer may assume `abs`'s bytes are
-        // unchanged when computing `hash(abs.as_bytes())` below.
+        // Writing in place through `(&ZStr).as_ptr().cast_mut()` /
+        // `(&[u8]).as_ptr().cast_mut()` would be UB under Stacked/Tree
+        // Borrows: those pointers carry read-only provenance, and the
+        // optimizer may assume `abs`'s bytes are unchanged when computing
+        // `hash(abs.as_bytes())` below.
         //
         // Instead: capture lengths, let the shared borrows of `joined` die,
         // then take a fresh `&mut joined[..abs_len]` (write provenance) and
@@ -430,8 +417,7 @@ pub fn get_or_put(
     };
     let abs_hash = hash(abs.as_bytes());
 
-    // PORT NOTE: reshaped for borrowck — Zig used getOrPut to reserve the slot before reading
-    // package.json; here we check first, compute, then insert, because read_package_json_from_disk
+    // Check first, compute, then insert, because read_package_json_from_disk
     // needs &mut manager.
     if let Some(existing) = manager.folders.get(&abs_hash) {
         return *existing;
@@ -479,7 +465,7 @@ pub fn get_or_put(
             let mut resolver = CacheFolderResolver {
                 // `GlobalOrRelative::CacheFolder` is only passed by
                 // `PackageManagerResolution` with a `version.tag == .npm`
-                // dependency (Zig: `version.value.npm.version.toVersion()`).
+                // dependency.
                 version: version.npm().version.to_version(),
             };
             break 'cache_folder read_package_json_from_disk(
@@ -511,5 +497,3 @@ pub fn get_or_put(
         .insert(abs_hash, FolderResolution::PackageId(package.meta.id));
     FolderResolution::NewPackageId(package.meta.id)
 }
-
-// ported from: src/install/resolvers/folder_resolver.zig
diff --git a/src/install/versioned_url.rs b/src/install/versioned_url.rs
index b0676500c34..69b6725021b 100644
--- a/src/install/versioned_url.rs
+++ b/src/install/versioned_url.rs
@@ -4,5 +4,3 @@
 // `crate::versioned_url::*` paths keep resolving.
 
 pub use bun_install_types::resolver_hooks::{OldV2VersionedURL, VersionedURL, VersionedURLType};
-
-// ported from: src/install/versioned_url.zig
diff --git a/src/install/windows-shim/BinLinkingShim.rs b/src/install/windows-shim/BinLinkingShim.rs
index 90dcd93b5d8..ec31524402c 100644
--- a/src/install/windows-shim/BinLinkingShim.rs
+++ b/src/install/windows-shim/BinLinkingShim.rs
@@ -9,7 +9,7 @@
 //! [WSTR:program][u16:0][WSTR:args][u32:bin_path_byte_len][u32:arg_byte_len]
 //! - args always ends with a trailing space
 //!
-//! See 'bun_shim_impl.zig' for more details on how this file is consumed.
+//! See `bun_shim_impl.rs` for more details on how this file is consumed.
 //!
 //! ## `shim_standalone` feature
 //!
@@ -22,8 +22,8 @@
 /// Random numbers are chosen for validation purposes
 /// These arbitrary numbers will probably not show up in the other fields.
 /// This will reveal off-by-one mistakes.
-// Zig: `enum(u13)` non-exhaustive (`_`). Rust has no `u13`, and the `_` makes it
-// open-ended, so model as a transparent u16 newtype holding a 13-bit value.
+// The encoding is an open-ended 13-bit value, so model it as a transparent u16
+// newtype rather than an exhaustive enum.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct VersionFlag(u16);
@@ -34,12 +34,17 @@ impl VersionFlag {
     /// Fixed bugs where passing arguments did not always work.
     pub(crate) const V5: VersionFlag = VersionFlag(5478);
 
-    /// std.math.maxInt(u13)
+    /// Maximum 13-bit value.
     const MAX: VersionFlag = VersionFlag((1u16 << 13) - 1);
+
+    #[inline]
+    pub const fn bits(self) -> u16 {
+        self.0
+    }
 }
 
-// Zig: `packed struct(u16)` with mixed bool + u13 fields → `#[repr(transparent)]`
-// newtype with manual shift accessors matching Zig field order (LSB first).
+// Packed u16 bitfield (three bools + a 13-bit version tag): `#[repr(transparent)]`
+// newtype with manual shift accessors (LSB first).
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Flags(u16);
@@ -144,14 +149,13 @@ mod host {
     /// has produced the PE — but any actual *use* of the data still fails loudly.
     /// Call this from every site that writes `EMBEDDED_EXECUTABLE_DATA` to disk.
     ///
-    /// PORT NOTE: this MUST be a process exit, not `panic!()`. The only caller
+    /// IMPORTANT: this MUST be a process exit, not `panic!()`. The only caller
     /// (`bin::Linker::create_windows_shim`) runs on the parallel-install thread
     /// pool; the workspace is `panic = "unwind"`, so a `panic!()` here unwinds
     /// and kills the worker thread — the main install loop's pending-task counter
     /// never decrements and `bun install` hangs until the CI 180s timeout, then
-    /// retries forever. Zig has no equivalent guard (build.zig provides the embed
-    /// via `addAnonymousImport` so it can never be empty); until the Rust port
-    /// wires the standalone-shim build step, fail the *process* fast instead.
+    /// retries forever. Until the build wires the standalone-shim build step,
+    /// fail the *process* fast instead.
     #[inline]
     #[track_caller]
     pub fn embedded_executable_data() -> &'static [u8] {
@@ -173,10 +177,8 @@ mod host {
         RunWithPowershell,
     }
 
-    // Zig used `std.StaticStringMap` keyed by the UTF-16LE *byte* reinterpretation of
-    // each extension (via `wU8`). Here we match directly on the `&[u16]` extension
-    // using `bun_core::w!` literals — semantically identical, drops the byte cast.
-    // PERF(port): was comptime StaticStringMap (perfect hash) — profile if hot.
+    // Match directly on the `&[u16]` extension using `bun_core::w!` literals.
+    // PERF: a precomputed perfect-hash table may be faster — profile if hot.
     fn bun_extensions_get(ext: &[u16]) -> Option<ExtensionType> {
         use ExtensionType::*;
         macro_rules! w {
@@ -203,28 +205,24 @@ mod host {
 
     #[derive(Copy, Clone)]
     pub struct Shebang<'a> {
-        // PORT NOTE: borrows into the caller's input buffer (see `parse` doc)
+        // Borrows into the caller's input buffer (see `parse` doc).
         pub launcher: &'a [u8],
         pub utf16_len: u32,
         pub is_node_or_bun: bool,
     }
 
     impl<'a> Shebang<'a> {
-        pub fn init(
-            launcher: &'a [u8],
-            is_node_or_bun: bool,
-        ) -> Result<Shebang<'a>, bun_core::Error> {
-            // TODO(port): narrow error set (Zig inferred empty error set here)
-            Ok(Shebang {
+        pub fn init(launcher: &'a [u8], is_node_or_bun: bool) -> Shebang<'a> {
+            Shebang {
                 launcher,
                 // TODO: what if this is invalid utf8?
                 utf16_len: u32::try_from(simdutf::length::utf16::from::utf8(launcher))
                     .expect("int cast"),
                 is_node_or_bun,
-            })
+            }
         }
 
-        /// std.fs.path.extension but utf16
+        /// Returns the file extension (including the dot) of a UTF-16 path.
         pub fn extension_w(path: &[u16]) -> &[u16] {
             let filename = strings::basename_windows(path);
             let Some(index) = filename.iter().rposition(|&c| c == b'.' as u16) else {
@@ -239,7 +237,7 @@ mod host {
         pub fn parse_from_bin_path(bin_path: &[u16]) -> Option<Shebang<'static>> {
             if let Some(i) = bun_extensions_get(Self::extension_w(bin_path)) {
                 return Some(match i {
-                    // `comptime Shebang.init(...) catch unreachable` → const-evaluated; the
+                    // Const-evaluated; the
                     // values below are the simdutf utf16 lengths of pure-ASCII literals
                     // (== byte length).
                     ExtensionType::RunWithBun => Shebang {
@@ -298,8 +296,8 @@ mod host {
                 break 'line &contents[2..line_i];
             };
 
-            // std.mem.tokenizeScalar(u8, line, ' ') — manual port preserving `.rest()` semantics.
-            // PORT NOTE: reshaped — Rust split() iterator has no `.rest()`.
+            // Manual space tokenizer preserving `.rest()` semantics.
+            // Reshaped — Rust split() iterator has no `.rest()`.
             let mut idx: usize = 0;
             // skip leading delimiters, then take token
             while idx < line.len() && line[idx] == b' ' {
@@ -331,10 +329,10 @@ mod host {
                 }
                 let is_node_or_bun =
                     eql_comptime(program, b"bun") || eql_comptime(program, b"node");
-                return Shebang::init(rest, is_node_or_bun).map(Some);
+                return Ok(Some(Shebang::init(rest, is_node_or_bun)));
             }
 
-            Shebang::init(line, false).map(Some)
+            Ok(Some(Shebang::init(line, false)))
         }
 
         pub fn encoded_length(&self) -> usize {
@@ -362,14 +360,16 @@ mod host {
             l
         }
 
-        /// The buffer must be exactly the correct length given by encoded_length
+        /// The buffer must be exactly the correct length given by encoded_length.
+        ///
+        /// The `Result` is kept only because the caller (`bin.rs`) treats it as
+        /// a fallible API — this always returns `Ok(())`.
         pub fn encode_into(&self, buf: &mut [u8]) -> Result<(), bun_core::Error> {
-            // TODO(port): narrow error set
             debug_assert!(buf.len() == self.encoded_length());
             debug_assert!(self.bin_path[0] != b'/' as u16);
 
-            // Zig used `@alignCast` here. `bytemuck::cast_slice_mut` performs the same
-            // runtime alignment + size-multiple check and panics on mismatch — no
+            // `bytemuck::cast_slice_mut` performs a runtime alignment +
+            // size-multiple check and panics on mismatch — no
             // `unsafe` needed. (The sole caller, `bin.rs`, passes a stack `[u8; 65536]`
             // whose Rust-guaranteed alignment is 1; it should be changed to a `[u16; N]`
             // buffer to make alignment a compile-time guarantee — tracked separately.)
@@ -413,7 +413,7 @@ mod host {
                 wbuf = &mut wbuf[1..];
 
                 // SAFETY: wbuf has at least 4 u16s (= 2 u32s) remaining per encoded_length();
-                // Zig wrote via `*align(1) u32` — use unaligned writes.
+                // the buffer is only 2-byte aligned, so use unaligned writes.
                 unsafe {
                     (wbuf.as_mut_ptr().cast::<u32>())
                         .write_unaligned(u32::try_from(self.bin_path.len() * 2).expect("int cast"));
@@ -448,8 +448,8 @@ mod host {
         if input.len() < FLAGS_SIZE + 2 * size_of::<u32>() + 8 {
             return None;
         }
-        // Zig read via `*align(1) const Flags`; bounds checked above so the trailing
-        // 2-byte slice is in range. `pod_read_unaligned` is the safe equivalent of
+        // Bounds checked above so the trailing 2-byte slice is in range.
+        // `pod_read_unaligned` is the safe equivalent of
         // `ptr.cast::<u16>().read_unaligned()` over a `&[u8]`.
         let flags = Flags::from_bits(bytemuck::pod_read_unaligned::<u16>(
             &input[input.len() - FLAGS_SIZE..],
@@ -488,5 +488,3 @@ mod host {
         })
     }
 } // mod host
-
-// ported from: src/install/windows-shim/BinLinkingShim.zig
diff --git a/src/install/windows-shim/bun_shim_impl.rs b/src/install/windows-shim/bun_shim_impl.rs
index 86b34592da6..e7add1394ce 100644
--- a/src/install/windows-shim/bun_shim_impl.rs
+++ b/src/install/windows-shim/bun_shim_impl.rs
@@ -1,5 +1,3 @@
-//! TODO(port): correct this documentation comment post-rust port
-//!
 //! This program is a shim for node_modules/.bin scripts.
 //!
 //! This is needed because:
@@ -10,7 +8,7 @@
 //! which is a HUGE dx win for developers.
 //!
 //! The approach implemented is a `.bunx` file which sits right next to the renamed
-//! launcher exe. We read that (see BinLinkingShim.zig for the creation of this file)
+//! launcher exe. We read that (see `BinLinkingShim.rs` for the creation of this file)
 //! and then we call NtCreateProcess to spawn the correct child process.
 //!
 //! Every attempt possible to make this file as minimal as possible has been made.
@@ -36,8 +34,10 @@
 //! Prior Art:
 //! - https://github.com/ScoopInstaller/Shim/blob/master/src/shim.cs
 //!
-//! The compiled binary is 13312 bytes and is `@embedFile`d into Bun itself.
-//! When this file is updated, the new binary should be compiled and BinLinkingShim.VersionFlag.current should be updated.
+//! This file is compiled twice: into bun.exe (for the bunx fast paths below) and as
+//! the standalone `bun_shim_impl.exe` PE (see `main.rs` / the `shim_standalone`
+//! feature), which is then `include_bytes!`-embedded into Bun by `BinLinkingShim.rs`.
+//! When the encoding changes, `BinLinkingShim::VersionFlag::CURRENT` should be bumped.
 //!
 //! Theorized and written by @paperclover during one of the most entranced all-nighters of her life.
 
@@ -50,7 +50,7 @@ use core::mem::{MaybeUninit, size_of};
 
 // Standalone PE: depend ONLY on `bun_windows_sys` (leaf, no native C, no
 // `#[no_mangle]` exports) so the link has no libuv/simdutf/ICU roots and the
-// binary stays tiny — matching Zig's freestanding build. `crate::compat`
+// binary stays tiny. `crate::compat`
 // re-exports `bun_windows_sys::*` and locally declares the few items
 // (`CreateProcessW`, `STARTUPINFOW`, `TEB`/`teb()`, …) that otherwise live in
 // `bun_sys::windows`. The local `bun_core`/`bun_str` shadows bring
@@ -70,8 +70,8 @@ use super::_bin_linking_shim::Flags;
 
 const DBG: bool = cfg!(debug_assertions);
 
-/// In Zig: `@import("root") == @This()` — true when this module IS the binary root
-/// (the standalone `bun_shim_impl.exe`), false when compiled into bun.exe.
+/// True when this module IS the binary root (the standalone
+/// `bun_shim_impl.exe`), false when compiled into bun.exe.
 const IS_STANDALONE: bool = cfg!(feature = "shim_standalone");
 
 #[cfg(not(feature = "shim_standalone"))]
@@ -103,7 +103,8 @@ mod nt {
         pub(super) safe fn NtClose(Handle: HANDLE) -> Status;
     }
 
-    // TODO(port): move to <install>_sys (or bun_sys::windows::ntdll)
+    // Declared locally (not in `bun_sys::windows::ntdll`) so the standalone PE
+    // build, whose `w` alias is `crate::compat`, needs no extra re-export.
     // SAFETY: ntdll syscalls; signatures match WDK headers. Kept `unsafe fn`
     // (not `safe fn`) because both write through caller-supplied out-pointers
     // (`IoStatusBlock`, `Buffer`) — validity is a genuine caller precondition.
@@ -112,10 +113,10 @@ mod nt {
         #[link_name = "NtReadFile"]
         pub(super) fn NtReadFile(
             FileHandle: HANDLE, // [in]
-            // PORT NOTE: Zig `?w.HANDLE` is pointer-sized via null-niche. Rust
-            // `Option<*mut c_void>` is NOT (raw pointers can already be null →
-            // no niche → 16-byte tagged enum, passed by-reference under Win64
-            // ABI). Use a plain HANDLE and pass null_mut() for "no event".
+            // `Option<*mut c_void>` is not pointer-sized (raw pointers can
+            // already be null → no niche → 16-byte tagged enum, passed
+            // by-reference under Win64 ABI). Use a plain HANDLE and pass
+            // null_mut() for "no event".
             Event: HANDLE,                       // [in, optional]
             ApcRoutine: *mut c_void,             // [in, optional]
             ApcContext: PVOID,                   // [in, optional]
@@ -176,19 +177,17 @@ mod k32 {
 
 macro_rules! debug {
     ($fmt:literal $(, $arg:expr)* $(,)?) => {{
-        // Zig spec (`bun_shim_impl.zig`): `const dbg = builtin.mode == .Debug;`
-        // and every call site is `if (dbg) debug(...)`. The Rust port omits the
-        // per-call-site `if`, so gate the body here instead — release builds
-        // see an empty block (no `cfg!` const-assert, which fails E0080 in
-        // const-eval when `debug_assertions` is off).
+        // Debug-only logging: gate the body here rather than at every call
+        // site — release builds see an empty block (no `cfg!` const-assert,
+        // which fails E0080 in const-eval when `debug_assertions` is off).
         #[cfg(debug_assertions)]
         {
             #[cfg(not(feature = "shim_standalone"))]
             { bun_output::scoped_log!(bun_shim_impl, $fmt $(, $arg)*); }
             #[cfg(feature = "shim_standalone")]
             {
-                // TODO(port): standalone build has no std logger; this was `std.log.debug`.
-                // Left as no-op to keep the binary tiny; revisit if standalone debug logging is needed.
+                // The standalone build has no logger; deliberately a no-op to
+                // keep the binary tiny.
                 let _ = ($($arg,)*);
             }
         }
@@ -279,9 +278,7 @@ impl core::fmt::Display for FailReason {
         }
 
         writer.write_str("error: ")?;
-        // PORT NOTE: Zig used `switch (reason) { inline else => |r| ... }` to make `r` comptime
-        // and resolve the template at compile time. We dispatch at runtime; the template lookup
-        // is a const fn so the cost is a single match.
+        // The template lookup is a const fn so the cost is a single match.
         if IS_STANDALONE && *self == FailReason::CouldNotDirectLaunch {
             // unreachable is ok because Direct Launch is not supported in standalone mode
             unreachable!();
@@ -289,8 +286,7 @@ impl core::fmt::Display for FailReason {
 
         let template = self.get_format_template();
 
-        // The Zig `comptime std.mem.indexOf(u8, template, "{s}")` check is replaced by an
-        // explicit match on the one variant whose template contains `{s}`.
+        // Explicit match on the one variant whose template contains `{s}`.
         if matches!(self, FailReason::InterpreterNotFound) {
             // `FAILURE_REASON_LEN` is set before InterpreterNotFound is raised;
             // safe atomic load (`usize` is `Copy`, no cell-deref needed).
@@ -302,7 +298,7 @@ impl core::fmt::Display for FailReason {
             let arg_slice = unsafe {
                 bun_core::ffi::slice(FAILURE_REASON_DATA.get().cast::<u8>().cast_const(), len)
             };
-            // Zig spec writes raw bytes (`{s}`). `arg_slice` is filled by truncating
+            // `arg_slice` is filled by truncating
             // UTF-16 code units to 7 bits (`& 0x7F`) — every byte is < 0x80, hence
             // valid single-byte UTF-8. Avoids `bstr` so the standalone PE stays
             // `#![no_std]` (`bstr` pulls `alloc`).
@@ -373,7 +369,7 @@ pub fn write_to_handle(handle: HANDLE, data: &[u8]) -> usize {
     io.Information
 }
 
-/// Zig: `std.Io.GenericWriter(w.HANDLE, error{}, writeToHandle)`
+/// `core::fmt::Write` adapter over a raw NT handle.
 struct NtWriter {
     context: HANDLE,
 }
@@ -388,9 +384,9 @@ impl core::fmt::Write for NtWriter {
 // PORTING.md §Global mutable state: standalone single-threaded shim exe (or
 // just-before-exit path when linked into bun). RacyCell — no concurrency.
 static FAILURE_REASON_DATA: bun_core::RacyCell<[u8; 512]> = bun_core::RacyCell::new([0; 512]);
-// Length of the argument written into `FAILURE_REASON_DATA[..len]`. The pointer
-// half of the original Zig `?[]const u8` is always `FAILURE_REASON_DATA.as_ptr()`,
-// so storing only the `usize` length lets this be a plain `AtomicUsize` (safe
+// Length of the argument written into `FAILURE_REASON_DATA[..len]`. The data
+// pointer is always `FAILURE_REASON_DATA.as_ptr()`, so storing only the
+// `usize` length lets this be a plain `AtomicUsize` (safe
 // `.load()`/`.store()`) instead of a `RacyCell<Option<(*const u8, usize)>>`
 // requiring unsafe `read()`/`write()`. `usize::MAX` encodes `None`.
 static FAILURE_REASON_LEN: core::sync::atomic::AtomicUsize =
@@ -434,7 +430,6 @@ pub(crate) enum LauncherMode {
 }
 
 impl LauncherMode {
-    // PERF(port): comptime mode/reason demoted to runtime args — profile if it shows up on a hot path.
     #[cold]
     #[inline(never)]
     fn fail(self, reason: FailReason) -> LauncherRet {
@@ -458,7 +453,7 @@ enum LauncherRet {
 }
 
 /// Abstraction over `()` (standalone), `FromBunRunContext`, and `FromBunShellContext`
-/// for the Zig `bun_ctx: anytype` parameter.
+/// for the `bun_ctx` parameter of `launcher`.
 trait BunCtx {
     fn base_path(&self) -> *mut u16;
     fn base_path_len(&self) -> usize;
@@ -504,10 +499,10 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
     let teb: *mut w::TEB = w::teb();
     // SAFETY: TEB/PEB are valid for the process lifetime.
     let peb = unsafe { (*teb).ProcessEnvironmentBlock };
-    // SAFETY: ProcessParameters is OS-owned process-global state. The Zig spec only ever reads
-    // from it (`const ProcessParameters = peb.ProcessParameters`), so we keep it as a raw pointer
-    // and perform raw field reads rather than materializing a long-lived `&mut` that would assert
-    // exclusive access across the syscalls below (and across threads in non-standalone mode).
+    // SAFETY: ProcessParameters is OS-owned process-global state that this code only ever
+    // reads, so we keep it as a raw pointer and perform raw field reads rather than
+    // materializing a long-lived `&mut` that would assert exclusive access across the
+    // syscalls below (and across threads in non-standalone mode).
     let process_parameters = unsafe { (*peb).ProcessParameters };
     // SAFETY: process_parameters is valid for the process lifetime; UNICODE_STRING is Copy.
     let command_line = unsafe { (*process_parameters).CommandLine };
@@ -556,8 +551,6 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
     let mut buf1 = MaybeUninit::<[u16; BUF1_LEN]>::uninit();
     let mut buf2 = MaybeUninit::<[u16; BUF2_U16_LEN]>::uninit();
 
-    // TODO(port): the Zig source slices these as `[comptime buf1.len..]` on a `[*]T` cast,
-    // whose semantics are unclear; from usage they are base-of-buffer raw pointers.
     // Derive each view from a single `as_mut_ptr()` call so the raw pointers share one
     // borrow tag (a second `as_mut_ptr()` would invalidate the first under Stacked Borrows).
     let buf1_u16: *mut u16 = buf1.as_mut_ptr().cast::<u16>();
@@ -568,7 +561,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
 
     // The NT prefix is only *functionally* required in standalone mode (NtCreateFile needs an
     // NT object path), but we write it unconditionally so that buf1[0..4] is always initialized.
-    // The Zig original gated this on `is_standalone` as a micro-optimization; in Rust that leaves
+    // Gating it on `is_standalone` as a micro-optimization would leave
     // those four u16s as uninitialized memory, and the DBG `BufferAfterRead` dump below forms a
     // `&[u16]` over buf1 starting at index 0 — reading uninit integers there is UB. Eight bytes
     // of unconditional store is negligible and keeps every later buf1 read defined.
@@ -712,9 +705,9 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
                     // if this is the end of the string then this becomes an empty slice,
                     // otherwise it is a slice of just the arguments
                     //
-                    // PORT NOTE: Zig ReleaseSmall reads one past `Length` here and hits the
-                    // PEB CommandLine NUL terminator, exiting the loop. Rust slice indexing
-                    // always bounds-checks, so we must guard the upper bound explicitly.
+                    // Slice indexing always bounds-checks, so guard the upper
+                    // bound explicitly rather than relying on the PEB
+                    // CommandLine NUL terminator.
                     while i < cmd_line_u16.len() && cmd_line_u16[i] == ' ' as u16 {
                         i += 1;
                     }
@@ -736,8 +729,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
     let _ = user_arguments_u16; // only read under DBG
 
     if DBG {
-        // Zig spec: `debug("UserArgs: '{s}' ({d} bytes)", .{ user_arguments_u8, ... })`
-        // — raw byte dump of the UTF-16-LE arg tail. Display via `fmt16` on the
+        // Raw dump of the UTF-16-LE arg tail. Display via `fmt16` on the
         // u16 view to keep this `core`-only (no `bstr`).
         debug!(
             "UserArgs: '{}' ({} bytes)",
@@ -812,7 +804,6 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
             }
         }
         // inlined loop to do this again, because the completion case is different
-        // using `inline for` caused comptime issues that made the code much harder to read
         loop {
             if DBG {
                 debug!("2 - {}", fmt16(unsafe { bun_core::ffi::slice(ptr, 1) }));
@@ -879,8 +870,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
         // In the context of this program, I don't think that is possible, but I will handle it
         {
             // STATUS_END_OF_FILE on a fresh sync handle at offset 0 means zero bytes were
-            // written into buf1. The Zig source yields `read_max_len` here and lets the
-            // (uninitialized) trailing bytes fail `is_valid()`; in Rust, reading those
+            // written into buf1, and reading those
             // never-written bytes is UB. Zero the last u16 of buf1 — that is exactly where
             // the Flags read below lands when `read_len == read_max_len` — so the read is
             // defined and `is_valid()` deterministically rejects it.
@@ -917,7 +907,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
     //                               copied into buf1 above (initialized, junk-as-flags).
     //   - END_OF_FILE             → lands on buf1[BUF1_LEN-1], zeroed in that arm above.
     // The latter two yield a Flags value whose version_tag ≠ CURRENT, so `is_valid()`
-    // rejects them — same observable behavior as the Zig source, without the uninit read.
+    // rejects them.
     read_ptr = read_ptr
         .cast::<u8>()
         .wrapping_add(read_len)
@@ -934,9 +924,10 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
         let flags_u16: u16 = flags.bits();
         debug!("FlagsInt: {}", flags_u16);
         debug!("Flags:");
-        // TODO(port): Zig used `inline for` over `std.meta.fieldNames(Flags)`. Replace with a
-        // manual dump or a `Debug` impl on `Flags`.
-        debug!("    {:#06x}", flags.bits());
+        debug!("    is_node_or_bun: {}", flags.is_node_or_bun());
+        debug!("    is_node: {}", flags.is_node());
+        debug!("    has_shebang: {}", flags.has_shebang());
+        debug!("    version_tag: {}", flags.version_tag().bits());
     }
 
     if !flags.is_valid() {
@@ -1044,14 +1035,14 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
                 debug!("args_len_bytes: {}", args_len_bytes);
             }
 
-            // magic number related to how BinLinkingShim.zig writes the metadata
+            // magic number related to how BinLinkingShim.rs writes the metadata
             // i'm sorry, i don't have a good explanation for why this number is this number. it just is.
             const VALIDATION_LENGTH_OFFSET: u64 = 14;
 
             // very careful here to not overflow u32, so that we properly error if you hijack the file
             //
             // Both lengths are byte counts of UTF-16 data written by
-            // BinLinkingShim.zig and must be even. An odd value (corrupt or
+            // BinLinkingShim.rs and must be even. An odd value (corrupt or
             // tampered shim) would later misalign `write_ptr` (used to store a
             // u16 NUL terminator) and break the even-length invariant relied on
             // by `bytemuck::cast_slice`. Reject up front.
@@ -1069,10 +1060,9 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
                 return LauncherMode::fail(MODE, FailReason::InvalidShimBounds);
             }
 
-            // Gated on `Launch`: in Zig the `.read_without_launch` instantiation cannot reach
-            // `bun_ctx.direct_launch_with_bun_js` (FromBunShellContext lacks the field, so it
-            // is a compile error). Rust's trait abstraction defers that to a runtime
-            // `unreachable!()`, so guard explicitly to preserve the static invariant.
+            // Gated on `Launch`: the `.read_without_launch` instantiation must never reach
+            // `bun_ctx.direct_launch_with_bun_js` (FromBunShellContext's impl is a runtime
+            // `unreachable!()`), so guard explicitly to preserve the invariant.
             if MODE == LauncherMode::Launch
                 && !IS_STANDALONE
                 && flags.is_node_or_bun()
@@ -1096,7 +1086,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
                     / 2
                     - NT_OBJECT_PREFIX.len()
                     - 2 /* "\"\x00".len */;
-                // SAFETY: buf1_u16 + 4 .. + 4 + len is within buf1; the next char is '"' (asserted in Zig via sentinel slice).
+                // SAFETY: buf1_u16 + 4 .. + 4 + len is within buf1; the next char is '"' (the metadata format places '"' after the bin path).
                 let launch_slice =
                     unsafe { bun_core::ffi::slice_mut(buf1_u16.add(NT_OBJECT_PREFIX.len()), len) };
                 debug_assert_eq!(
@@ -1251,10 +1241,9 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
 
     if MODE == LauncherMode::ReadWithoutLaunch {
         // Early-return the assembled command line to the caller instead of spawning.
-        // In Zig the `read_without_launch` instantiation would compile-error at the later
-        // `bun_ctx.environment` access (FromBunShellContext has no such field), so the spawn
-        // path is provably dead there. Rust's trait abstraction defers that to a runtime
-        // `unreachable!()`, hence the explicit branch-out here.
+        // The spawn path must be dead for `ReadWithoutLaunch`
+        // (FromBunShellContext's `environment` impl is `unreachable!()`), hence
+        // the explicit branch-out here.
         //
         // Copy into the caller-provided buffer so the returned pointer outlives this stack
         // frame (covers both the buf1-backed no-shebang path and the buf2-backed shebang path).
@@ -1274,10 +1263,8 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
         // Prepare stdio for the child process, as after this we are going to *immediatly* exit
         // it is likely that the c-runtime's atexit will not be called as we end the process ourselves.
         //
-        // PORT NOTE: gated on `Launch` so `ReadWithoutLaunch` does not irreversibly mutate the
-        // parent process's stdio state. In Zig the `read_without_launch` instantiation would
-        // compile-error at the later `bun_ctx.environment` access, so it never reaches here;
-        // Rust's trait abstraction defeats that comptime guard, hence the explicit mode check.
+        // Gated on `Launch` so `ReadWithoutLaunch` does not irreversibly mutate the
+        // parent process's stdio state.
         bun_core::output::source::stdio::restore();
         // Declared locally as `safe fn` (the `bun_sys::windows` re-export
         // forwards `bun_windows_sys::externs::windows_enable_stdio_inheritance`,
@@ -1361,8 +1348,7 @@ fn launcher<const MODE: LauncherMode, Ctx: BunCtx>(bun_ctx: Ctx) -> LauncherRet
         },
     };
 
-    // PERF(port): Zig used `inline for (.{ 0, 1 })` to unroll this loop with comptime
-    // `attempt_number`. We use a runtime loop; the body is large enough that unrolling is
+    // PERF: the body is large enough that unrolling this two-iteration loop is
     // unlikely to matter — profile if it shows up on a hot path.
     for attempt_number in [0u32, 1] {
         'iteration: {
@@ -1549,8 +1535,7 @@ type CommandContext<'a> = bun_options_types::context::Context<'a>;
 #[cfg(feature = "shim_standalone")]
 type CommandContext<'a> = core::marker::PhantomData<&'a ()>; // unused in standalone
 
-// Zig stores `cli_context: CommandContext` where `CommandContext = *Command.Context`
-// — a raw pointer copied by value. Mirror that with `*mut ContextData` so reading
+// `cli_context` is a raw `*mut ContextData` copied by value, so reading
 // the field through `&self` (the `BunCtx` impl is on `&FromBunRunContext` and the
 // trait method takes `&self`, i.e. two layers of `&`) does not retag the pointee
 // to SharedReadOnly. Storing `&'a mut ContextData` and casting `*const→*mut` in
@@ -1629,7 +1614,7 @@ impl BunCtx for &FromBunRunContext {
     }
 }
 
-/// This is called from run_command.zig in bun.exe which allows us to skip the CreateProcessW
+/// This is called from run_command.rs in bun.exe which allows us to skip the CreateProcessW
 /// call to create bun_shim_impl.exe. Instead we invoke the logic it has from an open file handle.
 ///
 /// This saves ~5-12ms depending on the machine.
@@ -1641,7 +1626,7 @@ impl BunCtx for &FromBunRunContext {
 pub fn try_startup_from_bun_js(context: FromBunRunContext) {
     debug_assert!(!context.base_path_slice().starts_with(&NT_OBJECT_PREFIX));
     const _: () = assert!(!IS_STANDALONE);
-    // TODO(port): `comptime assert(bun.FeatureFlags.windows_bunx_fast_path)` — wire up FeatureFlags const.
+    const _: () = assert!(bun_core::feature_flags::WINDOWS_BUNX_FAST_PATH);
     match launcher::<{ LauncherMode::Launch }, _>(&context) {
         LauncherRet::LaunchFellThrough => {}
         LauncherRet::Read(_) => unreachable!(),
@@ -1661,7 +1646,7 @@ pub struct FromBunShellContext {
     /// Was --bun passed?
     pub force_use_bun: bool,
     /// A pointer to memory needed to store the command line.
-    /// Matches Zig `buf: *Buf` (`*[buf2_u16_len]u16`). Kept as a raw pointer so the
+    /// Kept as a raw pointer so the
     /// `BunCtx` impl (which only sees `&Self`) can hand out a writable pointer without
     /// laundering provenance through a shared reborrow of `&mut [_; N]`.
     pub buf: *mut FromBunShellContextBuf,
@@ -1709,8 +1694,6 @@ impl BunCtx for &FromBunShellContext {
     }
 }
 
-// PORT NOTE: Zig `union` (untagged). Rust enums are tagged; the discriminant overhead is
-// negligible here and gives us safe matching.
 pub enum ReadWithoutLaunchResult {
     /// enum which has a predefined custom formatter
     Err(FailReason),
@@ -1728,7 +1711,7 @@ pub enum ReadWithoutLaunchResult {
 pub fn read_without_launch(context: FromBunShellContext) -> ReadWithoutLaunchResult {
     debug_assert!(!context.base_path_slice().starts_with(&NT_OBJECT_PREFIX));
     const _: () = assert!(!IS_STANDALONE);
-    // TODO(port): `comptime assert(bun.FeatureFlags.windows_bunx_fast_path)` — wire up FeatureFlags const.
+    const _: () = assert!(bun_core::feature_flags::WINDOWS_BUNX_FAST_PATH);
     match launcher::<{ LauncherMode::ReadWithoutLaunch }, _>(&context) {
         LauncherRet::Read(r) => r,
         LauncherRet::LaunchFellThrough => unreachable!(),
@@ -1740,17 +1723,17 @@ pub fn read_without_launch(context: FromBunShellContext) -> ReadWithoutLaunchRes
 #[inline]
 pub(crate) fn main() -> ! {
     const _: () = assert!(IS_STANDALONE);
-    // TODO(port): `comptime assert(builtin.single_threaded)` / `!link_libc` / `!link_libcpp` —
-    // these are build-config assertions; enforce in the standalone crate's Cargo.toml/build.rs.
+    // The standalone crate enforces the single-threaded, CRT-free build shape
+    // structurally via `#![no_std]` / `#![no_main]` and its link configuration
+    // (see `main.rs` and `scripts/build/rust.ts`).
     launcher::<{ LauncherMode::Launch }, _>(());
     unreachable!();
 }
 
 // ───── helpers ─────
 
-/// Zig `std.unicode.fmtUtf16Le`.
-// TODO(port): provide a proper UTF-16-LE Display adapter in `bun_str`; for now this lossy
-// debug-only formatter is sufficient (only used under `if DBG`).
+/// Lossy (replacement-char) UTF-16-LE formatter — only
+/// used for debug logging under `if DBG`, so lossiness is fine.
 fn fmt16(s: &[u16]) -> impl core::fmt::Display + '_ {
     struct F<'a>(&'a [u16]);
     impl core::fmt::Display for F<'_> {
@@ -1766,5 +1749,3 @@ fn fmt16(s: &[u16]) -> impl core::fmt::Display + '_ {
     }
     F(s)
 }
-
-// ported from: src/install/windows-shim/bun_shim_impl.zig
diff --git a/src/install/windows-shim/main.rs b/src/install/windows-shim/main.rs
index 8a419a91a2e..c5d31a4724b 100644
--- a/src/install/windows-shim/main.rs
+++ b/src/install/windows-shim/main.rs
@@ -12,8 +12,7 @@
 //!     no `#[no_mangle]` exports). Depending on the real crates would make
 //!     their `#[no_mangle]` C-ABI surface (`Bun__*`, `__bun_dispatch__*`) a
 //!     link root referencing libuv/simdutf/highway/ICU; the shim can't
-//!     satisfy those and shouldn't carry them. Zig's original
-//!     (`bun_shim_impl.zig`) was self-contained for the same reason.
+//!     satisfy those and shouldn't carry them.
 //!
 //! `BinLinkingShim.rs` is path-included for `Flags`/`VersionFlag` only; its
 //! encoder side (Shebang, `encode_into`, `include_bytes!` of this crate's own
@@ -23,9 +22,7 @@
 // modules assume these are set at the crate root.
 //
 // Freestanding: `no_std` + `no_main` so the link contains only the launcher
-// + Win32 externs — no Rust runtime, no CRT, no `std::sys` init. Matches
-// Zig's build (build.zig built `bun_shim_impl.zig` as a freestanding
-// ReleaseFast exe with `link_libc = false`, `single_threaded = true`).
+// + Win32 externs — no Rust runtime, no CRT, no `std::sys` init.
 // `scripts/build/rust.ts` supplies `/ENTRY:shim_main` and rebuilds `core`
 // with `panic_immediate_abort` so the panic/fmt machinery is dead code.
 #![no_std]
@@ -70,9 +67,7 @@ pub(crate) static _fltused: i32 = 0;
 /// `compiler_builtins` *has* this routine but hard-gates it on
 /// `cfg(target_env = "gnu")` (`src/x86_64.rs` / `src/aarch64.rs`) because on
 /// `*-msvc` it expects the CRT to provide it; there is no feature flag to
-/// opt in. Zig is in the same position and ships the probe in its own
-/// compiler-rt for `windows && !link_libc` (see
-/// `vendor/zig/lib/compiler_rt/stack_probe.zig`). We do likewise: the bodies
+/// opt in. So we ship the probe ourselves: the bodies
 /// below are taken verbatim from `compiler_builtins` (which in turn mirrors
 /// LLVM `compiler-rt/lib/builtins/{x86_64,aarch64}/chkstk.S`), so they are
 /// the upstream-tested instruction sequences rather than a local rewrite.
@@ -144,7 +139,7 @@ pub(crate) extern "C" fn shim_main() -> ! {
 /// panics are debug assertions; in release the build script enables `core`'s
 /// `panic_immediate_abort` so they compile to a bare trap and never reach
 /// this. If one does (debug `--profile shim` build), exit 255 — same code
-/// `fail_and_exit_with_reason` uses, and matching Zig's `panic = abort`.
+/// `fail_and_exit_with_reason` uses.
 #[cfg(windows)]
 #[panic_handler]
 fn panic(_: &core::panic::PanicInfo<'_>) -> ! {
@@ -205,7 +200,7 @@ pub mod bun_core {
     pub use crate::w_lit as w;
     /// Mirrors `bun_core::RacyCell` (src/bun_core/util.rs) — `static`-safe
     /// interior-mutability cell with no synchronization. The shim is
-    /// single-threaded (Zig built it `single_threaded = true`), so the
+    /// single-threaded (it never spawns a thread), so the
     /// unconditional `Sync` is trivially upheld.
     ///
     /// Internally backed by `Cell<T>` (not `UnsafeCell<T>`): `Cell` is
diff --git a/src/install/yarn.rs b/src/install/yarn.rs
index 9e3581c6bff..31ee66421c5 100644
--- a/src/install/yarn.rs
+++ b/src/install/yarn.rs
@@ -1,4 +1,5 @@
 use bun_collections::VecExt;
+use std::borrow::Cow;
 use std::io::Write as _;
 
 use bun_collections::{HashMap, StringHashMap};
@@ -7,7 +8,7 @@ use bun_install::bin::Bin;
 use bun_install::dependency::{self, Dependency, DependencyExt as _};
 use bun_install::install::{self, DependencyID, PackageID, PackageManager};
 use bun_install::integrity::Integrity;
-// PORT NOTE: `bun_install::lockfile` is the column-accessor stub used by the
+// `bun_install::lockfile` is the column-accessor stub used by the
 // audit/why CLI walkers; the yarn migrator needs the real Lockfile/Tree/
 // LoadResult enum, so import from `lockfile_real` and alias it back to
 // `lockfile` so the qualified `lockfile::DependencySlice` etc. paths below
@@ -19,7 +20,7 @@ use crate::lockfile_real::package::{
 };
 use crate::lockfile_real::{self as lockfile, LoadResult, Lockfile, tree, tree::Tree};
 use bun_install::npm;
-// PORT NOTE: `Package.resolution` is the file-backed `resolution_real::ResolutionType<u64>`
+// `Package.resolution` is the file-backed `resolution_real::ResolutionType<u64>`
 // (tag + zero-padded `Value` union), constructed via `init(TaggedValue::*)`; the
 // `bun_install::resolution` stub keeps `Value` as a struct-of-fields and has no `init`.
 use crate::bun_json;
@@ -31,10 +32,9 @@ use bun_paths::PathBuffer;
 use bun_semver::{self as Semver, SlicedString, String as SemverString};
 use bun_sys::Fd;
 
-// TODO(port): lifetime — Entry/YarnLock borrow from the input `data: &[u8]` passed to
-// `migrate_yarn_lockfile`. LIFETIMES.tsv had no rows for this file (no *T fields), so
-// `'a` here is the BORROW_PARAM classification applied to slice fields. Verify the few
-// owned slices (specs inner strings, file, git_repo_name) don't need `Box<[u8]>` instead.
+// Entry/YarnLock borrow from the input `data: &[u8]` passed to `migrate_yarn_lockfile`;
+// `resolved` may instead own a rewritten URL (see `Cow` below) and `git_repo_name` is
+// always owned.
 
 pub struct YarnLock<'a> {
     pub entries: Vec<Entry<'a>>,
@@ -43,7 +43,9 @@ pub struct YarnLock<'a> {
 pub struct Entry<'a> {
     pub specs: Vec<&'a [u8]>,
     pub version: &'a [u8],
-    pub resolved: Option<&'a [u8]>,
+    // Usually borrows from the input; owned when `parse_git_url` rewrites a
+    // `github:` spec to a `https://github.com/...` URL.
+    pub resolved: Option<Cow<'a, [u8]>>,
     pub integrity: Option<&'a [u8]>,
     pub dependencies: Option<StringHashMap<&'a [u8]>>,
     pub optional_dependencies: Option<StringHashMap<&'a [u8]>>,
@@ -54,7 +56,7 @@ pub struct Entry<'a> {
     pub file: Option<&'a [u8]>,
     pub os: Option<Vec<&'a [u8]>>,
     pub cpu: Option<Vec<&'a [u8]>>,
-    // Owned: allocated via allocPrint/dupe in parse(); freed in deinit
+    // Owned heap allocation (unlike the borrowed fields above); created in parse()
     pub git_repo_name: Option<Box<[u8]>>,
 }
 
@@ -84,9 +86,9 @@ pub struct ParsedGitUrl<'a> {
     pub commit: Option<&'a [u8]>,
     pub owner: Option<&'a [u8]>,
     pub repo: Option<&'a [u8]>,
-    // TODO(port): in Zig, `url` may be either a borrow into `version` or a freshly
-    // allocPrint'd "https://github.com/{path}". Here we keep an optional owned buffer
-    // so the borrow case stays zero-copy. Callers must check `owned_url` first.
+    // Optional owned "https://github.com/{path}" buffer so the borrow
+    // case stays zero-copy. Callers must check `owned_url` first: when it is `Some`,
+    // it supersedes `url` (see `into_resolved`).
     pub owned_url: Option<Vec<u8>>,
 }
 
@@ -212,7 +214,6 @@ impl<'a> Entry<'a> {
         _yarn_lock: &YarnLock<'a>,
         version: &'a [u8],
     ) -> Result<ParsedGitUrl<'a>, Error> {
-        // TODO(port): narrow error set
         let mut url: &[u8] = version;
         let mut commit: Option<&[u8]> = None;
         let mut owner: Option<&[u8]> = None;
@@ -245,7 +246,8 @@ impl<'a> Entry<'a> {
             buf.extend_from_slice(b"https://github.com/");
             buf.extend_from_slice(path_without_commit);
             owned_url = Some(buf);
-            // url now points into owned_url; callers must read owned_url when Some
+            // `url` still borrows the stripped input; callers must prefer
+            // `owned_url` when it is Some.
         } else if strings::index_of(url, b"github.com").is_some() {
             let mut remaining = url;
             if let Some(idx) = strings::index_of(remaining, b"github.com/") {
@@ -335,7 +337,6 @@ impl<'a> YarnLock<'a> {
     }
 
     pub(crate) fn parse(&mut self, content: &'a [u8]) -> Result<(), Error> {
-        // TODO(port): narrow error set
         let mut lines = strings::split(content, b"\n");
         let mut current_entry: Option<Entry<'a>> = None;
         let mut current_specs: Vec<&'a [u8]> = Vec::new();
@@ -469,36 +470,36 @@ impl<'a> YarnLock<'a> {
                             );
                         } else if Entry::is_git_dependency(value) {
                             let git_info = Entry::parse_git_url(self, value)?;
-                            // TODO(port): dropped logic — Zig reassigns `url` to the
-                            // allocPrint'd `https://github.com/{path}` buffer for the
-                            // `github:` branch and stores that as `resolved`. Here
-                            // `git_info.url` still borrows the stripped input slice and
-                            // `owned_url` is discarded, so github: URLs resolve INCORRECTLY.
-                            // Fix: change Entry.resolved to Cow<'a, [u8]> (or store the
-                            // owned buffer on Entry) so `owned_url` can be assigned here.
-                            entry.resolved = Some(git_info.url);
                             entry.commit = git_info.commit;
                             if let Some(repo_name) = git_info.repo {
                                 entry.git_repo_name = Some(Box::<[u8]>::from(repo_name));
                             }
+                            // For the `github:` branch the resolved URL is the
+                            // owned `https://github.com/{path}` buffer.
+                            entry.resolved = Some(match git_info.owned_url {
+                                Some(owned) => Cow::Owned(owned),
+                                None => Cow::Borrowed(git_info.url),
+                            });
                         } else if Entry::is_npm_alias(value) {
                             let alias_info = Entry::parse_npm_alias(value);
                             entry.version = alias_info.version;
                         } else if Entry::is_remote_tarball(value) {
-                            entry.resolved = Some(value);
+                            entry.resolved = Some(Cow::Borrowed(value));
                         }
                     } else if key == b"resolved" {
-                        entry.resolved = Some(value);
+                        entry.resolved = Some(Cow::Borrowed(value));
                         if Entry::is_git_dependency(value) {
                             let git_info = Entry::parse_git_url(self, value)?;
-                            // TODO(port): same github: owned_url issue as the `version` branch
-                            // above — Entry.resolved needs Cow<'a, [u8]> to hold the rewritten
-                            // `https://github.com/...` buffer.
-                            entry.resolved = Some(git_info.url);
                             entry.commit = git_info.commit;
                             if let Some(repo_name) = git_info.repo {
                                 entry.git_repo_name = Some(Box::<[u8]>::from(repo_name));
                             }
+                            // As in the `version` branch: prefer the rewritten
+                            // `https://github.com/...` buffer for `github:` specs.
+                            entry.resolved = Some(match git_info.owned_url {
+                                Some(owned) => Cow::Owned(owned),
+                                None => Cow::Borrowed(git_info.url),
+                            });
                         }
                     } else if key == b"integrity" {
                         entry.integrity = Some(value);
@@ -535,9 +536,9 @@ impl<'a> YarnLock<'a> {
     }
 
     fn find_entry_by_spec(&self, spec: &[u8]) -> Option<&Entry<'a>> {
-        // PORT NOTE: Zig returns `?*Entry` (mutable ptr) but every caller only
-        // reads `.workspace` / `.specs`, so `&self` suffices and avoids the
-        // borrowck conflict with the outer `entries.iter()` loops.
+        // Every caller only reads `.workspace` / `.specs`, so `&self`
+        // suffices and avoids the borrowck conflict with the outer
+        // `entries.iter()` loops.
         for entry in self.entries.iter() {
             for entry_spec in entry.specs.iter() {
                 if *entry_spec == spec {
@@ -568,7 +569,7 @@ impl<'a> YarnLock<'a> {
                 combined_specs.extend_from_slice(&new_entry.specs);
 
                 existing_entry.specs = combined_specs;
-                // new_entry.specs dropped here (Zig: allocator.free)
+                // new_entry.specs dropped here
                 return Ok(());
             }
         }
@@ -597,10 +598,8 @@ fn process_deps(
     manager: &mut PackageManager,
     yarn_entry_to_package_id: &[PackageID],
 ) -> Result<usize, Error> {
-    // TODO(port): narrow error set
-    // PORT NOTE: returns count instead of slice to avoid borrowck conflict with caller's bufs
+    // Returns count instead of slice to avoid borrowck conflict with caller's bufs.
     let mut count: usize = 0;
-    // PERF(port): was stack-fallback alloc (1024 bytes) — profile if it shows up on a hot path
 
     for (dep_name_key, dep_version_ref) in deps.iter() {
         let dep_name: &[u8] = dep_name_key.as_ref();
@@ -670,8 +669,8 @@ struct RootDep {
 #[derive(Clone)]
 struct VersionInfo {
     version: Vec<u8>,
-    // TODO(port): Zig stores `string` (borrow from input). Using Vec<u8> here to avoid
-    // a second lifetime on the local map; could switch to &'a [u8].
+    // Owned Vec<u8> (rather than a borrow from the input) avoids a second
+    // lifetime on the local map.
     package_id: PackageID,
     yarn_idx: usize,
 }
@@ -683,8 +682,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
     data: &[u8],
     dir: Fd,
 ) -> Result<LoadResult<'a>, Error> {
-    // TODO(port): narrow error set
-    // todo yarn v2+ support
+    // yarn v2+ (berry) lockfiles are not supported; only the v1 format migrates.
     if !strings::index_of(data, b"# yarn lockfile v1").is_some() {
         return Err(bun_core::err!("UnsupportedYarnLockfileVersion"));
     }
@@ -696,8 +694,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
     install::initialize_store();
     bun_core::analytics::Features::yarn_migration_inc(1);
 
-    // PORT NOTE: reshaped for borrowck. Zig keeps a single `var string_buf =
-    // this.stringBuf()` for the whole function, but in Rust that would hold
+    // A single `Buf` for the whole function would hold
     // `&mut this.buffers.string_bytes` + `&mut this.string_pool` for the
     // function's lifetime and lock out every other `this.*` access. Instead,
     // construct a fresh `Buf` per append via this macro so the mutable borrow
@@ -742,9 +739,8 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         };
         drop(package_json_fd); // close now; fd no longer needed past path resolution
 
-        // PORT NOTE: Zig passes `comptime opts: js_lexer.JSONOptions`; the Rust
-        // port spells the 8 option flags out as const generics (stable Rust has
-        // no struct const-generics). Unspecified Zig fields default to false.
+        // The 8 JSON option flags are spelled out as const generics (stable
+        // Rust has no struct const-generics).
         let json_bump = bun_alloc::Arena::new();
         let Ok(package_json_expr) = bun_json::parse_package_json_utf8_with_opts::<
             true,  // IS_JSON
@@ -904,8 +900,8 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         }
     }
 
-    // SAFETY: capacity reserved above to num_deps; Zig writes into items.ptr[0..num_deps]
-    // beyond len. We mirror with raw pointers and set len at the end.
+    // SAFETY: capacity reserved above to num_deps; we write past `len` through
+    // raw pointers into the reserved capacity and set `len` at the end.
     let dependencies_base_ptr = this.buffers.dependencies.as_mut_ptr();
     let resolutions_base_ptr = this.buffers.resolutions.as_mut_ptr();
     let mut dependencies_buf: &mut [Dependency] = unsafe {
@@ -940,7 +936,8 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
             }
         }
 
-        let name: &[u8] = if let (true, Some(resolved)) = (is_npm_alias, entry.resolved) {
+        let name: &[u8] = if let (true, Some(resolved)) = (is_npm_alias, entry.resolved.as_deref())
+        {
             Entry::get_package_name_from_resolved_url(resolved)
                 .unwrap_or_else(|| Entry::get_name_from_spec(entry.specs[0]))
         } else if is_direct_url {
@@ -1015,7 +1012,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
     let mut package_id_to_yarn_idx: Vec<usize> = vec![usize::MAX; next_package_id as usize];
 
     let created_packages: StringHashMap<bool> = StringHashMap::new();
-    let _ = &created_packages; // unused in Zig too (only init/deinit)
+    let _ = &created_packages; // never populated
 
     for (yarn_idx, entry) in yarn_lock.entries.iter().enumerate() {
         let mut is_npm_alias = false;
@@ -1036,12 +1033,13 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
             }
         }
 
-        let base_name: &[u8] = if let (true, Some(resolved)) = (is_npm_alias, entry.resolved) {
-            Entry::get_package_name_from_resolved_url(resolved)
-                .unwrap_or_else(|| Entry::get_name_from_spec(entry.specs[0]))
-        } else {
-            Entry::get_name_from_spec(entry.specs[0])
-        };
+        let base_name: &[u8] =
+            if let (true, Some(resolved)) = (is_npm_alias, entry.resolved.as_deref()) {
+                Entry::get_package_name_from_resolved_url(resolved)
+                    .unwrap_or_else(|| Entry::get_name_from_spec(entry.specs[0]))
+            } else {
+                Entry::get_name_from_spec(entry.specs[0])
+            };
         let package_id = yarn_entry_to_package_id[yarn_idx];
 
         if (package_id as usize) < package_id_to_yarn_idx.len()
@@ -1055,7 +1053,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         let name_to_use: &[u8] = 'blk: {
             if entry.commit.is_some() && entry.git_repo_name.is_some() {
                 break 'blk entry.git_repo_name.as_deref().unwrap();
-            } else if let Some(resolved) = entry.resolved {
+            } else if let Some(resolved) = entry.resolved.as_deref() {
                 if is_direct_url_dep
                     || Entry::is_remote_tarball(resolved)
                     || resolved.ends_with(b".tgz")
@@ -1084,7 +1082,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
 
         let name_hash = string_hash(name_to_use);
 
-        // PORT NOTE: reshaped for borrowck — compute the resolution before the
+        // reshaped for borrowck — compute the resolution before the
         // `this.packages.append(...)` call so the per-field `sbuf!()` borrows of
         // `this.buffers.string_bytes` don't overlap the two-phase reservation
         // on `this.packages`.
@@ -1103,7 +1101,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
                     break 'blk Resolution::init(ResolutionValue::Folder(sbuf!().append(file)?));
                 }
             } else if let Some(commit) = entry.commit {
-                if let Some(resolved) = entry.resolved {
+                if let Some(resolved) = entry.resolved.as_deref() {
                     let mut owner_str: &[u8] = b"";
                     let mut repo_str: &[u8] = resolved;
 
@@ -1146,7 +1144,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
                     }
                 }
                 break 'blk Resolution::default();
-            } else if let Some(resolved) = entry.resolved {
+            } else if let Some(resolved) = entry.resolved.as_deref() {
                 if is_direct_url_dep {
                     break 'blk Resolution::init(ResolutionValue::RemoteTarball(
                         sbuf!().append(resolved)?,
@@ -1228,9 +1226,9 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         })?;
     }
 
-    // PORT NOTE: Zig holds two `items(.field)` slices simultaneously; the
-    // derive's `&mut self` accessors can't alias, so we re-borrow per write
-    // below via `this.packages.items_*_mut()[idx] = …` instead of caching.
+    // The derive's `&mut self` accessors can't alias, so we re-borrow per write
+    // below via `this.packages.items_*_mut()[idx] = …` instead of caching
+    // two field slices simultaneously.
 
     let mut actual_root_dep_count: u32 = 0;
 
@@ -1309,7 +1307,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         let dependencies_start = dependencies_buf.as_mut_ptr();
         let resolutions_start = resolutions_buf.as_mut_ptr();
 
-        // PORT NOTE: reshaped for borrowck — iterate by index and re-borrow
+        // reshaped for borrowck — iterate by index and re-borrow
         // `yarn_lock.entries[yarn_idx]` for each map so the shared borrow of
         // `yarn_lock` passed into `process_deps` doesn't overlap an iterator.
         if let Some(deps) = yarn_lock.entries[yarn_idx].dependencies.as_ref() {
@@ -1440,7 +1438,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
                 )
                 .expect("unreachable");
 
-                // PORT NOTE: reshaped for borrowck — find_entry_by_spec via index search
+                // reshaped for borrowck — find_entry_by_spec via index search
                 // instead of returning &mut to avoid overlapping borrow with the loop below.
                 let dep_entry_specs: Option<Vec<&[u8]>> = {
                     let mut found: Option<Vec<&[u8]>> = None;
@@ -1511,10 +1509,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
         versions.sort_by_key(|a| a.package_id);
 
         let original_name_hash = string_hash(base_name);
-        // PORT NOTE: reshaped for borrowck — Zig matches on the entry only to
-        // call `existing_ids.deinit()` before `remove`; Rust's `remove` drops
-        // the value (and thus the `Ids` Vec) automatically, so the match is
-        // unnecessary and we avoid the overlapping `get_mut`/`remove` borrow.
+        // `remove` drops the value (and thus the `Ids` Vec) automatically.
         let _ = this.package_index.remove(&original_name_hash);
     }
 
@@ -1712,7 +1707,7 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
             continue;
         }
 
-        if let Some(resolved) = entry.resolved {
+        if let Some(resolved) = entry.resolved.as_deref() {
             if let Some(real_name) = Entry::get_package_name_from_resolved_url(resolved) {
                 for spec in entry.specs.iter() {
                     let alias_name = Entry::get_name_from_spec(spec);
@@ -2043,7 +2038,6 @@ pub(crate) fn migrate_yarn_lockfile<'a>(
 
     let result = LoadResult::Ok(lockfile::LoadResultOk {
         lockfile: this,
-        // TODO(port): LoadResult.ok stores *Lockfile; lifetime/ownership not yet resolved
         migrated: lockfile::Migrated::Yarn,
         loaded_from_binary_lockfile: false,
         serializer_result: Default::default(),
@@ -2058,9 +2052,8 @@ fn string_hash(s: &[u8]) -> u64 {
     Semver::string::Builder::string_hash(s)
 }
 
-/// Port of Zig's packed-struct `Behavior { .prod = …, .dev = … }` literal.
-/// Rust's bitflags-backed `Behavior` has no named fields, so build via
-/// `with(FLAG, cond)` chaining instead.
+/// The bitflags-backed `Behavior` has no named fields, so build via
+/// `with(FLAG, cond)` chaining.
 #[inline]
 fn behavior_for(dep_type: DependencyType, workspace: bool) -> dependency::Behavior {
     dependency::Behavior::default()
@@ -2079,5 +2072,3 @@ fn behavior_for(dep_type: DependencyType, workspace: bool) -> dependency::Behavi
         .with(dependency::Behavior::PEER, dep_type == DependencyType::Peer)
         .with(dependency::Behavior::WORKSPACE, workspace)
 }
-
-// ported from: src/install/yarn.zig
diff --git a/src/install_jsc/dependency_jsc.rs b/src/install_jsc/dependency_jsc.rs
index 3ef276570ab..5f20d685930 100644
--- a/src/install_jsc/dependency_jsc.rs
+++ b/src/install_jsc/dependency_jsc.rs
@@ -1,7 +1,5 @@
-//! JSC bridges for `bun_install::Dependency`. In Zig this was aliased back into
-//! `src/install/dependency.zig` so call sites were unchanged; in Rust the
-//! `to_js`/`from_js` surface lives here as extension-trait methods on the base
-//! type (see PORTING.md "Idiom map" — `*_jsc` alias lines are deleted).
+//! JSC bridges for `bun_install::Dependency`. The `to_js`/`from_js` surface
+//! lives here as extension-trait methods on the base type.
 
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult, StringJsc};
 
@@ -33,7 +31,7 @@ pub(crate) fn version_to_js(
         BunString::static_(<&'static str>::from(dep.tag).as_bytes()).to_js(global)?,
     );
 
-    // PORT NOTE: `dependency::Version` keeps `Value` as a `#[repr(C)] union`
+    // `dependency::Version` keeps `Value` as a `#[repr(C)] union`
     // (discriminant in `Version.tag`); the tag-checked accessors on
     // `DependencyVersion` (`npm()`, `git()`, …) wrap the union read.
     match dep.tag {
@@ -143,8 +141,6 @@ pub fn dependency_from_js(global: &JSGlobalObject, frame: &CallFrame) -> JsResul
     if arguments.len() == 1 {
         return crate::update_request_jsc::from_js(global, arguments[0]);
     }
-    // PERF(port): was arena bulk-free (std.heap.ArenaAllocator) — profile if hot
-    // PERF(port): was stack-fallback (std.heap.stackFallback(1024, ...)) — profile if hot
 
     let alias_value: JSValue = if !arguments.is_empty() {
         arguments[0]
@@ -168,8 +164,6 @@ pub fn dependency_from_js(global: &JSGlobalObject, frame: &CallFrame) -> JsResul
     };
     let name_slice = name_value.to_slice(global)?;
 
-    // PORT NOTE: reshaped for borrowck — Zig built `name`/`alias`/`buf` as
-    // overlapping slices into a StringBuilder's single allocation. Rust's
     // `StringBuilder::append` returns `&[u8]` borrowing `&mut self`, so we
     // can't hold two appended slices at once. Instead, build into an owned
     // `Vec<u8>` and reslice by offset (same memory layout, no aliasing fight).
@@ -220,5 +214,3 @@ pub fn dependency_from_js(global: &JSGlobalObject, frame: &CallFrame) -> JsResul
 
     version_to_js(&dep, buf, global)
 }
-
-// ported from: src/install_jsc/dependency_jsc.zig
diff --git a/src/install_jsc/hosted_git_info_jsc.rs b/src/install_jsc/hosted_git_info_jsc.rs
index 04f719a948b..06d339243fa 100644
--- a/src/install_jsc/hosted_git_info_jsc.rs
+++ b/src/install_jsc/hosted_git_info_jsc.rs
@@ -1,9 +1,8 @@
-//! JSC bridges for `src/install/hosted_git_info.zig`. Aliased back so call
-//! sites and `$newZigFunction("hosted_git_info.zig", …)` are unchanged.
+//! JSC bridges for `bun_install::hosted_git_info`.
 
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult, StringJsc};
 
-/// Extension trait providing `.to_js()` on `HostedGitInfo` (Zig: `hostedGitInfoToJS`).
+/// Extension trait providing `.to_js()` on `HostedGitInfo`.
 pub trait HostedGitInfoJsc {
     fn to_js(&self, go: &JSGlobalObject) -> JsResult<JSValue>;
 }
@@ -75,8 +74,8 @@ pub fn js_parse_url(go: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSVa
     // TODO(markovejnovic): This feels like there's too much going on all
     // to give us a slice. Maybe there's a better way to code this up.
     let npa_str = bun_core::OwnedString::new(arg0.to_bun_string(go)?);
-    // PORT NOTE: Zig used `ZigString.Slice.mut()` to get a mutable view; the Rust
-    // `ZigStringSlice` is read-only, so own a mutable copy via `into_vec()`.
+    // `ZigStringSlice` is read-only, so take an owned copy via `into_vec()`
+    // (`parse_url` itself only needs `&[u8]`).
     let mut as_utf8 = npa_str.to_utf8().into_vec();
     let parsed = match hgi::parse_url(as_utf8.as_mut_slice()) {
         Ok(p) => p,
@@ -114,7 +113,8 @@ pub fn js_from_url(go: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSVal
     // TODO(markovejnovic): This feels like there's too much going on all to give us a slice.
     // Maybe there's a better way to code this up.
     let npa_str = bun_core::OwnedString::new(arg0.to_bun_string(go)?);
-    // PORT NOTE: Zig used `ZigString.Slice.mut()`; own a mutable copy.
+    // `ZigStringSlice` is read-only, so take an owned copy
+    // (`from_url` itself only needs `&[u8]`).
     let mut as_utf8 = npa_str.to_utf8().into_vec();
     let parsed = match HostedGitInfo::from_url(as_utf8.as_mut_slice()) {
         Ok(Some(p)) => p,
@@ -129,5 +129,3 @@ pub fn js_from_url(go: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSVal
 
     parsed.to_js(go)
 }
-
-// ported from: src/install_jsc/hosted_git_info_jsc.zig
diff --git a/src/install_jsc/ini_jsc.rs b/src/install_jsc/ini_jsc.rs
index a5a84fef216..a2c8a4a2664 100644
--- a/src/install_jsc/ini_jsc.rs
+++ b/src/install_jsc/ini_jsc.rs
@@ -37,15 +37,11 @@ impl IniTestingAPIs {
 
         let mut log = Log::init();
 
-        // PERF(port): was ArenaAllocator bulk-free — profile if hot.
-        // (all `allocator.create`/`toOwnedSlice` below now use the global mimalloc)
-
         let envjs = frame.argument(1);
-        // PORT NOTE: reshaped for borrowck — Zig returned either a VM-owned *Loader or
-        // an arena-allocated *Loader from a labeled block. Per PORTING.md §Forbidden
+        // The loader is either VM-owned or built locally. Per PORTING.md §Forbidden
         // (`Box::leak` is banned), keep both `Map` and `Loader` owned in fn-scope
         // `Option`s and hand out a raw `*mut Loader` uniformly. Both drop at fn
-        // return — same lifetime as the original arena.
+        // return.
         let mut map_storage: Option<Box<dotenv::Map>>;
         let mut env_storage: Option<dotenv::Loader<'_>>;
         let env: *mut dotenv::Loader<'static> = if envjs.is_empty_or_undefined_or_null() {
@@ -77,7 +73,6 @@ impl IniTestingAPIs {
                 let value_str = value.get_zig_string(global)?;
                 let slice = value_str.to_owned_slice();
 
-                // Zig: `catch return globalThis.throwOutOfMemoryValue()` — Rust aborts on OOM.
                 envmap.put(
                     &keyslice,
                     dotenv::map::Entry {
@@ -89,7 +84,7 @@ impl IniTestingAPIs {
 
             map_storage = Some(Box::new(dotenv::Map { map: envmap }));
             // SAFETY-NOTE: `Loader` borrows from `map_storage`; both live until fn
-            // return, mirroring the Zig arena's bulk-free.
+            // return.
             let map_ref: &mut dotenv::Map = map_storage.as_deref_mut().unwrap();
             env_storage = Some(dotenv::Loader::init(map_ref));
             // `Loader<'a>` is invariant in `'a` (holds `&'a mut Map`); erase to `'static`
@@ -143,8 +138,7 @@ impl IniTestingAPIs {
         };
         // `defer { *.deref() }` deleted — bun_core::String impls Drop.
 
-        // PORT NOTE: `jsc.JSObject.create(.{ .field = val, ... }, global)` reflects over
-        // an anon struct's fields at comptime. Rust has no field reflection; mirror with
+        // Rust has no field reflection; mirror struct-literal object creation with
         // a local `PojoFields` impl (the bun_jsc-convention until `#[derive(PojoFields)]`
         // lands) so each `bun.String → JSValue` encoding interleaves with `put()` and
         // stays on the stack for JSC's conservative scan.
@@ -206,7 +200,7 @@ impl IniTestingAPIs {
         let utf8str = bunstr.to_utf8();
 
         let env = global.bun_vm().as_mut().transpiler.env_mut();
-        // TODO(port): lifetime — `Parser::init` ties `src: &'a [u8]` and
+        // `Parser::init` ties `src: &'a [u8]` and
         // `env: &'a mut DotEnvLoader<'a>` to one invariant `'a`; the VM-owned
         // env is `'static`, so erase `src` to match. SAFETY: `parser` is dropped
         // before `utf8str` (drop order is reverse of declaration); no borrow
@@ -214,9 +208,8 @@ impl IniTestingAPIs {
         let src: &'static [u8] = bun_ast::IntoStr::into_str(utf8str.slice());
         let mut parser = Parser::init(b"<src>", src, env);
 
-        // PORT NOTE: borrowck — `Parser::parse` takes `&'a Arena` (Zig passed
-        // `parser.arena.arena()`); split the borrow via raw ptr so the bump
-        // outlives the `&mut parser` for the call.
+        // Borrowck — `Parser::parse` takes `&'a Arena`; split the borrow via
+        // raw ptr so the bump outlives the `&mut parser` for the call.
         let arena_ptr: *const bun_alloc::Arena = &raw const parser.arena;
         // SAFETY: `parser.arena` is not moved/dropped for the lifetime of `parser`.
         let bump: &bun_alloc::Arena = unsafe { &*arena_ptr };
@@ -228,5 +221,3 @@ impl IniTestingAPIs {
         }
     }
 }
-
-// ported from: src/install_jsc/ini_jsc.zig
diff --git a/src/install_jsc/install_binding.rs b/src/install_jsc/install_binding.rs
index 2a436db92ee..fc382818136 100644
--- a/src/install_jsc/install_binding.rs
+++ b/src/install_jsc/install_binding.rs
@@ -22,7 +22,7 @@ pub mod bun_install_js_bindings {
         obj
     }
 
-    // PORT NOTE: lives at module scope (not in an `impl`) because the
+    // Lives at module scope (not in an `impl`) because the
     // `#[bun_jsc::host_fn]` Free-kind shim body emits `#fn_name(__g, __f)` without
     // a `Self::` qualifier, so the wrapped fn must resolve unqualified.
     #[bun_jsc::host_fn]
@@ -67,11 +67,9 @@ pub mod bun_install_js_bindings {
 
         let mut lockfile_ = Lockfile::default();
 
-        // PORT NOTE: reshaped for borrowck — Zig walked
-        // `globalObject.bunVM().transpiler.resolver` through chained pointer
-        // dereferences. `bun_vm()` returns `*mut VirtualMachine` (raw, mirroring
-        // Zig's `*VirtualMachine`); deref locally so the env-loader fixup and the
-        // package-manager borrow are scoped independently.
+        // `bun_vm()` returns a raw `*mut VirtualMachine`; deref locally so the
+        // env-loader fixup and the package-manager borrow are scoped
+        // independently.
         // SAFETY: `bun_vm()` returns the live VM that owns `global`; this host fn
         // runs on the JS thread so no concurrent `&mut VirtualMachine` exists.
         let vm = global.bun_vm().as_mut();
@@ -102,24 +100,20 @@ pub mod bun_install_js_bindings {
             LoadResult::Ok(_) => {}
         }
 
-        // Zig: `std.fmt.allocPrint("{f}", .{ std.json.fmt(lockfile, .{...}) })` —
-        // drives `Lockfile.jsonStringify` through a `std.json.WriteStream` with
-        // the given options. Port: feed the lockfile through the in-crate
+        // Feed the lockfile through the in-crate
         // `WriteStream` (lockfile_json_stringify_for_debugging.rs) into a
-        // `Vec<u8>`. OOM is `bun.handleOom` in Zig → infallible `Vec` growth here.
+        // `Vec<u8>`.
         let mut w = WriteStream::new(WriteStreamOptions {
             indent: 2,
             emit_null_optional_fields: true,
             emit_nonportable_numbers_as_strings: true,
         });
         // `jsonStringify` only surfaces the underlying writer's error; the
-        // `Vec<u8>` writer is infallible. Zig wraps the whole `allocPrint` in
-        // `bun.handleOom` (crash on the impossible alloc failure) — mirror that
-        // with an `expect` rather than swallowing.
+        // `Vec<u8>` writer is infallible, so `expect` rather than swallowing.
         json_stringify(&lockfile_, &mut w).expect("Vec<u8> JSON writer is infallible");
         let stringified = w.into_bytes();
 
-        // Zig: `defer str.deref()`. `bun_core::String` is `Copy` (no `Drop`),
+        // `bun_core::String` is `Copy` (no `Drop`),
         // so the +1 from `clone_utf8` must be released via `OwnedString`'s RAII
         // — `to_js_by_parse_json` borrows, it does not consume.
         let mut str = OwnedString::new(BunString::clone_utf8(&stringified));
@@ -127,5 +121,3 @@ pub mod bun_install_js_bindings {
         bun_jsc::bun_string_jsc::to_js_by_parse_json(&mut str, global)
     }
 }
-
-// ported from: src/install_jsc/install_binding.zig
diff --git a/src/install_jsc/lib.rs b/src/install_jsc/lib.rs
index 1882fc02176..bf13ed5b6dc 100644
--- a/src/install_jsc/lib.rs
+++ b/src/install_jsc/lib.rs
@@ -4,19 +4,8 @@
 //! `JSValue`/`JSGlobalObject`/`CallFrame` references.
 //!
 //! Host-fn bodies for hosted_git_info / dependency / update_request / npm /
-//! install_binding compile against the `bun_jsc` + `bun_install` surface.
-//! `npm_jsc::js_parse_manifest` body uses `PackageManifest::{name, versions,
-//! string_buf}` from `bun_install::npm`. Remaining gaps are the exact missing
-//! lower-tier symbols (`JSFunction::create` ↔
-//! `#[bun_jsc::host_fn]` shim-name bridge for associated fns,
-//! `bun_bundler::Transpiler` mutable field access via `bun_vm()`,
-//! `bun_resolver::Resolver::get_package_manager`, `bun_ini::load_npmrc` real
-//! signature) and tagged `// TODO(port): bun_X::Y`.
-//!
-//! NOTE: `cargo check -p bun_install_jsc` is currently hard-blocked on
-//! transitive lower-tier compile failures in `bun_css` / `bun_http` /
-//! `bun_js_parser` (via `bun_jsc → bun_bundler`); no edits in this crate can
-//! be cargo-verified until those un-gate.
+//! install_binding compile against the `bun_jsc` + `bun_install` surface and
+//! are wired into the runtime via the `dispatch_js2native` re-exports.
 
 pub mod dependency_jsc;
 pub mod hosted_git_info_jsc;
diff --git a/src/install_jsc/npm_jsc.rs b/src/install_jsc/npm_jsc.rs
index 018c6753444..bfe6efbe1c4 100644
--- a/src/install_jsc/npm_jsc.rs
+++ b/src/install_jsc/npm_jsc.rs
@@ -1,7 +1,5 @@
-//! JSC host fns extracted from `src/install/npm.zig` so that `install/` has
-//! no `JSValue`/`JSGlobalObject`/`CallFrame` references. Each enum keeps a
-//! `pub const jsFunction… = @import(...)` alias so call sites and the
-//! `$newZigFunction("npm.zig", "…")` codegen path are unchanged.
+//! JSC host fns for `bun_install::npm`, kept here so that `install/` has
+//! no `JSValue`/`JSGlobalObject`/`CallFrame` references.
 
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 
@@ -78,7 +76,7 @@ impl ManifestBindings {
     }
 }
 
-// PORT NOTE: lives at module scope (not `impl ManifestBindings`) because the
+// Lives at module scope (not `impl ManifestBindings`) because the
 // `#[bun_jsc::host_fn]` Free-kind shim body emits `#fn_name(__g, __f)` without
 // a `Self::` qualifier, so the wrapped fn must resolve unqualified.
 #[bun_jsc::host_fn]
@@ -106,8 +104,6 @@ pub(crate) fn js_parse_manifest(global: &JSGlobalObject, frame: &CallFrame) -> J
     let registry_str = scopeguard::guard(args[1].to_bun_string(global)?, |s| s.deref());
     let registry = registry_str.to_utf8();
 
-    // PORT NOTE: Zig used `std.fs.cwd().openFile`; PORTING.md bans std::fs, so go
-    // through bun_sys (read-only open).
     let manifest_file = match bun_sys::openat_a(
         bun_sys::Fd::cwd(),
         manifest_filename.slice(),
@@ -124,8 +120,7 @@ pub(crate) fn js_parse_manifest(global: &JSGlobalObject, frame: &CallFrame) -> J
         }
     };
 
-    // PORT NOTE: Zig built a borrowing `bun.URL` struct literal (host/hostname/
-    // href/origin/protocol all slicing `registry`). The Rust `Scope.url` field
+    // The `Scope.url` field
     // is `OwnedURL`, which stores only the href buffer and re-derives components
     // via `URL::parse` on demand. `load_by_file`/`read_all` only consult
     // `scope.url_hash` and `scope.url.href().len()`, so copying the raw href is
@@ -137,20 +132,16 @@ pub(crate) fn js_parse_manifest(global: &JSGlobalObject, frame: &CallFrame) -> J
         ..Default::default()
     };
 
-    let maybe_package_manifest = match npm::package_manifest::Serializer::load_by_file(
-        &scope,
-        // PORT NOTE: Zig wrapped std.fs.File via `bun.sys.File.from(...)`; we already
-        // opened a bun_sys::File above, so pass directly.
-        &manifest_file,
-    ) {
-        Ok(m) => m,
-        Err(err) => {
-            return Err(global.throw(format_args!(
-                "failed to load manifest file: {}",
-                BStr::new(err.name())
-            )));
-        }
-    };
+    let maybe_package_manifest =
+        match npm::package_manifest::Serializer::load_by_file(&scope, &manifest_file) {
+            Ok(m) => m,
+            Err(err) => {
+                return Err(global.throw(format_args!(
+                    "failed to load manifest file: {}",
+                    BStr::new(err.name())
+                )));
+            }
+        };
 
     let package_manifest: npm::PackageManifest = match maybe_package_manifest {
         Some(m) => m,
@@ -191,5 +182,3 @@ pub(crate) fn js_parse_manifest(global: &JSGlobalObject, frame: &CallFrame) -> J
     let mut result = BunString::borrow_utf8(&buf);
     bun_jsc::bun_string_jsc::to_js_by_parse_json(&mut result, global)
 }
-
-// ported from: src/install_jsc/npm_jsc.zig
diff --git a/src/install_jsc/update_request_jsc.rs b/src/install_jsc/update_request_jsc.rs
index 1c064a09436..f2f5380f73c 100644
--- a/src/install_jsc/update_request_jsc.rs
+++ b/src/install_jsc/update_request_jsc.rs
@@ -7,10 +7,8 @@ pub fn from_js(global: &JSGlobalObject, input: JSValue) -> JsResult<JSValue> {
     use bun_install::Subcommand;
     use bun_install::package_manager::update_request::{self, UpdateRequest};
 
-    // PERF(port): was arena bulk-free — profile if hot
-    // PERF(port): was stack-fallback — profile if hot
-    // PORT NOTE: `to_slice_clone` returns `ZigStringSlice`; convert to owned
-    // `Vec<u8>` via `.into_vec()` since the Zig arena is gone.
+    // `to_slice_clone` returns `ZigStringSlice`; convert to owned `Vec<u8>`
+    // via `.into_vec()` since there is no arena backing the slices here.
     let mut all_positionals: Vec<Vec<u8>> = Vec::new();
 
     let mut log = Log::init();
@@ -39,7 +37,6 @@ pub fn from_js(global: &JSGlobalObject, input: JSValue) -> JsResult<JSValue> {
 
     let mut array = update_request::Array::default();
 
-    // PORT NOTE: reshaped for borrowck — build a `&[&[u8]]` view over the owned buffers
     let positionals_view: Vec<&[u8]> = all_positionals.iter().map(|s| s.as_slice()).collect();
 
     let update_requests = match UpdateRequest::parse_with_error(
@@ -92,5 +89,3 @@ pub fn from_js(global: &JSGlobalObject, input: JSValue) -> JsResult<JSValue> {
     );
     Ok(object)
 }
-
-// ported from: src/install_jsc/update_request_jsc.zig
diff --git a/src/install_types/NodeLinker.rs b/src/install_types/NodeLinker.rs
index 9b4e57f9ac1..48003db6c87 100644
--- a/src/install_types/NodeLinker.rs
+++ b/src/install_types/NodeLinker.rs
@@ -1,6 +1,5 @@
-//! Extracted from `install/PackageManager/PackageManagerOptions.zig` so
-//! `options_types/schema.zig`, `cli/bunfig.zig`, and `ini/` can name the
-//! linker mode without depending on the full package manager.
+//! Lets `options_types`, `cli/bunfig`, and `ini/` name the linker mode
+//! without depending on the full package manager.
 
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
@@ -27,11 +26,9 @@ impl NodeLinker {
     }
 }
 
-// ported from: src/install_types/NodeLinker.zig
-
 // ══════════════════════════════════════════════════════════════════════════
 // npm::Registry constants
-// Ground truth: src/install/npm.zig — Registry.default_url / default_url_hash
+// Ground truth: src/install/npm.rs — Registry::DEFAULT_URL / default_url_hash
 // `ini` (T3) and `options_types` need the default registry URL without
 // pulling in the full `bun_install` package manager.
 // ══════════════════════════════════════════════════════════════════════════
@@ -47,8 +44,9 @@ pub mod npm {
 
         /// `bun.Wyhash11.hash(0, strings.withoutTrailingSlash(default_url))`
         /// — i.e. hash of `b"https://registry.npmjs.org"` (no trailing `/`).
-        // TODO(port): once bun_wyhash::Wyhash11::hash is `const fn`, fold this
-        // back to a `pub const`. For now compute on first use.
+        // Computed on use because `bun_wyhash::Wyhash11::hash` is not a
+        // `const fn` (only `Wyhash::hash_const` — a different algorithm —
+        // exists). Cheap and cold; not worth a cached static.
         #[inline]
         pub fn default_url_hash() -> u64 {
             use bun_wyhash::Wyhash11;
@@ -63,16 +61,16 @@ pub mod npm {
 
 // ══════════════════════════════════════════════════════════════════════════
 // PnpmMatcher
-// Ground truth: src/install/PnpmMatcher.zig
+// Ground truth:
 // https://github.com/pnpm/pnpm/blob/3abd3946237aa6ba7831552310ec371ddd3616c2/config/matcher/src/index.ts
 //
 // `ini` (T3) constructs PnpmMatcher from .npmrc `public-hoist-pattern` /
 // `hoist-pattern`. Moved down from `bun_install` so the npmrc loader does not
 // depend on the full package manager.
 //
-// The Zig source calls `jsc.RegularExpression` (tier-6) directly. That edge is
-// broken with link-time `extern "Rust"` (`__bun_regex_*`) defined `#[no_mangle]`
-// in `bun_jsc::regular_expression`.
+// Calling `bun_jsc::RegularExpression` (tier-6) directly would invert the
+// layering; that edge is broken with link-time `extern "Rust"`
+// (`__bun_regex_*`) defined `#[no_mangle]` in `bun_jsc::regular_expression`.
 // ══════════════════════════════════════════════════════════════════════════
 
 use core::ptr::NonNull;
@@ -83,7 +81,7 @@ use bun_core::escape_reg_exp::escape_reg_exp_for_package_name_matching;
 use bun_core::{String as BunString, strings};
 
 // LAYERING: `bun_jsc::RegularExpression` (Yarr FFI) lives in a higher tier.
-// Zig called it inline. The bodies are defined `#[no_mangle]` in
+// The bodies are defined `#[no_mangle]` in
 // `bun_jsc::regular_expression`; declared here as `extern "Rust"` and
 // resolved at link time.
 unsafe extern "Rust" {
@@ -170,19 +168,18 @@ bun_core::named_error_set!(FromExprError);
 
 impl PnpmMatcher {
     // `bun_ast::ExprData` exposes the real value-shaped enum
-    // (`EString`/`EArray` via `StoreRef<E::*>`). `match` arms reconciled
-    // against the arena-taking `E::String::slice` / `Expr::as_string_cloned`
-    // signatures — Zig's `allocator` param maps to a local `bun_alloc::Arena`
-    // (PORTING.md §Allocators: AST=bumpalo) used only for transient UTF-16→UTF-8
-    // transcoding inside `slice`/`string_cloned`.
+    // (`EString`/`EArray` via `StoreRef<E::*>`). The arena-taking
+    // `E::String::slice` / `Expr::as_string_cloned` signatures get a local
+    // `bun_alloc::Arena` (PORTING.md §Allocators: AST=bumpalo) used only for
+    // transient UTF-16→UTF-8 transcoding inside `slice`/`string_cloned`.
     pub fn from_expr(
         expr: &ast::Expr,
         log: &mut bun_ast::Log,
         source: &bun_ast::Source,
     ) -> Result<PnpmMatcher, FromExprError> {
         let mut buf: Vec<u8> = Vec::new();
-        // Scratch arena for `E::String::slice` / `as_string_cloned` (Zig passed
-        // `allocator`). Freed on return; the patterns are consumed by
+        // Scratch arena for `E::String::slice` / `as_string_cloned`.
+        // Freed on return; the patterns are consumed by
         // `create_matcher` before then.
         let arena = Arena::new();
 
@@ -287,9 +284,8 @@ impl PnpmMatcher {
             return false;
         }
 
-        // PORT NOTE: Zig `bun.String.fromBytes(name)`. `from_bytes` not yet on
-        // bun_string surface; package names are ASCII so `borrow_utf8` is an
-        // equivalent zero-copy borrow for the regex match call.
+        // Package names are ASCII, so
+        // `borrow_utf8` is a zero-copy borrow for the regex match.
         let name_str = BunString::borrow_utf8(name);
 
         match self.behavior {
@@ -368,18 +364,16 @@ pub fn create_matcher(raw: &[u8], buf: &mut Vec<u8>) -> Result<Matcher, CreateMa
         });
     }
 
-    // Writer.Allocating can only fail with OutOfMemory; Vec::push aborts on
-    // OOM under the global mimalloc allocator, so the explicit error mapping
-    // from the Zig source collapses. `escape_reg_exp_*` writes through
+    // Vec::push aborts on
+    // OOM under the global mimalloc allocator, so no error mapping is needed.
+    // `escape_reg_exp_*` writes through
     // `io::Write` for `Vec<u8>`, which is infallible.
     buf.push(b'^');
     let _ = escape_reg_exp_for_package_name_matching(trimmed, buf);
     buf.push(b'$');
 
-    // PERF(port): was inline `jsc::RegularExpression.init(.cloneUTF8(buf), .none)`
-    // — now link-time `__bun_regex_compile` (cold path). The Zig source
-    // unconditionally calls `bun.jsc.initialize(false)` before compiling; the
-    // extern impl does the same.
+    // `__bun_regex_compile` is a link-time extern (cold path) and performs
+    // `jsc::initialize(false)` before compiling.
     let regex = compile_regex(BunString::clone_utf8(buf.as_slice()))
         .ok_or(CreateMatcherError::InvalidRegExp)?;
 
@@ -388,5 +382,3 @@ pub fn create_matcher(raw: &[u8], buf: &mut Vec<u8>) -> Result<Matcher, CreateMa
         is_exclude,
     })
 }
-
-// ported from: src/install/PnpmMatcher.zig
diff --git a/src/install_types/resolver_hooks.rs b/src/install_types/resolver_hooks.rs
index 6604abf0f8f..ed456e87c68 100644
--- a/src/install_types/resolver_hooks.rs
+++ b/src/install_types/resolver_hooks.rs
@@ -33,7 +33,7 @@ pub const INVALID_PACKAGE_ID: PackageID = PackageID::MAX;
 pub const INVALID_DEPENDENCY_ID: DependencyID = DependencyID::MAX;
 
 // ─── ExternalSlice ────────────────────────────────────────────────────────
-// MOVE_DOWN of `install/ExternalSlice.zig` — `(off, len)` index pair into a
+// An `(off, len)` index pair into a
 // flat backing buffer (lockfile string-bytes / dependencies / resolutions).
 // Generic over element type; storage is two u32s with a phantom marker.
 
@@ -44,7 +44,7 @@ pub struct ExternalSlice<T> {
     _marker: PhantomData<T>,
 }
 
-// Manual impls: the Zig `extern struct { off: u32, len: u32 }` is unconditionally
+// Manual impls: the `(off, len)` pair is unconditionally
 // copyable/comparable regardless of `Type`. `#[derive]` would add spurious
 // `T: Copy/Clone/Default/PartialEq` bounds via `PhantomData<T>`, breaking
 // by-value `self` methods for non-`Copy` element types (e.g. `Dependency`).
@@ -109,7 +109,7 @@ impl<T> ExternalSlice<T> {
 
     #[inline]
     pub fn get(self, in_: &[T]) -> &[T] {
-        // Zig: `@min(in.len, this.off + this.len)` — compute the sum in usize so
+        // Compute the sum in usize so
         // the release-mode clamp applies instead of a debug u32-overflow panic.
         let end = in_.len().min(self.off as usize + self.len as usize);
         debug_assert!(self.off as usize + self.len as usize <= in_.len());
@@ -164,8 +164,8 @@ pub type ResolutionSlice = ExternalSlice<PackageID>;
 
 pub mod behavior {
     bitflags::bitflags! {
-        /// Port of `install/dependency.zig` `Behavior` (packed u8). Bit 0 and
-        /// bit 7 are reserved (`_unused_1`/`_unused_2` in Zig) so the on-disk
+        /// Bit 0 and
+        /// bit 7 are reserved so the on-disk
         /// lockfile encoding stays byte-compatible.
         #[repr(transparent)]
         #[derive(Default, Clone, Copy, PartialEq, Eq, Hash)]
@@ -183,9 +183,9 @@ pub mod behavior {
 pub use behavior::Behavior;
 
 impl Behavior {
-    /// (name, getter) table mirroring Zig's `@typeInfo(Behavior).@"struct".fields`
-    /// iteration (skipping the leading `_unused_1` and trailing `_unused_2` padding
-    /// bits). Used by debug JSON serialization in place of comptime field reflection.
+    /// (name, getter) table over the named flag bits (skipping the reserved
+    /// bit-0 and bit-7 padding bits). Used by debug JSON serialization in
+    /// place of field reflection.
     pub const NAMED_FLAGS: &'static [(&'static str, fn(&Behavior) -> bool)] = &[
         ("prod", |b| b.contains(Behavior::PROD)),
         ("optional", |b| b.contains(Behavior::OPTIONAL)),
@@ -199,7 +199,7 @@ impl Behavior {
     pub fn is_prod(self) -> bool {
         self.contains(Self::PROD)
     }
-    /// Zig: `optional and !peer` — peer-optionals are reported separately.
+    /// Peer-optionals are reported separately.
     #[inline]
     pub fn is_optional(self) -> bool {
         self.contains(Self::OPTIONAL) && !self.contains(Self::PEER)
@@ -238,13 +238,12 @@ impl Behavior {
         lhs.bits() == rhs.bits()
     }
 
-    /// Zig: `add(this, kind)` — Zig took `@Type(.enum_literal)`; callers pass `Behavior::FLAG`.
     #[inline]
     pub fn add(self, kind: Behavior) -> Behavior {
         self | kind
     }
 
-    /// Renamed from Zig `set` (collides with `bitflags::Flags::set`).
+    /// Named `with` so it doesn't collide with `bitflags::Flags::set`.
     #[inline]
     pub fn with(self, kind: Behavior, value: bool) -> Behavior {
         let mut new = self;
@@ -252,7 +251,7 @@ impl Behavior {
         new
     }
 
-    /// Zig: `Behavior.setOptional(this, value)` — toggles the OPTIONAL bit in place.
+    /// Toggles the OPTIONAL bit in place.
     #[inline]
     pub fn set_optional(&mut self, value: bool) {
         self.set(Behavior::OPTIONAL, value);
@@ -297,9 +296,8 @@ const _: () = assert!(Behavior::DEV.bits() == (1 << 3));
 const _: () = assert!(Behavior::PEER.bits() == (1 << 4));
 const _: () = assert!(Behavior::WORKSPACE.bits() == (1 << 5));
 
-/// Port of `install/dependency.zig` `Version.Tag`.
 #[derive(Default, Clone, Copy, PartialEq, Eq, strum::IntoStaticStr)]
-#[strum(serialize_all = "snake_case")] // match Zig @tagName: "npm"/"dist_tag"/"github"/...
+#[strum(serialize_all = "snake_case")] // "npm"/"dist_tag"/"github"/...
 #[repr(u8)]
 pub enum DependencyVersionTag {
     #[default]
@@ -337,7 +335,7 @@ pub enum DependencyVersionTag {
 // `Semver.String` handle, a `Repository`, or a `Semver.Query.Group` (all
 // lower-tier `bun_semver` data), so the full union is spellable here. Putting
 // the real union in this crate lets the resolver inspect
-// `value.npm.version.is_exact()` directly (Zig: `package_json.zig:926`) and
+// `value.npm.version.is_exact()` directly and
 // round-trip the parsed value through [`AutoInstaller`] without type erasure.
 
 #[derive(Clone, Copy)]
@@ -412,7 +410,7 @@ impl TarballInfo {
     }
 }
 
-/// Port of `install/dependency.zig` `Version.Value` — untagged; discriminant
+/// Untagged union; the discriminant
 /// lives in [`DependencyVersion::tag`]. The `npm` arm owns a `Box` linked list
 /// (`Semver.Query.Group`) and is `ManuallyDrop`-wrapped because the union has
 /// no tag; [`DependencyVersion`]'s `Drop`/`Clone` dispatch on `tag` to free /
@@ -446,7 +444,6 @@ impl Default for DependencyVersionValue {
 
 // No `Clone for DependencyVersionValue`: a tag-blind bitwise clone would double-free `npm`.
 
-/// Port of `install/dependency.zig` `Version`.
 #[repr(C)]
 pub struct DependencyVersion {
     pub tag: DependencyVersionTag,
@@ -512,14 +509,12 @@ impl DependencyVersion {
         Catalog   => catalog: SemverString,   mut catalog_mut;
     }
 
-    /// Zig: `if (version.tag == .npm) version.value.npm else null`.
     #[inline]
     pub fn try_npm(&self) -> Option<&NpmInfo> {
         (self.tag == DependencyVersionTag::Npm).then(|| self.npm())
     }
 
-    /// Port of `dependency_version.value.npm.version.isExact()`
-    /// (resolver/package_json.zig:926). Returns false for non-npm tags.
+    /// Returns false for non-npm tags.
     #[inline]
     pub fn is_exact_npm(&self) -> bool {
         self.try_npm().is_some_and(|n| n.version.is_exact())
@@ -558,7 +553,7 @@ impl Dependency {
     /// "name" must be ASC so that later, when we rebuild the lockfile, we
     /// insert it back in reverse order without an extra sorting pass.
     ///
-    /// MOVE_DOWN of `install/dependency.zig` `isLessThan` so the lockfile
+    /// Lives here so the lockfile
     /// stringifier (`bun.lock.rs`) can sort `&[Dependency]` without an upward
     /// `bun_install` edge or an extension trait.
     pub fn is_less_than(string_buf: &[u8], lhs: &Dependency, rhs: &Dependency) -> bool {
@@ -571,9 +566,8 @@ impl Dependency {
         bun_core::strings::cmp_strings_asc((), lhs_name, rhs_name)
     }
 
-    /// Total-order comparator for `slice::sort_by` (Zig's `std.sort.pdq`
-    /// accepts a strict-weak `lessThan`; Rust's sort requires a full
-    /// `Ordering`). Same key as [`is_less_than`](Self::is_less_than).
+    /// Total-order comparator for `slice::sort_by`. Same key as
+    /// [`is_less_than`](Self::is_less_than).
     pub fn cmp(string_buf: &[u8], lhs: &Dependency, rhs: &Dependency) -> Ordering {
         let behavior = lhs.behavior.cmp(rhs.behavior);
         if behavior != Ordering::Equal {
@@ -584,14 +578,13 @@ impl Dependency {
 }
 
 // ─── npm::{Negatable, OperatingSystem, Libc, Architecture} ────────────────
-// MOVE_DOWN from `bun_install::npm` (port of `install/npm.zig`) so both
+// MOVE_DOWN from `bun_install::npm` so both
 // `bun_resolver` (package.json `os`/`cpu` arrays) and `bun_install` (manifest
 // parsing, lockfile serialization) name the SAME bit-layout. The bit positions
 // are load-bearing — they round-trip through `bun.lock` and the npm manifest
-// cache; the Zig spec starts at `1 << 1` (bit 0 is never set).
+// cache; the bit values start at `1 << 1` (bit 0 is never set).
 
-/// Common shape of [`OperatingSystem`]/[`Architecture`]/[`Libc`] (Zig: `enum(uN)
-/// { none = 0, all = all_value, _ }` open-enum with associated bit consts).
+/// Common shape of [`OperatingSystem`]/[`Architecture`]/[`Libc`].
 pub trait NegatableEnum: Copy + Eq {
     type Int: 'static
         + Copy
@@ -603,7 +596,7 @@ pub trait NegatableEnum: Copy + Eq {
     const NONE: Self;
     const ALL: Self;
     const ALL_VALUE: Self::Int;
-    /// Zig: `ComptimeStringMap.get` — length-gated exact match.
+    /// Length-gated exact match.
     fn lookup_name(key: &[u8]) -> Option<Self::Int>;
     fn name_map_kvs() -> &'static [(&'static [u8], Self::Int)];
     fn has(self, other: Self::Int) -> bool;
@@ -611,7 +604,7 @@ pub trait NegatableEnum: Copy + Eq {
     fn from_raw(n: Self::Int) -> Self;
 }
 
-/// Port of `install/npm.zig` `Negatable(T)` — accumulates an `os`/`cpu`/`libc`
+/// Accumulates an `os`/`cpu`/`libc`
 /// allowlist+blocklist from package.json string arrays, then collapses to a
 /// single bitset via [`combine`](Self::combine).
 #[derive(Clone, Copy)]
@@ -694,9 +687,8 @@ impl<T: NegatableEnum> Negatable<T> {
             return;
         };
 
-        // Zig spec (src/install/npm.zig:551-555): `this.* = .{ .added = …, .removed = … }`
-        // resets `had_wildcard` / `had_unrecognized_values` to their defaults whenever a
-        // recognised token is applied. Match the spec literally so `["any","linux"]`
+        // Applying a recognised token resets `had_wildcard` /
+        // `had_unrecognized_values` to their defaults, so `["any","linux"]`
         // collapses to LINUX (wildcard cleared).
         if is_not {
             *self = Self {
@@ -757,8 +749,7 @@ impl<T: NegatableEnum> Negatable<T> {
     }
 }
 
-/// Zig: `pub fn negatable(this: T) Negatable(T)` — provided as a blanket ext
-/// so each enum doesn't repeat the constructor.
+/// Provided as a blanket ext so each enum doesn't repeat the constructor.
 pub trait NegatableExt: NegatableEnum {
     #[inline]
     fn negatable(self) -> Negatable<Self> {
@@ -775,22 +766,19 @@ impl<T: NegatableEnum> NegatableExt for T {}
 // ─── negatable_names! ─────────────────────────────────────────────────────
 // Single source of truth for the name↔bit table of a `NegatableEnum` newtype.
 //
-// Zig has ONE table per type (`pub const NameMap = bun.ComptimeStringMap(uN, .{...})`,
-// src/install/npm.zig) which comptime-derives BOTH `.kvs` (sorted iteration array,
-// walked by `Negatable.toJson` / bun.lock stringify) AND `.get()` (length-gated lookup).
-// The Rust port had forked that into a hand-maintained `NAME_MAP_KVS` const + a
-// hand-unrolled `lookup_name` match per type — two parallel tables with an
+// A hand-maintained `NAME_MAP_KVS` const + a hand-unrolled `lookup_name`
+// match per type would be two parallel tables with an
 // add-a-variant-forget-the-other drift hazard.
 //
-// This macro restores the single-source property: caller supplies ONE
+// This macro keeps the single-source property: caller supplies ONE
 // `b"name" => BIT` list (already in `(key.len asc, bytewise asc)` order — that
 // order is LOAD-BEARING: `Negatable::to_json` iterates it to serialize bun.lock
-// `"os"/"cpu"/"libc"` arrays and must stay byte-identical with Zig's
-// `precomputed.sorted_kvs`, src/collections/comptime_string_map.zig:21-27,66).
+// `"os"/"cpu"/"libc"` arrays, whose byte order is part of the lockfile
+// output format).
 // The macro then expands BOTH the inherent `NAME_MAP_KVS` const (kept inherent
 // so non-trait callers like `lockfile_json_stringify_for_debugging` still
 // path-qualify it) AND the full `NegatableEnum` impl, whose `lookup_name`
-// length-gates exactly like Zig `ComptimeStringMap.get`: one `usize` compare
+// length-gates the lookup: one `usize` compare
 // per bucket boundary, byte-compare only on length match, early-out once the
 // sorted table passes the requested length. ≤11 entries per type — `phf::Map`
 // would be a hash + indirect load + slice compare for at most 4 candidates.
@@ -861,7 +849,7 @@ impl OperatingSystem {
     pub const CURRENT: Self = Self(Self::FREEBSD);
 
     // NB: NODE not NPM — package.json `os` field uses process.platform values
-    // ("win32"). Also fixes missing Android arm (now "linux", matching Zig).
+    // ("win32").
     pub const CURRENT_NAME: &'static str = bun_core::env::OS_NAME_NODE;
 
     #[inline]
@@ -906,7 +894,7 @@ impl Libc {
 
     pub const ALL_VALUE: u8 = Self::GLIBC | Self::MUSL;
 
-    // TODO: (matches Zig — runtime libc detection)
+    // TODO: runtime libc detection
     pub const CURRENT: Self = Self(Self::GLIBC);
 
     #[inline]
@@ -1056,7 +1044,7 @@ impl Repository {
         builder.count(self.package_name.slice(buf));
     }
 
-    /// Zig `Repository.clone(buf, Builder, builder)` — re-interns each field
+    /// Re-interns each field
     /// into `builder`. Named `clone` so existing `repo.clone(buf, builder)`
     /// call sites resolve; bitwise copy goes through `Copy`/`*repo`.
     pub fn clone<B: bun_semver::StringBuilder>(&self, buf: &[u8], builder: &mut B) -> Repository {
@@ -1084,7 +1072,7 @@ impl Repository {
 }
 
 // ─── VersionedURL ─────────────────────────────────────────────────────────
-// MOVE_DOWN of `install/versioned_url.zig` so `bun_install::resolution::Value`
+// Lives here so `bun_install::resolution::Value`
 // can name the `npm` arm's payload without an upward edge.
 
 pub type VersionedURL = VersionedURLType<u64>;
@@ -1134,7 +1122,6 @@ impl<SemverInt: bun_semver::version::VersionInt> VersionedURLType<SemverInt> {
         builder.count(self.url.slice(buf));
     }
 
-    /// Zig `VersionedURLType.clone(buf, Builder, builder)`.
     pub fn clone<B: bun_semver::StringBuilder>(&self, buf: &[u8], builder: &mut B) -> Self {
         Self {
             version: self.version.append(buf, builder),
@@ -1155,7 +1142,6 @@ impl VersionedURLType<u32> {
 
 // ─── Resolution ───────────────────────────────────────────────────────────
 
-/// Port of `install/resolution.zig` `Resolution.Tag`.
 #[derive(Clone, Copy, PartialEq, Eq, Default)]
 #[repr(u8)]
 pub enum ResolutionTag {
@@ -1173,7 +1159,7 @@ pub enum ResolutionTag {
     SingleFileModule = 100,
 }
 
-/// Port of `install/resolution.zig` `Resolution.Value` (extern union). Every
+/// Every
 /// payload is `()`, a `Semver.String` handle, a [`Repository`], or a
 /// [`VersionedURLType`] — all lower-tier `bun_semver` data, so the real union
 /// lives here (not an opaque `[u64; N]`). `bun_install::resolution` re-exports
@@ -1201,8 +1187,8 @@ impl<I: VersionInt> Default for ResolutionValue<I> {
     }
 }
 
-/// Port of `install/resolution.zig` `Resolution` (= `ResolutionType(u64)`).
-/// Layout matches Zig `extern struct { tag: u8, _pad: [7]u8, value: Value }`.
+/// Layout is `{ tag: u8, _pad: [7]u8, value: Value }` so the on-disk lockfile
+/// encoding stays byte-compatible.
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct Resolution {
@@ -1232,7 +1218,7 @@ impl Resolution {
 
 // ─── PreinstallState / Features / misc ────────────────────────────────────
 
-#[repr(u8)] // Zig: enum(u4); u8 is the smallest repr Rust allows
+#[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum PreinstallState {
     Unknown = 0,
@@ -1274,32 +1260,26 @@ impl Default for Features {
 }
 
 impl Features {
-    /// Zig: `Features.main` decl-literal (src/install/install.zig).
     #[inline]
     pub const fn main() -> Self {
         Self::MAIN
     }
-    /// Zig: `Features.npm` decl-literal.
     #[inline]
     pub const fn npm() -> Self {
         Self::NPM
     }
-    /// Zig: `Features.folder` decl-literal.
     #[inline]
     pub const fn folder() -> Self {
         Self::FOLDER
     }
-    /// Zig: `Features.workspace` decl-literal.
     #[inline]
     pub const fn workspace() -> Self {
         Self::WORKSPACE
     }
-    /// Zig: `Features.link` decl-literal.
     #[inline]
     pub const fn link() -> Self {
         Self::LINK
     }
-    /// Zig: `Features.tarball` decl-literal.
     #[inline]
     pub const fn tarball() -> Self {
         Self::TARBALL
@@ -1377,10 +1357,10 @@ pub struct TaskCallbackContext {
     pub root_request_id: u32,
 }
 
-/// Port of `install.zig` `PackageManager.WakeHandler` — opaque
+/// Opaque
 /// (ctx-ptr + 2 fn-ptrs) handle the runtime installs to nudge the JS event
 /// loop when a network task completes. The resolver only stores and forwards
-/// it; the fields are `Option` so `Default` is all-None (Zig: `.{ }`).
+/// it; the fields are `Option` so `Default` is all-None.
 ///
 /// `handler`'s second parameter (`*PackageManager`) is erased to
 /// `*mut c_void` because that concrete type lives in `bun_install` (a higher
@@ -1392,9 +1372,7 @@ pub struct TaskCallbackContext {
 #[derive(Default, Copy, Clone)]
 pub struct WakeHandler {
     pub context: Option<NonNull<c_void>>,
-    /// Zig: `fn(ctx: *anyopaque, pm: *PackageManager) void`.
     pub handler: Option<fn(*mut c_void, *mut c_void)>,
-    /// Zig: `fn(ctx: *anyopaque, dep: Dependency, dep_id: DependencyID, err: anyerror) void`.
     pub on_dependency_error:
         Option<unsafe fn(*mut c_void, &Dependency, DependencyID, bun_core::Error)>,
 }
@@ -1402,20 +1380,20 @@ pub struct WakeHandler {
 impl WakeHandler {
     #[inline]
     pub fn get_handler(&self) -> fn(*mut c_void, *mut c_void) {
-        // SAFETY: handler is always set before context per VirtualMachine.zig:1162
+        // `handler` is Some whenever `context` is Some: the sole installer
+        // (runtime::jsc_hooks) sets `context`, `handler`, and
+        // `on_dependency_error` together in one struct literal, and callers
+        // gate on `context.is_some()` before invoking — so this unwrap cannot
+        // fire.
         self.handler.unwrap()
     }
 
-    /// Zig: `getonDependencyError` (sic — the missing underscore is a Zig
-    /// typo; the port uses idiomatic snake_case so the cross-crate caller
-    /// `bun_install::PackageManager::fail_root_resolution` links).
     #[inline]
     pub fn get_on_dependency_error(
         &self,
     ) -> unsafe fn(*mut c_void, &Dependency, DependencyID, bun_core::Error) {
-        // PORT NOTE: Zig casts `t.handler` (the wrong field) to the dep-error fn type — this is
-        // a Zig bug. The port reads `on_dependency_error` instead; preserving the bug would
-        // require an unsound transmute between fn-pointer signatures.
+        // Same invariant as `get_handler`: set together with `context` by the
+        // sole installer; callers gate on `context.is_some()`.
         self.on_dependency_error.unwrap()
     }
 }
@@ -1469,8 +1447,7 @@ impl DependencyGroup {
     pub const FOUR: [Self; 4] = [Self::DEPENDENCIES, Self::DEV, Self::OPTIONAL, Self::PEER];
 
     /// Reverse map a [`Behavior`] back to the package.json section key. Tests
-    /// dev → optional → peer → prod (Zig: `update_interactive_command.zig`
-    /// `dep.behavior.isDev()` chain); falls through to `"dependencies"` for
+    /// dev → optional → peer → prod; falls through to `"dependencies"` for
     /// PROD/WORKSPACE/BUNDLED/empty.
     #[inline]
     pub fn prop_for_behavior(b: Behavior) -> &'static [u8] {
@@ -1582,9 +1559,9 @@ pub trait AutoInstaller {
         behavior: Behavior,
     ) -> EnqueueResult;
 
-    // ── Dependency parsing (install/dependency.zig) ───────────────────────
+    // ── Dependency parsing ─────────────────────────────────────────────────
     // `&mut self`: `parse_with_tag` records `npm:`-aliased deps into
-    // `pm.known_npm_aliases` (dependency.zig:905), so the impl needs a
+    // `pm.known_npm_aliases`, so the impl needs a
     // mutable manager handle even though parsing is otherwise pure.
     fn parse_dependency(
         &mut self,
@@ -1603,7 +1580,7 @@ pub trait AutoInstaller {
         sliced: &bun_semver::SlicedString,
         log: Option<&mut bun_ast::Log>,
     ) -> Option<DependencyVersion>;
-    /// Port of `dependency.zig` `Version.Tag.infer` — pure string
+    /// Pure string
     /// classification, but the table lives in `bun_install`.
     fn infer_dependency_tag(&self, dependency: &[u8]) -> DependencyVersionTag;
 }
diff --git a/src/io/MaxBuf.rs b/src/io/MaxBuf.rs
index 4de05a7a428..6158f8e87bb 100644
--- a/src/io/MaxBuf.rs
+++ b/src/io/MaxBuf.rs
@@ -137,5 +137,3 @@ pub enum Kind {
     Stdout,
     Stderr,
 }
-
-// ported from: src/io/MaxBuf.zig
diff --git a/src/io/ParentDeathWatchdog.rs b/src/io/ParentDeathWatchdog.rs
index bdcf10852c3..663d34e6e9a 100644
--- a/src/io/ParentDeathWatchdog.rs
+++ b/src/io/ParentDeathWatchdog.rs
@@ -55,9 +55,8 @@ pub struct ParentDeathWatchdog;
 /// convention for "terminated because the controlling end went away".
 pub const EXIT_CODE: u8 = 128 + 1;
 
-// PORT NOTE: Zig used plain `var` globals (unsynchronized). Converted to
-// atomics/OnceLock per docs/PORTING.md §Global mutable state — same
-// single-writer-at-startup discipline, but no `static mut` aliasing.
+// Atomics/OnceLock with single-writer-at-startup discipline (see
+// docs/PORTING.md §Global mutable state).
 static ENABLED: AtomicBool = AtomicBool::new(false);
 static ORIGINAL_PPID: core::sync::atomic::AtomicI32 = core::sync::atomic::AtomicI32::new(0);
 
@@ -136,7 +135,7 @@ pub fn pop_sync_pgid() {
 /// Scoped to the `spawnSync` script(s) — does NOT call `kill_descendants()`,
 /// which is rooted at `getpid()` and would take out unrelated `Bun.spawn`
 /// siblings when `spawnSync` is reached from inside a live VM (e.g.
-/// `ffi.zig:getSystemRootDirOnce` shelling out to `xcrun`).
+/// FFI's system-root-dir lookup shelling out to `xcrun`).
 pub fn kill_sync_script_tree() {
     #[cfg(unix)]
     {
@@ -165,7 +164,6 @@ fn kill_sync_pgroups_and_descendants() {
     }
 }
 
-// TODO(port): move to <aio>_sys
 #[cfg(target_os = "macos")]
 unsafe extern "C" {
     // safe: no args; no preconditions.
@@ -348,8 +346,8 @@ pub fn install_on_event_loop(handle: EventLoopCtx) {
     }
 }
 
-/// `FilePoll.Owner` dispatch target — see the `ParentDeathWatchdog` arm in
-/// `posix_event_loop.zig`'s `onUpdate`. The kqueue `NOTE_EXIT` for our parent
+/// `FilePoll.Owner` dispatch target — invoked from the event loop's
+/// `ParentDeathWatchdog` poll arm. The kqueue `NOTE_EXIT` for our parent
 /// fired.
 pub fn on_parent_exit(_this: &mut ParentDeathWatchdog) {
     // Global.exit → Bun__onExit → on_process_exit → kill_descendants.
@@ -532,10 +530,6 @@ fn kill_tree_rooted_at(root: libc::pid_t, expected_ppid_of_root: libc::pid_t) {
     to_kill.push(root);
     let _ = to_visit.try_reserve(1);
     to_visit.push(root);
-    // PORT NOTE: Zig swallowed OOM on the to_visit push; Rust push() after a
-    // failed try_reserve would still attempt (and abort on OOM). In practice
-    // a 1-element reserve never fails; matching exact Zig OOM semantics is
-    // not worth the complexity here.
 
     let mut buf: [libc::pid_t; 4096] = [0; 4096];
     while !to_visit.is_empty() && to_kill.len() < 4096 {
@@ -680,7 +674,7 @@ fn list_child_pids_linux(parent: libc::pid_t, out: &mut [libc::pid_t]) -> Option
         let mut w = &mut path_buf[..];
         write!(w, "/proc/{}/task", parent).ok()?;
         let n = 64 - w.len();
-        // PORT NOTE: reshaped for borrowck — recompute slice after write.
+        // Reshaped for borrowck — recompute slice after write.
         &path_buf[..n]
     };
 
@@ -688,7 +682,7 @@ fn list_child_pids_linux(parent: libc::pid_t, out: &mut [libc::pid_t]) -> Option
         Ok(fd) => fd,
         Err(_) => return None,
     };
-    // PORT NOTE: Zig `defer task_fd.close()`; `Fd` is Copy and does not impl Drop.
+    // `Fd` is Copy and does not impl Drop, so close explicitly via a guard.
     let _task_fd_guard = scopeguard::guard(task_fd, |fd| {
         let _ = bun_sys::close(fd);
     });
@@ -699,7 +693,6 @@ fn list_child_pids_linux(parent: libc::pid_t, out: &mut [libc::pid_t]) -> Option
     let mut read_buf = [0u8; 32 * 1024];
     let mut it = bun_sys::dir_iterator::iterate(task_fd);
     loop {
-        // `it.next()` → `Maybe(?Entry)`; `.unwrap() catch null` → error/None both stop.
         let entry = match it.next() {
             Ok(Some(e)) => e,
             _ => break,
@@ -749,8 +742,8 @@ fn read_file_once<'a>(path: &ZStr, buf: &'a mut [u8]) -> Option<&'a [u8]> {
     let _guard = scopeguard::guard(fd, |fd| {
         let _ = bun_sys::close(fd);
     });
-    // Zig `file.readAll(buf)` — fixed-buffer read-until-EOF-or-full. The Rust
-    // `File::read_all` grows a `Vec`, which would allocate; do the loop here.
+    // Fixed-buffer read-until-EOF-or-full. `File::read_all` grows a `Vec`,
+    // which would allocate; do the loop here.
     let mut written = 0usize;
     while written < buf.len() {
         match bun_sys::read(fd, &mut buf[written..]) {
@@ -761,5 +754,3 @@ fn read_file_once<'a>(path: &ZStr, buf: &'a mut [u8]) -> Option<&'a [u8]> {
     }
     Some(&buf[..written])
 }
-
-// ported from: src/aio/ParentDeathWatchdog.zig
diff --git a/src/io/PipeReader.rs b/src/io/PipeReader.rs
index 37f31e8d0b0..a47f42f31dd 100644
--- a/src/io/PipeReader.rs
+++ b/src/io/PipeReader.rs
@@ -35,27 +35,23 @@ use bun_sys::windows::libuv as uv;
 // scope so method resolution finds them on `Pipe`/`uv_tty_t`/`fs_t`.
 use bun_sys::windows::libuv::UvHandle as _;
 
-// PipeReader.zig declares no `Output.scoped(.PipeReader, …)` scope; all logging
-// goes through `bun.sys.syslog` (the `SYS` scope) or `libuv::log!`.
+// All logging in this module goes through `bun.sys.syslog` (the `SYS` scope)
+// or `libuv::log!`.
 
 // ──────────────────────────────────────────────────────────────────────────
 // BufferedReaderVTable
 // ──────────────────────────────────────────────────────────────────────────
 
-// This is a runtime type instead of comptime due to bugs in Zig.
-// https://github.com/ziglang/zig/issues/18664
 pub struct BufferedReaderVTable {
     pub parent: *mut c_void,
     pub kind: crate::BufferedReaderParentLinkKind,
 }
 
 /// Trait that parent types implement to receive buffered-reader callbacks.
-/// Mirrors the duck-typed `Type.onReaderDone` / `Type.onReaderError` etc. in Zig.
 ///
 /// ## Aliasing contract (raw `*mut Self`, not `&mut self`)
 ///
-/// In the Zig spec these thunks receive `*anyopaque`, cast to `*Type`, and call
-/// the decl — Zig pointers freely alias. In Rust the parent `Self` *contains*
+/// The parent `Self` *contains*
 /// the `BufferedReader` as a field, and these callbacks are invoked from inside
 /// `BufferedReader` methods that hold a live `&mut BufferedReader`. Taking
 /// `&mut self` here would therefore materialize a `&mut Self` overlapping that
@@ -153,7 +149,7 @@ pub struct PosixBufferedReader {
     pub vtable: BufferedReaderVTable,
     pub flags: PosixFlags,
     pub count: usize,
-    // PORT NOTE: MaxBuf uses hand-rolled dual-ownership (Subprocess + reader) via
+    // MaxBuf uses hand-rolled dual-ownership (Subprocess + reader) via
     // `add_to_pipereader`/`remove_from_pipereader`, not Arc — see MaxBuf.rs.
     pub maxbuf: Option<NonNull<MaxBuf>>,
 }
@@ -175,7 +171,6 @@ bitflags::bitflags! {
 }
 
 impl PosixFlags {
-    /// Zig default: `.{ .close_handle = true }`
     pub const fn new() -> Self {
         PosixFlags::CLOSE_HANDLE
     }
@@ -223,12 +218,11 @@ impl PosixBufferedReader {
             count: 0,
             maxbuf: None,
         };
-        // PORT NOTE: `other.buffer().* = init(default_allocator)` and
-        // `other.handle = .closed` handled by mem::replace/mem::take above.
         other.flags.insert(PosixFlags::IS_DONE);
         other._offset = 0;
         MaxBuf::transfer_to_pipereader(&mut other.maxbuf, &mut self.maxbuf);
-        // PORT NOTE: reshaped for borrowck — capture *mut Self before borrowing field.
+        // Capture *mut Self before borrowing `handle` so the owner pointer
+        // doesn't conflict with the field borrow.
         let owner = std::ptr::from_mut(self).cast::<c_void>();
         self.handle
             .set_owner(Owner::new(PollTag::BufferedReader, owner.cast()));
@@ -239,7 +233,8 @@ impl PosixBufferedReader {
 
     pub fn set_parent(&mut self, parent: *mut c_void) {
         self.vtable.parent = parent;
-        // PORT NOTE: reshaped for borrowck — capture *mut Self before borrowing field.
+        // Capture *mut Self before borrowing `handle` so the owner pointer
+        // doesn't conflict with the field borrow.
         let owner = std::ptr::from_mut(self).cast::<c_void>();
         self.handle
             .set_owner(Owner::new(PollTag::BufferedReader, owner.cast()));
@@ -272,7 +267,7 @@ impl PosixBufferedReader {
     }
 
     /// Explicit teardown that does **not** fire `on_reader_done` (unlike
-    /// [`close`]). Mirrors Zig `PosixBufferedReader.deinit`. Safe to call
+    /// [`close`]). Safe to call
     /// before Drop; both paths are idempotent over an already-released handle.
     pub fn deinit(&mut self) {
         MaxBuf::remove_from_pipereader(&mut self.maxbuf);
@@ -329,8 +324,8 @@ impl PosixBufferedReader {
     pub fn final_buffer(&mut self) -> &mut Vec<u8> {
         if self.flags.contains(PosixFlags::MEMFD) {
             if let PollOrFd::Fd(fd) = self.handle {
-                // PORT NOTE: Zig `defer this.handle.close(null, {})` — close after
-                // the read regardless of result. `self.handle` owns the fd;
+                // The handle is closed after the read regardless of result.
+                // `self.handle` owns the fd;
                 // borrow a non-owning `File` view so the temporary doesn't
                 // close it on drop (handle.close() below does).
                 let result = sys::File::borrow(&fd)
@@ -403,7 +398,7 @@ impl PosixBufferedReader {
     }
 
     pub fn register_poll(&mut self) {
-        // PORT NOTE: reshaped for borrowck — hoist vtable-derived scalars and
+        // Hoist vtable-derived scalars and
         // normalize self.handle to Poll before taking the single &mut borrow,
         // so no raw-pointer escape is needed.
         let ev = self.vtable.event_loop();
@@ -539,7 +534,7 @@ impl PosixBufferedReader {
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — takes &vtable instead of &mut Self so
+    // Takes &vtable instead of &mut Self so
     // call sites can pass &parent._buffer alongside without a raw-pointer escape.
     #[inline]
     fn drain_chunk(vtable: &BufferedReaderVTable, chunk: &[u8], has_more: ReadState) -> bool {
@@ -599,9 +594,6 @@ impl PosixBufferedReader {
         );
     }
 
-    // PORT NOTE: reshaped for borrowck — `resizable_buffer` is no longer passed
-    // separately; functions access `parent._buffer` directly. In Zig the buffer
-    // pointer was always `parent.buffer()` anyway.
     fn read_blocking_pipe(
         parent: &mut PosixBufferedReader,
         fd: Fd,
@@ -710,7 +702,6 @@ impl PosixBufferedReader {
                             }
 
                             if streaming {
-                                // PORT NOTE: reshaped for borrowck — re-slice from _buffer.
                                 let new_len = parent._buffer.len();
                                 let chunk = &parent._buffer[new_len - bytes_read..new_len];
                                 if !parent.vtable.on_read_chunk(
@@ -789,9 +780,8 @@ impl PosixBufferedReader {
         }
     }
 
-    // PERF(port): `file_type` and `sys_fn` were comptime in Zig (monomorphization).
-    // adt_const_params is unstable, so `file_type` is a runtime arg; `sys_fn` is
-    // generic so it still monomorphizes — profile if hot.
+    // PERF: `file_type` is a runtime arg (adt_const_params is unstable); `sys_fn`
+    // is generic so it still monomorphizes — profile if hot.
     fn read_with_fn(
         parent: &mut PosixBufferedReader,
         file_type: FileType,
@@ -860,7 +850,7 @@ impl PosixBufferedReader {
 
                             // Keep reading as much as we can
                             if (stack_buffer_len - head_start) < stack_buffer_cutoff {
-                                // PORT NOTE: `&& !received_hup` mirrors the
+                                // `&& !received_hup` mirrors the
                                 // after-inner-loop flush below (line ~855).
                                 // Without it, a peer close (HUP) with >cutoff
                                 // bytes still buffered makes a parent that
@@ -868,10 +858,8 @@ impl PosixBufferedReader {
                                 // `PipeReader::on_read_chunk`) early-return
                                 // here with data left in the kernel and no
                                 // `register_poll`/`done()` → 90s hang in
-                                // shell-blocking-pipe.test.ts. The Zig spec
-                                // has the same asymmetry (PipeReader.zig:605)
-                                // but the Rust port hits the timing window
-                                // far more often; once HUP is set the kernel
+                                // shell-blocking-pipe.test.ts.
+                                // Once HUP is set the kernel
                                 // returns the remaining bytes then 0, so
                                 // draining to `bytes_read == 0` is bounded.
                                 if !parent.vtable.on_read_chunk(
@@ -1015,7 +1003,6 @@ impl PosixBufferedReader {
 
                     if parent.vtable.is_streaming_enabled() {
                         if parent._buffer.len() > 128_000 {
-                            // PORT NOTE: `defer resizable_buffer.clearRetainingCapacity()` inlined below.
                             let keep_going = parent
                                 .vtable
                                 .on_read_chunk(&parent._buffer, ReadState::Progress);
@@ -1066,11 +1053,11 @@ impl PosixBufferedReader {
 
         Self::read_blocking_pipe(parent, fd, size_hint, received_hup);
     }
-
-    // PORT NOTE: `comptime { bun.meta.banFieldType(@This(), bool); }` dropped —
-    // bitflags! ensures bools are packed.
 }
 
+// Keep boolean state in the `PosixFlags` bitflags field — no loose `bool`
+// fields on `PosixBufferedReader`.
+
 impl Drop for PosixBufferedReader {
     fn drop(&mut self) {
         MaxBuf::remove_from_pipereader(&mut self.maxbuf);
@@ -1116,7 +1103,6 @@ bitflags::bitflags! {
 }
 
 impl WindowsFlags {
-    /// Zig default: `.{ .close_handle = true, .is_paused = true }`
     pub const fn new() -> Self {
         Self::from_bits_truncate(WindowsFlags::CLOSE_HANDLE.bits() | WindowsFlags::IS_PAUSED.bits())
     }
@@ -1151,7 +1137,7 @@ impl WindowsBufferedReader {
 
     pub fn from(&mut self, other: &mut WindowsBufferedReader, parent: *mut c_void) {
         debug_assert!(other.source.is_some() && self.source.is_none());
-        // PORT NOTE: keep self.vtable; move other's state in.
+        // Keep self.vtable; move other's state in.
         self.flags = other.flags;
         self._buffer = mem::take(other.buffer());
         self._offset = other._offset;
@@ -1160,11 +1146,9 @@ impl WindowsBufferedReader {
         other.flags.insert(WindowsFlags::IS_DONE);
         other._offset = 0;
         // other._buffer / other.source already cleared by mem::take above.
-        // Zig spec (PipeReader.zig:825-831) re-inits `to.*` with a struct literal,
-        // which resets every unlisted field — including `maxbuf` — to its default
-        // (`null`) BEFORE `transferToPipereader`. The field-by-field assigns above
-        // leave `self.maxbuf` untouched, so drop any prior owner-count first to
-        // avoid leaking a MaxBuf ref when the destination already held one.
+        // The field-by-field assigns above leave `self.maxbuf` untouched, so
+        // drop any prior owner-count first to avoid leaking a MaxBuf ref when
+        // the destination already held one.
         MaxBuf::remove_from_pipereader(&mut self.maxbuf);
         MaxBuf::transfer_to_pipereader(&mut other.maxbuf, &mut self.maxbuf);
         self.set_parent(parent);
@@ -1505,7 +1489,6 @@ impl WindowsBufferedReader {
                     return;
                 }
 
-                // PORT NOTE: defer block inlined after body — see below.
                 let len: usize = usize::try_from(nread_int).expect("int cast");
                 this._offset += len;
                 // we got some data lets get the current iov
@@ -1514,8 +1497,7 @@ impl WindowsBufferedReader {
                 // *and* a slice borrowed from `self.source.File.iov`; under
                 // Stacked Borrows that's a self-mut + field-shared conflict.
                 // The boxed `File` lives in its own heap allocation, so a
-                // `*mut File` snapshot is provenance-disjoint from `&mut self`
-                // — same as the Zig `*File` pointer the original kept.
+                // `*mut File` snapshot is provenance-disjoint from `&mut self`.
                 let file_raw: *mut crate::source::File = match this.source.as_mut() {
                     Some(Source::File(f)) => f.as_mut() as *mut _,
                     _ => core::ptr::null_mut(),
@@ -1535,8 +1517,7 @@ impl WindowsBufferedReader {
                     );
                 }
 
-                // PORT NOTE: this is the Zig `defer { ... }` body, inlined after the body
-                // because both body paths fall through (void return).
+                // Shared epilogue: both body paths above fall through here.
                 // if we are not paused we keep reading until EOF or err
                 if !this.flags.contains(WindowsFlags::IS_PAUSED) {
                     // Re-snapshot — `on_read` may have mutated `this.source`.
@@ -1574,10 +1555,9 @@ impl WindowsBufferedReader {
                                     Some(Self::on_file_read),
                                 )
                             }
-                            // PORT NOTE: Zig PipeReader.zig:1113 tags this `.write` even
-                            // though the syscall is `uv_fs_read` (a Zig bug). Match the
-                            // spec for now so user-visible `error.syscall` stays
-                            // bit-identical; fix upstream in Zig first.
+                            // Tagged `.write` even though the syscall is
+                            // `uv_fs_read`, so user-visible `error.syscall`
+                            // stays bit-identical with previous releases.
                             .to_error(sys::Tag::write)
                             {
                                 file.complete(false);
@@ -1647,10 +1627,9 @@ impl WindowsBufferedReader {
                         Some(Self::on_file_read),
                     )
                 }
-                // PORT NOTE: Zig PipeReader.zig:1163 tags this `.write` even though the
-                // syscall is `uv_fs_read` (a Zig bug). Match the spec for now so
-                // user-visible `error.syscall` stays bit-identical; fix upstream in
-                // Zig first.
+                // Tagged `.write` even though the syscall is `uv_fs_read`, so
+                // user-visible `error.syscall` stays bit-identical with
+                // previous releases.
                 .to_error(sys::Tag::write)
                 {
                     file.complete(false);
@@ -1669,9 +1648,8 @@ impl WindowsBufferedReader {
                 }
                 .to_error(sys::Tag::open)
                 {
-                    // Zig spec PipeReader.zig:1171 routes through
-                    // `bun.windows.libuv.log` (the `uv` debug scope, toggled by
-                    // `BUN_DEBUG_uv=1`), not `SYS`.
+                    // Routed through `bun.windows.libuv.log` (the `uv` debug
+                    // scope, toggled by `BUN_DEBUG_uv=1`), not `SYS`.
                     bun_sys::windows::libuv::log!(
                         "uv_read_start() = {}",
                         bstr::BStr::new(err.name()),
@@ -1786,7 +1764,7 @@ impl WindowsBufferedReader {
     }
 
     /// Explicit teardown that does **not** fire `on_reader_done` (unlike
-    /// [`close`]). Mirrors Zig `WindowsBufferedReader.deinit`. Safe to call
+    /// [`close`]). Safe to call
     /// before Drop; both paths are idempotent over an already-taken source.
     pub fn deinit(&mut self) {
         MaxBuf::remove_from_pipereader(&mut self.maxbuf);
@@ -1796,18 +1774,16 @@ impl WindowsBufferedReader {
         };
         if !source.is_closed() {
             // closeImpl will take care of freeing the source.
-            // PORT NOTE: Zig nulls `source` *before* calling closeImpl, which
-            // makes that call a no-op (latent Zig leak). We cannot mirror that
-            // verbatim: in Zig nulling a `?*Pipe` leaks; in Rust dropping
-            // `Box<Pipe>` frees a uv_pipe_t still linked into the loop's
-            // handle queue → UAF. Restore the source so close_impl can do the
-            // proper take + hand-off to libuv (into_raw + uv_close).
+            // Dropping the `Box<Pipe>` here would free a uv_pipe_t still
+            // linked into the loop's handle queue → UAF. Restore the source so
+            // close_impl can do the proper take + hand-off to libuv
+            // (into_raw + uv_close).
             self.source = Some(source);
             self.close_impl::<false>();
         } else {
             // Already closing/closed: a uv close callback may still be pending
-            // on this allocation. Zig leaks here (pointer nulled, no dtor);
-            // match that — dropping the Box would free memory libuv still owns.
+            // on this allocation; dropping the Box would free memory libuv
+            // still owns, so leak it instead.
             core::mem::forget(source);
         }
     }
@@ -1865,15 +1841,11 @@ impl WindowsBufferedReader {
 
         let should_continue = self._on_read_chunk(slice, has_more);
 
-        // PORT NOTE: Spec parents that stream (IOReader.zig:161,
-        // shell/subproc.zig:1230) call `this.reader.startWithCurrentPipe()`
-        // from inside their `onReadChunk` callback on Windows. The Rust
-        // shell IOReader port cannot re-derive `&mut Self` from inside the
-        // vtable callback (Stacked-Borrows; see shell/IOReader.rs PORT NOTE),
-        // so the call is omitted there. The re-arm half of that call is
-        // already handled by `on_file_read`'s defer block / `uv_read_start`,
-        // but its other side effect — `buffer().clearRetainingCapacity()`
-        // (PipeReader.zig:949) — is load-bearing: without it `_buffer.len`
+        // Streaming parents (shell IOReader, subprocess) cannot re-derive
+        // `&mut Self` from inside the vtable callback to restart the pipe
+        // (Stacked-Borrows; see the comment in shell/IOReader.rs). The re-arm
+        // is already handled by `on_file_read`'s epilogue / `uv_read_start`,
+        // but clearing the buffer here is load-bearing: without it `_buffer.len`
         // grows by `amount_result` every chunk and never resets, so a 1 GB
         // `cat` holds 1 GB resident instead of ~64 KB. Clear it here, after
         // the streaming consumer has finished with `slice`.
@@ -1898,11 +1870,11 @@ impl WindowsBufferedReader {
         // we cannot sync read pipes on Windows so we just check if we are paused to resume the reading
         self.unpause();
     }
-
-    // PORT NOTE: `comptime { bun.meta.banFieldType(WindowsBufferedReader, bool); }` dropped —
-    // bitflags! ensures bools are packed.
 }
 
+// Keep boolean state in the `WindowsFlags` bitflags field — no loose `bool`
+// fields on `WindowsBufferedReader`.
+
 #[cfg(windows)]
 impl Drop for WindowsBufferedReader {
     fn drop(&mut self) {
@@ -1910,11 +1882,10 @@ impl Drop for WindowsBufferedReader {
         // Do NOT take() source here and let it drop: Box<Pipe>/Box<File> own
         // live uv handles registered with the loop. Let close_impl perform the
         // take + into_raw hand-off so the uv close callback reclaims them.
-        // PORT NOTE: Zig `WindowsBufferedReader.deinit` (PipeReader.zig:979)
-        // skips closeImpl when `source.isClosed()` — a uv_close is already
-        // pending on that allocation, so closing again would double-close and
-        // freeing the Box would UAF the handle libuv still references. Mirror
-        // deinit(): leak the already-closing handle (Zig parity).
+        // Skip close_impl when the source is already closed — a uv_close is
+        // already pending on that allocation, so closing again would
+        // double-close and freeing the Box would UAF the handle libuv still
+        // references. Same as deinit(): leak the already-closing handle.
         if let Some(source) = self.source.take() {
             if !source.is_closed() {
                 self.source = Some(source);
@@ -1936,5 +1907,3 @@ pub type BufferedReader = PosixBufferedReader;
 pub type BufferedReader = WindowsBufferedReader;
 #[cfg(not(any(unix, windows)))]
 compile_error!("Unsupported platform");
-
-// ported from: src/io/PipeReader.zig
diff --git a/src/io/PipeWriter.rs b/src/io/PipeWriter.rs
index e9847356024..2e53891c22f 100644
--- a/src/io/PipeWriter.rs
+++ b/src/io/PipeWriter.rs
@@ -22,13 +22,6 @@ use crate::source::Source;
 
 bun_core::define_scoped_log!(log, PipeWriter, hidden);
 
-// TODO(port): bun_sys::Error::oom — `oom()` is a private free fn in
-// `bun_sys::error`; promote to assoc fn or re-export, then drop this shim.
-#[inline]
-fn oom_err() -> sys::Error {
-    sys::Error::from_code(sys::E::ENOMEM, sys::Tag::write)
-}
-
 // ──────────────────────────────────────────────────────────────────────────
 // WriteResult / WriteStatus
 // ──────────────────────────────────────────────────────────────────────────
@@ -52,16 +45,13 @@ pub enum WriteStatus {
 // PosixPipeWriter
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `fn PosixPipeWriter(comptime This, getFd, getBuffer, onWrite, registerPoll, onError, _, getFileType) type`
-///
-/// Originally this was a comptime vtable struct. In Rust the comptime fn pointers
-/// become required trait methods on `Self`, and the returned struct's fns become
-/// provided trait methods.
+/// The hooks a writer supplies are the required trait methods; the shared
+/// write machinery is the provided trait methods.
 pub trait PosixPipeWriter {
     fn get_fd(&self) -> Fd;
     fn get_buffer(&self) -> &[u8];
     fn on_write(&mut self, written: usize, status: WriteStatus);
-    /// Optional in Zig (`?fn`). Implement as no-op when not needed and set
+    /// Optional. Implement as no-op when not needed and set
     /// `HAS_REGISTER_POLL = false`.
     fn register_poll(&mut self);
     const HAS_REGISTER_POLL: bool = true;
@@ -75,8 +65,8 @@ pub trait PosixPipeWriter {
     /// callers may pass a `buf` that borrows from a field of `self` (e.g.
     /// `self.outgoing.slice()`) without raw-pointer aliasing escapes.
     fn try_write(&self, force_sync: bool, buf: &[u8]) -> WriteResult {
-        // PERF(port): Zig used `switch { inline else }` to monomorphize
-        // try_write_with_write_fn per FileType — profile if hot.
+        // PERF: try_write_with_write_fn is not monomorphized per FileType —
+        // profile if hot.
         let ft = if !force_sync {
             self.get_file_type()
         } else {
@@ -130,7 +120,7 @@ pub trait PosixPipeWriter {
     }
 
     fn on_poll(&mut self, size_hint: isize, received_hup: bool) {
-        // PORT NOTE: reshaped for borrowck — capture buffer.len() before further &mut self calls.
+        // reshaped for borrowck — capture buffer.len() before further &mut self calls.
         let buffer_len = self.get_buffer().len();
         log!("onPoll({})", buffer_len);
         if buffer_len == 0 && !received_hup {
@@ -185,8 +175,7 @@ pub trait PosixPipeWriter {
         }
     }
 
-    /// Zig passed `buf: []const u8` separately while also mutating `self`;
-    /// here we re-derive the slice from `self.get_buffer()` each iteration.
+    /// Re-derives the slice from `self.get_buffer()` each iteration.
     /// `try_write` only needs `&self`, so the shared borrow of the buffer
     /// coexists with it, and the `&mut self` for `on_error` is taken after
     /// the temporary slice borrow has ended — no raw-pointer escape needed.
@@ -236,8 +225,8 @@ pub trait PosixPipeWriter {
     }
 }
 
-/// Zig: `fn writeToFileType(comptime file_type: FileType) *const fn(...)` — folded into
-/// `try_write` above. Kept here as a free fn for the blocking-pipe path.
+/// Free fn for the blocking-pipe path; the other file types are handled
+/// inline in `try_write` above.
 fn write_to_blocking_pipe(fd: Fd, buf: &[u8]) -> sys::Result<usize> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
@@ -256,19 +245,18 @@ fn write_to_blocking_pipe(fd: Fd, buf: &[u8]) -> sys::Result<usize> {
 // PosixBufferedWriter
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Function table for `PosixBufferedWriter`. In Zig this was `function_table: anytype`;
+/// Function table for `PosixBufferedWriter`;
 /// in many cases the function table can be the same as `Parent`.
 ///
 /// All methods take `*mut Self` (not `&mut self`) because the writer is an
-/// intrusive *field of* the parent — see PipeWriter.zig `parent: *Parent`.
+/// intrusive *field of* the parent (it holds a raw `parent` back-pointer).
 /// Materializing `&mut Parent` while a `&mut writer` is live would alias under
-/// Stacked Borrows. Zig's `*Parent` freely aliases; we mirror that with raw
+/// Stacked Borrows, so we use raw
 /// pointers and never form a `&mut Parent` inside the writer.
 pub trait PosixBufferedWriterParent {
     /// `bun_io::poll_tag` constant for this writer's `FilePoll` owner. The
     /// per-tag dispatch in `bun_runtime::dispatch::__bun_run_file_poll`
-    /// recovers `*mut PosixBufferedWriter<Self>` from this. Zig derived the
-    /// tag from `@TypeOf` (TaggedPointerUnion); Rust threads it explicitly.
+    /// recovers `*mut PosixBufferedWriter<Self>` from this.
     const POLL_OWNER_TAG: PollTag;
     /// # Safety
     /// `this` must point to a live `Self`.
@@ -307,7 +295,7 @@ impl<Parent: PosixBufferedWriterParent> Default for PosixBufferedWriter<Parent>
     fn default() -> Self {
         Self {
             handle: PollOrFd::Closed,
-            parent: None, // Zig: undefined
+            parent: None,
             is_done: false,
             pollable: false,
             closed_without_reporting: false,
@@ -548,7 +536,7 @@ impl<Parent: PosixBufferedWriterParent> PosixBufferedWriter<Parent> {
         self.parent = Some(bun_ptr::ParentRef::from(
             core::ptr::NonNull::new(parent).expect("set_parent: parent must not be null"),
         ));
-        // PORT NOTE: reshaped for borrowck — capture *mut Self before borrowing field.
+        // reshaped for borrowck — capture *mut Self before borrowing field.
         let owner = std::ptr::from_mut(self).cast::<c_void>();
         self.handle
             .set_owner(Owner::new(Parent::POLL_OWNER_TAG, owner.cast()));
@@ -569,8 +557,8 @@ impl<Parent: PosixBufferedWriterParent> PosixBufferedWriter<Parent> {
         }
     }
 
-    /// Zig accepts `bun.FD`, `*bun.MovableIfWindowsFd`, or `bun.MovableIfWindowsFd`.
-    // TODO(port): MovableIfWindowsFd overload — add an Into<Fd> bound or a separate fn.
+    /// On POSIX a `MovableIfWindowsFd` never transfers ownership, so callers
+    /// pass the plain `Fd` (via `MovableIfWindowsFd::get_posix()` when needed).
     pub fn start(&mut self, rawfd: Fd, pollable: bool) -> sys::Result<()> {
         let fd = rawfd;
         self.pollable = pollable;
@@ -609,15 +597,14 @@ impl<Parent: PosixBufferedWriterParent> PosixBufferedWriter<Parent> {
 
 /// Function table for `PosixStreamingWriter`.
 /// All methods take `*mut Self` (not `&mut self`) because the writer is an
-/// intrusive *field of* the parent — see PipeWriter.zig `parent: *Parent`.
+/// intrusive *field of* the parent (it holds a raw `parent` back-pointer).
 /// Materializing `&mut Parent` while a `&mut writer` is live would alias under
-/// Stacked Borrows. Zig's `*Parent` freely aliases; we mirror that with raw
+/// Stacked Borrows, so we use raw
 /// pointers and never form a `&mut Parent` inside the writer.
 pub trait PosixStreamingWriterParent {
     /// `bun_io::poll_tag` constant for this writer's `FilePoll` owner. The
     /// per-tag dispatch in `bun_runtime::dispatch::__bun_run_file_poll`
-    /// recovers `*mut PosixStreamingWriter<Self>` from this. Zig derived the
-    /// tag from `@TypeOf` (TaggedPointerUnion); Rust threads it explicitly.
+    /// recovers `*mut PosixStreamingWriter<Self>` from this.
     const POLL_OWNER_TAG: PollTag;
     /// # Safety
     /// `this` must point to a live `Self`.
@@ -654,7 +641,7 @@ impl<Parent: PosixStreamingWriterParent> Default for PosixStreamingWriter<Parent
         Self {
             outgoing: StreamBuffer::default(),
             handle: PollOrFd::Closed,
-            parent: core::ptr::null_mut(), // Zig: undefined
+            parent: core::ptr::null_mut(),
             is_done: false,
             closed_without_reporting: false,
             force_sync: false,
@@ -696,9 +683,13 @@ unsafe impl<Parent: PosixStreamingWriterParent> bun_ptr::LaunderedSelf
 }
 
 impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
-    // TODO: configurable?
-    // TODO(port): std.heap.page_size_min — pick correct const for target.
-    const CHUNK_SIZE: usize = 4096;
+    // The smallest page size the target
+    // supports (16K on Apple Silicon, 4K elsewhere among our targets).
+    const CHUNK_SIZE: usize = if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
+        16384
+    } else {
+        4096
+    };
 
     /// Raw backref to the owning `Parent`. Returned as `*mut` (never `&mut`)
     /// because this writer is an intrusive field of `Parent` and a `&mut Parent`
@@ -794,7 +785,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
 
     pub fn set_parent(&mut self, parent: *mut Parent) {
         self.parent = parent;
-        // PORT NOTE: reshaped for borrowck — capture *mut Self before borrowing field.
+        // reshaped for borrowck — capture *mut Self before borrowing field.
         let owner = std::ptr::from_mut(self).cast::<c_void>();
         self.handle
             .set_owner(Owner::new(Parent::POLL_OWNER_TAG, owner.cast()));
@@ -852,7 +843,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
         let before_len = self.outgoing.size();
 
         if self.outgoing.write_utf16(buf).is_err() {
-            return WriteResult::Err(oom_err());
+            return WriteResult::Err(sys::Error::oom());
         }
 
         let buf_len = self.outgoing.size() - before_len;
@@ -873,7 +864,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
 
         const CHECK_ASCII: bool = false;
         if self.outgoing.write_latin1::<CHECK_ASCII>(buf).is_err() {
-            return WriteResult::Err(oom_err());
+            return WriteResult::Err(sys::Error::oom());
         }
 
         let buf_len = self.outgoing.size() - before_len;
@@ -927,7 +918,6 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
                 Self::register_poll(self);
             }
 
-            // Zig `else => |r| return r` — only Err remains.
             WriteResult::Err(e) => return WriteResult::Err(e),
         }
 
@@ -943,7 +933,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
             // this is streaming, but we buffer the data below `chunk_size` to
             // reduce the number of writes
             if self.outgoing.write(buf).is_err() {
-                return WriteResult::Err(oom_err());
+                return WriteResult::Err(sys::Error::oom());
             }
 
             // noop, but need this to have a chance
@@ -959,7 +949,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
         if self.outgoing.size() > 0 {
             // make sure write is in-order
             if self.outgoing.write(buf).is_err() {
-                return WriteResult::Err(oom_err());
+                return WriteResult::Err(sys::Error::oom());
             }
 
             return self.try_write_newly_buffered_data();
@@ -970,7 +960,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
         match rc {
             WriteResult::Pending(amt) => {
                 if self.outgoing.write(&buf[amt..]).is_err() {
-                    return WriteResult::Err(oom_err());
+                    return WriteResult::Err(sys::Error::oom());
                 }
                 self.parent_on_write(amt, WriteStatus::Pending);
                 Self::register_poll(self);
@@ -978,7 +968,7 @@ impl<Parent: PosixStreamingWriterParent> PosixStreamingWriter<Parent> {
             WriteResult::Wrote(amt) => {
                 if amt < buf.len() {
                     if self.outgoing.write(&buf[amt..]).is_err() {
-                        return WriteResult::Err(oom_err());
+                        return WriteResult::Err(sys::Error::oom());
                     }
                     self.parent_on_write(amt, WriteStatus::Pending);
                     Self::register_poll(self);
@@ -1211,8 +1201,7 @@ pub trait BaseWindowsPipeWriter {
                 // an in-flight write (on_fs_write_complete) or will receive an
                 // async uv_fs_close callback (File::on_close_complete). Dropping
                 // the Box here would free that memory before the callback fires.
-                // Zig stores a raw `*File` so `this.source = null` is non-owning;
-                // mirror that by leaking via into_raw. on_close_detached path
+                // Leak via into_raw; the on_close_detached path
                 // reclaims via heap::take in File::on_close_complete.
                 let raw = bun_core::heap::into_raw(file);
                 // SAFETY: raw is heap-allocated by Source::open_file; libuv holds
@@ -1226,9 +1215,7 @@ pub trait BaseWindowsPipeWriter {
                     } else {
                         // Don't own fd: stop any in-flight op and detach parent so
                         // on_fs_write_complete won't touch the (possibly freed)
-                        // writer. We must still reclaim the Box<File> — the Zig
-                        // spec leaks it here (source.zig heap-allocates and never
-                        // destroys on this path); Rust port fixes that leak.
+                        // writer. We must still reclaim the Box<File>.
                         (*raw).stop();
                         (*raw).fs.data = core::ptr::null_mut();
                         if (*raw).state == crate::source::FileState::Deinitialized {
@@ -1328,8 +1315,7 @@ pub trait BaseWindowsPipeWriter {
         self.start_with_current_pipe()
     }
 
-    /// Zig accepts `bun.FD` or `*bun.MovableIfWindowsFd`.
-    // TODO(port): MovableIfWindowsFd overload — add a separate start_movable().
+    // TODO: MovableIfWindowsFd overload — add a separate start_movable().
     fn start(&mut self, rawfd: Fd, _pollable: bool) -> sys::Result<()> {
         let fd = rawfd;
         debug_assert!(self.source().is_none());
@@ -1344,8 +1330,8 @@ pub trait BaseWindowsPipeWriter {
         // Creating a uv_pipe/uv_tty takes ownership of the file descriptor
         // TODO: Change the type of the parameter and update all places to
         //       use MovableFD
-        // TODO(port): Zig branch `if (source is pipe|tty) and FDType == *MovableIfWindowsFd { rawfd.take() }`
-        // dropped — handle via a MovableFd overload.
+        // TODO: take ownership of the fd for pipe/tty sources via a MovableFd
+        // overload.
         let _ = matches!(source, Source::Pipe(_) | Source::Tty(_));
         source.set_data(core::ptr::from_mut(self).cast::<c_void>());
         *self.source_mut() = Some(source);
@@ -1356,8 +1342,7 @@ pub trait BaseWindowsPipeWriter {
 
     /// SAFETY: `pipe` must be a `Box<uv::Pipe>`-allocated pointer.
     unsafe fn set_pipe(&mut self, pipe: *mut uv::Pipe) {
-        // Zig overwrites a raw-pointer union (worst case: leak). In Rust the
-        // assignment below would Drop the prior Box WITHOUT uv_close, leaving
+        // The assignment below would Drop the prior Box WITHOUT uv_close, leaving
         // libuv with a dangling handle → UAF on next loop tick. All other
         // start_* paths assert empty; enforce the same invariant here.
         debug_assert!(self.source().is_none());
@@ -1369,8 +1354,8 @@ pub trait BaseWindowsPipeWriter {
 
     fn get_stream(&mut self) -> Option<*mut uv::uv_stream_t> {
         let source = self.source_mut().as_mut()?;
-        // Zig spec only excludes .file (latent bug); Rust's Source::to_stream()
-        // is `unreachable!()` for SyncFile too, so exclude both to avoid panic.
+        // `Source::to_stream()` is `unreachable!()` for both File and
+        // SyncFile, so exclude both to avoid panic.
         if matches!(source, Source::File(_) | Source::SyncFile(_)) {
             return None;
         }
@@ -1391,8 +1376,7 @@ extern "C" fn on_pipe_close(handle: *mut uv::Pipe) {
 extern "C" fn on_tty_close(handle: *mut uv::uv_tty_t) {
     // `close()` set `handle.data = handle` and then called `uv_close(handle)`;
     // libuv passes the same pointer back, so `handle` *is* the tty ptr.
-    // The stdin tty (fd 0) lives in static storage; never free it. Mirrors
-    // Zig PipeWriter onTtyClose's `is_stdin_tty()` gate.
+    // The stdin tty (fd 0) lives in static storage; never free it.
     if !crate::source::stdin_tty::is_stdin_tty(handle) {
         // SAFETY: non-stdin tty is heap-allocated (open_tty heap::alloc).
         drop(unsafe { bun_core::heap::take(handle) });
@@ -1402,10 +1386,10 @@ extern "C" fn on_tty_close(handle: *mut uv::uv_tty_t) {
 /// Common parent requirements for Windows writers (event loop access + ref counting).
 ///
 /// All methods take `*mut Self` (not `&self`) because the writer is an
-/// intrusive *field of* the parent — see PipeWriter.zig `parent: *Parent`.
+/// intrusive *field of* the parent (it holds a raw `parent` back-pointer).
 /// Materializing `&Parent`/`&mut Parent` while a `&mut writer` is live would
-/// alias under Stacked Borrows. Zig's `*Parent` freely aliases; we mirror that
-/// with raw pointers and never form a Rust reference to `Parent` inside the
+/// alias under Stacked Borrows, so we use
+/// raw pointers and never form a Rust reference to `Parent` inside the
 /// writer.
 #[cfg(windows)]
 pub trait WindowsWriterParent {
@@ -1466,7 +1450,7 @@ impl<Parent: WindowsBufferedWriterParent> Default for WindowsBufferedWriter<Pare
         Self {
             source: None,
             owns_fd: true,
-            parent: core::ptr::null_mut(), // Zig: undefined
+            parent: core::ptr::null_mut(),
             is_done: false,
             write_req: bun_core::ffi::zeroed(),
             write_buffer: uv::uv_buf_t::init(b""),
@@ -1694,8 +1678,7 @@ impl<Parent: WindowsBufferedWriterParent> WindowsBufferedWriter<Parent> {
         // BORROW_PARAM (raw-ptr break): the match arms mutate `self` while
         // borrowing into `self.source`. The boxed `File`/`Pipe` live in their
         // own heap allocations, so a `*mut` snapshot is provenance-disjoint
-        // from `&mut self` (mirrors the Zig `*Source` pointer the original
-        // kept across `self.*` writes).
+        // from `&mut self` and stays valid across `self.*` writes.
         let (file_raw, stream_raw): (*mut crate::source::File, *mut uv::uv_stream_t) =
             match self.source.as_mut() {
                 None => return,
@@ -1794,11 +1777,11 @@ impl StreamBuffer {
     }
 
     pub fn maybe_shrink(&mut self) {
-        // TODO(port): std.heap.pageSize() — using 4096; query the actual page size.
-        let page = 4096usize;
+        // Runtime page size of the host.
+        let page = bun_core::page_size();
         if self.list.capacity() > page {
-            // Zig: expandToCapacity() then shrinkAndFree(page) — i.e. truncate the
-            // buffer's content to `page` bytes AND release the excess capacity.
+            // Truncate the buffer's content to `page` bytes AND release the
+            // excess capacity.
             // Vec::shrink_to never goes below current len, so truncate first.
             self.list.truncate(page);
             self.list.shrink_to(page);
@@ -1831,7 +1814,6 @@ impl StreamBuffer {
     }
 
     pub fn write_assume_capacity(&mut self, buffer: &[u8]) {
-        // PERF(port): was appendSliceAssumeCapacity — profile if hot.
         self.list.extend_from_slice(buffer);
     }
 
@@ -1845,19 +1827,16 @@ impl StreamBuffer {
     }
 
     pub fn write_type_as_bytes_assume_capacity<T: bun_core::NoUninit>(&mut self, data: T) {
-        // PERF(port): was assume_capacity
         self.list.extend_from_slice(bun_core::bytes_of(&data));
     }
 
-    /// Zig: `writeOrFallback(buffer: anytype, comptime writeFn: anytype)` —
-    /// dispatched on fn-pointer identity at comptime. In Rust we use an enum tag.
+    /// Dispatched on the `WriteKind` enum tag.
     pub fn write_or_fallback<'a>(
         &'a mut self,
         buffer_u8: Option<&'a [u8]>,
         buffer_u16: Option<&[u16]>,
         kind: WriteKind,
     ) -> Result<&'a [u8], OOM> {
-        // TODO(refactor): comptime fn-ptr identity dispatch → enum tag; consider unifying with write_internal.
         match kind {
             WriteKind::Latin1 => {
                 let buffer = buffer_u8.unwrap();
@@ -1883,9 +1862,6 @@ impl StreamBuffer {
             }
         }
 
-        // PORT NOTE: Zig round-trips through `Vec::<u8>::moveFromList` to call
-        // `writeLatin1`; the underlying op is `allocateLatin1IntoUTF8WithList`,
-        // which we call on the `Vec<u8>` directly.
         let len = self.list.len();
         let list = mem::take(&mut self.list);
         self.list = bun_core::strings::allocate_latin1_into_utf8_with_list(list, len, buffer);
@@ -1893,10 +1869,9 @@ impl StreamBuffer {
     }
 
     pub fn write_utf16(&mut self, buffer: &[u16]) -> Result<(), OOM> {
-        // Zig (PipeWriter.zig:1213): `byte_list.writeUTF16(allocator, buffer)` —
-        // `ByteList.writeUTF16` (baby_list.zig:419) sizes the spare capacity via
-        // `simdutf.length.utf8.from.utf16.le` *before* the simdutf write. The
-        // `ByteVecExt::write_utf16` impl mirrors that contract; calling
+        // `ByteVecExt::write_utf16` sizes the spare capacity via
+        // `simdutf.length.utf8.from.utf16.le` *before* the simdutf write;
+        // calling
         // `convert_utf16_to_utf8_append` directly (its old shortcut) handed
         // simdutf a `Vec::new()` dangling pointer (`0x1`) and segfaulted.
         ByteVecExt::write_utf16(&mut self.list, buffer)?;
@@ -1968,7 +1943,7 @@ impl<Parent: WindowsStreamingWriterParent> Default for WindowsStreamingWriter<Pa
         Self {
             source: None,
             owns_fd: true,
-            parent: core::ptr::null_mut(), // Zig: undefined
+            parent: core::ptr::null_mut(),
             is_done: false,
             write_req: bun_core::ffi::zeroed(),
             write_buffer: uv::uv_buf_t::init(b""),
@@ -2078,8 +2053,8 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
     /// See [`r_on_error`](Self::r_on_error) for the encapsulated type
     /// invariant and laundered-receiver rationale. Reads `self.parent`
     /// **before** dispatch so the (potentially freeing) `Parent::deref`
-    /// runs with no borrow of `*this` live — mirrors the lazy Zig-`defer`
-    /// read order at each scopeguard site. Collapses the three
+    /// runs with no borrow of `*this` live — matching the lazy read order
+    /// at each scopeguard site. Collapses the three
     /// `Parent::deref` blocks into one `unsafe`.
     #[inline(always)]
     fn r_deref(this: *mut Self) {
@@ -2116,8 +2091,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
 
         // Deref the parent at the end to balance the ref taken in
         // process_send before submitting the async write request.
-        // Zig's `defer this.parent.deref()` reads `this.parent` LAZILY at scope
-        // exit; capturing `self.parent` by value here would snapshot the old
+        // Capturing `self.parent` by value here would snapshot the old
         // pointer and over-deref it if a re-entrant callback set_parent()s.
         // Capture the laundered `*mut Self` and read `.parent` at guard
         // execution instead — the `black_box` above also ensures the guard's
@@ -2234,7 +2208,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
 
         if let Some(err) = result.to_error(sys::Tag::write) {
             // deref to balance process_send ref — read `.parent` LAZILY at
-            // guard execution (Zig defer semantics), not eagerly, in case
+            // guard execution, not eagerly, in case
             // close()/on_error re-enter and swap the parent pointer.
             let _g = scopeguard::guard(this, |s| Self::r_deref(s));
             // close() may re-enter JS — every post-call `r(this)` reborrow
@@ -2398,7 +2372,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
             let result = (|| {
                 let remain = match self.outgoing.write_or_fallback(Some(buffer), None, kind) {
                     Ok(r) => r,
-                    Err(_) => return WriteResult::Err(oom_err()),
+                    Err(_) => return WriteResult::Err(sys::Error::oom()),
                 };
                 let initial_len = remain.len();
                 let mut remain = remain;
@@ -2436,7 +2410,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
             WriteKind::Utf16 => unreachable!(),
         };
         if r.is_err() {
-            return WriteResult::Err(oom_err());
+            return WriteResult::Err(sys::Error::oom());
         }
         if had_buffered_data {
             return WriteResult::Pending(0);
@@ -2458,7 +2432,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
                         .write_or_fallback(None, Some(buffer), WriteKind::Utf16)
                     {
                         Ok(r) => r,
-                        Err(_) => return WriteResult::Err(oom_err()),
+                        Err(_) => return WriteResult::Err(sys::Error::oom()),
                     };
                 let initial_len = remain.len();
                 let mut remain = remain;
@@ -2491,7 +2465,7 @@ impl<Parent: WindowsStreamingWriterParent> WindowsStreamingWriter<Parent> {
 
         let had_buffered_data = self.outgoing.is_not_empty();
         if self.outgoing.write_utf16(buffer).is_err() {
-            return WriteResult::Err(oom_err());
+            return WriteResult::Err(sys::Error::oom());
         }
         if had_buffered_data {
             return WriteResult::Pending(0);
@@ -2569,9 +2543,8 @@ pub type StreamingWriter<P> = WindowsStreamingWriter<P>;
 // Parent-vtable shim macros
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig's `StreamingWriter(Parent, .{ .onWrite = T.onWrite, ... })` takes a
-// comptime function table; the Rust port replaced it with monomorphic
-// `*WriterParent` traits whose every method is `unsafe fn(this: *mut Self, ..)`
+// The `*WriterParent` traits are monomorphic function tables whose every
+// method is `unsafe fn(this: *mut Self, ..)`
 // that derefs the BACKREF and forwards to an inherent method. Every concrete
 // parent (FileSink, Terminal, WindowsNamedPipe, shell IOWriter,
 // StaticPipeWriter) was hand-stamping the same triple of cfg-gated impls
@@ -2706,7 +2679,7 @@ macro_rules! impl_streaming_writer_parent {
 
         #[cfg(windows)]
         impl $($gen)* $crate::pipe_writer::WindowsStreamingWriterParent for $Ty {
-            // Zig `.onWritable` slot — same body as POSIX `on_ready`.
+            // Same body as POSIX `on_ready`.
             const HAS_ON_WRITABLE: bool = true;
             #[inline]
             unsafe fn on_write(this: *mut Self, amount: usize, status: $crate::WriteStatus) {
@@ -2889,5 +2862,3 @@ macro_rules! impl_buffered_writer_parent {
         $crate::impl_buffered_writer_parent! { @emit [] $Ty; $($rest)* }
     };
 }
-
-// ported from: src/io/PipeWriter.zig
diff --git a/src/io/heap.rs b/src/io/heap.rs
index 6e9b7926572..8c98a576f3a 100644
--- a/src/io/heap.rs
+++ b/src/io/heap.rs
@@ -4,8 +4,8 @@ use core::ptr;
 ///
 /// Why? Intrusive data structures require the element type to hold the metadata
 /// required for the structure, rather than an additional container structure.
-/// There are numerous pros/cons that are documented well by Boost[2]. For Zig,
-/// I think the primary benefits are making data structures allocation free
+/// There are numerous pros/cons that are documented well by Boost[2]. Here
+/// the primary benefits are making data structures allocation free
 /// (rather, shifting allocation up to the consumer which can choose how they
 /// want the memory to be available). There are various costs to this such as
 /// the costs of pointer chasing, larger memory overhead, requiring the element
@@ -21,12 +21,10 @@ use core::ptr;
 /// [1]: https://en.wikipedia.org/wiki/Pairing_heap
 /// [2]: https://www.boost.org/doc/libs/1_64_0/doc/html/intrusive/intrusive_vs_nontrusive.html
 //
-// PORT NOTE: Zig's `Intrusive(T, Context, less)` takes `less` as a comptime fn-pointer
-// parameter. Rust cannot use fn pointers as const generics on stable, so the comparator
-// is folded into a trait on `Context` (`HeapContext<T>::less`). This preserves
-// monomorphization (no indirect call) at the cost of requiring the caller to impl the
-// trait instead of passing a free fn.
-// PERF(port): was comptime fn-pointer monomorphization — profile if hot.
+// The comparator is a trait on `Context` (`HeapContext<T>::less`) rather than
+// a fn-pointer parameter (fn pointers can't be const generics on stable).
+// This preserves monomorphization (no indirect call) at the cost of requiring
+// the caller to impl the trait instead of passing a free fn.
 pub struct Intrusive<T: HeapNode, Context: HeapContext<T>> {
     pub root: *mut T,
     pub context: Context,
@@ -42,7 +40,6 @@ pub trait HeapContext<T> {
 }
 
 /// Trait giving generic access to the embedded `IntrusiveField` on `T`.
-/// In Zig this is duck-typed via `v.heap`; Rust needs an explicit bound.
 pub trait HeapNode: Sized {
     fn heap(&mut self) -> &mut IntrusiveField<Self>;
 }
@@ -304,5 +301,3 @@ impl<T> Default for IntrusiveField<T> {
         }
     }
 }
-
-// ported from: src/io/heap.zig
diff --git a/src/io/keep_alive.rs b/src/io/keep_alive.rs
index dd40e69ae2a..207a06e4bd0 100644
--- a/src/io/keep_alive.rs
+++ b/src/io/keep_alive.rs
@@ -1,11 +1,9 @@
 //! Single cross-platform `KeepAlive`.
 //!
-//! Zig keeps two copies (`posix_event_loop.zig:5-114` /
-//! `windows_event_loop.zig:3-113`); the Rust ports were faithful duplicates.
-//! 9 of 14 methods were byte-identical; the 5 that diverge keep their
-//! per-platform behaviour via `#[cfg]` arms inline below — no caller-visible
-//! contract changes (all external users go through `bun_io::KeepAlive` and
-//! only touch the identical-signature methods).
+//! The few methods that diverge per platform keep their behaviour via
+//! `#[cfg]` arms inline below — no caller-visible contract changes (all
+//! external users go through `bun_io::KeepAlive` and only touch the
+//! identical-signature methods).
 
 use crate::EventLoopCtx;
 use crate::posix_event_loop::js_vm_ctx;
@@ -68,8 +66,8 @@ impl KeepAlive {
     /// Only intended to be used from EventLoop.Pollable
     #[cfg(windows)]
     pub fn activate(&mut self, loop_: &mut crate::Loop) {
-        // Zig `windows_event_loop.zig` guards on `!= .active` (vs posix
-        // `!= .inactive`); preserved verbatim.
+        // The Windows arm guards on `!= Active` (vs posix `!= Inactive`);
+        // preserved verbatim.
         if self.status != Status::Active {
             return;
         }
@@ -121,7 +119,9 @@ impl KeepAlive {
             return;
         }
         self.status = Status::Inactive;
-        // TODO(port): vm.pending_unref_counter must be Atomic; Zig uses @atomicRmw .Add .monotonic
+        // Cross-thread increment: the counter is an `AtomicI32` RMW'd with
+        // `Ordering::Relaxed` (see
+        // `jsc::VirtualMachine::pending_unref_counter`).
         #[cfg(not(windows))]
         vm.increment_pending_unref_counter();
         // TODO: https://github.com/oven-sh/bun/pull/4410#discussion_r1317326194
@@ -140,9 +140,8 @@ impl KeepAlive {
 
     /// Allow a poll to keep the process alive.
     ///
-    /// Raw-identifier alias of [`KeepAlive::ref_`] matching the Zig method name
-    /// `ref` exactly (per PORTING.md "same fn names" rule). Downstream ports
-    /// call both spellings; this keeps them source-compatible.
+    /// Raw-identifier alias of [`KeepAlive::ref_`]. Callers use both
+    /// spellings; this keeps them source-compatible.
     #[inline]
     pub fn r#ref(&mut self, event_loop_ctx: EventLoopCtx) {
         self.ref_(event_loop_ctx)
diff --git a/src/io/lib.rs b/src/io/lib.rs
index a85d2a3a344..b0d1553e56b 100644
--- a/src/io/lib.rs
+++ b/src/io/lib.rs
@@ -41,12 +41,10 @@ pub mod posix_event_loop;
 pub use keep_alive::KeepAlive;
 
 // ParentDeathWatchdog is POSIX-only (uses `libc::pid_t`, `getppid`, signals);
-// Windows handles orphan death via Job Objects in `spawn`. The Zig original
-// compiles on all targets and short-circuits each fn with
-// `if (comptime !Environment.isPosix) return;`, so downstream code calls
-// `install()` / `enable()` / `is_enabled()` unconditionally. Mirror that with a
-// no-op Windows stub so the cross-platform call sites (main.rs, bunfig,
-// run_command, filter_run, dispatch) keep compiling.
+// Windows handles orphan death via Job Objects in `spawn`. Downstream code
+// calls `install()` / `enable()` / `is_enabled()` unconditionally, so a
+// no-op Windows stub keeps the cross-platform call sites (main.rs, bunfig,
+// run_command, filter_run, dispatch) compiling.
 #[cfg(not(windows))]
 #[path = "ParentDeathWatchdog.rs"]
 pub mod parent_death_watchdog;
@@ -115,14 +113,13 @@ pub type OpaqueCallback = unsafe extern "C" fn(*mut core::ffi::c_void);
 // `platform_event_loop_ptr` is typed `*mut bun_uws_sys::Loop` (the uws
 // wrapper — `PosixLoop`/`WindowsLoop`), NOT the cfg-aliased `crate::Loop`
 // re-export. On POSIX those coincide, but on Windows `crate::Loop` is the raw
-// `uv_loop_t` (Zig `windows_event_loop.zig:1`) whereas the impl bodies
-// (`VirtualMachine::uws_loop` / `MiniEventLoop::loop_ptr`) and the Zig spec
-// (`EventLoopHandle.loop() -> *uws.Loop`) hand back the wrapper.
+// `uv_loop_t` whereas the impl bodies
+// (`VirtualMachine::uws_loop` / `MiniEventLoop::loop_ptr`) hand back the wrapper.
 bun_dispatch::link_interface! {
     pub EventLoopCtx[Js, Mini] {
         fn platform_event_loop_ptr() -> *mut bun_uws_sys::Loop;
         fn file_polls_ptr() -> *mut Store;
-        // PORT NOTE: `alloc_file_poll() -> *mut FilePoll` was removed — it
+        // `alloc_file_poll() -> *mut FilePoll` was removed — it
         // returned an *uninitialized* hive slot, and any caller forming
         // `&mut FilePoll` over it hit validity-invariant UB on the niche-
         // bearing enum fields. `FilePoll::init` now goes through
@@ -293,7 +290,6 @@ pub mod file_poll {
 pub mod heap;
 // `source.rs` is Windows-only (libuv pipe/tty/file wrappers). On POSIX the
 // `Source` type is never constructed; callers are themselves `#[cfg(windows)]`.
-// TODO(port): bun_sys::windows::libuv — verify compiles on Windows in CI.
 #[path = "MaxBuf.rs"]
 pub mod max_buf;
 #[path = "openForWriting.rs"]
@@ -311,7 +307,7 @@ pub mod source;
 pub mod write;
 
 // ── re-exports for higher tiers ─────────────────────────────────────────────
-// Byte-level `Write` trait + helpers (Zig `std.Io.Writer` surface). Downstream
+// Byte-level `Write` trait + helpers. Downstream
 // crates name these as `bun_io::Write` / `bun_io::BufWriter` /
 // `bun_io::FmtAdapter` / `bun_io::Result`.
 pub use bun_core::fmt::SliceCursor;
@@ -355,10 +351,8 @@ bun_dispatch::link_interface! {
 
 /// One-stop generator for a `BufferedReader` parent: emits **both** the
 /// `impl BufferedReaderParent for $T` block and the matching
-/// `link_impl_BufferedReaderParentLink!` registration. Direct port of the Zig
-/// comptime thunk-generator `BufferedReaderVTable.Fn.init(comptime Type)`
-/// (PipeReader.zig:7-45) — every parent type just declares same-named inherent
-/// methods and writes one macro invocation.
+/// `link_impl_BufferedReaderParentLink!` registration. Every parent type just
+/// declares same-named inherent methods and writes one macro invocation.
 ///
 /// ## Shape
 ///
@@ -503,7 +497,7 @@ pub use source::Source;
 pub enum Source {}
 
 pub use pipe_reader::{BufferedReader, BufferedReaderParent, PosixFlags};
-/// Downstream alias (Zig: `bun.io.BufferedReader` is sometimes referenced as
+/// Downstream alias (`BufferedReader` is sometimes referenced as
 /// `PipeReader`).
 pub type PipeReader = BufferedReader;
 
@@ -519,7 +513,7 @@ pub use crate::closer::Closer;
 pub use crate::waker::Waker;
 use bun_sys::{self as sys, E, Fd};
 
-// Zig scope name is `.loop` (io.zig:11). `loop` is a Rust keyword, so the static is
+// `loop` is a Rust keyword, so the static is
 // named `io_loop` but the runtime tagname is `"loop"` so `BUN_DEBUG_loop=1` works.
 #[allow(non_upper_case_globals)]
 #[allow(dead_code)]
@@ -533,7 +527,7 @@ bun_core::define_scoped_log!(log, io_loop); // hand-declared static above (tagna
 #[cfg(windows)]
 mod windows_ffi {
     // Bun C++ shim over `QueryPerformanceCounter` (src/bun.js/bindings/
-    // c-bindings.cpp). Zig io.zig:314 declares it inline in `Loop`.
+    // c-bindings.cpp).
     unsafe extern "C" {
         // safe: out-params are `&mut i64` (non-null, valid for write); C++ side
         // only writes the slots and returns a status code — no preconditions.
@@ -558,8 +552,6 @@ mod safe_c {
         pub(super) safe fn kqueue() -> c_int;
         #[cfg(any(target_os = "linux", target_os = "android"))]
         pub(super) safe fn epoll_create1(flags: c_int) -> c_int;
-        #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
-        pub(super) safe fn eventfd(initval: libc::c_uint, flags: c_int) -> c_int;
         // Out-param `tp` is `&mut timespec` (non-null, valid for write); libc
         // only writes the slot and reports failure via the return value —
         // bad `clk_id` → `EINVAL`, never UB.
@@ -570,8 +562,8 @@ mod safe_c {
 
 // ─── platform type aliases ────────────────────────────────────────────────────
 
-/// `bun_sys::linux` doesn't exist yet; use `libc` constants directly.
-/// TODO(port): bun_sys::linux — replace with that module once available.
+/// `bun_sys` has no `linux` constants module; alias the `libc` constants
+/// locally so the call sites below stay terse.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux {
     pub(crate) use libc::epoll_event;
@@ -586,7 +578,7 @@ mod linux {
     pub(crate) const EPOLL_CTL_DEL: i32 = libc::EPOLL_CTL_DEL;
 }
 
-/// Zig std's `.freebsd` `EV` struct lacks `.EOF`; the value (0x8000) is the
+/// The value (0x8000) is the
 /// same on Darwin and FreeBSD (sys/event.h: `#define EV_EOF 0x8000`).
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
 const EV_EOF: u16 = 0x8000;
@@ -632,7 +624,7 @@ type EventType = linux::epoll_event;
 type EventType = KEvent;
 
 // ─── IoRequestLoop ──────────────────────────────────────────────────────────
-// This is io.zig's `Loop` — the bare-kqueue/epoll request loop that backs
+// The bare-kqueue/epoll request loop that backs
 // `Bun.file(path).text()` / `Bun.write()` & friends (and nothing else; see the
 // crate doc above). NOT the main event loop. Renamed from `Loop` so this
 // crate's `Loop` (= `posix_event_loop::Loop` = the uws `us_loop_t` everyone
@@ -666,7 +658,7 @@ pub struct IoRequestLoop {
 // §Concurrency: `OnceLock` for init gate; the singleton itself stays raw because
 // the IO thread mutates fields concurrently with `schedule()` callers (which only
 // touch the lock-free `pending` queue + `waker`), so wrapping the whole struct in a
-// `Mutex` would be wrong. Matches Zig `var loop: Loop = undefined;` + `std.once(load)`.
+// `Mutex` would be wrong.
 //
 // `ThreadCell` (not `RacyCell`) to encode "IO-thread-only after init" in the
 // type. `claim()` is invoked from `on_spawn_io_thread`. Cross-thread
@@ -772,7 +764,7 @@ impl IoRequestLoop {
             .stack_size(1024 * 1024 * 2)
             .spawn(Self::on_spawn_io_thread)
             .unwrap_or_else(|_| panic!("Failed to spawn IO watcher thread"));
-        // Zig: thread.detach() — Rust JoinHandle detaches on drop.
+        // The JoinHandle detaches on drop.
     }
 
     fn ensure_init() {
@@ -972,9 +964,8 @@ impl IoRequestLoop {
         }
     }
 
-    // Zig: `Waker.getFd` / the loop's poll fd are `@compileError` on Windows
-    // (src/io/windows_event_loop.zig:368-373). Gate these so any Windows
-    // call site fails at compile time, matching the spec, rather than
+    // `Waker.getFd` / the loop's poll fd have no Windows equivalent. Gate
+    // these so any Windows call site fails at compile time rather than
     // compiling cleanly and only panicking at runtime.
     #[cfg(not(windows))]
     pub fn pollfd(&self) -> Fd {
@@ -1002,14 +993,13 @@ impl IoRequestLoop {
         self.update_now();
 
         loop {
-            // PERF(port): was StackFallbackAllocator(256*sizeof(EventType)) — profile if it shows up on a hot path.
             let mut events_list: Vec<EventType> = Vec::with_capacity(256);
 
             // Process pending requests
             {
                 let mut pending = self.pending.pop_batch().iterator();
                 events_list.reserve(pending.batch.count);
-                // Zig: `addOneAssumeCapacity`. `reserve` above ⇒ no realloc; apply_kqueue
+                // `reserve` above ⇒ no realloc; apply_kqueue
                 // fully overwrites the slot so the zero is a safe placeholder.
                 #[inline(always)]
                 fn add_one(list: &mut Vec<EventType>) -> &mut EventType {
@@ -1069,13 +1059,11 @@ impl IoRequestLoop {
             let rc = kevent_call(
                 self.pollfd().native(),
                 events_list.as_ptr(),
-                // PERF(port): @intCast
                 c_int::try_from(change_count).expect("int cast"),
                 // The same array may be used for the changelist and eventlist.
                 events_list.as_mut_ptr(),
                 // we set 0 here so that if we get an error on
                 // registration, it becomes errno
-                // PERF(port): @intCast
                 c_int::try_from(capacity).expect("int cast"),
                 core::ptr::null(),
             );
@@ -1110,9 +1098,8 @@ impl IoRequestLoop {
         self.cached_now.set(ts);
     }
 
-    // PORT NOTE: Zig nests the `extern "c" fn clock_gettime_monotonic` decl
-    // inside the `Loop` namespace (io.zig:314); Rust forbids `extern` blocks
-    // inside `impl`, so it's hoisted to `windows_ffi` at module scope.
+    // The `extern "C" fn clock_gettime_monotonic` decl lives in `windows_ffi`
+    // at module scope (Rust forbids `extern` blocks inside `impl`).
 
     pub fn update_timespec(timespec: &mut libc::timespec) {
         #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -1160,8 +1147,7 @@ impl Request {
         }
     }
 
-    /// Atomic-ordered store of `callback` — mirrors Zig
-    /// `@atomicStore(?*const fn, &this.io_request.callback, cb, .seq_cst)`.
+    /// Atomic-ordered store of `callback`.
     ///
     /// The io thread reads `callback` after popping `self` from the MPSC
     /// queue (which already provides acquire on `next`); this SeqCst fence
@@ -1187,8 +1173,7 @@ impl Request {
 
 /// A type that embeds an intrusive `io_request: `[`Request`] field. Declares the
 /// byte offset once and provides the canonical container-of recovery used by
-/// every `fn(&mut Request) -> Action` io-loop trampoline (the Rust equivalent of
-/// Zig's per-site `@fieldParentPtr("io_request", req)`).
+/// every `fn(&mut Request) -> Action` io-loop trampoline.
 ///
 /// Implement via [`intrusive_io_request!`].
 ///
@@ -1277,15 +1262,11 @@ impl Default for Request {
     }
 }
 
-// `bun.UnboundedQueue(Request, .next)` — intrusive MPSC queue keyed on the
-// `next` field.
+// Intrusive MPSC queue keyed on the `next` field.
 //
-// Zig's `Request.next: ?*Request` is a plain optional pointer that the queue
-// reads/writes both atomically and non-atomically via `@atomicLoad`/`@field`.
-// The Rust port stores it as `AtomicPtr<Request>`; the non-atomic accessor
+// `next` is stored as `AtomicPtr<Request>`; the non-atomic accessor
 // paths (`get_next`/`set_next`, used only by the batch iterator and the
-// debug-mode `pushBatch` reachability assert) lower to `Relaxed` ops, which is
-// no weaker than the original.
+// debug-mode `pushBatch` reachability assert) lower to `Relaxed` ops.
 // SAFETY: `next` is the sole intrusive link for `UnboundedQueue(Request, .next)`.
 unsafe impl bun_threading::Linked for Request {
     #[inline]
@@ -1295,7 +1276,6 @@ unsafe impl bun_threading::Linked for Request {
     }
 }
 
-/// Zig: `pub const Queue = bun.UnboundedQueue(Request, .next);`
 pub(crate) type RequestQueue = bun_threading::UnboundedQueue<Request>;
 
 // ─── Action ───────────────────────────────────────────────────────────────────
@@ -1324,7 +1304,8 @@ pub struct CloseAction<'a> {
 
 // ─── Pollable ─────────────────────────────────────────────────────────────────
 
-// TODO(port): repr must match `bun.TaggedPointer.Tag` (15-bit tag in TaggedPtr).
+// Invariant: the repr must fit `bun.TaggedPointer.Tag` (the 15-bit tag packed
+// into `Pollable`'s u64 below) — keep `#[repr(u16)]` and values < 2^15.
 #[repr(u16)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum PollableTag {
@@ -1337,7 +1318,6 @@ pub enum PollableTag {
 /// into `(tag: u8, ptr: *mut ())`. Here the value must round-trip through a
 /// single `u64` (`epoll_event.data.u64` / `kevent.udata`), so we keep the
 /// packed addr:49 + tag:15 layout locally.
-/// PERF(port): was TaggedPointer pack — load-bearing (kernel-surface u64).
 #[cfg(not(windows))]
 #[derive(Clone, Copy)]
 struct Pollable {
@@ -1374,8 +1354,8 @@ impl Pollable {
             1 => PollableTag::ReadFile,
             2 => PollableTag::WriteFile,
             // Only `init` writes the tag bits, so any other value is memory
-            // corruption / a logic bug — match Zig's safety-checked
-            // `@enumFromInt` and trap rather than fabricate a discriminant.
+            // corruption / a logic bug — trap rather than fabricate a
+            // discriminant.
             n => unreachable!("invalid PollableTag {n}"),
         }
     }
@@ -1390,8 +1370,7 @@ impl Pollable {
 #[cfg(all(target_os = "macos", debug_assertions))]
 type GenerationNumberInt = u64;
 
-// PORTING.md §Global mutable state: counter → Atomic. Only the IO thread
-// touches this, so `Relaxed` matches the Zig non-atomic `+= 1`.
+// Only the IO thread touches this, so `Relaxed` is sufficient.
 #[cfg(all(target_os = "macos", debug_assertions))]
 static GENERATION_NUMBER_MONOTONIC: core::sync::atomic::AtomicU64 =
     core::sync::atomic::AtomicU64::new(0);
@@ -1419,8 +1398,8 @@ unsafe extern "Rust" {
     /// (`ReadFile` / `WriteFile`) live in `bun_runtime::webcore::blob` (T6);
     /// io (T2) only knows the embedded `*mut Poll` and the tag. The body is
     /// `#[no_mangle]` in `bun_runtime::dispatch` and recovers the parent
-    /// struct via `container_of(io_poll)` per spec `io.zig:626`.
-    /// PERF(port): was inline switch (cold path — Bun.write / Bun.file().text() only).
+    /// struct via `container_of(io_poll)`.
+    /// Cold path — only Bun.write / Bun.file().text() reach this.
     fn __bun_io_pollable_on_ready(tag: PollableTag, poll: *mut Poll);
     fn __bun_io_pollable_on_io_error(tag: PollableTag, poll: *mut Poll, err: &sys::Error);
 }
@@ -1467,12 +1446,10 @@ pub enum Flags {
 }
 
 pub type FlagsSet = enumset::EnumSet<Flags>;
-// TODO(port): `pub const Struct = std.enums.EnumFieldStruct(Flags, bool, false);` — a struct with
-// one `bool` field per variant. Unused in this file; provide if external callers need it.
 
-// PORT NOTE: Zig used a `comptime action: enum` const-generic. `adt_const_params`
+// A runtime parameter rather than a const generic: `adt_const_params`
 // is nightly-only and the body never uses ACTION in a type position — it just
-// `match`es on it — so demote to a runtime parameter (PORTING.md §Idiom-map).
+// `match`es on it.
 // Three call sites, each with a literal variant — trivially inlined; kqueue
 // registration is not hot enough for the lost monomorphization to matter.
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
@@ -1575,8 +1552,7 @@ impl Poll {
         // SAFETY: all-zero is a valid KEvent (POD).
         *kqueue_event = bun_core::ffi::zeroed();
         // `ident` is `u64` on Darwin's `kevent64_s`, `usize` on FreeBSD `kevent`.
-        // Zig `@intCast` would trap on a negative fd in safe builds — keep that
-        // safety net so a stray -1 doesn't silently register ident=u64::MAX.
+        // Assert so a stray -1 doesn't silently register ident=u64::MAX.
         debug_assert!(fd.native() >= 0, "register: negative fd {:?}", fd);
         kqueue_event.ident = fd.native() as _;
         kqueue_event.filter = filter;
@@ -1597,7 +1573,6 @@ impl Poll {
             kqueue_event.ext = [gen_, 0];
         }
 
-        // Zig `defer` block — runs after the body above.
         match action {
             ApplyAction::Readable => {
                 poll.flags.insert(Flags::PollReadable);
@@ -1620,8 +1595,7 @@ impl Poll {
         // which only exists on Darwin (GenerationNumberInt is u0 elsewhere).
         #[cfg(all(target_os = "macos", debug_assertions))]
         if action != ApplyAction::Cancel {
-            // Only the IO thread mutates this counter; Relaxed matches Zig's
-            // non-atomic `+= 1`.
+            // Only the IO thread mutates this counter; Relaxed is sufficient.
             poll.generation_number =
                 GENERATION_NUMBER_MONOTONIC.fetch_add(1, core::sync::atomic::Ordering::Relaxed) + 1;
         }
@@ -1670,7 +1644,7 @@ impl Poll {
                     // `event.data` is a kernel-supplied errno; do NOT transmute into the
                     // closed `sys::Errno` enum (size mismatch on darwin/freebsd where it
                     // is `#[repr(u16)]`, and UB for unmapped discriminants). Store the
-                    // raw integer via `from_code_int` (Zig: `@enumFromInt(event.data)`).
+                    // raw integer via `from_code_int`.
                     &sys::Error::from_code_int(event.data as core::ffi::c_int, sys::Tag::kevent),
                 )
             };
@@ -1700,12 +1674,11 @@ impl Poll {
             log!("error() = {:?}", errno);
             // SAFETY: poll is the `io_poll` field of a live owner; link-time
             // extern body matches on `tag`.
-            // TODO(port): bun_sys::Tag::epoll_ctl
             unsafe {
                 __bun_io_pollable_on_io_error(
                     tag,
                     poll,
-                    &sys::Error::from_code(errno, sys::Tag::TODO),
+                    &sys::Error::from_code(errno, sys::Tag::epoll_ctl),
                 )
             };
         } else {
@@ -1716,8 +1689,8 @@ impl Poll {
     }
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    // PORT NOTE: `flag` was a comptime param in Zig; `enumset::EnumSetType` cannot be a
-    // const generic, so it's a runtime arg. The `match` below preserves the exhaustiveness check.
+    // `enumset::EnumSetType` cannot be a const generic, so `flag` is a runtime
+    // arg. The `match` below preserves the exhaustiveness check.
     pub fn register_for_epoll(
         &mut self,
         flag: Flags,
@@ -1740,7 +1713,6 @@ impl Poll {
             linux::EPOLL_ONESHOT
         };
 
-        // "flag" is comptime to make sure we always check
         let flags: u32 = match flag {
             Flags::Process | Flags::PollReadable => {
                 linux::EPOLL_IN | linux::EPOLL_HUP | linux::EPOLL_ERR | one_shot_flag
@@ -1776,8 +1748,7 @@ impl Poll {
 
         let errno = sys::get_errno(ctl);
         if errno != E::SUCCESS {
-            // TODO(port): bun_sys::Tag::epoll_ctl
-            return Err(sys::Error::from_code(errno, sys::Tag::TODO));
+            return Err(sys::Error::from_code(errno, sys::Tag::epoll_ctl));
         }
         // Only mark if it successfully registered.
         // If it failed to register, we don't want to unregister it later if
@@ -1788,7 +1759,6 @@ impl Poll {
         self.flags.insert(match flag {
             Flags::PollReadable => Flags::PollReadable,
             Flags::PollProcess => {
-                // PORT NOTE: Zig's `Environment.isLinux` is true on Android too.
                 if cfg!(any(target_os = "linux", target_os = "android")) {
                     Flags::PollReadable
                 } else {
@@ -1902,11 +1872,10 @@ impl FilePollRef {
         #[cfg(windows)]
         {
             let _ = force;
-            if self.inner().unregister(loop_) {
-                Ok(())
-            } else {
-                Err(sys::Error::from_code(sys::E::INVAL, sys::Tag::TODO))
-            }
+            // The windows `FilePoll::unregister` always returns true — the
+            // bool is vestigial, so there is no error path to surface here.
+            let _ = self.inner().unregister(loop_);
+            Ok(())
         }
     }
     #[inline]
@@ -1974,8 +1943,7 @@ impl FilePollRef {
         }
         #[cfg(windows)]
         {
-            // Zig spec: `canEnableKeepingProcessAlive` is POSIX-only (posix_event_loop.zig:656-658);
-            // windows_event_loop.zig has no such method. The previous synthesized expression
+            // `canEnableKeepingProcessAlive` is POSIX-only. The previous synthesized expression
             // `!closed && can_ref()` reduced to `!has_incremented_poll_count` — the OPPOSITE
             // polarity of the POSIX semantics (`keeps_event_loop_alive && has_incremented_poll_count`).
             // All callers (PipeWriter PosixWriter, process.rs PollerPosix) are POSIX-only.
@@ -2009,8 +1977,7 @@ pub enum PathOrFileDescriptor<'a> {
 
 // ─── Waker (moved from bun_io) ──────────────────────────────────────────────
 //
-// Ported from src/aio/posix_event_loop.zig:1272-1384 (LinuxWaker / KEventWaker)
-// and src/aio/windows_event_loop.zig:361-383 (Windows Waker). io (T2) owns the
+// io (T2) owns the
 // Waker so `Loop::load` has no upward dep on bun_io (T3). bun_io re-exports.
 
 pub mod waker {
@@ -2042,13 +2009,10 @@ pub mod waker {
         }
 
         pub fn init() -> Result<Self, bun_core::Error> {
-            // TODO(port): migrate to bun_sys::eventfd (the wrapper exists);
-            // currently falls back to crate::safe_c::eventfd.
-            let raw = crate::safe_c::eventfd(0, 0);
-            if raw < 0 {
-                return Err(bun_core::Error::from_errno(bun_sys::last_errno()));
+            match bun_sys::eventfd(0, 0) {
+                Ok(fd) => Ok(Self::init_with_file_descriptor(fd)),
+                Err(err) => Err(bun_core::Error::from_errno(i32::from(err.errno))),
             }
-            Ok(Self::init_with_file_descriptor(Fd::from_native(raw)))
         }
 
         #[inline]
@@ -2161,8 +2125,7 @@ pub mod waker {
 
         pub fn init_with_file_descriptor(kq: i32) -> Result<Self, bun_core::Error> {
             debug_assert!(kq > -1);
-            // PERF(port): Zig used bun.default_allocator.alloc(u8, 1024); Box<[u8]>
-            // owns the buffer for the machport's lifetime.
+            // Box<[u8]> owns the buffer for the machport's lifetime.
             let mut machport_buf = vec![0u8; 1024].into_boxed_slice();
             // SAFETY: FFI call; buf outlives the machport (owned by the returned Waker).
             let machport = unsafe {
@@ -2253,8 +2216,7 @@ pub mod waker {
         /// `loop_` is the process-global singleton from `WindowsLoop::get()`
         /// (set in [`init`]), so the returned pointer has process lifetime —
         /// safe to hand to `uv::Timer::init` and friends without an `unsafe`
-        /// block at the call site. Mirrors Zig's `waker.loop.uv_loop` field
-        /// chain (BundleThread.zig:79).
+        /// block at the call site.
         #[inline]
         pub fn uv_loop(&self) -> *mut bun_sys::windows::libuv::Loop {
             // `BackRef` deref is safe (process-lifetime singleton); `uv_loop`
@@ -2266,8 +2228,7 @@ pub mod waker {
 
 // ─── Closer (moved from bun_io) ─────────────────────────────────────────────
 //
-// Ported from src/aio/posix_event_loop.zig:1386-1406 and
-// src/aio/windows_event_loop.zig:385-411. Schedules an async fd close on the
+// Schedules an async fd close on the
 // thread pool (POSIX) or via uv_fs_close (Windows). io (T2) owns it so
 // `pipes::PollOrFd::close` has no upward dep on bun_io (T3).
 
@@ -2376,5 +2337,3 @@ pub mod closer {
         }
     }
 }
-
-// ported from: src/io/io.zig
diff --git a/src/io/openForWriting.rs b/src/io/openForWriting.rs
index 926a7f8a9bb..c72cb542f20 100644
--- a/src/io/openForWriting.rs
+++ b/src/io/openForWriting.rs
@@ -3,11 +3,8 @@ use bun_core::ZStr;
 use bun_sys::FdExt;
 use bun_sys::{self, Fd, Mode};
 
-// PORT NOTE: Zig's `input_path: anytype` type-switches on `@TypeOf(input_path)` between
-// `bun.webcore.PathOrFileDescriptor` and `[:0]const u8` / `[:0]u8`. Rust has no type-switch,
-// so this is expressed as a sealed trait whose impls encode each `switch (PathT)` arm.
-// TODO(port): verify callers — if only one input type is ever used per call site, consider
-// monomorphizing into two free fns instead of the trait.
+// A sealed trait whose impls cover each accepted input type
+// (`PathOrFileDescriptor` and zero-terminated path slices).
 pub trait OpenForWritingInput {
     fn open_for_writing_result(
         &self,
@@ -195,5 +192,3 @@ where
         return Ok(fd);
     }
 }
-
-// ported from: src/io/openForWriting.zig
diff --git a/src/io/pipes.rs b/src/io/pipes.rs
index 7cb1e3ffb8e..b6247527be5 100644
--- a/src/io/pipes.rs
+++ b/src/io/pipes.rs
@@ -77,7 +77,7 @@ impl PollOrFd {
             // 7) ON ANOTHER THREAD: close(3) = 0,
             // 8) kevent(2, EVFILT_READ, EV_ADD | EV_ENABLE | EV_DISPATCH, 0, 0, 0) = 0
             // 9) ??? No more events for fd 2
-            // PORT NOTE: reshaped for borrowck — take ownership of the Box before
+            // Take ownership of the Box before
             // calling deinit_force_unregister, then leave self = Closed.
             let old = core::mem::replace(self, PollOrFd::Closed);
             if let PollOrFd::Poll(poll) = old {
@@ -89,7 +89,7 @@ impl PollOrFd {
                         close_async = false;
                     }
                 }
-                // Consumes the underlying allocation (Zig: poll.deinitForceUnregister()).
+                // Consumes the underlying allocation.
                 poll.deinit_force_unregister();
             }
         }
@@ -113,9 +113,8 @@ impl PollOrFd {
                 }
             }
             if let Some(f) = on_close_fn {
-                // SAFETY: Zig: onCloseFn(@ptrCast(@alignCast(ctx.?))) — caller
-                // guarantees ctx is Some and properly aligned for the callback's
-                // expected pointee type.
+                // SAFETY: caller guarantees ctx is Some and properly aligned
+                // for the callback's expected pointee type.
                 f(ctx.expect("ctx must be Some when on_close_fn is provided"));
             }
         } else {
@@ -147,5 +146,3 @@ pub enum ReadState {
     /// Received an EAGAIN
     Drained,
 }
-
-// ported from: src/io/pipes.zig
diff --git a/src/io/posix_event_loop.rs b/src/io/posix_event_loop.rs
index 6a82cf50714..942da6b2d8d 100644
--- a/src/io/posix_event_loop.rs
+++ b/src/io/posix_event_loop.rs
@@ -11,8 +11,7 @@ use bun_uws_sys::Loop as UwsLoop;
 
 pub type Loop = UwsLoop;
 
-// PORT NOTE: `addActive`/`subActive` live on `PosixLoop` in Zig (uws_sys/Loop.zig)
-// but the Rust `bun_uws_sys::Loop` only exposes `inc`/`dec`/`ref_`/`unref`. The
+// Note: `bun_uws_sys::Loop` only exposes `inc`/`dec`/`ref_`/`unref`. The
 // `active` counter is a public field, so inline the saturating math here until
 // `bun_uws_sys` grows `add_active`/`sub_active`. On Windows the uws loop has no
 // such counter (libuv tracks active handles itself); `posix_event_loop` is only
@@ -33,7 +32,7 @@ bun_core::declare_scope!(KeepAlive, visible);
 #[cfg(not(windows))]
 use bun_sys::syslog;
 
-/// Local port of `Maybe(T).errnoSys` (Zig: src/runtime/node.zig). `bun_sys`
+/// Local `errno_sys` helper. `bun_sys`
 /// does not yet expose this helper on `Result<T>`; once it does, drop this and
 /// call `sys::Result::<()>::errno_sys` directly.
 ///
@@ -98,7 +97,7 @@ unsafe extern "Rust" {
 /// Kind of fd a `FilePoll` (or pipe reader/writer) is wrapping. Lives here so
 /// `bun_io` (which now depends on this crate) and `FilePoll::file_type` share
 /// one definition; `bun_io::pipes` re-exports it for downstream callers.
-// PORT NOTE: Zig defines this in src/io/pipes.zig; sunk one tier to break the
+// Note: sunk one tier to break the
 // io↔aio cycle (FilePoll::file_type was the only aio→io edge).
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum FileType {
@@ -131,8 +130,7 @@ pub fn get_vm_ctx(kind: AllocatorType) -> EventLoopCtx {
 
 /// JS-thread [`EventLoopCtx`] for `KeepAlive::{ref_,unref}` / `FilePoll`.
 ///
-/// Zig passed `*jsc.VirtualMachine` directly via `anytype` dispatch
-/// (`posix_event_loop.zig:45`); the Rust crate split routes through the
+/// The crate split routes through the
 /// link-time `__bun_get_vm_ctx` hook installed by `bun_runtime::init()`.
 /// Every `Js`-tier caller (i.e. everything outside the install/Mini loop)
 /// wants exactly `get_vm_ctx(AllocatorType::Js)`, so this shorthand replaces
@@ -153,10 +151,9 @@ pub fn js_vm_ctx() -> EventLoopCtx {
 #[cfg(all(target_os = "macos", debug_assertions))]
 type KQueueGenerationNumber = usize;
 #[cfg(all(unix, not(all(target_os = "macos", debug_assertions))))]
-type KQueueGenerationNumber = u8; // PORT NOTE: Zig uses `u0`; smallest Rust int is u8. Gated by cfg below.
+type KQueueGenerationNumber = u8; // Note: conceptually zero-width; smallest Rust int is u8. Gated by cfg below.
 
-// PORTING.md §Global mutable state: counter → Atomic. Debug-only diagnostic;
-// `Relaxed` matches Zig's `+%=` (no synchronization implied).
+// Debug-only diagnostic; `Relaxed` (no synchronization implied).
 #[cfg(all(target_os = "macos", debug_assertions))]
 static MAX_GENERATION_NUMBER: core::sync::atomic::AtomicUsize =
     core::sync::atomic::AtomicUsize::new(0);
@@ -191,15 +188,11 @@ fn make_kevent(
     ev
 }
 
-/// Zig std's `.freebsd` `EV` struct omits EOF; the kernel value is the
+/// The kernel value is the
 /// same as Darwin/OpenBSD (sys/event.h: `#define EV_EOF 0x8000`).
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
 const EV_EOF: u16 = 0x8000;
 
-// PORT NOTE: Zig's `kqueue_or_epoll` comptime literal was only spliced into a
-// `panicLog` that the Rust port routes through `bun_output::panic!` (which
-// already names the syscall via `Tag`). No remaining call site → dropped.
-
 // ──────────────────────────────────────────────────────────────────────────
 // FilePoll Owner — hot-path tag+ptr (CYCLEBREAK §Hot dispatch list).
 // Low tier (here) stores `(tag: u8, ptr: *mut ())`; `bun_runtime::dispatch::on_poll`
@@ -355,8 +348,7 @@ impl FilePoll {
         FileType::Pipe
     }
 
-    // PORT NOTE: Zig `onKQueueEvent`/`onEpollEvent` take `_: *Loop` (unused, raw-pointer
-    // semantics). The Rust signatures drop the loop parameter entirely: holding a
+    // Note: these handlers take no loop parameter: holding a
     // protected `&mut Loop` across `on_update` would alias the fresh `&mut Loop`
     // that downstream `__bun_run_file_poll` handlers conjure via
     // `EventLoopCtx::platform_event_loop()` when they re-enter the loop
@@ -406,7 +398,7 @@ impl FilePoll {
         readable
     }
 
-    // PORT NOTE: not `impl Drop` — FilePoll is pool-allocated (HiveArray) and explicitly
+    // Note: not `impl Drop` — FilePoll is pool-allocated (HiveArray) and explicitly
     // put back via `Store::put`; Drop would be wrong here.
     pub fn deinit(&mut self) {
         let ctx = get_vm_ctx(self.allocator_type);
@@ -461,7 +453,7 @@ impl FilePoll {
 
         // Hot-path hoisted-match: the per-tag `switch` lives in
         // `bun_runtime::dispatch::__bun_run_file_poll` (link-time extern) so
-        // this T3 crate names no variant types. // PERF(port): was inline switch.
+        // this T3 crate names no variant types.
         // SAFETY: `self` is a live FilePoll for the duration of the call
         // (guaranteed by the uws loop callback contract).
         unsafe { __bun_run_file_poll(self, size_or_offset) };
@@ -551,7 +543,7 @@ impl FilePoll {
 
     /// Build a fully-initialized `FilePoll` value for `Store::get_init`.
     ///
-    /// PORT NOTE: the previous `&mut *pool.get()` + field-assign pattern was
+    /// Note: the previous `&mut *pool.get()` + field-assign pattern was
     /// instant validity UB — `FilePoll.owner`/`allocator_type` are enums with
     /// niches, and `&mut FilePoll` over an uninitialized hive slot asserts a
     /// valid discriminant. It also left `generation_number` uninitialized on
@@ -566,8 +558,7 @@ impl FilePoll {
             next_to_free: ptr::null_mut(),
             allocator_type: if vm.is_js() { AllocatorType::Js } else { AllocatorType::Mini },
             #[cfg(all(target_os = "macos", debug_assertions))]
-            // Matches Zig `max_generation_number +%= 1`; single-threaded event
-            // loop so `Relaxed` ordering is sufficient.
+            // Single-threaded event loop so `Relaxed` ordering is sufficient.
             generation_number: MAX_GENERATION_NUMBER
                 .fetch_add(1, core::sync::atomic::Ordering::Relaxed)
                 .wrapping_add(1),
@@ -576,8 +567,7 @@ impl FilePoll {
         }
     }
 
-    // PORT NOTE: Zig branches on @TypeOf(vm) for *PackageManager, EventLoopHandle, else.
-    // Callers normalize to EventLoopCtx before calling.
+    // Note: callers normalize to EventLoopCtx before calling.
     pub fn init(vm: EventLoopCtx, fd: Fd, flags: FlagsSet, owner: Owner) -> *mut FilePoll {
         let value = Self::new_value(vm, fd, flags, owner);
         let generation_number = value.generation_number;
@@ -724,8 +714,7 @@ impl FilePoll {
                 flags |= EPOLL::IN;
             }
 
-            // PORT NOTE: Zig uses `linux.epoll_event{ .data = .{ .ptr = ... } }`;
-            // libc::epoll_event flattens the union to a single `u64` field.
+            // Note: libc::epoll_event flattens the data union to a single `u64` field.
             let mut event = linux::epoll_event {
                 events: flags,
                 u64: Pollable::init(self).ptr() as u64,
@@ -942,9 +931,8 @@ impl FilePoll {
         fd: Fd,
         force_unregister: bool,
     ) -> sys::Result<()> {
-        // PORT NOTE: reshaped for borrowck (Zig `defer this.deactivate(loop)`) — compute the
-        // syscall result first, then unconditionally deactivate. Avoids the raw-pointer scopeguard
-        // the literal translation would require.
+        // Note: compute the syscall result first, then unconditionally
+        // deactivate. Avoids a raw-pointer scopeguard.
         #[cfg(any(
             target_os = "linux",
             target_os = "android",
@@ -1358,7 +1346,9 @@ impl fmt::Display for FlagsFormatter {
 // Store
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): Zig uses `if (bun.heap_breakdown.enabled) 0 else 128` for the hive size.
+// `bun_alloc::heap_breakdown` is a no-op outside macOS Instruments
+// heap-breakdown builds, so the 128-slot hive is unconditional here (same
+// choice as `RuntimeTranspilerStore`'s TranspilerJob hive).
 #[cfg(not(windows))]
 const HIVE_SIZE: usize = 128;
 #[cfg(not(windows))]
@@ -1411,8 +1401,8 @@ impl Store {
     /// `poll` is a live, fully-initialized slot in `self.hive`. It may point
     /// *inside* `self.hive`'s inline `[FilePoll; 128]` buffer, so accepting it
     /// as `&mut FilePoll` while `&mut self` is live would retag overlapping
-    /// storage under Stacked Borrows (UB). Mirror Zig's alias-tolerant
-    /// `poll: *FilePoll` and touch fields only through raw pointer ops — same
+    /// storage under Stacked Borrows (UB). Take it as a raw pointer and
+    /// touch fields only through raw pointer ops — same
     /// rationale as `process_deferred_frees` above.
     pub fn put(&mut self, poll: ptr::NonNull<FilePoll>, vm: EventLoopCtx, ever_registered: bool) {
         let poll = poll.as_ptr();
@@ -1469,9 +1459,9 @@ impl Store {
 // onTick (exported)
 // ──────────────────────────────────────────────────────────────────────────
 
-// `Pollable` mirrors Zig `bun.TaggedPointerUnion(.{FilePoll})`.
+// `Pollable` is a single-variant tagged-pointer union over `FilePoll`.
 //
-// PORT NOTE: `bun_collections::TaggedPtrUnion<(FilePoll,)>` cannot be
+// Note: `bun_collections::TaggedPtrUnion<(FilePoll,)>` cannot be
 // instantiated here — `impl_tagged_ptr_union!` would generate
 // `impl TypeList for (FilePoll,)`, which trips the orphan rule (foreign trait
 // on a tuple). Since the union has exactly one variant, wrap the raw
@@ -1483,7 +1473,7 @@ pub(crate) struct Pollable {
 }
 
 impl Pollable {
-    /// Tag value for `FilePoll` (index 0 in the Zig type tuple → `1024 - 0`).
+    /// Tag value for `FilePoll` (index 0 → `1024 - 0`).
     #[allow(dead_code)]
     pub(crate) const FILE_POLL_TAG: u16 = 1024;
 
@@ -1623,5 +1613,3 @@ mod tests {
         assert_eq!(err.get_errno(), sys::E::EINVAL);
     }
 }
-
-// ported from: src/aio/posix_event_loop.zig
diff --git a/src/io/source.rs b/src/io/source.rs
index 38a15e489b5..47f15fb815c 100644
--- a/src/io/source.rs
+++ b/src/io/source.rs
@@ -86,7 +86,7 @@ pub enum FileState {
 
 impl Default for File {
     fn default() -> Self {
-        // PORT NOTE: std.mem.zeroes(File) — hand-written because `state` is an enum field
+        // Hand-written equivalent of zero-initialization because `state` is an enum field
         // (PORTING.md forbids blanket zeroed() over enums). FileState::Deinitialized == 0.
         Self {
             fs: bun_core::ffi::zeroed(),
@@ -256,7 +256,7 @@ impl Source {
     pub fn get_handle(&mut self) -> *mut uv::Handle {
         match self {
             // SAFETY: uv::Pipe / uv::uv_tty_t embed uv_handle_t as their first member.
-            // `&mut self` so the returned `*mut` carries write provenance (Zig: `getHandle` returns `*uv.Handle`).
+            // `&mut self` so the returned `*mut` carries write provenance.
             Source::Pipe(pipe) => core::ptr::from_mut::<Pipe>(pipe.as_mut()).cast(),
             Source::Tty(tty) => tty.as_ptr().cast(),
             Source::SyncFile(_) | Source::File(_) => unreachable!(),
@@ -266,7 +266,7 @@ impl Source {
     pub fn to_stream(&mut self) -> *mut uv::uv_stream_t {
         match self {
             // SAFETY: uv::Pipe / uv::uv_tty_t embed uv_stream_t as their first member.
-            // `&mut self` so the returned `*mut` carries write provenance (Zig: `toStream` returns `*uv.uv_stream_t`).
+            // `&mut self` so the returned `*mut` carries write provenance.
             Source::Pipe(pipe) => core::ptr::from_mut::<Pipe>(pipe.as_mut()).cast(),
             Source::Tty(tty) => tty.as_ptr().cast(),
             Source::SyncFile(_) | Source::File(_) => unreachable!(),
@@ -327,7 +327,7 @@ impl Source {
     pub fn open_pipe(loop_: *mut uv::Loop, fd: Fd) -> bun_sys::Result<Box<Pipe>> {
         bun_core::scoped_log!(PipeSource, "openPipe (fd = {})", fd);
         let mut pipe: Box<Pipe> = Box::new(bun_core::ffi::zeroed::<Pipe>());
-        // we should never init using IPC here see ipc.zig
+        // we should never init using IPC here
         if let Some(err) = pipe.init(loop_, false).to_error(bun_sys::Tag::pipe) {
             drop(pipe);
             return bun_sys::Result::Err(err);
@@ -406,7 +406,7 @@ impl Source {
         }
     }
 
-    /// Direct accessor for the `File`/`SyncFile` arm (Zig: `source.file`).
+    /// Direct accessor for the `File`/`SyncFile` arm.
     /// Panics on Pipe/Tty — callers gate on `matches!(.., File | SyncFile)`.
     pub fn file(&self) -> &File {
         match self {
@@ -461,7 +461,6 @@ pub mod stdin_tty {
     }
 
     pub(super) fn get_stdin_tty(loop_: *mut uv::Loop) -> bun_sys::Result<bun_ptr::BackRef<Tty>> {
-        // Zig spec (source.zig:247-248): `lock.lock(); defer lock.unlock();`
         // bun_threading::Mutex::lock() returns `()` — must use lock_guard() for RAII
         // unlock-on-drop, otherwise the mutex is held forever and the next call
         // (e.g. Source__setRawModeStdin → open_tty(stdin)) deadlocks/UB-relocks.
@@ -483,9 +482,8 @@ pub mod stdin_tty {
     }
 }
 
-/// Zig spec (source.zig:357) calls `bun.jsc.VirtualMachine.get().uvLoop()` directly,
-/// which is a T6 dependency. PORTING.md §Forbidden bans dep-cycle fn-ptr hooks, so
-/// the uv loop is taken as a parameter instead; the C++ caller
+/// The uv loop is taken as a parameter (reading it from the VM directly would
+/// be a T6 dependency); the C++ caller
 /// (`ProcessBindingTTYWrap.cpp`) supplies `defaultGlobalObject()->uvLoop()`.
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn Source__setRawModeStdin(uv_loop: *mut uv::Loop, raw: bool) -> c_int {
@@ -514,5 +512,3 @@ pub(crate) extern "C" fn Source__setRawModeStdin(uv_loop: *mut uv::Loop, raw: bo
     }
     0
 }
-
-// ported from: src/io/source.zig
diff --git a/src/io/stub_event_loop.rs b/src/io/stub_event_loop.rs
index c8dec31ee3d..edf2c32b097 100644
--- a/src/io/stub_event_loop.rs
+++ b/src/io/stub_event_loop.rs
@@ -3,5 +3,3 @@ bun_opaque::opaque_ffi! {
     pub struct KeepAlive;
     pub struct FilePoll;
 }
-
-// ported from: src/aio/stub_event_loop.zig
diff --git a/src/io/windows_event_loop.rs b/src/io/windows_event_loop.rs
index 1d3dfe873db..572945b71d8 100644
--- a/src/io/windows_event_loop.rs
+++ b/src/io/windows_event_loop.rs
@@ -17,7 +17,7 @@ pub use crate::posix_event_loop::{
 bun_core::declare_scope!(KeepAlive, visible);
 bun_core::declare_scope!(FilePoll, visible);
 
-// Zig `windows_event_loop.zig:1` — `pub const Loop = uv.Loop;` — the raw
+// `Loop` here is the raw
 // `uv_loop_t`. (`WindowsLoop` is the uws wrapper that *owns* a `*mut uv::Loop`
 // in its `.uv_loop` field; callers that hold a `WindowsLoop*` project that
 // field themselves. See `VirtualMachine::event_loop_handle` /
@@ -66,7 +66,6 @@ impl FilePoll {
     }
 
     /// Make calling ref() on this poll into a no-op.
-    // pub fn disableKeepingProcessAlive(this: *FilePoll, vm: *jsc.VirtualMachine) void {
     pub fn disable_keeping_process_alive(&mut self, vm: EventLoopCtx) {
         if self.flags.contains(Flags::Closed) {
             return;
@@ -74,7 +73,6 @@ impl FilePoll {
         self.flags.insert(Flags::Closed);
 
         vm.loop_sub_active(self.flags.contains(Flags::HasIncrementedPollCount) as u32);
-        // vm.event_loop_handle.?.active_handles -= @as(u32, @intFromBool(this.flags.contains(.has_incremented_poll_count)));
     }
 
     pub fn init(vm: EventLoopCtx, fd: Fd, flags: FlagsStruct, owner: Owner) -> *mut FilePoll {
@@ -98,7 +96,7 @@ impl FilePoll {
             .as_ptr()
     }
 
-    // PORT NOTE: not `impl Drop` — FilePoll lives in a HiveArray pool slot, not a Box;
+    // Note: not `impl Drop` — FilePoll lives in a HiveArray pool slot, not a Box;
     // teardown returns the slot to the pool via `Store::put`.
     pub fn deinit(&mut self) {
         self.deinit_with_vm(js_vm_ctx());
@@ -118,10 +116,14 @@ impl FilePoll {
         // the wrong type (it should be a uv handle), at worst this code is a
         // crash due to invalid memory access.
         //
-        // Zig does `@ptrFromInt(@as(u64, @bitCast(this.fd)))`; `Fd` is
-        // `#[repr(transparent)]` over `u64` on Windows, so the bitcast is just
-        // the public backing field.
-        // SAFETY: see TODO above — preserved verbatim from Zig.
+        // SAFETY: in practice this call is unreachable. On Windows nothing
+        // ever sets the `Poll*` registration flags after construction (this
+        // module defines no `register`), and every in-tree constructor passes
+        // empty/default flags, so `is_registered()` stays false and
+        // `deinit_possibly_defer` — the only path here — never takes the
+        // `unregister` branch. If a Windows registration path is ever added,
+        // this cast must be replaced with a real `uv_handle_t` pointer first
+        // (see TODO above); `uv_unref` dereferences its argument.
         unsafe {
             uv::uv_unref(self.fd.0 as *mut uv::uv_handle_t);
         }
@@ -192,7 +194,6 @@ impl FilePoll {
         }
         self.flags.remove(Flags::Closed);
 
-        // vm.event_loop_handle.?.active_handles += @as(u32, @intFromBool(this.flags.contains(.has_incremented_poll_count)));
         vm.loop_add_active(self.flags.contains(Flags::HasIncrementedPollCount) as u32);
     }
 
@@ -201,8 +202,7 @@ impl FilePoll {
     }
 
     /// Only intended to be used from EventLoop.Pollable
-    // PORT NOTE: Zig takes `*Loop = *uv.Loop` here (`vm.event_loop_handle.?`),
-    // but the cycle-broken `EventLoopCtx::platform_event_loop` vtable is typed
+    // Note: the cycle-broken `EventLoopCtx::platform_event_loop` vtable is typed
     // `*mut bun_uws_sys::Loop` (the uws `WindowsLoop` wrapper) so the
     // impl-crate bodies (`VirtualMachine::uws_loop` / `MiniEventLoop::loop_ptr`)
     // type-check. `WindowsLoop::sub_active`/`add_active` proxy straight through
@@ -296,8 +296,7 @@ impl Store {
             // SAFETY: intrusive deferred-free list; nodes are valid HiveArray slots
             // until put(). Walk via raw-pointer reads/writes only — materializing a
             // `&mut FilePoll` here would alias the `&mut self.hive` borrow taken by
-            // `put()` below (the slot may live inside the inline hive buffer). Zig's
-            // `*FilePoll` freely aliases, so raw-ptr discipline is the faithful port.
+            // `put()` below (the slot may live inside the inline hive buffer).
             unsafe {
                 next = (*current).next_to_free;
                 (*current).next_to_free = ptr::null_mut();
@@ -323,7 +322,7 @@ impl Store {
 
         // SAFETY: `poll` is a valid HiveArray slot pointer. It may live inside
         // `self.hive.buffer`, so we access it via raw pointer only (no `&mut FilePoll`
-        // materialized) to avoid aliasing `&mut self` — Zig's `*FilePoll` freely aliases.
+        // materialized) to avoid aliasing `&mut self`.
         debug_assert!(unsafe { (*poll).next_to_free }.is_null());
 
         let tail = self.pending_free_tail;
@@ -381,8 +380,9 @@ unsafe impl Send for Waker {}
 unsafe impl Sync for Waker {}
 
 impl Waker {
+    // `Result` kept (despite being infallible here) for signature parity with
+    // the POSIX wakers, whose `init` can fail (eventfd / kqueue).
     pub fn init() -> Result<Waker, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Waker {
             loop_: bun_ptr::BackRef::from(
                 ptr::NonNull::new(WindowsLoop::get()).expect("WindowsLoop::get() singleton"),
@@ -402,24 +402,17 @@ impl Waker {
         self.loop_.uv_loop
     }
 
-    // TODO(port): Zig used @compileError here; on Windows these must never be linked.
-    pub fn get_fd(&self) -> Fd {
-        unreachable!("Waker.getFd is unsupported on Windows");
-    }
-
-    // TODO(port): Zig used @compileError here; on Windows these must never be linked.
-    pub fn init_with_file_descriptor(_fd: Fd) -> Waker {
-        unreachable!("Waker.initWithFileDescriptor is unsupported on Windows");
-    }
+    // `getFd`/`initWithFileDescriptor` must never be referenced on Windows,
+    // so they are simply not defined here — POSIX-only call sites are
+    // `cfg`-gated, so a stray Windows use fails the build.
 
     pub fn wait(&self) {
         // Do NOT go through `WindowsLoop::wait(&mut self)`: that would
         // materialize a `&mut WindowsLoop` over the process-global singleton
         // for the entire duration of `us_loop_run`/`uv_run`, and a concurrent
         // `wake()` from a worker thread would alias it (two live `&mut T` to
-        // one allocation = UB under Stacked/Tree Borrows). The Zig spec uses
-        // a bare `*WindowsLoop` with no exclusivity; mirror that by calling
-        // the C entry point with the raw pointer directly.
+        // one allocation = UB under Stacked/Tree Borrows). Call the C entry
+        // point with the raw pointer directly — no exclusivity claimed.
         // SAFETY: `loop_` is the live `WindowsLoop::get()` singleton.
         unsafe { waker_c::us_loop_run(self.loop_.as_ptr()) };
     }
@@ -449,5 +442,3 @@ mod waker_c {
 // `Closer` (struct + close/on_close) was duplicated here and in
 // `crate::closer` (lib.rs); the canonical one is re-exported as
 // `bun_io::Closer`. No callers referenced `windows_event_loop::Closer`.
-
-// ported from: src/aio/windows_event_loop.zig
diff --git a/src/io/write.rs b/src/io/write.rs
index 682adbfccdb..45a71c100b5 100644
--- a/src/io/write.rs
+++ b/src/io/write.rs
@@ -1,14 +1,14 @@
 //! Byte-oriented `Write` trait + helpers.
 //!
-//! Port of Zig's `std.Io.Writer` surface that the rest of the codebase actually
+//! The byte-writer surface the rest of the codebase actually
 //! touches (`writeAll`, `writeByte`, `print`, `splatByteAll`, `writeInt`,
-//! `flush`). The Zig writer is a fat-pointer vtable; here it is a normal trait
+//! `flush`). It is a normal trait
 //! whose only required method is [`Write::write_all`]. Everything else is
 //! provided in terms of that, so a sink only needs to spell out how to push a
 //! byte slice.
 //!
 //! This module also provides:
-//!   * [`BufWriter`] — `std.fs.File.writerStreaming`-style buffered wrapper
+//!   * [`BufWriter`] — buffered wrapper
 //!     over a borrowed `&mut [u8]` scratch buffer (no heap allocation).
 //!   * [`FmtAdapter`] — bridge a `core::fmt::Write` sink (e.g. a
 //!     `core::fmt::Formatter`) into a byte-level [`Write`], so byte-producing
@@ -36,7 +36,6 @@ pub use bun_core::write::{IntBe, IntLe, Write};
 // ════════════════════════════════════════════════════════════════════════════
 
 /// Discards all bytes written to it but tracks how many were written.
-/// Port of Zig `std.Io.Writer.Discarding` / `std.io.countingWriter(null_writer)`.
 #[derive(Default)]
 pub struct DiscardingWriter {
     /// Total bytes "written" (discarded) so far.
@@ -71,10 +70,9 @@ impl Write for DiscardingWriter {
 // FixedBufferStream — cursor over an in-memory buffer
 // ════════════════════════════════════════════════════════════════════════════
 
-/// Port of Zig `std.io.FixedBufferStream(B)` — a seekable cursor over a byte
+/// A seekable cursor over a byte
 /// buffer that can act as both a reader (when `B: AsRef<[u8]>`) and a writer
-/// (when `B: AsMut<[u8]>`). `pos` and `buffer` are public to mirror the Zig
-/// struct fields.
+/// (when `B: AsMut<[u8]>`). `pos` and `buffer` are public.
 pub struct FixedBufferStream<B> {
     pub buffer: B,
     pub pos: usize,
@@ -87,13 +85,13 @@ impl<B> FixedBufferStream<B> {
         Self { buffer, pos: 0 }
     }
 
-    /// Seek to absolute position `p`. Zig: `seekTo`.
+    /// Seek to absolute position `p`.
     #[inline]
     pub fn seek_to(&mut self, p: usize) {
         self.pos = p;
     }
 
-    /// Rewind to position 0. Zig: `reset`.
+    /// Rewind to position 0.
     #[inline]
     pub fn reset(&mut self) {
         self.pos = 0;
@@ -109,21 +107,21 @@ impl<'a> FixedBufferStream<&'a mut [u8]> {
 }
 
 impl<B: AsRef<[u8]>> FixedBufferStream<B> {
-    /// Bytes written so far (the slice `[0..pos]`). Zig: `getWritten()`.
+    /// Bytes written so far (the slice `[0..pos]`).
     #[inline]
     pub fn get_written(&self) -> &[u8] {
         &self.buffer.as_ref()[..self.pos]
     }
 
-    /// Current cursor position. Zig: `getPos()`.
+    /// Current cursor position.
     #[inline]
     pub fn get_pos(&self) -> Result<usize> {
         Ok(self.pos)
     }
 
-    /// Zig `reader()` returns a `Reader` view over the same buffer; the read
-    /// methods here live directly on `FixedBufferStream`, so this just returns
-    /// `self` to keep call-site shape (`stream.reader().read_int_le::<T>()`).
+    /// The read methods live directly on `FixedBufferStream`, so this just
+    /// returns `self` to keep call-site shape
+    /// (`stream.reader().read_int_le::<T>()`).
     #[inline]
     pub fn reader(&mut self) -> &mut Self {
         self
@@ -131,7 +129,6 @@ impl<B: AsRef<[u8]>> FixedBufferStream<B> {
 
     /// Read up to `out.len()` bytes from the current position, advancing it.
     /// Returns the number of bytes read (may be `< out.len()` at EOF).
-    /// Zig: `reader().readAll(buf)`.
     pub fn read_all(&mut self, out: &mut [u8]) -> Result<usize> {
         let buf = self.buffer.as_ref();
         let avail = buf.len().saturating_sub(self.pos);
@@ -157,7 +154,7 @@ impl<B: AsRef<[u8]>> FixedBufferStream<B> {
         Ok(())
     }
 
-    /// Read a little-endian integer. Zig: `reader().readInt(T, .little)`.
+    /// Read a little-endian integer.
     #[inline]
     pub fn read_int_le<I: IntLe>(&mut self) -> Result<I> {
         let mut bytes = I::Bytes::default();
@@ -165,7 +162,7 @@ impl<B: AsRef<[u8]>> FixedBufferStream<B> {
         Ok(I::from_le_bytes(bytes))
     }
 
-    /// Read a big-endian (network-order) integer. Zig: `reader().readInt(T, .big)`.
+    /// Read a big-endian (network-order) integer.
     #[inline]
     pub fn read_int_be<I: IntBe>(&mut self) -> Result<I> {
         let mut bytes = I::Bytes::default();
@@ -173,10 +170,10 @@ impl<B: AsRef<[u8]>> FixedBufferStream<B> {
         Ok(I::from_be_bytes(bytes))
     }
 
-    /// Read a POD struct. Zig: `reader().readStruct(T)`.
+    /// Read a POD struct.
     ///
     /// SAFETY: caller is responsible for `T` being `#[repr(C)]` POD with no
-    /// padding-sensitive invariants — same contract as Zig's `readStruct`.
+    /// padding-sensitive invariants.
     pub fn read_struct<T: Copy>(&mut self) -> Result<T> {
         let buf = self.buffer.as_ref();
         let n = core::mem::size_of::<T>();
@@ -189,8 +186,8 @@ impl<B: AsRef<[u8]>> FixedBufferStream<B> {
         }
         // SAFETY: `buf[pos..end]` is exactly `size_of::<T>()` initialized
         // bytes from the safe slice borrow; caller contract guarantees `T` is
-        // `#[repr(C)]` POD where every byte pattern is valid (same as Zig
-        // `readStruct`). `read_unaligned` tolerates any source alignment.
+        // `#[repr(C)]` POD where every byte pattern is valid.
+        // `read_unaligned` tolerates any source alignment.
         let out = unsafe { core::ptr::read_unaligned(buf[self.pos..end].as_ptr().cast::<T>()) };
         self.pos = end;
         Ok(out)
@@ -223,12 +220,11 @@ impl<B: AsMut<[u8]>> Write for FixedBufferStream<B> {
 
 /// Buffered writer over a caller-provided scratch slice.
 ///
-/// Port of Zig `std.fs.File.writerStreaming(&buf)` / `std.io.BufferedWriter`:
-/// the caller owns the byte buffer (typically a stack `[0u8; 4096]`), so this
+/// The caller owns the byte buffer (typically a stack `[0u8; 4096]`), so this
 /// type performs **no heap allocation**. Writes accumulate into `buf` and are
 /// flushed to `inner` when full or on explicit [`flush`](Write::flush).
 ///
-/// `Drop` does **not** flush — matching Zig semantics, where forgetting to
+/// `Drop` does **not** flush — forgetting to
 /// `flush()` is a bug the caller owns (and flushing in `Drop` would swallow the
 /// error). Callers must `writer.flush()?` before the buffer goes out of scope.
 pub struct BufWriter<'a, W: Write> {
@@ -312,8 +308,7 @@ impl<'a, W: Write> Write for BufWriter<'a, W> {
 /// can be passed where a byte-level [`Write`] is expected.
 ///
 /// Bytes are routed through `write_str` after a UTF-8 check; non-UTF-8 input is
-/// lossily decoded (same behaviour as Zig's `{s}` formatter on arbitrary
-/// bytes — it never fails on encoding, only on the underlying writer).
+/// lossily decoded — it never fails on encoding, only on the underlying writer.
 pub struct FmtAdapter<'a, W: ?Sized = fmt::Formatter<'a>> {
     inner: &'a mut W,
 }
diff --git a/src/js/builtins/BundlerPlugin.ts b/src/js/builtins/BundlerPlugin.ts
index 083a7c2949b..94c5d8f7a6a 100644
--- a/src/js/builtins/BundlerPlugin.ts
+++ b/src/js/builtins/BundlerPlugin.ts
@@ -129,8 +129,8 @@ export function runOnEndCallbacks(
   }
 
   if (promises.length > 0) {
-    // we return the promise here because detecting if the promise was handled or not
-    // in bundle_v2.zig is done by checking if this function did not return undefined
+    // we return the promise here because the native bundler detects whether the
+    // promise was handled by checking if this function did not return undefined
     return Promise.all(promises).then(
       () => {
         if (buildRejection !== undefined) {
diff --git a/src/js/builtins/ReadableStreamInternals.ts b/src/js/builtins/ReadableStreamInternals.ts
index 5ea53f67fa7..9515b0e02d2 100644
--- a/src/js/builtins/ReadableStreamInternals.ts
+++ b/src/js/builtins/ReadableStreamInternals.ts
@@ -854,7 +854,7 @@ export function assignStreamIntoResumableSink(stream, sink) {
     }
 
     // Native ResumableSink invokes this as (undefined, reason) — see
-    // ResumableSink.cancel in ResumableSink.zig. The first slot is unused
+    // the native ResumableSink.cancel. The first slot is unused
     // here (we close over `stream`), but the parameter is required so the
     // abort reason lands in the right argument.
     function cancelStream(_, reason: Error | null) {
diff --git a/src/js/bun/sql.ts b/src/js/bun/sql.ts
index 49bd9ae424f..c3a74582a25 100644
--- a/src/js/bun/sql.ts
+++ b/src/js/bun/sql.ts
@@ -1039,7 +1039,7 @@ SQL.SQLiteError = SQLiteError;
 SQL.MySQLError = MySQLError;
 
 // // Helper functions for native code to create error instances
-// // These are internal functions used by Zig/C++ code
+// // These are internal functions used by native code
 // export function $createPostgresError(
 //   message: string,
 //   code: string,
diff --git a/src/js/eval/fuzzilli-reprl.ts b/src/js/eval/fuzzilli-reprl.ts
index 4289c7fbb03..67f739c64ce 100644
--- a/src/js/eval/fuzzilli-reprl.ts
+++ b/src/js/eval/fuzzilli-reprl.ts
@@ -23,7 +23,7 @@ process.execve = () => {};
 // ============================================================================
 
 // Verify we're running under Fuzzilli before starting REPRL loop
-// The Zig code should have already checked, but double-check here
+// The native side should have already checked, but double-check here
 try {
   // Try to stat fd 100 to see if it exists
   fs.fstatSync(REPRL_CRFD);
diff --git a/src/js/internal-for-testing.ts b/src/js/internal-for-testing.ts
index 8a75f74746c..10064f1f8b3 100644
--- a/src/js/internal-for-testing.ts
+++ b/src/js/internal-for-testing.ts
@@ -82,15 +82,6 @@ export const subprocessInternals = {
 
 export const iniInternals = {
   parse: $newZigFunction("ini.zig", "IniTestingAPIs.parse", 1),
-  // loadNpmrc: (
-  //   src: string,
-  //   env?: Record<string, string>,
-  // ): {
-  //   default_registry_url: string;
-  //   default_registry_token: string;
-  //   default_registry_username: string;
-  //   default_registry_password: string;
-  // } => $newZigFunction("ini.zig", "IniTestingAPIs.loadNpmrcFromJS", 2)(src, env),
   loadNpmrc: $newZigFunction("ini.zig", "IniTestingAPIs.loadNpmrcFromJS", 2),
 };
 
diff --git a/src/js/internal/fs/binding.ts b/src/js/internal/fs/binding.ts
index 467f75a94c0..656eabc8504 100644
--- a/src/js/internal/fs/binding.ts
+++ b/src/js/internal/fs/binding.ts
@@ -1,3 +1,3 @@
-// The native `node:fs` binding (`createBinding` in `node_fs_binding.zig`), created once here
+// The native `node:fs` binding (`createBinding`), created once here
 // and shared by `node:fs`, `node:fs/promises`, and the lazily loaded `internal/fs/*` modules.
 export default $zig("node_fs_binding.zig", "createBinding") as $ZigGeneratedClasses.NodeJSFS;
diff --git a/src/js/internal/fs/watchfile.ts b/src/js/internal/fs/watchfile.ts
index 1e06761174b..d09944a6b65 100644
--- a/src/js/internal/fs/watchfile.ts
+++ b/src/js/internal/fs/watchfile.ts
@@ -6,7 +6,7 @@ const { getValidatedPath, throwIfNullBytesInFileName } = require("internal/valid
 // The native `node:fs` binding, shared via `internal/fs/binding`.
 const fs = require("internal/fs/binding");
 
-/** Implemented in `node_fs_stat_watcher.zig` */
+/** Implemented natively. */
 interface StatWatcherHandle {
   ref();
   unref();
diff --git a/src/js/internal/sql/mysql.ts b/src/js/internal/sql/mysql.ts
index 716683d38aa..f94578e56ed 100644
--- a/src/js/internal/sql/mysql.ts
+++ b/src/js/internal/sql/mysql.ts
@@ -41,7 +41,7 @@ initMySQL(
     }
 
     if (!is_last) {
-      // The Zig side swaps the pending value out for js_undefined before
+      // The native side swaps the pending value out for js_undefined before
       // invoking this callback; re-prime so the follow-up result set lands in
       // a fresh array.
       query[_handle].setPendingValue(new SQLResultArray());
diff --git a/src/js/node/_http2_upgrade.ts b/src/js/node/_http2_upgrade.ts
index a40b18b326a..daa028b4322 100644
--- a/src/js/node/_http2_upgrade.ts
+++ b/src/js/node/_http2_upgrade.ts
@@ -128,7 +128,7 @@ function tlsSocketFinal(this: TLSProxySocket, callback: () => void) {
 }
 
 // ---------------------------------------------------------------------------
-// Socket callbacks — called by Zig with `this` = native handle (not useful).
+// Socket callbacks — called natively with `this` = native handle (not useful).
 // All are bound to tlsSocket so `this` inside each = tlsSocket.
 // ---------------------------------------------------------------------------
 
@@ -281,14 +281,14 @@ function noop() {}
 // targets the H2 connectionListener instead of a generic secureConnection event.
 //
 // Data flow after upgrade:
-//   rawSocket (TCP) → upgradeDuplexToTLS (Zig TLS layer) → socket callbacks
+//   rawSocket (TCP) → upgradeDuplexToTLS (native TLS layer) → socket callbacks
 //     → tlsSocket.push() → H2 session reads
-//   H2 session writes → tlsSocket._write() → handle.$write() → Zig TLS layer → rawSocket
+//   H2 session writes → tlsSocket._write() → handle.$write() → native TLS layer → rawSocket
 //
 // CRITICAL: We do NOT set tlsSocket._handle to the native TLS handle.
 // If we did, the H2FrameParser constructor would detect it as a JSTLSSocket
 // and call attachNativeCallback(), which intercepts all decrypted data at the
-// Zig level, completely bypassing our JS data callback and Duplex.push() path.
+// native level, completely bypassing our JS data callback and Duplex.push() path.
 // Instead, we store the handle in _ctx.nativeHandle so _read/_write/_destroy
 // can use it, while the H2 session sees _handle as null and uses the JS-level
 // socket.on("data") → Duplex → parser.read() path for incoming frames.
@@ -326,17 +326,17 @@ function upgradeRawSocketToH2(
   tlsSocket._requestCert = server._requestCert || false;
   tlsSocket._rejectUnauthorized = server._requestCert ? server._rejectUnauthorized : false;
 
-  // socket: callbacks — bind to tlsSocket since Zig calls them with native handle as `this`
+  // socket: callbacks — bind to tlsSocket since they are invoked with the native handle as `this`
   let handle: NativeHandle, events: UpgradeContextType["events"];
   try {
     // upgradeDuplexToTLS wraps rawSocket with a TLS layer in server mode (isServer: true).
-    // The Zig side will:
+    // The native side will:
     //   1. Read encrypted data from rawSocket via events[0..3]
     //   2. Decrypt it through the TLS engine (with ALPN negotiation for "h2")
     //   3. Call our socket callbacks below with the decrypted plaintext
     //
     // ALPNProtocols: server.ALPNProtocols is a Buffer in wire format (e.g. <Buffer 02 68 32>
-    // for ["h2"]). The Zig SSLConfig expects an ArrayBuffer, so we slice the underlying buffer.
+    // for ["h2"]). The native SSLConfig expects an ArrayBuffer, so we slice the underlying buffer.
     [handle, events] = upgradeDuplexToTLS(rawSocket, {
       isServer: true,
       tls: {
@@ -373,13 +373,13 @@ function upgradeRawSocketToH2(
 
   // Store handle in _ctx (NOT on tlsSocket._handle).
   // This prevents H2FrameParser from attaching as native callback which would
-  // intercept data at the Zig level and bypass our Duplex push path.
+  // intercept data at the native level and bypass our Duplex push path.
   tlsSocket._ctx.nativeHandle = handle;
   tlsSocket._ctx.events = events;
 
   // Wire up the raw TCP socket to feed encrypted data into the TLS layer.
   // events[0..3] are native event handlers returned by upgradeDuplexToTLS that
-  // the Zig TLS engine expects to receive data/end/drain/close through.
+  // the native TLS engine expects to receive data/end/drain/close through.
   rawSocket.on("data", events[0]);
   rawSocket.on("end", events[1]);
   rawSocket.on("drain", events[2]);
diff --git a/src/js/node/async_hooks.ts b/src/js/node/async_hooks.ts
index c333a58322b..c06d4cbceeb 100644
--- a/src/js/node/async_hooks.ts
+++ b/src/js/node/async_hooks.ts
@@ -9,7 +9,7 @@
 // in the promise reaction) and then just before we call .then, we restore it.
 //
 // This means context tracking is *kind-of* manual. If we receive a callback in native code
-// - In Zig, call jsValue.withAsyncContextIfNeeded(); which returns another JSValue. Store that and
+// - In Rust, call jsValue.with_async_context_if_needed(); which returns another JSValue. Store that and
 //   then run .$call() on it later.
 // - In C++, call AsyncContextFrame::withAsyncContextIfNeeded(jsValue). Then to call it,
 //   use AsyncContextFrame:: call(...) instead of JSC:: call.
diff --git a/src/js/node/child_process.ts b/src/js/node/child_process.ts
index e2e9fb0a904..9cf9a6acb98 100644
--- a/src/js/node/child_process.ts
+++ b/src/js/node/child_process.ts
@@ -1482,7 +1482,7 @@ class ChildProcess extends EventEmitter {
     // We still need this send function because
     return this.#handle.send(message, handle, options, err => {
       // node does process.nextTick() to emit or call the callback
-      // we don't need to because the send callback is called on nextTick by ipc.zig
+      // we don't need to because the native IPC layer calls the send callback on nextTick
       if (callback) {
         callback(err);
       } else if (err) {
diff --git a/src/js/node/net.ts b/src/js/node/net.ts
index 5cb14482ea8..54a1e372341 100644
--- a/src/js/node/net.ts
+++ b/src/js/node/net.ts
@@ -2410,7 +2410,7 @@ Server.prototype[kRealListen] = function (
 
   if (contexts) {
     for (const [name, context] of contexts) {
-      // tls.ts stores the InternalSecureContext wrapper; the Zig side wants
+      // tls.ts stores the InternalSecureContext wrapper; the native side wants
       // the native SSL_CTX wrapper at `.context`.
       addServerName(this._handle, name, context.context ?? context);
     }
diff --git a/src/js/node/tls.ts b/src/js/node/tls.ts
index c684f4f00a7..dfa910558b5 100644
--- a/src/js/node/tls.ts
+++ b/src/js/node/tls.ts
@@ -396,7 +396,7 @@ function checkServerIdentity(hostname, cert) {
 }
 
 // Native SSL_CTX wrapper. `intern()` is WeakGCMap-memoised by config digest
-// (the native `SSLContextCache` underneath is shared with every Zig consumer
+// (the native `SSLContextCache` underneath is shared with every native consumer
 // — Postgres, Valkey, `Bun.connect`, …), so identical options return the same
 // native handle and the same `SSL_CTX*`. Replaces the SHA-256/WeakRef cache
 // that used to live in this file.
@@ -667,7 +667,7 @@ TLSSocket.prototype.getPeerCertificate = function getPeerCertificate(abbreviated
 };
 
 TLSSocket.prototype.getCertificate = function getCertificate() {
-  // need to implement certificate on socket.zig
+  // getCertificate is not yet implemented on the native socket
   const cert = this._handle?.getCertificate?.();
   if (cert) {
     // It's not a peer cert, but the formatting is identical.
@@ -738,7 +738,7 @@ function Server(options, secureConnectionListener): void {
     }
     if (this._handle) {
       // Pass the native SSL_CTX wrapper, not the JS InternalSecureContext —
-      // the Zig side detects it via SecureContext.fromJS and up_refs.
+      // the native side detects it via SecureContext.fromJS and up_refs.
       addServerName(this._handle, hostname, context.context);
     } else {
       if (!contexts) contexts = new Map();
diff --git a/src/js/private.d.ts b/src/js/private.d.ts
index 8c7b3e9ed29..2c0d72d5dc9 100644
--- a/src/js/private.d.ts
+++ b/src/js/private.d.ts
@@ -243,7 +243,7 @@ declare function $newZigFunction<T = (...args: any) => any>(
   argCount: number,
 ): T;
 /**
- * Retrieves a handle to a function defined in Zig or C++, defined in a
+ * Retrieves a handle to a function defined in native code, defined in a
  * `.bind.ts` file. For more information on how to define bindgen functions, see
  * [bindgen's documentation](https://bun.com/docs/project/bindgen).
  * @param filename - The basename of the `.bind.ts` file.
diff --git a/src/js_parser/defines_table.rs b/src/js_parser/defines_table.rs
index 75cf1641b1b..683eb5f0798 100644
--- a/src/js_parser/defines_table.rs
+++ b/src/js_parser/defines_table.rs
@@ -18,7 +18,7 @@ use crate::defines;
 use bun_ast::ExprData;
 use std::sync::OnceLock;
 
-// Zig: `string = []const u8`; each entry is a property-access chain (`&[_]string{...}`).
+// Each entry is a property-access chain.
 pub static GLOBAL_NO_SIDE_EFFECT_PROPERTY_ACCESSES: &[&[&[u8]]] = &[
     // Array: Static methods
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Static_methods
@@ -191,8 +191,7 @@ pub static GLOBAL_NO_SIDE_EFFECT_FUNCTION_CALLS_SAFE_FOR_TO_STRING: &[&[&[u8]]]
     // Haven't seen a bundle size improvement from adding more to this list yet.
 ];
 
-// PORTING.md §Concurrency: `OnceLock` for lazily-initialised statics (Zig used
-// const struct literals; `DefineData` is not const-constructible in Rust).
+// `OnceLock` for lazily-initialised statics (`DefineData` is not const-constructible).
 //
 // `DefineData` is not `Send`/`Sync` in general (it carries `ExprData`, whose
 // boxed variants hold `NonNull<_>`). The four instances stored here only ever
@@ -272,7 +271,6 @@ mod identifiers {
 pub(crate) enum PureGlobalIdentifierValue {
     NaN,
     Infinity,
-    /// Zig: `@"strict undefined"`
     StrictUndefined,
     Other,
 }
@@ -289,5 +287,3 @@ impl PureGlobalIdentifierValue {
 }
 
 include!("defines_table.generated.rs");
-
-// ported from: src/bundler/defines-table.zig
diff --git a/src/js_parser/fold.rs b/src/js_parser/fold.rs
index f9b208246ca..efa0bf996a0 100644
--- a/src/js_parser/fold.rs
+++ b/src/js_parser/fold.rs
@@ -46,9 +46,7 @@ fn e_string_eql_bytes(s: &E::EString, other: &[u8]) -> bool {
     }
 }
 
-// Zig: `pub fn AstMaybe(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
+// File-split mixin pattern: a direct `impl P` block.
 
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     pub fn maybe_relocate_vars_to_top_level(
@@ -128,7 +126,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let p = self;
         let name_static = E::Str::new(name);
 
-        // Zig labeled switch with `continue :sw` → loop + match with mutable scrutinee.
+        // Loop + match with mutable scrutinee (a restartable switch).
         let mut sw_data = target.data;
         'sw: loop {
             match sw_data {
@@ -139,8 +137,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     // module linking just to rewrite these EDot expressions.
                     if p.options.bundle {
                         if p.import_items_for_namespace.contains_key(&id.ref_) {
-                            // PORT NOTE: reshaped for borrowck — Zig held `*ImportItemForNamespaceMap`
-                            // across `p.newSymbol`; split into lookup → (maybe new_symbol) → re-borrow.
+                            // Note: split into lookup → (maybe new_symbol) → re-borrow for borrowck.
                             let existing = p
                                 .import_items_for_namespace
                                 .get(&id.ref_)
@@ -325,12 +322,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                         return None;
                                     }
                                 }
-                                // Zig: `for (props) |prop| { ... } else { deopt; return null }`
-                                // — the loop body has no `break`, so the `else` arm runs on
-                                // every normal completion (including empty `props`). The
-                                // entire stmts/decls/clause_items rewriting block that follows
-                                // in the Zig source is therefore unreachable there too and is
-                                // dropped from the port.
+                                // The loop above always runs to completion (no `break`), so
+                                // this block runs on every normal completion (including empty
+                                // `props`).
                                 {
                                     // empty object de-opts because otherwise the statement becomes
                                     // <empty space> = {};
@@ -389,8 +383,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                     return None;
                                 }
 
-                                // PORT NOTE: reshaped for borrowck — Zig held the
-                                // `getOrPut` entry across `p.newSymbol`.
+                                // Note: lookup is split from insertion for borrowck.
                                 let ref_ = if let Some(existing) =
                                     p.commonjs_named_exports.get(name)
                                 {
@@ -588,7 +581,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         inner_use.count_estimate += 1;
                     }
                 }
-                // Zig: `inline .e_dot, .e_index => |data, tag|` — expanded per arm
+                // EDot and EIndex are handled with structurally identical arms.
                 js_ast::ExprData::EDot(data) => {
                     if matches!(p.ts_namespace.expr, js_ast::ExprData::EDot(ns_data) if data.as_ptr() == ns_data.as_ptr())
                         && identifier_opts.assign_target() == js_ast::AssignTarget::None
@@ -619,7 +612,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                         return None;
                                     }
 
-                                    // PORT NOTE: reshaped for borrowck — see exports_ref arm above.
+                                    // Note: reshaped for borrowck — see exports_ref arm above.
                                     let ref_ = if let Some(existing) =
                                         p.commonjs_named_exports.get(name)
                                     {
@@ -699,7 +692,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                 loc,
                             });
                         }
-                        // Zig: `bun.ComptimeStringMap(void, ...)` over 7 fixed keys.
+                        // Membership check over 7 fixed keys.
                         let in_lookup_table = matches!(
                             name,
                             b"decline"
@@ -818,7 +811,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn check_if_defined_helper(&mut self, expr: Expr) -> Result<Expr, bun_core::Error> {
         let p = self;
-        // TODO(port): narrow error set
         let flags = if matches!(expr.data, js_ast::ExprData::EIdentifier(_)) {
             E::UnaryFlags::WAS_ORIGINALLY_TYPEOF_IDENTIFIER
         } else {
@@ -845,7 +837,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn maybe_defined_helper(&mut self, identifier_expr: Expr) -> Result<Expr, bun_core::Error> {
         let p = self;
-        // TODO(port): narrow error set
         let test_ = Self::check_if_defined_helper(p, identifier_expr)?;
         let object_ref = p
             .find_symbol(bun_ast::Loc::EMPTY, b"Object")
@@ -881,5 +872,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         );
     }
 }
-
-// ported from: src/js_parser/ast/maybe.zig
diff --git a/src/js_parser/lexer.rs b/src/js_parser/lexer.rs
index 1ba724ae858..291cbd0ed0a 100644
--- a/src/js_parser/lexer.rs
+++ b/src/js_parser/lexer.rs
@@ -1,6 +1,4 @@
 //! JavaScript/JSON lexer.
-//!
-//! Port of `src/js_parser/lexer.zig`.
 
 use core::fmt;
 
@@ -13,11 +11,8 @@ use bun_core::strings::CodepointIterator;
 use bun_core::{Environment, feature_flags as FeatureFlags};
 use identifier as js_identifier;
 // MOVE-IN: Indentation now lives in this crate (was bun_js_printer::Options::Indentation).
-use bun_ast::{Indentation, IndentationCharacter};
-// TODO(port): arena threading — js_parser is an AST crate; many `arena.*` calls below
-// should use `&'bump bumpalo::Bump`. For now we keep a `&dyn Allocator`-ish slot and
-// route owned buffers through `Vec`/`Box`.
 use bun_alloc::Arena;
+use bun_ast::{Indentation, IndentationCharacter};
 
 // Unicode ID-Start/ID-Continue tables moved DOWN to `bun_core` (pure data;
 // no upward deps) so `bun_core::lexer` / `MutableString` get full coverage
@@ -123,15 +118,14 @@ impl Default for JSONOptions {
     }
 }
 
-/// Zig's `NewLexer(comptime json_options)` and `NewLexer_(comptime ...bools)` return a struct
-/// type. In Rust we model this as a generic over the eight comptime bools.
+/// The lexer is generic over the eight const bools of the option set.
 ///
-/// `Lexer` (below) is the default instantiation (`NewLexer(.{})`).
+/// `Lexer` (below) is the default instantiation.
 ///
 /// nightly-2025-12-10 rejects field projection (`J.is_json`) on a
 /// `const J: JSONOptions` parameter inside a generic-const expression
 /// ("overly complex generic constant"), even with `generic_const_exprs`.
-/// The Zig comptime-struct param is therefore modeled as a *type* parameter
+/// The option set is therefore modeled as a *type* parameter
 /// implementing [`JsonOptionsT`], whose associated consts *are* accepted in
 /// const-argument position under `generic_const_exprs`. Callers define a ZST
 /// per option set and `impl JsonOptionsT for It { const IS_JSON: bool = true; … }`.
@@ -145,7 +139,7 @@ pub trait JsonOptionsT {
     const WAS_ORIGINALLY_MACRO: bool = false;
     const GUESS_INDENTATION: bool = false;
 
-    /// Reify as a value (mirrors the Zig `json_options` local).
+    /// Reify as a value.
     const OPTIONS: JSONOptions = JSONOptions {
         is_json: Self::IS_JSON,
         allow_comments: Self::ALLOW_COMMENTS,
@@ -179,7 +173,6 @@ pub type NewLexer<'a, J: JsonOptionsT = DefaultJsonOptions> = LexerType<
     { <J as JsonOptionsT>::GUESS_INDENTATION },
 >;
 
-// TODO(port): `thiserror` not in this crate's deps; hand-roll Display/Error.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, strum::IntoStaticStr)]
 pub enum Error {
     UTF8Fail,
@@ -188,8 +181,6 @@ pub enum Error {
     UnexpectedSyntax,
     JSONStringsMustUseDoubleQuotes,
     ParserError,
-    // TODO(port): Zig `error.Backtrack` is returned from `expected()` but not declared in
-    // the local error set; modeled here as an extra variant.
     Backtrack,
 }
 bun_core::impl_tag_error!(Error);
@@ -241,16 +232,10 @@ pub struct ScanResult<'a> {
     pub contents: &'a [u8],
 }
 
-// PORT NOTE: Zig's `FakeArrayList16` (fixed-slice writer with the `append` surface of an
-// ArrayList) is dead — every `decodeEscapeSequences` callsite in lexer.zig passes
-// `std.array_list.Managed(u16)`. Dropped instead of porting; `decode_escape_sequences` is
-// monomorphized to `Vec<u16>`.
-
 /// POD snapshot of all backtrack-relevant lexer state.
 ///
-/// Zig backtracks via `const old = lexer.*; ...; lexer.* = old;` — a full struct
-/// copy. Rust can't do that here because `LexerType` holds `log: &'a mut Log`
-/// (non-`Clone`, non-`Copy`, unique borrow). Instead, callers do:
+/// Backtracking can't snapshot the lexer with a full struct copy because
+/// `LexerType` owns heap-backed buffers and a `Log` pointer. Instead, callers do:
 ///
 /// ```ignore
 /// let snap = p.lexer.snapshot();
@@ -314,8 +299,8 @@ pub struct LexerType<
     const GUESS_INDENTATION: bool,
 > {
     // err: ?LexerType.Error,
-    /// Raw pointer to the caller-owned `Log`. Zig held a `*Log` here while the
-    /// parser held a second aliasing `*Log`; Rust cannot store two `&mut Log`
+    /// Raw pointer to the caller-owned `Log`. The parser holds a second
+    /// aliasing pointer to the same `Log`; Rust cannot store two `&mut Log`
     /// to the same allocation (Stacked-Borrows UB), so both the lexer and the
     /// parser keep `NonNull<Log>` and reborrow at use sites via `log()`. The
     /// `init*` constructors take a plain `&mut Log` (not tied to `'a`); the
@@ -323,11 +308,7 @@ pub struct LexerType<
     /// `init_without_reading`.
     pub log: core::ptr::NonNull<Log>,
     pub source: &'a Source,
-    /// Cached `source.contents()` slice. Zig stores `source: logger.Source` by
-    /// value with `contents: []const u8` (flat ptr+len), so the per-byte
-    /// `it.source.contents.ptr[current]` is one direct load and the
-    /// `noalias *LexerType` lets LLVM keep it register-resident across the
-    /// whole `next()` switch. With `source: &'a Source` plus
+    /// Cached `source.contents()` slice. With `source: &'a Source` plus
     /// `Source.contents: Cow<'static,[u8]>`, every inlined `step()` was a
     /// 3-load dependent chain (`self.source` → Cow tag/ptr → Cow len) that
     /// LLVM could not hoist (perf-annotate showed `mov 0x70(%rbx),%rax` at
@@ -340,7 +321,7 @@ pub struct LexerType<
     /// call and thread it by value into every hot sub-scanner
     /// (`step_with()`, `next_codepoint_with()`, `parse_string_literal_inner()`,
     /// `parse_numeric_literal_or_dot()`), so the ptr+len stays in a register
-    /// for the whole token loop, matching Zig codegen. `source` is kept for
+    /// for the whole token loop. `source` is kept for
     /// error-reporting paths that need `path` / `identifier_name`.
     pub contents: &'a [u8],
     pub current: usize,
@@ -373,21 +354,16 @@ pub struct LexerType<
     pub string_literal_raw_format: StringLiteralRawFormat,
     pub temp_buffer_u16: Vec<u16>,
 
-    /// Only used for JSON stringification when bundling
-    /// This is a zero-bit type unless we're parsing JSON.
-    // TODO(port): Zig uses `if (is_json) bool else void` for zero-cost when !is_json.
-    // PERF(port): always-bool here wastes 1 byte in non-JSON instantiations — profile if hot.
+    /// Only used for JSON stringification when bundling.
     pub is_ascii_only: bool,
     pub track_comments: bool,
     pub all_comments: Vec<Range>,
 
-    // TODO(port): Zig field type is `if (guess_indentation) struct{..} else void`.
-    // PERF(port): always-present here — profile if hot.
+    /// Only meaningful when `GUESS_INDENTATION` is set.
     pub indent_info: IndentInfo,
 }
 
-// Convenience: associated constants mirroring Zig's `const json = json_options;` etc.
-// PORT NOTE: Rust macros must emit complete items; the macro now wraps the
+// Note: Rust macros must emit complete items; the macro now wraps the
 // entire `impl { ... }` block instead of just the header.
 macro_rules! lexer_impl_header {
     ($($body:tt)*) => {
@@ -507,7 +483,8 @@ lexer_impl_header! {
             return Ok(());
         }
 
-        // TODO(port): Zig dupes `notes` with `self.log.msgs.arena`.
+        // The Log API takes an owned `Box<[Data]>` here (error path only,
+        // allocation cost is moot).
         let notes_owned: Box<[bun_ast::Data]> = notes.to_vec().into_boxed_slice();
         self.log()
             .add_range_error_fmt_with_notes(Some(self.source), r, notes_owned, args);
@@ -520,8 +497,7 @@ lexer_impl_header! {
     }
 
     /// Capture a `Copy` snapshot of all backtrack-relevant state. See
-    /// `LexerSnapshot` doc — this replaces Zig's by-value struct copy, which
-    /// Rust can't do here because the lexer owns heap-backed `Vec`s.
+    /// `LexerSnapshot` doc.
     pub fn snapshot(&self) -> LexerSnapshot<'a> {
         LexerSnapshot {
             current: self.current,
@@ -558,12 +534,11 @@ lexer_impl_header! {
         }
     }
 
-    /// Rewind to a prior `snapshot()`. Mirrors Zig's `this.* = original.*` then
-    /// patches back the growable buffers — here we copy each scalar field and
+    /// Rewind to a prior `snapshot()`: copy each scalar field and
     /// truncate the Vecs to their snapshotted lengths. `log`/`source`/`arena`
     /// are left untouched.
     pub fn restore(&mut self, original: &LexerSnapshot<'a>) {
-        // TODO(port): keep this list in sync with the struct fields.
+        // Keep this field list in sync with `snapshot()` and the Lexer struct fields.
         self.current = original.current;
         self.start = original.start;
         self.end = original.end;
@@ -627,8 +602,6 @@ lexer_impl_header! {
         text: &[u8],
         buf: &mut Vec<u16>,
     ) -> Result<(), Error> {
-        // PORT NOTE: monomorphized — Zig is generic over `comptime BufType: type` but every
-        // caller passes `std.array_list.Managed(u16)`; `FakeArrayList16` was dead in the source.
         if IS_JSON {
             self.is_ascii_only = false;
         }
@@ -681,10 +654,6 @@ lexer_impl_header! {
                         0x76 => {
                             // Vertical tab is invalid JSON
                             // We're going to allow it.
-                            // if (comptime is_json) {
-                            //     lexer.end = start + iter.i - width2;
-                            //     try lexer.syntaxError();
-                            // }
                             buf.push(0x0B);
                             continue;
                         }
@@ -900,7 +869,6 @@ lexer_impl_header! {
                                 // fixed-length
                             } else {
                                 // Fixed-length
-                                // comptime var j: usize = 0;
                                 let mut j: usize = 0;
                                 while j < 4 {
                                     match hex_digit_value_u32(c3 as u32) {
@@ -1170,13 +1138,13 @@ lexer_impl_header! {
         &self.contents[self.current..]
     }
 
-    /// PORT NOTE: split into an `#[inline(always)]` ASCII/EOF fast path plus
+    /// Note: split into an `#[inline(always)]` ASCII/EOF fast path plus
     /// an outlined multibyte tail. `step()` is called from ~50 sites inside
     /// the giant `next()` switch and inlines into it; with the multibyte
     /// decode in the same body LLVM declined to inline `next_codepoint`
     /// (showing as a separate ~2.7% symbol). The fast path is now 4 insns
     /// (bounds cmp, load, cmp 0x80, store) so it folds into every `step()`
-    /// site, matching Zig's per-byte `ptr[current]` increment.
+    /// site.
     ///
     /// PERF: takes `contents: &[u8]` by value (a `Copy` fat-ptr) instead of
     /// reloading `self.contents` from the struct. With `self.contents`, every
@@ -1184,8 +1152,8 @@ lexer_impl_header! {
     /// (perf-annotate of `next()` showed that single load at ~7.7% of `next()`
     /// samples) — LLVM couldn't prove the field load loop-invariant across the
     /// intervening `&mut self` writes. As a by-value SSA parameter it stays in
-    /// a register for the whole token loop, matching Zig's `noalias *Lexer`
-    /// codegen. Callers outside the hot loop use the thin `step()` wrapper
+    /// a register for the whole token loop.
+    /// Callers outside the hot loop use the thin `step()` wrapper
     /// below, which loads `self.contents` once.
     #[inline(always)]
     fn next_codepoint_with(&mut self, contents: &[u8]) -> CodePoint {
@@ -1199,9 +1167,8 @@ lexer_impl_header! {
 
         self.end = self.current;
 
-        // ASCII fast path (Zig elides this via the per-byte ptr[current] +
-        // 1-arm switch; here we lift it explicitly so the multibyte branch
-        // is out of the per-byte hot loop entirely).
+        // ASCII fast path, lifted explicitly so the multibyte branch
+        // is out of the per-byte hot loop entirely.
         if first < 0x80 {
             self.current += 1;
             return first as CodePoint;
@@ -1232,7 +1199,6 @@ lexer_impl_header! {
 
     #[inline]
     pub fn expect(&mut self, token: T) -> Result<(), Error> {
-        // PERF(port): Zig param is `comptime token: T` — profile if hot.
         if self.token != token {
             self.expected(token)?;
         }
@@ -1269,8 +1235,7 @@ lexer_impl_header! {
     pub fn scan_identifier_with_escapes(
         &mut self,
         kind: IdentifierKind,
-    ) -> Result<ScanResult<'a>, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<ScanResult<'a>, Error> {
         let mut result = ScanResult {
             token: T::TEndOfFile,
             contents: b"".as_slice(),
@@ -1310,7 +1275,6 @@ lexer_impl_header! {
                     self.step();
                 } else {
                     // Fixed-length
-                    // comptime var j: usize = 0;
                     for _ in 0..4 {
                         match self.code_point {
                             0x30..=0x39 | 0x61..=0x66 | 0x41..=0x46 =>
@@ -1334,7 +1298,7 @@ lexer_impl_header! {
         let original_text = self.raw();
 
         debug_assert!(self.temp_buffer_u16.is_empty());
-        // PORT NOTE: reshaped for borrowck — we move temp_buffer_u16 out, use it, then
+        // Note: reshaped for borrowck — we move temp_buffer_u16 out, use it, then
         // clear and put it back (mirrors `defer clearRetainingCapacity()`).
         let mut tmp = core::mem::take(&mut self.temp_buffer_u16);
         tmp.reserve(original_text.len());
@@ -1343,9 +1307,9 @@ lexer_impl_header! {
         if let Err(e) = decode_res {
             tmp.clear();
             self.temp_buffer_u16 = tmp;
-            return Err(e.into());
+            return Err(e);
         }
-        result.contents = self.utf16_to_string(&tmp)?;
+        result.contents = self.utf16_to_string(&tmp);
         tmp.clear();
         self.temp_buffer_u16 = tmp;
 
@@ -1521,8 +1485,8 @@ lexer_impl_header! {
     /// lexer's inner scanners; the parser calls it from hundreds of sites
     /// (directly and via `expect()`). We deliberately *don't* mark it
     /// `#[inline(never)]` — that turned every `lexer.next()` site into a real
-    /// call + caller-saved-register spill, whereas Zig's `pub fn next` is
-    /// partial-inlinable at leaf call sites (the EOF/`TSemicolon`/`TIdentifier`
+    /// call + caller-saved-register spill; we want it partial-inlinable at
+    /// leaf call sites (the EOF/`TSemicolon`/`TIdentifier`
     /// fast tails fold into the caller and the bulky switch stays out of line).
     /// To make that tractable for LLVM we instead anchor `#[inline(never)]` /
     /// `#[cold]` on the *heavy, rare* sub-scanners (`scan_identifier_with_escapes`,
@@ -1533,7 +1497,7 @@ lexer_impl_header! {
     /// `#[inline(never)]` here). The genuinely hot, tiny scanners
     /// (`latin1_identifier_continue_length`, `parse_numeric_literal_or_dot`,
     /// `parse_string_literal::<QUOTE>`) stay `#[inline]`/`#[inline(always)]` so
-    /// they merge *into* this body the way Zig's comptime monomorphisation does.
+    /// they merge *into* this body.
     pub fn next(&mut self) -> Result<(), Error> {
         self.has_newline_before = self.end == 0;
         self.has_pure_comment_before = false;
@@ -1587,8 +1551,7 @@ lexer_impl_header! {
                         self.step_with(contents);
                         if self.code_point == 0x5C {
                             self.identifier = self
-                                .scan_identifier_with_escapes(IdentifierKind::Private)
-                                .map_err(|_| Error::SyntaxError)? // TODO(port): error coercion
+                                .scan_identifier_with_escapes(IdentifierKind::Private)?
                                 .contents;
                         } else {
                             if !is_identifier_start(self.code_point) {
@@ -1601,8 +1564,7 @@ lexer_impl_header! {
                             }
                             if self.code_point == 0x5C {
                                 self.identifier = self
-                                    .scan_identifier_with_escapes(IdentifierKind::Private)
-                                    .map_err(|_| Error::SyntaxError)?
+                                    .scan_identifier_with_escapes(IdentifierKind::Private)?
                                     .contents;
                             } else {
                                 self.identifier = self.raw();
@@ -2162,24 +2124,20 @@ lexer_impl_header! {
                     self.step_with(contents);
 
                     if self.code_point >= 0x80 {
-                        // @branchHint(.unlikely)
                         while is_identifier_continue(self.code_point) {
                             self.step_with(contents);
                         }
                     }
 
                     if self.code_point != 0x5C {
-                        // @branchHint(.likely)
                         // this code is so hot that if you save lexer.raw() into a temporary variable
                         // it shows up in profiling
                         self.identifier = self.raw();
                         self.token =
                             tables::keyword(self.identifier).unwrap_or(T::TIdentifier);
                     } else {
-                        // @branchHint(.unlikely)
                         let scan_result = self
-                            .scan_identifier_with_escapes(IdentifierKind::Normal)
-                            .map_err(|_| Error::SyntaxError)?; // TODO(port): error coercion
+                            .scan_identifier_with_escapes(IdentifierKind::Normal)?;
                         self.identifier = scan_result.contents;
                         self.token = scan_result.token;
                     }
@@ -2196,8 +2154,7 @@ lexer_impl_header! {
                     }
 
                     let scan_result = self
-                        .scan_identifier_with_escapes(IdentifierKind::Normal)
-                        .map_err(|_| Error::SyntaxError)?;
+                        .scan_identifier_with_escapes(IdentifierKind::Normal)?;
                     self.identifier = scan_result.contents;
                     self.token = scan_result.token;
                 }
@@ -2220,8 +2177,7 @@ lexer_impl_header! {
                         }
                         if self.code_point == 0x5C {
                             let scan_result = self
-                                .scan_identifier_with_escapes(IdentifierKind::Normal)
-                                .map_err(|_| Error::SyntaxError)?;
+                                .scan_identifier_with_escapes(IdentifierKind::Normal)?;
                             self.identifier = scan_result.contents;
                             self.token = scan_result.token;
                         } else {
@@ -2519,7 +2475,7 @@ lexer_impl_header! {
                         if !IS_JSON {
                             let pragma_trigger_pos = self.end; // Position OF #/@
                             // Use remaining() which starts *after* the consumed #/@
-                            // PORT NOTE: reshaped for borrowck — `remaining()` borrows
+                            // Note: reshaped for borrowck — `remaining()` borrows
                             // `self.contents`; `scan_pragma` needs `&mut self`.
                             // Detach via `StoreStr` (arena-owned, lives for parse).
                             let chunk = js_ast::StoreStr::new(self.remaining());
@@ -2664,8 +2620,8 @@ lexer_impl_header! {
     pub fn range(&self) -> Range {
         Range {
             loc: bun_ast::usize2loc(self.start),
-            // TODO(port): std.math.lossyCast — saturate on overflow
-            len: (self.end - self.start) as i32,
+            // Saturate on overflow.
+            len: i32::try_from(self.end - self.start).unwrap_or(i32::MAX),
         }
     }
 
@@ -2808,8 +2764,8 @@ lexer_impl_header! {
     #[inline]
     fn assert_not_json(&self) {
         if IS_JSON {
-            // TODO(port): Zig uses @compileError; Rust const generics can't compile-error
-            // here without nightly. Could gate JSX methods to non-JSON instantiations.
+            // Stable Rust can't fail the build on a const-generic branch,
+            // so this is a runtime check on a dead path.
             unreachable!("JSON should not reach this point");
         }
     }
@@ -2824,8 +2780,8 @@ lexer_impl_header! {
 
                     let mut has_set_flags_start = false;
                     const FLAG_CHARACTERS: &[u8] = b"dgimsuvy";
-                    const MIN_FLAG: u8 = b'd'; // comptime std.mem.min
-                    const MAX_FLAG: u8 = b'y'; // comptime std.mem.max
+                    const MIN_FLAG: u8 = b'd'; // min of FLAG_CHARACTERS
+                    const MAX_FLAG: u8 = b'y'; // max of FLAG_CHARACTERS
                     let mut flags = bun_collections::IntegerBitSet::<
                         { (MAX_FLAG - MIN_FLAG) as usize + 1 },
                     >::init_empty();
@@ -2886,14 +2842,10 @@ lexer_impl_header! {
         }
     }
 
-    pub fn utf16_to_string(
-        &self,
-        js: JavascriptString<'_>,
-    ) -> Result<&'a [u8], bun_core::Error> {
-        // TODO(port): arena routing — Zig: strings.toUTF8AllocWithType(lexer.arena, js)
-        // PERF(port): goes through global Vec then dupes into the arena.
+    pub fn utf16_to_string(&self, js: JavascriptString<'_>) -> &'a [u8] {
+        // Transcode into a temporary Vec and dupe into the arena.
         let owned = strings::to_utf8_alloc_with_type(js);
-        Ok(self.arena.alloc_slice_copy(&owned))
+        self.arena.alloc_slice_copy(&owned)
     }
 
     pub fn next_inside_jsx_element(&mut self) -> Result<(), Error> {
@@ -3107,7 +3059,7 @@ lexer_impl_header! {
                             || c == 0x0C
                             || c == 0
                             || c == 0x09
-                            || c == 0x0B // std.ascii.control_code.vt
+                            || c == 0x0B // vertical tab
                             || c == 0x08 =>
                         {
                             needs_decode = true;
@@ -3352,7 +3304,7 @@ lexer_impl_header! {
                     base = 16;
                 }
 
-                // PORT NOTE: std.fmt.parseInt(i32, ..) — bytes-based parser; source bytes are
+                // Note: bytes-based integer parse — source bytes are
                 // not guaranteed UTF-8 so we never round-trip through &str (PORTING.md §Strings).
                 // Also reject values outside the Unicode range (0..=0x10FFFF); otherwise
                 // `push_codepoint_utf16` hits `debug_assert`s in `u16_lead`/`u16_trail`
@@ -3518,7 +3470,6 @@ lexer_impl_header! {
         // them. <CR><LF> and <CR> LineTerminatorSequences are normalized to
         // <LF> for both TV and TRV. An explicit EscapeSequence is needed to
         // include a <CR> or <CR><LF> sequence.
-        // TODO(port): MutableString — using arena-backed Vec<u8> here.
         let mut bytes: Vec<u8> = text.to_vec();
         let mut end: usize = 0;
         let mut i: usize = 0;
@@ -3543,12 +3494,11 @@ lexer_impl_header! {
 
         bytes.truncate(end);
         self.arena.alloc_slice_copy(&bytes)
-        // PERF(port): Zig used MutableString.toOwnedSliceLength — extra copy here.
     }
 
     // PERF: single caller (`next()`'s `0x2E | 0x30..=0x39` arm) per
     // monomorphization. `#[inline]` makes the body available cross-CGU so
-    // LLVM's single-caller heuristic merges it into `next()` like Zig does;
+    // LLVM's single-caller heuristic merges it into `next()`;
     // the hot `T::TDot` early-return then sits inside `next()`'s jump table
     // with no call overhead.
     #[inline]
@@ -3706,14 +3656,12 @@ lexer_impl_header! {
                             i += 1;
                         }
                     }
-                    // Note: Zig discards `bytes` here too (bug-compatible).
                 }
 
                 // Store bigints as text to avoid precision loss;
                 if is_big_integer_literal {
                     self.identifier = text;
                 } else if is_invalid_legacy_octal_literal {
-                    // TODO(port): std.fmt.parseFloat — bytes-based; using bun_core::wtf::parse_double
                     match bun_core::wtf::parse_double(text) {
                         Ok(num) => {
                             self.number = num;
@@ -3843,8 +3791,6 @@ lexer_impl_header! {
                     }
                 }
                 text = bytes;
-                // Note: Zig's else-branch ("Out of Memory Wah Wah Wah") is unreachable
-                // with infallible bump alloc.
             }
 
             if self.code_point == 0x6E && !has_dot_or_exponent {
@@ -3977,22 +3923,6 @@ pub fn range_of_identifier(source: &Source, loc: Loc) -> Range {
         r.len = i32::try_from(cursor.i).expect("int cast");
     }
 
-    // const offset = @intCast(usize, loc.start);
-    // var i: usize = 0;
-    // for (text) |c| {
-    //     if (isIdentifierStart(@as(CodePoint, c))) {
-    //         for (source.contents[offset + i ..]) |c_| {
-    //             if (!isIdentifierContinue(c_)) {
-    //                 r.len = std.math.lossyCast(i32, i);
-    //                 return r;
-    //             }
-    //             i += 1;
-    //         }
-    //     }
-    //
-    //     i += 1;
-    // }
-
     r
 }
 
@@ -4172,5 +4102,3 @@ impl fmt::Display for InvalidEscapeSequenceFormatter {
         }
     }
 }
-
-// ported from: src/js_parser/lexer.zig
diff --git a/src/js_parser/lib.rs b/src/js_parser/lib.rs
index 2101f95078d..390553b06b2 100644
--- a/src/js_parser/lib.rs
+++ b/src/js_parser/lib.rs
@@ -1,14 +1,12 @@
-//! Port of `src/js_parser/js_parser.zig`.
-//!
-//! NOTE on arena slices: this is the AST crate. Nearly every `[]const u8` /
-//! `[]T` struct field in the Zig points into either the source text or the
+//! NOTE on arena slices: this is the AST crate. Nearly every slice-typed
+//! struct field points into either the source text or the
 //! parser arena and is bulk-freed at end-of-parse. Per PORTING.md, lifetime
 //! params are not added to AST structs; arena-owned slices are typed as
-//! `StoreSlice<T>` / `StoreStr` here. TODO(refactor): thread a crate-wide
-//! `'bump` and rewrite these to `&'bump [T]` / `&'bump mut [T]`.
+//! `StoreSlice<T>` / `StoreStr` here. A future refactor could thread a
+//! crate-wide `'bump` and rewrite these to `&'bump [T]` / `&'bump mut [T]`.
 
 // `lexer::NewLexer<J: JsonOptionsT>` projects trait associated consts into
-// eight `const bool` slots (Zig: `NewLexer(comptime json_options)`). Field
+// eight `const bool` slots. Field
 // access on a `const J: JSONOptions` param is rejected by nightly-2025-12-10
 // ("overly complex generic constant"); assoc-const projection on a *type*
 // param works under `generic_const_exprs`. `adt_const_params` keeps
@@ -36,15 +34,12 @@ pub mod visit;
 pub use p::P;
 pub use parse::parse_entry::{Options as ParserOptions, Parser};
 
-// `pub const Macro = @import("../js_parser_jsc/Macro.zig");`
 // Full impl lives in *_jsc; this stub re-exposes the JSC-free constants and a
 // placeholder `MacroContext` so lower-tier crates (bundler, transpiler) that
 // only need the namespace strings / a context handle stay unblocked.
 #[allow(non_snake_case)]
 pub mod Macro {
-    /// Zig: `pub const namespace: string = "macro";`
     pub const NAMESPACE: &[u8] = b"macro";
-    /// Zig: `pub const namespaceWithColon: string = namespace ++ ":";`
     pub const NAMESPACE_WITH_COLON: &[u8] = b"macro:";
 
     #[inline]
@@ -52,8 +47,6 @@ pub mod Macro {
         str_.starts_with(NAMESPACE_WITH_COLON)
     }
 
-    /// Spec `bundler_jsc/PluginRunner.zig:MacroJSCtx` (= `JSC.JSValue`).
-    ///
     /// `JSValue` is `#[repr(transparent)] i64` (PORTING.md §JSC types). This
     /// newtype carries the encoded bits at the lowest tier that needs them so
     /// `Transpiler::ParseOptions.macro_js_ctx` and `MacroContext.javascript_object`
@@ -79,10 +72,9 @@ pub mod Macro {
     /// `Transpiler` and JSC types that live in crates which depend on
     /// `bun_js_parser`. To break the dep cycle the higher-tier `_jsc` crate
     /// owns that state behind `data`; the visit pass reaches it via
-    /// link-time-resolved `extern "Rust"` fns so `visitExpr.rs` stays a
-    /// faithful port of `visitExpr.zig:415` / `:1443` without an upward
-    /// import. `javascript_object` is surfaced here so `Transpiler::parse` can
-    /// thread `this_parse.macro_js_ctx` through (spec transpiler.zig:938-940)
+    /// link-time-resolved `extern "Rust"` fns so `visitExpr.rs` avoids an
+    /// upward import. `javascript_object` is surfaced here so
+    /// `Transpiler::parse` can thread `this_parse.macro_js_ctx` through
     /// without this crate depending on `bun_jsc::JSValue`.
     pub struct MacroContext {
         /// Encoded `JSC.JSValue` (the caller-supplied macro JS context).
@@ -90,8 +82,7 @@ pub mod Macro {
         pub javascript_object: MacroJSCtx,
         /// Opaque pointer to the higher-tier macro-runner state
         /// (resolver/env/macros/remap/bump). Allocated by `init` and leaked
-        /// (matches Zig's process-lifetime `default_allocator`);
-        /// `bun_js_parser` never dereferences it.
+        /// (process lifetime); `bun_js_parser` never dereferences it.
         pub data: *mut core::ffi::c_void,
     }
     impl Default for MacroContext {
@@ -155,8 +146,6 @@ pub mod Macro {
         __bun_macro_collect_vm_garbage();
     }
     impl MacroContext {
-        /// Zig: `pub fn call(self: *MacroContext, import_record_path, source_dir,
-        /// log, source, import_range, caller, function_name) !Expr`.
         #[inline]
         pub fn call(
             &mut self,
@@ -179,8 +168,6 @@ pub mod Macro {
                 function_name,
             )
         }
-        /// Zig: `pub fn init(transpiler: *Transpiler) MacroContext`.
-        ///
         /// `T` is always `bun_bundler::Transpiler<'_>`; generic so callers in
         /// `bun_bundler`/`bun_runtime` compile without `bun_js_parser` taking
         /// an upward dep on the bundler. The `_jsc` crate reads the concrete
@@ -210,7 +197,6 @@ pub mod Macro {
             // possible.
             unsafe { __bun_macro_context_deinit(self.data) }
         }
-        /// Zig: `pub fn getRemap(self: *MacroContext, path: []const u8) ?MacroRemapEntry`.
         /// Returns `'static` so callers can keep the result across `&mut self`
         /// parser calls without a borrowck conflict; the table lives in
         /// `Transpiler.options` which outlives every parse.
@@ -228,7 +214,6 @@ pub mod Macro {
         }
     }
 
-    /// Zig: `MacroImportReplacementMap` — `bun.StringArrayHashMap([]const u8)`.
     /// Values are owned (`Box<[u8]>`) so callers can populate without `unsafe`
     /// lifetime-extension casts; matches `bun_resolver::package_json::MacroImportReplacementMap`.
     pub type MacroRemapEntry = bun_collections::StringArrayHashMap<Box<[u8]>>;
@@ -241,8 +226,8 @@ use bun_ast::{Ast, Ref};
 // PERF NOTE: `bun_ast::Ast` is ~1 KB (40+ fields incl. Scope, NamedImports,
 // NamedExports, CharFreq, several HashMaps). Storing it inline made this enum
 // ~1 KB and forced a ~1 KB memmove at every layer of the return chain
-// `P::to_ast → _parse → parse → cache::JavaScript::parse → Transpiler::parse_*`
-// (Zig sidesteps this via result-location semantics; Rust does not). Boxing the
+// `P::to_ast → _parse → parse → cache::JavaScript::parse → Transpiler::parse_*`.
+// Boxing the
 // `Ast` variant collapses `Result` to 16 B so only a thin pointer is moved up
 // the stack — one mimalloc-arena alloc per parsed module is far cheaper than
 // 4+ kilobyte memmoves. The other variants are already tiny.
@@ -276,7 +261,7 @@ impl<'a, const IS_TS: bool, const SCAN: bool> bun_ast::expr::EqlParser
 
 pub mod defines_table;
 
-// ─── from bun_bundler::defines (src/bundler/defines.zig) ────────────────────
+// ─── from bun_bundler::defines ───────────────────────────────────────────────
 // B-3 UNIFIED: canonical `Define` / `DefineData` / `DotDefine` live here so the
 // parser (`P.define: &'a Define`) and the bundler (`BundleOptions.define:
 // Box<Define>`) share one nominal type. `bun_bundler::defines` re-exports these
@@ -291,7 +276,6 @@ pub mod defines {
     use bun_ast::StoreRef;
     use bun_ast::expr::Data as ExprData;
 
-    // Zig: `bun.StringArrayHashMap(string)` / `bun.StringArrayHashMap(DefineData)`.
     pub type RawDefines = StringArrayHashMap<Box<[u8]>>;
     pub type UserDefines = StringHashMap<DefineData>;
     pub type UserDefinesArray = StringArrayHashMap<DefineData>;
@@ -300,17 +284,14 @@ pub mod defines {
 
     #[derive(Clone)]
     pub struct DotDefine {
-        // Zig stored borrowed `[][]const u8` into static tables / user-define
-        // key strings; the Rust port owns the part strings (small, allocated
-        // once at startup). PERF(port): tiny copies.
+        // Owned part strings (small, allocated once at startup).
         pub parts: Vec<Box<[u8]>>,
         pub data: DefineData,
     }
 
-    /// Zig: `packed struct(u8)` — `_padding: u3, valueless: bool,
-    /// can_be_removed_if_unused: bool, call_can_be_unwrapped_if_unused:
-    /// E.CallUnwrap (u2), method_call_must_be_replaced_with_undefined: bool`.
-    /// Packed LSB-first → bit positions below match the Zig layout exactly.
+    /// Bit-packed flags (LSB-first): 3 padding bits, `valueless`,
+    /// `can_be_removed_if_unused`, `call_can_be_unwrapped_if_unused`
+    /// (`E.CallUnwrap`, 2 bits), `method_call_must_be_replaced_with_undefined`.
     #[repr(transparent)]
     #[derive(Clone, Copy, Default, PartialEq, Eq)]
     pub struct Flags(u8);
@@ -384,12 +365,10 @@ pub mod defines {
     #[derive(Clone)]
     pub struct DefineData {
         pub value: ExprData,
-        // Zig stored `original_name_ptr: ?[*]const u8` + `original_name_len: u32`
-        // borrowing into caller-owned strings (defines.zig:24-25 — the 48→40-byte
-        // packing trick). The Rust port owns the `RawDefines` value bytes
-        // (`Box<[u8]>`), so borrowing would be a use-after-free once the
-        // `RawDefines` map is dropped after `Define::init`. Own the bytes here
-        // instead — these are tiny startup-time copies.
+        // The `RawDefines` value bytes are owned (`Box<[u8]>`), so borrowing
+        // would be a use-after-free once the `RawDefines` map is dropped after
+        // `Define::init`. Own the bytes here instead — these are tiny
+        // startup-time copies.
         // Kept `pub` so the bundler-side `parse`/`from_input` (which live a
         // tier up for json-parser access) can construct directly.
         pub original_name: Option<Box<[u8]>>,
@@ -407,7 +386,6 @@ pub mod defines {
     impl Default for DefineData {
         fn default() -> Self {
             Self {
-                // Zig: `.e_missing = .{}`
                 value: ExprData::EMissing(E::Missing),
                 original_name: None,
                 flags: Flags::default(),
@@ -415,7 +393,7 @@ pub mod defines {
         }
     }
 
-    /// Named-init shim (mirrors Zig anonymous-struct init).
+    /// Named-init shim.
     #[derive(Clone, Copy)]
     pub struct Options<'a> {
         pub original_name: Option<&'a [u8]>,
@@ -493,7 +471,6 @@ pub mod defines {
             let mut flags = Flags::default();
             flags.set_can_be_removed_if_unused(true);
             DefineData {
-                // Zig: @constCast(str) — Expr.Data.e_string stores *E.String.
                 value: ExprData::EString(StoreRef::from_static(str)),
                 flags,
                 ..Default::default()
@@ -532,7 +509,6 @@ pub mod defines {
             crate::defines_table::lookup_pure_global_identifier(name).map(|v| v.value())
         }
 
-        // Zig: `comptime Iterator: type, iter: Iterator` — type param dropped.
         pub fn insert_from_iterator<'a, I>(&mut self, iter: I) -> Result<(), bun_alloc::AllocError>
         where
             I: Iterator<Item = (&'a [u8], &'a DefineData)>,
@@ -560,7 +536,7 @@ pub mod defines {
                 parts.push(Box::from(tail));
 
                 let mut initial_values: &[DotDefine] = &[];
-                // PORT NOTE: reshaped for borrowck — getOrPut split into get/insert.
+                // Note: reshaped for borrowck — getOrPut split into get/insert.
                 if let Some(existing) = self.dots.get_mut(tail) {
                     for part in existing.iter_mut() {
                         if are_parts_equal(&part.parts, &parts) {
@@ -599,372 +575,7 @@ pub mod defines {
 }
 pub use defines::{Define, DefineData};
 
-pub mod defines_full_draft {
-    use bstr::BStr;
-    use bun_collections::{ArrayHashMap, StringHashMap};
-    use bun_core::strings;
-
-    use bun_ast::base::Ref;
-    use bun_ast::e as E;
-    use bun_ast::expr;
-
-    use crate::lexer as js_lexer;
-    use bun_ast::StoreRef;
-
-    // Zig: `bun.StringArrayHashMap(string)` / `bun.StringHashMap(DefineData)`
-    pub type RawDefines = ArrayHashMap<Box<[u8]>, Box<[u8]>>;
-    pub type UserDefines = StringHashMap<DefineData>;
-    pub type UserDefinesArray = ArrayHashMap<Box<[u8]>, DefineData>;
-
-    pub type IdentifierDefine = DefineData;
-
-    #[derive(Clone)]
-    pub struct DotDefine {
-        // Zig stored borrowed `[][]const u8` into the user-define key strings;
-        // the Rust port owns the part bytes (small, allocated once at startup)
-        // so the `RawDefines` map can be dropped after `Define::init`.
-        pub parts: Vec<Box<[u8]>>,
-        pub data: DefineData,
-    }
-
-    bitflags::bitflags! {
-        // Zig: `packed struct(u8) { _padding: u3, valueless, can_be_removed_if_unused,
-        //        call_can_be_unwrapped_if_unused: E.CallUnwrap (u2), method_call_must_be_replaced_with_undefined }`
-        // Packed LSB-first → bit positions below match the Zig layout exactly.
-        #[derive(Copy, Clone, Default)]
-        pub struct DefineDataFlags: u8 {
-            const VALUELESS                                  = 1 << 3;
-            const CAN_BE_REMOVED_IF_UNUSED                   = 1 << 4;
-            // bits 5..7 hold `E::CallUnwrap` (2 bits) — read via accessor below.
-            const METHOD_CALL_MUST_BE_REPLACED_WITH_UNDEFINED = 1 << 7;
-        }
-    }
-    const CALL_UNWRAP_SHIFT: u8 = 5;
-    const CALL_UNWRAP_MASK: u8 = 0b11 << CALL_UNWRAP_SHIFT;
-
-    #[derive(Clone)]
-    pub struct DefineData {
-        pub value: expr::Data,
-        // Zig stored `original_name_ptr: ?[*]const u8` + `original_name_len: u32`
-        // borrowing into caller-owned strings (defines.zig:24-25 — the 48→40-byte
-        // packing trick). The Rust port owns the `RawDefines` value bytes
-        // (`Box<[u8]>`), so borrowing would be a use-after-free once the
-        // `RawDefines` map is dropped after `Define::init`. Own the bytes here
-        // instead — these are tiny startup-time copies.
-        pub original_name: Option<Box<[u8]>>,
-        pub flags: DefineDataFlags,
-    }
-
-    impl Default for DefineData {
-        fn default() -> Self {
-            Self {
-                value: expr::Data::EUndefined(E::Undefined {}),
-                original_name: None,
-                flags: DefineDataFlags::empty(),
-            }
-        }
-    }
-
-    impl DefineData {
-        #[inline]
-        pub fn original_name(&self) -> Option<&[u8]> {
-            match &self.original_name {
-                Some(name) if !name.is_empty() => Some(name.as_ref()),
-                _ => None,
-            }
-        }
-
-        /// True if accessing this value is known to not have any side effects. For
-        /// example, a bare reference to "Object.create" can be removed because it
-        /// does not have any observable side effects.
-        #[inline]
-        pub fn can_be_removed_if_unused(&self) -> bool {
-            self.flags
-                .contains(DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED)
-        }
-
-        /// True if a call to this value is known to not have any side effects. For
-        /// example, a bare call to "Object()" can be removed because it does not
-        /// have any observable side effects.
-        #[inline]
-        pub fn call_can_be_unwrapped_if_unused(&self) -> E::CallUnwrap {
-            // 2-bit field; explicit match keeps bit-pattern 3 sound.
-            match (self.flags.bits() & CALL_UNWRAP_MASK) >> CALL_UNWRAP_SHIFT {
-                0 => E::CallUnwrap::Never,
-                1 => E::CallUnwrap::IfUnused,
-                2 => E::CallUnwrap::IfUnusedAndToStringSafe,
-                _ => E::CallUnwrap::Never,
-            }
-        }
-
-        #[inline]
-        pub fn method_call_must_be_replaced_with_undefined(&self) -> bool {
-            self.flags
-                .contains(DefineDataFlags::METHOD_CALL_MUST_BE_REPLACED_WITH_UNDEFINED)
-        }
-
-        #[inline]
-        pub fn valueless(&self) -> bool {
-            self.flags.contains(DefineDataFlags::VALUELESS)
-        }
-
-        pub fn init_boolean(value: bool) -> DefineData {
-            DefineData {
-                value: expr::Data::EBoolean(E::Boolean { value }),
-                flags: DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED,
-                ..Default::default()
-            }
-        }
-
-        pub fn init_static_string(str_: &'static E::String) -> DefineData {
-            DefineData {
-                // Zig `@constCast` — Expr.Data stores StoreRef (NonNull); the static is never mutated.
-                value: expr::Data::EString(StoreRef::from_static(str_)),
-                flags: DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED,
-                ..Default::default()
-            }
-        }
-
-        pub fn merge(a: &DefineData, b: &DefineData) -> DefineData {
-            let mut flags = DefineDataFlags::empty();
-            if a.can_be_removed_if_unused() {
-                flags |= DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED;
-            }
-            flags = DefineDataFlags::from_bits_retain(
-                flags.bits() | ((a.call_can_be_unwrapped_if_unused() as u8) << CALL_UNWRAP_SHIFT),
-            );
-            // TODO: investigate if this is correct. This is what it was before. But that looks strange.
-            if a.method_call_must_be_replaced_with_undefined()
-                || b.method_call_must_be_replaced_with_undefined()
-            {
-                flags |= DefineDataFlags::VALUELESS;
-                flags |= DefineDataFlags::METHOD_CALL_MUST_BE_REPLACED_WITH_UNDEFINED;
-            }
-            DefineData {
-                value: b.value,
-                flags,
-                original_name: b.original_name.clone(),
-            }
-        }
-
-        // REFACTOR_BUN_AST: `bun_js_parser` is a sibling of `bun_parsers`, so the
-        // JSON-value branch takes a parser callback (the bundler passes
-        // `bun_parsers::json::parse_env_json`). With the unified `Expr` type,
-        // the result is the same `bun_ast::Expr` the rest of the parser uses —
-        // the former `json_data_to_expr_data` lift is gone.
-        pub fn parse(
-            key: &[u8],
-            value_str: &[u8],
-            value_is_undefined: bool,
-            method_call_must_be_replaced_with_undefined: bool,
-            log: &mut bun_ast::Log,
-            bump: &bun_alloc::Arena,
-            parse_json: &dyn Fn(
-                &bun_ast::Source,
-                &mut bun_ast::Log,
-                &bun_alloc::Arena,
-            )
-                -> core::result::Result<bun_ast::Expr, bun_core::Error>,
-        ) -> core::result::Result<DefineData, bun_core::Error> {
-            for part in key.split(|&c| c == b'.') {
-                if !js_lexer::is_identifier(part) {
-                    if strings::eql(part, key) {
-                        log.add_error_fmt(
-                            None,
-                            bun_ast::Loc::default(),
-                            format_args!(
-                                "define key \"{}\" must be a valid identifier",
-                                BStr::new(key)
-                            ),
-                        );
-                    } else {
-                        log.add_error_fmt(
-                            None,
-                            bun_ast::Loc::default(),
-                            format_args!(
-                                "define key \"{}\" contains invalid identifier \"{}\"",
-                                BStr::new(part),
-                                BStr::new(value_str)
-                            ),
-                        );
-                    }
-                    break;
-                }
-            }
-
-            // check for nested identifiers
-            let mut is_ident = true;
-            for part in value_str.split(|&c| c == b'.') {
-                if !js_lexer::is_identifier(part) || js_lexer::keyword(part).is_some() {
-                    is_ident = false;
-                    break;
-                }
-            }
-
-            let mut flags = DefineDataFlags::empty();
-            if value_is_undefined {
-                flags |= DefineDataFlags::VALUELESS;
-            }
-            if method_call_must_be_replaced_with_undefined {
-                flags |= DefineDataFlags::METHOD_CALL_MUST_BE_REPLACED_WITH_UNDEFINED;
-            }
-
-            if is_ident {
-                // Special-case undefined. it's not an identifier here
-                // https://github.com/evanw/esbuild/issues/1407
-                let value = if value_is_undefined || value_str == b"undefined" {
-                    expr::Data::EUndefined(E::Undefined {})
-                } else {
-                    expr::Data::EIdentifier(
-                        E::Identifier::init(Ref::NONE).with_can_be_removed_if_unused(true),
-                    )
-                };
-                flags |= DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED;
-                return Ok(DefineData {
-                    value,
-                    original_name: if value_str.is_empty() {
-                        None
-                    } else {
-                        Some(Box::<[u8]>::from(value_str))
-                    },
-                    flags,
-                });
-            }
-
-            // Value is JSON — round-trip through the env-JSON parser.
-            let source = bun_ast::Source {
-                contents: std::borrow::Cow::Owned(value_str.to_vec()),
-                path: bun_paths::fs::Path::init_with_namespace(b"defines.json", b"internal"),
-                ..Default::default()
-            };
-            let expr = parse_json(&source, log, bump)?;
-            // Zig: `expr.data.deepClone(arena)` followed by `expr.isPrimitiveLiteral()`.
-            // With one `Expr` type the parser result is already in the target
-            // shape; `deep_clone` re-roots payloads in `bump`.
-            let cloned = expr.data.deep_clone(bump)?;
-            if expr.is_primitive_literal() {
-                flags |= DefineDataFlags::CAN_BE_REMOVED_IF_UNUSED;
-            }
-            Ok(DefineData {
-                value: cloned,
-                original_name: if value_str.is_empty() {
-                    None
-                } else {
-                    Some(Box::<[u8]>::from(value_str))
-                },
-                flags,
-            })
-        }
-    }
-
-    pub struct Define {
-        pub identifiers: StringHashMap<IdentifierDefine>,
-        pub dots: StringHashMap<Vec<DotDefine>>,
-        pub drop_debugger: bool,
-    }
-
-    impl Define {
-        // Zig: `pub const Data = DefineData;` — Rust callers import `DefineData` directly.
-
-        pub fn for_identifier(&self, name: &[u8]) -> Option<&IdentifierDefine> {
-            if let Some(data) = self.identifiers.get(name) {
-                return Some(data);
-            }
-            // Draft module — pure-global table is wired into the canonical
-            // `crate::defines::Define` (this draft type is unused).
-            None
-        }
-
-        pub fn insert(
-            &mut self,
-            bump: &bun_alloc::Arena,
-            key: &[u8],
-            value: DefineData,
-        ) -> core::result::Result<(), bun_alloc::AllocError> {
-            let _ = bump;
-            // If it has a dot, then it's a DotDefine.
-            // e.g. process.env.NODE_ENV
-            if let Some(last_dot) = strings::last_index_of_char(key, b'.') {
-                let tail = &key[last_dot + 1..];
-                let remainder = &key[..last_dot];
-                let count = remainder.iter().filter(|&&c| c == b'.').count() + 1;
-                // Zig allocated `[][]const u8` borrowing the input key; the Rust
-                // port owns the part bytes (tiny startup-time copies) so the
-                // caller can drop `key` after `Define::init`.
-                let mut parts: Vec<Box<[u8]>> = Vec::with_capacity(count + 1);
-                for split in remainder.split(|&c| c == b'.') {
-                    parts.push(Box::from(split));
-                }
-                parts.push(Box::from(tail));
-
-                // "NODE_ENV"
-                let entry = self.dots.get_or_put(tail).unwrap().value_ptr;
-                for part in entry.iter_mut() {
-                    // ["process", "env"] === ["process", "env"]
-                    if are_parts_equal(&part.parts, &parts) {
-                        part.data = DefineData::merge(&part.data, &value);
-                        return Ok(());
-                    }
-                }
-                entry.push(DotDefine { data: value, parts });
-            } else {
-                // e.g. IS_BROWSER
-                self.identifiers.put_assume_capacity(key, value);
-            }
-            Ok(())
-        }
-
-        pub fn init(
-            user_defines: Option<UserDefines>,
-            string_defines: Option<UserDefinesArray>,
-            drop_debugger: bool,
-            omit_unused_global_calls: bool,
-            bump: &bun_alloc::Arena,
-        ) -> core::result::Result<Box<Define>, bun_alloc::AllocError> {
-            let _ = omit_unused_global_calls;
-            let mut define = Box::new(Define {
-                identifiers: StringHashMap::default(),
-                dots: StringHashMap::default(),
-                drop_debugger,
-            });
-            // TODO(port): Step 1/2 — load global_no_side_effect_* tables from
-            // bun_bundler::defines_table once that table moves down. Omitting
-            // here is safe-ish: only affects pure-annotation tree shaking.
-
-            // Step 3. Load user data into hash tables
-            // (Zig: `iter.next()` over `StringHashMap` — consume the inner map.)
-            if let Some(mut user_defines) = user_defines {
-                for (k, v) in core::mem::take(&mut *user_defines).into_iter() {
-                    define.insert(bump, &k, v)?;
-                }
-            }
-            // Step 4. Load environment data into hash tables.
-            // (Zig: `it.next()` over `StringArrayHashMap` — `ArrayHashMap` has
-            // no `IntoIterator`; walk insertion-order entries.)
-            if let Some(mut string_defines) = string_defines {
-                let mut it = string_defines.iterator();
-                while let Some(entry) = it.next() {
-                    define.insert(bump, &**entry.key_ptr, entry.value_ptr.clone())?;
-                }
-            }
-            Ok(define)
-        }
-    }
-
-    fn are_parts_equal(a: &[Box<[u8]>], b: &[Box<[u8]>]) -> bool {
-        if a.len() != b.len() {
-            return false;
-        }
-        for i in 0..a.len() {
-            if !strings::eql(&a[i], &b[i]) {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-// ─── from bun_js_printer::renamer (src/js_printer/renamer.zig) ──────────────
+// ─── from bun_js_printer::renamer ────────────────────────────────────────────
 // Only the slot-assignment helpers the parser calls (`P.rs:6658`) live here;
 // the full `NumberRenamer`/`MinifyRenamer` machinery stays in `bun_js_printer`
 // (it depends on the printer's name-buffer and reserved-names tables).
@@ -1109,5 +720,3 @@ pub mod renamer {
     // The remaining renamer types are only consumed by the printer and bundler
     // — they live in `bun_js_printer`.
 }
-
-// ported from: src/js_parser/js_parser.zig
diff --git a/src/js_parser/lower/lower_decorators.rs b/src/js_parser/lower/lower_decorators.rs
index 5cc0ddfbfe5..5c847a25266 100644
--- a/src/js_parser/lower/lower_decorators.rs
+++ b/src/js_parser/lower/lower_decorators.rs
@@ -1,6 +1,5 @@
 #![allow(clippy::too_many_arguments, clippy::needless_late_init)]
 //! Lowering for TC39 standard ES decorators.
-//! Extracted from P.zig to reduce duplication via shared helpers.
 
 use bun_alloc::ArenaVecExt as _;
 
@@ -14,8 +13,7 @@ use bun_ast::{self as js_ast, B, E, Expr, ExprNodeList, Flags, G, S, Stmt};
 
 type BumpVec<'a, T> = bun_alloc::ArenaVec<'a, T>;
 
-// Zig: `pub fn LowerDecorators(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
+// Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
 // a direct `impl P` block.
 
 // ── Local helper types ───────────────────────────────────────────────────────
@@ -68,7 +66,7 @@ enum RewriteKind {
 }
 
 // ── Shallow-copy helpers (Property / Class are not `Clone` because they hold
-//    raw arena pointers; copying the pointers is the intended Zig semantic). ──
+//    raw arena pointers; copying the raw pointers is intentional). ──
 
 #[inline]
 fn prop_copy(p: &Property) -> Property {
@@ -80,8 +78,12 @@ fn prop_copy(p: &Property) -> Property {
         ts_decorators: bun_alloc::AstAlloc::vec(),
         key: p.key,
         value: p.value,
-        // SAFETY: `Metadata` is a plain data enum (no Drop); shallow read is the
-        // intended Zig copy semantic.
+        // SAFETY: this duplicates ownership of any heap allocation inside
+        // `Metadata` (`MDot` owns a global-heap `Vec<Ref>`), but the source
+        // `Property` is an arena-resident AST node whose `Drop` never runs
+        // (AST stores are bulk-freed without dropping — see the
+        // `bun_alloc::ast_alloc` module docs), so at most one of the two
+        // copies ever reaches drop glue; no double free.
         ts_metadata: unsafe { core::ptr::read(&raw const p.ts_metadata) },
     }
 }
@@ -392,7 +394,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let mut v = BumpVec::<u8>::new_in(self.arena);
         v.extend_from_slice(prefix);
         if let Some(n) = n {
-            // PORT NOTE: bumpalo Vec<u8> doesn't impl io::Write; format into a
+            // bumpalo Vec<u8> doesn't impl io::Write; format into a
             // bump String and copy the bytes.
             let s = bun_alloc::arena_format!(in self.arena, "{}", n);
             v.extend_from_slice(s.as_bytes());
@@ -1075,8 +1077,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             inner_class_ref = p.new_sym(js_ast::symbol::Kind::Other, name);
         }
 
-        // Zig: `const class_decorators = class.ts_decorators; class.ts_decorators = .{};`
-        // — a shallow `BabyList` copy. In Rust `ExprNodeList = Vec<Expr>` owns its
+        // `ExprNodeList = Vec<Expr>` owns its
         // buffer, so this MUST be a real ownership transfer; the previous
         // `ptr::read` left a second owner in the local that dropped at function
         // exit, freeing the buffer that `E::Array { items }` (Phase-2/5 below)
@@ -2257,7 +2258,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     break;
                 }
                 let insert_at = if let Some(j) = super_index { j + 1 } else { 0 };
-                // PORT NOTE: BumpVec has no `splice`; rebuild.
+                // BumpVec has no `splice`; rebuild.
                 let mut spliced = BumpVec::<Stmt>::with_capacity_in(
                     body_stmts.len() + constructor_inject_stmts.len(),
                     bump,
@@ -2362,9 +2363,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 comma_parts.push(ba);
             }
 
-            // PORT NOTE: Zig used a local anonymous-struct fn; can't capture
-            // `&mut self` in a Rust closure while also calling `p.method()`, so
-            // inline both call sites against a `&[Stmt]` slice array.
+            // Can't capture `&mut self` in a closure while also calling
+            // `p.method()`, so inline both call sites against a `&[Stmt]`
+            // slice array.
             for stmts_list in [&pre_eval_stmts[..], &prefix_stmts[..]] {
                 for pstmt in stmts_list.iter() {
                     match &pstmt.data {
@@ -2505,5 +2506,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 }
-
-// ported from: src/js_parser/ast/lowerDecorators.zig
diff --git a/src/js_parser/lower/lower_esm_exports_hmr.rs b/src/js_parser/lower/lower_esm_exports_hmr.rs
index d2aaac43c61..fe298b6025a 100644
--- a/src/js_parser/lower/lower_esm_exports_hmr.rs
+++ b/src/js_parser/lower/lower_esm_exports_hmr.rs
@@ -8,9 +8,9 @@ use crate::p::P;
 use crate::parser::{ReactRefresh, Ref, TempRef};
 use bun_ast::{self as js_ast, B, Binding, E, Expr, G, S, Stmt};
 
-// PORT NOTE: `P::generate_temp_ref` is ``-gated in P.rs (round-6
-// re-gate); replicate it here so this file can un-gate independently. Body is
-// a 1:1 port of P.zig `generateTempRefWithScope` with `scope = current_scope`.
+// Note: `P::generate_temp_ref` is ``-gated in P.rs (round-6
+// re-gate); replicate it here so this file can un-gate independently
+// (with `scope = current_scope`).
 // `P::will_use_renamer` is private — its body is inlined.
 fn generate_temp_ref<'p, const TS: bool, const SCAN: bool>(
     p: &mut P<'p, TS, SCAN>,
@@ -48,11 +48,10 @@ pub(crate) struct ConvertESMExportsForHmr<'a> {
     pub export_props: Vec<G::Property>,
     pub stmts: Vec<Stmt>,
 }
-// PORT NOTE: Zig used `std.ArrayListUnmanaged` with `p.arena` for the four
-// collections; in Rust the parser arena is a `bumpalo::Bump`, but the consumers
+// Note: the consumers of the four collections
 // (`Vec::move_from_list` for `export_props`, arena copy for `stmts`) want
-// global-heap `Vec<T>` anyway. Kept as `Vec` so callers can construct via
-// `Default::default()` without needing `&'a Bump`. See P.zig:6389.
+// global-heap `Vec<T>`. Kept as `Vec` so callers can construct via
+// `Default::default()` without needing `&'a Bump`.
 
 #[derive(Default)]
 pub(crate) struct ImportRef {
@@ -66,9 +65,8 @@ pub(crate) struct DeduplicatedImportResult {
 }
 
 impl<'a> ConvertESMExportsForHmr<'a> {
-    // PORT NOTE: `<P>` unbounded generic → concrete `P<'p, TS, SCAN>`.
-    // TODO(port): Zig `p: anytype` also accepts AstBuilder; add `ParserLike` trait bound
-    //   when bundle_v2 lands.
+    // Note: takes the concrete `P<'p, TS, SCAN>`; `AstBuilder` instead
+    // open-codes the equivalent transform (see bundler/AstBuilder.rs).
     pub(crate) fn convert_stmt<'p, const TS: bool, const SCAN: bool>(
         &mut self,
         p: &mut P<'p, TS, SCAN>,
@@ -83,7 +81,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
                 st.is_export = false;
 
                 let mut new_len: usize = 0;
-                // PORT NOTE: reshaped for borrowck — index loop instead of `|*decl_ptr|`.
+                // Note: reshaped for borrowck — index loop instead of `|*decl_ptr|`.
                 let decls_len = st.decls.len_u32() as usize;
                 for i in 0..decls_len {
                     // explicit field copies (G::Decl is not `Copy`) to avoid aliasing
@@ -215,7 +213,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
                     },
                 };
                 if can_be_moved_to_inner_scope {
-                    // PORT NOTE: `StmtOrExpr` is not `Copy`; read by ptr to avoid moving
+                    // Note: `StmtOrExpr` is not `Copy`; read by ptr to avoid moving
                     // out of the StoreRef deref.
                     // SAFETY: StoreRef points into a live arena; value is POD-shaped.
                     let value = unsafe { core::ptr::read(&raw const st.value) }.to_expr();
@@ -491,7 +489,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
                 if stmt.items.is_empty() {
                     stmt.items = items;
                 } else {
-                    // PORT NOTE: Zig `std.mem.concat` — allocate concatenated slice in arena.
+                    // Allocate the concatenated slice in the arena.
                     // ClauseItem fields are all bitwise-copyable; copy raw to avoid Clone bound.
                     let prev_len = stmt.items.len();
                     let concat = p.arena.alloc_slice_fill_with(prev_len + items_len, |_| {
@@ -527,9 +525,8 @@ impl<'a> ConvertESMExportsForHmr<'a> {
                     let symbol = &mut p.symbols[namespace_ref.inner_index() as usize];
                     symbol.use_count_estimate = 0;
                     symbol.link.set(stmt.namespace_ref);
-                    // PORT NOTE: Zig `@hasField(@typeInfo(@TypeOf(p)).pointer.child, "symbol_uses")`
-                    // gated this on whether the concrete `p` type carries `symbol_uses`. The
-                    // concrete `P` always does; once a `ParserLike` trait is introduced for
+                    // Note: the concrete `P` always carries `symbol_uses`;
+                    // once a `ParserLike` trait is introduced for
                     // AstBuilder, that variant should override this to a no-op.
                     p.symbol_uses.swap_remove(&namespace_ref);
                 }
@@ -696,9 +693,8 @@ impl<'a> ConvertESMExportsForHmr<'a> {
     pub(crate) fn finalize<'p, const TS: bool, const SCAN: bool>(
         &mut self,
         p: &mut P<'p, TS, SCAN>,
-        // PORT NOTE: Zig took `all_parts: []Part` and freely re-derived
-        // `&mut all_parts[len-1]` while `ctx.last_part` aliased the same slot.
-        // Rust forbids that aliasing (Stacked Borrows: `&mut [Part]` asserts
+        // Note: `self.last_part` must not alias into this slice
+        // (Stacked Borrows: `&mut [Part]` asserts
         // exclusive access to every element). Caller passes the `[0..len-1]`
         // prefix obtained via `split_last_mut`, disjoint from `self.last_part`.
         head_parts: &mut [js_ast::Part],
@@ -791,7 +787,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
             self.last_part
                 .import_record_indices
                 .append_slice(part.import_record_indices.slice());
-            // PORT NOTE: reshaped for borrowck — Zig zipped keys()/values(); index loop avoids
+            // Note: reshaped for borrowck — index loop avoids
             // holding two shared borrows of `part.symbol_uses` while &mut-borrowing `last_part`.
             for i in 0..part.symbol_uses.count() {
                 let k = part.symbol_uses.keys()[i];
@@ -804,8 +800,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
                 }
             }
             part.stmts = bun_ast::StoreSlice::EMPTY;
-            // PORT NOTE: `declared_symbols` already cleared via `mem::take` above
-            // (Zig set `entries.len = 0` after `appendList`).
+            // Note: `declared_symbols` already cleared via `mem::take` above.
             part.tag = bun_ast::PartTag::DeadDueToInlining;
             part.dependencies.clear_retaining_capacity();
             part.dependencies.push(bun_ast::Dependency {
@@ -821,7 +816,7 @@ impl<'a> ConvertESMExportsForHmr<'a> {
             .declared_symbols
             .append_list(&p.declared_symbols)?;
 
-        // PORT NOTE: Zig assigned the ArrayList's `items` slice directly. `Stmt` is `Copy`;
+        // Note: `Stmt` is `Copy`;
         // copy into the parser arena so the `StoreSlice<Stmt>` outlives this struct.
         let stmts = core::mem::take(&mut self.stmts);
         self.last_part.stmts = bun_ast::StoreSlice::new_mut(p.arena.alloc_slice_copy(&stmts));
@@ -829,5 +824,3 @@ impl<'a> ConvertESMExportsForHmr<'a> {
         Ok(())
     }
 }
-
-// ported from: src/js_parser/ast/ConvertESMExportsForHmr.zig
diff --git a/src/js_parser/p.rs b/src/js_parser/p.rs
index 8dae7ba9a57..40d915611a7 100644
--- a/src/js_parser/p.rs
+++ b/src/js_parser/p.rs
@@ -1,10 +1,6 @@
 use bun_collections::VecExt;
-// Port of src/js_parser/ast/P.zig
-//
 // This file defines the `P` parser struct (generic over typescript/jsx/scan_only
-// const params) and its core methods. The Zig original uses
-// `fn NewParser_(comptime ...) type { return struct {...} }` which becomes a
-// generic struct + impl in Rust.
+// const params) and its core methods.
 
 use core::ptr::NonNull;
 use std::io::Write as _;
@@ -44,7 +40,6 @@ use bun_ast::{
 // Real bodies un-gate per-file later.
 use crate::renamer;
 
-// Type aliases matching the Zig `const List = std.ArrayListUnmanaged;` etc.
 // In this AST crate, lists are arena-backed.
 type BumpVec<'a, T> = bun_alloc::ArenaVec<'a, T>;
 type List<'a, T> = BumpVec<'a, T>;
@@ -52,7 +47,7 @@ type ListManaged<'a, T> = BumpVec<'a, T>;
 type Map<K, V> = HashMap<K, V>;
 
 /// Erases `P<'a, TS, SCAN>`'s const-generics so helpers like `JSXTag::parse`
-/// (which Zig wrote as `comptime P: type`) can take any instantiation. Only the
+/// can take any instantiation. Only the
 /// surface those helpers actually touch is exposed; widen this as the
 /// parse_* / visit_* sibling files un-gate.
 pub(crate) trait ParserLike<'a> {
@@ -101,17 +96,13 @@ pub struct ParserFeatures {
     pub scan_only: bool,
 }
 
-// workaround for https://github.com/ziglang/zig/issues/10903 — not needed in Rust;
 // `NewParser` is just an alias for the generic struct.
 pub type NewParser<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> =
     P<'a, TYPESCRIPT, SCAN_ONLY>;
-// TODO(port): the Zig `NewParser(features)` call sites pass a struct literal; in Rust callers
-// must spell out the three const params directly.
 
-// ─── Conditional field types (Zig: `if (only_scan_imports_and_do_not_visit) *T else T`) ───
-// Zig switched the field type at comptime. Rust const generics cannot select a type, so we
+// ─── Conditional field types ───
+// Rust const generics cannot select a type, so we
 // store both variants behind an enum and gate access in methods.
-// TODO(port): revisit with associated types / GATs.
 pub enum ImportRecordList<'a> {
     Owned(BumpVec<'a, ImportRecord>),
     Borrowed(&'a mut Vec<ImportRecord>),
@@ -146,7 +137,7 @@ impl<'a> ImportRecordList<'a> {
         }
     }
 
-    /// Zig: `ImportRecord.List.moveFromList(&p.import_records)` — transfer the
+    /// Transfer the
     /// backing storage into a `Vec<ImportRecord>` and leave `self` empty
     /// (so the parser can be dropped without aliasing the records the linker /
     /// printer now own).
@@ -154,7 +145,7 @@ impl<'a> ImportRecordList<'a> {
     /// Round-G fix: previously `to_ast` reached through `items_mut()` and
     /// wrapped the *live* BumpVec slice, leaving `self` non-empty; the BumpVec's
     /// Drop then ran element destructors on records the returned `Ast` still
-    /// pointed at. This adapter restores Zig's move-and-zero semantics for both
+    /// pointed at. This adapter restores move-and-zero semantics for both
     /// the bump-backed and externally-borrowed variants.
     pub(crate) fn move_to_baby_list(&mut self, arena: &'a Bump) -> BumpVec<'a, ImportRecord> {
         match core::mem::replace(self, Self::Owned(BumpVec::new_in(arena))) {
@@ -188,23 +179,21 @@ impl<'a> core::ops::DerefMut for NamedImportsType<'a> {
     }
 }
 
-// In Zig: `if (only_scan_imports_and_do_not_visit) bool else void`.
 pub(crate) type NeedsJSXType = bool;
-// In Zig: `if (track_symbol_usage_during_parse_pass) *Map else void`.
 pub(crate) type ParsePassSymbolUsageType<'a> = Option<&'a mut crate::ParsePassSymbolUsageMap>;
-// In Zig: `if (allow_macros) u32 else u0`.
 pub(crate) type MacroCallCountType = u32;
 
-// ─── Re-exports of sibling-module impls (Zig: `pub const X = mod.X;`) ───
-// In Rust these are inherent methods on `P` defined in sibling files via separate
+// ─── Re-exports of sibling-module impls ───
+// These are inherent methods on `P` defined in sibling files via separate
 // `impl<...> P<...>` blocks. Round-D/E: those files un-gate per-module; until
 // then their re-exports are gated so the *struct* + core helpers compile.
 pub use crate::parse::*;
 pub use crate::visit::*;
 // Re-export the real visitor so `P::binary_expression_stack` is typed against
-// the same struct `visitExpr.rs` pushes into it (cross-call buffer reuse,
-// matching Zig's `p.binary_expression_stack`).
+// the same struct `visitExpr.rs` pushes into it (cross-call buffer reuse).
 pub use crate::visit::visit_binary::BinaryExpressionVisitor;
+// Same pattern for the unused-expression simplifier's reusable stack.
+pub use crate::scan::scan_side_effects::BinaryExpressionSimplifyVisitor;
 
 pub struct RecentlyVisitedTSNamespace {
     pub expr: js_ast::ExprData,
@@ -239,8 +228,7 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
     pub macro_: MacroState<'a>,
     pub arena: &'a Bump,
     pub options: ParserOptions<'a>,
-    /// Raw pointer alias of `lexer.log`. Zig held two `*Log` (`p.log` and
-    /// `lexer.log`); Rust cannot store two `&'a mut Log` to one allocation
+    /// Raw pointer alias of `lexer.log`. Rust cannot store two `&'a mut Log` to one allocation
     /// (Stacked-Borrows UB), so this is a `NonNull` and reborrowed at use sites
     /// via `P::log()`. The pointee outlives `'a` (enforced by `Parser::init`).
     pub log: core::ptr::NonNull<bun_ast::Log>,
@@ -584,10 +572,10 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
     pub const_values: bun_ast::ast_result::ConstValuesMap,
 
     // These are backed by stack fallback allocators in _parse, and are uninitialized until then.
-    // PERF(port): was stack-fallback alloc — profile if hot.
     pub binary_expression_stack: ListManaged<'a, BinaryExpressionVisitor>,
-    // TODO(port): SideEffects::BinaryExpressionSimplifyVisitor (SideEffects.rs)
-    pub binary_expression_simplify_stack: ListManaged<'a, ()>,
+    // Reusable stack for `SideEffects::simplify_unused_binary_comma_expr`;
+    // avoids per-call allocation once that path is wired to push into it.
+    pub binary_expression_simplify_stack: ListManaged<'a, BinaryExpressionSimplifyVisitor>,
 
     /// We build up enough information about the TypeScript namespace hierarchy to
     /// be able to resolve scope lookups and property accesses for TypeScript enum
@@ -609,8 +597,8 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
     pub ts_namespace: RecentlyVisitedTSNamespace,
     pub top_level_enums: List<'a, Ref>,
 
-    // Value is a shared `&'a [ScopeOrder<'a>]` (Zig: `[]ScopeOrder` slice
-    // value). The visit pass never writes through these slices — it only reads
+    // Value is a shared `&'a [ScopeOrder<'a>]`. The visit pass never writes
+    // through these slices — it only reads
     // `Copy` elements and advances a cursor — so the map and
     // `scope_order_to_visit` may safely alias the same arena allocation.
     pub scopes_in_order_for_enum: ArrayHashMap<bun_ast::Loc, &'a [ScopeOrder<'a>]>,
@@ -620,17 +608,16 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
 
     /// Used for react refresh, it must be able to insert `const _s = $RefreshSig$();`
     pub nearest_stmt_list: Option<NonNull<ListManaged<'a, Stmt>>>,
-    // TODO(port): lifetime — points at a stack local saved/restored across calls
+    // Lifetime caution: points at a stack local saved/restored across calls.
     /// Name from assignment context for anonymous decorated class expressions.
     /// Set before visitExpr, consumed by lowerStandardDecoratorsImpl.
     pub decorator_class_name: Option<&'a [u8]>,
 }
 
-// Transposer helpers (Zig: `const ImportTransposer = ExpressionTransposer(P, ..., P.transposeImport);`)
+// Transposer helpers
 //
-// PORT NOTE: Zig's `ExpressionTransposer` is a comptime type-generator that
-// captures `*P` and recursively pushes `import()` / `require()` / `require.resolve()`
-// through `?:` arms. Routing that through `crate::ExpressionTransposer` would
+// Routing the `import()` / `require()` / `require.resolve()` recursion
+// through `crate::ExpressionTransposer` would
 // require materialising `&mut P` while a `&mut self` borrow of the transposer
 // field (a sub-range of `P`) is still live on the `maybe_transpose_if` frame —
 // an aliased-`&mut` shape PORTING.md forbids. Instead the recursion lives as
@@ -639,7 +626,7 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
 //
 // The structs below are ZST placeholders kept so the `P` struct retains the
 // `import_transposer` / `require_transposer` / `require_resolve_transposer`
-// field shape from Zig. They no longer carry a `*mut P` self-pointer: storing
+// field shape. They no longer carry a `*mut P` self-pointer: storing
 // `addr_of_mut!(*self)` in `prepare_for_visit_pass` produced a raw pointer
 // whose Stacked-Borrows tag was a child of *that* `&mut self` retag — every
 // later `&mut self` retag (entering any visit method) invalidated it, so the
@@ -711,11 +698,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool>
     }
 }
 
-// Zig: `const Binding2ExprWrapper = struct { pub const Namespace = Binding.ToExpr(P, P.wrapIdentifierNamespace); ... }`
-// PORT NOTE: `Binding.ToExpr(P, fn)` is a comptime type-generator returning a
-// struct that holds `*P` + arena and dispatches `wrapIdentifier` to the
-// captured fn. The Rust port type-erases `*P` (which is generic over
-// `<'a, TYPESCRIPT, J, SCAN_ONLY>`) into `binding::ToExprWrapper` - same shim
+// `binding::ToExprWrapper` type-erases `*P` (which is generic over
+// `<'a, TYPESCRIPT, J, SCAN_ONLY>`) - same shim
 // pattern as `ImportTransposer` above. Wired in `prepare_for_visit_pass`.
 pub(crate) type Binding2ExprWrapperNamespace = bun_ast::binding::ToExprWrapper;
 pub(crate) type Binding2ExprWrapperHoisted = bun_ast::binding::ToExprWrapper;
@@ -762,7 +746,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     /// Reborrow the shared `Log`. The `&self` receiver lets call sites pass
     /// other `self.*` fields as arguments (`self.log().add_error(Some(self.source), …)`)
     /// without a borrow-checker conflict; callers must not hold two results of
-    /// `log()` live at once. Matches Zig's two-aliasing-`*Log` model.
+    /// `log()` live at once.
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn log(&self) -> &mut bun_ast::Log {
@@ -852,17 +836,15 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     // ── thin allocate-helpers (un-gated so the parse_*/visit_* mixin bodies
-    //    can reference them; the full bodies with SCAN_ONLY require-scan and
-    //    @typeInfo branches stay in the gated block below) ────────────────
+    //    can reference them; the full bodies with SCAN_ONLY require-scan
+    //    branches stay in the gated block below) ──────────────────────────
     #[inline]
     pub fn new_expr<T>(&mut self, t: T, loc: bun_ast::Loc) -> Expr
     where
         T: js_ast::expr::IntoExprData,
     {
-        // PORT NOTE: Zig's `comptime Type == E.Call` check is done post-init by
-        // matching on the constructed `Data` (Rust has no comptime type-eq).
-        // Semantically equivalent — the import-record side-effect is order-
-        // independent of `Expr.init`'s Store allocation.
+        // The import-record side-effect is order-independent of `Expr.init`'s
+        // Store allocation.
         let expr = Expr::init(t, loc);
         if SCAN_ONLY {
             if let js_ast::ExprData::ECall(call) = expr.data {
@@ -917,13 +899,13 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 // stay individually ` // blocked_on:` below.
 // ═══════════════════════════════════════════════════════════════════════════
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    pub const ALLOW_MACROS: bool = true /* TODO(port): feature_flag::IS_MACRO_ENABLED */;
+    pub const ALLOW_MACROS: bool = !cfg!(target_family = "wasm");
 
     /// use this instead of checking p.source.index
     /// because when not bundling, p.source.index is `0`
     #[inline]
     pub fn is_source_runtime(&self) -> bool {
-        // Zig: Index.isRuntime() — index 0 is the synthetic runtime chunk.
+        // Index 0 is the synthetic runtime chunk.
         self.options.bundle && self.source.index.0 == 0
     }
 
@@ -1019,7 +1001,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     // ───────────────────────────────────────────────────────────────────────
-    // Inlined ExpressionTransposer recursion (Zig: parser.zig:163-199).
+    // Inlined ExpressionTransposer recursion.
     // Defined as `&mut self` methods so the only live `&mut` is the caller's
     // `&mut P` — avoids the aliased-`&mut` that arises when a transposer
     // *field* holds `&mut self` while a `&mut P` is materialised inside the
@@ -1179,8 +1161,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let _ = self.check_dynamic_specifier(arg, arg.loc, "require.resolve()");
 
-        // Zig: `arena.alloc(Expr, 1); args[0] = arg; ExprNodeList.fromOwnedSlice(args)`.
-        // PORT NOTE: Vec::from_owned_slice wants Box<[T]>; init_one is the
+        // Vec::from_owned_slice wants Box<[T]>; init_one is the
         // single-element equivalent (matches transpose_require below).
         self.new_expr(
             E::Call {
@@ -1287,8 +1268,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                     // Note that this symbol may be completely removed later.
                     let path_name = fs::PathName::init(pathname);
-                    // Zig: `path_name.nonUniqueNameString(arena)` — render the
-                    // sanitized-identifier formatter into the bump arena.
+                    // Render the sanitized-identifier formatter into the bump arena.
                     let name: &'a [u8] = {
                         use core::fmt::Write as _;
                         let mut buf = bun_alloc::ArenaString::new_in(self.arena);
@@ -1439,8 +1419,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     // blocked_on: is_binding_used; SideEffects::to_boolean; Part fields; named_exports key type
     pub fn tree_shake(&mut self, parts: &mut &'a mut [js_ast::Part], merge: bool) {
         let mut parts_ = core::mem::take(parts);
-        // PORT NOTE: Zig used `defer` to merge parts after the loop. We replicate by
-        // running the merge logic explicitly after the while-loop below.
 
         let default_export_ref = self
             .named_exports
@@ -1453,8 +1431,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             let last_end = parts_.len();
 
             for i in 0..parts_.len() {
-                // PORT NOTE: Zig copied `Part` by value (POD struct). Rust `Part` is
-                // not `Clone`, so borrow it for the dead-check; the only mutation
+                // `Part` is not `Clone`, so borrow it for the dead-check; the only mutation
                 // is the swap into `parts_[parts_end]` at the bottom.
                 let part = &parts_[i];
                 let is_dead = part.can_be_removed_if_unused
@@ -1570,7 +1547,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
 
             parts_ = &mut parts_[..parts_end];
-            // PORT NOTE: reshaped for borrowck — Zig wrote parts_.len = parts_end
             if last_end == parts_.len() {
                 break;
             }
@@ -1691,14 +1667,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     // SCAN_ONLY require("...") sniff branch is restored there once
     // IntoExprData::as_e_call() lands.
 
-    /// Zig: `p.b(t, loc)` — bump-allocate a binding payload and wrap it in `Binding`.
-    /// `BindingAlloc` (Binding.rs round-G2) replaces the Zig `@TypeOf(t)` switch.
+    /// Bump-allocate a binding payload and wrap it in `Binding`.
     ///
-    /// PORT NOTE: Zig's `p.b(t: anytype)` had a `@typeInfo == .pointer` arm that
-    /// dispatched to `Binding.init(t, loc)` (wrap-existing-allocation) instead of
-    /// `Binding.alloc`. That arm is intentionally dropped here: every Zig caller
-    /// passes `t` by value, so only the alloc path was ever exercised. If a future
-    /// caller needs to wrap an already-stored payload, call `Binding::init` directly.
+    /// If a caller needs to wrap an already-stored payload, call `Binding::init` directly.
     #[inline]
     pub fn b<T>(&mut self, t: T, loc: bun_ast::Loc) -> Binding
     where
@@ -1738,7 +1709,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         alias: &'a [u8],
         r#ref: Ref,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if let Some(name) = self.named_exports.get(alias) {
             // Duplicate exports are an error
             let notes: Box<[bun_ast::Data]> = Box::new([bun_ast::Data {
@@ -1792,8 +1762,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 debug_assert!(self.symbols.len() > ref_.inner_index() as usize);
             }
             self.symbols[ref_.inner_index() as usize].use_count_estimate += 1;
-            // `get_or_put` zero-initializes the slot on insert (`Use::default()`),
-            // so the Zig `found_existing` branch is unnecessary here.
+            // `get_or_put` zero-initializes the slot on insert (`Use::default()`).
             self.symbol_uses
                 .get_or_put(ref_)
                 .expect("unreachable")
@@ -1876,7 +1845,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         // Substitute an EImportIdentifier now if this has a namespace alias
         if opts.assign_target() == js_ast::AssignTarget::None && !opts.is_delete_target() {
-            // PORT NOTE: copy the alias out so the &self.symbols borrow is released
+            // copy the alias out so the &self.symbols borrow is released
             // before the &mut self calls below.
             let ns_alias_opt = self.symbols[ref_.inner_index() as usize]
                 .namespace_alias
@@ -2018,8 +1987,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if let Some(name) = original_name {
             let result = self.find_symbol(loc, name).expect("unreachable");
             let mut id_clone = ident;
-            // Zig: `id_clone.ref = result.ref` — flags are separate fields and
-            // survive. Here they ride in `ref_`'s user-bit lane, so re-apply
+            // Flags ride in `ref_`'s user-bit lane, so re-apply
             // them across the identity write or the visitor's
             // must_keep_due_to_with_stmt / can_be_removed_if_unused /
             // call_can_be_unwrapped_if_unused hints would be silently dropped.
@@ -2136,8 +2104,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         I: AsRef<[<Sym as GenerateImportSymbols>::Key]>,
         Sym: GenerateImportSymbols,
     {
-        // TODO(port): `imports: anytype` + `symbols: anytype` — modeled via a helper trait;
-        // verify shapes match the two call sites (RuntimeImports vs map).
         let arena = self.arena;
         let imports = imports.as_ref();
         let import_record_i =
@@ -2151,7 +2117,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .flags
                 .set(bun_ast::ImportRecordFlags::IS_INTERNAL, is_internal);
         }
-        // Zig: `nonUniqueNameString` = MutableString.ensureValidIdentifier(nonUniqueNameStringBase()).
         // Render the sanitized-identifier formatter into the bump arena (same
         // pattern as `transpose_require` above).
         let import_path_identifier: &'a [u8] = {
@@ -2298,8 +2263,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let import_record_index =
             self.add_import_record_by_range(ImportKind::Stmt, bun_ast::Range::NONE, import_path);
 
-        // PORT NOTE: Zig used `if (hot_module_reloading) B.Object.Property else js_ast.ClauseItem`
-        // as the comptime item type. Rust const-generics can't select a type
+        // Const generics can't select a type
         // for a local, so we keep two arena vecs and only fill the one the
         // const-generic arm selects (the other stays empty / zero-cost).
         let len = 1
@@ -2330,7 +2294,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 if HOT_MODULE_RELOADING {
                     let key = self.new_expr(E::String::init(entry.name), bun_ast::Loc::EMPTY);
                     let value = self.b(B::Identifier { r#ref: entry.r#ref }, bun_ast::Loc::EMPTY);
-                    // PERF(port): was assume_capacity
                     items_hmr.push(B::Property {
                         flags: Default::default(),
                         key,
@@ -2338,7 +2301,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         default_value: None,
                     });
                 } else {
-                    // PERF(port): was assume_capacity
                     items_import.push(js_ast::ClauseItem {
                         alias: js_ast::StoreStr::new(entry.name),
                         original_name: js_ast::StoreStr::new(entry.name),
@@ -2429,10 +2391,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         r#ref: Ref,
         replacement: Expr,
     ) -> bool {
-        // Zig matched on `stmt.data` and took `*Expr` into the arena-owned payload.
         // `StmtData` stores `StoreRef<S::*>` (Copy NonNull); matching by value yields
-        // an owned `StoreRef` whose `DerefMut` reaches the same arena slot Zig wrote
-        // through, so writing to `*expr` below mutates the AST in place.
+        // an owned `StoreRef` whose `DerefMut` reaches the underlying arena slot,
+        // so writing to `*expr` below mutates the AST in place.
         let mut expr: js_ast::StoreRef<Expr> = 'brk: {
             match stmt.data {
                 js_ast::StmtData::SExpr(mut exp) => {
@@ -2467,7 +2428,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             return false;
         };
         // `StoreRef<Expr>: DerefMut` — arena-owned slot, parser holds exclusive
-        // access during the single-threaded visit pass (same contract as Zig `*Expr`).
+        // access during the single-threaded visit pass.
         let expr = &mut *expr;
 
         // Only continue trying to insert this replacement into sub-expressions
@@ -2528,10 +2489,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             self.report_stack_overflow(expr.loc);
             return Substitution::Failure(expr);
         }
-        // Zig matched on `expr.data` (a tagged union of `*E.*`) and mutated through
-        // the captured pointer. `ExprData` is `Copy`; matching by value yields owned
+        // `ExprData` is `Copy`; matching by value yields owned
         // `StoreRef<E::*>` copies whose `DerefMut` writes to the same arena slot,
-        // so `e.target = result` mutates the AST in place exactly as Zig did.
+        // so `e.target = result` mutates the AST in place.
         'outer: {
             match expr.data {
                 js_ast::ExprData::EIdentifier(ident) => {
@@ -3022,7 +2982,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         }
                     }
 
-                    // Zig held `[]TemplatePart` and mutated `part.value` in place;
                     // `E::Template.parts` is `StoreSlice<TemplatePart>` (arena-owned, mutable
                     // provenance preserved end-to-end) so derive the unique view directly.
                     // SAFETY: arena-owned slice; single-threaded visit pass has exclusive
@@ -3068,7 +3027,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn prepare_for_visit_pass(&mut self) -> Result<(), bun_core::Error> {
         {
-            // Zig: `Binding2ExprWrapper.{Namespace,Hoisted}.init(this)`.
             // The wrapper stores only the arena and a non-capturing
             // fn-pointer trampoline; the `*mut P` context is supplied *at call
             // time* (see `Binding::to_expr`) so the raw pointer's provenance is
@@ -3100,7 +3058,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 buf.push(*item_);
             }
             // `into_bump_slice()` leaks the BumpVec into the arena and returns
-            // a `&'a [T]` for that allocation (Zig: `p.arena.alloc(ScopeOrder, n)`).
+            // a `&'a [T]` for that allocation.
             self.scope_order_to_visit = buf.into_bump_slice();
         }
 
@@ -3292,9 +3250,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if self.runtime_imports.__require.is_some() {
             return;
         }
-        // Spec P.zig:2224-2229 calls declareSymbolMaybeGenerated with
-        // generatedSymbolName("__require") (the hashed name) directly,
-        // regardless of bundle mode. Do NOT route through
+        // Call declare_symbol_maybe_generated with the hashed
+        // "__require" name directly, regardless of bundle mode. Do NOT route through
         // declare_generated_symbol — that helper skips the hash when
         // `options.bundle == true`, which would let a user-level
         // `var __require` collide in `current_scope.members` and link the
@@ -3349,16 +3306,13 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let scope_ref = &*scope;
         if !scope_ref.kind_stops_hoisting() {
             let arena = self.arena;
-            // PORT NOTE: Zig captured `var symbols = p.symbols.items;` and asserted it
-            // wasn't resized; we re-borrow `self.symbols` after each `new_symbol` call.
+            // Re-borrow `self.symbols` after each `new_symbol` call.
 
             // Check for collisions that would prevent to hoisting "var" symbols up to the enclosing function scope
             if let Some(scope_parent) = scope_ref.parent {
                 let scope_strict_mode = scope_ref.strict_mode;
-                // PORT NOTE: reshaped for borrowck — Zig iterated `scope.members` while
-                // pushing to `scope.generated` and inserting into ancestor scopes' members.
-                // The loop never inserts into `scope.members` itself (only ancestors), so
-                // snapshotting `(name_ptr, Member)` pairs up front is semantically identical
+                // The loop below never inserts into `scope.members` itself (only ancestors), so
+                // snapshotting `(name_ptr, Member)` pairs up front preserves iteration semantics
                 // and lets us re-borrow `*scope` mutably inside the body.
                 let member_snapshot: BumpVec<'a, (js_ast::StoreStr, js_ast::scope::Member)> = {
                     let members = &scope_ref.members;
@@ -3495,10 +3449,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             {
                                 // Silently merge this symbol into the existing symbol
                                 self.symbols[symbol_idx].link.set(member_in_scope.ref_);
-                                // PORT NOTE: Zig also wrote `entry.key_ptr.* = name`; the Rust
                                 // `StringHashMap` get_or_put already stores the key on insert and
                                 // cannot hand out `&mut K` (see StringHashMapGetOrPut docs), so
-                                // the key write is a no-op here.
+                                // no key write is needed here.
                                 *_scope
                                     .get_or_put_member_with_hash(name, hash.unwrap())
                                     .value_ptr = member_in_scope;
@@ -3586,7 +3539,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     #[inline]
     fn next_scope_in_order_for_visit_pass(&mut self) -> ScopeOrder<'a> {
-        // Zig: `const order = scope_order_to_visit[0]; scope_order_to_visit = scope_order_to_visit[1..]`
         let (head, rest) = self
             .scope_order_to_visit
             .split_first()
@@ -3612,9 +3564,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let order = self.next_scope_in_order_for_visit_pass();
 
         // Sanity-check that the scopes generated by the first and second passes match
-        // PORT NOTE: Zig `and` binds tighter than `or`, so the original
-        // `allow_assert and loc_mismatch or kind_mismatch` keeps the kind check
-        // unconditional in release builds. Preserve that grouping here.
+        // The kind check is unconditional in release builds; only the loc
+        // check is debug-only. Preserve that grouping here.
         let order_scope = order.scope_ref();
         if (cfg!(debug_assertions) && order.loc.start != loc.start) || order_scope.kind != kind {
             self.log().level = bun_ast::Level::Verbose;
@@ -3639,8 +3590,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(())
     }
 
-    // PORT NOTE: Zig took `comptime kind` (adt_const_params on stable). All
-    // call sites pass a literal so the branch on `kind` is trivially predicted.
+    // All call sites pass a literal so the branch on `kind` is trivially predicted.
     #[allow(non_snake_case)]
     pub fn push_scope_for_parse_pass(
         &mut self,
@@ -3694,7 +3644,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     last_i -= 1;
                 }
 
-                // PORT NOTE: reshaped for borrowck — copy out loc before borrowing self mutably.
+                // reshaped for borrowck — copy out loc before borrowing self mutably.
                 if let Some(prev_loc) = self.scopes_in_order[last_i].as_ref().map(|s| s.loc) {
                     if prev_loc.start >= loc.start {
                         self.log().level = bun_ast::Level::Verbose;
@@ -3807,7 +3757,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             .unwrap_or_else(|| self.b(B::Missing {}, item.loc)),
                         default_value: res.expr,
                     });
-                    // PERF(port): was assume_capacity
                 }
 
                 return Some(self.b(
@@ -3877,7 +3826,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             .unwrap_or_else(|| self.b(B::Missing {}, expr.loc)),
                         default_value: initializer,
                     });
-                    // PERF(port): was assume_capacity
                 }
 
                 return Some(self.b(
@@ -3950,8 +3898,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     /// make it a compile error
     #[inline]
     pub fn mark_type_script_only(&self) {
-        // TODO(port): Zig used @compileError; const-generic specialization can't express
-        // a compile error in Rust. Could move TS-only methods behind a trait.
+        // Const-generic specialization can't express a compile error in stable
+        // Rust, so this is a runtime assertion instead.
         if !TYPESCRIPT {
             unreachable!();
         }
@@ -3996,14 +3944,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             self.panic("Internal error", format_args!(""));
         }
 
-        // PORT NOTE (spec parity): Zig P.zig:2700-2707 does `var children =
-        // parent.children;` (a *value copy* of the Vec header) then
-        // `_ = children.pop();` — the pop mutates only the local copy, so
-        // `parent.children` is left unchanged (contrast `discardScopesUpTo`
-        // which writes back via `defer scope.children = children`). The
-        // discarded scope therefore remains in `parent.children` and is later
-        // visited by `hoistSymbols`/`computeCharacterFrequency` recursion.
-        // Match spec: only assert above, do not actually pop.
+        // Intentionally leave `parent.children` unchanged (contrast
+        // `discard_scopes_up_to`, which writes the modified children list back).
+        // The discarded scope remains in `parent.children` and is later visited
+        // by the hoist-symbols / compute-character-frequency recursion.
+        // Only assert above; do not actually pop.
     }
 
     // blocked_on: S::Import field set; crate::parser::MacroRefData; ParsedPath fields; ImportItemForNamespaceMap API
@@ -4014,7 +3959,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         loc: bun_ast::Loc,
         was_originally_bare_import: bool,
     ) -> Result<Stmt, bun_core::Error> {
-        let is_macro = true /* TODO(port): feature_flag::IS_MACRO_ENABLED */ && (path.is_macro || crate::Macro::is_macro_path(path.text));
+        let is_macro =
+            Self::ALLOW_MACROS && (path.is_macro || crate::Macro::is_macro_path(path.text));
         let mut stmt = stmt_;
         if is_macro {
             let id = self.add_import_record(ImportKind::Stmt, path.loc, path.text);
@@ -4258,9 +4204,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     }
                 }
 
-                // Zig had a duplicate `if (ParsePassSymbolUsageType != void)` block here;
-                // both gates resolve to the same condition in Rust so we omit the second.
-
                 // No need to add the `default_name` to `item_refs` because
                 // `.scanImportsAndExports(...)` special cases and handles
                 // `default_name` separately
@@ -4270,7 +4213,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let items_slice: &mut [js_ast::ClauseItem] = stmt.items.slice_mut();
         for i in 0..items_slice.len() {
-            // PORT NOTE: Zig copied `ClauseItem` by value (POD struct). Rust's
             // `ClauseItem` does not derive `Copy`; bit-copy via `ptr::read` —
             // all fields are POD (`StoreStr`/`Loc`/`LocRef`).
             // SAFETY: items_slice[i] is a live initialised `ClauseItem`; the
@@ -4459,7 +4401,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         kind: js_ast::symbol::Kind,
         identifier: &'a [u8],
     ) -> Result<Ref, bun_core::Error> {
-        // TODO(port): narrow error set
         let inner_index = self.symbols.len() as js_ast::base::RefInt; // @truncate
         self.symbols.push(Symbol {
             kind,
@@ -4529,8 +4470,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let mut cur = self.current_scope_ref();
         let current_scope_ptr: *mut js_ast::Scope = cur.as_ptr();
         let children = &mut cur.children;
-        // PORT NOTE: Zig copied `var children = scope.children` + `defer scope.children = children`.
-        // Vec isn't Copy in Rust; mutate the field in place via the handle instead.
 
         for _child in &self.scopes_in_order[scope_index..] {
             let Some(child) = _child else { continue };
@@ -4579,7 +4518,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         data: js_ast::ts::Data::Property,
                     },
                 )?;
-                // ref_to_ts_namespace_member derefs to std HashMap; Zig `put(arena, k, v)` → insert.
                 self.ref_to_ts_namespace_member
                     .insert(id.r#ref, js_ast::ts::Data::Property);
             }
@@ -4612,7 +4550,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         // statements with identifier bindings.
                         return Ok(());
                     }
-                    // PERF(port): was comptimePrint — runtime format here is fine for error path
                     self.log().add_error_fmt(
                         Some(self.source),
                         value.loc,
@@ -4643,7 +4580,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let what = match KIND {
             js_ast::s::Kind::KAwaitUsing | js_ast::s::Kind::KUsing => "declaration",
             js_ast::s::Kind::KConst => "constant",
-            _ => unreachable!(), // @compileError("unreachable") in Zig
+            _ => unreachable!(),
         };
 
         for decl in decls {
@@ -4730,10 +4667,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         // Otherwise, generate a new namespace object.
-        // PORT NOTE: Zig batched map+scope into one alloc and patched
-        // `exported_members` post-init. `StoreRef` is non-null so the field
-        // can't be null-then-patch; two bump allocs from the same arena is the
-        // same locality and avoids the self-referential init.
+        // Two bump allocs from the same arena; `StoreRef` is non-null so the
+        // map field can't be null-then-patched, and same-arena allocation
+        // keeps the locality while avoiding a self-referential init.
         let map = js_ast::StoreRef::from_bump(self.arena.alloc(Default::default()));
         self.ts_namespace_member_maps.push(map);
         let scope = js_ast::StoreRef::from_bump(self.arena.alloc(js_ast::TSNamespaceScope {
@@ -4901,9 +4837,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(ref_)
     }
 
-    /// Zig: `comptime name: string` — every call site passes a literal, and
-    /// `generatedSymbolName` concatenates a comptime hash. Rust can't macro-call
-    /// on a runtime param, so callers must pre-hash via `generated_symbol_name!`
+    /// Callers must pre-hash via `generated_symbol_name!`
     /// and pass the result, OR (non-bundle) we runtime-hash into the bump arena.
     pub fn declare_generated_symbol(
         &mut self,
@@ -4914,7 +4848,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if self.options.bundle {
             return self.declare_symbol_maybe_generated::<true>(kind, bun_ast::Loc::EMPTY, name);
         }
-        // Runtime equivalent of `generated_symbol_name!` (Zig comptime concat).
+        // Runtime equivalent of `generated_symbol_name!`.
         // Same bytes as the macro produces; arena-owned for symbol lifetime.
         let hash = bun_wyhash::hash(name);
         let hashed: &'a [u8] = bun_alloc::arena_format!(in self.arena, "{}_{}", bstr::BStr::new(name), bun_core::fmt::truncated_hash32(hash)).into_bump_str().as_bytes();
@@ -4927,7 +4861,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         loc: bun_ast::Loc,
         name: &'a [u8],
     ) -> Result<Ref, bun_core::Error> {
-        // PERF(port): Zig used @call(bun.callmod_inline, ...) — rely on LLVM inlining
         self.declare_symbol_maybe_generated::<false>(kind, loc, name)
     }
 
@@ -4955,7 +4888,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // Allocate a new symbol
         let mut ref_ = self.new_symbol(kind, name)?;
 
-        // Single-probe `getOrPut`, matching Zig. The previous two-probe shape
+        // Single-probe `getOrPut`. The previous two-probe shape
         // (`members.get` then `members.put_borrowed`) existed only because the
         // merge decision read `self.current_scope()` while the entry borrow was
         // live, which under Stacked Borrows invalidated the entry's `&mut`.
@@ -5109,7 +5042,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if contents_ptr <= name_ptr
             && (name_ptr + name.len()) <= (contents_ptr + self.source.contents.len())
         {
-            // Zig: `@intCast` — unchecked in ReleaseFast. Both values are
+            // Both values are
             // bounded by `source.contents.len()` which the lexer already
             // requires to fit in u32 (Loc is i32). debug_assert preserves the
             // safety check without the per-identifier branch in release.
@@ -5121,7 +5054,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 js_ast::base::RefTag::SourceContentsSlice,
             ))
         } else {
-            // Zig u31 `@intCast` — allocated_names.len() is bounded by the
+            // `allocated_names.len()` is bounded by the
             // symbol budget (asserted by Ref::pack's INNER_INDEX_BITS check).
             let inner_index = self.allocated_names.len();
             debug_assert!(inner_index <= u32::MAX as usize);
@@ -5162,12 +5095,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // `ImportRecord.path` is `fs::Path<'static>` (PORTING.md: no struct
         // lifetime params yet). The parser-supplied path borrows arena-owned 'a bytes
         // which outlive the import_records list (both dropped with the parser arena),
-        // so the lifetime extension is sound here. TODO(refactor): thread `'a` through
-        // `bun_ast::ImportRecord` and remove this erasure.
+        // so the lifetime extension is sound here. Removing the erasure requires
+        // threading `'a` through `bun_ast::ImportRecord`.
         // SAFETY: see above — arena 'a outlives every ImportRecord stored in self.import_records.
         let path: fs::Path<'static> = unsafe { path.into_static() };
-        // No `impl Default for ImportRecord` (range/path/kind have no Zig defaults) —
-        // spell out the optional fields with their Zig field-defaults explicitly.
+        // No `impl Default for ImportRecord` (range/path/kind have no defaults) —
+        // spell out the optional fields explicitly.
         self.import_records.push(ImportRecord {
             kind,
             range,
@@ -5258,8 +5191,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     #[cold]
     pub fn panic(&mut self, fmt: &'static str, args: core::fmt::Arguments) -> ! {
-        // TODO(port): forward to panic_loc once that un-gates (needs log.print(&mut [u8])).
-        Output::panic(format_args!("{}\n{}", fmt, args));
+        self.panic_loc(fmt, args, None)
     }
 
     #[cold]
@@ -5270,9 +5202,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         args: core::fmt::Arguments,
         loc: Option<bun_ast::Loc>,
     ) -> ! {
-        // PORT NOTE: Zig used a fixed `std.Io.Writer` over a 32 KiB stack buffer.
-        // Rust's `Log::print` takes `IntoLogWrite` (`fmt::Write`), so write into a
-        // bump-backed `String` instead — same single contiguous text output.
+        // `Log::print` takes `IntoLogWrite` (`fmt::Write`), so write into a
+        // bump-backed `String` — one contiguous text output.
         let mut panic_stream = bun_alloc::ArenaString::with_capacity_in(32 * 1024, self.arena);
 
         // panic during visit pass leaves the lexer at the end, which
@@ -5331,8 +5262,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 value,
                 part,
                 loc,
-                // Zig: `.{ .is_call_target = false, .assign_target = .none, .is_delete_target = false }`
-                // — all defaults on the packed-u8 IdentifierOpts.
+                // All defaults on the packed-u8 IdentifierOpts.
                 IdentifierOpts::default(),
             ) {
                 value = rewrote;
@@ -5383,14 +5313,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let arena = self.arena;
         let mut opts = PrependTempRefsOpts::default();
         let mut part_stmts = bun_alloc::vec_from_iter_in(stmts.iter().copied(), arena);
-        // PORT NOTE: Zig used ListManaged.fromOwnedSlice; we copy into a bump vec.
 
         self.visit_stmts_and_prepend_temp_refs(&mut part_stmts, &mut opts)?;
 
         // Insert any relocated variable statements now
         if !self.relocated_top_level_vars.is_empty() {
             let mut already_declared = RefMap::default();
-            // PERF(port): was stack-fallback alloc — profile if hot.
 
             for i in 0..self.relocated_top_level_vars.len() {
                 // Follow links because "var" declarations may be merged due to hoisting
@@ -5483,11 +5411,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(())
     }
 
-    // PORT NOTE: Zig p.zig:3719 declares `bindingCanBeRemovedIfUnused` (the
-    // DCE-gated wrapper) but never calls it — every caller goes through
-    // `stmtsCanBeRemovedIfUnused` which already gates on
-    // `dead_code_elimination` and then invokes the `_without_dce_check`
-    // recursion below. The wrapper is dead in spec and is dropped here.
     fn binding_can_be_removed_if_unused_without_dce_check(&mut self, binding: Binding) -> bool {
         match binding.data {
             js_ast::b::B::BArray(bi) => {
@@ -5718,9 +5641,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         None
     }
 
-    // PERF(port): takes `&Expr` — the Zig original passes `Expr` by value (cheap there:
-    // `Expr` is `{ *Data, Loc }` = 16B), but Rust's `Expr` inlines `ExprData` so a by-value
-    // pass copies the full union. The only caller (`visit_expr_in_out`) already holds `&mut Expr`.
+    // PERF: takes `&Expr` — `Expr` inlines `ExprData`, so a by-value pass copies
+    // the full union. The only caller (`visit_expr_in_out`) already holds `&mut Expr`.
     pub fn is_valid_assignment_target(&self, expr: &Expr) -> bool {
         match &expr.data {
             js_ast::ExprData::EIdentifier(ident) => {
@@ -5799,17 +5721,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn keep_expr_symbol_name(&mut self, _value: Expr, _name: &[u8]) -> Expr {
         _value
-        // var start = p.expr_list.items.len;
-        // p.expr_list.ensureUnusedCapacity(2) catch unreachable;
-        // p.expr_list.appendAssumeCapacity(_value);
-        // p.expr_list.appendAssumeCapacity(p.newExpr(E.String{
-        //     .utf8 = name,
-        // }, _value.loc));
-
-        // var value = p.callRuntime(_value.loc, "ℹ", p.expr_list.items[start..p.expr_list.items.len]);
-        // // Make sure tree shaking removes this if the function is never used
-        // value.getCall().can_be_unwrapped_if_unused = true;
-        // return value;
     }
 
     pub fn is_simple_parameter_list(args: &[G::Arg], has_rest_arg: bool) -> bool {
@@ -6127,8 +6038,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         false
     }
 
-    // (Zig commented-out `exprCanBeHoistedForJSX` omitted — was already dead code.)
-
     fn is_side_effect_free_unbound_identifier_ref(
         &mut self,
         value: Expr,
@@ -6374,8 +6283,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
             crate::parser::Runtime::ReplaceableExport::Inject { name, value } => {
                 let count = stmts.len();
-                // PORT NOTE: Zig kept `with.name` as an arena slice; the Rust
-                // `ReplaceableExport::Inject` boxes it, so copy into the bump
+                // `ReplaceableExport::Inject` boxes the name, so copy into the bump
                 // arena to satisfy `declare_symbol`'s `&'a [u8]`.
                 let name: &'a [u8] = self.arena.alloc_slice_copy(name);
                 let inject_ref = self
@@ -6494,7 +6402,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         match binding.data {
             js_ast::b::B::BMissing(_) => {}
             js_ast::b::B::BIdentifier(ident) => {
-                // RefRefMap derefs to std::collections::HashMap; Zig `put(arena, k, v)` → insert.
                 self.is_exported_inside_namespace.insert(ident.r#ref, r#ref);
             }
             js_ast::b::B::BArray(array) => {
@@ -6626,7 +6533,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             )
         };
 
-        // PORT NOTE: `G::Arg` is not `Copy` (contains `Vec<Decorator>`); use
+        // `G::Arg` is not `Copy` (contains `Vec<Decorator>`); use
         // `alloc_slice_fill_iter` instead of `alloc_slice_copy`.
         let func_args = bun_ast::StoreSlice::new_mut(arena.alloc_slice_fill_iter([G::Arg {
             binding: self.b(B::Identifier { r#ref: arg_ref }, name_loc),
@@ -6764,12 +6671,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         define_data: &DefineData,
     ) -> Expr {
         // Callers gate on `!valueless()` before reaching here, so `value` is a
-        // real Expr.Data by contract (Zig: `define_data.value`).
+        // real Expr.Data by contract.
         let value = define_data.value;
         match value {
             js_ast::ExprData::EIdentifier(id) => {
-                // Spec P.zig:5510: `define_data.original_name().?` — identifier
-                // defines always carry a name; `.?` panics on null. Match the
+                // Identifier defines always carry a name. Match the
                 // contract so `handle_identifier`'s trailing `find_symbol`
                 // rebind runs against the *resolved* scope ref, not the
                 // define-time ref silently passed through with `None`.
@@ -6869,7 +6775,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 }
 
-// Free fn: Zig `fs.Path.packageName`. `bun_paths::fs::Path` lacks this method
+// `bun_paths::fs::Path` lacks a package-name method
 // (it lives on the resolver `Path`, which `bun_js_parser` cannot depend on), so
 // the slice logic is inlined here. Mirrors `src/resolver/fs.rs::Path::packageName`.
 fn path_package_name<'a>(path: &fs::Path<'a>) -> Option<&'a [u8]> {
@@ -6878,7 +6784,6 @@ fn path_package_name<'a>(path: &fs::Path<'a>) -> Option<&'a [u8]> {
         name_to_use = &path.text[node_modules + bun_paths::NODE_MODULES_NEEDLE.len()..];
     }
 
-    // Zig: `bun.options.JSX.Pragma.parsePackageName` — pure slice helper.
     let pkgname = {
         let str = name_to_use;
         'brk: {
@@ -6925,9 +6830,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                 // Standard decorator lowering path (for both JS and TS files)
                 if s_class.class.should_lower_standard_decorators {
-                    // PORT NOTE: Zig `lowerStandardDecoratorsStmt` returns `[]Stmt`; the
-                    // Rust stub takes an out-param Vec instead. Wrap to keep
-                    // this function's `[]Stmt` contract.
+                    // `lower_standard_decorators_stmt` takes an out-param Vec; wrap to
+                    // keep this function's slice contract.
                     let mut out = BumpVec::<Stmt>::new_in(self.arena);
                     self.lower_standard_decorators_stmt(stmt, &mut out);
                     return out.into_bump_slice_mut();
@@ -7028,12 +6932,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         let mut array = BumpVec::<Expr>::new_in(self.arena);
 
                         if self.options.features.emit_decorator_metadata {
-                            // TODO(port): full design:type / design:paramtypes / design:returntype
-                            // metadata emission ported below in condensed form.
                             self.emit_decorator_metadata_for_prop(prop, &mut array, loc);
                         }
 
-                        // PORT NOTE: reshaped — Zig insertSlice(0, ...) prepends; we prepend then push args.
                         let mut full = BumpVec::<Expr>::with_capacity_in(
                             prop.ts_decorators.len_u32() as usize + array.len(),
                             self.arena,
@@ -7143,9 +7044,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         continue;
                     }
 
-                    // PORT NOTE: Zig copies `prop.*` by value into the new list; the old
-                    // backing slice is overwritten right after this loop, so `take` is
-                    // semantically equivalent (Property: Default).
+                    // The old backing slice is overwritten right after this loop, so
+                    // `take` is fine here (Property: Default).
                     class_properties.push(core::mem::take(prop));
                 }
 
@@ -7173,7 +7073,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         }
 
                         let i = super_index.map(|j| j + 1).unwrap_or(0);
-                        // TODO(port): bumpalo Vec lacks insert_slice; emulate via per-item insert.
+                        // bumpalo Vec lacks insert_slice; emulate via per-item insert.
                         for (off, m) in instance_members.iter().enumerate() {
                             constructor_stmts.insert(i + off, *m);
                         }
@@ -7181,9 +7081,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         cf.func.body.stmts =
                             bun_ast::StoreSlice::new_mut(constructor_stmts.into_bump_slice_mut());
                     } else {
-                        // PORT NOTE: Zig `Property.List.fromList(class.properties)` re-wraps the
-                        // freshly-installed slice and inserts at index 0. We rebuild instead
-                        // (Property is not Clone in Rust).
+                        // Rebuild the property list with the new entry at index 0
+                        // (Property is not Clone).
                         let old_props: bun_ast::StoreSlice<G::Property> = s_class.class.properties;
                         let old_len = old_props.len();
                         let mut properties =
@@ -7270,7 +7169,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     stmts_count += 1;
                 }
                 let mut stmts = BumpVec::<Stmt>::with_capacity_in(stmts_count, self.arena);
-                stmts.push(stmt); // PERF(port): was assume_capacity
+                stmts.push(stmt);
                 stmts.extend_from_slice(&static_members);
                 stmts.extend_from_slice(&instance_decorators);
                 stmts.extend_from_slice(&static_decorators);
@@ -7350,9 +7249,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
-    // Helper extracted from lower_class to keep that fn readable.
-    // TODO(port): this condenses the Zig per-kind metadata switch (lines 5024-5105).
-    // Diff against Zig to verify exact arg ordering for get/set.
+    // Helper extracted from lower_class to keep that fn readable; condenses
+    // the per-kind metadata switch.
     #[cold]
     #[inline(never)]
     fn emit_decorator_metadata_for_prop(
@@ -7364,7 +7262,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         use js_ast::g::PropertyKind;
 
         // Local helper: bump-alloc an arg pair and call __legacyMetadataTS.
-        // PORT NOTE: pulled out of the per-arm code to cut a ~3x repetition vs Zig.
+        // pulled out of the per-arm code to cut a ~3x repetition.
         macro_rules! push_metadata {
             ($label:expr, $value:expr) => {{
                 let label = self.new_expr(E::EString::from_static($label), bun_ast::Loc::EMPTY);
@@ -7687,7 +7585,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             .expect("infallible: in namespace");
         self.record_usage(enclosing_ref);
 
-        // TODO(port): E::Dot.name is `&'static [u8]` pending crate-wide 'bump
+        // E::Dot.name is `&'static [u8]` pending crate-wide 'bump
         // threading. Symbol.original_name is an arena-owned `StoreStr` (lives for
         // parser 'a, which outlives every Expr). Erase the lifetime to fit the
         // placeholder field type.
@@ -7708,10 +7606,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     pub fn wrap_identifier_hoisting(&mut self, loc: bun_ast::Loc, r#ref: Ref) -> Expr {
-        // There was a Zig stage1 bug here we had to copy `ref` into a local
-        // const variable or else the result would be wrong
-        // I remember that bug in particular took hours, possibly days to uncover.
-
         self.relocated_top_level_vars.push(LocRef {
             loc,
             ref_: Some(r#ref),
@@ -7972,10 +7866,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if call.args.len_u32() == 0 {
             return;
         }
-        // PORT NOTE: match `data` by value (it is `Copy`) so the `StoreRef<_>`
+        // match `data` by value (it is `Copy`) so the `StoreRef<_>`
         // payloads bind owned + `mut`, letting `to_utf8` mutate the EString in
-        // place and `arr.items.slice_mut()` write through `DerefMut` — same
-        // arena slots Zig's `*E.String` / `*E.Array` captures wrote to.
+        // place and `arr.items.slice_mut()` write through `DerefMut` into the
+        // underlying arena slots.
         match call.args.at(0).data {
             js_ast::ExprData::EString(mut str_) => {
                 let loc = call.args.at(0).loc;
@@ -8139,12 +8033,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     ) {
         debug_assert!(self.options.features.react_fast_refresh);
         debug_assert!(ReactRefresh::is_hook_name(original_name));
-        // PORT NOTE: Zig stores `?*?HookContext` (raw pointer to stack storage in
-        // the visiting fn frame). `ReactRefresh::hook_ctx_mut` centralises the
+        // `ReactRefresh::hook_ctx_mut` centralises the
         // raw-pointer deref and returns a borrow detached from `self` (the
         // storage is on a caller stack frame), so we can call other `&mut self`
         // methods (generate_temp_ref_with_scope, declared_symbols.append) while
-        // holding it — exactly mirroring the Zig pointer flow.
+        // holding it.
         let Some(ctx_storage) = self.react_refresh.hook_ctx_mut() else {
             return; // not in a function, ignore this hook call.
         };
@@ -8263,7 +8156,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             // The array has enough capacity, so there is no possibility of
             // allocation failure. We just move all of the statements over
             // by one, and increase the length using `addOneAssumeCapacity`
-            stmts.push(Stmt::empty()); // PERF(port): was assume_capacity
+            stmts.push(Stmt::empty());
             let len = stmts.len();
             stmts.copy_within(0..len - 1, 1);
         }
@@ -8325,7 +8218,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .alloc_slice_fill_default::<u8>(bun_base64::encode_len_from_size(
                     core::mem::size_of_val(&final_),
                 ));
-        // Zig: `&std.mem.toBytes(final)`
         let _written = bun_base64::encode(hash_data, &final_.to_ne_bytes());
         debug_assert!(_written == hash_data.len());
 
@@ -8419,9 +8311,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             debug_assert!(!self.options.tree_shaking);
             debug_assert!(self.options.features.hot_module_reloading);
 
-            // PORT NOTE: Zig held `&mut parts[last]` inside `hmr_transform_ctx`
-            // while iterating `parts` — Rust borrowck rejects that aliasing.
-            // Reshaped via `split_last_mut` so the head slice and tail part are
+            // `split_last_mut` keeps the head slice and tail part as
             // disjoint borrows; `finalize()` takes only the head prefix so the
             // two `&mut` regions stay disjoint (Stacked-Borrows-clean).
             let (last_part, head_parts) = parts
@@ -8429,7 +8319,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .expect("hot_module_reloading parse always has at least one part");
             let mut hmr_transform_ctx = ConvertESMExportsForHmr {
                 last_part,
-                // Spec P.zig:6390: `p.source.path.isNodeModule()`.
                 // Round-G fix: `bun_paths::fs::Path::is_node_module` is now real
                 // (checks `name.dir` for `<sep>node_modules<sep>` with the
                 // platform separator); the former inline copy mis-handled the
@@ -8459,7 +8348,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     Some(&mut hmr_transform_ctx),
                 )?;
             }
-            // Re-run for the last part (Zig iterated all `parts.items` including last).
+            // Re-run for the last part.
             {
                 let last_stmts = hmr_transform_ctx.last_part.stmts;
                 let _ = ImportScanner::scan::<TYPESCRIPT, SCAN_ONLY, true>(
@@ -8483,16 +8372,15 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 // Potentially remove some statements, then filter out parts to remove any
                 // with no statements
                 for idx in begin..parts.len() {
-                    // PORT NOTE: Zig `var part = part_;` is a *shallow bitwise copy*
-                    // that leaves `parts.items[idx]` intact so the outer multi-pass
-                    // loop (which restarts at `begin = parts_end`) re-scans real data
-                    // on the next iteration. `mem::take` would zero the slot and
-                    // degrade this to a single pass. Match Zig with `ptr::read`; the
+                    // A shallow bitwise copy leaves `parts[idx]` intact so the outer
+                    // multi-pass loop (which restarts at `begin = parts_end`) re-scans
+                    // real data on the next iteration. `mem::take` would zero the slot
+                    // and degrade this to a single pass, so use `ptr::read`; the
                     // duplicate is non-owning (paired with `ptr::write`/`forget`
                     // below to avoid double-drop of arena-backed Vec fields).
                     // SAFETY: idx < parts.len(); Part fields are arena/bump-backed
-                    // (Borrowed-origin BabyLists, raw stmt slices) — bitwise copy
-                    // matches Zig struct-assignment semantics.
+                    // (Borrowed-origin BabyLists, raw stmt slices), so the bitwise copy is
+                    // a valid non-owning duplicate.
                     let mut part = core::mem::ManuallyDrop::new(unsafe {
                         core::ptr::read(&raw const parts[idx])
                     });
@@ -8530,7 +8418,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             // SAFETY: `part` is a bitwise duplicate of `parts[idx]`
                             // (via `ptr::read` above); the old `declared_symbols`
                             // is still owned by that slot. Overwrite without running
-                            // Drop to match Zig's plain field assignment.
+                            // Drop, which would double-free the original.
                             unsafe {
                                 core::ptr::write(
                                     &raw mut part.declared_symbols,
@@ -8545,12 +8433,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                         if part.import_record_indices.is_empty() {
                             // Bump-arena slice; Vec::from_bump_slice marks origin
-                            // Borrowed so Drop is a no-op (matches Zig's
-                            // `ImportRecord.List.init(dupe(...))` arena ownership).
+                            // Borrowed so Drop is a no-op (arena ownership).
                             // The *old* value is a bitwise duplicate of
                             // `parts[idx].import_record_indices` and may be Owned —
-                            // overwrite without running Drop to mirror Zig's plain
-                            // field assignment.
+                            // overwrite without running Drop, which would double-free the original.
                             // SAFETY: bitwise duplicate field — overwrite without
                             // running Drop (see `declared_symbols` above).
                             unsafe {
@@ -8577,9 +8463,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                 Default::default(),
                             );
                         }
-                        // SAFETY: bitwise overwrite matching Zig
-                        // `parts.items[parts_end] = part;` — old slot value is not
-                        // dropped (arena-owned; Zig never deinit'd it either).
+                        // SAFETY: bitwise overwrite — the old slot value is intentionally not
+                        // dropped (its fields are arena-owned, so abandoning it does not leak).
                         unsafe {
                             core::ptr::write(
                                 parts.as_mut_ptr().add(parts_end),
@@ -8614,12 +8499,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
 
             // leave the first part in there for namespace export when bundling
-            // PORT NOTE: Zig `parts.items.len = parts_end` does not drop the tail.
             // `truncate` would drop slots that may alias kept parts (the loop
             // above did `ptr::read` without clearing the source), so use
-            // `set_len` to match Zig's no-destructor semantics.
+            // `set_len`, which runs no destructors.
             // SAFETY: `parts_end <= parts.len()`; tail slots are abandoned
-            // (arena-/process-lifetime, same as Zig).
+            // (arena-/process-lifetime).
             unsafe { parts.set_len(parts_end) };
 
             // Do a second pass for exported items now that imported items are filled out.
@@ -8722,7 +8606,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
             total_stmts_count += usize::from(preserve_strict_mode);
 
-            // PORT NOTE: Stmt is not Default; fill with `Stmt::empty()`.
+            // Stmt is not Default; fill with `Stmt::empty()`.
             let stmts_to_copy = arena.alloc_slice_fill_with(total_stmts_count, |_| Stmt::empty());
             {
                 let mut remaining_stmts = &mut stmts_to_copy[..];
@@ -8754,8 +8638,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             loc: bun_ast::Loc::EMPTY,
                             stmts: bun_ast::StoreSlice::new_mut(stmts_to_copy),
                         },
-                        // PORT NOTE: Zig `Flags.Function.init(.{ .is_export = false })` →
-                        // empty FunctionSet (no flags set).
                         flags: Flags::FUNCTION_NONE,
                         ..Default::default()
                     },
@@ -8771,7 +8653,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 bun_ast::Loc::EMPTY,
             )]);
 
-            // PORT NOTE: reshaped — Zig wrote `parts.items.len = 1` directly.
             // BumpVec has no `set_len`-on-grow path; ensure at least one slot then truncate.
             if parts.is_empty() {
                 parts.push(js_ast::Part::default());
@@ -8782,8 +8663,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         // REPL mode transforms
         if self.options.repl_mode {
-            // PORT NOTE: Zig `ReplTransforms(@This()).apply` → inherent `apply_repl_transforms`
-            // (declared in ast::repl_transforms as an `impl P` mixin).
+            // `apply_repl_transforms` is declared in ast::repl_transforms as an
+            // `impl P` mixin.
             self.apply_repl_transforms(parts, arena)?;
         }
 
@@ -8791,7 +8672,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         if self.options.bundle {
             // Each part tracks the other parts it depends on within this file
-            // PORT NOTE: closure captures (top_level, symbols) via the `ctx` arg of
+            // closure captures (top_level, symbols) via the `ctx` arg of
             // `for_each_top_level_symbol`, since the iterator borrows `parts` while the
             // closure mutates `top_level_symbols_to_parts` (disjoint from `self.symbols`).
             struct Ctx<'s> {
@@ -8876,12 +8757,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let ts_enums = self.compute_ts_enums_map(arena)?;
 
-        // Spec P.zig:6658: `.char_freq = p.computeCharacterFrequency()`.
         let char_freq: Option<js_ast::CharFreq> = self.compute_character_frequency();
 
         let module_scope_strict = self.module_scope().strict_mode;
-        // PORT NOTE: Zig shallow-copies `p.module_scope.*` into Ast; Scope is not
-        // `Clone` in Rust (Vec/HashMap members), so move it out and leave
+        // Scope is not `Clone` (Vec/HashMap members), so move it out and leave
         // a default in `*self.module_scope`. `to_ast` is terminal — the parser
         // does not touch `module_scope` afterwards.
         let module_scope = core::mem::take(self.module_scope_mut());
@@ -8899,14 +8778,14 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             self.symbols[self.require_ref.inner_index() as usize].use_count_estimate > 0
         };
 
-        // Spec P.zig:6645: `.runtime_imports = p.runtime_imports` — move the
+        // Move the
         // parser's accumulated runtime-helper refs into the Ast so the linker /
         // printer can emit `__require`, `__toESM`, etc. Precompute `require_ref`
         // first since it reads `__require` from the same struct we're taking.
         let require_ref = self.runtime_imports.__require.unwrap_or(self.require_ref);
         let runtime_imports = core::mem::take(&mut self.runtime_imports);
 
-        // Spec P.zig:6695-6697 (`moveFromList`): re-tag the arena-backed buffer
+        // Re-tag the arena-backed buffer
         // into the `Ast` and leave the parser-side slot empty — a pointer move,
         // no realloc/memcpy. `Ast.{symbols,parts,import_records}` are now
         // `ArenaVec<'a, T>` so the move is type-checked.
@@ -8919,7 +8798,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // returned up the `_parse → parse → cache → transpiler` chain (see
         // `js_parser::Result` PERF NOTE).
         Ok(Box::new(js_ast::Ast {
-            // Spec P.zig:6644: `.runtime_imports = p.runtime_imports`.
             // Round-G: `Ast.runtime_imports` is now the real
             // `parser::Runtime::Imports`; moved out above (P is terminal after
             // `to_ast`).
@@ -8960,7 +8838,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             has_commonjs_export_names: self.has_commonjs_export_names,
             has_import_meta: self.has_import_meta,
 
-            // Spec P.zig:6689: `.hashbang = hashbang`.
             hashbang: hashbang.into(),
             // TODO: cross-module constant inlining
             // const_values: self.const_values,
@@ -8971,8 +8848,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             parts: parts_list,
             import_records,
 
-            // ── Remaining fields spelled out (their Zig struct-literal
-            //    defaults). Previously `..Default::default()` constructed a
+            // ── Remaining fields spelled out explicitly. Previously
+            //    `..Default::default()` constructed a
             //    full temporary `Ast` — including a `Scope::default()` for
             //    `module_scope` and empty `Vec`/map headers for
             //    `parts`/`symbols`/`import_records`/`named_*` — only to drop
@@ -9007,7 +8884,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             let Some(js_ast::ts::Data::Namespace(namespace)) =
                 self.ref_to_ts_namespace_member.get(r#ref)
             else {
-                // Zig `.?` — must be present and a namespace for top-level enums.
+                // Must be present and a namespace for top-level enums.
                 unreachable!("top_level_enums entry missing namespace member data");
             };
             let ns: &js_ast::TSNamespaceMemberMap = namespace;
@@ -9099,17 +8976,17 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 }
 
 // The Binding2ExprWrapper / ExpressionTransposer self-referential helpers are
-// seeded with arena-unit placeholders inside the struct literal.
-// TODO(refactor): wire the real `*P` back-pointer.
+// seeded with arena-unit placeholders inside the struct literal; the real `*P`
+// back-pointer is wired lazily by the call sites.
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    /// Construct a `P` in place at `out` (matching Zig's `init(..., this: *P) !void`).
+    /// Construct a `P` in place at `out`.
     ///
-    /// PERF(port): the previous shape returned `Result<Self, _>` by value. `P`
+    /// PERF: an earlier shape returned `Result<Self, _>` by value. `P`
     /// is ~5 KiB; the by-value return forced a stack temp inside `init` (5176-B
     /// frame, ASM-verified) plus a move at the caller's `?` (`_scan_imports`
-    /// 14168-B frame, 5× `memcpy`). Zig's `var p: P = undefined; try P.init(..,
-    /// &p)` writes the struct exactly once at its final address. This restores
-    /// that: every pre-computable post-init mutation is hoisted above the
+    /// 14168-B frame, 5× `memcpy`). Out-pointer init writes the struct exactly
+    /// once at its final address: every pre-computable post-init mutation is
+    /// hoisted above the
     /// single `out.write(Self { .. })` so there is no stack temporary `Self`
     /// to relocate.
     ///
@@ -9127,8 +9004,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         mut opts: ParserOptions<'a>,
     ) -> Result<(), bun_core::Error> {
         // Pre-size the parser's per-file name/ref-keyed symbol maps so the
-        // common case never re-hashes while it grows. Upstream Zig grows these
-        // incrementally too, but profiling the runtime transpiler showed
+        // common case never re-hashes while it grows. Profiling the runtime
+        // transpiler showed
         // `hashbrown` `make_hash` / `reserve_rehash` churn from the module
         // scope's member map and the visit-pass `symbol_uses` map being created
         // at zero capacity and reserved one identifier reference at a time. A
@@ -9152,7 +9029,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let scope = js_ast::StoreRef::from_bump(scope_obj);
 
         scope_order.push(Some(ScopeOrder::new(loc_module_scope, scope.as_ptr())));
-        // PERF(port): was assume_capacity
 
         // Only enable during bundling, when not bundling CJS
         let commonjs_named_exports_deoptimized = if opts.bundle {
@@ -9173,13 +9049,14 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let unwrap_all_requires = 'brk: {
             if opts.bundle && opts.output_format != options::Format::Cjs {
-                // Zig: `source.path.packageName()` — `bun_paths::fs::Path<'static>` is the
+                // `bun_paths::fs::Path<'static>` is the
                 // crate-local minimal stub (no `pretty`, no `package_name()`),
                 // so reuse the free `path_package_name` body via a borrowed
                 // `bun_paths::fs::Path` view over the same `text`. `pretty`
                 // is irrelevant once `node_modules/` is found in `text`; when
                 // it isn't, the result won't match any `unwrap_commonjs_packages`
-                // entry anyway. // TODO(port): unify bun_paths::fs::Path<'static> → bun_paths::fs::Path
+                // entry anyway. (Goes away if `bun_paths::fs::Path<'static>` is
+                // ever unified with the resolver `bun_paths::fs::Path`.)
                 let path_view = fs::Path {
                     text: source.path.text,
                     pretty: source.path.text,
@@ -9242,27 +9119,25 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 has_multiple_args: false,
                 has_catch: false,
             },
-            // Zig: `Binding2ExprWrapper.{Namespace,Hoisted}.init(this)` at the
-            // tail of `init`; deferred to `prepare_for_visit_pass` for the same
+            // Wired in `prepare_for_visit_pass` for the same
             // reason as the transposers (self moves on return).
             to_expr_wrapper_namespace: bun_ast::binding::ToExprWrapper::dangling(),
             to_expr_wrapper_hoisted: bun_ast::binding::ToExprWrapper::dangling(),
-            // Zig's ExpressionTransposer captures `*P`; in Rust the recursion
+            // The transposer recursion
             // lives as inherent `P::maybe_transpose_if_*` methods (no aliased
             // `&mut`). These ZST fields exist only to keep field-shape parity.
             import_transposer: ImportTransposer::dangling(),
             require_transposer: RequireTransposer::dangling(),
             require_resolve_transposer: RequireResolveTransposer::dangling(),
             source,
-            // Zig: `MacroState.init(arena)` leaves `prepend_stmts = undefined`;
-            // Rust cannot leave a `&'a mut Vec<Stmt>` uninitialized, so allocate
+            // A `&'a mut Vec<Stmt>` cannot be left uninitialized, so allocate
             // an empty placeholder in the arena (real list is wired by the visit
             // pass before any macro expansion runs).
             macro_: MacroState::init(arena.alloc(Vec::new())),
             current_scope: scope,
             module_scope: scope,
             scopes_in_order: scope_order,
-            needs_jsx_import: false, // Zig: `if (scan_only) false else void` — NeedsJSXType collapsed to `bool`
+            needs_jsx_import: false,
             lexer,
 
             commonjs_named_exports_deoptimized,
@@ -9368,8 +9243,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             options: opts,
         });
 
-        // PORT NOTE: Zig wires `ImportTransposer.init(this)` etc. here. In Rust
-        // the recursion lives as inherent `P::maybe_transpose_if_*` methods
+        // The transposer recursion lives as inherent `P::maybe_transpose_if_*` methods
         // called directly (no stored `*mut P`), and `Binding2ExprWrapper`
         // receives its `*mut P` per-call from the live `&mut P` at the call
         // site — `prepare_for_visit_pass` only wires the arena/trampoline.
@@ -9384,7 +9258,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 }
 
-// ─── LowerUsingDeclarationsContext (Zig: nested `pub const ... = struct { ... }`) ───
+// ─── LowerUsingDeclarationsContext ───
 pub struct LowerUsingDeclarationsContext {
     pub first_using_loc: bun_ast::Loc,
     pub stack_ref: Ref,
@@ -9417,8 +9291,7 @@ impl LowerUsingDeclarationsContext {
         stmts: &mut [Stmt],
     ) {
         for stmt in stmts.iter_mut() {
-            // PORT NOTE: Zig `switch (stmt.data) { .s_local => |local| ... }` —
-            // `local` is a `*S.Local`. Match the `StoreRef` by value (Copy ptr)
+            // Match the `StoreRef` by value (Copy ptr)
             // so DerefMut writes through to the arena slot.
             let stmt_loc = stmt.loc;
             let js_ast::StmtData::SLocal(mut local) = stmt.data else {
@@ -9511,8 +9384,8 @@ impl LowerUsingDeclarationsContext {
                 }
                 js_ast::StmtData::SExportClause(data) => {
                     // Merge export clauses together.
-                    // PORT NOTE: ClauseItem isn't `Clone` (POD-only fields, no derive);
-                    // shallow-copy via ptr::read to mirror Zig `appendSlice`.
+                    // ClauseItem isn't `Clone` (POD-only fields, no derive);
+                    // shallow-copy via ptr::read.
                     // arena-owned `StoreSlice<ClauseItem>` valid for 'a; the source
                     // slot is never read again (this whole stmt is dropped via the
                     // `continue` below) — safe to `ptr::read` each item.
@@ -9536,9 +9409,8 @@ impl LowerUsingDeclarationsContext {
                     // If any of these are exported, turn it into a "var" and add export clauses
                     if local.is_export {
                         local.is_export = false;
-                        // PORT NOTE: Zig wrote `local.kind = .k_var` inside the
-                        // decls loop; borrowck rejects that aliasing through
-                        // StoreRef DerefMut. Hoist the kind write below.
+                        // Writing `local.kind` inside the decls loop would alias through
+                        // StoreRef DerefMut; hoist the kind write below.
                         let mut any_ident = false;
                         for decl in local.decls.slice() {
                             if let js_ast::b::B::BIdentifier(identifier) = decl.binding.data {
@@ -9731,7 +9603,6 @@ impl LowerUsingDeclarationsContext {
             },
             loc,
         ));
-        // PERF(port): was assume_capacity
         let catch_binding = p.b(B::Identifier { r#ref: caught_ref }, loc);
         let catch_body: js_ast::StmtNodeList = {
             let err_binding = p.b(B::Identifier { r#ref: err_ref }, loc);
@@ -9800,18 +9671,18 @@ impl LowerUsingDeclarationsContext {
     }
 }
 
-// ─── Helper trait for generate_import_stmt's `symbols: anytype` param ───
-// TODO(port): two call shapes exist (RuntimeImports and a string→Ref map). Impl
-// this for both and verify the alias_name() RuntimeImports special case.
+// ─── Helper trait for generate_import_stmt's generic `symbols` param ───
+// Dispatches the alias lookup via `alias_name()`; implemented
+// for `RuntimeImports` (Key = u8 index) and `JSXImportSymbols` (Key = alias).
 pub trait GenerateImportSymbols {
     type Key;
     fn get(&self, key: &Self::Key) -> Option<Ref>;
     fn alias_name(&self, key: &Self::Key) -> &'static [u8];
 }
 
-// ─── Module-level statics (Zig: `var ... = ...;` at file scope) ───
-// In Zig these were mutable file-level vars used as canonical singletons; in Rust we
-// expose constructor fns since `js_ast::ExprData` has interior pointers and isn't `const`.
+// ─── Module-level constructor fns ───
+// These are fns rather than statics since `js_ast::ExprData` has interior
+// pointers and isn't `const`.
 #[inline]
 pub fn null_expr_data() -> js_ast::ExprData {
     js_ast::ExprData::EMissing(E::Missing {})
@@ -9822,8 +9693,7 @@ pub fn null_stmt_data() -> js_ast::StmtData {
 }
 #[inline]
 pub fn key_expr_data() -> js_ast::ExprData {
-    // PORT NOTE: Zig's `&Prefill.String.Key` was a `*E.String` to a static.
-    // `ExprData::EString` now wraps a `StoreRef<EString>`; allocate a fresh
+    // `ExprData::EString` wraps a `StoreRef<EString>`; allocate a fresh
     // store node from the prefill constant on each call (callers are JSX-only
     // and infrequent — see js_ast::expr::IntoExprData for `EString`).
     use js_ast::expr::IntoExprData as _;
@@ -9837,5 +9707,3 @@ pub fn null_value_expr() -> js_ast::ExprData {
 pub fn false_value_expr() -> js_ast::ExprData {
     js_ast::ExprData::EBoolean(E::Boolean { value: false })
 }
-
-// ported from: src/js_parser/ast/P.zig
diff --git a/src/js_parser/parse/mod.rs b/src/js_parser/parse/mod.rs
index ed05fd408a6..f2203b55cf2 100644
--- a/src/js_parser/parse/mod.rs
+++ b/src/js_parser/parse/mod.rs
@@ -33,12 +33,10 @@ use bun_ast::op::Level;
 use bun_ast::{ArrayBinding, StrictModeKind};
 use bun_ast::{B, Binding, E, Expr, ExprNodeIndex, ExprNodeList, Flags, G, LocRef, S, Stmt};
 
-// Zig: `pub fn Parse(comptime ts, comptime jsx, comptime scan) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
+// File-split mixin: Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`,
+// so this is a direct `impl P` block.
 
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    // Zig: `inline fn parseExprOrBindings(p, level, errors: ?*DeferredErrors, expr: *Expr) !void`
     #[inline]
     pub fn parse_expr_or_bindings(
         &mut self,
@@ -48,14 +46,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     ) -> Result<(), Error> {
         self.parse_expr_common(level, errors, EFlags::None, expr)
     }
-    // Zig: `inline fn parseExpr(p, level) !Expr`
     #[inline]
     pub fn parse_expr(&mut self, level: Level) -> Result<Expr, Error> {
         let mut expr = Expr::EMPTY;
         self.parse_expr_common(level, None, EFlags::None, &mut expr)?;
         Ok(expr)
     }
-    // Zig: `inline fn parseExprWithFlags(p, level, flags, expr: *Expr) !void`
     #[inline]
     pub fn parse_expr_with_flags(
         &mut self,
@@ -79,8 +75,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let had_pure_comment_before =
             self.lexer.has_pure_comment_before && !self.options.ignore_dce_annotations;
         *expr = self.parse_prefix(level, errors.as_deref_mut(), flags)?;
-        // PORT NOTE: reshaped for borrowck — `errors` is reborrowed via as_deref_mut
-        // for each call site instead of Zig's single pointer pass-through.
+        // `errors` is reborrowed via as_deref_mut for each call site.
 
         // There is no formal spec for "__PURE__" comments but from reverse-
         // engineering, it looks like they apply to the next CallExpression or
@@ -199,7 +194,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 continue;
             }
 
-            // PORT NOTE: Zig hoisted `opts` above the loop; it is fully
+            // `opts` is fully
             // reinitialized here every iteration before any read, so declare
             // per-iteration.
             let mut opts = PropertyOpts {
@@ -223,7 +218,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             if let Some(property) =
                 p.parse_property(js_ast::g::PropertyKind::Normal, &mut opts, None)?
             {
-                // PORT NOTE: read fields before move (G::Property is not Copy).
+                // read fields before move (G::Property is not Copy).
                 let prop_kind = property.kind;
                 let prop_key = property.key;
                 properties.push(property);
@@ -343,12 +338,16 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     pub fn parse_call_args(&mut self) -> Result<ExprListLoc, Error> {
-        let p = self;
-        // Allow "in" inside call arguments
-        let old_allow_in = p.allow_in;
-        p.allow_in = true;
-        // TODO(port): errdefer — restore `p.allow_in = old_allow_in` on error path
+        // Allow "in" inside call arguments; restored on every exit path
+        let old_allow_in = self.allow_in;
+        self.allow_in = true;
+        let result = self.parse_call_args_inner();
+        self.allow_in = old_allow_in;
+        result
+    }
 
+    fn parse_call_args_inner(&mut self) -> Result<ExprListLoc, Error> {
+        let p = self;
         let mut args: smallvec::SmallVec<[Expr; 4]> = smallvec::SmallVec::new();
         p.lexer.expect(T::TOpenParen)?;
 
@@ -371,7 +370,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
         let close_paren_loc = p.lexer.loc();
         p.lexer.expect(T::TCloseParen)?;
-        p.allow_in = old_allow_in;
         Ok(ExprListLoc {
             list: ExprNodeList::from_arena_slice(&args),
             loc: close_paren_loc,
@@ -435,7 +433,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.allow_in = true;
 
         // Forbid "await" and "yield", but only for arrow functions
-        // PORT NOTE: Zig saved/restored via toBytes/bytesToValue; clone is equivalent.
         let old_fn_or_arrow_data = p.fn_or_arrow_data_parse.clone();
         p.fn_or_arrow_data_parse.arrow_arg_errors = arrow_arg_errors;
         p.fn_or_arrow_data_parse.track_arrow_arg_errors = true;
@@ -492,7 +489,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             p.lexer.next()?;
         }
         let items: &'a mut [Expr] = items_list.into_bump_slice_mut();
-        // PORT NOTE: Zig kept `items_list` alive and aliased `.items`; bump_slice is equivalent (arena-owned).
 
         // The parenthetical construct must end with a close parenthesis
         p.lexer.expect(T::TCloseParen)?;
@@ -759,9 +755,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 // SAFETY: E::String slices are arena-owned for 'a.
                 return Ok(unsafe { bun_collections::detach_lifetime(estr.slice8()) });
             } else {
-                // PORT NOTE: Zig used toUTF8AllocWithTypeWithoutInvalidSurrogatePairs which
-                // errors on lone surrogates. The Rust port replaces them with U+FFFD; the
-                // surrogate-error diagnostic path is dropped until the strict variant lands.
+                // Lone surrogates are replaced with U+FFFD; the surrogate-error
+                // diagnostic path is dropped until the strict variant lands.
                 let alias_utf8 = strings::to_utf8_alloc_with_type(estr.slice16());
                 let leaked: &'a [u8] = p.arena.alloc_slice_copy(&alias_utf8);
                 return Ok(leaked);
@@ -969,7 +964,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             )),
             ..Default::default()
         };
-        // PORT NOTE: reshaped for borrowck — Zig mutated `result.stmt_or_expr.expr` in place.
         if let js_ast::StmtOrExpr::Expr(ref mut e) = result.stmt_or_expr {
             p.parse_suffix(e, Level::Lowest, None, EFlags::None)?;
         }
@@ -1369,7 +1363,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 let supported_attribute: Option<SupportedAttribute> = 'brk: {
                     // Parse the key
                     if p.lexer.is_identifier_or_keyword() {
-                        // PORT NOTE: Zig used `inline for` over enum values + @tagName.
                         if p.lexer.identifier == b"type" {
                             break 'brk Some(SupportedAttribute::Type);
                         }
@@ -1407,7 +1400,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 if let Some(attr) = supported_attribute {
                     match attr {
                         SupportedAttribute::Type => {
-                            // This logic is duplicated in js_ast.zig fn importRecordTag()
                             let type_attr = string_literal_text;
                             if type_attr == b"macro" {
                                 path.is_macro = true;
@@ -1615,14 +1607,20 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             js_ast::scope::Kind::FunctionArgs,
                             async_range.loc,
                         )?;
-                        // TODO(port): errdefer — `defer p.popScope()` (borrowck blocks scopeguard over &mut p)
 
                         let mut data = FnOrArrowDataParse {
                             allow_await: AwaitOrYield::AllowExpr,
                             needs_async_loc: args[0].binding.loc,
                             ..Default::default()
                         };
-                        let mut arrow_body = p.parse_arrow_body(args, &mut data)?;
+                        // Pop the scope on the error path too.
+                        let mut arrow_body = match p.parse_arrow_body(args, &mut data) {
+                            Ok(body) => body,
+                            Err(e) => {
+                                p.pop_scope();
+                                return Err(e);
+                            }
+                        };
                         arrow_body.is_async = true;
                         p.pop_scope();
                         return Ok(p.new_expr(arrow_body, async_range.loc));
@@ -1688,5 +1686,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         ))
     }
 }
-
-// ported from: src/js_parser/ast/parse.zig
diff --git a/src/js_parser/parse/parse_entry.rs b/src/js_parser/parse/parse_entry.rs
index 8eadde3d0dd..f72795f5d20 100644
--- a/src/js_parser/parse/parse_entry.rs
+++ b/src/js_parser/parse/parse_entry.rs
@@ -21,8 +21,7 @@ use bun_ast as js_ast;
 use bun_ast::DeclaredSymbol;
 use bun_ast::{B, E, Expr, G, S, Stmt, Symbol};
 
-// Named instantiations of `P<'_, TS, SCAN>` matching the Zig
-// `JavaScriptParser`/`TypeScriptParser`/etc. comptime aliases.
+// Named instantiations of `P<'_, TS, SCAN>`.
 pub type JavaScriptParser<'a> = P<'a, false, false>;
 pub type JSXParser<'a> = P<'a, false, false>;
 pub type TypeScriptParser<'a> = P<'a, true, false>;
@@ -35,8 +34,7 @@ pub type TSXImportScanner<'a> = P<'a, true, true>;
 // In AST crates, ListManaged(T) backed by the arena → bumpalo Vec.
 type BumpVec<'bump, T> = bun_alloc::ArenaVec<'bump, T>;
 
-/// Stack-local in-place `P` constructor (Zig: `var p: ParserType = undefined;
-/// try ParserType.init(.., &p)`). `P` is ~5 KiB; the previous
+/// Stack-local in-place `P` constructor. `P` is ~5 KiB; the previous
 /// `let mut p = P::init(..)?` shape forced 2-3 by-value moves of the whole
 /// struct (ASM-verified: `_scan_imports` 14168-B frame, 5× `memcpy`). This
 /// macro reserves an uninitialized slot on the caller's stack, has `P::init`
@@ -61,7 +59,7 @@ macro_rules! init_p {
 pub struct Parser<'a> {
     pub options: Options<'a>,
     pub lexer: js_lexer::Lexer<'a>,
-    /// Raw pointer alias of `lexer.log`. Zig held two `*Log` pointers; Rust
+    /// Raw pointer alias of `lexer.log`. Rust
     /// cannot hold two live `&'a mut Log`, so both the parser- and lexer-side
     /// handles are `NonNull` and dereferenced at use sites (see `log_mut` /
     /// `Lexer::log()`). The pointee outlives `'a` (see `init`).
@@ -116,7 +114,7 @@ pub struct Options<'a> {
 
 impl<'a> Default for Options<'a> {
     fn default() -> Self {
-        // Zig: `macro_context = undefined` — modeled as `None`; caller must set
+        // `macro_context` is `None`; caller must set
         // before use. This impl exists so `_parse` can `core::mem::take` the
         // real options out of `Parser` (moving the heap-owning `jsx: Pragma`
         // by value) instead of bitwise-copying it and double-freeing on drop.
@@ -150,9 +148,8 @@ impl<'a> Default for Options<'a> {
 
 impl<'a> Options<'a> {
     /// Field-by-field clone for the bundler's empty-file fallback
-    /// (ParseTask.zig:335-342: `getEmptyAST(..., opts, ...)` after
-    /// `caches.js.parse(..., opts, ...)` returned null). Zig passed `opts` by
-    /// value (bitwise copy) to *both* calls; in Rust `parse()` consumes `opts`,
+    /// (`getEmptyAST(..., opts, ...)` after `caches.js.parse(..., opts, ...)`
+    /// returned null). `parse()` consumes `opts`,
     /// and `Options` is not `Clone` because `macro_context` is `&'a mut`.
     ///
     /// Co-located with the struct so adding a field is a hard error here —
@@ -242,7 +239,7 @@ impl<'a> Options<'a> {
                 // this holds the values for the jsx optimizaiton flags, which have both been removed
                 // as the optimizations break newer versions of react, see https://github.com/oven-sh/bun/issues/11025
                 let jsx_optimizations: [bool; 2] = [false, false];
-                // `bool: NoUninit`, `u8: AnyBitPattern`; matches Zig `std.mem.asBytes`.
+                // `bool: NoUninit`, `u8: AnyBitPattern`.
                 hasher.update(bytemuck::cast_slice::<bool, u8>(&jsx_optimizations));
             } else {
                 hasher.update(b"NO_JSX");
@@ -269,8 +266,7 @@ impl<'a> Options<'a> {
     }
 
     pub fn init(jsx: options::JSX::Pragma, loader: options::Loader) -> Options<'static> {
-        // Zig left `macro_context` as `undefined` and the rest of the fields at
-        // their declared defaults. Rust models the undefined pointer as `None`
+        // `macro_context` is `None`
         // (see field comment); caller overwrites before use.
         let mut opts = Options {
             ts: loader.is_typescript(),
@@ -286,9 +282,7 @@ impl<'a> Options<'a> {
             bundle: false,
             code_splitting: false,
             package_version: b"",
-            // Zig: `macro_context: *MacroContextType() = undefined` — uninitialized
-            // raw pointer the caller overwrites before any read. In Rust,
-            // materializing an invalid `&mut T` is immediate UB regardless of
+            // Materializing an invalid `&mut T` is immediate UB regardless of
             // use, so model "not yet set" as `None`; callers must assign `Some(_)`
             // before any read site `.unwrap()`s it.
             macro_context: None,
@@ -308,7 +302,7 @@ impl<'a> Options<'a> {
 }
 
 // ── live `Parser::init` ───────────────────────────────────────────────────
-// Zig held two aliasing `*Log` pointers (parser + lexer). Rust models this as
+// The two aliasing `Log` handles (parser + lexer) are modeled as
 // `NonNull<Log>` on both sides — neither stores a long-lived `&mut`, so no
 // Stacked-Borrows tag is invalidated when accesses interleave.
 impl<'a> Parser<'a> {
@@ -346,8 +340,7 @@ impl<'a> Parser<'a> {
 }
 
 // ── live `Parser::parse` / `Parser::scan_imports` symbols ────────────────
-// `parse()` is the real const-generic dispatcher (Zig: `if (ts && jsx.parse)
-// _parse(TSXParser) else …`). `_parse` carries the correct `<const TS, JX>`
+// `parse()` is the real const-generic dispatcher. `_parse` carries the correct `<const TS, JX>`
 // shape but its body is blocked on `P::{init, prepare_for_visit_pass,
 // append_part, to_ast, …}` (gated in P.rs); the full ported body is preserved
 // per-method-gated in the impl block below and replaces this stub once that
@@ -355,7 +348,6 @@ impl<'a> Parser<'a> {
 impl<'a> Parser<'a> {
     #[cfg_attr(not(target_arch = "wasm32"), allow(unused_mut))]
     pub fn parse(mut self) -> Result<crate::Result<'a>, Error> {
-        // TODO(port): narrow error set
         #[cfg(target_arch = "wasm32")]
         {
             self.options.ts = true;
@@ -366,7 +358,7 @@ impl<'a> Parser<'a> {
         // JSX is no longer part of the parser's monomorphization (it only
         // affects a few expr arms — see `parser.rs`); `P::init` reads the
         // transform mode off `options.jsx.parse` at runtime, so the only
-        // remaining comptime split is TypeScript.
+        // remaining compile-time split is TypeScript.
         #[cfg(not(target_arch = "wasm32"))]
         {
             if self.options.ts {
@@ -395,9 +387,7 @@ impl<'a> Parser<'a> {
         scan_pass: &'a mut ScanPassResult,
     ) -> Result<(), Error> {
         type Pi<'a, const TS: bool> = P<'a, TS, true>;
-        // Zig moves lexer/options by value into `P` (Parser.zig) and only
-        // `defer p.lexer.deinit()` cleans up — Zig has no implicit destructor
-        // on `Parser.lexer`. In Rust, `Lexer` owns `Vec`s and `Options` owns
+        // `Lexer` owns `Vec`s and `Options` owns
         // `jsx: Pragma` boxes, so a bitwise `ptr::read` would double-free
         // when `self` later drops. Move them out, leaving inert placeholders.
         //
@@ -417,7 +407,7 @@ impl<'a> Parser<'a> {
         let options = core::mem::take(&mut self.options);
         // `P.log` and `Lexer.log` are both `NonNull<Log>` (see P.rs / lexer.rs
         // field docs), so handing the same raw pointer to both is defined —
-        // matches Zig's two-aliasing-`*Log` model with no `&mut` materialized.
+        // no `&mut` is materialized.
         let mut __p = init_p!(Pi<'_, TS>;
             self.bump, self.log, self.source, self.define, lexer, options);
         // SAFETY: `init_p!` only yields after `init` succeeded.
@@ -488,7 +478,7 @@ impl<'a> Parser<'a> {
                     .set(ImportRecordFlags::IS_UNUSED, new_unused);
             }
 
-            // PORT NOTE: `scan_pass.used_symbols`/`import_records` are still
+            // `scan_pass.used_symbols`/`import_records` are still
             // exclusively borrowed inside `p`; route through `p`'s fields so the
             // borrow checker sees disjoint field access on the same struct.
             let import_records = p.import_records.items_mut();
@@ -511,8 +501,7 @@ impl<'a> Parser<'a> {
         // So we say "did we parse any JSX?"
         // if yes, just automatically add the import so that .bun knows to include the file.
         if p.options.jsx.parse && p.needs_jsx_import {
-            // PORT NOTE: Zig's `string` aliased the long-lived option storage
-            // directly. `add_import_record` requires `&'a [u8]`, but borrowing
+            // `add_import_record` requires `&'a [u8]`, but borrowing
             // `p.options` would conflict with `&mut p`, so copy into the arena.
             let arena = p.arena;
             let import_source: &'a [u8] = arena.alloc_slice_copy(p.options.jsx.import_source());
@@ -542,10 +531,7 @@ impl<'a> Parser<'a> {
         runtime_api_call: &'static [u8],
         symbols: js_ast::symbol::List<'a>,
     ) -> Result<crate::Result<'a>, Error> {
-        // TODO(port): narrow error set
-        // Zig moves lexer/options by value into `P` (Parser.zig) and only
-        // `defer p.lexer.deinit()` cleans up — Zig has no implicit destructor
-        // on `Parser.lexer`. In Rust we move them out and leave inert
+        // Move lexer/options out and leave inert
         // placeholders so `self` may drop without double-free.
         //
         // The placeholder lexer gets its own arena `Log` so it does not alias
@@ -563,7 +549,7 @@ impl<'a> Parser<'a> {
         let options = core::mem::take(&mut self.options);
         // `P.log` and `Lexer.log` are both `NonNull<Log>` (see P.rs / lexer.rs
         // field docs), so handing the same raw pointer to both is defined —
-        // matches Zig's two-aliasing-`*Log` model with no `&mut` materialized.
+        // no `&mut` is materialized.
         let mut __p = init_p!(JavaScriptParser<'_>;
             self.bump, self.log, self.source, self.define, lexer, options);
         // SAFETY: `init_p!` only yields after `init` succeeded.
@@ -578,8 +564,7 @@ impl<'a> Parser<'a> {
         // If we added to `p.symbols` it's going to fuck up all the indices
         // in the `symbols` array.
         debug_assert!(p.symbols.len() == 0);
-        // Zig: `moveToListManaged(arena)` — the buffer is already arena-backed,
-        // so this is now a plain move (matches Zig's pointer re-tag).
+        // The buffer is already arena-backed, so this is a plain move.
         p.symbols = symbols;
 
         p.prepare_for_visit_pass()?;
@@ -609,7 +594,6 @@ impl<'a> Parser<'a> {
             ..Default::default()
         };
         let mut parts = BumpVec::with_capacity_in(2, p.arena);
-        // PERF(port): was appendSliceAssumeCapacity — profile if hot
         parts.push(ns_export_part);
         parts.push(part);
 
@@ -656,7 +640,7 @@ impl<'a> Parser<'a> {
         let options = core::mem::take(&mut self.options);
         // `P.log` and `Lexer.log` are both `NonNull<Log>` (see P.rs / lexer.rs
         // field docs), so handing the same raw pointer to both is defined —
-        // matches Zig's two-aliasing-`*Log` model with no `&mut` materialized.
+        // no `&mut` is materialized.
         let mut __p = init_p!(TSXParser<'_>;
             self.bump, self.log, self.source, self.define, lexer, options);
         // SAFETY: `init_p!` only yields after `init` succeeded.
@@ -695,17 +679,14 @@ impl<'a> Parser<'a> {
 
         parse_tracer.end();
 
-        // Zig spec (Parser.zig:292) reads `self.log.errors`; `p.log` and
+        // `p.log` and
         // `self.log` alias the same `NonNull<Log>` so either is fine — route
         // through `p` for clarity.
         if p.log().errors > 0 {
             #[cfg(target_arch = "wasm32")]
             {
-                // If the logger is backed by console.log, every print appends a newline.
-                // so buffering is kind of mandatory here
-                // TODO(port): Zig builds a custom GenericWriter wrapping Output::print and a
-                // buffered writer over it. Provide a `bun_core::Output::buffered()`
-                // that returns an `impl core::fmt::Write` flushed on drop.
+                // Each message is emitted unbuffered (one console.log line per
+                // write on wasm32). Diagnostics formatting only.
                 for msg in p.log().msgs.as_slice() {
                     let mut m: bun_ast::Msg = *msg;
                     let _ = m.write_format(Output::writer(), true);
@@ -729,16 +710,13 @@ impl<'a> Parser<'a> {
     }
 
     fn _parse<const TS: bool>(self) -> Result<crate::Result<'a>, Error> {
-        // TODO(port): narrow error set
-        // TODO(port): bun_crash_handler::current_action — `Action` stores
-        // `&'static [u8]` but `self.source.path.text` is `'a`; widen
-        // the lifetime on `Action` (Zig held the same pointer). Once unblocked:
-        //   let _restore = bun_crash_handler::scoped_action(Action::Parse(self.source.path.text));
-        // (`ActionGuard` restores the previous action on Drop — no scopeguard.)
-
-        // Zig moves lexer/options by value into `P` (Parser.zig:339) and only
-        // `defer p.lexer.deinit()` cleans up — Zig has no implicit destructor
-        // on `Parser.lexer`. `parse()` consumes `self` by value, so we
+        // `Source.path` is `Path<'static>`, so
+        // `path.text` satisfies `Action::Parse(&'static [u8])` directly.
+        let _action_guard = bun_crash_handler::scoped_action(bun_crash_handler::Action::Parse(
+            self.source.path.text,
+        ));
+
+        // `parse()` consumes `self` by value, so we
         // destructure here and hand the owned `lexer`/`options` straight to
         // `P::init` — no `ptr::read`/`mem::replace` placeholder dance, no
         // double-free hazard.
@@ -756,7 +734,7 @@ impl<'a> Parser<'a> {
         let orig_error_count = lexer.log().errors;
         // `P.log` and `Lexer.log` are both `NonNull<Log>` (see P.rs / lexer.rs
         // field docs), so handing the same raw pointer to both is defined —
-        // matches Zig's two-aliasing-`*Log` model with no `&mut` materialized.
+        // no `&mut` is materialized.
         let mut __p = init_p!(P<'_, TS, false>;
             bump, log, source, define, lexer, options);
         // SAFETY: `init_p!` only yields after `init` succeeded.
@@ -772,13 +750,10 @@ impl<'a> Parser<'a> {
             p.should_fold_typescript_constant_expressions = true;
         }
 
-        // PERF(port): was stack-fallback arena (42 * sizeof(BinaryExpressionVisitor)) — profile if hot
+        // Pre-sized to typical worst-case binary-expression nesting depth.
         p.binary_expression_stack = BumpVec::with_capacity_in(41, p.arena);
-        // PERF(port): was stack-fallback arena (48 * sizeof(BinaryExpressionSimplifyVisitor)) — profile if hot
         p.binary_expression_simplify_stack = BumpVec::with_capacity_in(47, p.arena);
 
-        // (Zig asserted the stack-fallback arena owns the buffer; not applicable here.)
-
         // defer {
         //     if (p.allocated_names_pool) |pool| {
         //         pool.data = p.allocated_names;
@@ -804,13 +779,10 @@ impl<'a> Parser<'a> {
         // We must check the cache only after we've consumed the hashbang and leading // @bun pragma
         // We don't want to ever put files with `// @bun` into this cache, as that would be wasteful.
         #[cfg(not(target_arch = "wasm32"))]
-        if true
-        /* TODO(port): feature_flag */
-        {
+        if bun_core::feature_flags::RUNTIME_TRANSPILER_CACHE {
             if let Some(cache) = p.options.features.runtime_transpiler_cache_mut() {
-                // TODO(port): `Path::is_node_module`/`is_jsx_file` live on the
-                // resolver `fs::Path` (not the logger stub) — inline their
-                // bodies until the logger Path grows them.
+                // `Path::is_node_module`/`is_jsx_file` live on the resolver
+                // `fs::Path` (not the logger stub) — their bodies are inlined here.
                 let path = &p.source.path;
                 #[cfg(windows)]
                 const NM: &[u8] = b"\\node_modules\\";
@@ -872,8 +844,9 @@ impl<'a> Parser<'a> {
             return Err(err!("SyntaxError"));
         }
 
-        // TODO(port): bun_crash_handler::CURRENT_ACTION.set(Action::Visit(self.source.path.text))
-        // — see lifetime note at top of fn.
+        // A second guard dropped at end of `_parse` restores the previous action.
+        let _visit_action_guard =
+            bun_crash_handler::scoped_action(bun_crash_handler::Action::Visit(source.path.text));
 
         let mut visit_tracer = bun_core::perf::trace("JSParser::visit");
         p.prepare_for_visit_pass()?;
@@ -881,8 +854,7 @@ impl<'a> Parser<'a> {
         let mut before = BumpVec::<js_ast::Part>::new_in(p.arena);
         let mut after = BumpVec::<js_ast::Part>::new_in(p.arena);
         let mut parts = BumpVec::<js_ast::Part>::new_in(p.arena);
-        // (defer after.deinit()/before.deinit() — Zig only frees the backing buffer; element
-        // ownership is transferred into `parts` below via bitwise copy + set_len(0).)
+        // (Element ownership is transferred into `parts` below via bitwise copy + set_len(0).)
 
         if p.options.bundle {
             // The bundler requires a part for generated module wrappers. This
@@ -961,12 +933,12 @@ impl<'a> Parser<'a> {
             // The TypeScript compiler itself contains code with this pattern, so
             // it's important to implement this optimization.
 
-            // PORT NOTE: `Loc` lacks `Hash` (logger crate), so the
+            // `Loc` lacks `Hash` (logger crate), so the
             // `scopes_in_order_for_enum` lookups linear-scan `keys()` —
-            // matches Zig's ArrayHashMap linear behaviour at small N (one
+            // fine at small N (one
             // entry per top-level `enum`). `scope_order_to_visit` is
             // `&'a [_]` (a `Copy` cursor) so save/restore is a plain value
-            // copy, mirroring the Zig `[]ScopeOrder` slice value.
+            // copy.
             let arena = p.arena;
             let mut preprocessed_enums: BumpVec<BumpVec<'a, js_ast::Part>> = BumpVec::new_in(arena);
             let mut preprocessed_enum_i: usize = 0;
@@ -980,8 +952,7 @@ impl<'a> Parser<'a> {
                             .iter()
                             .position(|k| *k == stmt.loc)
                             .expect("enum scope-order entry recorded during parse");
-                        // Map stores `&'a [ScopeOrder]` (Zig `[]ScopeOrder` slice
-                        // value); shared borrow may freely alias the inner
+                        // Map stores `&'a [ScopeOrder]`; shared borrow may freely alias the inner
                         // re-lookup performed by `append_part → visit_stmts`.
                         p.scope_order_to_visit = p.scopes_in_order_for_enum.values()[idx];
 
@@ -1001,7 +972,7 @@ impl<'a> Parser<'a> {
                     js_ast::StmtData::SLocal(local) => {
                         if (local.decls.len_u32() as usize) > 1 {
                             for decl in local.decls.slice() {
-                                // PORT NOTE: `S::Local`/`Decl` are not `Copy`;
+                                // `S::Local`/`Decl` are not `Copy`;
                                 // rebuild the struct instead of `**local`.
                                 let _local = S::Local {
                                     kind: local.kind,
@@ -1056,7 +1027,7 @@ impl<'a> Parser<'a> {
                         p.append_part(&mut parts, sliced)?;
 
                         if should_move {
-                            // PORT NOTE: `Part` isn't `Copy`; pop+push instead of last+truncate.
+                            // `Part` isn't `Copy`; pop+push instead of last+truncate.
                             before.push(parts.pop().expect("unreachable"));
                         }
                     }
@@ -1073,7 +1044,7 @@ impl<'a> Parser<'a> {
                         }
                     }
                     js_ast::StmtData::SEnum(_) => {
-                        // PORT NOTE: `Part` isn't `Clone`; move out the
+                        // `Part` isn't `Clone`; move out the
                         // pre-visited parts instead of `appendSlice`.
                         let enum_parts = core::mem::replace(
                             &mut preprocessed_enums[preprocessed_enum_i],
@@ -1149,7 +1120,6 @@ impl<'a> Parser<'a> {
                             bun_ast::Loc::EMPTY,
                         )),
                     };
-                    // PERF(port): was assume_capacity
                     declared_symbols.append_assume_capacity(DeclaredSymbol {
                         ref_: p.dirname_ref,
                         is_top_level: true,
@@ -1222,7 +1192,7 @@ impl<'a> Parser<'a> {
                 let mut remaining_stmts: &mut [Stmt] = all_stmts;
 
                 for i in 0..p.imports_to_convert_from_require.len() {
-                    // PORT NOTE: borrowck — copy out the three Copy fields so the
+                    // borrowck — copy out the three Copy fields so the
                     // immutable borrow of `p.imports_to_convert_from_require`
                     // ends before `p.module_scope_mut()` takes `&mut self`.
                     let (ns_ref, ns_loc, import_record_id) = {
@@ -1259,7 +1229,6 @@ impl<'a> Parser<'a> {
                         ref_: ns_ref,
                         is_top_level: true,
                     });
-                    // PERF(port): was assume_capacity
                     before.push(js_ast::Part {
                         stmts: import_part_stmts.into(),
                         declared_symbols,
@@ -1273,9 +1242,8 @@ impl<'a> Parser<'a> {
             }
 
             if p.commonjs_named_exports.count() > 0 {
-                // PORT NOTE: borrowck — `deoptimize_commonjs_named_exports` mut-borrows
-                // `self`, so the `values()`/`keys()` slices are read once into locals
-                // (Zig kept slice handles across the call).
+                // borrowck — `deoptimize_commonjs_named_exports` mut-borrows
+                // `self`, so the `values()`/`keys()` slices are read once into locals.
                 let export_names_len = p.commonjs_named_exports.keys().len();
                 let first_export_ref_loc = p.commonjs_named_exports.values()[0].loc_ref.loc;
                 let export_refs_len = p.commonjs_named_exports.values().len();
@@ -1492,7 +1460,6 @@ impl<'a> Parser<'a> {
                                                 part.stmts.len() + 1,
                                                 p.arena,
                                             );
-                                            // PERF(port): was appendSliceAssumeCapacity
                                             new_stmts.extend_from_slice(&part_stmts[0..j]);
 
                                             new_stmts.push(Stmt::alloc(
@@ -1547,7 +1514,6 @@ impl<'a> Parser<'a> {
                         }
                     }
                     let _ = &mut *part;
-                    // PORT NOTE: Zig had no explicit continue/break here; loop continues
                     continue 'outer_part_loop;
                 }
             }
@@ -1563,9 +1529,8 @@ impl<'a> Parser<'a> {
             //    export const foo = 123
             //    export * as ns from './foo'
             //
-            if false
-            /* TODO(port): feature_flag — Zig gates with comptime FeatureFlags.export_star_redirect (false) */
-            {
+            // This is permanently disabled (see the circular-export breakage above).
+            if false {
                 // If the file only contains "export * from './blah'
                 // we pretend the file never existed in the first place.
                 // the semantic difference here is in export default statements
@@ -1916,10 +1881,9 @@ impl<'a> Parser<'a> {
             }
 
             // if they didn't use any of the jest globals, don't inject it, I guess.
-            // PORT NOTE: Zig used `inline for (comptime std.meta.fieldNames(Jest))` — comptime
-            // reflection over Jest's Ref fields. Rust iterates the static `Jest::FIELDS`
-            // table (`&[(&'static str, fn(&Jest) -> Ref)]`) instead; declaration order
-            // matches the Zig struct so emitted clause/property order is identical.
+            // Iterates the static `Jest::FIELDS`
+            // table (`&[(&'static str, fn(&Jest) -> Ref)]`); declaration order
+            // determines the emitted clause/property order.
             let items_count: usize = {
                 let mut count: usize = 0;
                 for (_name, get_ref) in Jest::FIELDS {
@@ -2095,10 +2059,10 @@ impl<'a> Parser<'a> {
             });
 
             if i > 0 {
-                // PORT NOTE: snapshot to break the `&mut self` ↔ `&self.runtime_imports`
+                // snapshot to break the `&mut self` ↔ `&self.runtime_imports`
                 // borrow overlap in `generate_import_stmt(symbols: &Sym)`; the callee
                 // never touches `self.runtime_imports`, so the clone is purely a
-                // borrow-checker workaround (Zig passed by value here).
+                // borrow-checker workaround.
                 let symbols = p.runtime_imports.clone();
                 p.generate_import_stmt(
                     RuntimeImports::NAME,
@@ -2118,12 +2082,12 @@ impl<'a> Parser<'a> {
             && p.options.features.auto_import_jsx
             && p.options.jsx.runtime == options::JSX::Runtime::Automatic
         {
-            // PORT NOTE: `generate_import_stmt` takes `&mut self` plus `import_path: &'a [u8]`
+            // `generate_import_stmt` takes `&mut self` plus `import_path: &'a [u8]`
             // and `symbols: &Sym`, so the Pragma-owned `Box<[u8]>` paths are copied into the
             // bump arena (giving them the required `'a` lifetime) and `jsx_imports` is moved
             // out via `take` (it is `Default`) to avoid an overlapping `&self.jsx_imports`
             // borrow. The callee never reads `self.jsx_imports`, so the take/restore is
-            // semantically a no-op vs. the Zig.
+            // semantically a no-op.
             let import_source: &'a [u8] = p.arena.alloc_slice_copy(p.options.jsx.import_source());
             let package_name: &'a [u8] = p.arena.alloc_slice_copy(&p.options.jsx.package_name);
             let jsx_imports = core::mem::take(&mut p.jsx_imports);
@@ -2211,7 +2175,7 @@ impl<'a> Parser<'a> {
         }
 
         if !before.is_empty() || !after.is_empty() {
-            // Single up-front reserve preserves the Zig fused-growth; the inner
+            // Single up-front reserve; the inner
             // reserve() calls in prepend_from / append become no-ops.
             parts.reserve(before.len() + after.len());
             parts.prepend_from(&mut before);
@@ -2222,9 +2186,7 @@ impl<'a> Parser<'a> {
         // p.popScope();
 
         #[cfg(not(target_arch = "wasm32"))]
-        if true
-        /* TODO(port): feature_flag */
-        {
+        if bun_core::feature_flags::RUNTIME_TRANSPILER_CACHE {
             if let Some(cache) = p.options.features.runtime_transpiler_cache_mut() {
                 if p.macro_call_count != 0 {
                     // disable this for:
@@ -2244,7 +2206,7 @@ impl<'a> Parser<'a> {
         )?))
     }
 
-    // PORT NOTE: associated fn (was `&self` reading `self.lexer.source.contents`)
+    // associated fn (was `&self` reading `self.lexer.source.contents`)
     // because `_parse` consumes `self` by value and destructures it before this
     // call site; the source contents are passed explicitly.
     // called from gated `_parse` body above
@@ -2332,5 +2294,3 @@ struct PragmaState {
 pub type MacroContext = Option<*mut c_void>;
 #[cfg(not(target_arch = "wasm32"))]
 pub type MacroContext = crate::Macro::MacroContext;
-
-// ported from: src/js_parser/ast/Parser.zig
diff --git a/src/js_parser/parse/parse_fn.rs b/src/js_parser/parse/parse_fn.rs
index 260d9f8fee1..8f6a0d3bc27 100644
--- a/src/js_parser/parse/parse_fn.rs
+++ b/src/js_parser/parse/parse_fn.rs
@@ -12,16 +12,9 @@ use bun_ast as js_ast;
 use bun_ast::op::Level;
 use bun_ast::{E, Expr, Flags, G, S, Stmt};
 
-// TODO(port): narrow error set
 type Error = bun_core::Error;
 
-// Zig: `pub fn ParseFn(comptime typescript, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    // Zig: `const is_typescript_enabled = P.is_typescript_enabled;`
-    // (PORT NOTE: P.rs already defines `IS_TYPESCRIPT_ENABLED`; reuse it.)
-
     /// This assumes the "function" token has already been parsed
     pub fn parse_fn_stmt(
         &mut self,
@@ -153,7 +146,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
         func.name = name;
 
-        // Zig: func.flags.setPresent(.has_if_scope, hasIfScope) — flags is freshly built so unset → only insert when true
+        // flags is freshly built so unset → only insert when true
         if has_if_scope {
             func.flags.insert(Flags::Function::HasIfScope);
         }
@@ -179,7 +172,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         //     p.markSyntaxFeature(compat.AsyncGenerator, data.asyncRange)
         // }
 
-        // Zig: Flags.Function.init(.{ .has_rest_arg = false, .is_async = ..., .is_generator = ... })
         let mut initial_flags = Flags::FunctionSet::empty();
         if opts.allow_await == AwaitOrYield::AllowExpr {
             initial_flags.insert(Flags::Function::IsAsync);
@@ -198,8 +190,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.lexer.expect(T::TOpenParen)?;
 
         // Await and yield are not allowed in function arguments
-        // PORT NOTE: Zig used `std.mem.toBytes` / `bytesToValue` to save/restore by value;
-        // in Rust `FnOrArrowDataParse` is `Clone`, so a clone is equivalent.
+        // `FnOrArrowDataParse` is `Clone`, so save/restore is a clone.
         let old_fn_or_arrow_data = p.fn_or_arrow_data_parse.clone();
 
         p.fn_or_arrow_data_parse.allow_await = if opts.allow_await == AwaitOrYield::AllowExpr {
@@ -223,7 +214,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let mut rest_arg: bool = false;
         let mut arg_has_decorators: bool = false;
-        // PERF(port): Zig used ArrayListUnmanaged backed by p.arena (arena).
         let mut args = bun_alloc::ArenaVec::<G::Arg>::new_in(p.arena);
         while p.lexer.token != T::TCloseParen {
             // Skip over "this" type annotations
@@ -329,7 +319,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 default_value = Some(p.parse_expr(Level::Comma)?);
             }
 
-            // PERF(port): was appendAssumeCapacity-style (catch unreachable on alloc)
             args.push(G::Arg {
                 ts_decorators,
                 binding: arg,
@@ -381,7 +370,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         p.lexer.expect(T::TCloseParen)?;
-        // PORT NOTE: Zig restored via `std.mem.bytesToValue`; plain copy is equivalent.
         p.fn_or_arrow_data_parse = old_fn_or_arrow_data;
 
         p.fn_or_arrow_data_parse.has_argument_decorators = arg_has_decorators;
@@ -570,25 +558,22 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         let _ = p.push_scope_for_parse_pass(js_ast::scope::Kind::FunctionBody, arrow_loc)?;
-        // PORT NOTE: Zig `defer p.popScope();` — moved to explicit call before each return below.
-        // TODO(port): consider scopeguard if more early-returns are added.
+        // `pop_scope` is called explicitly before each return below.
 
-        // PORT NOTE: Zig used `std.mem.toBytes`/`bytesToValue`; clone is equivalent.
         let old_fn_or_arrow_data = p.fn_or_arrow_data_parse.clone();
 
         p.fn_or_arrow_data_parse = data.clone();
         let expr = match p.parse_expr(Level::Comma) {
             Ok(e) => e,
             Err(err) => {
-                // PORT NOTE: Zig `try` returns here without restoring fn_or_arrow_data_parse;
-                // only the `defer p.popScope()` fires on the error path.
+                // The error path returns without restoring fn_or_arrow_data_parse;
+                // only the scope pop runs.
                 p.pop_scope();
                 return Err(err);
             }
         };
         p.fn_or_arrow_data_parse = old_fn_or_arrow_data;
 
-        // PERF(port): Zig used `p.arena.alloc(Stmt, 1)` (arena bulk-free).
         let ret_stmt = p.s(S::Return { value: Some(expr) }, expr.loc);
         let stmts: &'a mut [Stmt] = p.arena.alloc_slice_copy(&[ret_stmt]);
 
@@ -604,5 +589,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         })
     }
 }
-
-// ported from: src/js_parser/ast/parseFn.zig
diff --git a/src/js_parser/parse/parse_import_export.rs b/src/js_parser/parse/parse_import_export.rs
index 757b4f510f4..13626ffe5c4 100644
--- a/src/js_parser/parse/parse_import_export.rs
+++ b/src/js_parser/parse/parse_import_export.rs
@@ -8,10 +8,6 @@ use bun_ast::op::Level;
 use bun_ast::{ClauseItem, E, Expr, LocRef};
 use bun_core::Error;
 
-// Zig: `fn ParseImportExport(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     /// Note: The caller has already parsed the "import" keyword
     pub fn parse_import_expr(&mut self, loc: bun_ast::Loc, level: Level) -> Result<Expr, Error> {
@@ -73,7 +69,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.allow_in = old_allow_in;
 
         if SCAN_ONLY {
-            // PORT NOTE: reshaped for borrowck — EString::slice takes &mut self (rope flatten),
+            // Reshaped for borrowck — EString::slice takes &mut self (rope flatten),
             // so capture the slice (arena-lifetime) before re-using `value` by-value below.
             let slice_opt: Option<&'a [u8]> = if let ExprData::EString(e_string) = &mut value.data {
                 if e_string.is_utf8() && e_string.is_present() {
@@ -113,13 +109,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn parse_import_clause(&mut self) -> Result<ImportClause<'a>, Error> {
         let p = self;
-        // TODO(port): narrow error set
         let mut items = bun_alloc::ArenaVec::<ClauseItem>::new_in(p.arena);
         p.lexer.expect(T::TOpenBrace)?;
         let mut is_single_line = !p.lexer.has_newline_before;
         // this variable should not exist if we're not in a typescript file
-        // PORT NOTE: in Zig this var was comptime-gated to only exist when TS is enabled;
-        // in Rust we declare it unconditionally — dead-store elim removes it when !TS.
+        // Declared unconditionally — dead-store elim removes it when !TS.
         let mut had_type_only_imports = false;
 
         while p.lexer.token != T::TCloseBrace {
@@ -290,7 +284,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn parse_export_clause(&mut self) -> Result<ExportClauseResult<'a>, Error> {
         let p = self;
-        // TODO(port): narrow error set
         let mut items = bun_alloc::ArenaVec::<ClauseItem>::with_capacity_in(1, p.arena);
         p.lexer.expect(T::TOpenBrace)?;
         let mut is_single_line = !p.lexer.has_newline_before;
@@ -348,7 +341,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                     name,
                                     original_name: original_name.into(),
                                 });
-                                // PERF(port): was assume_capacity (catch unreachable on append)
                             }
                         } else if p.lexer.token != T::TComma && p.lexer.token != T::TCloseBrace {
                             // "export { type as xxx }"
@@ -472,5 +464,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         })
     }
 }
-
-// ported from: src/js_parser/ast/parseImportExport.zig
diff --git a/src/js_parser/parse/parse_jsx.rs b/src/js_parser/parse/parse_jsx.rs
index 15686b1d835..070eb6d13b7 100644
--- a/src/js_parser/parse/parse_jsx.rs
+++ b/src/js_parser/parse/parse_jsx.rs
@@ -9,10 +9,6 @@ use bun_ast::{E, Expr, ExprNodeIndex, ExprNodeList, G};
 use bun_collections::VecExt;
 use bun_core::err;
 
-// Zig: `pub fn ParseJSXElement(comptime ...) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`
-// (sealed trait + ZST), so this becomes a direct `impl` on `P` instead of a wrapper struct.
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     pub fn parse_jsx_element(&mut self, loc: bun_ast::Loc) -> Result<Expr, bun_core::Error> {
         let p = self;
@@ -53,7 +49,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             'parse_attributes: loop {
                 match p.lexer.token {
                     T::TIdentifier => {
-                        // PORT NOTE: `defer i += 1` inlined at each exit point of this arm.
+                        // `i` must be incremented whenever this arm pushes a property.
+                        // The early `continue` for an ignored bare `key` prop
+                        // intentionally skips the increment: no property is pushed there, so
+                        // `key_prop_i`/`first_spread_prop_i` stay valid indices into `props`.
                         // Parse the prop name
                         let key_range = p.lexer.range();
                         let prop_name_literal = p.lexer.identifier;
@@ -104,7 +103,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         i += 1; // defer i += 1
                     }
                     T::TOpenBrace => {
-                        // PORT NOTE: `defer i += 1` inlined at end of this arm.
+                        // This arm must increment `i` once before exiting.
                         // Use Next() not ExpectInsideJSXElement() so we can parse "..."
                         p.lexer.next()?;
 
@@ -332,7 +331,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                         let child = Self::parse_jsx_element(p, less_than_loc)?;
                         children.push(child);
-                        // PERF(port): was `catch unreachable` on append — Vec::push is infallible
 
                         // The call to parseJSXElement() above doesn't consume the last
                         // TGreaterThan because the caller knows what Next() function to call.
@@ -385,5 +383,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 }
-
-// ported from: src/js_parser/ast/parseJSXElement.zig
diff --git a/src/js_parser/parse/parse_prefix.rs b/src/js_parser/parse/parse_prefix.rs
index ac7d6068e5b..0a0a155b012 100644
--- a/src/js_parser/parse/parse_prefix.rs
+++ b/src/js_parser/parse/parse_prefix.rs
@@ -14,13 +14,9 @@ use bun_ast::g::{Arg, PropertyKind};
 use bun_ast::op::Level;
 use bun_ast::{self as js_ast, B, E, Expr, ExprData, ExprNodeList, G, OpCode, scope, symbol};
 
-// TODO(port): narrow error set — Zig used `anyerror!Expr` throughout
 type PResult<T> = core::result::Result<T, bun_core::Error>;
 
-// Zig: `fn ParsePrefix(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block. The 30+ per-token `t_*` helpers are private; only `parse_prefix` is
-// surfaced. Round-G un-gates the per-token bodies (same JsxT pattern as parseStmt.rs); helper
+// The 30+ per-token `t_*` helpers are private; only `parse_prefix` is surfaced. Helper
 // names pfx_-prefixed to avoid colliding with parseStmt.rs / parseSuffix.rs mixins on the same `P`.
 
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
@@ -257,7 +253,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // Handle the start of an arrow expression
         if p.lexer.token == T::TEqualsGreaterThan && level.lte(Level::Assign) {
             let ref_ = p.store_name_in_ref(name).expect("unreachable");
-            // PORT NOTE: reshaped for borrowck — build binding before borrowing arena.
+            // reshaped for borrowck — build binding before borrowing arena.
             // `Arg` is non-Copy (owns Vec) → use fill_iter instead of alloc_slice_copy.
             let binding = p.b(B::Identifier { r#ref: ref_ }, loc);
             let args = p.arena.alloc_slice_fill_iter([Arg {
@@ -268,7 +264,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             let _ = p
                 .push_scope_for_parse_pass(scope::Kind::FunctionArgs, loc)
                 .expect("unreachable");
-            // PORT NOTE: Zig `defer p.popScope()` — reshaped so pop_scope runs before `?` propagates
+            // pop_scope runs before `?` propagates
             let mut fn_or_arrow_data = FnOrArrowDataParse {
                 needs_async_loc: loc,
                 ..Default::default()
@@ -329,8 +325,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let loc = p.lexer.loc();
         p.lexer.scan_reg_exp()?;
         // always set regex_flags_start to null to make sure we don't accidentally use the wrong value later
-        // PORT NOTE: Zig `defer p.lexer.regex_flags_start = null` — reset after both success and
-        // the `next()?` error path. Reshaped: capture, advance, then unconditionally reset before
+        // Reset after both success and
+        // the `next()?` error path: capture, advance, then unconditionally reset before
         // propagating any error from `next()`.
         let value = E::Str::new(p.lexer.raw());
         let next_result = p.lexer.next();
@@ -416,7 +412,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         let mut flags = UnaryFlags::default();
-        // Zig: `value.isPropertyAccess()` — `.e_dot, .e_index => true`.
         if matches!(
             value.data,
             ExprData::EIdentifier(_) | ExprData::EDot(_) | ExprData::EIndex(_)
@@ -653,7 +648,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             )?;
         }
 
-        // PORT NOTE: spec passes the arena-backed `[]ExprNodeIndex` slice directly into
+        // spec passes the arena-backed `[]ExprNodeIndex` slice directly into
         // `ParseClassOptions{.ts_decorators = ts_decorators}`. `ParseClassOptions::ts_decorators`
         // is currently typed `&'a [Expr]` (parser.rs), so until that field is widened to
         // `ExprNodeList` we copy into the arena (Expr is `Copy`) and let `ts_decorators` drop
@@ -697,8 +692,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         // This will become the new expr
-        // PORT NOTE: Zig allocates E::New with undefined fields then fills via the arena
-        // pointer. Reshaped: parse target into a local, then construct E::New once.
+        // Parse target into a local, then construct E::New once.
         let mut target = Expr::EMPTY;
         p.parse_expr_with_flags(Level::Member, flags, &mut target)?;
 
@@ -746,7 +740,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         data: ExprData::EMissing(E::Missing {}),
                         loc: p.lexer.loc(),
                     });
-                    // PERF(port): was assume_capacity (catch unreachable on append)
                 }
                 T::TDotDotDot => {
                     if let Some(e) = errors.as_deref_mut() {
@@ -755,8 +748,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                     let dots_loc = p.lexer.loc();
                     p.lexer.next()?;
-                    // PORT NOTE: reshaped for borrowck — Zig wrote into unusedCapacitySlice()[0]
-                    // then bumped len; here we parse into a local then push.
+                    // Parse into a local then push.
                     let mut value = Expr::EMPTY;
                     p.parse_expr_or_bindings(Level::Comma, Some(&mut self_errors), &mut value)?;
                     items.push(p.new_expr(E::Spread { value }, dots_loc));
@@ -767,7 +759,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     }
                 }
                 _ => {
-                    // PORT NOTE: reshaped for borrowck — Zig wrote into unusedCapacitySlice()[0]
                     let mut item = Expr::EMPTY;
                     p.parse_expr_or_bindings(Level::Comma, Some(&mut self_errors), &mut item)?;
                     items.push(item);
@@ -836,8 +827,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         while p.lexer.token != T::TCloseBrace {
             if p.lexer.token == T::TDotDotDot {
                 p.lexer.next()?;
-                // PORT NOTE: reshaped for borrowck — Zig wrote into unusedCapacitySlice()[0]
-                // with `value: Expr.empty` then parsed into &property.value.?
                 let mut value = Expr::EMPTY;
                 p.parse_expr_or_bindings(Level::Comma, Some(&mut self_errors), &mut value)?;
                 properties.push(G::Property {
@@ -862,7 +851,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         debug_assert!(prop.key.is_some() || prop.value.is_some());
                     }
                     properties.push(prop);
-                    // PERF(port): was assume_capacity (catch unreachable on append)
                 }
             }
 
@@ -899,7 +887,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             self_errors.merge_into(errors.unwrap());
         }
 
-        // PORT NOTE: BumpVec → Vec via arena slice; see pfx_t_open_bracket.
+        // BumpVec → Vec via arena slice; see pfx_t_open_bracket.
         let properties_list = G::PropertyList::from_bump_vec(properties);
         Ok(p.new_expr(
             E::Object {
@@ -956,7 +944,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         //     <A[]>(x)
         //     <A>(x) => {}
         //     <A = B>(x) => {}
-        // PERF(port): was comptime monomorphization
         if Self::IS_TYPESCRIPT_ENABLED && p.is_jsx_enabled() {
             if p.is_ts_arrow_fn_jsx()? {
                 let _ =
@@ -1065,12 +1052,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             T::TNew => Self::pfx_t_new(p, flags),
             T::TSuper => Self::pfx_t_super(p, level),
             _ => {
-                // PERF(port): @branchHint(.cold)
                 p.lexer.unexpected()?;
                 Err(bun_core::err!("SyntaxError"))
             }
         }
     }
 }
-
-// ported from: src/js_parser/ast/parsePrefix.zig
diff --git a/src/js_parser/parse/parse_property.rs b/src/js_parser/parse/parse_property.rs
index 53b79617d0d..20e84693571 100644
--- a/src/js_parser/parse/parse_property.rs
+++ b/src/js_parser/parse/parse_property.rs
@@ -22,10 +22,6 @@ use js_ast::{
 };
 use js_lexer::T;
 
-// Zig: `fn ParseProperty(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     fn parse_method_expression(
         &mut self,
@@ -132,8 +128,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         p.pop_scope();
-        // PORT NOTE: G::Fn is not Copy (FnBody/TS-metadata aren't), so mutate in place via the
-        // E::Function payload after boxing rather than copying `func`.
+        // G::Fn is not Copy (FnBody/TS-metadata aren't), so mutate `func` in place.
         let mut func = func;
         func.flags.insert(flags::Function::IsUniqueFormalParameters);
         let args = func.args.slice();
@@ -260,8 +255,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // This while loop exists to conserve stack space by reducing (but not completely eliminating) recursion.
         'restart: loop {
             // Every match arm below assigns `key` (or `continue 'restart` /
-            // `return`) before any read; Zig's `var key: Expr = undefined` pre-
-            // init is unnecessary here.
+            // `return`) before any read.
             let mut key: Expr;
             let key_range = p.lexer.range();
             let mut is_computed = false;
@@ -524,7 +518,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             p.fn_or_arrow_data_parse = old_fn_or_arrow_data_parse;
                             p.lexer.expect(T::TCloseBrace)?;
 
-                            // PERF(port): was arena arena.create — bump.alloc returns &'a mut T;
                             // Vec::from_slice copies the bump-backed StmtList into a heap-backed list.
                             // TODO(perf): route ClassStaticBlock.stmts through arena slice directly.
                             let stmt_list = bun_alloc::AstVec::<Stmt>::from_slice(stmts.as_slice());
@@ -801,7 +794,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 ..Default::default()
             };
 
-            // PORT NOTE: reshaped for borrowck — `errors` is Option<&mut _>, reborrow via as_deref_mut
+            // `errors` is Option<&mut _>; reborrow via as_deref_mut so the caller's binding stays usable
             p.parse_expr_or_bindings(
                 Level::Comma,
                 errors.as_deref_mut(),
@@ -811,5 +804,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 }
-
-// ported from: src/js_parser/ast/parseProperty.zig
diff --git a/src/js_parser/parse/parse_skip_typescript.rs b/src/js_parser/parse/parse_skip_typescript.rs
index 8a42000f4c1..deace5618db 100644
--- a/src/js_parser/parse/parse_skip_typescript.rs
+++ b/src/js_parser/parse/parse_skip_typescript.rs
@@ -9,12 +9,7 @@ use bun_ast::op::Level;
 use bun_ast::ts::Metadata;
 use bun_core::{self, Error, err};
 
-// Zig: `fn SkipTypescript(comptime ts, comptime jsx, comptime scan_only) type { return struct {...} }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
-
-// PORT NOTE: Zig nested `Bitset` inside `SkipTypeOptions`; Rust hoists it to a module-level
-// alias. Re-export here so the parser-side type alias used in this file matches the
+// Re-export so the parser-side type alias used in this file matches the
 // canonical definition in `TypeScript.rs`.
 pub(crate) type SkipTypeOptionsBitset = typescript::SkipTypeOptionsBitset;
 
@@ -229,7 +224,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(())
     }
 
-    // PORT NOTE: Zig signature is `result: if (get_metadata) *TypeScript.Metadata else void`.
     // Rust cannot express a const-generic-dependent param type on stable; we use
     // `Option<&mut Metadata>` and require callers to pass `Some` iff `GET_METADATA == true`.
     // The const generic is kept so `if GET_METADATA { ... }` branches monomorphize away.
@@ -884,8 +878,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     }
 
                     if GET_METADATA {
-                        // PORT NOTE: reshaped for borrowck — `find_symbol` borrows `&mut self`;
-                        // `result` is a disjoint fn parameter so the borrows do not conflict.
+                        // `find_symbol` borrows `&mut self`; `result` is a disjoint fn
+                        // parameter so the borrows do not conflict.
                         let ident = self.lexer.identifier;
                         let r = result
                             .as_deref_mut()
@@ -1408,10 +1402,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     // ───────────────────────── Backtracking ─────────────────────────
-    // Zig defines `pub const Backtracking = struct { ... }` with comptime-reflective
-    // `lexerBacktracker` / `lexerBacktrackerWithArgs` that branch on `bun.meta.ReturnOf(func)`.
-    // Rust cannot inspect a closure's return type at compile time, so we split into two
-    // concrete helpers covering the actual call patterns:
+    // Two concrete helpers covering the actual call patterns:
     //   - `lexer_backtracker_bool`   — fn returns Result<()>/Result<bool>, helper returns bool
     //   - `lexer_backtracker_result` — fn returns Result<SkipTypeParameterResult>
 
@@ -1421,8 +1412,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         F: FnOnce(&mut Self) -> Result<R, Error>,
     {
         self.mark_type_script_only();
-        // PORT NOTE: Zig copies the lexer by value; Rust Lexer holds `&mut Log` so we use a
-        // POD `LexerSnapshot` and `restore()`.
+        // The Lexer
+        // holds `&mut Log`, so backtracking goes through a POD `LexerSnapshot` + `restore()`.
         let old_lexer = self.lexer.snapshot();
         let old_log_disabled = self.lexer.is_log_disabled;
         self.lexer.is_log_disabled = true;
@@ -1439,9 +1430,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
         self.lexer.is_log_disabled = old_log_disabled;
 
-        // Covers both Zig branches:
-        //   FnReturnType == anyerror!bool  → !backtrack
-        //   ReturnType == bool/void        → !backtrack
         !backtrack
     }
 
@@ -1595,5 +1583,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         skipped
     }
 }
-
-// ported from: src/js_parser/ast/skipTypescript.zig
diff --git a/src/js_parser/parse/parse_stmt.rs b/src/js_parser/parse/parse_stmt.rs
index f564c83b437..205fdce7557 100644
--- a/src/js_parser/parse/parse_stmt.rs
+++ b/src/js_parser/parse/parse_stmt.rs
@@ -20,17 +20,12 @@ use crate::typescript;
 use bun_ast::{ImportKind, ImportRecordFlags, ImportRecordTag};
 use js_ast::expr::EFlags;
 
-// TODO(port): narrow error set
 type Result<T> = core::result::Result<T, bun_core::Error>;
 
-// Zig: `pub fn ParseStmt(comptime ts, comptime jsx, comptime scan_only) type { return struct {...} }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block. The 25+ per-token `t_*` helpers are private; only `parse_stmt` is
-// surfaced. Round-G un-gated the simpler `t_*` bodies; phase-d ported the remaining
-// `t_export`/`t_import`/fallthrough bodies inline (the `_draft_heavy` staging mod is gone).
+// The 25+ per-token `t_*` helpers are private; only `parse_stmt` is surfaced.
 
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    // PORT NOTE on `#[inline]` / `#[inline(never)]` / `#[cold]` annotations across the `t_*` arms:
+    // Note on `#[inline]` / `#[inline(never)]` / `#[cold]` annotations across the `t_*` arms:
     // `parse_stmt` is invoked once per leading statement token; profiling showed its
     // stack-adjust prologue/epilogue dominating because LLVM was hoisting the larger
     // (and rarely-taken) `t_*` bodies inline, ballooning `parse_stmt`'s frame. Keep the
@@ -95,7 +90,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             //   "@decorator export declare class Foo {}"
             //   "@decorator export declare abstract class Foo {}"
             //
-            // PORT NOTE: spec stores the Vec<Expr> directly into `opts.ts_decorators.values`.
+            // spec stores the Vec<Expr> directly into `opts.ts_decorators.values`.
             // `DeferredTsDecorators::values` is currently typed `&'a [Expr]` (parser.rs), so until
             // that field is widened to `ExprNodeList` we copy into the arena (Expr is `Copy`) and
             // let `ts_decorators` drop normally — no `mem::forget` / `from_raw_parts` lifetime
@@ -204,7 +199,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     fn t_if(p: &mut Self, _: &mut ParseStatementOptions, loc: bun_ast::Loc) -> Result<Stmt> {
         let mut current_loc = loc;
         let mut root_if: Option<Stmt> = None;
-        // PORT NOTE: `StoreRef` (arena back-pointer with safe `Deref`/`DerefMut`)
+        // `StoreRef` (arena back-pointer with safe `Deref`/`DerefMut`)
         // into the previous iteration's `S::If` allocation — borrowck cannot
         // express the cross-iteration back-reference, but the arena keeps every
         // node alive for `'a`.
@@ -343,7 +338,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let body_loc = p.lexer.loc();
         let _ = p.push_scope_for_parse_pass(js_ast::scope::Kind::Block, body_loc)?;
-        // Zig: `defer p.popScope()`. Wrap the body in an inner closure so `pop_scope` runs once on
+        // Wrap the body in an inner closure so `pop_scope` runs once on
         // its `Result`, covering every `?` early-exit as well as explicit returns.
         let result: Result<Stmt> = (|| {
             p.lexer.expect(T::TOpenBrace)?;
@@ -351,8 +346,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             let mut found_default = false;
             while p.lexer.token != T::TCloseBrace {
                 let mut body = StmtList::new_in(p.arena);
-                // PORT NOTE: Zig hoisted `value`/`stmt_opts` above the loop;
-                // both are reinitialized every iteration before any read, so
+                // `value`/`stmt_opts` are reinitialized every iteration before any read, so
                 // declare per-iteration.
                 let mut value: Option<js_ast::Expr> = None;
                 if p.lexer.token == T::TDefault {
@@ -494,7 +488,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     #[inline(never)]
     fn t_for(p: &mut Self, _: &mut ParseStatementOptions, loc: bun_ast::Loc) -> Result<Stmt> {
         let _ = p.push_scope_for_parse_pass(js_ast::scope::Kind::Block, loc)?;
-        // Zig: `defer p.popScope()`. Wrap the body in an inner closure so `pop_scope` runs once on
+        // Wrap the body in an inner closure so `pop_scope` runs once on
         // its `Result`, covering every `?` early-exit as well as explicit returns.
         let result: Result<Stmt> = (|| {
             p.lexer.next()?;
@@ -777,7 +771,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         loc: bun_ast::Loc,
     ) -> Result<Stmt> {
         let _ = p.push_scope_for_parse_pass(js_ast::scope::Kind::Block, loc)?;
-        // Zig: `defer p.popScope()`. Wrap the body in an inner closure so `pop_scope` runs once on
+        // Wrap the body in an inner closure so `pop_scope` runs once on
         // its `Result`, covering every `?` early-exit.
         let result: Result<Stmt> = (|| {
             p.lexer.next()?;
@@ -1192,8 +1186,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     // "export * from 'path'"
                     p.lexer.expect_contextual_keyword(b"from")?;
                     path = p.parse_path()?;
-                    // Zig: `fs.PathName.init(path.text).nonUniqueNameString(arena)` —
-                    // sanitize the basename into an identifier and copy into the arena.
+                    // Sanitize the basename into an identifier and copy into the arena.
                     let name: &'a [u8] = {
                         use std::io::Write as _;
                         let base = fs::PathName::init(path.text).non_unique_name_string_base();
@@ -1287,7 +1280,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     let import_record_index =
                         p.add_import_record(ImportKind::Stmt, parsed_path.loc, parsed_path.text);
                     let path_name = fs::PathName::init(parsed_path.text);
-                    // PERF(port): was arena allocPrint — profile if hot.
                     let namespace_ref = {
                         use std::io::Write as _;
                         let mut buf: Vec<u8> = Vec::new();
@@ -1645,8 +1637,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         label_ref: Ref,
     ) -> Result<Stmt> {
         let _ = p.push_scope_for_parse_pass(js_ast::scope::Kind::Label, loc)?;
-        // Zig: `defer p.popScope();` — pop after parsing the labeled body.
-        // Hand-roll the defer so we can keep `p` exclusively borrowed.
+        // Pop after parsing the labeled body; done explicitly so we can keep
+        // `p` exclusively borrowed.
 
         // Parse a labeled statement
         p.lexer.next()?;
@@ -1895,13 +1887,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
     pub fn parse_stmt(&mut self, opts: &mut ParseStatementOptions<'a>) -> Result<Stmt> {
         if !self.stack_check.is_safe_to_recurse() {
-            // TODO(port): bun_core::throw_stack_overflow() not yet exported; map to a SyntaxError
-            // until the StackOverflow error variant lands.
+            // Sentinel error; mapped to a "Maximum call stack size exceeded"
+            // syntax error at the catch site in parse_entry.rs.
             return Err(err!("StackOverflow"));
         }
 
-        // Zig used `inline ... => |function| @field(@This(), @tagName(function))(...)` to dispatch
-        // by token name via comptime reflection. Rust has no `@field`/`@tagName`; expand the arms.
         let loc = self.lexer.loc();
         match self.lexer.token {
             T::TSemicolon => Self::t_semicolon(self),
diff --git a/src/js_parser/parse/parse_suffix.rs b/src/js_parser/parse/parse_suffix.rs
index 7a000d8b23b..d199e429c53 100644
--- a/src/js_parser/parse/parse_suffix.rs
+++ b/src/js_parser/parse/parse_suffix.rs
@@ -10,10 +10,7 @@ use bun_ast::expr::EFlags;
 use bun_ast::op::Level;
 use bun_ast::{E, Expr, ExprData, OpCode, OptionalChain};
 
-// Zig: `fn ParseSuffix(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block. The 50+ per-token `t_*` helpers are private; only `parse_suffix` is
-// surfaced. Round-G un-gates the per-token bodies (same JsxT pattern as parseStmt.rs).
+// The 50+ per-token `t_*` helpers are private; only `parse_suffix` is surfaced.
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Continuation {
@@ -100,8 +97,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 p.lexer.expect(T::TIdentifier)?;
             }
 
-            // TODO(port): `E::Dot::name` is `&'static [u8]` (arena-owned slice
-            // placeholder); lexer hands back `&'a [u8]`.
+            // `E::Dot::name` is spelled `&'static [u8]` but actually holds an
+            // arena-owned slice; the lexer hands back `&'a [u8]`.
             let name = E::Str::new(p.lexer.identifier);
             let name_loc = p.lexer.loc();
             p.lexer.next()?;
@@ -431,9 +428,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         let loc = left.loc;
         let prev = *left;
-        // PORT NOTE: Zig allocates an E::If with `undefined` yes/no then writes through the
-        // arena pointer (`ternary.data.e_if.yes`). The `Data::EIf(StoreRef<E::If>)` payload is a
-        // boxed arena slot, so we mirror that: allocate first, then fill via DerefMut on StoreRef.
+        // The `Data::EIf(StoreRef<E::If>)` payload is a
+        // boxed arena slot: allocate first, then fill via DerefMut on StoreRef.
         let ternary = p.new_expr(
             E::If {
                 test_: prev,
@@ -550,9 +546,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(Continuation::Next)
     }
 
-    // Zig used `inline` @field/@tagName comptime dispatch for the 30+ simple binary
-    // operators below. Rust has no struct-field-name reflection; each is written out.
-    // PORT NOTE: bodies are uniform — `if level.gte(L) {Done}; next; new Binary{op,left,right}`.
+    // The 30+ simple binary operators below have uniform
+    // bodies — `if level.gte(L) {Done}; next; new Binary{op,left,right}`.
 
     fn sfx_t_plus(p: &mut Self, level: Level, left: &mut Expr) -> CResult {
         if level.gte(Level::Add) {
@@ -580,7 +575,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.lexer.next()?;
         let loc = left.loc;
         let prev = *left;
-        // PORT NOTE: Zig wrote `@enumFromInt(@intFromEnum(Op.Level.assign) - 1)`; equivalent to `Level::Assign.sub(1)`.
         let right = p.parse_expr(Level::Assign.sub(1))?;
         *left = p.new_expr(
             E::Binary {
@@ -1442,16 +1436,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         flags: EFlags,
     ) -> Result<(), Error> {
         let p = self;
-        // PORT NOTE: Zig kept a separate `left_value` local + `left = &left_value`
-        // to work around a Zig codegen bug ("creates a new address to stack locals
-        // each & usage"). Rust has no such bug, so we mutate `left` directly and
-        // drop the trailing/deferred `left_and_out.* = left_value` writebacks.
 
         let mut optional_chain: Option<OptionalChain> = None;
         loop {
             if p.lexer.loc().start == p.after_arrow_body_loc.start {
-                // PORT NOTE: Zig labeled-switch `next_token: switch (...) { continue :next_token ... }`
-                // becomes a plain loop re-reading `p.lexer.token` each iteration.
+                // Plain loop re-reading `p.lexer.token` each iteration.
                 loop {
                     match p.lexer.token {
                         T::TComma => {
@@ -1496,14 +1485,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             optional_chain = None;
 
             // Each of these tokens are split into a function to conserve
-            // stack space. Currently in Zig, the compiler does not reuse
-            // stack space between scopes This means that having a large
-            // function with many scopes and local variables consumes
-            // enormous amounts of stack space.
-            //
-            // PORT NOTE: Zig used `inline ... => |tag| @field(@This(), @tagName(tag))(p, level, left)`
-            // for comptime name-based dispatch. Rust has no @field/@tagName reflection, so each
-            // arm is written out explicitly.
+            // stack space.
             let continuation = match p.lexer.token {
                 T::TAmpersand => Self::sfx_t_ampersand(p, level, left),
                 T::TAmpersandAmpersandEquals => {
@@ -1611,5 +1593,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(())
     }
 }
-
-// ported from: src/js_parser/ast/parseSuffix.zig
diff --git a/src/js_parser/parse/parse_typescript.rs b/src/js_parser/parse/parse_typescript.rs
index a766177d7c4..35a9c4290b6 100644
--- a/src/js_parser/parse/parse_typescript.rs
+++ b/src/js_parser/parse/parse_typescript.rs
@@ -31,12 +31,7 @@ fn clone_ts_member_data(d: &TSNamespaceMemberData) -> TSNamespaceMemberData {
     }
 }
 
-// Zig: `pub fn ParseTypescript(comptime ...) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
-    // TODO(port): narrow error set
     pub fn parse_type_script_decorators(&mut self) -> Result<ExprNodeList, Error> {
         let p = self;
         if !Self::IS_TYPESCRIPT_ENABLED && !p.options.features.standard_decorators {
@@ -53,7 +48,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 //   @Identifier.member
                 //   @Identifier.member(args)
                 //   @(Expression)
-                // PERF(port): was ensureUnusedCapacity + unusedCapacitySlice — profile if it shows up on a hot path
                 decorators.push(p.parse_standard_decorator()?);
             } else {
                 // Parse a new/call expression with "exprFlagTSDecorator" so we ignore
@@ -64,8 +58,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 //   }
                 //
                 // This matches the behavior of the TypeScript compiler.
-                // PERF(port): was ensureUnusedCapacity + unusedCapacitySlice — profile if it shows up on a hot path
-                // PORT NOTE: Zig `parseExprWithFlags` takes an out-param slot; preserved here.
                 let mut expr = Expr::EMPTY;
                 p.parse_expr_with_flags(Level::New, EFlags::TsDecorator, &mut expr)?;
                 decorators.push(expr);
@@ -82,7 +74,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     ///   @ DecoratorMemberExpression
     ///   @ DecoratorCallExpression
     ///   @ DecoratorParenthesizedExpression
-    // TODO(port): narrow error set
     pub fn parse_standard_decorator(&mut self) -> Result<ExprNodeIndex, Error> {
         let p = self;
         let loc = p.lexer.loc();
@@ -187,7 +178,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.lexer.next()?;
 
         // Generate the namespace object
-        // Arena-owned `StoreRef<TSNamespaceScope>` (Zig held a pointer into the arena).
+        // Arena-owned `StoreRef<TSNamespaceScope>`.
         let mut ts_namespace: js_ast::StoreRef<js_ast::TSNamespaceScope> =
             p.get_or_create_exported_namespace_members(name_text, opts.is_export, false);
         let mut exported_members: js_ast::StoreRef<TSNamespaceMemberMap> =
@@ -279,7 +270,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             .insert(ref_, TSNamespaceMemberData::Property);
                     }
                 }
-                // Zig: `inline .s_namespace, .s_enum => |ns|` — written out per-variant.
                 StmtData::SNamespace(ns) => {
                     if ns.is_export {
                         let ref_ = ns.name.ref_.expect("infallible: ref bound");
@@ -397,7 +387,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 //
                 //   namespace m { class m {} class _m {} }
                 //
-                // Candidates are built in the parse arena (Zig: `p.allocator`); the
+                // Candidates are built in the parse arena; the
                 // chosen one becomes the symbol's original name and is freed together
                 // with the rest of the AST arena.
                 let mut underscores: usize = 1;
@@ -431,7 +421,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .insert(name.ref_.expect("infallible: ref bound"), ns_member_data);
         }
 
-        // PORT NOTE: S::Namespace.stmts is `StoreSlice<Stmt>` (arena slice). BumpVec → bump slice.
+        // S::Namespace.stmts is `StoreSlice<Stmt>` (arena slice). BumpVec → bump slice.
         let stmts_slice: &'a mut [Stmt] = stmts.into_bump_slice_mut();
         Ok(p.s(
             S::Namespace {
@@ -522,7 +512,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let ref_ = p
             .declare_symbol(SymbolKind::Constant, default_name_loc, default_name)
             .expect("unreachable");
-        // PERF(port): was `arena.alloc(Decl, 1)` into arena slice — profile if it shows up on a hot path
         let binding = p.b(B::Identifier { r#ref: ref_ }, default_name_loc);
         let decls = G::DeclList::init_one(G::Decl {
             binding,
@@ -568,7 +557,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             name.ref_ = Some(p.declare_symbol(SymbolKind::TsEnum, name_loc, name_text)?);
             let _ = p.push_scope_for_parse_pass(ScopeKind::Entry, loc)?;
             p.current_scope_mut().ts_namespace = Some(ts_namespace);
-            // Zig: putNoClobber — debug-assert no prior entry.
+            // debug-assert no prior entry.
             let prev = p.ref_to_ts_namespace_member.insert(
                 name.ref_.expect("infallible: ref bound"),
                 TSNamespaceMemberData::Namespace(exported_members),
@@ -592,7 +581,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
             // Parse the name
             if p.lexer.token == T::TStringLiteral {
-                // PORT NOTE: `slice8()` is currently duplicated in E.rs (two impl blocks);
+                // `slice8()` is currently duplicated in E.rs (two impl blocks);
                 // read `.data` directly — `to_utf8_e_string` guarantees `is_utf16 == false`.
                 let estr = p.lexer.to_utf8_e_string()?;
                 debug_assert!(!estr.is_utf16);
@@ -672,8 +661,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 // Add a "_" to make tests easier to read, since non-bundler tests don't
                 // run the renamer. For external-facing things the renamer will avoid
                 // collisions automatically so this isn't important for correctness.
-                // PERF(port): strings::cat heap-allocates; Zig allocated into p.arena.
-                // TODO(perf): route through bump arena.
+                // PERF: strings::cat heap-allocates — could allocate into p.arena.
                 let prefixed = strings::cat(b"_", name_text).expect("unreachable");
                 let prefixed: &'a [u8] = p.arena.alloc_slice_copy(&prefixed);
                 arg_ref = p
@@ -723,7 +711,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
             break 'scope_order_clone items.into_bump_slice();
         };
-        // Zig: putNoClobber — debug-assert no prior entry.
+        // debug-assert no prior entry.
         // Stored as `&'a [ScopeOrder]`; the visit pass only reads these, so
         // `scope_order_to_visit` may alias the same arena slice freely.
         let prev = p.scopes_in_order_for_enum.insert(loc, scope_order_clone);
@@ -740,5 +728,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         ))
     }
 }
-
-// ported from: src/js_parser/ast/parseTypescript.zig
diff --git a/src/js_parser/parser.rs b/src/js_parser/parser.rs
index f6b33a185f4..03ea05b12e6 100644
--- a/src/js_parser/parser.rs
+++ b/src/js_parser/parser.rs
@@ -5,12 +5,11 @@
 
 use bun_ast::ImportRecord;
 use bun_collections::{ArrayHashMap, HashMap, StringArrayHashMap, StringHashMap};
-// Zig `std.hash.Wyhash` (final4 variant) — used by `hash_for_runtime_transpiler`
-// (runtime.zig:272) and `ReactRefresh.HookContext` (parser.zig:1140). NOT
-// interchangeable with `bun_wyhash::Wyhash11`.
+// `bun_wyhash::Wyhash` (wyhash final-4) — used by `hash_for_runtime_transpiler`
+// and `ReactRefresh.HookContext`. NOT interchangeable with `bun_wyhash::Wyhash11`.
 use bun_wyhash::Wyhash;
 
-// Re-exports (mirrors the Zig `pub const X = @import(...)` block at the bottom).
+// Re-exports.
 // Round-C: stub the still-gated submodules so the helper *types* in this file
 // compile; the real bodies arrive in rounds D/E.
 #[allow(non_snake_case)]
@@ -30,14 +29,12 @@ pub mod options {
     // re-exported here so the `options::Loader`/`options::Target` spelling used
     // throughout `P.rs`/`Parser.rs` keeps resolving without per-site churn.
     pub(crate) use bun_ast::Loader;
-    // TODO(port): bun_options_types::{ServerComponents, OutputFormat,
-    // AllowUnresolved, Format, Framework} — missing from lower-tier surface.
     pub use bun_options_types::bundle_enums::ModuleType;
     // D042: canonical `JSX::{Pragma, Runtime, ImportSource, Defaults, ...}`
     // lives in `bun_options_types::jsx`. The glob above already brings in
     // `jsx`/`JSX`; explicit re-export keeps the path stable for callers.
-    /// Zig: `bundler/options.zig` `ServerComponents` — same enum surface as
-    /// `Runtime.Features.ServerComponentsMode`. Aliased so call sites that
+    /// Same enum surface as `Runtime.Features.ServerComponentsMode`.
+    /// Aliased so call sites that
     /// spell it as either `options::ServerComponents` (P.rs) or
     /// `RuntimeFeatures.server_components` resolve to one type.
     pub(crate) use crate::parser::Runtime::ServerComponentsMode as ServerComponents;
@@ -53,9 +50,6 @@ pub mod options {
         Iife,
         Internal_BakeDev,
     }
-    /// Port of `options_types/BundleEnums.zig` `Format` (spec for
-    /// `Parser.Options.output_format`). Variants and order match spec exactly;
-    /// Zig's first variant `.esm` is the `#[default]`.
     #[derive(Clone, Copy, Default, PartialEq, Eq)]
     pub enum Format {
         #[default]
@@ -74,8 +68,6 @@ pub mod options {
             matches!(self, Format::Cjs)
         }
     }
-    /// Port of `bundler/options.zig` `AllowUnresolved`.
-    ///
     /// Canonical home is here (the parser is the consumer
     /// — `P::should_allow_unresolved_dynamic_specifier`). `bun_bundler::options`
     /// re-exports this so `BundleOptions.allow_unresolved` and
@@ -100,8 +92,7 @@ pub mod options {
         Patterns(Box<[Box<[u8]>]>, AllowUnresolvedMatcher),
     }
     impl AllowUnresolved {
-        // Zig: `pub const default: AllowUnresolved = .all;` — taken by address
-        // from `Options::init` (`&options::AllowUnresolved::DEFAULT`); rvalue
+        // Taken by address from `Options::init` (`&options::AllowUnresolved::DEFAULT`); rvalue
         // static promotion gives the borrow `'static` lifetime.
         pub const DEFAULT: AllowUnresolved = AllowUnresolved::All;
 
@@ -142,14 +133,13 @@ pub mod options {
     /// Port of `bake.Framework` (src/runtime/bake/mod.rs:129) — TYPE_ONLY
     /// parser-side mirror. The full struct lives in `bun_runtime::bake` (a
     /// higher tier we cannot depend on here); the parser only consumes the
-    /// two nested option fields below (see `Parser._parse`, Parser.zig:1415
-    /// and Parser.zig:1433), so `file_system_router_types`/`built_in_modules`
+    /// two nested option fields below (see `Parser._parse`),
+    /// so `file_system_router_types`/`built_in_modules`
     /// are intentionally elided.
     ///
-    /// String fields are `Cow<'static, [u8]>` to match the spec at
-    /// `bake/mod.rs` (the Zig backs them with arena-owned `[]const u8` that
-    /// is user-configured via `fromJS` and rewritten by `Framework.resolve`,
-    /// then freed in `UserOptions.deinit`). The parser only *borrows* them
+    /// String fields are `Cow<'static, [u8]>` to match `bake/mod.rs`
+    /// (they are user-configured via `fromJS`, rewritten by
+    /// `Framework.resolve`, and freed on teardown). The parser only *borrows* them
     /// for `'a` (parse lifetime), not `'static`, so `&'static [u8]` would
     /// wrongly restrict callers to literal defaults — see PORTING.md
     /// §Forbidden re: `&'static [T]` for arena-freed data.
@@ -159,16 +149,14 @@ pub mod options {
         pub server_components: Option<FrameworkServerComponents>,
         pub react_fast_refresh: Option<ReactFastRefresh>,
     }
-    /// Port of `bake.Framework.ServerComponents` (bake/mod.rs:69). Named
+    /// Mirror of `bake.Framework.ServerComponents` (bake/mod.rs:69). Named
     /// `FrameworkServerComponents` here because `options::ServerComponents`
     /// is already the `Runtime.Features.ServerComponentsMode` enum alias
-    /// (see re-export above) — both names exist in the Zig source under
-    /// different paths (`bundler/options.ServerComponents` vs
-    /// `bake.Framework.ServerComponents`).
+    /// (see re-export above).
     #[derive(Clone)]
     pub struct FrameworkServerComponents {
         pub separate_ssr_graph: bool,
-        /// REQUIRED — spec (bake.zig:360) gives no default; `fromJS` throws
+        /// REQUIRED — no default; `fromJS` throws
         /// if `serverRuntimeImportSource` is absent.
         pub server_runtime_import: Cow<'static, [u8]>,
         pub server_register_client_reference: Cow<'static, [u8]>,
@@ -275,7 +263,7 @@ pub mod Runtime {
         /// This is used for `--print` entry points so we can get the result.
         pub remove_cjs_module_wrapper: bool,
 
-        // PORT NOTE: `?*bun.jsc.RuntimeTranspilerCache` — raw `*mut` (not `&'a mut`)
+        // `?*bun.jsc.RuntimeTranspilerCache` — raw `*mut` (not `&'a mut`)
         // so `Features` stays `'static`-bounded inside `Parser::Options` and avoids
         // the borrowck self-borrow that `&'a mut` would induce while `P` holds
         // `&mut Options`.
@@ -287,10 +275,8 @@ pub mod Runtime {
         /// Feature flags for dead-code elimination via `import { feature } from "bun:bundle"`
         /// When `feature("FLAG_NAME")` is called, it returns true if FLAG_NAME is in this set.
         ///
-        /// Zig `bundler_feature_flags: *const bun.StringSet = &empty_bundler_feature_flags`.
         /// `None` ≡ the empty static set (contributes nothing to the hash).
-        /// Owned `Box` (not `&'static`) per PORTING.md §Forbidden — the Zig
-        /// caller frees it on `BundleOptions` teardown, so Rust must too;
+        /// Owned `Box` (not `&'static`) — freed on `BundleOptions` teardown.
         /// Leaking to satisfy a `&'static` would be an unbounded leak
         /// in watch/dev-server mode.
         pub bundler_feature_flags: Option<Box<StringSet>>,
@@ -302,7 +288,7 @@ pub mod Runtime {
         /// - Assigns functions to context for persistence
         pub repl_mode: bool,
 
-        // ── Vestigial bool stubs not present in Zig `Runtime.Features`. ──────────
+        // ── Vestigial bool stubs. ─────────────────────────────────────────────
         // Retained until their last reader (parseJSXElement.rs et al.) is ported to
         // the real predicate; they default false and are otherwise inert.
         pub jsx_optimization_inline: bool,
@@ -366,8 +352,7 @@ pub mod Runtime {
         pub fn runtime_transpiler_cache_mut(&self) -> Option<&mut RuntimeTranspilerCache> {
             // SAFETY: `runtime_transpiler_cache` is `Option<*mut _>` (see PORT
             // NOTE on the field) — the caller that populated it guarantees the
-            // pointee is unique to this parse and outlives `Features`; Zig held
-            // `*RuntimeTranspilerCache` and mutated freely.
+            // pointee is unique to this parse and outlives `Features`.
             self.runtime_transpiler_cache.map(|p| unsafe { &mut *p })
         }
 
@@ -375,17 +360,14 @@ pub mod Runtime {
         /// Returns an owned `Box<StringSet>`, or `None` if no flags are provided.
         /// Keys are kept sorted so iteration order is deterministic (for RuntimeTranspilerCache hashing).
         pub fn init_bundler_feature_flags(feature_flags: &[&[u8]]) -> Option<Box<StringSet>> {
-            // Zig returns `*const bun.StringSet` heap-allocated via `arena.create`, and
-            // the caller frees it on `BundleOptions` teardown. Empty path returns `None`
-            // (≡ static empty). Owned `Box` per PORTING.md §Forbidden — never leak.
+            // Empty path returns `None` (≡ static empty). Owned `Box` per
+            // PORTING.md §Forbidden — never leak.
             if feature_flags.is_empty() {
                 return None;
             }
-            // PORT NOTE: reshaped for borrowck — Zig inserted then sorted via
-            // `set.map.sort(...)` with a comparator borrowing `set.map.keys()`.
             // `StringSet` preserves insertion order and has no in-place key sort,
             // so sort the inputs first; the resulting `keys()` iteration order
-            // is then byte-lexicographic and matches runtime.zig:241-246.
+            // is then byte-lexicographic.
             let mut sorted: Vec<&[u8]> = feature_flags.to_vec();
             sorted.sort_unstable();
             let mut set = StringSet::new();
@@ -395,11 +377,10 @@ pub mod Runtime {
             Some(Box::new(set))
         }
 
-        // Zig: `hash_fields_for_runtime_transpiler` — a comptime tuple of field-name
-        // enum literals iterated with `inline for` + `@field`. Rust has no field
-        // reflection; expanded by hand. Keep this list in sync with the Zig tuple.
+        // The hashed field list is maintained by hand — keep it in sync with
+        // the feature fields that affect transpiled output.
         //
-        // Spec runtime.zig:272 takes `*std.hash.Wyhash` (NOT `Wyhash11`).
+        // Takes `Wyhash` (NOT `Wyhash11`).
         pub fn hash_for_runtime_transpiler(&self, hasher: &mut Wyhash) {
             debug_assert!(self.runtime_transpiler_cache.is_some());
 
@@ -424,12 +405,12 @@ pub mod Runtime {
                 // note that we do not include .inject_jest_globals, as we bail out of the cache entirely if this is true
             ];
 
-            // `[bool; N]` is N bytes of 0x00/0x01; matches Zig `std.mem.asBytes(&bools)`.
+            // `[bool; N]` is N bytes of 0x00/0x01.
             // `bool: NoUninit`, `u8: AnyBitPattern` → `cast_slice` is statically sound.
             hasher.update(bytemuck::cast_slice::<bool, u8>(&bools));
 
             // Hash --feature flags. These directly affect transpiled output via
-            // feature("NAME") replacement in visitExpr.zig. When empty, we add
+            // feature("NAME") replacement in visit_expr.rs. When empty, we add
             // nothing to the hash so existing cache entries remain valid.
             // Keys are sorted in init_bundler_feature_flags so flag order on the CLI doesn't matter.
             if let Some(flags) = self.bundler_feature_flags.as_deref() {
@@ -487,7 +468,7 @@ pub mod Runtime {
             bun_core::runtime_embed_file!(Codegen, "fallback-decoder.js").as_bytes()
         }
 
-        // Zig: `@import("build_options").fallback_html_version` — wired via build.rs.
+        // Wired via build.rs.
         pub const VERSION_HASH: &'static str = bun_core::build_options::FALLBACK_HTML_VERSION;
 
         pub fn version_hash() -> u32 {
@@ -511,9 +492,8 @@ pub mod Runtime {
             entry_point: &[u8],
             writer: &mut impl bun_io::Write,
         ) -> core::result::Result<(), bun_core::Error> {
-            // Zig: `writer.print(HTMLTemplate, PrintArgs{...})` — Zig's std.fmt named-field
-            // substitution (`{[name]s}`). Rust has no runtime named-format, so substitute
-            // by scanning the embedded template byte-for-byte.
+            // The embedded template uses `{[name]s}`-style named placeholders;
+            // substitute by scanning it byte-for-byte.
             let blob = Base64FallbackMessage { msg };
             let fallback = Self::fallback_decoder_js();
             render_named_template(writer, Self::HTML_TEMPLATE, &mut |w, name| match name {
@@ -549,7 +529,7 @@ pub mod Runtime {
         }
     }
 
-    /// Tiny substitutor for Zig-style `{[name]s}` / `{[name]f}` named placeholders
+    /// Tiny substitutor for `{[name]s}` / `{[name]f}` named placeholders
     /// (the only specifiers used in fallback.html / fallback-backend.html).
     fn render_named_template<W: bun_io::Write>(
         writer: &mut W,
@@ -579,7 +559,6 @@ pub mod Runtime {
         writer.write_all(&bytes[last..])
     }
 
-    /// Zig: `Fallback.Base64FallbackMessage`
     pub(crate) struct Base64FallbackMessage<'a> {
         pub msg: &'a api::FallbackMessageContainer,
     }
@@ -589,7 +568,7 @@ pub mod Runtime {
             let mut bb: Vec<u8> = Vec::new();
             let mut encoder = schema::Writer::new(&mut bb);
             self.msg.encode(&mut encoder); // catch {}
-            // Zig: `Fallback.Base64FallbackMessage.Base64Encoder` (standard alphabet, no '=' padding)
+            // Standard alphabet, no '=' padding.
             let enc = &bun_base64::zig_base64::STANDARD_NO_PAD.encoder;
             let mut out = vec![0u8; enc.calc_size(bb.len())];
             let s = enc.encode(&mut out, &bb); // catch {}
@@ -603,7 +582,6 @@ pub(crate) type RuntimeImports = Runtime::Imports;
 
 pub use crate::p::{NewParser, P};
 
-pub use bun_collections::StringHashMap as StringHashMapRe; // TODO(port): name collision with `StringHashMap` re-export
 // NOTE(b0): `pub use bun_js_printer as js_printer;` removed — js_printer is same-tier mutual
 // (js_printer depends on js_parser). Downstream callers import bun_js_printer directly.
 
@@ -670,7 +648,7 @@ pub enum JSXImport {
 }
 
 impl JSXImport {
-    /// Zig: `@tagName(field)` — the import-clause name as it appears in source.
+    /// The import-clause name as it appears in source.
     #[inline]
     pub(crate) fn tag_name(self) -> &'static [u8] {
         let s: &'static str = self.into();
@@ -783,10 +761,8 @@ impl JSXImportSymbols {
 }
 
 // ─── GenerateImportSymbols impls (for `P::generate_import_stmt`) ───
-// Zig: `generateImportStmt` took `symbols: anytype` and special-cased
-// `if (@TypeOf(symbols) == RuntimeImports) RuntimeImports.all[alias] else alias`
-// to map an integer key → its string name. Rust models that comptime branch via
-// this trait, with `Key = u8` (index into `ALL`) for `RuntimeImports` and
+// `generate_import_stmt` maps a key to its string name via this trait, with
+// `Key = u8` (index into `ALL`) for `RuntimeImports` and
 // `Key = &'static [u8]` (the alias string itself) for `JSXImportSymbols`.
 
 impl crate::p::GenerateImportSymbols for RuntimeImports {
@@ -889,8 +865,7 @@ pub struct VisitArgsOpts<'a> {
 
 /// Generic transposer over `if` expressions.
 ///
-/// `visitor` is a comptime fn pointer in Zig; here we store it as a plain
-/// `fn` pointer. // PERF(port): was comptime monomorphization
+/// `visitor` is stored as a plain `fn` pointer.
 pub struct ExpressionTransposer<'a, Context, State: Copy> {
     pub context: &'a mut Context,
     visitor: fn(&mut Context, Expr, State) -> Expr,
@@ -1060,7 +1035,6 @@ impl<'a> JSXTag<'a> {
                 return Err(bun_core::err!("SyntaxError"));
             }
 
-            // Zig: p.arena.alloc(u8, name.len + 1 + member.len)
             let new_name: &'a mut [u8] = p
                 .bump()
                 .alloc_slice_fill_default::<u8>(name.len() + 1 + member.len());
@@ -1098,7 +1072,6 @@ impl<'a> JSXTag<'a> {
 /// This makes sure that there's the lowest possible chance of having a generated name
 /// collide with a user's name. This is the easiest way to do so
 //
-// Zig: `comptime { name ++ "_" ++ truncatedHash32(std.hash.Wyhash.hash(0, name)) }`.
 // The const-fn Wyhash one-shot lives in `bun_wyhash::hash_const` next to the
 // runtime impl it must stay in lock-step with; the const-fn suffix encoder is
 // `bun_core::fmt::truncated_hash32_bytes` (re-exported here so the
@@ -1107,7 +1080,7 @@ impl<'a> JSXTag<'a> {
 #[doc(hidden)]
 pub mod __generated_symbol_hash {
 
-    /// `bun.fmt.truncatedHash32` — 8-byte base32-ish suffix (native-endian, matches Zig).
+    /// 8-byte base32-ish suffix (native-endian).
     pub use bun_core::fmt::truncated_hash32_bytes as truncated_hash32;
 }
 
@@ -1144,8 +1117,8 @@ macro_rules! generated_symbol_name {
 
 pub struct ExprOrLetStmt {
     pub stmt_or_expr: js_ast::StmtOrExpr,
-    // PORT NOTE: Zig writes `.decls = decls.slice()` borrowing the heap buffer
-    // that was just moved into `S::Local`. The buffer pointer is stable across
+    // `decls` borrows the heap buffer that was just moved into `S::Local`.
+    // The buffer pointer is stable across
     // the move, but borrowck can't see that — store as `RawSlice` to record the
     // outlives-holder invariant without a per-site unsafe cast. Read by the
     // for-loop parser so for-in/for-of heads can validate "let"/"using" decls.
@@ -1185,8 +1158,7 @@ impl AsyncPrefixExpression {
     /// duplicate `hash<[u8]>` bodies). All three keywords are exactly 5 ASCII
     /// bytes and start with 'a'/'y', so a length gate plus one fixed-array
     /// match rejects the overwhelming majority of identifiers in a single
-    /// branch with no hashing — same shape as Zig's `ComptimeStringMap`
-    /// length-bucket prefilter.
+    /// branch with no hashing.
     #[inline]
     pub(crate) fn find(ident: &[u8]) -> AsyncPrefixExpression {
         if ident.len() != 5 {
@@ -1203,10 +1175,10 @@ impl AsyncPrefixExpression {
     }
 }
 
-// Zig: `packed struct(u8)` — assign_target:u2, is_delete_target:b1,
-// was_originally_identifier:b1, is_call_target:b1, _padding:u3.
-// Not all-bool (assign_target is enum(u2)), so per PORTING.md we use a
-// transparent u8 with manual shift accessors matching Zig field order (LSB-first).
+// Packed u8 — assign_target:u2, is_delete_target:b1,
+// was_originally_identifier:b1, is_call_target:b1, _padding:u3 (LSB-first).
+// Not all-bool (assign_target is a 2-bit enum), so per PORTING.md we use a
+// transparent u8 with manual shift accessors.
 #[repr(transparent)]
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
 pub struct IdentifierOpts(u8);
@@ -1244,9 +1216,8 @@ impl IdentifierOpts {
         self.0 & Self::IS_CALL_TARGET != 0
     }
 
-    // Builder-style helpers so call sites can mirror Zig's `.{ .field = ... }`
-    // initialization without paying for a named-field struct (this stays a
-    // packed u8 to match the Zig ABI).
+    // Builder-style helpers (this stays a packed u8 rather than a
+    // named-field struct).
     #[inline]
     pub(crate) const fn new() -> Self {
         Self(0)
@@ -1401,7 +1372,6 @@ pub struct ThenCatchChain {
 impl Default for ThenCatchChain {
     fn default() -> Self {
         Self {
-            // Zig: zero-init `js_ast.Expr.Data` → `.e_missing` (tag 0).
             next_target: js_ast::ExprData::EMissing(E::Missing {}),
             has_multiple_args: false,
             has_catch: false,
@@ -1474,7 +1444,8 @@ pub struct StringVoidMap {
 impl StringVoidMap {
     /// Returns true if the map already contained the given key.
     pub(crate) fn get_or_put_contains(&mut self, key: &[u8]) -> bool {
-        // TODO(port): StringHashMap key ownership — Zig stored borrowed source slices.
+        // StringHashMap copies keys into owned heap allocations on insert,
+        // so the pooled map outliving any one source is fine.
         let entry = self.map.get_or_put(key).expect("unreachable");
         entry.found_existing
     }
@@ -1491,7 +1462,7 @@ impl StringVoidMap {
     }
 
     /// Returns an RAII guard that derefs to `&mut StringVoidMap` and is
-    /// returned to the pool on `Drop` (replaces Zig's `get` + `defer release`).
+    /// returned to the pool on `Drop`.
     #[inline]
     pub(crate) fn get() -> bun_collections::pool::PoolGuard<'static, StringVoidMap> {
         StringVoidMapPool::get()
@@ -1506,15 +1477,13 @@ impl bun_collections::pool::ObjectPoolType for StringVoidMap {
     }
 }
 
-// Zig: `ObjectPool(StringVoidMap, init, true, 32)` — `true` is thread-local,
-// `32` is the preheated capacity.
 bun_collections::object_pool!(pub StringVoidMapPool: StringVoidMap, threadsafe, 32);
 
 pub(crate) type StringBoolMap = StringHashMap<bool>;
-pub(crate) type RefMap = HashMap<Ref, ()>; // TODO(port): RefCtx hasher + 80% load factor
-pub(crate) type RefRefMap = HashMap<Ref, Ref>; // TODO(port): RefCtx hasher + 80% load factor
+pub(crate) type RefMap = HashMap<Ref, ()>;
+pub(crate) type RefRefMap = HashMap<Ref, Ref>;
 
-// PORT NOTE: `scope` is `*mut` (not `&'arena`) because the visit pass writes
+// `scope` is `*mut` (not `&'arena`) because the visit pass writes
 // through it (push_scope_for_visit_pass assigns it to `current_scope: *mut`)
 // and the parse pass needs Copy for the BumpVec<Option<ScopeOrder>> to be
 // indexable + truncatable. The Scope itself is arena-owned for `'arena`.
@@ -1677,7 +1646,7 @@ pub struct FnOnlyDataVisit<'a> {
     /// to implement "this" and "super" references. A name is automatically generated
     /// if one is missing so this will always be present inside a class body.
     ///
-    /// Zig's `?*Ref` becomes `&Cell<Ref>` (not `&mut Ref`): the visit pass needs to
+    /// `&Cell<Ref>` (not `&mut Ref`): the visit pass needs to
     /// both share this slot into nested `fn_only_data_visit` frames *and* read/write
     /// it from the enclosing `visit_class` frame. `Cell` gives shared interior
     /// mutability for the `Copy` `Ref` payload with zero `unsafe`.
@@ -1820,8 +1789,8 @@ impl ScanPassResult {
         self.named_imports.clear_retaining_capacity();
         self.import_records.clear();
         self.used_symbols.clear_retaining_capacity();
-        // PORT NOTE: parser.zig:778-783 does NOT clear import_records_to_keep here;
-        // matching Zig (the keep-list persists across reset()).
+        // import_records_to_keep is intentionally NOT cleared here;
+        // the keep-list persists across reset().
         self.approximate_newline_count = 0;
     }
 }
@@ -1897,23 +1866,13 @@ impl<'a> ParseStatementOptions<'a> {
     }
 }
 
-// TODO(port): `Prefill` holds mutable global AST node singletons (`pub var` in
-// Zig). Rust forbids non-`Sync` mutable statics without `unsafe`; several of
-// these contain raw pointers (e_string -> &E.String) and one (`ActivateIndex`)
-// has an `undefined` field. TODO(refactor): decide between `static mut` +
-// `unsafe`, `LazyLock`, or eliminating the globals entirely. The byte-array
-// constants are safe and ported as `pub const`.
+// Only const-able AST node singletons live here. Callers needing the rest
+// (missing nodes, empty statements, the HMR helper exprs) construct them
+// directly — they are cheap value types, so a shared-singleton optimization
+// isn't worth `static mut`/`LazyLock` plumbing.
 pub mod prefill {
     use super::*;
 
-    pub mod hot_module_reloading {
-        // TODO(port): mutable static Expr arrays — need `static mut` or `LazyLock`.
-        // pub static DEBUG_ENABLED_ARGS: [Expr; 1] = [...];
-        // pub static DEBUG_DISABLED: [Expr; 1] = [...];
-        // pub static ACTIVATE_STRING: E::String = E::String { data: b"activate" };
-        // pub static ACTIVATE_INDEX: E::Index = ...; // .target = undefined
-    }
-
     pub mod string_literal {
         pub(crate) const CHILDREN: [u8; 8] = *b"children";
     }
@@ -1931,13 +1890,6 @@ pub mod prefill {
 
     pub mod data {
         use super::*;
-        // TODO(port): Expr.Data / Stmt.Data / B variant statics — needs final
-        // shape of `js_ast::ExprData` (Rust enum) before these compile.
-        // pub static B_MISSING: B = B::Missing(B::Missing {});
-        // pub static E_MISSING: ExprData = ExprData::EMissing(E::Missing {});
-        // pub static S_EMPTY: StmtData = StmtData::SEmpty(S::Empty {});
-        // pub static FILENAME: ExprData = ExprData::EString(&string::FILENAME);
-        // ... etc.
         pub const THIS: js_ast::ExprData = js_ast::ExprData::EThis(E::This {});
         pub(crate) const ZERO: js_ast::ExprData = js_ast::ExprData::ENumber(value::ZERO);
     }
@@ -1960,9 +1912,7 @@ impl JSXTransformType {
         matches!(self, JSXTransformType::React)
     }
 
-    /// Derive the transform mode from parser options the way the Zig
-    /// `NewParser(.{ .jsx = ... })` instantiation did (`if (jsx.parse) .react
-    /// else .none`).
+    /// Derive the transform mode from parser options.
     #[inline]
     pub(crate) const fn from_parse_flag(parse: bool) -> JSXTransformType {
         if parse {
@@ -1982,9 +1932,8 @@ pub struct MacroState<'a> {
 }
 
 impl<'a> MacroState<'a> {
-    // TODO(port): Zig initializes `prepend_stmts = undefined`; Rust cannot leave
-    // a `&mut` field uninitialized. Caller must supply a placeholder list, or
-    // this field becomes `Option<&'a mut Vec<Stmt>>` set to `None` here.
+    // The field is write-only, but a `&mut` field cannot be left
+    // uninitialized, so the caller supplies a placeholder list.
     pub fn init(prepend_stmts: &'a mut Vec<Stmt>) -> MacroState<'a> {
         MacroState {
             refs: MacroRefs::default(),
@@ -2012,13 +1961,10 @@ pub struct Jest {
 }
 
 impl Jest {
-    /// Port of Zig `inline for (comptime std.meta.fieldNames(Jest))` — Rust has
-    /// no comptime struct-field reflection, so `_parse` iterates this static
-    /// table instead. The `&str` is the *JavaScript* global name (matches the
-    /// Zig field identifier verbatim, not the Rust snake_case rename), and the
-    /// fn-ptr projects the corresponding `Ref` out of the struct. Order matches
-    /// the Zig field declaration order so the emitted import-clause / binding
-    /// property order is identical.
+    /// `_parse` iterates this static table. The `&str` is the *JavaScript*
+    /// global name, and the fn-ptr projects the corresponding `Ref` out of
+    /// the struct. The table order determines the emitted import-clause /
+    /// binding property order.
     pub(crate) const FIELDS: &'static [(&'static str, fn(&Jest) -> Ref)] = &[
         ("test", |j| j.test),
         ("it", |j| j.it),
@@ -2058,20 +2004,8 @@ impl Default for Jest {
     }
 }
 
-// Doing this seems to yield a 1% performance improvement parsing larger files
-// ❯ hyperfine "../../build/macos-x86_64/bun node_modules/react-dom/cjs/react-dom.development.js --resolve=disable" "../../bun.before-comptime-js-parser node_modules/react-dom/cjs/react-dom.development.js --resolve=disable" --min-runs=500
-// Benchmark #1: ../../build/macos-x86_64/bun node_modules/react-dom/cjs/react-dom.development.js --resolve=disable
-//   Time (mean ± σ):      25.1 ms ±   1.1 ms    [User: 20.4 ms, System: 3.1 ms]
-//   Range (min … max):    23.5 ms …  31.7 ms    500 runs
-//
-// Benchmark #2: ../../bun.before-comptime-js-parser node_modules/react-dom/cjs/react-dom.development.js --resolve=disable
-//   Time (mean ± σ):      25.6 ms ±   1.3 ms    [User: 20.9 ms, System: 3.1 ms]
-//   Range (min … max):    24.1 ms …  39.7 ms    500 runs
-// '../../build/macos-x86_64/bun node_modules/react-dom/cjs/react-dom.development.js --resolve=disable' ran
-// 1.02 ± 0.07 times faster than '../../bun.before-comptime-js-parser node_modules/react-dom/cjs/react-dom.development.js --resolve=disable'
-//
-// `NewParser!` Zig comptime-type-fn lowering: named aliases now live in
-// `ast/Parser.rs` (where the JsxT ZSTs are in scope). Re-export here.
+// Named parser aliases live in `ast/Parser.rs` (where the JsxT ZSTs are
+// in scope). Re-export here.
 pub use crate::parse::parse_entry::{
     JSXImportScanner, JSXParser, JavaScriptImportScanner, JavaScriptParser, TSXImportScanner,
     TSXParser, TypeScriptImportScanner, TypeScriptParser,
@@ -2120,7 +2054,7 @@ pub fn new_lazy_export_ast<'bump>(
     log_to_copy_into: &mut bun_ast::Log,
     expr: Expr,
     source: &'bump bun_ast::Source,
-    runtime_api_call: &'static [u8], // PERF(port): was comptime monomorphization
+    runtime_api_call: &'static [u8],
 ) -> Result<Option<js_ast::Ast<'bump>>, bun_core::Error> {
     new_lazy_export_ast_impl(
         bump,
@@ -2141,13 +2075,13 @@ pub fn new_lazy_export_ast_impl<'bump>(
     log_to_copy_into: &mut bun_ast::Log,
     expr: Expr,
     source: &'bump bun_ast::Source,
-    runtime_api_call: &'static [u8], // PERF(port): was comptime monomorphization
+    runtime_api_call: &'static [u8],
     symbols: js_ast::symbol::List<'bump>,
 ) -> Result<Option<js_ast::Ast<'bump>>, bun_core::Error> {
     let mut temp_log = bun_ast::Log::init();
-    // Zig held two aliasing `*Log` (parser.log + lexer.log). Both sides store
-    // `NonNull<Log>` in Rust; copy the lexer's pointer so they share one
-    // provenance chain. See `Parser::init` for the same pattern.
+    // parser.log and lexer.log both store `NonNull<Log>`; copy the lexer's
+    // pointer so they share one provenance chain. See `Parser::init` for the
+    // same pattern.
     let lexer = js_lexer::Lexer::init_without_reading(&mut temp_log, source, bump);
     let log_ptr = lexer.log;
     let mut parser = Parser {
@@ -2272,8 +2206,8 @@ pub struct ReactRefresh<'a> {
     /// and then it will insert `var _s = ...`, add the `_s()` call at
     /// the start of the function, and then add the call to `_s(func, ...)`.
     ///
-    /// PORT NOTE: Zig type is `?*?HookContext` — a raw nullable pointer to
-    /// stack storage on the visiting fn frame. Modeled as `Option<NonNull<_>>`
+    /// A raw nullable pointer to stack storage on the visiting fn frame,
+    /// modeled as `Option<NonNull<_>>`
     /// (Copy) so the save/set/restore dance in visitStmt/visitExpr can take a
     /// stack-local address without the `'a` borrow the visitor cannot satisfy.
     pub hook_ctx_storage: Option<core::ptr::NonNull<Option<HookContext>>>,
@@ -2311,7 +2245,7 @@ pub struct HookContext {
 
 impl ReactRefresh<'_> {
     /// Reborrow the stack-allocated `Option<HookContext>` that
-    /// `hook_ctx_storage` points at (Zig: `?*?HookContext`). The returned
+    /// `hook_ctx_storage` points at. The returned
     /// borrow is detached from `self` because the storage lives on a *caller*
     /// stack frame (set/restored around each visit), disjoint from the parser
     /// struct. Centralises the one `unsafe` so call sites in `p.rs` /
@@ -2415,8 +2349,8 @@ pub(crate) fn float_to_int32(f: f64) -> i32 {
         return 0;
     }
 
-    // Note: Rust `as u32` saturates where Zig `@intFromFloat` is UB on overflow,
-    // but `@mod` ensures the value is in [0, u32::MAX] so behavior matches.
+    // The `%` keeps the value in [0, u32::MAX], so the `as u32` cast is exact
+    // (and would saturate rather than be UB if it weren't).
     let uint: u32 = (f.abs() % (u32::MAX as f64 + 1.0)) as u32;
     let int: i32 = uint as i32; // bitcast (same-width int cast reinterprets bits)
     if f < 0.0 { 0i32.wrapping_sub(int) } else { int }
@@ -2428,5 +2362,3 @@ pub struct ParseBindingOptions {
     /// is only allowed to be `using name, name2, name3`, nothing special.
     pub is_using_statement: bool,
 }
-
-// ported from: src/js_parser/parser.zig
diff --git a/src/js_parser/repl_transforms.rs b/src/js_parser/repl_transforms.rs
index 267f028e932..d338c2d1b0b 100644
--- a/src/js_parser/repl_transforms.rs
+++ b/src/js_parser/repl_transforms.rs
@@ -14,9 +14,6 @@ use bun_ast::flags;
 use bun_ast::stmt::Data as StmtData;
 use bun_ast::{B, Binding, E, Expr, ExprNodeList, G, S, Stmt};
 
-// Zig: `pub fn ReplTransforms(comptime P: type) type { return struct { ... } }`
-// — file-split mixin pattern. Round-D lowered to direct `impl P` block.
-
 use crate::p::P;
 
 impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
@@ -45,7 +42,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
         }
 
         // Collect all statements into a single array
-        // PERF(port): was bun.handleOom(arena.alloc(Stmt, n)) — bump alloc + index fill
         let mut all_stmts = BumpVec::with_capacity_in(total_stmts_count, bump);
         for part in parts.iter() {
             for stmt in part.stmts.iter() {
@@ -220,7 +216,7 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
                         ));
 
                         // Convert class declaration to assignment: ClassName = class ClassName {}
-                        // PORT NOTE: G::Class is non-Copy (owns a Vec); the original
+                        // G::Class is non-Copy (owns a Vec); the original
                         // S::Class store entry is dead after this rewrite, so move it out.
                         let class_value = core::mem::take(&mut class.class);
                         let class_expr = self.new_expr(class_value, stmt.loc);
@@ -498,7 +494,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
 
         // Final output: hoisted declarations + IIFE call
         let final_stmts_count = hoisted_stmts.len() + 1;
-        // PERF(port): was bun.handleOom(arena.alloc(Stmt, n)) — bump Vec + into_bump_slice
         let mut final_stmts = BumpVec::with_capacity_in(final_stmts_count, bump);
         for stmt in hoisted_stmts.iter() {
             final_stmts.push(*stmt);
@@ -697,7 +692,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
     /// Create { __proto__: null, value: expr } wrapper object
     /// Uses null prototype to create a clean data object
     fn repl_wrap_expr_in_value_object<'bump>(&mut self, expr: Expr, bump: &'bump Bump) -> Expr {
-        // PERF(port): was bun.handleOom(arena.alloc(G.Property, 2)).
         // G::Property is non-Copy (owns Vec) → use bump Vec instead of alloc_slice_copy.
         let mut properties = BumpVec::<G::Property>::with_capacity_in(2, bump);
         // __proto__: null - creates null-prototype object
@@ -804,7 +798,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
             B::B::BArray(arr) => {
                 let arr = arr.get();
                 let arr_items = arr.items();
-                // PERF(port): was bun.handleOom(arena.alloc(Expr, n))
                 let mut items = BumpVec::with_capacity_in(arr_items.len(), bump);
                 for (i, item) in arr_items.iter().enumerate() {
                     let expr = self.repl_convert_binding_to_expr(item.binding, bump);
@@ -837,7 +830,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
             B::B::BObject(obj) => {
                 let obj = obj.get();
                 let obj_props = obj.properties();
-                // PERF(port): was bun.handleOom(arena.alloc(G.Property, n))
                 let mut properties = BumpVec::with_capacity_in(obj_props.len(), bump);
                 for prop in obj_props.iter() {
                     properties.push(G::Property {
@@ -869,7 +861,7 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
     }
 }
 
-/// Bump-allocate a single-element `G::DeclList` (Zig: `Decl.List.fromOwnedSlice(arena.dupe(...))`).
+/// Bump-allocate a single-element `G::DeclList`.
 #[inline]
 fn repl_one_decl(bump: &Bump, binding: Binding) -> G::DeclList {
     let slice: &mut [G::Decl] = bump.alloc_slice_fill_with(1, |_| G::Decl {
@@ -878,5 +870,3 @@ fn repl_one_decl(bump: &Bump, binding: Binding) -> G::DeclList {
     });
     G::DeclList::from_arena_slice(slice)
 }
-
-// ported from: src/js_parser/ast/repl_transforms.zig
diff --git a/src/js_parser/scan/scan_imports.rs b/src/js_parser/scan/scan_imports.rs
index 29cdebfc562..98141a4b43b 100644
--- a/src/js_parser/scan/scan_imports.rs
+++ b/src/js_parser/scan/scan_imports.rs
@@ -9,8 +9,8 @@ use bun_collections::VecExt;
 use bun_core::strings;
 use bun_crash_handler::handle_oom::handle_oom;
 
-// PORT NOTE: Zig file-level struct → Rust struct. `stmts` is a sub-slice of the
-// input `stmts` argument (in-place compacted), so it borrows from the caller.
+// `stmts` is a sub-slice of the input `stmts` argument (in-place compacted),
+// so it borrows from the caller.
 #[derive(Default)]
 pub(crate) struct ImportScanner<'a> {
     pub stmts: &'a mut [Stmt],
@@ -26,11 +26,8 @@ fn raw_str(s: &'static [u8]) -> js_ast::StoreStr {
 }
 
 impl<'a> ImportScanner<'a> {
-    // TODO(port): narrow error set
-    // PORT NOTE: `<P>` unbounded generic → concrete `P<'a, TS, SCAN>`.
-    // TODO(port): the Zig also accepts `bun.bundle_v2.AstBuilder` as P (comptime
-    //   `P != AstBuilder` check). Only the parser P is handled here; the AstBuilder
-    //   path needs a `ParserLike` trait or a separate monomorphization.
+    // Only the parser P is handled here — the bundler scans imports via its own
+    // path and does not go through this function.
     pub(crate) fn scan<
         'p,
         const TYPESCRIPT: bool,
@@ -40,8 +37,7 @@ impl<'a> ImportScanner<'a> {
         p: &mut P<'p, TYPESCRIPT, SCAN_ONLY>,
         stmts: &'a mut [Stmt],
         will_transform_to_common_js: bool,
-        // PORT NOTE: Zig used `if (comptime_bool) *T else void` for this param's
-        // type; Rust const generics can't gate a param type, so use Option and
+        // Const generics can't gate a param type on a const, so use Option and
         // debug-assert presence matches the const.
         mut hot_module_reloading_context: Option<&mut ConvertESMExportsForHmr>,
     ) -> Result<ImportScanner<'a>, bun_core::Error> {
@@ -52,24 +48,20 @@ impl<'a> ImportScanner<'a> {
 
         let mut scanner = ImportScanner::default();
         let mut stmts_end: usize = 0;
-        // PORT NOTE: `arena` (p.arena) dropped — see §Allocators (AST crate).
+        // `arena` (p.arena) dropped — see §Allocators (AST crate).
         // Arena allocs below go through `p.arena` (a &Bump) where they persist.
         let is_typescript_enabled: bool = TYPESCRIPT;
 
         for i in 0..stmts.len() {
-            // PORT NOTE: Zig iterated by value-copy then wrote back via index at
-            // the bottom; we index directly to allow in-place mutation + reassign.
+            // Index directly to allow in-place mutation + reassignment.
             let mut stmt = stmts[i]; // copy
             match stmt.data {
                 js_ast::StmtData::SImport(mut import_ptr) => {
-                    // PORT NOTE: Zig did `var st = import_ptr.*; defer import_ptr.* = st;`
-                    // (copy + unconditional write-back). Equivalent to mutating in place.
                     let st: &mut S::Import = &mut *import_ptr;
 
                     let import_record_index = st.import_record_index;
-                    // PORT NOTE: reshaped for borrowck — Zig held `record: *ImportRecord`
-                    // for the whole arm; Rust can't keep a long-lived &mut alongside
-                    // other `p.*` borrows. We take a raw pointer once and unsafe-deref
+                    // We can't keep a long-lived `&mut ImportRecord` for the whole arm
+                    // alongside other `p.*` borrows. We take a raw pointer once and unsafe-deref
                     // at each use site (no operation below grows `p.import_records`, so
                     // the pointer stays valid for this iteration).
                     let record: *mut ImportRecord =
@@ -83,7 +75,7 @@ impl<'a> ImportScanner<'a> {
                     }
 
                     if record!().path.namespace == crate::Macro::NAMESPACE {
-                        // PORT NOTE: `Path::isMacro()` inlined (no Rust method yet).
+                        // `Path::isMacro()` inlined (no Rust method yet).
                         record!().flags.insert(import_record::Flags::IS_UNUSED);
                         record!().path.is_disabled = true;
                         continue;
@@ -240,7 +232,7 @@ impl<'a> ImportScanner<'a> {
 
                                 // Remove the symbol if it's never used outside a dead code region
                                 if symbol.use_count_estimate != 0 {
-                                    // PORT NOTE: ClauseItem isn't `Copy`; bitwise-move it
+                                    // ClauseItem isn't `Copy`; bitwise-move it
                                     // (its fields are all POD; arena-owned, never dropped).
                                     if items_end != idx {
                                         // SAFETY: items_end < idx < len; non-overlapping.
@@ -377,7 +369,7 @@ impl<'a> ImportScanner<'a> {
                             .insert(import_record::Flags::CONTAINS_DEFAULT_ALIAS);
                     }
 
-                    // PORT NOTE: borrow (not clone) — disjoint-field borrow vs. the
+                    // borrow (not clone) — disjoint-field borrow vs. the
                     // `p.symbols` / `p.named_imports` / `p.declared_symbols` writes
                     // below. `None` stands in for `ImportItemForNamespaceMap.init()`.
                     let existing_items: Option<&ImportItemForNamespaceMap> =
@@ -459,7 +451,6 @@ impl<'a> ImportScanner<'a> {
                             record!()
                                 .flags
                                 .insert(import_record::Flags::CONTAINS_IMPORT_STAR);
-                            // PERF(port): was assume_capacity
                             p.named_imports.put_assume_capacity(
                                 namespace_ref,
                                 js_ast::NamedImport {
@@ -478,7 +469,6 @@ impl<'a> ImportScanner<'a> {
                             record!()
                                 .flags
                                 .insert(import_record::Flags::CONTAINS_DEFAULT_ALIAS);
-                            // PERF(port): was assume_capacity
                             p.named_imports.put_assume_capacity(
                                 default.ref_.expect("infallible: ref bound"),
                                 js_ast::NamedImport {
@@ -497,7 +487,6 @@ impl<'a> ImportScanner<'a> {
                             let name: LocRef = item.name;
                             let name_ref = name.ref_.expect("infallible: ref bound");
 
-                            // PERF(port): was assume_capacity
                             p.named_imports.put_assume_capacity(
                                 name_ref,
                                 js_ast::NamedImport {
@@ -702,15 +691,13 @@ impl<'a> ImportScanner<'a> {
                     }
                 }
                 js_ast::StmtData::SExportDefault(mut st) => {
-                    // PORT NOTE: Zig used `defer` to record the export after the body;
-                    // capture default_name now and run the record after the body below.
+                    // Capture default_name now and record the export after the body below.
                     let deferred_default_name = st.default_name;
 
                     // Rewrite this export to be:
                     // exports.default =
                     // But only if it's anonymous
-                    // PORT NOTE: comptime `P != bun.bundle_v2.AstBuilder` check elided —
-                    // this monomorphization is the parser `P` only (see fn-level TODO).
+                    // This monomorphization is the parser `P` only (see fn-level TODO).
                     // blocked_on: P::module_exports gated (reconciler-6 re-gate in P.rs)
                     if !HOT_MODULE_RELOADING_TRANSFORMATIONS && will_transform_to_common_js {
                         let expr = core::mem::take(&mut st.value).to_expr();
@@ -842,5 +829,3 @@ impl<'a> ImportScanner<'a> {
         Ok(scanner)
     }
 }
-
-// ported from: src/js_parser/ast/ImportScanner.zig
diff --git a/src/js_parser/scan/scan_side_effects.rs b/src/js_parser/scan/scan_side_effects.rs
index 1dcd76b4d1e..fc052788d72 100644
--- a/src/js_parser/scan/scan_side_effects.rs
+++ b/src/js_parser/scan/scan_side_effects.rs
@@ -6,11 +6,7 @@ use bun_ast::symbol;
 use bun_ast::{self, Binding, E, Expr, ExprData, G, Op, Stmt, StmtData, StoreRef};
 use bun_collections::VecExt;
 
-// PORT NOTE: round-E un-gate. SideEffects in Zig is an enum with associated fns that
-// take `p: anytype`. Round-E converts the unbounded `<P>` generic to concrete
-// `P<'a, TS, SCAN>`. Method bodies gated; the `Result` type and enum surface are real.
-
-#[repr(u8)] // Zig: enum(u1) — Rust has no u1 repr; u8 is the smallest
+#[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
 pub enum SideEffects {
     #[default]
@@ -111,7 +107,7 @@ impl SideEffects {
         }
     }
 
-    // Re-exports of ExprData methods (Zig: `pub const toNumber = Expr.Data.toNumber;`)
+    // Re-exports of ExprData methods.
     #[inline(always)]
     pub fn to_number(data: &ExprData) -> Option<f64> {
         data.to_number()
@@ -151,7 +147,7 @@ impl SideEffects {
             p.report_stack_overflow(expr.loc);
             return Some(expr);
         }
-        // PORT NOTE: `Expr`/`ExprData`/`StoreRef<_>` are all `Copy`. We match on
+        // `Expr`/`ExprData`/`StoreRef<_>` are all `Copy`. We match on
         // `expr.data` *by value* so `expr` itself is never borrowed across a
         // recursive `simplify_unused_expr(p, ..)` call. Mutations to boxed
         // payloads write through `StoreRef::DerefMut` into the arena, so they
@@ -242,7 +238,6 @@ impl SideEffects {
                 }
             }
 
-            // Zig: `inline .e_call, .e_new => |call|` — written out per variant.
             ExprData::ECall(call) => {
                 // A call that has been marked "__PURE__" can be removed if all arguments
                 // can be removed. The annotation causes us to ignore the target.
@@ -253,7 +248,6 @@ impl SideEffects {
                             if call.can_be_unwrapped_if_unused
                                 == CallUnwrap::IfUnusedAndToStringSafe
                             {
-                                // PERF(port): @branchHint(.unlikely)
                                 // For now, only support this for 1 argument.
                                 if j.data.is_safe_to_string() {
                                     return None;
@@ -276,7 +270,6 @@ impl SideEffects {
                             if call.can_be_unwrapped_if_unused
                                 == CallUnwrap::IfUnusedAndToStringSafe
                             {
-                                // PERF(port): @branchHint(.unlikely)
                                 // For now, only support this for 1 argument.
                                 if j.data.is_safe_to_string() {
                                     return None;
@@ -403,9 +396,8 @@ impl SideEffects {
                             }
                         }
 
-                        // PORT NOTE: G::Property is not Copy (Vec ts_decorators
-                        // field). The Zig spec does an in-place struct copy; here we
-                        // swap so the kept property lands at `end` without cloning.
+                        // G::Property is not Copy (Vec ts_decorators field), so swap
+                        // so the kept property lands at `end` without cloning.
                         e_object.properties.slice_mut().swap(end, j);
                         end += 1;
                     }
@@ -536,11 +528,10 @@ impl SideEffects {
             Op::Code::BinStrictEq | Op::Code::BinStrictNe | Op::Code::BinComma
         ));
 
-        // PORT NOTE: Zig threads `p.binary_expression_simplify_stack` (a reusable
-        // ArrayList on `P`) to avoid per-call allocation. The Rust `P` field is
-        // currently `ListManaged<'a, ()>` (placeholder element type — see P.rs:537),
-        // so until that's reshaped to `BinaryExpressionSimplifyVisitor` we use a
-        // local Vec. Same iteration order; only the arena differs.
+        // Ideally this would reuse `p.binary_expression_simplify_stack` to avoid
+        // per-call allocation, but that `P` field is currently `ListManaged<'a, ()>`
+        // (placeholder element type — see P.rs:537); until it's reshaped to
+        // `BinaryExpressionSimplifyVisitor` we use a local Vec.
         let mut stack: Vec<StoreRef<E::Binary>> = Vec::with_capacity(8);
         stack.push(root_bin);
 
@@ -928,8 +919,8 @@ impl SideEffects {
                 }
             }
             ExprData::EString(e) => Result {
-                // Zig: `e.isPresent()` — open-coded to dodge an ambiguous inherent
-                // `len()` while E.rs's duplicate `impl EString` blocks are being merged.
+                // Open-coded `isPresent` to dodge an ambiguous inherent `len()`
+                // while E.rs's duplicate `impl EString` blocks are being merged.
                 value: e.rope_len > 0 || !e.data.is_empty(),
                 side_effects: SideEffects::NoSideEffects,
                 ok: true,
@@ -1081,5 +1072,3 @@ impl SideEffects {
         }
     }
 }
-
-// ported from: src/js_parser/ast/SideEffects.zig
diff --git a/src/js_parser/scan/scan_symbols.rs b/src/js_parser/scan/scan_symbols.rs
index 9bc6e55fea2..76db1e2f4e1 100644
--- a/src/js_parser/scan/scan_symbols.rs
+++ b/src/js_parser/scan/scan_symbols.rs
@@ -4,14 +4,6 @@ use crate::parser::FindSymbolResult;
 use bun_ast as js_ast;
 use bun_ast::{Ref, Scope};
 
-// PORT NOTE: Zig's `fn Symbols(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// is the file-split mixin pattern: a fieldless namespace whose associated fns all take `*P` as the
-// first arg, where `P = js_parser.NewParser_(ts, jsx, scan_only)`. In Rust this is a plain
-// `impl<const ...> P<...> { }` block — multiple impl blocks on the same type across files in one
-// crate are allowed.
-//
-// adt_const_params: lowered `const JSX: JSXTransformType` → `J: JsxT` (sealed trait + ZST).
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     pub fn find_symbol(
         &mut self,
@@ -79,9 +71,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                 // If this is an identifier from a sibling TypeScript namespace, then we're
                                 // going to have to generate a property access instead of a simple reference.
                                 // Lazily-generate an identifier that represents this property access.
-                                // PORT NOTE: reshaped for borrowck — Zig's getOrPut returns key/value
-                                // pointers while we also call self.new_symbol (&mut self). Split into
-                                // get-then-insert so the &mut self borrow does not overlap the map borrow.
+                                // Split into get-then-insert so the &mut self borrow
+                                // (self.new_symbol) does not overlap the map borrow.
                                 if let Some(existing) = ts.property_accesses.get(name) {
                                     break 'brk *existing;
                                 }
@@ -126,8 +117,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 break 'brk existing.ref_;
             }
 
-            // PORT NOTE: reshaped for borrowck — gpe borrows self.module_scope while
-            // self.new_symbol needs &mut self. Drop gpe, allocate, then re-insert.
+            // gpe borrows self.module_scope while self.new_symbol needs &mut self.
+            // Drop gpe, allocate, then re-insert.
             let new_ref = self
                 .new_symbol(js_ast::symbol::Kind::Unbound, name)
                 .expect("unreachable");
@@ -162,5 +153,3 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         })
     }
 }
-
-// ported from: src/js_parser/ast/symbols.zig
diff --git a/src/js_parser/typescript.rs b/src/js_parser/typescript.rs
index 66ce8c582ad..edbfb0f7e7a 100644
--- a/src/js_parser/typescript.rs
+++ b/src/js_parser/typescript.rs
@@ -1,10 +1,8 @@
 use crate::js_lexer::T;
 use crate::p::P;
 
-// Zig: `p: anytype` for the generic parser instance. Lowered NewParser_ →
-// `P<'a, const TS, const SCAN>` and converted to `impl P` methods (an unbounded
-// `<P>` cannot access fields). The `Metadata::*` methods that need
-// `p.load_name_from_ref` take a closure to avoid the impl-on-foreign-type problem.
+// The `Metadata::*` methods that need `p.load_name_from_ref` take a closure to
+// avoid the impl-on-foreign-type problem.
 
 // This function is taken from the official TypeScript compiler source code:
 // https://github.com/microsoft/TypeScript/blob/master/src/compiler/parser.ts
@@ -43,11 +41,10 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
 } // end impl P (can_follow_type_arguments_in_expression)
 
 impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
-    // TODO(port): narrow error set — only `lexer.next()` is fallible here.
     pub fn is_ts_arrow_fn_jsx(&mut self) -> Result<bool, bun_core::Error> {
         let p = self;
-        // PORT NOTE: Zig `const old = p.lexer` (value copy). Rust Lexer holds `&mut Log`
-        // so cannot Clone; use the LexerSnapshot POD via `snapshot()`/`restore()`.
+        // Lexer holds `&mut Log` so it cannot Clone; use the LexerSnapshot POD
+        // via `snapshot()`/`restore()`.
         let old_lexer = p.lexer.snapshot();
 
         p.lexer.next()?;
@@ -143,7 +140,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
 
     fn look_ahead_next_token_is_open_paren_or_less_than_or_dot(&mut self) -> bool {
         let p = self;
-        // PORT NOTE: Zig value-copied the Lexer; use snapshot()/restore() (see is_ts_arrow_fn_jsx).
         let old_lexer = p.lexer.snapshot();
         let old_log_disabled = p.lexer.is_log_disabled;
         p.lexer.is_log_disabled = true;
@@ -152,8 +148,6 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
 
         let result = matches!(p.lexer.token, T::TOpenParen | T::TLessThan | T::TDot);
 
-        // PORT NOTE: Zig used `defer` for restore; reshaped to linear since there is
-        // no early return between the defer and end of scope.
         p.lexer.restore(&old_lexer);
         p.lexer.is_log_disabled = old_log_disabled;
 
@@ -162,7 +156,7 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
 
     // This function is taken from the official TypeScript compiler source code:
     // https://github.com/microsoft/TypeScript/blob/master/src/compiler/parser.ts
-    // PORT NOTE: renamed `ts_is_identifier` to avoid clash with lexer/P helpers of the same name.
+    // renamed `ts_is_identifier` to avoid clash with lexer/P helpers of the same name.
     fn ts_is_identifier(&self) -> bool {
         use crate::parser::AwaitOrYield::AllowIdent;
         let p = self;
@@ -293,7 +287,7 @@ pub mod identifier {
         }
     }
 
-    // PERF(port): was `phf::Map<&[u8], Kind>`. phf hashes the full identifier
+    // PERF: avoids `phf::Map<&[u8], Kind>` — phf hashes the full identifier
     // (SipHash) on every TIdentifier in a TS type position — including the
     // overwhelmingly-common miss case (a user-defined type name). With only
     // 16 entries spanning lengths 3..=9, a length gate rejects almost every
@@ -393,10 +387,7 @@ pub enum SkipTypeOptions {
     DisallowConditionalTypes,
 }
 
-// PORT NOTE: Zig nested `Bitset` and `empty` inside `SkipTypeOptions`. Rust
-// inherent associated types (`impl Foo { type Bar = ...; }`) are unstable
+// Inherent associated types (`impl Foo { type Bar = ...; }`) are unstable
 // (`inherent_associated_types`), so the alias and empty constant are hoisted
 // to module scope.
 pub(crate) type SkipTypeOptionsBitset = enumset::EnumSet<SkipTypeOptions>;
-
-// ported from: src/js_parser/ast/TypeScript.zig
diff --git a/src/js_parser/visit/mod.rs b/src/js_parser/visit/mod.rs
index 66a3d50cda1..ef873c88926 100644
--- a/src/js_parser/visit/mod.rs
+++ b/src/js_parser/visit/mod.rs
@@ -27,7 +27,7 @@ use bun_ast::{
     Stmt, StmtData, Symbol,
 };
 use bun_collections::VecExt;
-// PORT NOTE: `parser::SideEffects` is a stub enum without the assoc fns; the real
+// `parser::SideEffects` is a stub enum without the assoc fns; the real
 // `should_keep_stmt_in_dead_control_flow` lives on `ast::side_effects::SideEffects`.
 use crate::scan::scan_side_effects::SideEffects;
 use bun_ast::StrictModeKind;
@@ -37,10 +37,6 @@ use core::ptr::NonNull;
 // In the AST crate, ListManaged is arena-backed.
 type ListManaged<'bump, T> = BumpVec<'bump, T>;
 
-// Zig: `pub fn Visit(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block.
-
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
     // Thin alias of `current_scope_mut()` kept for local readability.
     #[inline(always)]
@@ -53,7 +49,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         stmts: &mut ListManaged<'a, Stmt>,
         opts: &mut PrependTempRefsOpts,
     ) -> Result<(), bun_core::Error> {
-        // Zig: `if (only_scan_imports_and_do_not_visit) @compileError(...)`
         debug_assert!(
             !SCAN_ONLY,
             "only_scan_imports_and_do_not_visit must not run this."
@@ -89,13 +84,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     pub fn visit_func(&mut self, mut func: G::Fn, open_parens_loc: bun_ast::Loc) -> G::Fn {
-        // Zig: `if (only_scan_imports_and_do_not_visit) @compileError(...)`
         debug_assert!(
             !SCAN_ONLY,
             "only_scan_imports_and_do_not_visit must not run this."
         );
 
-        // PORT NOTE: FnOnlyDataVisit holds `Option<&'a Cell<Ref>>`; save/restore via
+        // FnOnlyDataVisit holds `Option<&'a Cell<Ref>>`; save/restore via
         // `take` so the old value is moved out before we overwrite the field.
         let old_fn_or_arrow_data = self.fn_or_arrow_data_visit;
         let old_fn_only_data = core::mem::take(&mut self.fn_only_data_visit);
@@ -141,7 +135,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         self.push_scope_for_visit_pass(ScopeKind::FunctionBody, body_loc)
             .expect("unreachable");
-        // PERF(port): was arena-backed ListManaged.fromOwnedSlice — Stmt is Copy.
+        // Stmt is Copy — copy the slice into a bump-backed Vec.
         let mut stmts = BumpVec::with_capacity_in(body_stmts.len(), self.arena);
         stmts.extend_from_slice(body_stmts);
         let mut temp_opts = PrependTempRefsOpts {
@@ -152,8 +146,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             .expect("unreachable");
 
         if self.options.features.react_fast_refresh {
-            // PORT NOTE: react_refresh.hook_ctx_storage is `Option<NonNull<Option<HookContext>>>`
-            // pointing at a stack-local on the visitStmt caller frame (Zig: `*?Hook`).
+            // react_refresh.hook_ctx_storage is `Option<NonNull<Option<HookContext>>>`
+            // pointing at a stack-local on the visitStmt caller frame.
             // `ReactRefresh::hook_ctx_mut` centralises the raw-pointer deref and returns a
             // borrow detached from `self` (the storage is on the caller's stack frame), so
             // it can be held across the `&mut self` method call below.
@@ -185,7 +179,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     pub fn visit_args(&mut self, args: &mut [G::Arg], opts: &VisitArgsOpts) {
         let strict_loc = fn_body_contains_use_strict(opts.body);
         let has_simple_args = Self::is_simple_parameter_list(args, opts.has_rest_arg);
-        // StringVoidMap::get returns a pool guard; Drop releases (replaces Zig `defer release`).
+        // StringVoidMap::get returns a pool guard; Drop releases.
         let mut duplicate_args_check: Option<
             bun_collections::pool::PoolGuard<'static, StringVoidMap>,
         > = None;
@@ -221,7 +215,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 self.visit_ts_decorators(&mut arg.ts_decorators);
             }
 
-            // PORT NOTE: reborrow per-iter (Zig passes the same pointer each time).
+            // reborrow per-iter.
             let dup: Option<&mut StringVoidMap> = duplicate_args_check.as_deref_mut();
             self.visit_binding(arg.binding, dup);
             if let Some(default) = arg.default.as_mut() {
@@ -230,8 +224,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
-    // PORT NOTE: Zig returned the list by value (`ExprNodeList` is a fat ptr there).
-    // `Vec<Expr>` is not `Copy` in Rust; mutate in place instead.
+    // `Vec<Expr>` is not `Copy`; mutate in place.
     pub fn visit_ts_decorators(&mut self, decs: &mut ExprNodeList) {
         for dec in decs.slice_mut() {
             self.visit_expr(dec);
@@ -244,8 +237,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         was_const: bool,
     ) -> usize {
         let mut j: usize = 0;
-        // PORT NOTE: reshaped for borrowck — Zig aliased `out_decls = decls` and
-        // iterated `decls` while writing through `out_decls[j]`. We iterate by index.
+        // Iterate by index so kept entries can be written back through `decls[j]`
+        // while scanning ahead.
         let len = decls.len();
         let mut i: usize = 0;
         'outer: while i < len {
@@ -262,7 +255,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 let prev_require_to_convert_count = self.imports_to_convert_from_require.len();
                 let prev_macro_call_count = self.macro_call_count;
                 let orig_dead = self.is_control_flow_dead;
-                // PORT NOTE: `replacement` is a `BackRef` (Zig `?*ReplaceableExport`) so the
+                // `replacement` is a `BackRef` so the
                 // borrow of `self.options` does not survive across `visit_expr_in_out(&mut self)`.
                 // `BackRef` invariant: `self.options.features.replace_exports` is never mutated
                 // during the visit pass, so the entry strictly outlives this loop body.
@@ -323,7 +316,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     if let Some(last_hook) = self.react_refresh.last_hook_seen {
                         if let Some(call) = decl.value.unwrap().data.e_call() {
                             if core::ptr::eq(last_hook, &raw const *call) {
-                                // PORT NOTE: disjoint field borrows — `react_refresh.hook_ctx_storage`
+                                // disjoint field borrows — `react_refresh.hook_ctx_storage`
                                 // points at caller-frame stack storage (detached lifetime via
                                 // `hook_ctx_mut`), and `symbols` is an independent field of `P`.
                                 let hasher = &mut self
@@ -710,7 +703,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
-    // PORT NOTE: P::stmts_to_single_stmt is ``-gated (P.rs:6267, blocked on
+    // P::stmts_to_single_stmt is ``-gated (P.rs:6267, blocked on
     // S::Block Default). Inline a local copy until that un-gates.
     fn stmts_to_single_stmt_(&mut self, loc: bun_ast::Loc, stmts: &'a mut [Stmt]) -> Stmt {
         if stmts.is_empty() {
@@ -760,8 +753,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             b.stmts = bun_ast::StoreSlice::new_mut(items);
         }
         if self.options.features.minify_syntax {
-            // PORT NOTE: reshaped for borrowck — `stmts` was consumed above; in Zig
-            // `stmts.items` aliases the slice now stored in `s_block.stmts`.
+            // `stmts` was consumed above; `items` aliases the slice now
+            // stored in `s_block.stmts`.
             new_stmt = self.stmts_to_single_stmt_(stmt.loc, items);
         }
 
@@ -801,7 +794,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         class: &mut G::Class,
         default_name_ref: Ref,
     ) -> Ref {
-        // Zig: `if (only_scan_imports_and_do_not_visit) @compileError(...)`
         debug_assert!(
             !SCAN_ONLY,
             "only_scan_imports_and_do_not_visit must not run this."
@@ -819,10 +811,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         self.enclosing_class_keyword = class.class_keyword;
         self.vis_scope()
             .recursive_set_strict_mode(StrictModeKind::ImplicitStrictModeClass);
-        // PORT NOTE: `FnOnlyDataVisit::class_name_ref` is `Option<&'a Cell<Ref>>`, so the
-        // shadow ref must outlive the parser borrow. Allocate it in the bump arena (Zig kept
-        // it on the stack and passed `&shadow_ref` — Rust's `'a` bound on the field forbids
-        // that). `Cell` lets us hand out a shared `&'a Cell<Ref>` to nested frames while
+        // `FnOnlyDataVisit::class_name_ref` is `Option<&'a Cell<Ref>>`, so the
+        // shadow ref must outlive the parser borrow. Allocate it in the bump arena.
+        // `Cell` lets us hand out a shared `&'a Cell<Ref>` to nested frames while
         // still reading/writing it here, with no raw-pointer `unsafe`.
         let shadow_ref: &'a core::cell::Cell<Ref> =
             core::cell::Cell::from_mut(self.arena.alloc(Ref::NONE));
@@ -898,7 +889,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     // Make it an error to use "arguments" in a static class block
                     self.vis_scope().forbid_arguments = true;
 
-                    // PERF(port): was Vec::move_to_list_managed; Stmt is Copy.
+                    // Stmt is Copy — copy the slice into a bump-backed Vec.
                     let csb_stmts = csb.stmts.slice();
                     let mut list = BumpVec::with_capacity_in(csb_stmts.len(), self.arena);
                     list.extend_from_slice(csb_stmts);
@@ -968,9 +959,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                 (value.data, key.data)
                             {
                                 if e_str.eql_comptime(b"constructor") {
-                                    // PORT NOTE: Zig keeps a `*E.Function` into property.value's
-                                    // arena slot, then re-reads it after visit_expr overwrites
-                                    // the value below. `StoreRef` carries the same arena pointer.
+                                    // `StoreRef` points into property.value's arena slot,
+                                    // so it can be re-read after visit_expr overwrites the
+                                    // value below.
                                     constructor_function_ = Some(e_func);
                                     constructor_function = constructor_function_;
                                 }
@@ -1091,8 +1082,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             old_props_len + to_add,
                             self.arena,
                         );
-                        // PORT NOTE: Zig `fromOwnedSlice` adopts the existing buffer in-place.
-                        // Rust BumpVec can't adopt a foreign arena slice, so move each element
+                        // BumpVec can't adopt a foreign arena slice, so move each element
                         // out by `ptr::read` (G::Property has no Drop; old slice becomes dead
                         // arena bytes).
                         for i in 0..old_props_len {
@@ -1105,7 +1095,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                         let args_len = func_args.len();
                         for arg_idx in 0..args_len {
-                            // PORT NOTE: reshaped for borrowck — copy the scalars we need
+                            // reshaped for borrowck — copy the scalars we need
                             // (id_ref, bind_loc) out of the arg before calling `&mut self`
                             // helpers, so no live `&Arg` overlaps `self.new_expr`/`declare_symbol`.
                             let (id_ref, bind_loc) = {
@@ -1147,9 +1137,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             stmts.insert(insert_at, Stmt::assign(dot, arg_ident));
 
                             // O(N)
-                            // Zig: `class_body.items.len += 1; bun.copy(...)` — open a 1-slot
-                            // gap at j and write the new field. `Vec::insert` is the same
-                            // memmove + write.
+                            // `Vec::insert` opens a 1-slot gap at j and writes the
+                            // new field (memmove + write).
                             // Copy the argument name symbol to prevent the class field
                             // declaration from being renamed but not the constructor argument.
                             let field_symbol_ref = self
@@ -1211,7 +1200,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         stmts: &mut ListManaged<'a, Stmt>,
         kind: StmtsKind,
     ) -> Result<(), bun_core::Error> {
-        // Zig: `if (only_scan_imports_and_do_not_visit) @compileError(...)`
         debug_assert!(
             !SCAN_ONLY,
             "only_scan_imports_and_do_not_visit must not run this."
@@ -1226,7 +1214,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             // Save the current control-flow liveness. This represents if we are
             // currently inside an "if (false) { ... }" block.
             let old_is_control_flow_dead = p.is_control_flow_dead;
-            // PORT NOTE: Zig `defer` — manually restored at block end. The error
+            // Restored manually at block end. The error
             // path (`?`) skips restore; acceptable because callers `.expect()` or
             // propagate fatally (parse abort) — no resumption after error.
 
@@ -1246,19 +1234,14 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 for stmt in stmts.iter_mut() {
                     if matches!(stmt.data, StmtData::SEnum(_)) {
                         // `scope_order_to_visit: &'a [ScopeOrder<'a>]` is `Copy`;
-                        // save/restore matches the Zig slice-copy directly.
+                        // plain save/restore.
                         let old_scopes_in_order = p.scope_order_to_visit;
 
-                        // `Loc` lacks `Hash` (logger crate) so `ArrayHashMap::get`
-                        // is unavailable; linear scan over `keys()`/`values()`
-                        // (enums are rare).
-                        // TODO(port): switch to `.get(&stmt.loc)` once `Loc: Hash`.
                         p.scope_order_to_visit =
                             scopes_for_enum_at(&p.scopes_in_order_for_enum, stmt.loc);
 
                         let mut temp = ListManaged::new_in(p.arena);
                         let res = p.visit_and_append_stmt(&mut temp, stmt);
-                        // Zig: `defer p.scope_order_to_visit = old_scopes_in_order`.
                         p.scope_order_to_visit = old_scopes_in_order;
                         res?;
                         preprocessed_enums.push(temp.into_bump_slice());
@@ -1266,21 +1249,15 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 }
             }
 
-            if p.current_scope == p.module_scope {
-                // TODO(port): `MacroState::prepend_stmts` is `&'a mut Vec<Stmt>` but
-                // `before` is a `BumpVec<'a, Stmt>` — type-shape divergence in
-                // parser.rs. Zig: `p.macro.prepend_stmts = &before;`. The macro
-                // expansion path is gated; this BACKREF is restored when MacroState
-                // switches to `BumpVec` / `NonNull`.
-                let _ = &mut before;
-            }
+            // `p.macro.prepend_stmts` is write-only (nothing ever reads it),
+            // so the backref is intentionally not wired here.
 
             // visit all statements first
             let mut visited: ListManaged<'a, Stmt> =
                 ListManaged::with_capacity_in(stmts.len(), p.arena);
 
             let prev_nearest_stmt_list = p.nearest_stmt_list;
-            // PORT NOTE: BACKREF — `before` outlives this block; raw NonNull avoids
+            // BACKREF — `before` outlives this block; raw NonNull avoids
             // the `&'a mut` borrow conflict. Derive via `addr_of_mut!` (no intermediate
             // `&mut`) so the pointer shares the local's base tag and survives the
             // direct `&mut before` reborrows in the loop below (Stacked Borrows).
@@ -1325,7 +1302,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                             let enum_scope_count =
                                 scopes_for_enum_at(&p.scopes_in_order_for_enum, stmt.loc).len();
-                            // Zig: `p.scope_order_to_visit = p.scope_order_to_visit[enum_scope_count..]`
                             p.scope_order_to_visit = &p.scope_order_to_visit[enum_scope_count..];
                             continue 'stmt_loop;
                         }
@@ -1403,8 +1379,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                             // The last function statement for a given symbol wins
                             data.func.name = None;
-                            // SAFETY: `G::Fn`'s fields are POD (`StoreSlice<T>`, ints, flags) but
-                            // lacks `derive(Copy)`; bitwise read matches Zig struct copy.
+                            // SAFETY: `G::Fn`'s fields are POD (`StoreSlice<T>`, ints, flags)
+                            // with no `Drop`, so a bitwise read is a plain copy; the type just
+                            // lacks `derive(Copy)`.
                             let func = unsafe { core::ptr::read(&raw const data.func) };
                             let_decls[index as usize].value =
                                 Some(p.new_expr(E::Function { func }, stmt.loc));
@@ -1474,8 +1451,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 visited_count = end;
             }
 
-            // PORT NOTE: reshaped — Zig `resize`+slice-walk; `Stmt: Copy` so the
-            // simpler clear+extend is equivalent and avoids a `Stmt::default()`
+            // `Stmt: Copy`, so clear+extend avoids a `Stmt::default()`
             // filler value.
             stmts.clear();
             stmts.reserve(visited_count + before.len() + after.len());
@@ -1492,9 +1468,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         if kind != StmtsKind::SwitchStmt && p.should_lower_using_declarations(stmts.as_slice()) {
             let mut ctx = LowerUsingDeclarationsContext::init(p)?;
             ctx.scan_stmts(p, stmts.as_mut_slice());
-            // PORT NOTE: Zig's `stmts.* = ctx.finalize(p, stmts.items, ...)`
-            // overwrote the ArrayList struct without freeing the old buffer.
-            // `finalize` stores a sub-slice of that buffer as the lowered
+            // `finalize` stores a sub-slice of the old buffer as the lowered
             // S.Try `body`, so the buffer must outlive the assignment. Leak
             // the old buffer into the 'a arena via `into_bump_slice_mut`
             // (reclaimed on arena reset) before installing the new list —
@@ -1556,7 +1530,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                             }
                                         }
                                     }
-                                    // PORT NOTE: `Decl` is field-wise `Copy` but lacks the
+                                    // `Decl` is field-wise `Copy` but lacks the
                                     // derive; `swap` compacts in place (idx >= end always).
                                     decls.swap(end, idx);
                                     end += 1;
@@ -1630,10 +1604,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     // by now since they are scoped to this block which we just finished
                     // visiting.
                     let prev_idx = output.len() - 1;
-                    // PORT NOTE: reshaped for borrowck — Zig held `&mut output[..]`
-                    // across `p.substitute...` (which borrows `&mut p`). We read the
-                    // `StoreRef` (Copy) first, then re-borrow `output` only when
-                    // truncating.
+                    // borrowck: read the `StoreRef` (Copy) first, then re-borrow
+                    // `output` only when truncating.
                     let StmtData::SLocal(mut local) = output[prev_idx].data else {
                         break;
                     };
@@ -1711,15 +1683,13 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         let prev_stmt = &mut output[prev_idx];
                         if let StmtData::SLocal(mut prev_local) = prev_stmt.data {
                             if local.can_merge_with(&prev_local) {
-                                // PORT NOTE: `Vec::append_slice` requires `T: Clone`
+                                // `Vec::append_slice` requires `T: Clone`
                                 // but `G::Decl` lacks the derive (its fields are all
-                                // `Copy`). Per-element bitwise copy matches Zig
-                                // `appendSlice` semantics.
+                                // `Copy`). Per-element bitwise copy instead.
                                 //
                                 // The parse pass allocates `decls` in the bump arena
                                 // (`from_bump_slice` → `Origin::Borrowed`); promote to a
-                                // global-heap buffer before growing it. In Zig both ends
-                                // are mimalloc so `appendSlice` just reallocs in place.
+                                // global-heap buffer before growing it.
                                 for d in local.decls.slice() {
                                     // SAFETY: Decl is field-wise Copy (Binding, Option<Expr>).
                                     prev_local.decls.push(unsafe { core::ptr::read(d) });
@@ -1763,7 +1733,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                     && prev_local.kind == LocalKind::KVar
                                 {
                                     if let ExprData::EIdentifier(left_id) = bin_assign.left.data {
-                                        // PORT NOTE: `prev_local` is a `StoreRef` (Copy) so
+                                        // `prev_local` is a `StoreRef` (Copy) so
                                         // re-slicing here writes through to the arena slot.
                                         let mut prev_local = prev_local;
                                         let decl = &mut prev_local.decls.slice_mut()[0];
@@ -1882,23 +1852,13 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 }
 
-/// `p.scopes_in_order_for_enum.get(loc)` workaround: `bun_ast::Loc` lacks
-/// `Hash`, so `ArrayHashMap::get` (gated on `ArrayHashContext<K>`) is
-/// unavailable. Linear scan over the (small) parallel key/value slices.
-// TODO(port): replace with `.get(&loc).unwrap()` once `Loc: Hash` lands in
-// bun_logger (cross-crate; out of scope here).
 fn scopes_for_enum_at<'a>(
     map: &bun_collections::ArrayHashMap<bun_ast::Loc, &'a [ScopeOrder<'a>]>,
     loc: bun_ast::Loc,
 ) -> &'a [ScopeOrder<'a>] {
-    let keys = map.keys();
-    let values = map.values();
-    for i in 0..keys.len() {
-        if keys[i] == loc {
-            return values[i];
-        }
-    }
-    unreachable!("scopes_in_order_for_enum miss for enum stmt loc");
+    map.get(&loc)
+        .copied()
+        .expect("scopes_in_order_for_enum miss for enum stmt loc")
 }
 
 pub(crate) fn fn_body_contains_use_strict(body: &[Stmt]) -> Option<bun_ast::Loc> {
diff --git a/src/js_parser/visit/visit_binary.rs b/src/js_parser/visit/visit_binary.rs
index 7591c25a41c..c433537dda0 100644
--- a/src/js_parser/visit/visit_binary.rs
+++ b/src/js_parser/visit/visit_binary.rs
@@ -11,14 +11,6 @@ use bun_ast::{
     expr::{Equality, LooseEql, StrictEql},
 };
 
-// PORT NOTE: The Zig `CreateBinaryExpressionVisitor(comptime ts, comptime jsx, comptime scan_only) type`
-// returned an anonymous namespace struct whose only public item was `BinaryExpressionVisitor`.
-// Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so `BinaryExpressionVisitor` carries
-// the parser generics directly.
-// Diff readers should map:
-//   Zig: CreateBinaryExpressionVisitor(TS, JSX, SCAN).BinaryExpressionVisitor
-//   Rust: BinaryExpressionVisitor<'arena, TS, J, SCAN>
-
 /// Try to optimize "typeof x === 'undefined'" to "typeof x > 'u'" or similar
 /// Returns the optimized expression if successful, None otherwise
 fn try_optimize_typeof_undefined<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool>(
@@ -80,7 +72,7 @@ fn try_optimize_typeof_undefined<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bo
     ))
 }
 
-// PORT NOTE: `Expr.Data.eql(left, right, p, .{loose,strict})` — thin adapter
+// `Expr.Data.eql(left, right, p, .{loose,strict})` — thin adapter
 // from the `const STRICT: bool` shape used at the four call sites below to the
 // canonical `ExprData::eql<P, K: EqlKindT>` (Expr.rs). Kept as a free fn so
 // the call sites don't each repeat the `LooseEql`/`StrictEql` type-select.
@@ -98,13 +90,13 @@ fn data_eql<'a, const STRICT: bool, const TYPESCRIPT: bool, const SCAN_ONLY: boo
 }
 
 pub struct BinaryExpressionVisitor {
-    /// Arena handle to the in-place `E::Binary` node (Zig: `*E.Binary`).
+    /// Arena handle to the in-place `E::Binary` node.
     /// `StoreRef` is the safe arena back-reference: `Copy` + `Deref`/`DerefMut`
     /// encapsulate the AST-store invariant, so call sites need no raw-pointer
     /// round-trip to forge an `'arena` borrow.
     pub e: StoreRef<E::Binary>,
     pub loc: bun_ast::Loc,
-    // PORT NOTE: Zig field name `in` is a Rust keyword; renamed to `in_`.
+    // `in` is a Rust keyword; named `in_`.
     pub in_: ExprIn,
 
     /// Input for visiting the left child
@@ -130,7 +122,6 @@ impl BinaryExpressionVisitor {
 
         let is_call_target =
             matches!(p.call_target, ExprData::EBinary(ptr) if core::ptr::eq(ptr.as_ptr(), e_ptr));
-        // const is_stmt_expr = @as(Expr.Tag, p.stmt_expr_value) == .e_binary and expr.data.e_binary == p.stmt_expr_value.e_binary;
         let was_anonymous_named_expr = e_.right.is_anonymous_named();
         let prev_decorator_class_name = p.decorator_class_name;
 
@@ -514,17 +505,12 @@ impl BinaryExpressionVisitor {
                 if p.should_fold_typescript_constant_expressions {
                     if let Some(vals) = Expr::extract_numeric_values(&e_.left.data, &e_.right.data)
                     {
-                        // TODO(port): move to <area>_sys
-                        unsafe extern "C" {
-                            // libc fmod is pure (value-type args, no errno, no pointers) → no caller preconditions.
-                            safe fn fmod(x: f64, y: f64) -> f64;
-                        }
                         return p.new_expr(
-                            // Use libc fmod here to be consistent with what JavaScriptCore does
+                            // Rust `%` on f64 has libc fmod semantics (LLVM frem),
+                            // which matches what JavaScriptCore does:
                             // https://github.com/oven-sh/WebKit/blob/7a0b13626e5db69aa5a32d037431d381df5dfb61/Source/JavaScriptCore/runtime/MathCommon.cpp#L574-L597
-                            // PORT NOTE: Zig had a non-native fallback to std.math.mod; Rust targets are always native.
                             E::Number {
-                                value: fmod(vals[0], vals[1]),
+                                value: vals[0] % vals[1],
                             },
                             v.loc,
                         );
@@ -566,7 +552,7 @@ impl BinaryExpressionVisitor {
                     {
                         let left = float_to_int32(vals[0]);
                         let right: u32 = (float_to_int32(vals[1]) as u32) % 32;
-                        // std.math.shr on i32 is arithmetic shift right
+                        // wrapping_shr on i32 is an arithmetic shift right
                         let result: i32 = left.wrapping_shr(right);
                         return p.new_expr(
                             E::Number {
@@ -738,7 +724,7 @@ impl BinaryExpressionVisitor {
             Op::Code::BinAssign => {
                 // Optionally preserve the name
                 if let ExprData::EIdentifier(ident) = e_.left.data {
-                    // PORT NOTE: reshaped for borrowck — copy the `StoreStr` out of
+                    // reshaped for borrowck — copy the `StoreStr` out of
                     // `p.symbols` before taking `&mut self` for `maybe_keep_expr_symbol_name`.
                     let name = p.symbols[ident.ref_.inner_index() as usize].original_name;
                     e_.right = p.maybe_keep_expr_symbol_name(
@@ -767,7 +753,7 @@ impl BinaryExpressionVisitor {
 
         Expr {
             loc: v.loc,
-            // Same arena slot Zig threads as `*E.Binary` — re-wrap the handle.
+            // Same arena slot — re-wrap the handle.
             data: ExprData::EBinary(e_handle),
         }
     }
@@ -832,5 +818,3 @@ impl BinaryExpressionVisitor {
         None
     }
 }
-
-// ported from: src/js_parser/ast/visitBinaryExpression.zig
diff --git a/src/js_parser/visit/visit_expr.rs b/src/js_parser/visit/visit_expr.rs
index 90de364837d..986bba02a14 100644
--- a/src/js_parser/visit/visit_expr.rs
+++ b/src/js_parser/visit/visit_expr.rs
@@ -17,16 +17,12 @@ use bun_ast as js_ast;
 use bun_ast::flags as Flags;
 use bun_ast::{E, Expr, ExprNodeIndex, ExprNodeList, G, Stmt, Symbol};
 
-// Local short-hands so the visitor bodies read close to the Zig
-// (`expr.data.e_dot`, `Expr.Data.e_binary`, `Op.Code.un_typeof`) without a
-// bulk find-replace at every call-site.
+// Local short-hands used heavily in the visitor bodies.
 use js_ast::ExprData as Data;
 use js_ast::ExprTag as Tag;
 use js_ast::OpCode as Op;
 
-// Zig: `pub fn VisitExpr(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
-// a direct `impl P` block. The 25+ per-variant `e_*` helpers are private; only `visit_expr` /
+// The 25+ per-variant `e_*` helpers are private; only `visit_expr` /
 // `visit_expr_in_out` are surfaced.
 
 impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_ONLY> {
@@ -36,8 +32,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     // and only writes back when the visitor produces a *different* node.
     #[inline]
     pub fn visit_expr(&mut self, e: &mut Expr) {
-        // Zig: `if (only_scan_imports_and_do_not_visit) @compileError(...)` — SCAN_ONLY
-        // monomorphizations must never reach the visit pass.
+        // SCAN_ONLY monomorphizations must never reach the visit pass.
         debug_assert!(
             !SCAN_ONLY,
             "only_scan_imports_and_do_not_visit must not run visit_expr",
@@ -56,9 +51,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .add_error(Some(self.source), e.loc, b"Invalid assignment target");
         }
 
-        // Zig dispatches via `inline else => |tag| if (comptime @hasDecl(visitors, @tagName(tag)))`.
-        // Rust has no struct-decl reflection; expand to an explicit match over the tags that have
-        // a visitor defined below. Any tag without a visitor leaves `*e` unchanged.
+        // Explicit match over the tags that have a visitor defined below.
+        // Any tag without a visitor leaves `*e` unchanged.
         use js_ast::ExprTag as Tag;
         match e.data.tag() {
             Tag::ENewTarget => Self::e_new_target(self, e, in_),
@@ -90,14 +84,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     // ─── visitors ───────────────────────────────────────────────────────────
-    // In Zig these live on a nested `const visitors = struct { ... }`; in Rust they are private
-    // associated fns on this impl so they can see the const-generic feature params.
+    // Private associated fns on this impl so they can see the const-generic
+    // feature params.
 
     fn e_new_target(_: &mut Self, _e: &mut Expr, _: ExprIn) {
-        // this error is not necessary and it is causing breakages
-        // if (!p.fn_only_data_visit.is_new_target_allowed) {
-        //     p.log.addRangeError(p.source, target.range, "Cannot use \"new.target\" here") catch unreachable;
-        // }
+        // The "Cannot use \"new.target\" here" range error is intentionally
+        // not emitted: it is not necessary and it was causing breakages.
     }
 
     fn e_string(_: &mut Self, _e: &mut Expr, _: ExprIn) {
@@ -347,7 +339,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     // big match arms into the recursive dispatcher, inflating its stack frame to
     // ~968B; deep ASTs then thrash L1d on the spill/reload (the spill into that
     // frame is the #2 hottest bun-native instruction under `bun --bun lint`).
-    // Mirrors Zig's switch-with-helper-fns layout.
     #[inline(never)]
     fn e_jsx_element(p: &mut Self, e: &mut Expr, in_: ExprIn) {
         let expr = *e;
@@ -357,8 +348,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             .data
             .e_jsx_element()
             .expect("infallible: variant checked");
-        // Zig: `switch (comptime jsx_transform_type)`; JSX is no longer a
-        // type parameter — dispatch on the runtime `P::jsx_transform` field.
+        // JSX is not a type parameter — dispatch on the runtime
+        // `P::jsx_transform` field.
         match p.jsx_transform {
             JSXTransformType::React => {
                 let tag: Expr = 'tagger: {
@@ -367,14 +358,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         break 'tagger _tag;
                     }
                     if p.options.jsx.runtime == options::JSX::Runtime::Classic {
-                        // PORT NOTE: `jsx_strings_to_member_expression` wants `&[&'a [u8]]`.
-                        // In Zig, `options.jsx.fragment: []const string` borrows from the
-                        // long-lived `transpiler.options.jsx`, so the strings outlive the
-                        // AST. Here, `options.jsx.fragment: Box<[Box<[u8]>]>` is OWNED by
+                        // `jsx_strings_to_member_expression` wants `&[&'a [u8]]`.
+                        // `options.jsx.fragment: Box<[Box<[u8]>]>` is OWNED by
                         // `P` and dropped when `Parser::parse` returns — but the parts are
                         // stored in symbols / `E::Dot.name` and read later by the printer.
-                        // Dupe each part into the arena (which backs the AST) to restore
-                        // the spec's lifetime invariant. Build the `&[&'a [u8]]` slice
+                        // Dupe each part into the arena (which backs the AST) so they
+                        // outlive the parse. Build the `&[&'a [u8]]` slice
                         // directly in the AST arena instead of a throwaway global-heap
                         // `Vec` — keeps the visitor off the `#[global_allocator]`.
                         let arena = p.arena;
@@ -419,15 +408,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 if runtime == options::JSX::Runtime::Classic || is_key_after_spread {
                     // Arguments to createElement()
                     let mut args = ExprNodeList::init_capacity(2 + children_count as usize);
-                    // PERF(port): was assume_capacity
                     VecExt::append(&mut args, tag);
 
                     let num_props = e_.properties.len_u32();
                     if num_props > 0 {
-                        // PORT NOTE: Zig duped the property slice into a fresh arena allocation
-                        // before wrapping in E.Object. PropertyList = Vec<Property> here is
-                        // already arena-backed and the JSX node is consumed; reuse in place.
-                        // PERF(port): was arena alloc + bun.copy — profile if it shows up on a hot path
+                        // PropertyList = Vec<Property> is already arena-backed and the
+                        // JSX node is consumed; reuse in place.
                         VecExt::append(
                             &mut args,
                             p.new_expr(
@@ -447,13 +433,12 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         let mut arg = *child;
                         p.visit_expr(&mut arg);
                         if !matches!(arg.data, Data::EMissing(..)) {
-                            // PERF(port): was assume_capacity
                             VecExt::append(&mut args, arg);
                         }
                     }
 
                     let target: Expr = if runtime == options::JSX::Runtime::Classic {
-                        // PORT NOTE: see fragment note above — `options.jsx.factory` is
+                        // see fragment note above — `options.jsx.factory` is
                         // owned by `P` and freed when the parser drops; dupe each part
                         // into the arena so the symbol/E::Dot names outlive the printer.
                         // Build the parts slice in the AST arena (no global-heap `Vec`).
@@ -468,8 +453,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         p.jsx_strings_to_member_expression(expr.loc, parts)
                             .expect("unreachable")
                     } else {
-                        // Spec (visitExpr.zig:257) calls jsxStringsToMemberExpression(factory)
-                        // unconditionally before the runtime check; that has the side-effect of
+                        // jsxStringsToMemberExpression(factory) must run
+                        // unconditionally before the runtime check; it has the side-effect of
                         // findSymbol(loc, factory[0]) which records usage of the factory ident.
                         // The full helper is Pragma-shape-blocked, so replicate the side-effect
                         // for the Automatic + key-after-spread path and discard the result.
@@ -510,10 +495,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         None
                     };
 
-                    // PORT NOTE: Zig reassigns `props` (a `*Vec(G.Property)`) to point inside
-                    // a spread object's properties via raw arena pointer. Track as a
-                    // `StoreRef` (safe `Deref`/`DerefMut`) so the spread-collapse walk
-                    // and the `push`/`take` calls below stay in safe code.
+                    // `props` may be reassigned to point inside a spread object's
+                    // properties. Track it as a `StoreRef` (safe `Deref`/`DerefMut`) so
+                    // the spread-collapse walk and the `push`/`take` calls below stay
+                    // in safe code.
                     let mut props_handle = js_ast::StoreRef::from_bump(&mut e_.properties);
 
                     // arguments needs to be like
@@ -524,9 +509,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
                     {
                         let mut last_child: u32 = 0;
-                        // PORT NOTE: Zig wrote `e_.children.ptr[last_child] = p.visitExpr(child)`
-                        // while iterating a slice over the same buffer. Iterate by index to avoid
-                        // borrowck on `e_.children`.
+                        // Iterate by index to avoid a borrowck conflict on
+                        // `e_.children` (writes alias the buffer being iterated).
                         for i in 0..children_count {
                             let mut visited = e_.children.slice()[i as usize];
                             p.visit_expr(&mut visited);
@@ -540,7 +524,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         e_.children.truncate(last_child as usize);
                     }
 
-                    // PERF(port): was process-static — profile if it shows up on a hot path
                     let children_key = p.new_expr(prefill::string::CHILDREN, expr.loc);
 
                     // Optimization: if the only non-child prop is a spread object
@@ -561,10 +544,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         {
                             break;
                         }
-                        // PORT NOTE: reshaped for borrowck — Zig reassigns `props` to point
-                        // inside the spread object's properties. Compute the next handle in
-                        // a block so the `DerefMut` borrow of `props_handle` ends before
-                        // reassignment.
+                        // Compute the next handle in a block so the `DerefMut`
+                        // borrow of `props_handle` ends before reassignment.
                         let next = {
                             let inner = props_handle.slice_mut()[0]
                                 .value
@@ -713,7 +694,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // arrows/functions inside them unconsumed and trip "Scope mismatch
         // while visiting" on the next scope push. Mirrors e_call, which visits
         // its arguments before macro handling.
-        // `Template.parts` is arena-owned (Zig: `[]E.TemplatePart`).
+        // `Template.parts` is arena-owned.
         for part in e_.parts_mut().iter_mut() {
             p.visit_expr(&mut part.value);
         }
@@ -775,7 +756,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         // We must visit it to convert inline_identifiers and record usage
                         // Reborrow via the field-disjoint `Lexer::log()` accessor
                         // so `&p.lexer` and `&mut p.options` split cleanly under
-                        // borrowck — Zig held two raw `*Log`.
+                        // borrowck.
                         let log = p.lexer.log();
                         let source = p.source;
                         let Ok(macro_result) = p
@@ -823,9 +804,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         // iteration on the heap instead of recursion on the call stack to avoid
         // stack overflow for deeply-nested ASTs.
         //
-        // PORT NOTE: Zig stores `*E.Binary` (arena ptr). `BinaryExpressionVisitor.e`
-        // is the `StoreRef<E::Binary>` arena handle directly — `Copy` + safe
-        // `Deref`/`DerefMut`, so no raw-pointer detach is needed here.
+        // `BinaryExpressionVisitor.e` is the `StoreRef<E::Binary>` arena
+        // handle — `Copy` + safe `Deref`/`DerefMut`, so no raw-pointer detach
+        // is needed here.
         let mut v: BinaryExpressionVisitor = BinaryExpressionVisitor {
             e: e_,
             loc: expr.loc,
@@ -840,8 +821,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let stack_bottom = p.binary_expression_stack.len();
 
         // Assigned on every `break` arm of the loop below; the initial input
-        // `expr` is never read directly (Zig's `var current = expr` was a
-        // pre-init habit, not load-bearing).
+        // `expr` is never read directly.
         let mut current;
 
         // Iterate down into the AST along the left node of the binary operation.
@@ -1175,9 +1155,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             );
         }
 
-        // PORT NOTE: `e_` is `StoreRef<E::Index>` — mutations above wrote through
-        // DerefMut into the same arena slot `expr.data` already points at. Zig's
-        // `p.newExpr(e_, loc)` re-wraps the same pointer; here `*e` is already that.
+        // `e_` is `StoreRef<E::Index>` — mutations above wrote through
+        // DerefMut into the same arena slot `expr.data` already points at,
+        // so `*e` is already up to date.
     }
 
     fn e_unary(p: &mut Self, e: &mut Expr, _: ExprIn) {
@@ -1751,8 +1731,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     && matches!(key.data, Data::EString(..))
                 {
                     let key_str = key.data.e_string().expect("infallible: variant checked");
-                    // PORT NOTE: Zig `string(arena)` transcodes UTF-16; while
-                    // E.rs has duplicate impls (E0034), reach the bytes directly
+                    // While E.rs has duplicate impls (E0034), reach the bytes directly
                     // — class-name keys are parser-produced (UTF-8, no rope).
                     p.decorator_class_name = if !key_str.is_utf16 {
                         Some(key_str.data.slice())
@@ -1830,7 +1809,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         //
         // const binding = await import(`./${process.platform}-${process.arch}.node`);
         //
-        // PORT NOTE: Zig `defer` restores at scope exit; restored manually before each return.
+        // Restored manually before each return.
         let prev_should_fold_typescript_constant_expressions = true;
         p.should_fold_typescript_constant_expressions = true;
 
@@ -1893,7 +1872,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         );
 
         // Copy the call side effect flag over if this is a known target
-        // PORT NOTE: copy the small inline payloads out first so the `match &e_.target.data`
+        // copy the small inline payloads out first so the `match &e_.target.data`
         // borrow doesn't overlap the `e_.can_be_unwrapped_if_unused = …` write below.
         match e_.target.data {
             Data::EIdentifier(ident) => {
@@ -1928,8 +1907,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         p.record_usage(p.exports_ref);
                     }
 
-                    // PORT NOTE: `Scope.parent: ?*Scope` in Zig is `Option<StoreRef<Scope>>` here;
-                    // walk via the safe arena back-pointer.
+                    // Walk `Scope.parent` (`Option<StoreRef<Scope>>`) via the safe
+                    // arena back-pointer.
                     let mut scope_iter: Option<js_ast::StoreRef<js_ast::Scope>> =
                         Some(p.current_scope);
                     while let Some(mut scope) = scope_iter {
@@ -1970,7 +1949,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         {
             let old_ce = p.options.ignore_dce_annotations;
-            // PORT NOTE: Zig `defer` restores at scope exit; do it manually below.
+            // Restored manually below.
             let old_should_fold_typescript_constant_expressions =
                 p.should_fold_typescript_constant_expressions;
             let old_is_control_flow_dead = p.is_control_flow_dead;
@@ -2015,7 +1994,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 p.visit_expr(arg);
             }
 
-            // Restore deferred state (Zig `defer`).
+            // Restore saved state.
             p.options.ignore_dce_annotations = old_ce;
             p.should_fold_typescript_constant_expressions =
                 old_should_fold_typescript_constant_expressions;
@@ -2211,7 +2190,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 p.macro_call_count += 1;
                 // Reborrow via the field-disjoint `Lexer::log()` accessor
                 // so `&p.lexer` and `&mut p.options` split cleanly under
-                // borrowck — Zig held two raw `*Log`.
+                // borrowck.
                 let log = p.lexer.log();
                 let source = p.source;
                 let macro_result = match p
@@ -2264,10 +2243,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         //
         // When we see a hook call, we need to hash it, and then mark a flag so that if
         // it is assigned to a variable, that variable also get's hashed.
-        //
-        // PORT NOTE: `Runtime::Features.server_components` is a `bool` stub; the
-        // full Zig type is `enum { off, client, server }` with `.isServerSide()`. Treat
-        // `true` as server-side until the enum lands.
         if p.options.features.react_fast_refresh
             || p.options.features.server_components.is_server_side()
         {
@@ -2473,9 +2448,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             return;
         }
 
-        // Zig: `std.mem.toBytes(...)` then `bytesToValue(...)` to save/restore. In Rust the struct
-        // is `Copy`/`Clone`, so just copy it.
-        // PORT NOTE: reshaped — toBytes/bytesToValue → plain copy.
+        // The struct is `Copy`, so save/restore is a plain copy.
         let old_fn_or_arrow_data = p.fn_or_arrow_data_visit;
         p.fn_or_arrow_data_visit = FnOrArrowDataVisit {
             is_arrow: true,
@@ -2493,7 +2466,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         p.push_scope_for_visit_pass(js_ast::scope::Kind::FunctionArgs, expr.loc)
             .expect("unreachable");
-        // PERF(port): was arena dupe — profile if it shows up on a hot path
         let dupe: &'a mut [Stmt] = p.arena.alloc_slice_copy(e_.body.stmts.slice());
 
         let args_mut: &mut [G::Arg] = e_.args.slice_mut();
@@ -2508,17 +2480,14 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         p.push_scope_for_visit_pass(js_ast::scope::Kind::FunctionBody, e_.body.loc)
             .expect("unreachable");
 
-        // Zig: `const prev = p.react_refresh.hook_ctx_storage; defer ... = prev; ... = &react_hook_data;`
-        // hook_ctx_storage is a raw NonNull so a stack local is fine; we manually restore `prev`
-        // on every exit path below (Zig used `defer`).
+        // hook_ctx_storage is a raw NonNull so a stack local is fine; we manually
+        // restore `prev` on every exit path below.
         let mut react_hook_data: Option<crate::parser::HookContext> = None;
         let prev_hook_ctx = p.react_refresh.hook_ctx_storage;
         p.react_refresh.hook_ctx_storage = Some(core::ptr::NonNull::from(&mut react_hook_data));
 
-        // TODO(port): Zig `ListManaged(Stmt).fromOwnedSlice(p.arena, dupe)` takes ownership of
-        // the arena slice without copying. bumpalo Vec cannot adopt an existing slice; a custom
-        // arena Vec that can would avoid this copy. Left as a copy with PERF note.
-        // PERF(port): was fromOwnedSlice (no copy) — profile if it shows up on a hot path
+        // bumpalo Vec cannot adopt an existing slice, so this copies.
+        // PERF: profile if it shows up on a hot path (react-refresh only).
         let mut stmts_list = bun_alloc::vec_from_iter_in(dupe.iter().copied(), p.arena);
         let mut temp_opts = PrependTempRefsOpts {
             kind: crate::parser::StmtsKind::FnBody,
@@ -2526,15 +2495,14 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         };
         p.visit_stmts_and_prepend_temp_refs(&mut stmts_list, &mut temp_opts)
             .expect("unreachable");
-        // Zig: `p.arena.free(e_.body.stmts)` — arena-backed, no individual free in Rust.
         p.pop_scope();
         p.pop_scope();
 
         p.fn_only_data_visit.is_inside_async_arrow_fn = old_inside_async_arrow_fn;
         p.fn_or_arrow_data_visit = old_fn_or_arrow_data;
 
-        // Zig: defer p.react_refresh.hook_ctx_storage = prev — restore before any further `p.*`
-        // call so the stack-local pointer never escapes this frame.
+        // Restore before any further `p.*` call so the stack-local pointer
+        // never escapes this frame.
         p.react_refresh.hook_ctx_storage = prev_hook_ctx;
 
         if let Some(hook) = react_hook_data.as_mut() {
@@ -2586,18 +2554,16 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             return;
         }
 
-        // Zig: `const prev = p.react_refresh.hook_ctx_storage; defer ... = prev; ... = &react_hook_data;`
         let mut react_hook_data: Option<crate::parser::HookContext> = None;
         let prev_hook_ctx = p.react_refresh.hook_ctx_storage;
         p.react_refresh.hook_ctx_storage = Some(core::ptr::NonNull::from(&mut react_hook_data));
 
-        // Spec (visitExpr.zig e_function): visitFunc(e_.func, expr.loc) — for function
-        // *expressions* the .function_args scope is pushed at the `function` keyword loc
-        // (parseFn.zig:364), not at open_parens_loc. (s_function correctly uses open_parens_loc.)
+        // For function *expressions* the .function_args scope is pushed at the
+        // `function` keyword loc, not at open_parens_loc. (s_function correctly
+        // uses open_parens_loc.)
         e_.func = p.visit_func(core::mem::take(&mut e_.func), expr.loc);
 
-        // Zig: defer p.react_refresh.hook_ctx_storage = prev — restore now so the stack-local
-        // pointer never escapes this frame.
+        // Restore now so the stack-local pointer never escapes this frame.
         p.react_refresh.hook_ctx_storage = prev_hook_ctx;
 
         // Remove unused function names when minifying (only when bundling is enabled)
@@ -2661,7 +2627,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let decorator_name_from_context = p.decorator_class_name;
         p.decorator_class_name = None;
 
-        // Zig: `p.visitClass(expr.loc, e_, Ref.None)`
         let _ = p.visit_class(expr.loc, &mut e_, Ref::NONE);
 
         // Lower standard decorators for class expressions
diff --git a/src/js_parser/visit/visit_stmt.rs b/src/js_parser/visit/visit_stmt.rs
index fc75eed6996..ff3f0588c7a 100644
--- a/src/js_parser/visit/visit_stmt.rs
+++ b/src/js_parser/visit/visit_stmt.rs
@@ -22,10 +22,9 @@ use bun_ast::StmtNodeList;
 // are arena-owned and outlive the visit pass.
 
 // ─── arena slice ↔ BumpVec helpers ──────────────────────────────────────────
-// `StmtNodeList = StoreSlice<Stmt>` (arena-owned). Zig's `ListManaged.fromOwnedSlice`
-// adopts the existing backing storage; bumpalo Vec cannot, so we copy. The arena
+// `StmtNodeList = StoreSlice<Stmt>` (arena-owned). bumpalo Vec cannot adopt the
+// existing backing storage, so we copy. The arena
 // reclaims both at end-of-parse.
-// PERF(port): was fromOwnedSlice (no copy) — profile if hot.
 #[inline]
 fn stmts_to_list<'a>(arena: &'a bun_alloc::Arena, ptr: StmtNodeList) -> StmtList<'a> {
     bun_alloc::vec_from_iter_in(ptr.iter().copied(), arena)
@@ -35,8 +34,6 @@ fn list_to_stmts<'a>(list: StmtList<'a>) -> StmtNodeList {
     StmtNodeList::from_bump(list)
 }
 
-// Zig: `pub fn VisitStmt(comptime ts, comptime jsx, comptime scan_only) type { return struct { ... } }`
-// — file-split mixin pattern. Round-C lowered `const JSX: JSXTransformType` → `J: JsxT`, so this is
 // a direct `impl P` block. The 30+ per-variant `s_*` helpers are private; only
 // `visit_and_append_stmt` is surfaced. Full draft body preserved under  mod _draft below.
 
@@ -65,8 +62,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let was_after_after_const_local_prefix = p.cur_scope().is_after_const_local_prefix;
         p.cur_scope().is_after_const_local_prefix = true;
 
-        // Zig: `switch (@as(Stmt.Tag, stmt.data))` with `inline else` reflection over @tagName.
-        // PORT NOTE: reshaped for borrowck — `Stmt::Data` is `Copy` (`StoreRef<T>` is a thin
+        // Borrowck: `Stmt::Data` is `Copy` (`StoreRef<T>` is a thin
         // `NonNull`); take a copy of the enum so the StoreRef payload can be DerefMut'd
         // without aliasing the `&mut Stmt` we also pass through. The deref'd `&mut S::*`
         // points into the arena, not into `*stmt`.
@@ -90,7 +86,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 Ok(())
             }
 
-            // Zig: `inline .s_enum, .s_local => |tag| return @field(visitors, @tagName(tag))(p, stmts, stmt, @field(stmt.data, @tagName(tag)), was_after_after_const_local_prefix)`
             StmtData::SEnum(mut sr) => {
                 Self::s_enum(p, stmts, stmt, &mut *sr, was_after_after_const_local_prefix)
             }
@@ -98,7 +93,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 Self::s_local(p, stmts, stmt, &mut *sr, was_after_after_const_local_prefix)
             }
 
-            // Zig: `inline else => |tag| return @field(visitors, @tagName(tag))(p, stmts, stmt, @field(stmt.data, @tagName(tag)))`
             StmtData::SImport(mut sr) => Self::s_import(p, stmts, stmt, &mut *sr),
             StmtData::SExportClause(mut sr) => Self::s_export_clause(p, stmts, stmt, &mut *sr),
             StmtData::SExportFrom(mut sr) => Self::s_export_from(p, stmts, stmt, &mut *sr),
@@ -131,8 +125,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     // ─── visitors ───────────────────────────────────────────────────────────
-    // In Zig these live on a nested `const visitors = struct { ... }`; in Rust they are private
-    // associated fns on this impl so they can see the const-generic feature params.
+    // Private associated fns on this impl so they can see the const-generic feature params.
 
     fn s_import(
         p: &mut Self,
@@ -164,8 +157,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         data: &mut S::ExportEquals,
     ) -> Result<(), Error> {
         // "module.exports = value"
-        // Zig: p.@"module.exports"(stmt.loc) — mapped to `module_exports`
-        // PORT NOTE: Zig evaluates lhs before rhs at the call site; preserve that order
+        // Evaluate lhs before visiting the rhs
         // (`module_exports` builds via `new_expr`, `visit_expr` mutates parser state).
         let lhs = p.module_exports(stmt.loc);
         p.visit_expr(&mut data.value);
@@ -191,7 +183,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 let symbol = p.find_symbol(items[i].alias_loc, name)?;
                 let ref_ = symbol.r#ref;
 
-                // PORT NOTE: reshaped for borrowck — get_ptr borrows options; clone the
+                // reshaped for borrowck — get_ptr borrows options; clone the
                 // small enum payload so `inject_replacement_export(&mut self, ...)` can run.
                 if let Some(entry) = p.options.features.replace_exports.get_ptr(name).cloned() {
                     if !entry.is_replace() {
@@ -314,12 +306,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
             // Truncate `data.items` to `j` by reslicing the arena view.
             data.items.truncate(j);
-
-            // TODO(port): dead branch in Zig — `data.items.len = j;` runs first, so
-            // `j == 0 and data.items.len > 0` is always false. Mirrored bug-for-bug.
-            if j == 0 && data.items.len() > 0 {
-                return Ok(());
-            }
         } else {
             // This is a re-export and the symbols created here are used to reference
             for item in items.iter_mut() {
@@ -382,8 +368,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         stmt: &mut Stmt,
         data: &mut S::ExportDefault,
     ) -> Result<(), Error> {
-        // Zig: defer { if (data.default_name.ref) |ref| p.recordDeclaredSymbol(ref) catch unreachable; }
-        // PORT NOTE: scopeguard can't borrow `p` across the body; restructured to a tail
+        // scopeguard can't borrow `p` across the body; restructured to a tail
         // closure invoked at every return site below.
         macro_rules! record_on_exit {
             () => {
@@ -404,7 +389,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
         }
 
-        // Zig: defer { p.is_control_flow_dead = orig_dead; }
         macro_rules! restore_dead {
             () => {
                 p.is_control_flow_dead = orig_dead;
@@ -536,7 +520,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             value: Some(*expr),
                         },
                     );
-                    // PERF(port): was assume_capacity
                     stmts.push(p.s(
                         S::Local {
                             decls,
@@ -550,7 +533,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         name: data.default_name,
                         ..Default::default()
                     }));
-                    // PERF(port): was assume_capacity
                     stmts.push(p.s(
                         S::ExportClause {
                             items: bun_ast::StoreSlice::new_mut(items),
@@ -586,7 +568,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
 
             js_ast::StmtOrExpr::Stmt(s2) => {
-                // PORT NOTE: reshaped for borrowck — `s2` borrows from `data.value`; copy
+                // reshaped for borrowck — `s2` borrows from `data.value`; copy
                 // `s2.loc`/`s2.data` (both Copy) so we can mutate `data.value` below.
                 let s2_loc = s2.loc;
                 let s2_data = s2.data;
@@ -627,8 +609,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         }
 
                         // Capture the original function name before any `mem::take` below resets
-                        // `func.func` to its default. The Zig spec copies `func.func` by value into
-                        // the E.Function expr, leaving `func.func.name` intact for the
+                        // `func.func` to its default; the name is needed for the
                         // react_fast_refresh temp-var emission that follows.
                         let func_name = func.func.name;
 
@@ -776,9 +757,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             stmts.push(*stmt);
                         }
 
-                        // if (func.func.name != null and func.func.name.?.ref != null) {
-                        //     stmts.append(p.keepStmtSymbolName(func.func.name.?.loc, func.func.name.?.ref.?, name)) catch unreachable;
-                        // }
                         p.react_refresh.hook_ctx_storage = prev;
                         restore_dead!();
                         record_on_exit!();
@@ -874,8 +852,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                         }
 
                         if p.options.features.server_components.wraps_exports() {
-                            // TODO(port): Zig spec mutates `data.value` *after* pushing `stmt` —
-                            // mirrored bug-for-bug. The class expr wrap likely belongs before push.
+                            // `data.value` is mutated *after* pushing `stmt`; the pushed
+                            // stmt still observes the write because `data` is an arena
+                            // backref shared with the pushed copy.
                             let class_expr =
                                 p.new_expr(core::mem::take(&mut class.class), stmt.loc);
                             data.value = js_ast::StmtOrExpr::Expr(
@@ -922,10 +901,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             p.is_control_flow_dead = true;
         }
 
-        // Spec (visitStmt.zig:517-520) unconditionally points p.react_refresh.hook_ctx_storage
-        // at this stack-local before visit_func and defer-restores it. Field is now
-        // `Option<NonNull<_>>` (Copy) matching Zig's `?*?HookContext`, so save/set/restore
-        // are trivial; no `'a` constraint to fight.
+        // Unconditionally point p.react_refresh.hook_ctx_storage at this stack-local
+        // before visit_func and restore it afterwards. Field is `Option<NonNull<_>>`
+        // (Copy), so save/set/restore are trivial; no `'a` constraint to fight.
         let mut react_hook_data: Option<crate::parser::HookContext> = None;
         let prev_hook_storage = p.react_refresh.hook_ctx_storage;
         p.react_refresh.hook_ctx_storage = Some(core::ptr::NonNull::from(&mut react_hook_data));
@@ -954,7 +932,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 .enclosing_namespace_arg_ref
                 .expect("infallible: in namespace");
             stmts.reserve(3);
-            stmts.push(*stmt); // PERF(port): was assume_capacity
+            stmts.push(*stmt);
             let func_name = data.func.name.expect("infallible: name checked");
             stmts.push(Stmt::assign(
                 p.new_expr(
@@ -970,10 +948,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     func_name.ref_.expect("infallible: ref bound"),
                     func_name.loc,
                 ),
-            )); // PERF(port): was assume_capacity
+            ));
         } else if !mark_as_dead {
             if remove_overwritten {
-                // Zig: defer { ... } — restore on early return.
+                // restore on early return.
                 p.react_refresh.hook_ctx_storage = prev_hook_storage;
                 if mark_as_dead {
                     p.is_control_flow_dead = original_is_dead;
@@ -1047,9 +1025,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
 
             if p.current_scope == p.module_scope {
-                // PORT NOTE: defer-vs-drop-scope — restore hook_ctx_storage/is_control_flow_dead
+                // defer-vs-drop-scope — restore hook_ctx_storage/is_control_flow_dead
                 // before propagating Err so the stack-local `react_hook_data` ptr is never left in
-                // p.react_refresh on the OOM path (Zig defer covers all exits).
+                // p.react_refresh on the OOM path.
                 rr = p.handle_react_refresh_register(
                     stmts,
                     original_name,
@@ -1059,9 +1037,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             }
         }
 
-        // Zig: defer p.react_refresh.hook_ctx_storage = prev;
         p.react_refresh.hook_ctx_storage = prev_hook_storage;
-        // Zig: defer { if (mark_as_dead) p.is_control_flow_dead = original_is_dead; }
         if mark_as_dead {
             p.is_control_flow_dead = original_is_dead;
         }
@@ -1149,7 +1125,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             ));
         }
 
-        // Zig: defer { if (mark_as_dead) p.is_control_flow_dead = original_is_dead; }
         if mark_as_dead {
             p.is_control_flow_dead = original_is_dead;
         }
@@ -1176,7 +1151,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         } else {
             p.visit_decls::<true>(data.decls.slice_mut(), was_const)
         };
-        // Spec (visitStmt.zig:724-727): drop the whole statement when every decl was
+        // Drop the whole statement when every decl was
         // eliminated; otherwise we'd emit an empty `var;`/`let;`/`const;`.
         if data.decls.len_u32() > 0 && new_len == 0 {
             return Ok(());
@@ -1192,7 +1167,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             .expect("infallible: in namespace"),
                     );
                     // TODO: is it necessary to lowerAssign? why does esbuild do it _most_ of the time?
-                    // PORT NOTE: ToExprWrapper is Copy; pass by value to avoid borrowing `*p`
+                    // ToExprWrapper is Copy; pass by value to avoid borrowing `*p`
                     // across `p.s(...)`. The `*mut P` ctx is derived from the live `&mut Self`
                     // here so its provenance is a child of the active Unique borrow.
                     let wrapper = p.to_expr_wrapper_namespace;
@@ -1426,8 +1401,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         p.visit_expr(&mut data.value);
 
-        // Zig: defer p.stmt_expr_value = .{ .e_missing = .{} };
-        // PORT NOTE: restructured — restored at every return below.
+        // `p.stmt_expr_value` is reset to EMissing at every return below.
         macro_rules! restore_stmt_expr {
             () => {
                 p.stmt_expr_value = js_ast::ExprData::EMissing(E::Missing {});
@@ -1453,7 +1427,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     if to_convert != u32::MAX {
                         p.commonjs_named_exports_needs_conversion = u32::MAX;
                         'convert: {
-                            // PORT NOTE: reshaped for borrowck — copy StoreRef so DerefMut
+                            // reshaped for borrowck — copy StoreRef so DerefMut
                             // points into the arena, freeing `&mut data.value`.
                             let js_ast::ExprData::EBinary(mut bin_ref) = data.value.data else {
                                 break 'convert;
@@ -1537,8 +1511,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             }
                         }
                     } else if p.commonjs_replacement_stmts.len() > 0 {
-                        // PORT NOTE: Zig directly swaps backing storage; commonjs_replacement_stmts
-                        // is `StmtNodeList = StoreSlice<Stmt>` here, so copy then clear.
+                        // `commonjs_replacement_stmts` is `StmtNodeList = StoreSlice<Stmt>`
+                        // here, so copy then clear.
                         let repl: &[Stmt] = p.commonjs_replacement_stmts.slice();
                         if stmts.is_empty() {
                             *stmts = bun_alloc::vec_from_iter_in(repl.iter().copied(), p.arena);
@@ -1925,7 +1899,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         {
             p.push_scope_for_visit_pass(js_ast::scope::Kind::Block, stmt.loc)
                 .expect("unreachable");
-            // Zig: defer p.popScope(); — restructured: pop at end of block
             let _ = p.visit_for_loop_init(data.init, true);
             p.visit_expr(&mut data.value);
             data.body = p.visit_loop_body(data.body);
@@ -1973,7 +1946,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     ) -> Result<(), Error> {
         p.push_scope_for_visit_pass(js_ast::scope::Kind::Block, stmt.loc)
             .expect("unreachable");
-        // Zig: defer p.popScope();
         let _ = p.visit_for_loop_init(data.init, true);
         p.visit_expr(&mut data.value);
         data.body = p.visit_loop_body(data.body);
@@ -2202,7 +2174,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
 
         p.record_declared_symbol(data.name.ref_.expect("infallible: ref bound"));
         p.push_scope_for_visit_pass(js_ast::scope::Kind::Entry, stmt.loc)?;
-        // Zig: defer p.popScope(); — moved to end (no early returns).
         p.record_declared_symbol(data.arg);
 
         // Scan ahead for any variables inside this namespace. This must be done
@@ -2365,7 +2336,6 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let mut value_stmts: StmtList<'a> = BumpVec::with_capacity_in(value_exprs.len(), p.arena);
         // Generate statements from expressions
         for expr in value_exprs.iter() {
-            // PERF(port): was assume_capacity
             value_stmts.push(p.s(
                 S::SExpr {
                     value: *expr,
diff --git a/src/js_parser_jsc/Macro.rs b/src/js_parser_jsc/Macro.rs
index 4bd3672d9e5..7daa679604e 100644
--- a/src/js_parser_jsc/Macro.rs
+++ b/src/js_parser_jsc/Macro.rs
@@ -17,9 +17,8 @@ use bun_resolver::package_json::{
     MacroImportReplacementMap as MacroRemapEntry, MacroMap as MacroRemap,
 };
 
-// PORT NOTE: Zig spec aliases `const js = bun.jsc.C;` (Macro.zig:642) — the
-// C-API surface is intentionally `#[deprecated]` upstream but is the spec'd
-// call path for `JSObjectCallAsFunctionReturnValueHoldingAPILock`.
+// The C-API surface is intentionally `#[deprecated]` upstream but is the
+// call path used for `JSObjectCallAsFunctionReturnValueHoldingAPILock`.
 use crate::expr_jsc::ExprJsc;
 use bun_jsc::js_property_iterator::JSPropertyIteratorOptions;
 use bun_jsc::virtual_machine::{
@@ -44,9 +43,7 @@ pub(crate) fn is_macro_path(str: &[u8]) -> bool {
 // MacroContext
 // ══════════════════════════════════════════════════════════════════════════
 
-// PORT NOTE: Zig stores `*Resolver` / `*DotEnv.Loader` and copies the
-// `MacroRemap` hash-map header by value (which aliases the same backing
-// storage). Rust models all three as raw pointers because the referents live
+// All three are modelled as raw pointers because the referents live
 // inside the owning `Transpiler` and are also reachable through other aliases
 // (`Transpiler.resolver`, `Transpiler.env`, `Transpiler.options`); a `&'a mut`
 // here would forbid that aliasing under stacked-borrows. The `'static`
@@ -58,11 +55,8 @@ pub struct MacroContext {
     pub macros: MacroMap,
     pub remap: bun_ptr::BackRef<MacroRemap>,
     pub javascript_object: JSValue,
-    /// PORT NOTE: Zig threads `default_allocator` (mimalloc, process-lifetime)
-    /// through `Runner::run` → `Run.allocator`; the slices it backs (property
-    /// keys / UTF-16 string data / `from_blob` JSON sub-parse) are never
-    /// individually freed and outlive the call frame. The Rust AST takes
-    /// lifetime-erased `&[u8]` arena slices, so we own the backing arena here
+    /// The AST takes lifetime-erased `&[u8]` arena slices (property keys /
+    /// UTF-16 string data / `from_blob` JSON sub-parse), so we own the backing arena here
     /// — `MacroContext` is stored in the long-lived `Transpiler` and outlives
     /// every `Expr` it produces (the parser splices the result into the AST and
     /// prints it before the `Transpiler` drops).
@@ -83,7 +77,7 @@ pub(crate) type MacroMap = ArrayHashMap<i32, Macro>;
 impl MacroContext {
     pub fn get_remap(&self, path: &[u8]) -> Option<&MacroRemapEntry> {
         // `remap` is a `BackRef` into `Transpiler.options`, which outlives
-        // every `MacroContext` (see struct PORT NOTE).
+        // every `MacroContext` (see struct comment).
         let remap = self.remap.get();
         if remap.is_empty() {
             return None;
@@ -125,7 +119,7 @@ impl MacroContext {
 
         debug_assert!(!is_macro_path(import_record_path_without_macro_prefix));
 
-        // SAFETY: `resolver` outlives `self` (see struct PORT NOTE); uniquely
+        // SAFETY: `resolver` outlives `self` (see struct comment); uniquely
         // accessed for the duration of this resolve call.
         let resolver = unsafe { &mut *self.resolver };
 
@@ -171,10 +165,7 @@ impl MacroContext {
                     return Err(e);
                 }
             };
-            // PORT NOTE: Zig captures the resolved primary path's `.text` and
-            // hands the slice to `Macro.init`/`loadMacroEntryPoint`, which
-            // copies into a buffer before the borrow ends. The Rust resolver's
-            // `Result` owns its path strings via the global `DirnameStore`
+            // The resolver's `Result` owns its path strings via the global `DirnameStore`
             // (lifetime-erased `&'static [u8]`), so dropping `resolve_result`
             // does not invalidate `text`.
             break 'brk resolve_result.path_pair.primary.text;
@@ -202,7 +193,6 @@ impl MacroContext {
             ) {
                 Ok(m) => m,
                 Err(e) => {
-                    // Zig: `Macro{ .resolver = undefined, .disabled = true }`
                     *macro_entry.value_ptr = Macro::disabled_sentinel();
                     return Err(e);
                 }
@@ -211,8 +201,7 @@ impl MacroContext {
         }
         let _flush_guard = Output::flush_guard();
 
-        // PORT NOTE: reshaped for borrowck — Zig copies the Macro by value out
-        // of the map. We snapshot the small POD fields we need (`disabled`,
+        // Borrowck: snapshot the small POD fields we need (`disabled`,
         // `vm`) so the macro_entry borrow can be released.
         let macro_disabled = macro_entry.value_ptr.disabled;
         let macro_vm = macro_entry.value_ptr.vm;
@@ -220,7 +209,7 @@ impl MacroContext {
         if macro_disabled {
             return Ok(caller);
         }
-        // SAFETY: `Some` for every non-disabled Macro; see `Macro` PORT NOTE.
+        // SAFETY: `Some` for every non-disabled Macro; see `Macro` struct comment.
         let vm = macro_vm
             .expect("Macro.vm accessed on disabled sentinel")
             .as_ptr();
@@ -230,12 +219,8 @@ impl MacroContext {
         // SAFETY: `event_loop()` returns a self-pointer into `*vm`.
         unsafe { (*(*vm).event_loop()).ensure_waker() };
 
-        // PORT NOTE: Zig builds `Wrapper { args: ArgsTuple, ret }` and calls
-        // `vm.runWithAPILock(Wrapper, &wrapper, Wrapper.call)` which is just
-        // `holdAPILock(ctx, fn(ctx))`. The Rust `run_with_api_lock` already
-        // takes a closure, so the wrapper struct collapses into captures.
         let javascript_object = self.javascript_object;
-        // PORT NOTE: reshaped for borrowck — `self.bump` is shared-borrowed for
+        // reshaped for borrowck — `self.bump` is shared-borrowed for
         // the closure while `self.macros` was already released above; capture
         // as a raw pointer so the closure does not extend `&mut self`.
         // Lazy-init the backing arena now that a macro is actually being
@@ -279,8 +264,7 @@ pub(crate) fn __bun_macro_context_init(
     // SAFETY: every caller of `js_parser::Macro::MacroContext::init<T>` passes a
     // `&mut bun_bundler::Transpiler<'_>`; the lifetime parameter is erased at
     // runtime so reading it as `'static` is layout-identical. The boxed state
-    // is leaked for the long-lived `vm.transpiler` instance (Zig backed it
-    // with `default_allocator`, process-lifetime) — but callers that run on a
+    // is leaked for the long-lived `vm.transpiler` instance — but callers that run on a
     // short-lived bytewise-cloned `Transpiler` (e.g.
     // `RuntimeTranspilerStore::TranspilerJob::run`) MUST pair this with
     // `__bun_macro_context_deinit` or the `Box<MacroContext>` (and, if a macro
@@ -356,7 +340,7 @@ pub(crate) fn __bun_macro_context_get_remap(
     // SAFETY: `data` is the `Box<MacroContext>` allocated in `init` above; the
     // remap table lives in `Transpiler.options` which outlives every parse, so
     // the `'static` borrow is sound for callers that drop it before the
-    // `Transpiler` does (matches the Zig by-value copy of the map header).
+    // `Transpiler` does.
     let inner = unsafe { &*data.cast::<MacroContext>() };
     inner.get_remap(path).map(|e| {
         // SAFETY: `e` borrows an entry in the remap table owned by
@@ -374,16 +358,14 @@ pub(crate) fn __bun_macro_context_get_remap(
 // Macro
 // ══════════════════════════════════════════════════════════════════════════
 
-// PORT NOTE: Zig stores `*Resolver` / `*VirtualMachine` and leaves them `undefined`
-// for the disabled sentinel (`Macro{ .resolver = undefined, .disabled = true }`).
-// Rust references cannot be uninitialised, so both are carried as `Option<NonNull<_>>`;
+// Both are carried as `Option<NonNull<_>>`;
 // they are `Some` for every live macro and `None` only when `disabled == true`, which
 // is checked before any access (see `MacroContext::call`).
 pub struct Macro {
-    // PORT NOTE: `Resolver<'a>` carries a borrow lifetime, but `Macro` is stored
+    // `Resolver<'a>` carries a borrow lifetime, but `Macro` is stored
     // by value in a `MacroMap` keyed by hash and outlives any single call frame.
-    // The Zig original stores a raw `*Resolver`; `NonNull` already erases borrow
-    // tracking, so `'static` here is the lifetime-erased moral equivalent.
+    // `NonNull` erases borrow tracking, so `'static` here is the lifetime-erased
+    // moral equivalent of a raw pointer.
     pub resolver: Option<NonNull<Resolver<'static>>>,
     pub vm: Option<NonNull<VirtualMachine>>,
 
@@ -400,7 +382,6 @@ impl Default for Macro {
 impl Macro {
     /// Sentinel stored in the `MacroMap` when `Macro::init` fails, so subsequent
     /// calls with the same hash short-circuit instead of retrying the load.
-    /// Mirrors Zig's `Macro{ .resolver = undefined, .disabled = true }`.
     fn disabled_sentinel() -> Self {
         Macro {
             resolver: None,
@@ -411,12 +392,11 @@ impl Macro {
     }
 
     /// Unwrap the VM handle. Only valid when `!self.disabled` — `MacroContext::call`
-    /// returns early on `disabled` before any `vm()` access, mirroring Zig where the
-    /// raw pointer is left `undefined` and never dereferenced on that path.
+    /// returns early on `disabled` before any `vm()` access.
     #[inline]
     pub fn vm(&self) -> *mut VirtualMachine {
         debug_assert!(!self.disabled);
-        // SAFETY-adjacent: `Some` for every non-disabled Macro; see struct PORT NOTE.
+        // SAFETY-adjacent: `Some` for every non-disabled Macro; see struct comment.
         self.vm
             .expect("Macro.vm accessed on disabled sentinel")
             .as_ptr()
@@ -432,16 +412,12 @@ impl Macro {
         specifier: &[u8],
         hash: i32,
     ) -> Result<Macro, Error> {
-        // TODO(port): narrow error set
         let (vm, is_new_vm): (*mut VirtualMachine, bool) = if VirtualMachine::is_loaded() {
             (VirtualMachine::get_mut_ptr(), false)
         } else {
-            // PORT NOTE: Zig saved/restored `resolver.opts.transform_options`
-            // across this block because `VirtualMachine.init` (via
-            // `Config.configureTransformOptionsForBunVM`) mutates the *passed*
-            // `args`. In the Rust port the resolver's forward-decl
-            // `BundleOptions` does not carry `transform_options` (the canonical
-            // owner is the bundler's `BundleOptions<'a>`), and
+            // The resolver's forward-decl `BundleOptions` does not carry
+            // `transform_options` (the canonical owner is the bundler's
+            // `BundleOptions<'a>`), and
             // `RuntimeHooks::init_runtime_state` builds the macro VM's
             // transpiler from a fresh `TransformOptions` value rather than
             // borrowing the caller's, so there is nothing to mutate-and-restore
@@ -522,7 +498,7 @@ pub enum MacroError {
     OutOfMemory,
     #[error(transparent)]
     ToJs(#[from] ToJSError),
-    // PORT NOTE: `JsError` does not impl `std::error::Error` in the stub surface,
+    // `JsError` does not impl `std::error::Error` in the stub surface,
     // so `#[error(transparent)]` / `#[from]` (which generates a `source()` requiring
     // `Error`) are unavailable; format via Debug + manual `From` instead.
     #[error("{0:?}")]
@@ -555,10 +531,7 @@ pub struct Run<'a> {
     pub function_name: &'a [u8],
     pub macro_: &'a Macro,
     pub global: &'a JSGlobalObject,
-    // PORT NOTE: Zig carried `std.mem.Allocator param` (always
-    // `default_allocator`, mimalloc, process-lifetime — slices backing
-    // `E.String` data / property keys are never freed). The Rust AST uses
-    // arena-owned slices (`EString::init` lifetime-erases its borrow), so
+    // The AST uses arena-owned slices (`EString::init` lifetime-erases its borrow), so
     // `coerce` needs a bump arena to back property keys / UTF-16 string data /
     // `from_blob` JSON sub-parsing. The arena is *borrowed* from
     // `MacroContext` (stored long-term in the `Transpiler`) so the slices
@@ -623,7 +596,7 @@ impl<'a> Run<'a> {
 
     pub fn run(&mut self, value: JSValue) -> Result<Expr, MacroError> {
         use ConsoleObject::formatter::Tag as T;
-        // PORT NOTE: `Tag::get` returns `TagResult { tag: TagPayload, .. }`;
+        // `Tag::get` returns `TagResult { tag: TagPayload, .. }`;
         // collapse the payload to its discriminant via `.tag()`.
         match T::get(value, self.global)?.tag.tag() {
             T::Error => self.coerce(T::Error, value),
@@ -644,8 +617,7 @@ impl<'a> Run<'a> {
                 self.log.add_error_fmt(
                     Some(self.source),
                     self.caller.loc,
-                    // PORT NOTE: `JSType` derives `Debug` (not `IntoStaticStr`);
-                    // Zig's `@tagName` ≈ `{:?}` here.
+                    // `JSType` derives `Debug` (not `IntoStaticStr`).
                     format_args!(
                         "cannot coerce {} ({:?}) to Bun's AST. Please return a simpler type",
                         bstr::BStr::new(name),
@@ -657,11 +629,7 @@ impl<'a> Run<'a> {
         }
     }
 
-    // PORT NOTE: Zig dispatched on `comptime tag`; that requires
-    // `Tag: core::marker::ConstParamTy`, which the upstream enum does not
-    // derive. Reshaped to a runtime `tag` param — every call site in `run`
-    // already matches once, so the comptime monomorphization was redundant.
-    // PERF(port): was comptime monomorphization — profile if it shows up on a hot path.
+    // Runtime `tag` param — every call site in `run` already matches once.
     pub fn coerce(
         &mut self,
         tag: ConsoleObject::formatter::Tag,
@@ -745,7 +713,6 @@ impl<'a> Run<'a> {
                 let mut iter = JSArrayIterator::init(value, self.global)?;
 
                 // Process all array items
-                // PERF(port): was allocator.alloc(Expr, iter.len) — profile if it shows up on a hot path
                 let mut array = ExprNodeList::init_capacity(iter.len as usize);
                 // (errdefer free deleted — drops on `?`)
                 let expr = Expr::init(
@@ -767,7 +734,7 @@ impl<'a> Run<'a> {
                     i += 1;
                 }
 
-                // PORT NOTE: reshaped for borrowck — `Expr.data.e_array` is a
+                // reshaped for borrowck — `Expr.data.e_array` is a
                 // `StoreRef` (raw arena ptr) so re-borrow it after the `run`
                 // recursion releases `self`.
                 if let ExprData::EArray(mut e_array) = expr.data {
@@ -814,7 +781,7 @@ impl<'a> Run<'a> {
                 while let Some(prop) = object_iter.next()? {
                     let object_value = self.run(object_iter.value)?;
 
-                    // PORT NOTE: `EString::init` lifetime-erases its borrow
+                    // `EString::init` lifetime-erases its borrow
                     // (arena-owned per the parser's `Str` convention). Copy the
                     // key into the `MacroContext` bump arena so it outlives the
                     // temporary `to_owned_slice()` Vec and the returned `Expr`.
@@ -838,18 +805,6 @@ impl<'a> Run<'a> {
 
             T::JSON => {
                 self.is_top_level = false;
-                // if (console_tag.cell == .JSDate) {
-                //     // in the code for printing dates, it never exceeds this amount
-                //     var iso_string_buf = this.allocator.alloc(u8, 36) catch unreachable;
-                //     var str = jsc.ZigString.init("");
-                //     value.jsonStringify(this.global, 0, &str);
-                //     var out_buf: []const u8 = std.fmt.bufPrint(iso_string_buf, "{}", .{str}) catch "";
-                //     if (out_buf.len > 2) {
-                //         // trim the quotes
-                //         out_buf = out_buf[1 .. out_buf.len - 1];
-                //     }
-                //     return Expr.init(E.New, E.New{.target = Expr.init(E.Dot{.target = E}) })
-                // }
             }
 
             T::Integer => {
@@ -872,24 +827,16 @@ impl<'a> Run<'a> {
                 let bun_str = bun_core::OwnedString::new(value.to_bun_string(self.global)?);
 
                 // encode into utf16 so the printer escapes the string correctly
-                // PERF(port): was allocator.alloc(u16, len) — profile if it shows up on a hot path
-                //
-                // Zig went through `bun.String.encodeInto(out, .utf16le)`
-                // (string.zig:630), which lives in `bun_runtime::webcore::
-                // encoding` (forward dep from here). For the fixed
-                // `.utf16le` target the body is just: UTF-16 → memcpy,
-                // Latin-1 → byte-widen. JS-sourced WTF strings are never
-                // UTF-8-tagged (the Zig path `@panic`ed on that anyway),
-                // so inline the two arms.
+                // UTF-16 → memcpy, Latin-1 → byte-widen. JS-sourced WTF
+                // strings are never UTF-8-tagged, so two arms suffice.
                 let utf16_bytes: Vec<u16> = if bun_str.is_utf16() {
                     bun_str.utf16().to_vec()
                 } else {
                     bun_str.latin1().iter().map(|&b| b as u16).collect()
                 };
-                // PORT NOTE: `E::EString::init_utf16` lifetime-erases the slice
+                // `E::EString::init_utf16` lifetime-erases the slice
                 // (arena-owned per the parser's `Str` convention). Copy into
-                // the `MacroContext` bump arena — Zig used `this.allocator`
-                // (`default_allocator`, process-lifetime).
+                // the `MacroContext` bump arena.
                 let arena_slice: &[u16] = self.bump.alloc_slice_copy(&utf16_bytes);
                 return Ok(Expr::init(
                     E::EString::init_utf16(arena_slice),
@@ -918,7 +865,7 @@ impl<'a> Run<'a> {
                 if rejected
                     || promise_result.is_error()
                     || promise_result.is_aggregate_error(self.global)
-                    // PORT NOTE: `JSGlobalObject::vm()` returns `&VM`;
+                    // `JSGlobalObject::vm()` returns `&VM`;
                     // `is_exception` takes `*mut VM` (FFI passthrough). The
                     // C++ side never writes through it.
                     || promise_result
@@ -943,7 +890,7 @@ impl<'a> Run<'a> {
         self.log.add_error_fmt(
             Some(self.source),
             self.caller.loc,
-            // PORT NOTE: `JSType` derives `Debug` (not `IntoStaticStr`).
+            // `JSType` derives `Debug` (not `IntoStaticStr`).
             format_args!(
                 "cannot coerce {:?} to Bun's AST. Please return a simpler type",
                 value.js_type(),
@@ -971,13 +918,11 @@ impl Runner {
             );
         }
 
-        // PORT NOTE: Zig `exception_holder = jsc.ZigException.Holder.init();` —
-        // the holder is never read in this body (legacy from an earlier
+        // The exception holder is never read in this body (legacy from an earlier
         // exception-reporting path); a thread-local sentinel suffices.
         EXCEPTION_HOLDER.with(|h| h.set(true));
 
-        // PORT NOTE: Zig's `defer { for js_args[..n] |a| a.unprotect();
-        // allocator.free(js_args); }` becomes an RAII guard that *owns* the
+        // An RAII guard *owns* the
         // `Vec<JSValue>` + processed count. All mutation goes through the
         // guard's fields so there is no aliasing of a raw pointer with later
         // direct writes (the previous `*mut Vec` capture popped its
@@ -1053,11 +998,9 @@ impl Runner {
             js_args.args[last] = javascript_object;
         }
 
-        // PORT NOTE: Zig stashes the call args + result in threadlocals so the
-        // `extern "C" fn()` trampoline (no userdata) can reach them, then calls
-        // `Bun__startMacro(&call, global)`. Rust round-trips through a
-        // threadlocal `*mut c_void` to a stack `CallData` instead — `CallArgs`
-        // is a tuple of borrowed refs that cannot live in a `thread_local!`.
+        // The `extern "C" fn()` trampoline (no userdata) reaches the call args +
+        // result through a threadlocal `*mut c_void` pointing at a stack `CallData`
+        // — `CallArgs` is a tuple of borrowed refs that cannot live in a `thread_local!`.
         thread_local! {
             static CALL_STATE: Cell<*mut c_void> = const { Cell::new(core::ptr::null_mut()) };
         }
@@ -1105,11 +1048,10 @@ impl Runner {
 
         jsc::mark_binding();
         CALL_STATE.with(|s| s.set((&raw mut data).cast::<c_void>()));
-        // SAFETY: `call` only reads CALL_STATE which we just set. Spec
-        // Macro.zig:581 passes the raw `vm.global: *JSGlobalObject` field
-        // directly — read it via raw-ptr field access (NOT the `&`-returning
-        // `.global()` accessor) so the `*mut` provenance is preserved across
-        // FFI.
+        // SAFETY: `call` only reads CALL_STATE which we just set. The raw
+        // `vm.global: *JSGlobalObject` field is read via raw-ptr field access
+        // (NOT the `&`-returning `.global()` accessor) so the `*mut` provenance
+        // is preserved across FFI.
         unsafe {
             Bun__startMacro(
                 call as *const c_void,
@@ -1125,8 +1067,8 @@ unsafe extern "C" {
     fn Bun__startMacro(function: *const c_void, global: *mut c_void);
 }
 
-/// Zig: `Expr.fromBlob` (`src/js_parser/ast/Expr.zig`). Lives here, not on
-/// `bun_ast::Expr`, because it parses JSON via `bun_parsers` — `bun_ast` is a
+/// Lives here, not on `bun_ast::Expr`, because it parses JSON via `bun_parsers`
+/// — `bun_ast` is a
 /// leaf below both. Only call site is the macro `Response`/`Blob` arm above.
 fn expr_from_blob(
     bytes: &[u8],
@@ -1208,5 +1150,3 @@ fn expr_from_blob(
         loc,
     ))
 }
-
-// ported from: src/js_parser_jsc/Macro.zig
diff --git a/src/js_parser_jsc/expr_jsc.rs b/src/js_parser_jsc/expr_jsc.rs
index f869958bcf2..12e6fb8b3a2 100644
--- a/src/js_parser_jsc/expr_jsc.rs
+++ b/src/js_parser_jsc/expr_jsc.rs
@@ -143,8 +143,23 @@ pub(crate) fn object_to_js(
     Ok(obj)
 }
 
-/// `E.String.toJS` (src/js_parser_jsc/expr_jsc.zig:79).
-///
+/// Serialize UTF-8 bytes to a JS string, transcoding to UTF-16 only when the
+/// bytes are not pure ASCII (`to_utf16_alloc` returns `Ok(None)` for
+/// pure-ASCII, in which case the 8-bit Latin-1 form is kept).
+fn utf8_bytes_to_js(bytes: &[u8], global: &JSGlobalObject) -> Result<JSValue, ToJSError> {
+    let utf16 = strings::to_utf16_alloc(bytes, false, false).map_err(|_| ToJSError::OutOfMemory)?;
+    if let Some(utf16) = utf16 {
+        let (mut out, chars) = BunString::create_uninitialized_utf16(utf16.len());
+        chars.copy_from_slice(&utf16);
+        bun_string_jsc::transfer_to_js(&mut out, global).map_err(js_err)
+    } else {
+        let (mut out, chars) = BunString::create_uninitialized_latin1(bytes.len());
+        chars.copy_from_slice(bytes);
+        bun_string_jsc::transfer_to_js(&mut out, global).map_err(js_err)
+    }
+}
+
+/// `E.String` → JS string conversion.
 /// Stamps the body for both `EString` nominal types: the full T4
 /// `bun_ast::E::String` (used by `data_to_js` / macros) and the
 /// value-subset T2 `bun_ast::E::EString` (used by the YAML / JSON5
@@ -154,34 +169,29 @@ pub(crate) fn object_to_js(
 macro_rules! impl_string_to_js {
     ($name:ident, $ty:ty) => {
         pub fn $name(s: &$ty, global: &JSGlobalObject) -> Result<JSValue, ToJSError> {
-            // TODO(port): Zig mutates `s` via `resolveRopeIfNeeded(allocator)`;
-            // callers only have `&` and there is no bump arena in scope here.
-            // Either thread a bump arena + interior-mut rope or resolve ropes
-            // before reaching here. For now, assert non-rope (current callers
-            // feed resolved literals).
-            debug_assert!(
-                s.next.is_none(),
-                "string_to_js: rope EString reached without resolveRopeIfNeeded; thread a bump arena"
-            );
+            // Callers here only have `&s` and no bump arena, so flatten the
+            // rope into a temporary heap buffer and serialize from that
+            // instead. Ropes are only ever built from UTF-8 parts
+            // (`resolve_rope_if_needed` is a no-op for UTF-16).
+            if s.next.is_some() && s.is_utf8() {
+                let mut bytes: Vec<u8> = Vec::with_capacity(s.rope_len as usize);
+                bytes.extend_from_slice(s.slice8());
+                let mut next = s.next;
+                while let Some(part) = next {
+                    let part = part.get();
+                    bytes.extend_from_slice(&part.data);
+                    next = part.next;
+                }
+                return utf8_bytes_to_js(&bytes, global);
+            }
+
             if !s.is_present() {
                 let emp = BunString::EMPTY;
                 return bun_string_jsc::to_js(&emp, global).map_err(js_err);
             }
 
             if s.is_utf8() {
-                // `to_utf16_alloc` returns `Ok(None)` for pure-ASCII (keep 8-bit form).
-                let utf16 = strings::to_utf16_alloc(s.slice8(), false, false)
-                    .map_err(|_| ToJSError::OutOfMemory)?;
-                if let Some(utf16) = utf16 {
-                    let (mut out, chars) = BunString::create_uninitialized_utf16(utf16.len());
-                    chars.copy_from_slice(&utf16);
-                    bun_string_jsc::transfer_to_js(&mut out, global).map_err(js_err)
-                } else {
-                    let bytes = s.slice8();
-                    let (mut out, chars) = BunString::create_uninitialized_latin1(bytes.len());
-                    chars.copy_from_slice(bytes);
-                    bun_string_jsc::transfer_to_js(&mut out, global).map_err(js_err)
-                }
+                utf8_bytes_to_js(s.slice8(), global)
             } else {
                 let utf16 = s.slice16();
                 let (mut out, chars) = BunString::create_uninitialized_utf16(utf16.len());
@@ -193,5 +203,3 @@ macro_rules! impl_string_to_js {
 }
 impl_string_to_js!(string_to_js, E::String);
 impl_string_to_js!(value_string_to_js, bun_ast::E::EString);
-
-// ported from: src/js_parser_jsc/expr_jsc.zig
diff --git a/src/js_printer/lib.rs b/src/js_printer/lib.rs
index e1dc61ab68d..f85dde30ad1 100644
--- a/src/js_printer/lib.rs
+++ b/src/js_printer/lib.rs
@@ -1,14 +1,10 @@
 //! JavaScript printer — translates the AST back to source text.
-//! Port of src/js_printer/js_printer.zig.
 //!
 //! The `Printer<'a, W, ...>` struct and its full method surface
 //! (`print_expr`, `print_stmt`, `print_binding`, `print_property`, …)
 //! compile against `bun_ast::{e,s,b,g,op,expr,stmt}`. The top-level
 //! `print` / `print_with_writer{,_and_platform}` / `print_common_js` /
-//! `get_source_map_builder` driver fns live at crate root. Remaining gaps
-//! (see TODO(port) markers below): the template-inlining fold, the
-//! ESM-to-CJS __export emission path, `print_dev_server_module`, the source-map
-//! self-borrow in `init`, and the `print_ast` minify-renamer driver / `print_json`.
+//! `print_json` / `get_source_map_builder` driver fns live at crate root.
 
 #![warn(unused_must_use)]
 #![feature(adt_const_params)]
@@ -44,8 +40,8 @@ pub use bun_io::Write;
 use bun_ast as js_ast;
 use js_ast::Ref;
 /// `lexer::*` — the printer only consumes the pure identifier/keyword
-/// classifiers, all of which live in `bun_ast::lexer_tables`. Aliased so the
-/// `lexer::is_identifier(...)` spelling matches the Zig path.
+/// classifiers, all of which live in `bun_ast::lexer_tables`. Aliased so
+/// call sites can use the `lexer::is_identifier(...)` spelling.
 mod lexer {
     pub(crate) use bun_ast::lexer_tables::*;
 }
@@ -55,7 +51,7 @@ use bun_sourcemap as SourceMap;
 
 pub use bun_options_types::schema::api::CssInJsBehavior;
 
-/// `fs.Path` from `src/resolver/fs.zig`. The resolver crate is a sibling
+/// The resolver crate is a sibling
 /// tier-4 crate; the canonical struct was MOVED DOWN to `bun_paths::fs::Path`
 /// so both the resolver and the printer can name it without a dep cycle.
 pub use bun_paths::fs::Path as FsPath;
@@ -64,15 +60,15 @@ pub use bun_paths::fs::Path as FsPath;
 // renamer — defined in `renamer.rs`. The five former leak sites
 // have been replaced with `bumpalo::Bump`-backed allocation (PORTING.md §Forbidden);
 // renamed-name strings are arena-owned and typed `*const [u8]` (PORTING.md §Allocators).
-// TODO(refactor): thread the AST `'bump` lifetime through Renamer to replace the raw pointers.
+// A future refactor could thread the AST `'bump` lifetime through Renamer to
+// replace the raw pointers.
 // ──────────────────────────────────────────────────────────────────────────
 #[path = "renamer.rs"]
 pub mod renamer;
 use renamer as rename;
 
 /// Map of mangled property `Ref` → final mangled name bytes.
-/// Zig: `std.AutoArrayHashMapUnmanaged(Ref, []const u8)` (values borrow bundler arena).
-// PERF(port): Zig values were arena-borrowed `[]const u8`; Box<[u8]> here owns —
+// PERF: `Box<[u8]>` values own their bytes —
 // revisit if profiling shows allocation pressure during link.
 pub type MangledProps = bun_collections::ArrayHashMap<Ref, Box<[u8]>>;
 
@@ -142,7 +138,7 @@ pub mod analyze_transpiled_module {
         }
     }
 
-    /// Zig: `packed struct(u8)`. Kept as plain bools for ergonomic field access
+    /// Kept as plain bools for ergonomic field access
     /// (`mi.flags.contains_import_meta = true`); bitcast at the (de)serialize boundary.
     #[derive(Clone, Copy, Default)]
     pub struct Flags {
@@ -183,7 +179,7 @@ pub mod analyze_transpiled_module {
         pub const STAR_NAMESPACE: Self = Self(u32::MAX - 1);
     }
 
-    /// Zig: `enum(u32)` with open range — non-reserved values bitcast to `StringID`.
+    /// Open `u32` range — non-reserved values bitcast to `StringID`.
     #[repr(transparent)]
     #[derive(Clone, Copy, PartialEq, Eq)]
     pub struct FetchParameters(pub u32);
@@ -222,7 +218,7 @@ pub mod analyze_transpiled_module {
     unsafe impl bytemuck::NoUninit for ModulePhase {}
 
     /// Borrowing view over a finalized/serialized `ModuleInfo`.
-    /// Zig kept this self-referentially inside `ModuleInfo`; Rust builds it on demand
+    /// Built on demand
     /// (`ModuleInfo::as_deserialized`) or borrows from an owned byte buffer
     /// (`ModuleInfoDeserializedOwned::as_ref`).
     pub struct ModuleInfoDeserialized<'a> {
@@ -279,9 +275,7 @@ pub mod analyze_transpiled_module {
     ///
     /// `as_ref()` below reinterprets interior ranges as `&[u32]` / `&[StringID]` /
     /// `&[FetchParameters]` via `bytemuck::cast_slice`. A plain `Box<[u8]>` only
-    /// guarantees `align(1)`, so forming an aligned `&[u32]` from it is UB. The Zig
-    /// sibling sidesteps this by typing the fields `[]align(1) const u32`
-    /// (analyze_transpiled_module.zig); Rust has no under-aligned slice type, so we
+    /// guarantees `align(1)`, so forming an aligned `&[u32]` from it is UB. We
     /// instead over-align the allocation by storing `Box<[u32]>` and viewing it as
     /// bytes — no raw alloc/dealloc, and `Send`/`Sync` are auto-derived.
     struct AlignedBytes {
@@ -309,7 +303,6 @@ pub mod analyze_transpiled_module {
     }
 
     /// Owns a duplicated byte buffer and exposes a `ModuleInfoDeserialized` view into it.
-    /// Replaces Zig's `.owner = .allocated_slice` arm.
     pub struct ModuleInfoDeserializedOwned {
         backing: AlignedBytes,
         // `RecordKind` is a `#[repr(u8)]` enum (not all bit patterns valid), so
@@ -445,7 +438,7 @@ pub mod analyze_transpiled_module {
     /// `(specifier, phase)` to match JSC's `ModuleAnalyzer::appendRequestedModule`,
     /// which appends one entry per unique pair — so the same specifier can be
     /// requested at both Evaluation and Defer phase.
-    // PERF(port): three allocations + a side HashMap; revisit with a real IndexMap.
+    // PERF: three allocations + a side HashMap; revisit with a real IndexMap.
     #[derive(Default)]
     struct RequestedModules {
         keys: Vec<StringID>,
@@ -480,7 +473,7 @@ pub mod analyze_transpiled_module {
             false
         }
         /// Replace every occurrence of `old` with `new` **in place**,
-        /// preserving insertion order. Mirrors Zig `keys()[idx] = new; reIndex()`.
+        /// preserving insertion order.
         fn rename_key(&mut self, old: StringID, new: StringID) {
             let mut touched = false;
             for k in self.keys.iter_mut() {
@@ -500,7 +493,7 @@ pub mod analyze_transpiled_module {
 
     pub struct ModuleInfo {
         /// all strings in wtf-8. index in hashmap = StringID
-        // Zig used an adapted ArrayHashMap keyed by offset; Rust keys by content
+        // Keyed by content
         // directly (wyhash via bun_collections::HashMap) and keeps the parallel
         // buf/lens vectors for the on-wire format.
         strings_map: HashMap<Vec<u8>, u32>,
@@ -656,8 +649,7 @@ pub mod analyze_transpiled_module {
             let idx = u32::try_from(self.strings_lens.len()).unwrap();
             self.strings_buf.extend_from_slice(value);
             self.strings_lens.push(u32::try_from(value.len()).unwrap());
-            // PERF(port): Zig avoided this owned-key dupe via adapted hashmap over
-            // strings_buf offsets; revisit with a raw-entry API.
+            // PERF: owned-key dupe; revisit with a raw-entry API.
             self.strings_map.insert(value.to_vec(), idx);
             StringID(idx)
         }
@@ -694,7 +686,7 @@ pub mod analyze_transpiled_module {
                     *item = new_id;
                 }
             }
-            // Zig: `requested_modules.keys()[idx] = new_id; reIndex()` — must preserve
+            // Must preserve
             // insertion order (serialized verbatim into ModuleInfo for JSC).
             self.requested_modules.rename_key(old_id, new_id);
         }
@@ -791,15 +783,8 @@ use bun_core::printer::{
 /// For support JavaScriptCore
 const ASCII_ONLY_ALWAYS_ON_UNLESS_MINIFYING: bool = true;
 
-pub fn write_module_id(writer: &mut impl core::fmt::Write, module_id: u32) {
-    debug_assert!(module_id != 0); // either module_id is forgotten or it should be disabled
-    writer.write_str("$").expect("unreachable");
-    write!(writer, "{:x}", module_id).expect("unreachable");
-}
-
-// PERF(port): was comptime monomorphization (`comptime CodePointType: type`) — Zig
-// instantiated per code-unit type; Rust callers widen to i32 at the boundary.
-// PERF(port): `ascii_only` is a *runtime* arg (was `const ASCII_ONLY`) so the large
+// Callers widen to i32 at the boundary.
+// PERF: `ascii_only` is a *runtime* arg so the large
 // callers (`write_pre_quoted_string_inner`, `estimate_length_for_utf8`) collapse to a
 // single monomorphization instead of one per (ascii_only × quote_char × …) combo —
 // see the comment on `write_pre_quoted_string`.
@@ -871,9 +856,8 @@ pub struct Whitespacer {
     pub minify: &'static [u8],
 }
 
-// NOTE: Zig `Whitespacer.append` was comptime string concatenation
-// (`.{ .normal = this.normal ++ str, .minify = this.minify ++ str }`).
-// Rust `const fn` can't concatenate `&'static [u8]` at compile time without
+// NOTE: `Whitespacer` has no `append`: `const fn` can't concatenate
+// `&'static [u8]` at compile time without
 // `const_format::concatcp!` at the call site, and a runtime no-op stub would
 // silently emit wrong bytes. Callers must inline the concatenated literals
 // (see e.g. SExportStar) instead of calling `.append()`.
@@ -907,7 +891,6 @@ pub const fn _ws_minify<const N: usize>(s: &[u8]) -> [u8; N] {
 }
 
 /// Compile-time helper: produce a `Whitespacer` whose `.minify` strips spaces.
-/// Zig computed `.minify` at comptime by stripping ' ' (js_printer.zig:92-108).
 #[macro_export]
 macro_rules! ws {
     ($s:expr) => {{
@@ -921,7 +904,7 @@ macro_rules! ws {
     }};
 }
 
-// PERF(port): `ascii_only`/`quote_char` are runtime args (were `const`) — collapses
+// PERF: `ascii_only`/`quote_char` are runtime args — collapses
 // the monomorphization fan-out; the inner branches are cheap and well-predicted.
 pub fn estimate_length_for_utf8(input: &[u8], ascii_only: bool, quote_char: u8) -> usize {
     let mut remaining = input;
@@ -951,9 +934,7 @@ pub fn estimate_length_for_utf8(input: &[u8], ascii_only: bool, quote_char: u8)
         }
         remaining = &remaining[char_len as usize..];
     }
-    // Zig's `else` on `while` runs when the condition fails (i.e. `None`).
     if remaining.as_ptr() == input.as_ptr() {
-        // PORT NOTE: reshaped — Zig returns `remaining.len + 2` when *no* escape was ever found.
         // The branch above already handled the loop body; falling out of the loop with no
         // iterations means "no escapes anywhere".
     }
@@ -1005,7 +986,7 @@ where
         "for json, quote_char must be '\"'"
     );
 
-    // PORT NOTE: this is a large hot-path function; logic is ported 1:1 but the
+    // this is a large hot-path function; logic is ported 1:1 but the
     // utf16 path needs &[u16] handling.
     let text = text_in;
     let mut i: usize = 0;
@@ -1188,7 +1169,7 @@ pub fn quote_for_json(
     bytes: &mut MutableString,
     ascii_only: bool,
 ) -> Result<(), bun_core::Error> {
-    // Zig: `comptime ascii_only: bool`. We now thread `ascii_only` at runtime so
+    // `ascii_only` is threaded at runtime so
     // the heavy escaper isn't monomorphized per ascii_only/quote-char combo.
     //
     // Heuristic reservation (~12.5% slack) instead of `estimate_length_for_utf8`,
@@ -1225,10 +1206,9 @@ pub struct SourceMapHandler<'a> {
     _marker: core::marker::PhantomData<&'a mut ()>,
 }
 
-/// PORTING.md §Dispatch — manual vtable. Zig's `For(comptime Type, handler)` monomorphized
-/// a typed callback into an erased thunk at comptime. Rust cannot bake a *runtime* fn pointer
-/// into a captureless `fn(*mut (), ..)` thunk, so the handler is moved to a trait method and
-/// the thunk is monomorphized over `T: OnSourceMapChunk` instead.
+/// PORTING.md §Dispatch — manual vtable. Rust cannot bake a *runtime* fn pointer
+/// into a captureless `fn(*mut (), ..)` thunk, so the handler is a trait method
+/// and the thunk is monomorphized over `T: OnSourceMapChunk`.
 pub trait OnSourceMapChunk {
     fn on_source_map_chunk(
         &mut self,
@@ -1288,7 +1268,6 @@ pub struct Options<'a> {
     // allocator dropped — global mimalloc (this is an AST crate but Options.allocator is the global default)
     pub source_map_handler: Option<SourceMapHandler<'a>>,
     pub source_map_builder: Option<&'a mut SourceMap::chunk::Builder>,
-    // TODO(port): bun_options_types::schema::api::CssInJsBehavior — local stand-in.
     pub css_import_behavior: CssInJsBehavior,
     pub target: bun_ast::Target,
 
@@ -1296,9 +1275,8 @@ pub struct Options<'a> {
     pub module_info: Option<&'a mut analyze_transpiled_module::ModuleInfo>,
     pub input_files_for_dev_server: Option<&'a [bun_ast::Source]>,
 
-    /// Borrowed from `BundledAst.commonjs_named_exports`. Zig passed the
-    /// unmanaged `StringArrayHashMap` header by value (shallow copy of
-    /// shared storage); the printer only reads from it.
+    /// Borrowed from `BundledAst.commonjs_named_exports`; the printer only
+    /// reads from it.
     pub commonjs_named_exports: Option<&'a CommonJSNamedExports>,
     pub commonjs_named_exports_deoptimized: bool,
     pub commonjs_module_exports_assigned_deoptimized: bool,
@@ -1324,8 +1302,7 @@ pub struct Options<'a> {
     // /// Used for cross-module inlining of import items when bundling
     // const_values: Ast.ConstValuesMap = .{},
     /// Borrowed from `LinkerGraph.ts_enums` (one shared map for the whole
-    /// bundle). Zig passed the unmanaged map header by value; the printer
-    /// only reads from it.
+    /// bundle); the printer only reads from it.
     pub ts_enums: Option<&'a TsEnumsMap>,
 
     // If we're writing out a source map, this table of line start indices lets
@@ -1333,8 +1310,7 @@ pub struct Options<'a> {
     /// Borrowed from `LinkerGraph.files[i].line_offset_table`. The same
     /// source can print into multiple part-ranges/chunks, so the table must
     /// not be consumed. `get_source_map_builder` shallow-copies it into the
-    /// builder (`ManuallyDrop`, never freed on the bundler path — matches
-    /// Zig `printWithWriter`).
+    /// builder (`ManuallyDrop`, never freed on the bundler path).
     pub line_offset_tables: Option<&'a SourceMap::line_offset_table::List<bun_alloc::AstAlloc>>,
 
     pub mangled_props: Option<&'a crate::MangledProps>,
@@ -1403,8 +1379,7 @@ impl<'a> Default for Options<'a> {
 
 use bun_ast::{Indentation, IndentationCharacter};
 
-/// Downstream-compat: `print_json` callers pass this. The Zig spec passes the
-/// full `Options` struct; only the fields any caller actually sets are surfaced
+/// Downstream-compat: `print_json` callers pass this. Only the fields any caller actually sets are surfaced
 /// here and forwarded into `Options { .. }` inside `print_json`.
 #[derive(Clone, Copy, Default)]
 pub struct PrintJsonOptions<'a> {
@@ -1451,9 +1426,8 @@ impl Default for RequireOrImportMetaCallback {
     }
 }
 
-/// PORTING.md §Dispatch — manual vtable. Zig's `init(comptime Context, ctx, callback)`
-/// `@ptrCast`-erased the typed callback at comptime. Rust monomorphizes the erased thunk
-/// over `T: RequireOrImportMetaSource` instead, so `callback` stays a captureless `fn`.
+/// PORTING.md §Dispatch — manual vtable. The erased thunk is monomorphized
+/// over `T: RequireOrImportMetaSource`, so `callback` stays a captureless `fn`.
 pub trait RequireOrImportMetaSource {
     fn require_or_import_meta_for_source(
         &mut self,
@@ -1474,8 +1448,8 @@ impl RequireOrImportMetaCallback {
             was_unwrapped_require: bool,
         ) -> RequireOrImportMeta {
             // SAFETY: `p` was constructed from `&mut T` in `init` below; caller guarantees
-            // `ctx` outlives this `RequireOrImportMetaCallback` (same contract as the Zig
-            // `*anyopaque` erasure), so the cast-back deref is valid and exclusive.
+            // `ctx` outlives this `RequireOrImportMetaCallback`, so the cast-back
+            // deref is valid and exclusive.
             unsafe { (*p.cast::<T>()).require_or_import_meta_for_source(id, was_unwrapped_require) }
         }
         Self {
@@ -1529,7 +1503,6 @@ impl ExprFlag {
     pub fn forbid_call() -> ExprFlagSet {
         ExprFlag::ForbidCall.into()
     }
-    // PORT NOTE: Zig had `ForbidAnd` referencing `.forbid_and` which doesn't exist in the enum — dead code.
     #[inline]
     pub fn has_non_optional_chain_parent() -> ExprFlagSet {
         ExprFlag::HasNonOptionalChainParent.into()
@@ -1544,84 +1517,6 @@ impl ExprFlag {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum ImportVariant {
-    PathOnly,
-    ImportStar,
-    ImportDefault,
-    ImportStarAndImportDefault,
-    ImportItems,
-    ImportItemsAndDefault,
-    ImportItemsAndStar,
-    ImportItemsAndDefaultAndStar,
-}
-
-impl ImportVariant {
-    #[inline]
-    pub(crate) fn has_items(self) -> Self {
-        match self {
-            Self::ImportDefault => Self::ImportItemsAndDefault,
-            Self::ImportStar => Self::ImportItemsAndStar,
-            Self::ImportStarAndImportDefault => Self::ImportItemsAndDefaultAndStar,
-            _ => Self::ImportItems,
-        }
-    }
-
-    // We always check star first so don't need to be exhaustive here
-    #[inline]
-    pub(crate) fn has_star(self) -> Self {
-        match self {
-            Self::PathOnly => Self::ImportStar,
-            _ => self,
-        }
-    }
-
-    // We check default after star
-    #[inline]
-    pub(crate) fn has_default(self) -> Self {
-        match self {
-            Self::PathOnly => Self::ImportDefault,
-            Self::ImportStar => Self::ImportStarAndImportDefault,
-            _ => self,
-        }
-    }
-
-    pub(crate) fn determine(record: &ImportRecord, s_import: &js_ast::S::Import) -> ImportVariant {
-        let mut variant = ImportVariant::PathOnly;
-
-        if record
-            .flags
-            .contains(ImportRecordFlags::CONTAINS_IMPORT_STAR)
-        {
-            variant = variant.has_star();
-        }
-
-        if !record
-            .flags
-            .contains(ImportRecordFlags::WAS_ORIGINALLY_BARE_IMPORT)
-        {
-            if !record
-                .flags
-                .contains(ImportRecordFlags::CONTAINS_DEFAULT_ALIAS)
-            {
-                if let Some(default_name) = &s_import.default_name {
-                    if default_name.ref_.is_some() {
-                        variant = variant.has_default();
-                    }
-                }
-            } else {
-                variant = variant.has_default();
-            }
-        }
-
-        if !s_import.items.is_empty() {
-            variant = variant.has_items();
-        }
-
-        variant
-    }
-}
-
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum ClauseItemAs {
     Import,
@@ -1637,16 +1532,8 @@ pub enum IsTopLevel {
     No,
 }
 
-/// `MAY_HAVE_MODULE_INFO = IS_BUN_PLATFORM && !REWRITE_ESM_TO_CJS`
-// TODO(port): const-generic associated const — written as a free fn until adt_const_params lands.
-#[inline(always)]
-pub const fn may_have_module_info(is_bun_platform: bool, rewrite_esm_to_cjs: bool) -> bool {
-    is_bun_platform && !rewrite_esm_to_cjs
-}
-
-// PORT NOTE: Zig defined `TopLevelAndIsExport`/`TopLevel` as conditional zero-size structs when
-// !may_have_module_info. In Rust we use one shape; dead-code elimination removes the unused
-// fields when MAY_HAVE_MODULE_INFO is false.
+// One shape; dead-code elimination removes the unused fields when
+// MAY_HAVE_MODULE_INFO is false.
 #[derive(Clone, Copy, Default)]
 pub struct TopLevelAndIsExport {
     pub is_export: bool,
@@ -1696,13 +1583,12 @@ pub mod __gated_printer {
     // ──────────────────────────────────────────────────────────────────────────
 
     /// Re-borrow an arena-owned `StoreSlice<T>` for the print pass. Kept as a
-    /// free fn (vs. calling `.slice()` inline) so the ~50 call sites stay
-    /// `.zig`-diffable; the printer only ever reads these.
+    /// free fn (vs. calling `.slice()` inline); the printer only ever reads these.
     #[inline(always)]
     pub(crate) fn slice_of<'a, T>(p: js_ast::StoreSlice<T>) -> &'a [T] {
         p.slice()
     }
-    /// `EnumSet<T>` field-style mutation as used by the Zig (`flags.x = true`).
+    /// `EnumSet<T>` field-style mutation helper.
     #[inline(always)]
     pub(crate) fn set_flag<T: enumset::EnumSetType>(
         set: &mut enumset::EnumSet<T>,
@@ -1758,12 +1644,11 @@ pub mod __gated_printer {
         pub stack_overflowed: bool,
 
         pub was_lazy_export: bool,
-        // PORT NOTE: Zig used `if (!may_have_module_info) void else ?*ModuleInfo` — in Rust we always
-        // carry the Option and gate at call sites with MAY_HAVE_MODULE_INFO.
+        // Always carried; gated at call sites with MAY_HAVE_MODULE_INFO.
         pub module_info: Option<&'a mut analyze_transpiled_module::ModuleInfo>,
 
         /// Arena for transient allocations during printing (rope flattening,
-        /// UTF-16→UTF-8 transcoding). Zig: `p.options.allocator`.
+        /// UTF-16→UTF-8 transcoding).
         pub bump: &'a bun_alloc::Arena,
     }
 
@@ -1773,7 +1658,7 @@ pub mod __gated_printer {
     /// code in the JavaScript parser for details.
     pub struct BinaryExpressionVisitor<'ast> {
         // Inputs
-        // PORT NOTE: Zig stored `*const E.Binary`; we keep a StoreRef so the
+        // A StoreRef so the
         // visitor stack can outlive the by-value `Expr` argument to `print_expr`.
         pub e: js_ast::StoreRef<E::Binary>,
         _phantom: core::marker::PhantomData<&'ast ()>,
@@ -1790,14 +1675,8 @@ pub mod __gated_printer {
         pub right_level: Level,
     }
 
-    impl<'ast> Default for BinaryExpressionVisitor<'ast> {
-        #[cold]
-        #[inline(never)]
-        fn default() -> Self {
-            // TODO(port): `entry` defaulted to `undefined` in Zig; we need a sentinel &'static OpInfo.
-            unreachable!("construct via fields")
-        }
-    }
+    // No `Default` impl: every construction
+    // site builds the visitor with all fields explicit.
 
     // ───────────────────────────────────────────────────────────────────────────
     // Printer methods
@@ -1818,8 +1697,8 @@ pub mod __gated_printer {
         pub const MAY_HAVE_MODULE_INFO: bool = IS_BUN_PLATFORM && !REWRITE_ESM_TO_CJS;
 
         /// When Printer is used as a io.Writer, this represents it's error type, aka nothing.
-        // (Zig: `pub const Error = error{};`) — inherent associated types are
-        // unstable; callers can name `core::convert::Infallible` directly.
+        // Inherent associated types are unstable; callers can name
+        // `core::convert::Infallible` directly.
 
         /// Reborrow the optional `ModuleInfo` for the duration of `&mut self`.
         /// Callers that need to interleave other `&mut self` calls (e.g.
@@ -1997,11 +1876,33 @@ pub mod __gated_printer {
         }
 
         fn fmt(&mut self, args: core::fmt::Arguments<'_>) -> Result<(), bun_core::Error> {
-            // PERF(port): Zig used std.fmt.count + bufPrint into reserved space (no heap).
-            // TODO(port): implement `count` over fmt::Arguments to match.
-            let mut buf: Vec<u8> = Vec::new();
-            Write::write_fmt(&mut buf, format_args!("{}", args)).expect("unreachable");
-            self.writer.write_reserved(&buf)
+            // Rust can't pre-count `fmt::Arguments` without formatting,
+            // so stream each formatted chunk straight into the writer's
+            // reserved space instead — same zero-heap property without
+            // formatting twice.
+            struct FmtAdapter<'w, W: WriterTrait> {
+                writer: &'w mut W,
+                err: Option<bun_core::Error>,
+            }
+            impl<W: WriterTrait> core::fmt::Write for FmtAdapter<'_, W> {
+                fn write_str(&mut self, s: &str) -> core::fmt::Result {
+                    match self.writer.write_reserved(s.as_bytes()) {
+                        Ok(()) => Ok(()),
+                        Err(e) => {
+                            self.err = Some(e);
+                            Err(core::fmt::Error)
+                        }
+                    }
+                }
+            }
+            let mut adapter = FmtAdapter {
+                writer: &mut self.writer,
+                err: None,
+            };
+            if core::fmt::write(&mut adapter, args).is_err() {
+                return Err(adapter.err.unwrap_or_else(|| bun_core::err!("WriteFailed")));
+            }
+            Ok(())
         }
 
         pub fn print_buffer(&mut self, str: &[u8]) {
@@ -2202,7 +2103,7 @@ pub mod __gated_printer {
 
             // Record var declarations for module_info. printGlobalBunImportStatement
             // bypasses printDeclStmt/printBinding, so we must record vars explicitly.
-            // PORT NOTE: reshaped for borrowck — compute names before borrowing module_info.
+            // reshaped for borrowck — compute names before borrowing module_info.
             if Self::MAY_HAVE_MODULE_INFO && self.module_info.is_some() {
                 if import.star_name_loc.is_some() {
                     let name = self.name_for_symbol(import.namespace_ref);
@@ -2307,7 +2208,6 @@ pub mod __gated_printer {
             self.add_source_mapping(loc);
             self.print(b"{");
             if !stmts.is_empty() {
-                // @branchHint(.likely)
                 self.print_newline();
                 self.indent();
                 self.print_block_body(stmts, tlmtlo);
@@ -2430,7 +2330,6 @@ pub mod __gated_printer {
                         // Reset the temporary bindings array early on
                         let mut temp_bindings = core::mem::take(&mut self.temporary_bindings);
                         temp_bindings.reserve(2);
-                        // PERF(port): was appendAssumeCapacity — profile
                         temp_bindings.push(B::Property {
                             flags: Default::default(),
                             key: Expr::init(
@@ -2493,7 +2392,7 @@ pub mod __gated_printer {
                             properties: js_ast::StoreSlice::new_mut(temp_bindings.as_mut_slice()),
                             is_single_line: true,
                         };
-                        // PORT NOTE: `Binding::init(*B.Object, loc)` is gated upstream;
+                        // `Binding::init(*B.Object, loc)` is gated upstream;
                         // inline its body — it just tags the union and copies `loc`.
                         // `from_bump` wraps a `&mut T` as a non-null arena ref; here the
                         // pointee is a stack local but `print_binding` only reads it and
@@ -2503,7 +2402,7 @@ pub mod __gated_printer {
                             data: BindingData::BObject(js_ast::StoreRef::from_bump(&mut b_object)),
                         };
                         self.print_binding(binding, tlm);
-                        // Zig defer (js_printer.zig:1252): if recursion replaced
+                        // If recursion replaced
                         // `self.temporary_bindings`, drop our local; else clear+restore.
                         if self.temporary_bindings.capacity() > 0 {
                             drop(temp_bindings);
@@ -2714,7 +2613,7 @@ pub mod __gated_printer {
 
         pub fn print_non_negative_float(&mut self, float: f64) {
             // Is this actually an integer?
-            // PORT NOTE: @setRuntimeSafety(false) / @setFloatMode(.optimized) have no Rust equivalent.
+            // @setRuntimeSafety(false) / @setFloatMode(.optimized) have no Rust equivalent.
             let floored = float.floor();
             let remainder = float - floored;
             let is_integer = remainder == 0.0;
@@ -2733,7 +2632,8 @@ pub mod __gated_printer {
                 return;
             }
 
-            // TODO(port): Zig "{d}" on f64 — need shortest-round-trip formatter (ryu) to match output exactly.
+            // `Display` for f64 emits the shortest digit string that
+            // round-trips, never scientific notation.
             let _ = self.fmt(format_args!("{}", float));
         }
 
@@ -2791,7 +2691,7 @@ pub mod __gated_printer {
         /// `Source::contents` buffer — both are kept alive for `'a` by the
         /// caller of `Printer::init`. Detach the borrow to a raw ptr per the
         /// parser's ARENA convention (matching `slice_of` for AST fields).
-        /// PORT NOTE: reshaped for borrowck — TODO(refactor): thread `'bump` through Renamer.
+        /// Reshaped for borrowck — a future refactor could thread `'bump` through Renamer.
         #[inline]
         fn name_for_symbol(&mut self, ref_: Ref) -> &'a [u8] {
             let p = std::ptr::from_ref::<[u8]>(self.renamer.name_for_symbol(ref_));
@@ -2811,7 +2711,7 @@ pub mod __gated_printer {
 
         #[inline]
         pub fn import_record(&self, import_record_index: usize) -> &'a ImportRecord {
-            // PORT NOTE: detached from `&self` so callers can interleave `&mut self` printing.
+            // detached from `&self` so callers can interleave `&mut self` printing.
             &self.import_records[import_record_index]
         }
 
@@ -2842,7 +2742,7 @@ pub mod __gated_printer {
             if wrap {
                 self.print(b"(");
             }
-            // PORT NOTE: Zig used `defer if (wrap) p.print(")")`. We close at every `return` below.
+            // The wrapping ")" is closed at every `return` below.
 
             debug_assert!(self.import_records.len() > import_record_index as usize);
             let record = self.import_record(import_record_index as usize);
@@ -3122,7 +3022,36 @@ pub mod __gated_printer {
         }
 
         pub fn print_string_literal_utf8(&mut self, str: &[u8], allow_backtick: bool) {
-            // TODO(port): bun_core::wtf8_validate_slice — debug-only assert dropped.
+            // WTF-8 = UTF-8 plus surrogate code points (U+D800..U+DFFF as
+            // `ED A0 80`..`ED BF BF`), so validate UTF-8 shape minus the
+            // surrogate exclusion.
+            fn is_valid_wtf8(mut s: &[u8]) -> bool {
+                while let Some(&b0) = s.first() {
+                    let len = match b0 {
+                        0x00..=0x7F => 1,
+                        0xC2..=0xDF => 2,
+                        0xE0..=0xEF => 3,
+                        0xF0..=0xF4 => 4,
+                        _ => return false,
+                    };
+                    if s.len() < len {
+                        return false;
+                    }
+                    let cont_ok = s[1..len].iter().all(|&b| b & 0xC0 == 0x80);
+                    if !cont_ok {
+                        return false;
+                    }
+                    match (len, b0) {
+                        (3, 0xE0) if s[1] < 0xA0 => return false, // overlong
+                        (4, 0xF0) if s[1] < 0x90 => return false, // overlong
+                        (4, 0xF4) if s[1] > 0x8F => return false, // > U+10FFFF
+                        _ => {}
+                    }
+                    s = &s[len..];
+                }
+                true
+            }
+            debug_assert!(is_valid_wtf8(str));
 
             let quote = if !IS_JSON {
                 best_quote_char_for_string(str, allow_backtick)
@@ -3453,7 +3382,7 @@ pub mod __gated_printer {
                     self.print_space_before_identifier();
                     self.add_source_mapping(expr.loc);
 
-                    // PORT NOTE: reshaped for borrowck — find the matching index first,
+                    // reshaped for borrowck — find the matching index first,
                     // then drop the immutable iter borrow before printing.
                     let mut found: Option<usize> = None;
                     if let Some(exports) = self.options.commonjs_named_exports {
@@ -4098,8 +4027,26 @@ pub mod __gated_printer {
                     self.print_string_literal_e_string(&e, true);
                 }
                 ExprData::ETemplate(e) => {
+                    // Print from a thread-local shallow copy of the template
+                    // node. The fold below must NOT be persisted into the
+                    // shared AST: during bundling the same module's parts can
+                    // be printed concurrently into multiple chunks
+                    // (multi-entry, non-split builds), so writing the folded
+                    // template back through the arena pointer
+                    // would be a cross-thread data race. Re-prints recompute
+                    // the identical fold, so emitted output is unchanged.
+                    let mut e = E::Template {
+                        tag: e.tag,
+                        parts: e.parts,
+                        head: match &e.head {
+                            E::TemplateContents::Cooked(c) => {
+                                E::TemplateContents::Cooked(c.shallow_clone())
+                            }
+                            E::TemplateContents::Raw(r) => E::TemplateContents::Raw(*r),
+                        },
+                    };
                     if e.tag.is_none() && (self.options.minify_syntax || self.was_lazy_export) {
-                        // Zig: `var part = part.*` — `TemplatePart` is structurally
+                        // `TemplatePart` is structurally
                         // `Copy` but `EString` doesn't derive it; field-wise copy.
                         #[inline]
                         fn part_clone(p: &E::TemplatePart) -> E::TemplatePart {
@@ -4115,7 +4062,12 @@ pub mod __gated_printer {
                             }
                         }
 
-                        let mut replaced: Vec<E::TemplatePart> = Vec::new();
+                        // Bump-allocated (printer arena) so the folded
+                        // template's parts outlive the inner block: the
+                        // thread-local `e` above keeps the parts slice alive
+                        // through the print loop at the end of this arm.
+                        let mut replaced =
+                            bun_alloc::ArenaVec::<E::TemplatePart>::new_in(self.bump);
                         for (i, _part) in e.parts().iter().enumerate() {
                             let mut part = part_clone(_part);
                             let inlined_value: Option<Expr> = match &part.value.data {
@@ -4142,12 +4094,12 @@ pub mod __gated_printer {
                         }
 
                         if !replaced.is_empty() {
-                            // Zig: `var copy = e.*; copy.parts = &replaced;` — build a
+                            // Build a
                             // local `Template` (not a StoreRef alias) so `fold`'s
                             // `mem::take(self.head)` doesn't clobber the AST node.
-                            // `replaced` outlives `copy`/`fold()`; wrap as a StoreSlice
-                            // over the local Vec to match `Template.parts`.
-                            let parts_slice = js_ast::StoreSlice::new_mut(replaced.as_mut_slice());
+                            // `replaced` is leaked into the bump arena, so the
+                            // parts slice stays valid past this block.
+                            let parts_slice = js_ast::StoreSlice::from_bump(replaced);
                             let mut copy = E::Template {
                                 tag: e.tag,
                                 parts: parts_slice,
@@ -4167,9 +4119,28 @@ pub mod __gated_printer {
                                     return;
                                 }
                                 ExprData::ETemplate(t) => {
-                                    // SAFETY: e is &mut behind the AST arena pointer
-                                    // TODO(port): Zig mutated `e.* = e2.data.e_template.*` — needs &mut access through arena.
-                                    let _ = t;
+                                    // Use the folded template for the print path
+                                    // below — assigned to the thread-local `e`,
+                                    // never written back into the shared AST node
+                                    // (see the comment at the top of this arm).
+                                    // Field values are arena/store-backed in both
+                                    // fold paths (the bail-out path aliases the
+                                    // stack `copy`, but its `parts`/`head` payloads
+                                    // are bump-allocated above), so copying the
+                                    // fields out is safe even though `t` itself may
+                                    // point at `copy`.
+                                    e = E::Template {
+                                        tag: t.tag,
+                                        parts: t.parts,
+                                        head: match &t.head {
+                                            E::TemplateContents::Cooked(c) => {
+                                                E::TemplateContents::Cooked(c.shallow_clone())
+                                            }
+                                            E::TemplateContents::Raw(r) => {
+                                                E::TemplateContents::Raw(*r)
+                                            }
+                                        },
+                                    };
                                 }
                                 _ => {}
                             }
@@ -4186,7 +4157,7 @@ pub mod __gated_printer {
                     if let Some(tag) = &e.tag {
                         self.add_source_mapping(expr.loc);
                         // Optional chains are forbidden in template tags
-                        // PORT NOTE: `Expr::is_optional_chain` is gated upstream; inline its body.
+                        // `Expr::is_optional_chain` is gated upstream; inline its body.
                         let is_optional_chain = match &expr.data {
                             ExprData::EDot(d) => d.optional_chain.is_some(),
                             ExprData::EIndex(i) => i.optional_chain.is_some(),
@@ -4205,7 +4176,6 @@ pub mod __gated_printer {
                     }
 
                     self.print(b"`");
-                    let mut e = *e;
                     match &mut e.head {
                         E::TemplateContents::Raw(raw) => self.print_raw_template_literal(raw),
                         E::TemplateContents::Cooked(cooked) => {
@@ -4224,8 +4194,8 @@ pub mod __gated_printer {
                             E::TemplateContents::Raw(raw) => self.print_raw_template_literal(raw),
                             E::TemplateContents::Cooked(cooked) => {
                                 if cooked.is_present() {
-                                    // PORT NOTE: `parts` is `*mut [TemplatePart]` but accessed `&[T]`
-                                    // here. Zig mutates in place; Rust resolves a local copy of the
+                                    // `parts` is `*mut [TemplatePart]` but accessed `&[T]`
+                                    // here. We resolve a local copy of the
                                     // EString header (the rope chain is StoreRef-linked and Copy) and
                                     // prints from that — the arena node stays roped.
                                     let mut local = E::EString { ..*cooked };
@@ -4281,7 +4251,7 @@ pub mod __gated_printer {
                     } else {
                         e.ref_
                     };
-                    // PORT NOTE: reshaped for borrowck — `get_const` borrows self;
+                    // reshaped for borrowck — `get_const` borrows self;
                     // capture as `BackRef` so the `&self` borrow is dropped before the
                     // `&mut self` print calls below. Symbol table is arena-backed and
                     // outlives the print pass (BackRef invariant).
@@ -4540,10 +4510,9 @@ pub mod __gated_printer {
                 }
                 ExprData::EJsxElement(_) | ExprData::EPrivateIdentifier(_) => {
                     if cfg!(debug_assertions) {
-                        // TODO(port): @tagName(expr.data) — ExprData lacks IntoStaticStr.
                         Output::panic(format_args!(
-                            "Unexpected expression of type {:?}",
-                            core::mem::discriminant(&expr.data)
+                            "Unexpected expression of type .{}",
+                            expr.data.tag_name()
                         ));
                     }
                 }
@@ -4677,8 +4646,7 @@ pub mod __gated_printer {
         }
 
         pub fn print_property(&mut self, item_in: &G::Property) {
-            // PORT NOTE: Zig took G.Property by value (Copy in Zig). Rust's
-            // G::Property isn't `Copy`, so take a borrow and shallow-copy the
+            // `G::Property` isn't `Copy`, so take a borrow and shallow-copy the
             // mutable bits we may rewrite (key + flags).
             let mut item = G::Property {
                 kind: item_in.kind,
@@ -4687,7 +4655,7 @@ pub mod __gated_printer {
                 key: item_in.key,
                 value: item_in.value,
                 initializer: item_in.initializer,
-                // PERF(port): Vec not Copy — re-slice instead of move.
+                // Vec is not Copy — re-slice instead of move.
                 ts_decorators: bun_alloc::AstAlloc::vec(),
                 ts_metadata: Default::default(),
             };
@@ -5000,7 +4968,7 @@ pub mod __gated_printer {
                     self.add_source_mapping(binding.loc);
                     self.print_symbol(b.r#ref);
                     if Self::MAY_HAVE_MODULE_INFO {
-                        // PORT NOTE: reshaped for borrowck — fetch name before borrowing module_info.
+                        // reshaped for borrowck — fetch name before borrowing module_info.
                         let local_name = self.name_for_symbol(b.r#ref);
                         if let Some(mi) = self.module_info() {
                             let name_id = mi.str(local_name);
@@ -5156,7 +5124,7 @@ pub mod __gated_printer {
                                                     self.name_for_symbol(id.r#ref),
                                                 ) {
                                                     if Self::MAY_HAVE_MODULE_INFO {
-                                                        // PORT NOTE: reshaped for borrowck — bump access first.
+                                                        // reshaped for borrowck — bump access first.
                                                         let str8 = str.slice(self.bump);
                                                         if let Some(mi) = self.module_info() {
                                                             let name_id = mi.str(str8);
@@ -5230,8 +5198,7 @@ pub mod __gated_printer {
             }
 
             let prev_stmt_tag = self.prev_stmt_tag;
-            // Zig: `defer { p.prev_stmt_tag = std.meta.activeTag(stmt.data); }`
-            // PORT NOTE: reshaped for borrowck — scopeguard would hold `&mut self.prev_stmt_tag`
+            // Borrowck: scopeguard would hold `&mut self.prev_stmt_tag`
             // across the whole match body and conflict with every `&mut self` call below. Instead
             // we assign `self.prev_stmt_tag = new_tag` at every return point (early + tail).
             let new_tag = stmt.data.tag();
@@ -5490,8 +5457,7 @@ pub mod __gated_printer {
                     self.add_source_mapping(stmt.loc);
 
                     if s.alias.is_some() {
-                        // Zig: ws("export *").append(" as ") — append() concatenates verbatim to
-                        // BOTH fields (js_printer.zig:86-88), so minify keeps the " as " literal.
+                        // The " as " literal must stay in BOTH fields (minify keeps it).
                         self.print_whitespacer(Whitespacer {
                             normal: b"export * as ",
                             minify: b"export* as ",
@@ -5547,7 +5513,7 @@ pub mod __gated_printer {
                                 self.print_space();
                                 let last = slice_of(s.items).len() - 1;
                                 for (i, item) in slice_of(s.items).iter().enumerate() {
-                                    // PORT NOTE: reshaped for borrowck — detach symbol from
+                                    // reshaped for borrowck — detach symbol from
                                     // `&self` via `BackRef` (arena-backed table outlives print).
                                     let symbol = BackRef::<Symbol>::new(
                                         self.symbols()
@@ -5610,10 +5576,11 @@ pub mod __gated_printer {
                         return Ok(());
                     }
 
-                    // PORT NOTE: Zig wraps `s.items` in an ArrayListUnmanaged and uses swapRemove
-                    // in-place. `ClauseItem` isn't `Clone`, so build a Vec of arena borrows
-                    // instead and swap-remove the borrows.
-                    // TODO(port): lifetime — Zig mutates `s.items` in place; consider writing back.
+                    // `ClauseItem` isn't `Clone`, so build a Vec of arena
+                    // borrows instead and swap-remove the borrows; the printer is
+                    // the only consumer of the filtered list, and a re-print
+                    // recomputes the identical filtering, so the AST write-back
+                    // is unnecessary.
                     let mut array: Vec<&js_ast::ClauseItem> = slice_of(s.items).iter().collect();
                     {
                         let mut i: usize = 0;
@@ -5621,7 +5588,7 @@ pub mod __gated_printer {
                             let item = array[i];
 
                             if !item.original_name.slice().is_empty() {
-                                // PORT NOTE: reshaped for borrowck — detach symbol from
+                                // reshaped for borrowck — detach symbol from
                                 // `&self` via `BackRef` (arena-backed; outlives the print pass).
                                 let symbol = self
                                     .symbols()
@@ -5662,7 +5629,7 @@ pub mod __gated_printer {
                             self.prev_stmt_tag = new_tag;
                             return Ok(());
                         }
-                        // s.items = array.items; — TODO(port): write back into AST
+                        // The write-back into the AST is intentionally skipped (see note above).
                     }
 
                     self.print(b"{");
@@ -5753,7 +5720,7 @@ pub mod __gated_printer {
                     self.print_semicolon_after_statement();
 
                     if Self::MAY_HAVE_MODULE_INFO && self.module_info.is_some() {
-                        // PORT NOTE: reshaped for borrowck — re-borrow module_info per item so
+                        // reshaped for borrowck — re-borrow module_info per item so
                         // `name_for_symbol` (which needs `&mut self`) can run between uses.
                         let irp_id = {
                             let mi = self.module_info().expect("infallible: module_info enabled");
@@ -6279,7 +6246,7 @@ pub mod __gated_printer {
                     self.print_semicolon_after_statement();
 
                     if Self::MAY_HAVE_MODULE_INFO && self.module_info.is_some() {
-                        // PORT NOTE: reshaped for borrowck — `module_info()` borrows `&mut self`,
+                        // reshaped for borrowck — `module_info()` borrows `&mut self`,
                         // so we re-borrow it between `name_for_symbol` calls instead of holding
                         // a single long-lived `mi` across the whole block. `irp_id` is Copy.
                         let import_record_path = &record.path.text;
@@ -6479,150 +6446,11 @@ pub mod __gated_printer {
             }
         }
 
-        pub fn print_bundled_import(&mut self, record: &ImportRecord, s: &S::Import) {
-            if record.flags.contains(ImportRecordFlags::IS_INTERNAL) {
-                return;
-            }
-
-            let import_record = self.import_record(s.import_record_index as usize);
-            let is_disabled = import_record.path.is_disabled;
-            let module_id = import_record.module_id;
-
-            // If the bundled import was disabled and only imported for side effects we can skip it
-            if record.path.is_disabled {
-                if self.symbols().get_const(s.namespace_ref).is_none() {
-                    return;
-                }
-            }
-
-            match ImportVariant::determine(record, s) {
-                ImportVariant::PathOnly => {
-                    if !is_disabled {
-                        self.print_call_module_id(module_id);
-                        self.print_semicolon_after_statement();
-                    }
-                }
-                ImportVariant::ImportItemsAndDefault | ImportVariant::ImportDefault => {
-                    if !is_disabled {
-                        self.print(b"var $");
-                        self.print_module_id(module_id);
-                        self.print_equals();
-                        self.print_load_from_bundle(s.import_record_index);
-
-                        if let Some(default_name) = &s.default_name {
-                            self.print(b", ");
-                            self.print_symbol(default_name.ref_.expect("infallible: ref bound"));
-                            self.print(b" = (($");
-                            self.print_module_id(module_id);
-                            self.print(b" && \"default\" in $");
-                            self.print_module_id(module_id);
-                            self.print(b") ? $");
-                            self.print_module_id(module_id);
-                            self.print(b".default : $");
-                            self.print_module_id(module_id);
-                            self.print(b")");
-                        }
-                    } else {
-                        if let Some(default_name) = &s.default_name {
-                            self.print(b"var ");
-                            self.print_symbol(default_name.ref_.expect("infallible: ref bound"));
-                            self.print_equals();
-                            self.print_disabled_import();
-                        }
-                    }
-                    self.print_semicolon_after_statement();
-                }
-                ImportVariant::ImportStarAndImportDefault => {
-                    self.print(b"var ");
-                    self.print_symbol(s.namespace_ref);
-                    self.print_equals();
-                    self.print_load_from_bundle(s.import_record_index);
-
-                    if let Some(default_name) = &s.default_name {
-                        self.print(b",");
-                        self.print_space();
-                        self.print_symbol(default_name.ref_.expect("infallible: ref bound"));
-                        self.print_equals();
-
-                        if !IS_BUN_PLATFORM {
-                            self.print(b"(");
-                            self.print_symbol(s.namespace_ref);
-                            self.print_whitespacer(ws!(b" && \"default\" in "));
-                            self.print_symbol(s.namespace_ref);
-                            self.print_whitespacer(ws!(b" ? "));
-                            self.print_symbol(s.namespace_ref);
-                            self.print_whitespacer(ws!(b".default : "));
-                            self.print_symbol(s.namespace_ref);
-                            self.print(b")");
-                        } else {
-                            self.print_symbol(s.namespace_ref);
-                        }
-                    }
-                    self.print_semicolon_after_statement();
-                }
-                ImportVariant::ImportStar => {
-                    self.print(b"var ");
-                    self.print_symbol(s.namespace_ref);
-                    self.print_equals();
-                    self.print_load_from_bundle(s.import_record_index);
-                    self.print_semicolon_after_statement();
-                }
-                _ => {
-                    self.print(b"var $");
-                    self.print_module_id_assume_enabled(module_id);
-                    self.print_equals();
-                    self.print_load_from_bundle(s.import_record_index);
-                    self.print_semicolon_after_statement();
-                }
-            }
-        }
-
-        pub fn print_load_from_bundle(&mut self, import_record_index: u32) {
-            self.print_load_from_bundle_without_call(import_record_index);
-            self.print(b"()");
-        }
-
         #[inline]
         fn print_disabled_import(&mut self) {
             self.print_whitespacer(ws!(b"(() => ({}))"));
         }
 
-        pub fn print_load_from_bundle_without_call(&mut self, import_record_index: u32) {
-            let record = self.import_record(import_record_index as usize);
-            if record.path.is_disabled {
-                self.print_disabled_import();
-                return;
-            }
-            self.print_module_id(self.import_record(import_record_index as usize).module_id);
-        }
-
-        pub fn print_call_module_id(&mut self, module_id: u32) {
-            self.print_module_id(module_id);
-            self.print(b"()");
-        }
-
-        #[inline]
-        fn print_module_id(&mut self, module_id: u32) {
-            debug_assert!(module_id != 0); // either module_id is forgotten or it should be disabled
-            self.print_module_id_assume_enabled(module_id);
-        }
-
-        #[inline]
-        fn print_module_id_assume_enabled(&mut self, module_id: u32) {
-            self.print(b"$");
-            let _ = self.fmt(format_args!("{:x}", module_id));
-        }
-
-        pub fn print_bundled_rexport(&mut self, name: &[u8], import_record_index: u32) {
-            self.print(b"Object.defineProperty(");
-            self.print_module_export_symbol();
-            self.print(b",");
-            self.print_string_literal_utf8(name, true);
-            self.print_whitespacer(ws!(b",{get: () => ("));
-            self.print_load_from_bundle(import_record_index);
-            self.print_whitespacer(ws!(b"), enumerable: true, configurable: true})"));
-        }
-
         // We must use Object.defineProperty() to handle re-exports from ESM -> CJS
         pub fn print_bundled_export(&mut self, name: &[u8], identifier: &[u8]) {
             self.print(b"Object.defineProperty(");
@@ -6883,8 +6711,7 @@ pub mod __gated_printer {
             self.print_semicolon_after_statement();
 
             if REWRITE_ESM_TO_CJS && is_export && !decls.is_empty() {
-                // PORT NOTE: Zig stored `?GeneratedSymbol`; the Rust `runtime::Imports`
-                // flattens this to `Option<Ref>`, so no `.ref_` projection.
+                // `runtime::Imports` flattens this to `Option<Ref>`, so no `.ref_` projection.
                 let export_ref = self.options.runtime_imports.__export.unwrap();
                 for decl in decls {
                     self.print_indent();
@@ -6996,7 +6823,7 @@ pub mod __gated_printer {
                 i += 1;
 
                 if strings::u16_is_lead(name[i - 1]) && i < n {
-                    // INTENTIONALLY no `u16_is_trail` check — matches Zig js_printer.zig:5311.
+                    // INTENTIONALLY no `u16_is_trail` check.
                     c = strings::u16_get_supplementary(name[i - 1], name[i]);
                     i += 1;
                 }
@@ -7146,9 +6973,8 @@ pub mod __gated_printer {
                 was_lazy_export: false,
                 module_info: None,
             };
-            // Spec js_printer.zig:5454-5460 caches `line_offset_tables.items(.byte_offset_to_start_of_line)`
-            // into `line_offset_table_byte_offset_list`. The Rust `Builder` field is `&'static [u32]`
-            // pending lifetime threading, so instead of caching a self-borrow here,
+            // The `Builder` field is `&'static [u32]` pending lifetime threading,
+            // so instead of caching a self-borrow here,
             // `Builder::add_source_mapping` derives the slice on demand from `line_offset_tables`
             // via `ListExt::items_byte_offset_to_start_of_line()` (see Chunk.rs).
             let _ = GENERATE_SOURCE_MAP;
@@ -7179,7 +7005,6 @@ pub mod __gated_printer {
 
             // Special-case lazy-export AST
             if ast.has_lazy_export {
-                // @branchHint(.unlikely)
                 self.print_fn_args(
                     Some(func.open_parens_loc),
                     slice_of(func.args),
@@ -7329,7 +7154,7 @@ pub mod __gated_printer {
 } // mod __gated_printer
 
 // ───────────────────────────────────────────────────────────────────────────
-// PrintArg helper trait (Zig's `anytype` for `print()`)
+// PrintArg helper trait (polymorphic args for `print()`)
 // ───────────────────────────────────────────────────────────────────────────
 
 pub trait PrintArg {
@@ -7340,9 +7165,8 @@ impl PrintArg for u8 {
         w.print_byte(self);
     }
 }
-// PORT NOTE: Zig `print(str: anytype)` matched `comptime_int, u16, u8` and narrowed via
-// `@as(u8, @intCast(str))` before `writeByte`. Mirror that for `u16` so wide-int char callers
-// (e.g. UTF-16 iteration) compile and emit one byte identically.
+// `u16` narrows to one byte so wide-int char callers (e.g. UTF-16 iteration)
+// compile and emit a single byte.
 impl PrintArg for u16 {
     #[inline]
     fn print_into<W: WriterTrait>(self, w: &mut W) {
@@ -7387,8 +7211,7 @@ pub struct WriteResult {
     pub end_off: u32,
 }
 
-/// Backend operations a `Writer` context provides. Mirrors the comptime fn-pointer
-/// params of Zig's `NewWriter(...)`.
+/// Backend operations a `Writer` context provides.
 pub trait WriterContext {
     fn write_byte(&mut self, char: u8) -> Result<usize, bun_core::Error>;
     fn write_all(&mut self, buf: &[u8]) -> Result<usize, bun_core::Error>;
@@ -7406,7 +7229,6 @@ pub trait WriterContext {
     fn done(&mut self) -> Result<(), bun_core::Error> {
         Ok(())
     }
-    // TODO(port): copyFileRange optional method (`@hasDecl` check in Zig)
 }
 
 /// Abstracted writer interface used by `Printer` (the methods Printer calls on `p.writer`).
@@ -7420,7 +7242,6 @@ pub trait WriterTrait {
     fn advance(&mut self, count: u64);
     /// Reserve `bytes.len()`, memcpy `bytes` into the reserved region, then advance.
     /// Centralizes the open-coded `reserve + copy_nonoverlapping + advance` triplet
-    /// (Zig js_printer.zig:874, 1505-1573, 5332, 5340 all open-code this).
     #[inline]
     fn write_reserved(&mut self, bytes: &[u8]) -> Result<(), bun_core::Error> {
         let ptr = self.reserve(bytes.len() as u64)?;
@@ -7440,7 +7261,8 @@ pub trait WriterTrait {
         StdWriterAdapter(self)
     }
     fn take_buffer(&mut self) -> MutableString;
-    // TODO(port): get_mutable_buffer / ctx access for source-map chunk generation
+    // No `ctx`/`get_mutable_buffer` accessor: source-map chunk generation reads
+    // the written bytes through `slice()`.
 }
 
 pub struct StdWriterAdapter<'a, W: ?Sized>(&'a mut W);
@@ -7478,22 +7300,6 @@ impl<C: WriterContext> Writer<C> {
         Ok(bytes.len())
     }
 
-    pub fn is_copy_file_range_supported() -> bool {
-        // TODO(port): @hasDecl(ContextType, "copyFileRange")
-        false
-    }
-
-    pub fn copy_file_range(
-        ctx: C,
-        in_file: Fd,
-        start: usize,
-        end: usize,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): ctx.sendfile(in_file, start, end)
-        let _ = (ctx, in_file, start, end);
-        Ok(())
-    }
-
     pub fn get_mutable_buffer(&mut self) -> &mut MutableString {
         self.ctx.get_mutable_buffer()
     }
@@ -7529,9 +7335,9 @@ impl<C: WriterContext> Writer<C> {
 
     pub fn advance(&mut self, count: u64) {
         self.ctx.advance_by(count);
-        // PERF(port): @intCast — output never approaches 2 GiB; checked add of
+        // PERF: output never approaches 2 GiB; the checked add of
         // a u64→i32 here was a measurable branch in the per-token print path.
-        // Keep Zig's debug-mode @intCast contract without paying for it in release.
+        // Keep the debug-mode overflow check without paying for it in release.
         debug_assert!(count <= i32::MAX as u64);
         self.written = self.written.wrapping_add(count as i32);
     }
@@ -7703,12 +7509,12 @@ impl DirectWriter {
 
 pub struct BufferWriter {
     pub buffer: MutableString,
-    /// Watermark into `buffer.list` set by `done()`. Zig stored `written: []u8` aliasing
-    /// `buffer`; Rust can't keep a self-borrowing slice in a field, so store the length and
+    /// Watermark into `buffer.list` set by `done()`. Rust can't keep a
+    /// self-borrowing slice in a field, so store the length and
     /// reslice on read (`written()` / `written_without_trailing_zero()`). Avoids the O(n)
     /// `to_vec().into_boxed_slice()` copy the previous port did on every `done()`.
     pub written_len: usize,
-    pub sentinel: &'static bun_core::ZStr, // TODO(port): lifetime — Zig stored a sentinel slice into `buffer`
+    // `done()` appends a NUL terminator when `append_null_byte` is true.
     pub append_null_byte: bool,
     pub append_newline: bool,
 }
@@ -7726,7 +7532,7 @@ impl BufferWriter {
         self.buffer.list.as_slice()
     }
 
-    /// Slice set by `done()` — zero-cost reslice of `buffer` (matches Zig's `ctx.written`).
+    /// Slice set by `done()` — zero-cost reslice of `buffer`.
     pub fn written(&self) -> &[u8] {
         &self.buffer.list[..self.written_len]
     }
@@ -7735,7 +7541,6 @@ impl BufferWriter {
         BufferWriter {
             buffer: MutableString::init_empty(),
             written_len: 0,
-            sentinel: bun_core::ZStr::EMPTY,
             append_null_byte: false,
             append_newline: false,
         }
@@ -7750,7 +7555,6 @@ impl BufferWriter {
         BufferWriter {
             buffer: MutableString::init(capacity).unwrap_or_else(|_| MutableString::init_empty()),
             written_len: 0,
-            sentinel: bun_core::ZStr::EMPTY,
             append_null_byte: false,
             append_newline: false,
         }
@@ -7834,11 +7638,16 @@ impl BufferWriter {
         }
 
         if self.append_null_byte {
-            // TODO(port): self.sentinel = self.buffer.slice_with_sentinel() — borrows buffer
-            self.written_len = self.buffer.list.len();
-        } else {
-            self.written_len = self.buffer.list.len();
+            // Append a NUL unless the buffer already ends with one; the NUL is
+            // *included* in `written` (consumers strip it via
+            // `written_without_trailing_zero`).
+            //
+            // For an *empty* buffer we still append the NUL.
+            if self.buffer.list.last().copied() != Some(0) {
+                self.buffer.append_char(0)?;
+            }
         }
+        self.written_len = self.buffer.list.len();
         Ok(())
     }
 
@@ -7943,13 +7752,12 @@ impl GenerateSourceMap {
 // former `__gated_entry_points` wrapper has been flattened away).
 // `print_ast` is live (borrowck reshape: `opts` re-reads routed through
 // `printer.options`, `*mut Symbol` for `must_not_be_renamed`, raw-ptr
-// `Scope.parent` backref). `print_json` remains individually re-gated on
-// lower-tier surface (see TODO(port) markers inline).
+// `Scope.parent` backref). `print_json` is live as well.
 // ───────────────────────────────────────────────────────────────────────────
 use self::__gated_printer::{Printer, slice_of};
 use js_ast::Ast;
 
-// PORT NOTE: Zig had `comptime generate_source_map`; Rust's `generic_const_exprs`
+// `generate_source_map` is a runtime arg: `generic_const_exprs`
 // can't compute a non-`bool` const-generic from a `bool` const-generic without
 // viral `where` clauses, and the body only does runtime branches anyway. The
 // `IS_BUN_PLATFORM` axis stays const so `prepend_count` is still a compile-time
@@ -7973,15 +7781,12 @@ pub fn get_source_map_builder<const IS_BUN_PLATFORM: bool>(
         cover_lines_without_mappings: true,
         approximate_input_line_count: tree.approximate_newline_count,
         prepend_count: IS_BUN_PLATFORM && generate_source_map == GenerateSourceMap::Lazy,
-        // PORT NOTE: Zig copied `opts.line_offset_tables orelse generate(...)`
-        // by value (shallow copy of the unmanaged `MultiArrayList` header).
-        // `Options.line_offset_tables` is now a borrow into shared linker
-        // state; mirror Zig's bitwise copy via `ptr::read` into a
+        // `Options.line_offset_tables` is a borrow into shared linker
+        // state; copy it bitwise via `ptr::read` into a
         // `ManuallyDrop` so dropping the `Builder` never frees borrowed
         // storage. When no table is supplied (the runtime/transpiler path) we
         // leave this `EMPTY` and let the builder build it lazily on the first
-        // mapping (see `set_deferred_line_offset_table` below) — matching the
-        // Zig transpiler, which only builds the table on demand.
+        // mapping (see `set_deferred_line_offset_table` below).
         line_offset_tables: core::mem::ManuallyDrop::new(match precomputed {
             // SAFETY: `borrowed` points to a valid `List` owned by the caller
             // (e.g. `LinkerGraph.files[i].line_offset_table`). The bitwise
@@ -8032,22 +7837,19 @@ pub fn print_ast<'a, W: WriterTrait, const ASCII_ONLY: bool, const GENERATE_SOUR
     let _restore =
         bun_crash_handler::scoped_action(bun_crash_handler::Action::Print(source.path.text));
 
-    // PORT NOTE: Zig declared `renamer`/`no_op_renamer` undefined and assigned per
-    // branch. `Renamer<'r,'src>` is invariant in `'src` (it holds `&'r mut
+    // `Renamer<'r,'src>` is invariant in `'src` (it holds `&'r mut`
     // NoOpRenamer<'src>`), so the two arms must agree on `'src`; constructing the
     // `MinifyRenamer` variant inline (rather than via `to_renamer() ->
     // Renamer<'static,'static>`) lets inference unify it with the no-op arm.
     let mut no_op_renamer;
-    // PORT NOTE: hoisted out of the `minify_identifiers` arm so the
+    // hoisted out of the `minify_identifiers` arm so the
     // `&'r mut MinifyRenamer` borrow stored in `renamer` outlives the branch.
     let mut minify_renamer;
     let renamer: rename::Renamer<'_, '_>;
-    // PORT NOTE: Zig copied `tree.module_scope` to a stack local and re-pointed
-    // children's `parent` at the local. `Scope` isn't `Copy` here and the only
+    // `Scope` isn't `Copy` here and the only
     // consumer (`compute_reserved_names_for_scope`) walks `members`/`generated`/
     // `children` — never `parent` — so we re-point at the in-place
-    // `tree.module_scope` instead (lives for `'a`, strictly safer than the Zig
-    // stack-local backref).
+    // `tree.module_scope` instead (lives for `'a`).
     let module_scope = &tree.module_scope;
     let stable_source_indices = [source.index.0];
     if opts.minify_identifiers {
@@ -8074,9 +7876,8 @@ pub fn print_ast<'a, W: WriterTrait, const ASCII_ONLY: bool, const GENERATE_SOUR
         let module_ref = tree.module_ref;
         let parts = &tree.parts;
 
-        // PORT NOTE: `symbols` was moved into `minify_renamer`; reach it through
-        // the renamer for the post-init `must_not_be_renamed` pass (Zig held a
-        // by-value copy).
+        // `symbols` was moved into `minify_renamer`; reach it through
+        // the renamer for the post-init `must_not_be_renamed` pass.
         let dont_break_the_code = [tree.module_ref, tree.exports_ref, tree.require_ref];
         for ref_ in dont_break_the_code {
             if let Some(symbol) = minify_renamer.symbols.get_mut(ref_) {
@@ -8137,7 +7938,7 @@ pub fn print_ast<'a, W: WriterTrait, const ASCII_ONLY: bool, const GENERATE_SOUR
 
     // defer: if minify_identifiers { renamer.deinit() } — Drop handles.
 
-    // Spec js_printer.zig:6024 — `is_bun_platform = ascii_only` for printAst.
+    // `is_bun_platform = ascii_only` for printAst.
     type PrinterType<'a, W, const A: bool, const G: bool> =
         Printer<'a, W, A, false, /*IS_BUN_PLATFORM=*/ A, false, G>;
     let mut writer = _writer;
@@ -8169,13 +7970,12 @@ pub fn print_ast<'a, W: WriterTrait, const ASCII_ONLY: bool, const GENERATE_SOUR
     // via `OwnedLineOffsetTables::Drop`). No caller of `print_ast` supplies a
     // precomputed table.
     printer.was_lazy_export = tree.has_lazy_export;
-    // PORT NOTE: borrowck reshape — `opts` was moved into `Printer::init`; mirror
-    // Zig's post-init `printer.module_info = opts.module_info` by taking it back
-    // out of `printer.options` (see `print_with_writer_and_platform`).
+    // Borrowck: `opts` was moved into `Printer::init`; populate
+    // `printer.module_info` by taking it back out of `printer.options`
+    // (see `print_with_writer_and_platform`).
     if PrinterType::<W, ASCII_ONLY, GENERATE_SOURCE_MAP>::MAY_HAVE_MODULE_INFO {
         printer.module_info = printer.options.module_info.take();
     }
-    // PERF(port): was stack-fallback allocator for binary_expression_stack
     printer.binary_expression_stack = Vec::new();
 
     if !printer.options.bundling
@@ -8224,8 +8024,7 @@ pub fn print_ast<'a, W: WriterTrait, const ASCII_ONLY: bool, const GENERATE_SOUR
 
     let mut source_maps_chunk: Option<SourceMap::Chunk> = if GENERATE_SOURCE_MAP {
         if printer.options.source_map_handler.is_some() {
-            // PORT NOTE: Zig used `printer.writer.ctx.getWritten()`; WriterTrait
-            // exposes the same buffer via `slice()` (cf. print_with_writer_and_platform).
+            // WriterTrait exposes the written buffer via `slice()`.
             Some(
                 printer
                     .source_map_builder
@@ -8280,11 +8079,8 @@ pub fn print_json<W: WriterTrait>(
     // NewPrinter(ascii_only=false, Writer, rewrite_esm_to_cjs=false, is_bun_platform=false, is_json=true, generate_source_map=false)
     type PrinterType<'a, W> = Printer<'a, W, false, false, false, true, false>;
     let writer = _writer;
-    // PORT NOTE: Zig built a throwaway `Ast.initTest(&parts)` (wrapping `expr` in
-    // an `S.SExpr`/Part) solely so the printer could read its default-empty
-    // `import_records` and `symbols` for the no-op renamer; the body then calls
-    // `printExpr(expr, ...)` directly without ever walking those parts. Rust
-    // constructs the same empty inputs without round-tripping through `Ast`.
+    // The printer only needs default-empty `import_records` and `symbols` for
+    // the no-op renamer; construct them directly without an `Ast`.
     let bump = bun_alloc::Arena::new();
     let mut no_op =
         rename::NoOpRenamer::init(js_ast::symbol::Map::init_list(vec![Vec::new()]), source);
@@ -8303,7 +8099,6 @@ pub fn print_json<W: WriterTrait>(
         no_op.to_renamer(),
         SourceMap::chunk::Builder::default(), // undefined
     );
-    // PERF(port): was stack-fallback allocator
     printer.binary_expression_stack = Vec::new();
 
     printer.print_expr(expr, js_ast::op::Level::Lowest, ExprFlagSet::empty());
@@ -8421,19 +8216,16 @@ pub fn print_with_writer_and_platform<
         source_map_builder,
     );
     printer.was_lazy_export = ast.has_lazy_export;
-    // PORT NOTE: `Printer::init` already moved `opts.module_info` (it's a field of
-    // `Options`); re-assigning it post-construction (as Zig does) would be a
-    // use-after-move in Rust. The field already lives on `printer.options.module_info`
-    // and `printer.module_info` was set to `None` by `init`, so mirror Zig by
-    // taking it back out of `printer.options`.
+    // `Printer::init` already moved `opts.module_info` (it's a field of
+    // `Options`); `printer.module_info` was set to `None` by `init`, so take
+    // it back out of `printer.options`.
     if PrinterType::<W, IS_BUN_PLATFORM, GENERATE_SOURCE_MAPS>::MAY_HAVE_MODULE_INFO {
         printer.module_info = printer.options.module_info.take();
     }
-    // PERF(port): was stack-fallback allocator
     printer.binary_expression_stack = Vec::new();
     // defer: temporary_bindings.deinit / writer.* = printer.writer.* — handled by move-out below.
 
-    // `Index::is_runtime` ⇔ `index.value == 0` (src/js_parser/ast/base.zig).
+    // `Index::is_runtime` ⇔ `index.value == 0`.
     if module_type == bundle_opts::Format::InternalBakeDev && source.index.0 != 0 {
         printer.print_dev_server_module(source, ast, &parts[0]);
     } else {
@@ -8466,8 +8258,8 @@ pub fn print_with_writer_and_platform<
         return PrintResult::Err(err);
     }
 
-    // TODO(port): need ctx accessor on WriterTrait for getWritten()
-    let written = printer.writer.slice(); // PORT NOTE: Zig used printer.writer.ctx.getWritten()
+    // `slice()` exposes the written buffer.
+    let written = printer.writer.slice();
     let source_map: Option<SourceMap::Chunk> = if GENERATE_SOURCE_MAPS {
         'brk: {
             if written.is_empty() || printer.source_map_builder.source_map.should_ignore() {
@@ -8529,7 +8321,6 @@ pub fn print_common_js<
     );
     // `defer { if (generate_source_map) printer.source_map_builder.line_offset_tables.deinit(opts.allocator); }`
     // — no longer needed: see `print_ast` above.
-    // PERF(port): was stack-fallback allocator
     printer.binary_expression_stack = Vec::new();
 
     for part in tree.parts.iter() {
@@ -8576,5 +8367,3 @@ pub fn serialize_module_info(
     }
     Some(buf.into_boxed_slice())
 }
-
-// ported from: src/js_printer/js_printer.zig
diff --git a/src/js_printer/renamer.rs b/src/js_printer/renamer.rs
index b0a22ac298d..203ce5dce5a 100644
--- a/src/js_printer/renamer.rs
+++ b/src/js_printer/renamer.rs
@@ -30,8 +30,7 @@ const fn name_str_empty() -> NameStr {
     bun_ast::StoreStr::EMPTY
 }
 
-/// Const array for `inline for (SlotNamespace.values)` translation. Skips
-/// `MustNotBeRenamed` (Zig's `inline for` over the renameable namespaces).
+/// The renameable slot namespaces. Skips `MustNotBeRenamed`.
 const SLOT_NAMESPACES: [SlotNamespace; 4] = [
     SlotNamespace::Default,
     SlotNamespace::Label,
@@ -55,7 +54,7 @@ const SLOT_NAMESPACES: [SlotNamespace; 4] = [
 /// Replaces the previous `StringHashMap<u32>` (whose `put_no_clobber` heap-boxed
 /// a `Box<[u8]>` copy of the key) with a `Copy` 16-byte key that needs no
 /// allocation on insert and no free on the per-scope drop in the renamer's
-/// pool walkback. Same shape as Zig's `StringHashMapUnmanaged([]const u8, u32)`.
+/// pool walkback.
 #[derive(Clone, Copy)]
 pub struct NameKey(NameStr);
 
@@ -97,10 +96,7 @@ pub(crate) type NameCountMap =
     bun_collections::hashbrown::HashMap<NameKey, u32, bun_wyhash::BuildHasher>;
 
 pub struct NoOpRenamer<'a> {
-    // PORT NOTE: Zig `Symbol.Map` is a non-owning `BabyList(BabyList(Symbol))`
-    // slice header passed by value (renamer.zig:2,126,452 — no `deinit` ever
-    // frees it). In the Rust port `symbol::Map` is `Vec<Vec<Symbol>>` (owning).
-    // Unlike `MinifyRenamer`/`NumberRenamer` (which the bundler builds over a
+    // `symbol::Map` is `Vec<Vec<Symbol>>` (owning). Unlike `MinifyRenamer`/`NumberRenamer` (which the bundler builds over a
     // *borrowed* `LinkerGraph.symbols` and so wrap in `ManuallyDrop`),
     // `NoOpRenamer` is only constructed by `print_ast`/`print_common_js`, whose
     // callers always pass an *owned* Map freshly built by
@@ -135,9 +131,11 @@ impl<'a> NoOpRenamer<'a> {
             // SAFETY: `original_name` is an AST-arena slice that outlives the renamer.
             symbol.original_name.slice()
         } else {
-            // TODO(port): include `self.source.path.text` once `bun_paths::fs::Path<'static>`
-            // exposes the text accessor.
-            Output::panic(format_args!("Invalid symbol {}", ref_));
+            Output::panic(format_args!(
+                "Invalid symbol {} in {}",
+                ref_,
+                bstr::BStr::new(self.source.path.text)
+            ));
         }
     }
 
@@ -146,9 +144,9 @@ impl<'a> NoOpRenamer<'a> {
     }
 }
 
-// PORT NOTE: two lifetime params — `'r` is the borrow of the underlying renamer,
-// `'src` is `NoOpRenamer`'s borrow of the `Source`. The Zig `Renamer` was a
-// tag+ptr union that erased both; using `&'a mut NoOpRenamer<'a>` would make
+// Two lifetime params — `'r` is the borrow of the underlying renamer,
+// `'src` is `NoOpRenamer`'s borrow of the `Source`. Erasing both with a
+// single lifetime via `&'a mut NoOpRenamer<'a>` would make
 // `'a` invariant and lock the source borrow to the renamer borrow.
 pub enum Renamer<'r, 'src> {
     NumberRenamer(&'r mut NumberRenamer),
@@ -182,10 +180,6 @@ impl<'r, 'src> Renamer<'r, 'src> {
     }
 }
 
-// PORT NOTE: Zig `Renamer.deinit` freed NumberRenamer/MinifyRenamer internals.
-// In Rust all three variants are `&'r mut` (caller-owned, Drop on caller's
-// storage). No explicit deinit needed.
-
 #[derive(Clone, Copy)]
 pub struct SymbolSlot {
     // Most minified names are under 15 bytes
@@ -251,7 +245,6 @@ impl TinyString {
         if input.len() <= 15 {
             Ok(TinyString::InlineString(InlineString::init(input)))
         } else {
-            // Zig: `allocator.dupe(u8, input)` — allocate into the renamer arena.
             let duped: &[u8] = arena.alloc_slice_copy(input);
             Ok(TinyString::String(bun_ast::StoreStr::new(duped)))
         }
@@ -276,7 +269,7 @@ pub struct MinifyRenamer {
     pub top_level_symbol_to_slot: TopLevelSymbolSlotMap,
     pub symbols: ManuallyDrop<symbol::Map>,
     pub owns_symbols: bool,
-    /// Backs `TinyString::String` slot-name allocations (Zig: `this.allocator`).
+    /// Backs `TinyString::String` slot-name allocations.
     pub arena: Bump,
 }
 
@@ -289,8 +282,6 @@ impl Drop for MinifyRenamer {
     }
 }
 
-// TODO(port): Zig used `std.HashMapUnmanaged(Ref, usize, RefCtx, 80)` —
-// bun_collections::HashMap should be parameterized with RefCtx hasher.
 pub(crate) type TopLevelSymbolSlotMap = HashMap<Ref, usize>;
 
 impl MinifyRenamer {
@@ -356,7 +347,7 @@ impl MinifyRenamer {
         symbol_uses: &js_ast::part::SymbolUseMap,
         stable_source_indices: &[u32],
     ) -> Result<(), bun_alloc::AllocError> {
-        // PORT NOTE: ArrayHashMap exposes parallel keys()/values() slices, no .iter().
+        // ArrayHashMap exposes parallel keys()/values() slices, no .iter().
         for (key, value) in symbol_uses.keys().iter().zip(symbol_uses.values().iter()) {
             self.accumulate_symbol_use_count(
                 top_level_symbols,
@@ -415,7 +406,7 @@ impl MinifyRenamer {
     ) -> Result<(), bun_alloc::AllocError> {
         for stable in top_level_symbols {
             let symbol: &Symbol = self.symbols.get_const(stable.ref_).unwrap();
-            // PORT NOTE: reshaped for borrowck — capture symbol fields before mut-borrowing slots
+            // Reshaped for borrowck — capture symbol fields before mut-borrowing slots
             let ns = symbol.slot_namespace();
             let must_start_with_capital = symbol.must_start_with_capital_letter_for_jsx;
             let slots = &mut self.slots[ns];
@@ -447,7 +438,6 @@ impl MinifyRenamer {
 
         let mut sorted: Vec<SlotAndCount> = Vec::new();
 
-        // PERF(port): was `inline for` over enum values — profile
         for &ns in SLOT_NAMESPACES.iter() {
             let slots = &mut self.slots[ns];
             sorted.clear();
@@ -530,9 +520,6 @@ impl StableSymbolCount {
     }
 }
 
-// PORT NOTE: Zig `packed struct(u64)`. Packed layout is not load-bearing here
-// (never bitcast/FFI — only sorted in a local Vec), so two named u32 fields
-// instead of a #[repr(transparent)] u64 with shift accessors.
 #[repr(C)]
 #[derive(Clone, Copy)]
 struct SlotAndCount {
@@ -548,17 +535,13 @@ impl SlotAndCount {
 }
 
 pub struct NumberRenamer {
-    // PORT NOTE: see `NoOpRenamer.symbols` — non-owning view; Zig
-    // `NumberRenamer.deinit` (renamer.zig:462) never frees `symbols`.
+    // See `NoOpRenamer.symbols` — non-owning view.
     pub symbols: ManuallyDrop<symbol::Map>,
     pub names: Box<[Vec<NameStr>]>,
-    // PERF(port): Zig had separate allocator/temp_allocator; global mimalloc now
     pub number_scope_pool: HiveArrayFallback<NumberScope, 128>,
-    // PERF(port): was arena bulk-free for NumberScope pool + name temp buffers
     pub root: NumberScope,
-    /// Backs renamed-name slices written into `names` (Zig: `r.allocator`).
+    /// Backs renamed-name slices written into `names`.
     pub arena: Bump,
-    // PERF(port): was StackFallbackAllocator(512) — profile
 }
 
 impl NumberRenamer {
@@ -598,7 +581,6 @@ impl NumberRenamer {
 
         // SAFETY: `original_name` is an AST-arena slice that outlives the renamer.
         let original_name: &[u8] = symbol.original_name.slice();
-        // PERF(port): Zig reset stack-fallback FBA here; arena reset semantics differ
         let name: NameStr = match scope.find_unused_name(&self.arena, original_name) {
             UnusedName::Renamed(name) => name,
             UnusedName::NoCollision => symbol.original_name,
@@ -619,7 +601,6 @@ impl NumberRenamer {
             .take(len)
             .collect();
 
-        // PERF(port): HiveArray.Fallback was bound to arena.arena() in Zig
         let number_scope_pool = HiveArrayFallback::<NumberScope, 128>::init();
 
         // The arena is created here (before `root.name_counts`) so the
@@ -637,10 +618,11 @@ impl NumberRenamer {
             root.name_counts.insert(NameKey(NameStr::new(duped)), value);
         }
 
-        // TODO(b2-blocked): bun_core::env_var::BUN_DUMP_SYMBOLS — typed accessor
-        // not yet declared upstream; debug-only `symbols.dump()` call elided.
-
-        // PORT NOTE: Zig @memset(sliceAsBytes(names), 0) — Vec::default() is already zeroed.
+        // Debug-only, presence-checked symbol dump.
+        #[cfg(debug_assertions)]
+        if bun_core::env_var::BUN_DUMP_SYMBOLS.get().is_some() {
+            symbols.dump();
+        }
 
         Ok(Box::new(NumberRenamer {
             symbols: ManuallyDrop::new(symbols),
@@ -668,8 +650,6 @@ impl NumberRenamer {
 
         self.assign_names_recursive_with_number_scope(s, scope, source_index, sorted);
 
-        // PORT NOTE: Zig `defer { s.deinit(); pool.put(s) }` — fn is infallible,
-        // so no scopeguard needed; cleanup runs unconditionally below.
         // SAFETY: s came from number_scope_pool.get() and was initialized above;
         // `put` drops `name_counts` in place before recycling the slot.
         unsafe { self.number_scope_pool.put(s) };
@@ -756,10 +736,7 @@ impl NumberRenamer {
             self.assign_names_recursive_with_number_scope(s, child, source_index, sorted);
         }
 
-        // PORT NOTE: Zig (renamer.zig:594-598) only put the final `s` because
-        // both the pool fallback (`.init(renamer.arena.allocator())`) and
-        // `name_counts` data lived in arenas bulk-freed by `NumberRenamer.deinit
-        // -> arena.deinit()`. The Rust port moved both to the global heap
+        // The pool fallback and `name_counts` data live on the global heap
         // (HiveArrayFallback::init() uses Box, StringHashMap uses global alloc),
         // so we must walk the parent chain and `put` every intermediate scope
         // we allocated in the loop above — not just the deepest one.
@@ -779,8 +756,10 @@ impl NumberRenamer {
     }
 
     pub fn add_top_level_symbol(&mut self, ref_: Ref) {
-        // PORT NOTE: reshaped for borrowck — root is a field of self
-        // TODO(port): self.assign_name needs &mut self AND &mut self.root simultaneously
+        // Reshaped for borrowck — root is a field of self, but `assign_name`
+        // needs `&mut self` AND `&mut self.root` simultaneously. Sound only
+        // while `assign_name` never reaches `self.root` through `self`; keep
+        // that invariant if `assign_name` changes.
         let root: *mut NumberScope = &raw mut self.root;
         // SAFETY: assign_name does not touch self.root through `self`
         self.assign_name(unsafe { &mut *root }, ref_);
@@ -891,11 +870,11 @@ pub enum UnusedName {
 
 /// Fast-path for `MutableString::ensure_valid_identifier`: returns `true` iff
 /// `s` is a non-empty ASCII identifier (`[A-Za-z_$][A-Za-z0-9_$]*`). This is
-/// the exact condition under which Zig's `ensureValidIdentifier` returns the
-/// input slice unchanged (modulo the strict-mode-reserved-word remap, handled
-/// by the caller). The Rust port of that function currently always allocates
-/// a `Box<[u8]>` even on the borrow path — see its `TODO(port)` — so hoisting
-/// this check into the renamer restores Zig's zero-alloc behaviour for the
+/// the exact condition under which `MutableString::ensure_valid_identifier`
+/// returns the input unchanged (modulo the strict-mode-reserved-word remap,
+/// handled by the caller). That function currently always allocates
+/// a `Box<[u8]>` even on the borrow path, so hoisting
+/// this check into the renamer keeps zero-alloc behaviour for the
 /// overwhelmingly common case (`symbol.original_name` is parser-produced and
 /// almost always satisfies this).
 #[inline]
@@ -917,10 +896,10 @@ fn is_simple_ascii_identifier(s: &[u8]) -> bool {
 impl NumberScope {
     /// Caller must use an arena allocator
     pub fn find_unused_name(&mut self, arena: &Bump, input_name: &[u8]) -> UnusedName {
-        // PORT NOTE: Zig's `MutableString.ensureValidIdentifier` borrows the
-        // input when it is already a valid ASCII identifier; the Rust port
-        // always heap-allocates (Box<[u8]>). Skip the call entirely for the
-        // common case so this stays alloc-free, matching the .zig fast path.
+        // `MutableString::ensure_valid_identifier` always heap-allocates
+        // (Box<[u8]>), even when the input is already a valid ASCII
+        // identifier. Skip the call entirely for the common case so this
+        // stays alloc-free.
         // The strict-mode-reserved-word remap (`let` → `_let`, etc.) is the
         // only transform that fires for an otherwise-valid ASCII name, so
         // gate on that too and fall through to the full normalizer when it
@@ -937,7 +916,7 @@ impl NumberScope {
             owned_name = MutableString::ensure_valid_identifier(input_name).expect("unreachable");
             &owned_name
         };
-        // PORT NOTE: hoisted from inside the match arm so `name` (which may borrow
+        // Hoisted from inside the match arm so `name` (which may borrow
         // it) stays valid through the trailing dupe.
         let mut mutable_name = MutableString::init_empty();
         // True iff a "name2"/"name3" suffix was appended below (i.e. `name` was
@@ -982,8 +961,7 @@ impl NumberScope {
                         if matches!(use_, NameUse::SameScope(_)) {
                             // `prefix` may borrow the local `owned_name`; if a
                             // new entry is needed, dupe into the renamer arena
-                            // so the `NameKey` outlives this function. Mirrors
-                            // Zig's conditional `allocator.dupe(u8, prefix)`.
+                            // so the `NameKey` outlives this function.
                             *self.entry_or_arena_dup(prefix, arena) = tries;
                         }
                         name = mutable_name.slice();
@@ -1029,7 +1007,6 @@ impl NumberScope {
             return UnusedName::NoCollision;
         }
 
-        // Zig: `allocator.dupe(u8, name)` — allocate into the renamer arena.
         let duped: &[u8] = arena.alloc_slice_copy(name);
         let name: NameStr = bun_ast::StoreStr::new(duped);
 
@@ -1043,8 +1020,7 @@ impl NumberScope {
     /// `name_counts.entry(prefix).or_insert(0)` with a vacant-only arena dup:
     /// when the key is already present we mutate it in place; when it is not,
     /// the bytes are bump-allocated into `arena` so the resulting [`NameKey`]
-    /// outlives the renamer. Mirrors Zig's `getOrPut` + conditional
-    /// `allocator.dupe(u8, prefix)` shape.
+    /// outlives the renamer.
     fn entry_or_arena_dup(&mut self, prefix: &[u8], arena: &Bump) -> &mut u32 {
         use bun_collections::hashbrown::hash_map::RawEntryMut;
         match self.name_counts.raw_entry_mut().from_key(prefix) {
@@ -1061,7 +1037,7 @@ pub struct ExportRenamer {
     pub string_buffer: MutableString,
     pub used: StringHashMap<u32>,
     pub count: isize,
-    /// Backs renamed export-name slices returned to the caller (Zig: caller's allocator).
+    /// Backs renamed export-name slices returned to the caller.
     pub arena: Bump,
 }
 
@@ -1098,13 +1074,12 @@ impl ExportRenamer {
                 .expect("unreachable");
                 tries += 1;
                 let attempt: &[u8] = self.string_buffer.slice();
-                // PORT NOTE: reshaped for borrowck — `get_or_put` borrows `self.used`
+                // Reshaped for borrowck — `get_or_put` borrows `self.used`
                 // mutably, so allocate the arena copy first.
                 let to_use: &[u8] = self.arena.alloc_slice_copy(attempt);
                 let entry = self.used.get_or_put(to_use).expect("unreachable");
                 if !entry.found_existing {
-                    // PORT NOTE: `StringHashMap` owns a boxed copy of the key on
-                    // insert; the Zig key-ptr write is unnecessary.
+                    // `StringHashMap` owns a boxed copy of the key on insert.
                     *entry.value_ptr = tries;
 
                     let entry = self.used.get_or_put(input).expect("unreachable");
@@ -1118,14 +1093,12 @@ impl ExportRenamer {
             *entry.value_ptr = tries;
         }
 
-        // PORT NOTE: Zig returned `entry.key_ptr.*` (the map's owned copy of `input`).
         // `StringHashMap` does not expose a key pointer; allocate a copy in `self.arena`
         // so the returned slice is tied to `&self` (sub-borrow of `&mut self`).
         self.arena.alloc_slice_copy(input)
     }
 
     pub fn next_minified_name(&mut self) -> Result<Vec<u8>, bun_core::Error> {
-        // TODO(port): narrow error set
         let name = js_ast::NameMinifier::default_number_to_minified_name(self.count)?;
         self.count += 1;
         Ok(name)
@@ -1158,12 +1131,10 @@ pub fn compute_initial_reserved_names(
     )?;
 
     for keyword in Keywords.keys() {
-        // PERF(port): was assume_capacity
         names.put_assume_capacity(keyword, 1);
     }
 
     for keyword in StrictModeReservedWords.iter() {
-        // PERF(port): was assume_capacity
         names.put_assume_capacity(keyword, 1);
     }
 
@@ -1176,13 +1147,11 @@ pub fn compute_initial_reserved_names(
     // something in a nested scope as an top-level export.
     if output_format == Format::Cjs {
         for name in CJS_NAMES {
-            // PERF(port): was assume_capacity
             names.put_assume_capacity(name, 1);
         }
     }
 
     for extra in EXTRAS {
-        // PERF(port): was assume_capacity
         names.put_assume_capacity(extra, 1);
     }
 
@@ -1194,9 +1163,6 @@ pub fn compute_reserved_names_for_scope(
     symbols: &symbol::Map,
     names: &mut StringHashMap<u32>,
 ) {
-    // PORT NOTE: Zig copied `names_.*` to a local and wrote back via defer.
-    // In Rust we mutate through &mut directly.
-
     for member in scope.members.values() {
         let symbol: &Symbol = symbols.get_const(member.ref_).unwrap();
         if symbol.kind == symbol::Kind::Unbound || symbol.must_not_be_renamed {
@@ -1228,5 +1194,3 @@ pub fn compute_reserved_names_for_scope(
         }
     }
 }
-
-// ported from: src/js_printer/renamer.zig
diff --git a/src/jsc/AbortSignal.rs b/src/jsc/AbortSignal.rs
index e4f7d1d25b3..4b3018444a3 100644
--- a/src/jsc/AbortSignal.rs
+++ b/src/jsc/AbortSignal.rs
@@ -23,8 +23,6 @@ bun_opaque::opaque_ffi! {
     pub struct AbortSignal;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `AbortSignal` and `JSGlobalObject` are opaque `UnsafeCell`-backed ZST
 // handles, so `&AbortSignal` is ABI-identical to a non-null `AbortSignal*`
 // and C++ mutating through it (refcount, listener list, abort flag) is
@@ -71,8 +69,7 @@ unsafe extern "C" {
     safe fn WebCore__AbortSignal__new(arg0: &JSGlobalObject) -> *mut AbortSignal;
 }
 
-/// Trait expressing the Zig `comptime cb: *const fn (*Context, JSValue) void`
-/// monomorphization for `listen`. Implement on your context type.
+/// Abort-callback monomorphization for `listen`. Implement on your context type.
 pub trait AbortListener {
     fn on_abort(&mut self, reason: JSValue);
 }
@@ -158,11 +155,12 @@ impl AbortSignal {
         self.unref();
     }
 
+    /// Lifetime: the returned pointer is borrowed from the JS wrapper and is
+    /// valid only while `value` remains reachable. Use [`AbortSignal::ref_from_js`]
+    /// to take refcounted ownership instead.
     pub fn from_js(value: JSValue) -> Option<*mut AbortSignal> {
         let ptr = WebCore__AbortSignal__fromJS(value);
         if ptr.is_null() { None } else { Some(ptr) }
-        // TODO(port): lifetime — returned ptr is borrowed from the JS wrapper;
-        // valid only while the JSValue is reachable.
     }
 
     pub fn to_js(&self, global: &JSGlobalObject) -> JSValue {
@@ -188,8 +186,6 @@ impl AbortSignal {
     /// to `this` for the duration (e.g., `this.ref_(); defer this.unref();`) and avoid
     /// caching the pointer across turns.
     pub fn get_timeout(&self) -> Option<&Timeout> {
-        // TODO(port): lifetime — callers that run/cancel/deinit need `*mut`; revisit
-        // whether `&mut Timeout` (or raw ptr) is the right shape once call sites port.
         let ptr = WebCore__AbortSignal__getTimeout(self);
         // SAFETY: returned Timeout is owned by `self` and valid while `self` is held
         // (see doc comment).
@@ -223,7 +219,7 @@ unsafe impl bun_ptr::ExternalSharedDescriptor for AbortSignal {
 /// `Clone` bumps the C++ refcount via `ref()`; `Drop` decrements via `unref()`.
 /// Replaces the broken `Arc<AbortSignal>` pattern (an `Arc` of an opaque ZST
 /// cannot own a C++-allocated object — its payload address is not the C++
-/// object address). Mirrors Zig `?*AbortSignal` + manual `ref()`/`unref()`.
+/// object address).
 pub type AbortSignalRef = bun_ptr::ExternalShared<AbortSignal>;
 
 impl AbortSignal {
@@ -256,14 +252,14 @@ impl AbortReason {
         }
     }
 
-    // PORT NOTE (phase-d): `to_body_value_error` reaches into
+    // `to_body_value_error` reaches into
     // `bun_runtime::webcore::body::value::ValueError` (forward dep on
     // `bun_runtime`). The conversion is trivial and is reconstructed at the
     // call-site in `bun_runtime` once that tier un-gates.
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `AbortSignal.Timeout` — port of `src/jsc/AbortSignal.zig:Timeout`.
+// `AbortSignal.Timeout`.
 //
 // LAYERING: `EventLoopTimer` + `TimerFlags` live in `bun_event_loop` (lower
 // tier). The per-VM timer heap (`Timer::All`) lives in `bun_runtime` (higher
@@ -283,9 +279,9 @@ pub struct Timeout {
 
     /// The `Timeout`'s lifetime is owned by the AbortSignal.
     /// But this does have a ref count increment.
-    // PORT NOTE: AbortSignal is an opaque C++ type with intrusive WebCore
+    // AbortSignal is an opaque C++ type with intrusive WebCore
     // refcounting (ref/unref) that crosses FFI — PORTING.md §Pointers: never
-    // Arc here. Kept as raw `*mut` with manual unref (matches Zig).
+    // Arc here. Kept as raw `*mut` with manual unref.
     pub signal: *mut AbortSignal,
 
     /// "epoch" is reused.
@@ -300,12 +296,9 @@ bun_event_loop::impl_timer_owner!(Timeout; from_timer_ptr => event_loop_timer);
 
 impl Timeout {
     fn init(vm: *mut VirtualMachine, signal_: *mut AbortSignal, milliseconds: u64) -> *mut Timeout {
-        // Zig: `bun.timespec.now(.allow_mocked_time).addMs(@intCast(milliseconds))`.
         let deadline = bun_core::Timespec::now_allow_mocked_time()
             .add_ms(i64::try_from(milliseconds).expect("AbortSignal.timeout(ms) overflows i64"));
 
-        // PORT NOTE: `bun.TrivialNew` → `heap::alloc(Box::new(...))` (mimalloc
-        // is the global allocator per PORTING.md §Prereq).
         let this: *mut Timeout = bun_core::heap::into_raw(Box::new(Timeout {
             event_loop_timer: EventLoopTimer {
                 next: ElTimespec {
@@ -322,7 +315,6 @@ impl Timeout {
             generation: VirtualMachine::get().test_isolation_generation,
         }));
 
-        // Zig: gated on `bun.Environment.ci_assert`.
         #[cfg(debug_assertions)]
         // `AbortSignal` is an `opaque_ffi!` ZST handle; `opaque_ref` is the
         // centralised non-null deref proof (caller contract: non-null).
@@ -373,7 +365,7 @@ impl Timeout {
             }
 
             // Dispatching the signal may cause the Timeout to get freed.
-            // PORT NOTE: capture raw ptr before `this` may dangle.
+            // Capture the raw ptr before `this` may dangle.
             let signal_ptr: *mut AbortSignal = (*this).signal;
             Self::dispatch(vm, signal_ptr);
         }
@@ -382,7 +374,7 @@ impl Timeout {
     fn dispatch(vm: *mut VirtualMachine, signal_ptr: *mut AbortSignal) {
         let _ = vm;
         let vm = VirtualMachine::get();
-        // PORT NOTE: `loop.enter(); defer loop.exit();` — RAII guard `exit`s on
+        // RAII guard `exit`s on
         // drop even if `signal` unwinds, and holds the raw VM-owned pointer so
         // borrowck doesn't see two live `&mut EventLoop` across re-entrant JS.
         let _guard = vm.enter_event_loop_scope();
@@ -394,7 +386,7 @@ impl Timeout {
     }
 
     // This may run inside the "signal" call.
-    // PORT NOTE: not `impl Drop` — Timeout is constructed/destroyed across FFI
+    // Deliberately not `impl Drop` — Timeout is constructed/destroyed across FFI
     // (see export fns below) and `deinit` needs a `vm` parameter.
     unsafe fn deinit(this: *mut Timeout, vm: *mut VirtualMachine) {
         // SAFETY: caller guarantees `this` came from `heap::alloc` in `init`.
@@ -442,5 +434,3 @@ pub(crate) unsafe extern "C" fn AbortSignal__Timeout__deinit(this: *mut Timeout)
     // VM singleton is process-lifetime.
     unsafe { Timeout::deinit(this, VirtualMachine::get_mut_ptr()) }
 }
-
-// ported from: src/jsc/AbortSignal.zig
diff --git a/src/jsc/AnyPromise.rs b/src/jsc/AnyPromise.rs
index ed601e64436..9a0a3d36c3d 100644
--- a/src/jsc/AnyPromise.rs
+++ b/src/jsc/AnyPromise.rs
@@ -4,9 +4,9 @@ use crate::host_fn::to_js_host_call;
 use crate::js_promise::{Status, UnwrapMode, Unwrapped};
 use crate::{JSGlobalObject, JSInternalPromise, JSPromise, JSValue, JsResult, JsTerminated, VM};
 
-/// `jsc.AnyPromise` — `JSPromise | JSInternalPromise` (AnyPromise.zig).
+/// `jsc.AnyPromise` — `JSPromise | JSInternalPromise`.
 ///
-/// Variants hold raw `*mut` (mirroring Zig's `*JSPromise`): the pointee is a
+/// Variants hold raw `*mut`: the pointee is a
 /// GC-managed JSC heap cell whose lifetime is governed by the VM, not by a
 /// Rust borrow. Callers must keep the cell reachable (e.g. via `Strong` or an
 /// on-stack `JSValue`) for as long as the `AnyPromise` is used.
@@ -70,8 +70,6 @@ impl AnyPromise {
 
     #[inline]
     pub fn reject(self, global_this: &JSGlobalObject, value: JSValue) -> Result<(), JsTerminated> {
-        // Zig: `promise.reject(globalThis, value)` — `JSValue` coerces to `JSError!JSValue`
-        // implicitly in Zig; map that with `Ok(value)` here.
         any_promise_dispatch!(self, |p| p.reject(global_this, Ok(value)))
     }
 
@@ -121,16 +119,11 @@ impl AnyPromise {
         }
     }
 
-    /// `AnyPromise.wrap` (AnyPromise.zig:76) — run `f` through the host-call
+    /// Run `f` through the host-call
     /// wrapper so a thrown exception (or returned `ErrorInstance`) is converted
     /// into a rejection of this existing promise; otherwise resolve with the
     /// result. The C++ side (`JSC__AnyPromise__wrap`, bindings.cpp) owns the
     /// resolve/reject decision.
-    ///
-    /// Zig used `std.meta.ArgsTuple(@TypeOf(Function))` to forward arbitrary
-    /// argument tuples through a `callconv(.c)` trampoline. Rust has no
-    /// compile-time fn-signature reflection, so this takes a closure that
-    /// captures those arguments instead.
     pub fn wrap<F>(self, global_object: &JSGlobalObject, f: F) -> Result<(), JsTerminated>
     where
         F: FnOnce(&JSGlobalObject) -> JsResult<JSValue>,
@@ -148,13 +141,11 @@ impl AnyPromise {
             // call (`&T` ≡ non-null `*const T` at the C ABI).
             let wrap_ = unsafe { bun_ptr::callback_ctx::<Wrapper<F>>(wrap_) };
             let f = wrap_.f.take().expect("AnyPromise::wrap called twice");
-            // Zig: `jsc.toJSHostCall(global, @src(), Fn, wrap_.args)` — installs the
-            // host-call exception/return-value validation around the invocation.
-            // `to_js_host_call` is `#[track_caller]`, so `@src()` is propagated.
+            // `to_js_host_call` installs the host-call exception/return-value
+            // validation around the invocation.
             to_js_host_call(global, move || f(global))
         }
 
-        // Zig: `var scope: jsc.TopExceptionScope = undefined; scope.init(global, @src()); defer scope.deinit();`
         crate::top_scope!(scope, global_object);
 
         let mut ctx = Wrapper { f: Some(f) };
@@ -187,5 +178,3 @@ unsafe extern "C" {
         f: extern "C" fn(*mut c_void, &JSGlobalObject) -> JSValue,
     );
 }
-
-// ported from: src/jsc/AnyPromise.zig
diff --git a/src/jsc/AsyncModule.rs b/src/jsc/AsyncModule.rs
index 3c1c472dc59..c2741524f6a 100644
--- a/src/jsc/AsyncModule.rs
+++ b/src/jsc/AsyncModule.rs
@@ -1,5 +1,3 @@
-//! Port of `src/jsc/AsyncModule.zig`.
-
 use core::ffi::c_void;
 use core::sync::atomic::AtomicU32;
 
@@ -43,15 +41,14 @@ pub struct AsyncModule {
     // This is all the state used by the printer to print the module
     pub parse_result: ParseResult<'static>,
     pub promise: StrongOptional, // Strong.Optional, default .empty
-    /// Packed `referrer ++ specifier ++ path.text`. Owns the bytes that the
-    /// Zig version aliased via `buf.allocatedSlice()`. Stored as offsets so
+    /// Packed `referrer ++ specifier ++ path.text`. Owns the bytes; stored as offsets so
     /// the struct stays movable (no self-referential borrows); reconstruct
     /// slices via `referrer()` / `specifier()` / `path_text()`.
     pub string_buf: Box<[u8]>,
     referrer_len: u32,
     specifier_len: u32,
     pub fd: Option<Fd>,
-    // PORT NOTE: `?*PackageJSON` / `*JSGlobalObject` — both are VM-lifetime
+    // `?*PackageJSON` / `*JSGlobalObject` — both are VM-lifetime
     // backrefs (BACKREF/JSC_BORROW class in LIFETIMES.tsv). `package_json` is
     // stored as a raw ptr so `AsyncModule` is `'static`-embeddable in
     // `Queue`/`VirtualMachine` without a phantom lifetime; `global_this` uses
@@ -117,7 +114,7 @@ impl Queue {
 
 // Taskable: `Queue` is enqueued via `ConcurrentTask::create_from(this)` in
 // `on_wake_handler` and dispatched in `bun_runtime::dispatch::run_task` →
-// `vm.modules.on_poll()` (Zig: `PollPendingModulesTask`). The pointer is a
+// `vm.modules.on_poll()`. The pointer is a
 // borrow into `VirtualMachine.modules`, never freed by the dispatcher.
 impl bun_event_loop::Taskable for Queue {
     const TAG: bun_event_loop::TaskTag = bun_event_loop::task_tag::PollPendingModulesTask;
@@ -141,7 +138,7 @@ impl AsyncModule {
         &self.string_buf[off..]
     }
 
-    /// Spec AsyncModule.zig:412-460. Dispatch the (possibly errored) transpile
+    /// Dispatch the (possibly errored) transpile
     /// result back into JSC via `Bun__onFulfillAsyncModule`. This is the entry
     /// point `RuntimeTranspilerStore::run_from_js_thread` calls when a
     /// concurrent transpile job finishes.
@@ -157,15 +154,14 @@ impl AsyncModule {
         jsc::mark_binding();
         let mut specifier = specifier_;
         let mut referrer = referrer_;
-        // PORT NOTE: Zig `defer { specifier.deref(); referrer.deref(); scope.deinit(); }` —
-        // BunString is `Copy` in the Rust port (no Drop), so deref the held
+        // BunString is `Copy` (no Drop), so deref the held
         // refcounts explicitly via scopeguard. The `TopExceptionScope` is
         // omitted: `from_js_host_call_generic` already checks the VM for a
         // pending exception after the FFI call (host_fn.rs).
         //
         // The guard captures raw pointers to the locals (not by-value copies)
-        // so the deref observes the *post-FFI* value of the variable, matching
-        // Zig `defer` semantics — `Bun__onFulfillAsyncModule` receives
+        // so the deref observes the *post-FFI* value of the variable —
+        // `Bun__onFulfillAsyncModule` receives
         // `&mut specifier`/`&mut referrer` and is free to overwrite them.
         // Safety: `specifier`/`referrer` are declared above this guard, so
         // they outlive it (locals drop in reverse order); the `&mut` reborrow
@@ -184,8 +180,7 @@ impl AsyncModule {
 
         let mut errorable: ErrorableResolvedSource;
         if let Some(e) = err {
-            // PORT NOTE: inner Zig `defer { if (needs_deref) { needs_deref = false;
-            // source_code.deref(); } }` — `OwnedString` derefs on Drop at the end
+            // `OwnedString` derefs on Drop at the end
             // of this `if` arm; `None` is the no-op path.
             let _source_code_guard = if resolved_source.source_code_needs_deref {
                 resolved_source.source_code_needs_deref = false;
@@ -200,13 +195,11 @@ impl AsyncModule {
                     global_this.take_error(JsError::Thrown),
                 );
             } else {
-                // Spec AsyncModule.zig:440-447 —
-                // `VirtualMachine.processFetchLog(globalThis, specifier,
-                // referrer, log, &errorable, e)` synthesizes a JS
+                // `process_fetch_log` synthesizes a JS
                 // Error/AggregateError from the parser log and writes it into
                 // `errorable.result.err.value`. Without this the import promise
                 // would reject with `undefined` (ModuleLoader.cpp:473).
-                // PORT NOTE: call the `virtual_machine` impl directly (takes
+                // call the `virtual_machine` impl directly (takes
                 // `&JSGlobalObject`) instead of the `module_loader` shim that
                 // takes `*mut` — avoids a `&T as *const T as *mut T` cast,
                 // which is UB-adjacent under Stacked Borrows even when the
@@ -224,10 +217,6 @@ impl AsyncModule {
         } else {
             errorable = ErrorableResolvedSource::ok(*resolved_source);
         }
-        // TODO(port): Zig calls log.deinit() here explicitly (early), then uses
-        // specifier after. In Rust, caller owns `log`; we leave it to caller's
-        // Drop. Verify no behavioral diff.
-
         bun_core::scoped_log!(AsyncModule, "fulfill: {}", specifier);
 
         jsc::from_js_host_call_generic(global_this, || {
@@ -242,14 +231,12 @@ impl AsyncModule {
     }
 }
 
-// PORT NOTE: pub fn deinit → impl Drop. Body only freed owned fields (promise,
+// pub fn deinit → impl Drop. Body only freed owned fields (promise,
 // parse_result, arena, string_buf), all of which now have Drop impls on their
 // Rust types. No explicit Drop needed; relying on field Drop order.
 // bun.default_allocator.free(this.stmt_blocks);
 // bun.default_allocator.free(this.expr_blocks);
 
-// TODO(port): move to <area>_sys
-//
 // safe: `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle (`&` is
 // ABI-identical to non-null `*const`); `ErrorableResolvedSource`/`BunString`
 // are `#[repr(C)]` payloads whose `&mut` is exclusive for the call. C++ reads
@@ -273,9 +260,7 @@ use bun_install::{self as install, LogLevel, PackageID};
 
 use crate::event_loop::{AnyTask, ConcurrentTaskItem, Task};
 
-/// `RunTasksCallbacks` impl for the auto-install module queue. Mirrors the Zig
-/// anonymous `comptime callbacks: anytype` struct passed at
-/// AsyncModule.zig:108-133 — `onExtract = void`, `onResolve` /
+/// `RunTasksCallbacks` impl for the auto-install module queue. `onResolve` /
 /// `onPackageManifestError` / `onPackageDownloadError` forward to the `Queue`
 /// methods, `progress_bar` selected via const generic to match the
 /// `enable_ansi_colors_stderr` branch.
@@ -317,9 +302,8 @@ impl Queue {
             bun_io::AllocatorType::Js,
         ));
 
-        // PORT NOTE: allocator arg dropped (Vec uses global mimalloc).
+        // allocator arg dropped (Vec uses global mimalloc).
         self.map.push(module);
-        // PERF(port): was assume_capacity-free append
         self.vm().package_manager().drain_dependency_list();
     }
 
@@ -340,12 +324,8 @@ impl Queue {
             bstr::BStr::new(this.vm().package_manager().lockfile.str(&dependency.name))
         );
 
-        // PORT NOTE: reshaped for borrowck — Zig iterated copies and
-        // compacted in place; Rust uses retain_mut and lets Drop free
-        // removed modules.
+        // retain_mut lets Drop free removed modules.
         this.map.retain_mut(|module| {
-            // PORT NOTE: Zig `MultiArrayList.items(.root_dependency_id)` →
-            // `Vec<PendingResolution>` field walk.
             for pending in module.parse_result.pending_imports.iter() {
                 if pending.root_dependency_id != root_dependency_id {
                     continue;
@@ -355,7 +335,7 @@ impl Queue {
                 // `container_of`-derived `*mut`; provenance is the original
                 // allocation, disjoint from the `&mut module` borrow above.
                 let vm = VirtualMachine::get().as_mut();
-                // PORT NOTE: reshaped for borrowck — `lockfile.str()` ties the
+                // reshaped for borrowck — `lockfile.str()` ties the
                 // returned slice to `&vm`, which conflicts with passing
                 // `&mut vm` to `resolve_error`. The lockfile string buffer is
                 // stable across `resolve_error` (no realloc on the error
@@ -403,9 +383,7 @@ impl Queue {
     }
 
     pub fn run_tasks(&mut self) {
-        // PORT NOTE: reshaped for borrowck — Zig held `pm` across the call
-        // while passing `this` (which can recover `pm` via
-        // `@fieldParentPtr`). The Rust `run_tasks` free fn takes both
+        // The `run_tasks` free fn takes both
         // `&mut PackageManager` and `&mut Queue`; the package manager is a
         // separate heap allocation (`NonNull<dyn AutoInstaller>` on the
         // resolver), so the two borrows are disjoint.
@@ -435,10 +413,8 @@ impl Queue {
             bstr::BStr::new(name)
         );
 
-        // PORT NOTE: reshaped for borrowck — compaction loop → retain_mut.
+        // reshaped for borrowck — compaction loop → retain_mut.
         self.map.retain_mut(|module| {
-            // PORT NOTE: Zig `MultiArrayList.items(.tag)` etc. →
-            // `Vec<PendingResolution>` field walk.
             for pending in module.parse_result.pending_imports.iter() {
                 if pending.tag == bun_resolver::PendingResolutionTag::Resolve {
                     if pending.esm.name.slice(&pending.string_buf) != name {
@@ -498,11 +474,8 @@ impl Queue {
                 .as_slice(),
         );
 
-        // PORT NOTE: reshaped for borrowck — compaction loop → retain_mut.
+        // reshaped for borrowck — compaction loop → retain_mut.
         self.map.retain_mut(|module| {
-            // PORT NOTE: Zig `MultiArrayList.items(.import_record_id)` /
-            // `.items(.root_dependency_id)` → `Vec<PendingResolution>` field
-            // walk.
             for pending in module.parse_result.pending_imports.iter() {
                 if resolution_ids.slice()[pending.root_dependency_id as usize] != package_id {
                     continue;
@@ -537,18 +510,13 @@ impl Queue {
             return;
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig compacted by index then
-        // truncated `items.len` without running deinit on finished slots. Rust
-        // walks by index and `remove(i)` finished modules by value into
+        // Walk by index and `remove(i)` finished modules by value into
         // `done(self)`, so each module's owned fields are dropped exactly once
         // (in `on_done`).
         let mut i = 0;
         while i < self.map.len() {
             let (done_count, tags_len) = {
                 let module = &mut self.map[i];
-                // PORT NOTE: Zig `MultiArrayList.items(.tag)` /
-                // `.items(.root_dependency_id)` → `Vec<PendingResolution>`
-                // field walk via `iter_mut()`.
                 let pending_imports = &mut module.parse_result.pending_imports;
                 // var esms = module.parse_result.pending_imports.items(.esm);
                 // var versions = module.parse_result.pending_imports.items(.dependency);
@@ -592,8 +560,7 @@ impl Queue {
 
                     let mut name_and_version_hash: Option<u64> = None;
                     let mut patchfile_hash: Option<u64> = None;
-                    // PORT NOTE: Zig passed `pm.lockfile` as a separate arg;
-                    // the Rust port collapsed it onto `&mut self.lockfile`
+                    // The lockfile is reached through `&mut self.lockfile`
                     // (PackageManagerLifecycle.rs) to avoid the
                     // `&mut self`/`&self.lockfile` aliasing borrowck rejects.
                     match pm.determine_preinstall_state(
@@ -647,7 +614,7 @@ impl AsyncModule {
     ) -> Result<AsyncModule, bun_alloc::AllocError> {
         // var stmt_blocks = js_ast.Stmt.Data.toOwnedSlice();
         // var expr_blocks = js_ast.Expr.Data.toOwnedSlice();
-        // PORT NOTE: `JSInternalPromise` aliases `JSPromise` upstream
+        // `JSInternalPromise` aliases `JSPromise` upstream
         // (JSInternalPromise.rs), so `JSPromise::create` is the
         // `createInternalPromise` equivalent.
         let this_promise = crate::JSPromise::create(global_object).to_js();
@@ -663,9 +630,7 @@ impl AsyncModule {
         unsafe {
             *opts.promise_ptr.unwrap() = this_promise.as_promise().unwrap();
         }
-        // PORT NOTE: Zig kept three aliasing slices into `buf` plus
-        // `buf.allocatedSlice()` as the owning storage. Rust can't store
-        // self-referential borrows, so capture lengths and pack
+        // Self-referential borrows can't be stored, so capture lengths and pack
         // `referrer ++ specifier ++ path.text` into `string_buf`, then expose
         // them via `referrer()`/`specifier()`/`path_text()`. `move_to_slice()`
         // transfers ownership (resets `buf` so its Drop is a no-op) — exactly
@@ -698,11 +663,9 @@ impl AsyncModule {
     }
 
     pub fn done(self, jsc_vm: &mut VirtualMachine) {
-        // PORT NOTE: Zig `allocator.create` + bitwise copy then truncated the
-        // queue without running deinit on the discarded slot — single
-        // ownership transfers to the heap clone. In Rust the caller
+        // The caller
         // (`Queue::poll_modules`) removes the element by value and passes it
-        // here, so `Box::new(self)` is the same single transfer with no
+        // here, so `Box::new(self)` is a single ownership transfer with no
         // `ptr::read` and no double-Drop.
         let clone = bun_core::heap::into_raw(Box::new(self));
         jsc_vm.modules.scheduled += 1;
@@ -710,9 +673,7 @@ impl AsyncModule {
         // task queue until on_done reclaims it via heap::take; we hold
         // the only reference here.
         unsafe {
-            // PORT NOTE: Zig `AnyTask.New(AsyncModule, onDone).init(clone)` —
-            // Rust cannot take a fn as const generic, so hand-write the shim
-            // (option (b) in event_loop/AnyTask.rs).
+            // Hand-written task shim (option (b) in event_loop/AnyTask.rs).
             (*clone).any_task = AnyTask::AnyTask {
                 ctx: Some(core::ptr::NonNull::new_unchecked(clone).cast()),
                 callback: |p| {
@@ -740,7 +701,7 @@ impl AsyncModule {
         let global_ref = this.global_this;
         let global_this: &JSGlobalObject = &global_ref;
         // SAFETY: `VirtualMachine::get()` is the live per-thread VM (one VM per
-        // thread); the Zig `globalThis.bunVM()` returns the same pointer.
+        // thread).
         let jsc_vm = VirtualMachine::get().as_mut();
         jsc_vm.modules.scheduled -= 1;
         if jsc_vm.modules.scheduled == 0 {
@@ -757,8 +718,7 @@ impl AsyncModule {
                 global_this.take_error(JsError::Thrown),
             ),
             Err(err) => {
-                // PORT NOTE: Zig declared `errorable = undefined` and relied on
-                // `processFetchLog` writing the out-param. Rust pre-seeds the
+                // Pre-seed the
                 // err so the `&mut` borrow is definitely-initialized;
                 // `process_fetch_log` overwrites `result.err.value`.
                 let mut errorable = ErrorableResolvedSource::err(err, JSValue::UNDEFINED);
@@ -791,9 +751,9 @@ impl AsyncModule {
         drop(unsafe { bun_core::heap::take(this) });
     }
 
-    // TODO(port): narrow error set to bun_alloc::AllocError — Zig body only
-    // `try`s std.fmt.allocPrint (OOM-only). write! into Vec<u8> is
-    // infallible here; `.ok()` collapses the `fmt::Result`.
+    // write! into Vec<u8>
+    // is infallible here; `.ok()` collapses the `fmt::Result`, so this never
+    // actually returns Err — the wide Result is kept for call-site uniformity.
     fn resolve_error(
         &mut self,
         vm: &mut VirtualMachine,
@@ -865,9 +825,6 @@ impl AsyncModule {
             .ok();
         } else if e == bun_core::err!("DistTagNotFound") || e == bun_core::err!("NoMatchingVersion")
         {
-            // PORT NOTE: Zig peeks at the tagged-union via
-            // `result.version.tag == .npm and
-            // result.version.value.npm.version.isExact()`. The Rust
             // `Version::try_npm()` performs the tag guard and yields the
             // `NpmInfo` (whose `.version` is the semver query group).
             let npm = result.version.try_npm();
@@ -997,9 +954,8 @@ impl AsyncModule {
         self.poll_ref.unref(bun_io::posix_event_loop::get_vm_ctx(
             bun_io::AllocatorType::Js,
         ));
-        // PORT NOTE: Zig called `this.deinit()` here; in Rust the caller
-        // (Queue::retain_mut) returns `false` and Vec drops the element,
-        // running Drop.
+        // The caller (Queue::retain_mut) returns `false` and Vec drops the
+        // element, running Drop.
         // `JSInternalPromise` is an `opaque_ffi!` ZST handle; `opaque_mut` is
         // the centralised non-null deref proof.
         let _ =
@@ -1218,8 +1174,7 @@ impl AsyncModule {
         self.poll_ref.unref(bun_io::posix_event_loop::get_vm_ctx(
             bun_io::AllocatorType::Js,
         ));
-        // PORT NOTE: Zig called `this.deinit()` here; caller drops via
-        // retain_mut → false.
+        // Caller drops via retain_mut → false.
         // `JSInternalPromise` is an `opaque_ffi!` ZST handle; `opaque_mut` is
         // the centralised non-null deref proof.
         let _ =
@@ -1236,8 +1191,7 @@ impl AsyncModule {
             "resumeLoadingModule: {}",
             bstr::BStr::new(self.specifier())
         );
-        // PORT NOTE: Zig copied `parse_result` by value, mutated, wrote
-        // back. Rust takes-by-value via `mem::take` then restores below to
+        // Take `parse_result` by value via `mem::take`, then restore below, to
         // satisfy borrowck around `linker.link(&mut parse_result)` while
         // `self` is also borrowed.
         let arena = *self.parse_result.ast.parts.allocator();
@@ -1254,8 +1208,7 @@ impl AsyncModule {
         let path_text: &[u8] = unsafe { bun_ptr::detach_lifetime(self.path_text()) };
         let path = Fs::Path::init(path_text);
         let jsc_vm = VirtualMachine::get_mut_ptr();
-        // SAFETY: `jsc_vm` is the live per-thread VM (one VM per thread);
-        // raw-ptr aliasing matches the Zig `*VirtualMachine` field accesses
+        // SAFETY: `jsc_vm` is the live per-thread VM (one VM per thread)
         // (`transpiler.log`/`resolver.log`/`linker.log` are themselves raw
         // `*mut Log` aliased deliberately — see `Transpiler::set_log`).
         // `vm.log` is set unconditionally in `init` and never cleared, so the
@@ -1296,7 +1249,7 @@ impl AsyncModule {
             )?;
         }
         self.parse_result = parse_result;
-        // PORT NOTE: `print_with_source_map` consumes `ParseResult` by
+        // `print_with_source_map` consumes `ParseResult` by
         // value (it moves `ast` into `print_ast`). Hoist the post-print
         // reads (`is_commonjs_module` / `input_fd`) above the move so we
         // can `mem::take` instead of cloning.
@@ -1306,11 +1259,9 @@ impl AsyncModule {
         let arena = *self.parse_result.ast.parts.allocator();
         let parse_result = core::mem::replace(&mut self.parse_result, ParseResult::empty(arena));
 
-        // PORT NOTE: `VirtualMachine.source_code_printer` is a thread-local
-        // `?*BufferPrinter` (see `SOURCE_CODE_PRINTER`); Zig dereferenced to
-        // copy by value (`var printer = source_code_printer.?.*`), reset, and
-        // wrote back in a `defer`. `BufferPrinter` is `!Clone` in Rust, so
-        // swap the buffer out instead and write it back via the `_writeback`
+        // `VirtualMachine.source_code_printer` is a thread-local
+        // `?*BufferPrinter` (see `SOURCE_CODE_PRINTER`). `BufferPrinter` is `!Clone`, so
+        // swap the buffer out and write it back via the `_writeback`
         // guard — same observable effect (the thread-local's buffer is
         // reused). Matches RuntimeTranspilerStore.rs.
         let mut printer_ptr = crate::virtual_machine::SOURCE_CODE_PRINTER
@@ -1322,7 +1273,7 @@ impl AsyncModule {
             bun_js_printer::BufferPrinter::init(bun_js_printer::BufferWriter::init()),
         );
         printer.ctx.reset();
-        // Zig: `defer source_code_printer.?.* = printer;` — fires at fn exit,
+        // The writeback must fire at fn exit,
         // *after* the `printer.ctx.get_written()` reads below. Declare the
         // guard immediately after `printer` so it drops last (locals drop in
         // reverse declaration order) and the buffer is still populated when
@@ -1363,14 +1314,17 @@ impl AsyncModule {
             }?;
         }
 
-        #[cfg(feature = "dump_source")]
-        crate::runtime_transpiler_store::dump_source_string(
-            // SAFETY: `jsc_vm` is the live per-thread `VirtualMachine` (BACKREF, non-null).
-            unsafe { core::ptr::NonNull::new_unchecked(jsc_vm) },
-            specifier,
-            printer.ctx.get_written(),
-        );
-        // TODO(port): Environment.dump_source mapped to cfg feature; confirm flag name.
+        // `bun_core::env::DUMP_SOURCE` is debug, non-test builds only. The previous
+        // `cfg(feature = "dump_source")` gate referenced a feature that doesn't
+        // exist, which silently compiled this call out everywhere.
+        if bun_core::env::DUMP_SOURCE {
+            crate::runtime_transpiler_store::dump_source_string(
+                // SAFETY: `jsc_vm` is the live per-thread `VirtualMachine` (BACKREF, non-null).
+                unsafe { core::ptr::NonNull::new_unchecked(jsc_vm) },
+                specifier,
+                printer.ctx.get_written(),
+            );
+        }
 
         // SAFETY: per-thread VM.
         if unsafe { (*jsc_vm).is_watcher_enabled() } {
@@ -1396,7 +1350,7 @@ impl AsyncModule {
                             .bun_watcher
                             .cast::<crate::hot_reloader::ImportWatcher>()
                     };
-                    // PORT NOTE: `bun_watcher::PackageJSON` is an opaque
+                    // `bun_watcher::PackageJSON` is an opaque
                     // forward-decl of `bun_resolver::PackageJSON`;
                     // the watcher only stores the pointer, so cast through.
                     // SAFETY: `package_json` (when set) is a VM-lifetime
@@ -1429,5 +1383,3 @@ impl AsyncModule {
         })
     }
 }
-
-// ported from: src/jsc/AsyncModule.zig
diff --git a/src/jsc/BuildMessage.rs b/src/jsc/BuildMessage.rs
index 7ad2813c37f..b2dc838f315 100644
--- a/src/jsc/BuildMessage.rs
+++ b/src/jsc/BuildMessage.rs
@@ -13,7 +13,6 @@ use crate::{
 pub struct BuildMessage {
     pub msg: bun_ast::Msg,
     // resolve_result: Resolver.Result,
-    // PORT NOTE: `std.mem.Allocator param` field dropped — global mimalloc.
     pub logged: Cell<bool>,
 }
 
@@ -47,8 +46,7 @@ impl BuildMessage {
     }
 
     pub fn to_string_fn(&self, global: &JSGlobalObject) -> JSValue {
-        // std.fmt.allocPrint → write! into Vec<u8>; Rust aborts on OOM so the
-        // `catch { throwOutOfMemoryValue }` branch is unreachable here.
+        // write! into a Vec<u8>; Rust aborts on OOM so no OOM-throw path is needed.
         let mut text: Vec<u8> = Vec::new();
         write!(
             &mut text,
@@ -77,7 +75,7 @@ impl BuildMessage {
         str.to_external_value(global)
     }
 
-    /// Spec `BuildMessage.create` (BuildMessage.zig:46) — clone `msg` into a
+    /// Clone `msg` into a
     /// fresh heap-allocated `BuildMessage` and wrap it in its JSC cell. The
     /// `JsClass::to_js` impl boxes `self` and calls the C++-side
     /// `BuildMessage__create(global, ptr)` (generated by `.classes.ts`); the
@@ -201,5 +199,3 @@ impl BuildMessage {
         Ok(ZigString::init(self.msg.kind.string()).to_js(global))
     }
 }
-
-// ported from: src/jsc/BuildMessage.zig
diff --git a/src/jsc/BunCPUProfiler.rs b/src/jsc/BunCPUProfiler.rs
index a9cebbc9d55..903bcc766db 100644
--- a/src/jsc/BunCPUProfiler.rs
+++ b/src/jsc/BunCPUProfiler.rs
@@ -18,8 +18,8 @@ pub(crate) enum ProfilerError {
 bun_core::named_error_set!(ProfilerError);
 
 pub struct CPUProfilerConfig {
-    // TODO(port): lifetime — these are borrowed slices in Zig (never freed here);
-    // using &'static per PORTING.md (no struct lifetime params).
+    // CLI-arg-backed and
+    // process-lifetime, so `&'static` is sound (no struct lifetime params).
     pub name: &'static [u8],
     pub dir: &'static [u8],
     pub md_format: bool,
@@ -40,7 +40,6 @@ impl Default for CPUProfilerConfig {
 }
 
 // C++ function declarations
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     /// `VM` is an opaque `UnsafeCell`-backed ZST handle; `&mut VM` is
     /// ABI-identical to a non-null `VM*`.
@@ -69,7 +68,6 @@ pub(crate) fn stop_and_write_profile(
     vm: &mut VM,
     config: &CPUProfilerConfig,
 ) -> Result<(), ProfilerError> {
-    // TODO(port): narrow error set
     let mut json_string = BunString::empty();
     let mut text_string = BunString::empty();
 
@@ -80,8 +78,7 @@ pub(crate) fn stop_and_write_profile(
         config.md_format.then_some(&mut text_string),
     );
     // C++ handed back +1 refs into json_string/text_string. `bun_core::String`
-    // is `Copy` (no Drop), so wrap in `OwnedString` for scope-exit `deref()` —
-    // the Rust spelling of Zig's `defer json_string.deref(); defer text_string.deref();`.
+    // is `Copy` (no Drop), so wrap in `OwnedString` for scope-exit `deref()`.
     let json_string = OwnedString::new(json_string);
     let text_string = OwnedString::new(text_string);
 
@@ -183,8 +180,8 @@ fn build_output_path(
 
     // Append directory if specified
     if !config.dir.is_empty() {
-        // PORT NOTE: AutoAbsPath uses CheckLength::ASSUME — Err arm is unreachable
-        // (Zig call is infallible). See paths/Path.rs `options::Result` note.
+        // AutoAbsPath uses CheckLength::ASSUME — Err arm is unreachable.
+        // See paths/Path.rs `options::Result` note.
         path.join(&[config.dir]).expect("unreachable");
     }
 
diff --git a/src/jsc/BunHeapProfiler.rs b/src/jsc/BunHeapProfiler.rs
index 8579f4ab7ee..d9ea12c24de 100644
--- a/src/jsc/BunHeapProfiler.rs
+++ b/src/jsc/BunHeapProfiler.rs
@@ -6,9 +6,8 @@ use bun_sys::{self as sys, E, Fd, FdDirExt};
 use crate::VM;
 
 pub struct HeapProfilerConfig {
-    // PORT NOTE: Zig held borrowed `[]const u8` for the process lifetime; the
-    // config originates from CLI args and lives until exit, so `&'static [u8]`
-    // matches the ownership exactly.
+    // The config originates from CLI args and lives until process exit, so
+    // `&'static [u8]` matches the ownership exactly.
     pub name: &'static [u8],
     pub dir: &'static [u8],
     pub text_format: bool,
@@ -36,8 +35,8 @@ pub fn generate_and_write_profile(vm: &mut VM, config: &HeapProfilerConfig) -> R
         return Ok(());
     }
 
+    // Freed by Drop on ZigStringSlice.
     let profile_slice = profile_string.to_utf8();
-    // `defer profile_slice.deinit()` — handled by Drop on ZigStringSlice.
 
     // Determine the output path using AutoAbsPath
     let mut path_buf = AutoAbsPath::init_top_level_dir();
@@ -55,8 +54,8 @@ pub fn generate_and_write_profile(vm: &mut VM, config: &HeapProfilerConfig) -> R
     );
 
     // Write the profile to disk using bun.sys.File.writeFile
-    // PORT NOTE: reshaped for borrowck — `slice_z()` borrows `path_buf` mutably,
-    // so we re-derive it at each call site instead of holding a single binding.
+    // `slice_z()` borrows `path_buf` mutably, so we re-derive it at each call
+    // site instead of holding a single binding.
     #[cfg(windows)]
     let result = sys::File::write_file_os_path(Fd::cwd(), output_path_os, profile_slice.slice());
     #[cfg(not(windows))]
@@ -136,7 +135,7 @@ fn generate_default_filename(buf: &mut PathBuffer, text_format: bool) -> Result<
 
     let extension: &str = if text_format { "md" } else { "heapsnapshot" };
 
-    // std.fmt.bufPrint → write into the fixed buffer, return the written slice
+    // Write into the fixed buffer, then return the written slice
     use std::io::Write;
     let buf_slice = buf.as_mut_slice();
     let total = buf_slice.len();
@@ -149,8 +148,5 @@ fn generate_default_filename(buf: &mut PathBuffer, text_format: bool) -> Result<
     .map_err(|_| err!(NoSpaceLeft))?;
     let remaining = cursor.len();
     let written = total - remaining;
-    // PORT NOTE: reshaped for borrowck — recompute slice from buf after dropping cursor borrow.
     Ok(&buf.as_slice()[..written])
 }
-
-// ported from: src/jsc/BunHeapProfiler.zig
diff --git a/src/jsc/CachedBytecode.rs b/src/jsc/CachedBytecode.rs
index 4fef3e002ba..7daeb0ae614 100644
--- a/src/jsc/CachedBytecode.rs
+++ b/src/jsc/CachedBytecode.rs
@@ -34,9 +34,8 @@ unsafe extern "C" {
 }
 
 impl CachedBytecode {
-    // PORT NOTE: the returned `&'static [u8]` actually borrows from the
-    // `CachedBytecode` handle and is invalidated when `deref()` is called —
-    // identical to the Zig `[]const u8` + `*CachedBytecode` pair. Callers own
+    // SAFETY CONTRACT: the returned `&'static [u8]` actually borrows from the
+    // `CachedBytecode` handle and is invalidated when `deref()` is called. Callers own
     // the handle and must call `deref()` (or drop via `allocator()`) to free.
     pub fn generate_for_esm(
         source_provider_url: &mut BunString,
@@ -115,13 +114,8 @@ impl CachedBytecode {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Zig exposed a `std.mem.Allocator` VTable here so callers could store the
-// bytecode slice alongside an "allocator" whose `.free()` decrements the
-// CachedBytecode refcount. This is a Zig-specific ownership-tracking idiom.
-//
-// PORT NOTE: the Zig `VTable.free` slot called `CachedBytecode__deref(ctx)` and
-// `VTable.alloc` panicked. The Rust `bun_alloc::Allocator` marker trait has no
-// `alloc`/`free` methods to dispatch through — so the "free → deref" semantics
+// The `bun_alloc::Allocator` marker trait has no
+// `alloc`/`free` methods to dispatch through — so "free → deref" semantics
 // cannot ride the trait object. Call sites that would have freed through this
 // allocator must instead call `deref()` on the `NonNull<CachedBytecode>` handle
 // directly. `is_instance` is preserved for the vtable-identity check in
@@ -131,9 +125,7 @@ impl CachedBytecode {
 impl bun_alloc::Allocator for CachedBytecode {}
 
 impl CachedBytecode {
-    /// Zig: `allocator_.vtable == VTable`. Expressed as concrete-type identity
-    /// via the `Allocator::type_id()` hook (the documented Rust mapping for
-    /// Zig vtable-pointer equality checks).
+    /// Concrete-type identity check via the `Allocator::type_id()` hook.
     pub fn is_instance(alloc: &dyn bun_alloc::Allocator) -> bool {
         alloc.is::<Self>()
     }
@@ -164,5 +156,3 @@ pub(crate) fn __bun_jsc_generate_cached_bytecode(
     CachedBytecode__deref(CachedBytecode::opaque_mut(handle.as_ptr()));
     Some(owned)
 }
-
-// ported from: src/jsc/CachedBytecode.zig
diff --git a/src/jsc/CallFrame.rs b/src/jsc/CallFrame.rs
index 3740f3775cb..faf1707c51b 100644
--- a/src/jsc/CallFrame.rs
+++ b/src/jsc/CallFrame.rs
@@ -110,8 +110,7 @@ impl CallFrame {
     #[inline]
     fn as_unsafe_js_value_array(&self) -> *const JSValue {
         // SAFETY: CallFrame is an opaque handle whose address IS the base of the
-        // JSC register array; reinterpreting &self as *const JSValue mirrors the
-        // Zig @ptrCast(@alignCast(self)).
+        // JSC register array, so reinterpreting &self as *const JSValue is valid.
         std::ptr::from_ref::<CallFrame>(self).cast::<JSValue>()
     }
 
@@ -146,7 +145,6 @@ impl CallFrame {
     pub fn arguments_old<const MAX: usize>(&self) -> Arguments<MAX> {
         let slice = self.arguments();
         debug_assert!(MAX <= 15);
-        // PERF(port): was `switch { inline 1...15 => |count| ... }` comptime monomorphization — profile if it shows up on a hot path.
         let count = slice.len().min(MAX);
         if count == 0 {
             Arguments {
@@ -163,7 +161,6 @@ impl CallFrame {
     pub fn arguments_undef<const MAX: usize>(&self) -> Arguments<MAX> {
         let slice = self.arguments();
         debug_assert!(MAX <= 9);
-        // PERF(port): was `switch { inline 1...9 => |count| ... }` comptime monomorphization — profile if it shows up on a hot path.
         let count = slice.len().min(MAX);
         if count == 0 {
             Arguments {
@@ -291,19 +288,17 @@ impl<'a> Iterator<'a> {
 pub struct ArgumentsSlice<'a> {
     /// Backing storage for the remaining-args view. Both [`Self::init`] and
     /// [`Self::init_async`] borrow — `all: &'a [JSValue]` already ties this
-    /// struct's lifetime to the source slice, so the heap-owned dupe Zig's
-    /// `initAsync` does buys nothing here (it could not outlive `'a`). Kept as
+    /// struct's lifetime to the source slice, so a heap-owned dupe
+    /// buys nothing here (it could not outlive `'a`). Kept as
     /// `Cow` so a future caller that does own its args can pass `Owned`
     /// without changing the type.
     remaining_buf: Cow<'a, [JSValue]>,
-    /// Cursor into `remaining_buf`; advances on `eat()`. Replaces Zig's
-    /// `remaining.ptr += 1` reslice (which a `Cow` can't express in-place).
+    /// Cursor into `remaining_buf`; advances on `eat()`.
     remaining_start: usize,
     pub vm: &'a VirtualMachine,
-    /// Zig: `bun.ArenaAllocator` (= `std.heap.ArenaAllocator`), which is **lazy** —
-    /// `init()` allocates nothing. The Rust `bun_alloc::Arena` is a `MimallocArena`
+    /// `bun_alloc::Arena` is a `MimallocArena`
     /// whose `new()` calls `mi_heap_new()` eagerly, so we keep it `None` until a
-    /// caller actually needs scratch storage (currently none do in the Rust port).
+    /// caller actually needs scratch storage (currently none do).
     pub arena: Option<bun_alloc::Arena>,
     pub all: &'a [JSValue],
     pub threw: bool,
@@ -318,7 +313,7 @@ impl<'a> ArgumentsSlice<'a> {
         &self.remaining_buf[self.remaining_start..]
     }
 
-    /// Lazily create the scratch arena (Zig: `slice.arena.allocator()`).
+    /// Lazily create the scratch arena.
     #[inline]
     pub fn arena(&mut self) -> &bun_alloc::Arena {
         self.arena.get_or_insert_with(bun_alloc::Arena::new)
@@ -337,8 +332,7 @@ impl<'a> ArgumentsSlice<'a> {
             return;
         }
         // `remaining_buf.len() == all.len()` for both init variants, so
-        // `all.len() - remaining().len()` reduces to `remaining_start` —
-        // matching Zig's `self.all.len - self.remaining.len`.
+        // `all.len() - remaining().len()` reduces to `remaining_start`.
         let index = self.all.len() - self.remaining().len();
         self.protected.set(index);
         self.all[index].protect();
@@ -353,8 +347,7 @@ impl<'a> ArgumentsSlice<'a> {
     }
 
     pub fn from(vm: &'a VirtualMachine, slice: &'a [JSValueRef]) -> ArgumentsSlice<'a> {
-        // SAFETY: JSValueRef and JSValue have identical layout (both are encoded i64);
-        // mirrors Zig @ptrCast(slice.ptr).
+        // SAFETY: JSValueRef and JSValue have identical layout (both are encoded i64).
         let as_values =
             unsafe { bun_core::ffi::slice(slice.as_ptr().cast::<JSValue>(), slice.len()) };
         Self::init(vm, as_values)
@@ -374,10 +367,9 @@ impl<'a> ArgumentsSlice<'a> {
     }
 
     pub fn init_async(vm: &'a VirtualMachine, slice: &'a [JSValue]) -> ArgumentsSlice<'a> {
-        // Spec (CallFrame.zig:258-265): `.remaining = bun.default_allocator.dupe(jsc.JSValue, slice)`.
-        // In the Rust port `all: &'a [JSValue]` already pins the struct lifetime to `slice`, so a
+        // `all: &'a [JSValue]` already pins the struct lifetime to `slice`, so a
         // heap-owned dupe of `remaining` cannot outlive `slice` anyway — borrow instead of copying.
-        // `all` stays borrowed (matches Zig) so `protect_eat` index math holds.
+        // `all` stays borrowed so `protect_eat` index math holds.
         ArgumentsSlice {
             remaining_buf: Cow::Borrowed(slice),
             remaining_start: 0,
@@ -421,8 +413,6 @@ impl<'a> Drop for ArgumentsSlice<'a> {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `CallFrame`/`VM`/`JSGlobalObject` are opaque `UnsafeCell`-backed ZST handles;
 // `&T` is ABI-identical to non-null `*const T`. Out-params are exclusive `&mut`
 // to plain `#[repr(C)]` PODs. `describeFrame` returns a raw C string that the
@@ -439,5 +429,3 @@ unsafe extern "C" {
     #[cfg(debug_assertions)]
     fn Bun__CallFrame__describeFrame(cf: *const CallFrame) -> *const core::ffi::c_char;
 }
-
-// ported from: src/jsc/CallFrame.zig
diff --git a/src/jsc/CommonAbortReason.rs b/src/jsc/CommonAbortReason.rs
index 60813086cf1..2e622056fcc 100644
--- a/src/jsc/CommonAbortReason.rs
+++ b/src/jsc/CommonAbortReason.rs
@@ -16,8 +16,6 @@ impl CommonAbortReasonExt for CommonAbortReason {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle; C++ allocating
 // the JS error value through it is interior mutation invisible to Rust.
 unsafe extern "C" {
@@ -26,5 +24,3 @@ unsafe extern "C" {
         reason: CommonAbortReason,
     ) -> JSValue;
 }
-
-// ported from: src/jsc/CommonAbortReason.zig
diff --git a/src/jsc/CommonStrings.rs b/src/jsc/CommonStrings.rs
index b9e6f5cee88..41254ee4b38 100644
--- a/src/jsc/CommonStrings.rs
+++ b/src/jsc/CommonStrings.rs
@@ -26,7 +26,6 @@ enum CommonStringsForZig {
     BinaryTypeUint8Array = 12,
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     // `JSGlobalObject` is an opaque `UnsafeCell`-backed FFI handle; `&T` is
     // ABI-identical to non-null `*const T` and the C++ side's lazy init of its
@@ -45,9 +44,6 @@ impl CommonStringsForZig {
 }
 
 impl<'a> CommonStrings<'a> {
-    // PORT NOTE: Zig had both `IPv4`/`IPv6` and `ipv4`/`ipv6` methods, which
-    // collide under snake_case. The lowercase Zig methods are renamed to
-    // `ipv4_lower`/`ipv6_lower` here (matching their enum variants).
     #[inline]
     pub fn ipv4(self) -> JSValue {
         CommonStringsForZig::IPv4.to_js(self.global_object)
@@ -56,14 +52,10 @@ impl<'a> CommonStrings<'a> {
     pub fn ipv6(self) -> JSValue {
         CommonStringsForZig::IPv6.to_js(self.global_object)
     }
-    // PORT NOTE: Zig `@"127.0.0.1"` — not a valid Rust identifier; renamed to
-    // match the enum variant.
     #[inline]
     pub fn in4_loopback(self) -> JSValue {
         CommonStringsForZig::IN4Loopback.to_js(self.global_object)
     }
-    // PORT NOTE: Zig `@"::"` — not a valid Rust identifier; renamed to match
-    // the enum variant.
     #[inline]
     pub fn in6_any(self) -> JSValue {
         CommonStringsForZig::IN6Any.to_js(self.global_object)
@@ -105,5 +97,3 @@ impl<'a> CommonStrings<'a> {
         CommonStringsForZig::BinaryTypeUint8Array.to_js(self.global_object)
     }
 }
-
-// ported from: src/jsc/CommonStrings.zig
diff --git a/src/jsc/ConcurrentPromiseTask.rs b/src/jsc/ConcurrentPromiseTask.rs
index 8fab41a8442..62aba68d025 100644
--- a/src/jsc/ConcurrentPromiseTask.rs
+++ b/src/jsc/ConcurrentPromiseTask.rs
@@ -13,8 +13,7 @@ use bun_ptr::BackRef;
 /// - `then(&mut self, &mut JSPromise)` — resolves the promise with the result on the JS thread
 pub trait ConcurrentPromiseTaskContext: Sized {
     /// Tag this `ConcurrentPromiseTask<Self>` carries when enqueued back onto the
-    /// JS event loop's concurrent queue (`task_tag::*`). Mirrors Zig's
-    /// per-instantiation `TaggedPointerUnion` membership (e.g. `CopyFilePromiseTask`).
+    /// JS event loop's concurrent queue (`task_tag::*`).
     const TASK_TAG: TaskTag;
 
     fn run(&mut self);
@@ -29,20 +28,18 @@ pub trait ConcurrentPromiseTaskContext: Sized {
 /// - `run(*Context)` - performs the work on the thread pool
 /// - `then(*Context, jsc.JSPromise)` - resolves the promise with the result on the JS thread
 pub struct ConcurrentPromiseTask<'a, Context: ConcurrentPromiseTaskContext> {
-    // Zig: `ctx: *Context` — heap-allocated by caller (e.g. `bun.new(CopyFile, ...)`).
-    // Owned here so dropping the task frees the context (matches Zig `Context.deinit()` → `bun.destroy`).
+    // Owned here so dropping the task frees the context.
     pub ctx: Box<Context>,
     pub task: WorkPoolTask,
     /// BACKREF — captured from the JS-thread VM at create time; the VM (and its
     /// `EventLoop`) outlives every task scheduled on it.
     pub event_loop: BackRef<EventLoop>,
-    // PORT NOTE: `allocator: std.mem.Allocator` field dropped — global mimalloc (non-AST crate)
     pub promise: JSPromiseStrong,
     pub global_this: &'a JSGlobalObject,
     pub concurrent_task: ConcurrentTask,
 
     // This is a poll because we want it to enter the uSockets loop
-    // PORT NOTE: `ref` is a Rust keyword; field renamed to `ref_`.
+    // (`ref` is a Rust keyword, hence `ref_`)
     pub ref_: KeepAlive,
 }
 
@@ -59,8 +56,6 @@ impl<Context: ConcurrentPromiseTaskContext> Taskable for ConcurrentPromiseTask<'
 }
 
 impl<'a, Context: ConcurrentPromiseTaskContext> ConcurrentPromiseTask<'a, Context> {
-    // Zig: `pub const new = bun.TrivialNew(@This());` — folded into `Box::new` below.
-
     pub fn create_on_js_thread(global_this: &'a JSGlobalObject, value: Box<Context>) -> Box<Self> {
         // `VirtualMachine::get()` returns the JS-thread singleton; the VM and
         // its `EventLoop` outlive every task scheduled on it.
@@ -135,5 +130,3 @@ impl<'a, Context: ConcurrentPromiseTaskContext> ConcurrentPromiseTask<'a, Contex
         drop(unsafe { bun_core::heap::take(this) });
     }
 }
-
-// ported from: src/jsc/ConcurrentPromiseTask.zig
diff --git a/src/jsc/ConsoleObject.rs b/src/jsc/ConsoleObject.rs
index f43552ed7d7..96455a9a651 100644
--- a/src/jsc/ConsoleObject.rs
+++ b/src/jsc/ConsoleObject.rs
@@ -1,5 +1,3 @@
-//! Port of `src/jsc/ConsoleObject.zig`.
-//!
 //! Implements `console.*` printing for the Bun runtime: type-tag dispatch,
 //! recursive value formatting, table printing, `%`-format specifier handling,
 //! `console.count`/`time`/`timeEnd`, and the C ABI shims that JavaScriptCore
@@ -17,17 +15,16 @@ use bun_core::{Output, StackCheck};
 use bun_core::{OwnedString, String as BunString, strings};
 
 /// Thin facade over `bun_js_parser::lexer` / `bun_js_printer` so the call
-/// sites below keep their Zig spelling (`JSLexer.isLatin1Identifier`,
-/// `JSPrinter.writeJsonString`) while the underlying crates expose slightly
-/// different shapes (single generic identifier predicate; const-generic
+/// sites below can use the `JSLexer.isLatin1Identifier` /
+/// `JSPrinter.writeJsonString` spelling while the underlying crates expose
+/// slightly different shapes (single generic identifier predicate; const-generic
 /// encoding on `write_json_string`).
 mod JSLexer {
     #[inline]
     pub(super) fn is_latin1_identifier_u8(name: &[u8]) -> bool {
         bun_ast::lexer_tables::is_latin1_identifier(name)
     }
-    /// Zig `isLatin1Identifier(comptime []const u16, name)` — same predicate
-    /// over a UTF-16 slice. Canonical impl lives next to the u8 overload in
+    /// Same predicate over a UTF-16 slice. Canonical impl lives next to the u8 overload in
     /// `bun_js_parser::lexer`.
     #[inline]
     pub(super) fn is_latin1_identifier_u16(name: &[u16]) -> bool {
@@ -62,10 +59,9 @@ mod JSPrinter {
 }
 
 /// Local front for `bun_core::pretty_fmt!` that accepts a runtime / const-
-/// generic bool. Zig's `Output.prettyFmt(comptime fmt, comptime enable_colors)`
-/// took a comptime bool; the Rust macro only matches `true`/`false` literals,
-/// so monomorphized callers (`<const C: bool>`) branch here.
-// PERF(port): was comptime bool dispatch — both arms are `&'static str`.
+/// generic bool. The macro only matches `true`/`false` literals, so
+/// monomorphized callers (`<const C: bool>`) branch here.
+// Both arms are `&'static str`.
 macro_rules! pfmt {
     ($fmt:expr, $colors:expr) => {
         if $colors {
@@ -110,13 +106,13 @@ pub struct ConsoleObject {
 
 impl core::fmt::Display for ConsoleObject {
     fn fmt(&self, _: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // Zig: `pub fn format(...) !void {}` — intentionally prints nothing.
+        // Intentionally prints nothing.
         Ok(())
     }
 }
 
 impl ConsoleObject {
-    // PORT NOTE: `adapt_to_new_api(&mut self.stderr_buffer)` captures a raw
+    // `adapt_to_new_api(&mut self.stderr_buffer)` captures a raw
     // pointer into the buffer field, so the struct is self-referential once
     // initialized. The previous out-param shape (`&mut MaybeUninit<Self>`)
     // still let the caller move the value afterwards (e.g.
@@ -131,9 +127,6 @@ impl ConsoleObject {
     // `VirtualMachine.console` stores the raw pointer (`*mut c_void`), so
     // callers leak via `heap::alloc(Pin::into_inner_unchecked(..))` — the
     // VM owns it for the process lifetime.
-    //
-    // TODO(port): make `QuietWriterAdapter` own its 4 KiB buffer so
-    // the self-reference disappears and this can become `-> Self`.
     pub fn init(
         error_writer: Output::StreamType,
         writer: Output::StreamType,
@@ -198,13 +191,13 @@ impl ConsoleObject {
         out
     }
 
-    /// Replacement for Zig's self-referential `error_writer: *std.Io.Writer`.
+    /// Returns the buffered stderr writer interface.
     #[inline]
     pub fn error_writer(&mut self) -> &mut bun_core::io::Writer {
         self.error_writer_backing.new_interface()
     }
 
-    /// Replacement for Zig's self-referential `writer: *std.Io.Writer`.
+    /// Returns the buffered stdout writer interface.
     #[inline]
     pub fn writer(&mut self) -> &mut bun_core::io::Writer {
         self.writer_backing.new_interface()
@@ -222,12 +215,12 @@ pub enum MessageLevel {
 }
 
 impl MessageLevel {
-    /// Zig spec is `enum(u32) { ..., _ }` (non-exhaustive). Taking the
-    /// exhaustive Rust enum directly across the C ABI would be instant UB if
-    /// JSC ever passes an out-of-range discriminant, so the
+    /// The wire value is an arbitrary `u32`, not guaranteed in range. Taking
+    /// the exhaustive Rust enum directly across the C ABI would be instant UB
+    /// if JSC ever passes an out-of-range discriminant, so the
     /// `Bun__ConsoleObject__messageWithTypeAndLevel` shim accepts a raw `u32`
-    /// and routes through here. Unknown values fold to `Log` — no Zig codepath
-    /// branches on the `_` case, so any clamp is spec-equivalent.
+    /// and routes through here. Unknown values fold to `Log` — nothing
+    /// branches on the unknown case, so the clamp is behavior-preserving.
     #[inline]
     pub const fn from_raw(raw: u32) -> Self {
         match raw {
@@ -261,8 +254,8 @@ pub enum MessageType {
 }
 
 impl MessageType {
-    /// See [`MessageLevel::from_raw`] — Zig spec is non-exhaustive
-    /// (`enum(u32) { ..., _ }`); fold unknown discriminants to `Log` so the
+    /// See [`MessageLevel::from_raw`] — the wire value is an arbitrary `u32`;
+    /// fold unknown discriminants to `Log` so the
     /// FFI boundary never constructs an invalid enum value.
     #[inline]
     pub const fn from_raw(raw: u32) -> Self {
@@ -304,7 +297,7 @@ fn vm_console(global: &JSGlobalObject) -> *mut ConsoleObject {
     // VM's lifetime; the C++ side never calls into `Bun__ConsoleObject__*`
     // before that. Returned as a raw pointer (not `&'static mut`) so callers
     // dereference at each use site without holding overlapping `&mut`
-    // references — matches the Zig shape (`*ConsoleObject` field).
+    // references.
     global.bun_vm().as_mut().console.cast::<ConsoleObject>()
 }
 
@@ -334,7 +327,7 @@ thread_local! {
 /// RAII guard for the per-stream reentrant console lock. Acquires on
 /// construction (incrementing the thread-local count and locking the global
 /// mutex on first entry), releases on `Drop` (decrementing and unlocking on
-/// last exit). Replaces the Zig `defer { ... unlock() }` pair.
+/// last exit).
 struct ConsoleStreamLock {
     use_stderr: bool,
 }
@@ -380,8 +373,7 @@ impl Drop for ConsoleStreamLock {
     }
 }
 
-/// RAII flush of a borrowed `bun_io::Write` at scope exit when `enabled`
-/// (Zig: `defer if (options.flush) writer.flush()`).
+/// RAII flush of a borrowed `bun_io::Write` at scope exit when `enabled`.
 ///
 /// Owns the `&mut dyn Write` for its lifetime; the body of the scope must
 /// reborrow through `&mut *guard.writer` so that all body accesses are
@@ -572,8 +564,7 @@ fn message_with_type_and_level_(
         if opts.is_object() {
             if let Some(depth_prop) = opts.get(global, b"depth")? {
                 if depth_prop.is_int32() || depth_prop.is_number() || depth_prop.is_big_int() {
-                    // Match Zig `JSValue.toU16`: `@truncate(@max(toInt32(), 0))`
-                    // — clamp negatives to 0, then truncate (not saturate) to u16.
+                    // Clamp negatives to 0, then truncate (not saturate) to u16.
                     print_options.max_depth = depth_prop.to_int32().max(0) as u32 as u16;
                 } else if depth_prop.is_null() {
                     print_options.max_depth = u16::MAX;
@@ -673,7 +664,7 @@ impl<'a> TablePrinter<'a> {
             is_iterable: tabular_data.is_iterable(global_object)?,
             jstype: tabular_data.js_type(),
             value_formatter: {
-                // PORT NOTE: `Formatter` has a `Drop` impl, so struct-update
+                // `Formatter` has a `Drop` impl, so struct-update
                 // from a temporary is rejected (E0509).
                 let mut f = Formatter::new(global_object);
                 f.single_line = true;
@@ -704,9 +695,8 @@ impl<'a> TablePrinter<'a> {
     /// Compute how much horizontal space a `JSValue` will take when printed.
     fn get_width_for_value(&mut self, value: JSValue) -> JsResult<u32> {
         let mut width: usize = 0;
-        // PERF(port): Zig used a 512-byte discard buffer between the generic
-        // writer adapter and the counter to amortize vtable calls; here we
-        // write straight into the counter. Profile if hot.
+        // PERF: writes straight into the counter with no buffering between
+        // the generic writer adapter and the counter. Profile if hot.
         let mut counter = VisibleCharacterCounter { width: &mut width };
         let mut value_formatter = self.value_formatter.shallow_clone();
 
@@ -781,7 +771,7 @@ impl<'a> TablePrinter<'a> {
                     let column: &mut Column = 'brk: {
                         let col_str = BunString::init(col_key);
 
-                        // PORT NOTE: reshaped for borrowck — split find/append.
+                        // reshaped for borrowck — split find/append.
                         if let Some(idx) =
                             columns[1..].iter().position(|col| col.name.eql(&col_str))
                         {
@@ -897,12 +887,11 @@ impl<'a> TablePrinter<'a> {
                     TagPayload::String | TagPayload::StringPossiblyFormatted
                 ));
 
-                // `defer` block: release pooled visit map after formatting.
-                // PORT NOTE: Zig's `defer` body also nulls
-                // `this.value_formatter.map_node`, but `shallow_clone()`
-                // already guarantees the source's `map_node` is `None`, so
-                // only the local clone needs draining. `Formatter::Drop` does
-                // the same release, so a plain scope is sufficient.
+                // Release pooled visit map after formatting.
+                // `shallow_clone()` guarantees the source's `map_node` is
+                // `None`, so only the local clone needs draining.
+                // `Formatter::Drop` does the same release, so a plain scope
+                // is sufficient.
                 {
                     let result = value_formatter.format::<ENABLE_ANSI_COLORS>(
                         tag,
@@ -941,14 +930,13 @@ impl<'a> TablePrinter<'a> {
     ) -> JsResult<()> {
         let global_object = self.global_object;
 
-        // PERF(port): was stack-fallback alloc (16 columns) — profile if hot.
         let mut columns: Vec<Column> = Vec::with_capacity(16);
         let mut _deref_names = scopeguard::guard(&mut columns, |cols| {
             for col in cols.iter_mut() {
                 col.name.deref();
             }
         });
-        // PORT NOTE: reshaped for borrowck — re-borrow through the guard.
+        // reshaped for borrowck — re-borrow through the guard.
         let columns: &mut Vec<Column> = &mut **_deref_names;
 
         // create the first column " " which is always present
@@ -956,7 +944,6 @@ impl<'a> TablePrinter<'a> {
             name: BunString::static_("\u{0020}"),
             width: 1,
         });
-        // PERF(port): was assume_capacity
 
         // special case for Map: create the special "Key" column at index 1
         if self.jstype.is_map() {
@@ -1270,9 +1257,8 @@ pub fn write_trace(writer: &mut dyn bun_io::Write, global: &JSGlobalObject) {
         let exception = holder.zig_exception();
         err.to_zig_exception(global, exception);
     }
-    // PORT NOTE: reshaped for borrowck — Zig held `exception` and
-    // `&holder.need_to_clear_parser_arena_on_deinit` simultaneously; in Rust
-    // those are two `&mut` into `holder`. Capture the flag in a local and
+    // `exception` and `&holder.need_to_clear_parser_arena_on_deinit` would be
+    // two simultaneous `&mut` into `holder`. Capture the flag in a local and
     // write it back after.
     let mut need_to_clear = holder.need_to_clear_parser_arena_on_deinit;
     vm.remap_zig_exception(
@@ -1292,10 +1278,8 @@ pub fn write_trace(writer: &mut dyn bun_io::Write, global: &JSGlobalObject) {
         Output::enable_ansi_colors_stderr(),
     );
 
-    // Zig: `defer if (source_code_slice) |slice| slice.deinit();` —
     // `ZigStringSlice` frees on `Drop`.
     drop(source_code_slice);
-    // Zig: `defer holder.deinit(vm);` — explicit (takes `vm`).
     holder.deinit(vm);
 }
 
@@ -1485,7 +1469,7 @@ pub fn format2(
 
     if len == 1 {
         // initialized later in this function.
-        // PORT NOTE: `Formatter` has a `Drop` impl, so struct-update from a
+        // `Formatter` has a `Drop` impl, so struct-update from a
         // temporary is rejected (E0509). Construct via `new()` then mutate.
         let mut fmt = Formatter::new(global);
         fmt.ordered_properties = options.ordered_properties;
@@ -1519,7 +1503,6 @@ pub fn format2(
 
             let _ = writer.flush();
         } else {
-            // PORT NOTE: Zig `defer if (options.flush) writer.flush()`.
             // Reborrow through the guard so SB sees body writes as children
             // of the guard's borrow (see `FlushOnDrop` doc).
             let mut _flush = FlushOnDrop {
@@ -1540,7 +1523,6 @@ pub fn format2(
         return Ok(());
     }
 
-    // PORT NOTE: Zig `defer if (options.flush) writer.flush()`.
     // Reborrow through the guard so SB sees body writes as children of the
     // guard's borrow (see `FlushOnDrop` doc).
     let mut _flush = FlushOnDrop {
@@ -1550,7 +1532,7 @@ pub fn format2(
     let writer: &mut dyn bun_io::Write = &mut *_flush.writer;
 
     let mut this_value: JSValue = vals[0];
-    // PORT NOTE: see E0509 note above.
+    // see E0509 note above.
     let mut fmt = Formatter::new(global);
     fmt.remaining_values = bun_ptr::RawSlice::new(&vals[1..]);
     fmt.ordered_properties = options.ordered_properties;
@@ -1636,8 +1618,7 @@ pub use formatter::{Formatter, Tag, TagOptions, TagPayload, TagResult, visited};
 pub mod formatter {
     use super::*;
 
-    /// RAII: write `prev` back through `place` on drop (Zig
-    /// `defer this.field = prev;`). Holds a raw `*mut` so the body of the
+    /// RAII: write `prev` back through `place` on drop. Holds a raw `*mut` so the body of the
     /// scope can freely take `&mut self` without aliasing the borrow.
     ///
     /// NOTE(aliasing): the `addr_of_mut!(self.field)` → body uses `&mut self`
@@ -1675,7 +1656,7 @@ pub mod formatter {
         }
     }
 
-    /// RAII: `*place -|= 1` on drop (Zig `defer this.field -|= 1;`). Holds a
+    /// RAII: saturating-decrement `*place` on drop. Holds a
     /// raw `*mut` so the body can freely take `&mut self`.
     pub(super) struct Decrement<T: SaturatingDec> {
         place: *mut T,
@@ -1689,8 +1670,7 @@ pub mod formatter {
         }
     }
 
-    /// RAII: `map.remove(value)` on drop iff `*armed` (Zig
-    /// `defer { if (...) _ = this.map.remove(value); }` in `printAs`). Holds
+    /// RAII: `map.remove(value)` on drop iff `*armed`. Holds
     /// raw pointers so the body can freely take `&mut self`; smaller than the
     /// equivalent `scopeguard::defer!` closure under ASAN stack redzones.
     pub(super) struct VisitedRemove {
@@ -1711,10 +1691,10 @@ pub mod formatter {
         }
     }
 
-    /// Mirror Zig's `defer this.field = prev;` without holding a live borrow
-    /// on `self` for the body of the scope. Zig `defer` reads at scope-exit
-    /// time and never aliases, so we capture a raw `*mut` to the field and
-    /// write through it on drop. This lets the body freely take `&mut self`.
+    /// Restore a field to `prev` at scope exit without holding a live borrow
+    /// on `self` for the body of the scope. The guard reads at scope-exit
+    /// time and never aliases: it captures a raw `*mut` to the field and
+    /// writes through it on drop. This lets the body freely take `&mut self`.
     macro_rules! defer_restore {
         ($place:expr, $prev:expr) => {
             Restore {
@@ -1724,7 +1704,7 @@ pub mod formatter {
         };
     }
 
-    /// Mirror Zig's `defer this.field -|= 1;` without holding a live borrow.
+    /// Saturating-decrement a field at scope exit without holding a live borrow.
     macro_rules! defer_decrement {
         ($place:expr) => {
             Decrement {
@@ -1737,8 +1717,7 @@ pub mod formatter {
         pub global_this: &'a JSGlobalObject,
 
         /// Callers seat this to a stack slice and reset it to `EMPTY` before
-        /// the backing storage goes away (mirrors the Zig
-        /// `defer self.formatter.remaining_values = &.{}` pattern). A `&'a`
+        /// the backing storage goes away. A `&'a`
         /// slice cannot express that without forcing `'a` to outlive locals;
         /// `RawSlice` carries the outlives-holder invariant instead.
         pub remaining_values: bun_ptr::RawSlice<JSValue>,
@@ -1746,8 +1725,7 @@ pub mod formatter {
         /// Pooled backing for `map`. `None` until the first cell that can have
         /// circular refs is formatted; `Drop` returns it to `visited::Pool`.
         /// Raw pointer (not `Box`) because `visited::Pool` owns the
-        /// `heap::alloc`/`from_raw` lifecycle — mirrors Zig
-        /// `?*Visited.Pool.Node`.
+        /// `heap::alloc`/`from_raw` lifecycle.
         pub map_node: Option<core::ptr::NonNull<visited::PoolNode>>,
         pub hide_native: bool,
         pub indent: u32,
@@ -1772,7 +1750,7 @@ pub mod formatter {
     }
 
     impl<'a> Formatter<'a> {
-        /// Field-default constructor (Zig struct field defaults).
+        /// Field-default constructor.
         pub fn new(global_this: &'a JSGlobalObject) -> Self {
             Self {
                 global_this,
@@ -1792,9 +1770,9 @@ pub mod formatter {
                 ordered_properties: false,
                 custom_formatted_object: CustomFormattedObject::default(),
                 disable_inspect_custom: false,
-                // Zig field default `.{}` (`cached_stack_end = 0` ⇒ check
-                // always passes); callers that want a real bound overwrite
-                // with `StackCheck::init()` explicitly.
+                // `StackCheck::default()` has `cached_stack_end = 0` ⇒ the
+                // check always passes; callers that want a real bound
+                // overwrite with `StackCheck::init()` explicitly.
                 stack_check: StackCheck::default(),
                 can_throw_stack_overflow: false,
                 error_display_level: ErrorDisplayLevel::Full,
@@ -1802,10 +1780,9 @@ pub mod formatter {
             }
         }
 
-        /// Zig copies `Formatter` by value (`var f = this.value_formatter;`).
-        /// In Rust `Formatter` has a `Drop` impl and owns `map`/`map_node`,
-        /// so a bit-copy via `ptr::read` would double-free. The Zig copy
-        /// only ever ships scalar config — `map`/`map_node` are always empty
+        /// `Formatter` has a `Drop` impl and owns `map`/`map_node`,
+        /// so a bit-copy via `ptr::read` would double-free. Only scalar
+        /// config needs to ship — `map`/`map_node` are always empty
         /// on the source at the call sites — so we copy those fields
         /// explicitly and leave `map`/`map_node` fresh on the clone.
         pub(super) fn shallow_clone(&self) -> Self {
@@ -1861,7 +1838,6 @@ pub mod formatter {
             if let Some(mut node) = self.map_node.take() {
                 // Move the working map back into the pooled node, shrink if it
                 // ballooned, then return the node to the thread-local pool.
-                // Mirrors `Formatter.deinit` (ConsoleObject.zig:1016-1024).
                 let map = core::mem::take(&mut self.map);
                 // `node_data_mut` is safe: `Map::INIT` is `Some`, so the
                 // pooled slot already holds an (empty, post-`take`) `Map`;
@@ -1899,11 +1875,10 @@ pub mod formatter {
         }
     }
 
-    /// `Display` adapter equivalent to Zig's `Formatter.ZigFormatter`.
+    /// `Display` adapter that formats a single `JSValue` through a borrowed
+    /// `Formatter`.
     ///
-    /// The Zig spec (`ConsoleObject.zig:1044-1062`) takes `self: ZigFormatter`
-    /// *by value* with a raw `*Formatter` field, so writing through
-    /// `self.formatter.*` carries no aliasing constraint. `Display::fmt` only
+    /// `Display::fmt` only
     /// gives us `&self`, so the mutable handle is parked behind a `Cell` and
     /// moved out for the duration of the call — this preserves unique-borrow
     /// provenance without the `&shared → *const → *mut` cast that would be UB
@@ -1926,7 +1901,7 @@ pub mod formatter {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             // Move the unique `&mut Formatter` out of the cell for the body;
             // re-seat it (and clear `remaining_values`) on the way out so the
-            // adapter mirrors Zig's `defer` and stays reusable.
+            // adapter stays reusable.
             let formatter: &mut Formatter<'_> = self
                 .formatter
                 .take()
@@ -1945,7 +1920,6 @@ pub mod formatter {
                     .map_err(|_| core::fmt::Error)
             })();
 
-            // Mirrors Zig `defer self.formatter.remaining_values = &.{}`.
             formatter.remaining_values = bun_ptr::RawSlice::EMPTY;
             self.formatter.set(Some(formatter));
             result
@@ -1979,14 +1953,12 @@ pub mod formatter {
         }
 
         impl bun_collections::pool::ObjectPoolType for Map {
-            // Zig: `ObjectPool(Map, Map.init, true, 16)` — fresh nodes start
-            // with an empty map so `clearRetainingCapacity()` on first use is
-            // well-defined.
+            // Fresh nodes start with an empty map so clearing retained
+            // capacity on first use is well-defined.
             const INIT: Option<fn() -> Result<Self, bun_core::Error>> = Some(|| Ok(Map::default()));
         }
 
-        // Thread-local free list, capped at 16 nodes — matches Zig
-        // `threadsafe = true, max_count = 16`.
+        // Thread-local free list, capped at 16 nodes.
         bun_collections::object_pool!(pub Pool: Map, threadsafe, 16);
         pub type PoolNode = bun_collections::pool::Node<Map>;
 
@@ -2083,7 +2055,7 @@ pub mod formatter {
         }
     }
 
-    /// Zig: `union(Tag)`. Only `CustomFormattedObject` carries a payload.
+    /// Only `CustomFormattedObject` carries a payload.
     #[derive(Copy, Clone, PartialEq, Eq)]
     pub enum TagPayload {
         StringPossiblyFormatted,
@@ -2121,14 +2093,13 @@ pub mod formatter {
     }
 
     impl TagPayload {
-        /// Zig `Formatter.Tag.get` — `TagPayload` is the Rust spelling of the
-        /// Zig union, so the constructor lives here as well as on the bare
+        /// The constructor lives here as well as on the bare
         /// discriminant `Tag`. Callers in sibling modules use either name.
         #[inline]
         pub fn get(value: JSValue, global_this: &JSGlobalObject) -> JsResult<TagResult> {
             Tag::get(value, global_this)
         }
-        /// Zig `Formatter.Tag.getAdvanced`.
+        /// Delegates to `Tag::get_advanced`.
         #[inline]
         pub fn get_advanced(
             value: JSValue,
@@ -2558,7 +2529,7 @@ pub mod formatter {
                             break;
                         }
 
-                        // PORT NOTE: borrowck — `writer` holds `&mut self.estimated_line_length`,
+                        // borrowck — `writer` holds `&mut self.estimated_line_length`,
                         // so route `remaining_values` reads/writes through the `RawSlice`
                         // field directly instead of the `&self` helper methods.
                         if self.remaining_values.is_empty() {
@@ -2580,11 +2551,10 @@ pub mod formatter {
                                 // then skip the second % so we dont hit it again
                                 slice = &slice[slice.len().min((i + 1) as usize)..];
                                 len = slice.len() as u32;
-                                // PORT NOTE: replicates Zig's `while : (i += 1)` continue-
-                                // expression — Zig's `i = 0; continue;` is bumped to 1 by
-                                // the continue-expr, so the next iteration inspects
-                                // `slice[1]`, not `slice[0]`. (This is itself an upstream
-                                // off-by-one vs the WHATWG spec; tracked separately.)
+                                // Start the next iteration at `slice[1]`,
+                                // not `slice[0]`. (This is itself an
+                                // off-by-one vs the WHATWG spec; tracked
+                                // separately.)
                                 i = 1;
                                 continue;
                             }
@@ -2784,7 +2754,7 @@ pub mod formatter {
                             PercentTag::J => {
                                 // JSON.stringify the value using FastStringifier
                                 // for SIMD optimization
-                                // Zig: `defer str.deref()` — `OwnedString` releases the
+                                // `OwnedString` releases the
                                 // +1 WTF ref on every exit (incl. the `?` below).
                                 let mut str = OwnedString::new(BunString::empty());
                                 next_value.json_stringify_fast(global, &mut str)?;
@@ -2808,9 +2778,8 @@ pub mod formatter {
         }
     }
 
-    /// Zig: `fn WrappedWriter(comptime Writer: type) type`. We collapse the
-    /// generic over `*std.Io.Writer` into `&mut dyn bun_io::Write`.
-    // PERF(port): was comptime monomorphization (`fn WrappedWriter(comptime Writer: type) type`) — profile if hot.
+    /// Failure-tracking writer wrapper over `&mut dyn bun_io::Write`.
+    // PERF: dynamic dispatch rather than monomorphization — profile if hot.
     pub struct WrappedWriter<'w> {
         pub ctx: &'w mut dyn bun_io::Write,
         pub failed: bool,
@@ -2889,9 +2858,7 @@ pub mod formatter {
             }
         }
 
-        // TODO(port): Zig computed `length_ignoring_formatted_values` at
-        // comptime by walking the format string. We'd need a `const fn` /
-        // proc-macro to recover that; for now the count is a runtime
+        // `fmt_len` (the length ignoring formatted values) is a runtime
         // argument computed by the `pretty!` macro.
         pub fn pretty<const ENABLE_ANSI_COLOR: bool>(
             &mut self,
@@ -3525,10 +3492,9 @@ pub mod formatter {
                 return Ok(());
             }
 
-            // Zig: `defer { if (... && remove_before_recurse) _ = this.map.remove(value); }`.
             // The body mutates both `self` and `remove_before_recurse`, so
             // capture raw pointers and read the *current* `remove_before_recurse`
-            // at scope-exit time, exactly like Zig's late-evaluated `defer`.
+            // at scope-exit time.
             let _visited = VisitedRemove {
                 map: &raw mut self.map,
                 armed: &raw const remove_before_recurse,
@@ -3605,10 +3571,9 @@ pub mod formatter {
     // ───────────────────────────────────────────────────────────────────────
     // Per-tag helpers split out of print_as
     //
-    // In Zig these are inline `switch` arms in `printAs`, where the comptime
-    // `Format` parameter means each instantiation contains only one arm's
-    // code and stack locals. Rust does not DCE dead `match` arms on a const
-    // generic in debug builds, so keeping them inline would make every
+    // Rust does not DCE dead `match` arms on a const
+    // generic in debug builds, so keeping these inline in `print_as` would
+    // make every
     // recursive `print_as` frame carry the union of all arms' locals. Each
     // body is therefore its own `#[inline(never)]` function.
     // ───────────────────────────────────────────────────────────────────────
@@ -4751,7 +4716,7 @@ pub mod formatter {
             js_type: jsc::JSType,
             remove_before_recurse: &mut bool,
         ) -> JsResult<()> {
-            // LAYERING: the Zig spec walks an `if (value.as(T))` chain over
+            // LAYERING: this needs to downcast over
             // `Response`/`Request`/`Blob`/`S3Client`/`Archive`/`BuildArtifact`/
             // `FetchHeaders`/`TimeoutObject`/`ImmediateObject`/`BuildMessage`/
             // `ResolveMessage`/Jest asymmetric matchers — all of which live in
@@ -4760,7 +4725,7 @@ pub mod formatter {
             // formatted `value`; otherwise we fall through to the generic
             // object printer below.
             if let Some(hooks) = crate::virtual_machine::runtime_hooks() {
-                // Zig: `threadlocal var name_buf: [512]u8`. The hook only ever
+                // The hook only ever
                 // seeds a `ZigString` that `get_class_name` immediately
                 // overwrites with JSC-owned bytes, so a shared zero buffer is
                 // sufficient and keeps 512B off every recursive frame.
@@ -4852,7 +4817,6 @@ pub mod formatter {
                 self.depth = self.depth.saturating_add(1);
                 let _i = defer_decrement!(self.indent);
                 let _d = defer_decrement!(self.depth);
-                // PERF(port): was comptime bool dispatch on single_line — profile if hot.
                 let global_this = self.global_this;
                 if self.single_line {
                     let mut iter = MapIteratorCtx::<C, false, true> {
@@ -4928,9 +4892,7 @@ pub mod formatter {
                     if iter.formatter.failed {
                         return Ok(());
                     }
-                    // Spec divergence: Zig's `.SetIterator` arm writes NOTHING in
-                    // single-line mode (`if (count > 0 and !single_line) writeAll("\n")`),
-                    // only `.MapIterator` writes a trailing space.
+                    // Only the MapIterator case writes a trailing space.
                     if count > 0 && label == "MapIterator" {
                         let _ = writer_.write_all(b" ");
                     }
@@ -5079,7 +5041,7 @@ pub mod formatter {
                 }
             };
 
-            // PORT NOTE: Zig `@tagName(event_type)`. `EventType` is a transparent
+            // `EventType` is a transparent
             // u8 newtype (non-exhaustive enum), so there is no derived `From<EventType>
             // for &str`; only the two arms above can reach here.
             let event_tag_name: &'static str = match event_type {
@@ -5217,12 +5179,9 @@ pub mod formatter {
             Ok(())
         }
 
-        // TODO(port): JSX printing is large (≈230 LOC) and entirely
-        // self-contained string formatting over `value.get("type"/"key"/"props"
-        // /"children")`. The logic is reproduced here at the same control-flow
-        // shape; verify against existing JSX snapshot tests
-        // (`test/js/bun/util/inspect.test.js`) before trusting the borrow-reseat
-        // points.
+        // JSX printing is large (≈230 LOC) and entirely self-contained string
+        // formatting over `value.get("type"/"key"/"props"/"children")`
+        // (covered by `test/js/bun/util/inspect.test.js` snapshots).
         #[inline(never)]
         fn print_jsx<const C: bool>(
             &mut self,
@@ -5247,16 +5206,13 @@ pub mod formatter {
             writer.write_all(pf!("<r>").as_bytes());
             writer.write_all(b"<");
 
-            // PORT NOTE: Zig initialized `needs_space = false` / `tag_name_slice = .empty`,
-            // but both arms of the `type` if/else below assign them, so deferred init
-            // avoids the dead-store warning while keeping semantics identical.
+            // Both arms of the `type` if/else below assign these, so deferred
+            // init avoids the dead-store warning.
             let mut needs_space: bool;
             let mut tag_name_str = ZigString::init(b"");
 
-            // PORT NOTE: Zig spelled this `ZigString.Slice` with an explicit
-            // `defer if (tag_name_slice.isAllocated()) tag_name_slice.deinit()`.
-            // The Rust `ZigStringSlice` enum frees on `Drop`, so the scopeguard
-            // is unnecessary.
+            // `ZigStringSlice` frees on `Drop`, so no explicit cleanup is
+            // needed.
             let tag_name_slice: strings::ZigStringSlice;
             let mut is_tag_kind_primitive = false;
 
@@ -5753,7 +5709,7 @@ pub mod formatter {
                 return Ok(());
             }
 
-            // PORT NOTE: `ArrayBuffer.typed_array_type` is `JSType` in the Rust
+            // `ArrayBuffer.typed_array_type` is `JSType` in the Rust
             // port (see array_buffer.rs), not the C-API `TypedArrayType` enum.
             writer.write_all(
                 if array_buffer.typed_array_type == jsc::JSType::Uint8Array
@@ -5813,7 +5769,7 @@ pub mod formatter {
             Ok(())
         }
 
-        // PORT NOTE: associated fn (no `&mut self`) so callers can pass a
+        // associated fn (no `&mut self`) so callers can pass a
         // `WrappedWriter` that already borrows `&mut self.estimated_line_length`
         // without tripping E0499. The only `self` use was `print_comma`, which
         // `WrappedWriter` mirrors.
@@ -6040,7 +5996,7 @@ pub extern "C" fn Bun__ConsoleObject__timeEnd(
     // SAFETY: caller passes a valid (ptr, len) pair.
     let slice = unsafe { bun_core::ffi::slice(chars, len) };
     let id = bun_wyhash::hash(slice);
-    // Zig `fetchPut(id, null)` — replace with `None`, returning the previous.
+    // Replace the slot with `None`, returning the previous value.
     let Some(prev) = PENDING_TIME_LOGS.with_borrow_mut(|m| m.get_mut(&id).map(|slot| slot.take()))
     else {
         return;
@@ -6089,7 +6045,7 @@ pub extern "C" fn Bun__ConsoleObject__timeLog(
     Output::flush();
 
     // print the arguments
-    // PORT NOTE: `Formatter` has a `Drop` impl, so struct-update from a
+    // `Formatter` has a `Drop` impl, so struct-update from a
     // temporary is rejected (E0509). Construct via `new()` then mutate.
     let mut fmt = Formatter::new(global);
     fmt.max_depth = bun_options_types::context::try_get()
@@ -6120,9 +6076,7 @@ pub extern "C" fn Bun__ConsoleObject__timeLog(
 }
 
 /// Stamp out the empty `Bun__ConsoleObject__*` C-ABI hooks that JSC's
-/// `ConsoleClient` vtable requires but Bun leaves unimplemented
-/// (zig:ConsoleObject.zig:3728-3793 hand-writes six identical
-/// `callconv(jsc.conv) void {}` stubs and `@export`s each). Two arms cover
+/// `ConsoleClient` vtable requires but Bun leaves unimplemented. Two arms cover
 /// the two trailing-arg shapes the C++ side declares in
 /// `bindings/headers.h:686-694`: `(…, *const u8, usize)` for the title-string
 /// hooks and `(…, *mut ScriptArguments)` for the inspector-args hooks.
@@ -6170,7 +6124,7 @@ pub extern "C" fn Bun__ConsoleObject__takeHeapSnapshot(
     // SAFETY: re-entry into our own host shim with a stack-local args slice.
     unsafe {
         message_with_type_and_level(
-            core::ptr::null_mut(), // Zig passes `undefined` here
+            core::ptr::null_mut(), // unused by the callee
             MessageType::Log,
             MessageLevel::Debug,
             global_this,
@@ -6192,7 +6146,7 @@ console_noop_hooks!(
 #[crate::host_call]
 pub extern "C" fn Bun__ConsoleObject__messageWithTypeAndLevel(
     ctype: *mut ConsoleObject,
-    // Zig spec types both as non-exhaustive `enum(u32) { ..., _ }`. Taking the
+    // Taking the
     // exhaustive Rust enums by value at the C ABI would be UB on an
     // out-of-range discriminant, so accept the raw `u32` (matching the C++
     // header in `bindings/headers.h`) and clamp via `from_raw`.
@@ -6214,5 +6168,3 @@ pub extern "C" fn Bun__ConsoleObject__messageWithTypeAndLevel(
         )
     };
 }
-
-// ported from: src/jsc/ConsoleObject.zig
diff --git a/src/jsc/Counters.rs b/src/jsc/Counters.rs
index 3ab2025a798..adcbe915694 100644
--- a/src/jsc/Counters.rs
+++ b/src/jsc/Counters.rs
@@ -9,9 +9,6 @@ pub struct Counters {
 
 impl Counters {
     pub fn mark(&mut self, tag: Field) {
-        // PORT NOTE: Zig used `comptime tag` + `@field(this, @tagName(tag))` reflection;
-        // Rust dispatches via match. Demoted to runtime arg (not used in a type position).
-        // PERF(port): was comptime monomorphization — profile if it shows up on a hot path.
         let slot = match tag {
             Field::SpawnSyncBlocking => &mut self.spawn_sync_blocking,
             Field::SpawnMemfd => &mut self.spawn_memfd,
@@ -20,8 +17,6 @@ impl Counters {
     }
 
     pub fn to_js(self, global: &JSGlobalObject) -> JsResult<JSValue> {
-        // PORT NOTE: Zig used `JSObject::create(struct_value, global)` (field reflection
-        // builds an object with one property per struct field). Hand-rolled `put` calls here.
         let obj = JSValue::create_empty_object(global, 2);
         obj.put(
             global,
@@ -37,15 +32,14 @@ impl Counters {
     }
 }
 
-// TODO(port): proc-macro — `#[bun_jsc::host_fn]` emits the `extern "sysv64"`/"C"
-// trampoline. Until the macro crate exists, expose the Zig-shape signature
-// directly; the trampoline is wired by codegen.
+// Called through the `$zig(...)` js2native codegen, which emits the extern
+// trampoline (`generate-js2native.ts` wraps this in `host_fn::host_fn_static`),
+// so no `#[bun_jsc::host_fn]` attribute is needed here.
 pub fn create_counters_object(global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
     // SAFETY: bun_vm() returns the per-thread VirtualMachine singleton; caller is on the JS thread.
     global.bun_vm().counters.to_js(global)
 }
 
-// Zig: `const Field = std.meta.FieldEnum(Counters);`
 #[derive(Clone, Copy, PartialEq, Eq, strum::IntoStaticStr)]
 pub enum Field {
     #[strum(serialize = "spawnSync_blocking")]
@@ -53,5 +47,3 @@ pub enum Field {
     #[strum(serialize = "spawn_memfd")]
     SpawnMemfd,
 }
-
-// ported from: src/jsc/Counters.zig
diff --git a/src/jsc/CppTask.rs b/src/jsc/CppTask.rs
index 7b940d61067..130402469c2 100644
--- a/src/jsc/CppTask.rs
+++ b/src/jsc/CppTask.rs
@@ -4,7 +4,6 @@ use crate::{JSGlobalObject, JsResult, VirtualMachineRef as VirtualMachine};
 use bun_event_loop::{TaskTag, Taskable, task_tag};
 use bun_threading::work_pool::{Task as WorkPoolTask, WorkPool};
 
-// TODO(port): move to jsc_sys
 #[allow(improper_ctypes)] // VirtualMachine is opaque to C++; passed as `void*`
 unsafe extern "C" {
     fn Bun__EventLoopTaskNoContext__performTask(task: *mut EventLoopTaskNoContext);
@@ -98,5 +97,3 @@ pub(crate) extern "C" fn ConcurrentCppTask__createAndRun(cpp_task: *mut EventLoo
         workpool_task: WorkPoolTask::default(),
     });
 }
-
-// ported from: src/jsc/CppTask.zig
diff --git a/src/jsc/CustomGetterSetter.rs b/src/jsc/CustomGetterSetter.rs
index efbc6cb09a6..3489e4cfdd8 100644
--- a/src/jsc/CustomGetterSetter.rs
+++ b/src/jsc/CustomGetterSetter.rs
@@ -13,10 +13,7 @@ impl CustomGetterSetter {
     }
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn JSC__CustomGetterSetter__isGetterNull(this: &CustomGetterSetter) -> bool;
     safe fn JSC__CustomGetterSetter__isSetterNull(this: &CustomGetterSetter) -> bool;
 }
-
-// ported from: src/jsc/CustomGetterSetter.zig
diff --git a/src/jsc/DOMFormData.rs b/src/jsc/DOMFormData.rs
index ce185f221fe..bc406d3bb3a 100644
--- a/src/jsc/DOMFormData.rs
+++ b/src/jsc/DOMFormData.rs
@@ -8,7 +8,6 @@ bun_opaque::opaque_ffi! {
     pub struct DOMFormData;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn WebCore__DOMFormData__create(arg0: &JSGlobalObject) -> JSValue;
     safe fn WebCore__DOMFormData__createFromURLQuery(
@@ -62,9 +61,8 @@ impl DOMFormData {
         })
     }
 
-    // PORT NOTE: Zig's `comptime Ctx: type, ctx: Ctx, comptime callback: fn(Ctx, ZigString)`
-    // is Zig's spelling of a monomorphized closure. Reshaped to `FnMut(ZigString)` — the
-    // closure environment IS the ctx, and the generic trampoline below is the `Wrapper.run`.
+    // The closure environment is the ctx pointer; the generic trampoline
+    // below unwraps it and invokes the closure.
     pub fn to_query_string<F>(&mut self, callback: &mut F)
     where
         F: FnMut(ZigString),
@@ -89,8 +87,9 @@ impl DOMFormData {
         // Returned pointer is valid while `value` is kept alive on the stack
         // (conservative GC scan). Null → None. `DOMFormData` is an opaque ZST
         // handle, so `opaque_mut` is the centralised zero-byte deref proof.
-        // TODO(port): lifetime — unbounded `'a` is a placeholder; caller must keep `value`
-        // stack-rooted for the lifetime of the returned reference.
+        // The unbounded `'a` cannot be expressed more tightly: the cell is
+        // GC-owned, so the caller must keep `value` stack-rooted for the
+        // lifetime of the returned reference.
         let p = WebCore__DOMFormData__fromJS(value);
         (!p.is_null()).then(|| DOMFormData::opaque_mut(p))
     }
@@ -113,9 +112,6 @@ impl DOMFormData {
         WebCore__DOMFormData__count(self)
     }
 
-    // PORT NOTE: Zig's `comptime Context: type, ctx: *Context, comptime callback_wrapper`
-    // reshaped to a Rust closure; the generic `extern "C"` trampoline below is `Wrap.forEachWrapper`.
-    //
     // LAYERING: `FormDataEntry::File::blob` is a `*mut webcore::Blob`, whose
     // layout lives in `bun_runtime` (a dependent of this crate). The C++ side
     // hands it as `*mut c_void`; this fn is generic over `B` so the caller (in
@@ -134,7 +130,7 @@ impl DOMFormData {
         ) where
             F: FnMut(ZigString, FormDataEntry<'_, B>),
         {
-            // SAFETY: ctx_ptr is the `&mut F` passed below; Zig did `ctx_ptr.?` (unwrap non-null).
+            // SAFETY: ctx_ptr is the non-null `&mut F` passed below.
             let ctx_ = unsafe { bun_ptr::callback_ctx::<F>(ctx_ptr) };
             let value = if is_blob == 0 {
                 // SAFETY: when is_blob == 0, value_ptr points to a ZigString.
@@ -182,5 +178,3 @@ pub enum FormDataEntry<'a, B> {
     String(ZigString),
     File { blob: &'a B, filename: ZigString },
 }
-
-// ported from: src/jsc/DOMFormData.zig
diff --git a/src/jsc/DOMURL.rs b/src/jsc/DOMURL.rs
index e765e2f5911..04a8bfe2e9d 100644
--- a/src/jsc/DOMURL.rs
+++ b/src/jsc/DOMURL.rs
@@ -8,15 +8,12 @@ bun_opaque::opaque_ffi! {
     pub struct DOMURL;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `DOMURL`/`VM` are opaque `UnsafeCell`-backed ZST handles; `ZigString`/`c_int`
 // out-params are plain `#[repr(C)]` PODs whose `&mut` is exclusive for the
 // call → `safe fn`.
 unsafe extern "C" {
     safe fn WebCore__DOMURL__cast_(value: JSValue, vm: &VM) -> *mut DOMURL;
     safe fn WebCore__DOMURL__fileSystemPath(this: &DOMURL, error_code: &mut c_int) -> bstr::String;
-    // These two are referenced via `bun.cpp.*` in the Zig source.
     safe fn WebCore__DOMURL__href_(this: &DOMURL, out: &mut ZigString);
     safe fn WebCore__DOMURL__pathname_(this: &DOMURL, out: &mut ZigString);
 }
@@ -35,7 +32,9 @@ bun_core::named_error_set!(ToFileSystemPathError);
 
 impl DOMURL {
     pub fn cast_<'a>(value: JSValue, vm: &'a VM) -> Option<&'a mut DOMURL> {
-        // TODO(port): lifetime — DOMURL is a GC-owned C++ cell; no Rust-expressible lifetime.
+        // DOMURL is a GC-owned C++ cell; the returned reference is only valid
+        // while `value` stays alive (e.g. stack-rooted for the conservative GC
+        // scan) — the borrow on `vm` does not capture that.
         // `DOMURL` is an `opaque_ffi!` ZST handle; `opaque_mut` is the
         // centralised non-null-ZST deref proof (zero-byte `&mut` cannot alias).
         let p = WebCore__DOMURL__cast_(value, vm);
@@ -83,5 +82,3 @@ impl DOMURL {
         out
     }
 }
-
-// ported from: src/jsc/DOMURL.zig
diff --git a/src/jsc/Debugger.rs b/src/jsc/Debugger.rs
index b4d2097b993..8cffe3d10db 100644
--- a/src/jsc/Debugger.rs
+++ b/src/jsc/Debugger.rs
@@ -27,8 +27,7 @@ bun_core::declare_scope!(LifecycleAgent, visible);
 // so `Debugger.http_server_agent` carries `next_server_id` state).
 // `BunFrontendDevServerAgent` is defined HERE (the canonical definition) —
 // it carries `next_inspector_connection_id` state inline in `Debugger`, so
-// it must live in this crate. Spec source:
-// `src/runtime/server/InspectorBunFrontendDevServerAgent.zig`.
+// it must live in this crate.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub use crate::http_server_agent::HTTPServerAgent;
@@ -39,7 +38,7 @@ bun_opaque::opaque_ffi! {
 }
 
 /// `BunFrontendDevServerAgent` — stored inline in `Debugger`. The two
-/// high-tier types the Zig spec referenced (`DevServer.RouteBundle.Index` in
+/// high-tier types involved (`DevServer.RouteBundle.Index` in
 /// `notifyClientNavigated`, `DevServer.ConsoleLogKind` in `notifyConsoleLog`)
 /// are forward deps; both reduce to `i32` / `u8` at the C++ FFI boundary, so
 /// callers in `bun_runtime` resolve them before calling.
@@ -303,9 +302,11 @@ pub enum Mode {
 }
 
 pub struct Debugger {
-    // TODO(port): lifetime — never freed in Zig; likely borrowed from CLI args / env for process lifetime
+    // `'static` is genuine: set from `cli::cli_dupe` (process-lifetime CLI
+    // arena) — see jsc_hooks.rs. Never freed.
     pub path_or_port: Option<&'static [u8]>,
-    // TODO(port): lifetime — never freed in Zig; default ""
+    // `'static` is genuine: borrowed from process-lifetime env-var storage;
+    // default `""`.
     pub from_environment_variable: &'static [u8],
     pub script_execution_context_id: u32,
     pub next_debugger_id: u64,
@@ -318,8 +319,7 @@ pub struct Debugger {
     pub test_reporter_agent: TestReporterAgent,
     pub lifecycle_reporter_agent: LifecycleAgent,
     /// `UnsafeCell` because `DevServer::inspector()` hands out `&mut` to this
-    /// agent through a shared `&VirtualMachine` borrow (Zig spec: `*const
-    /// DevServer -> *BunFrontendDevServerAgent`, free aliasing). JS-thread
+    /// agent through a shared `&VirtualMachine` borrow. JS-thread
     /// only; callers must not hold overlapping `&mut` borrows.
     pub frontend_dev_server_agent: UnsafeCell<BunFrontendDevServerAgent>,
     pub http_server_agent: HTTPServerAgent,
@@ -346,8 +346,6 @@ impl Default for Debugger {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // SAFETY (safe fn): `JSGlobalObject` is an opaque `UnsafeCell`-backed handle
 // (`&` is ABI-identical to non-null `*mut`); `BunString` is a `#[repr(C)]` POD
 // out-param. Remaining args are by-value scalars.
@@ -371,9 +369,7 @@ impl Debugger {
     /// `start()` (debugger thread) signals, then run the wait-loop until a
     /// frontend connects (`Debugger__didConnect`) or the deadline elapses.
     ///
-    /// Spec `Debugger.zig:31` `waitForDebuggerIfNecessary`.
-    ///
-    /// PORT NOTE — aliasing: `this.debugger` is read through a raw pointer
+    /// Aliasing: `this.debugger` is read through a raw pointer
     /// with fresh short-lived borrows because `event_loop().tick()` /
     /// `auto_tick_active()` re-enter JS, which calls `VirtualMachine::get()`
     /// and may form independent `&mut VirtualMachine` borrows. Holding a
@@ -396,7 +392,7 @@ impl Debugger {
             return;
         }
         let (ctx_id, wait) = (dbg.script_execution_context_id, dbg.wait_for_connection);
-        // Spec: `defer debugger.must_block_until_connected = false;`
+        // Reset `must_block_until_connected` on every exit path.
         let _reset = scopeguard::guard((), |()| {
             if let Some(d) = this.debugger_mut() {
                 d.must_block_until_connected = false;
@@ -404,9 +400,8 @@ impl Debugger {
         });
 
         bun_core::scoped_log!(debugger, "spin");
-        // PORT NOTE: spec `var futex_atomic = .init(0)` and nothing ever
-        // stores `1` before this load, so this loop is a no-op on first call
-        // — ported faithfully.
+        // `FUTEX_ATOMIC` starts at 0 and nothing ever stores `1` before this
+        // load, so this loop is a no-op on first call.
         while FUTEX_ATOMIC.load(Ordering::Relaxed) > 0 {
             bun_threading::Futex::wait_forever(&FUTEX_ATOMIC, 1);
         }
@@ -433,23 +428,21 @@ impl Debugger {
             bun_core::Timespec::now(bun_core::TimespecMockMode::ForceRealTime)
                 .add_ms(WAIT_FOR_CONNECTION_DELAY_MS)
         } else {
-            // Spec: `else undefined` — never read on the `.forever` path.
+            // Placeholder — never read on the `.forever` path.
             bun_core::Timespec { sec: 0, nsec: 0 }
         };
 
         #[cfg(windows)]
         {
-            // Spec Debugger.zig:56-77: arm a one-shot libuv timer that unrefs
-            // `poll_ref` after the delay (Windows lacks a working
-            // `tickWithTimeout`). Per the original Zig comment ("TODO: remove
-            // this when tickWithTimeout actually works properly on Windows").
+            // Arm a one-shot libuv timer that unrefs `poll_ref` after the
+            // delay (Windows lacks a working `tickWithTimeout`). TODO: remove
+            // this when tickWithTimeout actually works properly on Windows.
             use bun_sys::windows::libuv as uv;
             use bun_sys::windows::libuv::UvHandle as _;
             if wait == Wait::Shortly {
                 let uv_loop = this.uv_loop();
                 // SAFETY: `uv_loop` is a live initialized `uv_loop_t`.
                 unsafe { uv::uv_update_time(uv_loop) };
-                // Spec: `bun.handleOom(allocator.create(Timer))` + zero-init.
                 let timer: *mut uv::Timer =
                     bun_core::heap::into_raw(Box::new(bun_core::ffi::zeroed()));
                 // SAFETY: `timer` freshly allocated; `uv_loop` valid.
@@ -457,8 +450,8 @@ impl Debugger {
 
                 extern "C" fn on_debugger_timer(handle: *mut uv::Timer) {
                     // SAFETY: `vm` is the per-thread singleton; called on the
-                    // JS thread (libuv timer callback). Spec `.?` would panic;
-                    // unwinding across `extern "C"` is UB so we early-return.
+                    // JS thread (libuv timer callback). Unwinding across
+                    // `extern "C"` is UB so we early-return if no debugger.
                     if let Some(d) = VirtualMachine::get().as_mut().debugger.as_deref_mut() {
                         d.poll_ref.unref(get_vm_ctx(AllocatorType::Js));
                     }
@@ -487,7 +480,7 @@ impl Debugger {
         }
 
         // Drop the long-lived `&mut Debugger` before re-entering JS — see
-        // PORT NOTE above. Each loop iteration re-fetches via `debugger_mut()`
+        // the aliasing note on this fn. Each loop iteration re-fetches via `debugger_mut()`
         // so re-entrant JS may independently borrow the VM.
         loop {
             let wait = match this.debugger.as_deref() {
@@ -553,8 +546,6 @@ impl Debugger {
     /// `Debugger.create(vm, global)` — first-time debugger setup: create the
     /// JSC inspector context, spawn the debugger VM thread, and arm the
     /// keep-alive on the parent loop.
-    ///
-    /// Spec `Debugger.zig:118` `create`.
     pub fn create(
         this: *mut VirtualMachine,
         global_object: &JSGlobalObject,
@@ -564,9 +555,9 @@ impl Debugger {
         if HAS_CREATED_DEBUGGER.swap(true, Ordering::Relaxed) {
             return Ok(());
         }
-        // Spec: `std.mem.doNotOptimizeAway(&Bun__*Agent*)` — Rust
         // `#[unsafe(no_mangle)]` already prevents the linker from stripping
-        // these exported symbols, so the keep-alive references are unnecessary.
+        // the exported `Bun__*Agent*` symbols, so no explicit keep-alive
+        // references are needed.
 
         // `this` is the live per-thread VM; same allocation as
         // `VirtualMachine::get()` — route through the safe thread-local
@@ -581,19 +572,19 @@ impl Debugger {
 
         if !this_ref.has_started_debugger {
             this_ref.as_mut().has_started_debugger = true;
-            // PORT NOTE: `std::thread::spawn` requires `Send`; raw `*mut
+            // `std::thread::spawn` requires `Send`; raw `*mut
             // VirtualMachine` is `!Send`. Wrap in a `Send` newtype — the
             // pointer is only ever dereferenced on the debugger thread under
             // `holdAPILock` (see `start_js_debugger_thread` doc), and the VM
             // outlives the process.
             struct SendVmPtr(*mut VirtualMachine);
-            // SAFETY: see PORT NOTE above — cross-thread access is mediated
+            // SAFETY: see comment above — cross-thread access is mediated
             // by `holdAPILock` / the futex; the VM allocation is `'static`.
             unsafe impl Send for SendVmPtr {}
             let send_vm = SendVmPtr(this);
-            // Spec `std.Thread.spawn(.{}, ...)` — Zig's default is 16 MiB.
-            // Rust's `std::thread` default (2 MiB) is too small to run a full
-            // `VirtualMachine::init` + JS module load on this thread.
+            // Rust's `std::thread` default stack (2 MiB) is too small to run
+            // a full `VirtualMachine::init` + JS module load on this thread,
+            // so use 16 MiB.
             std::thread::Builder::new()
                 .name("Debugger".to_string())
                 .stack_size(16 * 1024 * 1024)
@@ -602,7 +593,7 @@ impl Debugger {
                     Debugger::start_js_debugger_thread(send_vm.0);
                 })
                 .map_err(|_| bun_core::err!("ThreadSpawnFailed"))?;
-            // Spec: `thread.detach()` — Rust `JoinHandle` detaches on drop.
+            // The `JoinHandle` is dropped here, detaching the thread.
         }
         this_ref.event_loop_mut().ensure_waker();
 
@@ -618,25 +609,21 @@ impl Debugger {
     /// Debugger-thread entry: build a second `VirtualMachine`, hold the API
     /// lock, run `start()`.
     ///
-    /// Spec `Debugger.zig:143` `startJSDebuggerThread`.
-    ///
-    /// PORT NOTE: `other_vm` is the *parent thread's* VM. The parent thread
+    /// `other_vm` is the *parent thread's* VM. The parent thread
     /// continues executing (and mutating that VM) concurrently with this
-    /// thread (Debugger.zig:131→134-138, then the wait-loop at zig:79-114).
+    /// thread.
     /// Taking `&mut VirtualMachine` here would assert exclusive access we do
-    /// not have — UB. Spec uses a raw `*VirtualMachine`; we mirror that and
+    /// not have — UB. We hold a raw `*VirtualMachine` and
     /// never materialize a `&`/`&mut VirtualMachine` to the foreign-thread VM.
     pub fn start_js_debugger_thread(other_vm: *mut VirtualMachine) {
-        // PORT NOTE: Zig `MimallocArena` + thread-local `DotEnv.Loader` are
-        // dropped per docs/PORTING.md §Allocators — the global allocator is
-        // mimalloc and `InitOptions` no longer carries `allocator`/`env_loader`
-        // (those are wired by `RuntimeHooks::init_runtime_state`).
+        // The global allocator is mimalloc and `InitOptions` does not carry
+        // `allocator`/`env_loader` (those are wired by
+        // `RuntimeHooks::init_runtime_state`).
         bun_core::Output::Source::configure_named_thread(bun_core::zstr!("Debugger"));
         bun_core::scoped_log!(debugger, "startJSDebuggerThread");
         jsc::mark_binding();
 
         let vm_ptr = VirtualMachine::init(crate::virtual_machine::InitOptions {
-            // Spec: `args = std.mem.zeroes(TransformOptions)`, `store_fd = false`.
             is_main_thread: false,
             ..Default::default()
         })
@@ -651,9 +638,8 @@ impl Debugger {
         vm.is_main_thread = false;
         vm.event_loop_mut().ensure_waker();
 
-        // Spec: `vm.global.vm().holdAPILock(other_vm, OpaqueWrap(VM, start))`.
         extern "C" fn start_trampoline(ctx: *mut c_void) {
-            // PORT NOTE: forward the raw pointer unchanged — see fn doc above
+            // Forward the raw pointer unchanged — see fn doc above
             // for why we never form `&mut VirtualMachine` to the parent VM.
             Debugger::start(ctx.cast::<VirtualMachine>());
         }
@@ -663,11 +649,11 @@ impl Debugger {
             .hold_api_lock(other_vm.cast(), start_trampoline);
     }
 
-    /// Spec `Debugger.zig:182` `start` — runs inside `holdAPILock` on the
+    /// Runs inside `holdAPILock` on the
     /// debugger thread. Publishes the inspector URL(s), wakes the futex the
     /// parent VM is blocked on, then spins this thread's event loop forever.
     ///
-    /// PORT NOTE — aliasing: every `VirtualMachine` / `EventLoop` access here
+    /// Aliasing: every `VirtualMachine` / `EventLoop` access here
     /// goes through a raw pointer with a fresh short-lived `&mut *p` formed at
     /// the call site, never bound to a long-lived reference. Reasons:
     ///
@@ -681,15 +667,12 @@ impl Debugger {
     /// 3. `Bun__startJSDebuggerThread` and `tick()` re-enter JS, which calls
     ///    `VirtualMachine::get()` / `event_loop()` and mints fresh `&mut` to
     ///    the same allocations — holding our own across those calls is UB.
-    ///
-    /// Spec Debugger.zig:185-187 holds raw `*VirtualMachine` / `*EventLoop`
-    /// (no exclusivity), which is what we mirror.
     fn start(other_vm: *mut VirtualMachine) {
         jsc::mark_binding();
 
         // `this` is this thread's own VM (created in `start_js_debugger_thread`)
         // — safe to hold as `&'static`. `other_vm` remains a raw pointer (see
-        // PORT NOTE above): the parent thread mutates it concurrently after the
+        // aliasing note above): the parent thread mutates it concurrently after the
         // futex wake, so forming `&VirtualMachine` to it would be a data race.
         let this: &VirtualMachine = VirtualMachine::get();
         // SAFETY: `other_vm` is the parent-thread VM, live for process
@@ -701,10 +684,10 @@ impl Debugger {
         let other_loop: *mut crate::event_loop::EventLoop = unsafe { (*other_vm).event_loop() };
         let global: &JSGlobalObject = this.global();
 
-        // PORT NOTE: copy the four scalars we need from the parent VM's
-        // debugger before re-entering JS or waking the parent. Spec `.?` would
-        // safety-panic, but we run inside an `extern "C"` trampoline where
-        // unwinding is UB — wake the parent and bail instead (unreachable in
+        // Copy the four scalars we need from the parent VM's
+        // debugger before re-entering JS or waking the parent. We run inside
+        // an `extern "C"` trampoline where unwinding is UB — if `debugger` is
+        // missing, wake the parent and bail instead (unreachable in
         // practice; `create()` always populates `debugger` before spawning).
         // SAFETY: `other_vm` live; short-lived shared borrow of `debugger`
         // ends before any other access to `*other_vm`.
@@ -754,7 +737,7 @@ impl Debugger {
         // SAFETY: `other_loop` is the parent VM's event loop, live for process
         // lifetime; `wakeup()` takes `&self` and is thread-safe.
         unsafe { (*other_loop).wakeup() };
-        // Spec re-reads `this.eventLoop()` here (zig:219) rather than reusing
+        // Re-read `this.event_loop()` here rather than reusing
         // the cached `loop` — `vm.event_loop` may have flipped between
         // `regular_event_loop` and `macro_event_loop` inside the re-entrant JS
         // above. `event_loop_mut()` re-reads the slot on every call.
@@ -779,8 +762,8 @@ impl Debugger {
 pub fn did_connect() {
     let this = VirtualMachine::get().as_mut();
     // SAFETY: `VirtualMachine::get()` returns the per-thread singleton; called
-    // on the JS thread. Spec: `this.debugger.?` would safety-panic; we early-
-    // return defensively (extern "C" — unwinding is UB).
+    // on the JS thread. If the debugger is missing we early-return
+    // defensively (extern "C" — unwinding is UB).
     let Some(dbg) = this.debugger.as_deref_mut() else {
         return;
     };
@@ -836,8 +819,7 @@ impl AsyncTaskTracker {
     }
 
     /// RAII pair for `will_dispatch` / `did_dispatch`. Calls `will_dispatch`
-    /// now and `did_dispatch` when the returned guard is dropped — the Rust
-    /// spelling of Zig's `tracker.willDispatch(); defer tracker.didDispatch();`.
+    /// now and `did_dispatch` when the returned guard is dropped.
     #[must_use]
     pub fn dispatch(self, global_object: &JSGlobalObject) -> DispatchScope<'_> {
         self.will_dispatch(global_object);
@@ -870,8 +852,6 @@ pub enum AsyncCallType {
     Microtask = 5,
 }
 
-// TODO(port): move to jsc_sys
-//
 // SAFETY (safe fn): `JSGlobalObject` is an opaque `UnsafeCell`-backed handle
 // (`&` is ABI-identical to non-null `*const`); remaining args are by-value
 // scalars / `#[repr(u8)]` enums.
@@ -937,8 +917,6 @@ pub enum TestType {
 
 bun_opaque::opaque_ffi! { pub struct TestReporterHandle; }
 
-// TODO(port): move to jsc_sys
-//
 // SAFETY (safe fn): `TestReporterHandle` and `CallFrame` are `opaque_ffi!`
 // ZST handles (`!Freeze` via `UnsafeCell`); `BunString` is a `#[repr(C)]`
 // in/out-param the C++ side reads/consumes in-place. Remaining args are
@@ -1018,9 +996,8 @@ pub fn test_reporter_agent_enable(agent: *mut TestReporterHandle) {
         // Retroactively report any tests that were already discovered before
         // the debugger connected.
         //
-        // LAYERING: `retroactivelyReportDiscoveredTests` (spec
-        // Debugger.zig:351) reaches into `jsc.Jest.Jest.runner` /
-        // `bun_test.DescribeScope`, which live in `bun_runtime::test_runner`
+        // LAYERING: `retroactivelyReportDiscoveredTests` reaches into
+        // the test runner (`bun_test.DescribeScope`), which lives in `bun_runtime::test_runner`
         // — a forward-dep cycle. Dispatched through [`RuntimeHooks`].
         if let Some(hooks) = runtime_hooks() {
             // SAFETY: `handle` is the live C++ agent just stored above.
@@ -1044,8 +1021,7 @@ pub fn test_reporter_agent_disable(_agent: *mut TestReporterHandle) {
 impl TestReporterAgent {
     /// Safe `&mut TestReporterHandle` accessor — `handle` is a live C++
     /// `Inspector::TestReporterAgent*` once the agent is enabled. Caller must
-    /// ensure `is_enabled()` (handle != null); the debug-assert mirrors the
-    /// Zig `agent.handle.?` unwrap.
+    /// ensure `is_enabled()` (handle != null).
     #[inline]
     #[allow(clippy::mut_from_ref)]
     fn handle_mut(&self) -> &mut TestReporterHandle {
@@ -1099,8 +1075,6 @@ pub struct LifecycleAgent {
 
 bun_opaque::opaque_ffi! { pub struct LifecycleHandle; }
 
-// TODO(port): move to jsc_sys
-//
 // SAFETY (safe fn): `LifecycleHandle` is an `opaque_ffi!` ZST handle (`!Freeze`
 // via `UnsafeCell`); `ZigException` is a `#[repr(C)]` out-param the C++ side
 // reads/fills in-place.
@@ -1170,5 +1144,3 @@ impl LifecycleAgent {
         }
     }
 }
-
-// ported from: src/jsc/Debugger.zig
diff --git a/src/jsc/DecodedJSValue.rs b/src/jsc/DecodedJSValue.rs
index b104c45445a..7797513eb1e 100644
--- a/src/jsc/DecodedJSValue.rs
+++ b/src/jsc/DecodedJSValue.rs
@@ -67,5 +67,3 @@ const _: () = assert!(
     cfg!(target_endian = "little"),
     "EncodedValueDescriptor.as_bits assumes a little-endian system",
 );
-
-// ported from: src/jsc/DecodedJSValue.zig
diff --git a/src/jsc/DeferredError.rs b/src/jsc/DeferredError.rs
index 1d3c3fdc1e8..53a40fc6cd1 100644
--- a/src/jsc/DeferredError.rs
+++ b/src/jsc/DeferredError.rs
@@ -41,5 +41,3 @@ impl DeferredError {
         err
     }
 }
-
-// ported from: src/jsc/DeferredError.zig
diff --git a/src/jsc/DeprecatedStrong.rs b/src/jsc/DeprecatedStrong.rs
index 4ac598b194e..c9e28cf8ebc 100644
--- a/src/jsc/DeprecatedStrong.rs
+++ b/src/jsc/DeprecatedStrong.rs
@@ -5,20 +5,15 @@ use core::ptr::NonNull;
 
 use crate::JSValue;
 
-// PORT NOTE: This file is a Zig file-level struct. In Zig it is referenced as
-// `jsc.Strong.Deprecated` (see bottom-of-file alias `const Strong = jsc.Strong.Deprecated`).
-// Ported here as `DeprecatedStrong`.
-//
-// PORT NOTE: Zig `deinit` → `impl Drop`. The manual `ref()`/`unref()` path
-// overlaps teardown; to avoid Drop double-`unprotect`ing after a final `unref`,
-// `unref()` zeroes `raw` and clears `_safety` when it frees (debug builds), so
-// Drop becomes a no-op (`unprotect` on ZERO is a no-op; `_safety == None` skips
-// the canary free).
-// TODO(port): release builds have no ref_count, so a caller that does the final
-// `unref()` and then lets Drop fire would double-unprotect — audit call sites
-// (Zig contract: ref/unref pairs are balanced, deinit is the release).
-
-// Zig: `enable_safety = bun.Environment.ci_assert`.
+// Refcount contract (load-bearing): `ref()`/`unref()` calls must be balanced
+// in pairs; Drop is the release for the `init()` protect. In debug builds a
+// final `unref()` (ref_count 1 → 0) additionally frees the canary, zeroes
+// `raw`, and clears `_safety` so a subsequent Drop is a no-op. Release builds
+// have no ref_count, so an unref-used-as-release followed by Drop would
+// double-unprotect — callers must never use `unref()` as the release.
+// (Audited 2026-06: the only user is test_runner/Collection.rs, which uses
+// `init` + Drop and never calls `ref`/`unref`.)
+
 #[cfg(debug_assertions)]
 macro_rules! enable_safety {
     () => {
@@ -39,13 +34,12 @@ type Safety = ();
 
 #[cfg(debug_assertions)]
 struct SafetyData {
-    // PORT NOTE: raw pointer (not Box) — this is a heap canary for UAF detection;
+    // Raw pointer (not Box) — this is a heap canary for UAF detection;
     // owning it via Box would change the semantics (Drop would recurse / hide UAF).
     // Backing allocation is `Box<ManuallyDrop<DeprecatedStrong>>` (repr(transparent))
     // so freeing does NOT run DeprecatedStrong::drop on the sentinel value; the
     // pointer is stored cast to the inner type for ergonomic field access.
     ptr: NonNull<DeprecatedStrong>,
-    // PORT NOTE: `gpa: std.mem.Allocator` dropped — global mimalloc.
     ref_count: u32,
 }
 
@@ -55,7 +49,7 @@ const SAFETY_NONE: Safety = None;
 const SAFETY_NONE: Safety = ();
 
 pub struct DeprecatedStrong {
-    // PORT NOTE: bare JSValue field is intentional — this *is* the GC-root
+    // Bare JSValue field is intentional — this *is* the GC-root
     // wrapper (uses JSValueProtect/Unprotect), so the §JSC "never store bare
     // JSValue on the heap" rule does not apply here.
     raw: JSValue,
@@ -98,8 +92,7 @@ impl DeprecatedStrong {
 
     pub fn swap(&mut self, next: JSValue) -> JSValue {
         let prev = self.raw;
-        // PORT NOTE: `*self = ...` drops the old value in place (runs Drop),
-        // matching Zig's explicit `this.deinit(); this.* = .init(next);`.
+        // `*self = ...` drops the old value in place (runs Drop).
         *self = Self::init(next);
         prev
     }
@@ -133,7 +126,7 @@ impl DeprecatedStrong {
                             .cast::<ManuallyDrop<DeprecatedStrong>>(),
                     ));
                 }
-                // Neutralize so Drop is a no-op (see top-of-file PORT NOTE).
+                // Neutralize so Drop is a no-op (see top-of-file refcount contract).
                 self._safety = None;
                 self.raw = JSValue::ZERO;
                 return;
@@ -171,8 +164,8 @@ pub struct Optional {
 }
 
 impl Optional {
-    // PORT NOTE: Zig `pub const empty = .initNonCell(null)` — inlined as a struct
-    // literal so it can be `const` (init_non_cell debug_asserts, which is non-const).
+    // Inlined as a struct literal so it can be `const` (init_non_cell
+    // debug_asserts, which is non-const).
     pub const EMPTY: Optional = Optional {
         backing: DeprecatedStrong {
             raw: JSValue::ZERO,
@@ -192,7 +185,7 @@ impl Optional {
         }
     }
 
-    // PORT NOTE: Zig `deinit` dropped — `backing: DeprecatedStrong` is dropped
+    // No explicit teardown — `backing: DeprecatedStrong` is dropped
     // automatically (its Drop impl runs `unprotect` + canary free).
 
     pub fn get(&self) -> Option<JSValue> {
@@ -232,5 +225,3 @@ impl Optional {
 
 // suppress unused warning in release builds
 const _: bool = enable_safety!();
-
-// ported from: src/jsc/DeprecatedStrong.zig
diff --git a/src/jsc/ErrorCode.rs b/src/jsc/ErrorCode.rs
index 43f0c78ed2a..9ccb182425d 100644
--- a/src/jsc/ErrorCode.rs
+++ b/src/jsc/ErrorCode.rs
@@ -1,7 +1,6 @@
 //! Node-compat error codes — generated from `src/jsc/bindings/ErrorCode.ts`.
 //!
-//! Mirrors `build/*/codegen/ErrorCode.zig` (`pub const Error = enum(u16)`) and
-//! C++ `Bun::ErrorCode` in `ErrorCode+List.h`. Discriminants MUST stay
+//! Mirrors C++ `Bun::ErrorCode` in `ErrorCode+List.h`. Discriminants MUST stay
 //! index-aligned with the C++ `errors[]` table so `Bun__createErrorWithCode`
 //! picks the correct ctor / name / code triple.
 //!
@@ -45,10 +44,9 @@ impl GlobalObjectRef for crate::JSGlobalObject {
 
 type ErrorCodeInt = u16;
 
-/// `@import("ErrorCode").Error` — `enum(u16)` in Zig codegen, `Bun::ErrorCode`
-/// in C++. Modelled as a newtype-over-`u16` so the same type can also carry
-/// the legacy `anyerror`-derived sentinels (`PARSER_ERROR` / `JS_ERROR_OBJECT`)
-/// from `src/jsc/ErrorCode.zig` without an exhaustive-match obligation.
+/// `Bun::ErrorCode` in C++. Modelled as a newtype-over-`u16` so the same type
+/// can also carry the legacy sentinels (`PARSER_ERROR` / `JS_ERROR_OBJECT`)
+/// without an exhaustive-match obligation.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct ErrorCode(pub ErrorCodeInt);
@@ -688,7 +686,7 @@ impl ErrorCode {
 
 // ──────────────────────────────────────────────────────────────────────────
 // `ERR_`-prefixed aliases — some callers spell the full Node code string,
-// some use the Zig-style stripped name. Both resolve to the same discriminant.
+// some use the stripped name. Both resolve to the same discriminant.
 // ──────────────────────────────────────────────────────────────────────────
 impl ErrorCode {
     pub const ERR_ACCESS_DENIED: ErrorCode = ErrorCode::ACCESS_DENIED;
@@ -1040,9 +1038,8 @@ impl ErrorCode {
     pub const ERR_SECRETS_INTERACTION_REQUIRED: ErrorCode = ErrorCode::SECRETS_INTERACTION_REQUIRED;
 
     // NOTE: `ERR_SYSTEM_ERROR` / `ERR_CHILD_CLOSED_BEFORE_REPLY` intentionally
-    // do NOT live here. They belong to the unrelated Zig enum
-    // `jsc.Node.ErrorCode` (src/runtime/node/nodejs_error_code.zig →
-    // `bun_runtime::node::nodejs_error_code::ErrorCode`), not to the
+    // do NOT live here. They belong to the unrelated enum
+    // `bun_runtime::node::nodejs_error_code::ErrorCode`, not to the
     // ErrorCode.ts-derived table this type mirrors. Adding them here with
     // out-of-range discriminants (≥ Self::COUNT) is a memory-safety bug: the
     // C++ side does `errors[static_cast<size_t>(code)]` against a fixed
@@ -1371,7 +1368,7 @@ static CODE_STR: [&str; ErrorCode::COUNT as usize] = [
 ];
 
 // ──────────────────────────────────────────────────────────────────────────
-// Legacy anyerror-wrapper sentinels (src/jsc/ErrorCode.zig).
+// Legacy anyerror-wrapper sentinels.
 // ──────────────────────────────────────────────────────────────────────────
 impl ErrorCode {
     pub const PARSER_ERROR: ErrorCodeInt = 0xFFFE;
@@ -1379,13 +1376,11 @@ impl ErrorCode {
 
     #[inline]
     pub fn from(code: bun_core::Error) -> ErrorCode {
-        // Zig: @as(ErrorCode, @enumFromInt(@intFromError(code)))
         ErrorCode(code.as_u16() as ErrorCodeInt)
     }
 
     #[inline]
     pub fn to_error(self) -> bun_core::Error {
-        // Zig: @errorFromInt(@intFromEnum(self))
         bun_core::Error::from_errno(self.0 as i32)
     }
 }
@@ -1405,8 +1400,7 @@ impl ErrorCode {
             .unwrap_or("ERR_UNKNOWN")
     }
 
-    /// `Error.fmt(this, globalThis, fmt, args)` (codegen ErrorCode.zig) —
-    /// formats `args` into a `bun.String`, hands it to
+    /// Formats `args` into a `bun.String`, hands it to
     /// `Bun__createErrorWithCode`, and returns the constructed Error JSValue.
     /// The C++ side picks the ctor / `.name` / `.code` from `errors[self.0]`.
     pub fn fmt<G: GlobalObjectRef + ?Sized>(self, global: &G, args: Arguments<'_>) -> JSValue {
@@ -1414,7 +1408,7 @@ impl ErrorCode {
         // `G` is one of the two `#[repr(C)]` opaque ZST `JSGlobalObject`
         // handles (see `GlobalObjectRef` doc); `opaque_ref` is the safe
         // ZST-handle deref proof (panics on null). C++ clones the impl into a
-        // JSString; Zig wrapper does `defer message.deref()`, mirrored below.
+        // JSString; `message` is deref'd below after the call.
         let global = JSGlobalObject::opaque_ref(global.as_global_ptr().cast::<JSGlobalObject>());
         let v = Bun__createErrorWithCode(global, self, &mut message);
         message.deref();
@@ -1454,7 +1448,7 @@ unsafe extern "C" {
     ) -> JSValue;
 }
 
-/// Runtime equivalent of Zig's comptime `ErrorBuilder(code, fmt, Args)`.
+/// Pending error (code + format args).
 /// Returned from `JSGlobalObject::err(code, args)` so callers can choose
 /// `.throw()` / `.to_js()` / `.reject()` at the use site.
 pub struct ErrorBuilder<'a, G: GlobalObjectRef + ?Sized = JSGlobalObject> {
@@ -1496,18 +1490,14 @@ impl<'a, G: GlobalObjectRef + ?Sized> ErrorBuilder<'a, G> {
     }
 }
 
-// Zig: comptime { @export(&ErrorCode.ParserError, .{ .name = "Zig_ErrorCodeParserError" }); ... }
-//
-// Gated off: in Zig these are `@intFromEnum(ErrorCode.from(error.ParserError))`
-// — i.e. derived from the anyerror integer so that the value C++ compares
-// against (`extern "C" ZigErrorCode Zig_ErrorCodeParserError;`,
-// headers-handwritten.h) is exactly what `from()` produces. The Rust `from()`
-// above currently maps via `code.errno`, which never yields the hard-coded
-// 0xFFFE/0xFFFD placeholders, so exporting them would make C++ parser-error
-// detection silently never match. Until `bun_core::Error` gains the
-// NonZeroU16 anyerror interning (`err!("ParserError").as_u16()`) and these
-// constants can be derived from the same source as `from()`, keep the Zig-side
-// `@export` authoritative and do not let C++ link against bogus Rust statics.
+// C++ compares parser-error sentinels against these exported statics
+// (`extern "C" ZigErrorCode Zig_ErrorCodeParserError;`, headers-handwritten.h).
+// CAUTION: `from()` above currently maps via `code.errno`, which never yields
+// the hard-coded 0xFFFE/0xFFFD placeholder values, so a code produced by
+// `from()` will never compare equal to these constants. Until
+// `bun_core::Error` gains NonZeroU16 anyerror interning
+// (`err!("ParserError").as_u16()`) so these constants can be derived from the
+// same source as `from()`, that mismatch stands.
 
 #[unsafe(no_mangle)]
 pub(crate) static Zig_ErrorCodeParserError: ErrorCodeInt = ErrorCode::PARSER_ERROR;
diff --git a/src/jsc/Errorable.rs b/src/jsc/Errorable.rs
index a3c9cec63f9..fb37f37efba 100644
--- a/src/jsc/Errorable.rs
+++ b/src/jsc/Errorable.rs
@@ -51,5 +51,3 @@ impl<T: Copy> Errorable<T> {
         }
     }
 }
-
-// ported from: src/jsc/Errorable.zig
diff --git a/src/jsc/EventLoopHandle.rs b/src/jsc/EventLoopHandle.rs
index 77f4c0ead61..e0506a03d27 100644
--- a/src/jsc/EventLoopHandle.rs
+++ b/src/jsc/EventLoopHandle.rs
@@ -1,39 +1,16 @@
 //! `jsc.EventLoopHandle` — non-owning reference to either the JS event loop or
 //! the mini event loop.
 //!
-//! LAYERING: the Zig spec (`src/jsc/EventLoopHandle.zig`) lives
-//! under `jsc` and reaches freely into `jsc.EventLoop`, `jsc.VirtualMachine`,
-//! and `bun_runtime::webcore::Blob::Store`. In Rust that is a hard dep cycle:
-//! `bun_runtime → bun_jsc`, and many tier-≤4 crates (`bun_install`,
-//! `bun_spawn`, `bun_shell`) need `EventLoopHandle` without pulling in
-//! `bun_jsc`. The type was therefore MOVED DOWN to
+//! LAYERING: many tier-≤4 crates (`bun_install`, `bun_spawn`, `bun_shell`)
+//! need `EventLoopHandle` without pulling in `bun_jsc`, so the type lives in
 //! [`bun_event_loop::any_event_loop`] (`src/event_loop/AnyEventLoop.rs`),
-//! where the `.js` arm holds an erased `*mut ()` and dispatches through a
+//! where the `.js` arm holds an erased `*mut ()` and dispatches through
 //! link-time `extern "Rust"` shims defined in `bun_jsc::event_loop`.
 //!
 //! This module is the thin shim that keeps the `bun_jsc::event_loop_handle`
-//! path (and the `jsc.EventLoopHandle` namespace shape) compiling. All
-//! behaviour lives in the lower crate; nothing here owns logic.
-//!
-//! Spec mapping (EventLoopHandle.zig → bun_event_loop::any_event_loop):
-//!   `globalObject`                → `EventLoopHandle::global_object` (erased ptr)
-//!   `bunVM`                       → `EventLoopHandle::bun_vm` (erased ptr)
-//!   `stdout` / `stderr`           → `EventLoopHandle::{stdout,stderr}` (erased ptr)
-//!   `enter` / `exit`              → `EventLoopHandle::{enter,exit}` / `entered`
-//!   `init(anytype)`               → `EventLoopHandle::{init,init_mini,from_any,js_current}`
-//!   `filePolls` / `putFilePoll`   → `EventLoopHandle::{file_polls,put_file_poll}`
-//!   `enqueueTaskConcurrent`       → `EventLoopHandle::enqueue_task_concurrent`
-//!   `loop` / `platformEventLoop`  → `EventLoopHandle::{loop_,platform_event_loop}`
-//!   `pipeReadBuffer`              → `EventLoopHandle::pipe_read_buffer`
-//!   `ref` / `unref`               → `EventLoopHandle::{ref_,unref}`
-//!   `createNullDelimitedEnvMap`   → `EventLoopHandle::create_null_delimited_env_map`
-//!   `topLevelDir` / `env`         → `EventLoopHandle::{top_level_dir,env}`
-//!   `cast(tag)`                   → callers pattern-match on the enum directly
-//!   `allocator`                   → dropped per PORTING.md §Allocators (non-AST crate)
-//!   `EventLoopTask` / `EventLoopTaskPtr` → re-exported verbatim
+//! path compiling. All behaviour lives in the lower crate; nothing here owns
+//! logic.
 
 pub use bun_event_loop::any_event_loop::{
     EnteredEventLoop, EventLoopHandle, EventLoopTask, EventLoopTaskPtr,
 };
-
-// ported from: src/jsc/EventLoopHandle.zig
diff --git a/src/jsc/EventType.rs b/src/jsc/EventType.rs
index d1b13a33877..34b91d299ff 100644
--- a/src/jsc/EventType.rs
+++ b/src/jsc/EventType.rs
@@ -1,10 +1,10 @@
 use phf::phf_map;
 
-// PORT NOTE: Zig `enum(u8) { ..., _ }` is non-exhaustive — it can hold any u8
-// value, not just the named tags. A plain `#[repr(u8)] enum` cannot express
-// that (Rust enums are exhaustive; transmuting an unnamed discriminant is UB).
-// Modeled as a transparent u8 newtype with associated consts so the `else`
-// arm in `label()` remains reachable, matching Zig control flow.
+// This type can hold any u8 value, not just the named tags. A plain
+// `#[repr(u8)] enum` cannot express that (Rust enums are exhaustive;
+// transmuting an unnamed discriminant is UB). Modeled as a transparent u8
+// newtype with associated consts so the fallback arm in `label()` remains
+// reachable.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct EventType(pub u8);
@@ -37,5 +37,3 @@ impl EventType {
         }
     }
 }
-
-// ported from: src/jsc/EventType.zig
diff --git a/src/jsc/Exception.rs b/src/jsc/Exception.rs
index b351582f20e..4e690c11668 100644
--- a/src/jsc/Exception.rs
+++ b/src/jsc/Exception.rs
@@ -5,7 +5,6 @@ bun_opaque::opaque_ffi! {
     pub struct Exception;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn JSC__Exception__getStackTrace(
         this: &Exception,
@@ -24,5 +23,3 @@ impl Exception {
         JSC__Exception__asJSValue(self)
     }
 }
-
-// ported from: src/jsc/Exception.zig
diff --git a/src/jsc/FFI.rs b/src/jsc/FFI.rs
index 140c387dba5..583cc1b118b 100644
--- a/src/jsc/FFI.rs
+++ b/src/jsc/FFI.rs
@@ -1,12 +1,10 @@
-// This is zig translate-c run on ffi.h
+// Mechanical translation of ffi.h.
 // it turns out: FFI.h is faster than our implementation that calls into C++ bindings
 // so we just use this in some cases
 //
-// PORT NOTE: the original .zig is raw `zig translate-c` output. The meaningful
-// surface (EncodedJSValue + tag constants + inline coercion fns) is ported
-// below; the ~390 lines of compiler-builtin macro noise (`__clang__`,
-// `__INT_MAX__`, `__ARM_FEATURE_*`, …) emitted by translate-c are dropped —
-// they are never referenced.
+// The meaningful surface is EncodedJSValue + tag constants + inline coercion
+// fns; the compiler-builtin macro noise from ffi.h is dropped — it is never
+// referenced.
 
 #![allow(non_snake_case, non_upper_case_globals, clippy::missing_safety_doc)]
 
@@ -52,8 +50,6 @@ pub(crate) const TRUE_I64: i64 = ((2 | 4) | 1) as i64;
 pub(crate) static ValueTrue: bun_core::RacyCell<EncodedJSValue> =
     bun_core::RacyCell::new(EncodedJSValue { as_int64: TRUE_I64 });
 
-// TODO(port): move to jsc_sys
-//
 // By-value POD union arg; no invariants beyond ABI → `safe fn`.
 unsafe extern "C" {
     pub safe fn JSVALUE_TO_UINT64_SLOW(value: EncodedJSValue) -> u64;
@@ -65,20 +61,12 @@ pub fn uint64_to_jsvalue_slow(global_object: &JSGlobalObject, val: u64) -> JSVal
     JSValue::from_uint64_no_truncate(global_object, val)
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     pub fn JSFunctionCall(globalObject: *mut c_void, callFrame: *mut c_void) -> *mut c_void;
 }
 
-// PORT NOTE: ~390 lines of translate-c compiler-builtin macro definitions
-// (`__block`, `__INTMAX_C_SUFFIX__`, `__clang_major__`, `__SIZEOF_*`,
-// `__ARM_FEATURE_*`, `__APPLE__`, …) from FFI.zig:121-509 intentionally
-// dropped — they are clang predefined-macro spew with no callers.
-
 pub(crate) const DOUBLE_ENCODE_OFFSET_BIT: c_int = 49;
 pub(crate) const DOUBLE_ENCODE_OFFSET: c_longlong = (1 as c_longlong) << DOUBLE_ENCODE_OFFSET_BIT;
 pub(crate) const OTHER_TAG: c_int = 0x2;
 pub(crate) const NOT_CELL_MASK: c_ulonglong = NUMBER_TAG | OTHER_TAG as c_ulonglong;
 pub(crate) const NUMBER_TAG: c_ulonglong = 0xfffe_0000_0000_0000;
-
-// ported from: src/jsc/FFI.zig
diff --git a/src/jsc/FetchHeaders.rs b/src/jsc/FetchHeaders.rs
index cec2b5d26d6..774149329f9 100644
--- a/src/jsc/FetchHeaders.rs
+++ b/src/jsc/FetchHeaders.rs
@@ -6,14 +6,11 @@ use crate::{JSGlobalObject, JSValue, JsResult, VM, host_fn};
 use bun_core::{StringPointer, ZigString};
 use bun_uws::ResponseKind;
 
-// TODO(port): consider an RAII wrapper that calls `deref` on Drop instead of returning `NonNull<FetchHeaders>` from constructors.
 bun_opaque::opaque_ffi! {
     /// Opaque C++ `WebCore::FetchHeaders` handle (ref-counted on the C++ side; see `deref`).
     pub struct FetchHeaders;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `FetchHeaders`/`JSGlobalObject`/`VM` are opaque `UnsafeCell`-backed ZST
 // handles, so `&T` is ABI-identical to a non-null `*const T` and C++ mutating
 // header storage / VM state through them is interior mutation invisible to
@@ -213,8 +210,6 @@ impl FetchHeaders {
             .expect("WebCore__FetchHeaders__createEmpty returned null")
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig took `pico_headers: anytype` and read
-    // `pico_headers.list.ptr` / `.list.len`. In Rust, callers pass the slice directly.
     pub fn create_from_pico_headers<T>(pico_headers_list: &[T]) -> NonNull<FetchHeaders> {
         let out = PicoHeaders {
             ptr: pico_headers_list.as_ptr().cast::<c_void>(),
@@ -242,7 +237,6 @@ impl FetchHeaders {
         value: &[u8],
         global: &JSGlobalObject,
     ) -> JsResult<()> {
-        // TODO(port): bun.jsc.fromJSHostCallGeneric — wraps the FFI call and converts a pending VM exception into JsError
         host_fn::from_js_host_call_generic(global, || {
             let zs = ZigString::init(value);
             WebCore__FetchHeaders__put(self, name_, &zs, global)
@@ -257,7 +251,7 @@ impl FetchHeaders {
         let mut out = ZigString::EMPTY;
         self.get_(&ZigString::init(name_), &mut out, global);
         if out.len > 0 {
-            // PORT NOTE: returns the ZigString view (borrows C++-owned header
+            // Returns the ZigString view (borrows C++-owned header
             // storage); caller may `.slice()` it. Returning `&[u8]` directly
             // would borrow the local `out`, not the underlying buffer.
             return Some(out);
@@ -331,7 +325,6 @@ impl FetchHeaders {
         &mut self,
         global: &JSGlobalObject,
     ) -> JsResult<Option<NonNull<FetchHeaders>>> {
-        // TODO(port): bun.jsc.fromJSHostCallGeneric — wraps the FFI call and converts a pending VM exception into JsError
         host_fn::from_js_host_call_generic(global, || {
             NonNull::new(WebCore__FetchHeaders__cloneThis(self, global))
         })
@@ -352,5 +345,3 @@ impl FetchHeaders {
 // `WebCore__FetchHeaders__put` extern decl above and the `fast_*` methods take
 // it by value, so the re-export is ABI-transparent.
 pub use bun_http_types::Method::HeaderName as HTTPHeaderName;
-
-// ported from: src/jsc/FetchHeaders.zig
diff --git a/src/jsc/GarbageCollectionController.rs b/src/jsc/GarbageCollectionController.rs
index fc966ca2de0..c35111234f5 100644
--- a/src/jsc/GarbageCollectionController.rs
+++ b/src/jsc/GarbageCollectionController.rs
@@ -28,14 +28,15 @@ use crate::VM;
 use crate::virtual_machine::VirtualMachine;
 
 pub struct GarbageCollectionController {
-    // TODO(port): lifetime — FFI handle created by uws::Timer::create_fallthrough, freed in Drop.
-    // Stored as `Option<NonNull<Timer>>` (None = uninit; Some after `init`).
+    // Raw FFI handle created by `uws::Timer::create_fallthrough` in `init`,
+    // freed in Drop. Stored as `Option<NonNull<Timer>>` (None = uninit).
     pub gc_timer: Option<core::ptr::NonNull<uws::Timer>>,
     pub gc_last_heap_size: usize,
     pub gc_last_heap_size_on_repeating_timer: usize,
     pub heap_size_didnt_change_for_repeating_timer_ticks_count: u8,
     pub gc_timer_state: GCTimerState,
-    // TODO(port): lifetime — FFI handle created by uws::Timer::create_fallthrough, freed in Drop
+    // Raw FFI handle created by `uws::Timer::create_fallthrough` in `init`,
+    // freed in Drop.
     pub gc_repeating_timer: Option<core::ptr::NonNull<uws::Timer>>,
     pub gc_timer_interval: i32,
     pub gc_repeating_timer_fast: bool,
@@ -128,12 +129,10 @@ impl GarbageCollectionController {
             }
         }
 
-        // PORT NOTE: in the Zig spec `vm.transpiler` is fully constructed
-        // before `JSGlobalObject.create` → `ensureWaker` → this `init`. The
-        // Rust port defers `Transpiler::init` to the high-tier
-        // `init_runtime_state` hook (which runs *after* `ensure_waker`), so
-        // `vm.transpiler.env` is still the zeroed null ptr here on the main
-        // boot path. Fall back to defaults when null — these are debug/tuning
+        // `Transpiler::init` is deferred to the high-tier
+        // `init_runtime_state` hook (which runs *after* `ensure_waker` →
+        // this `init`), so `vm.transpiler.env` is still the zeroed null ptr
+        // here on the main boot path. Fall back to defaults when null — these are debug/tuning
         // knobs (BUN_GC_TIMER_INTERVAL / BUN_GC_TIMER_DISABLE /
         // BUN_GC_RUNS_UNTIL_SKIP_RELEASE_ACCESS) and the dot_env loader would
         // just be reading process env anyway.
@@ -186,7 +185,7 @@ impl GarbageCollectionController {
         VirtualMachine::get().as_mut()
     }
 
-    /// Explicit teardown (Zig `deinit`). Idempotent — `Drop` forwards here.
+    /// Explicit teardown. Idempotent — `Drop` forwards here.
     /// Kept as an inherent method because callers (web_worker, VM exit path)
     /// need to release the uws timers before the owning VM storage is freed.
     pub fn deinit(&mut self) {
@@ -213,7 +212,6 @@ impl GarbageCollectionController {
     //
     // When the heap size is increasing, we always switch to fast mode
     // When the heap size has been the same or less for 30 seconds, we switch to slow mode
-    // PERF(port): was comptime enum-literal monomorphization — profile if hot.
     pub fn update_gc_repeat_timer(&mut self, setting: GcRepeatSetting) {
         if setting == GcRepeatSetting::Fast && !self.gc_repeating_timer_fast {
             self.gc_repeating_timer_fast = true;
@@ -325,5 +323,3 @@ pub enum GCTimerState {
     Scheduled,
     RunOnNextTick,
 }
-
-// ported from: src/jsc/GarbageCollectionController.zig
diff --git a/src/jsc/GetterSetter.rs b/src/jsc/GetterSetter.rs
index b46e8e161a4..62294fc0814 100644
--- a/src/jsc/GetterSetter.rs
+++ b/src/jsc/GetterSetter.rs
@@ -10,10 +10,7 @@ impl GetterSetter {
     }
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn JSC__GetterSetter__isGetterNull(this: &GetterSetter) -> bool;
     safe fn JSC__GetterSetter__isSetterNull(this: &GetterSetter) -> bool;
 }
-
-// ported from: src/jsc/GetterSetter.zig
diff --git a/src/jsc/HTTPServerAgent.rs b/src/jsc/HTTPServerAgent.rs
index e396aa4fb9b..58739844520 100644
--- a/src/jsc/HTTPServerAgent.rs
+++ b/src/jsc/HTTPServerAgent.rs
@@ -40,14 +40,13 @@ impl HTTPServerAgent {
 
     // #region Events
     //
-    // PORT NOTE (phase-d): `notify_server_started` / `notify_server_stopped` /
+    // `notify_server_started` / `notify_server_stopped` /
     // `notify_server_routes_updated` reach into `bun_jsc::api::AnyServer` and
     // `ServerConfig::RouteDeclaration`, which live in `bun_runtime` (forward
     // dep). The C++ side only needs `Bun__HTTPServerAgent__setEnabled` for
     // linkage; the per-event notifiers are called from Rust → C++ (FFI decls
     // below) and are wired from `bun_runtime` once that tier un-gates. The
-    // event-body Zig ports are preserved in HTTPServerAgent.zig and will land
-    // when `AnyServer` is reachable.
+    // event bodies will land when `AnyServer` is reachable.
 
     // #endregion
 }
@@ -118,15 +117,13 @@ impl Drop for Route {
 
 // #endregion
 
-// #region C++ agent reference type for Zig
+// #region C++ agent reference type
 
 bun_opaque::opaque_ffi! {
     /// Opaque handle to the C++ `InspectorHTTPServerAgent`.
     pub struct InspectorHTTPServerAgent;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `safe fn`: `InspectorHTTPServerAgent` is an `opaque_ffi!` ZST handle
 // (`!Freeze` via `UnsafeCell`); `BunString` is `#[repr(C)]` and read-only
 // across the call. `&mut`/`&` are ABI-identical to non-null `*mut`/`*const`.
@@ -255,7 +252,7 @@ impl InspectorHTTPServerAgent {
 
 // #endregion
 
-// #region Zig -> C++
+// #region C++ entry points
 
 #[unsafe(no_mangle)]
 pub extern "C" fn Bun__HTTPServerAgent__setEnabled(agent: *mut InspectorHTTPServerAgent) {
@@ -274,5 +271,3 @@ pub type RequestId = i32;
 pub type RouteId = i32;
 pub type HotReloadId = i32;
 pub type HTTPMethod = bun_http::Method;
-
-// ported from: src/jsc/HTTPServerAgent.zig
diff --git a/src/jsc/JSArray.rs b/src/jsc/JSArray.rs
index fb7301461f2..982f379b132 100644
--- a/src/jsc/JSArray.rs
+++ b/src/jsc/JSArray.rs
@@ -5,7 +5,6 @@ bun_opaque::opaque_ffi! {
     pub struct JSArray;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     // TODO: this can throw
     fn JSArray__constructArray(
@@ -19,9 +18,8 @@ unsafe extern "C" {
 impl JSArray {
     #[track_caller]
     pub fn create(global: &JSGlobalObject, items: &[JSValue]) -> JsResult<JSValue> {
-        // PORT NOTE: `fromJSHostCall(global, @src(), fn, .{args})` is a comptime-reflection
-        // wrapper that calls `fn(args...)` then checks the VM for a pending exception.
-        // Modeled as a closure-taking helper here.
+        // `from_js_host_call` runs the closure, then checks the VM for a
+        // pending exception.
         crate::from_js_host_call(global, || unsafe {
             // SAFETY: items.ptr/len are a valid contiguous slice; global is a live &JSGlobalObject.
             JSArray__constructArray(global, items.as_ptr(), items.len())
@@ -37,5 +35,3 @@ impl JSArray {
         JSValue::from_cell(self).array_iterator(global)
     }
 }
-
-// ported from: src/jsc/JSArray.zig
diff --git a/src/jsc/JSArrayIterator.rs b/src/jsc/JSArrayIterator.rs
index ccda7691bbc..3c97628f88c 100644
--- a/src/jsc/JSArrayIterator.rs
+++ b/src/jsc/JSArrayIterator.rs
@@ -55,7 +55,6 @@ impl<'a> JSArrayIterator<'a> {
     }
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn Bun__JSArray__getContiguousVector(value: JSValue, out_len: &mut u32) -> *const JSValue;
     // safe: by-value `JSValue`/`u32`; `elements` is only pointer-compared against
@@ -67,5 +66,3 @@ unsafe extern "C" {
         len: u32,
     ) -> bool;
 }
-
-// ported from: src/jsc/JSArrayIterator.zig
diff --git a/src/jsc/JSBigInt.rs b/src/jsc/JSBigInt.rs
index ad293bc5e75..bc614d35ab0 100644
--- a/src/jsc/JSBigInt.rs
+++ b/src/jsc/JSBigInt.rs
@@ -8,7 +8,6 @@ bun_opaque::opaque_ffi! {
     pub struct JSBigInt;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     // safe: `JSValue` is a by-value tagged i64; returns a nullable GC-cell
     // pointer the caller checks before deref.
@@ -21,7 +20,6 @@ unsafe extern "C" {
 }
 
 /// Types that can be compared against a `JSBigInt` via the FFI order functions.
-/// Mirrors the `comptime T: type` switch in the Zig `order` fn.
 pub trait BigIntOrderable: Copy {
     fn raw_order(self, this: &JSBigInt) -> i8;
 }
@@ -55,7 +53,6 @@ impl JSBigInt {
         // (stack-scanned) for as long as the returned ref is used. `JSBigInt`
         // is an opaque ZST handle so the deref is the centralised `opaque_ref`
         // proof.
-        // TODO(port): lifetime — model as `&'a JSBigInt` tied to a stack guard?
         let p = JSC__JSBigInt__fromJS(value);
         (!p.is_null()).then(|| JSBigInt::opaque_ref(p))
     }
@@ -79,5 +76,3 @@ impl JSBigInt {
         crate::host_fn::from_js_host_call_generic(global, || JSC__JSBigInt__toString(self, global))
     }
 }
-
-// ported from: src/jsc/JSBigInt.zig
diff --git a/src/jsc/JSCScheduler.rs b/src/jsc/JSCScheduler.rs
index ffb0e1354c5..e17cd952365 100644
--- a/src/jsc/JSCScheduler.rs
+++ b/src/jsc/JSCScheduler.rs
@@ -28,8 +28,8 @@ impl JSCDeferredWorkTask {
         let global_this = VirtualMachine::get().global();
         crate::validation_scope!(scope, global_this);
         Bun__runDeferredWork(self);
-        // Zig: `try scope.assertNoExceptionExceptTermination()` — the only error variant
-        // that fn returns is termination, so map the wider `JsError` back down.
+        // The only error variant that fn returns is termination, so map the
+        // wider `JsError` back down.
         scope
             .assert_no_exception_except_termination()
             .map_err(|_| JsTerminated::JSTerminated)
@@ -60,8 +60,7 @@ pub(crate) extern "C" fn Bun__queueJSCDeferredWorkTaskConcurrently(
     crate::mark_binding!();
     // C++ passes a non-null live `VirtualMachine*`; ABI-compatible with `&T`.
     let loop_: &EventLoop = jsc_vm.event_loop_shared();
-    // Zig: `ConcurrentTask.new(.{ .task = Task.init(task), .next = .auto_delete })`
-    // — `create_from` is exactly that (heap-allocates with the auto-delete bit set).
+    // `create_from` heap-allocates with the auto-delete bit set.
     loop_.enqueue_task_concurrent(ConcurrentTask::create_from(task));
 }
 
@@ -78,7 +77,3 @@ pub(crate) unsafe extern "C" fn Bun__tickWhilePaused(paused: *mut bool) {
             .tick_while_paused(paused.cast_const());
     }
 }
-
-// Zig `comptime { _ = Bun__... }` force-reference block dropped — Rust links what's `pub`.
-
-// ported from: src/jsc/JSCScheduler.zig
diff --git a/src/jsc/JSCell.rs b/src/jsc/JSCell.rs
index 31347eb4070..db3f0d04111 100644
--- a/src/jsc/JSCell.rs
+++ b/src/jsc/JSCell.rs
@@ -1,6 +1,6 @@
 use crate::custom_getter_setter::CustomGetterSetter;
 use crate::getter_setter::GetterSetter;
-use crate::{JSGlobalObject, JSObject, JSValue};
+use crate::{JSGlobalObject, JSObject, JSType, JSValue};
 
 bun_opaque::opaque_ffi! {
     /// Opaque FFI handle for `JSC::JSCell`.
@@ -10,8 +10,9 @@ bun_opaque::opaque_ffi! {
 impl JSCell {
     /// Statically cast a cell to a JSObject. Returns null for non-objects.
     /// Use `to_object` to mutate non-objects into objects.
+    #[track_caller]
     pub fn get_object(&self) -> Option<&JSObject> {
-        // TODO(port): jsc.markMemberBinding(JSCell, @src()) — comptime binding marker, likely drop
+        crate::mark_member_binding("JSCell", core::panic::Location::caller());
         // `JSObject` is an `opaque_ffi!` ZST handle; `opaque_ref` is the
         // centralised non-null-ZST deref proof. Nullable per the C++ contract
         // (non-object cells return null).
@@ -26,18 +27,20 @@ impl JSCell {
     ///
     /// ## References
     /// - [ECMA-262 §7.1.18 ToObject](https://tc39.es/ecma262/#sec-toobject)
+    #[track_caller]
     pub fn to_object<'a>(&'a self, global: &'a JSGlobalObject) -> &'a JSObject {
-        // TODO(port): jsc.markMemberBinding(JSCell, @src()) — comptime binding marker, likely drop
+        crate::mark_member_binding("JSCell", core::panic::Location::caller());
         // `JSObject` is an `opaque_ffi!` ZST handle; `opaque_ref` is the
         // centralised non-null deref proof (ToObject on a cell never returns null).
         JSObject::opaque_ref(JSC__JSCell__toObject(self, global))
     }
 
-    pub fn get_type(&self) -> u8 {
-        // TODO(port): jsc.markMemberBinding(JSCell, @src()) — comptime binding marker, likely drop
-        // TODO(port): Zig wraps the extern result in @enumFromInt but the fn return type is `u8`;
-        // likely intended to return `JSType` — verify.
-        JSC__JSCell__getType(self)
+    #[track_caller]
+    pub fn get_type(&self) -> JSType {
+        crate::mark_member_binding("JSCell", core::panic::Location::caller());
+        // `JSType` is a `#[repr(transparent)]` newtype over `u8`, so any byte
+        // returned by the extern is a valid value (see the extern's NOTE).
+        JSType(JSC__JSCell__getType(self))
     }
 
     pub fn to_js(&self) -> JSValue {
@@ -45,7 +48,7 @@ impl JSCell {
     }
 
     pub fn get_getter_setter(&self) -> &GetterSetter {
-        // TODO(port): bun_jsc::JSValue::is_getter_setter (debug_assert dropped while JSValue.rs gated)
+        debug_assert!(self.get_type() == JSType::GetterSetter);
         // Caller-asserted invariant — this cell's JSType is GetterSetter.
         // `GetterSetter` is an `opaque_ffi!` ZST handle; `opaque_ref` is the
         // centralised non-null-ZST deref proof (`self` is non-null).
@@ -53,7 +56,7 @@ impl JSCell {
     }
 
     pub fn get_custom_getter_setter(&self) -> &CustomGetterSetter {
-        // TODO(port): bun_jsc::JSValue::is_custom_getter_setter (debug_assert dropped while JSValue.rs gated)
+        debug_assert!(self.get_type() == JSType::CustomGetterSetter);
         // Caller-asserted invariant — this cell's JSType is CustomGetterSetter.
         // `CustomGetterSetter` is an `opaque_ffi!` ZST handle; see `get_getter_setter`.
         CustomGetterSetter::opaque_ref(
@@ -66,8 +69,6 @@ impl JSCell {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSCell`/`JSGlobalObject` are opaque `UnsafeCell`-backed ZST handles, so
 // `&T` is ABI-identical to a non-null `*const T` and C++ mutating cell state
 // through it is interior mutation invisible to Rust.
@@ -81,8 +82,6 @@ unsafe extern "C" {
     safe fn JSC__JSCell__getType(this: &JSCell) -> u8;
 }
 
-// ported from: src/jsc/JSCell.zig
-
 // ════════════════════════════════════════════════════════════════════════════
 // JsCell<T> — single-JS-thread interior mutability
 // ════════════════════════════════════════════════════════════════════════════
@@ -97,9 +96,8 @@ unsafe extern "C" {
 /// Bun runs **one** `VirtualMachine` per JS thread. JavaScript is
 /// single-threaded and reentrant: a host function may call back into JS, which
 /// may call back into Rust, but always on the *same* OS thread. There is no
-/// true concurrent aliasing — only stacked, same-thread reentrancy. The Zig
-/// source models this with raw `*VirtualMachine` everywhere; `JsCell` is the
-/// Rust spelling of that contract.
+/// true concurrent aliasing — only stacked, same-thread reentrancy. `JsCell`
+/// is the Rust spelling of that contract.
 ///
 /// `get_mut()` is therefore *not* sound under arbitrary `Sync` semantics — the
 /// `unsafe impl Sync` below is a lie to the type system that we discharge by
diff --git a/src/jsc/JSErrorCode.rs b/src/jsc/JSErrorCode.rs
index caff048922e..cd24d740edf 100644
--- a/src/jsc/JSErrorCode.rs
+++ b/src/jsc/JSErrorCode.rs
@@ -1,8 +1,8 @@
 /// Represents JavaScript error types
 //
-// PORT NOTE: Zig source is `enum(u8) { ..., _ }` (non-exhaustive — any u8 is a
-// valid bit pattern). A Rust `#[repr(u8)] enum` would make non-listed values
-// UB, so this is ported as a transparent u8 newtype with associated consts.
+// Non-exhaustive on the C++ side — any u8 is a valid bit pattern. A Rust
+// `#[repr(u8)] enum` would make non-listed values UB, so this is a
+// transparent u8 newtype with associated consts.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct JSErrorCode(pub u8);
@@ -80,5 +80,3 @@ pub enum DOMExceptionCode {
     InvalidURLError,
     CryptoOperationFailedError,
 }
-
-// ported from: src/jsc/JSErrorCode.zig
diff --git a/src/jsc/JSFunction.rs b/src/jsc/JSFunction.rs
index d1ea2c0b41a..884c2a0c2a9 100644
--- a/src/jsc/JSFunction.rs
+++ b/src/jsc/JSFunction.rs
@@ -18,8 +18,8 @@ pub enum ImplementationVisibility {
 
 /// In WebKit: Intrinsic.h
 //
-// Zig: `enum(u8) { none, _ }` — non-exhaustive; any u8 is a valid bit pattern,
-// so a Rust `#[repr(u8)] enum` would be UB for unknown values. Use a newtype.
+// Non-exhaustive — any u8 is a valid bit pattern, so a Rust `#[repr(u8)]`
+// enum would be UB for unknown values. Use a newtype.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Intrinsic(u8);
@@ -41,8 +41,6 @@ pub struct CreateJSFunctionOptions {
     pub constructor: Option<JSHostFn>,
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle; the remaining
 // params are by-value scalars / `#[repr(C)]` PODs / fn-ptrs, so all three
 // shims are declared `safe fn`. `getSourceCode` writes a `ZigString` view into
@@ -97,5 +95,3 @@ impl JSFunction {
         }
     }
 }
-
-// ported from: src/jsc/JSFunction.zig
diff --git a/src/jsc/JSGlobalObject.rs b/src/jsc/JSGlobalObject.rs
index b508beadba0..a8772dff007 100644
--- a/src/jsc/JSGlobalObject.rs
+++ b/src/jsc/JSGlobalObject.rs
@@ -83,8 +83,7 @@ impl core::fmt::Debug for GlobalRef {
 
 impl JSGlobalObject {
     /// Alias of the macro-provided [`as_mut_ptr`](Self::as_mut_ptr) kept for
-    /// call-site readability where mutation is not the intent (Zig passes
-    /// `*JSGlobalObject` everywhere).
+    /// call-site readability where mutation is not the intent.
     #[inline(always)]
     pub fn as_ptr(&self) -> *mut JSGlobalObject {
         self.as_mut_ptr()
@@ -93,7 +92,7 @@ impl JSGlobalObject {
     pub fn throw_stack_overflow(&self) -> JsError {
         // Wrap the raw FFI throw in a validation scope (mirrors `VM::throw_error`).
         // The Rust `#[bun_jsc::host_fn]` thunk inserts an `ExceptionValidationScope`
-        // one frame above us that the Zig `toJSHostFn` does not; with that scope
+        // one frame above us; with that scope
         // present `~ThrowScope` inside `JSGlobalObject__throwStackOverflow` no
         // longer sees its previous scope as above `topEntryFrame`, so it
         // `simulateThrow()`s and leaves `m_needExceptionCheck` set. Observe the
@@ -224,8 +223,8 @@ impl JSGlobalObject {
 
     #[inline]
     pub fn to_js_value(&self) -> JSValue {
-        // JSValue is #[repr(transparent)] over the encoded pointer-width word; encoding a
-        // cell pointer is exactly Zig's `@enumFromInt(@intFromPtr(globalThis))`.
+        // JSValue is #[repr(transparent)] over the encoded pointer-width word; a
+        // cell pointer is encoded as its address.
         JSValue::from_encoded(std::ptr::from_ref::<Self>(self) as usize)
     }
 
@@ -253,7 +252,6 @@ impl JSGlobalObject {
 
     #[inline]
     pub fn throw_missing_arguments_value(&self, arg_names: &[&str]) -> JsError {
-        // PORT NOTE: Zig version is comptime over `arg_names.len` (0 => @compileError).
         match arg_names.len() {
             0 => unreachable!("requires at least one argument"),
             1 => self
@@ -291,8 +289,6 @@ impl JSGlobalObject {
         field: &'static str,
         typename: &'static str,
     ) -> JSValue {
-        // PORT NOTE: Zig used std.fmt.comptimePrint here; const_format::formatcp!
-        // requires the literals at the macro callsite, so we format at runtime.
         self.err(
             JscError::INVALID_ARG_TYPE,
             format_args!("Expected {} to be a {} for '{}'.", field, typename, name_),
@@ -301,8 +297,6 @@ impl JSGlobalObject {
     }
 
     pub fn to_js<T: Into<JSValue>>(&self, value: T) -> JsResult<JSValue> {
-        // PORT NOTE: Zig `JSValue.fromAny(this, @TypeOf(value), value)` reflects on the
-        // type. Rust callers go through `From<T> for JSValue` impls (i32, f64, bool, …).
         Ok(value.into())
     }
 
@@ -397,7 +391,7 @@ impl JSGlobalObject {
     /// Returns a +1-ref'd `BunString` describing `value`'s type for error messages.
     /// The result is wrapped in [`OwnedString`] so the ref is released on drop —
     /// `bun_core::String` is `Copy` and has no `Drop`, so a bare `BunString`
-    /// here would leak (Zig spec does `defer actual_string_value.deref()`).
+    /// here would leak.
     pub fn determine_specific_type(global: &Self, value: JSValue) -> JsResult<OwnedString> {
         // The C++ side opens a `DECLARE_THROW_SCOPE`; under
         // `BUN_JSC_validateExceptionChecks=1` its dtor sets `m_needExceptionCheck`, so we
@@ -436,7 +430,7 @@ impl JSGlobalObject {
                     buf.len(),
                 )
             };
-            // Slice up to the NUL terminator (matches Zig's `[:0]u8` slice semantics).
+            // Slice up to the NUL terminator.
             let msg = bun_core::slice_to_nul(&buf);
             return self
                 .err(
@@ -455,8 +449,7 @@ impl JSGlobalObject {
 
     /// "The {argname} argument must be of type {typename}. Received {value}"
     ///
-    /// Accepts `&str`, `&[u8]`, or `b"..."` for `argname`/`typename` — Zig call
-    /// sites pass `[]const u8` literals, so the Rust port takes `AsRef<[u8]>`.
+    /// Accepts `&str`, `&[u8]`, or `b"..."` for `argname`/`typename`.
     pub fn throw_invalid_argument_type_value(
         &self,
         argname: impl AsRef<[u8]>,
@@ -574,7 +567,7 @@ impl JSGlobalObject {
         typename: &[u8],
         value: JSValue,
     ) -> JsError {
-        // `defer ty_str.deinit()` → `ZigStringSlice` is RAII: `Owned` frees
+        // `ZigStringSlice` is RAII: `Owned` frees
         // its `Vec<u8>`, `WTF` derefs the backing `WTFStringImpl` in `Drop`.
         let ty_str = value.js_type_string(self).to_slice(self);
         self.err(
@@ -655,9 +648,8 @@ impl JSGlobalObject {
     }
 
     pub fn create_error_instance(&self, args: Arguments<'_>) -> JSValue {
-        // PORT NOTE: Zig branched at comptime on whether `args` is empty. With
-        // `core::fmt::Arguments`, `as_str()` returns `Some(&'static str)` when
-        // there are no interpolated args — equivalent fast path.
+        // `core::fmt::Arguments::as_str()` returns `Some(&'static str)` when
+        // there are no interpolated args — fast path for constant messages.
         if let Some(fmt) = args.as_str() {
             if strings::is_all_ascii(fmt.as_bytes()) {
                 return BunString::static_str(fmt).to_error_instance(self);
@@ -666,7 +658,6 @@ impl JSGlobalObject {
             }
         }
 
-        // PERF(port): was stack-fallback (4KB) + Allocating writer with 2KB initial capacity.
         let mut buf: Vec<u8> = Vec::with_capacity(2048);
         use core::fmt::Write;
         if write!(WriteVec(&mut buf), "{}", args).is_err() {
@@ -685,7 +676,6 @@ impl JSGlobalObject {
         if let Some(fmt) = args.as_str() {
             return ZigString::init(fmt.as_bytes()).to_type_error_instance(self);
         }
-        // PERF(port): was stack-fallback (4KB) + MutableString.init2048.
         let mut buf: Vec<u8> = Vec::with_capacity(2048);
         use core::fmt::Write;
         if write!(WriteVec(&mut buf), "{}", args).is_err() {
@@ -704,7 +694,6 @@ impl JSGlobalObject {
         if let Some(fmt) = args.as_str() {
             return Ok(ZigString::init(fmt.as_bytes()).to_dom_exception_instance(self, code));
         }
-        // PERF(port): was stack-fallback (4KB) + MutableString.init2048.
         let mut buf: Vec<u8> = Vec::with_capacity(2048);
         use core::fmt::Write;
         write!(WriteVec(&mut buf), "{}", args).map_err(|_| JsError::Thrown)?;
@@ -716,7 +705,6 @@ impl JSGlobalObject {
         if let Some(fmt) = args.as_str() {
             return ZigString::init(fmt.as_bytes()).to_syntax_error_instance(self);
         }
-        // PERF(port): was stack-fallback (4KB) + MutableString.init2048.
         let mut buf: Vec<u8> = Vec::with_capacity(2048);
         use core::fmt::Write;
         if write!(WriteVec(&mut buf), "{}", args).is_err() {
@@ -731,7 +719,6 @@ impl JSGlobalObject {
         if let Some(fmt) = args.as_str() {
             return ZigString::init(fmt.as_bytes()).to_range_error_instance(self);
         }
-        // PERF(port): was stack-fallback (4KB) + MutableString.init2048.
         let mut buf: Vec<u8> = Vec::with_capacity(2048);
         use core::fmt::Write;
         if write!(WriteVec(&mut buf), "{}", args).is_err() {
@@ -795,18 +782,15 @@ impl JSGlobalObject {
     }
 
     pub fn throw_pretty(&self, args: Arguments<'_>) -> JsError {
-        // PORT NOTE: Zig switched on `Output.enable_ansi_colors_stderr` and
-        // rewrote the *format string* at comptime (`Output.prettyFmt(fmt,
-        // enabled)`). Rust can't rewrite the format string of an
-        // already-captured `Arguments<'_>`, so render first, then run the
-        // `<tag>` → ANSI/strip pass at runtime via `pretty_fmt_rt`.
+        // The format string of an already-captured `Arguments<'_>` can't be
+        // rewritten, so render first, then run the `<tag>` → ANSI/strip pass
+        // at runtime via `pretty_fmt_rt`.
         //
-        // Zig routed through `createErrorInstance` which catches a mid-format
-        // `WriteFailed` (e.g. user `Symbol.toPrimitive` throws while
-        // stringifying the Received value). `pretty_fmt_rt` would `format!`
-        // into a `String`, and `format!` panics if a `Display` impl returns
-        // `fmt::Error` when the underlying writer didn't — so render via
-        // fallible `write!` here and mirror Zig's catch: clear the pending JS
+        // Formatting can fail mid-write (e.g. user `Symbol.toPrimitive` throws
+        // while stringifying the Received value). `pretty_fmt_rt` would
+        // `format!` into a `String`, and `format!` panics if a `Display` impl
+        // returns `fmt::Error` when the underlying writer didn't — so render
+        // via fallible `write!` here: on failure, clear the pending JS
         // exception and throw with whatever was written so far.
         let enabled = Output::enable_ansi_colors_stderr();
         use core::fmt::Write;
@@ -829,10 +813,8 @@ impl JSGlobalObject {
         self.throw_value(instance)
     }
 
-    /// Queue a native callback as a microtask. The Zig version monomorphises a
-    /// `callconv(.c)` trampoline at comptime over `Function`; in Rust callers
-    /// supply the C-ABI trampoline directly so the wrapper need only erase the
-    /// context pointer type.
+    /// Queue a native callback as a microtask. Callers supply the C-ABI
+    /// trampoline directly; the wrapper only erases the context pointer type.
     pub fn queue_microtask_callback<C>(
         &self,
         ctx_val: *mut C,
@@ -899,7 +881,6 @@ impl JSGlobalObject {
         // - We're incorrectly returning JSError from a function that did not throw.
         debug_assert!(err != bun_core::err!("JSError"));
 
-        // PERF(port): was stack-fallback (128 bytes).
         let mut buffer: Vec<u8> = Vec::new();
         use core::fmt::Write;
         if write!(WriteVec(&mut buffer), "{} {}", err.name(), fmt).is_err() {
@@ -960,8 +941,8 @@ impl JSGlobalObject {
     /// (`JSGlobalObject__hasException`) constructs a temporary `TopExceptionScope`, whose
     /// ctor *does* call `verifyExceptionCheckNeedIsSatisfied` — so this asserts if
     /// `vm.m_needExceptionCheck` was left set by a prior un-scoped FFI call. The remaining
-    /// call sites in the port (1:1 with the `.zig` spec) follow `JsResult`-returning helpers
-    /// that already opened a scope and cleared the bit, so they are sound. New code must not
+    /// call sites follow `JsResult`-returning helpers that already opened a scope and
+    /// cleared the bit, so they are sound. New code must not
     /// pair this with a raw `extern "C"` throwing call — use the generated
     /// [`crate::cpp`] wrappers or [`top_scope!`](crate::top_scope) instead.
     pub fn has_exception(&self) -> bool {
@@ -1077,13 +1058,12 @@ impl JSGlobalObject {
     /// Raw-pointer variant of [`Self::bun_vm`]. Returns the per-thread
     /// `*mut VirtualMachine` so callers that need to mutate VM fields don't
     /// launder provenance through `&VirtualMachine -> *mut` (UB under Stacked
-    /// Borrows). Spec `JSGlobalObject.zig:617` returns `*VirtualMachine`
-    /// (mutable); this preserves that intent.
+    /// Borrows).
     ///
     /// Reads the thread-local directly (one `mov fs:[OFF]`) instead of calling
     /// `JSC__JSGlobalObject__bunVM`: cross-language LTO does not inline that
     /// C++ shim into Rust callers (905 out-of-line `callq` sites in the
-    /// release binary vs the symbol not even existing in the Zig build), and
+    /// release binary), and
     /// the FFI result is provably the same singleton — debug-asserted below
     /// and in [`Self::bun_vm`]. Same-thread callers only; cross-thread paths
     /// must use [`Self::bun_vm_concurrently`].
@@ -1237,11 +1217,6 @@ impl JSGlobalObject {
         .throw()
     }
 
-    // PORT NOTE: Zig's `validateBigIntRange` / `validateIntegerRange` / `getInteger`
-    // take `comptime T: type` plus a `comptime range: IntegerRange` with
-    // `comptime_int` bounds and use @typeInfo for signedness, comptime @max/@min
-    // clamping, and @compileError on bad ranges. Ported as plain generics over
-    // `T: bun_core::Integer`; the comptime bounds checks become `debug_assert!`.
     pub fn validate_big_int_range<T: bun_core::Integer>(
         &self,
         value: JSValue,
@@ -1306,17 +1281,15 @@ impl JSGlobalObject {
         let min_t: i128 = range.min.max(T::MIN_I128).max(i128::from(MIN_SAFE_INTEGER));
         let max_t: i128 = range.max.min(T::MAX_I128).min(i128::from(MAX_SAFE_INTEGER));
 
-        // PORT NOTE: comptime { if (min_t > max_t) @compileError(...) } — became debug_assert.
-        debug_assert!(min_t <= max_t, "max must be less than min");
+        debug_assert!(min_t <= max_t, "min must be less than or equal to max");
 
         let field_name = range.field_name;
-        // PORT NOTE: comptime field_name.len == 0 → @compileError.
         debug_assert!(!field_name.is_empty(), "field_name must not be empty");
         let always_allow_zero = range.always_allow_zero;
-        // Zig passes the *unclamped* `range.min`/`range.max` to `throwRangeError`
-        // (not `min_t`/`max_t`). Zig's `comptime` guaranteed these fit in the
-        // formatter's `i64` range; preserve that as a checked narrowing so an
-        // out-of-range bound surfaces as a panic rather than silent wrap.
+        // Pass the *unclamped* `range.min`/`range.max` to the range error
+        // (not `min_t`/`max_t`). The bounds must fit in the formatter's `i64`
+        // range; enforce that as a checked narrowing so an out-of-range bound
+        // surfaces as a panic rather than silent wrap.
         let min = i64::try_from(range.min)
             .expect("validate_integer_range: range.min exceeds i64 (Zig comptime invariant)");
         let max = i64::try_from(range.max)
@@ -1378,9 +1351,9 @@ impl JSGlobalObject {
         default: T,
         range: IntegerRange,
     ) -> Option<T> {
-        // `JSValue::get` already returns `JsResult` (scoped internally), so the
-        // post-hoc `has_exception()` the Zig spec carried is dead here — `Err(_)`
-        // covers the throw path and `Ok(None)` is by definition exception-free.
+        // `JSValue::get` already returns `JsResult` (scoped internally), so no
+        // post-hoc `has_exception()` is needed — `Err(_)` covers the throw
+        // path and `Ok(None)` is by definition exception-free.
         match obj.get(self, range.field_name) {
             Ok(Some(val)) => self.validate_integer_range::<T>(val, default, range).ok(),
             Ok(None) => Some(default),
@@ -1401,8 +1374,6 @@ impl JSGlobalObject {
     ///
     /// The set of errors accepted by `err()` is defined in `ErrorCode.ts`.
     pub fn err<'a>(&'a self, code: JscError, args: Arguments<'a>) -> ErrorBuilder<'a, Self> {
-        // PORT NOTE: Zig `ERR` returns a comptime-monomorphized `ErrorBuilder(code, fmt, @TypeOf(args))`.
-        // The Rust ErrorBuilder carries the code + Arguments at runtime.
         ErrorBuilder {
             global: self,
             code,
@@ -1473,7 +1444,6 @@ impl JSGlobalObject {
             }
             return zig_str.to_error_instance(self);
         }
-        // PERF(port): was stack-fallback (256 bytes).
         let mut buf: Vec<u8> = Vec::new();
         use core::fmt::Write;
         write!(WriteVec(&mut buf), "{}", args).expect("unreachable");
@@ -1509,15 +1479,14 @@ impl JSGlobalObject {
 // see one nominal type (the previous local duplicate diverged from lib.rs).
 pub use crate::GregorianDateTime;
 
-/// Spec `JSGlobalObject.BunPluginTarget` (JSGlobalObject.zig:265). The enum is
-/// defined once in `bun_bundler::transpiler` (the lowest tier that names it,
+/// The enum is defined once in `bun_bundler::transpiler` (the lowest tier that names it,
 /// for `Linker::link`'s call into `PluginResolver::on_resolve`) and re-exported
 /// here so the C++ FFI signature and all `bun_jsc` callers share one nominal
 /// type — no mirror enum, no transmute.
 pub use bun_bundler::transpiler::BunPluginTarget;
 
-// PORT NOTE: no `Default` derive — Zig's `code: jsc.Node.ErrorCode` has NO default
-// (only `errno`/`name` default to null). Callers must always supply `code`.
+// No `Default` derive — `code` has no default (only `errno`/`name` are
+// optional). Callers must always supply `code`.
 pub struct SysErrOptions {
     pub code: NodeErrorCode,
     pub errno: Option<i32>,
@@ -1561,7 +1530,7 @@ impl From<ScriptExecutionContextIdentifier> for u32 {
 use bun_core::fmt::VecWriter as WriteVec;
 
 // ──────────────────────────────────────────────────────────────────────────────
-// Exported (callconv(.c)) functions — Zig used `comptime { @export(...) }`.
+// Exported `extern "C"` functions.
 // ──────────────────────────────────────────────────────────────────────────────
 
 #[unsafe(no_mangle)]
@@ -1574,8 +1543,8 @@ pub(crate) unsafe extern "C" fn Zig__GlobalObject__resolve(
 ) {
     crate::mark_binding();
     // SAFETY: C++ passes valid non-null pointers. `BunString` is `Copy`, so
-    // `*specifier` / `*source` is the bitwise load Zig spells as `specifier.*`
-    // — no refcount bump (the caller still owns the ref).
+    // `*specifier` / `*source` is a bitwise load — no refcount bump (the
+    // caller still owns the ref).
     let (global, specifier, source) = unsafe { (&*global, *specifier, *source) };
     // SAFETY: C++ passes valid non-null pointers.
     let (res, query) = unsafe { (&mut *res, &mut *query) };
@@ -1597,7 +1566,7 @@ pub(crate) unsafe extern "C" fn Zig__GlobalObject__reportUncaughtException(
     unsafe { VirtualMachine::report_uncaught_exception(&*global, &*exception) }
 }
 
-// Safe wrapper used internally (matches Zig's pub fn).
+// Safe wrapper used internally.
 #[inline]
 pub(crate) fn report_uncaught_exception(global: &JSGlobalObject, exception: &Exception) -> JSValue {
     crate::mark_binding();
@@ -1611,7 +1580,7 @@ pub(crate) extern "C" fn Zig__GlobalObject__onCrash() {
     panic!("A C++ exception occurred");
 }
 
-// PORT NOTE (LAYERING): `getBodyStreamOrBytesForWasmStreaming` deals entirely
+// LAYERING: `getBodyStreamOrBytesForWasmStreaming` deals entirely
 // in `webcore` types (`Response`, `Body.Value`, `Blob`, `ReadableStream`)
 // which live in `bun_runtime`. The exported `extern "C"` symbol
 // `Zig__GlobalObject__getBodyStreamOrBytesForWasmStreaming` is therefore
@@ -1762,8 +1731,6 @@ unsafe extern "C" {
     safe fn ScriptExecutionContextIdentifier__forGlobalObject(global: &JSGlobalObject) -> u32;
 }
 
-// ported from: src/jsc/JSGlobalObject.zig
-
 impl ScriptExecutionContextIdentifier {
     /// Returns `None` if the context referred to by `self` no longer exists.
     pub fn global_object(self) -> Option<GlobalRef> {
diff --git a/src/jsc/JSInternalPromise.rs b/src/jsc/JSInternalPromise.rs
index 12888a6dbda..c33ef38fe7f 100644
--- a/src/jsc/JSInternalPromise.rs
+++ b/src/jsc/JSInternalPromise.rs
@@ -2,5 +2,3 @@
 // loader uses regular JSPromise everywhere. Keep this as a transparent alias so
 // existing Rust callers continue to compile.
 pub use crate::JSPromise as JSInternalPromise;
-
-// ported from: src/jsc/JSInternalPromise.zig
diff --git a/src/jsc/JSMap.rs b/src/jsc/JSMap.rs
index 0f20a4314d9..522756df9f0 100644
--- a/src/jsc/JSMap.rs
+++ b/src/jsc/JSMap.rs
@@ -62,12 +62,10 @@ impl JSMap {
     ///
     /// Returns `None` if the value is not a Map.
     ///
-    /// Returns a raw `NonNull<JSMap>` (mirrors Zig's `?*JSMap`). The pointee is a
+    /// Returns a raw `NonNull<JSMap>`. The pointee is a
     /// GC-heap cell; callers must dereference unsafely at use-site and ensure the
     /// underlying `JSValue` is kept alive across GC.
     pub fn from_js(value: JSValue) -> Option<NonNull<JSMap>> {
-        // PORT NOTE: Zig used `jsTypeLoose() == .JSMap`; the Rust stub surface
-        // exposes `is_cell()` + `js_type()` (which together are equivalent).
         if value.is_cell() && value.js_type() == crate::JSType::Map {
             // SAFETY: value is a Map cell; its encoded pointer is a valid,
             // non-null *JSMap on the GC heap.
@@ -76,5 +74,3 @@ impl JSMap {
         None
     }
 }
-
-// ported from: src/jsc/JSMap.zig
diff --git a/src/jsc/JSModuleLoader.rs b/src/jsc/JSModuleLoader.rs
index 3567edfaa9f..bcae05e3b89 100644
--- a/src/jsc/JSModuleLoader.rs
+++ b/src/jsc/JSModuleLoader.rs
@@ -6,8 +6,6 @@ bun_opaque::opaque_ffi! {
     pub struct JSModuleLoader;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque ZST handle on the Rust side; Rust never reads or
 // writes bytes through it. C++ mutates VM state internally, but that is outside
 // Rust's aliasing model, so these externs take `*const JSGlobalObject` (matching
@@ -128,5 +126,3 @@ impl JSModuleLoader {
         .ok_or(JsError::Thrown)
     }
 }
-
-// ported from: src/jsc/JSModuleLoader.zig
diff --git a/src/jsc/JSONLineBuffer.rs b/src/jsc/JSONLineBuffer.rs
index a73d1b64e29..3d6c3a36c30 100644
--- a/src/jsc/JSONLineBuffer.rs
+++ b/src/jsc/JSONLineBuffer.rs
@@ -139,5 +139,3 @@ impl JSONLineBuffer {
 }
 
 // `pub fn deinit` dropped: Vec<u8>'s Drop frees the backing allocation (global mimalloc).
-
-// ported from: src/jsc/JSONLineBuffer.zig
diff --git a/src/jsc/JSObject.rs b/src/jsc/JSObject.rs
index 964d48ee15b..041906c343e 100644
--- a/src/jsc/JSObject.rs
+++ b/src/jsc/JSObject.rs
@@ -4,7 +4,6 @@ use core::mem::ManuallyDrop;
 use crate::{JSCell, JSGlobalObject, JSValue, JsError, JsResult};
 use bun_core::{String as BunString, ZigString};
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     // safe: read-only `const unsigned` exported by C++ (link-time constant).
     safe static JSC__JSObject__maxInlineCapacity: c_uint;
@@ -92,9 +91,8 @@ impl JSObject {
         pojo: &T,
         global: &JSGlobalObject,
     ) -> JsResult<&'static mut JSObject> {
-        // TODO(port): Zig used `@typeInfo(T).@"struct"` to enumerate fields at
-        // comptime. Rust has no field reflection; `PojoFields` is expected to be
-        // provided by a `#[derive(PojoFields)]` proc-macro that emits an inline
+        // Rust has no field reflection; `PojoFields` impls are hand-written
+        // (see trait docs) and emit an inline
         // `put(b"name", JSValue::from_any(global, &self.name)?)?;` per field.
 
         let val = if NULL_PROTOTYPE {
@@ -111,9 +109,9 @@ impl JSObject {
         let obj = JSObject::opaque_mut(val.0 as *mut JSObject);
 
         let cell = obj.to_js();
-        // PORT NOTE: Zig used `inline for` — each `fromAny` result is `put()` immediately
-        // before the next field is encoded. The callback shape preserves that ordering and
-        // keeps every intermediate JSValue on the stack (never collected into a Vec).
+        // Each `fromAny` result is `put()` immediately before the next field
+        // is encoded. The callback shape preserves that ordering and keeps
+        // every intermediate JSValue on the stack (never collected into a Vec).
         pojo.put_fields(global, |name, value| {
             cell.put(global, name, value);
             Ok(())
@@ -147,11 +145,10 @@ impl JSObject {
         global: &JSGlobalObject,
         properties: &T,
     ) -> JsResult<()> {
-        // TODO(port): Zig used `std.meta.fieldNames(@TypeOf(properties))` +
-        // `@field(properties, field)`. Relies on the `JSValueFields` derive.
-        // PORT NOTE: Zig's `put` signature forces each field to already be a JSValue —
-        // there is NO `fromAny` encoding here (unlike `create`). Hence a separate trait
-        // from `PojoFields` that yields raw JSValues without conversion.
+        // Types hand-implement `JSValueFields`. Each field must already be a
+        // JSValue — there is NO `fromAny` encoding here (unlike `create`).
+        // Hence a separate trait from `PojoFields` that yields raw JSValues
+        // without conversion.
         properties.put_fields(|name, value| self.put(global, name, value))
     }
 
@@ -175,7 +172,7 @@ impl JSObject {
     ) -> JSValue {
         crate::mark_binding!();
         debug_assert!(owner.is_cell());
-        // JSObject.zig:118 — passes `owner.asCell()`. A cell-tagged JSValue's
+        // A cell-tagged JSValue's
         // payload IS the JSCell* (NotCellMask bits are zero), so the raw usize
         // is the pointer. SAFETY: caller guarantees `owner.is_cell()`.
         let owner_cell = owner.0 as *mut JSCell;
@@ -221,7 +218,6 @@ impl JSObject {
         key: &mut ZigString,
         values: &mut [ZigString],
     ) -> JsResult<()> {
-        // Zig calls `bun.cpp.JSC__JSObject__putRecord` (`[[ZIG_EXPORT(check_slow)]]`).
         // SAFETY: pointers are valid for the duration of the call; C++ does not
         // retain them.
         unsafe {
@@ -287,9 +283,8 @@ impl Drop for ExternColumnIdentifier {
 pub(crate) type InitializeCallback =
     extern "C" fn(ctx: *mut c_void, obj: *mut JSObject, global: &JSGlobalObject);
 
-/// Zig's `Initializer(comptime Ctx, comptime func)` returned a type with a
-/// single `extern "C" fn call`. In Rust the contract is a trait: implement
-/// `create` on your context type and pass it to `JSObject::create_with_initializer`.
+/// Object-initializer contract: implement `create` on your context type and
+/// pass it to `JSObject::create_with_initializer`.
 pub trait ObjectInitializer {
     fn create(&mut self, obj: &mut JSObject, global: &JSGlobalObject) -> JsResult<()>;
 }
@@ -304,7 +299,7 @@ extern "C" fn initializer_call<Ctx: ObjectInitializer>(
     // taken by reference at the C ABI (`&T` ≡ non-null `*const T`).
     let result = unsafe { Ctx::create(&mut *this.cast::<Ctx>(), &mut *obj, global) };
     if let Err(err) = result {
-        // Mirrors `host_fn::void_from_js_error` (host_fn.zig) — OOM throws,
+        // Mirrors `host_fn::void_from_js_error` — OOM throws,
         // anything else asserts an exception is already pending.
         match err {
             JsError::OutOfMemory => {
@@ -322,18 +317,15 @@ extern "C" fn initializer_call<Ctx: ObjectInitializer>(
 
 /// Compile-time field enumeration for POJO marshalling.
 ///
-/// Zig used `@typeInfo(T)` to iterate struct fields and called
-/// `JSValue.fromAny(global, @TypeOf(property), property)` per field.
-/// Rust has no built-in reflection, so types opt in via
-/// `#[derive(bun_jsc::PojoFields)]`.
+/// Rust has no built-in reflection, so types opt in by hand-implementing
+/// this trait (no derive macro exists today).
 ///
-/// The derive must emit a sequence of
+/// Implementations must emit a sequence of
 /// `put(b"name", JSValue::from_any(global, &self.name)?)?;` calls — one per
 /// field, in declaration order — so each encoded JSValue lives only on the
-/// stack between `from_any` and `put` (matching Zig's `inline for`; never
+/// stack between `from_any` and `put` (never
 /// collected into a `Vec<JSValue>`, which would sit on the Rust heap and be
 /// invisible to JSC's conservative stack scan).
-// TODO(port): proc-macro — implement `#[derive(PojoFields)]` in bun_jsc.
 pub trait PojoFields {
     const FIELD_COUNT: usize;
     /// Invoke `put(field_name, encoded_value)` once per struct field, encoding
@@ -347,15 +339,12 @@ pub trait PojoFields {
 }
 
 /// Compile-time field enumeration for structs whose fields are **already**
-/// `JSValue` (Zig's `putAllFromStruct` — `@field(properties, field)` is passed
+/// `JSValue` (each field is passed
 /// straight to `put()` with no `fromAny` encoding).
 ///
 /// Separate from [`PojoFields`] because that trait encodes; this one does not.
-// TODO(port): proc-macro — implement `#[derive(JSValueFields)]` in bun_jsc.
 pub trait JSValueFields {
     /// Invoke `put(field_name, self.<field>)` once per struct field. Fields are
     /// `JSValue` and forwarded as-is.
     fn put_fields(&self, put: impl FnMut(&'static [u8], JSValue) -> JsResult<()>) -> JsResult<()>;
 }
-
-// ported from: src/jsc/JSObject.zig
diff --git a/src/jsc/JSPromise.rs b/src/jsc/JSPromise.rs
index 60276eebdf3..dbba6938b3d 100644
--- a/src/jsc/JSPromise.rs
+++ b/src/jsc/JSPromise.rs
@@ -26,8 +26,6 @@ pub enum Status {
     Rejected = 2,
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSPromise` and `JSGlobalObject` are opaque `UnsafeCell`-backed ZST handles
 // (so `&T` is ABI-identical to non-null `*const T` and C++ mutating through
 // the pointer is interior mutation invisible to Rust). The shims that take
@@ -62,21 +60,18 @@ unsafe extern "C" {
         call: extern "C" fn(*mut c_void, *mut JSGlobalObject) -> JSValue,
     ) -> JSValue;
 
-    // Referenced via `bun.cpp.*` in the Zig — declared directly here.
     safe fn JSC__JSPromise__status(this: &JSPromise) -> u32;
     safe fn JSC__JSPromise__result(this: &mut JSPromise, vm: &VM) -> JSValue;
     safe fn JSC__JSPromise__isHandled(this: &JSPromise) -> bool;
     safe fn JSC__JSPromise__setHandled(this: &mut JSPromise);
-    // These three are `void` on the C side (bindings.cpp). The Zig `bun.cpp.*`
-    // wrappers (build/debug/codegen/cpp.zig) call the void extern and then do
-    // `Bun__RETURN_IF_EXCEPTION(global)` to surface `error.JSError` — there is
-    // no bool sentinel on the wire. Mirror that by checking `global.has_exception()`
-    // after the call.
+    // The resolve/reject/rejectAsHandled shims are `void` on the C side
+    // (bindings.cpp) — there is no bool sentinel on the wire; a pending
+    // exception is surfaced by checking `global.has_exception()` after the
+    // call.
 }
 
 // ───────────────────────────── JSPromise.Weak(T) ─────────────────────────────
 
-/// Zig: `pub fn Weak(comptime T: type) type { return struct { ... } }`
 pub struct Weak<T> {
     weak: JscWeak<T>,
 }
@@ -96,8 +91,8 @@ impl<T> Weak<T> {
 
     /// Like `reject`, except it drains microtasks at the end of the current event loop iteration.
     pub fn reject_task(&mut self, global: &JSGlobalObject, val: JSValue) {
-        // RAII for Zig's `loop.enter(); defer loop.exit();` — the safe wrapper
-        // funnels through the single audited deref in `enter_event_loop_scope`.
+        // The safe wrapper funnels through the single audited deref in
+        // `enter_event_loop_scope`.
         let _guard = VirtualMachine::get().enter_event_loop_scope();
         self.reject(global, val);
     }
@@ -118,9 +113,8 @@ impl<T> Weak<T> {
         ref_type: WeakRefType,
         ctx: &mut T,
     ) -> Self {
-        // PORT NOTE: Zig threaded a `comptime finalizer` fn-ptr; the Rust
-        // `Weak<T>` encodes that via `WeakRefType` (one variant per finalizer
-        // — see Weak.rs). PERF(port): was comptime monomorphization.
+        // `Weak<T>` encodes the finalizer via `WeakRefType` (one variant per
+        // finalizer — see Weak.rs).
         Self {
             weak: JscWeak::<T>::create(promise, global, ref_type, ctx),
         }
@@ -154,7 +148,7 @@ impl<T> Weak<T> {
 
     pub fn swap(&mut self) -> &mut JSPromise {
         let prom = self.weak.swap().as_promise().unwrap();
-        // Zig: `this.weak.deinit()` — drop the underlying weak handle now.
+        // Drop the underlying weak handle now.
         self.weak = JscWeak::default();
         // `as_promise()` returns a non-null `*mut JSPromise` for a live promise cell;
         // GC-owned, so the resulting `&mut` is a resolver-style accessor (see `get`).
@@ -162,8 +156,7 @@ impl<T> Weak<T> {
     }
 }
 
-// Zig `deinit` only does `this.weak.clear(); this.weak.deinit();` — both are
-// subsumed by `Drop` on `JscWeak<T>`. No explicit `Drop` impl needed.
+// Cleanup is subsumed by `Drop` on `JscWeak<T>`; no explicit `Drop` impl needed.
 
 // ───────────────────────────── JSPromise.Strong ──────────────────────────────
 
@@ -221,14 +214,12 @@ impl Strong {
         global: &JSGlobalObject,
         val: JSValue,
     ) -> Result<(), JsTerminated> {
-        // RAII for Zig's `loop.enter(); defer loop.exit();` — the safe wrapper
-        // funnels through the single audited deref in `enter_event_loop_scope`.
+        // The safe wrapper funnels through the single audited deref in
+        // `enter_event_loop_scope`.
         let _guard = VirtualMachine::get().enter_event_loop_scope();
         self.reject(global, Ok(val))
     }
 
-    // Zig: `pub const rejectOnNextTick = @compileError("...")`
-
     pub fn resolve(&mut self, global: &JSGlobalObject, val: JSValue) -> Result<(), JsTerminated> {
         self.swap().resolve(global, val)
     }
@@ -258,8 +249,7 @@ impl Strong {
     }
 
     /// Wrap an existing promise `JSValue` in a fresh Strong handle.
-    /// PORT NOTE: Zig copies `JSPromise.Strong` by value (HandleSlot ptr is
-    /// shared); Rust `Strong` owns its slot, so a literal copy would
+    /// `Strong` owns its slot, so a literal copy would
     /// double-free. Callers that need a second owner of the same promise
     /// (e.g. `bake::DevServer::PromiseEnsureRouteBundledCtx::ensurePromise`)
     /// allocate a second slot here instead.
@@ -304,7 +294,7 @@ impl Strong {
 
     pub fn swap(&mut self) -> &mut JSPromise {
         let prom = self.strong.swap().as_promise().unwrap();
-        // Zig: `this.strong.deinit()` — release the handle slot now.
+        // Release the handle slot now.
         self.strong = JscStrong::empty();
         // `as_promise()` returns a non-null `*mut JSPromise` for a live promise cell;
         // GC-owned, so the resulting `&mut` is a resolver-style accessor (see `get`).
@@ -316,7 +306,7 @@ impl Strong {
     }
 }
 
-// Zig `deinit` only does `this.strong.deinit()` — subsumed by `Drop` on `JscStrong`.
+// Cleanup is subsumed by `Drop` on `JscStrong`; no explicit `Drop` impl needed.
 
 // ───────────────────────────── JSPromise methods ─────────────────────────────
 
@@ -328,14 +318,10 @@ impl JSPromise {
 
     /// Wrap a fallible host call in a Promise: if `f` throws, the promise is
     /// rejected; otherwise it resolves with the returned value.
-    ///
-    /// Zig signature took `comptime Function: anytype` + `args: ArgsTuple(@TypeOf(Function))`
-    /// and built a `callconv(.c)` trampoline via `jsc.toJSHostCall`. That is the
-    /// host-fn reflection pattern — in Rust it collapses to a monomorphized closure
-    /// + extern-C trampoline.
-    // TODO(port): proc-macro — the Zig version threads `@src()` and uses
-    // `jsc.toJSHostCall` for exception-scope plumbing. Verify the
-    // closure form below is ABI-equivalent or replace with `#[bun_jsc::host_fn]`.
+    //
+    // The trampoline routes through `crate::to_js_host_call`, and the
+    // surrounding `top_scope!` + `assert_no_exception_except_termination`
+    // handle the exception-scope plumbing.
     pub fn wrap<F>(global: &JSGlobalObject, f: F) -> Result<JSValue, JsTerminated>
     where
         F: FnOnce(&JSGlobalObject) -> JsResult<JSValue>,
@@ -353,12 +339,9 @@ impl JSPromise {
             // `g` is a live JSGlobalObject; safe ZST-handle deref (panics on null).
             let g = JSGlobalObject::opaque_ref(g);
             let f = this.f.take().unwrap();
-            // Zig: `jsc.toJSHostCall(g, @src(), Fn, this.args)` — `@src()` mapped to
-            // `Location::caller()` (resolves to this trampoline's call site).
             crate::to_js_host_call(g, move || f(g))
         }
 
-        // Zig: `var scope: jsc.TopExceptionScope = undefined; scope.init(global, @src()); defer scope.deinit();`
         crate::top_scope!(scope, global);
 
         let mut ctx = Wrapper { f: Some(f) };
@@ -367,7 +350,7 @@ impl JSPromise {
         let promise = JSC__JSPromise__wrap(global, (&raw mut ctx).cast::<c_void>(), call::<F>);
         // JSC__JSPromise__wrap converts any thrown exception into a rejected promise,
         // so a pending non-termination exception here indicates a bug; assert and
-        // surface termination as JsTerminated (matching JSPromise.zig:202-207).
+        // surface termination as JsTerminated.
         scope
             .assert_no_exception_except_termination()
             .map_err(|_| JsTerminated::JSTerminated)?;
@@ -477,7 +460,7 @@ impl JSPromise {
             }
         }
 
-        // `[[ZIG_EXPORT(check_slow)]]` — `bun.cpp.JSC__JSPromise__resolve(...) catch return error.JSTerminated`.
+        // `[[ZIG_EXPORT(check_slow)]]`
         crate::cpp::JSC__JSPromise__resolve(self, global, value)
             .map_err(|_| JsTerminated::JSTerminated)
     }
@@ -515,7 +498,7 @@ impl JSPromise {
             }
         };
 
-        // `[[ZIG_EXPORT(check_slow)]]` — `bun.cpp.JSC__JSPromise__reject(...) catch return error.JSTerminated`.
+        // `[[ZIG_EXPORT(check_slow)]]`
         crate::cpp::JSC__JSPromise__reject(self, global, err)
             .map_err(|_| JsTerminated::JSTerminated)
     }
@@ -586,5 +569,3 @@ pub enum UnwrapMode {
     MarkHandled,
     LeaveUnhandled,
 }
-
-// ported from: src/jsc/JSPromise.zig
diff --git a/src/jsc/JSPromiseRejectionOperation.rs b/src/jsc/JSPromiseRejectionOperation.rs
index 0f1c6ddd3a0..cdc077dc6e0 100644
--- a/src/jsc/JSPromiseRejectionOperation.rs
+++ b/src/jsc/JSPromiseRejectionOperation.rs
@@ -4,5 +4,3 @@ pub enum JSPromiseRejectionOperation {
     Reject = 0,
     Handle = 1,
 }
-
-// ported from: src/jsc/JSPromiseRejectionOperation.zig
diff --git a/src/jsc/JSPropertyIterator.rs b/src/jsc/JSPropertyIterator.rs
index 814716a310d..8a1b26cd155 100644
--- a/src/jsc/JSPropertyIterator.rs
+++ b/src/jsc/JSPropertyIterator.rs
@@ -4,14 +4,13 @@ use crate::host_fn::from_js_host_call_generic;
 use crate::{JSGlobalObject, JSObject, JSValue, JsResult};
 use bun_core as bstr;
 
-/// Comptime config struct in Zig (`JSPropertyIterator.zig:1-7`); ported as a runtime
-/// flag set passed to [`JSPropertyIterator::init`].
+/// Runtime flag set passed to [`JSPropertyIterator::init`].
 ///
-/// `Default` mirrors the Zig field defaults: `own_properties_only = true`,
+/// `Default` is `own_properties_only = true`,
 /// `observable = true`, `only_non_index_properties = false`.
-// PERF(port): was comptime monomorphization (`fn JSPropertyIterator(comptime options) type`).
-// Demoted to runtime flags because the branches gate per-property work, not a hot inner
-// loop, and the monomorphization fan-out would be 32 instantiations. Profile if hot.
+// Runtime flags (not const generics) because the branches gate per-property work, not a
+// hot inner loop, and the monomorphization fan-out would be 32 instantiations. Profile
+// if hot.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct JSPropertyIteratorOptions {
     pub skip_empty_name: bool,
@@ -22,9 +21,8 @@ pub struct JSPropertyIteratorOptions {
 }
 
 impl JSPropertyIteratorOptions {
-    /// Shorthand matching the Zig spec's most common call-site shape
-    /// `.{ .skip_empty_name = …, .include_value = … }`; the remaining three options
-    /// take the Zig struct defaults.
+    /// Shorthand for the most common call-site shape; the remaining three
+    /// options take the [`Default`] values.
     pub const fn new(skip_empty_name: bool, include_value: bool) -> Self {
         Self {
             skip_empty_name,
@@ -50,7 +48,7 @@ impl Default for JSPropertyIteratorOptions {
 }
 
 /// Two-field shorthand of [`JSPropertyIteratorOptions`]; the remaining three options
-/// take the Zig struct defaults via the `From` conversion.
+/// take the default values via the `From` conversion.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct PropertyIteratorOptions {
     pub skip_empty_name: bool,
@@ -64,8 +62,8 @@ impl From<PropertyIteratorOptions> for JSPropertyIteratorOptions {
     }
 }
 
-/// Conversion shim so [`JSPropertyIterator::init`]'s `object` argument accepts the
-/// same operand shapes Zig callers use (`*JSObject`, `&JSObject`).
+/// Conversion shim so [`JSPropertyIterator::init`]'s `object` argument accepts
+/// both `*mut JSObject` and `&JSObject`.
 pub trait IntoIterObject {
     fn into_iter_object(self) -> *mut JSObject;
 }
@@ -111,7 +109,7 @@ pub struct JSPropertyIterator<'a> {
     pub object: *mut JSObject,
     /// Current property value being yielded (only meaningful when
     /// `options.include_value` is set).
-    // PORT NOTE: bare JSValue field is sound because this struct is stack-only (`'a` borrow);
+    // The bare JSValue field is sound because this struct is stack-only (`'a` borrow);
     // conservative stack scan keeps it alive. Do NOT box this struct.
     pub value: JSValue,
 
@@ -248,7 +246,6 @@ impl<'a> Drop for JSPropertyIterator<'a> {
             // freed (we only free here, once).
             unsafe { Bun__JSPropertyIterator__deinit(impl_.as_ptr()) };
         }
-        // Zig: `this.* = undefined;` — no-op in Rust.
     }
 }
 
@@ -283,10 +280,9 @@ impl JSPropertyIteratorImpl {
         property_name: &mut bstr::String,
         i: usize,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: Zig wrapped this in a manual `TopExceptionScope.init/deinit` +
-        // `returnIfException`; that is exactly `from_js_host_call_generic`'s contract
-        // (the FFI may return `.zero` without throwing, so the non-generic
-        // `from_js_host_call` — which treats empty as thrown — is wrong here).
+        // The FFI may return `.zero` without throwing, so the non-generic
+        // `from_js_host_call` — which treats empty as thrown — is wrong here;
+        // `from_js_host_call_generic` checks the exception scope instead.
         from_js_host_call_generic(global_object, || {
             Bun__JSPropertyIterator__getNameAndValue(iter, global_object, object, property_name, i)
         })
@@ -351,5 +347,3 @@ unsafe extern "C" {
         object: &JSObject,
     ) -> usize;
 }
-
-// ported from: src/jsc/JSPropertyIterator.zig
diff --git a/src/jsc/JSRef.rs b/src/jsc/JSRef.rs
index 29cfdbdacac..41366c7ec4e 100644
--- a/src/jsc/JSRef.rs
+++ b/src/jsc/JSRef.rs
@@ -1,8 +1,7 @@
 use core::marker::PhantomData;
 
-// PORT NOTE: JSRef.zig stores `jsc.Strong.Optional`, not `jsc.Strong`. The
-// methods below (`get() -> Option`, `has()`, `try_swap()`) live on the
-// Optional wrapper, so import it under the local name `Strong`.
+// The methods used below (`get() -> Option`, `has()`, `try_swap()`) live on
+// the Optional wrapper, so import it under the local name `Strong`.
 use crate::strong::Optional as Strong;
 use crate::{JSGlobalObject, JSValue};
 
@@ -140,9 +139,9 @@ impl JsRef {
     }
 
     /// `try_get().unwrap_or(JSValue::UNDEFINED)`. Convenience for callers that
-    /// previously stored a bare `JSValue` field (Zig `this.js_value`) and read
-    /// it unconditionally — the `JsRef` wrapper was added on the Rust side for
-    /// GC-safety, so `get()` recovers the original ergonomics.
+    /// previously stored a bare `JSValue` field and read it unconditionally —
+    /// the `JsRef` wrapper was added for GC-safety, so `get()` recovers the
+    /// original ergonomics.
     pub fn get(&self) -> JSValue {
         self.try_get().unwrap_or(JSValue::UNDEFINED)
     }
@@ -152,9 +151,8 @@ impl JsRef {
         match self {
             JsRef::Weak(_) => {}
             JsRef::Strong(_) => {
-                // PORT NOTE: Zig calls `this.strong.deinit()` here. In Rust,
                 // `Strong`'s `Drop` deallocates the HandleSlot when `*self` is
-                // overwritten below, so the explicit call is elided.
+                // overwritten below, so no explicit deinit is needed.
             }
             JsRef::Finalized => {
                 return;
@@ -192,10 +190,9 @@ impl JsRef {
             JsRef::Strong(strong) => {
                 let value = strong.try_swap().unwrap_or(JSValue::UNDEFINED);
                 value.ensure_still_alive();
-                // PORT NOTE: Zig calls `strong.deinit()` here; in Rust the old
-                // `Strong` is dropped by the assignment below.
-                // PORT NOTE: reshaped for borrowck — `strong` borrow ends at
-                // last use above, permitting reassignment of `*self`.
+                // The old `Strong` is dropped by the assignment below; the
+                // `strong` borrow ends at its last use above, permitting
+                // reassignment of `*self`.
                 *self = JsRef::Weak(value);
             }
             JsRef::Finalized => {}
@@ -224,9 +221,8 @@ impl JsRef {
     }
 
     pub fn finalize(&mut self) {
-        // PORT NOTE: Zig calls `self.deinit()` then sets `.finalized`. In Rust,
-        // overwriting `*self` drops the prior variant (releasing the `Strong`
-        // HandleSlot via its `Drop`), so the explicit deinit step is elided.
+        // Overwriting `*self` drops the prior variant (releasing the `Strong`
+        // HandleSlot via its `Drop`), so no explicit deinit step is needed.
         // External `jsref.deinit()` callers become `*jsref = JsRef::empty()`.
         *self = JsRef::Finalized;
     }
@@ -254,5 +250,3 @@ impl Default for JsRef {
         JsRef::empty()
     }
 }
-
-// ported from: src/jsc/JSRef.zig
diff --git a/src/jsc/JSRuntimeType.rs b/src/jsc/JSRuntimeType.rs
index e86619b5142..7413679d304 100644
--- a/src/jsc/JSRuntimeType.rs
+++ b/src/jsc/JSRuntimeType.rs
@@ -1,7 +1,7 @@
 /// Represents JavaScript runtime value types
-// PORT NOTE: Zig `enum(u16) { ... , _ }` is non-exhaustive — any u16 bit-pattern is a
-// valid value (and the discriminants are bitflags). A `#[repr(u16)] enum` would be UB
-// for unlisted values, so map to a transparent newtype with associated consts instead.
+// Any u16 bit-pattern is a valid value (the discriminants are bitflags). A
+// `#[repr(u16)] enum` would be UB for unlisted values, so this is a transparent
+// newtype with associated consts instead.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct JSRuntimeType(pub u16);
@@ -19,5 +19,3 @@ impl JSRuntimeType {
     pub const SYMBOL: Self = Self(0x100);
     pub const BIG_INT: Self = Self(0x200);
 }
-
-// ported from: src/jsc/JSRuntimeType.zig
diff --git a/src/jsc/JSSecrets.rs b/src/jsc/JSSecrets.rs
index a777bb697d2..78369d55ef4 100644
--- a/src/jsc/JSSecrets.rs
+++ b/src/jsc/JSSecrets.rs
@@ -3,8 +3,6 @@ use crate::{AnyTaskJob, AnyTaskJobCtx, JSGlobalObject, JSValue, JsResult, Strong
 // Opaque pointer to C++ SecretsJobOptions struct
 bun_opaque::opaque_ffi! { pub struct SecretsJobOptions; }
 
-// TODO(port): move to <area>_sys
-//
 // safe fn: `SecretsJobOptions` and `JSGlobalObject` are `opaque_ffi!` ZST
 // handles (`!Freeze` via `UnsafeCell`); `&mut`/`&` are ABI-identical to
 // non-null `*mut`/`*const` and C++ mutating job state through them is interior
@@ -79,8 +77,3 @@ pub(crate) extern "C" fn Bun__Secrets__scheduleJob(
     )
     .expect("SecretsCtx::init is infallible");
 }
-
-// Zig `fixDeadCodeElimination` + `comptime { _ = ... }` dropped:
-// #[unsafe(no_mangle)] already prevents DCE of Bun__Secrets__scheduleJob in Rust.
-
-// ported from: src/jsc/JSSecrets.zig
diff --git a/src/jsc/JSString.rs b/src/jsc/JSString.rs
index 7351771d607..7344d757200 100644
--- a/src/jsc/JSString.rs
+++ b/src/jsc/JSString.rs
@@ -2,8 +2,6 @@ use core::ffi::c_void;
 
 use crate::{JSGlobalObject, JSObject, JSValue, JsResult};
 use bun_core::ZigString;
-// `ZigString.Slice` in Zig — re-exported in Rust as `bun_core::zig_string::Slice`
-// (alias for `bun_core::ZigStringSlice`).
 use bun_core::zig_string::Slice as ZigStringSlice;
 
 bun_opaque::opaque_ffi! {
@@ -11,10 +9,8 @@ bun_opaque::opaque_ffi! {
     pub struct JSString;
 }
 
-// TODO(port): move to jsc_sys
-//
-// NOTE: Zig declares several of these params as `*JSString` / `*JSGlobalObject`
-// (mutable), but the C ABI does not distinguish `*const T` from `*mut T`. We
+// NOTE: the C++ side may mutate through several of these `*JSString` /
+// `*JSGlobalObject` params, but the C ABI does not distinguish `*const T` from `*mut T`. We
 // intentionally declare them `*const` here — matching the convention in
 // JSGlobalObject.rs / JSValue.rs — so that callers can pass `&self` / `&global`
 // directly without an `as *const _ as *mut _` cast. `JSString` and
@@ -51,7 +47,7 @@ impl JSString {
     }
 
     pub fn ensure_still_alive(&self) {
-        // SAFETY: matches Zig's std.mem.doNotOptimizeAway(this) — JSString is always a cell.
+        // Keep the cell pointer observable to the GC's conservative stack scan.
         core::hint::black_box(std::ptr::from_ref::<Self>(self));
     }
 
@@ -61,7 +57,6 @@ impl JSString {
         out
     }
 
-    // pub const view = getZigString;
     #[inline]
     pub fn view(&self, global: &JSGlobalObject) -> ZigString {
         self.get_zig_string(global)
@@ -74,7 +69,7 @@ impl JSString {
         str.to_slice()
     }
 
-    // Spec (JSString.zig:44-52): `str.toSliceClone(allocator)` always allocates
+    // `to_slice_clone` always allocates
     // an owned UTF-8 copy so the result outlives the GC'd JSString. Returning
     // `to_slice()` here (a borrow that may alias JSC-owned memory) would hand
     // callers a use-after-free once the cell is collected.
@@ -85,7 +80,7 @@ impl JSString {
         Ok(str.to_slice_clone())
     }
 
-    // Spec (JSString.zig:54-62): `str.toSliceZ(allocator)` guarantees a `[:0]`
+    // `to_slice_z` guarantees a trailing NUL
     // sentinel. `to_slice()` is not NUL-terminated; passing it to a C API that
     // expects one reads past the buffer end.
 
@@ -134,7 +129,7 @@ pub struct Iterator {
 }
 
 impl Iterator {
-    /// Raw type-erased user-data pointer (Zig: `data: ?*anyopaque`).
+    /// Raw type-erased user-data pointer.
     ///
     /// This is the sole accessor for the `data` field. A `&T`-returning
     /// accessor is intentionally **not** provided: `data` is an opaque
@@ -143,7 +138,7 @@ impl Iterator {
     /// append/write callbacks while C++ holds `*mut Iterator` re-entrantly.
     /// Callers must cast and dereference under their own `unsafe` block.
     ///
-    /// Invariant: may be null (Zig spec declares it optional). When set by
+    /// Invariant: may be null. When set by
     /// `iter()`-style constructors it points to a stack-local context struct
     /// that outlives the `JSC__JSString__iterator` call.
     #[inline]
@@ -151,5 +146,3 @@ impl Iterator {
         self.data
     }
 }
-
-// ported from: src/jsc/JSString.zig
diff --git a/src/jsc/JSType.rs b/src/jsc/JSType.rs
index b53b57d3bf3..991eb263906 100644
--- a/src/jsc/JSType.rs
+++ b/src/jsc/JSType.rs
@@ -92,10 +92,10 @@
 
 use crate::array_buffer::TypedArrayType;
 
-// PORT NOTE: Zig's `enum(u8) { ..., _ }` is non-exhaustive — any u8 value is a valid
-// JSType (values are read directly from JSCell::m_type via FFI, including embedder-
-// defined types). A plain `#[repr(u8)] enum` would be UB for unknown discriminants,
-// so this is a transparent newtype with associated consts instead.
+// Any u8 value is a valid JSType (values are read directly from JSCell::m_type
+// via FFI, including embedder-defined types). A plain `#[repr(u8)] enum` would
+// be UB for unknown discriminants, so this is a transparent newtype with
+// associated consts instead.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, core::marker::ConstParamTy)]
 pub struct JSType(pub u8);
@@ -582,7 +582,7 @@ impl JSType {
     pub const DOMWrapper: JSType = JSType(0b11101110);
     pub const EmbedderArrayLike: JSType = JSType(0b11101101);
 
-    /// This means that we don't have Zig bindings for the type yet, but it
+    /// This means that we don't have bindings for the type yet, but it
     /// implements .toJSON()
     pub const JSAsJSONType: JSType = JSType(0b11110000 | 1);
 }
@@ -591,7 +591,7 @@ impl JSType {
     pub const MIN_TYPED_ARRAY: JSType = JSType::Int8Array;
     pub const MAX_TYPED_ARRAY: JSType = JSType::DataView;
 
-    /// Port of Zig `@tagName(arrayBuffer.typed_array_type)` — `JSType` is a
+    /// `JSType` is a
     /// newtype-const (not a Rust `enum`), so there is no derived stringifier.
     /// Covers every `is_typed_array_or_array_buffer()` variant + `DataView`.
     /// The `_ => "TypedArray"` arm is unreachable for any real
@@ -870,5 +870,3 @@ impl JSType {
         )
     }
 }
-
-// ported from: src/jsc/JSType.zig
diff --git a/src/jsc/JSUint8Array.rs b/src/jsc/JSUint8Array.rs
index a8bbf5c76fe..7b1819bf1b1 100644
--- a/src/jsc/JSUint8Array.rs
+++ b/src/jsc/JSUint8Array.rs
@@ -11,8 +11,8 @@ bun_opaque::opaque_ffi! {
 impl JSUint8Array {
     pub fn ptr(&self) -> *mut u8 {
         // SAFETY: `self` points at a live JSUint8Array cell; the typed-array vector
-        // pointer lives at a fixed byte offset computed by the C++ codegen (sizes.zig).
-        // Using byte_add preserves provenance vs. the Zig `@ptrFromInt(@intFromPtr(..)+off)`.
+        // pointer lives at a fixed byte offset computed by the C++ codegen
+        // (`crate::sizes`). `byte_add` preserves pointer provenance.
         unsafe {
             std::ptr::from_ref::<Self>(self)
                 .byte_add(sizes::BUN_FFI_POINTER_OFFSET_TO_TYPED_ARRAY_VECTOR)
@@ -33,16 +33,15 @@ impl JSUint8Array {
     }
 
     pub fn slice(&mut self) -> &mut [u8] {
-        // PORT NOTE: detached/empty JSUint8Array has ptr=null, len=0. Zig `ptr[0..0]` is
-        // valid for any ptr; `ffi::slice_mut` tolerates `(null, 0)` so no extra guard.
+        // Note: detached/empty JSUint8Array has ptr=null, len=0;
+        // `ffi::slice_mut` tolerates `(null, 0)` so no extra guard.
         // SAFETY: JSC guarantees `ptr()` is valid for `len()` bytes while the cell is alive.
         unsafe { bun_core::ffi::slice_mut(self.ptr(), self.len()) }
     }
 
     /// `bytes` must come from `bun.default_allocator` (the global mimalloc allocator);
     /// ownership is transferred to the returned JS Uint8Array.
-    // PORT NOTE: Zig took `[]u8` + a doc comment requiring default_allocator provenance.
-    // In Rust the global allocator IS mimalloc, so `Box<[u8]>` encodes that ownership.
+    // The global allocator IS mimalloc, so `Box<[u8]>` encodes that ownership.
     pub fn from_bytes(global: &JSGlobalObject, bytes: Box<[u8]>) -> JSValue {
         let len = bytes.len();
         let ptr = bun_core::heap::into_raw(bytes).cast::<u8>();
@@ -69,7 +68,6 @@ impl JSUint8Array {
     }
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     fn JSUint8Array__fromDefaultAllocator(
         global: *const JSGlobalObject,
@@ -84,5 +82,3 @@ unsafe extern "C" {
         buffer: bool,
     ) -> JSValue;
 }
-
-// ported from: src/jsc/JSUint8Array.zig
diff --git a/src/jsc/JSValue.rs b/src/jsc/JSValue.rs
index dcad9d61907..67976fc7c65 100644
--- a/src/jsc/JSValue.rs
+++ b/src/jsc/JSValue.rs
@@ -5,8 +5,6 @@
 //!
 //! In the future, this type will exclude `zero`, encoding it as `error.JSError`
 //! instead.
-//!
-//! Ported from `src/jsc/JSValue.zig`.
 
 use core::ffi::{c_char, c_void};
 use core::marker::PhantomData;
@@ -24,14 +22,15 @@ use crate::{
 /// `PhantomData<*const ()>` enforces `!Send + !Sync` (negative impls are
 /// nightly-only and not used here for portability of the auto-trait inference).
 //
-// TODO(port): inner type should be `i64` per spec; kept `usize` (same width on
-// all supported 64-bit targets) to avoid a cascading bit-twiddle / pointer-cast
-// rewrite across already-un-gated leaf modules that pattern-match on `.0`.
+// The spec encoding is `i64`; the inner field is `usize`
+// (same width on all supported 64-bit targets — see the size assert below)
+// because leaf modules pattern-match on `.0` with pointer/unsigned arithmetic.
+// `BackingInt`/`from_raw` are the signed views where sign-correct math matters.
 #[repr(transparent)]
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct JSValue(pub usize, PhantomData<*const ()>);
 
-/// Backing integer type for the encoded value (Zig: `enum(i64)`).
+/// Backing integer type for the encoded value.
 pub type BackingInt = i64;
 
 const _: () = assert!(
@@ -40,7 +39,7 @@ const _: () = assert!(
 );
 
 // ──────────────────────────────────────────────────────────────────────────
-// Tag constants (JSValue.zig:14-33).
+// Tag constants.
 // ──────────────────────────────────────────────────────────────────────────
 impl JSValue {
     /// Typically means an exception was thrown.
@@ -55,22 +54,22 @@ impl JSValue {
     /// Deleted is a special encoding used in JSC hash-map internals for the
     /// null state; it is re-used here for "not present".
     pub const PROPERTY_DOES_NOT_EXIST: JSValue = JSValue(0x4, PhantomData);
-    /// Zig spelling (`.property_does_not_exist_on_object`).
+    /// Alias of [`Self::PROPERTY_DOES_NOT_EXIST`], kept for binding-name compatibility.
     pub const PROPERTY_DOES_NOT_EXIST_ON_OBJECT: JSValue = Self::PROPERTY_DOES_NOT_EXIST;
 
     pub const IS_POINTER: bool = false;
 
-    /// Construct a JSValue from an opaque encoded bit-pattern (Zig: `@enumFromInt`).
+    /// Construct a JSValue from an opaque encoded bit-pattern.
     #[inline]
     pub const fn from_encoded(bits: usize) -> JSValue {
         JSValue(bits, PhantomData)
     }
-    /// Read the raw encoded bit-pattern (Zig: `@intFromEnum`).
+    /// Read the raw encoded bit-pattern.
     #[inline]
     pub const fn encoded(self) -> usize {
         self.0
     }
-    /// Signed view of the encoded bit-pattern (Zig backing type is `i64`).
+    /// Signed view of the encoded bit-pattern.
     #[inline]
     pub const fn raw(self) -> i64 {
         self.0 as i64
@@ -93,19 +92,19 @@ impl JSValue {
     /// context through `Promise.then` reaction arguments.
     #[inline]
     pub fn from_ptr_address(addr: usize) -> JSValue {
-        // Matches Zig `fromPtrAddress` → `jsDoubleNumber` (always double-encoded;
-        // never the int32 fast path), so `as_ptr_address` round-trips bit-exact.
+        // Always double-encoded via `jsDoubleNumber` (never the int32 fast
+        // path), so `as_ptr_address` round-trips bit-exact.
         Self::js_double_number(addr as f64)
     }
 
-    /// `JSValue.asPtrAddress` (JSValue.zig) — inverse of `from_ptr_address`:
-    /// `@intFromFloat(this.asNumber())`.
+    /// `JSValue.asPtrAddress` — inverse of `from_ptr_address`:
+    /// `as_number() as usize`.
     #[inline]
     pub fn as_ptr_address(self) -> usize {
         self.as_number() as usize
     }
 
-    /// `JSValue.asPromisePtr` (JSValue.zig) — decode a `*mut T` smuggled
+    /// `JSValue.asPromisePtr` — decode a `*mut T` smuggled
     /// through [`from_ptr_address`] as the trailing `.then` reaction argument.
     #[inline]
     pub fn as_promise_ptr<T>(self) -> *mut T {
@@ -115,9 +114,8 @@ impl JSValue {
     /// Attach `(resolve, reject)` reactions to this Promise, passing `ctx` as
     /// the trailing argument to each. Thin wrapper over `JSC__JSValue___then`.
     ///
-    /// Port of `JSValue.then(ctx: ?*anyopaque, resolve, reject)` (JSValue.zig).
-    /// The Zig version wraps in a `TopExceptionScope` and surfaces only
-    /// termination; every current call site does `catch {}`, so this returns
+    /// Wraps in a `TopExceptionScope` and surfaces only
+    /// termination; every current call site discards the error, so this returns
     /// `()` and lets the caller's surrounding scope (or none) observe a
     /// termination on its next check.
     pub fn then<T>(
@@ -139,8 +137,7 @@ impl JSValue {
                 reject: host_fn::JSHostFn,
             );
         }
-        // Zig (JSValue.zig:1495): `TopExceptionScope` + `assertNoExceptionExceptTermination`.
-        // Every current call site does `catch {}`, so swallow termination.
+        // Every current call site discards the error, so swallow termination.
         crate::top_scope!(scope, global);
         JSC__JSValue___then(
             self,
@@ -153,9 +150,8 @@ impl JSValue {
     }
 
     /// Like [`then`] but the context is a `JSValue` (not a raw pointer encoded
-    /// as a JS number). Port of `JSValue.then2` (JSValue.zig:1487). The Zig
-    /// version wraps in a `TopExceptionScope` and surfaces only termination;
-    /// every current call site does `catch {}`, so this returns `()`.
+    /// as a JS number). Wraps in a `TopExceptionScope` and surfaces only
+    /// termination; every current call site discards the error, so this returns `()`.
     pub fn then2(
         self,
         global: &JSGlobalObject,
@@ -173,7 +169,6 @@ impl JSValue {
                 reject: host_fn::JSHostFn,
             );
         }
-        // Zig (JSValue.zig:1487): `TopExceptionScope` + `assertNoExceptionExceptTermination`.
         crate::top_scope!(scope, global);
         JSC__JSValue___then(self, global, ctx, resolve, reject);
         let _ = scope.assert_no_exception_except_termination();
@@ -182,10 +177,10 @@ impl JSValue {
     /// Like [`then`], but the context is a `JSValue` instead of a raw pointer.
     /// Use this when the context should be GC-managed (e.g. a JSCell that gets
     /// collected with the Promise's reaction if the Promise is GC'd without
-    /// settling). Port of `JSValue.thenWithValue` (JSValue.zig).
+    /// settling).
     ///
-    /// The Zig version wraps in a `TopExceptionScope` and surfaces only
-    /// termination; every current call site does `catch {}`, so this returns
+    /// Wraps in a `TopExceptionScope` and surfaces only
+    /// termination; every current call site discards the error, so this returns
     /// `()` and lets the caller's surrounding scope (or none) observe a
     /// termination on its next check.
     #[inline]
@@ -199,7 +194,7 @@ impl JSValue {
         self.then2(global, ctx, resolve, reject)
     }
 
-    /// `@enumFromInt(@bitCast(@intFromPtr(ptr)))`.
+    /// Reinterpret a raw pointer's address as a JSValue bit-pattern.
     #[inline]
     pub fn cast<T>(ptr: *const T) -> JSValue {
         JSValue(ptr as usize, PhantomData)
@@ -211,7 +206,7 @@ impl JSValue {
 // `jsc::ConsoleObject::Formatter`.
 
 // ──────────────────────────────────────────────────────────────────────────
-// Tag predicates (inline mirrors of JSValue.zig).
+// Tag predicates.
 // ──────────────────────────────────────────────────────────────────────────
 impl JSValue {
     #[inline]
@@ -228,7 +223,6 @@ impl JSValue {
     }
     #[inline]
     pub fn is_undefined_or_null(self) -> bool {
-        // Zig: `return @intFromEnum(this) | 0x8 == 0xa;`
         (self.0 | 0x8) == 0xa
     }
     #[inline]
@@ -263,7 +257,7 @@ impl JSValue {
     pub fn is_any_int(self) -> bool {
         JSC__JSValue__isAnyInt(self)
     }
-    /// ECMA-262 20.1.2.3 `Number.isInteger` (JSValue.zig:124).
+    /// ECMA-262 20.1.2.3 `Number.isInteger`.
     #[inline]
     pub fn is_integer(self) -> bool {
         if self.is_int32() {
@@ -281,7 +275,7 @@ impl JSValue {
     pub fn is_string(self) -> bool {
         self.is_cell() && self.js_type().is_string_like()
     }
-    /// `JSValue.isStringLiteral` (JSValue.zig) — primitive string only
+    /// `JSValue.isStringLiteral` — primitive string only
     /// (`JSType::String`); excludes `StringObject` / `DerivedStringObject`.
     #[inline]
     pub fn is_string_literal(self) -> bool {
@@ -312,7 +306,7 @@ impl JSValue {
     pub fn is_big_int(self) -> bool {
         JSC__JSValue__isBigInt(self)
     }
-    /// `JSValue.isBigInt32()` (JSValue.zig:1073) — true iff this value uses
+    /// `JSValue.isBigInt32()` — true iff this value uses
     /// JSC's packed BigInt32 immediate representation (vs heap `JSBigInt`).
     #[inline]
     pub fn is_big_int32(self) -> bool {
@@ -321,7 +315,7 @@ impl JSValue {
         }
         JSC__JSValue__isBigInt32(self)
     }
-    /// `JSValue.isHeapBigInt()` (JSValue.zig:1070) — true iff this is a
+    /// `JSValue.isHeapBigInt()` — true iff this is a
     /// heap-allocated `JSBigInt` cell. Distinct from [`is_big_int`], which
     /// also returns `true` for the packed `BigInt32` immediate.
     #[inline]
@@ -331,7 +325,7 @@ impl JSValue {
         }
         JSC__JSValue__isHeapBigInt(self)
     }
-    /// `JSValue.isBigIntInInt64Range` (JSValue.zig:40) — `self` must already be
+    /// `JSValue.isBigIntInInt64Range` — `self` must already be
     /// known to be a BigInt; checks `min <= self <= max` without truncation.
     #[inline]
     pub fn is_big_int_in_int64_range(self, min: i64, max: i64) -> bool {
@@ -340,7 +334,7 @@ impl JSValue {
         }
         JSC__isBigIntInInt64Range(self, min, max)
     }
-    /// `JSValue.isBigIntInUInt64Range` (JSValue.zig:36).
+    /// `JSValue.isBigIntInUInt64Range`.
     #[inline]
     pub fn is_big_int_in_uint64_range(self, min: u64, max: u64) -> bool {
         unsafe extern "C" {
@@ -348,12 +342,12 @@ impl JSValue {
         }
         JSC__isBigIntInUInt64Range(self, min, max)
     }
-    /// `JSValue.isCallable()` (JSValue.zig:1159).
+    /// `JSValue.isCallable()`.
     #[inline]
     pub fn is_callable(self) -> bool {
         JSC__JSValue__isCallable(self)
     }
-    /// `JSValue.isFunction()` (JSValue.zig:1094) — JSType-byte check, NOT
+    /// `JSValue.isFunction()` — JSType-byte check, NOT
     /// `isCallable()`. Callable proxies return `false` here but `true` from
     /// `is_callable()`.
     #[inline]
@@ -368,13 +362,13 @@ impl JSValue {
         }
         JSC__JSValue__isAnyError(self)
     }
-    /// `JSValue.isError()` (JSValue.zig:999) — true iff this is an
+    /// `JSValue.isError()` — true iff this is an
     /// `ErrorInstance` cell (does NOT match `Exception`).
     #[inline]
     pub fn is_error(self) -> bool {
         self.is_cell() && self.js_type() == JSType::ErrorInstance
     }
-    /// `JSValue.isJSXElement(globalObject)` (JSValue.zig:56). Checks via the
+    /// `JSValue.isJSXElement(globalObject)`. Checks via the
     /// global's `Symbol.for("react.element")` / `Symbol.for("react.transitional.element")`
     /// for `$$typeof`; may invoke a user getter and throw.
     pub fn is_jsx_element(self, global: &JSGlobalObject) -> JsResult<bool> {
@@ -383,7 +377,7 @@ impl JSValue {
         }
         host_fn::from_js_host_call_generic(global, || JSC__JSValue__isJSXElement(self, global))
     }
-    /// `JSValue.isAggregateError(globalObject)` (JSValue.zig:2194).
+    /// `JSValue.isAggregateError(globalObject)`.
     #[inline]
     pub fn is_aggregate_error(self, global: &JSGlobalObject) -> bool {
         unsafe extern "C" {
@@ -391,7 +385,7 @@ impl JSValue {
         }
         JSC__JSValue__isAggregateError(self, global)
     }
-    /// `JSValue.getErrorsProperty(globalObject)` (JSValue.zig:552). Returns the
+    /// `JSValue.getErrorsProperty(globalObject)`. Returns the
     /// own `errors` data property via `JSObject::getDirect` — no prototype
     /// walk, no getters invoked, nothrow. Used for `AggregateError.errors`.
     #[inline]
@@ -404,13 +398,13 @@ impl JSValue {
         }
         JSC__JSValue__getErrorsProperty(self, global)
     }
-    /// `JSValue.isTerminationException()` (JSValue.zig:1182) — true if this
+    /// `JSValue.isTerminationException()` — true if this
     /// value is the VM's termination-exception sentinel.
     #[inline]
     pub fn is_termination_exception(self) -> bool {
         JSC__JSValue__isTerminationException(self)
     }
-    /// `JSValue.isException(vm)` (JSValue.zig:1169) — true if this value is a
+    /// `JSValue.isException(vm)` — true if this value is a
     /// `JSC::Exception` cell.
     #[inline]
     pub fn is_exception(self, vm: *mut crate::VM) -> bool {
@@ -418,7 +412,7 @@ impl JSValue {
         // zero-byte deref proof, so no `unsafe` is needed at this call site.
         JSC__JSValue__isException(self, crate::VM::opaque_ref(vm))
     }
-    /// `JSValue.asException(vm)` (JSValue.zig:1174) — cast to `*mut Exception`
+    /// `JSValue.asException(vm)` — cast to `*mut Exception`
     /// if `is_exception`, else null. The returned pointer borrows the GC cell;
     /// callers must keep `self` alive (the only callsite —
     /// `runErrorHandler` — holds it on the stack).
@@ -426,7 +420,7 @@ impl JSValue {
     pub fn as_exception(self, vm: *mut crate::VM) -> Option<*mut crate::Exception> {
         if self.is_exception(vm) {
             // SAFETY: `is_exception` proved the cell is a `JSC::Exception`;
-            // the encoded value is the cell pointer (Zig `uncheckedPtrCast`).
+            // the encoded value is the cell pointer.
             Some(self.0 as *mut crate::Exception)
         } else {
             None
@@ -464,7 +458,7 @@ impl JSValue {
         }
     }
 
-    /// `jsTypeLoose()` (JSValue.zig:291) — `js_type` but maps non-cell numbers
+    /// `jsTypeLoose()` — `js_type` but maps non-cell numbers
     /// to `NumberObject` so callers can switch on `JSType` without a separate
     /// `is_number()` arm.
     #[inline]
@@ -498,7 +492,7 @@ impl JSValue {
             Self::js_number(i as f64)
         }
     }
-    /// `JSValue.jsNumberFromInt64` (JSValue.zig:814) — int32 fast-path,
+    /// `JSValue.jsNumberFromInt64` — int32 fast-path,
     /// otherwise lossy double.
     pub fn js_number_from_int64(i: i64) -> JSValue {
         if i <= i32::MAX as i64 && i >= i32::MIN as i64 {
@@ -528,7 +522,7 @@ impl JSValue {
     pub fn create_empty_object_with_null_prototype(global: &JSGlobalObject) -> JSValue {
         JSC__JSValue__createEmptyObjectWithNullPrototype(global)
     }
-    /// `JSValue.createObject2` (JSValue.zig:536) — `{ [key1]: value1, [key2]: value2 }`.
+    /// `JSValue.createObject2` — `{ [key1]: value1, [key2]: value2 }`.
     pub fn create_object2(
         global: &JSGlobalObject,
         key1: &bun_core::ZigString,
@@ -542,7 +536,6 @@ impl JSValue {
     }
     #[track_caller]
     pub fn create_empty_array(global: &JSGlobalObject, len: usize) -> JsResult<JSValue> {
-        // Zig: `fromJSHostCall` (== `call_zero_is_throw`).
         crate::call_zero_is_throw(global, || JSC__JSValue__createEmptyArray(global, len))
     }
     /// Replaces the hand-stamped `create_empty_array` + `enumerate` +
@@ -577,7 +570,7 @@ impl JSValue {
     ) -> JsResult<JSValue> {
         Self::create_array_from_iter(global, items.iter().copied(), Ok)
     }
-    /// `JSValue.createBufferFromLength` (JSValue.zig:557) — allocates a Node.js
+    /// `JSValue.createBufferFromLength` — allocates a Node.js
     /// `Buffer` (the `JSBufferSubclassStructure` Uint8Array subclass) of `len`
     /// zeroed bytes via `JSBuffer__bufferFromLength`. May throw OOM.
     pub fn create_buffer_from_length(global: &JSGlobalObject, len: usize) -> JsResult<JSValue> {
@@ -585,7 +578,7 @@ impl JSValue {
         host_fn::from_js_host_call(global, || JSBuffer__bufferFromLength(global, len as i64))
     }
     pub fn create_buffer(global: &JSGlobalObject, slice: &mut [u8]) -> JSValue {
-        // JSValue.zig:createBuffer — wraps `JSBuffer__bufferFromPointerAndLengthAndDeinit`
+        // Wraps `JSBuffer__bufferFromPointerAndLengthAndDeinit`
         // with `MarkedArrayBuffer_deallocator` (or null for empty slices).
         // SAFETY: `global` is live; slice ptr/len describe a valid range whose
         // ownership is transferred to JSC (freed via the deallocator).
@@ -630,7 +623,7 @@ impl JSValue {
             )
         }
     }
-    /// `JSValue.createBufferWithCtx` (JSValue.zig) — wrap a foreign-owned byte
+    /// `JSValue.createBufferWithCtx` — wrap a foreign-owned byte
     /// range in a Node `Buffer`, transferring ownership to JS. `free(ctx, ptr)`
     /// runs when the Buffer's backing store is collected.
     ///
@@ -670,7 +663,7 @@ impl JSValue {
     pub fn from_uint64_no_truncate(global: &JSGlobalObject, i: u64) -> JSValue {
         JSC__JSValue__fromUInt64NoTruncate(global, i)
     }
-    /// `JSValue.fromTimevalNoTruncate` (JSValue.zig:1227) — encode a `struct timeval`
+    /// `JSValue.fromTimevalNoTruncate` — encode a `struct timeval`
     /// as a BigInt (`sec * 1_000_000 + nsec`) without precision loss. May allocate
     /// a heap BigInt, so wrapped in `from_js_host_call` for exception checking.
     pub fn from_timeval_no_truncate(
@@ -682,12 +675,11 @@ impl JSValue {
             JSC__JSValue__fromTimevalNoTruncate(global, nsec, sec)
         })
     }
-    /// `JSValue.bigIntSum` (JSValue.zig:1232) — `a + b` where both are BigInt.
-    /// Infallible per the Zig signature (no `JSError!`).
+    /// `JSValue.bigIntSum` — `a + b` where both are BigInt.
     pub fn big_int_sum(global: &JSGlobalObject, a: JSValue, b: JSValue) -> JSValue {
         JSC__JSValue__bigIntSum(global, a, b)
     }
-    /// `JSValue.fromEntries` (JSValue.zig:757) — build a plain object from
+    /// `JSValue.fromEntries` — build a plain object from
     /// parallel `keys`/`values` `ZigString` arrays. When `clone` is true the
     /// C++ side copies the string bytes (caller may free `keys`/`values`).
     pub fn from_entries(
@@ -717,7 +709,6 @@ impl JSValue {
 impl JSValue {
     #[inline]
     pub fn to_boolean(self) -> bool {
-        // JSValue.zig:2103 — `this != .zero and JSC__JSValue__toBoolean(this)`.
         !self.is_empty() && JSC__JSValue__toBoolean(self)
     }
     #[inline]
@@ -733,7 +724,7 @@ impl JSValue {
     #[inline]
     pub fn as_double(self) -> f64 {
         debug_assert!(self.is_double());
-        // FFI.zig: JSVALUE_TO_DOUBLE — subtract DoubleEncodeOffset, bitcast to f64.
+        // Subtract DoubleEncodeOffset, bitcast to f64.
         f64::from_bits((self.0 as i64).wrapping_sub(ffi::DOUBLE_ENCODE_OFFSET) as u64)
     }
     /// Asserts this is a number, undefined, null, or a boolean.
@@ -763,7 +754,7 @@ impl JSValue {
             return (self.0 & 0xffff_ffff) as u32 as i32;
         }
         if let Some(num) = self.get_number() {
-            // JSValue.zig:2129 — coerceJSValueDoubleTruncatingT(i32, num):
+            // coerceJSValueDoubleTruncatingT(i32, num):
             // NaN → 0, ±Inf/out-of-range → saturate to i32 MIN/MAX, else truncate.
             if num.is_nan() {
                 return 0;
@@ -777,7 +768,6 @@ impl JSValue {
             return self.as_int32() as i64;
         }
         if let Some(num) = self.get_number() {
-            // JSValue.zig:916 — coerceDoubleTruncatingIntoInt64.
             if num.is_nan() {
                 return 0;
             }
@@ -785,7 +775,7 @@ impl JSValue {
         }
         JSC__JSValue__toInt64(self)
     }
-    /// `JSValue.asInt52()` (JSValue.zig:2116) — saturating-truncate
+    /// `JSValue.asInt52()` — saturating-truncate
     /// `as_number()` into i52 range, returned widened to i64. NaN → 0;
     /// out-of-range / ±Inf saturate to i52 MIN/MAX.
     #[inline]
@@ -805,7 +795,7 @@ impl JSValue {
         }
         num as i64
     }
-    /// `JSValue.toU32()` (JSValue.zig:2160) — clamp `toInt64()` into
+    /// `JSValue.toU32()` — clamp `toInt64()` into
     /// `[0, u32::MAX]`. Negative → 0, overflow → `u32::MAX`. Distinct from
     /// JS `ToUint32` (which wraps modulo 2³²); this is a Bun-side saturating
     /// helper used by matchers/bindings that want a non-negative count.
@@ -813,7 +803,7 @@ impl JSValue {
     pub fn to_u32(self) -> u32 {
         self.to_int64().clamp(0, u32::MAX as i64) as u32
     }
-    /// `JSValue.isUInt32AsAnyInt()` (JSValue.zig) — true iff this value is a
+    /// `JSValue.isUInt32AsAnyInt()` — true iff this value is a
     /// non-negative integer (Int32 fast-path or integral double in u32 range).
     #[inline]
     pub fn is_uint32_as_any_int(self) -> bool {
@@ -822,7 +812,7 @@ impl JSValue {
         }
         JSC__JSValue__isUInt32AsAnyInt(self)
     }
-    /// `JSValue.toUInt64NoTruncate()` (JSValue.zig) — read a non-negative
+    /// `JSValue.toUInt64NoTruncate()` — read a non-negative
     /// integer (Int32/double/BigInt) as `u64` without going through ToNumber.
     #[inline]
     pub fn to_uint64_no_truncate(self) -> u64 {
@@ -834,7 +824,7 @@ impl JSValue {
     /// `JSValue.createUninitializedUint8Array(global, len)` — allocate a new
     /// `Uint8Array` of `len` bytes without zeroing. Backing memory is
     /// uninitialized; caller must write every byte before exposing it to JS.
-    /// May throw (OOM) — Zig spec wraps via `fromJSHostCall`.
+    /// May throw (OOM).
     #[inline]
     pub fn create_uninitialized_uint8_array(
         global: &JSGlobalObject,
@@ -853,12 +843,12 @@ impl JSValue {
     pub fn coerce_to_i32(self, global: &JSGlobalObject) -> JsResult<i32> {
         host_fn::from_js_host_call_generic(global, || JSC__JSValue__coerceToInt32(self, global))
     }
-    /// `JSValue.coerceToInt64` (JSValue.zig:47) — full ToNumber → Int64 path
+    /// `JSValue.coerceToInt64` — full ToNumber → Int64 path
     /// (may throw via `valueOf`/`toString`).
     pub fn coerce_to_int64(self, global: &JSGlobalObject) -> JsResult<i64> {
         host_fn::from_js_host_call_generic(global, || JSC__JSValue__coerceToInt64(self, global))
     }
-    /// Generic coercion (`coerce(comptime T)` in Zig). Per-type helpers are
+    /// Generic coercion. Per-type helpers are
     /// `coerce_to_i32` / `coerce_f64` etc.; this fronts the i32 path.
     pub fn coerce<T: CoerceTo>(self, global: &JSGlobalObject) -> JsResult<T> {
         T::coerce_from(self, global)
@@ -883,8 +873,7 @@ impl JSValue {
         host_fn::from_js_host_call_generic(global, || JSC__JSValue__toZigString(self, out, global))
     }
     pub fn to_slice(self, global: &JSGlobalObject) -> JsResult<bun_core::ZigStringSlice> {
-        // Spec (JSValue.zig `toSlice`): `bun.String.fromJS` → `defer str.deref()`
-        // → `toUTF8`. `to_bun_string` returns a +1 ref; `bun_core::String` is
+        // `to_bun_string` returns a +1 ref; `bun_core::String` is
         // `Copy` (no `Drop`), so wrap in `OwnedString` for the scope-exit
         // `deref()`. `to_utf8()` takes its own ref (or owned alloc) so the
         // slice survives the drop.
@@ -896,8 +885,7 @@ impl JSValue {
     ///
     /// Remember that `Symbol` throws an exception when you call `toString()`.
     ///
-    /// Spec (JSValue.zig `toSliceClone` → `toSliceCloneWithAllocator`): the
-    /// returned slice is *always* heap-owned and independent of the backing
+    /// The returned slice is *always* heap-owned and independent of the backing
     /// `JSString` cell, so it outlives GC. Allocator param dropped per
     /// PORTING.md (default_allocator only).
     pub fn to_slice_clone(self, global: &JSGlobalObject) -> JsResult<bun_core::ZigStringSlice> {
@@ -905,10 +893,8 @@ impl JSValue {
     }
     /// Call `toString()` on the JSValue and clone the result.
     ///
-    /// Spec (JSValue.zig `toSliceOrNull`): `bun.String.fromJS` →
-    /// `defer str.deref()` → `toUTF8` with the default allocator.
-    /// `bun_core::String` is `Copy` and has NO `Drop`; the RAII spelling of
-    /// Zig's `defer str.deref()` is `OwnedString`. `to_utf8()` refs the
+    /// `bun_core::String` is `Copy` and has NO `Drop`; `OwnedString` provides
+    /// the scope-exit `deref()`. `to_utf8()` refs the
     /// underlying WTFStringImpl (or heap-clones) so the slice survives the
     /// `OwnedString` drop.
     pub fn to_slice_or_null(self, global: &JSGlobalObject) -> JsResult<bun_core::ZigStringSlice> {
@@ -922,7 +908,7 @@ impl JSValue {
         let v = JSC__JSValue__toError_(self);
         if v.is_empty() { None } else { Some(v) }
     }
-    /// Map a JS string value to an enum via the type's `phf` map (Zig `toEnum`).
+    /// Map a JS string value to an enum via the type's `phf` map.
     pub fn to_enum<E: FromJsEnum>(
         self,
         global: &JSGlobalObject,
@@ -959,7 +945,7 @@ impl JSValue {
         }
         self.as_array_buffer(global)
     }
-    /// Generic downcast (`as(comptime T)` in Zig). Dispatches via [`JsClass::from_js`].
+    /// Generic downcast. Dispatches via [`JsClass::from_js`].
     #[inline]
     pub fn as_<T: JsClass>(self) -> Option<*mut T> {
         if !self.is_cell() {
@@ -967,7 +953,7 @@ impl JSValue {
         }
         T::from_js(self)
     }
-    /// `JSValue.asDirect(T)` (JSValue.zig:431) — unchecked-prototype downcast.
+    /// `JSValue.asDirect(T)` — unchecked-prototype downcast.
     /// Caller must have already verified `is_cell()`; dispatches via
     /// [`JsClass::from_js_direct`] (skips the prototype-chain walk that `as_`
     /// performs, so subclasses are *not* matched).
@@ -1007,7 +993,7 @@ impl JSValue {
         self.as_::<T>().map(|p| unsafe { &*p })
     }
     /// `JSValue.asPromise()` — downcast to `JSPromise` (matches `JSInternalPromise` too).
-    /// Returns a raw pointer (mirrors Zig `?*JSPromise`); conjuring a
+    /// Returns a raw pointer; conjuring a
     /// `&'static mut` here would permit aliased `&mut` UB across two calls on
     /// the same value (PORTING.md §Forbidden).
     pub fn as_promise(self) -> Option<*mut JSPromise> {
@@ -1018,7 +1004,7 @@ impl JSValue {
         if p.is_null() { None } else { Some(p) }
     }
     /// `JSValue.asInternalPromise()` — downcast to `JSInternalPromise`.
-    /// Returns a raw pointer (mirrors Zig `?*JSInternalPromise`); see
+    /// Returns a raw pointer; see
     /// [`as_promise`] for the aliasing rationale.
     pub fn as_internal_promise(self) -> Option<*mut JSInternalPromise> {
         if !self.is_cell() {
@@ -1031,7 +1017,7 @@ impl JSValue {
         if !self.is_cell() {
             return None;
         }
-        // JSValue.zig:657 — check internal FIRST (JSInternalPromise extends JSPromise,
+        // Check internal FIRST (JSInternalPromise extends JSPromise,
         // so `asPromise` would also match it and misclassify).
         let p = JSC__JSValue__asInternalPromise(self);
         if !p.is_null() {
@@ -1082,7 +1068,7 @@ impl JSValue {
 // Property access.
 // ──────────────────────────────────────────────────────────────────────────
 impl JSValue {
-    /// `JSValue.fastGet(global, BuiltinName)` (JSValue.zig:1414) — property
+    /// `JSValue.fastGet(global, BuiltinName)` — property
     /// lookup using a preallocated `JSC::Identifier` (avoids allocating a key
     /// string). `self` must be known to be an object.
     pub fn fast_get(
@@ -1094,7 +1080,7 @@ impl JSValue {
         let v = host_fn::from_js_host_call_generic(global, || {
             JSC__JSValue__fastGet(self, global, builtin_name as u8)
         })?;
-        // JSValue.zig:1424 — `.property_does_not_exist_on_object` (0x4) and
+        // `.property_does_not_exist_on_object` (0x4) and
         // `.js_undefined` map to None; `.zero` ⇒ exception (handled above).
         if v.0 == JSValue::PROPERTY_DOES_NOT_EXIST.0 || v.is_undefined() {
             Ok(None)
@@ -1103,7 +1089,7 @@ impl JSValue {
         }
     }
 
-    /// Spec JSValue.zig `implementsToString` — safe to use on any JSValue.
+    /// Safe to use on any JSValue.
     /// Returns true iff the value is an object whose `toString` property is a callable cell.
     pub fn implements_to_string(self, global: &JSGlobalObject) -> JsResult<bool> {
         if !self.is_object() {
@@ -1122,8 +1108,8 @@ impl JSValue {
         property: impl AsRef<[u8]>,
     ) -> JsResult<Option<JSValue>> {
         let property = property.as_ref();
-        // Spec (JSValue.zig:1536-1540) only routes to `fastGet` when the key is
-        // *comptime-known*. A runtime byte-slice match here is wrong because
+        // Never route a runtime key to `fastGet`: a runtime byte-slice match
+        // here is wrong because
         // C++ `builtinNameMap` maps e.g. `asyncIterator` → `Symbol.asyncIterator`
         // (and `inspectCustom` → `Symbol.for("nodejs.util.inspect.custom")`), so
         // a dynamic `b"asyncIterator"` would fetch the *symbol* property instead
@@ -1138,7 +1124,7 @@ impl JSValue {
                 property.len(),
             )
         }?;
-        // JSValue.zig:1545 — `.property_does_not_exist_on_object` (encoded 0x4 = ValueDeleted)
+        // `.property_does_not_exist_on_object` (encoded 0x4 = ValueDeleted)
         // and `.js_undefined` map to None. `.zero` ⇒ exception (handled above).
         if v.0 == JSValue::PROPERTY_DOES_NOT_EXIST.0 || v.is_undefined() {
             Ok(None)
@@ -1158,12 +1144,12 @@ impl JSValue {
         global: &JSGlobalObject,
         property: impl AsRef<[u8]>,
     ) -> JsResult<Option<JSValue>> {
-        // JSValue.zig:1625 truthyPropertyValue: filters undef/null AND empty strings.
+        // Filters undef/null AND empty strings.
         Ok(self
             .get(global, property)?
             .filter(|v| !v.is_empty_or_undefined_or_null() && !(v.is_string() && !v.to_boolean())))
     }
-    /// JSValue.zig:1649 `getTruthyComptime` — `fast_get` (precached `JSC::Identifier`,
+    /// `fast_get` (precached `JSC::Identifier`,
     /// no StringImpl alloc / atom-table probe) followed by the same `truthyPropertyValue`
     /// filter as `get_truthy`. Use this when the property name is a `BuiltinName`.
     pub fn fast_get_truthy(
@@ -1171,12 +1157,12 @@ impl JSValue {
         global: &JSGlobalObject,
         builtin_name: BuiltinName,
     ) -> JsResult<Option<JSValue>> {
-        // JSValue.zig:1625 truthyPropertyValue: filters undef/null AND empty strings.
+        // Filters undef/null AND empty strings.
         Ok(self
             .fast_get(global, builtin_name)?
             .filter(|v| !v.is_empty_or_undefined_or_null() && !(v.is_string() && !v.to_boolean())))
     }
-    /// JSValue.zig:1866 `getBooleanLoose` — missing/undefined → `None`; otherwise
+    /// Missing/undefined → `None`; otherwise
     /// truthy-coerce the property value (never throws on the coercion itself).
     pub fn get_boolean_loose(
         self,
@@ -1191,7 +1177,7 @@ impl JSValue {
         property: impl AsRef<[u8]>,
     ) -> JsResult<Option<bun_core::String>> {
         let property = property.as_ref();
-        // JSValue.zig:1682 `getStringish` — `get(prop)`, filter null/false → None,
+        // `get(prop)`, filter null/false → None,
         // reject symbols, otherwise coerce via `toBunString` and filter "" → None.
         let Some(prop) = self.get(global, property)? else {
             return Ok(None);
@@ -1200,9 +1186,9 @@ impl JSValue {
             return Ok(None);
         }
         if prop.is_symbol() {
-            // JSValue.zig:1693 — `throwInvalidPropertyTypeValue(property, "string", prop)`
+            // `throwInvalidPropertyTypeValue(property, "string", prop)`
             // (Node-style ERR_INVALID_ARG_TYPE TypeError including received value's type).
-            // PORT NOTE: routed via `throw_invalid_arguments` until
+            // Note: routed via `throw_invalid_arguments` until
             // `JSGlobalObject::throw_invalid_property_type_value` is ported.
             return Err(global.throw_invalid_arguments(format_args!(
                 "The \"{}\" property must be of type string. Received a symbol",
@@ -1212,10 +1198,9 @@ impl JSValue {
         let s = prop.to_bun_string(global)?;
         if s.is_empty() { Ok(None) } else { Ok(Some(s)) }
     }
-    /// JSValue.zig `getOptional(ZigString.Slice, ...)` — own/prototype lookup,
+    /// Own/prototype lookup,
     /// `null`/`undefined` → `None`, non-string → `ERR_INVALID_ARG_TYPE`,
-    /// otherwise return the UTF-8 slice (spec: `coerceOptional` checks
-    /// `prop.isString()` before `toSlice`).
+    /// otherwise return the UTF-8 slice.
     pub fn get_optional_slice(
         self,
         global: &JSGlobalObject,
@@ -1232,8 +1217,7 @@ impl JSValue {
             _ => Ok(None),
         }
     }
-    /// JSValue.zig:1824 `getFunction` — `getOptional(JSValue)` (filters
-    /// undefined/null), then non-callable throws "{prop} must be a function".
+    /// Filters undefined/null; non-callable throws "{prop} must be a function".
     pub fn get_function(
         self,
         global: &JSGlobalObject,
@@ -1254,7 +1238,7 @@ impl JSValue {
         }
         Ok(Some(v))
     }
-    /// JSValue.zig:1873 `getBooleanStrict` — missing/undefined → `None`;
+    /// Missing/undefined → `None`;
     /// boolean → `Some(b)`; anything else throws `ERR_INVALID_ARG_TYPE`.
     pub fn get_boolean_strict(
         self,
@@ -1273,10 +1257,9 @@ impl JSValue {
         }
         Err(global.throw_invalid_property_type(property, "boolean", prop))
     }
-    /// JSValue.zig:1703 `toEnumFromMap` — validates `is_string`, looks up via
-    /// the supplied phf map, throws "must be one of …" on miss. The Zig
-    /// `one_of` list is a comptime concat over `enumFieldNames`; Rust callers
-    /// pass a `'static` literal.
+    /// Validates `is_string`, looks up via the supplied phf map, throws
+    /// "must be one of …" on miss. Callers pass `one_of` as a `'static`
+    /// literal.
     pub fn to_enum_from_map<E: Copy>(
         self,
         global: &JSGlobalObject,
@@ -1297,7 +1280,7 @@ impl JSValue {
             ))),
         }
     }
-    /// JSValue.zig:1748 `getOptionalEnum` — `get(prop)`, filter
+    /// `get(prop)`, filter
     /// undefined/null → `None`, otherwise `toEnum` (dispatches via
     /// `FromJsEnum`).
     pub fn get_optional_enum<E: FromJsEnum>(
@@ -1312,7 +1295,7 @@ impl JSValue {
             _ => Ok(None),
         }
     }
-    /// JSValue.zig:1748 `getOptionalEnum` — `get(prop)`, filter
+    /// `get(prop)`, filter
     /// undefined/null → `None`, otherwise `toEnum` (via `to_enum_from_map`).
     pub fn get_optional_enum_from_map<E: Copy>(
         self,
@@ -1337,7 +1320,7 @@ impl JSValue {
         property: impl AsRef<[u8]>,
     ) -> JsResult<Option<JSValue>> {
         let property = property.as_ref();
-        // JSValue.zig:1784 `getArray` → `coerceToArray`: `get(prop)`, require
+        // `get(prop)`, require
         // `jsTypeLoose().isArray()` (numbers map to NumberObject — never an
         // array — so the cell guard is sufficient), then filter empty arrays.
         let Some(prop) = self.get(global, property)? else {
@@ -1347,7 +1330,6 @@ impl JSValue {
             return Ok(None);
         }
         if !prop.is_cell() || !prop.js_type().is_array() {
-            // JSValue.zig:1785-1787 — `property_name ++ " must be an array"` via throwInvalidArguments.
             return Err(global.throw_invalid_arguments(format_args!(
                 "{} must be an array",
                 bstr::BStr::new(property),
@@ -1366,8 +1348,7 @@ impl JSValue {
         let v = JSC__JSValue__getOwnByValue(self, global, property_value);
         if v.is_empty() { None } else { Some(v) }
     }
-    /// `Object.hasOwnProperty(key)` (Zig: `JSValue.hasOwnPropertyValue`,
-    /// JSValue.zig:793). `self` **must** be an object — the C++ side
+    /// `Object.hasOwnProperty(key)`. `self` **must** be an object — the C++ side
     /// `uncheckedDowncast`s. `key.toPropertyKey()` and Proxy `ownKeys` traps
     /// can throw, so this is routed through `from_js_host_call_generic`.
     #[track_caller]
@@ -1376,8 +1357,8 @@ impl JSValue {
             JSC__JSValue__hasOwnPropertyValue(self, global, key)
         })
     }
-    /// `Function.prototype.bind` (Zig: `JSValue.bind`, JSValue.zig:2448 →
-    /// `Bun__JSValue__bind`, bindings.cpp:6305). Creates a bound-function
+    /// `Function.prototype.bind` (via `Bun__JSValue__bind`,
+    /// bindings.cpp:6305). Creates a bound-function
     /// object whose `name`/`length` are fixed up to the supplied values; `args`
     /// are prepended to the eventual call's argument list. C++ is annotated
     /// `[[ZIG_EXPORT(zero_is_throw)]]`, so `0` ↔ pending exception.
@@ -1421,14 +1402,13 @@ impl JSValue {
         if len == f64::MAX {
             return Ok(0);
         }
-        // JSValue.zig:2181 — clamps to `std.math.maxInt(i52)` (2^51 − 1), not MAX_SAFE_INTEGER.
+        // Clamps to i52 max (2^51 − 1), not MAX_SAFE_INTEGER.
         const I52_MAX: i64 = (1i64 << 51) - 1;
         Ok(len.clamp(0.0, I52_MAX as f64) as u64)
     }
-    /// `JSValue.put` (JSValue.zig:366) — `key: anytype` dispatches on type at
-    /// comptime to `putZigString`/`putBunString`. Rust ports the dispatch via
-    /// the [`PutKey`] trait so callers may pass `&[u8]`, `ZigString`,
-    /// `&ZigString`, `bun.String`, or `&bun.String` exactly as in Zig.
+    /// Set a property. Key dispatch goes through the [`PutKey`] trait so
+    /// callers may pass `&[u8]`, `ZigString`, `&ZigString`, `bun.String`, or
+    /// `&bun.String`.
     pub fn put<K: PutKey>(self, global: &JSGlobalObject, key: K, value: JSValue) {
         key.put(self, global, value)
     }
@@ -1468,16 +1448,16 @@ impl JSValue {
         }
         Ok(())
     }
-    /// `JSValue.deleteProperty` (JSValue.zig:334) — delete an own property by name.
+    /// `JSValue.deleteProperty` — delete an own property by name.
     pub fn delete_property(self, global: &JSGlobalObject, key: impl AsRef<[u8]>) -> bool {
         let zs = bun_core::ZigString::init(key.as_ref());
         JSC__JSValue__deleteProperty(self, global, &zs)
     }
-    /// `JSValue.putBunString` (JSValue.zig:353).
+    /// `JSValue.putBunString`.
     pub fn put_bun_string(self, global: &JSGlobalObject, key: &bun_core::String, value: JSValue) {
         JSC__JSValue__putBunString(self, global, key, value)
     }
-    /// `JSValue.putMayBeIndex` (JSValue.zig:389) — same as [`put`] but accepts
+    /// `JSValue.putMayBeIndex` — same as [`put`] but accepts
     /// both non-numeric and numeric keys. Prefer [`put`] when the key is
     /// guaranteed non-numeric.
     pub fn put_may_be_index(
@@ -1502,10 +1482,9 @@ impl JSValue {
     }
     #[track_caller]
     pub fn put_index(self, global: &JSGlobalObject, i: u32, out: JSValue) -> JsResult<()> {
-        // Zig: `fromJSHostCallGeneric` (== `call_check_slow`).
         crate::call_check_slow(global, || JSC__JSValue__putIndex(self, global, i, out))
     }
-    /// `JSValue.putBunStringOneOrArray` (JSValue.zig) — put `key`/`value` into
+    /// `JSValue.putBunStringOneOrArray` — put `key`/`value` into
     /// `self`. If `key` is already present on the object, create an array for
     /// the values (used by FrameworkRouter catch-all params).
     pub fn put_bun_string_one_or_array(
@@ -1519,14 +1498,13 @@ impl JSValue {
         })
     }
 
-    /// `JSValue.push` (JSValue.zig:404) — append to an array-typed JS value.
+    /// `JSValue.push` — append to an array-typed JS value.
     #[track_caller]
     pub fn push(self, global: &JSGlobalObject, out: JSValue) -> JsResult<()> {
-        // Zig: `fromJSHostCallGeneric` (== `call_check_slow`).
         crate::call_check_slow(global, || JSC__JSValue__push(self, global, out))
     }
 
-    /// `JSValue.getOptionalInt` (JSValue.zig:1896) — typed integer property
+    /// `JSValue.getOptionalInt` — typed integer property
     /// fetch with `validateIntegerRange` clamping. Returns `None` if the
     /// property is absent.
     pub fn get_optional_int<T: bun_core::Integer>(
@@ -1555,7 +1533,7 @@ impl JSValue {
         JSArrayIterator::init(self, global)
     }
 
-    /// `JSValue.jsonStringify` (JSValue.zig:1278).
+    /// `JSValue.jsonStringify`.
     pub fn json_stringify(
         self,
         global: &JSGlobalObject,
@@ -1567,7 +1545,7 @@ impl JSValue {
         })
     }
 
-    /// `JSValue.jsonStringifyFast` (JSValue.zig:1287) — `JSON.stringify(this)`
+    /// `JSValue.jsonStringifyFast` — `JSON.stringify(this)`
     /// with no indent / no replacer (fast path used by SQL value binders).
     pub fn json_stringify_fast(
         self,
@@ -1592,7 +1570,6 @@ impl JSValue {
 // ──────────────────────────────────────────────────────────────────────────
 impl JSValue {
     /// Prevents the GC from collecting this value while it's on the stack.
-    /// Mirrors `std.mem.doNotOptimizeAway`.
     #[inline]
     pub fn ensure_still_alive(self) {
         if !self.is_cell() {
@@ -1603,7 +1580,7 @@ impl JSValue {
 
     /// If this value is callable and an `AsyncContextFrame` is currently active,
     /// returns a wrapper that restores that frame when invoked; otherwise
-    /// returns `self` unchanged. Mirrors Zig `JSValue.withAsyncContextIfNeeded`.
+    /// returns `self` unchanged.
     #[inline]
     pub fn with_async_context_if_needed(self, global: &JSGlobalObject) -> JSValue {
         unsafe extern "C" {
@@ -1613,8 +1590,7 @@ impl JSValue {
             ) -> JSValue;
         }
         // No `is_callable()` precondition: `Timer::sleep` passes a Promise here
-        // (Zig spec JSValue.zig:2267 has no assert; the C++ shim returns
-        // non-callables unchanged).
+        // (the C++ shim returns non-callables unchanged).
         AsyncContextFrame__withAsyncContextIfNeeded(global, self)
     }
 
@@ -1637,7 +1613,7 @@ impl JSValue {
         Protected(self)
     }
 
-    /// `JSValue.callWithGlobalThis(global, args)` (JSValue.zig:237) — `call`
+    /// `JSValue.callWithGlobalThis(global, args)` — `call`
     /// with `global` as the receiver.
     #[inline]
     #[track_caller]
@@ -1649,7 +1625,7 @@ impl JSValue {
         self.call(global, global.to_js_value(), args)
     }
 
-    /// `JSValue.call(global, thisValue, args)` (JSValue.zig:249).
+    /// `JSValue.call(global, thisValue, args)`.
     /// Calls `function` with `this_value` as the receiver. Returns
     /// `Err(JsError::Thrown)` if a JS exception was raised.
     #[track_caller]
@@ -1659,7 +1635,7 @@ impl JSValue {
         this_value: JSValue,
         args: &[JSValue],
     ) -> JsResult<JSValue> {
-        // PORT NOTE: debug-only event-loop bookkeeping (JSValue.zig:251-258) is
+        // Note: debug-only event-loop bookkeeping is
         // omitted while VirtualMachine.rs is gated; restore when it un-gates.
         host_fn::from_js_host_call(global, || {
             // SAFETY: `global` is live; `args` is a contiguous slice of valid
@@ -1677,8 +1653,7 @@ pub struct Protected(JSValue);
 impl Protected {
     /// Wrap an **already-protected** value so it is unprotected on drop.
     /// Unlike [`JSValue::protected`], this does *not* bump the protect
-    /// refcount — use when adopting a `protect()` taken elsewhere (the
-    /// Rust spelling of Zig's bare `defer value.unprotect()`).
+    /// refcount — use when adopting a `protect()` taken elsewhere.
     #[inline]
     pub fn adopt(value: JSValue) -> Self {
         Self(value)
@@ -1695,17 +1670,15 @@ impl Drop for Protected {
     }
 }
 
-// `JSValue.Hash` (Zig: `std.hash_map` Context adapter) is just
-// `core::hash::Hash` in Rust — hash the raw encoded bit-pattern. Callers that
-// want wyhash supply it as the map's `BuildHasher`, not via a Zig-style
-// context struct.
+// Hash the raw encoded bit-pattern. Callers that want wyhash supply it as
+// the map's `BuildHasher`.
 impl core::hash::Hash for JSValue {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.0.hash(state)
     }
 }
 
-// ── `JSValue::from(T)` blanket constructors (Zig: anytype dispatch) ───────
+// ── `JSValue::from(T)` blanket constructors ───────
 impl From<bool> for JSValue {
     #[inline]
     fn from(b: bool) -> Self {
@@ -1748,34 +1721,29 @@ impl From<usize> for JSValue {
 }
 
 impl JSValue {
-    /// `JSValue.asEncoded` (JSValue.zig:967) — view the encoded word as the
+    /// `JSValue.asEncoded` — view the encoded word as the
     /// `EncodedJSValue` C union (used by the FFI fast-paths in `bun:ffi`).
     #[inline]
     pub fn as_encoded(self) -> ffi::EncodedJSValue {
         ffi::EncodedJSValue { as_js_value: self }
     }
 
-    /// `JSValue.fromAny(global, T, value)` (JSValue.zig:2351) — generic
-    /// value→JSValue conversion. Zig reflected over `@TypeOf(value)`; in Rust
-    /// the dispatch is via [`FromAny`], implemented for each supported leaf
-    /// type. Slice / struct reflection is handled by per-element impls instead
-    /// of comptime recursion.
+    /// Generic value→JSValue conversion. Dispatch is via [`FromAny`],
+    /// implemented for each supported leaf type.
     #[inline]
     pub fn from_any<T: FromAny>(global: &JSGlobalObject, value: T) -> JsResult<JSValue> {
         value.into_js_value(global)
     }
 }
 
-/// Dispatch trait for [`JSValue::from_any`]. Zig used a comptime
-/// `@TypeOf`/`@typeInfo` switch (JSValue.zig:2351); in Rust each supported
-/// leaf type implements this trait directly.
+/// Dispatch trait for [`JSValue::from_any`]. Each supported leaf type
+/// implements this trait directly.
 pub trait FromAny {
     fn into_js_value(self, global: &JSGlobalObject) -> JsResult<JSValue>;
 }
 
-/// Primitive numeric / boolean / `JSValue` arms of the Zig `fromAny` switch
-/// all reduce to the existing `From<T> for JSValue` impls — `global` is unused
-/// for these leaves (Zig: `jsNumberWithType`, `jsBoolean`, identity).
+/// Primitive numeric / boolean / `JSValue` leaves all reduce to the existing
+/// `From<T> for JSValue` impls — `global` is unused.
 macro_rules! from_any_via_from {
     ($($t:ty),* $(,)?) => {$(
         impl FromAny for $t {
@@ -1788,8 +1756,7 @@ macro_rules! from_any_via_from {
 }
 from_any_via_from!(bool, i32, u32, f64, u64, usize, JSValue);
 
-// Zig: `bun.trait.isNumber(Type)` arm — small integers go through
-// `jsNumberWithType` (widened to int32 here; values fit losslessly).
+// Small integers are widened to int32 (values fit losslessly).
 impl FromAny for u8 {
     #[inline]
     fn into_js_value(self, _global: &JSGlobalObject) -> JsResult<JSValue> {
@@ -1803,8 +1770,6 @@ impl FromAny for u16 {
     }
 }
 impl FromAny for &[u16] {
-    /// Zig: `[]const u16` → `createEmptyArray` + `putIndex(.jsNumber(item))`
-    /// (JSValue.zig:2390 — the inline numeric-slice arm).
     fn into_js_value(self, global: &JSGlobalObject) -> JsResult<JSValue> {
         let array = JSValue::create_empty_array(global, self.len())?;
         for (i, &item) in self.iter().enumerate() {
@@ -1821,7 +1786,6 @@ impl FromAny for () {
     }
 }
 impl FromAny for &[u8] {
-    /// Zig: `bun.String.createUTF8ForJS(globalObject, value)`.
     #[inline]
     fn into_js_value(self, global: &JSGlobalObject) -> JsResult<JSValue> {
         bun_string_jsc::create_utf8_for_js(global, self)
@@ -1834,8 +1798,7 @@ impl FromAny for &str {
     }
 }
 impl FromAny for Box<[bun_core::String]> {
-    /// Zig: `[]const bun.String` arm (JSValue.zig:2378) — `bun.String.toJSArray`
-    /// then `defer { for (value) |out| out.deref(); free(value); }`. The boxed
+    /// The boxed
     /// slice is consumed: every element's WTF refcount is dropped and the
     /// backing allocation freed via `Box` drop. `bun_core::String` is `Copy`
     /// with no `Drop`, so the explicit `deref()` loop is required.
@@ -1848,7 +1811,7 @@ impl FromAny for Box<[bun_core::String]> {
     }
 }
 impl<T: FromAny> FromAny for Option<T> {
-    /// Zig: `if (@typeInfo(T) == .optional) ...` — `null` → `undefined`.
+    /// `None` → `undefined`.
     #[inline]
     fn into_js_value(self, global: &JSGlobalObject) -> JsResult<JSValue> {
         match self {
@@ -1858,10 +1821,8 @@ impl<T: FromAny> FromAny for Option<T> {
     }
 }
 
-/// Dispatch trait for [`JSValue::put`]'s `key: anytype` parameter
-/// (JSValue.zig:366). Zig used `@typeInfo` to route `ZigString`/`bun.String`/
-/// `[]const u8` to the matching FFI; Rust expresses that as a trait per
-/// PORTING.md §Comptime reflection.
+/// Dispatch trait for [`JSValue::put`]'s key parameter: routes
+/// `ZigString`/`bun.String`/byte-slice keys to the matching FFI.
 pub trait PutKey {
     fn put(self, target: JSValue, global: &JSGlobalObject, value: JSValue);
 }
@@ -1909,13 +1870,13 @@ impl PutKey for &str {
     }
 }
 
-/// Dispatch trait for `JSValue::coerce::<T>()`. Zig used a comptime type switch.
+/// Dispatch trait for `JSValue::coerce::<T>()`.
 pub trait CoerceTo: Sized {
     fn coerce_from(v: JSValue, global: &JSGlobalObject) -> JsResult<Self>;
 }
 impl CoerceTo for i32 {
     fn coerce_from(v: JSValue, global: &JSGlobalObject) -> JsResult<i32> {
-        // JSValue.zig:163-170 `coerce(i32)` — fast-path numbers via
+        // Fast-path numbers via
         // `coerceJSValueDoubleTruncatingT(i32, num)` (NaN→0, out-of-range
         // saturates to i32 MIN/MAX) BEFORE falling through to the C++
         // `coerceToInt32` (ECMAScript ToInt32 modular wrap) for non-numbers.
@@ -1931,8 +1892,8 @@ impl CoerceTo for i32 {
     }
 }
 
-/// Dispatch trait for `JSValue::to_enum::<E>()`. Zig used `comptime Enum: type`
-/// + a `phf` `Map` decl; the Rust port supplies the map per-enum via this trait.
+/// Dispatch trait for `JSValue::to_enum::<E>()`; the `phf` map is supplied
+/// per-enum via this trait.
 pub trait FromJsEnum: Sized {
     fn from_js_value(
         v: JSValue,
@@ -2135,27 +2096,27 @@ unsafe extern "C" {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Additional ports (JSValue.zig — second tranche).
+// Additional bindings.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `JSValue.ProxyInternalField` (JSValue.zig:2320).
+/// `JSValue.ProxyInternalField`.
 #[repr(u32)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProxyField {
     Target = 0,
     Handler = 1,
 }
-/// Zig spelling.
+/// Alias kept for binding-name compatibility.
 pub type ProxyInternalField = ProxyField;
 
-/// `JSValue.SerializedFlags` (JSValue.zig:2303).
+/// `JSValue.SerializedFlags`.
 #[derive(Debug, Default, Clone, Copy)]
 pub struct SerializedFlags {
     pub for_cross_process_transfer: bool,
     pub for_storage: bool,
 }
 
-/// `JSValue.SerializedScriptValue` (JSValue.zig:2287) — owned view over a
+/// `JSValue.SerializedScriptValue` — owned view over a
 /// `WebCore::SerializedScriptValue` byte buffer. Call `deinit` to free.
 pub struct SerializedScriptValue {
     bytes: *const u8,
@@ -2187,14 +2148,12 @@ struct SerializedScriptValueExternal {
     handle: *mut c_void,
 }
 
-/// Callback signature for [`JSValue::for_each`] / [`JSValue::for_each_with_context`]
-/// (Zig: `*const fn (vm, globalObject, ctx, nextValue) callconv(.c) void`).
+/// Callback signature for [`JSValue::for_each`] / [`JSValue::for_each_with_context`].
 pub type ForEachCallback =
     extern "C" fn(vm: *mut crate::VM, global: &JSGlobalObject, ctx: *mut c_void, next: JSValue);
 
 /// Callback signature for [`JSValue::for_each_property`] /
-/// [`JSValue::for_each_property_non_indexed`]
-/// (Zig: `*const fn (*JSGlobalObject, ?*anyopaque, *ZigString, JSValue, bool, bool) callconv(.c) void`).
+/// [`JSValue::for_each_property_non_indexed`].
 pub(crate) type ForEachPropertyCallback = extern "C" fn(
     global: &JSGlobalObject,
     ctx: *mut c_void,
@@ -2204,7 +2163,7 @@ pub(crate) type ForEachPropertyCallback = extern "C" fn(
     is_private_symbol: bool,
 );
 
-/// `JSValue.StringFormatter` (JSValue.zig:2019) — `Display` adapter that
+/// `JSValue.StringFormatter` — `Display` adapter that
 /// coerces the value via `toBunString` at format time.
 pub struct StringFormatter<'a> {
     value: JSValue,
@@ -2224,7 +2183,7 @@ impl core::fmt::Display for StringFormatter<'_> {
 }
 
 impl JSValue {
-    // ── C-API bridging (JSValue.zig:2230-2247, deprecated in spec). ───────
+    // ── C-API bridging. ───────
     /// `JSValue.c(JSValueRef)` — wrap a C-API `JSValueRef` as a `JSValue`.
     #[inline]
     pub fn c(ptr: crate::C::JSValueRef) -> JSValue {
@@ -2242,7 +2201,7 @@ impl JSValue {
         self.0 as crate::C::JSObjectRef
     }
 
-    // ── Equality / identity (JSValue.zig:1358-1361, 1948). ────────────────
+    // ── Equality / identity. ────────────────
     #[inline]
     pub fn eql_value(self, other: JSValue) -> bool {
         JSC__JSValue__eqlValue(self, other)
@@ -2252,7 +2211,7 @@ impl JSValue {
     /// Differs from IsStrictlyEqual by treating all NaN values as equivalent
     /// and by differentiating +0 from -0. Can throw (rope-string resolution).
     pub fn is_same_value(self, other: JSValue, global: &JSGlobalObject) -> JsResult<bool> {
-        // Identity fast-path (JSValue.zig:1949): same encoded bits ⇒ same value.
+        // Identity fast-path: same encoded bits ⇒ same value.
         if self == other {
             return Ok(true);
         }
@@ -2261,13 +2220,13 @@ impl JSValue {
         })
     }
 
-    // ── Numeric coercion (JSValue.zig:119, 153, 2156). ────────────────────
+    // ── Numeric coercion. ────────────────────
     /// `JSValue.toNumber` — full ECMA `ToNumber` (`+value`); may throw.
     pub fn to_number(self, global: &JSGlobalObject) -> JsResult<f64> {
         host_fn::from_js_host_call_generic(global, || Bun__JSValue__toNumber(self, global))
     }
 
-    /// `JSValue.toPortNumber` (JSValue.zig:211) — Node `validatePort` semantics:
+    /// `JSValue.toPortNumber` — Node `validatePort` semantics:
     /// numeric, non-NaN, integer-truncated `0..=65535`, else `ERR_SOCKET_BAD_PORT`.
     pub fn to_port_number(self, global: &JSGlobalObject) -> JsResult<u16> {
         if self.is_number() {
@@ -2286,20 +2245,20 @@ impl JSValue {
         Err(crate::ErrorCode::SOCKET_BAD_PORT.throw(global, format_args!("Invalid port number")))
     }
 
-    /// `JSValue.coerce(f64)` (JSValue.zig:153) — fast-path doubles, else `ToNumber`.
+    /// `JSValue.coerce(f64)` — fast-path doubles, else `ToNumber`.
     pub fn coerce_f64(self, global: &JSGlobalObject) -> JsResult<f64> {
         if self.is_double() {
             return Ok(self.as_double());
         }
         self.to_number(global)
     }
-    /// `JSValue.toU16` (JSValue.zig:2156) — truncating, clamped-at-zero.
+    /// `JSValue.toU16` — truncating, clamped-at-zero.
     #[inline]
     pub fn to_u16(self) -> u16 {
         (self.to_int32().max(0) as u32) as u16
     }
 
-    // ── Object / cell views (JSValue.zig:1164, 1331, 1354). ───────────────
+    // ── Object / cell views. ───────────────
     /// Statically cast to a `JSCell*`; `None` for non-cells.
     #[inline]
     pub fn to_cell(self) -> Option<*mut crate::JSCell> {
@@ -2318,7 +2277,7 @@ impl JSValue {
             Ok(p)
         }
     }
-    /// `JSValue.unwrapBoxedPrimitive` (JSValue.zig:1343) — unwraps Number,
+    /// `JSValue.unwrapBoxedPrimitive` — unwraps Number,
     /// Boolean, String, and BigInt objects to their primitive forms.
     pub fn unwrap_boxed_primitive(self, global: &JSGlobalObject) -> JsResult<JSValue> {
         host_fn::from_js_host_call(global, || JSC__JSValue__unwrapBoxedPrimitive(global, self))
@@ -2328,7 +2287,7 @@ impl JSValue {
         JSC__JSValue__getPrototype(self, global)
     }
 
-    // ── Reflection / naming (JSValue.zig:1128, 1136, 1515). ───────────────
+    // ── Reflection / naming. ───────────────
     /// `JSValue.getName` — function/class display name.
     pub fn get_name(self, global: &JSGlobalObject) -> JsResult<bun_core::String> {
         let mut ret = bun_core::String::default();
@@ -2360,7 +2319,7 @@ impl JSValue {
         JSC__JSValue__symbolFor(global, key)
     }
 
-    // ── Property access (JSValue.zig:328, 1578). ──────────────────────────
+    // ── Property access. ──────────────────────────
     /// `JSValue.putZigString` — `JSC__JSValue__put` keyed by an existing
     /// `ZigString` (avoids the temporary in [`JSValue::put`]).
     pub fn put_zig_string(
@@ -2377,7 +2336,6 @@ impl JSValue {
         global: &JSGlobalObject,
         property_name: &bun_core::String,
     ) -> JsResult<Option<JSValue>> {
-        // Zig (JSValue.zig:1578): manual `TopExceptionScope` + `returnIfException`.
         crate::top_scope!(scope, global);
         let v = JSC__JSValue__getOwn(self, global, property_name);
         scope.return_if_exception()?;
@@ -2396,7 +2354,7 @@ impl JSValue {
         }
     }
     /// `JSValue.getOwnObject` — own-property lookup; throws "{prop} must be an
-    /// object" when the own-truthy value is not an object (JSValue.zig:1812).
+    /// object" when the own-truthy value is not an object.
     pub fn get_own_object(
         self,
         global: &JSGlobalObject,
@@ -2415,7 +2373,7 @@ impl JSValue {
         }
     }
     /// `JSValue.getOwnArray` — own-property lookup (no prototype walk) routed
-    /// through `coerceToArray` (JSValue.zig:1784): non-array truthy → throw
+    /// through `coerceToArray`: non-array truthy → throw
     /// "{prop} must be an array"; empty array → `None`.
     pub fn get_own_array(
         self,
@@ -2445,7 +2403,7 @@ impl JSValue {
         JSC__JSValue__isClass(self, global)
     }
 
-    // ── Iteration (JSValue.zig:2199-2223). ────────────────────────────────
+    // ── Iteration. ────────────────────────────────
     /// `JSValue.isIterable`.
     pub fn is_iterable(self, global: &JSGlobalObject) -> JsResult<bool> {
         host_fn::from_js_host_call_generic(global, || JSC__JSValue__isIterable(self, global))
@@ -2461,8 +2419,8 @@ impl JSValue {
             JSC__JSValue__forEach(self, global, ctx, callback)
         })
     }
-    /// `JSValue.forEachWithContext` — typed-ctx wrapper (Zig erased the ctx
-    /// type via `@ptrCast`; callers here pass `*mut c_void` directly).
+    /// `JSValue.forEachWithContext` — typed-ctx wrapper (callers pass
+    /// `*mut c_void` directly).
     #[inline]
     pub fn for_each_with_context(
         self,
@@ -2472,12 +2430,11 @@ impl JSValue {
     ) -> JsResult<()> {
         self.for_each(global, ctx, callback)
     }
-    /// `JSValue.forEachProperty` (JSValue.zig:96) — enumerate own props,
+    /// `JSValue.forEachProperty` — enumerate own props,
     /// invoking `callback` per (key, value, is_symbol, is_private_symbol).
     ///
-    /// Mirrors the Zig codegen wrapper shape (cpp.zig `check_slow`): seat the
-    /// exception scope and call the FFI directly so the deep `print_as`
-    /// recursion does not pay an extra closure frame per object level.
+    /// Seats the exception scope and calls the FFI directly so the deep
+    /// `print_as` recursion does not pay an extra closure frame per object level.
     #[inline(always)]
     pub fn for_each_property(
         self,
@@ -2501,7 +2458,7 @@ impl JSValue {
         JSC__JSValue__forEachProperty(self, global, ctx, callback);
         scope.return_if_exception()
     }
-    /// `JSValue.forEachPropertyNonIndexed` (JSValue.zig:87) — like
+    /// `JSValue.forEachPropertyNonIndexed` — like
     /// [`for_each_property`](Self::for_each_property) but skips array-index
     /// keys.
     pub fn for_each_property_non_indexed(
@@ -2523,7 +2480,7 @@ impl JSValue {
         JSC__JSValue__forEachPropertyNonIndexed(self, global, ctx, callback);
         scope.return_if_exception()
     }
-    /// `JSValue.forEachPropertyOrdered` (JSValue.zig:105) — like
+    /// `JSValue.forEachPropertyOrdered` — like
     /// [`for_each_property`](Self::for_each_property) but visits keys in
     /// stable enumeration order (used by `console.log` with
     /// `ordered_properties`).
@@ -2551,7 +2508,7 @@ impl JSValue {
         unsafe { crate::TopExceptionScope::destroy(scope) };
         result
     }
-    /// `JSValue.isBuffer` (JSValue.zig:492) — `instanceof Buffer` check via
+    /// `JSValue.isBuffer` — `instanceof Buffer` check via
     /// the C++ `JSBuffer__isBuffer` shim. Accepts any JSValue; the C++ side
     /// handles non-cells (returns false), so no precondition is asserted.
     pub fn is_buffer(self, global: &JSGlobalObject) -> bool {
@@ -2560,7 +2517,7 @@ impl JSValue {
         }
         JSBuffer__isBuffer(global, self)
     }
-    /// `JSValue.getDirectIndex` (JSValue.zig:65) — read the `i`th indexed
+    /// `JSValue.getDirectIndex` — read the `i`th indexed
     /// own-property slot directly (no prototype walk, no getters). Returns
     /// the empty value for holes.
     pub fn get_direct_index(self, global: &JSGlobalObject, i: u32) -> JSValue {
@@ -2573,7 +2530,7 @@ impl JSValue {
         }
         JSC__JSValue__getDirectIndex(self, global, i)
     }
-    /// `JSValue.getNameProperty` (JSValue.zig:1119) — write the value's
+    /// `JSValue.getNameProperty` — write the value's
     /// `.name` (function/class name) into `ret`. No-op for empty/`undefined`/`null`.
     pub fn get_name_property(
         self,
@@ -2595,14 +2552,14 @@ impl JSValue {
         })
     }
 
-    // ── Proxy internals (JSValue.zig:2326). ───────────────────────────────
+    // ── Proxy internals. ───────────────────────────────
     /// Asserts `self` is a `Proxy`.
     pub fn get_proxy_internal_field(self, field: ProxyField) -> JSValue {
         debug_assert!(self.is_cell() && self.js_type() == JSType::ProxyObject);
         Bun__ProxyObject__getInternalField(self, field as u32)
     }
 
-    // ── Formatting (JSValue.zig:2030). ────────────────────────────────────
+    // ── Formatting. ────────────────────────────────────
     #[inline]
     pub fn fmt_string(self, global: &JSGlobalObject) -> StringFormatter<'_> {
         StringFormatter {
@@ -2611,14 +2568,13 @@ impl JSValue {
         }
     }
 
-    /// `JSValue.toFmt(formatter)` (JSValue.zig:2037) — reset `formatter` for a
+    /// `JSValue.toFmt(formatter)` — reset `formatter` for a
     /// fresh top-level format of `self` and return a `Display` adapter.
     ///
-    /// The Zig spec also called `formatter.deinit()` when `map_node != null`
-    /// (releasing the visited-pool node mid-flight); the Rust `Formatter` runs
-    /// that logic in `Drop`, so reusing a formatter that already owns a
-    /// `map_node` is handled at end-of-scope instead. All current callers pass
-    /// a freshly-constructed formatter (`map_node == None`).
+    /// The `Formatter` releases any owned `map_node` in `Drop`, so reusing a
+    /// formatter that already owns a `map_node` is handled at end-of-scope.
+    /// All current callers pass a freshly-constructed formatter
+    /// (`map_node == None`).
     pub fn to_fmt<'a, 'b>(
         self,
         formatter: &'a mut crate::console_object::Formatter<'b>,
@@ -2628,7 +2584,7 @@ impl JSValue {
         crate::console_object::formatter::ZigFormatter::new(formatter, self)
     }
 
-    // ── Next-tick scheduling (JSValue.zig:275). ───────────────────────────
+    // ── Next-tick scheduling. ───────────────────────────
     /// `JSValue.callNextTick(global, .{arg})` for the 1-arg case.
     pub fn call_next_tick_1(
         function: JSValue,
@@ -2640,7 +2596,7 @@ impl JSValue {
         })
     }
 
-    // ── Structured clone (JSValue.zig:2279, 2309). ────────────────────────
+    // ── Structured clone. ────────────────────────
     /// `JSValue.deserialize(bytes, global)`.
     pub fn deserialize(bytes: &[u8], global: &JSGlobalObject) -> JsResult<JSValue> {
         // SAFETY: `global` is live; `bytes` valid for the call.
@@ -2733,13 +2689,13 @@ unsafe extern "C" {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Jest / test-runner support (JSValue.zig — `jestDeepEquals` family,
+// Jest / test-runner support (`jestDeepEquals` family,
 // `asBigIntCompare`, `keys`/`values`, `isInstanceOf`, `isConstructor`,
 // `isObjectEmpty`, `getIfPropertyExistsFromPath`, `stringIncludes`,
-// `toMatch`). Third tranche, ported for `bun_runtime::test_runner::expect`.
+// `toMatch`). Used by `bun_runtime::test_runner::expect`.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `JSValue.ComparisonResult` (JSValue.zig:923) — result of
+/// `JSValue.ComparisonResult` — result of
 /// [`JSValue::as_big_int_compare`].
 #[repr(u8)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -2752,7 +2708,7 @@ pub enum ComparisonResult {
 }
 
 impl JSValue {
-    // ── Jest deep-equality (JSValue.zig:1957-1975). ───────────────────────
+    // ── Jest deep-equality. ───────────────────────
     /// `JSValue.jestDeepEquals` — Jest's recursive `expect(a).toEqual(b)`
     /// semantics (asymmetric matchers, undefined-equals-missing, etc.).
     pub fn jest_deep_equals(self, other: JSValue, global: &JSGlobalObject) -> JsResult<bool> {
@@ -2788,7 +2744,7 @@ impl JSValue {
         })
     }
 
-    // ── BigInt ordering (JSValue.zig:931). ────────────────────────────────
+    // ── BigInt ordering. ────────────────────────────────
     /// `JSValue.asBigIntCompare` — compare a BigInt against another BigInt or
     /// Number. Returns [`ComparisonResult::InvalidComparison`] if `self` is
     /// not a BigInt or `other` is neither BigInt nor Number.
@@ -2799,7 +2755,7 @@ impl JSValue {
         JSC__JSValue__asBigIntCompare(self, global, other)
     }
 
-    // ── Object.keys / Object.values (JSValue.zig:767-786). ────────────────
+    // ── Object.keys / Object.values. ────────────────
     /// `JSValue.keys` — `Object.keys(self)`.
     pub fn keys(self, global: &JSGlobalObject) -> JsResult<JSValue> {
         host_fn::from_js_host_call(global, || JSC__JSValue__keys(global, self))
@@ -2811,7 +2767,7 @@ impl JSValue {
         host_fn::from_js_host_call(global, || JSC__JSValue__values(global, self))
     }
 
-    // ── instanceof / constructor (JSValue.zig:229, 1113). ─────────────────
+    // ── instanceof / constructor. ─────────────────
     /// `JSValue.isInstanceOf` — `self instanceof constructor`.
     pub fn is_instance_of(self, global: &JSGlobalObject, constructor: JSValue) -> JsResult<bool> {
         if !self.is_cell() {
@@ -2830,7 +2786,7 @@ impl JSValue {
         JSC__JSValue__isConstructor(self)
     }
 
-    // ── Jest "is empty object" (JSValue.zig:1097). ────────────────────────
+    // ── Jest "is empty object". ────────────────────────
     /// `JSValue.isObjectEmpty` — Jest-extended `toBeEmptyObject` semantics:
     /// Map/Set/RegExp/Date are *not* empty objects; otherwise an object with
     /// zero own-enumerable keys.
@@ -2843,7 +2799,7 @@ impl JSValue {
         Ok(ty.is_object() && self.keys(global)?.get_length(global)? == 0)
     }
 
-    // ── Length introspection (JSValue.zig:2189). ──────────────────────────
+    // ── Length introspection. ──────────────────────────
     /// `JSValue.getLengthIfPropertyExistsInternal` — returns `f64::MAX` when
     /// no `length`-ish property exists. Do not call directly; prefer
     /// [`JSValue::get_length`].
@@ -2853,7 +2809,7 @@ impl JSValue {
         })
     }
 
-    // ── Path lookup (JSValue.zig:1457). ───────────────────────────────────
+    // ── Path lookup. ───────────────────────────────────
     /// `JSValue.getIfPropertyExistsFromPath` — Jest `toHaveProperty` path
     /// resolution (accepts `"a.b[0].c"` string or array path).
     pub fn get_if_property_exists_from_path(
@@ -2861,14 +2817,13 @@ impl JSValue {
         global: &JSGlobalObject,
         path: JSValue,
     ) -> JsResult<JSValue> {
-        // Zig (JSValue.zig:1458): manual `TopExceptionScope` + `returnIfException`.
         crate::top_scope!(scope, global);
         let result = JSC__JSValue__getIfPropertyExistsFromPath(self, global, path);
         scope.return_if_exception()?;
         Ok(result)
     }
 
-    // ── String / RegExp matching (JSValue.zig:1202, 2225). ────────────────
+    // ── String / RegExp matching. ────────────────
     /// `JSValue.stringIncludes` — `self.includes(other)` for JS strings.
     pub fn string_includes(self, global: &JSGlobalObject, other: JSValue) -> JsResult<bool> {
         host_fn::from_js_host_call_generic(global, || {
diff --git a/src/jsc/MarkedArgumentBuffer.rs b/src/jsc/MarkedArgumentBuffer.rs
index 0a7dfea2630..a7520a127f7 100644
--- a/src/jsc/MarkedArgumentBuffer.rs
+++ b/src/jsc/MarkedArgumentBuffer.rs
@@ -8,7 +8,6 @@ bun_opaque::opaque_ffi! {
     pub struct MarkedArgumentBuffer;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn MarkedArgumentBuffer__append(args: &MarkedArgumentBuffer, value: JSValue);
     // safe: `ctx` is an opaque round-trip pointer C++ only forwards to `f`
@@ -23,7 +22,7 @@ unsafe extern "C" {
 impl MarkedArgumentBuffer {
     /// Stack-construct a `MarkedArgumentBuffer` and pass it to `f`. There is no
     /// heap-allocated owning form (the C++ type is non-movable); `new` is a
-    /// scoped-borrow constructor like Zig's `MarkedArgumentBuffer.run`.
+    /// scoped-borrow constructor.
     pub fn new<R>(f: impl FnOnce(&mut MarkedArgumentBuffer) -> R) -> R {
         struct Ctx<F, R> {
             f: Option<F>,
@@ -53,8 +52,8 @@ impl MarkedArgumentBuffer {
     }
 
     pub fn run<T>(ctx: &mut T, func: extern "C" fn(ctx: *mut T, args: *mut MarkedArgumentBuffer)) {
-        // Mirrors Zig `@ptrCast` of both ctx and func — `MarkedArgumentBuffer__run`
-        // round-trips `ctx` opaquely back to `func`, and `func`'s ABI is identical modulo the
+        // `MarkedArgumentBuffer__run` round-trips `ctx` opaquely back to `func`,
+        // and `func`'s ABI is identical modulo the
         // pointee types (both params are thin pointers).
         MarkedArgumentBuffer__run(
             std::ptr::from_mut::<T>(ctx).cast::<c_void>(),
@@ -70,14 +69,8 @@ impl MarkedArgumentBuffer {
     }
 }
 
-/// Port of `MarkedArgumentBuffer.wrap`.
-///
-/// Zig's `wrap` is a `comptime` fn that takes a
-/// `fn(*JSGlobalObject, *CallFrame, *MarkedArgumentBuffer) bun.JSError!JSValue`
-/// and returns a `jsc.JSHostFnZig`. Rust cannot parameterize a `fn` item by a const
+/// Rust cannot parameterize a `fn` item by a const
 /// fn-pointer, so this is a macro that expands to a `#[bun_jsc::host_fn]` wrapper.
-// TODO(port): consider a proc-macro attribute (`#[bun_jsc::with_marked_argument_buffer]`)
-// instead of `macro_rules!` once the host_fn codegen is settled.
 #[macro_export]
 macro_rules! marked_argument_buffer_wrap {
     ($function:path) => {{
@@ -106,7 +99,7 @@ macro_rules! marked_argument_buffer_wrap {
             let mut ctx = Context {
                 global_this,
                 callframe,
-                // PORT NOTE: Zig used `undefined`; init with a placeholder since `run`
+                // Placeholder; `run`
                 // unconditionally overwrites it before we read.
                 result: ::core::result::Result::Ok($crate::JSValue::ZERO),
             };
@@ -116,5 +109,3 @@ macro_rules! marked_argument_buffer_wrap {
         wrapper
     }};
 }
-
-// ported from: src/jsc/MarkedArgumentBuffer.zig
diff --git a/src/jsc/ModuleLoader.rs b/src/jsc/ModuleLoader.rs
index a1e893b93e2..4610d91fbc3 100644
--- a/src/jsc/ModuleLoader.rs
+++ b/src/jsc/ModuleLoader.rs
@@ -1,5 +1,3 @@
-//! Port of `src/jsc/ModuleLoader.zig`.
-//!
 //! The `ModuleLoader` struct, `FetchFlags`, and the `HardcodedModule`
 //! re-export compile against the `lib.rs` stub surface.
 //! `transpile_source_code` / `fetch_builtin_module` / `resolve_embedded_file`
@@ -19,12 +17,11 @@ use crate::{
     JSValue, JsError, JsResult, ResolvedSource,
 };
 
-// Re-exports (thin re-exports from the original Zig file).
+// Re-exports.
 pub use crate::runtime_transpiler_store::RuntimeTranspilerStore;
 pub use bun_resolve_builtins::HardcodedModule;
 pub use bun_resolver::node_fallbacks;
 
-// Spec ModuleLoader.zig:4 — `pub const AsyncModule = @import("./AsyncModule.zig").AsyncModule;`
 // LAYERING: re-export from the crate-level mount (`crate::async_module`)
 // instead of `#[path]`-mounting `AsyncModule.rs` a second time. A duplicate
 // mount compiles two distinct `Queue` types — `VirtualMachine.modules` is
@@ -53,24 +50,28 @@ pub(crate) fn set_is_allowed_to_use_internal_testing_apis(v: bool) {
 impl ModuleLoader {
     /// This must be called after calling transpileSourceCode
     ///
-    /// PORT NOTE: takes only `&mut VirtualMachine` (not `&mut self,
+    /// Takes only `&mut VirtualMachine` (not `&mut self,
     /// &mut VirtualMachine`) — `ModuleLoader` is a value field of
     /// `VirtualMachine`, so passing both would alias (PORTING.md §Forbidden).
     /// Access `module_loader` through `jsc_vm` instead.
     pub fn reset_arena(jsc_vm: &mut VirtualMachine) {
-        // Spec ModuleLoader.zig:24-29: `if (smol) reset() else
-        // reset(.{.retain_with_limit = 8M})`. The port collapses both arms to
-        // `reset()` — `MimallocArena` is not a bump allocator, so there is no
-        // capacity to retain (see `MimallocArena::reset_retain_with_limit`
-        // PORT NOTE); mimalloc's per-thread segment cache already provides the
-        // warm-page reuse Zig's `.retain_with_limit` was after.
+        // PERF: this unconditionally calls `reset()`. Per
+        // `MimallocArena::reset_retain_with_limit`'s doc comment, the
+        // "mimalloc's segment cache keeps pages warm anyway" theory behind
+        // unconditional `reset()` proved wrong (purged pages get re-committed
+        // and re-zeroed each cycle), which is why the cap-gated retain exists
+        // and the other call sites use `reset_retain_with_limit(8 MiB)`.
+        // Switching to the retain-with-limit form (when not in smol mode) is
+        // a perf-sensitive change that
+        // needs benchmarking (transpile arena RSS vs cycle cost), so it is
+        // tracked as a dedicated work order rather than changed inline.
         if let Some(arena) = jsc_vm.module_loader.transpile_source_code_arena.as_mut() {
             arena.reset();
         }
     }
 }
 
-/// RAII shape of Zig's `defer jsc_vm.module_loader.resetArena(jsc_vm)` — calls
+/// RAII guard that calls
 /// [`ModuleLoader::reset_arena`] on the held VM when dropped. Holds a
 /// [`BackRef`] (not `&mut`) so the body of the guarded scope may also reach
 /// into the VM via raw pointers without aliasing the guard; the VM-outlives-
@@ -149,9 +150,9 @@ pub struct TranspileArgs<'a> {
 /// `bun_runtime`) so both tiers agree on layout; every field type is already a
 /// `bun_jsc` dep (`bun_resolver`, `bun_bundler::options`, `bun_js_printer`).
 ///
-/// PORT NOTE: Zig passed these as positional params to `transpileSourceCode`
-/// (ModuleLoader.zig:90-96). They're bundled because the §Dispatch fn-ptr
-/// signature must be stable across the crate boundary.
+/// Bundled into one struct (rather than positional params)
+/// because the §Dispatch fn-ptr signature must be
+/// stable across the crate boundary.
 #[repr(C)]
 pub struct TranspileExtra {
     pub path: bun_resolver::fs::Path<'static>,
@@ -160,13 +161,13 @@ pub struct TranspileExtra {
     /// `*js_printer.BufferPrinter` — the per-VM shared printer. Never null
     /// when `extra` itself is non-null.
     pub source_code_printer: *mut bun_js_printer::BufferPrinter,
-    /// `?*?*jsc.JSInternalPromise` — out-param for the async-module path
-    /// (ModuleLoader.zig:95). Null forbids async resolution.
+    /// `?*?*jsc.JSInternalPromise` — out-param for the async-module path.
+    /// Null forbids async resolution.
     pub promise_ptr: *mut *mut JSInternalPromise,
 }
 
-/// Result of `LoaderHooks::fetch_builtin_module` — tri-state to mirror
-/// ModuleLoader.zig:861-876, where an ERROR during builtin lookup must be
+/// Result of `LoaderHooks::fetch_builtin_module` — tri-state because
+/// an ERROR during builtin lookup must be
 /// surfaced to C++ (return `true` with `ret` populated as `.err`) rather than
 /// falling through to filesystem resolution.
 #[repr(u8)]
@@ -209,7 +210,7 @@ pub struct LoaderHooks {
         out: *mut ResolvedSource,
     ) -> bool,
     /// `ModuleLoader.resolveEmbeddedFile(vm, &path_buf, input_path, "node")`
-    /// (spec ModuleLoader.zig:1332-1342) — extracts an embedded `.node` addon
+    /// — extracts an embedded `.node` addon
     /// from the standalone-module graph to a real on-disk temp file and writes
     /// the resulting path back into `*in_out_str`. Returns `true` on success.
     /// Body lives in `bun_runtime` (reaches into `node::fs` +
@@ -218,7 +219,7 @@ pub struct LoaderHooks {
         unsafe fn(vm: *mut VirtualMachine, in_out_str: *mut bun_core::String) -> bool,
     /// `VirtualMachine.resolveMaybeNeedsTrailingSlash(res, global, specifier,
     /// source, query_string?, is_esm, is_a_file_path, is_user_require_resolve)`
-    /// (spec VirtualMachine.zig:1873-2016) — the resolution path behind
+    /// — the resolution path behind
     /// `Bun__resolveSync` / `Zig__GlobalObject__resolve` / `import.meta.resolve`.
     /// Body reaches into `transpiler.resolver.resolveAndAutoInstall`, the
     /// `PluginRunner`, `ObjectURLRegistry`, and `ServerEntryPoint` (all
@@ -226,7 +227,7 @@ pub struct LoaderHooks {
     ///
     /// Writes `*res` (always — `.ok` or `.err`); writes `*query_string` (if
     /// non-null) to a fresh owned `bun.String`. Returns `false` iff a JS
-    /// exception is pending on `global` (the Zig `bun.JSError!void` shape).
+    /// exception is pending on `global`.
     pub resolve: unsafe fn(
         res: *mut ErrorableString,
         global: *mut JSGlobalObject,
@@ -237,11 +238,11 @@ pub struct LoaderHooks {
         is_a_file_path: bool,
         is_user_require_resolve: bool,
     ) -> bool,
-    /// `Bun__transpileVirtualModule` body (spec ModuleLoader.zig:1234-1304) —
+    /// `Bun__transpileVirtualModule` body —
     /// transpiles plugin-provided source through the per-thread `BufferPrinter`
     /// (a `bun_runtime` thread-local). Writes `*ret` (always — `.ok` or `.err`)
-    /// and returns `true` (the only `false` return in Zig is unreachable here
-    /// because the C++ caller already proved `plugin_runner != null`).
+    /// and always returns `true`
+    /// (the C++ caller already proved `plugin_runner != null`).
     pub transpile_virtual_module: unsafe fn(
         global: *mut JSGlobalObject,
         specifier: *const bun_core::String,
@@ -283,7 +284,7 @@ fn loader_hooks() -> Option<&'static LoaderHooks> {
 }
 
 /// `ModuleLoader.transpileSourceCode(...)` — thin shim over the §Dispatch
-/// hook. PERF(port): was inline switch — direct call in Zig; the indirection
+/// hook. PERF: the indirection
 /// is one fn-ptr per import, dwarfed by the parser/printer work it does.
 pub(crate) fn transpile_source_code(
     jsc_vm: &mut VirtualMachine,
@@ -317,8 +318,8 @@ pub(crate) fn fetch_builtin_module(
 
 /// because the §Dispatch fn-ptr signature must be monomorphic across the crate
 /// boundary. The branch is a single length-check / `dirWithTrailingSlash` —
-/// PERF(port): was inline switch; the fn-ptr indirection is one call per
-/// `import` / `require.resolve`, dominated by the resolver's dir-cache walk.
+/// the fn-ptr indirection is one call per `import` / `require.resolve`,
+/// dominated by the resolver's dir-cache walk.
 pub fn resolve_maybe_needs_trailing_slash(
     res: &mut ErrorableString,
     global: &mut JSGlobalObject,
@@ -338,8 +339,8 @@ pub fn resolve_maybe_needs_trailing_slash(
     let qs = query_string
         .map(std::ptr::from_mut::<bun_core::String>)
         .unwrap_or(core::ptr::null_mut());
-    // SAFETY: hook contract — `global` is the live JS-thread global (Zig
-    // `*JSGlobalObject`, mutable: hook may throw on it); `res`/`qs` are valid
+    // SAFETY: hook contract — `global` is the live JS-thread global
+    // (mutable: hook may throw on it); `res`/`qs` are valid
     // out-params for the call (single-threaded, no aliasing).
     let ok = unsafe {
         (hooks.resolve)(
@@ -362,10 +363,9 @@ pub fn resolve_maybe_needs_trailing_slash(
 /// ModuleLoader.cpp:473) rejects the import promise with a real Error instead
 /// of `undefined`.
 ///
-/// PORT NOTE: previously routed through `LoaderHooks` on the assumption the
-/// body needed `bun_runtime` types; it doesn't — `BuildMessage` /
-/// `ResolveMessage` live in this crate — so the hook slot was dropped and this
-/// forwards to the real impl in [`crate::virtual_machine::process_fetch_log`].
+/// No `LoaderHooks` indirection is needed here — `BuildMessage` /
+/// `ResolveMessage` live in this crate — so this forwards to the real impl in
+/// [`crate::virtual_machine::process_fetch_log`].
 pub fn process_fetch_log(
     global: &JSGlobalObject,
     specifier: bun_core::String,
@@ -404,7 +404,6 @@ pub(crate) unsafe extern "C" fn Bun__transpileFile(
         return core::ptr::null_mut();
     };
     // SAFETY: hook contract — all pointers are valid for the call (C++ ABI).
-    // PERF(port): was inline switch.
     unsafe {
         (hooks.transpile_file)(
             jsc_vm,
@@ -440,7 +439,7 @@ pub(crate) unsafe extern "C" fn Bun__fetchBuiltinModule(
             &mut *ret,
         )
     };
-    // PORT NOTE: spec ModuleLoader.zig:861-876 — when `fetchBuiltinModule`
+    // When `fetchBuiltinModule`
     // ERRORS, it calls `VirtualMachine.processFetchLog(..., ret, err)` and
     // returns **true** (so C++ surfaces the error instead of falling through to
     // filesystem resolution). The hook writes `ret` directly on Found/Errored.
@@ -450,8 +449,8 @@ pub(crate) unsafe extern "C" fn Bun__fetchBuiltinModule(
     }
 }
 
-/// `HardcodedModule.Alias.bun_aliases.get(str)` — linear scan over the
-/// `BUN_ALIASES` const tables (PERF(port): could replace with phf).
+/// Linear scan over the `BUN_ALIASES` const tables (PERF: could replace with
+/// phf).
 #[inline]
 fn bun_aliases_get(name: &[u8]) -> Option<bun_resolve_builtins::Alias> {
     for table in bun_resolve_builtins::HardcodedModule::BUN_ALIASES {
@@ -464,7 +463,7 @@ fn bun_aliases_get(name: &[u8]) -> Option<bun_resolve_builtins::Alias> {
     None
 }
 
-/// Spec ModuleLoader.zig:828-848.
+/// C++ entry point: if `specifier` names a builtin module, writes its resolved source into `ret` and returns `true`.
 #[unsafe(no_mangle)]
 pub(crate) unsafe extern "C" fn Bun__resolveAndFetchBuiltinModule(
     jsc_vm: *mut VirtualMachine,
@@ -496,7 +495,7 @@ pub(crate) unsafe extern "C" fn Bun__resolveAndFetchBuiltinModule(
     true
 }
 
-/// Spec ModuleLoader.zig:1332-1342. Support embedded .node files.
+/// Support embedded .node files.
 #[unsafe(no_mangle)]
 pub(crate) unsafe extern "C" fn Bun__resolveEmbeddedNodeFile(
     vm: *mut VirtualMachine,
@@ -510,18 +509,16 @@ pub(crate) unsafe extern "C" fn Bun__resolveEmbeddedNodeFile(
     // `StandaloneModuleGraph` — forward-dep on `bun_jsc`. Per §Dispatch the low
     // tier owns the extern symbol and dispatches through `LoaderHooks`; the
     // high tier extracts the embedded addon to a temp file and writes the
-    // on-disk path back into `*in_out_str` (spec ModuleLoader.zig:1332-1342:
-    // `bun.String.cloneUTF8(result)`).
+    // on-disk path back into `*in_out_str`.
     let Some(hooks) = loader_hooks() else {
         unreachable!()
     };
     // SAFETY: hook contract — `vm` is the live per-thread VM; `in_out_str` is a
     // valid in/out `bun.String*` (C++ ABI, BunProcess.cpp:463).
-    // PERF(port): was inline switch.
     unsafe { (hooks.resolve_embedded_node_file)(vm, in_out_str) }
 }
 
-/// Spec ModuleLoader.zig:1344-1347.
+/// C++ entry point: whether `data[..len]` names a builtin module.
 #[unsafe(no_mangle)]
 pub(crate) unsafe extern "C" fn ModuleLoader__isBuiltin(data: *const u8, len: usize) -> bool {
     // SAFETY: C++ guarantees `data[..len]` is a valid UTF-8 specifier slice.
@@ -529,18 +526,18 @@ pub(crate) unsafe extern "C" fn ModuleLoader__isBuiltin(data: *const u8, len: us
     bun_aliases_get(str).is_some()
 }
 
-// PORT NOTE (spec bundler_jsc/PluginRunner.zig:11-32): the pure byte-string
+// The pure byte-string
 // `extractNamespace` / `couldBePlugin` helpers live in
 // `bun_bundler::transpiler::PluginRunner` — `bun_bundler` is already a
 // `bun_jsc` dep, so `Bun__runVirtualModule` calls them directly rather than
 // duplicating them here.
 use bun_bundler::transpiler::PluginRunner;
 
-// PORT NOTE: `ModuleLoader.resolveEmbeddedFile` (spec ModuleLoader.zig:33-71)
-// has been MOVED to `bun_runtime::jsc_hooks::resolve_embedded_file_to_buf`
+// `ModuleLoader.resolveEmbeddedFile`
+// lives in `bun_runtime::jsc_hooks::resolve_embedded_file_to_buf`
 // per PORTING.md §Forbidden ("dep-cycle: MOVE the code to the right crate") —
 // the body reaches into `bun_standalone_graph` + `bun_sys::Tmpfile` +
-// `node::fs`, none of which are `bun_jsc` deps. Three Zig callers live in
+// `node::fs`, none of which are `bun_jsc` deps. Three callers live in
 // `bun_runtime`:
 //   - `Bun__resolveEmbeddedNodeFile` above (extname `"node"`, goes through
 //     `LoaderHooks::resolve_embedded_node_file` to bridge the crate gap).
@@ -548,7 +545,7 @@ use bun_bundler::transpiler::PluginRunner;
 //   - `ffi_body::FFI::open` (extname `"so"`/`"dylib"`/`"dll"`; same-crate
 //     call to `resolve_embedded_file_to_buf`, no hook needed).
 
-/// Spec ModuleLoader.zig:73-83.
+/// C++ entry point: picks the loader for a specifier from its file extension and the VM's loader map.
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn Bun__getDefaultLoader(
     global: &JSGlobalObject,
@@ -570,7 +567,7 @@ pub(crate) extern "C" fn Bun__getDefaultLoader(
     loader
 }
 
-/// Spec ModuleLoader.zig:1234-1304.
+/// C++ entry point: transpiles a plugin-provided virtual module's source, writing the result into `ret`.
 #[unsafe(no_mangle)]
 pub(crate) unsafe extern "C" fn Bun__transpileVirtualModule(
     global: *mut JSGlobalObject,
@@ -594,13 +591,12 @@ pub(crate) unsafe extern "C" fn Bun__transpileVirtualModule(
         return true;
     };
     // SAFETY: hook contract — all pointers are valid for the call (C++ ABI).
-    // PERF(port): was inline switch.
     unsafe {
         (hooks.transpile_virtual_module)(global, specifier, referrer, source_code, loader, ret)
     }
 }
 
-/// Spec ModuleLoader.zig:1122-1143.
+/// C++ entry point: runs the plugin for a virtual-module specifier, returning its exports (or zero when no plugin runner is set).
 #[unsafe(no_mangle)]
 pub(crate) unsafe extern "C" fn Bun__runVirtualModule(
     global: &JSGlobalObject,
@@ -631,10 +627,7 @@ pub(crate) unsafe extern "C" fn Bun__runVirtualModule(
         bun_core::String::init(bun_core::ZigString::init(after_namespace)),
         crate::BunPluginTarget::Bun,
     ) {
-        // `catch return .zero` / `orelse return .zero`
         Ok(Some(v)) => v,
         Ok(None) | Err(_) => JSValue::ZERO,
     }
 }
-
-// ported from: src/jsc/ModuleLoader.zig
diff --git a/src/jsc/NodeModuleModule.rs b/src/jsc/NodeModuleModule.rs
index 466e65b8587..473818c587e 100644
--- a/src/jsc/NodeModuleModule.rs
+++ b/src/jsc/NodeModuleModule.rs
@@ -8,15 +8,15 @@ use bun_core::{OwnedString, String as BunString, strings};
 use bun_options_types::LoaderExt as _;
 use bun_options_types::schema::api;
 
-// `bun.schema.api.Loader` — bindgen-emitted enum from `src/options_types/schema.zig`.
-// Mirrored as a transparent `u8` because the schema enum is *open* in Zig
-// (`enum(u8) { …, _ }`) and the FFI caller may hand us discriminants outside
+// `bun.schema.api.Loader` — bindgen-emitted schema enum.
+// Mirrored as a transparent `u8` because the schema enum is *open*
+// and the FFI caller may hand us discriminants outside
 // the closed Rust `api::Loader` set; transmuting an unknown tag would be UB.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub(crate) struct ApiLoader(pub u8);
 impl ApiLoader {
-    /// schema.zig:326 — `_none = 254`.
+    /// `_none = 254`.
     pub(crate) const NONE: Self = Self(api::Loader::_none as u8);
 
     /// Reconstruct the closed schema enum. Only valid when `self != NONE` is
@@ -30,9 +30,7 @@ impl ApiLoader {
     }
 }
 
-// Zig: `export const NodeModuleModule__findPath = jsc.host_fn.wrap3(findPath);`
-// `wrap3` emits an `extern "C" fn(*JSGlobalObject, bun.String, ?*JSArray) -> JSValue` shim
-// that forwards to `findPath` via `toJSHostCall`. The C++ caller (NodeModuleModule.cpp
+// The C++ caller (NodeModuleModule.cpp
 // `jsFunctionFindPath`) does the CallFrame → (BunString, JSArray*) extraction itself and
 // invokes this with the coerced args directly — there is no CallFrame here.
 #[unsafe(no_mangle)]
@@ -54,7 +52,6 @@ fn find_path(
     request_bun_str: BunString,
     paths_maybe: Option<&JSArray>,
 ) -> JsResult<JSValue> {
-    // PERF(port): was stack-fallback (8192 bytes) — profile if it shows up on a hot path.
     let request_slice = request_bun_str.to_utf8();
     let request = request_slice.slice();
 
@@ -68,7 +65,7 @@ fn find_path(
         'found: {
             let mut iter = paths.iterator(global)?;
             while let Some(path) = iter.next()? {
-                // Zig: `defer cur_path.deref()` — `OwnedString` releases the +1 from `fromJS`.
+                // `OwnedString` releases the +1 from `from_js` on drop.
                 let cur_path = OwnedString::new(BunString::from_js(path, global)?);
 
                 if let Some(found) = find_path_inner(request_bun_str, cur_path.get(), global) {
@@ -97,8 +94,7 @@ fn find_path_inner(
     // SAFETY: zero-init is the documented `ErrorableString` "empty" state; the
     // callee fully overwrites it on both ok/err paths.
     let mut errorable: ErrorableString = unsafe { bun_core::ffi::zeroed_unchecked() };
-    // `bun_core::String` is `Copy` — passing by value here mirrors Zig's
-    // by-value struct copy with no refcount change.
+    // `bun_core::String` is `Copy` — passing by value makes no refcount change.
     match VirtualMachine::resolve_maybe_needs_trailing_slash::<true>(
         &mut errorable,
         global,
@@ -110,7 +106,7 @@ fn find_path_inner(
     ) {
         Ok(()) => {}
         Err(JsError::Thrown) => {
-            // TODO sus — Zig clears the pending exception here.
+            // TODO sus — clears the pending exception here.
             global.clear_exception();
             return None;
         }
@@ -120,7 +116,7 @@ fn find_path_inner(
 }
 
 pub fn _stat(path: &[u8]) -> i32 {
-    // PERF(port): Zig passed the slice straight through; `exists_at_type`
+    // PERF: `exists_at_type`
     // takes a `&ZStr`, so we copy into a NUL-terminated heap buffer here.
     let zpath = bun_core::ZBox::from_bytes(path);
     match bun_sys::exists_at_type(bun_sys::Fd::cwd(), &zpath) {
@@ -143,8 +139,6 @@ impl Default for CustomLoader {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle; remaining
 // params are by-value `JSValue`/scalars → `safe fn`.
 unsafe extern "C" {
@@ -162,7 +156,7 @@ unsafe extern "C" {
 }
 
 // Memory management is complicated because JSValues are stored in gc-visitable
-// WriteBarriers in C++ but the hash map for extensions is in Zig for flexibility.
+// WriteBarriers in C++ but the hash map for extensions is in Rust for flexibility.
 fn on_require_extension_modify(
     global: &JSGlobalObject,
     str: &[u8],
@@ -176,7 +170,7 @@ fn on_require_extension_modify(
     let gop = vm.commonjs_custom_extensions.get_or_put(str)?;
     if !gop.found_existing {
         // `gop.key_ptr` already owns a duped `Box<[u8]>` (StringArrayHashMap
-        // boxes the key on insert), so the Zig `dupe` is implicit.
+        // boxes the key on insert).
         if is_built_in {
             vm.has_mutated_built_in_extensions += 1;
         }
@@ -198,9 +192,8 @@ fn on_require_extension_modify(
         }
     }
 
-    // Zig `defer vm.transpiler.resolver.opts.extra_cjs_extensions = list.keys()`.
-    // PERF(port): Zig aliased the map's key storage directly; the resolver's
-    // `extra_cjs_extensions` is owned `Box<[Box<[u8]>]>` here, so we clone.
+    // PERF: the resolver's
+    // `extra_cjs_extensions` is owned `Box<[Box<[u8]>]>`, so we clone the keys.
     vm.transpiler.resolver.opts.extra_cjs_extensions = vm
         .commonjs_custom_extensions
         .keys()
@@ -218,16 +211,15 @@ fn on_require_extension_modify_non_function(
     let is_built_in = DEFAULT_LOADERS.get(str).is_some();
 
     if let Some(prev) = vm.commonjs_custom_extensions.fetch_swap_remove(str) {
-        // `prev.key: Box<[u8]>` — freed on drop (Zig: `allocator.free(prev.key)`).
+        // `prev.key: Box<[u8]>` — freed on drop.
         if is_built_in {
             vm.has_mutated_built_in_extensions -= 1;
         }
-        // `prev.value` drops here; `Strong`'s `Drop` impl is the Zig `deinit`.
+        // `prev.value` drops here, releasing any held `Strong`.
         drop(prev);
     }
 
-    // Zig `defer vm.transpiler.resolver.opts.extra_cjs_extensions = list.keys()`.
-    // PERF(port): see `on_require_extension_modify`.
+    // PERF: see `on_require_extension_modify`.
     vm.transpiler.resolver.opts.extra_cjs_extensions = vm
         .commonjs_custom_extensions
         .keys()
@@ -262,7 +254,6 @@ pub(crate) extern "C" fn NodeModuleModule__onRequireExtensionModify(
     loader: ApiLoader,
     value: JSValue,
 ) {
-    // PERF(port): was stack-fallback (8192 bytes) — profile if it shows up on a hot path.
     let str_slice = str.to_utf8();
     if on_require_extension_modify(global, str_slice.slice(), loader, value).is_err() {
         bun_core::out_of_memory();
@@ -274,11 +265,8 @@ pub(crate) extern "C" fn NodeModuleModule__onRequireExtensionModifyNonFunction(
     global: &JSGlobalObject,
     str: &BunString,
 ) {
-    // PERF(port): was stack-fallback (8192 bytes) — profile if it shows up on a hot path.
     let str_slice = str.to_utf8();
     if on_require_extension_modify_non_function(global, str_slice.slice()).is_err() {
         bun_core::out_of_memory();
     }
 }
-
-// ported from: src/jsc/NodeModuleModule.zig
diff --git a/src/jsc/PluginRunner.rs b/src/jsc/PluginRunner.rs
index 0296e40a8f8..a50c359c772 100644
--- a/src/jsc/PluginRunner.rs
+++ b/src/jsc/PluginRunner.rs
@@ -1,4 +1,4 @@
-//! Spec PluginRunner.zig — the concrete JSC-aware plugin-resolve hook.
+//! The concrete JSC-aware plugin-resolve hook.
 //!
 //! LAYERING: the static byte helpers (`extract_namespace` / `could_be_plugin`)
 //! live in `bun_bundler::transpiler::PluginRunner` (JSC-free, lowest tier).
@@ -16,11 +16,8 @@ use bun_paths::fs::Path as FsPath;
 use crate::JSGlobalObject;
 use bun_ptr::BackRef;
 
-/// Spec PluginRunner.zig:7.
 pub struct PluginRunner {
     pub global_object: BackRef<JSGlobalObject>,
-    // PORT NOTE: Zig stored `allocator: std.mem.Allocator`; dropped per
-    // PORTING.md (global mimalloc).
 }
 
 // Re-export the JSC-free static helpers so callers in this crate can keep
@@ -47,7 +44,6 @@ impl PluginRunner {
 }
 
 impl PluginResolver for PluginRunner {
-    /// Spec PluginRunner.zig:34 `onResolve`.
     fn on_resolve(
         &self,
         specifier: &[u8],
@@ -88,7 +84,7 @@ impl PluginResolver for PluginRunner {
             return Ok(None);
         }
 
-        // Spec PluginRunner.zig:62 `defer file_path.deref()` — `bun_core::String`
+        // `bun_core::String`
         // is `Copy` (no `Drop`), so RAII-wrap the +1 WTF ref across every
         // remaining `?` / early-return.
         let file_path = OwnedString::new(path_value.to_bun_string(global)?);
@@ -146,15 +142,12 @@ impl PluginResolver for PluginRunner {
 
             break 'brk BunString::init(b"file");
         };
-        // Spec PluginRunner.zig:121 `defer user_namespace.deref()`.
         let user_namespace = OwnedString::new(user_namespace);
 
-        // PORT NOTE: Zig used `std.fmt.allocPrint(this.allocator, …)` and
-        // returned the allocator-owned slice by value inside `Fs.Path`.
         // `FsPath<'static>` borrows, so the formatted buffer is leaked to
-        // model the same caller-owns-forever contract (the Zig path also
-        // never frees these — the linker arena owns them for the build).
-        // PERF(port): was `std.fmt.allocPrint(this.allocator, …)` — profile if hot.
+        // model the caller-owns-forever contract (these are
+        // never freed — the linker arena owns them for the build).
+        // PERF: profile if hot.
         let mut path_buf: Vec<u8> = Vec::new();
         write!(&mut path_buf, "{}", file_path).expect("unreachable");
         let path_static: &'static [u8] = path_buf.leak();
diff --git a/src/jsc/PosixSignalHandle.rs b/src/jsc/PosixSignalHandle.rs
index 6569e6330a9..4a1390268b1 100644
--- a/src/jsc/PosixSignalHandle.rs
+++ b/src/jsc/PosixSignalHandle.rs
@@ -98,8 +98,6 @@ impl PosixSignalHandle {
     #[allow(dead_code)]
     pub(crate) fn drain(&self, event_loop: &mut EventLoop) {
         while let Some(signal) = self.dequeue() {
-            // PORT NOTE: Zig stamps the discriminant via `Task.init(&stack_marker)` then
-            // overwrites the packed `_ptr` bitfield with `setUintptr(signal)`. The Rust
             // `Task` is a plain `{ tag, ptr }` pair (no bitfield packing), so build it
             // directly — `bun_runtime::dispatch::run_task` unpacks `task.ptr as usize as u8`.
             let task = Task::new(
@@ -143,7 +141,6 @@ impl Taskable for PosixSignalTask {
     const TAG: bun_event_loop::TaskTag = task_tag::PosixSignalTask;
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn Bun__onSignalForJS(number: i32, global_object: &JSGlobalObject);
 }
@@ -174,5 +171,3 @@ pub(crate) extern "C" fn Bun__ensureSignalHandler() {
         }
     }
 }
-
-// ported from: src/jsc/PosixSignalHandle.zig
diff --git a/src/jsc/ProcessAutoKiller.rs b/src/jsc/ProcessAutoKiller.rs
index dbda5ebad16..bced8b2f4ea 100644
--- a/src/jsc/ProcessAutoKiller.rs
+++ b/src/jsc/ProcessAutoKiller.rs
@@ -8,8 +8,7 @@ bun_core::declare_scope!(AutoKiller, hidden);
 #[derive(Default)]
 pub struct ProcessAutoKiller {
     /// Keys are intrusively-refcounted `*Process` (ref()'d on insert, deref()'d
-    /// on remove/drop). Stored as raw ptr to preserve identity-hash semantics
-    /// of Zig `AutoArrayHashMap(*Process, void)`.
+    /// on remove/drop). Stored as raw ptr for identity-hash semantics.
     pub processes: ArrayHashMap<*mut Process, ()>,
     pub enabled: bool,
     pub ever_enabled: bool,
@@ -63,12 +62,12 @@ impl ProcessAutoKiller {
         self.processes.clear();
     }
 
-    /// Spec: `onSubprocessSpawn(*ProcessAutoKiller, *bun.spawn.Process)`.
-    /// Takes a raw `*mut Process` (not `&Process`) to preserve Zig's pointer
+    /// Registers a freshly spawned subprocess for auto-kill tracking.
+    /// Takes a raw `*mut Process` (not `&Process`) to preserve pointer
     /// identity semantics for the map key without a const→mut provenance cast.
     pub fn on_subprocess_spawn(&mut self, process: NonNull<Process>) {
         if self.enabled {
-            // Zig: `put(...) catch return` — alloc failure means we never took
+            // Alloc failure means we never took
             // a ref, so just bail. `put` here is fallible only on OOM.
             if self.processes.put(process.as_ptr(), ()).is_err() {
                 return;
@@ -79,7 +78,8 @@ impl ProcessAutoKiller {
         }
     }
 
-    /// Spec: `onSubprocessExit(*ProcessAutoKiller, *bun.spawn.Process)`.
+    /// Removes an exited subprocess from auto-kill tracking, releasing the
+    /// ref taken at spawn.
     pub fn on_subprocess_exit(&mut self, process: NonNull<Process>) {
         if self.ever_enabled {
             if self.processes.swap_remove(&process.as_ptr()) {
@@ -105,5 +105,3 @@ impl Drop for ProcessAutoKiller {
         // `self.processes` storage freed by its own Drop.
     }
 }
-
-// ported from: src/jsc/ProcessAutoKiller.zig
diff --git a/src/jsc/RefString.rs b/src/jsc/RefString.rs
index c8819f777c7..ab591e7a0c0 100644
--- a/src/jsc/RefString.rs
+++ b/src/jsc/RefString.rs
@@ -7,8 +7,7 @@ use core::ffi::c_void;
 use core::ptr::NonNull;
 
 use bun_jsc::{JSGlobalObject, JSValue, JsResult};
-// Zig's `bun.WTF.StringImpl` is the *pointer* type `*WTFStringImplStruct`;
-// in Rust that's `bun_core::WTFStringImpl` (= `*mut WTFStringImplStruct`).
+// `bun_core::WTFStringImpl` is the *pointer* type (= `*mut WTFStringImplStruct`).
 use bun_core::WTFStringImpl;
 use bun_jsc::StringJsc as _; // extension trait providing `.to_js()` on `bun_core::String`
 
@@ -29,7 +28,7 @@ pub struct RefString {
     // `impl` is a Rust keyword — renamed to `impl_`.
     pub impl_: WTFStringImpl,
 
-    // Zig field `allocator: std.mem.Allocator` dropped — non-AST crate uses the
+    // No per-instance allocator — non-AST crate uses the
     // global mimalloc allocator (see PORTING.md §Allocators). `destroy` below
     // frees via `heap::take`.
     pub ctx: Option<NonNull<c_void>>,
@@ -38,14 +37,13 @@ pub struct RefString {
 
 impl RefString {
     pub fn to_js(&self, global: &JSGlobalObject) -> JsResult<JSValue> {
-        // Zig: `bun.String.init(this.impl).toJS(global)` — wrap the raw
+        // Wrap the raw
         // `WTFStringImpl` pointer without bumping the refcount (`String` has
-        // no `Drop`, so this is the same adopt-then-forget as Zig's init).
+        // no `Drop`, so this is adopt-then-forget).
         bun_core::String::adopt_wtf_impl(self.impl_).to_js(global)
     }
 
     pub fn compute_hash(input: &[u8]) -> u32 {
-        // Zig: `std.hash.XxHash32.hash(0, input)`.
         bun_hash::XxHash32::hash(0, input)
     }
 
@@ -71,7 +69,6 @@ impl RefString {
     }
 
     pub fn leak(&self) -> &[u8] {
-        // Zig: `@setRuntimeSafety(false); return this.ptr[0..this.len];`
         // SAFETY: `ptr` points to a live allocation of `len` bytes for the
         // lifetime of `self` (freed only in `destroy`).
         unsafe { bun_core::ffi::slice(self.ptr, self.len) }
@@ -83,16 +80,14 @@ impl RefString {
 
     /// Called when the underlying `WTF::StringImpl` refcount reaches zero.
     ///
-    /// Zig signature: `pub fn deinit(this: *RefString) void` — frees the byte
-    /// buffer and then `allocator.destroy(this)` (self-destroying). Because
+    /// Frees the byte
+    /// buffer and then the `RefString` itself (self-destroying). Because
     /// `RefString` is heap-allocated and held as `*mut RefString` (see `Map`),
     /// this stays an explicit raw-pointer destroy rather than `impl Drop`.
     ///
     /// SAFETY: `this` must be the unique live reference to a `RefString`
     /// previously allocated via `heap::alloc` (or equivalent). After this
     /// call `this` is dangling.
-    // TODO(port): revisit ownership — intrusive refcount via
-    // WTF::StringImpl; may become `impl Drop` if `RefString` ends up `Box`-owned.
     pub unsafe fn destroy(this: *mut RefString) {
         // SAFETY: caller contract — `this` is the unique live pointer to a
         // `Box<RefString>`-allocated value whose `ptr`/`len` describe a
@@ -100,7 +95,7 @@ impl RefString {
         // below operate on those owned allocations.
         unsafe {
             if let Some(on_before_deinit) = (*this).on_before_deinit {
-                // Zig does `this.ctx.?` — caller guarantees `ctx` is set
+                // Caller guarantees `ctx` is set
                 // whenever `on_before_deinit` is set.
                 on_before_deinit((*this).ctx.unwrap().as_ptr(), this);
             }
@@ -119,5 +114,3 @@ impl RefString {
         }
     }
 }
-
-// ported from: src/jsc/RefString.zig
diff --git a/src/jsc/RegularExpression.rs b/src/jsc/RegularExpression.rs
index 52abbf2a0e2..9fe143252cd 100644
--- a/src/jsc/RegularExpression.rs
+++ b/src/jsc/RegularExpression.rs
@@ -28,8 +28,6 @@ pub enum RegularExpressionError {
 
 bun_core::named_error_set!(RegularExpressionError);
 
-// TODO(port): move to bun_jsc_sys
-//
 // `RegularExpression` is an opaque `UnsafeCell`-backed ZST handle, so
 // `&RegularExpression` is ABI-identical to a non-null `*const` and C++ mutating
 // internal Yarr state through it is interior mutation invisible to Rust. The
@@ -61,7 +59,6 @@ impl RegularExpression {
             unsafe { Self::destroy(regex) };
             return Err(RegularExpressionError::InvalidRegExp);
         }
-        // TODO(port): consider an owning wrapper with Drop instead of returning a raw *mut.
         Ok(regex)
     }
 
@@ -102,15 +99,14 @@ impl RegularExpression {
 // ──────────────────────────────────────────────────────────────────────────
 // `bun_install_types::NodeLinker` / `bun_install::PnpmMatcher` extern impls.
 //
-// Those lower-tier crates cannot name `jsc::RegularExpression`. Zig
-// (`PnpmMatcher.zig`) called `bun.jsc.RegularExpression.init` inline after
-// `bun.jsc.initialize(false)`. The bodies live here as `#[no_mangle]` Rust-ABI
+// Those lower-tier crates cannot name `jsc::RegularExpression`.
+// The bodies live here as `#[no_mangle]` Rust-ABI
 // fns, declared `extern "Rust"` on the low-tier side; link-time resolved.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[unsafe(no_mangle)]
 pub(crate) fn __bun_regex_compile(pattern: BunString) -> Option<core::ptr::NonNull<()>> {
-    // Zig: `bun.jsc.initialize(false)` before first compile (idempotent).
+    // Initialize JSC before first compile (idempotent).
     crate::initialize(false);
     match RegularExpression::init(pattern, Flags::None) {
         Ok(r) => core::ptr::NonNull::new(r.cast()),
@@ -131,5 +127,3 @@ pub(crate) fn __bun_regex_drop(regex: core::ptr::NonNull<()>) {
     // SAFETY: `regex` was produced by `__bun_regex_compile`; consumed here.
     unsafe { RegularExpression::destroy(regex.as_ptr().cast()) }
 }
-
-// ported from: src/jsc/RegularExpression.zig
diff --git a/src/jsc/ResolveMessage.rs b/src/jsc/ResolveMessage.rs
index bd994a3bb38..21ac2d7b160 100644
--- a/src/jsc/ResolveMessage.rs
+++ b/src/jsc/ResolveMessage.rs
@@ -16,10 +16,9 @@ use crate::{
 #[crate::JsClass]
 pub struct ResolveMessage {
     pub msg: bun_ast::Msg,
-    // PORT NOTE: Zig stored `allocator: std.mem.Allocator` here; dropped — fields own their
-    // allocations and free on Drop / finalize.
+    // Note: fields own their allocations and free on Drop / finalize.
     //
-    // PORT NOTE: Zig stored `referrer: ?Fs.Path` and only ever read `.text`;
+    // Note: only the referrer path's `.text` is ever read;
     // store the duped text directly so we don't pull in `bun_paths::fs::Path`
     // (which is lifetime-parameterised over its backing buffer).
     pub referrer: Option<Box<[u8]>>,
@@ -149,7 +148,7 @@ impl ResolveMessage {
             .ok();
             return out;
         }
-        // PORT NOTE: matching against interned bun_core::Error consts (Zig: `switch (err)`).
+        // Note: matching against interned bun_core::Error consts.
         if err == bun_core::err!("ModuleNotFound") {
             if referrer == b"bun:main" {
                 write!(&mut out, "Module not found '{}'", BStr::new(specifier)).ok();
@@ -237,8 +236,9 @@ impl ResolveMessage {
             return out;
         }
 
-        // TODO(port): `toExternalValue` transfers ownership of `text` to JSC; ensure
-        // `ZigString::to_external_value` consumes the Vec without double-free.
+        // `to_external_value` transfers ownership of `text` to JSC: the Box is
+        // leaked here (single transfer via `heap::release`) and freed exactly
+        // once by JSC's external-string finalizer with the global allocator.
         let leaked = text.into_boxed_slice();
         let mut str = ZigString::init(bun_core::heap::release(leaked));
         str.set_output_encoding();
@@ -294,7 +294,7 @@ impl ResolveMessage {
         Ok(object)
     }
 
-    /// Spec `ResolveMessage.create` (ResolveMessage.zig:166) — clone `msg` +
+    /// Clone `msg` +
     /// dupe `referrer` into a fresh heap-allocated `ResolveMessage` and wrap it
     /// in its JSC cell. `JsClass::to_js` boxes `self` and calls the C++-side
     /// `ResolveMessage__create(global, ptr)`; the resulting `m_ctx` is freed by
@@ -336,7 +336,7 @@ impl ResolveMessage {
                 ZigString::init(resolve.specifier.slice(&this.msg.data.text)).to_js(global)
             }
             // Unreachable in practice (ResolveMessage is only constructed for
-            // `.resolve` metadata) — Zig accessed the union arm unchecked.
+            // `.resolve` metadata).
             _ => ZigString::init(b"").to_js(global),
         })
     }
@@ -365,5 +365,3 @@ impl ResolveMessage {
         drop(self);
     }
 }
-
-// ported from: src/jsc/ResolveMessage.zig
diff --git a/src/jsc/ResolvedSource.rs b/src/jsc/ResolvedSource.rs
index 0d64d35f0f6..e43fbd8b1f1 100644
--- a/src/jsc/ResolvedSource.rs
+++ b/src/jsc/ResolvedSource.rs
@@ -8,9 +8,9 @@ use crate::JSValue;
 // half of the table is code-generated (see `generated_resolved_source_tag.rs`).
 pub use crate::resolved_source_tag::ResolvedSourceTag as Tag;
 
-// PORT NOTE: `Copy` is required by `Errorable<T: Copy>` (the `#[repr(C)]`
-// tagged-union it travels through to C++). All fields are POD; `bun.String` is
-// a tagged pointer pair and is `Copy` in the Rust port too.
+// `Copy` is required by `Errorable<T: Copy>` (the `#[repr(C)]` tagged-union it
+// travels through to C++). All fields are POD; `BunString` is a tagged pointer
+// pair and is `Copy`.
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct ResolvedSource {
@@ -28,7 +28,7 @@ pub struct ResolvedSource {
     /// the JSFunction extension. It is kept alive by
     /// - This structure is stored on the stack
     /// - There is a JSC::Strong reference to it
-    // PORT NOTE: bare JSValue field is sound here — ResolvedSource is #[repr(C)] and lives
+    // The bare JSValue field is sound here — ResolvedSource is #[repr(C)] and lives
     // on the stack while crossing to C++ (see comment above + headers-handwritten.h).
     pub cjs_custom_extension_index: JSValue,
 
@@ -144,5 +144,3 @@ impl Drop for OwnedResolvedSource {
         self.0.bytecode_origin_path.deref();
     }
 }
-
-// ported from: src/jsc/ResolvedSource.zig
diff --git a/src/jsc/RuntimeTranspilerCache.rs b/src/jsc/RuntimeTranspilerCache.rs
index 47e8006358d..70ac25bdb03 100644
--- a/src/jsc/RuntimeTranspilerCache.rs
+++ b/src/jsc/RuntimeTranspilerCache.rs
@@ -12,8 +12,8 @@ use bun_paths::resolve_path::{self as path_handler, platform};
 use bun_paths::{self as paths, MAX_PATH_BYTES, PathBuffer, SEP};
 use bun_resolver::fs::{FileSystem, Path as FsPath};
 use bun_sys::{self as sys, Fd, FdExt as _};
-// Zig: `std.hash.Wyhash` (final4 variant). Must match exactly so on-disk
-// `.pile` filenames/hashes are interchangeable with Zig-produced caches.
+// Wyhash (final4 variant). Must stay stable so on-disk
+// `.pile` filenames/hashes remain interchangeable across versions.
 use bun_wyhash::Wyhash;
 
 bun_core::declare_scope!(cache, visible);
@@ -68,7 +68,7 @@ pub enum ModuleType {
     Cjs = 2,
 }
 
-/// Non-exhaustive in Zig (`_` arm) — represented as a transparent u8 so unknown
+/// Represented as a transparent u8 so unknown
 /// values round-trip until validated in `decode`.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Default)]
@@ -130,7 +130,6 @@ impl Default for Metadata {
 }
 
 impl Metadata {
-    // Zig computed this via @typeInfo field iteration; in Rust we sum it by hand.
     // 1×u32 + 2×u8 (enum reprs) + 12×u64 = 4 + 2 + 96 = 102
     pub const SIZE: usize = 4 + 1 + 1 + 12 * 8;
 
@@ -158,9 +157,8 @@ impl Metadata {
         Ok(())
     }
 
-    /// PORT NOTE: Zig took `anytype reader`; both call sites
-    /// (`from_file_with_cache_file_path`, the debug round-trip in `Entry::save`)
-    /// drive it from a `fixedBufferStream`, so we accept the concrete
+    /// Both call sites (`from_file_with_cache_file_path`, the debug round-trip
+    /// in `Entry::save`) drive this from a fixed buffer, so accept the concrete
     /// `bun_io::FixedBufferStream` over a borrowed slice.
     pub fn decode(
         &mut self,
@@ -171,9 +169,8 @@ impl Metadata {
             return Err(bun_core::err!(StaleCache));
         }
 
-        // PORT NOTE: reshaped for borrowck/enum-safety — Zig stored raw @enumFromInt then
-        // validated at the end; here we validate immediately so ModuleType never holds an
-        // out-of-range discriminant.
+        // Validate the raw discriminants immediately so `ModuleType` never
+        // holds an out-of-range value.
         let module_type_raw = reader.read_int_le::<u8>()?;
         let output_encoding_raw = reader.read_int_le::<u8>()?;
 
@@ -252,9 +249,6 @@ pub struct Entry {
 }
 
 impl Entry {
-    /// PORT NOTE: Zig `deinit` took three allocator params; per §Allocators
-    /// (non-AST crate) the Rust port owns its buffers via `Box<[u8]>` /
-    /// `BunString`, so this is just an explicit `deref()` + drop.
     pub fn deinit(&mut self) {
         self.output_code.deinit();
         self.sourcemap = Box::default();
@@ -309,9 +303,8 @@ impl Entry {
                     },
                     output_encoding: match output_code {
                         OutputCode::Utf8(_) => Encoding::UTF8,
-                        // PORT NOTE: `bun_core::String` has no `.encoding()` yet;
-                        // derive from the is_* predicates (same discrimination Zig's
-                        // `String.encoding()` performs).
+                        // `bun_core::String` has no `.encoding()`; derive it
+                        // from the `is_*` predicates.
                         OutputCode::String(str) => {
                             if str.is_utf16() {
                                 Encoding::UTF16
@@ -417,7 +410,7 @@ impl Entry {
             let _ = scopeguard::ScopeGuard::into_inner(errdefer);
         }
 
-        // Zig: `@ptrCast(std.fs.path.basename(...))` — basename of a NUL-terminated
+        // The basename of a NUL-terminated
         // path is itself NUL-terminated (it's a suffix), so we can hand it to
         // `Tmpfile::finish` as a `&ZStr` without copying.
         let dest_slice = destination_path.as_bytes();
@@ -449,10 +442,10 @@ impl Entry {
         } else {
             match self.metadata.output_encoding {
                 Encoding::UTF8 => {
-                    // PORT NOTE / PERF: Zig threaded `output_code_allocator`
-                    // (the per-call arena) here so the ~1.2 MB scratch buffer
-                    // was bump-freed with the parse arena. The Rust port
-                    // dropped that field and `pread_box`'d into a `Box<[u8]>`
+                    // PERF: a per-call arena (`output_code_allocator`) here
+                    // would let the ~1.2 MB scratch buffer
+                    // be bump-freed with the parse arena. Instead this
+                    // `pread_box`'s into a `Box<[u8]>`
                     // on the worker thread's mimalloc heap, which — even after
                     // the consumer's `String::clone_utf8` + drop — leaves the
                     // segment resident in that thread heap (build/create-vue
@@ -559,7 +552,6 @@ impl Entry {
             }
         };
 
-        // Zig: errdefer { switch (this.output_code) { .utf8 => free, .string => deref } }
         // BunString is Copy with no Drop, so dropping `Entry` on error does NOT
         // deref the WTFStringImpl — must do it explicitly here.
         let output_code_errdefer = scopeguard::guard(&mut self.output_code, |oc| oc.deinit());
@@ -600,12 +592,10 @@ pub struct RuntimeTranspilerCache {
     pub exports_kind: ExportsKind,
     pub output_code: Option<BunString>,
     pub entry: Option<Entry>,
-    // PORT NOTE: Zig had sourcemap_allocator / output_code_allocator / esm_record_allocator
-    // fields. `sourcemap` / `esm_record` were `bun.default_allocator` at every
-    // call site so `Box<[u8]>` (global mimalloc) is equivalent.
-    // `output_code_allocator` was the per-call arena; rather than re-thread it,
-    // the UTF-8 load arm now preads straight into WTF storage (see
-    // `Entry::load`), so no arena scratch is needed at all.
+    // `sourcemap` / `esm_record` are owned `Box<[u8]>` (global mimalloc).
+    // The per-call arena that once backed the output code is gone: the UTF-8
+    // load arm preads straight into WTF storage (see `Entry::load`), so no
+    // arena scratch is needed at all.
 }
 
 impl Default for RuntimeTranspilerCache {
@@ -650,7 +640,7 @@ fn pread_box(file: &sys::File, len: usize, offset: u64) -> Result<Box<[u8]>, bun
 
 impl RuntimeTranspilerCache {
     pub fn write_cache_filename(buf: &mut [u8], input_hash: u64) -> Result<usize, bun_core::Error> {
-        // Zig: "{x}" on std.mem.asBytes(&input_hash) — hex-encodes the 8 native-endian bytes.
+        // Hex-encode the 8 native-endian bytes of `input_hash`.
         let bytes = input_hash.to_ne_bytes();
         let suffix: &[u8] = if cfg!(debug_assertions) {
             b".debug.pile"
@@ -682,8 +672,7 @@ impl RuntimeTranspilerCache {
     }
 
     /// Writes the resolved cache directory into `buf` (NUL-terminated) and
-    /// returns its byte length. Returns 0 to mean "cache disabled" (Zig
-    /// returned `""`).
+    /// returns its byte length. Returns 0 to mean "cache disabled".
     fn really_get_cache_dir(buf: &mut PathBuffer) -> usize {
         #[cfg(debug_assertions)]
         {
@@ -706,10 +695,10 @@ impl RuntimeTranspilerCache {
             return len;
         }
 
-        // PORT NOTE: Zig used `FileSystem.instance.absBufZ(parts, buf)`. The
-        // inline `bun_resolver::fs::FileSystem` surface only exposes `abs_buf`
-        // (no `_z`), so go straight to the underlying joiner with the same
-        // `top_level_dir` + `Loose` platform Zig's `absBufZ` used.
+        // The inline `bun_resolver::fs::FileSystem` surface only exposes
+        // `abs_buf` (no NUL-terminating `_z` variant), so go straight to the
+        // underlying joiner with the same `top_level_dir` + `Loose` platform
+        // that `absBufZ` used.
         let top = FileSystem::instance().top_level_dir;
 
         if let Some(dir) = env_var::XDG_CACHE_HOME.get() {
@@ -751,10 +740,9 @@ impl RuntimeTranspilerCache {
     }
 
     // Only do this at most once per-thread.
-    // PORT NOTE: Zig used `bun.ThreadlocalBuffers(struct { buf: bun.PathBuffer })`
-    // plus a threadlocal `?[:0]const u8` pointing into it. Rust thread_local
-    // can't easily borrow into itself across calls, so we cache the resolved
-    // path bytes + length and re-copy into the caller's buffer on each call.
+    // A Rust thread_local can't easily hand out borrows into itself across
+    // calls, so cache the resolved path bytes + length and re-copy into the
+    // caller's buffer on each call.
     thread_local! {
         // bun.ThreadlocalBuffers: heap-backed so only a Box pointer lives in TLS.
         static CACHE_DIR_BUF: RefCell<Box<PathBuffer>> = RefCell::new(Box::new(PathBuffer::ZEROED));
@@ -762,8 +750,7 @@ impl RuntimeTranspilerCache {
     }
 
     /// Copies the (cached) cache-dir path into `buf`, NUL-terminates it, and
-    /// returns its length. Zig returned the threadlocal `[:0]const u8`; we
-    /// return the length so the caller can keep mutably borrowing `buf` to
+    /// returns its length, so the caller can keep mutably borrowing `buf` to
     /// append the filename.
     fn get_cache_dir(buf: &mut PathBuffer) -> Result<usize, bun_core::Error> {
         if IS_DISABLED.load(Ordering::Relaxed) {
@@ -816,8 +803,7 @@ impl RuntimeTranspilerCache {
         let mut metadata_bytes_buf = [0u8; Metadata::SIZE * 2];
         let cache_fd = sys::open(cache_file_path, sys::O::RDONLY, 0)?;
         let file = sys::File::from_fd(cache_fd);
-        // Zig: `errdefer { _ = bun.sys.unlink(...) }` — on any error, delete the
-        // cache file.
+        // On any error, delete the cache file.
         let unlink_guard = scopeguard::guard(cache_file_path, |p| {
             let _ = sys::unlink(p);
         });
@@ -869,14 +855,12 @@ impl RuntimeTranspilerCache {
         let _tracer = bun_core::perf::trace("RuntimeTranspilerCache.toFile");
 
         let mut cache_file_path_buf = PathBuffer::uninit();
-        // PORT NOTE: Zig matched on `source_code.encoding()`; derive from
-        // `is_utf8()` instead. Zig's `.utf8` arm borrowed `source_code.byteSlice()`
-        // without copying; `OutputCode::Utf8` here owns a `Box<[u8]>`, so we
-        // copy. PERF(port): add a borrowed `OutputCode` variant to avoid the copy.
+        // `OutputCode::Utf8` owns a `Box<[u8]>`, so we copy.
+        // PERF: add a borrowed `OutputCode` variant to avoid the copy.
         //
-        // Zig: `else => .{ .string = source_code }` — by-value copy, **no**
-        // `dupeRef()` and **no** matching `deref()`. `BunString` is `Copy` and
-        // `OutputCode` has no `Drop`, so `*source_code` here is the same
+        // The non-UTF-8 arm is a by-value copy, **no**
+        // `dupe_ref()` and **no** matching `deref()`. `BunString` is `Copy` and
+        // `OutputCode` has no `Drop`, so `*source_code` here is a
         // refcount-neutral borrow.
         let output_code: OutputCode = if source_code.is_utf8() {
             OutputCode::Utf8(Box::from(source_code.byte_slice()))
@@ -898,7 +882,6 @@ impl RuntimeTranspilerCache {
         let cache_dir_fd: Fd = 'brk: {
             let dirname = path_handler::dirname::<platform::Auto>(cache_file_path.as_bytes());
             if !dirname.is_empty() {
-                // Zig: `std.fs.cwd().makeOpenPath(dirname, .{ .access_sub_paths = true })`
                 let dir =
                     sys::Dir::cwd().make_open_path(dirname, sys::OpenDirOptions::default())?;
                 let dfd = dir.into_raw();
@@ -958,8 +941,8 @@ impl RuntimeTranspilerCache {
             return false;
         }
 
-        // PORT NOTE: `bun_paths::fs::Path<'static>` is the trimmed TYPE_ONLY mirror and
-        // doesn't carry `is_file()` yet; inline the same check the resolver
+        // `bun_paths::fs::Path<'static>` is the trimmed TYPE_ONLY mirror and
+        // doesn't carry `is_file()`; inline the same check the resolver
         // `Path::is_file` performs (`namespace == "" || namespace == "file"`).
         if !(source.path.namespace.is_empty() || source.path.namespace == b"file") {
             return false;
@@ -1032,7 +1015,7 @@ impl RuntimeTranspilerCache {
         }
         debug_assert!(self.entry.is_none());
         let output_code = BunString::clone_latin1(output_code_bytes);
-        // Zig: `this.output_code = output_code;` — refcount stays at 1, sole owner.
+        // Refcount stays at 1, sole owner.
         // BunString is Copy with no Drop, so an extra dupe_ref here would leak.
         self.output_code = Some(output_code);
 
@@ -1120,5 +1103,3 @@ bun_ast::link_impl_TranspilerCacheImpl! {
         is_disabled() => RuntimeTranspilerCache::is_disabled(),
     }
 }
-
-// ported from: src/jsc/RuntimeTranspilerCache.zig
diff --git a/src/jsc/RuntimeTranspilerStore.rs b/src/jsc/RuntimeTranspilerStore.rs
index 465d44b9bd6..28057e87299 100644
--- a/src/jsc/RuntimeTranspilerStore.rs
+++ b/src/jsc/RuntimeTranspilerStore.rs
@@ -57,7 +57,7 @@ bun_core::declare_scope!(RuntimeTranspilerStore, hidden);
 // Debug source dumping (debug-only helpers; no-ops in release)
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: takes `NonNull<VirtualMachine>` (not `&mut`) — these are called
+// Note: takes `NonNull<VirtualMachine>` (not `&mut`) — these are called
 // from the transpiler worker thread while the JS thread is concurrently live on
 // the same VM, so a `&mut VirtualMachine` would be a data race AND would alias
 // the caller's `&mut TranspilerJob` (which is stored inside
@@ -73,7 +73,6 @@ pub(crate) fn dump_source_string(vm: NonNull<VirtualMachine>, specifier: &[u8],
     }
 }
 
-// Zig: local `struct { pub var dir; pub var lock; }` — module statics in Rust.
 // PORTING.md §Global mutable state: lazily-opened debug-dump dir, guarded by a
 // mutex. `Guarded` fuses the lock and the payload so the per-access body is
 // safe code (replaces the prior split `Mutex` + `RacyCell` pair).
@@ -84,7 +83,6 @@ pub(crate) fn dump_source_string_failiable(
     specifier: &[u8],
     written: &[u8],
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     if !cfg!(debug_assertions) {
         return Ok(());
     }
@@ -101,7 +99,6 @@ pub(crate) fn dump_source_string_failiable(
 
     if holder.is_none() {
         let base_name: &[u8] = if cfg!(windows) {
-            // Spec: bun.fs.FileSystem.RealFS.platformTempDir() ++ "\\bun-debug-src"
             let temp = Fs::RealFS::platform_temp_dir();
             let suffix = b"\\bun-debug-src";
             path_buf.0[..temp.len()].copy_from_slice(temp);
@@ -158,7 +155,7 @@ pub(crate) fn dump_source_string_failiable(
 
             use core::fmt::Write as _;
             let mut out = std::string::String::new();
-            // PORT NOTE: closures can't unify input/output lifetimes for the
+            // Note: closures can't unify input/output lifetimes for the
             // `JSONFormatterUTF8<'_>` borrow — local fn item works.
             fn json(s: &[u8]) -> bun_core::fmt::JSONFormatterUTF8<'_> {
                 bun_core::fmt::format_json_string_utf8(
@@ -166,9 +163,8 @@ pub(crate) fn dump_source_string_failiable(
                     bun_core::fmt::JSONFormatterUTF8Options::default(),
                 )
             }
-            // PORT NOTE: Zig used a 4 KiB buffered writer streaming to the fd;
-            // building the whole document in memory then `write_all` is
-            // observationally identical for this debug-only dump.
+            // Building the whole document in memory then `write_all` is
+            // fine for this debug-only dump.
             write!(
                 out,
                 "{{\n  \"version\": 3,\n  \"file\": {},\n  \"sourceRoot\": \"\",\n  \"sources\": [{}],\n  \"sourcesContent\": [{}],\n  \"names\": [],\n  \"mappings\": \"{}\"\n}}",
@@ -183,14 +179,17 @@ pub(crate) fn dump_source_string_failiable(
     } else {
         let base = bun_paths::basename(specifier);
         let base_z = bun_paths::resolve_path::z(base, &mut path_buf);
-        // Zig: `dir.writeFile(...) catch return;`
         let _ = File::write_file(dir.fd, base_z, written);
     }
 
     Ok(())
 }
 
-pub(crate) fn set_break_point_on_first_line() -> bool {
+// `pub`: also consumed cross-crate by bun_runtime's ModuleLoader transpile path
+// (runtime/jsc_hooks.rs). The one-shot AtomicBool
+// must stay shared between that path and this store — whichever transpiles the
+// main module first consumes it.
+pub fn set_break_point_on_first_line() -> bool {
     static SET_BREAK_POINT: AtomicBool = AtomicBool::new(true);
     SET_BREAK_POINT.swap(false, Ordering::SeqCst)
 }
@@ -225,9 +224,8 @@ impl Taskable for RuntimeTranspilerStore {
 
 impl RuntimeTranspilerStore {
     pub fn init() -> RuntimeTranspilerStore {
-        // PORT NOTE: Zig passed `bun.typedAllocator(TranspilerJob)` to
-        // `Store.init`; the Rust HiveArrayFallback uses the global mimalloc
-        // (PORTING.md §Allocators), so the allocator arg drops.
+        // The HiveArrayFallback uses the global mimalloc
+        // (PORTING.md §Allocators).
         Self::default()
     }
 
@@ -236,11 +234,11 @@ impl RuntimeTranspilerStore {
     /// uninitialized — its bytes are never read until `used.set()` claims a
     /// slot, so any bit pattern is valid.
     ///
-    /// PERF(port): `out.write(Self::init())` materialises a stack temporary
+    /// PERF: `out.write(Self::init())` materialises a stack temporary
     /// of `size_of::<Self>()` (≈ 64 × `size_of::<TranspilerJob>()`) and
     /// `memcpy`s it; rustc cannot elide the copy through the `MaybeUninit`
-    /// payload. Zig's `Store.init()` left `buffer` `undefined` and only
-    /// zeroed the bitset — this restores that.
+    /// payload. This leaves `buffer` uninitialized and only
+    /// zeroes the bitset.
     ///
     /// On return, `*out` is fully initialized.
     pub fn init_in_place(out: &mut core::mem::MaybeUninit<Self>) {
@@ -260,7 +258,7 @@ impl RuntimeTranspilerStore {
         }
     }
 
-    // PORT NOTE: takes `NonNull` rather than `&mut` for `event_loop`/`vm`
+    // Note: takes `NonNull` rather than `&mut` for `event_loop`/`vm`
     // because `&mut self` already aliases `vm.transpiler_store` (this `Self` is
     // a field of `VirtualMachine`). Field-level derefs only.
     pub fn run_from_js_thread(
@@ -386,7 +384,7 @@ impl RuntimeTranspilerStore {
 // TranspilerJob
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: bun.heap_breakdown.enabled gate on inline capacity — the Rust
+// Note: bun.heap_breakdown.enabled gate on inline capacity — the Rust
 // `bun_alloc::heap_breakdown` is a no-op outside macOS Instruments builds, so
 // the 64-slot hive is unconditional here.
 const TRANSPILER_JOB_HIVE_CAP: usize = 64;
@@ -394,7 +392,7 @@ const TRANSPILER_JOB_HIVE_CAP: usize = 64;
 pub(crate) type TranspilerJobStore = HiveArrayFallback<TranspilerJob, TRANSPILER_JOB_HIVE_CAP>;
 
 pub struct TranspilerJob {
-    // PORT NOTE: stored as the lower-tier `bun_paths::fs::Path<'static>` (the type
+    // Note: stored as the lower-tier `bun_paths::fs::Path<'static>` (the type
     // `ParseOptions.path` / `bun_ast::Source.path` use). The slices borrow the
     // Box'd buffer allocated in `transpile()` and freed in `reset_for_pool()`.
     pub path: bun_paths::fs::Path<'static>,
@@ -404,8 +402,8 @@ pub struct TranspilerJob {
     pub non_threadsafe_referrer: OwnedString,
     pub loader: Loader,
     pub promise: StrongOptional,
-    // PORT NOTE: struct is stored in a HiveArray and crosses to a worker thread;
-    // Zig used `*VirtualMachine` / `*JSGlobalObject` (BACKREF — VM owns the
+    // Note: struct is stored in a HiveArray and crosses to a worker thread;
+    // raw pointers/BackRefs are used (BACKREF — VM owns the
     // store and outlives every job).
     pub vm: *mut VirtualMachine,
     pub global_this: BackRef<JSGlobalObject>,
@@ -438,9 +436,8 @@ pub enum Fetcher {
     File,
 }
 
-// PORT NOTE: Zig `Fetcher.deinit` called `.deref()` on the contained `bun.String`.
-// In the Rust port `bun_core::String` is `Copy` with manual `.deref()`; matching
-// Zig, decrement explicitly when replacing the enum value.
+// Note: `bun_core::String` is `Copy` with manual `.deref()`;
+// decrement explicitly when replacing the enum value.
 impl Fetcher {
     fn deinit(&mut self) {
         if let Fetcher::VirtualModule(s) = self {
@@ -449,15 +446,14 @@ impl Fetcher {
     }
 }
 
-/// Per-worker output buffer (Zig: `threadlocal var source_code_printer:
-/// ?*js_printer.BufferPrinter = null`). The printer is the **only** state
+/// Per-worker output buffer. The printer is the **only** state
 /// retained across `run()` calls — its backing `Vec<u8>` is genuinely worth
 /// reusing (capped at 512 K / 2 M below). The parse arena and AST memory
 /// store, by contrast, are stack-local per call and bulk-freed on return; see
 /// the RSS-regression note in `run()`.
 //
-// `#[thread_local]` not `thread_local!`: Zig `threadlocal var` is bare
-// `__thread`; the macro's `LocalKey::__getit` wrapper showed up on the
+// `#[thread_local]` not `thread_local!`: the macro's `LocalKey::__getit`
+// wrapper showed up on the
 // async-import hot path. Const-init `Cell<ptr>` (no dtor).
 #[thread_local]
 static SOURCE_CODE_PRINTER: Cell<Option<NonNull<BufferPrinter>>> = Cell::new(None);
@@ -486,12 +482,12 @@ fn tls_get_or_leak<T>(
 }
 
 impl TranspilerJob {
-    /// Zig `deinit` — kept as a private inherent fn (not `impl Drop`) because the
+    /// Kept as a private inherent fn (not `impl Drop`) because the
     /// slot is recycled into the HiveArray via `store.put(this)`. Only caller is
     /// `run_from_js_thread`.
     ///
-    /// PORT NOTE: `HiveArrayFallback::put` runs `drop_in_place` on the slot (see
-    /// hive_array.rs PORT NOTE), so the Drop-carrying fields — `OwnedString` ×2,
+    /// Note: `HiveArrayFallback::put` runs `drop_in_place` on the slot (see
+    /// hive_array.rs note), so the Drop-carrying fields — `OwnedString` ×2,
     /// `OwnedResolvedSource`, `Log`, `StrongOptional` — are torn down *there*,
     /// not here. This function handles only the teardown that field drop glue
     /// does **not** cover: the leaked `path.text` Box, `poll_ref.disable()`,
@@ -538,7 +534,7 @@ impl TranspilerJob {
         // before `reset_for_pool`/`put` need `&mut *self` below; deref at the
         // `fulfill` call site instead.
         let global_this = self.global_this;
-        // PORT NOTE: Zig `poll_ref.unref(vm)` — the Rust KeepAlive takes an `EventLoopCtx`
+        // Note: the KeepAlive takes an `EventLoopCtx`
         // vtable; resolve it via the `get_vm_ctx` hook (registered by `bun_runtime::init`).
         self.poll_ref.unref(get_vm_ctx(AllocatorType::Js));
 
@@ -588,7 +584,7 @@ impl TranspilerJob {
     }
 
     pub(crate) fn schedule(&mut self) {
-        // PORT NOTE: Zig `poll_ref.ref(this.vm)` — the Rust KeepAlive takes an
+        // Note: the KeepAlive takes an
         // `EventLoopCtx` vtable; resolve it via the `get_vm_ctx` hook (registered by
         // `bun_runtime::init`).
         self.poll_ref.ref_(get_vm_ctx(AllocatorType::Js));
@@ -605,10 +601,7 @@ impl TranspilerJob {
     }
 
     pub(crate) fn run(&mut self) {
-        // Zig: `var arena = bun.ArenaAllocator.init(bun.default_allocator);
-        //       defer arena.deinit();`
-        //
-        // Stack-local per call, bulk-freed on return. An earlier port hoisted
+        // Stack-local per call, bulk-freed on return. An earlier version hoisted
         // this to a per-worker-thread leaked `Box<MimallocArena>` (and a second
         // one inside a leaked `ASTMemoryAllocator`) and only `reset()` it at
         // the *start* of the next call. On a 64-core box ~40 thread-pool
@@ -633,7 +626,7 @@ impl TranspilerJob {
         }
 
         // SAFETY contract: `vm` outlives the job (BACKREF — VM owns the store).
-        // PORT NOTE: kept as a raw pointer — never form `&mut VirtualMachine`
+        // Note: kept as a raw pointer — never form `&mut VirtualMachine`
         // here. (a) the JS thread is concurrently live on the same VM, so a
         // `&mut` would be a data race; (b) `self` is stored *inside*
         // `(*vm).transpiler_store.store` (HiveArray inline slot), so a
@@ -643,7 +636,7 @@ impl TranspilerJob {
         // expressions / leaf-field borrows) only.
         let vm: *mut VirtualMachine = self.vm;
 
-        // SAFETY: `vm` is the live owning VM (BACKREF — see PORT NOTE above);
+        // SAFETY: `vm` is the live owning VM (BACKREF — see note above);
         // atomic load on a leaf field, no `&VirtualMachine` formed.
         let store_generation = unsafe {
             (*vm)
@@ -656,8 +649,7 @@ impl TranspilerJob {
             return;
         }
 
-        // Zig: `var ast_scope = ast_memory_store.?.enter(allocator); defer ast_scope.exit();`
-        // `borrowing()` matches the Zig shape: the AST node store and the
+        // `borrowing()`: the AST node store and the
         // `AstVec` spill share `arena`'s heap and are bulk-freed when `arena`
         // drops at the end of `run()`.
         let mut ast_memory_store = ASTMemoryAllocator::borrowing(&arena);
@@ -668,8 +660,7 @@ impl TranspilerJob {
         let loader = self.loader;
         let this_tag = self.resolved_source.get().tag;
 
-        // PORT NOTE: Zig threaded the arena into `output_code_allocator`; the Rust port of
-        // RuntimeTranspilerCache dropped the per-allocator fields (Box<[u8]> + global mimalloc).
+        // RuntimeTranspilerCache has no per-allocator fields (Box<[u8]> + global mimalloc).
         // LAYERING: this is the canonical `bun_ast::RuntimeTranspilerCache`
         // wired with the JSC vtable so the parser's `cache.get()` reaches the
         // disk-backed `Entry` loader; on a hit `cache.entry` holds a type-erased
@@ -692,13 +683,13 @@ impl TranspilerJob {
             },
         );
 
-        // PORT NOTE: Zig copies the whole Transpiler by value (`transpiler = vm.transpiler`).
+        // The whole Transpiler is copied by value here.
         // `Transpiler<'static>` is not `Clone` (it holds raw self-referential pointers); we do
-        // a bytewise copy mirroring the Zig value-copy. SAFETY: `vm.transpiler` is read via
+        // a bytewise copy. SAFETY: `vm.transpiler` is read via
         // `addr_of!` (no `&VirtualMachine` formed); every internal raw pointer in the copy
         // still targets memory owned by `vm.transpiler` (resolver caches, define, env) which
         // outlives this stack frame; `vm.transpiler` is not concurrently mutated.
-        // Zig did not `deinit` the by-value copy; `ManuallyDrop` suppresses Drop so owned
+        // The by-value copy must not be deinitialized; `ManuallyDrop` suppresses Drop so owned
         // fields aren't double-freed against `vm.transpiler`.
         let mut transpiler_storage =
             core::mem::ManuallyDrop::new(unsafe { ptr::read(ptr::addr_of!((*vm).transpiler)) });
@@ -712,13 +703,11 @@ impl TranspilerJob {
             unsafe { &mut *(&raw mut *transpiler_storage).cast::<Transpiler<'_>>() };
         transpiler.set_arena(&arena);
         transpiler.set_log(&raw mut log);
-        // PORT NOTE: reshaped for borrowck — Zig: transpiler.resolver.opts = transpiler.options
-        // (BundleOptions value copy). The Rust resolver already shares opts with the parent
+        // Note: the resolver already shares opts with the parent
         // Transpiler via raw pointer; set_arena/set_log keep them in sync.
         transpiler.macro_context = None;
-        // PORT NOTE: Zig's `MacroContext.init` is a value-type with no heap
-        // allocation, so re-creating it per-iteration (as `parse_maybe` does
-        // when `macro_context.is_none()`) is free. The Rust port boxes a
+        // Note: `parse_maybe` re-creates the macro context per-iteration
+        // when `macro_context.is_none()`. It boxes a
         // higher-tier `MacroContext` via `__bun_macro_context_init`; that Box
         // is intentionally leaked for the long-lived `vm.transpiler`, but here
         // we operate on a per-iteration `ManuallyDrop` bytewise copy, so we
@@ -739,7 +728,7 @@ impl TranspilerJob {
                     ctx.deinit();
                 }
             });
-        // Zig: `transpiler.linker.resolver = &transpiler.resolver` — the bytewise copy left
+        // The bytewise copy left
         // `linker.resolver` pointing at `vm.transpiler.resolver` (wrong allocator/log); rewire
         // it at the local copy so `print_with_source_map` resolves through the arena-backed
         // resolver.
@@ -758,7 +747,7 @@ impl TranspilerJob {
         // (BACKREF — when non-null it points at the process-lifetime watcher
         // leaked in `enable_hot_module_reloading`, so the `ParentRef` invariant
         // holds for this transpile job's duration). Raw `(*vm)` field
-        // projection avoids forming `&VirtualMachine` per the `vm` PORT NOTE.
+        // projection avoids forming `&VirtualMachine` per the `vm` note.
         let import_watcher: Option<bun_ptr::ParentRef<ImportWatcher>> =
             unsafe { bun_ptr::ParentRef::from_nullable_mut((*vm).bun_watcher.cast()) };
         if let Some(iw) = import_watcher {
@@ -766,8 +755,7 @@ impl TranspilerJob {
             // `flush_evictions` closes fds and `swap_remove`s), so snapshot
             // under the watcher mutex — see
             // `ImportWatcher::snapshot_fd_and_package_json` doc for the EBADF
-            // race this closes (port improves on Zig spec; Zig
-            // `RuntimeTranspilerStore.zig:344` reads unlocked).
+            // race this closes.
             (fd, package_json) = iw.snapshot_fd_and_package_json(hash);
             // On Linux, `addFileByPathSlow` inserts watchlist entries with
             // `fd = invalid_fd` (only kqueue needs the descriptor). Treat
@@ -783,18 +771,18 @@ impl TranspilerJob {
         // this should be a cheap lookup because 24 bytes == 8 * 3 so it's read 3 machine words
         let is_node_override = strings::has_prefix_comptime(specifier, node_fallbacks::IMPORT_PATH);
 
-        // SAFETY: leaf scalar field reads on `*vm`; see `vm` PORT NOTE above.
+        // SAFETY: leaf scalar field reads on `*vm`; see `vm` note above.
         let macro_remappings = if unsafe { (*vm).macro_mode }
             || !unsafe { (*vm).has_any_macro_remappings }
             || is_node_override
         {
             MacroRemap::default()
         } else {
-            // PORT NOTE: `MacroRemap` (StringArrayHashMap of StringArrayHashMap)
+            // Note: `MacroRemap` (StringArrayHashMap of StringArrayHashMap)
             // has no nested `Clone` impl (the inherent `clone()` requires
-            // `V: Clone`); the Zig copied it by value. Re-key shallowly here
+            // `V: Clone`). Re-key shallowly here
             // matching the build-command conversion (transpiler.rs:2616).
-            // Spec (Zig l.363) is an infallible value-copy, so OOM during the
+            // OOM during the
             // inner `clone()` must abort — never silently drop a remapping.
             let mut m = MacroRemap::default();
             for (k, v) in transpiler.options.macro_remap.iter() {
@@ -803,10 +791,10 @@ impl TranspilerJob {
             m
         };
 
-        // Zig: `var fallback_source: logger.Source = undefined;` — only
+        // Only
         // initialised on the `is_node_override` branch and only read through
-        // `parse_options.virtual_source` (raw-ptr borrow). `MaybeUninit` mirrors
-        // the `= undefined` exactly; the write is `Cow::Borrowed`/borrowed-path
+        // `parse_options.virtual_source` (raw-ptr borrow).
+        // The write is `Cow::Borrowed`/borrowed-path
         // only, so skipping `Drop` is sound.
         let mut fallback_source = core::mem::MaybeUninit::<bun_ast::Source>::uninit();
 
@@ -815,14 +803,14 @@ impl TranspilerJob {
         // If we're re-using the file descriptor from the fs watcher
         // Do not close it because that will break the kqueue-based watcher
         //
-        // PORT NOTE: stored in a `Cell` so the scopeguard closure can capture
+        // Note: stored in a `Cell` so the scopeguard closure can capture
         // `&Cell<bool>` and the post-parse writes are visible to it without
         // raw-pointer laundering (which the unused-assignment lint can't see).
         let should_close_input_file_fd = Cell::new(fd.is_none());
 
         let mut input_file_fd: Fd = Fd::INVALID;
 
-        // SAFETY: leaf scalar field reads on `*vm`; see `vm` PORT NOTE above.
+        // SAFETY: leaf scalar field reads on `*vm`; see `vm` note above.
         let (vm_main, vm_main_hash) = unsafe { ((*vm).main(), (*vm).main_hash) };
         let is_main = vm_main.len() == path.text.len()
             && vm_main_hash == hash
@@ -855,7 +843,7 @@ impl TranspilerJob {
             dont_bundle_twice: true,
             allow_commonjs: true,
             inject_jest_globals: transpiler.options.rewrite_jest_for_tests,
-            // SAFETY: leaf-field `&` borrow on `*vm.debugger`; see `vm` PORT NOTE above.
+            // SAFETY: leaf-field `&` borrow on `*vm.debugger`; see `vm` note above.
             set_breakpoint_on_first_line: unsafe { &(*vm).debugger }
                 .as_ref()
                 .map(|d| d.set_breakpoint_on_first_line)
@@ -870,7 +858,7 @@ impl TranspilerJob {
             } else {
                 None
             },
-            // SAFETY: leaf-field read on `*vm.module_loader`; see `vm` PORT NOTE above.
+            // SAFETY: leaf-field read on `*vm.module_loader`; see `vm` note above.
             remove_cjs_module_wrapper: is_main
                 && unsafe { (*vm).module_loader.eval_source.is_some() },
             module_type,
@@ -912,8 +900,8 @@ impl TranspilerJob {
             }
         }
 
-        // Zig spec: `vm.isWatcherEnabled()` ⇔ `vm.bun_watcher != .none`. The
-        // Rust field is a type-erased `*mut ImportWatcher`, so a non-null
+        // `vm.isWatcherEnabled()` ⇔ watcher present. The
+        // field is a nullable `*mut ImportWatcher`, so a non-null
         // pointer may still hold `ImportWatcher::None`; both must be ruled out
         // or we'd skip closing `input_file_fd` without a watcher to adopt it.
         // Discriminant read on the BACKREF captured above; only the JS thread
@@ -972,7 +960,7 @@ impl TranspilerJob {
             }
         }
 
-        // SAFETY: leaf scalar field read; see `vm` PORT NOTE above. Inlined
+        // SAFETY: leaf scalar field read; see `vm` note above. Inlined
         // `VirtualMachine::use_isolation_source_provider_cache` to avoid forming
         // `&VirtualMachine`.
         let use_isolation_source_provider_cache = unsafe { (*vm).test_isolation_enabled }
@@ -995,7 +983,7 @@ impl TranspilerJob {
             );
 
             if bun_core::env::DUMP_SOURCE {
-                // SAFETY: `vm` is the live owning VM (BACKREF — see `vm` PORT NOTE above).
+                // SAFETY: `vm` is the live owning VM (BACKREF — see `vm` note above).
                 let vm = unsafe { NonNull::new_unchecked(vm) };
                 dump_source_string(vm, specifier, entry.output_code.byte_slice());
             }
@@ -1085,9 +1073,8 @@ impl TranspilerJob {
             bp
         });
 
-        // PORT NOTE: Zig copies BufferPrinter by value here (`var printer = source_code_printer.?.*`)
-        // and writes it back later. We swap the buffer out instead and write it back via the
-        // _writeback guard — same observable effect (the thread-local's buffer is reused).
+        // Swap the buffer out and write it back via the
+        // _writeback guard (the thread-local's buffer is reused).
         let mut printer = core::mem::replace(
             source_code_printer,
             BufferPrinter::init(BufferWriter::init()),
@@ -1120,7 +1107,7 @@ impl TranspilerJob {
             } else {
                 None
             };
-        // Spec ModuleLoader.zig:523 — propagate top-level-await to the cached
+        // Propagate top-level-await to the cached
         // module record. Without this, modules cached via the isolation source
         // provider (used under --isolate / --parallel) are reported to JSC as
         // having no TLA, so the module's evaluation promise resolves before the
@@ -1129,7 +1116,7 @@ impl TranspilerJob {
         if let Some(mi) = module_info.as_deref_mut() {
             mi.flags.has_tla = !parse_result.ast.top_level_await_keyword.is_empty();
         }
-        // PORT NOTE: derive `*mut` from a `&mut` borrow (not `&x as *const _ as
+        // Note: derive `*mut` from a `&mut` borrow (not `&x as *const _ as
         // *mut _`, which is Stacked-Borrows UB). The `&mut` borrow ends when the
         // closure returns; the raw pointer stays valid until `module_info` is
         // moved/touched again (after `print_with_source_map`).
@@ -1137,7 +1124,7 @@ impl TranspilerJob {
             module_info.as_deref_mut().map(std::ptr::from_mut);
 
         let print_result = {
-            // SAFETY: see `vm` PORT NOTE above — `from_raw` stores `vm` as a raw
+            // SAFETY: see `vm` note above — `from_raw` stores `vm` as a raw
             // pointer and only borrows leaf fields (`source_mappings`, `debugger`)
             // inside `get()`. No `&mut VirtualMachine` is ever formed.
             let mut mapper = unsafe { SourceMapHandlerGetter::from_raw(vm, &raw mut printer) };
@@ -1174,7 +1161,7 @@ impl TranspilerJob {
         }
 
         if bun_core::env::DUMP_SOURCE {
-            // SAFETY: `vm` is the live owning VM (BACKREF — see `vm` PORT NOTE above).
+            // SAFETY: `vm` is the live owning VM (BACKREF — see `vm` note above).
             let vm = unsafe { NonNull::new_unchecked(vm) };
             dump_source(vm, specifier, source_code_printer);
         }
@@ -1188,7 +1175,7 @@ impl TranspilerJob {
             debug_assert!(cache.output_code.is_none());
             let result = String::clone_latin1(written);
 
-            // SAFETY: leaf scalar field read on `*vm`; see `vm` PORT NOTE above.
+            // SAFETY: leaf scalar field read on `*vm`; see `vm` note above.
             if written.len() > 1024 * 1024 * 2 || unsafe { (*vm).smol } {
                 // printer.ctx.buffer.deinit() → Drop
                 let writer = BufferWriter::init();
@@ -1228,5 +1215,3 @@ impl TranspilerJob {
         // this point — `source_code` above is a fresh WTF::String copy.
     }
 }
-
-// ported from: src/jsc/RuntimeTranspilerStore.zig
diff --git a/src/jsc/SavedSourceMap.rs b/src/jsc/SavedSourceMap.rs
index d7b32fc1d8e..78127b7d66f 100644
--- a/src/jsc/SavedSourceMap.rs
+++ b/src/jsc/SavedSourceMap.rs
@@ -4,7 +4,7 @@ use core::ffi::c_void;
 use core::ptr;
 use std::sync::Arc;
 
-use bun_collections::{HashMap, TaggedPtrUnion};
+use bun_collections::{HashMap, IdentityContext, TaggedPtrUnion};
 use bun_core::MutableString;
 use bun_core::Ordinal;
 use bun_sourcemap::internal_source_map::FindCache;
@@ -41,7 +41,7 @@ impl Default for SavedSourceMap {
 }
 
 impl SavedSourceMap {
-    // TODO(port): in-place init — `this` is a pre-allocated field on VirtualMachine; `map` is a sibling field backref.
+    // In-place init — `this` is a pre-allocated field on VirtualMachine; `map` is a sibling field backref.
     pub unsafe fn init(this: &mut core::mem::MaybeUninit<Self>, map: *mut HashTable) {
         this.write(Self {
             map,
@@ -91,8 +91,7 @@ pub type Value = TaggedPtrUnion<ValueTypes>;
 /// Local type-list marker so `TypeList`/`UnionMember` impls satisfy orphan
 /// rules — `bun_ptr::impl_tagged_ptr_union!` would impl on a tuple of foreign
 /// types (all five live in `bun_sourcemap`), which the coherence checker
-/// rejects from this crate. Tags are `1024 - i` to match Zig's
-/// `TagTypeEnumWithTypeMap` ordering in `SavedSourceMap.zig`.
+/// rejects from this crate. Tags are `1024 - i`.
 pub struct ValueTypes;
 
 impl bun_ptr::tagged_pointer::TypeList for ValueTypes {
@@ -168,8 +167,8 @@ impl SavedSourceMap {
         path: &[u8],
     ) {
         self.lock();
-        // PORT NOTE: reshaped for borrowck — explicit unlock paired manually.
-        // Zig `getEntry`/`removeByPtr` collapsed to `get`+`remove(&key)`; the std
+        // Note: reshaped for borrowck — explicit unlock paired manually.
+        // `get`+`remove(&key)`: the std
         // backing has no key-slot pointer to hand out, and the key is a u64 hash
         // we already have in hand.
         let map = self.map_mut();
@@ -204,8 +203,8 @@ impl SavedSourceMap {
 
     pub fn remove_zig_source_provider(&mut self, opaque_source_provider: *mut c_void, path: &[u8]) {
         self.lock();
-        // PORT NOTE: reshaped for borrowck — explicit unlock paired manually.
-        // Zig `getEntry`/`removeByPtr` collapsed to `get`+`remove(&key)`; the std
+        // Note: reshaped for borrowck — explicit unlock paired manually.
+        // `get`+`remove(&key)`: the std
         // backing has no key-slot pointer to hand out, and the key is a u64 hash
         // we already have in hand.
         let map = self.map_mut();
@@ -234,8 +233,10 @@ impl SavedSourceMap {
     }
 }
 
-// TODO(port): std.HashMap(u64, *anyopaque, bun.IdentityContext(u64), 80) — needs identity (passthrough) hasher and 80% max load.
-pub type HashTable = HashMap<u64, *mut c_void>;
+// Keys are
+// already wyhash u64s, so use the passthrough hasher; `bun_collections`'
+// zig_hash_map uses an 80% max load factor.
+pub type HashTable = HashMap<u64, *mut c_void, IdentityContext<u64>>;
 
 impl bun_js_printer::OnSourceMapChunk for SavedSourceMap {
     fn on_source_map_chunk(
@@ -247,9 +248,7 @@ impl bun_js_printer::OnSourceMapChunk for SavedSourceMap {
     }
 }
 
-/// Port of `SavedSourceMap.SourceMapHandler` (SavedSourceMap.zig) —
-/// `js_printer.SourceMapHandler.For(SavedSourceMap, onSourceMapChunk)`. The Zig
-/// comptime type-generator is replaced by `SourceMapHandler::for_::<SavedSourceMap>`,
+/// `SourceMapHandler::for_::<SavedSourceMap>` is
 /// monomorphized over the `OnSourceMapChunk` impl above.
 pub type SourceMapHandler<'a> = bun_js_printer::SourceMapHandler<'a>;
 
@@ -258,7 +257,6 @@ impl Drop for SavedSourceMap {
         {
             self.lock();
             let map = self.map_mut();
-            // Zig `valueIterator()` → std `values()`.
             for val in map.values() {
                 let value = Value::from(Some(*val));
                 if let Some(source_map) = value.get::<ParsedSourceMap>() {
@@ -280,7 +278,10 @@ impl Drop for SavedSourceMap {
         }
 
         self.map_mut().unlock_pointers();
-        // TODO(port): deinit() on a backref-owned HashMap — ownership lives on VirtualMachine; verify.
+        // The HashTable storage is owned by the sibling `saved_source_map_table`
+        // field on VirtualMachine; `deinit()` resets it to an empty default in
+        // place, so the VM's later (or absent) drop of that field is a no-op —
+        // no double free.
         self.map_mut().deinit();
     }
 }
@@ -291,7 +292,6 @@ impl SavedSourceMap {
         source: &bun_ast::Source,
         mut mappings: MutableString,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // --hot can re-read a file mid-rewrite (truncate + write) and transpile
         // a comment-only prefix into a 0-mapping map. Overwriting a real map
         // with that would make any still-unreported error from the previous
@@ -309,14 +309,12 @@ impl SavedSourceMap {
                 if contains {
                     return Ok(());
                 }
-                // PORT NOTE: reshaped for borrowck — Zig held the lock across the early return; here we
-                // release before returning since no further table access follows.
+                // Note: reshaped for borrowck — the lock is
+                // released before returning since no further table access follows.
             }
         }
 
-        // PORT NOTE: Zig `default_allocator.dupe(u8, mappings.list.items)` —
-        // Zig dups because the printer's `MutableString` is backed by a
-        // recycled buffer it does not own. In Rust every caller MOVES an owned
+        // Note: every caller MOVES an owned
         // `Vec<u8>` here (printer chunk by value, cache hit via `mem::take`),
         // so `into_boxed_slice()` transfers the existing allocation without
         // re-alloc+memcpy (1.38 MB for `_tsc.js`'s cached map). `heap::alloc`
@@ -342,15 +340,14 @@ impl SavedSourceMap {
     pub fn put_value(&mut self, path: &[u8], value: Value) -> Result<(), bun_core::Error> {
         use bun_collections::zig_hash_map::MapEntry as Entry;
 
-        // TODO(port): narrow error set
         self.lock();
-        // PORT NOTE: reshaped for borrowck — explicit unlock paired manually.
+        // Note: reshaped for borrowck — explicit unlock paired manually.
 
         self.find_cache.invalidate_all();
         self.last_ism = None;
 
         // `bun_collections::HashMap` derefs to `std::collections::HashMap`, so
-        // the std `entry()` API is used directly (Zig `getOrPut`).
+        // the std `entry()` API is used directly.
         match self.map_mut().entry(hash(path)) {
             Entry::Occupied(mut o) => {
                 let old_value = Value::from(Some(*o.get()));
@@ -406,7 +403,7 @@ impl SavedSourceMap {
                 data: tagged.as_unchecked::<InternalSourceMap>() as *const u8,
             };
             // Table holds one strong ref (leaked via `into_raw`); caller gets
-            // the returned `Arc`. Mirrors Zig's intrusive `ref()` pair.
+            // the returned `Arc`.
             let result = Arc::new(ParsedSourceMap::from_internal(ism));
             *mapping = Value::init(Arc::into_raw(Arc::clone(&result))).ptr();
             self.unlock();
@@ -434,10 +431,9 @@ impl SavedSourceMap {
             // Do not lock the mutex while we're parsing JSON!
             // SAFETY: SourceProviderMap is kept alive by JSC; we did not hold a ref.
             if let Some(parse) = unsafe { (*ptr).get_source_map(path, Default::default(), hint) } {
-                // TODO(port): `.none` enum literal for second arg — verify SourceMap load-hint default.
                 if let Some(ref parsed_map) = parse.map {
                     // The mutex is not locked. We have to check the hash table again.
-                    // Leak one strong ref into the table (mirrors Zig `map.ref()`).
+                    // Leak one strong ref into the table.
                     let _ =
                         self.put_value(path, Value::init(Arc::into_raw(Arc::clone(parsed_map))));
 
@@ -552,7 +548,7 @@ impl SavedSourceMap {
 
         let mapping = match parse.mapping {
             Some(m) => m,
-            // Spec SavedSourceMap.zig:343 — pass `line`/`column` straight
+            // Pass `line`/`column` straight
             // through. `SourceMap::Ordinal` is a re-export of `bun_core::Ordinal`;
             // round-tripping via `from_zero_based(x.zero_based())` debug-asserts
             // on the legitimate INVALID (-1) sentinel.
@@ -567,5 +563,3 @@ impl SavedSourceMap {
         })
     }
 }
-
-// ported from: src/jsc/SavedSourceMap.zig
diff --git a/src/jsc/ScriptExecutionStatus.rs b/src/jsc/ScriptExecutionStatus.rs
index 78fdb224b24..19aa68388b4 100644
--- a/src/jsc/ScriptExecutionStatus.rs
+++ b/src/jsc/ScriptExecutionStatus.rs
@@ -5,5 +5,3 @@ pub enum ScriptExecutionStatus {
     Suspended = 1,
     Stopped = 2,
 }
-
-// ported from: src/jsc/ScriptExecutionStatus.zig
diff --git a/src/jsc/SourceProvider.rs b/src/jsc/SourceProvider.rs
index 70c467ce782..40ed2161c42 100644
--- a/src/jsc/SourceProvider.rs
+++ b/src/jsc/SourceProvider.rs
@@ -9,11 +9,8 @@ impl SourceProvider {
     }
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     // safe: `SourceProvider` is an opaque `UnsafeCell`-backed ZST handle; `&mut` is
     // ABI-identical to a non-null pointer and C++ refcount mutation is interior.
     safe fn JSC__SourceProvider__deref(provider: &mut SourceProvider);
 }
-
-// ported from: src/jsc/SourceProvider.zig
diff --git a/src/jsc/SourceType.rs b/src/jsc/SourceType.rs
index 26b12de1d6d..7d1b3b9b7cd 100644
--- a/src/jsc/SourceType.rs
+++ b/src/jsc/SourceType.rs
@@ -6,5 +6,3 @@ pub enum SourceType {
     Module = 1,
     WebAssembly = 2,
 }
-
-// ported from: src/jsc/SourceType.zig
diff --git a/src/jsc/StringBuilder.rs b/src/jsc/StringBuilder.rs
index f774e59880a..039f4a1c991 100644
--- a/src/jsc/StringBuilder.rs
+++ b/src/jsc/StringBuilder.rs
@@ -25,13 +25,6 @@ impl StringBuilder {
         }
     }
 
-    // PORT NOTE: Zig's `append(comptime append_type: Append, value: append_type.Type())`
-    // dispatches on a comptime enum to pick the value's *type*. Rust const
-    // generics cannot vary a parameter's type by enum value, and a trait would
-    // collide (e.g. `String` is used for both `.string` and `.quoted_json_string`).
-    // Each comptime arm is therefore a separate method below; callers that wrote
-    // `sb.append(.latin1, s)` now write `sb.append_latin1(s)`.
-
     pub fn append_latin1(&mut self, value: &[u8]) {
         // SAFETY: forwards a valid (ptr,len) slice to C++.
         unsafe { StringBuilder__appendLatin1(self, value.as_ptr(), value.len()) }
@@ -71,9 +64,8 @@ impl StringBuilder {
     }
 
     pub fn to_string(&mut self, global: &JSGlobalObject) -> JsResult<JSValue> {
-        // PORT NOTE: Zig wraps this in a TopExceptionScope. `from_js_host_call`
-        // is the equivalent shape (call FFI → check pending exception); using it
-        // here avoids the in-place-init / pinning dance TopExceptionScope needs.
+        // `from_js_host_call` (call FFI → check pending exception) avoids the
+        // in-place-init / pinning dance TopExceptionScope needs.
         crate::from_js_host_call(global, || StringBuilder__toString(self, global))
     }
 
@@ -88,8 +80,6 @@ impl Drop for StringBuilder {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `StringBuilder` is `#[repr(C, align(8))]` with a single `[u8; SIZE]` field,
 // so `&mut StringBuilder` is ABI-identical to a non-null aligned `void*` to the
 // inline `WTF::StringBuilder` storage. The shims that take only that handle
@@ -112,5 +102,3 @@ unsafe extern "C" {
     safe fn StringBuilder__toString(this: &mut StringBuilder, global: &JSGlobalObject) -> JSValue;
     safe fn StringBuilder__ensureUnusedCapacity(this: &mut StringBuilder, additional: usize);
 }
-
-// ported from: src/jsc/StringBuilder.zig
diff --git a/src/jsc/Strong.rs b/src/jsc/Strong.rs
index 1bf04d7255c..11a71198c1c 100644
--- a/src/jsc/Strong.rs
+++ b/src/jsc/Strong.rs
@@ -6,7 +6,7 @@ use core::ptr::NonNull;
 
 use crate::{JSGlobalObject, JSValue};
 
-// PORT NOTE: field renamed from `impl` (Rust keyword) to `handle`.
+// Note: field renamed from `impl` (Rust keyword) to `handle`.
 pub struct Strong {
     handle: NonNull<Impl>,
     // NonNull<T> is already !Send + !Sync, matching the requirement that
@@ -57,16 +57,14 @@ impl Drop for Strong {
     fn drop(&mut self) {
         // SAFETY: `self.handle` came from `Impl::init` and is consumed exactly once here.
         unsafe { Impl::destroy(self.handle) };
-        // Zig: `if (Environment.isDebug) strong.* = undefined;` — Rust drop
-        // already invalidates the binding; no poison needed.
     }
 }
 
 /// Holds a strong reference to a JS value, protecting it from garbage
 /// collection. When not holding a value, the strong may still be allocated.
-// PORT NOTE: field renamed from `impl` (Rust keyword) to `handle`.
-// `#[repr(transparent)]` matches the Zig layout (`?*Impl` — single nullable
-// pointer) so it stays FFI-safe when embedded in `extern "C"` structs.
+// Note: field renamed from `impl` (Rust keyword) to `handle`.
+// `#[repr(transparent)]` over a single nullable pointer keeps this FFI-safe
+// when embedded in `extern "C"` structs.
 #[repr(transparent)]
 #[derive(Default)]
 pub struct Optional {
@@ -109,8 +107,6 @@ impl Optional {
         let Some(function) = self.try_swap() else {
             return JSValue::ZERO;
         };
-        // PORT NOTE: Zig source (Strong.zig:71) calls `function.call(global, args)`
-        // which predates the `thisValue` param on JSValue.call; pass `.undefined`.
         function
             .call(global, JSValue::UNDEFINED, args)
             .unwrap_or(JSValue::ZERO)
@@ -159,9 +155,8 @@ impl Optional {
         Some(result)
     }
 
-    /// Explicit teardown for call sites ported from Zig that wrote
-    /// `strong.deinit()` (Strong.zig:96). Idempotent; equivalent to dropping
-    /// in place and leaving `self` empty so `Drop` is a no-op.
+    /// Explicit teardown. Idempotent; equivalent to dropping in place and
+    /// leaving `self` empty so `Drop` is a no-op.
     pub fn deinit(&mut self) {
         let Some(r) = self.handle.take() else { return };
         // SAFETY: `r` came from `Impl::init` and is consumed exactly once here.
@@ -202,11 +197,10 @@ impl Impl {
 
     pub fn get(this: NonNull<Impl>) -> JSValue {
         // `this` is actually a pointer to a `JSC::JSValue`; see Strong.cpp.
-        // SAFETY: HandleSlot storage is a live, aligned JSC::JSValue (encoded i64) for the
-        // lifetime of the Impl handle. JSValue stub is `#[repr(transparent)] usize` (same
-        // size); reading it directly is the encode() operation.
-        // TODO(port): once DecodedJSValue.rs un-gates, switch back to `(*js_value).encode()`.
-        unsafe { *this.as_ptr().cast::<JSValue>() }
+        // SAFETY: HandleSlot storage is a live, aligned JSC::JSValue for the
+        // lifetime of the Impl handle; `DecodedJSValue` is its `#[repr(C)]`
+        // ABI-compatible mirror.
+        unsafe { (*this.as_ptr().cast::<crate::DecodedJSValue>()).encode() }
     }
 
     pub fn set(this: NonNull<Impl>, global: &JSGlobalObject, value: JSValue) {
@@ -246,8 +240,6 @@ impl Impl {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `Impl` and `JSGlobalObject` are opaque `UnsafeCell`-backed ZST handles, so
 // `&Impl`/`&JSGlobalObject` are ABI-identical to non-null `*const T` and C++
 // mutating through them (HandleSet slot write) is interior mutation invisible
@@ -260,5 +252,3 @@ unsafe extern "C" {
 }
 
 pub use crate::deprecated_strong as deprecated;
-
-// ported from: src/jsc/Strong.zig
diff --git a/src/jsc/SystemError.rs b/src/jsc/SystemError.rs
index f8d46cd1b0e..a8ab99dad8f 100644
--- a/src/jsc/SystemError.rs
+++ b/src/jsc/SystemError.rs
@@ -20,9 +20,6 @@ pub struct SystemError {
     pub dest: String,
 }
 
-// Zig `extern struct` field defaults: `errno=0, code/path/syscall/hostname/dest=.empty,
-// fd=c_int::MIN`. Provide `Default` so call sites can `..Default::default()`-init the
-// way Zig partial-inits.
 impl Default for SystemError {
     fn default() -> Self {
         Self {
@@ -39,9 +36,8 @@ impl Default for SystemError {
 }
 
 /// Reshape the T1 `bun_sys::SystemError` (non-`#[repr(C)]`, different field
-/// order) into the `#[repr(C)]` extern layout C++ reads. In Zig there is one
-/// `jsc.SystemError`; the Rust port split data (T1) from the JSC bridge (T6) —
-/// this `From` is the canonical layering seam (see PORTING.md §_jsc bridge).
+/// order) into the `#[repr(C)]` extern layout C++ reads. Data (T1) is split
+/// from the JSC bridge (T6) — this `From` is the canonical layering seam.
 impl From<bun_sys::SystemError> for SystemError {
     fn from(e: bun_sys::SystemError) -> Self {
         Self {
@@ -60,7 +56,6 @@ impl From<bun_sys::SystemError> for SystemError {
 /// `core::result::Result` alias in Phase F so callers get `?` for free.
 pub type Maybe<R> = core::result::Result<R, SystemError>;
 
-// TODO(port): move to jsc_sys
 // SAFETY (safe fn): `SystemError` is `#[repr(C)]` and read-only on the C++ side;
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed handle, so `&JSGlobalObject`
 // is ABI-identical to a non-null `JSGlobalObject*` with write provenance.
@@ -96,23 +91,20 @@ impl SystemError {
         self.dest.ref_();
     }
 
-    /// Bitwise-copy + bump every `bun_core::String` ref. Mirrors Zig
-    /// `var v = this.*; v.ref();` (used by `Body.ValueError.dupe`).
+    /// Bitwise-copy + bump every `bun_core::String` ref.
     /// `bun_core::String` has no `Clone` impl (intrusive WTF refcount), so
     /// `#[derive(Clone)]` is unavailable; this is the manual equivalent.
     pub fn dupe(&self) -> SystemError {
         // SAFETY: `SystemError` is `#[repr(C)]` and every field is either `c_int`
         // (trivially copyable) or `bun_core::String` — a `#[repr(C)]` smart-ptr
         // whose bitwise copy is sound provided we immediately bump each ref
-        // (preventing a double-free on drop). This is exactly the Zig spec
-        // `var v = this.*; v.ref();`.
+        // (preventing a double-free on drop).
         let mut v: SystemError = unsafe { core::ptr::read(self) };
         v.ref_();
         v
     }
 
     pub fn to_error_instance(&self, global: &JSGlobalObject) -> JSValue {
-        // Zig: defer this.deref();
         let result = SystemError__toErrorInstance(self, global);
         self.deref();
         result
@@ -152,7 +144,6 @@ impl SystemError {
     /// implementing follows this convention. It is exclusively used
     /// to match the error code that `node:os` throws.
     pub fn to_error_instance_with_info_object(&self, global: &JSGlobalObject) -> JSValue {
-        // Zig: defer this.deref();
         let result = SystemError__toErrorInstanceWithInfoObject(self, global);
         self.deref();
         result
@@ -165,7 +156,7 @@ impl SystemError {
 /// LAYERING: lives here (not `bun_runtime::socket::uws_jsc`) so both
 /// `bun_runtime` and `bun_sql_jsc` import the single canonical body — both
 /// crates already depend on `bun_jsc` + `bun_uws`, and the body touches
-/// nothing higher-tier. Spec: `src/runtime/socket/uws_jsc.zig`.
+/// nothing higher-tier.
 pub fn verify_error_to_js(
     err: &bun_uws::us_bun_verify_error_t,
     global: &JSGlobalObject,
@@ -184,10 +175,9 @@ pub fn verify_error_to_js(
 
 impl fmt::Display for SystemError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // PORT NOTE: bun.Output.prettyFmt is a comptime color-tag → ANSI transformer that
-        // takes (fmt_str, comptime enable_colors) and returns a comptime-expanded format
-        // string; `bun_core::pretty_fmt!` is the Rust equivalent. The runtime bool → comptime
-        // dispatch (`switch (b) { inline else => |c| ... }`) is preserved as an if/else.
+        // Note: `bun_core::pretty_fmt!` expands color tags in the format
+        // string at compile time for both the colored and uncolored variants;
+        // the runtime ANSI-support check selects between them via if/else.
         if !self.path.is_empty() {
             // TODO: remove this hardcoding
             if bun_core::Output::enable_ansi_colors_stderr() {
@@ -223,5 +213,3 @@ impl fmt::Display for SystemError {
         }
     }
 }
-
-// ported from: src/jsc/SystemError.zig
diff --git a/src/jsc/Task.rs b/src/jsc/Task.rs
index ba49ca096fd..ebe4a868f54 100644
--- a/src/jsc/Task.rs
+++ b/src/jsc/Task.rs
@@ -3,8 +3,8 @@
 //! Per `docs/PORTING.md` §Dispatch hot-path: this crate (low/mid tier) only
 //! stores `{ tag: u8, ptr: *mut () }` and a one-shot hook; the per-tick
 //! `match` over all ~96 variant types lives in `bun_runtime::dispatch`
-//! (high tier — it owns every variant type). LLVM inlines the high-tier arms
-//! exactly as the Zig `inline else` did; this layer never names a variant.
+//! (high tier — it owns every variant type). LLVM inlines the high-tier arms;
+//! this layer never names a variant.
 //!
 //! To add a new task to the queue:
 //! 1. Add a tag constant to `bun_event_loop::task_tag` (the canonical list).
@@ -23,8 +23,7 @@ pub use bun_event_loop::{Task, TaskTag, Taskable, task_tag};
 
 /// `Task::new<T: Taskable>(ptr)` — typed constructor. Kept as a free fn for
 /// back-compat with existing call sites; equivalent to [`Task::init`].
-/// Zig: `Task.init(of: anytype)` derived the tag at comptime from `@TypeOf(of)`;
-/// in Rust the tag comes from the [`Taskable`] impl.
+/// The tag comes from the [`Taskable`] impl.
 #[inline]
 pub fn new<T: Taskable>(ptr: *mut T) -> Task {
     Task::init(ptr)
@@ -52,10 +51,16 @@ pub fn report_error_or_terminate(
     if ex.is_termination_exception() {
         return Err(JsTerminated::JSTerminated);
     }
-    // TODO(port): `global.report_uncaught_exception(ex.as_exception(vm))` —
-    // `JSValue::as_exception` / `JSGlobalObject::report_uncaught_exception`
-    // surface lands when JSGlobalObject.rs un-gates.
-    let _ = (global, ex);
+    let vm = std::ptr::from_ref::<crate::VM>(global.vm()).cast_mut();
+    let exc = ex
+        .as_exception(vm)
+        .expect("exception value must be an Exception cell");
+    // `as_exception` returned a non-null cell pointer rooted on the VM;
+    // `Exception` is an opaque ZST handle — safe deref (panics on null).
+    let _ = crate::js_global_object::report_uncaught_exception(
+        global,
+        crate::Exception::opaque_ref(exc),
+    );
     Ok(())
 }
 
@@ -63,5 +68,3 @@ pub fn report_error_or_terminate(
 // `bun_runtime::dispatch::run_tasks` per §Dispatch hot-path — every arm names
 // a `bun_runtime`/`bun_shell`/`bun_s3` type and so cannot compile at this tier.
 // See git history of this file for the original draft.
-
-// ported from: src/jsc/Task.zig
diff --git a/src/jsc/TextCodec.rs b/src/jsc/TextCodec.rs
index 1ef0066660a..29688c5507c 100644
--- a/src/jsc/TextCodec.rs
+++ b/src/jsc/TextCodec.rs
@@ -3,7 +3,6 @@ use core::ptr::NonNull;
 use crate::mark_binding;
 use bun_core::String as BunString;
 
-// TODO(port): move to <jsc>_sys
 unsafe extern "C" {
     fn Bun__createTextCodec(
         encoding_name: *const u8,
@@ -46,7 +45,7 @@ impl TextCodec {
         unsafe { Bun__createTextCodec(encoding.as_ptr(), encoding.len()) }
     }
 
-    // PORT NOTE: FFI-owned opaque; constructed/destroyed across FFI, so explicit
+    // FFI-owned opaque; constructed/destroyed across FFI, so explicit
     // destroy instead of `impl Drop` (cannot own a `TextCodec` by value).
     pub unsafe fn destroy(this: *mut TextCodec) {
         mark_binding!();
@@ -96,5 +95,3 @@ impl TextCodec {
         Some(unsafe { bun_core::ffi::slice(name.as_ptr(), len) })
     }
 }
-
-// ported from: src/jsc/TextCodec.zig
diff --git a/src/jsc/TopExceptionScope.rs b/src/jsc/TopExceptionScope.rs
index 50c6375a5f9..4720a093b6c 100644
--- a/src/jsc/TopExceptionScope.rs
+++ b/src/jsc/TopExceptionScope.rs
@@ -11,7 +11,8 @@ const SIZE: usize = 56;
 const SIZE: usize = 8;
 const ALIGNMENT: usize = 8;
 
-/// Mirrors `std.builtin.SourceLocation`. Rust's `core::panic::Location` lacks `fn_name`
+/// A NUL-terminated source location (function name, file, line, column).
+/// Rust's `core::panic::Location` lacks `fn_name`
 /// and is not NUL-terminated, so callers construct this via the [`src!`](crate::src) macro
 /// (which captures `module_path!()`/`file!()`/`line!()` as NUL-terminated literals) or via
 /// [`SourceLocation::from_caller`] which interns the runtime `Location` for `#[track_caller]`
@@ -332,8 +333,7 @@ impl TopExceptionScope {
                 // (not via `debug_assert!`): release+ASAN builds enter here via
                 // `bun_asan` with `debug_assertions` off, and the C++ scope's
                 // destructor will fail `verifyExceptionCheckNeedIsSatisfied` unless
-                // the underlying `VM::exception()` was actually invoked. Zig spec
-                // uses `bun.assertf` (active under `ci_assert`, which includes ASAN).
+                // the underlying `VM::exception()` was actually invoked.
                 assert!(self.has_exception(), "Expected an exception to be thrown");
             } else {
                 self.assert_no_exception();
@@ -425,9 +425,8 @@ macro_rules! validation_scope {
 
 /// Limited subset of TopExceptionScope functionality, for when you have a different way to detect
 /// exceptions and you only need a TopExceptionScope to prove that you are checking exceptions correctly.
-/// Gated by `cfg(any(debug_assertions, bun_asan))` — Zig's `Environment.ci_assert` is
-/// `isDebug || isTest || enable_asan || (ReleaseSafe && is_canary)`; the bun_jsc crate has no
-/// `ci_assert` Cargo feature, so gate on the same predicate this file already uses for `SIZE`.
+/// Gated by `cfg(any(debug_assertions, bun_asan))` — the same predicate this file
+/// already uses for `SIZE`.
 /// Without this, debug builds left the scope as a no-op while `debug_assert!` callers (e.g.
 /// `bun_string_jsc::from_js`) still fired, panicking on every legitimate stringify exception.
 ///
@@ -597,14 +596,14 @@ impl ExceptionValidationScope {
     }
 }
 
-// ──────────────── per-mode FFI-call wrappers (Rust analogue of cpp.zig) ────────────────
+// ──────────────── per-mode FFI-call wrappers ────────────────
 //
 // `src/codegen/cppbind.ts` parses C++ `[[ZIG_EXPORT(mode)]]` attributes and emits
-// `build/<profile>/codegen/cpp.zig`, where each throwing FFI gets a typed wrapper that
+// typed wrappers into `cpp.rs` (see `generateRustFn` in cppbind.ts), which
+// `bun_jsc::cpp` `include!`s. Each throwing FFI gets a wrapper that
 // (a) opens an `ExceptionValidationScope`/`TopExceptionScope` *before* the call,
 // (b) asserts the return-value sentinel agrees with the scope's exception state, and
-// (c) converts to `error{JSError}`. The Rust port emits the same wrappers into
-// `cpp.rs` (see `generateRustFn` in cppbind.ts), which `bun_jsc::cpp` `include!`s.
+// (c) converts to `JsResult`.
 //
 // These four helpers are the per-mode bodies the generated wrappers (and hand-written
 // FFI shims in `JSValue.rs`/`JSPromise.rs`/etc.) delegate to. They are *not* the
@@ -696,9 +695,8 @@ pub fn call_null_is_throw<T>(
 ///
 /// Under `cfg(any(debug_assertions, bun_asan))` this opens a real [`TopExceptionScope`]
 /// so `simulateThrow()` is satisfied and the assertion fires on mismatch. In release
-/// builds the C++ validation machinery is compiled out, so we match Zig's generated
-/// `check_slow` wrapper exactly: single `Bun__RETURN_IF_EXCEPTION` FFI call after the
-/// closure (1 FFI hop instead of 3).
+/// builds the C++ validation machinery is compiled out: a single
+/// `Bun__RETURN_IF_EXCEPTION` FFI call after the closure (1 FFI hop instead of 3).
 #[inline]
 pub fn call_check_slow_at<R>(
     global: &JSGlobalObject,
@@ -791,5 +789,3 @@ unsafe extern "C" {
     safe fn TopExceptionScope__assertNoException(ptr: &mut [u8; SIZE]);
     fn TopExceptionScope__destruct(ptr: *mut [u8; SIZE]);
 }
-
-// ported from: src/jsc/TopExceptionScope.zig
diff --git a/src/jsc/URL.rs b/src/jsc/URL.rs
index 91cde9561fe..bc2fe0fa2cb 100644
--- a/src/jsc/URL.rs
+++ b/src/jsc/URL.rs
@@ -3,18 +3,11 @@ use core::ptr::NonNull;
 use bun_core::String;
 use bun_jsc::{JSGlobalObject, JSValue, JsResult};
 
-// PORT NOTE: `jsc.markBinding(@src())` calls were dropped — debug-only binding-trace
-// helper with no Rust equivalent; a `mark_binding!()` macro could be added if wanted.
-
 bun_opaque::opaque_ffi! {
     /// Opaque handle to a WebKit `WTF::URL` allocated on the C++ side.
     pub struct URL;
 }
 
-// TODO(port): move to jsc_sys
-// PORT NOTE: getters take `*const URL` — the C++ side (BunString.cpp) never mutates the
-// WTF::URL on read. `JSGlobalObject` is an opaque FFI handle whose state Rust never
-// observes directly, so it is passed `*const` per the JSGlobalObject.rs convention.
 // Getters take `&URL` (non-null `*const URL` at the C ABI; BunString.cpp never
 // mutates the WTF::URL on read). `&mut String` for the in/out params is
 // ABI-identical to non-null `*mut String`. `URL__deinit` consumes the C++
@@ -77,13 +70,11 @@ impl URL {
     /// If it fails, the tag is marked Dead
     #[track_caller]
     pub fn href_from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<String> {
-        // Zig (URL.zig): `fromJSHostCallGeneric` (== `call_check_slow`).
         crate::call_check_slow(global, || URL__getHrefFromJS(value, global))
     }
 
     #[track_caller]
     pub fn from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<Option<NonNull<URL>>> {
-        // Zig (URL.zig): `fromJSHostCallGeneric` (== `call_check_slow`).
         crate::call_check_slow(global, || URL__fromJS(value, global)).map(NonNull::new)
     }
 
@@ -95,8 +86,8 @@ impl URL {
         let mut input = str;
         NonNull::new(URL__fromString(&mut input))
     }
-    // TODO(port): from_js/from_string/from_utf8 return an owned C++ heap pointer that
-    // the caller must destroy(). Consider an RAII wrapper instead of NonNull<URL>.
+    // from_js/from_string/from_utf8 return an owned C++ heap pointer that the
+    // caller must destroy().
 
     pub fn protocol(&self) -> String {
         URL__protocol(self)
@@ -148,7 +139,7 @@ impl URL {
         URL__port(self)
     }
 
-    // PORT NOTE: kept as explicit destroy (not Drop) — URL is an opaque #[repr(C)] FFI
+    // Kept as explicit destroy (not Drop) — URL is an opaque #[repr(C)] FFI
     // handle constructed/destroyed across the C++ boundary.
     pub unsafe fn destroy(this: *mut Self) {
         // SAFETY: `this` is a valid *URL from C++; freed exactly once
@@ -159,5 +150,3 @@ impl URL {
         URL__pathname(self)
     }
 }
-
-// ported from: src/jsc/URL.zig
diff --git a/src/jsc/URLSearchParams.rs b/src/jsc/URLSearchParams.rs
index d6b15d361a2..e911c332468 100644
--- a/src/jsc/URLSearchParams.rs
+++ b/src/jsc/URLSearchParams.rs
@@ -9,7 +9,6 @@ bun_opaque::opaque_ffi! {
     pub struct URLSearchParams;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     safe fn URLSearchParams__create(global_object: &JSGlobalObject, init: &ZigString) -> JSValue;
     safe fn URLSearchParams__fromJS(value: JSValue) -> Option<NonNull<URLSearchParams>>;
@@ -28,15 +27,15 @@ impl URLSearchParams {
         URLSearchParams__create(global_object, &init)
     }
 
-    // TODO(port): lifetime — opaque handle is owned by the JS GC heap, not by `value`.
+    // The returned opaque handle is owned by the JS GC heap, not by `value`;
+    // callers must keep the JS object alive while using it.
     pub fn from_js(value: JSValue) -> Option<NonNull<URLSearchParams>> {
         URLSearchParams__fromJS(value)
     }
 
     pub fn to_string<Ctx>(&mut self, ctx: &mut Ctx, callback: fn(ctx: &mut Ctx, str: ZigString)) {
-        // PORT NOTE: reshaped — Zig captured `callback` at comptime so the C trampoline
-        // only needed `ctx` through the void*. Rust cannot take a fn pointer as a const
-        // generic, so pack (ctx, callback) on the stack and pass that instead.
+        // A fn pointer cannot be a const generic, so pack (ctx, callback) on the
+        // stack and pass the pair through the C trampoline's void* context.
         struct Wrap<'a, Ctx> {
             ctx: &'a mut Ctx,
             callback: fn(&mut Ctx, ZigString),
@@ -58,5 +57,3 @@ impl URLSearchParams {
         URLSearchParams__toString(self, (&raw mut w).cast::<c_void>(), cb::<Ctx>);
     }
 }
-
-// ported from: src/jsc/URLSearchParams.zig
diff --git a/src/jsc/VM.rs b/src/jsc/VM.rs
index ab94568a0d9..bfe379e7e72 100644
--- a/src/jsc/VM.rs
+++ b/src/jsc/VM.rs
@@ -2,8 +2,6 @@ use core::ffi::c_void;
 
 use crate::{Exception, JSGlobalObject, JSValue, JsError};
 
-// TODO(port): move to <jsc>_sys
-//
 // All JSC__VM__* shims take only a `JSC::VM*` (and at most a
 // `JSGlobalObject*` / `JSC::Exception*` / scalar). `VM` and `JSGlobalObject`
 // are opaque `UnsafeCell`-backed ZST handles, so `&VM` is ABI-identical to a
@@ -64,11 +62,10 @@ pub enum HeapType {
 }
 
 impl VM {
-    // PORT NOTE: `JSC__VM__create` was removed from bindings.cpp (Bun creates
+    // Note: `JSC__VM__create` was removed from bindings.cpp (Bun creates
     // its VM via `Zig::GlobalObject::create` → `WebWorker__createVM` instead).
-    // The Zig `VM.create` wrapper is dead code; do not port it.
 
-    // PORT NOTE: not `impl Drop` — takes a `global_object` param and `VM` is an opaque FFI handle.
+    // Note: not `impl Drop` — takes a `global_object` param and `VM` is an opaque FFI handle.
     pub fn deinit(&self, global_object: &JSGlobalObject) {
         JSC__VM__deinit(self, global_object)
     }
@@ -97,19 +94,17 @@ impl VM {
         Lock { vm: self }
     }
 
-    // PORT NOTE: `JSC__VM__deferGC` was removed from bindings.cpp in the
-    // WebKit-bump that introduced `JSC::DeferGC` RAII; the Zig `deferGC`
-    // wrapper is dead code. Callers should use `holdAPILock`/`DeferGC` on the
-    // C++ side instead.
+    // Note: `JSC__VM__deferGC` was removed from bindings.cpp in the
+    // WebKit-bump that introduced `JSC::DeferGC` RAII. Callers should use
+    // `holdAPILock`/`DeferGC` on the C++ side instead.
 
     pub fn report_extra_memory(&self, size: usize) {
         crate::mark_binding!();
         JSC__VM__reportExtraMemory(self, size)
     }
 
-    /// Alias retained for parity with the Zig comment naming this the
-    /// "deprecated" GC accounting hook (the underlying C++ is
-    /// `Heap::deprecatedReportExtraMemory`). Forward to [`report_extra_memory`].
+    /// Alias for the "deprecated" GC accounting hook (the underlying C++ is
+    /// `Heap::deprecatedReportExtraMemory`). Forwards to [`report_extra_memory`].
     #[inline]
     pub fn deprecated_report_extra_memory(&self, size: usize) {
         self.report_extra_memory(size);
@@ -222,14 +217,13 @@ impl VM {
     }
 }
 
-/// RAII JSLockHolder returned by [`VM::get_api_lock`]. Mirrors Zig
-/// `JSC.VM.Lock` (`defer api_lock.release()` → `Drop`).
+/// RAII JSLockHolder returned by [`VM::get_api_lock`]. Released on `Drop`.
 pub struct Lock<'a> {
     vm: &'a VM,
 }
 
 impl<'a> Lock<'a> {
-    /// Explicit release (Zig spelling). Equivalent to `drop(self)`.
+    /// Explicit release. Equivalent to `drop(self)`.
     #[inline]
     pub fn release(self) {}
 }
@@ -239,5 +233,3 @@ impl Drop for Lock<'_> {
         JSC__VM__releaseAPILock(self.vm)
     }
 }
-
-// ported from: src/jsc/VM.zig
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index 1a96c995d9b..999122f4b47 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -50,7 +50,7 @@ pub fn synthetic_allocation_limit() -> usize {
 }
 // `string_allocation_limit` lives in `bun_core` (read by `String::max_length`
 // without an upward dep on this crate) and is C-exported there as
-// `Bun__stringSyntheticAllocationLimit`. Re-export under the Zig spec name.
+// `Bun__stringSyntheticAllocationLimit`.
 pub use bun_core::STRING_ALLOCATION_LIMIT;
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -59,7 +59,7 @@ pub use bun_core::STRING_ALLOCATION_LIMIT;
 
 pub(crate) type OnUnhandledRejection = fn(&mut VirtualMachine, &JSGlobalObject, JSValue);
 pub(crate) type MacroMap = bun_collections::ArrayHashMap<i32, jsc::C::JSObjectRef>;
-/// Spec VirtualMachine.zig:144 `ExceptionList`. `api::JsException` lives in
+/// `api::JsException` lives in
 /// [`crate::schema_api`] (not `bun_options_types::schema::api`) because its
 /// `stack: StackTrace` field transitively names `ZigStackFramePosition` from
 /// this crate — see the `schema_api` module doc in lib.rs.
@@ -76,29 +76,26 @@ pub struct EntryPointResult {
 }
 
 /// Downstream-compat alias: lib.rs previously exposed `virtual_machine::InitOptions`.
-/// Carries the cross-tier subset of Zig `Options` that [`init`] and
+/// Carries the cross-tier subset of `Options` that [`init`] and
 /// `RuntimeHooks::init_runtime_state` need. `transform_options`/`debugger`
 /// live in `bun_options_types` (already a dep of `bun_jsc`), so they thread
 /// through here instead of being dropped at the CLI call-site.
 pub struct InitOptions {
-    /// Spec VirtualMachine.zig:1207 `Options.args` — the CLI's
-    /// `api.TransformOptions`. Consumed by `RuntimeHooks::init_runtime_state`
+    /// The CLI's `api.TransformOptions`. Consumed by `RuntimeHooks::init_runtime_state`
     /// → `Transpiler::init(.., configureTransformOptionsForBunVM(args), ..)`.
     pub transform_options: bun_options_types::schema::api::TransformOptions,
-    /// Spec VirtualMachine.zig:1215 `Options.debugger` —
-    /// `bun.cli.Command.Debugger` (now `bun_options_types::context::Debugger`).
     /// Consumed by `RuntimeHooks::init_runtime_state` → `configureDebugger`.
     pub debugger: bun_options_types::context::Debugger,
-    /// Spec VirtualMachine.zig:1208 `Options.log`. When `Some`, [`init`] adopts
+    /// When `Some`, [`init`] adopts
     /// the caller's log instead of boxing a fresh one (CLI-path macros pass the
     /// transpiler's log so macro load errors land in the bundle output).
     pub log: Option<NonNull<bun_ast::Log>>,
-    /// Spec VirtualMachine.zig:1210 `Options.env_loader`. Forwarded to
+    /// Forwarded to
     /// `RuntimeHooks::init_runtime_state` so the high-tier `Transpiler::init`
     /// reuses the caller's env loader.
     pub env_loader: Option<NonNull<bun_dotenv::Loader<'static>>>,
     pub graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
-    /// Spec VirtualMachine.zig:1211 `Options.store_fd`. Must be applied to
+    /// Must be applied to
     /// `transpiler.resolver.store_fd` BEFORE `configure_linker()` reads
     /// `top_level_dir`, so it threads through `init_runtime_state`.
     pub store_fd: bool,
@@ -106,16 +103,15 @@ pub struct InitOptions {
     pub eval_mode: bool,
     pub is_main_thread: bool,
     /// Forwarded to `Zig__GlobalObject__create` so the C++ ZigGlobalObject is
-    /// created with its `WebCore::Worker*` already wired (spec
-    /// VirtualMachine.zig:1477-1484). `null` for the main-thread / bake paths.
+    /// created with its `WebCore::Worker*` already wired. `null` for the
+    /// main-thread / bake paths.
     pub worker_ptr: *mut c_void,
     /// Debugger script-execution-context id. Main thread = 1, workers receive
     /// `WebWorker::execution_context_id`; `None` lets [`init`] derive it from
     /// `is_main_thread` (matches the previous behaviour for non-worker init).
     pub context_id: Option<i32>,
     /// Forwarded as `mini_mode` to `Zig__GlobalObject__create`. For the
-    /// main-thread path this is `smol`; for workers it is `WebWorker::mini`
-    /// (spec VirtualMachine.zig:1482).
+    /// main-thread path this is `smol`; for workers it is `WebWorker::mini`.
     pub mini_mode: bool,
 }
 
@@ -142,15 +138,17 @@ pub struct VirtualMachine {
     pub global: *mut JSGlobalObject,
     // allocator dropped per §Allocators (global mimalloc)
     pub has_loaded_constructors: bool,
-    // TODO(port): lifetime — `Transpiler<'a>` borrows `log`/`allocator`; VM is
+    // LIFETIME-ERASED: `Transpiler<'a>` borrows `log`/`allocator`; VM is
     // self-referential and cannot carry `<'a>`, so we erase to `'static` and the
     // owner guarantees the borrowed `log` outlives the VM (see `init`).
     pub transpiler: Transpiler<'static>,
-    // TODO(b2-cycle): `bun_watcher` is `ImportWatcher` from hot_reloader.rs (gated sibling).
-    pub bun_watcher: *mut c_void,
+    /// Hot-reload import watcher (heap `Box`, installed by
+    /// [`crate::hot_reloader::HotReloaderCtx::install_bun_watcher`]); null when
+    /// hot reload is disabled. Read via [`Self::bun_watcher_ptr`].
+    pub bun_watcher: *mut crate::hot_reloader::ImportWatcher,
     pub console: *mut crate::console_object::ConsoleObject,
-    // TODO(port): lifetime — LIFETIMES.tsv says BORROW_PARAM (`&'a mut bun_ast::Log`);
-    // raw NonNull used because VM is self-referential and cannot carry `<'a>`.
+    // BORROW_PARAM (`&'a mut bun_ast::Log` per LIFETIMES.tsv) — raw NonNull
+    // used because VM is self-referential and cannot carry `<'a>`.
     pub log: Option<NonNull<bun_ast::Log>>,
     /// Path of the entry module. BACKREF — borrows process-argv, the resolver's
     /// process-lifetime `dirname_store`/`filename_store`, the standalone module
@@ -166,7 +164,9 @@ pub struct VirtualMachine {
     pub overridden_main: crate::strong::Optional,
     pub entry_point: bun_bundler::entry_points::ServerEntryPoint,
     pub origin: bun_url::URL<'static>,
-    // TODO(b2-cycle): `node_fs` is `Option<Box<bun_runtime::node::fs::NodeFS>>`.
+    // LAYERING: real type is `Option<Box<bun_runtime::node::fs::NodeFS>>`, but
+    // `bun_runtime` is a forward dep of this crate; stored type-erased and
+    // cast back by the `bun_runtime` consumers.
     pub node_fs: Option<*mut c_void>,
     /// Opaque per-VM `bun_runtime` state (boxed `timer::All` +
     /// `Body::Value::HiveAllocator` + …). Set by
@@ -174,30 +174,33 @@ pub struct VirtualMachine {
     /// `RuntimeHooks::deinit_runtime_state` in [`destroy`]. Null when no high
     /// tier is installed (e.g. `bun_jsc` unit tests).
     ///
-    /// PORT NOTE: the Zig `timer: api.Timer.All` and
-    /// `body_value_pool: webcore.Body.Value.HiveAllocator` value
-    /// fields live inside this box rather than as `()` shadows here — both
-    /// types are owned by `bun_runtime` (forward dep). Access goes through
+    /// Note: the per-VM timer state and body-value pool live inside this box —
+    /// both types are owned by `bun_runtime` (forward dep). Access goes through
     /// [`RuntimeHooks::timer_insert`] / [`RuntimeHooks::body_value_hive_ref`].
     pub runtime_state: *mut c_void,
     pub event_loop_handle: Option<*mut PlatformEventLoop>,
-    pub pending_unref_counter: i32,
+    /// Pending `unref` count drained by the event-loop thread. Atomic because
+    /// `KeepAlive::unref_on_next_tick_concurrently` increments it from OTHER
+    /// threads.
+    pub pending_unref_counter: core::sync::atomic::AtomicI32,
     pub preload: Vec<Box<[u8]>>,
     pub unhandled_pending_rejection_to_capture: Option<*mut JSValue>,
-    // PORT NOTE: layering — the concrete `bun_standalone_graph::Graph` lives
+    // Note: layering — the concrete `bun_standalone_graph::Graph` lives
     // in a higher-tier crate. The resolver already broke that cycle with the
     // `bun_resolver::StandaloneModuleGraph` trait; we hold the same trait
     // object here so `init_with_module_graph` can hand it straight to
     // `transpiler.resolver.standalone_module_graph` without a downcast.
     pub standalone_module_graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
     pub smol: bool,
-    // TODO(b2-cycle): `dns_result_order` is `bun_runtime::api::dns::Resolver::Order`.
+    // LAYERING: real type is `bun_runtime::api::dns::Resolver::Order` (forward
+    // dep); stored as its `u8` repr.
     pub dns_result_order: u8,
     pub cpu_profiler_config: Option<crate::bun_cpu_profiler::CPUProfilerConfig>,
     pub heap_profiler_config: Option<crate::bun_heap_profiler::HeapProfilerConfig>,
     pub counters: Counters,
 
-    // TODO(b2-cycle): `hot_reload` is `bun_runtime::cli::Command::HotReload`.
+    // LAYERING: real type is `bun_runtime::cli::Command::HotReload` (forward
+    // dep); stored as its `u8` repr (see `HOT_RELOAD_*` constants).
     pub hot_reload: u8,
     pub jsc_vm: *mut VM,
 
@@ -217,7 +220,8 @@ pub struct VirtualMachine {
     pub exit_handler: ExitHandler,
 
     pub default_tls_reject_unauthorized: Option<bool>,
-    // TODO(b2-cycle): `default_verbose_fetch` is `Option<http::HTTPVerboseLevel>`.
+    // LAYERING: real type is `Option<http::HTTPVerboseLevel>` (forward dep);
+    // stored as the enum's `u8` repr.
     pub default_verbose_fetch: Option<u8>,
 
     /// Do not access this field directly! It exists in the VirtualMachine struct so
@@ -226,7 +230,8 @@ pub struct VirtualMachine {
     pub saved_source_map_table: crate::saved_source_map::HashTable,
     pub source_mappings: SavedSourceMap,
 
-    // TODO(port): lifetime — `&'a mut Arena`; caller-owned (web_worker).
+    // BACKREF — `&'a mut Arena` in spirit; caller-owned (web_worker) and
+    // outlives the VM.
     pub arena: Option<NonNull<bun_alloc::Arena>>,
     pub has_loaded: bool,
 
@@ -235,7 +240,8 @@ pub struct VirtualMachine {
     pub had_errors: bool,
 
     pub macros: MacroMap,
-    // TODO(b2-cycle): `MacroEntryPoint` from `bun_bundler::entry_points` (gated).
+    // LAYERING: values are `MacroEntryPoint` from `bun_bundler::entry_points`
+    // (forward dep); stored type-erased and cast back by the consumers.
     pub macro_entry_points: bun_collections::ArrayHashMap<i32, *mut c_void>,
     pub macro_mode: bool,
     /// Depth of live [`MacroModeGuard`]s on this thread. Nonzero exactly while
@@ -265,7 +271,7 @@ pub struct VirtualMachine {
 
     pub argv: Vec<Box<[u8]>>,
 
-    pub origin_timer: std::time::Instant, // TODO(port): std.time.Timer
+    pub origin_timer: std::time::Instant,
     pub origin_timestamp: u64,
     /// For fake timers: override performance.now() with a specific value (in nanoseconds).
     pub overridden_performance_now: Option<u64>,
@@ -297,7 +303,6 @@ pub struct VirtualMachine {
     pub is_handling_uncaught_exception: bool,
     pub exit_on_uncaught_exception: bool,
 
-    // TODO(b2): `modules` is `ModuleLoader::AsyncModule::Queue` (AsyncModule.rs gated).
     pub modules: crate::async_module::Queue,
     pub aggressive_garbage_collection: GCLevel,
 
@@ -315,8 +320,6 @@ pub struct VirtualMachine {
 
     #[cfg(debug_assertions)]
     pub debug_thread_id: std::thread::ThreadId,
-    // PORT NOTE: Zig `if (Environment.isDebug) std.Thread.Id else void` — the
-    // release-build ZST is intentional spec parity, not a placeholder.
     #[cfg(not(debug_assertions))]
     pub debug_thread_id: (),
 
@@ -348,8 +351,6 @@ pub struct VirtualMachine {
 // FFI declarations
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle, so
 // `&JSGlobalObject` is ABI-identical to a non-null `JSGlobalObject*` and C++
 // mutating VM/process state through it is interior mutation invisible to Rust.
@@ -380,7 +381,7 @@ pub const HOT_RELOAD_WATCH: u8 = 2;
 // Nested types
 // ──────────────────────────────────────────────────────────────────────────
 
-#[repr(u8)] // u3 in Zig — smallest fitting repr
+#[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Default)]
 pub enum GCLevel {
     #[default]
@@ -403,20 +404,16 @@ impl UnhandledRejectionScope {
     }
 }
 
-/// Thread-local VM holder (`VMHolder` in VirtualMachine.zig). Wired to the
+/// Thread-local VM holder. Wired to the
 /// crate-level `VirtualMachine::get()`/`set_current()` accessors.
 pub(crate) struct VMHolder;
 
-// PORT NOTE: Zig nests `pub var main_thread_vm` inside the struct namespace;
-// Rust forbids associated `static`s, so it lives at module scope and is
-// re-exported as `VMHolder::MAIN_THREAD_VM` via a const fn accessor.
 pub(crate) static MAIN_THREAD_VM: core::sync::atomic::AtomicPtr<VirtualMachine> =
     core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
 
 // `#[thread_local]` (bare `__thread` slot) instead of `thread_local!` macro:
 // `LocalKey::__getit` adds a lazy-init check + on some targets a
-// `pthread_getspecific` round-trip per access; Zig's `threadlocal var vm`
-// is a single `mov %fs:OFFSET`. `get_or_null()` (which reads `VM`) is the
+// `pthread_getspecific` round-trip per access. `get_or_null()` (which reads `VM`) is the
 // highest-fan-in accessor on the per-request path — every
 // `VirtualMachine::get()/as_mut()/vm_get()` reaches it ≥3× per
 // `run_callback`. Const-init `Cell<ptr>` has no destructor, so no
@@ -499,7 +496,7 @@ impl ExitHandler {
         vm.exit_handler.exit_code = code;
     }
 
-    /// PORT NOTE: spec calls `this.exit_handler.dispatchOnExit()` from a
+    /// Note: spec calls `this.exit_handler.dispatchOnExit()` from a
     /// `*VirtualMachine`. Taking `&mut self: ExitHandler` and recovering the
     /// parent via `container_of` would escape the provenance of `&mut self`
     /// (which only covers the `ExitHandler` field). Callers pass the VM
@@ -535,8 +532,7 @@ pub(crate) const ORIGIN_RELATIVE_EPOCH: i128 = 946_684_800 * 1_000_000_000;
 // ──────────────────────────────────────────────────────────────────────────
 
 /// RAII guard returned by [`VirtualMachine::auto_gc_on_drop`]. Calls
-/// [`VirtualMachine::auto_garbage_collect`] when dropped — the Rust spelling
-/// of Zig's `defer globalThis.bunVM().autoGarbageCollect()`.
+/// [`VirtualMachine::auto_garbage_collect`] when dropped.
 #[must_use = "dropping immediately runs GC now; bind to `let _gc = ...` to defer to scope end"]
 pub struct AutoGcOnDrop<'a> {
     vm: &'a VirtualMachine,
@@ -550,8 +546,7 @@ impl Drop for AutoGcOnDrop<'_> {
 }
 
 /// RAII guard that scopes [`VirtualMachine::enable_macro_mode`] /
-/// [`VirtualMachine::disable_macro_mode`] — the Rust spelling of Zig's
-/// `vm.enableMacroMode(); defer vm.disableMacroMode();` (Macro.zig:120).
+/// [`VirtualMachine::disable_macro_mode`].
 ///
 /// Holds a [`BackRef`] (not `&'a mut`) because callers continue to access the
 /// per-thread VM (event loop, `run_with_api_lock`) while the guard is live;
@@ -636,8 +631,8 @@ impl VirtualMachine {
     /// `*mut VirtualMachine` or need a whole-struct `&mut`.
     ///
     /// Per-request hot path: `vm_get`/`as_mut`/`NewServer::vm_mut` all funnel
-    /// through here, so it is reached several times per `run_callback` (Zig
-    /// just reads the bare `threadlocal var vm`). The previous `.expect()`
+    /// through here, so it is reached several times per `run_callback`. The
+    /// previous `.expect()`
     /// emitted a check + cold-path panic-format branch on every call;
     /// `unwrap_unchecked` collapses to one TLS load. The "no VM on this
     /// thread" case is a programmer error (host_fn reached before `init()`),
@@ -707,7 +702,7 @@ impl VirtualMachine {
         VM.get().is_some()
     }
 
-    /// Installs `vm` as the current thread's VM (Zig: `VMHolder.vm = vm`).
+    /// Installs `vm` as the current thread's VM.
     pub fn set_current(vm: *mut VirtualMachine) {
         VM.set(Some(vm));
     }
@@ -725,8 +720,7 @@ impl VirtualMachine {
         JSGlobalObject::opaque_ref(self.global)
     }
 
-    /// Spec VirtualMachine.zig: `pub fn eventLoop(this: *VirtualMachine) *EventLoop`
-    /// — returns a raw `*EventLoop` (no aliasing guarantee). Returning `&mut`
+    /// Returns a raw `*EventLoop` (no aliasing guarantee). Returning `&mut`
     /// here would let two overlapping callers (e.g. a JS callback re-entering
     /// `vm.event_loop()` from inside `tick()`) mint aliased `&mut EventLoop` to
     /// the same allocation — UB per PORTING.md §Forbidden. Callers form a
@@ -792,22 +786,21 @@ impl VirtualMachine {
     }
 
     /// Raw accessor for the hot-reload import watcher. `bun_watcher` is the
-    /// type-erased `*mut ImportWatcher` installed by
+    /// `*mut ImportWatcher` installed by
     /// [`crate::hot_reloader::HotReloaderCtx::install_bun_watcher`] (separate
     /// `Box` heap allocation), or null when hot reload is disabled.
     ///
     /// NOTE: unlike `event_loop_mut`, the pointee is **not** JS-thread-only —
     /// the inner `Box<Watcher>` is held as `&mut Watcher` for the lifetime of
     /// the spawned file-watcher thread (`Watcher::thread_main`), and
-    /// `RuntimeTranspilerStore` reads it from transpiler workers. The Zig spec
-    /// models this as an alias-allowed `*Watcher` with an internal mutex, so we
+    /// `RuntimeTranspilerStore` reads it from transpiler workers. The pointee
+    /// guards itself with an internal mutex, so we
     /// return the raw pointer and leave the `unsafe` deref at the call site to
     /// keep the cross-thread hazard visible. Callers must scope any reborrow to
     /// a single mutex-guarded `Watcher` operation.
     #[inline]
     pub fn bun_watcher_ptr(&self) -> *mut crate::hot_reloader::ImportWatcher {
         self.bun_watcher
-            .cast::<crate::hot_reloader::ImportWatcher>()
     }
 
     /// `event_loop().enter()` now, `.exit()` on drop. Safe wrapper over
@@ -902,17 +895,13 @@ impl VirtualMachine {
         self.event_loop_handle.map(|h| unsafe { &mut *h })
     }
 
-    /// Read-then-zero `pending_unref_counter`. Wraps the common
-    /// `let n = vm.pending_unref_counter; if n > 0 { vm.pending_unref_counter = 0; ... }`
-    /// pattern so callers don't open-code two raw-ptr writes.
+    /// Read-then-zero `pending_unref_counter`. `swap(0)` so a concurrent
+    /// `increment_pending_unref_counter()` from another thread can't be lost
+    /// between the read and the reset.
     #[inline]
     pub fn take_pending_unref(&self) -> i32 {
-        let this = self.as_mut();
-        let n = this.pending_unref_counter;
-        if n > 0 {
-            this.pending_unref_counter = 0;
-        }
-        n
+        self.pending_unref_counter
+            .swap(0, core::sync::atomic::Ordering::Relaxed)
     }
 
     /// Safe shared accessor for the per-VM `bun_ast::Log`. The log is
@@ -947,17 +936,16 @@ impl VirtualMachine {
         &mut self.source_mappings
     }
 
-    /// Port of `VirtualMachine.sourceMapHandler` (VirtualMachine.zig:441).
     /// Returns a small adaptor whose `get()` produces the erased
     /// `js_printer::SourceMapHandler` for `print_with_source_map`.
     ///
-    /// PORT NOTE: takes `*mut BufferPrinter` (raw), not `&'a mut`, because the
+    /// Note: takes `*mut BufferPrinter` (raw), not `&'a mut`, because the
     /// SAME `BufferPrinter` is also passed as the live `writer` to
     /// `print_with_source_map`. Creating an `&'a mut` here would alias with
     /// that writer borrow for the entire print; instead we stash the raw
     /// pointer and only reborrow inside `on_source_map_chunk` once the
     /// writer's last use (`print_slice`) has retired. See jsc_hooks.rs
-    /// `print_with_source_map` call-site PORT NOTE.
+    /// `print_with_source_map` call-site Note.
     #[inline]
     pub fn source_map_handler<'a>(
         &'a mut self,
@@ -1002,7 +990,6 @@ impl VirtualMachine {
         self.has_run_cleanup_hooks
     }
 
-    /// Port of `VirtualMachine.scriptExecutionStatus` (VirtualMachine.zig:885).
     /// Exported to C++ as `Bun__VM__scriptExecutionStatus` via virtual_machine_exports.rs.
     pub fn script_execution_status(&self) -> crate::ScriptExecutionStatus {
         if self.is_shutting_down {
@@ -1021,7 +1008,7 @@ impl VirtualMachine {
     /// Per-callback hot path: `drain_microtasks_with_global` calls
     /// `uws_loop_mut()` (→ this) every time the microtask queue drains, and
     /// the only call site there is already gated on
-    /// `event_loop_handle.is_some()`. Zig (`uwsLoop`) is a bare field load.
+    /// `event_loop_handle.is_some()`.
     #[inline(always)]
     pub fn uws_loop(&self) -> *mut uws::Loop {
         #[cfg(unix)]
@@ -1114,7 +1101,7 @@ impl VirtualMachine {
         _: &JSGlobalObject,
         value: JSValue,
     ) {
-        // SAFETY: BORROW_PARAM ptr set by caller, outlives this call (TODO(port): lifetime)
+        // SAFETY: BORROW_PARAM ptr set by caller; outlives this call.
         let list = this
             .on_unhandled_rejection_exception_list
             .map(|mut p| unsafe { p.as_mut() });
@@ -1140,8 +1127,7 @@ impl VirtualMachine {
     }
 
     /// RAII form of `auto_garbage_collect`: returns a guard that calls
-    /// `auto_garbage_collect()` when it goes out of scope. Ports Zig's
-    /// `defer vm.autoGarbageCollect()` without an ad-hoc scopeguard closure.
+    /// `auto_garbage_collect()` when it goes out of scope.
     #[inline]
     pub fn auto_gc_on_drop(&self) -> AutoGcOnDrop<'_> {
         AutoGcOnDrop { vm: self }
@@ -1220,10 +1206,8 @@ impl VirtualMachine {
         }
     }
 
-    /// `runWithAPILock(comptime Context, ctx, comptime fn)` — acquires the JSC
-    /// API lock around `f(ctx)`. Rust collapses the comptime params into a closure.
+    /// Acquires the JSC API lock for the duration of `f()`.
     ///
-    /// Spec VirtualMachine.zig:2629-2631: `this.global.vm().holdAPILock(ctx, callback)`.
     /// Routes `f` through `JSC__VM__holdAPILock` via an `OpaqueWrap`-style C
     /// trampoline so the JSC API lock is held for the full duration of `f()`.
     pub fn run_with_api_lock<F, R>(&self, f: F) -> R
@@ -1232,10 +1216,8 @@ impl VirtualMachine {
     {
         use core::mem::{ManuallyDrop, MaybeUninit};
 
-        // PORT NOTE: Zig's `OpaqueWrap(Context, function)` synthesizes a
-        // `fn(*anyopaque) void` that casts back and calls the body. The Rust
-        // closure carries its own context, so the trampoline state is just
-        // `{ closure, out-slot }`. `ManuallyDrop` lets us move the `FnOnce`
+        // Note: the closure carries its own context, so the trampoline state is
+        // just `{ closure, out-slot }`. `ManuallyDrop` lets us move the `FnOnce`
         // out by value inside the `extern "C"` body without `Option::take`.
         struct Trampoline<F, R> {
             f: ManuallyDrop<F>,
@@ -1268,7 +1250,7 @@ impl VirtualMachine {
         result: JSValue,
         exception_list: Option<&mut ExceptionList>,
     ) {
-        // Spec VirtualMachine.zig:2156-2189: save/restore `had_errors` around
+        // Save/restore `had_errors` around
         // the print, then route the value through `printException` /
         // `printErrorlikeObject` (ConsoleObject formatter). The save/restore
         // has no higher-tier dep, so it lives here unconditionally.
@@ -1280,14 +1262,14 @@ impl VirtualMachine {
         // mirroring `auto_tick`/`ensure_debugger` — so the error is actually
         // emitted to stderr before callers hard-exit. With no hook installed
         // (low-tier unit tests), fail loudly: PORTING.md §Forbidden bans a
-        // silent no-op here since the .zig has real, observable logic.
+        // silent no-op here since the real path has observable logic.
         if let Some(hooks) = runtime_hooks() {
             (hooks.print_exception)(self, result, exception_list);
         } else {
             // Low-tier fallback (no `bun_runtime` installed — unit tests):
             // we cannot reach `ConsoleObject::Formatter`, so emit a degraded
-            // one-line render via the buffered error writer. Spec
-            // VirtualMachine.zig:2156-2189 routes through `printErrorlikeObject`
+            // one-line render via the buffered error writer. The full path
+            // routes through `printErrorlikeObject`
             // (which formats name/message/stack); the closest we can do here
             // without the high tier is the value's own `toString`.
             let _ = exception_list;
@@ -1311,12 +1293,12 @@ impl VirtualMachine {
             let _ = writer.flush();
         }
 
-        // PORT NOTE: Zig `defer this.had_errors = prev_had_errors;` — the hook
-        // does not unwind across the dispatch boundary, so restore linearly.
+        // The hook does not unwind across the dispatch boundary, so restore
+        // linearly.
         self.had_errors = prev_had_errors;
     }
 
-    /// Spec VirtualMachine.zig:2606 `loadMacroEntryPoint`. Looks up (or
+    /// Looks up (or
     /// generates) the synthetic `MacroEntryPoint` source for `(entry_path,
     /// function_name, hash)` and evaluates it under the JSC API lock via
     /// [`run_with_api_lock`].
@@ -1334,7 +1316,7 @@ impl VirtualMachine {
             Entry::Vacant(v) => {
                 let mut ep = Box::new(MacroEntryPoint::default());
                 // SAFETY: PathName stores slices with an artificial 'static
-                // bound (Zig has no lifetimes); the generated entry point is
+                // bound; the generated entry point is
                 // boxed into `macro_entry_points` and lives for the VM
                 // lifetime, and `entry_path` is only borrowed for the
                 // duration of `generate` (it copies into `code_buffer`).
@@ -1353,10 +1335,6 @@ impl VirtualMachine {
             }
         };
 
-        // PORT NOTE: Zig used a `MacroEntryPointLoader` struct + `OpaqueWrap`
-        // because `runWithAPILock` only accepts `fn(*Ctx) void`. The Rust
-        // `run_with_api_lock` already takes a closure, so the loader struct
-        // collapses into a captured local.
         // SAFETY: `entry_point` was just inserted (heap-allocated) or fetched
         // from the cache; it lives for the VM lifetime.
         let path: &[u8] = unsafe { &*entry_point }.source.path.text;
@@ -1371,20 +1349,16 @@ impl VirtualMachine {
         !self.bun_watcher.is_null()
     }
 
-    /// Spec VirtualMachine.zig:454 — `pub threadlocal var is_main_thread_vm`.
     /// Thin setter so callers don't need `.with` plumbing on the thread-local.
     #[inline]
     pub fn set_is_main_thread_vm(value: bool) {
         IS_MAIN_THREAD_VM.set(value);
     }
 
-    /// Spec VirtualMachine.zig:2283 `ensureDebugger`.
-    ///
     /// The body lives in `bun_runtime` (it constructs `bun.api.Debugger`), so
     /// dispatch through [`RuntimeHooks::ensure_debugger`] like
     /// [`reload_entry_point`] does. No-op when hooks aren't installed (pure
-    /// `bun_jsc` unit tests) — matches the Zig early-return when `debugger`
-    /// is unset.
+    /// `bun_jsc` unit tests).
     pub fn ensure_debugger(&mut self, block_until_connected: bool) -> Result<(), bun_core::Error> {
         if let Some(hooks) = runtime_hooks() {
             // SAFETY: hook contract — `self` is the live per-thread VM.
@@ -1443,15 +1417,13 @@ impl VirtualMachine {
             self.exit_handler.exit_code = 1;
             (self.on_unhandled_rejection)(self, global_object, err);
         }
-        // PORT NOTE: Zig `defer this.is_handling_uncaught_exception = false;`
-        // (VirtualMachine.zig:707) covers BOTH the FFI call and the
+        // Note: this reset must cover BOTH the FFI call and the
         // `onUnhandledRejection` callback above. The flag must stay raised
         // while that callback runs so a re-entrant `uncaught_exception` from
         // a user handler trips the recursion guard and hard-exits with code 7
         // instead of recursing. Neither the FFI call nor the fn-pointer
         // callback unwind past this frame (re-entry hits `process_exit` →
-        // `panic!`, which never returns), so a linear reset here matches the
-        // Zig `defer` scope.
+        // `panic!`, which never returns), so a linear reset here suffices.
         self.is_handling_uncaught_exception = false;
         handled
     }
@@ -1460,11 +1432,7 @@ impl VirtualMachine {
         if self.hot_reload != HOT_RELOAD_HOT {
             return None;
         }
-        // TODO(b2-cycle): spec lazy-inits via `RareData::hotMap(allocator)`;
-        // that accessor is gated in `rare_data.rs::_accessor_body`. Until it
-        // un-gates, return whatever the field already holds (callers that need
-        // the lazy-init path are themselves gated on `bun_runtime`).
-        self.rare_data.as_deref_mut()?.hot_map.as_mut()
+        Some(self.rare_data().hot_map())
     }
 
     pub fn on_before_exit(&mut self) {
@@ -1516,7 +1484,7 @@ impl VirtualMachine {
 
         // Make sure we run new cleanup hooks introduced by running cleanup
         // hooks.
-        // PORT NOTE: each iteration re-fetches `rare_data` so the FFI hook
+        // Note: each iteration re-fetches `rare_data` so the FFI hook
         // bodies (which may re-enter `VirtualMachine` and push more hooks) do
         // not run while a `&mut RareData` is live — the borrow ends after
         // `mem::take` returns the owned `Vec`.
@@ -1531,8 +1499,7 @@ impl VirtualMachine {
                 (hook.func)(hook.ctx);
             }
         }
-        // Zig `defer rare_data.cleanup_hooks.clearAndFree(...)` — `mem::take`
-        // above leaves an empty `Vec` (capacity already freed by drop).
+        // `mem::take` above leaves an empty `Vec` (capacity already freed by drop).
         self.has_run_cleanup_hooks = true;
     }
 
@@ -1546,8 +1513,7 @@ impl VirtualMachine {
             if let Some(t) = self.event_loop_mut().forever_timer.take() {
                 // SAFETY: `t` is the live usockets timer created in
                 // `EventLoop::auto_tick`; `close::<true>()` (fallthrough)
-                // frees it without re-entering the loop. Spec
-                // VirtualMachine.zig:967 `t.deinit(true)`.
+                // frees it without re-entering the loop.
                 unsafe { uws::Timer::close::<true>(t.as_ptr()) };
             }
             // Drain `TimeoutObject`s / `ImmediateObject`s from `All.timers`
@@ -1586,7 +1552,7 @@ impl VirtualMachine {
             // alive (closeAll() fires on_close → JS). After JSC teardown,
             // RareData's Drop only deinit()s the groups (asserts empty).
             if self.rare_data.is_some() {
-                // PORT NOTE: reshaped for borrowck — `close_all_socket_groups`
+                // Note: reshaped for borrowck — `close_all_socket_groups`
                 // walks the loop's group list via `vm.uws_loop()` and never
                 // touches `vm.rare_data`, so the disjoint reborrow is sound.
                 // SAFETY: `self` is the live per-thread VM; the shared borrow
@@ -1638,8 +1604,8 @@ extern crate alloc;
 // in the higher-tier `bun_runtime` crate (`api::Timer::All`, `node::fs`,
 // `webcore::Body`, the bundler entry-point generator, …). Per PORTING.md
 // §Dispatch (cold-path), the low tier defines a manual vtable; `bun_runtime`
-// defines the `#[no_mangle]` static `__BUN_RUNTIME_HOOKS`. Every call
-// site below is `// PERF(port): was inline switch` — acceptable, each does
+// defines the `#[no_mangle]` static `__BUN_RUNTIME_HOOKS`. The fn-ptr
+// indirection at every call site below is acceptable — each does
 // real work (I/O, JS callback, allocation).
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -1652,11 +1618,11 @@ pub struct RuntimeHooks {
     /// `bun.api.Timer.All.init()` + `Body.Value.HiveAllocator.init()` +
     /// `configureDebugger()` — everything `init()` does that names a
     /// `bun_runtime` type. Called once with the freshly-boxed VM AFTER
-    /// `vm.global` / `vm.jsc_vm` are populated (spec VirtualMachine.zig:1313+);
+    /// `vm.global` / `vm.jsc_vm` are populated;
     /// returns the opaque per-VM runtime state pointer (or null). `Err` when
     /// `Transpiler::init` fails (e.g. a deleted cwd → `getcwd` ENOENT); the
     /// hook unwinds its own allocations, so [`VirtualMachine::init`] only has to
-    /// propagate the error (spec bubbles it via `try Transpiler.init(...)`).
+    /// propagate the error.
     pub init_runtime_state: unsafe fn(
         vm: *mut VirtualMachine,
         opts: &mut InitOptions,
@@ -1664,17 +1630,16 @@ pub struct RuntimeHooks {
     /// Reclaim the per-VM state boxed by `init_runtime_state`. Called from
     /// [`VirtualMachine::destroy`] (worker teardown) with the exact opaque
     /// pointer `init_runtime_state` returned (or null). The high tier
-    /// `heap::take`s it and clears its thread-local cache. Spec
-    /// VirtualMachine.zig: `timer`/`entry_point` are value fields freed in
-    /// worker `destroy()`; without this slot every worker leaked one box.
+    /// `heap::take`s it and clears its thread-local cache. Without this slot
+    /// every worker leaked one box.
     pub deinit_runtime_state: unsafe fn(vm: *mut VirtualMachine, state: RuntimeState),
     /// `ServerEntryPoint.generate(watch, entry_path)` — produces the synthetic
     /// `bun:main` module body for `entry_path`. Returns `false` on error
     /// (error already logged into `vm.log`).
     pub generate_entry_point: fn(vm: &VirtualMachine, watch: bool, entry_path: &[u8]) -> bool,
     /// `loadPreloads()` — runs `--preload` scripts. Returns the first rejected
-    /// preload promise if any, else null. Errors propagate like Zig's
-    /// `try this.loadPreloads()` (resolver failures / `ModuleNotFound`).
+    /// preload promise if any, else null. Errors propagate
+    /// (resolver failures / `ModuleNotFound`).
     pub load_preloads:
         unsafe fn(vm: *mut VirtualMachine) -> Result<*mut JSInternalPromise, bun_core::Error>,
     /// `ensureDebugger(block_until_connected)` — no-op when no debugger.
@@ -1683,14 +1648,14 @@ pub struct RuntimeHooks {
     /// Hoisted here so `event_loop.rs` doesn't need its own hook table.
     pub auto_tick: unsafe fn(vm: *mut VirtualMachine),
     /// `eventLoop().autoTickActive()` — like `auto_tick` but only sleeps in
-    /// the uSockets loop while it has active handles (spec event_loop.zig:455).
+    /// the uSockets loop while it has active handles.
     /// Separate slot because the body skips `runImminentGCTimer` /
     /// `handleRejectedPromises` and falls through to `tickWithoutIdle` when
     /// idle — folding it into `auto_tick` would change shutdown semantics.
     pub auto_tick_active: unsafe fn(vm: *mut VirtualMachine),
     /// `printException` / `printErrorlikeObject` — formats `value` (or its
     /// wrapped `JSC::Exception`) to stderr via `ConsoleObject::Formatter`.
-    /// Spec `runErrorHandler` body (VirtualMachine.zig:2164-2188). High tier
+    /// High tier
     /// owns the formatter; low tier dispatches here from
     /// [`VirtualMachine::run_error_handler`].
     pub print_exception:
@@ -1711,7 +1676,7 @@ pub struct RuntimeHooks {
     /// `SSL_CTX*`, shared by every `tls: true` outbound connection that didn't
     /// supply explicit options. The storage slot lives in `RareData`
     /// (low-tier) but population reaches `RuntimeState.ssl_ctx_cache`
-    /// (`bun_runtime`, b2-cycle); spec rare_data.zig:741.
+    /// (`bun_runtime`, b2-cycle).
     pub default_client_ssl_ctx: unsafe fn(vm: *mut VirtualMachine) -> *mut uws::SslCtx,
     /// `RareData.sslCtxCache().getOrCreateOpts(opts, &err)` — per-VM
     /// digest-keyed weak `SSL_CTX*` cache. Returns a +1 ref or `None` on
@@ -1722,42 +1687,36 @@ pub struct RuntimeHooks {
         opts: &uws::SocketContext::BunSocketContextOptions,
         err: &mut uws::create_bun_socket_error_t,
     ) -> Option<*mut uws::SslCtx>,
-    /// `Node.fs.NodeFS{ .vm = … }` lazy creation (spec VirtualMachine.zig:827).
+    /// Lazy `NodeFS` creation.
     /// `NodeFS` lives in `bun_runtime`; the high tier boxes one and returns
     /// the type-erased pointer. Stored back into `vm.node_fs`.
     pub create_node_fs: unsafe fn(vm: *mut VirtualMachine) -> *mut c_void,
-    /// `WebCore.ObjectURLRegistry.singleton().has(specifier["blob:".len..])` —
-    /// spec VirtualMachine.zig:1760. Registry lives in `bun_runtime::webcore`.
+    /// `ObjectURLRegistry` lookup. Registry lives in `bun_runtime::webcore`.
     pub has_blob_url: fn(blob_id: &[u8]) -> bool,
     /// `Response::get_blob_without_call_frame` /
-    /// `Request::get_blob_without_call_frame` — spec Macro.zig:331-334. If
+    /// `Request::get_blob_without_call_frame`. If
     /// `value` downcasts to a `Response` or `Request` (both live in
     /// `bun_runtime::webcore`), return its body Blob wrapped in a resolved
     /// Promise; `Ok(None)` to fall through to the `Blob`/`BuildMessage`/
     /// `ResolveMessage` arms in `Macro::Run::coerce`.
     pub body_mixin_get_blob:
         fn(value: JSValue, global: &JSGlobalObject) -> JsResult<Option<JSValue>>,
-    /// `bun.api.node.process.exit(global, code)` — spec
-    /// `runtime/node/node_process.zig`. Main-thread is `noreturn`; in a worker
+    /// `process.exit(global, code)`. Main-thread is `noreturn`; in a worker
     /// it returns and the caller `panic!`s. Lives in `bun_runtime::node`
     /// (forward-dep cycle), so [`uncaught_exception`] reaches it through this
     /// slot instead of the linker.
     pub process_exit: unsafe fn(global: *mut JSGlobalObject, code: u8),
-    /// `node_cluster_binding.handleInternalMessageChild(global, data)` — spec
-    /// VirtualMachine.zig:3960 (IPCInstance.handleIPCMessage `.internal` arm).
+    /// `node_cluster_binding.handleInternalMessageChild(global, data)`.
     pub handle_ipc_internal_child: unsafe fn(global: *mut JSGlobalObject, data: JSValue),
-    /// `node_cluster_binding.child_singleton.deinit()` — spec
-    /// VirtualMachine.zig:3972 (IPCInstance.handleIPCClose).
+    /// `node_cluster_binding.child_singleton.deinit()`.
     pub ipc_child_singleton_deinit: fn(),
-    /// `Jest.runner.?.bun_test_root.onBeforePrint()` — spec
-    /// ConsoleObject.zig:170. The `bun:test` runner lives in `bun_runtime`;
+    /// `onBeforePrint()` for the `bun:test` runner, which lives in `bun_runtime`;
     /// `console.log` calls this so the test reporter can flush its line state
     /// before user output interleaves with it. No-op when `bun test` isn't
     /// running.
     pub console_on_before_print: fn(),
-    /// `ConsoleObject.Formatter.printAs(.Object, …)` runtime-type dispatch —
-    /// spec ConsoleObject.zig `printAs` `.Object` arm: the long `if (value.as(T))`
-    /// chain over `Response`/`Request`/`Blob`/`S3Client`/`Archive`/
+    /// `ConsoleObject.Formatter` runtime-type dispatch
+    /// over `Response`/`Request`/`Blob`/`S3Client`/`Archive`/
     /// `BuildArtifact`/`FetchHeaders`/`Timer`/`Immediate`/`BuildMessage`/
     /// `ResolveMessage`/Jest asymmetric matchers. All of those types live in
     /// `bun_runtime`; the high tier owns the downcast + `write_format` calls.
@@ -1772,8 +1731,7 @@ pub struct RuntimeHooks {
         name_buf: &'a [u8; 512],
         enable_ansi_colors: bool,
     ) -> JsResult<bool>,
-    /// `bun.bun_js.applyStandaloneRuntimeFlags(b, graph)` — spec
-    /// web_worker.zig:552. Applies `--compile`-baked runtime flags to the
+    /// Applies `--compile`-baked runtime flags to the
     /// worker's transpiler. `graph` is the same trait object stored in
     /// `vm.standalone_module_graph` (the high tier downcasts to its concrete
     /// `bun_standalone_graph::Graph` — the sole implementor).
@@ -1781,33 +1739,33 @@ pub struct RuntimeHooks {
         transpiler: *mut Transpiler<'static>,
         graph: &'static dyn bun_resolver::StandaloneModuleGraph,
     ),
-    /// Spec web_worker.zig:445-476 — parse `execArgv` against the `RunCommand`
+    /// Parse `execArgv` against the `RunCommand`
     /// param table and return the resulting `allow_addons` value
-    /// (`!args.flag("--no-addons")`), or `None` if parsing failed (Zig's
-    /// `catch break :parse_new_args`). The param table lives in
-    /// `bun_runtime::cli` (forward-dep). Spec only honours `--no-addons`;
+    /// (`!args.flag("--no-addons")`), or `None` if parsing failed.
+    /// The param table lives in
+    /// `bun_runtime::cli` (forward-dep). Only `--no-addons` is honoured;
     /// the caller writes the returned bool back into
     /// `transform_options.allow_addons` so the override semantics
     /// ("override the existing even if it was set") match.
     pub parse_worker_exec_argv_allow_addons:
         unsafe fn(exec_argv: &[bun_core::WTFStringImpl]) -> Option<bool>,
-    /// `jsc.API.cron.CronJob.clearAllForVM(vm, .teardown)` — spec
-    /// web_worker.zig:727. `CronJob` lives in `bun_runtime::api::cron`.
+    /// `CronJob.clearAllForVM(vm, .teardown)`. `CronJob` lives in
+    /// `bun_runtime::api::cron`.
     pub cron_clear_all_teardown: fn(vm: &mut VirtualMachine),
-    /// `webcore.WebWorker.terminateAllAndWait(timeout_ms)` — spec
-    /// VirtualMachine.zig:975. `WebWorker` lives in this crate but the
+    /// `WebWorker.terminateAllAndWait(timeout_ms)`.
+    /// `WebWorker` lives in this crate but the
     /// `web_worker` module is above `virtual_machine` in the dep graph
     /// (forward use) AND the body re-enters `bun_runtime` for the worker
     /// thread's `event_loop().auto_tick()`, so [`global_exit`] reaches it
     /// through this slot. Prevents detached worker threads from racing the
     /// freed resolver BSSMap singletons during `transpiler.deinit()`.
     pub terminate_all_workers_and_wait: fn(timeout_ms: u64),
-    /// `jsc.API.cron.CronJob.clearAllForVM(vm, .reload)` — spec
-    /// VirtualMachine.zig:815. Same impl as `cron_clear_all_teardown` but
+    /// `CronJob.clearAllForVM(vm, .reload)`.
+    /// Same impl as `cron_clear_all_teardown` but
     /// the `.reload` mode preserves the next-fire schedule across the new
     /// global so timers re-register instead of being torn down.
     pub cron_clear_all_reload: fn(vm: &mut VirtualMachine),
-    /// `graph.find(path).?.sourcemap.load()` — spec VirtualMachine.zig:3875.
+    /// Standalone-graph sourcemap load.
     /// The concrete `bun_standalone_graph::Graph` / `File` / `LazySourceMap`
     /// live above `bun_jsc`; the high tier reaches them via the graph's own
     /// `UnsafeCell` singleton accessor (NOT by downcasting the resolver trait
@@ -1818,8 +1776,7 @@ pub struct RuntimeHooks {
     /// path. The caller gates the call on `vm.standalone_module_graph`.
     pub load_standalone_sourcemap:
         fn(path: &[u8]) -> Option<std::sync::Arc<bun_sourcemap::ParsedSourceMap>>,
-    /// `bake::production::PerThread` source-map JSON lookup — spec
-    /// sourcemap_jsc/source_provider.zig:24
+    /// `bake::production::PerThread` source-map JSON lookup
     /// (`pt.source_maps.get(filename) → pt.bundled_outputs[idx].value.asSlice()`).
     /// `pt` is the opaque `*mut PerThread` round-tripped through C++ via
     /// `BakeGlobalObject__attachPerThreadData` / `…__getPerThreadData`;
@@ -1831,8 +1788,8 @@ pub struct RuntimeHooks {
     /// outlives any error-stack source-map resolution).
     pub bake_per_thread_source_map:
         unsafe fn(pt: *mut c_void, source_filename: &[u8]) -> Option<*const [u8]>,
-    /// `TestReporterAgent.retroactivelyReportDiscoveredTests(agent)` — spec
-    /// Debugger.zig:351. Walks `Jest.runner.?.bun_test_root.active_file`'s
+    /// `TestReporterAgent.retroactivelyReportDiscoveredTests(agent)`.
+    /// Walks the active test file's
     /// scope tree and emits `reportTestFoundWithLocation` for every test
     /// discovered before the inspector connected. `Jest` / `DescribeScope`
     /// live in `bun_runtime::test_runner` (forward-dep cycle), so the body is
@@ -1853,10 +1810,9 @@ pub struct RuntimeHooks {
 
 /// Canonical `EventLoopCtx` vtable for a `*mut VirtualMachine` owner — the JS
 /// half of `bun_io`'s cycle-break manual vtable. Every slot is implementable
-/// from in-crate data (spec posix_event_loop.zig:100-104 / RareData.zig:441),
+/// from in-crate data,
 /// so this is the single fully-populated instance; `aio::get_vm_ctx(.Js)` and
-/// the websocket-client adapters resolve to it. PORT NOTE: in Zig the
-/// `KeepAlive::ref(anytype)` accepted `*VirtualMachine` directly.
+/// the websocket-client adapters resolve to it.
 /// Recover `&mut VirtualMachine` from the erased vtable `owner`. Private to
 /// this module — every caller is an `unsafe fn` slot in
 /// [`VM_EVENT_LOOP_CTX_VTABLE`] whose contract guarantees `owner` was erased
@@ -1876,10 +1832,12 @@ bun_io::link_impl_EventLoopCtx! {
         },
         // CROSS-THREAD: reached via `KeepAlive::unref_on_next_tick_concurrently`.
         // Do NOT route through `vm_from_owner()` — that mints `&mut VM`, which
-        // would alias the JS thread's `&mut`. Raw place RMW only (the
-        // field-level non-atomic race is pre-existing; TODO: make
-        // `pending_unref_counter` an `AtomicI32` with `fetch_add`).
-        increment_pending_unref_counter() => (*this).pending_unref_counter += 1,
+        // would alias the JS thread's `&mut`. Atomic RMW through a shared ref.
+        increment_pending_unref_counter() => {
+            (*this)
+                .pending_unref_counter
+                .fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+        },
         // CROSS-THREAD: reached via `KeepAlive::{,un}ref_concurrently`. Do NOT
         // use `vm_from_owner()` / `event_loop_mut()` — both mint `&mut`, UB
         // against the JS thread's borrow. `event_loop()` takes `&self` (Sync)
@@ -1955,8 +1913,7 @@ impl VirtualMachine {
 unsafe extern "Rust" {
     /// The single `&'static` instance, defined `#[no_mangle]` in
     /// `bun_runtime::jsc_hooks`. Link-time resolved — no `AtomicPtr`, no
-    /// init-order hazard. Zig had no crate split here; `VirtualMachine`
-    /// reached `Timer::All` / `ServerEntryPoint` / etc. directly.
+    /// init-order hazard.
     /// `RuntimeHooks` is an immutable POD of fn-ptrs with a single definition;
     /// reading it has no precondition beyond the link succeeding → `safe static`.
     safe static __BUN_RUNTIME_HOOKS: RuntimeHooks;
@@ -1970,13 +1927,8 @@ pub fn runtime_hooks() -> Option<&'static RuntimeHooks> {
     Some(&__BUN_RUNTIME_HOOKS)
 }
 
-// TODO(port): move to jsc_sys
 #[allow(improper_ctypes)] // VirtualMachine is opaque to C++; passed as `void*`
 unsafe extern "C" {
-    // Spec JSGlobalObject.zig:863 / headers.h:435 — note the real symbol is
-    // `Zig__GlobalObject__create` and takes 5 args (no leading `vm`); the Zig
-    // wrapper `JSGlobalObject.create` accepts `vm` only to call
-    // `vm.eventLoop().ensureWaker()` before the FFI.
     // safe: `console`/`worker_ptr` are opaque round-trip pointers C++ stores
     // into the new ZigGlobalObject (never dereferenced as Rust data); remaining
     // args are by-value scalars.
@@ -2020,7 +1972,7 @@ fn get_origin_timestamp() -> u64 {
 impl VirtualMachine {
     /// `VirtualMachine.init(opts)` — allocate + wire the per-thread VM.
     ///
-    /// PORT NOTE: every step that names a `bun_runtime` / `bun_webcore` type
+    /// Note: every step that names a `bun_runtime` / `bun_webcore` type
     /// (`Timer.All.init`, `Body.Value.HiveAllocator`, `configureDebugger`,
     /// `Config.configureTransformOptionsForBunVM`, `ParentDeathWatchdog`) is
     /// dispatched through `RuntimeHooks::init_runtime_state` so `bun_jsc` does
@@ -2029,18 +1981,17 @@ impl VirtualMachine {
     pub fn init(mut opts: InitOptions) -> Result<*mut VirtualMachine, bun_core::Error> {
         jsc::mark_binding();
 
-        // Spec VirtualMachine.zig:1234 — `opts.log orelse allocator.create(Log)`.
         let log: *mut bun_ast::Log = match opts.log {
             Some(l) => l.as_ptr(),
             None => bun_core::heap::into_raw(Box::new(bun_ast::Log::default())),
         };
 
         // SAFETY: VM is large + self-referential; allocate zeroed and fill in
-        // place (mirrors Zig's `allocator.create` + struct-init). The
+        // place. The
         // allocation lives for the thread lifetime (never freed on the main
         // thread; worker `destroy()` frees it explicitly).
         //
-        // PORT NOTE (validity): the zeroed bytes are NOT a valid
+        // Note (validity): the zeroed bytes are NOT a valid
         // `VirtualMachine` — `origin_timer: Instant`, `on_unhandled_rejection:
         // fn(...)`, (debug) `debug_thread_id: ThreadId`, every `Vec`/`Box`/
         // `HashMap`/`ArrayHashMap` field (NonNull dangling-when-empty), `URL`
@@ -2049,7 +2000,7 @@ impl VirtualMachine {
         // `&mut VirtualMachine` until all such fields have been `ptr::write`n
         // via `addr_of_mut!`; remaining fields are zero-valid
         // (integers/raw-ptr/atomic-mutex/`Option<NonNull>`/`Option<Box>`) so
-        // the zero-fill stands in for the Zig struct-init defaults.
+        // the zero-fill stands in for the struct-init defaults.
         let layout = core::alloc::Layout::new::<VirtualMachine>();
         // SAFETY: `layout` is non-zero-sized; `alloc_zeroed` returns either a
         // valid aligned ptr or null (handled by `handle_alloc_error`).
@@ -2066,7 +2017,7 @@ impl VirtualMachine {
         }
 
         // ConsoleObject is self-referential (buffers + adapters) — allocate
-        // stable storage and init in place. Spec VirtualMachine.zig:1238-1239:
+        // stable storage and init in place.
         // `console.init(Output.rawErrorWriter(), Output.rawWriter())` must
         // happen BEFORE the pointer is stored/passed; the previous port left
         // it as raw `MaybeUninit` (UB on first C++ read).
@@ -2100,7 +2051,7 @@ impl VirtualMachine {
             addr_of_mut!((*vm).main_resolved_path).write(bun_core::String::empty());
             addr_of_mut!((*vm).hide_bun_stackframes).write(true);
             addr_of_mut!((*vm).is_main_thread).write(opts.is_main_thread);
-            // Spec VirtualMachine.zig:154 — `= std.math.maxInt(u32)`. Left at the
+            // Left at the
             // zeroed default this aliases `hot_reload_counter`'s initial 0, so a
             // watcher event that races the very first entry-point load makes
             // `reload()` think the rejection was already reported and proceed
@@ -2164,7 +2115,7 @@ impl VirtualMachine {
             addr_of_mut!((*vm).event_loop).write(regular);
 
             // `source_mappings.map` is a sibling-field backref onto
-            // `saved_source_map_table` (spec VirtualMachine.zig:1273).
+            // `saved_source_map_table`.
             addr_of_mut!((*vm).saved_source_map_table)
                 .write(crate::saved_source_map::HashTable::default());
             addr_of_mut!((*vm).source_mappings).write(SavedSourceMap::default());
@@ -2172,16 +2123,15 @@ impl VirtualMachine {
         }
 
         // High-tier per-VM state — Transpiler / Timer::All / entry_point.
-        // PORT NOTE (init order): spec VirtualMachine.zig:1241/1259 builds
-        // `Transpiler.init` and `.timer = bun.api.Timer.All.init()` as part of
-        // the struct initializer BEFORE `JSGlobalObject.create`. The C++ body
+        // Note (init order): the transpiler and per-VM timer state must be
+        // built BEFORE `JSGlobalObject` creation. The C++ body
         // of `Zig__GlobalObject__create` re-enters via `WTFTimer__create`/
         // `WTFTimer__update` (JSC's GC scheduler), which dereferences
         // `runtime_state().timer` — so this hook MUST run first or that path
         // null-derefs. The post-global tail (`configureDebugger`,
-        // `Body.Value.HiveAllocator.init`, spec :1321-1322) is gated TODO in
+        // `Body.Value.HiveAllocator.init`) is gated TODO in
         // the hook body and will need a separate post-global hook when
-        // un-gated. PERF(port): was inline switch.
+        // un-gated.
         if let Some(hooks) = runtime_hooks() {
             // SAFETY: hook contract — `vm` is the unique live VM on this
             // thread. Write through the raw `vm` ptr (not `vm_ref`) so no
@@ -2192,19 +2142,18 @@ impl VirtualMachine {
             // `Transpiler::init`) the hook already unwound its own per-VM state,
             // so abort `init` here — `vm.transpiler` was never written, and
             // bailing out before the CLI reads it turns the old segfault into a
-            // clean error + non-zero exit (spec: `try Transpiler.init(...)`).
+            // clean error + non-zero exit.
             unsafe { (*vm).runtime_state = (hooks.init_runtime_state)(vm, &mut opts)? };
         }
 
-        // JSGlobalObject creation. Spec JSGlobalObject.zig:875 — the wrapper
-        // calls `vm.eventLoop().ensureWaker()` before the 5-arg FFI.
+        // JSGlobalObject creation. `ensure_waker()` must run before the FFI.
         // SAFETY: `vm` is the unique live VM on this thread; raw-ptr deref so
         // no `&mut` is held across the FFI re-entry (`Bun__getVM()` —
         // ZigGlobalObject.cpp:473/961).
         unsafe { (*vm).regular_event_loop.ensure_waker() };
         // `console`/`worker_ptr` are opaque round-trip pointers C++ stores into
         // the new global. `worker_ptr` is the C++ `WebCore::Worker*` (or null on
-        // the main thread) — spec VirtualMachine.zig:1477-1484 / JSGlobalObject.zig:876.
+        // the main thread).
         let global = Zig__GlobalObject__create(
             console.cast(),
             context_id,
@@ -2212,7 +2161,7 @@ impl VirtualMachine {
             opts.eval_mode,
             opts.worker_ptr,
         );
-        // JSC may mess with the stack size (spec JSGlobalObject.zig:879).
+        // JSC may mess with the stack size.
         bun_core::StackCheck::configure_thread();
         // SAFETY: write through the raw `vm` ptr (not `vm_ref`) so no
         // `&mut VirtualMachine` is held live across the FFI call above; same
@@ -2228,7 +2177,7 @@ impl VirtualMachine {
         };
         VMHolder::set_cached_global_object(Some(global));
 
-        // Spec VirtualMachine.zig:1313: `uws.Loop.get().internal_loop_data.jsc_vm
+        // `uws.Loop.get().internal_loop_data.jsc_vm
         // = vm.jsc_vm` — must run AFTER `jsc_vm` is set so C/uws callbacks can
         // recover the JSC VM via `internal_loop_data`.
         // SAFETY: `uws::Loop::get()` returns the live per-thread uws loop.
@@ -2236,14 +2185,13 @@ impl VirtualMachine {
             (*uws::Loop::get()).internal_loop_data.jsc_vm = jsc_vm.cast();
         }
 
-        // Spec VirtualMachine.zig:1316 / :1191 — `if (opts.is_main_thread)
-        // bun.ParentDeathWatchdog.installOnEventLoop(jsc.EventLoopHandle.init(vm))`.
+        // `ParentDeathWatchdog` install for the main thread.
         // Must run AFTER `ensure_waker()` (above) has set `event_loop_handle`,
         // since on macOS the kqueue registration resolves the platform loop via
         // `event_loop_ctx → uws_loop()`. No-op off macOS / when `--no-orphans`
         // is not enabled. `init_with_module_graph` / `init_bake` route through
         // here with their caller's `is_main_thread`; `init_worker` passes
-        // `false` so workers never arm the watchdog (matches spec `initWorker`).
+        // `false` so workers never arm the watchdog.
         if opts.is_main_thread {
             // SAFETY: `vm` is the freshly-initialised per-thread VM singleton.
             bun_io::ParentDeathWatchdog::install_on_event_loop(unsafe { Self::event_loop_ctx(vm) });
@@ -2257,9 +2205,8 @@ impl VirtualMachine {
         Ok(vm)
     }
 
-    /// `init` + set `main` to `entry_path`. Port-side convenience for the
-    /// `bun -e` / `bun run <file>` boot path; Zig open-codes this in
-    /// `run_command.zig`.
+    /// `init` + set `main` to `entry_path`. Convenience for the
+    /// `bun -e` / `bun run <file>` boot path.
     pub fn init_with_main(
         opts: InitOptions,
         entry_path: &[u8],
@@ -2294,7 +2241,7 @@ impl VirtualMachine {
 
     /// `eventLoop().waitForPromise(promise)` — spin tick/auto_tick until
     /// `promise` settles. Thin forwarder; body lives in
-    /// [`crate::event_loop::EventLoop::wait_for_promise`] (spec event_loop.zig).
+    /// [`crate::event_loop::EventLoop::wait_for_promise`].
     #[inline]
     pub fn wait_for_promise(&mut self, promise: jsc::AnyPromise) {
         // accessed here (no overlapping `&mut EventLoop`).
@@ -2307,7 +2254,6 @@ impl VirtualMachine {
     pub fn auto_tick(&mut self) {
         if let Some(hooks) = runtime_hooks() {
             // SAFETY: hook contract — `self` is the live per-thread VM.
-            // PERF(port): was inline switch.
             unsafe { (hooks.auto_tick)(self) };
         } else {
             // No high tier (unit tests) — fall back to a non-blocking tick.
@@ -2316,15 +2262,14 @@ impl VirtualMachine {
     }
 
     /// `eventLoop().autoTickActive()` — like [`auto_tick`](Self::auto_tick)
-    /// but only sleeps in the uSockets loop while it has active handles
-    /// (spec event_loop.zig:456). The real body lives in `event_loop.rs`
+    /// but only sleeps in the uSockets loop while it has active handles.
+    /// The real body lives in `event_loop.rs`
     /// behind `` until the b2-cycle (`Timer::All`) breaks; until
     /// then route through the same `auto_tick` hook so drain loops in
     /// `on_before_exit` / `bun_main` still make forward progress.
     #[inline]
     pub fn auto_tick_active(&mut self) {
         if let Some(hooks) = runtime_hooks() {
-            // PERF(port): was inline switch — direct call in event_loop.zig.
             // SAFETY: `self` is the live per-thread VM (hook contract).
             unsafe { (hooks.auto_tick_active)(self) };
         } else {
@@ -2373,7 +2318,7 @@ impl VirtualMachine {
                     }
                 }
 
-                // Check if Module.runMain was patched (spec VirtualMachine.zig:2322-2335).
+                // Check if Module.runMain was patched.
                 if self.has_patched_run_main {
                     bun_core::hint::cold();
                     self.pending_internal_promise = None;
@@ -2397,7 +2342,7 @@ impl VirtualMachine {
                 }
             }
 
-            // PORT NOTE: reshaped for borrowck — capture raw ptr before &self call.
+            // Note: reshaped for borrowck — capture raw ptr before &self call.
             let global = self.global;
             let global_ref = self.global();
             let promise = if !self.main_is_html_entrypoint {
@@ -2476,9 +2421,8 @@ impl VirtualMachine {
     }
 
     /// Drain pending tasks/microtasks if the event loop is not currently
-    /// re-entered. Port-side convenience used after top-level evaluation on
-    /// the `bun -e` path (Zig open-codes `eventLoop().tick()` +
-    /// `drainMicrotasks()` at each call site).
+    /// re-entered. Convenience used after top-level evaluation on
+    /// the `bun -e` path.
     pub fn drain_queues_if_needed(&mut self) {
         // SAFETY: `event_loop` is a self-pointer into this VM; uniquely
         // accessed here (no overlapping `&mut EventLoop`).
@@ -2491,16 +2435,14 @@ impl VirtualMachine {
     }
 }
 
-/// Spec VirtualMachine.zig:2032 `processFetchLog`. Synthesize a JS
+/// Synthesize a JS
 /// `BuildMessage` / `ResolveMessage` / `AggregateError` from the parser
 /// `log` and write it into `ret` as `.err(..)` so the C++ module-loader
 /// (`Bun__onFulfillAsyncModule`, ModuleLoader.cpp) rejects the import promise
 /// with a real Error instead of `undefined`.
 ///
-/// Free function (file-level in Zig); takes `&JSGlobalObject` directly rather
-/// than `&mut VirtualMachine` because the body never touches VM state — Zig
-/// only used `globalThis.arena()` for the format buffers, which is
-/// `bun.default_allocator` (= global mimalloc) and dropped per §Allocators.
+/// Free function; takes `&JSGlobalObject` directly rather
+/// than `&mut VirtualMachine` because the body never touches VM state.
 pub fn process_fetch_log(
     global_this: &JSGlobalObject,
     specifier: bun_core::String,
@@ -2511,12 +2453,12 @@ pub fn process_fetch_log(
 ) {
     use crate::{BuildMessage, ResolveMessage};
 
-    // Helper: `expr catch |e| globalThis.takeException(e)`.
+    // Helper: on error, swap in the pending exception value.
     let take =
         |r: JsResult<JSValue>| -> JSValue { r.unwrap_or_else(|e| global_this.take_exception(e)) };
 
-    // Spec: `referrer.toUTF8(bun.default_allocator)` — `ResolveMessage::create`
-    // takes raw `&[u8]` and stores them verbatim, so we must convert here.
+    // `ResolveMessage::create` takes raw `&[u8]` and stores them verbatim, so
+    // we must convert to UTF-8 here.
     let referrer_utf8 = referrer.to_utf8();
 
     match log.msgs.len() {
@@ -2553,9 +2495,8 @@ pub fn process_fetch_log(
         }
 
         1 => {
-            // PORT NOTE: Zig copied `log.msgs.items[0]` by value; `Msg` is not
-            // `Copy` here, so move it out — the caller `defer log.deinit()`s
-            // immediately after, so consuming the vec is sound.
+            // Note: `Msg` is not `Copy`, so move it out — the caller deinits
+            // the log immediately after, so consuming the vec is sound.
             let msg = log.msgs.swap_remove(0);
             let value = match msg.metadata {
                 bun_ast::Metadata::Build => take(BuildMessage::create(global_this, msg)),
@@ -2569,10 +2510,9 @@ pub fn process_fetch_log(
         }
 
         _ => {
-            // Spec caps at 256 (`var errors_stack: [256]JSValue`). PERF(port):
-            // was inline switch — Zig stack-allocated; we heap-allocate the
+            // Caps at 256. We heap-allocate the
             // exact `len` since `JSValue` is a thin u64 and 256 * 8 B = 2 KiB
-            // is fine either way, but `Vec` avoids the uninit-array dance.
+            // is fine either way, and `Vec` avoids the uninit-array dance.
             let len = log.msgs.len().min(256);
             let mut errors: alloc::vec::Vec<JSValue> = alloc::vec::Vec::with_capacity(len);
             for msg in log.msgs.drain(..len) {
@@ -2606,17 +2546,16 @@ pub fn process_fetch_log(
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// SourceMapHandlerGetter — port of VirtualMachine.zig:403 `SourceMapHandlerGetter`.
+// SourceMapHandlerGetter
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Port of `SourceMapHandlerGetter` (VirtualMachine.zig:403). Holds raw
+/// Holds raw
 /// pointers to the VM and the active `BufferPrinter` so that `get()` can
 /// return an erased `js_printer::SourceMapHandler` borrowing either the VM's
 /// `source_mappings` (fast path) or `self` (debugger / inline-sourcemap path)
 /// without the two `&mut` borrows colliding.
 ///
-/// PORT NOTE: Zig stored `*VirtualMachine` / `*BufferPrinter` directly. Here
-/// we keep raw pointers + a `PhantomData<&'a mut ()>` so the getter's lifetime
+/// Note: we keep raw pointers + a `PhantomData<&'a mut ()>` so the getter's lifetime
 /// is tied to the `&'a mut VirtualMachine` it was built from in
 /// `source_map_handler`, but `get()` can still hand out a
 /// `SourceMapHandler<'_>` over `vm.source_mappings` without tripping borrowck
@@ -2695,7 +2634,7 @@ impl<'a> SourceMapHandlerGetter<'a> {
     /// pointer once the writer's last byte has been emitted (i.e. inside
     /// `on_source_map_chunk`, which the printer invokes from its tail).
     pub fn get(&mut self) -> bun_js_printer::SourceMapHandler<'_> {
-        // VirtualMachine.zig:408: take the inline-sourcemap path only when a
+        // Take the inline-sourcemap path only when a
         // debugger is present AND it is *not* in `.connect` mode — `.connect`
         // (VSCode-extension) clients fall through to the `source_mappings`
         // fast-path handler.
@@ -2714,8 +2653,6 @@ impl<'a> SourceMapHandlerGetter<'a> {
 }
 
 impl<'a> bun_js_printer::OnSourceMapChunk for SourceMapHandlerGetter<'a> {
-    /// Port of `SourceMapHandlerGetter.onChunk` (VirtualMachine.zig:418).
-    ///
     /// When the inspector is enabled, we want to generate an inline sourcemap.
     /// And, for now, we also store it in `source_mappings` like normal.
     /// This is hideously expensive memory-wise...
@@ -2759,16 +2696,14 @@ impl<'a> bun_js_printer::OnSourceMapChunk for SourceMapHandlerGetter<'a> {
             .ctx
             .buffer
             .grow_if_needed(encode_len + prefix_len + 2)?;
-        // Zig: "\n" ++ source_map_url_prefix_start
         printer.ctx.buffer.append_assume_capacity(b"\n");
         printer
             .ctx
             .buffer
             .append_assume_capacity(SOURCE_MAP_URL_PREFIX_START);
         {
-            // Zig wrote into `buffer.list.items.ptr[len..capacity]` then bumped
-            // `items.len`. `MutableString::list` is a `Vec<u8>`; mirror that with
-            // a spare-capacity write + `commit_spare`.
+            // `MutableString::list` is a `Vec<u8>`; write into spare capacity,
+            // then commit the written length.
             let buf = &mut printer.ctx.buffer.list;
             // SAFETY: `grow_if_needed` reserved ≥encode_len spare; encode writes
             // `wrote<=encode_len` bytes.
@@ -2796,37 +2731,37 @@ impl<'a> bun_js_printer::OnSourceMapChunk for SourceMapHandlerGetter<'a> {
 // ──────────────────────────────────────────────────────────────────────────
 // ──────────────────────────────────────────────────────────────────────────
 // Options / IPC / per-thread printer — supporting types referenced by the
-// impl below. Field set mirrors VirtualMachine.zig:1204 (`Options`) and
-// :3899 (`IPCInstanceUnion` / `IPCInstance`).
+// impl below.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Spec VirtualMachine.zig:1204 `Options`. `allocator` dropped per
-/// §Allocators (global mimalloc).
+/// `allocator` dropped per §Allocators (global mimalloc).
 #[derive(Default)]
 pub struct Options {
     pub args: bun_options_types::schema::api::TransformOptions,
     pub log: Option<NonNull<bun_ast::Log>>,
-    // TODO(port): lifetime — `&'a mut bun_dot_env::Loader`.
+    // BORROW_PARAM (`&'a mut bun_dotenv::Loader`) — caller-owned; the loader
+    // outlives the VM, so the inner lifetime is erased to `'static`.
     pub env_loader: Option<NonNull<bun_dotenv::Loader<'static>>>,
     pub store_fd: bool,
     pub smol: bool,
-    // TODO(b2-cycle): real type is `bun_runtime::api::dns::Resolver::Order`.
+    // LAYERING: real type is `bun_runtime::api::dns::Resolver::Order` (forward
+    // dep); stored as its `u8` repr.
     pub dns_result_order: u8,
     /// `--print` needs the result from evaluating the main module.
     pub eval: bool,
-    // PORT NOTE: layering — concrete `bun_standalone_graph::Graph` is in a
+    // Note: layering — concrete `bun_standalone_graph::Graph` is in a
     // forward-dep crate; callers pass it as the resolver's trait object so
     // both VM and resolver can hold it without the cycle.
     pub graph: Option<&'static dyn bun_resolver::StandaloneModuleGraph>,
-    // PORT NOTE: Zig `debugger: bun.cli.Command.Debugger` dropped — debugger
+    // Note: debugger
     // configuration is plumbed through `RuntimeHooks::ensure_debugger` (the
     // CLI option struct lives in `bun_cli`, a forward dep). See
-    // `runtime/jsc_hooks.rs` for the spec :1321 `configureDebugger` call site.
+    // `runtime/jsc_hooks.rs` for the `configureDebugger` call site.
     pub is_main_thread: bool,
     pub destruct_main_thread_on_exit: bool,
 }
 
-/// Spec VirtualMachine.zig:3899 `IPCInstanceUnion`.
+/// State of the child-side IPC channel: enabled-but-waiting for a JS listener, or fully initialized.
 pub enum IPCInstanceUnion {
     /// IPC is put in this "enabled but not started" state when IPC is
     /// detected but the client JavaScript has not yet done `.on("message")`.
@@ -2837,7 +2772,7 @@ pub enum IPCInstanceUnion {
     Initialized(*mut IPCInstance),
 }
 
-/// Spec VirtualMachine.zig:3909 `IPCInstance`.
+/// Child-side IPC channel: the send queue plus the global object it dispatches incoming messages into.
 pub struct IPCInstance {
     pub global_this: *mut JSGlobalObject,
     /// Embedded per-VM group on `RareData.spawn_ipc_group`; this is just a
@@ -2870,7 +2805,7 @@ impl IPCInstance {
         drop(unsafe { bun_core::heap::take(this) });
     }
 
-    /// Spec VirtualMachine.zig:3940 `IPCInstance.handleIPCMessage`.
+    /// Dispatches a decoded IPC message (and optional handle) to the JS `process` listeners.
     pub fn handle_ipc_message(&mut self, message: &crate::ipc::DecodedIPCMessage, handle: JSValue) {
         crate::mark_binding!();
         let global_this = self.global_this;
@@ -2905,7 +2840,7 @@ impl IPCInstance {
         }
     }
 
-    /// Spec VirtualMachine.zig:3966 `IPCInstance.handleIPCClose`.
+    /// Tears down the IPC channel and emits the disconnect events on `process`.
     pub fn handle_ipc_close(&mut self) {
         bun_core::scoped_log!(IPC, "IPCInstance#handleIPCClose");
         // SAFETY: VM singleton is process-lifetime.
@@ -2944,7 +2879,7 @@ impl crate::ipc::SendQueueOwner for IPCInstance {
     fn handle_ipc_message(&mut self, msg: crate::ipc::DecodedIPCMessage, handle: JSValue) {
         IPCInstance::handle_ipc_message(self, &msg, handle)
     }
-    /// VM-side owner has no JS-visible `this` (Zig: `.null` arm).
+    /// VM-side owner has no JS-visible `this`.
     fn this_jsvalue(&self) -> JSValue {
         JSValue::ZERO
     }
@@ -2953,15 +2888,18 @@ impl crate::ipc::SendQueueOwner for IPCInstance {
     }
 }
 
-/// Spec VirtualMachine.zig:1708 `ResolveFunctionResult`.
+/// Output slot for module resolution: the resolver result plus the resolved path and query string.
 #[derive(Default)]
 pub struct ResolveFunctionResult {
     pub result: Option<bun_resolver::Result>,
-    pub path: &'static [u8], // TODO(port): lifetime — borrows resolver arena
+    // LIFETIME-ERASED: `path`/`query_string` borrow argv or the resolver's
+    // process-lifetime arena (`detach_lifetime` in `resolve_maybe_need_dirname_uncached`),
+    // which outlives every `ResolveFunctionResult`.
+    pub path: &'static [u8],
     pub query_string: &'static [u8],
 }
 
-/// Spec VirtualMachine.zig:1584 `source_code_printer`.
+/// Per-thread `BufferPrinter` used when printing transpiled module source.
 #[thread_local]
 pub(crate) static SOURCE_CODE_PRINTER: Cell<Option<NonNull<bun_js_printer::BufferPrinter>>> =
     Cell::new(None);
@@ -2976,7 +2914,6 @@ pub(crate) static SOURCE_CODE_PRINTER: Cell<Option<NonNull<bun_js_printer::Buffe
 #[thread_local]
 static SOURCE_CODE_PRINTER_FROM_MACRO: Cell<bool> = Cell::new(false);
 
-/// Spec VirtualMachine.zig:1712 `normalizeSpecifierForResolution`.
 fn normalize_specifier_for_resolution<'a>(
     specifier_: &'a [u8],
     query_string: &mut &'a [u8],
@@ -2989,8 +2926,7 @@ fn normalize_specifier_for_resolution<'a>(
     }
 }
 
-/// Spec VirtualMachine.zig:1722 `specifier_cache_resolver_bufs` (bun.ThreadlocalBuffers —
-/// heap-backed so only a pointer lives in TLS; see test/js/bun/binary/tls-segment-size).
+/// Heap-backed so only a pointer lives in TLS; see test/js/bun/binary/tls-segment-size.
 #[thread_local]
 static SPECIFIER_CACHE_RESOLVER_BUF: core::cell::Cell<*mut bun_paths::PathBuffer> =
     core::cell::Cell::new(core::ptr::null_mut());
@@ -3139,7 +3075,7 @@ extern "C" fn free_ref_string(str_: *mut crate::ref_string::RefString, _: *mut c
 }
 
 impl VirtualMachine {
-    /// Spec VirtualMachine.zig:234 `getDevServerAsyncLocalStorage`.
+    /// Returns the dev server's `AsyncLocalStorage` instance, or `None` when unset.
     pub fn get_dev_server_async_local_storage(&mut self) -> JsResult<Option<JSValue>> {
         let global_ref = self.global();
         let jsvalue =
@@ -3150,7 +3086,7 @@ impl VirtualMachine {
         Ok(Some(jsvalue))
     }
 
-    /// Spec VirtualMachine.zig:245 `allowAddons` (`callconv(.c)`).
+    /// Whether native addons (`process.dlopen`) are allowed (`--no-addons` disables them).
     #[unsafe(export_name = "Bun__VM__allowAddons")]
     pub extern "C" fn allow_addons(this: &VirtualMachine) -> bool {
         this.transpiler
@@ -3160,14 +3096,14 @@ impl VirtualMachine {
             .unwrap_or(true)
     }
 
-    /// Spec VirtualMachine.zig:248 `allowRejectionHandledWarning` (`callconv(.c)`).
+    /// Whether to warn when a previously-unhandled rejection later gains a handler.
     #[unsafe(export_name = "Bun__VM__allowRejectionHandledWarning")]
     pub extern "C" fn allow_rejection_handled_warning(this: &VirtualMachine) -> bool {
         use bun_options_types::schema::api::UnhandledRejections;
         this.unhandled_rejections_mode() != UnhandledRejections::Bun
     }
 
-    /// Spec VirtualMachine.zig:251 `unhandledRejectionsMode`.
+    /// The configured `--unhandled-rejections` mode (defaults to Bun's behavior).
     pub fn unhandled_rejections_mode(&self) -> bun_options_types::schema::api::UnhandledRejections {
         use bun_options_types::schema::api::UnhandledRejections;
         self.transpiler
@@ -3177,7 +3113,7 @@ impl VirtualMachine {
             .unwrap_or(UnhandledRejections::Bun)
     }
 
-    /// Spec VirtualMachine.zig:279 `uvLoop`.
+    /// Returns this VM's libuv event loop handle (must already be initialized).
     pub fn uv_loop(&self) -> *mut Async::Loop {
         #[cfg(debug_assertions)]
         {
@@ -3191,7 +3127,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:298 `getTLSRejectUnauthorized`.
+    /// Whether TLS certificate verification is enforced, from the cached override or the env loader.
     pub fn get_tls_reject_unauthorized(&self) -> bool {
         if let Some(v) = self.default_tls_reject_unauthorized {
             return v;
@@ -3199,21 +3135,21 @@ impl VirtualMachine {
         self.transpiler.env_mut().get_tls_reject_unauthorized()
     }
 
-    /// Spec VirtualMachine.zig:302 `onSubprocessSpawn`.
+    /// Registers a spawned subprocess with the auto-killer.
     pub fn on_subprocess_spawn(&mut self, process: core::ptr::NonNull<bun_spawn::Process>) {
         self.auto_killer.on_subprocess_spawn(process);
     }
 
-    /// Spec VirtualMachine.zig:306 `onSubprocessExit`.
+    /// Unregisters an exited subprocess from the auto-killer.
     pub fn on_subprocess_exit(&mut self, process: core::ptr::NonNull<bun_spawn::Process>) {
         self.auto_killer.on_subprocess_exit(process);
     }
 
-    /// Spec VirtualMachine.zig:310 `getVerboseFetch`.
+    /// Verbose fetch logging level, from the cached override or `BUN_CONFIG_VERBOSE_FETCH`.
     pub fn get_verbose_fetch(&mut self) -> bun_http::HTTPVerboseLevel {
         use bun_http::HTTPVerboseLevel as L;
         if let Some(v) = self.default_verbose_fetch {
-            // PORT NOTE: field is `Option<u8>` until the b2-cycle widens it;
+            // Note: field is `Option<u8>` until the b2-cycle widens it;
             // map ordinals back.
             return match v {
                 1 => L::Headers,
@@ -3235,12 +3171,12 @@ impl VirtualMachine {
         L::None
     }
 
-    /// Spec VirtualMachine.zig:369 `mimeType`.
+    /// Resolves a MIME type string via the VM's cached MIME-type table.
     pub fn mime_type(&mut self, str_: &[u8]) -> Option<bun_http::MimeType::MimeType> {
         self.rare_data().mime_type_from_string(str_)
     }
 
-    /// Spec VirtualMachine.zig:498 `loadExtraEnvAndSourceCodePrinter`.
+    /// Applies env-derived runtime settings, claims the per-thread source code printer, and adopts `NODE_CHANNEL_FD` for IPC.
     pub fn load_extra_env_and_source_code_printer(&mut self) {
         // `Transpiler::env_mut()` encapsulates the raw-ptr deref; the returned
         // `&'static mut Loader` is independent of `&self`, so `map` may be held
@@ -3272,10 +3208,7 @@ impl VirtualMachine {
                 .map(|i| map.map.swap_remove_at(i).1)
                 .and_then(|v| crate::ipc::Mode::from_string(&v.value))
                 .unwrap_or(crate::ipc::Mode::Json);
-            // PORT NOTE: Zig `IPC.log()` debug-only; the `IPC` scope static
-            // lives in `crate::ipc` and `scoped_log!` requires a bare ident,
-            // so the log line is dropped here.
-            // Spec: `std.fmt.parseInt(u31, fd_s, 10)` — accept only
+            // Accept only
             // non-negative values that fit in i31 (i.e. `0..=i32::MAX`).
             // Parsing as `u32` then `as i32` would silently wrap values in
             // `2^31..2^32` to a negative fd instead of taking the warn branch.
@@ -3331,7 +3264,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:595 `unhandledRejection`.
+    /// Routes an unhandled promise rejection to the configured handler, bumping the unhandled-error counter.
     pub fn unhandled_rejection(
         &mut self,
         global_object: &JSGlobalObject,
@@ -3351,8 +3284,7 @@ impl VirtualMachine {
             return;
         }
 
-        // PORT NOTE: Zig `defer eventLoop().drainMicrotasks()` per-arm —
-        // hoisted into a closure.
+        // Each arm drains microtasks on exit — hoisted into a closure.
         let drain = |this: &mut Self| {
             let _ = this.event_loop_mut().drain_microtasks();
         };
@@ -3367,10 +3299,7 @@ impl VirtualMachine {
             });
             if let Err(e) = r {
                 let exc = global_object.take_exception(e);
-                // PORT NOTE: Zig went `exc.asException(vm)` → `reportUncaughtException`,
-                // which itself just does `uncaughtException(global, exception.value(), false)`.
-                // `JSValue::as_exception` is not yet ported; inline the body — `exc` is
-                // already the exception's value.
+                // `exc` is already the exception's value; report it directly.
                 let _ = this.uncaught_exception(global_object, exc, false);
             }
         };
@@ -3403,7 +3332,6 @@ impl VirtualMachine {
                 if handled {
                     return;
                 }
-                // PORT NOTE: Zig returned unconditionally after warn; mirror it.
                 return;
             }
             Mode::Strict => {
@@ -3428,9 +3356,8 @@ impl VirtualMachine {
                     drain(self);
                     return;
                 }
-                // continue to default handler — but spec VirtualMachine.zig
-                // :667-669 RETURNS on `error.JSTerminated` from this drain
-                // (the VM is dead; don't bump the counter or invoke the
+                // continue to default handler — but RETURN if this drain
+                // errors (the VM is dead; don't bump the counter or invoke the
                 // handler).
                 if self.event_loop_mut().drain_microtasks().is_err() {
                     return;
@@ -3441,9 +3368,8 @@ impl VirtualMachine {
         (self.on_unhandled_rejection)(self, global_object, reason);
     }
 
-    /// Spec VirtualMachine.zig:718 `reportExceptionInHotReloadedModuleIfNeeded`.
+    /// After a hot reload, surfaces the entry-point promise's rejection (if any) and re-arms the watcher.
     pub fn report_exception_in_hot_reloaded_module_if_needed(&mut self) {
-        // PORT NOTE: Zig `defer this.addMainToWatcherIfNeeded()`.
         let promise = match self.pending_internal_promise {
             Some(p) => p,
             None => {
@@ -3481,7 +3407,7 @@ impl VirtualMachine {
         self.add_main_to_watcher_if_needed();
     }
 
-    /// Spec VirtualMachine.zig:737 `addMainToWatcherIfNeeded`.
+    /// Adds the main entry point to the file watcher when watch mode is enabled.
     pub fn add_main_to_watcher_if_needed(&mut self) {
         if !self.is_watcher_enabled() {
             return;
@@ -3500,13 +3426,11 @@ impl VirtualMachine {
             // discriminant is write-once at install and read-only thereafter,
             // and `add_file_by_path_slow` serializes the inner watchlist write
             // via `Watcher.mutex`. Borrow is scoped to this single
-            // mutex-guarded call (Zig spec uses alias-allowed `*Watcher`).
+            // mutex-guarded call.
             let _ = unsafe { (*watcher).add_file_by_path_slow(main, loader) };
         }
     }
 
-    /// Spec VirtualMachine.zig:751 `packageManager`.
-    ///
     /// `bun_resolver` holds the manager as an opaque forward-decl (it cannot
     /// depend on `bun_install`). `bun_jsc` *can*, so cast the opaque back to
     /// the concrete `bun_install::PackageManager` here — the resolver's
@@ -3528,7 +3452,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:769 `reload`.
+    /// Performs a hot reload: re-evaluates the entry point once any pending entry-point load settles.
     pub fn reload(&mut self, _: Option<&mut crate::hot_reloader::HotReloadTask>) {
         if let Some(p) = self.pending_internal_promise {
             // SAFETY: `p` is a live JSC heap cell tracked by the VM.
@@ -3581,15 +3505,13 @@ impl VirtualMachine {
         }
         // reload_entry_point() stores into pending_internal_promise on every return path.
         let main = self.main;
-        // PORT NOTE: reshaped for borrowck — copy the `RawSlice` first to avoid
+        // Note: reshaped for borrowck — copy the `RawSlice` first to avoid
         // overlapping `&self`/`&mut self` borrows.
         if self.reload_entry_point(main.slice()).is_err() {
             panic!("Failed to reload");
         }
     }
 
-    /// Spec VirtualMachine.zig:827 `nodeFS`.
-    ///
     /// `NodeFS` lives in `bun_runtime` (forward-dep on `bun_jsc`), so the
     /// field is stored type-erased and the lazy boxed allocation goes through
     /// [`RuntimeHooks::create_node_fs`]. Callers in `bun_runtime` cast the
@@ -3608,7 +3530,7 @@ impl VirtualMachine {
         new
     }
 
-    /// Spec VirtualMachine.zig:998 `nextAsyncTaskID`.
+    /// Returns the next debugger async-task id, or 0 when no debugger is attached.
     pub fn next_async_task_id(&mut self) -> u64 {
         let Some(debugger) = self.debugger.as_deref_mut() else {
             return 0;
@@ -3617,9 +3539,7 @@ impl VirtualMachine {
         debugger.next_debugger_id
     }
 
-    /// Spec VirtualMachine.zig:1016 `enqueueImmediateTask`.
-    ///
-    /// PORT NOTE (§Dispatch): `task` is an erased
+    /// Note (§Dispatch): `task` is an erased
     /// `*mut bun_runtime::timer::ImmediateObject` — see
     /// [`crate::event_loop::RunImmediateFn`].
     #[inline]
@@ -3627,7 +3547,7 @@ impl VirtualMachine {
         self.event_loop_mut().enqueue_immediate_task(task);
     }
 
-    /// Spec VirtualMachine.zig:1020 `enqueueTaskConcurrent`.
+    /// Enqueues a task from another thread onto this VM's event loop.
     #[inline]
     pub fn enqueue_task_concurrent(
         &mut self,
@@ -3636,8 +3556,6 @@ impl VirtualMachine {
         self.event_loop_mut().enqueue_task_concurrent(task);
     }
 
-    /// Spec VirtualMachine.zig:1028 `waitFor`.
-    ///
     /// `cond` is `&Cell<bool>` (not `&mut bool`): the re-entrant
     /// `tick()/auto_tick()` calls run JS that flips the flag through an
     /// independently-captured handle, so the read must not be `noalias`.
@@ -3663,7 +3581,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:1042 `waitForTasks`.
+    /// Ticks the event loop until no tasks keep it alive.
     pub fn wait_for_tasks(&mut self) {
         while self.is_event_loop_alive() {
             self.event_loop_mut().tick();
@@ -3673,9 +3591,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:1107 `initWithModuleGraph`.
-    ///
-    /// PORT NOTE: shares ~90% with [`init`]; the differences are (a) the
+    /// Note: shares ~90% with [`init`]; the differences are (a) the
     /// transpiler is built without `Config::configureTransformOptionsForBunVM`,
     /// (b) `standalone_module_graph` is mandatory and propagated into the
     /// resolver, (c) `configureLinkerWithAutoJSX(false)` instead of
@@ -3705,9 +3621,7 @@ impl VirtualMachine {
         Ok(vm)
     }
 
-    /// Spec VirtualMachine.zig:1394 `initWorker`.
-    ///
-    /// PORT NOTE: takes `&WebWorker` (not `&mut`) — the worker thread may only
+    /// Note: takes `&WebWorker` (not `&mut`) — the worker thread may only
     /// hold a shared reference to its `WebWorker` (the parent / main thread
     /// concurrently observes it; see `web_worker.rs` worker-thread `&self`
     /// note). All accesses on `worker` here are read-only.
@@ -3724,8 +3638,8 @@ impl VirtualMachine {
             smol: opts.smol,
             eval_mode: opts.eval,
             is_main_thread: false,
-            // Spec VirtualMachine.zig:1477-1484 — `JSGlobalObject.create` is
-            // called with `worker.cpp_worker`, `worker.execution_context_id`,
+            // The global is created
+            // with `worker.cpp_worker`, `worker.execution_context_id`,
             // and `worker.mini` so the C++ ZigGlobalObject is born with its
             // WorkerGlobalScope + debugger context id wired.
             worker_ptr: worker.cpp_worker(),
@@ -3733,7 +3647,7 @@ impl VirtualMachine {
             mini_mode: worker.mini(),
             ..Default::default()
         };
-        // PORT NOTE: Zig open-coded the full struct init; we route through
+        // Route through
         // [`init`] (which already wires console / event-loop / global / jsc_vm
         // / RuntimeHooks) and then patch the worker-specific fields.
         let vm = Self::init(init_opts)?;
@@ -3744,7 +3658,7 @@ impl VirtualMachine {
         // `parent_poll_ref` is held (see web_worker.rs file header).
         let parent = worker.parent_vm();
         vm_ref.standalone_module_graph = parent.standalone_module_graph;
-        // Spec VirtualMachine.zig:1465 `initWorker` — the worker's resolver also
+        // The worker's resolver also
         // needs the standalone graph, otherwise embedded `/$bunfs/...` specifiers
         // (e.g. a `new Worker("./worker.ts")` entry point inside a compiled
         // executable) resolve against the real filesystem and fail.
@@ -3760,7 +3674,7 @@ impl VirtualMachine {
         Ok(vm)
     }
 
-    /// Spec VirtualMachine.zig:1495 `initBake`.
+    /// Creates a `VirtualMachine` configured for the bake (dev server) runtime.
     pub fn init_bake(opts: Options) -> Result<*mut VirtualMachine, bun_core::Error> {
         let init_opts = InitOptions {
             transform_options: opts.args,
@@ -3772,7 +3686,7 @@ impl VirtualMachine {
             is_main_thread: opts.is_main_thread,
             ..Default::default()
         };
-        // PORT NOTE: shares the console / log / event-loop wiring with `init`;
+        // Note: shares the console / log / event-loop wiring with `init`;
         // the only delta is the global is created via `BakeCreateProdGlobal`
         // instead of `ZigGlobalObject__create`. Route through `init` then
         // swap the global.
@@ -3798,8 +3712,6 @@ impl VirtualMachine {
         Ok(vm)
     }
 
-    /// Spec VirtualMachine.zig:1586 `clearRefString`.
-    ///
     /// Stored as [`RefString::on_before_deinit`] (an unsafe-fn-ptr slot) in
     /// [`ref_counted_string_with_was_new`]; only ever invoked from
     /// `RefString::destroy` with the live `*mut RefString` being torn down.
@@ -3812,7 +3724,7 @@ impl VirtualMachine {
         VirtualMachine::get().as_mut().ref_strings.remove(&hash);
     }
 
-    /// Spec VirtualMachine.zig:1590 `refCountedResolvedSource`.
+    /// Builds a `ResolvedSource` backed by a ref-counted copy of `code` interned in the VM's ref-string map.
     pub fn ref_counted_resolved_source<const ADD_DOUBLE_REF: bool>(
         &mut self,
         code: &[u8],
@@ -3830,8 +3742,7 @@ impl VirtualMachine {
                 ..Default::default()
             };
         }
-        // PORT NOTE: Zig `refCountedString(code, hash_, !add_double_ref)` —
-        // const-generic bool can't be `!ADD_DOUBLE_REF`, so branch.
+        // Const-generic bool can't be `!ADD_DOUBLE_REF`, so branch.
         let source = if ADD_DOUBLE_REF {
             self.ref_counted_string::<false>(code, hash_)
         } else {
@@ -3856,7 +3767,6 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:1615 `refCountedStringWithWasNew`.
     fn ref_counted_string_with_was_new<const DUPE: bool>(
         &mut self,
         new: &mut bool,
@@ -3868,10 +3778,10 @@ impl VirtualMachine {
         jsc::mark_binding();
         debug_assert!(!input_.is_empty());
         let hash = hash_.unwrap_or_else(|| RefString::compute_hash(input_));
-        // PORT NOTE: Zig `lock(); defer unlock()` — RAII guard releases on every
+        // RAII guard releases on every
         // exit (including the early-return `Occupied` arm).
         let _unlock = self.ref_strings_mutex.lock_guard();
-        // PORT NOTE: reshaped for borrowck — capture the back-pointer before
+        // Note: reshaped for borrowck — capture the back-pointer before
         // `ref_strings.entry()` takes its unique borrow on `self`.
         let self_ctx = NonNull::new(std::ptr::from_mut::<VirtualMachine>(self).cast::<c_void>());
 
@@ -3881,7 +3791,7 @@ impl VirtualMachine {
                 *o.get()
             }
             Entry::Vacant(v) => {
-                // Spec :1624-1626 — dupe the input bytes when `DUPE`, otherwise
+                // Dupe the input bytes when `DUPE`, otherwise
                 // adopt the caller's allocation (caller transferred ownership).
                 let (ptr, len) = if DUPE {
                     let buf = Box::<[u8]>::from(input_);
@@ -3920,7 +3830,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:1650 `refCountedString`.
+    /// Interns `input_` in the VM's ref-string map and returns the ref-counted entry.
     pub fn ref_counted_string<const DUPE: bool>(
         &mut self,
         input_: &[u8],
@@ -3931,11 +3841,10 @@ impl VirtualMachine {
         self.ref_counted_string_with_was_new::<DUPE>(&mut was_new, input_, hash_)
     }
 
-    /// Spec VirtualMachine.zig:1656 `fetchWithoutOnLoadPlugins`.
-    // PORT NOTE: Zig `comptime flags: FetchFlags` lowered to a runtime arg —
+    // Note: `flags` is a runtime arg —
     // `FetchFlags` would need `ConstParamTy` (unstable derive on the enum's
-    // owning module) to stay a const generic; the only branches are cheap
-    // equality tests so the runtime form is fine. PERF(port): revisit.
+    // owning module) to be a const generic; the only branches are cheap
+    // equality tests so the runtime form is fine.
     pub fn fetch_without_on_load_plugins(
         jsc_vm: &mut VirtualMachine,
         global_object: &JSGlobalObject,
@@ -3961,8 +3870,7 @@ impl VirtualMachine {
         let referrer_clone = referrer.to_utf8();
 
         let mut virtual_source_to_use: Option<bun_ast::Source> = None;
-        // Spec :1676-1677 — `var blob_to_deinit: ?webcore.Blob = null;
-        // defer if (blob_to_deinit) |*blob| blob.deinit();`. The blob crosses
+        // The blob crosses
         // the bundler↔runtime boundary as an erased `OpaqueBlob`; deinit goes
         // through the same `VmLoaderCtx` that produced it.
         struct BlobDeinit(
@@ -3992,7 +3900,6 @@ impl VirtualMachine {
             None,
         ) {
             Ok(lr) => lr,
-            // Spec :1679 `catch { return error.ModuleNotFound; }`.
             Err(_) => return Err(bun_core::err!("ModuleNotFound")),
         };
         let module_type = lr
@@ -4000,9 +3907,8 @@ impl VirtualMachine {
             .map(|pkg| pkg.module_type)
             .unwrap_or(bun_bundler::options::ModuleType::Unknown);
 
-        // PORT NOTE: Zig `defer if (flags != .print_source) resetArena();
-        // errdefer if (flags == .print_source) resetArena()`. Model with a
-        // drop-guard so both paths reset on the right edge.
+        // A drop-guard so both the normal and error paths reset the arena on
+        // the right edge.
         struct ArenaReset<'a>(&'a mut VirtualMachine, bool);
         impl Drop for ArenaReset<'_> {
             fn drop(&mut self) {
@@ -4019,9 +3925,8 @@ impl VirtualMachine {
             .get()
             .expect("source_code_printer not initialized");
 
-        // PORT NOTE: Zig passes path/loader/module_type/printer/promise_ptr as
-        // positional params to `transpileSourceCode`; the §Dispatch shim takes
-        // them bundled as `TranspileExtra` behind `args.extra` (see
+        // Note: the §Dispatch shim takes path/loader/module_type/printer/
+        // promise_ptr bundled as `TranspileExtra` behind `args.extra` (see
         // ModuleLoader.rs `TranspileArgs`).
         let mut extra = ModuleLoader::TranspileExtra {
             // SAFETY: `lr.path` borrows from `specifier_clone` (and the VM's
@@ -4037,7 +3942,7 @@ impl VirtualMachine {
             }),
             module_type,
             source_code_printer: printer.as_ptr(),
-            // Spec: `null` — `fetchWithoutOnLoadPlugins` forbids the async path.
+            // `fetchWithoutOnLoadPlugins` forbids the async path.
             promise_ptr: core::ptr::null_mut(),
         };
         let args = ModuleLoader::TranspileArgs {
@@ -4056,11 +3961,11 @@ impl VirtualMachine {
         if !ok && flags == FetchFlags::PrintSource {
             guard.1 = true; // errdefer
         }
-        // `blob_to_deinit` drop guard fires here (spec :1677 `defer`).
+        // `blob_to_deinit` drop guard fires here.
         ret.unwrap()
     }
 
-    /// Zig `bun.default_allocator.dupe(u8, s)` for the `_resolve` fast-paths.
+    /// Dupe `s` into a VM-owned allocation for the `_resolve` fast-paths.
     fn dupe_resolved_path(&mut self, s: &[u8]) -> &'static [u8] {
         let boxed: Box<[u8]> = s.to_vec().into_boxed_slice();
         // SAFETY: `boxed`'s heap allocation has a stable address for as long
@@ -4070,10 +3975,8 @@ impl VirtualMachine {
         slice
     }
 
-    /// Spec VirtualMachine.zig:1724 `_resolve`.
-    ///
-    /// PORT NOTE: Zig has `comptime is_a_file_path: bool`; folded to a runtime
-    /// arg here to avoid duplicating the body for both monomorphizations.
+    /// Note: `is_a_file_path` is a runtime
+    /// arg to avoid duplicating the body for both monomorphizations.
     pub fn _resolve(
         &mut self,
         ret: &mut ResolveFunctionResult,
@@ -4085,10 +3988,10 @@ impl VirtualMachine {
         use bun_js_parser::Macro;
         use bun_resolver::{ResultUnion, node_fallbacks};
 
-        // SAFETY: PORT — `specifier`/`source` borrow argv / resolver-arena
-        // bytes that outlive `ResolveFunctionResult` (`'static` per the
-        // struct's TODO(port) lifetime note). Erase to `'static` to seat the
-        // result paths without threading a lifetime parameter through the VM.
+        // SAFETY: `specifier`/`source` borrow argv / resolver-arena bytes that
+        // outlive `ResolveFunctionResult` (see the struct's lifetime-erasure
+        // note). Erase to `'static` to seat the result paths without threading
+        // a lifetime parameter through the VM.
         let specifier: &'static [u8] = unsafe { bun_ptr::detach_lifetime(specifier) };
 
         // `Runtime.Runtime.Imports.{alt_name, Name}` are both `"bun:wrap"`
@@ -4166,8 +4069,7 @@ impl VirtualMachine {
             top_level_dir
         };
 
-        // PORT NOTE: Zig modeled this as a labeled `while (true)` with
-        // `continue` after a successful cache bust. Expressed as a `loop`
+        // A `loop`
         // returning the resolver result; `retry_on_not_found` is consumed on
         // the first miss.
         let mut retry_on_not_found = bun_paths::is_absolute(source_to_use);
@@ -4254,7 +4156,8 @@ impl VirtualMachine {
             .path_const()
             .ok_or_else(|| bun_core::err!("ModuleNotFound"))?;
         // SAFETY: `result_path.text` borrows the resolver's arena, which
-        // outlives `ResolveFunctionResult` (see field TODO(port) lifetime).
+        // outlives `ResolveFunctionResult` (see the struct's lifetime-erasure
+        // note).
         ret.path = unsafe { bun_ptr::detach_lifetime(result_path.text) };
         ret.result = Some(result);
         self.resolved_count += 1;
@@ -4262,7 +4165,7 @@ impl VirtualMachine {
         Ok(())
     }
 
-    /// Spec VirtualMachine.zig:1854 `resolve`.
+    /// Resolves `specifier` relative to `source`, writing the result or error into `res`.
     pub fn resolve(
         res: &mut ErrorableString,
         global: &JSGlobalObject,
@@ -4282,7 +4185,7 @@ impl VirtualMachine {
         )
     }
 
-    /// Spec VirtualMachine.zig:1873 `resolveMaybeNeedsTrailingSlash`.
+    /// Module-resolution core: resolves `specifier` relative to `source`, with path-length checks when `IS_A_FILE_PATH`.
     pub fn resolve_maybe_needs_trailing_slash<const IS_A_FILE_PATH: bool>(
         res: &mut ErrorableString,
         global: &JSGlobalObject,
@@ -4364,8 +4267,8 @@ impl VirtualMachine {
         }
 
         // Swap in a fresh log so resolver errors don't pollute the VM's main log.
-        // `vm.log` is set unconditionally in `init` and never cleared (Zig
-        // stores `*logger.Log`, always non-null), so the `Option` is purely a
+        // `vm.log` is set unconditionally in `init` and never cleared,
+        // so the `Option` is purely a
         // zeroed-init nicety; the `expect` is infallible.
         let old_log: NonNull<bun_ast::Log> = jsc_vm.log.expect("vm.log set in init");
         let mut log = bun_ast::Log::default();
@@ -4377,7 +4280,7 @@ impl VirtualMachine {
             // (sole impl — see `VirtualMachine::package_manager`).
             unsafe { (*pm.cast::<bun_install::PackageManager>().as_ptr()).log = &raw mut log };
         }
-        // PORT NOTE: Zig `defer { restore old_log }` — fires on every exit
+        // Note: the restore must fire on every exit
         // (including `?` from `ResolveMessage::create` below), so the VM's
         // `log` cannot be left pointing at the dropped stack `log`. Hand-roll
         // a drop guard (no captured borrows) so the unique `&mut *jsc_vm_ptr`
@@ -4411,7 +4314,7 @@ impl VirtualMachine {
             vm: bun_ptr::BackRef::from(NonNull::new(jsc_vm_ptr).expect("vm non-null")),
             old_log,
         };
-        // PORT NOTE: reshaped for borrowck — re-derive from raw so the unique
+        // Note: reshaped for borrowck — re-derive from raw so the unique
         // borrow doesn't span the guard's drop.
         // SAFETY: per-thread VM is live for this synchronous call.
         let jsc_vm = unsafe { &mut *jsc_vm_ptr };
@@ -4479,19 +4382,18 @@ impl VirtualMachine {
         *res = ErrorableString::ok(bun_core::String::clone_utf8(result.path));
         Ok(())
     }
-    /// `VirtualMachine.deinit` — worker-thread teardown. Spec
-    /// VirtualMachine.zig:2109.
+    /// Worker-thread teardown.
     pub fn destroy(&mut self) {
         self.regular_event_loop.deinit();
         self.macro_event_loop.deinit();
 
-        // PORT NOTE: Zig `auto_killer.deinit()` — `ProcessAutoKiller`'s `Drop`
+        // `ProcessAutoKiller`'s `Drop`
         // is the deinit body; take()+drop runs it without dropping `self`.
         drop(core::mem::take(&mut self.auto_killer));
 
         drop_source_code_printer();
 
-        // PORT NOTE: `SavedSourceMap`'s `Drop` is the Zig `deinit()`; it frees
+        // Note: `SavedSourceMap`'s `Drop` frees
         // each stored map and `deinit()`s the sibling `saved_source_map_table`.
         drop(core::mem::take(&mut self.source_mappings));
 
@@ -4509,7 +4411,7 @@ impl VirtualMachine {
             drop(rare);
         }
 
-        // PORT NOTE: Zig `proxy_env_storage.deinit()` — drops all `Arc`-held
+        // Drops all `Arc`-held
         // proxy strings; `ProxyEnvStorage: Default` so take()+drop suffices.
         drop(core::mem::take(&mut self.proxy_env_storage));
 
@@ -4528,9 +4430,8 @@ impl VirtualMachine {
 
         self.overridden_main.deinit();
 
-        // PORT NOTE: Zig frees `timer`/`entry_point` as value fields of `self`;
-        // here they live in the high-tier `RuntimeState` box, so dispatch the
-        // reclaim through the hook. PERF(port): was inline switch.
+        // `timer`/`entry_point` live in the high-tier `RuntimeState` box, so
+        // dispatch the reclaim through the hook.
         if let Some(hooks) = runtime_hooks() {
             let state = core::mem::replace(&mut self.runtime_state, core::ptr::null_mut());
             // SAFETY: hook contract — `state` is exactly the pointer
@@ -4540,9 +4441,7 @@ impl VirtualMachine {
         }
         self.has_terminated = true;
     }
-    /// Spec VirtualMachine.zig:2134 `printException`.
-    ///
-    /// PORT NOTE: Zig is `comptime Writer`-generic; collapse to the concrete
+    /// Note: takes the concrete
     /// `bun_core::io::Writer` since every call site passes
     /// `Output.errorWriterBuffered()`.
     pub fn print_exception(
@@ -4566,7 +4465,7 @@ impl VirtualMachine {
         // `defer formatter.deinit()` → Drop.
     }
 
-    /// Spec VirtualMachine.zig:2195 `clearEntryPoint`.
+    /// Deletes the synthetic main-entry module from the module registry.
     pub fn clear_entry_point(&mut self) -> JsResult<()> {
         if self.main().is_empty() {
             return Ok(());
@@ -4575,7 +4474,7 @@ impl VirtualMachine {
         self.global().delete_module_registry_entry(&str)
     }
 
-    /// Spec VirtualMachine.zig:2363 `useIsolationSourceProviderCache` (exported `callconv(.c)`).
+    /// Whether the per-test-isolation source provider cache is active.
     #[unsafe(export_name = "Bun__VM__useIsolationSourceProviderCache")]
     pub extern "C" fn use_isolation_source_provider_cache(&self) -> bool {
         self.test_isolation_enabled
@@ -4583,7 +4482,7 @@ impl VirtualMachine {
                 .unwrap_or(false)
     }
 
-    /// Spec VirtualMachine.zig:2378 `reloadEntryPointForTestRunner`.
+    /// Resets entry-point state and re-loads `entry_path` for the test runner, returning the load promise.
     pub fn reload_entry_point_for_test_runner(
         &mut self,
         entry_path: &[u8],
@@ -4613,7 +4512,7 @@ impl VirtualMachine {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck.
+        // Note: reshaped for borrowck.
         let global = self.global;
         let main_str = bun_core::String::from_bytes(self.main());
         let promise = jsc::JSModuleLoader::load_and_evaluate_module_ptr(global, Some(&main_str))
@@ -4625,7 +4524,7 @@ impl VirtualMachine {
         Ok(promise)
     }
 
-    /// Spec VirtualMachine.zig:2410 `loadEntryPointForWebWorker`.
+    /// Loads the worker entry point and waits for it, honoring termination requests.
     pub fn load_entry_point_for_web_worker(
         &mut self,
         entry_path: &[u8],
@@ -4642,7 +4541,7 @@ impl VirtualMachine {
         Ok(self.pending_internal_promise.unwrap())
     }
 
-    /// Spec VirtualMachine.zig:2424 `loadEntryPointForTestRunner`.
+    /// Loads a test-file entry point and waits for the load promise to settle.
     pub fn load_entry_point_for_test_runner(
         &mut self,
         entry_path: &[u8],
@@ -4682,7 +4581,7 @@ impl VirtualMachine {
         Ok(self.pending_internal_promise.unwrap())
     }
 
-    /// Spec VirtualMachine.zig:2486 `addListeningSocketForWatchMode`.
+    /// Tracks a listening socket so watch-mode reloads can close it.
     pub fn add_listening_socket_for_watch_mode(&mut self, socket: bun_sys::Fd) {
         if self.hot_reload != HOT_RELOAD_WATCH && !self.test_isolation_enabled {
             return;
@@ -4690,7 +4589,7 @@ impl VirtualMachine {
         self.rare_data().add_listening_socket_for_watch_mode(socket);
     }
 
-    /// Spec VirtualMachine.zig:2493 `removeListeningSocketForWatchMode`.
+    /// Stops tracking a watch-mode listening socket.
     pub fn remove_listening_socket_for_watch_mode(&mut self, socket: bun_sys::Fd) {
         if self.hot_reload != HOT_RELOAD_WATCH && !self.test_isolation_enabled {
             return;
@@ -4699,6 +4598,8 @@ impl VirtualMachine {
             .remove_listening_socket_for_watch_mode(socket);
     }
 
+    /// Replaces the global object between test files so each file runs in a fresh realm.
+    ///
     /// Callers must run `bun_runtime::jsc_hooks::close_isolation_handles(vm)`
     /// first so leaked watchers/servers are stopped (dropping their JS-side
     /// Strongs, which otherwise pin the outgoing global) before the blind
@@ -4830,7 +4731,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:2641 `_loadMacroEntryPoint`.
+    /// Loads and evaluates a macro entry module, waiting for its promise.
     #[inline]
     pub fn _load_macro_entry_point(&mut self, entry_path: &[u8]) -> Option<*mut JSInternalPromise> {
         let path_str = bun_core::String::init(entry_path);
@@ -4841,16 +4742,12 @@ impl VirtualMachine {
         Some(promise)
     }
 
-    /// Spec VirtualMachine.zig:2652 `printErrorLikeObjectToConsole`.
+    /// Prints an error-like JS value to the console via the error handler.
     pub fn print_error_like_object_to_console(&mut self, value: JSValue) {
         self.run_error_handler(value, None);
     }
 
-    /// Spec VirtualMachine.zig:2663 `printErrorlikeObject`.
-    ///
-    /// PORT NOTE: Zig is `comptime Writer` + `comptime allow_ansi_color` +
-    /// `comptime allow_side_effects` — collapse to runtime bools and the
-    /// concrete `bun_core::io::Writer`.
+    /// Note: takes runtime bools and the concrete `bun_core::io::Writer`.
     pub fn print_errorlike_object(
         &mut self,
         value: JSValue,
@@ -4861,20 +4758,17 @@ impl VirtualMachine {
         allow_ansi_color: bool,
         allow_side_effects: bool,
     ) {
-        // PORT NOTE: Zig declared `was_internal` and ran the
-        // exception-stack-trace `defer` after the body. Reshape: handle the
-        // post-print stack/exception_list block at the tail instead of via a
-        // drop guard (the body has no early-`?` returns once the AggregateError
-        // branch is taken).
+        // Note: the post-print stack/exception_list block is handled at the
+        // tail instead of via a drop guard (the body has no early-`?` returns
+        // once the AggregateError branch is taken).
         let global_ref = self.global();
 
         if value.is_aggregate_error(global_ref) {
-            // PORT NOTE: Zig comptime-generated `AggregateErrorIterator` with
-            // `extern "C"` callbacks. `JSValue::for_each` takes a C-ABI fn
+            // Note: `JSValue::for_each` takes a C-ABI fn
             // pointer + erased ctx, so thread the captures through a struct.
             // The C trampoline erases lifetimes via `*mut c_void`; round-trip
             // the caller's `&mut ExceptionList` as a raw pointer so child
-            // errors append to the same list (spec VirtualMachine.zig:2715).
+            // errors append to the same list.
             struct AggCtx<'a> {
                 formatter: *mut crate::console_object::Formatter<'a>,
                 writer: *mut bun_core::io::Writer,
@@ -4924,16 +4818,16 @@ impl VirtualMachine {
                 allow_ansi_color,
                 allow_side_effects,
             };
-            // Spec VirtualMachine.zig:2717 — `getErrorsProperty` is
+            // `getErrorsProperty` is
             // `getDirect` (own data prop, nothrow); `for_each` may throw, in
-            // which case the spec `catch return` swallows it.
+            // which case the error is swallowed.
             let errors = value.get_errors_property(global_ref);
             let _ = errors.for_each(global_ref, (&raw mut ctx).cast(), agg_iter);
             return;
         }
 
-        // PORT NOTE: reborrow so the Zig `defer { addToErrorList(exception_list) }`
-        // tail can still see it after `print_error_from_maybe_private_data`.
+        // Note: reborrow so the add-to-error-list tail can still see it after
+        // `print_error_from_maybe_private_data`.
         let mut exception_list = exception_list;
         let was_internal = self.print_error_from_maybe_private_data(
             value,
@@ -4947,9 +4841,8 @@ impl VirtualMachine {
         if was_internal {
             if let Some(exception_) = exception {
                 let mut holder = crate::zig_exception::Holder::init();
-                // PORT NOTE: Zig calls `holder.deinit(this)` *before*
-                // `getStackTrace` (no-op on the empty holder); reordered to
-                // the tail for borrowck — semantics unchanged because
+                // Note: `holder.deinit(self)` runs at the tail (for borrowck)
+                // — semantics unchanged because
                 // `need_to_clear_parser_arena_on_deinit` is false here.
                 let zig_exception: &mut ZigException = holder.zig_exception();
                 exception_.get_stack_trace(global_ref, &mut zig_exception.stack);
@@ -4966,7 +4859,6 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:2735 `printErrorFromMaybePrivateData`.
     fn print_error_from_maybe_private_data(
         &mut self,
         value: JSValue,
@@ -5054,7 +4946,7 @@ impl VirtualMachine {
         false
     }
 
-    /// Spec VirtualMachine.zig:2807 `reportUncaughtException`.
+    /// Reports an uncaught exception through the owning VM's handler; returns `undefined`.
     pub fn report_uncaught_exception(
         global_object: &JSGlobalObject,
         exception: &Exception,
@@ -5064,10 +4956,7 @@ impl VirtualMachine {
         JSValue::UNDEFINED
     }
 
-    /// Spec VirtualMachine.zig:2813 `printStackTrace`.
-    ///
-    /// PORT NOTE: Zig is `comptime Writer` + `comptime allow_ansi_colors`;
-    /// collapse to runtime bool + concrete writer.
+    /// Note: takes a runtime bool + concrete writer.
     pub fn print_stack_trace(
         writer: &mut bun_core::io::Writer,
         trace: &crate::ZigStackTrace,
@@ -5094,8 +4983,8 @@ impl VirtualMachine {
             if file.is_empty() && func.is_empty() {
                 continue;
             }
-            // PERF(port): Zig used `std.fmt.count` to test if the formatter
-            // emits anything; format into a scratch `String` to probe.
+            // Format into a scratch `String` to probe whether the formatter
+            // emits anything.
             let has_name = {
                 use core::fmt::Write as _;
                 let mut probe = String::new();
@@ -5103,8 +4992,7 @@ impl VirtualMachine {
                 !probe.is_empty()
             };
 
-            // PORT NOTE: Zig used `comptime Output.prettyFmt(...)` per arm;
-            // route through `bun_core::pretty_fmt!` with a local wrapper that
+            // Route through `bun_core::pretty_fmt!` with a local wrapper that
             // dispatches on the runtime `allow_ansi_colors` flag.
             macro_rules! pretty_write {
                 ($fmt:literal $(, $arg:expr)* $(,)?) => {
@@ -5141,8 +5029,6 @@ impl VirtualMachine {
         Ok(())
     }
 
-    /// Spec VirtualMachine.zig:2904 `remapStackFramePositions`.
-    ///
     /// # Safety
     /// `frames` must point to `frames_count` initialized `ZigStackFrame`s.
     pub unsafe fn remap_stack_frame_positions(
@@ -5155,15 +5041,13 @@ impl VirtualMachine {
         }
         // **Warning** this method can be called in the heap collector thread!!
         self.remap_stack_frames_mutex.lock();
-        // PORT NOTE: Zig `defer unlock()`.
 
         self.source_mappings.lock();
 
-        // PORT NOTE: the Zig body caches the last `(hash → InternalSourceMap)`
-        // pair across the loop and falls back to `resolve_source_mapping` on a
-        // miss. The cache is purely a perf optimization (most stacks repeat
-        // the same source); port the straightforward per-frame resolve and
-        // leave the cache as `// PERF(port)`.
+        // Note: a last-`(hash → InternalSourceMap)` cache across the loop
+        // would be purely a perf optimization (most stacks repeat the same
+        // source); do the straightforward per-frame resolve. See the PERF
+        // note below.
         // SAFETY: caller passes `frames_count` valid `ZigStackFrame`s.
         let frames = unsafe { bun_core::ffi::slice_mut(frames, frames_count) };
         for frame in frames {
@@ -5176,7 +5060,7 @@ impl VirtualMachine {
                 frame.remapped = true;
                 continue;
             }
-            // PERF(port): Zig cached `(hash → ism)` across iterations.
+            // PERF: could cache `(hash → ism)` across iterations.
             // Slow path: drops and re-acquires the source_mappings lock around
             // resolve_source_mapping().
             self.source_mappings.unlock();
@@ -5190,7 +5074,7 @@ impl VirtualMachine {
                     frame.source_url.deref();
                     frame.source_url = source_url;
                 }
-                // Spec VirtualMachine.zig:3022 — direct copy; both sides are
+                // Direct copy; both sides are
                 // `bun_core::Ordinal`. A `from_zero_based` round-trip would
                 // debug-assert on the valid INVALID (-1) sentinel.
                 frame.position.line = lookup.mapping.original.lines;
@@ -5206,7 +5090,7 @@ impl VirtualMachine {
         self.remap_stack_frames_mutex.unlock();
     }
 
-    /// Spec VirtualMachine.zig:3029 `remapZigException`.
+    /// Fills `exception` from `error_instance`, remapping stack frames through source maps.
     pub fn remap_zig_exception(
         &mut self,
         exception: &mut ZigException,
@@ -5222,7 +5106,7 @@ impl VirtualMachine {
         error_instance.to_zig_exception(global, exception);
         // `Cell<bool>` so the `Tail` drop-guard below can hold a shared `&Cell`
         // and read the *current* value at scope-exit without a raw-ptr deref,
-        // while the body freely `.set()`s it (Zig late-evaluated `defer`).
+        // while the body freely `.set()`s it.
         let enable_source_code_preview = Cell::new(
             allow_source_code_preview
                 && !(bun_core::env_var::feature_flag::BUN_DISABLE_SOURCE_CODE_PREVIEW::get()
@@ -5231,9 +5115,8 @@ impl VirtualMachine {
                         .unwrap_or(false)),
         );
 
-        // PORT NOTE: Zig modeled the two `defer` blocks below at fn-top; in
-        // Rust we run them on the way out via this guard so every early
-        // `return` is covered.
+        // Note: this guard runs the two tail blocks on the way out so every
+        // early `return` is covered.
         struct Tail<'a> {
             this: *mut VirtualMachine,
             exception: *mut ZigException,
@@ -5273,7 +5156,7 @@ impl VirtualMachine {
                 }
                 if let Some(list) = self.exception_list.take() {
                     let top_level_dir = this.top_level_dir();
-                    // Zig `catch unreachable` — OOM-only.
+                    // OOM-only.
                     bun_core::handle_oom(exception.add_to_error_list(
                         list,
                         top_level_dir,
@@ -5297,7 +5180,6 @@ impl VirtualMachine {
         let source_code_slice: &mut Option<bun_core::ZigStringSlice> =
             unsafe { &mut *_tail.source_code_slice.cast_mut() };
 
-        /// Spec VirtualMachine.zig:3058 `NoisyBuiltinFunctionMap`.
         fn is_noisy_builtin(name: &bun_core::String) -> bool {
             name.eql_comptime("asyncModuleEvaluation")
                 || name.eql_comptime("link")
@@ -5344,7 +5226,7 @@ impl VirtualMachine {
                     {
                         continue;
                     }
-                    // PORT NOTE: `frames[j] = frame`. `ZigStackFrame` impls
+                    // Note: `frames[j] = frame`. `ZigStackFrame` impls
                     // `Drop` so `copy_within` is unavailable; swap instead —
                     // the discarded tail past `j` is never read after we
                     // truncate `frames_len` below.
@@ -5421,7 +5303,7 @@ impl VirtualMachine {
         };
 
         if let Some(lookup) = maybe_lookup {
-            // Zig `defer if (source_map) |map| map.deref();` — Arc drop on scope exit.
+            // The source-map Arc drops on scope exit.
             let mapping = lookup.mapping;
             let display_url = if !already_remapped {
                 lookup.display_source_url_if_needed(top_source_url.slice())
@@ -5461,7 +5343,7 @@ impl VirtualMachine {
                 let Ok(original_source) = Self::fetch_without_on_load_plugins(
                     self,
                     global,
-                    // Spec VirtualMachine.zig:3194 passes `top.source_url` by
+                    // `top.source_url` is passed by
                     // value (no `dupeRef`); `bun_core::String` is `Copy`.
                     frames[top].source_url,
                     bun_core::String::empty(),
@@ -5471,12 +5353,10 @@ impl VirtualMachine {
                     return;
                 };
                 *must_reset_parser_arena_later = true;
-                // PORT NOTE: spec ModuleLoader.zig:358 *borrows*
-                // `parse_result.source.contents` for `.print_source`
-                // (`bun.String.init`), so the Zig caller has nothing to
-                // release. The Rust transpile path must `clone_utf8` instead
+                // Note: the transpile path `clone_utf8`s the source for
+                // `.print_source`
                 // (the backing `parse_result` drops on return — see
-                // jsc_hooks.rs PORT NOTE at the `PrintSource` arm), leaving
+                // jsc_hooks.rs Note at the `PrintSource` arm), leaving
                 // `source_code` with a +1 strong ref this caller never
                 // consumed. `to_utf8()` takes its own ref via
                 // `ZigStringSlice::WTF`, so balance the clone here. Also
@@ -5496,8 +5376,7 @@ impl VirtualMachine {
                 exception.collect_source_lines(error_instance, global);
             }
 
-            // Spec VirtualMachine.zig:3205 — direct copy; both sides are
-            // `bun_core::Ordinal`.
+            // Direct copy; both sides are `bun_core::Ordinal`.
             frames[top].position.line = mapping.original.lines;
             frames[top].position.column = mapping.original.columns;
             exception.remapped = true;
@@ -5561,7 +5440,7 @@ impl VirtualMachine {
                     }
                     let mapping = lookup.mapping;
                     frames[i].remapped = true;
-                    // Spec VirtualMachine.zig:3257 — direct copy.
+                    // Direct copy.
                     frames[i].position.line = mapping.original.lines;
                     frames[i].position.column = mapping.original.columns;
                 }
@@ -5569,7 +5448,7 @@ impl VirtualMachine {
         }
     }
 
-    /// Spec VirtualMachine.zig:3265 `printExternallyRemappedZigException`.
+    /// Prints an already-remapped exception (name, message, stack, source lines) to `writer`.
     pub fn print_externally_remapped_zig_exception(
         &mut self,
         zig_exception: &mut ZigException,
@@ -5592,8 +5471,8 @@ impl VirtualMachine {
         // `defer default_formatter.deinit()` → Drop.
     }
 
-    /// `printErrorInstance(.js, ...)` — split out from the Zig
-    /// `comptime mode: enum { js, zig_exception }` generic.
+    /// JS-value variant of the error printer; see
+    /// [`Self::print_error_instance_body`].
     fn print_error_instance_js(
         &mut self,
         error_instance: JSValue,
@@ -5603,11 +5482,9 @@ impl VirtualMachine {
         allow_ansi_color: bool,
         allow_side_effects: bool,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: stack-safety guard for the Error recursion path.
-        // Zig's `printErrorInstance` is `comptime Writer`/`allow_ansi_color`/
-        // `allow_side_effects`-monomorphized so each instantiation carries
-        // only one branch's locals. The Rust port collapses those to runtime
-        // bools, so `print_error_instance_body` carries the union of all
+        // Note: stack-safety guard for the Error recursion path.
+        // `print_error_instance_body` dispatches on runtime bools, so it
+        // carries the union of all
         // branches' locals (every `pretty_write!` expands to two `write!`s).
         // More importantly, `remap_zig_exception` below calls
         // `fetch_without_on_load_plugins` → the transpiler for source-line
@@ -5638,13 +5515,12 @@ impl VirtualMachine {
             return Ok(());
         }
 
-        // PORT NOTE: `Holder` is ~4 KB (32 ZigStackFrames + 6 source lines +
-        // ZigException). Zig stack-allocates it inside a small monomorphized
-        // function; here it sits next to the large runtime-dispatched body, so
+        // Note: `Holder` is ~4 KB (32 ZigStackFrames + 6 source lines +
+        // ZigException). It sits next to the large runtime-dispatched body, so
         // box it to keep the per-level recursion frame small enough for the
         // 16K-deep `bun-inspect.test.ts` Error chain on Windows debug.
         let mut exception_holder = Box::new(crate::zig_exception::Holder::init());
-        // PORT NOTE: reshaped for borrowck — `zig_exception()` returns a
+        // Note: reshaped for borrowck — `zig_exception()` returns a
         // `&mut` into the holder; we need to also borrow
         // `need_to_clear_parser_arena_on_deinit` disjointly. Route through a
         // raw pointer (the holder is heap-pinned for the call).
@@ -5666,7 +5542,7 @@ impl VirtualMachine {
             // SAFETY: see above.
             unsafe { &mut *exception },
             error_instance,
-            None, // PORT NOTE: spec passes `exception_list` but it was already
+            None, // Note: `exception_list` was already
             // consumed by `remap_zig_exception` above (only writer).
             formatter,
             writer,
@@ -5675,7 +5551,7 @@ impl VirtualMachine {
         );
 
         drop(source_code_slice);
-        // Spec VirtualMachine.zig:3304 `defer exception_holder.deinit(this)` —
+        // `exception_holder.deinit`
         // releases the WTFString refs (`name`/`message`/stack-frame
         // `function_name`/`source_url`/source-line bodies) populated by
         // `JSC__JSValue__toZigException`. Skipping this leaks ~1 KB/error and
@@ -5684,9 +5560,9 @@ impl VirtualMachine {
         result
     }
 
-    /// Spec VirtualMachine.zig:3288 `printErrorInstance` — shared body for both
-    /// `mode == .js` (`error_instance != .zero`) and `mode == .zig_exception`
-    /// (`error_instance == .zero`). Renders source-line previews, the
+    /// Shared error-printer body for both the JS-value
+    /// (`error_instance != .zero`) and pre-built-exception
+    /// (`error_instance == .zero`) modes. Renders source-line previews, the
     /// name/message line, owned-property dump, stack trace, and the `cause:` /
     /// AggregateError chain.
     #[allow(clippy::too_many_arguments)]
@@ -5706,7 +5582,7 @@ impl VirtualMachine {
 
         let prev_had_errors = self.had_errors;
         self.had_errors = true;
-        // PORT NOTE: Zig `defer this.had_errors = prev_had_errors;` — restore on
+        // Note: restore `had_errors` on
         // every exit (including `?` from `JSError` paths). `BackRef` holds the
         // VM without a live borrow; the write at drop routes through
         // `VirtualMachine::as_mut` (thread-local provenance).
@@ -5731,8 +5607,7 @@ impl VirtualMachine {
             }
         }
 
-        // PORT NOTE: Zig `defer if (allow_side_effects and Output.is_github_action)
-        // printGithubAnnotation(exception);`.
+        // Defer the GitHub-annotation print to scope exit.
         struct DeferGhAnnotation {
             run: bool,
             /// BACKREF — borrows the caller's stack-local `ZigException`, live
@@ -5752,8 +5627,8 @@ impl VirtualMachine {
             exception: bun_ptr::BackRef::new_mut(exception),
         };
 
-        // Runtime dispatch over `comptime allow_ansi_color` — `pretty_fmt!` is
-        // a `const`-param macro, so route through a local wrapper.
+        // `pretty_fmt!` takes a `const` color parameter, so route the runtime
+        // `allow_ansi_color` bool through a local wrapper.
         macro_rules! pretty_write {
             ($w:expr, $fmt:literal $(, $arg:expr)* $(,)?) => {
                 if allow_ansi_color {
@@ -5807,8 +5682,7 @@ impl VirtualMachine {
                 .strip_prefix(b"\n")
                 .unwrap_or(text)
                 .trim_ascii_end();
-            // Zig: trimRight(trim(text, "\n"), "\t ") — match by trimming
-            // newlines on both sides then trailing tab/space.
+            // Trim newlines on both sides, then trailing tab/space.
             let trimmed = bun_core::trim(text, b"\n");
             let trimmed = bun_core::trim_right(trimmed, b"\t ");
             let clamped = &trimmed[..trimmed.len().min(MAX_LINE_LENGTH)];
@@ -5849,11 +5723,10 @@ impl VirtualMachine {
         // `Formatter<'2>::format`, which requires an unbounded (VM-lifetime)
         // borrow. `global()` returns `&'static` so the borrow detaches.
         let global_ref = self.global();
-        // PORT NOTE: Zig keeps a borrowed `[]const u8` whose backing
-        // `bun.String` is `defer .deref()`-ed; hold the owning `bun_core::String`
+        // Note: hold the owning `bun_core::String`
         // alongside the slice so the latin1 view stays live for this fn.
         // `bun_core::String` is `Copy` (no `Drop`), so use a scopeguard to
-        // run `.deref()` on every exit path (matches Zig `defer`).
+        // run `.deref()` on every exit path.
         let mut code_string_guard = scopeguard::guard(None::<bun_core::String>, |s| {
             if let Some(s) = s {
                 s.deref();
@@ -6020,7 +5893,7 @@ impl VirtualMachine {
 
         // This is usually unsafe to do, but we are protecting them each time first.
         let mut errors_to_append: Vec<JSValue> = Vec::new();
-        // PORT NOTE: Zig `defer { for (..) |e| e.unprotect(); deinit(); }`.
+        // Each appended error is unprotected at scope exit.
         // `BackRef` (constructed from `&raw mut` via `NonNull` so the tag is
         // not popped by later `errors_to_append.push` reborrows) lets the drop
         // body read the Vec safely.
@@ -6087,7 +5960,7 @@ impl VirtualMachine {
                     formatter.max_depth = 1;
                     formatter.quote_strings = true;
                     formatter.disable_inspect_custom = true;
-                    // PORT NOTE: Zig `defer { restore }` — hand-rolled drop guard.
+                    // Hand-rolled drop guard restores the formatter state.
                     struct RestoreFmt<'a, 'f> {
                         f: &'a mut crate::console_object::Formatter<'f>,
                         d: bool,
@@ -6231,7 +6104,6 @@ impl VirtualMachine {
         Ok(())
     }
 
-    /// Spec VirtualMachine.zig:3679 `printErrorNameAndMessage`.
     fn print_error_name_and_message(
         name: bun_core::String,
         message: bun_core::String,
@@ -6326,7 +6198,7 @@ impl VirtualMachine {
         Ok(())
     }
 
-    /// Spec VirtualMachine.zig:3739 `printGithubAnnotation`.
+    /// Emits a GitHub Actions `::error` annotation for the exception when running in CI.
     #[cold]
     #[inline(never)]
     pub fn print_github_annotation(exception: &ZigException) {
@@ -6444,7 +6316,7 @@ impl VirtualMachine {
         let _ = writer.flush();
     }
 
-    /// Spec VirtualMachine.zig:3864 `resolveSourceMapping`.
+    /// Looks up the source-map mapping for `path` at `line:column`.
     pub fn resolve_source_mapping(
         &mut self,
         path: &[u8],
@@ -6459,8 +6331,7 @@ impl VirtualMachine {
             return Some(lookup);
         }
 
-        // Spec VirtualMachine.zig:3871-3889 — standalone-module-graph fallback.
-        // `graph.find(path).?.sourcemap.load()` reaches into
+        // Standalone-module-graph fallback: the sourcemap load reaches into
         // `bun_standalone_graph::{Graph,File,LazySourceMap}` (higher tier);
         // dispatch through [`RuntimeHooks::load_standalone_sourcemap`] per
         // §Dispatch (cold path — one-time decode then cached below).
@@ -6473,10 +6344,9 @@ impl VirtualMachine {
         // standalone graph's internal `INIT_LOCK`.
         let map = (hooks.load_standalone_sourcemap)(path)?;
 
-        // Spec: `map.ref(); this.source_mappings.putValue(path, Value.init(map))`.
         // The `Arc::clone` is the ref-bump; `into_raw` transfers that strong
         // ref into the table (reclaimed by `put_value`'s replace path /
-        // `SavedSourceMap` teardown). `catch bun.outOfMemory()` → `handle_oom`.
+        // `SavedSourceMap` teardown).
         bun_core::handle_oom(self.source_mappings.put_value(
             path,
             crate::saved_source_map::Value::init(std::sync::Arc::into_raw(std::sync::Arc::clone(
@@ -6494,13 +6364,13 @@ impl VirtualMachine {
         })
     }
 
-    /// Spec VirtualMachine.zig:3989 `initIPCInstance`.
+    /// Records the inherited IPC fd/mode in the waiting state until JS attaches a listener.
     pub fn init_ipc_instance(&mut self, fd: bun_sys::Fd, mode: crate::ipc::Mode) {
         bun_core::scoped_log!(IPC, "initIPCInstance {:?}", fd);
         self.ipc = Some(IPCInstanceUnion::Waiting { fd, mode });
     }
 
-    /// Spec VirtualMachine.zig:3994 `getIPCInstance`.
+    /// Returns the initialized IPC instance, lazily creating it from the waiting fd/mode.
     pub fn get_ipc_instance(&mut self) -> Option<*mut IPCInstance> {
         let (fd, mode) = match self.ipc.as_ref()? {
             IPCInstanceUnion::Initialized(inst) => return Some(*inst),
@@ -6511,7 +6381,7 @@ impl VirtualMachine {
 
         self.event_loop_mut().ensure_waker();
 
-        // PORT NOTE: reshaped for borrowck — `rare_data()` borrows `self` and
+        // Note: reshaped for borrowck — `rare_data()` borrows `self` and
         // `spawn_ipc_group` then needs `&mut VirtualMachine`. Split via raw
         // pointers (disjoint fields) per the existing `Bun__RareData__*`
         // accessors in virtual_machine_exports.rs.
@@ -6528,7 +6398,7 @@ impl VirtualMachine {
             };
 
             // Box the instance first so `data.owner` can name its final
-            // address (Zig wrote `.data = undefined` then re-init in place).
+            // address.
             let instance = IPCInstance::new(IPCInstance {
                 global_this: self.global,
                 group,
@@ -6660,11 +6530,11 @@ fn wrap_unhandled_rejection_error_for_uncaught_exception(
     if like {
         return reason;
     }
-    // Zig (VirtualMachine.zig:581-585) opens an explicit `TopExceptionScope`
-    // around the call and clears any exception via the scope; the C++ side has a
-    // `DECLARE_THROW_SCOPE`, so under `BUN_JSC_validateExceptionChecks=1` the
-    // post-call `clear_exception()` (whose own scope ctor asserts) is wrong
-    // without a Rust-side scope live across the call.
+    // Open an explicit `TopExceptionScope`
+    // around the call and clear any exception via the scope; the C++ side has a
+    // `DECLARE_THROW_SCOPE`, so under `BUN_JSC_validateExceptionChecks=1` a
+    // post-call `clear_exception()` (whose own scope ctor asserts) would be
+    // wrong without a Rust-side scope live across the call.
     let reason_str = {
         crate::top_scope!(scope, global_object);
         let r = Bun__noSideEffectsToString(global_object.vm(), global_object, reason);
@@ -6695,8 +6565,6 @@ fn wrap_unhandled_rejection_error_for_uncaught_exception(
         .to_js()
 }
 
-/// Spec PluginRunner.zig:121 `onResolveJSC`.
-///
 /// LAYERING: moved DOWN from `bun_bundler_jsc::PluginRunner` so
 /// `resolve_maybe_needs_trailing_slash` can consult `Bun.plugin()` resolvers
 /// without a `bun_jsc → bun_bundler_jsc` cycle. The body only touches
@@ -6791,7 +6659,7 @@ pub fn plugin_runner_on_resolve_jsc(
         }
         break 'brk bun_core::String::static_(b"file");
     };
-    // Spec PluginRunner.zig:212 `defer user_namespace.deref()` — `bun_core::String`
+    // `bun_core::String`
     // is `Copy` (no `Drop`), so guard the WTF refcount across the remaining
     // early-return paths.
     let user_namespace = scopeguard::guard(user_namespace, |s| s.deref());
@@ -6821,5 +6689,3 @@ pub fn plugin_runner_on_resolve_jsc(
     };
     Ok(Some(ErrorableString::ok(out)))
 }
-
-// ported from: src/jsc/VirtualMachine.zig
diff --git a/src/jsc/WTF.rs b/src/jsc/WTF.rs
index 4e586823dfb..0efaf79840b 100644
--- a/src/jsc/WTF.rs
+++ b/src/jsc/WTF.rs
@@ -1,25 +1,16 @@
-// PORT NOTE: Zig wraps everything in `pub const WTF = struct { ... }` as a
-// namespace. In Rust the file itself is the module, so items live at module
-// level. Callers use `bun_jsc::wtf::foo()`.
-//
-// PORT NOTE: `jsc.markBinding(@src())` calls dropped — debug-only binding
-// presence marker with no Rust equivalent.
-
-// without a T6 dep. Re-exported here to keep the original Zig namespace shape.
+// Canonical lives in `bun_alloc::wtf` so it is callable without a T6 dep.
 pub use bun_alloc::wtf::release_fast_malloc_free_memory_for_this_thread;
 
 // `WTF.parseDouble` canonical lives in bun_core::fmt (tier-0); re-exported here
-// to keep the Zig namespace shape (`bun_jsc::wtf::parse_double`).
+// as `bun_jsc::wtf::parse_double`.
 pub use bun_core::fmt::{InvalidCharacter, parse_double};
 pub type ParseDoubleError = bun_core::fmt::InvalidCharacter;
 
 // Canonical lives in bun_core (tier-0) so install/ can call it without bun_jsc.
 pub use bun_core::wtf::{InvalidDate, parse_es5_date, parse_es5_date_raw};
 
-// it without a bun_jsc dep. Re-exported here to keep the Zig namespace shape
-// (src/jsc/WTF.zig:52).
+// Canonical lives in `bun_http_types` so http code can call it without a
+// bun_jsc dep; re-exported here.
 pub use bun_http_types::ETag::wtf::write_http_date;
 
 pub use crate::string_builder::StringBuilder;
-
-// ported from: src/jsc/WTF.zig
diff --git a/src/jsc/Weak.rs b/src/jsc/Weak.rs
index 14e8ffb8f5a..7cd505ec7e2 100644
--- a/src/jsc/Weak.rs
+++ b/src/jsc/Weak.rs
@@ -58,8 +58,6 @@ impl WeakImpl {
     }
 }
 
-// TODO(port): move to jsc_sys
-//
 // `WeakImpl` is an opaque `UnsafeCell`-backed ZST handle (`&WeakImpl` is
 // ABI-identical to non-null `*const WeakImpl`; C++ slot mutation is interior).
 // `new` is `safe fn`: `&JSGlobalObject` is the non-null handle proof, and `ctx`
@@ -103,8 +101,6 @@ impl<T> Weak<T> {
         let Some(function) = self.try_swap() else {
             return JSValue::ZERO;
         };
-        // PORT NOTE: Zig source (Weak.zig:50) calls `function.call(global, args)`
-        // which predates the `thisValue` param on JSValue.call; pass `.undefined`.
         function
             .call(&self.global_this.unwrap(), JSValue::UNDEFINED, args)
             .unwrap_or(JSValue::ZERO)
@@ -193,5 +189,3 @@ impl<T> Drop for Weak<T> {
         unsafe { WeakImpl::destroy(r#ref) };
     }
 }
-
-// ported from: src/jsc/Weak.zig
diff --git a/src/jsc/WorkTask.rs b/src/jsc/WorkTask.rs
index 9d3541f7ed3..aa90ad9373a 100644
--- a/src/jsc/WorkTask.rs
+++ b/src/jsc/WorkTask.rs
@@ -22,13 +22,11 @@ use bun_ptr::BackRef;
 /// - Context receives a reference to the WorkTask itself in the `run` method
 pub trait WorkTaskContext: Sized {
     /// Tag this `WorkTask<Self>` carries when enqueued back onto the JS event
-    /// loop's concurrent queue (`task_tag::*`). Mirrors Zig's per-instantiation
-    /// `TaggedPointerUnion` membership (e.g. `GetAddrInfoRequestTask`).
+    /// loop's concurrent queue (`task_tag::*`).
     const TASK_TAG: TaskTag;
 
     /// Perform the work on the thread pool. `this`/`task` are raw pointers
-    /// because the context is heap-allocated, crosses threads, and is mutated
-    /// — the Zig signature is `fn run(this: *Context, task: *Task) void`.
+    /// because the context is heap-allocated, crosses threads, and is mutated.
     fn run(this: *mut Self, task: *mut WorkTask<Self>);
     fn then(this: *mut Self, global_this: &JSGlobalObject) -> Result<(), crate::JsTerminated>;
 }
@@ -45,7 +43,6 @@ pub struct WorkTask<Context: WorkTaskContext> {
     pub async_task_tracker: AsyncTaskTracker,
 
     // This is a poll because we want it to enter the uSockets loop
-    // PORT NOTE: `ref` is a Rust keyword; field renamed to `ref_`.
     pub ref_: KeepAlive,
 }
 
@@ -79,15 +76,15 @@ impl<Context: WorkTaskContext> WorkTask<Context> {
         });
         this.ref_.ref_(Async::js_vm_ctx());
 
-        // PORT NOTE: intrusive `task` field is recovered via container_of in
+        // The intrusive `task` field is recovered via container_of in
         // run_from_thread_pool, so this must live at a stable heap address as a
         // raw pointer. Paired with `heap::take` in `destroy`.
         bun_core::heap::into_raw(this)
     }
 
-    // PORT NOTE: not `impl Drop` — `ref_.unref` is also called from `run_from_js`,
-    // and `Self` is held as a raw pointer (intrusive task). Explicit destroy matches
-    // the Zig `bun.destroy(this)` shape.
+    // Not `impl Drop` — `ref_.unref` is also called from `run_from_js`,
+    // and `Self` is held as a raw pointer (intrusive task), so destruction
+    // is explicit.
     pub unsafe fn destroy(this: *mut Self) {
         // SAFETY: `this` was produced by heap::alloc in create_on_js_thread and
         // has not been freed.
@@ -143,5 +140,3 @@ impl<Context: WorkTaskContext> WorkTask<Context> {
         event_loop.enqueue_task_concurrent(task);
     }
 }
-
-// ported from: src/jsc/WorkTask.zig
diff --git a/src/jsc/ZigErrorType.rs b/src/jsc/ZigErrorType.rs
index 5b5af8d38ff..f184dcffa34 100644
--- a/src/jsc/ZigErrorType.rs
+++ b/src/jsc/ZigErrorType.rs
@@ -5,9 +5,7 @@ use crate::error_code::ErrorCode;
 #[derive(Copy, Clone)]
 pub struct ZigErrorType {
     pub code: ErrorCode,
-    // PORT NOTE: bare JSValue field is OK here — this is a #[repr(C)] FFI payload
+    // Bare JSValue field is OK here — this is a #[repr(C)] FFI payload
     // passed by value across the C++ boundary, not a heap-allocated Rust struct.
     pub value: JSValue,
 }
-
-// ported from: src/jsc/ZigErrorType.zig
diff --git a/src/jsc/ZigException.rs b/src/jsc/ZigException.rs
index a0503184e4d..123cdac745e 100644
--- a/src/jsc/ZigException.rs
+++ b/src/jsc/ZigException.rs
@@ -54,7 +54,7 @@ impl ZigException {
         ZigException__collectSourceLines(value, global, self);
     }
 
-    // PORT NOTE: kept as explicit `deinit` (not `Drop`) — this is a #[repr(C)] FFI
+    // Kept as explicit `deinit` (not `Drop`) — this is a #[repr(C)] FFI
     // payload whose lifetime is gated by `Holder.loaded`; C++ constructs/populates it.
     pub fn deinit(&mut self) {
         self.syscall.deref();
@@ -79,10 +79,10 @@ impl ZigException {
         }
     }
 
-    // PORT NOTE: `ZigException__fromException` is declared in headers.h but
-    // has no C++ body (bindings.cpp dropped it; the only producer is
-    // `JSC__JSValue__toZigException` which writes through an out-param). The
-    // Zig `fromException` re-export is dead code; do not port it.
+    // `ZigException__fromException` is declared in headers.h but has no C++
+    // body (bindings.cpp dropped it; the only producer is
+    // `JSC__JSValue__toZigException` which writes through an out-param), so
+    // there is intentionally no `from_exception` here.
 
     pub fn add_to_error_list(
         &mut self,
@@ -95,20 +95,17 @@ impl ZigException {
 
         let name = name_slice.slice();
         let message = message_slice.slice();
-        // PORT NOTE: `defer name_slice.deinit()` / `defer message_slice.deinit()` —
-        // `ZigStringSlice` drops at scope exit.
 
         let mut is_empty = true;
         let mut api_exception = api::JsException {
-            // PORT NOTE: `@intFromEnum` — JSRuntimeType/JSErrorCode are
-            // transparent newtypes over u16/u8 (non-exhaustive Zig enums).
+            // JSRuntimeType/JSErrorCode are transparent newtypes over u16/u8
+            // (non-exhaustive enums).
             runtime_type: self.runtime_type.0,
             code: u16::from(self.r#type.0),
             ..Default::default()
         };
 
         if !name.is_empty() {
-            // PORT NOTE: `error_list.allocator.dupe(u8, _name)` → Box<[u8]> (global mimalloc).
             api_exception.name = Box::<[u8]>::from(name);
             is_empty = false;
         }
@@ -137,8 +134,8 @@ pub struct Holder {
     pub source_lines: [String; Self::SOURCE_LINES_COUNT],
     pub frames: [ZigStackFrame; Self::FRAME_COUNT],
     pub loaded: bool,
-    // PORT NOTE: Zig had `= undefined` (never read until `loaded` flips and
-    // `zig_exception()` writes it). Use MaybeUninit and gate access on `loaded`.
+    // Never read until `loaded` flips and `zig_exception()` writes it;
+    // all access must be gated on `loaded`.
     pub zig_exception: MaybeUninit<ZigException>,
     pub need_to_clear_parser_arena_on_deinit: bool,
 }
@@ -147,12 +144,8 @@ impl Holder {
     const FRAME_COUNT: usize = 32;
     pub const SOURCE_LINES_COUNT: usize = 6;
 
-    // PORT NOTE: Zig had `pub const Zero: Holder`; Rust const requires every
-    // initializer to be const-evaluable. Using a fn instead.
     pub fn zero() -> Self {
         Self {
-            // PORT NOTE: `[ZigStackFrame::ZERO; N]` would require `Copy`;
-            // mirror the Zig `@memset` via from_fn.
             frames: core::array::from_fn(|_| ZigStackFrame::ZERO),
             source_line_numbers: [-1; Self::SOURCE_LINES_COUNT],
             source_lines: core::array::from_fn(|_| String::EMPTY),
@@ -166,11 +159,11 @@ impl Holder {
         Self::zero()
     }
 
-    // PORT NOTE: not just `Drop` — takes `vm` parameter for `reset_arena`. Zig
-    // callers all `defer holder.deinit(vm)`; Rust callers should still call this
-    // explicitly at the tail (it does the arena reset which `Drop` cannot), but
-    // the string-ref release half is also covered by `Drop` below so an early
-    // `?`/return between population and the tail call won't leak WTF string refs.
+    // Not just `Drop` — takes the `vm` parameter for `reset_arena`. Callers
+    // should call this explicitly at the tail (it does the arena reset which
+    // `Drop` cannot), but the string-ref release half is also covered by
+    // `Drop` below so an early `?`/return between population and the tail
+    // call won't leak WTF string refs.
     pub fn deinit(&mut self, vm: &mut VirtualMachine) {
         if self.loaded {
             // SAFETY: `loaded == true` ⇔ `zig_exception()` has written this slot.
@@ -179,9 +172,6 @@ impl Holder {
             self.loaded = false;
         }
         if self.need_to_clear_parser_arena_on_deinit {
-            // PORT NOTE: reshaped for borrowck — Zig `vm.module_loader.resetArena(vm)`
-            // would borrow `vm` twice; the Rust port made `reset_arena` an
-            // associated fn on `ModuleLoader` taking only `&mut VirtualMachine`.
             ModuleLoader::reset_arena(vm);
         }
     }
@@ -189,8 +179,6 @@ impl Holder {
     pub fn zig_exception(&mut self) -> &mut ZigException {
         if !self.loaded {
             self.zig_exception.write(ZigException {
-                // Zig: `@as(JSErrorCode, @enumFromInt(255))` — non-exhaustive
-                // enum(u8) → transparent newtype, so just construct directly.
                 r#type: JSErrorCode(255),
                 runtime_type: JSRuntimeType::NOTHING,
                 name: String::EMPTY,
@@ -224,10 +212,10 @@ impl Holder {
 }
 
 impl Drop for Holder {
-    // PORT NOTE: restores the string-ref-release half of Zig's
-    // `defer holder.deinit(vm)`. The explicit `deinit(&mut self, vm)` clears
-    // `loaded` after running, so this is a no-op on the happy path; it only
-    // fires when an early-return/`?`/panic skips the tail `deinit` call.
+    // Covers the string-ref-release half of cleanup. The explicit
+    // `deinit(&mut self, vm)` clears `loaded` after running, so this is a
+    // no-op on the happy path; it only fires when an early-return/`?`/panic
+    // skips the tail `deinit` call.
     fn drop(&mut self) {
         if self.loaded {
             // SAFETY: `loaded == true` ⇔ `zig_exception()` has written this slot.
@@ -236,5 +224,3 @@ impl Drop for Holder {
         }
     }
 }
-
-// ported from: src/jsc/ZigException.zig
diff --git a/src/jsc/ZigStackFrame.rs b/src/jsc/ZigStackFrame.rs
index ccb541301b3..4f51600a947 100644
--- a/src/jsc/ZigStackFrame.rs
+++ b/src/jsc/ZigStackFrame.rs
@@ -36,7 +36,7 @@ impl ZigStackFrame {
     /// `ZigException::deinit()` → `frame.deinit()` to release the strings, but
     /// the array elements are then later dropped by Rust when `Holder` itself
     /// drops. A `Drop` impl would deref the same `WTF::StringImpl` a second
-    /// time (UAF). Match the Zig spec: explicit `deinit` only.
+    /// time (UAF). Explicit `deinit` only.
     pub fn deinit(&mut self) {
         self.function_name.deref();
         self.source_url.deref();
@@ -47,15 +47,9 @@ impl ZigStackFrame {
         root_path: &[u8],
         origin: Option<&ZigURL<'_>>,
     ) -> Result<api::StackFrame, bun_alloc::AllocError> {
-        // Zig was `!api.StackFrame` with alloc-only `try` sites; allocator param dropped.
-        // Zig used `comptime std.mem.zeroes` (zero-valued slices/enums) — `Default` is the
-        // semantic equivalent here since `Box<[u8]>` fields are NonNull and not zero-safe.
         let mut frame: api::StackFrame = api::StackFrame::default();
         if !self.function_name.is_empty() {
             let slicer = self.function_name.to_utf8();
-            // Zig: `(try slicer.cloneIfBorrowed(allocator)).slice()` — clone-if-borrowed then leak
-            // the slice into `frame.function_name`. `Box::from(slice)` always copies, which is the
-            // semantic equivalent now that the field owns its bytes (drops the Zig leak).
             // TODO: Memory leak? `frame.function_name` may have just been allocated by this
             // function, but it doesn't seem like we ever free it. Changing to `toUTF8Owned` would
             // make the ownership clearer, but would also make the memory leak worse without an
@@ -76,7 +70,7 @@ impl ZigStackFrame {
 
         frame.position = self.position;
         // api::StackFrameScope is a #[repr(transparent)] u8 newtype with the same
-        // discriminants as ZigStackFrameCode (schema.zig:373 / ZigStackFrameCode.zig).
+        // discriminants as ZigStackFrameCode.
         frame.scope = api::StackFrameScope(self.code_type.0);
 
         Ok(frame)
@@ -93,8 +87,6 @@ impl ZigStackFrame {
     };
 
     pub fn name_formatter(&self, enable_color: bool) -> NameFormatter {
-        // PERF(port): was comptime monomorphization (`comptime enable_color: bool`) — but the
-        // formatter stores it as a runtime field anyway, so no monomorphization was happening.
         NameFormatter {
             function_name: self.function_name,
             code_type: self.code_type,
@@ -110,8 +102,6 @@ impl ZigStackFrame {
         exclude_line_column: bool,
         enable_color: bool,
     ) -> SourceURLFormatter<'a> {
-        // PERF(port): was comptime monomorphization (`comptime enable_color: bool`) — stored as
-        // runtime field.
         SourceURLFormatter {
             source_url: self.source_url,
             exclude_line_column,
@@ -322,5 +312,3 @@ impl fmt::Display for NameFormatter {
         Ok(())
     }
 }
-
-// ported from: src/jsc/ZigStackFrame.zig
diff --git a/src/jsc/ZigStackFrameCode.rs b/src/jsc/ZigStackFrameCode.rs
index 545cef86c33..de39dee88b9 100644
--- a/src/jsc/ZigStackFrameCode.rs
+++ b/src/jsc/ZigStackFrameCode.rs
@@ -1,8 +1,7 @@
-// PORT NOTE: Zig source is `enum(u8) { ..., _ }` (non-exhaustive — any u8 is a
-// valid bit pattern). A `#[repr(u8)] enum` in Rust would be UB for values >6
-// arriving over FFI, so this is ported as a transparent newtype with associated
-// consts. The `match` arms below mirror the Zig `switch` exactly, including the
-// `else` fallthrough for unknown values.
+// This is logically a non-exhaustive enum(u8): any u8 is a valid bit pattern
+// over FFI. A `#[repr(u8)] enum` in Rust would be UB for values >6 arriving
+// from C++, so this is a transparent newtype with associated consts; the
+// `match` arms below must keep a fallthrough for unknown values.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct ZigStackFrameCode(pub u8);
@@ -22,8 +21,7 @@ impl ZigStackFrameCode {
     /// 👷
     pub const CONSTRUCTOR: Self = Self(6);
 
-    // PORT NOTE: Zig returns `u21` (Unicode code point width). Rust has no u21;
-    // u32 is the narrowest native type that fits.
+    /// Returns a Unicode code point.
     pub fn emoji(self) -> u32 {
         match self {
             Self::EVAL => 0x1F3C3,
@@ -49,5 +47,3 @@ impl ZigStackFrameCode {
         }
     }
 }
-
-// ported from: src/jsc/ZigStackFrameCode.zig
diff --git a/src/jsc/ZigStackFramePosition.rs b/src/jsc/ZigStackFramePosition.rs
index 88145673516..2c415386e18 100644
--- a/src/jsc/ZigStackFramePosition.rs
+++ b/src/jsc/ZigStackFramePosition.rs
@@ -20,12 +20,9 @@ impl ZigStackFramePosition {
     };
 
     pub fn is_invalid(&self) -> bool {
-        // Zig: std.mem.eql(u8, std.mem.asBytes(this), std.mem.asBytes(&invalid))
-        // #[repr(C)] + derived PartialEq on POD fields is equivalent.
         *self == Self::INVALID
     }
 
-    // TODO(port): narrow error set
     pub fn decode<R>(reader: &mut R) -> Result<Self, bun_core::Error>
     where
         R: ?Sized + bun_analytics::Reader,
@@ -33,9 +30,9 @@ impl ZigStackFramePosition {
         Ok(Self {
             line: Ordinal::from_zero_based(reader.read_value::<i32>()?),
             column: Ordinal::from_zero_based(reader.read_value::<i32>()?),
-            // TODO(port): Zig's `decode` omits `line_start_byte` in the struct literal
-            // (extern-struct field left at zero/default). Confirm intended value.
-            line_start_byte: 0,
+            // `encode` never writes this field, so a decoded frame has no
+            // line-start-byte information: -1 means "not present".
+            line_start_byte: -1,
         })
     }
 
@@ -44,5 +41,3 @@ impl ZigStackFramePosition {
         writer.write_int(self.column.zero_based());
     }
 }
-
-// ported from: src/jsc/ZigStackFramePosition.zig
diff --git a/src/jsc/ZigStackTrace.rs b/src/jsc/ZigStackTrace.rs
index fe7012e3353..de55243069b 100644
--- a/src/jsc/ZigStackTrace.rs
+++ b/src/jsc/ZigStackTrace.rs
@@ -24,8 +24,8 @@ pub struct ZigStackTrace {
     /// Non-null if `source_lines_*` points into data owned by a JSC::SourceProvider.
     /// If so, then .deref must be called on it to release the memory.
     ///
-    /// `Option<NonNull<_>>` niche-optimizes to a single thin pointer, matching
-    /// the Zig `?*SourceProvider` ABI exactly.
+    /// `Option<NonNull<_>>` niche-optimizes to a single thin pointer, so the
+    /// FFI layout is exactly one nullable pointer.
     pub referenced_source_provider: Option<NonNull<SourceProvider>>,
 }
 
@@ -50,8 +50,6 @@ impl ZigStackTrace {
         root_path: &[u8],
         origin: Option<&ZigURL<'_>>,
     ) -> Result<api::StackTrace, bun_alloc::AllocError> {
-        // Zig: `comptime std.mem.zeroes(api.StackTrace)` — `Default` is the semantic
-        // equivalent (`Vec` fields are NonNull and not zero-safe).
         let mut stack_trace = api::StackTrace::default();
         {
             let mut source_lines_iter = self.source_line_iterator();
@@ -61,11 +59,9 @@ impl ZigStackTrace {
             if source_line_len > 0 {
                 let n_lines = usize::try_from((source_lines_iter.i + 1).max(0)).expect("int cast");
                 let mut source_lines: Vec<api::SourceLine> = Vec::with_capacity(n_lines);
-                // PORT NOTE: Zig packed all line texts into a single contiguous
-                // `source_line_buf` and stored sub-slices in each `SourceLine`.
-                // The Rust `api::SourceLine.text` is `Box<[u8]>` (owns its bytes),
-                // so each line gets its own allocation instead.
-                // PERF(port): one alloc per line vs one shared buffer — profile if hot.
+                // `api::SourceLine.text` is `Box<[u8]>` (owns its bytes), so each
+                // line gets its own allocation rather than sub-slices of one shared
+                // buffer. One alloc per line — profile if this ever shows up hot.
                 source_lines_iter = self.source_line_iterator();
                 while let Some(source) = source_lines_iter.next() {
                     let text = source.text.slice();
@@ -73,7 +69,7 @@ impl ZigStackTrace {
                         text: Box::<[u8]>::from(text),
                         line: source.line,
                     });
-                    // `defer source.text.deinit()` → handled by Drop on ZigStringSlice at end of scope.
+                    // `source.text` is released by `ZigStringSlice`'s Drop at end of scope.
                 }
                 stack_trace.source_lines = source_lines;
             }
@@ -95,7 +91,7 @@ impl ZigStackTrace {
 
     pub fn frames(&self) -> &[ZigStackFrame] {
         // SAFETY: frames_ptr points to a caller-owned buffer of at least frames_len elements
-        // (populated by C++ via FFI; see ZigException.zig:111).
+        // (populated by C++ via FFI).
         unsafe { bun_core::ffi::slice(self.frames_ptr, self.frames_len as usize) }
     }
 
@@ -108,8 +104,8 @@ impl ZigStackTrace {
     #[inline]
     pub fn source_lines_mut(&mut self) -> &mut [BunString] {
         // SAFETY: `source_lines_ptr` points to a caller-owned buffer of at least
-        // `source_lines_len` initialized elements (populated by C++ via FFI;
-        // see ZigException.zig:108). The borrow is tied to `&mut self`.
+        // `source_lines_len` initialized elements (populated by C++ via FFI).
+        // The borrow is tied to `&mut self`.
         unsafe { bun_core::ffi::slice_mut(self.source_lines_ptr, self.source_lines_len as usize) }
     }
 
@@ -117,7 +113,7 @@ impl ZigStackTrace {
     #[inline]
     pub fn source_line_numbers(&self) -> &[i32] {
         // SAFETY: `source_lines_numbers` points to a caller-owned buffer of at
-        // least `source_lines_len` initialized elements (see ZigException.zig:108).
+        // least `source_lines_len` initialized elements (populated by C++ via FFI).
         unsafe { bun_core::ffi::slice(self.source_lines_numbers, self.source_lines_len as usize) }
     }
 
@@ -187,5 +183,3 @@ impl<'a> SourceLineIterator<'a> {
         Some(result)
     }
 }
-
-// ported from: src/jsc/ZigStackTrace.zig
diff --git a/src/jsc/ZigString.rs b/src/jsc/ZigString.rs
index 00cfcc110f0..93dda8128b1 100644
--- a/src/jsc/ZigString.rs
+++ b/src/jsc/ZigString.rs
@@ -32,8 +32,7 @@ pub use crate::ZigStringJsc;
 
 // `OpaqueJSString` / `JSStringRef` retained for type-level compatibility with
 // the JSC C API surface; the `to_js_string_ref` constructor wrappers were dead
-// code (no C++ body for `JSStringCreateStatic` in Bun's link image — Zig's
-// `toJSStringRef` is unreachable behind `@hasDecl(bun, "bindgen")`).
+// code (no C++ body for `JSStringCreateStatic` in Bun's link image).
 bun_opaque::opaque_ffi! { pub struct OpaqueJSString; }
 
 unsafe extern "C" {
@@ -44,8 +43,8 @@ unsafe extern "C" {
     ) -> JSValue;
 }
 
-/// `ZigString.static(comptime s)` — borrow a static ASCII/Latin-1 literal.
-/// Spec (`ZigString.static`, ZigString.zig:499-506) constructs the string with
+/// `ZigString::static_` — borrow a static ASCII/Latin-1 literal.
+/// Constructs the string with
 /// the raw literal pointer and NO encoding tag. Callers who need UTF-8
 /// semantics must use `init_utf8` / `from_utf8` explicitly.
 #[inline]
@@ -53,7 +52,7 @@ pub(crate) fn static_(s: &'static [u8]) -> ZigString {
     ZigString::init(s)
 }
 
-/// `ZigString.toExternalU16` (ZigString.zig:571) — hand a globally-allocated
+/// Hand a globally-allocated
 /// UTF-16 buffer to JSC as an external string. Ownership of `ptr[0..len]`
 /// transfers to JSC on success; on the too-long path the buffer is freed
 /// here, a `STRING_TOO_LONG` error is thrown, and `.zero` is returned.
@@ -66,14 +65,13 @@ pub unsafe fn to_external_u16(ptr: *const u16, len: usize, global: &JSGlobalObje
     if len > BunString::max_length() {
         // SAFETY: caller contract — `ptr` came from the default (global) allocator.
         unsafe { bun_alloc::default_alloc::free(ptr.cast_mut().cast::<core::ffi::c_void>()) };
-        // TODO(port): Zig used `global.ERR(.STRING_TOO_LONG, msg).throw()`;
-        // the codegen'd `ErrorCode::ERR_STRING_TOO_LONG` builder hasn't landed
-        // yet, so throw a plain RangeError with the same message. Propagation
-        // is swallowed (matches Zig's `catch {}`).
-        let err = global.create_range_error_instance(format_args!(
-            "Cannot create a string longer than 2^32-1 characters"
-        ));
-        let _ = global.throw_value(err);
+        // Propagation of the throw is intentionally swallowed.
+        let _ = global
+            .err(
+                crate::ErrorCode::STRING_TOO_LONG,
+                format_args!("Cannot create a string longer than 2^32-1 characters"),
+            )
+            .throw();
         return JSValue::ZERO;
     }
     // SAFETY: ptr/len describe a globally-allocated UTF-16 buffer; ownership
@@ -92,8 +90,10 @@ pub(crate) unsafe extern "C" fn ZigString__free(
     let Some(allocator_) = core::ptr::NonNull::new(allocator_) else {
         return;
     };
-    // TODO(port): Zig dereferenced *std.mem.Allocator from opaque ptr — Rust uses global mimalloc;
-    // verify no callers pass a non-default allocator here.
+    // The buffer is always owned by the global allocator. Verified:
+    // no C++ call site passes a non-default allocator — the only reference to
+    // this symbol outside this file is the declaration in
+    // headers-handwritten.h (helpers.h frees via `ZigString__freeGlobal`).
     let _ = allocator_;
     // SAFETY: raw/len describe a valid slice allocated by the caller-provided allocator.
     let s = unsafe { bun_core::ffi::slice(raw, len) };
@@ -133,5 +133,3 @@ pub(crate) unsafe extern "C" fn ZigString__freeGlobal(ptr: *const u8, len: usize
 // `super::Slice`). Kept for FFI surfaces that need the raw `{allocator, ptr,
 // len}` layout; the enum form is preferred for pure-Rust callers.
 // ──────────────────────────────────────────────────────────────────────────
-
-// ported from: src/jsc/ZigString.zig
diff --git a/src/jsc/any_task_job.rs b/src/jsc/any_task_job.rs
index 7c881dd51b9..870232d0fae 100644
--- a/src/jsc/any_task_job.rs
+++ b/src/jsc/any_task_job.rs
@@ -1,7 +1,5 @@
 //! `AnyTaskJob<C>` — the canonical "{WorkPool offload → AnyTask re-queue →
-//! JS-thread completion}" boilerplate that was open-coded at five sites in
-//! Zig (`SecretsJob`, `ExternCryptoJob`, `CryptoJob<Ctx>`, `PBKDF2::Job`,
-//! `ZstdJob`). Each call site supplies only a `Ctx` impl of
+//! JS-thread completion}" boilerplate. Each call site supplies only a `Ctx` impl of
 //! [`AnyTaskJobCtx`]; the heap allocation, intrusive `WorkPoolTask`/`AnyTask`
 //! wiring, `KeepAlive` ref/unref, and `is_shutting_down` guard live here.
 //!
@@ -88,9 +86,7 @@ impl<C: AnyTaskJobCtx> AnyTaskJob<C> {
             ctx,
         }));
         // SAFETY: `job` was just allocated and is exclusively owned here.
-        // Zig: `AnyTask.New(@This(), &runFromJS).init(job)`. Rust's `New<T>`
-        // cannot carry a comptime callback, so build the erased AnyTask
-        // directly with a non-capturing shim.
+        // Build the erased AnyTask directly with a non-capturing shim.
         unsafe {
             (*job).any_task = AnyTask {
                 ctx: NonNull::new(job.cast::<c_void>()),
@@ -145,9 +141,6 @@ impl<C: AnyTaskJobCtx> AnyTaskJob<C> {
         let job = unsafe { &mut *Self::from_task_ptr(task) };
         let vm = job.vm;
         job.ctx.run(vm.global);
-        // Mirror Zig `defer vm.enqueueTaskConcurrent(...)` — there is no early
-        // return between the body and the enqueue, so the `defer` reduces to a
-        // trailing call.
         // `ConcurrentTask::create` heap-allocates a fresh task; the queue takes
         // ownership of it.
         vm.event_loop_shared()
diff --git a/src/jsc/array_buffer.rs b/src/jsc/array_buffer.rs
index 0541d38e7de..65b8e8a7c5d 100644
--- a/src/jsc/array_buffer.rs
+++ b/src/jsc/array_buffer.rs
@@ -44,10 +44,7 @@ impl Default for ArrayBuffer {
     }
 }
 
-// TODO(port): move to <jsc>_sys
-//
-// PORT NOTE (aliasing): Zig declares these with `*jsc.JSGlobalObject` (mutable
-// pointer), but `JSGlobalObject` is an opaque ZST handle on the Rust side — the
+// Aliasing: `JSGlobalObject` is an opaque ZST handle on the Rust side — the
 // `&JSGlobalObject` reference covers zero bytes, and all mutation happens inside
 // C++ on memory Rust never observes. Declaring the FFI parameter as
 // `*const JSGlobalObject` (ABI-identical) lets `&JSGlobalObject` coerce directly
@@ -258,7 +255,7 @@ impl ArrayBuffer {
             return Ok(result);
         }
 
-        // bun_sys::mmap takes raw i32 prot/flags (mirrors Zig std.posix.PROT / .{ .TYPE = .SHARED }).
+        // bun_sys::mmap takes raw i32 prot/flags.
         // Windows impl ignores these and returns ENOTSUP.
         #[cfg(unix)]
         let (prot, map_flags) = (libc::PROT_READ | libc::PROT_WRITE, libc::MAP_SHARED);
@@ -282,7 +279,7 @@ impl ArrayBuffer {
     }
 
     pub const EMPTY: ArrayBuffer = ArrayBuffer {
-        ptr: core::ptr::NonNull::<u8>::dangling().as_ptr(), // Zig: &.{} (non-null empty)
+        ptr: core::ptr::NonNull::<u8>::dangling().as_ptr(), // non-null empty
         len: 0,
         byte_len: 0,
         value: JSValue::ZERO,
@@ -295,7 +292,8 @@ impl ArrayBuffer {
 
     #[inline]
     pub fn stream(self) -> ArrayBufferStream<'static> {
-        // TODO(port): lifetime — Zig returns a stream over self.slice() (raw ptr-backed).
+        // Lifetime: the stream is over self.slice() (raw ptr-backed); the
+        // caller must keep the backing JSValue alive for the stream's lifetime.
         // Spec routes through `slice()` which yields `&.{}` for detached buffers; mirror
         // that here to avoid passing a null ptr to `from_raw_parts_mut` (UB even at len 0).
         if self.is_detached() {
@@ -307,10 +305,9 @@ impl ArrayBuffer {
         std::io::Cursor::new(slice)
     }
 
-    // PORT NOTE: Zig took `comptime kind: JSType`. Restored via
-    // `#![feature(adt_const_params)]` — `JSType` derives `ConstParamTy`, so
-    // `KIND` is a true const-generic and the `match` const-folds (Zig's
-    // `@compileError` arm becomes a post-mono `panic!` on the unreachable arm).
+    // Via `#![feature(adt_const_params)]`: `JSType` derives `ConstParamTy`, so
+    // `KIND` is a true const-generic and the `match` const-folds (the
+    // unreachable arm becomes a post-mono `panic!`).
     pub fn create<const KIND: JSType>(global: &JSGlobalObject, bytes: &[u8]) -> JsResult<JSValue> {
         crate::mark_binding!();
         match KIND {
@@ -324,7 +321,7 @@ impl ArrayBuffer {
             JSType::ArrayBuffer => crate::host_fn::from_js_host_call(global, || unsafe {
                 Bun__createArrayBufferForCopy(global, bytes.as_ptr().cast(), bytes.len())
             }),
-            _ => panic!("ArrayBuffer::create: KIND not implemented"), // Zig: @compileError
+            _ => panic!("ArrayBuffer::create: KIND not implemented"),
         }
     }
 
@@ -341,7 +338,7 @@ impl ArrayBuffer {
             JSType::ArrayBuffer => crate::host_fn::from_js_host_call(global, || unsafe {
                 Bun__createArrayBufferForCopy(global, ptr::null(), 0)
             }),
-            _ => panic!("ArrayBuffer::create_empty: KIND not implemented"), // Zig: @compileError
+            _ => panic!("ArrayBuffer::create_empty: KIND not implemented"),
         }
     }
 
@@ -375,7 +372,7 @@ impl ArrayBuffer {
             JSType::ArrayBuffer => crate::host_fn::from_js_host_call(global, || {
                 Bun__allocArrayBufferForCopy(global, len as usize, &mut ptr_out)
             })?,
-            _ => panic!("ArrayBuffer::alloc: KIND not implemented"), // Zig: @compileError
+            _ => panic!("ArrayBuffer::alloc: KIND not implemented"),
         };
         // SAFETY: Bun__alloc*ForCopy writes a valid `len`-byte buffer pointer into ptr_out on success.
         let slice = unsafe { bun_core::ffi::slice_mut(ptr_out, len as usize) };
@@ -403,7 +400,7 @@ impl ArrayBuffer {
             JSType::ArrayBuffer => unsafe {
                 JSArrayBuffer__fromDefaultAllocator(global, bytes.as_mut_ptr(), bytes.len())
             },
-            // PORT NOTE: `JSUint8Array::from_bytes` takes `Box<[u8]>`; reconstruct
+            // `JSUint8Array::from_bytes` takes `Box<[u8]>`; reconstruct
             // ownership from the mimalloc-backed slice the caller hands us.
             JSType::Uint8Array => {
                 // SAFETY: caller guarantees `bytes` is exactly a `Box<[u8]>`
@@ -414,7 +411,7 @@ impl ArrayBuffer {
                 let owned = unsafe { bun_core::heap::take(ptr::from_mut(bytes)) };
                 jsc::JSUint8Array::from_bytes(global, owned)
             }
-            _ => unreachable!("Not implemented yet"), // Zig: @compileError
+            _ => unreachable!("Not implemented yet"),
         }
     }
 
@@ -474,8 +471,7 @@ impl ArrayBuffer {
                 self.ptr.cast(),
                 self.byte_len,
                 Some(MarkedArrayBuffer_deallocator),
-                // PORT NOTE: Zig passes `&bun.default_allocator` as opaque ctx; the
-                // deallocator ignores it (mi_free needs no ctx). Any non-null
+                // The deallocator ignores its ctx (mi_free needs no ctx). Any non-null
                 // sentinel would do; pass the data ptr itself for symmetry with
                 // `MarkedArrayBuffer::to_js`.
                 self.ptr.cast(),
@@ -570,9 +566,7 @@ impl ArrayBuffer {
     /// ```js
     ///    new ArrayBuffer(view.buffer, view.byteOffset, view.byteLength)
     /// ```
-    // PORT NOTE: Zig `byteSlice(self: *const @This()) []u8` is sound under Zig's
-    // aliasing model but cannot be transliterated to `&self -> &mut [_]` in Rust
-    // (forbidden aliased-`&mut` per PORTING.md §Forbidden). Split into a shared
+    // An aliased `&self -> &mut [_]` accessor is forbidden in Rust. Split into a shared
     // accessor (`&self -> &[u8]`) and an exclusive one (`&mut self -> &mut [u8]`).
     #[inline]
     pub fn byte_slice(&self) -> &[u8] {
@@ -609,8 +603,7 @@ impl ArrayBuffer {
         self.byte_slice_mut()
     }
 
-    /// Zig `asU16`: `@alignCast(asU16Unaligned())`. `@alignCast` is a checked
-    /// cast in Zig safe builds, so we debug-assert the same precondition here
+    /// Debug-asserts 2-byte alignment
     /// before handing out a naturally-aligned `&mut [u16]`. Callers that cannot
     /// guarantee alignment must use [`as_u16_unaligned`] instead.
     #[inline]
@@ -618,7 +611,7 @@ impl ArrayBuffer {
         bun_core::Unaligned::slice_align_cast_mut(self.as_u16_unaligned())
     }
 
-    /// Zig `asU16Unaligned() []align(1) u16`. Returns a slice of
+    /// Returns a slice of
     /// [`Unaligned<u16>`](bun_core::Unaligned) — Rust forbids forming
     /// `&[u16]` over a possibly-odd address, so the align(1) wrapper carries
     /// the "load via `read_unaligned`" obligation to the caller.
@@ -674,9 +667,7 @@ impl Default for ArrayBufferStrong {
 
 impl ArrayBufferStrong {
     pub fn clear(&mut self) {
-        // TODO(port): Zig source references `this.ref` which is not a field on this struct
-        // (only `array_buffer` and `held` exist). This appears to be dead/broken code upstream.
-        // Porting as a no-op matching the orelse-return on a missing field.
+        // Intentionally a no-op.
         let _ = self;
     }
 
@@ -689,14 +680,14 @@ impl ArrayBufferStrong {
     }
 }
 
-// Zig `deinit` only calls `this.held.deinit()`; `crate::Strong` already impls `Drop`,
-// so no explicit `impl Drop for ArrayBufferStrong` is needed.
+// `crate::Strong` already impls `Drop`, so no explicit
+// `impl Drop for ArrayBufferStrong` is needed.
 
 // ──────────────────────────────────────────────────────────────────────────
 // BinaryType
 // ──────────────────────────────────────────────────────────────────────────
 
-#[repr(u8)] // Zig: enum(u4) — Rust has no u4; u8 is the smallest backing.
+#[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Hash, strum::IntoStaticStr)]
 pub enum BinaryType {
     Buffer,
@@ -820,7 +811,7 @@ impl BinaryType {
                 let buffer = ArrayBuffer::create::<{ JSType::ArrayBuffer }>(global, bytes)?;
                 // SAFETY: FFI — `global` is a live opaque ZST handle; `JSGlobalObject` is
                 // a ZST on the Rust side so the `*const` → `*mut` cast launders no
-                // provenance (see PORT NOTE on the extern block above). `buffer` is a
+                // provenance (see the aliasing note on the extern block above). `buffer` is a
                 // fresh ArrayBuffer JSValue (cell pointer), so `as_object_ref` yields a
                 // valid `JSObjectRef`.
                 let obj = unsafe {
@@ -885,8 +876,7 @@ impl TypedArrayType {
         }
     }
 
-    // LAYERING: Zig's `toNapi` (array_buffer.zig:524) maps to
-    // `napi_typedarray_type`, which is defined in `bun_runtime` (a higher-tier
+    // LAYERING: `napi_typedarray_type` is defined in `bun_runtime` (a higher-tier
     // crate that depends on `bun_jsc`). The conversion lives next to its target
     // type as `napi_typedarray_type::from_typed_array_type` in
     // `bun_runtime::napi` to avoid the dep cycle.
@@ -909,7 +899,8 @@ pub(crate) type ArrayBufferStream<'a> = std::io::Cursor<&'a mut [u8]>;
 impl MarkedArrayBuffer {
     #[inline]
     pub fn stream(&mut self) -> ArrayBufferStream<'_> {
-        // TODO(port): see ArrayBuffer::stream lifetime note.
+        // See the ArrayBuffer::stream lifetime note: caller must keep the
+        // backing JSValue alive for the stream's lifetime.
         std::io::Cursor::new(self.buffer.byte_slice_mut())
     }
 
@@ -997,8 +988,7 @@ impl MarkedArrayBuffer {
     pub fn to_node_buffer(&self, global: &JSGlobalObject) -> JSValue {
         // `JSValue::create_buffer` takes `&mut [u8]` (ownership transfers to JSC
         // via the deallocator). `ArrayBuffer` is `Copy` over a raw pointer, so
-        // copy the descriptor and project a mutable slice — matches Zig
-        // `jsc.JSValue.createBuffer(ctx, this.buffer.byteSlice())`.
+        // copy the descriptor and project a mutable slice.
         let mut buf = self.buffer;
         JSValue::create_buffer(global, buf.byte_slice_mut())
     }
@@ -1035,7 +1025,7 @@ impl MarkedArrayBuffer {
 // `no_mangle` dropped: 0 C++ refs (phase_c_exports.rs mention is a comment).
 pub use bun_alloc::c_thunks::mi_free_bytes as MarkedArrayBuffer_deallocator;
 
-// LAYERING: `BlobArrayBuffer_deallocator` (array_buffer.zig:646) releases a
+// LAYERING: `BlobArrayBuffer_deallocator` releases a
 // `Blob::Store` ref. `Store` is a `bun_runtime` type, so the `#[no_mangle]`
 // export lives next to it at `bun_runtime::webcore::blob::Store` — `bun_jsc`
 // cannot own this symbol without a dep cycle. C++ links by name only.
@@ -1112,5 +1102,3 @@ impl JSCArrayBuffer {
         }
     }
 }
-
-// ported from: src/jsc/array_buffer.zig
diff --git a/src/jsc/bindgen.rs b/src/jsc/bindgen.rs
index 1578c126ef5..58f87065b63 100644
--- a/src/jsc/bindgen.rs
+++ b/src/jsc/bindgen.rs
@@ -16,19 +16,17 @@ use bun_ptr::{ExternalShared, ExternalSharedDescriptor, ExternalSharedOptional};
 // C++ buffer with `mi_free` directly.
 
 // ──────────────────────────────────────────────────────────────────────────
-// The Zig file defines a family of "Bindgen*" comptime structs that all share
-// the same shape: associated `ZigType`/`ExternType` plus `convertFromExtern`,
-// and optionally `OptionalZigType`/`OptionalExternType`/`convertOptionalFromExtern`.
-// In Rust this is a trait. `@hasDecl(Child, "OptionalExternType")` (structural
-// duck-typing) becomes a separate trait that a `Child` may opt into.
+// A `Bindgen` adapter supplies associated `ZigType`/`ExternType` plus
+// `convert_from_extern`; a bespoke optional representation is a separate
+// trait that a `Child` may opt into.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait Bindgen {
     type ZigType;
     type ExternType;
 
-    /// `true` when `ZigType` and `ExternType` are layout-identical (Zig's
-    /// `Child.ZigType == Child.ExternType` test). Enables `BindgenArray`'s
+    /// `true` when `ZigType` and `ExternType` are layout-identical.
+    /// Enables `BindgenArray`'s
     /// allocation-reuse fast path. Defaults to `false`; override per adapter.
     const SAME_REPR: bool = false;
 
@@ -37,7 +35,6 @@ pub trait Bindgen {
 
 /// Implemented by `Bindgen` types that have a bespoke "optional" representation
 /// (e.g. a nullable pointer) instead of the default `ExternTaggedUnion` wrapper.
-/// Mirrors Zig's `@hasDecl(Child, "OptionalExternType")` checks.
 pub trait BindgenOptionalRepr: Bindgen {
     type OptionalZigType;
     type OptionalExternType;
@@ -85,7 +82,7 @@ impl Bindgen for BindgenStrongAny {
 
     fn convert_from_extern(extern_value: Self::ExternType) -> Self::ZigType {
         // SAFETY: bindgen contract — C++ passes a freshly-allocated Strong handle
-        // whose ownership is transferred to Zig/Rust here.
+        // whose ownership is transferred to Rust here.
         unsafe { Strong::adopt(extern_value.expect("non-null")) }
     }
 }
@@ -123,11 +120,9 @@ pub struct BindgenOptional<Child>(PhantomData<Child>);
 // Default path: `Child` does NOT define a custom optional repr — wrap in
 // `ExternTaggedUnion<(u8, Child::ExternType)>` and produce `Option<Child::ZigType>`.
 //
-// PORT NOTE: Zig switches on `@hasDecl(Child, "OptionalExternType")` to pick
-// between this default and `Child::convertOptionalFromExtern`. Stable Rust
-// cannot specialize on "does Child impl BindgenOptionalRepr", so the bindgen
-// codegen emits `BindgenOptional<Child>` vs `BindgenOptionalCustom<Child>`
-// explicitly per call site.
+// Stable Rust cannot specialize on "does Child impl BindgenOptionalRepr",
+// so the bindgen codegen emits `BindgenOptional<Child>` vs
+// `BindgenOptionalCustom<Child>` explicitly per call site.
 impl<Child: Bindgen> Bindgen for BindgenOptional<Child> {
     type ZigType = Option<Child::ZigType>;
     type ExternType = ExternTaggedUnion2<u8, Child::ExternType>;
@@ -144,8 +139,7 @@ impl<Child: Bindgen> Bindgen for BindgenOptional<Child> {
     }
 }
 
-/// Explicit wrapper for children that DO define a custom optional repr
-/// (the `@hasDecl` == true branch in Zig).
+/// Explicit wrapper for children that DO define a custom optional repr.
 pub struct BindgenOptionalCustom<Child>(PhantomData<Child>);
 
 impl<Child: BindgenOptionalRepr> Bindgen for BindgenOptionalCustom<Child> {
@@ -192,22 +186,17 @@ impl BindgenOptionalRepr for BindgenString {
 // ──────────────────────────────────────────────────────────────────────────
 // BindgenUnion / ExternTaggedUnion / ExternUnion
 //
-// Zig builds these via `@typeInfo` / `@Type` over a `[]const type` slice —
-// pure comptime reflection with no Rust equivalent. The Rust side must be
-// generated per arity (or by a proc-macro from the bindgen codegen).
+// These are generated per arity (or by a proc-macro from the bindgen codegen).
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: `BindgenUnion(children)` reflects over a comptime type list to
-// build a tagged union and dispatch `convertFromExtern` per arm via
-// `inline else`. The bindgen TS codegen emits a concrete `enum` + `#[repr(C)]`
-// union pair per call site rather than a generic Rust combinator (see
+// The bindgen TS codegen emits a concrete `enum` + `#[repr(C)]` union pair
+// per call site rather than a generic Rust combinator (see
 // `src/jsc/generated.rs`). This marker type exists for documentation parity.
 pub struct BindgenUnion;
 
 /// `extern struct { data: ExternUnion(field_types), tag: u8 }`
 ///
-/// Zig builds the inner untagged `extern union` from a comptime type list via
-/// `@Type`. We provide fixed-arity instantiations; the 2-ary case is the only
+/// We provide fixed-arity instantiations; the 2-ary case is the only
 /// one used directly in this file (by `BindgenOptional`). Higher arities are
 /// emitted by codegen alongside their consumers.
 #[repr(C)]
@@ -216,9 +205,10 @@ pub struct ExternTaggedUnion2<T0, T1> {
     pub tag: u8,
 }
 
-/// PORT NOTE: union fields wrapped in `ManuallyDrop` so non-`Copy` payloads
+/// Union fields are wrapped in `ManuallyDrop` so non-`Copy` payloads
 /// (e.g. nested `ExternTaggedUnion2`, `ExternArrayList`) are permitted without
-/// trait bounds. Matches Zig `extern union` semantics (no auto-drop).
+/// trait bounds. There is no auto-drop — the active arm must be dropped
+/// explicitly by whoever knows the tag.
 #[repr(C)]
 pub union ExternUnion2<T0, T1> {
     pub _0: ManuallyDrop<T0>,
@@ -256,13 +246,12 @@ impl<Child: Bindgen> Bindgen for BindgenArray<Child> {
             // Don't reuse memory in this case; it would be freed by the wrong allocator.
         } else if size_of::<Child::ZigType>() == size_of::<Child::ExternType>()
             && align_of::<Child::ZigType>() == align_of::<Child::ExternType>()
-            // PORT NOTE: Zig checks `Child.ZigType == Child.ExternType` (type identity).
-            // Rust has no stable type-equality test in generic context. Gate this
-            // fast-path on a `const SAME_REPR: bool` opt-in so it only fires when the
-            // bindgen codegen has proven layout identity.
+            // Rust has no stable type-equality test in generic context, so this
+            // fast-path is gated on the `const SAME_REPR: bool` opt-in: it only
+            // fires when the bindgen codegen has proven layout identity.
             && Child::SAME_REPR
         {
-            // PORT NOTE: when the types are identical the Vec is returned as-is.
+            // The layouts are identical, so the Vec is returned as-is.
             let (ptr, len, cap) = {
                 let mut v = ManuallyDrop::new(unmanaged);
                 (v.as_mut_ptr(), v.len(), v.capacity())
@@ -276,23 +265,20 @@ impl<Child: Bindgen> Bindgen for BindgenArray<Child> {
         {
             // We can reuse the allocation, but we still need to convert the elements.
             //
-            // PORT NOTE: Zig's `@ptrCast(unmanaged.allocatedSlice())` to a `[]u8`
-            // is fine under Zig's (lack of a) memory model. In Rust, materializing
-            // a `&mut [u8]` over the full capacity would assert that every byte —
-            // including uninitialized tail elements and `ExternType` padding — is
-            // a valid `u8`, which is UB. Work entirely through raw `*mut u8` and
-            // `ptr::copy_nonoverlapping` instead; no reference to the storage is
-            // ever formed.
+            // Materializing a `&mut [u8]` over the full capacity would assert that
+            // every byte — including uninitialized tail elements and `ExternType`
+            // padding — is a valid `u8`, which is UB. Work entirely through raw
+            // `*mut u8` and `ptr::copy_nonoverlapping` instead; no reference to
+            // the storage is ever formed.
             let mut v = ManuallyDrop::new(unmanaged);
             let mut storage_ptr: *mut u8 = v.as_mut_ptr().cast::<u8>();
             let storage_len = v.capacity() * size_of::<Child::ExternType>();
 
             // Convert the elements.
             for i in 0..length {
-                // Zig doesn't have a formal aliasing model, so we should be maximally
-                // pessimistic.
-                // PORT NOTE: Rust DOES — but we keep the byte-wise copy to match behavior
-                // exactly (in-place reinterpretation of overlapping element slots).
+                // Byte-wise copy: this is an in-place reinterpretation of
+                // overlapping element slots, so each element is copied out
+                // before conversion.
                 let mut old_elem = core::mem::MaybeUninit::<Child::ExternType>::uninit();
                 // SAFETY: source range lies within the mimalloc block and holds a
                 // valid (C++-initialized) `ExternType` for `i < length`.
@@ -371,7 +357,7 @@ impl<Child: Bindgen> Bindgen for BindgenArray<Child> {
 
 #[repr(C)]
 pub struct ExternArrayList<Child> {
-    // Zig `?[*]Child` — single-word nullable pointer. `Option<*mut T>` has no niche
+    // Single-word nullable pointer. `Option<*mut T>` has no niche
     // (two words) and would break the C ABI; use raw `*mut T` and check `.is_null()`.
     pub data: *mut Child,
     pub length: c_uint,
diff --git a/src/jsc/bindgen_test.rs b/src/jsc/bindgen_test.rs
index d6d1c411972..50103e20da1 100644
--- a/src/jsc/bindgen_test.rs
+++ b/src/jsc/bindgen_test.rs
@@ -6,8 +6,8 @@ use crate::{JSGlobalObject, JSObject, JSValue, JsResult};
 use crate::r#gen::bindgen_test as generated;
 
 pub fn get_bindgen_test_functions(global: &JSGlobalObject) -> JsResult<JSValue> {
-    // PORT NOTE: Zig used an anon struct with `jsc.JSObject.create`; Rust has no
-    // field reflection, so a local `PojoFields` impl enumerates the fields.
+    // Rust has no field reflection, so a local `PojoFields` impl enumerates
+    // the fields.
     struct Fns {
         add: JSValue,
         required_and_optional_arg: JSValue,
@@ -36,9 +36,9 @@ pub fn add(global: &JSGlobalObject, a: i32, b: i32) -> JsResult<i32> {
     match a.checked_add(b) {
         Some(v) => Ok(v),
         None => {
-            // Binding functions can return `error.OutOfMemory` and `error.JSError`.
-            // Others like `error.Overflow` from `std.math.add` must be converted.
-            // Remember to be descriptive.
+            // Binding functions can propagate out-of-memory and JS exceptions
+            // directly; other failures (like this integer overflow) must be
+            // converted into a thrown error. Remember to be descriptive.
             Err(global.throw_pretty(format_args!("Integer overflow while adding")))
         }
     }
@@ -50,9 +50,6 @@ pub fn required_and_optional_arg(a: bool, b: Option<usize>, c: i32, d: Option<u8
             .wrapping_add(c)
             .wrapping_add(i32::from(d.unwrap_or(0)));
     };
-    // Zig: @truncate(@as(isize, @as(u53, @truncate(
-    //     (b_nonnull +% @as(usize, @abs(c))) *% (d orelse 1),
-    // ))))
     let inner: usize = b_nonnull
         .wrapping_add(c.unsigned_abs() as usize)
         .wrapping_mul(usize::from(d.unwrap_or(1)));
@@ -64,5 +61,3 @@ pub fn required_and_optional_arg(a: bool, b: Option<usize>, c: i32, d: Option<u8
     }
     math_result
 }
-
-// ported from: src/jsc/bindgen_test.zig
diff --git a/src/jsc/bindings/Bindgen/ExternVectorTraits.h b/src/jsc/bindings/Bindgen/ExternVectorTraits.h
index f6f62bc8f65..ad609c7781d 100644
--- a/src/jsc/bindings/Bindgen/ExternVectorTraits.h
+++ b/src/jsc/bindings/Bindgen/ExternVectorTraits.h
@@ -30,9 +30,8 @@ template<typename T>
 void asanSetBufferSizeToFullCapacity(T* buffer, std::size_t length, std::size_t capacity)
 {
 #if ASAN_ENABLED
-    // Without this, ASan will complain if Zig touches memory in the range
-    // [storage + length, storage + capacity), which will always happen when freeing the
-    // memory in Debug mode when Zig writes 0xaa to it.
+    // Without this, ASan will complain if the Rust side touches memory in the range
+    // [storage + length, storage + capacity), which happens when freeing the memory.
     __sanitizer_annotate_contiguous_container(
         buffer, // beg
         buffer + capacity, // end
diff --git a/src/jsc/bindings/BufferEncodingType.h b/src/jsc/bindings/BufferEncodingType.h
index 4052d23d1b0..1df3b6ceb78 100644
--- a/src/jsc/bindings/BufferEncodingType.h
+++ b/src/jsc/bindings/BufferEncodingType.h
@@ -4,7 +4,7 @@
 
 namespace WebCore {
 
-// must match src/runtime/node/types.zig#Encoding
+// must match `Encoding` in src/runtime/node/types.rs
 enum class BufferEncodingType : uint8_t {
     utf8 = 0,
     ucs2 = 1,
diff --git a/src/jsc/bindings/BunCommonStrings.cpp b/src/jsc/bindings/BunCommonStrings.cpp
index ea5351bd926..42e51363445 100644
--- a/src/jsc/bindings/BunCommonStrings.cpp
+++ b/src/jsc/bindings/BunCommonStrings.cpp
@@ -45,7 +45,7 @@ void CommonStrings::visit(Visitor& visitor)
 template void CommonStrings::visit(JSC::AbstractSlotVisitor&);
 template void CommonStrings::visit(JSC::SlotVisitor&);
 
-// Must be kept in sync with method.zig
+// Must be kept in sync with src/http_types/Method.rs
 enum class HTTPMethod : uint8_t {
     httpACL = 0,
     httpBIND = 1,
@@ -201,7 +201,7 @@ extern "C" JSC::EncodedJSValue Bun__CommonStringsForZig__toJS(CommonStringsForZi
     return JSValue::encode(toJS(globalObject, commonString));
 }
 
-// Must be kept in sync with src/http/FetchCacheMode.zig
+// Must be kept in sync with src/http_types/FetchCacheMode.rs
 enum class FetchCacheMode : uint8_t {
     Default = 0,
     NoStore = 1,
@@ -234,7 +234,7 @@ extern "C" JSC::EncodedJSValue Bun__FetchCacheMode__toJS(FetchCacheMode mode, Zi
     }
 }
 
-// Must be kept in sync with src/http/FetchRedirect.zig
+// Must be kept in sync with src/http_types/FetchRedirect.rs
 enum class FetchRedirect : uint8_t {
     Follow = 0,
     Manual = 1,
@@ -258,7 +258,7 @@ extern "C" JSC::EncodedJSValue Bun__FetchRedirect__toJS(FetchRedirect redirect,
     }
 }
 
-// Must be kept in sync with src/http/FetchRequestMode.zig
+// Must be kept in sync with src/http_types/FetchRequestMode.rs
 enum class FetchRequestMode : uint8_t {
     SameOrigin = 0,
     NoCors = 1,
diff --git a/src/jsc/bindings/BunMarkdownMeta.cpp b/src/jsc/bindings/BunMarkdownMeta.cpp
index 0950f1eb315..a125099b65e 100644
--- a/src/jsc/bindings/BunMarkdownMeta.cpp
+++ b/src/jsc/bindings/BunMarkdownMeta.cpp
@@ -53,7 +53,7 @@ Structure* createLinkMetaStructure(VM& vm, JSGlobalObject* globalObject)
 } // namespace Bun
 
 // ──────────────────────────────────────────────────────────────────────────
-// extern "C" constructors — callable from MarkdownObject.zig
+// extern "C" constructors — callable from src/runtime/api/MarkdownObject.rs
 // ──────────────────────────────────────────────────────────────────────────
 
 extern "C" JSC::EncodedJSValue BunMarkdownMeta__createListItem(
diff --git a/src/jsc/bindings/BunMarkdownTagStrings.cpp b/src/jsc/bindings/BunMarkdownTagStrings.cpp
index 7eb331e5741..299f3cbc727 100644
--- a/src/jsc/bindings/BunMarkdownTagStrings.cpp
+++ b/src/jsc/bindings/BunMarkdownTagStrings.cpp
@@ -36,7 +36,7 @@ template void MarkdownTagStrings::visit(JSC::SlotVisitor&);
 
 } // namespace Bun
 
-// C API for Zig bindings
+// C API for the Rust bindings
 extern "C" JSC::EncodedJSValue BunMarkdownTagStrings__getTagString(Zig::GlobalObject* globalObject, uint8_t tagIndex)
 {
     if (tagIndex >= MARKDOWN_TAG_STRINGS_COUNT)
diff --git a/src/jsc/bindings/BunObject+exports.h b/src/jsc/bindings/BunObject+exports.h
index f7579d4e6d0..c8c703df57a 100644
--- a/src/jsc/bindings/BunObject+exports.h
+++ b/src/jsc/bindings/BunObject+exports.h
@@ -86,12 +86,12 @@
 FOR_EACH_CALLBACK(DECLARE_ZIG_BUN_OBJECT_CALLBACK);
 #undef DECLARE_ZIG_BUN_OBJECT_CALLBACK
 
-// declaration for the exported function in BunObject.zig
+// declaration for the exported function in src/runtime/api/BunObject.rs
 #define DECLARE_ZIG_BUN_OBJECT_GETTER(name) extern "C" JSC::EncodedJSValue SYSV_ABI BunObject_lazyPropCb_##name(JSC::JSGlobalObject*, JSC::JSObject*);
 FOR_EACH_GETTER(DECLARE_ZIG_BUN_OBJECT_GETTER);
 #undef DECLARE_ZIG_BUN_OBJECT_GETTER
 
-// definition of the C++ wrapper to call the Zig function
+// definition of the C++ wrapper to call the Rust function
 #define DEFINE_ZIG_BUN_OBJECT_GETTER_WRAPPER(name) static JSC::JSValue BunObject_lazyPropCb_wrap_##name(JSC::VM &vm, JSC::JSObject *object) { \
     return JSC::JSValue::decode(BunObject_lazyPropCb_##name(object->globalObject(), object)); \
 } \
diff --git a/src/jsc/bindings/BunProcess.cpp b/src/jsc/bindings/BunProcess.cpp
index 6935f0cbbce..86a9622c33a 100644
--- a/src/jsc/bindings/BunProcess.cpp
+++ b/src/jsc/bindings/BunProcess.cpp
@@ -227,7 +227,6 @@ static JSValue constructVersions(VM& vm, JSObject* processObject)
     object->putDirect(vm, JSC::Identifier::fromString(vm, "picohttpparser"_s), JSC::jsOwnedString(vm, ASCIILiteral::fromLiteralUnsafe(BUN_VERSION_PICOHTTPPARSER)), 0);
     object->putDirect(vm, JSC::Identifier::fromString(vm, "uwebsockets"_s), JSC::jsOwnedString(vm, ASCIILiteral::fromLiteralUnsafe(BUN_VERSION_UWS)), 0);
     object->putDirect(vm, JSC::Identifier::fromString(vm, "webkit"_s), JSC::jsOwnedString(vm, ASCIILiteral::fromLiteralUnsafe(BUN_VERSION_WEBKIT)), 0);
-    // Zig version from CMake-generated header
     object->putDirect(vm, JSC::Identifier::fromString(vm, "zig"_s), JSC::jsOwnedString(vm, ASCIILiteral::fromLiteralUnsafe(BUN_VERSION_ZIG)), 0);
 
     // Use commit hash for zlib to match test expectations
@@ -451,7 +450,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen, (JSC::JSGlobalObject * globalOb
     CString utf8;
 
     // Support embedded .node files
-    // See StandaloneModuleGraph.zig for what this "$bunfs" thing is
+    // See src/standalone_graph/StandaloneModuleGraph.rs for what this "$bunfs" thing is
 #if OS(WINDOWS)
 #define StandaloneModuleGraph__base_path "B:/~BUN/"_s
 #else
@@ -699,7 +698,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionDlopen, (JSC::JSGlobalObject * globalOb
 #endif
 
     // TODO(@190n) look for node_register_module_vXYZ according to BuildOptions.reported_nodejs_version
-    // (bun/src/env.zig:36) and the table at https://github.com/nodejs/node/blob/main/doc/abi_version_registry.json
+    // and the table at https://github.com/nodejs/node/blob/main/doc/abi_version_registry.json
     auto napi_register_module_v1 = reinterpret_cast<napi_value (*)(napi_env, napi_value)>(dlsym(handle, "napi_register_module_v1"));
 
     auto node_api_module_get_api_version_v1 = reinterpret_cast<int32_t (*)()>(dlsym(handle, "node_api_module_get_api_version_v1"));
@@ -1760,8 +1759,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionExecve, (JSGlobalObject * lexicalGlobal
     // extensions: POSIX_SPAWN_SETEXEC makes posix_spawn(2) behave like a more
     // featureful execve(2) (replace the current image rather than fork), and
     // POSIX_SPAWN_CLOEXEC_DEFAULT atomically closes every descriptor that
-    // isn't explicitly inherited via file actions. This mirrors
-    // reloadProcess() in src/bun.zig.
+    // isn't explicitly inherited via file actions.
     posix_spawnattr_t attrs;
     posix_spawn_file_actions_t actions;
     posix_spawnattr_init(&attrs);
@@ -2451,7 +2449,6 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionWriteReport, (JSGlobalObject * globalOb
 static JSValue constructProcessReportObject(VM& vm, JSObject* processObject)
 {
     auto* globalObject = processObject->globalObject();
-    // auto* globalObject = static_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto process = uncheckedDowncast<Process>(processObject);
 
     auto* report = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 10);
@@ -2785,7 +2782,6 @@ static JSValue constructExecPath(VM& vm, JSObject* processObject)
     return JSValue::decode(Bun__Process__getExecPath(globalObject));
 }
 
-// get from zig
 extern "C" EncodedJSValue Bun__Process__getArgv(JSGlobalObject* lexicalGlobalObject)
 {
     auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
@@ -3256,7 +3252,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionReallyExit, (JSGlobalObject * globalObj
     auto* zigGlobal = defaultGlobalObject(globalObject);
     Bun__Process__exit(zigGlobal, exitCode);
     // Main-thread Bun__Process__exit is noreturn. In a worker it returns; the
-    // Zig WebWorker.exit() it called requests JSC termination (guarded so it's a
+    // WebWorker exit path it called requests JSC termination (guarded so it's a
     // no-op when re-entered from a process.on('exit') handler).
     throwScope.release();
     return JSC::JSValue::encode(jsUndefined());
diff --git a/src/jsc/bindings/BunSecureContextCache.cpp b/src/jsc/bindings/BunSecureContextCache.cpp
index c9004f3b4c3..447413c4e56 100644
--- a/src/jsc/bindings/BunSecureContextCache.cpp
+++ b/src/jsc/bindings/BunSecureContextCache.cpp
@@ -5,9 +5,9 @@
 
 using namespace JSC;
 
-// Called from Zig (`SecureContext.intern`). Returns the cached JSSecureContext
+// Called from Rust (`SecureContext::intern`). Returns the cached JSSecureContext
 // for `key` (low 64 bits of the config digest) or jsEmpty() if none / GC'd.
-// The full 32-byte digest lives on the Zig SecureContext, so the caller does
+// The full 32-byte digest lives on the Rust SecureContext, so the caller does
 // a content-equality check on hit to handle the (~2⁻⁶⁴) key-collision case.
 extern "C" JSC::EncodedJSValue Bun__SecureContextCache__get(Zig::GlobalObject* global, uint64_t key)
 {
diff --git a/src/jsc/bindings/BunSecureContextCache.h b/src/jsc/bindings/BunSecureContextCache.h
index 33aa6d2773f..5db7d4ca9aa 100644
--- a/src/jsc/bindings/BunSecureContextCache.h
+++ b/src/jsc/bindings/BunSecureContextCache.h
@@ -6,7 +6,7 @@
 //
 // Backs the JS-side dedup of `tls.createSecureContext()`: same config digest
 // → same `JSSecureContext` cell while it's alive. The native `SSL_CTX*` cache
-// (Zig `SSLContextCache`) is independent — BoringSSL's refcount is the single
+// (`SSLContextCache`) is independent — BoringSSL's refcount is the single
 // source of truth, so the two never need to coordinate.
 
 #include "root.h"
diff --git a/src/jsc/bindings/ExceptionCode.h b/src/jsc/bindings/ExceptionCode.h
index 4b200cca6ae..6772e376a6e 100644
--- a/src/jsc/bindings/ExceptionCode.h
+++ b/src/jsc/bindings/ExceptionCode.h
@@ -24,7 +24,7 @@
 
 namespace WebCore {
 
-// keep in sync with DOMExceptionCode in src/jsc/bindings/JSErrorCode.Zig
+// keep in sync with DOMExceptionCode in src/jsc/JSErrorCode.rs
 enum ExceptionCode : uint8_t {
     // DOMException error names (https://webidl.spec.whatwg.org/#idl-DOMException-error-names).
     // Those need to be kept in sync with the array in DOMException.cpp.
diff --git a/src/jsc/bindings/FormatStackTraceForJS.cpp b/src/jsc/bindings/FormatStackTraceForJS.cpp
index 03e4fc86e34..b28d99e5370 100644
--- a/src/jsc/bindings/FormatStackTraceForJS.cpp
+++ b/src/jsc/bindings/FormatStackTraceForJS.cpp
@@ -236,7 +236,7 @@ WTF::String formatStackTrace(
     sb.append("\n"_s);
 
     // Pass 1: collect (line, col, source_url) for frames that should be
-    // source-mapped, then batch the remap so the Zig side can resolve each
+    // source-mapped, then batch the remap so the Rust side can resolve each
     // file's map once instead of per frame.
     WTF::Vector<ZigStackFrame, 8> remappedFrames;
     WTF::Vector<WTF::String, 8> sourceURLs;
@@ -250,7 +250,7 @@ WTF::String formatStackTrace(
     for (size_t i = 0; i < framesCount; i++) {
         StackFrame& frame = stackTrace.at(i);
         ZigStackFrame& remappedFrame = remappedFrames[i];
-        // Match `ZigStackFramePosition.invalid` exactly so the Zig batch loop's
+        // Match `ZigStackFramePosition::INVALID` exactly so the Rust batch loop's
         // `position.isInvalid()` skips frames we never populate (vm-context
         // frames, frames without line/col info). memset alone leaves
         // `line_start_byte = 0` which fails that byte-compare.
diff --git a/src/jsc/bindings/GeneratedBindings.rs b/src/jsc/bindings/GeneratedBindings.rs
index 21e9ddcc81a..4c7eb6dd182 100644
--- a/src/jsc/bindings/GeneratedBindings.rs
+++ b/src/jsc/bindings/GeneratedBindings.rs
@@ -1,5 +1,4 @@
-//! Hand-ported surface of `src/codegen/bindgen.ts` output
-//! (source: src/jsc/bindings/GeneratedBindings.zig — bindgen dispatch shims).
+//! Hand-written surface of `src/codegen/bindgen.ts` output (bindgen dispatch shims).
 //!
 //! Until the generator grows a `.rs` backend, the modules required by
 //! downstream Rust callers are ported here by hand. Each `create_*_callback`
@@ -11,7 +10,7 @@
 
 use crate::{JSGlobalObject, JSHostFn, JSValue, host_fn, zig_string};
 
-/// Generated for "src/jsc/bindgen_test.zig"
+/// Generated for "src/jsc/bindgen_test.rs"
 pub mod bindgen_test {
     use super::*;
 
@@ -47,5 +46,3 @@ pub mod bindgen_test {
         )
     }
 }
-
-// ported from: src/jsc/bindings/GeneratedBindings.zig
diff --git a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
index 4cc5e4c6593..dabee36f67b 100644
--- a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
+++ b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.cpp
@@ -133,7 +133,7 @@ void InspectorBunFrontendDevServerAgent::consoleLog(int devServerId, char kind,
     m_frontendDispatcher->consoleLog(devServerId, kind, data);
 }
 
-// C API implementations for Zig
+// C API implementations for the Rust side
 extern "C" {
 
 void InspectorBunFrontendDevServerAgent__notifyClientConnected(InspectorBunFrontendDevServerAgent* agent, int devServerId, int connectionId)
diff --git a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
index 2ba0e332841..6c150df6bcc 100644
--- a/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
+++ b/src/jsc/bindings/InspectorBunFrontendDevServerAgent.h
@@ -50,7 +50,7 @@ class InspectorBunFrontendDevServerAgent final : public InspectorAgentBase, publ
     bool m_enabled { false };
 };
 
-// C API for Zig to call
+// C API for the Rust side to call
 extern "C" {
 void BunFrontendDevServerAgent__notifyClientConnected(InspectorBunFrontendDevServerAgent* agent, int connectionId);
 void BunFrontendDevServerAgent__notifyClientDisconnected(InspectorBunFrontendDevServerAgent* agent, int connectionId);
diff --git a/src/jsc/bindings/InspectorHTTPServerAgent.cpp b/src/jsc/bindings/InspectorHTTPServerAgent.cpp
index e1e12784982..0b4bf89e9f0 100644
--- a/src/jsc/bindings/InspectorHTTPServerAgent.cpp
+++ b/src/jsc/bindings/InspectorHTTPServerAgent.cpp
@@ -13,7 +13,7 @@ namespace Inspector {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(InspectorHTTPServerAgent);
 
-// Zig bindings implementation
+// Rust bindings implementation
 extern "C" {
 void Bun__HTTPServerAgent__setEnabled(Inspector::InspectorHTTPServerAgent* agent);
 
@@ -177,10 +177,10 @@ void InspectorHTTPServerAgent::requestHandlerException(Ref<Protocol::HTTPServer:
 
 }
 
-// Zig API implementation
+// Rust-facing C API implementation
 extern "C" {
 
-// Functions for Zig to call to notify about HTTP server events
+// Functions for the Rust side to call to notify about HTTP server events
 
 typedef int ServerId;
 typedef int HotReloadId;
@@ -199,7 +199,7 @@ typedef int RequestId;
     agent->serverStopped(serverId, timestamp);
 }
 
-// This matches the Route extern struct in Zig
+// This matches the Route extern struct on the Rust side
 struct Route {
     enum class Type : uint8_t {
         Default = 1,
diff --git a/src/jsc/bindings/InspectorLifecycleAgent.cpp b/src/jsc/bindings/InspectorLifecycleAgent.cpp
index 761f7a67891..c40e94aae0b 100644
--- a/src/jsc/bindings/InspectorLifecycleAgent.cpp
+++ b/src/jsc/bindings/InspectorLifecycleAgent.cpp
@@ -25,7 +25,7 @@ namespace Inspector {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(InspectorLifecycleAgent);
 
-// Zig bindings implementation
+// Rust bindings implementation
 extern "C" {
 
 void Bun__LifecycleAgentEnable(Inspector::InspectorLifecycleAgent* agent);
diff --git a/src/jsc/bindings/InspectorTestReporterAgent.cpp b/src/jsc/bindings/InspectorTestReporterAgent.cpp
index 968e5faf6ee..f10a8693c1d 100644
--- a/src/jsc/bindings/InspectorTestReporterAgent.cpp
+++ b/src/jsc/bindings/InspectorTestReporterAgent.cpp
@@ -20,7 +20,7 @@ namespace Inspector {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(InspectorTestReporterAgent);
 
-// Zig bindings implementation
+// Rust bindings implementation
 extern "C" {
 
 void Bun__TestReporterAgentEnable(Inspector::InspectorTestReporterAgent* agent);
@@ -76,7 +76,7 @@ void Bun__TestReporterAgentReportTestStart(Inspector::InspectorTestReporterAgent
 }
 
 enum class BunTestStatus : uint8_t {
-    // this enum is kept in sync with zig Debugger.zig `pub const TestStatus`
+    // this enum is kept in sync with `TestStatus` in src/jsc/Debugger.rs
     Pass,
     Fail,
     Timeout,
diff --git a/src/jsc/bindings/InternalForTesting.cpp b/src/jsc/bindings/InternalForTesting.cpp
index d59999cfc1b..141195bc252 100644
--- a/src/jsc/bindings/InternalForTesting.cpp
+++ b/src/jsc/bindings/InternalForTesting.cpp
@@ -85,7 +85,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_BunString_toThreadSafeRefCountDelta, (JSC::J
 
     const unsigned before = original->refCount();
 
-    // Give the BunString its own ref, mirroring how a Zig-side bun.String
+    // Give the BunString its own ref, mirroring how a Rust-side bun.String
     // owns one reference to the underlying StringImpl.
     original->ref();
     BunString str = { BunStringTag::WTFStringImpl, { .wtf = original.ptr() } };
diff --git a/src/jsc/bindings/JSBundlerPlugin.cpp b/src/jsc/bindings/JSBundlerPlugin.cpp
index db131223046..af79303c095 100644
--- a/src/jsc/bindings/JSBundlerPlugin.cpp
+++ b/src/jsc/bindings/JSBundlerPlugin.cpp
@@ -47,7 +47,7 @@ extern "C" void OnBeforeParseResult__reset(OnBeforeParseResult* result);
 #define WRAP_BUNDLER_PLUGIN(argName) jsDoubleNumber(std::bit_cast<double>(reinterpret_cast<uintptr_t>(argName)))
 #define UNWRAP_BUNDLER_PLUGIN(callFrame) reinterpret_cast<void*>(std::bit_cast<uintptr_t>(callFrame->argument(0).asDouble()))
 
-/// These are callbacks defined in Zig and to be run after their associated JS version is run
+/// These are native callbacks to be run after their associated JS version is run
 extern "C" void JSBundlerPlugin__addError(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onLoadAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue);
 extern "C" void JSBundlerPlugin__onResolveAsync(void*, void*, JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::EncodedJSValue);
@@ -539,7 +539,7 @@ extern "C" void JSBundlerPlugin__matchOnLoad(Bun::JSBundlerPlugin* plugin, BunSt
         auto exception = scope.exception();
         (void)scope.tryClearException();
         if (!plugin->plugin.tombstoned) {
-            // which = 1 (Load). Zig's JSBundlerPlugin__addError casts ctx based on this value.
+            // which = 1 (Load). JSBundlerPlugin__addError casts ctx based on this value.
             plugin->plugin.addError(
                 context,
                 plugin,
@@ -579,7 +579,7 @@ extern "C" void JSBundlerPlugin__matchOnResolve(Bun::JSBundlerPlugin* plugin, Bu
         auto exception = JSValue(scope.exception());
         (void)scope.tryClearException();
         if (!plugin->plugin.tombstoned) {
-            // which = 0 (Resolve). Zig's JSBundlerPlugin__addError casts ctx based on this value.
+            // which = 0 (Resolve). JSBundlerPlugin__addError casts ctx based on this value.
             plugin->plugin.addError(
                 context,
                 plugin,
diff --git a/src/jsc/bindings/JSEnvironmentVariableMap.cpp b/src/jsc/bindings/JSEnvironmentVariableMap.cpp
index fd6cce51c70..9d6816d2ce3 100644
--- a/src/jsc/bindings/JSEnvironmentVariableMap.cpp
+++ b/src/jsc/bindings/JSEnvironmentVariableMap.cpp
@@ -68,10 +68,10 @@ JSC_DEFINE_CUSTOM_SETTER(jsSetterEnvironmentVariable, (JSGlobalObject * globalOb
 }
 
 // Proxy-related env vars (HTTP_PROXY, HTTPS_PROXY, NO_PROXY and lowercase
-// variants) are read by fetch()'s Zig-side proxy resolution via
-// env_loader.getHttpProxyFor(). Writes from JS must sync back to the Zig env
+// variants) are read by fetch()'s native proxy resolution via
+// env_loader.getHttpProxyFor(). Writes from JS must sync back to the native env
 // map so runtime changes take effect. Unlike the generic getter, this does
-// NOT cache on the JS object — the Zig env map is the single source of truth
+// NOT cache on the JS object — the native env map is the single source of truth
 // so set-then-get stays consistent and the CustomAccessor isn't clobbered.
 JSC_DEFINE_CUSTOM_GETTER(jsGetterProxyEnvironmentVariable, (JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, PropertyName propertyName))
 {
@@ -370,7 +370,7 @@ JSValue createEnvironmentVariablesMap(Zig::GlobalObject* globalObject)
     bool hasNodeTLSRejectUnauthorized = false;
     bool hasBunConfigVerboseFetch = false;
 
-    // Proxy-related env vars need write-back to the Zig env map so that
+    // Proxy-related env vars need write-back to the native env map so that
     // fetch()'s getHttpProxyFor() observes runtime changes.
     static constexpr ASCIILiteral proxyVarNames[] = {
         "HTTP_PROXY"_s,
@@ -485,7 +485,7 @@ JSValue createEnvironmentVariablesMap(Zig::GlobalObject* globalObject)
 
     for (size_t j = 0; j < proxyVarCount; j++) {
         // Known limitation: `delete process.env.NO_PROXY` removes the accessor
-        // without calling the setter, leaving Zig's env map stale (same as TZ).
+        // without calling the setter, leaving the native env map stale (same as TZ).
         // Use `process.env.NO_PROXY = ""` to unset. DontDelete would throw in
         // strict mode, so we leave it deletable and document the gap.
         unsigned attrs = JSC::PropertyAttribute::CustomAccessor | 0;
diff --git a/src/jsc/bindings/JSMockFunction.cpp b/src/jsc/bindings/JSMockFunction.cpp
index 1c1c7fe70f6..9b39827ad78 100644
--- a/src/jsc/bindings/JSMockFunction.cpp
+++ b/src/jsc/bindings/JSMockFunction.cpp
@@ -1431,13 +1431,13 @@ BUN_DEFINE_HOST_FUNCTION(JSMock__jsUseRealTimers, (JSC::JSGlobalObject * globalO
     return JSValue::encode(callframe->thisValue());
 }
 
-// Helper function for Zig to set the overriden Date.now() time
+// Helper function for native code to set the overriden Date.now() time
 extern "C" [[ZIG_EXPORT(nothrow)]] void JSMock__setOverridenDateNow(JSC::JSGlobalObject* globalObject, double time_ms)
 {
     globalObject->overridenDateNow = time_ms;
 }
 
-// Helper function for Zig to get the current Unix epoch time in milliseconds
+// Helper function for native code to get the current Unix epoch time in milliseconds
 extern "C" [[ZIG_EXPORT(nothrow)]] double JSMock__getCurrentUnixTimeMs()
 {
     return WTF::WallTime::now().secondsSinceEpoch().milliseconds();
diff --git a/src/jsc/bindings/JSMockFunction.h b/src/jsc/bindings/JSMockFunction.h
index 2cfc44c89f0..a22b8d960dc 100644
--- a/src/jsc/bindings/JSMockFunction.h
+++ b/src/jsc/bindings/JSMockFunction.h
@@ -46,7 +46,7 @@ class JSMockModule final {
     // This list includes activeSpies
     JSC::Strong<JSC::Unknown> activeMocks;
 
-    // Called by Zig::GlobalObject::visitChildren
+    // Called by GlobalObject::visitChildren
     template<typename Visitor>
     void visit(Visitor& visitor);
 };
diff --git a/src/jsc/bindings/JSNodePerformanceHooksHistogramPrototype.cpp b/src/jsc/bindings/JSNodePerformanceHooksHistogramPrototype.cpp
index dd071fca50a..7b54af25fc6 100644
--- a/src/jsc/bindings/JSNodePerformanceHooksHistogramPrototype.cpp
+++ b/src/jsc/bindings/JSNodePerformanceHooksHistogramPrototype.cpp
@@ -423,7 +423,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_createHistogram, (JSGlobalObject * globalObj
     return JSValue::encode(histogram);
 }
 
-// Extern declarations for Timer.zig
+// Extern declarations for the native timer implementation
 extern "C" void Timer_enableEventLoopDelayMonitoring(void* vm, JSC::EncodedJSValue histogram, int32_t resolution);
 extern "C" void Timer_disableEventLoopDelayMonitoring(void* vm);
 
@@ -486,7 +486,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_enableEventLoopDelay, (JSGlobalObject * glob
     // Reset histogram data on enable
     histogram->reset();
 
-    // Enable the event loop delay monitor in Timer.zig
+    // Enable the event loop delay monitor in the native timer implementation
     Timer_enableEventLoopDelayMonitoring(bunVM(globalObject), JSValue::encode(histogram), resolution);
 
     RELEASE_AND_RETURN(scope, JSValue::encode(jsUndefined()));
@@ -511,13 +511,13 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_disableEventLoopDelay, (JSGlobalObject * glo
         return JSValue::encode(jsUndefined());
     }
 
-    // Call into Zig to disable monitoring
+    // Call into native code to disable monitoring
     Timer_disableEventLoopDelayMonitoring(bunVM(globalObject));
 
     return JSValue::encode(jsUndefined());
 }
 
-// Extern function for Zig to record delays
+// Extern function for native code to record delays
 extern "C" void JSNodePerformanceHooksHistogram_recordDelay(JSC::EncodedJSValue histogram, int64_t delay_ns)
 {
     if (!histogram || delay_ns <= 0) return;
diff --git a/src/jsc/bindings/JSSecrets.cpp b/src/jsc/bindings/JSSecrets.cpp
index de855e55876..2d4e9feb376 100644
--- a/src/jsc/bindings/JSSecrets.cpp
+++ b/src/jsc/bindings/JSSecrets.cpp
@@ -234,7 +234,7 @@ struct SecretsJobOptions {
     }
 };
 
-// C interface implementation for Zig binding
+// C interface implementation for the native binding
 extern "C" {
 
 // Runs on the threadpool - does the actual platform API work
@@ -315,7 +315,7 @@ void Bun__SecretsJobOptions__deinit(SecretsJobOptions* opts)
     delete opts;
 }
 
-// Zig binding exports
+// Native binding exports
 void Bun__Secrets__scheduleJob(JSGlobalObject* global, SecretsJobOptions* opts, EncodedJSValue promise);
 
 } // extern "C"
diff --git a/src/jsc/bindings/NativePromiseContext.cpp b/src/jsc/bindings/NativePromiseContext.cpp
index a68f4f1f109..f060c8cdbad 100644
--- a/src/jsc/bindings/NativePromiseContext.cpp
+++ b/src/jsc/bindings/NativePromiseContext.cpp
@@ -2,7 +2,7 @@
 
 #include "ZigGlobalObject.h"
 
-// Implemented in Zig (src/runtime/api/NativePromiseContext.zig). Switches on
+// Implemented in src/runtime/api/NativePromiseContext.rs. Switches on
 // tag to release the ref on the right native type.
 extern "C" void Bun__NativePromiseContext__destroy(void* ctx, uint8_t tag);
 
diff --git a/src/jsc/bindings/NativePromiseContext.h b/src/jsc/bindings/NativePromiseContext.h
index 5c42a0be561..42d64c73402 100644
--- a/src/jsc/bindings/NativePromiseContext.h
+++ b/src/jsc/bindings/NativePromiseContext.h
@@ -7,7 +7,7 @@
 namespace Bun {
 
 // Opaque marker type so CompactPointerTuple's allowCompactPointers check
-// passes. The actual pointee is one of several Zig-side native types; we
+// passes. The actual pointee is one of several native types; we
 // cast through void* at the boundary.
 struct NativePromiseContextPointee {
     WTF_ALLOW_STRUCT_COMPACT_POINTERS;
@@ -36,7 +36,7 @@ class NativePromiseContext final : public JSC::JSCell {
     // CompactPointerTuple, so this cell adds only one pointer of storage
     // beyond the JSCell header.
     //
-    // Must stay in sync with Tag in src/runtime/api/NativePromiseContext.zig.
+    // Must stay in sync with Tag in src/runtime/api/NativePromiseContext.rs.
     enum class Tag : uint8_t {
         HTTPServerRequestContext,
         HTTPSServerRequestContext,
diff --git a/src/jsc/bindings/NoOrphansTracker.cpp b/src/jsc/bindings/NoOrphansTracker.cpp
index db887d214ec..621e11102c5 100644
--- a/src/jsc/bindings/NoOrphansTracker.cpp
+++ b/src/jsc/bindings/NoOrphansTracker.cpp
@@ -257,7 +257,7 @@ class NoOrphansTracker {
     // Scratch buffer for proc_listallpids; persisted across scans so a
     // fork-heavy script (e.g. `make -j`) isn't reallocating every NOTE_FORK.
     WTF::Vector<pid_t> m_pids;
-    int m_kq = -1; // borrowed; owned by Zig's spawnPosix
+    int m_kq = -1; // borrowed; owned by spawnPosix
 };
 
 } // namespace Bun
diff --git a/src/jsc/bindings/NodeVM.cpp b/src/jsc/bindings/NodeVM.cpp
index 16aa553a1ef..3c51d04db60 100644
--- a/src/jsc/bindings/NodeVM.cpp
+++ b/src/jsc/bindings/NodeVM.cpp
@@ -785,7 +785,7 @@ void unsafeEvalNoop(JSGlobalObject*, const WTF::String&) {}
 
 static void promiseRejectionTrackerForNodeVM(JSGlobalObject* globalObject, JSC::JSPromise* promise, JSC::JSPromiseRejectionOperation operation)
 {
-    // Delegate to the parent Zig::GlobalObject so that unhandled rejections
+    // Delegate to the parent global object so that unhandled rejections
     // in VM contexts are reported to the main process (matching Node.js behavior)
     auto* zigGlobalObject = defaultGlobalObject(globalObject);
     Zig::GlobalObject::promiseRejectionTracker(zigGlobalObject, promise, operation);
@@ -833,7 +833,7 @@ void NodeVMGlobalObject::finishCreation(JSC::VM& vm)
 
     vm.ensureTerminationException();
 
-    // Share the async context data with the parent Zig::GlobalObject.
+    // Share the async context data with the parent global object.
     // This is necessary because AsyncLocalStorage methods (run, getStore, etc.) are defined
     // in the parent realm and reference the parent's $asyncContext. However, microtask
     // processing (JSMicrotask.cpp) operates on this NodeVMGlobalObject's m_asyncContextData.
diff --git a/src/jsc/bindings/ScriptExecutionContext.cpp b/src/jsc/bindings/ScriptExecutionContext.cpp
index 76f742b8882..66a581369c5 100644
--- a/src/jsc/bindings/ScriptExecutionContext.cpp
+++ b/src/jsc/bindings/ScriptExecutionContext.cpp
@@ -264,7 +264,7 @@ void ScriptExecutionContext::postTask(EventLoopTask* task)
     static_cast<Zig::GlobalObject*>(m_globalObject)->queueTask(task);
 }
 
-// Zig bindings
+// Native bindings
 extern "C" ScriptExecutionContextIdentifier ScriptExecutionContextIdentifier__forGlobalObject(JSC::JSGlobalObject* globalObject)
 {
     return defaultGlobalObject(globalObject)->scriptExecutionContext()->identifier();
diff --git a/src/jsc/bindings/Serialization.cpp b/src/jsc/bindings/Serialization.cpp
index caaec599f81..1919a91d2a3 100644
--- a/src/jsc/bindings/Serialization.cpp
+++ b/src/jsc/bindings/Serialization.cpp
@@ -8,7 +8,7 @@
 using namespace JSC;
 using namespace WebCore;
 
-// Must be synced with bindings.zig's JSValue.SerializedScriptValue.External
+// Must be synced with SerializedScriptValueExternal in src/jsc/JSValue.rs
 struct SerializedValueSlice {
     const uint8_t* bytes;
     size_t size;
diff --git a/src/jsc/bindings/TextCodecWrapper.cpp b/src/jsc/bindings/TextCodecWrapper.cpp
index d7cbb9e7d47..810abbe4741 100644
--- a/src/jsc/bindings/TextCodecWrapper.cpp
+++ b/src/jsc/bindings/TextCodecWrapper.cpp
@@ -1,7 +1,7 @@
 #include "root.h"
 
 /*
- * Wrapper functions for Text Codecs to allow access from Zig
+ * Wrapper functions for Text Codecs to allow access from native code
  */
 
 #include "TextCodec.h"
diff --git a/src/jsc/bindings/TopExceptionScopeBinding.cpp b/src/jsc/bindings/TopExceptionScopeBinding.cpp
index 19113d6fbb8..230f2683cb0 100644
--- a/src/jsc/bindings/TopExceptionScopeBinding.cpp
+++ b/src/jsc/bindings/TopExceptionScopeBinding.cpp
@@ -22,7 +22,7 @@ extern "C" void TopExceptionScope__construct(
     size_t size,
     size_t alignment)
 {
-    // validate that Zig is correct about what the size and alignment should be
+    // validate that the caller is correct about what the size and alignment should be
     ASSERT(size >= sizeof(TopExceptionScope));
     ASSERT(alignment >= alignof(TopExceptionScope));
     ASSERT((uintptr_t)ptr % alignment == 0);
@@ -72,6 +72,6 @@ extern "C" void TopExceptionScope__assertNoException(void* ptr)
 {
     ASSERT((uintptr_t)ptr % alignof(TopExceptionScope) == 0);
     // this function assumes it should assert in all build modes, anything else would be confusing.
-    // Zig should only call TopExceptionScope__assertNoException if it wants the assertion.
+    // Callers should only call TopExceptionScope__assertNoException if they want the assertion.
     static_cast<TopExceptionScope*>(ptr)->releaseAssertNoException();
 }
diff --git a/src/jsc/bindings/ZigException.cpp b/src/jsc/bindings/ZigException.cpp
index aae5b6086e4..3312748ef96 100644
--- a/src/jsc/bindings/ZigException.cpp
+++ b/src/jsc/bindings/ZigException.cpp
@@ -1,7 +1,7 @@
 /**
  * ZigException handling and error processing utilities.
  *
- * This file contains functions for converting JavaScript exceptions to Zig exceptions,
+ * This file contains functions for converting JavaScript exceptions to ZigException,
  * processing stack traces, and collecting source lines.
  */
 #include "root.h"
diff --git a/src/jsc/bindings/ZigGlobalObject.cpp b/src/jsc/bindings/ZigGlobalObject.cpp
index 15858d7bc13..456898e72aa 100644
--- a/src/jsc/bindings/ZigGlobalObject.cpp
+++ b/src/jsc/bindings/ZigGlobalObject.cpp
@@ -355,7 +355,7 @@ extern "C" void* Bun__getVM();
 
 extern "C" void Bun__setDefaultGlobalObject(Zig::GlobalObject* globalObject);
 
-// Declare the Zig functions for LazyProperty initializers
+// Declare the native functions for LazyProperty initializers
 extern "C" JSC::EncodedJSValue BunObject__createBunStdin(JSC::JSGlobalObject*);
 extern "C" JSC::EncodedJSValue BunObject__createBunStderr(JSC::JSGlobalObject*);
 extern "C" JSC::EncodedJSValue BunObject__createBunStdout(JSC::JSGlobalObject*);
@@ -841,8 +841,8 @@ JSC_DEFINE_HOST_FUNCTION(functionEsmLoadSync, (JSC::JSGlobalObject * lexicalGlob
 extern "C" void* Zig__GlobalObject__getModuleRegistryMap(JSC::JSGlobalObject*)
 {
     // The JSC module loader registry is no longer a JS Map; snapshot/restore
-    // is no longer supported. The only Zig declaration of this symbol has no
-    // callers, so this is dead code kept for ABI compatibility.
+    // is no longer supported. This symbol has no callers, so this is dead
+    // code kept for ABI compatibility.
     return nullptr;
 }
 
@@ -1042,10 +1042,6 @@ extern "C" void Bun__handleHandledPromise(Zig::GlobalObject* JSGlobalObject, JSC
 void GlobalObject::promiseRejectionTracker(JSGlobalObject* obj, JSC::JSPromise* promise,
     JSC::JSPromiseRejectionOperation operation)
 {
-    // Zig__GlobalObject__promiseRejectionTracker(
-    //     obj, prom, reject == JSC::JSPromiseRejectionOperation::Reject ? 0 : 1);
-
-    // Do this in C++ for now
     auto* globalObj = static_cast<GlobalObject*>(obj);
 
     switch (operation) {
@@ -3034,8 +3030,8 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
 
 // ===================== start conditional builtin globals =====================
 // These functions register globals based on runtime conditions (e.g. CLI flags,
-// environment variables, etc.). See `Run.addConditionalGlobals()` in bun_js.zig
-// for where these are called.
+// environment variables, etc.). See `add_conditional_globals()` in
+// src/runtime/cli/run_command.rs for where these are called.
 
 /// `globalThis.gc()` is an alias for `Bun.gc(true)`
 /// Note that `vm` is a `VirtualMachine*`
@@ -3621,7 +3617,7 @@ JSC::JSPromise* GlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject,
     memset(&res.result, 0, sizeof res.result);
 
     // require(esm) needs the entire dependency graph to load without yielding
-    // to microtasks. The async fetch path goes through Zig's transpiler thread
+    // to microtasks. The async fetch path goes through the transpiler thread
     // pool; route to the synchronous fetch instead so the returned promise is
     // already fulfilled and the loader keeps draining its private queue (see
     // JSModuleLoader::loadModuleSync / VM::m_synchronousModuleQueue).
@@ -3691,7 +3687,7 @@ JSC::JSValue EvalGlobalObject::moduleLoaderEvaluate(JSGlobalObject* lexicalGloba
         WTF::move(scriptFetcher), sentValue, resumeMode);
     // The new C++ loader propagates the module body's throw out of
     // evaluateNonVirtual; the old JS-side ModuleLoader.js swallowed it before
-    // dispatching here. Don't call back into Zig (which opens an
+    // dispatching here. Don't call back into native code (which opens an
     // ExceptionValidationScope) with an exception still pending.
     RETURN_IF_EXCEPTION(scope, result);
 
@@ -3706,7 +3702,7 @@ JSC::JSValue EvalGlobalObject::moduleLoaderEvaluate(JSGlobalObject* lexicalGloba
         //
         // Instead, when the module yielded, capture the async capability's
         // promise. Its resolution value is the module's final completion
-        // value; the --print loop in bun.js.zig already unwraps promises
+        // value; the --print loop in run_command.rs already unwraps promises
         // via asAnyPromise + Bun__onResolveEntryPointResult.
         JSC::JSValue valueToStore = result;
         if (auto* moduleRecord = dynamicDowncast<JSC::AbstractModuleRecord>(moduleRecordValue)) {
diff --git a/src/jsc/bindings/ZigSourceProvider.cpp b/src/jsc/bindings/ZigSourceProvider.cpp
index e7b3f6e47ab..fa3778b481d 100644
--- a/src/jsc/bindings/ZigSourceProvider.cpp
+++ b/src/jsc/bindings/ZigSourceProvider.cpp
@@ -179,7 +179,7 @@ SourceProvider::~SourceProvider()
         zig__ModuleInfoDeserialized__deinit(static_cast<bun_ModuleInfoDeserialized*>(m_resolvedSource.module_info));
         m_resolvedSource.module_info = nullptr;
     }
-    // The Rust/Zig side hands these as +1 (RuntimeTranspilerStore::run_from_js_thread:
+    // The Rust side hands these as +1 (RuntimeTranspilerStore::run_from_js_thread:
     // `out.dupeRef()` / `out.createIfDifferent(..)`; ModuleLoader paths likewise).
     // #9521 removed the early deref in `create()` because these strings are still
     // read after that point; the matching deref belongs here, once all uses are done.
diff --git a/src/jsc/bindings/bindings.cpp b/src/jsc/bindings/bindings.cpp
index ae3d8986c71..5ddf563c32c 100644
--- a/src/jsc/bindings/bindings.cpp
+++ b/src/jsc/bindings/bindings.cpp
@@ -178,7 +178,7 @@ using namespace WebCore;
 
 typedef uint8_t ExpectFlags;
 
-// Note: keep this in sync with Expect.Flags implementation in zig (at expect.zig)
+// Note: keep this in sync with Flags in src/runtime/test_runner/expect.rs
 // clang disable unused warning
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-variable"
@@ -2244,7 +2244,7 @@ JSC::EncodedJSValue JSGlobalObject__createOutOfMemoryError(JSC::JSGlobalObject*
 
 // Walk a promise's reaction chain to find the async generators awaiting it,
 // and collect them as async StackFrames. Used when an error is created from
-// native code at the top of the event loop (e.g. runFromJSThread in node_fs.zig)
+// native code at the top of the event loop (e.g. run_from_js_thread in node_fs.rs)
 // where there's no JS call stack, but the promise being rejected has an await
 // chain that tells us where the user's code is.
 //
@@ -2611,7 +2611,7 @@ double JSC__JSValue__getLengthIfPropertyExistsInternal(JSC::EncodedJSValue value
 
         if (auto* object = dynamicDowncast<JSObject>(cell)) {
             auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
-            scope.release(); // zig binding handles exceptions
+            scope.release(); // the extern-C caller checks for the pending exception
             JSValue lengthValue = object->getIfPropertyExists(globalObject, globalObject->vm().propertyNames->length);
             RETURN_IF_EXCEPTION(scope, 0);
             if (lengthValue) {
@@ -4946,7 +4946,7 @@ void JSC__VM__holdAPILock(JSC::VM* arg0, void* ctx, void (*callback)(void* arg0)
 }
 
 // The following two functions are copied 1:1 from JSLockHolder to provide a
-// new, more ergonomic binding for interacting with the lock from Zig
+// new, more ergonomic binding for interacting with the lock from native code
 // https://github.com/WebKit/WebKit/blob/main/Source/JavaScriptCore/runtime/JSLock.cpp
 
 extern "C" void JSC__VM__getAPILock(JSC::VM* vm)
@@ -5108,7 +5108,7 @@ JSC::EncodedJSValue JSC__JSValue__createUninitializedUint8Array(JSC::JSGlobalObj
     return JSC::JSValue::encode(value);
 }
 
-// This enum must match the zig enum in src/jsc/bindings/JSValue.zig JSValue.BuiltinName
+// This enum must match BuiltinName in src/jsc/lib.rs
 enum class BuiltinNamesMap : uint8_t {
     method,
     headers,
@@ -6463,8 +6463,8 @@ extern "C" JSC::EncodedJSValue Bun__REPL__evaluate(
         return JSC::JSValue::encode(JSC::jsUndefined());
     }
 
-    // Note: _ is now set in Zig code (repl.zig) after extracting the value from
-    // the REPL transform wrapper. We don't set it here anymore.
+    // Note: _ is now set in src/runtime/cli/repl.rs after extracting the value
+    // from the REPL transform wrapper. We don't set it here anymore.
 
     return JSC::JSValue::encode(result);
 }
diff --git a/src/jsc/bindings/headers-handwritten.h b/src/jsc/bindings/headers-handwritten.h
index 3d2cdd525e8..a36fb80aecb 100644
--- a/src/jsc/bindings/headers-handwritten.h
+++ b/src/jsc/bindings/headers-handwritten.h
@@ -47,7 +47,7 @@ enum class BunStringTag : uint8_t {
     Empty = 4,
 };
 
-/// Mirrors `bun.uws.ResponseKind` in src/uws_sys/uws.zig.
+/// Mirrors `ResponseKind` in src/uws/lib.rs.
 enum class UWSResponseKind : int32_t {
     TCP = 0,
     SSL = 1,
@@ -252,7 +252,7 @@ const JSErrorCode JSErrorCodeOutOfMemoryError = 8;
 const JSErrorCode JSErrorCodeStackOverflow = 253;
 const JSErrorCode JSErrorCodeUserErrorCode = 254;
 
-// Must be kept in sync with bun.schema.api.Loader in schema.zig
+// Must be kept in sync with Loader in src/options_types/schema.rs
 typedef uint8_t BunLoaderType;
 const BunLoaderType BunLoaderTypeNone = 254;
 const BunLoaderType BunLoaderTypeJSX = 1;
@@ -407,7 +407,7 @@ extern "C" const char* Bun__version;
 extern "C" const char* Bun__version_with_sha;
 
 // Version exports removed - now handled by CMake-generated header (bun_dependency_versions.h)
-// Only keep the ones still exported from Zig
+// Only keep the ones still exported from native code
 extern "C" const char* Bun__versions_uws;
 extern "C" const char* Bun__versions_usockets;
 
diff --git a/src/jsc/bindings/image_coregraphics_shim.cpp b/src/jsc/bindings/image_coregraphics_shim.cpp
index b92628805e2..da2242c4ade 100644
--- a/src/jsc/bindings/image_coregraphics_shim.cpp
+++ b/src/jsc/bindings/image_coregraphics_shim.cpp
@@ -1,16 +1,14 @@
 // CoreGraphics / ImageIO backend for Bun.Image — implemented entirely in C++.
 //
-// Calling dlsym'd CG/ImageIO functions through Zig function pointers crashed
-// on x86_64 macOS (arm64 was fine). Rather than thunking call-by-call, this
-// file owns every framework call: clang generates the SysV/AAPCS64 prologues
-// natively, and the Zig boundary is two extern-C entry points with only
-// scalar/pointer args.
+// This file owns every framework call: clang generates the SysV/AAPCS64
+// prologues natively, and the FFI boundary is two extern-C entry points with
+// only scalar/pointer args.
 //
 // Decode renders to RGBA via vImage rather than CGBitmapContext+DrawImage:
 // CGBitmapContext refuses non-premultiplied alpha, so the old draw-then-
 // unpremultiply path lost ±1 LSB on RGB wherever α<255 — and worse, the
 // default source-over blend composited the image *over* whatever the caller's
-// uninitialised buffer held (0xAA in Zig debug). vImageBuffer_InitWithCGImage
+// uninitialised buffer held. vImageBuffer_InitWithCGImage
 // converts to a caller-chosen pixel format directly — including straight
 // alpha — so PNG round-trip stays byte-exact and we drop the manual unpremul
 // loop. Encode likewise wraps the straight-alpha buffer in a CGImage via
@@ -260,8 +258,8 @@ enum : int32_t { CG_OK = 0,
 
 // Decode `bytes[0..len)` into a caller-allocated RGBA8 buffer.
 // Two-phase: pass `out=nullptr` to get dimensions; then call again with a
-// buffer of `w*h*4` to fill it. Avoids allocating in C++ so the Zig side owns
-// the buffer in `bun.default_allocator` like every other decode path.
+// buffer of `w*h*4` to fill it. Avoids allocating in C++ so the caller owns
+// the buffer like every other decode path.
 int32_t bun_coregraphics_decode(const uint8_t* bytes, size_t len, uint64_t max_pixels,
     uint32_t* out_w, uint32_t* out_h, uint8_t* out)
 {
@@ -314,8 +312,8 @@ int32_t bun_coregraphics_decode(const uint8_t* bytes, size_t len, uint64_t max_p
     auto rc = s->vImageBuffer_InitWithCGImage(&buf, &fmt, nullptr, r.img, kBunVImageNoAllocate);
     // The contract is that kvImageNoAllocate honours buf.data exactly, but be
     // defensive: an OS that ignored the flag would set buf.data to its own
-    // malloc and leave `out` uninitialised, which on a Zig debug build is
-    // 0xAA — that's the garbage we shipped before the constant was fixed.
+    // malloc and leave `out` uninitialised — that's the garbage we shipped
+    // before the constant was fixed.
     if (rc != 0 || buf.data != out) return CG_DECODE_FAILED;
     return CG_OK;
 }
@@ -334,7 +332,7 @@ int32_t bun_coregraphics_encode(const uint8_t* rgba, uint32_t width, uint32_t he
     Pool pool(s);
     // Thread-local pending result so the size-probe and the copy-out share one
     // encode. Safe: each WorkPool thread runs at most one PipelineTask at a
-    // time, and the two calls are back-to-back in codecs.zig.
+    // time, and the two calls are back-to-back in backend_coregraphics.rs encode().
     thread_local CFRef pending = nullptr;
     if (out && pending) {
         long n = s->CFDataGetLength(pending);
@@ -425,8 +423,8 @@ int32_t bun_coregraphics_encode(const uint8_t* rgba, uint32_t width, uint32_t he
 
 // ── Geometry via vImage ────────────────────────────────────────────────────
 //
-// These take packed RGBA8 (rowBytes = w*4) on both ends so the Zig side can
-// keep allocating with `bun.default_allocator`. The ARGB8888 kernels are
+// These take packed RGBA8 (rowBytes = w*4) on both ends so the caller can
+// keep using its own allocator. The ARGB8888 kernels are
 // channel-order agnostic for 4×u8, so RGBA works without a permute. They run
 // on Apple's AMX units on M-series — typically 2-4× the Highway path — and we
 // already have Accelerate dlopened for decode, so the only cost is four more
@@ -555,8 +553,8 @@ int64_t bun_coregraphics_clipboard_change_count()
 } // extern "C"
 
 #else
-// Non-Apple: stubs so the link succeeds; Zig only references these under
-// Environment.isMac so they're dead code, but LTO needs the definitions.
+// Non-Apple: stubs so the link succeeds; callers only reference these on
+// macOS so they're dead code, but LTO needs the definitions.
 extern "C" int bun_coregraphics_decode(const void*, unsigned long, unsigned long long, void*, void*, void*) { return 1; }
 extern "C" int bun_coregraphics_encode(const void*, unsigned, unsigned, int, int, void*, void*) { return 1; }
 extern "C" int bun_coregraphics_scale(const void*, unsigned, unsigned, void*, unsigned, unsigned) { return 1; }
diff --git a/src/jsc/bindings/image_resize.cpp b/src/jsc/bindings/image_resize.cpp
index 9f75f745efa..516fbf401fc 100644
--- a/src/jsc/bindings/image_resize.cpp
+++ b/src/jsc/bindings/image_resize.cpp
@@ -245,7 +245,7 @@ static void FlipVImpl(const uint8_t* HWY_RESTRICT src, size_t w, size_t h, uint8
 // Nearest-palette index for one RGBA point. Squared Euclidean over all four
 // channels; SIMD across palette entries (4 entries' R/G/B/A laid out as
 // contiguous u8, so we load 16 at a time and compute 4 distances per step on
-// targets where Lanes(u32) ≥ 4). Used by quantize.zig's Floyd–Steinberg
+// targets where Lanes(u32) ≥ 4). Used by quantize.rs's Floyd–Steinberg
 // mapper — the diffusion itself is serial, but this inner search is hot and
 // parallelisable.
 static uint32_t NearestPaletteImpl(const uint8_t* HWY_RESTRICT palette, uint32_t k,
@@ -502,9 +502,8 @@ struct ScratchLayout {
 
 extern "C" {
 
-// How many bytes of scratch the resize needs. Caller (Zig) allocates this
-// alongside the output in ONE bun.default_allocator block — zero mallocs in
-// this TU.
+// How many bytes of scratch the resize needs. The caller allocates this
+// alongside the output in ONE allocation — zero mallocs in this TU.
 size_t bun_image_resize_scratch_size(int32_t src_w, int32_t src_h, int32_t dst_w, int32_t dst_h, int32_t filter_kind)
 {
     if (src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0) return 0;
diff --git a/src/jsc/bindings/image_wic_shim.cpp b/src/jsc/bindings/image_wic_shim.cpp
index 7aa68389a8f..fe9796980e2 100644
--- a/src/jsc/bindings/image_wic_shim.cpp
+++ b/src/jsc/bindings/image_wic_shim.cpp
@@ -1,6 +1,6 @@
 // Thin C wrapper around the one WIC interaction whose ABI is too fiddly to
-// hand-roll from Zig: IPropertyBag2::Write with a VARIANT. The rest of the
-// WIC backend (vtable-shaped COM calls) lives in src/image/backend_wic.zig
+// hand-roll over FFI: IPropertyBag2::Write with a VARIANT. The rest of the
+// WIC backend (vtable-shaped COM calls) lives in src/runtime/image/backend_wic.rs
 // because those are plain function-pointer tables and have been stable; this
 // file exists so the SDK's own <oaidl.h> definition of VARIANT (with its
 // union/BRECORD/DECIMAL padding) is the source of truth instead of an extern
@@ -8,7 +8,7 @@
 //
 // Kept header-light: only the option name + a float go in, so if we later
 // need more knobs (CompressionQuality, HeifCompressionMethod) they're one
-// branch each rather than a Zig-side VARIANT for every type.
+// branch each rather than an FFI-side VARIANT for every type.
 
 #if defined(_WIN32)
 
@@ -55,7 +55,7 @@ extern "C" int32_t bun_wic_propbag_write_u8(void* props, const wchar_t* name, ui
 }
 
 #else
-// Stubs so the symbols exist everywhere; backend_wic.zig is Windows-only so
+// Stubs so the symbols exist everywhere; backend_wic.rs is Windows-only so
 // these are never called, but the linker wants them.
 extern "C" int bun_wic_propbag_write_f32(void*, const void*, float) { return 0; }
 extern "C" int bun_wic_propbag_write_u8(void*, const void*, unsigned char) { return 0; }
diff --git a/src/jsc/bindings/napi.cpp b/src/jsc/bindings/napi.cpp
index 6e7749b54e1..8fef5dcfa30 100644
--- a/src/jsc/bindings/napi.cpp
+++ b/src/jsc/bindings/napi.cpp
@@ -2226,7 +2226,7 @@ extern "C" napi_status napi_get_value_int64(napi_env env, napi_value value, int6
     NAPI_RETURN_SUCCESS(env);
 }
 
-// must match src/runtime/node/types.zig#Encoding, which matches WebCore::BufferEncodingType
+// must match Encoding in src/runtime/node/types.rs, which matches WebCore::BufferEncodingType
 enum class NapiStringEncoding : uint8_t {
     utf8 = static_cast<uint8_t>(WebCore::BufferEncodingType::utf8),
     utf16 = static_cast<uint8_t>(WebCore::BufferEncodingType::utf16le),
@@ -2866,9 +2866,9 @@ extern "C" napi_status napi_call_function(napi_env env, napi_value recv,
     // Ideally, funcValue is never of type AsyncContextFrame, as that type
     // should never be exposed to user-code. To preserve async local storage
     // contexts across napi_threadsafe_callback, AsyncContextFrame is created.
-    // An alternative here would be to unwrap the frame in napi.zig
-    // ThreadSafeCallback.call, but doing the work assigning and restoring the
-    // global state is not trivial since there are no Zig bindings for that.
+    // An alternative here would be to unwrap the frame on the native side
+    // (ThreadSafeFunction in src/runtime/napi/napi_body.rs), but doing the work
+    // assigning and restoring the global state is not trivial there.
     // Most, if not all, threadsafe callbacks will not pass the callback to JS,
     // they will just call it with this function.
     NAPI_RETURN_EARLY_IF_FALSE(env, funcValue.isCallable() || dynamicDowncast<AsyncContextFrame>(funcValue), napi_invalid_arg);
diff --git a/src/jsc/bindings/sliceAnsi.cpp b/src/jsc/bindings/sliceAnsi.cpp
index 600b5764a90..a3d61c8c2ec 100644
--- a/src/jsc/bindings/sliceAnsi.cpp
+++ b/src/jsc/bindings/sliceAnsi.cpp
@@ -6,7 +6,7 @@
 #include <wtf/text/StringBuilder.h>
 #include <wtf/Vector.h>
 
-// Zig exports for visible width and grapheme break
+// Native exports (implemented in stringWidth.cpp) for visible width and grapheme break
 extern "C" uint8_t Bun__codepointWidth(uint32_t cp, bool ambiguous_as_wide);
 extern "C" bool Bun__graphemeBreak(uint32_t cp1, uint32_t cp2, uint8_t* state);
 extern "C" bool Bun__isEmojiPresentation(uint32_t cp);
@@ -17,13 +17,13 @@ namespace Bun {
 using namespace WTF;
 
 // Shared SIMD/SGR helpers live in ANSIHelpers.h. We keep a local
-// GraphemeWidthState mirror of visible.zig's GraphemeState because these are
+// GraphemeWidthState mirror of stringWidth.cpp's GraphemeState because these are
 // called per-codepoint in the hot loop — extern-call overhead would hurt more
 // than the ~80 lines of duplication. Drift is caught by tests that assert
 // Bun.stringWidth(s) == width of Bun.sliceAnsi(s, 0, N) for edge cases.
 
 // ============================================================================
-// Grapheme-aware Visible Width (mirrors visible.zig GraphemeState; see above)
+// Grapheme-aware Visible Width (mirrors stringWidth.cpp GraphemeState; see above)
 // ============================================================================
 
 struct GraphemeWidthState {
@@ -86,7 +86,7 @@ struct GraphemeWidthState {
         if (keycap)
             return 2;
         if (regionalIndicator)
-            return 1; // Single (unpaired) regional indicator is width 1 — matches visible.zig
+            return 1; // Single (unpaired) regional indicator is width 1
         if (emojiBase && (skinTone || zwj))
             return 2;
         if (vs15 || vs16) {
@@ -101,7 +101,7 @@ struct GraphemeWidthState {
             }
             return 1;
         }
-        // Match visible.zig GraphemeState.width() exactly: return accumulated width
+        // Match stringWidth.cpp GraphemeState::width() exactly: return accumulated width
         // (may be 0 for zero-width-only clusters like U+200B ZWSP).
         return static_cast<uint8_t>(nonEmojiWidth);
     }
diff --git a/src/jsc/bindings/stringWidth.cpp b/src/jsc/bindings/stringWidth.cpp
index ff51eaa4543..9dd05beae80 100644
--- a/src/jsc/bindings/stringWidth.cpp
+++ b/src/jsc/bindings/stringWidth.cpp
@@ -9,7 +9,7 @@
 // autovectorizer. Escape-sequence scanning reuses the WTF::SIMD helpers in
 // ANSIHelpers.h shared with stripANSI/wrapAnsi/sliceAnsi.
 //
-// Rust/Zig callers (console.table column sizing, the markdown ANSI renderer)
+// Rust callers (console.table column sizing, the markdown ANSI renderer)
 // and sliceAnsi.cpp/wrapAnsi.cpp consume the `Bun__*` C exports at the bottom
 // of this file.
 
diff --git a/src/jsc/bindings/stringWidthTables.h b/src/jsc/bindings/stringWidthTables.h
index 2049c322d0f..841d1597232 100644
--- a/src/jsc/bindings/stringWidthTables.h
+++ b/src/jsc/bindings/stringWidthTables.h
@@ -30,9 +30,7 @@
 //   ```
 //
 // - The 3-stage codepoint classification table fuses the uucode-derived
-//   grapheme break classes (previously generated into
-//   src/string/immutable/grapheme_tables.zig, `zig build generate-grapheme-tables`)
-//   with the width and emoji data above. Each stage3 byte packs
+//   grapheme break classes with the width and emoji data above. Each stage3 byte packs
 //   GraphemeBreakClass (bits 0-4), width class (bits 5-6) and the Emoji
 //   property (bit 7) — see the banner above kGraphemeBreakStage1 and
 //   stringWidth.cpp. Regenerate with `bun scripts/generate-stringwidth-tables.mjs`.
diff --git a/src/jsc/bindings/webcore/JSWebSocket.cpp b/src/jsc/bindings/webcore/JSWebSocket.cpp
index 1cdac6e59df..24fe06a9eda 100644
--- a/src/jsc/bindings/webcore/JSWebSocket.cpp
+++ b/src/jsc/bindings/webcore/JSWebSocket.cpp
@@ -213,7 +213,7 @@ static inline JSC::EncodedJSValue constructJSWebSocket3(JSGlobalObject* lexicalG
 
     Vector<String> protocols;
     int rejectUnauthorized = -1;
-    // Zig heap SSLConfig. RAII — freed on any early return, moved into
+    // Native heap SSLConfig. RAII — freed on any early return, moved into
     // WebSocket::create() on success.
     WebSocketSSLConfigPtr sslConfig;
     auto headersInit = std::optional<Converter<IDLUnion<IDLSequence<IDLSequence<IDLByteString>>, IDLRecord<IDLByteString, IDLByteString>>>::ReturnType>();
@@ -254,7 +254,7 @@ static inline JSC::EncodedJSValue constructJSWebSocket3(JSGlobalObject* lexicalG
             }
         }
 
-        // Parse TLS options using Zig's SSLConfig.fromJS for full TLS option support
+        // Parse TLS options using the native SSLConfig parser for full TLS option support
         JSValue tlsOptionsValue = Bun::getOwnPropertyIfExists(globalObject, options, PropertyName(Identifier::fromString(vm, "tls"_s)));
         RETURN_IF_EXCEPTION(throwScope, {});
         if (tlsOptionsValue && !tlsOptionsValue.isUndefinedOrNull() && tlsOptionsValue.isObject()) {
@@ -267,7 +267,7 @@ static inline JSC::EncodedJSValue constructJSWebSocket3(JSGlobalObject* lexicalG
                 }
             }
 
-            // Parse full TLS options using Zig's SSLConfig.fromJS
+            // Parse full TLS options using the native SSLConfig parser
             sslConfig = WebSocketSSLConfigPtr { Bun__WebSocket__parseSSLConfig(globalObject, JSValue::encode(tlsOptionsValue)) };
             RETURN_IF_EXCEPTION(throwScope, {});
         }
diff --git a/src/jsc/bindings/webcore/WebSocket.cpp b/src/jsc/bindings/webcore/WebSocket.cpp
index 08971a3bb30..89203ec56d0 100644
--- a/src/jsc/bindings/webcore/WebSocket.cpp
+++ b/src/jsc/bindings/webcore/WebSocket.cpp
@@ -550,7 +550,7 @@ ExceptionOr<void> WebSocket::connect(const String& url, const Vector<String>& pr
     // Materialize host/path as WTF::String so the BunString wrappers hold a
     // stable WTFStringImpl backing (preserving 8-bit vs UTF-16 encoding).
     // ZigString wrappers over non-ASCII Latin1/UTF-16 data lose the encoding
-    // tag and corrupt the HTTP upgrade request build in Zig.
+    // tag and corrupt the HTTP upgrade request build on the native side.
     String hostString = m_url.host().toString();
     auto resource = resourceName(m_url);
     String unixSocketPathString;
@@ -603,7 +603,7 @@ ExceptionOr<void> WebSocket::connect(const String& url, const Vector<String>& pr
         port = userPort.value();
     }
 
-    // Hold WTF::Strings so the BunString wrappers stay valid for the Zig call.
+    // Hold WTF::Strings so the BunString wrappers stay valid for the native call.
     Vector<String, 8> headerNameStrings;
     Vector<String, 8> headerValueStrings;
     Vector<BunString, 8> headerNames;
@@ -694,7 +694,7 @@ ExceptionOr<void> WebSocket::connect(const String& url, const Vector<String>& pr
     }
     BunString targetAuth = Bun::toString(targetAuthorization);
 
-    // Pass SSLConfig pointer to Zig (ownership transferred - Zig will deinit when connection closes)
+    // Pass SSLConfig pointer to the upgrade client (ownership transferred - it is freed when the connection closes)
     // After this call, m_sslConfig should not be used by C++ anymore
     void* sslConfig = m_sslConfig.release();
 
@@ -917,7 +917,7 @@ void WebSocket::sendWebSocketString(const String& message, const Opcode op)
 
 // Called from close()/terminate() while m_state == CONNECTING.
 //
-// The Zig-side upgrade client's cancel() clears its back-pointer to us
+// The native upgrade client's cancel() clears its back-pointer to us
 // without calling didAbruptClose, so none of didConnect /
 // didFailWithErrorCode / didClose will ever fire for this socket. We
 // must therefore finish the close ourselves: cancel the upgrade, queue
diff --git a/src/jsc/bindings/webcore/WebSocket.h b/src/jsc/bindings/webcore/WebSocket.h
index 05653925061..a0c1ada560d 100644
--- a/src/jsc/bindings/webcore/WebSocket.h
+++ b/src/jsc/bindings/webcore/WebSocket.h
@@ -60,10 +60,10 @@ namespace WebCore {
 
 class Blob;
 
-// Move-only owning handle for the Zig heap-allocated SSLConfig returned by
+// Move-only owning handle for the natively heap-allocated SSLConfig returned by
 // Bun__WebSocket__parseSSLConfig. The SSLConfig holds duped cert/key/CA
 // strings, so every exception / early-return path between parsing and the
-// Zig upgrade client taking ownership must free it. Wrapping the raw `void*`
+// upgrade client taking ownership must free it. Wrapping the raw `void*`
 // in this RAII type lets normal C++ destruction handle all of those paths
 // without ad-hoc scope guards or manual frees at each call site.
 class WebSocketSSLConfigPtr {
@@ -91,7 +91,7 @@ class WebSocketSSLConfigPtr {
 
     explicit operator bool() const { return m_ptr != nullptr; }
 
-    // Transfer ownership out to the Zig upgrade client; after this the
+    // Transfer ownership out to the upgrade client; after this the
     // destructor is a no-op.
     void* release() { return std::exchange(m_ptr, nullptr); }
 
@@ -344,7 +344,7 @@ class WebSocket final : public RefCounted<WebSocket>, public EventTargetWithInli
     ConnectedWebSocketKind m_connectedWebSocketKind { ConnectedWebSocketKind::None };
     size_t m_pendingActivityCount { 0 };
 
-    // TLS options (Zig heap SSLConfig — ownership is released to the Zig
+    // TLS options (native heap SSLConfig — ownership is released to the
     // upgrade client in connect(); freed by ~WebSocketSSLConfigPtr otherwise).
     WebSocketSSLConfigPtr m_sslConfig;
 
diff --git a/src/jsc/bindings/webcore/WebSocketDeflate.h b/src/jsc/bindings/webcore/WebSocketDeflate.h
index 2ac79e8614d..3f81b3e938a 100644
--- a/src/jsc/bindings/webcore/WebSocketDeflate.h
+++ b/src/jsc/bindings/webcore/WebSocketDeflate.h
@@ -2,7 +2,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-// This must match the layout of WebSocketDeflate.Params in WebSocketDeflate.zig
+// This must match the layout of Params in src/http_jsc/websocket_client/WebSocketDeflate.rs
 typedef struct {
     uint8_t server_max_window_bits;
     uint8_t client_max_window_bits;
diff --git a/src/jsc/bindings/webcore/Worker.cpp b/src/jsc/bindings/webcore/Worker.cpp
index d67e36a5152..a1c5c9b5086 100644
--- a/src/jsc/bindings/webcore/Worker.cpp
+++ b/src/jsc/bindings/webcore/Worker.cpp
@@ -50,12 +50,12 @@ namespace WebCore {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(Worker);
 
-// ---- Zig FFI -----------------------------------------------------------------------------------
-// The Zig WebWorker struct is owned by this Worker (freed in ~Worker) and drives the worker
-// thread. See src/jsc/web_worker.zig for the matching side of each entry point.
+// ---- Native FFI --------------------------------------------------------------------------------
+// The native WebWorker struct is owned by this Worker (freed in ~Worker) and drives the worker
+// thread. See src/jsc/web_worker.rs for the matching side of each entry point.
 extern "C" {
 
-// Allocate the Zig WebWorker, take a keep-alive on the parent event loop, and spawn the worker
+// Allocate the native WebWorker, take a keep-alive on the parent event loop, and spawn the worker
 // thread. Returns null (and sets errorMessage) on any failure; nothing needs cleanup in that case.
 void* WebWorker__create(
     Worker* worker,
@@ -87,7 +87,7 @@ void WebWorker__setRef(void* worker, bool ref);
 // thread.
 void WebWorker__releaseParentPollRef(void* worker);
 
-// Free the Zig WebWorker struct. Called from ~Worker.
+// Free the native WebWorker struct. Called from ~Worker.
 void WebWorker__destroy(void* worker);
 
 } // extern "C"
@@ -563,7 +563,7 @@ bool Worker::dispatchExit(int32_t exitCode)
         });
 }
 
-// ---- extern "C" shims (called from Zig) -------------------------------------
+// ---- extern "C" shims (called from native code) ------------------------------
 
 extern "C" void WebWorker__teardownJSCVM(Zig::GlobalObject* globalObject)
 {
@@ -592,9 +592,7 @@ extern "C" void WebWorker__teardownJSCVM(Zig::GlobalObject* globalObject)
     // Drop the single ref taken by `Zig__GlobalObject__create`
     // (`vmPtr->refSuppressingSaferCPPChecking()`), bringing the VM refcount
     // to zero — `~VM` runs here while the API lock is still held by this
-    // thread, exactly as in the Zig build (where `pthread_exit` skipped the
-    // outer `JSLockHolder` destructor and a second `deref` here released its
-    // abandoned ref). The Rust port acquires the API lock manually with no
+    // thread. The worker thread acquires the API lock manually with no
     // extra VM ref (see `WebWorker::thread_main`), so a second `deref` would
     // run `~VM` twice / dereference the freed VM.
     vm.derefSuppressingSaferCPPChecking(); // NOLINT
diff --git a/src/jsc/bindings/webcore/Worker.h b/src/jsc/bindings/webcore/Worker.h
index ccca3fc29e7..ced0e30d8a4 100644
--- a/src/jsc/bindings/webcore/Worker.h
+++ b/src/jsc/bindings/webcore/Worker.h
@@ -49,9 +49,9 @@ struct WorkerOptions;
 
 /// Parent-side handle for a Web or Node worker thread.
 ///
-/// Lifetime / ownership (see also the header comment in web_worker.zig):
+/// Lifetime / ownership (see also the header comment in src/jsc/web_worker.rs):
 ///
-///   JSWorker (GC'd JSCell)  ──Ref──►  Worker  ──owns──►  Zig WebWorker
+///   JSWorker (GC'd JSCell)  ──Ref──►  Worker  ──owns──►  native WebWorker
 ///     parent thread                   ThreadSafeRefCounted   default_allocator
 ///
 /// Refs held on this object:
@@ -62,7 +62,7 @@ struct WorkerOptions;
 ///                            worker thread (EventListenerMap is single-threaded)
 ///   - transient Ref{*this} captured by posted tasks
 ///
-/// impl_ (Zig WebWorker*) is owned by this object and freed in ~Worker(), so
+/// impl_ (native WebWorker*) is owned by this object and freed in ~Worker(), so
 /// terminate()/ref()/unref() can never see a dangling pointer while JS holds
 /// the wrapper.
 ///
@@ -86,7 +86,7 @@ struct WorkerOptions;
 /// accepts and silently drops the message, matching browser/Node semantics.
 ///
 /// m_terminateRequested is orthogonal: set once by terminate(), gates
-/// dispatchEvent()/setKeepAlive(), and is mirrored into the Zig side via
+/// dispatchEvent()/setKeepAlive(), and is mirrored into the native side via
 /// WebWorker__notifyNeedTermination so the worker loop can observe it.
 class Worker final : public ThreadSafeRefCounted<Worker>, public EventTargetWithInlineData, private ContextDestructionObserver {
     WTF_MAKE_TZONE_ALLOCATED(Worker);
@@ -185,7 +185,7 @@ class Worker final : public ThreadSafeRefCounted<Worker>, public EventTargetWith
     // once the worker VM is up).
     const ScriptExecutionContextIdentifier m_clientIdentifier;
 
-    // Owned Zig WebWorker*. Written once in create(), read only on the parent
+    // Owned native WebWorker*. Written once in create(), read only on the parent
     // thread (terminate/setKeepAlive) or in the close task (also parent thread).
     // Freed in ~Worker(). Never null once create() returns successfully.
     void* impl_ { nullptr };
diff --git a/src/jsc/bindings/wrapAnsi.cpp b/src/jsc/bindings/wrapAnsi.cpp
index 54a2d615eb7..2a30ec75d25 100644
--- a/src/jsc/bindings/wrapAnsi.cpp
+++ b/src/jsc/bindings/wrapAnsi.cpp
@@ -8,7 +8,7 @@
 #include <wtf/MathExtras.h>
 #include <cmath>
 
-// Zig exports for visible width calculation
+// Native exports (implemented in stringWidth.cpp) for visible width calculation
 extern "C" size_t Bun__visibleWidthExcludeANSI_utf16(const uint16_t* ptr, size_t len, bool ambiguous_as_wide);
 extern "C" size_t Bun__visibleWidthExcludeANSI_latin1(const uint8_t* ptr, size_t len);
 extern "C" uint8_t Bun__codepointWidth(uint32_t cp, bool ambiguous_as_wide);
@@ -38,7 +38,7 @@ struct WrapAnsiOptions {
 };
 
 // ============================================================================
-// String Width Calculation (using Zig implementation)
+// String Width Calculation
 // ============================================================================
 
 template<typename Char>
diff --git a/src/jsc/bindings/xxhash3.cpp b/src/jsc/bindings/xxhash3.cpp
index 59f1ab50358..b77dd94438c 100644
--- a/src/jsc/bindings/xxhash3.cpp
+++ b/src/jsc/bindings/xxhash3.cpp
@@ -271,7 +271,7 @@ static inline void InitCustomSecret(u8* customSecret, u64 seed64)
 // in the reference — each processes a fixed stripe of 16/32 bytes per iteration
 // with scalar integer ops — so they live outside the Highway per-ISA namespace
 // (no runtime dispatch, no baseline-allowlist entries). Straight C++ beats the
-// generic twox-hash Rust codegen and matches Zig's std.hash.XxHash{32,64}.
+// generic twox-hash Rust codegen.
 //
 // Output is bit-identical to the reference (and the retired twox-hash crate);
 // verified against the reference vectors and SMHasher constants in
@@ -667,13 +667,13 @@ uint64_t highway_xxhash3_64(const uint8_t* input, size_t len, uint64_t seed)
     return bun::xxh3::Hash64(input, len, seed);
 }
 
-// XXH32 one-shot. Scalar; bit-identical to the reference / Zig std.hash.XxHash32.
+// XXH32 one-shot. Scalar; bit-identical to the reference.
 uint32_t highway_xxhash32(const uint8_t* input, size_t len, uint32_t seed)
 {
     return bun::xxh3::XXH32(input, len, seed);
 }
 
-// XXH64 one-shot. Scalar; bit-identical to the reference / Zig std.hash.XxHash64.
+// XXH64 one-shot. Scalar; bit-identical to the reference.
 uint64_t highway_xxhash64(const uint8_t* input, size_t len, uint64_t seed)
 {
     return bun::xxh3::XXH64(input, len, seed);
diff --git a/src/jsc/btjs.rs b/src/jsc/btjs.rs
index 0272ce18402..f884928f8cb 100644
--- a/src/jsc/btjs.rs
+++ b/src/jsc/btjs.rs
@@ -7,13 +7,13 @@ use crate::{CallFrame, VirtualMachineRef as VirtualMachine};
 #[cfg(debug_assertions)]
 use bun_core::{self, Error, err};
 
-// Port of the subset of Zig `std.debug.*` used by btjs.zig: `SelfInfo`, `StackIterator`,
-// plus the symbol-lookup helpers. The frame-pointer unwinder lives in `bun_core::debug`.
+// `SelfInfo`, `StackIterator`, plus the symbol-lookup helpers. The
+// frame-pointer unwinder lives in `bun_core::debug`.
 #[cfg(debug_assertions)]
 mod zig_std_debug {
     pub(super) use bun_core::debug::{StackIterator, frame_address};
 
-    // ── SelfInfo (vendor/zig/lib/std/debug/SelfInfo.zig) ─────────────────
+    // ── SelfInfo ─────────────────────────────────────────────────────────
     // D104: relocated to `bun_crash_handler::debug` (lower-tier crate, also
     // needed by the crash handler's stack-trace printer). Re-export so the
     // in-file callers below compile unchanged.
@@ -24,8 +24,7 @@ mod zig_std_debug {
 #[cfg(debug_assertions)]
 use zig_std_debug::{Module, SelfInfo, SourceLocation, StackIterator, SymbolInfo};
 
-// Port of the subset of `std.io.tty.{Config,Color,detectConfig}` used by btjs.zig
-// (vendor/zig/lib/std/Io/tty.zig). The `windows_api` variant is omitted because
+// A Windows console-API colour variant is deliberately omitted because
 // btjs writes to an in-memory `Vec<u8>` returned to lldb, not to the live console
 // handle, so `SetConsoleTextAttribute` would colour the wrong stream.
 #[cfg(debug_assertions)]
@@ -33,18 +32,17 @@ mod tty {
     // D089: `Config`/`Color`/`set_color` deduped to the canonical port in
     // `bun_crash_handler::debug` (lower-tier crate; `Vec<u8>` already impls
     // `bun_io::Write` so the generic `set_color` covers btjs's in-memory sink).
-    // `detect_config_stdout` stays LOCAL — it ports a *different* Zig call
-    // site (`detectConfig(stdout())` with NO_COLOR/CLICOLOR_FORCE/isatty) than
-    // crash_handler's `detect_tty_config_stderr()` (Output::ENABLE_ANSI_COLORS_STDERR).
+    // `detect_config_stdout` stays LOCAL — it implements a *different* detection
+    // (stdout with NO_COLOR/CLICOLOR_FORCE/isatty) than crash_handler's
+    // `detect_tty_config_stderr()` (Output::ENABLE_ANSI_COLORS_STDERR).
     pub(super) use bun_crash_handler::debug::{Color, TtyConfig as Config};
 
     /// Port of `process.hasNonEmptyEnvVarConstant`.
     fn has_non_empty_env_var(name: &core::ffi::CStr) -> bool {
         #[cfg(windows)]
         {
-            // Zig spec (vendor/zig/lib/std/process.zig:435-446) reads the Win32
-            // environment via `getenvW`, NOT MSVCRT `getenv`. The CRT keeps its
-            // own narrow-string env cache that is not updated by
+            // Read the Win32 environment directly, NOT via MSVCRT `getenv`. The
+            // CRT keeps its own narrow-string env cache that is not updated by
             // `SetEnvironmentVariableW`, which is how Bun mutates env vars at
             // runtime — so `libc::getenv` would silently miss those.
             unsafe extern "system" {
@@ -84,7 +82,7 @@ mod tty {
         }
     }
 
-    /// Port of `std.io.tty.detectConfig(std.fs.File.stdout())`.
+    /// Detect the TTY color configuration for stdout (color env vars + isatty).
     pub(super) fn detect_config_stdout() -> Config {
         let force_color: Option<bool> = if has_non_empty_env_var(c"NO_COLOR") {
             Some(false)
@@ -100,7 +98,7 @@ mod tty {
 
         // `file.getOrEnableAnsiEscapeSupport()` — on POSIX this is `isatty(fd)`;
         // on Windows it tries to enable VT processing on the console handle.
-        // PORT NOTE: btjs writes into a `Vec<u8>` returned to lldb, so the
+        // btjs writes into a `Vec<u8>` returned to lldb, so the
         // `.windows_api` variant (which calls `SetConsoleTextAttribute` mid-write)
         // cannot apply; fall through to escape_codes / no_color.
         if bun_sys::isatty(bun_sys::Fd::stdout()) {
@@ -128,8 +126,8 @@ unsafe extern "C" {
 /// allocated using bun.default_allocator. when called from lldb, it is never freed.
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn dumpBtjsTrace() -> *const c_char {
-    // Zig: `if (comptime bun.Environment.isDebug)` — must use #[cfg], not cfg!(), so the
-    // entire debug impl is DCE'd from release builds.
+    // Must use #[cfg], not cfg!(), so the entire debug impl is DCE'd from
+    // release builds.
     #[cfg(debug_assertions)]
     {
         return dump_btjs_trace_debug_impl();
@@ -167,9 +165,6 @@ fn dump_btjs_trace_debug_impl() -> *const c_char {
         }
     };
 
-    // std.log.info("jsc_llint_begin: {x}", .{@intFromPtr(&jsc_llint_begin)});
-    // std.log.info("jsc_llint_end: {x}", .{@intFromPtr(&jsc_llint_end)});
-
     let tty_config = tty::detect_config_stdout();
 
     let mut it = StackIterator::init(zig_std_debug::frame_address());
@@ -206,7 +201,6 @@ fn print_source_at_address(
     tty_config: tty::Config,
     fp: usize,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     if !cfg!(debug_assertions) {
         unreachable!();
     }
@@ -285,7 +279,6 @@ fn print_unknown_source(
     address: usize,
     tty_config: tty::Config,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     if !cfg!(debug_assertions) {
         unreachable!();
     }
@@ -310,12 +303,10 @@ fn print_line_info(
     symbol_name: &[u8],
     compile_unit_name: &[u8],
     tty_config: tty::Config,
-    // Zig: `comptime printLineFromFile: anytype` — anytype maps to generic/impl-Trait so it
-    // monomorphizes (PORTING.md type map), not a runtime fn pointer.
+    // impl-Trait so it monomorphizes, not a runtime fn pointer.
     print_line_from_file: impl Fn(&mut Vec<u8>, &SourceLocation) -> Result<(), Error>,
     do_llint: bool,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     if !cfg!(debug_assertions) {
         unreachable!();
     }
@@ -382,16 +373,15 @@ fn print_line_from_file_any_os(
     out_stream: &mut Vec<u8>,
     source_location: &SourceLocation,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     if !cfg!(debug_assertions) {
         unreachable!();
     }
 
     // Need this to always block even in async I/O mode, because this could potentially
     // be called from e.g. the event loop code crashing.
-    // TODO(port): Zig used std.fs.cwd().openFile directly (bypassing bun.sys). PORTING.md
-    // forbids std::fs; using bun_sys here. Confirm bun_sys::File is safe to call
-    // from inside a crash handler / lldb (must not re-enter event loop).
+    // `bun_sys::File::open_at`/`read`
+    // are direct openat(2)/read(2) wrappers with no event-loop involvement, so
+    // they are safe to call from inside a crash handler / lldb.
     let f = bun_sys::File::open_at(
         bun_sys::Fd::cwd(),
         &source_location.file_name,
@@ -466,8 +456,7 @@ fn replace_scalar(slice: &mut [u8], from: u8, to: u8) {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Thin forwarders to the `zig_std_debug` port — keep the call-site shape
-// matching the Zig (`std.debug.getSelfDebugInfo()`, `it.getLastError()`, …).
+// Thin forwarders to `zig_std_debug`.
 // ──────────────────────────────────────────────────────────────────────────
 #[cfg(debug_assertions)]
 #[inline]
@@ -489,5 +478,3 @@ fn get_symbol_at_address(module: &mut Module, addr: usize) -> Result<SymbolInfo,
 fn get_module_name_for_address(di: &mut SelfInfo, addr: usize) -> Option<Box<[u8]>> {
     di.get_module_name_for_address(addr)
 }
-
-// ported from: src/jsc/btjs.zig
diff --git a/src/jsc/bun_string_jsc.rs b/src/jsc/bun_string_jsc.rs
index 8cf0cfe6ecf..f93db4d71b5 100644
--- a/src/jsc/bun_string_jsc.rs
+++ b/src/jsc/bun_string_jsc.rs
@@ -94,11 +94,8 @@ pub fn to_js(this: &String, global_object: &JSGlobalObject) -> JsResult<JSValue>
 /// `simulateThrow()` leaves `m_needExceptionCheck` set and the caller's
 /// `to_js_host_call` scope dtor asserts "unchecked exception".
 ///
-/// PORT NOTE: Zig's `toJSDOMURL` returns bare `JSValue` (no `JSError!`), which
-/// is a latent spec gap — it relies on the generated `toJSHostCall` thunk's
-/// `assertExceptionPresenceMatches(normal == .zero)` to satisfy the check. The
-/// Rust port routes the FFI through `from_js_host_call` so the exception is
-/// observed at the call site and surfaced as `Err(JsError::Thrown)`.
+/// Routing the FFI through `from_js_host_call` observes the exception at the
+/// call site and surfaces it as `Err(JsError::Thrown)`.
 #[track_caller]
 pub fn to_jsdomurl(this: &mut String, global_object: &JSGlobalObject) -> JsResult<JSValue> {
     crate::from_js_host_call(global_object, || BunString__toJSDOMURL(global_object, this))
@@ -169,16 +166,15 @@ fn slice_with_underlying_string_to_js_with_options(
             debug_assert!(!this.utf8.is_wtf_allocated());
         }
 
-        // PORT NOTE: Zig checked `utf8.allocator.get()` for "owns an
-        // allocator". The Rust `ZigStringSlice` enum encodes ownership in the
-        // variant: `Owned`/`WTF` ⇒ allocated, `Static` ⇒ borrowed.
+        // `ZigStringSlice` encodes ownership in the variant:
+        // `Owned`/`WTF` ⇒ allocated, `Static` ⇒ borrowed.
         if this.utf8.is_allocated() {
             if let Some(utf16) =
                 strings::to_utf16_alloc(this.utf8.slice(), false, false).unwrap_or(None)
             {
-                // Drop the now-unused utf8 allocation (Zig: `this.utf8.deinit()`).
+                // Drop the now-unused utf8 allocation.
                 this.utf8 = ZigStringSlice::default();
-                // PORT NOTE: ownership of `utf16` is transferred to JSC as an
+                // Ownership of `utf16` is transferred to JSC as an
                 // external string; do not drop it here.
                 let mut utf16 = core::mem::ManuallyDrop::new(utf16);
                 utf16.shrink_to_fit();
@@ -188,7 +184,7 @@ fn slice_with_underlying_string_to_js_with_options(
                     zig_string::to_external_u16(utf16.as_ptr(), utf16.len(), global_object)
                 });
             } else if let Some((ptr, len)) = this.utf8.take_owned_raw() {
-                // PORT NOTE: ownership of utf8 bytes transferred to JSC via
+                // Ownership of the utf8 bytes is transferred to JSC via
                 // `to_external_value`; `take_owned_raw` already cleared `utf8`
                 // and leaked the buffer (mimalloc-freed by JSC).
                 let zig = ZigString::from_bytes(
@@ -231,8 +227,7 @@ pub fn js_escape_reg_exp(global: &JSGlobalObject, call_frame: &CallFrame) -> JsR
 
     let mut buf: Vec<u8> = Vec::new();
 
-    // Zig mapped `error.WriteFailed` → `error.OutOfMemory`; Vec<u8> writes can
-    // only fail on OOM.
+    // Vec<u8> writes can only fail on OOM.
     if bun_core::escape_reg_exp::escape_reg_exp(input.slice(), &mut buf).is_err() {
         return Err(JsError::OutOfMemory);
     }
@@ -258,8 +253,7 @@ pub fn js_escape_reg_exp_for_package_name_matching(
 
     let mut buf: Vec<u8> = Vec::new();
 
-    // Zig mapped `error.WriteFailed` → `error.OutOfMemory`; Vec<u8> writes can
-    // only fail on OOM.
+    // Vec<u8> writes can only fail on OOM.
     if bun_core::escape_reg_exp::escape_reg_exp_for_package_name_matching(input.slice(), &mut buf)
         .is_err()
     {
@@ -278,8 +272,8 @@ pub mod unicode_testing_apis {
 
     /// Used in JS tests, see `internal-for-testing.ts`.
     /// Exercises the `sentinel = true` path of `toUTF16AllocForReal`, which is
-    /// otherwise only reachable from Windows-only code (`bun build --compile`
-    /// metadata in `src/windows.zig`).
+    /// otherwise only reachable from Windows-only `bun build --compile`
+    /// metadata code.
     #[bun_jsc::host_fn]
     pub fn to_utf16_alloc_sentinel(
         global_this: &JSGlobalObject,
@@ -305,9 +299,8 @@ pub mod unicode_testing_apis {
             }
         };
 
-        // PORT NOTE: Rust's `to_utf16_alloc_for_real(.., sentinel=true)` includes
-        // the trailing NUL **in** `result.len()` (Zig's `[:0]u16` kept it past-the-end),
-        // so slice it off before handing to JSC.
+        // `to_utf16_alloc_for_real(.., sentinel=true)` includes the trailing
+        // NUL **in** `result.len()`, so slice it off before handing to JSC.
         debug_assert_eq!(result.last().copied(), Some(0));
 
         let out = String::clone_utf16(&result[..result.len() - 1]);
@@ -316,5 +309,3 @@ pub mod unicode_testing_apis {
         js
     }
 }
-
-// ported from: src/jsc/bun_string_jsc.zig
diff --git a/src/jsc/codegen.rs b/src/jsc/codegen.rs
index 0f06ea8810b..8e151a9ccea 100644
--- a/src/jsc/codegen.rs
+++ b/src/jsc/codegen.rs
@@ -3,20 +3,18 @@ use bun_jsc::{JSGlobalObject, JSValue, JsResult};
 // These fn pointers carry no caller-side preconditions: `JSValue` is a value
 // type (`#[repr(transparent)]` over an encoded i64), and the C++ codegen'd
 // getters/setters they point to only read/write a JS field — so the fn-pointer
-// type is safe-to-call (Zig spec: plain `fn (JSValue) callconv(.c) JSValue`).
+// type is safe-to-call.
 pub(crate) type CallbackGetterFn = extern "C" fn(JSValue) -> JSValue;
 pub(crate) type CallbackSetterFn = extern "C" fn(JSValue, JSValue);
 
-// Zig: `fn CallbackWrapper(comptime Getter, comptime Setter) type { return struct { ... } }`
 // Rust const generics cannot carry function pointers, so the getter/setter are stored as
 // runtime fields instead of monomorphized type parameters.
-// PERF(port): was comptime monomorphization (Getter/Setter were comptime fn ptrs) — profile if hot.
 #[derive(Copy, Clone)]
 pub struct CallbackWrapper {
     get_fn: CallbackGetterFn,
     set_fn: CallbackSetterFn,
-    // PORT NOTE: bare JSValue field is sound here — this wrapper is a by-value stack helper
-    // (Zig methods take `self: @This()`, not `*@This()`); never heap-stored.
+    // Bare JSValue field is sound here — this wrapper is a by-value stack
+    // helper (methods take `self` by value); never heap-stored.
     pub container: JSValue,
 }
 
@@ -54,14 +52,11 @@ impl CallbackWrapper {
         global_object: &JSGlobalObject,
         args: &[JSValue],
     ) -> JsResult<Option<JSValue>> {
-        // PORT NOTE: codegen.zig's `callback.call(globalObject, args)` predates the
-        // 3-arg JSValue.call signature and is dead Zig (never instantiated). The intent
-        // is `callWithGlobalThis`; the JS exception is propagated rather than swallowed.
+        // `call_with_global_this` is the intended semantics here. The JS
+        // exception is propagated rather than swallowed.
         if let Some(callback) = self.get() {
             return Ok(Some(callback.call_with_global_this(global_object, args)?));
         }
         Ok(None)
     }
 }
-
-// ported from: src/jsc/codegen.zig
diff --git a/src/jsc/comptime_string_map_jsc.rs b/src/jsc/comptime_string_map_jsc.rs
index 465d47d43e9..a4aa386a3b2 100644
--- a/src/jsc/comptime_string_map_jsc.rs
+++ b/src/jsc/comptime_string_map_jsc.rs
@@ -3,16 +3,10 @@
 
 use crate::{JSGlobalObject, JSValue, JsResult};
 use bun_core::{OwnedString, String as BunString, Tag};
-// PORT NOTE: `from_js` on `bun_core::String` is provided by the `StringJsc`
-// extension trait, which is allowed here because this file lives in `src/jsc/`.
+// `from_js` on `bun_core::String` is provided by the `StringJsc` extension
+// trait, which is allowed here because this file lives in `src/jsc/`.
 use crate::StringJsc as _;
 
-// PORT NOTE: reshaped for borrowck / Rust generics. Zig took `comptime Map: type`
-// (the `ComptimeStringMap(V, ...)` instantiation, a namespace with static
-// lookup decls). The Rust port of `ComptimeStringMap` is a `phf::Map` *value*
-// (see PORTING.md §Collections), so callers pass a `&'static phf::Map` instead
-// of a type parameter, and `Map.Value` becomes the generic `V`.
-
 /// `map` is the `phf::Map<&'static [u8], V>` instance (Rust port of
 /// `ComptimeStringMap(V, ...)`); `V` is the value type.
 pub fn from_js<V: Copy>(
@@ -23,14 +17,10 @@ pub fn from_js<V: Copy>(
     // `defer str.deref()` — `OwnedString` releases the +1 ref on Drop.
     let str = OwnedString::new(BunString::from_js(input, global_this)?);
     debug_assert!(str.tag() != Tag::Dead);
-    // Zig used `Map.getWithEql(str, bun.String.eqlComptime)`, comparing a
-    // `bun.String` against the map's comptime UTF-8 keys without unconditionally
-    // transcoding. `phf` keys are `&[u8]`, so materialize UTF-8 bytes and do a
-    // direct phf lookup.
-    // PERF(port): avoid the UTF-8 transcode for 8-bit/latin1-backed strings —
+    // `phf` keys are `&[u8]`, so materialize UTF-8 bytes and do a direct phf
+    // lookup.
+    // PERF: avoid the UTF-8 transcode for 8-bit/latin1-backed strings —
     // profile if hot.
     let utf8 = str.to_utf8();
     Ok(map.get(utf8.slice()).copied())
 }
-
-// ported from: src/jsc/comptime_string_map_jsc.zig
diff --git a/src/jsc/cpp.rs b/src/jsc/cpp.rs
index f939e8c0939..c8882bf1be2 100644
--- a/src/jsc/cpp.rs
+++ b/src/jsc/cpp.rs
@@ -2,10 +2,7 @@
 //!
 //! `src/codegen/cppbind.ts` parses every `.cpp` under `src/` for the
 //! `[[ZIG_EXPORT(nothrow|zero_is_throw|false_is_throw|null_is_throw|check_slow)]]`
-//! attribute and emits two siblings into `${BUN_CODEGEN_DIR}`:
-//!
-//!   - `cpp.zig`  — the Zig `bun.cpp.*` namespace (typed wrappers + raw externs)
-//!   - `cpp.rs`   — this module's body
+//! attribute and emits `cpp.rs` (this module's body) into `${BUN_CODEGEN_DIR}`.
 //!
 //! Each throwing function gets a `pub fn` that opens a
 //! [`TopExceptionScope`](crate::TopExceptionScope) /
diff --git a/src/jsc/event_loop.rs b/src/jsc/event_loop.rs
index b19b78e8465..eefced1e637 100644
--- a/src/jsc/event_loop.rs
+++ b/src/jsc/event_loop.rs
@@ -1,4 +1,4 @@
-//! `jsc.EventLoop` — the JS-thread event loop. Port of `src/jsc/event_loop.zig`.
+//! `jsc.EventLoop` — the JS-thread event loop.
 //!
 //! `tick`/`enter`/`exit`/`drain_microtasks`/`run_callback`/concurrent-queue
 //! plumbing are real. The two hot dispatch loops (`tickQueueWithCount`'s
@@ -21,8 +21,7 @@ use crate::{self as jsc, CallFrame, JSGlobalObject, JSValue, JsResult};
 
 // ──────────────────────────────────────────────────────────────────────────
 // Re-exports (thin re-exports of sibling/neighbor modules — do NOT inline
-// bodies). Kept so downstream `bun_jsc::event_loop::Foo` paths match the
-// Zig namespace shape (`jsc.EventLoop.Foo` re-exports at file tail).
+// bodies). Kept so downstream `bun_jsc::event_loop::Foo` paths resolve.
 // ──────────────────────────────────────────────────────────────────────────
 pub use bun_event_loop::AnyTask;
 pub use bun_event_loop::AnyTaskWithExtraContext;
@@ -63,7 +62,7 @@ pub struct EventLoop {
     ///
     /// Having two queues avoids infinite loops creating by calling `setImmediate` in a `setImmediate` callback.
     ///
-    /// PORT NOTE (§Dispatch): payload is `*mut ()` — the real
+    /// Note (§Dispatch): payload is `*mut ()` — the real
     /// `bun_runtime::timer::ImmediateObject` lives in the higher-tier crate
     /// (cycle). Low tier stores the erased pointer; the high-tier hook
     /// (link-time `__bun_run_immediate_task`) casts it back.
@@ -71,16 +70,16 @@ pub struct EventLoop {
     pub next_immediate_tasks: Vec<*mut ()>,
 
     pub concurrent_tasks: ConcurrentQueue,
-    // TODO(port): lifetime — *JSGlobalObject backref owned by VM
+    // BACKREF — `*JSGlobalObject` owned by the VM; outlives this EventLoop.
     pub global: Option<NonNull<JSGlobalObject>>,
-    // TODO(port): lifetime — *VirtualMachine backref (EventLoop is a field of VirtualMachine)
+    // BACKREF — owning `*VirtualMachine` (EventLoop is a value field of it).
     pub virtual_machine: Option<NonNull<VirtualMachine>>,
     pub waker: Option<Waker>,
-    // TODO(port): lifetime — ?*uws.Timer FFI handle
+    // `?*uws.Timer` FFI handle.
     pub forever_timer: Option<NonNull<uws::Timer>>,
     pub deferred_tasks: DeferredTaskQueue::DeferredTaskQueue,
     #[cfg(windows)]
-    // TODO(port): lifetime — ?*uws.Loop FFI handle
+    // `?*uws.Loop` FFI handle.
     pub uws_loop: Option<NonNull<uws::Loop>>,
     #[cfg(not(windows))]
     pub uws_loop: (),
@@ -88,9 +87,9 @@ pub struct EventLoop {
     pub debug: Debug,
     pub entered_event_loop_count: isize,
     pub concurrent_ref: AtomicI32,
-    /// `std.atomic.Value(?*Timer.WTFTimer)` — atomic nullable pointer.
+    /// Atomic nullable pointer to the next-due `WTFTimer`.
     ///
-    /// PORT NOTE (§Dispatch): payload is `*mut ()` — the real
+    /// Note (§Dispatch): payload is `*mut ()` — the real
     /// `bun_runtime::timer::WTFTimer` lives in the higher-tier crate (cycle).
     /// Low tier stores the erased pointer; the high-tier hook installed via
     /// (link-time `__bun_run_wtf_timer`) casts it back.
@@ -179,8 +178,7 @@ impl Debug {
     pub fn exit(&mut self) {}
 }
 
-/// RAII pairing for [`Debug::enter`] / [`Debug::exit`] — the Rust spelling of
-/// Zig's `loop.debug.enter(); defer loop.debug.exit();`. Holds the raw pointer
+/// RAII pairing for [`Debug::enter`] / [`Debug::exit`]. Holds the raw pointer
 /// (not `&mut`) so re-entrant JS callbacks that touch the same loop while the
 /// guard is live don't alias a long-lived mutable borrow.
 #[must_use = "dropping immediately exits the debug scope"]
@@ -216,8 +214,6 @@ mod drain_result {
     pub(super) const JS_TERMINATED: u8 = 1;
 }
 
-// TODO(port): move to jsc_sys
-//
 // `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle; C++ mutating
 // the microtask queue through it is interior mutation invisible to Rust.
 unsafe extern "C" {
@@ -230,7 +226,7 @@ pub enum JsTerminated {
     JSTerminated,
 }
 
-/// Zig: `bun.JSTerminated!T` — short alias for `Result<T, JsTerminated>`.
+/// Short alias for `Result<T, JsTerminated>`.
 pub type JsTerminatedResult<T> = Result<T, JsTerminated>;
 
 impl From<JsTerminated> for bun_core::Error {
@@ -250,7 +246,7 @@ impl From<JsTerminated> for bun_core::Error {
 // isolated `SpawnSyncEventLoop`, not `vm.event_loop()`) plus the VM.
 unsafe extern "Rust" {
     /// `bun_runtime::dispatch::tick_queue_with_count` — the real per-task
-    /// match loop (Zig `tickQueueWithCount`). Link-time resolved.
+    /// match loop. Link-time resolved.
     fn __bun_tick_queue_with_count(
         el: *mut EventLoop,
         vm: *mut VirtualMachine,
@@ -335,7 +331,6 @@ impl EventLoop {
 
         self.entered_event_loop_count -= 1;
         self.debug.exit();
-        // PORT NOTE: reshaped for borrowck — Zig `defer this.debug.exit()` moved to tail; no early returns
     }
 
     /// `enter()` now, `exit()` on drop. Takes the raw VM-owned pointer so the
@@ -365,9 +360,8 @@ impl EventLoop {
             Ok(())
         };
 
-        // PORT NOTE: spec event_loop.zig:92-103 uses `try drainMicrotasksWithGlobal(...)`
-        // which returns BEFORE reaching `entered_event_loop_count -= 1`; only
-        // `defer this.debug.exit()` runs on the error path. Mirror that here.
+        // On the error path, `entered_event_loop_count` is intentionally NOT
+        // decremented; only the debug-scope exit runs.
         if result.is_ok() {
             self.entered_event_loop_count -= 1;
         }
@@ -422,10 +416,9 @@ impl EventLoop {
         self.deferred_tasks.run();
         vm.is_inside_deferred_task_queue.set(false);
 
-        // PORT NOTE: spec event_loop.zig:144-146 guards on `event_loop_handle != null`
-        // but then calls `this.virtual_machine.uwsLoop().drainQuicIfNecessary()`.
-        // On Windows `uwsLoop()` returns `uws.Loop.get()` (NOT `event_loop_handle`,
-        // which is the libuv loop). Mirror that here.
+        // Guard on `event_loop_handle` being set, but drain via `uws_loop_mut()`:
+        // on Windows the uSockets loop (`uws::Loop::get()`) is NOT
+        // `event_loop_handle` (which is the libuv loop).
         if vm.event_loop_handle.is_some() {
             vm.uws_loop_mut().drain_quic_if_necessary();
         }
@@ -441,9 +434,9 @@ impl EventLoop {
 
     #[inline(always)]
     pub fn drain_microtasks(&mut self) -> Result<(), JsTerminated> {
-        // Zig spec (event_loop.zig:153) reads `this.global` directly — match
-        // it via `global_ref()` instead of round-tripping through
-        // `virtual_machine` (saves a dependent load on the hot path).
+        // Read `this.global` directly via `global_ref()` instead of
+        // round-tripping through `virtual_machine` (saves a dependent load on
+        // the hot path).
         let global = self.global_ref();
         let jsc_vm = self.vm_ref().jsc_vm();
         self.drain_microtasks_with_global(global, jsc_vm)
@@ -489,7 +482,7 @@ impl EventLoop {
         let this: *mut Self = core::hint::black_box(this);
         // SAFETY: as above.
         unsafe { (*this).exit() };
-        // PORT NOTE: reshaped for borrowck — `defer this.exit()` moved to tail; no early returns
+        // Note: reshaped for borrowck — `defer this.exit()` moved to tail; no early returns
     }
 
     pub fn run_callback_with_result(
@@ -513,7 +506,7 @@ impl EventLoop {
         let this: *mut Self = core::hint::black_box(this);
         // SAFETY: as above.
         unsafe { (*this).exit() };
-        // PORT NOTE: reshaped for borrowck — `defer this.exit()` moved to tail
+        // Note: reshaped for borrowck — `defer this.exit()` moved to tail
         result
     }
 
@@ -534,7 +527,6 @@ impl EventLoop {
     }
 
     pub fn run_imminent_gc_timer(&mut self) {
-        // Spec event_loop.zig:302-306: `if (swap()) |timer| timer.run(vm)`.
         // The real `WTFTimer` lives in `bun_runtime` (cycle), so the body
         // dispatches through `__bun_run_wtf_timer` (link-time extern).
         let ptr = self
@@ -571,9 +563,6 @@ impl EventLoop {
 
         let mut iter = concurrent.iterator();
         let start_count = self.tasks.readable_length();
-        // PORT NOTE: Zig resets `head = 0` when empty as a micro-opt; LinearFifo
-        // realigns internally on grow, so this is folded into `ensure_unused_capacity`.
-
         let _ = self.tasks.ensure_unused_capacity(count);
 
         // Defer destruction of the ConcurrentTask to avoid issues with pointer aliasing
@@ -595,8 +584,7 @@ impl EventLoop {
                 to_destroy = Some(task);
             }
 
-            // PERF(port): Zig wrote into `writable_slice(0)` and bumped `count`
-            // directly; LinearFifo's fields are private — `write_item` is the
+            // LinearFifo's fields are private — `write_item` is the
             // public path (single-slot copy, same complexity).
             let _ = self.tasks.write_item(task_ref.task);
         }
@@ -610,8 +598,7 @@ impl EventLoop {
     }
 
     fn update_counts(&mut self) {
-        // PORT NOTE: spec event_loop.zig:283-284 unwraps `event_loop_handle.?`
-        // (panic). Do NOT silently drop the swapped delta when the handle is
+        // Do NOT silently drop the swapped delta when the handle is
         // missing — refs queued via `ref_concurrently()` would be lost forever.
         let delta = self.concurrent_ref.swap(0, Ordering::SeqCst);
         let loop_ = self
@@ -645,8 +632,7 @@ impl EventLoop {
     /// Walk `self.virtual_machine.event_loop_handle` via raw-pointer
     /// projection without materializing a `&VirtualMachine` (the VM may be
     /// mutably borrowed elsewhere on the JS thread when libuv completion
-    /// callbacks reach for the loop). Mirrors Zig
-    /// `this.event_loop.virtual_machine.event_loop_handle.?`.
+    /// callbacks reach for the loop).
     #[inline]
     pub fn uv_loop(&self) -> *mut crate::PlatformEventLoop {
         let vm = self.virtual_machine.expect("virtual_machine").as_ptr();
@@ -658,9 +644,9 @@ impl EventLoop {
     }
 
     pub fn usockets_loop(&self) -> *mut uws::Loop {
-        // Spec event_loop.zig:359-365 unwraps `.?` (panic on null). Preserve
-        // that fail-fast contract — callers immediately materialize `&mut *`,
-        // so a null return would be instant UB instead of a clean panic.
+        // Panic on null rather than returning it — callers immediately
+        // materialize `&mut *`, so a null return would be instant UB instead
+        // of a clean panic.
         #[cfg(windows)]
         {
             return self
@@ -686,27 +672,23 @@ impl EventLoop {
         crate::top_scope!(scope, self.global_ref());
         self.entered_event_loop_count += 1;
         self.debug.enter();
-        // PORT NOTE: reshaped for borrowck — Zig
-        //   `defer scope.deinit(); defer { entered_event_loop_count -= 1; debug.exit() }`
-        // is inlined at each return site below (a scopeguard closure would
-        // alias `&mut self`).
+        // The scope/counter/debug-exit cleanup is inlined at each return site
+        // below (a scopeguard closure would alias `&mut self`).
 
         let ctx = self.vm();
         self.tick_concurrent();
         self.process_gc_timer();
 
-        // PORT NOTE: reshaped for borrowck — `vm_ref()` is `&'static`, so the
+        // Note: reshaped for borrowck — `vm_ref()` is `&'static`, so the
         // global borrow detaches from `&self` and survives the `&mut self` call.
         let global = self.vm_ref().global();
         let global_vm = self.vm_ref().jsc_vm();
 
         loop {
-            // Zig: while (tickWithCount > 0) : (handleRejectedPromises) { tickConcurrent } else { ... }
             while self.tick_with_count(ctx) > 0 {
                 self.tick_concurrent();
                 self.global_ref().handle_rejected_promises();
             }
-            // Zig while-else: else branch runs whenever the condition becomes false.
             if self
                 .drain_microtasks_with_global(global, global_vm)
                 .is_err()
@@ -747,7 +729,7 @@ impl EventLoop {
         }
 
         self.vm_ref().suppress_microtask_drain.set(prev);
-        // PORT NOTE: reshaped for borrowck — `defer vm.suppress_microtask_drain = prev` moved to tail
+        // Note: reshaped for borrowck — `defer vm.suppress_microtask_drain = prev` moved to tail
     }
 
     pub fn enqueue_task(&mut self, task: Task) {
@@ -858,8 +840,7 @@ impl EventLoop {
                 requeue.push(task);
             }
         }
-        // PORT NOTE: Zig's `tasks.deinit()` / `clearAndFree()` map to dropping
-        // the owned buffers; reassigning a fresh value drops the old in place.
+        // Reassigning a fresh value drops the old buffers in place.
         self.tasks = Queue::init();
         for task in requeue {
             let _ = self.tasks.write_item(task);
@@ -875,22 +856,22 @@ impl EventLoop {
         }
     }
 
-    /// PORT NOTE (§Dispatch): `task` is an erased
+    /// Note (§Dispatch): `task` is an erased
     /// `*mut bun_runtime::timer::ImmediateObject` — see [`RunImmediateFn`].
     pub fn enqueue_immediate_task(&mut self, task: *mut ()) {
         self.immediate_tasks.push(task);
     }
 
-    /// `tickImmediateTasks` — spec event_loop.zig:239-270. Swaps the two
+    /// `tickImmediateTasks` — swaps the two
     /// immediate queues, drains the now-current batch, then recycles the
     /// drained Vec as the next-tick buffer.
     ///
-    /// PORT NOTE: the real `ImmediateObject` lives in `bun_runtime` (cycle), so
+    /// Note: the real `ImmediateObject` lives in `bun_runtime` (cycle), so
     /// the per-task body dispatches through `__bun_run_immediate_task` (link-
     /// time, definer in `bun_runtime`). The swap always happens — this is
     /// load-bearing for `auto_tick`'s `has_pending_immediate` read, which must
     /// observe the post-swap `immediate_tasks` (next-tick immediates), not the
-    /// un-drained current batch (busy-spin hazard, spec Timer.zig:251-256).
+    /// un-drained current batch (busy-spin hazard).
     ///
     /// # Safety
     /// `virtual_machine` must be the live per-thread VM that owns this `EventLoop`.
@@ -962,8 +943,7 @@ impl EventLoop {
             let vm = self.vm();
             // SAFETY: `vm` is the live owning VM.
             unsafe { (*vm).event_loop_handle = Some(Async::Loop::get()) };
-            // PORT NOTE: reshaped for borrowck — Zig passes `vm.gc_controller` and
-            // `vm` simultaneously; route through raw addr_of to avoid stacked-borrow
+            // Route through raw addr_of to avoid stacked-borrow
             // aliasing of the embedded field with its parent.
             // SAFETY: `vm` is the live owning VM; gc_controller is embedded.
             unsafe {
@@ -978,7 +958,7 @@ impl EventLoop {
                 self.uws_loop = NonNull::new(uws::Loop::get());
             }
         }
-        // PORT NOTE: `EventLoopHandle` lives in `bun_event_loop` (lower tier),
+        // Note: `EventLoopHandle` lives in `bun_event_loop` (lower tier),
         // which cannot name `jsc::EventLoop`, so it stores `*mut ()`. The
         // typed `set_parent_event_loop` extension trait in `bun_uws` expects
         // a `ParentEventLoopHandle` impl, but `EventLoopHandle` already
@@ -1008,8 +988,8 @@ impl EventLoop {
     }
 
     /// `eventLoop().autoTickActive()` — like [`auto_tick`](Self::auto_tick) but
-    /// only sleeps in the uSockets loop while it has active handles
-    /// (spec event_loop.zig:455-493). Dispatches through
+    /// only sleeps in the uSockets loop while it has active handles.
+    /// Dispatches through
     /// `VirtualMachine::auto_tick_active` → `RuntimeHooks::auto_tick_active`
     /// (body lives in `bun_runtime::jsc_hooks` — needs `Timer::All`).
     #[inline]
@@ -1018,7 +998,7 @@ impl EventLoop {
     }
 
     /// `eventLoop().waitForPromise(promise)` — spin tick/auto_tick until
-    /// `promise` settles or execution is forbidden (spec event_loop.zig:553-576).
+    /// `promise` settles or execution is forbidden.
     pub fn wait_for_promise(&mut self, promise: jsc::AnyPromise) {
         let jsc_vm = self.vm_ref().jsc_vm();
         if promise.status() != PromiseStatus::Pending {
@@ -1080,12 +1060,10 @@ impl EventLoop {
         self.wakeup();
     }
 
-    // ──────────── private helpers (port-only; not in Zig) ────────────
-    // TODO(port): lifetime — these unwrap NonNull backrefs; replace with
-    // proper borrow plumbing.
+    // ──────────── private helpers ────────────
     //
-    // PORT NOTE: returns a raw pointer, NOT `&mut VirtualMachine`. `EventLoop`
-    // is a value field of `VirtualMachine`, so materializing `&mut VM` while a
+    // `vm()` returns a raw pointer, NOT `&mut VirtualMachine`. `EventLoop` is a
+    // value field of `VirtualMachine`, so materializing `&mut VM` while a
     // `&EventLoop`/`&mut EventLoop` is live would alias (PORTING.md §Forbidden).
     // Callers must dereference per-field at use sites.
     #[inline(always)]
@@ -1099,7 +1077,7 @@ impl EventLoop {
     /// lifetime. Prefer this over `unsafe { &*self.vm() }` for read-only field
     /// access; whole-struct mutation goes through [`VirtualMachine::as_mut`].
     ///
-    /// node:http perf showed the `Option::unwrap` (vs Zig's bare `vm.*` field
+    /// node:http perf showed the `Option::unwrap` (vs a bare field
     /// load) was one of ~200 diffuse ~15-insn idiom-tax sites contributing the
     /// residual +3.3k insn/req. Force-inline so the unwrap collapses to one
     /// load+test; hot loops that straddle FFI calls hoist it to a local.
@@ -1111,8 +1089,7 @@ impl EventLoop {
     }
     #[inline(always)]
     pub fn global_ref(&self) -> &'static JSGlobalObject {
-        // Zig spec reads `this.global` (direct EventLoop field). `self.global`
-        // is always assigned `vm.global` at every write site
+        // `self.global` is always assigned `vm.global` at every write site
         // (`__bun_spawn_sync_*`, `init_runtime_state`, `reload_global`), so
         // read it directly instead of the vm→global dependent-load chain.
         // `'static` so callers can hold it across `&mut self` (see
@@ -1228,8 +1205,7 @@ impl EventLoop {
                 panic!("EventLoop.enqueueTaskConcurrent: VM has terminated");
             }
         }
-        // Spec event_loop.zig:667 unwraps `batch.front.?`/`batch.last.?` —
-        // preserve the panic-on-empty contract; `push_batch`'s first line is
+        // Panic on an empty batch; `push_batch`'s first line is
         // `set_next(last, null)`, so a null `last` would be UB, not a clean fail.
         assert!(
             !batch.front.is_null() && !batch.last.is_null(),
@@ -1342,9 +1318,8 @@ pub fn event_loop_exit(global: &JSGlobalObject) {
 // `bun_event_loop::any_event_loop::js` extern impls
 //
 // `AnyEventLoop` / `EventLoopHandle` live in the lower-tier `bun_event_loop`
-// crate and cannot name `jsc::EventLoop`. Zig (`src/event_loop/AnyEventLoop.zig`,
-// `src/jsc/EventLoopHandle.zig`) calls these inline because Zig has no crate
-// boundaries. Rather than a runtime-registered vtable, the low tier declares
+// crate and cannot name `jsc::EventLoop`.
+// Rather than a runtime-registered vtable, the low tier declares
 // these as `extern "Rust"` and the bodies live here, resolved at link time —
 // hardcoded, single consumer. Each slot casts the erased `*mut ()` owner back
 // to `*mut EventLoop` and forwards to the real method.
@@ -1362,9 +1337,9 @@ fn el_ref<'a>(owner: *mut ()) -> &'a mut EventLoop {
 // JS thread.
 bun_event_loop::link_impl_JsEventLoop! {
     Jsc for EventLoop => |this| {
-        // Spec event_loop.zig:359 reads the EventLoop's own `uws_loop` field; on
+        // Reads the EventLoop's own `uws_loop` field; on
         // Windows that and `VM::uws_loop()` (= `uws::Loop::get()`) are different
-        // code paths. Route through `usockets_loop()` to match spec semantics.
+        // code paths. Route through `usockets_loop()`.
         iteration_number() => (&*(*this).usockets_loop()).iteration_number(),
         // Return raw to avoid asserting uniqueness — multiple handles may name the
         // same VM (see `EventLoopHandle::file_polls` doc).
@@ -1425,8 +1400,7 @@ pub(crate) fn __bun_js_event_loop_current() -> *mut () {
 // `bun_event_loop::SpawnSyncEventLoop` extern impls
 //
 // `SpawnSyncEventLoop` lives in the lower-tier `bun_event_loop` crate and
-// cannot name `jsc::EventLoop` / `jsc::VirtualMachine`. Zig
-// (`SpawnSyncEventLoop.zig`) did inline field access. The bodies live here as
+// cannot name `jsc::EventLoop` / `jsc::VirtualMachine`. The bodies live here as
 // `#[no_mangle]` Rust-ABI fns, declared `extern "Rust"` on the low-tier side
 // and resolved at link time. Each erased `*mut ()` is a `*mut VirtualMachine`
 // or `*mut EventLoop`; cast back and forward to the real method/field.
@@ -1442,7 +1416,7 @@ fn vm_from_ptr<'a>(vm: *mut ()) -> &'a mut VirtualMachine {
 }
 
 /// Heap-allocate a fresh `EventLoop` bound to `vm`; on Windows, store
-/// `uws_loop` in `event_loop.uws_loop`. Spec SpawnSyncEventLoop.zig:62-68.
+/// `uws_loop` in `event_loop.uws_loop`.
 #[unsafe(no_mangle)]
 pub(crate) fn __bun_spawn_sync_create_event_loop(vm: *mut (), uws_loop: *mut uws::Loop) -> *mut () {
     let vm = vm_from_ptr(vm);
@@ -1467,7 +1441,6 @@ pub(crate) fn __bun_spawn_sync_destroy_event_loop(el: *mut ()) {
 }
 
 /// Re-bind `event_loop.{global, virtual_machine}` to `vm` (prepare path).
-/// Spec SpawnSyncEventLoop.zig:93-95.
 #[unsafe(no_mangle)]
 pub(crate) fn __bun_spawn_sync_event_loop_set_vm(el: *mut (), vm: *mut ()) {
     let el = el_ref(el);
@@ -1507,5 +1480,3 @@ pub(crate) fn __bun_spawn_sync_vm_set_event_loop(vm: *mut (), el: *mut ()) {
 pub(crate) fn __bun_spawn_sync_vm_swap_suppress_microtask_drain(vm: *mut (), v: bool) -> bool {
     vm_from_ptr(vm).suppress_microtask_drain.replace(v)
 }
-
-// ported from: src/jsc/event_loop.zig
diff --git a/src/jsc/ffi_imports.rs b/src/jsc/ffi_imports.rs
index 13b409206a0..816a1f80cb0 100644
--- a/src/jsc/ffi_imports.rs
+++ b/src/jsc/ffi_imports.rs
@@ -16,8 +16,7 @@
 #![allow(non_snake_case, improper_ctypes, clippy::missing_safety_doc)]
 
 /// Declare an `extern` block with the JSC calling convention (`"sysv64"` on
-/// win-x64, `"C"` elsewhere). Mirrors Zig's single `jsc.conv` constant
-/// (`src/jsc/jsc.zig:9`); Rust forbids non-literal ABI strings, so the
+/// win-x64, `"C"` elsewhere). Rust forbids non-literal ABI strings, so the
 /// cfg-split lives here once instead of being hand-duplicated at each site.
 ///
 /// Two call shapes:
diff --git a/src/jsc/fmt_jsc.rs b/src/jsc/fmt_jsc.rs
index 41fbde21b0c..3d65201fc24 100644
--- a/src/jsc/fmt_jsc.rs
+++ b/src/jsc/fmt_jsc.rs
@@ -1,5 +1,5 @@
 //! Bindgen target for `fmt_jsc.bind.ts`. The actual formatters live in
-//! `src/bun_core/fmt.zig`; only the JS-facing wrapper that takes a
+//! `src/bun_core/fmt.rs`; only the JS-facing wrapper that takes a
 //! `&JSGlobalObject` lives here so `bun_core/` stays JSC-free.
 
 use std::io::Write as _;
@@ -65,5 +65,3 @@ pub mod js_bindings {
         Ok(String::clone_utf8(buffer.list.as_slice()))
     }
 }
-
-// ported from: src/jsc/fmt_jsc.zig
diff --git a/src/jsc/generated.rs b/src/jsc/generated.rs
index f5b75aa1b12..f8b5f64ce00 100644
--- a/src/jsc/generated.rs
+++ b/src/jsc/generated.rs
@@ -2,14 +2,13 @@
 //!
 //! Two distinct generators feed this file:
 //!
-//!   1. **bindgen option-structs** (`src/codegen/bindgen.ts` →
-//!      `build/*/codegen/bindgen_generated/*.zig`). Each emits a
+//!   1. **bindgen option-structs** (`src/codegen/bindgen.ts`). Each emits a
 //!      `bindgenConvertJSTo<Name>` C++ shim that fills a `#[repr(C)]` extern
 //!      struct, plus a `convertFromExtern` that reshapes it into the public
-//!      Zig/Rust type. `from_js` glues the two.
+//!      Rust type. `from_js` glues the two.
 //!
-//!   2. **per-class accessor modules** (`src/codegen/generate-classes.ts` →
-//!      `ZigGeneratedClasses.zig`). Each `JS${Type}` exposes
+//!   2. **per-class accessor modules** (`src/codegen/generate-classes.ts`).
+//!      Each `JS${Type}` exposes
 //!      `from_js` / `from_js_direct` / `to_js` / `get_constructor` thin-wrapping
 //!      the `${Type}__fromJS` / `__fromJSDirect` / `__create` / `__getConstructor`
 //!      C++ exports, plus one `${name}_get_cached` / `${name}_set_cached` pair
@@ -33,7 +32,7 @@ use crate::{JSCArrayBuffer, JSGlobalObject, JSValue, JsResult};
 // ──────────────────────────────────────────────────────────────────────────
 // Generic accessor wrappers.
 //
-// The Zig bindgen emits per-field newtypes with `.get()` (optional) /
+// Per-field accessors come in two shapes: `.get()` (optional) /
 // `.items()` (array). Dependents pattern-match on these without naming the
 // wrapper type directly, so a pair of generic carriers covers every field.
 // ──────────────────────────────────────────────────────────────────────────
@@ -71,11 +70,11 @@ impl<T> GenList<T> {
     }
 }
 
-/// Bindgen option-structs for `BunObject.bind.ts` (`GeneratedBindings.zig`).
+/// Bindgen option-structs for `BunObject.bind.ts`.
 pub mod bun_object {
     /// `gen.BunObject.BracesOptions` — `#[repr(C)]` extern struct passed by
-    /// pointer from the C++ dispatch shim. Field order matches
-    /// `GeneratedBindings.zig` (`parse`, `tokenize`).
+    /// pointer from the C++ dispatch shim. Field order is
+    /// `parse`, `tokenize`.
     #[repr(C)]
     #[derive(Default, Clone, Copy)]
     pub struct BracesOptions {
@@ -90,10 +89,11 @@ pub mod bun_object {
 // already provides.
 pub type GenString = bun_core::String;
 
-/// `bun.bun_js.jsc.JSCArrayBuffer.Ref` — adopted `*mut JSC::ArrayBuffer` (refcount
-/// already +1 from C++); deref via `JSC__ArrayBuffer__deref` on drop.
-// TODO(port): wrap in `bun_ptr::ExternalShared<JSCArrayBuffer>` once that crate
-// exposes `adopt(*mut T)`. Raw ptr for now (leaks on drop).
+/// `bun.bun_js.jsc.JSCArrayBuffer.Ref` — adopted `*mut JSC::ArrayBuffer`
+/// (refcount already +1 from C++). Stays a raw `Copy` pointer because it is
+/// also embedded in the `#[repr(C)]` extern unions below, which require POD
+/// arms; the +1 ref is released exactly once via
+/// `release_gen_val_array_buffer` in the owning containers' `Drop` impls.
 pub type GenArrayBuffer = *mut JSCArrayBuffer;
 
 /// `bun.bun_js.webcore.Blob.Ref` — adopted `*mut Blob` (the codegen `m_ctx`
@@ -105,10 +105,10 @@ pub type GenArrayBuffer = *mut JSCArrayBuffer;
 pub type GenBlob = *mut core::ffi::c_void;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Extern-ABI helper layouts (mirror `src/jsc/bindgen.zig`).
+// Extern-ABI helper layouts.
 //
-// `ExternTaggedUnion(&.{T0, T1, ...})` in Zig is `extern struct { data:
-// extern union { @"0": T0, ... }, tag: u8 }`. Rust has no variadic
+// The bindgen's tagged-union extern layout is `{ data: union, tag: u8 }`.
+// Rust has no variadic
 // `#[repr(C)] union`, so we hand-roll the few arities the bindgen actually
 // emits for the structs below. All extern types are `Copy` POD; the
 // `convert_from_extern` step takes ownership of any embedded heap refs.
@@ -175,7 +175,7 @@ fn adopt_opt_string(ptr: RawWTFStringImpl) -> GenOpt<GenString> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// SocketConfigHandlers (build/*/codegen/bindgen_generated/socket_config_handlers.zig)
+// SocketConfigHandlers
 // ──────────────────────────────────────────────────────────────────────────
 
 #[repr(u32)]
@@ -244,7 +244,7 @@ impl SocketConfigHandlers {
     }
 
     pub fn from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<Self> {
-        // Zig wraps this in an `ExceptionValidationScope` for the
+        // Wrapped in an `ExceptionValidationScope` for the
         // `assertExceptionPresenceMatches(!success)` check; the scope must exist
         // *before* the FFI call so the C++ ThrowScope's `simulateThrow()` is
         // satisfied under `validateExceptionChecks=1`.
@@ -258,7 +258,7 @@ impl SocketConfigHandlers {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// SSLConfig (build/*/codegen/bindgen_generated/ssl_config.zig + friends)
+// SSLConfig
 // ──────────────────────────────────────────────────────────────────────────
 
 pub enum SSLConfigAlpnProtocols {
@@ -306,12 +306,8 @@ pub struct SSLConfig {
 // ── refcount release on drop ──────────────────────────────────────────────
 //
 // `adopt_string` adopts a +1 `WTF::StringImpl` ref into a `GenString`
-// (= `bun_core::String`), which is `Copy` and has no `Drop`. The Zig
-// bindgen output instead types these fields as `bun.string.WTFString.Optional`
-// — an RAII `WTF::Ref`-alike whose `deinit()` derefs — and the generated
-// struct's `deinit()` calls `bun.memory.deinit(&field)` on each. We replicate
-// that here by deref-ing every owned string field from the container's `Drop`
-// (matches `bindgen_generated.SSLConfig.deinit` in ssl_config.zig).
+// (= `bun_core::String`), which is `Copy` and has no `Drop`. So the
+// container's `Drop` deref's every owned string field to release those refs.
 //
 // `GenArrayBuffer` / `GenBlob` raw-pointer payloads likewise carry an adopted
 // +1 ref (C++ `ExternTraits<RefPtr<T>>::convertToExtern` calls `leakRef()`);
@@ -482,10 +478,8 @@ impl SSLConfigFile {
                         let elem = unsafe { *arr.data.add(i) };
                         out.push(SSLConfigSingleFile::convert_from_extern(elem));
                     }
-                    // PORT NOTE: Zig `BindgenArray` reuses the allocation in-place
-                    // when `ZigType == ExternType`. This path copies-then-frees the
-                    // source buffer; in-place reuse deferred.
-                    // PERF(port): was BindgenArray in-place convert — profile if it shows up on a hot path.
+                    // This path copies-then-frees the
+                    // source buffer; profile if it shows up on a hot path.
                     // SAFETY: `arr.data` was allocated by `WTF::fastMalloc` ≡ mimalloc
                     // (per crate prereq); `mi_free` is size-agnostic.
                     unsafe { bun_alloc::basic::free_without_size(arr.data.cast()) };
@@ -596,7 +590,7 @@ impl SSLConfig {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// SocketConfig (build/*/codegen/bindgen_generated/socket_config.zig)
+// SocketConfig
 // ──────────────────────────────────────────────────────────────────────────
 
 pub enum SocketConfigTls {
@@ -716,7 +710,7 @@ impl SocketConfig {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Per-class cached-accessor modules (`jsc.Codegen.JS*` in Zig).
+// Per-class cached-accessor modules.
 //
 // Each `JS${Type}` module exposes the C++-side hooks the `.classes.ts`
 // generator emits: `from_js` / `from_js_direct` / `to_js` / `get_constructor`
@@ -952,8 +946,8 @@ macro_rules! impl_js_class_via_generated {
 /// / `to_js` / `to_js_unchecked` / `dangerously_set_ptr` / `get_constructor`,
 /// plus a cached-accessor pair per listed property.
 ///
-/// Mirrors Zig `jsc.Codegen.JS${T}` (one impl, generated once — see
-/// `src/codegen/generate-classes.ts:2428`). All extern symbols use
+/// One impl, generated once — see
+/// `src/codegen/generate-classes.ts:2428`. All extern symbols use
 /// `JSC_CALLCONV` (= sysv64 on win-x64, C otherwise).
 ///
 /// `$Payload` is the native `m_ctx` payload type. When the payload struct is
@@ -1066,10 +1060,9 @@ macro_rules! js_class_module {
                 __create(global.as_ptr(), ptr)
             }
 
-            /// Zig-compat alias for [`to_js`] with `(global, ptr)` argument
-            /// order — matches `jsc.Codegen.JS${T}.toJSUnchecked` so ported
-            /// `Response::to_js` / `Request::to_js` call sites resolve without
-            /// reordering.
+            /// Alias for [`to_js`] with `(global, ptr)` argument
+            /// order, so `Response::to_js` / `Request::to_js` call sites
+            /// resolve without reordering.
             #[inline]
             pub fn to_js_unchecked(global: &JSGlobalObject, ptr: *mut Payload) -> JSValue {
                 to_js(ptr, global)
@@ -1083,8 +1076,7 @@ macro_rules! js_class_module {
 
             /// Detach (`ptr = null`) or replace the wrapped native pointer on
             /// an existing JS wrapper. Returns `false` if `value` is not (a
-            /// subclass of) the wrapper type. Mirrors Zig
-            /// `js.dangerouslySetPtr` (ZigGeneratedClasses.zig).
+            /// subclass of) the wrapper type.
             ///
             /// # Safety
             /// Caller must ensure the previous `m_ctx` is finalized exactly
@@ -1112,7 +1104,7 @@ js_class_module!(JSResumableS3UploadSink = "ResumableS3UploadSink" { ondrain, on
 // `values: ["resolve", "reject"]` in src/runtime/api/Shell.classes.ts.
 js_class_module!(JSShellInterpreter      = "ShellInterpreter"      { resolve, reject });
 // `src/runtime/crypto/crypto.classes.ts` — one entry per `StaticCryptoHasher`
-// monomorphization (Zig: `@field(jsc.Codegen, "JS" ++ name)`). Payload erased;
+// monomorphization. Payload erased;
 // the native struct lives in `bun_runtime::crypto`.
 js_class_module!(JSMD4        = "MD4"        {});
 js_class_module!(JSMD5        = "MD5"        {});
@@ -1122,5 +1114,3 @@ js_class_module!(JSSHA256     = "SHA256"     {});
 js_class_module!(JSSHA384     = "SHA384"     {});
 js_class_module!(JSSHA512     = "SHA512"     {});
 js_class_module!(JSSHA512_256 = "SHA512_256" {});
-
-// ported from: build/*/codegen/bindgen_generated/{socket_config*,ssl_config*}.zig
diff --git a/src/jsc/generated_classes_list.rs b/src/jsc/generated_classes_list.rs
index 9e8ac44d89f..53eccf23d62 100644
--- a/src/jsc/generated_classes_list.rs
+++ b/src/jsc/generated_classes_list.rs
@@ -1,26 +1,16 @@
-//! Port of `src/jsc/generated_classes_list.zig`.
-//!
-//! LAYERING: the Zig `Classes` struct is a flat namespace of
-//! `pub const X = path.to.Y;` aliases mapping each `.classes.ts` class name to
+//! LAYERING: `Classes` is a flat namespace of
+//! `pub use` aliases mapping each `.classes.ts` class name to
 //! its native backing type. Every target lives under `bun.api`, `bun.webcore`,
 //! `bun.bake`, or `bun.SourceMap` — i.e. in the Rust crate graph, in
 //! `bun_runtime` / `bun_sql_jsc` / `bun_sourcemap_jsc`, all of which **depend
 //! on** `bun_jsc`. Re-exporting them from `bun_jsc` would create a hard cycle.
 //!
-//! Zig gets away with this because the whole tree is one lazy compilation unit
-//! and `generated_classes_list.zig` is only consumed by the **Zig** codegen
-//! output (`ZigGeneratedClasses.zig`, via `const Classes = jsc.GeneratedClassesList;`
-//! at `generate-classes.ts:3296`). The **Rust** codegen output
+//! The codegen output
 //! (`generated_classes.rs`) does **not** consume this list — it resolves each
 //! class to its Rust struct via `rustModuleResolver.resolveStruct`
 //! (`generate-classes.ts:2602`/`:3450`) and is `include!`d into `bun_runtime`
 //! where every backing type is already in scope.
 //!
-//! The single in-tree Zig consumer outside codegen
-//! (`src/runtime/node/net/BlockList.zig:255` →
-//! `bun.jsc.GeneratedClassesList.SocketAddress`) is ported as a direct
-//! `crate::socket::SocketAddress` import in `BlockList.rs`.
-//!
 //! Resolution: this file is `#[path]`-mounted from **`bun_runtime/lib.rs`**
 //! (not `bun_jsc/lib.rs`) so every alias resolves via `crate::`. The public
 //! name is `bun_runtime::GeneratedClassesList`; `bun_jsc::GeneratedClassesList`
@@ -127,5 +117,3 @@ pub mod Classes {
     pub use bun_sql_jsc::postgres::PostgresSQLConnection;
     pub use bun_sql_jsc::postgres::PostgresSQLQuery;
 }
-
-// ported from: src/jsc/generated_classes_list.zig
diff --git a/src/jsc/host_fn.rs b/src/jsc/host_fn.rs
index 57d90c6b6ac..d65bf77c176 100644
--- a/src/jsc/host_fn.rs
+++ b/src/jsc/host_fn.rs
@@ -1,15 +1,12 @@
 //! Host function wrappers — the glue between Rust functions and JSC native callbacks.
 //!
-//! In the Zig source this module is almost entirely `comptime`/`@typeInfo` reflection
-//! that inspects a function's signature and emits an `extern callconv(jsc.conv)` shim.
-//! Rust has no equivalent runtime/const reflection, so per PORTING.md §"Comptime
-//! reflection" the wrapping machinery (`toJSHostFn`, `wrapN`, `wrapInstanceMethod`,
-//! `wrapStaticMethod`, `DOMCall`) becomes the `#[bun_jsc::host_fn]` / `#[bun_jsc::host_call]`
-//! proc-macro attributes. This file keeps:
+//! The fn-wrapping machinery lives in the `#[bun_jsc::host_fn]` /
+//! `#[bun_jsc::host_call]` proc-macro attributes. This file keeps:
 //!   - the runtime result-mapping helpers the macros call into,
 //!   - the FFI surface for `JSFunction` creation,
 //!   - `DomEffect` (plain data),
-//! and stubs the reflection-driven generators with `// TODO(port): proc-macro`.
+//! and stubs the reflection-driven generators (callers hand-write the
+//! equivalent decode/dispatch glue until the proc-macros grow those modes).
 
 use core::ffi::c_void;
 
@@ -28,7 +25,7 @@ use crate::{self as jsc, CallFrame, JSGlobalObject, JSValue, JsError, JsResult};
 // across its public API, so there is no foreign unwind to catch either. The
 // closure-taking helpers below (`to_js_host_call`, `host_setter_result`,
 // `host_construct_result`, `host_fn_finalize`) therefore call the user body
-// directly — same end state as Zig `@panic` → `bun.crash_handler`.
+// directly.
 
 // ───────────────────────────── type aliases ──────────────────────────────
 
@@ -52,10 +49,8 @@ pub type JsHostFn = unsafe extern "C" fn(*mut JSGlobalObject, *mut CallFrame) ->
 /// wrap this type into a `JsHostFn`.
 pub type JsHostFnZig = fn(&JSGlobalObject, &CallFrame) -> JsResult<JSValue>;
 
-// Zig: `pub fn JSHostFnZigWithContext(comptime ContextType: type) type`
 pub type JsHostFnZigWithContext<C> = fn(&mut C, &JSGlobalObject, &CallFrame) -> JsResult<JSValue>;
 
-// Zig: `pub fn JSHostFunctionTypeWithContext(comptime ContextType: type) type`
 #[cfg(all(windows, target_arch = "x86_64"))]
 pub type JsHostFunctionTypeWithContext<C> =
     unsafe extern "sysv64" fn(*mut C, *mut JSGlobalObject, *mut CallFrame) -> JSValue;
@@ -86,21 +81,17 @@ macro_rules! jsc_host_abi {
     };
 }
 
-// Capitalized re-exports — Zig spells these `JSHostFn*` (acronym-caps); the
-// PORTING.md acronym rule lowercases to `Js…`, but enough call sites (and the
-// crate-root re-export in lib.rs) use the Zig spelling that both must resolve.
+// Capitalized re-exports — enough call sites (and the crate-root re-export in
+// lib.rs) use the acronym-caps `JSHostFn*` spelling that both must resolve.
 pub use {
     JsHostFn as JSHostFn, JsHostFnZig as JSHostFnZig,
     JsHostFnZigWithContext as JSHostFnZigWithContext,
     JsHostFunctionTypeWithContext as JSHostFunctionTypeWithContext,
 };
 
-// ─────────────────────── comptime fn-wrapping → proc-macro ───────────────────────
+// ─────────────────────── host-fn wrapping (proc-macro) ───────────────────────
 
-// Zig: `pub fn toJSHostFn(comptime functionToWrap: JSHostFnZig) JSHostFn`
-//
-// In Zig this returns a freshly-monomorphized `extern fn` that closes over a
-// `comptime` function pointer. Rust cannot mint an `extern "C" fn` item from a
+// Rust cannot mint an `extern "C" fn` item from a
 // const fn pointer without a proc-macro (no `const fn` ABI thunks). Callers use
 // `#[bun_jsc::host_fn]` instead, which emits the shim and calls
 // `to_js_host_fn_result` for the body.
@@ -109,7 +100,6 @@ pub const fn to_js_host_fn(_function_to_wrap: JsHostFnZig) -> ! {
     panic!("use #[bun_jsc::host_fn] instead of to_js_host_fn()");
 }
 
-// Zig: `pub fn toJSHostFnWithContext(comptime ContextType: type, comptime Function: ...) ...`
 #[doc(hidden)]
 pub const fn to_js_host_fn_with_context<C>(_function: JsHostFnZigWithContext<C>) -> ! {
     panic!("use #[bun_jsc::host_fn(method)] instead of to_js_host_fn_with_context()");
@@ -118,7 +108,6 @@ pub const fn to_js_host_fn_with_context<C>(_function: JsHostFnZigWithContext<C>)
 /// Map a `JsResult<JSValue>` to the raw `JSValue` a host fn must return
 /// (`.zero` when an exception is pending).
 pub fn to_js_host_fn_result(global_this: &JSGlobalObject, result: JsResult<JSValue>) -> JSValue {
-    // Zig: `if (Environment.allow_assert and Environment.is_canary)`
     if Environment::ALLOW_ASSERT && Environment::IS_CANARY {
         let value = match result {
             Ok(v) => v,
@@ -138,8 +127,7 @@ pub fn to_js_host_fn_result(global_this: &JSGlobalObject, result: JsResult<JSVal
 }
 
 fn debug_exception_assertion(global_this: &JSGlobalObject, value: JSValue, func: &'static str) {
-    // Zig passed `comptime func: anytype` and printed its address for `image lookup`.
-    // Rust passes the fn name string (the proc-macro supplies `stringify!(fn_name)`).
+    // `func` is the fn name string (the proc-macro supplies `stringify!(fn_name)`).
     if Environment::IS_DEBUG {
         if !value.is_empty() && global_this.has_exception() {
             let mut formatter = jsc::ConsoleObject::Formatter::new(global_this);
@@ -155,7 +143,7 @@ fn debug_exception_assertion(global_this: &JSGlobalObject, value: JSValue, func:
                 ),
             );
             Output::flush();
-            // `formatter` drops here (Zig: `defer formatter.deinit()`).
+            // `formatter` drops here.
         }
     }
     let _ = func;
@@ -199,8 +187,8 @@ impl IntoHostFnReturn for JsResult<JSValue> {
     fn into_host_fn_return(self) -> JsResult<JSValue> { self }
 }
 
-/// Normalize a setter body's return type to `JsResult<()>`. Zig setters return
-/// `void` or `JSError!void`; both map to `bool` (true on success) at the ABI.
+/// Normalize a setter body's return type to `JsResult<()>`. Setter bodies
+/// return `()` or `JsResult<()>`; both map to `bool` (true on success) at the ABI.
 pub trait IntoHostSetterReturn {
     fn into_host_setter_return(self) -> JsResult<()>;
 }
@@ -212,10 +200,8 @@ impl IntoHostSetterReturn for JsResult<()> {
     #[inline]
     fn into_host_setter_return(self) -> JsResult<()> { self }
 }
-// Some Zig setters return `bool` directly (e.g. `Image.setBackend`): the
-// generated Zig thunk passes the bool through to C++ with no exception-scope
-// wrap, so `false` is the ABI signal for "exception already thrown" (the
-// `catch return false` idiom). The Rust thunk *does* wrap in an
+// Some setters return `bool` directly (e.g. `Image.setBackend`): at the ABI,
+// `false` is the signal for "exception already thrown". The Rust thunk wraps in an
 // `ExceptionValidationScope` and re-derives the ABI bool from `JsResult`, so
 // `false` must round-trip to `Err(Thrown)` here — discarding it (as `Ok(())`)
 // makes `host_setter_result` return `true` and trips
@@ -677,12 +663,11 @@ pub fn host_construct_result<R: IntoHostConstructReturn>(
 
 /// Convert the return value of a function returning an error union into a maybe-empty `JSValue`.
 ///
-/// Zig signature took `comptime function: anytype` + an args tuple and `@call`'d it; in Rust the
-/// caller (the proc-macro expansion) passes a closure that performs the call, so this only handles
-/// the result mapping + exception-scope assertion.
+/// The caller (the proc-macro expansion) passes a closure that performs the call, so this only
+/// handles the result mapping + exception-scope assertion.
 ///
 /// `#[track_caller]` propagates the caller's `Location` through to
-/// `ExceptionValidationScope::init`, replacing Zig's explicit `@src()` argument.
+/// `ExceptionValidationScope::init`.
 #[track_caller]
 pub fn to_js_host_call(
     global_this: &JSGlobalObject,
@@ -708,15 +693,15 @@ pub fn to_js_host_call(
 /// `TopExceptionScope`.
 ///
 /// `#[track_caller]` propagates the caller's `Location` through to
-/// `ExceptionValidationScope::init`, replacing Zig's explicit `@src()` argument.
+/// `ExceptionValidationScope::init`.
 #[track_caller]
 #[inline]
 pub fn from_js_host_call(
     global_this: &JSGlobalObject,
     f: impl FnOnce() -> JSValue,
 ) -> Result<JSValue, JsError> {
-    // Zig: `if (@TypeOf(value) != JSValue) @compileError(...)` — enforced by the
-    // closure return type here. Body is the `[[ZIG_EXPORT(zero_is_throw)]]` shape.
+    // The JSValue-only constraint is enforced by the closure return type here.
+    // Body is the `[[ZIG_EXPORT(zero_is_throw)]]` shape.
     crate::call_zero_is_throw(global_this, f)
 }
 
@@ -724,7 +709,7 @@ pub fn from_js_host_call(
 /// whether an exception was thrown.
 ///
 /// `#[track_caller]` propagates the caller's `Location` through to
-/// `TopExceptionScope::init`, replacing Zig's explicit `@src()` argument.
+/// `TopExceptionScope::init`.
 #[track_caller]
 #[inline]
 pub fn from_js_host_call_generic<R>(
@@ -737,12 +722,13 @@ pub fn from_js_host_call_generic<R>(
     // from_js_host_call_generic is only for functions where the return value tells you nothing
     // about whether an exception was thrown.
     //
-    // TODO(port): static-assert `R != JSValue` (Zig used @compileError; Rust needs a
-    // negative trait bound or specialization — neither stable). A sealed-trait trick could enforce this.
+    // Statically rejecting `R == JSValue` would need a
+    // negative trait bound or specialization (neither stable), so this is enforced
+    // by convention only.
     crate::call_check_slow(global_this, f)
 }
 
-// ───────────────────────── error-set parsing (comptime) ─────────────────────────
+// ───────────────────────── error conversion helpers ─────────────────────────
 
 // For when bubbling up errors to functions that require a C ABI boundary
 // TODO: make this not need a 'global_this'
@@ -755,30 +741,14 @@ pub fn void_from_js_error(err: JsError, global_this: &JSGlobalObject) {
         JsError::Terminated => {}
     }
     // TODO: catch exception, declare throw scope, re-throw
-    // c++ needs to be able to see that zig functions can throw for BUN_JSC_validateExceptionChecks
+    // c++ needs to be able to see that these host functions can throw for BUN_JSC_validateExceptionChecks
 }
 
-// ───────────────────────────── wrapN family ──────────────────────────────
-//
-// Zig `wrap1`..`wrap5` / `wrap4v` each take a `comptime func: anytype`, reflect on
-// its parameter list with `@typeInfo`, and return a fresh `extern fn` of matching
-// arity that forwards through `toJSHostCall`. This is signature reflection —
-// `// TODO(port): proc-macro`. The Rust replacement is a single attribute:
-//
-//     #[bun_jsc::host_call(wrap)]       // -> extern "C"   (wrap1..wrap5)
-//     #[bun_jsc::host_call(wrap, sysv)] // -> jsc.conv ABI (wrap4v)
-//
-// `checkWrapParams` (arity + first-arg-is-*JSGlobalObject assertion) is enforced by
-// the macro at expansion time.
-// TODO(port): proc-macro — `wrap1`..`wrap5`, `wrap4v`, `checkWrapParams`.
-
 // ───────────────────────────── FFI: JSFunction creation ──────────────────────────────
 
 mod private {
     use super::*;
 
-    // TODO(port): move to jsc_sys
-    //
     // safe fn: `JSGlobalObject` is an opaque `UnsafeCell`-backed ZST handle (`&`
     // is ABI-identical to non-null `*mut`); `Option<&ZigString>` is ABI-identical
     // to a nullable `*const ZigString` via the guaranteed null-pointer
@@ -791,8 +761,8 @@ mod private {
             global: &JSGlobalObject,
             symbol_name: Option<&ZigString>,
             arg_count: u32,
-            // Zig `*const JSHostFn` is a fn *pointer*; `JsHostFn` in Rust is already
-            // `unsafe extern "C" fn(...)`, i.e. the pointer type.
+            // `JsHostFn` is already `unsafe extern "C" fn(...)`, i.e. the
+            // fn-pointer type.
             function: JsHostFn,
             data: *mut c_void,
         ) -> JSValue;
@@ -856,8 +826,7 @@ pub fn new_function_with_data(
     data: *mut c_void,
 ) -> JSValue {
     jsc::mark_binding();
-    // Zig: `toJSHostFn(function)` wrapped a `comptime JSHostFnZig` here. In Rust the
-    // caller passes an already-wrapped `JsHostFn` (produced by `#[bun_jsc::host_fn]`).
+    // The caller passes an already-wrapped `JsHostFn` (produced by `#[bun_jsc::host_fn]`).
     private::Bun__CreateFFIFunctionWithDataValue(
         global_object,
         symbol_name,
@@ -877,7 +846,7 @@ pub struct DomEffect {
 
 impl Default for DomEffect {
     fn default() -> Self {
-        // Zig: `std.mem.zeroes([4]ID)` — ID(0) == InvalidAbstractHeap.
+        // All-zero: ID(0) == InvalidAbstractHeap.
         Self {
             reads: [DomEffectId::InvalidAbstractHeap; 4],
             writes: [DomEffectId::InvalidAbstractHeap; 4],
@@ -971,32 +940,18 @@ pub enum DomEffectId {
 
 // ───────────────────────── DOMCall codegen helpers ─────────────────────────
 //
-// `DOMCallArgumentType` / `DOMCallArgumentTypeWrapper` / `DOMCallResultType` map a
-// Zig type to a C++ spec-string at comptime. They feed the C++ codegen
-// (`generate-classes.ts`), not runtime. The proc-macro for `#[bun_jsc::dom_call]`
-// owns this mapping in Rust.
-// TODO(port): proc-macro — DOMCall type→spec-string tables move into the macro crate.
-
-// Zig: `pub fn DOMCall(comptime class_name, comptime Container, comptime functionName,
-//                      comptime dom_effect) type`
-//
-// Returns an `extern struct` that:
-//   - `@export`s `<class>__<fn>__slowpath` / `__fastpath` with `callconv(jsc.conv)`,
-//   - `@extern`s `<class>__<fn>__put`,
-//   - exposes `effect`, `put()`, and `Arguments`.
-//
-// This is link-name synthesis + signature reflection. Rust replacement:
-//
-//     #[bun_jsc::dom_call(class = "Foo", effect = DomEffect::PURE)]
-//     impl Foo { fn bar(...) -> ... { ... }  fn bar_without_type_checks(...) -> ... { ... } }
-//
-// TODO(port): proc-macro — `DOMCall` type-generator.
+// `DOMCallArgumentType` / `DOMCallArgumentTypeWrapper` / `DOMCallResultType`
+// feed the C++ codegen
+// (`generate-classes.ts`), not runtime — there is nothing for the Rust side to
+// hold; the spec-strings stay in the codegen script.
 
-/// Runtime descriptor for a `DOMCall(...)`-generated DOMJIT entry.
+// The hand-written [`DomCall`] descriptor below is the mechanism for DOMJIT
+// entries — call sites write the slow/fast paths and the
+// `<class>__<fn>__put` extern themselves.
+
+/// Runtime descriptor for a DOMJIT entry.
 ///
-/// In Zig `DOMCall` returns a comptime-generated `extern struct` type that
-/// `@export`s `<class>__<fn>__slowpath`/`__fastpath` and `@extern`s
-/// `<class>__<fn>__put`. Until the `#[bun_jsc::dom_call]` proc-macro lands,
+/// Until the `#[bun_jsc::dom_call]` proc-macro lands,
 /// callers (e.g. `bun:ffi`'s `FFIObject`) hand-write the slow/fast paths and
 /// declare the C++-side `*__put` extern themselves; this struct carries just
 /// enough to drive `to_js` (the `put(global, obj)` call that installs the
@@ -1011,44 +966,6 @@ pub struct DomCall {
 
 // ───────────────────────── instance/static method wrapping ─────────────────────────
 
-// Zig: `pub fn InstanceMethodType(comptime Container: type) type`
+// There is no generic argument-decoding wrapper: each call site hand-writes
+// its own argument decoding.
 pub type InstanceMethodType<C> = fn(&mut C, &JSGlobalObject, &CallFrame) -> JsResult<JSValue>;
-
-// Zig: `pub fn wrapInstanceMethod(comptime Container, comptime name, comptime auto_protect)
-//          InstanceMethodType(Container)`
-//
-// This is the heaviest reflection in the file: it iterates `@typeInfo(Fn).params`,
-// pattern-matches each parameter TYPE (`*JSGlobalObject`, `ZigString`,
-// `?jsc.ArrayBuffer`, `*WebCore.Response`, `?HTMLRewriter.ContentOptions`, ...) and
-// emits per-param argument-decoding + error-throwing glue, then `@call`s the target.
-// There is no value-level translation; the entire body is a type-directed code
-// generator. Per PORTING.md §"Comptime reflection":
-//
-// TODO(port): proc-macro — `#[bun_jsc::host_fn(method, auto_protect)]` replaces
-// `wrapInstanceMethod`. The macro must reproduce the per-type decode table:
-//   *Container            -> `this`
-//   *JSGlobalObject       -> `global`
-//   *CallFrame            -> `frame`
-//   Node.StringOrBuffer   -> `StringOrBuffer::from_js(global, arena, arg)?` or throw
-//   ?Node.StringOrBuffer  -> optional of above (null/undefined -> None)
-//   ArrayBuffer           -> `arg.as_array_buffer(global)` or throw "expected TypedArray"
-//   ?ArrayBuffer          -> optional of above
-//   ZigString             -> `arg.get_zig_string(global)?` (throws on undefined/null)
-//   ?HTMLRewriter.ContentOptions -> `{ html: arg.get("html")?.to_boolean() }`
-//   *WebCore.Response     -> `arg.as::<Response>()` or throw "Expected Response object"
-//   *WebCore.Request      -> `arg.as::<Request>()` or throw "Expected Request object"
-//   JSValue               -> required arg or throw "Missing argument"
-//   ?JSValue              -> optional arg
-//   C.ExceptionRef        -> `&mut exception_slot` (and re-throw on return if set)
-//   <else>                -> compile_error!
-// `auto_protect` selects `ArgumentsSlice::protect_eat_next` vs `::next_eat`.
-
-// Zig: `pub fn wrapStaticMethod(comptime Container, comptime name, comptime auto_protect)
-//          jsc.JSHostFnZig`
-//
-// Same as `wrapInstanceMethod` minus the `*Container`/`*CallFrame`/`ExceptionRef`
-// arms, plus a `Node.BlobOrStringOrBuffer` arm.
-// TODO(port): proc-macro — `#[bun_jsc::host_fn(static, auto_protect)]` replaces
-// `wrapStaticMethod` (decode table as above + BlobOrStringOrBuffer).
-
-// ported from: src/jsc/host_fn.zig
diff --git a/src/jsc/host_object.rs b/src/jsc/host_object.rs
index 86de1da3d94..97b60ba9495 100644
--- a/src/jsc/host_object.rs
+++ b/src/jsc/host_object.rs
@@ -5,10 +5,7 @@
 //!     obj.put(global, b"bar", JSFunction::create(global, "bar", __jsc_host_bar, 2, Default::default()));
 //!     obj
 //!
-//! into a single declarative slice. Zig had no shared helper for this (each
-//! `*.zig` hand-unrolled it, or used a per-file `inline for` over a comptime
-//! tuple — `UnsafeObject.zig`, `HashObject.zig`). This is a NEW abstraction,
-//! not a parity loss.
+//! into a single declarative slice.
 //!
 //! Also fixes the capacity-hint drift bug class: `UnsafeObject.rs` passed
 //! `len = 3` for 4 entries because the hand-counted N wasn't bumped when
diff --git a/src/jsc/hot_reloader.rs b/src/jsc/hot_reloader.rs
index 69d98e14111..c4385b0b82c 100644
--- a/src/jsc/hot_reloader.rs
+++ b/src/jsc/hot_reloader.rs
@@ -30,6 +30,12 @@ pub enum ImportWatcher {
     Watch(Box<Watcher>),
 }
 
+// Drift guard for the bun_watcher CYCLEBREAK `Loader` newtype: its `File`
+// constant must mirror `bun_ast::Loader::File` —
+// the watcher stores that value for auto-watched directories. This crate sees
+// both types, so the compile-time check lives here.
+const _: () = assert!(bun_watcher::Loader::File.0 == bun_ast::Loader::File as u8);
+
 impl ImportWatcher {
     pub fn start(&mut self) -> Result<(), bun_core::Error> {
         match self {
@@ -67,9 +73,8 @@ impl ImportWatcher {
     /// thread can read the cached fd here while the watcher thread is between
     /// pass 1 (close) and pass 2 (remove), surfacing as `EBADF reading
     /// "<path>"` in `transpiler.rs:read_file_with_allocator` (hot.test.ts
-    /// "should work with sourcemap generation" on debian-aarch64). Zig has
-    /// the same race (`ModuleLoader.zig:173-174` reads unlocked); the port
-    /// closes it by locking the same mutex `append_file_maybe_lock<true>` and
+    /// "should work with sourcemap generation" on debian-aarch64). The race
+    /// is closed by locking the same mutex `append_file_maybe_lock<true>` and
     /// `flush_evictions` take.
     pub fn snapshot_fd_and_package_json(
         &self,
@@ -102,7 +107,7 @@ impl ImportWatcher {
 
     #[inline]
     pub fn add_file_by_path_slow(&mut self, file_path: &[u8], loader: bun_ast::Loader) -> bool {
-        // PORT NOTE: bun_watcher::Loader is an opaque newtype over u8;
+        // Note: bun_watcher::Loader is an opaque newtype over u8;
         // wrap the bun_ast::Loader discriminant.
         match self {
             ImportWatcher::Hot(w) | ImportWatcher::Watch(w) => {
@@ -120,7 +125,7 @@ impl ImportWatcher {
         hash: bun_watcher::HashType,
         loader: bun_ast::Loader,
         dir_fd: Fd,
-        // PORT NOTE: bun_watcher::PackageJSON is an opaque forward-decl;
+        // Note: bun_watcher::PackageJSON is an opaque forward-decl;
         // callers cast from `&bun_resolver::PackageJSON`.
         package_json: Option<&'static bun_watcher::PackageJSON>,
     ) -> bun_sys::Result<()> {
@@ -154,9 +159,8 @@ impl HotReloaderCtx for VirtualMachine {
     }
 
     fn bun_watcher_mut(&mut self) -> &mut Watcher {
-        // PORT NOTE: Zig's three-way `@TypeOf(this.ctx.bun_watcher)` reflection
-        // collapses here — `VirtualMachine.bun_watcher` is the type-erased
-        // `*mut ImportWatcher` (TODO(b2-cycle) field comment in
+        // `VirtualMachine.bun_watcher` is the
+        // `*mut ImportWatcher` (see the field comment in
         // VirtualMachine.rs), and `getContext` only runs after
         // `enable_hot_module_reloading` has populated it, so the `.None` arm
         // is unreachable.
@@ -171,9 +175,8 @@ impl HotReloaderCtx for VirtualMachine {
     }
 
     fn reload(&mut self, _task: &mut dyn HotReloadTaskView) {
-        // The inherent `reload` ignores its task argument (spec
-        // VirtualMachine.zig:769 takes `_: ?*HotReloader.HotReloadTask`), so
-        // pass `None` rather than threading the dyn view through.
+        // The inherent `reload` ignores its task argument, so pass `None`
+        // rather than threading the dyn view through.
         VirtualMachine::reload(self, None);
     }
 
@@ -186,7 +189,6 @@ impl HotReloaderCtx for VirtualMachine {
     }
 
     fn log_level_at_least_info(&self) -> bool {
-        // Zig: `if (@hasField(Ctx, "log")) this.log.level.atLeast(.info)`.
         // Note `Level.atLeast` is `self <= other` (Verbose=0..Err=4), so this is
         // true for Verbose/Debug/Info — i.e. "verbose enough to print info".
         self.log_ref()
@@ -195,8 +197,8 @@ impl HotReloaderCtx for VirtualMachine {
     }
 
     fn is_watcher_enabled(&self) -> bool {
-        // Zig: `this.bun_watcher != .none`. The field is stored type-erased
-        // (`*mut c_void` → `*mut ImportWatcher`); a null pointer means `.none`.
+        // The field is a typed `*mut ImportWatcher`; a null pointer means no
+        // watcher is installed.
         if self.bun_watcher.is_null() {
             return false;
         }
@@ -217,8 +219,6 @@ impl HotReloaderCtx for VirtualMachine {
         watcher: Box<Watcher>,
         reload_immediately: bool,
     ) -> *mut Watcher {
-        // Zig: `this.bun_watcher = if (reload_immediately) .{ .watch = w } else .{ .hot = w }`
-        // followed by `this.transpiler.resolver.watcher = ResolveWatcher(...).init(w)`.
         let mut iw = Box::new(if reload_immediately {
             ImportWatcher::Watch(watcher)
         } else {
@@ -228,14 +228,12 @@ impl HotReloaderCtx for VirtualMachine {
             ImportWatcher::Hot(w) | ImportWatcher::Watch(w) => &raw mut **w,
             ImportWatcher::None => unreachable!(),
         };
-        // The VM holds `bun_watcher` type-erased as `*mut c_void` (b2-cycle).
-        self.bun_watcher = bun_core::heap::into_raw(iw).cast::<core::ffi::c_void>();
+        self.bun_watcher = bun_core::heap::into_raw(iw);
 
         // Wire the resolver's directory-watch callback at the same time.
-        // Zig: `ResolveWatcher(*Watcher, Watcher.onMaybeWatchDirectory).init(w)`;
-        // `Watcher::get_resolve_watcher` is the Rust-side equivalent that
-        // erases the `*mut Watcher` into the resolver's `AnyResolveWatcher`
-        // vtable (re-exported from `bun_watcher`, so it's the same type).
+        // `Watcher::get_resolve_watcher` erases the `*mut Watcher` into the
+        // resolver's `AnyResolveWatcher` vtable (re-exported from
+        // `bun_watcher`, so it's the same type).
         // SAFETY: `watcher_ptr` was just installed into `self.bun_watcher`
         // via `heap::alloc` and is live for the VM's lifetime.
         self.transpiler.resolver.watcher = Some(unsafe { (*watcher_ptr).get_resolve_watcher() });
@@ -250,19 +248,13 @@ impl HotReloaderCtx for VirtualMachine {
     }
 }
 
-/// The concrete `HotReloadTask` instance the JS event loop dispatches
-/// (`jsc.hot_reloader.HotReloader.Task` in Zig). The dyn trait of the same
-/// name below is the type-erased view used by `HotReloaderCtx::reload`.
+/// The concrete `HotReloadTask` instance the JS event loop dispatches.
+/// The dyn trait below is the type-erased view used by
+/// `HotReloaderCtx::reload`.
 pub type HotReloadTask = Task<VirtualMachine, EventLoop, false>;
 
-/// Replaces Zig's structural duck-typing on `Ctx` (`this.ctx.eventLoop()`,
-/// `this.ctx.bun_watcher`, `this.ctx.bustDirCache`, `this.ctx.getLoaders`,
-/// `this.ctx.reload`) with an explicit trait bound. Implemented by
-/// `VirtualMachine` and `bun.bake.DevServer`.
-///
-/// `bun_watcher_mut` collapses the three-way `@TypeOf(this.ctx.bun_watcher)`
-/// reflection in `getContext` (ImportWatcher / Option / bare) into one method
-/// the impl picks the right arm of.
+/// Trait bound on `Ctx` exposing the operations the reloader needs.
+/// Implemented by `VirtualMachine` and `bun.bake.DevServer`.
 pub trait HotReloaderCtx {
     type EventLoop;
 
@@ -275,42 +267,33 @@ pub trait HotReloaderCtx {
     /// `event_loop()` pointer at each site.
     fn event_loop_ref(&self) -> &Self::EventLoop;
 
-    /// Zig: `this.ctx.bun_watcher` field, with comptime `@TypeOf` reflection
-    /// to unwrap `ImportWatcher`/`Option`. Implementor returns the live
-    /// `Watcher` regardless of how it's stored.
+    /// Implementor returns the live `Watcher` regardless of how it's stored.
     fn bun_watcher_mut(&mut self) -> &mut Watcher;
 
-    /// Called from `Task::run` to perform the actual reload. Zig passed the
-    /// concrete `*HotReloadTask`; Rust erases the const-generic via the
-    /// `HotReloadTask` view so this trait isn't recursively generic.
+    /// Called from `Task::run` to perform the actual reload. The const-generic
+    /// task is erased via the `HotReloadTaskView` so this trait isn't
+    /// recursively generic.
     fn reload(&mut self, task: &mut dyn HotReloadTaskView);
 
-    /// Zig: `this.ctx.bustDirCache(path)`. Returns whether anything was busted.
+    /// Returns whether anything was busted.
     fn bust_dir_cache(&mut self, path: &[u8]) -> bool;
 
-    /// Zig: `this.ctx.getLoaders()` — `&transpiler.options.loaders`.
+    /// `&transpiler.options.loaders`.
     fn get_loaders(&self) -> &bun_ast::LoaderHashTable;
 
-    /// Zig: `if (@hasField(Ctx, "log")) this.log.level.atLeast(.info) else false`.
     fn log_level_at_least_info(&self) -> bool {
         false
     }
 
     // ── enable_hot_module_reloading accessors ────────────────────────────
-    // Zig's `enableHotModuleReloading` reaches into `ctx.bun_watcher` and
-    // `ctx.transpiler.{fs, env, resolver.watcher}` via structural duck-typing.
     // The methods below expose just enough surface for the generic body.
 
-    /// Zig: `this.bun_watcher != .none` / `this.bun_watcher != null`.
     fn is_watcher_enabled(&self) -> bool;
 
-    /// Zig: `this.transpiler.fs.top_level_dir` — the watcher only consumes the
-    /// project root path.
+    /// The watcher only consumes the project root path.
     fn watcher_top_level_dir(&self) -> &'static [u8];
 
-    /// Zig: assigns `this.bun_watcher = .{ .hot/.watch = w }` (or `= w` for
-    /// non-ImportWatcher ctxs) and `this.transpiler.resolver.watcher =
-    /// ResolveWatcher(*Watcher, Watcher.onMaybeWatchDirectory).init(w)`.
+    /// Installs the watcher and wires the resolver's watch callback.
     /// Returns the now-installed `*mut Watcher` so the caller can `start()` it.
     fn install_bun_watcher(
         &mut self,
@@ -318,12 +301,10 @@ pub trait HotReloaderCtx {
         reload_immediately: bool,
     ) -> *mut Watcher;
 
-    /// Zig: `!this.transpiler.env.hasSetNoClearTerminalOnReload(!Output.enable_ansi_colors_stdout)`.
     fn compute_clear_screen(&self) -> bool;
 }
 
-/// Replaces Zig's structural call `this.eventLoop().enqueueTaskConcurrent(task)`
-/// with a trait bound on the `EventLoopType` generic. The only concrete event
+/// Trait bound on the `EventLoopType` generic. The only concrete event
 /// loop ever instantiated is `crate::event_loop::EventLoop`.
 pub trait HotReloaderEventLoop {
     /// Forward to the inherent `enqueue_task_concurrent`. Takes `&Self` so
@@ -340,12 +321,10 @@ impl HotReloaderEventLoop for EventLoop {
     }
 }
 
-/// `bun build --watch` instantiates `NewHotReloader<BundleV2, AnyEventLoop, true>`
-/// (bundle_v2.zig:50). With `RELOAD_IMMEDIATELY = true`, `Task::enqueue` diverges
-/// via `bun_core::reload_process()` before any concurrent task is enqueued, and
-/// in the Zig spec `enqueueTaskConcurrent` is `unreachable` (hot_reloader.zig:161).
-/// `BundleV2` doesn't even define `eventLoop()` — Zig's lazy compilation never
-/// instantiates it. Match that here.
+/// `bun build --watch` instantiates `NewHotReloader<BundleV2, AnyEventLoop, true>`.
+/// With `RELOAD_IMMEDIATELY = true`, `Task::enqueue` diverges via
+/// `bun_core::reload_process()` before any concurrent task is enqueued, so
+/// this is never reached.
 impl HotReloaderEventLoop for bun_event_loop::AnyEventLoop<'static> {
     fn enqueue_task_concurrent(_this: &Self, _task: core::ptr::NonNull<ConcurrentTask>) {
         unreachable!()
@@ -381,12 +360,12 @@ impl<Ctx, EventLoopType, const RELOAD_IMMEDIATELY: bool> HotReloadTaskView
 /// would re-run every test affected by any uncommitted change, not just
 /// the one that was just edited).
 ///
-/// Set by `test_command.zig` on the main thread before the watcher thread
+/// Set by `ChangedFilesFilter` on the main thread before the watcher thread
 /// starts; after that point only the watcher thread touches it. Its
 /// contents are written to `watch_changed_trigger_file` immediately
 /// before `reload_process`; the new process reads and deletes that file.
-// Zig was `?*bun.StringSet`; written once on main thread before watcher thread
-// starts, then watcher-thread-only. `OnceLock` carries the publish.
+// Written once on main thread before watcher thread starts, then
+// watcher-thread-only. `OnceLock` carries the publish.
 pub static WATCH_CHANGED_PATHS: std::sync::OnceLock<WatchChangedPaths> = std::sync::OnceLock::new();
 
 /// `Send + Sync` newtype around the arena-allocated `StringSet` pointer so it
@@ -429,7 +408,7 @@ unsafe impl Sync for WatchChangedPaths {}
 /// the changed-path list into. The same path is exported via the
 /// `BUN_INTERNAL_TEST_CHANGED_TRIGGER_FILE` env var so the restarted
 /// process can find it. Set alongside `WATCH_CHANGED_PATHS` by
-/// `test_command.zig`; the string must outlive the process.
+/// `ChangedFilesFilter`; the string must outlive the process.
 ///
 /// Init-once-then-read-only (main thread sets, watcher thread reads), so
 /// `OnceLock` per PORTING.md §Global mutable state. `&ZStr` is a fat pointer
@@ -483,15 +462,14 @@ fn flush_changed_paths_for_reload() {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn BunDebugger__willHotReload();
 }
 
-// TODO(port): in Zig this was a `pub var` inside the generic struct, giving one
-// static per monomorphization. Rust can't put a static in a generic impl; both
-// HotReloader and WatchReloader now share this. Revisit if the per-type split
-// was load-bearing.
+// Rust can't put a static in a generic impl, so HotReloader and WatchReloader
+// share this. That is fine in practice: the flag is derived from the same CLI
+// clear-screen setting and written only during single-threaded reloader init,
+// before the watcher thread starts.
 static CLEAR_SCREEN: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
 
 pub struct NewHotReloader<Ctx, EventLoopType, const RELOAD_IMMEDIATELY: bool> {
@@ -511,7 +489,9 @@ pub struct NewHotReloader<Ctx, EventLoopType, const RELOAD_IMMEDIATELY: bool> {
 
 pub struct MainFile {
     /// Includes a trailing "/"
-    // TODO(port): lifetime — borrows from `entry_path` (owned by Ctx, outlives Reloader)
+    // `'static` is the API contract of `enable_hot_module_reloading`
+    // (`entry_path: Option<&'static [u8]>`): the entry path is owned by the
+    // Ctx, which outlives the leaked Reloader for the process lifetime.
     pub dir: &'static [u8],
     pub dir_hash: bun_watcher::HashType,
 
@@ -570,10 +550,9 @@ impl MainFile {
 pub struct Task<Ctx, EventLoopType, const RELOAD_IMMEDIATELY: bool> {
     pub count: u8,
     pub hashes: [u32; 8],
-    // TODO(port): in Zig this field's type is `[8][]const u8` only when
-    // `Ctx == bun.bake.DevServer`, else `void`. Rust can't branch a field
-    // type on a generic parameter without specialization; storing it
-    // unconditionally for now.
+    // Only meaningful for the DevServer Ctx, but Rust can't branch a field
+    // type on a generic parameter without specialization, so it is stored
+    // unconditionally (8 fat pointers of overhead for non-DevServer Ctx).
     pub paths: [&'static [u8]; 8],
     /// Left `None` until [`Self::enqueue`] populates it on the heap copy.
     pub concurrent_task: Option<ConcurrentTask>,
@@ -592,7 +571,7 @@ where
         Self {
             reloader,
             hashes: [0u32; 8],
-            // TODO(port): was `if (Ctx == bun.bake.DevServer) [_][]const u8{&.{}} ** 8`
+            // See the `paths` field comment for why this is unconditional.
             paths: [b"".as_slice(); 8],
             count: 0,
             concurrent_task: None,
@@ -644,8 +623,7 @@ where
         self.count += 1;
     }
 
-    /// Spec: hot_reloader.zig `Task.deinit` → `bun.destroy(this)`. The
-    /// dispatched task was heap-allocated in [`Self::enqueue`] via
+    /// The dispatched task was heap-allocated in [`Self::enqueue`] via
     /// `heap::alloc`; the event loop calls this after `run()` to free it.
     ///
     /// # Safety
@@ -681,17 +659,6 @@ where
 
         if RELOAD_IMMEDIATELY {
             Output::flush();
-            // Zig: `if (comptime Ctx == ImportWatcher) { if (ctx.rare_data) |rare|
-            // rare.closeAllListenSocketsForWatchMode(); }`. That comptime guard is
-            // *never* true for any actual instantiation (Ctx is VirtualMachine or
-            // BundleV2, never ImportWatcher itself), so the call is dead code in
-            // the spec. Match spec literally: no-op for every Ctx.
-            //
-            // PORT NOTE: this is almost certainly a Zig typo — the intent was
-            // likely `@TypeOf(ctx.bun_watcher) == ImportWatcher`, which would
-            // close listen sockets before exec()-restarting under --watch on a
-            // VirtualMachine. But fixing that here would diverge from observable
-            // Zig behaviour; revisit upstream first.
             flush_changed_paths_for_reload();
             bun_core::reload_process(
                 CLEAR_SCREEN.load(core::sync::atomic::Ordering::Relaxed),
@@ -712,16 +679,15 @@ where
         }));
         // SAFETY: `that` was just allocated above and is exclusively owned here.
         unsafe {
-            // PORT NOTE: `JscTask::init` requires `Taskable`, but const-generic
+            // Note: `JscTask::init` requires `Taskable`, but const-generic
             // `Task<Ctx, _, _>` can't implement it (one tag per monomorphization).
-            // The Zig source tagged the concrete `HotReloader.HotReloadTask` —
-            // use the raw `(tag, ptr)` constructor.
+            // Use the raw `(tag, ptr)` constructor.
             let concurrent = (*that).concurrent_task.insert(ConcurrentTask {
                 task: JscTask::new(task_tag::HotReloadTask, that.cast::<()>()),
                 ..Default::default()
             });
-            // TODO(port): `&that.concurrent_task` is an interior pointer into a
-            // Box-allocated Task; event loop must not outlive `that`. Matches Zig.
+            // `&that.concurrent_task` is an interior pointer into a
+            // Box-allocated Task; the event loop must not outlive `that`.
             //
             // Inlines `NewHotReloader::enqueue_task_concurrent` to avoid forming
             // a whole-struct `&NewHotReloader` (see `Self::pending_count` doc).
@@ -770,8 +736,7 @@ where
         let mut watcher = match Watcher::init(reloader, fs.top_level_dir) {
             Ok(w) => w,
             Err(err) => {
-                // TODO(port): bun.handleErrorReturnTrace — debug-only diagnostics; no Rust equivalent yet
-                let _ = &err;
+                bun_core::handle_error_return_trace(&err);
                 Output::panic(format_args!(
                     "Failed to enable File Watcher: {}",
                     err.name()
@@ -779,8 +744,7 @@ where
             }
         };
         if let Err(err) = watcher.start() {
-            // TODO(port): bun.handleErrorReturnTrace — debug-only diagnostics; no Rust equivalent yet
-            let _ = &err;
+            bun_core::handle_error_return_trace(&err);
             Output::panic(format_args!("Failed to start File Watcher: {}", err.name()));
         }
         watcher
@@ -819,8 +783,6 @@ where
         // the reloader allocated below.
         let ctx = unsafe { &mut *this };
 
-        // Zig: `if (@TypeOf(this.bun_watcher) == ImportWatcher) { if (!= .none) return; }
-        //        else { if (!= null) return; }`
         if ctx.is_watcher_enabled() {
             return;
         }
@@ -838,7 +800,7 @@ where
         let watcher = match Watcher::init(reloader, ctx.watcher_top_level_dir()) {
             Ok(w) => w,
             Err(err) => {
-                // TODO(port): bun.handleErrorReturnTrace — debug-only diagnostics; no Rust equivalent yet
+                bun_core::handle_error_return_trace(&err);
                 Output::panic(format_args!(
                     "Failed to enable File Watcher: {}",
                     err.name()
@@ -846,9 +808,6 @@ where
             }
         };
 
-        // Zig: assigns `this.bun_watcher = .{.hot/.watch = w}` (or bare) and
-        // `this.transpiler.resolver.watcher = ResolveWatcher(...).init(w)` in one
-        // comptime-reflected block. Folded into the trait method.
         let watcher_ptr = ctx.install_bun_watcher(watcher, RELOAD_IMMEDIATELY);
 
         // SAFETY: single-threaded init; watcher thread not yet started.
@@ -874,9 +833,7 @@ where
     }
 
     pub fn on_error(_: &mut Self, err: &bun_sys::Error) {
-        // Zig: `Output.err(@as(bun.sys.E, @enumFromInt(err.errno)), ...)`.
-        // `bun_sys::Error::name()` does the same errno→tag-name lookup
-        // (with the unchecked-@enumFromInt UB folded into a checked path).
+        // `bun_sys::Error::name()` does the errno→tag-name lookup.
         Output::err(err.name(), "Watcher crashed", ());
         if cfg!(debug_assertions) {
             panic!("Watcher crash");
@@ -896,9 +853,6 @@ where
     }
 
     pub fn get_context(&mut self) -> &mut Watcher {
-        // PORT NOTE: Zig branched three ways on `@TypeOf(this.ctx.bun_watcher)`
-        // (ImportWatcher / Option / bare). Folded into `HotReloaderCtx::bun_watcher_mut`;
-        // each impl picks the right unwrap.
         self.ctx_mut().bun_watcher_mut()
     }
 
@@ -911,10 +865,10 @@ where
     ) {
         let slice = watchlist.slice();
         let file_paths = slice.items_file_path();
-        // PORT NOTE: `WatchItemColumns` doesn't expose a `count` accessor; reach
-        // through the generic SoA column directly. Zig mutates this in place
-        // (`counts[index] = update_count`) — build the &mut from the raw column
-        // pointer rather than ref-casting `&[u32]` (which is UB).
+        // Note: `WatchItemColumns` doesn't expose a `count` accessor; reach
+        // through the generic SoA column directly. The loop below mutates the
+        // column in place — build the &mut from the raw column pointer rather
+        // than ref-casting `&[u32]` (which is UB).
         // SAFETY: column `Count` is `u32`; `items_raw` yields a pointer valid
         // for `slice.len()` elements; the watcher thread is the sole writer of
         // this column for the loop's duration and no other `&` to it is live.
@@ -924,18 +878,17 @@ where
         let hashes = slice.items_hash();
         let parents = slice.items_parent_hash();
         let file_descriptors = slice.items_fd();
-        // PORT NOTE: reshaped for borrowck — `ctx` is held as a raw pointer so
+        // Note: reshaped for borrowck — `ctx` is held as a raw pointer so
         // `self` can be reborrowed inside the loop body for tombstone access,
         // and so the deferred `flush_evictions` doesn't hold `&mut Watcher`
         // across the loop.
         let ctx: *mut Watcher = std::ptr::from_mut(self.get_context());
-        // Zig: `defer current_task.enqueue();` — wrap the Task itself in the guard
-        // so any exit path (including future early-returns) flushes the buffered
-        // hashes. Dereferenced as `&mut *current_task` for the loop body below.
+        // Wrap the Task itself in a guard so any exit path (including future
+        // early-returns) flushes the buffered hashes via `enqueue()`.
+        // Dereferenced as `&mut *current_task` for the loop body below.
         //
-        // PORT NOTE: declared *before* `_flush` (inverting the Zig defer order)
-        // so `flush_evictions()` runs **before** `enqueue()` on drop. The Zig
-        // order (`enqueue` → `Output.flush` → `flushEvictions`) opens a window
+        // Note: declared *before* `_flush` so `flush_evictions()` runs
+        // **before** `enqueue()` on drop. The reverse order opens a window
         // where the JS thread can pick up the concurrent task, look the file up
         // in the watchlist, and read the cached fd while this thread is still
         // about to `close()` + `swap_remove()` it in `flush_evictions` —
@@ -946,8 +899,7 @@ where
             Task::<Ctx, EventLoopType, RELOAD_IMMEDIATELY>::init_empty(self),
             |mut t| t.enqueue(),
         );
-        // `defer ctx.flushEvictions(); defer Output.flush();` — see PORT NOTE
-        // above for why this drops *before* `current_task`.
+        // See the note above for why this drops *before* `current_task`.
         let _flush = scopeguard::guard(ctx, |ctx| {
             Output::flush();
             // SAFETY: the Watcher outlives this call (it owns the Reloader that calls us).
@@ -988,7 +940,7 @@ where
                     if self.verbose {
                         Self::debug(format_args!(
                             "File changed: {}",
-                            // PORT NOTE: `fs.relative_to(file_path)` would borrow `&*fs`
+                            // Note: `fs.relative_to(file_path)` would borrow `&*fs`
                             // while `rfs = &mut fs.fs` is live; inline the body so the
                             // split-borrow on `fs.top_level_dir` is visible to borrowck.
                             bstr::BStr::new(bun_paths::resolve_path::relative(
@@ -1041,10 +993,9 @@ where
                         let mut affected_buf: [&[u8]; 128] = [b"".as_slice(); 128];
                         let mut entries_option: Option<*mut Fs::EntriesOption> = None;
 
-                        // PORT NOTE: the Zig labeled block produced a slice whose
-                        // element type differs by platform (`[]const u8` on kqueue,
-                        // `?[:0]u8` on inotify). Split into two locals; only one is
-                        // populated per cfg.
+                        // Note: the affected-name element type differs by
+                        // platform (kqueue vs inotify). Split into two locals;
+                        // only one is populated per cfg.
                         let mut affected_kqueue: &[&[u8]] = &[];
                         let mut affected_inotify: &[ChangedFilePath] = &[];
                         let _ = (&mut affected_kqueue, &mut affected_inotify);
@@ -1068,15 +1019,11 @@ where
                                     if self.main.is_waiting_for_dir_change
                                         && self.main.dir_hash == current_hash
                                     {
-                                        // Zig: `if (bun.sys.faccessat(fd, basename) == .result)`.
-                                        // That compares the Maybe(bool) *tag*, ignoring the
-                                        // payload — `.result(true)` and `.result(false)` both
-                                        // match (faccessat only yields `.err` on NAMETOOLONG).
-                                        // Match spec literally: `.is_ok()`. The comment above
-                                        // says "Verify it exists", and this is likely a latent
-                                        // Zig bug, but spec parity wins; in practice the
-                                        // branch is harmless (re-watching a missing entrypoint
-                                        // is a no-op downstream).
+                                        // `.is_ok()` only checks faccessat didn't
+                                        // error (it errs only on NAMETOOLONG), not
+                                        // that the file exists; harmless in
+                                        // practice (re-watching a missing
+                                        // entrypoint is a no-op downstream).
                                         let mut name_buf = [0u8; 256];
                                         let basename = bun_paths::basename(self.main.file);
                                         let exists = if basename.len() < name_buf.len() {
@@ -1107,7 +1054,6 @@ where
                                     for (entry_id, parent_hash) in parents.iter().enumerate() {
                                         if *parent_hash == current_hash {
                                             let affected_path: &[u8] = &file_paths[entry_id];
-                                            // Zig: `std.posix.access(affected_path, F_OK) != 0`.
                                             // bun_sys::access takes a &ZStr; build one on the
                                             // stack from the &[u8] watch-list slice.
                                             let was_deleted = {
@@ -1220,7 +1166,6 @@ where
                                 let changed_name: &[u8] = if IS_KQUEUE {
                                     affected_kqueue[i]
                                 } else {
-                                    // Zig: `bun.asByteSlice(changed_name_.?)`
                                     affected_inotify[i].unwrap().as_bytes()
                                 };
                                 if changed_name.is_empty()
@@ -1237,15 +1182,12 @@ where
                                     .get(PathName::find_extname(changed_name))
                                     .copied()
                                     .unwrap_or(bun_ast::Loader::File);
-                                // PORT NOTE: Zig declares `prev_entry_id` per-iteration and
-                                // reassigns it just before `break`; the write is dead there
-                                // too (hot_reloader.zig:535/563). Keep the shape for
-                                // fidelity; the post-assignment `_ = prev_entry_id` below
-                                // documents the intentional dead store.
+                                // Note: the post-assignment `_ = prev_entry_id`
+                                // below documents the intentional dead store.
                                 let mut prev_entry_id: usize = usize::MAX;
                                 if loader != bun_ast::Loader::File {
-                                    // Zig leaves these `undefined` / overwritten; both arms
-                                    // of `'brk` assign before any read.
+                                    // Both arms of `'brk` assign these before
+                                    // any read.
                                     let path_string: bun_ptr::Interned;
                                     let file_hash: bun_watcher::HashType;
                                     let abs_path: &[u8] = 'brk: {
@@ -1298,12 +1240,12 @@ where
                                             _on_file_update_path_buf
                                                 [file_path_without_trailing_slash.len()] = SEP;
 
-                                            // PORT NOTE: Zig copies `changed_name` starting at
-                                            // index `len` (overlapping the just-written SEP)
-                                            // and then slices `len + changed_name.len + 1`
-                                            // bytes — this includes one byte past the copy.
-                                            // Ported verbatim.
-                                            // TODO(port): verify intended off-by-one in Zig source
+                                            // The separator written at index `len` is
+                                            // immediately overwritten by the
+                                            // `changed_name` copy, and the slice takes
+                                            // one stale byte past the copy. Deliberate:
+                                            // changing it would change the resulting
+                                            // path hash.
                                             _on_file_update_path_buf
                                                 [file_path_without_trailing_slash.len()
                                                     ..file_path_without_trailing_slash.len()
@@ -1354,15 +1296,12 @@ where
 
         // Drop order (LIFO): `_flush` guard → Output::flush() +
         // ctx.flush_evictions(), then `current_task` guard → enqueue(). See
-        // PORT NOTE on `current_task` above for why this inverts the Zig
-        // defer order.
+        // the note on `current_task` above for why this order matters.
     }
 }
 
 /// `Watcher::init` stores the `NewHotReloader` as its opaque context and
-/// dispatches file-change/error callbacks through this trait. In Zig this
-/// was structural (`@hasDecl(T, "onFileUpdate")`); the Rust watcher uses
-/// `WatcherContext` instead.
+/// dispatches file-change/error callbacks through this trait.
 impl<Ctx, EventLoopType, const RELOAD_IMMEDIATELY: bool> bun_watcher::WatcherContext
     for NewHotReloader<Ctx, EventLoopType, RELOAD_IMMEDIATELY>
 where
@@ -1384,19 +1323,17 @@ where
 }
 
 // ── `bun build --watch` (Ctx = BundleV2) ─────────────────────────────────
-// Zig: `pub const Watcher = bun.jsc.hot_reloader.NewHotReloader(BundleV2,
-// EventLoop, true)` (bundle_v2.zig:50). `RELOAD_IMMEDIATELY = true` means the
-// watcher thread `execve()`s on the first change (Task::enqueue diverges), so
-// `event_loop()` / `reload()` are never reached; Zig doesn't even define
-// `BundleV2.eventLoop()` (lazy compilation prunes it). The bundler crate (T5)
-// can't name this generic, so it calls in via the `#[no_mangle]` hook below.
+// `RELOAD_IMMEDIATELY = true` means the watcher thread `execve()`s on the
+// first change (Task::enqueue diverges), so `event_loop()` / `reload()` are
+// never reached. The bundler crate (T5) can't name this generic, so it calls
+// in via the `#[no_mangle]` hook below.
 
 impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     type EventLoop = bun_event_loop::AnyEventLoop<'static>;
 
     fn event_loop(&self) -> *mut Self::EventLoop {
-        // Zig: BundleV2 has no `eventLoop()`; with RELOAD_IMMEDIATELY=true the
-        // only caller (`Task::enqueue` post-diverge) is dead code.
+        // With RELOAD_IMMEDIATELY=true the only caller
+        // (`Task::enqueue` post-diverge) is dead code.
         unreachable!()
     }
 
@@ -1406,8 +1343,6 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     }
 
     fn bun_watcher_mut(&mut self) -> &mut Watcher {
-        // Zig: `else if (@typeInfo(@TypeOf(this.ctx.bun_watcher)) == .optional)
-        //          return this.ctx.bun_watcher.?;` (hot_reloader.zig:373).
         let handle = self
             .bun_watcher
             .expect("bun_watcher_mut on un-enabled BundleV2 reloader");
@@ -1431,13 +1366,11 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     }
 
     fn log_level_at_least_info(&self) -> bool {
-        // Zig: `if (@hasField(Ctx, "log")) … else false` — BundleV2 has no
-        // `log` field (the log is on `transpiler`), so this arm is `false`.
+        // BundleV2 has no `log` field (the log is on `transpiler`), so `false`.
         false
     }
 
     fn is_watcher_enabled(&self) -> bool {
-        // Zig: `else { if (this.bun_watcher != null) return; }`.
         self.bun_watcher.is_some()
     }
 
@@ -1450,9 +1383,6 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
         watcher: Box<Watcher>,
         _reload_immediately: bool,
     ) -> *mut Watcher {
-        // Zig (the non-ImportWatcher arm, hot_reloader.zig:330):
-        //   this.bun_watcher = Watcher.init(...);
-        //   this.transpiler.resolver.watcher = ResolveWatcher(...).init(this.bun_watcher.?);
         // `watcher_nn` is a fresh non-null heap allocation; live for the
         // process (BundleV2 is leaked under --watch — see `generate_from_cli`).
         let watcher_nn = bun_core::heap::into_raw_nn(watcher);
@@ -1471,14 +1401,13 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     }
 }
 
-/// Zig: `bundle_v2.Watcher = NewHotReloader(BundleV2, EventLoop, true)`
-/// (bundle_v2.zig:50). `'static` because the only caller (`bun build --watch`)
+/// `'static` because the only caller (`bun build --watch`)
 /// allocates the transpiler from the process-lifetime CLI arena.
 type BundlerWatcher =
     NewHotReloader<bun_bundler::BundleV2<'static>, bun_event_loop::AnyEventLoop<'static>, true>;
 
 /// CYCLEBREAK extern hook: called from `BundleV2::init` (T5) when
-/// `cli_watch_flag` is set (bundle_v2.zig:993). Defined here (not in
+/// `cli_watch_flag` is set. Defined here (not in
 /// `bun_bundler`) because the bundler crate can't name `NewHotReloader`.
 #[unsafe(no_mangle)]
 fn __bun_jsc_enable_hot_module_reloading_for_bundler(
@@ -1491,5 +1420,3 @@ fn __bun_jsc_enable_hot_module_reloading_for_bundler(
 }
 
 pub use crate::MarkedArrayBuffer as Buffer;
-
-// ported from: src/jsc/hot_reloader.zig
diff --git a/src/jsc/ipc.rs b/src/jsc/ipc.rs
index 8bdcb252246..5c0d50a411b 100644
--- a/src/jsc/ipc.rs
+++ b/src/jsc/ipc.rs
@@ -29,8 +29,8 @@ use bun_uws;
 // ──────────────────────────────────────────────────────────────────────────
 // SendQueue ownership (§Layering / Dispatch).
 //
-// In Zig, `SendQueue.owner` is a tagged union over `*Subprocess` (parent side)
-// and `*VirtualMachine` (child side). `Subprocess` lives in `bun_runtime`
+// `SendQueue.owner` is logically either a `*Subprocess` (parent side)
+// or a `*VirtualMachine` (child side). `Subprocess` lives in `bun_runtime`
 // (tier-6), so the concrete type cannot be named here. Instead of a hand-
 // rolled fn-pointer table, the owner is stored as a raw `*mut dyn` trait
 // object: `IPCInstance` (this crate) and `Subprocess` (`bun_runtime`) both
@@ -48,7 +48,7 @@ use bun_uws;
 /// to describe different events it performs. It will send a message with an incrementing sequence number and then call a callback
 /// when a message is received with an 'ack' property of the same sequence number.
 ///
-/// PORT NOTE: moved down from `bun_runtime::node::node_cluster_binding` (cycle-break per
+/// Note: moved down from `bun_runtime::node::node_cluster_binding` (cycle-break per
 /// docs/PORTING.md) — `SendQueue` stores one inline so the struct must live at this tier.
 /// All field accesses + dispatch methods need only `bun_jsc`/`bun_collections` symbols.
 pub struct InternalMsgHolder {
@@ -80,8 +80,6 @@ impl InternalMsgHolder {
     }
 
     pub fn enqueue(&mut self, message: JSValue, global: &JSGlobalObject) {
-        // TODO: .addOne is workaround for .append causing crash/ dependency loop in zig compiler
-        // (Rust: just push; the workaround is Zig-specific.)
         self.messages
             .push(crate::StrongOptional::create(message, global));
     }
@@ -103,10 +101,8 @@ impl InternalMsgHolder {
         if let Some(p) = message.get(global, "ack")? {
             if !p.is_undefined() {
                 let ack = p.to_int32();
-                // PORT NOTE: reshaped for borrowck — Zig copied the Strong out of the
-                // entry, then conditionally deinit+swapRemove. Here we peek the JSValue
-                // first (ending the immutable borrow), then swap_remove (which drops the
-                // Strong == `defer cbstrong.deinit()`).
+                // Note: peek the JSValue first (ending the immutable borrow),
+                // then swap_remove (which drops the Strong).
                 let entry = self.callbacks.get(&ack).map(|s| s.get());
                 if let Some(callback_opt) = entry {
                     if let Some(callback) = callback_opt {
@@ -300,7 +296,6 @@ mod advanced {
         Version = 1,
         SerializedMessage = 2,
         SerializedInternalMessage = 3,
-        // Zig: `_` (non-exhaustive)
     }
     // SAFETY: `#[repr(u8)]` fieldless enum → size 1, align 1, no padding,
     // `Copy + 'static`; the single byte is always an initialized discriminant.
@@ -317,7 +312,6 @@ mod advanced {
         }
     }
 
-    // comptime std.mem.asBytes(&VersionPacket{})
     static VERSION_PACKET_BYTES: [u8; HEADER_LENGTH] = {
         let v = VERSION.to_ne_bytes();
         [IPCMessageType::Version as u8, v[0], v[1], v[2], v[3]]
@@ -424,13 +418,12 @@ mod advanced {
 
         let payload_length: usize = size_of::<IPCMessageType>() + size_of::<u32>() + size as usize;
 
-        // Spec ipc.zig:160 uses `try` — propagate OOM so serializeAndSend
+        // Propagate OOM so serializeAndSend
         // returns `.failure` instead of silently discarding the Result.
         writer
             .ensure_unused_capacity(payload_length)
             .map_err(|_| IPCSerializationError::OutOfMemory)?;
 
-        // PERF(port): was assume_capacity
         writer.write_type_as_bytes_assume_capacity(match is_internal {
             IsInternal::Internal => IPCMessageType::SerializedInternalMessage,
             IsInternal::External => IPCMessageType::SerializedMessage,
@@ -528,7 +521,6 @@ mod json {
             BunString::borrow_utf8(json_data)
         };
 
-        // Zig: `defer { str.deref(); if (is_ascii && !was_ascii_string_freed) @panic(...) }`.
         // `bun_core::String` is `Copy` (no `Drop`), so the +1 ref taken by
         // `create_external` / `borrow_utf8` must be released explicitly. The
         // ASCII-path free callback (`json_ipc_data_string_free_cb`) only fires
@@ -579,7 +571,7 @@ mod json {
                 JsError::Terminated => IPCSerializationError::JSTerminated,
                 JsError::OutOfMemory => IPCSerializationError::OutOfMemory,
             })?;
-        // Zig: `defer out.deref()`. `bun_core::String` is `Copy` (no `Drop`),
+        // `bun_core::String` is `Copy` (no `Drop`),
         // so the +1 ref written by `json_stringify_fast` is wrapped in
         // `OwnedString` immediately so every exit path (Dead, OOM in
         // `ensure_unused_capacity`, success) releases it.
@@ -598,13 +590,12 @@ mod json {
             result_len += 1;
         }
 
-        // Spec ipc.zig:280 uses `try` — propagate OOM so serializeAndSend
+        // Propagate OOM so serializeAndSend
         // returns `.failure` instead of silently discarding the Result.
         writer
             .ensure_unused_capacity(result_len)
             .map_err(|_| IPCSerializationError::OutOfMemory)?;
 
-        // PERF(port): was assume_capacity
         if is_internal == IsInternal::Internal {
             writer.write_assume_capacity(&[2]);
         }
@@ -666,8 +657,9 @@ pub fn get_nack_packet(mode: Mode) -> &'static [u8] {
     }
 }
 
+// `bun_uws::SocketHandler<SSL>` is an alias for `NewSocketHandler<SSL>`
+// (uws_sys/socket.rs); `<false>` is the non-SSL handler.
 pub type Socket = bun_uws::SocketHandler<false>;
-// TODO(port): uws.NewSocketHandler(false) — verify generic shape in bun_uws
 
 pub struct Handle {
     pub fd: Fd,
@@ -792,7 +784,7 @@ impl WindowsWrite {
 #[derive(Default)]
 pub struct WindowsState {
     pub is_server: bool,
-    /// Non-owning raw pointer (matches Zig `?*WindowsWrite`). The allocation
+    /// Non-owning raw pointer. The allocation
     /// is `heap::alloc`'d in `_write` and freed exactly once by
     /// `_windows_on_write_complete` via `WindowsWrite::destroy`. Nulling this
     /// field never frees.
@@ -846,7 +838,7 @@ pub struct SendQueue {
     /// SendQueue is stored inline in its owner, so this is a self-referential
     /// raw pointer; never reborrow as `&mut dyn` while a `&mut SendQueue` is
     /// live (every access goes through `unsafe { &mut *self.owner }` at the
-    /// call site, mirroring the Zig union dispatch).
+    /// call site).
     pub owner: *mut dyn SendQueueOwner,
 
     pub close_next_tick: Option<Task>,
@@ -863,8 +855,7 @@ pub struct SendQueue {
 
 /// Dispatch surface for the SendQueue's embedding object — either a
 /// `Subprocess` (parent side, `bun_runtime`) or a `VirtualMachine::IPCInstance`
-/// (child side, this crate). Replaces the Zig `union(enum) { subprocess,
-/// virtual_machine }` switch with a trait object so the concrete `Subprocess`
+/// (child side, this crate). A trait object so the concrete `Subprocess`
 /// type need not be named here.
 pub trait SendQueueOwner {
     fn global_this(&self) -> *const JSGlobalObject;
@@ -1003,15 +994,14 @@ impl SendQueue {
         // owner is about to free the memory that backs `this`, so scheduling
         // a task that points back into it would use-after-free.
         if was_open && self.after_close_task.is_none() {
-            // PORT NOTE: `bun_event_loop::JsResult` erases the error to `*mut ()`;
+            // Note: `bun_event_loop::JsResult` erases the error to `*mut ()`;
             // adapt the jsc-crate `JsResult` via a non-capturing closure (coerces to fn ptr).
             let task = ManagedTask::new(std::ptr::from_mut::<SendQueue>(self), |p| {
                 let _ = Self::_on_after_ipc_closed(p);
                 Ok(())
             });
             self.after_close_task = Some(task);
-            // Spec ipc.zig:589 calls `bunVM().enqueueTask(...)` on a raw
-            // `*VirtualMachine`. Do NOT materialize `&mut VirtualMachine` from
+            // Do NOT materialize `&mut VirtualMachine` from
             // `bun_vm()`'s shared `&VirtualMachine` (Stacked-Borrows UB —
             // `&mut T` while other `&T` exist). Route through the safe
             // `event_loop_mut(&self)` accessor (single audited deref), which
@@ -1060,7 +1050,7 @@ impl SendQueue {
             self.close_socket(CloseReason::Normal, CloseFrom::User);
             return;
         }
-        // PORT NOTE: see `_socket_closed` — adapt `bun_event_loop::JsResult` via closure.
+        // Note: see `_socket_closed` — adapt `bun_event_loop::JsResult` via closure.
         let task = ManagedTask::new(std::ptr::from_mut::<SendQueue>(self), |p| {
             let _ = Self::_close_socket_task(p);
             Ok(())
@@ -1111,7 +1101,7 @@ impl SendQueue {
 
         // optimal case: appending a message without a handle to the end of the queue when the last message also doesn't have a handle and isn't ack/nack
         // this is rare. it will only happen if messages stack up after sending a handle, or if a long message is sent that is waiting for writable
-        // PORT NOTE: reshaped for borrowck (NLL limitation: early-return of
+        // Note: reshaped for borrowck (NLL limitation: early-return of
         // `&mut self.queue[..]` would otherwise extend the borrow across the
         // fallback push). Compute the predicate first, then re-borrow.
         let use_last = if handle.is_none() && !self.queue.is_empty() {
@@ -1222,8 +1212,8 @@ impl SendQueue {
 
     pub fn update_ref(&mut self, global: &JSGlobalObject) {
         let _ = global;
-        // PORT NOTE: KeepAlive::{ref_,unref} take an `EventLoopCtx` (aio cycle-
-        // break vtable), not `&VirtualMachine`. The Zig anytype dispatch is
+        // Note: KeepAlive::{ref_,unref} take an `EventLoopCtx` (aio cycle-
+        // break vtable), not `&VirtualMachine`; dispatch is
         // routed through `bun_io::get_vm_ctx` which `bun_runtime` registers.
         let ctx = bun_io::posix_event_loop::get_vm_ctx(bun_io::AllocatorType::Js);
         if self.should_ref() {
@@ -1242,8 +1232,10 @@ impl SendQueue {
             }
         );
         self.debug_log_message_queue();
-        // defer this.updateRef(global) — handled at every return below.
-        // TODO(port): errdefer — use scopeguard for update_ref-on-exit.
+        // `update_ref(global)` is called manually at every
+        // return below (the recursive `continue_send` path delegates to its
+        // own tail `update_ref`). A scopeguard can't hold `&mut self` while
+        // the body also uses `self`, so the manual spelling stays.
 
         if self.queue.is_empty() {
             self.update_ref(global);
@@ -1274,7 +1266,6 @@ impl SendQueue {
             log!("IPC call continueSend() from empty item");
             return self.continue_send(global, reason);
         }
-        // log("sending ipc message: '{'}' (has_handle={})", .{ std.zig.fmtString(to_send), first.handle != null });
         debug_assert!(!self.write_in_progress);
         self.write_in_progress = true;
         let fd = self.queue[0].handle.as_ref().map(|h| h.fd);
@@ -1368,7 +1359,7 @@ impl SendQueue {
     ) -> SerializeAndSendResult {
         log!("SendQueue#serializeAndSend");
         let indicate_backoff = self.waiting_for_ack.is_some() && !self.queue.is_empty();
-        // PORT NOTE: reshaped for borrowck — work on msg via local then drop borrow before continue_send.
+        // Note: reshaped for borrowck — work on msg via local then drop borrow before continue_send.
         let mode = self.mode;
         let msg = match self.start_message(global, callback, handle) {
             Ok(m) => m,
@@ -1381,7 +1372,6 @@ impl SendQueue {
             Err(_) => return SerializeAndSendResult::Failure,
         };
         debug_assert!(msg.data.list.len() == start_offset + payload_length);
-        // log("enqueueing ipc message: '{'}'", .{std.zig.fmtString(msg.data.list.items[start_offset..])});
 
         log!("IPC call continueSend() from serializeAndSend");
         self.continue_send(global, ContinueSendReason::NewMessageAppended);
@@ -1481,8 +1471,7 @@ impl SendQueue {
                     // `WindowsWrite::destroy`; holding a live `&mut WindowsWrite`
                     // across that free would dangle the reference (UB) and the
                     // `Box::from_raw` would carry the `&mut`-reborrow tag instead
-                    // of the original allocation root. Matches Zig's raw-pointer
-                    // pass-through (libuv.zig `uvWriteCb`).
+                    // of the original allocation root.
                     |req: *mut WindowsWrite, rc| SendQueue::_windows_on_write_complete(req, rc),
                 )
             };
@@ -1565,12 +1554,11 @@ impl SendQueue {
         if this.windows.try_close_after_write {
             this.close_socket(CloseReason::Normal, CloseFrom::User);
         }
-        // Zig: `defer vm.eventLoop().exit()` — handled by `_scope` drop.
+        // The event-loop exit is handled by `_scope` drop.
     }
     fn get_global_this(&self) -> crate::GlobalRef {
-        // PORT NOTE: lifetime detached from `&self` so callers can hold the
-        // global across `&mut self` borrows (Zig passes `*JSGlobalObject` by
-        // raw pointer everywhere). The owner (Subprocess / IPCInstance)
+        // Note: lifetime detached from `&self` so callers can hold the
+        // global across `&mut self` borrows. The owner (Subprocess / IPCInstance)
         // outlives this SendQueue and the JSGlobalObject is heap-allocated by
         // JSC for the VM's lifetime. `opaque_ref` is the safe ZST-handle deref
         // (panics on null) — see `bun_opaque::opaque_deref`.
@@ -1637,7 +1625,6 @@ impl SendQueue {
         this: *mut Self,
         pipe_fd: Fd,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         log!("configureClient");
         let ipc_pipe: *mut uv::Pipe =
             bun_core::heap::into_raw(Box::new(bun_core::ffi::zeroed::<uv::Pipe>()));
@@ -1681,7 +1668,7 @@ impl SendQueue {
 }
 
 /// Adapter from `UvStream::read_start_ctx` to the `IPCHandlers::WindowsNamedPipe`
-/// callbacks. Zig passed the three fns as `comptime` pointers; Rust bakes them
+/// callbacks. The three fns are baked
 /// into the trait impl so the `extern "C"` trampoline is monomorphised over
 /// `SendQueue` with zero per-handle storage.
 #[cfg(windows)]
@@ -1692,7 +1679,7 @@ impl uv::StreamReader for SendQueue {
     }
     #[inline]
     fn on_read_error(this: &mut Self, err: core::ffi::c_int) {
-        // Zig: `errEnum() orelse bun.sys.E.CANCELED` — map the raw libuv errno
+        // Map the raw libuv errno
         // to `bun_sys::E`, defaulting to CANCELED for unmapped codes.
         let e = bun_sys::windows::translate_uv_error_to_e(err);
         IPCHandlers::WindowsNamedPipe::on_read_error(this, e);
@@ -1765,19 +1752,21 @@ fn handle_ipc_message(
 ) {
     #[cfg(debug_assertions)]
     {
-        // PORT NOTE: Zig formats the JSValue via ConsoleObject.Formatter for
-        // the scoped log; the Rust `Formatter` has no `Default` and threading
-        // it through here pulls in the full table-printer machinery for a
-        // debug-only log line. Log the variant tag instead.
-        // TODO(port): wire `console_object::Formatter::new(global_this)` once
-        // its construction stabilises.
-        let _ = global_this;
+        // The `Formatter` runs its deinit in `Drop`.
+        let mut formatter = jsc::ConsoleObject::Formatter::new(global_this);
         match &message {
             DecodedIPCMessage::Version(version) => {
                 log!("received ipc message: version: {}", version)
             }
-            DecodedIPCMessage::Data(_) => log!("received ipc message: \\<data>"),
-            DecodedIPCMessage::Internal(_) => log!("received ipc message: internal"),
+            DecodedIPCMessage::Data(jsvalue) => {
+                log!("received ipc message: {}", jsvalue.to_fmt(&mut formatter))
+            }
+            DecodedIPCMessage::Internal(jsvalue) => {
+                log!(
+                    "received ipc message: internal: {}",
+                    jsvalue.to_fmt(&mut formatter)
+                )
+            }
         }
     }
     let mut internal_command: Option<IPCCommand> = None;
@@ -1890,7 +1879,6 @@ fn handle_ipc_message(
 
 fn on_data2(send_queue: &mut SendQueue, all_data: &[u8]) {
     let mut data = all_data;
-    // log("onData '{'}'", .{std.zig.fmtString(data)});
 
     // In the VirtualMachine case, `globalThis` is an optional, in case
     // the vm is freed before the socket closes.
@@ -1898,7 +1886,7 @@ fn on_data2(send_queue: &mut SendQueue, all_data: &[u8]) {
 
     // Decode the message with just the temporary buffer, and if that
     // fails (not enough bytes) then we allocate to .ipc_buffer
-    // PORT NOTE: reshaped for borrowck — match on raw discriminant pointer to allow
+    // Note: reshaped for borrowck — match on raw discriminant pointer to allow
     // calling &mut self methods on send_queue inside arms.
     match &mut send_queue.incoming {
         IncomingBuffer::Json(_) => {
@@ -2307,5 +2295,3 @@ pub fn ipc_parse(
     // `[[ZIG_EXPORT(zero_is_throw)]]`
     crate::cpp::IPCParse(global_object, target, serialized, fd)
 }
-
-// ported from: src/jsc/ipc.zig
diff --git a/src/jsc/javascript_core_c_api.rs b/src/jsc/javascript_core_c_api.rs
index 06795c5d48b..554ceaf6530 100644
--- a/src/jsc/javascript_core_c_api.rs
+++ b/src/jsc/javascript_core_c_api.rs
@@ -12,13 +12,12 @@ use bun_jsc::{JSGlobalObject, JSValue};
 
 bun_opaque::opaque_ffi! {
     /// Opaque FFI handle backing every `*Ref` typedef in the JavaScriptCore C API.
-    /// In Zig this is a single `opaque {}` aliased under many names; we mirror that.
+    /// A single opaque type aliased under many names.
     pub struct Generic;
 }
 
 impl Generic {
     pub fn value(&self) -> JSValue {
-        // Zig: @enumFromInt(@as(JSValue.backing_int, @bitCast(@intFromPtr(this))))
         // The JSC C API hands out JSValueRef as the cell pointer itself; reinterpreting the
         // pointer bits as an encoded JSValue is exactly what JSC::JSValue(JSCell*) does.
         JSValue::from_encoded(std::ptr::from_ref::<Self>(self) as usize)
@@ -32,7 +31,6 @@ pub(crate) type OpaqueJSValue = Generic;
 pub type JSValueRef = *mut OpaqueJSValue;
 pub type JSObjectRef = *mut OpaqueJSValue;
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     pub fn JSGarbageCollect(ctx: *mut JSGlobalObject);
 }
@@ -51,8 +49,9 @@ pub enum JSType {
 }
 
 /// From JSValueRef.h:81
-// TODO(port): Zig enum is non-exhaustive (`_`); only ever passed *to* C in this file so a
-// #[repr(u32)] enum is sound here. If a future extern returns this, switch to a newtype.
+// This enum is only ever passed *to* C in this file, so an exhaustive
+// #[repr(u32)] enum is sound here. If a future extern ever *returns* this
+// type, switch to a newtype over u32.
 #[repr(u32)] // c_uint
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum JSTypedArrayType {
@@ -71,7 +70,6 @@ pub enum JSTypedArrayType {
     kJSTypedArrayTypeBigUint64Array,
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     pub fn JSValueGetType(ctx: *mut JSGlobalObject, value: JSValueRef) -> JSType;
     pub fn JSValueMakeNull(ctx: *mut JSGlobalObject) -> JSValueRef;
@@ -105,7 +103,6 @@ pub enum JSClassAttributes {
 
 pub type ExceptionRef = *mut JSValueRef;
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     pub fn JSObjectGetPrototype(ctx: *mut JSGlobalObject, object: JSObjectRef) -> JSValueRef;
     pub fn JSObjectGetPropertyAtIndex(
@@ -145,7 +142,6 @@ unsafe extern "C" {
     ) -> JSObjectRef;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     pub fn JSObjectMakeTypedArray(
         ctx: *mut JSGlobalObject,
@@ -204,7 +200,6 @@ unsafe extern "C" {
     ) -> usize;
 }
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     /// This is a workaround for not receiving a JSException* object
     /// This function lets us use the C API but returns a plain old JSValue
@@ -228,5 +223,3 @@ unsafe extern "C" {
 
     pub fn JSObjectGetProxyTarget(object: JSObjectRef) -> JSObjectRef;
 }
-
-// ported from: src/jsc/javascript_core_c_api.zig
diff --git a/src/jsc/lib.rs b/src/jsc/lib.rs
index 1f10634d4a5..e1e607847f0 100644
--- a/src/jsc/lib.rs
+++ b/src/jsc/lib.rs
@@ -3,12 +3,9 @@
 //!
 //! Web and runtime-specific APIs should go in `bun.webcore` and `bun.api`.
 //!
-//! LAYERING: `jsc.zig` carries deprecated aliases `WebCore = bun.webcore`,
-//! `API = bun.api`, `Node = bun.api.node`, `Subprocess = bun.api.Subprocess`.
-//! In the Rust crate graph those targets live in `bun_runtime`, which depends
-//! on this crate — re-exporting them here would create a cycle. The Zig source
-//! already marks every one of them `Deprecated` with a "TODO: Remove" header,
-//! so the Rust port drops the aliases outright. Callers reference
+//! LAYERING: no `WebCore`/`API`/`Node`/`Subprocess` aliases are exported here.
+//! Those targets live in `bun_runtime`, which depends on this crate —
+//! re-exporting them here would create a cycle. Callers reference
 //! `bun_runtime::{webcore,api,node}` directly; lower-tier consumers that
 //! constructed those types (e.g. `output_file_jsc`, `BlobArrayBuffer_deallocator`)
 //! have been moved up into `bun_runtime`, and the few that only need an opaque
@@ -16,9 +13,9 @@
 
 #![allow(deprecated, non_snake_case)]
 #![allow(unexpected_cfgs)]
-// `ConsoleObject::Formatter::print_as` dispatches on `const FORMAT: Tag` to
-// preserve Zig's comptime monomorphization (zig:2210). `Tag` is a fieldless
-// enum, so this is the structural-match subset of the feature.
+// `ConsoleObject::Formatter::print_as` dispatches on `const FORMAT: Tag`.
+// `Tag` is a fieldless enum, so this is the structural-match subset of the
+// feature.
 #![feature(adt_const_params)]
 // `#[thread_local]` for the per-JS-thread VM holder and adjacent hot
 // per-callback statics — bare `__thread`/`.tbss` instead of the
@@ -47,8 +44,7 @@ pub use bun_jsc_macros::{JsClass, JsClassDerive, codegen_cached_accessors, host_
 
 /// The calling convention used for JavaScript functions <> Native.
 ///
-/// In Zig this is a `std.builtin.CallingConvention` value (`.x86_64_sysv` on
-/// Windows-x64, `.c` elsewhere). Rust cannot express an ABI as a runtime value
+/// Rust cannot express an ABI as a runtime value
 /// — `extern "..."` takes a string literal, not an expression. The
 /// `#[bun_jsc::host_fn]` / `#[bun_jsc::host_call]` attribute macros emit the
 /// correct ABI per-target instead. See PORTING.md §FFI / §JSC types.
@@ -112,13 +108,10 @@ pub mod zig_stack_frame_position;
 
 /// `bun.schema.api` types that reference `ZigStackFramePosition` (this crate)
 /// and so cannot live in `bun_options_types::schema::api` without a dep cycle.
-/// Ported from `src/options_types/schema.zig` (`StackFrameScope`, `StackFrame`,
-/// `StackFramePosition`, `SourceLine`, `StackTrace`).
 pub mod schema_api {
     use crate::ZigStackFramePosition;
 
-    /// schema.zig:373 — `enum(u8) { _none, eval, module, function, global, wasm,
-    /// constructor, _ }` (non-exhaustive). Newtype keeps any-u8 FFI-safe.
+    /// Non-exhaustive stack-frame scope tag. Newtype keeps any-u8 FFI-safe.
     #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub struct StackFrameScope(pub u8);
@@ -133,10 +126,10 @@ pub mod schema_api {
         pub const CONSTRUCTOR: Self = Self(6);
     }
 
-    /// schema.zig:431 — `pub const StackFramePosition = bun.jsc.ZigStackFramePosition;`
+    /// Line/column position of a stack frame (FFI layout shared with C++).
     pub type StackFramePosition = ZigStackFramePosition;
 
-    /// schema.zig:401 — `struct StackFrame`.
+    /// One captured stack frame: function name, file, position, and scope (FFI layout shared with C++).
     #[derive(Clone)]
     pub struct StackFrame {
         /// function_name
@@ -160,7 +153,7 @@ pub mod schema_api {
         }
     }
 
-    /// schema.zig:433 — `struct SourceLine`.
+    /// A line of source text with its line number, used for error previews.
     #[derive(Clone, Default)]
     pub struct SourceLine {
         /// line
@@ -169,7 +162,7 @@ pub mod schema_api {
         pub text: Box<[u8]>,
     }
 
-    /// schema.zig:455 — `struct StackTrace`.
+    /// A captured stack trace: frames plus the source lines used to render previews.
     #[derive(Clone, Default)]
     pub struct StackTrace {
         /// source_lines
@@ -178,7 +171,6 @@ pub mod schema_api {
         pub frames: Vec<StackFrame>,
     }
 
-    /// schema.zig:475 — peechy `message JsException` (all fields optional).
     /// Lives here (not `bun_options_types::schema::api`) because `stack`'s
     /// [`StackTrace`] transitively names `ZigStackFramePosition` from this
     /// crate; the `bun_options_types` copy omits `stack` to avoid the cycle.
@@ -250,9 +242,9 @@ pub use self::js_value::{
     SerializedFlags, SerializedScriptValue,
 };
 
-// LAYERING (PORTING.md §Dispatch): `Task.run` (jsc/Task.zig:39) is a giant
-// `switch` over every concrete task variant — most of which live in
-// `bun_runtime`. The Rust port follows the §Dispatch convention: this crate
+// LAYERING (PORTING.md §Dispatch): the task dispatch covers every concrete
+// task variant — most of which live in
+// `bun_runtime`. Per the §Dispatch convention, this crate
 // stores the erased `(tag, *mut ())` `Task` and exposes the queue; the high
 // tier (`bun_runtime::dispatch::tick_queue_with_count`) owns the `match` loop
 // and is wired into `event_loop::tick` directly at link time. No fn-pointer
@@ -275,14 +267,11 @@ pub use self::task::Taskable;
 
 /// Trait surface for `write_format`-style hooks on runtime types
 /// (`Response::write_format`, `Request::write_format`, `S3File::write_format`,
-/// …). Mirrors the duck-typed `*ConsoleObject.Formatter` parameter in Zig —
-/// callers only ever touch `globalThis` and `printAs`, so the trait exposes
-/// just those two and the `bun_jsc::Formatter` struct provides the canonical
-/// impl.
+/// …). Callers only ever touch `globalThis` and `printAs`, so the trait
+/// exposes just those two and the `bun_jsc::Formatter` struct provides the
+/// canonical impl.
 pub trait ConsoleFormatter {
     fn global_this(&self) -> &JSGlobalObject;
-    /// `Formatter.printAs(comptime Format, Writer, writer, value, jsType)` —
-    /// the const-generic `ENABLE_ANSI_COLORS` mirrors Zig's comptime bool.
     fn print_as<W: core::fmt::Write, const ENABLE_ANSI_COLORS: bool>(
         &mut self,
         tag: FormatTag,
@@ -296,10 +285,8 @@ pub trait ConsoleFormatter {
     /// calling this pair manually when the indented region contains `?` early
     /// returns.
     fn indent_inc(&mut self);
-    /// `formatter.indent -|= 1` — saturating decrement (Zig spelling).
+    /// Saturating decrement of the nesting level.
     fn indent_dec(&mut self);
-    /// Zig: `formatter.indent += 1; defer formatter.indent -|= 1;`.
-    ///
     /// Shorthand for [`IndentScope::new`]. Shadow the binding for the indented
     /// block; the guard `Deref`s to `&mut Self` so method calls auto-deref, and
     /// `Drop` restores the indent on every exit path (including `?`).
@@ -319,8 +306,7 @@ pub trait ConsoleFormatter {
     ) -> core::fmt::Result;
 }
 
-/// RAII indent guard for [`ConsoleFormatter`] — Zig's
-/// `formatter.indent += 1; defer formatter.indent -|= 1;` pair.
+/// RAII indent guard for [`ConsoleFormatter`].
 ///
 /// Increments on construction, decrements on `Drop`. `Deref`s to the wrapped
 /// formatter so the guard can shadow the original binding for the indented
@@ -437,8 +423,8 @@ pub use self::top_exception_scope::{
     call_false_is_throw_at, call_null_is_throw, call_null_is_throw_at, call_zero_is_throw,
     call_zero_is_throw_at,
 };
-/// Generated FFI wrappers for C++ `[[ZIG_EXPORT(mode)]]` functions — Rust analogue of
-/// Zig's `bun.cpp.*`. Emitted by `src/codegen/cppbind.ts` into
+/// Generated FFI wrappers for C++ `[[ZIG_EXPORT(mode)]]` functions.
+/// Emitted by `src/codegen/cppbind.ts` into
 /// `${BUN_CODEGEN_DIR}/cpp.rs` and `include!`d here so every throwing C++ FFI
 /// is reachable as `bun_jsc::cpp::Name(...)` with a properly-scoped exception
 /// check (no `global.has_exception()` after-the-fact).
@@ -572,8 +558,7 @@ pub mod work_task;
 
 /// Binding for JSCInitialize in ZigGlobalObject.cpp
 pub fn initialize(eval_mode: bool) {
-    // Spec jsc.zig:251 — `bun.analytics.Features.jsc += 1`. Counter lives in
-    // `bun_core` so this crate doesn't depend on
+    // The counter lives in `bun_core` so this crate doesn't depend on
     // `bun_analytics`.
     bun_core::analytics::Features::jsc_inc();
     let env = bun_sys::environ();
@@ -621,7 +606,6 @@ fn is_one_shot_eval_invocation() -> bool {
     false
 }
 
-/// Port of `onJSCInvalidEnvVar` (jsc.zig:254).
 extern "C" fn on_jsc_invalid_env_var(name: *const u8, len: usize) {
     // SAFETY: C++ guarantees `name[..len]` is valid for the call.
     let name = unsafe { bun_core::ffi::slice(name, len) };
@@ -637,7 +621,6 @@ Warning: options change between releases of Bun and WebKit without notice. This
 }
 
 /// `bun.JSError` — the canonical Bun JS error union (`error{Thrown, OutOfMemory, Terminated}`).
-/// `JsResult<T>` is the Rust spelling of Zig's `bun.JSError!T`.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum JsError {
     /// A JavaScript exception is pending in the VM's exception scope.
@@ -740,36 +723,33 @@ impl<T> JsResultExt for JsResult<T> {
 
 impl From<bun_core::Error> for JsError {
     fn from(_: bun_core::Error) -> Self {
-        // PORT NOTE: Zig coerces arbitrary `anyerror` into the JS error union by
-        // throwing a generic Error; the throw happens at the call site. Mapping
-        // to `Thrown` here lets `?` propagate while the actual throw is handled
-        // by the host-fn wrapper.
+        // Mapping to `Thrown` here lets `?` propagate while the actual throw
+        // is handled by the host-fn wrapper.
         JsError::Thrown
     }
 }
 
 impl From<JsError> for bun_core::Error {
     /// Widen a `bun.JSError` value back into the `anyerror` newtype. Preserves
-    /// the exact Zig tag (`@errorName`) so call sites that round-trip through
+    /// the exact error tag so call sites that round-trip through
     /// `bun_core::Error` (e.g. the `bun_bundler::dispatch::DevServerVTable`
     /// boundary) keep `error.OutOfMemory` distinguishable from `error.JSError`.
     #[inline]
     fn from(e: JsError) -> Self {
         match e {
             JsError::OutOfMemory => bun_core::err!("OutOfMemory"),
-            // `Terminated` is a Rust-port addition (worker shutdown); it has no
-            // distinct Zig `error.` tag, so collapse into `JSError` like every
-            // other thrown JS exception.
+            // `Terminated` (worker shutdown) has no distinct error tag of its
+            // own, so collapse into `JSError` like every other thrown JS
+            // exception.
             JsError::Thrown | JsError::Terminated => bun_core::err!("JSError"),
         }
     }
 }
 
-/// Adapter for Zig-style `(comptime fmt, args)` throw helpers ported to Rust.
+/// Adapter for `(fmt, args)`-style throw helpers.
 ///
-/// Zig's `globalThis.throw("msg {s}", .{x})` formats `fmt` with `args` and
-/// throws the result. The mechanically-ported call sites pass either `()`
-/// (Zig `.{}`, no interpolation — message *is* the literal) or a pre-expanded
+/// Call sites pass either `()`
+/// (no interpolation — message *is* the literal) or a pre-expanded
 /// `format_args!(..)` (interpolation already applied — message *is* the
 /// `Arguments` value). This trait dispatches both shapes onto the canonical
 /// [`JSGlobalObject::throw`] / [`JSGlobalObject::throw_invalid_arguments`]
@@ -787,7 +767,7 @@ pub trait ThrowFmtArgs: Sized {
 impl ThrowFmtArgs for () {
     #[inline]
     fn dispatch_throw(self, global: &JSGlobalObject, fmt: &'static str) -> JsError {
-        // Zig `.{}` — no interpolation; the literal IS the message. Route
+        // No interpolation; the literal IS the message. Route
         // through `throw` with an `Arguments` whose `as_str()` is `Some(fmt)`
         // so `create_error_instance` hits its static-string fast path.
         global.throw(format_args!("{fmt}"))
@@ -820,7 +800,7 @@ impl ThrowFmtArgs for core::fmt::Arguments<'_> {
 /// must use absolute `::bun_jsc::` paths and cannot assume `::bun_core` is in
 /// the consumer crate's dep graph.
 pub use bun_core::heap;
-/// Debug-only binding-presence marker. In Zig this is `jsc.markBinding(@src())`.
+/// Debug-only binding-presence marker.
 /// MOVE_DOWN: the macro lives in `bun_core` (no jsc dep) so `bun_io` /
 /// `bun_http_jsc` / `bun_event_loop` can call it without a `bun_jsc` cycle.
 /// Re-exported here so existing `crate::mark_binding!()` call sites resolve.
@@ -845,7 +825,7 @@ pub mod __macro_support {
 
     /// Normalizes a host-fn body's return type to `JsResult<JSValue>` so the
     /// proc-macro can wrap bodies that return either `JSValue` or
-    /// `JsResult<JSValue>` (mirrors Zig's `anytype` dispatch in `toJSHostFn`).
+    /// `JsResult<JSValue>`.
     pub trait IntoHostFnResult {
         fn into_host_fn_result(self) -> JsResult<JSValue>;
     }
@@ -893,8 +873,8 @@ pub mod __macro_support {
     }
 
     /// Map a `JsResult<JSValue>` from a Rust host fn to the raw `JSValue` the
-    /// JSC ABI expects (`.ZERO` when an exception is/was thrown). Mirrors
-    /// `host_fn.zig:toJSHostCall` — installs an `ExceptionValidationScope`
+    /// JSC ABI expects (`.ZERO` when an exception is/was thrown).
+    /// Installs an `ExceptionValidationScope`
     /// pinned at the macro caller's `Location` and asserts the empty/thrown
     /// invariant.
     ///
@@ -908,7 +888,7 @@ pub mod __macro_support {
         global: &JSGlobalObject,
         f: impl FnOnce() -> R,
     ) -> JSValue {
-        // PORT NOTE: Zig passed `@src()` explicitly; `to_js_host_call` is
+        // `to_js_host_call` is
         // `#[track_caller]` so the caller's `Location` propagates through this
         // `#[track_caller]` shim into `ExceptionValidationScope::init`.
         super::host_fn::to_js_host_call(global, move || f().into_host_fn_result())
@@ -1003,7 +983,7 @@ mod __macro_smoke {
 // JSC Classes Bindings — re-exported from their per-type modules (declared
 // above with `#[path = "…"] pub mod …;`). These were previously placeholder
 // newtypes; the real opaque-FFI structs now live in their own files and are
-// surfaced here at the crate root to match `jsc.zig`'s flat namespace.
+// surfaced here at the crate root.
 pub use self::cached_bytecode::CachedBytecode;
 pub use self::deferred_error::DeferredError;
 pub use self::dom_form_data::DOMFormData;
@@ -1021,9 +1001,9 @@ pub use self::js_global_object::{GlobalRef, JSGlobalObject};
 pub use self::vm::{HeapType, Lock as ApiLock, VM};
 
 /// Options for `JSGlobalObject::validate_integer_range` / `validate_bigint_range`.
-/// Mirrors Zig's `IntegerRange` (comptime min/max collapsed to i128 so every
+/// min/max are `i128` so every
 /// signed/unsigned primitive's bounds + MIN/MAX_SAFE_INTEGER fit without
-/// narrowing). Defined at crate root so `bun_runtime` callers and
+/// narrowing. Defined at crate root so `bun_runtime` callers and
 /// `JSGlobalObject.rs` (which re-exports it) share one type.
 #[derive(Clone, Copy)]
 pub struct IntegerRange {
@@ -1054,7 +1034,7 @@ pub type IntegerRangeOptions = IntegerRange;
 pub mod resolved_source;
 pub use self::resolved_source::ResolvedSource;
 
-/// `ResolvedSource.Tag` — `enum(u32)` in Zig, plain `uint32_t` in C++
+/// `ResolvedSource.Tag` — plain `uint32_t` in C++
 /// (`headers-handwritten.h:123`). Modelled as a transparent `u32` newtype so
 /// the generated InternalModuleRegistry IDs (`(1 << 9) | id`, see
 /// `build/*/codegen/generated_resolved_source_tag.rs`) round-trip without an
@@ -1085,8 +1065,7 @@ pub mod resolved_source_tag {
         pub const CommonJsCustomExtension: Self = Self(10);
 
         /// Map a canonical builtin-module specifier (e.g. `b"node:fs"`) to its
-        /// InternalModuleRegistry tag (`(1 << 9) | id`). Ports Zig's
-        /// `@field(ResolvedSource.Tag, @tagName(hardcoded))` (ModuleLoader.zig).
+        /// InternalModuleRegistry tag (`(1 << 9) | id`).
         ///
         /// Unrecognised names debug-panic / release-fall-back to `Javascript`;
         /// callers feed only `HardcodedModule` strum values, so a miss means a
@@ -1137,7 +1116,7 @@ pub use self::fetch_headers::{FetchHeaders, HTTPHeaderName};
 /// in C++ (`BunBuiltinNames.h`). Passed to `JSValue::fast_get` as a `u8` index
 /// into `BuiltinNamesMap` (src/jsc/bindings/bindings.cpp).
 ///
-/// The Zig source (JSValue.zig:1491) uses lowercase variant names; downstream
+/// Variant names are lowercase; downstream
 /// Rust callers were drafted with PascalCase. Associated-const aliases below
 /// keep both spellings working until the call sites converge.
 #[repr(u8)]
@@ -1240,7 +1219,7 @@ impl Drop for EnsureStillAlive {
 /// `jsc.JSPromise.Strong` — a `Strong.Optional` typed to hold a `JSPromise`.
 pub use self::js_promise::Strong as JSPromiseStrong;
 
-/// `JSPromise.Status` (JSPromise.zig) — surfaced at the crate root as
+/// `JSPromise.Status` — surfaced at the crate root as
 /// `PromiseStatus` for downstream callers (web_worker.rs / fetch.rs reference
 /// it via `jsc::PromiseStatus::{Pending,Fulfilled,Rejected}`).
 pub use self::js_promise::Status as PromiseStatus;
@@ -1251,21 +1230,19 @@ pub use self::js_promise::Status as PromiseStatus;
 pub use bun_ptr::RefPtr;
 
 /// `bun.String` — refcounted WTF-backed string. Re-exported at the crate root
-/// so submodules ported from Zig can write `crate::String` (the Zig spelling
-/// is `bun.String`, which the lazy import graph routed via `jsc`).
+/// so submodules can write `crate::String`.
 pub use bun_core::String;
 
 /// Legacy alias used by runtime drafts: `VirtualMachineRef` is just the
 /// `VirtualMachine` struct itself (callers hold `*mut VirtualMachineRef`).
 pub use self::virtual_machine::VirtualMachine as VirtualMachineRef;
 
-/// `jsc.AnyPromise` — `JSPromise | JSInternalPromise` (AnyPromise.zig).
+/// `jsc.AnyPromise` — `JSPromise | JSInternalPromise`.
 pub use self::any_promise::AnyPromise;
 
-/// `JSPromise.UnwrapMode` (JSPromise.zig:349).
 pub use self::js_promise::UnwrapMode as PromiseUnwrapMode;
 
-/// `JSPromise.Unwrapped` (JSPromise.zig:343) — surfaced at the crate root as
+/// `JSPromise.Unwrapped` — surfaced at the crate root as
 /// `PromiseResult` for downstream callers (Macro.rs / JSBundler.rs reference it
 /// via `jsc::PromiseResult::{Pending,Fulfilled,Rejected}`).
 pub use self::js_promise::Unwrapped as PromiseResult;
@@ -1365,7 +1342,7 @@ impl JSGlobalObject {
 /// expect (`jsc.RangeErrorOptions`).
 pub type RangeErrorOptions<'a> = bun_core::fmt::OutOfRangeOptions<'a>;
 
-/// `JSGlobalObject.GregorianDateTime` (JSGlobalObject.zig:35).
+/// Broken-down calendar date/time exchanged with C++.
 #[repr(C)]
 #[derive(Debug, Default, Clone, Copy)]
 pub struct GregorianDateTime {
@@ -1378,9 +1355,7 @@ pub struct GregorianDateTime {
     pub weekday: i32,
 }
 
-/// `JSGlobalObject.validateObject`'s anonymous options struct
-/// (JSGlobalObject.zig:710). Field names match Zig (`nullable`, not
-/// `allow_nullable`) so callers porting from Zig don't have to rename.
+/// Options for `JSGlobalObject::validate_object`.
 #[derive(Default, Copy, Clone)]
 pub struct ValidateObjectOpts {
     pub allow_array: bool,
@@ -1388,7 +1363,7 @@ pub struct ValidateObjectOpts {
     pub nullable: bool,
 }
 
-/// Mirrors `JSGlobalObject.BunPluginTarget` (JSGlobalObject.zig). Defined once
+/// `BunPluginTarget` is defined once
 /// in `bun_bundler::transpiler` (lowest tier) and re-exported via
 /// `js_global_object` so `crate::BunPluginTarget` and every consumer share one
 /// nominal type.
@@ -1408,8 +1383,7 @@ pub use self::js_object::{ExternColumnIdentifier, ExternColumnIdentifierValue, J
 pub mod call_frame;
 pub use self::call_frame::{ArgumentsSlice, CallFrame};
 
-/// `JSValue.toEnumFromMap(global, "signal", SignalCode, SignalCode.Map)`
-/// (JSValue.zig:1703). Lives here (not in `bun_sys_jsc`) because the orphan
+/// Lives here (not in `bun_sys_jsc`) because the orphan
 /// rule requires either the trait or the type to be local; `FromJsEnum` is.
 impl FromJsEnum for bun_sys::SignalCode {
     fn from_js_value(
@@ -1430,7 +1404,7 @@ impl FromJsEnum for bun_sys::SignalCode {
         match hit {
             Some(code) => Ok(code),
             None => {
-                // Mirror Zig's comptime `toEnumFromMap` list
+                // Expected-names list
                 // (`'SIGHUP', 'SIGINT', … or 'SIGSYS'`), built from the
                 // canonical signal X-macro so names are never re-spelled.
                 let names = &bun_core::SIGNAL_NAMES[1..];
@@ -1560,11 +1534,9 @@ pub use self::runtime_transpiler_store::RuntimeTranspilerStore;
 pub mod web_worker;
 pub use self::web_worker::WebWorker;
 
-// LAYERING: `jsc.zig:121-124` re-exports `Jest`/`TestScope`/`Expect`/`Snapshot`
-// from `../runtime/test_runner/` — a forward-dep on `bun_runtime`, which itself
-// depends on `bun_jsc`. The Zig side gets away with this via lazy compilation;
-// in Rust it is a hard cycle. The Zig spec already marks these
-// `// TODO: move into bun.api`, so the Rust port executes that TODO: callers
+// LAYERING: `Jest`/`TestScope`/`Expect`/`Snapshot` live in
+// `bun_runtime::test_runner` — a forward-dep on `bun_runtime`, which itself
+// depends on `bun_jsc`, so aliasing them here would be a hard cycle. Callers
 // reference `bun_runtime::test_runner::{jest, expect, snapshot}` directly
 // instead of routing through `bun_jsc`. No alias is exported here.
 
@@ -1591,7 +1563,7 @@ pub type PlatformEventLoop = bun_uws::Loop;
 pub type PlatformEventLoop = bun_io::Loop;
 
 pub use self::c_api as C;
-/// Legacy lower-case alias (Zig: `jsc.c`).
+/// Legacy lower-case alias.
 pub use self::c_api as c;
 /// Deprecated: Remove all of these please.
 pub use self::sizes as Sizes;
@@ -1620,7 +1592,7 @@ pub mod webcore_types;
 // so `bun_runtime` callers don't reach through `node_path`.
 pub use self::node_path::{ThreadSafe, Unprotect};
 
-/// `jsc.WebCore` (jsc.zig:163, deprecated alias) — only the data-shape subset
+/// `jsc.WebCore` (deprecated alias) — only the data-shape subset
 /// that was hoisted to this tier. Reach for `bun_runtime::webcore` for the
 /// full API surface.
 #[allow(non_snake_case)]
@@ -1628,7 +1600,7 @@ pub mod WebCore {
     pub use crate::webcore_types::store::{Store, StoreRef};
     pub use crate::webcore_types::{Blob, MAX_SIZE, SizeType};
 }
-/// Lower-case alias + nested `blob` namespace (Zig: `jsc.webcore.blob.Store`).
+/// Lower-case alias + nested `blob` namespace.
 pub mod webcore {
     pub use crate::webcore_types::{Blob, MAX_SIZE, SizeType};
     pub mod blob {
@@ -1636,31 +1608,27 @@ pub mod webcore {
         pub use crate::webcore_types::{MAX_SIZE, SizeType};
     }
 }
-/// `jsc.Node` (jsc.zig:165, deprecated alias) — `PathLike`/`PathOrFileDescriptor`
+/// `jsc.Node` (deprecated alias) — `PathLike`/`PathOrFileDescriptor`
 /// hoisted to this tier; full `bun.api.node` lives in `bun_runtime::node`.
 #[allow(non_snake_case)]
 pub mod Node {
-    /// `bun.api.node.ErrorCode` — the Node-compat `ERR_*` codes. The Zig spec
-    /// defines this in `runtime/node/types.zig` as a re-export of the codegen
-    /// `Error` enum; in the Rust port that enum is [`crate::ErrorCode`], so the
-    /// `node::ErrorCode` alias resolves to it directly (LAYERING: avoids a
+    /// `bun.api.node.ErrorCode` — the Node-compat `ERR_*` codes; the
+    /// `node::ErrorCode` alias resolves directly to [`crate::ErrorCode`]
+    /// (LAYERING: avoids a
     /// `bun_jsc → bun_runtime` cycle for `DeferredError` / `node_error_binding`).
     pub use crate::ErrorCode;
     pub use crate::node_path::*;
 }
 pub use self::Node as node;
 
-/// `jsc.zig:170 markBinding(@src())` — opt-in `BUN_DEBUG_JSC=1` trace of every
-/// FFI binding entry. Zig: `log("{s} ({s}:{d})", .{src.fn_name, src.file, src.line})`
-/// where `log = Output.scoped(.JSC, .hidden)`.
+/// Opt-in `BUN_DEBUG_JSC=1` trace of every FFI binding entry.
 ///
 /// LAYERING: the `JSC` scoped logger lives in `bun_core::Global::JSC_SCOPE` (it
 /// has no jsc dep) so lower-tier crates can mark bindings without depending on
-/// `bun_jsc`. This fn is the thin wrapper `jsc.zig` exposes for in-crate use.
+/// `bun_jsc`. This fn is the thin wrapper exposed for in-crate use.
 ///
-/// PORT NOTE: `std.builtin.SourceLocation.fn_name` has no Rust equivalent;
-/// `#[track_caller]` only surfaces file/line, so the leading `{fn_name}` is
-/// dropped. Prefer the `mark_binding!()` macro form (re-exported above) which
+/// Note: `#[track_caller]` only surfaces file/line, so no function name is
+/// logged. Prefer the `mark_binding!()` macro form (re-exported above) which
 /// captures `module_path!()` at the call site.
 #[track_caller]
 #[inline]
@@ -1671,8 +1639,7 @@ pub fn mark_binding() {
     }
 }
 
-/// `jsc.zig:173 markMemberBinding(class, @src())` —
-/// `log("{s}.{s} ({s}:{d})", .{class, src.fn_name, src.file, src.line})`.
+/// Like [`mark_binding`], with a class-name prefix.
 #[inline]
 pub fn mark_member_binding(class: &'static str, src: &core::panic::Location<'static>) {
     if cfg!(debug_assertions) && bun_core::Global::JSC_SCOPE.is_visible() {
@@ -1685,9 +1652,9 @@ pub fn mark_member_binding(class: &'static str, src: &core::panic::Location<'sta
     }
 }
 
-// LAYERING: `jsc.zig:183` aliases `Subprocess = bun.api.Subprocess`, but that
-// type lives in `bun_runtime::api` (forward-dep). The Rust port drops the
-// alias; callers reference `bun_runtime::api::Subprocess` directly.
+// LAYERING: no `Subprocess` alias is exported here — that type lives in
+// `bun_runtime::api` (forward-dep); callers reference
+// `bun_runtime::api::Subprocess` directly.
 
 /// Generated classes — re-run generate-classes.ts with .rs output.
 pub mod codegen {
@@ -1708,11 +1675,10 @@ pub mod codegen {
     }
 }
 pub use self::codegen as Codegen;
-// `jsc.zig:202` — `GeneratedClassesList` lives in `bun_runtime::GeneratedClassesList`
+// `GeneratedClassesList` lives in `bun_runtime::GeneratedClassesList`
 // (layering: every aliased type is defined above `bun_jsc`).
 
 /// Extension trait providing JSC-aware methods on `bun_core::String`.
-/// Mirrors the `pub usingnamespace` in bun_string_jsc.zig.
 pub trait StringJsc {
     fn from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<bun_core::String>;
     fn to_js(&self, global: &JSGlobalObject) -> JsResult<JSValue>;
@@ -1747,9 +1713,8 @@ impl StringJsc for bun_core::String {
 }
 
 /// Extension trait providing JSC-aware methods on
-/// `bun_core::SliceWithUnderlyingString` (lower-tier, no JSC dep).
-/// Mirrors the JSC-touching methods on Zig's `SliceWithUnderlyingString`
-/// (`toJS`, `transferToJS`, `reportExtraMemory`); the free-function bodies
+/// `bun_core::SliceWithUnderlyingString` (lower-tier, no JSC dep) —
+/// `to_js`, `transfer_to_js`, `report_extra_memory`; the free-function bodies
 /// live in [`bun_string_jsc`].
 pub trait SliceWithUnderlyingStringJsc {
     fn to_js(&mut self, global: &JSGlobalObject) -> JsResult<JSValue>;
@@ -1765,8 +1730,7 @@ impl SliceWithUnderlyingStringJsc for bun_core::SliceWithUnderlyingString {
     fn transfer_to_js(&mut self, global: &JSGlobalObject) -> JsResult<JSValue> {
         bun_string_jsc::slice_with_underlying_string_transfer_to_js(self, global)
     }
-    /// `SliceWithUnderlyingString.reportExtraMemory` (string.zig:1041) —
-    /// account `utf8`'s backing allocation against the GC heap unless it is
+    /// Account `utf8`'s backing allocation against the GC heap unless it is
     /// already JSC-owned (WTF-backed) or borrowed.
     fn report_extra_memory(&mut self, vm: &VM) {
         #[cfg(debug_assertions)]
@@ -1793,11 +1757,8 @@ impl SliceWithUnderlyingStringJsc for bun_core::SliceWithUnderlyingString {
 pub trait ZigStringJsc: Sized {
     fn to_error_instance(&self, global: &JSGlobalObject) -> JSValue;
     fn to_type_error_instance(&self, global: &JSGlobalObject) -> JSValue;
-    /// `ZigString.toSyntaxErrorInstance` (ZigString.zig:814).
     fn to_syntax_error_instance(&self, global: &JSGlobalObject) -> JSValue;
-    /// `ZigString.toRangeErrorInstance` (ZigString.zig:819).
     fn to_range_error_instance(&self, global: &JSGlobalObject) -> JSValue;
-    /// `ZigString.toDOMExceptionInstance` (ZigString.zig:809).
     fn to_dom_exception_instance(&self, global: &JSGlobalObject, code: DOMExceptionCode)
     -> JSValue;
     /// `ZigString.toJS` — copies into a GC-managed `JSString` (or hands an
@@ -1947,14 +1908,12 @@ pub unsafe fn zig_string_to_external_u16(
 }
 
 /// Extension trait providing JSC-aware methods on `bun_sys::Error` (`bun.sys.Error`).
-/// Mirrors `Error.toJS` / `Error.throw` in src/sys/Error.zig.
 pub trait SysErrorJsc {
     fn to_system_error(&self) -> SystemError;
     fn to_js(&self, global: &JSGlobalObject) -> JSValue;
     fn throw(&self, global: &JSGlobalObject) -> JsError;
 }
 impl SysErrorJsc for bun_sys::Error {
-    /// `bun.sys.Error.toSystemError()` (src/sys/Error.zig:toSystemError).
     fn to_system_error(&self) -> SystemError {
         SystemError::from(bun_sys::Error::to_system_error(self))
     }
@@ -1967,12 +1926,11 @@ impl SysErrorJsc for bun_sys::Error {
 }
 
 /// Extension trait providing JSC-aware methods on `bun_ast::Log`.
-/// Mirrors `Log.toJS` / `Log.toJSArray` in src/logger.zig.
 pub trait LogJsc {
     fn to_js(&self, global: &JSGlobalObject, message: &str) -> JsResult<JSValue>;
     fn to_js_array(&self, global: &JSGlobalObject) -> JsResult<JSValue>;
 }
-/// Spec `msgToJS` (src/logger_jsc/logger_jsc.zig:23) — wrap a single `Msg` in
+/// Wrap a single `Msg` in
 /// either a `BuildMessage` or `ResolveMessage` JS cell, dispatching on metadata.
 fn msg_to_js(msg: &bun_ast::Msg, global: &JSGlobalObject) -> JsResult<JSValue> {
     match msg.metadata {
@@ -1983,7 +1941,7 @@ fn msg_to_js(msg: &bun_ast::Msg, global: &JSGlobalObject) -> JsResult<JSValue> {
 impl LogJsc for bun_ast::Log {
     fn to_js(&self, global: &JSGlobalObject, message: &str) -> JsResult<JSValue> {
         let msgs = &self.msgs;
-        // Spec: `@min(msgs.len, errors_stack.len)` — errors_stack is `[256]JSValue`.
+        // Cap at 256 — the consumer's stack buffer holds at most 256 JSValues.
         let count = msgs.len().min(256);
         match count {
             0 => Ok(JSValue::UNDEFINED),
@@ -2048,7 +2006,7 @@ pub trait JsClass: Sized {
 
     /// Dynamic heap footprint reported to JSC's GC via
     /// `reportExtraMemoryAllocated` / `reportExtraMemoryVisited`
-    /// (generate-classes.ts:1656-1660, 1913-1916). Mirrors the Zig
+    /// (generate-classes.ts:1656-1660, 1913-1916). Implements the
     /// `${typeName}.estimatedSize(thisValue)` contract: types that own large
     /// out-of-line buffers (Blob/Request/Response bodies) override this so the
     /// collector sees real memory pressure, not just `size_of::<Self>()`.
@@ -2067,9 +2025,7 @@ pub trait JsClass: Sized {
 /// resolution on `${T}::finalize` picks an *inherent* `fn finalize(self:
 /// Box<Self>)` first when one exists (refcounted / leak-on-pending types),
 /// otherwise falls through to this trait's default: drop the `Box`, running
-/// `T`'s `Drop` glue and freeing the allocation. Zig has no `Drop`, so every
-/// `*.zig` sibling must spell `bun.destroy(this)` per type; in Rust the
-/// trivial body collapses to this one default.
+/// `T`'s `Drop` glue and freeing the allocation.
 ///
 /// **Override by defining an inherent `pub fn finalize(self: Box<Self>)` on
 /// the concrete type** — do *not* `impl JsFinalize for MyType`; the blanket
@@ -2132,20 +2088,17 @@ pub trait FnTyped<Context> {
     fn call(this: &mut Context);
 }
 
-/// `jsc.zig:239` — `Error = @import("ErrorCode").Error`. The codegen module
-/// (`build/*/codegen/ErrorCode.zig`) defines `pub const Error = enum(u16)`;
-/// the Rust port of that enum is [`ErrorCode`] (`src/jsc/ErrorCode.rs`), so
-/// this alias resolves to the same type under both names.
+/// Legacy alias for [`ErrorCode`] (`src/jsc/ErrorCode.rs`) — the same type
+/// under both names.
 pub type Error = ErrorCode;
 
 /// Maximum Date in JavaScript is less than Number.MAX_SAFE_INTEGER (u52).
 pub const INIT_TIMESTAMP: JSTimeType = (1u64 << 52) - 1;
 pub type JSTimeType = u64;
 
-/// `jsc.zig:245 toJSTime(sec, nsec)`. Zig: `@intCast` (safety-checked sign
-/// cast) into `u64`, then `@truncate(u52)`. Compute in `i128` first so the
-/// `sec * 1000` widening cannot overflow `isize`, then cast to `u64` (matching
-/// `@intCast` for non-negative inputs) before masking to 52 bits (`@truncate`).
+/// Compute in `i128` first so the
+/// `sec * 1000` widening cannot overflow `isize`, then cast to `u64`
+/// (non-negative inputs) before masking to 52 bits.
 pub fn to_js_time(sec: isize, nsec: isize) -> JSTimeType {
     const MS_PER_S: i128 = bun_core::time::MS_PER_S as i128;
     let millisec = (nsec as i128) / bun_core::time::NS_PER_MS as i128;
@@ -2156,7 +2109,6 @@ pub fn to_js_time(sec: isize, nsec: isize) -> JSTimeType {
 pub const MAX_SAFE_INTEGER: i64 = 9007199254740991;
 pub const MIN_SAFE_INTEGER: i64 = -9007199254740991;
 
-// TODO(port): move to jsc_sys
 unsafe extern "C" {
     fn JSCInitialize(
         env: *const *const c_char,
@@ -2167,16 +2119,13 @@ unsafe extern "C" {
     );
 }
 
-// TODO(port): generated module — re-run bindgen with .rs output. Hand-stubbed
-// in `generated.rs` until `src/codegen/generate-classes.ts` grows a `.rs`
-// backend.
+// Hand-stubbed in `generated.rs` until `src/codegen/generate-classes.ts`
+// grows a `.rs` backend (same arrangement as `r#gen` below).
 #[path = "generated.rs"]
 pub mod generated;
 
-/// `bun.gen` — bindgen dispatch shims (`src/jsc/bindings/GeneratedBindings.zig`).
-/// Hand-ported per-module until `src/codegen/bindgen.ts` grows a `.rs` backend.
+/// `bun.gen` — bindgen dispatch shims.
+/// Hand-written per-module until `src/codegen/bindgen.ts` grows a `.rs` backend.
 /// (`gen` is a reserved keyword in edition 2024; use `r#gen` at call sites.)
 #[path = "bindings/GeneratedBindings.rs"]
 pub mod r#gen;
-
-// ported from: src/jsc/jsc.zig
diff --git a/src/jsc/modules/_NativeModule.h b/src/jsc/modules/_NativeModule.h
index 70b19153bae..82beb9692e0 100644
--- a/src/jsc/modules/_NativeModule.h
+++ b/src/jsc/modules/_NativeModule.h
@@ -12,7 +12,7 @@
 
 // To add a new native module
 //   1. Add a new line to `BUN_FOREACH_NATIVE_MODULE`
-//   2. Add a case to `module_loader.zig` that resolves the import.
+//   2. Add a case to `HardcodedModule` (src/resolve_builtins/HardcodedModule.rs) that resolves the import.
 //   3. Add a new file in this folder named after the module, camelcase and suffixed with Module,
 //      like "NodeBufferModule.h" or "BunJSCModule.h". It should call DEFINE_NATIVE_MODULE(name).
 //
diff --git a/src/jsc/node_path.rs b/src/jsc/node_path.rs
index 0e0853dc83b..3f2efd20713 100644
--- a/src/jsc/node_path.rs
+++ b/src/jsc/node_path.rs
@@ -1,6 +1,6 @@
 //! `node.PathLike` / `node.PathOrFileDescriptor` — single nominal definitions.
 //!
-//! LAYERING: ported from `src/runtime/node/types.zig:532-910`. Defined at the
+//! LAYERING: defined at the
 //! `bun_jsc` tier because every variant payload (`CowSlice<u8>`, `Buffer` =
 //! `MarkedArrayBuffer`, `SliceWithUnderlyingString`, `ZigStringSlice`, `Fd`)
 //! is already reachable from this crate. `bun_runtime::node::types`
@@ -16,12 +16,12 @@ use crate::array_buffer::MarkedArrayBuffer;
 // ──────────────────────────────────────────────────────────────────────────
 // RAII for `protect()`/`unprotect()` pairs taken by `to_thread_safe()`.
 //
-// Zig's async-fs path calls `args.toThreadSafe()` (which `JSValue.protect()`s
+// The async-fs path calls `to_thread_safe()` (which `JSValue::protect()`s
 // any borrowed JS-backed buffers so the work-pool thread may read them) and
-// later `args.deinitAndUnprotect()` to release. In Rust the "deinit" half is
+// must later release them. The "deinit" half is
 // already `Drop`; only the JS-side `unprotect()` needs an explicit hook, and
 // pairing it with the protect via a guard type removes the leak hazard on
-// every early return between `toThreadSafe` and the manual cleanup.
+// every early return between `to_thread_safe` and the manual cleanup.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Undo the `JSValue::protect()` calls taken by [`to_thread_safe`](
@@ -37,8 +37,7 @@ pub trait Unprotect {
 
 /// RAII guard returned by `into_thread_safe()`: a `T` whose JS-backed buffers
 /// have been `protect()`ed. `Drop` calls [`Unprotect::unprotect`] then drops
-/// the inner `T` normally — the Rust spelling of Zig's
-/// `defer args.deinitAndUnprotect()`.
+/// the inner `T` normally.
 ///
 /// `repr(transparent)` so identity-casts in the const-generic dispatch macros
 /// (see `node_fs.rs`'s `args_as!`) remain bit-exact.
@@ -86,7 +85,7 @@ impl<T: Unprotect + Default> Default for ThreadSafe<T> {
 
 // `ThreadSafe<T>` crosses to the work-pool thread; auto-`Send` iff `T: Send`.
 
-/// `node.PathLike` (types.zig:532) — `union(enum)`.
+/// `node.PathLike`.
 pub enum PathLike {
     String(CowSlice<u8>),
     Buffer(MarkedArrayBuffer),
@@ -103,7 +102,7 @@ impl Default for PathLike {
 }
 
 impl Clone for PathLike {
-    /// Zig `PathLike` is bitwise-copy; the Rust port bumps any owning ref so
+    /// Bumps any owning ref so
     /// the clone is independently droppable *and* `clone().slice()` returns
     /// the same bytes as the original.
     fn clone(&self) -> Self {
@@ -168,7 +167,6 @@ impl Drop for PathLike {
 }
 
 impl PathLike {
-    /// Zig parity: `pathlike == .string`.
     #[inline]
     pub fn is_string(&self) -> bool {
         matches!(self, Self::String(_))
@@ -193,11 +191,11 @@ impl PathLike {
         }
     }
 
-    /// `PathLike.toThreadSafe()` (types.zig:557) — promote any borrowed-JS
+    /// Promote any borrowed-JS
     /// payload to a thread-safe representation. For `Buffer` the variant is
     /// kept and the backing JS value is `protect()`ed (paired with
     /// [`Unprotect::unprotect`]); the discriminant is preserved so callers
-    /// matching on `Buffer` after this call see the same shape as Zig.
+    /// matching on `Buffer` after this call see the same shape.
     ///
     /// Prefer [`Self::into_thread_safe`] which returns a [`ThreadSafe`] guard;
     /// this in-place form exists for nested calls from container types'
@@ -217,8 +215,7 @@ impl PathLike {
     }
 
     /// Consuming `to_thread_safe()`: protect any JS-backed buffer and return a
-    /// guard that unprotects on drop. The Rust replacement for Zig's
-    /// `args.toThreadSafe()` / `defer args.deinitAndUnprotect()` pair.
+    /// guard that unprotects on drop.
     #[inline]
     pub fn into_thread_safe(mut self) -> ThreadSafe<Self> {
         self.to_thread_safe();
@@ -227,7 +224,7 @@ impl PathLike {
 }
 
 impl Unprotect for PathLike {
-    /// `PathLike.deinitAndUnprotect()` (types.zig:571), JS-side half — undo
+    /// JS-side half of cleanup — undo
     /// the `protect()` taken by [`Self::to_thread_safe`] /
     /// `ArgumentsSlice::protect_eat`. Owned payloads are released by `Drop`.
     #[inline]
@@ -238,7 +235,7 @@ impl Unprotect for PathLike {
     }
 }
 
-/// `node.PathOrFileDescriptor` (types.zig:903) — `union(enum) { fd, path }`.
+/// `node.PathOrFileDescriptor`.
 pub enum PathOrFileDescriptor {
     Fd(Fd),
     Path(PathLike),
@@ -260,7 +257,7 @@ impl Clone for PathOrFileDescriptor {
     }
 }
 
-/// `PathOrFileDescriptor.SerializeTag` (types.zig:912) — `enum(u8)`.
+/// `PathOrFileDescriptor.SerializeTag`.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum PathOrFileDescriptorSerializeTag {
@@ -312,7 +309,7 @@ impl PathOrFileDescriptor {
 }
 
 impl Unprotect for PathOrFileDescriptor {
-    /// `PathOrFileDescriptor.deinitAndUnprotect()` (types.zig:934), JS-side half.
+    /// JS-side half of cleanup — see [`PathLike::unprotect`].
     #[inline]
     fn unprotect(&mut self) {
         if let Self::Path(p) = self {
@@ -333,20 +330,18 @@ impl core::fmt::Display for PathOrFileDescriptor {
 }
 
 impl PathOrFileDescriptor {
-    /// Zig: `pathlike == .path`.
     #[inline]
     pub fn is_path(&self) -> bool {
         matches!(self, Self::Path(_))
     }
 
-    /// Zig: `pathlike == .fd`.
     #[inline]
     pub fn is_fd(&self) -> bool {
         matches!(self, Self::Fd(_))
     }
 
-    /// Unwrap the `Path` arm. Panics on `Fd` (mirrors Zig's `pathlike.path`
-    /// direct field access, used only after the caller has matched on the tag).
+    /// Unwrap the `Path` arm. Panics on `Fd` (used only after the caller has
+    /// matched on the tag).
     #[inline]
     pub fn path(&self) -> &PathLike {
         match self {
diff --git a/src/jsc/rare_data.rs b/src/jsc/rare_data.rs
index 7fd72e979de..e61f53ad37e 100644
--- a/src/jsc/rare_data.rs
+++ b/src/jsc/rare_data.rs
@@ -91,17 +91,14 @@ impl HotMap {
         if gop.found_existing {
             panic!("HotMap already contains key");
         }
-        // PORT NOTE: `get_or_put` already boxed the key; Zig wrote
-        // `entry.key_ptr.* = dupe(key)` because its map didn't own keys.
+        // `get_or_put` already boxed the key; the map owns its keys.
         *gop.value_ptr = entry;
     }
 
     pub fn remove(&mut self, key: &[u8]) {
-        // PORT NOTE: Zig captured the stored key ptr to free post-removal; here
-        // the map owns the Box<[u8]> key and `swap_remove` drops it. Preserve
-        // the aliasing assert (caller must not pass the map's own key storage).
-        // Ordering doesn't matter for HotMap consumers — Zig's `orderedRemove`
-        // was incidental, not load-bearing.
+        // The map owns the Box<[u8]> key and `swap_remove` drops it. The
+        // aliasing assert below means the caller must not pass the map's own
+        // key storage. Ordering doesn't matter for HotMap consumers.
         let Some(i) = self._map.get_index(key) else {
             return;
         };
@@ -175,8 +172,9 @@ pub(crate) type CleanupHookFunction = extern "C" fn(*mut c_void);
 pub struct CleanupHook {
     pub ctx: *mut c_void,
     pub func: CleanupHookFunction,
-    // PORT NOTE: LIFETIMES.tsv says &'a JSGlobalObject (JSC_BORROW); raw ptr
-    // avoids threading a lifetime param through `RareData`.
+    // Conceptually a borrow of the JSGlobalObject (JSC_BORROW per
+    // LIFETIMES.tsv); a raw ptr avoids threading a lifetime param through
+    // `RareData`.
     pub global_this: *const JSGlobalObject,
 }
 
@@ -219,7 +217,7 @@ pub struct RareData {
     /// Erased `*mut webcore::blob::Store` (intrusive-refcounted on the runtime
     /// side). Constructed via `__bun_stdio_blob_store_new`; high tier casts back.
     /// `mode` is cached so [`Bun__Process__getStdinFdType`] doesn't have to
-    /// re-stat (Zig read `store.data.file.mode`).
+    /// re-stat.
     pub stderr_store: Option<NonNull<c_void>>,
     pub stderr_mode: Mode,
     pub stdin_store: Option<NonNull<c_void>>,
@@ -284,16 +282,16 @@ pub struct RareData {
 
     pub temp_pipe_read_buffer: Option<Box<PipeReadBuffer>>,
 
-    // PORT NOTE: `aws_signature_cache` field dropped — storage moved DOWN to
-    // `bun_s3_signing::credentials::AWS_SIGNATURE_CACHE` (process static). The
-    // Zig code always reached it via `getMainThreadVM()`, so it was a
-    // singleton in practice; hosting it in the consumer crate removes the
-    // upward `s3_signing → jsc` hook.
+    // There is intentionally no `aws_signature_cache` field — storage lives in
+    // `bun_s3_signing::credentials::AWS_SIGNATURE_CACHE` (process static; it
+    // was always reached via the main-thread VM, so it was a singleton in
+    // practice). Hosting it in the consumer crate removes the upward
+    // `s3_signing → jsc` hook.
     pub s3_default_client: Strong,
     pub default_csrf_secret: Box<[u8]>,
 
-    /// Owned NUL-terminated buffer (`[:0]u8`). `len()` includes the trailing 0;
-    /// [`Self::tls_default_ciphers`] strips it to match Zig `dupeZ` semantics.
+    /// Owned NUL-terminated buffer. `len()` includes the trailing 0;
+    /// [`Self::tls_default_ciphers`] strips it.
     pub tls_default_ciphers: Option<Box<[u8]>>,
 
     // proxy_env_storage moved to VirtualMachine — see comment there on why
@@ -303,7 +301,6 @@ pub struct RareData {
     pub path_buf: PathBuf,
 }
 
-// Type aliases matching Zig's local imports
 pub(crate) type FilePollStore = Async::file_poll::Store;
 
 impl Default for RareData {
@@ -368,7 +365,6 @@ impl PathBuf {
     const S: usize = MAX_PATH_BYTES;
 
     /// Returns the smallest lazily-allocated tier buffer that fits `min_len`.
-    // PERF(port): was stack-fallback (FixedBufferAllocator + fallback allocator).
     // Revisit caller semantics for inputs exceeding the large tier.
     pub fn get(&mut self, min_len: usize) -> &mut [u8] {
         if min_len <= 2 * Self::S {
@@ -442,8 +438,7 @@ pub struct Slot<'a> {
 }
 
 /// Helper macro: expands `$body` once per proxy-env field, binding `$name`
-/// (the static byte-string key) and `$field` (the field ident). Replaces
-/// the Zig `inline for (@typeInfo(...).fields)` iteration.
+/// (the static byte-string key) and `$field` (the field ident).
 macro_rules! for_each_proxy_field {
     ($self:expr, |$name:ident, $field:ident| $body:block) => {{
         // Uppercase fields are declared first. On Windows the case-insensitive
@@ -512,8 +507,7 @@ impl ProxyEnvSlots {
     /// parent's strings. Caller passes the parent's locked guard — the `Arc`
     /// load + clone is not atomic with respect to `Bun__setEnvValue`'s drop.
     pub fn clone_from(&mut self, parent: &ProxyEnvSlots) {
-        // PORT NOTE: reshaped for borrowck — Zig iterated fields via @typeInfo;
-        // here Arc::clone bumps the refcount.
+        // Arc::clone bumps the refcount.
         self.HTTP_PROXY.clone_from(&parent.HTTP_PROXY);
         self.http_proxy.clone_from(&parent.http_proxy);
         self.HTTPS_PROXY.clone_from(&parent.HTTPS_PROXY);
@@ -551,9 +545,8 @@ impl ProxyEnvSlots {
 /// A ref-counted heap-allocated byte slice. The env map stores borrowed
 /// `.bytes` slices; as long as any VM holds a ref, the bytes stay valid.
 ///
-/// PORT NOTE: Zig used intrusive `ThreadSafeRefCount`; LIFETIMES.tsv classifies
-/// holders as `Arc<RefCountedEnvValue>`, so the refcount lives in the `Arc`
-/// header and `ref`/`deref` become `Arc::clone`/`drop`.
+/// Holders are `Arc<RefCountedEnvValue>` (per LIFETIMES.tsv): the refcount
+/// lives in the `Arc` header, so ref/deref are `Arc::clone`/`drop`.
 pub struct RefCountedEnvValue {
     pub bytes: Box<[u8]>,
 }
@@ -575,8 +568,7 @@ pub use bun_s3_signing::credentials::AWSSignatureCache;
 // RareData methods — simple accessors / lazy-init
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Expand `$body` once per embedded `SocketGroup` field — the Rust analogue of
-/// Zig's `inline for (socket_group_fields) |f| @field(this, f)`.
+/// Expand `$body` once per embedded `SocketGroup` field.
 macro_rules! for_each_socket_group {
     ($self:ident, |$g:ident| $body:block) => {{
         {
@@ -687,10 +679,10 @@ impl RareData {
     }
 
     pub fn boring_engine(&mut self) -> *mut boring::ENGINE {
-        // PORT NOTE: Zig spec is `ENGINE_new().?` (panic on null). We cache the
-        // raw result; `EVP_DigestInit_ex` tolerates a NULL engine, so OOM here
-        // degrades to "no engine" rather than crashing. Debug-assert to surface
-        // the divergence without altering release behavior.
+        // The raw `ENGINE_new()` result is cached without a null check:
+        // `EVP_DigestInit_ex` tolerates a NULL engine, so OOM here degrades to
+        // "no engine" rather than crashing. Debug-assert to surface it without
+        // altering release behavior.
         let ptr = *self
             .boring_ssl_engine
             .get_or_insert_with(|| boring::ENGINE_new());
@@ -708,11 +700,10 @@ impl RareData {
     }
 
     pub fn tls_default_ciphers(&self) -> Option<&[u8]> {
-        // PORT NOTE: Zig returns `[:0]const u8` whose `.len` excludes the NUL
-        // sentinel. The stored buffer is NUL-terminated (set_tls_default_ciphers
-        // appends 0), so strip the trailing NUL from the returned slice's length
-        // to match `dupeZ` semantics. Callers needing a C string can still take
-        // `.as_ptr()` — the NUL byte remains in storage one-past-the-end.
+        // The stored buffer is NUL-terminated (set_tls_default_ciphers
+        // appends 0); the trailing NUL is stripped from the returned slice's
+        // length. Callers needing a C string can still take `.as_ptr()` — the
+        // NUL byte remains in storage one-past-the-end.
         self.tls_default_ciphers
             .as_deref()
             .map(|s| &s[..s.len() - 1])
@@ -738,9 +729,9 @@ impl RareData {
 
     pub fn spawn_sync_event_loop(&mut self, vm: &mut VirtualMachine) -> &mut SpawnSyncEventLoop {
         if self.spawn_sync_event_loop_.is_none() {
-            // PORT NOTE: in-place out-param init — Zig used Owned::new(undefined)
-            // then ptr.init(vm). `event_loop` inside captures `self`-addr, so the
-            // value must not move after init; allocate the Box first, init into it.
+            // In-place out-param init: `event_loop` inside captures the
+            // `self` address, so the value must not move after init; allocate
+            // the Box first, then init into it.
             let mut boxed = Box::<SpawnSyncEventLoop>::new_uninit();
             SpawnSyncEventLoop::init(
                 &mut *boxed,
@@ -784,8 +775,6 @@ impl RareData {
     // ── socket groups: lazy init ──────────────────────────────────────────
     #[inline]
     fn lazy_group<'a>(g: &'a mut SocketGroup, vm: &VirtualMachine) -> &'a mut SocketGroup {
-        // PORT NOTE: Zig took `comptime field: []const u8` + @field; Rust takes
-        // the field reference directly since callers know the field statically.
         if g.loop_.is_null() {
             g.init(vm.uws_loop(), None, core::ptr::null_mut());
         }
@@ -865,7 +854,7 @@ impl RareData {
     // ── close_all_socket_groups ───────────────────────────────────────────
     /// Drain every embedded socket group. Must run BEFORE JSC teardown — closeAll
     /// fires on_close → JS callbacks → needs a live VM. RareData.deinit() runs
-    /// after `WebWorker__teardownJSCVM` (web_worker.zig), so doing the closeAll
+    /// after `WebWorker__teardownJSCVM`, so doing the closeAll
     /// there would dispatch into freed JSC heap.
     pub fn close_all_socket_groups(&mut self, vm: &VirtualMachine) {
         // closeAll() dispatches on_close into JS while the VM is still alive, so a
@@ -905,7 +894,7 @@ impl RareData {
 //
 // Low tier owns the fstat + lazy-init flow; the actual `webcore::blob::Store`
 // allocation goes through `__bun_stdio_blob_store_new` (link-time extern
-// defined in `bun_runtime::webcore::blob`). Zig built `Blob.Store` inline.
+// defined in `bun_runtime::webcore::blob`).
 // ──────────────────────────────────────────────────────────────────────────
 
 unsafe extern "Rust" {
@@ -968,8 +957,7 @@ impl RareData {
                 Ok(stat) => stat.st_mode as Mode,
                 Err(_) => 0,
             };
-            // Zig: `if (fd.unwrapValid()) |valid| std.posix.isatty(valid.native()) else false`
-            // — on Windows an invalid stdin handle must short-circuit to false.
+            // On Windows an invalid stdin handle must short-circuit to false.
             let is_atty = fd.unwrap_valid().map(syscall::isatty).unwrap_or(false);
             let store = Self::stdio_ctor(fd, is_atty, mode);
             self.stdin_store = NonNull::new(store);
@@ -994,8 +982,8 @@ pub(crate) enum StdinFdType {
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn Bun__Process__getStdinFdType(vm: &VirtualMachine, fd: i32) -> StdinFdType {
     let rare = vm.as_mut().rare_data();
-    // PORT NOTE: Zig read `store.data.file.mode`; the store is erased here, so
-    // `stderr/stdout/stdin()` cache `mode` alongside the pointer.
+    // The store is type-erased here, so `stderr/stdout/stdin()` cache `mode`
+    // alongside the pointer.
     let mode = match fd {
         0 => {
             rare.stdin();
@@ -1011,9 +999,9 @@ pub(crate) extern "C" fn Bun__Process__getStdinFdType(vm: &VirtualMachine, fd: i
         }
         _ => unreachable!(),
     };
-    // Zig: `bun.S.ISFIFO(mode)` / `bun.S.ISSOCK(mode)` — platform-shimmed (works on
-    // Windows where libc::S_IFSOCK is undefined and on macOS where the libc constants
-    // are u16). `kind_from_mode` uses hard-coded u32 octal masks for the same effect.
+    // `kind_from_mode` uses hard-coded u32 octal masks so it works on
+    // Windows where libc::S_IFSOCK is undefined and on macOS where the libc
+    // constants are u16.
     match bun_sys::kind_from_mode(mode) {
         bun_sys::FileKind::NamedPipe => StdinFdType::Pipe,
         bun_sys::FileKind::UnixDomainSocket => StdinFdType::Socket,
@@ -1118,5 +1106,3 @@ impl Drop for RareData {
 }
 
 pub use bun_event_loop::SpawnSyncEventLoop::SpawnSyncEventLoop as SpawnSyncEventLoopReexport;
-
-// ported from: src/jsc/rare_data.zig
diff --git a/src/jsc/resolve_path_jsc.rs b/src/jsc/resolve_path_jsc.rs
index 063cae7ce4b..b664d3260ea 100644
--- a/src/jsc/resolve_path_jsc.rs
+++ b/src/jsc/resolve_path_jsc.rs
@@ -13,16 +13,14 @@ pub(crate) extern "C" fn ResolvePath__joinAbsStringBufCurrentPlatformBunString(
 ) -> BunString {
     let str = input.to_utf8_without_ref();
 
-    // Spec: `globalObject.bunVM().transpiler.fs.top_level_dir`. The Rust
-    // `Transpiler` shape doesn't expose `fs` directly; the singleton accessor
-    // is the same backing storage (resolver_jsc.rs uses it identically).
+    // The cwd is the FileSystem singleton's top_level_dir (resolver_jsc.rs
+    // uses the same backing storage).
     let cwd: &[u8] = bun_paths::fs::FileSystem::instance().top_level_dir();
     let _ = global_object; // bun_vm() retained for future direct field access
 
     // The input is user-controlled and may be arbitrarily long. The
     // threadlocal `join_buf` is only 4096 bytes, so allocate a buffer sized
-    // to fit. Zig used a StackFallbackAllocator(4096) here.
-    // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
+    // to fit.
     let mut buf = vec![0u8; cwd.len() + str.slice().len() + 2];
 
     let out_slice = resolve_path::join_abs_string_buf::<bun_paths::platform::Auto>(
@@ -33,5 +31,3 @@ pub(crate) extern "C" fn ResolvePath__joinAbsStringBufCurrentPlatformBunString(
 
     BunString::clone_utf8(out_slice)
 }
-
-// ported from: src/jsc/resolve_path_jsc.zig
diff --git a/src/jsc/resolver_jsc.rs b/src/jsc/resolver_jsc.rs
index 12fa66826a0..811d7383d5b 100644
--- a/src/jsc/resolver_jsc.rs
+++ b/src/jsc/resolver_jsc.rs
@@ -1,5 +1,5 @@
-//! Host fns / C++ exports for `node:module` `_nodeModulePaths`. Extracted from
-//! `resolver/resolver.zig` so `resolver/` has no JSC references.
+//! Host fns / C++ exports for `node:module` `_nodeModulePaths`. Lives here so
+//! `resolver/` has no JSC references.
 
 use bstr::BStr;
 
@@ -32,15 +32,15 @@ pub(crate) extern "C" fn Resolver__propForRequireMainPaths(global: &JSGlobalObje
     node_module_paths_js_value(in_str, global, false)
 }
 
-// TODO(port): C++ callers pass `in_str` by value without transferring a ref; verify
-// `bun_core::String` Drop semantics match (Zig callee did not `deref`).
+// C++ callers pass `in_str` by value without transferring a ref:
+// `bun_core::String` is `Copy` with no `Drop` impl, so receiving it by value
+// never releases the caller's ref.
 #[unsafe(export_name = "Resolver__nodeModulePathsJSValue")]
 pub(crate) extern "C" fn node_module_paths_js_value(
     in_str: BunString,
     global: &JSGlobalObject,
     use_dirname: bool,
 ) -> JSValue {
-    // PERF(port): was ArenaAllocator + stackFallback(1024) bulk-free — profile if hot.
     let mut list: Vec<BunString> = Vec::new();
 
     let sliced = in_str.to_utf8();
@@ -68,9 +68,8 @@ pub(crate) extern "C" fn node_module_paths_js_value(
     };
     let mut root_path: &[u8] = &full_path[0..root_index];
     if full_path.len() > root_path.len() {
-        // PORT NOTE: reshaped for borrowck — `std.mem.splitBackwardsScalar` exposes
-        // `.buffer` and `.index`, which Rust's `rsplit` does not. Manual iteration
-        // mirrors the Zig SplitBackwardsIterator state machine exactly.
+        // Manual backwards-split iteration: we need both the remaining buffer
+        // and the split index, which Rust's `rsplit` does not expose.
         let suffix: &[u8] = &full_path[root_index..];
         let mut index: Option<usize> = Some(suffix.len());
         while let Some(end) = index {
@@ -117,8 +116,7 @@ pub(crate) extern "C" fn node_module_paths_js_value(
     list.as_slice().to_js_array(global).unwrap_or(JSValue::ZERO)
 }
 
-/// `[bun.String]::to_js_array` lives on the `StringArrayJsc` ext trait below
-/// (mirrors `bun_string_jsc.zig`'s `BunString__createArray`).
+/// `[bun.String]::to_js_array` lives on the `StringArrayJsc` ext trait below.
 trait StringArrayJsc {
     fn to_js_array(&self, global: &JSGlobalObject) -> JsResult<JSValue>;
 }
@@ -138,5 +136,3 @@ impl StringArrayJsc for [BunString] {
         })
     }
 }
-
-// ported from: src/jsc/resolver_jsc.zig
diff --git a/src/jsc/sizes.rs b/src/jsc/sizes.rs
index 20b70b9f4cf..0d75d7037ff 100644
--- a/src/jsc/sizes.rs
+++ b/src/jsc/sizes.rs
@@ -8,5 +8,3 @@
 pub const BUN_FFI_POINTER_OFFSET_TO_ARGUMENTS_LIST: usize = 6;
 pub(crate) const BUN_FFI_POINTER_OFFSET_TO_TYPED_ARRAY_VECTOR: usize = 16;
 pub(crate) const BUN_FFI_POINTER_OFFSET_TO_TYPED_ARRAY_LENGTH: usize = 24;
-
-// ported from: src/jsc/sizes.zig
diff --git a/src/jsc/uuid.rs b/src/jsc/uuid.rs
index 491d7ffa66e..43dcc6a9d53 100644
--- a/src/jsc/uuid.rs
+++ b/src/jsc/uuid.rs
@@ -57,7 +57,6 @@ impl UUID {
             return Err(UuidError::InvalidUUID);
         }
 
-        // PERF(port): was `inline for` (comptime unroll) — profile if it shows up on a hot path.
         for (j, &i) in ENCODED_POS.iter().enumerate() {
             uuid.bytes[j] = bun_core::fmt::hex_pair_value(buf[i as usize], buf[i as usize + 1])
                 .ok_or(UuidError::InvalidUUID)?;
@@ -93,7 +92,6 @@ fn print_bytes(bytes: &[u8; 16], buf: &mut [u8; 36]) {
     buf[13] = b'-';
     buf[18] = b'-';
     buf[23] = b'-';
-    // PERF(port): was `inline for` (comptime unroll) — profile if it shows up on a hot path.
     for (j, &i) in ENCODED_POS.iter().enumerate() {
         let [hi, lo] = bun_core::fmt::hex_byte_lower(bytes[j]);
         buf[i as usize] = hi;
@@ -179,8 +177,7 @@ pub struct UUID5 {
     pub bytes: [u8; 16],
 }
 
-// PORT NOTE: Zig nested `pub const namespaces = struct { ... }` used as a namespace;
-// Rust cannot nest a module inside an `impl`, so it lives adjacent to `UUID5`.
+/// Well-known UUID v5 namespaces (RFC 4122 Appendix C).
 pub mod namespaces {
     use super::*;
 
@@ -259,5 +256,3 @@ impl fmt::Display for UUID5 {
         self.to_uuid().fmt(f)
     }
 }
-
-// ported from: src/jsc/uuid.zig
diff --git a/src/jsc/virtual_machine_exports.rs b/src/jsc/virtual_machine_exports.rs
index ccc145f26f1..38760d616ae 100644
--- a/src/jsc/virtual_machine_exports.rs
+++ b/src/jsc/virtual_machine_exports.rs
@@ -11,8 +11,8 @@ use bun_core::String as BunString;
 use bun_event_loop::ManagedTask::ManagedTask;
 use bun_sourcemap::{BakeSourceProvider, DevServerSourceProvider};
 
-// Zig: comptime { if (Environment.isWindows) @export(&Bun__ZigGlobalObject__uvLoop, ...) }
-// Handled below by `#[cfg(windows)]` on the fn definition itself.
+// `Bun__ZigGlobalObject__uvLoop` is Windows-only: `#[cfg(windows)]` on the fn
+// definition itself.
 //
 // `#[unsafe(no_mangle)] extern "C"` thunks for everything below are emitted by
 // `src/codegen/generate-host-exports.ts` from the `// HOST_EXPORT(Sym, c)`
@@ -42,7 +42,6 @@ pub fn read_origin_timer(vm: &VirtualMachine) -> u64 {
     if let Some(overridden) = vm.overridden_performance_now {
         return overridden;
     }
-    // PORT NOTE: Zig `std.time.Timer.read()`; the Rust field is `Instant`.
     vm.origin_timer.elapsed().as_nanos() as u64
 }
 
@@ -155,9 +154,9 @@ pub fn handle_rejected_promise(global: &JSGlobalObject, promise: &mut JSPromise)
 struct HandledPromiseContext {
     // VM-lifetime backref (JSC_BORROW) — `GlobalRef` encapsulates the deref.
     global_this: crate::GlobalRef,
-    // PORT NOTE: Zig stored a bare JSValue rooted via `.protect()`/`.unprotect()`.
-    // PORTING.md forbids bare JSValue fields on heap-allocated structs; `Strong`
-    // is the prescribed root type and its `Drop` releases the handle slot.
+    // PORTING.md forbids bare JSValue fields on heap-allocated structs;
+    // `Strong` is the prescribed root type and its `Drop` releases the
+    // handle slot.
     promise: Strong,
 }
 
@@ -286,7 +285,6 @@ pub fn add_bake_source_provider_source_map(
     opaque_source_provider: *mut c_void,
     specifier: &BunString,
 ) {
-    // PERF(port): was stack-fallback alloc — profile if hot
     let slice = specifier.to_utf8();
     vm.source_mappings.put_bake_source_provider(
         opaque_source_provider.cast::<BakeSourceProvider>(),
@@ -300,7 +298,6 @@ pub fn add_dev_server_source_provider(
     opaque_source_provider: *mut c_void,
     specifier: &BunString,
 ) {
-    // PERF(port): was stack-fallback alloc — profile if hot
     let slice = specifier.to_utf8();
     vm.source_mappings.put_dev_server_source_provider(
         opaque_source_provider.cast::<DevServerSourceProvider>(),
@@ -314,7 +311,6 @@ pub fn remove_dev_server_source_provider(
     opaque_source_provider: *mut c_void,
     specifier: &BunString,
 ) {
-    // PERF(port): was stack-fallback alloc — profile if hot
     let slice = specifier.to_utf8();
     vm.source_mappings
         .remove_dev_server_source_provider(opaque_source_provider, slice.slice());
@@ -326,7 +322,6 @@ pub fn add_source_provider_source_map(
     opaque_source_provider: *mut c_void,
     specifier: &BunString,
 ) {
-    // PERF(port): was stack-fallback alloc — profile if hot
     let slice = specifier.to_utf8();
     vm.source_mappings
         .put_zig_source_provider(opaque_source_provider, slice.slice());
@@ -338,7 +333,6 @@ pub fn remove_source_provider_source_map(
     opaque_source_provider: *mut c_void,
     specifier: &BunString,
 ) {
-    // PERF(port): was stack-fallback alloc — profile if hot
     let slice = specifier.to_utf8();
     vm.source_mappings
         .remove_zig_source_provider(opaque_source_provider, slice.slice());
@@ -372,5 +366,3 @@ pub fn Bun__setSyntheticAllocationLimitForTesting(
         .store(limit, core::sync::atomic::Ordering::Relaxed);
     Ok(JSValue::js_number(prev as f64))
 }
-
-// ported from: src/jsc/virtual_machine_exports.zig
diff --git a/src/jsc/web_worker.rs b/src/jsc/web_worker.rs
index ce353170c3b..ceb045b8f5e 100644
--- a/src/jsc/web_worker.rs
+++ b/src/jsc/web_worker.rs
@@ -7,7 +7,7 @@
 //!
 //!   ┌─ PARENT THREAD ───────────────────────────────────────────────────────┐
 //!   │  JSWorker (GC'd JSCell) ──Ref──► WebCore::Worker (ThreadSafeRefCounted)│
-//!   │                                    └─ impl_ ──owns──► Zig WebWorker    │
+//!   │                                    └─ impl_ ──owns──► WebWorker        │
 //!   └───────────────────────────────────────────────────────┬───────────────┘
 //!                                                            │
 //!   ┌─ WORKER THREAD ───────────────────────────────────────┴───────────────┐
@@ -98,7 +98,6 @@ pub struct WebWorker {
     eval_mode: bool,
     store_fd: bool,
     /// Borrowed from C++ `WorkerOptions` (kept alive by the owning `Worker`).
-    // TODO(port): lifetime — borrowed from cpp_worker (BACKREF).
     argv_ptr: *const WTFStringImpl,
     argv_len: usize,
     exec_argv_ptr: *const WTFStringImpl,
@@ -107,7 +106,7 @@ pub struct WebWorker {
     /// Heap-owned by this struct; freed in `destroy()`.
     unresolved_specifier: Box<[u8]>,
     preloads: Vec<Box<[u8]>>,
-    /// Owned NUL-terminated bytes; Zig was `[:0]const u8`.
+    /// Owned NUL-terminated bytes.
     name: bun_core::ZBox,
 
     // ---- Cross-thread signalling --------------------------------------------
@@ -121,8 +120,6 @@ pub struct WebWorker {
     /// Rust's aliasing model still requires interior mutability. `*mut T` is
     /// `Copy`, so `Cell` (not `UnsafeCell`) suffices and every read/write is
     /// safe `.get()`/`.set()`.
-    // TODO(port): intrusive doubly-linked list node — `bun_collections` has no
-    // `IntrusiveList` yet; raw next/prev pointers used directly.
     live_next: Cell<*mut WebWorker>,
     live_prev: Cell<*mut WebWorker>,
 
@@ -165,17 +162,15 @@ pub struct WebWorker {
     // thread while another thread holds `&WebWorker` is aliased-&mut UB. Hence
     // `Cell` / `UnsafeCell` even for single-threaded data.
     status: Cell<Status>,
-    // PERF(port): was MimallocArena bulk-free backing the worker VM — keep as
-    // explicit arena rather than deleting per §Allocators non-AST rule, because
-    // the VM's allocator IS this arena (load-bearing). Profile if it shows up on a hot path.
+    // Kept as an explicit arena (rather than the global allocator) because
+    // the VM's allocator IS this arena (load-bearing).
     // `JsCell` (not `Cell`) because `Arena` is non-`Copy`; worker-thread-only
     // so the single-owner-thread invariant `JsCell` documents is upheld.
     arena: JsCell<Option<bun_alloc::Arena>>,
-    /// Heap-owned cloned env (Map + Loader) for the worker VM. In Zig both
-    /// were `allocator.create`'d on the worker arena and bulk-freed by
-    /// `arena.deinit()`. Rust's `Arena = bumpalo::Bump` does not run `Drop`
-    /// (so the inner `HashTable` would leak), and `clone_with_allocator()` no
-    /// longer routes through the arena allocator anyway — own them as `Box`es
+    /// Heap-owned cloned env (Map + Loader) for the worker VM. The worker
+    /// `Arena` (`bumpalo::Bump`) does not run `Drop` (so the inner
+    /// `HashTable` would leak), and `clone_with_allocator()` does not route
+    /// through the arena allocator anyway — own them as `Box`es
     /// here instead. `start_vm()` `heap::alloc`s and stores the pointers;
     /// `shutdown()` step 5 `heap::take`s after `vm.destroy()` (loader
     /// first, then map — `Loader<'static>` borrows `*map`).
@@ -201,7 +196,6 @@ pub enum Status {
     Terminated,
 }
 
-// TODO(port): move to <area>_sys
 // `JSGlobalObject` is an opaque FFI handle (ZST); per codebase convention
 // (see JSGlobalObject.rs externs) it crosses FFI as `*const` even when C++
 // mutates — Rust never reads/writes bytes through it, so no `*mut` needed.
@@ -217,7 +211,7 @@ unsafe extern "C" {
     // by-value scalars/`#[repr(C)]` PODs.
     safe fn WebWorker__dispatchExit(cpp_worker: *mut c_void, exit_code: i32);
     // Re-declared here (also private in VM.rs) so `thread_main` can take the
-    // API lock as a raw FFI call with NO RAII guard — see PORT NOTE there.
+    // API lock as a raw FFI call with NO RAII guard — see the note there.
     safe fn JSC__VM__getAPILock(vm: &jsc::VM);
     safe fn WebWorker__dispatchOnline(cpp_worker: *mut c_void, global: &JSGlobalObject);
     safe fn WebWorker__fireEarlyMessages(cpp_worker: *mut c_void, global: &JSGlobalObject);
@@ -239,15 +233,12 @@ unsafe extern "C" {
 mod live_workers {
     use super::*;
 
-    // PORT NOTE: `Mutex::new()` is the prevailing const-init spelling across
-    // un-gated jsc modules (ConsoleObject.rs, bundler/ThreadPool.rs); the
-    // `bun_threading` crate provides it.
     pub(super) static MUTEX: Mutex = Mutex::new();
-    // TODO(port): std.DoublyLinkedList — intrusive, nodes are `WebWorker.live_{next,prev}`
+    // Intrusive doubly-linked list head; nodes are `WebWorker.live_{next,prev}`.
     // PORTING.md §Global mutable state: list head, every read/write is under
     // `MUTEX` above. `AtomicCell` so the slot itself is `Sync` with safe
     // load/store (the mutex still provides the actual happens-before for the
-    // intrusive list walk; Zig: plain `var head: ?*WebWorker`).
+    // intrusive list walk).
     pub(super) static HEAD: bun_core::AtomicCell<*mut WebWorker> =
         bun_core::AtomicCell::new(core::ptr::null_mut());
     /// Number of workers registered in `list`. Separate atomic so
@@ -266,8 +257,7 @@ mod live_workers {
             }
         }
         HEAD.store(worker);
-        // fetch_add and wake MUST happen under MUTEX (matching the Zig
-        // `defer mutex.unlock()` ordering) so that `terminate_all_and_wait`
+        // fetch_add and wake MUST happen under MUTEX so that `terminate_all_and_wait`
         // can never observe the worker in the list while OUTSTANDING is still
         // at its pre-increment value — otherwise it could sweep B, see
         // OUTSTANDING==0 (A's unregister already ran, B's add hasn't), and
@@ -353,7 +343,7 @@ pub fn terminate_all_and_wait(timeout_ms: u64) {
     // was never set. Sweeping is O(outstanding) and `requested_terminate`
     // is a swap, so re-sweeping already-terminated entries is cheap.
     let timer = std::time::Instant::now();
-    let deadline_ns: u64 = timeout_ms * 1_000_000; // std.time.ns_per_ms
+    let deadline_ns: u64 = timeout_ms * 1_000_000;
     loop {
         live_workers::MUTEX.lock();
         // MUTEX held while walking the intrusive list; HEAD load is safe.
@@ -432,15 +422,15 @@ impl WebWorker {
         self.parent_poll_ref.with_mut(f)
     }
 
-    /// Zig: `worker.eval_mode` field — whether this worker was started in
-    /// eval mode (entry source is a string, not a file).
+    /// Whether this worker was started in eval mode (entry source is a
+    /// string, not a file).
     #[inline]
     pub fn eval_mode(&self) -> bool {
         self.eval_mode
     }
 
-    /// Zig: `worker.argv: []const WTFStringImpl` field — borrowed from the C++
-    /// `WorkerOptions` (kept alive by the owning `WebCore::Worker`).
+    /// Borrowed from the C++ `WorkerOptions` (kept alive by the owning
+    /// `WebCore::Worker`).
     #[inline]
     pub fn argv(&self) -> &[WTFStringImpl] {
         // SAFETY: `argv_ptr[..argv_len]` is borrowed from C++ WorkerOptions
@@ -449,7 +439,7 @@ impl WebWorker {
         unsafe { bun_core::ffi::slice(self.argv_ptr, self.argv_len) }
     }
 
-    /// Zig: `worker.execArgv: ?[]const WTFStringImpl` — `None` when
+    /// `None` when
     /// `inherit_exec_argv` (the worker inherits the parent's execArgv),
     /// otherwise `Some(slice)` (possibly empty) borrowed from C++ WorkerOptions.
     #[inline]
@@ -502,8 +492,7 @@ impl WebWorker {
         let prev_log = parent_ref.transpiler.log;
         let mut temp_log = bun_ast::Log::default();
         parent_ref.transpiler.set_log(&raw mut temp_log);
-        // RAII: Zig's `defer parent.transpiler.setLog(prev_log)` +
-        // `defer temp_log.deinit()` — restored on every return path.
+        // RAII: log pointer restored and temp log dropped on every return path.
         let mut restore = scopeguard::guard((parent_ref, temp_log), |(p, log)| {
             p.transpiler.set_log(prev_log);
             drop(log);
@@ -591,7 +580,6 @@ impl WebWorker {
         // worker whose thread is already running.
         live_workers::register(worker);
 
-        // PORT NOTE: Zig's `std.Thread.spawn(.{ .stack_size }, threadMain, .{worker})`.
         // `std::thread` is permitted (only `std::{fs,net,process}` are banned);
         // bun_threading has no generic spawn helper.
         struct SendPtr(*mut WebWorker);
@@ -762,8 +750,7 @@ impl WebWorker {
     // main thread may concurrently hold `&WebWorker` (`notify_need_termination`,
     // `terminate_all_and_wait`), so materialising `&mut WebWorker` here would
     // be aliased-&mut UB. Worker-thread-only mutable fields are wrapped in
-    // `Cell` / `UnsafeCell` instead. Zig spec uses `*WebWorker` everywhere,
-    // which aliases freely.
+    // `Cell` / `UnsafeCell` instead.
     fn thread_main(&self) {
         bun_analytics::features::workers_spawned.fetch_add(1, Ordering::Relaxed);
 
@@ -792,7 +779,7 @@ impl WebWorker {
             }
         };
 
-        // PORT NOTE: `start_vm()` may have observed `requested_terminate` and
+        // `start_vm()` may have observed `requested_terminate` and
         // run `shutdown()` itself (which now returns instead of `noreturn`).
         // In that case it returns `Ok(null)` and there is nothing left to do —
         // fall out of `thread_main` so the thread exits cleanly. We must NOT
@@ -811,20 +798,13 @@ impl WebWorker {
         // the safe thread-local accessor returns the same allocation.
         debug_assert!(core::ptr::eq(vm_ptr, VirtualMachine::get_mut_ptr()));
         let global = VirtualMachine::get().global();
-        // PORT NOTE: Zig calls `holdAPILock(this, OpaqueWrap(spin))`; the
-        // callback ends in `bun.exitThread()` (`pthread_exit`), whose forced
-        // unwind cannot walk Zig frames (no unwind tables), so glibc falls
-        // back to a longjmp and the C++ `JSLockHolder` destructor never
-        // runs — `WebWorker__teardownJSCVM` (called from `shutdown()`)
-        // accounts for that abandoned ref by `deref`ing twice.
-        //
-        // In Rust we cannot use `pthread_exit` (its forced unwind aborts at
-        // the first `extern "C"` boundary — see `shutdown` PORT NOTE), so
-        // `spin()` returns. To preserve the Zig invariant that the API lock
-        // is simply abandoned along with the destroyed VM, take the lock via
+        // We cannot use `pthread_exit` (its forced unwind aborts at
+        // the first `extern "C"` boundary — see the `shutdown` note), so
+        // `spin()` returns. The API lock
+        // is simply abandoned along with the destroyed VM: take the lock via
         // raw FFI (NOT the `Lock<'_>` RAII guard) and never release it.
         // `WebWorker__teardownJSCVM` correspondingly `deref`s once, since
-        // unlike Zig's `JSLockHolder` this path takes no extra `RefPtr<VM>`
+        // this path takes no extra `RefPtr<VM>`
         // — see the matching note in `Worker.cpp`.
         //
         // We deliberately do NOT use `get_api_lock()` + `mem::forget(guard)`:
@@ -852,24 +832,24 @@ impl WebWorker {
         // `parent` is a `BackRef` and outlives this worker while
         // `parent_poll_ref` is held (see file header). The parent VM runs
         // concurrently on its own thread, so we must NOT materialise a
-        // `&mut VirtualMachine` here — Zig's `*T` aliases freely but a
-        // Rust `&mut` would assert uniqueness we don't have. All uses
+        // `&mut VirtualMachine` here — a
+        // `&mut` would assert uniqueness we don't have. All uses
         // below are read-only (clone of transform_options, locked read of
         // proxy_env_storage / env.map, copy of standalone_module_graph),
-        // so a shared reference is sufficient and matches the .zig intent.
+        // so a shared reference is sufficient.
         let parent = self.parent.get();
         // Deref-clone out of the `Arc` — worker mutates `allow_addons` below
         // and passes the owned struct as `args` to the new VM.
         let mut transform_options = (*parent.transpiler.options.transform_options).clone();
 
         if let Some(exec_argv) = self.exec_argv() {
-            // Spec web_worker.zig:445-476 — parse `execArgv` with the
+            // Parse `execArgv` with the
             // RunCommand param table. The param table lives in
             // `bun_runtime::cli` (forward-dep), so dispatch through
             // `RuntimeHooks::parse_worker_exec_argv_allow_addons`. Currently
             // only honours `--no-addons`; the hook owns the temporary UTF-8
-            // alloc + clap parse + `args.deinit()` (the full `defer` chain in
-            // the .zig). `None` ↔ Zig's `catch break :parse_new_args` arm.
+            // alloc + clap parse + `args.deinit()`. `None` on parse failure
+            // (the parent's setting is kept).
 
             // SAFETY: `exec_argv` borrows C++ `WorkerOptions` kept alive by the
             // owning `WebCore::Worker` for `self`'s lifetime; the hook only
@@ -893,11 +873,8 @@ impl WebWorker {
         // state.
         let mut temp_proxy_slots = jsc::rare_data::ProxyEnvSlots::default();
 
-        // PORT NOTE: Zig allocated Map/Loader on the worker arena (bulk-freed
-        // in shutdown). Rust's `Arena = bumpalo::Bump` doesn't run Drop, so
-        // box on the global heap instead and hand ownership to the VM via
+        // Box Map/Loader on the global heap and hand ownership to the VM via
         // `transpiler.env`; reclaimed in `vm.destroy()` in `shutdown()`.
-        // PERF(port): MimallocArena bulk-free — profile if it shows up on a hot path.
         let mut map = Box::new(bun_dotenv::Map::default());
         {
             let parent_slots = parent.proxy_env_storage.lock();
@@ -909,14 +886,13 @@ impl WebWorker {
         // Ensure map entries point at the exact bytes we hold refs on.
         temp_proxy_slots.sync_into(&mut map);
 
-        // `Loader<'static>` borrows `map` for its lifetime. In Zig both lived
-        // on the worker arena (bulk-freed); here both are `heap::alloc`'d
+        // `Loader<'static>` borrows `map` for its lifetime. Both are `heap::alloc`'d
         // and stashed on `self` so `shutdown()` step 5 reclaims them on every
         // path — including the early-terminate checkpoint below, which calls
         // `shutdown()` before the VM exists.
         let map_ptr: *mut bun_dotenv::Map = bun_core::heap::into_raw(map);
         // SAFETY: `map_ptr` heap-allocated above; `'static` is the lifetime
-        // erasure for the worker-VM-lifetime borrow (Zig: arena-backed).
+        // erasure for the worker-VM-lifetime borrow.
         let loader = Box::new(bun_dotenv::Loader::init(unsafe { &mut *map_ptr }));
         let loader_ptr: *mut bun_dotenv::Loader<'static> = bun_core::heap::into_raw(loader);
         self.worker_env_map.set(map_ptr);
@@ -1026,9 +1002,8 @@ impl WebWorker {
     /// Phase 2: load the entry point, dispatch 'online', run the event loop.
     /// Runs inside `holdAPILock`. Always ends by calling `shutdown()`.
     ///
-    /// PORT NOTE: Zig's `spin` is `noreturn` (every path ends in `shutdown`
-    /// → `bun.exitThread`). The Rust port returns `()` so the thread can
-    /// unwind-free fall out of the `extern "C"` trampoline — see `shutdown`.
+    /// Returns `()` so the thread can unwind-free fall out of the
+    /// `extern "C"` trampoline — see `shutdown`.
     fn spin(&self) {
         log!("[{}] spin start", self.execution_context_id);
 
@@ -1060,8 +1035,7 @@ impl WebWorker {
         }
 
         // `preloads` is owned by `self` (heap `WebWorker` outlives the VM).
-        // PORT NOTE: Zig's slice-copy assignment; here `preload: Vec<Box<[u8]>>`
-        // so clone the boxes (cheap, ≤handful).
+        // `preload: Vec<Box<[u8]>>` — clone the boxes (cheap, ≤handful).
         vm.as_mut().preload.clone_from(&self.preloads);
 
         // Resolve the entry point on the worker thread (the parent only stored
@@ -1153,9 +1127,8 @@ impl WebWorker {
         // don't run the GC if we don't actually need to
         if vm.is_event_loop_alive() || vm.event_loop_mut().tick_concurrent_with_count() > 0 {
             vm.global().vm().release_weak_refs();
-            // PERF(port): `vm.arena.gc()` was `MimallocArena.gc()` →
-            // `mi_heap_collect`. `Arena = bumpalo::Bump` has no collect;
-            // global mimalloc handles reclamation. Profile if it shows up on a hot path.
+            // `Arena = bumpalo::Bump` has no collect; global mimalloc
+            // handles reclamation.
             let _ = vm.global().vm().run_gc(false);
         }
 
@@ -1202,11 +1175,10 @@ impl WebWorker {
     ///                                  null and skips wakeup() instead of touching
     ///                                  memory freed in step 5.
     ///   2. `vm.onExit()`             — user 'exit' handlers run; needs the JSC VM.
-    ///   3. `teardownJSCVM()`         — collectNow + vm.deref (single — Zig
-    ///                                  derefs ×2 because `JSLockHolder` holds
-    ///                                  a `RefPtr<VM>`; the Rust API-lock path
-    ///                                  takes no extra ref, see `thread_main`
-    ///                                  PORT NOTE); can re-enter via
+    ///   3. `teardownJSCVM()`         — collectNow + vm.deref (single — the
+    ///                                  API-lock path takes no extra
+    ///                                  `RefPtr<VM>`, see the `thread_main`
+    ///                                  note); can re-enter via
     ///                                  finalizers, so must precede step 5.
     ///   4. `dispatchExit()`          — posts close task → parent releases
     ///                                  parent_poll_ref + thread-held Worker ref.
@@ -1215,9 +1187,8 @@ impl WebWorker {
     ///
     /// Does NOT free `this` — see ownership rule in the file header.
     ///
-    /// PORT NOTE: Zig's `shutdown` is `noreturn` (ends in `bun.exitThread`).
-    /// The Rust port returns `()` and lets the thread fall out of the spawn
-    /// closure instead — see the note at the bottom of this fn.
+    /// Returns `()` and lets the thread fall out of the spawn
+    /// closure — see the note at the bottom of this fn.
     fn shutdown(&self) {
         jsc::mark_binding();
         self.set_status(Status::Terminated);
@@ -1270,7 +1241,7 @@ impl WebWorker {
             // closeAll() fires on_close → JS callbacks. RareData.deinit() runs
             // after teardownJSCVM and only deinit()s (asserts empty in debug).
             if let Some(rare) = vm.rare_data.as_deref_mut() {
-                // PORT NOTE: reshaped for borrowck — `close_all_socket_groups`
+                // reshaped for borrowck — `close_all_socket_groups`
                 // wants `&VirtualMachine` while `rare` is `&mut` borrowed from
                 // `vm`. Re-derive `vm` through the raw ptr (sole owner).
 
@@ -1324,11 +1295,9 @@ impl WebWorker {
             bun_sys::windows::libuv::Loop::shutdown();
         }
         if !vm_ptr.is_null() {
-            // SAFETY: vm_ptr valid; sole owner. `destroy()` is the port of
-            // Zig `vm.deinit()`.
+            // SAFETY: vm_ptr valid; sole owner.
             unsafe { (*vm_ptr).destroy() };
-            // Reclaim the boxes that Zig bulk-freed via `arena.deinit()`
-            // (web_worker.zig:515) but the Rust port allocated on the global
+            // Reclaim the boxes allocated on the global
             // heap in `VirtualMachine::init` — `destroy()` only deinits the
             // fields, not the box storage. Worker `init_worker` always passes
             // `log: None`, so the log box is VM-owned here.
@@ -1352,8 +1321,7 @@ impl WebWorker {
             }
         }
         // Reclaim the cloned env (loader borrows `*map` — drop loader first).
-        // In Zig both lived on the worker arena and were bulk-freed below;
-        // here they were `heap::alloc`'d in `start_vm()` (see field doc).
+        // Both were `heap::alloc`'d in `start_vm()` (see field doc).
         if !env_loader.is_null() {
             // SAFETY: `heap::alloc`'d in `start_vm`; sole owner; the VM is
             // gone so its raw `transpiler.env` borrow is dead.
@@ -1365,8 +1333,8 @@ impl WebWorker {
         }
         bun_core::delete_all_pools_for_thread_exit();
         // Free this thread's lazily-created uWS loop and its 512 KiB recv
-        // buffer. Zig reached this via the `pthread_exit`-driven C++
-        // thread_local `~LoopCleaner`, but the Rust port returns normally and
+        // buffer. The C++ thread_local `~LoopCleaner` does not fire here:
+        // we return normally and
         // unwinding never crosses the `extern "C"` frame, so the destructor is
         // skipped on glibc; under BUN_DESTRUCT_VM_ON_EXIT it would also gate
         // on `!bun_is_exiting()`. Everything that registers polls on the loop
@@ -1374,8 +1342,8 @@ impl WebWorker {
         bun_uws::on_thread_exit();
         drop(arena.take());
 
-        // PORT NOTE: Zig calls `bun.exitThread()` (`pthread_exit`) here. In
-        // Rust we MUST NOT — glibc's `pthread_exit` throws a `__forced_unwind`
+        // We MUST NOT call `pthread_exit` here —
+        // glibc's `pthread_exit` throws a `__forced_unwind`
         // C++ exception to run destructors, and unwinding that across an
         // `extern "C"` (`nounwind`) Rust frame on the way out to
         // `std::thread`'s entry point makes Rust abort the whole process.
@@ -1444,9 +1412,8 @@ impl WebWorker {
             WebWorker__dispatchError(global, self.cpp_worker, &mut str, err)
         });
         if let Err(e) = dispatch {
-            // Spec web_worker.zig:810 — `.asException(..).?`: `take_exception`
-            // on a `JsError` always returns an Exception cell; None is
-            // unreachable. Do not silently drop the error.
+            // `take_exception` on a `JsError` always returns an Exception
+            // cell; None is unreachable. Do not silently drop the error.
             let exc = global
                 .take_exception(e)
                 .as_exception(global.vm().as_mut_ptr())
@@ -1503,15 +1470,11 @@ fn on_unhandled_rejection(
         }
         error_instance = global_object.try_take_exception().unwrap();
     }
-    // PORT NOTE: Zig's `writer.flush()` — `Vec<u8>` writer is unbuffered, so
-    // there is nothing to flush; the `bun.outOfMemory()` arm is unreachable.
     jsc::mark_binding();
-    // PORT NOTE: Zig calls `WebWorker__dispatchError` bare here because the
-    // very next statement is `worker.shutdown()` (noreturn — `bun.exitThread`
-    // longjmps), so the C++ `DECLARE_THROW_SCOPE` inside
-    // `SerializedScriptValue::create` (reached via `dispatchErrorWithValue`)
-    // never has its simulated-throw bookkeeping validated. Rust RETURNS through
-    // the live C++ frames (see PORT NOTE below), so that simulated throw must
+    // We RETURN through
+    // the live C++ frames after dispatching (see the note below), so the
+    // simulated throw of the C++ `DECLARE_THROW_SCOPE` inside
+    // `SerializedScriptValue::create` (reached via `dispatchErrorWithValue`) must
     // be checked before unwinding, or the next `TopExceptionScope` ctor on the
     // stack — `performMicrotaskCheckpoint` / NodeTimerObject `call()` — trips
     // `verifyExceptionCheckNeedIsSatisfied`. Wrap in `from_js_host_call_generic`
@@ -1533,9 +1496,8 @@ fn on_unhandled_rejection(
         let _ = global_object.try_take_exception();
     }
     let _ = worker.set_requested_terminate();
-    // PORT NOTE: Zig calls `worker.shutdown()` here, which is `noreturn`
-    // (`bun.exitThread` longjmps out, abandoning the C++ frames on the
-    // stack). In Rust `shutdown()` RETURNS — calling it here would destroy
+    // Do NOT call `worker.shutdown()` here —
+    // `shutdown()` RETURNS, so calling it here would destroy
     // the `JSC::VM`, free the Bun `VirtualMachine` + arena, and post
     // `dispatchExit` (after which `worker` itself may be freed), then return
     // through `VirtualMachine::uncaught_exception` (which writes
@@ -1550,7 +1512,7 @@ fn on_unhandled_rejection(
     // `shutdown()` call at its bottom with no live JSC frames above it. The
     // promise-rejection path in `spin()` (line ~1044) gets there even sooner:
     // `uncaught_exception` returns `handled == false`, so `spin()` calls
-    // `return self.shutdown()` directly — same observable ordering as Zig.
+    // `return self.shutdown()` directly — same observable ordering.
     // `vm.jsc_vm` is the worker's live `JSC::VM*` (we just used it via
     // `global_object`); `notify_need_termination` is documented thread-safe
     // (VMTraps).
@@ -1606,8 +1568,8 @@ unsafe fn resolve_entry_point_specifier<'s>(
                 );
                 let base_len = base.len();
                 let extname_len = bun_paths::extension(base).len();
-                // PORT NOTE: reshaped for borrowck — Zig held `extname` as a
-                // sub-slice of `pathbuf` while writing into `pathbuf`. Compare
+                // `extname` cannot be held as a sub-slice of `pathbuf` while
+                // writing into `pathbuf` — compare
                 // by re-slicing after dropping the mutable borrow.
                 let extname = &pathbuf[base_len - extname_len..base_len];
 
@@ -1696,8 +1658,7 @@ unsafe fn resolve_entry_point_specifier<'s>(
 
     // `Path::text` borrows the resolver's process-lifetime `dirname_store` /
     // `filename_store` (`Path<'static>`), NOT `resolved_entry_point` itself —
-    // copy the slice out and let `resolved_entry_point` drop on the stack,
-    // exactly as the Zig spec does.
+    // copy the slice out and let `resolved_entry_point` drop on the stack.
     match resolved_entry_point.path_const() {
         Some(entry_path) => Some(entry_path.text),
         None => {
@@ -1706,5 +1667,3 @@ unsafe fn resolve_entry_point_specifier<'s>(
         }
     }
 }
-
-// ported from: src/jsc/web_worker.zig
diff --git a/src/jsc/webcore_types.rs b/src/jsc/webcore_types.rs
index 32742667795..e7fc53a87e1 100644
--- a/src/jsc/webcore_types.rs
+++ b/src/jsc/webcore_types.rs
@@ -7,10 +7,7 @@
 //! lets lower-tier crates (`bun_http_jsc`, `bun_sql_jsc`) downcast a `JSValue`
 //! to `*mut Blob` and read its bytes without a `bun_runtime` forward-dep.
 //!
-//! Ported from `src/runtime/webcore/Blob.zig` (struct fields + `init`/
-//! `initWithStore`/`sharedView`/`dupe`/`detach`/`deinit`) and
-//! `src/runtime/webcore/blob/Store.zig` (`Store`/`Data`/`Bytes`/`File`/`S3`/
-//! `init`/`ref`/`deref`/`sharedView`/`deinit`). Everything that touches the
+//! Everything that touches the
 //! event loop / fs / network stays in `bun_runtime`.
 //!
 //! `BuildArtifact` is **not** hoisted here: its `#[host_fn]`-decorated accessors
@@ -31,10 +28,9 @@ use crate::JsCell;
 use crate::node_path::{PathLike, PathOrFileDescriptor};
 use crate::{JSGlobalObject, JSValue, JsClass};
 
-/// `webcore.Blob.SizeType` (Blob.zig:60) — Zig `u52`; widened to `u64` here
-/// (Rust has no native `u52`). Values are masked to 52 bits at the boundary.
+/// Blob size type. Values are masked to 52 bits at the boundary.
 pub type SizeType = u64;
-/// `webcore.Blob.max_size` (Blob.zig:61) — `std.math.maxInt(u52)`.
+/// Maximum blob size (52 bits).
 pub const MAX_SIZE: SizeType = (1u64 << 52) - 1;
 
 #[repr(u8)]
@@ -48,7 +44,7 @@ pub enum ClosingState {
 // Blob
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `webcore.Blob` (src/runtime/webcore/Blob.zig:7-52). The `m_ctx` payload of
+/// The `m_ctx` payload of
 /// the codegen'd `JSBlob` wrapper.
 ///
 /// R-2 (`sharedThis`): every JS-facing host-fn takes `&Blob` (not `&mut Blob`)
@@ -62,11 +58,11 @@ pub struct Blob {
     pub size: Cell<SizeType>,
     pub offset: Cell<SizeType>,
     /// Intrusively-refcounted backing store. `StoreRef::clone`/`drop` map
-    /// directly to Zig's `store.ref()`/`store.deref()`.
+    /// directly to `Store::ref_()`/`Store::deref()`.
     pub store: JsCell<Option<StoreRef>>,
     /// Either a `&'static [u8]` (mime constant / literal) or a heap allocation
     /// owned by this Blob, discriminated by `content_type_allocated`.
-    // TODO(port): model as Cow<'static, [u8]> once callers are audited.
+    /// (`Cow<'static, [u8]>` is not `#[repr(C)]`, so the manual encoding stays.)
     pub content_type: Cell<*const [u8]>,
     pub content_type_allocated: Cell<bool>,
     pub content_type_was_set: Cell<bool>,
@@ -76,10 +72,10 @@ pub struct Blob {
     pub is_jsdom_file: Cell<bool>,
     /// `bun.ptr.RawRefCount(u32, .single_threaded)` — counts in-flight `*Blob`
     /// borrows handed to async readers; not the JS GC retain count. Zero while
-    /// the JS cell is the sole owner (Blob.zig:44).
+    /// the JS cell is the sole owner.
     ///
     /// Public so `bun_runtime` can construct `Blob { ref_count: …, .. }`
-    /// literals (the Zig spec spells out per-field init at every call site).
+    /// literals.
     pub ref_count: bun_ptr::RawRefCount,
     pub global_this: Cell<*const JSGlobalObject>,
     pub last_modified: Cell<f64>,
@@ -88,7 +84,7 @@ pub struct Blob {
 }
 
 // SAFETY: `Blob` holds raw pointers (`content_type`, `global_this`) which
-// default to `!Send`/`!Sync`. The Zig original moves `Blob` across threads
+// default to `!Send`/`!Sync`. `Blob` moves across threads
 // under `ObjectURLRegistry`'s mutex and via the work-pool read/write tasks;
 // the pointee data is either `'static`/heap-owned (`content_type`) or an
 // opaque JSC handle only ever dereferenced on its owning JS thread.
@@ -126,7 +122,7 @@ impl Default for Blob {
 const _: () = {
     use crate::generated::JSBlob;
 
-    // `JSValue::as(Blob)` (JSValue.zig:462-472) special-case: a `BuildArtifact`
+    // `JSValue::as(Blob)` special-case: a `BuildArtifact`
     // wraps a `Blob`, so downcasting to `Blob` must also match it. The struct
     // lives in `bun_runtime`, so resolve the fallback at link time.
     //
@@ -145,7 +141,7 @@ const _: () = {
             JSBlob::from_js_direct(value)
         }
         fn to_js(self, global: &JSGlobalObject) -> JSValue {
-            // `Blob.toJS` (Blob.zig:3707, simplified): heap-promote and hand
+            // Heap-promote and hand
             // ownership to the codegen wrapper. The S3File fast-path (different
             // JS wrapper) is layered on by `bun_runtime`'s `BlobExt::to_js` for
             // S3-backed blobs; lower-tier callers never construct S3 blobs.
@@ -159,8 +155,8 @@ const _: () = {
 };
 
 impl Blob {
-    /// `bun.TrivialNew(@This())` (Blob.zig:16) — heap-promote and mark as
-    /// heap-allocated so `deinit` knows to `bun.destroy(self)`.
+    /// Heap-promote and mark as
+    /// heap-allocated so `deinit` knows to free the heap box.
     #[inline]
     pub fn new(mut blob: Blob) -> *mut Blob {
         blob.ref_count = bun_ptr::RawRefCount::init(1);
@@ -187,7 +183,7 @@ impl Blob {
 
     #[inline]
     pub fn is_heap_allocated(&self) -> bool {
-        // Spec (Blob.zig:5092-5094): single read of `self.#ref_count.raw_value != 0`.
+        // Single read of `self.ref_count`'s raw value.
         self.ref_count.unsafe_get_value() != 0
     }
 
@@ -212,8 +208,8 @@ impl Blob {
         self.store.get().as_ref()
     }
 
-    /// Move the store ref out (Zig: `this.store = null` without `.deref()`;
-    /// the caller adopts the existing +1). `None` if already detached.
+    /// Move the store ref out without releasing it —
+    /// the caller adopts the existing +1. `None` if already detached.
     #[inline]
     pub fn take_store(&self) -> Option<StoreRef> {
         self.store.replace(None)
@@ -248,12 +244,11 @@ impl Blob {
         }
     }
 
-    /// `Blob.initWithStore(store, globalThis)` (Blob.zig:3649). Accepts both
+    /// Accepts both
     /// `Box<Store>` (from `Store::new` / `Store::init*`) and `StoreRef`.
     pub fn init_with_store<S: Into<StoreRef>>(store: S, global_this: &JSGlobalObject) -> Blob {
         let store: StoreRef = store.into();
         let size = store.size();
-        // Zig: `if (store.data == .file) store.data.file.mime_type.value else ""`.
         // `MimeType::value` is `Cow<'static, [u8]>`; the raw slice pointer is
         // stable for the life of `store` (either `'static` or backed by the heap
         // allocation we hold a ref to in `self.store`).
@@ -270,8 +265,7 @@ impl Blob {
         blob
     }
 
-    /// `Blob.init(bytes, allocator, globalThis)` (Blob.zig:3576). Takes
-    /// ownership of `bytes`.
+    /// Takes ownership of `bytes`.
     pub fn init(bytes: Vec<u8>, global_this: &JSGlobalObject) -> Blob {
         let size = bytes.len() as SizeType;
         let store = if !bytes.is_empty() {
@@ -286,7 +280,6 @@ impl Blob {
         blob
     }
 
-    /// `Blob.initEmpty(globalThis)` (Blob.zig:3660).
     #[inline]
     pub fn init_empty(global_this: &JSGlobalObject) -> Blob {
         let blob = Blob::default();
@@ -294,7 +287,7 @@ impl Blob {
         blob
     }
 
-    /// `Blob.sharedView()` (Blob.zig:3737) — borrowed view of the in-memory
+    /// Borrowed view of the in-memory
     /// bytes (`offset..offset+size` of the backing store). Empty for
     /// file-/S3-backed or zero-length blobs.
     pub fn shared_view(&self) -> &[u8] {
@@ -315,7 +308,7 @@ impl Blob {
         &slice[..slice.len().min(self.size.get() as usize)]
     }
 
-    /// `Blob.detach()` (Blob.zig:3675) — release the store ref without
+    /// Release the store ref without
     /// dropping `self`.
     #[inline]
     pub fn detach(&self) {
@@ -323,20 +316,19 @@ impl Blob {
         self.store.set(None);
     }
 
-    /// `Blob.dupe()` (Blob.zig:3684) — new view onto the same store, +1 ref.
+    /// New view onto the same store, +1 ref.
     #[inline]
     pub fn dupe(&self) -> Blob {
         self.dupe_with_content_type(false)
     }
 
-    /// Rust spelling of Zig's raw `blob.*` bitwise copy (e.g.
-    /// `PathOrBlob.fromJSNoCopy`, `var blob_internal = .{ .blob = this.* }`).
+    /// Alias for [`Self::dupe`].
     #[inline]
     pub fn borrowed_view(&self) -> Blob {
         self.dupe()
     }
 
-    /// `Blob.dupeWithContentType()` (Blob.zig:3688). The Zig spec ignores
+    /// Ignores
     /// `include_content_type` and **always** deep-copies a heap-allocated
     /// `content_type` so freeing one side does not dangle the other (the old
     /// borrow path was removed because it dropped user-supplied parameters
@@ -348,7 +340,6 @@ impl Blob {
         } else {
             self.content_type.get()
         };
-        // Zig: `if (this.store != null) this.store.?.ref()` then bitwise-copy.
         // `Option<StoreRef>::clone` bumps the intrusive `Store::ref_count`.
         Blob {
             reported_estimated_size: Cell::new(self.reported_estimated_size.get()),
@@ -368,7 +359,7 @@ impl Blob {
     }
 
     // ────────────────────────────────────────────────────────────────────
-    // Data-only predicates (Blob.zig:3601-3659). LAYERING: hoisted from
+    // Data-only predicates. LAYERING: hoisted from
     // `bun_runtime::webcore::blob::BlobExt` — these read only the `Store`
     // discriminant / `content_type` / `pathlike`, so lower-tier crates
     // (`bun_http_jsc`, `bun_runtime::server`, …) can call them without
@@ -431,12 +422,12 @@ impl Blob {
                 PathOrFileDescriptor::Path(path) => Some(path.slice()),
                 PathOrFileDescriptor::Fd(_) => None,
             },
-            // Zig: `s3.path()` (URL-normalized), NOT `s3.pathlike.slice()`.
+            // Use `s3.path()` (URL-normalized), NOT `s3.pathlike.slice()`.
             store::Data::S3(s3) => Some(s3.path()),
         }
     }
 
-    /// `Blob.deinit()` (Blob.zig:3720). Tear down owned resources; if
+    /// Tear down owned resources; if
     /// heap-allocated, also frees the heap box.
     pub fn deinit(&mut self) {
         self.detach();
@@ -488,29 +479,27 @@ pub extern "C" fn Blob__deref(self_: &mut Blob) {
     );
     if self_.ref_count.decrement() == bun_ptr::raw_ref_count::DecrementResult::ShouldDestroy {
         // `deinit` has its own `is_heap_allocated()` guard around the
-        // `drop(heap::take)`, so re-arm so it returns true (Blob.zig:5112).
+        // `drop(heap::take)`, so re-arm so it returns true.
         self_.ref_count.increment();
         self_.deinit();
     }
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Store (Blob.zig:11 → blob/Store.zig)
+// Store
 // ──────────────────────────────────────────────────────────────────────────
 
 pub mod store {
     use super::*;
 
-    /// `Blob.Store` (Store.zig:1-9). Intrusively-refcounted; always
-    /// heap-allocated (`bun.TrivialNew`).
+    /// Intrusively-refcounted; always
+    /// heap-allocated.
     #[derive(bun_ptr::ThreadSafeRefCounted)]
     pub struct Store {
         pub data: Data,
         pub mime_type: MimeType,
         pub ref_count: bun_ptr::ThreadSafeRefCount<Store>,
         pub is_all_ascii: Option<bool>,
-        // PORT NOTE: `allocator: std.mem.Allocator` field dropped — global
-        // mimalloc everywhere (PORTING.md §Allocators).
     }
 
     impl Default for Store {
@@ -524,7 +513,7 @@ pub mod store {
         }
     }
 
-    /// `Store.Data` (Store.zig:37) — `union(enum) { bytes, file, s3 }`.
+    /// Backing data for a `Store`.
     #[derive(bun_core::EnumTag)]
     #[enum_tag(existing = DataTag)]
     pub enum Data {
@@ -533,7 +522,7 @@ pub mod store {
         S3(S3),
     }
 
-    /// Discriminant-only tag for `Data` (Zig: `std.meta.Tag(Store.Data)`).
+    /// Discriminant-only tag for `Data`.
     #[derive(Clone, Copy, PartialEq, Eq, Debug)]
     pub enum DataTag {
         Bytes,
@@ -570,7 +559,7 @@ pub mod store {
     // Bytes
     // ────────────────────────────────────────────────────────────────────
 
-    /// `Blob.Store.Bytes` (Store.zig:472). Kept as `(ptr,len,cap,allocator)`
+    /// Kept as `(ptr,len,cap,allocator)`
     /// rather than `Vec<u8>` so the memfd-backed path
     /// (`LinuxMemFdAllocator::create` → `mmap`'d region freed via `munmap`)
     /// can carry its allocator vtable with the buffer.
@@ -585,7 +574,7 @@ pub mod store {
     }
 
     // SAFETY: `Bytes` is morally `Vec<u8>`-with-custom-free. The raw
-    // `NonNull<u8>` is uniquely owned (Zig: `ptr` is the sole alias) and
+    // `NonNull<u8>` is uniquely owned (`ptr` is the sole alias) and
     // `StdAllocator` is `Send + Sync`.
     unsafe impl Send for Bytes {}
     // SAFETY: `&Bytes` only reads the uniquely-owned slice via `slice()`; no
@@ -612,7 +601,7 @@ pub mod store {
             let cap = v.capacity();
             Bytes {
                 ptr: NonNull::new(v.as_mut_ptr()),
-                // Zig: `@truncate(bytes.len)` for both — we additionally keep
+                // We keep
                 // the real `cap` so `to_internal_blob` can soundly
                 // `Vec::from_raw_parts`.
                 len: len as SizeType,
@@ -711,7 +700,7 @@ pub mod store {
         pub fn allocated_slice(&self) -> &[u8] {
             match self.ptr {
                 // SAFETY: `ptr[..cap]` is the full allocation; bytes in
-                // `[len..cap]` may be uninitialized (mirrors Zig `ptr[0..cap]`).
+                // `[len..cap]` may be uninitialized.
                 Some(p) => unsafe { core::slice::from_raw_parts(p.as_ptr(), self.cap as usize) },
                 None => &[],
             }
@@ -734,10 +723,8 @@ pub mod store {
 
     impl Drop for Bytes {
         fn drop(&mut self) {
-            // Zig `deinit`: `default_allocator.free(stored_name.slice())` then
-            // `this.allocator.free(ptr[0..cap])`. `stored_name` is a `Box<[u8]>`,
-            // so its field `Drop` frees it; only the custom-allocator buffer
-            // needs an explicit free here.
+            // `stored_name` is a `Box<[u8]>`, so its field `Drop` frees it;
+            // only the custom-allocator buffer needs an explicit free here.
             // Route through the existing accessor instead of re-deriving the
             // slice from raw parts here: `allocated_slice` already encapsulates
             // the `(ptr, cap)` → `&[u8]` invariant (and the `None` ⇒ `&[]`
@@ -752,7 +739,7 @@ pub mod store {
     // File
     // ────────────────────────────────────────────────────────────────────
 
-    /// `Store.File` (Store.zig:250) — a blob store referencing a file on disk.
+    /// A blob store referencing a file on disk.
     #[derive(Clone)]
     pub struct File {
         pub pathlike: PathOrFileDescriptor,
@@ -805,7 +792,7 @@ pub mod store {
     // S3
     // ────────────────────────────────────────────────────────────────────
 
-    /// `Store.S3` (Store.zig:291) — an S3 blob store. Data-only at this tier;
+    /// An S3 blob store. Data-only at this tier;
     /// I/O methods (`unlink`/`stat`/`listObjects`/`getCredentialsWithOptions`)
     /// live in `bun_runtime` because they reach the HTTP client / event loop.
     pub struct S3 {
@@ -874,7 +861,7 @@ pub mod store {
             credentials: bun_s3_signing::S3Credentials,
         ) -> S3 {
             S3 {
-                // Zig: `credentials.dupe()` — heap-allocate a fresh refcounted copy.
+                // Heap-allocate a fresh refcounted copy.
                 credentials: Some(Rc::new(credentials)),
                 pathlike,
                 mime_type: mime_type.unwrap_or(bun_http_types::MimeType::OTHER),
@@ -886,9 +873,8 @@ pub mod store {
         }
     }
 
-    // PORT NOTE: `S3.deinit` body deleted — only freed owned fields
-    // (`pathlike`, `credentials.deref()`), all handled by `PathLike::drop` /
-    // `Option<Arc<_>>::drop`. Per PORTING.md §Idiom map, no explicit `Drop`.
+    // No explicit `Drop`: the owned fields (`pathlike`, `credentials`) are
+    // all released by `PathLike::drop` / `Option<Arc<_>>::drop`.
 
     // ────────────────────────────────────────────────────────────────────
     // Store impl
@@ -901,7 +887,7 @@ pub mod store {
             Box::new(init)
         }
 
-        /// `Store.init(bytes, allocator)` (Store.zig:152). Takes ownership of
+        /// Takes ownership of
         /// `bytes`. Returns a +1-ref heap `Store`.
         pub fn init(bytes: Vec<u8>) -> StoreRef {
             StoreRef::from(Store::new(Store {
@@ -942,7 +928,6 @@ pub mod store {
             }
         }
 
-        /// `Store.size()` (Store.zig:28).
         #[inline]
         pub fn size(&self) -> SizeType {
             match &self.data {
@@ -951,7 +936,6 @@ pub mod store {
             }
         }
 
-        /// `Store.sharedView()` (Store.zig:164).
         #[inline]
         pub fn shared_view(&self) -> &[u8] {
             if let Data::Bytes(bytes) = &self.data {
@@ -960,7 +944,7 @@ pub mod store {
             &[]
         }
 
-        /// `Store.ref()` (Store.zig:43).
+        /// Bump the intrusive refcount.
         #[inline]
         pub fn ref_(&self) {
             // SAFETY: `self` is live; `ref_` only touches the interior-mutable
@@ -970,13 +954,12 @@ pub mod store {
             };
         }
 
-        /// `Store.hasOneRef()` (Store.zig:48).
         #[inline]
         pub fn has_one_ref(&self) -> bool {
             self.ref_count.has_one_ref()
         }
 
-        /// `Store.deref()` (Store.zig:171). Consumes one reference; on last
+        /// Consumes one reference; on last
         /// ref, drops & frees the heap `Store`.
         ///
         /// # Safety
@@ -989,9 +972,8 @@ pub mod store {
             unsafe { bun_ptr::ThreadSafeRefCount::<Self>::deref(this.as_ptr()) };
         }
 
-        /// `extern fn external` (Store.zig:63) — `JSCArrayBuffer` deallocator
-        /// hook signature. Zig has only `callconv(.c)` (callback fn pointer),
-        /// no `@export`, so no `#[unsafe(no_mangle)]` here.
+        /// `JSCArrayBuffer` deallocator hook. Only ever passed as a
+        /// callback fn pointer, so no `#[unsafe(no_mangle)]` here.
         pub extern "C" fn external(
             ptr: *mut core::ffi::c_void,
             _: *mut core::ffi::c_void,
@@ -1001,14 +983,12 @@ pub mod store {
                 return;
             };
             // SAFETY: caller passes a `*Store` (originally leaked via
-            // `heap::alloc`) as the opaque pointer; mirrors Zig
-            // `bun.cast(*Store, ptr)`.
+            // `heap::alloc`) as the opaque pointer.
             unsafe { Store::deref(this) };
         }
     }
 
     impl Drop for Store {
-        /// `Store.deinit()` (Store.zig:179) sans the trailing `bun.destroy` —
         /// `Box` handles the allocation. Every `Data` variant self-frees on
         /// field drop: `Bytes::drop` frees its buffer + `stored_name`; the
         /// `File.pathlike` / `S3` payloads (including an owned
@@ -1022,7 +1002,7 @@ pub mod store {
     // ────────────────────────────────────────────────────────────────────
 
     /// Owning handle to a heap `Store`, refcounted via the *intrusive*
-    /// `Store::ref_count` field. Mirrors Zig's `*Store` with `.ref()`/`.deref()`.
+    /// `Store::ref_count` field.
     ///
     /// Not `Arc<Store>`: `Store::deref()` (reachable from `Store::external` and
     /// other FFI callbacks) frees via `heap::take` when the intrusive count
@@ -1078,14 +1058,15 @@ pub mod store {
             core::mem::ManuallyDrop::new(self).ptr.as_ptr()
         }
 
-        /// Mutable access to `data` through the shared handle. Zig mutates
-        /// `store.data` freely through any holder; the caller must ensure no
+        /// Mutable access to `data` through the shared handle. The caller
+        /// must ensure no
         /// other `&mut` to the same `Store` is live (single-threaded JS
         /// event-loop discipline).
         #[inline]
         #[allow(clippy::mut_from_ref)]
         pub fn data_mut(&self) -> &mut Data {
-            // SAFETY: Zig-semantics shared-mutable interior; see doc comment.
+            // SAFETY: caller guarantees no other `&mut` to this `Store` is
+            // live; see doc comment.
             unsafe { &mut (*self.as_ptr()).data }
         }
     }
@@ -1137,11 +1118,10 @@ pub mod store {
     impl Eq for StoreRef {}
 
     // SAFETY: `Store`'s refcount is atomic and its payload is either
-    // immutable-after-init or guarded by callers; matches Zig's cross-thread
-    // `*Store` usage.
+    // immutable-after-init or guarded by callers.
     unsafe impl Send for StoreRef {}
     // SAFETY: `Store::ref_count` is atomic and `&StoreRef` only derefs to
-    // `&Store`; matches Zig's cross-thread shared `*Store` reads.
+    // `&Store`.
     unsafe impl Sync for StoreRef {}
 }
 pub use store::{Store, StoreRef};
diff --git a/src/jsc_macros/lib.rs b/src/jsc_macros/lib.rs
index 4cec390af9b..e326d30c4a1 100644
--- a/src/jsc_macros/lib.rs
+++ b/src/jsc_macros/lib.rs
@@ -1,7 +1,7 @@
 //! Proc-macros for `bun_jsc`.
 //!
-//! These replace the Zig `comptime`/`@typeInfo` reflection in `host_fn.zig`
-//! and the `.classes.ts` codegen (`src/codegen/generate-classes.ts`). Rust
+//! Together with the `.classes.ts` codegen (`src/codegen/generate-classes.ts`)
+//! these generate the JSC host-function glue. Rust
 //! cannot accept a macro in `extern "<abi>"` position, so the JSC calling
 //! convention (`"sysv64"` on Windows-x64, `"C"` elsewhere) is encoded by
 //! emitting two `#[cfg]`-gated shims from a proc-macro instead.
@@ -143,8 +143,7 @@ fn expand_host_fn(args: &HostFnArgs, func: &ItemFn) -> syn::Result<TokenStream2>
     };
 
     // Shim symbol name. Only emitted when an explicit `export = "..."` is
-    // supplied. In Zig, `@export(&toJSHostFn(f), .{ .name = ... })` always
-    // received a caller-supplied unique name; defaulting to the bare Rust
+    // supplied: defaulting to the bare Rust
     // ident here produces cross-module link collisions for common names
     // (`parse`, `getter`, `crc32`, …) once codegen runs. With no explicit
     // export, Rust mangling on `__jsc_host_<name>` keeps each module's shim
@@ -175,7 +174,7 @@ fn expand_host_fn(args: &HostFnArgs, func: &ItemFn) -> syn::Result<TokenStream2>
         // the `(method)` arg when the signature has `&self`).
         HostFnKind::Free | HostFnKind::Method => {
             // `passThis: true` in `.classes.ts` adds a trailing
-            // `this_value: JSValue` parameter (Zig: `this_value: jsc.JSValue`).
+            // `this_value: JSValue` parameter.
             // The real exported wrapper lives in `generated_classes.rs`; this
             // placeholder shim only needs to type-check, so detect the 4-arg
             // shape (self/this + global + frame + this_value) and forward
@@ -259,8 +258,8 @@ fn expand_host_fn(args: &HostFnArgs, func: &ItemFn) -> syn::Result<TokenStream2>
 //   `${TypeName}Prototype__${prop}GetCachedValue(JSValue) -> JSValue`
 //   `${TypeName}Prototype__${prop}SetCachedValue(JSValue, *JSGlobalObject, JSValue)`
 // shims that `src/codegen/generate-classes.ts` produces for every
-// `cache: true` property. The getter maps `.zero` → `None` (matches the Zig
-// `${name}GetCached` wrapper). Both extern blocks are duplicated under the
+// `cache: true` property. The getter maps `.zero` → `None`.
+// Both extern blocks are duplicated under the
 // JSC calling-convention `#[cfg]` split (see `jsc_extern_fn` above).
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -402,7 +401,7 @@ pub fn codegen_cached_accessors(input: TokenStream) -> TokenStream {
             quote! { Gc::#p => #f(this_value, global, value), }
         });
         out.extend(quote! {
-            /// GC-cached value slots on the JS wrapper (Zig: `js.gc.<field>.get/set/clear`).
+            /// GC-cached value slots on the JS wrapper.
             #[allow(non_camel_case_types, dead_code)]
             #[derive(Clone, Copy)]
             #[repr(u8)]
@@ -539,8 +538,8 @@ impl Parse for JsClassArgs {
 #[proc_macro_attribute]
 pub fn JsClass(attr: TokenStream, item: TokenStream) -> TokenStream {
     let args = parse_macro_input!(attr as JsClassArgs);
-    // Accept both `struct` and `enum` payloads — Zig `.classes.ts` `m_ctx`
-    // payloads are frequently `union(enum)`, which port to Rust `enum`s.
+    // Accept both `struct` and `enum` payloads — `.classes.ts` `m_ctx`
+    // payloads are frequently sum types, which map to Rust `enum`s.
     let item2 = item.clone();
     if let Ok(strukt) = syn::parse::<ItemStruct>(item) {
         return expand_js_class(&args, strukt)
@@ -679,8 +678,7 @@ fn js_class_hooks(args: &JsClassArgs, rust_ty: &Ident) -> TokenStream2 {
 
             impl #rust_ty {
                 /// Wrap an already-heap-allocated `*mut Self` in a JS object
-                /// without re-boxing. Mirrors Zig's generated
-                /// `${T}.toJS(this: *T, globalThis)` which forwards the
+                /// without re-boxing: forwards the
                 /// existing pointer to `${T}__create`. Use this when `Self`
                 /// was allocated via `heap::alloc` / intrusive-RC `init()`
                 /// and `JsClass::to_js(self, ..)` would double-allocate.
@@ -765,8 +763,8 @@ fn js_class_hooks(args: &JsClassArgs, rust_ty: &Ident) -> TokenStream2 {
 // now a no-op.
 //
 // The user body contains **no `unsafe`** — all pointer reconstruction lives in
-// the generated thunk under a single `// SAFETY:` umbrella mirroring the Zig
-// `OpaqueWrap` invariant: the registered ctx pointer is the same `*mut Self`
+// the generated thunk under a single `// SAFETY:` umbrella whose
+// invariant is: the registered ctx pointer is the same `*mut Self`
 // the caller passed to the C side, and any `(ptr, len)` pair describes a slice
 // valid for the duration of the callback.
 //
@@ -873,8 +871,7 @@ fn expand_uws_callback(args: &UwsCallbackArgs, func: &ItemFn) -> syn::Result<Tok
                 thunk_params.push(quote! { #p: #ptr_ty });
                 thunk_params.push(quote! { #l: usize });
                 // Tolerate (null, 0) — uWS passes this for empty buffers, and
-                // `from_raw_parts(null, 0)` is UB. Zig's `[]const u8` also
-                // permits `(undefined, 0)`. Use an explicit, obviously-sound
+                // `from_raw_parts(null, 0)` is UB. Use an explicit, obviously-sound
                 // construction per mutability instead of `(&mut [][..]) as _`,
                 // which borrows a temporary and relies on a non-existent
                 // `&mut [T] -> &[T]` `as`-cast.
diff --git a/src/libarchive/lib.rs b/src/libarchive/lib.rs
index 3028985f47c..d557519121b 100644
--- a/src/libarchive/lib.rs
+++ b/src/libarchive/lib.rs
@@ -19,8 +19,7 @@ use bun_wyhash::hash;
 
 // ──────────────────────────────────────────────────────────────────────────
 // Local libarchive C-API surface. Thin safe(ish) wrappers over the raw
-// `extern "C"` libarchive symbols, ported 1:1 from
-// `src/libarchive_sys/bindings.zig`. The opaque `Archive` / `Entry` types
+// `extern "C"` libarchive symbols. The opaque `Archive` / `Entry` types
 // here are layout-compatible with libarchive's `struct archive` /
 // `struct archive_entry` (zero-sized, `#[repr(C)]`, !Unpin).
 // ──────────────────────────────────────────────────────────────────────────
@@ -57,8 +56,7 @@ pub mod lib {
     }
 
     // ── raw libarchive C FFI ───────────────────────────────────────────────
-    // Signatures match `vendor/libarchive/archive.h` /
-    // `src/libarchive_sys/bindings.zig` exactly. `Result` is `#[repr(i32)]`
+    // Signatures match `vendor/libarchive/archive.h` exactly. `Result` is `#[repr(i32)]`
     // so it is ABI-compatible with the C `int` return values.
     unsafe extern "C" {
         // read side
@@ -227,8 +225,7 @@ pub mod lib {
         }
 
         pub fn write_zeros_to_file(file: &bun_sys::File, count: usize) -> Result {
-            // Use a runtime memset (vs `[0u8; _]`) to keep .rodata small,
-            // matching the Zig (`@memset(&zero_buf, 0)`).
+            // Use a runtime memset (vs `[0u8; _]`) to keep .rodata small.
             let mut zero_buf = [0u8; 16 * 1024];
             zero_buf.fill(0);
             let mut remaining = count;
@@ -351,8 +348,8 @@ pub mod lib {
             }
             // SAFETY: libarchive owns the error string for the lifetime of the
             // archive; callers treat it as borrowed-until-next-call. The
-            // `'static` here mirrors Zig's `[]const u8` — caller must not
-            // outlive the archive (same as the Zig API).
+            // `'static` here is a lifetime erasure — the caller must not let
+            // the slice outlive the archive.
             unsafe { ZStr::from_c_ptr(p) }.as_bytes()
         }
 
@@ -473,7 +470,7 @@ pub mod lib {
             unsafe { archive_entry_clear(self.as_mut_ptr()) }
         }
         /// Raw `archive_entry_set_pathname` — bytes are stored verbatim (no
-        /// charset conversion). Matches Zig's `setPathname` on POSIX.
+        /// charset conversion).
         pub fn set_pathname(&self, name: &ZStr) {
             // SAFETY: self valid; name is NUL-terminated.
             unsafe { archive_entry_set_pathname(self.as_mut_ptr(), name.as_ptr()) }
@@ -607,7 +604,7 @@ pub mod lib {
         }
     }
 
-    // ── Archive::Iterator (port of `libarchive_sys/bindings.zig` Iterator) ─
+    // ── Archive::Iterator ──────────────────────────────────────────────────
     //
     // Thin streaming reader over a tar.gz blob: `init` opens the archive in
     // memory, `next` yields one header at a time, `read_entry_data` slurps the
@@ -615,7 +612,7 @@ pub mod lib {
     // libarchive `*mut Archive` plus a static message so callers can append
     // `Archive::error_string`.
 
-    /// Generic result type used by [`ArchiveIterator`] (Zig: `Iterator.Result(T)`).
+    /// Generic result type used by [`ArchiveIterator`].
     pub enum IteratorResult<T> {
         Err {
             archive: *mut Archive,
@@ -638,10 +635,11 @@ pub mod lib {
         }
     }
 
-    /// Port of `Archive.Iterator` (src/libarchive_sys/bindings.zig).
+    /// Iterates over the entries of an open archive, skipping entries whose
+    /// file kind has its bit set in `filter`.
     pub struct ArchiveIterator {
         pub archive: *mut Archive,
-        // Zig: `std.EnumSet(std.fs.File.Kind)`; mapped to a u16 bitmask over
+        // A u16 bitmask over
         // `bun_sys::FileKind` variants.
         pub filter: u16,
     }
@@ -737,7 +735,7 @@ pub mod lib {
             }
         }
 
-        /// Port of `Iterator.deinit` — Zig returned `Result(void)`, so this
+        /// Returns a `Result` the caller inspects, so this
         /// cannot be `Drop`. Explicit-close per PORTING.md §Idiom map.
         pub fn close(self) -> IteratorResult<()> {
             let a = self.archive();
@@ -758,8 +756,8 @@ pub mod lib {
     }
 
     impl NextEntry {
-        /// Port of `Iterator.NextEntry.readEntryData`. `archive` is the live
-        /// handle this `NextEntry` was yielded from.
+        /// Reads this entry's full data into a heap buffer. `archive` is the
+        /// live handle this `NextEntry` was yielded from.
         pub fn read_entry_data(
             &self,
             archive: &Archive,
@@ -873,11 +871,12 @@ pub mod lib {
     }
 
     // ── Archive::Iterator ──────────────────────────────────────────────────
-    // Port of `Archive.Iterator` (src/libarchive_sys/bindings.zig). Thin
+    // Thin
     // wrapper that opens a tarball from memory and yields one
     // `IteratorEntry` per `next()`, used by `bun publish <tarball>`.
 
-    /// Port of `Iterator.Result(T).err` payload.
+    /// Error payload for [`IterResult`]: the archive handle (for
+    /// `error_string()`) plus a static description.
     pub struct IteratorError {
         pub archive: *mut Archive,
         pub message: &'static [u8],
@@ -895,7 +894,8 @@ pub mod lib {
     /// (kept for `ArchiveIterator`); callers of `Iterator` use this alias.
     pub type IterResult<T> = core::result::Result<T, IteratorError>;
 
-    /// Port of `Iterator.NextEntry` (bindings.zig).
+    /// One entry yielded by [`Iterator::next`]: the raw libarchive entry
+    /// handle plus its decoded file kind.
     pub struct IteratorEntry {
         pub entry: *mut Entry,
         pub kind: bun_sys::FileKind,
@@ -908,7 +908,7 @@ pub mod lib {
             // libarchive guarantees it stays valid until the next header read.
             unsafe { &*self.entry }
         }
-        /// Port of `NextEntry.readEntryData` (bindings.zig). Allocates `size`
+        /// Allocates `size`
         /// bytes and reads the current entry's data into it.
         ///
         /// `archive` is the live handle this entry was yielded from.
@@ -936,12 +936,12 @@ pub mod lib {
         }
     }
 
-    /// Port of `Archive.Iterator` (src/libarchive_sys/bindings.zig).
+    /// Streaming reader over an in-memory tarball; yields one
+    /// [`IteratorEntry`] per archive entry via [`Iterator::next`].
     pub struct Iterator {
         pub archive: *mut Archive,
-        // PORT NOTE: Zig had a `filter: std.EnumSet(std.fs.File.Kind)` field
-        // that every caller leaves at `.initEmpty()` and never sets. Dropped
-        // here (would need `EnumSetType` on `FileKind`); re-add if a caller
+        // No filter field: every caller would leave it empty;
+        // re-add if a caller
         // ever needs it.
     }
     impl Iterator {
@@ -957,7 +957,7 @@ pub mod lib {
             unsafe { &*self.archive }
         }
 
-        /// Port of `Iterator.init` (bindings.zig). Opens `tarball_bytes` as a
+        /// Opens `tarball_bytes` as a
         /// gzip-compressed (gnu)tar archive.
         pub fn init(tarball_bytes: &[u8]) -> IterResult<Self> {
             let archive = Archive::read_new();
@@ -1013,7 +1013,9 @@ pub mod lib {
             Ok(Iterator { archive })
         }
 
-        /// Port of `Iterator.next` (bindings.zig).
+        /// Reads the next entry header, retrying on transient (`Retry`)
+        /// statuses; returns `Ok(None)` at end of archive and `Err` on a
+        /// fatal read error.
         pub fn next(&mut self) -> IterResult<Option<IteratorEntry>> {
             let a = self.archive();
             let mut entry: *mut Entry = core::ptr::null_mut();
@@ -1037,8 +1039,8 @@ pub mod lib {
             }
         }
 
-        /// Port of `Iterator.deinit` (bindings.zig). Closes & frees the
-        /// underlying `*mut Archive`. NOT a `Drop` impl because the Zig
+        /// Closes & frees the
+        /// underlying `*mut Archive`. NOT a `Drop` impl because it
         /// returns a `Result` the caller inspects for error reporting.
         pub fn deinit(&mut self) -> IterResult<()> {
             let a = self.archive();
@@ -1097,7 +1099,7 @@ impl BufferReadStream {
     /// (including its `Drop`). Violating this makes [`buf()`], [`buf_left()`],
     /// and [`open_read()`] dereference a dangling pointer (UB).
     pub unsafe fn init(buf: &[u8]) -> Self {
-        // PORT NOTE: was an out-param constructor (`this.* = ...`)
+        // was an out-param constructor (`this.* = ...`)
         Self {
             buf: std::ptr::from_ref::<[u8]>(buf),
             pos: 0,
@@ -1235,8 +1237,7 @@ impl BufferReadStream {
         let offset = isize::try_from(offset).expect("int cast");
 
         // libarchive only ever passes SEEK_SET/CUR/END; trap on anything
-        // else (matches Zig safety-checked `@enumFromInt(whence)` and the
-        // diff's own convention for out-of-range bitfield decode).
+        // else (the convention for out-of-range bitfield decode).
         let whence = match whence {
             0 => Seek::Set,
             1 => Seek::Current,
@@ -1398,8 +1399,7 @@ pub fn path_traverses_created_symlink(path: &[u8], created_symlinks: &[Vec<u8>])
     false
 }
 
-/// Port of `bun.MakePath.makePath(u16, dir, sub_path)` (bun.zig:2481) — the
-/// Windows arm calls `makeOpenPathAccessMaskW`, which component-iterates the
+/// Recursive mkdir over a WTF-16 path: component-iterates the
 /// wide path and `NtCreateFile`s each prefix with `FILE_OPEN_IF`, walking back
 /// on `FileNotFound` and forward again on success. This stays in WTF-16
 /// throughout (no UTF-8 round-trip — `bun_sys::make_path_w` is the *different*
@@ -1408,8 +1408,8 @@ pub fn path_traverses_created_symlink(path: &[u8], created_symlinks: &[Vec<u8>])
 #[cfg(windows)]
 fn make_path_u16(dir_fd: Fd, sub_path: &[u16]) -> Result<(), bun_core::Error> {
     use bun_sys::{E, WindowsOpenDirOp, WindowsOpenDirOptions, open_dir_at_windows};
-    // Match Zig's access mask (`STANDARD_RIGHTS_READ | FILE_READ_ATTRIBUTES |
-    // FILE_READ_EA | SYNCHRONIZE | FILE_TRAVERSE`) by setting `read_only`,
+    // Access mask (`STANDARD_RIGHTS_READ | FILE_READ_ATTRIBUTES |
+    // FILE_READ_EA | SYNCHRONIZE | FILE_TRAVERSE`) is selected by setting `read_only`,
     // and `FILE_OPEN_IF` via `OpenOrCreate`.
     let opts = WindowsOpenDirOptions {
         op: WindowsOpenDirOp::OpenOrCreate,
@@ -1442,11 +1442,22 @@ pub mod archiver {
         pub all_files: EntryMap,
     }
 
-    // TODO(port): Zig used a custom U64Context (hash = truncate u64→u32, eql = ==).
-    // bun_collections::ArrayHashMap should accept a custom hasher; encode that here.
-    pub type EntryMap = ArrayHashMap<u64, *mut u8>;
+    // U64Context: hash = truncate u64→u32, eql = ==; the
+    // keys are already wyhash u64s, so truncation is the entire hash.
+    pub type EntryMap = ArrayHashMap<u64, *mut u8, U64Context>;
 
+    #[derive(Default, Clone, Copy)]
     pub struct U64Context;
+    impl bun_collections::array_hash_map::ArrayHashContext<u64> for U64Context {
+        #[inline]
+        fn hash(&self, k: &u64) -> u32 {
+            *k as u32 // @truncate
+        }
+        #[inline]
+        fn eql(&self, a: &u64, b: &u64, _: usize) -> bool {
+            a == b
+        }
+    }
     impl bun_collections::array_hash_map::ArrayHashAdapter<u64, u64> for U64Context {
         #[inline]
         fn hash(&self, k: &u64) -> u32 {
@@ -1470,7 +1481,6 @@ pub mod archiver {
             filepath: &[OSPathChar],
             estimated_size: usize,
         ) -> Result<Plucker, bun_core::Error> {
-            // TODO(port): narrow error set
             Ok(Plucker {
                 contents: MutableString::init(estimated_size)?,
                 filename_hash: hash(slice_as_bytes(filepath)),
@@ -1535,7 +1545,6 @@ impl Archiver {
         ctx: &mut Context,
         appender: &mut A,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut entry: *mut lib::Entry = ptr::null_mut();
 
         // SAFETY: `file_buffer` outlives `stream` (stack-local, dropped at fn exit).
@@ -1543,8 +1552,7 @@ impl Archiver {
         let _ = stream.open_read();
         let archive = stream.archive;
 
-        // PORT NOTE: std.fs.Dir / openDirAbsolute / cwd().openDir — mapped to
-        // bun_sys directory-fd helpers (open_dir_absolute / open_dir_at).
+        // Uses the bun_sys directory-fd helpers (open_dir_absolute / open_dir_at).
         let dir: Fd = 'brk: {
             let cwd = Fd::cwd();
 
@@ -1561,7 +1569,6 @@ impl Archiver {
                 break 'brk d;
             }
         };
-        // PORT NOTE: Zig spec also lacks `defer dir.close()` here (pre-existing leak).
         // Fd has no Drop impl; close explicitly on every return path to avoid leaking
         // a directory HANDLE on Windows. Mirrors the guard pattern in extract_to_disk.
         let _close_dir_guard = scopeguard::guard(dir, |d| d.close());
@@ -1584,9 +1591,9 @@ impl Archiver {
                     let pathname_full = lib::Entry::opaque_ref(entry).pathname();
                     let pathname_bytes = pathname_full.as_bytes();
 
-                    // TODO(port): std.mem.tokenizeScalar + .rest() — approximated by
-                    // skipping DEPTH_TO_SKIP separator-delimited tokens then taking the
-                    // remainder. TODO: verify edge cases (leading/trailing seps).
+                    // Tokenizer semantics: `next()` skips leading
+                    // separators and returns None only when no token remains;
+                    // the rest-of-input slice also skips leading separators.
                     let mut remaining = pathname_bytes;
                     let mut depth_i = 0usize;
                     while depth_i < DEPTH_TO_SKIP {
@@ -1625,14 +1632,12 @@ impl Archiver {
                     let size: usize =
                         usize::try_from(lib::Entry::opaque_ref(entry).size().max(0)).unwrap();
                     if size > 0 {
-                        // PORT NOTE: Zig used `dir.openFile(pathname, .{ .mode = .write_only })`.
                         let Ok(opened) = bun_sys::openat_a(dir, pathname, bun_sys::O::WRONLY, 0)
                         else {
                             continue 'loop_;
                         };
-                        // PORT NOTE: defer opened.close()
+                        // defer opened.close()
                         let _close_guard = scopeguard::guard(opened, |fd| fd.close());
-                        // PORT NOTE: Zig `opened.getEndPos()` → bun_sys::get_file_size.
                         let stat_size = bun_sys::get_file_size(opened)?;
 
                         if stat_size > 0 {
@@ -1676,7 +1681,6 @@ impl Archiver {
         appender: &mut A,
         options: ExtractOptions,
     ) -> Result<u32, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut entry: *mut lib::Entry = ptr::null_mut();
 
         // SAFETY: `file_buffer` outlives `stream` (stack-local, dropped at fn exit).
@@ -1686,7 +1690,7 @@ impl Archiver {
         let mut count: u32 = 0;
         let dir_fd = dir;
 
-        // PORT NOTE: reshaped for borrowck — ctx is Option<&mut>, rebound as needed
+        // reshaped for borrowck — ctx is Option<&mut>, rebound as needed
         let mut ctx = ctx;
 
         #[cfg(unix)]
@@ -1904,7 +1908,6 @@ impl Archiver {
 
                             #[cfg(windows)]
                             {
-                                // Zig: `try bun.MakePath.makePath(u16, dir, path);`
                                 make_path_u16(dir, path_slice)?;
                                 let _ = mode;
                             }
@@ -1925,7 +1928,6 @@ impl Archiver {
                                         // It's possible for some tarballs to return a directory twice, with and
                                         // without `./` in the beginning. So if it already exists, continue to the
                                         // next entry.
-                                        // PORT NOTE: Zig matched error.PathAlreadyExists / error.NotDir.
                                         match err.get_errno() {
                                             bun_sys::E::EEXIST | bun_sys::E::ENOTDIR => continue,
                                             _ => {}
@@ -1973,7 +1975,6 @@ impl Archiver {
                                 };
                                 match bun_sys::symlinkat(link_target, dir_fd, path_z) {
                                     Ok(()) => {}
-                                    // PORT NOTE: Zig matched error.EPERM / error.ENOENT (errnoToZigErr maps 1:1).
                                     Err(err) => match err.get_errno() {
                                         bun_sys::E::EPERM | bun_sys::E::ENOENT => {
                                             let dirname = bun_paths::dirname_simple(path_slice);
@@ -2032,16 +2033,13 @@ impl Archiver {
                                     Ok(fd) => fd,
                                     Err(e) => match e.get_errno() {
                                         bun_sys::E::EPERM | bun_sys::E::ENOENT => {
-                                            // Zig: `bun.Dirname.dirname(u16, path_slice) orelse
-                                            //        return bun.errnoToZigErr(e.errno)` —
-                                            // `std.fs.path.dirnameWindows` semantics (strips
-                                            // trailing separators), NOT `bun.path.dirnameW`.
+                                            // `Dirname::dirname` strips
+                                            // trailing separators.
                                             let Some(dirname) =
                                                 bun_paths::Dirname::dirname(path_slice)
                                             else {
                                                 return Err(e.into());
                                             };
-                                            // Zig: `bun.MakePath.makePath(u16, dir, …) catch {};`
                                             let _ = make_path_u16(dir, dirname);
                                             bun_sys::openat_windows(dir_fd, path_slice, flags, 0)?
                                         }
@@ -2051,14 +2049,13 @@ impl Archiver {
 
                             #[cfg(not(windows))]
                             let file_handle_native: Fd = {
-                                // PORT NOTE: dir.createFileZ(.{truncate, mode}) → bun_sys::openat
+                                // dir.createFileZ(.{truncate, mode}) → bun_sys::openat
                                 // SAFETY: normalized_buf[path_slice.len()] == 0 (written above).
                                 let path_z: &ZStr = unsafe {
                                     ZStr::from_raw(path_slice.as_ptr(), path_slice.len())
                                 };
                                 match bun_sys::openat(dir_fd, path_z, flags, mode) {
                                     Ok(fd) => fd,
-                                    // PORT NOTE: Zig matched error.AccessDenied / error.FileNotFound.
                                     Err(err) => match err.get_errno() {
                                         bun_sys::E::EACCES
                                         | bun_sys::E::EPERM
@@ -2085,7 +2082,7 @@ impl Archiver {
                                 owned
                             };
 
-                            // PORT NOTE: reshaped for borrowck — `plucked_file` is captured by
+                            // reshaped for borrowck — `plucked_file` is captured by
                             // the guard tuple; mutate via close_guard.1.
                             let mut close_guard =
                                 scopeguard::guard((file_handle, false), |(fh, plucked)| {
@@ -2137,7 +2134,6 @@ impl Archiver {
                                     for plucker_ in ctx_.pluckers.iter_mut() {
                                         if plucker_.filename_hash == h {
                                             plucker_.contents.inflate(size)?;
-                                            // Zig: plucker_.contents.list.expandToCapacity()
                                             let cap = plucker_.contents.list.capacity();
                                             plucker_.contents.list.resize(cap, 0);
                                             // SAFETY: archive valid
@@ -2241,7 +2237,6 @@ impl Archiver {
         appender: &mut A,
         options: ExtractOptions,
     ) -> Result<u32, bun_core::Error> {
-        // TODO(port): narrow error set
         let dir: Fd = 'brk: {
             let cwd = Fd::cwd();
             let _ = cwd.make_path_u8(root);
@@ -2262,5 +2257,3 @@ impl Archiver {
         Self::extract_to_dir(file_buffer, dir, ctx, appender, options)
     }
 }
-
-// ported from: src/libarchive/libarchive.zig
diff --git a/src/libdeflate_sys/libdeflate.rs b/src/libdeflate_sys/libdeflate.rs
index d2641947c37..3a9ed0db70d 100644
--- a/src/libdeflate_sys/libdeflate.rs
+++ b/src/libdeflate_sys/libdeflate.rs
@@ -542,5 +542,3 @@ unsafe extern "C" {
         free_func: Option<unsafe extern "C" fn(*mut c_void)>,
     );
 }
-
-// ported from: src/libdeflate_sys/libdeflate.zig
diff --git a/src/libuv_sys/lib.rs b/src/libuv_sys/lib.rs
index 1f54d8613fa..6296ee6225c 100644
--- a/src/libuv_sys/lib.rs
+++ b/src/libuv_sys/lib.rs
@@ -2,8 +2,7 @@
 #![warn(unused_must_use)]
 //! Raw libuv FFI (Windows only). Re-exports the `libuv` module's contents at
 //! crate root so callers can write `bun_libuv_sys::fs_t` /
-//! `bun_sys::windows::libuv::uv_fs_open` (matching the Zig
-//! `bun.windows.libuv.*` namespace).
+//! `bun_sys::windows::libuv::uv_fs_open`.
 pub mod libuv;
 #[cfg(windows)]
 pub use libuv::*;
diff --git a/src/libuv_sys/libuv.rs b/src/libuv_sys/libuv.rs
index 379c038fd6d..697fe34c92f 100644
--- a/src/libuv_sys/libuv.rs
+++ b/src/libuv_sys/libuv.rs
@@ -1,8 +1,7 @@
 //! Zero-cost, zero-alloc FFI bindings for libuv on **Windows**.
 //!
-//! Field-accurate `#[repr(C)]` mirrors of every `uv_*_t` Bun touches, ported
-//! directly from `src/libuv_sys/libuv.zig` (itself `translate-c` of
-//! `vendor/libuv/include/uv.h` + `uv/win.h`). All structs are POD (`Copy` where
+//! Field-accurate `#[repr(C)]` mirrors of every `uv_*_t` Bun touches, derived
+//! from `vendor/libuv/include/uv.h` + `uv/win.h`. All structs are POD (`Copy` where
 //! `union`s permit), all-zero is a valid bit-pattern (libuv expects callers to
 //! `memset(0)` before `uv_*_init`), and no method allocates.
 //!
@@ -63,8 +62,7 @@ pub use bun_windows_sys::{
 // • NTSTATUS: libuv wants plain i32, `bun_windows_sys::NTSTATUS` is a newtype.
 pub type CHAR = u8;
 pub type NTSTATUS = i32;
-/// Win32 `SOCKET` is `UINT_PTR` (an integer), not a pointer; matches Zig's
-/// `std.os.windows.ws2_32.SOCKET = usize`. A raw-pointer type would give
+/// Win32 `SOCKET` is `UINT_PTR` (an integer), not a pointer. A raw-pointer type would give
 /// `Option<SOCKET>` an unwanted niche (None ↔ 0 collides with socket 0) and
 /// force int-to-ptr provenance for `INVALID_SOCKET`.
 pub type SOCKET = usize;
@@ -155,8 +153,7 @@ impl uv_buf_t {
     }
     #[inline]
     pub fn slice(&self) -> &[u8] {
-        // Zig `this.base[0..this.len]` is well-defined for `(null, 0)`; Rust's
-        // `from_raw_parts` is not (requires non-null, aligned even for len==0).
+        // `from_raw_parts` requires non-null, aligned even for len==0.
         // libuv routinely hands back `{len:0, base:NULL}` (declined alloc_cb,
         // `uv_buf_init(NULL,0)`), so guard the empty/null case explicitly.
         if self.len == 0 || self.base.is_null() {
@@ -165,8 +162,7 @@ impl uv_buf_t {
         // SAFETY: caller-supplied (base, len); valid for the buffer's lifetime.
         unsafe { core::slice::from_raw_parts(self.base, self.len as usize) }
     }
-    /// Mutable view of the buffer (Zig `uv_buf_t::slice` returned `[]u8`, which
-    /// carries no exclusivity invariant — Rust `&mut [u8]` does).
+    /// Mutable view of the buffer.
     ///
     /// SAFETY: caller asserts that `(base, len)` came from a writeable
     /// allocation and that no other `&mut`/`&` to that storage is live for the
@@ -396,8 +392,7 @@ const _: () = assert!(!core::mem::needs_drop::<Loop>());
 const _: () = assert!(!core::mem::needs_drop::<UnsafeCell<MaybeUninit<Loop>>>());
 
 thread_local! {
-    /// `threadlocal var threadlocal_loop_data: Loop = undefined` — static TLS
-    /// storage (zero-alloc; mirrors Zig). `MaybeUninit` because the slot is
+    /// Static TLS storage (zero-alloc). `MaybeUninit` because the slot is
     /// only valid after `uv_loop_init`.
     static THREADLOCAL_LOOP_DATA: UnsafeCell<MaybeUninit<Loop>> =
         const { UnsafeCell::new(MaybeUninit::uninit()) };
@@ -407,7 +402,7 @@ thread_local! {
 }
 
 impl Loop {
-    /// `bun.windows.libuv.Loop.get()` (libuv.zig:733). Returns this thread's
+    /// Returns this thread's
     /// libuv loop, lazily `uv_loop_init`ing it on first call. Each thread owns
     /// its own loop; sharing `uv_default_loop()` across worker threads is
     /// unsound for the per-worker shutdown path.
@@ -432,7 +427,7 @@ impl Loop {
         })
     }
 
-    /// `bun.windows.libuv.Loop.shutdown()` (libuv.zig:714). Closes this
+    /// Closes this
     /// thread's libuv loop. Called from `WebWorker::shutdown`.
     pub fn shutdown() {
         THREADLOCAL_LOOP.with(|slot| {
@@ -442,15 +437,15 @@ impl Loop {
             }
             // SAFETY: `loop_` is the live per-thread loop initialized in `get()`.
             if let Some(err) = unsafe { uv_loop_close(loop_) }.raw_errno() {
-                // Zig: `if (err == .BUSY)` — only EBUSY means handles are
+                // Only EBUSY means handles are
                 // still open; walk + close them, run once to flush close
                 // callbacks, then close again (must succeed). `uv_loop_close`
                 // documents no other failure code.
                 if err == (UV_EBUSY as c_int).unsigned_abs() as u16 {
                     unsafe { uv_walk(loop_, Some(close_walk_cb), ptr::null_mut()) };
                     let _ = unsafe { uv_run(loop_, RunMode::Default) };
-                    // NOTE the call is unconditional (Zig `bun.debugAssert`
-                    // evaluates its argument in release too).
+                    // NOTE the call is unconditional — the close must run in
+                    // release builds too.
                     let rc = unsafe { uv_loop_close(loop_) };
                     debug_assert_eq!(rc, ReturnCode::ZERO);
                 }
@@ -482,7 +477,7 @@ impl Loop {
         log!("dec");
         self.active_handles = self.active_handles.saturating_sub(1);
     }
-    /// Aliases matching Zig's `pub const ref = inc`.
+    /// `ref`/`unref` aliases for `inc`/`dec`.
     #[inline]
     pub fn ref_(&mut self) {
         self.inc();
@@ -494,10 +489,9 @@ impl Loop {
     #[inline]
     pub fn unref_count(&mut self, count: i32) {
         log!("unrefCount({})", count);
-        // Zig: `-|= @as(u32, @intCast(count))` — `@intCast` is safety-checked
-        // (panics on negative). A bare `count as u32` would silently wrap a
-        // negative to ~4 billion and zero out `active_handles`. Mirror the
-        // checked cast: assert in debug, clamp in release so we never wrap.
+        // A bare `count as u32` would silently wrap a
+        // negative to ~4 billion and zero out `active_handles`:
+        // assert in debug, clamp in release so we never wrap.
         debug_assert!(count >= 0, "unref_count: count must be non-negative");
         self.active_handles = self.active_handles.saturating_sub(count.max(0) as u32);
     }
@@ -546,7 +540,7 @@ unsafe extern "C" fn close_walk_cb(handle: *mut uv_handle_t, _data: *mut c_void)
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `HandleMixin` (libuv.zig:437) — Rust ports this as a generic trait every
+// Handle mixin — a generic trait every
 // handle type opts into. All methods are `#[inline]` zero-cost casts.
 // ──────────────────────────────────────────────────────────────────────────
 /// Marker for `#[repr(C)]` structs whose first fields are exactly
@@ -583,7 +577,7 @@ pub unsafe trait UvHandle: Sized {
     /// Ownership of `data` transfers to the handle; reclaim with
     /// [`take_owned_data`](UvHandle::take_owned_data) (typically in the
     /// `uv_close_cb`). This is the centralized `Box::into_raw` for the
-    /// `handle.data = bun.new(T, ..)` Zig pattern — callers never spell the
+    /// owned-`handle->data` pattern — callers never spell the
     /// raw round-trip themselves.
     #[inline]
     fn set_owned_data<T>(&mut self, data: Box<T>) {
@@ -722,15 +716,14 @@ pub unsafe trait UvStream: UvHandle {
         // SAFETY: stream prefix invariant.
         unsafe { uv_is_writable((self as *const Self).cast()) != 0 }
     }
-    /// Port of `StreamMixin::readStart` (libuv.zig:3067) — high-level wrapper
+    /// High-level wrapper
     /// over `uv_read_start` that thunks Rust callbacks through a monomorphised
     /// `extern "C"` trampoline. `context` is stashed in `handle.data` and
     /// recovered in the trampoline; the three callbacks are baked into the
-    /// monomorphisation via the [`StreamReader`] trait (Zig captures them as
-    /// `comptime` fn pointers — Rust expresses that as associated fns so the
+    /// monomorphisation via the [`StreamReader`] trait (associated fns, so the
     /// trampoline stays zero-alloc and `Handle` needs no spare storage).
     ///
-    /// Unlike Zig (`error_cb` takes `bun.sys.E`), the Rust binding passes the
+    /// `error_cb` receives the
     /// raw negative libuv errno (`c_int`); this crate is layered below
     /// `bun_sys` so it can't name `E`. Callers map via
     /// `bun_sys::windows::translate_uv_error_to_e`. Returns the raw
@@ -791,11 +784,10 @@ pub unsafe trait UvStream: UvHandle {
     }
 }
 
-/// Callback bundle for [`UvStream::read_start_ctx`]. Port of the three
-/// `comptime` fn-pointer parameters on Zig's `StreamMixin::readStart`
-/// (libuv.zig:3070-3072): Rust monomorphises the `extern "C"` trampolines over
+/// Callback bundle for [`UvStream::read_start_ctx`].
+/// The `extern "C"` trampolines are monomorphised over
 /// this trait so the callbacks are baked into the codegen (zero-alloc, no
-/// per-handle storage) exactly as in Zig.
+/// per-handle storage).
 pub trait StreamReader: Sized {
     fn on_read_alloc(this: &mut Self, suggested_size: usize) -> &mut [u8];
     /// `err` is the raw negative libuv errno (e.g. `UV_EOF`). Map via
@@ -946,16 +938,12 @@ impl uv_write_t {
         // SAFETY: caller initialized `self`; `stream` is a live stream handle.
         unsafe { uv_write(self, stream, input, 1, cb) }
     }
-    /// Context-aware `uv_write` (Zig libuv.zig:1327 `uv_write_t::write` with
-    /// `context: anytype, comptime onWrite`). Stores `context` in `req.data`;
+    /// Context-aware `uv_write`. Stores `context` in `req.data`;
     /// the trampoline recovers it and dispatches to `on_write` as a plain Rust
     /// `&mut`. Generic monomorphisation gives one `extern "C"` thunk per `<T>`.
     ///
-    /// PORT NOTE: Zig captures `onWrite` at *comptime* (one thunk per
-    /// callsite, direct call) and returns `Maybe(void)` with the
-    /// `.toError(.write)` already applied. The Rust port can do neither
-    /// without a `bun_sys` dependency / unstable const-generic fn pointers, so
-    /// it (a) keeps `on_write` runtime-dispatched but stashes it as a `usize`
+    /// Without a `bun_sys` dependency / unstable const-generic fn pointers,
+    /// this (a) keeps `on_write` runtime-dispatched but stashes it as a `usize`
     /// (fn-ptr ↔ integer is well-defined; fn-ptr ↔ data-ptr is not — Miri
     /// rejects the latter), and (b) returns the raw [`ReturnCode`]; callers
     /// apply `.to_error(Tag::write)` themselves. The `bun.sys.syslog` line is
@@ -979,8 +967,7 @@ impl uv_write_t {
             // `uv_write` below; libuv invokes this exactly once with the same
             // `req` pointer. The `usize` → `fn` cast round-trips the address
             // written by `on_write as usize` above (Win64: same width).
-            // Pass the raw `*mut T` straight through (matches Zig's
-            // `uvWriteCb`: `callback(@ptrCast(@alignCast(handler.data)), status)`)
+            // Pass the raw `*mut T` straight through
             // — callers commonly free the `T` allocation inside the callback,
             // so materialising `&mut T` here would leave that reference
             // dangling across the dealloc (UB).
@@ -1181,7 +1168,7 @@ pub struct Pipe {
 pub type uv_pipe_t = Pipe;
 
 impl Pipe {
-    /// `uv_pipe_init` (libuv.zig:1419). Returns the raw `ReturnCode`; callers
+    /// `uv_pipe_init` wrapper. Returns the raw `ReturnCode`; callers
     /// in higher tiers map to `bun_sys::Result` themselves so this crate stays
     /// free of `bun_sys`.
     #[inline]
@@ -1199,7 +1186,7 @@ impl Pipe {
         // SAFETY: pipe was `init`ed; libuv copies the name.
         unsafe { uv_pipe_bind2(self, named_pipe.as_ptr(), named_pipe.len(), flags) }
     }
-    /// `StreamMixin::listen` (libuv.zig:3047). Caller supplies a plain
+    /// Caller supplies a plain
     /// `uv_connection_cb` and recovers its context from `handle.data` itself.
     #[inline]
     pub fn listen(
@@ -1262,7 +1249,7 @@ impl Pipe {
     pub fn as_stream_ptr(&mut self) -> *mut uv_stream_t {
         self.as_stream()
     }
-    /// `Pipe::closeAndDestroy` (libuv.zig:1471) — close the pipe handle (if
+    /// Close the pipe handle (if
     /// needed) and then `Box::from_raw`-drop it. Handles all states:
     /// never-initialized (`loop_ == null`), already closing, or active. After
     /// `uv_pipe_init` the handle is in the event loop's `handle_queue`;
@@ -1274,8 +1261,8 @@ impl Pipe {
     /// never-initialized branch deallocates the pointee — holding a live
     /// `&mut self` across that drop would dangle. In the already-closing
     /// branch the allocation is *not* reclaimed here: the previously
-    /// registered `uv_close` callback is assumed to free the box (matches
-    /// Zig); if a non-freeing callback was registered, the pipe leaks.
+    /// registered `uv_close` callback is assumed to free the box;
+    /// if a non-freeing callback was registered, the pipe leaks.
     pub unsafe fn close_and_destroy(this: *mut Pipe) {
         unsafe extern "C" fn on_close_destroy(handle: *mut Pipe) {
             // SAFETY: handle was Box-allocated; callback fires exactly once.
@@ -1666,7 +1653,7 @@ impl uv_fs_event_t {
         !self.dirw.is_null()
     }
 
-    /// Port of `uv_fs_event_t.hash` (libuv.zig:1750) — `std.hash.Wyhash` over
+    /// Wyhash over
     /// `path ?? "null"`, `events` bytes, `filename`, `status` bytes.
     pub fn hash(&self, filename: &[u8], events: c_int, status: ReturnCode) -> u64 {
         let mut hasher = bun_wyhash::Wyhash::init(0);
@@ -1852,7 +1839,7 @@ impl uv_stat_t {
         self.birthtim
     }
     // Un-prefixed accessors so cross-platform code that pattern-matches on
-    // POSIX `stat.mode`/`stat.size` (Zig: `st.mode`, `st.size`) can call
+    // POSIX `stat.mode`/`stat.size` can call
     // through without `cfg` arms.
     #[inline]
     pub fn mode(&self) -> u64 {
@@ -1941,10 +1928,10 @@ impl fs_t {
 
     /// Debug sentinel: `loop_` is poisoned so `deinit()` can assert that libuv
     /// actually wrote the request before we try to clean it up.
-    /// Zig: `pub const uninitialized: fs_t` — kept as a fn (raw-pointer fields
+    /// Kept as a fn rather than a `const` (raw-pointer fields
     /// in nested unions block a true `const`); `#[inline(always)]` so the
-    /// ~440-byte zero-fill on every sync `uv_fs_*` call optimises identically
-    /// to the Zig `.rodata` value.
+    /// ~440-byte zero-fill on every sync `uv_fs_*` call optimises to a
+    /// `.rodata` copy.
     #[inline(always)]
     pub fn uninitialized() -> fs_t {
         let mut v: fs_t = bun_core::ffi::zeroed();
@@ -1986,7 +1973,7 @@ impl fs_t {
         self.assert_initialized();
         self.ptr.cast::<T>()
     }
-    /// `req.file.fd` (Zig: `union(.{ pathw, fd })` arm). The union is private
+    /// `req.file.fd` union arm. The union is private
     /// because the active variant is path-dependent (`uv_fs_open` writes `fd`;
     /// path-taking ops write `pathw`); callers reading the wrong arm get UB.
     /// SAFETY: only valid after a `uv_fs_*` call that populated the `fd` arm.
@@ -2137,14 +2124,12 @@ pub struct uv_thread_options_t {
 /// Map a negative `UV_E*` libuv error code to the stable `bun.sys.E` /
 /// `bun_errno::E` discriminant (e.g. `UV_ENOENT (-4058)` → `2`).
 ///
-/// This is the leaf-crate copy of Zig `ReturnCode.errno()`'s switch
-/// (libuv.zig:2888-2970). Layering forbids depending on `bun_errno` here, so
+/// Layering forbids depending on `bun_errno` here, so
 /// the integer discriminants are inlined; they are ABI-stable POSIX values
 /// plus a fixed Bun-assigned tail (`UNKNOWN=134`..`FTYPE=137`). Unmapped
-/// codes return `None`, matching Zig's `else => null`.
+/// codes return `None`.
 ///
-/// Keep in sync with `bun_errno::E` (src/errno/windows_errno.rs) and the Zig
-/// switch in `libuv.zig`.
+/// Keep in sync with `bun_errno::E` (src/errno/windows_errno.rs).
 #[inline]
 pub const fn uv_err_to_e_discriminant(code: c_int) -> Option<u16> {
     Some(match code {
@@ -2248,8 +2233,7 @@ pub struct ReturnCode(pub c_int);
 // above is `#[repr(C)]` POD whose fields are integers, raw pointers,
 // `Option<extern fn>` callbacks, nested POD unions, or `HandleType` (a
 // `#[repr(C)]` enum with `Unknown = 0`). The all-zero bit pattern is therefore
-// a valid pre-`uv_*_init` state — exactly what `std::mem::zeroes` produced in
-// the Zig original. Auditing the bound once per type here lets every
+// a valid pre-`uv_*_init` state. Auditing the bound once per type here lets every
 // `Box::new(zeroed())` / stack out-param site drop its `unsafe` block.
 //
 // SAFETY (per type): audited against the field list in this file — no
@@ -2285,7 +2269,7 @@ impl ReturnCode {
     }
     /// `Some(|UV_E*|)` when negative — the **raw** libuv error magnitude
     /// (e.g. 4082 for `UV_EBUSY`). Use [`errno`] for the translated POSIX
-    /// `bun.sys.E` value (e.g. 16 for `BUSY`) that Zig's `errno()` returns.
+    /// `bun.sys.E` value (e.g. 16 for `BUSY`).
     #[inline]
     pub const fn raw_errno(self) -> Option<u16> {
         if self.0 < 0 {
@@ -2294,10 +2278,10 @@ impl ReturnCode {
             None
         }
     }
-    /// Zig `ReturnCode.errno()` (libuv.zig:2888-2970): when negative, map the
+    /// When negative, map the
     /// `UV_E*` code to the small POSIX `bun.sys.E` discriminant (e.g.
     /// `UV_ENOENT (-4058)` → `2`). Returns `None` for non-negative *or*
-    /// unmapped negative codes (Zig: `else => null`). Downstream callers
+    /// unmapped negative codes. Downstream callers
     /// (`node_fs`, `sys::Fd`, `write_file`, …) store this directly into
     /// `bun_sys::Error.errno`, so it MUST be the translated value, not the raw
     /// `|UV_E*|` magnitude — see [`raw_errno`] for the latter.
@@ -2309,14 +2293,14 @@ impl ReturnCode {
             None
         }
     }
-    /// Zig `errEnum()` (libuv.zig:2975-2979) — same translated value as
+    /// Same translated value as
     /// [`errno`]; for the typed `bun_sys::E` use
     /// `bun_sys::ReturnCodeExt::err_enum_e` (layering: `E` lives upstream).
     #[inline]
     pub const fn err_enum(self) -> Option<u16> {
         self.errno()
     }
-    /// Layer-free `< 0` check (Zig: `Maybe(void).isErr()` after `.toError`).
+    /// Layer-free `< 0` check.
     /// For the tagged `bun_sys::Error` use [`ReturnCodeExt::to_error`].
     #[inline]
     pub const fn is_err(self) -> bool {
@@ -2354,7 +2338,7 @@ impl ReturnCodeI64 {
             None
         }
     }
-    /// Zig `errEnum()` (libuv.zig:3022-3027) — translated `bun_sys::E`
+    /// Translated `bun_sys::E`
     /// discriminant via [`uv_err_to_e_discriminant`] (matching
     /// [`ReturnCode::err_enum`]). For the typed `bun_sys::E` use
     /// `bun_sys::ReturnCodeExt::err_enum_e` (layering: `E` lives upstream).
@@ -2366,7 +2350,7 @@ impl ReturnCodeI64 {
             None
         }
     }
-    /// Zig: `toFD()` — `req.result` after a successful `uv_fs_open` is the
+    /// `req.result` after a successful `uv_fs_open` is the
     /// CRT fd. Returns the raw `uv_file`; caller wraps with `Fd::from_uv`
     /// (`bun_core::Fd` is a higher-tier type).
     #[inline]
@@ -2382,10 +2366,10 @@ impl fmt::Display for ReturnCodeI64 {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `O` — `UV_FS_O_*` flag namespace + `from_bun_o`/`to_bun_o` translation
-// (libuv.zig:170-254). The `bun.O.*` POSIX-like values are passed in by the
-// caller as a raw `i32` (per **Zig** `bun.O` on Windows — sys.zig:188-213 —
-// which normalises to Linux-style octal constants, NOT MSVC `libc::O_*`);
+// `O` — `UV_FS_O_*` flag namespace + `from_bun_o`/`to_bun_o` translation.
+// The `bun.O.*` POSIX-like values are passed in by the
+// caller as a raw `i32` (Bun's `O` on Windows normalises to Linux-style
+// octal constants, NOT MSVC `libc::O_*`);
 // these fns map to/from libuv's MSVC `_O_*` values that `uv_fs_open` expects.
 // ──────────────────────────────────────────────────────────────────────────
 pub mod O {
@@ -2415,13 +2399,11 @@ pub mod O {
 
     // `bun.O.*` — POSIX-shaped flag values Bun normalises to internally.
     //
-    // ⚠ These match **Zig `bun.O` on Windows** (src/sys/sys.zig:188-213),
-    // which hard-codes Linux-style octal constants. They do **NOT** match
+    // ⚠ These are hard-coded Linux-style octal constants. They do **NOT** match
     // `bun_sys::O` if that crate is built against MSVC `libc::O_*`
     // (CREAT=0x100, EXCL=0x400, APPEND=0x8). `bun_sys::O` on Windows must
-    // mirror sys.zig — cross-crate static asserts live in `bun_sys` (this
-    // crate stays leaf). libuv.zig pulls these from `bun.O`; the constants
-    // are stable.
+    // mirror these values — cross-crate static asserts live in `bun_sys` (this
+    // crate stays leaf). The constants are stable.
     mod bun_o {
         pub(super) const WRONLY: i32 = 0o1;
         pub(super) const RDWR: i32 = 0o2;
@@ -2463,9 +2445,8 @@ pub mod O {
         // SYNC and DSYNC must be mutually exclusive for libuv on Windows.
         // `bun.O.SYNC` (0o4010000) is a superset of `DSYNC` (0o10000), so check
         // SYNC first to emit only `UV_FS_O_SYNC` when both bits are present.
-        // NOTE: `& != 0` (any-overlap) matches the Zig spec verbatim
-        // (libuv.zig:213); a DSYNC-only input also takes this branch — if that
-        // is wrong it is wrong upstream too.
+        // NOTE: `& != 0` is an any-overlap check;
+        // a DSYNC-only input also takes this branch.
         if c_flags & bun_o::SYNC != 0 {
             flags |= SYNC;
         } else if c_flags & bun_o::DSYNC != 0 {
@@ -2616,7 +2597,7 @@ pub const UV_EUNATCH: c_int = -4023;
 pub const UV_ENOEXEC: c_int = -4022;
 pub const UV_ERRNO_MAX: c_int = -4096;
 
-// `uv_dirent_type_t` discriminants (libuv.zig:2497-2504) — compared against
+// `uv_dirent_type_t` discriminants — compared against
 // `uv_dirent_t.type_` by Windows `fs.readdir`.
 pub const UV_DIRENT_UNKNOWN: c_int = 0;
 pub const UV_DIRENT_FILE: c_int = 1;
@@ -2681,9 +2662,8 @@ pub mod StdioFlags {
     pub const writable_pipe: super::c_uint = super::UV_WRITABLE_PIPE;
     pub const nonblock_pipe: super::c_uint = super::UV_NONBLOCK_PIPE;
     pub const overlapped_pipe: super::c_uint = super::UV_OVERLAPPED_PIPE;
-    // SCREAMING_CASE aliases — Zig exposes both via the implicit
-    // tag↔int coercion; downstream `bun_spawn` was authored against the
-    // upper-case form (process.zig:1261 `StdioFlags.INHERIT_FD`).
+    // SCREAMING_CASE aliases — downstream `bun_spawn` was authored against the
+    // upper-case form (`StdioFlags.INHERIT_FD`).
     pub const IGNORE: super::c_uint = super::UV_IGNORE;
     pub const CREATE_PIPE: super::c_uint = super::UV_CREATE_PIPE;
     pub const INHERIT_FD: super::c_uint = super::UV_INHERIT_FD;
@@ -2742,14 +2722,14 @@ pub const UV_FS_O_SYNC: i32 = O::SYNC;
 
 pub const UV_HANDLE_CLOSED: c_uint = 0x0000_0002;
 
-/// Non-ABI helper (libuv.zig:2772): `flags & UV_HANDLE_CLOSED != 0`.
+/// Non-ABI helper: `flags & UV_HANDLE_CLOSED != 0`.
 #[inline]
 pub fn uv_is_closed(handle: &uv_handle_t) -> bool {
     handle.flags & UV_HANDLE_CLOSED != 0
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// extern "C" — full surface from libuv.zig:2191-2767.
+// extern "C" — full libuv surface Bun uses.
 // ──────────────────────────────────────────────────────────────────────────
 unsafe extern "C" {
     // version / loop
@@ -3596,5 +3576,3 @@ const _: () = {
     assert_offset!(uv_poll_t, data, 0);
     assert_offset!(uv_udp_t, data, 0);
 };
-
-// ported from: src/libuv_sys/libuv.zig
diff --git a/src/lolhtml_sys/lol_html.rs b/src/lolhtml_sys/lol_html.rs
index 34913fc842d..74493f14942 100644
--- a/src/lolhtml_sys/lol_html.rs
+++ b/src/lolhtml_sys/lol_html.rs
@@ -6,7 +6,6 @@ pub enum Error {
     #[error("Fail")]
     Fail,
 }
-// TODO(port): impl From<Error> for bun_core::Error
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -140,8 +139,8 @@ impl HTMLRewriter {
         Ok(())
     }
 
-    // TODO(port): opaque FFI handle freed via C — cannot impl Drop on zero-sized opaque marker.
-    // Consider an owning newtype `OwnedRewriter(NonNull<HTMLRewriter>)` with Drop.
+    // Opaque FFI handle freed via C — Drop cannot be implemented on the
+    // zero-sized opaque marker, so freeing stays an explicit call.
     pub unsafe fn destroy(this: *mut HTMLRewriter) {
         auto_disable();
         // SAFETY: caller guarantees `this` was returned by lol_html_rewriter_build and not yet freed
@@ -191,7 +190,7 @@ unsafe extern "C" {
 }
 
 impl HTMLRewriterBuilder {
-    // TODO(port): opaque FFI handle — see HTMLRewriter::destroy note re: owning wrapper + Drop
+    // Opaque FFI handle — see HTMLRewriter::destroy note.
     pub unsafe fn destroy(this: *mut HTMLRewriterBuilder) {
         auto_disable();
         // SAFETY: caller guarantees `this` came from lol_html_rewriter_builder_new and not yet freed
@@ -221,7 +220,7 @@ impl HTMLRewriterBuilder {
     ///
     /// WARNING: Pointers passed to handlers are valid only during the
     /// handler execution. So they should never be leaked outside of handlers.
-    // PORT NOTE: handler-data params are `Option<NonNull<H>>`, not
+    // handler-data params are `Option<NonNull<H>>`, not
     // `Option<&mut H>` — callers routinely pass the SAME allocation for
     // multiple slots (one `DocumentHandler` services doctype/comment/text/end),
     // and materializing several live `&mut` to one object is UB under Stacked
@@ -282,10 +281,10 @@ impl HTMLRewriterBuilder {
     ///
     /// WARNING: Pointers passed to handlers are valid only during the
     /// handler execution. So they should never be leaked outside of handlers.
-    // PORT NOTE: Zig also checked `handler != null` (in addition to `handler_data != null`); the trait
+    // The trait
     // model assumes the handler is always present when data is Some, so (handler=null, data=non-null)
     // is unrepresentable here.
-    // PORT NOTE: see `add_document_content_handlers` — `Option<NonNull<H>>` to
+    // see `add_document_content_handlers` — `Option<NonNull<H>>` to
     // permit the same handler allocation in multiple slots without aliased
     // `&mut`.
     pub fn add_element_content_handlers<EL, CM, TX>(
@@ -323,7 +322,7 @@ impl HTMLRewriterBuilder {
         }
     }
 
-    // PORT NOTE: takes `*mut S` (not `&mut S`) so the userdata pointer stored
+    // takes `*mut S` (not `&mut S`) so the userdata pointer stored
     // in the C rewriter retains the caller's raw-pointer provenance (typically
     // a `heap::alloc` root). If we took `&mut S`, the userdata would carry a
     // tag derived from that short-lived Unique borrow, and any subsequent
@@ -360,7 +359,7 @@ impl HTMLRewriterBuilder {
     }
 }
 
-/// Trait modeling Zig's `comptime Writer/Done` fn-value pair for `build`.
+/// Writer/Done callback pair for `build`.
 pub trait OutputSink {
     fn write(&mut self, bytes: &[u8]);
     fn done(&mut self);
@@ -373,7 +372,6 @@ unsafe extern "C" fn output_sink_function<S: OutputSink>(
 ) {
     auto_disable();
 
-    // Zig: @setRuntimeSafety(false)
     // SAFETY: user_data was set to &mut S in build(); ptr[0..len] is valid for the duration of this call
     let this = unsafe { bun_core::callback_ctx::<S>(user_data) };
     match len {
@@ -396,7 +394,7 @@ unsafe extern "C" {
 
 impl HTMLSelector {
     /// Frees the memory held by the parsed selector object.
-    // TODO(port): opaque FFI handle — see HTMLRewriter::destroy note
+    // Opaque FFI handle — see HTMLRewriter::destroy note.
     pub unsafe fn destroy(selector: *mut HTMLSelector) {
         auto_disable();
         // SAFETY: caller guarantees `selector` was returned by parse() and not yet freed
@@ -874,7 +872,7 @@ unsafe extern "C" {
 }
 
 impl HTMLString {
-    // TODO(port): #[repr(C)] value crosses FFI by-value; explicit deinit kept instead of Drop
+    // #[repr(C)] value crosses FFI by-value; explicit deinit kept instead of Drop.
     pub fn deinit(self) {
         auto_disable();
         // if (this.len > 0) {
@@ -891,7 +889,6 @@ impl HTMLString {
 
     pub fn slice(&self) -> &[u8] {
         auto_disable();
-        // Zig: @setRuntimeSafety(false)
         // lol_html.h: several getters (lol_html_take_last_error, lol_html_element_get_attribute,
         // lol_html_doctype_*_get) return { data: NULL, len: 0 } to mean "absent". `ffi::slice`
         // tolerates the (null, 0) shape.
@@ -1057,7 +1054,7 @@ impl AttributeIterator {
         }
     }
 
-    // TODO(port): opaque FFI handle — see HTMLRewriter::destroy note
+    // Opaque FFI handle — see HTMLRewriter::destroy note.
     pub fn destroy(&mut self) {
         auto_disable();
         lol_html_attributes_iterator_free(self);
@@ -1217,18 +1214,15 @@ impl DocEnd {
 pub(crate) type DirectiveFunctionType<Container> =
     unsafe extern "C" fn(*mut Container, *mut c_void) -> Directive;
 
-// Zig: fn DirectiveFunctionTypeForHandler(comptime Container, comptime UserDataType) type
-//      = *const fn (*UserDataType, *Container) bool;
-// Rust models this as a trait the user-data type implements per container.
+// A trait the user-data type implements per container.
 pub trait DirectiveCallback<Container> {
     fn call(&mut self, container: &mut Container) -> bool;
 }
 
-// Zig: pub fn DirectiveHandler(comptime Container, comptime UserDataType, comptime Callback) DirectiveFunctionType(Container)
-// Rust: monomorphized extern "C" trampoline per <Container, UserDataType>.
-// TODO(port): Zig took the callback as a comptime fn-value (multiple callbacks per type possible).
-// Rust trait dispatch allows one callback per (UserDataType, Container) pair. If callers need
-// multiple, add a const-generic fn-pointer wrapper or distinct ZST marker types.
+// Monomorphized extern "C" trampoline per <Container, UserDataType>.
+// Trait dispatch allows one callback per
+// (UserDataType, Container) pair. If callers ever need multiple, add a
+// const-generic fn-pointer wrapper or distinct ZST marker types.
 pub unsafe extern "C" fn directive_handler<Container, U: DirectiveCallback<Container>>(
     this: *mut Container,
     user_data: *mut c_void,
@@ -1295,8 +1289,7 @@ pub enum Encoding {
 }
 
 impl Encoding {
-    // Zig: std.enums.EnumMap(Encoding, []const u8) populated at comptime.
-    // For 2 entries a plain match is equivalent and avoids the EnumMap dependency.
+    // For 2 entries a plain match is sufficient.
     pub fn label(self) -> &'static [u8] {
         match self {
             Encoding::UTF8 => b"UTF-8",
@@ -1304,5 +1297,3 @@ impl Encoding {
         }
     }
 }
-
-// ported from: src/lolhtml_sys/lol_html.zig
diff --git a/src/md/ansi_renderer.rs b/src/md/ansi_renderer.rs
index de57b6a8494..9ae612954ee 100644
--- a/src/md/ansi_renderer.rs
+++ b/src/md/ansi_renderer.rs
@@ -36,8 +36,7 @@ pub struct Theme<'a> {
     /// `collectImageUrls` + the CLI entry point) so `emitImage` can
     /// send remote images through Kitty's `t=f` path. When null, http
     /// and https URLs fall through to the alt-text fallback.
-    // LIFETIMES.tsv: BORROW_PARAM. Zig type is
-    // `bun.StringHashMapUnmanaged([]const u8)` — keys are URL bytes,
+    // LIFETIMES.tsv: BORROW_PARAM. Keys are URL bytes,
     // values are file-path bytes.
     pub remote_image_paths: Option<&'a StringHashMap<Box<[u8]>>>,
     /// Base directory used to resolve relative image `src` paths. When
@@ -78,7 +77,6 @@ impl ImageUrlCollector {
     }
 }
 
-// PORT NOTE: Zig manual VTable collapsed into RendererImpl trait.
 impl RendererImpl for ImageUrlCollector {
     fn enter_block(&mut self, _: BlockType, _: u32, _: u32) -> JsResult<()> {
         Ok(())
@@ -271,8 +269,7 @@ impl OutputBuffer {
         if self.oom {
             return;
         }
-        // PERF(port): was appendSlice with latched OOM — Vec::extend aborts
-        // on OOM under the global mimalloc allocator.
+        // Vec::extend aborts on OOM under the global mimalloc allocator.
         self.list.extend_from_slice(data);
     }
 
@@ -374,9 +371,9 @@ impl<'a> AnsiRenderer<'a> {
                     kind: BlockKind::Li,
                     ..Default::default()
                 };
-                // PORT NOTE: reshaped for borrowck — find_parent_list returns
-                // an index instead of `&mut BlockContext` so we can call
-                // self.write_styled() afterwards without an aliasing borrow.
+                // find_parent_list returns an index instead of
+                // `&mut BlockContext` so we can call self.write_styled()
+                // afterwards without an aliasing borrow.
                 let parent_list = self.find_parent_list();
                 let task_mark = types::task_mark_from_data(data);
                 if let Some(idx) = parent_list {
@@ -593,9 +590,8 @@ impl<'a> AnsiRenderer<'a> {
                     if self.theme.colors && self.theme.hyperlinks {
                         if let Some(href) = &self.link_href {
                             // OSC 8 hyperlink start
-                            // PORT NOTE: reshaped for borrowck — clone the
-                            // bytes so write_raw_no_color(&mut self) doesn't
-                            // alias `&self.link_href`.
+                            // Clone the bytes so write_raw_no_color(&mut self)
+                            // doesn't alias `&self.link_href`.
                             let href = href.clone();
                             self.write_raw_no_color(b"\x1b]8;;");
                             self.write_raw_no_color(&href);
@@ -1324,9 +1320,8 @@ impl<'a> AnsiRenderer<'a> {
 
     /// Find the nearest enclosing ul/ol in the block stack (walking
     /// from innermost outward, skipping the current li at the top).
-    // PORT NOTE: reshaped for borrowck — returns an index into
-    // block_stack instead of `&mut BlockContext` so callers can call
-    // other &mut self methods between accesses.
+    // Returns an index into block_stack instead of `&mut BlockContext`
+    // so callers can call other &mut self methods between accesses.
     fn find_parent_list(&self) -> Option<usize> {
         let len = self.block_stack.len();
         if len == 0 {
@@ -1354,8 +1349,8 @@ impl<'a> AnsiRenderer<'a> {
         // inside a blockquote the bold+color writes reach heading_buf and
         // may realloc its backing array, dangling the `content` slice below.
         self.heading_level = 0;
-        // PORT NOTE: reshaped for borrowck — take ownership of heading_buf
-        // so write_indent(&mut self) doesn't alias `content`.
+        // Take ownership of heading_buf so write_indent(&mut self)
+        // doesn't alias `content`.
         let content = core::mem::take(&mut self.heading_buf);
         self.write_indent();
         if self.theme.colors {
@@ -1417,8 +1412,8 @@ impl<'a> AnsiRenderer<'a> {
     // ========================================
 
     fn flush_code_block(&mut self) {
-        // PORT NOTE: reshaped for borrowck — take ownership of code_buf so
-        // self.write_indent() etc. don't alias it.
+        // Take ownership of code_buf so self.write_indent() etc.
+        // don't alias it.
         let src = core::mem::take(&mut self.code_buf);
         // Strip exactly one trailing newline (parser adds one).
         let body: &[u8] = if !src.is_empty() && src[src.len() - 1] == b'\n' {
@@ -1622,8 +1617,8 @@ impl<'a> AnsiRenderer<'a> {
         self.last_was_newline = true;
 
         let mut has_separated_header = false;
-        // PORT NOTE: reshaped for borrowck — take ownership of table_rows so
-        // self.write_row_cells(&mut self) doesn't alias it.
+        // Take ownership of table_rows so self.write_row_cells(&mut self)
+        // doesn't alias it.
         let rows = core::mem::take(&mut self.table_rows);
         for row in &rows {
             self.write_row_cells(row, &widths, &aligns);
@@ -1877,8 +1872,8 @@ impl<'a> AnsiRenderer<'a> {
         // Snapshot alt + link fields now — emitImage drops out of the
         // image context before writing, so image_alt / image_depth checks
         // in emitInline would otherwise still divert output.
-        // PORT NOTE: reshaped for borrowck — take ownership of buffered
-        // fields so &mut self methods below don't alias.
+        // Take ownership of the buffered fields so &mut self methods
+        // below don't alias.
         let alt = core::mem::take(&mut self.image_alt);
         let src = self.image_src.take();
         let title = self.image_title.take();
@@ -2535,7 +2530,6 @@ pub fn detect_kitty_graphics() -> bool {
 /// the reply with a short timeout. Raw mode is applied + restored
 /// around the read so the bytes don't echo to the user's terminal.
 fn probe_kitty_graphics() -> bool {
-    // Zig: `if (comptime !bun.Environment.isPosix) return false;`
     #[cfg(not(unix))]
     {
         return false;
@@ -2582,7 +2576,6 @@ fn probe_kitty_graphics() -> bool {
             events: bun_sys::posix::POLL_IN,
             revents: 0,
         }];
-        // bun.sys.poll has a Maybe variant Zig flags as incomplete — keep std.posix.poll.
         let ready = match bun_sys::posix::poll(&mut pfd, 80) {
             Ok(r) => r,
             Err(_) => return false,
@@ -2698,7 +2691,6 @@ fn extract_png_data_url_base64(src: &[u8]) -> Option<&[u8]> {
     Some(payload)
 }
 
-// PORT NOTE: Zig manual VTable collapsed into RendererImpl trait.
 impl RendererImpl for AnsiRenderer<'_> {
     fn enter_block(&mut self, block_type: BlockType, data: u32, flags: u32) -> JsResult<()> {
         AnsiRenderer::enter_block(self, block_type, data, flags);
@@ -2742,5 +2734,3 @@ pub fn render_to_ansi<'a>(
         core::mem::take(&mut renderer.out.list).into_boxed_slice(),
     ))
 }
-
-// ported from: src/md/ansi_renderer.zig
diff --git a/src/md/autolinks.rs b/src/md/autolinks.rs
index bc9e2987267..f1b386a9987 100644
--- a/src/md/autolinks.rs
+++ b/src/md/autolinks.rs
@@ -395,5 +395,3 @@ fn post_process_autolink_end(content: &[u8], beg: usize, end_in: usize) -> usize
 
     end
 }
-
-// ported from: src/md/autolinks.zig
diff --git a/src/md/blocks.rs b/src/md/blocks.rs
index f4ced5313ee..7f9dcccd1fe 100644
--- a/src/md/blocks.rs
+++ b/src/md/blocks.rs
@@ -22,11 +22,10 @@ impl Parser<'_> {
         self.enter_block(BlockType::Doc, 0, 0)?;
 
         while off < self.size {
-            // PORT NOTE: reshaped for borrowck — index into line_buf via raw idx
             let line = &mut line_buf[line_idx];
 
             self.analyze_line(off, &mut off, &pivot_line, line)?;
-            // PORT NOTE: reshaped for borrowck — pass whole buf + idx so process_line can swap
+            // Pass the whole buf + idx so process_line can swap lines.
             self.process_line(&mut pivot_line, line_idx, &mut line_buf, &mut line_idx)?;
         }
 
@@ -694,8 +693,8 @@ impl Parser<'_> {
         line_buf: &mut [Line; 2],
         line_idx: &mut usize,
     ) -> Result<(), bun_alloc::AllocError> {
-        // PORT NOTE: reshaped for borrowck — Zig passed `line: *Line` aliasing into line_buf;
-        // here we index into line_buf via cur_line_idx.
+        // Index into line_buf via cur_line_idx instead of taking a `&mut Line`
+        // parameter, which would alias line_buf.
         let line = &mut line_buf[cur_line_idx];
 
         // Blank line ends current leaf block.
@@ -882,8 +881,8 @@ impl Parser<'_> {
 
     pub fn end_current_block(&mut self) -> Result<(), bun_alloc::AllocError> {
         if let Some(cb_off) = self.current_block {
-            // PORT NOTE: reshaped for borrowck — capture header fields, drop the &mut borrow,
-            // then access other &self fields.
+            // Capture the header fields, drop the &mut borrow, then access
+            // other &self fields.
             let (is_setext, hdr_n_lines) = {
                 let hdr = self.get_block_header_at(cb_off);
                 (
@@ -940,7 +939,6 @@ impl Parser<'_> {
 
         // Merge lines into buffer for ref def parsing
         self.buffer.clear();
-        // PORT NOTE: reshaped for borrowck — index instead of borrowing items slice.
         for idx in 0..self.current_block_lines.len() {
             let vline = self.current_block_lines[idx];
             if vline.beg > vline.end || vline.end > self.size {
@@ -953,8 +951,8 @@ impl Parser<'_> {
                 .extend_from_slice(&self.text[vline.beg as usize..vline.end as usize]);
         }
 
-        // PORT NOTE: reshaped for borrowck — move merged buffer out of self so
-        // parse_ref_def/normalize_label can borrow &self/&mut self.
+        // Move the merged buffer out of self so parse_ref_def/normalize_label
+        // can borrow &self/&mut self.
         let merged = core::mem::take(&mut self.buffer);
         let mut pos: usize = 0;
         let mut lines_consumed: u32 = 0;
@@ -1004,7 +1002,6 @@ impl Parser<'_> {
 
         if lines_consumed > 0 {
             if let Some(cb_off) = self.current_block {
-                // PORT NOTE: reshaped for borrowck — capture n_lines, mutate, then write back.
                 let hdr_n_lines = self.get_block_header_at(cb_off).n_lines;
                 if lines_consumed >= hdr_n_lines {
                     // All lines consumed
@@ -1028,5 +1025,3 @@ impl Parser<'_> {
 }
 
 use crate::types::LineType;
-
-// ported from: src/md/blocks.zig
diff --git a/src/md/containers.rs b/src/md/containers.rs
index c8ee6f57a0c..c38ec8e2b43 100644
--- a/src/md/containers.rs
+++ b/src/md/containers.rs
@@ -10,7 +10,6 @@ impl Parser<'_> {
     pub fn push_container(&mut self, c: &Container) -> Result<(), AllocError> {
         if (self.n_containers as usize) >= self.containers.len() {
             self.containers.push(*c);
-            // PERF(port): Vec::push aborts on OOM; Zig returned error.OutOfMemory
         } else {
             self.containers[self.n_containers as usize] = *c;
         }
@@ -53,8 +52,7 @@ impl Parser<'_> {
     pub fn enter_child_containers(&mut self, count: u32) -> Result<(), AllocError> {
         let mut i: u32 = self.n_containers - count;
         while i < self.n_containers {
-            // PORT NOTE: reshaped for borrowck — capture container fields before
-            // calling &mut self methods.
+            // Capture the container fields before calling &mut self methods.
             let idx = i as usize;
             let ch = self.containers[idx].ch;
             let is_task = self.containers[idx].is_task;
@@ -105,8 +103,7 @@ impl Parser<'_> {
     pub fn leave_child_containers(&mut self, keep: u32) -> Result<(), AllocError> {
         while self.n_containers > keep {
             self.n_containers -= 1;
-            // PORT NOTE: reshaped for borrowck — capture container fields before
-            // calling &mut self methods.
+            // Capture the container fields before calling &mut self methods.
             let idx = self.n_containers as usize;
             let ch = self.containers[idx].ch;
             let is_loose = self.containers[idx].is_loose;
@@ -183,9 +180,8 @@ impl Parser<'_> {
 
     pub fn process_all_blocks(&mut self) -> Result<(), parser::Error> {
         let mut off: usize = 0;
-        // PORT NOTE: reshaped for borrowck — capture raw ptr/len so we can call
-        // &mut self methods inside the loop. block_bytes is not mutated during
-        // process_all_blocks.
+        // Capture the raw ptr/len so we can call &mut self methods inside the
+        // loop. block_bytes is not mutated during process_all_blocks.
         let bytes_len = self.block_bytes.len();
         let bytes_ptr = self.block_bytes.as_ptr();
 
@@ -294,5 +290,3 @@ impl Parser<'_> {
         Ok(())
     }
 }
-
-// ported from: src/md/containers.zig
diff --git a/src/md/entity.rs b/src/md/entity.rs
index 6a461af8688..4d85c8c045f 100644
--- a/src/md/entity.rs
+++ b/src/md/entity.rs
@@ -7,7 +7,6 @@ use core::cmp::Ordering;
 /// Sorted array of entity names (including & and ;) mapped to Unicode codepoint(s).
 pub(crate) struct Entity {
     pub name: &'static [u8],
-    // PORT NOTE: Zig `u21` (Unicode codepoint) → `u32`.
     pub codepoints: [u32; 2],
 }
 
@@ -2158,5 +2157,3 @@ static ENTITY_MAP: &[Entity] = &[
     Entity { name: b"&zwj;", codepoints: [8205, 0] },
     Entity { name: b"&zwnj;", codepoints: [8204, 0] },
 ];
-
-// ported from: src/md/entity.zig
diff --git a/src/md/helpers.rs b/src/md/helpers.rs
index 852f9d78f16..5cf0c76d639 100644
--- a/src/md/helpers.rs
+++ b/src/md/helpers.rs
@@ -430,7 +430,7 @@ pub fn generate_slug<'a>(
     let mut out_len: usize = 0;
     let mut prev_hyphen: bool = true; // true to trim leading hyphens
 
-    // PORT NOTE: reshaped for borrowck — index instead of `for &c in text_items`
+    // reshaped for borrowck — index instead of `for &c in text_items`
     for idx in 0..text_len {
         let c = text_buf[idx];
         if c >= b'A' && c <= b'Z' {
@@ -456,25 +456,25 @@ pub fn generate_slug<'a>(
         out_len -= 1;
     }
 
-    // Deduplicate via slug_counts
-    // TODO(port): exact bun_collections::StringHashMap entry/get_or_put API — Zig used getOrPut
-    // with a borrowed key then duped it on first insert. Here we look up first, then insert an
-    // owned key on miss; map is assumed to own its keys (so Drop frees them).
-    if let Some(value) = slug_counts.get_mut(&text_buf[..out_len]) {
-        // Already seen — append -N suffix
-        let count = *value + 1;
-        *value = count;
-        text_buf.truncate(out_len);
-        text_buf.push(b'-');
-
-        let mut dec_buf = bun_core::fmt::ItoaBuf::new();
-        text_buf.extend_from_slice(bun_core::fmt::itoa(&mut dec_buf, count));
-        return text_buf.as_slice();
+    // Deduplicate via slug_counts. `StringHashMap::get_or_put` probes
+    // once (the map owns its keys, value starts at 0 on miss).
+    let Ok(gop) = slug_counts.get_or_put(&text_buf[..out_len]) else {
+        return &text_buf[..out_len];
+    };
+    if !gop.found_existing {
+        // First occurrence — value initialised to 0 by `get_or_put`.
+        return &text_buf[..out_len];
     }
 
-    // First occurrence — store an owned key so the map owns it
-    slug_counts.put_assume_capacity(&text_buf[..out_len], 0);
-    &text_buf[..out_len]
+    // Already seen — append -N suffix
+    let count = *gop.value_ptr + 1;
+    *gop.value_ptr = count;
+    text_buf.truncate(out_len);
+    text_buf.push(b'-');
+
+    let mut dec_buf = bun_core::fmt::ItoaBuf::new();
+    text_buf.extend_from_slice(bun_core::fmt::itoa(&mut dec_buf, count));
+    text_buf.as_slice()
 }
 
 /// Shared heading-ID state used by all renderers (HTML, React AST, JS callbacks).
@@ -540,5 +540,3 @@ impl HeadingIdTracker {
         self.text_buf.clear();
     }
 }
-
-// ported from: src/md/helpers.zig
diff --git a/src/md/html_renderer.rs b/src/md/html_renderer.rs
index b6076083baa..6a5f1c99911 100644
--- a/src/md/html_renderer.rs
+++ b/src/md/html_renderer.rs
@@ -12,7 +12,7 @@ pub(crate) struct HtmlRenderer<'src> {
     // allocator dropped — non-AST crate uses global mimalloc
     pub src_text: &'src [u8],
     pub image_nesting_level: u32,
-    // PORT NOTE: was `&'src [u8]` borrowing parser content; owned now so the
+    // Owned (rather than `&'src [u8]` borrowing parser content) so the
     // RendererImpl trait does not entangle SpanDetail's lifetime with 'src.
     pub saved_img_title: Box<[u8]>,
     pub tag_filter: bool,
@@ -159,7 +159,7 @@ impl<'src> HtmlRenderer<'src> {
                     }
                     if lang_end > info_beg {
                         self.write(b" class=\"language-");
-                        // PORT NOTE: reshaped for borrowck — capture slice before &mut self call.
+                        // Capture the slice before the &mut self call.
                         let src_text = self.src_text;
                         self.write_with_entity_decoding(&src_text[info_beg..lang_end]);
                         self.write(b"\"");
@@ -340,7 +340,7 @@ impl<'src> HtmlRenderer<'src> {
                     self.write(b"\"");
                     if !self.saved_img_title.is_empty() {
                         self.write(b" title=\"");
-                        // PORT NOTE: reshaped for borrowck — take field before &mut self call.
+                        // Take the field before the &mut self call.
                         let title = core::mem::take(&mut self.saved_img_title);
                         self.write_title_with_escapes(&title);
                         self.write(b"\"");
@@ -643,8 +643,6 @@ impl<'src> HtmlRenderer<'src> {
 // Static helpers
 // ========================================
 
-// PORT NOTE: Zig's manual `*anyopaque + VTable` is collapsed into the
-// `RendererImpl` trait (see types.rs); the static VTABLE is no longer needed.
 impl RendererImpl for HtmlRenderer<'_> {
     fn enter_block(&mut self, block_type: BlockType, data: u32, flags: u32) -> JsResult<()> {
         HtmlRenderer::enter_block(self, block_type, data, flags);
@@ -691,7 +689,6 @@ fn is_disallowed_tag(content: &[u8]) -> bool {
         b"script",
         b"plaintext",
     ];
-    // PERF(port): was `inline for` (comptime unroll) — profile if it shows up on a hot path.
     for tag in DISALLOWED.iter() {
         if match_tag_name_ci(content, after_lt, tag) {
             return true;
@@ -721,5 +718,3 @@ fn match_tag_name_ci(content: &[u8], pos: usize, tag: &[u8]) -> bool {
 fn find_entity_in_text(content: &[u8], start: usize) -> Option<usize> {
     helpers::find_entity(content, start)
 }
-
-// ported from: src/md/html_renderer.zig
diff --git a/src/md/inlines.rs b/src/md/inlines.rs
index f29d219f913..1f1226e527a 100644
--- a/src/md/inlines.rs
+++ b/src/md/inlines.rs
@@ -19,9 +19,9 @@ pub struct EmphDelim {
     pub close_count: usize, // total chars consumed as closer
     // Individual match sizes in order (each is 1 for em, 2 for strong)
     pub open_sizes: [u8; MAX_EMPH_MATCHES],
-    pub open_num: u8, // number of open matches (Zig: u4)
+    pub open_num: u8, // number of open matches
     pub close_sizes: [u8; MAX_EMPH_MATCHES],
-    pub close_num: u8, // number of close matches (Zig: u4)
+    pub close_num: u8, // number of close matches
     pub active: bool,  // false if deactivated between matched pairs
 }
 
@@ -145,10 +145,13 @@ impl Parser<'_> {
                 merged_len -= 1;
             }
         }
-        // PORT NOTE: reshaped for borrowck — Zig passes self.buffer.items directly into a
-        // &self method; Rust take()s the Vec out so process_inline_content (and any recursive
-        // call via process_link) gets a fresh self.buffer to scribble on without aliasing.
-        // TODO(port): verify recursive calls (via process_link) do not need the parent buffer.
+        // take() the Vec out so process_inline_content (and any recursive
+        // call via process_link) gets a fresh self.buffer to scribble on without
+        // aliasing. Verified: nothing reachable from process_inline_content
+        // (including recursive process_link -> process_inline_content calls, which
+        // operate solely on the `content`/label slices) touches `self.buffer`; its
+        // other users (ref-def merging in blocks.rs/ref_defs.rs) run during the
+        // block phase, never re-entrantly from here.
         let merged = core::mem::take(&mut self.buffer);
         let ret = self.process_inline_content(&merged[..merged_len], block_lines[0].beg);
         self.buffer = merged;
@@ -183,7 +186,6 @@ impl Parser<'_> {
         self.resolve_emphasis_delimiters();
 
         // Copy resolved delimiters locally (recursive calls may modify emph_delims)
-        // PORT NOTE: Zig dupe() catch OOM → emit plain text fallback; Rust Vec::clone aborts on OOM.
         let resolved: Vec<EmphDelim> = self.emph_delims.clone();
 
         // Phase 2: Emit content using resolved emphasis info
@@ -672,7 +674,7 @@ impl Parser<'_> {
 
     /// Resolve emphasis delimiters using the CommonMark algorithm.
     pub fn resolve_emphasis_delimiters(&mut self) {
-        // PORT NOTE: reshaped for borrowck — index directly into self.emph_delims
+        // reshaped for borrowck — index directly into self.emph_delims
         // instead of binding `delims` + `opener` aliases.
         let len = self.emph_delims.len();
         if len == 0 {
@@ -1165,5 +1167,3 @@ pub fn can_close_emphasis(emph_char: u8, content: &[u8], run_start: usize, run_e
     !lf || (run_end < content.len()
         && helpers::is_unicode_punctuation(helpers::decode_utf8(content, run_end).codepoint))
 }
-
-// ported from: src/md/inlines.zig
diff --git a/src/md/line_analysis.rs b/src/md/line_analysis.rs
index e8091adfc9c..9dc466c0e6c 100644
--- a/src/md/line_analysis.rs
+++ b/src/md/line_analysis.rs
@@ -4,9 +4,7 @@ use super::types;
 use super::types::{Align, Container, OFF};
 
 // ──────────────────────────────────────────────────────────────────────────
-// Result types for the anonymous-struct returns in the Zig source.
-// Kept as named structs (not tuples) so field names line up with the .zig
-// for side-by-side diffing.
+// Result types, kept as named structs (not tuples) for readable field access.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Copy, Clone)]
@@ -845,5 +843,3 @@ impl Parser<'_> {
         }
     }
 }
-
-// ported from: src/md/line_analysis.zig
diff --git a/src/md/links.rs b/src/md/links.rs
index 92a89cde4fd..99d14f1423d 100644
--- a/src/md/links.rs
+++ b/src/md/links.rs
@@ -3,8 +3,8 @@ use crate::inlines;
 use crate::parser::{self, Parser};
 use crate::types::{OFF, SpanDetail, SpanType, TextType};
 
-// PORT NOTE: aliases for the real `SpanType` / `SpanDetail` types (the Zig
-// original named them `Span` / `SpanAttrs`).
+// Aliases for the real `SpanType` / `SpanDetail` types (named `Span` /
+// `SpanAttrs` in the original implementation).
 type Span = SpanType;
 type SpanAttrs<'a> = SpanDetail<'a>;
 type Off = OFF;
@@ -22,14 +22,14 @@ const MAX_LINK_DEST_PAREN_DEPTH: u32 = 32;
 /// wiki links are enabled, e.g. via `Bun.markdown.ansi`).
 const MAX_WIKI_BRACKET_DEPTH: u32 = 32;
 
-/// Result of `try_match_bracket_link` — Zig anonymous return struct.
+/// Result of `try_match_bracket_link`.
 pub struct BracketLinkMatch {
     pub is_link: bool,
     pub label_end: usize,
     pub link_end: usize,
 }
 
-/// Result of `find_autolink` — Zig anonymous return struct.
+/// Result of `find_autolink`.
 pub struct Autolink {
     pub end_pos: usize,
     pub is_email: bool,
@@ -496,8 +496,8 @@ impl Parser<'_> {
                 };
                 pos += 1;
                 if let Some(ref_def) = self.lookup_ref_def(ref_label) {
-                    // PORT NOTE: reshaped for borrowck — clone owned dest/title so the
-                    // &self borrow from lookup_ref_def is dropped before &mut self calls.
+                    // Clone the owned dest/title so the &self borrow from
+                    // lookup_ref_def is dropped before &mut self calls.
                     let dest: Box<[u8]> = Box::from(&ref_def.dest[..]);
                     let title: Box<[u8]> = Box::from(&ref_def.title[..]);
                     // Link nesting prohibition
@@ -523,7 +523,8 @@ impl Parser<'_> {
         };
         if char_after_label != b'[' {
             if let Some(ref_def) = self.lookup_ref_def(label) {
-                // PORT NOTE: reshaped for borrowck — clone owned dest/title.
+                // Clone the owned dest/title so the &self borrow from
+                // lookup_ref_def is dropped before &mut self calls.
                 let dest: Box<[u8]> = Box::from(&ref_def.dest[..]);
                 let title: Box<[u8]> = Box::from(&ref_def.title[..]);
                 // Link nesting prohibition
@@ -1014,5 +1015,3 @@ impl Parser<'_> {
         Ok(())
     }
 }
-
-// ported from: src/md/links.zig
diff --git a/src/md/parser.rs b/src/md/parser.rs
index a7ae8aadec2..a98aeacc6c5 100644
--- a/src/md/parser.rs
+++ b/src/md/parser.rs
@@ -5,8 +5,7 @@ use core::ffi::c_void;
 
 use bun_collections::bit_set::{ArrayBitSet, num_masks_for};
 
-// Zig `bun.bit_set.StaticBitSet(256)` resolves to `ArrayBitSet(usize, 256)`
-// (size > @bitSizeOf(usize)). Stable Rust cannot branch a type on a const
+// Stable Rust cannot branch a type on a const
 // generic, so per bit_set.rs guidance we pick `ArrayBitSet` directly. The
 // inline scanner in inlines.rs depends on `is_set()` being real — a no-op
 // stub here makes every byte fall through the fast path and disables all
@@ -20,19 +19,18 @@ use super::types::{
     Align, BlockType, Container, Flags, Mark, NUM_OPENER_STACKS, OFF, OpenerStack, Renderer,
     TABLE_MAXCOLCOUNT, VerbatimLine,
 };
-use crate::RenderOptions; // Zig: `root.RenderOptions` (root.zig → crate lib.rs)
+use crate::RenderOptions;
 
-// Re-exports that Zig nested under `Parser.*` — Rust has no struct-scoped type
-// aliases, so they live at module scope as `parser::EmphDelim` etc.
+// Rust has no struct-scoped type
+// aliases, so these live at module scope as `parser::EmphDelim` etc.
 pub use super::inlines::{EmphDelim, HtmlScanMemo, MAX_EMPH_MATCHES};
 pub use super::ref_defs::RefDef;
 
 /// Parser context holding all state during parsing.
-// PORT NOTE: `text` is a caller-owned borrow for the parser's lifetime.
+// `text` is a caller-owned borrow for the parser's lifetime.
 // PORTING.md's mechanical-port guidance was "no struct lifetimes", but raw-ptr
 // here would obscure every `ch()` call; one obvious `'a` is the honest mapping.
 pub struct Parser<'a> {
-    // Zig field `std.mem.Allocator` param — dropped; global mimalloc.
     pub text: &'a [u8],
     pub size: OFF,
     pub flags: Flags,
@@ -52,10 +50,12 @@ pub struct Parser<'a> {
     // Dynamic arrays
     pub marks: Vec<Mark>,
     pub containers: Vec<Container>,
-    // TODO(port): Zig uses `ArrayListAlignedUnmanaged(u8, .@"4")` — 4-byte
-    // alignment is load-bearing for `BlockHeader` reinterpretation via
-    // `getBlockHeaderAt`. Wrap in an aligned-vec newtype or store
-    // `Vec<u32>` and byte-view it.
+    // 4-byte alignment is
+    // load-bearing for the `BlockHeader` reinterpretation in
+    // `get_block_header_at`. Here the invariant rests on (a) offsets being
+    // padded to a multiple of 4 by every writer and (b) the global allocator
+    // returning >=16-byte-aligned bases; `get_block_header_at`
+    // debug-asserts it on every access.
     pub block_bytes: Vec<u8>,
     pub buffer: Vec<u8>,
     pub emph_delims: Vec<EmphDelim>,
@@ -126,14 +126,13 @@ impl Default for BlockHeader {
     }
 }
 
-/// `Parser.Error` in Zig is `bun.JSError || bun.StackOverflow`, i.e. the union
+/// `Parser`'s error type: the union
 /// of `{ OutOfMemory, JSError, JSTerminated }` with `{ StackOverflow }`.
-// TODO(port): narrow error set — `bun_jsc::JsError` already covers the first
-// three; could be `enum { Js(JsError), StackOverflow }` instead.
-// TODO(port): thiserror/strum not in workspace deps — derive dropped, hand-roll if needed.
+// (`bun_jsc::JsError` covers the first three, but the md crate sits below
+// `bun_jsc` in the layering, so the variants stay flat here.)
 pub type Error = ParserError;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, strum::IntoStaticStr)]
 pub enum ParserError {
     OutOfMemory,
     JSError,
@@ -144,9 +143,8 @@ pub enum ParserError {
 bun_core::oom_from_alloc!(ParserError);
 
 impl From<ParserError> for bun_core::Error {
-    fn from(_e: ParserError) -> Self {
-        // TODO(port): wire IntoStaticStr → interned tag; bun_core::err! only accepts ident
-        bun_core::err!(ParserError)
+    fn from(e: ParserError) -> Self {
+        bun_core::err!(from e)
     }
 }
 
@@ -156,8 +154,6 @@ impl<'a> Parser<'a> {
         // to a multiple of `align_of::<BlockHeader>()`, and the global allocator returns
         // blocks aligned to at least `align_of::<usize>()`, so the resulting pointer is
         // 4-byte aligned (asserted below). The buffer holds an initialized BlockHeader there.
-        // TODO(port): borrowck — this returns &mut into self.block_bytes while other
-        // &mut self borrows may be live at call sites; may need raw *mut.
         unsafe {
             let ptr = self
                 .block_bytes
@@ -221,8 +217,7 @@ impl<'a> Parser<'a> {
         p
     }
 
-    // Zig `fn deinit(self: *Parser)` only frees the `ArrayListUnmanaged` fields.
-    // All of those are now `Vec<_>`, so `Drop` is automatic — no explicit impl.
+    // All owned buffers are `Vec<_>`, so `Drop` is automatic — no explicit impl.
 
     #[inline]
     pub fn ch(&self, off: OFF) -> u8 {
@@ -274,12 +269,10 @@ impl<'a> Parser<'a> {
     // Delegated methods (re-exports)
     // ========================================
     //
-    // In Zig these are `pub const foo = other_mod.foo;` aliases that pull free
-    // functions into `Parser`'s decl namespace so they dispatch as methods
-    // (`parser.foo(...)`). Rust has no decl-aliasing; instead each sibling
+    // Each sibling
     // module defines its own `impl Parser<'_> { ... }` block (multiple `impl`
     // blocks per type within one crate are idiomatic). The list below is kept
-    // as documentation so the .zig ↔ .rs diff stays line-aligned.
+    // as documentation of where each method lives.
     //
     // render_blocks.rs — impl Parser:
     //   enter_block, leave_block, process_code_block, process_html_block,
@@ -335,10 +328,8 @@ pub fn render_to_html(
     let input = helpers::skip_utf8_bom(text);
 
     let mut html_renderer = HtmlRenderer::init(input, render_opts);
-    // Zig `errdefer html_renderer.deinit()` — Drop handles cleanup on `?`.
 
     let mut parser = Parser::init(input, flags, html_renderer.renderer());
-    // Zig `defer parser.deinit()` — Drop handles cleanup at scope exit.
 
     // HtmlRenderer never returns JSError/JSTerminated, so OutOfMemory is the only possible error.
     match parser.process_doc() {
@@ -366,9 +357,6 @@ pub fn render_with_renderer<'a>(
     let input = helpers::skip_utf8_bom(text);
 
     let mut p = Parser::init(input, flags, rend);
-    // Zig `defer p.deinit()` — Drop.
 
     p.process_doc()
 }
-
-// ported from: src/md/parser.zig
diff --git a/src/md/ref_defs.rs b/src/md/ref_defs.rs
index ee69dac29d9..b6c0c2e18ff 100644
--- a/src/md/ref_defs.rs
+++ b/src/md/ref_defs.rs
@@ -17,8 +17,6 @@ pub struct RefDef {
     pub title: Box<[u8]>, // raw title (slice of source)
 }
 
-// PORT NOTE: Zig anonymous return structs `?struct { ... }` are mapped to small
-// named structs borrowing from the `text` parameter (BORROW_PARAM class).
 pub struct ParsedRefDef<'a> {
     pub end_pos: usize,
     pub label: &'a [u8],
@@ -41,8 +39,6 @@ impl Parser<'_> {
     /// strip leading/trailing whitespace, case-fold.
     pub fn normalize_label(&mut self, raw: &[u8]) -> Vec<u8> {
         // Collapse whitespace and apply Unicode case folding (per CommonMark §6.7)
-        // PORT NOTE: Zig returned `raw` on alloc failure; Rust Vec aborts on OOM, so
-        // the `catch return raw` paths are dropped.
         let mut result: Vec<u8> = Vec::new();
         let mut in_ws = true; // skip leading whitespace
         let mut i: usize = 0;
@@ -88,8 +84,7 @@ impl Parser<'_> {
     }
 
     /// Look up a reference definition by label (case-insensitive, whitespace-normalized).
-    // PORT NOTE: returns `Option<&RefDef>` instead of by-value copy; Zig RefDef was
-    // three borrowed slices (Copy), Rust RefDef owns its buffers.
+    // Returns `Option<&RefDef>` instead of a by-value copy: RefDef owns its buffers.
     pub fn lookup_ref_def(&mut self, raw_label: &[u8]) -> Option<&RefDef> {
         if raw_label.is_empty() || self.ref_defs.is_empty() {
             return None;
@@ -339,10 +334,9 @@ impl Parser<'_> {
 
     pub fn build_ref_def_hashtable(&mut self) -> Result<(), AllocError> {
         let mut off: usize = 0;
-        // PORT NOTE: reshaped for borrowck — take a raw pointer to block_bytes so we
-        // can call &mut self methods (normalize_label, parse_ref_def via self.buffer)
-        // while iterating the byte buffer. The Zig code mutates headers in-place via
-        // pointer casts; we preserve that with raw pointer arithmetic.
+        // Take a raw pointer to block_bytes so we can call &mut self methods
+        // (normalize_label, parse_ref_def via self.buffer) while iterating the
+        // byte buffer. Headers are mutated in-place via raw pointer arithmetic.
         let bytes_ptr = self.block_bytes.as_mut_ptr();
         let bytes_len = self.block_bytes.len();
 
@@ -404,8 +398,8 @@ impl Parser<'_> {
                     .extend_from_slice(&self.text[vline.beg as usize..vline.end as usize]);
             }
 
-            // PORT NOTE: reshaped for borrowck — move merged buffer out of self so
-            // parse_ref_def/normalize_label can borrow &self/&mut self.
+            // Move the merged buffer out of self so parse_ref_def/normalize_label
+            // can borrow &self/&mut self.
             let merged = core::mem::take(&mut self.buffer);
             let mut pos: usize = 0;
             let mut lines_consumed: u32 = 0;
@@ -432,7 +426,6 @@ impl Parser<'_> {
                         dest: dest_dupe,
                         title: title_dupe,
                     });
-                    // PERF(port): was assume_capacity / arena alloc — profile if hot.
                 }
 
                 // Count how many newlines were consumed to track lines
@@ -496,5 +489,3 @@ impl Parser<'_> {
         Ok(())
     }
 }
-
-// ported from: src/md/ref_defs.zig
diff --git a/src/md/render_blocks.rs b/src/md/render_blocks.rs
index fe8e624b8e0..e5cb3687d1b 100644
--- a/src/md/render_blocks.rs
+++ b/src/md/render_blocks.rs
@@ -157,11 +157,9 @@ impl Parser<'_> {
                                 && ci + 1 < cell_content.len()
                                 && cell_content[ci + 1] == b'|'
                             {
-                                // PERF(port): was appendAssumeCapacity
                                 buf.push(b'|');
                                 ci += 2;
                             } else {
-                                // PERF(port): was appendAssumeCapacity
                                 buf.push(cell_content[ci]);
                                 ci += 1;
                             }
@@ -210,5 +208,3 @@ impl Parser<'_> {
         Ok(())
     }
 }
-
-// ported from: src/md/render_blocks.zig
diff --git a/src/md/root.rs b/src/md/root.rs
index 61b29fee847..b3869be0499 100644
--- a/src/md/root.rs
+++ b/src/md/root.rs
@@ -69,8 +69,7 @@ impl Default for Options {
 }
 
 impl Options {
-    // Private base (all-false) used for struct-update in the presets below,
-    // mirroring Zig's field-default semantics for `.{ .field = ... }`.
+    // Private base (all-false) used for struct-update in the presets below.
     const NONE: Self = Self {
         tables: false,
         strikethrough: false,
@@ -153,8 +152,7 @@ impl Options {
         }
     }
 
-    /// `(snake_case, camelCase, setter)` for every bool field — replaces the
-    /// Zig comptime `@typeInfo(Options).@"struct".fields` reflection loop in
+    /// `(snake_case, camelCase, setter)` for every bool field — used by
     /// `Bun.markdown`'s option parser.
     pub const BOOL_FIELD_SETTERS: &'static [(
         &'static str,
@@ -246,5 +244,3 @@ pub use ansi::Theme as AnsiTheme;
 pub use ansi::detect_kitty_graphics;
 pub use ansi::detect_light_background;
 pub use ansi::render_to_ansi;
-
-// ported from: src/md/root.zig
diff --git a/src/md/types.rs b/src/md/types.rs
index 5d082a6f6c9..6d9127dee96 100644
--- a/src/md/types.rs
+++ b/src/md/types.rs
@@ -1,4 +1,5 @@
-// TODO(port): bun_jsc::JsResult missing from lower-tier stub surface — local alias.
+// The md crate sits below `bun_jsc` in the layering, so `bun_jsc::JsResult`
+// is unreachable here; this local alias plays the same role.
 pub type JsResult<T> = Result<T, crate::parser::ParserError>;
 
 /// Offset into the input document.
@@ -133,15 +134,14 @@ pub struct WikilinkDetail<'a> {
 
 /// Renderer interface. The parser calls these methods to produce output.
 //
-// PORT NOTE: Zig's `*anyopaque + *const VTable` manual fat-pointer is collapsed
-// into `&mut dyn RendererImpl`. LIFETIMES.tsv classified `ptr` as
+// A `&mut dyn RendererImpl` fat pointer. LIFETIMES.tsv classified `ptr` as
 // `&'a mut dyn RendererImpl` (BORROW_PARAM) and `vtable` as `&'static VTable`
 // (STATIC); the trait object encodes both.
 pub struct Renderer<'a> {
     pub ptr: &'a mut dyn RendererImpl,
 }
 
-/// Trait backing the `Renderer` fat pointer (was Zig `Renderer.VTable`).
+/// Trait backing the `Renderer` fat pointer.
 pub trait RendererImpl {
     fn enter_block(&mut self, block_type: BlockType, data: u32, flags: u32) -> JsResult<()>;
     fn leave_block(&mut self, block_type: BlockType, data: u32) -> JsResult<()>;
@@ -174,8 +174,7 @@ impl<'a> Renderer<'a> {
 }
 
 /// Detail data for span events (links, images, wikilinks).
-// TODO(port): lifetime — href/title borrow from the source text; could thread
-// an arena `'bump` lifetime instead.
+/// `href`/`title` borrow from the source text.
 #[derive(Copy, Clone)]
 pub struct SpanDetail<'a> {
     pub href: &'a [u8],
@@ -227,7 +226,7 @@ impl<'a> SpanDetail<'a> {
 
 /// An attribute is a string that may contain embedded entities.
 /// The text is split into substrings, each with a type (normal or entity).
-// TODO(port): lifetime — substr slices borrow from parser-owned buffers.
+/// The substr slices borrow from parser-owned buffers.
 #[derive(Copy, Clone)]
 pub struct Attribute<'a> {
     /// Slices into the source text, one per substring.
@@ -235,8 +234,8 @@ pub struct Attribute<'a> {
     pub substr_types: &'a [SubstrType],
 }
 
-// PORT NOTE: Zig nests `SubstrType`/`SubstrOffset` inside `Attribute`; Rust has
-// no nested type defs in structs, so they are hoisted to module scope.
+// `SubstrType`/`SubstrOffset` belong conceptually to `Attribute` but Rust has
+// no nested type defs in structs, so they live at module scope.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum SubstrType {
@@ -327,8 +326,8 @@ pub struct Container {
 }
 
 /// Block flags stored in MD_BLOCK.
-// PORT NOTE: Zig `packed struct(u32)` with bool fields + u28 padding. Not every
-// field is `bool` (padding), so per PORTING.md this is a transparent newtype
+// Packed u32 with bool bits + 28 bits of padding. Not every
+// field is `bool` (padding), so this is a transparent newtype
 // with manual shift accessors rather than `bitflags!`.
 #[repr(transparent)]
 #[derive(Copy, Clone, Default, Eq, PartialEq)]
@@ -433,7 +432,7 @@ pub struct Flags {
 }
 
 impl Flags {
-    // Private base mirroring the Zig field defaults so the named presets below
+    // Private base of field defaults so the named presets below
     // can use struct-update syntax in const context.
     const DEFAULTS: Flags = Flags {
         collapse_whitespace: false,
@@ -564,5 +563,3 @@ pub fn task_mark_from_data(data: u32) -> u8 {
 pub fn is_task_checked(task_mark: u8) -> bool {
     task_mark != 0 && task_mark != b' '
 }
-
-// ported from: src/md/types.zig
diff --git a/src/md/unicode.rs b/src/md/unicode.rs
index 2b30ff4ba9d..76c9bb00147 100644
--- a/src/md/unicode.rs
+++ b/src/md/unicode.rs
@@ -1,6 +1,3 @@
-// PORT NOTE: Zig `u21` (codepoint) → `u32`; Zig `u2` (count) → `u8`.
-// Rust has no arbitrary-bit-width integers; the next natural width is used.
-
 pub(crate) struct FoldInfo {
     pub codepoints: [u32; 3],
     pub n_codepoints: u8,
@@ -350,7 +347,6 @@ fn case_fold_from_map<const N: u8>(
     };
 
     // Copy the base codepoints from the data table.
-    // PERF(port): was `inline for` (compile-time unrolled) — profile if hot.
     result.codepoints[..(N as usize)]
         .copy_from_slice(&data[data_offset..data_offset + (N as usize)]);
 
@@ -525,5 +521,3 @@ mod tests {
         assert_eq!(1u8, info.n_codepoints);
     }
 }
-
-// ported from: src/md/unicode.zig
diff --git a/src/mimalloc_sys/mimalloc.rs b/src/mimalloc_sys/mimalloc.rs
index 8565dc4ee6b..ee099698a16 100644
--- a/src/mimalloc_sys/mimalloc.rs
+++ b/src/mimalloc_sys/mimalloc.rs
@@ -2,9 +2,9 @@
 
 use core::ffi::{c_char, c_int, c_long, c_ulong, c_ulonglong, c_ushort, c_void};
 
-// PORT NOTE: `Option` below is the mimalloc `mi_option_t` enum (kept verbatim
-// from the Zig). Nullable fn-pointer params therefore spell out
-// `core::option::Option<...>` to avoid the shadow.
+// `Option` below is the mimalloc `mi_option_t` enum, which shadows
+// `core::option::Option` in this module. Nullable fn-pointer params therefore
+// spell out `core::option::Option<...>` to avoid the shadow.
 
 unsafe extern "C" {
     /// No preconditions; returns null on failure.
@@ -282,8 +282,8 @@ bun_opaque::opaque_ffi! {
     /// `THeap` directly and skip that lookup.
     ///
     /// **Do not cache across `Send`**: a `mi_theap_t*` is per-OS-thread, while
-    /// the `mi_heap_t*` it belongs to is `Send`. Zig parity is plain
-    /// `mi_heap_*`; see `MimallocArena.rs` PERF NOTE. The entry points below
+    /// the `mi_heap_t*` it belongs to is `Send`.
+    /// See `MimallocArena.rs` PERF NOTE. The entry points below
     /// are `#[deprecated]` for this reason.
     pub struct THeap;
 }
@@ -386,7 +386,7 @@ unsafe extern "C" {
     pub fn mi_thread_set_in_threadpool();
 }
 
-// PORT NOTE: kept name `Option` to match Zig; shadows `core::option::Option` in
+// Named `Option` after mimalloc's `mi_option_t`; shadows `core::option::Option` in
 // this module (callers use `mimalloc::Option`). `enum(c_uint)` → `#[repr(u32)]`
 // (c_uint == u32 on all Bun targets; `#[repr(C)]` would give a signed c_int discriminant).
 #[repr(u32)]
@@ -588,5 +588,3 @@ unsafe extern "C" {
         arena_id: mi_arena_id_t,
     ) -> *mut Heap;
 }
-
-// ported from: src/mimalloc_sys/mimalloc.zig
diff --git a/src/opaque/lib.rs b/src/opaque/lib.rs
index b317b628d89..46a32c0d6b4 100644
--- a/src/opaque/lib.rs
+++ b/src/opaque/lib.rs
@@ -345,17 +345,17 @@ pub unsafe fn opaque_deref_mut_nn<'a, T>(p: *mut T) -> &'a mut T {
 /// `core`-only FFI slice/string primitives shared between `bun_core::ffi` and
 /// the freestanding `bun_shim_impl` PE. Lives here (not `bun_core`) because
 /// `bun_core` carries `#[no_mangle]` C-ABI exports that become unsatisfiable
-/// link roots in a `#![no_std]`/`no_main` binary; this crate has none. Mirrors
-/// Zig `std.mem.{len,span}` / `bun.sliceTo`, which both consumers re-spelled
-/// verbatim before this single audited copy existed.
+/// link roots in a `#![no_std]`/`no_main` binary; this crate has none. Both
+/// consumers re-spelled these primitives verbatim before this single audited
+/// copy existed.
 pub mod ffi {
-    /// `std.mem.len` for `[*:0]const u16` — count u16 code units up to (and
+    /// Count u16 code units up to (and
     /// excluding) the first NUL. Single audited funnel for the hand-rolled
     /// `while *p.add(n) != 0 { n += 1 }` loop that appeared at every
     /// `LPCWSTR` / `char16_t*` ingestion point (Windows path APIs, N-API
     /// `napi_create_string_utf16`, libarchive `_w` accessors, env-block
     /// scan). Adds a `debug_assert!(!p.is_null())` — same precondition as
-    /// `CStr::from_ptr` and Zig `std.mem.len([*:0]const u16)`.
+    /// `CStr::from_ptr`.
     ///
     /// # Safety
     /// `p` must be non-null and point to a NUL-terminated u16 sequence
@@ -372,8 +372,7 @@ pub mod ffi {
     }
 
     /// UTF-16 analogue of `cstr_bytes`: scan to NUL and borrow the code units
-    /// as a `&[u16]`. Dominant shape at call sites (Zig
-    /// `std.mem.span([*:0]const u16)` port).
+    /// as a `&[u16]`. Dominant shape at call sites.
     ///
     /// # Safety
     /// Same contract as [`wcslen`]; the returned borrow must not outlive the
diff --git a/src/options_types/bundle_enums.rs b/src/options_types/bundle_enums.rs
index 3029592afdd..710eb7049e0 100644
--- a/src/options_types/bundle_enums.rs
+++ b/src/options_types/bundle_enums.rs
@@ -1,4 +1,4 @@
-//! Pure enum/struct option types extracted from `bundler/options.zig` so
+//! Pure enum/struct bundler option types, kept here so
 //! `cli/` and other tiers can reference them without depending on `bundler/`.
 //! Aliased back at original locations — call sites unchanged.
 //!
@@ -63,12 +63,10 @@ impl Format {
         b"internal_bake_dev" => Format::InternalBakeDev,
     };
 
-    // `fromJS` alias to `bundler_jsc/options_jsc.zig` deleted — see PORTING.md
-    // (`to_js`/`from_js` live as extension-trait methods in the `*_jsc` crate).
+    // `to_js`/`from_js` live as extension-trait methods in the `*_jsc` crate.
 
     pub fn from_string(slice: &[u8]) -> Option<Format> {
-        // Zig: Map.getWithEql(slice, bun.strings.eqlComptime) — eqlComptime is
-        // exact byte equality, which is phf's default lookup.
+        // Exact byte equality, which is phf's default lookup.
         Self::MAP.get(slice).copied()
     }
 }
@@ -95,8 +93,6 @@ pub type BundlePackageMap = bun_collections::StringArrayHashMap<BundlePackage>;
 
 // ─── move-in: TYPE_ONLY from bun_bundler::options ─────────────────────────
 
-/// `bundler/options.zig:1815` `BundleOptions.ForceNodeEnv`.
-///
 /// Set by the process environment to override the JSX configuration. When
 /// `Unspecified`, tsconfig.json drives the choice between "react-jsx" and
 /// "react-jsx-dev-runtime".
@@ -109,7 +105,7 @@ pub enum ForceNodeEnv {
     Production,
 }
 
-/// `bundler/options.zig` `ModuleType` — package.json `"type"` field.
+/// package.json `"type"` field.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
 pub enum ModuleType {
@@ -294,7 +290,7 @@ impl ImportKindExt for bun_ast::ImportKind {
 
 // ─── move-in: TYPE_ONLY from bun_runtime::bake::framework ──────────────────────────
 
-/// `bake/bake.zig` `Framework.BuiltInModule` — virtual module backing for a
+/// Virtual module backing for a
 /// framework-declared built-in: either an import path to redirect to, or
 /// inline source code.
 #[derive(Clone, Debug)]
@@ -317,5 +313,3 @@ impl From<bun_ast::ExportsKind> for ModuleType {
         }
     }
 }
-
-// ported from: src/options_types/BundleEnums.zig
diff --git a/src/options_types/code_coverage_options.rs b/src/options_types/code_coverage_options.rs
index a20853fc289..72b13481549 100644
--- a/src/options_types/code_coverage_options.rs
+++ b/src/options_types/code_coverage_options.rs
@@ -1,8 +1,7 @@
-//! `bun test --coverage` option struct, extracted from `cli/test_command.zig`
-//! so `options_types/Context.zig` (and `cli/cli.zig` `TestOptions`) can hold
+//! `bun test --coverage` option struct, kept in `options_types/`
+//! so `Context` (and the CLI `TestOptions`) can hold
 //! it without depending on `cli/`.
 
-// move-in: TYPE_ONLY from bun_sourcemap_jsc::CodeCoverage (`sourcemap_jsc/CodeCoverage.zig` `Fraction`).
 // Lifted here so the option struct (and CLI tier) needn't depend on tier-6 sourcemap_jsc.
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub struct Fraction {
@@ -28,24 +27,21 @@ impl Default for Fraction {
 pub struct CodeCoverageOptions {
     pub skip_test_files: bool,
     pub reporters: Reporters,
-    /// Zig: `[]const u8 = "coverage"` — process-lifetime in Zig (default_allocator-backed
-    /// when populated from argv/bunfig); owned `Box` here so bunfig parsing can write a
+    /// Defaults to `"coverage"`; owned `Box` so bunfig parsing can write a
     /// heap value without leaking.
     pub reports_directory: Box<[u8]>,
     pub fractions: Fraction,
     pub ignore_sourcemap: bool,
     pub enabled: bool,
     pub fail_on_low_coverage: bool,
-    /// Zig: `[]const []const u8 = &.{}` — populated from CLI/bunfig.
+    /// Populated from CLI/bunfig.
     pub ignore_patterns: Vec<Box<[u8]>>,
 }
 
 impl Default for CodeCoverageOptions {
     fn default() -> Self {
         Self {
-            // TODO(port): Zig `!bun.Environment.allow_assert` (allow_assert = isDebug || is_canary || isTest);
-            // mapped to `!cfg!(debug_assertions)` — may want a `bun_core::Environment::ALLOW_ASSERT` const.
-            skip_test_files: !cfg!(debug_assertions),
+            skip_test_files: !bun_core::env::ALLOW_ASSERT,
             reporters: Reporters {
                 text: true,
                 lcov: false,
@@ -65,5 +61,3 @@ pub struct Reporters {
     pub text: bool,
     pub lcov: bool,
 }
-
-// ported from: src/options_types/CodeCoverageOptions.zig
diff --git a/src/options_types/command_tag.rs b/src/options_types/command_tag.rs
index 1c42bc83fe1..f667abf1fa5 100644
--- a/src/options_types/command_tag.rs
+++ b/src/options_types/command_tag.rs
@@ -3,7 +3,7 @@
 //! switch on which command is running without importing `cli/`.
 //!
 //! Heavy methods that reference `Arguments`/`HelpCommand`/`clap` (`params()`,
-//! `printHelp()`) live in `src/cli/cli.zig` as free fns; only the pure enum,
+//! `printHelp()`) live in the CLI crate as free fns; only the pure enum,
 //! `char()`, classifier predicates, and the `EnumArray` flag tables are here.
 
 use enum_map::Enum;
@@ -126,16 +126,14 @@ impl Tag {
     /// tables below can size themselves without naming the trait at every use.
     pub const COUNT: usize = <Self as Enum>::LENGTH;
 
-    // Heavy methods that pull in `Arguments` / help text live in `cli/cli.zig`.
-    // In Zig these were aliased here (`params`, `printHelp`) relying on lazy
-    // decl resolution so `options_types/` did not compile-depend on `cli/`
-    // unless invoked. Rust has no lazy decl resolution; re-exporting
+    // Heavy methods that pull in `Arguments` / help text live in the CLI crate.
+    // Re-exporting
     // `bun_runtime::cli::Command::{tag_params, tag_print_help}` here would create a
     // crate cycle (cli → options_types → cli).
 }
 
 /// `.rodata` flag table indexed by [`Tag`] discriminant. These tables cost zero
-/// init code on the startup path (matches Zig `std.EnumArray.initDefault`).
+/// init code on the startup path.
 #[repr(transparent)]
 pub struct TagTable<V: 'static>(pub [V; Tag::COUNT]);
 
@@ -208,5 +206,3 @@ pub static USES_GLOBAL_OPTIONS: TagTable<bool> = TagTable({
     a[Tag::UpdateCommand as usize] = false;
     a
 });
-
-// ported from: src/options_types/CommandTag.zig
diff --git a/src/options_types/compile_target.rs b/src/options_types/compile_target.rs
index c7869cec074..10dc55f4a0e 100644
--- a/src/options_types/compile_target.rs
+++ b/src/options_types/compile_target.rs
@@ -97,7 +97,6 @@ pub enum ParseError {
     #[error("InvalidTarget")]
     InvalidTarget,
 }
-// TODO(port): impl From<ParseError> for bun_core::Error
 
 impl CompileTarget {
     pub fn eql(&self, other: &CompileTarget) -> bool {
@@ -113,17 +112,11 @@ impl CompileTarget {
     }
 
     pub fn to_npm_registry_url<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8], bun_core::Error> {
-        // TODO(port): narrow error set
         if let Some(url) = env_var::BUN_COMPILE_TARGET_TARBALL_URL.get() {
             if strings::has_prefix(url, b"http://") || strings::has_prefix(url, b"https://") {
-                // TODO(port): lifetime — Zig returns the env var slice directly (`return url;`),
-                // which is not tied to `buf`. Could change the return type to allow returning a
-                // non-buf slice (e.g. Cow<'_, [u8]>). For now copy into buf without truncation.
-                if url.len() > buf.len() {
-                    return Err(bun_core::err!("BufferTooSmall"));
-                }
-                buf[..url.len()].copy_from_slice(url);
-                return Ok(&buf[..url.len()]);
+                // The env var slice is `&'static [u8]`,
+                // which outlives `'a`, so return it directly instead of copying into `buf`.
+                return Ok(url);
             }
         }
 
@@ -135,15 +128,12 @@ impl CompileTarget {
         buf: &'a mut [u8],
         registry_url: &[u8],
     ) -> Result<&'a [u8], bun_core::Error> {
-        // TODO(port): narrow error set
         // Validate the target is supported before building URL
         if !self.is_supported() {
             return Err(bun_core::err!("UnsupportedTarget"));
         }
 
-        // PERF(port): was comptime monomorphization (inline else over os/arch/libc/baseline
-        // building a comptime format string) — profile. Runtime concat is fine
-        // for a one-shot URL build.
+        // Runtime concat is fine for a one-shot URL build.
         let os = self.os.npm_name().as_bytes();
         let arch = self.arch.npm_name();
         let libc = self.libc.npm_name();
@@ -400,8 +390,6 @@ impl CompileTarget {
                 } else if strings::contains(input, b"wasm") {
                     bun_core::err_generic!("invalid target, WebAssembly is not supported. Sorry!");
                 } else if strings::contains(input, b"v") {
-                    // PORT NOTE: Zig used a comptime-concat format string with VERSION_STRING.
-                    // `format_args!` requires a literal; pass the version as a runtime arg.
                     bun_core::err_generic!(
                         "Please pass a complete version number to --target. For example, --target=bun-v{}",
                         Environment::VERSION_STRING,
@@ -424,8 +412,7 @@ impl CompileTarget {
     }
 
     pub fn define_values(&self) -> &'static [&'static [u8]] {
-        // PERF(port): was comptime monomorphization (inline else over os/arch/libc returning
-        // anonymous struct const). Could generate static tables via macro_rules! or
+        // Could generate static tables via macro_rules! or
         // const_format::concatcp! over OperatingSystem::name_string().
         macro_rules! table {
             ($platform:literal, $arch:literal) => {{
@@ -489,5 +476,3 @@ impl fmt::Display for CompileTarget {
 
 // `fromJS` / `fromSlice` re-exports from bundler_jsc deleted — see PORTING.md §Idiom map.
 // In Rust these are extension-trait methods living in bun_bundler_jsc.
-
-// ported from: src/options_types/CompileTarget.zig
diff --git a/src/options_types/context.rs b/src/options_types/context.rs
index 5e7a5b25eb0..4d39c7e861b 100644
--- a/src/options_types/context.rs
+++ b/src/options_types/context.rs
@@ -1,11 +1,9 @@
-//! `Command.ContextData` and its option-carrying nested structs, lifted out of
-//! `cli/cli.zig` so subsystems (install, bundler, bake, shell) can reference
+//! `Command.ContextData` and its option-carrying nested structs, kept out of
+//! the CLI crate so subsystems (install, bundler, bake, shell) can reference
 //! the parsed-options shape without importing the CLI itself.
 //!
 //! `create()` (which calls `Arguments.parse`) and the `global_cli_ctx`/
-//! `context_data` storage stay in `cli.rs`; they are forward-aliased onto
-//! `ContextData` below so call sites that write `Command::ContextData::create()`
-//! keep working.
+//! `context_data` storage stay in `cli.rs`.
 
 use crate::schema::api;
 use bun_collections::ArrayHashMap;
@@ -16,21 +14,18 @@ use crate::compile_target::CompileTarget;
 use crate::global_cache::GlobalCache;
 use crate::offline_mode::OfflineMode;
 
-// TODO(port): every `[]const u8` / `[]const []const u8` struct field below is a
-// proc-lifetime CLI string (no `deinit`, populated once from argv/bunfig and
-// never freed). Ported as `Box<[u8]>` / `Vec<Box<[u8]>>` for now; may retype to
-// `&'static [u8]` once the CLI parser leaks into a bump arena.
+// Every `Box<[u8]>` / `Vec<Box<[u8]>>` struct field below is a proc-lifetime
+// CLI string: populated once from argv/bunfig during startup and never freed.
 
 pub struct ContextData {
     pub start_time: i128,
     pub args: api::TransformOptions,
-    /// Zig: `log: *Log`. Raw pointer (not `&mut`) so `Default` works and so the
+    /// Raw pointer (not `&mut`) so `Default` works and so the
     /// process-global `CONTEXT_DATA` static can be zero-initialized before
     /// `create_context_data()` writes the real `&mut Log` into it.
     // SAFETY: written exactly once in single-threaded CLI startup; thereafter
     // always non-null for the process lifetime. Callers deref via `ctx.log()`.
     pub log: *mut bun_ast::Log,
-    // PORT NOTE: `std.mem.Allocator param` deleted (global mimalloc).
     pub positionals: Vec<Box<[u8]>>,
     pub passthrough: Vec<Box<[u8]>>,
     pub install: Option<Box<api::BunInstall>>,
@@ -59,10 +54,10 @@ impl Default for ContextData {
     // `CompileTarget` / `CpuProf` …) sampling 31× across ≈10 distinct 4 KB
     // r-xp pages — each nested `Default` impl landed in its own CGU, so the
     // single call from `write_context_no_parse` faulted in ~40 KB of scattered
-    // `.text`. The Zig spec is `std.mem.zeroes(Context)` (one comptime blob).
+    // `.text`.
     //
-    // A literal `unsafe { core::mem::zeroed() }` would match Zig but is
-    // **unsound** in Rust: `Vec<T>` / `Box<[u8]>` carry a `NonNull` pointer
+    // A literal `unsafe { core::mem::zeroed() }` is
+    // **unsound**: `Vec<T>` / `Box<[u8]>` carry a `NonNull` pointer
     // (validity invariant — null is immediate UB regardless of len). Instead,
     // every `Default` impl in this module is `#[inline(always)]` so the entire
     // recursive chain folds into the one `write_context_no_parse` call site
@@ -97,14 +92,14 @@ impl ContextData {
     /// Deref the process-lifetime `*mut Log` set in `create_context_data()`.
     ///
     /// Takes `&mut self` (not `&self`) so the borrow checker ties the returned
-    /// `&mut Log` to an exclusive borrow of the `ContextData` — Zig's `*Log`
-    /// freely aliases, but in Rust a `&self -> &mut Log` accessor would let two
+    /// `&mut Log` to an exclusive borrow of the `ContextData` — a
+    /// `&self -> &mut Log` accessor would let two
     /// live `&mut Log` overlap (UB). Note this is *necessary but not
     /// sufficient*: the same `*Log` is borrowed (not owned) from the CLI
     /// caller and is also fanned out to and stored by the transpiler/bundler
-    /// (`bundler/options.zig`), the install pipeline (`install/migration.zig`,
-    /// `install/PackageManagerOptions.zig`), JSON parsing
-    /// (`interchange/json.zig`), etc. Exclusive `self` does NOT exclude those
+    /// options, the install pipeline (migration,
+    /// `PackageManagerOptions`), JSON parsing,
+    /// etc. Exclusive `self` does NOT exclude those
     /// aliases — see `# Safety` for the full precondition.
     ///
     /// # Safety
@@ -182,22 +177,16 @@ impl ContextData {
         // live `&mut Log` overlapping this.
         unsafe { &*self.log }
     }
-
-    /// `Arguments.parse` lives in `cli/`; forward-aliased so
-    /// `Command::ContextData::create(...)` keeps working.
-    // TODO(port): Zig was `pub const create = bun.cli.Command.createContextData;`
-    // — Rust cannot re-export an associated fn; TODO(port): add a thin
-    // delegating `pub fn create(...)` here once `bun_cli` exists, or invert the
-    // alias direction (cli re-exports this type).
-    pub const CREATE_SEE_CLI: () = ();
 }
 
+// `create()` lives in the CLI crate
+// (`bun_runtime::cli::command::create_context_data`), which depends on this
+// crate — a delegating fn here would invert the dependency.
+
 pub struct BundlerOptions {
     pub outdir: Box<[u8]>,
     pub outfile: Box<[u8]>,
-    // TODO(port): was `[:0]const u8` (NUL-terminated); decide owned ZStr repr.
     pub metafile: Box<[u8]>,
-    // TODO(port): was `[:0]const u8` (NUL-terminated); decide owned ZStr repr.
     pub metafile_md: Box<[u8]>,
     pub root_dir: Box<[u8]>,
     pub public_path: Box<[u8]>,
@@ -294,9 +283,6 @@ impl Default for BundlerOptions {
 }
 
 pub type Context<'a> = &'a mut ContextData;
-// TODO(port): Zig `*ContextData` is passed everywhere as a long-lived handle;
-// the borrow lifetime above may need to become `*mut ContextData` at call sites
-// that re-enter the global ctx.
 
 // ──────────────────────────────────────────────────────────────────────────
 // Process-global CLI context handle.
@@ -392,7 +378,7 @@ pub enum MacroOptions {
     Map(MacroMap),
 }
 
-/// Re-declared from `resolver/package_json.zig` (plain hashmap aliases) so this
+/// Plain hashmap aliases re-declared here so this
 /// file does not depend on `resolver/`.
 pub type MacroImportReplacementMap = ArrayHashMap<Box<[u8]>, Box<[u8]>>;
 pub type MacroMap = ArrayHashMap<Box<[u8]>, MacroImportReplacementMap>;
@@ -485,7 +471,7 @@ impl Default for TestOptions {
     #[inline(always)]
     fn default() -> Self {
         Self {
-            // 5 * std.time.ms_per_s
+            // 5 seconds
             default_timeout_ms: 5 * 1000,
             update_snapshots: false,
             repeat_count: 0,
@@ -626,5 +612,3 @@ impl Default for RuntimeOptions {
         }
     }
 }
-
-// ported from: src/options_types/Context.zig
diff --git a/src/options_types/global_cache.rs b/src/options_types/global_cache.rs
index e5a60999461..667a1d02b4e 100644
--- a/src/options_types/global_cache.rs
+++ b/src/options_types/global_cache.rs
@@ -57,5 +57,3 @@ impl GlobalCache {
         )
     }
 }
-
-// ported from: src/options_types/GlobalCache.zig
diff --git a/src/options_types/jsx.rs b/src/options_types/jsx.rs
index 7af24aac3fd..af52257b933 100644
--- a/src/options_types/jsx.rs
+++ b/src/options_types/jsx.rs
@@ -1,5 +1,5 @@
-//! Port of `bundler/options.zig` `JSX` namespace (`Runtime`, `ImportSource`,
-//! `Pragma`, `RuntimeDevelopmentPair`, `RuntimeMap`, `Defaults`).
+//! JSX options (`Runtime`, `ImportSource`, `Pragma`, `RuntimeDevelopmentPair`,
+//! `RuntimeMap`, `Defaults`).
 //!
 //! Canonical home (D042): previously triplicated across
 //! `bundler/options.rs`, `js_parser/parser.rs`, and
@@ -12,11 +12,9 @@ use crate::schema::api;
 use bun_core::strings;
 use std::borrow::Cow;
 
-/// Port of `options.JSX.Runtime` (options.zig:1359 — `pub const Runtime =
-/// api.JsxRuntime;`). 4-state including `_None` so `Pragma.runtime` preserves
-/// the zero value when an `api.Jsx` arrives with `runtime == _none` (Zig
-/// options.zig:1344 assigns it directly). `#[default]` is `Automatic` (Zig:
-/// `runtime: api.Api.JsxRuntime = .automatic`).
+/// 4-state including `_None` so `Pragma.runtime` preserves the zero value
+/// when an `api.Jsx` arrives with `runtime == _none`. `#[default]` is
+/// `Automatic`.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
 pub enum Runtime {
@@ -45,7 +43,6 @@ pub struct RuntimeDevelopmentPair {
     pub development: Option<bool>,
 }
 
-/// Port of `options.JSX.RuntimeMap` (`bun.ComptimeStringMap`, options.zig:1179).
 pub static RUNTIME_MAP: phf::Map<&'static [u8], RuntimeDevelopmentPair> = phf::phf_map! {
     b"classic" => RuntimeDevelopmentPair { runtime: Runtime::Classic, development: None },
     b"automatic" => RuntimeDevelopmentPair { runtime: Runtime::Automatic, development: Some(true) },
@@ -54,15 +51,13 @@ pub static RUNTIME_MAP: phf::Map<&'static [u8], RuntimeDevelopmentPair> = phf::p
     b"react-jsxdev" => RuntimeDevelopmentPair { runtime: Runtime::Automatic, development: Some(true) },
 };
 
-/// Port of Zig `[]const string` for `Pragma.{factory,fragment}`.
+/// Member-expression list for `Pragma.{factory,fragment}`.
 ///
-/// In Zig (options.zig:1193) the field is a fat slice that, by default, points
-/// at the static `Defaults.Factory` array — copying the struct is a 16-byte
-/// pointer copy with **zero** allocations. The original Rust port boxed every
-/// element (`Box<[Box<[u8]>]>`), making `Pragma::default()` / `Clone` cost ~10
-/// heap allocations and dominating mimalloc samples in the resolver hot path.
+/// Boxing every element (`Box<[Box<[u8]>]>`) made `Pragma::default()` /
+/// `Clone` cost ~10 heap allocations and dominated mimalloc samples in the
+/// resolver hot path.
 ///
-/// `MemberList` restores Zig's cost model: the overwhelmingly-common case
+/// `MemberList` keeps default+clone cheap: the overwhelmingly-common case
 /// (`Static`) borrows a `&'static [&'static [u8]]` so default+clone are a
 /// pointer copy; only an explicit override (`/** @jsx foo */`, tsconfig
 /// `jsxFactory`, …) materialises an `Owned` boxed slice.
@@ -143,10 +138,8 @@ impl<'a> Iterator for MemberListIter<'a> {
 
 impl<'a> ExactSizeIterator for MemberListIter<'a> {}
 
-/// Port of `options.JSX.ImportSource` (options.zig:1208).
-///
-/// Zig stores `[]const u8` borrowing `Defaults.ImportSourceDev`/`ImportSource`;
-/// `Cow::Borrowed` matches that (zero-alloc default/clone), `Cow::Owned` covers
+/// `Cow::Borrowed` keeps the default/clone path zero-alloc (borrowing
+/// `defaults::IMPORT_SOURCE_DEV`/`IMPORT_SOURCE`); `Cow::Owned` covers
 /// the `set_import_source()` override path.
 #[derive(Debug, Clone)]
 pub struct ImportSource {
@@ -164,18 +157,14 @@ impl Default for ImportSource {
     }
 }
 
-/// Port of `options.JSX.Pragma` (options.zig:1192).
-///
-/// All string fields default to borrowed `'static` data (matching Zig's
-/// `Defaults.*` slice initialisers), so `Pragma::default()` and the derived
+/// All string fields default to borrowed `'static` data
+/// (the `defaults::*` slices), so `Pragma::default()` and the derived
 /// `Clone` perform **zero** heap allocations in the common case. Hot callers
 /// — `RuntimeTranspilerStore` (per transpiled module) and `Resolver`
 /// (per resolve) — clone this struct on every operation.
 #[derive(Debug, Clone)]
 pub struct Pragma {
     // these need to be arrays
-    // Zig: `[]const string` — either the static `Defaults.Factory` or a
-    // heap slice from `memberListToComponentsIfDifferent`.
     pub factory: MemberList,
     pub fragment: MemberList,
     pub runtime: Runtime,
@@ -215,9 +204,8 @@ impl Default for Pragma {
 
 impl Pragma {
     pub fn hash_for_runtime_transpiler(&self, hasher: &mut bun_wyhash::Wyhash) {
-        // PORT NOTE: spec options.zig:1213 takes `*std.hash.Wyhash`, which is the
-        // algorithm behind `bun.hash` — distinct from `bun.Wyhash11`. Using
-        // `Wyhash11` would yield a different cache key than the Zig path.
+        // Uses `bun_wyhash::Wyhash` (the algorithm behind `bun.hash`) — distinct
+        // from `Wyhash11`, which would yield a different cache key.
         for factory in self.factory.iter() {
             hasher.update(factory);
         }
@@ -267,10 +255,8 @@ impl Pragma {
             || &*self.package_name == b"@emotion/react"
     }
 
-    /// Port of `options.JSX.Pragma.setImportSource` (Zig wraps
-    /// `strings.concatIfNeeded`). When `package_name` is the default
-    /// `"react"`, this borrows the interned `defaults::IMPORT_SOURCE*` —
-    /// matching Zig's interned-string fast path with zero allocations.
+    /// When `package_name` is the default `"react"`, this borrows the
+    /// interned `defaults::IMPORT_SOURCE*` with zero allocations.
     pub fn set_import_source(&mut self) {
         self.import_source.development = Self::concat_or_interned(
             &self.package_name,
@@ -373,7 +359,7 @@ impl Pragma {
     }
 }
 
-/// Port of `options.JSX.Defaults` (options.zig).
+/// Default JSX factory/fragment/import-source values.
 pub mod defaults {
     pub const FACTORY: &[&[u8]] = &[b"React", b"createElement"];
     pub const FRAGMENT: &[&[u8]] = &[b"React", b"Fragment"];
diff --git a/src/options_types/offline_mode.rs b/src/options_types/offline_mode.rs
index b238b722184..b3f3c7af78c 100644
--- a/src/options_types/offline_mode.rs
+++ b/src/options_types/offline_mode.rs
@@ -11,5 +11,3 @@ pub static PREFER: phf::Map<&'static [u8], OfflineMode> = phf::phf_map! {
     b"latest" => OfflineMode::Latest,
     b"online" => OfflineMode::Online,
 };
-
-// ported from: src/options_types/OfflineMode.zig
diff --git a/src/options_types/schema.rs b/src/options_types/schema.rs
index 8a798fd5150..e5562dc09cf 100644
--- a/src/options_types/schema.rs
+++ b/src/options_types/schema.rs
@@ -1,11 +1,10 @@
 // GENERATED: re-run peechy (src/api/schema.peechy) with .rs output
-// source: src/options_types/schema.zig (3224 lines)
 // PORT STATUS: skipped — generated file (see PORTING.md §Don't translate)
 //
 // Minimal hand-stubbed `api` namespace so Context.rs / BundleEnums.rs
 // struct fields type-check. Full body arrives when peechy emits .rs.
 
-/// Port of `schema.Writer(WritableStream)` (schema.zig:169) specialised to a
+/// Schema writer specialised to a
 /// `Vec<u8>` sink — the only instantiation reachable from Rust today
 /// (`js_parser::runtime::Base64FallbackMessage::fmt`). The full generic shape
 /// arrives with the peechy-generated body.
@@ -26,7 +25,7 @@ impl<'a> Writer<'a> {
     pub fn write_byte(&mut self, byte: u8) {
         self.writable.push(byte);
     }
-    /// Zig: `writeInt` — `std.mem.asBytes(&int)` is native-endian raw bytes.
+    /// Writes the int's native-endian raw bytes.
     #[inline]
     pub fn write_int<I: Copy>(&mut self, int: I) {
         // SAFETY: `int` is a live stack local, so `&raw const int` is valid for reads of
@@ -45,7 +44,7 @@ impl<'a> Writer<'a> {
     pub fn write_enum<E: Copy>(&mut self, val: E) {
         self.write_int(val);
     }
-    /// Zig: `writeArray(u8, slice)` — length-prefixed byte slice.
+    /// Length-prefixed byte slice.
     #[inline]
     pub fn write_array_u8(&mut self, slice: &[u8]) {
         self.write_int(u32::try_from(slice.len()).unwrap());
@@ -58,10 +57,10 @@ impl<'a> Writer<'a> {
 }
 
 pub mod api {
-    /// schema.zig:1172 — canonical definition lives in bun_dotenv (lower tier).
+    /// Canonical definition lives in bun_dotenv (lower tier).
     pub use bun_dotenv::DotEnvBehavior;
 
-    /// schema.zig:711 — `enum(u8)` (open). Kept closed.
+    /// Open `enum(u8)` in the wire schema. Kept closed.
     /// Variants PascalCased to match the only downstream writer
     /// (`runtime/cli/Arguments.rs` → `api::ResolveMode::Lazy`).
     #[repr(u8)]
@@ -75,7 +74,7 @@ pub mod api {
         Bundle = 4,
     }
 
-    /// schema.zig:2295 — `enum(u32)` (open). Kept closed.
+    /// Open `enum(u32)` in the wire schema. Kept closed.
     /// PascalCased: `bun_ast::Kind::to_api` matches on `Err`/`Warn`/`Note`/`Debug`.
     #[repr(u32)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
@@ -89,7 +88,7 @@ pub mod api {
         Debug = 5,
     }
 
-    /// schema.zig:1622 — `enum(u8)` (closed; not a peechy `smol`).
+    /// `enum(u8)` (closed; not a peechy `smol`).
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum UnhandledRejections {
@@ -104,7 +103,7 @@ pub mod api {
 
     impl UnhandledRejections {
         /// `UnhandledRejections.map` — `bun.ComptimeStringMap` → `phf::Map`.
-        /// Note: Zig deliberately omits `"bun"` (it's the implicit default).
+        /// Note: deliberately omits `"bun"` (it's the implicit default).
         pub const MAP: phf::Map<&'static [u8], UnhandledRejections> = phf::phf_map! {
             b"strict" => UnhandledRejections::Strict,
             b"throw" => UnhandledRejections::Throw,
@@ -114,10 +113,9 @@ pub mod api {
         };
     }
 
-    /// schema.zig:1639 — peechy `message TransformOptions`. Full field set,
+    /// peechy `message TransformOptions`. Full field set,
     /// hand-expanded so `bundler::options::BundleOptions::from_api` and the
-    /// bunfig/CLI parsers can un-gate. Field order mirrors the Zig struct
-    /// exactly so side-by-side diff stays readable.
+    /// bunfig/CLI parsers can un-gate.
     ///
     /// Type map (matches the convention block below):
     ///   `?T`                  → `Option<T>`
@@ -127,8 +125,8 @@ pub mod api {
     ///   `?[:0]const u8`       → `Option<Box<[u8]>>`   (sentinel re-derived
     ///                            at use-site)
     ///
-    /// `Default` ⇔ `std.mem.zeroes(TransformOptions)` — every Option `None`,
-    /// every slice empty, every scalar `0`/`false`.
+    /// `Default` is all-zero: every Option `None`, every slice empty, every
+    /// scalar `0`/`false`.
     ///
     /// LIFECYCLE: `BundleOptions::from_api` parks this in an `Arc` whose final ref
     /// lives on the process-lifetime `Transpiler` (LSan-rooted in build_command.rs).
@@ -142,8 +140,7 @@ pub mod api {
         pub resolve: Option<ResolveMode>,
         /// origin
         pub origin: Option<Box<[u8]>>,
-        /// absolute_working_dir — Zig `?[:0]const u8`; sentinel dropped (see
-        /// type-map note above).
+        /// absolute_working_dir — sentinel dropped (see type-map note above).
         pub absolute_working_dir: Option<Box<[u8]>>,
         /// define
         pub define: Option<StringMap>,
@@ -216,8 +213,7 @@ pub mod api {
 
     // ─── BunInstall + supporting types ───────────────────────────────────────
 
-    /// schema.zig:2807 — `api.NpmRegistry`.
-    /// `Default` ⇔ `std.mem.zeroes(NpmRegistry)` (empty slices).
+    /// `Default` is empty slices.
     #[derive(Clone, Debug, Default)]
     pub struct NpmRegistry {
         /// url
@@ -233,24 +229,23 @@ pub mod api {
     }
 
     impl NpmRegistry {
-        /// `NpmRegistry.dupe(allocator)` — Zig packs all five strings into one
-        /// contiguous allocation and reslices. Rust can't hand back five
-        /// `Box<[u8]>` views into one buffer without leaking, so this is a
-        /// plain field-wise clone. PERF(port): could pack into a single buffer.
+        /// Plain field-wise clone. PERF: could pack all five strings into one
+        /// contiguous allocation and reslice, but Rust can't hand back five
+        /// `Box<[u8]>` views into one buffer without leaking.
         #[inline]
         pub fn dupe(&self) -> NpmRegistry {
             self.clone()
         }
     }
 
-    /// schema.zig:2956 — `scopes: bun.StringArrayHashMapUnmanaged(NpmRegistry)`.
+    /// Per-scope npm registry overrides, keyed by scope name.
     #[derive(Default)]
     pub struct NpmRegistryMap {
         pub scopes: bun_collections::StringArrayHashMap<NpmRegistry>,
     }
 
-    /// schema.zig:3041 — anonymous `?union(enum) { str, list }` field on
-    /// `BunInstall.ca`; hoisted to a named type so callers can construct it.
+    /// Value of `BunInstall.ca`; hoisted to a named type so callers can
+    /// construct it.
     #[derive(Clone, Debug)]
     pub enum Ca {
         Str(Box<[u8]>),
@@ -263,8 +258,8 @@ pub mod api {
     /// same type.
     pub use bun_install_types::NodeLinker::{NodeLinker, PnpmMatcher};
 
-    /// schema.zig:2973 — `api.BunInstall`. Full field set, order-faithful.
-    /// `Default` ⇔ `std.mem.zeroes(Api.BunInstall)` (every field `None`/empty).
+    /// Full field set.
+    /// `Default` is every field `None`/empty.
     ///
     /// No `Debug`/`Clone` derive: `NpmRegistryMap` wraps `StringArrayHashMap`
     /// which currently provides neither.
@@ -327,7 +322,7 @@ pub mod api {
         pub hoist_pattern: Option<PnpmMatcher>,
     }
 
-    /// schema.zig:1967 — `enum(u8)` (open). Generated body emits `_` open
+    /// Open `enum(u8)` in the wire schema. Generated body emits `_` open
     /// variant; Rust side keeps it closed since callers exhaustively match
     /// only the four named tags (see bundler/options.rs `SourceMapOption`).
     #[repr(u8)]
@@ -340,7 +335,7 @@ pub mod api {
         Linked,
     }
 
-    /// schema.zig:732 — `enum(u8)` (open). Kept closed; `BundleEnums::Target::from`
+    /// Open `enum(u8)` in the wire schema. Kept closed; `BundleEnums::Target::from`
     /// guards the open tail with a `_ => Browser` arm.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
@@ -368,7 +363,7 @@ pub mod api {
     /// Alias: `runtime/cli/Arguments.rs` spells the schema type both ways.
     pub type Packages = PackagesMode;
 
-    /// schema.zig:325 — `enum(u8)` (open), `_none = 254`. Kept closed;
+    /// Open `enum(u8)` in the wire schema, `_none = 254`. Kept closed;
     /// `BundleEnums::Loader::from_api` guards the open tail with `_ => File`.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
@@ -399,7 +394,7 @@ pub mod api {
     }
 
     impl Loader {
-        /// Zig `@enumFromInt` for the schema `Loader` (open `enum(u8)` in Zig).
+        /// Converts a raw discriminant to the schema `Loader`.
         /// Unknown discriminants fall back to `_none`, matching how
         /// `BundleEnums::Loader::from_api` already guards the open tail.
         #[inline]
@@ -431,7 +426,7 @@ pub mod api {
         }
     }
 
-    /// schema.zig:2200 — `enum(u8)` (open). Kept closed.
+    /// Open `enum(u8)` in the wire schema. Kept closed.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum ImportKind {
@@ -460,10 +455,10 @@ pub mod api {
     //
     // Enum variant names are PascalCase (idiomatic Rust, matches downstream
     // callers in bundler/options.rs + router/lib.rs); `_none` retained as the
-    // zero-tag default where the Zig schema has it. Full peechy `.rs` emit
+    // zero-tag default where the wire schema has it. Full peechy `.rs` emit
     // will replace this block wholesale.
 
-    /// schema.zig:771 — `enum(u8)` (open). Kept closed.
+    /// Open `enum(u8)` in the wire schema. Kept closed.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum JsxRuntime {
@@ -474,7 +469,7 @@ pub mod api {
         Solid = 3,
     }
 
-    /// schema.zig:789
+    /// JSX transform configuration (factory, fragment, runtime, …).
     #[derive(Clone, Debug, Default)]
     pub struct Jsx {
         pub factory: Box<[u8]>,
@@ -485,7 +480,7 @@ pub mod api {
         pub side_effects: bool,
     }
 
-    /// schema.zig:1130
+    /// Parallel-array string→string map as transmitted on the wire.
     #[derive(Clone, Debug, Default)]
     pub struct StringMap {
         pub keys: Vec<Box<[u8]>>,
@@ -499,21 +494,21 @@ pub mod api {
         };
     }
 
-    /// schema.zig:1151
+    /// Parallel-array map from file extension to [`Loader`].
     #[derive(Clone, Debug, Default)]
     pub struct LoaderMap {
         pub extensions: Vec<Box<[u8]>>,
         pub loaders: Vec<Loader>,
     }
 
-    /// schema.zig:1193 — peechy `message` (all fields optional)
+    /// peechy `message` (all fields optional)
     #[derive(Clone, Debug, Default)]
     pub struct EnvConfig {
         pub prefix: Option<Box<[u8]>>,
         pub defaults: Option<StringMap>,
     }
 
-    /// schema.zig:1247
+    /// Fully-resolved env configuration ([`EnvConfig`] with defaults applied).
     #[derive(Clone, Debug, Default)]
     pub struct LoadedEnvConfig {
         pub dotenv: DotEnvBehavior,
@@ -521,7 +516,7 @@ pub mod api {
         pub prefix: Box<[u8]>,
     }
 
-    /// schema.zig:355 — `enum(u8)` (open). Kept closed.
+    /// Open `enum(u8)` in the wire schema. Kept closed.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum FrameworkEntryPointType {
@@ -532,7 +527,8 @@ pub mod api {
         Fallback = 3,
     }
 
-    /// schema.zig:1365
+    /// One resolved framework entry point (client/server/fallback) with its
+    /// path and env config.
     #[derive(Clone, Debug, Default)]
     pub struct FrameworkEntryPoint {
         pub kind: FrameworkEntryPointType,
@@ -540,7 +536,7 @@ pub mod api {
         pub env: LoadedEnvConfig,
     }
 
-    /// schema.zig:1391 — peechy `message` (all fields optional)
+    /// peechy `message` (all fields optional)
     #[derive(Clone, Debug, Default)]
     pub struct FrameworkEntryPointMap {
         pub client: Option<FrameworkEntryPoint>,
@@ -548,14 +544,15 @@ pub mod api {
         pub fallback: Option<FrameworkEntryPoint>,
     }
 
-    /// schema.zig:1444 — peechy `message` (all fields optional)
+    /// peechy `message` (all fields optional)
     #[derive(Clone, Debug, Default)]
     pub struct FrameworkEntryPointMessage {
         pub path: Option<Box<[u8]>>,
         pub env: Option<EnvConfig>,
     }
 
-    /// schema.zig:1528
+    /// Fully-resolved router configuration (dir, extensions, static dir,
+    /// asset prefix).
     #[derive(Clone, Debug, Default)]
     pub struct LoadedRouteConfig {
         pub dir: Box<[u8]>,
@@ -564,7 +561,7 @@ pub mod api {
         pub asset_prefix: Box<[u8]>,
     }
 
-    /// schema.zig:1559 — peechy `message` (array fields default empty,
+    /// peechy `message` (array fields default empty,
     /// scalar fields optional)
     #[derive(Clone, Debug, Default)]
     pub struct RouteConfig {
@@ -574,7 +571,7 @@ pub mod api {
         pub asset_prefix: Option<Box<[u8]>>,
     }
 
-    /// schema.zig:753 — `enum(u8)` (open). Kept closed.
+    /// Open `enum(u8)` in the wire schema. Kept closed.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum CssInJsBehavior {
@@ -585,7 +582,7 @@ pub mod api {
         AutoOnimportcss = 3,
     }
 
-    /// schema.zig:1987 — `enum(u8)` (open, no `_none`). Kept closed.
+    /// Open `enum(u8)` in the wire schema (no `_none`). Kept closed.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum PackagesMode {
@@ -594,11 +591,11 @@ pub mod api {
         External = 1,
     }
 
-    // ── Fallback error-page wire types (schema.zig:548-708) ────────────────
+    // ── Fallback error-page wire types ──────────────────────────────────────
     // Hand-stubbed subset so `js_parser::runtime::Fallback` un-gates. Full
     // bodies (with `decode`) arrive from the peechy generator.
 
-    /// schema.zig:548 — `enum(u8)` (open).
+    /// Open `enum(u8)` in the wire schema.
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
     pub enum FallbackStep {
@@ -614,7 +611,7 @@ pub mod api {
         fetch_event_handler = 8,
     }
 
-    /// schema.zig:612 — peechy `struct Router`.
+    /// peechy `struct Router`.
     #[derive(Clone, Debug, Default)]
     pub struct Router {
         pub routes: StringMap,
@@ -629,7 +626,7 @@ pub mod api {
         }
     }
 
-    /// schema.zig:581 — peechy `struct Problems`.
+    /// peechy `struct Problems`.
     #[derive(Clone, Debug, Default)]
     pub struct Problems {
         pub code: u16,
@@ -649,7 +646,7 @@ pub mod api {
         }
     }
 
-    /// schema.zig:475 — peechy `message JsException` (all fields optional).
+    /// peechy `message JsException` (all fields optional).
     #[derive(Clone, Debug, Default)]
     pub struct JsException {
         pub name: Option<Box<[u8]>>,
@@ -693,7 +690,7 @@ pub mod api {
         }
     }
 
-    /// schema.zig — peechy `struct Log` (minimal: `warnings`, `errors`, `msgs`).
+    /// peechy `struct Log` (minimal: `warnings`, `errors`, `msgs`).
     #[derive(Copy, Clone, Debug, Default)]
     pub struct Log {
         pub warnings: u32,
@@ -708,7 +705,7 @@ pub mod api {
         }
     }
 
-    /// schema.zig:638 — peechy `message FallbackMessageContainer`.
+    /// peechy `message FallbackMessageContainer`.
     #[derive(Clone, Debug, Default)]
     pub struct FallbackMessageContainer {
         pub message: Option<Box<[u8]>>,
diff --git a/src/output/lib.rs b/src/output/lib.rs
index 90568c0cf9c..8276e8f9c13 100644
--- a/src/output/lib.rs
+++ b/src/output/lib.rs
@@ -13,8 +13,6 @@
 #![warn(unused_must_use)]
 // ── scoped logging (the requested symbol) ────────────────────────────────
 //
-// Zig: `bun.Output.scoped(.X, .visible)` → Rust:
-//
 //     bun_output::declare_scope!(X, visible);
 //     bun_output::scoped_log!(X, "fmt {} {}", a, b);
 //
@@ -43,8 +41,7 @@ pub use bun_core::{
 };
 
 /// `bun_output::scope_is_visible!(X)` — sugar for `X.is_visible()` on a
-/// `declare_scope!`-produced static. Mirrors Zig
-/// `Output.isScopeVisible(.X)`. Kept as a macro (not a fn) so the scope
+/// `declare_scope!`-produced static. Kept as a macro (not a fn) so the scope
 /// ident resolves at the call site without an import.
 #[macro_export]
 macro_rules! scope_is_visible {
diff --git a/src/parsers/json.rs b/src/parsers/json.rs
index 5ff04381b52..7771dd9126a 100644
--- a/src/parsers/json.rs
+++ b/src/parsers/json.rs
@@ -23,14 +23,13 @@ const LEXER_DEBUGGER_WORKAROUND: bool = false;
 mod hash_map_pool {
     use super::*;
 
-    // Zig: std.HashMap(u64, void, IdentityContext, 80)
-    // TODO(port): identity-hash u64 set with 80% max-load — verify bun_collections has an
-    // identity-hasher variant; otherwise add one. Using HashMap<u64, ()> for now.
-    pub(super) type HashMap = bun_collections::HashMap<u64, ()>;
-
-    // Zig used a threadlocal SinglyLinkedList<HashMap> as a freelist.
-    // PORT NOTE: reshaped for borrowck — Rust thread_local + Vec<HashMap> freelist;
-    // a borrowed Node* across calls is replaced by an owned HashMap moved out/in.
+    // Keys are pre-hashed (`EString::hash()`), so identity hashing avoids
+    // re-hashing the hash.
+    pub(super) type HashMap =
+        bun_collections::HashMap<u64, (), bun_collections::IdentityContext<u64>>;
+
+    // thread_local + Vec<HashMap> freelist; an owned HashMap is moved out/in
+    // rather than borrowed across calls.
     thread_local! {
         static LIST: RefCell<Vec<HashMap>> = const { RefCell::new(Vec::new()) };
     }
@@ -57,30 +56,33 @@ fn new_expr<Ty>(t: Ty, loc: bun_ast::Loc) -> Expr
 where
     Ty: js_ast::ExprInit,
 {
-    // Zig had: if @typeInfo(Type) == .pointer => @compileError — Rust's type system
-    // already prevents passing a reference where a value is expected; no runtime check needed.
-
-    #[cfg(debug_assertions)]
-    {
-        // TODO(port): the Zig code asserted, when Ty == E.Object, that every property
-        // has key.is_some(), value.is_some(), initializer.is_none(). Requires
-        // specialization or a method on the ExprInit trait.
-    }
-
+    // For Ty == E.Object, every property must have key != null, value != null,
+    // initializer == null. Rust has no specialization, so that check lives in
+    // `debug_assert_json_object_shape`, called at the (single) E::Object
+    // construction site below.
     Expr::init(t, loc)
 }
 
+/// JSON objects must have every property fully keyed/valued with no
+/// initializer.
+#[inline]
+fn debug_assert_json_object_shape(properties: &[G::Property]) {
+    if cfg!(debug_assertions) {
+        for prop in properties {
+            // json should never have an initializer set
+            debug_assert!(prop.initializer.is_none());
+            debug_assert!(prop.key.is_some());
+            debug_assert!(prop.value.is_some());
+        }
+    }
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // JSONLikeParser
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig defines two layers:
-//   fn JSONLikeParser(comptime opts: JSONOptions) type   — wrapper
-//   fn JSONLikeParser_(comptime ...8 bools...) type      — "hack fixes using LLDB"
-//
-// The Rust port collapses both into a *single* concrete type carrying
-// `JSONOptions` at runtime. The earlier port mirrored Zig's comptime layer
-// with 8 struct-level `const bool` generics plus 2 more on `parse_expr`; that
+// A *single* concrete type carrying `JSONOptions` at runtime. An earlier
+// version used 8 struct-level `const bool` generics plus 2 more on `parse_expr`; that
 // gave a 2^10 monomorphization surface (6+ live combos in-tree, more once
 // downstream crates pick their own), each re-emitted in every crate that
 // touched a new combo. The body is I/O-bound on lexer reads and the option
@@ -89,13 +91,13 @@ where
 // exactly once in `bun_parsers`. (benches: startup/npm-script.)
 //
 // `crate::json_lexer::Lexer` already carries a runtime `JSONOptions` (the JSON
-// token loop is small enough that comptime specialisation bought nothing), so
+// token loop is small enough that const-generic specialisation buys nothing), so
 // the parser simply reuses the same struct.
 
 pub struct JSONLikeParser<'a, 'bump> {
     pub lexer: js_lexer::Lexer<'a, 'bump>,
-    // PORT NOTE — Stacked Borrows: the Zig spec stores a second `*logger.Log`
-    // here (json.zig:103). In Rust that would alias the lexer's `*mut Log`; a
+    // Stacked Borrows: a second log pointer stored here
+    // would alias the lexer's `*mut Log`; a
     // live `&'a mut Log` field would invalidate the lexer's SharedReadWrite tag
     // on first use (UB on the next lexer error). All log writes route through
     // `self.lexer.log_mut()` instead — single provenance chain.
@@ -119,7 +121,6 @@ where
         source_: &'a bun_ast::Source,
         log: &'a mut bun_ast::Log,
     ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
         Self::init_with_list_allocator(opts, bump, bump, source_, log)
     }
 
@@ -130,7 +131,6 @@ where
         source_: &'a bun_ast::Source,
         log: &'a mut bun_ast::Log,
     ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
         Expr::data_store_assert();
         Stmt::data_store_assert();
         Ok(Self {
@@ -162,7 +162,6 @@ where
         force_utf8: bool,
     ) -> Result<Expr, bun_core::Error> {
         if !self.stack_check.is_safe_to_recurse() {
-            // Zig: `bun.throwStackOverflow()`.
             return Err(bun_core::err!("StackOverflow"));
         }
 
@@ -204,9 +203,7 @@ where
             T::TOpenBracket => {
                 self.lexer.next()?;
                 let mut is_single_line = !self.lexer.has_newline_before;
-                // PORT NOTE: Zig grew an `ArrayList(Expr)` in `list_allocator` and
-                // `moveFromList`-ed it. The Rust `Vec` is `Vec`-backed (global
-                // allocator), so build a `Vec<Expr>` directly and hand it off.
+                // Build a `Vec<Expr>` (global allocator) directly and hand it off.
                 let mut exprs: Vec<Expr> = Vec::new();
                 // errdefer exprs.deinit() — dropped automatically on `?`.
 
@@ -226,7 +223,7 @@ where
                     }
 
                     let item = self.parse_expr(false, force_utf8)?;
-                    exprs.push(item); // PERF(port): Zig used `catch unreachable` (OOM crash)
+                    exprs.push(item);
                 }
 
                 if self.lexer.has_newline_before {
@@ -246,12 +243,12 @@ where
             T::TOpenBrace => {
                 self.lexer.next()?;
                 let mut is_single_line = !self.lexer.has_newline_before;
-                // PORT NOTE: see TOpenBracket note — `Vec` is `Vec`-backed.
+                // see TOpenBracket note — `Vec` is `Vec`-backed.
                 let mut properties: Vec<G::Property> = Vec::new();
                 // errdefer properties.deinit() — dropped automatically on `?`.
 
-                // PORT NOTE: reshaped for borrowck — Zig used `void`/`*Node` when
-                // json_warn_duplicate_keys is false; Rust uses Option to keep one code path.
+                // Option keeps one code path whether or not
+                // json_warn_duplicate_keys is set.
                 let warn_dup = self.opts.json_warn_duplicate_keys;
                 let mut duplicates: Option<hash_map_pool::HashMap> = if warn_dup {
                     Some(hash_map_pool::get())
@@ -263,7 +260,7 @@ where
                         hash_map_pool::release(map);
                     }
                 });
-                // PORT NOTE: Zig `defer` — scopeguard runs on both success and error paths.
+                // scopeguard runs on both success and error paths.
 
                 while self.lexer.token != T::TCloseBrace {
                     if !properties.is_empty() {
@@ -285,9 +282,8 @@ where
                     };
 
                     let key_range = self.lexer.range();
-                    // Zig copied the `E.String` by value; `EString` is intentionally
-                    // not `Clone` (rope `next` would alias) — `shallow_clone` is the
-                    // explicit field-copy that matches the Zig struct copy.
+                    // `EString` is intentionally not `Clone` (rope `next` would
+                    // alias) — `shallow_clone` is the explicit field-copy.
                     let key = new_expr(str.shallow_clone(), key_range.loc);
                     self.lexer.expect(T::TStringLiteral)?;
 
@@ -321,13 +317,13 @@ where
                         initializer: None,
                         ..Default::default()
                     });
-                    // PERF(port): Zig used `catch unreachable` (OOM crash)
                 }
 
                 if self.lexer.has_newline_before {
                     is_single_line = false;
                 }
                 self.lexer.expect(T::TCloseBrace)?;
+                debug_assert_json_object_shape(&properties);
                 Ok(new_expr(
                     E::Object {
                         properties: G::PropertyList::move_from_list(properties),
@@ -340,7 +336,7 @@ where
             }
             _ => {
                 if maybe_auto_quote {
-                    // PORT NOTE: borrowck — capture `source` (a `&'a Source`,
+                    // borrowck — capture `source` (a `&'a Source`,
                     // Copy) and the lexer's `*mut Log` before reassigning
                     // `self.lexer`. The new lexer is built over the *same* raw
                     // log pointer so there is still exactly one provenance
@@ -367,7 +363,6 @@ where
     }
 
     pub fn parse_maybe_trailing_comma(&mut self, closer: T) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set
         let comma_range = self.lexer.range();
         self.lexer.expect(T::TComma)?;
 
@@ -403,7 +398,7 @@ where
 pub struct PackageJSONVersionChecker<'a, 'bump> {
     pub lexer: js_lexer::Lexer<'a, 'bump>,
     pub source: &'a bun_ast::Source,
-    // PORT NOTE — Stacked Borrows: no separate `log` field; route through
+    // Stacked Borrows: no separate `log` field; route through
     // `self.lexer.log_mut()` (single provenance chain — see `JSONLikeParser`).
     pub bump: &'bump Bump,
     pub depth: usize,
@@ -412,8 +407,7 @@ pub struct PackageJSONVersionChecker<'a, 'bump> {
     pub found_version_buf: [u8; 1024],
     pub found_name_buf: [u8; 1024],
 
-    // PORT NOTE: reshaped for borrowck — Zig stored `found_name: []const u8` as a
-    // self-referential slice into `found_name_buf`. Rust stores the length instead;
+    // Stores lengths rather than self-referential slices into the bufs;
     // use `.found_name()` / `.found_version()` accessors.
     found_name_len: usize,
     found_version_len: usize,
@@ -424,7 +418,6 @@ pub struct PackageJSONVersionChecker<'a, 'bump> {
     pub name_loc: bun_ast::Loc,
 }
 
-// Zig: const opts = if (LEXER_DEBUGGER_WORKAROUND) JSONOptions{} else JSONOptions{ is_json=true, json_warn_duplicate_keys=false, allow_trailing_commas=true, allow_comments=true }
 const PKG_JSON_OPTS: js_lexer::JSONOptions = if LEXER_DEBUGGER_WORKAROUND {
     js_lexer::JSONOptions::DEFAULT
 } else {
@@ -446,7 +439,6 @@ where
         source: &'a bun_ast::Source,
         log: &'a mut bun_ast::Log,
     ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Self {
             lexer: js_lexer::Lexer::init(log, source, bump, PKG_JSON_OPTS)?,
             bump,
@@ -475,7 +467,6 @@ where
 
     pub fn parse_expr(&mut self) -> Result<Expr, bun_core::Error> {
         if !self.stack_check.is_safe_to_recurse() {
-            // Zig: `bun.throwStackOverflow()`.
             return Err(bun_core::err!("StackOverflow"));
         }
 
@@ -536,7 +527,7 @@ where
             T::TOpenBrace => {
                 self.lexer.next()?;
                 self.depth += 1;
-                // PORT NOTE: Zig `defer p.depth -= 1` — wrap body in a closure so `?`
+                // Wrap body in a closure so `?`
                 // returns here and depth is decremented exactly once on every exit path
                 // (Ok, Err, early break). scopeguard cannot hold `&mut self.depth` while
                 // the body re-borrows `&mut self`.
@@ -565,10 +556,9 @@ where
                             if let (Some(key_s), Some(val_s)) =
                                 (key.data.as_e_string(), value.data.as_e_string())
                             {
-                                // Zig matched on `.e_string` tag and read
-                                // `.e_string.data` directly; `as_e_string()` returns
-                                // `StoreRef<EString>` which derefs to the payload, so
-                                // `.data` is the raw byte slice.
+                                // `as_e_string()` returns `StoreRef<EString>` which
+                                // derefs to the payload, so `.data` is the raw byte
+                                // slice.
                                 if !self.has_found_name && key_s.data == b"name" {
                                     let len = val_s.data.len().min(self.found_name_buf.len());
 
@@ -608,7 +598,6 @@ where
     }
 
     pub fn parse_maybe_trailing_comma(&mut self, closer: T) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set
         let comma_range = self.lexer.range();
         self.lexer.expect(T::TComma)?;
 
@@ -631,9 +620,8 @@ where
 // toAST
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig `toAST` switches on `@typeInfo(Type)` to recursively convert any value
-// into a `js_ast.Expr`. Rust has no `@typeInfo`; this becomes a trait with
-// per-type impls. Struct/enum/union arms require a derive macro.
+// Recursively converts a value into a `js_ast.Expr` via a trait with
+// per-type impls. Struct/enum/union support would require a derive macro.
 
 pub trait ToAst {
     fn to_ast(&self, bump: &Bump) -> Result<Expr, bun_core::Error>;
@@ -660,10 +648,9 @@ macro_rules! impl_to_ast_int {
         }
     )*};
 }
-// PORT NOTE: `u8` is intentionally omitted so the generic `impl<T: ToAst> for [T]`
-// / `[T; N]` does NOT match byte arrays — Zig special-cases `Array.child == u8`
-// (json.zig:557-565) to emit `E::String`, not `E::Array`. See dedicated
-// `[u8]` / `[u8; N]` impls below.
+// `u8` is intentionally omitted so the generic `impl<T: ToAst> for [T]`
+// / `[T; N]` does NOT match byte arrays — byte slices/arrays emit
+// `E::String`, not `E::Array`. See dedicated `[u8]` / `[u8; N]` impls below.
 impl_to_ast_int!(i8, i16, i32, i64, isize, u16, u32, u64, usize);
 
 macro_rules! impl_to_ast_float {
@@ -714,7 +701,7 @@ impl<T: ToAst, const N: usize> ToAst for [T; N] {
     }
 }
 
-// Spec json.zig:557-565 — `Array.child == u8` → `E::String` (not `E::Array`).
+// Byte arrays emit `E::String` (not `E::Array`).
 impl<const N: usize> ToAst for [u8; N] {
     fn to_ast(&self, _bump: &Bump) -> Result<Expr, bun_core::Error> {
         Ok(Expr::init(
@@ -751,41 +738,19 @@ impl ToAst for bun_core::Error {
     }
 }
 
-// TODO(port): proc-macro — Zig's `.@"struct"` arm iterates `@typeInfo(Type).Struct.fields`
-// and emits an `E.Object` keyed by field name. Provide `#[derive(ToAst)]` that
-// expands to:
-//   impl ToAst for Foo {
-//     fn to_ast(&self, bump: &Bump) -> Result<Expr, _> {
-//       let mut properties = Vec::<G::Property>::with_capacity(bump, N);
-//       properties.push_assume_capacity(G::Property {
-//         key: Some(Expr::init(E::String { data: b"field_name" }, Loc::EMPTY)),
-//         value: Some(self.field_name.to_ast(bump)?),
-//         ..Default::default()
-//       });
-//       ...
-//       Ok(Expr::init(E::Object { properties, is_single_line: N <= 1, .. }, Loc::EMPTY))
-//     }
-//   }
-//
-// TODO(port): proc-macro — Zig's `.@"enum"` arm validates the discriminant via
-// `intToEnum` (returns null on failure) then emits `@tagName(value)` as a string.
-// Map to `#[derive(strum::IntoStaticStr)]` + `<&'static str>::from(*self).as_bytes().to_ast()`.
-//
-// TODO(port): proc-macro — Zig's `.@"union"` arm (tagged union) constructs a
-// single-field anonymous struct `{ <variant_name>: payload }` and recurses.
-// In Rust this is the natural shape of `enum` payloads; the derive should emit
-// `match self { Variant(v) => /* { "Variant": v } */ }`.
+// Struct/enum/union conversion would need a derive macro, and no current call
+// site converts a struct/enum value — only the primitive/slice impls above are
+// used.
 
 // ──────────────────────────────────────────────────────────────────────────
 // Parser option presets
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig spelt these as distinct `JSONLikeParser(.{...})` *types*. With the
-// const-generic surface collapsed (see `JSONLikeParser` note), they become
-// plain `JSONOptions` constants fed to the one concrete parser.
+// With the const-generic surface collapsed (see `JSONLikeParser` note), these
+// are plain `JSONOptions` constants fed to the one concrete parser.
 //
-// Spec lexer.zig:50 — `json_warn_duplicate_keys: bool = true` is the DEFAULT;
-// json.zig:647-655/734 do not override it for the first four presets.
+// `json_warn_duplicate_keys: bool = true` is the DEFAULT; the first four
+// presets do not override it.
 
 const JSON_OPTS: js_lexer::JSONOptions = js_lexer::JSONOptions {
     is_json: true,
@@ -825,11 +790,8 @@ const PACKAGE_JSON_OPTS: js_lexer::JSONOptions = js_lexer::JSONOptions {
 
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): these were `var` (mutable file-scope) in Zig because Expr.Data
-// stores `*E.Object` etc. Never mutated — `RacyCell` only because
+// Never mutated — `RacyCell` only because
 // `StoreRef::from_raw` wants a `*mut T` and the payload types are `!Sync`.
-// Could prefer `Expr::Data` constructors that don't need a backing static
-// (e.g. inline empty-object sentinel).
 static EMPTY_OBJECT: bun_core::RacyCell<E::Object> = bun_core::RacyCell::new(E::Object::EMPTY);
 static EMPTY_ARRAY: bun_core::RacyCell<E::Array> = bun_core::RacyCell::new(E::Array::EMPTY);
 static EMPTY_STRING: bun_core::RacyCell<E::String> = bun_core::RacyCell::new(E::String::EMPTY);
@@ -865,7 +827,6 @@ pub fn parse<const FORCE_UTF8: bool>(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     let mut parser = JSONLikeParser::init(JSON_OPTS, bump, source, log)?;
     match source.contents.len() {
         // This is to be consisntent with how disabled JS files are handled
@@ -910,7 +871,6 @@ pub fn parse_package_json_utf8(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     let len = source.contents.len();
 
     match len {
@@ -955,7 +915,7 @@ pub struct JsonResult {
     pub indentation: Indentation,
 }
 
-// Zig signature takes `comptime opts: js_lexer.JSONOptions`. The 8-bool
+// The 8-bool
 // const-generic spelling is kept *only* as a back-compat shim for existing
 // call sites in downstream crates; it immediately reifies the flags into a
 // runtime `JSONOptions` and forwards to the single non-generic body below.
@@ -1001,7 +961,6 @@ pub fn parse_package_json_utf8_with_opts_rt(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<JsonResult, bun_core::Error> {
-    // TODO(port): narrow error set
     let len = source.contents.len();
 
     match len {
@@ -1071,7 +1030,6 @@ pub fn parse_utf8(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     parse_utf8_impl::<false>(source, log, bump)
 }
 
@@ -1081,7 +1039,6 @@ pub fn parse_utf8_impl<const CHECK_LEN: bool>(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     let len = source.contents.len();
 
     match len {
@@ -1133,7 +1090,6 @@ pub fn parse_for_macro(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     match source.contents.len() {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1187,7 +1143,6 @@ pub fn parse_for_bundling(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<JSONParseResult, bun_core::Error> {
-    // TODO(port): narrow error set
     match source.contents.len() {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1230,7 +1185,6 @@ pub fn parse_for_bundling(
         _ => {}
     }
 
-    // NOTE: Zig passes `source.*` (by value) here, unlike every other call site.
     let mut parser = JSONLikeParser::init(JSON_OPTS, bump, source, log)?;
     let result = parser.parse_expr(false, true)?;
     Ok(JSONParseResult {
@@ -1250,7 +1204,6 @@ pub fn parse_env_json(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     match source.contents.len() {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1319,7 +1272,6 @@ pub fn parse_ts_config<const FORCE_UTF8: bool>(
     log: &mut bun_ast::Log,
     bump: &Bump,
 ) -> Result<Expr, bun_core::Error> {
-    // TODO(port): narrow error set
     match source.contents.len() {
         // This is to be consisntent with how disabled JS files are handled
         0 => {
@@ -1366,7 +1318,6 @@ mod tests {
     use bun_js_printer as js_printer;
 
     fn expect_printed_json(_contents: &[u8], expected: &[u8]) -> Result<(), bun_core::Error> {
-        // Zig: Expr.Data.Store.create(); Stmt.Data.Store.create(); defer { ..reset() }.
         // RAII: `StoreResetGuard` resets both thread-local AST stores on every
         // exit path (including `?`).
         let _store_scope = js_ast::StoreResetGuard::new();
@@ -1415,5 +1366,3 @@ mod tests {
         Ok(())
     }
 }
-
-// ported from: src/interchange/json.zig
diff --git a/src/parsers/json5.rs b/src/parsers/json5.rs
index a1af864b3ab..23904c448f1 100644
--- a/src/parsers/json5.rs
+++ b/src/parsers/json5.rs
@@ -1118,5 +1118,3 @@ fn append_codepoint_to_utf8(buf: &mut BumpVec<'_, u8>, cp: i32) -> Result<(), Pa
 fn is_ident_continue_ascii(c: u8) -> bool {
     matches!(c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'$')
 }
-
-// ported from: src/interchange/json5.zig
diff --git a/src/parsers/json_lexer.rs b/src/parsers/json_lexer.rs
index f7d5a643f1a..1b5954bd403 100644
--- a/src/parsers/json_lexer.rs
+++ b/src/parsers/json_lexer.rs
@@ -4,18 +4,12 @@
 //! `bun_js_parser::js_lexer::Lexer` (T4), creating a GENUINE same-tier cycle
 //! (`bun_js_parser` → `bun_interchange` → `bun_js_parser`). Per the cycle-break
 //! plan, the ~10 lexer entry-points JSON actually exercises are inlined here
-//! against the *is_json = true* compile-time branch only — i.e. every
-//! `if (comptime is_json) …` arm in `src/js_parser/lexer.zig` is taken, every
+//! against the *is_json = true* branch only — every
 //! JS-only arm (operators, JSX, regexp, template literals, pragmas, hashbang,
 //! private identifiers, bigint) is dropped or hard-errors via
 //! `add_unsupported_syntax_error`. The full `T` token enum is collapsed to the
 //! tokens the JSON parser matches on.
 //!
-//! Source: `src/js_parser/lexer.zig` — `JSONOptions`, `NewLexer_` with
-//! `is_json = true`, `next`, `parseStringLiteral`, `parseNumericLiteralOrDot`,
-//! `expect`/`expected`/`unexpected`, `range`/`loc`/`raw`, `init`/`initJSON`,
-//! `toEString`/`toUTF8EString`, `step`/`nextCodepoint`.
-//!
 //! `bun_js_parser::js_lexer` remains the canonical lexer; this module is a
 //! sliced re-port and is NOT re-exported outside `bun_interchange`.
 
@@ -31,7 +25,6 @@ use bun_core::strings::CodePoint;
 // JSONOptions
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `pub const JSONOptions = struct { ... }` (lexer.zig:37).
 #[derive(Clone, Copy)]
 pub struct JSONOptions {
     /// Enable JSON-specific warnings/errors.
@@ -56,7 +49,6 @@ impl JSONOptions {
         allow_trailing_commas: false,
         ignore_leading_escape_sequences: false,
         ignore_trailing_escape_sequences: false,
-        // NOTE: Zig default is `true` (lexer.zig:50).
         json_warn_duplicate_keys: true,
         was_originally_macro: false,
         guess_indentation: false,
@@ -73,7 +65,7 @@ impl Default for JSONOptions {
 // T — token kind (JSON subset)
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `js_lexer_tables.T`. This enum carries ONLY the variants the JSON
+/// This enum carries ONLY the variants the JSON
 /// parser inspects; every JS-only token collapses into `TSyntaxError` here.
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -99,7 +91,7 @@ pub enum T {
 }
 
 impl T {
-    /// Zig: `tokenToString.get(token)`. Only the JSON subset has names; the
+    /// Only the JSON subset has names; the
     /// rest fall through to `unexpected()`.
     fn to_str(self) -> &'static str {
         match self {
@@ -149,19 +141,18 @@ impl Default for IndentInfo {
     }
 }
 
-/// JSON-only lexer. Field layout mirrors the Zig `LexerType` for the fields
-/// the JSON parser reads directly (`token`, `number`, `has_newline_before`,
+/// JSON-only lexer. The public fields are
+/// the ones the JSON parser reads directly (`token`, `number`, `has_newline_before`,
 /// `source`, `end`, `is_ascii_only`, `identifier`, `indent_info`).
 ///
-/// PORT NOTE — borrowck/Stacked Borrows: Zig stored `log: *logger.Log` on
-/// both the lexer *and* the parser (json.zig:103,119). The Rust port keeps a
-/// single `*mut Log` here as the sole provenance chain; the parser does **not**
+/// borrowck/Stacked Borrows: a
+/// single `*mut Log` here is the sole provenance chain; the parser does **not**
 /// hold its own `&mut Log` (that would alias this pointer and any parser-side
 /// `&mut` deref would invalidate the lexer's SharedReadWrite tag — UB the next
 /// time the lexer reports an error). Parser-side log writes go through
 /// `log_mut()`. Matches the toml lexer's shape.
 pub struct Lexer<'a, 'bump> {
-    // PORT NOTE: raw ptr — see struct doc.
+    // raw ptr — see struct doc.
     log: *mut bun_ast::Log,
     pub source: &'a bun_ast::Source,
     bump: &'bump Bump,
@@ -188,7 +179,7 @@ pub struct Lexer<'a, 'bump> {
     /// Only used for JSON stringification when bundling.
     pub is_ascii_only: bool,
 
-    /// Runtime copy of the comptime `JSONOptions`. The cold-path flags
+    /// Runtime copy of `JSONOptions`. The cold-path flags
     /// (`allow_comments`, `guess_indentation`, `ignore_leading_escape_sequences`)
     /// stay runtime; the hot per-byte string loop is monomorphised over
     /// `const QUOTE: u8` and reads `is_json` as compile-time `true` (this
@@ -270,9 +261,9 @@ where
         }
     }
 
-    /// Zig: `init` — `NewLexer(opts).init`. The parser's 8 const-generic bools
+    /// The parser's 8 const-generic bools
     /// are flattened back into a runtime `JSONOptions` here; the JSON token
-    /// loop is small enough that the comptime specialisation buys nothing at
+    /// loop is small enough that const-generic specialisation buys nothing at
     /// this layer (the full JS lexer is where it mattered).
     pub(crate) fn init(
         log: &mut bun_ast::Log,
@@ -286,7 +277,7 @@ where
         Ok(lex)
     }
 
-    /// Zig: `initJSON` — identical body to `init` for the JSON lexer; kept as a
+    /// Identical body to `init`; kept as a
     /// separate entry point because `json.rs` calls it by name in the
     /// `MAYBE_AUTO_QUOTE` retry path.
     pub(crate) fn init_json(
@@ -384,7 +375,7 @@ where
 
     #[cold]
     fn expected_string(&mut self, text: &str) -> LexResult {
-        // PORT NOTE: the `prev_token_was_await_keyword` branch is JS-only and
+        // the `prev_token_was_await_keyword` branch is JS-only and
         // dropped here.
         let r = self.range();
         if self.source.contents.len() != self.start {
@@ -396,8 +387,8 @@ where
         } else {
             self.add_range_error(r, format_args!("Expected {} but found end of file", text))?;
         }
-        // Spec lexer.zig:1798-1863 — `expectedString` only logs via
-        // `addRangeError` and returns void; it does NOT raise. `expect()` then
+        // `expected_string` only logs via
+        // `add_range_error` and returns; it does NOT raise. `expect()` then
         // falls through to `next()` for error recovery.
         Ok(())
     }
@@ -414,7 +405,7 @@ where
             self.did_panic = true;
             self.add_range_error(r, format_args!("Unexpected {}", bstr::BStr::new(raw)))?;
         }
-        // Spec lexer.zig:1798-1812 — `unexpected` only logs and returns void;
+        // `unexpected` only logs and returns;
         // callers (e.g. `parse_expr` else arm) follow with an explicit
         // `error.ParserError` if they need to abort.
         Ok(())
@@ -431,18 +422,17 @@ where
             0 => self.parse_string_literal_inner::<0>(),
             q if q == '"' as CodePoint => self.parse_string_literal_inner::<b'"'>(),
             q if q == '\'' as CodePoint => self.parse_string_literal_inner::<b'\''>(),
-            // Only the three above are ever passed (lexer.zig:630 takes
-            // `comptime quote`); anything else is a port bug.
+            // Only the three above are ever passed; anything else is a bug.
             _ => unreachable!("parse_string_literal: invalid quote {}", quote),
         }
     }
 
-    /// Zig: `parseStringLiteral(comptime quote)` with `is_json = true`,
-    /// template-literal (`\``) and `$`-substitution arms removed. `QUOTE == 0`
+    /// String-literal scanner; template-literal (`\``) and `$`-substitution
+    /// arms are JS-only and absent. `QUOTE == 0`
     /// is the implicit (.env auto-quote) string.
     ///
-    /// PERF: `QUOTE` is a const generic mirroring Zig's `comptime quote:
-    /// CodePoint` so the per-byte `match` folds to a guard-free jump table and
+    /// PERF: `QUOTE` is a const generic
+    /// so the per-byte `match` folds to a guard-free jump table and
     /// the `QUOTE == 0` / SIMD-gate checks const-propagate away. `is_json` is
     /// hard-wired `true` (this module *is* the is_json slice — see file header)
     /// so the `< 0x20` control-char check is branchless on the option load.
@@ -508,10 +498,10 @@ where
                     if cp >= 0x80 {
                         needs_decode = true;
                     } else if cp < 0x20 {
-                        // `comptime is_json` is always true in this module.
+                        // `is_json` is always true in this module.
                         self.syntax_error()?;
                     } else if (QUOTE == b'"' || QUOTE == b'\'') && bun_core::env::IS_NATIVE {
-                        // Spec lexer.zig:730-740 — SIMD skip-ahead over plain
+                        // SIMD skip-ahead over plain
                         // ASCII string content. Critical for inline-sourcemap
                         // JSON where `sourcesContent` can be hundreds of KB.
                         let remainder = &self.source.contents[self.current..];
@@ -555,15 +545,11 @@ where
         self.string_literal_start = self.start;
         self.is_ascii_only = self.is_ascii_only && !needs_decode;
 
-        // Spec lexer.zig:775-779 gates the "JSON strings must use double quotes"
-        // error on `if (comptime !FeatureFlags.allow_json_single_quotes)`, and
-        // feature_flags.zig:24 sets `allow_json_single_quotes = true`, so the
-        // spec NEVER emits this error.
-
         Ok(())
     }
 
-    /// Zig: `toEString`.
+    /// Converts the current string literal token into an `E::String`,
+    /// decoding escape sequences and choosing UTF-8 vs UTF-16 storage.
     pub(crate) fn to_e_string(&mut self) -> LexResult<js_ast::E::String> {
         match self.string_literal_raw_format {
             StringLiteralFormat::Ascii => {
@@ -588,7 +574,8 @@ where
         }
     }
 
-    /// Zig: `toUTF8EString`.
+    /// Like [`Self::to_e_string`] but always returns UTF-8 storage,
+    /// transcoding a UTF-16 result if needed.
     pub(crate) fn to_utf8_e_string(&mut self) -> LexResult<js_ast::E::String> {
         let mut res = self.to_e_string()?;
         if res.is_utf16 {
@@ -599,13 +586,15 @@ where
         Ok(res)
     }
 
-    /// Zig: `decodeEscapeSequences`. Ported for the `is_json = true` arm only —
+    /// Escape-sequence decoder for the JSON arm only —
     /// legacy-octal, template `\r\n` normalization and tagged-template raw
     /// preservation are JS-only and dropped.
-    // TODO(port): JSON spec only permits `\" \\ \/ \b \f \n \r \t \uXXXX`; the
-    // Zig path additionally accepts `\0` `\v` `\x` `\u{…}` etc. and then errors
-    // post-hoc via `is_json` checks. Mirror that once the surrogate-pair
-    // handling in `bun_str` is wired.
+    // Lenient escapes: `\v`, `\x`, `\8`/`\9`
+    // are accepted; `\0`–`\7` (legacy octal)
+    // and `\u{…}` reach
+    // `syntax_error()` via the fallthrough/non-hex-digit arms. Astral
+    // codepoints in raw text are surrogate-pair encoded by `push_codepoint`
+    // (`strings::push_codepoint_utf16`).
     fn decode_escape_sequences(
         &mut self,
         _start: usize,
@@ -620,8 +609,7 @@ where
             let c = iter.c;
             match c {
                 cp if cp == '\\' as CodePoint => {
-                    // Spec lexer.zig:321 — `_ = iterator.next(&iter) or return;`
-                    // (silent Ok return on a trailing backslash).
+                    // Silent Ok return on a trailing backslash.
                     if !iterator.next(&mut iter) {
                         return Ok(());
                     }
@@ -633,17 +621,15 @@ where
                         cp if cp == 'r' as CodePoint => buf.push(0x0d),
                         cp if cp == 't' as CodePoint => buf.push(0x09),
                         cp if cp == 'v' as CodePoint => {
-                            // Vertical tab is invalid JSON. Spec lexer.zig:340-349
-                            // has the is_json check COMMENTED OUT with note
-                            // "We're going to allow it" — unconditionally push.
+                            // Vertical tab is technically invalid JSON, but we
+                            // allow it — unconditionally push.
                             buf.push(0x0b);
                         }
-                        // Spec lexer.zig:426-428 — `'8','9'` pass through as the
-                        // digit char (no is_json gate).
+                        // `'8','9'` pass through as the digit char.
                         cp if cp == '8' as CodePoint || cp == '9' as CodePoint => {
                             push_codepoint(buf, c2);
                         }
-                        // Spec lexer.zig:430-474 — `\xNN` 2-digit hex (no is_json gate).
+                        // `\xNN` 2-digit hex.
                         cp if cp == 'x' as CodePoint => {
                             let mut value: CodePoint = 0;
                             for _ in 0..2 {
@@ -658,8 +644,8 @@ where
                             }
                             push_codepoint(buf, value);
                         }
-                        // Spec lexer.zig:596-607 — only `"` `\` `/` are whitelisted
-                        // for the is_json `else` arm; `\'` falls through to syntaxError.
+                        // Only `"` `\` `/` are whitelisted;
+                        // `\'` falls through to syntax_error.
                         cp if cp == '"' as CodePoint
                             || cp == '\\' as CodePoint
                             || cp == '/' as CodePoint =>
@@ -682,9 +668,8 @@ where
                             buf.push(value as u16);
                         }
                         _ => {
-                            // `comptime is_json` is always true in this module
-                            // (see file header) — the Zig pass-through arm is
-                            // unreachable here.
+                            // The JS-only pass-through arm is unreachable in
+                            // this JSON-only module (see file header).
                             return self.syntax_error();
                         }
                     }
@@ -697,9 +682,8 @@ where
 
     // ── numeric literal ──────────────────────────────────────────────────
 
-    /// Zig: `parseNumericLiteralOrDot`. Spec lexer.zig:2736-2998 has NO is_json
-    /// gate on the radix-prefix integer-literal path (`0x…/0b…/0o…`/legacy
-    /// octal) or underscore separators, so they are accepted here too. Only the
+    /// Radix-prefix integer literals (`0x…/0b…/0o…`/legacy
+    /// octal) and underscore separators are accepted. Only the
     /// bigint `'n'` token is JS-only and left to the trailing
     /// `is_identifier_start` syntax error.
     fn parse_numeric_literal_or_dot(&mut self) -> LexResult {
@@ -813,8 +797,7 @@ where
                 }
 
                 // Filter out underscores;
-                // (Zig allocates a filtered buffer here but discards it; mirror
-                // the no-op semantics — `text` is reused below as-is.)
+                // (no-op here — `text` is reused below as-is.)
 
                 // Store bigints as text to avoid precision loss;
                 if is_bigint_literal {
@@ -969,7 +952,7 @@ where
         }
 
         // Handle bigint literals after the underscore-at-end check above;
-        // PORT NOTE: bigint `'n'` falls through to the identifier-start check
+        // bigint `'n'` falls through to the identifier-start check
         // below (T::TBigIntegerLiteral is JS-only and not in this token enum).
 
         // An identifier can't immediately follow a number.
@@ -982,7 +965,7 @@ where
 
     // ── identifier with escapes ──────────────────────────────────────────
 
-    /// Zig: `scanIdentifierWithEscapes(.normal)` (lexer.zig:875). Minimal port
+    /// Minimal identifier-with-escapes scanner
     /// for the JSON keyword set: scans `\uXXXX` / `\u{…}` escapes interleaved
     /// with identifier-continue codepoints, decodes via
     /// `decode_escape_sequences`, and maps the result to
@@ -1032,7 +1015,7 @@ where
         let utf8 = strings::to_utf8_alloc(&buf);
         let contents: &'a [u8] = self.bump.alloc_slice_copy(&utf8);
 
-        // PORT NOTE: full Unicode `isIdentifier` validation omitted — JSON only
+        // full Unicode `isIdentifier` validation omitted — JSON only
         // recognises `true`/`false`/`null`; anything else is `t_identifier`
         // and the parser will reject it.
         self.identifier = contents;
@@ -1047,7 +1030,7 @@ where
 
     // ── next ─────────────────────────────────────────────────────────────
 
-    /// Zig: `next()` with every `if (comptime is_json)` branch taken. Operators
+    /// Advance to the next token. Operators
     /// and JS-only punctuation hard-error; comments are gated on
     /// `opts.allow_comments`.
     pub(crate) fn next(&mut self) -> LexResult {
@@ -1239,8 +1222,7 @@ where
                         self.step();
                         continue;
                     }
-                    // Spec lexer.zig:1739-1750 — no is_json gate; scan an
-                    // identifier-with-escapes (e.g. `true` → t_true).
+                    // Scan an identifier-with-escapes (e.g. `true` → t_true).
                     self.scan_identifier_with_escapes()?;
                 }
 
@@ -1293,8 +1275,8 @@ where
                 // here aborts `Lexer::init` before `parse_env_json` gets a
                 // chance to auto-quote.
                 //
-                // They get a dedicated arm (not the catch-all) because the spec
-                // arms (lexer.zig `'('`/`')'`/`'?'`/`'*'`) all `step()` past the
+                // They get a dedicated arm (not the catch-all) because these
+                // arms must `step()` past the
                 // char, while the catch-all leaves `code_point` on `contents[0]`.
                 // The auto-quote retry rebuilds the lexer (same state) and then
                 // calls `parse_string_literal_inner::<0>()`, whose leading
@@ -1374,7 +1356,7 @@ fn is_identifier_start(cp: CodePoint) -> bool {
     matches!(cp, 0x24 /* $ */ | 0x5F /* _ */)
         || (cp >= 'a' as CodePoint && cp <= 'z' as CodePoint)
         || (cp >= 'A' as CodePoint && cp <= 'Z' as CodePoint)
-    // PORT NOTE: full Unicode ID_Start table omitted — JSON only ever
+    // full Unicode ID_Start table omitted — JSON only ever
     // recognises `true`/`false`/`null` here, all ASCII.
 }
 
@@ -1382,5 +1364,3 @@ fn is_identifier_start(cp: CodePoint) -> bool {
 fn is_identifier_continue(cp: CodePoint) -> bool {
     is_identifier_start(cp) || (cp >= '0' as CodePoint && cp <= '9' as CodePoint)
 }
-
-// ported from: src/js_parser/lexer.zig
diff --git a/src/parsers/lib.rs b/src/parsers/lib.rs
index 38f680922a8..e5fb1f707a7 100644
--- a/src/parsers/lib.rs
+++ b/src/parsers/lib.rs
@@ -2,8 +2,7 @@
 #![allow(unexpected_cfgs)]
 
 // ───── json_lexer ─────────────────────────────────────────────────────────
-// JSON-only subset of `bun_js_parser::js_lexer`, sliced from
-// `src/js_parser/lexer.zig` with `is_json = true` arms taken. Breaks the
+// JSON-only subset of `bun_js_parser::js_lexer`. Breaks the
 // GENUINE T4 cycle (`bun_js_parser` → `bun_interchange` → `bun_js_parser`)
 // so `json.rs` can build without an upward dep. See module doc-comment.
 // Crate-private: implementation detail of `json.rs`; no external consumers.
@@ -16,8 +15,8 @@ mod json_lexer;
 #[path = "json.rs"]
 pub mod json;
 
-/// Zig-side import path is `bun.json` (the parser module). Downstream Rust
-/// crates name it both `json` and `json_parser`; alias the latter here.
+/// Downstream Rust crates name it both `json` and `json_parser`; alias the
+/// latter here.
 pub use json as json_parser;
 
 // ───── json5 ──────────────────────────────────────────────────────────────
@@ -31,5 +30,3 @@ pub mod toml;
 // ───── yaml ───────────────────────────────────────────────────────────────
 #[path = "yaml.rs"]
 pub mod yaml;
-
-// ported from: src/interchange/interchange.zig
diff --git a/src/parsers/toml.rs b/src/parsers/toml.rs
index 549ab1223c0..d6b3a07148d 100644
--- a/src/parsers/toml.rs
+++ b/src/parsers/toml.rs
@@ -9,7 +9,6 @@ pub mod lexer;
 pub use self::lexer::Lexer;
 use self::lexer::T;
 
-// Zig: `js_ast.E.Object.Rope`. The MOVE_DOWN landed it at
 type Rope = js_ast::e::Rope;
 use js_ast::e::SetError;
 
@@ -19,8 +18,7 @@ use js_ast::e::SetError;
 
 pub struct TOML<'a> {
     pub lexer: Lexer<'a>,
-    // PORT NOTE: Zig also stores `log: *logger.Log` on the parser, but it is
-    // never read — all logging goes through `lexer.log`. Dropped here to avoid
+    // No separate `log` field — all logging goes through `lexer.log`, avoiding
     // a second `&mut Log` borrow overlapping `lexer.log`.
     pub bump: &'a Bump,
     pub stack_check: StackCheck,
@@ -33,7 +31,6 @@ impl<'a> TOML<'a> {
         log: &'a mut bun_ast::Log,
         redact_logs: bool,
     ) -> Result<TOML<'a>, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(TOML {
             lexer: Lexer::init(log, source_, bump, redact_logs)?,
             bump,
@@ -46,9 +43,7 @@ impl<'a> TOML<'a> {
         self.lexer.source
     }
 
-    // Zig: `fn e(_: *TOML, t: anytype, loc: logger.Loc) Expr` with a
-    // `@typeInfo(Type) == .pointer` auto-deref. In Rust the deref is implicit at
-    // call sites, so this collapses to a single generic forwarding to Expr::init.
+    // Single generic forwarding to Expr::init.
     pub fn e<D>(&self, t: D, loc: bun_ast::Loc) -> Expr
     where
         D: js_ast::ExprInit,
@@ -62,7 +57,6 @@ impl<'a> TOML<'a> {
         bump: &'a Bump,
         redact_logs: bool,
     ) -> Result<Expr, bun_core::Error> {
-        // TODO(port): narrow error set
         match source_.contents.len() {
             // This is to be consisntent with how disabled JS files are handled
             0 => {
@@ -74,17 +68,15 @@ impl<'a> TOML<'a> {
             _ => {}
         }
 
-        // PORT NOTE: Zig copies the `Source` by value (`source_.*`). The Rust
-        // `Lexer` borrows it (`&'a Source`) so `identifier`/`string_literal_slice`
-        // can point into `source.contents` for `'a` without a self-referential
-        // struct — no copy needed.
+        // The `Lexer` borrows the `Source` (`&'a Source`) so
+        // `identifier`/`string_literal_slice` can point into `source.contents`
+        // for `'a` without a self-referential struct — no copy needed.
         let mut parser = TOML::init(bump, source_, log, redact_logs)?;
 
         parser.run_parser()
     }
 
     pub fn parse_maybe_trailing_comma(&mut self, closer: T) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set
         self.lexer.expect(T::t_comma)?;
 
         if self.lexer.token == closer {
@@ -131,9 +123,8 @@ impl<'a> TOML<'a> {
 
     #[allow(clippy::mut_from_ref)]
     pub fn parse_key(&mut self, bump: &'a Bump) -> Result<&'a mut Rope, bun_core::Error> {
-        // TODO(port): lifetime — Zig returns `*Rope` allocated from `allocator`
-        // (a stack-fallback arena reset per-iteration). Here we allocate from the
-        // caller-provided bump and return `&mut Rope` borrowed from it.
+        // Allocate from the caller-provided bump and return `&mut Rope`
+        // borrowed from it.
         let rope: &mut Rope = bump.alloc(Rope {
             head: match self.parse_key_segment()? {
                 Some(seg) => seg,
@@ -167,7 +158,6 @@ impl<'a> TOML<'a> {
             }
             // SAFETY: `rope` points into `bump` and is live for this call; we are
             // the sole mutator. Raw pointers used to avoid stacked &mut reborrows.
-            // PORT NOTE: reshaped for borrowck
             unsafe {
                 rope = (*rope).append(seg, bump)?;
             }
@@ -184,11 +174,10 @@ impl<'a> TOML<'a> {
             .e_object()
             .expect("infallible: variant checked")
             .as_ptr();
-        // TODO(port): `head` aliases into `root.data`; using raw pointer to mirror
-        // the Zig `*E.Object` and sidestep overlapping &mut on `root`.
+        // SAFETY: `head` aliases into `root.data`; the raw pointer sidesteps
+        // overlapping &mut on `root`.
 
-        // PERF(port): was stack-fallback (std.heap.stackFallback(@sizeOf(Rope)*6)) —
-        // profile. Using the parser's bump directly.
+        // Uses the parser's bump directly.
         let key_allocator = self.bump;
 
         loop {
@@ -225,7 +214,6 @@ impl<'a> TOML<'a> {
                         .e_object()
                         .expect("infallible: variant checked")
                         .as_ptr();
-                    // PERF(port): was `stack.fixed_buffer_allocator.reset()` — profile
                 }
                 // child table array
                 T::t_open_bracket_double => {
@@ -263,7 +251,6 @@ impl<'a> TOML<'a> {
                         .e_object()
                         .expect("infallible: variant checked")
                         .as_ptr();
-                    // PERF(port): was `stack.fixed_buffer_allocator.reset()` — profile
                 }
                 _ => {
                     // SAFETY: `head` points to an E.Object inside `root` (or a
@@ -271,7 +258,6 @@ impl<'a> TOML<'a> {
                     unsafe {
                         self.parse_assignment(&mut *head, key_allocator)?;
                     }
-                    // PERF(port): was `stack.fixed_buffer_allocator.reset()` — profile
                 }
             }
         }
@@ -300,8 +286,8 @@ impl<'a> TOML<'a> {
                     let loc = rope.head.loc;
                     debug_assert!(loc.start > 0);
                     let start: u32 = u32::try_from(loc.start).expect("int cast");
-                    // std.ascii.whitespace = { ' ', '\t', '\n', '\r', 0x0B, 0x0C }
-                    // PORT NOTE: reshaped for borrowck — `self.source()` returns
+                    // ASCII whitespace: ' ', '\t', '\n', '\r', 0x0B, 0x0C.
+                    // Reshaped for borrowck — `self.source()` returns
                     // `&'a Source` (independent of `&self`), so bind it before
                     // the `&mut self.lexer` borrow below.
                     let src: &'a bun_ast::Source = self.source();
@@ -323,14 +309,10 @@ impl<'a> TOML<'a> {
     }
 
     pub fn parse_value(&mut self) -> Result<Expr, bun_core::Error> {
-        // Zig: `bun.throwStackOverflow()` guarded only by `StackCheck`. The
-        // Rust port previously added a hard depth cap because release-mode
-        // frames are smaller than Zig's (Zig didn't emit LLVM lifetime
-        // annotations, so `parse_value`'s frame was the union of all locals
-        // including the `stackFallback(@sizeOf(Rope)*6)` buffer; Rust's is
-        // just the live set). The cap was an artificial limit on a feature —
-        // the test's `depth = 25_000` was Zig-calibrated and is now bumped to
-        // a value that exhausts the 18 MB stack regardless of frame size.
+        // Recursion depth is guarded only by `StackCheck`. A previous hard
+        // depth cap was an artificial limit on a feature; the test's recursion
+        // depth is set to a value that exhausts the 18 MB stack regardless of
+        // frame size.
         if !self.stack_check.is_safe_to_recurse() {
             return Err(bun_core::err!("StackOverflow"));
         }
@@ -385,8 +367,6 @@ impl<'a> TOML<'a> {
             T::t_open_brace => {
                 self.lexer.next()?;
                 let mut is_single_line = !self.lexer.has_newline_before;
-                // PERF(port): was stack-fallback (std.heap.stackFallback(@sizeOf(Rope)*6)) —
-                // profile
                 let key_allocator = self.bump;
                 let expr = self.e(E::Object::default(), loc);
                 let obj: *mut E::Object = expr
@@ -394,7 +374,8 @@ impl<'a> TOML<'a> {
                     .e_object()
                     .expect("infallible: variant checked")
                     .as_ptr();
-                // TODO(port): `obj` aliases into `expr.data`; raw pointer mirrors Zig.
+                // SAFETY: `obj` aliases into `expr.data`; the raw pointer
+                // sidesteps overlapping &mut on `expr`.
 
                 while self.lexer.token != T::t_close_brace {
                     // SAFETY: `obj` points into the AST store and is live here.
@@ -414,7 +395,6 @@ impl<'a> TOML<'a> {
                         self.parse_assignment(&mut *obj, key_allocator)?;
                     }
                     self.lexer.allow_double_bracket = false;
-                    // PERF(port): was `stack.fixed_buffer_allocator.reset()` — profile
                 }
 
                 if self.lexer.has_newline_before {
@@ -439,7 +419,8 @@ impl<'a> TOML<'a> {
                     .e_array()
                     .expect("infallible: variant checked")
                     .as_ptr();
-                // TODO(port): `array` aliases into `array_.data`; raw pointer mirrors Zig.
+                // SAFETY: `array` aliases into `array_.data`; the raw pointer
+                // sidesteps overlapping &mut on `array_`.
                 let bump = self.bump;
                 self.lexer.allow_double_bracket = false;
 
@@ -481,5 +462,3 @@ impl<'a> TOML<'a> {
         }
     }
 }
-
-// ported from: src/interchange/toml.zig
diff --git a/src/parsers/toml/lexer.rs b/src/parsers/toml/lexer.rs
index be445c66a06..53959f034f6 100644
--- a/src/parsers/toml/lexer.rs
+++ b/src/parsers/toml/lexer.rs
@@ -4,12 +4,11 @@ use bun_ast as js_ast;
 use bun_ast::LexerLog;
 use bun_core::fmt::hex_digit_value_u32;
 use bun_core::strings;
-// In Zig it's `bun.CodePoint` (i32); lives at `bun_core::strings::CodePoint`.
 use bun_core::strings::CodePoint;
 
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, strum::IntoStaticStr)]
-#[allow(non_camel_case_types)] // PORTING.md: "Match the Zig's structure" — Zig: `t_end_of_file`.
+#[allow(non_camel_case_types)]
 pub enum T {
     t_end_of_file,
 
@@ -47,11 +46,10 @@ pub enum T {
 }
 
 pub struct Lexer<'a> {
-    // PORT NOTE: borrowed (`&'a Source`) rather than owned so
+    // Borrowed (`&'a Source`) rather than owned so
     // `identifier`/`string_literal_slice` can borrow `&'a [u8]` from
-    // `source.contents` without a self-referential struct. The Zig original
-    // copied `Source` by value because Zig has no borrow checker; the Rust
-    // `bun_ast::Source.contents` is now `Cow<'static,[u8]>` so an owned copy
+    // `source.contents` without a self-referential struct.
+    // `bun_ast::Source.contents` is `Cow<'static,[u8]>` so an owned copy
     // would tie those slices to `&self` instead of `'a`.
     pub source: &'a bun_ast::Source,
     pub log: &'a mut bun_ast::Log,
@@ -291,7 +289,7 @@ impl<'a> Lexer<'a> {
                             i += 1;
                         }
                     }
-                    // PORT NOTE: Zig discards `bytes` here (dead store); ported faithfully.
+                    // `bytes` is intentionally discarded here.
                 }
 
                 // Store bigints as text to avoid precision loss;
@@ -429,7 +427,6 @@ impl<'a> Lexer<'a> {
             // Filter out underscores;
             if underscore_count > 0 {
                 let mut i: usize = 0;
-                // PORT NOTE: Zig handled OOM via if/else on allocator.alloc; arena alloc here is infallible.
                 let bytes = self
                     .bump
                     .alloc_slice_fill_default::<u8>(text.len() - underscore_count);
@@ -467,7 +464,6 @@ impl<'a> Lexer<'a> {
 
     #[inline]
     pub fn expect(&mut self, token: T) -> Result<(), Error> {
-        // PERF(port): was comptime monomorphization (`comptime token: T`) — profile
         if self.token != token {
             self.expected(token)?;
         }
@@ -710,8 +706,8 @@ impl<'a> Lexer<'a> {
                         }
                     }
 
-                    // PORT NOTE: reshaped for borrowck — capture slice bounds as indices
-                    // instead of laundering a `&'a [u8]` through a raw pointer. On the fast
+                    // Capture the slice bounds as indices instead of laundering
+                    // a `&'a [u8]` through a raw pointer. On the fast
                     // path we reslice immediately before `return`; on the slow path we
                     // reslice after the loop and hand it straight to
                     // `decode_escape_sequences` without stashing in `self` first.
@@ -864,9 +860,6 @@ impl<'a> Lexer<'a> {
         text: &[u8],
         buf: &mut bun_alloc::ArenaVec<'a, u8>,
     ) -> Result<(), Error> {
-        // PORT NOTE: Zig copied `*buf_` into a local and `defer`-wrote it back.
-        // In Rust we operate on `buf` directly via &mut.
-
         let iterator = strings::CodepointIterator::init(text);
         let mut iter = strings::Cursor::default();
         while iterator.next(&mut iter) {
@@ -915,10 +908,6 @@ impl<'a> Lexer<'a> {
                         c if c == 'v' as CodePoint => {
                             // Vertical tab is invalid JSON
                             // We're going to allow it.
-                            // if (comptime is_json) {
-                            //     lexer.end = start + iter.i - width2;
-                            //     try lexer.syntaxError();
-                            // }
                             buf.push(11);
                             continue;
                         }
@@ -1117,7 +1106,6 @@ impl<'a> Lexer<'a> {
                                 // fixed-length
                             } else {
                                 // Fixed-length
-                                // comptime var j: usize = 0;
                                 let mut j: usize = 0;
                                 while j < 4 {
                                     match hex_digit_value_u32(c3 as u32) {
@@ -1210,7 +1198,7 @@ impl<'a> Lexer<'a> {
             }
         };
 
-        // PORT NOTE: reshaped for borrowck — compute range before borrowing `found` from source.
+        // Compute the range before borrowing `found` from source.
         let range = self.range();
         self.add_range_error(range, format_args!("Unexpected {}", bstr::BStr::new(found)))
     }
@@ -1238,7 +1226,7 @@ impl<'a> Lexer<'a> {
     pub fn range(&self) -> bun_ast::Range {
         bun_ast::Range {
             loc: bun_ast::usize2loc(self.start),
-            len: (self.end - self.start) as i32, // std.math.lossyCast
+            len: (self.end - self.start) as i32,
         }
     }
 
@@ -1297,13 +1285,10 @@ pub(crate) fn is_identifier_part(code_point: CodePoint) -> bool {
         | '-'
         | ':'
     ) && (0..=127).contains(&code_point)
-    // PORT NOTE: Zig matched CodePoint directly against char ranges; Rust requires
-    // bounding to ASCII before the byte cast above is sound.
+    // The `(0..=127)` bound is required for the byte cast above to be sound.
 }
 
 #[inline]
 fn float64(num: CodePoint) -> f64 {
     num as f64
 }
-
-// ported from: src/interchange/toml/lexer.zig
diff --git a/src/parsers/yaml.rs b/src/parsers/yaml.rs
index 9e4ccf975ee..dbff81069ea 100644
--- a/src/parsers/yaml.rs
+++ b/src/parsers/yaml.rs
@@ -1,14 +1,11 @@
-//! YAML parser ported from src/interchange/yaml.zig
+//! YAML parser.
 //!
-//! NOTE ON GENERICITY: Zig's `Parser(comptime enc: Encoding)` returns a type whose
-//! `enc.unit()` is `u8` or `u16`. Rust const generics cannot return types, so this
-//! port models `Encoding` as a trait with an associated `Unit` type, and `Parser<Enc>`
-//! is generic over `Enc: Encoding`.
+//! `Encoding` is modeled as a trait with an associated `Unit` type (`u8` or
+//! `u16`), and `Parser<Enc>` is generic over `Enc: Encoding`.
 //!
-//! NOTE ON LABELED SWITCH: Zig's `label: switch (x) { ... continue :label y; }` is a
-//! state-machine loop. These are ported as `let mut __c = x; loop { match __c { ... } }`
-//! with `__c = y; continue;` for `continue :label y`. Each is marked
-//! `// PORT NOTE: labeled-switch loop`.
+//! Several scanners are state-machine loops written as
+//! `let mut __c = x; loop { match __c { ... } }` with `__c = y; continue;`.
+//! Each is marked `// labeled-switch loop`.
 
 use core::cmp::Ordering;
 use core::fmt;
@@ -31,7 +28,6 @@ impl YAML {
         log: &mut bun_ast::Log,
         bump: &bun_alloc::Arena,
     ) -> Result<Expr, YamlParseError> {
-        // Zig: `bun.analytics.Features.yaml_parse += 1;`
         bun_core::analytics::Features::yaml_parse_inc();
 
         let mut parser: Parser<Utf8> = Parser::init(bump, source.contents());
@@ -56,7 +52,6 @@ impl YAML {
                     ast::ExprNodeList::init_capacity(stream.docs.len());
                 for doc in &stream.docs {
                     items.push(doc.root);
-                    // PERF(port): was appendAssumeCapacity
                 }
                 Ok(Expr::init(
                     E::Array {
@@ -83,11 +78,8 @@ pub enum YamlParseError {
 bun_core::oom_from_alloc!(YamlParseError);
 
 impl From<YamlParseError> for bun_core::Error {
-    // PORT NOTE: Zig `YAML.ParseError` is an `error{...}` set, so callers
-    // (e.g. `try YAML.parse(...)` in `ParseTask.getAST`) coerce it into the
-    // wider inferred error union. Mirror that by mapping each variant to its
-    // Zig-tag string via `bun.err!`, the same shape `json5::ExternalError`
-    // uses one file over.
+    // Map each variant to its tag string via `bun.err!`, the same shape
+    // `json5::ExternalError` uses one file over.
     fn from(e: YamlParseError) -> Self {
         match e {
             YamlParseError::OutOfMemory => bun_core::err!("OutOfMemory"),
@@ -101,7 +93,10 @@ impl From<YamlParseError> for bun_core::Error {
 // Top-level free functions
 // ───────────────────────────────────────────────────────────────────────────
 
-pub fn parse<Enc: Encoding>(bump: &bun_alloc::Arena, input: &[Enc::Unit]) -> ParseResult<Enc> {
+pub fn parse<'i, Enc: Encoding>(
+    bump: &'i bun_alloc::Arena,
+    input: &'i [Enc::Unit],
+) -> ParseResult<'i, Enc> {
     let mut parser: Parser<Enc> = Parser::init(bump, input);
 
     match parser.parse() {
@@ -110,12 +105,8 @@ pub fn parse<Enc: Encoding>(bump: &bun_alloc::Arena, input: &[Enc::Unit]) -> Par
     }
 }
 
-pub fn print<Enc: Encoding, W: fmt::Write>(stream: Stream<Enc>, writer: &mut W) -> fmt::Result {
-    // Zig body (yaml.zig:44-53) constructs `Parser(encoding).Printer(@TypeOf(writer))`
-    // and calls `printer.print()`. The `Printer` type is commented out in the spec
-    // (yaml.zig:4927-5250) and operates on the removed `Node` enum, so any Zig
-    // call to `print()` is a compile error on instantiation. Rust eagerly checks
-    // generics, so we cannot mirror that; instead this is a hard panic on the
+pub fn print<Enc: Encoding, W: fmt::Write>(stream: Stream<'_, Enc>, writer: &mut W) -> fmt::Result {
+    // The printer was never implemented; this is a hard panic on the
     // (currently unreachable — `rg yaml::print src/` has no callers) path.
     let _ = (stream, writer);
     panic!(
@@ -271,8 +262,7 @@ impl IndentIndicator {
             7 => IndentIndicator::N7,
             8 => IndentIndicator::N8,
             9 => IndentIndicator::N9,
-            // Zig's safety-checked `@enumFromInt` traps on out-of-range; the
-            // only caller (`read_indentation_indicator`) passes `digit - b'0'`
+            // The only caller (`read_indentation_indicator`) passes `digit - b'0'`
             // after a `b'1'..=b'9'` guard, so this arm is unreachable.
             _ => panic!("invalid IndentIndicator"),
         }
@@ -393,11 +383,8 @@ impl Line {
     }
 }
 
-// Zig: comptime { bun.assert(Pos != Indent); ... } — type-distinctness checks.
-// Rust newtypes are already distinct; nothing to assert.
-
 // ───────────────────────────────────────────────────────────────────────────
-// Encoding trait (replaces Zig `Encoding` enum + `enc.unit()` type fn)
+// Encoding trait
 // ───────────────────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -407,11 +394,10 @@ pub enum EncodingKind {
     Utf16,
 }
 
-/// Stack buffer for an ASCII literal widened to `Enc::Unit`. Replaces Zig's
-/// `enc.literal("...")` (a `comptime` utf8→utf16 transcode via
-/// `std.unicode.utf8ToUtf16LeStringLiteral`). Rust cannot do const transcoding
-/// behind a trait method, so the literal is widened at the call site into this
-/// inline buffer instead. All call sites in this file pass ≤4-byte ASCII; the
+/// Stack buffer for an ASCII literal widened to `Enc::Unit`. Rust cannot do
+/// const transcoding behind a trait method, so the literal is widened at the
+/// call site into this inline buffer instead.
+/// All call sites in this file pass ≤4-byte ASCII; the
 /// cap of 8 leaves headroom for new literals.
 #[derive(Clone, Copy)]
 pub struct EncLit<U: Copy + Default> {
@@ -441,7 +427,7 @@ impl<U: Copy + Default> AsRef<[U]> for EncLit<U> {
     }
 }
 
-/// Trait modeling Zig's `Encoding` comptime enum where `unit()` returns a type.
+/// Code-unit encoding of the parser input; `Unit` is `u8` or `u16`.
 pub trait Encoding: Copy + 'static {
     type Unit: Copy + Eq + Ord + Default + fmt::Debug + Into<u32> + 'static;
 
@@ -458,19 +444,17 @@ pub trait Encoding: Copy + 'static {
         u.into()
     }
 
-    /// `enc.literal("...")` — Zig's comptime string literal in the target
-    /// encoding. Callers pass ASCII only; widened into an inline `EncLit`
-    /// buffer (see `EncLit` doc for the const-generics rationale).
+    /// A string literal in the target encoding. Callers pass ASCII only;
+    /// widened into an inline `EncLit` buffer (see `EncLit` doc for the
+    /// const-generics rationale).
     fn literal(s: &'static [u8]) -> EncLit<Self::Unit>;
 
     /// Number of leading units to skip if `input` starts with [3] c-byte-order-mark.
     fn bom_len(input: &[Self::Unit]) -> usize;
 
     /// Reinterpret a `&[Unit]` slice as `&[u8]` for `StringHashMap` keying
-    /// (`anchors` / `tag_handles`). Zig's `bun.StringHashMap` is keyed by
-    /// `[]const u8`; calls like `tag_handles.put(handle.slice(self.input), {})`
-    /// only type-check there for `unit() == u8` thanks to lazy generic
-    /// instantiation. Rust eagerly checks generics, so we route through this
+    /// (`anchors` / `tag_handles`). `StringHashMap` is keyed by `&[u8]`, so we
+    /// route through this
     /// method — identity for `u8` encodings, byte-reinterpret (`len * 2`) for
     /// `Utf16`. Byte-reinterpret preserves key uniqueness; do **not** use this
     /// for text (see `NodeScalar::to_expr` for the encoding-aware string path).
@@ -478,9 +462,7 @@ pub trait Encoding: Copy + 'static {
 
     /// Construct a Unit from a `u16` code unit. Only meaningful for `Utf16`
     /// (identity); the `u8` encodings mark this `unreachable!()` because every
-    /// call site is gated on `Enc::KIND == EncodingKind::Utf16`. Mirrors Zig's
-    /// `text.append(@intCast(cp))` paths in `scanDoubleQuotedScalar` /
-    /// `decodeHexCodePoint` where `unit() == u16`.
+    /// call site is gated on `Enc::KIND == EncodingKind::Utf16`.
     fn unit_from_u16(u: u16) -> Self::Unit;
 
     /// Reinterpret `&[Unit]` as `&[u16]`. Identity for `Utf16`; the `u8`
@@ -577,8 +559,7 @@ impl Encoding for Utf16 {
     }
     #[inline]
     fn literal(s: &'static [u8]) -> EncLit<u16> {
-        // Zig: `std.unicode.utf8ToUtf16LeStringLiteral` (comptime). All call
-        // sites pass ASCII, so widen byte-by-byte into the inline buffer.
+        // All call sites pass ASCII, so widen byte-by-byte into the inline buffer.
         debug_assert!(s.len() <= 8, "Enc::literal: bump EncLit cap");
         let mut buf = [0u16; 8];
         let mut i = 0;
@@ -614,7 +595,7 @@ impl Encoding for Utf16 {
 }
 
 // ───────────────────────────────────────────────────────────────────────────
-// chars — character classification (Zig: `Encoding.chars()` returned a type)
+// chars — character classification
 // ───────────────────────────────────────────────────────────────────────────
 
 pub mod chars {
@@ -846,8 +827,8 @@ impl StringRange {
     }
 }
 
-// PORT NOTE: reshaped for borrowck — Zig captured `parser.pos` lazily via a
-// pointer field; in Rust that pins an immutable borrow across mutating scans.
+// Capturing `parser.pos` lazily via a pointer field would pin an immutable
+// borrow across mutating scans.
 // Capture only `off` and have callers pass the end `Pos` explicitly.
 #[derive(Clone, Copy)]
 pub struct StringRangeStart {
@@ -861,6 +842,7 @@ impl StringRangeStart {
     }
 }
 
+#[derive(Clone)]
 pub enum YamlString<Enc: Encoding> {
     Range(StringRange),
     List(Vec<Enc::Unit>),
@@ -900,16 +882,16 @@ impl<Enc: Encoding> YamlString<Enc> {
     }
 }
 
-// `String.Builder` — owns a back-reference into the parser. The Zig code stored
-// `parser: *Parser(enc)` and mutated `parser.whitespace_buf`. In Rust this is a
-// borrow-checker hazard (the builder borrows `&mut Parser` while the parser also
-// drives scanning). We keep a raw pointer with SAFETY notes.
-// TODO(port): refactor whitespace_buf out of Parser or pass &mut explicitly.
+// `String.Builder` — owns a back-reference into the parser and mutates
+// `parser.whitespace_buf`. A `&mut Parser` field would be a borrow-checker
+// hazard (the builder borrows `&mut Parser` while the parser also drives
+// scanning). We keep a raw pointer with SAFETY notes.
+// TODO: refactor whitespace_buf out of Parser or pass &mut explicitly.
 pub struct StringBuilder<'a, Enc: Encoding> {
-    // PORT NOTE: a `&'a mut Parser<'a, Enc>` field would tie the borrow lifetime
+    // a `&'a mut Parser<'a, Enc>` field would tie the borrow lifetime
     // to Parser's input lifetime (invariant under &mut), which both fails
-    // borrowck at `string_builder()` and is exactly the aliasing the Zig already
-    // had. Use a raw backref (the LIFETIMES.tsv BACKREF resolution).
+    // borrowck at `string_builder()`.
+    // Use a raw backref (the LIFETIMES.tsv BACKREF resolution).
     // Private — invariant-bearing raw backref; reach via `parser()`/`parser_mut()`.
     parser: *mut Parser<'a, Enc>,
     pub str: YamlString<Enc>,
@@ -962,7 +944,7 @@ impl<'a, Enc: Encoding> StringBuilder<'a, Enc> {
     }
 
     fn drain_whitespace(&mut self) -> Result<(), AllocError> {
-        // PORT NOTE: reshaped for borrowck — take ownership of buf, process, clear.
+        // reshaped for borrowck — take ownership of buf, process, clear.
         let buf = core::mem::take(&mut self.parser_mut().whitespace_buf);
         let input = self.input();
         for ws in &buf {
@@ -986,7 +968,6 @@ impl<'a, Enc: Encoding> StringBuilder<'a, Enc> {
                         let mut list: Vec<Enc::Unit> = Vec::with_capacity(range.len() + 1);
                         list.extend_from_slice(range.slice(input));
                         list.push(*unit);
-                        // PERF(port): was assume_capacity
                         self.str = YamlString::List(list);
                     }
                     YamlString::List(list) => list.push(*unit),
@@ -1080,7 +1061,6 @@ impl<'a, Enc: Encoding> StringBuilder<'a, Enc> {
                 let mut list: Vec<Enc::Unit> = Vec::with_capacity(range.len() + 1);
                 list.extend_from_slice(range.slice(input));
                 list.push(unit);
-                // PERF(port): was assume_capacity
                 self.str = YamlString::List(list);
             }
             YamlString::List(list) => list.push(unit),
@@ -1099,7 +1079,6 @@ impl<'a, Enc: Encoding> StringBuilder<'a, Enc> {
                 let mut list: Vec<Enc::Unit> = Vec::with_capacity(range.len() + s.len());
                 list.extend_from_slice(range.slice(input));
                 list.extend_from_slice(s);
-                // PERF(port): was assume_capacity
                 self.str = YamlString::List(list);
             }
             YamlString::List(list) => list.extend_from_slice(s),
@@ -1147,10 +1126,8 @@ pub enum FirstChar {
     Other,
 }
 
-// PORT NOTE: Zig defined this inline inside scanPlainScalar. Hoisted to module
-// scope so methods can be `impl`'d. `parser` is `*mut` because the outer
-// `&mut self` in scan_plain_scalar drives scanning concurrently — see
-// LIFETIMES.tsv BACKREF.
+// `parser` is `*mut` because the outer `&mut self` in scan_plain_scalar
+// drives scanning concurrently — see LIFETIMES.tsv BACKREF.
 pub struct ScalarResolverCtx<'i, Enc: Encoding> {
     pub str_builder: StringBuilder<'i, Enc>,
 
@@ -1291,8 +1268,6 @@ impl<'i, Enc: Encoding> ScalarResolverCtx<'i, Enc> {
         self.str_builder.append_whitespace_n_times(unit, n)
     }
 
-    // PORT NOTE: Zig `Keywords` enum (yaml.zig:1862-1887) was unused; not ported.
-
     pub fn resolve(
         &mut self,
         scalar: NodeScalar<Enc>,
@@ -1503,7 +1478,7 @@ impl<'i, Enc: Encoding> ScalarResolverCtx<'i, Enc> {
 
         let mut first = true;
 
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         let mut __c = Enc::wide(parser!().next());
         let (end, valid): (Pos, bool) = 'end: loop {
             match __c {
@@ -1765,8 +1740,8 @@ fn parse_double_generic<Enc: Encoding>(s: &[Enc::Unit]) -> Result<f64, ()> {
     }
 }
 
-/// Port of `std.fmt.parseUnsigned(u64, slice, 0)` over an encoding-generic
-/// slice. Radix 0 = auto-detect `0x`/`0X` (hex), `0o`/`0O` (oct), `0b`/`0B`
+/// Parses a `u64` from an encoding-generic slice with radix
+/// auto-detection: `0x`/`0X` (hex), `0o`/`0O` (oct), `0b`/`0B`
 /// (bin), else decimal; `_` is a digit separator. Utf8/Latin1 narrow via
 /// `Enc::key_bytes`; Utf16 narrows via [`bun_core::strings::narrow_ascii_u16`].
 fn parse_unsigned_radix0<Enc: Encoding>(s: &[Enc::Unit]) -> Result<u64, ()> {
@@ -1826,6 +1801,7 @@ impl NodeTag {
     }
 }
 
+#[derive(Clone)]
 pub enum NodeScalar<Enc: Encoding> {
     Null,
     Boolean(bool),
@@ -1840,20 +1816,14 @@ impl<Enc: Encoding> NodeScalar<Enc> {
             NodeScalar::Boolean(value) => Expr::init(E::Boolean { value: *value }, pos.loc()),
             NodeScalar::Number(value) => Expr::init(E::Number { value: *value }, pos.loc()),
             NodeScalar::String(value) => {
-                // Zig: `.init(E.String, .{ .data = value.slice(input) }, pos.loc())`.
-                // `E.String.data` is `[]const u8`, so the Zig source only
-                // type-checks for `unit() == u8`. For `Utf16` we route through
-                // `E::String::init_utf16` instead of mirroring the Zig compile
-                // error (Rust eagerly monomorphizes).
+                // For `Utf16` we route through `E::String::init_utf16`.
                 //
-                // LIFETIME: Zig's `String.list` is `array_list.Managed` backed
-                // by `parser.allocator` (the bump arena), so `list.items`
-                // outlives the scalar token. The Rust port uses a global-alloc
-                // `Vec` that is dropped with the local `scalar` immediately
-                // after this returns — the resulting `EString.data` would
-                // dangle. Dupe `.list` bytes into the bump arena to recover the
-                // Zig lifetime; `.range` already borrows `input` (source text)
-                // which outlives the Expr → JS conversion.
+                // LIFETIME: `YamlString::List` is a global-alloc `Vec` that is
+                // dropped with the local `scalar` immediately after this
+                // returns — the resulting `EString.data` would dangle. Dupe
+                // the list bytes into the bump arena; `.range` already borrows
+                // `input` (source text) which outlives the Expr → JS
+                // conversion.
                 let s: &[Enc::Unit] = match value {
                     YamlString::Range(range) => range.slice(input),
                     YamlString::List(list) => bump.alloc_slice_copy(list.as_slice()),
@@ -1917,10 +1887,59 @@ pub struct Document {
 
 // impl Drop for Document — Vec<Directive> auto-drops; Expr is arena-backed.
 
-pub struct Stream<Enc: Encoding> {
+/// Should only be used with expressions created with the YAML parser. It assumes
+/// only null, boolean, number, string, array, object are possible. It also only
+/// does pointer comparison with arrays and objects (so exponential merges are avoided).
+/// Operates on already-built `Expr`s, so it is independent of the input encoding.
+fn yaml_merge_key_expr_eql(l: &Expr, r: &Expr) -> bool {
+    if core::mem::discriminant(&l.data) != core::mem::discriminant(&r.data) {
+        return false;
+    }
+    match (&l.data, &r.data) {
+        (ast::ExprData::ENull(_), _) => true,
+        (ast::ExprData::EBoolean(lb), ast::ExprData::EBoolean(rb)) => lb.value == rb.value,
+        (ast::ExprData::ENumber(ln), ast::ExprData::ENumber(rn)) => ln.value == rn.value,
+        (ast::ExprData::EString(ls), ast::ExprData::EString(rs)) => {
+            // UTF-8/UTF-16-aware string equality.
+            if ls.is_utf16 != rs.is_utf16 {
+                if ls.is_utf16 {
+                    rs.eql_bytes(ls.data.slice())
+                } else {
+                    ls.eql_bytes(rs.data.slice())
+                }
+            } else if ls.is_utf16 {
+                ls.slice16() == rs.slice16()
+            } else {
+                ls.data == rs.data
+            }
+        }
+        // pointer comparison
+        (ast::ExprData::EArray(la), ast::ExprData::EArray(ra)) => la.as_ptr() == ra.as_ptr(),
+        (ast::ExprData::EObject(lo), ast::ExprData::EObject(ro)) => lo.as_ptr() == ro.as_ptr(),
+        _ => false,
+    }
+}
+
+/// Encoding-independent companion to [`yaml_merge_key_expr_eql`].
+fn yaml_merge_key_expr_hash(key: &Expr) -> u64 {
+    match &key.data {
+        ast::ExprData::ENull(_) => 0,
+        ast::ExprData::EBoolean(b) => 1 + b.value as u64,
+        ast::ExprData::ENumber(n) => {
+            let value = if n.value == 0.0 { 0.0 } else { n.value };
+            value.to_bits()
+        }
+        ast::ExprData::EString(s) => s.hash(),
+        ast::ExprData::EArray(a) => a.as_ptr() as usize as u64,
+        ast::ExprData::EObject(o) => o.as_ptr() as usize as u64,
+        _ => u64::MAX,
+    }
+}
+
+pub struct Stream<'i, Enc: Encoding> {
     pub docs: Vec<Document>,
-    pub input: *const [Enc::Unit],
-    // TODO(port): lifetime — Zig stored `[]const enc.unit()` borrowing parser input.
+    /// Borrows the parser input.
+    pub input: &'i [Enc::Unit],
 }
 
 // ───────────────────────────────────────────────────────────────────────────
@@ -1934,6 +1953,9 @@ pub struct TokenInit {
     pub line: Line,
 }
 
+// `Clone` deep-copies the `Vec` inside `YamlString::List`, which is fine for
+// the read-only uses here.
+#[derive(Clone)]
 pub struct Token<Enc: Encoding> {
     pub start: Pos,
     pub indent: Indent,
@@ -1941,20 +1963,7 @@ pub struct Token<Enc: Encoding> {
     pub data: TokenData<Enc>,
 }
 
-impl<Enc: Encoding> Clone for Token<Enc> {
-    fn clone(&self) -> Self {
-        // TODO(port): TokenData contains NodeScalar<Enc> which holds a Vec for
-        // String::List. Zig copied tokens by value (struct copy). TODO(port):
-        // make Token cheaply-copyable or store scalars by index.
-        Token {
-            start: self.start,
-            indent: self.indent,
-            line: self.line,
-            data: self.data.clone(),
-        }
-    }
-}
-
+#[derive(Clone)]
 pub enum TokenData<Enc: Encoding> {
     Eof,
     /// `-`
@@ -1992,61 +2001,7 @@ pub enum TokenData<Enc: Encoding> {
     Scalar(TokenScalar<Enc>),
 }
 
-impl<Enc: Encoding> Clone for TokenData<Enc> {
-    fn clone(&self) -> Self {
-        // TODO(port): see Token::clone note
-        match self {
-            TokenData::Eof => TokenData::Eof,
-            TokenData::SequenceEntry => TokenData::SequenceEntry,
-            TokenData::MappingKey => TokenData::MappingKey,
-            TokenData::MappingValue => TokenData::MappingValue,
-            TokenData::CollectEntry => TokenData::CollectEntry,
-            TokenData::SequenceStart => TokenData::SequenceStart,
-            TokenData::SequenceEnd => TokenData::SequenceEnd,
-            TokenData::MappingStart => TokenData::MappingStart,
-            TokenData::MappingEnd => TokenData::MappingEnd,
-            TokenData::Anchor(r) => TokenData::Anchor(*r),
-            TokenData::Alias(r) => TokenData::Alias(*r),
-            TokenData::Tag(t) => TokenData::Tag(*t),
-            TokenData::Directive => TokenData::Directive,
-            TokenData::Reserved => TokenData::Reserved,
-            TokenData::DocumentStart => TokenData::DocumentStart,
-            TokenData::DocumentEnd => TokenData::DocumentEnd,
-            TokenData::Scalar(_) => {
-                // TODO(port): Scalar contains a Vec; Zig copied by value. Reshape to make it Copy.
-                unreachable!("Token<Scalar> should not be cloned")
-            }
-        }
-    }
-}
-
-impl<Enc: Encoding> TokenData<Enc> {
-    pub fn discriminant(&self) -> u8 {
-        // SAFETY: #[repr(...)] not declared; use mem::discriminant for comparisons instead.
-        // This helper exists only for the labeled-switch-loop ports below.
-        // TODO(port): replace with core::mem::discriminant comparisons.
-        match self {
-            TokenData::Eof => 0,
-            TokenData::SequenceEntry => 1,
-            TokenData::MappingKey => 2,
-            TokenData::MappingValue => 3,
-            TokenData::CollectEntry => 4,
-            TokenData::SequenceStart => 5,
-            TokenData::SequenceEnd => 6,
-            TokenData::MappingStart => 7,
-            TokenData::MappingEnd => 8,
-            TokenData::Anchor(_) => 9,
-            TokenData::Alias(_) => 10,
-            TokenData::Tag(_) => 11,
-            TokenData::Directive => 12,
-            TokenData::Reserved => 13,
-            TokenData::DocumentStart => 14,
-            TokenData::DocumentEnd => 15,
-            TokenData::Scalar(_) => 16,
-        }
-    }
-}
-
+#[derive(Clone)]
 pub struct TokenScalar<Enc: Encoding> {
     pub data: NodeScalar<Enc>,
     pub multiline: bool,
@@ -2221,13 +2176,13 @@ impl<Enc: Encoding> Token<Enc> {
 // ParseResult
 // ───────────────────────────────────────────────────────────────────────────
 
-pub enum ParseResult<Enc: Encoding> {
-    Result(ParseResultOk<Enc>),
+pub enum ParseResult<'i, Enc: Encoding> {
+    Result(ParseResultOk<'i, Enc>),
     Err(ParseResultError),
 }
 
-pub struct ParseResultOk<Enc: Encoding> {
-    pub stream: Stream<Enc>,
+pub struct ParseResultOk<'i, Enc: Encoding> {
+    pub stream: Stream<'i, Enc>,
     // allocator dropped — global mimalloc
 }
 
@@ -2314,12 +2269,12 @@ impl ParseResultError {
     }
 }
 
-impl<Enc: Encoding> ParseResult<Enc> {
-    pub fn success(stream: Stream<Enc>, _parser: &Parser<Enc>) -> Self {
+impl<'i, Enc: Encoding> ParseResult<'i, Enc> {
+    pub fn success(stream: Stream<'i, Enc>, _parser: &Parser<'_, Enc>) -> Self {
         ParseResult::Result(ParseResultOk { stream })
     }
 
-    pub fn fail(err: ParseError, parser: &Parser<Enc>) -> Self {
+    pub fn fail(err: ParseError, parser: &Parser<'_, Enc>) -> Self {
         let e = match err {
             ParseError::OutOfMemory => ParseResultError::Oom,
             ParseError::StackOverflow => ParseResultError::StackOverflow,
@@ -2407,7 +2362,7 @@ pub struct Parser<'i, Enc: Encoding> {
     pub line: Line,
     pub token: Token<Enc>,
 
-    /// Zig `parser.allocator`. Growable buffers in this port use the global
+    /// Growable buffers use the global
     /// allocator (and `Drop`); the arena is threaded for the few places that
     /// must hand a borrowed slice into the long-lived `Expr` tree (see
     /// `NodeScalar::to_expr`).
@@ -2472,7 +2427,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         ParseError::UnexpectedToken
     }
 
-    pub fn parse(&mut self) -> Result<Stream<Enc>, ParseError> {
+    pub fn parse(&mut self) -> Result<Stream<'i, Enc>, ParseError> {
         self.scan(ScanOptions {
             first_scan: true,
             ..Default::default()
@@ -2480,7 +2435,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         self.parse_stream()
     }
 
-    pub fn parse_stream(&mut self) -> Result<Stream<Enc>, ParseError> {
+    pub fn parse_stream(&mut self) -> Result<Stream<'i, Enc>, ParseError> {
         let mut docs: Vec<Document> = Vec::new();
 
         // we want one null document if eof, not zero documents.
@@ -2493,11 +2448,10 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         Ok(Stream {
             docs,
-            input: std::ptr::from_ref::<[Enc::Unit]>(self.input),
+            input: self.input,
         })
     }
 
-    // PERF(port): was comptime monomorphization — profile
     fn peek(&self, n: usize) -> Enc::Unit {
         let pos = self.pos.add(n);
         if pos.is_less_than(self.input.len()) {
@@ -2654,7 +2608,6 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
     pub fn parse_document(&mut self) -> Result<Document, ParseError> {
         let mut directives: Vec<Directive> = Vec::new();
 
-        // Zig: `clearRetainingCapacity()` — `HashMap::clear()` already retains capacity.
         self.anchors.clear();
         self.tag_handles.clear();
 
@@ -2822,10 +2775,9 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         self.context.set(Context::FlowIn)?;
 
-        // PORT NOTE: Zig `defer self.context.unset(.flow_in)` — capture the
-        // fallible body's result and unset on EVERY exit (including `?` paths).
-        // The post-`]` scan happens AFTER `.flow_in` is popped (yaml.zig:771),
-        // so only the loop body lives inside the closure.
+        // Capture the fallible body's result and unset `FlowIn` on EVERY exit
+        // (including `?` paths). The post-`]` scan happens AFTER `FlowIn` is
+        // popped, so only the loop body lives inside the closure.
         let result: Result<(), ParseError> = (|| {
             self.scan(ScanOptions::default())?;
             while !matches!(self.token.data, TokenData::SequenceEnd) {
@@ -2908,13 +2860,12 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         self.context.set(Context::FlowIn)?;
 
-        // PORT NOTE: Zig `defer self.context.unset(.flow_in)` — capture the
-        // fallible body's result and unset on EVERY exit (including `?` paths).
-        // The post-`}` scan happens AFTER `.flow_in` is popped (yaml.zig:852),
-        // so only the loop body lives inside the closure.
+        // Capture the fallible body's result and unset `FlowIn` on EVERY exit
+        // (including `?` paths). The post-`}` scan happens AFTER `FlowIn` is
+        // popped, so only the loop body lives inside the closure.
         let result: Result<(), ParseError> = (|| {
             {
-                // Zig `defer self.context.unset(.flow_key)` — unset before propagating.
+                // Unset `FlowKey` before propagating.
                 self.context.set(Context::FlowKey)?;
                 let r = self.scan(ScanOptions::default());
                 self.context.unset(Context::FlowKey);
@@ -3037,8 +2988,8 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         self.block_indents.push(sequence_indent)?;
 
-        // PORT NOTE: Zig `defer self.block_indents.pop()` — capture the fallible
-        // body's result and pop on EVERY exit (including `?` paths).
+        // Capture the fallible body's result and pop `block_indents` on EVERY
+        // exit (including `?` paths).
         let result: Result<Expr, ParseError> = (|| {
             let mut seq: ast::ExprNodeList = bun_alloc::AstAlloc::vec();
 
@@ -3090,53 +3041,6 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         result
     }
 
-    /// Should only be used with expressions created with the YAML parser. It assumes
-    /// only null, boolean, number, string, array, object are possible. It also only
-    /// does pointer comparison with arrays and objects (so exponential merges are avoided)
-    fn yaml_merge_key_expr_eql(l: &Expr, r: &Expr) -> bool {
-        if core::mem::discriminant(&l.data) != core::mem::discriminant(&r.data) {
-            return false;
-        }
-        match (&l.data, &r.data) {
-            (ast::ExprData::ENull(_), _) => true,
-            (ast::ExprData::EBoolean(lb), ast::ExprData::EBoolean(rb)) => lb.value == rb.value,
-            (ast::ExprData::ENumber(ln), ast::ExprData::ENumber(rn)) => ln.value == rn.value,
-            (ast::ExprData::EString(ls), ast::ExprData::EString(rs)) => {
-                // Zig: `ls.eqlEString(rs)` — inline the UTF-8/UTF-16 + slice-eq logic.
-                if ls.is_utf16 != rs.is_utf16 {
-                    if ls.is_utf16 {
-                        rs.eql_bytes(ls.data.slice())
-                    } else {
-                        ls.eql_bytes(rs.data.slice())
-                    }
-                } else if ls.is_utf16 {
-                    ls.slice16() == rs.slice16()
-                } else {
-                    ls.data == rs.data
-                }
-            }
-            // pointer comparison
-            (ast::ExprData::EArray(la), ast::ExprData::EArray(ra)) => la.as_ptr() == ra.as_ptr(),
-            (ast::ExprData::EObject(lo), ast::ExprData::EObject(ro)) => lo.as_ptr() == ro.as_ptr(),
-            _ => false,
-        }
-    }
-
-    fn yaml_merge_key_expr_hash(key: &Expr) -> u64 {
-        match &key.data {
-            ast::ExprData::ENull(_) => 0,
-            ast::ExprData::EBoolean(b) => 1 + b.value as u64,
-            ast::ExprData::ENumber(n) => {
-                let value = if n.value == 0.0 { 0.0 } else { n.value };
-                value.to_bits()
-            }
-            ast::ExprData::EString(s) => s.hash(),
-            ast::ExprData::EArray(a) => a.as_ptr() as usize as u64,
-            ast::ExprData::EObject(o) => o.as_ptr() as usize as u64,
-            _ => u64::MAX,
-        }
-    }
-
     fn parse_block_mapping(
         &mut self,
         first_key: Expr,
@@ -3162,8 +3066,8 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
             self.block_indents.push(mapping_indent)?;
         }
 
-        // PORT NOTE: Zig `defer self.block_indents.pop()` — capture the fallible
-        // body's result and pop on EVERY exit (including `?` paths).
+        // Capture the fallible body's result and pop `block_indents` on EVERY
+        // exit (including `?` paths).
         let result: Result<Expr, ParseError> = (|| {
             let mut props = MappingProps::init();
             let mut first_entry_end_line = mapping_line;
@@ -3241,8 +3145,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
             self.context.set(Context::BlockIn)?;
 
-            // PORT NOTE: Zig `defer self.context.unset(.block_in)` — same
-            // capture-then-unset pattern, nested.
+            // Same capture-then-unset pattern, nested.
             let inner: Result<Expr, ParseError> = (|| {
                 let mut previous_line = first_entry_end_line;
 
@@ -3414,12 +3317,11 @@ impl MappingProps {
         budget: &mut usize,
     ) -> Result<(), AllocError> {
         self.list.reserve(merge_props.len().min(*budget));
-        // PERF(port): was ensureUnusedCapacity
 
         while self.merge_indexed < self.list.len() {
             let idx = self.merge_indexed;
             let key = self.list[idx].key.as_ref().unwrap();
-            let hash = Parser::<Utf8>::yaml_merge_key_expr_hash(key);
+            let hash = yaml_merge_key_expr_hash(key);
             self.merge_index
                 .get_or_put(hash)?
                 .value_ptr
@@ -3429,19 +3331,17 @@ impl MappingProps {
 
         'next_merge_prop: for merge_prop in merge_props.iter().rev() {
             let merge_key = merge_prop.key.as_ref().unwrap();
-            let merge_hash = Parser::<Utf8>::yaml_merge_key_expr_hash(merge_key);
+            let merge_hash = yaml_merge_key_expr_hash(merge_key);
             if let Some(candidates) = self.merge_index.get(&merge_hash) {
                 for existing_idx in candidates.iter() {
                     let existing_key = self.list[*existing_idx as usize].key.as_ref().unwrap();
-                    if Parser::<Utf8>::yaml_merge_key_expr_eql(existing_key, merge_key) {
-                        // TODO(port): yaml_merge_key_expr_eql is generic-agnostic; using Utf8 monomorph here is a hack.
+                    if yaml_merge_key_expr_eql(existing_key, merge_key) {
                         continue 'next_merge_prop;
                     }
                 }
             }
             *budget = budget.checked_sub(1).ok_or(AllocError)?;
-            // `G::Property` is not `Clone`; reconstruct from its `Copy` fields
-            // (Zig copied the struct by value).
+            // `G::Property` is not `Clone`; reconstruct from its `Copy` fields.
             self.list.push(G::Property {
                 key: merge_prop.key,
                 value: merge_prop.value,
@@ -3450,7 +3350,6 @@ impl MappingProps {
                 initializer: merge_prop.initializer,
                 ..Default::default()
             });
-            // PERF(port): was appendAssumeCapacity
             self.merge_index
                 .get_or_put(merge_hash)?
                 .value_ptr
@@ -3723,8 +3622,8 @@ impl Default for ScanOptions {
 // Escape
 // ───────────────────────────────────────────────────────────────────────────
 
-// PERF(port): was a comptime parameter (Zig `comptime escape`); ConstParamTy needs
-// nightly `adt_const_params`. Downgraded to a runtime arg — branch is trivially
+// PERF: a const-generic parameter would need nightly `adt_const_params`
+// (ConstParamTy). Kept as a runtime arg — branch is trivially
 // predicted (3 fixed call sites). Re-evaluate.
 #[derive(Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
@@ -3963,9 +3862,8 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
             node_props.set_anchor(anchor)?;
         }
 
-        // PORT NOTE: labeled-switch loop on `self.token.data`. The Zig
-        // `continue :node self.token.data` re-enters with the new token after
-        // scanning. We loop and re-match.
+        // labeled-switch loop on `self.token.data`: loop and re-match with
+        // the new token after scanning.
         let node: Expr = 'node: loop {
             match &self.token.data {
                 TokenData::Eof | TokenData::DocumentStart | TokenData::DocumentEnd => {
@@ -4013,7 +3911,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                         Some(e) => *e,
                         None => {
                             // we failed to find the alias, but it might be cyclic and
-                            // available later. (see Zig comment block)
+                            // available later.
                             return Err(ParseError::UnresolvedAlias);
                         }
                     };
@@ -4345,7 +4243,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                     let scalar_line = self.token.line;
                     let scalar_tab_after_indent = self.tab_after_indent;
 
-                    // PORT NOTE: reshaped for borrowck — we must hold the scalar
+                    // reshaped for borrowck — we must hold the scalar
                     // payload across `self.scan()` which replaces self.token.
                     // Take it out before scanning.
                     let scalar = match core::mem::replace(
@@ -4371,7 +4269,6 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
                     if matches!(self.token.data, TokenData::MappingValue) {
                         // this might be the start of a new object with an implicit key
-                        // (see Zig comments for cases 1-4)
                         if self.token.indent.is_less_than(scalar_indent)
                             || (opts.explicit_mapping_key
                                 && scalar_line != self.token.line
@@ -4495,7 +4392,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
     fn fold_lines(&mut self) -> usize {
         let mut total: usize = 0;
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         let mut __c = Enc::wide(self.next());
         loop {
             match __c {
@@ -4548,7 +4445,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
     // `StringBuilder` that ALSO holds `*Parser`. Both are BACKREF in
     // LIFETIMES.tsv → modeled as raw `*mut Parser` here.
     //
-    // TODO(port): borrowck reshape — TODO(port): either (a) move
+    // TODO: borrowck reshape — either (a) move
     // `whitespace_buf` out of Parser, or (b) restructure ctx to take `&mut self`
     // per call instead of storing it. The raw-pointer aliasing below is sound
     // because `ctx` never outlives `&mut self` and never re-enters Parser
@@ -4588,7 +4485,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
             multiline: false,
         };
 
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         let mut __c = Enc::wide(parser!().next());
         loop {
             match __c {
@@ -4933,7 +4830,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         let mut indent_indicator: Option<IndentIndicator> = None;
         let mut chomp: Option<Chomp> = None;
 
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         let mut __c = Enc::wide(self.next());
         loop {
             match __c {
@@ -5009,11 +4906,19 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
     // ── scanAutoIndentedLiteralScalar ───────────────────────────────────────
     //
-    // TODO(port): Another large labeled-switch state machine (yaml.zig:2703-2979)
-    // with an inner `LiteralScalarCtx` struct. The two-phase loop (find
-    // content_indent, then scan body) with `ctx.append`/`ctx.done` and chomp
-    // handling is preserved structurally below; verify the nested `newlines:`
-    // switch translation against the Zig original.
+    // Another large labeled-switch state machine with an inner
+    // `LiteralScalarCtx` struct: a two-phase loop (find content_indent,
+    // then scan body) with `ctx.append`/`ctx.done` (verified against the
+    // official yaml-test-suite):
+    // - explicit `indent_indicator` support;
+    // - EOF chomping normalized via `leading_newlines` in `done()` so Clip and
+    //   Keep agree with eemeli/yaml + js-yaml (L24T/01, JEF9/02);
+    // - folded more-indented lines tracked with `prev/cur_more_indented`
+    //   flags, so breaks adjacent to more-indented lines are not folded
+    //   (spec [73]-[74]);
+    // - the per-line indent guard is the precomputed `min_indent`
+    //   (>= content_indent AND > parent block indent);
+    // - `---`/`...` document markers additionally require line start.
 
     fn scan_auto_indented_literal_scalar(
         &mut self,
@@ -5147,7 +5052,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         };
 
         // Phase 1: find content_indent and first non-ws char
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         let mut consumed_indent_this_line = false;
         let (content_indent, first): (Indent, u32) = 'phase1: loop {
             let __c = Enc::wide(self.next());
@@ -5239,7 +5144,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         };
 
         // Phase 2: scan body
-        // PORT NOTE: labeled-switch loop with nested `newlines:` switch
+        // labeled-switch loop with nested `newlines:` switch
         let mut __c = first;
         loop {
             match __c {
@@ -5386,7 +5291,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         let mut text: Vec<Enc::Unit> = Vec::new();
 
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         loop {
             let c = Enc::wide(self.next());
             match c {
@@ -5448,7 +5353,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                         indent: scalar_indent,
                         line: scalar_line,
                         resolved: TokenScalar {
-                            // TODO: wrong! (matches Zig comment)
+                            // TODO: wrong!
                             multiline: self.line != scalar_line,
                             is_quoted: true,
                             data: NodeScalar::String(YamlString::List(text)),
@@ -5469,7 +5374,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
         let scalar_indent = self.line_indent;
         let mut text: Vec<Enc::Unit> = Vec::new();
 
-        // PORT NOTE: labeled-switch loop
+        // labeled-switch loop
         loop {
             let c = Enc::wide(self.next());
             match c {
@@ -5526,7 +5431,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                         indent: scalar_indent,
                         line: scalar_line,
                         resolved: TokenScalar {
-                            // TODO: wrong! (matches Zig comment)
+                            // TODO: wrong!
                             multiline: self.line != scalar_line,
                             is_quoted: true,
                             data: NodeScalar::String(YamlString::List(text)),
@@ -5635,8 +5540,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                 }
             }
             EncodingKind::Utf16 => {
-                // Zig: std.unicode.utf16CodepointSequenceLength + manual surrogate split.
-                // utf16CodepointSequenceLength rejects surrogate code points; mirror that.
+                // Surrogate code points are rejected.
                 if (0xD800..=0xDFFF).contains(&cp) {
                     return Err(ParseError::UnexpectedCharacter);
                 }
@@ -5820,7 +5724,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 
         let previous_token_line = self.token.line;
 
-        // PORT NOTE: labeled-switch loop with `inline` whitespace dispatch.
+        // labeled-switch loop with `inline` whitespace dispatch.
         // We loop on `Enc::wide(self.next())` and break with the resulting token.
         let token: Token<Enc> = 'next: loop {
             let c = Enc::wide(self.next());
@@ -6073,8 +5977,7 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
                     self.token = Token::reserved(self.token_init(start));
                     return Err(Self::unexpected_token());
                 }
-                // PORT NOTE: ScanCtx.scanWhitespace inlined.
-                // whitespace — Zig used `inline '\r','\n',' ','\t' => |ws| ctx.scanWhitespace(ws)`
+                // ScanCtx.scanWhitespace inlined.
                 0x0D /* '\r' */ => {
                     if Enc::wide(self.peek(1)) == 0x0A {
                         self.inc(1);
@@ -6417,12 +6320,3 @@ impl<'i, Enc: Encoding> Parser<'i, Enc> {
 fn eq_ascii<Enc: Encoding>(s: &[Enc::Unit], lit: &[u8]) -> bool {
     s.len() == lit.len() && s.iter().zip(lit).all(|(a, b)| Enc::wide(*a) == *b as u32)
 }
-
-// ───────────────────────────────────────────────────────────────────────────
-// Omitted: large commented-out blocks from yaml.zig
-//   - `Node` struct (lines 4758-4881) — commented out in source
-//   - `Printer` fn   (lines 4927-5248) — commented out in source
-// These were not active code; intentionally not ported.
-// ───────────────────────────────────────────────────────────────────────────
-
-// ported from: src/interchange/yaml.zig
diff --git a/src/patch/lib.rs b/src/patch/lib.rs
index 22bfb2e9b46..ea64b33f33b 100644
--- a/src/patch/lib.rs
+++ b/src/patch/lib.rs
@@ -1,6 +1,4 @@
 //! Patch file parser and applier.
-//!
-//! Port of `src/patch/patch.zig`.
 
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 #![warn(unused_must_use)]
@@ -28,7 +26,7 @@ const PAGE_SIZE: usize = 16384;
 // ──────────────────────────────────────────────────────────────────────────
 
 /// All strings point to the original patch file text
-// PORT NOTE: lifetime — every `&'a [u8]` in this module borrows from the
+// lifetime — every `&'a [u8]` in this module borrows from the
 // original patch file text. The port generally avoids struct lifetimes, but
 // this parser's whole output is borrowed; raw `*const [u8]` everywhere would
 // be worse.
@@ -40,15 +38,11 @@ pub enum PatchFilePart<'a> {
     FileModeChange(Box<FileModeChange<'a>>),
 }
 
-// Zig `deinit` only freed owned fields → Drop is automatic.
-
 #[derive(Default)]
 pub struct PatchFile<'a> {
     pub parts: Vec<PatchFilePart<'a>>,
 }
 
-// Zig `deinit` only freed owned fields → Drop is automatic.
-
 #[cfg_attr(unix, allow(dead_code))]
 struct ApplyState {
     pathbuf: PathBuffer,
@@ -71,12 +65,12 @@ impl ApplyState {
         }
         match sys::get_fd_path(fd, &mut self.pathbuf) {
             sys::Result::Ok(p) => {
-                // PORT NOTE: reshaped for borrowck — capture len, drop `p`,
+                // reshaped for borrowck — capture len, drop `p`,
                 // then re-borrow `self.pathbuf` to write the sentinel.
                 let len = p.len();
-                // Zig `state.pathbuf[0..p.len :0]` asserts a NUL sentinel; on
-                // Linux `readlink(2)` does not NUL-terminate, so write it
-                // explicitly (the buffer is zero-initialized but be defensive).
+                // On Linux `readlink(2)` does not NUL-terminate, so write the
+                // sentinel explicitly (the buffer is zero-initialized but be
+                // defensive).
                 self.pathbuf.0[len] = 0;
                 self.patch_dir_abs_path = Some(len);
                 sys::Result::Ok(ZStr::from_buf(&self.pathbuf.0, len))
@@ -89,7 +83,6 @@ impl ApplyState {
 impl<'a> PatchFile<'a> {
     pub fn apply(&self, patch_dir: Fd) -> Option<sys::Error> {
         let mut state = ApplyState::new();
-        // PERF(port): was stack-fallback + arena bulk-free per iteration — profile if hot.
 
         for part in &self.parts {
             match part {
@@ -136,12 +129,10 @@ impl<'a> PatchFile<'a> {
                     let mode = file_creation.mode;
 
                     if !filedir.is_empty() {
-                        // PORT NOTE: Zig calls `NodeFS.mkdirRecursive` with the bare relative
-                        // `filedir` (resolved against process CWD), then immediately `openat`s
-                        // the same path against `patch_dir`. That is internally inconsistent
-                        // when `patch_dir != cwd`. We intentionally diverge and create the
-                        // directory under `patch_dir` so the subsequent `openat` succeeds.
-                        // Consider back-porting this fix to patch.zig.
+                        // Create the directory under `patch_dir` so the
+                        // subsequent `openat` against `patch_dir` succeeds
+                        // (resolving `filedir` against the process CWD would be
+                        // inconsistent when `patch_dir != cwd`).
                         if let sys::Result::Err(e) =
                             sys::mkdir_recursive_at_mode(patch_dir, filedir, mode.to_bun_mode())
                         {
@@ -177,7 +168,7 @@ impl<'a> PatchFile<'a> {
                         total
                     };
 
-                    // PERF(port): Zig used arena for small (<= PAGE_SIZE) allocations.
+                    // PERF: small (<= PAGE_SIZE) allocations could use an arena.
                     let _ = PAGE_SIZE;
 
                     // TODO: this additional allocation is probably not necessary in all cases and should be avoided or use stack buffer
@@ -265,7 +256,6 @@ impl<'a> PatchFile<'a> {
 /// - If file size <= PAGE_SIZE, read the whole file into memory. memcpy/memmove the file contents around will be fast
 /// - If file size > PAGE_SIZE, rather than making a list of lines, make a list of chunks
 fn apply_patch(patch: &FilePatch<'_>, patch_dir: Fd, state: &mut ApplyState) -> sys::Result<()> {
-    // PERF(port): was arena.arena().dupeZ — profile if hot.
     let file_path = ZBox::from_vec_with_nul(patch.path.to_vec());
 
     // Need to get the mode of the original file
@@ -297,7 +287,6 @@ fn apply_patch(patch: &FilePatch<'_>, patch_dir: Fd, state: &mut ApplyState) ->
     //
     // But if the file size is small, like less than a single page, it's probably ok
     // to use the arena
-    // PERF(port): was arena vs default_allocator selection — profile if hot.
     let _use_arena: bool = stat.st_size as usize <= PAGE_SIZE;
     let filebuf: Vec<u8> = match read_file_alloc(patch_dir, &file_path, 1024 * 1024 * 1024 * 4) {
         Ok(b) => b,
@@ -389,7 +378,6 @@ fn apply_patch(patch: &FilePatch<'_>, patch_dir: Fd, state: &mut ApplyState) ->
                         );
                     }
 
-                    // Zig: addManyAt + @memcpy
                     lines.splice(line_cursor..line_cursor, part.lines.iter().copied());
                     line_cursor += part.lines.len();
                     if part.no_newline_at_end_of_file {
@@ -442,11 +430,10 @@ fn apply_patch(patch: &FilePatch<'_>, patch_dir: Fd, state: &mut ApplyState) ->
 }
 
 fn read_file_alloc(dir: Fd, path: &ZStr, max: usize) -> sys::Result<Vec<u8>> {
-    // PORT NOTE: Zig's `std.fs.Dir.readFileAlloc` opens, fstats, allocates
-    // `min(size, max)` and errors `error.FileTooBig` past `max`. Enforce the
-    // same cap so a pathological multi-GiB target file errors instead of
-    // allocating unboundedly. (`error.FileTooBig` would surface as `.INVAL` at
-    // the only call site anyway, so we map it to EINVAL here.)
+    // Allocate `min(size, max)` and error past `max`, so a pathological
+    // multi-GiB target file errors instead of allocating unboundedly. (The
+    // too-big error would surface as `.INVAL` at the only call site anyway,
+    // so we map it to EINVAL here.)
     let stat = sys::fstatat(dir, path)?;
     if stat.st_size as u64 > max as u64 {
         return sys::Result::Err(
@@ -456,7 +443,7 @@ fn read_file_alloc(dir: Fd, path: &ZStr, max: usize) -> sys::Result<Vec<u8>> {
     sys::File::read_from(dir, path)
 }
 
-/// Port of `std.mem.join` for byte slices.
+/// Joins byte slices with a separator.
 fn join_bytes(sep: &[u8], slices: &[&[u8]]) -> Vec<u8> {
     if slices.is_empty() {
         return Vec::new();
@@ -499,11 +486,7 @@ impl<'a> FileDeets<'a> {
         mem::take(&mut self.hunks)
     }
 
-    // Zig `deinit` only freed owned fields → Drop is automatic.
-
     fn nullify_empty_strings(&mut self) {
-        // Zig used @typeInfo reflection over all `?[]const u8` fields. No Rust
-        // equivalent — written out by hand.
         macro_rules! nullify {
             ($($f:ident),*) => {$(
                 if matches!(self.$f, Some(v) if v.is_empty()) {
@@ -550,8 +533,6 @@ pub enum PartType {
     Deletion,
 }
 
-// Zig `PatchMutationPart.deinit` only freed `lines` → Drop is automatic.
-
 #[derive(Default)]
 pub struct Hunk<'a> {
     pub header: Header,
@@ -583,8 +564,6 @@ impl Header {
     };
 }
 
-// Zig `Hunk.deinit` only freed owned fields → Drop is automatic.
-
 impl<'a> Hunk<'a> {
     pub(crate) fn verify_integrity(&self) -> bool {
         let mut original_length: usize = 0;
@@ -658,7 +637,6 @@ pub struct FilePatch<'a> {
     pub before_hash: Option<&'a [u8]>,
     pub after_hash: Option<&'a [u8]>,
 }
-// Zig `deinit` freed hunks + bun.destroy(this) → Drop on Box<FilePatch> handles both.
 
 pub struct FileDeletion<'a> {
     pub path: &'a [u8],
@@ -666,7 +644,6 @@ pub struct FileDeletion<'a> {
     pub hunk: Option<Box<Hunk<'a>>>,
     pub hash: Option<&'a [u8]>,
 }
-// Zig `deinit` freed hunk + bun.destroy(this) → Drop on Box<FileDeletion> handles both.
 
 pub struct FileCreation<'a> {
     pub path: &'a [u8],
@@ -674,7 +651,6 @@ pub struct FileCreation<'a> {
     pub hunk: Option<Box<Hunk<'a>>>,
     pub hash: Option<&'a [u8]>,
 }
-// Zig `deinit` freed hunk + bun.destroy(this) → Drop on Box<FileCreation> handles both.
 
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub(crate) enum PatchFilePartKind {
@@ -688,21 +664,19 @@ pub(crate) enum PatchFilePartKind {
 // ──────────────────────────────────────────────────────────────────────────
 // json_fmt — JSON `Display` adapter for `PatchFile`
 //
-// Port of Zig's `std.json.fmt(patchfile, .{})` (used only by the testing
-// bindings in `src/patch_jsc/testing.zig`). The output shape is dictated by
-// Zig's default `std.json.stringify` rules, so it must match exactly for the
-// snapshot tests in `test/js/bun/patch/patch.test.ts` to pass:
+// Used only by the testing bindings in `bun_patch_jsc`. The output shape must
+// match exactly for the snapshot tests in `test/js/bun/patch/patch.test.ts`
+// to pass:
 //   - struct           → `{"field":...}` in field-declaration order
-//   - `ArrayListUnmanaged` (our `Vec<T>`) → `{"items":[...],"capacity":N}`
-//   - `[]const u8`     → JSON string
-//   - `enum`           → `"tag_name"`
-//   - `union(enum)`    → `{"tag_name":payload}`
-//   - `?T`             → `null` or value
-//   - `*T`             → serialized as the pointee
+//   - `Vec<T>`         → `{"items":[...],"capacity":N}`
+//   - byte string      → JSON string
+//   - enum             → `"tag_name"`
+//   - tagged union     → `{"tag_name":payload}`
+//   - `Option<T>`      → `null` or value
+//   - `Box<T>`         → serialized as the pointee
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Returns a `Display` adapter that serializes `patchfile` as JSON, matching
-/// the output of Zig's `std.json.fmt(patchfile, .{})`.
+/// Returns a `Display` adapter that serializes `patchfile` as JSON.
 pub fn json_fmt<'a, 'b>(patchfile: &'b PatchFile<'a>) -> impl core::fmt::Display + 'b {
     PatchFileJsonFmt(patchfile)
 }
@@ -728,8 +702,8 @@ mod json {
         }
     }
 
-    /// Zig `std.ArrayListUnmanaged(T)` is a plain struct `{ items: []T, capacity: usize }`,
-    /// which `std.json` serializes field-wise. Reproduce that wrapper around a `Vec<T>`.
+    /// Serialize a `Vec<T>` as `{"items":[...],"capacity":N}` (the shape the
+    /// snapshot tests expect).
     fn write_list<W: Write, T>(
         w: &mut W,
         v: &Vec<T>,
@@ -769,7 +743,7 @@ mod json {
     }
 
     fn write_mutation_part(w: &mut impl Write, p: &PatchMutationPart<'_>) -> Result {
-        // Zig field name is `type`; Rust field is `ty`.
+        // JSON field name is `type`; the Rust field is `ty`.
         write!(w, "{{\"type\":\"{}\",\"lines\":", part_type_tag(p.ty))?;
         write_list(w, &p.lines, |w, line| write_str(w, line))?;
         write!(
@@ -940,7 +914,7 @@ pub fn parse_patch_file(file: &[u8]) -> Result<PatchFile<'_>, ParseErr> {
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — take ownership of result vec instead of slicing.
+    // reshaped for borrowck — take ownership of result vec instead of slicing.
     let mut files = mem::take(&mut lines_parser.result);
     patch_file_second_pass(&mut files)
 }
@@ -1082,7 +1056,7 @@ fn is_safe_patch_path(path: &[u8]) -> bool {
 // ScalarSplitIter / LookbackIterator
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Port of `std.mem.SplitIterator(u8, .scalar)` exposing `.index` so callers
+/// Split-on-scalar iterator exposing `.index` so callers
 /// can rewind / inspect cursor (Rust's `slice::Split` does not expose this).
 struct ScalarSplitIter<'a> {
     buffer: &'a [u8],
@@ -1185,11 +1159,10 @@ struct ParseOpts {
 }
 
 impl<'a> PatchLinesParser<'a> {
-    // Zig `deinit` had a `comptime clear_result_retaining_capacity: bool` param.
-    // In Rust, Drop handles freeing; `reset()` handles the retain-capacity case.
+    // Drop handles freeing; `reset()` handles the retain-capacity case.
 
     fn reset(&mut self) {
-        // PORT NOTE: reshaped for borrowck — take result vec, clear it, reinit self.
+        // reshaped for borrowck — take result vec, clear it, reinit self.
         let mut result = mem::take(&mut self.result);
         result.clear();
         *self = Self {
@@ -1203,7 +1176,7 @@ impl<'a> PatchLinesParser<'a> {
             return Ok(());
         }
         let end = 'brk: {
-            // std.mem.splitBackwardsScalar — peek at last segment after final '\n'
+            // Peek at the last segment after the final '\n'.
             let mut prev: usize = file_.len();
             let last_nl = file_.iter().rposition(|b| *b == b'\n');
             let last_line = match last_nl {
@@ -1212,7 +1185,7 @@ impl<'a> PatchLinesParser<'a> {
             };
             if last_line.is_empty() {
                 if let Some(i) = last_nl {
-                    // Zig: iter.index.? — index points to the byte BEFORE the delimiter.
+                    // index points to the byte BEFORE the delimiter.
                     prev = i;
                 }
             }
@@ -1560,8 +1533,7 @@ fn parse_diff_hashes(line: &[u8]) -> Option<(&[u8], &[u8])> {
 
     let delimiter_start = strings::index_of(line, b"..")? as usize;
 
-    // PERF(port): was comptime IntegerBitSet — ArrayBitSet::set is non-const,
-    // so this builds at runtime. Profile if it shows up on a hot path.
+    // ArrayBitSet::set is non-const, so this builds at runtime.
     let valid_chars: ByteBitSet = {
         let mut bitset = ByteBitSet::init_empty();
         // TODO: the regex uses \w which is [a-zA-Z0-9_]
@@ -1658,15 +1630,11 @@ fn parse_diff_line_paths(line: &[u8]) -> Option<(&[u8], &[u8])> {
     Some((a_path, b_path))
 }
 
-// `pub const TestingAPIs = @import("../patch_jsc/testing.zig").TestingAPIs;`
-// — *_jsc alias line; deleted per PORTING.md. Consumers use bun_patch_jsc::TestingAPIs.
-
 // ──────────────────────────────────────────────────────────────────────────
 // spawnOpts / diffPostProcess / gitDiff*
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: Zig returns `bun.spawn.sync.Options` with `argv`/`envp` allocated on
-// `bun.default_allocator` and freed by the caller. `bun_spawn::sync::Options` owns
+// `bun_spawn::sync::Options` owns
 // `argv` (`Vec<Box<[u8]>>`) but borrows `envp` (`Option<*const *const c_char>`), so
 // the null-terminated envp array is returned alongside as the second tuple element —
 // caller must keep it alive while `Options` is in use (no `Box::leak`, §Forbidden).
@@ -1690,7 +1658,7 @@ pub fn spawn_opts(
             b"--full-index",
             b"--no-index",
         ];
-        // PERF(port): Zig stored borrowed slices; `Options.argv` is
+        // PERF: `Options.argv` is
         // `Vec<Box<[u8]>>`, so we copy. Profile if it shows up on a hot path.
         let mut argv_buf: Vec<Box<[u8]>> = Vec::with_capacity(ARGV.len() + 2);
         argv_buf.push(Box::from(git.as_bytes()));
@@ -1719,9 +1687,9 @@ pub fn spawn_opts(
             envp_buf.push(s.as_ptr().cast::<core::ffi::c_char>());
         }
         if let Some(p) = path {
-            // PORT NOTE: `env_var::PATH.get()` yields a slice into the C env
+            // `env_var::PATH.get()` yields a slice into the C env
             // block (NUL byte immediately follows on POSIX — see
-            // `bun_core::getenv_z`), matching Zig's `@ptrCast(p.ptr)`.
+            // `bun_core::getenv_z`).
             envp_buf.push(p.as_ptr().cast::<core::ffi::c_char>());
         }
         envp_buf.push(core::ptr::null()); // sentinel
@@ -1739,8 +1707,8 @@ pub fn spawn_opts(
         argv,
         #[cfg(windows)]
         windows: bun_spawn::sync::WindowsOptions {
-            // Zig matched on `loop.*` to build the handle by hand; `as_handle`
-            // owns that conversion now so variant internals stay encapsulated.
+            // `as_handle` owns the handle conversion so variant internals
+            // stay encapsulated.
             loop_: bun_event_loop::AnyEventLoop::as_handle(loop_),
             ..Default::default()
         },
@@ -1761,7 +1729,7 @@ pub fn diff_post_process(
     mem::swap(&mut stdout, &mut result.stdout);
     mem::swap(&mut stderr, &mut result.stderr);
 
-    // PORT NOTE: errdefer-style flags replaced by Drop semantics; on early return
+    // errdefer-style flags replaced by Drop semantics; on early return
     // the unreturned vec is dropped automatically.
 
     if !stderr.is_empty() {
@@ -1773,9 +1741,7 @@ pub fn diff_post_process(
     Ok(Ok(stdout))
 }
 
-// PORT NOTE: Zig signature returns `[2]if (sentinel) [:0]const u8 else []const u8` —
-// return type depends on a comptime bool. Rust cannot express this without GAT-ish
-// traits, so we return owned `Vec<u8>` pairs (NUL-appended when SENTINEL).
+// Returns owned `Vec<u8>` pairs (NUL-appended when SENTINEL).
 pub fn git_diff_preprocess_paths<const SENTINEL: bool>(
     old_folder_: &[u8],
     new_folder_: &[u8],
@@ -1790,8 +1756,8 @@ pub fn git_diff_preprocess_paths<const SENTINEL: bool>(
         paths::slashes_to_posix_in_place(&mut cpy[..]);
         if SENTINEL {
             cpy[old_folder_.len()] = 0;
-            // Zig: `break :brk cpy[0..len :0]` — sentinel slice's `.len` excludes
-            // the NUL. Truncate so `Vec::len()` matches; the NUL byte stays in
+            // The sentinel slice's `.len` excludes the NUL. Truncate so
+            // `Vec::len()` matches; the NUL byte stays in
             // spare capacity for callers that need a C string via `.as_ptr()`.
             cpy.truncate(old_folder_.len());
         }
@@ -1807,7 +1773,7 @@ pub fn git_diff_preprocess_paths<const SENTINEL: bool>(
         paths::slashes_to_posix_in_place(&mut cpy[..]);
         if SENTINEL {
             cpy[new_folder_.len()] = 0;
-            // Zig: `break :brk cpy[0..len :0]` — `.len` excludes the sentinel.
+            // `.len` excludes the sentinel.
             cpy.truncate(new_folder_.len());
         }
         cpy
@@ -1817,7 +1783,7 @@ pub fn git_diff_preprocess_paths<const SENTINEL: bool>(
 
     #[cfg(unix)]
     if SENTINEL {
-        // Zig: allocator.dupeZ — append NUL.
+        // Append NUL.
         let mut o = old_folder;
         o.push(0);
         let mut n = new_folder;
@@ -1838,7 +1804,6 @@ pub fn git_diff_internal(
     let old_folder = &paths[0][..];
     let new_folder = &paths[1][..];
 
-    // Zig used `std.process.Child`, which searches `$PATH` for argv[0].
     // `bun_spawn::sync` execs argv[0] verbatim (execve, no PATH search), so
     // resolve `git` here — same as `patchCommit`'s `bun.which` call.
     let mut gitbuf = PathBuffer::uninit();
@@ -1902,8 +1867,7 @@ pub fn git_diff_internal(
         stderr: bun_spawn::sync::Stdio::Buffer,
         envp: Some(envp_buf.as_ptr()),
         argv,
-        // PORT NOTE: Zig used `std.process.Child` (no uv loop). The Rust port
-        // routes through `bun_spawn::sync::spawn`, whose Windows path
+        // This routes through `bun_spawn::sync::spawn`, whose Windows path
         // unconditionally derefs `windows.loop_` (process.rs spawn_windows_*).
         // `WindowsOptions::default()` is `zeroed_unchecked()`, so leaving this
         // defaulted is a null deref on Windows — supply the caller's loop.
@@ -1966,7 +1930,6 @@ fn git_diff_postprocess(
     old_folder: &[u8],
     new_folder: &[u8],
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let old_folder_trimmed = strings::trim(old_folder, b"/");
     let new_folder_trimmed = strings::trim(new_folder, b"/");
 
@@ -2002,10 +1965,8 @@ fn git_diff_postprocess(
     let mut saw_b_folder: Option<usize> = None;
     let mut line_idx: u32 = 0;
 
-    // PORT NOTE: reshaped for borrowck — Zig mutated `stdout` while iterating
-    // `std.mem.splitScalar` over it (relying on the iterator's by-value buffer
-    // pointer staying valid because replaceRange only shrinks). In Rust we
-    // re-implement the cursor manually so we can mutate `stdout` between lines.
+    // The cursor is maintained manually (rather than via a split iterator)
+    // so we can mutate `stdout` between lines.
     let mut cursor: usize = 0;
     while cursor <= stdout.len() {
         // Compute current line [line_start, line_end) and the index AFTER its delimiter.
@@ -2018,8 +1979,8 @@ fn git_diff_postprocess(
                 }
                 None => (stdout.len(), stdout.len(), true),
             };
-        // Mirror Zig SplitIterator: `index` after next() points one past delimiter,
-        // so `index - 1 - line.len() == line_start`.
+        // The cursor after a line points one past its delimiter,
+        // so `cursor - 1 - line.len() == line_start`.
         let line_len = line_end - line_start;
 
         // Borrow line for read-only checks; drop before mutating stdout.
@@ -2037,7 +1998,7 @@ fn git_diff_postprocess(
                     line_start + old_folder_slash_start
                         ..line_start + old_folder_slash_start + old_folder_trimmed.len() + 1,
                 );
-                // Zig: line_iter.index.? -= 1 + line.len  → re-examine this same line.
+                // Re-examine this same line.
                 cursor = line_start;
                 saw_a_folder = Some(line_idx as usize);
                 continue;
@@ -2050,7 +2011,7 @@ fn git_diff_postprocess(
                     line_start + new_folder_slash_start
                         ..line_start + new_folder_slash_start + new_folder_trimmed.len() + 1,
                 );
-                // Zig: line_iter.index.? -= new_folder_trimmed.len + 1 → next iteration
+                // The next iteration
                 // resumes at the (now-shifted) byte after this line's '\n'.
                 cursor = next_cursor - (new_folder_trimmed.len() + 1);
                 saw_b_folder = Some(line_idx as usize);
@@ -2122,5 +2083,3 @@ fn should_skip_line(line: &[u8]) -> bool {
             // line like: "--- a/numbers.txt" or "+++ b/numbers.txt" we should not skip
             && !(line.len() >= 4 && (&line[0..4] == b"--- " || &line[0..4] == b"+++ ")))
 }
-
-// ported from: src/patch/patch.zig
diff --git a/src/patch_jsc/testing.rs b/src/patch_jsc/testing.rs
index d2c6795b6b1..a316038eb88 100644
--- a/src/patch_jsc/testing.rs
+++ b/src/patch_jsc/testing.rs
@@ -10,7 +10,7 @@ use bun_sys::{Fd, FdExt};
 pub struct TestingAPIs;
 
 impl TestingAPIs {
-    // PORT NOTE: `#[bun_jsc::host_fn]` Free-kind shim emits an unqualified
+    // `#[bun_jsc::host_fn]` Free-kind shim emits an unqualified
     // `fn_name(g, f)` call, so it cannot wrap an associated fn. The C-ABI
     // shim is emitted at module scope below (`__jsc_host_*`).
     pub fn make_diff(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
@@ -22,7 +22,7 @@ impl TestingAPIs {
         let Some(old_folder_jsval) = arguments.next_eat() else {
             return Err(global.throw(format_args!("expected 2 strings")));
         };
-        // `to_bun_string` returns +1 ref; `OwnedString` derefs on drop (Zig: `defer .deref()`).
+        // `to_bun_string` returns +1 ref; `OwnedString` derefs on drop.
         let old_folder_bunstr = OwnedString::new(old_folder_jsval.to_bun_string(global)?);
 
         let Some(new_folder_jsval) = arguments.next_eat() else {
@@ -33,9 +33,8 @@ impl TestingAPIs {
         let old_folder = old_folder_bunstr.to_utf8();
         let new_folder = new_folder_bunstr.to_utf8();
 
-        // PORT NOTE: Zig `gitDiffInternal` used `std.process.Child` (no uv loop).
-        // Rust routes through `bun_spawn::sync`, which on Windows derefs
-        // `WindowsOptions.loop_` — supply the JS event loop.
+        // `git_diff_internal` routes through `bun_spawn::sync`, which on
+        // Windows derefs `WindowsOptions.loop_` — supply the JS event loop.
         // `global.bun_vm().event_loop()` is the live per-thread `jsc::EventLoop`.
         let mut loop_ = bun_jsc::AnyEventLoop::js(global.bun_vm().event_loop().cast());
         let diff = match git_diff_internal(old_folder.slice(), new_folder.slice(), &mut loop_) {
@@ -44,7 +43,7 @@ impl TestingAPIs {
         };
         match diff {
             Ok(s) => {
-                // Zig: `bun.String.fromBytes(s.items).toJS(...)` — borrow, no +1 WTF ref.
+                // `from_bytes` borrows — no +1 WTF ref.
                 let result = BunString::from_bytes(s.as_slice()).to_js(global);
                 drop(s);
                 result
@@ -121,7 +120,7 @@ impl TestingAPIs {
         };
 
         let dir_fd = if let Some(dir_js) = arguments.next_eat() {
-            // +1 ref from `to_bun_string`; release via `OwnedString` drop (Zig: `defer bunstr.deref()`).
+            // +1 ref from `to_bun_string`; release via `OwnedString` drop.
             let bunstr = OwnedString::new(dir_js.to_bun_string(global)?);
             let path = bunstr.to_owned_slice_z();
 
@@ -149,8 +148,8 @@ impl TestingAPIs {
                 return Err(e);
             }
         };
-        // +1 ref from `to_bun_string`; release via `OwnedString` drop (Zig:
-        // `defer patchfile_bunstr.deref()`). `to_utf8()` takes its own ref, so
+        // +1 ref from `to_bun_string`; release via `OwnedString` drop.
+        // `to_utf8()` takes its own ref, so
         // `patchfile_src` outlives this guard.
         let patchfile_bunstr = OwnedString::new(patchfile_bunstr);
         let patchfile_src = patchfile_bunstr.to_utf8();
@@ -199,7 +198,7 @@ impl Drop for ApplyArgs {
 // in its generated shim body, so it can't wrap an associated fn directly.
 // These module-scope thunks forward to `TestingAPIs::*` so the proc-macro can
 // generate the JSC-calling-convention `__jsc_host_*` exports the codegen side
-// links against (Zig: `jsc.host_fn.wrap(TestingAPIs.makeDiff)` etc.).
+// links against.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[bun_jsc::host_fn]
@@ -216,5 +215,3 @@ pub fn patch_apply(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSVal
 pub fn patch_parse(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     TestingAPIs::parse(global, frame)
 }
-
-// ported from: src/patch_jsc/testing.zig
diff --git a/src/paths/EnvPath.rs b/src/paths/EnvPath.rs
index e5e19e463ca..05d5e69cad0 100644
--- a/src/paths/EnvPath.rs
+++ b/src/paths/EnvPath.rs
@@ -14,22 +14,15 @@ fn trim_path_delimiters(input: &[u8]) -> &[u8] {
     trimmed
 }
 
-// Zig: `pub fn EnvPath(comptime opts: EnvPathOptions) type { return struct { ... } }`
-// TODO(port): `EnvPathOptions` currently has no fields, so the comptime `opts`
-// parameter is vacuous. Re-introduce a `<const OPTS: EnvPathOptions>` const
-// generic (with `#[derive(core::marker::ConstParamTy)]` on `EnvPathOptions`)
-// once options are actually added.
 #[derive(Default)]
 pub struct EnvPath {
-    // Zig: `std.mem.Allocator param` — dropped (non-AST crate, global mimalloc).
     buf: Vec<u8>,
 }
 
 /// Input accepted by [`EnvPath::append`].
 ///
-/// Zig's `append` takes `input: anytype` and switches on `@TypeOf(input)`:
-/// raw slices are trimmed, anything else is assumed already-trimmed and has
-/// `.slice()` called on it. In Rust we express that dispatch as a trait.
+/// Raw slices are trimmed; anything else is assumed already-trimmed and has
+/// `.slice()` called on it.
 pub trait EnvPathInput {
     fn as_trimmed(&self) -> &[u8];
 }
@@ -40,8 +33,7 @@ impl EnvPathInput for [u8] {
     }
 }
 
-// "assume already trimmed" — the `else` arm in Zig calls `input.slice()` for any
-// `bun.Path(...)` instantiation. Blanket over all const params so callers may pass
+// "assume already trimmed" — blanket over all const params so callers may pass
 // any `&Path<u8, KIND, SEP, CHECK>` (e.g. `PathComponentBuilder.apply()`).
 impl<const KIND: u8, const SEP_OPT: u8, const CHECK: u8> EnvPathInput
     for crate::Path<u8, KIND, SEP_OPT, CHECK>
@@ -57,15 +49,12 @@ impl EnvPath {
     }
 
     pub fn init_capacity(capacity: usize) -> Result<Self, AllocError> {
-        // PERF(port): Zig used `ArrayListUnmanaged.initCapacity` which is fallible;
         // `Vec::with_capacity` aborts on OOM under the global mimalloc allocator.
         Ok(Self {
             buf: Vec::with_capacity(capacity),
         })
     }
 
-    // Zig `deinit` only freed `buf` — handled by `Drop` on `Vec<u8>`.
-
     pub fn slice(&self) -> &[u8] {
         self.buf.as_slice()
     }
@@ -79,7 +68,6 @@ impl EnvPath {
 
         if !self.buf.is_empty() {
             self.buf.reserve(trimmed.len() + 1);
-            // PERF(port): was appendAssumeCapacity / appendSliceAssumeCapacity.
             self.buf.push(DELIMITER);
             self.buf.extend_from_slice(trimmed);
         } else {
@@ -98,24 +86,20 @@ impl EnvPath {
 
 pub struct PathComponentBuilder<'a> {
     env_path: &'a mut EnvPath,
-    // Zig: `AbsPath(.{ .sep = .auto })`
     path_buf: crate::AutoAbsPath,
 }
 
 impl<'a> PathComponentBuilder<'a> {
     pub fn append(&mut self, component: &[u8]) {
-        let _ = self.path_buf.append(component); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = self.path_buf.append(component); // OOM/capacity: fire-and-forget
     }
 
     pub fn append_fmt(&mut self, args: core::fmt::Arguments<'_>) {
-        let _ = self.path_buf.append_fmt(args); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = self.path_buf.append_fmt(args); // OOM/capacity: fire-and-forget
     }
 
     pub fn apply(self) -> Result<(), AllocError> {
         self.env_path.append(&self.path_buf)?;
-        // Zig: `this.path_buf.deinit();` — `path_buf` drops at end of scope.
         Ok(())
     }
 }
-
-// ported from: src/paths/EnvPath.zig
diff --git a/src/paths/Path.rs b/src/paths/Path.rs
index 0363c6d76cc..2b77316de79 100644
--- a/src/paths/Path.rs
+++ b/src/paths/Path.rs
@@ -1,10 +1,8 @@
-// PORT NOTE: Zig's comptime enum options become `const u8` generics on stable
+// Enum options are passed as `const u8` generics on stable
 // (adt_const_params is nightly-only). Each fn that branches on an option
-// reconstructs the enum from the u8 via `decode_opts!` so the original
-// `match Kind::Abs => ..` arms stay unchanged. The optimizer sees through the
+// reconstructs the enum from the u8 via `decode_opts!` so the
+// `match Kind::Abs => ..` arms stay readable. The optimizer sees through the
 // `const fn from_u8` so monomorphization is preserved.
-// TODO(refactor): either enable the feature crate-wide or lower the const-generic
-// enums to a trait-per-option encoding if nightly is unacceptable.
 
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
@@ -19,11 +17,10 @@ use bun_core::{Fd, WStr, ZStr, strings};
 // Options
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig models `Options` as a struct of comptime enum fields passed as a single
-// `comptime opts: Options` parameter. Rust cannot take a struct as a const
-// generic on stable, so the fields are spread as individual const-generic
-// parameters on `Path` below. The `Options` namespace is kept as a module for
-// the enums so diff readers can map `Options.Kind` ↔ `options::Kind`.
+// Rust cannot take a struct as a const
+// generic on stable, so the option fields are spread as individual
+// const-generic parameters on `Path` below. The `Options` namespace is kept
+// as a module for the enums.
 
 pub mod options {
     use super::*;
@@ -104,7 +101,6 @@ pub mod options {
     impl PathSeparators {
         pub const fn char(self) -> u8 {
             match self {
-                // Zig: @compileError("use the existing slash")
                 PathSeparators::Any => panic!("use the existing slash"),
                 PathSeparators::Auto => SEP,
                 PathSeparators::Posix => SEP_POSIX,
@@ -113,12 +109,11 @@ pub mod options {
         }
     }
 
-    // Zig: `pub fn pathUnit(comptime opts) type` / `notPathUnit`
-    // Rust models this as a trait with an associated `Other` type; see `PathUnit` below.
+    // Path units are modeled as a trait with an associated `Other` type; see
+    // `PathUnit` below.
 
-    // Zig: `pub fn maxPathLength(comptime opts) usize`
-    // Moved to `PathUnit::MAX_PATH` associated const; the `.assume_always_less_than_max_path`
-    // arm's @compileError is enforced by simply never reading MAX_PATH in that mode.
+    // The max path length is the `PathUnit::MAX_PATH` associated const; in
+    // `.assume_always_less_than_max_path` mode it is simply never read.
 
     /// `error{MaxPathExceeded}`
     #[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error, strum::IntoStaticStr)]
@@ -133,25 +128,18 @@ pub mod options {
         }
     }
 
-    // Zig: `pub fn ResultFn(comptime opts) fn(type) type` — returns `T` when
-    // `.assume_always_less_than_max_path`, `Error!T` otherwise.
-    //
-    // TODO(port): Rust cannot vary a fn's return type on a const-generic value.
-    // All `Result(T)` call sites below return `Result<T, Error>` unconditionally;
+    // Rust cannot vary a fn's return type on a const-generic value, so all
+    // `Result(T)` call sites below return `Result<T, Error>` unconditionally;
     // callers configured with `AssumeAlwaysLessThanMaxPath` should treat the
-    // `Err` arm as unreachable. Could split into two inherent impls via
-    // `where` bounds on `CHECK_LENGTH` once `generic_const_exprs` lands, or
-    // expose `_unchecked` variants.
+    // `Err` arm as unreachable (see `AssumeOk` below).
     pub type Result<T> = core::result::Result<T, Error>;
 
     /// `Result::unwrap` for the `CheckLength::AssumeAlwaysLessThanMaxPath`
     /// configuration (every `Auto*`/`Os*` `Path` alias).
     ///
-    /// In Zig, `Path(.{ .check_length = .assume_always_less_than_max_path })`
-    /// `from`/`append`/`appendFmt` return bare `T` (not `Error!T`), so call
-    /// sites are `path.append(x)` with no `try`. The Rust port returns
-    /// `Result<T, Error>` unconditionally (see PORT NOTE above), but the
-    /// `from`/`append` bodies *skip the length check entirely* in `ASSUME`
+    /// `from`/`append`/`append_fmt` return
+    /// `Result<T, Error>` unconditionally (see note above), but their
+    /// bodies *skip the length check entirely* in `ASSUME`
     /// mode -- `Err(MaxPathExceeded)` is dead code, and an over-long input
     /// instead panics inside `PooledBuf::append` slice indexing. So callers
     /// on `ASSUME` types should use this instead of `?`/`handle_oom`: it
@@ -178,10 +166,6 @@ pub mod options {
             }
         }
     }
-
-    // Zig: `pub fn inputChildType(opts, InputType) type` — strips array-ness
-    // off string literals to get the element type. In Rust the generic `&[C]`
-    // parameter already names `C` directly, so this helper disappears.
 }
 
 use options::{CheckLength, Error as PathError, Kind, PathSeparators};
@@ -227,8 +211,8 @@ pub trait PathUnit: crate::PathChar {
     /// `bun.path_buffer_pool.get()` / `bun.w_path_buffer_pool.get()`
     // LIFETIMES.tsv classifies `Buf.pooled` as OWNED → Box<PathBuffer>; the
     // underlying pool hands out heap buffers and reclaims them in `deinit`.
-    // TODO(port): swap to `crate::path_buffer_pool()` RAII guard once the
-    // guard type is generic over unit; for now model as Box and put-back in Drop.
+    // Modeled as Box with put-back in `Path`'s Drop impl below (the pool's
+    // RAII guard type is not generic over unit).
     fn pool_get() -> Box<Self::Buffer>;
     fn pool_put(buf: Box<Self::Buffer>);
 
@@ -237,7 +221,7 @@ pub trait PathUnit: crate::PathChar {
 
     /// `bun.windows.long_path_prefix{,_u8}` lifted into the unit trait so
     /// `crate::windows::long_path_prefix_for::<U>()` can pick the right width without a runtime
-    /// switch. Mirrors Zig's comptime branch on `.u8`/`.u16` in `paths/Path.zig`.
+    /// switch.
     const LONG_PATH_PREFIX: &'static [Self];
 
     // ── identity downcasts ────────────────────────────────────────────────
@@ -376,7 +360,7 @@ impl PathUnit for u16 {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Buf — `opts.Buf()` (only the `.pool` variant is implemented in Zig)
+// Buf — only the `.pool` variant is implemented
 // ──────────────────────────────────────────────────────────────────────────
 
 pub(crate) struct Buf<U: PathUnit, const SEP_OPT: u8> {
@@ -436,10 +420,8 @@ impl<U: PathUnit, const SEP_OPT: u8> Buf<U, SEP_OPT> {
             self.len += 1;
         }
 
-        // TODO(port): the Zig branches on `opts.inputChildType(@TypeOf(characters))` to pick
-        // convertUTF8toUTF16InBuffer vs convertUTF16toUTF8InBuffer. Rust cannot match on a
-        // type parameter at runtime; could route through a helper trait. For now this
-        // dispatches via TypeId-equivalent specialization on the two concrete impls.
+        // Width dispatch happens via `convert_into_buffer`'s per-unit
+        // specialization on the two concrete `PathUnit` impls.
         let converted_len = convert_into_buffer::<U>(&mut buf[self.len..], characters);
         if SEP_OPT != PathSeparators::ANY {
             for off in 0..converted_len {
@@ -453,7 +435,7 @@ impl<U: PathUnit, const SEP_OPT: u8> Buf<U, SEP_OPT> {
     }
 }
 
-/// Width-generic `bun.strings.basename` (Zig: `src/string/immutable/paths.zig:413`).
+/// Width-generic `bun.strings.basename`.
 /// Platform-split: POSIX recognizes only `/`; Windows recognizes `/`, `\`, and
 /// the `X:` drive designator at index 1.
 #[inline]
@@ -465,9 +447,9 @@ fn basename_generic<U: PathUnit>(path: &[U]) -> &[U] {
     }
 }
 
-/// Width-generic `bun.Dirname.dirname` (Zig: `src/bun.zig:2520`).
-/// Platform-split: POSIX is `std.fs.path.dirnamePosix` (only `/`); Windows is
-/// `dirnameWindows` with disk-designator handling.
+/// Width-generic `bun.Dirname.dirname`.
+/// Platform-split: POSIX considers only `/`; Windows adds
+/// disk-designator handling.
 pub(crate) fn dirname_generic<U: PathUnit>(path: &[U]) -> Option<&[U]> {
     #[cfg(not(windows))]
     return dirname_posix(path);
@@ -541,7 +523,7 @@ fn dirname_windows<U: PathUnit>(path: &[U]) -> Option<&[U]> {
 /// `windowsParsePath(..).disk_designator.len`. Handles drive-letter (`C:` → 2)
 /// and UNC NetworkShare (`\\server\share` → index past second token).
 pub(crate) fn disk_designator_len_windows<U: PathUnit>(path: &[U]) -> usize {
-    // Zig: `path_.len >= 2 and path_[1] == ':'` — no alphabetic check on path_[0].
+    // No alphabetic check on path[0].
     if path.len() >= 2 && path[1].eq_ascii(b':') {
         return 2;
     }
@@ -564,7 +546,7 @@ pub(crate) fn disk_designator_len_windows<U: PathUnit>(path: &[U]) -> usize {
             if path[2].eq_ascii(this_sep) {
                 return 0;
             }
-            // `std.mem.tokenizeScalar(T, path, this_sep)`: skip sep runs,
+            // Tokenize on `this_sep`: skip sep runs,
             // yield non-empty tokens; after two `next()`, `it.index` is the
             // offset just past the second token (at next sep or len).
             let mut idx = 0usize;
@@ -604,7 +586,7 @@ pub type AbsPath<
     const CHECK: u8 = { CheckLength::ASSUME },
 > = Path<U, { Kind::ABS }, SEP_OPT, CHECK>;
 
-/// `Path(.{ .kind = .abs, .sep = .auto })`
+/// Absolute path with auto separator.
 pub type AutoAbsPath = Path<u8, { Kind::ABS }, { PathSeparators::AUTO }>;
 
 /// `RelPath(opts)` — forces `kind = .rel`.
@@ -614,12 +596,13 @@ pub type RelPath<
     const CHECK: u8 = { CheckLength::ASSUME },
 > = Path<U, { Kind::REL }, SEP_OPT, CHECK>;
 
-/// `Path(.{ .kind = .rel, .sep = .auto })`
+/// Relative path with auto separator.
 pub type AutoRelPath = Path<u8, { Kind::REL }, { PathSeparators::AUTO }>;
 
-/// `Path(comptime opts: Options) type`
+/// Generic path buffer parameterised by unit width, kind, and separator
+/// options.
 ///
-/// `BufType` is omitted as a parameter because only `.pool` is implemented in Zig.
+/// `BufType` is omitted as a parameter because only `.pool` is implemented.
 /// `Unit` is encoded as the type parameter `U: PathUnit` (use `u8` or `u16`).
 pub struct Path<
     U: PathUnit = u8,
@@ -656,14 +639,13 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
                 debug_assert!(is_input_absolute(top_level_dir));
                 trim_input(TrimInputKind::Abs, top_level_dir)
             }
-            // Zig: @compileError("cannot create a relative path from top_level_dir")
             Kind::Rel => panic!("cannot create a relative path from top_level_dir"),
             Kind::Any => trim_input(TrimInputKind::Abs, top_level_dir),
         };
 
         let mut this = Self::init();
-        // TODO(port): top_level_dir is &[u8]; when U == u16 this should route through
-        // append_other. See note on `append_input` below.
+        // top_level_dir is &[u8]; `_buf_append_input` routes it through
+        // `append_other` (transcoding) when U == u16.
         this._buf_append_input(trimmed, false);
         this
     }
@@ -702,20 +684,17 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
 
         // `getFdPath`/`getFdPathW` are libc/kernel32-only, so the bodies live
         // in `bun_core::fd_path_raw[_w]` (T0). >0 = units written, <0 = error.
-        // PORT NOTE: Zig `fd.getFdPath(this._buf.pooled)` dispatches on the
-        // pooled buffer's element type (u8 → readlink/F_GETPATH, u16 →
-        // GetFinalPathNameByHandleW). Rust monomorphizes eagerly, so we
-        // TypeId-dispatch on the buffer element type.
+        // Dispatch on the pooled buffer's element type (u8 →
+        // readlink/F_GETPATH, u16 → GetFinalPathNameByHandleW) via TypeId.
         use core::any::TypeId;
         let mut this = Self::init();
 
         if TypeId::of::<U>() == TypeId::of::<u8>() {
             let buf: &mut [u8] = U::id_u8_mut(U::buffer_as_mut_slice(&mut this._buf.pooled));
 
-            // Zig spec (`bun.getFdPath` with `*PathBuffer`): on Windows the
-            // u8 path still resolves via `GetFinalPathNameByHandleW` into a
-            // stack `WPathBuffer`, then transcodes to UTF-8 with
-            // `strings.copyUTF16IntoUTF8`. `fd_path_raw` has no Windows arm
+            // On Windows the u8 path still resolves via
+            // `GetFinalPathNameByHandleW` into a stack `WPathBuffer`, then
+            // transcodes to UTF-8. `fd_path_raw` has no Windows arm
             // (returns 0), so route through the wide call here.
             #[cfg(windows)]
             {
@@ -724,14 +703,14 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
                 // SAFETY: wslice is valid for wslice.len() writable u16 units.
                 let n = unsafe { bun_core::fd_path_raw_w(fd, wslice.as_mut_ptr(), wslice.len()) };
                 if n <= 0 {
-                    // Zig `bun.windows.GetFinalPathNameByHandle` surfaces
-                    // `error.FileNotFound` (return_length==0) or
-                    // `error.NameTooLong` (return_length>=buf.len);
-                    // `fd_path_raw_w` collapses both to -1, so propagate the
-                    // dominant Zig error rather than inventing EBADF.
-                    // TODO(port): have `fd_path_raw_w` distinguish overflow
-                    // (e.g. -2) so callers can map ENAMETOOLONG separately.
-                    return Err(bun_core::Error::intern("FileNotFound"));
+                    // `GetFinalPathNameByHandle` surfaces
+                    // FileNotFound (return_length==0 → -1) or
+                    // NameTooLong (return_length>=buf.len → -2).
+                    return Err(if n == -2 {
+                        bun_core::Error::intern("NameTooLong")
+                    } else {
+                        bun_core::Error::intern("FileNotFound")
+                    });
                 }
                 let wide = &wslice[..n as usize];
                 let written = strings::convert_utf16_to_utf8_in_buffer(buf, wide).len();
@@ -746,7 +725,7 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
                 // SAFETY: buf is valid for buf.len() writable bytes.
                 let n = unsafe { bun_core::fd_path_raw(fd, buf.as_mut_ptr(), buf.len()) };
                 // `fd_path_raw` returns 0 on misc failure — do not swallow as
-                // an empty path; Zig `try fd.getFdPath(...)` propagates errors.
+                // an empty path; propagate an error.
                 if n <= 0 {
                     return Err(bun_core::Error::from_errno(9)); // EBADF — fd_path_raw surfaces no errno
                 }
@@ -761,11 +740,14 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
             // SAFETY: buf is valid for buf.len() writable u16 units.
             let n = unsafe { bun_core::fd_path_raw_w(fd, buf.as_mut_ptr(), buf.len()) };
             if n <= 0 {
-                // Zig `bun.windows.GetFinalPathNameByHandle` surfaces
-                // `error.FileNotFound` / `error.NameTooLong`; `fd_path_raw_w`
-                // collapses both to -1, so propagate the dominant Zig error
-                // rather than inventing EBADF.
-                return Err(bun_core::Error::intern("FileNotFound"));
+                // `GetFinalPathNameByHandle` surfaces
+                // FileNotFound (return_length==0 → -1) or
+                // NameTooLong (return_length>=buf.len → -2).
+                return Err(if n == -2 {
+                    bun_core::Error::intern("NameTooLong")
+                } else {
+                    bun_core::Error::intern("FileNotFound")
+                });
             }
             let raw = &buf[..n as usize];
             let trimmed = trim_input(TrimInputKind::Abs, raw);
@@ -775,7 +757,6 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
     }
 
     pub fn from_long_path<C: PathUnit>(input: &[C]) -> options::Result<Self> {
-        // Zig restricts @TypeOf(input) to u8/u16 slices; the `C: PathUnit` bound enforces that.
         let trimmed = match Kind::from_u8(KIND) {
             Kind::Abs => {
                 debug_assert!(is_input_absolute(input));
@@ -844,8 +825,8 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
 
     pub fn is_absolute(&self) -> bool {
         match Kind::from_u8(KIND) {
-            // Zig: @compileError — Rust can't compile-error on a const-generic value
-            // without specialization; debug-panic instead.
+            // Rust can't compile-error on a const-generic value
+            // without specialization; panic instead.
             Kind::Abs => panic!("already known to be absolute"),
             Kind::Rel => panic!("already known to not be absolute"),
             Kind::Any => is_input_absolute(self.slice()),
@@ -857,13 +838,11 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
     }
 
     pub fn basename_z(&mut self) -> &U::ZSlice {
-        // PORT NOTE: reshaped for borrowck (Zig took *const and wrote NUL via @constCast).
         let len = self._buf.len;
         let buf = U::buffer_as_mut_slice(&mut self._buf.pooled);
         buf[len] = U::from_u8(0);
         let base_len = basename_generic(&buf[..len]).len();
-        // Mirror Zig `full[full.len - base.len ..][0..base.len :0]` exactly:
-        // index from the END of `buf[..len]`, not from `base.as_ptr()`, so that
+        // Index from the END of `buf[..len]`, not from `base.as_ptr()`, so that
         // when `base_len == 0` the result points at `buf[len]` (the NUL just
         // written) and the sentinel invariant holds.
         // SAFETY: `base_len <= len`, `buf[len] == 0`, and `buf` outlives the
@@ -881,7 +860,7 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
     }
 
     /// Reinterpret this path under a different `SEP_OPT` const parameter.
-    /// Zig's `bun.Path(.{ .sep = .auto })` and `bun.Path(.{})` are
+    /// All `SEP_OPT` instantiations are
     /// structurally identical at runtime — the option only affects how
     /// `append`/`append_join` normalize separators going forward — so
     /// passing a built path to a callee typed with a different `sep`
@@ -910,7 +889,6 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
 
     pub fn slice_z(&mut self) -> &U::ZSlice {
         // match BufType::Pool
-        // PORT NOTE: reshaped for borrowck (Zig took *const and wrote NUL via @constCast).
         let len = self._buf.len;
         let buf = U::buffer_as_mut_slice(&mut self._buf.pooled);
         buf[len] = U::from_u8(0);
@@ -920,7 +898,6 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
 
     pub fn buf(&mut self) -> &mut [U] {
         // match BufType::Pool
-        // PORT NOTE: reshaped for borrowck (Zig took *const and handed out a mutable slice).
         U::buffer_as_mut_slice(&mut self._buf.pooled)
     }
 
@@ -1092,7 +1069,8 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
     }
 
     pub fn join(&mut self, parts: &[&[U]]) -> options::Result<()> {
-        // TODO(port): Zig @compileError when unit == u16; enforced here at runtime.
+        // Rust can't compile-error on a
+        // type parameter without specialization; enforced here at runtime.
         if core::any::TypeId::of::<U>() == core::any::TypeId::of::<u16>() {
             panic!("unsupported unit type");
         }
@@ -1132,11 +1110,8 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
             }
         }
 
-        // TODO(port): the Zig dispatches on `@TypeOf(part)` × `opts.pathUnit()` to pick
-        // joinStringBuf vs joinStringBufW vs a transcode-then-recurse path. Rust cannot
-        // match on type identity in a fn body without specialization. The four arms are
-        // reproduced below via TypeId checks; could be replaced with a sealed-trait
-        // dispatch on (C, U).
+        // The four (C, U) arms are dispatched below via TypeId checks, which
+        // const-fold to a single arm per monomorphization.
         use core::any::TypeId;
         let c_is_u8 = TypeId::of::<C>() == TypeId::of::<u8>();
         let u_is_u8 = TypeId::of::<U>() == TypeId::of::<u8>();
@@ -1163,7 +1138,6 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
                 let part_u8: &[u8] = C::id_u8(part);
                 let converted =
                     strings::convert_utf8_to_utf16_in_buffer(&mut path_buf[..], part_u8);
-                // Zig recurses on `appendJoin(converted)`.
                 return self.append_join::<u16>(converted);
             }
             (false, false) => {
@@ -1196,13 +1170,9 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
         &self,
         to: &Path<U, K2, SEP_OPT, CHECK>,
     ) -> RelPath<U, SEP_OPT, CHECK> {
-        // PORT NOTE: `resolve_path::relative_buf_z` is `&[u8]`-only and the Zig
-        // had no u16 variant either — Path.zig `relative` calls `relativeBufZ`
-        // unconditionally, which would compile-error on a u16 instantiation
-        // (Zig's lazy eval hides that). Rust monomorphizes eagerly, so we
+        // `resolve_path::relative_buf_z` is `&[u8]`-only, so we
         // TypeId-dispatch: u8 → identity-cast and call; u16 → transcode through
-        // temp u8 buffers and back. TODO(port): width-generic
-        // `relative_buf_z_t<C>` if u16 callers turn out to be hot.
+        // temp u8 buffers and back.
         use core::any::TypeId;
         let mut output: RelPath<U, SEP_OPT, CHECK> = Path::init();
 
@@ -1217,8 +1187,8 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
             // U == u16: transcode from/to → u8 scratch buffers, compute the
             // relative path in u8-space, then transcode back into the u16
             // output buffer. Mirrors the cross-width arms in `append_join`.
-            // PERF(port): three pooled buffers + two transcodes — profile if
-            // hot; only ever reached on Windows wide-path callers.
+            // Three pooled buffers + two transcodes — only ever reached on
+            // Windows wide-path callers.
             let from_u16: &[u16] = U::id_u16(self.slice());
             let to_u16: &[u16] = U::id_u16(to.slice());
 
@@ -1291,7 +1261,7 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8>
     // ── private helpers ──────────────────────────────────────────────────
 
     /// Dispatch `Buf::append` / `Buf::append_other` based on whether the input
-    /// element type matches `U`. Stands in for Zig's `anytype` + `inputChildType`.
+    /// element type matches `U`.
     fn _buf_append_input<C: PathUnit>(&mut self, characters: &[C], add_separator: bool) {
         use core::any::TypeId;
         // Route via concrete `u8`/`u16` using the safe trait-dispatched
@@ -1326,9 +1296,6 @@ impl<U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8> Drop
         // SAFETY: `pooled` is initialized in `init()` and never taken before this; Drop runs once.
         let pooled = unsafe { ManuallyDrop::take(&mut self._buf.pooled) };
         U::pool_put(pooled);
-        // TODO(port): replace Box<Buffer> + manual put-back with the
-        // `crate::path_buffer_pool()` RAII guard once it is generic over
-        // unit, then delete this Drop impl entirely.
     }
 }
 
@@ -1367,7 +1334,7 @@ impl<'a, U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8> core::
 impl<'a, U: PathUnit, const KIND: u8, const SEP_OPT: u8, const CHECK: u8> Drop
     for ResetScope<'a, U, KIND, SEP_OPT, CHECK>
 {
-    /// Mirrors Zig `defer save.restore()` — truncate the path back to its
+    /// Truncate the path back to its
     /// length at `save()` time on every scope exit (including `?` early
     /// returns).
     fn drop(&mut self) {
@@ -1546,5 +1513,3 @@ fn is_input_absolute<C: PathUnit>(input: &[C]) -> bool {
 
     false
 }
-
-// ported from: src/paths/Path.zig
diff --git a/src/paths/component_iterator.rs b/src/paths/component_iterator.rs
index 3ccc9c4715d..6cb97959131 100644
--- a/src/paths/component_iterator.rs
+++ b/src/paths/component_iterator.rs
@@ -1,5 +1,5 @@
-//! Port of `std.fs.path.ComponentIterator(format, T)` + the `std.fs.Dir.makePath`
-//! back-then-forward walk. Pure path logic — no I/O; the mkdir walk takes a
+//! Path component iteration plus the recursive-mkdir back-then-forward
+//! walk. Pure path logic — no I/O; the mkdir walk takes a
 //! closure so callers supply `mkdirat` / `NtCreateFile(FILE_OPEN_IF)` /
 //! `CreateDirectoryW` themselves.
 //!
@@ -11,7 +11,7 @@
 
 use crate::PathChar;
 
-/// Runtime equivalent of Zig's `comptime path_type: PathType`. The hot
+/// Path format selector. The hot
 /// `is_sep` branch inlines to a single compare on POSIX and two compares on
 /// Windows; we keep it a runtime enum (vs. a const-generic) so one
 /// monomorphisation per `T` covers both — call sites that hard-code the
@@ -23,7 +23,7 @@ pub enum PathFormat {
 }
 
 impl PathFormat {
-    /// `std.fs.path.native_os` → `.windows` / `.posix`.
+    /// The native path format for the target OS.
     #[cfg(windows)]
     pub const NATIVE: Self = Self::Windows;
     #[cfg(not(windows))]
@@ -50,7 +50,7 @@ pub struct Component<'a, T> {
     pub path: &'a [T],
 }
 
-/// Port of `std.fs.path.ComponentIterator(path_type, T)` — bidirectional
+/// A bidirectional
 /// iterator over `Component`s with a parsed root prefix that is never yielded.
 #[derive(Clone, Copy, Debug)]
 pub struct ComponentIterator<'a, T> {
@@ -206,7 +206,7 @@ impl<'a, T: PathChar> ComponentIterator<'a, T> {
     }
 }
 
-/// `std.fs.path.componentIterator` — native-format convenience wrapper over
+/// Native-format convenience wrapper over
 /// `ComponentIterator::init` for `u8` paths.
 #[inline]
 pub fn component_iterator(path: &[u8]) -> Result<ComponentIterator<'_, u8>, bun_core::Error> {
@@ -227,7 +227,7 @@ pub enum MakePathStep<E> {
     NotFound(E),
 }
 
-/// Port of the `std.fs.Dir.makePath` back-then-forward walk, parameterised
+/// The recursive-mkdir back-then-forward walk, parameterised
 /// over the per-prefix `mkdir` step so callers supply `mkdirat` /
 /// `NtCreateFile(FILE_OPEN_IF)` / `CreateDirectoryW` themselves.
 ///
@@ -265,8 +265,8 @@ pub fn make_path_with<'a, T: PathChar, E>(
 }
 
 // ─── Windows root parsing ───────────────────────────────────────────────────
-// Direct port of `std.os.windows.{getNamespacePrefix, getUnprefixedPathType}`
-// + the `.windows` arm of `ComponentIterator.init`. Kept private — callers
+// Windows namespace-prefix and unprefixed-path-type parsing backing the
+// Windows arm of `ComponentIterator::init`. Kept private — callers
 // only see `ComponentIterator::init`; for ad-hoc root-length probing
 // `resolve_path::windows_filesystem_root_t` already exists.
 
diff --git a/src/paths/lib.rs b/src/paths/lib.rs
index ab93d95081e..b8598cfd244 100644
--- a/src/paths/lib.rs
+++ b/src/paths/lib.rs
@@ -1,6 +1,6 @@
 #![warn(unused_must_use)]
-// `Platform` is used as a const-generic param (Zig: `comptime _platform: Platform`)
-// in resolve_path.rs and downstream (`bun_runtime::node::path::normalize_string_t`).
+// `Platform` is used as a const-generic param in resolve_path.rs and
+// downstream (`bun_runtime::node::path::normalize_string_t`).
 // Pinned nightly — enable the structural-match subset directly instead of the
 // `PlatformT` sealed-trait workaround.
 #![feature(adt_const_params)]
@@ -26,7 +26,7 @@ pub mod w_path_buffer_pool {
 // `bun.strings.paths` — Windows path-shape transcoders. Hosted here (not in
 // `bun_core::string::immutable`) to avoid a `bun_core → bun_paths` cycle.
 // Exposed as both `bun_paths::string_paths::*` and the flattened
-// `bun_paths::strings::*` (Zig-parity: `bun.strings.toNTPath` etc).
+// `bun_paths::strings::*`.
 // ──────────────────────────────────────────────────────────────────────────
 pub mod string_paths;
 /// `bun.strings.*` superset: `bun_core`'s scalar/SIMD string utils plus the
@@ -39,7 +39,7 @@ pub mod strings {
     // Disambiguate names that exist in both `bun_core::strings` and
     // `string_paths` (path-shape transcoders win — they're the canonical
     // `bun.strings.*` impl that depends on this crate's path helpers).
-    /// `bun.strings.paths` submodule alias (Zig: `bun.strings.paths.X`).
+    /// `bun.strings.paths` submodule alias.
     pub use super::string_paths as paths;
     pub use super::string_paths::from_w_path as from_wpath;
     pub use super::string_paths::to_w_path_normalized as to_wpath_normalized;
@@ -49,14 +49,12 @@ pub mod strings {
     };
 }
 
-// std.fs.path equivalents (PORTING.md §Crate map: never std::path).
+// Native separator re-exports (PORTING.md §Crate map: never std::path).
 pub use bun_alloc::SEP;
 pub use bun_alloc::SEP_STR;
 
 /// `<SEP>node_modules<SEP>` — platform-dependent infix needle for detecting whether
-/// a path passes through a `node_modules` directory. Zig writes this inline at every
-/// site as `std.fs.path.sep_str ++ "node_modules" ++ std.fs.path.sep_str` (comptime
-/// `++`); Rust has no comptime concat operator, so we name it once here.
+/// a path passes through a `node_modules` directory.
 pub const NODE_MODULES_NEEDLE: &[u8] =
     const_format::concatcp!(SEP_STR, "node_modules", SEP_STR).as_bytes();
 
@@ -69,13 +67,13 @@ pub const NODE_MODULES_TRAILING: &[u8] =
 pub(crate) const SEP_POSIX: u8 = b'/';
 pub const SEP_WINDOWS: u8 = b'\\';
 
-/// Port of `std.fs.path.isAbsolutePosix`.
+/// Returns true if `p` is POSIX-absolute (starts with `/`).
 #[inline]
 pub fn is_absolute_posix(p: &[u8]) -> bool {
     !p.is_empty() && p[0] == b'/'
 }
 
-/// Generic over u8/u16. Port of `std.fs.path.isAbsoluteWindows{,WTF16}`.
+/// Returns true if `p` is Windows-absolute. Generic over u8/u16.
 pub fn is_absolute_windows_t<T: PathChar>(p: &[T]) -> bool {
     if p.is_empty() {
         return false;
@@ -84,7 +82,7 @@ pub fn is_absolute_windows_t<T: PathChar>(p: &[T]) -> bool {
     if c0 == T::from_u8(b'/') || c0 == T::from_u8(b'\\') {
         return true;
     }
-    // Drive letter: `X:\` or `X:/` — Zig std does NOT require `X` be alphabetic.
+    // Drive letter: `X:\` or `X:/` — `X` is NOT required to be alphabetic.
     if p.len() >= 3
         && p[1] == T::from_u8(b':')
         && (p[2] == T::from_u8(b'/') || p[2] == T::from_u8(b'\\'))
@@ -97,17 +95,16 @@ pub fn is_absolute_windows_t<T: PathChar>(p: &[T]) -> bool {
 pub fn is_absolute_windows(p: &[u8]) -> bool {
     is_absolute_windows_t::<u8>(p)
 }
-/// `std.fs.path.isAbsoluteWindowsWTF16` — UTF-16 sibling.
+/// UTF-16 sibling of [`is_absolute_windows`].
 #[inline]
 pub fn is_absolute_windows_wtf16(p: &[u16]) -> bool {
     is_absolute_windows_t::<u16>(p)
 }
 
-/// Port of `std.fs.path.diskDesignatorWindows` — returns the leading drive
+/// Returns the leading drive
 /// designator (e.g. `C:` or `\\server\share`) or empty.
 ///
-/// Faithful to Zig std `windowsParsePath`: no alphabetic gate on the drive
-/// letter; UNC requires a *matching* separator pair (`//` or `\\`, not mixed),
+/// No alphabetic gate on the drive letter; UNC requires a *matching* separator pair (`//` or `\\`, not mixed),
 /// rejects a third leading separator, and requires BOTH server and share
 /// tokens — otherwise returns `b""`.
 #[inline]
@@ -123,13 +120,13 @@ pub use path_char::PathChar;
 pub const DELIMITER: u8 = if cfg!(windows) { b';' } else { b':' };
 
 /// `bun.pathLiteral("a/b")` → NUL-terminated path with platform separators.
-/// Port of `bun.zig:pathLiteral` — on POSIX returns the literal as-is; on
+/// On POSIX returns the literal as-is; on
 /// Windows rewrites `/` → `\` at compile time. Yields `&'static ZStr` so it
 /// drops into `[:0]const u8` slots (`stringZ`).
 #[macro_export]
 macro_rules! path_literal {
     ($lit:expr) => {{
-        // Port of `bun.zig:pathLiteral` — on Windows, const-eval `/`→`\` so
+        // On Windows, const-eval `/`→`\` so
         // callers feeding `\\?\`-prefixed NT paths get backslashes (Win32 does
         // NOT normalize `/` under the `\\?\` namespace). On POSIX the rewrite
         // condition is `false` and bytes copy through unchanged.
@@ -157,7 +154,7 @@ macro_rules! path_literal {
 }
 
 /// `bun.OSPathLiteral` — like `path_literal!` but yields the platform path-char
-/// width (`u8` on POSIX, `u16` on Windows). Port of `bun.zig:OSPathLiteral`.
+/// width (`u8` on POSIX, `u16` on Windows).
 ///
 /// Evaluates to `&'static OSPathSliceZ` (i.e. `&ZStr` on POSIX, `&WStr` on
 /// Windows). Both deref to `&[OSPathChar]`, so call sites that want a bare
@@ -210,9 +207,8 @@ pub fn is_absolute(p: &[u8]) -> bool {
 // CANONICAL ALREADY EXISTS — no new primitive. Two entry points cover all
 // legitimate callers:
 //
-//   1. bun_paths::is_absolute(p)           — host cfg-dispatched (Zig:
-//      std.fs.path.isAbsolute). Use when the path came from THIS host's
-//      filesystem.
+//   1. bun_paths::is_absolute(p)           — host cfg-dispatched. Use when
+//      the path came from THIS host's filesystem.
 //
 //   2. bun_paths::resolve_path::Platform::Loose.is_absolute(p) — host-agnostic
 //      (accepts '/', '\\', and 'X:/'|'X:\\' on ANY host). Use when the path is
@@ -221,17 +217,16 @@ pub fn is_absolute(p: &[u8]) -> bool {
 // `is_absolute_loose` is a thin discoverable wrapper for (2) so call sites
 // don't have to spell out `resolve_path::Platform::Loose.is_absolute(..)`.
 /// Host-agnostic absolute-path check: accepts `/…`, `\…`, and `X:/…`/`X:\…`
-/// on ANY host. Faithful to Zig std `isAbsoluteWindows` (no alphabetic gate
-/// on the drive byte). Use for cross-platform map keys / bundler specifiers
+/// on ANY host (no alphabetic gate on the drive byte). Use for
+/// cross-platform map keys / bundler specifiers
 /// where the input may have come from either OS.
 #[inline]
 pub fn is_absolute_loose(p: &[u8]) -> bool {
     resolve_path::Platform::Loose.is_absolute(p)
 }
 
-// ───── std.fs.path.join / joinZ (non-normalizing) ─────
-// Faithful port of vendor/zig/lib/std/fs/path.zig `joinSepMaybeZ` with
-// `sep = path.sep`, `isSep = path.isSep` (both '/' and '\\' on Windows):
+// ───── non-normalizing join helpers ─────
+// Treats both '/' and '\\' as separators on Windows:
 // concatenates `parts`, skipping empties, inserting SEP only when neither
 // seam side already has one, and stripping exactly one leading sep when both
 // sides have one. Byte-level / ASCII-sep only — never normalizes.
@@ -258,9 +253,9 @@ fn join_sep_vec(parts: &[&[u8]]) -> Vec<u8> {
     }
     out
 }
-/// `std.fs.path.join` / `std.fs.path.joinZ` — non-normalizing concatenation
+/// Non-normalizing concatenation
 /// with the native separator. When `SENTINEL` the trailing NUL is included in
-/// the returned slice (Zig: `[:0]u8` coerced to `[]u8`).
+/// the returned slice.
 #[inline]
 pub fn join_sep_maybe_z<const SENTINEL: bool>(parts: &[&[u8]]) -> Box<[u8]> {
     let mut out = join_sep_vec(parts);
@@ -269,8 +264,8 @@ pub fn join_sep_maybe_z<const SENTINEL: bool>(parts: &[&[u8]]) -> Box<[u8]> {
     }
     out.into_boxed_slice()
 }
-/// NOT a port of `std.fs.path.dirname` — this is the naive "slice before last
-/// separator" used by a handful of callers that want exactly that. For Zig-std
+/// NOT full `dirname` — this is the naive "slice before last
+/// separator" used by a handful of callers that want exactly that. For full
 /// `dirname` semantics (Option, trailing-slash handling, root preservation)
 /// use `bun_core::dirname`.
 pub fn dirname_simple(p: &[u8]) -> &[u8] {
@@ -279,12 +274,12 @@ pub fn dirname_simple(p: &[u8]) -> &[u8] {
         .map(|i| &p[..i])
         .unwrap_or(b"")
 }
-/// Port of `std.fs.path.basename` — strips trailing separators before slicing
+/// Basename: strips trailing separators before slicing
 /// the final component (so `basename("/a/b/")` is `"b"`, not `""`).
 /// Canonical impls (width-generic over `PathByte`) live in `bun_core::strings`.
 pub use bun_core::strings::{PathByte, basename, basename_posix, basename_windows};
 
-/// Port of `std.fs.path.extension` — returns the file extension of `p`
+/// Returns the file extension of `p`
 /// **including** the leading dot, or `b""` if none. Dotfiles (`.gitignore`)
 /// and basenames whose only `.` is at index 0 report no extension.
 pub fn extension(p: &[u8]) -> &[u8] {
@@ -295,7 +290,7 @@ pub fn extension(p: &[u8]) -> &[u8] {
     }
 }
 
-/// Port of `std.fs.path.stem` — returns the basename of `p` with the
+/// Returns the basename of `p` with the
 /// extension (as defined by [`extension`]) stripped. Dotfiles keep their
 /// leading dot (`.gitignore` → `.gitignore`).
 pub fn stem(p: &[u8]) -> &[u8] {
@@ -312,8 +307,7 @@ pub fn stem(p: &[u8]) -> &[u8] {
 // `bun_core` share a single nominal type — `bun_core::getcwd`, `bun_which::which`
 // etc. accept a buffer obtained from this crate without a pointer cast.
 pub use bun_core::{MAX_PATH_BYTES, PATH_MAX_WIDE, PathBuffer, WPathBuffer};
-/// Zig spells the wide-path capacity `bun.MAX_WPATH` (`libuv.zig` uses the same
-/// alias); keep both names so ported call sites resolve without churn.
+/// Alias for [`PATH_MAX_WIDE`].
 pub const MAX_WPATH: usize = PATH_MAX_WIDE;
 
 #[cfg(windows)]
@@ -321,7 +315,7 @@ pub type OSPathChar = u16;
 #[cfg(not(windows))]
 pub type OSPathChar = u8;
 
-// Zig: `[:0]const OSPathChar`. Callers borrow as `&OSPathSliceZ`.
+// NUL-terminated; callers borrow as `&OSPathSliceZ`.
 #[cfg(windows)]
 pub type OSPathSliceZ = bun_core::WStr;
 #[cfg(not(windows))]
@@ -346,10 +340,8 @@ pub mod component_iterator;
 pub use component_iterator::{
     Component, ComponentIterator, MakePathStep, PathFormat, component_iterator, make_path_with,
 };
-// Crate-root re-exports for the path-mutation helpers callers spell as
-// `bun.path.*` in Zig (e.g. `bun.path.dangerouslyConvertPathToPosixInPlace`,
-// `bun.path.pathToPosixBuf`). Zig flattens `resolve_path` into the `bun.path`
-// namespace; mirror that here so `#[cfg(windows)]` install paths can call
+// Crate-root re-exports for the path-mutation helpers so `#[cfg(windows)]`
+// install paths can call
 // `bun_paths::dangerously_convert_path_to_posix_in_place(..)` directly.
 pub use resolve_path::{
     dangerously_convert_path_to_posix_in_place, dangerously_convert_path_to_windows_in_place,
@@ -359,7 +351,6 @@ pub use resolve_path::{
     relative_to_common_path_buf, slashes_to_posix_in_place, slashes_to_windows_in_place,
     windows_volume_name_len,
 };
-// `bun.os_path_buffer_pool.get()` in Zig is a namespace call, not a value.
 // Re-export the pool *type* at crate root so `bun_paths::os_path_buffer_pool::get()`
 // resolves on both targets (= `WPathBuffer` pool on Windows, `PathBuffer` on
 // POSIX).
@@ -370,22 +361,19 @@ pub use path::{
     AbsPath, AutoAbsPath, AutoRelPath, Path, PathUnit, RelPath, options as path_options,
 };
 
-/// Duck-typing surface for the `anytype` `buf` parameter on Zig path-builder
-/// helpers (`appendStorePath`, `appendGlobalStoreEntryPath`, etc. in
-/// `isolated_install/Installer.zig`). Zig accepted any `bun.Path(...)`
-/// instantiation; Rust callers pass `Path<U, KIND, SEP, CHECK>` for arbitrary
-/// const params, so expose the three operations the helpers need behind a
-/// trait and blanket-impl it for every monomorphisation.
+/// Generic surface for the `buf` parameter on path-builder helpers
+/// (`appendStorePath`, `appendGlobalStoreEntryPath`, etc.). Callers pass
+/// `Path<U, KIND, SEP, CHECK>` for arbitrary const params, so expose the
+/// three operations the helpers need behind a trait and blanket-impl it for
+/// every monomorphisation.
 pub trait PathLike {
     fn clear(&mut self);
     fn append(&mut self, bytes: &[u8]);
     fn append_fmt(&mut self, args: core::fmt::Arguments<'_>);
 }
-// PORT NOTE: Bound to `CheckLength::ASSUME` only. In Zig the helpers call
-// `buf.append(x)` with no `try`, so passing a `.check_for_greater_than_max_path`
-// Path is a *compile error* (`Error!void` is not `void`). Mirroring that here
-// prevents check-mode callers from silently swallowing `MaxPathExceeded` through
-// the duck-typed surface; they must use `Path::append`/`?` directly.
+// Bound to `CheckLength::ASSUME` only. This prevents check-mode callers from
+// silently swallowing `MaxPathExceeded` through the duck-typed surface; they
+// must use `Path::append`/`?` directly.
 impl<U: PathUnit, const KIND: u8, const SEP: u8> PathLike
     for path::Path<U, KIND, SEP, { path::options::CheckLength::ASSUME }>
 {
@@ -405,7 +393,7 @@ impl<U: PathUnit, const KIND: u8, const SEP: u8> PathLike
     }
 }
 
-/// Zig: `bun.Dirname` namespace — width-generic `std.fs.path.dirname`
+/// Width-generic dirname
 /// (POSIX `/` on Unix, disk-designator-aware on Windows). Backed by
 /// `path::dirname_generic`.
 #[allow(non_snake_case)]
@@ -423,7 +411,7 @@ pub mod Dirname {
     }
 }
 
-/// Convenience: `std.fs.path.dirname` for `u8` paths (returns `None` for
+/// Convenience: dirname for `u8` paths (returns `None` for
 /// root / no-parent). Prefer `Dirname::dirname::<T>` for width-generic use.
 ///
 /// POSIX: re-exports `bun_core::dirname` (canonical u8 impl — identical state
@@ -443,7 +431,7 @@ pub use env_path::{EnvPath, EnvPathInput, PathComponentBuilder};
 
 // ──────────────────────────────────────────────────────────────────────────
 // Windows path-prefix constants — relocated from
-// `bun_sys::windows` (src/sys/windows/windows.zig) so tier-1 callers
+// `bun_sys::windows` so tier-1 callers
 // (`bun_core::immutable::paths`, this crate's `Path.rs`) can resolve them
 // without depending upward on `bun_sys`.
 // ──────────────────────────────────────────────────────────────────────────
@@ -473,7 +461,7 @@ pub mod windows {
     /// `\\?\` — Win32 long-path prefix (UTF-8/ASCII).
     pub const LONG_PATH_PREFIX_U8: [u8; 4] = *b"\\\\?\\";
 
-    /// `src/paths/Path.zig` so `Path::<U, ..>::from_long_path` stays width-generic.
+    /// Per-width long-path prefix so `Path::<U, ..>::from_long_path` stays width-generic.
     #[inline]
     pub fn long_path_prefix_for<U: crate::path::PathUnit>() -> &'static [U] {
         U::LONG_PATH_PREFIX
@@ -482,7 +470,7 @@ pub mod windows {
 
 // ──────────────────────────────────────────────────────────────────────────
 // `is_package_path` / `is_package_path_not_absolute` — pure path predicates
-// with no resolver state. Source: src/resolver/resolver.zig:6-26. Lives here
+// with no resolver state. Lives here
 // (not bun_resolver) so bun_install / bun_js_parser can drop their resolver
 // edge; bun_resolver re-exports these for its own callers.
 // ──────────────────────────────────────────────────────────────────────────
@@ -491,9 +479,7 @@ pub mod windows {
 /// i.e. not absolute and not relative (`./`, `../`, `.`, `..`).
 ///
 /// Always rejects POSIX-absolute (`/...`); on Windows additionally rejects
-/// Windows-absolute forms via `std.fs.path.isAbsolute` semantics.
-///
-/// Port of `isPackagePath` (src/resolver/resolver.zig).
+/// Windows-absolute forms via [`is_absolute`] semantics.
 #[inline]
 pub fn is_package_path(path: &[u8]) -> bool {
     !is_absolute(path) && is_package_path_not_absolute(path)
@@ -518,7 +504,6 @@ pub fn is_package_path_not_absolute(non_absolute_path: &[u8]) -> bool {
 
 // ──────────────────────────────────────────────────────────────────────────
 // `fs` — TYPE_ONLY subset of resolver fs.
-// Source: src/resolver/fs.zig.
 //
 // The full `FileSystem` (DirEntry cache, RealFS impl, FilenameStore/DirnameStore)
 // stays in `bun_resolver`; only the path-shaped types (`Path`, `PathName`,
@@ -535,26 +520,22 @@ pub mod fs {
 
     use crate::resolve_path::{is_sep_any, last_index_of_sep};
 
-    /// Minimal `FileSystem` singleton: holds `top_level_dir` only. The Zig original
-    /// (`src/resolver/fs.zig:14`) also owns the dir-entry cache and filename arenas;
-    /// those remain in `bun_resolver` and reach back here for the cwd string.
+    /// Minimal `FileSystem` singleton: holds `top_level_dir` only. The dir-entry
+    /// cache and filename arenas remain in `bun_resolver` and reach back here
+    /// for the cwd string.
     ///
-    /// Concurrency: Zig's `instance_loaded: bool` + `instance: FileSystem = undefined`
-    /// init-once pair → `OnceLock<FileSystem>` per PORTING.md §Concurrency.
+    /// Concurrency: init-once via `OnceLock<FileSystem>`.
     pub struct FileSystem {
-        // Zig: `top_level_dir: stringZ` — owned, NUL-terminated. Stored as raw
-        // bytes (not `String`): POSIX paths are arbitrary byte sequences, not
-        // guaranteed UTF-8, and every reader (`top_level_dir()`, resolve_path.rs)
-        // wants `&[u8]` to match Zig's `[]const u8`.
+        // Stored as raw bytes (not `String`): POSIX paths are arbitrary byte
+        // sequences, not guaranteed UTF-8, and every reader
+        // (`top_level_dir()`, resolve_path.rs) wants `&[u8]`.
         top_level_dir: Vec<u8>,
     }
 
     static INSTANCE: OnceLock<FileSystem> = OnceLock::new();
-    // Kept as a separate flag so `instance_loaded()` is a cheap relaxed load that
-    // mirrors the Zig `pub var instance_loaded: bool`.
+    // Kept as a separate flag so `instance_loaded()` is a cheap relaxed load.
     static INSTANCE_LOADED: AtomicBool = AtomicBool::new(false);
 
-    // Zig: `var tmpname_id_number = std.atomic.Value(u32).init(0);`
     static TMPNAME_ID_NUMBER: AtomicU32 = AtomicU32::new(0);
 
     impl FileSystem {
@@ -563,8 +544,7 @@ pub mod fs {
             INSTANCE_LOADED.load(Ordering::Relaxed)
         }
 
-        /// Panics if `init` has not been called. Mirrors Zig's `&instance` after
-        /// `instance_loaded` is asserted.
+        /// Panics if `init` has not been called.
         #[inline]
         pub fn instance() -> &'static FileSystem {
             INSTANCE
@@ -572,8 +552,7 @@ pub mod fs {
                 .expect("FileSystem.instance accessed before init")
         }
 
-        /// Zig: `FileSystem.init(top_level_dir)` (force=false path). Higher-tier
-        /// `bun_resolver::fs` calls this during its own `initWithForce` after it
+        /// Higher-tier `bun_resolver::fs` calls this during its own `initWithForce` after it
         /// resolves the cwd. Takes raw bytes — POSIX cwd is not guaranteed UTF-8.
         pub fn init(top_level_dir: &[u8]) -> &'static FileSystem {
             let _ = INSTANCE.set(FileSystem {
@@ -583,9 +562,8 @@ pub mod fs {
             INSTANCE.get().unwrap()
         }
 
-        /// Zig has a single mutable `Fs.FileSystem.instance.top_level_dir` that
-        /// `PackageManager.init` reassigns after walking up to the workspace
-        /// root. The port split that global across tiers; the canonical
+        /// `PackageManager.init` reassigns the top-level dir after walking up
+        /// to the workspace root. The canonical
         /// writable storage lives in `bun_core::TOP_LEVEL_DIR` (updated by
         /// `bun_resolver::FileSystem::set_top_level_dir`). Delegate the read
         /// there so `Path::init_top_level_dir` observes the post-chdir value
@@ -602,7 +580,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `topLevelDirWithoutTrailingSlash`.
+        /// The top-level dir with any single trailing separator stripped
+        /// (the root `/` is left intact).
         pub fn top_level_dir_without_trailing_slash(&self) -> &[u8] {
             let d = self.top_level_dir();
             if d.len() > 1 && d.last() == Some(&crate::SEP) {
@@ -612,24 +591,19 @@ pub mod fs {
             }
         }
 
-        /// Port of `FileSystem.tmpname` in `src/resolver/fs.zig`:
-        /// `pub fn tmpname(extname: string, buf: []u8, hash: u64) std.fmt.BufPrintError![:0]u8`
-        ///
         /// Writes `.<hex(hash|nanos)>-<HEX(counter)>.<extname>\0` into `buf` and returns
-        /// the NUL-terminated borrow. Static (no `&self`) — matches the Zig.
+        /// the NUL-terminated borrow. Static (no `&self`).
         pub fn tmpname<'b>(
             extname: &[u8],
             buf: &'b mut [u8],
             hash: u64,
         ) -> Result<&'b mut ZStr, bun_core::Error> {
-            // Zig: `@as(u64, @truncate(@as(u128, hash) | @as(u128, std.time.nanoTimestamp())))`
             let hex_value: u64 =
                 (u128::from(hash) | (bun_core::time::nano_timestamp() as u128)) as u64;
 
             let len = buf.len();
             let mut cursor = &mut buf[..];
-            // Zig: bun.fmt.hexIntLower / hexIntUpper — fixed-width, zero-padded
-            // to `@bitSizeOf(Int)/4` digits (u64 → 16, u32 → 8).
+            // Fixed-width, zero-padded hex (u64 → 16 digits, u32 → 8).
             write!(
                 &mut cursor,
                 ".{:016x}-{:08X}.{}",
@@ -647,7 +621,7 @@ pub mod fs {
         }
     }
 
-    /// Port of `PathName` in `src/resolver/fs.zig:1582` — parsed (dir, base, ext,
+    /// Parsed (dir, base, ext,
     /// filename) view over a borrowed path slice. All four fields point into the
     /// same backing allocation.
     ///
@@ -676,7 +650,8 @@ pub mod fs {
     }
 
     impl<'a> PathName<'a> {
-        /// Zig: `PathName.findExtname`.
+        /// Returns the extension of `path` including the leading `.`, or `""`
+        /// for extensionless / dotfile basenames.
         pub fn find_extname(path: &[u8]) -> &[u8] {
             let start = last_index_of_sep(path).map(|i| i + 1).unwrap_or(0);
             let base = &path[start..];
@@ -697,7 +672,6 @@ pub mod fs {
             }
         }
 
-        /// Zig: `PathName.nonUniqueNameStringBase`.
         /// `/bar/foo/index.js` → `foo`; `/bar/foo.js` → `foo`.
         pub fn non_unique_name_string_base(&self) -> &'a [u8] {
             // /bar/foo/index.js -> foo
@@ -710,19 +684,21 @@ pub mod fs {
             self.base
         }
 
-        /// Zig: `PathName.dirOrDot`.
+        /// The dir component, or `"."` when it is empty.
         #[inline]
         pub fn dir_or_dot(&self) -> &'a [u8] {
             if self.dir.is_empty() { b"." } else { self.dir }
         }
 
-        /// Zig: `PathName.fmtIdentifier`.
+        /// Formats [`Self::non_unique_name_string_base`] as a valid JS
+        /// identifier.
         #[inline]
         pub fn fmt_identifier(&self) -> bun_core::fmt::FormatValidIdentifier<'a> {
             bun_core::fmt::fmt_identifier(self.non_unique_name_string_base())
         }
 
-        /// Zig: `PathName.dirWithTrailingSlash`.
+        /// The dir component with its trailing separator restored
+        /// (`"./"` when the dir is empty).
         #[inline]
         pub fn dir_with_trailing_slash(&self) -> &'a [u8] {
             // The three strings basically always point to the same underlying ptr
@@ -741,7 +717,8 @@ pub mod fs {
             unsafe { core::slice::from_raw_parts(self.dir.as_ptr(), self.dir.len() + extend) }
         }
 
-        /// Zig: `PathName.init`.
+        /// Parses `path_` into its (dir, base, ext, filename) components; all
+        /// returned slices borrow `path_`.
         pub fn init(path_: &'a [u8]) -> PathName<'a> {
             #[cfg(all(windows, debug_assertions))]
             {
@@ -812,7 +789,7 @@ pub mod fs {
         }
     }
 
-    /// Port of `Path` in `src/resolver/fs.zig:1727` — the bundler/resolver's logical
+    /// The bundler/resolver's logical
     /// path (display `pretty`, canonical `text`, `namespace`, parsed `name`).
     ///
     /// NOTE: distinct from `crate::Path` (the buffer-backed AbsPath/RelPath). This is
@@ -875,7 +852,6 @@ pub mod fs {
             }
         }
 
-        // Zig: `pub const empty = Fs.Path.init("");`
         pub const EMPTY: Path<'static> = Path {
             pretty: b"",
             text: b"",
@@ -892,7 +868,7 @@ pub mod fs {
             PathName::init(self.text)
         }
 
-        /// Zig: `Path.init(text)` — sets `text`/`pretty` to the same slice,
+        /// Sets `text`/`pretty` to the same slice,
         /// namespace defaults to `"file"`.
         #[inline]
         pub const fn init(text: &'a [u8]) -> Self {
@@ -905,7 +881,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.initWithPretty`.
+        /// Like [`Self::init`] but with a caller-supplied display (`pretty`)
+        /// path.
         #[inline]
         pub const fn init_with_pretty(text: &'a [u8], pretty: &'a [u8]) -> Self {
             Self {
@@ -917,7 +894,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.initWithNamespace`.
+        /// Like [`Self::init`] but with a caller-supplied namespace instead
+        /// of `"file"`.
         #[inline]
         pub const fn init_with_namespace(text: &'a [u8], namespace: &'a [u8]) -> Self {
             Self {
@@ -929,8 +907,6 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.initWithNamespaceVirtual(comptime text, namespace, package)`.
-        /// PORT NOTE: Zig formed `pretty = namespace ++ ":" ++ package` at comptime;
         /// `const_format::concatcp!` can't accept fn-param `&str`, so callers pass
         /// the precomputed `concatcp!` result as `pretty`.
         #[inline]
@@ -948,8 +924,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.initForKitBuiltIn`.
-        /// PORT NOTE: same comptime-concat caveat as `init_with_namespace_virtual`.
+        /// Same const-concat caveat as `init_with_namespace_virtual`:
+        /// callers pass the precomputed `concatcp!` result as `pretty`.
         #[inline]
         pub const fn init_for_kit_built_in(
             namespace: &'static [u8],
@@ -965,7 +941,7 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.assertPrettyIsValid` — debug-only check that `pretty`
+        /// Debug-only check that `pretty`
         /// contains no backslashes (Windows). No-op on POSIX.
         #[inline]
         pub fn assert_pretty_is_valid(&self) {
@@ -978,7 +954,7 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.assertFilePathIsAbsolute` — CI-assert only.
+        /// CI-assert only.
         #[inline]
         pub fn assert_file_path_is_absolute(&self) {
             if bun_core::Environment::CI_ASSERT && self.is_file() {
@@ -1023,33 +999,34 @@ pub mod fs {
             self.namespace == b"macro"
         }
 
-        /// Zig: `pub inline fn sourceDir(this: *const Path) string`
+        /// Directory of `text`, with trailing separator.
         #[inline]
         pub fn source_dir(&self) -> &'a [u8] {
             self.name().dir_with_trailing_slash()
         }
 
-        /// Zig: `pub inline fn prettyDir(this: *const Path) string`
+        /// Directory used for display purposes, with trailing separator.
         #[inline]
         pub fn pretty_dir(&self) -> &'a [u8] {
             self.name().dir_with_trailing_slash()
         }
 
-        /// Zig: `Path.isNodeModule` — checks for `<sep>node_modules<sep>` in the
+        /// Checks for `<sep>node_modules<sep>` in the
         /// parsed dir component (`name.dir`, NOT `text`).
         pub fn is_node_module(&self) -> bool {
             use bstr::ByteSlice;
             self.name().dir.rfind(crate::NODE_MODULES_NEEDLE).is_some()
         }
 
-        /// Zig: `Path.isJSXFile`.
+        /// True if the filename ends in `.jsx` or `.tsx`.
         #[inline]
         pub fn is_jsx_file(&self) -> bool {
             let f = self.name().filename;
             f.ends_with(b".jsx") || f.ends_with(b".tsx")
         }
 
-        /// Zig: `Path.keyForIncrementalGraph`.
+        /// Key used to identify this path in the incremental graph: the real
+        /// `text` for `file:` paths, the `pretty` form otherwise.
         #[inline]
         pub fn key_for_incremental_graph(&self) -> &'a [u8] {
             if self.is_file() {
@@ -1059,7 +1036,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Path.setRealpath`.
+        /// Records the resolved symlink target: `text` becomes `to`, the old
+        /// path is kept as `pretty`, and `is_symlink` is set.
         pub fn set_realpath(&mut self, to: &'a [u8]) {
             let old_path = self.text;
             self.text = to;
@@ -1068,15 +1046,12 @@ pub mod fs {
         }
     }
 
-    /// Port of `PathContentsPair` in `src/resolver/fs.zig:1505`.
+    /// A resolved path together with the file contents loaded from it.
     #[derive(Debug, Clone, Default)]
     pub struct PathContentsPair<'a> {
         pub path: Path<'a>,
-        // Zig: `contents: string` (`[]const u8`).
         pub contents: &'a [u8],
     }
 }
 
 pub use self::fs::PathContentsPair;
-
-// ported from: src/paths/paths.zig
diff --git a/src/paths/path_buffer_pool.rs b/src/paths/path_buffer_pool.rs
index f8153bdb535..a44dbaf115f 100644
--- a/src/paths/path_buffer_pool.rs
+++ b/src/paths/path_buffer_pool.rs
@@ -4,11 +4,9 @@
 //! make the stack memory usage more predictable. We keep up to 4 path buffers
 //! alive per thread at a time.
 //!
-//! PORT NOTE: Zig used `bun.ObjectPool<T, null, true, 4>` (a thread-safe
-//! 4-slot freelist). Rewritten over `thread_local!` + `RefCell<Vec<Box<T>>>`
-//! per PORTING.md §Concurrency (init-once / per-thread → no lock needed).
-//! Same observable behavior: at most 4 buffers cached per thread; excess `put`s
-//! drop. RAII guard replaces the manual `get`/`put` pairing.
+//! Implemented over `thread_local!` + `RefCell<Vec<Box<T>>>` (per-thread, so no
+//! lock needed): at most 4 buffers cached per thread; excess `put`s drop. An
+//! RAII guard replaces manual `get`/`put` pairing.
 
 use core::cell::RefCell;
 use core::marker::PhantomData;
@@ -21,9 +19,8 @@ const POOL_CAP: usize = 4;
 /// Per-thread pool of reusable path buffers.
 pub struct PathBufferPoolT<T: 'static + Default>(PhantomData<T>);
 
-// One thread-local Vec per buffer type. Zig's threadsafe pool used a global
-// lock; per-thread is closer to "use a thread-local allocator so mimalloc
-// deletes it on thread deinit" (the original comment) and avoids any lock.
+// One thread-local Vec per buffer type: per-thread storage means mimalloc
+// frees the buffers on thread deinit and no lock is needed.
 thread_local! {
     #[allow(clippy::vec_box)]
     static U8_POOL: RefCell<Vec<Box<PathBuffer>>> = const { RefCell::new(Vec::new()) };
@@ -74,14 +71,13 @@ impl<T: PoolStorage> PathBufferPoolT<T> {
     /// Returns an RAII guard that derefs to `&mut T` and returns the buffer to
     /// the pool on `Drop`. Replaces manual `get`/`put` pairing.
     pub fn get() -> PoolGuard<T> {
-        // Zig leaves the buffer `undefined`; we zero-allocate on the (rare)
-        // cache-miss path instead — see `PoolStorage::new_boxed` for the
-        // soundness/perf justification.
+        // Zero-allocate on the (rare) cache-miss path — see
+        // `PoolStorage::new_boxed` for the soundness/perf justification.
         let buf = T::with_pool(|p| p.borrow_mut().pop()).unwrap_or_else(T::new_boxed);
         PoolGuard { buf: Some(buf) }
     }
 
-    /// Manual return path (kept for structure parity with Zig). Prefer dropping
+    /// Manual return path. Prefer dropping
     /// the `PoolGuard` instead.
     pub(crate) fn put(buf: Box<T>) {
         T::with_pool(|p| {
@@ -130,7 +126,7 @@ pub type w_path_buffer_pool = PathBufferPoolT<WPathBuffer>;
 
 /// `bun.path_buffer_pool.get()` — convenience wrapper returning the RAII guard.
 /// `Path<U>` callers store this in a `ManuallyDrop` and explicitly `put` on
-/// reset (matches Zig's manual get/put), so also expose `into_box`/free `put`.
+/// reset, so also expose `into_box`/free `put`.
 pub type Guard = PoolGuard<PathBuffer>;
 #[inline]
 pub fn get() -> PoolGuard<PathBuffer> {
@@ -157,5 +153,3 @@ pub type os_path_buffer_pool = w_path_buffer_pool;
 #[cfg(not(windows))]
 #[allow(non_camel_case_types)]
 pub type os_path_buffer_pool = path_buffer_pool;
-
-// ported from: src/paths/path_buffer_pool.zig
diff --git a/src/paths/path_char.rs b/src/paths/path_char.rs
index 9ea7b489b6e..7ea4f7a356e 100644
--- a/src/paths/path_char.rs
+++ b/src/paths/path_char.rs
@@ -1,8 +1,5 @@
 //! Canonical `PathChar` — the one trait abstracting over `u8`/`u16` path code
-//! units. Replaces the per-crate re-definitions that grew out of porting Zig's
-//! `comptime T: type` duck-typing (Zig had **no** trait; every site asserted
-//! `T ∈ {u8,u16}` via `validatePathT` and shared exactly one helper,
-//! `bun.strings.literal(T, str)` at `string/immutable/unicode.zig:1395`).
+//! units. Replaces per-crate re-definitions of the same abstraction.
 //!
 //! Tier-0: depends only on `bun_core`. Higher crates **extend** this trait
 //! (`bun_paths::PathUnit`, `bun_sys::make_path::MakePathUnit`,
@@ -20,7 +17,7 @@ use bun_core::strings;
 /// transcoding write (`write_u8_part`) that lets `u16` call sites memcpy a
 /// UTF-8 part without an `if T::IS_U16` branch.
 pub trait PathChar: strings::PathByte + Ord {
-    /// `true` iff `Self == u16` (WTF-16). Replaces Zig's `if (T == u16)`.
+    /// `true` iff `Self == u16` (WTF-16).
     const IS_U16: bool;
 
     // `from_u8` inherited from `PathByte`.
@@ -30,8 +27,7 @@ pub trait PathChar: strings::PathByte + Ord {
     fn as_u32(self) -> u32;
 
     /// `Some(b)` if this code unit is in the ASCII range (`<= 0x7F`), else
-    /// `None`. `u8` always returns `Some(self)` (matches Zig's `@intCast` site
-    /// which never observed non-ASCII u8 there).
+    /// `None`. `u8` always returns `Some(self)`.
     #[inline]
     fn to_ascii(self) -> Option<u8> {
         let w = self.as_u32();
@@ -45,8 +41,8 @@ pub trait PathChar: strings::PathByte + Ord {
         self == Self::from_u8(c)
     }
 
-    /// ASCII upper-case (passes through non-ASCII unchanged). Port of the
-    /// per-unit upper-casing in `resolve_path.zig` drive-letter handling.
+    /// ASCII upper-case (passes through non-ASCII unchanged). Used by
+    /// drive-letter handling in `resolve_path`.
     #[inline]
     fn to_ascii_upper(self) -> Self {
         match self.to_ascii() {
@@ -63,8 +59,7 @@ pub trait PathChar: strings::PathByte + Ord {
     /// `bun.strings.literal(T, "...")` — yields a `&'static [Self]` for an
     /// ASCII byte literal. `u8` returns the input slice; `u16` const-widens
     /// the **closed set** of literals actually passed by callers (see the
-    /// `match` in the `u16` impl). Zero allocation; matches Zig's comptime
-    /// `Holder.value` static-per-call-site emission.
+    /// `match` in the `u16` impl). Zero allocation.
     fn lit(s: &'static [u8]) -> &'static [Self];
 
     /// Write a UTF-8 path part into `dest` (transcoding to UTF-16 when
@@ -109,12 +104,11 @@ impl PathChar for u16 {
     }
     #[inline]
     fn lit(s: &'static [u8]) -> &'static [u16] {
-        // Zig's `bun.strings.literal(u16, str)` is `std.unicode.utf8ToUtf16LeStringLiteral`
-        // — a comptime constant. Rust cannot widen an arbitrary `&'static [u8]` at
+        // Rust cannot widen an arbitrary `&'static [u8]` at
         // const time, so dispatch on the closed set of ASCII literals actually
-        // passed through `T::lit` across the codebase. Each gets one static,
-        // exactly as Zig emits one `Holder.value` per call site. Zero runtime
-        // allocation; `Box::leak` is forbidden here (PORTING.md §Forbidden).
+        // passed through `T::lit` across the codebase. Each gets one static.
+        // Zero runtime allocation; `Box::leak` is forbidden here
+        // (PORTING.md §Forbidden).
         macro_rules! w {
             ($($b:literal),* $(,)?) => {{ static W: &[u16] = &[$($b as u16),*]; W }};
         }
diff --git a/src/paths/resolve_path.rs b/src/paths/resolve_path.rs
index 237c0a84da4..8f9ec1cb2d0 100644
--- a/src/paths/resolve_path.rs
+++ b/src/paths/resolve_path.rs
@@ -4,9 +4,9 @@ use crate::fs as Fs;
 use crate::{MAX_PATH_BYTES, PathBuffer, SEP, SEP_POSIX, SEP_WINDOWS};
 use bun_core::{WStr, ZStr, strings};
 
-// PORT NOTE: Zig `threadlocal var` buffers. Stored in `UnsafeCell` (not `RefCell`)
+// Thread-local scratch buffers. Stored in `UnsafeCell` (not `RefCell`)
 // because callers must receive a raw `&mut` slice that outlives the `.with` closure
-// to match Zig's "valid until next call on this thread" pointer semantics. RefCell's
+// — the contract is "valid until next call on this thread". RefCell's
 // runtime borrow tracking cannot express that contract and would force an
 // unsafe-lifetime-extend through `RefCell::as_ptr` (PORTING.md §Forbidden).
 // SAFETY invariant: each buffer has at most one live mutable borrow per thread;
@@ -22,8 +22,8 @@ thread_local! {
 ///
 /// The `'static` output lifetime is the honest contract: the buffer is
 /// thread-local storage that lives for the thread's lifetime, and the returned
-/// slice is "valid until the next call on this thread" (Zig threadlocal-var
-/// pointer semantics — see module PORT NOTE above). Callers uphold the
+/// slice is "valid until the next call on this thread" (see module comment
+/// above). Callers uphold the
 /// single-live-borrow-per-thread invariant.
 #[inline]
 fn tl_buf_mut<const N: usize>(b: &UnsafeCell<[u8; N]>) -> &'static mut [u8; N] {
@@ -48,14 +48,14 @@ pub fn z<'a>(input: &[u8], output: &'a mut PathBuffer) -> &'a ZStr {
 }
 
 type IsSeparatorFunc = fn(char: u8) -> bool;
-// TODO(port): IsSeparatorFuncT/LastSeparatorFunctionT take `comptime T: type` —
-// represented here as generic-over-PathChar fn pointers; Rust cannot express
-// "fn<T>(T) -> bool" as a value, so callers dispatch via Platform methods.
+// Rust cannot express "fn<T>(T) -> bool" as a value, so the generic-`T`
+// callers dispatch via Platform methods instead of fn pointers.
 type LastSeparatorFunction = fn(slice: &[u8]) -> Option<usize>;
 
 #[inline(always)]
 fn is_dotdot_with_type<T: PathChar>(slice: &[T]) -> bool {
-    // TODO(port): specialization for T==u8 used @bitCast; generic path checks bytewise
+    // PERF: the generic path checks elementwise (no specialized T==u8 wide
+    // compare) — profile if it shows up on a hot path.
     slice.len() >= 2 && slice[0] == T::from_u8(b'.') && slice[1] == T::from_u8(b'.')
 }
 
@@ -92,15 +92,14 @@ pub fn is_parent_or_equal(parent_: &[u8], child: &[u8]) -> ParentEqual {
 pub(crate) fn get_if_exists_longest_common_path_generic<'a, P: PlatformT>(
     input: &[&'a [u8]],
 ) -> Option<&'a [u8]> {
-    // TODO(port): return lifetime — borrows from `input` strings; caller must ensure outlives
     let is_path_separator = P::P.get_separator_func();
 
     let nql_at_index_fn: fn(usize, usize, &[&[u8]]) -> bool = match P::P {
         Platform::Windows => |n, i, inp| nql_at_index_case_insensitive_dyn(n, i, inp),
         _ => |n, i, inp| nql_at_index_dyn(n, i, inp),
     };
-    // PERF(port): Zig used `inline 2..8 => |N|` to unroll per-count; Rust uses
-    // a runtime `n` here. Profile if it shows up on a hot path.
+    // PERF: uses a runtime `n` (no per-count unrolling). Profile if it shows
+    // up on a hot path.
 
     let mut min_length: usize = usize::MAX;
     for str in input {
@@ -181,7 +180,7 @@ pub(crate) fn get_if_exists_longest_common_path_generic<'a, P: PlatformT>(
     Some(&input[0][0..last_common_separator.unwrap() + 1])
 }
 
-// Runtime helpers for the demoted comptime-count nql checks above.
+// Runtime helpers for the nql checks above.
 #[inline]
 fn nql_at_index_dyn(string_count: usize, index: usize, input: &[&[u8]]) -> bool {
     for s in 1..string_count {
@@ -211,7 +210,7 @@ pub(crate) fn longest_common_path_generic<'a, P: PlatformT>(input: &[&'a [u8]])
         Platform::Windows => nql_at_index_case_insensitive_dyn,
         _ => nql_at_index_dyn,
     };
-    // PERF(port): Zig used `inline 2..8 => |N|` to unroll per-count — profile if hot
+    // PERF: no per-count unrolling — profile if hot
 
     let mut min_length: usize = usize::MAX;
     for str in input {
@@ -326,7 +325,7 @@ pub fn get_if_exists_longest_common_path<'a>(input: &[&'a [u8]]) -> Option<&'a [
     get_if_exists_longest_common_path_generic::<platform::Loose>(input)
 }
 
-// PORT NOTE: bun.ThreadlocalBuffers(struct {...}) heap-allocates on first use and
+// bun.ThreadlocalBuffers(struct {...}) heap-allocates on first use and
 // stores only a pointer in TLS. Represented as three independent lazily-boxed
 // thread-locals so that `relative_platform_buf` can hold disjoint `&mut` to
 // from/to buffers while `relative_to_common_path_buf()` is borrowed elsewhere
@@ -369,8 +368,7 @@ fn lazy_path_buf(c: &LazyPathBuf) -> &'static mut PathBuffer {
 
 /// Raw pointer into the thread-local scratch buffer. Callers reborrow
 /// per-access — PORTING.md §Global mutable state. Valid until the next call on
-/// this thread; do not hold across re-entry (matches Zig threadlocal-var
-/// pointer semantics).
+/// this thread; do not hold across re-entry.
 #[inline]
 pub fn relative_to_common_path_buf() -> *mut PathBuffer {
     RELATIVE_TO_COMMON_PATH_BUF.with(lazy_path_buf)
@@ -494,8 +492,7 @@ pub(crate) fn relative_to_common_path<'a, const ALWAYS_COPY: bool, P: PlatformT>
     // Generate the relative path based on the path difference between `to`
     // and `from`.
 
-    // PORT NOTE: reshaped for borrowck — Zig used a growing slice `out_slice`
-    // pointing into `buf`; we track length and re-slice at end.
+    // Track length and re-slice into `buf` at the end (borrowck-friendly).
     let mut out_len: usize = 0;
 
     if !normalized_from.is_empty() {
@@ -572,9 +569,9 @@ pub fn relative_normalized_buf<'a, P: PlatformT, const ALWAYS_COPY: bool>(
     relative_to_common_path::<ALWAYS_COPY, P>(common_path, from, to, buf)
 }
 
-// PORT NOTE: result borrows either the thread-local common-path buf ('static)
+// result borrows either the thread-local common-path buf ('static)
 // or `to` (when !ALWAYS_COPY and result==to). Return lifetime is `'a` (=to's),
-// since 'static: 'a. Zig's "valid until next call" semantics still applies for
+// since 'static: 'a. "Valid until next call" still applies for
 // the buf-backed case.
 pub fn relative_normalized<'a, P: PlatformT, const ALWAYS_COPY: bool>(
     from: &'a [u8],
@@ -642,7 +639,7 @@ pub fn relative(from: &[u8], to: &[u8]) -> &'static [u8] {
 pub fn relative_buf_z<'a>(buf: &'a mut [u8], from: &[u8], to: &[u8]) -> &'a ZStr {
     let rel = relative_platform_buf::<platform::Auto, true>(buf, from, to);
     let len = rel.len();
-    // PORT NOTE: reshaped for borrowck — drop `rel` borrow before mutating buf
+    // reshaped for borrowck — drop `rel` borrow before mutating buf
     buf[len] = 0;
     // SAFETY: buf[len] == 0 written above
     ZStr::from_buf(&buf[..], len)
@@ -670,7 +667,7 @@ pub fn relative_platform_buf<'a, P: PlatformT, const ALWAYS_COPY: bool>(
                 platform_to_posix_in_place::<u8>(normalized);
                 break 'brk &*normalized;
             }
-            // PORT NOTE: reshaped for borrowck — capture len, drop inner &mut, re-slice
+            // reshaped for borrowck — capture len, drop inner &mut, re-slice
             let path_len =
                 normalize_string_buf::<true, P, true>(from, &mut relative_from_buf[1..]).len();
             if P::P == Platform::Windows {
@@ -680,8 +677,8 @@ pub fn relative_platform_buf<'a, P: PlatformT, const ALWAYS_COPY: bool>(
             break 'brk &relative_from_buf[0..path_len + 1];
         }
     } else {
-        // PORT NOTE: Zig aliased relative_from_buf as both input (normalize result)
-        // and output (join target). Reshape: normalize into relative_to_buf scratch,
+        // Avoid aliasing relative_from_buf as both input (normalize result)
+        // and output (join target): normalize into relative_to_buf scratch,
         // then join into relative_from_buf. Safe because normalized_to is computed
         // afterwards (overwrites relative_to_buf anyway).
         let norm_len = normalize_string_buf::<true, P, true>(from, &mut relative_to_buf[..]).len();
@@ -702,7 +699,7 @@ pub fn relative_platform_buf<'a, P: PlatformT, const ALWAYS_COPY: bool>(
                 platform_to_posix_in_place::<u8>(normalized);
                 break 'brk &*normalized;
             }
-            // PORT NOTE: reshaped for borrowck — capture len, drop inner &mut, re-slice
+            // reshaped for borrowck — capture len, drop inner &mut, re-slice
             let path_len =
                 normalize_string_buf::<true, P, true>(to, &mut relative_to_buf[1..]).len();
             if P::P == Platform::Windows {
@@ -712,8 +709,8 @@ pub fn relative_platform_buf<'a, P: PlatformT, const ALWAYS_COPY: bool>(
             break 'brk &relative_to_buf[0..path_len + 1];
         }
     } else {
-        // PORT NOTE: Zig aliased relative_to_buf as both input (normalize result)
-        // and output (join target). Reshape: normalize into `buf` scratch (caller
+        // Avoid aliasing relative_to_buf as both input (normalize result)
+        // and output (join target): normalize into `buf` scratch (caller
         // output buffer, untouched until the final relative_normalized_buf call
         // and disjoint from both threadlocals), then join into relative_to_buf.
         let norm_len = normalize_string_buf::<true, P, true>(to, buf).len();
@@ -769,8 +766,8 @@ pub(crate) fn windows_volume_name_len_t<T: PathChar>(path: &[T]) -> (usize, usiz
         && !Platform::Windows.is_separator_t::<T>(path[2])
         && path[2] != T::from_u8(b'.')
     {
-        // TODO(port): Zig branched on T==u8 to use SIMD index_of_any vs generic;
-        // collapse to a single generic helper here. PERF(port): profile if hot.
+        // PERF: the single generic helper checks elementwise (no T==u8 SIMD
+        // branch) — profile if hot.
         if let Some(idx) = strings::index_of_any_t::<T>(&path[3..], T::lit(b"/\\")) {
             // TODO: handle input "//abc//def" should be picked up as a unc path
             if path.len() > idx + 4 && !Platform::Windows.is_separator_t::<T>(path[idx + 4]) {
@@ -920,7 +917,7 @@ pub fn normalize_string_generic_t<
     )
 }
 
-/// Ported as a plain options struct; the `comptime options:` callsite becomes
+/// Plain options struct whose flags become
 /// individual const-generic bools below (separator and is_separator stay
 /// runtime since Rust const generics cannot carry fn pointers / non-integral T).
 pub struct NormalizeOptions<T: PathChar> {
@@ -951,8 +948,8 @@ impl<T: PathChar> Default for NormalizeOptions<T> {
     }
 }
 
-// TODO(port): return type was `if (options.zero_terminate) [:0]T else []T`.
-// Rust cannot vary the return type on a const-generic bool without specialization;
+// Rust cannot vary the return type on a const-generic bool without
+// specialization, so
 // we always return `&mut [T]` and write the NUL when `ZERO_TERMINATE`. Callers
 // that need `&ZStr`/`&WStr` re-wrap with `from_raw`.
 pub fn normalize_string_generic_tz<
@@ -969,8 +966,7 @@ pub fn normalize_string_generic_tz<
     is_separator: impl Fn(T) -> bool + Copy,
 ) -> &'a mut [T] {
     let is_windows = separator == T::from_u8(SEP_WINDOWS);
-    // sep_str: single-char slice [separator]
-    // PERF(port): Zig built `sep_str` at comptime; we build per-call.
+    // sep_str: single-char slice [separator], built per-call.
 
     if is_windows && cfg!(debug_assertions) {
         // this is here to catch a potential mistake by the caller
@@ -1164,7 +1160,7 @@ pub enum Platform {
     Nt,
 }
 
-// PORT NOTE: Zig used `comptime _platform: Platform` const-generics. Nightly
+// Nightly
 // `adt_const_params` is now enabled crate-wide (see lib.rs), so `Platform`
 // derives `ConstParamTy` and `<const PLATFORM: Platform>` is the preferred
 // form for new code. The `PlatformT` sealed-trait shim below is kept for
@@ -1215,8 +1211,8 @@ impl Platform {
         self.is_absolute_t::<u8>(path)
     }
 
-    // PORT NOTE: dropped `const` — PathChar trait methods aren't const-callable
-    // on stable. Zig's `comptime` here was for monomorphization, not const-eval.
+    // dropped `const` — PathChar trait methods aren't const-callable
+    // on stable.
     pub fn is_absolute_t<T: PathChar>(self, path: &[T]) -> bool {
         match self {
             Platform::Posix => !path.is_empty() && path[0] == T::from_u8(b'/'),
@@ -1331,8 +1327,8 @@ impl Platform {
 }
 
 pub fn normalize_string<const ALLOW_ABOVE_ROOT: bool, P: PlatformT>(str: &[u8]) -> &mut [u8] {
-    // PORT NOTE: returns slice into thread-local PARSER_BUFFER; valid until the
-    // next call on this thread (Zig threadlocal-var semantics).
+    // returns slice into thread-local PARSER_BUFFER; valid until the
+    // next call on this thread.
     PARSER_BUFFER.with(|b| normalize_string_buf::<ALLOW_ABOVE_ROOT, P, false>(str, tl_buf_mut(b)))
 }
 
@@ -1356,7 +1352,6 @@ pub fn normalize_buf_t<'a, T: PathChar, P: PlatformT>(str: &[T], buf: &'a mut [T
 
     let is_absolute = P::P.is_absolute_t::<T>(str);
 
-    // TODO(port): platform.getLastSeparatorFuncT()(T, str) — dispatched manually
     let trailing_separator = match P::P {
         Platform::Loose => last_index_of_separator_loose_t::<T>(str),
         Platform::Nt | Platform::Windows => last_index_of_separator_windows_t::<T>(str),
@@ -1420,7 +1415,7 @@ pub fn join_abs<'a, P: PlatformT>(cwd: &'a [u8], part: &[u8]) -> &'a [u8] {
 /// This is the equivalent of path.resolve
 ///
 /// Returned path is stored in a temporary buffer. It must be copied if it needs to be stored.
-// PORT NOTE: result borrows the thread-local buffer ('static) OR returns `cwd`
+// result borrows the thread-local buffer ('static) OR returns `cwd`
 // directly when `parts.is_empty()`. Return tied to `cwd`'s lifetime ('static: 'a).
 pub fn join_abs_string<'a, P: PlatformT>(cwd: &'a [u8], parts: &[&[u8]]) -> &'a [u8] {
     PARSER_JOIN_INPUT_BUFFER.with(|b| join_abs_string_buf::<P>(cwd, tl_buf_mut(b), parts))
@@ -1448,7 +1443,7 @@ pub fn join_z<P: PlatformT>(parts: &[&[u8]]) -> &'static ZStr {
 }
 
 pub fn join_z_buf<'a, P: PlatformT>(buf: &'a mut [u8], parts: &[&[u8]]) -> &'a ZStr {
-    // PORT NOTE: reshaped for borrowck — capture buf base ptr before sub-borrow
+    // reshaped for borrowck — capture buf base ptr before sub-borrow
     let buf_base = buf.as_mut_ptr();
     let buf_len = buf.len();
     let (start_offset, len) = {
@@ -1468,15 +1463,15 @@ pub fn join_string_buf<'a, P: PlatformT>(buf: &'a mut [u8], parts: &[&[u8]]) ->
     join_string_buf_t::<u8, P>(buf, parts)
 }
 
-/// `joinStringBufW` overload for u16 parts (no transcode). Covers the
-/// `T == u16 && Elem == u16` arm of Zig's `joinStringBufT` `anytype` dispatch.
+/// `joinStringBufW` overload for u16 parts (no transcode): the
+/// `T == u16 && Elem == u16` case.
 pub fn join_string_buf_w_same<'a, P: PlatformT>(buf: &'a mut [u16], parts: &[&[u16]]) -> &'a [u16] {
     join_string_buf_t_same::<u16, P>(buf, parts)
 }
 
 /// Same-width `joinStringBufT`: parts already match `T`, so no UTF-8→16 transcode.
-/// PORT NOTE: split out of `join_string_buf_t` because Rust can't monomorphize on
-/// `parts: anytype` element types like Zig — callers pick the overload.
+/// split out of `join_string_buf_t` because Rust can't monomorphize on the
+/// parts' element types — callers pick the overload.
 pub(crate) fn join_string_buf_t_same<'a, T: PathChar, P: PlatformT>(
     buf: &'a mut [T],
     parts: &[&[T]],
@@ -1485,7 +1480,6 @@ pub(crate) fn join_string_buf_t_same<'a, T: PathChar, P: PlatformT>(
     let mut temp_buf_: [T; 4096] = [T::from_u8(0); 4096];
     let mut temp_buf: &mut [T] = &mut temp_buf_;
     let mut heap_temp_buf: Vec<T>;
-    // PERF(port): was stack-fallback (manual free) — Vec drops on scope exit
 
     let mut count: usize = 0;
     for part in parts {
@@ -1525,7 +1519,7 @@ pub(crate) fn join_string_buf_t_same<'a, T: PathChar, P: PlatformT>(
 }
 
 pub fn join_string_buf_wz<'a, P: PlatformT>(buf: &'a mut [u16], parts: &[&[u8]]) -> &'a WStr {
-    // PORT NOTE: reshaped for borrowck — capture buf base ptr before sub-borrow
+    // reshaped for borrowck — capture buf base ptr before sub-borrow
     let buf_base = buf.as_mut_ptr();
     let buf_len = buf.len();
     let (start_offset, len) = {
@@ -1542,7 +1536,7 @@ pub fn join_string_buf_wz<'a, P: PlatformT>(buf: &'a mut [u16], parts: &[&[u8]])
 }
 
 pub fn join_string_buf_z<'a, P: PlatformT>(buf: &'a mut [u8], parts: &[&[u8]]) -> &'a ZStr {
-    // PORT NOTE: reshaped for borrowck — capture buf base ptr before sub-borrow
+    // reshaped for borrowck — capture buf base ptr before sub-borrow
     let buf_base = buf.as_mut_ptr();
     let buf_len = buf.len();
     let (start_offset, len) = {
@@ -1562,13 +1556,12 @@ pub(crate) fn join_string_buf_t<'a, T: PathChar, P: PlatformT>(
     buf: &'a mut [T],
     parts: &[&[u8]],
 ) -> &'a [T] {
-    // TODO(port): Zig used `parts: anytype` (tuple of slices, possibly mixed
-    // element types). Rust takes `&[&[u8]]`; transcoding to u16 handled below.
+    // Takes `&[&[u8]]` — every in-tree caller passes u8
+    // parts — and transcodes to u16 below when `T == u16`.
     let mut written: usize = 0;
     let mut temp_buf_: [T; 4096] = [T::from_u8(0); 4096];
     let mut temp_buf: &mut [T] = &mut temp_buf_;
     let mut heap_temp_buf: Vec<T>;
-    // PERF(port): was stack-fallback (manual free) — Vec drops on scope exit
 
     let mut count: usize = 0;
     for part in parts {
@@ -1595,8 +1588,7 @@ pub(crate) fn join_string_buf_t<'a, T: PathChar, P: PlatformT>(
             written += 1;
         }
 
-        // TODO(port): Zig inspected std.meta.Elem(@TypeOf(part)); we always
-        // receive u8 parts, so transcode iff T == u16.
+        // Parts are always u8 (see fn-level comment); transcode iff T == u16.
         written += T::write_u8_part(&mut temp_buf[written..], part);
     }
 
@@ -1609,8 +1601,8 @@ pub(crate) fn join_string_buf_t<'a, T: PathChar, P: PlatformT>(
 }
 
 /// Scratch buffer for `_join_abs_string_buf`'s unnormalized concatenation.
-/// Zig used `std.heap.stackFallback(MAX_PATH_BYTES * 2)`; we draw from the
-/// thread-local `path_buffer_pool` for the common case and only heap-allocate
+/// Draws from the
+/// thread-local `path_buffer_pool` for the common case and only heap-allocates
 /// when the concatenation would overflow a single `PathBuffer`. The pooled
 /// buffer is not re-zeroed — callers write every byte they later read.
 enum JoinScratch {
@@ -1673,7 +1665,6 @@ pub fn join_abs_string_buf_checked<'a, P: PlatformT>(
     // Slow path: allocate a large scratch for the result. The inner
     // join_abs_string_buf will heap-allocate its own temp buffer for the concat
     // since `total > MAX_PATH_BYTES * 2 > sfa inline size` is likely here.
-    // PERF(port): was stack-fallback alloc — profile if hot
     let mut scratch = vec![0u8; total];
     let joined = join_abs_string_buf::<P>(cwd, &mut scratch, parts);
     if joined.len() > buf.len() {
@@ -1694,9 +1685,8 @@ pub fn join_abs_string_buf_z<'a, P: PlatformT>(
     unsafe { ZStr::from_raw(r.as_ptr(), r.len()) }
 }
 
-// TODO(port): Zig used `comptime ReturnType: type` to vary `[:0]const u8` vs
-// `[]const u8`. We always return `&[u8]`; when `IS_SENTINEL` a NUL is written
-// at `result.len()` and callers re-wrap as `ZStr`.
+// We always return `&[u8]`; when `IS_SENTINEL` a NUL is written
+// at `result.len()` and callers (e.g. `join_abs_string_buf_z`) re-wrap as `ZStr`.
 fn _join_abs_string_buf<'a, const IS_SENTINEL: bool, P: PlatformT>(
     _cwd: &'a [u8],
     buf: &'a mut [u8],
@@ -1729,8 +1719,7 @@ fn _join_abs_string_buf<'a, const IS_SENTINEL: bool, P: PlatformT>(
         && parts[0].len() == 1
         && parts[0][0] == SEP_POSIX
     {
-        // PORT NOTE: Zig returned the literal `"/"` (`[:0]const u8` — NUL-backed).
-        // Rust `b"/"` is NOT NUL-terminated and not in `buf`, breaking callers
+        // A bare `b"/"` literal is NOT NUL-terminated and not in `buf`, breaking callers
         // that assume buf-backing (`ZStr::from_raw`, trailing-slash check).
         // Write into `buf` so the result is always buf-backed and sentinel-safe.
         buf[0] = b'/';
@@ -1785,7 +1774,7 @@ fn _join_abs_string_buf<'a, const IS_SENTINEL: bool, P: PlatformT>(
         out += part.len();
     }
 
-    // PORT NOTE: reshaped for borrowck — stash leading separator into a local
+    // reshaped for borrowck — stash leading separator into a local
     // [u8; 8] (max len: NT prefix `\\?\` = 4) so we don't hold a borrow into
     // temp_buf across the normalize call below.
     let mut leading_buf = [0u8; 8];
@@ -1801,8 +1790,8 @@ fn _join_abs_string_buf<'a, const IS_SENTINEL: bool, P: PlatformT>(
         leading_buf[0] = b'/';
         1
     };
-    // Copy leading separator into buf (Zig does this after normalize; order-
-    // independent since normalize writes into buf[leading_len..]).
+    // Copy leading separator into buf (order-independent with normalize,
+    // which writes into buf[leading_len..]).
     buf[..leading_len].copy_from_slice(&leading_buf[..leading_len]);
 
     let result = normalize_string_buf::<false, P, true>(
@@ -1949,7 +1938,6 @@ pub(crate) fn last_index_of_separator_windows(slice: &[u8]) -> Option<usize> {
 }
 
 pub(crate) fn last_index_of_separator_windows_t<T: PathChar>(slice: &[T]) -> Option<usize> {
-    // std.mem.lastIndexOfAny(T, slice, "\\/")
     slice.iter().rposition(|&c| is_sep_any_t::<T>(c))
 }
 
@@ -2017,7 +2005,7 @@ pub(crate) fn normalize_string_node_t<'a, T: PathChar, P: PlatformT>(
 
     // `normalize_string_generic` handles absolute path cases for windows
     // we should not prefix with /
-    // PORT NOTE: reshaped for borrowck — track an offset instead of reslicing.
+    // reshaped for borrowck — track an offset instead of reslicing.
     let buf_off: usize = if P::P == Platform::Windows { 0 } else { 1 };
 
     let separator_t = T::from_u8(P::P.separator());
@@ -2077,7 +2065,7 @@ pub(crate) fn normalize_string_node_t<'a, T: PathChar, P: PlatformT>(
     &mut buf[buf_off..buf_off + out_len]
 }
 
-/// Port of `resolve_path.zig:basename` — **NOT** `std.fs.path.basename` (see
+/// **NOT** plain basename (see
 /// [`crate::basename`] for that). Differs in two load-bearing ways: treats
 /// `\` as a separator on all platforms (`is_sep_any`), and returns `b"/"`
 /// (not `b""`) when the input is all separators. Shell builtins
@@ -2187,8 +2175,8 @@ impl PosixToWinNormalizer {
     ) -> Result<&'a mut ZStr, bun_core::Error> {
         Self::resolve_cwd_with_external_buf_z(&mut self._raw_bytes, maybe_posix_path)
     }
-    // TODO(windows): on posix `_raw_bytes` is `()`; the Zig version still
-    // null-terminates into a buffer. Callers on posix should use
+    // On posix `_raw_bytes` is `()` so `resolve_cwd_z` is windows-only.
+    // Callers on posix use
     // `resolve_cwd_with_external_buf_z` with an explicit PathBuffer.
 
     // underlying implementation:
@@ -2288,7 +2276,7 @@ impl PosixToWinNormalizer {
             if root.len() == 1 {
                 debug_assert!(is_sep_any(root[0]));
                 if strings::is_windows_absolute_path_missing_drive_letter::<u8>(maybe_posix_path) {
-                    // PORT NOTE: reshaped for borrowck — `getcwd` writes into
+                    // reshaped for borrowck — `getcwd` writes into
                     // `buf` and returns a borrow of it; capture the lengths we
                     // need, drop the borrow, then re-slice `buf`.
                     let sr_len = {
@@ -2336,7 +2324,7 @@ impl PosixToWinNormalizer {
             if root.len() == 1 {
                 debug_assert!(is_sep_any(root[0]));
                 if strings::is_windows_absolute_path_missing_drive_letter::<u8>(maybe_posix_path) {
-                    // PORT NOTE: reshaped for borrowck — see resolve_cwd above.
+                    // reshaped for borrowck — see resolve_cwd above.
                     let sr_len = {
                         let cwd = bun_core::getcwd(buf)?;
                         windows_filesystem_root(cwd.as_bytes()).len()
@@ -2378,21 +2366,19 @@ impl PosixToWinNormalizer {
     }
 }
 
-// ResolvePath__joinAbsStringBufCurrentPlatformBunString: see src/jsc/resolve_path_jsc.zig
+// ResolvePath__joinAbsStringBufCurrentPlatformBunString: see src/jsc/resolve_path_jsc.rs
 // (reaches into the VM for cwd; paths/ is JSC-free).
 
 // ─────────────────────────────────────────────────────────────────────────────
 // In-place separator rewrites.
 //
 // `slashes_to_{posix,windows}_in_place` are the two PRIMITIVES — unconditional,
-// no host-OS gating, no drive-letter touch. They are the Rust analogue of Zig's
-// `std.mem.replaceScalar(T, buf, '\\', '/')` (and inverse), which is what Zig
-// callers handroll at the sites this dedup targets.
+// no host-OS gating, no drive-letter touch.
 //
-// The four pre-existing public fns below are now thin wrappers over the
-// primitives so that Zig grep-parity (`platformToPosixInPlace`,
+// The four pre-existing public fns below (`platformToPosixInPlace`,
 // `dangerouslyConvertPathTo{Posix,Windows}InPlace`, `posixToPlatformInPlace`)
-// is preserved without a fourth/fifth copy of the loop body.
+// are thin wrappers over the primitives so there isn't a fourth/fifth copy of
+// the loop body.
 //
 // Encoding safety: both 0x2F ('/') and 0x5C ('\\') are single-unit ASCII in
 // UTF-8 and UTF-16 and never appear as a sub-unit of a multi-unit sequence, so
@@ -2495,5 +2481,3 @@ pub fn posix_to_platform_in_place<T: PathChar>(path_buffer: &mut [T]) {
 // `PathChar` is now canonical at `crate::path_char`; re-export for callers
 // that still path through `resolve_path::PathChar`.
 pub use crate::PathChar;
-
-// ported from: src/paths/resolve_path.zig
diff --git a/src/paths/string_paths.rs b/src/paths/string_paths.rs
index 0cde5490a94..a107119be2f 100644
--- a/src/paths/string_paths.rs
+++ b/src/paths/string_paths.rs
@@ -12,8 +12,8 @@ use crate::windows;
 use bun_core::string::immutable as strings;
 use bun_core::{WStr, ZStr};
 
-// Generic code-unit bound for fns that operate over both u8 and u16 paths.
-// Zig used `comptime T: type`; bound on `crate::PathChar` (provides
+// Generic code-unit bound for fns that operate over both u8 and u16 paths:
+// `crate::PathChar` (provides
 // `from_u8`/`IS_U16`) plus `Into<u32>` + `NoUninit` for `strings::contains_char_t`.
 pub trait Ch: PathChar + Into<u32> + bun_core::NoUninit {}
 impl Ch for u8 {}
@@ -24,8 +24,8 @@ impl Ch for u16 {}
 /// stack `WPathBuffer` filled to `len` with a NUL written at `wbuf[len]`.
 /// The slice borrow proves `wbuf[..=len]` lies in one allocation and ties the
 /// returned lifetime to it; the NUL is debug-asserted (release relies on the
-/// caller upholding the documented `wbuf[len] == 0` precondition — same
-/// contract as Zig `[:0]const u16` slicing). Mirrors [`ZStr::from_buf`].
+/// caller upholding the documented `wbuf[len] == 0` precondition).
+/// Mirrors [`ZStr::from_buf`].
 #[inline(always)]
 pub(crate) fn wstr_in_buf(wbuf: &[u16], len: usize) -> &WStr {
     WStr::from_buf(wbuf, len)
@@ -56,7 +56,7 @@ fn has_prefix_ascii_t<T: Ch>(s: &[T], prefix: &[u8]) -> bool {
 /// an absolute path contain a drive letter.
 ///
 /// Thin wrapper over the canonical [`crate::strings`] impl that additionally
-/// debug-asserts the Zig precondition `Platform.windows.isAbsoluteT(chars)`
+/// debug-asserts the precondition `Platform.windows.isAbsoluteT(chars)`
 /// (bun_core can't, as `bun_paths` would be a tier-0 cycle there).
 #[inline]
 pub fn is_windows_absolute_path_missing_drive_letter<T: Ch + From<u8>>(chars: &[T]) -> bool {
@@ -79,8 +79,8 @@ pub fn without_nt_prefix<T: Ch>(path: &[T]) -> &[T] {
     if !cfg!(windows) {
         return path;
     }
-    // PORT NOTE: Zig dispatched hasPrefixComptime vs hasPrefixComptimeUTF16 on T;
-    // collapsed to a local `has_prefix_ascii_t` (widens each ASCII byte via T::from_u8).
+    // A local `has_prefix_ascii_t` covers both widths (widens each ASCII byte
+    // via T::from_u8).
     if has_prefix_ascii_t(path, &windows::NT_OBJECT_PREFIX_U8) {
         return &path[windows::NT_OBJECT_PREFIX.len()..];
     }
@@ -234,8 +234,8 @@ pub(crate) fn to_w_path_normalized16<'a>(wbuf: &'a mut [u16], path: &[u16]) -> &
         return wstr_in_buf(wbuf, 0);
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig wrote into wbuf and then re-sliced wbuf;
-    // here we capture the length and re-derive the mutable slice.
+    // Capture the length and re-derive the mutable slice (borrowck-friendly
+    // alternative to writing into wbuf and re-slicing it).
     let len = {
         let mut path_to_use = normalize_slashes_only_t::<u16, b'\\', true>(wbuf, path);
 
@@ -262,7 +262,7 @@ pub(crate) fn normalize_slashes_only_t<
     buf: &'a mut [T],
     path: &'a [T],
 ) -> &'a [T] {
-    // PORT NOTE: was `const _: () = assert!(..)` but Rust forbids const items
+    // Was `const _: () = assert!(..)` but Rust forbids const items
     // referencing outer const-generic params (E0401). Debug-assert instead.
     debug_assert!(DESIRED_SLASH == b'/' || DESIRED_SLASH == b'\\');
     let undesired_slash: u8 = if DESIRED_SLASH == b'/' { b'\\' } else { b'/' };
@@ -284,9 +284,9 @@ pub(crate) fn normalize_slashes_only_t<
     path
 }
 
-// TODO(port): `desired_slash` was `comptime u8` in Zig; kept as runtime arg here since
+// `desired_slash` is a runtime arg (not a const generic) since a
 // const-generic value can't be forwarded from a runtime call site without duplication.
-// PERF(port): was comptime monomorphization.
+// PERF: profile if it shows up on a hot path.
 pub fn normalize_slashes_only<'a>(
     buf: &'a mut [u8],
     utf8: &'a [u8],
@@ -320,7 +320,7 @@ pub fn to_w_dir_path<'a>(wbuf: &'a mut [u16], utf8: &[u8]) -> &'a WStr {
 /// NT maximum path length), leaving room for the longest prefix any converter
 /// prepends (`\??\UNC\`, 8 units), a trailing slash, and the NUL? Paths that
 /// fail this cannot exist on disk; callers surface `false`/`ENAMETOOLONG`
-/// instead of converting (mirrors the Zig-side fix in oven-sh/bun#27775).
+/// instead of converting (see oven-sh/bun#27775).
 ///
 /// UTF-8 → UTF-16 never expands the unit count, so the byte count fitting
 /// already proves the fit; the unit count (simdutf, SIMD) is only computed
@@ -371,13 +371,12 @@ pub(crate) fn to_w_path_maybe_dir<'a, const ADD_TRAILING_LASH: bool>(
     debug_assert!(!wbuf.is_empty());
 
     let cap = wbuf.len().saturating_sub(1 + (ADD_TRAILING_LASH as usize));
-    // PORT NOTE: Zig used `bun.simdutf.convert.utf8.to.utf16.le.with_errors`;
-    // route through the checked `try_convert_utf8_to_utf16_in_buffer` (same
-    // simdutf primitive + WTF-8 fallback) to avoid a `bun_simdutf` crate dep.
+    // Route through the checked `try_convert_utf8_to_utf16_in_buffer`
+    // (simdutf + WTF-8 fallback) to avoid a `bun_simdutf` crate dep.
     //
-    // Over-long input is fail-safed to "" instead of overflowing: the Zig
-    // original handed simdutf a buffer it could write past, silently
-    // corrupting the stack once a path's UTF-16 form exceeded the wide
+    // Over-long input is fail-safed to "" instead of overflowing: handing
+    // simdutf a buffer it could write past would silently
+    // corrupt the stack once a path's UTF-16 form exceeded the wide
     // buffer (32767 units for `WPathBuffer`, i.e. longer than any path NT
     // can address). The empty result makes the consuming syscall fail
     // cleanly; JS-facing paths are rejected with `false`/ENAMETOOLONG before
@@ -421,7 +420,7 @@ pub fn clone_normalizing_separators(input: &[u8]) -> Vec<u8> {
     if base[0] == crate::SEP {
         buf[0] = crate::SEP;
     }
-    // PORT NOTE: reshaped for borrowck — track index instead of moving slice ptr.
+    // Reshaped for borrowck — track index instead of moving slice ptr.
     let mut i: usize = (base[0] == crate::SEP) as usize;
 
     for token in base.split(|b| *b == crate::SEP).filter(|s| !s.is_empty()) {
@@ -750,5 +749,3 @@ mod tests {
         assert!(fits_in_wide_path_buffer(&vec![0x80u8; 32757]));
     }
 }
-
-// ported from: src/string/immutable/paths.zig
diff --git a/src/perf/generated_perf_trace_events.rs b/src/perf/generated_perf_trace_events.rs
index e0fe0b99006..def31d5d25d 100644
--- a/src/perf/generated_perf_trace_events.rs
+++ b/src/perf/generated_perf_trace_events.rs
@@ -1,48 +1,54 @@
-// GENERATED: re-run scripts/generate-perf-trace-events.sh with .rs output
-// (source: src/perf/generated_perf_trace_events.zig — defines #[repr(i32)] enum PerfEvent)
-// TODO(port): teach the generator to emit Rust; do not hand-maintain this file.
-
-// TODO(port): stub until generator emits real variants — variants are added
-// piecemeal as call sites un-gate.
+// Hand-maintained: scripts/generate-perf-trace-events.sh does not emit Rust,
+// so this file mirrors the generated event list manually until the generator
+// learns to emit Rust. Variants are added piecemeal as call sites un-gate; the
+// discriminants are assigned EXPLICITLY to the canonical ids from
+// src/jsc/bindings/generated_perf_trace_events.h (the Darwin signpost path
+// passes `event as i32`, so the numeric id must match the generated header).
 #[repr(i32)]
 #[derive(Clone, Copy, Debug)]
 pub enum PerfEvent {
-    _Stub = 0,
-    FolderResolverReadPackageJSONFromDiskWorkspace,
-    FolderResolverReadPackageJSONFromDiskFolder,
-    ModuleResolverResolve,
+    /// Placeholder for call sites whose real event variant has not been
+    /// mirrored from the generated header yet. Not a header id.
+    _Stub = -1,
+    FolderResolverReadPackageJSONFromDiskFolder = 34,
+    FolderResolverReadPackageJSONFromDiskWorkspace = 35,
+    ModuleResolverResolve = 47,
+    StandaloneModuleGraphSerialize = 54,
+    SymbolsFollowAll = 55,
 }
 
 impl From<PerfEvent> for &'static str {
     fn from(e: PerfEvent) -> &'static str {
         match e {
             PerfEvent::_Stub => "_Stub",
-            PerfEvent::FolderResolverReadPackageJSONFromDiskWorkspace => {
-                "FolderResolver.readPackageJSONFromDisk.workspace"
-            }
             PerfEvent::FolderResolverReadPackageJSONFromDiskFolder => {
                 "FolderResolver.readPackageJSONFromDisk.folder"
             }
+            PerfEvent::FolderResolverReadPackageJSONFromDiskWorkspace => {
+                "FolderResolver.readPackageJSONFromDisk.workspace"
+            }
             PerfEvent::ModuleResolverResolve => "ModuleResolver.resolve",
+            PerfEvent::StandaloneModuleGraphSerialize => "StandaloneModuleGraph.serialize",
+            PerfEvent::SymbolsFollowAll => "Symbols.followAll",
         }
     }
 }
 
 impl PerfEvent {
-    /// NUL-terminated tag name, mirroring Zig's `@tagName(this.event).ptr` which yields
-    /// `[*:0]const u8`. Required for FFI to `Bun__linux_trace_emit` (expects C string).
+    /// NUL-terminated tag name. Required for FFI to `Bun__linux_trace_emit`
+    /// (expects C string).
     pub fn as_cstr(self) -> &'static core::ffi::CStr {
         match self {
             PerfEvent::_Stub => c"_Stub",
-            PerfEvent::FolderResolverReadPackageJSONFromDiskWorkspace => {
-                c"FolderResolver.readPackageJSONFromDisk.workspace"
-            }
             PerfEvent::FolderResolverReadPackageJSONFromDiskFolder => {
                 c"FolderResolver.readPackageJSONFromDisk.folder"
             }
+            PerfEvent::FolderResolverReadPackageJSONFromDiskWorkspace => {
+                c"FolderResolver.readPackageJSONFromDisk.workspace"
+            }
             PerfEvent::ModuleResolverResolve => c"ModuleResolver.resolve",
+            PerfEvent::StandaloneModuleGraphSerialize => c"StandaloneModuleGraph.serialize",
+            PerfEvent::SymbolsFollowAll => c"Symbols.followAll",
         }
     }
 }
-
-// ported from: src/perf/generated_perf_trace_events.zig
diff --git a/src/perf/hw_timer.rs b/src/perf/hw_timer.rs
index 6b9372946f3..3bec3eae94b 100644
--- a/src/perf/hw_timer.rs
+++ b/src/perf/hw_timer.rs
@@ -54,5 +54,3 @@ pub fn read_counter() -> u64 {
     #[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
     compile_error!("hw_timer::read_counter: unsupported architecture");
 }
-
-// ported from: src/perf/hw_timer.zig
diff --git a/src/perf/lib.rs b/src/perf/lib.rs
index b78e6053ddb..bd02a88a50c 100644
--- a/src/perf/lib.rs
+++ b/src/perf/lib.rs
@@ -43,8 +43,7 @@ impl Ctx {
     }
 }
 
-// Zig callsites pair `bun.perf.trace(...)` with `defer tracer.end()`. Per
-// PORTING.md `defer <side effect>` → RAII: `Ctx` ends itself on drop so callers
+// `Ctx` ends itself on drop so callers
 // write `let _tracer = bun_perf::trace(...)` and forget about it.
 impl Drop for Ctx {
     #[inline]
@@ -103,24 +102,17 @@ pub(crate) fn is_enabled() -> bool {
 ///
 /// When instruments is not connected, this is a no-op.
 ///
-/// When adding a new event, you must run `scripts/generate-perf-trace-events.sh` to update the list of trace events.
-///
-/// Tip: Make sure you write bun.perf.trace() with a string literal exactly instead of passing a variable.
-///
-/// It has to be compile-time known this way because they need to become string literals in C.
-// PORT NOTE: Zig took `comptime name: [:0]const u8` and used `@hasField(PerfEvent, name)` +
-// `@compileError` to validate membership at compile time, then `@field(PerfEvent, name)` to get
-// the enum value. In Rust, taking `PerfEvent` directly gives the same compile-time guarantee via
-// the type system — the @hasField/@compileError block is dropped.
+/// Pass a `PerfEvent` variant; the type system guarantees the event is a
+/// compile-time-known member of the generated set. Event names must become
+/// string literals in C, so when adding a new event you must run
+/// `scripts/generate-perf-trace-events.sh` to regenerate the list.
 pub fn trace(event: PerfEvent) -> Ctx {
     if !is_enabled() {
-        // PERF(port): @branchHint(.likely) — profile if it shows up on a hot path.
         return Ctx::Disabled(Disabled);
     }
 
     #[cfg(target_os = "macos")]
     {
-        // PERF(port): was comptime monomorphization (event id was comptime i32) — profile if it shows up on a hot path.
         return Ctx::Enabled(Darwin::init(event as i32));
     }
     #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -151,11 +143,10 @@ mod darwin_impl {
     }
 
     impl Darwin {
-        // PERF(port): was `comptime name: i32` — profile if it shows up on a hot path.
         pub fn init(name: i32) -> Self {
             Self {
                 // SAFETY: `is_enabled()` returned true, which implies `Darwin::get()` is Some
-                // (see `is_enabled_once`). Zig used `os_log.?` (unchecked unwrap).
+                // (see `is_enabled_once`).
                 interval: Self::get()
                     .expect("unreachable")
                     .signpost(name)
@@ -223,8 +214,7 @@ impl Linux {
             .ns()
             .saturating_sub(self.start_time);
 
-        // Zig's `@tagName(this.event).ptr` yields `[*:0]const u8` (NUL-terminated).
-        // `PerfEvent::as_cstr()` provides the equivalent `&'static CStr` so the C side's
+        // `PerfEvent::as_cstr()` provides a `&'static CStr` so the C side's
         // `snprintf("C|%d|%s|%lld", ...)` reads a properly terminated string.
         // SAFETY: FFI call; pointer is 'static and NUL-terminated.
         let _ = unsafe {
@@ -243,5 +233,3 @@ static INIT_ONCE: Once = Once::new();
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use bun_core::perf::sys::{Bun__linux_trace_emit, Bun__linux_trace_init};
-
-// ported from: src/perf/perf.zig
diff --git a/src/perf/system_timer.rs b/src/perf/system_timer.rs
index 8b0b157a02d..519f4841105 100644
--- a/src/perf/system_timer.rs
+++ b/src/perf/system_timer.rs
@@ -1,7 +1,5 @@
-// Zig's `fn NewTimer() type { ... }` is a comptime type-returning fn that
-// selects between a WASM stub and `std.time.Timer`. In Rust we collapse the
-// type-fn + `pub const Timer = NewTimer();` into cfg-gated definitions of
-// `Timer` directly.
+// Selects between a WASM stub and an `Instant`-backed timer via cfg-gated
+// definitions of `Timer`.
 
 #[cfg(target_family = "wasm")]
 pub struct Timer;
@@ -12,9 +10,8 @@ impl Timer {
         Ok(Self)
     }
 
-    // TODO(port): Zig used `@compileError` here, which fires lazily only if the
-    // fn is referenced. Rust's `compile_error!` fires unconditionally, so we
-    // keep the fn signatures for structural parity and trap at runtime instead.
+    // Tracing is never enabled in WASM; keep the fn signatures and trap at
+    // runtime instead of using `compile_error!` (which fires unconditionally).
     pub fn read(&self) -> u64 {
         unreachable!("FeatureFlags.tracing should be disabled in WASM");
     }
@@ -28,9 +25,8 @@ impl Timer {
     }
 }
 
-// Non-WASM: Zig used `std.time.Timer` directly. Rust has no identical type, so
-// wrap `std::time::Instant` with the same method surface (`start`/`read`/`lap`/
-// `reset`, ns as u64).
+// Non-WASM: wrap `std::time::Instant` behind a small monotonic-timer surface
+// (`start`/`read`/`lap`/`reset`, ns as u64).
 #[cfg(not(target_family = "wasm"))]
 pub struct Timer {
     started: std::time::Instant,
@@ -39,7 +35,8 @@ pub struct Timer {
 #[cfg(not(target_family = "wasm"))]
 impl Timer {
     pub fn start() -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+        // Infallible here, but kept fallible to match the `Result` signature
+        // callers already handle.
         Ok(Self {
             started: std::time::Instant::now(),
         })
@@ -60,5 +57,3 @@ impl Timer {
         self.started = std::time::Instant::now();
     }
 }
-
-// ported from: src/perf/system_timer.zig
diff --git a/src/perf/tracy.rs b/src/perf/tracy.rs
index 39eb1674eb3..6431baaf5cf 100644
--- a/src/perf/tracy.rs
+++ b/src/perf/tracy.rs
@@ -1,9 +1,6 @@
 //! https://github.com/wolfpld/tracy
 //! To use this module, you must have Tracy installed on your system.
 //! On macOS, you can install it with `brew install tracy`.
-//!
-//! This file is based on the code from Zig's transpiler source.
-//! Thank you to the Zig team
 
 use core::ffi::{c_char, c_int, c_void};
 use core::ptr;
@@ -14,9 +11,8 @@ use bun_core::env_var;
 pub const ENABLE_ALLOCATION: bool = false;
 pub const ENABLE_CALLSTACK: bool = false;
 
-// PORT NOTE: Zig `pub var enable = false;` — use AtomicBool so reads are safe
-// from any thread without `unsafe`. All loads/stores are Relaxed (matches Zig's
-// unsynchronized plain global).
+// An AtomicBool keeps reads safe from any thread without `unsafe`. All
+// loads/stores are Relaxed.
 static ENABLE: AtomicBool = AtomicBool::new(false);
 
 #[inline(always)]
@@ -80,16 +76,11 @@ impl ___tracy_c_zone_context {
 
 pub type Ctx = ___tracy_c_zone_context;
 
+/// Begin a Tracy zone. The
+/// per-callsite static source location is emitted by the `tracy_trace!`
+/// macro, which calls this with the already-built static.
 #[inline]
 pub fn trace(srcloc: &'static ___tracy_source_location_data) -> Ctx {
-    // TODO(port): Zig signature is `trace(comptime src: std.builtin.SourceLocation)`
-    // and synthesizes a per-monomorphization `static holder.srcloc`. Rust cannot
-    // create a fresh static per generic-value instantiation without a macro, so this
-    // fn takes the already-built static directly. TODO(port): provide a `tracy_trace!()`
-    // macro that emits a per-callsite
-    // `static SRCLOC: ___tracy_source_location_data { function: concat!(module_path!(),"\0"),
-    // file: concat!(file!(),"\0"), line: line!(), .. }` and calls this — do NOT
-    // reintroduce an intermediate SourceLocation struct.
     if !enable() {
         return Ctx::default();
     }
@@ -101,12 +92,12 @@ pub fn trace(srcloc: &'static ___tracy_source_location_data) -> Ctx {
     }
 }
 
+/// Begin a named Tracy zone. The
+/// per-callsite static (with `name` set) is emitted by the
+/// `tracy_trace_named!` macro, which calls this with the already-built
+/// static.
 #[inline]
 pub fn trace_named(srcloc: &'static ___tracy_source_location_data) -> Ctx {
-    // TODO(port): Zig `traceNamed(comptime src, comptime name)` — same
-    // per-callsite-static issue as `trace`. The `name` is folded into the
-    // caller-provided static `srcloc.name`. TODO(port): add a
-    // `tracy_trace_named!("name")` macro.
     if !enable() {
         return Ctx::default();
     }
@@ -118,20 +109,64 @@ pub fn trace_named(srcloc: &'static ___tracy_source_location_data) -> Ctx {
     }
 }
 
+/// Begin a Tracy zone with a per-callsite static source location.
+/// Expands to a fresh `static SRCLOC` per
+/// callsite (no intermediate `SourceLocation` struct) and calls
+/// `tracy::trace`.
+#[macro_export]
+macro_rules! tracy_trace {
+    () => {{
+        static SRCLOC: $crate::tracy::___tracy_source_location_data =
+            $crate::tracy::___tracy_source_location_data {
+                name: ::core::ptr::null(),
+                function: concat!(module_path!(), "\0")
+                    .as_ptr()
+                    .cast::<::core::ffi::c_char>(),
+                file: concat!(file!(), "\0")
+                    .as_ptr()
+                    .cast::<::core::ffi::c_char>(),
+                line: line!(),
+                color: 0,
+            };
+        $crate::tracy::trace(&SRCLOC)
+    }};
+}
+
+/// Begin a named Tracy zone with a per-callsite static source location.
+/// The name must be a
+/// string literal; it is NUL-terminated and stored in the per-callsite
+/// static, then passed to `tracy::trace_named`.
+#[macro_export]
+macro_rules! tracy_trace_named {
+    ($name:literal) => {{
+        static SRCLOC: $crate::tracy::___tracy_source_location_data =
+            $crate::tracy::___tracy_source_location_data {
+                name: concat!($name, "\0").as_ptr().cast::<::core::ffi::c_char>(),
+                function: concat!(module_path!(), "\0")
+                    .as_ptr()
+                    .cast::<::core::ffi::c_char>(),
+                file: concat!(file!(), "\0")
+                    .as_ptr()
+                    .cast::<::core::ffi::c_char>(),
+                line: line!(),
+                color: 0,
+            };
+        $crate::tracy::trace_named(&SRCLOC)
+    }};
+}
+
 pub fn tracy_allocator() -> TracyAllocator {
     TracyAllocator::init()
 }
 
-/// Zig: `fn TracyAllocator(comptime name: ?[:0]const u8) type { return struct { ... } }`
-///
-/// In Zig this is a `std.mem.Allocator` vtable wrapper around a parent allocator.
-/// Per PORTING.md §Allocators, `src/perf/` is not an AST crate, so the
-/// `std.mem.Allocator` parameter is deleted and the parent is implicitly the
+/// Per PORTING.md §Allocators, `src/perf/` is not an AST crate, so there is
+/// no allocator parameter; the parent is implicitly the
 /// global mimalloc (`#[global_allocator]`).
-// TODO(port): re-express as a `core::alloc::GlobalAlloc` shim over
-// `bun_alloc::Mimalloc` that emits tracy alloc/free hooks (alloc/alloc_named/
-// free/free_named below). Only relevant if `ENABLE_ALLOCATION` is flipped on —
-// it is `false` today, so this is dead in practice.
+// The tracy alloc/free hooks (`___tracy_emit_memory_alloc` etc.) are not
+// wired up: `ENABLE_ALLOCATION` is `false`,
+// so allocation tracking is intentionally dead.
+// If it is ever flipped on, express it as a `core::alloc::GlobalAlloc` shim
+// over the global mimalloc that emits the tracy hooks.
 pub struct TracyAllocator {}
 
 impl TracyAllocator {
@@ -140,7 +175,7 @@ impl TracyAllocator {
     }
 }
 
-/// This function only accepts comptime-known strings, see `message_copy` for runtime strings
+/// This function only accepts `'static` strings, see `message_copy` for runtime strings
 #[inline]
 pub fn message(msg: &'static core::ffi::CStr) {
     if !enable() {
@@ -152,7 +187,7 @@ pub fn message(msg: &'static core::ffi::CStr) {
     );
 }
 
-/// This function only accepts comptime-known strings, see `message_color_copy` for runtime strings
+/// This function only accepts `'static` strings, see `message_color_copy` for runtime strings
 #[inline]
 pub fn message_color(msg: &'static core::ffi::CStr, color: u32) {
     if !enable() {
@@ -212,9 +247,8 @@ pub fn named_frame(name: &'static core::ffi::CStr) -> Frame {
     Frame { name }
 }
 
-/// Zig: `fn Frame(comptime name: [:0]const u8) type`
-// PERF(port): was comptime monomorphization (zero-sized struct per name) —
-// store name as a field instead.
+/// Tracy frame span; `name` is stored as a field (one struct serves all
+/// names).
 pub struct Frame {
     name: &'static core::ffi::CStr,
 }
@@ -433,7 +467,6 @@ fn ___tracy_emit_frame_mark(name: *const c_char) {
 pub fn init() -> bool {
     #[cfg(target_family = "wasm")]
     {
-        // TODO(port): bun.Environment.isNative — assuming "native" == not-wasm
         return false;
     }
 
@@ -505,11 +538,9 @@ impl Default for ___tracy_source_location_data {
     }
 }
 
-// PORT NOTE: Zig defined `Handle` as a per-instantiation local struct inside
-// `dlsym`, giving each (Type, symbol) pair its own static handle. That is
-// wasteful (re-dlopens libtracy per symbol) and not expressible in Rust without
-// const-generic strings. Use a single shared handle instead — dlopen on the
-// same path is refcounted so behavior is equivalent.
+// A single shared handle serves all symbols (a per-(Type, symbol) handle
+// would wastefully re-dlopen libtracy per symbol; dlopen on the same path is
+// refcounted anyway).
 static HANDLE: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
 
 fn handle_getter() -> Option<*mut c_void> {
@@ -585,16 +616,15 @@ fn dlsym<T: Copy>(symbol: &'static core::ffi::CStr) -> Option<T> {
                 )))]
                 const PATHS_TO_TRY: &[&core::ffi::CStr] = &[];
 
-                // TODO(port): RTLD flags — Zig used `@bitCast(@as(i32, -2))` on
-                // macOS (RTLD_DEFAULT semantics for dlopen?) and default `.{}` on
-                // Linux. Map to bun_sys::dlopen flag type once defined.
+                // RTLD flags passed straight through to dlopen as raw values:
+                // -2 on macOS, 0 elsewhere.
                 #[cfg(target_os = "macos")]
                 let rtld: i32 = -2;
                 #[cfg(not(target_os = "macos"))]
                 let rtld: i32 = 0;
 
                 if let Some(path) = env_var::BUN_TRACY_PATH.get() {
-                    // std.posix.toPosixPath — copy into a NUL-terminated PathBuffer.
+                    // Copy into a NUL-terminated PathBuffer.
                     let mut buf = bun_paths::PathBuffer::uninit();
                     let zpath = bun_paths::resolve_path::z(path, &mut buf);
                     if let Some(handle) = bun_sys::dlopen(zpath, rtld) {
@@ -615,18 +645,28 @@ fn dlsym<T: Copy>(symbol: &'static core::ffi::CStr) -> Option<T> {
             }
         }
 
-        // PORT NOTE: Zig `bun.C.dlsymWithHandle` cached per-(Type,symbol) via a comptime
-        // local static. Rust has no const-generic-string statics; do an uncached lookup
-        // through the shared handle. PERF(port): per-symbol OnceLock cache — profile if it shows up on a hot path.
+        // Uncached lookup through the shared handle. PERF: a per-symbol
+        // OnceLock cache is possible — profile if it shows up on a hot path.
         let p = bun_sys::dlsym_impl(handle_getter(), sym_z)?;
-        // SAFETY: caller asserts `T` is fn-pointer-shaped matching the symbol's ABI
-        // (same contract as Zig `bun.cast(Type, ptr)`).
+        // SAFETY: caller asserts `T` is fn-pointer-shaped matching the symbol's ABI.
         Some(unsafe { core::mem::transmute_copy::<*mut c_void, T>(&p) })
     }
 }
 
-// TODO(port): Zig pulls this from `@import("build_options").tracy_callstack_depth`.
-// Wire to build-time config (env! / cfg-set const).
+// Only consulted when `ENABLE_CALLSTACK` is true.
 const CALLSTACK_DEPTH: c_int = 10;
 
-// ported from: src/perf/tracy.zig
+#[cfg(test)]
+mod tests {
+    // Expand both macros so the per-callsite statics (and their const
+    // initializers) are compile-checked even though no runtime caller exists
+    // yet. With `enable()` false (the default), `trace`/`trace_named` return
+    // `Ctx::default()` and `end()` is a no-op, so this is safe to run.
+    #[test]
+    fn trace_macros_expand() {
+        let ctx = crate::tracy_trace!();
+        ctx.end();
+        let named = crate::tracy_trace_named!("test");
+        named.end();
+    }
+}
diff --git a/src/picohttp/lib.rs b/src/picohttp/lib.rs
index 71d726aa50d..9469584bccd 100644
--- a/src/picohttp/lib.rs
+++ b/src/picohttp/lib.rs
@@ -7,10 +7,9 @@ use bstr::BStr;
 use bun_core::output::enable_ansi_colors_stderr;
 use bun_core::pretty_fmt;
 
-// PORT NOTE: `Header::clone` / `Request::clone` / `Response::clone` need the
+// `Header::clone` / `Request::clone` / `Response::clone` need the
 // unbound-lifetime `append_raw` so they can interleave appends and stash the
-// raw ptr/len pairs — the Zig original returns aliasing `[]const u8` with no
-// lifetime tracking. The buffer is heap-owned; callers keep the builder (or
+// raw ptr/len pairs. The buffer is heap-owned; callers keep the builder (or
 // its moved-out buffer) alive while the returned slices are in use.
 pub use bun_core::StringBuilder;
 
@@ -87,8 +86,7 @@ use bun_core::strings;
 // ──────────────────────────────────────────────────────────────────────────
 
 /// NOTE: layout MUST match `c::phr_header` exactly (see static asserts below).
-/// Zig used `name: []const u8` / `value: []const u8` and relied on Zig's slice
-/// ABI being `{ptr, len}`. Rust `&[u8]` has no guaranteed field order in
+/// Rust `&[u8]` has no guaranteed field order in
 /// `#[repr(C)]`, so we spell the fields out and expose `.name()` / `.value()`.
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -111,9 +109,8 @@ impl Header {
     /// initialize fixed-size header arrays before filling them.
     ///
     /// Uses `null()` (not `b"".as_ptr()`) so the const evaluates to all-zero
-    /// bytes — `[Header::ZERO; N]` statics land in `.bss` instead of `.data`,
-    /// matching Zig's `var buf: [N]Header = undefined`. `name()`/`value()` go
-    /// through `ffi::slice`, which tolerates `(null, 0)`.
+    /// bytes — `[Header::ZERO; N]` statics land in `.bss` instead of `.data`.
+    /// `name()`/`value()` go through `ffi::slice`, which tolerates `(null, 0)`.
     pub const ZERO: Self = Self {
         name_ptr: core::ptr::null(),
         name_len: 0,
@@ -123,7 +120,7 @@ impl Header {
 
     /// Construct a `Header` from borrowed name/value slices. The caller is
     /// responsible for keeping the backing storage alive for as long as the
-    /// `Header` is read (matches the Zig `[]const u8` field semantics).
+    /// `Header` is read.
     #[inline]
     pub const fn new(name: &[u8], value: &[u8]) -> Self {
         Self {
@@ -163,7 +160,7 @@ impl Header {
     pub fn clone(&self, builder: &mut StringBuilder) -> Header {
         // SAFETY: returned slices alias `builder`'s heap buffer; caller of the
         // outer `clone` keeps the builder (or its moved-out buffer) alive for
-        // the lifetime of the cloned `Header` (see PORT NOTE on `StringBuilder`).
+        // the lifetime of the cloned `Header` (see the comment on `StringBuilder`).
         let name = unsafe { builder.append_raw(self.name()) };
         // SAFETY: same buffer-lifetime invariant as `name` above.
         let value = unsafe { builder.append_raw(self.value()) };
@@ -182,7 +179,7 @@ impl Header {
 
 impl fmt::Display for Header {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // NOTE: pretty_fmt! is the comptime ANSI-tag expander (`<r><cyan>` → escape
+        // NOTE: pretty_fmt! is the compile-time ANSI-tag expander (`<r><cyan>` → escape
         // codes).
         if enable_ansi_colors_stderr() {
             if self.is_multiline() {
@@ -244,9 +241,6 @@ impl fmt::Display for HeaderCurlFormatter<'_> {
 #[derive(Clone, Copy, Default)]
 pub struct HeaderList<'a> {
     pub list: &'a [Header],
-    // TODO(port): Zig field is `[]Header` (mutable slice) but only ever read
-    // through `*const List`; using `&'a [Header]` here. Revisit if a caller
-    // mutates through it.
 }
 
 impl<'a> HeaderList<'a> {
@@ -378,7 +372,7 @@ impl<'a> Request<'a> {
         if rc > -1 {
             // SAFETY: path_ptr points into buf; the byte after the path is the
             // space before "HTTP/1.x" which picohttpparser has already consumed,
-            // so writing a NUL there is in-bounds. Zig casts away const here too.
+            // so writing a NUL there is in-bounds.
             unsafe { path_ptr.cast_mut().add(path_len).write(0) };
         }
 
@@ -481,9 +475,9 @@ impl fmt::Display for RequestCurlFormatter<'_> {
 
         if !self.body.is_empty() && Self::is_printable_body(content_type) {
             f.write_str(" --data-raw ")?;
-            // Zig: bun.js_printer.writeJSONString — bun_core re-exports the
-            // tier-0 minimal impl as `js_printer::write_json_string`; the full
-            // encoding-aware printer in bun_js_printer overrides at link time.
+            // bun_core re-exports the tier-0 minimal impl as
+            // `js_printer::write_json_string`; the full encoding-aware printer
+            // in bun_js_printer overrides at link time.
             bun_core::js_printer::write_json_string(
                 self.body,
                 f,
@@ -747,5 +741,3 @@ pub use c::phr_parse_request;
 pub use c::phr_parse_response;
 pub use c::struct_phr_chunked_decoder;
 pub use c::struct_phr_header;
-
-// ported from: src/picohttp/picohttp.zig
diff --git a/src/platform/darwin.rs b/src/platform/darwin.rs
index a66e49adc76..d8310fe4ddc 100644
--- a/src/platform/darwin.rs
+++ b/src/platform/darwin.rs
@@ -12,7 +12,6 @@ pub mod nocancel {
     use core::ffi::{c_char, c_int, c_uint, c_void};
     use libc::{iovec, off_t, pollfd, sigset_t, sockaddr, socklen_t, timespec};
 
-    // TODO(port): move to platform_sys
     unsafe extern "C" {
         #[link_name = "recvfrom$NOCANCEL"]
         pub fn recvfrom_nocancel(
@@ -235,5 +234,3 @@ impl<'a> Interval<'a> {
 }
 
 use core::ffi::CStr;
-
-// ported from: src/platform/darwin.zig
diff --git a/src/platform/lib.rs b/src/platform/lib.rs
index e56df6b2b54..50da2fb9aef 100644
--- a/src/platform/lib.rs
+++ b/src/platform/lib.rs
@@ -2,10 +2,8 @@
 #![warn(unused_must_use)]
 //! Per-OS APIs that don't fit in `bun_sys` (signposts, the `sys_epoll_pwait2` export).
 
-// Zig's `Environment.isLinux` is `os.tag == .linux`, which is true on Android
-// (Zig models Android as `os = linux, abi = android`); Rust splits them, so
-// list both so the `#[no_mangle]` C exports (`sys_epoll_pwait2`, …) reach the
-// linker on the `*-linux-android` targets.
+// Android is listed alongside Linux so the `#[no_mangle]` C exports
+// (`sys_epoll_pwait2`, …) reach the linker on the `*-linux-android` targets.
 #[cfg(target_os = "macos")]
 pub mod darwin;
 #[cfg(any(target_os = "linux", target_os = "android"))]
diff --git a/src/platform/linux.rs b/src/platform/linux.rs
index b95a2c88c7e..f9e519dec33 100644
--- a/src/platform/linux.rs
+++ b/src/platform/linux.rs
@@ -5,14 +5,13 @@
 
 use core::ffi::c_long;
 
-// Zig: `pub const MemFdAllocator = bun.allocators.LinuxMemFdAllocator;`
 // LAYERING: `LinuxMemFdAllocator` lives in `bun_runtime::allocators` (it pulls in
 // `bun_core`/`bun_sys`/`bun_ptr`); `bun_platform` is below `bun_runtime` so cannot
-// re-export it. The alias has no consumers — `Blob`/`Store` already path through
-// `crate::allocators::linux_mem_fd_allocator` directly.
+// re-export it. A re-export here would have no consumers — `Blob`/`Store` already
+// path through `crate::allocators::linux_mem_fd_allocator` directly.
 
-/// Re-encode a glibc `syscall(2)` wrapper return into the raw-kernel convention used by
-/// Zig's `std.os.linux.syscallN`: on error the kernel returns `-errno` in the result
+/// Re-encode a glibc `syscall(2)` wrapper return into the raw-kernel
+/// convention: on error the kernel returns `-errno` in the result
 /// register (i.e. a value in `-4095..=-1`), whereas glibc's wrapper translates that to
 /// `-1` and stashes the code in thread-local `errno`. The caller (the C
 /// `epoll_kqueue.c` loop) decodes errno *from the return value*, so we must put it
@@ -44,14 +43,13 @@ pub(crate) extern "C" fn sys_epoll_pwait2(
             timeout as usize,
             sigmask as usize,
             // This is the correct value. glibc claims to pass `sizeof sigset_t` for this argument,
-            // which would be 128, but they actually pass 8 which is what the kernel expects.
-            // https://github.com/ziglang/zig/issues/12715
+            // which would be 128, but they actually pass 8 which is what the kernel expects:
+            // the raw syscall validates sigsetsize against the kernel's sigset_t (sizeof(u64)),
+            // not glibc's 128-byte userspace sigset_t. See epoll_pwait2(2).
             8usize,
         )
     };
     // The C caller (epoll_kqueue.c) checks `ret == -EINTR` / `ret != -ENOSYS` against the
-    // raw kernel return; mirror `@bitCast(std.os.linux.syscall6(...))` semantics.
+    // raw kernel return, so encode errno back in-band.
     encode_raw_errno(rc)
 }
-
-// ported from: src/platform/linux.zig
diff --git a/src/ptr/CowSlice.rs b/src/ptr/CowSlice.rs
index 5330df6fc61..d713621e854 100644
--- a/src/ptr/CowSlice.rs
+++ b/src/ptr/CowSlice.rs
@@ -28,11 +28,11 @@ pub type CowSlice<T> = CowSliceZ<T, false>;
 /// "Copy on write" slice with optional sentinel termination. See module docs.
 ///
 /// `Z = true` means the backing storage has a sentinel element at `[len]`
-/// (the sentinel value is assumed to be the zero value of `T`).
-// TODO(port): Zig's `comptime sentinel: ?T` allowed an arbitrary sentinel value;
-// Rust const generics cannot express `Option<T>` for generic `T`, so this port
-// uses a `bool` and assumes sentinel == 0 when `Z`. Revisit if a non-zero
-// sentinel is ever needed.
+/// (the sentinel value is assumed to be the zero value of `T`, produced via
+/// `T::default()`).
+///
+/// For `Z = true`, owned allocations are physically `len + 1` elements
+/// (logical `len` plus the sentinel).
 pub struct CowSliceZ<T: 'static, const Z: bool> {
     /// Pointer to the underlying data. Do not access this directly.
     ///
@@ -106,19 +106,31 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
         self.debug.map(|d| unsafe { d.as_ref() })
     }
 
-    // TODO(port): Zig exposed `pub const Slice` / `SliceMut` associated type
-    // aliases that switched on `sentinel` (`[:z]const T` vs `[]const T`). Rust
-    // has no inherent associated type aliases; callers use `&[T]` / `&mut [T]`
-    // directly. For `Z = true` the NUL is at `slice()[len]` in backing storage.
+    // For `Z = true` the sentinel is at `slice()[len]` in the backing storage.
+
+    /// Number of elements physically backing an owned allocation of logical
+    /// length `len`: for `Z = true` the trailing sentinel adds one element.
+    #[inline]
+    const fn physical_len(len: usize) -> usize {
+        len + Z as usize
+    }
 
     /// Create a new Cow that owns its allocation.
     ///
     /// `data` is transferred into the returned string, and must be freed with
     /// `Drop` when the string and its borrows are done being used.
+    ///
+    /// For `Z = true`, `data` must include the trailing sentinel as its final
+    /// element; the logical length is `data.len() - 1`.
     pub fn init_owned(data: Box<[T]>) -> Self {
-        // PORT NOTE: Zig asserted ownership at runtime via a debug allocator
-        // wrapper. In Rust the `Box<[T]>` type already proves unique ownership.
-        let len = data.len();
+        // The `Box<[T]>` type already proves unique ownership. The
+        // `checked_sub` enforces the sentinel contract even in release builds:
+        // an empty box for `Z = true` would otherwise underflow to a near-max
+        // length and make `slice()` instant UB.
+        let len = data
+            .len()
+            .checked_sub(Z as usize)
+            .expect("CowSliceZ<_, true>::init_owned requires a trailing sentinel element");
         let ptr = bun_core::heap::into_raw(data).cast::<T>();
         Self {
             ptr,
@@ -129,18 +141,29 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
     }
 
     /// Create a new Cow that copies `data` into a new allocation.
+    ///
+    /// For `Z = true`, the new allocation holds `data.len() + 1` elements
+    /// with a trailing zero (`T::default()`) sentinel.
     pub fn init_dupe(data: &[T]) -> Result<Self, AllocError>
     where
         T: Clone + Default,
     {
-        // TODO(port): `allocator.dupeZ(T, data)` for `Z = true` — must allocate
-        // len+1 with a trailing zero sentinel. `Vec::into_boxed_slice` shrinks
-        // capacity to len, so the sentinel cannot live in spare capacity; the
-        // Box must hold len+1 and `Flags::len`/`Drop`/`take_slice` must be
-        // Z-aware (free len+1, expose len). Stubbed to plain dupe for now —
-        // sentinel is NOT preserved.
-        let bytes: Box<[T]> = Box::<[T]>::from(data);
-        Ok(Self::init_owned(bytes))
+        Ok(Self::init_owned(Self::dupe_maybe_z(data)))
+    }
+
+    /// Copy `data` into a fresh boxed slice, appending the zero sentinel when
+    /// `Z = true`. `Vec::into_boxed_slice` shrinks capacity to length, so the
+    /// sentinel is part of the box (physical `len + 1`), never spare capacity.
+    fn dupe_maybe_z(data: &[T]) -> Box<[T]>
+    where
+        T: Clone + Default,
+    {
+        let mut vec = Vec::with_capacity(Self::physical_len(data.len()));
+        vec.extend_from_slice(data);
+        if Z {
+            vec.push(T::default());
+        }
+        vec.into_boxed_slice()
     }
 
     /// Create a Cow that wraps a static slice.
@@ -205,6 +228,9 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
     /// Caller owns the returned memory and must deinitialize it when done.
     /// `self` may be re-used. An allocation will be incurred if and only if
     /// `self` is not owned.
+    ///
+    /// For `Z = true` the returned box includes the trailing sentinel element
+    /// (its length is the logical length plus one).
     pub fn take_slice(&mut self) -> Result<Box<[T]>, AllocError>
     where
         T: Clone + Default,
@@ -221,13 +247,18 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
                 drop(unsafe { bun_core::heap::take(d.as_ptr()) });
             }
         }
-        // Zig: `defer str.* = Self.empty` — a *bitwise* overwrite. In Rust,
         // `*self = Self::EMPTY` would run `Drop` on the old value first and
         // free the very `ptr[..len]` allocation we are about to hand back.
         // `ManuallyDrop::new(mem::replace(..))` resets `self` without dropping.
         let _ = core::mem::ManuallyDrop::new(core::mem::replace(self, Self::EMPTY));
-        // SAFETY: owned ⇒ `ptr[..len]` was produced by `heap::alloc`.
-        Ok(unsafe { bun_core::heap::take(core::ptr::slice_from_raw_parts_mut(ptr, len)) })
+        // SAFETY: owned ⇒ `ptr[..physical_len(len)]` was produced by `heap::alloc`
+        // (owned Z-cows always physically hold `len + 1` elements).
+        Ok(unsafe {
+            bun_core::heap::take(core::ptr::slice_from_raw_parts_mut(
+                ptr,
+                Self::physical_len(len),
+            ))
+        })
     }
 
     /// Returns a new string that borrows this string's data.
@@ -258,8 +289,9 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
     /// assertions get performed.
     pub fn borrow_subslice(&self, start: usize, end: Option<usize>) -> Self {
         let end_ = end.unwrap_or(self.flags.len());
-        // TODO(port): Zig's sentinel-aware `str.ptr[start..end_ :s]` asserted
-        // the sentinel is present at `end_`. No equivalent check here.
+        // Asserting the sentinel is present at `end_` would force a
+        // `PartialEq + Default` bound on every caller, so the `Z = true` path
+        // skips that debug assertion.
         let mut result = self.borrow();
         // SAFETY: const semantics are enforced by is_owned flag; `start <= end_ <= len`.
         result.ptr = unsafe { self.ptr.add(start) };
@@ -288,9 +320,9 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
     {
         debug_assert!(!self.is_owned());
 
-        // TODO(port): `allocator.dupeZ` for `Z = true` — see `init_dupe`.
-        // Sentinel is NOT preserved in this stub.
-        let bytes: Box<[T]> = Box::<[T]>::from(self.slice());
+        // For `Z = true` the duplicate gets a fresh trailing zero sentinel
+        // (see `dupe_maybe_z`).
+        let bytes: Box<[T]> = Self::dupe_maybe_z(self.slice());
         self.ptr = bun_core::heap::into_raw(bytes).cast::<T>();
         // flags.len already correct (unchanged)
         self.flags.set_is_owned(true);
@@ -311,6 +343,10 @@ impl<T: 'static, const Z: bool> CowSliceZ<T, Z> {
     }
 
     /// Does not include debug safety checks.
+    ///
+    /// `data` is the logical slice. For `Z = true` with `is_owned = true`, the
+    /// backing allocation must physically hold `data.len() + 1` elements (the
+    /// sentinel beyond the slice), as `Drop` frees the physical length.
     pub fn init_unchecked(data: &[T], is_owned: bool) -> Self {
         Self {
             // SAFETY: const semantics are enforced by is_owned flag
@@ -330,8 +366,6 @@ impl<T: 'static, const Z: bool> Drop for CowSliceZ<T, Z> {
     fn drop(&mut self) {
         #[cfg(debug_assertions)]
         if let Some(dbg) = self.debug_data() {
-            // PORT NOTE: Zig asserted `debug.allocator.vtable == allocator.vtable`
-            // here. With a single global allocator that check is moot.
             if self.is_owned() {
                 let borrows = dbg.mutex.lock();
                 // active borrows become invalid data
@@ -349,11 +383,12 @@ impl<T: 'static, const Z: bool> Drop for CowSliceZ<T, Z> {
             }
         }
         if self.flags.is_owned() {
-            // SAFETY: owned ⇒ `ptr[..len]` came from `heap::alloc`.
+            // SAFETY: owned ⇒ `ptr[..physical_len(len)]` came from `heap::alloc`
+            // (owned Z-cows always physically hold `len + 1` elements).
             drop(unsafe {
                 bun_core::heap::take(core::ptr::slice_from_raw_parts_mut(
                     self.ptr,
-                    self.flags.len(),
+                    Self::physical_len(self.flags.len()),
                 ))
             });
         }
@@ -362,7 +397,6 @@ impl<T: 'static, const Z: bool> Drop for CowSliceZ<T, Z> {
 
 impl<const Z: bool> core::fmt::Display for CowSliceZ<u8, Z> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // PORT NOTE: Zig `writer.writeAll(str.slice())` wrote raw bytes.
         // `BStr` gives lossy Display over `[u8]` without UTF-8 validation.
         core::fmt::Display::fmt(bstr::BStr::new(self.slice()), f)
     }
@@ -371,9 +405,8 @@ impl<const Z: bool> core::fmt::Display for CowSliceZ<u8, Z> {
 #[cfg(debug_assertions)]
 struct DebugData {
     /// Guards `borrows` (number of active borrows).
-    // PORT NOTE: Zig used `bun.Mutex` with `borrows` as a separate field;
-    // folded into the mutex payload here. `bun_core::Mutex` (poison-free
-    // `std::sync` wrapper) is used because `bun_ptr` sits below `bun_threading`.
+    // `bun_core::Mutex` (poison-free `std::sync` wrapper) is used because
+    // `bun_ptr` sits below `bun_threading`.
     mutex: bun_core::Mutex<usize>,
 }
 
@@ -386,7 +419,7 @@ impl DebugData {
     }
 }
 
-// `comptime` size assertion: CowSlice should be the same size as a native slice
+// Compile-time size assertion: CowSlice should be the same size as a native slice
 // (modulo the debug pointer).
 #[cfg(not(debug_assertions))]
 const _: () = assert!(
@@ -423,6 +456,45 @@ mod tests {
         // borrow is unaffected by str being dropped
         assert_eq!(borrow.slice(), b"hello");
     }
-}
 
-// ported from: src/ptr/CowSlice.zig
+    /// Exercises every `Z = true` path so the sentinel-aware alloc/free
+    /// symmetry (physical `len + 1` everywhere) is monomorphized, compiled,
+    /// and run — there are no other in-tree instantiations of `Z = true`.
+    #[test]
+    fn cow_slice_z_sentinel() {
+        // init_dupe: physical len + 1 with trailing 0 sentinel.
+        let mut str = CowSliceZ::<u8, true>::init_dupe(b"hello").unwrap();
+        assert!(str.is_owned());
+        assert_eq!(str.length(), 5);
+        assert_eq!(str.slice(), b"hello");
+        // SAFETY: owned Z-cows physically hold `len + 1` elements; index
+        // `len` is the sentinel.
+        assert_eq!(unsafe { *str.slice().as_ptr().add(str.length()) }, 0);
+
+        // borrow → to_owned re-dupes through the sentinel-aware path.
+        let mut borrow = str.borrow();
+        assert!(!borrow.is_owned());
+        assert_eq!(borrow.slice(), b"hello");
+        borrow.to_owned().unwrap();
+        assert!(borrow.is_owned());
+        assert_eq!(borrow.slice(), b"hello");
+        // SAFETY: owned Z-cow ⇒ sentinel at index `len`.
+        assert_eq!(unsafe { *borrow.slice().as_ptr().add(borrow.length()) }, 0);
+        drop(borrow);
+
+        // take_slice hands back the physical allocation: logical len + sentinel.
+        let boxed = str.take_slice().unwrap();
+        assert_eq!(boxed.len(), 6);
+        assert_eq!(&boxed[..5], b"hello");
+        assert_eq!(boxed[5], 0);
+        // `str` was reset to empty and is safe to reuse/drop.
+        assert_eq!(str.slice(), b"");
+
+        // init_owned round-trips the sentinel-carrying box; Drop frees len + 1
+        // (an alloc/free length mismatch here would abort under ASAN/debug heap).
+        let owned = CowSliceZ::<u8, true>::init_owned(boxed);
+        assert_eq!(owned.length(), 5);
+        assert_eq!(owned.slice(), b"hello");
+        drop(owned);
+    }
+}
diff --git a/src/ptr/lib.rs b/src/ptr/lib.rs
index db1588fff1a..c9037a64c48 100644
--- a/src/ptr/lib.rs
+++ b/src/ptr/lib.rs
@@ -24,7 +24,7 @@ pub type CowString<'a> = Cow<'a, [u8]>;
 
 // `bun.ptr.CowSlice(T)` / `CowSliceZ` — the lifetime-free struct port (owns or
 // borrows a raw slice with `init_owned`/`borrow_subslice`/`length`). Distinct
-// from the `std::borrow::Cow` aliases above; callers that need the Zig-shaped
+// from the `std::borrow::Cow` aliases above; callers that need the struct-shaped
 // API (e.g. `pack_command::Pattern`) reach for `cow_slice::CowSlice<u8>`.
 #[path = "CowSlice.rs"]
 pub mod cow_slice;
@@ -85,16 +85,11 @@ pub use bun_core::{
 // runtime crates spell `bun_ptr::callback_ctx::<T>(ctx)`.
 pub use bun_core::callback_ctx;
 
-pub mod meta; // small, used by other crates
-
-// ported from: src/ptr/ptr.zig
-
 // ─────────────────────────────────────────────────────────────────────────────
 // BackRef<T> / RawSlice<T> — runtime back-reference / borrowed-slice wrappers.
 //
-// Runtime structs frequently hold a non-owning pointer back to their owner
-// (Zig: `*Parent`, `*const VirtualMachine`, `[]const u8`). The original port
-// modeled these as raw `*mut T` / `*const [T]` and open-coded
+// Runtime structs frequently hold a non-owning pointer back to their owner.
+// These fields were once raw `*mut T` / `*const [T]` with open-coded
 // `unsafe { &*self.field }` at every read site. These two wrappers centralise
 // that pattern under the
 // `StoreRef`/`StoreSlice` contract from the parser, but for the *runtime*
@@ -109,7 +104,7 @@ pub mod meta; // small, used by other crates
 
 /// Non-owning, non-null back-reference to an object that outlives `self`.
 ///
-/// Mirrors Zig `*T` struct fields where the pointee is the owner/parent and is
+/// For struct fields where the pointee is the owner/parent and is
 /// guaranteed live for the holder's entire lifetime (owner-creates-child).
 /// `Copy` + `Deref` so call sites read `self.owner.method()` instead of
 /// `unsafe { &*self.owner }.method()`.
@@ -221,9 +216,8 @@ impl<T: ?Sized> Eq for BackRef<T> {}
 /// Detach a slice borrow from its borrowck lifetime.
 ///
 /// This is the **local-variable** counterpart to [`RawSlice`]. Use it when you
-/// need to read through a slice while a sibling field is reborrowed `&mut`
-/// (the classic Zig `var buf = lockfile.buffers.string_bytes; … &mut lockfile`
-/// pattern), and the backing storage is known not to move/realloc for the
+/// need to read through a slice while a sibling field is reborrowed `&mut`,
+/// and the backing storage is known not to move/realloc for the
 /// scope of the returned reference. Unlike `RawSlice`, this is *not* meant for
 /// struct fields — it exists so the borrowck-dodge stays a one-liner with the
 /// `unsafe` centralised here, rather than laundering the slice through a
@@ -244,8 +238,8 @@ pub unsafe fn detach_lifetime<'a, T>(s: &[T]) -> &'a [T] {
 /// [`detach_lifetime`]).
 ///
 /// Replaces the open-coded `unsafe { &*std::ptr::from_ref::<T>(x) }` /
-/// `unsafe { &*(&raw const x) }` lifetime-laundering idiom that the original
-/// port scattered everywhere a Zig `*const T` was held across a sibling
+/// `unsafe { &*(&raw const x) }` lifetime-laundering idiom that was once
+/// scattered everywhere a raw `*const T` was held across a sibling
 /// `&mut self` reborrow (arena handles, SoA columns, self-referential views).
 /// Centralising it here makes the call sites grep-able and the safety
 /// obligation uniform.
@@ -279,10 +273,8 @@ pub unsafe fn detach_lifetime_mut<'a, T: ?Sized>(r: &mut T) -> &'a mut T {
 /// `core::hint::black_box` (PORT_NOTES_PLAN **R-2**) before dispatching a
 /// re-entrant parent/user callback, then reborrow via [`LaunderedSelf::r`].
 ///
-/// Zig has no `noalias` on `*Self`, so the original `.zig` just writes
-/// `this.*` directly; this trait is the Rust-port-only artifact that makes the
-/// equivalent reborrow sound without scattering `unsafe { &mut *this }` at
-/// every field access.
+/// This trait makes the reborrow sound without scattering
+/// `unsafe { &mut *this }` at every field access.
 ///
 /// # Safety (impl contract)
 /// For every method on `Self` that calls [`r`](Self::r):
diff --git a/src/ptr/meta.rs b/src/ptr/meta.rs
deleted file mode 100644
index 7a11a00f27d..00000000000
--- a/src/ptr/meta.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! Private utilities used in smart pointer implementations.
-//!
-//! TODO(port): This module is Zig comptime type-reflection machinery that lets
-//! `Owned(P)` / `Shared(P)` accept `*T`, `[]T`, `?*T`, `?[]T` as a single
-//! generic `P` and then introspect optionality / constness / element type via
-//! `@typeInfo`. Per PORTING.md §Pointers, `bun.ptr.Owned/Shared/AtomicShared`
-//! map directly to `Box<T>` / `Rc<T>` / `Arc<T>` (and `Box<[T]>`,
-//! `Option<Box<T>>` etc. are spelled at the use site), so the reflection layer
-//! has no Rust counterpart. The skeleton below preserves shape for diffing;
-//! TODO(refactor): delete this module once the `bun_ptr` callers are migrated
-//! to std smart pointers.
-
-use core::marker::PhantomData;
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub enum Kind {
-    Single,
-    Slice,
-}
-
-/// A possibly optional slice or single-item pointer type descriptor.
-/// E.g., `*u8`, `[]u8`, `?*u8`, `?[]u8` in Zig.
-///
-/// TODO(port): In Zig this carries three `type` fields (`Pointer`,
-/// `NonOptionalPointer`, `Child`) populated by `@typeInfo`. Rust cannot store
-/// types as values; the generics here are a best-effort placeholder so
-/// downstream signatures that mention `PointerInfo` have something to name.
-pub struct PointerInfo<Pointer, NonOptionalPointer, Child> {
-    /// A possibly optional slice or single-item pointer type.
-    /// E.g., `*u8`, `[]u8`, `?*u8`, `?[]u8`.
-    _pointer: PhantomData<Pointer>,
-
-    /// If `Pointer` is an optional pointer, this is the non-optional equivalent. Otherwise, this
-    /// is the same as `Pointer`.
-    ///
-    /// For example, if `Pointer` is `?[]u8`, this is `[]u8`.
-    _non_optional_pointer: PhantomData<NonOptionalPointer>,
-
-    /// The type of data stored by the pointer, i.e., the type obtained by dereferencing a
-    /// single-item pointer or accessing an element of a slice.
-    ///
-    /// For example, if `Pointer` is `?[]u8`, this is `u8`.
-    _child: PhantomData<Child>,
-}
-
-impl<Pointer, NonOptionalPointer, Child> PointerInfo<Pointer, NonOptionalPointer, Child> {
-    pub fn kind(&self) -> Kind {
-        // TODO(port): Zig: `switch (@typeInfo(self.NonOptionalPointer).pointer.size)`.
-        // Rust has no `@typeInfo`; in the std-smart-pointer mapping the caller
-        // already knows whether it has `Box<T>` vs `Box<[T]>`.
-        unreachable!("comptime reflection — resolved at type level in Rust")
-    }
-
-    pub fn is_optional(&self) -> bool {
-        // TODO(port): Zig: `@typeInfo(self.Pointer) == .optional`.
-        unreachable!("comptime reflection — resolved at type level in Rust")
-    }
-
-    pub fn is_const(&self) -> bool {
-        // TODO(port): Zig: `@typeInfo(self.NonOptionalPointer).pointer.is_const`.
-        unreachable!("comptime reflection — resolved at type level in Rust")
-    }
-
-    pub fn parse(_options: ParseOptions) -> Self {
-        // TODO(port): Zig body walks `@typeInfo(Pointer)`:
-        //   - unwrap `.optional` to get `NonOptionalPointer`
-        //   - assert `.pointer`, extract `Child`
-        //   - reject `.many` / `.c` sizes, `is_volatile`, non-default
-        //     alignment, `is_allowzero`, sentinel-terminated
-        //   - reject `.slice` if `!options.allow_slices`
-        //   - reject `is_const` if `!options.allow_const`
-        // None of these checks are expressible in Rust's type system as a
-        // value-level function; they are subsumed by choosing `Box<T>` /
-        // `Box<[T]>` / `Option<Box<T>>` directly at the call site.
-        unreachable!("comptime reflection — resolved at type level in Rust")
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct ParseOptions {
-    pub allow_const: bool,
-    pub allow_slices: bool,
-}
-
-impl Default for ParseOptions {
-    fn default() -> Self {
-        Self {
-            allow_const: true,
-            allow_slices: true,
-        }
-    }
-}
-
-// TODO(port): `pub fn AddConst(Pointer: type) type` mutates `@typeInfo` to set
-// `.pointer.is_const = true` (recursing through `.optional`) and rebuilds the
-// type via `@Type`. Rust has no type-level function for this; the moral
-// equivalent is an associated type on a trait. Kept as a marker so callers
-// (`Owned::asConst` etc.) have a name to reference.
-pub trait AddConst {
-    type Output;
-}
-
-// ported from: src/ptr/meta.zig
diff --git a/src/ptr/owned.rs b/src/ptr/owned.rs
index 4af47cb371d..d121be352af 100644
--- a/src/ptr/owned.rs
+++ b/src/ptr/owned.rs
@@ -1,21 +1,20 @@
 //! Owned pointer abstractions.
 //!
-//! PORT NOTE: The Zig `Owned(comptime Pointer: type)` is a single type-returning function that
-//! dispatches on `@typeInfo(Pointer)` (single-item vs slice, optional vs non-optional). Rust has
-//! no `@typeInfo`, so the four shapes become four distinct std types per the crate map:
+//! The four pointer shapes (single-item vs slice, optional vs non-optional) map to
+//! four distinct std types per the crate map:
 //!
-//!   Zig                       Rust
-//!   ───────────────────────   ──────────────────────────
+//!   legacy shape              Rust type
+//!   ------------------------  ---------
 //!   Owned(*T)                 Box<T>
 //!   Owned([]T)                Box<[T]>   (or Vec<T> if it grows)
 //!   Owned(?*T)                Option<Box<T>>
 //!   Owned(?[]T)               Option<Box<[T]>>
 //!   OwnedIn(P, Allocator)     Box<T> — allocator param deleted (global mimalloc)
-//!   Dynamic(P)                Box<T> — std.mem.Allocator field deleted
+//!   Dynamic(P)                Box<T> — allocator field deleted
 //!   Unmanaged                 Box<T> — managed/unmanaged split disappears
 //!
 //! Callers should use the std types directly (PORTING.md §Pointers). This file exists so
-//! `bun_ptr::owned::*` resolves and so the Zig API surface has a 1:1 diffable mapping comment.
+//! `bun_ptr::owned::*` resolves and so the API surface has a 1:1 diffable mapping comment.
 
 /// An owned pointer or slice that was allocated using the default allocator.
 ///
@@ -29,41 +28,27 @@
 /// This type is an alias of `OwnedIn(Pointer, bun.DefaultAllocator)`, and thus has no overhead
 /// because `bun.DefaultAllocator` is a zero-sized type.
 ///
-/// PORT NOTE: in Rust this is `Box<T>` / `Box<[T]>` / `Option<Box<_>>`. The alias below covers
+/// In Rust this is `Box<T>` / `Box<[T]>` / `Option<Box<_>>`. The alias below covers
 /// only the `*T` (single, non-optional) case, which is the overwhelmingly common one. Slice and
-/// optional callers use `Box<[T]>` / `Option<Box<T>>` directly.
+/// optional callers use `Box<[T]>` / `Option<Box<T>>` directly (PORTING.md §Pointers).
 pub type Owned<T> = Box<T>;
-// TODO(port): Zig `Owned` accepts a *pointer type* (`*T`, `[]T`, `?*T`, `?[]T`) and branches on
-// kind via @typeInfo. Rust generics cannot inspect "is T a slice / is T optional", so a single
-// alias cannot cover all four. Audit call sites; they should already be `Box<T>` /
-// `Box<[T]>` / `Option<Box<_>>` per PORTING.md §Pointers and LIFETIMES.tsv.
 
-/// `std.mem.Allocator` param/field is deleted entirely outside AST crates. `Dynamic` collapses
+/// The runtime-allocator param/field is deleted entirely outside AST crates. `Dynamic` collapses
 /// to `Box<T>`.
 pub type Dynamic<T> = Box<T>;
-// TODO(port): if any caller genuinely needs a runtime-chosen allocator (e.g. arena vs heap at
-// runtime), that caller is in an AST crate and should use `bumpalo::boxed::Box<'bump, T>` or a
-// bespoke enum — not this type. Audit call sites if one appears.
+// A caller that genuinely needs a runtime-chosen allocator (e.g. arena vs heap at runtime)
+// belongs in an AST crate and should use `bumpalo::boxed::Box<'bump, T>` or a bespoke enum —
+// not this type.
 
 /// An owned pointer or slice, allocated using an instance of `Allocator`.
 ///
-/// `Allocator` must be one of the following:
-///
-/// * `std.mem.Allocator`
-/// * A type with a method named `allocator` that takes no parameters (except `self`) and returns
-///   an instance of `std.mem.Allocator`.
-///
-/// If `Allocator` is a zero-sized type, the owned pointer has no overhead compared to a raw
-/// pointer.
-///
-/// PORT NOTE: the `Allocator` type parameter is dropped — global mimalloc. See module doc.
+/// The `Allocator` type parameter is dropped — global mimalloc. See module doc.
 pub type OwnedIn<T /*, Allocator */> = Box<T>;
-// TODO(port): nightly `allocator_api` (`Box<T, A>`) would be the literal translation, but
-// PORTING.md forbids it (delete allocator params). Keeping the alias single-param.
+// Nightly `allocator_api` (`Box<T, A>`) would be the literal translation, but PORTING.md
+// forbids it (delete allocator params), so the alias stays single-param.
 
 // ──────────────────────────────────────────────────────────────────────────────────────────────
-// The block below mirrors the body of `fn OwnedIn(...) type { return struct { ... } }` so that
-// reviewers can diff method-by-method against owned.zig. Each Zig method is mapped to
+// The block below maps each method of the original `OwnedIn` API to
 // its `Box<T>` / `Box<[T]>` / `Option<Box<_>>` equivalent.
 // ──────────────────────────────────────────────────────────────────────────────────────────────
 
@@ -79,19 +64,19 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 
 // pub const Unmanaged = owned.Unmanaged(Pointer, Allocator);
 //   → managed/unmanaged split disappears (no allocator field to elide). `Box<T>` is already
-//     "unmanaged" in the Zig sense (no per-value allocator storage).
+//     "unmanaged" (no per-value allocator storage).
 
 // ── alloc ────────────────────────────────────────────────────────────────────────────────────
 // Allocates a new owned pointer with a default-initialized `Allocator`.
 //
 //   .single: alloc(value: Child) AllocError!Self
 //     → Box::new(value)                         (infallible — aborts on OOM, same as bun.handleOom)
-//     → Box::try_new(value)                     // TODO(port): nightly; use if AllocError must propagate
+//     → Box::try_new(value)                     // nightly-only; would apply if AllocError must propagate
 //
 //   .slice:  alloc(count: usize, elem: Child) AllocError!Self   (shallow copies of `elem`)
 //     → vec![elem; count].into_boxed_slice()    where Child: Clone
 //
-// PORT NOTE: Zig returns `AllocError!Self`; Rust `Box::new` aborts on OOM. PORTING.md says
+// `Box::new` aborts on OOM. PORTING.md says
 // `bun.handleOom(expr)` → `expr`, so the fallible form is not needed at most call sites.
 
 // ── allocIn ──────────────────────────────────────────────────────────────────────────────────
@@ -101,8 +86,7 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 //   .slice:  allocIn(count, elem, allocator)
 //     → vec![elem; count].into_boxed_slice()                     (allocator param deleted)
 //
-// The Zig body does `bun.memory.create` / `allocator.alloc` + `@memset`. In Rust the vec! macro
-// handles both allocation and fill.
+// The vec! macro handles both allocation and fill.
 
 // ── new ──────────────────────────────────────────────────────────────────────────────────────
 // Allocates an owned pointer for a single item, and calls `bun.outOfMemory` if allocation fails.
@@ -127,14 +111,9 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 //                  or, when `data` came from `Vec::into_raw_parts`:
 //                  unsafe { Vec::from_raw_parts(ptr, len, cap) }.into_boxed_slice()
 //     optional:  → if data.is_null() { None } else { Some(unsafe { bun_core::heap::take(data) }) }
-//
-// PORT NOTE: the Zig doc's caveat about `bun.new` vs `bun.default_allocator.create` is the
-// typed-mimalloc-heap distinction; in Rust both paths go through the same `#[global_allocator]`,
-// so the caveat does not apply.
 
 // ── fromRawIn ────────────────────────────────────────────────────────────────────────────────
 //   fromRawIn(data, allocator) → same as fromRaw; allocator param deleted.
-//   Zig sets `#allocator = undefined` when optional+null — irrelevant in Rust (no field).
 
 // ── deinit ───────────────────────────────────────────────────────────────────────────────────
 // Calls `deinit` on the underlying data (pointer target or slice elements) and then frees.
@@ -146,7 +125,7 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 // Frees the memory without calling `deinit` on the underlying data.
 //   deinitShallow(self: *Self) void
 //     → let _ = bun_core::heap::into_raw(ManuallyDrop::into_inner(/* ... */));
-//   PORT NOTE: "free the box allocation but don't drop T" is unusual in Rust. The two real uses:
+//   "Free the box allocation but don't drop T" is unusual in Rust. The two real uses:
 //     (a) T has no Drop → plain `drop(boxed)` is already shallow.
 //     (b) caller moved the payload out first → use `*boxed` to move out, then `drop(boxed)`.
 //   If a literal "dealloc without dropping" is needed:
@@ -174,7 +153,6 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 // ── PointerAndAllocator / intoRawWithAllocator ───────────────────────────────────────────────
 //   intoRawWithAllocator(self: *Self) (Pointer, Allocator) | ?(NonOptionalPointer, Allocator)
 //     → bun_core::heap::into_raw(boxed)                     (allocator dropped from tuple)
-//   // TODO(port): if any caller actually inspects the returned allocator, it needs rethinking.
 
 // ── initNull ─────────────────────────────────────────────────────────────────────────────────
 // Returns a null owned pointer (only when `Pointer` is optional).
@@ -202,7 +180,7 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 //     → boxed                                    (identity; no allocator field to drop)
 
 // ── toDynamic ────────────────────────────────────────────────────────────────────────────────
-// Converts a fixed-allocator owned pointer into one storing `std.mem.Allocator`.
+// Converts a fixed-allocator owned pointer into one storing a runtime allocator handle.
 //   toDynamic(self: *Self) Dynamic(Pointer)
 //     → boxed                                    (identity; allocator type erased → deleted)
 //   The `@hasDecl(Allocator, "Borrowed")` compile-time check has no Rust analogue and is
@@ -212,20 +190,19 @@ pub type OwnedIn<T /*, Allocator */> = Box<T>;
 // Returns a borrowed version of the allocator.
 //   allocator(self: Self) MaybeAllocator
 //     → ()                                       (no allocator stored)
-//   // TODO(port): callers should be deleted along with the allocator threading.
 
 // ── getStdAllocator (private) ────────────────────────────────────────────────────────────────
 //   → deleted.
 
 // ── deinitImpl (private) ─────────────────────────────────────────────────────────────────────
-//   deinitImpl(self, comptime mode: enum { deep, shallow })
+//   deinitImpl(self, mode: { deep, shallow })
 //     .deep    → drop(boxed)
 //     .shallow → see deinitShallow above
 //   The `info.kind()` switch (`bun.memory.destroy` vs `allocator.free`) is subsumed by Box's
 //   Drop impl, which knows its own Layout.
 
 // ──────────────────────────────────────────────────────────────────────────────────────────────
-// fn Unmanaged(comptime Pointer: type, comptime Allocator: type) type
+// Unmanaged(Pointer, Allocator)
 // ──────────────────────────────────────────────────────────────────────────────────────────────
 
 pub type Unmanaged<T /*, Allocator */> = Box<T>;
@@ -253,7 +230,6 @@ pub type Unmanaged<T /*, Allocator */> = Box<T>;
 
 #[inline]
 pub fn alloc_slice<T: Clone>(count: usize, elem: T) -> Box<[T]> {
-    // PERF(port): Zig used allocator.alloc + @memset (no per-elem clone for Copy types).
     vec![elem; count].into_boxed_slice()
 }
 
@@ -262,9 +238,8 @@ pub fn alloc_slice<T: Clone>(count: usize, elem: T) -> Box<[T]> {
 /// Shallow-copies `data` into a freshly heap-allocated boxed slice.
 /// For empty input this returns a zero-length `Box` with a dangling
 /// pointer and **no allocation** — identical to `Box::<[T]>::default()`,
-/// so callers MUST NOT add their own `is_empty()` guard (that pattern is
-/// a Zig-port artifact where the static `""` must not be freed — irrelevant
-/// in Rust where empty boxed slices are non-allocating).
+/// so callers MUST NOT add their own `is_empty()` guard — empty boxed
+/// slices are non-allocating.
 #[inline]
 pub fn alloc_dupe_slice<T: Clone>(data: &[T]) -> Box<[T]> {
     Box::<[T]>::from(data)
@@ -278,7 +253,7 @@ pub fn alloc_dupe_slice<T: Clone>(data: &[T]) -> Box<[T]> {
 /// and must not be freed elsewhere for the life of the returned `Box`.
 #[inline]
 pub unsafe fn from_raw<T>(data: *mut T) -> Box<T> {
-    // SAFETY: caller contract above mirrors Zig `fromRaw` requirements.
+    // SAFETY: caller contract above.
     unsafe { bun_core::heap::take(data) }
 }
 
@@ -289,5 +264,3 @@ pub fn into_raw<T>(boxed: Box<T>) -> *mut T {
 }
 
 // Suppress unused-import warnings until the unused helpers are pruned.
-
-// ported from: src/ptr/owned.zig
diff --git a/src/ptr/parent_ref.rs b/src/ptr/parent_ref.rs
index 71ad737ab43..38cde7b2077 100644
--- a/src/ptr/parent_ref.rs
+++ b/src/ptr/parent_ref.rs
@@ -224,7 +224,7 @@ impl<T: ?Sized> ParentRef<T> {
         }
     }
 
-    /// Wrap a raw `*mut T` with **write provenance** preserved (Zig `*T`).
+    /// Wrap a raw `*mut T` with **write provenance** preserved.
     ///
     /// This is the constructor for sites that will later call
     /// [`assume_mut`](Self::assume_mut): the pointer must originate from
diff --git a/src/ptr/raw_ref_count.rs b/src/ptr/raw_ref_count.rs
index 2a464e1819f..cfc549742f1 100644
--- a/src/ptr/raw_ref_count.rs
+++ b/src/ptr/raw_ref_count.rs
@@ -3,13 +3,11 @@
 //!
 //! May be useful for implementing the interface required by `ExternalShared`.
 //!
-//! PORT NOTE: Zig's `RawRefCount(Int, thread_safety)` is a comptime type
-//! function selecting field types from an enum. Stable Rust cannot vary a
-//! field's type from a const generic, and there is no generic `Atomic<Int>`.
-//! Split into two concrete structs (the only `Int` ever used is `u32`):
+//! Two concrete structs rather than one generic (stable Rust cannot vary a
+//! field's type from a const generic, and there is no generic `Atomic<Int>`):
 //!   `RawRefCount`       — single-threaded, plain `u32`, debug `ThreadLock`
 //!   `RawAtomicRefCount` — thread-safe, `AtomicU32`
-//! and a `const ATOMIC: bool` alias for callers that want the Zig spelling.
+//! plus a `const ATOMIC: bool` alias for callers that select by flag.
 
 use core::sync::atomic::{AtomicU32, Ordering};
 
@@ -89,7 +87,7 @@ impl RawAtomicRefCount {
     }
 
     pub fn decrement(&self) -> DecrementResult {
-        // Zig: `fetchSub(1, .release)` then `if new == 0 { fence(.acquire) }`.
+        // Release decrement, acquire fence on the last reference (below).
         let old = self.raw_value.fetch_sub(1, Ordering::Release);
         if cfg!(debug_assertions) || cfg!(windows) {
             // Always-on on Windows while #53265 fs-promises-writeFile is being
@@ -121,5 +119,3 @@ impl RawAtomicRefCount {
 // cannot dispatch on the const param on stable Rust, so any such alias would
 // silently resolve to one variant regardless of the bool — a footgun. Callers
 // must pick `RawRefCount` (single-thread) vs `RawAtomicRefCount` explicitly.
-
-// ported from: src/ptr/raw_ref_count.zig
diff --git a/src/ptr/ref_count.rs b/src/ptr/ref_count.rs
index 2eee27c476d..6b0a1a766f0 100644
--- a/src/ptr/ref_count.rs
+++ b/src/ptr/ref_count.rs
@@ -1,9 +1,7 @@
 //! Intrusive reference counting (single-threaded and thread-safe) + `RefPtr<T>`
 //! debug-tracking wrapper.
 //!
-//! Ported from `src/ptr/ref_count.zig`. The Zig original uses comptime
-//! type-returning functions (`fn RefCount(T, field_name, destructor, opts) type`)
-//! as mixins; in Rust this becomes a pair of (embedded struct + trait the host
+//! Each ref-count mixin is a pair of (embedded struct + trait the host
 //! type implements). See `RefCounted` / `ThreadSafeRefCounted`.
 
 use core::cell::Cell;
@@ -16,7 +14,7 @@ use core::sync::atomic::{AtomicU32, Ordering};
 use bun_core::StoredTrace;
 use bun_core::ThreadLock;
 
-// PORT NOTE(b0): was `bun_collections::{ArrayHashMap, HashMap}` (T1 → upward).
+// was `bun_collections::{ArrayHashMap, HashMap}` (T1 → upward).
 // Debug-only diagnostic storage; std HashMap drops insertion order for `frees`
 // which is acceptable for leak reports.
 #[cfg(debug_assertions)]
@@ -49,9 +47,8 @@ fn dump_stack_hook(trace: Option<&StoredTrace>, ret_addr: usize) {
 
 /// Options for `RefCount` / `ThreadSafeRefCount`.
 ///
-/// PORT NOTE: Zig's `Options` also carried `destructor_ctx: ?type`. A *type*
-/// cannot be a struct field in Rust; it becomes the associated type
-/// `RefCounted::DestructorCtx` instead.
+/// The destructor-context knob is the associated type
+/// `RefCounted::DestructorCtx`, not a field here.
 #[derive(Default)]
 pub struct Options {
     /// Defaults to the type basename.
@@ -60,31 +57,45 @@ pub struct Options {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Host-type traits (replace Zig's comptime `field_name` / `destructor` params)
+// Host-type traits (field projection + destructor)
 // ──────────────────────────────────────────────────────────────────────────
 
+/// `bun.meta.typeBaseName` — strip the module path (and the path inside any
+/// leading generic segment) from a `core::any::type_name` string, returning a
+/// subslice so the result stays `&'static str`.
+/// `"a::b::Foo<c::Bar>"` → `"Foo<c::Bar>"`.
+fn type_base_name(name: &'static str) -> &'static str {
+    let end = name.find('<').unwrap_or(name.len());
+    match name[..end].rfind("::") {
+        Some(i) => &name[i + 2..],
+        None => name,
+    }
+}
+
 /// Implemented by types that embed a [`RefCount`] field.
-///
-/// Replaces the Zig comptime parameters `field_name: []const u8`,
-/// `destructor: anytype`, and `options: Options` passed to
-/// `RefCount(T, field_name, destructor, options)`.
 pub trait RefCounted: Sized {
-    /// Zig: `options.destructor_ctx orelse void`.
     type DestructorCtx;
 
-    /// Zig: `options.debug_name orelse bun.meta.typeBaseName(@typeName(T))`.
+    /// Defaults to the type basename.
     fn debug_name() -> &'static str {
-        // TODO(port): bun.meta.typeBaseName — strip module path from type_name
-        core::any::type_name::<Self>()
+        type_base_name(core::any::type_name::<Self>())
     }
 
-    /// Zig: `&@field(self, field_name)` — locate the embedded `RefCount` field.
+    /// Locate the embedded `RefCount` field.
     ///
     /// # Safety
-    /// `this` must point to a live `Self`.
+    /// `this` must be non-null, properly aligned, and in-bounds of an
+    /// allocation large enough for `Self` — but it may point to
+    /// **uninitialized** memory: `offset_of_ref_count` probes this method
+    /// with a `MaybeUninit<Self>` to recover the field offset.
+    ///
+    /// Consequently, implementations MUST be pure raw-pointer field
+    /// projections (`&raw mut (*this).field`): no reads through `this`, no
+    /// creation of references (`&`/`&mut`) to `*this` or any of its fields,
+    /// and no other side effects.
     unsafe fn get_ref_count(this: *mut Self) -> *mut RefCount<Self>;
 
-    /// Zig: the `destructor` fn pointer passed to `RefCount(...)`.
+    /// Called when the refcount reaches zero.
     ///
     /// # Safety
     /// `this` must point to a live `Self` with `raw_count == 0`.
@@ -93,18 +104,26 @@ pub trait RefCounted: Sized {
 
 /// Implemented by types that embed a [`ThreadSafeRefCount`] field.
 pub trait ThreadSafeRefCounted: Sized {
-    /// Zig: `options.debug_name orelse bun.meta.typeBaseName(@typeName(T))`.
+    /// Defaults to the type basename.
     fn debug_name() -> &'static str {
-        core::any::type_name::<Self>()
+        type_base_name(core::any::type_name::<Self>())
     }
 
-    /// Zig: `&@field(self, field_name)`.
+    /// Locate the embedded `ThreadSafeRefCount` field.
     ///
     /// # Safety
-    /// `this` must point to a live `Self`.
+    /// `this` must be non-null, properly aligned, and in-bounds of an
+    /// allocation large enough for `Self` — but it may point to
+    /// **uninitialized** memory: `offset_of_ref_count_ts` probes this
+    /// method with a `MaybeUninit<Self>` to recover the field offset.
+    ///
+    /// Consequently, implementations MUST be pure raw-pointer field
+    /// projections (`&raw mut (*this).field`): no reads through `this`, no
+    /// creation of references (`&`/`&mut`) to `*this` or any of its fields,
+    /// and no other side effects.
     unsafe fn get_ref_count(this: *mut Self) -> *mut ThreadSafeRefCount<Self>;
 
-    /// Zig: the `destructor: fn (*T) void` parameter.
+    /// Called when the refcount reaches zero.
     ///
     /// # Safety
     /// `this` must point to a live `Self` with `raw_count == 0`.
@@ -118,10 +137,6 @@ pub trait ThreadSafeRefCounted: Sized {
 }
 
 /// Unifying trait so `RefPtr<T>` works with either ref-count flavor.
-///
-/// PORT NOTE: Zig's `RefPtr` reflected on `@FieldType(T, "ref_count")` and the
-/// private `is_ref_count == unique_symbol` marker to accept either mixin. In
-/// Rust the trait bound IS that check.
 pub trait AnyRefCounted: Sized {
     type DestructorCtx;
 
@@ -131,10 +146,8 @@ pub trait AnyRefCounted: Sized {
     /// # Safety
     /// `this` must point to a live `Self`.
     unsafe fn rc_deref_with_context(this: *mut Self, ctx: Self::DestructorCtx);
-    /// Zig's `deref(self)` forwards `{}` (void) as the ctx — equivalent to
-    /// `Default::default()`. Types with a non-unit `DestructorCtx` must call
-    /// `rc_deref_with_context` explicitly (matches Zig's compile error when
-    /// `destructor_ctx != null`).
+    /// Forwards `Default::default()` as the ctx. Types with a non-unit
+    /// `DestructorCtx` must call `rc_deref_with_context` explicitly.
     ///
     /// # Safety
     /// `this` must point to a live `Self`.
@@ -261,7 +274,7 @@ impl<T: RefCounted> RefCount<T> {
 
     // interface implementation
 
-    // PORT NOTE: `ref` is a Rust keyword; renamed to `ref_`.
+    // `ref` is a Rust keyword; renamed to `ref_`.
     /// # Safety
     /// `self_` must point to a live `T`.
     pub unsafe fn ref_(self_: *mut T) {
@@ -271,9 +284,8 @@ impl<T: RefCounted> RefCount<T> {
         {
             count.debug.assert_valid();
         }
-        // TODO(port): per-type scoped logging — Zig used
-        // `bun.Output.Scoped(debug_name, .hidden)` keyed on T's name. The
-        // `bun_core::scoped_log!` macro expects a static scope ident.
+        // `bun_core::scoped_log!` requires a static scope ident, so all types
+        // share the single `ref_count` scope.
         bun_core::scoped_log!(
             ref_count,
             "0x{:x}   ref {} -> {}:",
@@ -282,7 +294,6 @@ impl<T: RefCounted> RefCount<T> {
             count.raw_count.get() + 1,
         );
         if DEBUG_STACK_TRACE {
-            // TODO(port): was dump_current_stack_trace(ret, {frame_count:2, skip:[ref_count.zig]})
             dump_stack_hook(None, return_address());
         }
         count.assert_single_threaded();
@@ -316,7 +327,6 @@ impl<T: RefCounted> RefCount<T> {
             count.raw_count.get() - 1,
         );
         if DEBUG_STACK_TRACE {
-            // TODO(port): was dump_current_stack_trace(ret, {frame_count:2, skip:[ref_count.zig]})
             dump_stack_hook(None, return_address());
         }
         count.assert_single_threaded();
@@ -358,7 +368,10 @@ impl<T: RefCounted> RefCount<T> {
         {
             // SAFETY: self is the `ref_count` field of a live T
             let ptr: *mut T = unsafe {
-                bun_core::container_of::<T, Self>(std::ptr::from_mut(self), offset_of_ref_count())
+                bun_core::container_of::<T, Self>(
+                    std::ptr::from_mut(self),
+                    offset_of_ref_count::<T>(),
+                )
             };
             self.debug.dump(
                 Some(core::any::type_name::<T>().as_bytes()),
@@ -370,7 +383,6 @@ impl<T: RefCounted> RefCount<T> {
 
     /// The count is 0 after the destructor is called.
     pub fn assert_no_refs(&self) {
-        // Zig: gated on `bun.Environment.ci_assert`.
         assert!(self.raw_count.get() == 0);
     }
 
@@ -388,11 +400,11 @@ impl<T: RefCounted> RefCount<T> {
         self.thread.lock_or_assert();
     }
 
-    // PORT NOTE: `getRefCount(self: *T) *@This()` is the trait method
+    // `getRefCount(self: *T) *@This()` is the trait method
     // `T::get_ref_count` above; not duplicated here.
 
-    // PORT NOTE: `is_ref_count = unique_symbol` and `ref_count_options` were
-    // comptime-reflection markers for `RefPtr`; replaced by the `AnyRefCounted`
+    // `is_ref_count = unique_symbol` and `ref_count_options` were
+    // reflection markers for `RefPtr`; replaced by the `AnyRefCounted`
     // trait bound.
 }
 
@@ -575,7 +587,7 @@ impl<T: ThreadSafeRefCounted> ThreadSafeRefCount<T> {
             let ptr: *mut T = unsafe {
                 bun_core::container_of::<T, Self>(
                     std::ptr::from_mut(self),
-                    offset_of_ref_count_ts(),
+                    offset_of_ref_count_ts::<T>(),
                 )
             };
             self.debug.dump(
@@ -588,7 +600,6 @@ impl<T: ThreadSafeRefCounted> ThreadSafeRefCount<T> {
 
     /// The count is 0 after the destructor is called.
     pub fn assert_no_refs(&self) {
-        // Zig: gated on `bun.Environment.ci_assert`.
         assert!(self.raw_count.load(Ordering::SeqCst) == 0);
     }
 
@@ -614,7 +625,7 @@ impl<T: ThreadSafeRefCounted> ThreadSafeRefCount<T> {
         &raw mut self.debug
     }
 
-    // PORT NOTE: `getRefCount` / `is_ref_count` / `ref_count_options` — see
+    // `getRefCount` / `is_ref_count` / `ref_count_options` — see
     // notes on RefCount above.
 }
 
@@ -744,9 +755,6 @@ pub fn noop_debug_data() -> *mut dyn DebugDataOps {
 // with the `RefCounted` blanket above (Rust forbids overlapping blanket impls).
 // Instead, thread-safe hosts opt in via `#[derive(ThreadSafeRefCounted)]`,
 // which emits the per-type `AnyRefCounted` impl alongside the trait impl.
-//
-// Zig: `RefPtr` reflected on `@FieldType(T, "ref_count")` to accept either
-// mixin; the derive is the manual half of that dispatch.
 
 // ──────────────────────────────────────────────────────────────────────────
 // RefPtr
@@ -764,8 +772,7 @@ pub fn noop_debug_data() -> *mut dyn DebugDataOps {
 ///
 /// # ⚠️ No `Drop` impl — the owned ref must be released *manually*
 ///
-/// This mirrors the Zig original, which (having no destructors) never released
-/// on scope exit. `RefPtr` does **not** implement `Drop`: dropping a `RefPtr`
+/// `RefPtr` does **not** implement `Drop`: dropping a `RefPtr`
 /// value — including `Option::take()`-then-drop, or letting a struct field
 /// holding one go out of scope — **leaks** the strong ref it owns. On every
 /// path that gives up a `RefPtr` you must explicitly call one of:
@@ -795,14 +802,12 @@ impl<T: AnyRefCounted> RefPtr<T> {
     pub unsafe fn init_ref(raw_ptr: *mut T) -> Self {
         // SAFETY: caller contract
         unsafe { T::rc_ref(raw_ptr) };
-        // PORT NOTE: Zig re-asserted `is_ref_count == unique_symbol` here;
-        // the `T: AnyRefCounted` bound is that assertion.
         // SAFETY: caller contract
         unsafe { Self::unchecked_and_unsafe_init(raw_ptr, return_address()) }
     }
 
     // NOTE: would be nice to use a const for deref dispatch, but keep two
-    // methods for clarity (matches Zig comment).
+    // methods for clarity.
 
     /// Decrement the reference count, and destroy the object if the count is 0.
     pub fn deref(&self)
@@ -821,11 +826,11 @@ impl<T: AnyRefCounted> RefPtr<T> {
         }
         // SAFETY: data is live (we hold a ref)
         unsafe { T::rc_deref_with_context(self.as_ptr(), ctx) };
-        // make UAF fail faster (ideally integrate this with ASAN)
-        // PORT NOTE: Zig did `@constCast(self).data = undefined`. In Rust we
-        // cannot mutate through `&self` without UnsafeCell; and `RefPtr` is
-        // consumed-by-value in idiomatic use anyway.
-        // TODO(port): consider taking `self` by value and dropping.
+        // The handle is not poisoned after release: that would require
+        // mutating through `&self` (UnsafeCell), and `&self` is load-bearing
+        // here: hundreds of call sites (including Drop impls and ScopedRef)
+        // deref through a borrow they cannot move out of, so a by-value
+        // signature is not an option.
     }
 
     pub fn dupe_ref(&self) -> Self {
@@ -940,8 +945,7 @@ impl<T: AnyRefCounted> RefPtr<T> {
             // SAFETY: data is live (we hold a ref)
             unsafe { (*T::rc_debug_data(ptr)).release(self.debug, return_address()) };
         }
-        // PORT NOTE: Zig set `self.data = undefined`; taking `self` by value
-        // here makes the RefPtr unusable, which is the same intent.
+        // Taking `self` by value makes the RefPtr unusable afterwards.
         ptr
     }
 
@@ -982,7 +986,7 @@ impl<T: AnyRefCounted> core::ops::Deref for RefPtr<T> {
 
 /// RAII scope guard for an intrusive refcount: bumps on construction, derefs
 /// on `Drop`. Use to bracket a `ref_()`/`deref()` pair that protects `*T`
-/// across a re-entrant call (Zig: `this.ref(); defer this.deref();`).
+/// across a re-entrant call.
 ///
 /// Unlike [`RefPtr`] this is not a smart-pointer handle (no `Deref`, not
 /// stored in fields) — it exists solely so the paired deref runs on every
@@ -1012,7 +1016,7 @@ where
     /// Adopt an already-held ref: does **not** bump on construction, but still
     /// derefs on `Drop`. Use when the matching `ref()` was taken earlier (e.g.
     /// by an in-flight async op) and this scope is responsible for releasing
-    /// it (Zig: `defer this.deref();` with no preceding `this.ref()`).
+    /// it.
     ///
     /// # Safety
     /// `ptr` must point to a live `T` for which the caller owns one outstanding
@@ -1045,7 +1049,6 @@ struct TrackedRef {
 }
 
 /// Not an index, just a unique identifier for the debug data.
-// PORT NOTE: Zig used `bun.GenericIndex(u32, TrackedRef)` (opaque type-tag).
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct TrackedRefId(u32);
 
@@ -1078,15 +1081,11 @@ const MAGIC_VALID: u128 = 0x2f84_e51d;
 
 /// Provides Ref tracking. This is not generic over the pointer T to reduce
 /// analysis complexity.
-// PORT NOTE: Zig parameterized on `comptime thread_safe: bool` and selected
-// `Count`/`Lock` types accordingly. Rust cannot select a type from a const
-// bool without a helper trait; instead we parameterize on the `Count` storage
-// type directly (`Cell<u32>` or `AtomicU32`). The lock and `next_id` are made
-// uniformly thread-safe (debug-only — perf irrelevant).
+// Parameterized on the `Count` storage type directly (`Cell<u32>` or
+// `AtomicU32`). The lock and `next_id` are made uniformly thread-safe
+// (debug-only — perf irrelevant).
 #[cfg(debug_assertions)]
 pub struct DebugData<Count> {
-    // TODO(port): Zig used `align(@alignOf(u32))` to reduce u128 alignment to
-    // 4. Rust cannot under-align a field; consider `[u32; 4]` if layout matters.
     magic: u128,
     lock: bun_core::Mutex<()>,
     next_id: AtomicU32,
@@ -1097,7 +1096,7 @@ pub struct DebugData<Count> {
 
 #[cfg(debug_assertions)]
 impl<Count: CountLoad> DebugData<Count> {
-    // PORT NOTE(b0): was `pub const EMPTY` — std HashMap::new() is non-const.
+    // was `pub const EMPTY` — std HashMap::new() is non-const.
     pub fn empty() -> Self {
         Self {
             magic: MAGIC_VALID,
@@ -1119,7 +1118,6 @@ impl<Count: CountLoad> DebugData<Count> {
     }
 
     fn alloc_id(&self) -> TrackedRefId {
-        // PORT NOTE: Zig branched on `thread_safe` (atomic RMW vs plain ++).
         // Debug-only path; always atomic here.
         TrackedRefId::new(self.next_id.fetch_add(1, Ordering::SeqCst))
     }
@@ -1134,17 +1132,15 @@ impl<Count: CountLoad> DebugData<Count> {
         self.frees.insert(id, TrackedDeref);
     }
 
-    // PORT NOTE: Zig `deinit` took `std.mem.asBytes(self)` as `data: []const u8`
-    // but never read it; the Rust port dropped the parameter to avoid forming a
-    // `&[u8]` over `T` (which may contain padding/uninit bytes — UB to read).
     fn deinit(&mut self, ret_addr: usize) {
         self.assert_valid();
-        self.magic = 0; // Zig: `= undefined`
+        self.magic = 0;
         let _guard = self.lock.lock();
         self.map.clear();
         self.map.shrink_to_fit();
+        // Clear and release the allocation.
         self.frees.clear();
-        // TODO(port): ArrayHashMap shrink — Zig clearAndFree
+        self.frees.shrink_to_fit();
         let _ = ret_addr;
     }
 }
@@ -1156,13 +1152,10 @@ impl<Count: CountLoad> DebugDataOps for DebugData<Count> {
     }
 
     fn acquire(&mut self, return_address: usize) -> TrackedRefId {
-        // PORT NOTE: Zig's `acquire` took `count_pointer: *Count` because
-        // `RefPtr.uncheckedAndUnsafeInit` reached into `raw_ptr.ref_count.raw_count`.
-        // The dyn surface cannot name `Count`; the typed call site
-        // (RefCount::ref_/ThreadSafeRefCount::ref_) wires the count_pointer
-        // separately. Here we acquire without updating count_pointer.
-        // TODO(port): plumb count_pointer through AnyRefCounted if leak-dump
-        // needs it for RefPtr-created refs.
+        // The dyn surface cannot name `Count`, so we acquire without a count
+        // pointer; that is fine because the only leak-dump path
+        // (`dump_active_refs`) receives the current count explicitly as a
+        // parameter, so nothing reads a stored count pointer.
         let _guard = self.lock.lock();
         let id = self.alloc_id();
         self.map.insert(
@@ -1244,10 +1237,8 @@ fn generic_dump(
 // maybe_assert_no_refs
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig used `@hasField(T, "ref_count")` + `@hasDecl(Rc, "assertNoRefs")`
-/// reflection to make this a no-op for non-ref-counted types. In Rust the
-/// "has ref_count" check IS the trait bound.
-// TODO(port): callers that passed non-ref-counted T must simply not call this.
+/// The trait bound restricts this to ref-counted types; callers with a
+/// non-ref-counted T must simply not call this.
 pub fn maybe_assert_no_refs<T: AnyRefCounted>(ptr: &T) {
     // SAFETY: `ptr` is a live reference to T
     unsafe { T::rc_assert_no_refs(std::ptr::from_ref::<T>(ptr)) }
@@ -1262,25 +1253,34 @@ fn return_address() -> usize {
     bun_core::return_address()
 }
 
+// The ref-count field name is not known here as a const, but
+// `T::get_ref_count` is a pure raw-pointer field projection
+// (`&raw mut (*this).field` — no read), so probing an uninitialized stack
+// value yields the field offset soundly.
+
 #[cfg(debug_assertions)]
 #[inline(always)]
-fn offset_of_ref_count() -> usize {
-    // TODO(port): Zig used `@fieldParentPtr(field_name, count)`. Without the
-    // field name as a const, compute via the trait: feed a dangling aligned T
-    // and diff pointers. The derive macro could emit `offset_of!(T, ref_count)`.
-    0
+fn offset_of_ref_count<T: RefCounted>() -> usize {
+    let mut uninit = core::mem::MaybeUninit::<T>::uninit();
+    let base = uninit.as_mut_ptr();
+    // SAFETY: `get_ref_count` only projects a field within `base`'s
+    // allocation; it never reads `*base`.
+    let field = unsafe { T::get_ref_count(base) };
+    field as usize - base as usize
 }
 
 #[cfg(debug_assertions)]
 #[inline(always)]
-fn offset_of_ref_count_ts() -> usize {
-    // TODO(port): see offset_of_ref_count.
-    0
+fn offset_of_ref_count_ts<T: ThreadSafeRefCounted>() -> usize {
+    let mut uninit = core::mem::MaybeUninit::<T>::uninit();
+    let base = uninit.as_mut_ptr();
+    // SAFETY: `get_ref_count` only projects a field within `base`'s
+    // allocation; it never reads `*base`.
+    let field = unsafe { T::get_ref_count(base) };
+    field as usize - base as usize
 }
 
-// PORT NOTE: `const unique_symbol = opaque {};` — type-identity marker for
-// comptime assertion in `RefPtr`. Replaced by `AnyRefCounted` trait bound.
+// `const unique_symbol = opaque {};` — type-identity marker for
+// compile-time assertion in `RefPtr`. Replaced by `AnyRefCounted` trait bound.
 
 bun_core::declare_scope!(ref_count, hidden);
-
-// ported from: src/ptr/ref_count.zig
diff --git a/src/ptr/shared.rs b/src/ptr/shared.rs
index 3d1acf3c904..182d45f19d4 100644
--- a/src/ptr/shared.rs
+++ b/src/ptr/shared.rs
@@ -6,9 +6,9 @@
 //! weak-count header word ("4 uses tree-wide, 8 bytes per allocation is negligible,
 //! and you lose `Rc::downgrade`/`make_mut`/`get_mut`").
 //!
-//! This module therefore re-exports `Rc`/`Arc`/`Weak` under the Zig names so that
+//! This module therefore re-exports `Rc`/`Arc`/`Weak` under the legacy names so that
 //! mechanical `bun_ptr::shared::*` references resolve, and documents the 1:1 method
-//! mapping for reviewers diffing against `src/ptr/shared.zig`.
+//! mapping.
 
 use std::rc::Rc;
 
@@ -16,54 +16,17 @@ use std::rc::Rc;
 // Options
 // ───────────────────────────────────────────────────────────────────────────────
 
-/// Options for `WithOptions`.
-///
-/// In the Rust port these collapse to the std `Rc`/`Arc` knobs:
-///
-/// * `Allocator` — std `Rc`/`Arc` always use the global allocator (mimalloc via
-///   `#[global_allocator]`). `Rc::new_in`/`Arc::new_in` are nightly-only
-///   (`feature(allocator_api)`); see `// TODO(port)` on `SharedIn` below.
-/// * `atomic` — picks `Rc` vs `Arc`.
-/// * `allow_weak` — `Rc`/`Arc` always carry a weak count, so this is always
-///   effectively `true`. The Zig flag existed only to save 4 bytes when weak
-///   pointers were not needed.
-/// * `deinit` — `Rc`/`Arc` always run `Drop` on the inner `T`. To suppress
-///   `Drop`, wrap the payload in `ManuallyDrop<T>` at the call site.
+// The legacy `Options` struct (the parameter of `WithOptions`) has no Rust value:
+// each knob collapses to a std `Rc`/`Arc` choice made at the use site.
 //
-// TODO(port): this struct is kept only as documentation of the Zig surface; no
-// Rust code should construct it. Remove once all `WithOptions` call sites are
-// migrated to plain `Rc<T>`/`Arc<T>`.
-pub struct Options {
-    // If non-null, the shared pointer will always use the provided allocator. This saves a small
-    // amount of memory, but it means the shared pointer will be a different type from shared
-    // pointers that use different allocators.
-    // (Rust: global mimalloc; allocator_api is unstable.)
-    //
-    /// Whether to use an atomic type to store the ref count. This makes the shared pointer
-    /// thread-safe, assuming the underlying data is also thread-safe.
-    pub atomic: bool,
-
-    /// Whether to allow weak pointers to be created. This uses slightly more memory but is often
-    /// negligible due to padding.
-    ///
-    /// There is no point in enabling this if `deinit` is false, or if your data type doesn't have
-    /// a `deinit` method, since the sole purpose of weak pointers is to allow `deinit` to be called
-    /// before the memory is freed.
-    pub allow_weak: bool,
-
-    /// Whether to call `deinit` on the data before freeing it, if such a method exists.
-    pub deinit: bool,
-}
-
-impl Default for Options {
-    fn default() -> Self {
-        Self {
-            atomic: false,
-            allow_weak: false,
-            deinit: true,
-        }
-    }
-}
+// * `Allocator` — std `Rc`/`Arc` always use the global allocator (mimalloc via
+//   `#[global_allocator]`). `Rc::new_in`/`Arc::new_in` are nightly-only
+//   (`feature(allocator_api)`).
+// * `atomic` — picks `Rc` vs `Arc`.
+// * `allow_weak` — `Rc`/`Arc` always carry a weak count, so this is always
+//   effectively `true`.
+// * `deinit` — `Rc`/`Arc` always run `Drop` on the inner `T`. To suppress
+//   `Drop`, wrap the payload in `ManuallyDrop<T>` at the call site.
 
 // ───────────────────────────────────────────────────────────────────────────────
 // Shared / AtomicShared
@@ -74,12 +37,12 @@ impl Default for Options {
 /// This type is not thread-safe: all pointers to the same piece of data must live on the same
 /// thread. See `AtomicShared` for a thread-safe version.
 ///
-/// ## Method map (Zig → Rust)
+/// ## Method map (legacy → Rust)
 ///
-/// | Zig                         | Rust                                          |
+/// | Legacy                      | Rust                                          |
 /// |-----------------------------|-----------------------------------------------|
 /// | `Shared(*T).alloc(v)`       | `Rc::new(v)` (infallible; aborts on OOM)      |
-/// | `Shared(*T).allocIn(v, a)`  | — (allocator_api unstable; `// TODO(port)`)   |
+/// | `Shared(*T).allocIn(v, a)`  | — (allocator_api unstable; allocator deleted) |
 /// | `Shared(*T).new(v)`         | `Rc::new(v)`                                  |
 /// | `s.get()`                   | `&*s` / `Rc::as_ptr(&s)`                      |
 /// | `s.clone()`                 | `Rc::clone(&s)`                               |
@@ -94,13 +57,12 @@ impl Default for Options {
 /// | `Self.adoptRawUnsafe(p)`    | `unsafe { Rc::from_raw(p) }`                  |
 /// | `Self.cloneFromRawUnsafe(p)`| `unsafe { Rc::increment_strong_count(p); Rc::from_raw(p) }` |
 ///
-// PERF(port): Rc weak-count header — profile if hot (PORTING.md §Pointers).
+// PERF: Rc carries a weak-count header — profile if hot (PORTING.md §Pointers).
 pub type Shared<T> = Rc<T>;
 
 /// A shared pointer allocated using a specific type of allocator.
 ///
 /// The requirements for `Allocator` are the same as `bun.ptr.OwnedIn`.
-/// `Allocator` may be `std.mem.Allocator` to allow any kind of allocator.
 //
 
 /// A thread-safe shared pointer allocated using a specific type of allocator.
@@ -119,9 +81,9 @@ pub type Shared<T> = Rc<T>;
 /// accessed. This upgrading can fail if no shared pointers exist anymore, as the shared
 /// data will have been deinitialized in that case.
 ///
-/// ## Method map (Zig → Rust)
+/// ## Method map (legacy → Rust)
 ///
-/// | Zig                  | Rust                                  |
+/// | Legacy               | Rust                                  |
 /// |----------------------|---------------------------------------|
 /// | `w.upgrade()`        | `w.upgrade()` (→ `Option<Rc<T>>`)     |
 /// | `w.clone()`          | `w.clone()`                           |
@@ -136,7 +98,7 @@ pub type Weak<T> = std::rc::Weak<T>;
 // FullData / NonAtomicCount / AtomicCount
 // ───────────────────────────────────────────────────────────────────────────────
 //
-// The Zig `FullData` struct (value + strong_count + weak_count + allocator +
+// The legacy `FullData` struct (value + strong_count + weak_count + allocator +
 // thread_lock) is the moral equivalent of `RcInner<T>` / `ArcInner<T>` in std,
 // which are private implementation details. We do not re-implement them.
 //
@@ -151,18 +113,12 @@ pub type Weak<T> = std::rc::Weak<T>;
 //
 // The `fromValuePtr` (`@fieldParentPtr("value", ptr)`) recovery is provided by
 // `Rc::from_raw` / `Arc::from_raw`, which subtract the header offset internally.
-//
-// TODO(port): if profiling shows the std weak-count word is measurable in a
-// hot array, revisit with a `#[repr(C)]` hand-rolled inner — but per
-// PORTING.md this is explicitly deprioritized.
 
-// `RawCount` was `u32` in Zig; std uses `usize`. The overflow assertion
+// `RawCount` was `u32`; std uses `usize`. The overflow assertion
 // (`old != maxInt(RawCount)`) is replaced by std's own abort-on-overflow check
 // in `Arc::clone` (it aborts if the count would exceed `isize::MAX`).
 
-// `parsePointer` (Zig comptime reflection over `*T` / `?*T`) has no Rust
+// `parsePointer` (reflection over `*T` / `?*T`) has no Rust
 // analogue and is not needed: optionality is expressed at the use site as
 // `Option<Rc<T>>`, and slices/const are rejected by the type system rather than
-// a comptime check.
-
-// ported from: src/ptr/shared.zig
+// a compile-time check.
diff --git a/src/ptr/tagged_pointer.rs b/src/ptr/tagged_pointer.rs
index df6281afa2a..22abb838722 100644
--- a/src/ptr/tagged_pointer.rs
+++ b/src/ptr/tagged_pointer.rs
@@ -6,8 +6,7 @@ pub(crate) type AddressableSize = u64;
 
 /// `TaggedPtr::Tag` — logically u15, carried in u16. (Inherent assoc types are nightly; hoisted here.)
 pub type TagType = u16;
-/// Zig: `packed struct(u64) { _ptr: u49, data: u15 }`
-/// Packed-struct field order in Zig is LSB-first, so:
+/// Bit layout:
 ///   bits  0..49 → `_ptr`
 ///   bits 49..64 → `data`
 #[repr(transparent)]
@@ -24,9 +23,7 @@ impl TaggedPtr {
 
     #[inline]
     pub fn init<T>(ptr: *const T, data: TagType) -> TaggedPtr {
-        // Zig's `if (Ptr == @TypeOf(null))` branch is subsumed: a null `*const T`
-        // yields address 0 below. The `@typeInfo(Ptr) != .pointer` compile error
-        // is enforced by `*const T` in the signature.
+        // A null `*const T` yields address 0 below.
         let address = ptr as usize;
         TaggedPtr(
             (address as u64 & Self::ADDR_MASK) // @truncate to u49
@@ -52,22 +49,17 @@ impl TaggedPtr {
     #[inline]
     pub fn get<Type>(self) -> *mut Type {
         // SAFETY: caller asserts the stored address points to a live `Type`.
-        // @ptrFromInt(@intCast(this._ptr))
         self.ptr_bits() as usize as *mut Type
     }
 
     #[inline]
     pub fn to(self) -> *mut c_void {
-        // @ptrFromInt(@bitCast(this)) — note: includes the tag bits in the high
-        // word, matching Zig. This is intentional: round-tripping through
-        // `*anyopaque` preserves the tag.
+        // Note: includes the tag bits in the high word. This is intentional:
+        // round-tripping through `*anyopaque` preserves the tag.
         self.0 as usize as *mut c_void
     }
 }
 
-// Zig `from(val: anytype)` dispatches on @TypeOf(val):
-//   f64 | i64 | u64        => @bitCast(val)
-//   ?*anyopaque|*anyopaque => @bitCast(@intFromPtr(val))
 impl From<u64> for TaggedPtr {
     #[inline]
     fn from(val: u64) -> Self {
@@ -104,20 +96,17 @@ impl From<Option<*mut c_void>> for TaggedPtr {
 // TaggedPointerUnion
 // ─────────────────────────────────────────────────────────────────────────────
 //
-// Zig builds this with heavy comptime reflection: `@typeName`, `@Type` to mint
-// an enum, `@hasField`/`@field` for membership checks, and `inline for` over a
-// type tuple. None of that exists in Rust. We model it with two traits:
+// Modeled with two traits:
 //
 //   - `TypeList`      : implemented for the tuple `(T1, T2, ...)`; carries the
 //                       variant count and the tag→name table.
 //   - `UnionMember<L>`: implemented for each `Ti` against its list `L`; carries
-//                       that type's tag value (1024 - index, matching Zig).
+//                       that type's tag value (1024 - index).
 //
-// `assert_type` / `@hasField` become a `T: UnionMember<Ts>` bound — the compile
-// error is the trait-bound failure.
+// Membership checks become a `T: UnionMember<Ts>` bound — the compile error is
+// the trait-bound failure.
 //
-// Tag values are assigned exactly as Zig does: `1024 - i` for index `i`. Zig
-// also reifies a non-exhaustive `enum(u15)` for the tag; we keep the raw u15
+// Tag values are assigned as `1024 - i` for index `i`. We keep the raw u15
 // and expose `tag()` as the integer (callers that need an enum can define one
 // per instantiation).
 
@@ -133,18 +122,16 @@ pub trait TypeList {
 }
 
 /// `T: UnionMember<Ts>` ⇔ `T` is one of the types in the list `Ts`.
-/// Replaces Zig's `assert_type` / `@hasField(Tag, @typeName(Type))`.
 pub trait UnionMember<Ts: TypeList> {
     const TAG: TagType;
     const NAME: &'static str;
 }
 
 /// Generates `TypeList` for `($($T,)*)` and `UnionMember<($($T,)*)>` for each
-/// `$T`, assigning tags `1024 - i` to match Zig's `TagTypeEnumWithTypeMap`.
-// TODO(port): proc-macro — Zig uses `@typeName` for both the tag enum field
-// name and the `name` string. `stringify!($T)` is the closest analogue but
-// won't match Zig's fully-qualified `@typeName` output; confirm no caller
-// depends on the exact string.
+/// `$T`, assigning tags `1024 - i`.
+// `stringify!($T)` is not a fully-qualified type name. That is fine: no
+// caller consumes the strings (`type_name`/`type_name_from_tag` have no users
+// outside debug output), so the exact spelling is not load-bearing.
 #[macro_export]
 macro_rules! impl_tagged_ptr_union {
     ($($T:ty),+ $(,)?) => {
@@ -203,18 +190,16 @@ impl<Ts: TypeList> TaggedPtrUnion<Ts> {
         *self = Self::NULL;
     }
 
-    // `typeFromTag(comptime the_tag) type` has no Rust equivalent (cannot
-    // return a type from a const value). Callers must name the type directly.
-    // TODO(port): if any callsite needs this, it becomes a trait associated type.
+    // A tag→type mapping function has no Rust equivalent (cannot
+    // return a type from a const value). Callers must name the type directly;
+    // no callsite needs it.
 
     pub fn type_name_from_tag(the_tag: TagType) -> Option<&'static str> {
         Ts::type_name_from_tag(the_tag)
     }
 
     pub fn type_name(self) -> Option<&'static str> {
-        // Zig: @tagName(this.tag()) — on a non-exhaustive enum this is defined
-        // for known fields. We return None for unknown tags to match the
-        // optional return type the Zig caller sees.
+        // Returns `None` for unknown tags.
         Ts::type_name_from_tag(self.repr.data())
     }
 
@@ -229,18 +214,17 @@ impl<Ts: TypeList> TaggedPtrUnion<Ts> {
 
     #[inline]
     pub fn tag(self) -> TagType {
-        // Zig returns the reified enum; we return the raw integer.
         self.repr.data()
     }
 
-    /// Zig `case(comptime Type) Tag` → the tag constant for `Type`.
+    /// The tag constant for `Type`.
     #[inline]
     pub const fn case<Type: UnionMember<Ts>>() -> TagType {
         Type::TAG
     }
 
     /// unsafely cast a tagged pointer to a specific type, without checking that it's really that type
-    // PORT NOTE: Zig name is `as`, which is a Rust keyword.
+    // `as` is a Rust keyword, hence `as_unchecked`.
     #[inline]
     pub fn as_unchecked<Type: UnionMember<Ts>>(self) -> *mut Type {
         self.repr.get::<Type>()
@@ -299,8 +283,6 @@ impl<Ts: TypeList> TaggedPtrUnion<Ts> {
 
     #[inline]
     pub fn init<Type: UnionMember<Ts>>(ptr: *const Type) -> Self {
-        // Zig splits `init` (infers Type via std.meta.Child) and `initWithType`.
-        // In Rust the generic param IS the inferred child type, so both collapse.
         Self::init_with_type::<Type>(ptr)
     }
 
@@ -317,13 +299,4 @@ impl<Ts: TypeList> TaggedPtrUnion<Ts> {
     pub fn is_null(self) -> bool {
         self.repr.ptr_bits() == 0
     }
-
-    // TODO(port): `call(comptime fn_name, args, comptime Ret)` dispatches by
-    // tag and invokes `@field(entry.ty, fn_name)` reflectively. Rust cannot
-    // look up a method by string at compile time. Port pattern: define a trait
-    // with the target method, bound every `Ti: TheTrait`, and have callers
-    // `match self.tag()` (or use a per-instantiation `dispatch!` macro). Each
-    // callsite of `.call(...)` needs to be rewritten by hand.
 }
-
-// ported from: src/ptr/tagged_pointer.zig
diff --git a/src/ptr/weak_ptr.rs b/src/ptr/weak_ptr.rs
index 3f72fb04b91..83fe77db46d 100644
--- a/src/ptr/weak_ptr.rs
+++ b/src/ptr/weak_ptr.rs
@@ -1,7 +1,6 @@
 use core::ptr::NonNull;
 
-/// Zig: `packed struct(u32) { reference_count: u31, finalized: bool }`
-/// First field occupies the low bits, so:
+/// Bit layout:
 ///   bits 0..=30 → reference_count
 ///   bit  31     → finalized
 #[repr(transparent)]
@@ -55,10 +54,8 @@ impl Default for WeakPtrData {
 /// Implemented by types that embed a `WeakPtrData` field and can be weakly
 /// referenced via `WeakPtr<T>`.
 ///
-/// Zig expressed this as `WeakPtr(comptime T: type, data_field: []const u8)`
-/// and used `@field(value, data_field)` to reach the embedded data. Rust has
-/// no comptime field-name reflection, so the field projection becomes a trait
-/// method (typically implemented via `core::mem::offset_of!`).
+/// The field projection is a trait method (typically implemented via
+/// `core::mem::offset_of!`).
 pub trait HasWeakPtrData {
     /// Return a pointer to the embedded `WeakPtrData` field on `this`.
     ///
@@ -75,10 +72,9 @@ pub trait HasWeakPtrData {
 /// `WeakPtr`s are released. Even if the allocation is present, `WeakPtr<T>::get`
 /// will return `None` after the inner contents are freed.
 pub struct WeakPtr<T: HasWeakPtrData> {
-    // PORT NOTE: LIFETIMES.tsv classifies this field as SHARED → `Weak<T>`,
-    // but this file *is* the definition of the intrusive weak pointer; per
-    // PORTING.md §Pointers ("keep as `*mut T` + manual ref/deref over an
-    // embedded `WeakPtrData`"), the field stays a raw pointer.
+    // Intentionally a raw pointer, not `std::sync::Weak<T>`: this file *is*
+    // the definition of the intrusive weak pointer, with liveness tracked by
+    // the embedded `WeakPtrData` and manual ref/deref.
     raw_ptr: Option<NonNull<T>>,
 }
 
@@ -129,8 +125,7 @@ impl<T: HasWeakPtrData> WeakPtr<T> {
         let count = weak_data.reference_count() - 1;
         weak_data.set_reference_count(count);
         if weak_data.finalized() && count == 0 {
-            // Zig: `bun.destroy(value)` — the allocation came from
-            // `bun.new(T, ...)` (i.e. `Box::new` + `heap::alloc`).
+            // The allocation came from `heap::alloc` (via `Box::new`).
             // SAFETY: this is the last reference and the owner has finalized,
             // so we hold the only pointer to a `Box`-allocated `T`.
             drop(unsafe { bun_core::heap::take(value.as_ptr()) });
@@ -143,5 +138,3 @@ impl<T: HasWeakPtrData> Default for WeakPtr<T> {
         Self::EMPTY
     }
 }
-
-// ported from: src/ptr/weak_ptr.zig
diff --git a/src/resolve_builtins/Cargo.toml b/src/resolve_builtins/Cargo.toml
index e5a297cefa5..576fa2a8127 100644
--- a/src/resolve_builtins/Cargo.toml
+++ b/src/resolve_builtins/Cargo.toml
@@ -22,5 +22,6 @@ bitflags.workspace = true
 # TODO(b1): bun_bundler dep removed — crate does not compile yet; re-add when options::Target lands.
 # bun_bundler.workspace = true
 bun_options_types.workspace = true
+bun_collections.workspace = true
 bun_ast.workspace = true
 bun_core.workspace = true
diff --git a/src/resolve_builtins/HardcodedModule.rs b/src/resolve_builtins/HardcodedModule.rs
index 71e6d151a37..559f352f2a2 100644
--- a/src/resolve_builtins/HardcodedModule.rs
+++ b/src/resolve_builtins/HardcodedModule.rs
@@ -3,8 +3,6 @@ use bun_ast::import_record;
 use bun_core::ZStr;
 use bun_core::zstr;
 
-// Zig: `const string = []const u8;` — in Rust we use `&'static [u8]` directly for keys.
-
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, strum::IntoStaticStr)]
 pub enum HardcodedModule {
     #[strum(serialize = "bun")]
@@ -180,8 +178,8 @@ impl HardcodedModule {
     /// The module loader first uses `Aliases` to get a single string during
     /// resolution, then maps that single string to the actual module.
     /// Do not include aliases here; Those go in `Aliases`.
-    // Zig: `pub const map = bun.ComptimeStringMap(...)`. Associated `static` is
-    // unstable (E0658); `phf::Map` is const-constructible so use an associated const.
+    // Associated `static` is unstable (E0658); `phf::Map` is
+    // const-constructible so use an associated const.
     pub const MAP: phf::Map<&'static [u8], HardcodedModule> = phf::phf_map! {
         // Bun
         b"bun" => HardcodedModule::Bun,
@@ -275,10 +273,10 @@ impl HardcodedModule {
 /// Contains the list of built-in modules from the perspective of the module
 /// loader. This logic is duplicated for `isBuiltinModule` and the like.
 // Note: `ZStr` is a bare DST without `PartialEq`/`Debug`, so `Alias` can't
-// auto-derive them. The Zig struct doesn't define equality either.
+// auto-derive them.
 #[derive(Copy, Clone)]
 pub struct Alias {
-    // Zig: `[:0]const u8` → `&'static ZStr` per PORTING.md type map
+    // `&'static ZStr` per PORTING.md type map
     // (length-carrying NUL-terminated; module specifiers are bytes, not &str).
     pub path: &'static ZStr,
     pub tag: import_record::Tag,
@@ -298,7 +296,6 @@ impl Default for Alias {
 }
 
 /// Prepend `"node:"` to a literal at compile time iff it isn't already prefixed.
-/// Mirrors Zig: `if (path.len > 5 and std.mem.eql(u8, path[0..5], "node:")) path else "node:" ++ path`.
 macro_rules! ensure_node_prefix {
     ($path:literal) => {{
         const HAS_PREFIX: bool = {
@@ -363,14 +360,10 @@ macro_rules! entry {
     };
 }
 
-// Zig builds three `ComptimeStringMap`s by concatenating these const arrays
-// (`common ++ bun_extra ++ bun_test_extra`). `phf::phf_map!` only accepts
-// inline literal entries, so it cannot consume const slices directly.
-//
-// TODO(perf): generate `NODE_ALIASES` / `BUN_ALIASES` /
-// `BUN_TEST_ALIASES` as `phf::Map<&'static [u8], Alias>` via `phf_codegen` in
-// `build.rs`, fed from these const slices. The `get()` lookups below are the
-// only public surface, so swapping the backing store is mechanical.
+// `phf::phf_map!` only accepts inline literal entries, so it cannot consume
+// const slices directly; instead the const tables stay the source of truth
+// (callers like `ModuleLoader` iterate them) and `lookup` goes through
+// lazily-built hash maps.
 
 type AliasKv = (&'static [u8], Alias);
 
@@ -776,9 +769,9 @@ const BUN_TEST_EXTRA_ALIAS_KVS: &[AliasKv] = &[
     ),
 ];
 
-// TODO(port): replace with `phf::Map<&'static [u8], Alias>` generated by
-// `phf_codegen` in build.rs (Zig: `bun.ComptimeStringMap(Alias, common_alias_kvs)`).
-// PERF(port): linear scan placeholder — Zig used a comptime perfect-hash map.
+// A lazily-built `HashMap` per alias table (see `lookup`); the const
+// slice-of-tables form is kept public because `ModuleLoader` iterates the raw
+// entries.
 const NODE_ALIASES: &[&[AliasKv]] = &[COMMON_ALIAS_KVS];
 pub const BUN_ALIASES: &[&[AliasKv]] = &[COMMON_ALIAS_KVS, BUN_EXTRA_ALIAS_KVS];
 const BUN_TEST_ALIASES: &[&[AliasKv]] = &[
@@ -787,17 +780,31 @@ const BUN_TEST_ALIASES: &[&[AliasKv]] = &[
     BUN_TEST_EXTRA_ALIAS_KVS,
 ];
 
-#[inline]
-fn lookup(tables: &[&[AliasKv]], name: &[u8]) -> Option<Alias> {
-    // PERF(port): O(n) scan; could replace with a phf perfect-hash lookup.
+fn build_alias_map(tables: &[&[AliasKv]]) -> bun_collections::HashMap<&'static [u8], Alias> {
+    let mut map = bun_collections::HashMap::with_capacity(tables.iter().map(|t| t.len()).sum());
     for table in tables {
         for (k, v) in *table {
-            if *k == name {
-                return Some(*v);
-            }
+            // First table wins, matching the previous in-order scan
+            // (keys are unique across tables anyway).
+            map.entry(*k).or_insert_with(|| *v);
         }
     }
-    None
+    map
+}
+
+static NODE_ALIAS_MAP: std::sync::LazyLock<bun_collections::HashMap<&'static [u8], Alias>> =
+    std::sync::LazyLock::new(|| build_alias_map(NODE_ALIASES));
+static BUN_ALIAS_MAP: std::sync::LazyLock<bun_collections::HashMap<&'static [u8], Alias>> =
+    std::sync::LazyLock::new(|| build_alias_map(BUN_ALIASES));
+static BUN_TEST_ALIAS_MAP: std::sync::LazyLock<bun_collections::HashMap<&'static [u8], Alias>> =
+    std::sync::LazyLock::new(|| build_alias_map(BUN_TEST_ALIASES));
+
+#[inline]
+fn lookup(
+    map: &std::sync::LazyLock<bun_collections::HashMap<&'static [u8], Alias>>,
+    name: &[u8],
+) -> Option<Alias> {
+    map.get(name).copied()
 }
 
 #[derive(Copy, Clone, Default)]
@@ -813,15 +820,13 @@ impl Alias {
     pub fn get(name: &[u8], target: Target, cfg: Cfg) -> Option<Alias> {
         if target.is_bun() {
             if cfg.rewrite_jest_for_tests {
-                return lookup(BUN_TEST_ALIASES, name);
+                return lookup(&BUN_TEST_ALIAS_MAP, name);
             } else {
-                return lookup(BUN_ALIASES, name);
+                return lookup(&BUN_ALIAS_MAP, name);
             }
         } else if target.is_node() {
-            return lookup(NODE_ALIASES, name);
+            return lookup(&NODE_ALIAS_MAP, name);
         }
         None
     }
 }
-
-// ported from: src/resolve_builtins/HardcodedModule.zig
diff --git a/src/resolve_builtins/node_builtins.rs b/src/resolve_builtins/node_builtins.rs
index 2526ad141f6..94b7fd05803 100644
--- a/src/resolve_builtins/node_builtins.rs
+++ b/src/resolve_builtins/node_builtins.rs
@@ -1,9 +1,6 @@
 //! Single-source list of Node.js core module names.
 //!
-//! Zig spec `src/bundler/options.zig:180-364` hand-spells this list THREE
-//! times (Raw, Compat, Map) and derives a fourth (Patterns) via comptime
-//! `++`. The Rust port lost the comptime concat and hand-spelled it FOUR
-//! times. This module is the one declarative source: each name appears
+//! This module is the one declarative source: each name appears
 //! exactly once, tagged with whether it belongs in the Bun-compat subset.
 //!
 //! `NODE_BUILTINS_MAP` (the phf lookup set) is intentionally NOT emitted
@@ -18,21 +15,20 @@
 /// tt-muncher: `compat` names go in all three consts, `node_only` names are
 /// the five Bun-compat exclusions (buffer/fs/path/process/test) and go only
 /// in RAW/PATTERNS. Every current consumer inserts into a hash set, so the
-/// "compat-first, exclusions-last" order vs. Zig's strict-alpha order is not
+/// "compat-first, exclusions-last" order (vs. strict-alpha) is not
 /// observable.
 macro_rules! node_builtins_table {
     (
         compat:    [ $( $c:literal ),* $(,)? ],
         node_only: [ $( $n:literal ),* $(,)? ] $(,)?
     ) => {
-        /// All Node.js core module bare names (Zig `NodeBuiltinPatternsRaw`).
+        /// All Node.js core module bare names.
         pub const NODE_BUILTIN_PATTERNS_RAW: &[&[u8]] = &[
             $( $c.as_bytes(), )*
             $( $n.as_bytes(), )*
         ];
 
-        /// `RAW ++ RAW.map(|m| "node:" ++ m)` — Zig `NodeBuiltinPatterns`,
-        /// which Zig builds via comptime `++`. `concat!` recovers that here.
+        /// RAW plus the same names with a `node:` prefix.
         pub const NODE_BUILTIN_PATTERNS: &[&[u8]] = &[
             $( $c.as_bytes(), )*
             $( $n.as_bytes(), )*
@@ -40,8 +36,7 @@ macro_rules! node_builtins_table {
             $( concat!("node:", $n).as_bytes(), )*
         ];
 
-        /// RAW minus the `node_only` exclusions — Zig
-        /// `BunNodeBuiltinPatternsCompat`.
+        /// RAW minus the `node_only` exclusions.
         pub const BUN_NODE_BUILTIN_PATTERNS_COMPAT: &[&[u8]] = &[
             $( $c.as_bytes(), )*
         ];
@@ -103,8 +98,7 @@ node_builtins_table! {
         "worker_threads",
         "zlib",
     ],
-    // Bun-compat exclusions (commented-out / omitted in Zig's
-    // `BunNodeBuiltinPatternsCompat`): these five stay resolvable under
+    // Bun-compat exclusions: these five stay resolvable under
     // `--target=bun` rather than being marked external.
     node_only: [
         "buffer",
diff --git a/src/resolver/data_url.rs b/src/resolver/data_url.rs
index 583e5352581..4ae1e6f88b3 100644
--- a/src/resolver/data_url.rs
+++ b/src/resolver/data_url.rs
@@ -1,6 +1,5 @@
 use bun_core::strings;
 
-// https://github.com/Vexu/zuri/blob/master/src/zuri.zig#L61-L127
 pub(crate) struct PercentEncoding;
 
 /// possible errors for decode and encode
@@ -14,6 +13,58 @@ pub enum EncodeError {
 
 bun_core::named_error_set!(EncodeError);
 
+impl EncodeError {
+    /// Returns the error name string.
+    pub fn name(self) -> &'static str {
+        self.into()
+    }
+}
+
+/// Error set of [`DataURL::parse`] / [`DataURL::parse_without_check`].
+#[derive(thiserror::Error, strum::IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ParseDataURLError {
+    #[error("InvalidDataURL")]
+    InvalidDataURL,
+}
+
+bun_core::named_error_set!(ParseDataURLError);
+
+impl ParseDataURLError {
+    /// Returns the error name string.
+    pub fn name(self) -> &'static str {
+        self.into()
+    }
+}
+
+/// Error set of [`DataURL::decode_data`]: `EncodeError || error{Base64DecodeError}`.
+#[derive(thiserror::Error, strum::IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DecodeDataError {
+    #[error("InvalidCharacter")]
+    InvalidCharacter,
+    #[error("OutOfMemory")]
+    OutOfMemory,
+    #[error("Base64DecodeError")]
+    Base64DecodeError,
+}
+
+bun_core::named_error_set!(DecodeDataError);
+
+impl DecodeDataError {
+    /// Returns the error name string.
+    pub fn name(self) -> &'static str {
+        self.into()
+    }
+}
+
+impl From<EncodeError> for DecodeDataError {
+    fn from(e: EncodeError) -> Self {
+        match e {
+            EncodeError::InvalidCharacter => Self::InvalidCharacter,
+            EncodeError::OutOfMemory => Self::OutOfMemory,
+        }
+    }
+}
+
 impl PercentEncoding {
     /// returns true if str starts with a valid path character or a percent encoded octet
     pub(crate) fn is_pchar(str: &[u8]) -> bool {
@@ -93,7 +144,7 @@ impl PercentEncoding {
     }
 }
 
-// PORT NOTE: `mime_type`/`data` are slices into the caller-provided `url` string.
+// `mime_type`/`data` are slices into the caller-provided `url` string.
 // Classified as BORROW_PARAM — struct gets a lifetime parameter.
 pub struct DataURL<'a> {
     pub url: bun_core::String,
@@ -103,8 +154,7 @@ pub struct DataURL<'a> {
 }
 
 impl<'a> DataURL<'a> {
-    pub fn parse(url: &'a [u8]) -> Result<Option<DataURL<'a>>, bun_core::Error> {
-        // TODO(port): narrow error set
+    pub fn parse(url: &'a [u8]) -> Result<Option<DataURL<'a>>, ParseDataURLError> {
         if !url.starts_with(b"data:") {
             return Ok(None);
         }
@@ -112,10 +162,9 @@ impl<'a> DataURL<'a> {
         Ok(Some(Self::parse_without_check(url)?))
     }
 
-    pub fn parse_without_check(url: &'a [u8]) -> Result<DataURL<'a>, bun_core::Error> {
-        // TODO(port): narrow error set
-        let comma = strings::index_of_char(url, b',')
-            .ok_or_else(|| bun_core::err!("InvalidDataURL"))? as usize;
+    pub fn parse_without_check(url: &'a [u8]) -> Result<DataURL<'a>, ParseDataURLError> {
+        let comma =
+            strings::index_of_char(url, b',').ok_or(ParseDataURLError::InvalidDataURL)? as usize;
 
         let mut parsed = DataURL {
             url: bun_core::String::empty(),
@@ -137,8 +186,7 @@ impl<'a> DataURL<'a> {
     }
 
     /// Decodes the data from the data URL. Always returns an owned slice.
-    pub fn decode_data(&self) -> Result<Vec<u8>, bun_core::Error> {
-        // TODO(port): narrow error set
+    pub fn decode_data(&self) -> Result<Vec<u8>, DecodeDataError> {
         let percent_decoded_owned: Option<Vec<u8>> = PercentEncoding::decode_unstrict(self.data)?;
         // defer: `percent_decoded_owned` drops at scope exit
         let percent_decoded: &[u8] = percent_decoded_owned.as_deref().unwrap_or(self.data);
@@ -149,7 +197,7 @@ impl<'a> DataURL<'a> {
             // errdefer: `buf` drops automatically on error path
             let result = bun_base64::decode(&mut buf, percent_decoded);
             if !result.is_successful() || result.count != len {
-                return Err(bun_core::err!("Base64DecodeError"));
+                return Err(DecodeDataError::Base64DecodeError);
             }
             return Ok(buf);
         }
@@ -186,13 +234,15 @@ impl<'a> DataURL<'a> {
             return buf;
         }
 
-        // TODO(port): Zig source's `bufPrint` writes `text` raw with `{s}` here, not the
-        // base64-encoded form — ported faithfully; verify upstream intent.
-        let mut base64buf = Vec::with_capacity(total_base64_encode_len);
-        base64buf.extend_from_slice(b"data:");
-        base64buf.extend_from_slice(mime_type);
-        base64buf.extend_from_slice(b";base64,");
-        base64buf.extend_from_slice(text);
+        // When the percent-escape path bails, the payload must be
+        // base64-encoded for real (the buffer is sized for the encoded form).
+        let mut base64buf = vec![0u8; total_base64_encode_len];
+        let prefix_len = b"data:".len() + mime_type.len() + b";base64,".len();
+        base64buf[..b"data:".len()].copy_from_slice(b"data:");
+        base64buf[b"data:".len()..b"data:".len() + mime_type.len()].copy_from_slice(mime_type);
+        base64buf[b"data:".len() + mime_type.len()..prefix_len].copy_from_slice(b";base64,");
+        let encoded_len = bun_base64::encode(&mut base64buf[prefix_len..], text);
+        base64buf.truncate(prefix_len + encoded_len);
         base64buf
     }
 
@@ -259,9 +309,8 @@ impl<'a> DataURL<'a> {
     }
 }
 
-/// Abstraction over `Vec<u8>` and `CountingBuf` for `encode_string_as_percent_escaped_data_url`
-/// (Zig used `buf: anytype` calling `.appendSlice`/`.append`).
-// PERF(port): Zig anytype was infallible OOM-abort via Vec; trait methods are infallible here.
+/// Abstraction over `Vec<u8>` and `CountingBuf` for
+/// `encode_string_as_percent_escaped_data_url`.
 pub(crate) trait DataUrlBuf {
     fn append_slice(&mut self, slice: &[u8]);
     fn append(&mut self, c: u8);
@@ -294,4 +343,53 @@ impl DataUrlBuf for CountingBuf {
     }
 }
 
-// ported from: src/resolver/data_url.zig
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Round-trips a data URL produced by `encode_string_as_shortest_data_url`
+    /// back through `parse` + `decode_data` and asserts the original bytes.
+    fn round_trip(mime_type: &[u8], text: &[u8]) -> DataURL<'static> {
+        let url = DataURL::encode_string_as_shortest_data_url(mime_type, text);
+        let url: &'static [u8] = Vec::leak(url);
+        let parsed = DataURL::parse(url)
+            .expect("emitted data URL must parse")
+            .expect("emitted data URL must start with data:");
+        assert_eq!(parsed.mime_type, mime_type);
+        let decoded = parsed.decode_data().expect("emitted data URL must decode");
+        assert_eq!(decoded, text);
+        parsed
+    }
+
+    #[test]
+    fn shortest_data_url_percent_path() {
+        // Plain ASCII: percent-escaped form is shorter than base64.
+        let url = DataURL::encode_string_as_shortest_data_url(b"text/plain", b"hello");
+        assert_eq!(url, b"data:text/plain,hello");
+        round_trip(b"text/plain", b"hello");
+    }
+
+    #[test]
+    fn shortest_data_url_base64_fallback_invalid_utf8() {
+        // Non-UTF-8 input makes the percent-escape path bail; the fallback
+        // must emit a real base64 payload.
+        let text: &[u8] = &[0xff, 0xfe, 0x00, 0x01, b'a', 0x80];
+        let url = DataURL::encode_string_as_shortest_data_url(b"application/octet-stream", text);
+        assert!(url.starts_with(b"data:application/octet-stream;base64,"));
+        let parsed = round_trip(b"application/octet-stream", text);
+        assert!(parsed.is_base64);
+    }
+
+    #[test]
+    fn shortest_data_url_base64_fallback_when_shorter() {
+        // Every byte needs escaping (3 bytes each) so base64 (4/3 per byte)
+        // wins and the fallback path is taken.
+        let text = vec![b'\n'; 96];
+        let url = DataURL::encode_string_as_shortest_data_url(b"text/plain", &text);
+        assert!(url.starts_with(b"data:text/plain;base64,"));
+        // 96 bytes -> 128 base64 chars, no padding.
+        assert_eq!(url.len(), b"data:text/plain;base64,".len() + 128);
+        let parsed = round_trip(b"text/plain", &text);
+        assert!(parsed.is_base64);
+    }
+}
diff --git a/src/resolver/dir_info.rs b/src/resolver/dir_info.rs
index 2db61822cbf..43737b48eda 100644
--- a/src/resolver/dir_info.rs
+++ b/src/resolver/dir_info.rs
@@ -17,7 +17,7 @@ pub type Index = IndexType;
 // ─────────────────────────────────────────────────────────────────────────────
 // DirInfoRef — arena handle into the DirInfo BSSMap singleton.
 //
-// Resolver code threads `*mut DirInfo` (Zig: `*DirInfo`) pervasively and
+// Resolver code threads `*mut DirInfo` pervasively and
 // open-coded `unsafe { &*dir_info }` at ~50 read sites. The BSSMap backing
 // store is process-lifetime and append-only (slots are never freed; `reset()`
 // runs only at shutdown after all readers are gone), so a `Copy` handle that
@@ -106,11 +106,11 @@ pub struct DirInfo {
     // A pointer to the enclosing dirInfo with a valid "browser" field in
     // package.json. We need this to remap paths after they have been resolved.
     pub enclosing_browser_scope: Index,
-    // PORT NOTE: lifetime — `&'static` borrows below are ARENA-backed (the
+    // lifetime — `&'static` borrows below are ARENA-backed (the
     // resolver-owned PackageJSON/TSConfigJSON caches outlive every DirInfo).
-    // Fields Zig typed `?*const T` (`package_json_for_browser_field`,
-    // `enclosing_tsconfig_json` — dir_info.zig:12-13) are `Option<&'static T>`.
-    // Fields Zig typed `?*T` (mutable) are `Option<NonNull<T>>` so
+    // Read-only fields (`package_json_for_browser_field`,
+    // `enclosing_tsconfig_json`) are `Option<&'static T>`.
+    // Fields with write sites are `Option<NonNull<T>>` so
     // mut-provenance from the allocation site is preserved through to the
     // write/drop sites (a `*const→*mut` cast there would be UB under Stacked
     // Borrows). Read sites use the `.package_json()` / `.tsconfig_json()` /
@@ -122,32 +122,28 @@ pub struct DirInfo {
     /// it's the deepest one in the hierarchy with a "name" field
     /// or, if using `bun run`, the name field is optional
     /// https://github.com/oven-sh/bun/issues/229
-    // PORT NOTE: Zig `?*PackageJSON` (mutable, dir_info.zig:19) but no write
-    // site exists in resolver.zig or any caller — kept `Option<&'static>` for
-    // ergonomics. If a write is ever ported, retype to `Option<NonNull<_>>`.
+    // No write site exists in any caller — kept `Option<&'static>` for
+    // ergonomics. If a write is ever added, retype to `Option<NonNull<_>>`.
     pub enclosing_package_json: Option<&'static PackageJSON>,
 
-    // PORT NOTE: Zig `?*PackageJSON` (mutable, dir_info.zig:21). `NonNull` (not
-    // `&'static`) so `enqueue_dependency_to_resolve` can write
-    // `package_manager_package_id` back through it (resolver.zig:2394) without
-    // a const→mut provenance cast. Read via `.package_json_for_dependencies()`.
+    // `NonNull` (not `&'static`) so `enqueue_dependency_to_resolve` can write
+    // `package_manager_package_id` back through it without a const→mut
+    // provenance cast. Read via `.package_json_for_dependencies()`.
     pub package_json_for_dependencies: Option<NonNull<PackageJSON>>,
 
-    // TODO(port): lifetime — slice into BSS-backed path storage; never individually freed
+    // lifetime — slice into BSS-backed path storage; never individually freed
     pub abs_path: &'static [u8],
     pub entries: Index,
     /// Is there a "package.json" file?
-    // PORT NOTE: Zig `?*PackageJSON` (mutable). `NonNull` (not `&'static`) so
-    // `reset()` can `drop_in_place` without a const→mut provenance cast. Read
-    // via `.package_json()`.
+    // `NonNull` (not `&'static`) so `reset()` can `drop_in_place` without a
+    // const→mut provenance cast. Read via `.package_json()`.
     pub package_json: Option<NonNull<PackageJSON>>,
     /// Is there a "tsconfig.json" file in this directory or a parent directory?
-    // PORT NOTE: Zig `?*TSConfigJSON` (mutable). `NonNull` (not `&'static`) so
-    // `reset()` can `drop_in_place` without a const→mut provenance cast. Read
-    // via `.tsconfig_json()`.
+    // `NonNull` (not `&'static`) so `reset()` can `drop_in_place` without a
+    // const→mut provenance cast. Read via `.tsconfig_json()`.
     pub tsconfig_json: Option<NonNull<TSConfigJSON>>,
     /// If non-empty, this is the real absolute path resolving any symlinks
-    // TODO(port): lifetime — slice into BSS-backed path storage; never individually freed
+    // lifetime — slice into BSS-backed path storage; never individually freed
     pub abs_real_path: &'static [u8],
 
     pub flags: Flags,
@@ -163,7 +159,6 @@ impl Default for DirInfo {
             enclosing_package_json: None,
             package_json_for_dependencies: None,
             abs_path: b"",
-            // PORT NOTE: Zig left this `= undefined`; using a zero-value placeholder.
             entries: Index::default(),
             package_json: None,
             tsconfig_json: None,
@@ -215,7 +210,8 @@ impl DirInfo {
     }
 
     /// Read-only view of `package_json_for_dependencies`. The field stores
-    /// `NonNull` to preserve mut-provenance for the write at resolver.zig:2394;
+    /// `NonNull` to preserve mut-provenance for the write in
+    /// `enqueue_dependency_to_resolve`;
     /// callers that only read go through here.
     #[inline]
     pub fn package_json_for_dependencies(&self) -> Option<&'static PackageJSON> {
@@ -244,7 +240,7 @@ impl DirInfo {
         Fd::INVALID
     }
 
-    /// Port of `getEntries` in `dir_info.zig` (returns `?*DirEntry`). Returns a
+    /// Returns a
     /// raw pointer (not `&'static mut`) because the BSSMap singleton is
     /// shared-mutable and Rust forbids manufacturing aliased `&mut`. Callers
     /// dereference at the use site where exclusivity is locally provable.
@@ -291,7 +287,7 @@ impl DirInfo {
     }
 
     /// Handle to the enclosing browser-scope `DirInfo` slot. Frequently
-    /// resolves back to *this* slot (resolver.zig:4161), which is why a
+    /// resolves back to *this* slot, which is why a
     /// `Copy` arena handle (not `&mut`) is returned — overlapping shared
     /// reads through `DirInfoRef::deref` are sound.
     pub fn get_enclosing_browser_scope(&self) -> Option<DirInfoRef> {
@@ -299,8 +295,7 @@ impl DirInfo {
     }
 }
 
-// PORT NOTE: Zig `BSSMap` is a per-monomorphization singleton (`var instance` inside
-// the comptime-returned struct). Rust `BSSMapInner<DirInfo, ..>` cannot host a
+// `BSSMapInner<DirInfo, ..>` cannot host a
 // per-generic-instantiation static on stable, so the singleton pointer lives here at
 // the use site and `bun_alloc::BSSMapInner::init()` hands back the storage.
 // PORTING.md §Global mutable state: lazy singleton. `AtomicCell` over the
@@ -362,7 +357,7 @@ impl Flags {
         self.set(flag, present);
     }
 }
-/// Body addresses individual flags as `DirInfo::Flag::X` (Zig nesting).
+/// Allows addressing individual flags as `DirInfo::Flag::X`.
 pub use Flags as Flag;
 
 impl DirInfo {
@@ -372,15 +367,14 @@ impl DirInfo {
             // derived from the arena's `&mut Box<PackageJSON>`); this is the sole
             // remaining owner at shutdown. `drop_in_place` releases its owned
             // resources in-place (storage itself is BSS/cache-owned and not freed
-            // here, matching Zig `p.deinit()`).
+            // here).
             unsafe { core::ptr::drop_in_place(p.as_ptr()) };
         }
         if let Some(t) = self.tsconfig_json.take() {
             // SAFETY: `t` carries mut-provenance from `heap::alloc` in the
             // tsconfig merge loop; this is the sole remaining owner at shutdown.
             // `drop_in_place` releases its owned resources in-place (storage
-            // itself is BSS/cache-owned and not freed here, matching Zig
-            // `t.deinit()`).
+            // itself is BSS/cache-owned and not freed here).
             unsafe { core::ptr::drop_in_place(t.as_ptr()) };
         }
     }
@@ -392,9 +386,7 @@ impl DirInfo {
 // 3. Store whether a directory has been queried and whether that query was successful.
 // 4. Allocate onto the https://en.wikipedia.org/wiki/.bss#BSS_in_C instead of the heap, so we can avoid memory leaks
 //
-// PORT NOTE: Zig `BSSMap(DirInfo, COUNT, store_keys=false, est_key_len=128, rm_slash=true)`;
-// Rust splits the comptime branch — `store_keys=false` → `BSSMapInner<V, COUNT, RM_SLASH>`.
-// `est_key_len` is unused on the inner shape. COUNT mirrors `fs::preallocate::counts::DIR_ENTRY`.
+// COUNT mirrors `fs::preallocate::counts::DIR_ENTRY`.
 pub type HashMap = allocators::BSSMapInner<DirInfo, 2048, true>;
 
 /// Resolver-side extension trait adapting `BSSMapInner`'s inherent surface to
@@ -431,14 +423,13 @@ impl HashMapExt for HashMap {
         result: &mut allocators::Result,
         value: DirInfo,
     ) -> core::result::Result<*mut DirInfo, bun_core::Error> {
-        // Spec bun_alloc.zig:615 `put(self: *Self, result: *Result, value) !*ValueType` —
         // `result.index` is written back, so `&mut`. Inherent returns `&mut DirInfo`;
         // erase to `*mut` so callers can stash it past borrowck. NOTE (Stacked Borrows):
         // this erasure does NOT make the pointer survive a sibling `&mut HashMap` Unique
         // retag of the same `BSSMapInner` allocation — `backing_buf` is inline, so a fresh
         // `&mut *dir_cache()` pops every tag derived here. Callers MUST derive all slot
         // pointers from a single bound `&mut HashMap` (see resolver.rs `dir_info_cached_*`).
-        // TODO(port): derive via `addr_of_mut!` from the raw singleton (SharedReadWrite
+        // TODO: derive via `addr_of_mut!` from the raw singleton (SharedReadWrite
         // provenance) so slot pointers survive sibling retags outright.
         self.put(result, value)
             .map(std::ptr::from_mut::<DirInfo>)
@@ -456,11 +447,8 @@ impl HashMapExt for HashMap {
     }
     #[inline]
     fn values_mut(&mut self) -> core::slice::IterMut<'_, DirInfo> {
-        // Spec resolver.zig:602 `for (r.dir_cache.values()) |*di|` — backing_buf slice
-        // only (overflow_list excluded, matching Zig `BSSMapType` which exposes no
-        // overflow iterator). Inherent `values()` already returns `&mut [DirInfo]`.
+        // backing_buf slice only (overflow_list excluded). Inherent `values()`
+        // already returns `&mut [DirInfo]`.
         self.values().iter_mut()
     }
 }
-
-// ported from: src/resolver/dir_info.zig
diff --git a/src/resolver/fs.rs b/src/resolver/fs.rs
index 1c749fa5dae..c72ebe8c1b7 100644
--- a/src/resolver/fs.rs
+++ b/src/resolver/fs.rs
@@ -16,16 +16,16 @@ use bun_ptr::Interned;
 use bun_sys::{self, Fd};
 use bun_threading::Mutex;
 
-// PORT NOTE: scope tag renamed `fs` → `Fs` so it doesn't collide with `fs:` fn
+// scope tag renamed `fs` → `Fs` so it doesn't collide with `fs:` fn
 // params (the `declare_scope!` macro emits a `static` with the tag name, and
 // edition-2024 forbids fn params shadowing statics).
 bun_core::define_scoped_log!(debug, Fs, hidden);
 
 // ── BOM ──────────────────────────────────────────────────────────────────────
-// Port of `bun.strings.BOM` from `src/string/immutable.zig`. The Rust port
+// A `BOM` enum also
 // lives in `bun_core::immutable::unicode_draft` but that module is private
 // (`mod unicode_draft` — no `pub use` of `BOM` yet); the resolver needs it for
-// `read_file_with_handle_and_allocator` so the enum is re-ported here. The
+// `read_file_with_handle_and_allocator` so the enum is duplicated here. The
 // UTF-16→UTF-8 transcode goes through `strings::to_utf8_alloc` (re-exported
 // from `bun_core::strings`, simdutf-backed) — no C++ is reimplemented.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -94,7 +94,7 @@ impl BOM {
             BOM::Utf16Le => {
                 // `trimmed` is `&[u8]` at offset 2 of a `Vec<u8>` allocation; its
                 // alignment is not guaranteed ≥ 2, so reinterpreting it as `&[u16]`
-                // (the Zig `@alignCast` port) is UB in Rust. Route through the
+                // is UB. Route through the
                 // byte-level helper which copies into an aligned `Vec<u16>` first.
                 let trimmed = &bytes[Self::UTF16_LE_BYTES.len()..];
                 let out = strings::to_utf8_alloc_from_le_bytes(trimmed);
@@ -120,7 +120,6 @@ impl BOM {
                 let n = Self::UTF8_BYTES.len();
                 let len = list.len();
                 list.copy_within(n.., 0);
-                // PORT NOTE: Zig returned a subslice without truncating; mirror by slicing.
                 &list[..len - n]
             }
             BOM::Utf16Le => {
@@ -145,8 +144,6 @@ impl BOM {
     }
 }
 
-// pub const FilesystemImplementation = @import("./fs_impl.zig");
-
 pub(crate) mod preallocate {
     pub(crate) mod counts {
         pub(crate) const DIR_ENTRY: usize = 2048;
@@ -154,33 +151,29 @@ pub(crate) mod preallocate {
     }
 }
 
-// PORT NOTE: Zig `BSSStringList(_COUNT, _ITEM_LENGTH)` internally remaps to
-// `<_COUNT * 2, _ITEM_LENGTH + 1>`; the Rust port took the post-transform
-// const params, so apply the arithmetic at the type-alias / declare site.
 pub(crate) type DirnameStoreBacking =
     allocators::BSSStringList<{ preallocate::counts::DIR_ENTRY * 2 }, { 128 + 1 }>;
 pub(crate) type FilenameStoreBacking =
     allocators::BSSStringList<{ preallocate::counts::FILES * 2 }, { 64 + 1 }>;
-// PORT NOTE: Zig `BSSList(_COUNT)` → Rust `BSSList<{_COUNT * 2}>`.
 pub(crate) type EntryStoreBacking = allocators::BSSList<Entry, { preallocate::counts::FILES * 2 }>;
 
-// Per-monomorphization singleton storage — Zig kept `var instance` inside the
-// generic; Rust emits it at the declare site via `bss_*!` macros (returns `*mut`).
+// Per-monomorphization singleton storage, emitted at the declare site via
+// `bss_*!` macros (returns `*mut`).
 bun_alloc::bss_string_list! { pub dirname_store_backing : preallocate::counts::DIR_ENTRY * 2, 128 + 1 }
 bun_alloc::bss_string_list! { pub filename_store_backing : preallocate::counts::FILES * 2, 64 + 1 }
 bun_alloc::bss_list! { pub entry_store_backing : Entry, preallocate::counts::FILES * 2 }
 
-/// Port of `FileSystem.DirnameStore` — ZST handle resolving to the
+/// ZST handle resolving to the
 /// `dirname_store_backing()` singleton on every call.
 pub struct DirnameStore(());
-/// Port of `FileSystem.FilenameStore` — ZST handle.
+/// ZST handle resolving to the `filename_store_backing()` singleton.
 pub struct FilenameStore(());
 
 static DIRNAME_STORE_ZST: DirnameStore = DirnameStore(());
 static FILENAME_STORE_ZST: FilenameStore = FilenameStore(());
 
-// PORT NOTE: `BSSStringList::append`/`append_lower_case`/`print` now take a raw
-// `*mut Self` receiver (matching `BSSList::append` and Zig's `*Self`), so the
+// `BSSStringList::append`/`append_lower_case`/`print` now take a raw
+// `*mut Self` receiver (matching `BSSList::append`), so the
 // inner `self.mutex` is the sole serialization point and no `&mut` is ever
 // materialized before the lock is held. The previous outer `LazyLock<Mutex>`
 // pair existed only to prevent aliased-`&mut`-before-lock UB under the old
@@ -197,7 +190,7 @@ macro_rules! string_store_impl {
             }
             #[inline]
             fn backing() -> *mut $bty {
-                // PORT NOTE: returns the raw `*mut` singleton (Zig `*Self`).
+                // returns the raw `*mut` singleton.
                 // `BSSStringList`'s mutating methods take `*mut Self` and lock
                 // internally, so callers may pass this directly without ever
                 // forming a `&mut`.
@@ -211,7 +204,7 @@ macro_rules! string_store_impl {
                 // mi_malloc), so widening to `'static` is sound.
                 unsafe { <$bty>::append(Self::backing(), &value) }
             }
-            /// Zig: `FileSystem.DirnameStore.print(fmt, args)` — format directly
+            /// Format directly
             /// into the store's tail (no intermediate `String`). See
             /// `BSSStringList::print` (bun_alloc) for the in-place writer.
             pub fn print(
@@ -330,8 +323,8 @@ impl FileSystem {
     }
 }
 
-// PORT NOTE: Zig `FileSystem.deinit()` only called .deinit() on dirname_store/filename_store,
-// which are &'static singletons here — nothing owned to free, so no `impl Drop`.
+// dirname_store/filename_store are &'static singletons —
+// nothing owned to free, so no `impl Drop`.
 
 // ══════════════════════════════════════════════════════════════════════════
 // CANONICAL Entry / DirEntry / EntryLookup family.
@@ -360,7 +353,6 @@ pub trait EntryKindResolver {
     ) -> core::result::Result<EntryCache, bun_core::Error>;
 }
 
-/// Port of `FileSystem.Entry.Kind` in `fs.zig`.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum EntryKind {
@@ -368,7 +360,6 @@ pub enum EntryKind {
     File,
 }
 
-/// Port of `FileSystem.Entry.Cache` in `fs.zig`.
 #[derive(Clone, Copy)]
 pub struct EntryCache {
     pub symlink: Interned,
@@ -388,10 +379,9 @@ impl Default for EntryCache {
     }
 }
 
-/// Port of `FileSystem.Entry` in `fs.zig`.
-// PORT NOTE: `cache` / `need_stat` are lazily populated by `Entry::kind` /
-// `Entry::symlink` while callers hold a shared `&Entry` (Zig used a freely-
-// aliasing-mutable `*Entry`). `EntryCache` is `Copy`, so `Cell` gives us safe
+// `cache` / `need_stat` are lazily populated by `Entry::kind` /
+// `Entry::symlink` while callers hold a shared
+// `&Entry`. `EntryCache` is `Copy`, so `Cell` gives us safe
 // `.get()/.set()` through `&self` — `RealFS.entries_mutex` serializes access
 // across threads (the `unsafe impl Sync for Entry` below opts back in under
 // that external-locking discipline).
@@ -458,34 +448,32 @@ impl Entry {
         self.base_lowercase_.slice()
     }
 
-    /// Zig: `entry.dir` field (fs.zig:333) — interned in DirnameStore.
+    /// Interned in DirnameStore.
     #[inline]
     pub fn dir(&self) -> &'static [u8] {
         self.dir
     }
 
-    /// Zig: `entry.abs_path` field. `Interned` is `Copy`.
+    /// `Interned` is `Copy`.
     #[inline]
     pub fn abs_path(&self) -> Interned {
         self.abs_path
     }
 
-    /// Zig: `entry.abs_path = PathString.init(...)`.
     #[inline]
     pub fn set_abs_path(&mut self, p: Interned) {
         self.abs_path = p;
     }
 
-    /// Port of `Entry.kind` in `fs.zig` — stat-on-first-use.
+    /// Stat-on-first-use.
     ///
     /// # Safety
     /// `fs` must point to a live `EntryKindResolver` (the process-global
     /// `RealFS` singleton in practice) and the caller must hold
     /// `RealFS.entries_mutex` so the `&mut *fs` reborrow is exclusive for the
     /// duration of the call.
-    // PORT NOTE: `Entry` lives in the EntryStore BSSMap singleton; all access is
-    // serialized through `RealFS.entries_mutex`. Zig used `*Entry` (freely
-    // aliasing-mutable) and `*Fs.FileSystem.RealFS` (raw). `fs` is `*mut` so the
+    // `Entry` lives in the EntryStore BSSMap singleton; all access is
+    // serialized through `RealFS.entries_mutex`. `fs` is `*mut` so the
     // call site does not require a second exclusive `&mut RealFS` borrow while a
     // `&mut Entry` (borrowed out of `RealFS.entries`) is live. Mutation of the
     // lazily-populated `need_stat` / `cache` goes through `Cell`. Generic over
@@ -506,7 +494,6 @@ impl Entry {
         self.cache().kind
     }
 
-    /// Port of `Entry.symlink` in `fs.zig`.
     ///
     /// # Safety
     /// `fs` must point to a live `EntryKindResolver` (the process-global
@@ -522,7 +509,7 @@ impl Entry {
             self.need_stat.set(false);
             // This error can happen if the file was deleted between the time the directory
             // was scanned and the time it was read
-            // SAFETY: see `Entry::kind` PORT NOTE.
+            // SAFETY: see the note on `Entry::kind`.
             match unsafe { &mut *fs }.resolve_kind(self.dir, self.base(), self.cache().fd, store_fd)
             {
                 Ok(c) => self.cache.set(c),
@@ -533,10 +520,10 @@ impl Entry {
     }
 }
 
-// PORT NOTE: `BSSList::append` requires `ValueType: Clone` (its overflow path
+// `BSSList::append` requires `ValueType: Clone` (its overflow path
 // retries with a copy). `Mutex`/`StringOrTinyString` aren't `Clone`, but for a
 // freshly-constructed `Entry` (the only thing ever appended) a field-wise copy
-// with a fresh `Mutex` is semantically equivalent to Zig's by-value move.
+// with a fresh `Mutex` is semantically equivalent to a by-value move.
 impl Clone for Entry {
     fn clone(&self) -> Self {
         Self {
@@ -565,9 +552,9 @@ impl Default for Entry {
     }
 }
 
-/// Port of `FileSystem.DirEntry.DifferentCase` in `fs.zig`.
-// PORT NOTE: lifetime-generic, but resolver storage requires `'static` (all
-// three slices borrow DirnameStore/EntryStore-interned data in practice).
+// lifetime-generic, but resolver storage requires `'static`; in practice all
+// three slices borrow process-lifetime interned data (`dir` → DirnameStore,
+// `query` → FilenameStore copy made in `DirEntry::get`, `actual` → EntryStore).
 #[derive(Clone, Copy)]
 pub struct DifferentCase<'a> {
     pub dir: &'a [u8],
@@ -575,8 +562,7 @@ pub struct DifferentCase<'a> {
     pub actual: &'a [u8],
 }
 
-/// Port of `FileSystem.DirEntry.Lookup` in `fs.zig`.
-// PORT NOTE: `entry` is a RAW `*mut Entry` (matching Zig `*Entry`). A safe
+// `entry` is a RAW `*mut Entry`. A safe
 // `&self → &mut Entry` accessor would let two `get()` calls produce coexisting
 // aliased `&mut Entry` (PORTING.md §Forbidden). Callers `unsafe { &mut *entry }`
 // at each write site under `entries_mutex`.
@@ -603,7 +589,7 @@ impl<'a> EntryLookup<'a> {
         unsafe { &*self.entry }
     }
 
-    // PORT NOTE: former `entry_mut() -> &'a mut Entry` accessor removed
+    // former `entry_mut() -> &'a mut Entry` accessor removed
     // (zero callers). `Entry`'s only mutable state (`cache`) is `Cell`-backed,
     // so all mutation goes through `entry().set_cache*()` on a shared borrow;
     // no `&mut Entry` escape hatch is needed. Write sites that bypass the
@@ -611,21 +597,22 @@ impl<'a> EntryLookup<'a> {
     // `entries_mutex` (see struct doc above).
 }
 
-/// Port of `FileSystem.DirEntry` namespace items (`EntryMap`, `EntryStore`, `Err`).
+/// `DirEntry` companion items: the entry map, the global entry store, and the
+/// error pair type.
 pub mod dir_entry {
     use super::{Entry, EntryStoreBacking};
 
-    /// Port of `DirEntry.EntryMap` (`bun.StringHashMap(*Entry)`).
+    /// Lowercased-basename → entry-pointer map backing `DirEntry::data`.
     pub(crate) type EntryMap = bun_collections::StringHashMap<*mut Entry>;
 
-    /// Port of `DirEntry.EntryStore` (`allocators.BSSList<Entry, files>`).
+    /// Process-wide append-only store that owns all `Entry` allocations.
     /// ZST handle resolving to the `entry_store_backing()` singleton.
     pub(crate) struct EntryStore(());
 
     impl EntryStore {
         #[inline]
         pub(crate) fn instance() -> *mut EntryStoreBacking {
-            // PORT NOTE: returns the raw `*mut` singleton (Zig `*Self`). Do NOT
+            // returns the raw `*mut` singleton. Do NOT
             // materialize a `&'static mut` here — concurrent callers would alias.
             super::entry_store_backing()
         }
@@ -638,8 +625,7 @@ pub mod dir_entry {
         /// loop: `Entry` is ~168 bytes and the by-value `append` above forces a
         /// stack temporary + memcpy that Rust does not reliably NRVO across
         /// the call boundary. Reserving the slot first lets the per-field
-        /// writes lower straight into the destination (matching Zig's
-        /// result-location semantics).
+        /// writes lower straight into the destination.
         #[inline(always)]
         pub(crate) fn append_uninit()
         -> core::result::Result<*mut core::mem::MaybeUninit<Entry>, bun_alloc::AllocError> {
@@ -650,7 +636,8 @@ pub mod dir_entry {
         }
     }
 
-    /// Port of `DirEntry.Err`.
+    /// Directory-read failure: the original error plus the error for the
+    /// canonicalized path.
     #[derive(Clone, Copy)]
     pub struct Err {
         pub original_err: bun_core::Error,
@@ -658,8 +645,7 @@ pub mod dir_entry {
     }
 }
 
-/// Trait abstraction for the `comptime Iterator: type, iterator: Iterator` pattern
-/// in `addEntry`/`readdir` (Zig used a duck-typed `iterator.next(*Entry, FD)`).
+/// Per-entry hook invoked by `add_entry`/`readdir`.
 pub trait DirEntryIterator {
     const IS_VOID: bool = false;
     fn next(&self, entry: &mut Entry, fd: Fd);
@@ -678,10 +664,9 @@ impl<T: DirEntryIterator + ?Sized> DirEntryIterator for &T {
     }
 }
 
-/// Port of `FileSystem.DirEntry` in `fs.zig`.
 pub struct DirEntry {
-    // TODO(port): rule deviation — Zig deinit calls allocator.free(d.dir) so guide says Box<[u8]>,
-    // but this is interned in DirnameStore (a &'static BSSList). Keeping &'static.
+    // `dir` is interned in
+    // DirnameStore (a process-lifetime BSSList), so `&'static` is correct.
     pub dir: &'static [u8],
     pub fd: Fd,
     pub generation: Generation,
@@ -701,9 +686,6 @@ impl DirEntry {
         }
     }
 
-    /// Port of `DirEntry.addEntry` in `fs.zig`.
-    // PORT NOTE: Zig signature was `(prev_map, *entry, allocator, comptime Iterator, iterator)`.
-    // The Zig `allocator` param is dropped (everything routes through the global stores).
     // Compatibility wrapper for callers outside the `readdir` hot loop —
     // resolves the `FilenameStore` singleton on demand. Hot-loop callers
     // should hoist `FilenameStoreAppender::new()` once and call
@@ -728,7 +710,7 @@ impl DirEntry {
         use bun_sys::FileKind as DK;
         // `entry.name.slice()` is OS-native (`&[u16]` on Windows); the
         // entry-store / hashmap key in `data` is UTF-8, so use the eagerly-
-        // transcoded `slice_u8()` (mirrors Zig's `.u8` `NewWrappedIterator`).
+        // transcoded `slice_u8()`.
         let name_slice = entry.name.slice_u8();
         let found_kind: Option<EntryKind> = match entry.kind {
             DK::Directory => Some(EntryKind::Dir),
@@ -777,8 +759,7 @@ impl DirEntry {
 
         let stored: *mut Entry = 'brk: {
             if let Some(map) = prev_map {
-                // `data` keys are the lowercased basenames (Zig's `getAdapted`
-                // lowercases for both hash and eql), so an exact match on
+                // `data` keys are the lowercased basenames, so an exact match on
                 // `name_lc` is the case-insensitive match — and reuses
                 // `name_hash` instead of re-hashing.
                 if let Some(&existing_ptr) = map.get_hashed(name_hash, name_lc) {
@@ -809,7 +790,7 @@ impl DirEntry {
             }
 
             // Reserve the destination slot first so each field write below
-            // lowers straight into the store (Zig result-location semantics) —
+            // lowers straight into the store —
             // avoids a ~168-byte `Entry` stack temporary + memcpy per entry.
             let slot = dir_entry::EntryStore::append_uninit()?;
             // SAFETY: `slot` is a freshly-reserved uninit cell exclusively
@@ -865,14 +846,13 @@ impl DirEntry {
         // SAFETY: just produced from EntryStore append or prev_map lookup
         let stored_ref = unsafe { &mut *stored };
 
-        // PERF(port): Zig's `StringHashMap.put` borrows the key slice; the
-        // generic `put` here would heap-box a second copy. `base_lowercase`
+        // PERF: the
+        // generic `put` here would heap-box a second key copy. `base_lowercase`
         // points either into the `Entry`'s inline `StringOrTinyString` buffer
         // (≤31B names) or into the process-static `FilenameStore`; the `Entry`
         // itself lives in the process-lifetime `EntryStore` BSSList, so in
         // both cases the bytes are address-stable for the life of the process.
-        // Widen to `'static` and store the slice directly — same ownership
-        // model as Zig.
+        // Widen to `'static` and store the slice directly.
         // SAFETY: `stored` is an `EntryStore` slot (never freed, never moved);
         // `base_lowercase_` is never mutated after construction.
         let key: &'static [u8] =
@@ -887,7 +867,7 @@ impl DirEntry {
         }
 
         if FeatureFlags::VERBOSE_FS {
-            // PORT NOTE: re-borrow `base()` after the `iterator.next` mutable borrow ends.
+            // re-borrow `base()` after the `iterator.next` mutable borrow ends.
             let stored_name = stored_ref.base();
             if found_kind == Some(EntryKind::Dir) {
                 bun_core::prettyln!("   + {}/", BStr::new(stored_name));
@@ -899,10 +879,16 @@ impl DirEntry {
         Ok(())
     }
 
-    /// Port of `DirEntry.get` in `fs.zig`.
-    // PORT NOTE: `query_` borrow detached from the returned Entry lifetime so
+    // `query_` borrow detached from the returned Entry lifetime so
     // callers can pass a slice into the same threadlocal buffer they then
-    // mutate; `DifferentCase` widens to 'static (DirnameStore-backed).
+    // mutate; on a case mismatch the query bytes are interned into the
+    // process-lifetime `FilenameStore` so `DifferentCase<'static>` holds a
+    // genuinely `'static` slice. The store does not dedup, so
+    // repeated lookups of the same case-mismatched specifier (e.g. watch-mode
+    // rebuilds with a busted resolution cache) each intern a fresh copy that
+    // is never freed; accepted because the mismatch arm is a warning/error
+    // path and each copy is small. The intern goes through `handle_oom`
+    // (abort).
     pub fn get<'a>(&'a self, query_: &[u8]) -> Option<EntryLookup<'a>> {
         if query_.is_empty() || query_.len() > MAX_PATH_BYTES {
             return None;
@@ -919,10 +905,10 @@ impl DirEntry {
                 entry: result_ptr,
                 diff_case: Some(DifferentCase {
                     dir: self.dir,
-                    // TODO(port): lifetime — Zig stored caller's slice; widened to 'static.
-                    // SAFETY: extended for borrowck reshape; consumed before caller's buffer
-                    // is overwritten (see resolver call sites).
-                    query: unsafe { &*core::ptr::from_ref::<[u8]>(query_) },
+                    // intern a copy of the caller's (possibly
+                    // threadlocal-buffer-backed) slice so the `'static` in
+                    // `DifferentCase<'static>` is real, not discipline-based.
+                    query: bun_core::handle_oom(FilenameStore::instance().append(query_)),
                     // SAFETY: `basename` borrows EntryStore (process-lifetime).
                     actual: unsafe { &*core::ptr::from_ref::<[u8]>(basename) },
                 }),
@@ -937,11 +923,9 @@ impl DirEntry {
         })
     }
 
-    /// Port of `DirEntry.getComptimeQuery` in `fs.zig`.
-    // PORT NOTE: Zig used comptime string lowering + comptime hash; Rust port
-    // takes a &'static [u8] that is already lowercase.
+    /// Looks up a cached entry by name. Takes a `&'static [u8]` that is
+    /// already lowercase, so no per-call lowercasing buffer is needed.
     pub fn get_comptime_query<'a>(&'a self, query_lower: &'static [u8]) -> Option<EntryLookup<'a>> {
-        // PERF(port): was comptime hash precompute — profile if hot
         let &result_ptr = self.data.get(query_lower)?;
         // SAFETY: EntryStore-owned pointer; read-only basename compare.
         let basename = unsafe { &*result_ptr }.base();
@@ -966,22 +950,20 @@ impl DirEntry {
         })
     }
 
-    /// Port of `DirEntry.hasComptimeQuery` in `fs.zig`.
+    /// True if a cached entry exists for the given already-lowercase name.
     pub fn has_comptime_query(&self, query_lower: &'static [u8]) -> bool {
-        // PERF(port): was comptime hash precompute — profile if hot
         self.data.contains_key(query_lower)
     }
 
-    /// Zig: `dir_entry.fd` (fs.zig:121) — cached open directory fd, or
-    /// `bun.invalid_fd` when the resolver did not retain it.
+    /// Cached open directory fd, or
+    /// `Fd::INVALID` when the resolver did not retain it.
     #[inline]
     pub fn fd(&self) -> Fd {
         self.fd
     }
 
-    /// Zig: `dir_entry.data.iterator()` (fs.zig:117). Yields the raw
-    /// `*mut Entry` value for each cached file (Zig's `EntryMap` value
-    /// type is `*Entry`). Yields `*mut Entry`, NOT `&mut Entry`, because
+    /// Yields the raw
+    /// `*mut Entry` value for each cached file — NOT `&mut Entry`, because
     /// the map hands out raw pointers with no exclusivity guarantee;
     /// callers reborrow at the use site under `entries_mutex`.
     #[inline]
@@ -990,8 +972,8 @@ impl DirEntry {
     }
 }
 
-// PORT NOTE: Zig `DirEntry.deinit(allocator)` freed `data` (now drops itself) and `dir`
-// (interned in DirnameStore — see field TODO). Body would be empty, so no `impl Drop`.
+// `data` drops itself and `dir` is interned in DirnameStore (see the comment
+// on `DirEntry::dir`). Body would be empty, so no `impl Drop`.
 
 impl bun_dotenv::DirEntryProbe for DirEntry {
     #[inline]
@@ -1017,8 +999,6 @@ pub use dir_entry::Err as DirEntryErr;
 // RealFS
 // ──────────────────────────────────────────────────────────────────────────
 
-// Zig: `allocators.BSSMap(EntriesOption, dir_entry, false, 256, true)`.
-// `store_keys=false` → Rust `BSSMapInner<V, COUNT, RM_SLASH>` (est_key_len unused on inner shape).
 pub(crate) type EntriesOptionMap =
     allocators::BSSMapInner<EntriesOption, { preallocate::counts::DIR_ENTRY }, true>;
 
@@ -1103,7 +1083,7 @@ impl EntriesGuard {
 pub struct RealFS {
     pub entries_mutex: Mutex,
     pub entries: EntriesMap,
-    pub cwd: &'static [u8], // TODO(port): lifetime — interned
+    pub cwd: &'static [u8], // interned (process-lifetime)
     pub file_limit: usize,
     pub file_quota: usize,
 }
@@ -1208,8 +1188,6 @@ impl RealFS {
     pub fn open_tmp_dir(&self) -> Result<bun_sys::Dir, bun_core::Error> {
         #[cfg(windows)]
         {
-            // fs.zig:601-608 — `openDirAtWindowsA(invalid_fd, tmpdirPath(),
-            // .{ .iterable = true, .can_rename_or_delete = false, .read_only = true })`.
             // The generic `open_dir_absolute` path goes through `open_a(.., O::DIRECTORY, 0)`
             // and on Windows `O::DIRECTORY == 0`, so the directory dispatch in
             // `openat_windows_impl` is never taken and the handle lacks
@@ -1250,7 +1228,7 @@ impl RealFS {
         index: allocators::IndexType,
         generation: Generation,
     ) -> Option<*mut EntriesOption> {
-        // PORT NOTE: Zig fs.zig:613 does not lock here; in Rust we must, because every
+        // Locking is required here: every
         // `EntriesMap` method auto-refs the global `BSSMapInner` to `&mut self`, and a
         // concurrent `read_directory_with_iterator` (which *does* lock) would otherwise
         // alias that `&mut` — UB under Stacked Borrows. `EntriesGuard` holds
@@ -1259,24 +1237,23 @@ impl RealFS {
         // (`readdir`, `read_directory_error`) remain unconstrained while held.
         let map = self.entries_locked();
 
-        // PORT NOTE: `at_index` returns a raw `*mut EntriesOption` (matching Zig's
-        // `*EntriesOption`). Form short-lived `&mut` only at each use site below;
+        // `at_index` returns a raw `*mut EntriesOption`.
+        // Form short-lived `&mut` only at each use site below;
         // never hand a `&'static mut` back to the caller.
         let existing_ptr = map.at_index(index)?;
         // SAFETY: `entries_mutex` held; no other `&mut` to this slot in scope.
         if let EntriesOption::Entries(entries) = unsafe { &mut *existing_ptr } {
             if entries.generation < generation {
                 let dir_path = entries.dir;
-                // PORT NOTE: capture raw ptrs to the in-place `DirEntry` fields, then
+                // capture raw ptrs to the in-place `DirEntry` fields, then
                 // drop the short-lived `&mut` before re-borrowing `self` for
-                // `readdir` / `read_directory_error` (Zig used `*DirEntry` directly).
+                // `readdir` / `read_directory_error`.
                 let entries_ptr: *mut DirEntry = &raw mut **entries;
                 // SAFETY: derive `prev_map_ptr` FROM `entries_ptr` so both raw ptrs
                 // share one provenance root. Writing `&mut entries.data` here would
                 // call `Box::deref_mut` a second time, which under Stacked Borrows
                 // retags the whole `DirEntry` and invalidates `entries_ptr` — making
-                // the later `*entries_ptr = new_entry` UB. Zig's `existing.entries.*`
-                // / `existing.entries.data` go through one `*DirEntry`; mirror that.
+                // the later `*entries_ptr = new_entry` UB.
                 let prev_map_ptr: *mut dir_entry::EntryMap =
                     unsafe { core::ptr::addr_of_mut!((*entries_ptr).data) };
                 let handle_dir = match bun_sys::Dir::open(dir_path) {
@@ -1365,7 +1342,7 @@ impl RealFS {
 
     /// Returns `true` if an entry was removed
     pub fn bust_entries_cache(&mut self, file_path: &[u8]) -> bool {
-        // PORT NOTE: Zig fs.zig:778 does not lock here; in Rust we must, because
+        // Locking is required here:
         // `EntriesMap::remove` auto-refs the global `BSSMapInner` to `&mut self`, and a
         // concurrent `read_directory_with_iterator` (which *does* lock) would otherwise
         // alias that `&mut` — UB. `&mut self` alone proves nothing cross-thread since
@@ -1438,38 +1415,36 @@ impl RealFS {
 
 #[derive(Default, Clone, Copy)]
 pub struct ModKey {
-    pub inode: u64, // TODO(port): std.fs.File.INode equivalent
+    pub inode: u64, // u64 covers libc stat `ino_t`
     pub size: u64,
     pub mtime: i128,
-    pub mode: u32, // TODO(port): std.fs.File.Mode equivalent
-}
-
-thread_local! {
-    static HASH_NAME_BUF: RefCell<[u8; 1024]> = const { RefCell::new([0u8; 1024]) };
+    pub mode: u32, // u32 covers libc stat `mode_t`
 }
 
 impl ModKey {
-    pub fn hash_name(&self, basename: &[u8]) -> Result<&'static [u8], bun_core::Error> {
-        // TODO(port): returns slice into threadlocal buffer; lifetime is unsound — should take a caller-supplied buffer
+    /// Writes `basename` + `-` + the hex hash into `out` and returns the
+    /// written prefix.
+    pub fn hash_name<'out>(
+        &self,
+        basename: &[u8],
+        out: &'out mut [u8],
+    ) -> Result<&'out [u8], bun_core::Error> {
         let hex_int = self.hash();
 
-        HASH_NAME_BUF.with_borrow_mut(|buf| {
-            let len = buf.len();
-            let mut cursor = &mut buf[..];
-            // Zig `{s}` writes `[]const u8` verbatim — `BStr`'s `Display` would
-            // lossily emit U+FFFD for non-UTF-8 bytes (and 1→3 expand), so use
-            // raw `io::Write` for the basename.
-            cursor
-                .write_all(basename)
-                .map_err(|_| bun_core::err!("NoSpaceLeft"))?;
-            cursor
-                .write_all(b"-")
-                .map_err(|_| bun_core::err!("NoSpaceLeft"))?;
-            write!(&mut cursor, "{:x}", hex_int).map_err(|_| bun_core::err!("NoSpaceLeft"))?;
-            let written = len - cursor.len();
-            // SAFETY: threadlocal buffer outlives caller's use (matches Zig pattern)
-            Ok(unsafe { bun_ptr::detach_lifetime(&buf[..written]) })
-        })
+        let len = out.len();
+        let mut cursor = &mut out[..];
+        // `BStr`'s `Display` would
+        // lossily emit U+FFFD for non-UTF-8 bytes (and 1→3 expand), so write
+        // the basename verbatim via raw `io::Write`.
+        cursor
+            .write_all(basename)
+            .map_err(|_| bun_core::err!("NoSpaceLeft"))?;
+        cursor
+            .write_all(b"-")
+            .map_err(|_| bun_core::err!("NoSpaceLeft"))?;
+        write!(&mut cursor, "{:x}", hex_int).map_err(|_| bun_core::err!("NoSpaceLeft"))?;
+        let written = len - cursor.len();
+        Ok(&out[..written])
     }
 
     pub fn hash(&self) -> u64 {
@@ -1494,8 +1469,8 @@ impl ModKey {
         let stat = file.stat()?;
 
         const NS_PER_S: i128 = 1_000_000_000;
-        // PORT NOTE: `bun_sys::Stat` is `libc::stat`; Zig's `std.fs.File.stat()` returned a
-        // normalized struct with `mtime: i128` ns. Reconstruct from `st_mtime` (sec) +
+        // `bun_sys::Stat` is `libc::stat`; reconstruct `mtime` (i128
+        // ns) from `st_mtime` (sec) +
         // `st_mtime_nsec` (ns). The `libc` crate flattens BSD/Darwin `st_mtimespec` into
         // `st_mtime`/`st_mtime_nsec`, so the access is uniform on all `unix`.
         #[cfg(unix)]
@@ -1512,7 +1487,7 @@ impl ModKey {
         // Don't generate a modification key if the file is too new
         let now = bun_core::time::nano_timestamp();
         let now_seconds = now / NS_PER_S;
-        // PORT NOTE: Zig had `seconds > seconds` (always false) — preserved
+        // NOTE: `seconds > seconds` is always false; kept to preserve existing behavior
         #[allow(clippy::eq_op)]
         if seconds > seconds || (seconds == now_seconds && mtime > now) {
             return Err(bun_core::err!("Unusable"));
@@ -1550,7 +1525,7 @@ pub enum EntriesOption {
 
 // SAFETY: ARENA — `EntriesOption` holds a `Box<DirEntry>` whose `data` map stores
 // `*mut Entry` into the BSSList singleton. All access is serialized through
-// `RealFS.entries_mutex`; Zig used a `threadlocal var instance`. The raw-pointer
+// `RealFS.entries_mutex`. The raw-pointer
 // fields are the only thing blocking auto-Sync (needed for `bss_map_inner!`'s
 // `SyncUnsafeCell` static).
 unsafe impl Sync for EntriesOption {}
@@ -1565,9 +1540,8 @@ unsafe impl Send for Entry {}
 
 impl RealFS {
     pub fn open_dir(&self, unsafe_dir_string: &[u8]) -> Result<bun_sys::Dir, bun_core::Error> {
-        // fs.zig:944-955 — on Windows this must go through
-        // `openDirAtWindowsA(invalid_fd, path, .{ .iterable = true, .no_follow = false,
-        // .read_only = true })` so the resulting handle has FILE_LIST_DIRECTORY +
+        // On Windows this must go through `open_dir_at_windows_a` with
+        // iterable + read_only so the resulting handle has FILE_LIST_DIRECTORY +
         // FILE_DIRECTORY_FILE and can be iterated by `readdir`. The generic
         // `open_a(.., O::DIRECTORY, 0)` path doesn't work here because on Windows
         // `O::DIRECTORY == 0` (sys/lib.rs), so the `(flags & O::DIRECTORY) != 0`
@@ -1607,12 +1581,11 @@ impl RealFS {
         let mut iter = bun_sys::iterate_dir(handle_fd);
         let mut dir = DirEntry::init(dir_, generation);
         let mut prev_map = prev_map;
-        // PERF(port): on a re-read, the previous entry count is the best
+        // PERF: on a re-read, the previous entry count is the best
         // capacity guess we have — reserving it up-front avoids the
         // grow-then-rehash-every-key cascade hashbrown otherwise pays
         // (perf showed `RawTable::reserve_rehash` as the dominant `add_entry`
-        // cost). Zig's `StringHashMap` grows the same way but its hash inlines
-        // into `grow`; we additionally skip the grows when we can.
+        // cost).
         if let Some(prev) = prev_map.as_deref() {
             dir.data.reserve(prev.len());
         }
@@ -1629,8 +1602,7 @@ impl RealFS {
         // back to a small floor for cold reads. Do NOT collect dirents into a
         // `Vec` first — that costs N `push`es + ~log2(N) Vec grows just to learn
         // the count, and forces every `Name` allocation to outlive the loop.
-        // Stream `getdents64` straight into `add_entry` like Zig's
-        // `while (try iter.next()) |*e| dir.addEntry(e)`. Floor at 64 even when
+        // Stream `getdents64` straight into `add_entry`. Floor at 64 even when
         // a `prev_map` exists but is tiny/empty — a directory that just grew
         // would otherwise rebuild `data` from a zero-capacity table.
         dir.data
@@ -1680,7 +1652,7 @@ impl RealFS {
                         original_err: err,
                         canonical_error: err,
                     }));
-                    // PORT NOTE: threadlocal storage outlives caller (matches Zig);
+                    // threadlocal storage outlives caller;
                     // return raw `*mut` — caller forms a short-lived `&mut` at use site.
                     slot.as_mut_ptr()
                 }));
@@ -1701,7 +1673,7 @@ impl RealFS {
                 original_err: err,
                 canonical_error: err,
             }));
-            // PORT NOTE: threadlocal storage outlives caller (matches Zig);
+            // threadlocal storage outlives caller;
             // return raw `*mut` — caller forms a short-lived `&mut` at use site.
             slot.as_mut_ptr()
         }))
@@ -1728,7 +1700,7 @@ impl RealFS {
     /// Caller borrows the returned EntriesOption. When `FeatureFlags::ENABLE_ENTRY_CACHE` is `false`,
     /// it is not safe to store this pointer past the current function call.
     ///
-    /// PORT NOTE: returns a raw `*mut EntriesOption` (matching Zig's `*EntriesOption`), not
+    /// returns a raw `*mut EntriesOption`, not
     /// `&'static mut`. Handing out `&'static mut` from a safe `pub fn` would let two callers
     /// (sequential or across the resolver thread pool) each hold a live `&mut` aliasing the
     /// same BSSMap slot — instant UB under Rust's `&mut` noalias model. Callers form a
@@ -1745,7 +1717,7 @@ impl RealFS {
 
         crate::Resolver::assert_valid_cache_key(dir);
         let mut cache_result: Option<allocators::Result> = None;
-        // PORT NOTE: Zig `defer self.entries_mutex.unlock()`. `EntriesGuard` holds the
+        // `EntriesGuard` holds the
         // mutex by raw pointer (no borrow of `self`), so the `&mut self` calls below
         // (`open_dir`, `readdir`, `read_directory_error`) remain unconstrained while
         // the lock is held.
@@ -1780,7 +1752,7 @@ impl RealFS {
                             original_err: bun_core::err!("ENOENT"),
                             canonical_error: bun_core::err!("ENOENT"),
                         }));
-                        // PORT NOTE: threadlocal storage outlives caller; return raw `*mut`.
+                        // threadlocal storage outlives caller; return raw `*mut`.
                         slot.as_mut_ptr()
                     }));
                 }
@@ -1811,7 +1783,6 @@ impl RealFS {
                 DirnameStore::instance().append(dir_maybe_trail_slash)?
             }
         } else {
-            // PORT NOTE: Zig stored the caller-provided slice directly (no lifetime system).
             // Intern into DirnameStore so the cache entry never dangles — `append` is a
             // bump-pointer copy and dedups against the singleton, so cost is bounded.
             DirnameStore::instance().append(dir)?
@@ -1840,8 +1811,7 @@ impl RealFS {
         let handle_fd = handle.fd();
 
         // `readdir` succeeded. If the resolver caches fds, hand the
-        // freshly-opened one off. (The Zig spec leaked here — its `defer` only
-        // closes when `!store_fd || needToCloseFiles()`, on success or failure.)
+        // freshly-opened one off.
         if !had_handle && store_fd && !self.need_to_close_files() {
             if let Some(d) = _opened.take() {
                 let _ = d.into_raw();
@@ -1853,8 +1823,7 @@ impl RealFS {
                 entries.fd = handle_fd;
             }
 
-            // PORT NOTE: Zig stores `EntriesOption{ .entries: *DirEntry }` (raw pointer), so
-            // `put` is a plain pointer overwrite with no drop glue. In Rust the slot owns a
+            // The slot owns a
             // `Box<DirEntry>`; calling `put` again on an already-populated slot would drop the
             // old Box (use-after-free if `in_place` aliases it) or leak it. Split the two cases:
             //  - in_place Some → write through the existing pointer, return the existing slot.
@@ -1884,7 +1853,7 @@ impl RealFS {
 
         Ok(TEMP_ENTRIES_OPTION.with_borrow_mut(|slot| {
             slot.write(EntriesOption::Entries(Box::new(entries)));
-            // PORT NOTE: threadlocal storage outlives caller; return raw `*mut`.
+            // threadlocal storage outlives caller; return raw `*mut`.
             slot.as_mut_ptr()
         }))
     }
@@ -1899,7 +1868,7 @@ impl RealFS {
         read_file_with_handle_impl::<USE_SHARED_BUFFER, STREAM>(path, size_, file, shared_buffer)
     }
 
-    /// Thin forward — kept for spec-shape fidelity (fs.zig:1160).
+    /// Thin forward to `read_file_with_handle_impl`.
     pub fn read_file_with_handle_and_allocator<
         'p,
         'buf,
@@ -1924,12 +1893,11 @@ impl RealFS {
 // ══════════════════════════════════════════════════════════════════════════
 // CANONICAL: read-file-with-handle (stat → grow → pread-loop → BOM-strip)
 //
-// Spec: src/resolver/fs.zig:1160 `RealFS.readFileWithHandleAndAllocator`.
 // One body, three entry points:
 //   • `read_file_with_handle_impl`  — free fn, const-generic, returns
-//     `PathContentsPair` (the spec shape). No `&mut RealFS` needed: the only
-//     `self` uses in the Zig body are `setMaxFd` (a static) and
-//     `readFileError` (a no-op in release; the Rust port already stubs it).
+//     `PathContentsPair`. No `&mut RealFS` needed: the only
+//     `self` uses are `setMaxFd` (a static) and
+//     `readFileError` (a no-op in release).
 //   • `RealFS::read_file_with_handle_and_allocator` — keeps the existing
 //     fs.rs:2121 signature for spec-shape fidelity; thin forward.
 //   • `read_file_contents` — runtime-bool → const-generic dispatcher for the
@@ -1957,15 +1925,14 @@ pub fn read_file_contents<'buf>(
 }
 
 /// Arena-backed twin of the `USE_SHARED_BUFFER = false` arm of
-/// [`read_file_with_handle_impl`]. Port of the `allocator` forwarding in
-/// `Fs.readFileWithHandleAndAllocator` (fs.zig:1617): the returned bytes live
+/// [`read_file_with_handle_impl`]: the returned bytes live
 /// in `arena` so they are bulk-freed when the per-call `MimallocArena` is
 /// `mi_heap_destroy`'d (`TranspilerJob::run` / `ParseTask`), instead of
 /// round-tripping through the worker thread's *default* mimalloc heap (which
 /// is never destroyed and retains the segment for the process lifetime).
 ///
 /// Returns `(ptr, len)` into `arena`-owned memory; a sentinel NUL is written
-/// at `ptr[len]` (not counted in `len`), matching Zig's `[:0]u8` `dupeZ`.
+/// at `ptr[len]` (not counted in `len`).
 pub fn read_file_contents_in_arena(
     file: &bun_sys::File,
     path: &[u8],
@@ -1980,9 +1947,9 @@ pub fn read_file_contents_in_arena(
     // need to dynamically allocate memory to read it.
     let read_count = file.read_all(&mut initial_buf)?;
     if read_count + 1 < initial_buf.len() {
-        // allocator.dupeZ — own the buffer in `arena`; trailing NUL not in len.
-        // Allocate UNINITIALIZED (no zero-fill), like Zig's `allocator.alloc(u8,
-        // size + 1)`: `copy_from_slice` initializes `[..read_count]` and
+        // Own the buffer in `arena`; trailing NUL not in len.
+        // Allocate UNINITIALIZED (no zero-fill):
+        // `copy_from_slice` initializes `[..read_count]` and
         // `finish_arena_contents` writes the trailing NUL at `[read_count]`.
         let buf = arena_alloc_uninit_bytes(arena, read_count + 1);
         buf[..read_count].copy_from_slice(&initial_buf[..read_count]);
@@ -2000,8 +1967,8 @@ pub fn read_file_contents_in_arena(
     }
 
     // Arena-owned `[u8; cap + 1]` instead of `vec![0u8; size + 1]` — this is
-    // the load-bearing change vs. `read_file_with_handle_impl::<false, _>`. Like
-    // Zig's `allocator.alloc(u8, size + 1)` the buffer is UNINITIALIZED; the
+    // the load-bearing change vs. `read_file_with_handle_impl::<false, _>`.
+    // The buffer is UNINITIALIZED; the
     // `copy_from_slice` + `read_all` below cover `[..total]` and
     // `finish_arena_contents` writes the trailing NUL at `[total]`.
     //
@@ -2024,8 +1991,8 @@ pub fn read_file_contents_in_arena(
     Ok(finish_arena_contents(arena, buf, total))
 }
 
-/// Allocate `len` bytes from `arena` left **uninitialized** (no zero-fill —
-/// matches Zig's `allocator.alloc(u8, len)`), returned as a raw `&mut [u8]`.
+/// Allocate `len` bytes from `arena` left **uninitialized** (no zero-fill),
+/// returned as a raw `&mut [u8]`.
 ///
 /// The caller must write every byte before reading it; the file-content readers
 /// do (`copy_from_slice` of the already-read prefix + `File::read_all` for the
@@ -2087,13 +2054,13 @@ pub fn read_file_with_handle_impl<'p, 'buf, const USE_SHARED_BUFFER: bool, const
     file: &bun_sys::File,
     shared_buffer: &'buf mut MutableString,
 ) -> Result<PathContentsPair<'p, 'buf>, bun_core::Error> {
-    // PORT NOTE: allocator param dropped (global mimalloc)
+    // allocator param dropped (global mimalloc)
     FileSystem::set_max_fd(file.handle().native());
 
-    // PORT NOTE: in the `USE_SHARED_BUFFER` branch, `file_contents` borrows
+    // in the `USE_SHARED_BUFFER` branch, `file_contents` borrows
     // `shared_buffer.list`; tracked as a raw (ptr, len) pair so borrowck doesn't tie the
     // slice to `&mut shared_buffer` across the read/truncate/grow loop. The final slice is
-    // reconstituted with `from_raw_parts` (matches Zig's `[]const u8` return). The
+    // reconstituted with `from_raw_parts`. The
     // non-shared-buffer branch owns its allocation and returns early with `Cow::Owned`.
     // Definite-init: the read `loop` below assigns both before any `break`/read; the
     // `else` (non-shared-buffer) arm always early-returns.
@@ -2185,7 +2152,6 @@ pub fn read_file_with_handle_impl<'p, 'buf, const USE_SHARED_BUFFER: bool, const
         // `&mut shared_buffer.list` reborrow inside the BOM branch.
         if let Some(bom) = BOM::detect(&shared_buffer.list[..file_contents_len]) {
             debug!("Convert {} BOM", bom.tag_name());
-            // PORT NOTE: Zig passed `&shared_buffer.list` and the returned slice aliases it.
             // We pre-set `list.len` to the un-BOM'd payload length so the helper sees the
             // correct logical size (the read loop above truncated to `file_contents_len`).
             shared_buffer.list.truncate(file_contents_len);
@@ -2202,12 +2168,10 @@ pub fn read_file_with_handle_impl<'p, 'buf, const USE_SHARED_BUFFER: bool, const
             let buf: &mut [u8] = &mut initial_buf;
             let read_count = file.read_all(buf)?;
             if read_count + 1 < buf.len() {
-                // allocator.dupeZ — own the buffer; caller frees via PathContentsPair drop.
-                // PORT NOTE: Zig returned an allocator-owned `[:0]u8` and the caller freed it
-                // later; Rust returns `Cow::Owned` so the caller's drop frees it. The trailing
-                // NUL sentinel is not part of `contents` (matches Zig `[:0]`).
-                // Allocate exact (no zero-fill), like Zig's
-                // `allocator.alloc(u8, size + 1)`: `extend_from_slice` + `push`
+                // Own the buffer; the returned `Cow::Owned` frees it on the
+                // caller's drop. The trailing
+                // NUL sentinel is not part of `contents`.
+                // Allocate exact (no zero-fill): `extend_from_slice` + `push`
                 // initialize all `read_count + 1` bytes, then `truncate` drops
                 // the sentinel from the logical length.
                 let mut allocation: Vec<u8> = Vec::with_capacity(read_count + 1);
@@ -2238,8 +2202,8 @@ pub fn read_file_with_handle_impl<'p, 'buf, const USE_SHARED_BUFFER: bool, const
         };
         debug!("stat({}) = {}", file.handle(), size);
 
-        // Allocate UNINITIALIZED (no zero-fill), like Zig's `allocator.alloc(u8,
-        // size + 1)`: `extend_from_slice` writes the prefix, `read_all` writes
+        // Allocate UNINITIALIZED (no zero-fill):
+        // `extend_from_slice` writes the prefix, `read_all` writes
         // the tail, then `set_len` exposes only the initialized `..total`.
         let mut buf: Vec<u8> = Vec::with_capacity(size + 1);
         buf.extend_from_slice(initial_read);
@@ -2279,7 +2243,7 @@ pub fn read_file_with_handle_impl<'p, 'buf, const USE_SHARED_BUFFER: bool, const
         });
     }
 
-    // PORT NOTE: `file_contents_ptr` always equals `shared_buffer.list.as_ptr()` on every
+    // `file_contents_ptr` always equals `shared_buffer.list.as_ptr()` on every
     // shared-buffer path above (read loop and BOM rewrite both anchor at index 0), so we
     // re-derive the final slice safely from `shared_buffer` with the real `'buf` lifetime
     // instead of fabricating `'static` via `from_raw_parts`.
@@ -2430,7 +2394,7 @@ impl RealFS {
                     bun_sys::open_file_absolute_z(absolute_path_c, bun_sys::OpenFlags::READ_ONLY)?
                         .into_raw()
                 } else {
-                    // PORT NOTE: Zig `bun.openFileForPath` (bun.zig:1900-1910) — O_PATH is
+                    // O_PATH is
                     // Linux-only; macOS/BSD use O_RDONLY. Both add O_NOCTTY|O_CLOEXEC.
                     #[cfg(any(target_os = "linux", target_os = "android"))]
                     let flags = bun_sys::O::PATH | bun_sys::O::CLOEXEC | bun_sys::O::NOCTTY;
@@ -2440,8 +2404,8 @@ impl RealFS {
                 };
                 FileSystem::set_max_fd(file.native());
 
-                // PORT NOTE: Zig `defer { if (...) file.close() else cache.fd = file }` runs on
-                // BOTH success and error paths — use scopeguard so close-or-store happens even if
+                // close-or-store must run on
+                // BOTH success and error paths — use scopeguard so it happens even if
                 // stat()/get_fd_path() return early with `?`.
                 let need_to_close_files = self.need_to_close_files();
                 let cache_ptr: *mut EntryCache = &raw mut cache;
@@ -2501,7 +2465,7 @@ pub struct PathContentsPair<'a, 'buf> {
     pub path: Path<'a>,
     /// `Owned` for the heap-allocated branch (caller frees on drop); `Borrowed`
     /// for the shared-buffer branch (points into the caller's `MutableString`,
-    /// tied to `'buf` — see PORT NOTE in `read_file_with_handle_and_allocator`).
+    /// tied to `'buf` — see the note in `read_file_with_handle_and_allocator`).
     pub contents: Cow<'buf, [u8]>,
 }
 
@@ -2518,11 +2482,6 @@ thread_local! {
     static JOIN_BUF: RefCell<[u8; 1024]> = const { RefCell::new([0u8; 1024]) };
 }
 
-// pub fn customRealpath(path: &[u8]) -> Result<Box<[u8]>, bun_core::Error> {
-//     var opened = try std.posix.open(path, if (Environment.isLinux) bun.O.PATH else bun.O.RDONLY, 0);
-//     defer std.posix.close(opened);
-// }
-
 /// Display wrapper for fd-like handles (i32 / *anyopaque / FD).
 pub(crate) struct PrintHandle<T>(pub T);
 
@@ -2535,7 +2494,7 @@ impl core::fmt::Display for PrintHandle<i32> {
         write!(f, "{}", self.0)
     }
 }
-// PORT NOTE: PrintHandle<c_int> overlaps PrintHandle<i32> on every supported target — dropped.
+// PrintHandle<c_int> overlaps PrintHandle<i32> on every supported target — dropped.
 impl core::fmt::Display for PrintHandle<*mut c_void> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "{:p}", self.0)
@@ -2549,5 +2508,3 @@ impl core::fmt::Display for PrintHandle<Fd> {
 
 #[path = "fs/stat_hash.rs"]
 pub mod stat_hash;
-
-// ported from: src/resolver/fs.zig
diff --git a/src/resolver/fs/stat_hash.rs b/src/resolver/fs/stat_hash.rs
index aae3f33e140..6f8e795126d 100644
--- a/src/resolver/fs/stat_hash.rs
+++ b/src/resolver/fs/stat_hash.rs
@@ -1,7 +1,6 @@
-use bun_sys::{S, Stat, Timespec};
-// Zig: `std.hash.XxHash64` (streaming init/update/digest).
 use bun_hash::XxHash64Streaming as XxHash64;
 use bun_http_types::ETag::wtf;
+use bun_sys::{S, Stat, Timespec};
 
 #[derive(Default)]
 pub struct StatHash {
@@ -13,8 +12,8 @@ pub struct StatHash {
     // TODO: add etag support here!
 }
 
-// Zig `std.posix.Stat.mtime()` — Rust `libc::stat` has no method, project the
-// platform-specific fields here (mirrors `bun_sys::PosixStat::stat_mtime`).
+// `libc::stat` has no mtime method, so project the platform-specific fields
+// here (mirrors `bun_sys::PosixStat::stat_mtime`).
 #[inline]
 fn stat_mtime(s: &Stat) -> Timespec {
     // The `libc` crate flattens BSD/Darwin `st_mtimespec` into
@@ -79,5 +78,3 @@ impl StatHash {
         Some(&self.last_modified_buffer[0..usize::from(self.last_modified_buffer_len)])
     }
 }
-
-// ported from: src/resolver/fs/stat_hash.zig
diff --git a/src/resolver/lib.rs b/src/resolver/lib.rs
index d4d9598a3d5..cb2c145c37a 100644
--- a/src/resolver/lib.rs
+++ b/src/resolver/lib.rs
@@ -1,4 +1,3 @@
-// Port of src/resolver/resolver.zig
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types, non_upper_case_globals)]
 #![allow(static_mut_refs, private_interfaces, private_bounds)]
@@ -57,7 +56,7 @@ pub use result::{
 };
 pub use standalone_module_graph::StandaloneModuleGraph;
 
-/// Minimal real subset of `src/resolver/fs.zig` so `bun_resolver::fs::X` paths
+/// Minimal real subset of `fs.rs` so `bun_resolver::fs::X` paths
 /// resolve for downstream crates. The full draft remains in `fs.rs` (gated)
 /// until bun_alloc::BSSStringList / bun_output land.
 pub mod fs {
@@ -70,13 +69,10 @@ pub mod fs {
     // The resolver body interns paths via `dirname_store.append_slice` /
     // `append_parts`. Backed by `bun_alloc::BSSStringList` singletons emitted
     // via `bss_string_list!` (per-monomorphization static + first-call init).
-    //
-    // Zig type params are pre-transformed to match `BSSStringList<COUNT, ITEM_LENGTH>`'s
-    // `COUNT = _COUNT * 2, ITEM_LENGTH = _ITEM_LENGTH + 1` const-generic encoding.
 
-    // PORT NOTE: `BSSStringList(2048, 128)` → `<{2048*2}, {128+1}>`
+    // `BSSStringList(2048, 128)` → `<{2048*2}, {128+1}>`
     bun_alloc::bss_string_list! { pub dirname_store_backing : 4096, 129 }
-    // PORT NOTE: `BSSStringList(4096, 64)` → `<{4096*2}, {64+1}>`
+    // `BSSStringList(4096, 64)` → `<{4096*2}, {64+1}>`
     bun_alloc::bss_string_list! { pub filename_store_backing : 8192, 65 }
 
     /// Port of `FileSystem.DirnameStore` (`BSSStringList<2048,128>`).
@@ -98,8 +94,8 @@ pub mod fs {
                     &self,
                     value: &[u8],
                 ) -> core::result::Result<&'static [u8], bun_core::Error> {
-                    // SAFETY: `$backing()` returns the raw `*mut` process-lifetime singleton
-                    // (Zig `*Self`); `BSSStringList::append` takes `*mut Self` and serializes
+                    // SAFETY: `$backing()` returns the raw `*mut` process-lifetime singleton;
+                    // `BSSStringList::append` takes `*mut Self` and serializes
                     // all mutation through its internal `mutex` (no aliased `&mut` is ever
                     // formed). The returned slice borrows its never-freed backing storage
                     // (heap-owned by a `'static` `BSSStringList` or a leaked mi_malloc), so
@@ -115,8 +111,7 @@ pub mod fs {
                     unsafe { bun_alloc::BSSStringList::append($backing(), &parts) }
                         .map_err(|_| bun_core::err!("OutOfMemory"))
                 }
-                /// Zig: `FileSystem.DirnameStore.print(fmt, args)` — format
-                /// directly into the store's tail; no intermediate `String`.
+                /// Format directly into the store's tail; no intermediate `String`.
                 pub fn print(
                     &self,
                     args: core::fmt::Arguments<'_>,
@@ -138,12 +133,11 @@ pub mod fs {
     string_store_impl!(DirnameStore, DIRNAME_STORE_ZST, dirname_store_backing);
     string_store_impl!(FilenameStore, FILENAME_STORE_ZST, filename_store_backing);
 
-    // Method names matching Zig `BSSStringList.append` / `appendLowerCase`
-    // (allocators.zig) — `OOM!T` mapped per PORTING.md.
     macro_rules! string_store_append_impl {
         ($t:ty, $backing:ident) => {
             impl $t {
-                /// Zig: `<Store>.append(allocator, value)`.
+                /// Interns `value` into the never-freed backing store and
+                /// returns the `'static` copy.
                 #[inline]
                 pub fn append(
                     &self,
@@ -156,7 +150,8 @@ pub mod fs {
                     unsafe { bun_alloc::BSSStringList::append($backing(), &value) }
                         .map_err(|_| bun_alloc::AllocError)
                 }
-                /// Zig: `<Store>.appendLowerCase(allocator, value)`.
+                /// Like `append`, but ASCII-lowercases `value` while copying
+                /// it into the store.
                 #[inline]
                 pub fn append_lower_case(
                     &self,
@@ -174,7 +169,9 @@ pub mod fs {
 
     // ── FileSystem ───────────────────────────────────────────────────────
 
-    /// Port of `FileSystem` in `fs.zig`.
+    /// Process-global filesystem facade for the resolver: holds the cached
+    /// top-level dir, the real-FS backend, and the dirname/filename interning
+    /// stores.
     pub struct FileSystem {
         pub top_level_dir: &'static [u8],
 
@@ -187,30 +184,28 @@ pub mod fs {
         pub filename_store: &'static FilenameStore,
     }
 
-    // Global mutable singleton; Zig used `var instance: FileSystem = undefined`.
+    // Global mutable singleton.
     // `RacyCell` is the alias-safe static cell — `init()` is the only writer,
     // serialized at startup; readers go through `instance()`.
     pub(crate) static INSTANCE: bun_core::RacyCell<core::mem::MaybeUninit<FileSystem>> =
         bun_core::RacyCell::new(core::mem::MaybeUninit::uninit());
     pub static INSTANCE_LOADED: AtomicBool = AtomicBool::new(false);
 
-    /// Port of `FileSystem.max_fd` global in `fs.zig`.
-    // PORT NOTE: Windows uses `HANDLE` (no monotone ordering); tracked POSIX-only.
+    // Windows uses `HANDLE` (no monotone ordering); tracked POSIX-only.
     #[cfg(not(windows))]
     pub(crate) static MAX_FD: core::sync::atomic::AtomicI32 = core::sync::atomic::AtomicI32::new(0);
 
     static TMPNAME_ID_NUMBER: AtomicU32 = AtomicU32::new(0);
 
     impl FileSystem {
-        /// Port of `FileSystem.tmpname` in `fs.zig`:
-        /// `pub fn tmpname(extname: string, buf: []u8, hash: u64) std.fmt.BufPrintError![:0]u8`
+        /// Generates a unique NUL-terminated temp filename into `buf` from
+        /// `extname`, `hash`, a per-process counter, and the current time.
         pub fn tmpname<'b>(
             extname: &[u8],
             buf: &'b mut [u8],
             hash: u64,
         ) -> core::result::Result<&'b mut ZStr, bun_core::Error> {
-            // PORT NOTE: `std.time.nanoTimestamp()` — bun_core has no `time` module yet;
-            // use std directly (matches Zig which also calls std.time).
+            // bun_core has no `time` module yet; use std directly.
             let nanos: u128 = std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .map(|d| d.as_nanos())
@@ -237,7 +232,7 @@ pub mod fs {
 
         #[inline]
         pub fn instance() -> &'static mut FileSystem {
-            // SAFETY: caller guarantees init() was called (matches Zig global singleton).
+            // SAFETY: caller guarantees init() was called, so INSTANCE is initialized.
             unsafe { (*INSTANCE.get()).assume_init_mut() }
         }
 
@@ -261,7 +256,7 @@ pub mod fs {
             unsafe { (*INSTANCE.get()).assume_init_ref() }
         }
 
-        /// Port of `FileSystem.init` (fs.zig:90-108). First call writes the
+        /// First call writes the
         /// global `INSTANCE`; subsequent calls return it untouched. Delegates
         /// `Implementation` construction to `RealFS::init` so the process
         /// RLIMIT_NOFILE is raised and `file_limit`/`file_quota` carry the
@@ -273,14 +268,14 @@ pub mod fs {
             Self::init_with_force::<false>(top_level_dir)
         }
 
-        /// Port of `FileSystem.initWithForce` (fs.zig). When `FORCE`, re-seeds
+        /// When `FORCE`, re-seeds
         /// the singleton even if already loaded — used by the router test
         /// harness which `chdir`s between fixtures and needs a fresh
         /// `top_level_dir`.
         pub fn init_with_force<const FORCE: bool>(
             top_level_dir: Option<&[u8]>,
         ) -> core::result::Result<*mut FileSystem, bun_core::Error> {
-            // SAFETY: matches Zig global singleton init pattern; called from
+            // SAFETY: single-threaded startup; called from
             // `Transpiler::init` before any worker spawn.
             unsafe {
                 if INSTANCE_LOADED.load(Ordering::Acquire) && !FORCE {
@@ -288,12 +283,11 @@ pub mod fs {
                 }
             }
             let cwd: &'static [u8] = match top_level_dir {
-                // PORT NOTE: intern into the process-lifetime `DirnameStore` so
+                // intern into the process-lifetime `DirnameStore` so
                 // callers may pass a borrowed path without leaking it themselves
-                // (Zig had no lifetime; the singleton outlives every caller).
+                // (the singleton outlives every caller).
                 Some(d) => DirnameStore::instance().append_slice(d)?,
                 None => {
-                    // Spec fs.zig:161 — `bun.getcwdAlloc(allocator)`.
                     let mut buf = bun_paths::PathBuffer::default();
                     let n = bun_sys::getcwd(&mut buf[..])?;
                     DirnameStore::instance().append_slice(&buf[..n])?
@@ -304,8 +298,7 @@ pub mod fs {
             // `Path::init_top_level_dir` reach `bun_paths::fs::FileSystem::
             // instance()` (a strict `OnceLock` — panics if unset), and the
             // doc-comment on that `init` names this as the intended seeding
-            // point. Zig had a single `Fs.FileSystem.instance` global so the
-            // split is a porting artifact; this keeps both halves in lockstep.
+            // point. This keeps both halves in lockstep.
             // The call is a no-op on subsequent inits (`OnceLock::set` returns
             // `Err`). `cwd` is passed as raw bytes — POSIX paths are not
             // guaranteed UTF-8, and the lower tier stores/serves bytes.
@@ -328,7 +321,8 @@ pub mod fs {
             }
         }
 
-        /// Port of `FileSystem.setMaxFd` in `fs.zig`.
+        /// Records `_fd` as the highest file descriptor seen so far
+        /// (POSIX-only; no-op on Windows).
         #[inline]
         pub fn set_max_fd(_fd: bun_sys::RawFd) {
             #[cfg(windows)]
@@ -340,89 +334,92 @@ pub mod fs {
                 if !bun_core::feature_flags::STORE_FILE_DESCRIPTORS {
                     return;
                 }
-                // SAFETY: single-threaded mutation in resolver context (matches Zig global `max_fd`).
                 MAX_FD.fetch_max(_fd, Ordering::Relaxed);
             }
         }
 
-        /// Port of `FileSystem.max_fd` global in `fs.zig` — highest fd seen via `set_max_fd`.
+        /// Highest fd seen via `set_max_fd`.
         #[inline]
         #[cfg(not(windows))]
         pub fn max_fd() -> bun_sys::RawFd {
-            // SAFETY: single-threaded read in resolver context (matches Zig global `max_fd`).
             MAX_FD.load(Ordering::Relaxed)
         }
 
-        /// Port of `FileSystem.absBuf` in `fs.zig`.
+        /// Joins `parts` against `top_level_dir` into `buf`, returning the
+        /// absolute path slice.
         pub fn abs_buf<'b>(&self, parts: &[&[u8]], buf: &'b mut [u8]) -> &'b [u8] {
             use bun_paths::resolve_path::{join_abs_string_buf, platform};
             join_abs_string_buf::<platform::Loose>(self.top_level_dir, buf, parts)
         }
 
-        /// Port of `FileSystem.absBufChecked` in `fs.zig` — returns `None` on overflow.
+        /// Returns `None` on overflow.
         pub fn abs_buf_checked<'b>(&self, parts: &[&[u8]], buf: &'b mut [u8]) -> Option<&'b [u8]> {
             use bun_paths::resolve_path::{join_abs_string_buf_checked, platform};
             join_abs_string_buf_checked::<platform::Loose>(self.top_level_dir, buf, parts)
         }
 
-        /// Port of `FileSystem.absBufZ` in `fs.zig` — like `abs_buf` but writes a
+        /// Like `abs_buf` but writes a
         /// NUL sentinel and returns a `ZStr` borrowing `buf`.
         pub fn abs_buf_z<'b>(&self, parts: &[&[u8]], buf: &'b mut [u8]) -> &'b ZStr {
             use bun_paths::resolve_path::{join_abs_string_buf_z, platform};
             join_abs_string_buf_z::<platform::Loose>(self.top_level_dir, buf, parts)
         }
 
-        /// Port of `FileSystem.normalizeBuf` in `fs.zig`.
+        /// Normalizes `str` (separators, `.`/`..` segments) into `buf`.
         pub fn normalize_buf<'b>(&self, buf: &'b mut [u8], str: &[u8]) -> &'b [u8] {
             use bun_paths::resolve_path::{normalize_string_buf, platform};
             normalize_string_buf::<false, platform::Auto, false>(str, buf)
         }
 
-        /// Port of `FileSystem.abs` in `fs.zig` — joins against `top_level_dir`
+        /// Joins against `top_level_dir`
         /// into the resolver-shared threadlocal join buffer.
         pub fn abs(&self, parts: &[&[u8]]) -> &[u8] {
             use bun_paths::resolve_path::{join_abs_string, platform};
             join_abs_string::<platform::Loose>(self.top_level_dir, parts)
         }
 
-        /// Port of `FileSystem.absAlloc` in `fs.zig`.
+        /// Like `abs`, but interns the joined path into `DirnameStore` and
+        /// returns the `'static` copy.
         pub fn abs_alloc(
             &self,
             parts: &[&[u8]],
         ) -> core::result::Result<&'static [u8], bun_alloc::AllocError> {
             use bun_paths::resolve_path::{join_abs_string, platform};
             let joined = join_abs_string::<platform::Loose>(self.top_level_dir, parts);
-            // PORT NOTE: Zig duped via `allocator.dupe`; route through DirnameStore so
+            // Route through DirnameStore so
             // the resolver's `&'static [u8]` storage contract holds.
             DirnameStore::instance()
                 .append_slice(joined)
                 .map_err(|_| bun_alloc::AllocError)
         }
 
-        /// Port of `FileSystem.relative` in `fs.zig` — `bun.path.relative(from, to)`.
+        /// Relative path from `from` to `to`. Returns a slice into the
+        /// resolver-shared threadlocal relative buffer; caller must dup
+        /// before the next call.
         pub fn relative(&self, from: &[u8], to: &[u8]) -> &'static [u8] {
             bun_paths::resolve_path::relative(from, to)
         }
 
-        /// Port of `FileSystem.relativeTo` in `fs.zig` — relative path from
+        /// Relative path from
         /// `top_level_dir` to `to`. Returns a slice into the resolver-shared
         /// threadlocal relative buffer; caller must dup before the next call.
         pub fn relative_to(&self, to: &[u8]) -> &'static [u8] {
             bun_paths::resolve_path::relative(self.top_level_dir, to)
         }
 
-        /// Port of `FileSystem.relativeFrom` in `fs.zig`.
+        /// Relative path from `from` to `top_level_dir`; same threadlocal
+        /// buffer caveat as `relative`.
         pub fn relative_from(&self, from: &[u8]) -> &'static [u8] {
             bun_paths::resolve_path::relative(from, self.top_level_dir)
         }
 
-        /// Zig: `f.top_level_dir` — cached cwd captured at `FileSystem::init`.
+        /// Cached cwd captured at `FileSystem::init`.
         #[inline]
         pub fn top_level_dir(&self) -> &'static [u8] {
             self.top_level_dir
         }
 
-        /// Zig: `f.top_level_dir = slice` (PackageManager.zig:776). `dir` must be
+        /// `dir` must be
         /// `'static` (interned in `DirnameStore` or a process-lifetime buffer
         /// like `cwd_buf`). Takes `&mut self` — callers hold `&'static mut
         /// FileSystem` from `instance()`; only called during single-threaded
@@ -433,7 +430,8 @@ pub mod fs {
             bun_core::set_top_level_dir(dir);
         }
 
-        /// Zig: `topLevelDirWithoutTrailingSlash` (fs.zig).
+        /// `top_level_dir` with any trailing separator stripped (root `/` is
+        /// left intact).
         pub fn top_level_dir_without_trailing_slash(&self) -> &'static [u8] {
             let d = self.top_level_dir;
             if d.len() > 1 && d.last() == Some(&bun_paths::SEP) {
@@ -443,34 +441,33 @@ pub mod fs {
             }
         }
 
-        /// Zig: `FileSystem.normalize` (fs.zig:415) —
-        /// `path_handler.normalizeString(str, true, .auto)`.
+        /// Normalizes `str` in the shared scratch space, returning the input
+        /// unchanged when already normalized.
         #[inline]
         pub fn normalize<'a>(&self, str: &'a [u8]) -> &'a [u8] {
             use bun_paths::resolve_path::{normalize_string, platform};
             normalize_string::<true, platform::Auto>(str)
         }
 
-        /// Zig: `f.dirname_store` (fs.zig:76).
+        /// The process-global directory-name interning store.
         #[inline]
         pub fn dirname_store(&self) -> &'static DirnameStore {
             self.dirname_store
         }
-        /// Zig: `f.filename_store` (fs.zig:77).
+        /// The process-global file-name interning store.
         #[inline]
         pub fn filename_store(&self) -> &'static FilenameStore {
             self.filename_store
         }
 
-        /// Zig: `FileSystem.RealFS.getDefaultTempDir()` — `BUN_TMPDIR` or the
+        /// `BUN_TMPDIR` or the
         /// platform fallback. Process-static once-computed.
         #[inline]
         pub fn get_default_temp_dir() -> &'static [u8] {
             RealFS::get_default_temp_dir()
         }
 
-        /// Zig: `fs.fs.readDirectory(dir, null, generation, store_fd)`
-        /// (fs.zig:872 `RealFS.readDirectory`). Returns the cached
+        /// Returns the cached
         /// `*EntriesOption` slot owned by the resolver's BSSMap singleton
         /// (process-lifetime).
         #[inline]
@@ -505,7 +502,7 @@ pub mod fs {
         }
     }
 
-    /// Resolver-tier `fs.zig:Path` methods that pull deps `bun_paths` can't
+    /// Resolver-tier `Path` methods that pull deps `bun_paths` can't
     /// reach (`FilenameStore`/`DirnameStore`, `bun_wyhash`, `bun_options_types`,
     /// `bun_string`). Import this trait to call `.loader()` / `.dupe_alloc()` /
     /// `.hash_key()` on a `Path`.
@@ -528,11 +525,11 @@ pub mod fs {
     }
 
     impl<'a> PathResolverExt<'a> for Path<'a> {
-        /// Port of `Path.dupeAlloc` in `fs.zig` — interns `text`/`pretty` into the
+        /// Interns `text`/`pretty` into the
         /// process-static `FilenameStore` so the returned `Path` borrows `'static`
         /// data.
         ///
-        /// Mirrors the Zig short-circuit: if `text` (and, where relevant,
+        /// Short-circuit: if `text` (and, where relevant,
         /// `pretty`) already points into a process-lifetime store
         /// (`FilenameStore` or `DirnameStore`), the slices are already `'static`
         /// and we return the path unchanged instead of appending a duplicate.
@@ -543,7 +540,6 @@ pub mod fs {
             &self,
             alloc: &bun_alloc::MimallocArena,
         ) -> Result<Path<'static>, bun_core::Error> {
-            // Zig: `isSliceInBuffer` against both stores' backing buffers.
             let is_interned = |slice: &[u8]| {
                 FilenameStore::instance().exists(slice) || DirnameStore::instance().exists(slice)
             };
@@ -612,7 +608,7 @@ pub mod fs {
                         p.pretty = &text[offset..][..self.pretty.len()];
                         p
                     } else {
-                        // Disjoint `text`/`pretty`. Zig allocates one combined
+                        // Disjoint `text`/`pretty`. Allocate one combined
                         // `text\0pretty\0` buffer from the per-build arena (NOT the
                         // process-lifetime `FilenameStore`): `pretty` here is a
                         // freshly-relativized display path recomputed every build, so
@@ -640,7 +636,6 @@ pub mod fs {
             }
         }
 
-        /// Port of `Path.dupeAllocFixPretty` in `fs.zig`.
         fn dupe_alloc_fix_pretty(
             &self,
             alloc: &bun_alloc::MimallocArena,
@@ -651,8 +646,7 @@ pub mod fs {
             }
             #[cfg(windows)]
             {
-                // Spec: `if (this.isPrettyPathPosix()) return this.dupeAlloc(allocator);`
-                // — `isPrettyPathPosix` on Windows is `indexOfChar(pretty, '\\') == null`.
+                // If `pretty` contains no backslashes it is already POSIX-style.
                 // Short-circuiting preserves the `pretty.ptr == text.ptr` aliasing
                 // optimisation inside `dupe_alloc` and avoids a fresh FilenameStore alloc.
                 if !self.pretty.iter().any(|&b| b == b'\\') {
@@ -661,7 +655,7 @@ pub mod fs {
                 let mut new = self.clone();
                 new.pretty = b"";
                 let mut new = new.dupe_alloc(alloc)?;
-                // Zig: `allocator.dupe(u8, this.pretty)` — the posix-normalized
+                // The posix-normalized
                 // display path goes into the per-build arena, not the
                 // process-lifetime `FilenameStore` (it is recomputed each build).
                 let pretty: &mut [u8] = alloc.alloc_slice_copy(self.pretty);
@@ -674,13 +668,12 @@ pub mod fs {
             }
         }
 
-        /// Port of `Path.hashKey` in `fs.zig`.
         fn hash_key(&self) -> u64 {
             if self.is_file() {
                 return bun_wyhash::hash(self.text);
             }
 
-            // PERF(port): Zig used incremental `std.hash.Wyhash.update`; bun_wyhash
+            // PERF: bun_wyhash
             // exposes only the stateless `WyhashStateless` (aligned-chunk update +
             // tail final) and one-shot `hash`. Concat to a temp and one-shot.
             let mut buf = Vec::with_capacity(self.namespace.len() + 8 + self.text.len());
@@ -690,8 +683,6 @@ pub mod fs {
             bun_wyhash::hash(&buf)
         }
 
-        /// Port of `Path.hashForKit` in `fs.zig`.
-        ///
         /// This hash is used by the hot-module-reloading client in order to
         /// identify modules. Since that code is JavaScript, the hash must remain in
         /// range [-MAX_SAFE_INTEGER, MAX_SAFE_INTEGER] or else information is lost
@@ -701,7 +692,6 @@ pub mod fs {
             self.hash_key() & ((1u64 << 52) - 1)
         }
 
-        /// Port of `Path.packageName` in `fs.zig`.
         fn package_name(&self) -> Option<&[u8]> {
             let mut name_to_use = self.pretty;
             // SEP_STR ++ "node_modules" ++ SEP_STR
@@ -720,7 +710,6 @@ pub mod fs {
             Some(pkgname)
         }
 
-        /// Port of `Path.loader` in `fs.zig`.
         fn loader(&self, loaders: &bun_ast::LoaderHashTable) -> Option<bun_ast::Loader> {
             use bun_ast::Loader;
             if self.is_data_url() {
@@ -804,8 +793,8 @@ pub mod fs {
     fn temp_entries_option_write(value: EntriesOption) -> &'static mut EntriesOption {
         TEMP_ENTRIES_OPTION.with_borrow_mut(|slot| {
             slot.write(value);
-            // SAFETY: just wrote; threadlocal storage outlives caller (matches Zig
-            // `&temp_entries_option`). Re-erase to 'static for the BSSMap-shaped
+            // SAFETY: just wrote; threadlocal storage outlives the caller.
+            // Re-erase to 'static for the BSSMap-shaped
             // unbounded `&mut EntriesOption` return type — the `RefMut` guard
             // drops immediately on return, so no live `RefCell` borrow aliases
             // the escaped reference.
@@ -814,8 +803,7 @@ pub mod fs {
     }
 
     // ── RealFS.Tmpfile ───────────────────────────────────────────────────
-    /// Port of `FileSystem.RealFS.Tmpfile` (fs.zig). The Zig POSIX impl never
-    /// touched its `*RealFS` arg (it always opens at cwd); the Windows impl
+    /// Temporary-file helper. The POSIX impl opens at cwd; the Windows impl
     /// only needs the temp-dir path, which routes via `tmpdir_path`.
     pub struct RealFsTmpfile {
         pub fd: bun_sys::Fd,
@@ -846,8 +834,7 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Tmpfile.create(*RealFS, name)` — POSIX path opens at cwd
-        /// (the `*RealFS` arg is unused there); Windows opens under the
+        /// POSIX path opens at cwd; Windows opens under the
         /// process temp dir.
         pub fn create(&mut self, name: &ZStr) -> core::result::Result<(), bun_core::Error> {
             #[cfg(not(windows))]
@@ -862,11 +849,10 @@ pub mod fs {
             }
             #[cfg(windows)]
             {
-                // Spec: `const tmp_dir = try rfs.openTmpDir();` — `openTmpDir`
-                // is `openDirAtWindowsA(invalid_fd, tmpdirPath(), .{ iterable,
-                // !can_rename_or_delete, read_only })`. `tmpdirPath()` uses
-                // `BUN_TMPDIR.getNotEmpty()` (so an empty env var falls through
-                // to `platformTempDir`), not `get()`.
+                // Open the temp dir iterable + read-only, with delete/rename
+                // sharing denied. The temp dir path honours BUN_TMPDIR only
+                // when it is non-empty (an empty env var falls through to the
+                // platform temp dir).
                 let tmp = RealFS::tmpdir_path();
                 let tmp_dir = bun_sys::open_dir_at_windows_a(
                     bun_sys::Fd::INVALID,
@@ -891,7 +877,8 @@ pub mod fs {
             }
         }
 
-        /// Zig: `Tmpfile.promoteToCWD(from_name, name)`.
+        /// Renames the temp file from `from_name` to `name` relative to the
+        /// current working directory.
         pub fn promote_to_cwd(
             &mut self,
             from_name: &ZStr,
@@ -953,8 +940,7 @@ pub mod fs {
         }
     }
 
-    /// Port of `FileSystem.RealFS.EntriesOption` in `fs.zig`.
-    // PORT NOTE: Zig stores `*DirEntry` (raw, BSSMap-owned). Modeled as
+    // Modeled as
     // an unbounded `&mut DirEntry` so resolver match arms (`Entries(entries) =>
     // entries.dir`) auto-deref. The backing storage is the BSSMap singleton;
     // `'static` is the ARENA lifetime.
@@ -972,20 +958,19 @@ pub mod fs {
 
     // SAFETY: ARENA — `EntriesOption` holds an unbounded `&mut DirEntry` (whose `data`
     // map stores `*mut Entry` into the BSSMap singleton). All access is serialized
-    // through `RealFS.entries_mutex`; Zig used a `threadlocal var instance`. The
+    // through `RealFS.entries_mutex`. The
     // raw-pointer fields are the only thing blocking auto-Sync.
     unsafe impl Sync for EntriesOption {}
     // SAFETY: the `&'static mut DirEntry` points into the process-lifetime BSSMap
     // singleton; ownership may cross threads under the same `entries_mutex` serialization.
     unsafe impl Send for EntriesOption {}
 
-    /// Port of `FileSystem.RealFS.EntriesOption.Map` in `fs.zig`:
-    /// `allocators.BSSMap(EntriesOption, Preallocate.Counts.dir_entry, false, 256, true)`.
-    /// `store_keys=false` → Rust `BSSMapInner<V, COUNT, RM_SLASH>` (est_key_len unused on inner shape).
+    /// Fixed-capacity (2048-entry) BSS-backed hash map for the directory-entry
+    /// cache. Keys are not stored — only their hashes — so lookups cannot
+    /// recover key bytes (`BSSMapInner` is the keyless inner shape).
     pub(crate) type EntriesOptionMap = bun_alloc::BSSMapInner<EntriesOption, 2048, true>;
 
-    // Per-monomorphization singleton storage for `EntriesOption.Map` — Zig kept
-    // `var instance` inside the generic; Rust emits it here at the declare site.
+    // Per-monomorphization singleton storage for `EntriesOption.Map`.
     bun_alloc::bss_map_inner! { pub entries_option_map : EntriesOption, 2048, true }
 
     /// Resolver-side wrapper over `EntriesOptionMap` exposing the BSSMap surface
@@ -1046,9 +1031,9 @@ pub mod fs {
             result: &mut bun_alloc::Result,
             value: EntriesOption,
         ) -> core::result::Result<*mut EntriesOption, bun_core::Error> {
-            // PORT NOTE: `BSSMapInner::put` mutates `result.index` to record placement; callers
+            // `BSSMapInner::put` mutates `result.index` to record placement; callers
             // (e.g. `dir_info_cached_maybe_log`) re-read `result.index` post-`put`, so the
-            // mutation must be visible — pass through directly (Zig: `*Result`).
+            // mutation must be visible — pass through directly.
             self.inner()
                 .put(result, value)
                 .map(std::ptr::from_mut::<EntriesOption>)
@@ -1062,12 +1047,13 @@ pub mod fs {
         }
     }
 
-    /// Zig: `pub const Implementation = RealFS;`
+    /// The active filesystem backend (always the real filesystem).
     pub type Implementation = RealFS;
 
     // ── RealFS ───────────────────────────────────────────────────────────
 
-    /// Port of `FileSystem.RealFS` in `fs.zig`.
+    /// Real-filesystem backend: directory-entry cache plus fd-limit
+    /// bookkeeping.
     pub struct RealFS {
         pub entries_mutex: Mutex,
         /// Port of `entries: *EntriesOption.Map`. The resolver body addresses
@@ -1080,7 +1066,7 @@ pub mod fs {
     }
 
     impl RealFS {
-        /// Port of `RealFS.init` (fs.zig:823-837) — raise RLIMIT_NOFILE and
+        /// Raise RLIMIT_NOFILE and
         /// record the resulting fd budget so `need_to_close_files` can decide
         /// whether to cache directory fds.
         pub fn init(cwd: &'static [u8]) -> RealFS {
@@ -1131,17 +1117,15 @@ pub mod fs {
             }
         }
 
-        /// Port of `RealFS.openDir` in `fs.zig` — `open(path, O_DIRECTORY)`.
+        /// `open(path, O_DIRECTORY)`.
         pub fn open_dir(
             &self,
             unsafe_dir_string: &[u8],
         ) -> core::result::Result<Fd, bun_core::Error> {
             #[cfg(windows)]
             {
-                // Spec: `bun.sys.openDirAtWindowsA(invalid_fd, path,
-                // .{ iterable, !no_follow, read_only })` — NtCreateFile with
-                // FILE_DIRECTORY_FILE/FILE_LIST_DIRECTORY so the resulting
-                // handle is iterable for `readdir`.
+                // NtCreateFile with FILE_DIRECTORY_FILE/FILE_LIST_DIRECTORY so
+                // the resulting handle is iterable for `readdir`.
                 return bun_sys::open_dir_at_windows_a(
                     bun_sys::Fd::INVALID,
                     unsafe_dir_string,
@@ -1156,14 +1140,13 @@ pub mod fs {
             }
             #[cfg(not(windows))]
             {
-                // PORT NOTE: Zig used `std.fs.openDirAbsolute` on POSIX, which
-                // reduces to `open(path, O_DIRECTORY)`; route through
+                // `open(path, O_DIRECTORY)`; route through
                 // `bun_sys::open_a` for the NUL-termination handling.
                 bun_sys::open_a(unsafe_dir_string, bun_sys::O::DIRECTORY, 0).map_err(Into::into)
             }
         }
 
-        /// Port of `RealFS.readdir` in `fs.zig` — iterate `handle` and populate a
+        /// Iterate `handle` and populate a
         /// fresh `DirEntry` (re-using `prev_map` Entry slots where the name matches).
         fn readdir<I: DirEntryIterator>(
             &mut self,
@@ -1198,7 +1181,7 @@ pub mod fs {
             Ok(dir)
         }
 
-        /// Port of `RealFS.readDirectoryError` in `fs.zig` — cache (or threadlocal-
+        /// Cache (or threadlocal-
         /// stash) an `EntriesOption::Err` for `dir` and hand back its address.
         fn read_directory_error(
             &mut self,
@@ -1236,7 +1219,6 @@ pub mod fs {
             )))
         }
 
-        /// Port of `RealFS.readDirectory` in `fs.zig`.
         pub fn read_directory(
             &mut self,
             dir_: &[u8],
@@ -1255,8 +1237,6 @@ pub mod fs {
         // https://twitter.com/jarredsumner/status/1655787337027309568
         // https://twitter.com/jarredsumner/status/1655714084569120770
         // https://twitter.com/jarredsumner/status/1655464485245845506
-        /// Port of `RealFS.readDirectoryWithIterator` in `fs.zig`.
-        ///
         /// Caller borrows the returned `EntriesOption`. When `FeatureFlags::ENABLE_ENTRY_CACHE`
         /// is `false`, it is not safe to store this pointer past the current function call.
         pub fn read_directory_with_iterator<I: DirEntryIterator>(
@@ -1285,7 +1265,7 @@ pub mod fs {
                 let cr = cache_result.as_ref().unwrap();
                 if cr.has_checked_if_exists() {
                     if let Some(cached_result) = self.entries.at_index(cr.index) {
-                        // PORT NOTE: erase to raw immediately so the early-return reborrow
+                        // erase to raw immediately so the early-return reborrow
                         // doesn't conflict with the `&mut self.entries` borrow above.
                         let cached_ptr = std::ptr::from_mut::<EntriesOption>(cached_result);
                         // SAFETY: BSSMap-owned slot; uniquely held under `entries_mutex`.
@@ -1318,7 +1298,7 @@ pub mod fs {
                 },
             };
 
-            // PORT NOTE: Zig `defer { if (...) handle.close() }` — runs on every exit. Use
+            // Close the handle on every exit path. Use
             // scopeguard so close happens even if `readdir`/`put` early-return with `?`.
             let should_close_handle = !had_handle && (!store_fd || self.need_to_close_files());
             let _close_guard = scopeguard::guard(handle, move |h| {
@@ -1337,8 +1317,7 @@ pub mod fs {
                     DirnameStore::instance().append_slice(dir_maybe_trail_slash)?
                 }
             } else {
-                // PORT NOTE: Zig stored the caller-provided slice directly (no lifetime
-                // system). Intern into DirnameStore so the cache entry never dangles —
+                // Intern into DirnameStore so the cache entry never dangles —
                 // `append_slice` is a bump-pointer copy, cost is bounded.
                 DirnameStore::instance().append_slice(dir)?
             };
@@ -1354,7 +1333,6 @@ pub mod fs {
                 Err(err) => {
                     if let Some(existing) = in_place {
                         // SAFETY: see above.
-                        // PORT NOTE: Zig `clear_and_free`; bun_collections::StringHashMap exposes `clear`.
                         unsafe { (*existing).data.clear() };
                     }
                     return self.read_directory_error(dir, err);
@@ -1362,7 +1340,6 @@ pub mod fs {
             };
 
             if bun_core::FeatureFlags::ENABLE_ENTRY_CACHE {
-                // PORT NOTE: Zig `entries_ptr = in_place orelse allocator.create(DirEntry)`.
                 // `EntriesOption::Entries` here holds an unbounded `&mut DirEntry` (raw, BSSMap-stored
                 // pointer), so a fresh slot is a leaked `Box<DirEntry>` whose lifetime is the
                 // `entries_option_map()` singleton (process-static).
@@ -1372,7 +1349,6 @@ pub mod fs {
                 };
                 if let Some(original) = in_place {
                     // SAFETY: BSSMap-owned; entries_mutex held.
-                    // PORT NOTE: Zig `clear_and_free`; bun_collections::StringHashMap exposes `clear`.
                     unsafe { (*original).data.clear() };
                 }
                 if store_fd && !entries.fd.is_valid() {
@@ -1394,7 +1370,7 @@ pub mod fs {
 
             // ENABLE_ENTRY_CACHE = false: stash in the threadlocal and hand back its
             // address. The leaked Box lives until the next `read_directory` call on
-            // this thread (matches Zig — threadlocal `temp_entries_option`).
+            // this thread.
             let entries_ptr = bun_core::heap::into_raw(Box::new(entries));
             // SAFETY: freshly-leaked Box; re-borrow as 'static for the threadlocal slot.
             Ok(temp_entries_option_write(EntriesOption::Entries(unsafe {
@@ -1402,9 +1378,10 @@ pub mod fs {
             })))
         }
 
-        /// Port of `RealFS.bustEntriesCache` in `fs.zig`.
+        /// Evicts `file_path` from the directory-entry cache; returns whether
+        /// an entry was removed.
         pub fn bust_entries_cache(&mut self, file_path: &[u8]) -> bool {
-            // Zig took no lock here, but `entries` is the process-global
+            // `entries` is the process-global
             // BSSMap singleton and `remove` mutates it; callers (transpiler /
             // hot-reloader / VM) reach this without `RESOLVER_MUTEX`, so take
             // `entries_mutex` to satisfy `EntriesMap::inner`'s aliasing
@@ -1414,7 +1391,7 @@ pub mod fs {
             self.entries.remove(file_path)
         }
 
-        /// Port of `RealFS.kind` in `fs.zig` — lstat + (if symlink) open + fstat +
+        /// lstat + (if symlink) open + fstat +
         /// readlink to populate an `EntryCache`. Windows: `GetFileAttributesW` +
         /// (if reparse point) `CreateFileW`-follow + `GetFinalPathNameByHandle`
         /// realpath.
@@ -1551,7 +1528,7 @@ pub mod fs {
                         )?
                         .into_raw()
                     } else {
-                        // PORT NOTE: Zig `bun.openFileForPath` (bun.zig:1900-1910) — O_PATH is
+                        // O_PATH is
                         // Linux-only; macOS/BSD use O_RDONLY. Both add O_NOCTTY|O_CLOEXEC.
                         #[cfg(any(target_os = "linux", target_os = "android"))]
                         let flags = bun_sys::O::PATH | bun_sys::O::CLOEXEC | bun_sys::O::NOCTTY;
@@ -1561,7 +1538,7 @@ pub mod fs {
                     };
                     FileSystem::set_max_fd(file.native());
 
-                    // PORT NOTE: Zig `defer { if (...) file.close() else cache.fd = file }` runs on
+                    // The close-or-store cleanup runs on
                     // BOTH success and error paths — use scopeguard so close-or-store happens even if
                     // fstat()/get_fd_path() return early with `?`.
                     let need_to_close_files = self.need_to_close_files();
@@ -1611,7 +1588,8 @@ pub mod fs {
     }
 
     impl RealFS {
-        /// Port of `RealFS.needToCloseFiles` in `fs.zig`.
+        /// Whether cached file descriptors should be closed eagerly instead
+        /// of kept open (fd budget exceeded or fd-storing disabled).
         #[inline]
         pub fn need_to_close_files(&self) -> bool {
             if !bun_core::feature_flags::STORE_FILE_DESCRIPTORS {
@@ -1622,9 +1600,8 @@ pub mod fs {
             {
                 // 'false' is okay here because windows gives you a seemingly unlimited number of
                 // open file handles, while posix has a lower limit. Handles are automatically
-                // closed when the process exits. See fs.zig `needToCloseFiles` for the full
-                // rationale (handle ordering on Windows is non-monotone, so MAX_FD tracking
-                // doesn't apply).
+                // closed when the process exits. Handle ordering on Windows is non-monotone, so
+                // MAX_FD tracking doesn't apply.
                 return false;
             }
 
@@ -1636,14 +1613,14 @@ pub mod fs {
             }
         }
 
-        /// Port of `RealFS.entriesAt` in `fs.zig` — index lookup with generation-check
+        /// Index lookup with generation-check
         /// re-read (open + readdir + cache replace) when the cached listing is stale.
         pub fn entries_at(
             &mut self,
             index: bun_alloc::IndexType,
             generation: Generation,
         ) -> Option<&mut EntriesOption> {
-            // PORT NOTE: erase to raw immediately so re-borrowing `&mut self` for
+            // erase to raw immediately so re-borrowing `&mut self` for
             // `open_dir`/`readdir`/`read_directory_error` doesn't conflict.
             // `entries_mutex` held by caller; sole `&mut` to this slot.
             let result_ptr = std::ptr::from_mut::<EntriesOption>(self.entries.at_index(index)?);
@@ -1653,12 +1630,12 @@ pub mod fs {
                     let e_ptr: *mut DirEntry = std::ptr::from_mut::<DirEntry>(*existing);
                     // SAFETY: BSSMap-owned `DirEntry` (boxed/leaked into `EntriesOption`); `entries_mutex` held.
                     let dir = unsafe { (*e_ptr).dir };
-                    // Spec fs.zig:617 — `bun.openDirForIteration(FD.cwd(), dir)`, NOT
+                    // `open_dir_for_iteration`, NOT
                     // `RealFS.openDir`. On Windows the two diverge: `open_dir` passes
                     // `read_only: true` (no DELETE access on the handle), whereas
                     // `openDirForIteration` uses the default `WindowsOpenDirOptions`
                     // (`can_rename_or_delete: true`). On POSIX it's `O_DIRECTORY` only
-                    // vs `O_RDONLY|O_DIRECTORY`. Match the spec's flag set exactly.
+                    // vs `O_RDONLY|O_DIRECTORY`.
                     let handle = match bun_sys::open_dir_for_iteration(Fd::cwd(), dir) {
                         Ok(h) => h,
                         Err(err) => {
@@ -1667,7 +1644,6 @@ pub mod fs {
                             return self.read_directory_error(dir, err.into()).ok();
                         }
                     };
-                    // PORT NOTE: Zig `defer handle.close()` — runs on every exit.
                     let _close_guard = scopeguard::guard(handle, |h| {
                         let _ = bun_sys::close(h);
                     });
@@ -1760,21 +1736,19 @@ pub mod fs {
             }
         }
 
-        /// Port of `RealFS.platformTempDir()` in `fs.zig`.
+        /// Platform temp directory, computed once per process.
         pub fn platform_temp_dir() -> &'static [u8] {
             static ONCE: bun_core::Once<&'static [u8]> = bun_core::Once::new();
             ONCE.call(Self::platform_temp_dir_compute)
         }
 
-        /// Port of `RealFS.tmpdirPath()` in `fs.zig`:
-        /// `pub fn tmpdirPath() []const u8 { return bun.env_var.BUN_TMPDIR.getNotEmpty() orelse platformTempDir(); }`
+        /// Non-empty `BUN_TMPDIR`, falling back to `platform_temp_dir`.
         pub fn tmpdir_path() -> &'static [u8] {
             bun_core::env_var::BUN_TMPDIR
                 .get_not_empty()
                 .unwrap_or_else(Self::platform_temp_dir)
         }
 
-        /// Port of `RealFS.getDefaultTempDir()` in `fs.zig`.
         pub fn get_default_temp_dir() -> &'static [u8] {
             bun_core::env_var::BUN_TMPDIR
                 .get()
@@ -1783,8 +1757,7 @@ pub mod fs {
     }
 
     // ── `file_system` namespace shim ─────────────────────────────────────
-    // The resolver body addresses types via `Fs::file_system::*` (the
-    // Zig nesting was `FileSystem.RealFS.EntriesOption` etc.). Re-export the
+    // The resolver body addresses types via `Fs::file_system::*`. Re-export the
     // flat types under the nested module paths the body expects.
     /// Re-exports from the full `fs.rs` port: `BOM` (detect/strip tables) and
     /// the canonical read-file helpers, so `cache::Fs` (here and in
@@ -1796,7 +1769,7 @@ pub mod fs {
     };
 
     /// Re-export `StatHash` from the full `fs.rs` port so `bun_runtime::server::FileRoute`
-    /// can hash mtimes/sizes without inlining the formatter (Zig: `bun.fs.StatHash`).
+    /// can hash mtimes/sizes without inlining the formatter.
     pub use super::fs_full::stat_hash;
     pub use super::fs_full::stat_hash::StatHash;
 
@@ -1810,14 +1783,13 @@ pub mod fs {
         /// reaching `ModKey` via this re-export hold the inline-`fs` `RealFS`,
         /// which is a different type, so they need an entry point that doesn't
         /// require `fs_full::RealFS`. Body is the spec `generate` minus the
-        /// dead args (linker.zig:58 → fs.zig `ModKey.generate`).
+        /// dead args.
         pub fn from_file(file: &bun_sys::File) -> core::result::Result<Self, bun_core::Error> {
             let stat = file.stat()?;
 
             const NS_PER_S: i128 = 1_000_000_000;
-            // PORT NOTE: `bun_sys::Stat` is `libc::stat`; Zig's
-            // `std.fs.File.stat()` returned a normalized struct with
-            // `mtime: i128` ns. Reconstruct from `st_mtime` (sec) +
+            // `bun_sys::Stat` is `libc::stat`.
+            // Reconstruct `mtime` (i128 ns) from `st_mtime` (sec) +
             // `st_mtime_nsec` (ns). The `libc` crate flattens BSD/Darwin
             // `st_mtimespec` into `st_mtime`/`st_mtime_nsec`, so the access is
             // uniform on all `unix`.
@@ -1836,7 +1808,7 @@ pub mod fs {
             // Don't generate a modification key if the file is too new
             let now = bun_core::time::nano_timestamp();
             let now_seconds = now / NS_PER_S;
-            // PORT NOTE: Zig had `seconds > seconds` (always false) — preserved
+            // `seconds > seconds` is always false — intentionally kept
             #[allow(clippy::eq_op)]
             if seconds > seconds || (seconds == now_seconds && mtime > now) {
                 return Err(bun_core::err!("Unusable"));
@@ -1866,7 +1838,7 @@ pub mod fs {
 
 // ──────────────────────────────────────────────────────────────────────────
 // DirEntryAccessor — `bun_glob::walk::Accessor` impl backed by the resolver's
-// DirEntry cache. Port of `glob.walk.DirEntryAccessor` (GlobWalker.zig).
+// DirEntry cache.
 //
 // Lives here (not in `bun_glob`) because it needs `fs::DirEntry`/
 // `RealFS::read_directory`, and `bun_resolver` already depends on `bun_glob`.
@@ -1906,7 +1878,6 @@ pub mod dir_entry_accessor {
         }
     }
 
-    // PORT NOTE: Zig `FS.DirEntry.EntryMap.Iterator` (key_ptr/value_ptr shape).
     // `dir_entry::EntryMap` = `StringHashMap<*mut Entry>` which derefs to
     // `std::collections::HashMap<Box<[u8]>, *mut Entry>`; iterate that directly.
     type EntryMapIter = bun_collections::hashbrown::hash_map::Iter<
@@ -1933,7 +1904,6 @@ pub mod dir_entry_accessor {
         // not a BSS-arena slice, so minting a `'static` borrow via
         // `from_raw_parts` would be a lifetime lie. `RawSlice` encapsulates
         // the outlives-holder invariant so `slice()` is safe.
-        // Mirrors Zig `IterResult.NameWrapper.value: []const u8` (no lifetime).
         pub value: bun_ptr::RawSlice<u8>,
     }
 
@@ -1985,7 +1955,6 @@ pub mod dir_entry_accessor {
                 // The key is a `Box<[u8]>` owned by `DirEntry.data` and valid
                 // until the next `read_directory` regeneration; `name_slice()`
                 // re-narrows the lifetime so it never escapes the iter result.
-                // Mirrors Zig `nextval.key_ptr.*`.
                 Ok(Some(DirEntryIterResult {
                     name: DirEntryNameWrapper {
                         value: bun_ptr::RawSlice::new(&**key),
@@ -2104,7 +2073,8 @@ pub mod dir_entry_accessor {
         fn getcwd(path_buf: &mut PathBuffer) -> Maybe<&[u8]> {
             let cwd = FS::instance().fs.cwd;
             path_buf[..cwd.len()].copy_from_slice(cwd);
-            // TODO(port): Zig version has no return; assuming it should return the copied slice
+            // Returning the copied slice is what every Accessor caller expects
+            // (it matches the syscall-backed Accessor's contract).
             Ok(&path_buf[..cwd.len()])
         }
     }
@@ -2112,7 +2082,7 @@ pub mod dir_entry_accessor {
 pub use dir_entry_accessor::DirEntryAccessor;
 
 // ──────────────────────────────────────────────────────────────────────────
-// `cache` — port of `src/bundler/cache.zig` (`Set`/`Fs`/`Entry`/`JavaScript`/
+// `cache` — `Set`/`Fs`/`Entry`/`JavaScript`/
 // `Json`). These types live below `bun_bundler` in
 // the crate graph because `Resolver.caches` is typed by them and the bundler
 // constructs/assigns it (`transpiler.resolver.caches = Set::init()`). The
@@ -2130,7 +2100,8 @@ pub mod cache {
 
     bun_core::declare_scope!(CacheFs, visible);
 
-    /// Port of `cache::Set` (cache.zig:1).
+    /// Bundle of the per-transpiler caches: JavaScript parse cache, file
+    /// cache, and JSON cache.
     pub struct Set {
         pub js: JavaScript,
         pub fs: Fs,
@@ -2152,7 +2123,8 @@ pub mod cache {
         }
     }
 
-    /// Port of `cache::Fs` (cache.zig:18).
+    /// File-read cache: shared read buffers plus flags controlling buffer
+    /// reuse and streaming reads.
     pub struct Fs {
         pub shared_buffer: MutableString,
         pub macro_shared_buffer: MutableString,
@@ -2172,7 +2144,8 @@ pub mod cache {
         }
     }
 
-    /// Port of `Fs.Entry.ExternalFreeFunction` (cache.zig:26).
+    /// Optional external destructor (`function(ctx)`) invoked when an entry's
+    /// contents are released; `NONE` when the entry owns its bytes.
     #[repr(C)]
     pub struct ExternalFreeFunction {
         pub ctx: *mut c_void,
@@ -2202,8 +2175,7 @@ pub mod cache {
     /// Provenance-tagged backing for [`Entry`] source bytes.
     ///
     /// Replaces the prior `&'static [u8]` + `Box::leak`/`heap::take` pair
-    /// (forbidden per docs/PORTING.md §Forbidden patterns). Zig's `string`
-    /// field (cache.zig:20) carried an implicit allocator contract; Rust makes
+    /// (forbidden per docs/PORTING.md §Forbidden patterns). The enum makes
     /// provenance explicit so `deinit` matches on the variant instead of
     /// guessing — the old scheme would `heap::take` a `MutableString`-owned
     /// pointer on the `use_shared_buffer=true` path (UB).
@@ -2214,14 +2186,14 @@ pub mod cache {
         Empty,
         /// Heap-owned buffer (default-allocator path). Freed when this variant
         /// drops. Stored as `Vec<u8>` (not `Box<[u8]>`) so a sentinel NUL can
-        /// sit in spare capacity past `len`, matching fs.zig:1671.
+        /// sit in spare capacity past `len`.
         Owned(Vec<u8>),
         /// Bytes live in a caller-supplied `bun_alloc::Arena` (the per-call
         /// `MimallocArena` from `ParseOptions.arena`). NOT freed on `deinit` —
         /// bulk-reclaimed by `mi_heap_destroy` when the arena drops. This is
-        /// the `allocator != bun.default_allocator` arm of
-        /// `Fs.readFileWithAllocator` (cache.zig:146 → fs.zig:1617): the
-        /// concurrent-transpiler path passed `this_parse.allocator` so the
+        /// the arena arm of
+        /// `read_file_with_allocator`: the
+        /// concurrent-transpiler path passes a per-job arena so the
         /// 1.6 MB vite chunk source landed in the per-job arena, not the
         /// worker thread's default mimalloc heap (which is never destroyed).
         Arena {
@@ -2330,9 +2302,9 @@ pub mod cache {
         }
     }
 
-    /// Port of `Fs.Entry` (cache.zig:19). `contents` is provenance-tagged (see
+    /// `contents` is provenance-tagged (see
     /// [`Contents`]); callers feed `entry.contents()` into `bun_ast::Source`.
-    /// Ownership is **manual** (`deinit`), matching Zig — callers frequently
+    /// Ownership is **manual** (`deinit`) — callers frequently
     /// hand the bytes off to a `Source` that outlives the `Entry`.
     pub struct Entry {
         pub contents: Contents,
@@ -2371,7 +2343,7 @@ pub mod cache {
             self.contents.as_slice()
         }
 
-        /// Port of `Entry.deinit` (cache.zig:39). NOT `Drop` — Zig callers free
+        /// NOT `Drop` — callers free
         /// explicitly (and frequently hand `contents` off to a `Source` that
         /// outlives the `Entry`).
         pub fn deinit(&mut self) {
@@ -2382,14 +2354,16 @@ pub mod cache {
             self.contents = Contents::Empty;
         }
 
-        /// Port of `Entry.closeFD` (cache.zig:48).
+        /// Closes the entry's cached fd (if open) and marks it invalid;
+        /// returns the close error, if any.
         pub fn close_fd(&mut self) -> Option<bun_sys::Error> {
             use bun_sys::FdExt as _;
             if self.fd.is_valid() {
                 let fd = self.fd;
                 self.fd = Fd::INVALID;
-                // TODO(port): @returnAddress() has no stable Rust equivalent; pass None.
-                return fd.close_allowing_bad_file_descriptor(None);
+                // `bun_core::return_address()` is called directly from this
+                // frame so the PC anchors our caller.
+                return fd.close_allowing_bad_file_descriptor(Some(bun_core::return_address()));
             }
             None
         }
@@ -2410,9 +2384,7 @@ pub mod cache {
         /// When we need to suspend/resume something that has pointers into the shared buffer, we need to
         /// switch out the shared buffer so that it is not in use.
         ///
-        /// Ownership transfer: in Zig (cache.zig:77/79) the field is overwritten WITHOUT freeing
-        /// the old buffer, because the suspended parse keeps pointers into it (see ModuleLoader.zig:488,
-        /// "this shared buffer is about to become owned by the AsyncModule struct"). In Rust, plain
+        /// Ownership transfer: the suspended parse keeps pointers into the old buffer, so plain
         /// field assignment would drop+free the old buffer → use-after-free on resume. So we return
         /// the detached buffer; the caller MUST take ownership of it and keep it alive for as long as
         /// `parse_result.source.contents` may be read.
@@ -2426,7 +2398,7 @@ pub mod cache {
             }
         }
 
-        /// Port of `Fs.readFileShared` (cache.zig:87) — read `path` into the
+        /// Read `path` into the
         /// caller's `shared` buffer (HMR / dev-server path).
         pub fn read_file_shared(
             &mut self,
@@ -2487,7 +2459,9 @@ pub mod cache {
             })
         }
 
-        /// Port of `Fs.readFile` (cache.zig:126).
+        /// Opens and reads `path` (relative to `dirname_fd`), optionally into
+        /// the shared buffer, returning a cache `Entry` with the contents and
+        /// possibly the kept-open fd.
         pub fn read_file(
             &mut self,
             _fs: &mut fs_mod::FileSystem,
@@ -2506,23 +2480,19 @@ pub mod cache {
             )
         }
 
-        /// Port of `Fs.readFileWithAllocator` (cache.zig:146).
-        ///
-        /// PORT NOTE: `comptime use_shared_buffer` is taken at runtime — the live
+        /// `use_shared_buffer` is taken at runtime — the live
         /// callers (`ParseTask::get_code_for_parse_task_without_plugins`,
         /// `Transpiler::parse`) pass a value computed from runtime state, and the
         /// resolver's earlier forward-decl already pinned this shape.
-        /// PERF(port): re-monomorphize once both callers stabilize.
+        /// PERF: re-monomorphize once both callers stabilize.
         ///
-        /// `arena` restores the Zig `allocator` param: when
+        /// `arena`: when
         /// `!use_shared_buffer && arena.is_some()` the file body is read
         /// directly into `arena` (`Contents::Arena`), so the bytes are
         /// bulk-freed by `mi_heap_destroy` when the per-call `MimallocArena`
         /// drops instead of landing in the worker thread's default mimalloc
         /// heap (which is never destroyed). `None` keeps the global-heap
-        /// `Contents::Owned(Vec<u8>)` path. Zig: `transpiler.zig:838-839`
-        /// passed `if (use_shared_buffer) bun.default_allocator else
-        /// this_parse.allocator`.
+        /// `Contents::Owned(Vec<u8>)` path.
         pub fn read_file_with_allocator(
             &mut self,
             _fs: &mut fs_mod::FileSystem,
@@ -2536,8 +2506,7 @@ pub mod cache {
 
             let will_close = rfs.need_to_close_files() && _file_handle.is_none();
 
-            // PORT NOTE: reshaped — Zig declared `file_handle = undefined` then assigned on each
-            // branch; restructured into a single let-expression to avoid `mem::zeroed()` on a
+            // A single let-expression avoids `mem::zeroed()` on a
             // type that may have niche (NonZero) fields.
             let file_handle: bun_sys::File = if let Some(f) = _file_handle {
                 bun_sys::lseek(f, 0, libc::SEEK_SET).map_err(bun_core::Error::from)?;
@@ -2586,13 +2555,12 @@ pub mod cache {
                 fd
             );
 
-            // PORT NOTE: reshaped for borrowck — capture `stream` scalar before borrowing
+            // reshaped for borrowck — capture `stream` scalar before borrowing
             // the shared buffer.
             let stream = self.stream;
 
             let contents = match (use_shared_buffer, arena) {
-                // Zig: `readFileWithHandleAndAllocator(this_parse.allocator, …)`
-                // — read straight into the per-call arena so the source bytes
+                // Read straight into the per-call arena so the source bytes
                 // are reclaimed by `mi_heap_destroy` instead of pinning a
                 // segment in the worker thread's default heap.
                 (false, Some(arena)) => {
@@ -2653,9 +2621,9 @@ pub mod cache {
         }
     }
 
-    /// Port of `cache::JavaScript` (cache.zig:204) — unit struct; AST caching is
-    /// "probably only relevant when bundling for production" (per the Zig
-    /// comment), so the struct is empty and `parse`/`scan` are stateless.
+    /// Unit struct; AST caching is
+    /// probably only relevant when bundling for production,
+    /// so the struct is empty and `parse`/`scan` are stateless.
     ///
     /// CYCLEBREAK: `parse`/`scan` need `bun_js_parser::Parser::init` + the
     /// `Define` table type, both of which are mid-unification with the bundler's
diff --git a/src/resolver/node_fallbacks.rs b/src/resolver/node_fallbacks.rs
index cfc4f98a309..b7c4831436d 100644
--- a/src/resolver/node_fallbacks.rs
+++ b/src/resolver/node_fallbacks.rs
@@ -10,10 +10,9 @@ const _: () = assert!(IMPORT_PATH.len().is_multiple_of(8));
 
 pub(crate) struct FallbackModule {
     pub path: fs::Path<'static>,
-    // PORT NOTE: Zig stored `*const PackageJSON` to a comptime literal (rvalue static
-    // promotion). PackageJSON has heap-backed fields (`Box<[u8]>`, hash maps) that cannot
-    // be const-constructed, so the LazyLock below owns the PackageJSONs and we hand out
-    // `&'static` borrows into it.
+    // PackageJSON has heap-backed fields (`Box<[u8]>`, hash maps) that cannot
+    // be const-constructed, so the process-lifetime singleton below owns the
+    // PackageJSONs and we hand out `&'static` borrows into it.
     pub package_json: &'static PackageJSON,
     pub code: fn() -> &'static str,
 }
@@ -22,10 +21,9 @@ pub(crate) struct FallbackModule {
 // Using `include_str!` forces you to wait for the native build to finish in
 // debug builds, even when you only changed JS builtins.
 //
-// PORT NOTE: Zig's `createSourceCodeGetter(comptime code_path: string)` returned a
-// `*const fn () string` by defining a nested struct with a `get` fn closing over the
-// comptime path. Rust fn pointers cannot close over const-generic `&str` on stable, so
-// this is expressed as a macro that expands to a local `fn get()` and yields its pointer.
+// Rust fn pointers cannot close over const-generic `&str` on stable, so this
+// is expressed as a macro that expands to a local `fn get()` and yields its
+// pointer.
 //
 // Release builds (`bun_codegen_embed`) embed the zstd-compressed `<name>.js.zst`
 // written by the codegen step (src/node-fallbacks/build-fallbacks.ts) and
@@ -72,12 +70,8 @@ macro_rules! create_source_code_getter {
     }};
 }
 
-// PORT NOTE: Zig's `pub fn init(comptime name: string) FallbackModule` did comptime string
-// concatenation (`++`) and took the address of a comptime `PackageJSON` literal. PackageJSON
-// is not const-constructible in Rust (Box<[u8]>/HashMap fields), so per PORTING.md
-// §Concurrency this is a `LazyLock` runtime-init singleton. `@setEvalBranchQuota` is dropped.
-//
-// PERF(port): Zig used a comptime perfect-hash map; this builds at first access.
+// PackageJSON is not const-constructible (Box<[u8]>/HashMap fields), so the
+// table is built at runtime, once, on first access.
 macro_rules! fallback_module_init {
     ($name:literal, $code_path:literal) => {{
         const _VERSION: &[u8] = b"0.0.0-polyfill";
@@ -93,8 +87,8 @@ macro_rules! fallback_module_init {
                 name: Box::from($name.as_bytes()),
                 version: Box::from(_VERSION),
                 module_type: ModuleType::Esm,
-                // PORT NOTE: Zig used `undefined` for main_fields/browser_map (never read on
-                // this code path); Default::default() is the closest safe equivalent.
+                // main_fields/browser_map are never read on this code path;
+                // Default::default() fills them safely.
                 source: bun_ast::Source::init_path_string(_PKGJSON_PATH, b""),
                 side_effects: SideEffects::False,
                 ..Default::default()
@@ -112,11 +106,11 @@ type FallbackEntry = (
     fn() -> &'static str,
 );
 
-// PORT NOTE: `PackageJSON` is `!Sync` (contains `StringArrayHashMap` with a
-// `Cell<bool>`), so it cannot live in `LazyLock`/`OnceLock`. Zig built this at
-// comptime (no thread-safety concern); the Rust port uses `RacyCell` + `Once`,
-// which matches the "process-lifetime singleton, init once, read-only thereafter"
-// shape. All reads go through `modules()`/`map()` which assert init ordering.
+// `PackageJSON` is `!Sync` (contains `StringArrayHashMap` with a `Cell<bool>`),
+// so it cannot live in `LazyLock`/`OnceLock`. `RacyCell` + `Once` matches the
+// "process-lifetime singleton, init once, read-only thereafter" shape. All
+// reads go through `map()`, which initializes via `INIT.call_once(init_modules)`
+// before touching the cells.
 static MODULES: bun_core::RacyCell<Option<Box<[FallbackEntry]>>> = bun_core::RacyCell::new(None);
 static MAP: bun_core::RacyCell<Option<bun_collections::StringHashMap<FallbackModule>>> =
     bun_core::RacyCell::new(None);
@@ -194,5 +188,3 @@ pub fn contents_from_path(path: &[u8]) -> Option<&'static [u8]> {
 
     None
 }
-
-// ported from: src/resolver/node_fallbacks.zig
diff --git a/src/resolver/options.rs b/src/resolver/options.rs
index 9d7d6c3a734..719121563f9 100644
--- a/src/resolver/options.rs
+++ b/src/resolver/options.rs
@@ -12,7 +12,6 @@ pub use crate::tsconfig_json::options::jsx;
 pub(crate) use bun_ast::{Loader, Target};
 pub use bun_options_types::bundle_enums::ModuleType;
 
-/// Port of `bundler/options.zig` `Packages`.
 #[derive(Clone, Copy, PartialEq, Eq, Default)]
 pub enum Packages {
     #[default]
@@ -20,7 +19,6 @@ pub enum Packages {
     External,
 }
 
-/// Port of `bundler/options.zig` `ExternalModules`.
 #[derive(Default)]
 pub struct ExternalModules {
     pub patterns: Vec<WildcardPattern>,
@@ -49,7 +47,6 @@ pub struct WildcardPattern {
 /// silently ignored every `--external` absolute path / package name.
 pub use bun_collections::StringSet;
 
-/// Port of `bundler/options.zig` `Conditions`.
 #[derive(Default)]
 pub struct Conditions {
     pub import: crate::package_json::ConditionsMap,
@@ -60,8 +57,7 @@ pub struct Conditions {
 /// `Copy` tag selecting one of the extension-order lists owned by
 /// [`BundleOptions`]. Replaces the previous `*const [Box<[u8]>]`
 /// self-reference (`Resolver.extension_order` pointing into
-/// `Resolver.opts`) with a value type — the Zig save/restore pattern
-/// (`resolver.zig:691-696` etc.) survives unchanged because the tag is
+/// `Resolver.opts`) with a value type. The tag is
 /// `Copy`, and the actual slice is resolved on demand via
 /// [`BundleOptions::ext_order_slice`] / [`Resolver::extension_order`].
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
@@ -75,10 +71,10 @@ pub(crate) enum ExtOrder {
     NodeModulesDefault,
     /// `opts.extension_order.node_modules.esm`
     NodeModulesEsm,
-    /// `opts.extension_order.css` (Zig reads `Defaults.CssExtensionOrder` directly)
+    /// `opts.extension_order.css`
     Css,
     /// `opts.main_field_extension_order` — used when resolving the `"main"`
-    /// package.json field (`resolver.zig:3703,3715,3721`).
+    /// package.json field.
     MainField,
 }
 
@@ -88,7 +84,6 @@ pub fn owned_string_list(s: &[&[u8]]) -> Box<[Box<[u8]>]> {
     s.iter().map(|s| Box::<[u8]>::from(*s)).collect()
 }
 
-/// Port of `bundler/options.zig` `ResolveFileExtensions`.
 pub struct ExtensionOrder {
     pub default: ExtensionOrderGroup,
     pub node_modules: ExtensionOrderGroup,
@@ -124,7 +119,7 @@ impl Default for ExtensionOrder {
     }
 }
 impl ExtensionOrder {
-    /// Port of `options.zig` `ResolveFileExtensions.kind`. Returns the
+    /// Returns the
     /// [`ExtOrder`] tag; resolve to a slice via
     /// [`BundleOptions::ext_order_slice`].
     pub fn kind(&self, kind: bun_ast::ImportKind, is_node_modules: bool) -> ExtOrder {
@@ -198,7 +193,7 @@ pub mod bundle_options {
 // field on the local `BundleOptions` subset stay source-compatible.
 pub use ::bun_options_types::ForceNodeEnv;
 
-/// Port of `bundler/options.zig` `Framework` (Bake) — only the
+/// Bake `Framework` — only the
 /// `built_in_modules` field, which is the sole resolver-read member.
 pub struct Framework {
     pub built_in_modules: bun_collections::StringArrayHashMap<bun_options_types::BuiltInModule>,
@@ -220,8 +215,7 @@ pub struct BundleOptions {
     pub extra_cjs_extensions: Box<[Box<[u8]>]>,
     pub framework: Option<Framework>,
     pub global_cache: bun_options_types::global_cache::GlobalCache,
-    // Zig: `?*api.BunInstall` (options.zig:1753). Spec consumer
-    // `PackageManagerOptions.zig:load` only reads through it; the bundler
+    // The bundler
     // projects this from its own `Option<NonNull<api::BunInstall>>` field
     // (CLI-owned `Box<BunInstall>`, process-lifetime).
     pub install: Option<core::ptr::NonNull<bun_options_types::schema::api::BunInstall>>,
@@ -229,7 +223,7 @@ pub struct BundleOptions {
     pub load_tsconfig_json: bool,
     pub main_field_extension_order: Box<[Box<[u8]>]>,
     pub main_fields: Box<[Box<[u8]>]>,
-    /// Spec resolver.zig `auto_main` compares the *pointer* of
+    /// `auto_main` compares the *pointer* of
     /// `opts.main_fields` against `Target.DefaultMainFields.get(target)` to
     /// detect "user did not pass --main-fields". The bundler stores an owned
     /// `Box<[Box<[u8]>]>` whose pointer can never match a static, so the
@@ -244,8 +238,7 @@ pub struct BundleOptions {
     pub production: bool,
     pub force_node_env: ForceNodeEnv,
     // Bundler-only fields read via `c.resolver.opts` in
-    // `linker_context/*` (Zig stores the full `BundleOptions` on the
-    // resolver). Projected by `bun_bundler` at link time.
+    // `linker_context/*`. Projected by `bun_bundler` at link time.
     pub output_dir: Box<[u8]>,
     pub root_dir: Box<[u8]>,
     pub public_path: Box<[u8]>,
@@ -256,7 +249,7 @@ pub struct BundleOptions {
 }
 
 impl Default for BundleOptions {
-    /// Spec: `options.zig` field-init defaults. Only the fields the resolver
+    /// Only the fields the resolver
     /// reads — `bun_bundler::Transpiler::init` overlays the per-field
     /// projections it can map (target/packages/jsx/bools/global_cache/…)
     /// before handing this to `Resolver::init1`.
@@ -299,7 +292,6 @@ impl Default for BundleOptions {
 }
 
 impl BundleOptions {
-    /// Port of `options.zig:1825 BundleOptions.setProduction`.
     pub fn set_production(&mut self, value: bool) {
         if self.force_node_env == ForceNodeEnv::Unspecified {
             self.production = value;
@@ -308,10 +300,8 @@ impl BundleOptions {
     }
 }
 
-// Port of `bundler/options.zig` `Target.DefaultMainFields`.
-//
 // These are the per-target default `--main-fields` orderings. `BundleOptions.main_fields`
-// is initialised to alias one of these slices (see options.zig:1712 / 2022), and the
+// is initialised to alias one of these slices, and the
 // resolver's `auto_main` heuristic at `load_as_main_field` compares the *pointer* of
 // `opts.main_fields` against `DEFAULT_MAIN_FIELDS.get(opts.target)` to detect whether the
 // user explicitly set a main-fields list. The previous `&[]` stub made that check always
diff --git a/src/resolver/package_json.rs b/src/resolver/package_json.rs
index 9065c0dd368..070743bdf69 100644
--- a/src/resolver/package_json.rs
+++ b/src/resolver/package_json.rs
@@ -40,11 +40,8 @@ pub mod install_stubs {
         pub use ::bun_install_types::resolver_hooks::DependencyVersionTag as Tag;
     }
 }
-// TODO(port): bun_bundler::options::{Framework, RouteConfig} — local opaque
-// FORWARD_DECL: legacy `options::Framework` and friends. The Zig
-// `package_json.zig:loadFramework*` block references `options.Framework`, which
-// no longer exists in `options.zig` (removed upstream); the loaders have no
-// callers. Port the field-shape locally so the bodies compile as-written —
+// FORWARD_DECL: legacy `options::Framework` and friends. The loaders have no
+// callers. Keep the field-shape locally so the bodies compile as-written —
 // MOVE_DOWN to `bun_options_types` if/when `bun_bundler` revives these.
 pub mod options {
     use bun_options_types::schema::api;
@@ -67,7 +64,9 @@ pub mod options {
         pub fn init() -> Env {
             Env::default()
         }
-        /// `options.zig` Env::setBehaviorFromPrefix.
+        /// Maps an env-var prefix to a behavior: `"*"` loads all vars, a
+        /// non-empty prefix loads only matching vars, and an empty prefix
+        /// disables env loading.
         pub fn set_behavior_from_prefix(&mut self, prefix: Box<[u8]>) {
             self.behavior = EnvBehavior::disable;
             self.prefix = Box::default();
@@ -135,7 +134,9 @@ pub mod options {
     }
 }
 use bun_options_types::schema::api;
-// TODO(port): bun_collections::StringMap (array-backed string→string map)
+// Deliberately a bare alias rather than `bun_collections::StringMap` (which
+// wraps the same `StringArrayHashMap<Box<[u8]>>` with a `dupe_keys` flag the
+// resolver never needs); callers here use the map API directly.
 pub type StringMap = StringArrayHashMap<Box<[u8]>>;
 pub use bun_collections::StringHashMapUnownedKey;
 use bun_glob as glob;
@@ -143,29 +144,28 @@ use bun_glob as glob;
 // Assume they're not going to have hundreds of main fields or browser map
 // so use an array-backed hash table instead of bucketed
 pub type BrowserMap = StringMap;
-/// Values are owned (Zig: `[]const u8` borrowing the package.json source
-/// buffer). Owned `Box<[u8]>` here so callers (CLI bunfig → bundler options)
+/// Values are owned `Box<[u8]>` so callers (CLI bunfig → bundler options)
 /// can populate without `unsafe` lifetime-extension casts.
 pub type MacroImportReplacementMap = StringArrayHashMap<Box<[u8]>>;
 pub type MacroMap = StringArrayHashMap<MacroImportReplacementMap>;
 
-type ScriptsMap = StringArrayHashMap<&'static [u8]>; // TODO(port): lifetime — values borrow source buffer
+// Values borrow the package.json source buffer; `'static` is a lifetime-erased
+// borrow kept alive by `PackageJSON::source_contents` (the owning field).
+type ScriptsMap = StringArrayHashMap<&'static [u8]>;
 
 pub type MainFieldMap = StringMap;
 
 #[derive(Default)]
 pub struct DependencyMap {
     pub map: DependencyHashMap,
-    // TODO(port): lifetime — borrows the package.json source contents
+    // Borrows the package.json source contents; lifetime-erased to 'static,
+    // kept alive by `PackageJSON::source_contents`.
     pub source_buf: &'static [u8],
 }
 
 impl Clone for DependencyMap {
-    /// Zig copies `DependencyMap` by value (the inner `ArrayHashMap` is a
-    /// pointer + len, so the copy aliases the same backing storage). Rust
-    /// owns the storage, so we deep-clone the small key/value vecs instead —
-    /// `SemverString`/`Dependency` are POD over `source_buf`, so semantics
-    /// match the Zig shallow copy.
+    /// Deep-clones the small key/value vecs; `SemverString`/`Dependency` are
+    /// POD over `source_buf`.
     fn clone(&self) -> Self {
         Self {
             map: self.map.clone().expect("OOM"),
@@ -174,29 +174,27 @@ impl Clone for DependencyMap {
     }
 }
 
-// PORT NOTE: Zig had `DependencyMap.HashMap` as a nested decl; Rust inherent impls cannot carry associated type aliases (stable), so use a free alias.
+// Inherent impls cannot carry associated type aliases (stable), so use a free alias.
 pub type DependencyHashMap =
     ArrayHashMap<SemverString, Dependency /* , SemverString::ArrayHashContext */>;
-// TODO(port): ArrayHashMap context param — Zig used String.ArrayHashContext with store_hash=false
 
 pub struct PackageJSON {
     pub name: Box<[u8]>,
     pub source: bun_ast::Source,
-    /// PORT NOTE: owns the file bytes that `source.contents` (and the
+    /// Owns the file bytes that `source.contents` (and the
     /// `&'static [u8]` map values below) borrow. Replaces the prior
     /// `mem::forget` leak — forbidden per docs/PORTING.md §Forbidden patterns.
-    /// Zig (`package_json.zig:615`) used `bun.default_allocator` and never
-    /// freed on success because the DirInfo cache is process-lifetime; here the
-    /// `PackageJSON` itself is the owner so the bytes free if it ever drops.
-    // TODO(port): lifetime — once `bun_ast::Source::contents` becomes
-    // `Cow<'static, [u8]>`, fold this into `source` and drop the re-borrow.
+    /// The `PackageJSON` itself is the owner so the bytes free if it ever drops.
+    /// (`bun_ast::Source::contents` is `&'static [u8]`, so this separate owner
+    /// field is what keeps that borrow — and the map values above — alive.)
     pub source_contents: Box<[u8]>,
     pub main_fields: MainFieldMap,
     pub module_type: ModuleType,
     pub version: Box<[u8]>,
 
     pub scripts: Option<Box<ScriptsMap>>,
-    pub config: Option<Box<StringArrayHashMap<&'static [u8]>>>, // TODO(port): value lifetime
+    // Values borrow the source buffer (lifetime-erased; owned by `source_contents`).
+    pub config: Option<Box<StringArrayHashMap<&'static [u8]>>>,
 
     pub arch: Architecture,
     pub os: OperatingSystem,
@@ -237,12 +235,11 @@ pub struct PackageJSON {
     pub imports: Option<ExportsMap>,
 }
 
-// PORT NOTE: hand-rolled `Default` because `#[derive(Default)]` would zero
+// hand-rolled `Default` because `#[derive(Default)]` would zero
 // `package_manager_package_id` (a valid lockfile id — typically the root
-// package). Spec `package_json.zig:68` declares the field default as
-// `Install.invalid_package_id` (= `u32::MAX`); `node_fallbacks.rs` relies on
-// `..Default::default()` matching that. Likewise `arch`/`os` default to
-// `*::all()` (zig:65-66).
+// package). The field defaults to `Install.invalid_package_id` (= `u32::MAX`);
+// `node_fallbacks.rs` relies on `..Default::default()` matching that. Likewise
+// `arch`/`os` default to `*::all()`.
 impl Default for PackageJSON {
     fn default() -> Self {
         PackageJSON {
@@ -326,7 +323,6 @@ impl ::bun_install_types::resolver_hooks::PackageJsonView for PackageJSON {
 
 impl PackageJSON {
     pub fn name_for_import(&self) -> Result<Box<[u8]>, bun_core::Error> {
-        // TODO(port): narrow error set
         if strings::index_of(self.source.path.text, NODE_MODULES_PATH.as_bytes()).is_some() {
             Ok(Box::from(&*self.name))
         } else {
@@ -370,7 +366,6 @@ pub enum SideEffects {
     Mixed(MixedPatterns),
 }
 
-// TODO(port): std.HashMapUnmanaged with StringHashMapUnowned.Key/Adapter and 80% load factor
 pub type SideEffectsMap = bun_collections::HashMap<StringHashMapUnownedKey, ()>;
 
 pub type GlobList = Vec<Box<[u8]>>;
@@ -426,13 +421,12 @@ impl SideEffects {
 // ── Local extension shims so `parse` can call shapes that live in higher-tier
 //    crates (full FileSystem). Bodies forward to bun_paths. ────────────────
 //
-// PORT NOTE: the former `JsonCachePackageJsonExt` shim trait is removed —
+// the former `JsonCachePackageJsonExt` shim trait is removed —
 // `JsonCacheVTable` now has a real `parse_package_json` slot and `JsonCache`
 // exposes the inherent forwarder (tsconfig_json.rs).
 // `bun_bundler::cache::JSON_CACHE_VTABLE` wires it to `bun_parsers::json`.
 
-/// The Zig body calls the threadlocal-buffer `abs`/`join`/`normalize` and
-/// immediately dupes the result. Thin extension trait that delegates to
+/// Thin extension trait that delegates to
 /// `bun_paths::resolve_path` and returns owned `Box<[u8]>` so no `'static`
 /// lifetime is fabricated from a threadlocal scratch buffer (forbidden per
 /// docs/PORTING.md §Forbidden patterns — "`unsafe { &*(p as *const _) }` to
@@ -446,9 +440,8 @@ pub trait FileSystemPackageJsonExt {
 }
 impl FileSystemPackageJsonExt for crate::fs::FileSystem {
     fn abs_owned(&self, parts: &[&[u8]]) -> Box<[u8]> {
-        // PORT NOTE: Zig `FileSystem.abs` joins against `top_level_dir` into a
-        // threadlocal buffer; caller immediately dupes. Return owned to avoid
-        // laundering the threadlocal borrow into `'static`.
+        // Joins against `top_level_dir`; return owned so no scratch-buffer
+        // borrow is laundered into `'static`.
         let out = resolve_path::resolve_path::join_abs_string::<
             resolve_path::resolve_path::platform::Loose,
         >(self.top_level_dir, parts);
@@ -458,11 +451,7 @@ impl FileSystemPackageJsonExt for crate::fs::FileSystem {
         resolve_path::resolve_path::join::<resolve_path::resolve_path::platform::Loose>(parts)
     }
     fn normalize(&self, str: &[u8]) -> Box<[u8]> {
-        // PORT NOTE: Zig `FileSystem.normalize` (fs.zig) is
-        // `path_handler.normalizeString(str, true, .auto)` — collapses `.`/`..`/dup-separators
-        // only; it does NOT join against cwd. Writes into a threadlocal buffer;
-        // caller immediately dupes. Return owned to avoid laundering the
-        // threadlocal borrow into `'static`.
+        // Collapses `.`/`..`/dup-separators only; does NOT join against cwd.
         let out = resolve_path::resolve_path::normalize_string::<
             true,
             resolve_path::resolve_path::platform::Auto,
@@ -471,8 +460,8 @@ impl FileSystemPackageJsonExt for crate::fs::FileSystem {
     }
 }
 
-// TODO(port): bun_bundler::options + bun_ast::Expr full API + bun_install + bun_schema
-// — framework/define loaders stay gated until bun_bundler::options lands.
+// Legacy framework/define loaders: no callers today; bodies kept compiling
+// against the local `options` shim.
 
 impl PackageJSON {
     fn load_define_defaults(
@@ -480,7 +469,6 @@ impl PackageJSON {
         json: &js_ast::E::Object,
         bump: &Bump,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut valid_count: usize = 0;
         for prop in json.properties.slice() {
             if !matches!(
@@ -508,7 +496,6 @@ impl PackageJSON {
             ) {
                 continue;
             }
-            // PERF(port): was appendAssumeCapacity
             env.defaults.push(options::EnvDefault {
                 key: Box::from(
                     prop.key
@@ -550,11 +537,8 @@ impl PackageJSON {
             valid_count += 1;
         }
 
-        let buffer: Vec<Box<[u8]>> = vec![Box::default(); valid_count * 2];
-        // TODO(port): Zig used a single allocation split into keys/values; Rust uses two Vecs
         let mut keys: Vec<Box<[u8]>> = Vec::with_capacity(valid_count);
         let mut values: Vec<Box<[u8]>> = Vec::with_capacity(valid_count);
-        let _ = buffer; // unused after reshaping
         for prop in json.properties.slice() {
             if !matches!(
                 prop.value
@@ -730,9 +714,6 @@ impl PackageJSON {
             || framework.fallback.is_enabled()
     }
 
-    // PORT NOTE: Zig `comptime load_framework: LoadFramework` lowered to a runtime
-    // arg — `LoadFramework` is a plain enum (no `ConstParamTy`), and the only
-    // use is the trailing `match`. PERF(port): was comptime — irrelevant (dead).
     pub fn load_framework_with_preference<const READ_DEFINES: bool>(
         package_json: &PackageJSON,
         pair: &mut FrameworkRouterPair<'_>,
@@ -867,7 +848,7 @@ impl PackageJSON {
                                 }
                                 extensions.push(e_str.data.slice());
                             }
-                            // TODO(port): `extensions` is computed but never assigned anywhere (matches Zig)
+                            // `extensions` is computed but never assigned anywhere.
                             let _ = extensions;
                         }
                     }
@@ -1020,7 +1001,6 @@ impl PackageJSON {
                     None => continue,
                 };
 
-                // PERF(port): was putAssumeCapacityNoClobber
                 map.insert(import_name, Box::<[u8]>::from(remap_value_str));
             }
 
@@ -1039,7 +1019,6 @@ impl PackageJSON {
         package_id: Option<PackageID>,
         include_scripts_: IncludeScripts,
     ) -> Option<PackageJSON> {
-        // PERF(port): include_scripts_ was a comptime enum param — profile if hot
         let include_scripts = include_scripts_ == IncludeScripts::IncludeScripts;
 
         // SAFETY: PORT (Stacked Borrows) — `r.fs()`/`r.log()` return RAW `*mut`
@@ -1047,8 +1026,7 @@ impl PackageJSON {
         // singletons so the two `&mut` projections below do not alias each other,
         // and no other `&mut *r.fs` / `&mut *r.log` retag occurs while they are
         // live in this function. Caller upholds the single-thread `Resolver`
-        // aliasing contract (Zig had no borrow split here either — `r.fs`/`r.log`
-        // are accessed freely throughout `parse`).
+        // aliasing contract.
         let r_fs: &mut fs::FileSystem = unsafe { &mut *r.fs() };
         // SAFETY: see above — `r.log()` points to a distinct singleton from `r.fs()`.
         let r_log: &mut bun_ast::Log = unsafe { &mut *r.log() };
@@ -1090,7 +1068,7 @@ impl PackageJSON {
                 return None;
             }
         };
-        // PORT NOTE: reshaped for borrowck — `mem::take` the contents (leaving
+        // Reshaped for borrowck — `mem::take` the contents (leaving
         // `Contents::Empty` behind) so `entry` stays whole for the close-guard.
         // Immediately convert to owned `Box<[u8]>`: `use_shared_buffer = false`
         // above guarantees `Contents::Owned`/`Empty`, so the match is exhaustive
@@ -1111,21 +1089,18 @@ impl PackageJSON {
             ));
         }
 
-        // PORT NOTE: `bun_ast::Source.path` is the lightweight `bun_paths::fs::Path<'static>` (no
+        // `bun_ast::Source.path` is the lightweight `bun_paths::fs::Path<'static>` (no
         // `pretty`/`is_node_module`); `key_path` is only used for `text`, so init the
         // source directly from the interned path.
         //
-        // TODO(port): lifetime — `bun_ast::Source::contents` is `&'static [u8]`; once
-        // it becomes `Cow<'static, [u8]>` move `entry_contents` straight into
-        // `json_source` and delete this re-borrow.
+        // `bun_ast::Source::contents` is `&'static [u8]`, so `json_source`
+        // re-borrows `entry_contents` (lifetime-erased) instead of owning it.
         //
         // SAFETY: `entry_contents: Box<[u8]>` is the unique owner of these bytes.
         // On the success path it is *moved* (not leaked) into
         // `package_json.source_contents` at the bottom of this fn, so the heap
-        // allocation lives for the life of the returned `PackageJSON` (Zig:
-        // `bun.default_allocator`, never freed — "DirInfo cache is reused
-        // globally"). On every early `return None` below `entry_contents` drops
-        // and frees normally (Zig: `allocator.free(entry.contents)`), after
+        // allocation lives for the life of the returned `PackageJSON`. On every
+        // early `return None` below `entry_contents` drops and frees normally, after
         // `json_source` is already dead. `Box<[u8]>` heap address is stable
         // across the move.
         let contents_static: &'static [u8] = unsafe { bun_ptr::detach_lifetime(&entry_contents) };
@@ -1156,7 +1131,7 @@ impl PackageJSON {
         let mut package_json = PackageJSON {
             name: Box::default(),
             version: Box::default(),
-            // PORT NOTE: reshaped for borrowck — `json_source` stays a local until the
+            // Reshaped for borrowck — `json_source` stays a local until the
             // end so we can borrow it while mutating other `package_json` fields.
             source: bun_ast::Source::default(),
             // Filled at the bottom by moving `entry_contents` in (see SAFETY note above).
@@ -1174,8 +1149,8 @@ impl PackageJSON {
             exports: None,
             imports: None,
         };
-        // PORT NOTE: shadow as `&Source` so the body matches the Zig shape; the
-        // owned value is reconstructed at the bottom (Source isn't `Clone`).
+        // shadow as `&Source`; the owned value is reconstructed at the bottom
+        // (Source isn't `Clone`).
         let json_source = &json_source;
 
         // Note: we tried rewriting this to be fewer loops over all the properties (asProperty loops over each)
@@ -1291,7 +1266,7 @@ impl PackageJSON {
                             // import of "foo", but that's actually not a bug. Or arguably it's a
                             // bug in Browserify but we have to replicate this bug because packages
                             // do this in the wild.
-                            // PORT NOTE: inherent `FileSystem::normalize` (fs.rs)
+                            // inherent `FileSystem::normalize` (fs.rs)
                             // returns a threadlocal-backed `&[u8]` and shadows the
                             // owned-returning trait method; UFCS to get the `Box`.
                             let key: Box<[u8]> =
@@ -1315,7 +1290,7 @@ impl PackageJSON {
                                 }
                                 _ => {
                                     // Only print this warning if its not inside node_modules, since node_modules/ is not actionable.
-                                    // PORT NOTE: `bun_paths::fs::Path<'static>` has no `is_node_module`; inline the check.
+                                    // `bun_paths::fs::Path<'static>` has no `is_node_module`; inline the check.
                                     if !strings::contains(
                                         json_source.path.text,
                                         NODE_MODULES_PATH.as_bytes(),
@@ -1358,7 +1333,7 @@ impl PackageJSON {
                 }
             } else if let js_ast::ExprData::EArray(e_array) = &side_effects_field.data {
                 // Handle arrays, including empty arrays
-                // PORT NOTE: reshaped — `ArrayIterator` is not `Clone`; iterate the
+                // Reshaped — `ArrayIterator` is not `Clone`; iterate the
                 // underlying `Vec<Expr>` slice directly for both passes.
                 let items = e_array.items.slice();
                 let mut map = SideEffectsMap::default();
@@ -1410,10 +1385,8 @@ impl PackageJSON {
                                 // Normalize pattern to use forward slashes for cross-platform compatibility
                                 let normalized_pattern = Self::normalize_path_for_glob(pattern)
                                     .unwrap_or_else(|_| pattern.to_vec());
-                                // PERF(port): was appendAssumeCapacity
                                 glob_list.push(normalized_pattern.into_boxed_slice());
                             } else {
-                                // PERF(port): was getOrPutAssumeCapacity
                                 let _ = map.insert(StringHashMapUnownedKey::init(pattern), ());
                             }
                         }
@@ -1440,7 +1413,6 @@ impl PackageJSON {
                             // Normalize pattern to use forward slashes for cross-platform compatibility
                             let normalized_pattern = Self::normalize_path_for_glob(pattern)
                                 .unwrap_or_else(|_| pattern.to_vec());
-                            // PERF(port): was appendAssumeCapacity
                             glob_list.push(normalized_pattern.into_boxed_slice());
                         }
                     }
@@ -1453,7 +1425,6 @@ impl PackageJSON {
                             let joined: [&[u8]; 2] =
                                 [json_source.path.name().dir_with_trailing_slash(), name];
 
-                            // PERF(port): was getOrPutAssumeCapacity
                             let _ =
                                 map.insert(StringHashMapUnownedKey::init(r_fs.join(&joined)), ());
                         }
@@ -1463,10 +1434,6 @@ impl PackageJSON {
             }
         }
 
-        // TODO(port): bun_install::{Dependency, Architecture, OperatingSystem,
-        // lockfile::Package::DependencyGroup, PackageManager}. The whole
-        // dependencies/os/cpu block is install-tier.
-
         if INCLUDE_DEPENDENCIES == IncludeDependencies::Main
             || INCLUDE_DEPENDENCIES == IncludeDependencies::Local
         {
@@ -1547,7 +1514,6 @@ impl PackageJSON {
                 } else {
                     &[DependencyGroup::DEPENDENCIES, DependencyGroup::OPTIONAL]
                 };
-                // PERF(port): was comptime monomorphization (inline for over comptime array) — profile if hot
 
                 let mut total_dependency_count: usize = 0;
                 for group in dependency_groups {
@@ -1560,10 +1526,10 @@ impl PackageJSON {
 
                 if total_dependency_count > 0 {
                     package_json.dependencies.map = DependencyHashMap::default();
-                    // TODO(port): lifetime — source_buf borrows json_source.contents
+                    // source_buf borrows json_source.contents (lifetime-erased;
+                    // owned by `package_json.source_contents` on the success path).
                     package_json.dependencies.source_buf = contents_static;
-                    // PORT NOTE: Zig used `SemverString.ArrayHashContext` (compares against
-                    // `source_buf`); ArrayHashMap has no `*_context` variant yet — the
+                    // ArrayHashMap has no `*_context` variant yet — the
                     // generic `put_assume_capacity` path is sufficient because keys are
                     // `SemverString` (offset+len into `source_buf`, hashed by content).
                     package_json
@@ -1598,8 +1564,7 @@ impl PackageJSON {
                                     let sliced_str =
                                         Semver::SlicedString::init(version_str, version_str);
 
-                                    // Zig's `Dependency.parse` accepts `?*PackageManager`;
-                                    // the parser body lives in install-tier so route through
+                                    // The parser body lives in install-tier so route through
                                     // the AutoInstaller vtable when one is wired. When it
                                     // isn't, still record the dependency name (with an
                                     // uninitialized-tag version) — `bun run --filter` reads
@@ -1621,8 +1586,6 @@ impl PackageJSON {
                                             name_hash,
                                             behavior: group.behavior,
                                         };
-                                        // Zig: `putAssumeCapacityContext(name, dep, ctx)` where
-                                        // `ctx = SemverString.ArrayHashContext{arg_buf, existing_buf}`.
                                         let buf = package_json.dependencies.source_buf;
                                         let ctx = Semver::semver_string::ArrayHashContext {
                                             arg_buf: buf,
@@ -1644,7 +1607,7 @@ impl PackageJSON {
         }
 
         // used by `bun run`
-        // PORT NOTE: `Expr::as_property_string_map` returns
+        // `Expr::as_property_string_map` returns
         // `ArrayHashMap<&'bump [u8], &'bump [u8]>` (bump-tied lifetimes), but
         // `ScriptsMap` stores `&'static [u8]` borrowing the package.json source
         // bytes (`contents_static`, see SAFETY note above). Inline the
@@ -1672,11 +1635,10 @@ impl PackageJSON {
                         else {
                             continue;
                         };
-                        // Zig `asPropertyStringMap` drops entries where the key
-                        // OR the value is empty (expr.zig: `key.len > 0 and
-                        // value.len > 0`). An empty-valued script
-                        // (`{"scripts":{"build":""}}`) must NOT become a real
-                        // (empty) script — Zig reports "Script not found".
+                        // Drop entries where the key OR the value is empty.
+                        // An empty-valued script (`{"scripts":{"build":""}}`)
+                        // must NOT become a real (empty) script — report
+                        // "Script not found".
                         // (npm actually runs empty scripts and exits 0; we
                         // intentionally diverge here to match released Bun.)
                         if key.is_empty() || value.is_empty() {
@@ -1687,8 +1649,7 @@ impl PackageJSON {
                         let value: &'static [u8] = unsafe { bun_ptr::detach_lifetime(value) };
                         map.put_assume_capacity(key, value);
                     }
-                    // Zig returns null when the FILTERED map is empty
-                    // (expr.zig: `if (count == 0) return null;`), not just when
+                    // Return None when the FILTERED map is empty, not just when
                     // the raw object had no properties.
                     if map.is_empty() {
                         return None;
@@ -1704,7 +1665,7 @@ impl PackageJSON {
         }
         let _ = (include_scripts, package_id);
 
-        // PORT NOTE: reshaped for borrowck — assign source last (see struct init above).
+        // Reshaped for borrowck — assign source last (see struct init above).
         // `bun_ast::Source` isn't `Clone`; reconstruct from its (all-Copy/Clone) fields.
         package_json.source = bun_ast::Source {
             path: json_source.path,
@@ -1767,7 +1728,7 @@ impl<'a> Visitor<'a> {
                 };
             }
             js_ast::ExprData::EString(str) => {
-                // PORT NOTE: JSON-parsed strings are always UTF-8 (latin1 source bytes);
+                // JSON-parsed strings are always UTF-8 (latin1 source bytes);
                 // `str.data` is the raw slice, no bump-arena transcode needed.
                 debug_assert!(!str.is_utf16);
                 return Entry {
@@ -1790,11 +1751,7 @@ impl<'a> Visitor<'a> {
             }
             js_ast::ExprData::EObject(e_obj) => {
                 let prop_len = e_obj.properties.len_u32() as usize;
-                // PORT NOTE: reshaped for borrowck — Zig used MultiArrayList column slices;
-                // EntryDataMapList is a Vec<MapEntry> placeholder until
-                // bun_collections::MultiArrayList lands. Push whole entries instead of
-                // writing through three parallel column slices.
-                // TODO(port): bun_collections::MultiArrayList column accessors
+                // `EntryDataMapList` is a `Vec<MapEntry>`, so push whole entries.
                 let mut map_data: EntryDataMapList = Vec::with_capacity(prop_len);
                 let mut expansion_keys: Vec<MapEntry> = Vec::with_capacity(prop_len);
                 let mut is_conditional_sugar = false;
@@ -1906,7 +1863,7 @@ pub enum EntryData {
     Invalid,
     Null,
     Boolean(bool),
-    String(Box<[u8]>), // TODO(port): lifetime — borrows source contents in Zig
+    String(Box<[u8]>), // owned copy
     Array(Box<[Entry]>),
     Map(EntryDataMap),
 }
@@ -1928,34 +1885,23 @@ pub struct EntryDataMap {
     pub list: EntryDataMapList,
 }
 
-// TODO(port): bun_collections::MultiArrayList<MapEntry> — needs MultiArrayElement derive +
-// per-field column accessors. Using Vec<MapEntry> as a placeholder shape.
 pub type EntryDataMapList = Vec<MapEntry>;
 
 #[derive(Clone)]
 pub struct MapEntry {
-    pub key: Box<[u8]>, // TODO(port): lifetime — borrows source contents in Zig
+    pub key: Box<[u8]>, // owned copy
     pub key_range: bun_ast::Range,
     pub value: Entry,
 }
 
-// TODO(port): MultiArrayList field selector enum
-pub enum MapEntryField {
-    Key,
-    KeyRange,
-    Value,
-}
-
 impl Entry {
     pub fn keys_start_with_dot(&self) -> bool {
-        // TODO(port): bun_collections::MultiArrayList column accessor; Vec placeholder.
         matches!(&self.data, EntryData::Map(m) if !m.list.is_empty() && strings::starts_with_char(&m.list[0].key, b'.'))
     }
 
     pub fn value_for_key(&self, key_: &[u8]) -> Option<&Entry> {
         match &self.data {
             EntryData::Map(m) => {
-                // TODO(port): bun_collections::MultiArrayList column accessor; Vec placeholder.
                 for entry in m.list.iter() {
                     if strings::eql(&entry.key, key_) {
                         return Some(&entry.value);
@@ -1981,10 +1927,8 @@ pub struct ESModule<'a> {
 #[derive(Clone)]
 pub struct Resolution {
     pub status: Status,
-    // PORT NOTE: Zig returned slices into threadlocal PathBuffers / the package.json source
-    // buffer. In Rust the source-buffer case (`EntryData::String(Box<[u8]>)`) is owned by a
+    // The source-buffer case (`EntryData::String(Box<[u8]>)`) is owned by a
     // possibly-temporary `Entry`, so borrowing would dangle. Copy out into an owned buffer.
-    // TODO(perf): thread a real `'a` lifetime once `EntryData::String` is `&'a [u8]`.
     pub path: Box<[u8]>,
     pub debug: ResolutionDebug,
 }
@@ -2110,7 +2054,7 @@ impl<'a> Package<'a> {
     /// Allocate a fresh string buffer and clone `name`/`version`/`subpath`
     /// into it as offset-encoded `Semver::String`s. Mirrors the inline
     /// `count` → `allocate` → `clone` Builder dance the resolver does at the
-    /// auto-install pending sites (resolver.zig), exposed as the `esm.copy`
+    /// auto-install pending sites, exposed as the `esm.copy`
     /// helper that `PendingResolution::init` expects.
     pub fn copy(self) -> Result<(PackageExternal, Vec<u8>), bun_core::Error> {
         let mut builder = Semver::semver_string::Builder::default();
@@ -2178,7 +2122,6 @@ impl<'a> Package<'a> {
     }
 
     pub fn parse(specifier: &'a [u8], subpath_buf: &'a mut [u8]) -> Option<Package<'a>> {
-        // TODO(port): lifetime — &'static is a placeholder; should be <'a>
         if specifier.is_empty() {
             return None;
         }
@@ -2244,56 +2187,7 @@ impl<'a> Package<'a> {
     }
 }
 
-// ── Local string helpers (TODO(port): bun_core::{replacement_size, replace}) ──
-// Minimal local impls so the ESModule resolution algorithm compiles; replace with the
-// canonical bun_core versions once they land. Recorded in blocked_on.
-
-/// Port of `std.mem.replacementSize` — total bytes after replacing every `needle` in
-/// `input` with `replacement`.
-#[inline]
-fn replacement_size(input: &[u8], needle: &[u8], replacement: &[u8]) -> usize {
-    if needle.is_empty() {
-        return input.len();
-    }
-    let mut size = 0usize;
-    let mut i = 0usize;
-    while i < input.len() {
-        if input[i..].starts_with(needle) {
-            size += replacement.len();
-            i += needle.len();
-        } else {
-            size += 1;
-            i += 1;
-        }
-    }
-    size
-}
-
-/// Port of `std.mem.replace` — replace every `needle` in `input` with `replacement`,
-/// writing into `output`. Returns number of replacements.
-#[inline]
-fn replace(input: &[u8], needle: &[u8], replacement: &[u8], output: &mut [u8]) -> usize {
-    if needle.is_empty() {
-        output[..input.len()].copy_from_slice(input);
-        return 0;
-    }
-    let mut i = 0usize;
-    let mut o = 0usize;
-    let mut count = 0usize;
-    while i < input.len() {
-        if input[i..].starts_with(needle) {
-            output[o..o + replacement.len()].copy_from_slice(replacement);
-            o += replacement.len();
-            i += needle.len();
-            count += 1;
-        } else {
-            output[o] = input[i];
-            o += 1;
-            i += 1;
-        }
-    }
-    count
-}
+use bun_core::strings::{replace, replacement_size};
 
 const INVALID_PERCENT_CHARS: [&[u8]; 4] = [b"%2f", b"%2F", b"%5c", b"%5C"];
 
@@ -2304,8 +2198,8 @@ struct ModuleBufs {
 }
 
 thread_local! {
-    // PORT NOTE: bun.ThreadlocalBuffers — Zig heap-allocates the buffer struct on first use and
-    // stores only a pointer in TLS so the static-TLS template stays small (PE/COFF has no
+    // Heap-allocate the buffer struct on first use and store only a pointer
+    // in TLS so the static-TLS template stays small (PE/COFF has no
     // TLS-BSS; ELF PT_TLS MemSiz scales with this — see test/js/bun/binary/tls-segment-size).
     // resolve_target / resolve_target_reverse are RECURSIVE (Map/Array arms call themselves), so a
     // RefCell + escaped `&mut PathBuffer` would create aliased `&mut` at the inner call → UB.
@@ -2331,9 +2225,8 @@ fn module_bufs() -> *mut ModuleBufs {
     })
 }
 
-// PORT NOTE: Zig used `r: *const ESModule` (const ptr) but mutated `r.module_type.*`
-// and `r.debug_logs.?.*` through interior pointers. In Rust those fields are `&'a mut T`,
-// so reading/writing them requires `&mut self`. All resolution methods take `&mut self`.
+// `module_type` / `debug_logs` are `&'a mut T`, so reading/writing them
+// requires `&mut self`. All resolution methods take `&mut self`.
 impl<'a> ESModule<'a> {
     pub fn resolve(&mut self, package_url: &[u8], subpath: &[u8], exports: &Entry) -> Resolution {
         let r = self.resolve_exports(package_url, subpath, exports);
@@ -2419,8 +2312,7 @@ impl<'a> ESModule<'a> {
             };
         }
 
-        // PORT NOTE: Zig returned a slice into the threadlocal resolved_path_buf_percent.
-        // Copy out — see `Resolution.path` note. PERF(port): avoid the alloc if hot.
+        // Copy out — see `Resolution.path` note. PERF: avoid the alloc if hot.
         result.path = Box::<[u8]>::from(resolved_path);
         result
     }
@@ -2640,10 +2532,9 @@ impl<'a> ESModule<'a> {
                     ));
                     log.increase_indent();
                 }
-                // PORT NOTE: Zig had `defer log.decrease_indent()` capturing the unwrapped
-                // `*DebugLogs`. Rust scopeguard cannot hold the &mut across the recursive
-                // `&mut self` calls below; manual decrease at each return below.
-                // TODO(port): errdefer — verify all return paths decrease_indent.
+                // A scopeguard cannot hold the &mut across the recursive
+                // `&mut self` calls below; every return path in this arm invokes
+                // `dedent!()` manually instead (audited: all 10 returns in this arm dedent).
                 macro_rules! dedent {
                     () => {
                         if let Some(log) = self.debug_logs.as_deref_mut() {
@@ -2738,8 +2629,7 @@ impl<'a> ESModule<'a> {
                                 },
                             };
                         } else {
-                            // PORT NOTE: Zig used `.auto` here, carried over as a
-                            // latent Windows bug (#30839): this branch runs when an
+                            // Latent Windows bug (#30839): this branch runs when an
                             // `imports` target is itself a package specifier
                             // (e.g. `@myproject/resolver`) that we hand back to
                             // package-resolve. Per the Node.js packages spec these
@@ -2909,8 +2799,6 @@ impl<'a> ESModule<'a> {
                 let mut did_find_map_entry = false;
                 let mut last_map_entry_i: usize = 0;
 
-                // PORT NOTE: Zig used MultiArrayList column slices; `EntryDataMapList`
-                // is `Vec<MapEntry>` so iterate AoS directly.
                 for (i, entry) in object.list.iter().enumerate() {
                     let key: &[u8] = &entry.key;
                     if self.conditions.contains_key(key) {
@@ -2991,7 +2879,7 @@ impl<'a> ESModule<'a> {
                         //     |              ^
                         //
                         // More information: https://github.com/evanw/esbuild/issues/1484
-                        // PORT NOTE: reshaped for borrowck — return_target points into slice; clone keys below
+                        // Reshaped for borrowck — return_target points into slice; clone keys below
                         return_target = last_map_entry_value;
                     }
 
@@ -3200,5 +3088,3 @@ fn is_invalid_segment(segment: &[u8]) -> bool {
     let d = &decoded[..len];
     d == b"." || d == b".." || d == b"node_modules"
 }
-
-// ported from: src/resolver/package_json.zig
diff --git a/src/resolver/resolver.rs b/src/resolver/resolver.rs
index ae4cd319328..2b9f84b4c12 100644
--- a/src/resolver/resolver.rs
+++ b/src/resolver/resolver.rs
@@ -1,8 +1,8 @@
 //! The [`Resolver`] state machine: import-path resolution against the on-disk
 //! filesystem, `node_modules` tree, `tsconfig.json` paths, package `exports`,
 //! `browser` maps, and the standalone (compiled) module graph. Holds the
-//! Zig→Rust port of `src/resolver/resolver.zig`'s `Resolver` struct and its
-//! impl, plus the local helper shims (`bun_paths` value-dispatch joins,
+//! `Resolver` struct and its impl,
+//! plus the local helper shims (`bun_paths` value-dispatch joins,
 //! `bun_sys` dir-open wrappers, `FdExt`) and threadlocal scratch buffers.
 
 use crate::{is_package_path, is_package_path_not_absolute};
@@ -24,13 +24,13 @@ use ::bun_semver as Semver;
 // `bun_install_types` dep (LAYERING: pass-through, no new edge).
 pub use ::bun_install_types::resolver_hooks::AutoInstaller as PackageManagerTrait;
 
-// LAYERING: `PackageManager.initWithRuntime` (Zig resolver.zig:540) lives in
+// LAYERING: `PackageManager.initWithRuntime` lives in
 // `bun_install`, which depends on this crate. The lazy-init body is defined
 // `#[no_mangle]` in `bun_install::auto_installer` and resolved at link time
 // (same pattern as `__bun_regex_*` / `__BUN_RUNTIME_HOOKS`). `install` is the
 // `?*Api.BunInstall` (`self.opts.install`); `env` is the `*DotEnv.Loader`
 // (lifetime-erased to `'static` — the install crate stores it as a raw
-// `NonNull<Loader<'static>>`, matching Zig's untracked `*DotEnv.Loader`).
+// `NonNull<Loader<'static>>`).
 unsafe extern "Rust" {
     /// SAFETY (genuine FFI precondition — NOT a `safe fn` candidate): impl
     /// reborrows `&mut *log` / `&mut *env` and reads `*install` if non-null.
@@ -45,8 +45,8 @@ unsafe extern "Rust" {
 use crate::cache::Set as CacheSet;
 use ::bun_resolve_builtins::{Alias as HardcodedAlias, Cfg as HardcodedAliasCfg};
 
-/// `Dependency` namespace as the body spells it (Zig: `Dependency.Version` /
-/// `Dependency.Behavior`). Re-exports the canonical `bun_install_types` items.
+/// `Dependency` namespace as the body spells it (`Dependency::Version` /
+/// `Dependency::Behavior`). Re-exports the canonical `bun_install_types` items.
 pub mod Dependency {
     pub use ::bun_install_types::resolver_hooks::{
         Behavior, Dependency, DependencyVersion as Version, DependencyVersionTag,
@@ -61,7 +61,7 @@ pub mod Dependency {
 /// re-exports of `bun_install_types` (no local stubs).
 pub(crate) mod __forward_decls {}
 // bun_paths shim — value-dispatched join helpers over `resolve_path::Platform`.
-// `dirname` (`Option`-returning, `std.fs.path.dirname` semantics) and
+// `dirname` (`Option`-returning) and
 // `PosixToWinNormalizer` are the real `::bun_paths` items — brought in by the
 // glob / explicit re-export below, no local re-implementation.
 mod bun_paths {
@@ -71,8 +71,7 @@ mod bun_paths {
 
     /// Value-dispatch over `Platform` to the const-generic `PlatformT`
     /// monomorphizations in `resolve_path`. The resolver body threads
-    /// `Platform::AUTO` / `Platform::Loose` at runtime (carried over from Zig's
-    /// `comptime _platform: Platform` callsites that took a function param).
+    /// `Platform::AUTO` / `Platform::Loose` at runtime.
     macro_rules! dispatch_platform {
         ($p:expr, |$P:ident| $body:expr) => {{
             use ::bun_paths::resolve_path::{self as rp, platform};
@@ -112,7 +111,7 @@ mod bun_paths {
         )
     }
     pub(super) fn join_abs(cwd: &[u8], platform: Platform, part: &[u8]) -> &'static [u8] {
-        // PORT NOTE: `resolve_path::join_abs` ties the result lifetime to `cwd`, but the
+        // NOTE: `resolve_path::join_abs` ties the result lifetime to `cwd`, but the
         // returned slice always points into the threadlocal `PARSER_JOIN_INPUT_BUFFER`
         // (or is `cwd` itself when `parts.is_empty()`, which never happens here — we
         // pass exactly one part). Re-erase to `'static` so the resolver can hold it
@@ -120,7 +119,7 @@ mod bun_paths {
         let s = dispatch_platform!(platform, |P| ::bun_paths::resolve_path::join_abs::<P>(
             cwd, part
         ));
-        // SAFETY: see PORT NOTE — slice borrows threadlocal storage, valid 'static per-thread.
+        // SAFETY: see NOTE — slice borrows threadlocal storage, valid 'static per-thread.
         unsafe { bun_ptr::detach_lifetime(s) }
     }
     pub(super) fn join(parts: &[&[u8]], platform: Platform) -> &'static [u8] {
@@ -136,11 +135,10 @@ mod bun_paths {
             |P| ::bun_paths::resolve_path::join_string_buf::<P>(buf, parts)
         )
     }
-    /// Zig `bun.pathLiteral` — compile-time platform-separator literal. Zig
-    /// rewrites `/` → `\` at comptime; Rust can't transform a borrowed
-    /// `&'static [u8]` in a const fn, so this is a macro that emits a fresh
-    /// const array with the swap applied. Result is `&'static [u8; N]`
-    /// (coerces to `&[u8]`).
+    /// Compile-time platform-separator literal (`/` → `\` on Windows). A
+    /// const fn can't transform a borrowed `&'static [u8]`, so this is a
+    /// macro that emits a fresh const array with the swap applied. Result is
+    /// `&'static [u8; N]` (coerces to `&[u8]`).
     #[macro_export]
     #[doc(hidden)]
     macro_rules! __resolver_path_literal {
@@ -193,9 +191,8 @@ mod strings {
 mod bun_sys {
     pub(super) use ::bun_sys::*;
 
-    /// Port of `std.fs.openDirAbsoluteZ` — `open(path, O_DIRECTORY|O_RDONLY|O_CLOEXEC[|O_NOFOLLOW])`.
-    /// `opts.iterate` is a no-op on POSIX (Zig only used it to pick `iterate=true`
-    /// on `IterableDir`, which is just an open mode hint).
+    /// `open(path, O_DIRECTORY|O_RDONLY|O_CLOEXEC[|O_NOFOLLOW])`.
+    /// `opts.iterate` is a no-op on POSIX (just an open mode hint).
     #[cfg(not(windows))]
     pub(super) fn open_dir_absolute_z(
         path: &::bun_core::ZStr,
@@ -211,13 +208,13 @@ mod bun_sys {
         ::bun_sys::open(path, O::DIRECTORY | O::CLOEXEC | O::RDONLY | nofollow, 0)
             .map_err(Into::into)
     }
-    /// Port of `std.fs.Dir.openDirZ` — `openat(dir, path, O_DIRECTORY|O_RDONLY|O_CLOEXEC)`.
+    /// Opens a directory relative to `dir`: `openat(dir, path, O_DIRECTORY|O_RDONLY|O_CLOEXEC)`.
     pub(super) fn open_dir_z(
         dir: Fd,
         path: &[u8],
         _opts: OpenDirOptions,
     ) -> core::result::Result<Fd, ::bun_core::Error> {
-        // PORT NOTE: callers pass either a `&'static [u8]` literal or a NUL-terminated
+        // NOTE: callers pass either a `&'static [u8]` literal or a NUL-terminated
         // slice; `open_dir_at` builds its own ZStr internally so we strip the sentinel.
         let path = if path.last() == Some(&0) {
             &path[..path.len() - 1]
@@ -233,7 +230,7 @@ mod bun_sys {
 
 /// `bun_sys::Fd` extension surface — thin method-syntax wrappers over the
 /// free functions `::bun_sys::{close, get_fd_path}` and `Fd::native`, so the
-/// resolver body can spell `fd.close()` / `fd.get_fd_path(buf)` per the Zig.
+/// resolver body can spell `fd.close()` / `fd.get_fd_path(buf)`.
 trait FdExt: Sized {
     fn close(self);
     fn get_fd_path<'b>(
@@ -302,8 +299,7 @@ use bun_ast::SideEffects;
 // ── Process-lifetime arenas for DirInfo-cached parses ─────────────────────
 // The DirInfo cache (`DirInfo::hash_map_instance()`) is a true process-lifetime
 // singleton; entries hold `&'static PackageJSON` / `&'static TSConfigJSON` and
-// borrow `&'static [u8]` source bytes. Zig models this with `bun.TrivialNew`
-// (heap-allocate, never free). PORTING.md §Forbidden bars `Box::leak`/
+// borrow `&'static [u8]` source bytes. PORTING.md §Forbidden bars `Box::leak`/
 // `mem::forget` for this — process-lifetime storage must go through
 // `LazyLock`. These append-only arenas are that storage; the `Box<T>` heap
 // address is stable across `Vec` growth, so handing out `&'static T` is sound.
@@ -326,19 +322,21 @@ fn intern_package_json(pkg: PackageJSON) -> core::ptr::NonNull<PackageJSON> {
     core::ptr::NonNull::from(&mut **guard.last_mut().unwrap())
 }
 
-// Port of `const debuglog = Output.scoped(.Resolver, .hidden)` (resolver.zig:4).
 // `bun_core::declare_scope!` emits the per-scope `static ScopedLogger`; the
 // `debuglog!` macro forwards to the real `bun_core::scoped_log!` so debug builds
 // emit and release builds dead-strip (PORTING.md §Logging).
 //
-// PORT NOTE: resolver.zig:1692 also binds `const dev = Output.scoped(.Resolver,
-// .visible)` for `bustDirCache` — same scope name, different visibility. Rust's
-// `declare_scope!` is one static per ident; route both through the `.hidden`
-// declaration (matches the file-top binding) and let `BUN_DEBUG_Resolver=1`
-// surface the bust log.
 bun_core::define_scoped_log!(debuglog, Resolver, hidden);
 
-// PORT NOTE: `Path` in the body is the `'static`-interned variant (paths borrow
+// Used by `bustDirCache`. Same `Resolver` tag as `debuglog` above (so
+// `BUN_DEBUG_Resolver` controls both) but visible by default. `declare_scope!`
+// derives the tag from the static's ident, so this one is hand-declared to
+// keep the printed tag identical.
+#[allow(non_upper_case_globals)]
+static ResolverDev: bun_core::output::ScopedLogger =
+    bun_core::output::ScopedLogger::new("Resolver", bun_core::output::Visibility::Visible);
+
+// NOTE: `Path` in the body is the `'static`-interned variant (paths borrow
 // DirnameStore/FilenameStore). Alias here so the ~80 bare-`Path` use sites
 // resolve without a per-site lifetime annotation.
 type Path = crate::fs::Path<'static>;
@@ -367,8 +365,8 @@ pub struct Bufs {
     pub esm_absolute_package_path: PathBuffer,
     pub esm_absolute_package_path_joined: PathBuffer,
 
-    // PORT NOTE: Zig left this `= undefined`; `DirEntryResolveQueueItem` holds
-    // `&'static [u8]` fields, so a zeroed bit-pattern is UB in Rust. Use
+    // NOTE: `DirEntryResolveQueueItem` holds
+    // `&'static [u8]` fields, so a zeroed bit-pattern is UB. Use
     // `MaybeUninit` and `assume_init_{ref,mut}` at the (linear write-then-read)
     // use sites in `dir_info_cached_maybe_log`.
     pub dir_entry_paths_to_resolve: [core::mem::MaybeUninit<DirEntryResolveQueueItem>; 256],
@@ -400,10 +398,10 @@ pub struct Bufs {
 }
 // `Bufs` is modeled as a `thread_local! { static BUFS_PTR: BufsSlot }` caching a
 // leaked `Box<Bufs>` pointer. `BufsSlot`'s `Drop` reclaims that box when a
-// worker/transpiler-pool thread exits; the main thread's lives process-lifetime
-// (as in Zig, which never freed it). The `bufs!()` macro hands out `&mut` to a
+// worker/transpiler-pool thread exits; the main thread's lives process-lifetime.
+// The `bufs!()` macro hands out `&mut` to a
 // single field. This relies on the caller never holding two `bufs!()` borrows
-// simultaneously across the same field; the Zig code already obeys that invariant.
+// simultaneously across the same field.
 struct BufsSlot(core::cell::Cell<*mut Bufs>);
 impl Drop for BufsSlot {
     fn drop(&mut self) {
@@ -443,7 +441,7 @@ fn bufs_storage_init() -> *mut Bufs {
     // (`PathBuffer` = `[u8; N]`, `[FD; 256]` where `Fd` is a
     // `#[repr(C)]` integer newtype, `[MaybeUninit<_>; 256]` which has
     // no validity requirement, `()`), so EVERY bit-pattern — not just
-    // all-zero — is a valid `Bufs`. Zig left these `= undefined`; each
+    // all-zero — is a valid `Bufs`. Each
     // field is scratch (write-then-read within a single resolve call,
     // including `open_dirs` which is bounded by `open_dir_count`), so
     // there is no need to pay for zero-filling ~100 KiB on first use.
@@ -462,19 +460,16 @@ macro_rules! bufs {
 }
 
 // This is a global so even if multiple resolvers are created, the mutex will still work
-// TODO(port): `bun_threading::Mutex` has no `const fn new()`; use LazyLock until it does.
 // `pub(crate)` so the `fs::EntriesMap::inner` debug-assert can verify it is held
 // (the resolver mutex is one of the two documented guards for the entries singleton).
-pub(crate) static RESOLVER_MUTEX: std::sync::LazyLock<Mutex> =
-    std::sync::LazyLock::new(Mutex::default);
-// Zig had `resolver_Mutex_loaded` to lazily zero-init; Rust const init handles that.
+pub(crate) static RESOLVER_MUTEX: Mutex = Mutex::new();
 
 type BinFolderArray = BoundedArray<&'static [u8], 128>;
-// TODO(port): `BoundedArray` has no const constructor; init lazily under
-// `BIN_FOLDERS_LOADED` (matches Zig's `bin_folders_loaded` lazy zero-init).
+// `BoundedArray` has no const constructor; init lazily under
+// `BIN_FOLDERS_LOADED`.
 static BIN_FOLDERS: bun_core::RacyCell<core::mem::MaybeUninit<BinFolderArray>> =
     bun_core::RacyCell::new(core::mem::MaybeUninit::uninit());
-static BIN_FOLDERS_LOCK: std::sync::LazyLock<Mutex> = std::sync::LazyLock::new(Mutex::default);
+static BIN_FOLDERS_LOCK: Mutex = Mutex::new();
 static BIN_FOLDERS_LOADED: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
 
@@ -485,14 +480,10 @@ static BIN_FOLDERS_LOADED: core::sync::atomic::AtomicBool =
 // `Resolver.watcher` without a seam converter.
 pub use bun_watcher::AnyResolveWatcher;
 
-// Zig: `pub fn ResolveWatcher(comptime Context: type, comptime onWatch: anytype) type` —
-// type-generator returning a struct with `.init(ctx) -> AnyResolveWatcher` and a
-// monomorphized `watch` shim. Per PORTING.md (`fn Foo(comptime T) type` → `struct Foo<T>`).
-//
-// PORT NOTE: const fn-pointer generics (`adt_const_params` for fn ptrs) and
-// const params depending on type params are both forbidden. Reshape to a
-// runtime fn-pointer carried alongside the context — `init` produces the same
-// `AnyResolveWatcher` erased shim as Zig's monomorphized `wrap`.
+// NOTE: const fn-pointer generics (`adt_const_params` for fn ptrs) and
+// const params depending on type params are both forbidden. Carry a
+// runtime fn-pointer alongside the context — `init` produces the
+// `AnyResolveWatcher` erased shim.
 
 pub struct ResolveWatcher<C> {
     on_watch: fn(*mut C, &[u8], FD),
@@ -509,8 +500,8 @@ impl<C> ResolveWatcher<C> {
         AnyResolveWatcher {
             context: ctx.cast(),
             // SAFETY: `fn(*mut C, ..)` and `fn(*mut (), ..)` are ABI-identical
-            // (Rust-ABI, thin-ptr first arg); the `wrap` shim in Zig did the
-            // same erase. The callback body discharges its own type-recovery.
+            // (Rust-ABI, thin-ptr first arg). The callback body discharges its
+            // own type-recovery.
             callback: unsafe {
                 bun_ptr::cast_fn_ptr::<fn(*mut C, &[u8], FD), fn(*mut (), &[u8], FD)>(self.on_watch)
             },
@@ -520,7 +511,7 @@ impl<C> ResolveWatcher<C> {
 
 pub struct Resolver<'a> {
     pub opts: options::BundleOptions,
-    // PORT NOTE: Zig `fs: *Fs.FileSystem` / `log: *logger.Log` are raw aliasing
+    // NOTE: `fs` / `log` are raw aliasing
     // pointers — the bundler builds a `Resolver` per worker thread sharing the
     // process-wide `FileSystem` singleton, so `&'a mut` here would manufacture
     // aliased unique refs across threads (instant UB). Model as `*mut` /
@@ -529,8 +520,7 @@ pub struct Resolver<'a> {
     pub fs: *mut Fs::FileSystem,
     pub log: NonNull<bun_ast::Log>,
     // allocator dropped — global mimalloc
-    /// PORT NOTE: Zig stores `[]const []const u8` aliasing into
-    /// `r.opts.extension_order` and saves/restores it across nested resolves.
+    /// NOTE: saved/restored across nested resolves.
     /// Stored as a `Copy` enum tag (no self-reference) and resolved on demand
     /// via [`Self::extension_order`] / [`options::BundleOptions::ext_order_slice`].
     pub extension_order: options::ExtOrder,
@@ -555,20 +545,19 @@ pub struct Resolver<'a> {
     /// [`AutoInstaller`]; the resolver only sees the trait object so it stays
     /// below `bun_install` in the dep graph. The runtime/bundler that enables
     /// auto-install (`opts.global_cache != .disable`) is responsible for
-    /// constructing the `PackageManager` (Zig: `PackageManager.initWithRuntime`)
-    /// and assigning it here BEFORE resolution; the resolver no longer
-    /// constructs it lazily — that would require depending on `bun_install`,
+    /// constructing the `PackageManager`
+    /// and assigning it here BEFORE resolution; the resolver does not
+    /// construct it lazily — that would require depending on `bun_install`,
     /// which depends on us. When `None`, [`get_package_manager`] panics if the
     /// auto-install path is reached.
     pub package_manager: Option<NonNull<dyn AutoInstaller>>,
     pub on_wake_package_manager: Install::WakeHandler,
-    // Spec resolver.zig:477 `env_loader: ?*DotEnv.Loader` — raw nullable pointer.
     // Stored as `NonNull` (not `&'a Loader`) because the same allocation is
     // mutably reborrowed via `Transpiler.env: *mut Loader` after this field is
     // set (e.g. bake/production.rs assigns this then calls `configure_defines()`
     // → `run_env_loader()` which takes `&mut *self.env`). Holding a live
     // `&Loader` across that `&mut Loader` would be aliased-&mut UB; a raw
-    // pointer carries no aliasing guarantee and matches the Zig shape.
+    // pointer carries no aliasing guarantee.
     pub env_loader: Option<NonNull<DotEnv::Loader<'a>>>,
     pub store_fd: bool,
 
@@ -617,7 +606,7 @@ pub struct Resolver<'a> {
     /// This cache maps a directory path to information about that directory and
     /// all parent directories. When interacting with this structure, make sure
     /// to validate your keys with `Resolver.assertValidCacheKey`
-    // PORT NOTE: Zig `dir_cache: *DirInfo.HashMap` is a raw aliasing pointer to the
+    // NOTE: a raw aliasing pointer to the
     // `DirInfo::hash_map_instance()` singleton. Modeled as `*mut` (not `&'static mut`)
     // for the same reason as `fs`/`log` above — every per-worker `Resolver` shares the
     // singleton, so a `&'static mut` here would manufacture aliased unique refs (UB).
@@ -637,8 +626,7 @@ pub struct Resolver<'a> {
 }
 
 /// RAII guard returned by [`Resolver::scoped_log`]. Restores the previous
-/// `Resolver::log` pointer on drop — port of the Zig
-/// `defer resolver.log = orig_log` save/restore pattern.
+/// `Resolver::log` pointer on drop.
 pub struct ResolverLogScope {
     slot: *mut NonNull<bun_ast::Log>,
     prev: NonNull<bun_ast::Log>,
@@ -656,7 +644,7 @@ impl Drop for ResolverLogScope {
 
 impl<'a> Resolver<'a> {
     /// Per-worker constructor — replaces the bundler's prior bitwise
-    /// `transpiler.* = from.*` (Zig ThreadPool.zig:308) for the resolver
+    /// copy-from-`from` for the resolver
     /// portion. Every `Copy` / raw-pointer field is copied from `from`; the
     /// per-worker `caches` (the only `Drop`-carrying field, via the
     /// `Json` cache's `MimallocArena`) and `debug_logs`/`timer` are freshly
@@ -688,7 +676,6 @@ impl<'a> Resolver<'a> {
             debug_logs: None,
             elapsed: 0,
             watcher: from.watcher,
-            // Spec ThreadPool.zig:313 `transpiler.resolver.caches = CacheSet.Set.init(allocator)`.
             caches: CacheSet::init(),
             generation: from.generation,
             package_manager: from.package_manager,
@@ -715,16 +702,13 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    /// Port of Zig `r.fs` deref.
-    ///
-    /// PORT NOTE (Stacked Borrows): returns the RAW `*mut` (NOT `&'a mut`). A
+    /// NOTE (Stacked Borrows): returns the RAW `*mut` (NOT `&'a mut`). A
     /// `&'a mut` accessor would let two `fs()` calls manufacture coexisting
     /// aliased unique refs to the same singleton (PORTING.md §Forbidden:
     /// aliased-&mut), and any later `&mut *self.fs` retag would pop a previously
     /// returned `&'a mut`'s SB tag while it's still nominally live for `'a`.
     /// Callers must `unsafe { &mut *r.fs() }` at the narrowest use site and let
-    /// the projection die at end-of-expression. Spec resolver.zig:455 stores raw
-    /// `*Fs.FileSystem` and dereferences per-use.
+    /// the projection die at end-of-expression.
     #[inline(always)]
     pub fn fs(&self) -> *mut Fs::FileSystem {
         self.fs
@@ -762,7 +746,7 @@ impl<'a> Resolver<'a> {
     }
 
     /// Resolve the current [`options::ExtOrder`] tag to the slice it names
-    /// inside `self.opts`. Port of Zig `r.extension_order` field read.
+    /// inside `self.opts`.
     #[inline(always)]
     pub fn extension_order(&self) -> &[Box<[u8]>] {
         self.opts.ext_order_slice(self.extension_order)
@@ -770,7 +754,7 @@ impl<'a> Resolver<'a> {
 
     /// Raw-pointer projection to the inner `RealFS` (`self.fs.fs`).
     ///
-    /// PORT NOTE (Stacked Borrows): derived directly from the raw `*mut
+    /// NOTE (Stacked Borrows): derived directly from the raw `*mut
     /// FileSystem` field via `addr_of_mut!` so the resulting `*mut RealFS`
     /// carries SharedReadWrite provenance — later `fs_ref()` (Shared) or
     /// short-lived `&mut *self.fs()` retags do NOT invalidate it. Callers
@@ -784,9 +768,7 @@ impl<'a> Resolver<'a> {
         unsafe { core::ptr::addr_of_mut!((*self.fs).fs) }
     }
 
-    /// Port of Zig `r.log` deref.
-    ///
-    /// PORT NOTE (Stacked Borrows): returns RAW `*mut` (see `fs()` note). BACKREF
+    /// NOTE (Stacked Borrows): returns RAW `*mut` (see `fs()` note). BACKREF
     /// — owner (Transpiler/BundleV2) outlives the Resolver; worker clones share
     /// the same Log under the resolver mutex. Caller `unsafe { &mut *r.log() }`
     /// at each use site; do not bind the projected `&mut Log` across another
@@ -797,8 +779,7 @@ impl<'a> Resolver<'a> {
     }
 
     /// Temporarily redirect `self.log` to `log`, returning a guard that
-    /// restores the previous pointer on drop. Port of the Zig
-    /// `const orig = r.log; r.log = &tmp; defer r.log = orig;` pattern.
+    /// restores the previous pointer on drop.
     ///
     /// Takes a raw `*mut Self` (not `&mut self`) so the stored slot pointer
     /// carries SharedReadWrite provenance and stays valid under Stacked
@@ -854,9 +835,7 @@ impl<'a> Resolver<'a> {
         unsafe { self.log.as_mut() }
     }
 
-    /// Port of Zig `r.dir_cache` deref.
-    ///
-    /// PORT NOTE (Stacked Borrows): returns RAW `*mut` (see `fs()` note). ARENA —
+    /// NOTE (Stacked Borrows): returns RAW `*mut` (see `fs()` note). ARENA —
     /// `DirInfo::hash_map_instance()` singleton; never freed. Caller
     /// `unsafe { &mut *r.dir_cache() }` at each use site.
     #[inline(always)]
@@ -887,27 +866,24 @@ impl<'a> Resolver<'a> {
         unsafe { &mut *self.dir_cache }
     }
 
-    /// Port of resolver.zig `getPackageManager`. The Zig spec lazily calls
-    /// `PackageManager.initWithRuntime` here; in the Rust crate graph that
-    /// would be a `bun_resolver → bun_install` cycle, so the lazy init is
+    /// Lazily initializing
+    /// `PackageManager.initWithRuntime` here directly would
+    /// be a `bun_resolver → bun_install` cycle, so the lazy init is
     /// dispatched through the link-time `extern "Rust"` factory
     /// [`__bun_resolver_init_package_manager`] (defined `#[no_mangle]` in
     /// `bun_install::auto_installer`). The factory performs
     /// `HTTPThread.init` + `PackageManager.initWithRuntime` and returns the
     /// process-static singleton as a `dyn AutoInstaller`. We then wire
-    /// `on_wake` and cache the pointer — exactly the Zig body. Reached from
+    /// `on_wake` and cache the pointer. Reached from
     /// the auto-install path (`load_node_modules` global-cache block) when
     /// [`use_package_manager`] is `true`.
     pub fn get_package_manager(&mut self) -> *mut dyn AutoInstaller {
         if let Some(pm) = self.package_manager {
             return pm.as_ptr();
         }
-        // Zig: `bun.HTTPThread.init(&.{}); const pm = PackageManager.initWithRuntime(
-        //     this.log, this.opts.install, bun.default_allocator, .{}, this.env_loader.?);`
         // SAFETY: `DotEnv::Loader<'a>` is layout-identical across `'a`;
         // `init_with_runtime` only borrows it for the synchronous init (the
-        // static `PackageManager` retains a raw `NonNull<Loader<'static>>`,
-        // matching Zig's untracked `*DotEnv.Loader` aliasing).
+        // static `PackageManager` retains a raw `NonNull<Loader<'static>>`).
         let env: NonNull<DotEnv::Loader<'static>> = self
             .env_loader
             .expect("Resolver.env_loader must be set before auto-install")
@@ -919,7 +895,6 @@ impl<'a> Resolver<'a> {
         // names the `PackageManager` singleton (`'static`).
         let pm: NonNull<dyn AutoInstaller> =
             unsafe { __bun_resolver_init_package_manager(self.log, self.opts.install, env) };
-        // Zig: `pm.onWake = this.onWakePackageManager;`
         // SAFETY: `pm` is the just-initialized singleton; sole `&mut` here.
         unsafe { (*pm.as_ptr()).set_on_wake(self.on_wake_package_manager) };
         self.package_manager = Some(pm);
@@ -994,10 +969,9 @@ impl<'a> Resolver<'a> {
         Resolver {
             // allocator dropped
             // Route through the per-monomorphization singleton so this field and
-            // `DirInfo::get_parent()` / `get_enclosing_browser_scope()` share storage
-            // (Zig `BSSMap.init()` is a per-type singleton, not a fresh alloc).
+            // `DirInfo::get_parent()` / `get_enclosing_browser_scope()` share storage.
             dir_cache: DirInfo::hash_map_instance(),
-            mutex: &*RESOLVER_MUTEX,
+            mutex: &RESOLVER_MUTEX,
             caches: CacheSet::init(),
             opts,
             timer: Timer::start().unwrap_or_else(|_| panic!("Timer fail")),
@@ -1055,9 +1029,9 @@ impl<'a> Resolver<'a> {
         kind: ast::ImportKind,
         out: &mut MatchResult,
     ) -> MatchStatus {
-        // SAFETY: PORT — `import_path` is caller-interned (DirnameStore/source text)
-        // and outlives the returned MatchResult. Zig used raw `[]const u8` here.
-        // TODO(port): thread an explicit `'a` through MatchResult instead.
+        // SAFETY: `import_path` is caller-interned (DirnameStore/source text)
+        // and outlives the returned MatchResult.
+        // TODO: thread an explicit `'a` through MatchResult instead.
         let import_path: &'static [u8] = unsafe { &*std::ptr::from_ref::<[u8]>(import_path) };
         if source_dir.is_empty() {
             return MatchStatus::NotFound;
@@ -1081,8 +1055,7 @@ impl<'a> Resolver<'a> {
         &mut self,
         flush_mode: FlushMode,
     ) -> core::result::Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: capture `log` before partially borrowing `self.debug_logs`
+        // NOTE: capture `log` before partially borrowing `self.debug_logs`
         // so the method call doesn't conflict with the field borrow (`log()`
         // derefs the raw `*mut Log` and is lifetime-decoupled from `&self`).
         // SAFETY: BACKREF — `self.log` points at owner-allocated `Log`; disjoint from
@@ -1090,7 +1063,7 @@ impl<'a> Resolver<'a> {
         // `self.debug_logs.as_mut()` borrow below.
         let log = unsafe { &mut *self.log() };
         if let Some(debug) = self.debug_logs.as_mut() {
-            // PORT NOTE: spec resolver.zig:650-658 — only consume `what`/`notes` inside
+            // NOTE: only consume `what`/`notes` inside
             // the arm that actually emits, so the success-at-non-verbose path touches
             // nothing. `add_range_debug_with_notes`/`add_verbose_with_notes` take
             // `&'static [u8]`; bypass them and build the `Msg` directly so the Log owns
@@ -1146,9 +1119,9 @@ impl<'a> Resolver<'a> {
         kind: ast::ImportKind,
         global_cache: GlobalCache,
     ) -> ResultUnion {
-        // SAFETY: PORT — `import_path` is caller-interned (source text / DirnameStore)
-        // and outlives the returned Result. Zig used raw `[]const u8` here.
-        // TODO(port): thread an explicit lifetime through Result instead.
+        // SAFETY: `import_path` is caller-interned (source text / DirnameStore)
+        // and outlives the returned Result.
+        // TODO: thread an explicit lifetime through Result instead.
         let import_path: &'static [u8] = unsafe { &*std::ptr::from_ref::<[u8]>(import_path) };
         let _tracer = ::bun_perf::trace(::bun_perf::PerfEvent::ModuleResolverResolve);
 
@@ -1165,12 +1138,25 @@ impl<'a> Resolver<'a> {
                 bstr::BStr::new(import_path),
                 bstr::BStr::new(source_dir),
             );
-            // @breakpoint() — no Rust equiv; left as TODO(port)
+            // Trap into an attached debugger.
+            // NOTE: `core::arch::breakpoint()` is still unstable on the pinned
+            // toolchain; emit the trap instruction directly via stable `asm!`.
+            #[cfg(target_arch = "x86_64")]
+            // SAFETY: `int3` only raises SIGTRAP/EXCEPTION_BREAKPOINT; no memory or
+            // register state is touched.
+            unsafe {
+                core::arch::asm!("int3")
+            };
+            #[cfg(target_arch = "aarch64")]
+            // SAFETY: `brk` only raises SIGTRAP/EXCEPTION_BREAKPOINT; no memory or
+            // register state is touched.
+            unsafe {
+                core::arch::asm!("brk #0xf000")
+            };
         }
 
         let original_order = self.extension_order;
-        // PORT NOTE: Zig `defer r.extension_order = original_order` — reshaped for
-        // borrowck so the restore happens explicitly at every return point below.
+        // NOTE: the restore happens explicitly at every return point below.
         self.extension_order = match kind {
             ast::ImportKind::Url | ast::ImportKind::AtConditional | ast::ImportKind::At => {
                 options::ExtOrder::Css
@@ -1186,8 +1172,8 @@ impl<'a> Resolver<'a> {
             self.timer.reset();
         }
 
-        // Spec resolver.zig:703-707: `defer { if (tracing) r.elapsed += r.timer.read() }`
-        // — fires on EVERY return path. Capture raw field ptrs (Copy) so the closure
+        // The tracing-elapsed accumulation
+        // fires on EVERY return path. Capture raw field ptrs (Copy) so the closure
         // does not hold a `&mut self` borrow across the function body.
         let elapsed_ptr: *mut u64 = core::ptr::addr_of_mut!(self.elapsed);
         let timer_ptr: *const Timer = core::ptr::addr_of!(self.timer);
@@ -1513,8 +1499,30 @@ impl<'a> Resolver<'a> {
 
                 let _ = self.flush_debug_logs(FlushMode::Success);
                 result.import_kind = kind;
-                if cfg!(feature = "debug_logs") {
-                    // TODO(port): debuglog! with bun.fmt.fmtPath formatting
+                if cfg!(debug_assertions) {
+                    // `debuglog!` self-gates on `debug_assertions`, the outer `if`
+                    // dead-strips the `resolved_text` computation in release too.
+                    let resolved_text: &[u8] =
+                        result.path().map_or(&b"<NULL>"[..], |path| path.text());
+                    let opts = bun_core::fmt::PathFormatOptions::default;
+                    if let Some(secondary) = result.path_pair.secondary.as_ref() {
+                        debuglog!(
+                            "resolve({}, from: {}, {}) = {} (secondary: {})",
+                            bun_core::fmt::fmt_path(import_path, opts()),
+                            bun_core::fmt::fmt_path(source_dir, opts()),
+                            bstr::BStr::new(kind.label()),
+                            bun_core::fmt::fmt_path(resolved_text, opts()),
+                            bun_core::fmt::fmt_path(secondary.text(), opts()),
+                        );
+                    } else {
+                        debuglog!(
+                            "resolve({}, from: {}, {}) = {}",
+                            bun_core::fmt::fmt_path(import_path, opts()),
+                            bun_core::fmt::fmt_path(source_dir, opts()),
+                            bstr::BStr::new(kind.label()),
+                            bun_core::fmt::fmt_path(resolved_text, opts()),
+                        );
+                    }
                 }
                 ResultUnion::Success(result)
             }
@@ -1543,7 +1551,6 @@ impl<'a> Resolver<'a> {
         import_path: &[u8],
         kind: ast::ImportKind,
     ) -> core::result::Result<Result, bun_core::Error> {
-        // TODO(port): narrow error set
         match self.resolve_and_auto_install(source_dir, import_path, kind, GlobalCache::disable) {
             ResultUnion::Success(result) => Ok(result),
             ResultUnion::Pending(_) | ResultUnion::NotFound => {
@@ -1561,10 +1568,9 @@ impl<'a> Resolver<'a> {
         import_path: &[u8],
         kind: ast::ImportKind,
     ) -> core::result::Result<Result, bun_core::Error> {
-        // SAFETY: PORT — `import_path` is caller-interned (source text / DirnameStore)
-        // and outlives the returned Result. TODO(port): thread explicit lifetime.
+        // SAFETY: `import_path` is caller-interned (source text / DirnameStore)
+        // and outlives the returned Result. TODO: thread an explicit lifetime.
         let import_path: &'static [u8] = unsafe { &*std::ptr::from_ref::<[u8]>(import_path) };
-        // TODO(port): narrow error set
         if let Some(f) = self.opts.framework.as_ref() {
             if let Some(mod_) = f.built_in_modules.get(import_path) {
                 match mod_ {
@@ -1583,7 +1589,7 @@ impl<'a> Resolver<'a> {
                         });
                     }
                     bun_options_types::BuiltInModule::Import(path) => {
-                        // PORT NOTE: copy out `path` so the `&self.opts.framework` borrow
+                        // NOTE: copy out `path` so the `&self.opts.framework` borrow
                         // ends before `self.resolve(&mut self, ...)`.
                         // SAFETY: `path` borrows `self.opts.framework`, which lives for the
                         // resolver's lifetime; the `'static` erase only releases the `&self` borrow.
@@ -1593,7 +1599,6 @@ impl<'a> Resolver<'a> {
                         return self.resolve(top, path, ast::ImportKind::EntryPointBuild);
                     }
                 }
-                // unreachable in Zig (return after switch)
             }
         }
         self.resolve(source_dir, import_path, kind)
@@ -1604,7 +1609,6 @@ impl<'a> Resolver<'a> {
         result: &mut Result,
         kind: ast::ImportKind,
     ) -> core::result::Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if result.flags.is_external() {
             return Ok(());
         }
@@ -1741,7 +1745,7 @@ impl<'a> Resolver<'a> {
                         let parts = [dir.abs_real_path, query.entry().base()];
                         let mut buf = bun_paths::PathBuffer::uninit();
 
-                        // PORT NOTE: `abs_buf` returns a borrow of `buf`; capture only the
+                        // NOTE: `abs_buf` returns a borrow of `buf`; capture only the
                         // length so `buf` can be re-borrowed for null-termination below.
                         let out_len = self.fs_ref().abs_buf(&parts, &mut buf).len();
 
@@ -1751,9 +1755,8 @@ impl<'a> Resolver<'a> {
                             buf[out_len] = 0;
                             // SAFETY: buf[out_len] == 0 written above
                             let span = bun_core::ZStr::from_buf(&buf[..], out_len);
-                            // Spec resolver.zig:1099 uses `try std.fs.openFileAbsoluteZ`,
-                            // which propagates I/O errors so `resolveAndAutoInstall` can
-                            // return them as `Result.Union.failure`. Mirror that — never
+                            // I/O errors propagate so `resolveAndAutoInstall` can
+                            // return them as `Result.Union.failure` — never
                             // panic on EACCES/EMFILE/ELOOP here.
                             let file = bun_sys::open(span, bun_sys::O::RDONLY, 0)
                                 .map_err(Into::<bun_core::Error>::into)?;
@@ -1761,7 +1764,7 @@ impl<'a> Resolver<'a> {
                             Fs::FileSystem::set_max_fd(file.native());
                         }
 
-                        // PORT NOTE: snapshot `need_to_close_files` and raw-ptr the entry so
+                        // NOTE: snapshot `need_to_close_files` and raw-ptr the entry so
                         // the closure captures only Copy values — keeps `self` and
                         // `query.entry` reborrowable across the guard's lifetime.
                         let need_close = self.fs_ref().fs.need_to_close_files();
@@ -2211,7 +2214,7 @@ impl<'a> Resolver<'a> {
         }
 
         let prev_extension_order = self.extension_order;
-        // PORT NOTE: defer restore reshaped — restored before each return
+        // NOTE: defer restore reshaped — restored before each return
         if strings::path_contains_node_modules_folder(abs_path) {
             self.extension_order = self.opts.extension_order.kind(kind, true);
         }
@@ -2274,9 +2277,9 @@ impl<'a> Resolver<'a> {
                     debug_assert!(is_package_path(import_path));
                 }
                 let mut closest_dir = source_dir;
-                // Use std.fs.path.dirname to get `null` once the entire
-                // directory tree has been visited. `null` is theoretically
-                // impossible since the drive root should always exist.
+                // `dirname` returns `None` once the entire directory tree
+                // has been visited. `None` is theoretically impossible since
+                // the drive root should always exist.
                 while let Some(current) = bun_paths::dirname(closest_dir) {
                     match self.dir_info_cached(current) {
                         Err(_) => return ResultUnion::NotFound,
@@ -2568,7 +2571,7 @@ impl<'a> Resolver<'a> {
         let first_bust = self.fs_mut().fs.bust_entries_cache(path);
         let second_bust = self.dir_cache_mut().remove(path);
         bun_core::scoped_log!(
-            Resolver,
+            ResolverDev,
             "Bust {} = {}, {}",
             bstr::BStr::new(path),
             first_bust,
@@ -2614,11 +2617,11 @@ impl<'a> Resolver<'a> {
         &mut self,
         import_path: &[u8],
         kind: ast::ImportKind,
-        // PORT NOTE: `DirInfoRef` (not `&mut`) — body re-enters `dir_cache` via
+        // NOTE: `DirInfoRef` (not `&mut`) — body re-enters `dir_cache` via
         // `dir_info_cached()` which, in the self-reference branch, returns the
         // SAME BSSMap slot. A `&mut` param carries an FnEntry protector under
         // Stacked Borrows; the inner retag would pop it (aliased-&mut UB).
-        // Spec resolver.zig:1761 takes raw `*DirInfo`; the arena handle Derefs
+        // The arena handle Derefs
         // to `&DirInfo` per use so overlapping shared reads are sound.
         _dir_info: DirInfoRef,
         global_cache: GlobalCache,
@@ -2634,8 +2637,7 @@ impl<'a> Resolver<'a> {
             ));
             debug.increase_indent();
         }
-        // PORT NOTE: Zig `defer { debug.decreaseIndent() }` — reshaped for borrowck;
-        // `decrease_indent()` is called explicitly at every return point below.
+        // NOTE: `decrease_indent()` is called explicitly at every return point below.
 
         // First, check path overrides from the nearest enclosing TypeScript "tsconfig.json" file
 
@@ -2751,7 +2753,7 @@ impl<'a> Resolver<'a> {
                     }
 
                     let prev_extension_order = self.extension_order;
-                    // PORT NOTE: defer restore reshaped — restored at end of block
+                    // NOTE: defer restore reshaped — restored at end of block
 
                     if let Some(ref esm) = esm_ {
                         let abs_package_path: &[u8] = if is_self_reference {
@@ -2774,9 +2776,7 @@ impl<'a> Resolver<'a> {
                                 if let Some(exports_map) = package_json.exports.as_ref() {
                                     // The condition set is determined by the kind of import
                                     let mut module_type = package_json.module_type;
-                                    // PORT NOTE: reshaped for borrowck — Zig held a single `ESModule`
-                                    // with a raw `*DebugLogs` across both `resolve` calls and the
-                                    // intervening `handle_esm_resolution`. In Rust, keeping the
+                                    // NOTE: keeping a single
                                     // `ESModule` (which holds `&mut self.debug_logs`) alive across a
                                     // `&mut self` call is aliased-&mut UB. Build a fresh short-lived
                                     // `ESModule` per `resolve` call so its borrow ends before
@@ -2893,7 +2893,7 @@ impl<'a> Resolver<'a> {
                                             d.decrease_indent();
                                         }
                                         *out = MatchResult {
-                                            // PORT NOTE: PackageJSON.source.path is bun_paths::fs::Path<'static>; convert
+                                            // NOTE: PackageJSON.source.path is bun_paths::fs::Path<'static>; convert
                                             // to the resolver's interned crate::fs::Path<'static> via its text.
                                             path_pair: PathPair {
                                                 primary: Path::init(package_json.source.path.text),
@@ -2901,7 +2901,7 @@ impl<'a> Resolver<'a> {
                                             },
                                             dirname_fd: pkg_dir_info.get_file_descriptor(),
                                             file_fd: FD::INVALID,
-                                            // Spec resolver.zig:1930 — `Path.isNodeModule()` checks
+                                            // `Path.isNodeModule()` checks
                                             // `lastIndexOf(name.dir, SEP++"node_modules"++SEP)`, i.e. a
                                             // separator-bounded directory component on `name.dir` (not a
                                             // bare substring of the full text). `bun_paths::fs::Path<'static>`
@@ -2994,7 +2994,7 @@ impl<'a> Resolver<'a> {
                 // If the source directory doesn't have a node_modules directory, we can
                 // check the global cache directory for a package.json file.
                 //
-                // PORT NOTE (Stacked Borrows): `get_package_manager` returns the
+                // NOTE (Stacked Borrows): `get_package_manager` returns the
                 // `*mut dyn AutoInstaller` raw pointer; the body below re-borrows
                 // `self` for `enqueue_dependency_to_resolve` / `debug_logs` /
                 // `log()`. The PackageManager lives in a separate allocation, so
@@ -3120,8 +3120,7 @@ impl<'a> Resolver<'a> {
                     match self.enqueue_dependency_to_resolve(
                         // Read the raw `NonNull` fields directly (NOT the
                         // `&'static`-yielding accessors) so mut-provenance from
-                        // `intern_package_json` survives to the write inside
-                        // (Zig: resolver.zig:2074).
+                        // `intern_package_json` survives to the write inside.
                         dir_info
                             .package_json_for_dependencies
                             .or(dir_info.package_json),
@@ -3165,9 +3164,9 @@ impl<'a> Resolver<'a> {
                         if err == bun_core::err!("FileNotFound") {
                             match manager!().get_preinstall_state(resolved_package_id) {
                                 Install::PreinstallState::Done => {
-                                    // PORT NOTE: `MatchResult.path_pair` is `Path<'static>`;
+                                    // NOTE: `MatchResult.path_pair` is `Path<'static>`;
                                     // intern `import_path` so the disabled-module record
-                                    // outlives this frame (Zig had no lifetime here).
+                                    // outlives this frame.
                                     let interned = Fs::file_system::DirnameStore::instance()
                                         .append_slice(import_path)
                                         .expect("unreachable");
@@ -3252,7 +3251,7 @@ impl<'a> Resolver<'a> {
                             if let Some(package_json) = pkg_dir_info.package_json() {
                                 if let Some(exports_map) = package_json.exports.as_ref() {
                                     // The condition set is determined by the kind of import
-                                    // PORT NOTE: reshaped for borrowck — see identical note above.
+                                    // NOTE: reshaped for borrowck — see identical note above.
                                     // Resolve against the path "/", then join it with the absolute
                                     // directory path. This is done because ESM package resolution uses
                                     // URLs while our path resolution uses file system paths. We don't
@@ -3415,7 +3414,6 @@ impl<'a> Resolver<'a> {
         dir_path_maybe_trail_slash: &[u8],
         package_id: Install::PackageID,
     ) -> core::result::Result<Option<DirInfoRef>, bun_core::Error> {
-        // TODO(port): narrow error set
         debug_assert!(self.package_manager.is_some());
 
         let dir_path = strings::without_trailing_slash_windows_path(dir_path_maybe_trail_slash);
@@ -3446,7 +3444,7 @@ impl<'a> Resolver<'a> {
         // resolver mutex held; `EntriesMap` methods are safe wrappers over the singleton.
         let mut cached_dir_entry_result = rfs!().entries.get_or_put(dir_path)?;
 
-        // PORT NOTE: always assigned by either the cached-hit arm or the
+        // NOTE: always assigned by either the cached-hit arm or the
         // `needs_iter` block below; null-init so rustc accepts the proof.
         let mut dir_entries_option: *mut Fs::file_system::real_fs::EntriesOption =
             core::ptr::null_mut();
@@ -3515,7 +3513,7 @@ impl<'a> Resolver<'a> {
             }
             if let Some(existing) = in_place {
                 // SAFETY: see block-wide note above.
-                // PORT NOTE: Zig `clearAndFree` — `StringHashMap` (std::HashMap newtype)
+                // NOTE: `StringHashMap` (std::HashMap newtype)
                 // has no separate `clear_and_free`; `clear()` drops all entries.
                 unsafe { &mut *existing }.data.clear();
             }
@@ -3523,7 +3521,7 @@ impl<'a> Resolver<'a> {
             if self.store_fd {
                 new_entry.fd = open_dir;
             }
-            // PORT NOTE: see `dir_info_cached_maybe_log` — `DirEntry.data` holds a `NonNull`,
+            // NOTE: see `dir_info_cached_maybe_log` — `DirEntry.data` holds a `NonNull`,
             // so a zeroed slot is UB; box `new_entry` directly for the fresh case.
             let dir_entries_ptr = match in_place {
                 Some(p) => {
@@ -3534,7 +3532,15 @@ impl<'a> Resolver<'a> {
                 None => bun_core::heap::into_raw(Box::new(new_entry)),
             };
 
-            // bun.fs.debug("readdir({f}, {s}) = {d}", ...) — TODO(port): scoped log
+            bun_core::scoped_log!(
+                crate::fs_full::Fs,
+                "readdir({}, {}) = {}",
+                open_dir,
+                bstr::BStr::new(dir_path),
+                // SAFETY: `dir_entries_ptr` is a live BSSMap slot (`in_place`) or a freshly
+                // boxed entry (see block-wide note above).
+                unsafe { (*dir_entries_ptr).data.count() },
+            );
 
             dir_entries_option = rfs!()
                 .entries
@@ -3550,7 +3556,7 @@ impl<'a> Resolver<'a> {
 
         // We must initialize it as empty so that the result index is correct.
         // This is important so that browser_scope has a valid index.
-        // PORT NOTE: erase the `&mut DirInfo` borrow to `*mut` immediately so
+        // NOTE: erase the `&mut DirInfo` borrow to `*mut` immediately so
         // `self.dir_cache` (and `*self`) are reborrowable for the call below.
         let dir_info_ptr: *mut DirInfo::DirInfo = self
             .dir_cache_mut()
@@ -3586,7 +3592,7 @@ impl<'a> Resolver<'a> {
 
     fn enqueue_dependency_to_resolve(
         &mut self,
-        // PORT NOTE: Zig `package_json_: ?*PackageJSON` (mutable). Carried as
+        // NOTE: carried as
         // `NonNull` end-to-end so the mut-provenance from `intern_package_json`
         // survives to the `package_manager_package_id` write below — taking
         // `*const` and casting back to `*mut` would be UB under Stacked Borrows.
@@ -3606,7 +3612,7 @@ impl<'a> Resolver<'a> {
         }
 
         let input_package_id = *input_package_id_;
-        // PORT NOTE: see `manager_ptr` note in `load_node_modules` — split the
+        // NOTE: see `manager_ptr` note in `load_node_modules` — split the
         // `&mut self` borrow by holding the PackageManager via raw pointer.
         let pm_ptr: *mut dyn AutoInstaller = self.get_package_manager();
         macro_rules! pm {
@@ -3629,10 +3635,9 @@ impl<'a> Resolver<'a> {
                 // from `NonNull::from(&mut **last)` and no other live borrow
                 // exists here.
                 let package_json: &mut PackageJSON = unsafe { package_json.as_mut() };
-                // PORT NOTE: Zig called `Package.fromPackageJSON(lockfile, pm,
-                // log, package_json, features)` then `setHasInstallScript` then
-                // `lockfile.appendPackage`. The `Package` type is bun_install-
-                // internal; the `AutoInstaller` impl performs all three steps.
+                // NOTE: the `Package` type is bun_install-internal; the
+                // `AutoInstaller` impl performs the from-package-json /
+                // setHasInstallScript / appendPackage steps.
                 let id = match pm!().lockfile_append_from_package_json(
                     package_json,
                     Install::Features {
@@ -3697,10 +3702,7 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        // PORT NOTE: 1:1 with Zig — `resolver.zig` ends this function with
-        // `bun.unreachablePanic("TODO: implement enqueueDependencyToResolve for
-        // non-root packages", .{})`. The non-root path is genuinely unimplemented
-        // in the Zig source; this is not a porting stub.
+        // NOTE: the non-root path is genuinely unimplemented; this is not a stub.
         unreachable!("TODO: implement enqueueDependencyToResolve for non-root packages")
     }
 
@@ -3795,7 +3797,7 @@ impl<'a> Resolver<'a> {
                                         ));
                                     }
                                     esm_resolution.status = Status::ModuleNotFoundMissingExtension;
-                                    let _ = ext; // PORT NOTE: Zig stored `missing_suffix = ext` here; unused after `return null`.
+                                    let _ = ext;
                                     break;
                                 }
                             }
@@ -3919,9 +3921,8 @@ impl<'a> Resolver<'a> {
 
     pub fn resolve_without_remapping(
         &mut self,
-        // PORT NOTE: `DirInfoRef` (not `&mut`) — forwards into `load_node_modules`
+        // NOTE: `DirInfoRef` (not `&mut`) — forwards into `load_node_modules`
         // which re-enters `dir_cache` and may re-derive the same DirInfo slot.
-        // Spec resolver.zig:2584 takes raw `*DirInfo`.
         source_dir_info: DirInfoRef,
         import_path: &[u8],
         kind: ast::ImportKind,
@@ -3949,7 +3950,7 @@ impl<'a> Resolver<'a> {
         // Since tsconfig.json is cached permanently, in our DirEntries cache
         // we must use the global allocator
         let mut entry = self.caches.fs.read_file_with_allocator(
-            // SAFETY: process-global `FileSystem` singleton (see `fs()` PORT NOTE); narrow `&mut`
+            // SAFETY: process-global `FileSystem` singleton (see `fs()` NOTE); narrow `&mut`
             // for this call only — `self.caches` is a field of `self` (disjoint allocation).
             unsafe { &mut *self.fs() },
             file,
@@ -3958,7 +3959,7 @@ impl<'a> Resolver<'a> {
             None,
             None,
         )?;
-        // PORT NOTE: reshaped for borrowck — `mem::take` the contents (leaving
+        // NOTE: reshaped for borrowck — `mem::take` the contents (leaving
         // `Contents::Empty` behind) so `entry` stays whole for the close-guard.
         let entry_contents = core::mem::take(&mut entry.contents);
         let _close_guard = scopeguard::guard(entry, |mut e| {
@@ -3975,11 +3976,9 @@ impl<'a> Resolver<'a> {
             .expect("unreachable");
 
         // `use_shared_buffer = false` above, so `entry_contents` is
-        // `Contents::Owned`/`Empty`. Zig reads with `bun.default_allocator` and
-        // never frees because the Zig `TSConfigJSON` borrows slices into the
-        // source; the Rust `TSConfigJSON` owns `Box<[u8]>` copies of every
-        // field, so the source bytes are dead once `parse` returns and can be
-        // dropped with the local `Source`.
+        // `Contents::Owned`/`Empty`. `TSConfigJSON` owns `Box<[u8]>` copies of
+        // every field, so the source bytes are dead once `parse` returns and
+        // can be dropped with the local `Source`.
         let contents = match entry_contents {
             crate::cache::Contents::Owned(v) => v,
             crate::cache::Contents::Empty => Vec::new(),
@@ -3989,7 +3988,7 @@ impl<'a> Resolver<'a> {
         let source = bun_ast::Source::init_path_string_owned(key_path, contents);
         let file_dir = source.path.source_dir();
 
-        // SAFETY: BACKREF — `self.log` (see `log()` PORT NOTE); disjoint from `self.caches`,
+        // SAFETY: BACKREF — `self.log` (see `log()` NOTE); disjoint from `self.caches`,
         // narrow `&mut` for this call only.
         let mut result =
             match TSConfigJSON::parse(unsafe { &mut *self.log() }, &source, &mut self.caches.json)?
@@ -4001,10 +4000,9 @@ impl<'a> Resolver<'a> {
         if result.has_base_url() {
             // this might leak
             if !bun_paths::is_absolute(&result.base_url) {
-                // PORT NOTE: Zig interns into `dirname_store` and stores the
-                // arena slice; Rust `base_url: Box<[u8]>` owns its bytes, so
+                // NOTE: `base_url: Box<[u8]>` owns its bytes, so
                 // copy `abs_buf`'s thread-local result directly instead of
-                // double-copying through the arena.
+                // double-copying through the `dirname_store` arena.
                 let abs = self
                     .fs_ref()
                     .abs_buf(&[file_dir, &result.base_url[..]], bufs!(tsconfig_base_url));
@@ -4023,8 +4021,7 @@ impl<'a> Resolver<'a> {
             result.base_url_for_paths = Box::from(abs);
         }
 
-        // PORT NOTE: Zig `TSConfigJSON.parse` returns `*TSConfigJSON` (already
-        // heap). Return the `Box` so the caller (`dir_info_uncached`) takes
+        // NOTE: return the `Box` so the caller (`dir_info_uncached`) takes
         // ownership — intermediate configs in an extends-chain are dropped via
         // `heap::take`, the final one is interned into the DirInfo cache.
         Ok(Some(result))
@@ -4046,7 +4043,7 @@ impl<'a> Resolver<'a> {
         package_id: Option<Install::PackageID>,
     ) -> core::result::Result<Option<core::ptr::NonNull<PackageJSON>>, bun_core::Error> {
         use crate::package_json::{IncludeDependencies, IncludeScripts};
-        // PORT NOTE: Zig threaded both as comptime params; `IncludeDependencies` is a
+        // NOTE: `IncludeDependencies` is a
         // const generic on `PackageJSON::parse`, `IncludeScripts` is runtime (it only
         // gates one branch).
         let include_scripts = if self.care_about_scripts {
@@ -4073,8 +4070,7 @@ impl<'a> Resolver<'a> {
         };
         let Some(pkg) = pkg else { return Ok(None) };
 
-        // PORT NOTE: Zig `PackageJSON.new` = `bun.TrivialNew` (heap-allocate,
-        // never freed — DirInfo cache holds `&'static` refs). PORTING.md
+        // NOTE: the DirInfo cache holds `&'static` refs. PORTING.md
         // §Forbidden bars `Box::leak`; intern into the process-lifetime arena
         // owned alongside the DirInfo singleton instead.
         Ok(Some(intern_package_json(pkg)))
@@ -4099,8 +4095,7 @@ impl<'a> Resolver<'a> {
         self.dir_info_cached_maybe_log(false, path).ok().flatten()
     }
 
-    // PORT NOTE: Zig's `dirInfoCachedMaybeLog` takes `comptime enable_logging`
-    // and `comptime follow_symlinks`. `follow_symlinks` is `true` at every call
+    // NOTE: `follow_symlinks` is `true` at every call
     // site, so it's dropped here; `enable_logging` is a plain runtime parameter
     // (it gates one cold error-formatting branch) so this large dir-walk function
     // monomorphizes to a single copy instead of two faulted in at startup.
@@ -4109,7 +4104,6 @@ impl<'a> Resolver<'a> {
         enable_logging: bool,
         raw_input_path: &[u8],
     ) -> core::result::Result<Option<DirInfoRef>, bun_core::Error> {
-        // TODO(port): narrow error set
         // `self.mutex` is `&'static Mutex` (Copy) — bind it first so the guard
         // doesn't keep `self` borrowed across the body.
         let _unlock = self.mutex.lock_guard();
@@ -4228,7 +4222,7 @@ impl<'a> Resolver<'a> {
         let root_path = &path[0..1];
         Self::assert_valid_cache_key(root_path);
 
-        // PORT NOTE: hold RealFS as a raw `*mut` so the entries-mutex/close-dirs
+        // NOTE: hold RealFS as a raw `*mut` so the entries-mutex/close-dirs
         // scopeguards can capture it by Copy without keeping a `self.rfs_ptr()`
         // borrow live across the loop body (which calls `&mut self` methods).
         // SAFETY: ARENA — `self.fs` points at the process-global FileSystem singleton.
@@ -4332,10 +4326,10 @@ impl<'a> Resolver<'a> {
         let open_dir_count = core::cell::Cell::new(0usize);
 
         // When this function halts, any item not processed means it's not found.
-        // PORT NOTE: capture only what the cleanup needs by-value (store_fd) / by-Cell
+        // NOTE: capture only what the cleanup needs by-value (store_fd) / by-Cell
         // (open_dir_count) so the guard doesn't pin `&mut self` across the loop
-        // body. `need_to_close_files()` is evaluated AT DROP TIME (matching
-        // Zig's `defer`), not snapshotted up-front — the loop body calls
+        // body. `need_to_close_files()` is evaluated AT DROP TIME,
+        // not snapshotted up-front — the loop body calls
         // `Fs.FileSystem.setMaxFd()` which can flip `needToCloseFiles()`
         // mid-walk. Reach the RealFS via the `&'static` singleton accessor
         // instead of capturing a raw `*mut RealFS` (the read is `&self`-only).
@@ -4418,8 +4412,12 @@ impl<'a> Resolver<'a> {
                         .map_err(Into::into)
                     };
 
-                    // bun.fs.debug("open({s})", .{sentinel}) — TODO(port): scoped log
-                    // Restore the byte we NUL-terminated above (Zig: `defer path[len] = prev_char`).
+                    bun_core::scoped_log!(
+                        crate::fs_full::Fs,
+                        "open({})",
+                        bstr::BStr::new(sentinel.as_bytes()),
+                    );
+                    // Restore the byte we NUL-terminated above.
                     // No early-return path exists between the write and here, so a guard is unnecessary.
                     path[nul_at] = prev_char;
 
@@ -4490,7 +4488,7 @@ impl<'a> Resolver<'a> {
                 if _safe_path.is_none() {
                     // Now that we've opened the topmost directory successfully, it's reasonable to store the slice.
                     // `path` spans `input_path_len + 1` for the NUL-splice above; the
-                    // logical input is `path[..input_path_len]` (Zig resolver.zig:2750).
+                    // logical input is `path[..input_path_len]`.
                     let input = &path[..input_path_len];
                     if input[input.len() - 1] != SEP {
                         let parts: [&[u8]; 2] = [input, SEP_STR.as_bytes()];
@@ -4502,13 +4500,12 @@ impl<'a> Resolver<'a> {
 
                 let safe_path = _safe_path.unwrap();
 
-                // Spec resolver.zig:2965 calls `std.mem.indexOf` (returns 0 for an
-                // empty needle), not `bun.strings.indexOf` (returns null for an
-                // empty needle). On Windows `queue_top_unsafe_path` is empty when
+                // An empty needle must yield index 0, not None. On Windows
+                // `queue_top_unsafe_path` is empty when
                 // `windows_filesystem_root` cannot classify the input — e.g.
                 // `import(":://x")` is "absolute" per std but has no drive root,
-                // so `root_path` is `path[0..0]`. Match the spec so the resolver
-                // caches a not-found instead of panicking.
+                // so `root_path` is `path[0..0]`. Treat that as 0 so the
+                // resolver caches a not-found instead of panicking.
                 let dir_path_i = if queue_top_unsafe_path.is_empty() {
                     0
                 } else {
@@ -4569,10 +4566,8 @@ impl<'a> Resolver<'a> {
                 new_entry.data.reserve(64);
 
                 let mut dir_iterator = bun_sys::iterate_dir(open_dir);
-                // PORT NOTE: Zig `while (dir_iterator.next().unwrap()) |entry|` —
-                // `.unwrap()` was on the inner `Maybe(?Entry)`; the Rust `WrappedIterator::next`
-                // is already flattened to `Result<Option<IteratorResult>>`, so the `.unwrap()`
-                // moved to `?`-style break-on-error.
+                // NOTE: `WrappedIterator::next` returns
+                // `Result<Option<IteratorResult>>`, so use `?`-style break-on-error.
                 // Hoist the `FilenameStore` singleton resolve out of the per-entry loop
                 // (see `DirEntry::add_entry` doc-comment) and reuse the appender state.
                 let mut filename_store = FilenameStoreAppender::new();
@@ -4594,12 +4589,11 @@ impl<'a> Resolver<'a> {
                 }
                 if let Some(existing) = in_place {
                     // SAFETY: see block-wide note above.
-                    // PORT NOTE: Zig `clear_and_free`; bun_collections::StringHashMap exposes `clear`.
+                    // NOTE: bun_collections::StringHashMap exposes `clear`, which drops all entries.
                     unsafe { &mut *existing }.data.clear();
                 }
                 new_entry.fd = if self.store_fd { open_dir } else { FD::INVALID };
-                // PORT NOTE: Zig `entries_ptr = in_place orelse allocator.create(DirEntry)` then
-                // `entries_ptr.* = new_entry` (no drop glue). `DirEntry.data` is a `HashMap`
+                // NOTE: `DirEntry.data` is a `HashMap`
                 // (`NonNull` inside), so a zeroed slot is UB and `*ptr = new_entry` would drop it.
                 // Box `new_entry` directly for the fresh case; assign-into only for `in_place`.
                 let dir_entries_ptr = match in_place {
@@ -4610,6 +4604,19 @@ impl<'a> Resolver<'a> {
                     }
                     None => bun_core::heap::into_raw(Box::new(new_entry)),
                 };
+                // NOTE (Stacked Borrows): log BEFORE `entries.put` stores the
+                // `&'static mut DirEntry` — a later read through the parent raw
+                // pointer would pop that reference's Unique tag (the ordering
+                // is unobservable).
+                bun_core::scoped_log!(
+                    crate::fs_full::Fs,
+                    "readdir({}, {}) = {}",
+                    open_dir,
+                    bstr::BStr::new(dir_path),
+                    // SAFETY: `dir_entries_ptr` is a live BSSMap slot (`in_place`) or a
+                    // freshly boxed entry (see block-wide note above).
+                    unsafe { (*dir_entries_ptr).data.count() },
+                );
                 dir_entries_option = rfs!().entries.put(
                     &mut cached_dir_entry_result,
                     Fs::file_system::real_fs::EntriesOption::Entries(
@@ -4617,19 +4624,17 @@ impl<'a> Resolver<'a> {
                         unsafe { &mut *dir_entries_ptr },
                     ),
                 )?;
-                // bun.fs.debug("readdir({f}, {s}) = {d}", ...) — TODO(port): scoped log
             }
 
             // We must initialize it as empty so that the result index is correct.
             // This is important so that browser_scope has a valid index.
-            // PORT NOTE: erase the `&mut DirInfo` borrow to `*mut` immediately so
+            // NOTE: erase the `&mut DirInfo` borrow to `*mut` immediately so
             // `self.dir_cache` (and `*self`) are reborrowable for the call below.
-            // SAFETY: ARENA — `dir_cache()` singleton (see PORT NOTE). Stacked Borrows: bind
+            // SAFETY: ARENA — `dir_cache()` singleton (see NOTE). Stacked Borrows: bind
             // ONE `&mut HashMap` and derive BOTH slot pointers from it so they share a parent
             // tag — a second `&mut *self.dir_cache()` Unique retag of the whole `BSSMapInner`
             // (whose `backing_buf` is inline) would pop `dir_info_ptr`'s tag before
-            // `dir_info_uncached` writes through it. Spec resolver.zig:3022/3030 routes both
-            // through the single raw `r.dir_cache: *HashMap` with no intermediate retag.
+            // `dir_info_uncached` writes through it.
             // NOTE: erasing `&mut V` to `*mut V` does NOT, by itself, survive a sibling Unique
             // retag of the parent allocation; the shared `dc` parent is what keeps both live.
             let dc = self.dir_cache_mut();
@@ -4658,13 +4663,9 @@ impl<'a> Resolver<'a> {
 
                 // Is the directory we're searching for actually a file?
             } else if queue_slice_len == 1 {
-                // const next_in_queue = queue_slice[0];
-                // const next_basename = std.fs.path.basename(next_in_queue.unsafe_path);
-                // if (dir_info_ptr.getEntries(r.generation)) |entries| {
-                //     if (entries.get(next_basename) != null) {
-                //         return null;
-                //     }
-                // }
+                // (Unimplemented fast path: if this directory's entries already
+                // contain the next queue entry's basename, the "directory" being
+                // searched for is actually a file and resolution could bail early.)
             }
         }
 
@@ -4706,7 +4707,7 @@ impl<'a> Resolver<'a> {
 
         // Check for exact matches first
         {
-            // PORT NOTE: ArrayHashMap has no `&self` (key,value) iterator; zip the
+            // NOTE: ArrayHashMap has no `&self` (key,value) iterator; zip the
             // parallel `keys()`/`values()` slices (insertion order).
             for (key, value) in tsconfig
                 .paths
@@ -4863,12 +4864,11 @@ impl<'a> Resolver<'a> {
     pub fn load_package_imports(
         &mut self,
         import_path: &[u8],
-        // PORT NOTE: `DirInfoRef` (not `&mut`) — `handle_esm_resolution` re-enters
+        // NOTE: `DirInfoRef` (not `&mut`) — `handle_esm_resolution` re-enters
         // `dir_cache` via `dir_info_cached(dirname(abs_esm_path))`; for any
         // imports-map entry resolving to `./<file>` that dirname equals
         // `dir_info.abs_path`, re-deriving `&mut` to the SAME slot while a
         // `&mut` param's FnEntry protector is live is aliased-&mut UB.
-        // Spec resolver.zig:3182 takes raw `*DirInfo`.
         dir_info: DirInfoRef,
         kind: ast::ImportKind,
         global_cache: GlobalCache,
@@ -4882,7 +4882,7 @@ impl<'a> Resolver<'a> {
                 bstr::BStr::new(package_json.source.path.text)
             ));
             debug.increase_indent();
-            // defer debug.decreaseIndent() — TODO(port): missing matching decrease in Zig too
+            // No matching `decreaseIndent()` — the indent is intentionally leaked here.
         }
         let imports_map = package_json.imports.as_ref().unwrap();
 
@@ -4897,9 +4897,9 @@ impl<'a> Resolver<'a> {
         }
         let mut module_type = options::ModuleType::Unknown;
 
-        // PORT NOTE: reshaped for borrowck — Zig kept a raw `*DebugLogs` inside
-        // `ESModule` across the subsequent `&mut self` calls. In Rust that is
-        // aliased-&mut UB, so the `ESModule` is constructed as a temporary whose
+        // NOTE: keeping the `ESModule`'s borrow of `self.debug_logs` alive
+        // across the subsequent `&mut self` calls would be aliased-&mut UB, so
+        // the `ESModule` is constructed as a temporary whose
         // borrow of `self.debug_logs` ends as soon as `resolve_imports` returns.
         let esm_resolution = ESModule {
             conditions: match kind {
@@ -5062,9 +5062,9 @@ impl<'a> Resolver<'a> {
     pub fn load_from_main_field(
         &mut self,
         path: &[u8],
-        // PORT NOTE: `DirInfoRef` (not `&mut`) — `get_enclosing_browser_scope()`
-        // may return `dir_info` itself (resolver.zig:4161 self-browser-scope),
-        // which would alias a live `&mut`. Spec uses raw `*DirInfo`.
+        // NOTE: `DirInfoRef` (not `&mut`) — `get_enclosing_browser_scope()`
+        // may return `dir_info` itself (self-browser-scope),
+        // which would alias a live `&mut`.
         dir_info: DirInfoRef,
         _field_rel_path: &[u8],
         field: &[u8],
@@ -5171,10 +5171,10 @@ impl<'a> Resolver<'a> {
         r
     }
 
-    // nodeModulePathsForJS / Resolver__propForRequireMainPaths: see src/jsc/resolver_jsc.zig
-    // (no Zig callers; exported to C++ only)
+    // nodeModulePathsForJS / Resolver__propForRequireMainPaths: see src/jsc/resolver_jsc.rs
+    // (exported to C++ only)
 
-    // PORT NOTE: `dir_info` is a `DirInfoRef` (matching spec `*DirInfo`) so
+    // NOTE: `dir_info` is a `DirInfoRef` (matching spec `*DirInfo`) so
     // `load_index_with_extension` may re-borrow without aliasing the caller's `&mut`.
     pub fn load_as_index(
         &mut self,
@@ -5183,7 +5183,7 @@ impl<'a> Resolver<'a> {
         out: &mut MatchResult,
     ) -> MatchStatus {
         // Try the "index" file with extensions
-        // PORT NOTE: index by `0..len` so each iteration takes a fresh short
+        // NOTE: index by `0..len` so each iteration takes a fresh short
         // borrow of `self.opts` that ends before `&mut self` is taken by
         // `load_index_with_extension` (matches `extra_cjs_extensions` loop below).
         let n = self.opts.ext_order_slice(extension_order).len();
@@ -5199,7 +5199,7 @@ impl<'a> Resolver<'a> {
                 return MatchStatus::Success;
             }
         }
-        // PORT NOTE: index by `0..len` so each iteration takes a fresh short
+        // NOTE: index by `0..len` so each iteration takes a fresh short
         // borrow of `self.opts` that ends before `&mut self` is taken by
         // `load_index_with_extension` (avoids the forbidden lifetime-extension cast).
         let n = self.opts.extra_cjs_extensions.len();
@@ -5305,9 +5305,9 @@ impl<'a> Resolver<'a> {
 
     pub fn load_as_index_with_browser_remapping(
         &mut self,
-        // PORT NOTE: `DirInfoRef` (not `&mut`) — `get_enclosing_browser_scope()`
-        // may return `dir_info` itself (resolver.zig:4161 self-browser-scope),
-        // which would alias a live `&mut`. Spec uses raw `*DirInfo`.
+        // NOTE: `DirInfoRef` (not `&mut`) — `get_enclosing_browser_scope()`
+        // may return `dir_info` itself (self-browser-scope),
+        // which would alias a live `&mut`.
         dir_info: DirInfoRef,
         path_: &[u8],
         extension_order: options::ExtOrder,
@@ -5465,7 +5465,7 @@ impl<'a> Resolver<'a> {
             }};
         }
 
-        // PORT NOTE: `DirInfoRef` (matching spec resolver.zig:3674 raw `*DirInfo`).
+        // NOTE: `DirInfoRef` (not `&mut`).
         // The callees fetch `get_enclosing_browser_scope()` which can resolve
         // back to this same BSSMap slot — holding a `&mut` here would alias.
         let dir_info: DirInfoRef = match self.dir_info_cached(path) {
@@ -5494,11 +5494,9 @@ impl<'a> Resolver<'a> {
                 // never mutated during resolve.
                 let main_field_keys = bun_ptr::RawSlice::<Box<[u8]>>::new(&self.opts.main_fields);
                 let mf_ext_order = options::ExtOrder::MainField;
-                // Spec resolver.zig compares the *pointer* of `opts.main_fields`
-                // against the per-target default to detect "user did not pass
-                // --main-fields"; the bundler now projects that as an explicit
-                // bool because the owned `Box<[Box<[u8]>]>` can never alias a
-                // static.
+                // The bundler projects "user did not pass --main-fields" as an
+                // explicit bool because the owned `Box<[Box<[u8]>]>` can never
+                // alias a static default to compare pointers against.
                 let auto_main = self.opts.main_fields_is_default;
 
                 if let Some(debug) = self.debug_logs.as_mut() {
@@ -5653,8 +5651,7 @@ impl<'a> Resolver<'a> {
         path: &[u8],
         extension_order: options::ExtOrder,
     ) -> Option<LoadResult> {
-        // SAFETY: PORT — RealFS is the global singleton (fs.zig); Zig held a raw
-        // pointer here (resolver.zig:3784). Derive provenance from the raw
+        // SAFETY: RealFS is the global singleton. Derive provenance from the raw
         // `*mut FileSystem` field so intervening `unsafe { &mut *self.fs() }` calls in
         // `load_extension` / `dirname_store.append_slice` don't invalidate `rfs`
         // under Stacked Borrows. We re-borrow `&mut *rfs` at each use site.
@@ -5771,7 +5768,7 @@ impl<'a> Resolver<'a> {
 
         // Try the path with extensions
         bufs!(load_as_file)[..path.len()].copy_from_slice(path);
-        // PORT NOTE: index by `0..len` so each iteration takes a fresh short
+        // NOTE: index by `0..len` so each iteration takes a fresh short
         // borrow of `self.opts` that ends before `&mut self` is taken by
         // `load_extension` (matches `extra_cjs_extensions` loop below).
         let n = self.opts.ext_order_slice(extension_order).len();
@@ -5785,7 +5782,7 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        // PORT NOTE: index by `0..len` so each iteration takes a fresh short
+        // NOTE: index by `0..len` so each iteration takes a fresh short
         // borrow of `self.opts` that ends before `&mut self` is taken by
         // `load_extension` (avoids the forbidden lifetime-extension cast).
         let n = self.opts.extra_cjs_extensions.len();
@@ -5815,8 +5812,7 @@ impl<'a> Resolver<'a> {
         // https://github.com/microsoft/TypeScript/issues/4595
         if let Some(last_dot) = strings::last_index_of_char(base, b'.') {
             let ext = &base[last_dot..base.len()];
-            // PORT NOTE: spec resolver.zig:3890-3891 — Zig `and` binds tighter than `or`, so the
-            // node_modules gate only applies to the `.mjs` arm. Mirror that precedence exactly.
+            // NOTE: the node_modules gate only applies to the `.mjs` arm.
             if ext == b".js"
                 || ext == b".jsx"
                 || (ext == b".mjs"
@@ -5999,17 +5995,16 @@ impl<'a> Resolver<'a> {
     ) -> core::result::Result<(), bun_core::Error> {
         let result = _result;
 
-        // SAFETY: PORT — RealFS / DirEntry are global ARENA singletons (BSSMap-backed);
-        // Zig held raw pointers here (resolver.zig:4004 `rfs: *Fs.FileSystem.RealFS`).
+        // SAFETY: RealFS / DirEntry are global ARENA singletons (BSSMap-backed).
         // Derive `rfs_ptr` from the raw `*mut FileSystem` field so later `unsafe { &mut *self.fs() }` calls
         // (`abs_buf` / `dirname_store.append_slice` in the parent-symlink block) cannot
         // invalidate it under Stacked Borrows. Re-borrow at EACH use site so no `&mut`
         // outlives a `unsafe { &mut *self.fs() }` / `get_entries()` / `parse_package_json()` call.
-        // TODO(port): split RealFS borrow once entries iteration is interior-mutability-backed.
+        // TODO: split RealFS borrow once entries iteration is interior-mutability-backed.
         let rfs_ptr: *mut Fs::file_system::RealFS = self.rfs_ptr();
         // SAFETY: caller passes `_entries` as a live slot in the global BSSMap-backed entries cache (ARENA).
         let entries_ptr: *mut Fs::file_system::DirEntry = unsafe { &mut *_entries }.entries_mut();
-        // PORT NOTE: re-borrow per use; see SAFETY note above.
+        // NOTE: re-borrow per use; see SAFETY note above.
         macro_rules! rfs {
             () => {
                 // SAFETY: `rfs_ptr` points at the process-global RealFS singleton; see note above.
@@ -6174,7 +6169,7 @@ impl<'a> Resolver<'a> {
                 if parent_package_json.dependencies.map.count() > 0
                     || parent_package_json.package_manager_package_id != Install::INVALID_PACKAGE_ID
                 {
-                    // PORT NOTE: store the raw `NonNull` field (not the
+                    // NOTE: store the raw `NonNull` field (not the
                     // `&'static` accessor result) so mut-provenance flows
                     // through to `enqueue_dependency_to_resolve`.
                     info.package_json_for_dependencies = parent_.package_json;
@@ -6224,7 +6219,7 @@ impl<'a> Resolver<'a> {
                         } else if !parent_.abs_real_path.is_empty() {
                             // this might leak a little i'm not sure
                             let parts = [parent_.abs_real_path, base];
-                            // PORT NOTE: split into two statements so the two `&mut FileSystem`
+                            // NOTE: split into two statements so the two `&mut FileSystem`
                             // borrows from `unsafe { &mut *self.fs() }` don't overlap (Stacked Borrows).
                             let joined = self
                                 .fs_ref()
@@ -6312,7 +6307,7 @@ impl<'a> Resolver<'a> {
                         if pkg.dependencies.map.count() > 0
                             || pkg.package_manager_package_id != Install::INVALID_PACKAGE_ID
                         {
-                            // PORT NOTE: store the raw `NonNull` field (not the
+                            // NOTE: store the raw `NonNull` field (not the
                             // `&'static` accessor result) so mut-provenance flows
                             // through to `enqueue_dependency_to_resolve`.
                             info.package_json_for_dependencies = info.package_json;
@@ -6366,7 +6361,7 @@ impl<'a> Resolver<'a> {
                     }
                 }
             } else if parent.is_none() {
-                // PORT NOTE: re-borrow as 'static so the `&self.opts` borrow ends before
+                // NOTE: re-borrow as 'static so the `&self.opts` borrow ends before
                 // `self.parse_tsconfig(&mut self, ...)`. `tsconfig_override` is owned by
                 // BundleOptions (lives for the resolver's lifetime).
                 // SAFETY: `tsconfig_override` is owned by `self.opts` (resolver-lifetime);
@@ -6417,10 +6412,11 @@ impl<'a> Resolver<'a> {
                         None
                     }
                 };
-                // PORT NOTE: spec resolver.zig:4207 assigns info.tsconfig_json here (a raw
-                // ?*TSConfigJSON), then frees that allocation in the merge loop below before
-                // reassigning. With Rust references (Option<&'static TSConfigJSON>, dir_info.rs)
-                // that briefly-dangling state is UB. Defer the assignment to after the merge —
+                // NOTE: assigning info.tsconfig_json here and then freeing that
+                // allocation in the merge loop below before reassigning would
+                // leave a briefly-dangling reference
+                // (Option<&'static TSConfigJSON>, dir_info.rs) — UB.
+                // Defer the assignment to after the merge —
                 // it is always overwritten when parsed_tsconfig.is_some(), and DirInfo defaults
                 // tsconfig_json to None otherwise.
                 if let Some(tsconfig_json) = parsed_tsconfig {
@@ -6496,12 +6492,9 @@ impl<'a> Resolver<'a> {
                         // "not defined" from "defined as {}" — the latter clears inherited
                         // paths per TypeScript semantics.
                         if !parent_config.base_url_for_paths.is_empty() {
-                            // The previous merged_config.paths is being replaced; free its
-                            // backing storage before overwriting so the PathsMap from the
-                            // deeper config doesn't leak. Each value is a []string slice
-                            // that was separately heap-allocated in TSConfigJSON.parse()
-                            // (tsconfig_json.zig), so free those before the map itself.
-                            // (In Rust, dropping the map frees values automatically.)
+                            // The previous merged_config.paths is being replaced;
+                            // dropping the map frees the values automatically, so the
+                            // PathsMap from the deeper config doesn't leak.
                             mc.paths = core::mem::take(&mut parent_config.paths);
                             mc.base_url_for_paths =
                                 core::mem::take(&mut parent_config.base_url_for_paths);
@@ -6535,24 +6528,25 @@ impl<'a> Resolver<'a> {
 }
 
 impl<'a> Resolver<'a> {
-    /// Port of `pub fn deinit(r: *ThisResolver)` (resolver.zig:601-604).
-    ///
-    /// PORT NOTE: NOT `impl Drop` — the bundler builds a `Resolver` per worker
+    /// NOTE: NOT `impl Drop` — the bundler builds a `Resolver` per worker
     /// thread (see `for_worker`), and all instances share the same `dir_cache`
     /// singleton. A `Drop` impl would fire once per worker going out of scope,
     /// resetting the SHARED cache (freeing PackageJSON/TSConfigJSON, closing cached
-    /// fds) while other live Resolvers still hold pointers into it. Spec calls
-    /// `deinit` explicitly exactly once at shutdown; mirror that.
+    /// fds) while other live Resolvers still hold pointers into it. Call
+    /// `deinit` explicitly exactly once at shutdown.
     pub fn deinit(&mut self) {
         // Caller is the sole remaining owner at shutdown; no other Resolver alias is live.
         for di in self.dir_cache_mut().values_mut() {
-            // Zig: `di.deinit()` — releases owned PackageJSON / TSConfigJSON resources
+            // `DirInfo::reset` releases owned PackageJSON / TSConfigJSON resources
             // in-place (side effects beyond memory: those Drops close cached fds /
-            // deref intrusive refcounts). Ported as `DirInfo::reset`.
+            // deref intrusive refcounts).
             di.reset();
         }
-        // dir_cache is &'static — do not deinit the singleton here
-        // TODO(port): Zig calls dir_cache.deinit() but it's a global BSSMap; revisit ownership
+        // dir_cache is &'static — do not deinit the singleton here. `dir_cache`
+        // is the process-global
+        // BSSMap singleton (`DirInfo.HashMap` / `hash_map_instance()`); the
+        // entries' owned resources are released by the `reset()` loop above and
+        // the map storage itself lives for the process.
     }
 }
 
@@ -6591,7 +6585,7 @@ impl<'b> BrowserMapPath<'b> {
             // cache is process-global); the `'b` borrow on `map` artificially shortens
             // what is process-lifetime storage. `Interned` is the canonical proof type.
             self.remapped = unsafe { bun_ptr::Interned::assume(result) }.as_bytes();
-            // SAFETY: TODO(port): lifetime — extending borrow of caller-owned slice; consumed before checker is dropped.
+            // SAFETY: extending borrow of caller-owned slice; consumed before checker is dropped (TODO: thread explicit lifetime).
             self.input_path = unsafe { &*std::ptr::from_ref::<[u8]>(path_to_check) };
             return true;
         }
@@ -6615,7 +6609,7 @@ impl<'b> BrowserMapPath<'b> {
                 if let Some(_remapped) = map.get(new_path) {
                     // SAFETY: ARENA — see `result` note above.
                     self.remapped = unsafe { bun_ptr::Interned::assume(_remapped) }.as_bytes();
-                    // SAFETY: TODO(port): lifetime — `new_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite.
+                    // SAFETY: `new_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite (TODO: thread explicit lifetime).
                     self.cleaned = unsafe { &*std::ptr::from_ref::<[u8]>(new_path) };
                     // SAFETY: same as above.
                     self.input_path = unsafe { &*std::ptr::from_ref::<[u8]>(new_path) };
@@ -6642,7 +6636,7 @@ impl<'b> BrowserMapPath<'b> {
         if let Some(_remapped) = map.get(index_path) {
             // SAFETY: ARENA — see `result` note above.
             self.remapped = unsafe { bun_ptr::Interned::assume(_remapped) }.as_bytes();
-            // SAFETY: TODO(port): lifetime — `index_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite.
+            // SAFETY: `index_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite (TODO: thread explicit lifetime).
             self.input_path = unsafe { &*std::ptr::from_ref::<[u8]>(index_path) };
             return true;
         }
@@ -6663,7 +6657,7 @@ impl<'b> BrowserMapPath<'b> {
                 if let Some(_remapped) = map.get(new_path) {
                     // SAFETY: ARENA — see `result` note above.
                     self.remapped = unsafe { bun_ptr::Interned::assume(_remapped) }.as_bytes();
-                    // SAFETY: TODO(port): lifetime — `new_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite.
+                    // SAFETY: `new_path` borrows the threadlocal `extension_path` buf; consumed before next overwrite (TODO: thread explicit lifetime).
                     self.cleaned = unsafe { &*std::ptr::from_ref::<[u8]>(new_path) };
                     // SAFETY: same as above.
                     self.input_path = unsafe { &*std::ptr::from_ref::<[u8]>(new_path) };
@@ -6688,10 +6682,8 @@ fn is_dot_slash(path: &[u8]) -> bool {
     }
 }
 
-// ModuleTypeMap = bun.ComptimeStringMap(options.ModuleType, .{...})
-//
-// PERF(port): was `phf::Map<&[u8], ModuleType>`. With only 4 keys — all
-// length 4 — the phf hash + index probe is strictly more work than a single
+// PERF: with only 4 keys — all length 4 — a `phf::Map<&[u8], ModuleType>`
+// hash + index probe would be strictly more work than a single
 // length gate followed by 4-byte compares (which LLVM lowers to one u32
 // load + compare per arm once `len == 4` is established). Mirrors the
 // length-gated dispatch used in `clap::find_param`.
@@ -6710,15 +6702,11 @@ fn module_type_from_ext(ext: &[u8]) -> Option<options::ModuleType> {
 const NODE_MODULE_ROOT_STRING: &[u8] =
     const_format::concatcp!(SEP_STR, "node_modules", SEP_STR).as_bytes();
 
-// `dev` scope (Output.scoped(.Resolver, .visible)) — same scope name as `debuglog` but visible.
-// Folded into the same `Resolver` declared scope; TODO(port): restore the visible/hidden
-// scope distinction.
-
 pub struct Dirname;
 
 impl Dirname {
-    /// NOT `std.fs.path.dirname`. Resolver-specific upward-traversal dirname
-    /// (resolver.zig:4297): returns trailing-sep-INCLUSIVE slice, never `None`,
+    /// Resolver-specific upward-traversal dirname:
+    /// returns trailing-sep-INCLUSIVE slice, never `None`,
     /// `is_sep_any` on all platforms. Do NOT replace with `bun_core::dirname`.
     pub fn dirname(path: &[u8]) -> &[u8] {
         if path.is_empty() {
@@ -6775,5 +6763,3 @@ pub struct RootPathPair<'b> {
     pub base_path: &'b [u8],
     pub package_json: *const PackageJSON,
 }
-
-// ported from: src/resolver/resolver.zig
diff --git a/src/resolver/result.rs b/src/resolver/result.rs
index 85095a5ec1c..b87be5428c1 100644
--- a/src/resolver/result.rs
+++ b/src/resolver/result.rs
@@ -21,13 +21,17 @@ use crate::options;
 use crate::package_json::PackageJSON;
 use crate::resolver::Dependency;
 
-// PORT NOTE: `Path` in the body is the `'static`-interned variant (paths borrow
+// NOTE: `Path` in the body is the `'static`-interned variant (paths borrow
 // DirnameStore/FilenameStore). Alias here so the bare-`Path` use sites resolve
 // without a per-site lifetime annotation.
 type Path = crate::fs::Path<'static>;
 
 pub struct SideEffectsData {
-    pub source: Option<NonNull<bun_ast::Source>>, // TODO(port): lifetime — never instantiated
+    // Modeled as
+    // `Option<NonNull>`: no constructor ever
+    // populates the field, so `None` stands in for the
+    // never-written pointer until lifetime modeling is actually needed.
+    pub source: Option<NonNull<bun_ast::Source>>,
     pub range: bun_ast::Range,
 
     // If true, "sideEffects" was an array. If false, "sideEffects" was false.
@@ -49,7 +53,7 @@ impl Default for PathPair {
 }
 
 pub(crate) struct PathPairIter<'a> {
-    index: u8, // u2 in Zig
+    index: u8,
     ctx: &'a mut PathPair,
 }
 
@@ -93,8 +97,8 @@ impl PathPair {
 }
 
 // Re-export of `bun_ast::SideEffects`.
-// Spec: options.zig:884 `Loader.sideEffects()` returns `bun.resolver.SideEffects`
-// — the SAME type stored in `Result.primary_side_effects_data`. Re-export so
+// `Loader.sideEffects()` returns
+// the SAME type stored in `Result.primary_side_effects_data`. Re-export so
 // `result.primary_side_effects_data = loader.side_effects()` type-checks.
 use bun_ast::SideEffects;
 
@@ -137,7 +141,7 @@ impl Default for Result {
             debug_meta: None,
             dirname_fd: FD::INVALID,
             file_fd: FD::INVALID,
-            import_kind: ast::ImportKind::Stmt, // Zig: undefined
+            import_kind: ast::ImportKind::Stmt,
             flags: ResultFlags::default(),
         }
     }
@@ -161,7 +165,7 @@ bitflags::bitflags! {
     }
 }
 
-// Convenience accessors mirroring the Zig packed-struct field syntax.
+// Convenience accessors with field-style names.
 impl ResultFlags {
     #[inline]
     pub fn is_external(self) -> bool {
@@ -339,7 +343,7 @@ impl DebugMeta {
         r: bun_ast::Range,
         args: core::fmt::Arguments<'_>,
     ) -> core::result::Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+        // Uses the broad `bun_core::Error` per repo-wide convention.
         if source.is_some() && !self.suggestion_message.is_empty() {
             let suggestion_range = if self.suggestion_range == SuggestionRange::End {
                 bun_ast::Range {
@@ -352,10 +356,8 @@ impl DebugMeta {
                 r
             };
             let data = bun_ast::range_data(source, suggestion_range, self.suggestion_message);
-            // PORT NOTE: Zig spec writes `data.location.?.suggestion = m.suggestion_text`
-            // here, but `logger.Location` (logger.zig:73) has no `suggestion` field —
-            // `logErrorMsg` is uncalled in the Zig source so the field access is never
-            // type-checked under lazy compilation. Mirror the effective behavior (no-op).
+            // NOTE: `logger.Location` has no `suggestion` field, so
+            // `suggestion_text` is intentionally unused (no-op).
             let _ = &self.suggestion_text;
             self.notes.push(data);
         }
@@ -374,7 +376,7 @@ impl DebugMeta {
 
 pub struct DirEntryResolveQueueItem {
     pub result: allocators::Result,
-    // PORT NOTE: `RawSlice<u8>` (not `&'static [u8]`) — these point into the
+    // NOTE: `RawSlice<u8>` (not `&'static [u8]`) — these point into the
     // threadlocal `dir_info_uncached_path` buffer and are consumed before
     // `dir_info_cached_maybe_log` returns. `RawSlice` is `repr(transparent)`
     // over `*const [u8]` so the bit-level zero-init invariant for `Bufs` is
@@ -439,7 +441,7 @@ impl DebugLogs {
         })
     }
 
-    // deinit → Drop (only frees `notes`; `indent` deinit was commented out in Zig)
+    // deinit → Drop (only frees `notes`)
 
     #[cold]
     pub fn increase_indent(&mut self) {
@@ -550,8 +552,8 @@ impl Default for PendingResolution {
 }
 
 impl PendingResolution {
-    // PORT NOTE: deinitListItems → Drop on MultiArrayList<PendingResolution>
-    // (Zig body only freed `dependency` + `string_buf` per item; both are owned fields with Drop.)
+    // NOTE: deinitListItems → Drop on MultiArrayList<PendingResolution>
+    // (`dependency` + `string_buf` are owned fields with Drop.)
 
     // deinit → Drop (frees dependency + string_buf; both have Drop)
 
@@ -560,9 +562,7 @@ impl PendingResolution {
         dependency: Dependency::Version,
         resolution_id: Install::PackageID,
     ) -> core::result::Result<PendingResolution, bun_core::Error> {
-        // PORT NOTE: Zig body called `try esm.copy(allocator)` and left `string_buf`
-        // / `tag` defaulted; that fn was never compiled (Zig lazy-analyzes unreferenced
-        // fns). `Package::copy` is the count→allocate→clone Builder dance the live
+        // NOTE: `Package::copy` is the count→allocate→clone Builder dance the live
         // call sites open-code, so thread the freshly-allocated buffer into
         // `string_buf` here so `Drop` frees what backs the cloned `esm` strings.
         let (esm, string_buf) = esm.copy()?;
@@ -584,7 +584,9 @@ pub enum PendingResolutionTag {
 }
 
 pub struct LoadResult {
-    pub path: &'static [u8], // TODO(port): lifetime — interned in dirname_store
+    /// Interned in `DirnameStore`/`FilenameStore` (process-lifetime singletons),
+    /// so the `'static` borrow is genuine.
+    pub path: &'static [u8],
     pub diff_case: Option<Fs::file_system::entry::lookup::DifferentCase<'static>>,
     pub dirname_fd: FD,
     pub file_fd: FD,
diff --git a/src/resolver/tsconfig_json.rs b/src/resolver/tsconfig_json.rs
index 30c6535c4b9..eb2943646aa 100644
--- a/src/resolver/tsconfig_json.rs
+++ b/src/resolver/tsconfig_json.rs
@@ -6,32 +6,28 @@ use bun_parsers::json_parser;
 use enumset::{EnumSet, EnumSetType};
 
 // D042: `options::jsx::{Pragma, Runtime, ImportSource, RUNTIME_MAP, ...}` is
-// the canonical `bun_options_types::jsx` module. The previous local `Pragma`
-// (with `Vec` factory/fragment + empty defaults) diverged from spec — Zig
-// `JSX.Pragma{}` defaults to `["React","createElement"]`/`["React","Fragment"]`.
-// Unification corrects that; `merge_jsx` already uses `JsxFieldSet` (not
-// emptiness) to track was-set, so behavior is preserved.
+// the canonical `bun_options_types::jsx` module. `merge_jsx` uses
+// `JsxFieldSet` (not emptiness) to track was-set.
 pub mod options {
     pub use bun_options_types::jsx;
 }
 
-/// Port of the anonymous `enum { json, jsonc }` parameter to
-/// `cache::Json.parseJSON` (cache.zig:296).
+/// Selects strict JSON vs JSONC (comments + trailing commas) parsing in
+/// `JsonCache::parse_json`.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum JsonMode {
     Json,
     Jsonc,
 }
 
-/// Port of `cache::Json` (cache.zig:283). Moved down from `bun_bundler::cache`
-/// so the resolver names it directly — `bun_parsers::json_parser` is
-/// lower-tier than the resolver, so no cycle exists.
+/// JSON parse cache. Lives below `bun_bundler::cache` so the resolver names it
+/// directly — `bun_parsers::json_parser` is lower-tier than the resolver, so no
+/// cycle exists.
 ///
-/// Zig's `Json` is stateless and threads `bun.default_allocator` through every
-/// call; the Rust `json_parser` arena-allocates into a `&bun_alloc::Arena`, so
-/// this struct owns one. The arena is **never reset** — package.json/tsconfig
-/// ASTs are cached process-long ("DirInfo cache is reused globally / so we
-/// cannot free these", package_json.zig).
+/// `json_parser` arena-allocates into a `&bun_alloc::Arena`, so this struct
+/// owns one. The arena is **never reset** — package.json/tsconfig ASTs are
+/// cached process-long (the DirInfo cache is reused globally, so these cannot
+/// be freed).
 ///
 /// The arena is lazy-initialized on first `parse()`. `Resolver::for_worker`
 /// creates one `CacheSet` (and thus one `JsonCache`) per bundler worker thread,
@@ -47,7 +43,6 @@ impl JsonCache {
         JsonCache { bump: None }
     }
 
-    /// Port of `cache::Json::parse` (cache.zig:287).
     #[inline]
     fn parse(
         &mut self,
@@ -61,14 +56,13 @@ impl JsonCache {
     ) -> Result<Option<bun_ast::Expr>, bun_core::Error> {
         let mut temp_log = bun_ast::Log::init();
         let bump = self.bump.get_or_insert_with(bun_alloc::Arena::new);
-        // PORT NOTE: reshaped for borrowck — Zig `defer temp_log.appendToMaybeRecycled(log, source) catch {}`
-        // runs after the `func() catch null` body; here the append is hoisted past the match.
         let result = func(source, &mut temp_log, bump).ok();
         let _ = temp_log.append_to_maybe_recycled(log, source);
         Ok(result)
     }
 
-    /// Port of `cache::Json.parseTSConfig` (cache.zig:311).
+    /// Parses tsconfig.json/jsconfig.json source as JSONC into the cache
+    /// arena.
     #[inline]
     pub fn parse_tsconfig(
         &mut self,
@@ -78,7 +72,8 @@ impl JsonCache {
         self.parse(log, source, json_parser::parse_ts_config::<true>)
     }
 
-    /// Port of `cache::Json.parsePackageJSON` (cache.zig:307).
+    /// Parses package.json source into the cache arena, optionally forcing
+    /// UTF-8 string allocation.
     #[inline]
     pub fn parse_package_json(
         &mut self,
@@ -93,7 +88,8 @@ impl JsonCache {
         }
     }
 
-    /// Port of `cache::Json.parseJSON` (cache.zig:296).
+    /// Parses JSON source into the cache arena using `mode` to pick strict
+    /// JSON vs JSONC.
     #[inline]
     pub fn parse_json(
         &mut self,
@@ -122,11 +118,10 @@ impl JsonCache {
 // Heuristic: you probably don't have 100 of these
 // Probably like 5-10
 // Array iteration is faster and deterministically ordered in that case.
-// TODO(port): bun.StringArrayHashMap — confirm bun_collections key/value ownership for byte-slice keys
+// Both keys and values are owned (`Box`/`Vec`) and freed when the map drops.
 pub(crate) type PathsMap = ArrayHashMap<Box<[u8]>, Vec<Box<[u8]>>>;
 
-// Zig: `fn FlagSet(comptime Type: type) type { return std.EnumSet(std.meta.FieldEnum(Type)); }`
-// Rust has no `FieldEnum` reflection; we hand-list the Pragma fields actually used below.
+// Hand-listed Pragma fields actually used below.
 #[derive(EnumSetType, Debug)]
 pub(crate) enum JsxField {
     Factory,
@@ -139,8 +134,6 @@ pub(crate) enum JsxField {
 pub(crate) type JsxFieldSet = EnumSet<JsxField>;
 
 pub struct TSConfigJSON {
-    // TODO(port): lifetime — Zig never frees these string fields (resolver-lifetime arena);
-    // modeled here as owned Box<[u8]>. Revisit if profiling shows churn.
     pub abs_path: Box<[u8]>,
 
     /// The absolute path of "compilerOptions.baseUrl"
@@ -199,20 +192,17 @@ pub(crate) enum ImportsNotUsedAsValue {
     Invalid,
 }
 
-// Zig: `pub const List = bun.ComptimeStringMap(ImportsNotUsedAsValue, ...)`
 pub(crate) static IMPORTS_NOT_USED_AS_VALUE_LIST: phf::Map<&'static [u8], ImportsNotUsedAsValue> = phf::phf_map! {
     b"preserve" => ImportsNotUsedAsValue::Preserve,
     b"error" => ImportsNotUsedAsValue::Err,
     b"remove" => ImportsNotUsedAsValue::Remove,
 };
 
-// Zig: `Output.scoped(.alloc, .visibleIf(hasDecl(T, "log_allocations")))` — hidden by
-// default, enabled via `BUN_DEBUG_alloc=1`. Tests count `new(TSConfigJSON)` /
+// Hidden by default, enabled via `BUN_DEBUG_alloc=1`. Tests count `new(TSConfigJSON)` /
 // `destroy(TSConfigJSON)` lines to assert the extends-chain merge frees intermediates.
 bun_core::declare_scope!(alloc, hidden);
 
 impl TSConfigJSON {
-    // Zig: `pub const new = bun.TrivialNew(@This());` → `bun.new` logs under `.alloc`.
     #[inline]
     pub fn new(v: Self) -> Box<Self> {
         let boxed = Box::new(v);
@@ -222,7 +212,7 @@ impl TSConfigJSON {
         boxed
     }
 
-    // Zig: `bun.destroy(this)` — logs under `.alloc` then frees.
+    // Logs under `.alloc` then frees.
     #[inline]
     pub fn destroy(boxed: Box<Self>) {
         if cfg!(debug_assertions) {
@@ -311,17 +301,15 @@ impl TSConfigJSON {
         // The extra null-byte here is unnecessary. But it's kind of nice in the debugger sometimes.
         let _ = string_builder.append_z(remaining);
 
-        // PERF(port): Zig returned a sub-slice into the builder's single allocation; Rust copies once.
         let len = string_builder.len - 1;
         let written = string_builder.allocated_slice();
         Ok(Box::from(&written[..len]))
     }
 
-    // PORT NOTE: Zig `Expr.asString(allocator)` allocates and never frees (the
-    // resolver owns the JSON AST for its lifetime). The live Rust `Expr` query
-    // API exposes `as_utf8_string_literal() -> Option<&[u8]>` instead — the
-    // tsconfig parser forces UTF-8 (cache.zig:313 `force_utf8=true`), so every
-    // `EString` is already a flat UTF-8 slice and we can copy at the boundary.
+    // NOTE: the `Expr` query API exposes `as_utf8_string_literal() ->
+    // Option<&[u8]>` — the tsconfig parser forces UTF-8 (`force_utf8=true`),
+    // so every `EString` is already a flat UTF-8 slice and we can copy at the
+    // boundary.
     pub fn parse(
         log: &mut bun_ast::Log,
         source: &bun_ast::Source,
@@ -347,9 +335,7 @@ impl TSConfigJSON {
             paths: PathsMap::default(),
             ..Default::default()
         };
-        // errdefer allocator.free(result.paths) — handled by Drop on `result`.
-        //
-        // PERF(port): Zig (and the first Rust port) re-scans each JSON object's
+        // PERF: avoid re-scanning each JSON object's
         // property vector once per field — `expr.asProperty(...)` is an O(n)
         // linear scan, and there are ~11 of them on `compilerOptions` plus 2 on
         // the top-level object, so a typical tsconfig walks `compilerOptions`
@@ -495,11 +481,12 @@ impl TSConfigJSON {
             // https://www.typescriptlang.org/docs/handbook/jsx.html#basic-usages
             if let Some(jsx_prop) = jsx_v {
                 if let Some(str) = jsx_prop.as_utf8_string_literal() {
-                    // PERF(port): Zig allocs `vec![0u8; str.len()]` to lowercase
-                    // before the map lookup. `RUNTIME_MAP`'s keys are all
-                    // lowercase ASCII and the longest (`b"react-jsxdev"`) is 12
-                    // bytes, so a longer value can't match — lowercase into a
-                    // fixed stack buffer (returns `None` when it can't fit).
+                    // PERF: lowercase into a fixed stack buffer instead of
+                    // allocating before the map lookup. `RUNTIME_MAP`'s keys
+                    // are all lowercase ASCII and the longest
+                    // (`b"react-jsxdev"`) is 12 bytes, so a longer value can't
+                    // match (`ascii_lowercase_buf` returns `None` when it
+                    // can't fit).
                     if let Some((str_lower, len)) = strings::ascii_lowercase_buf::<12>(str) {
                         // - We don't support "preserve" yet
                         if let Some(runtime) = options::jsx::RUNTIME_MAP.get(&str_lower[..len]) {
@@ -590,8 +577,6 @@ impl TSConfigJSON {
             // Parse "paths"
             if let Some(paths_prop) = paths_v {
                 if let bun_ast::ExprData::EObject(paths) = &paths_prop.data {
-                    // PORT NOTE: Zig `defer { Features.tsconfig_paths += 1 }` hoisted to top of block;
-                    // it runs on every exit path either way.
                     bun_analytics::features::tsconfig_paths
                         .fetch_add(1, core::sync::atomic::Ordering::Relaxed);
 
@@ -670,9 +655,9 @@ impl TSConfigJSON {
                                     if !values.is_empty() {
                                         // Invalid patterns are filtered out above, so count <= array.len.
                                         // Shrink the allocation so the slice stored in the map is exactly
-                                        // what was allocated — callers that later free these values (the
-                                        // extends-merge in resolver.zig) pass the stored slice to
-                                        // Allocator.free, which requires the original length.
+                                        // what was allocated — callers that later free these values
+                                        // (the extends-merge in the resolver) pass the stored slice
+                                        // to the allocator, which requires the original length.
                                         values.shrink_to_fit();
                                         let _ = result.paths.put(Box::from(key), values);
                                     }
@@ -736,7 +721,6 @@ impl TSConfigJSON {
         loc: bun_ast::Loc,
         text: &[u8],
     ) -> Result<Box<[Box<[u8]>]>, bun_core::Error> {
-        // TODO(port): narrow error set
         if text.is_empty() {
             return Ok(Box::default());
         }
@@ -763,8 +747,6 @@ impl TSConfigJSON {
                 return Ok(Box::default());
             }
 
-            // PERF(port): was appendAssumeCapacity
-            // PERF(port): Zig stored a borrowed slice into `text`; Rust clones into Box<[u8]>.
             parts.push(Box::from(text));
             return Ok(parts.into_boxed_slice());
         }
@@ -784,7 +766,6 @@ impl TSConfigJSON {
                 );
                 return Ok(Box::default());
             }
-            // PERF(port): was appendAssumeCapacity
             parts.push(Box::from(part));
         }
 
@@ -853,8 +834,6 @@ impl TSConfigJSON {
         false
     }
 
-    // Zig `deinit` only freed `paths` and `bun.destroy(this)`. In Rust, `Box<TSConfigJSON>`
-    // drop handles both: PathsMap has Drop, and Box frees the allocation. No explicit Drop needed.
+    // `Box<TSConfigJSON>` drop handles cleanup: PathsMap has Drop, and Box
+    // frees the allocation. No explicit Drop needed.
 }
-
-// ported from: src/resolver/tsconfig_json.zig
diff --git a/src/router/lib.rs b/src/router/lib.rs
index 3f2969d695a..743513c9ff9 100644
--- a/src/router/lib.rs
+++ b/src/router/lib.rs
@@ -18,10 +18,10 @@ use bun_http_types::URLPath::URLPath;
 
 // ──────────────────────────────────────────────────────────────────────────
 // Cross-crate name aliases. These are pure re-exports of real lower-tier types
-// (no shadow structs); kept as a private module so Zig-shaped paths
+// (no shadow structs); kept as a private module so the aliased paths
 // (`bun_ast::Log`, `Fs::Entry`, `api::LoadedRouteConfig`) read naturally.
 // ──────────────────────────────────────────────────────────────────────────
-// `bun.hash(bytes)` — std.hash.Wyhash seed 0. NOT Wyhash11 (different algo).
+// Wyhash with seed 0. NOT Wyhash11 (different algo).
 #[inline]
 fn wyhash(input: &[u8]) -> u64 {
     bun_wyhash::hash(input)
@@ -50,7 +50,6 @@ use bun_ptr::Interned;
 // cross-tier decoupling
 // ──────────────────────────────────────────────────────────────────────────
 
-// Ground truth: src/bundler/options.zig `pub const RouteConfig = struct { ... }`.
 // Defined here so T4 router is self-contained; `bun_bundler::options` re-exports
 // this (`pub use bun_router::RouteConfig`) so the original path keeps resolving.
 #[derive(Debug, Clone, Default)]
@@ -184,16 +183,14 @@ impl RouteConfig {
     }
 }
 
-// const index_route_hash = @truncate(bun.hash("$$/index-route$$-!(@*@#&*%-901823098123"))
-// TODO(port): make this a true const once bun_wyhash::hash is const fn
-fn index_route_hash() -> u32 {
-    wyhash(b"$$/index-route$$-!(@*@#&*%-901823098123") as u32
-}
+// `hash_const` is byte-identical to the runtime `bun_wyhash::hash` (seed 0);
+// `tests::hash_const_matches_runtime` in `bun_wyhash` guards drift.
+const INDEX_ROUTE_HASH: u32 =
+    bun_wyhash::hash_const(0, b"$$/index-route$$-!(@*@#&*%-901823098123") as u32;
 
 // Param/List are lifetime-parameterized: `name` borrows the route name
-// (DirnameStore-backed) and `value` borrows the *request URL buffer*. The Zig
-// version stores raw slices with no ownership; the correct Rust port is a
-// borrowed `&'a [u8]`, not a forged `'static`.
+// (DirnameStore-backed) and `value` borrows the *request URL buffer*, so the
+// correct representation is a borrowed `&'a [u8]`, not a forged `'static`.
 //
 // `bun_url::route_param::Param<'a>` is now lifetime-generic (TYPE_ONLY
 // move-down landed); collapse the local copy to a re-export so the param list
@@ -234,7 +231,7 @@ impl<'a> Router<'a> {
     }
 
     pub fn route_index_by_hash(&self, hash: u32) -> Option<usize> {
-        if hash == index_route_hash() {
+        if hash == INDEX_ROUTE_HASH {
             return self.routes.index_id;
         }
 
@@ -290,8 +287,7 @@ impl<'a> Router<'a> {
             }
         }
 
-        // PERF(port): Zig reused a threadlocal `params_list` to avoid realloc.
-        // A borrowed `List<'a>` cannot soundly live in a `'static` thread_local,
+        // PERF: a borrowed `List<'a>` cannot soundly live in a `'static` thread_local,
         // so we allocate per-request; revisit with an arena/SmallVec if hot.
         {
             let mut params_list = route_param::List::default();
@@ -339,8 +335,7 @@ struct RouteIndex {
 
 // TODO(b2-blocked): bun_collections::MultiArrayElement derive — proc-macro not
 // yet landed, so MultiArrayList<RouteIndex> can't expose per-field column
-// accessors. Hand-rolled SoA struct (semantically identical to Zig's
-// MultiArrayList(RouteIndex)) until the derive exists.
+// accessors. Hand-rolled SoA struct until the derive exists.
 #[derive(Default)]
 pub struct RouteIndexList {
     // The `Box` is load-bearing: `Routes::index` / `Routes::static_` hold
@@ -407,8 +402,7 @@ pub struct Routes {
     pub list: RouteIndexList,
     /// Index into `list`'s columns where dynamic routes begin (sorted after
     /// static). Stored as an offset+len instead of materialized slices to avoid
-    /// a self-referential struct — Zig sliced `route_list.items(.route)[i..]`
-    /// directly; in Rust we re-slice on each `match_dynamic` call.
+    /// a self-referential struct; we re-slice on each `match_dynamic` call.
     pub dynamic_start: Option<usize>,
     pub dynamic_len: usize,
 
@@ -420,8 +414,7 @@ pub struct Routes {
     pub static_: StringHashMap<*const Route>,
 
     /// Corresponds to "index.js" on the filesystem.
-    /// Spec (router.zig:386-396) stores `index: ?*Route` — a raw pointer
-    /// co-owned with `list` (points into a `Box<Route>` owned by
+    /// A raw pointer co-owned with `list` (points into a `Box<Route>` owned by
     /// `list.route`). Stored as `NonNull` (not `&'a Route`) so `Routes` claims
     /// no borrow it doesn't actually take; matches `static_` above.
     pub index: Option<NonNull<Route>>,
@@ -503,7 +496,7 @@ impl Routes {
                     path: index.abs_path.as_bytes(),
                     pathname: url_path.pathname,
                     basename: index.basename,
-                    hash: index_route_hash(),
+                    hash: INDEX_ROUTE_HASH,
                     file_path: index.abs_path.as_bytes(),
                     query_string: url_path.query_string,
                     client_framework_enabled: self.client_framework_enabled,
@@ -514,8 +507,6 @@ impl Routes {
             return None;
         }
 
-        // PORT NOTE: Zig moved params into a local MatchContextType then back via
-        // defer; in Rust a plain reborrow suffices.
         if let Some(route_ptr) = self.match_(path, params) {
             // SAFETY: pointers from static_/dynamic alias Box<Route> stored in
             // self.list, which outlives self.
@@ -596,7 +587,7 @@ struct RouteLoader<'a> {
 
     dedupe_dynamic: ArrayHashMap<u32, &'static [u8]>,
     log: &'a mut bun_ast::Log,
-    // PORT NOTE: raw NonNull (not &'a Route) because it points into self.all_routes
+    // NOTE: raw NonNull (not &'a Route) because it points into self.all_routes
     // (self-referential); `Routes` co-owns it with `list`.
     index: Option<NonNull<Route>>,
     static_list: StringHashMap<*const Route>,
@@ -611,7 +602,7 @@ impl<'a> RouteLoader<'a> {
         use bun_collections::hash_map::Entry;
 
         // /index.js
-        if route.full_hash == index_route_hash() {
+        if route.full_hash == INDEX_ROUTE_HASH {
             let new_route = Box::new(route);
             // SAFETY: Box contents have stable address; never removed from all_routes until consumed by load_all
             self.index = Some(NonNull::from(&*new_route));
@@ -621,7 +612,6 @@ impl<'a> RouteLoader<'a> {
 
         // static route
         if route.param_count == 0 {
-            // PORT NOTE: Zig getOrPut → std Entry API (StringHashMap = std HashMap).
             if let Some(existing) = self.static_list.get(route.match_name.as_bytes()) {
                 let source = bun_ast::Source::init_empty_file(route.abs_path.as_bytes());
                 self.log.add_error_fmt(
@@ -711,9 +701,7 @@ impl<'a> RouteLoader<'a> {
     ) -> Routes {
         let mut route_dirname_len: u16 = 0;
 
-        // Zig: `FileSystem.instance().relative(base_dir, config.dir)` — thin wrapper
-        // around `path_handler.relative` (resolver/fs.zig:439). Call bun_paths directly
-        // to avoid the higher-tier bun_resolver dep.
+        // Call bun_paths directly to avoid the higher-tier bun_resolver dep.
         let relative_dir = bun_paths::resolve_path::relative(base_dir, &config.dir);
         if !relative_dir.starts_with(b"..") {
             route_dirname_len =
@@ -755,11 +743,10 @@ impl<'a> RouteLoader<'a> {
                 dynamic_start = Some(i);
             }
 
-            if route.full_hash == index_route_hash() {
+            if route.full_hash == INDEX_ROUTE_HASH {
                 index_id = Some(i);
             }
 
-            // PERF(port): was appendAssumeCapacity — profile if hot
             let (filepath, match_name, public_path) = (
                 route.abs_path.as_bytes(),
                 route.match_name.as_bytes(),
@@ -793,7 +780,7 @@ impl<'a> RouteLoader<'a> {
             dynamic_len,
             static_: this.static_list,
             // Points into a Box<Route> now owned by `route_list`; co-owned raw
-            // pointer (router.zig:386-396 stores `?*Route`).
+            // pointer.
             index: this.index,
             config,
             index_id,
@@ -812,8 +799,7 @@ impl<'a> RouteLoader<'a> {
         if let Some(entries) = root_dir_info.get_entries_const() {
             let iter = entries.iter();
             'outer: for entry_ptr in iter {
-                // PORT NOTE: `iter()` yields raw `*mut Entry` (matching Zig's
-                // `*Entry` map value type, fs.zig:117). Reborrow locally for
+                // NOTE: `iter()` yields raw `*mut Entry`. Reborrow locally for
                 // each access so `&` reads and the `&mut` `kind()` call do not
                 // overlap. Single iterator active for this scan; serialized via
                 // `RealFS.entries_mutex`.
@@ -822,11 +808,10 @@ impl<'a> RouteLoader<'a> {
                     continue 'outer;
                 }
 
-                // Zig: `entry.kind(&fs.fs, false)` (router.zig:416). Thread the
-                // resolver's fs `Implementation` through — `Entry.kind` derefs
-                // it to lazily stat when `need_stat` is true, so null would be
-                // a latent crash / silent route-drop once the stub forwards it.
-                // Zig `Entry.Kind` is exactly `{dir, file}` (resolver/fs.zig:378).
+                // Thread the resolver's fs `Implementation` through —
+                // `Entry.kind` derefs it to lazily stat when `need_stat` is
+                // true, so null would be a latent crash / silent route-drop
+                // once the stub forwards it.
                 // SAFETY: no other live borrow of `*entry_ptr` here; entries_mutex
                 // held; `resolver.fs_impl()` points at the process-global RealFS.
                 let kind = unsafe { (&*entry_ptr).kind(resolver.fs_impl(), false) };
@@ -896,7 +881,7 @@ impl<'a> RouteLoader<'a> {
     }
 }
 
-// Zig: `packed struct(u32) { offset: u16, len: u16 }` — bitcast-compatible u32.
+// Packed `{ offset: u16, len: u16 }` pair stored in a u32.
 #[repr(transparent)]
 #[derive(Copy, Clone, Default, PartialEq, Eq)]
 pub struct TinyPtr(u32);
@@ -964,9 +949,7 @@ impl TinyPtr {
 }
 
 // On Windows we need to normalize this path to have forward slashes.
-// Zig heap-allocates a separate buffer (`allocator.dupe`) so it doesn't mutate
-// memory it doesn't own (router.zig:537-547). The Rust port interns the
-// normalized path into `DirnameStore` (process-lifetime arena) instead, so
+// The normalized path is interned into `DirnameStore` (process-lifetime arena), so
 // `abs_path` is uniformly an `Interned` over `'static` bytes on every
 // platform — keeping `RouteIndexList.filepath: &'static [u8]` sound and
 // avoiding the borrow-then-move at `RouteLoader::load_all`.
@@ -1010,7 +993,7 @@ impl Route {
     /// # Safety
     /// `entry` must point to a live `Fs::Entry` (EntryStore-owned) with no
     /// other active `&mut` borrow for the duration of the call. `base_` and
-    /// `extname` may borrow `(*entry).base_`; see the PORT NOTE below.
+    /// `extname` may borrow `(*entry).base_`; see the NOTE below.
     pub unsafe fn parse(
         base_: &[u8],
         extname: &[u8],
@@ -1019,9 +1002,9 @@ impl Route {
         public_dir_: &[u8],
         routes_dirname_len: u16,
     ) -> Option<Route> {
-        // PORT NOTE: `entry` is a raw `*mut Entry` (matching Zig's `*Entry`)
+        // NOTE: `entry` is a raw `*mut Entry`
         // because `base_`/`extname` may borrow `(*entry).base_` (tiny inline
-        // string, fs.zig:333) and a `&mut Entry` parameter would alias them.
+        // string) and a `&mut Entry` parameter would alias them.
         // Reads go through `unsafe { &*entry }`; the single mutation
         // (`set_abs_path`) goes through `unsafe { &mut *entry }` after
         // `base_`/`extname` are no longer used.
@@ -1052,7 +1035,7 @@ impl Route {
                 let mut buf: &mut [u8] = &mut route_file_buf[..];
 
                 if !public_dir.is_empty() {
-                    // PORT NOTE: reshaped for borrowck — `buf` already aliases
+                    // NOTE: reshaped for borrowck — `buf` already aliases
                     // route_file_buf[..]; write through it instead of re-borrowing.
                     buf[0] = b'/';
                     buf = &mut buf[1..];
@@ -1098,7 +1081,7 @@ impl Route {
             let is_index = name.is_empty();
 
             let mut has_uppercase = false;
-            // PORT NOTE: reshaped for borrowck — both arms intern via DirnameStore
+            // NOTE: reshaped for borrowck — both arms intern via DirnameStore
             // (process-lifetime arena → `&'static`), so the post-if bindings are
             // 'static and the route_file_buf borrow is dropped before the
             // abs-path block below needs it mutably.
@@ -1118,7 +1101,7 @@ impl Route {
                     let name_offset = name.as_ptr() as usize - public_path.as_ptr() as usize;
                     let name_len = name.len();
 
-                    // PORT NOTE: DirnameStore::append returns `&'static [u8]` (process-
+                    // NOTE: DirnameStore::append returns `&'static [u8]` (process-
                     // lifetime arena), so rebinding here drops the borrow on
                     // `route_file_buf` and avoids needing lifetime transmutes
                     // below.
@@ -1149,7 +1132,7 @@ impl Route {
                 };
 
             if abs_path_str.is_empty() {
-                // PORT NOTE: reshaped for borrowck — `defer if (needs_close) file.close()`
+                // NOTE: reshaped for borrowck — `defer if (needs_close) file.close()`
                 // becomes a scopeguard owning the Option<File>; `needs_close` is a
                 // Cell so the drop closure can read it while the body still mutates.
                 // The guard is inverted: when the fd belongs to the cache
@@ -1164,17 +1147,16 @@ impl Route {
                     }
                 });
 
-                // SAFETY: see fn-level PORT NOTE — read-only reborrow.
+                // SAFETY: see fn-level NOTE — read-only reborrow.
                 if let Some(valid) = unsafe { &*entry }.cache().fd.unwrap_valid() {
                     *file = Some(bun_sys::File::from_fd(valid));
                     needs_close.set(false);
                 } else {
-                    // SAFETY: see fn-level PORT NOTE — read-only reborrow.
+                    // SAFETY: see fn-level NOTE — read-only reborrow.
                     let entry_r = unsafe { &*entry };
                     let parts = [entry_r.dir(), entry_r.base()];
                     let abs_len = FileSystem::instance().abs_buf(&parts, route_file_buf).len();
-                    // Zig: `abs_path_str = FileSystem.instance.absBuf(...)`
-                    // (router.zig:743). Rebind so the later getFdPath error
+                    // Rebind so the later getFdPath error
                     // message prints the computed path instead of `b""`.
                     // SAFETY: lifetime-laundered raw view into route_file_buf
                     // (same pattern as `public_path` above) so the buffer can
@@ -1227,7 +1209,6 @@ impl Route {
                     .append(_abs)
                     .expect("unreachable");
 
-                // Zig: `entry.abs_path = PathString.init(abs_path_str)`.
                 // SAFETY: sole mutation; `base_`/`extname` (which may borrow
                 // `(*entry).base_.remainder_buf`) are not used after this.
                 unsafe { &mut *entry }.set_abs_path(Interned::from_static(abs_path_str));
@@ -1235,9 +1216,8 @@ impl Route {
 
             #[cfg(windows)]
             let abs_path: AbsPath = {
-                // Zig: `allocator.dupe(u8, platformToPosixBuf(...))` — process-
-                // lifetime heap dup. Intern into DirnameStore so the slice is
-                // genuinely `'static` and the `Interned` widen is sound on Windows.
+                // Intern into DirnameStore so the slice is genuinely `'static`
+                // and the `Interned` widen is sound on Windows.
                 let normalized = bun_paths::resolve_path::platform_to_posix_buf(
                     abs_path_str,
                     &mut bufs.normalized_abs_path_buf,
@@ -1261,9 +1241,9 @@ impl Route {
                 debug_assert!(!strings::index_of_char(unsafe { &*entry }.base(), b'\\').is_some());
             }
 
-            // PORT NOTE: name/match_name/public_path are already `&'static` via
+            // NOTE: name/match_name/public_path are already `&'static` via
             // DirnameStore::append above. `entry.base()` borrows the entry (it
-            // may be inline-stored for ≤31-byte names, fs.zig:333); intern it
+            // may be inline-stored for ≤31-byte names); intern it
             // explicitly to get `&'static` without a lifetime transmute.
             // SAFETY: read-only reborrow; the `&mut` write above is dead.
             let basename: &'static [u8] = FileSystem::instance()
@@ -1277,7 +1257,7 @@ impl Route {
                 public_path: Interned::from_static(public_path),
                 match_name: Interned::from_static(match_name),
                 full_hash: if is_index {
-                    index_route_hash()
+                    INDEX_ROUTE_HASH
                 } else {
                     wyhash(name) as u32
                 },
@@ -1333,10 +1313,7 @@ pub mod sorter {
         match (a.kind as u8).cmp(&(b.kind as u8)) {
             Ordering::Equal => match a.kind {
                 // static + dynamic are sorted alphabetically
-                pattern::Tag::Static | pattern::Tag::Dynamic => {
-                    // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot
-                    sort_by_name_string(a_name, b_name)
-                }
+                pattern::Tag::Static | pattern::Tag::Dynamic => sort_by_name_string(a_name, b_name),
                 // catch all and optional catch all must appear below dynamic
                 pattern::Tag::CatchAll | pattern::Tag::OptionalCatchAll => {
                     match a.param_count.cmp(&b.param_count) {
@@ -1363,9 +1340,6 @@ pub mod sorter {
     }
 }
 
-// PORT NOTE: Zig nested `Sorter` under `Route`; Rust has no `impl Route { pub use Sorter }`
-// equivalent, so callers use `crate::sorter` directly.
-
 struct RouteBufs {
     route_file_buf: PathBuffer,
     #[cfg(windows)]
@@ -1398,7 +1372,7 @@ pub struct Match<'a> {
     pub basename: &'a [u8],
 
     pub hash: u32,
-    // PORT NOTE: raw `*mut` (not `&'a mut`) to match Zig's `*Param.List`.
+    // NOTE: raw `*mut` (not `&'a mut`).
     // `MatchedRoute` (bun_runtime) stores this self-referentially — a
     // `&'a mut List` here would be invalidated under Stacked Borrows the
     // moment any `&mut MatchedRoute` is taken. Callers that need a borrow
@@ -1494,17 +1468,17 @@ impl<'a> Match<'a> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Traits introduced to replace Zig's `comptime T: type` duck-typing
+// Traits abstracting over the router's collaborators
 // (Resolver, Server, RequestContext).
 // TODO(refactor): colocate these with the canonical types in
 // bun_resolver / bun_runtime.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait ResolverLike {
-    // `bun_resolver::fs::FileSystem` is a singleton in Zig, so `'static` here
-    // is faithful and avoids threading the resolver borrow into RouteLoader<'a>.
+    // `bun_resolver::fs::FileSystem` is a process-global singleton, so `'static`
+    // here is faithful and avoids threading the resolver borrow into RouteLoader<'a>.
     fn fs(&self) -> &'static FileSystem;
-    /// Zig: `&fs.fs` — the resolver's `Implementation` field, passed to
+    /// The resolver's `Implementation` field, passed to
     /// `Entry.kind` for lazy stat.
     fn fs_impl(&self) -> *mut Fs::Implementation;
     /// Returns an arena handle (not a borrow) so the resolver's `&mut self`
@@ -1569,7 +1543,7 @@ pub mod pattern {
                         let segment =
                             &path_[0..path_.iter().position(|&b| b == b'/').unwrap_or(path_.len())];
                         if !str_.eql_bytes(segment) {
-                            params.truncate(0); // TODO(b1): was shrink_retaining_capacity (MultiArrayList API)
+                            params.truncate(0); // shrinkRetainingCapacity(0)
                             return false;
                         }
 
@@ -1592,7 +1566,7 @@ pub mod pattern {
                             path_ = &path_[i + 1..];
 
                             if pattern.is_end(name) {
-                                params.truncate(0); // TODO(b1): was shrink_retaining_capacity (MultiArrayList API)
+                                params.truncate(0); // shrinkRetainingCapacity(0)
                                 return false;
                             }
 
@@ -1917,7 +1891,6 @@ pub mod pattern {
         pub kind: Tag,
     }
 
-    // TODO(b1): thiserror not in deps; manual Display/Error impl.
     #[derive(strum::IntoStaticStr, Debug, Clone, Copy)]
     pub enum PatternParseError {
         CatchAllMustBeAtTheEnd,
@@ -2047,38 +2020,27 @@ mod tests {
     }
 
     fn make_test(cwd_path: &[u8], data: &[(&str, &str)]) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig used comptime field iteration over an anonymous struct.
-        // Ported as runtime slice of (path, content) pairs.
         Output::init_test();
         debug_assert!(cwd_path.len() > 1 && cwd_path != b"/" && !cwd_path.ends_with(b"bun"));
-        // const bun_tests_dir = try std.fs.cwd().makeOpenPath("bun-test-scratch", .{});
         let bun_tests_dir = bun_sys::Dir::cwd()
             .make_open_path(b"bun-test-scratch", bun_sys::OpenDirOptions::default())?;
-        // bun_tests_dir.deleteTree(cwd_path) catch {};
         let _ = bun_tests_dir.delete_tree(cwd_path);
 
-        // const cwd = try bun_tests_dir.makeOpenPath(cwd_path, .{});
         let cwd = bun_tests_dir.make_open_path(cwd_path, bun_sys::OpenDirOptions::default())?;
-        // try cwd.setAsCwd();
         bun_sys::fchdir(cwd.fd())?;
 
-        // inline for (fields) |field| { ... }
         for (name, value) in data {
             let name_b = name.as_bytes();
-            // if (std.fs.path.dirname(field.name)) |dir| { try cwd.makePath(dir); }
-            // PORT NOTE: `std.fs.path.dirname` returns null for paths without a
-            // separator; replicate with rposition on '/' (test fixture paths
-            // are always forward-slash).
+            // NOTE: paths without a '/' have no parent dir to create;
+            // rposition on '/' finds the parent (test fixture paths are
+            // always forward-slash).
             if let Some(slash) = name_b.iter().rposition(|&c| c == b'/') {
                 if slash > 0 {
                     cwd.make_path(&name_b[..slash])?;
                 }
             }
-            // var file = try cwd.createFile(field.name, .{ .truncate = true });
             let file = bun_sys::File::create(cwd.fd(), name_b, true)?;
-            // try file.writeAll(value);
             file.write_all(value.as_bytes())?;
-            // file.close();
             let _ = file.close();
         }
         Ok(())
@@ -2137,7 +2099,7 @@ mod tests {
             )?;
 
             let mut log = bun_ast::Log::init();
-            // PORT NOTE: `errdefer logger.print(Output.errorWriter())` — Rust has
+            // NOTE: `errdefer logger.print(Output.errorWriter())` — Rust has
             // no errdefer; the test harness panics on error anyway, but the guard
             // still flushes diagnostics on early-return for parity.
             let _err_dump = scopeguard::guard(core::ptr::from_mut(&mut log), |log| {
@@ -2146,7 +2108,7 @@ mod tests {
             });
 
             // const opts = Options.BundleOptions{ .target = .browser, ... };
-            // PORT NOTE: the resolver-side `BundleOptions` subset omits
+            // NOTE: the resolver-side `BundleOptions` subset omits
             // `loaders`/`define`/`log`/`routes`/`entry_points`/`out_extensions`/
             // `transform_options` — none are read by `Resolver::init1` or the
             // dir-info walk, so `Default` + `target` is the faithful projection.
@@ -2244,7 +2206,6 @@ mod tests {
             )?;
             let entry_points = router.get_entry_points();
 
-            // try expectEqual(std.meta.fieldNames(@TypeOf(data)).len, entry_points.len);
             assert_eq!(data.len(), entry_points.len());
             scopeguard::ScopeGuard::into_inner(_err_dump);
             Ok(router)
@@ -2465,29 +2426,12 @@ mod tests {
         assert!(run(optional_catch_all) == 0);
     }
 
-    #[test]
-    #[ignore = "TODO(port): depends on Test::make filesystem fixture harness"]
-    fn github_api_route_loader() {
-        // TODO(port): port body once Test::make is implemented; see router.zig:1571-1678
-    }
-
-    #[test]
-    #[ignore = "TODO(port): depends on Test::make filesystem fixture harness"]
-    fn sample_route_loader() {
-        // TODO(port): port body once Test::make is implemented; see router.zig:1680-1782
-    }
-
-    #[test]
-    #[ignore = "TODO(port): depends on Test::make filesystem fixture harness"]
-    fn routes_basic() {
-        // TODO(port): port body once Test::make is implemented; see router.zig:1784-1832
-    }
-
-    #[test]
-    #[ignore = "TODO(port): depends on Test::make filesystem fixture harness"]
-    fn dynamic_routes() {
-        // TODO(port): port body once Test::make is implemented; see router.zig:1834-1868
-    }
+    // The route-loader integration tests ("Github
+    // API Route Loader", "Sample Route Loader", "Routes Basic", "Dynamic
+    // Routes") are not implemented: they assert through `ctx.matched_route`, which
+    // `Router::match_` does not yet populate (the JavaScriptHandler enqueue
+    // path is still commented out), and they consume fixture route lists that
+    // live in the test-runner harness crate.
 
     #[test]
     fn pattern() {
@@ -2526,5 +2470,3 @@ mod tests {
         }
     }
 }
-
-// ported from: src/router/router.zig
diff --git a/src/runtime/allocators/LinuxMemFdAllocator.rs b/src/runtime/allocators/LinuxMemFdAllocator.rs
index d6e90adaed4..e48ff34afa5 100644
--- a/src/runtime/allocators/LinuxMemFdAllocator.rs
+++ b/src/runtime/allocators/LinuxMemFdAllocator.rs
@@ -31,8 +31,7 @@ use crate::webcore::blob::store::Bytes as BlobStoreBytes;
 ///
 /// `ref_count` must stay at this field offset for `bun_ptr::IntrusiveArc<Self>`.
 //
-// Zig: `bun.ptr.ThreadSafeRefCount(@This(), "ref_count", deinit, .{})`
-// → intrusive *atomic* refcount. Blob stores (and thus this allocator, smuggled
+// Intrusive *atomic* refcount. Blob stores (and thus this allocator, smuggled
 // through `StdAllocator.ptr`) cross threads, so the single-threaded `RefCount`
 // flavor would data-race on ref/deref.
 #[derive(bun_ptr::ThreadSafeRefCounted)]
@@ -44,7 +43,7 @@ pub struct LinuxMemFdAllocator {
 }
 
 impl LinuxMemFdAllocator {
-    /// Zig `deinit`: close fd, then `bun.destroy(self)`.
+    /// Close the fd, then free the allocation.
     ///
     /// # Safety
     /// Refcount hit 0; `this` came from `heap::alloc` in `IntrusiveArc::new`.
@@ -60,7 +59,6 @@ impl LinuxMemFdAllocator {
 static MEMFD_COUNTER: AtomicUsize = AtomicUsize::new(0);
 
 impl LinuxMemFdAllocator {
-    /// Zig: `pub const new = bun.TrivialNew(@This());`
     pub fn new(fd: Fd, size: usize) -> bun_ptr::IntrusiveArc<Self> {
         bun_ptr::IntrusiveArc::new(Self {
             ref_count: bun_ptr::ThreadSafeRefCount::init(),
@@ -69,7 +67,6 @@ impl LinuxMemFdAllocator {
         })
     }
 
-    /// Zig: `pub const ref = RefCount.ref;`
     pub fn ref_(&self) {
         // SAFETY: `self` is a live `Self`; `ThreadSafeRefCount::ref_` only
         // touches the interior-mutable atomic `ref_count` field.
@@ -78,17 +75,14 @@ impl LinuxMemFdAllocator {
         };
     }
 
-    /// Zig: `pub const deref = RefCount.deref;`
-    ///
     /// # Safety
     /// `this` must point to a live, Box-allocated `Self` (as produced by
     /// [`Self::new`] / `IntrusiveArc::new`), and the caller must own one
     /// outstanding ref. After this call `this` may be dangling; the caller
     /// must not hold any live `&Self`/`&mut Self` derived from `this`.
     //
-    // PORT NOTE: takes `*mut Self` (not `&self`) to mirror Zig's
-    // `RefCount.deref(self: *Self)`. Taking `&self` and then freeing the
-    // allocation via `heap::take(self as *const _ as *mut _)` is UB:
+    // Takes `*mut Self`, not `&self`: taking `&self` and then freeing the
+    // allocation via `heap::take(self as *const _ as *mut _)` is UB —
     // it materializes `&mut Self` (via `Drop`) while a shared `&self`
     // borrow is still live.
     pub unsafe fn deref(this: *mut Self) {
@@ -97,8 +91,6 @@ impl LinuxMemFdAllocator {
         unsafe { bun_ptr::ThreadSafeRefCount::<Self>::deref(this) };
     }
 
-    /// Zig: `.{ .ptr = self, .vtable = AllocatorInterface.VTable }`
-    ///
     /// # Safety
     /// `this` must be the `*mut Self` originally produced by `heap::alloc`
     /// (via [`Self::new`] / `IntrusiveArc::new`) — the returned allocator's
@@ -112,7 +104,6 @@ impl LinuxMemFdAllocator {
         }
     }
 
-    /// Zig: `if (allocator_.vtable == AllocatorInterface.VTable) @ptrCast(@alignCast(allocator_.ptr))`
     pub fn from(alloc: StdAllocator) -> Option<*mut Self> {
         if core::ptr::eq(alloc.vtable, allocator_interface::VTABLE) {
             Some(alloc.ptr.cast::<Self>())
@@ -121,8 +112,6 @@ impl LinuxMemFdAllocator {
         }
     }
 
-    /// Zig: `fn alloc(self: *Self, len, offset, flags: std.posix.MAP) Maybe(Blob.Store.Bytes)`
-    ///
     /// # Safety
     /// `this` must be a live Box-allocated `*mut Self` (see [`Self::allocator`]).
     /// On `Ok`, the returned `Bytes` borrows one ref on `*this` (via the
@@ -131,8 +120,8 @@ impl LinuxMemFdAllocator {
         this: *mut Self,
         len: usize,
         offset: usize,
-        // Zig: `std.posix.MAP` bitset. `sys::mmap` takes raw `i32` flags; callers
-        // pass `libc::MAP_*` directly. `.TYPE = .SHARED` is forced below.
+        // `sys::mmap` takes raw `i32` flags; callers pass `libc::MAP_*`
+        // directly. `MAP_SHARED` is forced below.
         flags: i32,
     ) -> sys::Result<BlobStoreBytes> {
         // memfd + mmap are POSIX-only; on Windows `should_use()` always
@@ -152,14 +141,13 @@ impl LinuxMemFdAllocator {
             let page = bun_alloc::page_size();
             size = (size + page - 1) & !(page - 1);
 
-            // Zig: `flags_mut.TYPE = .SHARED;` — `TYPE` is the low-4-bit field of
-            // `std.posix.MAP`, so this *replaces* it (not OR). Mask out the
+            // The map type *replaces* the low TYPE bits (not OR). Mask out the
             // existing TYPE bits first so e.g. an incoming `MAP_PRIVATE` (0x02)
             // becomes `MAP_SHARED` (0x01), not `MAP_SHARED_VALIDATE` (0x03).
             #[cfg(any(target_os = "linux", target_os = "android"))]
             const MAP_TYPE: i32 = libc::MAP_TYPE;
             #[cfg(not(any(target_os = "linux", target_os = "android")))]
-            const MAP_TYPE: i32 = 0x0f; // `std.posix.MAP.TYPE` is `u4` on every POSIX target
+            const MAP_TYPE: i32 = 0x0f; // the map-type field is 4 bits on every POSIX target
             let flags_mut = (flags & !MAP_TYPE) | libc::MAP_SHARED;
 
             // SAFETY: `this` is live per caller contract; we only read scalar fields.
@@ -175,8 +163,6 @@ impl LinuxMemFdAllocator {
                 offset as i64,
             ) {
                 Ok(slice_ptr) => {
-                    // Zig: `Blob.Store.Bytes{ .cap = @truncate(slice.len), .ptr = slice.ptr,
-                    //                          .len = @truncate(len), .allocator = self.arena() }`
                     // SAFETY: `slice_ptr[0..map_len]` is the mmap'd region; `Self::allocator(this)`
                     // is the vtable whose `free` will `munmap` exactly that region and then
                     // `deref` `this`. `len <= map_len` (cap) by construction.
@@ -227,7 +213,6 @@ impl LinuxMemFdAllocator {
         #[cfg(any(target_os = "linux", target_os = "android"))]
         {
             let mut label_buf = [0u8; 128];
-            // Zig: `std.fmt.bufPrintZ(&label_buf, "memfd-num-{d}", .{n}) catch ""`
             let label: &core::ffi::CStr = {
                 use std::io::Write as _;
                 let n = MEMFD_COUNTER.fetch_add(1, Ordering::Relaxed);
@@ -284,23 +269,15 @@ impl LinuxMemFdAllocator {
                 }
             }
 
-            // PORT NOTE: Zig's `Self.new` returns a raw `*Self` (refcount=1).
-            // `into_raw()` extracts the `heap::alloc` pointer and transfers
-            // the +1 to us (RefPtr has no `Drop`); on `Ok` that ref moves into
-            // `res.allocator`, on `Err` we `deref` it explicitly — exactly the
-            // Zig flow.
+            // `Self::new` returns refcount=1; `into_raw()` extracts the
+            // `heap::alloc` pointer and transfers the +1 to us (RefPtr has no
+            // `Drop`). On `Ok` that ref moves into `res.allocator`; on `Err`
+            // we `deref` it explicitly.
             let memfd: *mut Self = Self::new(fd, bytes.len()).into_raw();
 
             // SAFETY: `memfd` is the `heap::alloc` pointer
             // (full provenance) with one live ref — required by `Self::alloc`.
-            match unsafe {
-                Self::alloc(
-                    memfd,
-                    bytes.len(),
-                    0,
-                    libc::MAP_SHARED, // Zig: `.{ .TYPE = .SHARED }`
-                )
-            } {
+            match unsafe { Self::alloc(memfd, bytes.len(), 0, libc::MAP_SHARED) } {
                 Ok(res) => Ok(res),
                 Err(err) => {
                     // SAFETY: we still own the +1 from `into_raw()`; release it
@@ -312,24 +289,18 @@ impl LinuxMemFdAllocator {
         }
     }
 
-    /// Zig: `allocator_.vtable == AllocatorInterface.VTable`
     pub fn is_instance(alloc: StdAllocator) -> bool {
         core::ptr::eq(alloc.vtable, allocator_interface::VTABLE)
     }
 }
 
 // ─── AllocatorInterface ─────────────────────────────────────────────────────
-// Zig defined a private `AllocatorInterface` struct holding alloc/free/VTable.
-// `bun_alloc::AllocatorVTable` is the `std.mem.Allocator.VTable` shape; the
-// vtable functions are kept as raw-ptr free functions matching Zig's
-// `*anyopaque` signatures so that `free` retains the `heap::alloc` *mut
-// provenance it needs to drop `self`.
+// The vtable functions are kept as raw-ptr free functions so that `free`
+// retains the `heap::alloc` *mut provenance it needs to drop `self`.
 
 mod allocator_interface {
     use super::*;
 
-    /// Zig: `fn free(ptr: *anyopaque, buf: []u8, _, _) void`
-    ///
     /// # Safety
     /// `ptr` must be the `*mut LinuxMemFdAllocator` originally produced by
     /// `heap::alloc` (via [`LinuxMemFdAllocator::new`] / `IntrusiveArc::new`)
@@ -341,12 +312,11 @@ mod allocator_interface {
     /// allocator. The region is unmapped on return; the caller must not access
     /// it afterwards.
     unsafe fn free(ptr: *mut c_void, buf: &mut [u8], _alignment: Alignment, _ret_addr: usize) {
-        // Zig: `var self: *Self = @ptrCast(@alignCast(ptr)); defer self.deref();`
-        // — runs after munmap regardless of result.
+        // The deref runs after munmap regardless of result.
         //
-        // PORT NOTE: takes the raw vtable data pointer (Zig's `*anyopaque`)
-        // directly rather than `&self`. `deref` may free the allocation, which
-        // requires `*mut Self` with full `heap::alloc` provenance; deriving
+        // Takes the raw vtable data pointer directly rather than `&self`.
+        // `deref` may free the allocation, which requires
+        // `*mut Self` with full `heap::alloc` provenance; deriving
         // it from a `&self` (`as *const _ as *mut _`) would be SharedReadOnly
         // provenance and the `heap::take` → `Drop` write would be UB under
         // Stacked Borrows.
@@ -362,7 +332,7 @@ mod allocator_interface {
         unsafe { LinuxMemFdAllocator::deref(this) };
     }
 
-    /// `std.mem.Allocator.VTable{ .alloc = noAlloc, .resize = noResize, .remap = noRemap, .free }`
+    /// Free-only vtable.
     /// Own static — address is the identity tag for `is_instance`.
     pub(super) static VTABLE: &AllocatorVTable = &AllocatorVTable::free_only(free);
 }
@@ -372,5 +342,3 @@ mod allocator_interface {
 pub(super) fn std_vtable() -> &'static AllocatorVTable {
     allocator_interface::VTABLE
 }
-
-// ported from: src/bun_alloc/LinuxMemFdAllocator.zig
diff --git a/src/runtime/allocators/mod.rs b/src/runtime/allocators/mod.rs
index ba1a746fca1..ff6908a2606 100644
--- a/src/runtime/allocators/mod.rs
+++ b/src/runtime/allocators/mod.rs
@@ -10,20 +10,19 @@ pub use linux_mem_fd_allocator::LinuxMemFdAllocator;
 
 /// Push this crate's `StdAllocator` vtable addresses into the
 /// `bun_safety::alloc::has_ptr` registry so allocator-mismatch checks can
-/// distinguish instances (Zig: chain of inline `isInstance` calls in
-/// `safety/alloc.zig:hasPtr`). Idempotent enough — call once at startup.
+/// distinguish instances. Idempotent enough — call once at startup.
 ///
-/// Coverage vs the Zig spec's `hasPtr` chain:
+/// Coverage:
 ///  - `LinuxMemFdAllocator` / `MimallocArena` ×2 /
 ///    `bundle_v2::ExternalFreeFunctionAllocator` → registered below.
 ///  - `c_allocator` / `z_allocator` / `MimallocArena::is_instance` /
 ///    `String::is_wtf_allocator` → checked directly in `bun_safety::alloc::
 ///    has_ptr` (`bun_alloc` is below the safety tier).
-///  - `std.heap.ArenaAllocator` / `MaxHeapAllocator` / `CachedBytecode` /
-///    `heap_breakdown::Zone` → these have **no `StdAllocator` vtable** in the
-///    Rust port; their `is_instance` is `TypeId`-based on `&dyn Allocator`,
-///    which `has_ptr(StdAllocator)` cannot dispatch on. They are intentionally
-///    omitted (safe under-approximation — `has_ptr` may return `false`).
+///  - `MaxHeapAllocator` / `CachedBytecode` / `heap_breakdown::Zone` → these
+///    have **no `StdAllocator` vtable**; their `is_instance` is `TypeId`-based
+///    on `&dyn Allocator`, which `has_ptr(StdAllocator)` cannot dispatch on.
+///    They are intentionally omitted (safe under-approximation — `has_ptr` may
+///    return `false`).
 pub fn register_safety_vtables() {
     bun_safety::register_alloc_vtable(linux_mem_fd_allocator::std_vtable());
     for vt in bun_alloc::mimalloc_arena::std_vtables() {
diff --git a/src/runtime/api.rs b/src/runtime/api.rs
index d81b659979e..70877331325 100644
--- a/src/runtime/api.rs
+++ b/src/runtime/api.rs
@@ -21,8 +21,6 @@ pub use crate::socket::NewSocket;
 pub use crate::socket::SocketAddress;
 pub use crate::socket::TCPSocket;
 pub use crate::socket::TLSSocket;
-// PORT NOTE: dropped `comptime { _ = @import("./socket/uws_jsc.zig"); }` force-reference;
-// Rust links `us_socket_buffered_js_write` via `pub` export in crate::socket::uws_jsc.
 pub use crate::socket::udp_socket::UDPSocket;
 
 pub use crate::ffi::FFI;
@@ -33,7 +31,6 @@ pub use crate::napi;
 pub use crate::node;
 
 // ─── BuildMessage / ResolveMessage ───────────────────────────────────────────
-// Zig: `pub const {Build,Resolve}Message = @import("../jsc/{Build,Resolve}Message.zig").…;`
 // Canonical defs live in `bun_jsc` (with `#[bun_jsc::JsClass]` derives wiring
 // the C++ `${T}__create`/`__fromJS`/`__finalize` symbols). `bun_runtime` already
 // depends on `bun_jsc`, so this is a plain downstream re-export — no cycle.
@@ -158,7 +155,7 @@ pub mod bun {
         // `Terminal.PtyResult`, `Winsize`, `OpenPtyFn`, `CreatePtyError` —
         // pure FFI handles with no JSC. Canonical defs live in
         // `api/bun/Terminal.rs`; re-exported here so callers can name them via
-        // `api::Terminal::*` exactly as in the Zig (`Terminal.PtyResult` etc.).
+        // `api::Terminal::*` (`Terminal.PtyResult` etc.).
         pub use crate::api::bun_terminal_body::{
             CreatePtyError, OpenPtyFn, OpenPtyTermios, PtyResult, Winsize,
         };
@@ -236,9 +233,6 @@ pub use crate::webview::host_process as WebViewHostProcess;
 // and hands `(&arena, &mut log, &source)` to a per-format closure that does the
 // format-specific parse, error match (StackOverflow / OOM / SyntaxError vs
 // log.to_js), and tail conversion.
-//
-// Zig has no shared helper (four open-coded copies); this is net-new cleanup of
-// a faithfully-ported duplication.
 pub(crate) fn with_text_format_source<R>(
     global: &bun_jsc::JSGlobalObject,
     frame: &bun_jsc::CallFrame,
@@ -249,7 +243,6 @@ pub(crate) fn with_text_format_source<R>(
 ) -> bun_jsc::JsResult<R> {
     use crate::node::{BlobOrStringOrBuffer, StringOrBuffer};
 
-    // PERF(port): was ArenaAllocator bulk-free feeding the parser + AST stores.
     let arena = bun_alloc::Arena::new();
     let mut ast_memory_allocator = bun_ast::ASTMemoryAllocator::borrowing(&arena);
     let _ast_scope = ast_memory_allocator.enter();
@@ -284,5 +277,3 @@ pub(crate) fn with_text_format_source<R>(
 
     f(&arena, &mut log, &source)
 }
-
-// ported from: src/runtime/api.zig
diff --git a/src/runtime/api/Archive.rs b/src/runtime/api/Archive.rs
index de38a21b15b..f51fc4b3f2b 100644
--- a/src/runtime/api/Archive.rs
+++ b/src/runtime/api/Archive.rs
@@ -44,8 +44,9 @@ impl Default for GzipOptions {
     }
 }
 
-// TODO(port): #[bun_jsc::JsClass] derive — hand-written until the proc-macro
-// grows `no_finalize`/`no_construct` knobs Archive needs (custom `finalize`).
+// Hand-written JS class glue (not the `#[bun_jsc::JsClass]` derive): Archive
+// needs a custom `finalize` and no constructor, which the proc-macro does not
+// expose.
 #[repr(C)]
 pub struct Archive {
     /// The underlying data for the archive - uses Blob.Store for thread-safe ref counting
@@ -55,7 +56,7 @@ pub struct Archive {
 }
 
 impl Archive {
-    /// Borrow the backing `StoreRef` (Zig: `archive.store`).
+    /// Borrow the backing `StoreRef`.
     #[inline]
     pub fn store_ref(&self) -> &StoreRef {
         &self.store
@@ -70,8 +71,7 @@ bun_jsc::impl_js_class_via_generated!(Archive => crate::generated_classes::js_Ar
 impl Archive {
     /// `Archive.write(path, data, options?)` static class fn — codegen
     /// (`ArchiveClass__write`) resolves it as an associated item on the struct,
-    /// so forward to the module-level [`write`] body below (Zig had it as
-    /// `pub fn write` in the file struct, which is both).
+    /// so forward to the module-level [`write`] body below.
     #[inline]
     pub fn write(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         self::write(global, callframe)
@@ -167,7 +167,7 @@ impl Archive {
     /// - compress: "gzip" - Enable gzip compression
     /// - level: number (1-12) - Compression level (default 6)
     /// When no options are provided, no compression is applied
-    // PORT NOTE: `#[bun_jsc::host_fn]` has no `constructor` kind yet; the
+    // NOTE: `#[bun_jsc::host_fn]` has no `constructor` kind yet; the
     // `JsClass` derive emits a `constructor` shim that calls this directly.
     pub fn constructor(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<Box<Archive>> {
         let [data_arg, options_arg] = callframe.arguments_as_array::<2>();
@@ -273,8 +273,7 @@ fn create_archive(data: Vec<u8>, compress: Compression) -> Box<Archive> {
     Box::new(Archive { store, compress })
 }
 
-/// `JSValue::as_::<Blob>()` shim — kept as a free fn so the call sites read
-/// the same as the Zig (`jsc.WebCore.Blob.fromJS(value)`). Returns a shared
+/// `JSValue::as_::<Blob>()` shim — kept as a free fn. Returns a shared
 /// borrow (BACKREF: m_ctx payload kept live by the JSC cell rooted by `value`
 /// on the caller's stack) so callers don't open-code `unsafe { &*ptr }`.
 #[inline]
@@ -576,7 +575,6 @@ fn parse_pattern_arg(
             }
             let pattern: Box<[u8]> = Box::from(str_slice.slice());
             patterns.push(pattern);
-            // PERF(port): was appendAssumeCapacity.
             i += 1;
         }
 
@@ -651,7 +649,6 @@ impl PromiseResult {
     }
 }
 
-/// Trait extracted from the Zig structural-duck-typing on `Context`.
 /// Context must provide:
 ///   - `run` — runs on thread pool, stores result in `self`
 ///   - `run_from_js` — returns value to resolve/reject
@@ -941,7 +938,7 @@ impl TaskContext for BlobContext {
             }
             BlobResult::Uncompressed => Ok(match self.output_type {
                 BlobOutputType::Blob => {
-                    // Zig: `this.store.ref()` — clone bumps the refcount; ownership of
+                    // The clone bumps the refcount; ownership of
                     // the new ref transfers into the Blob via init_with_store.
                     let store = self.store.clone();
                     let blob_ptr = Blob::new(Blob::init_with_store(store, global));
@@ -949,8 +946,13 @@ impl TaskContext for BlobContext {
                     PromiseResult::Resolve(unsafe { (*blob_ptr).to_js(global) })
                 }
                 BlobOutputType::Bytes => {
-                    let dup = self.store.shared_view().to_vec();
-                    // TODO(port): Zig matched OOM here and rejected; Rust Vec aborts on OOM.
+                    // On allocation failure, reject the promise instead of aborting.
+                    let view = self.store.shared_view();
+                    let mut dup: Vec<u8> = Vec::new();
+                    if dup.try_reserve_exact(view.len()).is_err() {
+                        return Ok(PromiseResult::Reject(global.create_out_of_memory_error()));
+                    }
+                    dup.extend_from_slice(view);
                     PromiseResult::Resolve(JSValue::create_buffer_from_box(
                         global,
                         dup.into_boxed_slice(),
@@ -1178,10 +1180,8 @@ impl FilesContext {
                     let to_read = (size - total_read).min(buf.len());
                     let read = archive.read_data(&mut buf[..to_read]);
                     if read < 0 {
-                        // Read error - returned as a normal Result (not a Zig error), so the
-                        // errdefer above won't fire. Free the current buffer and all previously
-                        // collected entries manually to avoid leaking them.
-                        // PORT NOTE: in Rust both `data` and `entries` drop automatically here.
+                        // Read error.
+                        // NOTE: both `data` and `entries` drop automatically here.
                         // SAFETY: `archive` is the live `read_new()` handle opened above.
                         return Ok(if let Some(err) = Self::clone_error_string(&archive) {
                             FilesResult::LibarchiveErr(err)
@@ -1339,9 +1339,8 @@ fn compress_gzip(data: &[u8], level: u8) -> Result<Vec<u8>, CompressError> {
 
     let max_size = compressor.max_bytes_needed(data, libdeflate::Encoding::Gzip);
 
-    // PERF(port): the Zig spec used a 256 KiB on-stack scratch for small inputs;
-    // in Rust the scratch is heap-allocated either way, so the threshold is dead
-    // weight — just size the Vec to `max_size` once.
+    // The scratch is heap-allocated either way, so a small-input threshold is
+    // dead weight — just size the Vec to `max_size` once.
     let mut output = Vec::with_capacity(max_size);
     let result = compressor.compress_to_vec(data, &mut output, libdeflate::Encoding::Gzip);
     if result.status != libdeflate::Status::Success {
@@ -1420,7 +1419,6 @@ fn extract_to_disk_filtered(
     root: &[u8],
     glob_patterns: Option<&[Box<[u8]>]>,
 ) -> Result<u32, bun_core::Error> {
-    // TODO(port): narrow error set
     use libarchive::lib;
     let archive = lib::ReadArchive::new();
     configure_archive_reader(&archive);
@@ -1599,5 +1597,3 @@ fn extract_to_disk_filtered(
 
     Ok(count)
 }
-
-// ported from: src/runtime/api/Archive.zig
diff --git a/src/runtime/api/BunObject.rs b/src/runtime/api/BunObject.rs
index a06b1a5d235..ede56cfa32c 100644
--- a/src/runtime/api/BunObject.rs
+++ b/src/runtime/api/BunObject.rs
@@ -14,9 +14,9 @@ pub(crate) fn get_public_path_with_asset_prefix<W: core::fmt::Write>(
     use bun_core::strings;
     use bun_paths::{Platform, resolve_path};
 
-    // PERF(port): bun_url::URL::join_write wants a `bun_io::Write`; route all
+    // bun_url::URL::join_write wants a `bun_io::Write`; route all
     // byte output through a Vec<u8> then forward to the caller's fmt::Write.
-    // Spec writes raw bytes — POSIX paths are arbitrary byte sequences — so use
+    // POSIX paths are arbitrary byte sequences — so use
     // a lossy conversion rather than silently dropping the whole component.
     #[inline]
     fn write_bytes<W: core::fmt::Write>(w: &mut W, bytes: &[u8]) -> core::fmt::Result {
@@ -28,7 +28,7 @@ pub(crate) fn get_public_path_with_asset_prefix<W: core::fmt::Write>(
     let relative_path: &[u8] = if strings::has_prefix(to, dir) {
         strings::without_trailing_slash(&to[dir.len()..])
     } else {
-        // PORT NOTE: spec is `VirtualMachine.get().transpiler.fs.relativePlatform(dir, to, platform)`;
+        // NOTE: spec is `VirtualMachine.get().transpiler.fs.relativePlatform(dir, to, platform)`;
         // that wrapper is stateless and forwards to bun_paths — dispatch on runtime `platform`
         // here to keep this fn callable without const-generic plumbing through `transpiler.fs`.
         match platform {
@@ -125,9 +125,7 @@ pub mod r#gen {
 }
 
 // ─── wrap_static_method adapters ───────────────────────────────────────────
-// Zig's `host_fn.wrapStaticMethod(T, "name", auto_protect)` reflects on the
-// target fn's parameter types and decodes each from the CallFrame. The Rust
-// proc-macro replacement (`#[bun_jsc::host_fn(static)]`) is not yet emitted,
+// `#[bun_jsc::host_fn(static)]` is not yet emitted,
 // so hand-roll the arg-extraction shims for the six call sites below.
 mod static_adapters {
     use super::*;
@@ -228,8 +226,8 @@ mod static_adapters {
         } else {
             JSValue::UNDEFINED
         };
-        // auto_protect = true: protect each arg across the call (Zig side
-        // re-enters the VM for Blob materialization).
+        // Protect each arg across the call (Blob materialization
+        // re-enters the VM).
         let _a0_guard = a0.protected();
         let _a1_guard = a1.protected();
         let Some(input) = BlobOrStringOrBuffer::from_js(g, a0)? else {
@@ -257,14 +255,14 @@ mod static_adapters {
 pub mod bun_object {
     use super::*;
 
-    // TODO(port): proc-macro — Zig used `toJSCallback = jsc.toJSHostFn` and
-    // `toJSLazyPropertyCallback` (comptime fn wrappers) plus comptime `@export`
-    // to emit each callback under `BunObject_callback_<name>` /
-    // `BunObject_lazyPropCb_<name>`. In Rust, the `#[bun_jsc::host_fn]`
-    // attribute on the underlying fn emits the JSC-ABI shim; the export name
-    // is set with `#[unsafe(no_mangle)]` on the shim. The two `macro_rules!`
-    // below expand the static export tables; verify the shim ABI matches
-    // `LazyPropertyCallback` for the property variants.
+    // Each callback is exported under
+    // `BunObject_callback_<name>` / `BunObject_lazyPropCb_<name>`. The
+    // two `macro_rules!` below expand the static export tables.
+    // ABI check vs the C++ declarations (BunObject+exports.h:90):
+    // `extern "C" EncodedJSValue SYSV_ABI (JSGlobalObject*, JSObject*)` for the
+    // property variants — matched here by `jsc_host_abi!` (`extern "sysv64"`
+    // on Windows-x64, `extern "C"` elsewhere) returning `JSValue`, which is
+    // `#[repr(transparent)]` over `EncodedJSValue`.
 
     // Ident concat via `${concat()}` is unstable (`macro_metavar_expr_concat`),
     // so the full `BunObject_callback_<name>` / `BunObject_lazyPropCb_<name>`
@@ -273,7 +271,7 @@ pub mod bun_object {
     macro_rules! export_callbacks {
         ($( $(#[$attr:meta])* $sym:ident => $target:expr ),* $(,)?) => {
             $(
-                // Zig spec (BunObject.zig) — `callconv(jsc.conv)`. C++ declares
+                // C++ declares
                 // these via `BUN_DECLARE_HOST_FUNCTION` → `JSC_HOST_CALL_ATTRIBUTES`
                 // = SysV on Windows-x64. Mismatching `extern "C"` here puts
                 // `globalObject` in RCX vs C++'s RDI → garbage deref.
@@ -315,8 +313,7 @@ pub mod bun_object {
     macro_rules! export_lazy_prop_callbacks {
         ($( $sym:ident => $target:path ),* $(,)?) => {
             $(
-                // Zig spec (BunObject.zig:108-112) — `LazyPropertyCallback` is
-                // `callconv(jsc.conv)`. C++ declares the extern as `SYSV_ABI`
+                // C++ declares the extern as `SYSV_ABI`
                 // (`BunObject+exports.h:91`); on Windows-x64 that's RDI/RSI,
                 // not RCX/RDX, so `extern "C"` reads garbage for both args.
                 bun_jsc::jsc_host_abi! {
@@ -429,10 +426,8 @@ pub mod bun_object {
     pub use super::set_main;
     // --- Setters ---
 
-    // PORT NOTE: Zig's `lazyPropertyCallbackName`/`callbackName` were comptime
-    // string concats used only at `comptime @export` sites. The export names
-    // are now spelled out verbatim in the `export_*!` macro invocations above,
-    // so the comptime-only helpers are dropped (no runtime callers).
+    // The export names
+    // are spelled out verbatim in the `export_*!` macro invocations above.
 
     // type LazyPropertyCallback = extern "C" fn(*mut JSGlobalObject, *mut JSObject) -> JSValue
     // (the `callconv(jsc.conv)` ABI is emitted by `#[bun_jsc::host_fn]` / the macro above;
@@ -496,7 +491,6 @@ pub(crate) fn braces(
 ) -> JsResult<JSValue> {
     let brace_slice = brace_str.to_utf8();
 
-    // PERF(port): was arena bulk-free — profile if hot
     let mut arena = bun_alloc::Arena::new();
     let _ = &mut arena;
 
@@ -517,9 +511,8 @@ pub(crate) fn braces(
     let expansion_count = Braces::calculate_expanded_amount(&lexer_output.tokens[..]);
 
     if opts.tokenize {
-        // PORT NOTE: Zig's `std.json.fmt` reflects over the tagged-union token
-        // list. The Rust `Braces::Token` enum has no `serde::Serialize`; emit
-        // the same shape (`[{"<tag>": <payload>|{}} , …]`) by hand so the
+        // NOTE: the `Braces::Token` enum has no `serde::Serialize`; emit
+        // the JSON shape (`[{"<tag>": <payload>|{}} , …]`) by hand so the
         // debug-only `Bun.braces(str, {tokenize:true})` round-trips.
         let str = Braces::tokens_to_json(&lexer_output.tokens[..]);
         let bun_str = BunString::from_bytes(&str);
@@ -531,7 +524,7 @@ pub(crate) fn braces(
             Ok(v) => v,
             Err(err) => return Err(global.throw_error(err.into(), "failed to parse braces")),
         };
-        // PORT NOTE: see `tokenize` arm — manual JSON encoder for the AST.
+        // NOTE: see `tokenize` arm — manual JSON encoder for the AST.
         let str = Braces::ast_to_json(&ast_node);
         let bun_str = BunString::from_bytes(&str);
         return bun_str.to_js(global);
@@ -652,7 +645,7 @@ pub(crate) fn inspect_table(
         return BunString::empty().to_js(global_this);
     }
 
-    // PORT NOTE: protect/unprotect over a copied [JSValue; 5]; the borrow of
+    // NOTE: protect/unprotect over a copied [JSValue; 5]; the borrow of
     // `all_arguments` cannot escape into a guard closure, so copy out into an
     // array of RAII guards.
     let _prot: [bun_jsc::ProtectedJSValue; 5] =
@@ -725,7 +718,7 @@ pub(crate) fn inspect(global_this: &JSGlobalObject, callframe: &CallFrame) -> Js
     for arg in args_buf.slice() {
         arg.protect();
     }
-    // Spec BunObject.zig:450 — `defer { for (arguments) |a| a.unprotect(); }`.
+    // Each arg is unprotected on scope exit.
     // `arguments_old::<4>` is a stack `[JSValue; 4]`; move it into the guard
     // and re-slice instead of heap-allocating a `Vec` per call.
     //
@@ -905,7 +898,7 @@ pub(crate) fn enable_ansi_colors(_global_this: &JSGlobalObject, _: &JSObject) ->
 
 // callconv(jsc.conv) — `SYSV_ABI` on win-x64 (BunObject.cpp:1103). Returns
 // plain `JSValue` so the generated thunk is a bare deref+call (no
-// `ExceptionValidationScope`), matching the .zig spec's bare body.
+// `ExceptionValidationScope`).
 // HOST_EXPORT(BunObject_getter_main, jsc)
 pub fn get_main(global_this: &JSGlobalObject) -> JSValue {
     // SAFETY: bun_vm() returns the live singleton VirtualMachine for a Bun-owned global.
@@ -995,15 +988,15 @@ pub(crate) fn get_argv(global_this: &JSGlobalObject, _: &JSObject) -> JSValue {
     node::process::get_argv(global_this)
 }
 
-// PORT NOTE (layering): `RareData.editor_context` in `bun_jsc` is an opaque ZST
+// NOTE (layering): `RareData.editor_context` in `bun_jsc` is an opaque ZST
 // stub — the real `EditorContext` lives in this crate (`cli::open`) and depends
 // on `bun_dotenv` / `bun_spawn`, so it can't move down without dragging those
-// into `bun_jsc`'s graph. Zig stored it on `rareData()`; semantically it is
+// into `bun_jsc`'s graph. Semantically it is
 // per-JS-thread state (one VM per thread), so a `thread_local` here is
 // equivalent and breaks the cycle without type erasure.
 //
 // `name_storage` owns the user-supplied editor name so `EditorContext.name`
-// (typed `&'static [u8]` to match the Zig dirname-store backing) can borrow it
+// (typed `&'static [u8]`) can borrow it
 // without leaking; the borrow lives as long as the thread.
 struct EditorContextSlot {
     ctx: crate::cli::open::EditorContext,
@@ -1053,9 +1046,7 @@ pub(crate) fn open_in_editor(
 
                     if !strings::eql_long(prev_name, sliced.slice(), true) {
                         let prev = core::mem::take(edit);
-                        // PORT NOTE: Zig stashed the arena-backed slice
-                        // directly into the persistent EditorContext (latent
-                        // UAF in spec). Own the bytes in `name_storage` and
+                        // Own the bytes in `name_storage` and
                         // hand back a thread-lifetime borrow.
                         let prev_storage =
                             core::mem::replace(&mut slot.name_storage, sliced.slice().to_vec());
@@ -1278,7 +1269,6 @@ fn do_resolve_with_args<const IS_FILE_PATH: bool>(
     owned.result_value = unsafe { errorable.result.value };
 
     if !owned.query_string.is_empty() {
-        // PERF(port): was stack-fallback
         let mut arraylist: Vec<u8> = Vec::with_capacity(1024);
         // Vec<u8> writes are infallible.
         let _ = write!(
@@ -1599,7 +1589,7 @@ pub(crate) fn serve(global_object: &JSGlobalObject, callframe: &CallFrame) -> Js
     // SAFETY: same VM pointer; re-borrow after `args` is dropped.
     let vm = global_object.bun_vm().as_mut();
 
-    // PORT NOTE (layering): Zig's `HotMap` is a `TaggedPtrUnion` over the four
+    // NOTE (layering): `HotMap` is a tagged union over the four
     // `NewServer` monomorphizations + sockets. `bun_jsc::rare_data::HotMapEntry`
     // is the erased `(tag: u8, ptr: *mut ())` lowering of that union; the tag
     // values for servers are pinned here to match `crate::server::AnyServerTag`
@@ -1653,7 +1643,7 @@ pub(crate) fn serve(global_object: &JSGlobalObject, callframe: &CallFrame) -> Js
             }
             let obj = <$ServerType>::ptr_to_js(server, global_object);
             if route_list_object != JSValue::ZERO {
-                // PORT NOTE: `ServerType.js.routeListSetCached` (codegen
+                // NOTE: `ServerType.js.routeListSetCached` (codegen
                 // `.classes.ts`) — routed through the typed helper in
                 // `server_body` until per-type codegen externs land.
                 <$ServerType>::js_gc_route_list_set(obj, global_object, route_list_object);
@@ -1671,12 +1661,16 @@ pub(crate) fn serve(global_object: &JSGlobalObject, callframe: &CallFrame) -> Js
                 }
             }
 
-            if config.allow_hot {
+            // `init` moved `config` into the server (`mem::take`), so the
+            // local `config` is defaulted from here on — read `allow_hot`
+            // and `id` from the server's own config or the registration is
+            // keyed on the wrong (empty) id.
+            if server_ref.config.allow_hot {
                 // SAFETY: same VM pointer; re-borrow after the earlier `vm` mut
                 // borrow was released by the `hot_map()` arm above.
                 if let Some(hot) = global_object.bun_vm().as_mut().hot_map() {
                     hot.insert_raw(
-                        &config.id,
+                        &server_ref.config.id,
                         HotMapEntry {
                             tag: $tag as u8,
                             ptr: server.cast::<()>(),
@@ -1704,8 +1698,7 @@ pub(crate) fn serve(global_object: &JSGlobalObject, callframe: &CallFrame) -> Js
         }};
     }
 
-    // PORT NOTE: Zig used nested `switch (bool) { inline else => |c| ... }` to
-    // monomorphize over (has_ssl_config, development). Expanded here.
+    // Monomorphized over (has_ssl_config, development), expanded here.
     let has_ssl_config = config.ssl_config.is_some();
     let development = config.is_development();
     match (development, has_ssl_config) {
@@ -1773,9 +1766,7 @@ pub(crate) fn mmap_file(global_this: &JSGlobalObject, callframe: &CallFrame) ->
         // SAFETY: buf[path_len] == 0 written above
         let buf_z = bun_core::ZStr::from_buf(&buf[..], path_len);
 
-        // PORT NOTE: Zig used `std.c.MAP{ .TYPE = .SHARED }` (a packed bitfield
-        // struct). Rust libc exposes raw `MAP_*` ints; build the flag word
-        // directly.
+        // libc exposes raw `MAP_*` ints; build the flag word directly.
         let mut flags: libc::c_int = libc::MAP_SHARED;
 
         // Conforming applications must specify either MAP_PRIVATE or MAP_SHARED.
@@ -1819,7 +1810,7 @@ pub(crate) fn mmap_file(global_this: &JSGlobalObject, callframe: &CallFrame) ->
                         )));
                     }
                     offset = usize::try_from(offset_value).expect("int cast");
-                    // std.mem.alignBackwardAnyAlign(usize, offset, pageSize())
+                    // Align the offset down to a page boundary.
                     let page = bun_sys::page_size();
                     offset -= offset % page;
                 }
@@ -1902,7 +1893,7 @@ pub(crate) fn get_s3_client_constructor(global_this: &JSGlobalObject, _: &JSObje
 }
 
 pub(crate) fn get_s3_default_client(global_this: &JSGlobalObject, _: &JSObject) -> JSValue {
-    // PORT NOTE (layering): `RareData::s3_default_client` body lives in
+    // NOTE (layering): `RareData::s3_default_client` body lives in
     // `bun_jsc::rare_data::_accessor_body` and names `bun_runtime::s3` types.
     // That can't compile in `bun_jsc`, so port the body here where the S3
     // types are in scope and store the cached value through the public
@@ -1911,14 +1902,14 @@ pub(crate) fn get_s3_default_client(global_this: &JSGlobalObject, _: &JSObject)
     use bun_jsc::StrongOptional;
     // SAFETY: bun_vm() returns the live thread-local VM for a Bun-owned global.
     let vm = global_this.bun_vm().as_mut();
-    // PORT NOTE: reshaped for borrowck — capture the raw env loader pointer
+    // NOTE: reshaped for borrowck — capture the raw env loader pointer
     // before `rare_data()` takes the long-lived `&mut` of `vm`.
     let env_ptr = vm.transpiler.env;
     let rare = vm.rare_data();
     if let Some(v) = rare.s3_default_client.get() {
         return v;
     }
-    // PORT NOTE (layering): `bun_dotenv::Loader::get_s3_credentials` returns the
+    // NOTE (layering): `bun_dotenv::Loader::get_s3_credentials` returns the
     // T2 POD mirror; lift it into the refcounted `bun_s3_signing::S3Credentials`
     // here at the high-tier call site (dotenv ≤T2 may not name s3_signing T5).
     // SAFETY: `transpiler.env` is the process-lifetime dotenv loader; disjoint
@@ -2000,7 +1991,7 @@ pub(crate) fn get_embedded_files(global_this: &JSGlobalObject, _: &JSObject) ->
     if vm.standalone_module_graph.is_none() {
         return JSValue::create_empty_array(global_this, 0);
     }
-    // PORT NOTE (layering): `VirtualMachine.standalone_module_graph` is
+    // NOTE (layering): `VirtualMachine.standalone_module_graph` is
     // type-erased to `&dyn bun_resolver::StandaloneModuleGraph` so `bun_jsc`
     // doesn't depend on `bun_standalone_graph`. The concrete graph is the
     // process singleton — `Graph::get()` returns the same instance the trait
@@ -2039,10 +2030,9 @@ pub(crate) fn get_embedded_files(global_this: &JSGlobalObject, _: &JSObject) ->
     });
     for (i, index) in sort_indices.iter().enumerate() {
         let file: &mut GraphFile = &mut unsorted_files[*index as usize];
-        // PORT NOTE (layering): `File::blob()` lives in the Zig spec's
-        // `StandaloneModuleGraph.File`; that crate can't depend on
-        // `bun_runtime::webcore::Blob`, so build the blob here from the
-        // file's `cached_blob` slot / contents.
+        // NOTE (layering): the crate defining `StandaloneModuleGraph.File`
+        // can't depend on `bun_runtime::webcore::Blob`, so build the blob
+        // here from the file's `cached_blob` slot / contents.
         let input_blob: *mut Blob = standalone_file_blob(file, global_this);
         // We call .dupe() on this to ensure that we don't return a blob that might get freed later.
         // SAFETY: `standalone_file_blob` returns a non-null heap allocation.
@@ -2069,9 +2059,8 @@ fn standalone_file_blob(
     }
     let store: StoreRef = Store::init(file.contents.as_bytes().to_vec());
     let blob_body = Blob::init_with_store(store, global);
-    // PORT NOTE (cyclebreak): `MimeType::by_loader` takes the `#[repr(u8)]`
-    // discriminant and an extension; matches Zig spec
-    // `MimeType.byLoader(file.loader, std.fs.path.extension(file.name))`.
+    // NOTE (cyclebreak): `MimeType::by_loader` takes the `#[repr(u8)]`
+    // discriminant and an extension.
     let mime =
         bun_http_types::MimeType::by_loader(file.loader as u8, bun_paths::extension(file.name));
     // SAFETY: `mime.value` is `Cow<'static, [u8]>`; the slice pointer is
@@ -2112,7 +2101,7 @@ impl CSRFObject {
     pub(crate) fn create(global_this: &JSGlobalObject) -> JSValue {
         let object = JSValue::create_empty_object(global_this, 2);
 
-        // PORT NOTE: `JSFunction::create` takes the raw JSC-ABI host fn pointer,
+        // NOTE: `JSFunction::create` takes the raw JSC-ABI host fn pointer,
         // so wrap the safe Rust-style `JsResult` fns via `to_js_host_call`.
         bun_jsc::jsc_host_abi! {
             unsafe fn csrf_generate_shim(
@@ -2230,7 +2219,7 @@ pub mod environment_variables {
         true
     }
 
-    /// Sync a process.env write back to the Zig-side env map so that Zig
+    /// Sync a process.env write back to the native env map so that native
     /// consumers (e.g. fetch's proxy resolution via env.getHttpProxyFor)
     /// observe the updated value. Used by custom setters for proxy-related
     /// env vars (HTTP_PROXY, HTTPS_PROXY, NO_PROXY and lowercase variants).
@@ -2263,7 +2252,7 @@ pub mod environment_variables {
         // bytes stay alive; if not, they're freed now.
         *slot.ptr = None;
 
-        // PORT NOTE: `Loader.map` is `&'a mut Map` (a mutable reference field);
+        // NOTE: `Loader.map` is `&'a mut Map` (a mutable reference field);
         // re-borrow as `&mut *` to avoid moving the reference out of the loader.
         let env_map = &mut *vm.transpiler.env_mut().map;
 
@@ -2280,9 +2269,7 @@ pub mod environment_variables {
         let new_val = bun_jsc::rare_data::RefCountedEnvValue::create(value_slice.slice());
         let stored = slot.ptr.insert(new_val);
         // slot.key is a static-lifetime string literal (the struct field name).
-        // PORT NOTE: Zig's `map.put` stored the slice header without duping,
-        // so the slot write had to precede `put` for the map to borrow live
-        // bytes. Rust's `Map::put` boxes its own copy — the Arc wrapper now
+        // NOTE: `Map::put` boxes its own copy — the Arc wrapper now
         // only backs `proxy_env_storage` for worker `cloneFrom`; ordering is
         // kept for spec parity.
         bun_core::handle_oom(env_map.put(slot.key, &stored.bytes));
@@ -2371,15 +2358,15 @@ pub mod JSZlib {
         }
     }
 
-    // PORT NOTE: Zig's `list.allocatedSlice()` (the full `[0..capacity)` window)
+    // NOTE: a full `[0..capacity)` window
     // was previously shimmed here as `&mut [u8]`, but materializing `&mut [u8]`
-    // over uninitialized bytes is UB in Rust regardless of later `set_len`.
+    // over uninitialized bytes is UB regardless of later `set_len`.
     // Callers now use `Vec::spare_capacity_mut()` (-> `&mut [MaybeUninit<u8>]`)
     // with `compress_into` / `decompress_into`, which is the sound equivalent.
 
-    // PORT NOTE: Zig exported `reader_deallocator` / `compressor_deallocator`
-    // to free a heap-allocated reader/compressor (and its owned `ArrayList`)
-    // from the ArrayBuffer finalizer. The Rust port keeps the reader on-stack
+    // NOTE: no `reader_deallocator` / `compressor_deallocator` exports are
+    // needed to free a heap-allocated reader/compressor from the ArrayBuffer
+    // finalizer. The reader stays on-stack
     // borrowing a local `Vec<u8>`, then leaks only the Vec's allocation into
     // the ArrayBuffer — so both zlib paths converge on `global_deallocator`
     // and the per-type callbacks are gone. (`no_mangle` dropped: 0 C++ refs.)
@@ -2543,8 +2530,7 @@ pub mod JSZlib {
                     return Err(global_this
                         .throw_value(ZigString::init(msg).to_error_instance(global_this)));
                 }
-                // PORT NOTE: Zig moved `list` into the reader and freed via a
-                // dedicated finalizer. In Rust the reader *borrows* `list_ptr`,
+                // NOTE: the reader *borrows* `list_ptr`,
                 // so drop the reader to release the borrow, then leak the owned
                 // `list` directly into the ArrayBuffer (freed by
                 // `global_deallocator`).
@@ -2659,7 +2645,7 @@ pub mod JSZlib {
         }
 
         let compressed = buffer.slice();
-        let _ = window_bits; // unused in Zig too
+        let _ = window_bits; // unused
 
         match library {
             Library::Zlib => {
@@ -2697,7 +2683,7 @@ pub mod JSZlib {
                     return Err(global_this
                         .throw_value(ZigString::init(msg).to_error_instance(global_this)));
                 }
-                // PORT NOTE: see gunzip path — reader borrows `list`, so drop
+                // NOTE: see gunzip path — reader borrows `list`, so drop
                 // it before leaking `list` into the ArrayBuffer.
                 drop(reader);
                 list.shrink_to_fit();
@@ -2763,7 +2749,7 @@ pub mod JSZlib {
 pub mod JSZstd {
     use super::*;
 
-    // `no_mangle` dropped: 0 C++ refs, 0 Rust refs (kept for parity with Zig export).
+    // `no_mangle` dropped: 0 C++ refs, 0 Rust refs.
     pub use bun_alloc::c_thunks::mi_free_ctx as deallocator;
 
     fn get_level(global_this: &JSGlobalObject, options_val: Option<JSValue>) -> JsResult<i32> {
@@ -2823,9 +2809,10 @@ pub mod JSZstd {
 
         // Calculate max compressed size
         let max_size = bun_zstd::compress_bound(input.len());
+        // The zero-fill
+        // here is output-irrelevant (zstd overwrites the prefix it reports).
+        // PERF: use Box::new_uninit_slice — profile if hot.
         let mut output = vec![0u8; max_size];
-        // TODO(port): allocator.alloc(u8, n) — Zig left this uninitialized.
-        // PERF(port): use Box::new_uninit_slice — profile if hot.
 
         // Perform compression with context
         let compressed_size = match bun_zstd::compress(&mut output, input, Some(level)) {
@@ -2892,11 +2879,16 @@ pub mod JSZstd {
                 // Compression path
                 // Calculate max compressed size
                 let max_size = bun_zstd::compress_bound(input.len());
-                // TODO(port): allocator.alloc(u8, n) — Zig left this uninitialized
-                // and surfaced OOM as an error. Rust's global allocator aborts on
-                // OOM, so the explicit "Out of memory" path is unreachable here.
-                // Could route through a fallible bun_alloc helper.
-                self.output = vec![0u8; max_size];
+                // Surface OOM
+                // as a rejected promise instead of aborting. The zero-fill is
+                // output-irrelevant (zstd overwrites the prefix it reports).
+                let mut output: Vec<u8> = Vec::new();
+                if output.try_reserve_exact(max_size).is_err() {
+                    self.error_message = Some(b"Out of memory");
+                    return;
+                }
+                output.resize(max_size, 0);
+                self.output = output;
 
                 // Perform compression
                 self.output = match bun_zstd::compress(&mut self.output, input, Some(self.level)) {
@@ -2951,7 +2943,7 @@ pub mod JSZstd {
         }
     }
 
-    /// Zig `ZstdJob.create` — free fn (not `impl ZstdJob`) because
+    /// Free fn (not `impl ZstdJob`) because
     /// `AnyTaskJob<_>` is a foreign type. Returns the promise `JSValue`
     /// directly so callers stay safe (the only state read back from the heap
     /// job is `ctx.promise.value()`; capture it before moving the strong into
@@ -3002,46 +2994,17 @@ pub mod JSZstd {
     }
 }
 
-// const InternalTestingAPIs = struct {
-//     pub fn BunInternalFunction__syntaxHighlighter(globalThis: *JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!JSValue {
-//         const args = callframe.arguments_old(1);
-//         if (args.len < 1) {
-//             globalThis.throwNotEnoughArguments("code", 1, 0);
-//         }
-//
-//         const code = args.ptr[0].toSliceOrNull(globalThis) orelse return .zero;
-//         defer code.deinit();
-//         var buffer = MutableString.initEmpty(bun.default_allocator);
-//         defer buffer.deinit();
-//         var writer = buffer.bufferedWriter();
-//         const formatter = bun.fmt.fmtJavaScript(code.slice(), .{
-//             .enable_colors = true,
-//             .check_for_unhighlighted_write = false,
-//         });
-//         writer.writer().print("{f}", .{formatter}) catch |err| {
-//             return globalThis.throwError(err, "Error formatting code");
-//         };
-//
-//         writer.flush() catch |err| {
-//             return globalThis.throwError(err, "Error formatting code");
-//         };
-//
-//         return bun.String.createUTF8ForJS(globalThis, buffer.list.items);
-//     }
-// };
-
-// PORT NOTE: Zig `comptime { _ = ...; BunObject.exportAll(); }` block dropped —
-// Rust links what's pub via the `#[unsafe(no_mangle)]` exports above.
+// NOTE: symbols are linked via the `#[unsafe(no_mangle)]` exports above.
 // Referenced: Crypto::JSPasswordObject::JSPasswordObject__create,
 // bun_jsc::btjs::dump_btjs_trace.
 
 // LazyProperty initializers for stdin/stderr/stdout
 //
-// PORT NOTE (layering): `RareData.{stdin,stdout,stderr}_store` are typed as
+// NOTE (layering): `RareData.{stdin,stdout,stderr}_store` are typed as
 // `Option<Arc<high_tier::BlobStore>>` opaque stubs in `bun_jsc`. The real
 // `Blob::Store` (intrusively refcounted, with `File` payload) lives in this
-// crate and can't move down without dragging `node::PathLike`/S3/aio. The Zig
-// spec stores them on RareData purely for per-VM lazy init; that is per-thread
+// crate and can't move down without dragging `node::PathLike`/S3/aio. The
+// stores exist purely for per-VM lazy init; that is per-thread
 // in practice (`VirtualMachine::get()` is thread-local), so cache the
 // `StoreRef`s here.
 mod stdio_stores {
@@ -3062,8 +3025,7 @@ mod stdio_stores {
             Ok(stat) => stat.st_mode as bun_sys::Mode,
             Err(_) => 0,
         };
-        // PORT NOTE: Zig set `ref_count = 2` to account for the RareData slot
-        // plus the Blob; with `StoreRef` (intrusive RAII) the slot is +1 and
+        // NOTE: with `StoreRef` (intrusive RAII) the slot is +1 and
         // the Blob takes its own +1 via `clone()`.
         let store = Store::new(Store {
             data: Data::File(FileStore {
@@ -3086,7 +3048,6 @@ mod stdio_stores {
         is_atty: bool,
         feature: &'static core::sync::atomic::AtomicUsize,
     ) -> JSValue {
-        // Zig: `bun.analytics.Features.@"Bun.std…" += 1` (rare_data.zig).
         feature.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
         let store = slot.with(|cell| {
             let mut s = cell.borrow_mut();
@@ -3153,5 +3114,3 @@ pub fn create_bun_stderr(global_this: &JSGlobalObject) -> JSValue {
 pub fn create_bun_stdout(global_this: &JSGlobalObject) -> JSValue {
     stdio_stores::stdout(global_this)
 }
-
-// ported from: src/runtime/api/BunObject.zig
diff --git a/src/runtime/api/HashObject.rs b/src/runtime/api/HashObject.rs
index 1d0ebb5a538..e70d3c615c0 100644
--- a/src/runtime/api/HashObject.rs
+++ b/src/runtime/api/HashObject.rs
@@ -5,12 +5,10 @@ use bun_jsc::{self as jsc, CallFrame, JSFunction, JSGlobalObject, JSValue, JsRes
 // ──────────────────────────────────────────────────────────────────────────
 // Hash algorithm abstraction
 //
-// Zig's `hashWrap` uses `@hasDecl` / `std.meta.ArgsTuple` / `@TypeOf` to
-// reflect on each `std.hash.*` type's inconsistent interface (1-arg vs
-// 2-arg, seed-first vs bytes-first, `hash` vs `hashWithSeed`). Per
-// PORTING.md §Comptime reflection, that collapses to a trait: every hasher
-// presents a uniform `hash(seed, input) -> Output` and the per-type impl
-// absorbs the signature differences.
+// The underlying hashers have inconsistent interfaces (1-arg vs 2-arg,
+// seed-first vs bytes-first, seeded vs unseeded). A trait unifies them:
+// every hasher presents a uniform `hash(seed, input) -> Output` and the
+// per-type impl absorbs the signature differences.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub(crate) trait HashOutput: Copy {
@@ -34,14 +32,14 @@ impl HashOutput for u64 {
 pub(crate) trait HashAlgorithm {
     type Output: HashOutput;
     /// `seed` is always passed as u64 from JS; impls truncate to their native
-    /// seed width (matches Zig's `@truncate(seed)`). Hashers that take no
-    /// seed (Adler32) ignore it — matches the Zig 1-arg branch.
+    /// seed width. Hashers that take no seed (Adler32) ignore it.
     fn hash(seed: u64, input: &[u8]) -> Self::Output;
 }
 
 // ──────────────────────────────────────────────────────────────────────────
 // Hasher impls — one unit struct per algorithm.
-// Each must produce output **bit-identical** to Zig's `std.hash.*`.
+// Each must produce output **bit-identical** to previous Bun releases
+// (pinned by the vector suite in test/js/bun/util/hash.test.js).
 // ──────────────────────────────────────────────────────────────────────────
 
 pub(crate) struct Wyhash;
@@ -56,7 +54,7 @@ pub(crate) struct Adler32;
 impl HashAlgorithm for Adler32 {
     type Output = u32;
     fn hash(_seed: u64, input: &[u8]) -> u32 {
-        // Zig: std.hash.Adler32.hash(input) — single-arg, seed ignored.
+        // Single-arg, seed ignored.
         bun_hash::Adler32::hash(input)
     }
 }
@@ -90,9 +88,8 @@ pub(crate) struct CityHash32;
 impl HashAlgorithm for CityHash32 {
     type Output = u32;
     fn hash(_seed: u64, input: &[u8]) -> u32 {
-        // Zig: std.hash.CityHash32.hash(str) — single-arg, seed ignored
-        // (Zig's CityHash32 has no `hashWithSeed`, so hashWrap takes the
-        // 1-arg branch and never reads the JS seed).
+        // Single-arg, seed ignored (the JS seed is never read; CityHash32
+        // has no seeded variant here).
         bun_hash::CityHash32::hash(input)
     }
 }
@@ -101,7 +98,6 @@ pub(crate) struct CityHash64;
 impl HashAlgorithm for CityHash64 {
     type Output = u64;
     fn hash(seed: u64, input: &[u8]) -> u64 {
-        // Zig: std.hash.CityHash64.hashWithSeed(str, seed) — bytes-first.
         bun_hash::CityHash64::hash_with_seed(input, seed)
     }
 }
@@ -134,8 +130,8 @@ impl HashAlgorithm for XxHash3 {
         // src/jsc/bindings/xxhash3.cpp. Output is bit-identical to the xxHash
         // reference, pinned by the vector suite in test/js/bun/util/hash.test.js.
         //
-        // Zig wrapper forces a u32 seed (via @truncate) before widening back to
-        // XxHash3's native u64 — preserve that truncation.
+        // The seed is truncated to u32 before widening back to XxHash3's
+        // native u64 — preserve that truncation for output stability.
         bun_highway::xxhash3_64(seed as u32 as u64, input)
     }
 }
@@ -144,7 +140,6 @@ pub(crate) struct Murmur32v2;
 impl HashAlgorithm for Murmur32v2 {
     type Output = u32;
     fn hash(seed: u64, input: &[u8]) -> u32 {
-        // Zig: std.hash.murmur.Murmur2_32.hashWithSeed(str, seed)
         bun_hash::Murmur2_32::hash_with_seed(input, seed as u32)
     }
 }
@@ -153,7 +148,6 @@ pub(crate) struct Murmur32v3;
 impl HashAlgorithm for Murmur32v3 {
     type Output = u32;
     fn hash(seed: u64, input: &[u8]) -> u32 {
-        // Zig: std.hash.murmur.Murmur3_32.hashWithSeed(str, seed)
         bun_hash::Murmur3_32::hash_with_seed(input, seed as u32)
     }
 }
@@ -162,7 +156,6 @@ pub(crate) struct Murmur64v2;
 impl HashAlgorithm for Murmur64v2 {
     type Output = u64;
     fn hash(seed: u64, input: &[u8]) -> u64 {
-        // Zig: std.hash.murmur.Murmur2_64.hashWithSeed(str, seed)
         bun_hash::Murmur2_64::hash_with_seed(input, seed)
     }
 }
@@ -171,15 +164,13 @@ pub(crate) struct Rapidhash;
 impl HashAlgorithm for Rapidhash {
     type Output = u64;
     fn hash(seed: u64, input: &[u8]) -> u64 {
-        // Zig: bun.deprecated.RapidHash.hash(seed, input)
         bun_hash::RapidHash::hash(seed, input)
     }
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Host functions — one per algorithm. Zig expressed these as
-// `pub const wyhash = hashWrap(std.hash.Wyhash);` (comptime fn returning a
-// JSHostFnZig). Rust spells the monomorphization explicitly.
+// Host functions — one per algorithm, each an explicit monomorphization of
+// `hash_wrap`.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[bun_jsc::host_fn]
@@ -271,14 +262,13 @@ pub(crate) fn create(global: &JSGlobalObject) -> JSValue {
 
 fn hash_wrap<H: HashAlgorithm>(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     let arguments = frame.arguments_old::<2>();
-    // SAFETY: `bun_vm()` never returns null for a Bun-owned global
-    // (see JSGlobalObject.zig:620); ArgumentsSlice borrows it for the call.
+    // SAFETY: `bun_vm()` never returns null for a Bun-owned global;
+    // ArgumentsSlice borrows it for the call.
     let mut args = jsc::ArgumentsSlice::init(global.bun_vm(), arguments.slice());
 
     let mut input: &[u8] = b"";
     let input_slice: ZigStringSlice;
-    // Hoisted to outlive the borrow stored in `input` (Zig's stack-value
-    // `array_buffer` lived for the whole function; mirror that scope here).
+    // Hoisted so `array_buffer` outlives the borrow stored in `input`.
     let array_buffer;
     if let Some(arg) = args.next_eat() {
         if let Some(blob) = arg.as_class_ref::<Blob>() {
@@ -318,12 +308,9 @@ fn hash_wrap<H: HashAlgorithm>(global: &JSGlobalObject, frame: &CallFrame) -> Js
         }
     }
 
-    // std.hash has inconsistent interfaces
-    //
-    // PORT NOTE: the Zig used `@hasDecl`/`ArgsTuple`/`bun.trait.isNumber` to
-    // pick between `hash` vs `hashWithSeed`, 1-arg vs 2-arg, and seed-first
-    // vs bytes-first. That dispatch is absorbed into `HashAlgorithm::hash`
-    // per-impl above; here we always read an optional seed and pass it.
+    // The per-algorithm hash/hashWithSeed signature differences are absorbed
+    // into `HashAlgorithm::hash` per-impl above; here we always read an
+    // optional seed and pass it.
     let mut seed: u64 = 0;
     if let Some(arg) = args.next_eat() {
         if arg.is_number() || arg.is_big_int() {
@@ -334,5 +321,3 @@ fn hash_wrap<H: HashAlgorithm>(global: &JSGlobalObject, frame: &CallFrame) -> Js
     let value = H::hash(seed, input);
     Ok(value.to_js(global))
 }
-
-// ported from: src/runtime/api/HashObject.zig
diff --git a/src/runtime/api/JSBundler.rs b/src/runtime/api/JSBundler.rs
index 5c9fa5dd73d..40610f0d62b 100644
--- a/src/runtime/api/JSBundler.rs
+++ b/src/runtime/api/JSBundler.rs
@@ -96,8 +96,6 @@ pub mod js_bundler {
             // copied, JS strings are decoded). Extract them into the lower-tier
             // map and release the wrapper immediately so no JSC handle crosses
             // threads.
-            // PERF(port): Zig stores the `BlobOrStringOrBuffer` directly; here we
-            // make one extra owned copy to keep `bun_bundler` free of JSC types.
             let bytes: Box<[u8]> = blob_or_string.slice().to_vec().into_boxed_slice();
             drop(blob_or_string);
 
@@ -111,7 +109,6 @@ pub mod js_bundler {
                 key.as_mut_slice(),
             );
 
-            // PERF(port): was assume_capacity
             this.map.put_assume_capacity(&key, bytes);
         }
 
@@ -850,7 +847,7 @@ pub mod js_bundler {
                         });
                     }
 
-                    // PORT NOTE: `get_if_exists_longest_common_path` wants `&[&[u8]]`
+                    // NOTE: `get_if_exists_longest_common_path` wants `&[&[u8]]`
                     // but `StringSet::keys()` yields `&[Box<[u8]>]`; build a borrow
                     // adapter on the stack.
                     let borrowed: Vec<&[u8]> = entry_points.iter().map(|b| b.as_ref()).collect();
@@ -949,23 +946,12 @@ pub mod js_bundler {
                 }
             }
 
-            // if (try config.getOptional(globalThis, "dir", ZigString.Slice)) |slice| {
-            //     defer slice.deinit();
-            //     this.appendSliceExact(slice.slice()) catch unreachable;
-            // } else {
-            //     this.appendSliceExact(globalThis.bunVM().transpiler.fs.top_level_dir) catch unreachable;
-            // }
-
             if let Some(slice) = config.get_optional_slice(global_this, b"publicPath")? {
                 this.public_path.append_slice_exact(slice.slice())?;
                 drop(slice);
             }
 
             if let Some(naming) = config.get_truthy(global_this, "naming")? {
-                // Zig kept a separate `owned_*: OwnedString` buffer per template
-                // and pointed `template.data` (a `[]const u8`) into it. Rust's
-                // `PathTemplate.data` is already `Box<[u8]>` (owned), so build
-                // straight into it — no self-referential borrow, no clone.
                 let with_dot_slash = |s: &[u8]| -> Box<[u8]> {
                     if s.starts_with(b"./") {
                         Box::<[u8]>::from(s)
@@ -1078,7 +1064,6 @@ pub mod js_bundler {
                     }
                     drop(prop_slice);
 
-                    // PERF(port): was assume_capacity
                     loader_values.push(loader_iter.value.to_enum_from_map(
                         global_this,
                         "loader",
@@ -1201,17 +1186,15 @@ pub mod js_bundler {
                             return Err(global_this.throw_invalid_arguments(format_args!("cannot use compile with an output file named 'bun' because bun won't realize it's a standalone executable. Please choose a different name for compile.outfile")));
                         }
 
-                        // PORT NOTE (diverges from Zig spec — flake fix): when no
-                        // `outdir`/`outfile` was given, the Zig path stores only
-                        // the basename here and `doCompilation` later resolves it
-                        // against the process-wide `top_level_dir`. Under the JS
-                        // API that means every `Bun.build({compile: true,
-                        // entrypoints: [tmp + "/app.js"]})` from any test process
-                        // writes the *same* `<cwd>/app`, so concurrently-running
-                        // test files race on the executable (observed flake in
-                        // bun-build-compile-sourcemap.test.ts). Placing the
+                        // NOTE: when no `outdir`/`outfile` was given, place the
                         // auto-derived executable next to its entry point — the
-                        // only path the caller actually supplied — keeps each
+                        // only path the caller actually supplied. Resolving the
+                        // basename against the process-wide cwd instead would
+                        // make every `Bun.build({compile: true, entrypoints:
+                        // [tmp + "/app.js"]})` from any test process write the
+                        // *same* `<cwd>/app`, so concurrently-running test files
+                        // would race on the executable (observed flake in
+                        // bun-build-compile-sourcemap.test.ts). This keeps each
                         // build's output inside its own (temp) directory and is
                         // also the more intuitive default for a programmatic API.
                         // Explicit `outfile`/`outdir` are unaffected.
@@ -1267,9 +1250,9 @@ pub mod js_bundler {
     // `Config` owns only `Drop`-aware fields (`Box<[u8]>` map values, `Vec`s,
     // `MutableString`, `Strong`); no manual `Drop` needed.
 
-    /// Zig kept a separate `owned_*: OwnedString` per template and pointed
-    /// `template.data: []const u8` into it (self-referential). Rust's
-    /// `PathTemplate.data` is `Box<[u8]>` (owned), so the indirection is gone.
+    /// Output path templates for entry points, chunks, and assets. Each
+    /// `PathTemplate.data` is owned (`Box<[u8]>`), so no separate backing
+    /// string per template is needed.
     pub struct Names {
         pub entry_point: options::PathTemplate,
         pub chunk: options::PathTemplate,
@@ -1358,7 +1341,7 @@ pub mod js_bundler {
         build(global_this, arguments.slice())
     }
 
-    // PORT NOTE: `Resolve`/`Load`/`MiniImportRecord`/etc. are owned by
+    // NOTE: `Resolve`/`Load`/`MiniImportRecord`/etc. are owned by
     // `bun_bundler::bundle_v2::api::JSBundler` so that `BundleV2` can operate
     // on them directly (`on_resolve_async`/`on_load_async`). `dispatch()` and
     // `run_on_js_thread()` are also inherent methods there — they only need
@@ -1401,7 +1384,6 @@ pub mod js_bundler {
         unsafe { &mut *bv2_mut(bv2).plugins.unwrap().as_ptr() }
     }
 
-    // TODO(port): move to runtime_sys
     /// # Safety
     /// `resolve` must be the live `*mut Resolve` previously handed to C++ via
     /// `Resolve::dispatch`; sole owner on the JS thread for the call duration.
@@ -1519,7 +1501,6 @@ pub mod js_bundler {
         BundleV2::on_notify_defer_mini(unsafe { &mut *load }, unsafe { &mut *ctx });
     }
 
-    // TODO(port): move to runtime_sys
     /// # Safety
     /// `load` must be the live `*mut Load` previously handed to C++ via
     /// `Load::dispatch`, and `global` must be the plugin's owning
@@ -1533,7 +1514,6 @@ pub mod js_bundler {
         unsafe { jsc::to_js_host_call(&*global, || (&mut *load).on_defer(&*global)) }
     }
 
-    // TODO(port): move to runtime_sys
     #[unsafe(no_mangle)]
     pub(crate) extern "C" fn JSBundlerPlugin__onLoadAsync(
         this: &mut Load,
@@ -1557,8 +1537,6 @@ pub mod js_bundler {
                         )),
                     );
                 }
-                // Zig: this.deinit() — explicit drop
-                // TODO(port): Load is not Box-allocated here; Zig deinit only resets value
                 this.value = LoadValue::Consumed;
                 return;
             }
@@ -1690,11 +1668,10 @@ pub mod js_bundler {
                 Err(JsError::Terminated) => return Err(JsError::Terminated),
             };
 
-            // Zig (JSBundler.zig:1572-1582) opens an explicit `TopExceptionScope`
-            // before the FFI call and `returnIfException`s after; the C++ side has
-            // a `DECLARE_THROW_SCOPE` whose dtor sets `m_needExceptionCheck` under
-            // `BUN_JSC_validateExceptionChecks=1`, so a post-hoc `has_exception()`
-            // (whose own scope ctor asserts) is wrong.
+            // The C++ side has a `DECLARE_THROW_SCOPE` whose dtor sets
+            // `m_needExceptionCheck` under `BUN_JSC_validateExceptionChecks=1`,
+            // so a post-hoc `has_exception()` (whose own scope ctor asserts) is
+            // wrong; open a top-level exception scope around the FFI call.
             bun_jsc::top_scope!(scope, global_this);
             let value = JSBundlerPlugin__runOnEndCallbacks(
                 self,
@@ -1768,9 +1745,8 @@ pub mod js_bundler {
     /// pending-item counter is decremented. Returning early here would cause
     /// `Bun.build` to hang forever waiting on the counter.
     ///
-    /// Runs on the JS thread, so allocations go through the global heap (Zig
-    /// passes `bun.default_allocator`); the bundler arena is owned by another
-    /// thread.
+    /// Runs on the JS thread, so allocations go through the global heap; the
+    /// bundler arena is owned by another thread.
     fn plugin_msg_from_js(plugin: &mut Plugin, file: &[u8], exception: JSValue) -> bun_ast::Msg {
         let global = plugin.global_object();
         match bun_ast_jsc::msg_from_js(global, file.to_vec(), exception) {
@@ -1800,7 +1776,6 @@ pub mod js_bundler {
         }
     }
 
-    // TODO(port): move to runtime_sys
     /// # Safety
     /// `plugin` must be a live `JSBundlerPlugin` opaque handle. `ctx` must be
     /// the live `*mut Resolve` (when `which == 0`) or `*mut Load` (when
@@ -1861,7 +1836,7 @@ pub struct BuildArtifact {
 /// callers stay unchanged.
 pub use bun_bundler::options::OutputKind;
 
-/// `JSValue::as(Blob)` BuildArtifact fallback (JSValue.zig:467) — declared
+/// `JSValue::as(Blob)` BuildArtifact fallback — declared
 /// `extern "Rust"` in `bun_jsc::webcore_types`; link-time resolved.
 #[unsafe(no_mangle)]
 pub(crate) fn __bun_blob_from_build_artifact(value: JSValue) -> Option<*mut Blob> {
@@ -1887,7 +1862,6 @@ impl BuildArtifact {
         global_this: &JSGlobalObject,
         callframe: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PERF(port): was @call(bun.callmod_inline, ...)
         this.blob.get_text(global_this, callframe)
     }
 
@@ -2004,7 +1978,7 @@ impl BuildArtifact {
 
         {
             formatter.indent_inc();
-            // PORT NOTE: reshaped for borrowck — scopeguard cannot reborrow
+            // NOTE: reshaped for borrowck — scopeguard cannot reborrow
             // `formatter` while it is also borrowed for the body; decrement
             // after the block instead.
 
@@ -2104,5 +2078,3 @@ impl BuildArtifact {
         Ok(())
     }
 }
-
-// ported from: src/runtime/api/JSBundler.zig
diff --git a/src/runtime/api/JSON5Object.rs b/src/runtime/api/JSON5Object.rs
index b85b4da966f..0ca08293d49 100644
--- a/src/runtime/api/JSON5Object.rs
+++ b/src/runtime/api/JSON5Object.rs
@@ -86,9 +86,9 @@ struct Stringifier {
     builder: wtf::StringBuilder,
     indent: usize,
     space: Space,
-    // PORT NOTE: `JSValue` keys live on the heap here, but every entry is also
+    // NOTE: `JSValue` keys live on the heap here, but every entry is also
     // live on the native stack via the `stringify_value` recursion chain, so the
-    // conservative GC scan keeps them alive. Matches the Zig.
+    // conservative GC scan keeps them alive.
     visiting: HashMap<JSValue, ()>,
 }
 
@@ -137,7 +137,7 @@ impl Space {
     }
 }
 
-// PORT NOTE: `Space::deinit` deleted — `BunString` field derefs via `Drop`.
+// NOTE: `Space::deinit` deleted — `BunString` field derefs via `Drop`.
 
 impl Stringifier {
     pub(crate) fn init(global: &JSGlobalObject, space_value: JSValue) -> JsResult<Stringifier> {
@@ -150,7 +150,7 @@ impl Stringifier {
         })
     }
 
-    // PORT NOTE: `deinit` deleted — all fields (`builder`, `space`, `visiting`)
+    // NOTE: `deinit` deleted — all fields (`builder`, `space`, `visiting`)
     // free via `Drop`.
 
     pub(crate) fn stringify_value(
@@ -208,16 +208,22 @@ impl Stringifier {
             return Ok(());
         }
 
-        // Object or array — check for circular references
-        // TODO(port): narrow error set — `try_insert`/`get_or_put` OOM maps to JsError::OutOfMemory
-        let was_present = self.visiting.insert(unwrapped, ()).is_some();
+        // Object or array — check for circular references.
+        // The call site is wired for fallible
+        // allocation (Err → OutOfMemory), but `zig_hash_map`'s grow path currently
+        // allocates infallibly and aborts on OOM, so the Err arm only becomes live
+        // once the collections-side grow is made fallible.
+        let was_present = self
+            .visiting
+            .get_or_put(unwrapped)
+            .map_err(|_| StringifyError::Js(JsError::OutOfMemory))?
+            .found_existing;
         if was_present {
             return Err(global
                 .throw(format_args!("Converting circular structure to JSON5"))
                 .into());
         }
-        // PORT NOTE: reshaped for borrowck — Zig used `defer visiting.remove`;
-        // a scopeguard here would hold `&mut self.visiting` across the recursive
+        // NOTE: a scopeguard here would hold `&mut self.visiting` across the recursive
         // `&mut self` calls below, so remove manually after the call instead.
         let result = if unwrapped.is_array() {
             self.stringify_array(global, unwrapped)
@@ -427,9 +433,8 @@ impl Stringifier {
 }
 
 fn estring_to_js(str: &E::EString, global: &JSGlobalObject) -> JsResult<JSValue> {
-    // PORT NOTE: shim for `EString::to_js(allocator, global)` (lives in
-    // `bun_ast::e::String` Zig-side). The JSON5 parser never builds
-    // ropes, so the simple slice → JS path is sufficient.
+    // NOTE: the JSON5 parser never builds ropes, so the simple slice → JS
+    // path is sufficient.
     if str.is_utf16 {
         let zig = ZigString::init_utf16(str.slice16());
         let bun_s = BunString::init(zig);
@@ -479,5 +484,3 @@ fn expr_to_js_with_check(
         _ => Ok(JSValue::UNDEFINED),
     }
 }
-
-// ported from: src/runtime/api/JSON5Object.zig
diff --git a/src/runtime/api/JSONCObject.rs b/src/runtime/api/JSONCObject.rs
index 9f24c28f726..3bcdf084ae8 100644
--- a/src/runtime/api/JSONCObject.rs
+++ b/src/runtime/api/JSONCObject.rs
@@ -39,5 +39,3 @@ pub fn parse(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         },
     )
 }
-
-// ported from: src/runtime/api/JSONCObject.zig
diff --git a/src/runtime/api/JSTranspiler.rs b/src/runtime/api/JSTranspiler.rs
index 4e2de009bd7..f1de7db502a 100644
--- a/src/runtime/api/JSTranspiler.rs
+++ b/src/runtime/api/JSTranspiler.rs
@@ -47,15 +47,13 @@ pub struct JSTranspiler {
     pub scan_pass_result: JsCell<ScanPassResult>,
     pub buffer_writer: JsCell<Option<JSPrinter::BufferWriter>>,
     pub log_level: bun_ast::Level,
-    // TODO(port): non-AST crate keeps an arena field for bulk-freeing config strings.
-    // Consider replacing with per-field Box ownership.
-    // Boxed so its address is stable across the move into `Box<JSTranspiler>` —
+    // Arena bulk-frees the config strings. Boxed so its
+    // address is stable across the move into `Box<JSTranspiler>` —
     // `transpiler.arena` holds a `&'static Arena` pointing into it.
     pub arena: Box<Arena>,
-    // Intrusive refcount field for `bun_ptr::IntrusiveRc<JSTranspiler>`.
-    // TODO(port): LIFETIMES.tsv classifies the consumer (`TransformTask.js_instance`) as
-    // `Arc<JSTranspiler>`, but `bun.ptr.RefCount` is single-thread intrusive and `*JSTranspiler`
-    // crosses FFI as `m_ctx`. Reconcile (likely IntrusiveRc, not Arc).
+    // Intrusive refcount field for `bun_ptr::IntrusiveRc<JSTranspiler>`:
+    // single-thread intrusive `bun.ptr.RefCount` because `*JSTranspiler`
+    // crosses FFI as `m_ctx` (per PORTING.md §Pointers; not `Arc`).
     pub ref_count: bun_ptr::RefCount<JSTranspiler>,
 }
 
@@ -116,8 +114,8 @@ impl Default for Config {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `from_js` enum lookups for `Loader`/`Target`. The canonical port of
-// `bundler_jsc/options_jsc.zig` lives in `bun_bundler_jsc::options_jsc` and
+// `from_js` enum lookups for `Loader`/`Target`. The canonical implementation
+// lives in `bun_bundler_jsc::options_jsc` and
 // carries the spec'd error semantics (throw `TypeError` on non-string / unknown
 // loader). The earlier local shims here only did a bare `phf` lookup and
 // silently returned `None` for unknown loaders, breaking
@@ -137,9 +135,8 @@ fn level_from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<Option<bun
     bun_ast::Level::MAP.from_js(global, value)
 }
 
-/// Deep-clone a [`MacroMap`]. Zig's `=` on `StringArrayHashMap` is a struct copy
-/// that shares the backing slice; Rust's keys are `Box<[u8]>` so an owned copy
-/// is needed wherever the spec assigns by value.
+/// Deep-clone a [`MacroMap`]. The keys are `Box<[u8]>`, so an owned copy
+/// is needed wherever the map is assigned by value.
 fn clone_macro_map(src: &MacroMap) -> MacroMap {
     let mut out = MacroMap::default();
     bun_core::handle_oom(out.ensure_unused_capacity(src.count()));
@@ -160,7 +157,7 @@ const PROP_ITER_OPTS: JSPropertyIteratorOptions = JSPropertyIteratorOptions {
 };
 
 impl Config {
-    // PORT NOTE: out-param constructor kept as `&mut self` because `self` is a pre-initialized
+    // NOTE: out-param constructor kept as `&mut self` because `self` is a pre-initialized
     // field on `JSTranspiler` (in-place mutation), not a fresh value to return.
     pub fn from_js(
         &mut self,
@@ -214,7 +211,6 @@ impl Config {
                         )));
                     }
 
-                    // PERF(port): was appendAssumeCapacity — profile if hot.
                     names.push(prop.to_owned_slice().into());
                     let mut val = ZigString::init(b"");
                     property_value.to_zig_string(&mut val, global)?;
@@ -223,7 +219,6 @@ impl Config {
                     }
                     let mut buf = Vec::new();
                     write!(&mut buf, "{}", val).expect("unreachable");
-                    // PERF(port): was appendAssumeCapacity — profile if hot.
                     values.push(buf.into_boxed_slice());
                 }
 
@@ -520,10 +515,10 @@ impl Config {
                             if str.len == 0 {
                                 continue;
                             }
-                            // Spec uses `std.fmt.bufPrint` into the fixed spare capacity
-                            // (sized from UTF-16 code-unit lengths) and throws on overflow.
-                            // `write!` on a `Vec` would silently grow instead, so check the
-                            // bound explicitly to preserve the spec's overflow throw.
+                            // The capacity bound is sized from UTF-16 code-unit
+                            // lengths and overflowing it must throw. `write!` on a
+                            // `Vec` would silently grow instead, so check the
+                            // bound explicitly to preserve the overflow throw.
                             let start = buf.len();
                             write!(&mut buf, "{}", str).ok();
                             if buf.len() > total_name_buf_len as usize {
@@ -537,7 +532,6 @@ impl Config {
                             // can drop normally at end of scope.
                             let name_slice = &buf[start..start + name_len];
                             if name_len > 0 {
-                                // PERF(port): was putAssumeCapacity — profile if hot.
                                 replacements.put_assume_capacity(
                                     name_slice,
                                     bun_ast::runtime::ReplaceableExport::Delete,
@@ -563,14 +557,12 @@ impl Config {
                 if iter.len > 0 {
                     bun_core::handle_oom(replacements.ensure_unused_capacity(iter.len));
 
-                    // We cannot set the exception before `?` because it could be
-                    // a double free with the errdefer.
-                    // TODO(port): the Zig `defer if (globalThis.hasException()) { free keys; clear }`
-                    // is a conditional cleanup at scope exit. Model with scopeguard
-                    // (captures &mut replacements + &global; borrowck conflict with the loop
-                    // below — needs restructuring). Keys are Box<[u8]> in Rust, so dropping
-                    // `replacements` on `?` already frees them; only the explicit
-                    // `clear_and_free` on the has_exception path is unported.
+                    // Exception cleanup is covered by RAII: a pending exception
+                    // always surfaces as `Err(JsError::Thrown)` through `?`, and
+                    // `replacements` is a local (moved into
+                    // `self.runtime.replace_exports` only on success), so the
+                    // early return drops it — freeing the `Box<[u8]>` keys and
+                    // clearing the map.
 
                     while let Some(key_) = iter.next()? {
                         let value = iter.value;
@@ -588,12 +580,10 @@ impl Config {
                             )));
                         }
 
-                        // PERF(port): was getOrPutAssumeCapacity — profile if hot.
-                        // PORT NOTE: reshaped — `StringArrayHashMap::get_or_put` is gated on
+                        // NOTE: `StringArrayHashMap::get_or_put` is gated on
                         // `V: Default` upstream and `ReplaceableExport` has no Default. Compute
                         // the value first, then `put` (which upserts without needing a default
-                        // slot). The Zig getOrPut left the slot uninitialized on the error path
-                        // anyway, so this is strictly safer.
+                        // slot).
                         if let Some(expr) = export_replacement_value(value, global, arena)? {
                             replacements
                                 .put(&key, bun_ast::runtime::ReplaceableExport::Replace(expr))
@@ -670,14 +660,13 @@ pub(crate) struct TransformTask<'a> {
     /// [`bun_jsc::ThreadSafe`] guard unprotects on drop.
     pub input_code: bun_jsc::ThreadSafe<StringOrBuffer>,
     pub output_code: BunString,
-    /// Bitwise copy of `js_instance.transpiler` (Zig: `= transpiler.transpiler`).
+    /// Bitwise copy of `js_instance.transpiler`.
     /// Heap-owned fields (`Box<Define>`, resolver caches, …) are *shared* with
     /// `js_instance`, which is kept alive by the `IntrusiveRc` below for the
     /// task's lifetime. `ManuallyDrop` prevents double-free; the original owns.
     pub transpiler: core::mem::ManuallyDrop<Transpiler::Transpiler<'static>>,
-    // TODO(port): LIFETIMES.tsv says Arc<JSTranspiler> — reconcile. JSTranspiler uses
-    // single-thread intrusive `bun.ptr.RefCount` and crosses FFI as `m_ctx`, so per
-    // PORTING.md §Pointers this must be IntrusiveRc, not Arc.
+    // `IntrusiveRc` (not `Arc`): JSTranspiler uses single-thread intrusive
+    // `bun.ptr.RefCount` and crosses FFI as `m_ctx` (PORTING.md §Pointers).
     pub js_instance: bun_ptr::IntrusiveRc<JSTranspiler>,
     pub log: bun_ast::Log,
     pub err: Option<Error>,
@@ -714,10 +703,9 @@ impl<'a> TransformTask<'a> {
         let mut log = bun_ast::Log::init();
         log.level = config.log.level;
 
-        // SAFETY: bitwise struct copy mirroring Zig's by-value
-        // `transform_task.transpiler = transpiler.transpiler`. Heap-owned fields
-        // are shared with `js_instance` (kept alive via IntrusiveRc); the copy is
-        // wrapped in `ManuallyDrop` so only the original frees them.
+        // SAFETY: bitwise struct copy of `transpiler.transpiler`. Heap-owned
+        // fields are shared with `js_instance` (kept alive via IntrusiveRc); the
+        // copy is wrapped in `ManuallyDrop` so only the original frees them.
         let transpiler_copy = core::mem::ManuallyDrop::new(unsafe {
             core::ptr::read(transpiler.transpiler.as_ptr())
         });
@@ -736,14 +724,13 @@ impl<'a> TransformTask<'a> {
                 entries: config.runtime.replace_exports.entries.clone().expect("OOM"),
             },
             // SAFETY: `transpiler` is the live `m_ctx` payload; `init_ref` bumps the
-            // `Cell<u32>`-backed count (Zig: `transpiler.ref()`). `as_ctx_ptr`
+            // `Cell<u32>`-backed count. `as_ctx_ptr`
             // yields `*mut Self` from `&Self` — signature-only; the only mutation
             // is to the `RefCount` field, which is interior-mutable.
             js_instance: unsafe { bun_ptr::IntrusiveRc::init_ref(transpiler.as_ctx_ptr()) },
         });
 
-        // Zig: `transform_task.transpiler.linker.resolver = &transform_task.transpiler.resolver`
-        // — re-point the linker's resolver backref into the heap-allocated copy.
+        // Re-point the linker's resolver backref into the heap-allocated copy.
         // Must happen AFTER the move into the Box so the address is stable.
         let resolver_ptr: *mut _ = &raw mut transform_task.transpiler.resolver;
         transform_task.transpiler.linker.resolver = resolver_ptr;
@@ -761,9 +748,7 @@ impl<'a> TransformTask<'a> {
     pub(crate) fn run(&mut self) {
         let name = self.loader.stdin_name();
 
-        // PERF(port): was MimallocArena bulk-free — profile if hot.
         let arena = Arena::new();
-        // defer arena.deinit() → Drop
 
         // `self.transpiler` is a `ManuallyDrop` bytewise copy of the
         // `JSTranspiler`'s long-lived transpiler (`ptr::read` in `create()`),
@@ -864,9 +849,8 @@ impl<'a> TransformTask<'a> {
 
         if printed > 0 {
             buffer_writer = printer.ctx;
-            // TODO(port): `buffer_writer.buffer.list.items = buffer_writer.written;` —
-            // Zig truncates the Vec's view to `written`. Map to `.truncate(written.len())` or
-            // a slice copy depending on BufferWriter shape.
+            // `written()` reslices via `written_len`; copy out the printed
+            // bytes, then the local writer is dropped.
             self.output_code = BunString::clone_utf8(buffer_writer.written());
         } else {
             self.output_code = BunString::empty();
@@ -874,9 +858,11 @@ impl<'a> TransformTask<'a> {
     }
 
     pub(crate) fn then(&mut self, promise: &mut JSPromise) -> Result<(), bun_jsc::JsTerminated> {
-        // defer this.deinit() — handled by caller / Drop on Box<TransformTask>
-        // TODO(port): Zig `defer this.deinit()` here destroys self at end of `then`. In Rust,
-        // ConcurrentPromiseTask should own the Box and drop it after `then` returns.
+        // After `then` returns, the dispatcher
+        // (`run_then_destroy!` for `task_tag::AsyncTransformTask` in
+        // runtime/dispatch.rs) unconditionally calls
+        // `ConcurrentPromiseTask::destroy`, dropping the owned `ctx`
+        // (this `TransformTask`) and running its `Drop` (transpiler deref etc.).
 
         if self.log.has_any() || self.err.is_some() {
             let error_value: JsResult<JSValue> = 'brk: {
@@ -917,7 +903,7 @@ impl<'a> TransformTask<'a> {
 // released explicitly or the `JSTranspiler` never reaches refcount 0.
 impl<'a> Drop for TransformTask<'a> {
     fn drop(&mut self) {
-        // Release the +1 taken in `TransformTask::create` (Zig: `transpiler.deref()`).
+        // Release the +1 taken in `TransformTask::create`.
         bun_ptr::RefPtr::deref(&self.js_instance);
     }
 }
@@ -963,7 +949,7 @@ fn export_replacement_value(
         let zig_str = value.get_zig_string(global)?;
         let mut buf = Vec::new();
         write!(&mut buf, "{}", zig_str).expect("unreachable");
-        // Zig allocPrint'd into the caller's arena. Bump-allocate so the bytes
+        // Bump-allocate so the bytes
         // live as long as the JSTranspiler arena that owns the resulting Expr;
         // `E::EString::init` erases the borrow to `'static` per the AST
         // crate's `Str` convention (see ast/E.rs).
@@ -987,12 +973,16 @@ impl JSTranspiler {
     ) -> JsResult<*mut JSTranspiler> {
         let arguments = callframe.arguments_old::<3>();
 
-        // PORT NOTE: reshaped — Zig allocates `this` first with `transpiler = undefined` and
-        // assigns it later. Rust cannot leave a non-POD field uninitialized in a live Box
+        // NOTE: a non-POD field cannot be left uninitialized in a live Box
         // (zeroed()/assume_init() on Transpiler is UB), so build `config` + `transpiler` on the
-        // stack first, then move both into the Box.
-        // TODO(port): in-place init — if the Box must be allocated up-front (e.g. stable
-        // address for resolver backrefs), switch the field to `MaybeUninit<Transpiler>`.
+        // stack first, then move both into the Box. Nothing observes the
+        // `Box<JSTranspiler>` address before construction completes. The
+        // address-sensitive pointers are `transpiler.arena` (points into the
+        // separately-boxed `arena`, whose address is move-stable) and
+        // `transpiler.log` (initially points at the stack-local `config.log`;
+        // it is re-pointed via `set_log` once the Box exists — see the NOTE
+        // below), so no up-front allocation / `MaybeUninit` in-place init is
+        // needed.
         let mut config = Config {
             log: bun_ast::Log::init(),
             ..Default::default()
@@ -1056,9 +1046,8 @@ impl JSTranspiler {
         });
         // errdefer past this point → `this: Box<_>` drops and runs Drop for JSTranspiler.
 
-        // PORT NOTE: reshaped — Zig allocated `this` on the heap FIRST and passed `&this.config.log`
-        // into `Transpiler::init`, giving a stable address. We built `config` on the stack and
-        // moved it into the Box, so `transpiler.log` (a `*mut Log`) still points at the moved-from
+        // NOTE: `config` was built on the stack and moved into the Box, so
+        // `transpiler.log` (a `*mut Log`) still points at the moved-from
         // stack slot. Re-point it at the heap-stable field now that the Box exists.
         // SAFETY: `this: Box<_>` is exclusively owned (init-time, before the JS
         // wrapper exists) so projecting `&mut`/`*mut` from the JsCells is trivially
@@ -1143,10 +1132,6 @@ impl Drop for JSTranspiler {
     }
 }
 
-/// RAII guard mirroring Zig's
-/// `defer { setLog(&this.config.log); setAllocator(prev); arena.deinit(); }`
-/// (and `transformSync`'s full-snapshot `defer { this.transpiler = prev_bundler; }`).
-///
 /// `scan` / `transform_sync` / `scan_imports` temporarily point the long-lived
 /// `Transpiler` at a stack-local `Arena`/`Log`; on EVERY exit (including `?`
 /// and early `return Err`) those must be restored before the locals drop, or
@@ -1244,8 +1229,7 @@ impl JSTranspiler {
     /// Caller must not hold another `&`/`&mut` to `self.transpiler` for the
     /// borrow's lifetime. `Transpiler::parse` may re-enter JS via macros; if
     /// that JS calls back into a `JSTranspiler` host-fn on *this same instance*
-    /// the inner `Transpiler` is re-borrowed — a pre-existing spec-level hazard
-    /// (Zig holds a raw `*Transpiler` across the same call) that R-2's
+    /// the inner `Transpiler` is re-borrowed — a pre-existing hazard that R-2's
     /// outer-struct fix does not address. The R-2 invariant this upholds is
     /// that no `noalias &mut JSTranspiler` is live across that re-entry.
     #[inline]
@@ -1272,7 +1256,7 @@ impl JSTranspiler {
         // If code starts with { and doesn't end with ; it might be an object literal
         // that would otherwise be parsed as a block statement
         //
-        // Zig: `allocPrint(allocator, "({s})", .{code}) catch code` — allocated in the
+        // Allocated in the
         // CALLER's arena so the bytes outlive `parse()` and the returned `ParseResult`
         // (whose AST may hold slices into the source). A stack-local `Vec` would drop at
         // the end of this fn and leave dangling references.
@@ -1361,7 +1345,6 @@ impl JSTranspiler {
             return Ok(JSValue::ZERO);
         }
 
-        // PERF(port): was MimallocArena bulk-free — profile if hot.
         let arena = Arena::new();
         let mut log = bun_ast::Log::init();
         // defer log.deinit() → Drop
@@ -1501,7 +1484,6 @@ impl JSTranspiler {
             ));
         };
 
-        // PERF(port): was MimallocArena bulk-free — profile if hot.
         let arena = Arena::new();
         let Some(code_holder) = StringOrBuffer::from_js(global, code_arg)? else {
             return Err(global.throw_invalid_argument_type(
@@ -1556,7 +1538,7 @@ impl JSTranspiler {
         let mut ast_memory_allocator = bun_ast::ASTMemoryAllocator::borrowing(&arena);
         let _ast_scope = ast_memory_allocator.enter();
 
-        // PORT NOTE: spec snapshots the WHOLE `this.transpiler` by value
+        // NOTE: spec snapshots the WHOLE `this.transpiler` by value
         // (`prev_bundler = this.transpiler`) and restores it on exit. `Transpiler` is not
         // bitwise-copyable in Rust, so explicitly snapshot the fields the body mutates
         // (`allocator`, `log`, `macro_context`) and restore them via RAII guard.
@@ -1569,7 +1551,7 @@ impl JSTranspiler {
         let arena_ref: &'static Arena = unsafe { bun_ptr::detach_lifetime_ref(&arena) };
         let (prev_arena, prev_macro_context) = self.transpiler.with_mut(|t| {
             let prev_arena = t.arena;
-            // `take()` both reads the prior value AND nulls it (spec: `macro_context = null`).
+            // `take()` both reads the prior value AND nulls it.
             let prev_mc = t.macro_context.take();
             t.set_arena(arena_ref);
             t.set_log(&raw mut log);
@@ -1600,7 +1582,6 @@ impl JSTranspiler {
         let mut buffer_writer = self.buffer_writer.replace(None).unwrap_or_else(|| {
             let mut writer = JSPrinter::BufferWriter::init();
             bun_core::handle_oom(writer.buffer.grow_if_needed(code.len()));
-            // Zig: `writer.buffer.list.expandToCapacity()` — Vec<u8> can grow lazily; skip.
             writer
         });
 
@@ -1640,10 +1621,8 @@ fn named_exports_to_js(
         return JSValue::create_empty_array(global, 0);
     }
 
-    // PERF(port): was stack-fallback allocator — profile if hot.
-    // PORT NOTE: Zig sorted the map in-place via `StringArrayByIndexSorter` then iterated.
-    // `StringArrayHashMap` in Rust has no in-place sort, so collect the keys, sort them
-    // lexicographically (matching `strings.order`), then emit `BunString`s in that order.
+    // NOTE: `StringArrayHashMap` has no in-place sort, so collect the keys, sort them
+    // lexicographically, then emit `BunString`s in that order.
     let mut keys: Vec<&[u8]> = Vec::with_capacity(named_exports.count());
     let mut named_exports_iter = named_exports.iterator();
     while let Some(entry) = named_exports_iter.next() {
@@ -1749,7 +1728,6 @@ impl JSTranspiler {
             )));
         }
 
-        // PERF(port): was MimallocArena bulk-free — profile if hot.
         let arena = Arena::new();
         let mut log = bun_ast::Log::init();
         // defer log.deinit() → Drop
@@ -1793,10 +1771,10 @@ impl JSTranspiler {
         opts.macro_context = transpiler.macro_context.as_mut();
 
         // `options.define` is `Box<Define>` owned by the long-lived `Transpiler`;
-        // the parser borrows it for the arena lifetime (Zig held `*const Define`).
+        // the parser borrows it for the arena lifetime.
         let define = &*transpiler.options.define;
 
-        // PORT NOTE: spec calls `transpiler.resolver.caches.js.scan`. The
+        // NOTE: spec calls `transpiler.resolver.caches.js.scan`. The
         // resolver-side `cache::JavaScript` is a fieldless shell with
         // no `scan` body; the real `scan` lives on `bun_bundler::cache::JavaScript`.
         // Both are stateless unit structs, so calling the bundler-crate one
@@ -1811,9 +1789,9 @@ impl JSTranspiler {
             &source,
         );
 
-        // Zig: `defer this.scan_pass_result.reset()` covers every exit past this
-        // point (including the catch arm and the `try namedImportsToJS` error
-        // path). Compute the result, then reset unconditionally before returning.
+        // `scan_pass_result` must be reset on every exit past this point
+        // (including the error paths). Compute the result, then reset
+        // unconditionally before returning.
         let result = (|| -> JsResult<JSValue> {
             if let Err(err) = scan_result {
                 if (log.warnings + log.errors) > 0 {
@@ -1858,5 +1836,3 @@ pub fn is_likely_object_literal(code: &[u8]) -> bool {
     // Check if ends with semicolon - if so, it's likely a block statement
     !(end > 0 && code[end - 1] == b';')
 }
-
-// ported from: src/runtime/api/JSTranspiler.zig
diff --git a/src/runtime/api/MarkdownObject.rs b/src/runtime/api/MarkdownObject.rs
index 727ff8aae97..a5e423cbdd5 100644
--- a/src/runtime/api/MarkdownObject.rs
+++ b/src/runtime/api/MarkdownObject.rs
@@ -2,7 +2,7 @@
 
 use bun_core::StackCheck;
 use bun_jsc::{ArrayBuffer, CallFrame, JSGlobalObject, JSValue, JsResult, MarkedArgumentBuffer};
-// PORT NOTE: Zig's `bun.md` is `src/md/root.zig`; the Rust crate's lib.rs is a
+// Note: the `bun_md` crate's lib.rs is a
 // thin mod-decl shim, so alias the `root` module (which re-exports BlockType,
 // SpanType, TextType, SpanDetail, Renderer, helpers, types, ansi, …) as `md`.
 use crate::node::StringOrBuffer;
@@ -16,7 +16,6 @@ fn create_utf8_for_js(global: &JSGlobalObject, utf8: &[u8]) -> JsResult<JSValue>
     bun_jsc::bun_string_jsc::create_utf8_for_js(global, utf8)
 }
 
-/// `JSValue.push` (JSValue.zig:404).
 #[inline]
 fn js_array_push(arr: JSValue, global: &JSGlobalObject, item: JSValue) -> JsResult<()> {
     arr.push(global, item)
@@ -83,7 +82,6 @@ pub fn render_to_ansi(global_this: &JSGlobalObject, callframe: &CallFrame) -> Js
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
     }
 
-    // PERF(port): was arena bulk-free — profile if hot
     let Some(buffer) = StringOrBuffer::from_js(global_this, input_value)? else {
         return Err(global_this
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
@@ -157,7 +155,6 @@ pub(crate) fn render_to_html(
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
     }
 
-    // PERF(port): was arena bulk-free — profile if hot
     let Some(buffer) = StringOrBuffer::from_js(global_this, input_value)? else {
         return Err(global_this
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
@@ -218,12 +215,10 @@ fn parse_options(global_this: &JSGlobalObject, opts_value: JSValue) -> JsResult<
             }
         }
 
-        // Handle remaining boolean options (autolinks/headings are only settable via compound options above)
-        // TODO(port): comptime reflection over md::Options bool fields — Zig used
-        // `inline for (@typeInfo(md.Options).@"struct".fields)` to iterate every bool
-        // field (excluding the six handled above), checking both camelCase and
-        // snake_case keys. This list could be generated from md::Options
-        // (proc-macro or hand-maintained const slice in bun_md).
+        // Handle remaining boolean options (autolinks/headings are only settable via
+        // compound options above). `md::Options::BOOL_FIELD_SETTERS` is a hand-maintained
+        // table in bun_md that carries each bool field's snake_case and camelCase names
+        // plus a setter.
         for (snake, camel, set) in md::Options::BOOL_FIELD_SETTERS {
             // skip the compound-only fields
             if matches!(
@@ -249,12 +244,6 @@ fn parse_options(global_this: &JSGlobalObject, opts_value: JSValue) -> JsResult<
     Ok(options)
 }
 
-// TODO(port): `camelCaseOf` was a comptime fn producing `&'static [u8]` from a
-// snake_case literal. In Rust this should be `const_format::map_ascii_case!` or
-// a `macro_rules!` mapper. The only caller is the reflection loop above, which
-// is itself TODO'd to use a precomputed table that already carries the camelCase
-// form, so this helper is intentionally omitted.
-
 /// `Bun.markdown.render(text, callbacks, options?)` — render markdown with custom callbacks.
 ///
 /// Each callback receives the accumulated children as a string plus an optional
@@ -269,7 +258,6 @@ pub(crate) fn render(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsR
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
     }
 
-    // PERF(port): was arena bulk-free — profile if hot
     let Some(buffer) = StringOrBuffer::from_js(global_this, input_value)? else {
         return Err(global_this
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
@@ -314,9 +302,8 @@ pub(crate) fn render(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsR
 
 /// `Bun.markdown.react(text, components?, options?)` — returns a React Fragment element
 /// containing the parsed markdown as children.
-// TODO(port): Zig used `jsc.MarkedArgumentBuffer.wrap(renderReactImpl)` to generate
-// the host-fn shim that allocates a MarkedArgumentBuffer. Here we hand-roll the
-// equivalent until bun_jsc provides a `#[marked_args]` attribute.
+// The closure scopes a MarkedArgumentBuffer around the impl so every JSValue it
+// accumulates stays GC-visible for the duration of the call.
 #[bun_jsc::host_fn]
 pub(crate) fn render_react(
     global_this: &JSGlobalObject,
@@ -325,7 +312,6 @@ pub(crate) fn render_react(
     MarkedArgumentBuffer::new(|marked_args| render_react_impl(global_this, callframe, marked_args))
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn JSReactElement__createFragment(
         global_object: &JSGlobalObject,
@@ -373,7 +359,6 @@ fn render_ast(
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
     }
 
-    // PERF(port): was arena bulk-free — profile if hot
     let Some(buffer) = StringOrBuffer::from_js(global_this, input_value)? else {
         return Err(global_this
             .throw_invalid_arguments(format_args!("Expected a string or buffer to render")));
@@ -432,7 +417,7 @@ fn render_ast(
 struct ParseRenderer<'a> {
     global_object: &'a JSGlobalObject,
     marked_args: &'a mut MarkedArgumentBuffer,
-    // PORT NOTE: JSValue in Vec is safe here — every entry.children is also appended to self.marked_args (GC root).
+    // Note: JSValue in Vec is safe here — every entry.children is also appended to self.marked_args (GC root).
     stack: Vec<ParseStackEntry>,
     stack_check: StackCheck,
     src_text: &'a [u8],
@@ -441,7 +426,6 @@ struct ParseRenderer<'a> {
     react_version: Option<u8>,
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn JSReactElement__create(
         global_object: &JSGlobalObject,
@@ -485,13 +469,13 @@ struct Components {
     u: JSValue,
     br: JSValue,
 }
-// PORT NOTE: `Default` for JSValue must be `JSValue::ZERO` (encoded 0), matching Zig's `.zero` initializers.
+// Note: `Default` for JSValue must be `JSValue::ZERO` (encoded 0).
 
 struct ParseStackEntry {
     children: JSValue,
     data: u32,
     flags: u32,
-    // PORT NOTE: `SpanDetail` borrows from `src_text`; the `RendererImpl`
+    // Note: `SpanDetail` borrows from `src_text`; the `RendererImpl`
     // trait erases that lifetime, so we extend it to `'static` at the
     // `enter_span` boundary (see SAFETY note there). Entries are popped
     // and consumed strictly before `src_text` is dropped.
@@ -509,10 +493,9 @@ impl Default for ParseStackEntry {
     }
 }
 
-// PORT NOTE: Zig used a hand-rolled `*anyopaque + VTable`; the Rust `bun_md`
-// `Renderer` is `&mut dyn RendererImpl`, so the trait already gives us
-// `&mut self` — the `*_impl` bodies below are plain methods, no pointer
-// round-trip needed.
+// Note: the `bun_md` `Renderer` is `&mut dyn RendererImpl`, so the trait
+// already gives us `&mut self` — the `*_impl` bodies below are plain methods,
+// no pointer round-trip needed.
 impl<'a> md::types::RendererImpl for ParseRenderer<'a> {
     fn enter_block(
         &mut self,
@@ -572,7 +555,7 @@ impl<'a> ParseRenderer<'a> {
         Ok(self_)
     }
 
-    // PORT NOTE: deinit() dropped — Vec<ParseStackEntry> and HeadingIdTracker free via Drop.
+    // Note: deinit() dropped — Vec<ParseStackEntry> and HeadingIdTracker free via Drop.
 
     /// Extract component overrides from options. Any non-boolean truthy value
     /// (function, class, string, etc.) keyed by an HTML tag name is stored
@@ -718,9 +701,8 @@ impl<'a> ParseRenderer<'a> {
         let tag_index = get_block_type_tag(block_type, entry.data);
 
         // For headings, compute slug before counting props
-        // PORT NOTE: own the slug bytes — leave_heading() borrows the tracker mutably,
-        // and we need self again below for get_block_component(). Mirrors the Zig
-        // path which allocator-allocated the slug.
+        // Note: own the slug bytes — leave_heading() borrows the tracker mutably,
+        // and we need self again below for get_block_component().
         let slug: Option<Vec<u8>> = if block_type == md::BlockType::H {
             self.heading_tracker.leave_heading().map(|s| s.to_vec())
         } else {
@@ -973,7 +955,7 @@ impl<'a> ParseRenderer<'a> {
         if self.stack.is_empty() {
             return Ok(());
         }
-        // PORT NOTE: reshaped for borrowck — capture parent.children (Copy JSValue) instead of holding &mut into self.stack.
+        // Note: reshaped for borrowck — capture parent.children (Copy JSValue) instead of holding &mut into self.stack.
         let parent_children = self.stack.last().unwrap().children;
 
         match text_type {
@@ -1024,7 +1006,7 @@ impl<'a> ParseRenderer<'a> {
 /// callback's return value to the parent buffer.
 struct JsCallbackRenderer<'a> {
     global_object: &'a JSGlobalObject,
-    // PORT NOTE: #allocator field dropped — global mimalloc.
+    // Note: #allocator field dropped — global mimalloc.
     src_text: &'a [u8],
     stack: Vec<CallbackStackEntry>,
     callbacks: Callbacks,
@@ -1056,7 +1038,7 @@ struct Callbacks {
     strikethrough: JSValue,
     text: JSValue,
 }
-// PORT NOTE: `Default` for JSValue must be `JSValue::ZERO`.
+// Note: `Default` for JSValue must be `JSValue::ZERO`.
 
 struct CallbackStackEntry {
     buffer: Vec<u8>,
@@ -1066,7 +1048,7 @@ struct CallbackStackEntry {
     /// For ul/ol: number of li children seen so far (next li's index).
     /// For li: this item's 0-based index within its parent list.
     child_index: u32,
-    // PORT NOTE: `SpanDetail` borrows from `src_text`; the `RendererImpl`
+    // Note: `SpanDetail` borrows from `src_text`; the `RendererImpl`
     // trait erases that lifetime, so we extend it to `'static` at the
     // `enter_span` boundary (see SAFETY note there). Entries are popped
     // and consumed strictly before `src_text` is dropped.
@@ -1173,7 +1155,7 @@ impl<'a> JsCallbackRenderer<'a> {
         Ok(())
     }
 
-    // PORT NOTE: deinit() dropped — Vec<CallbackStackEntry> (with Vec<u8> buffers) and HeadingIdTracker free via Drop.
+    // Note: deinit() dropped — Vec<CallbackStackEntry> (with Vec<u8> buffers) and HeadingIdTracker free via Drop.
 
     fn renderer(&mut self) -> md::Renderer<'_> {
         md::Renderer { ptr: self }
@@ -1283,7 +1265,7 @@ impl<'a> JsCallbackRenderer<'a> {
         }
 
         let callback = self.get_block_callback(block_type);
-        // PORT NOTE: reshaped for borrowck — clone the saved entry (cheap; buffer not used) instead of holding a borrow across method calls.
+        // Note: reshaped for borrowck — clone the saved entry (cheap; buffer not used) instead of holding a borrow across method calls.
         let saved = if self.stack.len() > 1 {
             CallbackStackEntry {
                 buffer: Vec::new(),
@@ -1386,7 +1368,7 @@ impl<'a> JsCallbackRenderer<'a> {
         let mut buf = [0u8; 8];
         let decoded =
             md::helpers::decode_entity_to_utf8(entity_text, &mut buf).unwrap_or(entity_text);
-        // PORT NOTE: reshaped for borrowck — copy the (≤8-byte) decoded slice out of `buf`
+        // Note: reshaped for borrowck — copy the (≤8-byte) decoded slice out of `buf`
         // before calling &mut self method, to avoid overlapping borrows when the
         // borrow checker tracks `buf` as borrowed by `decoded`.
         self.append_text_or_raw(decoded)
@@ -1654,7 +1636,6 @@ pub(crate) enum TagIndex {
     Br = 29,
 }
 
-// TODO(port): move to <area>_sys
 // `JSGlobalObject` is `#[repr(C)]` with `UnsafeCell<[u8; 0]>`, so `&JSGlobalObject`
 // is ABI-identical to a non-null pointer; all other params are value types.
 unsafe extern "C" {
diff --git a/src/runtime/api/NativePromiseContext.rs b/src/runtime/api/NativePromiseContext.rs
index b0a73ae7a04..86fa7fe727c 100644
--- a/src/runtime/api/NativePromiseContext.rs
+++ b/src/runtime/api/NativePromiseContext.rs
@@ -28,9 +28,8 @@ use crate::api::html_rewriter;
 use crate::api::server;
 use crate::webcore::body;
 
-// Zig's `server.HTTPServer.RequestContext` etc. are nested types on each
-// `NewServer(..)` instantiation. The Rust port flattens that to a single
-// generic `NewRequestContext<ThisServer, SSL, DEBUG, HTTP3>`; alias the six
+// Request contexts are a single generic
+// `NewRequestContext<ThisServer, SSL, DEBUG, HTTP3>`; alias the six
 // concrete monomorphizations here so the tag↔type mapping stays readable.
 type HTTPServerRequestContext = server::NewRequestContext<server::HTTPServer, false, false, false>;
 type HTTPSServerRequestContext = server::NewRequestContext<server::HTTPSServer, true, false, false>;
@@ -77,17 +76,15 @@ impl Tag {
     }
 }
 
-/// Maps a concrete native type to its `Tag`. This replaces Zig's
-/// `Tag.fromType(comptime T: type)` which switched on `@TypeOf` — Rust
-/// expresses the same compile-time mapping as a trait impl per type.
+/// Maps a concrete native type to its `Tag`, expressed as a compile-time
+/// mapping via a trait impl per type.
 pub(crate) trait NativePromiseContextType {
     const TAG: Tag;
 }
 
-// PORT NOTE (layering): blanket-impl over `ThisServer` so that ANY server
+// Layering note: blanket-impl over `ThisServer` so that ANY server
 // type (mod.rs::NewServer or server_body::NewServer) yields the same Tag —
-// the tag depends only on (SSL, DBG, H3), never on the server type. This is
-// the Zig semantics (the Zig Tag enum cases name the (ssl,debug,h3) tuple).
+// the tag depends only on (SSL, DBG, H3), never on the server type.
 const fn npc_tag_for(ssl: bool, dbg: bool, h3: bool) -> Tag {
     match (ssl, dbg, h3) {
         (false, false, false) => Tag::HTTPServerRequestContext,
@@ -110,7 +107,6 @@ impl NativePromiseContextType for body::ValueBufferer<'_> {
     const TAG: Tag = Tag::BodyValueBufferer;
 }
 
-// TODO(port): move to <runtime>_sys
 // `&JSGlobalObject` is ABI-identical to a non-null pointer. `ctx` is stored
 // opaquely (never dereferenced by the C++ side), so the FFI itself has no
 // pointer-validity precondition — the ref-count contract is documented on
@@ -166,9 +162,8 @@ pub(crate) extern "C" fn Bun__NativePromiseContext__destroy(ctx: *mut c_void, ta
 ///     │ ctx ptr (aligned)  │ our Tag │
 ///     └────────────────────┴─────────┘
 ///
-/// Zig packed both into a 49-bit bitfield via `setUintptr`; the Rust `Task`
-/// stores `{ tag, ptr }` as separate fields, so the discriminant is carried
-/// in `Task.tag` and only the ctx|Tag packing remains in `Task.ptr`.
+/// `Task` stores `{ tag, ptr }` as separate fields, so the discriminant is
+/// carried in `Task.tag` and only the ctx|Tag packing remains in `Task.ptr`.
 pub(crate) struct DeferredDerefTask;
 
 impl Taskable for DeferredDerefTask {
@@ -191,10 +186,8 @@ impl DeferredDerefTask {
         let addr = ctx as usize;
         debug_assert!(addr & Self::TAG_MASK == 0);
 
-        // Zig stamped the discriminant via `Task.init(&marker)` then overwrote
-        // the packed `_ptr` bitfield with `setUintptr(@truncate(addr | tag))`.
-        // The Rust `Task` is a plain `{ tag, ptr }` pair (no bitfield packing),
-        // so build it directly — dispatch unpacks via `task.ptr as usize`.
+        // `Task` is a plain `{ tag, ptr }` pair (no bitfield packing), so
+        // build it directly — dispatch unpacks via `task.ptr as usize`.
         let task = Task::new(
             <DeferredDerefTask as Taskable>::TAG,
             (addr | (tag as usize)) as *mut (),
@@ -255,5 +248,3 @@ const _: () =
     assert!(core::mem::align_of::<DebugHTTPSServerRequestContext>() > DeferredDerefTask::TAG_MASK);
 const _: () =
     assert!(core::mem::align_of::<body::ValueBufferer<'_>>() > DeferredDerefTask::TAG_MASK);
-
-// ported from: src/runtime/api/NativePromiseContext.zig
diff --git a/src/runtime/api/TOMLObject.rs b/src/runtime/api/TOMLObject.rs
index 63bde07cc49..7deed966c70 100644
--- a/src/runtime/api/TOMLObject.rs
+++ b/src/runtime/api/TOMLObject.rs
@@ -33,7 +33,6 @@ pub fn parse(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
             // for now...
             let buffer_writer = js_printer::BufferWriter::init();
             let mut writer = js_printer::BufferPrinter::init(buffer_writer);
-            // PORT NOTE: Zig passed `*js_printer.BufferPrinter` as a comptime type param; dropped per (comptime X: type, arg: X) rule
             if js_printer::print_json(
                 &mut writer,
                 parse_result,
@@ -56,5 +55,3 @@ pub fn parse(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         },
     )
 }
-
-// ported from: src/runtime/api/TOMLObject.zig
diff --git a/src/runtime/api/UnsafeObject.rs b/src/runtime/api/UnsafeObject.rs
index fe134902e60..5c92dc9a83a 100644
--- a/src/runtime/api/UnsafeObject.rs
+++ b/src/runtime/api/UnsafeObject.rs
@@ -60,7 +60,6 @@ pub(crate) fn array_buffer_to_string(
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn dump_zone_malloc_stats();
     safe fn Bun__memoryFootprint() -> usize;
@@ -83,16 +82,19 @@ fn memory_footprint(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JS
 }
 
 #[bun_jsc::host_fn]
-fn dump_mimalloc(global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
-    // SAFETY: `bun_vm()` returns a non-null `*mut VirtualMachine` for a Bun-owned global.
-    let _vm = global.bun_vm();
-    // TODO(port): blocked_on: bun_alloc::Arena::dump_stats — `VirtualMachine.arena` is now
-    // `Option<NonNull<bumpalo::Bump>>` and bumpalo has no `dump_stats()`; the original
-    // mimalloc-arena stat dump needs a dedicated shim once the arena type lands.
+fn dump_mimalloc(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
+    // Print the process-wide mimalloc stats to stderr via
+    // `mi_stats_print_out` directly.
+    extern "C" fn dump(text: *const core::ffi::c_char, _arg: *mut core::ffi::c_void) {
+        // SAFETY: mimalloc passes a valid NUL-terminated string.
+        let text = unsafe { core::ffi::CStr::from_ptr(text) };
+        let _ = bun_core::Output::error_writer().write_all(text.to_bytes());
+    }
+    // SAFETY: `dump` matches `mi_output_fun` and does not unwind.
+    unsafe { bun_alloc::mimalloc::mi_stats_print_out(Some(dump), core::ptr::null_mut()) };
+    bun_core::Output::flush();
     if bun_alloc::heap_breakdown::ENABLED {
         dump_zone_malloc_stats();
     }
     Ok(JSValue::UNDEFINED)
 }
-
-// ported from: src/runtime/api/UnsafeObject.zig
diff --git a/src/runtime/api/YAMLObject.rs b/src/runtime/api/YAMLObject.rs
index 8cdf6649719..ffb4193dd46 100644
--- a/src/runtime/api/YAMLObject.rs
+++ b/src/runtime/api/YAMLObject.rs
@@ -75,8 +75,7 @@ pub(crate) struct Stringifier {
 pub(crate) enum Space {
     Minified,
     Number(u32),
-    /// +1 WTF ref owned for the lifetime of the `Stringifier` (Zig:
-    /// `Space.deinit() → str.deref()`).
+    /// +1 WTF ref owned for the lifetime of the `Stringifier`.
     Str(OwnedString),
 }
 
@@ -114,10 +113,9 @@ pub(crate) struct AnchorAlias {
 
 impl Default for AnchorAlias {
     fn default() -> Self {
-        // PORT NOTE: `HashMap::get_or_put` requires `V: Default` to fill the
-        // freshly-inserted slot before the caller overwrites `*value_ptr`. Zig
-        // left it `undefined`; this is the closest legal Rust equivalent and is
-        // immediately overwritten by the caller (see `find_anchors_and_aliases`).
+        // Exists only because `HashMap::get_or_put` requires `V: Default` to
+        // fill the freshly-inserted slot; the value is immediately overwritten
+        // by the caller (see `find_anchors_and_aliases`).
         AnchorAlias {
             anchored: false,
             used: false,
@@ -240,7 +238,6 @@ impl Stringifier {
             return Ok(());
         }
 
-        // Zig: `bun.assertWithLocation(cond, @src())` gated on `bun.Environment.ci_assert`.
         debug_assert!(unwrapped.is_object());
 
         let object_entry = self.known_collections.get_or_put(unwrapped)?;
@@ -380,7 +377,6 @@ impl Stringifier {
             return Ok(());
         }
 
-        // Zig: `bun.assertWithLocation(cond, @src())` gated on `bun.Environment.ci_assert`.
         debug_assert!(unwrapped.is_object());
 
         let has_anchor: Option<&mut AnchorAlias> = 'has_anchor: {
@@ -424,7 +420,8 @@ impl Stringifier {
                 return Ok(());
             }
 
-            // PORT NOTE: reshaped for borrowck — set anchored before newline()
+            // `anchored` is set before `newline()` (the order is irrelevant to
+            // output; doing it here releases the `anchor` borrow first).
             anchor.anchored = true;
             match self.space {
                 Space::Minified => {
@@ -1218,5 +1215,3 @@ impl<'a> ParserCtx<'a> {
         }
     }
 }
-
-// ported from: src/runtime/api/YAMLObject.zig
diff --git a/src/runtime/api/bun/SSLContextCache.rs b/src/runtime/api/bun/SSLContextCache.rs
index fbe1bda339a..92a9401d071 100644
--- a/src/runtime/api/bun/SSLContextCache.rs
+++ b/src/runtime/api/bun/SSLContextCache.rs
@@ -23,7 +23,7 @@ use core::ffi::{c_int, c_long, c_void};
 use core::ptr;
 
 use bun_boringssl_sys as boringssl;
-use bun_collections::ArrayHashMap;
+use bun_collections::array_hash_map::{ArrayHashContext, ArrayHashMap};
 use bun_threading::Mutex;
 use bun_uws as uws;
 use bun_uws::create_bun_socket_error_t;
@@ -33,8 +33,7 @@ use crate::api::server::server_config::SSLConfig;
 
 #[derive(Default)]
 pub struct SSLContextCache {
-    // TODO(port): ArrayHashMap needs custom context = DigestContext, store_hash = false
-    map: ArrayHashMap<Digest, *mut Entry>,
+    map: ArrayHashMap<Digest, *mut Entry, DigestContext>,
     mutex: Mutex,
     ops_since_compact: u32,
 }
@@ -45,17 +44,19 @@ pub type Digest = [u8; 32];
 /// bucket hash — no need to re-Wyhash 32 bytes (what AutoContext would do).
 /// `eql` still compares the full digest. `store_hash = false` since recompute
 /// is a single load.
+#[derive(Default)]
 pub struct DigestContext;
 
-impl DigestContext {
-    pub fn hash(&self, k: &Digest) -> u32 {
+impl ArrayHashContext<Digest> for DigestContext {
+    #[inline]
+    fn hash(&self, k: &Digest) -> u32 {
         u32::from_le_bytes([k[0], k[1], k[2], k[3]])
     }
-    pub fn eql(&self, a: &Digest, b: &Digest, _: usize) -> bool {
+    #[inline]
+    fn eql(&self, a: &Digest, b: &Digest, _b_index: usize) -> bool {
         bun_core::strings::eql_long(a, b, false)
     }
 }
-// TODO(port): wire DigestContext as the ArrayHashMap hasher/eq (Zig: 4th generic param)
 
 pub struct Entry {
     /// Nulled by `bun_ssl_ctx_cache_on_free` when BoringSSL drops the last
@@ -270,12 +271,9 @@ impl Drop for SSLContextCache {
 
 pub mod c {
     use core::ffi::c_int;
-    // TODO(port): move to bun_uws_sys
     unsafe extern "C" {
         /// Registered alongside the other usockets ex_data slots in
         /// `us_ex_idx_init` (pthread_once-guarded).
         pub safe fn us_ssl_ctx_cache_ex_idx() -> c_int;
     }
 }
-
-// ported from: src/runtime/api/bun/SSLContextCache.zig
diff --git a/src/runtime/api/bun/SecureContext.rs b/src/runtime/api/bun/SecureContext.rs
index deb91602e37..1fbeb267a1a 100644
--- a/src/runtime/api/bun/SecureContext.rs
+++ b/src/runtime/api/bun/SecureContext.rs
@@ -21,8 +21,8 @@ use bun_jsc::JsClass as _;
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use bun_uws as uws;
 
-/// Mirrors Zig's `pub const js = jsc.Codegen.JSSecureContext`. Re-export the
-/// codegen-emitted module so `$zig(SecureContext.zig, js.getConstructor)` in
+/// Re-export the codegen-emitted module so
+/// `$zig(SecureContext.zig, js.getConstructor)` in
 /// `generated_js2native.rs` resolves as `secure_context::js::get_constructor`.
 pub use crate::generated_classes::js_SecureContext as js;
 
@@ -53,7 +53,7 @@ pub(crate) fn js_live_count(_global: &JSGlobalObject, _callframe: &CallFrame) ->
 }
 
 impl SecureContext {
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the `Free` shim it emits calls
+    // Note: no `#[bun_jsc::host_fn]` here — the `Free` shim it emits calls
     // a bare `constructor(...)` which cannot resolve inside an `impl`. The
     // `#[bun_jsc::JsClass]` macro already emits the `<Self>::constructor` shim.
     pub fn constructor(
@@ -79,9 +79,9 @@ impl SecureContext {
     /// digest so identical configs return the same `JSSecureContext` cell while
     /// it's alive; falls through to `create()` (which itself hits the native
     /// `SSLContextCache`) on miss. Returning the same cell is what makes
-    /// `secureContext === createSecureContext(opts)` hold and lets `Listener.zig`
+    /// `secureContext === createSecureContext(opts)` hold and lets `Listener`
     /// pointer-compare without a JS-side WeakRef map.
-    // PORT NOTE: codegen (`generated_classes.rs::SecureContextClass__intern`)
+    // Note: codegen (`generated_classes.rs::SecureContextClass__intern`)
     // wraps this in `host_fn_result` and exports the C-ABI shim, so no
     // `#[bun_jsc::host_fn]` here — that macro's Free shim calls by bare name
     // and cannot resolve an associated fn.
@@ -140,7 +140,7 @@ impl SecureContext {
         d: [u8; 32],
     ) -> JsResult<Box<SecureContext>> {
         let mut err = uws::create_bun_socket_error_t::none;
-        // PORT NOTE: spec is `global.bunVM().rareData().sslCtxCache()`. In the
+        // Note: spec is `global.bunVM().rareData().sslCtxCache()`. In the
         // Rust crate split, `bun_jsc::RareData::ssl_ctx_cache()` returns an
         // opaque cycle-break stub; the concrete per-VM `SSLContextCache` lives
         // on this crate's `RuntimeState` (one per JS thread, same lifetime as
@@ -206,7 +206,6 @@ use bun_uws_sys::socket_context::c;
 
 mod cpp {
     use super::*;
-    // TODO(port): move to runtime_sys
     unsafe extern "C" {
         pub(super) safe fn Bun__SecureContextCache__get(
             global: &JSGlobalObject,
@@ -219,5 +218,3 @@ mod cpp {
         );
     }
 }
-
-// ported from: src/runtime/api/bun/SecureContext.zig
diff --git a/src/runtime/api/bun/Terminal.rs b/src/runtime/api/bun/Terminal.rs
index 32a4dca9428..18bc8315148 100644
--- a/src/runtime/api/bun/Terminal.rs
+++ b/src/runtime/api/bun/Terminal.rs
@@ -40,8 +40,7 @@ bun_output::declare_scope!(Terminal, hidden);
 
 // Generated bindings — `jsc.Codegen.JSTerminal`. The `.classes.ts` codegen
 // emits `crate::generated_classes::js_Terminal` with `from_js`/`to_js` and the
-// cached-value accessors; re-export here so callers continue to spell `js::*`
-// (matching Zig's `js.toJS`/`js.gc.set(.data, …)`).
+// cached-value accessors; re-export here so callers continue to spell `js::*`.
 pub use self::js::{from_js, from_js_direct, to_js};
 pub mod js {
     pub use crate::generated_classes::js_Terminal::{
@@ -49,7 +48,7 @@ pub mod js {
         exit_set_cached, from_js, from_js_direct, get_constructor, to_js,
     };
 
-    /// Zig: `js.gc` — typed accessor for the `values:` slots.
+    /// Typed accessor for the `values:` slots.
     pub mod gc {
         use bun_jsc::{JSGlobalObject, JSValue};
 
@@ -144,9 +143,9 @@ pub struct Terminal {
     event_loop_handle: EventLoopHandle,
 
     /// Global object reference. Read-only after construction.
-    // PORT NOTE: LIFETIMES.tsv says JSC_BORROW → `&JSGlobalObject`, but Terminal
-    // is a heap-allocated `.classes.ts` m_ctx payload and cannot carry a lifetime
-    // param. Stored as a `BackRef`; deref via `self.global()`.
+    // Terminal is a heap-allocated `.classes.ts` m_ctx payload and cannot
+    // carry a lifetime param, so the global is stored as a `BackRef` rather
+    // than `&JSGlobalObject`; deref via `self.global()`.
     global_this: bun_ptr::BackRef<JSGlobalObject>,
 
     /// Writer for sending data to the terminal
@@ -215,7 +214,7 @@ impl Default for Options {
     }
 }
 
-// Local extension shims for `JSValue.getOptional` (Terminal.zig). Typed
+// Local extension shims for typed optional property reads. Typed
 // `getOptional` is not yet a single inherent generic on `bun_jsc::JSValue`;
 // these wrap `get` + the per-type coercion. `withAsyncContextIfNeeded` is the
 // inherent `JSValue::with_async_context_if_needed` in `bun_jsc` — call sites
@@ -296,8 +295,8 @@ impl Options {
 
 impl Drop for Options {
     fn drop(&mut self) {
-        // term_name: ZigString::Slice has its own Drop; reset to default afterward
-        // matches Zig `this.* = .{}` but is unnecessary in Rust.
+        // term_name: ZigString::Slice has its own Drop; nothing further to
+        // clean up here.
     }
 }
 
@@ -431,7 +430,7 @@ impl Terminal {
         // doesn't double-free on the WriterStartFailed/ReaderStartFailed paths.
         options.term_name = ZigStringSlice::default();
 
-        // `bun.new(Terminal, .{...})` → heap::alloc; the intrusive ref_count
+        // Heap-allocate the Terminal; the intrusive ref_count
         // field starts at 1 (JS side's ref). Wrapped as IntrusiveRc on success.
         let terminal: *mut Terminal = bun_core::heap::into_raw(Box::new(Terminal {
             ref_count: bun_ptr::RefCount::init(),
@@ -650,8 +649,6 @@ impl Terminal {
     /// `create_from_spawn` whose subprocess never started. Downgrades the
     /// JSRef so the wrapper is GC-eligible, marks `finalized` so
     /// `on_reader_done` skips the JS exit callback, and runs `close_internal`.
-    /// Mirrors the `defer { terminal_info.? }` block in
-    /// `js_bun_spawn_bindings.zig`.
     pub(crate) fn abandon_from_spawn(&self) {
         self.this_value.with_mut(|v| v.downgrade());
         self.update_flags(|f| f.insert(Flags::FINALIZED));
@@ -697,9 +694,8 @@ impl Terminal {
     /// before the thread completes.
     #[cfg(windows)]
     fn close_pseudoconsole_off_thread(&self, hpcon: windows::HPCON) {
-        // PORT NOTE: Zig used `std.Thread.spawn(.{}, fn, .{hpcon})` then
-        // `.detach()`. PORTING.md bans std::process but not std::thread; a raw
-        // detached OS thread matches the Zig (no event-loop integration needed).
+        // PORTING.md bans std::process but not std::thread; a raw detached OS
+        // thread is intentional here (no event-loop integration needed).
         let hpcon_addr = hpcon as usize;
         match std::thread::Builder::new().spawn(move || {
             // SAFETY: hpcon was a valid HPCON when taken; ClosePseudoConsole is
@@ -794,9 +790,9 @@ mod lib_util {
     use super::*;
     use bun_core::ZStr;
 
-    // PORT NOTE: Zig used non-atomic file-level vars (single-threaded init).
-    // PORTING.md §Global mutable state: bool→AtomicBool; handle slot is an
-    // AtomicPtr (null ⇔ None — dlopen never yields a null Some). JS-thread-only.
+    // Per PORTING.md §Global mutable state: the flag is an AtomicBool and the
+    // handle slot an AtomicPtr (null ⇔ None — dlopen never yields a null Some).
+    // JS-thread-only.
     static HANDLE: core::sync::atomic::AtomicPtr<c_void> =
         core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
     static LOADED: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
@@ -834,8 +830,8 @@ fn get_open_pty_fn() -> Option<OpenPtyFn> {
     // On macOS, openpty is in libc, so we can use it directly
     #[cfg(target_os = "macos")]
     {
-        // PORT NOTE: declared locally (not via the `libc` crate) so the
-        // `OpenPtyFn` type unifies with the Linux dlsym path.
+        // Declared locally (not via the `libc` crate) so the `OpenPtyFn`
+        // type unifies with the Linux dlsym path.
         unsafe extern "C" {
             // SAFETY precondition: out-param fd pointers must be writable and
             // termp/winp must be null or valid — raw-pointer contract. Kept
@@ -902,16 +898,12 @@ fn create_pty_posix(cols: u16, rows: u16) -> Result<PtyResult, CreatePtyError> {
             let mut t = termios;
 
             // Input flags: standard terminal input processing
-            // PORT NOTE: Zig used struct-literal flag init on std.posix tc_iflag_t;
-            // Rust libc termios uses raw tcflag_t bitfields, so these are bit-ORs
-            // of the libc constants (identical values).
             t.c_iflag = libc::ICRNL // Map CR to NL on input
                 | libc::IXON // Enable XON/XOFF flow control on output
                 | libc::IXANY // Any character restarts output
                 | libc::IMAXBEL // Ring bell on input queue full
                 | libc::BRKINT; // Signal interrupt on break
-            // IUTF8: present in Linux/macOS/FreeBSD kernels but Zig std's
-            // tc_iflag_t only exposes the field on Linux/macOS, so probe for it.
+            // IUTF8: only set where the libc constant is exposed.
             #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
             {
                 t.c_iflag |= libc::IUTF8;
@@ -954,8 +946,7 @@ fn create_pty_posix(cols: u16, rows: u16) -> Result<PtyResult, CreatePtyError> {
             t.c_cc[libc::VTIME] = 0; // Timeout for non-canonical read
 
             // Set baud rate to 38400 (standard for PTYs)
-            // PORT NOTE: Zig assigned `.B38400` to ispeed/ospeed enum fields;
-            // libc termios on Linux encodes speed in c_cflag, so use
+            // libc termios on Linux encodes speed in c_cflag; use
             // cfsetispeed/cfsetospeed (the portable way to set both).
             // SAFETY: `t` is a fully-initialized termios from tcgetattr.
             unsafe {
@@ -1111,10 +1102,9 @@ fn create_pty_windows(cols: u16, rows: u16) -> Result<PtyResult, CreatePtyError>
     let mut hpcon: Option<windows::HPCON> = None;
 
     // errdefer block: scopeguard captures &mut to all of the above.
-    // PORT NOTE: reshaped for borrowck — using a single closure that reads the
-    // Option cells at drop-time would require interior mutability. Instead,
-    // inline the cleanup at each early-return point. This matches the Zig
-    // errdefer semantics exactly (cleanup runs on every `return Err`).
+    // Cleanup is inlined at each early-return point (a single drop-time
+    // closure reading the Option cells would require interior mutability);
+    // it must run on every `return Err`.
     macro_rules! cleanup {
         () => {
             // SAFETY: every Some(h) is a valid open Win32 handle still owned by
@@ -1193,8 +1183,8 @@ fn create_pty_windows(cols: u16, rows: u16) -> Result<PtyResult, CreatePtyError>
     // Wrap server (overlapped) ends as libuv-owned FDs so they can be passed
     // to BufferedReader/StreamingWriter.start() which calls uv_pipe_open.
     // Do not .take() until after success — on Err the cleanup! must still see
-    // Some(h) so the HANDLE isn't leaked (matches Zig: `out_server = null` only
-    // after the fallible call succeeds).
+    // Some(h) so the HANDLE isn't leaked; clear `out_server` only after the
+    // fallible call succeeds.
     let read_fd = match Fd::from_system(out_server.unwrap()).make_libuv_owned() {
         Ok(fd) => {
             out_server = None;
@@ -1262,9 +1252,6 @@ impl Terminal {
             let Some(termios_data) = get_termios(self.master_fd.get()) else {
                 return JSValue::js_number(0.0);
             };
-            // PORT NOTE: Zig used @typeInfo to extract the packed-struct backing
-            // integer of std.posix tc_*flag_t. In Rust/libc these are already raw
-            // integers (tcflag_t), so read the field directly.
             let raw: u64 = match FIELD {
                 TermiosField::Iflag => termios_data.c_iflag as u64,
                 TermiosField::Oflag => termios_data.c_oflag as u64,
@@ -1294,8 +1281,6 @@ impl Terminal {
             let Some(mut termios_data) = get_termios(self.master_fd.get()) else {
                 return Ok(());
             };
-            // PORT NOTE: Zig computed maxInt of the packed-struct backing integer
-            // via @typeInfo. tcflag_t::MAX is the same value (platform width).
             let max_val: f64 = libc::tcflag_t::MAX as f64;
             let clamped = num.max(0.0).min(max_val);
             let bits = clamped as libc::tcflag_t;
@@ -1799,10 +1784,8 @@ impl Terminal {
         };
 
         let global_this = self.global();
-        // allocator.dupe(u8, chunk) — Zig recovered from OOM here (logged + `return true`
-        // to keep reading). Replicate with try_reserve so a transient OOM on a large
-        // chunk doesn't abort the process.
-        // PERF(port): was explicit dupe + MarkedArrayBuffer.fromBytes; preserving.
+        // Use try_reserve so a transient OOM on a large chunk doesn't abort
+        // the process — log and `return true` to keep reading instead.
         let mut v: Vec<u8> = Vec::new();
         if v.try_reserve_exact(chunk.len()).is_err() {
             bun_output::scoped_log!(
@@ -1878,8 +1861,8 @@ fn deinit_and_destroy(this: *mut Terminal) {
     drop(unsafe { bun_core::heap::take(this) });
 }
 
-// `bun.io.BufferedReader.init(@This())` — vtable parent. Terminal declares
-// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop` (Terminal.zig).
+// BufferedReader vtable parent: Terminal declares
+// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop`.
 bun_io::buffered_reader_parent_link!(Terminal for Terminal);
 impl BufferedReaderParent for Terminal {
     const KIND: bun_io::BufferedReaderParentLinkKind =
@@ -1898,8 +1881,7 @@ impl BufferedReaderParent for Terminal {
     unsafe fn loop_(this: *mut Self) -> *mut bun_io::pipe_reader::Loop {
         // Delegate to the inherent `Terminal::loop_()` which is cfg-split:
         // on Windows it projects `.uv_loop()` (the `*mut uv_loop_t` field of
-        // `WindowsLoop`), NOT a raw cast of the `bun_uws::Loop` wrapper —
-        // matching Terminal.zig `loop()` (`this.event_loop_handle.loop().uv_loop`).
+        // `WindowsLoop`), NOT a raw cast of the `bun_uws::Loop` wrapper.
         Self::from_parent_ptr(this).loop_().cast()
     }
     unsafe fn event_loop(this: *mut Self) -> bun_io::EventLoopHandle {
@@ -1973,5 +1955,3 @@ impl bun_io::pipe_writer::WindowsStreamingWriterParent for Terminal {
         Self::from_parent_ptr(this).on_writer_close()
     }
 }
-
-// ported from: src/runtime/api/bun/Terminal.zig
diff --git a/src/runtime/api/bun/h2_frame_parser.rs b/src/runtime/api/bun/h2_frame_parser.rs
index 14ce1890208..e655624adbb 100644
--- a/src/runtime/api/bun/h2_frame_parser.rs
+++ b/src/runtime/api/bun/h2_frame_parser.rs
@@ -1,4 +1,4 @@
-//! HTTP/2 frame parser — ported from h2_frame_parser.zig
+//! HTTP/2 frame parser.
 #![allow(
     non_camel_case_types,
     non_upper_case_globals,
@@ -77,8 +77,7 @@ pub mod JSH2FrameParser {
         safe fn __get_constructor(global: *mut JSGlobalObject) -> JSValue;
     }
 
-    /// Lazily fetch the JS constructor from `globalObject` (Zig:
-    /// `JSH2FrameParser.getConstructor`).
+    /// Lazily fetch the JS constructor from `globalObject`.
     #[inline]
     pub fn get_constructor(global: &JSGlobalObject) -> JSValue {
         __get_constructor(global.as_mut_ptr())
@@ -110,7 +109,6 @@ enum BunSocket {
     TcpWriteonly(bun_ptr::BackRef<TCPSocket>),
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn JSC__JSGlobalObject__getHTTP2CommonString(
         global_object: &JSGlobalObject,
@@ -120,9 +118,8 @@ unsafe extern "C" {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Local shim for `globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE*, fmt, .{}).throw()`
-// (Zig codegen surfaces these as per-code helper methods on JSGlobalObject; the
-// Rust ErrorCode table exposes them via `JscErrorCode::*` instead.)
+// Local builder for throwing `HTTP2_INVALID_SETTING_VALUE*` errors; the
+// ErrorCode table exposes them via `JscErrorCode::*`.
 // ──────────────────────────────────────────────────────────────────────────
 pub(crate) struct H2ErrBuilder<'a> {
     global: &'a JSGlobalObject,
@@ -244,7 +241,7 @@ enum SettingsFlags {
     ACK = 0x1,
 }
 
-// Non-exhaustive enum in Zig (`_` catch-all) → newtype over u32
+// Open set of wire values → newtype over u32
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct ErrorCode(u32);
@@ -261,7 +258,7 @@ impl ErrorCode {
     const MAX_PENDING_SETTINGS_ACK: Self = Self(0xe);
 }
 
-// Non-exhaustive enum in Zig → newtype over u16
+// Open set of wire values → newtype over u16
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 struct SettingsType(u16);
@@ -307,12 +304,9 @@ impl UInt31WithReserved {
     fn init(value: u32, reserved: bool) -> Self {
         Self((value & 0x7fff_ffff) | if reserved { 0x8000_0000 } else { 0 })
     }
-    /// PORT NOTE (intentional divergence): Zig's `toUInt32()` is `@bitCast` of
-    /// `packed struct(u32){ reserved: bool, uint31: u31 }`, which on little-endian places
-    /// `reserved` in bit 0 and yields `(uint31 << 1) | reserved`. That is a latent RFC 7540
-    /// §6.3 bug in Zig's deprecated PRIORITY path — the wire format wants the reserved/E
-    /// bit at bit 31. We keep the RFC-compliant `(reserved << 31) | uint31` layout here, which
-    /// already matches `from_bytes`/`write` and the on-wire `StreamPriority.stream_identifier`.
+    /// Note: the wire format (RFC 7540 §6.3) wants the reserved/E bit at bit
+    /// 31, so the layout is `(reserved << 31) | uint31`, which matches
+    /// `from_bytes`/`write` and the on-wire `StreamPriority.stream_identifier`.
     #[inline]
     fn to_uint32(self) -> u32 {
         self.0
@@ -368,7 +362,8 @@ impl StreamPriority {
 }
 
 // packed struct(u72): length: u24, type: u8, flags: u8, streamIdentifier: u32
-// TODO(port): u24 — represented as u32 here; wire encoding handled in write()/from()
+// `length` is u24 on the wire; widened to u32 here (Rust has no u24). The 3-byte
+// big-endian encoding is handled explicitly in write()/decode().
 #[derive(Clone, Copy)]
 pub struct FrameHeader {
     length: u32, // u24 on the wire
@@ -401,11 +396,9 @@ impl FrameHeader {
     }
     /// Decode a complete 9-byte big-endian frame header.
     ///
-    /// Zig accumulates raw wire bytes directly into the packed `struct(u72)`
-    /// across two `from()` calls and byte-swaps at the end. `FrameHeader` here
-    /// is not `#[repr(packed)]` (its `length` is a widened `u32`), so the
-    /// caller assembles the 9 raw bytes on the stack and hands us the finished
-    /// buffer instead — no per-instance or thread-local scratch needed.
+    /// `FrameHeader` is not `#[repr(packed)]` (its `length` is a widened
+    /// `u32`), so the caller assembles the 9 raw bytes on the stack and hands
+    /// us the finished buffer — no per-instance or thread-local scratch needed.
     #[inline]
     fn decode(raw: &[u8; Self::BYTE_SIZE]) -> Self {
         Self {
@@ -444,7 +437,9 @@ impl SettingsPayloadUnit {
 }
 
 // packed struct(u336) — 7 × (u16 type + u32 value) = 42 bytes
-// TODO(port): #[repr(C, packed)] for wire layout; verify byteSwapAllFields equivalence in Phase B
+// Wire layout via #[repr(C, packed)]: all fields are byte-aligned u16/u32, and
+// the per-field swap_bytes() in write() swaps each field individually, not the
+// whole backing int.
 #[repr(C, packed)]
 #[derive(Clone, Copy)]
 pub(crate) struct FullSettingsPayload {
@@ -579,7 +574,7 @@ impl FullSettingsPayload {
     }
 }
 
-/// Writer trait used for `(comptime Writer: type, writer: Writer)` params.
+/// Writer trait used for generic wire-serialization writer params.
 /// All call sites use either a `FixedBufferStream` cursor or `DirectWriterStruct`.
 use bun_io::Write as WireWriter;
 
@@ -587,15 +582,14 @@ use bun_io::Write as WireWriter;
 // Static header maps
 // ──────────────────────────────────────────────────────────────────────────
 
-// PERF(port): was phf::Map<&[u8], ()> used only via .contains_key() on a 1-entry
-// set. A single slice compare is strictly cheaper than a SipHash + compare.
+// PERF: a single slice compare is strictly cheaper than a phf::Map
+// .contains_key() (SipHash + compare) on a 1-entry set.
 #[inline]
 fn is_valid_response_pseudo_header(name: &[u8]) -> bool {
     name == b":status"
 }
 
-// PERF(port): was phf::Map<&[u8], ()> used only via .contains_key() on a 5-entry
-// set. phf hashes the full key (SipHash) before compare; with 5 keys whose
+// PERF: a phf::Map hashes the full key (SipHash) before compare; with 5 keys whose
 // lengths are {5,7,7,9,10} a length-gated match rejects most misses on a single
 // usize compare and hits in ≤2 slice compares — cheaper than the hash.
 #[inline]
@@ -669,11 +663,9 @@ const SINGLE_VALUE_HEADERS_LEN: usize = 40;
 /// solely to address a per-request `[bool; SINGLE_VALUE_HEADERS_LEN]` bitset
 /// for duplicate detection — the concrete numeric value has no other meaning.
 ///
-/// PERF(port): Zig used `ComptimeStringMap.indexOf`, which compiles to a
-/// length-gated switch. The Phase-A draft used a `phf::Map` but, because phf
-/// does not expose stable indices, had to fall back to a *linear*
-/// `.entries().position()` scan — 40 slice compares per header per HTTP/2
-/// request. The hand-rolled match below restores the Zig dispatch shape: one
+/// PERF: a `phf::Map` does not expose stable indices, so it would force a
+/// *linear* `.entries().position()` scan — 40 slice compares per header per
+/// HTTP/2 request. The hand-rolled match below is a length-gated switch: one
 /// `usize` length compare rejects every miss whose length has no entries, and
 /// the largest same-length bucket is 5 entries (len 7), so a hit costs at
 /// most 5 short slice compares and a miss typically costs 0–2.
@@ -1247,7 +1239,7 @@ impl Handlers {
 
 pub use JSH2FrameParser::get_constructor as H2FrameParserConstructor;
 /// snake_case alias for the codegen'd `$zig(h2_frame_parser.zig, H2FrameParserConstructor)`
-/// thunk in `generated_js2native.rs` (the generator snake-cases the Zig export name).
+/// thunk in `generated_js2native.rs` (the generator snake-cases the export name).
 pub use JSH2FrameParser::get_constructor as h2_frame_parser_constructor;
 
 use bun_io::FixedBufferStream;
@@ -1392,17 +1384,16 @@ impl H2FrameParser {
 
 /// The streams hashmap may mutate when growing we use this when we need to make sure its safe to iterate over it
 ///
-/// Zig walks the raw bucket array by index so a rehash mid-loop can't
-/// invalidate the iterator. `bun_collections::HashMap` is backed by
-/// `std::collections::HashMap`, which exposes no bucket index and randomises
-/// iteration order on every mutation, so the bucket trick can't be ported
-/// faithfully. Instead we snapshot the stream IDs at `init` and re-look-up
+/// `bun_collections::HashMap` is backed by `std::collections::HashMap`, which
+/// exposes no bucket index and randomises iteration order on every mutation,
+/// so iterating while mutating is not possible directly. Instead we snapshot
+/// the stream IDs at `init` and re-look-up
 /// each one on demand: streams removed mid-loop are skipped, streams added
 /// mid-loop are not visited, and nothing is yielded twice. That's the
 /// guarantee the call sites actually rely on (flush / emit-to-all / detach).
 pub(crate) struct StreamResumableIterator {
-    // PORT NOTE: Zig's `parser: *H2FrameParser` freely aliases. R-2: `streams`
-    // is now `JsCell`-backed, so a shared backref suffices and the in-loop
+    // Note: `streams`
+    // is `JsCell`-backed, so a shared backref suffices and the in-loop
     // body can keep its own `&H2FrameParser` without provenance gymnastics.
     // `ParentRef` encapsulates the back-pointer invariant (parser outlives the
     // iterator — every call site constructs the iterator from a live `&Self`
@@ -1490,11 +1481,10 @@ pub(crate) struct SignalRef {
     // LIFETIMES.tsv: SHARED — AbortSignal is intrusively refcounted across FFI/codegen.
     // `AbortSignal` is an opaque C++ type whose ref/unref go through
     // `WebCore__AbortSignal__ref/unref`; it does not (and cannot) implement
-    // `bun_ptr::RefCounted`, so balance refs by hand in `attach_signal` / `Drop`
-    // (mirrors Zig `*AbortSignal`). `BackRef` captures the backref invariant
+    // `bun_ptr::RefCounted`, so balance refs by hand in `attach_signal` /
+    // `Drop`. `BackRef` captures the backref invariant
     // (signal is `ref_()`'d in `attach_signal` and outlives this struct until
     // `Drop` calls `detach()`/`unref()`), so reads go through safe `Deref`.
-    // TODO(port): wrap in a dedicated smart-pointer once AbortSignal grows one.
     signal: bun_ptr::BackRef<AbortSignal>,
     // LIFETIMES.tsv: SHARED — H2FrameParser carries an intrusive RefCount and is
     // recovered via `from_field_ptr!` from the auto-flusher. It uses a hand-rolled
@@ -1502,8 +1492,7 @@ pub(crate) struct SignalRef {
     // `RefCounted` bound is unsatisfiable. `ParentRef` captures the backref
     // invariant (parser is `ref_()`'d in `attach_signal` and outlives the
     // `SignalRef` until `Drop` calls `deref()`), so reads go through safe
-    // `Deref`; the explicit `ref_()/deref()` balancing stays (mirrors Zig
-    // `*H2FrameParser`).
+    // `Deref`; the explicit `ref_()/deref()` balancing stays.
     parser: bun_ptr::ParentRef<H2FrameParser>,
     stream_id: u32,
 }
@@ -1832,7 +1821,7 @@ impl Stream {
             }
         };
 
-        // defer block from Zig (only when the full frame was flushed)
+        // only when the full frame was flushed
         if let Some(_frame) = owned_frame {
             // only call the callback + free the frame if we write to the socket the full frame
             client
@@ -1881,7 +1870,7 @@ impl Stream {
     ) {
         let global_this = client.global_this;
 
-        // PORT NOTE: `dispatch_write_callback()` below re-enters JS, which can
+        // Note: `dispatch_write_callback()` below re-enters JS, which can
         // call back into `H2FrameParser` host-fns (e.g. `writeStream`) that
         // look this `Stream` up by id from `client.streams` and reach
         // `queue_frame()` again with a fresh `&mut Stream` aliasing this one.
@@ -1900,13 +1889,13 @@ impl Stream {
             // SAFETY: helper for the pre-dispatch accesses below; `last_frame`
             // is the unique tail slot in `self.data_frame_queue.data`, valid
             // until the dispatch call (after which we re-`black_box` before
-            // every access — see PORT NOTE above).
+            // every access — see note above).
             macro_rules! lf {
                 () => {
                     // SAFETY: `last_frame` points at the live tail slot of
                     // `self.data_frame_queue`; provenance is re-laundered via
                     // `black_box` before each post-dispatch expansion so no
-                    // other `&mut` to the slot is live here (see PORT NOTE).
+                    // other `&mut` to the slot is live here (see note).
                     unsafe { &mut *last_frame }
                 };
             }
@@ -2147,8 +2136,8 @@ impl Stream {
     }
 }
 
-// Route AbortSignal callbacks through the Rust trait — the Zig spec passes a
-// fn pointer; `bun_jsc::abort_signal::listen` instead expects `*mut C: AbortListener`.
+// Route AbortSignal callbacks through the trait —
+// `bun_jsc::abort_signal::listen` expects `*mut C: AbortListener`.
 impl AbortListener for SignalRef {
     fn on_abort(&mut self, reason: JSValue) {
         SignalRef::abort_listener(self, reason);
@@ -2157,17 +2146,6 @@ impl AbortListener for SignalRef {
 
 type HeaderValue = lshpack::DecodeResult;
 
-// PORT NOTE: `lshpack::HpackError` does not yet impl `From` for `bun_core::Error`
-// (see TODO in lshpack.rs). Map variants 1:1 to interned error names so Zig
-// callers that match on `error.UnableToDecode` etc. keep their semantics.
-fn hpack_error_to_core(e: &lshpack::HpackError) -> bun_core::Error {
-    match e {
-        lshpack::HpackError::UnableToDecode => bun_core::err!("UnableToDecode"),
-        lshpack::HpackError::EmptyHeaderName => bun_core::err!("EmptyHeaderName"),
-        lshpack::HpackError::UnableToEncode => bun_core::err!("UnableToEncode"),
-    }
-}
-
 // ──────────────────────────────────────────────────────────────────────────
 // H2FrameParser impl — core methods
 // ──────────────────────────────────────────────────────────────────────────
@@ -2184,14 +2162,12 @@ impl H2FrameParser {
         value: &[u8],
         never_index: bool,
     ) -> Result<usize, bun_core::Error> {
-        // TODO(port): narrow error set
         let old_len = encoded_headers.len();
         let required = old_len + name.len() + value.len() + HPACK_ENTRY_OVERHEAD;
-        // PORT NOTE: Zig wrote into `allocatedSlice()` past `.len` then bumped `.len` on
-        // success. In Rust, materializing `&mut [u8]` over uninitialized capacity is UB and
+        // Note: materializing `&mut [u8]` over uninitialized capacity is UB and
         // hpack.encode() needs `&mut [u8]` (not `&mut [MaybeUninit<u8>]`), so zero-extend to
         // `required` first. On both Ok and Err we truncate so `len` never exposes scratch
-        // bytes — the `?` early-return / corrupted-len hazard from the original port is gone.
+        // bytes.
         encoded_headers.resize(required, 0);
         match self.encode(
             encoded_headers.as_mut_slice(),
@@ -2214,9 +2190,7 @@ impl H2FrameParser {
     pub(crate) fn decode(&self, src_buffer: &[u8]) -> Result<HeaderValue, bun_core::Error> {
         self.hpack.with_mut(|hpack| {
             if let Some(hpack) = hpack.as_mut() {
-                return hpack
-                    .decode(src_buffer)
-                    .map_err(|e| hpack_error_to_core(&e));
+                return hpack.decode(src_buffer).map_err(bun_core::Error::from);
             }
             Err(bun_core::err!("UnableToDecode"))
         })
@@ -2235,7 +2209,7 @@ impl H2FrameParser {
                 // lets make sure the name is lowercase
                 return hpack
                     .encode(name, value, never_index, dst_buffer, dst_offset)
-                    .map_err(|e| hpack_error_to_core(&e));
+                    .map_err(bun_core::Error::from);
             }
             Err(bun_core::err!("UnableToEncode"))
         })
@@ -2287,7 +2261,7 @@ impl H2FrameParser {
     }
 
     fn increment_window_size_if_needed(&self) {
-        // PORT NOTE: reshaped for borrowck — collect actions then apply
+        // Note: reshaped for borrowck — collect actions then apply
         let mut updates: Vec<(u32, u64)> = Vec::new();
         for (_, item) in self.streams.get().iter() {
             // SAFETY: item is &*mut Stream from streams.iter(); the boxed Stream outlives the iteration
@@ -2903,7 +2877,7 @@ impl H2FrameParser {
 
     pub(crate) fn flush(&self) -> usize {
         bun_output::scoped_log!(H2FrameParser, "flush");
-        // Zig: `this.ref(); defer this.deref();` — keep `self` alive across the
+        // Keep `self` alive across the
         // re-entrant JS calls below. ScopedRef stores a raw pointer so it does
         // not borrow `self`.
         // SAFETY: `self` is live; all mutation goes through `Cell`/`JsCell`
@@ -3112,11 +3086,11 @@ impl H2FrameParser {
     }
 }
 
-// PORT NOTE: raw-ptr slice — Zig's `[]const u8` payload may alias `this.readBuffer` across
+// Note: raw-ptr slice — the payload may alias `this.readBuffer` across
 // `readBuffer.reset()` (e.g. handleHeadersFrame resets then calls decodeHeaderBlock(payload)).
 // A borrowed `&'a [u8]` tied to `&'a mut self` forces every caller into an aliasing
 // `unsafe { &mut *self_ptr }` reborrow, which under Stacked Borrows invalidates the slice the
-// moment the caller touches `self` again. Carrying a raw pointer keeps the Zig aliasing intent
+// moment the caller touches `self` again. Carrying a raw pointer keeps the aliasing workable
 // without materialising overlapping `&mut` borrows.
 pub(crate) struct Payload {
     data_ptr: *const u8,
@@ -3136,7 +3110,7 @@ impl Payload {
     /// `data_ptr` is derived via `Vec::as_mut_ptr()` (raw-ptr method, no intermediate `&[u8]`
     /// borrow), which is documented to remain valid across non-reallocating mutation, so under
     /// Stacked Borrows the `Vec::clear()` inside `reset()` does not invalidate it and the bytes
-    /// remain readable (matches the Zig ordering where several handlers reset before consuming
+    /// remain readable (several handlers reset before consuming
     /// `payload`). The returned borrow is tied to the local `Payload` (not `self: H2FrameParser`),
     /// so `&mut self` operations on the parser do not conflict with it under borrowck.
     #[inline]
@@ -3231,8 +3205,8 @@ impl H2FrameParser {
             // no intermediate &[u8]) so the provenance survives `read_buffer.reset()` —
             // Vec::clear() forms `&mut [u8]` internally, which under Stacked Borrows would pop a
             // SharedReadOnly tag obtained from `as_slice().as_ptr()`. Several handlers
-            // (origin/altsvc/continuation/headers) read `payload` AFTER reset(), mirroring the
-            // Zig ordering, so the pointer must outlive that mutation. R-2: `JsCell` is
+            // (origin/altsvc/continuation/headers) read `payload` AFTER reset(),
+            // so the pointer must outlive that mutation. R-2: `JsCell` is
             // `UnsafeCell`-backed; deriving the pointer via `with_mut` keeps SharedReadWrite
             // provenance through later `read_buffer` accesses.
             let (data_ptr, data_len) = self.read_buffer.with_mut(|rb| {
@@ -3986,8 +3960,8 @@ impl H2FrameParser {
             let payload = content.data();
             let is_not_ack = frame.flags & PingFrameFlags::ACK as u8 == 0;
             let end = content.end;
-            // PORT NOTE: Zig resets readBuffer before send_ping(payload); reset() only clears len
-            // so the bytes stay readable. Copy out anyway so send_ping/to_js below don't depend on
+            // Note: reset() only clears len so the bytes would stay readable;
+            // copy out anyway so send_ping/to_js below don't depend on
             // that subtlety once read_buffer is mutated further.
             let payload_owned = payload.to_vec();
             self.read_buffer.with_mut(|rb| rb.reset());
@@ -4720,10 +4694,8 @@ impl H2FrameParser {
                     .deprecated_report_extra_memory(bytes.len());
                 return Ok(bytes.len());
             }
-            // Zig writes the buffered prefix into the packed struct, then the
-            // tail at `offset = buffered_data`, then byte-swaps. Reassemble the
-            // 9 wire bytes on the stack and decode in one shot — same result,
-            // no shared scratch state.
+            // Reassemble the 9 wire bytes on the stack and decode in one shot
+            // — no shared scratch state.
             let needed = FrameHeader::BYTE_SIZE - buffered_data;
             let mut raw = [0u8; FrameHeader::BYTE_SIZE];
             raw[..buffered_data].copy_from_slice(&self.read_buffer.get().list[..buffered_data]);
@@ -4789,7 +4761,7 @@ impl H2FrameParser {
         )
     }
 
-    // PORT NOTE: hoisted from three identical switch blocks in read_bytes for borrowck/DRY.
+    // Note: hoisted from three identical switch blocks in read_bytes for borrowck/DRY.
     // The `add` parameter is the number of bytes already consumed before `bytes` (0, `needed`, or BYTE_SIZE).
     fn dispatch_frame(
         &self,
@@ -4869,7 +4841,7 @@ impl H2FrameParser {
     }
 }
 
-// PORT NOTE: holds a `BackRef<H2FrameParser>` so the borrow of the parser ends
+// Note: holds a `BackRef<H2FrameParser>` so the borrow of the parser ends
 // at `to_writer()`'s return — `Stream::flush_queue` interleaves field
 // reads/writes on the parser between `writer.write()` calls. R-2: `write()`
 // takes `&self` (Cell/JsCell-backed), so a shared back-reference is sufficient
@@ -5031,8 +5003,8 @@ impl H2FrameParser {
 
                     // Validate setting ID (key) is in range [0, 0xFFFF]
                     let setting_id_str = prop_name.to_utf8();
-                    // Parse bytes directly (ASCII decimal) — Zig: std.fmt.parseInt(u32, slice, 10).
-                    // Do not insert UTF-8 validation on external data per PORTING.md §Strings.
+                    // Parse bytes directly (ASCII decimal); do not insert
+                    // UTF-8 validation on external data.
                     let Some(setting_id) =
                         bun_core::parse_int::<u32>(setting_id_str.slice(), 10).ok()
                     else {
@@ -5333,7 +5305,7 @@ impl H2FrameParser {
             }
         } else if origin_arg.is_array() {
             let mut buffer = vec![0u8; FrameHeader::BYTE_SIZE + 16384];
-            // PERF(port): was stack array [FrameHeader.byteSize + 16384]u8 — heap to avoid 16K stack frame
+            // Heap-allocated to avoid a 16K stack frame.
             let mut stream = FixedBufferStream::new(&mut buffer);
             stream.seek_to(FrameHeader::BYTE_SIZE);
             let mut value_iter = origin_arg.array_iterator(global_object)?;
@@ -5885,7 +5857,6 @@ impl H2FrameParser {
             }
         }
 
-        // defer block from Zig
         if !enqueued {
             self.dispatch_write_callback(callback);
             if close {
@@ -6050,7 +6021,6 @@ impl H2FrameParser {
             );
         }
 
-        // PERF(port): was BufferFallbackAllocator over shared_request_buffer — using plain Vec
         let mut encoded_headers: Vec<u8> = Vec::new();
         if encoded_headers.try_reserve(16384).is_err() {
             return Err(global_object.throw(format_args!("Failed to allocate header buffer")));
@@ -6696,7 +6666,6 @@ impl H2FrameParser {
                 global_object.throw(format_args!("Expected sensitiveHeaders to be an object"))
             );
         }
-        // PERF(port): was BufferFallbackAllocator over shared_request_buffer — using plain Vec
         let mut encoded_headers: Vec<u8> = Vec::new();
         if encoded_headers.try_reserve(16384).is_err() {
             return Err(global_object.throw(format_args!("Failed to allocate header buffer")));
@@ -6717,8 +6686,8 @@ impl H2FrameParser {
         let mut single_value_headers = [false; SINGLE_VALUE_HEADERS_LEN];
 
         for ignore_pseudo_headers in 0..2usize {
-            // PORT NOTE: `bun_jsc::JSPropertyIterator` (runtime-options variant) lacks `.reset()`;
-            // re-initialize per pass instead — same observable property walk as the Zig two-pass loop.
+            // Note: `bun_jsc::JSPropertyIterator` (runtime-options variant) lacks `.reset()`;
+            // re-initialize per pass instead — the observable property walk is the same.
             let mut iter = bun_jsc::JSPropertyIterator::init(
                 global_object,
                 headers_obj,
@@ -7393,7 +7362,7 @@ impl H2FrameParser {
         }
         let buffer = args_list.ptr[0];
         buffer.ensure_still_alive();
-        // Zig: `defer this.incrementWindowSizeIfNeeded()`. Wrap the body in a
+        // Wrap the body in a
         // closure so `?` short-circuits to the `result` binding instead of out
         // of the function, and the window-size update still runs on the error
         // path.
@@ -7475,11 +7444,8 @@ impl H2FrameParser {
         Ok(JSValue::UNDEFINED)
     }
 
-    /// Zig: `if (socket.attachNativeCallback(.{ .h2 = this })) … else { socket.ref(); writeonly }`.
-    ///
     /// `attach_native_callback` stores an `IntrusiveRc<H2FrameParser>` (the
-    /// `init_ref` bumps `ref_count`, mirroring Zig's `h2.ref()` inside
-    /// `attachNativeCallback`); the matching `deref` happens in
+    /// `init_ref` bumps `ref_count`); the matching `deref` happens in
     /// `NewSocket::detach_native_callback`. When the socket already has a
     /// native callback attached we fall back to write-only mode and take a
     /// manual `ref()` on the socket itself, balanced by `detach_native_socket`.
@@ -7495,7 +7461,7 @@ impl H2FrameParser {
         // BACKREF: `socket` is the live `m_ctx` borrowed from the JS wrapper rooted by the
         // caller's `socket_js`; it strictly outlives the returned `BunSocket` via the
         // attach/detach refcount protocol (see `BunSocket` docs). `NonNull::new` panics on
-        // null, matching Zig's `*TLSSocket` (never-null) field type.
+        // null — the field is never-null by construction.
         let socket_nn = NonNull::new(socket).expect("NewSocket m_ctx");
         let socket_ref = bun_ptr::BackRef::from(socket_nn);
         if socket_ref.attach_native_callback(NativeCallbacks::H2(h2)) {
@@ -7608,7 +7574,7 @@ impl H2FrameParser {
         } else {
             bun_core::heap::into_raw(Box::new(init))
         };
-        // Zig: `errdefer this.deinit()`. The remaining `?` sites below may throw a JS
+        // The remaining `?` sites below may throw a JS
         // exception; the guard returns the slot to the pool / frees the Box on that
         // path. Defused on success.
         let guard = scopeguard::guard(this, |this| {
@@ -7716,7 +7682,7 @@ impl H2FrameParser {
             .strong_this
             .with_mut(|s| s.set_strong(this_value, global_object));
 
-        // PORT NOTE: `HPACK::init` returns a C-allocated wrapper that must be
+        // Note: `HPACK::init` returns a C-allocated wrapper that must be
         // torn down via `lshpack_wrapper_deinit` (runs `lshpack_{enc,dec}_cleanup`
         // before freeing). Wrapping it in `heap::take` and letting `Box` drop
         // would `mi_free` the struct but leak the encoder/decoder internals.
@@ -7763,7 +7729,7 @@ impl H2FrameParser {
         self.unregister_auto_flush();
         self.detach_native_socket();
 
-        // Zig: `this.readBuffer.deinit()` — frees the allocation. `reset()` would only
+        // Free the allocation, not just the length: `reset()` would only
         // clear `len`; detach() is reachable from JS without a following `deinit`, so the
         // capacity must be released here. Drop-and-replace = free.
         self.read_buffer.set(MutableString::default());
@@ -7778,9 +7744,9 @@ impl H2FrameParser {
         bun_output::scoped_log!(H2FrameParser, "deinit");
 
         self.detach();
-        // PORT NOTE: JsRef::deinit() dropped — overwrite with empty(); Drop releases the Strong slot.
+        // Note: JsRef::deinit() dropped — overwrite with empty(); Drop releases the Strong slot.
         self.strong_this.set(JsRef::empty());
-        // PORT NOTE: take the map out first so `self` is free for
+        // Note: take the map out first so `self` is free for
         // `free_resources(self)` while we walk the entries.
         let streams = self.streams.replace(BunHashMap::default());
         for (_, item) in streams.iter() {
@@ -7793,9 +7759,7 @@ impl H2FrameParser {
         }
         drop(streams);
 
-        // defer: pool.put(this) / bun.destroy(this)
-        // Zig has no destructors, so `pool.put` just reclaims storage. Rust still
-        // owes Drop on the remaining fields (`handlers`, `auto_flusher`, the now-
+        // Drop is still owed on the remaining fields (`handlers`, `auto_flusher`, the now-
         // empty `streams`/`read_buffer`/`write_buffer`/`strong_this`, …);
         // `HiveArrayFallback::put` runs `drop_in_place` before recycling the slot,
         // and `heap::destroy` drops via `Box<T>`, so both branches drop exactly once.
@@ -7823,7 +7787,7 @@ impl H2FrameParser {
 
     pub(crate) fn finalize(self: Box<Self>) {
         bun_output::scoped_log!(H2FrameParser, "finalize");
-        // PORT NOTE: JsRef::deinit() dropped — overwrite with empty(); Drop releases the Strong slot.
+        // Note: JsRef::deinit() dropped — overwrite with empty(); Drop releases the Strong slot.
         bun_ptr::finalize_js_box(self, |this| {
             this.strong_this.set(JsRef::empty());
             // process.exit() never unwinds, so a stack-rooted ref can strand and deinit()
@@ -7843,5 +7807,3 @@ impl H2FrameParser {
         });
     }
 }
-
-// ported from: src/runtime/api/bun/h2_frame_parser.zig
diff --git a/src/runtime/api/bun/js_bun_spawn_bindings.rs b/src/runtime/api/bun/js_bun_spawn_bindings.rs
index d2b7637997e..55c2fa8b841 100644
--- a/src/runtime/api/bun/js_bun_spawn_bindings.rs
+++ b/src/runtime/api/bun/js_bun_spawn_bindings.rs
@@ -123,15 +123,13 @@ fn subprocess_ipc_owner(ptr: *mut SubprocessT<'_>) -> *mut dyn IPC::SendQueueOwn
 
 bun_output::declare_scope!(Subprocess, hidden);
 
-// `SpawnOptions.Stdio` in Zig is a platform-dependent nested decl. Rust enums
-// cannot nest type decls, so process.rs defines `PosixStdio` / `WindowsStdio`
+// Stdio is platform-dependent: process.rs defines `PosixStdio` / `WindowsStdio`
 // as siblings; alias the active one here so the body stays platform-neutral.
 #[cfg(not(windows))]
 type SpawnOptionsStdio = spawn::PosixStdio;
 #[cfg(windows)]
 type SpawnOptionsStdio = spawn::WindowsStdio;
 
-// TODO(port): move to runtime_sys
 // Reading the symbol address has no precondition (the value itself is a
 // rodata `const char*`); kept `safe` to match the identical declaration in
 // `runtime/shell/subproc.rs` so the two extern blocks don't diverge.
@@ -215,9 +213,8 @@ fn get_argv0(
 /// `argv` for `Bun.spawn` & `Bun.spawnSync`
 ///
 /// `storage` receives ownership of every NUL-terminated string whose pointer is
-/// pushed into `argv` / `argv0`. The Zig original used a bump arena freed at the
-/// end of `spawnMaybeSync`; here the caller's `Vec<ZBox>` plays the same role
-/// and is dropped after `spawn_process` returns.
+/// pushed into `argv` / `argv0`; the caller's `Vec<ZBox>`
+/// is dropped after `spawn_process` returns.
 fn get_argv(
     global_this: &JSGlobalObject,
     args: JSValue,
@@ -278,7 +275,7 @@ fn get_argv(
     *argv0 = Some(argv0_result.argv0.as_ptr());
     argv.push(argv0_result.arg0.as_ptr());
     // Transfer ownership to the caller's backing store so the pointers above
-    // stay valid past `spawn_process` (Zig used a bump arena freed at fn exit).
+    // stay valid past `spawn_process`.
     storage.push(argv0_result.argv0);
     storage.push(argv0_result.arg0);
 
@@ -360,10 +357,9 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         }
     }
 
-    // PERF(port): was arena bulk-free — argv/env strings allocated per-iteration; profile if hot.
+    // PERF: argv/env strings are allocated per-iteration; profile if hot.
     // Backing store for every NUL-terminated string whose `*const c_char` is
-    // pushed into `argv` / `argv0` / `env_array` below. Zig used a bump arena
-    // (`arena.deinit()` at fn exit); this `Vec` is the Rust equivalent and
+    // pushed into `argv` / `argv0` / `env_array` below. This `Vec`
     // drops after `spawn_process` returns, freeing all argv/env allocations.
     let mut cstr_storage: Vec<ZBox> = Vec::new();
 
@@ -432,11 +428,11 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             }
         },
     );
-    // PORT NOTE: reshaped for borrowck — re-borrow through the guard tuple.
+    // Note: reshaped for borrowck — re-borrow through the guard tuple.
     let (abort_signal, terminal_info) = &mut *defer_guard;
 
     // Owned ZBox for `cwd` held here so the `&[u8]` borrow stays valid until
-    // `spawn_process` returns (Zig used the bump arena).
+    // `spawn_process` returns.
     let cwd_owned: ZBox;
     {
         if args.is_empty_or_undefined_or_null() {
@@ -706,7 +702,6 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                                 i32::try_from((timeout_int as u32) & 0x7FFF_FFFF)
                                     .expect("int cast"),
                             );
-                            // PORT NOTE: Zig `@intCast(@as(u31, @truncate(timeout_int)))` — truncate to u31 then widen to i32.
                         }
                     }
                 }
@@ -847,8 +842,8 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
 
     bun_output::scoped_log!(Subprocess, "spawn maxBuffer: {:?}", max_buffer);
 
-    // Owns the `K=V\0` storage when inheriting the parent env (Zig used the
-    // bump arena; here the struct is the arena and lives until spawn returns).
+    // Owns the `K=V\0` storage when inheriting the parent env; the struct
+    // lives until spawn returns.
     let mut inherited_env_storage: Option<bun_dotenv::NullDelimitedEnvMap> = None;
     if !override_env && env_array.is_empty() {
         // `Transpiler::env_mut()` is the audited safe `&mut Loader` accessor
@@ -863,17 +858,15 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             Ok(m) => m,
             Err(_) => return Err(global_this.throw_out_of_memory()),
         };
-        // PORT NOTE: Zig assigned `env_array.items = envp` (sentinel slice — the
-        // trailing `null` lives at `[len]`, outside `.items`). The Rust port's
-        // `as_slice()` *includes* the trailing null, so strip it; the common
-        // tail below re-appends one after the optional NODE_CHANNEL_* entries.
+        // Note: `as_slice()` *includes* the trailing null, so strip it; the
+        // common tail below re-appends one after the optional NODE_CHANNEL_*
+        // entries.
         let entries = envmap.as_slice();
         env_array.extend_from_slice(&entries[..entries.len().saturating_sub(1)]);
         inherited_env_storage = Some(envmap);
     }
     let _ = &inherited_env_storage;
 
-    // PORT NOTE: Zig `inline for (0..stdio.len)` — unrolled here as a regular for; const N=3.
     for fd_index in 0..stdio.len() {
         if stdio[fd_index].can_use_memfd(IS_SYNC, fd_index > 0 && max_buffer.is_some()) {
             if stdio[fd_index].use_memfd(fd_index as u32) {
@@ -889,11 +882,10 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             if *should_close_memfd {
                 for fd_index in 0..stdio.len() {
                     if matches!(stdio[fd_index], Stdio::Memfd(_)) {
-                        // PORT NOTE: Zig closes the fd then writes
-                        // `stdio[i] = .ignore`. In Rust that assignment would
+                        // Note: closing the fd first and then assigning would
                         // Drop the old `Stdio::Memfd` and re-close the same fd
                         // (EBADF → fd.rs debug_assert). `Stdio`'s Drop already
-                        // closes a Memfd, so just replace with `.ignore` and
+                        // closes a Memfd, so just replace with `Ignore` and
                         // let Drop perform the single close.
                         drop(core::mem::replace(&mut stdio[fd_index], Stdio::Ignore));
                     }
@@ -901,7 +893,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             }
         },
     );
-    // PORT NOTE: reshaped for borrowck — re-borrow through the guard tuple so the guard
+    // Note: reshaped for borrowck — re-borrow through the guard tuple so the guard
     // stays armed (runs on every early return) until disarmed by `**should_close_memfd = false` below.
     let (should_close_memfd, stdio) = &mut *memfd_guard;
 
@@ -954,12 +946,9 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                     Err(_) => return Err(global_this.throw_out_of_memory()),
                 }
             };
-            // PERF(port): was assume_capacity
             env_array.push(pipe_env.as_ptr().cast::<c_char>());
 
-            // PERF(port): was assume_capacity
             env_array.push(match ipc_mode {
-                // PORT NOTE: Zig `inline else => |t| "..." ++ @tagName(t)` — written out per variant.
                 IPC::Mode::Json => c"NODE_CHANNEL_SERIALIZATION_MODE=json".as_ptr(),
                 IPC::Mode::Advanced => c"NODE_CHANNEL_SERIALIZATION_MODE=advanced".as_ptr(),
             });
@@ -1008,17 +997,16 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
     // For spawnSync, use an isolated event loop to prevent JavaScript timers from firing
     // and to avoid interfering with the main event loop.
     //
-    // PORT NOTE: borrowck — `rare_data()` borrows `jsc_vm` mutably and the
+    // Note: borrowck — `rare_data()` borrows `jsc_vm` mutably and the
     // returned `&mut SpawnSyncEventLoop` keeps that borrow alive, so we cannot
     // also pass `jsc_vm` into `spawn_sync_event_loop`/`prepare`/`cleanup` while
     // holding it. Route through a raw `*mut VirtualMachineRef` for the duration.
     let jsc_vm_ptr: *mut jsc::VirtualMachineRef = jsc_vm;
     // For IS_SYNC, use the isolated loop's `event_loop` (created by
     // `SpawnSyncEventLoop::init`) so stdio readers/writers register on it
-    // instead of the main loop — matches Zig
-    // `&jsc_vm.rareData().spawnSyncEventLoop(jsc_vm).event_loop`.
+    // instead of the main loop.
     let event_loop: *mut jsc::event_loop::EventLoop = if IS_SYNC {
-        // SAFETY: see PORT NOTE above; `spawn_sync_event_loop` re-borrows the
+        // SAFETY: see note above; `spawn_sync_event_loop` re-borrows the
         // same VM via the raw pointer for its `vm` arg.
         unsafe {
             let sync_loop = (*jsc_vm_ptr)
@@ -1037,7 +1025,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         jsc_vm.event_loop()
     };
 
-    // PORT NOTE: reshaped for borrowck — `defer!` is non-`move`, so the closure
+    // Note: reshaped for borrowck — `defer!` is non-`move`, so the closure
     // would capture the *place* `*jsc_vm_ptr` and conflict with later
     // `&mut *jsc_vm_ptr` re-borrows below. Copy the raw pointer into a sibling
     // local so the closure's captured place is disjoint.
@@ -1107,8 +1095,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             // `as_spawn_option` allocated and `spawn_process_windows` may have
             // `uv_pipe_init`-registered on the spawn-sync loop. Skipping this
             // leaks them and trips `assert(err == 0)` in `uv_loop_delete` at
-            // `SpawnSyncEventLoop::Drop`. POSIX: no-op. (Zig spec
-            // js_bun_spawn_bindings.zig:627 — `spawn_options.deinit()`.)
+            // `SpawnSyncEventLoop::Drop`. POSIX: no-op.
             spawn_options.deinit();
             let display_path: &ZStr = if !argv.is_empty() && !argv[0].is_null() {
                 // SAFETY: argv[0] is non-null and points at a NUL-terminated
@@ -1135,14 +1122,14 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             return Err(global_this.throw_value(sys_system_error_to_js(&systemerror, global_this)));
         }
         Err(err) => {
-            // See EMFILE arm above — Zig spec js_bun_spawn_bindings.zig:637.
+            // See EMFILE arm above.
             spawn_options.deinit();
             let _ = global_this.throw_error(err, ": failed to spawn process");
             return Ok(JSValue::ZERO);
         }
         Ok(maybe) => match maybe {
             sys::Result::Err(err) => {
-                // See EMFILE arm above — Zig spec js_bun_spawn_bindings.zig:642.
+                // See EMFILE arm above.
                 spawn_options.deinit();
                 match err.get_errno() {
                     errno @ (sys::Errno::EACCES
@@ -1177,17 +1164,17 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
 
     // Use the isolated loop for spawnSync operations
     //
-    // PORT NOTE: `PosixSpawnResult::to_process` consumes `self` but only reads
-    // `pid`/`pidfd`/`has_exited`. Zig kept using `spawned.stdin/stdout/stderr/
-    // extra_pipes` afterward; in Rust, take those fields out first so the
-    // partial move is explicit.
+    // Note: `PosixSpawnResult::to_process` consumes `self` but only reads
+    // `pid`/`pidfd`/`has_exited`. `stdin/stdout/stderr/extra_pipes` are still
+    // needed afterward, so take those fields out first so the partial move is
+    // explicit.
     let spawned_stdin = spawned.stdin.take();
     let spawned_stdout = spawned.stdout.take();
     let spawned_stderr = spawned.stderr.take();
     let mut spawned_extra_pipes = core::mem::take(&mut spawned.extra_pipes);
     // `to_process` returns a freshly Box-allocated `Process` carrying an
     // intrusive `ThreadSafeRefCount` initialized to 1. `Subprocess.process`
-    // stores it as `*mut Process` (Zig: `*Process`); the matching `deref()` in
+    // stores it as `*mut Process`; the matching `deref()` in
     // `Subprocess::finalize` (or the error path below) frees the Box when the
     // refcount reaches zero.
     let process: *mut Process = spawned.to_process(loop_handle, IS_SYNC);
@@ -1201,11 +1188,8 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
 
     // When run synchronously, subprocess isn't garbage collected.
     //
-    // PORT NOTE: Zig built a placeholder struct, took its address for
-    // `MaxBuf::create_for_subprocess`, then overwrote `subprocess.*` with the
-    // real aggregate. In Rust that whole-struct reassignment would (a) move
-    // `process` twice and (b) run Drop on every field of the placeholder. Build
-    // the struct once with its final field values instead, then fill in the
+    // Note: build
+    // the struct once with its final field values, then fill in the
     // address-dependent fields (maxbufs, ipc_data on Windows) afterward.
     let subprocess_ptr = bun_core::heap::into_raw(Box::new(SubprocessT {
         global_this: bun_ptr::BackRef::new(global_this),
@@ -1217,9 +1201,9 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         // `Writable.init()` writes to `subprocess.weak_file_sink_stdin_ptr`,
         // `subprocess.flags`, and calls `subprocess.ref()` for `.pipe` /
         // `.readable_stream` stdin; if called from inside this aggregate
-        // initializer those writes are clobbered by `.ref_count =
-        // .initExactRefs(2)`, `.flags = .{...}`, and the default
-        // `weak_file_sink_stdin_ptr = null` below. stdout/stderr are deferred
+        // initializer those writes are clobbered by the `ref_count`, `flags`,
+        // and default `weak_file_sink_stdin_ptr` initializers below.
+        // stdout/stderr are deferred
         // so that if `Writable.init()` fails the catch block doesn't have to
         // tear down unstarted `PipeReader`s (whose `deinit()` asserts
         // `isDone()`).
@@ -1332,7 +1316,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             }
             subprocess.finalize_streams();
             subprocess.process_mut().detach();
-            // Zig: `subprocess.process.deref()` releases the intrusive ref
+            // Release the intrusive ref
             // (finalize() won't run on this error path).
             // SAFETY: this error path returns without ever reading `process` again.
             unsafe { Process::deref(subprocess.process.as_ptr()) };
@@ -1344,8 +1328,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
             subprocess.stderr_maxbuf.set(mb);
             subprocess.deref();
             subprocess.deref();
-            // PORT NOTE: Zig returned `err` directly (`bun.JSError` or
-            // `error.OutOfMemory`); the Rust port's `Writable::init` returns
+            // Note: `Writable::init` returns
             // `bun_core::Error`. Map non-thrown to OOM.
             if global_this.has_exception() {
                 return Err(JsError::Thrown);
@@ -1355,7 +1338,6 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         }
     }
 
-    // PORT NOTE: Zig passed `allocator` (unused/autofix) — dropped in Rust port of Readable::init.
     // event_loop points to the live JSC EventLoop for this thread.
     let event_loop_nn = NonNull::new(event_loop).expect("event_loop is null");
     subprocess.stdout.set(Readable::init(
@@ -1417,8 +1399,9 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         return Err(global_this.throw_value(err));
     }
 
-    // PORT NOTE: Zig left this `undefined` and only read it on the assigned path; Rust uses
-    // Option since `IPC::Socket` is a tagged union (zeroed enum is UB).
+    // Note: Option (rather than an uninitialized value) since `IPC::Socket`
+    // is a tagged union (zeroed enum is UB) and it is only read on the
+    // assigned path.
     #[cfg(unix)]
     let mut posix_ipc_info: Option<IPC::Socket> = None;
     #[cfg(unix)]
@@ -1471,8 +1454,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         {
             use crate::node::MaybeExt as _;
             let idx = usize::try_from(ipc_channel).expect("int cast");
-            // Zig: `stdio_pipes.items[ipc_channel].buffer` — direct union-field
-            // access (the IPC channel is always a `buffer` pipe on Windows).
+            // The IPC channel is always a `buffer` pipe on Windows.
             // Ownership of the heap `uv::Pipe` transfers to `ipc_data.socket`;
             // neutralize the slot up front so `finalizeStreams` can't
             // double-close it (the Box would otherwise drop on reassignment).
@@ -1482,9 +1464,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                     other => {
                         // Restore the slot before panicking so the
                         // `Subprocess` finalizer still sees the original
-                        // variant. Zig's `.buffer` field access is
-                        // safety-checked in ReleaseSafe and panics on a
-                        // non-`.buffer` variant; mirror that with
+                        // variant. Use
                         // `unreachable!` (NOT `debug_assert!` — that would
                         // compile out in release and feed null to
                         // `windows_configure_server`, which immediately
@@ -1516,9 +1496,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
     }
 
     if matches!(subprocess.stdin.get(), Writable::Pipe(_)) && promise_for_stream == JSValue::ZERO {
-        // PORT NOTE: Zig writes `subprocess.stdin.pipe.signal =
-        // Signal.init(&subprocess.stdin)` and the callback `@fieldParentPtr`s
-        // back to the `Subprocess`. In Rust the SignalHandler impl is on
+        // Note: the SignalHandler impl is on
         // `Subprocess` and the stored back-pointer is the `*mut Subprocess`
         // (whole-allocation provenance), so `Writable::on_close` can raw-project
         // `stdin` instead of doing out-of-provenance pointer arithmetic. The
@@ -1542,9 +1520,8 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
     let out = if !IS_SYNC {
         // `subprocess_ptr` came from `heap::alloc` above and has not yet been
         // wrapped; ownership transfers to the C++ JS cell (released via
-        // `SubprocessClass__finalize`). Zig's `subprocess.toJS(globalThis)` did
-        // not re-allocate, so use the raw-ptr entrypoint instead of the
-        // by-value `JsClass::to_js` (which would re-box).
+        // `SubprocessClass__finalize`). Use the raw-ptr entrypoint instead of
+        // the by-value `JsClass::to_js` (which would re-box).
         SubprocessT::to_js_from_ptr(subprocess_ptr, global_this)
     } else {
         JSValue::ZERO
@@ -1563,7 +1540,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         if let Some(timeout_val) = timeout {
             let ts =
                 Timespec::ms_from_now(TimespecMockMode::AllowMockedTime, i64::from(timeout_val));
-            // PORT NOTE: `EventLoopTimer.next` is a local-stub Timespec until
+            // Note: `EventLoopTimer.next` is a local-stub Timespec until
             // `bun_event_loop` switches to `bun_core::Timespec`; copy fieldwise.
             subprocess.event_loop_timer.with_mut(|t| {
                 t.next = crate::timer::ElTimespec {
@@ -1571,7 +1548,6 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                     nsec: ts.nsec,
                 };
             });
-            // Zig: `globalThis.bunVM().timer.insert(&subprocess.event_loop_timer)`.
             // `Timer::All` lives in `bun_runtime`; reach it via the
             // `RuntimeHooks` dispatch (`VirtualMachineRef::timer_insert`) which
             // forwards to `crate::timer::All::insert`.
@@ -1621,7 +1597,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — copy `subprocess_ptr` so the
+    // Note: reshaped for borrowck — copy `subprocess_ptr` so the
     // non-`move` `defer!` closure captures a disjoint place from the
     // `(*subprocess_ptr).abort_signal = …` writes that follow.
     let subprocess_ptr_exit = subprocess_ptr;
@@ -1651,7 +1627,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
     }
 
     if let Readable::Pipe(pipe) = subprocess.stdout.get() {
-        // PORT NOTE: pass `subprocess_nn` (the `NonNull<Subprocess<'static>>`
+        // Note: pass `subprocess_nn` (the `NonNull<Subprocess<'static>>`
         // captured above) instead of the live `&mut subprocess`, which would
         // alias with the `&mut subprocess.stdout` borrow held by `pipe`.
         if let Err(err) = Readable::pipe_reader_mut(pipe).start(subprocess_nn, event_loop_nn) {
@@ -1667,7 +1643,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
     }
 
     if let Readable::Pipe(pipe) = subprocess.stderr.get() {
-        // PORT NOTE: see stdout arm above — avoid aliased &mut.
+        // Note: see stdout arm above — avoid aliased &mut.
         if let Err(err) = Readable::pipe_reader_mut(pipe).start(subprocess_nn, event_loop_nn) {
             let _ = subprocess.try_kill(subprocess.kill_signal);
             let _ = global_this.throw_value(err.to_js(global_this));
@@ -1711,8 +1687,8 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         return Ok(out);
     }
 
-    // PORT NOTE: Zig `comptime bun.assert(is_sync)` — anonymous const items cannot capture
-    // const-generic params, so use a runtime debug_assert (the !IS_SYNC path returned above).
+    // Note: anonymous const items cannot capture const-generic params, so use
+    // a runtime debug_assert (the !IS_SYNC path returned above).
     debug_assert!(IS_SYNC);
 
     if can_block_entire_thread_to_reduce_cpu_usage_in_fast_path {
@@ -1773,7 +1749,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
         // This does mean if an AbortSignal times out it will throw
         if let Some(signal) = subprocess.abort_signal_ref() {
             if let Some(abort_signal_timeout) = signal.get_timeout() {
-                // PORT NOTE: `AbortSignal::Timeout.event_loop_timer` uses the
+                // Note: `AbortSignal::Timeout.event_loop_timer` uses the
                 // bun_event_loop-local `Timespec` stub; convert fieldwise.
                 if abort_signal_timeout.event_loop_timer.state
                     == crate::timer::EventLoopTimerState::ACTIVE
@@ -1872,7 +1848,7 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
                                 .unwrap()
                                 .remove_active_timeout(unsafe { &mut *jsc_vm_ptr });
 
-                            // This might internally call `std.c.kill` on this
+                            // This might internally call `kill(2)` on this
                             // spawnSync process. Even if we do that, we still
                             // need to reap the process. So we may go through
                             // the event loop again, but it should wake up
@@ -1959,7 +1935,6 @@ pub(crate) fn spawn_maybe_sync<const IS_SYNC: bool>(
 }
 
 fn throw_command_not_found(global_this: &JSGlobalObject, command: &[u8]) -> JsError {
-    // Zig returns `bun.JSError` (the error value itself); callers wrap in `Err(...)`.
     let err = SystemError {
         message: BunString::create_format(format_args!(
             "Executable not found in $PATH: \"{}\"",
@@ -1977,9 +1952,8 @@ fn throw_command_not_found(global_this: &JSGlobalObject, command: &[u8]) -> JsEr
 }
 
 /// `storage` receives ownership of every `K=V\0` line whose pointer is pushed
-/// into `envp` (and, for `PATH=`, sliced into `*path`). The Zig original used a
-/// bump arena freed at the end of `spawnMaybeSync`; the caller's `Vec<ZBox>`
-/// plays the same role and is dropped after `spawn_process` returns.
+/// into `envp` (and, for `PATH=`, sliced into `*path`); the caller's
+/// `Vec<ZBox>` is dropped after `spawn_process` returns.
 pub(crate) fn append_envp_from_js(
     global_this: &JSGlobalObject,
     object: &JSObject,
@@ -2039,8 +2013,7 @@ pub(crate) fn append_envp_from_js(
                 .throw());
         }
 
-        // PORT NOTE: Zig `std.fmt.allocPrintSentinel(envp.allocator, "{f}={f}", .{key, value}, 0)`
-        // PERF(port): was arena bulk-free — profile if it shows up on a hot path.
+        // PERF: per-entry allocation — profile if it shows up on a hot path.
         let line: ZBox = {
             let mut buf: Vec<u8> = Vec::new();
             write!(&mut buf, "{}={}", key, value_bunstr.to_zig_string())
@@ -2060,5 +2033,3 @@ pub(crate) fn append_envp_from_js(
     }
     Ok(())
 }
-
-// ported from: src/runtime/api/bun/js_bun_spawn_bindings.zig
diff --git a/src/runtime/api/bun/spawn.rs b/src/runtime/api/bun/spawn.rs
index edbb6796099..5cc3f756ac1 100644
--- a/src/runtime/api/bun/spawn.rs
+++ b/src/runtime/api/bun/spawn.rs
@@ -10,7 +10,6 @@
 
 #![warn(unused_must_use)]
 
-// child module: src/runtime/api/bun/spawn/stdio.zig
 // NOTE: explicit #[path] required because the parent (`api.rs`) loads this file
 // via `#[path = "api/bun/spawn.rs"]`, which disables the implicit `spawn/`
 // submodule dir.
@@ -19,5 +18,4 @@ pub mod stdio;
 
 pub use ::bun_spawn::posix_spawn::{BunSpawn, PosixSpawn, bun_spawn, posix_spawn};
 
-// sibling module: src/runtime/api/bun/process.zig — now re-exported from the
-// `bun_spawn` workspace crate.
+// `process` is re-exported from the `bun_spawn` workspace crate.
diff --git a/src/runtime/api/bun/spawn/stdio.rs b/src/runtime/api/bun/spawn/stdio.rs
index 13e6f4bceb8..81f5ef10f2b 100644
--- a/src/runtime/api/bun/spawn/stdio.rs
+++ b/src/runtime/api/bun/spawn/stdio.rs
@@ -5,7 +5,7 @@ use bun_sys::windows::libuv as uv;
 use bun_sys::{self as sys, Fd, FdExt as _};
 
 // `bun.jsc.WebCore` lives in this crate (not `bun_jsc`); alias so the body can
-// say `webcore::ReadableStream` / `webcore::body::Value` per the .zig spec.
+// say `webcore::ReadableStream` / `webcore::body::Value`.
 use crate::webcore;
 use crate::webcore::blob::store::Data as StoreData;
 use crate::webcore::node_types::{PathLike, PathOrFileDescriptor};
@@ -14,39 +14,39 @@ use crate::webcore::node_types::{PathLike, PathOrFileDescriptor};
 // keep `process` leaf; `subprocess` re-exports it).
 use crate::api::bun_process::{self as process, Dup2 as ProcessDup2, StdioKind};
 
-// `SpawnOptions.Stdio` in Zig is a platform-dependent nested decl. Rust enums
-// can't nest type decls, so process.rs exposes `PosixStdio` / `WindowsStdio`;
-// alias the active one as `SpawnOptionsStdio` so the body stays platform-neutral.
+// `SpawnOptions.Stdio` is platform-dependent: process.rs exposes `PosixStdio` /
+// `WindowsStdio`; alias the active one as `SpawnOptionsStdio` so the body stays
+// platform-neutral.
 #[cfg(not(windows))]
 pub(crate) type SpawnOptionsStdio = process::PosixStdio;
 #[cfg(windows)]
 pub(crate) type SpawnOptionsStdio = process::WindowsStdio;
 
 // `bun.FD.Stdio` (the StdIn/StdOut/StdErr tag enum) is `bun_core::Stdio`,
-// re-exported through `bun_sys`. Alias so `FdStdio::StdIn` etc. read as the
-// Zig `bun.FD.Stdio.std_in`.
+// re-exported through `bun_sys`.
 use sys::Stdio as FdStdio;
 
 // `const log = bun.sys.syslog;`
 bun_output::define_scoped_log!(log, SYS, visible);
 
-/// Anonymous payload of `Stdio::Capture` in Zig: `struct { buf: *bun.Vec<u8> }`.
+/// Payload of `Stdio::Capture`.
 #[derive(Clone, Copy)]
 pub struct Capture {
-    // TODO(port): lifetime — Zig holds a raw `*bun.Vec<u8>` backref owned
-    // elsewhere (shell). LIFETIMES.tsv has no row; treating as BACKREF.
+    // BACKREF: raw pointer to a capture buffer owned by the shell interpreter.
+    // The shell keeps the buffer alive for the lifetime
+    // of the spawned process; this struct never frees it.
     pub buf: *mut Vec<u8>,
 }
 
-/// Anonymous payload of `Stdio::Dup2` in Zig.
+/// Payload of `Stdio::Dup2`.
 #[derive(Clone, Copy)]
 pub struct Dup2 {
     pub out: StdioKind,
     pub to: StdioKind,
 }
 
-// Mirrors the Zig `bun.spawn.Stdio` union and is constructed/matched in many
-// other files (subprocess, shell); boxing `Blob` would ripple through all of them.
+// Constructed/matched in many other files (subprocess, shell); boxing `Blob`
+// would ripple through all of them.
 #[allow(clippy::large_enum_variant)]
 pub enum Stdio {
     Inherit,
@@ -63,9 +63,7 @@ pub enum Stdio {
     ReadableStream(webcore::ReadableStream),
 }
 
-// In Zig these are `Stdio.Result` / `Stdio.ResultT` / `Stdio.ToSpawnOptsError`.
-// Rust enums cannot nest type decls, so they live at module scope and callers
-// reference them as `stdio::Result` etc.
+// These live at module scope and callers reference them as `stdio::Result` etc.
 
 pub enum ResultT<T> {
     Result(T),
@@ -185,15 +183,12 @@ impl Stdio {
                 }
             }
 
-            // PORT NOTE: reshaped for borrowck — `remain` borrows `*self`, so we
+            // Note: reshaped for borrowck — `remain` borrows `*self`, so we
             // must drop it before mutating `self`. Shadowing ends the borrow here.
             let _ = remain;
 
-            // PORT NOTE: in Zig only `.array_buffer` / `.blob` are explicitly
-            // deinit'd before reassignment. In Rust, assigning to `*self` drops
-            // the previous variant via `Drop`, which has equivalent behaviour
-            // for those arms and is a no-op for others (and additionally closes
-            // a prior `.memfd`, which Zig left open — arguably a leak fix).
+            // Assigning to `*self` drops the previous variant via `Drop`
+            // (and closes a prior `.memfd`).
             *self = Stdio::Memfd(fd);
             true
         }
@@ -235,8 +230,6 @@ impl Stdio {
                 let fd = FdStdio::from_int(i).unwrap().fd();
                 if blob.needs_to_read_file() {
                     if let Some(store) = blob.store() {
-                        // Zig accesses `store.data.file` directly (union payload);
-                        // in Rust `data` is an enum so match the `File` arm.
                         if let StoreData::File(ref file) = store.data {
                             match file.pathlike {
                                 PathOrFileDescriptor::Fd(store_fd) => {
@@ -429,8 +422,7 @@ impl Stdio {
             }
             return Ok(());
         } else if value.is_number() {
-            // `JSValue.asFileDescriptor()` (jsc/JSValue.zig:2151) is just
-            // `bun.FD.fromUV(this.toInt32())` — inline it here since the
+            // `bun.FD.fromUV(this.toInt32())` inlined here since the
             // upstream `bun_jsc::JSValue` doesn't expose a wrapper.
             let fd = Fd::from_uv(value.to_int32());
             let file_fd = fd.uv();
@@ -558,8 +550,6 @@ impl Stdio {
 
         if blob.needs_to_read_file() {
             if let Some(store) = blob.store() {
-                // Zig accesses `store.data.file` directly (union payload);
-                // in Rust `data` is an enum so match the `File` arm.
                 if let StoreData::File(ref file) = store.data {
                     match file.pathlike {
                         PathOrFileDescriptor::Fd(store_fd) => {
@@ -652,5 +642,3 @@ fn create_zeroed_pipe() -> *mut uv::Pipe {
     // `heap::take` without aliasing a live `Box` (which would double-free).
     bun_core::heap::into_raw(Box::new(bun_core::ffi::zeroed::<uv::Pipe>()))
 }
-
-// ported from: src/runtime/api/bun/spawn/stdio.zig
diff --git a/src/runtime/api/bun/subprocess.rs b/src/runtime/api/bun/subprocess.rs
index ebc32887d8a..26bb1f23b5a 100644
--- a/src/runtime/api/bun/subprocess.rs
+++ b/src/runtime/api/bun/subprocess.rs
@@ -105,7 +105,7 @@ pub enum ObservableGetter {
 
 pub use bun_spawn::process::StdioKind;
 
-// PORT NOTE: `#[bun_jsc::JsClass]` does not yet handle generic structs (it emits the
+// Note: `#[bun_jsc::JsClass]` does not yet handle generic structs (it emits the
 // bare ident in extern signatures). The `JsClass` impl + finalize/construct C-ABI
 // hooks are hand-expanded below for `Subprocess<'_>`.
 //
@@ -116,12 +116,12 @@ pub use bun_spawn::process::StdioKind;
 // codegen shim hands to whichever method JS calls next. `UnsafeCell`-backed
 // fields suppress `noalias` on the outer `&Subprocess`, making the miscompile
 // structurally impossible.
-// Intrusive ref-count: bun.ptr.RefCount(@This(), "ref_count", deinit, .{})
-// `RefPtr<Subprocess>` provides ref/deref and frees the Box when ref_count → 0.
+// Intrusive ref-count: `RefPtr<Subprocess>` provides ref/deref and frees the
+// Box when ref_count → 0; `deinit` runs when the last ref drops.
 #[derive(bun_ptr::RefCounted)]
 pub struct Subprocess<'a> {
     pub ref_count: RefCount<Subprocess<'a>>,
-    /// Intrusively-refcounted `Process` (Zig: `*Process`). Allocated via
+    /// Intrusively-refcounted `Process`. Allocated via
     /// `heap::alloc` in `Process::init_posix`/`init_windows`; the +1 ref
     /// from construction is released in [`Subprocess::finalize`] via
     /// `Process::deref()`. Not `Arc` — `Process` carries its own
@@ -138,7 +138,7 @@ pub struct Subprocess<'a> {
     /// Terminal attached to this subprocess (if spawned with terminal option)
     pub terminal: Cell<Option<NonNull<Terminal>>>,
 
-    // Zig: `*jsc.JSGlobalObject` — JSC global outlives every Subprocess.
+    // The JSC global outlives every Subprocess.
     pub global_this: bun_ptr::BackRef<JSGlobalObject>,
     pub observable_getters: Cell<EnumSet<ObservableGetter>>,
     pub closed: Cell<EnumSet<StdioKind>>,
@@ -148,7 +148,8 @@ pub struct Subprocess<'a> {
     pub ipc_data: JsCell<Option<IPC::SendQueue>>,
     pub flags: Cell<Flags>,
 
-    // TODO(port): lifetime — weak observer, nulled in onStdinDestroyed; no ownership
+    /// Weak observer of the stdin `FileSink` — holds no ownership/ref. `onStdinDestroyed`
+    /// nulls this before the sink is freed, so it is never dereferenced after the sink dies.
     pub weak_file_sink_stdin_ptr: Cell<Option<NonNull<FileSink>>>,
     /// +1 C++-intrusive ref held; released in `clear_abort_signal` via
     /// `AbortSignal::unref()`. Not `Arc` — `AbortSignal` is an opaque FFI
@@ -170,8 +171,8 @@ pub struct Subprocess<'a> {
 
 bun_event_loop::impl_timer_owner!(Subprocess<'_>; from_timer_ptr => event_loop_timer);
 
-// PORT NOTE: no `Default` impl for `Subprocess`. `js_bun_spawn_bindings::
-// spawn_maybe_sync` fills every field explicitly (see PORT NOTE there), and
+// Note: no `Default` impl for `Subprocess`. `js_bun_spawn_bindings::
+// spawn_maybe_sync` fills every field explicitly (see note there), and
 // `*mut Process` has no sound placeholder anyway.
 
 pub type SubprocessRc<'a> = RefPtr<Subprocess<'a>>;
@@ -222,10 +223,9 @@ impl<'a> Subprocess<'a> {
         }
     }
 
-    /// Borrow the intrusively-refcounted `Process`. Zig stores `*Process` and
-    /// reads/mutates freely; every access site is single-threaded on the JS
-    /// mutator, so projecting `&`/`&mut` through the raw pointer mirrors the
-    /// original semantics.
+    /// Borrow the intrusively-refcounted `Process`. Every access site is
+    /// single-threaded on the JS mutator, so projecting `&`/`&mut` through
+    /// the raw pointer is sound.
     #[inline]
     pub fn process(&self) -> &Process {
         self.process.get()
@@ -239,15 +239,16 @@ impl<'a> Subprocess<'a> {
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub(super) fn process_mut(&self) -> &mut Process {
-        // SAFETY: see `process()` — Zig `*Process` semantics. R-2: `&self`
+        // SAFETY: see `process()` — all access is on the single JS-mutator
+        // thread. R-2: `&self`
         // (interior-mutability) so callers don't need `&mut Subprocess`;
         // `Process` lives in a separate allocation (BackRef) so the returned
         // `&mut` never aliases `*self`. Single JS-mutator thread.
         unsafe { &mut *self.process.as_ptr() }
     }
 
-    /// Borrow the stored JSC global. Zig stores `*jsc.JSGlobalObject` raw; the
-    /// global is guaranteed to outlive every Subprocess it created.
+    /// Borrow the stored JSC global. The global is guaranteed to outlive
+    /// every Subprocess it created.
     #[inline]
     pub fn global_this(&self) -> &JSGlobalObject {
         self.global_this.get()
@@ -270,19 +271,19 @@ impl<'a> Subprocess<'a> {
         self.flags.set(v);
     }
 
-    /// Intrusive `ref()` — Zig's `pub const ref = ref_count.ref`.
+    /// Intrusive `ref()`.
     #[inline]
     pub fn ref_(&self) {
         // SAFETY: `&self` → live `*const Self`; `RefCount::ref_` only touches
         // the intrusive counter via `addr_of_mut!`.
         unsafe { RefCount::<Self>::ref_(self.as_ctx_ptr()) }
     }
-    /// Intrusive `deref()` — Zig's `pub const deref = ref_count.deref`.
+    /// Intrusive `deref()`.
     /// May free `self`; do not use `self` after calling.
     #[inline]
     pub fn deref(&self) {
         // SAFETY: `&self` → live `*const Self`; destructor handles the Box.
-        // R-2: `&self` so callers can `defer self.deref()` without holding a
+        // R-2: `&self` so callers can deref at scope exit without holding a
         // unique borrow across re-entrant JS.
         unsafe { RefCount::<Self>::deref(self.as_ctx_ptr()) }
     }
@@ -453,7 +454,6 @@ impl Subprocess<'_> {
             return true;
         }
 
-        // PERF(port): was `inline for` over .{stdout, stderr} — unrolled manually.
         if self.stdout.get().has_pending_activity() {
             return true;
         }
@@ -496,9 +496,8 @@ impl Subprocess<'_> {
                     &self.stderr
                 };
                 if matches!(out.get(), Readable::Pipe(_)) {
-                    // Mirror Zig: copy the pipe pointer out, reassign `out.*`, then
-                    // mutate/deref the pipe. In Rust, move the Rc<PipeReader> out of
-                    // `*out` first so reassigning doesn't drop it while still borrowed.
+                    // Move the Rc<PipeReader> out of `*out` first so
+                    // reassigning doesn't drop it while still borrowed.
                     let Readable::Pipe(pipe) = out.replace(Readable::Ignore) else {
                         unreachable!()
                     };
@@ -586,9 +585,8 @@ impl Subprocess<'_> {
         }
         this.observable_getters
             .set(this.observable_getters.get() | ObservableGetter::Stdin);
-        // PORT NOTE: reshaped for borrowck — Zig passed `&stdin` and `*Subprocess`
-        // separately (aliasing). `Writable::to_js` takes only the parent and
-        // projects `stdin` internally so no two `&mut` overlap here.
+        // `Writable::to_js` takes only the parent and projects `stdin`
+        // internally so no two `&mut` overlap here.
         Ok(Writable::to_js(this, global_this))
     }
 
@@ -768,8 +766,6 @@ impl Subprocess<'_> {
             self.update_has_pending_activity();
         }
 
-        // Zig `defer if (must_deref) this.deref()` — there are no early returns
-        // above, so running it last is the exact LIFO order.
         if must_deref {
             self.deref();
         }
@@ -844,9 +840,8 @@ impl Subprocess<'_> {
             #[cfg(windows)]
             {
                 if let StdioResult::Buffer(buffer) = item {
-                    // `UvHandle::fd()` returns a `HANDLE` (`*mut c_void`); Zig's
-                    // `@intFromPtr(item.buffer.fd().cast())` is just the
-                    // numeric handle value.
+                    // `UvHandle::fd()` returns a `HANDLE` (`*mut c_void`);
+                    // expose the numeric handle value.
                     let fdno: usize = buffer.fd() as usize;
                     array.push(global, JSValue::js_number(fdno as f64))?;
                 } else {
@@ -897,8 +892,7 @@ impl Subprocess<'_> {
         let is_sync = self.flags.get().contains(Flags::IS_SYNC);
         self.clear_abort_signal();
 
-        // defer this.deref();
-        // defer this.disconnectIPC(true);
+        // `deref()` and `disconnect_ipc(true)` run at the tail of this body.
         // R-2: now that both take `&self`, scopeguard would no longer alias —
         // kept explicit at the tail for now (no early returns in this body).
 
@@ -1121,13 +1115,10 @@ impl Subprocess<'_> {
             }
         }
 
-        // defer if (!did_update_has_pending_activity) this.updateHasPendingActivity();
         if !did_update_has_pending_activity {
             self.update_has_pending_activity();
         }
-        // defer this.disconnectIPC(true);
         self.disconnect_ipc(true);
-        // defer this.deref();
         self.deref();
     }
 
@@ -1199,8 +1190,7 @@ impl Subprocess<'_> {
             if let StdioResult::Buffer(buffer) = item {
                 // `uv_close` is async — the pipe must outlive this scope until
                 // `on_pipe_close` runs and reclaims the allocation. Hand the
-                // `Box` back to libuv as a raw pointer (Zig keeps `*uv.Pipe`
-                // and `clearAndFree` only frees the slice of pointers).
+                // `Box` back to libuv as a raw pointer.
                 Box::leak(buffer).close(on_pipe_close);
             }
         }
@@ -1272,7 +1262,7 @@ impl Subprocess<'_> {
         if exit_handler_pending {
             this.deref();
         }
-        // Match Zig's `this.process.deref()`: release the intrusive ref now,
+        // Release the intrusive ref now,
         // not when `ref_count` → 0. The raw `*mut Process` is left dangling but
         // no code path reads `this.process` after this (finalize runs once).
         // SAFETY: `process` is the live Box-backed Process; deref() frees it
@@ -1543,8 +1533,6 @@ pub mod testing_apis {
         Ok(JSValue::TRUE)
     }
 }
-// `generated_js2native.rs` snake-cases Zig's `TestingAPIs` as `testing_ap_is`
+// `generated_js2native.rs` snake-cases `TestingAPIs` as `testing_ap_is`
 // (the converter splits the trailing `…APIs` cluster into `AP` + `Is`).
 pub use testing_apis as testing_ap_is;
-
-// ported from: src/runtime/api/bun/subprocess.zig
diff --git a/src/runtime/api/bun/subprocess/Readable.rs b/src/runtime/api/bun/subprocess/Readable.rs
index eec27c85992..54eb8e21293 100644
--- a/src/runtime/api/bun/subprocess/Readable.rs
+++ b/src/runtime/api/bun/subprocess/Readable.rs
@@ -16,7 +16,7 @@ use bun_ptr::cow_slice::CowSlice;
 use super::subprocess_pipe_reader::PipeReader;
 use super::{StdioResult, Subprocess};
 
-// `bun.ptr.CowString` — the Zig-shaped owned/borrowed byte slice (has
+// `bun.ptr.CowString` — owned/borrowed byte slice (has
 // `init_owned` / `length` / `take_slice`). Distinct from the std `Cow` alias
 // re-exported at `bun_ptr::CowString`.
 pub type CowString = CowSlice<u8>;
@@ -58,8 +58,8 @@ impl Readable {
         unsafe { &mut *pipe.as_ptr() }
     }
 
-    /// Clear the `PipeReader`'s `process` backref and release the caller's ref
-    /// (Zig: `pipe.detach()`). Centralises what was the `into_raw()` +
+    /// Clear the `PipeReader`'s `process` backref and release the caller's ref.
+    /// Centralises what was the `into_raw()` +
     /// `unsafe { PipeReader::detach(raw) }` dance so the three callers in
     /// `finalize` / `to_js` / `to_buffered_value` stay safe — the caller's
     /// `IntrusiveRc` encodes the "live + one ref" invariant `detach()` needs,
@@ -113,12 +113,10 @@ impl Readable {
         max_size: Option<NonNull<MaxBuf>>,
         _is_sync: bool,
     ) -> Readable {
-        // PORT NOTE: Zig `allocator` param dropped (was unused / autofix); global mimalloc assumed.
         super::assert_stdio_result!(result);
 
         // Ownership of any resource inside `stdio` (notably `.memfd`) is being
-        // *transferred* into the returned `Readable` — Zig's `Readable.init`
-        // never calls `stdio.deinit()`. `Stdio` has a Rust `Drop` impl that
+        // *transferred* into the returned `Readable`. `Stdio` has a `Drop` impl that
         // would close the memfd, so suppress it here to avoid a double-close
         // (EBADF) when the Readable later closes the same fd.
         let stdio = mem::ManuallyDrop::new(stdio);
@@ -214,7 +212,6 @@ impl Readable {
                 *self = Readable::Closed;
             }
             Readable::Pipe(_) => {
-                // PORT NOTE: reshaped for borrowck — Zig captures `pipe` by-copy then overwrites `this.*`.
                 let Readable::Pipe(pipe) = mem::replace(self, Readable::Closed) else {
                     unreachable!()
                 };
@@ -240,8 +237,8 @@ impl Readable {
                 Self::pipe_detach(&pipe);
             }
             Readable::Buffer(_) => {
-                // PORT NOTE: Zig calls `buf.deinit(default_allocator)` without resetting the tag.
-                // In Rust, dropping the CowString (via overwrite) is the equivalent; finalize is terminal.
+                // Dropping the CowString (via the overwrite) frees the buffer;
+                // finalize is terminal.
                 *self = Readable::Closed;
             }
             _ => {}
@@ -255,7 +252,6 @@ impl Readable {
 
             Readable::Fd(fd) => Ok(fd.to_js(global)),
             Readable::Pipe(_) => {
-                // PORT NOTE: reshaped for borrowck.
                 let Readable::Pipe(pipe) = mem::replace(self, Readable::Closed) else {
                     unreachable!()
                 };
@@ -264,7 +260,6 @@ impl Readable {
                 result
             }
             Readable::Buffer(_) => {
-                // PORT NOTE: reshaped for borrowck — `defer this.* = .closed` becomes take-then-use.
                 let Readable::Buffer(mut buffer) = mem::replace(self, Readable::Closed) else {
                     unreachable!()
                 };
@@ -297,7 +292,6 @@ impl Readable {
                 }
             }
             Readable::Pipe(_) => {
-                // PORT NOTE: reshaped for borrowck.
                 let Readable::Pipe(pipe) = mem::replace(self, Readable::Closed) else {
                     unreachable!()
                 };
@@ -306,7 +300,6 @@ impl Readable {
                 Ok(result)
             }
             Readable::Buffer(_) => {
-                // PORT NOTE: reshaped for borrowck.
                 let Readable::Buffer(mut buf) = mem::replace(self, Readable::Closed) else {
                     unreachable!()
                 };
@@ -315,9 +308,8 @@ impl Readable {
                     Err(_) => return Err(global.throw_out_of_memory()),
                 };
 
-                // PORT NOTE: ownership of the mimalloc-backed buffer transfers to
-                // JSC (freed via `MarkedArrayBuffer_deallocator`) — matches Zig
-                // `fromBytes(own, .Uint8Array)`.
+                // Ownership of the mimalloc-backed buffer transfers to JSC
+                // (freed via `MarkedArrayBuffer_deallocator`).
                 Ok(jsc::MarkedArrayBuffer {
                     buffer: jsc::ArrayBuffer::from_owned_bytes(own, jsc::JSType::Uint8Array),
                     owns_buffer: true,
@@ -331,5 +323,3 @@ impl Readable {
 }
 
 use bun_core as _; // bun.Output → bun_core (panics inlined as panic!())
-
-// ported from: src/runtime/api/bun/subprocess/Readable.zig
diff --git a/src/runtime/api/bun/subprocess/ResourceUsage.rs b/src/runtime/api/bun/subprocess/ResourceUsage.rs
index 469e4ab17ce..8feb8b5f4bc 100644
--- a/src/runtime/api/bun/subprocess/ResourceUsage.rs
+++ b/src/runtime/api/bun/subprocess/ResourceUsage.rs
@@ -93,5 +93,3 @@ impl ResourceUsage {
         ctx
     }
 }
-
-// ported from: src/runtime/api/bun/subprocess/ResourceUsage.zig
diff --git a/src/runtime/api/bun/subprocess/SubprocessPipeReader.rs b/src/runtime/api/bun/subprocess/SubprocessPipeReader.rs
index a38b2cd5bc0..91a58ac4dad 100644
--- a/src/runtime/api/bun/subprocess/SubprocessPipeReader.rs
+++ b/src/runtime/api/bun/subprocess/SubprocessPipeReader.rs
@@ -28,7 +28,7 @@ pub enum State {
     Err(bun_sys::Error),
 }
 
-// `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})` — intrusive, single-thread.
+// Intrusive, single-thread ref-count; `deinit` runs when the last ref drops.
 #[derive(bun_ptr::RefCounted)]
 #[ref_count(destroy = PipeReader::deinit, debug_name = "PipeReader")]
 pub struct PipeReader {
@@ -121,8 +121,7 @@ impl PipeReader {
         MaxBuf::add_to_pipereader(limit, &mut this.reader.maxbuf);
         #[cfg(windows)]
         {
-            // Zig: `this.reader.source = .{ .pipe = this.stdio_result.buffer }` —
-            // on Windows `StdioResult` is the `WindowsStdioResult` enum and the
+            // On Windows `StdioResult` is the `WindowsStdioResult` enum and the
             // `.buffer` payload is a heap-allocated `uv::Pipe`. Ownership
             // transfers to `reader.source`; `stdio_result` is left `Unavailable`.
             if let StdioResult::Buffer(pipe) = this.stdio_result.take() {
@@ -183,10 +182,6 @@ impl PipeReader {
                             // will drop the last ref and deinit() closes the handle.
                             return bun_sys::Result::Ok(());
                         }
-                        // PORT NOTE: `PollOrFd` is an enum in the Rust port; the Zig
-                        // `this.reader.handle.poll` field projection becomes a variant
-                        // pattern. `FilePoll` is an opaque vtable-backed handle (Copy)
-                        // with `set_flag` standing in for `poll.flags.insert(...)`.
                         if let Some(poll) = self.reader.handle.get_poll() {
                             poll.set_flag(FilePollFlag::Socket);
                             poll.set_flag(FilePollFlag::Nonblocking);
@@ -238,8 +233,8 @@ impl PipeReader {
 
     pub(crate) fn to_owned_slice(&mut self) -> Vec<u8> {
         if let State::Done(bytes) = core::mem::replace(&mut self.state, State::Pending) {
-            // PORT NOTE: reshaped for borrowck — Zig reads `state.done` in place; here we
-            // take it out and restore Pending (caller immediately overwrites state anyway).
+            // Take the bytes out and restore Pending — the caller immediately
+            // overwrites the state anyway.
             return bytes;
         }
         // we do not use .toOwnedSlice() because we don't want to reallocate memory.
@@ -250,8 +245,7 @@ impl PipeReader {
             return Vec::new();
         }
 
-        // PERF(port): Zig returns `out.items` (len-only slice) without shrinking capacity;
-        // returning the Vec preserves capacity, which is the same intent.
+        // Returning the Vec preserves capacity intentionally.
         out
     }
 
@@ -269,7 +263,7 @@ impl PipeReader {
         &mut self,
         global_object: &JSGlobalObject,
     ) -> JsResult<JSValue> {
-        // `defer this.detach()` — detach() = clear `process` backref + deref. The deref
+        // detach() at scope exit = clear `process` backref + deref. The deref
         // may drop the last ref, so it must run after the result is computed; the backref
         // clear must also wait (from_pipe hands `&mut self.reader` to JS, which may
         // re-enter on_reader_done/on_reader_error and consult `self.process`). Compound
@@ -283,15 +277,15 @@ impl PipeReader {
 
         match &self.state {
             State::Pending => {
-                // PORT NOTE: `_parent` is unused in `from_pipe` (Zig `anytype` discard); pass the
-                // raw ptr instead of `self` so borrowck allows `&mut self.reader` alongside it.
+                // `_parent` is unused in `from_pipe`; pass the raw ptr instead
+                // of `self` so borrowck allows `&mut self.reader` alongside it.
                 let stream = ReadableStream::from_pipe(global_object, this_ptr, &mut self.reader);
                 self.state = State::Done(Vec::new());
                 stream
             }
             State::Done(_) => {
-                // PORT NOTE: reshaped for borrowck — take the payload only in this arm so the
-                // Pending arm above observes `state == Pending` when `from_pipe` reads `self`.
+                // Take the payload only in this arm so the Pending arm above
+                // observes `state == Pending` when `from_pipe` reads `self`.
                 let State::Done(bytes) =
                     core::mem::replace(&mut self.state, State::Done(Vec::new()))
                 else {
@@ -314,8 +308,8 @@ impl PipeReader {
         match &mut self.state {
             State::Done(bytes) => {
                 let bytes = core::mem::take(bytes);
-                // `defer this.state = .{ .done = &.{} }` — state.done is now empty via take().
-                // PORT NOTE: `MarkedArrayBuffer::from_bytes` takes a borrowed `&mut [u8]`
+                // `state.done` is now empty via `take()`.
+                // `MarkedArrayBuffer::from_bytes` takes a borrowed `&mut [u8]`
                 // with `owns_buffer = true` (freed via mimalloc on the JS side); leak the
                 // boxed slice so JS becomes the owner — same pattern as
                 // `MarkedArrayBuffer::from_string`.
@@ -328,7 +322,7 @@ impl PipeReader {
     }
 
     pub(crate) fn on_reader_error(&mut self, err: bun_sys::Error) {
-        // Zig: if state == .done, free state.done — handled by Drop of the replaced Vec.
+        // A previous `State::Done` buffer is freed by Drop of the replaced Vec.
         self.state = State::Err(err);
         if let Some(process) = self.process.take() {
             // `process` backref is valid while set; cleared before deref.
@@ -401,16 +395,15 @@ impl PipeReader {
             );
         }
 
-        // Zig: if state == .done, free state.done — handled by Drop of `state` when Box drops.
-        // Zig: this.reader.deinit() — handled by Drop of `reader` field when Box drops.
+        // The `state` buffer and `reader` are freed by Drop when the Box drops.
 
         // SAFETY: `this` was created via heap::alloc in `create()`.
         drop(unsafe { bun_core::heap::take(this) });
     }
 }
 
-// `bun.io.BufferedReader.init(@This())` — vtable parent. The Zig spec declares
-// `onReaderDone`/`onReaderError`/`loop`/`eventLoop` (no `onReadChunk`).
+// BufferedReader vtable parent: `onReaderDone`/`onReaderError`/`loop`/
+// `eventLoop` (no `onReadChunk`).
 // `on_reader_done`/`on_reader_error` are tail-position (the reader is finished
 // with `self`), so `&mut *this` autoref is OK.
 bun_io::impl_buffered_reader_parent! {
@@ -441,5 +434,3 @@ bun_io::impl_buffered_reader_parent! {
         sp.on_max_buffer(kind);
     };
 }
-
-// ported from: src/runtime/api/bun/subprocess/SubprocessPipeReader.zig
diff --git a/src/runtime/api/bun/subprocess/Writable.rs b/src/runtime/api/bun/subprocess/Writable.rs
index 0e5f3caef54..0ec7ac6e134 100644
--- a/src/runtime/api/bun/subprocess/Writable.rs
+++ b/src/runtime/api/bun/subprocess/Writable.rs
@@ -18,8 +18,8 @@ use bun_io::pipe_writer::BaseWindowsPipeWriter as _;
 use super::{Flags, StaticPipeWriter, StdioResult, Subprocess, js};
 
 pub enum Writable<'a> {
-    // PORT NOTE: Zig uses intrusive-refcounted `*FileSink` (manual ref/deref).
-    // Keep a raw NonNull and call `FileSink::deref` explicitly to mirror that.
+    // `FileSink` is intrusive-refcounted (manual ref/deref): keep a raw
+    // NonNull and call `FileSink::deref` explicitly.
     Pipe(NonNull<FileSink>),
     Fd(Fd),
     Buffer(RefPtr<StaticPipeWriter<'a>>),
@@ -137,9 +137,7 @@ impl<'a> Writable<'a> {
     // When the stream has closed we need to be notified to prevent a use-after-free
     // We can test for this use-after-free by enabling hot module reloading on a file and then saving it twice
     //
-    // PORT NOTE: reshaped for borrowck — Zig `@fieldParentPtr("stdin", this)`
-    // recovers `*Subprocess` from `*Writable` and freely interleaves access to
-    // both. In Rust, deriving the parent from `&mut self` is out-of-provenance
+    // Note: deriving the parent from `&mut self` would be out-of-provenance
     // (the `&mut` only covers the `stdin` field). Instead the `SignalHandler`
     // impl is on `Subprocess` and hands us the parent directly; field accesses
     // here are disjoint and sequential so a plain `&Subprocess` suffices.
@@ -150,12 +148,11 @@ impl<'a> Writable<'a> {
             }
         }
 
-        // Moving the payload out and writing `.Ignore` here hoists Zig's
-        // trailing `this.* = .{.ignore}` ahead of `on_stdin_destroyed` — in
-        // Zig that write follows a `deref()` that may free `process`, which
-        // would be a write-after-free. The only observable difference is
-        // `has_pending_activity_stdio()` seeing `Ignore` (== false) instead of
-        // a just-deref'd `Buffer` (== true) inside
+        // Move the payload out and write `.Ignore` *before*
+        // `on_stdin_destroyed` — writing afterwards would follow a `deref()`
+        // that may free `process`, a write-after-free. The only observable
+        // difference is `has_pending_activity_stdio()` seeing `Ignore`
+        // (== false) instead of a just-deref'd `Buffer` (== true) inside
         // `update_has_pending_activity`, which is the state it converges to
         // immediately after anyway.
         match process.stdin.replace(Writable::Ignore) {
@@ -182,7 +179,6 @@ impl<'a> Writable<'a> {
         result: StdioResult,
         promise_for_stream: &mut JSValue,
     ) -> Result<Writable<'a>, bun_core::Error> {
-        // TODO(port): narrow error set
         super::assert_stdio_result!(result);
 
         let global = event_loop.global_ref();
@@ -204,8 +200,8 @@ impl<'a> Writable<'a> {
                 Stdio::Pipe | Stdio::ReadableStream(_) => {
                     if let StdioResult::Buffer(buffer) = result {
                         // Ownership of the `Box<uv::Pipe>` transfers to the
-                        // FileSink's writer (mirrors Zig where `result.buffer`
-                        // is a heap pointer the sink takes over).
+                        // FileSink's writer (the sink takes over the heap
+                        // pointer).
                         let uv_pipe: *mut _ = bun_core::heap::into_raw(buffer);
                         // `create_with_pipe` returns a freshly-boxed non-null pointer.
                         let pipe_nn = NonNull::new(FileSink::create_with_pipe(evtloop, uv_pipe))
@@ -322,8 +318,7 @@ impl<'a> Writable<'a> {
                     }
                 }
 
-                // Zig: `pipe.writer.handle.poll.flags.insert(.socket);`
-                // `handle` is `PollOrFd` (enum) in Rust; flag mutation goes
+                // `handle` is `PollOrFd` (enum); flag mutation goes
                 // through the FilePoll vtable shim.
                 pipe.writer.with_mut(|w| {
                     if let Some(poll) = w.handle.get_poll() {
@@ -379,8 +374,7 @@ impl<'a> Writable<'a> {
                 super::source_from_array_buffer(core::mem::take(array_buffer)),
             ))),
             Stdio::Memfd(_) => {
-                // Transfer ownership: Zig's `Writable.init` never calls
-                // `stdio.deinit()`. `Stdio`'s Drop would close the memfd, so
+                // Transfer ownership: `Stdio`'s Drop would close the memfd, so
                 // take it out via ManuallyDrop (same pattern as the Blob arm)
                 // to keep the caller's `stdio[0]` drop from double-closing the
                 // fd that Writable now owns.
@@ -399,9 +393,8 @@ impl<'a> Writable<'a> {
     }
 
     pub fn to_js(subprocess: &Subprocess<'a>, global_this: &JSGlobalObject) -> JSValue {
-        // PORT NOTE: reshaped for borrowck — Zig passed `*Writable` (== `&stdin`)
-        // and `*Subprocess` separately, which alias. Take only the parent and
-        // project `stdin` here so no two `&mut` overlap at any point.
+        // Take only the parent and project `stdin` here so no two `&mut`
+        // overlap at any point.
         match subprocess.stdin.replace(Writable::Ignore) {
             Writable::Fd(fd) => {
                 subprocess.stdin.set(Writable::Fd(fd));
@@ -421,7 +414,7 @@ impl<'a> Writable<'a> {
                 JSValue::UNDEFINED
             }
             Writable::Pipe(pipe_nn) => {
-                // stdin already replaced with Ignore above (mirrors Zig `this.* = .{ .ignore = {} }`)
+                // stdin already replaced with Ignore above;
                 // pipe is live (held a +1 in this enum); separate allocation
                 // from `*subprocess` so the borrows are disjoint.
                 if subprocess.has_exited()
@@ -451,8 +444,7 @@ impl<'a> Writable<'a> {
                             &subprocess.process().status,
                         )
                     };
-                    // Rust `FileSink::to_js` takes its own per-wrapper +1 (Zig's
-                    // `toJS` *transfers* the create-time +1). Release the
+                    // `FileSink::to_js` takes its own per-wrapper +1. Release the
                     // enum's create-time +1 now that the wrapper holds its own
                     // — mirrors Blob.rs:1899-1902. `stdin` was already swapped
                     // to `Ignore` above so `on_close` won't double-release.
@@ -495,10 +487,8 @@ impl<'a> Writable<'a> {
         }
     }
 
-    // PORT NOTE: reshaped for borrowck — see `on_close`. Zig
-    // `@fieldParentPtr("stdin", this)` is replaced by the caller passing the
-    // parent; deriving it from `&mut self` on `Writable` would be
-    // out-of-provenance.
+    // Note: see `on_close` — the caller passes the parent; deriving it from
+    // `&mut self` on `Writable` would be out-of-provenance.
     pub fn finalize(subprocess: &Subprocess<'a>) {
         if let Some(this_jsvalue) = subprocess.this_value.get().try_get() {
             if let Some(existing_value) = js::stdin_get_cached(this_jsvalue) {
@@ -520,7 +510,6 @@ impl<'a> Writable<'a> {
             }
             Writable::Buffer(buffer) => {
                 Self::buffer_writer_mut(&buffer).update_ref(false);
-                // PORT NOTE: Zig calls `buffer.deref()` without reassigning to `.ignore`;
                 // RefPtr::deref drops the held ref.
                 buffer.deref();
             }
@@ -558,13 +547,11 @@ impl<'a> Writable<'a> {
     }
 }
 
-// PORT NOTE: Zig wires `pipe.signal = Signal.init(&subprocess.stdin)` and the
-// callbacks then `@fieldParentPtr` back to the `Subprocess`. Registering the
-// `*mut Writable` and recovering the parent inside the callback is
-// out-of-provenance in Rust (the `&mut Writable` formed by the vtable thunk
-// only carries provenance for the `stdin` field). Register the `*mut
-// Subprocess` instead — `signal.ptr` carries whole-allocation provenance and
-// `on_close`/`finalize`/`to_js` raw-project `stdin` from it.
+// Note: registering the `*mut Writable` and recovering the parent inside the
+// callback would be out-of-provenance (the `&mut Writable` formed by the
+// vtable thunk only carries provenance for the `stdin` field). Register the
+// `*mut Subprocess` instead — `signal.ptr` carries whole-allocation provenance
+// and `on_close`/`finalize`/`to_js` raw-project `stdin` from it.
 impl<'a> SignalHandler for Subprocess<'a> {
     fn on_close(&mut self, err: Option<bun_sys::Error>) {
         Writable::on_close(self, err)
@@ -572,5 +559,3 @@ impl<'a> SignalHandler for Subprocess<'a> {
     fn on_ready(&mut self, _: Option<BlobSizeType>, _: Option<BlobSizeType>) {}
     fn on_start(&mut self) {}
 }
-
-// ported from: src/runtime/api/bun/subprocess/Writable.zig
diff --git a/src/runtime/api/bun/x509.rs b/src/runtime/api/bun/x509.rs
index 3e0b38098a7..cbc505acda2 100644
--- a/src/runtime/api/bun/x509.rs
+++ b/src/runtime/api/bun/x509.rs
@@ -13,7 +13,6 @@ pub(crate) fn to_js_object(cert: &mut X509, global_object: &JSGlobalObject) -> J
     Ok(Bun__X509__toJS(cert, global_object))
 }
 
-// TODO(port): move to runtime_sys (or bun_boringssl_sys)
 // `X509`/`JSGlobalObject` are opaque `repr(C)` handles; `&mut`/`&` are
 // ABI-identical to non-null pointers, so the validity proof is in the type.
 unsafe extern "C" {
@@ -23,5 +22,3 @@ unsafe extern "C" {
     ) -> JSValue;
     safe fn Bun__X509__toJS(cert: &mut X509, global_object: &JSGlobalObject) -> JSValue;
 }
-
-// ported from: src/runtime/api/bun/x509.zig
diff --git a/src/runtime/api/crash_handler_jsc.rs b/src/runtime/api/crash_handler_jsc.rs
index f570f45bef7..ebf4942c5ea 100644
--- a/src/runtime/api/crash_handler_jsc.rs
+++ b/src/runtime/api/crash_handler_jsc.rs
@@ -13,7 +13,6 @@ pub mod js_bindings {
 
     pub fn generate(global: &JSGlobalObject) -> JSValue {
         let obj = JSValue::create_empty_object(global, 8);
-        // PORT NOTE: `inline for` over homogeneous (name, host_fn) tuples → const array + plain `for`.
         // `#[bun_jsc::host_fn]` emits an `extern "C"` shim named `__jsc_host_<fn>`; that
         // shim is the `JSHostFn` value passed to `JSFunction::create`.
         const ENTRIES: &[(&str, bun_jsc::JSHostFn)] = &[
@@ -70,8 +69,6 @@ pub mod js_bindings {
 
     #[bun_jsc::host_fn]
     pub(crate) fn js_segfault(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
-        // Zig: @setRuntimeSafety(false) — Rust has no per-fn equivalent; the raw-ptr write below
-        // is already unchecked inside `unsafe`.
         crash_handler::suppress_core_dumps_if_necessary();
         // Under ASAN the SIGSEGV handler is intentionally not installed
         // (`reset_on_posix()` early-returns so ASAN's own DEADLYSIGNAL diagnostic
@@ -132,7 +129,7 @@ pub mod js_bindings {
     ) -> JsResult<JSValue> {
         let bits = analytics::packed_features();
         let mut buf = BoundedArray::<u8, 16>::default();
-        // Zig `@bitCast(bits)` → bitflags `.bits()` (PackedFeatures is repr(transparent) u64).
+        // PackedFeatures is repr(transparent) u64; `.bits()` exposes the raw value.
         crash_handler::write_u64_as_two_vlqs(buf.writer(), bits.bits() as usize)
             // there is definitely enough space in the bounded array
             .expect("unreachable");
@@ -178,5 +175,3 @@ pub mod js_bindings {
         Ok(obj)
     }
 }
-
-// ported from: src/runtime/api/crash_handler_jsc.zig
diff --git a/src/runtime/api/cron.rs b/src/runtime/api/cron.rs
index 4023b3cf8a2..b2f47266199 100644
--- a/src/runtime/api/cron.rs
+++ b/src/runtime/api/cron.rs
@@ -42,7 +42,7 @@ use bun_core::ZStr;
 use bun_io::pipe_reader::BufferedReaderParent;
 #[cfg(target_os = "macos")]
 use bun_sys::FdDirExt as _;
-// Owned NUL-terminated string (Zig `[:0]u8` allocation) — `bun_str` exposes the
+// Owned NUL-terminated string — `bun_str` exposes the
 // borrowed `ZStr` only; the heap-backed counterpart is `bun_core::ZBox`.
 use bun_core::ZBox as ZString;
 use bun_sys::{self as sys, Fd, File};
@@ -65,10 +65,8 @@ use crate::jsc_hooks::timer_all_mut as timer_all;
 // ============================================================================
 
 /// Shared base for [`CronRegisterJob`] and [`CronRemoveJob`].
-// Zig: `fn CronJobBase(comptime Self: type) type { return struct { ... } }`
-//
-// PORT NOTE: every method on the path to `finish()` (which `heap::take`-
-// drops `this`) takes a raw `*mut Self` receiver, mirroring the Zig `*Self`.
+// Note: every method on the path to `finish()` (which `heap::take`-
+// drops `this`) takes a raw `*mut Self` receiver.
 // A `&mut self` *parameter* would carry a Stacked Borrows FnEntry protector,
 // making the in-flight dealloc UB; a *local* `let s = &mut *this` reborrow
 // has no protector and ends at last use under NLL, so field access via `s`
@@ -215,7 +213,7 @@ impl CronRegisterJob {
         }
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn maybe_finished(this: *mut Self) {
         // SAFETY: local reborrow (no FnEntry protector); not used after any
         // call below that may free `this`.
@@ -308,7 +306,7 @@ impl CronRegisterJob {
         unsafe { Self::advance_state(this) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn advance_state(this: *mut Self) {
         // SAFETY: local reborrow; last use precedes any self-freeing call.
         let s = unsafe { &mut *this };
@@ -369,9 +367,8 @@ impl CronRegisterJob {
                 .promise
                 .resolve(&this_ref.global, JSValue::UNDEFINED);
         }
-        // Match Zig ordering: `defer ev.exit(); …; this.deinit();` — Drop runs
-        // INSIDE the enter/exit scope so Process detach/deref and reader
-        // teardown observe the entered event-loop state.
+        // Drop runs INSIDE the enter/exit scope so Process detach/deref and
+        // reader teardown observe the entered event-loop state.
         // SAFETY: `this` was created via heap::alloc in cron_register.
         unsafe { drop(bun_core::heap::take(this)) };
         ev.exit();
@@ -390,7 +387,7 @@ impl CronRegisterJob {
 
     // -- Linux --
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(all(not(target_os = "macos"), not(windows)))]
     unsafe fn start_linux(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -408,7 +405,7 @@ impl CronRegisterJob {
         unsafe { Self::spawn_cmd(this, &mut argv, spawn::Stdio::Ignore, spawn::Stdio::Buffer) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(not(target_os = "macos"))]
     unsafe fn process_crontab_and_install(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -465,15 +462,15 @@ impl CronRegisterJob {
             }
         };
         if file.write_all(&result).is_err() {
-            let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+            let _ = file.close(); // close error is non-actionable
             s.set_err(format_args!("Failed to write temp file"));
             // SAFETY: local reborrow `s` has ended; `this` is the live heap job.
             return unsafe { Self::finish(this) };
         }
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
 
         s.state = RegisterState::InstallingCrontab;
-        // PORT NOTE: explicit deinit of old reader before reassign — Drop handles it.
+        // Note: explicit deinit of old reader before reassign — Drop handles it.
         s.stdout_reader = OutputReader::init::<CronRegisterJob>();
         let Some(crontab_path) = find_crontab() else {
             s.set_err(format_args!("crontab not found in PATH"));
@@ -487,7 +484,7 @@ impl CronRegisterJob {
 
     // -- macOS --
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(target_os = "macos")]
     unsafe fn start_mac(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_bootout`/`finish`.
@@ -607,18 +604,18 @@ impl CronRegisterJob {
             }
         };
         if file.write_all(&plist).is_err() {
-            let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+            let _ = file.close(); // close error is non-actionable
             s.set_err(format_args!("Failed to write plist"));
             // SAFETY: local reborrow `s` has ended; `this` is the live heap job.
             return unsafe { Self::finish(this) };
         }
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
 
         // SAFETY: local reborrow `s` has ended; `this` is the live heap job.
         unsafe { Self::spawn_bootout(this) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(target_os = "macos")]
     unsafe fn spawn_bootout(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -647,7 +644,7 @@ impl CronRegisterJob {
         drop(uid_str);
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(target_os = "macos")]
     unsafe fn spawn_bootstrap(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -834,7 +831,7 @@ pub fn cron_register(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSV
 impl CronRegisterJob {
     // -- Windows --
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn start_windows(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
         let s = unsafe { &mut *this };
@@ -898,12 +895,12 @@ impl CronRegisterJob {
             }
         };
         if file.write_all(&xml).is_err() {
-            let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+            let _ = file.close(); // close error is non-actionable
             s.set_err(format_args!("Failed to write temp XML file"));
             // SAFETY: local reborrow `s` has ended; `this` is the live heap job.
             return unsafe { Self::finish(this) };
         }
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
 
         let mut argv: [*const c_char; 9] = [
             b"schtasks\0".as_ptr().cast(),
@@ -1017,7 +1014,7 @@ impl CronRemoveJob {
         }
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn maybe_finished(this: *mut Self) {
         // SAFETY: local reborrow (no FnEntry protector); not used after any
         // call below that may free `this`.
@@ -1090,7 +1087,7 @@ impl CronRemoveJob {
         unsafe { Self::advance_state(this) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn advance_state(this: *mut Self) {
         // SAFETY: local reborrow; last use precedes any self-freeing call.
         let s = unsafe { &mut *this };
@@ -1165,9 +1162,8 @@ impl CronRemoveJob {
                 .promise
                 .resolve(&this_ref.global, JSValue::UNDEFINED);
         }
-        // Match Zig ordering: `defer ev.exit(); …; this.deinit();` — Drop runs
-        // INSIDE the enter/exit scope so Process detach/deref and reader
-        // teardown observe the entered event-loop state.
+        // Drop runs INSIDE the enter/exit scope so Process detach/deref and
+        // reader teardown observe the entered event-loop state.
         // SAFETY: `this` was created via heap::alloc in cron_remove.
         unsafe { drop(bun_core::heap::take(this)) };
         ev.exit();
@@ -1184,7 +1180,7 @@ impl CronRemoveJob {
         unsafe { spawn_cmd_generic(this, argv, stdin_opt, stdout_opt) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(all(not(target_os = "macos"), not(windows)))]
     unsafe fn start_linux(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -1202,7 +1198,7 @@ impl CronRemoveJob {
         unsafe { Self::spawn_cmd(this, &mut argv, spawn::Stdio::Ignore, spawn::Stdio::Buffer) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(not(target_os = "macos"))]
     unsafe fn remove_crontab_entry(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -1241,12 +1237,12 @@ impl CronRemoveJob {
             }
         };
         if file.write_all(&result).is_err() {
-            let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+            let _ = file.close(); // close error is non-actionable
             s.set_err(format_args!("Failed to write temp file"));
             // SAFETY: local reborrow `s` has ended; `this` is the live heap job.
             return unsafe { Self::finish(this) };
         }
-        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = file.close(); // close error is non-actionable
 
         s.state = RemoveState::InstallingCrontab;
         s.stdout_reader = OutputReader::init::<CronRemoveJob>();
@@ -1260,7 +1256,7 @@ impl CronRemoveJob {
         unsafe { Self::spawn_cmd(this, &mut argv, spawn::Stdio::Ignore, spawn::Stdio::Ignore) };
     }
 
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     #[cfg(target_os = "macos")]
     unsafe fn start_mac(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
@@ -1353,7 +1349,7 @@ pub fn cron_remove(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSVal
 
 #[cfg(windows)]
 impl CronRemoveJob {
-    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] PORT NOTE.
+    /// May free `this`. Raw-ptr receiver: see [`CronJobBase`] note.
     unsafe fn start_windows(this: *mut Self) {
         // SAFETY: local reborrow; not used after `spawn_cmd`/`finish`.
         let s = unsafe { &mut *this };
@@ -1463,7 +1459,7 @@ impl CronJob {
     fn destroy_impl(this: *mut Self) {
         // deinit: this_value.deinit() then destroy.
         // SAFETY: last ref; nobody else holds a pointer.
-        // PORT NOTE: `JsRef::deinit()` was dropped — Strong's Drop on
+        // Note: `JsRef::deinit()` was dropped — Strong's Drop on
         // reassignment handles teardown (JSRef.rs trailer).
         unsafe {
             (*this).this_value.set(JsRef::empty());
@@ -1513,9 +1509,8 @@ impl CronJob {
     }
 
     /// RAII pair for `ref_()` / `deref()`: bumps the intrusive refcount now and
-    /// releases it on drop. Replaces the Zig `this.ref(); defer this.deref();`
-    /// idiom. The guard holds a raw pointer (not `&mut Self`) so no Rust
-    /// reference is live across the potential free in `deref()`.
+    /// releases it on drop. The guard holds a raw pointer (not `&mut Self`) so
+    /// no Rust reference is live across the potential free in `deref()`.
     ///
     /// Safe under the same module-private invariant as [`from_ctx_ptr`]: every
     /// call site (private to this module) passes the intrusively-refcounted
@@ -1582,7 +1577,7 @@ impl CronJob {
     }
 
     fn remove_from_list(this: *mut Self, vm: &VirtualMachine) {
-        // PORT NOTE: `RareData::cron_jobs` stores the opaque
+        // Note: `RareData::cron_jobs` stores the opaque
         // `rare_data::high_tier::CronJob`; cast through `*mut ()` for compare.
         // SAFETY: address-equality only.
         let needle = this.cast::<()>();
@@ -1619,7 +1614,7 @@ impl CronJob {
             None => return,
         };
         for job in jobs {
-            // PORT NOTE: stored as opaque `rare_data::high_tier::CronJob`; the
+            // Note: stored as opaque `rare_data::high_tier::CronJob`; the
             // concrete type is this `CronJob` (see `register` push site).
             let job = job.cast::<CronJob>();
             // List holds a ref for each entry.
@@ -1766,10 +1761,9 @@ impl CronJob {
                         Bun__CronJob__onPromiseResolve,
                         Bun__CronJob__onPromiseReject,
                     );
-                    // Zig's `then()` is `TopExceptionScope`-wrapped and only fails
-                    // on termination. The Rust `then()` returns `()`, so re-check
-                    // the VM status and run the same recovery the Zig `catch`
-                    // ran — otherwise `pending_ref` and the `ref_()` above leak.
+                    // `then()` returns `()`, so re-check the VM status and
+                    // recover on termination — otherwise `pending_ref` and the
+                    // `ref_()` above leak.
                     if vm.script_execution_status() != jsc::ScriptExecutionStatus::Running {
                         js::pending_promise_set_cached(
                             js_this,
@@ -1893,7 +1887,7 @@ impl CronJob {
         // so skip the list ref + append entirely.
         if vm.hot_reload == HOT_RELOAD_HOT || vm.worker.is_some() {
             job_ref.ref_(); // owned by cron_jobs entry
-            // PORT NOTE: `RareData::cron_jobs` stores the opaque high-tier
+            // Note: `RareData::cron_jobs` stores the opaque high-tier
             // placeholder type; cast through `*mut ()` and let inference pick
             // the element type.
             vm.rare_data().cron_jobs.push(job.cast::<()>().cast());
@@ -2068,7 +2062,6 @@ pub fn cron_parse(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValu
 // ============================================================================
 
 /// Trait abstracting over CronRegisterJob/CronRemoveJob for `spawn_cmd_generic`.
-// TODO(refactor): merge with CronJobBase.
 trait SpawnCmdTarget: CronJobBase + BufferedReaderParent {
     const EXIT_KIND: bun_spawn::ProcessExitKind;
     fn set_err(&mut self, args: core::fmt::Arguments<'_>);
@@ -2149,7 +2142,7 @@ impl SpawnCmdTarget for CronRemoveJob {
 ///
 /// May free `this` (synchronously, via either an early `T::finish` on setup
 /// error or `watch_or_reap` → exit handler → `maybe_finished` → `finish`).
-/// Raw-ptr receiver: see [`CronJobBase`] PORT NOTE. Callers must not touch
+/// Raw-ptr receiver: see [`CronJobBase`] note. Callers must not touch
 /// `this` after this returns.
 unsafe fn spawn_cmd_generic<T: SpawnCmdTarget>(
     this: *mut T,
@@ -2191,7 +2184,6 @@ unsafe fn spawn_cmd_generic<T: SpawnCmdTarget>(
             }
         }
     }
-    // PERF(port): was arena bulk-free for envp on Windows
     #[cfg(unix)]
     let envp: *const *const c_char = bun_core::c_environ();
     #[cfg(windows)]
@@ -2217,9 +2209,7 @@ unsafe fn spawn_cmd_generic<T: SpawnCmdTarget>(
         }
     };
 
-    // PORT NOTE / OWNERSHIP: Zig stashes the heap libuv pipe in
-    // `stderr_reader.source.?.pipe` and reuses the same pointer for
-    // `SpawnOptions.stderr = .{ .buffer = pipe }`. In the Rust port BOTH
+    // Ownership note: BOTH
     // `Source::Pipe` and `WindowsStdioResult::Buffer` own a `Box<uv::Pipe>`,
     // and `spawn_process_windows` `heap::take`s the raw `Stdio::Buffer`
     // pointer into `WindowsStdioResult::Buffer` on success. Pre-stashing the
@@ -2382,7 +2372,6 @@ fn find_crontab() -> Option<*const c_char> {
     }
     #[cfg(not(windows))]
     {
-        // Zig: `const static = struct { var buf: bun.PathBuffer = undefined; };`
         // The returned `*const c_char` borrows this buffer, so it must outlive
         // the call. `Bun.cron` is exposed on every `BunObject`, so this is
         // reachable from the main JS thread *and* any Worker thread
@@ -2441,8 +2430,6 @@ fn alloc_print_z(args: core::fmt::Arguments<'_>) -> Result<ZString, bun_alloc::A
 #[cfg(not(target_os = "macos"))]
 fn make_temp_path(prefix: &'static str) -> Result<ZString, bun_alloc::AllocError> {
     let mut name_buf = PathBuffer::uninit();
-    // PORT NOTE: Zig used `prefix ++ "tmp"` at comptime; concat at runtime here.
-    // TODO(port): use const_format::concatcp! once call sites pass a const.
     let mut full_prefix = Vec::with_capacity(prefix.len() + 3);
     full_prefix.extend_from_slice(prefix.as_bytes());
     full_prefix.extend_from_slice(b"tmp");
@@ -2551,7 +2538,6 @@ pub enum CalendarError {
     #[error("OutOfMemory")]
     OutOfMemory,
 }
-// TODO(port): narrow error set
 
 impl From<CalendarError> for bun_core::Error {
     fn from(e: CalendarError) -> Self {
@@ -2581,7 +2567,6 @@ pub fn cron_to_calendar_interval(schedule: &[u8]) -> Result<Vec<u8>, CalendarErr
         }
         let mut vals: Vec<i32> = Vec::new();
         for part in field.split(|&b| b == b',') {
-            // Zig: std.fmt.parseInt(i32, part, 10) on raw []const u8.
             // parse_unsigned (not parse_int) keeps '-5' → InvalidCron.
             let val: i32 =
                 bun_core::parse_unsigned(part, 10).map_err(|_| CalendarError::InvalidCron)?;
@@ -3073,7 +3058,6 @@ fn append_calendar_trigger_with_schedule(
 /// Local stand-in for the planned `bun_core::BitOps` trait — only what
 /// `compute_step_interval` needs, implemented for the two integer widths the
 /// cron bitfields use.
-// TODO(port): replace with `bun_core::BitOps` once that trait lands.
 trait StepBits:
     Copy + core::ops::BitAnd<Output = Self> + core::ops::Sub<Output = Self> + PartialEq
 {
@@ -3124,5 +3108,3 @@ fn compute_step_interval<T: StepBits>(bits: T, _min: u8, max: u8) -> Option<u32>
 }
 
 use bun_core::fmt::buf_print;
-
-// ported from: src/runtime/api/cron.zig
diff --git a/src/runtime/api/cron_parser.rs b/src/runtime/api/cron_parser.rs
index 472fd594795..a45dc2cbaa0 100644
--- a/src/runtime/api/cron_parser.rs
+++ b/src/runtime/api/cron_parser.rs
@@ -277,7 +277,6 @@ enum NameKind {
 
 /// Parse a single cron field (e.g. "1,5-10,*/3") into a bitset.
 fn parse_field<T: BitInt>(field: &[u8], min: u8, max: u8, kind: NameKind) -> Result<T, CronError> {
-    // TODO(port): Zig used u7 for min/max/step/i; using u8 here (values 128-255 behavior may differ for step)
     if field.is_empty() {
         return Err(CronError::InvalidField);
     }
@@ -299,7 +298,11 @@ fn parse_field<T: BitInt>(field: &[u8], min: u8, max: u8, kind: NameKind) -> Res
             if s.is_empty() {
                 return Err(CronError::InvalidStep);
             }
-            bun_core::parse_decimal::<u8>(s).ok_or(CronError::InvalidStep)?
+            // Steps 128-255 overflow into InvalidStep too.
+            match bun_core::parse_decimal::<u8>(s) {
+                Some(v @ 0..=127) => v,
+                _ => return Err(CronError::InvalidStep),
+            }
         } else {
             1
         };
@@ -438,5 +441,3 @@ macro_rules! impl_bit_int {
     )*};
 }
 impl_bit_int!(u8, u16, u32, u64);
-
-// ported from: src/runtime/api/cron_parser.zig
diff --git a/src/runtime/api/csrf_jsc.rs b/src/runtime/api/csrf_jsc.rs
index 3a952dacb90..e5ad0287ecf 100644
--- a/src/runtime/api/csrf_jsc.rs
+++ b/src/runtime/api/csrf_jsc.rs
@@ -11,7 +11,7 @@ use crate::crypto::evp;
 use crate::node::Encoding as NodeEncoding;
 
 // ── local shims ──────────────────────────────────────────────────────────
-// `bun.ComptimeStringMap.fromJSCaseInsensitive` — the upstream
+// The upstream
 // `bun_jsc::comptime_string_map_jsc` only exposes the case-sensitive `from_js`;
 // the case-insensitive variant is still cfg-gated. Map keys are all lower-case
 // ASCII, so lower the probe and do a direct phf lookup (mirrors PBKDF2.rs).
@@ -23,8 +23,8 @@ fn algorithm_from_js_case_insensitive(
     Ok(evp::lookup_ignore_case(slice.slice()))
 }
 
-/// `JSValue.getOptional(_, _, ZigString.Slice)` — local shim until `bun_jsc`
-/// grows a typed `get_optional`. Returns `None` for missing/null/undefined.
+/// Local shim until `bun_jsc` grows a typed `get_optional`.
+/// Returns `None` for missing/null/undefined.
 fn get_optional_slice(
     target: JSValue,
     global: &JSGlobalObject,
@@ -44,10 +44,9 @@ fn get_optional_slice(
     }
 }
 
-/// `JSValue.getOptionalInt(_, _, u64)` — local shim. Spec (`JSValue.zig:1896`)
-/// delegates to `validateIntegerRange` with `[0, MAX_SAFE_INTEGER]`; that
-/// helper is defined on the cfg-gated `JSGlobalObject` impl, so inline the
-/// minimal u64 path here.
+/// Local shim: validates an integer in `[0, MAX_SAFE_INTEGER]`.
+/// `validateIntegerRange` is defined on the cfg-gated `JSGlobalObject` impl,
+/// so inline the minimal u64 path here.
 fn get_optional_int_u64(
     target: JSValue,
     global: &JSGlobalObject,
@@ -94,8 +93,6 @@ pub(crate) fn csrf__generate(global: &JSGlobalObject, frame: &CallFrame) -> JsRe
         }
         secret = Some(js_secret.to_slice(global)?);
     }
-    // `defer if (secret) |s| s.deinit();` — handled by Drop on ZigStringSlice
-
     // Default values
     let mut expires_in: u64 = csrf::DEFAULT_EXPIRATION_MS;
     let mut encoding: csrf::TokenFormat = csrf::TokenFormat::Base64Url;
@@ -238,11 +235,10 @@ pub(crate) fn csrf__verify(global: &JSGlobalObject, frame: &CallFrame) -> JsResu
         );
     }
     let token = js_token.to_slice(global)?;
-    // `defer token.deinit();` — handled by Drop on ZigStringSlice
 
     // Default values
     let mut secret: Option<ZigStringSlice> = None;
-    // `defer if (secret) |s| s.deinit();` — handled by Drop
+    // `secret` is freed by Drop.
     let mut max_age: u64 = csrf::DEFAULT_EXPIRATION_MS;
     let mut encoding: csrf::TokenFormat = csrf::TokenFormat::Base64Url;
     let mut session_id: Option<ZigStringSlice> = None;
@@ -344,5 +340,3 @@ pub(crate) fn csrf__verify(global: &JSGlobalObject, frame: &CallFrame) -> JsResu
 
     Ok(JSValue::from(is_valid))
 }
-
-// ported from: src/runtime/api/csrf_jsc.zig
diff --git a/src/runtime/api/filesystem_router.rs b/src/runtime/api/filesystem_router.rs
index 49e58f47db2..c8be0bf8b38 100644
--- a/src/runtime/api/filesystem_router.rs
+++ b/src/runtime/api/filesystem_router.rs
@@ -44,12 +44,11 @@ use crate::api::bun_object;
 use crate::webcore::{Request, Response};
 use bun_bundler as Transpiler;
 
-// PORT NOTE: `FrameworkFileSystemRouter` is declared in this file's
+// Note: `FrameworkFileSystemRouter` is declared in this file's
 // `filesystem_router.classes.ts`, so codegen looks for the backing struct here
-// (`crate::api::filesystem_router::FrameworkFileSystemRouter`). In Zig the
-// implementation lives in `bake/FrameworkRouter.zig` as `JSFrameworkRouter` and
-// is wired via `generated_classes_list.zig`. Re-export the real type so the
-// codegen-generated thunks resolve without a stub.
+// (`crate::api::filesystem_router::FrameworkFileSystemRouter`). The
+// implementation is `bake::framework_router::JSFrameworkRouter`; re-export the
+// real type so the codegen-generated thunks resolve without a stub.
 pub use crate::bake::framework_router::JSFrameworkRouter as FrameworkFileSystemRouter;
 
 pub(crate) const DEFAULT_EXTENSIONS: &[&[u8]] = &[b"tsx", b"jsx", b"ts", b"mjs", b"cjs", b"js"];
@@ -103,20 +102,20 @@ pub struct FileSystemRouter {
     // router (we hold +1 via `claim` in `constructor`, released in `finalize`).
     pub origin: Option<BackRef<RefString>>,
     pub base_dir: Option<BackRef<RefString>>,
-    // PORT NOTE: Router<'a> only borrows the global FileSystem singleton — `'static` is faithful.
+    // Note: Router<'a> only borrows the global FileSystem singleton — `'static` is faithful.
     pub router: JsCell<Router::Router<'static>>,
-    // PERF(port): was arena bulk-free — Router borrows slices from this arena across calls;
-    // kept as boxed arena per LIFETIMES.tsv (OWNED). TODO(port): confirm bumpalo vs ArenaAllocator.
+    // Router borrows slices from this arena across calls;
+    // kept as boxed arena per LIFETIMES.tsv (OWNED). `bun_alloc::Arena` (mimalloc heap) is
+    // the runtime-wide arena type, so allocations here are individually freeable too.
     pub arena: JsCell<Box<ArenaAllocator>>,
-    // PORT NOTE: dropped `std.mem.Allocator param` field — it was always `arena.arena()`.
     pub asset_prefix: Option<BackRef<RefString>>,
 }
 
 impl FileSystemRouter {
-    // PORT NOTE: `pub const js = jsc.Codegen.JSFileSystemRouter; toJS/fromJS/fromJSDirect`
+    // Note: `pub const js = jsc.Codegen.JSFileSystemRouter; toJS/fromJS/fromJSDirect`
     // are wired by `#[bun_jsc::JsClass]` codegen — deleted per PORTING.md.
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the `Free` shim it emits calls
+    // Note: no `#[bun_jsc::host_fn]` here — the `Free` shim it emits calls
     // a bare `constructor(...)` which cannot resolve inside an `impl`. The
     // `#[bun_jsc::JsClass]` macro already emits the `<Self>::constructor` shim.
     pub fn constructor(
@@ -136,7 +135,6 @@ impl FileSystemRouter {
 
         let mut root_dir_path: ZigStringSlice =
             ZigStringSlice::from_utf8_never_free(vm.top_level_dir());
-        // `defer root_dir_path.deinit()` → Drop on ZigStringSlice
         let mut origin_str: ZigStringSlice = ZigStringSlice::default();
         let mut asset_prefix_slice: ZigStringSlice = ZigStringSlice::default();
 
@@ -181,7 +179,7 @@ impl FileSystemRouter {
                 global_this.throw_invalid_arguments(format_args!("Expected dir to be a string"))
             );
         }
-        // PERF(port): was arena bulk-free — extensions/asset_prefix/log all allocated from this.
+        // extensions/asset_prefix/log are all allocated from this arena.
         let arena = Box::new(ArenaAllocator::new());
         let mut extensions: Vec<&[u8]> = Vec::new();
         if let Some(file_extensions) = argument.get(global_this, "fileExtensions")? {
@@ -202,7 +200,6 @@ impl FileSystemRouter {
                 if val.get_length(global_this)? == 0 {
                     continue;
                 }
-                // PERF(port): was appendAssumeCapacity
                 let bytes = val.to_slice(global_this)?.into_vec();
                 // SAFETY: arena is boxed and moved into the returned `FileSystemRouter`, so the
                 // backing allocation outlives this slice. Cast through raw ptr to detach the
@@ -219,7 +216,8 @@ impl FileSystemRouter {
                     .throw_invalid_arguments(format_args!("Expected assetPrefix to be a string")));
             }
 
-            // TODO(port): `clone_if_borrowed` not on `ZigStringSlice` — copy into arena.
+            // Copy into the arena so the slice always owns stable bytes (ZigStringSlice
+            // has no clone-if-borrowed helper; the copy only happens at construction).
             let s = asset_prefix.to_slice(global_this)?;
             // SAFETY: arena is boxed and moved into the returned `FileSystemRouter`; allocation
             // outlives this slice. Detach borrow via raw ptr so `arena` can be moved below.
@@ -264,7 +262,7 @@ impl FileSystemRouter {
         };
 
         let mut router = Router::Router::init(
-            // PORT NOTE: `vm.transpiler.fs` — the resolver's `FileSystem` singleton.
+            // Note: `vm.transpiler.fs` — the resolver's `FileSystem` singleton.
             Fs::FileSystem::instance(),
             RouteConfig {
                 dir: Box::from(&path_to_use[..]),
@@ -317,14 +315,12 @@ impl FileSystemRouter {
             root_dir_info.abs_path
         };
 
-        // PORT NOTE: `vm.refCountedString` is an interning cache — on a cache HIT it
-        // returns the existing `*mut RefString` WITHOUT bumping the refcount. The Zig
-        // spec gets away with this because `getScriptSrc`/`getOrigin` call `.slice()`
-        // (which leaks +1 each access) so the impl never reaches 0. The Rust port uses
-        // `.leak()` (no ref) there, which exposed the latent imbalance: N routers
-        // sharing one interned RefString → N finalizers deref a single +1 → UAF on the
-        // second deref. Claim an explicit +1 here so each `FileSystemRouter` owns its
-        // hold; `finalize` releases it. (Mirrors Zig's `fs_router.base_dir.?.ref()`.)
+        // Note: `vm.refCountedString` is an interning cache — on a cache HIT it
+        // returns the existing `*mut RefString` WITHOUT bumping the refcount.
+        // `getScriptSrc`/`getOrigin` use `.leak()` (no ref), so without an
+        // explicit hold N routers sharing one interned RefString → N finalizers
+        // deref a single +1 → UAF on the second deref. Claim an explicit +1 here
+        // so each `FileSystemRouter` owns its hold; `finalize` releases it.
         let claim = |p: *mut RefString| -> BackRef<RefString> {
             // `ref_counted_string` returns a live interned `*mut RefString`; wrap as
             // `BackRef` (owner-outlives-holder: VM intern cache + our +1).
@@ -353,9 +349,8 @@ impl FileSystemRouter {
             arena: JsCell::new(arena),
         });
 
-        // PORT NOTE: `base_dir.?.ref()` — Zig borrowed the RefString bytes into
-        // `router.config.dir` and bumped the refcount. RouteConfig::dir is now an owned
-        // `Box<[u8]>`, so copy the bytes; the `claim` above already took our +1.
+        // RouteConfig::dir is an owned `Box<[u8]>`, so copy the bytes; the
+        // `claim` above already took our +1.
         // `base_dir` was just set to Some above.
         let base_dir = fs_router.base_dir.unwrap();
         fs_router
@@ -378,8 +373,8 @@ impl FileSystemRouter {
         let normalized: Vec<u8>;
         #[cfg(windows)]
         {
-            // PORT NOTE: Zig used a `ThreadlocalBuffers` slot. `with_borrow_mut` can't
-            // hand back a slice that outlives the closure, so copy out (cold reload path).
+            // Note: `with_borrow_mut` can't hand back a slice that outlives
+            // the closure, so copy out (cold reload path).
             normalized = WIN32_NORMALIZE_BUF
                 .with_borrow_mut(|buf| vm.fs().normalize_buf(&mut buf[..], input_path).to_vec());
             path = normalized.as_slice();
@@ -439,7 +434,7 @@ impl FileSystemRouter {
     pub fn bust_dir_cache(&self, global_this: &JSGlobalObject) {
         let dir =
             strings::paths::without_trailing_slash_windows_path(&self.router.get().config.dir);
-        // PORT NOTE: reshaped for borrowck — `dir` borrows `self.router.config.dir`; the
+        // Note: reshaped for borrowck — `dir` borrows `self.router.config.dir`; the
         // recursive walk re-derives the path from the resolver per-iteration so a one-time
         // copy is sufficient.
         let dir = dir.to_vec();
@@ -469,7 +464,7 @@ impl FileSystemRouter {
         };
 
         this.bust_dir_cache(global_this);
-        // PORT NOTE: `bust_dir_cache` re-derives the VM borrow internally; rebind here so
+        // Note: `bust_dir_cache` re-derives the VM borrow internally; rebind here so
         // our `vm` borrow is fresh under Stacked Borrows.
         let vm = global_this.bun_vm().as_mut();
 
@@ -525,8 +520,8 @@ impl FileSystemRouter {
         }
 
         // `this.router.deinit(); this.arena.deinit(); destroy(this.arena)` — drop old values.
-        // PORT NOTE: order matters — old router borrows slices from old arena, so it must drop
-        // first (matches Zig teardown order).
+        // Note: order matters — old router borrows slices from old arena, so it must drop
+        // first.
         this.router.set(router);
         this.arena.set(arena);
         // `js.routesSetCached` — wired via `codegen_cached_accessors!` above.
@@ -554,7 +549,8 @@ impl FileSystemRouter {
 
         let mut path: ZigStringSlice = 'brk: {
             if argument.is_string() {
-                // TODO(port): `clone_if_borrowed` not on `ZigStringSlice`; force-own via into_vec.
+                // Force ownership via into_vec: ZigStringSlice has no clone-if-borrowed
+                // helper, and `path` must outlive the JS string rope it came from.
                 break 'brk ZigStringSlice::init_owned(argument.to_slice(global_this)?.into_vec());
             }
 
@@ -605,7 +601,7 @@ impl FileSystemRouter {
             Err(err) => {
                 return Err(global_this.throw(format_args!(
                     "{} parsing path: {}",
-                    err.name(),
+                    bun_core::Error::from(err).name(),
                     bstr::BStr::new(path.slice())
                 )));
             }
@@ -634,8 +630,7 @@ impl FileSystemRouter {
             path = ZigStringSlice::init_owned(decoded.into_vec());
         }
 
-        // PORT NOTE: Zig leaked `path` here (TODO comment in spec) and pointer-freed it
-        // in `MatchedRoute.deinit` via `mi_free(pathname.ptr)`. We instead MOVE `path`
+        // MOVE `path`
         // into `MatchedRoute` so the bytes that `route.pathname`/`query_string`/param
         // values borrow are owned by the same heap-stable Box and freed on finalize.
         let result = MatchedRoute::init(
@@ -647,12 +642,11 @@ impl FileSystemRouter {
         )
         .expect("unreachable");
 
-        // PORT NOTE: `result` is a self-referential `Box<MatchedRoute>` (`route` points
+        // Note: `result` is a self-referential `Box<MatchedRoute>` (`route` points
         // at `route_holder` inside this very allocation). The trait `JsClass::to_js(self)`
         // would deref-move the value OUT of the Box and re-box it at a new address,
         // leaving the self-ref pointers dangling (ASAN use-after-poison). Hand the
-        // existing allocation straight to the C++ wrapper instead — matches Zig's
-        // `result.toJS(globalThis)` which forwards the `*MatchedRoute` as-is.
+        // existing allocation straight to the C++ wrapper instead.
         // Ownership transfers to the GC wrapper (freed via
         // `MatchedRouteClass__finalize`); the leak lives once in `to_js_boxed`.
         Ok(MatchedRoute::to_js_boxed(result, global_this))
@@ -706,8 +700,8 @@ impl FileSystemRouter {
     // false positive on that contract.
     #[allow(clippy::boxed_local)]
     pub fn finalize(mut self: Box<Self>) {
-        // PORT NOTE: RefString deref()s — Zig `?.deref()` on each. `BackRef` Derefs
-        // to `&RefString`; use `.get()` to avoid resolving to `<BackRef as Deref>::deref`.
+        // Note: `BackRef` Derefs to `&RefString`; use `.get()` to avoid
+        // resolving to `<BackRef as Deref>::deref`.
         if let Some(p) = self.asset_prefix.take() {
             p.get().deref();
         }
@@ -723,12 +717,12 @@ impl FileSystemRouter {
 #[bun_jsc::JsClass(no_construct, no_constructor)]
 pub struct MatchedRoute {
     /// Self-referential: always points at `self.route_holder`. See `init`.
-    // PORT NOTE: `Match<'a>` borrows (a) the resolver's process-lifetime DirnameStore for
+    // Note: `Match<'a>` borrows (a) the resolver's process-lifetime DirnameStore for
     // `name`/`file_path`/`basename`/`path` and (b) `self.pathname_backing` for
     // `pathname`/`query_string`/param values. Both are stable for `Self`'s lifetime, so
     // the stored `'static` is the standard self-referential erasure — see `init`.
     pub route: *const RouterMatch<'static>,
-    // PORT NOTE: `route_holder`/`params_list_holder` are wrapped in `UnsafeCell` because
+    // Note: `route_holder`/`params_list_holder` are wrapped in `UnsafeCell` because
     // `route` (above) and `route_holder.params` hold raw self-referential pointers into
     // them. Without `UnsafeCell`, taking `&mut MatchedRoute` (as `get_params`/`get_query`
     // do) would assert unique access to these fields under Stacked Borrows and invalidate
@@ -739,8 +733,7 @@ pub struct MatchedRoute {
     pub param_map: JsCell<Option<QueryStringMap>>,
     pub params_list_holder: UnsafeCell<route_param::List<'static>>,
     /// Owns the bytes that `route_holder.pathname`/`query_string` and the param values in
-    /// `params_list_holder` borrow. Replaces the Zig leak-then-`mi_free(pathname.ptr)`
-    /// pattern with proper ownership; freed by Drop on finalize.
+    /// `params_list_holder` borrow. Freed by Drop on finalize.
     pub pathname_backing: ZigStringSlice,
     // BACKREF — interned `RefString`s; we hold +1 (bumped in `init`, released in
     // `deinit`). The interned allocation outlives every `MatchedRoute`.
@@ -751,7 +744,7 @@ pub struct MatchedRoute {
 }
 
 impl MatchedRoute {
-    // PORT NOTE: `pub const js = jsc.Codegen.JSMatchedRoute; toJS/fromJS/fromJSDirect`
+    // Note: `pub const js = jsc.Codegen.JSMatchedRoute; toJS/fromJS/fromJSDirect`
     // wired by `#[bun_jsc::JsClass]` — deleted.
 
     #[inline]
@@ -821,7 +814,7 @@ impl MatchedRoute {
             pathname_backing,
             needs_deinit: true,
         });
-        // PORT NOTE: `base_dir.ref()` / `o.ref()` / `prefix.ref()` — bump refcounts.
+        // Note: `base_dir.ref()` / `o.ref()` / `prefix.ref()` — bump refcounts.
         // Each is a live interned `RefString` (caller-provided BackRef).
         base_dir.ref_();
         if let Some(o) = origin {
@@ -840,7 +833,7 @@ impl MatchedRoute {
         Ok(route)
     }
 
-    // PORT NOTE: `deinit` is called only from `finalize`; not exposed as `Drop` because
+    // Note: `deinit` is called only from `finalize`; not exposed as `Drop` because
     // `MatchedRoute` is a JsClass m_ctx payload (finalize owns teardown per PORTING.md).
     fn deinit(this: *mut MatchedRoute) {
         // SAFETY: called from finalize on mutator thread.
@@ -848,8 +841,7 @@ impl MatchedRoute {
         this_ref.query_string_map.set(None);
         this_ref.param_map.set(None);
         if this_ref.needs_deinit {
-            // PORT NOTE: Zig did `if mi_is_in_heap_region(pathname.ptr) { mi_free(pathname.ptr) }`
-            // to free the leaked `path` from `match`. We own that allocation as
+            // We own the `path` allocation from `match` as
             // `pathname_backing`; dropping it (and `params_list_holder`) here releases the
             // borrowed bytes BEFORE `route_holder`'s slices would dangle on Box drop.
             this_ref.pathname_backing = ZigStringSlice::EMPTY;
@@ -909,14 +901,13 @@ impl MatchedRoute {
         impl<'a> ObjectInitializer for QueryObjectCreator<'a> {
             fn create(&mut self, obj: &mut JSObject, global: &JSGlobalObject) -> JsResult<()> {
                 // Stack scratch — 256 × 16-byte fat ptr × 2 ≈ 8 KiB, well within Bun's
-                // JS-thread stack budget. The Zig original parked these in
-                // `threadlocal var` purely as a zero-init convenience; porting that as a
-                // `RefCell<[&'static [u8]; 256]>` TLS slot is unsound: `iter.next()`
-                // writes QueryStringMap-lifetime slices into it, and once the map drops
-                // the TLS slot is left holding dangling `&'static [u8]` — invalid-value
-                // UB the next time `with_borrow_mut` produces a `&mut` over it. A stack
-                // array lets inference tie the element lifetime to `iter` and dies with
-                // this frame.
+                // JS-thread stack budget. A `RefCell<[&'static [u8]; 256]>` TLS slot
+                // would be unsound: `iter.next()` writes QueryStringMap-lifetime
+                // slices into it, and once the map drops the TLS slot is left
+                // holding dangling `&'static [u8]` — invalid-value UB the next time
+                // `with_borrow_mut` produces a `&mut` over it. A stack array lets
+                // inference tie the element lifetime to `iter` and dies with this
+                // frame.
                 let mut values_buf: [&[u8]; 256] = [b""; 256];
                 let mut refs_buf: [ZigString; 256] = [ZigString::EMPTY; 256];
 
@@ -951,8 +942,7 @@ impl MatchedRoute {
 
     pub fn get_script_src_string(
         origin: &URL,
-        // PORT NOTE: Zig used `comptime Writer: type, writer: Writer` over a fixedBufferStream of
-        // path bytes; `bun_object::get_public_path` takes `core::fmt::Write`.
+        // `bun_object::get_public_path` takes `core::fmt::Write`.
         writer: &mut impl core::fmt::Write,
         file_path: &[u8],
         client_framework_enabled: bool,
@@ -981,7 +971,6 @@ impl MatchedRoute {
 
     #[bun_jsc::host_fn(getter)]
     pub fn get_script_src(this: &Self, global_this: &JSGlobalObject) -> JsResult<JSValue> {
-        // PORT NOTE: Zig used `std.io.fixedBufferStream` over a PathBuffer. The accessible
         // `bun_object::get_public_path_with_asset_prefix` takes `core::fmt::Write`, so write
         // into a `String` (path components are UTF-8 in practice).
         let mut writer = String::with_capacity(MAX_PATH_BYTES);
@@ -1068,7 +1057,7 @@ impl MatchedRoute {
     }
 }
 
-// PORT NOTE: `bun.ThreadlocalBuffers(struct { buf: if (isWindows) [MAX_PATH_BYTES*2]u8 else void })`
+// Note: `bun.ThreadlocalBuffers(struct { buf: if (isWindows) [MAX_PATH_BYTES*2]u8 else void })`
 // Heap-backed so only a Box pointer lives in TLS — a `const { [0u8; MAX_PATH_BYTES*2] }`
 // initializer here would put ~192 KB of zeros directly into the PE `.tls` section
 // (PE/COFF has no TLS-BSS). See test/js/bun/binary/tls-segment-size.
@@ -1077,5 +1066,3 @@ thread_local! {
     static WIN32_NORMALIZE_BUF: core::cell::RefCell<Box<[u8; MAX_PATH_BYTES * 2]>> =
         core::cell::RefCell::new(bun_core::boxed_zeroed());
 }
-
-// ported from: src/runtime/api/filesystem_router.zig
diff --git a/src/runtime/api/glob.rs b/src/runtime/api/glob.rs
index 7daf31452b8..f0e6bd58a99 100644
--- a/src/runtime/api/glob.rs
+++ b/src/runtime/api/glob.rs
@@ -36,7 +36,7 @@ impl ScanOpts {
         _arena: &Arena,
         cwd_val: JSValue,
         absolute: bool,
-        fn_name: &'static str, // PERF(port): was comptime monomorphization
+        fn_name: &'static str,
     ) -> JsResult<Box<[u8]>> {
         let cwd_string = bun_core::OwnedString::new(BunString::from_js(cwd_val, global_this)?);
         if cwd_string.is_empty() {
@@ -58,7 +58,7 @@ impl ScanOpts {
                 break 'cwd_str Box::<[u8]>::from(cwd_utf8.slice());
             }
 
-            // `cwd_utf8` drops at scope exit (was `defer cwd_utf8.deinit()`).
+            // `cwd_utf8` drops at scope exit.
             let mut path_buf2 = [0u8; MAX_PATH_BYTES * 2];
 
             if !absolute {
@@ -97,7 +97,7 @@ impl ScanOpts {
     fn from_js(
         global_this: &JSGlobalObject,
         arguments: &mut ArgumentsSlice,
-        fn_name: &'static str, // PERF(port): was comptime monomorphization
+        fn_name: &'static str,
         arena: &mut Arena,
     ) -> JsResult<Option<ScanOpts>> {
         let Some(opts_obj) = arguments.next_eat() else {
@@ -193,8 +193,7 @@ impl ScanOpts {
 }
 
 pub(crate) struct WalkTask<'a> {
-    // PORT NOTE: Zig `WalkTask.deinit` did `walker.deinit(true); destroy(walker)`.
-    // `Box<GlobWalker>` drop runs `GlobWalker::Drop` (≡ `deinit(true)`) then frees.
+    // `Box<GlobWalker>` drop runs `GlobWalker::Drop` then frees the box.
     walker: Box<GlobWalker>,
     err: Option<WalkTaskErr>,
     global: &'a JSGlobalObject,
@@ -220,16 +219,11 @@ impl WalkTaskErr {
 pub(crate) type AsyncGlobWalkTask<'a> = ConcurrentPromiseTask<'a, WalkTask<'a>>;
 
 impl<'a> WalkTask<'a> {
-    // PORT NOTE: Zig returned `!*AsyncGlobWalkTask` (the only `try` was the heap
-    // allocation). With the global mimalloc allocator `Box::new` is infallible
-    // (panics on OOM), so the Rust port returns the boxed task directly.
     pub(crate) fn create(
         global_this: &'a JSGlobalObject,
         glob_walker: Box<GlobWalker>,
         has_pending_activity: &'a AtomicUsize,
     ) -> Box<AsyncGlobWalkTask<'a>> {
-        // PORT NOTE: Zig returned `!*AsyncGlobWalkTask` (alloc OOM); Rust `Box::new`
-        // is infallible (panics on OOM via mimalloc), so no error variant.
         let walk_task = Box::new(WalkTask {
             walker: glob_walker,
             global: global_this,
@@ -243,7 +237,6 @@ impl<'a> WalkTask<'a> {
 impl<'a> ConcurrentPromiseTaskContext for WalkTask<'a> {
     const TASK_TAG: bun_event_loop::TaskTag = bun_event_loop::task_tag::AsyncGlobWalkTask;
     fn run(&mut self) {
-        // PORT NOTE: `defer decrPendingActivityFlag(...)` — runs on all paths.
         let guard = scopeguard::guard(self.has_pending_activity, |hpa| {
             decr_pending_activity_flag(hpa);
         });
@@ -265,8 +258,7 @@ impl<'a> ConcurrentPromiseTaskContext for WalkTask<'a> {
     }
 
     fn then(&mut self, promise: &mut JSPromise) -> Result<(), JsTerminated> {
-        // PORT NOTE: Zig `defer this.deinit()` freed walker + self. Ownership of
-        // `Box<WalkTask>` is held by `ConcurrentPromiseTask.ctx`; the wrapper is
+        // Ownership of `Box<WalkTask>` is held by `ConcurrentPromiseTask.ctx`; the wrapper is
         // freed via `ConcurrentPromiseTask::destroy` on the `.manual_deinit` path
         // after `run_from_js` returns, which drops `ctx` (and thus `walker`).
 
@@ -277,7 +269,7 @@ impl<'a> ConcurrentPromiseTaskContext for WalkTask<'a> {
 
         let js_strings = match glob_walk_result_to_js(&mut self.walker, self.global) {
             Ok(v) => v,
-            // PORT NOTE: `error.JSError` → pass the JsError through; reject() pulls the pending exception.
+            // `reject()` pulls the pending exception off the VM.
             Err(e) => return promise.reject(self.global, Err(e)),
         };
         promise.resolve(self.global, js_strings)
@@ -293,9 +285,6 @@ fn glob_walk_result_to_js(
         return JSValue::create_empty_array(global_this, 0);
     }
 
-    // PORT NOTE: Zig keyed `MatchedMap` on `bun.String` so it could call
-    // `BunString.toJSArray(keys)` directly. The Rust `MatchedMap` is
-    // `StringArrayHashMap<()>` (Box<[u8]> keys), so rebuild the JS array here.
     JSValue::create_array_from_iter(global_this, keys.iter(), |key| {
         bun_string_jsc::create_utf8_for_js(global_this, key)
     })
@@ -309,7 +298,7 @@ impl Glob {
         &self,
         global_this: &JSGlobalObject,
         arguments: &mut ArgumentsSlice,
-        fn_name: &'static str, // PERF(port): was comptime monomorphization
+        fn_name: &'static str,
         arena: &mut Arena,
     ) -> JsResult<Option<Box<GlobWalker>>> {
         let Some(match_opts) = ScanOpts::from_js(global_this, arguments, fn_name, arena)? else {
@@ -322,11 +311,6 @@ impl Glob {
         let error_on_broken_symlinks = match_opts.error_on_broken_symlinks;
         let only_files = match_opts.only_files;
 
-        // PORT NOTE: Zig stack-inits `GlobWalker = .{}` then calls `.init()` /
-        // `.initWithCwd()` as out-param mutators. The Rust `GlobWalker` reshaped
-        // those into associated constructors returning `Result<Maybe<Self>>`, so
-        // there is no `Default` and no separate allocation step.
-        // `errdefer alloc.destroy(globWalker)` is handled by Box drop on `?` paths.
         let _ = arena; // arena ownership is no longer threaded through GlobWalker init.
 
         if let Some(cwd) = cwd {
@@ -365,7 +349,7 @@ impl Glob {
         Ok(Some(glob_walker))
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the `#[bun_jsc::JsClass]` derive on
+    // No `#[bun_jsc::host_fn]` here — the `#[bun_jsc::JsClass]` derive on
     // the struct already emits the `GlobClass__construct` shim that calls
     // `<Glob>::constructor(..)`. The free-fn `host_fn` expansion can't name an
     // associated fn without a receiver.
@@ -373,7 +357,7 @@ impl Glob {
         let arguments_ = callframe.arguments_old::<1>();
         // SAFETY: bun_vm() returns a non-null *mut to the live VirtualMachine for this global.
         let mut arguments = ArgumentsSlice::init(global_this.bun_vm(), arguments_.slice());
-        // `arguments` drops at scope exit (was `defer arguments.deinit()`).
+        // `arguments` drops at scope exit.
         let Some(pat_arg) = arguments.next_eat() else {
             return Err(global_this.throw(format_args!(
                 "Glob.constructor: expected 1 arguments, got 0"
@@ -428,8 +412,8 @@ impl Glob {
         // `arguments` drops at scope exit.
 
         let mut arena = Arena::new();
-        // PORT NOTE: GlobWalker::init/init_with_cwd own their allocations (Box) in
-        // the Rust port; the arena here is vestigial and only mirrors Zig structure.
+        // GlobWalker::init/init_with_cwd own their allocations (Box); the
+        // arena here is vestigial.
         let glob_walker =
             match self.make_glob_walker(global_this, &mut arguments, "scan", &mut arena) {
                 Err(err) => {
@@ -444,15 +428,12 @@ impl Glob {
             };
 
         incr_pending_activity_flag(&self.has_pending_activity);
-        // PORT NOTE: Zig `catch { decr; deinit; throwOOM }` handled alloc failure.
-        // Rust `Box::new` is infallible (panics via mimalloc on OOM), so the error
-        // arm collapses; `glob_walker` is moved in and dropped on unwind.
         let mut task = WalkTask::create(global_this, glob_walker, &self.has_pending_activity);
         let promise = task.promise.value();
         task.schedule();
         // Ownership passes to the work pool / event loop; freed via
         // `ConcurrentPromiseTask::destroy` on the `.manual_deinit` path.
-        // PORT NOTE: lifetime — WalkTask<'_> borrows `&self.has_pending_activity`
+        // WalkTask<'_> borrows `&self.has_pending_activity`
         // and `global_this`. Both referents outlive the task: `Glob` is GC-rooted
         // via `hasPendingActivity()`, and `JSGlobalObject` lives until VM teardown.
         // `into_raw` erases the stack-tied `'_` once the heap allocation escapes.
@@ -483,8 +464,7 @@ impl Glob {
                 }
                 Ok(Some(gw)) => gw,
             };
-        // Zig: `defer { globWalker.deinit(true); alloc.destroy(globWalker); }` — Box<GlobWalker>
-        // drops at scope exit (`GlobWalker::Drop` ≡ `deinit(true)`).
+        // Box<GlobWalker> drops at scope exit.
 
         match glob_walker.walk()? {
             bun_sys::Result::Err(err) => {
@@ -502,9 +482,6 @@ impl Glob {
         global_this: &JSGlobalObject,
         callframe: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PERF(port): was arena bulk-free — Zig used a local ArenaAllocator for the
-        // toSlice() temp allocation. Dropped here; to_slice() owns its buffer.
-
         let arguments_ = callframe.arguments_old::<1>();
         // SAFETY: bun_vm() returns a non-null *mut to the live VirtualMachine for this global.
         let mut arguments = ArgumentsSlice::init(global_this.bun_vm(), arguments_.slice());
@@ -521,12 +498,10 @@ impl Glob {
         }
 
         let str = str_arg.to_slice(global_this)?;
-        // `str` drops at scope exit (was `defer str.deinit()`).
+        // `str` drops at scope exit.
 
         Ok(JSValue::from(
             bun_glob::r#match(&self.pattern, str.slice()).matches(),
         ))
     }
 }
-
-// ported from: src/runtime/api/glob.zig
diff --git a/src/runtime/api/html_rewriter.rs b/src/runtime/api/html_rewriter.rs
index 40d271a355d..aa2ea0ee3e9 100644
--- a/src/runtime/api/html_rewriter.rs
+++ b/src/runtime/api/html_rewriter.rs
@@ -1,6 +1,4 @@
 //! HTMLRewriter API — wraps lol-html for JS.
-//!
-//! Ported from src/runtime/api/html_rewriter.zig.
 
 use core::cell::{Cell, RefCell};
 use core::ptr::NonNull;
@@ -14,7 +12,7 @@ use bun_jsc::{
     self as jsc, CallFrame, GlobalRef, JSGlobalObject, JSValue, JsCell, JsResult, ProtectedJSValue,
     StrongOptional, SystemError, bun_string_jsc,
 };
-// PORT NOTE: `bun_jsc::VirtualMachine` is a *module* re-export
+// Note: `bun_jsc::VirtualMachine` is a *module* re-export
 // (`pub use self::virtual_machine as VirtualMachine;`). The struct lives at
 // `bun_jsc::virtual_machine::VirtualMachine` — import that directly so the
 // name resolves as a type at `&mut VirtualMachine` annotations and as the
@@ -24,7 +22,7 @@ use bun_jsc::virtual_machine::VirtualMachine;
 // (`to_js`, `with_encoding`, …) come from the `ZigStringJsc` extension trait.
 use bun_jsc::ZigStringJsc as _;
 use bun_jsc::zig_string::ZigString;
-// PORT NOTE: there is no `bun_lolhtml` safe-wrapper crate yet — the safe
+// Note: there is no `bun_lolhtml` safe-wrapper crate yet — the safe
 // surface lives directly in `bun_lolhtml_sys::lol_html`. Code below references
 // both `lolhtml::Foo` (safe wrappers) and `lolhtml_sys::Foo` (raw opaque
 // handles); they resolve to the same module, so alias both names.
@@ -62,19 +60,16 @@ fn system_error(code: &'static str, message: &'static str) -> SystemError {
 
 type SelectorMap = Vec<*mut lolhtml::HTMLSelector>;
 
-// ─────────────────── wrapInstanceMethod arg-decode helpers ───────────────
+// ─────────────────── instance-method arg-decode helpers ──────────────────
 //
-// PORT NOTE: Zig's `host_fn.wrapInstanceMethod` is a comptime
-// type-directed argument decoder (see host_fn.zig:493-648). The
-// `#[bun_jsc::host_fn(method)]` proc-macro that will eventually replace it
-// hasn't landed, so the per-type decode arms used by HTMLRewriter
+// Note: a `#[bun_jsc::host_fn(method)]` proc-macro form of typed argument
+// decoding hasn't landed, so the per-type decode arms used by HTMLRewriter
 // (`ZigString`, `?ContentOptions`, `JSValue`) are open-coded here as small
-// helpers. They mirror the Zig branches exactly: same error messages, same
-// undefined/null handling, same eat order.
+// helpers.
 
-/// `wrapInstanceMethod` arm for `jsc.ZigString` — eat next arg, throw
+/// Decode arm for `ZigString` — eat next arg, throw
 /// "Missing argument" if absent, "Expected string" if undefined/null,
-/// otherwise `getZigString`.
+/// otherwise `get_zig_string`.
 fn eat_zig_string(iter: &mut ArgumentsSlice<'_>, global: &JSGlobalObject) -> JsResult<ZigString> {
     let Some(value) = iter.next_eat() else {
         return Err(global.throw_invalid_arguments(format_args!("Missing argument")));
@@ -85,14 +80,14 @@ fn eat_zig_string(iter: &mut ArgumentsSlice<'_>, global: &JSGlobalObject) -> JsR
     value.get_zig_string(global)
 }
 
-/// `wrapInstanceMethod` arm for `jsc.JSValue` (required) — eat next arg or
+/// Decode arm for `JSValue` (required) — eat next arg or
 /// throw "Missing argument".
 fn eat_js_value(iter: &mut ArgumentsSlice<'_>, global: &JSGlobalObject) -> JsResult<JSValue> {
     iter.next_eat()
         .ok_or_else(|| global.throw_invalid_arguments(format_args!("Missing argument")))
 }
 
-/// `wrapInstanceMethod` arm for `?ContentOptions` — peek next arg, read
+/// Decode arm for optional `ContentOptions` — peek next arg, read
 /// `.html` and coerce to bool. `None` if no arg or no `.html` property.
 fn eat_content_options(
     iter: &mut ArgumentsSlice<'_>,
@@ -124,17 +119,15 @@ fn eat_content_args(
 }
 
 /// Emit the per-wrapper `content_handler` plus one `(${name}_, $name)` pair
-/// per lol-html content op. Restores the Zig shape (`host_fn.wrapInstanceMethod`
-/// invoked N×) that the Rust port hand-expanded for lack of comptime reflection,
-/// and additionally collapses the 5× duplicated `content_handler` body that Zig
-/// never deduped.
+/// per lol-html content op, sharing one `content_handler` body across all
+/// wrappers.
 ///
 /// - `$Raw`      — bare ident under `lolhtml::` (also paths the raw op as
 ///                 `lolhtml::$Raw::$name`, which holds for all 16 ops).
 /// - `$field`    — the `Cell<*mut lolhtml_sys::$Raw>` field on `self`.
 /// - `$null_ret` — sentinel when the raw ptr is null. **Differs per wrapper**:
 ///                 `JSValue::UNDEFINED` for TextChunk/Element,
-///                 `JSValue::NULL` for DocEnd/Comment/EndTag (matches Zig).
+///                 `JSValue::NULL` for DocEnd/Comment/EndTag.
 /// - Each op arm accepts leading attrs (doc comments, `#[allow(dead_code)]`).
 ///
 /// Expands inside an `impl $Wrapper { ... }` block to associated items.
@@ -185,9 +178,8 @@ macro_rules! lol_content_ops {
                 )
             }
 
-            // host_fn.wrapInstanceMethod hand-expansion: decode
-            // `(content: ZigString, contentOptions: ?ContentOptions)` then
-            // forward.
+            // Decode `(content: ZigString, contentOptions: ?ContentOptions)`
+            // then forward.
             $(#[$attr])*
             pub fn $name(
                 &self,
@@ -233,7 +225,7 @@ pub struct HTMLRewriter {
 }
 
 impl HTMLRewriter {
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — `#[bun_jsc::JsClass]` on the
+    // Note: no `#[bun_jsc::host_fn]` here — `#[bun_jsc::JsClass]` on the
     // struct already emits the C-ABI constructor shim that calls
     // `<HTMLRewriter>::constructor(__g, __f)`.
     pub fn constructor(
@@ -292,7 +284,7 @@ impl HTMLRewriter {
             )
         };
         if res.is_err() {
-            // errdefer: drop handler (Box drop runs ElementHandler::drop) + selector_guard fires.
+            // Error path: drop handler (Box drop runs ElementHandler::drop) + selector_guard fires.
             return Err(global.throw_value(create_lolhtml_error(global)));
         }
 
@@ -344,12 +336,11 @@ impl HTMLRewriter {
 
     pub fn finalize_without_destroy(&self) {
         // context: Rc drop happens via field drop; builder needs explicit FFI deinit.
+        // The Rc release happens when the HTMLRewriter box is dropped — the
+        // only caller is `finalize` above, which consumes `Box<Self>` and
+        // drops it immediately after this returns.
         // SAFETY: builder was created by Builder::init() and not yet freed.
         unsafe { lolhtml::HTMLRewriterBuilder::destroy(self.builder) };
-        // TODO(port): Zig calls context.deref() here explicitly; with Rc the
-        // drop happens when HTMLRewriter is dropped. If finalize_without_destroy
-        // is called without immediate drop, we'd want to swap context to a
-        // fresh Rc. Verify call sites.
     }
 
     pub fn begin_transform(
@@ -369,7 +360,7 @@ impl HTMLRewriter {
         global: &JSGlobalObject,
         response_value: JSValue,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: `Response` doesn't yet impl `JsClass`, so use the
+        // Note: `Response` doesn't yet impl `JsClass`, so use the
         // codegen `from_js` directly instead of `JSValue::as_::<Response>()`.
         if let Some(response) =
             webcore::response::js::from_js(response_value).map(|p| p.cast::<Response>())
@@ -417,7 +408,6 @@ impl HTMLRewriter {
                 BunString::empty(),
                 false,
             )));
-            // defer resp.finalize();
             let _resp_guard = scopeguard::guard(resp, |r| {
                 // SAFETY: `r` is the `heap::into_raw` allocation from just
                 // above; finalize takes ownership and frees it exactly once.
@@ -447,7 +437,7 @@ impl HTMLRewriter {
             let _out_guard = scopeguard::guard((out_response_value, out_response), |(v, r)| {
                 // `Response.js.dangerouslySetPtr(v, null)` — null out the JS
                 // wrapper's `m_ctx` so its GC finalize is a no-op, then finalize
-                // the native side ourselves (Zig: html_rewriter.zig:223-226).
+                // the native side ourselves.
                 // SAFETY: `v` is the live JS wrapper (kept on stack via
                 // ensure_still_alive); `r` is its `m_ctx` pointer, detached here
                 // and finalized exactly once.
@@ -474,9 +464,8 @@ impl HTMLRewriter {
         Err(global.throw_invalid_arguments(format_args!("Expected Response or Body")))
     }
 
-    // ── host_fn.wrapInstanceMethod hand-expansions ───────────────────────
-    // Zig: `pub const on = host_fn.wrapInstanceMethod(HTMLRewriter, "on_", false)`
-    // etc. — see arg-decode helpers at top of file.
+    // ── instance-method arg-decode wrappers ──────────────────────────────
+    // See arg-decode helpers at top of file.
 
     pub fn on(&self, global: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args = call_frame.arguments_old::<2>();
@@ -513,9 +502,11 @@ pub struct HTMLRewriterLoader {
     pub context: Rc<RefCell<LOLHTMLContext>>,
     pub chunk_size: usize,
     pub failed: bool,
-    // TODO(port): lifetime — Zig `Sink` stores `*anyopaque` (no borrow). Rust
-    // `Sink<'a>` borrows its handler; the destination handler outlives this
-    // loader (set in `setup()`), so the lifetime is erased to `'static` here.
+    // Invariant: `Sink<'a>` borrows its handler; the destination handler
+    // outlives this loader (the caller of `setup()` guarantees it), so
+    // `'static` stands in for that cross-object lifetime — the handler
+    // registration is type-erased through FFI, so a real lifetime parameter
+    // cannot be threaded here.
     pub output: webcore::Sink<'static>,
     pub signal: Signal,
     pub backpressure: LinearFifo<u8, DynamicBuffer<u8>>,
@@ -571,12 +562,8 @@ impl HTMLRewriterLoader {
                 self.done();
             }
             Writable::Pending(pending) => {
-                // PORT NOTE: Zig calls `pending.applyBackpressure(allocator,
-                // &this.output, pending, bytes)` — that decl does not exist in
-                // the Zig source (dead code; HTMLRewriterLoader.sink() is never
-                // referenced so Zig never compiles this arm). Mirror the call
-                // shape exactly; do NOT also push into `self.backpressure`
-                // here — that would double-buffer relative to the spec.
+                // Do NOT also push into `self.backpressure` here — that would
+                // double-buffer.
                 // SAFETY: `pending` points at a heap WritablePending owned by
                 // the destination sink; valid for the duration of this call.
                 unsafe { (*pending).apply_backpressure(&mut self.output, bytes) };
@@ -592,9 +579,8 @@ impl HTMLRewriterLoader {
                 );
             }
             Writable::Done => {
-                // PORT NOTE: Zig switch omits `.done` (dead code never
-                // compiled there); route it through `done()` like the other
-                // *AndDone arms rather than silently swallowing it.
+                // Route it through `done()` like the other *AndDone arms
+                // rather than silently swallowing it.
                 self.done();
             }
         }
@@ -630,18 +616,15 @@ impl HTMLRewriterLoader {
             Ok(r) => r,
             Err(_) => {
                 let _ = output.end(None); // error already surfaced via signal/fail path
-                // PORT NOTE: Zig returned a borrowed `[]const u8` into
-                // lol-html's threadlocal last-error buffer. Rust can't return a
-                // slice tied to a temporary, so return the owning `HTMLString`
-                // (caller calls `.slice()` then `.deinit()`).
+                // Return the owning `HTMLString` for lol-html's threadlocal
+                // last-error buffer (caller calls `.slice()` then `.deinit()`).
                 return Some(lolhtml::HTMLString::last_error());
             }
         };
 
         self.chunk_size = chunk_size;
-        // Share the context with the caller via Rc; the Zig version stored a
-        // POD struct copy of an `ArrayListUnmanaged`, which in Rust would
-        // double-own `Vec`/`Box` heap buffers. Clone the Rc instead.
+        // Share the context with the caller via Rc — a struct copy would
+        // double-own `Vec`/`Box` heap buffers.
         self.context = context;
         self.output = output;
 
@@ -652,10 +635,9 @@ impl HTMLRewriterLoader {
         webcore::Sink::init(self)
     }
 
-    // PORT NOTE: The Zig spec (html_rewriter.zig:346-356) does not deinit on
-    // the error path at all — matched here exactly: only the Owned* arms free,
-    // and only on success (caller wraps owned bytes in `ManuallyDrop` and
-    // takes them back out on the success path).
+    // Note: no deinit on the error path — only the Owned* arms free, and only
+    // on success (caller wraps owned bytes in `ManuallyDrop` and takes them
+    // back out on the success path).
     fn write_bytes(&mut self, bytes: &[u8]) -> Option<bun_sys::Error> {
         // SAFETY: rewriter valid (setup() succeeded, not yet finalized).
         if unsafe { lolhtml::HTMLRewriter::write(self.rewriter, bytes) }.is_err() {
@@ -693,8 +675,7 @@ impl HTMLRewriterLoader {
     }
 
     pub fn end(&mut self, err: Option<bun_sys::Error>) -> bun_sys::Result<()> {
-        // PORT NOTE: Zig HTMLRewriterLoader has no `end` (sink() is dead code
-        // there). On input-stream end, flush the rewriter (which calls
+        // On input-stream end, flush the rewriter (which calls
         // OutputSink::done → self.done()) or fail.
         if let Some(e) = err {
             self.fail(e);
@@ -733,7 +714,10 @@ pub struct BufferOutputSink {
     pub response: *mut Response, // BORROW_FIELD: kept alive by response_value Strong
     pub response_value: StrongOptional,
     pub body_value_bufferer: Option<webcore::body::ValueBufferer<'static>>,
-    pub tmp_sync_error: Option<NonNull<JSValue>>, // TODO(port): lifetime — points at a stack local in init()
+    // Points at the `sink_error` stack local in `init()`;
+    // only written while `init()` is on the stack.
+    // See `write_tmp_sync_error` for the full liveness/provenance argument.
+    pub tmp_sync_error: Option<NonNull<JSValue>>,
 }
 
 impl BufferOutputSink {
@@ -775,10 +759,9 @@ impl BufferOutputSink {
             body_value_bufferer: None,
             tmp_sync_error: None,
         }));
-        // defer sink.deref();
         // SAFETY: `sink` is the `heap::into_raw` allocation above; refcount >= 1.
         let _sink_guard = unsafe { bun_ptr::ScopedRef::<BufferOutputSink>::adopt(sink) };
-        // PORT NOTE: do not hold a long-lived `&mut *sink` here — the same
+        // Note: do not hold a long-lived `&mut *sink` here — the same
         // allocation is also written through the raw pointer by the lol-html
         // output-sink callback during `bufferer.run()` and by `deref(sink)`
         // below. Access fields via raw-pointer place expressions instead.
@@ -799,7 +782,7 @@ impl BufferOutputSink {
 
         // SAFETY: sink was just allocated via heap::alloc above; refcount==1.
         unsafe { (*sink).response = result };
-        // PORT NOTE (Stacked Borrows): `sink_error` is written via raw pointer
+        // Note (Stacked Borrows): `sink_error` is written via raw pointer
         // by the unhandled-rejection handler during `bufferer.run()` and via
         // `tmp_sync_error` from `on_finished_buffering`. Use a `Cell` so the
         // exported `*mut` (via `Cell::as_ptr`, i.e. `UnsafeCell::get`) carries
@@ -825,8 +808,8 @@ impl BufferOutputSink {
         unsafe { (*sink).tmp_sync_error = Some(NonNull::new_unchecked(sink_error_ptr)) };
         vm.on_unhandled_rejection =
             VirtualMachine::on_quiet_unhandled_rejection_handler_capture_value;
-        // Zig `defer sink_error.ensureStillAlive()` — read the *live* slot at
-        // scope exit (Cell shares provenance with the raw-pointer writers).
+        // Read the *live* slot at scope exit (Cell shares provenance with the
+        // raw-pointer writers).
         scopeguard::defer! {
             sink_error.get().ensure_still_alive();
             // SAFETY: VM outlives this guard (sync stack frame).
@@ -838,7 +821,7 @@ impl BufferOutputSink {
         // SAFETY: builder valid; sink outlives rewriter (deinit in Drop). Pass
         // the raw `sink` (heap::alloc root) directly so the userdata pointer
         // stored in the C rewriter shares provenance with every other
-        // `(*sink).field` access in this module — see the PORT NOTE on
+        // `(*sink).field` access in this module — see the Note on
         // `HTMLRewriterBuilder::build`.
         let built = unsafe {
             (*builder).build(
@@ -880,7 +863,7 @@ impl BufferOutputSink {
             );
 
             // https://github.com/oven-sh/bun/issues/3334
-            // PORT NOTE: `clone_this` takes `&mut self`, so use the `_mut`
+            // Note: `clone_this` takes `&mut self`, so use the `_mut`
             // accessor (original is `*mut Response`). `clone_this` only reads
             // `self` (FFI mutates a freshly-allocated clone, not the receiver).
             if let Some(headers) = (*original).get_init_headers_mut() {
@@ -896,8 +879,7 @@ impl BufferOutputSink {
         unsafe { (*sink).response_value.set(global, response_js_value) };
 
         // SAFETY: result/original are live *Response (see SAFETY note above).
-        // `url()` is +0 borrowed-bits; `set_url` takes +1 — `.clone()` to bump
-        // (html_rewriter.zig:492 `original.getUrl().clone()`).
+        // `url()` is +0 borrowed-bits; `set_url` takes +1 — `.clone()` to bump.
         unsafe { (*result).set_url((*original).url().clone()) };
 
         // SAFETY: original is a live *Response kept alive by caller.
@@ -910,7 +892,7 @@ impl BufferOutputSink {
             (*sink).ref_();
             (*sink).body_value_bufferer = Some(webcore::body::ValueBufferer::init(
                 sink.cast::<core::ffi::c_void>(),
-                // PORT NOTE: `ValueBuffererCallback` takes `*mut c_void` for ctx;
+                // Note: `ValueBuffererCallback` takes `*mut c_void` for ctx;
                 // `on_finished_buffering` takes `*mut BufferOutputSink`. The
                 // wrapper trampoline restores the concrete type.
                 Self::on_finished_buffering_trampoline,
@@ -950,7 +932,7 @@ impl BufferOutputSink {
         }
 
         // sync error occurs — read via the Cell (shares SharedReadWrite
-        // provenance with the raw-pointer writers; see PORT NOTE above).
+        // provenance with the raw-pointer writers; see Note above).
         let captured = sink_error.get();
         if !captured.is_empty() {
             captured.ensure_still_alive();
@@ -987,7 +969,7 @@ impl BufferOutputSink {
         // SAFETY: `sink` was ref'd in `init()` before scheduling this callback;
         // refcount > 0 so the allocation is live. `adopt` consumes that +1 on Drop.
         let _g = unsafe { bun_ptr::ScopedRef::<BufferOutputSink>::adopt(sink) };
-        // PORT NOTE: do not materialise `&mut *sink` here — the lol-html
+        // Note: do not materialise `&mut *sink` here — the lol-html
         // write/end FFI calls below re-enter `<BufferOutputSink as
         // OutputSink>::write/done` through the userdata pointer, which forms
         // its own `&mut *sink`. Holding an outer `&mut` across that re-entry
@@ -1046,7 +1028,7 @@ impl BufferOutputSink {
         }
     }
 
-    /// PORT NOTE: takes `*mut Self` (not `&mut self`) because
+    /// Note: takes `*mut Self` (not `&mut self`) because
     /// `lolhtml::HTMLRewriter::write/end` re-enter
     /// `<BufferOutputSink as OutputSink>::write/done(&mut self)` through the
     /// userdata pointer registered at build time. A `&mut self` receiver here
@@ -1060,7 +1042,7 @@ impl BufferOutputSink {
         // invariant). Read fields into locals before the FFI calls so no
         // borrow of `*sink` is live across the re-entrant callback.
         let (global, response, rewriter) = unsafe {
-            let _ = (*sink).bytes.grow_by(bytes.len()); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = (*sink).bytes.grow_by(bytes.len()); // OOM/capacity: fire-and-forget
             ((*sink).global, (*sink).response, (*sink).rewriter)
         };
 
@@ -1114,7 +1096,7 @@ impl BufferOutputSink {
     }
 
     pub fn write(&mut self, bytes: &[u8]) {
-        let _ = self.bytes.append(bytes); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = self.bytes.append(bytes); // OOM/capacity: fire-and-forget
     }
 }
 
@@ -1149,8 +1131,8 @@ impl Drop for BufferOutputSink {
 pub struct DocumentHandler {
     // Callbacks are GC-rooted via `ProtectedJSValue` (RAII `JSValue::protect`/
     // `unprotect` pair). `Option::None` ⇒ no protect was taken; `Some` drops
-    // its guard on field drop, so neither the errdefer-on-init nor a manual
-    // `Drop` impl is needed.
+    // its guard on field drop, so neither error-path cleanup at init nor a
+    // manual `Drop` impl is needed.
     pub on_doc_type_callback: Option<ProtectedJSValue>,
     pub on_comment_callback: Option<ProtectedJSValue>,
     pub on_text_callback: Option<ProtectedJSValue>,
@@ -1202,7 +1184,7 @@ impl DocumentHandler {
 
         // Each `Some(val.protected())` below pairs the gcProtect with the
         // field's own drop, so an early `?` return unprotects exactly the
-        // callbacks taken so far — no scopeguard errdefer needed.
+        // callbacks taken so far — no error-path scopeguard needed.
         let mut handler = DocumentHandler {
             on_doc_type_callback: None,
             on_comment_callback: None,
@@ -1329,8 +1311,7 @@ pub trait WrapperLike {
 
 /// Forwarding `WrapperLike` impl — every wrapper type's trait impl is a pure
 /// pass-through to inherent / `CellRefCounted`-derived / `JsClass`-codegen
-/// methods. Mirrors Zig's `HandlerCallback` comptime duck-typing (which needs
-/// no impl block at all — html_rewriter.zig:890). The optional `, invalidate`
+/// methods. The optional `, invalidate`
 /// tail wires up types (Element) that hand out sub-objects which must be
 /// detached alongside the lol-html value.
 macro_rules! impl_wrapper_like {
@@ -1399,8 +1380,7 @@ where
     // (R-2); aliased `&H` is sound, aliased `&mut H` is not.
     let this = unsafe { &*this };
     let global = this.global();
-    // PORT NOTE: spec (html_rewriter.zig:938,954,969,972) re-derives
-    // `this.global.bunVM()` at each use site rather than caching a `&mut`.
+    // Note: re-derive the VM at each use site rather than caching a `&mut`.
     // `cb.call(...)` and `wait_for_promise(...)` re-enter JS / the event loop,
     // which mutate the same VirtualMachine through `global.bun_vm()` (and a
     // nested handler_callback would form its own `&mut VirtualMachine`).
@@ -1410,13 +1390,13 @@ where
     let vm = || -> &mut VirtualMachine { global.bun_vm().as_mut() };
 
     // Use a TopExceptionScope to properly handle exceptions from the JavaScript
-    // callback (html_rewriter.zig:920-922). A post-hoc `try_take_exception()`
+    // callback. A post-hoc `try_take_exception()`
     // is *not* equivalent under
     // `BUN_JSC_validateExceptionChecks=1`: `JSGlobalObject__tryTakeException`
     // constructs a fresh `TopExceptionScope` whose ctor calls
     // `verifyExceptionCheckNeedIsSatisfied`, asserting if the preceding
     // `Bun__JSValue__call` ThrowScope's `simulateThrow()` was not yet observed
-    // by an enclosing scope. Mirror the spec exactly: open the scope here, read
+    // by an enclosing scope. Open the scope here, read
     // the pending exception through it, and clear it explicitly.
     bun_jsc::top_scope!(scope, global);
 
@@ -1466,8 +1446,8 @@ where
     }
 
     if !result.is_undefined_or_null() {
-        // PORT NOTE: spec is `result.isError() or result.isAggregateError(global)`
-        // (html_rewriter.zig:964) — NOT `isAnyError`, which has different
+        // Note: `is_error() || is_aggregate_error(global)` —
+        // NOT `isAnyError`, which has different
         // coverage (Exception cells / `Symbol.error` vs cross-realm
         // AggregateError).
         if result.is_error() || result.is_aggregate_error(global) {
@@ -1865,7 +1845,7 @@ impl Comment {
         html_string_to_js(comment.get_text(), global_object)
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
+    // Note: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
     // emits `CommentPrototype__setText` via `host_setter_result` (which wants
     // `JsResult<()>`); the proc-macro shim would emit a second, conflicting
     // `JsResult<bool>` wrapper.
@@ -1907,9 +1887,9 @@ pub struct EndTag {
 }
 
 pub struct EndTagHandler {
-    // TODO(port): bare JSValue heap field kept alive via JSC gcProtect —
-    // evaluate bun_jsc::Strong (see DocumentHandler note).
-    pub callback: Option<JSValue>,
+    // GC-rooted via `ProtectedJSValue` (RAII protect/unprotect), matching
+    // `DocumentHandler`/`ElementHandler` — self-unprotects on drop.
+    pub callback: Option<ProtectedJSValue>,
     pub global: GlobalRef, // JSC_BORROW
 }
 
@@ -1919,7 +1899,7 @@ impl EndTagHandler {
             this,
             value,
             |w| w.end_tag.set(core::ptr::null_mut()),
-            |h| h.callback,
+            |h| h.callback.as_ref().map(ProtectedJSValue::value),
         )
     }
 
@@ -1973,7 +1953,7 @@ impl EndTag {
         html_string_to_js(end_tag.get_name(), global_object)
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
+    // Note: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
     // emits `EndTagPrototype__setName` via `host_setter_result`.
     pub fn set_name(&self, global: &JSGlobalObject, value: JSValue) -> JsResult<()> {
         let Some(end_tag) = lolhtml::EndTag::from_ptr(self.end_tag.get()) else {
@@ -2184,9 +2164,11 @@ impl Element {
             return Ok(ZigString::init_utf8(b"Expected a function").to_js(global_object));
         }
 
+        // `protected()` takes the gcProtect ref up front; if registration
+        // fails below, dropping the handler box unprotects it again.
         let end_tag_handler = bun_core::heap::into_raw(Box::new(EndTagHandler {
             global: GlobalRef::from(global_object),
-            callback: Some(function),
+            callback: Some(function.protected()),
         }));
 
         if el
@@ -2202,7 +2184,6 @@ impl Element {
             return Err(global_object.throw_value(err));
         }
 
-        function.protect();
         Ok(call_frame.this())
     }
 
@@ -2286,7 +2267,7 @@ impl Element {
         call_frame.this()
     }
 
-    // ── host_fn.wrapInstanceMethod hand-expansions (attribute ops) ───────
+    // ── instance-method arg-decode wrappers (attribute ops) ──────────────
 
     pub fn on_end_tag(&self, global: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args = call_frame.arguments_old::<1>();
@@ -2387,7 +2368,7 @@ impl Element {
         html_string_value(el.tag_name(), global_object)
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
+    // Note: no `#[bun_jsc::host_fn(setter)]` — generated_classes.rs already
     // emits `ElementPrototype__setTagName` via `host_setter_result`.
     pub fn set_tag_name(&self, global: &JSGlobalObject, value: JSValue) -> JsResult<()> {
         let Some(el) = lolhtml::Element::from_ptr(self.element.get()) else {
@@ -2462,5 +2443,3 @@ impl Element {
 }
 
 impl_wrapper_like!(Element, lolhtml::Element, invalidate);
-
-// ported from: src/runtime/api/html_rewriter.zig
diff --git a/src/runtime/api/js_bundle_completion_task.rs b/src/runtime/api/js_bundle_completion_task.rs
index 54318402d90..eb829f09824 100644
--- a/src/runtime/api/js_bundle_completion_task.rs
+++ b/src/runtime/api/js_bundle_completion_task.rs
@@ -50,14 +50,13 @@ use crate::node::types::{
 };
 use crate::server::html_bundle;
 
-/// Mirrors Zig `BundleV2.JSBundleCompletionTask`. See module doc for the
-/// layering rationale.
-// `bun.ptr.ThreadSafeRefCount(@This(), "ref_count", deinit, .{})`
-// NOTE: comment says ThreadSafeRefCount but field is `RefCount<Self>` — pre-
-// existing port discrepancy, not addressed by the dedup.
+/// See module doc for the layering rationale.
 #[derive(bun_ptr::RefCounted)]
 #[ref_count(destroy = Self::deinit, debug_name = "JSBundleCompletionTask")]
 pub struct JSBundleCompletionTask {
+    // NOTE: this should arguably be a thread-safe refcount, but it is the plain
+    // (non-atomic) `RefCount<Self>` — a pre-existing discrepancy. See the
+    // `unsafe impl Send` below for the thread-affinity constraint this imposes.
     pub ref_count: RefCount<Self>,
     pub config: JSBundlerConfig,
     // BACKREF — the JS-thread `EventLoop` outlives every completion task; safe
@@ -95,7 +94,7 @@ impl JSBundleCompletionTask {
         boxed.poll_ref.disable();
         if let Some(plugin) = boxed.plugins.take() {
             // `plugin` is the live FFI handle stashed at construction;
-            // last-ref drop is the only place that releases it (Zig: `plugin.deinit()`).
+            // last-ref drop is the only place that releases it.
             Plugin::destroy(plugin.as_ptr());
         }
         // Owned fields (`config`, `log`, `result`, `promise`) drop with the Box.
@@ -103,7 +102,12 @@ impl JSBundleCompletionTask {
 }
 
 // SAFETY: enqueued onto the bundle thread; field access is serialized by
-// the producer/consumer handshake (`UnboundedQueue` + `Waker`).
+// the producer/consumer handshake (`UnboundedQueue` + `Waker`). Additionally,
+// `ref_count` is the non-atomic `RefCount<Self>` (a `Cell<u32>`; its
+// `ThreadLock` asserts single-thread affinity in debug builds only), so all
+// `ref_()`/`deref()` calls must happen on the JS thread — the bundle thread
+// may hold and transfer an already-taken +1 across the handshake but must
+// never touch the count itself.
 unsafe impl Send for JSBundleCompletionTask {}
 
 /// `BundleV2.createAndScheduleCompletionTask` — construct, take a process-keepalive
@@ -275,9 +279,6 @@ impl JSBundleCompletionTask {
 
     /// Port of `JSBundleCompletionTask.doCompilation`.
     fn do_compilation(&mut self, output_files: &mut Vec<OutputFile>) -> CompileResult {
-        // PORT NOTE: reshaped for borrowck — `self.config` is reborrowed for
-        // every field projection so the `&mut self` receiver stays usable for
-        // `self.env` below.
         let compile_options = self
             .config
             .compile
@@ -303,8 +304,6 @@ impl JSBundleCompletionTask {
         // Always get an absolute path for the outfile to ensure it works
         // correctly with PE metadata operations.
         // Add .exe extension for Windows targets if not already present.
-        // PORT NOTE: collapsed to a single owned `Box<[u8]>` so the
-        // `&mut outbuf` borrow ends before the rest of `self` is touched.
         let full_outfile_path: Box<[u8]> = {
             let outdir_slice = &self.config.outdir.list;
             let outfile_slice = &compile_options.outfile.list;
@@ -442,10 +441,8 @@ impl JSBundleCompletionTask {
         // keep them in the output array. Destroy all other non-entry-point files.
         // With --splitting, there can be multiple sourcemap files (one per chunk).
         let mut kept: usize = 0;
-        // PORT NOTE: reshaped for borrowck — Zig wrote `output_files.items[kept]
-        // = current.*` while iterating `&mut output_files.items`. Swap-compact in
-        // place via index iteration so each loop body holds at most one `&mut`
-        // into `output_files`.
+        // Swap-compact in place via index iteration so each loop body holds
+        // at most one `&mut` into `output_files`.
         for i in 0..output_files.len() {
             let keep_this = if i == entry_point_index {
                 true
@@ -533,8 +530,7 @@ impl JSBundleCompletionTask {
                 output_files.swap(kept, i);
                 kept += 1;
             }
-            // PORT NOTE: Zig called `current.deinit()` on dropped entries; in
-            // Rust the trailing entries are dropped by `truncate` below.
+            // Trailing (dropped) entries are freed by `truncate` below.
         }
         output_files.truncate(kept);
 
@@ -571,18 +567,17 @@ impl JSBundleCompletionTask {
         // instead of `*this` — `do_compilation`/`to_js_error` below need `&mut *this`.
         let global_this_ref = this.global_this;
         let global_this = global_this_ref.get();
-        // PORT NOTE: `Strong::swap` ties the returned `&mut JSPromise` to
+        // `Strong::swap` ties the returned `&mut JSPromise` to
         // `&mut this.promise` even though the cell lives on the GC heap (raw
         // ptr deref inside). Detach via raw ptr so `this` can be reborrowed
-        // for `result`/`config`/`log` below — Zig stored `*JSPromise`.
+        // for `result`/`config`/`log` below.
         let promise: *mut JSPromise = this.promise.swap();
         // SAFETY: GC-owned cell; valid for the duration of this JS-thread callback.
         let promise = unsafe { &mut *promise };
 
-        // PORT NOTE: reshaped for borrowck — `do_compilation` borrows
-        // `&mut self` while needing `&mut output_files` from inside
-        // `self.result`. Temporarily move the Vec out via `take` so the
-        // method gets a disjoint `&mut self`.
+        // `do_compilation` borrows `&mut self` while needing
+        // `&mut output_files` from inside `self.result`. Temporarily move the
+        // Vec out via `take` so the method gets a disjoint `&mut self`.
         if matches!(this.result, BundleV2Result::Value(_)) && this.config.compile.is_some() {
             let mut output_files = match &mut this.result {
                 BundleV2Result::Value(build) => core::mem::take(&mut build.output_files),
@@ -614,9 +609,9 @@ impl JSBundleCompletionTask {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — `to_js_error` borrows `&mut self`,
-        // which would overlap a `&mut this.result` match scrutinee. Dispatch
-        // the pending/err arms first, then take a fresh `&mut` for Value.
+        // `to_js_error` borrows `&mut self`, which would overlap a
+        // `&mut this.result` match scrutinee. Dispatch the pending/err arms
+        // first, then take a fresh `&mut` for Value.
         if matches!(this.result, BundleV2Result::Pending) {
             unreachable!();
         }
@@ -637,10 +632,10 @@ impl JSBundleCompletionTask {
                     );
                 }
 
-                // PORT NOTE: reshaped for borrowck — `output_file.to_js()` needs
-                // `&mut OutputFile` while the path computation reads
-                // `this.config`. Snapshot the config slices once outside the
-                // loop so the per-file `&mut` doesn't overlap `&this.config`.
+                // `output_file.to_js()` needs `&mut OutputFile` while the path
+                // computation reads `this.config`. Snapshot the config slices
+                // once outside the loop so the per-file `&mut` doesn't overlap
+                // `&this.config`.
                 let outdir_is_abs = !this.config.outdir.is_empty()
                     && bun_paths::is_absolute(&this.config.outdir.list);
                 let outdir = this.config.outdir.list.clone();
@@ -825,9 +820,8 @@ impl CompletionStruct for JSBundleCompletionTask {
 
         transpiler.options.env.behavior = config.env_behavior;
         transpiler.options.env.prefix = Box::from(config.env_prefix.list.as_slice());
-        // PORT NOTE: Zig `&config.features` (a `*StringSet` borrow). The Rust
-        // `BundleOptions.bundler_feature_flags: Option<Box<StringSet>>` owns,
-        // so clone the set rather than alias.
+        // `BundleOptions.bundler_feature_flags: Option<Box<StringSet>>` owns
+        // its set, so clone rather than alias `config.features`.
         transpiler.options.bundler_feature_flags = Some(Box::new(config.features.clone()?));
         if config.force_node_env != options::ForceNodeEnv::Unspecified {
             transpiler.options.force_node_env = config.force_node_env;
@@ -953,10 +947,8 @@ impl CompletionStruct for JSBundleCompletionTask {
             transpiler.options.compile = false;
             config.compile = None;
         }
-        // PORT NOTE: `BundleOptions.{banner,footer}` are `Cow<'static, [u8]>`;
-        // Zig assigned a borrow into `*JSBundleCompletionTask` (`this.config`
-        // outlives the build). Clone into Owned so the static bound holds
-        // without tying `&mut self` to `'a`.
+        // `BundleOptions.{banner,footer}` are `Cow<'static, [u8]>`; clone into
+        // Owned so the static bound holds without tying `&mut self` to `'a`.
         transpiler.options.banner = std::borrow::Cow::Owned(config.banner.list.clone());
         transpiler.options.footer = std::borrow::Cow::Owned(config.footer.list.clone());
         transpiler.options.react_fast_refresh = config.react_fast_refresh;
@@ -991,8 +983,7 @@ impl CompletionStruct for JSBundleCompletionTask {
         transpiler.resolver.env_loader =
             NonNull::new(transpiler.env.cast::<bun_dotenv::Loader<'_>>());
         // `Resolver.opts` is the resolver-crate subset
-        // — re-project from the now-mutated `transpiler.options` (Zig assigned
-        // the struct by value: `resolver.opts = transpiler.options`).
+        // — re-project from the now-mutated `transpiler.options`.
         transpiler.sync_resolver_opts();
         Ok(())
     }
@@ -1036,8 +1027,6 @@ impl CompletionStruct for JSBundleCompletionTask {
         &mut self,
         bump: &'a Arena,
     ) -> Result<&'a mut Transpiler<'a>, bun_core::Error> {
-        // Zig: `transpiler.* = try bun.Transpiler.init(alloc, &completion.log,
-        //        api.TransformOptions{ ... }, completion.env);`
         let config = &self.config;
         let opts = api::TransformOptions {
             define: if config.define.count() > 0 {
@@ -1061,13 +1050,9 @@ impl CompletionStruct for JSBundleCompletionTask {
             extension_order: Vec::new(),
             env_files: Vec::new(),
             conditions: config.conditions.keys().to_vec(),
-            // PORT NOTE: Zig read `transpiler.options.ignore_dce_annotations`
-            // off the *uninitialized* out-param (i.e. whatever the previous
-            // build left there). The Rust port has no prior `Transpiler` here;
-            // use the config value, which `configure_bundler` reapplies anyway.
+            // Use the config value, which `configure_bundler` reapplies anyway.
             ignore_dce_annotations: config.ignore_dce_annotations,
             drop: config.drop.keys().to_vec(),
-            // PORT NOTE: same uninitialized-read for `bunfig_path`; default empty.
             bunfig_path: Box::default(),
             jsx: Some(config.jsx.clone()),
             ..Default::default()
@@ -1081,8 +1066,8 @@ impl CompletionStruct for JSBundleCompletionTask {
         let t = Transpiler::init(bump, log, opts, Some(env))?;
         let transpiler: &'a mut Transpiler<'a> = bump.alloc(t);
 
-        // Post-init field wiring (the rest of Zig `configureBundler`).
-        // PORT NOTE: reborrow through a raw ptr so `&mut self` is usable
+        // Post-init field wiring.
+        // Reborrow through a raw ptr so `&mut self` is usable
         // again after handing `&'a mut Transpiler` (which is tied to `bump`,
         // not `self`) to the trait method.
         let tp: *mut Transpiler<'a> = transpiler;
@@ -1114,8 +1099,7 @@ impl CompletionStruct for JSBundleCompletionTask {
         // (`NonNull`) end-to-end; `ThreadPool::init` stores it as `*mut`.
         let worker_pool = NonNull::new(thread_pool);
 
-        // Zig passed the same `heap` by value (mimalloc handle struct copy);
-        // `Graph.heap` is now a borrow, so reuse the caller-owned `bump`.
+        // `Graph.heap` is a borrow, so reuse the caller-owned `bump`.
         let mut bv2 = BundleV2::init(transpiler, None, bump, event_loop, false, worker_pool, bump)?;
 
         bv2.plugins = self.plugins();
@@ -1127,7 +1111,7 @@ impl CompletionStruct for JSBundleCompletionTask {
 
         self.set_transpiler(&raw mut *bv2);
 
-        // Snapshot entry points as `&[&[u8]]` (Zig `keys()` is `[][]const u8`).
+        // Snapshot entry points as `&[&[u8]]`.
         let entry_points: Vec<&[u8]> = self
             .config
             .entry_points
@@ -1138,9 +1122,8 @@ impl CompletionStruct for JSBundleCompletionTask {
 
         let run = bv2.run_from_js_in_new_thread(&entry_points);
 
-        // Zig: `defer { ast_memory_allocator.pop(); this.deinitWithoutFreeingArena(); }`
-        // (the AST-allocator pop lives in `generate_in_new_thread`).
-        // `errdefer { source_maps.*_wait_group.wait(); }` — only on error path.
+        // The AST-allocator pop lives in `generate_in_new_thread`; the
+        // source-map wait-group waits run only on the error path.
         match run {
             Ok(build) => {
                 self.set_result(BundleV2Result::Value(build));
@@ -1156,5 +1139,3 @@ impl CompletionStruct for JSBundleCompletionTask {
         }
     }
 }
-
-// ported from: src/bundler_jsc/JSBundleCompletionTask.zig
diff --git a/src/runtime/api/lolhtml_jsc.rs b/src/runtime/api/lolhtml_jsc.rs
index 2be30bc5a54..c07bff82bbf 100644
--- a/src/runtime/api/lolhtml_jsc.rs
+++ b/src/runtime/api/lolhtml_jsc.rs
@@ -4,7 +4,7 @@ use bun_core::{String as BunString, strings};
 use bun_jsc::{JSGlobalObject, JSValue, JsResult, StringJsc as _};
 use bun_lolhtml_sys::HTMLString;
 
-/// `HTMLString.toString` — port of `lol_html.zig:HTMLString.toString`.
+/// `HTMLString.toString`.
 ///
 /// Lives here (not in `bun_lolhtml_sys`) because the `*_sys` crate is a leaf
 /// FFI crate with no `bun_string` dependency; pulling one in would invert the
@@ -35,11 +35,9 @@ pub(crate) fn html_string_to_string(this: HTMLString) -> BunString {
 }
 
 pub(crate) fn html_string_to_js(this: HTMLString, global: &JSGlobalObject) -> JsResult<JSValue> {
-    // Zig: `var str = this.toString(); defer str.deref();` — `bun_core::String`
-    // is `Copy` with NO `Drop`; `OwnedString` is the RAII wrapper that releases
+    // `bun_core::String` is `Copy` with NO `Drop`; `OwnedString` is the RAII
+    // wrapper that releases
     // the +1 ref returned by `html_string_to_string` on scope exit.
     let str = bun_core::OwnedString::new(html_string_to_string(this));
     str.to_js(global)
 }
-
-// ported from: src/runtime/api/lolhtml_jsc.zig
diff --git a/src/runtime/api/output_file_jsc.rs b/src/runtime/api/output_file_jsc.rs
index 59eb7ecd802..9fc9bcd790e 100644
--- a/src/runtime/api/output_file_jsc.rs
+++ b/src/runtime/api/output_file_jsc.rs
@@ -1,4 +1,4 @@
-//! `to_js`/`to_blob` bridges for `bundler/OutputFile.zig`. Exposed as an
+//! `to_js`/`to_blob` bridges for the bundler's `OutputFile`. Exposed as an
 //! extension trait so call sites stay `output.to_js(global)`.
 //!
 //! LAYERING: this file lives in `bun_runtime` (not `bun_bundler_jsc`) because
@@ -22,7 +22,7 @@ use crate::webcore::blob::store::StoreExt as _;
 use crate::webcore::blob::{SizeType as BlobSizeType, Store as BlobStore};
 
 /// Heap-dupe `path` into an owning `PathLike` so the resulting `Blob.Store`
-/// outlives the borrowed source. Mirrors Zig's `allocator.dupe(u8, path)`.
+/// outlives the borrowed source.
 #[inline]
 fn dupe_path_like(path: &[u8]) -> PathLike {
     PathLike::EncodedSlice(
@@ -80,9 +80,8 @@ impl SavedFile {
         .expect("unreachable");
 
         let blob = Blob::init_with_store(store, global_this);
-        // PORT NOTE: Zig overwrites `blob.content_type = mime.value` here;
-        // `init_with_store` already populated it from the store's `File`
-        // mime (which is the same value), so the overwrite is a no-op.
+        // `init_with_store` already populated `blob.content_type` from the
+        // store's `File` mime, so no separate assignment is needed.
         blob.size.set(byte_size as BlobSizeType);
         let ptr = Blob::new(blob);
         // SAFETY: `ptr` is a freshly heap-allocated `*mut Blob` from
@@ -109,10 +108,9 @@ impl OutputFileJsc for OutputFile {
             _ => {}
         }
 
-        // PORT NOTE: each Zig arm reassigns `this.value = .buffer{.{}}` after
-        // consuming the payload. Taking the value out up-front avoids the
-        // borrowck conflict between `&mut self.value` (match scrutinee) and
-        // `self.{hash,loader,...}` reads inside the arms.
+        // Taking the value out up-front avoids the borrowck conflict between
+        // `&mut self.value` (match scrutinee) and `self.{hash,loader,...}`
+        // reads inside the arms.
         let value = core::mem::replace(
             &mut self.value,
             OutputFileValue::Buffer {
@@ -273,5 +271,3 @@ impl OutputFileJsc for OutputFile {
         }
     }
 }
-
-// ported from: src/bundler_jsc/output_file_jsc.zig
diff --git a/src/runtime/api/standalone_graph_jsc.rs b/src/runtime/api/standalone_graph_jsc.rs
index b2859394ce9..df233aad5ab 100644
--- a/src/runtime/api/standalone_graph_jsc.rs
+++ b/src/runtime/api/standalone_graph_jsc.rs
@@ -8,7 +8,7 @@ use bun_core::{self as bstring, strings};
 use bun_http::MimeType;
 use bun_jsc::JSGlobalObject;
 
-// PORT NOTE: `StandaloneModuleGraph` is the inner *module* (so
+// `StandaloneModuleGraph` here is the inner *module* (so
 // `StandaloneModuleGraph::BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX` resolves);
 // `File` is re-exported at the crate root.
 use crate::webcore::Blob;
@@ -24,7 +24,6 @@ pub(crate) trait FileJsc {
 impl FileJsc for File {
     fn file_blob(&mut self, global: &JSGlobalObject) -> &mut Blob {
         if self.cached_blob.is_none() {
-            // Spec: `Store.init(@constCast(this.contents), bun.default_allocator)`.
             // `contents` is a `'static` slice into the embedded executable
             // section — borrow it directly (no copy) and hand it to a `Bytes`
             // store with the default allocator. The leaked extra `ref_()` below
@@ -32,7 +31,7 @@ impl FileJsc for File {
             // the (otherwise UB) free of a static slice is unreachable.
             let contents = self.contents.as_bytes();
             // SAFETY: `contents` is `'static` and never freed (see above);
-            // `@constCast` mirrors Zig — Blob consumers only read via
+            // the const-cast is sound because Blob consumers only read via
             // `shared_view()`.
             let bytes = unsafe {
                 Bytes::from_raw_parts(
@@ -42,7 +41,7 @@ impl FileJsc for File {
                     bun_alloc::basic::C_ALLOCATOR,
                 )
             };
-            // PORT NOTE: cannot use `..Default::default()` — `Store: Drop`
+            // Cannot use `..Default::default()` — `Store: Drop`
             // forbids partial moves out of the temporary default.
             let store = StoreRef::from(Store::new(Store {
                 data: Data::Bytes(bytes),
@@ -54,8 +53,8 @@ impl FileJsc for File {
             store.ref_();
 
             // Hold the raw pointer so we can keep mutating the store after
-            // `init_with_store` consumes the `StoreRef` (Zig freely aliases the
-            // `*Store` across both). The store outlives this fn (leaked above).
+            // `init_with_store` consumes the `StoreRef`. The store outlives
+            // this fn (leaked above).
             let store_ptr = store.as_ptr();
 
             let b = Blob::init_with_store(store, global);
@@ -92,8 +91,7 @@ impl FileJsc for File {
                 b.name.set(bstring::String::clone_utf8(self.name));
             }
 
-            // Zig: `Blob{...}.new()` — heap-promote and stash the raw pointer.
-            // The standalone graph (and thus this Blob) lives for the process.
+            // Heap-promote and stash the raw pointer. The standalone graph (and thus this Blob) lives for the process.
             // `cached_blob` is typed against the lower crate's opaque `Blob`
             // newtype (it cannot name `webcore::Blob` without a dep cycle), so
             // erase via `.cast()` here and back below.
@@ -110,5 +108,3 @@ impl FileJsc for File {
         unsafe { self.cached_blob.unwrap().cast::<Blob>().as_mut() }
     }
 }
-
-// ported from: src/runtime/api/standalone_graph_jsc.zig
diff --git a/src/runtime/bake/BakeGlobalObject.cpp b/src/runtime/bake/BakeGlobalObject.cpp
index ec57b163264..b86cfa16c34 100644
--- a/src/runtime/bake/BakeGlobalObject.cpp
+++ b/src/runtime/bake/BakeGlobalObject.cpp
@@ -50,7 +50,6 @@ bakeModuleLoaderImportModule(JSC::JSGlobalObject* global,
     }
 
     // TODO: make static cast instead of jscast
-    // Use Zig::GlobalObject's function
     return uncheckedDowncast<Zig::GlobalObject>(global)->moduleLoaderImportModule(global, moduleLoader, moduleNameValue, WTF::move(parameters), sourceOrigin, false);
 }
 
@@ -88,7 +87,6 @@ JSC::Identifier bakeModuleLoaderResolve(JSC::JSGlobalObject* jsGlobal,
         }
     }
 
-    // Use Zig::GlobalObject's function
     return Zig::GlobalObject::moduleLoaderResolve(jsGlobal, loader, key, referrer, WTF::move(origin), useImportMap);
 }
 
@@ -148,7 +146,7 @@ JSC::JSPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
             }
 
             // We unconditionally prefix the key with "bake:" inside
-            // BakeProdResolve in production.zig.
+            // BakeProdResolve.
             //
             // But if someone does: `await import(resolve(import.meta.dir, "nav.ts"))`
             // we don't actually want to load it from the Bake production module
diff --git a/src/runtime/bake/DevServer.rs b/src/runtime/bake/DevServer.rs
index ce1504f82b3..930ca31e707 100644
--- a/src/runtime/bake/DevServer.rs
+++ b/src/runtime/bake/DevServer.rs
@@ -9,7 +9,7 @@
 //! Theorized and designed over 2 years out of pure love —— paper clover <3
 //! For questions about its core philosophy, email `devserver@paperclover.net`
 
-#![allow(unexpected_cfgs)] // `feature = "bake_debugging_features"` mirrors Zig `bun.FeatureFlags.bake_debugging_features`; not yet a declared cargo feature.
+#![allow(unexpected_cfgs)] // `feature = "bake_debugging_features"` is not yet a declared cargo feature.
 
 use ::core::ffi::c_void;
 use bun_bundler::mal_prelude::*;
@@ -80,15 +80,14 @@ pub(super) use crate::bake::dev_server::memory_cost_body::MemoryCost;
 
 impl DevServer {
     /// `DevServer.memoryCost` — sums the per-category breakdown from
-    /// `memory_cost_detailed`. Body lives in `dev_server::memory_cost_body`
-    /// (mirrors Zig `pub const memoryCost = MemoryCost.memoryCost;`).
+    /// `memory_cost_detailed`. Body lives in `dev_server::memory_cost_body`.
     #[inline]
     pub fn memory_cost(&self) -> usize {
         crate::bake::dev_server::memory_cost_body::memory_cost(self)
     }
 
     /// `DevServer.memoryCostDetailed` — body lives in
-    /// `dev_server::memory_cost_body` (free fn ported from `memory_cost.zig`).
+    /// `dev_server::memory_cost_body`.
     #[inline]
     pub fn memory_cost_detailed(&self) -> MemoryCost {
         crate::bake::dev_server::memory_cost_body::memory_cost_detailed(self)
@@ -96,7 +95,7 @@ impl DevServer {
 
     /// Recover `&VirtualMachine` from the JSC_BORROW `vm` back-reference.
     /// Safe `Deref` via [`BackRef`](bun_ptr::BackRef): vm is valid for
-    /// DevServer's entire lifetime (DevServer.zig:315).
+    /// DevServer's entire lifetime.
     #[inline]
     pub(crate) fn vm(&self) -> &VirtualMachine {
         self.vm.get()
@@ -184,15 +183,13 @@ pub struct Options<'a> {
     pub dump_state_on_crash: Option<bool>,
 }
 
-// PORT NOTE: Zig `Options` only had field-level defaults for `dump_sources`
-// (`if (Environment.isDebug) ".bake-debug" else null`) and `dump_state_on_crash`
-// (`null`). The remaining fields (`arena`, `root`, `vm`, `framework`,
+// Note: the fields (`arena`, `root`, `vm`, `framework`,
 // `bundler_options`, `broadcast_console_log_from_browser_to_server`) are
 // required with no sensible zero value, so `Default` is intentionally NOT
 // implemented. Callers construct `Options` via struct-literal at the call site
 // (see `bake_body.rs::UserOptions::into_dev_server_options`).
 impl<'a> Options<'a> {
-    /// Zig field default: `if (Environment.isDebug) ".bake-debug" else null`.
+    /// Debug builds dump bundled sources to `.bake-debug` by default.
     pub const DEFAULT_DUMP_SOURCES: Option<&'static [u8]> = if cfg!(debug_assertions) {
         Some(b".bake-debug")
     } else {
@@ -249,7 +246,7 @@ pub enum TestingBatchEvents {
 /// while in-flight. All allocations held by `.bv2.graph.heap`'s arena
 pub struct CurrentBundle {
     /// OWNED (LIFETIMES.tsv): `BundleV2.init()` → `deinitWithoutFreeingArena()`.
-    /// PORT NOTE: `'static` is a stand-in for the DevServer-self lifetime —
+    /// Note: `'static` is a stand-in for the DevServer-self lifetime —
     /// `BundleV2<'a>` borrows the three `Transpiler<'_>` fields stored inline
     /// in `DevServer`, so the true bound is the `Box<DevServer>` allocation
     /// (stable address, never moved post-init). Threading a real `'dev` would
@@ -296,7 +293,7 @@ pub struct NextBundle {
     pub promise: DeferredPromise,
 }
 
-// PORT NOTE: this is the **canonical** `DevServer` struct. `dev_server/mod.rs`
+// Note: this is the **canonical** `DevServer` struct. `dev_server/mod.rs`
 // re-exports it (`pub use super::dev_server_body::DevServer`) so the
 // `container_of` submodules (`incremental_graph`, `assets`, …) and the
 // 4.8 kL of method bodies in this file all name the same type. The
@@ -323,7 +320,7 @@ pub struct DevServer {
     /// lifetime-generic — it is `Box`-owned by `ServerInstance` which outlives
     /// the VM anyway. The back-reference invariant (pointee outlives holder)
     /// is the JSC_BORROW guarantee: vm is valid for DevServer's entire
-    /// lifetime (DevServer.zig:315).
+    /// lifetime.
     pub vm: bun_ptr::BackRef<VirtualMachine>,
     /// May be `None` if not attached to an HTTP server yet. When no server is
     /// available, functions taking in requests and responses are unavailable.
@@ -366,10 +363,7 @@ pub struct DevServer {
     /// All bundling failures are stored until a file is saved and rebuilt.
     /// They are stored in the wire format the HMR runtime expects so that
     /// serialization only happens once.
-    /// Zig: `AutoArrayHashMapUnmanaged(SerializedFailure, void,
-    /// SerializedFailure.ArrayHashContextViaOwner, false)` — keyed by
-    /// `failure.owner`. Port stores `OwnerPacked → SerializedFailure` so the
-    /// custom context is unnecessary.
+    /// Keyed by `failure.owner`, stored as `OwnerPacked → SerializedFailure`.
     pub bundling_failures: ArrayHashMap<serialized_failure::OwnerPacked, SerializedFailure>,
     /// When set, nothing is ever bundled for the server-side,
     /// and DevSever acts purely as a frontend bundler.
@@ -385,9 +379,8 @@ pub struct DevServer {
     pub server_register_update_callback: jsc::StrongOptional,
 
     // Watching
-    // PORT NOTE: Zig stores `*bun.Watcher` and calls `deinit(true)` in
-    // `DevServer.deinit`, which *transfers* ownership to the watcher thread
-    // (the thread frees the allocation in `threadMain`). Auto-dropping a
+    // Note: the watcher thread owns this allocation at shutdown (it frees it
+    // in `thread_main` once `running` flips false). Auto-dropping a
     // `Box<Watcher>` here would free the heap block while the watcher thread
     // is still blocked in `GetQueuedCompletionStatus`/`read()` holding a
     // `*mut Watcher` into it (and on Windows the kernel still has a pending
@@ -397,7 +390,6 @@ pub struct DevServer {
     pub bun_watcher: ::core::mem::ManuallyDrop<Box<Watcher>>,
     pub directory_watchers: DirectoryWatchStore,
     pub watcher_atomics: WatcherAtomics,
-    /// See doc comment in Zig source.
     pub testing_batch_events: TestingBatchEvents,
 
     /// Number of bundles that have been executed. This is currently not read, but
@@ -410,7 +402,7 @@ pub struct DevServer {
     pub bundler_framework_views: Vec<*mut bun_bundler::bake_types::Framework>,
     pub bundler_options: bake::SplitBundlerOptions,
     // Each logical graph gets its own bundler configuration.
-    // PORT NOTE: `'static` is the DevServer-self lifetime stand-in (see
+    // Note: `'static` is the DevServer-self lifetime stand-in (see
     // `CurrentBundle.bv2`). `Transpiler<'a>` borrows the global
     // `Fs::FileSystem` singleton + `dot_env::Loader`, both of which outlive
     // the server.
@@ -449,7 +441,6 @@ pub struct DevServer {
     pub memory_visualizer_timer: EventLoopTimer,
 
     pub has_pre_crash_handler: bool,
-    /// See doc comment in Zig source.
     pub assume_perfect_incremental_bundling: bool,
 
     /// If true, console logs from the browser will be echoed to the server console.
@@ -498,7 +489,7 @@ impl DeferredPromise {
 
 /// DevServer is stored on the heap, storing its allocator.
 pub fn init(options: Options) -> JsResult<Box<DevServer>> {
-    // PORT NOTE: `Features.dev_server +|= 1` (saturating add). AtomicUsize has
+    // Note: `Features.dev_server +|= 1` (saturating add). AtomicUsize has
     // no `saturating_inc`; on a 64-bit counter overflow is unreachable, so a
     // relaxed `fetch_add(1)` is equivalent in practice.
     bun_core::analytics::Features::DEV_SERVER.fetch_add(1, ::core::sync::atomic::Ordering::Relaxed);
@@ -525,13 +516,13 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
         .map(|sc| sc.separate_ssr_graph)
         .unwrap_or(false);
 
-    // PORT NOTE: Zig used `bun.new(DevServer, .{ ... = undefined })` then assigned
-    // `server_transpiler` / `client_transpiler` / `ssr_transpiler` / `bun_watcher` /
-    // `router` / `watcher_atomics` after the heap address was stable. Rust forbids
-    // partial struct literals and `mem::zeroed()` here is UB (`Box<Watcher>` is
-    // `NonNull`-backed; `Transpiler<'a>` carries `&'a Arena`). The faithful port is
-    // `Box::new_uninit()` + per-field `addr_of_mut!().write()`, leaving the
-    // `undefined` fields uninitialized until their real values are computed against
+    // Note: `server_transpiler` / `client_transpiler` / `ssr_transpiler` /
+    // `bun_watcher` / `router` / `watcher_atomics` must be assigned after the
+    // heap address is stable. Rust forbids partial struct literals and
+    // `mem::zeroed()` here is UB (`Box<Watcher>` is `NonNull`-backed;
+    // `Transpiler<'a>` carries `&'a Arena`), so use
+    // `Box::new_uninit()` + per-field `addr_of_mut!().write()`, leaving those
+    // fields uninitialized until their real values are computed against
     // the stable `*mut DevServer`, then `assume_init()` once every field is written.
     use ::core::mem::MaybeUninit;
     use ::core::ptr::addr_of_mut;
@@ -704,9 +695,9 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
     // `bake_body.rs`), so the previous (uninitialized) bytes are never dropped.
     // `framework`/`log`/`bundler_options` were written above; reborrowing each
     // individually via `addr_of_mut!` is sound because no `&mut DevServer` exists.
-    // PORT NOTE: `Transpiler<'static>` erases the arena lifetime — `options.arena`
+    // Note: `Transpiler<'static>` erases the arena lifetime — `options.arena`
     // is the `UserOptions.arena` which is moved into / outlives the `DevServer`
-    // box (Zig had no lifetime). Widen `'a → 'static` here once.
+    // box. Widen `'a → 'static` here once.
     // SAFETY: `options.arena` outlives every `Transpiler` field it backs (see
     // `Options::arena` doc — "must live until DevServer drops").
     let arena: &'static Arena = unsafe { bun_ptr::detach_lifetime_ref(options.arena) };
@@ -755,9 +746,9 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
                 Err(err) => return Err(global.throw_error(err, generic_action)),
             }
         } else {
-            // PORT NOTE: Zig left `ssr_transpiler` `undefined` when
-            // `!separate_ssr_graph` and never read it. Rust must still write a
-            // valid value before `assume_init()`. Bitwise-alias the server
+            // Note: when `!separate_ssr_graph`, `ssr_transpiler` is never
+            // read, but a valid value must still be written before
+            // `assume_init()`. Bitwise-alias the server
             // transpiler. This is sound only because `Drop for DevServer` gates
             // `ssr_transpiler.assume_init_drop()` behind the same
             // `separate_ssr_graph` check (see Drop impl): in the `!separate`
@@ -785,9 +776,8 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
     let mut dev: Box<DevServer> = unsafe { dev_uninit.assume_init() };
     let dev_ptr: *mut DevServer = &raw mut *dev;
 
-    // PORT NOTE: Zig asserted `*.owner() == dev` (intrusive parent-ptr derived
-    // via `container_of`). The Rust port stores these by value; `owner()`
-    // is provided on `IncrementalGraph` via `offset_of!` so the invariant is
+    // Note: the graphs are stored by value; `owner()` is provided on
+    // `IncrementalGraph` via `offset_of!` so the parent-pointer invariant is
     // structural. Retain the field touches so the addresses are stable for
     // `container_of` consumers below.
     let _ = (
@@ -822,7 +812,7 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
     debug_assert!(dev.server_transpiler().resolver.opts.target != bun_ast::Target::Browser);
     debug_assert!(dev.client_transpiler().resolver.opts.target == bun_ast::Target::Browser);
 
-    // PORT NOTE: reborrow `framework` and the two resolvers via `dev_ptr` so
+    // Note: reborrow `framework` and the two resolvers via `dev_ptr` so
     // borrowck doesn't see three overlapping `&mut dev`.
     // SAFETY: `dev_ptr` is the live `Box<DevServer>` heap address; the three
     // fields are disjoint.
@@ -845,12 +835,10 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
         )?));
     }
 
-    // Spec DevServer.zig:425 — Zig stores `transpiler.options.framework` as a
-    // `?*bake.Framework` aliasing `dev.framework`, so the post-`resolve`
-    // assignment retroactively gives every transpiler the resolved
-    // `server_runtime_import` / `react_fast_refresh.import_source`. The Rust
-    // port arena-snapshots that projection inside `init_transpiler`, breaking
-    // the alias; re-project after resolve so parser-generated imports (e.g.
+    // `init_transpiler` arena-snapshots the framework projection, so the
+    // transpilers do not see the resolved
+    // `server_runtime_import` / `react_fast_refresh.import_source`;
+    // re-project after resolve so parser-generated imports (e.g.
     // `serverRuntimeImportSource` in `wrap_exports_for_client_reference`) see
     // absolute paths instead of the user's relative `"./framework/server.ts"`.
     {
@@ -879,7 +867,7 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
                 Ok(s) => s,
                 Err(e) => Output::panic(format_args!("unhandled {}", e)),
             };
-            // PORT NOTE: `sys::Stat` is `libc::stat` on POSIX / `uv_stat_t` on
+            // Note: `sys::Stat` is `libc::stat` on POSIX / `uv_stat_t` on
             // Windows (where mtime is `mtim.sec`). Debug-only cache-bust key.
             #[cfg(not(windows))]
             bun_core::write_any_to_hasher(&mut h, stat.st_mtime as i64);
@@ -945,8 +933,8 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
         {
             h.update(k);
             h.update(&[0]);
-            // Zig: `@intFromEnum(v)` for the active tag, then `switch (v) { inline else => |data| data }`
-            // for the payload. `bun_bundler::bake_types::BuiltInModule` has no `.tag()`/`.data_slice()`;
+            // Hash the active tag, then the payload.
+            // `bun_bundler::bake_types::BuiltInModule` has no `.tag()`/`.data_slice()`;
             // shim locally with a match (upstream type — cannot add inherent methods).
             let (tag, data): (u8, &[u8]) = match v {
                 bun_bundler::bake_types::BuiltInModule::Import(d) => (0, &d[..]),
@@ -966,11 +954,11 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
     // Add react fast refresh if needed. This is the first file on the client side,
     // as it will be referred to by index.
     if let Some(rfr) = &dev.framework.react_fast_refresh {
-        // Spec (DevServer.zig:511): `bun.assert` always evaluates its argument;
-        // `debug_assert!` does not in release. Hoist the side-effecting `insert_stale`
+        // `debug_assert!` does not evaluate its argument in release. Hoist
+        // the side-effecting `insert_stale`
         // out so the refresh runtime is registered at index 0 in all builds.
         let idx = dev.client_graph.insert_stale(&rfr.import_source, false)?;
-        debug_assert!(idx == incremental_graph::FileIndex::<{ bake::Side::Client }>::init(0)); // Zig: react_refresh_index = .init(0)
+        debug_assert!(idx == incremental_graph::FileIndex::<{ bake::Side::Client }>::init(0));
     }
 
     if !dev.frontend_only {
@@ -982,7 +970,7 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
         let mut types: Vec<framework_router::Type> =
             Vec::with_capacity(dev.framework.file_system_router_types.len());
 
-        // PORT NOTE: the loop body mutates `server_transpiler.resolver`,
+        // Note: the loop body mutates `server_transpiler.resolver`,
         // `server_graph`, `client_graph`, and `route_lookup` while iterating
         // `framework.file_system_router_types` by shared ref. All five fields
         // are disjoint; reborrow them through `dev_ptr` so the shared
@@ -1078,12 +1066,66 @@ pub fn init(options: Options) -> JsResult<Box<DevServer>> {
 impl Drop for DevServer {
     fn drop(&mut self) {
         debug_log!("deinit");
-        // Zig used `+|= 1` (saturating add); for a usize test counter, wrapping
-        // at usize::MAX is unreachable in practice, so a plain fetch_add is fine.
+        // For a usize test counter, wrapping at usize::MAX is unreachable in
+        // practice, so a plain fetch_add is fine.
         DEV_SERVER_DEINIT_COUNT_FOR_TESTING.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 
-        // TODO(port): Zig used `useAllFields(DevServer, .{...})` to ensure every field
-        // was visited. Only side-effecty cleanup is kept here.
+        // Exhaustiveness check: destructuring without `..` fails to compile when a field is added,
+        // removed, or renamed, forcing this Drop to be reviewed. All bindings
+        // are `_` so nothing is moved; cleanup not done explicitly below
+        // happens via the implicit field drops after this body returns.
+        {
+            let DevServer {
+                magic: _,
+                root: _,
+                inspector_server_id: _,
+                configuration_hash_key: _,
+                vm: _,
+                server: _,
+                router: _,
+                route_bundles: _,
+                graph_safety_lock: _,
+                client_graph: _,
+                server_graph: _,
+                barrel_files_with_deferrals: _,
+                barrel_needed_exports: _,
+                incremental_result: _,
+                route_lookup: _,
+                html_router: _,
+                assets: _,
+                source_maps: _,
+                bundling_failures: _,
+                frontend_only: _,
+                has_tailwind_plugin_hack: _,
+                server_fetch_function_callback: _,
+                server_register_update_callback: _,
+                bun_watcher: _,
+                directory_watchers: _,
+                watcher_atomics: _,
+                testing_batch_events: _,
+                generation: _,
+                bundles_since_last_error: _,
+                framework: _,
+                bundler_framework_views: _,
+                bundler_options: _,
+                server_transpiler: _,
+                client_transpiler: _,
+                ssr_transpiler: _,
+                log: _,
+                plugin_state: _,
+                current_bundle: _,
+                next_bundle: _,
+                deferred_request_pool: _,
+                active_websocket_connections: _,
+                dump_dir: _,
+                emit_incremental_visualizer_events: _,
+                emit_memory_visualizer_events: _,
+                memory_visualizer_timer: _,
+                has_pre_crash_handler: _,
+                assume_perfect_incremental_bundling: _,
+                broadcast_console_log_from_browser_to_server: _,
+            } = &*self;
+        }
 
         // WebSockets should be deinitialized before other parts.
         // `websocket.close()` synchronously dispatches `HmrSocket.onClose`,
@@ -1109,8 +1151,7 @@ impl Drop for DevServer {
             self.timer_heap().remove(timer_ptr);
         }
         self.graph_safety_lock.lock();
-        // Zig: `.bun_watcher = dev.bun_watcher.deinit(true),` — hand ownership of
-        // the heap allocation to the watcher thread (which frees it in
+        // Hand ownership of the heap allocation to the watcher thread (which frees it in
         // `thread_main` once `running` flips false). Auto-dropping the `Box`
         // here would free the allocation out from under the still-running
         // thread; on Windows the kernel additionally retains a pending
@@ -1133,9 +1174,7 @@ impl Drop for DevServer {
             bun_crash_handler::remove_pre_crash_handler(std::ptr::from_mut(self).cast::<c_void>());
         }
 
-        // PORT NOTE: Zig looped `failure.deinit()` then `clearAndFree`. The
-        // map's `Drop` runs `SerializedFailure::drop` for each value, so the
-        // explicit loop is folded into field drop.
+        // The map's `Drop` runs `SerializedFailure::drop` for each value.
 
         if self.current_bundle.is_some() {
             debug_assert!(false); // impossible to de-initialize this state correctly.
@@ -1217,9 +1256,8 @@ impl Drop for DevServer {
 }
 
 impl DevServer {
-    /// Zig threaded a borrowed debug allocator handle through DevServer; in
-    /// the Rust port everything is `Box`/`Vec` on the global mimalloc, so this
-    /// just returns the default `StdAllocator`. Kept for the few call sites
+    /// Everything is `Box`/`Vec` on the global mimalloc, so this just
+    /// returns the default `StdAllocator`. Kept for the few call sites
     /// that still want a `StdAllocator` handle.
     #[inline]
     pub fn allocator(&self) -> bun_alloc::StdAllocator {
@@ -1287,10 +1325,8 @@ impl DevServer {
 
     /// Deferred one tick so that the server can be up faster
     fn scan_initial_routes(&mut self) -> Result<(), bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — Zig passed `dev` as the
-        // `InsertionContext` while also borrowing `&mut dev.router` and
-        // `&mut dev.server_transpiler.resolver`. Reborrow each via the raw
-        // self-ptr (the three are disjoint fields of the heap-stable `*self`).
+        // Reborrow `self`, `self.router`, and `self.server_transpiler.resolver`
+        // via the raw self-ptr (the three are disjoint fields of the heap-stable `*self`).
         let self_ptr = std::ptr::from_mut::<Self>(self);
         // SAFETY: `router`, `server_transpiler.resolver`, and the
         // `InsertionHandler` callbacks (touch `server_graph`/`route_lookup`)
@@ -1318,10 +1354,8 @@ impl DevServer {
         let app = unsafe { &mut *server.app.unwrap() };
         let dev = std::ptr::from_mut::<Self>(self).cast::<c_void>();
 
-        // PORT NOTE: Zig's `wrapGenericRequestHandler(fn, is_ssl)` produced a
-        // monomorphized `extern fn(*DevServer, *Response, *Request)` per
-        // handler. The Rust equivalent is the ZST-fn-item trampoline pattern
-        // used by `server::server_body::AppRouteExt`: a generic `extern "C"`
+        // The ZST-fn-item trampoline pattern used by
+        // `server::server_body::AppRouteExt`: a generic `extern "C"`
         // shim parameterized on the handler type `H` (which is zero-sized for
         // a fn-item), so each `tramp::<H, SSL>` lowers to a distinct C
         // function pointer with the handler baked in.
@@ -1390,9 +1424,8 @@ impl DevServer {
     }
 }
 
-/// Handler dispatch for `dev_route_tramp`. Zig used a comptime fn-ptr param to
-/// monomorphize one `extern "C"` trampoline per handler; Rust can't take a fn
-/// pointer as a const generic, so use a `ConstParamTy` enum instead and
+/// Handler dispatch for `dev_route_tramp`. A fn pointer cannot be a const
+/// generic, so use a `ConstParamTy` enum instead and
 /// `match` inside the trampoline (the optimizer folds the constant `match`).
 #[derive(Copy, Clone, Eq, PartialEq, ::core::marker::ConstParamTy)]
 pub(super) enum DevHandlerId {
@@ -1597,17 +1630,16 @@ fn hmr_socket_behavior<const SSL: bool>() -> bun_uws_sys::WebSocketBehavior {
 
 // `WebSocketBehavior.Wrap(ServerType, Type, ssl)` requires `Type` (= `HmrSocket`)
 // to be a `WebSocketHandler` and `ServerType` (= `DevServer`) to be a
-// `WebSocketUpgradeServer<SSL>`. The Zig used `@hasDecl` duck-typing; in Rust
-// we wire the trait explicitly and forward to the inherent method bodies in
+// `WebSocketUpgradeServer<SSL>`. The trait is wired explicitly and forward to the inherent method bodies in
 // `dev_server::hmr_socket_body`.
 impl bun_uws_sys::web_socket::WebSocketHandler for HmrSocket {
-    // Zig HmrSocket has no `onDrain`/`onPing`/`onPong` decls — `Wrap.apply`
-    // leaves those C callbacks `null` when `HAS_ON_* == false`.
+    // `Wrap.apply` leaves the drain/ping/pong C callbacks `null` when
+    // `HAS_ON_* == false`.
     const HAS_ON_DRAIN: bool = false;
     const HAS_ON_PING: bool = false;
     const HAS_ON_PONG: bool = false;
 
-    // PORT NOTE (noalias re-entrancy): the trait now hands the handler a raw
+    // Note (noalias re-entrancy): the trait now hands the handler a raw
     // `*mut Self` (see `WebSocketHandler` doc). `HmrSocket::on_close` already
     // takes `*mut Self`; `on_open`/`on_message` still take `&mut self` so
     // re-derive a fresh `&mut *this` here (not carried in from a `noalias`
@@ -1672,7 +1704,7 @@ impl<const SSL: bool> bun_uws_sys::web_socket::WebSocketUpgradeServer<SSL> for D
 }
 
 // `ResponseLike` for the concrete `Response<SSL>` so `HmrSocket::new` can be
-// called from `on_websocket_upgrade` (Zig: `res: anytype`).
+// called from `on_websocket_upgrade`.
 impl<const SSL: bool> ResponseLike for bun_uws_sys::response::Response<SSL> {
     fn write_status(&mut self, status: &[u8]) {
         bun_uws_sys::response::Response::<SSL>::write_status(self, status)
@@ -1759,7 +1791,7 @@ fn on_js_request(dev: &mut DevServer, req: &mut Request, resp: AnyResponse) {
 
     if is_map {
         let source_id = source_map_store::SourceId(id);
-        // PORT NOTE: `render_json` needs `&mut DevServer` while `entry` borrows
+        // Note: `render_json` needs `&mut DevServer` while `entry` borrows
         // `dev.source_maps.entries[_]`. The entry is read-only (`&self`) and
         // `render_json` does not touch `source_maps.entries`, so erase the
         // entry borrow to a raw pointer and reborrow `dev` for the call.
@@ -1771,7 +1803,6 @@ fn on_js_request(dev: &mut DevServer, req: &mut Request, resp: AnyResponse) {
             return not_found(resp);
         };
         let entry_ptr: *const source_map_store::Entry = &raw const *entry;
-        // PERF(port): was ArenaAllocator scratch
         // SAFETY: `entry_ptr` points into `dev.source_maps.entries` storage,
         // which is not reallocated by `render_json`.
         let json_bytes =
@@ -1847,7 +1878,6 @@ fn on_src_request(_dev: &mut DevServer, req: &mut Request, resp: AnyResponse) {
     }
 
     // TODO: better editor detection. on chloe's dev env, this opens apple terminal + vim
-    // This is already done in Next.js. we have to port this to Zig so we can use.
     resp.write_status(b"501 Not Implemented");
     resp.end(b"TODO", false);
 }
@@ -1877,8 +1907,8 @@ fn on_memory_visualizer_corked(resp: AnyResponse) {
 }
 
 struct RequestEnsureRouteBundledCtx {
-    // PORT NOTE: erased to raw pointer — the Zig code freely re-borrowed `dev`
-    // across the ctx; a `&mut DevServer` field would alias the caller's borrow.
+    // Note: erased to raw pointer — a `&mut DevServer` field would alias the
+    // caller's borrow.
     dev: *mut DevServer,
     req: ReqOrSaved,
     resp: AnyResponse,
@@ -1899,7 +1929,7 @@ impl RequestEnsureRouteBundledCtx {
     }
 
     fn on_defer(&mut self, bundle_field: BundleQueueType) -> JsResult<()> {
-        // PORT NOTE: reshaped for borrowck — captured args before re-borrowing dev
+        // Note: reshaped for borrowck — captured args before re-borrowing dev
         let route_bundle_index = self.route_bundle_index;
         let kind = self.kind;
         let req = ::core::mem::replace(&mut self.req, ReqOrSaved::Aborted);
@@ -1931,8 +1961,7 @@ impl RequestEnsureRouteBundledCtx {
             deferred_request::HandlerKind::ServerHandler => {
                 let route_bundle_index = self.route_bundle_index;
                 let resp = self.resp;
-                // PORT NOTE: Zig copied `SavedRequest` by value (POD); Rust's
-                // `Strong` field is move-only. Take ownership out of `self.req`
+                // The `Strong` field is move-only. Take ownership out of `self.req`
                 // (it is consumed by `on_framework_request_with_bundle`).
                 let req = match ::core::mem::replace(&mut self.req, ReqOrSaved::Aborted) {
                     ReqOrSaved::Req(r) => {
@@ -1957,8 +1986,7 @@ impl RequestEnsureRouteBundledCtx {
     }
 
     fn on_failure(&mut self) -> JsResult<()> {
-        // PORT NOTE: Zig held two `*DevServer`-derived borrows at once
-        // (route_bundle slot + send_serialized_failures). Reborrow via raw
+        // Reborrow via raw
         // pointer so the failure slice and the `&mut DevServer` don't alias.
         let route_bundle_index = self.route_bundle_index;
         let failure = std::ptr::from_ref::<SerializedFailure>(
@@ -2115,7 +2143,6 @@ fn ensure_route_is_bundled<Ctx: EnsureRouteCtx>(
                 }
 
                 // Prepare a bundle with just this route.
-                // PERF(port): was stack-fallback alloc
                 let mut entry_points = EntryPointList::empty();
                 dev.append_route_entry_points_if_not_stale(&mut entry_points, route_bundle_index)?;
 
@@ -2250,7 +2277,7 @@ impl DevServer {
             weakly_referenced_by_requestcontext: false,
             handler: match kind {
                 deferred_request::HandlerKind::BundledHtmlPage => 'brk: {
-                    // PORT NOTE: `on_aborted<U: 'static>` rejects `DeferredRequest`;
+                    // Note: `on_aborted<U: 'static>` rejects `DeferredRequest`;
                     // erase to `c_void` and cast back inside the trampoline.
                     resp.on_aborted(
                         |p: *mut c_void, r: AnyResponse| {
@@ -2280,7 +2307,7 @@ impl DevServer {
                                     Some(method),
                                 )? {
                                 Some(saved) => saved,
-                                // Zig: `catch return` — abort the deferral on failure.
+                                // Abort the deferral on failure.
                                 // `deferred_slot` drops here, releasing the
                                 // still-uninitialized slot without `drop_in_place`.
                                 None => return Ok(()),
@@ -2345,14 +2372,12 @@ fn check_route_failures(
     route_bundle_index: route_bundle::Index,
     resp: DevResponse,
 ) -> Result<CheckResult, bun_core::Error> {
-    // PERF(port): was stack-fallback (65536)
     let mut gts = dev.init_graph_trace_state(0)?;
-    // PORT NOTE: erase to a raw pointer so the deferred cleanup only fires on
-    // scope exit when no other borrow of `dev` is live (Zig `defer` had no
-    // aliasing check).
+    // Note: erase to a raw pointer so the deferred cleanup only fires on
+    // scope exit when no other borrow of `dev` is live.
     let dev_ptr = std::ptr::from_mut::<DevServer>(dev);
     scopeguard::defer! {
-        // SAFETY: see PORT NOTE above.
+        // SAFETY: see Note above.
         unsafe { (*dev_ptr).incremental_result.failures_added.clear() }
     };
     let _lock_guard = dev.graph_safety_lock.guard();
@@ -2409,7 +2434,7 @@ impl DevServer {
         let client_file_names = self.client_graph.bundled_files.keys();
 
         // Build a list of all files that have not yet been bundled.
-        // PORT NOTE: split borrow — `route_bundle_ptr`/`type_ptr` are `&mut self`;
+        // Note: split borrow — `route_bundle_ptr`/`type_ptr` are `&mut self`;
         // index `route_bundles`/`types` immutably so the SoA key slices above stay live.
         match &self.route_bundles[rbi.get() as usize].data {
             route_bundle::Data::Framework(bundle) => {
@@ -2467,7 +2492,6 @@ impl DevServer {
     }
 }
 
-// TODO(port): move to <area>_sys
 // C++ side defines `extern "C" SYSV_ABI` (BakeAdditionsToGlobalObject.cpp).
 bun_jsc::jsc_abi_extern! {
     safe fn Bake__getEnsureAsyncLocalStorageInstanceJSFunction(global: &JSGlobalObject) -> JSValue;
@@ -2487,9 +2511,8 @@ struct FrameworkRequestArgs {
 }
 
 impl DevServer {
-    /// PORT NOTE: raw-pointer receiver. Zig freely held aliasing `*DevServer` /
-    /// `*RouteBundle` / `*Router.Type` heap pointers across this body; the
-    /// previous Rust port bound long-lived `&mut RouteBundle` / `&mut Type` from
+    /// Note: raw-pointer receiver. A previous version of this body bound
+    /// long-lived `&mut RouteBundle` / `&mut Type` from
     /// `&mut *self_ptr` and then reborrowed `&mut *self_ptr` again — overlapping
     /// `&mut` UB. Per docs/PORTING.md §Global mutable state we instead stay in
     /// raw-ptr land: hold `*mut Self` / `*mut Type` and deref per-access via
@@ -2630,8 +2653,7 @@ impl DevServer {
                 None => 'str: {
                     let bundle_index: u32 = route_bundle_index.get();
                     let generation: u32 = client_script_generation;
-                    // Zig: `"{x}{x}", .{ asBytes(&u32), asBytes(&u32) }` → fixed
-                    // 8-char native-endian byte hex per u32; `on_js_request`
+                    // Fixed 8-char native-endian byte hex per u32; `on_js_request`
                     // slices exactly 16 chars and decodes via `parse_hex_to_int`.
                     let mut hex = [0u8; 16];
                     bun_core::fmt::bytes_to_hex_lower(&bundle_index.to_ne_bytes(), &mut hex[..8]);
@@ -2695,9 +2717,8 @@ impl DevServer {
         req: SavedRequestUnion,
         resp: AnyResponse,
     ) -> JsResult<()> {
-        // PORT NOTE: erase the `&mut RouteBundle` to a raw pointer so subsequent
-        // `&self` accesses (vm/router/callback) don't trip borrowck — Zig freely
-        // aliased `dev` across this scope.
+        // Note: erase the `&mut RouteBundle` to a raw pointer so subsequent
+        // `&self` accesses (vm/router/callback) don't trip borrowck.
         let route_bundle: *mut RouteBundle = self.route_bundle_ptr(route_bundle_index);
         debug_assert!(matches!(
             // SAFETY: `route_bundle` points into `self.route_bundles`, not resized in this fn.
@@ -2745,7 +2766,7 @@ impl DevServer {
 
         // SAFETY: `self` is live; `framework_bundle` points into
         // `self.route_bundles[route_bundle_index].data`. Raw-ptr receiver — see
-        // PORT NOTE on `compute_arguments_for_framework_request`.
+        // Note on `compute_arguments_for_framework_request`.
         let args = unsafe {
             Self::compute_arguments_for_framework_request(
                 self,
@@ -2783,9 +2804,8 @@ impl DevServer {
         resp: AnyResponse,
         method: Method,
     ) {
-        // PORT NOTE: erase `self` to a raw pointer so the `route_bundle` borrow
-        // doesn't conflict with the `&mut self` calls below (Zig held these as
-        // plain heap pointers). Per docs/PORTING.md §Global mutable state: hold
+        // Note: erase `self` to a raw pointer so the `route_bundle` borrow
+        // doesn't conflict with the `&mut self` calls below. Per docs/PORTING.md §Global mutable state: hold
         // `*mut T` and deref per-access; do not bind a long-lived `&mut`.
         let self_ptr = std::ptr::from_mut::<Self>(self);
         // SAFETY: `route_bundles` is not reallocated for the duration of this fn.
@@ -2853,8 +2873,7 @@ impl DevServer {
         route_bundle_index: route_bundle::Index,
         route_bundle: &RouteBundle,
     ) -> Result<Vec<u8>, bun_core::Error> {
-        // PORT NOTE: Zig passed `*RouteBundle` and `*RouteBundle.HTML` separately
-        // (overlapping); re-derive `html` here from `route_bundle.data` so the
+        // Re-derive `html` here from `route_bundle.data` so the
         // caller never holds two `&mut` into the same allocation. `route_bundle`
         // is read-only in this fn — `&RouteBundle` suffices.
         let html = route_bundle.data.html();
@@ -2886,7 +2905,6 @@ impl DevServer {
         let _lock = self.graph_safety_lock.guard();
 
         // Prepare bitsets for tracing
-        // PERF(port): was stack-fallback (65536)
         let mut gts = self.init_graph_trace_state(0)?;
         // Run tracing
         self.client_graph.reset();
@@ -2908,7 +2926,6 @@ impl DevServer {
             + SCRIPT_UNREF_PAYLOAD.len();
 
         let mut array: Vec<u8> = Vec::with_capacity(payload_size);
-        // PERF(port): was appendSliceAssumeCapacity throughout
         array.extend_from_slice(before_head_end);
 
         // Insert all link tags before "</head>"
@@ -2953,7 +2970,6 @@ impl DevServer {
         input_file_sources: &[bun_ast::Source],
         loaders: &[Loader],
     ) -> Result<Box<[u8]>, bun_core::Error> {
-        // PERF(port): was stack-fallback (65536)
         let mut array: Vec<u8> = Vec::with_capacity(65536);
         let w = &mut array;
 
@@ -2995,7 +3011,6 @@ impl DevServer {
         w.extend_from_slice(b"], [], [], () => {}, false],\n");
 
         // Avoid-recloning if it is was moved to the heap
-        // PERF(port): Zig checked if buffer was on stack vs heap; Vec always heap
         Ok(array.into_boxed_slice())
     }
 
@@ -3005,7 +3020,7 @@ impl DevServer {
         resp: AnyResponse,
         method: Method,
     ) {
-        // PORT NOTE: erase `self` to a raw pointer so `route_bundle` borrow
+        // Note: erase `self` to a raw pointer so `route_bundle` borrow
         // doesn't conflict with `generate_client_bundle(&mut self, ..)`.
         let self_ptr = std::ptr::from_mut::<Self>(self);
         // SAFETY: `self_ptr` accesses below touch disjoint fields of `*self`.
@@ -3177,11 +3192,10 @@ impl DeferredRequest {
             "DeferredRequest(0x{:x}) deinitImpl",
             std::ptr::from_ref(self) as usize
         );
-        // PORT NOTE: the pool stores `MaybeUninit<DeferredRequest>` (no `Drop`),
+        // Note: the pool stores `MaybeUninit<DeferredRequest>` (no `Drop`),
         // so the `Handler` payload must be torn down explicitly here. Swap to
         // `Aborted` (zero-payload) and let the moved-out value drop — for
-        // `ServerHandler` this releases `saved.js_request: Strong` (the GC
-        // handle Zig freed via `js_request.deinit()`).
+        // `ServerHandler` this releases `saved.js_request: Strong`.
         let handler = ::core::mem::replace(&mut self.handler, Handler::Aborted);
         match handler {
             Handler::ServerHandler(mut saved) => {
@@ -3209,7 +3223,7 @@ impl DeferredRequest {
                 saved
                     .ctx
                     .set_signal_aborted(jsc::CommonAbortReason::ConnectionClosed);
-                // PORT NOTE: saved.js_request (jsc::Strong) drops at end of arm
+                // Note: saved.js_request (jsc::Strong) drops at end of arm
                 drop(saved);
             }
             Handler::BundledHtmlPage(r) => {
@@ -3240,7 +3254,6 @@ impl DevServer {
         // Notify inspector about bundle start
         // SAFETY: JS-thread only; sole `&mut` agent borrow in this scope.
         if let Some(agent) = unsafe { self.inspector() } {
-            // PERF(port): was stack-fallback
             let mut trigger_files: Vec<BunString> = Vec::with_capacity(entry_points.set.len());
             for key in entry_points.set.keys() {
                 trigger_files.push(BunString::clone_utf8(key));
@@ -3259,10 +3272,10 @@ impl DevServer {
         }
 
         // Boxed so its address is stable: `bv2.graph.heap: &'static Arena`
-        // borrows it (self-ref via `CurrentBundle`, see PORT NOTE on
+        // borrows it (self-ref via `CurrentBundle`, see Note on
         // `CurrentBundle.bv2`).
         let heap: Box<bun_alloc::MimallocArena> = Box::new(bun_alloc::MimallocArena::new());
-        // Borrows `heap` (Zig parity), so AST nodes built during bundle setup
+        // Borrows `heap`, so AST nodes built during bundle setup
         // live exactly as long as the bundle. The arena-allocated allocator
         // never runs `Drop`; the `AstAllocState` is taken into `CurrentBundle`
         // on success and recycled by the guard below on error paths.
@@ -3283,8 +3296,7 @@ impl DevServer {
         // `current_bundle` below.
         let ast_scope = unsafe { &mut *ast_memory_store }.enter();
 
-        // Zig: `.{ .js = dev.vm.eventLoop() }` constructed an `AnyEventLoop`
-        // by value; the Rust bundler instead stores
+        // The bundler stores
         // `Option<NonNull<AnyEventLoop<'static>>>`. Park the value in `heap`
         // — bumpalo chunks are heap-allocated, so the address is stable across
         // the move of `heap` into `bv2.graph.heap` and lives exactly as long
@@ -3299,7 +3311,7 @@ impl DevServer {
         // `CurrentBundle` (which also owns `bv2`); the boxed arena's address
         // is stable for the lifetime of `bv2.graph.heap`'s borrow.
         let heap_ptr: *const bun_alloc::Arena = &raw const *heap;
-        // PORT NOTE: split `&mut self` into disjoint field reborrows so
+        // Note: split `&mut self` into disjoint field reborrows so
         // `server_transpiler` (`&'a mut`) and `client/ssr_transpiler`
         // (NonNull) don't trip the single-`&mut self` rule.
         let self_ptr = std::ptr::from_mut::<Self>(self);
@@ -3332,7 +3344,6 @@ impl DevServer {
         )?;
         bv2.bun_watcher = Some(::core::ptr::NonNull::from(&mut **self.bun_watcher));
         bv2.asynchronous = true;
-        // Zig: `linker.dev_server = transpiler.options.dev_server` inside init.
         let dev_handle = self.bundler_handle();
         bv2.dev_server = Some(dev_handle);
         bv2.linker.dev_server = Some(dev_handle);
@@ -3428,7 +3439,6 @@ impl DevServer {
 
     fn index_failures(&mut self) -> Result<(), bun_core::Error> {
         // After inserting failures into the IncrementalGraphs, they are traced to their routes.
-        // PERF(port): was stack-fallback (65536)
 
         if !self.incremental_result.failures_added.is_empty() {
             let mut total_len: usize =
@@ -3445,7 +3455,6 @@ impl DevServer {
 
             let mut payload: Vec<u8> = Vec::with_capacity(total_len);
             payload.push(MessageId::Errors.char());
-            // PERF(port): was assume_capacity
 
             payload.extend_from_slice(
                 &u32::try_from(self.incremental_result.failures_removed.len())
@@ -3484,7 +3493,7 @@ impl DevServer {
                 }
             }
 
-            // PORT NOTE: iterate by index — the loop bodies need
+            // Note: iterate by index — the loop bodies need
             // `&mut self.route_bundles` / `&mut self.router`, which conflicts
             // with the `&self.incremental_result` iterator borrow.
             for i in 0..self.incremental_result.framework_routes_affected.len() {
@@ -3548,12 +3557,11 @@ impl DevServer {
         debug_assert!(route_bundle.server_state == route_bundle::State::Loaded);
 
         let _lock = self.graph_safety_lock.guard();
-        // PORT NOTE: scopeguard closures capture `self` by ref, wedging borrowck for
-        // the rest of the fn. Erase to a raw pointer (Zig `defer` had no aliasing check).
+        // Note: scopeguard closures capture `self` by ref, wedging borrowck for
+        // the rest of the fn. Erase to a raw pointer.
         let self_ptr: *mut Self = self;
 
         // Prepare bitsets
-        // PERF(port): was stack-fallback (65536)
         let mut gts = self.init_graph_trace_state(0)?;
 
         // Run tracing
@@ -3561,7 +3569,7 @@ impl DevServer {
         // `current_chunk_parts`/`current_chunk_len` are scratch buffers shared with
         // the HMR pipeline. We must leave them cleared on every exit path.
         // SAFETY: see `self_ptr` SAFETY above.
-        // PORT NOTE: copy `self_ptr` so the `defer!` closure captures a distinct
+        // Note: copy `self_ptr` so the `defer!` closure captures a distinct
         // local — otherwise borrowck treats `*self_ptr` as held for the guard's
         // lifetime and rejects later `&mut (*self_ptr).…` reborrows.
         let self_ptr_defer: *mut Self = self_ptr;
@@ -3614,7 +3622,6 @@ impl DevServer {
                     (*self_ptr).source_maps.unref(id)
                 });
                 gts.clear_and_free();
-                // PERF(port): was ArenaAllocator scratch — `take_source_map`
                 // allocates internally with the global allocator in the port.
                 // SAFETY: see `self_ptr` SAFETY above; `client_graph` is a
                 // disjoint field from `source_maps`.
@@ -3624,7 +3631,7 @@ impl DevServer {
             source_map_store::PutOrIncrementRefCount::Shared(_) => {}
         }
 
-        // PORT NOTE: `take_js_bundle` mutably borrows `client_graph` while
+        // Note: `take_js_bundle` mutably borrows `client_graph` while
         // `initial_entry` would alias `client_graph.bundled_files.keys()[idx]`.
         // Clone the key (a short path string) so the borrow ends before the
         // `&mut client_graph` call; cold path (per-route bundle finalize).
@@ -3658,7 +3665,6 @@ impl DevServer {
         let _lock = self.graph_safety_lock.guard();
 
         // Prepare bitsets
-        // PERF(port): was stack-fallback (65536)
         let mut gts = self.init_graph_trace_state(0)?;
 
         // Run tracing
@@ -3696,7 +3702,6 @@ impl DevServer {
         Ok(arr)
     }
 
-    // PERF(port): was comptime monomorphization (`comptime goal: TraceImportGoal`) — profile in Phase B
     fn trace_all_route_imports(
         &mut self,
         route_bundle: &RouteBundle,
@@ -3706,7 +3711,7 @@ impl DevServer {
         match &route_bundle.data {
             route_bundle::Data::Framework(fw) => {
                 let mut route = self.router.route_ptr(fw.route_index);
-                // PORT NOTE: copy the two `Type` fields up front so the
+                // Note: copy the two `Type` fields up front so the
                 // `&self.router` borrow doesn't overlap `&mut self.*_graph`.
                 let (rt_server_file, rt_client_file) = {
                     let rt = self.router.type_ptr_const(route.r#type);
@@ -3802,9 +3807,8 @@ pub struct HotUpdateContext<'a> {
 }
 
 /// Sentinel-encoded `Option<FileIndex>` packed into a `u32` (`u32::MAX` == none).
-/// Mirrors Zig `IncrementalGraph(side).FileIndex.Optional`. Side-erased so the
-/// `resolved_index_cache` backing slice stores it directly (Zig stored `[]u32`
-/// and bit-cast); callers re-tag with the correct `FileIndex<SIDE>` on `unwrap`.
+/// Side-erased so the `resolved_index_cache` backing slice stores it directly;
+/// callers re-tag with the correct `FileIndex<SIDE>` on `unwrap`.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct CachedFileIndex(pub u32);
@@ -3857,19 +3861,21 @@ pub(super) fn finalize_bundle(
     result: &mut bundler::bundle_v2::DevServerOutput,
 ) -> JsResult<()> {
     debug_assert!(dev.magic == Magic::Valid);
-    // PORT NOTE: `had_sent_hmr_event` is read inside the outer-defer scopeguard
+    // Note: `had_sent_hmr_event` is read inside the outer-defer scopeguard
     // and mutated later in the body. Use a `Cell` so the closure capture is `&Cell`
     // (shared), letting the body keep writing through `.set()`.
     let had_sent_hmr_event = ::core::cell::Cell::new(false);
 
-    // TODO(port): the giant `defer` block at the start of finalizeBundle has been
-    // moved into a scopeguard. Phase B must verify ordering relative to ?-returns.
-    // PORT NOTE: erase `dev`/`bv2` to raw pointers inside the guard so the
-    // long-lived closure capture doesn't lock borrowck for the entire fn body
-    // (Zig `defer` had no aliasing analysis).
+    // Both `defer!`s below (outer cleanup, then current_bundle request
+    // drain) are registered before the first fallible operation — the only
+    // statements in between are infallible (raw-pointer copies and the
+    // `expect` on an invariant). Guards run LIFO (drain → outer), and the
+    // `graph_safety_lock` guard declared after them drops first.
+    // Note: erase `dev`/`bv2` to raw pointers inside the guard so the
+    // long-lived closure capture doesn't lock borrowck for the entire fn body.
     let dev_ptr = std::ptr::from_mut::<DevServer>(dev);
     let bv2_ptr = std::ptr::from_mut::<BundleV2>(bv2);
-    // PORT NOTE: copy the raw ptrs into closure-only locals so `defer!`'s by-ref
+    // Note: copy the raw ptrs into closure-only locals so `defer!`'s by-ref
     // capture does not hold `*dev_ptr`/`*bv2_ptr` borrowed for the entire fn body.
     let dev_ptr_outer: *mut DevServer = dev_ptr;
     let bv2_ptr_outer: *mut BundleV2 = bv2_ptr;
@@ -3915,9 +3921,9 @@ pub(super) fn finalize_bundle(
         }
     };
 
-    // PORT NOTE: holding `&mut CurrentBundle` for the rest of the fn locks `*dev`
+    // Note: holding `&mut CurrentBundle` for the rest of the fn locks `*dev`
     // mutably. Erase to a raw pointer and reborrow at each use site via the
-    // `current_bundle!()` macro (Zig freely re-aliased `dev.current_bundle.?`).
+    // `current_bundle!()` macro.
     let current_bundle_ptr: *mut CurrentBundle = dev
         .current_bundle
         .as_mut()
@@ -3932,7 +3938,7 @@ pub(super) fn finalize_bundle(
             unsafe { &mut *current_bundle_ptr }
         };
     }
-    // PORT NOTE: see `dev_ptr_outer` rationale above — separate copy for the
+    // Note: see `dev_ptr_outer` rationale above — separate copy for the
     // `defer!` capture so `current_bundle!()` keeps reborrowing freely.
     let current_bundle_ptr_defer: *mut CurrentBundle = current_bundle_ptr;
     scopeguard::defer! {
@@ -3956,13 +3962,13 @@ pub(super) fn finalize_bundle(
 
     let _lock = dev.graph_safety_lock.guard();
 
-    // PORT NOTE: `js_pseudo_chunk()`/`css_chunks()`/`html_chunks()` each take
+    // Note: `js_pseudo_chunk()`/`css_chunks()`/`html_chunks()` each take
     // `&mut DevServerOutput`, so calling more than one wedges borrowck. Split
     // `result.chunks` once up front (the three regions are disjoint:
     // `[0] | [1..1+n_css] | [1+n_css..1+n_css+n_html]`).
     let n_css = result.css_file_list.count();
     let n_html = result.html_files.count();
-    // PORT NOTE: snapshot `result.chunks` ptr/len before `split_at_mut` so the
+    // Note: snapshot `result.chunks` ptr/len before `split_at_mut` so the
     // CSS-chunk loop can re-form the full slice for `intermediate_output.code()`
     // without re-borrowing `result.chunks` (already split).
     let chunks_ptr: *mut bundler::chunk::Chunk = result.chunks.as_mut_ptr();
@@ -3985,7 +3991,6 @@ pub(super) fn finalize_bundle(
     let targets = bv2.graph.ast.items_target();
     let scbs = bv2.graph.server_component_boundaries.slice();
 
-    // PERF(port): was stack-fallback (65536) on bv2.arena()
     let mut scb_bitset = DynamicBitSet::init_empty(input_file_sources.len())?;
     for ((source_index, ssr_index), ref_index) in scbs
         .list
@@ -4003,8 +4008,8 @@ pub(super) fn finalize_bundle(
 
     let mut resolved_index_cache = vec![CachedFileIndex::NONE; input_file_sources.len() * 2];
 
-    // PORT NOTE: ctx fields `server_seen_bit_set`/`gts` were `undefined` in Zig then
-    // assigned AFTER Pass 1 (receive_chunk grows `bundled_files`, so the trace bitsets
+    // Note: ctx fields `server_seen_bit_set`/`gts` are seeded with
+    // placeholders and assigned AFTER Pass 1 (receive_chunk grows `bundled_files`, so the trace bitsets
     // must be sized post-Pass-1). Seed with empty placeholders; real init below.
     let mut gts_storage = GraphTraceState {
         server_bits: DynamicBitSet::default(),
@@ -4101,10 +4106,10 @@ pub(super) fn finalize_bundle(
 
         let index = bun_ast::Index::init(chunk.entry_point.source_index());
 
-        // PORT NOTE: `IntermediateOutput::code` takes `&mut self` (a field of
+        // Note: `IntermediateOutput::code` takes `&mut self` (a field of
         // `*chunk`) plus `chunk: &Chunk` and `chunks: &[Chunk]`; borrowck still
         // rejects the overlap (`&mut chunk.intermediate_output` aliases the
-        // shared `&chunk` / `&chunks[..]`). Zig aliased freely. Split via raw
+        // shared `&chunk` / `&chunks[..]`). Split via raw
         // pointers — the callee never reborrows `chunk.intermediate_output`
         // through the `chunk`/`chunks` params (it reads metadata only).
         let code = {
@@ -4120,9 +4125,9 @@ pub(super) fn finalize_bundle(
                 // SAFETY: see above; shared reborrow of the same allocation,
                 // disjoint from the `&mut intermediate_output` receiver.
                 unsafe { &*chunk_ptr },
-                // SAFETY: `result.chunks` outlives this loop body; Zig passed
-                // the same slice while iterating it. `chunks_ptr/len` were
-                // snapshotted before `split_at_mut`; `code()` only reads.
+                // SAFETY: `result.chunks` outlives this loop body;
+                // `chunks_ptr/len` were snapshotted before `split_at_mut`,
+                // and `code()` only reads.
                 unsafe { ::core::slice::from_raw_parts(chunks_ptr, chunks_len) },
                 None,
                 false,
@@ -4137,9 +4142,8 @@ pub(super) fn finalize_bundle(
         // TODO: use a hash mix with the first half being a path hash and the second half content hash
         let h = hash(key);
         // Track css files that look like tailwind files.
-        // PORT NOTE: hoisted before `replace_path` because that consumes
-        // `code.buffer`; same observable order as Zig (buffer is identical
-        // pre- and post-asset-registration there).
+        // Note: hoisted before `replace_path` because that consumes
+        // `code.buffer`.
         let looks_like_tailwind = dev.has_tailwind_plugin_hack.is_some() && {
             let first_1024 = &code.buffer[..code.buffer.len().min(1024)];
             strings::index_of(first_1024, b"tailwind").is_some()
@@ -4158,7 +4162,7 @@ pub(super) fn finalize_bundle(
 
         if let Some(map) = &mut dev.has_tailwind_plugin_hack {
             if looks_like_tailwind {
-                // PORT NOTE: `get_or_put` consumes the key by value; on miss the key
+                // Note: `get_or_put` consumes the key by value; on miss the key
                 // already lives in the map so the explicit `*key_ptr =` is redundant.
                 let _ = map.get_or_put(Box::from(key))?;
             } else {
@@ -4187,10 +4191,11 @@ pub(super) fn finalize_bundle(
             code: compile_result_code,
             script_injection_offset: compile_result_offset,
             ..
-        } = &chunk.compile_results_for_chunk[0]
+        } = chunk.compile_results_for_chunk.get_mut(0)
         else {
             unreachable!()
         };
+        let compile_result_offset = *compile_result_offset;
         let generated_js = dev.generate_javascript_code_for_html_file(
             index,
             import_records,
@@ -4213,7 +4218,7 @@ pub(super) fn finalize_bundle(
         let route_bundle_index = dev.client_graph.html_route_bundle_index(client_index);
         let route_bundle = dev.route_bundle_ptr(route_bundle_index);
         debug_assert!(route_bundle.data.html().bundled_file == client_index);
-        // PORT NOTE: split borrow — `invalidate_client_bundle` needs `&mut RouteBundle`
+        // Note: split borrow — `invalidate_client_bundle` needs `&mut RouteBundle`
         // so the `cached_response` take is done before the long-lived `html` borrow.
         if route_bundle
             .data
@@ -4230,16 +4235,18 @@ pub(super) fn finalize_bundle(
             route_bundle::Data::Html(h) => h,
             _ => unreachable!(),
         };
-        if let Some(_slice) = html.bundled_html_text.take() {}
-        html.bundled_html_text = Some(compile_result_code.clone()); // TODO(port): ownership transfer
-        html.script_injection_offset = Some(route_bundle::ByteOffset::init(*compile_result_offset));
+        // Drops the previous text and transfers ownership of the chunk's
+        // compile-result code, leaving an empty
+        // boxed slice behind in the chunk — nothing reads it after this.
+        html.bundled_html_text = Some(std::mem::take(compile_result_code));
+        html.script_injection_offset = Some(route_bundle::ByteOffset::init(compile_result_offset));
 
         chunk
             .entry_point
             .set_entry_point_id(route_bundle_index.get());
     }
 
-    // Zig: `var gts = try dev.initGraphTraceState(...); ctx.gts = &gts;` — sized AFTER
+    // Sized AFTER
     // Pass 1 so server/client bitsets cover files just inserted by `receive_chunk`.
     *ctx.gts = dev.init_graph_trace_state(if n_css > 0 {
         input_file_sources.len()
@@ -4323,10 +4330,9 @@ pub(super) fn finalize_bundle(
                 };
 
                 // Fill the source map entry
-                // PERF(port): was ArenaAllocator
                 dev.server_graph.take_source_map(&mut source_map_entry)?;
-                // PORT NOTE: erase to raw ptr so `render_json` can borrow the entry
-                // while the cleanup guard is armed (Zig `defer` had no aliasing check).
+                // Note: erase to raw ptr so `render_json` can borrow the entry
+                // while the cleanup guard is armed.
                 let entry_ptr: *mut source_map_store::Entry = &raw mut source_map_entry;
                 scopeguard::defer! {
                     // SAFETY: `source_map_entry` is a stack local that outlives this guard.
@@ -4368,8 +4374,8 @@ pub(super) fn finalize_bundle(
                     // `print_error_like_object_to_console` needs `&mut`.
                     dev.vm_mut()
                         .print_error_like_object_to_console(global.take_exception(err));
-                    // PORT NOTE: Zig `@panic` aborts; Rust `panic!()` would unwind
-                    // through the `extern "C"` boundary above (`nounwind` UB).
+                    // Note: `panic!()` would unwind through the
+                    // `extern "C"` boundary above (`nounwind` UB), so abort.
                     bun_core::Output::panic(format_args!(
                         "Error thrown while evaluating server code. This is always a bug in the bundler."
                     ));
@@ -4383,15 +4389,15 @@ pub(super) fn finalize_bundle(
                     // `print_error_like_object_to_console` needs `&mut`.
                     dev.vm_mut()
                         .print_error_like_object_to_console(global.take_exception(err));
-                    // PORT NOTE: Zig `@panic` aborts; Rust `panic!()` would unwind
-                    // through the `extern "C"` boundary above (`nounwind` UB).
+                    // Note: `panic!()` would unwind through the
+                    // `extern "C"` boundary above (`nounwind` UB), so abort.
                     bun_core::Output::panic(format_args!(
                         "Error thrown while evaluating server code. This is always a bug in the bundler."
                     ));
                 }
             }
         };
-        // PORT NOTE: `make_array_for_server_components_patch` needs `&mut self`
+        // Note: `make_array_for_server_components_patch` needs `&mut self`
         // while reading `self.incremental_result.client_components_{added,removed}`.
         // It only touches `server_graph.bundled_files.keys()`, so reborrow the
         // index slices via `dev_ptr` (disjoint fields).
@@ -4431,7 +4437,6 @@ pub(super) fn finalize_bundle(
 
     let mut has_route_bits_set = false;
 
-    // PERF(port): was stack-fallback (65536)
     let mut hot_update_payload: Vec<u8> = Vec::with_capacity(65536);
     hot_update_payload.push(MessageId::HotUpdate.char());
 
@@ -4546,13 +4551,13 @@ pub(super) fn finalize_bundle(
 
     // `route_bits` will have all of the routes that were modified.
     if has_route_bits_set && (will_hear_hot_update || dev.incremental_result.had_adjusted_edges) {
-        // PORT NOTE: copy out before the loop so the `&mut RouteBundle` borrow
+        // Note: copy out before the loop so the `&mut RouteBundle` borrow
         // below doesn't overlap a `&dev.incremental_result` read.
         let had_adjusted_edges = dev.incremental_result.had_adjusted_edges;
         let mut it = route_bits.iterator::<true, true>();
         // List 2
         while let Some(i) = it.next() {
-            // PORT NOTE: erase to raw ptr — `trace_all_route_imports` below needs
+            // Note: erase to raw ptr — `trace_all_route_imports` below needs
             // `&mut *dev` while `route_bundle` (a sub-borrow of `dev.route_bundles`)
             // is still live; the two do not actually alias.
             let route_bundle: *mut RouteBundle = dev.route_bundle_ptr(route_bundle::Index::init(
@@ -4629,7 +4634,7 @@ pub(super) fn finalize_bundle(
             // Send the JS chunk
             if dev.client_graph.current_chunk_len > 0 {
                 let script_id = 'h: {
-                    // `bundler.ContentHasher.Hash` = `std.hash.XxHash64`.
+                    // Matches the bundler's `ContentHasher` hash (XxHash64).
                     let mut source_map_hash = bun_hash::XxHash64Streaming::new(0x4b12);
                     let keys = dev.client_graph.bundled_files.keys();
                     let values = dev.client_graph.bundled_files.values();
@@ -4663,7 +4668,7 @@ pub(super) fn finalize_bundle(
                     .put_or_increment_ref_count(script_id, sockets)?
                 {
                     source_map_store::PutOrIncrementRefCount::Uninitialized(entry) => 'brk: {
-                        // PORT NOTE: reborrow `client_graph` via `dev_ptr` so the
+                        // Note: reborrow `client_graph` via `dev_ptr` so the
                         // `&mut Entry` borrow inside `source_maps` does not alias.
                         // SAFETY: `dev_ptr` is live for this fn; disjoint fields.
                         unsafe { &mut (*dev_ptr).client_graph }.take_source_map(entry)?;
@@ -4696,14 +4701,14 @@ pub(super) fn finalize_bundle(
         dev.bundles_since_last_error = 0;
 
         // SAFETY: JS-thread only; sole `&mut` agent borrow in this scope.
-        // PORT NOTE: erase the agent borrow to a raw pointer so it can be passed
+        // Note: erase the agent borrow to a raw pointer so it can be passed
         // through `send_serialized_failures` (which also borrows `dev`) and then
-        // re-used below — Zig passed the optional pointer by value.
+        // re-used below.
         let mut inspector_agent_ptr: Option<*mut BunFrontendDevServerAgent> =
             unsafe { dev.inspector() }.map(std::ptr::from_mut);
         if current_bundle!().promise.strong.has_value() {
             // SAFETY: see `current_bundle!` SAFETY; guard runs before `_outer_defer`.
-            // PORT NOTE: copy the raw ptr so `defer!`'s by-ref capture does not
+            // Note: copy the raw ptr so `defer!`'s by-ref capture does not
             // hold `*current_bundle_ptr` borrowed across `current_bundle!()` uses.
             let cb_ptr_defer: *mut CurrentBundle = current_bundle_ptr;
             scopeguard::defer! {
@@ -4714,10 +4719,9 @@ pub(super) fn finalize_bundle(
                 .promise
                 .set_route_bundle_state(dev, route_bundle::State::PossibleBundlingFailures);
             let global = dev.global();
-            // PORT NOTE: `bundling_failures` lives on `*dev` but
+            // Note: `bundling_failures` lives on `*dev` but
             // `send_serialized_failures` needs `&mut self`; reborrow the keys
-            // through `dev_ptr` (Zig passed `dev.bundling_failures.keys()` by
-            // value with no aliasing check). The callee never touches
+            // through `dev_ptr`. The callee never touches
             // `bundling_failures`.
             // SAFETY: `dev_ptr` is live for the entire fn body (see line 3133).
             let failures = unsafe { (*dev_ptr).bundling_failures.values() };
@@ -4754,7 +4758,7 @@ pub(super) fn finalize_bundle(
                 Handler::BundledHtmlPage(ram) => DevResponse::Http(ram.response),
             };
 
-            // SAFETY: see PORT NOTE on `failures` above; `dev_ptr` is live and
+            // SAFETY: see Note on `failures` above; `dev_ptr` is live and
             // `send_serialized_failures` does not mutate `bundling_failures`.
             let failures = unsafe { (*dev_ptr).bundling_failures.values() };
             dev.send_serialized_failures(
@@ -4851,7 +4855,7 @@ pub(super) fn finalize_bundle(
                         break 'rbi route_bundle_indices[0];
                     };
 
-                    // PORT NOTE: index `route_bundles` immutably so `dev.relative_path`
+                    // Note: index `route_bundles` immutably so `dev.relative_path`
                     // / `dev.router` / `dev.server_graph` reads below stay disjoint.
                     break 'brk match &dev.route_bundles[route_bundle_index.get() as usize].data {
                         route_bundle::Data::Html(html) => {
@@ -4916,7 +4920,7 @@ pub(super) fn finalize_bundle(
 
     if current_bundle!().promise.strong.has_value() {
         // SAFETY: see `current_bundle!` SAFETY; guard runs before `_outer_defer`.
-        // PORT NOTE: copy the raw ptr so `defer!`'s by-ref capture does not
+        // Note: copy the raw ptr so `defer!`'s by-ref capture does not
         // hold `*current_bundle_ptr` borrowed across `current_bundle!()` uses.
         let cb_ptr_defer: *mut CurrentBundle = current_bundle_ptr;
         scopeguard::defer! {
@@ -4945,7 +4949,7 @@ pub(super) fn finalize_bundle(
         let rb = dev.route_bundle_ptr(req.route_bundle_index);
         rb.server_state = route_bundle::State::Loaded;
 
-        // PORT NOTE: `SavedRequest` is move-only (`Strong` field). Take the
+        // Note: `SavedRequest` is move-only (`Strong` field). Take the
         // handler by value so the `Saved` payload moves into the union; the
         // node is being torn down via `_deref` regardless.
         match ::core::mem::replace(&mut req.handler, Handler::Aborted) {
@@ -4953,10 +4957,7 @@ pub(super) fn finalize_bundle(
             Handler::ServerHandler(saved) => {
                 let response = saved.response;
                 let ctx = saved.ctx;
-                // PORT NOTE: Zig copied `saved` by value into the call and let
-                // `defer req.deref()` → `__deinit` → `saved.deinit()` release
-                // the original (`js_request.deinit()` + `ctx.deref()`). The
-                // Rust port moves `saved` out (so `__deinit` sees `Aborted`);
+                // Note: `saved` is moved out (so `__deinit` sees `Aborted`);
                 // `js_request: StrongOptional` releases on Drop, but
                 // `ctx: AnyRequestContext` is `Copy` — explicitly balance the
                 // `ctx.ref_()` from `defer_request` here so the request
@@ -4991,7 +4992,6 @@ impl DevServer {
             || !self.next_bundle.requests.first.is_null()
             || self.next_bundle.promise.strong.has_value()
         {
-            // PERF(port): was stack-fallback (4096)
             let mut entry_points = EntryPointList::empty();
 
             let (is_reload, timer) = if let Some(event) = self.next_bundle.reload_event.take() {
@@ -5027,7 +5027,7 @@ impl DevServer {
                 (false, Instant::now())
             };
 
-            // PORT NOTE: iterate by index — `route_bundle_ptr` /
+            // Note: iterate by index — `route_bundle_ptr` /
             // `append_route_entry_points_if_not_stale` need `&mut self`,
             // conflicting with the `keys()` iterator borrow.
             for i in 0..self.next_bundle.route_queue.len() {
@@ -5137,14 +5137,7 @@ pub struct CacheEntry {
 impl DevServer {
     pub fn is_file_cached(&mut self, path: &[u8], side: bake::Graph) -> Option<CacheEntry> {
         // Barrel files with deferred records must always be re-parsed.
-        // TODO(port): `ArrayHashMap<Box<[u8]>, ()>::contains_key` wants
-        // `&Box<[u8]>`; no `Borrow<[u8]>` adapter yet, so linear-scan keys.
-        if self
-            .barrel_files_with_deferrals
-            .keys()
-            .iter()
-            .any(|k| &**k == path)
-        {
+        if self.barrel_files_with_deferrals.contains_key(path) {
             return None;
         }
 
@@ -5362,7 +5355,6 @@ impl DevServer {
             route_bundle::Index::init(u32::try_from(self.route_bundles.len()).expect("int cast"));
 
         self.route_bundles.reserve(1);
-        // PERF(port): was assume_capacity
         self.route_bundles.push(RouteBundle {
             data: match route {
                 route_bundle::UnresolvedIndex::Framework(route_index) => {
@@ -5384,10 +5376,8 @@ impl DevServer {
                             .insert_stale_extra(&html_ref.bundle.path, false, true)?;
                     let file = &mut self.client_graph.bundled_files.values_mut()
                         [incremental_graph_index.get() as usize];
-                    // PORT NOTE: Zig packs/unpacks; the un-gated `incremental_graph::File`
-                    // is unpacked already.
                     file.html_route_bundle_index = Some(bundle_index);
-                    // Zig `.initRef(html)` — bump intrusive refcount; matched by
+                    // Bump the intrusive refcount; matched by
                     // `RouteBundle::deinit`'s deref of `html_bundle`.
                     // SAFETY: `html` is a live IntrusiveRc-managed allocation.
                     unsafe { bun_ptr::RefCount::<HTMLBundleRoute>::ref_(html) };
@@ -5437,7 +5427,6 @@ impl DevServer {
         let mut all_failures: Vec<u8> = Vec::with_capacity(all_failures_len);
         for fail in failures {
             all_failures.extend_from_slice(&fail.data);
-            // PERF(port): was assume_capacity
         }
 
         let failures_start_buf_pos = buf.len();
@@ -5454,8 +5443,7 @@ impl DevServer {
         if let Some(agent) = inspector_agent {
             debug_assert!(agent.is_enabled());
             let failures_encoded = &buf[failures_start_buf_pos..];
-            // base64 output is pure ASCII so a UTF-8 borrow is byte-identical to
-            // Zig's `BunString.initLatin1OrASCIIView`.
+            // base64 output is pure ASCII so a UTF-8 borrow is safe.
             let mut s = BunString::borrow_utf8(failures_encoded);
             agent.notify_bundle_failed(self.inspector_server_id, &mut s);
         }
@@ -5579,7 +5567,7 @@ impl DevServer {
     }
 }
 
-// PORT NOTE: FileKind/ChunkKind/TraceImportGoal/IncrementalResult/GraphTraceState
+// Note: FileKind/ChunkKind/TraceImportGoal/IncrementalResult/GraphTraceState
 // are defined once in `crate::bake::dev_server` and re-exported here so the
 // Phase-A draft body and the keystone struct module agree on identity.
 pub(super) use crate::bake::dev_server::FileKind;
@@ -5613,7 +5601,7 @@ impl DevServer {
     }
 }
 
-// PORT NOTE: canonical `ChunkKind` lives in `crate::bake::dev_server`; the
+// Note: canonical `ChunkKind` lives in `crate::bake::dev_server`; the
 // body module re-exports it so both modules name the same type.
 pub(super) use crate::bake::dev_server::ChunkKind;
 
@@ -5713,8 +5701,8 @@ impl DevServer {
     pub fn emit_visualizer_message_if_needed(&mut self) {
         #[cfg(feature = "bake_debugging_features")]
         {
-            // PORT NOTE: erase `self` to a raw ptr so the `defer!` doesn't pin a
-            // unique borrow for the rest of the fn (Zig `defer` had no aliasing).
+            // Note: erase `self` to a raw ptr so the `defer!` doesn't pin a
+            // unique borrow for the rest of the fn.
             let self_ptr: *mut Self = self;
             // SAFETY: `self_ptr` points to `*self`, live for the fn body.
             scopeguard::defer! { unsafe { (*self_ptr).emit_memory_visualizer_message_if_needed() } };
@@ -5722,7 +5710,6 @@ impl DevServer {
                 return;
             }
 
-            // PERF(port): was stack-fallback (65536)
             let mut payload: Vec<u8> = Vec::with_capacity(65536);
 
             if self.write_visualizer_message(&mut payload).is_err() {
@@ -5767,7 +5754,6 @@ impl DevServer {
         debug_assert!(cfg!(feature = "bake_debugging_features"));
         debug_assert!(self.emit_memory_visualizer_events > 0);
 
-        // PERF(port): was stack-fallback (65536)
         let mut payload: Vec<u8> = Vec::with_capacity(65536);
         payload.push(MessageId::MemoryVisualizer.char());
         if self.write_memory_visualizer_message(&mut payload).is_err() {
@@ -5782,9 +5768,8 @@ impl DevServer {
     ) -> Result<(), bun_core::Error> {
         let cost = self.memory_cost_detailed();
         let system_total = crate::node::os::totalmem();
-        // Wire format: 10 contiguous native-endian u32s — the Zig side declared
-        // a packed `Fields` struct, but a `[u32; 10]` has the identical layout
-        // (no padding) and is `bytemuck::Pod`, so the byte view is safe.
+        // Wire format: 10 contiguous native-endian u32s. `[u32; 10]` has no
+        // padding and is `bytemuck::Pod`, so the byte view is safe.
         let fields: [u32; 10] = [
             /* incremental_graph_client */ cost.incremental_graph_client as u32,
             /* incremental_graph_server */ cost.incremental_graph_server as u32,
@@ -5792,8 +5777,7 @@ impl DevServer {
             /* source_maps */ cost.source_maps as u32,
             /* assets */ cost.assets as u32,
             /* other */ cost.other as u32,
-            // PORT NOTE: Zig populated this from a debug allocation-scope
-            // tracker; Rust ownership has no equivalent runtime counter.
+            // No runtime allocation-scope tracker exists; report 0.
             /* devserver_tracked */
             0,
             /* process_used */ sys::self_process_memory_usage().unwrap_or(0) as u32,
@@ -5830,7 +5814,6 @@ impl DevServer {
 
     pub fn write_visualizer_message(&self, payload: &mut Vec<u8>) -> Result<(), bun_core::Error> {
         payload.push(MessageId::Visualizer.char());
-        // PERF(port): was assume_capacity
 
         macro_rules! emit_files {
             ($side:expr, $g:expr) => {{
@@ -5847,7 +5830,7 @@ impl DevServer {
                     .zip(g.bundled_files.values())
                     .enumerate()
                 {
-                    // PORT NOTE: un-gated `incremental_graph::File` is unpacked already.
+                    // Note: un-gated `incremental_graph::File` is unpacked already.
                     let file = v;
                     let mut buf = paths::path_buffer_pool::get();
                     let normalized_key = self.relative_path(&mut *buf, k);
@@ -5882,9 +5865,8 @@ impl DevServer {
         emit_files!(bake::Side::Client, &self.client_graph);
         emit_files!(bake::Side::Server, &self.server_graph);
 
-        // PORT NOTE: Zig used `inline for` over a `[2]bake.Side` tuple — written
-        // out as a small macro to avoid duplicating the per-side body while
-        // still monomorphizing on the const-generic graph type.
+        // A small macro avoids duplicating the per-side body while still
+        // monomorphizing on the const-generic graph type.
         macro_rules! emit_edges {
             ($g:expr) => {{
                 let g = $g;
@@ -5911,7 +5893,7 @@ impl DevServer {
     }
 }
 
-// PORT NOTE: MessageId/IncomingMessageId/ConsoleLogKind/HmrTopic are defined
+// Note: MessageId/IncomingMessageId/ConsoleLogKind/HmrTopic are defined
 // once in `crate::bake::dev_server` and re-exported here.
 pub(super) use crate::bake::dev_server::{HmrTopic, MessageId};
 
@@ -6010,7 +5992,6 @@ mod c {
     }
 }
 
-// PERF(port): was comptime monomorphization (`comptime n: comptime_int, bits: [n]*DynamicBitSetUnmanaged`) — profile in Phase B
 fn mark_all_route_children(
     router: &FrameworkRouter,
     bits: &mut [&mut DynamicBitSet],
@@ -6054,8 +6035,7 @@ impl DevServer {
         if let Some(debugger) = self.vm().debugger.as_ref() {
             bun_core::hint::cold();
             // SAFETY: `frontend_dev_server_agent` is `UnsafeCell`-wrapped for
-            // interior mutability (Zig spec returns `*Agent` from `*const
-            // DevServer`). JS-thread only; caller upholds the no-alias
+            // interior mutability. JS-thread only; caller upholds the no-alias
             // contract documented above.
             let agent = unsafe { &mut *debugger.frontend_dev_server_agent.get() };
             if agent.is_enabled() {
@@ -6078,7 +6058,7 @@ impl DevServer {
         scopeguard::defer! { debug_log!("onFileUpdate end") };
 
         let mut slice = watchlist.slice();
-        // PORT NOTE: SoA columns are disjoint, but `items_mut` borrows the whole
+        // Note: SoA columns are disjoint, but `items_mut` borrows the whole
         // slice mutably. Erase each column to a raw `*mut [T]` and reborrow at
         // the use sites — the columns never alias (per `MultiArrayElement` layout).
         let file_paths: *const [std::borrow::Cow<'static, [u8]>] = slice.items_file_path();
@@ -6097,9 +6077,8 @@ impl DevServer {
         // SAFETY: `watcher_acquire_event` returns a valid `*mut HotReloadEvent`
         // into `self.watcher_atomics.events`; exclusive on the watcher thread.
         let ev = unsafe { &mut *ev_ptr };
-        // PORT NOTE: erase `self` to a raw ptr in the deferred closures so the
-        // loop body can keep using `self.bun_watcher` (Zig `defer` had no
-        // aliasing check).
+        // Note: erase `self` to a raw ptr in the deferred closures so the
+        // loop body can keep using `self.bun_watcher`.
         let self_ptr: *mut Self = self;
         scopeguard::defer! {
             // SAFETY: `self_ptr` is live for the entire fn body; guard runs at scope exit.
@@ -6147,10 +6126,8 @@ impl DevServer {
                     ev.append_file(file_path);
                 }
                 bun_watcher::Kind::Directory => {
-                    // PORT NOTE: Zig's `Environment.isLinux` is `os.tag == .linux`,
-                    // which is *true* on Android (Zig encodes Android via the ABI
-                    // tag, not the OS tag). Rust's `target_os = "linux"` is false
-                    // on Android, so include `target_os = "android"` explicitly to
+                    // Note: `target_os = "linux"` is false on Android, so
+                    // include `target_os = "android"` explicitly to
                     // keep forwarding inotify sub-path names there.
                     #[cfg(any(target_os = "linux", target_os = "android"))]
                     {
@@ -6176,7 +6153,7 @@ impl DevServer {
 
     pub fn on_watch_error(&self, err: sys::Error) {
         if !err.path.is_empty() {
-            // PORT NOTE: split out path before moving `err` into `Output::err`.
+            // Note: split out path before moving `err` into `Output::err`.
             let path = err.path.clone();
             Output::err(
                 err,
@@ -6410,16 +6387,42 @@ fn dump_state_due_to_crash(dev: &mut DevServer) -> Result<(), bun_core::Error> {
         }
     };
 
-    // TODO(port): comptime brk: { @setEvalBranchQuota; @embedFile; lastIndexOf }
+    // Const-evaluate the lastIndexOf here so a
+    // missing `<script>` tag fails the build instead of panicking at
+    // crash-dump time.
     const VISUALIZER: &[u8] = include_bytes!("incremental_visualizer.html");
-    // TODO(port): const split at compile time — Phase B
-    let i = strings::last_index_of(VISUALIZER, b"<script>").unwrap() + b"<script>".len();
-    let (start, end) = (&VISUALIZER[..i], &VISUALIZER[i..]);
+    const SPLIT: usize = {
+        const NEEDLE: &[u8] = b"<script>";
+        let mut last_match: usize = usize::MAX;
+        let mut i = 0;
+        while i + NEEDLE.len() <= VISUALIZER.len() {
+            let mut j = 0;
+            let mut matched = true;
+            while j < NEEDLE.len() {
+                if VISUALIZER[i + j] != NEEDLE[j] {
+                    matched = false;
+                    break;
+                }
+                j += 1;
+            }
+            if matched {
+                last_match = i;
+            }
+            i += 1;
+        }
+        assert!(
+            last_match != usize::MAX,
+            "incremental_visualizer.html must contain a <script> tag"
+        );
+        last_match + NEEDLE.len()
+    };
+    const START: &[u8] = VISUALIZER.split_at(SPLIT).0;
+    const END: &[u8] = VISUALIZER.split_at(SPLIT).1;
+    let (start, end) = (START, END);
 
     file.write_all(start)?;
     file.write_all(b"\nlet inlinedData = Uint8Array.from(atob(\"")?;
 
-    // PERF(port): was stack-fallback (4096)
     let mut payload: Vec<u8> = Vec::with_capacity(4096);
     dev.write_visualizer_message(&mut payload)?;
 
@@ -6520,7 +6523,6 @@ impl EntryPointList {
 
 /// This structure does not increment the reference count of its contents, as
 /// the lifetime of them are all tied to the underling Bun.serve instance.
-/// Zig stores `*HTMLBundle.HTMLBundleRoute` (BACKREF — DevServer.zig:4364);
 /// `<'a>` retained only for the owning `DevServer<'a>`'s `Transpiler` borrows.
 #[derive(Default)]
 pub struct HTMLRouter {
@@ -6698,7 +6700,7 @@ impl UnrefSourceMapRequest {
 
 #[derive(Default)]
 pub struct TestingBatch {
-    /// Keys are borrowed. See doc comment in Zig source.
+    /// Keys are borrowed.
     pub entry_points: EntryPointList,
 }
 
@@ -6732,8 +6734,8 @@ pub(crate) fn get_deinit_count_for_testing() -> usize {
 }
 
 struct PromiseEnsureRouteBundledCtx<'a> {
-    // PORT NOTE: raw ptr — the Zig code freely re-borrowed `dev` across the ctx
-    // while also passing `&mut dev` into `ensure_route_is_bundled`.
+    // Note: raw ptr — `dev` is re-borrowed across the ctx while also passed
+    // as `&mut` into `ensure_route_is_bundled`.
     dev: *mut DevServer,
     global: &'a JSGlobalObject,
     promise: Option<jsc::JSPromiseStrong>,
@@ -6772,9 +6774,8 @@ impl<'a> PromiseEnsureRouteBundledCtx<'a> {
             self.p = Some(std::ptr::from_mut(strong.get()));
             self.promise = Some(strong);
         }
-        // PORT NOTE: Zig returned the `Strong` by bitwise copy (shared
-        // HandleSlot). Rust `Strong` owns its slot, so allocate a second
-        // handle to the same JSPromise instead — both `self.promise` and the
+        // Note: `Strong` owns its slot, so allocate a second
+        // handle to the same JSPromise — both `self.promise` and the
         // returned value root the same cell.
         let value = self.promise.as_ref().unwrap().value();
         jsc::JSPromiseStrong::from_value(value, self.global)
@@ -6849,7 +6850,7 @@ impl<'a> PromiseEnsureRouteBundledCtx<'a> {
             global: self.global,
         };
 
-        // PORT NOTE: split the route-bundle borrow off via raw pointer so the
+        // Note: split the route-bundle borrow off via raw pointer so the
         // failure slice doesn't conflict with the `&mut DevServer` below.
         let route_bundle_index = self.route_bundle_index;
         let failure = std::ptr::from_ref::<SerializedFailure>(
@@ -6978,8 +6979,8 @@ fn bundle_new_route_js_function_impl(
     };
 
     let rbi = ctx.route_bundle_index;
-    // SAFETY: `ctx.dev` aliases the same DevServer; Zig passed both freely.
-    // Reborrow via raw ptr to satisfy borrowck while ctx is also &mut-borrowed.
+    // SAFETY: `ctx.dev` aliases the same DevServer. Reborrow via raw ptr to
+    // satisfy borrowck while ctx is also &mut-borrowed.
     ensure_route_is_bundled(unsafe { &mut *dev_ptr }, rbi, &mut ctx)?;
 
     let array = JSValue::create_empty_array(global, 2)?;
@@ -6999,7 +7000,6 @@ fn bundle_new_route_js_function_impl(
     Ok(array)
 }
 
-// TODO(port): move to <area>_sys
 // `JSGlobalObject` is `#[repr(C)]` with `UnsafeCell<[u8; 0]>`; remaining args
 // are by-value `JSValue`s — validity is encoded in the signature.
 // C++ side defines `extern "C" SYSV_ABI` (BakeAdditionsToGlobalObject.cpp).
@@ -7095,9 +7095,8 @@ fn new_route_params_for_bundle_promise(
     route_bundle_index: route_bundle::Index,
     url: &[u8],
 ) -> JsResult<JSValue> {
-    // PORT NOTE: erase `dev` so the `route_bundle` / `framework_bundle`
-    // borrows don't conflict with `dev.router` / `dev.compute_arguments_...`
-    // (Zig held these as plain heap pointers).
+    // Note: erase `dev` so the `route_bundle` / `framework_bundle`
+    // borrows don't conflict with `dev.router` / `dev.compute_arguments_...`.
     let dev_ptr = std::ptr::from_mut::<DevServer>(dev);
     // SAFETY: `dev_ptr` accesses below touch disjoint fields of `*dev`.
     let route_bundle = unsafe { &mut *dev_ptr }.route_bundle_ptr(route_bundle_index);
@@ -7127,7 +7126,7 @@ fn new_route_params_for_bundle_promise(
 
     // SAFETY: `dev_ptr` is live; `framework_bundle` points into
     // `(*dev_ptr).route_bundles[route_bundle_index].data`. Raw-ptr receiver —
-    // see PORT NOTE on `compute_arguments_for_framework_request`.
+    // see Note on `compute_arguments_for_framework_request`.
     let args = unsafe {
         DevServer::compute_arguments_for_framework_request(
             dev_ptr,
@@ -7180,5 +7179,3 @@ use crate::bake::dev_server::serialized_failure;
 use crate::bake::dev_server::source_map_store;
 type DebuggerId = jsc::debugger::DebuggerId;
 type BunFrontendDevServerAgent = jsc::debugger::BunFrontendDevServerAgent;
-
-// ported from: src/bake/DevServer.zig
diff --git a/src/runtime/bake/DevServer/DirectoryWatchStore.rs b/src/runtime/bake/DevServer/DirectoryWatchStore.rs
index e496e553560..66fe3e6f8db 100644
--- a/src/runtime/bake/DevServer/DirectoryWatchStore.rs
+++ b/src/runtime/bake/DevServer/DirectoryWatchStore.rs
@@ -6,5 +6,3 @@
 //! This structure manages those watchers, including releasing them once
 //! import resolution failures are solved.
 // TODO: when a file fixes its resolution, there is no code specifically to remove the watchers.
-
-// ported from: src/bake/DevServer/DirectoryWatchStore.zig
diff --git a/src/runtime/bake/DevServer/ErrorReportRequest.rs b/src/runtime/bake/DevServer/ErrorReportRequest.rs
index 1a252de49a9..9d35c13c0e8 100644
--- a/src/runtime/bake/DevServer/ErrorReportRequest.rs
+++ b/src/runtime/bake/DevServer/ErrorReportRequest.rs
@@ -41,9 +41,8 @@ pub(crate) struct ErrorReportRequest {
     // BACKREF: heap-allocated request; DevServer owns the server lifecycle and
     // outlives every in-flight request (BackRef invariant).
     dev: bun_ptr::BackRef<DevServer>,
-    // PORT NOTE: BodyReaderMixin is a Zig comptime mixin parameterized by
-    // (Self, "body", run_with_body, finalize). Modeled as a generic helper that
-    // stores the buffered body and dispatches to the two callbacks below.
+    // BodyReaderMixin is a generic helper that stores the buffered body and
+    // dispatches to the two callbacks below.
     body: uws::BodyReaderMixin<ErrorReportRequest>,
 }
 
@@ -110,23 +109,13 @@ impl ErrorReportRequest {
         body: &[u8],
         r: AnyResponse,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-
         // .finalize has to be called last, but only in the non-error path.
-        // PORT NOTE: Zig used `defer if (should_finalize_self) ctx.finalize()`
-        // with `should_finalize_self` flipped to true only at the very end.
         // On error return, BodyReaderMixin calls `on_error` → `finalize`, so
         // here we simply call `finalize` directly at the success tail.
 
         let mut reader = bun_io::FixedBufferStream::new(body);
 
-        // PERF(port): was stack-fallback (65536) + ArenaAllocator — profile if it shows up on a hot path.
         let arena = Arena::new();
-        // The Zig used a separate per-source-map arena that was reset between
-        // parses; the Rust `source_map_store::get_parsed_source_map` (the
-        // canonical impl on `DevServer.source_maps`) takes `&self` and
-        // allocates VLQ scratch + result mappings into the global mimalloc
-        // heap, so no per-map reset arena is threaded here.
 
         // BackRef::get() is safe under the back-reference invariant (DevServer
         // outlives this request). No `&mut *ctx` is formed for the body of this
@@ -184,7 +173,7 @@ impl ErrorReportRequest {
         let mut parsed_source_maps: ArrayHashMap<SourceMapKey, Option<GetResult<'_>>> =
             ArrayHashMap::new();
         bun_core::handle_oom(parsed_source_maps.ensure_total_capacity(4));
-        // PORT NOTE: `defer for (parsed_source_maps.values()) |*v| v.deinit()` deleted —
+        // Note: `defer for (parsed_source_maps.values()) |*v| v.deinit()` deleted —
         // `GetResult` drops its owned `mappings` automatically.
 
         let mut runtime_lines: Option<[&[u8]; 5]> = None;
@@ -192,9 +181,8 @@ impl ErrorReportRequest {
         let mut top_frame_position = ZigStackFramePosition::INVALID;
         let mut region_of_interest_line: u32 = 0;
         for frame in frames.iter_mut() {
-            // PORT NOTE: Zig read `frame.source_url.value.ZigString.slice()` —
-            // every `source_url` here is `Tag::ZigString` (built via
-            // `String::init(&[u8])`), so `byte_slice()` is the equivalent view.
+            // Every `source_url` here is `Tag::ZigString` (built via
+            // `String::init(&[u8])`), so `byte_slice()` is the right view.
             let source_url: &[u8] = frame.source_url.byte_slice();
             // The browser code strips "http://localhost:3000" when the string
             // has /_bun/client. It's done because JS can refer to `location`
@@ -205,8 +193,6 @@ impl ErrorReportRequest {
             // Get and cache the parsed source map
             let gop = bun_core::handle_oom(parsed_source_maps.get_or_put(id));
             if !gop.found_existing {
-                // PERF(port): Zig reset a per-map arena here; the Rust port
-                // allocates VLQ/result into the global heap and frees on Drop.
                 match dev.source_maps.get_parsed_source_map(id) {
                     None => {
                         bun_core::debug_warn!(
@@ -298,8 +284,7 @@ impl ErrorReportRequest {
             // Ensure that trimming will not remove ALL frames.
             let mut all_runtime = true;
             for frame in frames.iter() {
-                // PORT NOTE: Zig compared `slice().ptr == runtime_name` —
-                // pointer-identity on the borrowed RUNTIME_NAME slice.
+                // Pointer-identity check on the borrowed RUNTIME_NAME slice.
                 let is_runtime = frame.position.is_invalid()
                     && frame.source_url.byte_slice().as_ptr() == RUNTIME_NAME.as_ptr();
                 if !is_runtime {
@@ -311,10 +296,7 @@ impl ErrorReportRequest {
                 break 'trim_runtime_frames;
             }
 
-            // Move all frames up
-            // PORT NOTE: reshaped — Zig copied items down then truncated; Rust
-            // `Vec::retain` does the same in-place compaction with the same
-            // relative order.
+            // Move all frames up.
             frames.retain(|frame| {
                 !(frame.position.is_invalid()
                     && frame.source_url.byte_slice().as_ptr() == RUNTIME_NAME.as_ptr())
@@ -340,8 +322,8 @@ impl ErrorReportRequest {
         {
             let stderr = Output::error_writer_buffered();
             let _flush = Output::flush_guard();
-            // PERF(port): was comptime bool dispatch — `print_externally_remapped_zig_exception`
-            // takes runtime `allow_ansi_color`, so no `inline else` split needed.
+            // `print_externally_remapped_zig_exception` takes a runtime
+            // `allow_ansi_color` flag.
             let ansi_colors = Output::enable_ansi_colors_stderr();
             // `dev.vm` is `*const` (shared-ref provenance from `Options.vm`);
             // `vm_mut()` recovers `&mut VirtualMachine` via the per-thread
@@ -416,7 +398,7 @@ impl ErrorReportRequest {
                 ..Default::default()
             },
         );
-        // `should_finalize_self = true;` — see PORT NOTE at fn top.
+        // `should_finalize_self = true;` — see Note at fn top.
         // `ctx` is the original heap-allocated pointer (caller contract); the
         // only borrow derived from it (`dev`) points into a separate DevServer
         // allocation, so freeing `*ctx` does not invalidate any live reference.
@@ -430,7 +412,6 @@ pub(crate) fn parse_id(source_url: &[u8], browser_url: &[u8]) -> Option<source_m
         return None;
     }
     let after_host = &source_url[strings::without_trailing_slash(browser_url).len()..];
-    // PORT NOTE: `client_prefix ++ "/"` is comptime string concat in Zig.
     if !(after_host.starts_with(CLIENT_PREFIX.as_bytes())
         && after_host.get(CLIENT_PREFIX.len()) == Some(&b'/'))
     {
@@ -455,7 +436,6 @@ fn extract_json_encoded_source_code<'a, const N: usize>(
     target_line: u32,
     arena: &'a Arena,
 ) -> Result<Option<[&'a [u8]; N]>, bun_core::Error> {
-    // TODO(port): narrow error set
     let mut line: usize = 0;
     let mut prev: usize = 0;
     let index_of_first_line: usize = if target_line == 0 {
@@ -491,7 +471,7 @@ fn extract_json_encoded_source_code<'a, const N: usize>(
     // This function expects but does not assume the escape sequences
     // given are valid, and does not bubble errors up.
     //
-    // PORT NOTE: `Lexer<'a>` borrows `&'a mut Log` and `&'a Source`; allocate
+    // Note: `Lexer<'a>` borrows `&'a mut Log` and `&'a Source`; allocate
     // both from the caller's arena so their lifetime matches the decoded
     // `ArenaVec<'a, u8>` slices we hand back in `result`.
     let log: &'a mut Log = arena.alloc(Log::init());
@@ -618,5 +598,3 @@ pub(crate) fn sanitize_for_terminal<'a>(s: &'a [u8], arena: &'a Arena) -> &'a [u
     }
     copy
 }
-
-// ported from: src/bake/DevServer/ErrorReportRequest.zig
diff --git a/src/runtime/bake/DevServer/HmrSocket.rs b/src/runtime/bake/DevServer/HmrSocket.rs
index aaeb675746b..84ec6a22825 100644
--- a/src/runtime/bake/DevServer/HmrSocket.rs
+++ b/src/runtime/bake/DevServer/HmrSocket.rs
@@ -10,8 +10,8 @@ use super::source_map_store::{self, RemoveOrUpgradeMode};
 use super::{ConsoleLogKind, DevServer, HmrTopic, IncomingMessageId, MessageId};
 use crate::bake::dev_server_body::HmrTopicBits;
 
-// Local shim for Zig's `res: anytype` — shared with `DevServer::on_web_socket_upgrade`.
-// TODO(port): replace with `bun_uws::ResponseLike` once that trait lands upstream.
+// Shared with `DevServer::on_web_socket_upgrade`.
+// The trait lives in `dev_server/mod.rs`; only the dev server needs it.
 pub(crate) use super::ResponseLike;
 
 // Struct definition lives in `dev_server/mod.rs` so the public
@@ -20,7 +20,7 @@ pub(crate) use super::ResponseLike;
 pub(crate) use super::HmrSocket;
 
 impl HmrSocket {
-    // `res: anytype` — only `.getRemoteSocketInfo()` is called on it.
+    // `res` is generic — only `.get_remote_socket_info()` is called on it.
     // Bound matches the caller in `DevServer::on_web_socket_upgrade`.
     pub fn new<R>(dev: &mut DevServer, res: &mut R) -> Box<HmrSocket>
     where
@@ -88,16 +88,15 @@ impl HmrSocket {
             return ws.close();
         }
 
-        // Zig's IncomingMessageId is non-exhaustive (`_ => ws.close()`), so msg[0] may be any
-        // byte. Transmuting an out-of-range u8 into a #[repr(u8)] enum is UB regardless of a
-        // wildcard match arm — match on the raw byte instead.
+        // `msg[0]` may be any byte. Transmuting an out-of-range u8 into a
+        // #[repr(u8)] enum is UB regardless of a wildcard match arm — match on
+        // the raw byte instead.
         match msg[0] {
             x if x == IncomingMessageId::Init as u8 => {
                 if msg.len() != 9 {
                     return ws.close();
                 }
                 let mut generation_bytes = [0u8; 4];
-                // std.fmt.hexToBytes → bun_core::decode_hex_to_bytes
                 if strings::decode_hex_to_bytes(&mut generation_bytes, &msg[1..]).is_err() {
                     return ws.close();
                 }
@@ -109,10 +108,7 @@ impl HmrSocket {
                     .source_maps
                     .remove_or_upgrade_weak_ref(source_map_id, RemoveOrUpgradeMode::Upgrade)
                 {
-                    self.referenced_source_maps
-                        .insert(source_map_id, ())
-                        // PERF(port): was `catch bun.outOfMemory()` — Rust HashMap aborts on OOM
-                        ;
+                    self.referenced_source_maps.insert(source_map_id, ());
                 }
             }
             x if x == IncomingMessageId::Subscribe as u8 => {
@@ -121,14 +117,11 @@ impl HmrSocket {
                 if topics.len() > HmrTopic::MAX_COUNT {
                     return;
                 }
-                // Zig: inline for over @typeInfo(HmrTopic).@"enum".fields, matching
-                // `char == field.value` and setting the corresponding bit.
                 for &ch in topics {
                     if let Some(topic) = HmrTopic::from_u8(ch) {
                         new_bits.insert(topic.as_bit());
                     }
                 }
-                // Zig: inline for over std.enums.values(HmrTopic)
                 for &field in HmrTopic::ALL {
                     let bit = field.as_bit();
                     if new_bits.contains(bit) && !self.subscriptions.contains(bit) {
@@ -151,7 +144,7 @@ impl HmrSocket {
                                             dev.memory_visualizer_timer.state
                                                 != EventLoopTimerState::ACTIVE
                                         );
-                                        // PORT NOTE (jsc/runtime crate cycle): `vm.timer` is `()` on the
+                                        // Note (jsc/runtime crate cycle): `vm.timer` is `()` on the
                                         // low-tier `VirtualMachine`; the real `timer::All`
                                         // lives in `RuntimeState` (see jsc_hooks.rs).
                                         let state = crate::jsc_hooks::runtime_state();
@@ -174,9 +167,9 @@ impl HmrSocket {
                             }
                         }
                     } else if new_bits.contains(bit) && !self.subscriptions.contains(bit) {
-                        // PORT NOTE: this `else if` condition is identical to the `if` above in
-                        // the source Zig (line 96) and is therefore unreachable. Ported verbatim;
-                        // likely an upstream bug (intended: `!new && old` → unsubscribe).
+                        // Note: this `else if` condition is identical to the `if`
+                        // above and is therefore unreachable; likely a bug
+                        // (intended: `!new && old` → unsubscribe).
                         let _ = ws.unsubscribe(&[field as u8]);
                     }
                 }
@@ -240,8 +233,7 @@ impl HmrSocket {
                         ws.close();
                     }
                     super::TestingBatchEvents::Enabled(_event_const) => {
-                        // PORT NOTE: reshaped for borrowck — Zig copied the payload then
-                        // overwrote the union; here we replace-and-extract.
+                        // Replace-and-extract to satisfy borrowck.
                         let super::TestingBatchEvents::Enabled(mut event) = core::mem::replace(
                             &mut dev.testing_batch_events,
                             super::TestingBatchEvents::Disabled,
@@ -344,7 +336,7 @@ impl HmrSocket {
                 if dev.emit_incremental_visualizer_events == 0
                     && dev.memory_visualizer_timer.state == EventLoopTimerState::ACTIVE
                 {
-                    // PORT NOTE (jsc/runtime crate cycle): `vm.timer` is `()` on the low-tier
+                    // Note (jsc/runtime crate cycle): `vm.timer` is `()` on the low-tier
                     // `VirtualMachine`; the real `timer::All` lives in `RuntimeState`.
                     let state = crate::jsc_hooks::runtime_state();
                     // SAFETY: `runtime_state()` is non-null after `bun_runtime::init()`;
@@ -420,5 +412,3 @@ impl HmrSocket {
         }
     }
 }
-
-// ported from: src/bake/DevServer/HmrSocket.zig
diff --git a/src/runtime/bake/DevServer/IncrementalGraph.rs b/src/runtime/bake/DevServer/IncrementalGraph.rs
index 8c2c4c1ca06..2f2511ccbd3 100644
--- a/src/runtime/bake/DevServer/IncrementalGraph.rs
+++ b/src/runtime/bake/DevServer/IncrementalGraph.rs
@@ -1,4 +1,4 @@
-//! `DevServer.IncrementalGraph(side)` — port of `IncrementalGraph.zig`.
+//! `DevServer.IncrementalGraph(side)`.
 //!
 //! An earlier draft formerly defined a *second*, layout-incompatible
 //! `IncrementalGraph<S: GraphSide>` struct here (trait-param `Client`/`Server`
@@ -17,4 +17,4 @@
 //! `crate::bake::dev_server::incremental_graph` and are re-exported here so
 //! `incremental_graph_body` resolves to the same nominal types. Per-side
 //! `ServerFile`/`ClientFile` are folded into the canonical `File` (see the
-//! `TODO(port)` there for the eventual layout split).
+//! note on `File` there about the eventual layout split).
diff --git a/src/runtime/bake/DevServer/RouteBundle.rs b/src/runtime/bake/DevServer/RouteBundle.rs
index 2d563dac446..8b137891791 100644
--- a/src/runtime/bake/DevServer/RouteBundle.rs
+++ b/src/runtime/bake/DevServer/RouteBundle.rs
@@ -1 +1 @@
-// ported from: src/bake/DevServer/RouteBundle.zig
+
diff --git a/src/runtime/bake/DevServer/memory_cost.rs b/src/runtime/bake/DevServer/memory_cost.rs
index 37b73f83091..30c0265a71e 100644
--- a/src/runtime/bake/DevServer/memory_cost.rs
+++ b/src/runtime/bake/DevServer/memory_cost.rs
@@ -33,11 +33,62 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
     let mut source_maps: usize = 0;
     let mut assets: usize = 0;
 
-    // See https://github.com/ziglang/zig/issues/21879
-    // PORT NOTE: Zig used `useAllFields(DevServer, .{...})` to compile-time-assert that
-    // every DevServer field is accounted for below. Rust has no equivalent; the field
-    // list is preserved as comments. A proc-macro or static-assert could re-add the check.
-    // TODO(port): exhaustiveness check for DevServer fields (was bun.meta.useAllFields)
+    // Exhaustiveness check:
+    // destructuring without `..` fails to compile when a DevServer field is
+    // added, removed, or renamed, forcing the accounting below to be updated.
+    // All bindings are `_` so nothing is moved or borrowed past this block.
+    {
+        let DevServer {
+            magic: _,
+            root: _,
+            inspector_server_id: _,
+            configuration_hash_key: _,
+            vm: _,
+            server: _,
+            router: _,
+            route_bundles: _,
+            graph_safety_lock: _,
+            client_graph: _,
+            server_graph: _,
+            barrel_files_with_deferrals: _,
+            barrel_needed_exports: _,
+            incremental_result: _,
+            route_lookup: _,
+            html_router: _,
+            assets: _,
+            source_maps: _,
+            bundling_failures: _,
+            frontend_only: _,
+            has_tailwind_plugin_hack: _,
+            server_fetch_function_callback: _,
+            server_register_update_callback: _,
+            bun_watcher: _,
+            directory_watchers: _,
+            watcher_atomics: _,
+            testing_batch_events: _,
+            generation: _,
+            bundles_since_last_error: _,
+            framework: _,
+            bundler_framework_views: _,
+            bundler_options: _,
+            server_transpiler: _,
+            client_transpiler: _,
+            ssr_transpiler: _,
+            log: _,
+            plugin_state: _,
+            current_bundle: _,
+            next_bundle: _,
+            deferred_request_pool: _,
+            active_websocket_connections: _,
+            dump_dir: _,
+            emit_incremental_visualizer_events: _,
+            emit_memory_visualizer_events: _,
+            memory_visualizer_timer: _,
+            has_pre_crash_handler: _,
+            assume_perfect_incremental_bundling: _,
+            broadcast_console_log_from_browser_to_server: _,
+        } = dev;
+    }
 
     // does not contain pointers
     //   .assume_perfect_incremental_bundling
@@ -80,6 +131,9 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
     for bundle in dev.route_bundles.iter() {
         other_bytes += bundle.memory_cost();
     }
+    // .bundler_framework_views (the pointed-to Frameworks are owned elsewhere;
+    // count the Vec's own backing store)
+    other_bytes += memory_cost_array_list(&dev.bundler_framework_views);
     // .server_graph
     {
         let cost = dev.server_graph.memory_cost_detailed();
@@ -103,20 +157,27 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
     // .source_maps
     other_bytes += memory_cost_array_hash_map(&dev.source_maps.entries);
     for entry in dev.source_maps.entries.values() {
-        // PORT NOTE: Zig stored `MultiArrayList(PackedMap.Shared)` and called
-        // `entry.files.memoryCost()` (capacityInBytes). The Rust port stores a
-        // plain `Vec<packed_map::Shared>` (see source_map_store.rs PORT NOTE),
-        // so the SoA byte-count is replaced by `cap * size_of::<Shared>()`.
         source_maps += entry.files.capacity() * size_of::<packed_map::Shared>();
         for file in entry.files.iter() {
             source_maps += file.memory_cost();
         }
     }
     // .incremental_result
-    // TODO(port): exhaustiveness check for IncrementalResult fields (was bun.meta.useAllFields)
     {
-        let _ = core::mem::size_of::<IncrementalResult>(); // anchor for grep
-        // .had_adjusted_edges
+        // Exhaustiveness check — fails to compile when
+        // an IncrementalResult field is added/removed/renamed.
+        let IncrementalResult {
+            framework_routes_affected: _,
+            html_routes_soft_affected: _,
+            html_routes_hard_affected: _,
+            had_adjusted_edges: _,
+            client_components_added: _,
+            client_components_removed: _,
+            failures_removed: _,
+            client_components_affected: _,
+            failures_added: _,
+        } = &dev.incremental_result;
+        // .had_adjusted_edges (bool — no heap)
         // .client_components_added
         other_bytes += memory_cost_array_list(&dev.incremental_result.client_components_added);
         // .framework_routes_affected
@@ -154,9 +215,8 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
         dev.html_router.map.capacity() * (size_of::<*const HTMLBundleRoute>() + size_of::<&[u8]>());
     // DevServer does not count the referenced HTMLBundle.HTMLBundleRoutes
     // .bundling_failures
-    // PORT NOTE: Zig keys the set by `SerializedFailure` directly; the Rust port
-    // stores `OwnerPacked → SerializedFailure`, so the failure payloads live in
-    // `.values()`.
+    // The map stores `OwnerPacked → SerializedFailure`, so the failure
+    // payloads live in `.values()`.
     other_bytes += memory_cost_slice(dev.bundling_failures.values());
     for failure in dev.bundling_failures.values() {
         other_bytes += failure.data.len();
@@ -164,8 +224,7 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
     // All entries are owned by the bundler arena, not DevServer, except for `requests`
     // .current_bundle
     if let Some(bundle) = &dev.current_bundle {
-        // PORT NOTE: Zig walked the intrusive list (`while (r) |req| : (r = req.next)`)
-        // only to count nodes; `SinglyLinkedList::len()` does the same O(N) walk.
+        // `SinglyLinkedList::len()` is an O(N) walk; only the node count matters.
         other_bytes += bundle.requests.len() * size_of::<deferred_request::Node>();
     }
     // .next_bundle
@@ -196,9 +255,7 @@ pub(crate) fn memory_cost_detailed(dev: &DevServer) -> MemoryCost {
 
 pub(crate) fn memory_cost(dev: &DevServer) -> usize {
     let cost = memory_cost_detailed(dev);
-    // PORT NOTE: Zig iterated `@typeInfo(MemoryCost).@"struct".fields` to sum every
-    // field. Rust has no field reflection; the sum is written out explicitly. Keep this
-    // in sync with the `MemoryCost` struct definition above.
+    // Keep this in sync with the `MemoryCost` struct definition above.
     let mut acc: usize = 0;
     acc += cost.incremental_graph_client;
     acc += cost.incremental_graph_server;
@@ -218,11 +275,7 @@ pub(crate) fn memory_cost_slice<T>(slice: &[T]) -> usize {
 }
 
 pub(crate) fn memory_cost_array_hash_map<K, V, C>(map: &ArrayHashMap<K, V, C>) -> usize {
-    // Zig: `@TypeOf(map.entries).capacityInBytes(map.entries.capacity)` — the
-    // SoA byte capacity of the backing `MultiArrayList`. The Rust `ArrayHashMap`
-    // stores three separate `Vec`s (keys, values, 32-bit hashes) instead, so the
-    // equivalent footprint is `capacity * (sizeof K + sizeof V + sizeof u32)`.
+    // `ArrayHashMap` stores three separate `Vec`s (keys, values, 32-bit
+    // hashes), so the footprint is `capacity * (sizeof K + sizeof V + sizeof u32)`.
     map.capacity() * (size_of::<K>() + size_of::<V>() + size_of::<u32>())
 }
-
-// ported from: src/bake/DevServer/memory_cost.zig
diff --git a/src/runtime/bake/DevServerSourceProvider.cpp b/src/runtime/bake/DevServerSourceProvider.cpp
index 291e0883ea4..bbd4672310d 100644
--- a/src/runtime/bake/DevServerSourceProvider.cpp
+++ b/src/runtime/bake/DevServerSourceProvider.cpp
@@ -2,10 +2,10 @@
 #include "BunBuiltinNames.h"
 #include "BunString.h"
 
-// The Zig implementation will be provided to handle registration
+// Implemented on the Rust side to handle registration.
 extern "C" void Bun__addDevServerSourceProvider(void* bun_vm, Bake::DevServerSourceProvider* opaque_source_provider, BunString* specifier);
 
-// Export functions for Zig to access DevServerSourceProvider
+// Exported for the Rust side to access DevServerSourceProvider.
 extern "C" BunString DevServerSourceProvider__getSourceSlice(Bake::DevServerSourceProvider* provider)
 {
     return Bun::toStringView(provider->source());
diff --git a/src/runtime/bake/DevServerSourceProvider.h b/src/runtime/bake/DevServerSourceProvider.h
index 46c022dbe32..39d1dd9d940 100644
--- a/src/runtime/bake/DevServerSourceProvider.h
+++ b/src/runtime/bake/DevServerSourceProvider.h
@@ -9,7 +9,7 @@ namespace Bake {
 
 class DevServerSourceProvider;
 
-// Function to be implemented in Zig to register the source provider
+// Implemented on the Rust side to register the source provider.
 extern "C" void Bun__addDevServerSourceProvider(void* bun_vm, DevServerSourceProvider* opaque_source_provider, BunString* specifier);
 extern "C" void Bun__removeDevServerSourceProvider(void* bun_vm, DevServerSourceProvider* opaque_source_provider, BunString* specifier);
 
diff --git a/src/runtime/bake/FrameworkRouter.rs b/src/runtime/bake/FrameworkRouter.rs
index bcc2b704347..cc3e8b355dc 100644
--- a/src/runtime/bake/FrameworkRouter.rs
+++ b/src/runtime/bake/FrameworkRouter.rs
@@ -26,7 +26,6 @@ use crate::bake::dev_server::route_bundle::IndexOptional as RouteBundleIndexOpti
 /// where it is an entrypoint index.
 pub enum OpaqueFileIdMarker {}
 pub type OpaqueFileId = bun_core::GenericIndex<u32, OpaqueFileIdMarker>;
-// TODO(port): bun.GenericIndex.Optional is a packed sentinel (maxInt = none); using Option<T> here changes layout.
 pub type OpaqueFileIdOptional = Option<OpaqueFileId>;
 
 pub struct FrameworkRouter {
@@ -70,9 +69,6 @@ pub struct FrameworkRouter {
     ///    this arena to ensure that everything gets freed.
     pub pattern_string_arena: Arena,
 
-    /// Dead-code in the Zig source (`newEdge` references `fr.edges`/`fr.freed_edges`/`Route.Edge`
-    /// which are never otherwise defined or used). Ported as a free-list pair so the body of
-    /// `new_edge` matches the spec verbatim.
     pub edges: Vec<RouteEdge>,
     pub freed_edges: Vec<RouteEdgeIndex>,
 }
@@ -82,8 +78,10 @@ pub type DynamicRouteMap = ArrayHashMap<EncodedPattern, RouteIndex, EffectiveUrl
 
 /// A logical route, for which layouts are looked up on after resolving a route.
 pub struct Route {
-    // TODO(port): lifetime — payload bytes borrow from `pattern_string_arena` (ARENA class).
-    // Erased to 'static via `to_owned_part()` at insertion; could switch to `*const [u8]`.
+    // Payload bytes borrow from the sibling `pattern_string_arena` field — a
+    // self-referential borrow Rust lifetimes cannot express, so it is detached
+    // to `'static` via `to_owned_part()` at insertion. See `to_owned_part` for
+    // the safety invariant (arena outlives every `Route`).
     pub part: Part<'static>,
     pub r#type: TypeIndex,
 
@@ -123,11 +121,9 @@ pub enum FileKind {
 }
 
 pub enum RouteMarker {}
-pub type RouteIndex = bun_core::GenericIndex<u32, RouteMarker>; // Zig: u31 (loses u31 range debug-assert)
+pub type RouteIndex = bun_core::GenericIndex<u32, RouteMarker>;
 
-/// Zig: `Route.Edge` — referenced only by the dead `newEdge` free-list helper in the spec.
-/// The struct body is never defined upstream; ported as an opaque unit so `new_edge` compiles
-/// with its real body.
+/// Referenced only by the dead `new_edge` free-list helper.
 #[derive(Copy, Clone, Debug, Default)]
 pub struct RouteEdge;
 
@@ -191,7 +187,6 @@ impl FrameworkRouter {
             ty.abs_root = strings::paths::without_trailing_slash_windows_path(&ty.abs_root).into();
             debug_assert!(strings::has_prefix(&ty.abs_root, root));
 
-            // PERF(port): was appendAssumeCapacity
             routes.push(Route {
                 part: Part::Text(b""),
                 r#type: TypeIndex::init(u8::try_from(type_index).expect("int cast")),
@@ -222,11 +217,12 @@ impl FrameworkRouter {
     pub fn memory_cost(&self) -> usize {
         let mut cost: usize = size_of::<FrameworkRouter>();
         cost += self.routes.capacity() * size_of::<Route>();
-        // TODO(port): StaticRouteMap/DynamicRouteMap DataList::capacity_in_bytes equivalent
-        // (`bun_collections::ArrayHashMap` does not yet expose capacity_in_bytes; approximate as 0).
-        // cost += self.static_routes.capacity_in_bytes();
-        // cost += self.dynamic_routes.capacity_in_bytes();
-        let _ = (&self.static_routes, &self.dynamic_routes);
+        // The `ArrayHashMap` stores three column `Vec`s (keys, values, 32-bit
+        // hashes), so the footprint is `capacity * (sizeof K + sizeof V + sizeof u32)`.
+        cost += self.static_routes.capacity()
+            * (size_of::<Box<[u8]>>() + size_of::<RouteIndex>() + size_of::<u32>());
+        cost += self.dynamic_routes.capacity()
+            * (size_of::<EncodedPattern>() + size_of::<RouteIndex>() + size_of::<u32>());
         cost
     }
 
@@ -646,14 +642,10 @@ pub enum Style {
     JavascriptDefined(Strong),
 }
 
-// PORT NOTE: Zig copies `Style` by value (bitwise), which for the
-// `.javascript_defined` arm shallow-copies the `jsc.Strong.Optional` pointer —
-// both copies alias the same C++ StrongRef and only one `deinit()` is ever
-// called. In Rust `Strong` has `Drop`, so a bitwise copy would double-free.
-// The built-in styles are trivially copyable; the JS-defined arm is an
-// unimplemented feature in the Zig source as well (`Style.parse` does
-// `@panic("TODO: customizable Style")`), so cloning it is unreachable today.
-// Mirror the Zig `@panic` message instead of inventing unsafe aliasing.
+// The built-in styles are trivially copyable; the `JavascriptDefined` arm owns
+// a `Strong` (Drop type), so a shallow copy would double-free. That arm is an
+// unimplemented feature (`Style::from_js` never produces it), so cloning it is
+// unreachable today.
 impl Clone for Style {
     fn clone(&self) -> Self {
         match self {
@@ -661,7 +653,6 @@ impl Clone for Style {
             Style::NextjsAppUi => Style::NextjsAppUi,
             Style::NextjsAppRoutes => Style::NextjsAppRoutes,
             Style::JavascriptDefined(_) => {
-                // Matches Zig `Style.parse`: `@panic("TODO: customizable Style")`.
                 panic!("TODO: customizable Style")
             }
         }
@@ -677,11 +668,9 @@ pub(crate) static STYLE_MAP: phf::Map<&'static [u8], fn() -> Style> = phf::phf_m
 pub(crate) const STYLE_ERROR_MESSAGE: &str = "'style' must be either \"nextjs-pages\", \"nextjs-app-ui\", \"nextjs-app-routes\", or a function.";
 
 impl Style {
-    // TODO(port): move to *_jsc — calls JSValue methods
     pub fn from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<Style> {
         if value.is_string() {
             let bun_string = bun_core::OwnedString::new(value.to_bun_string(global)?);
-            // PERF(port): was stack-fallback allocator
             let utf8 = bun_string.to_utf8();
             if let Some(style) = STYLE_MAP.get(utf8.slice()) {
                 return Ok(style());
@@ -1050,8 +1039,7 @@ pub enum InsertError {
 }
 bun_core::oom_from_alloc!(InsertError);
 
-// PERF(port): Zig used `comptime insertion_kind` with dependent type `insertion_kind.Pattern()`.
-// Rust models this as a runtime enum carrying both pattern shapes; profile if hot.
+// Runtime enum carrying both pattern shapes; profile if hot.
 pub enum InsertPattern {
     Static(StaticPattern),
     Dynamic(EncodedPattern),
@@ -1082,7 +1070,7 @@ impl FrameworkRouter {
             InsertPattern::Static(p) => (Some(p.iterate()), None),
             InsertPattern::Dynamic(p) => (None, Some(p.iterate())),
         };
-        // PORT NOTE: a closure can't express that the returned `Part<'a>` borrows from the
+        // Note: a closure can't express that the returned `Part<'a>` borrows from the
         // iterator's `'a` (Rust infers fresh anon lifetimes per `'_`). Use a local fn item.
         fn next_part<'a>(
             s: &mut Option<StaticPatternIterator<'a>>,
@@ -1101,7 +1089,6 @@ impl FrameworkRouter {
             };
 
             let mut route_index = root_route;
-            // PORT NOTE: reshaped for borrowck — Zig held `route: *Route`; we re-fetch via index.
             'outer: loop {
                 let mut next = self.route_ptr(route_index).first_child;
                 while let Some(current) = next {
@@ -1205,16 +1192,15 @@ impl FrameworkRouter {
     }
 }
 
-// TODO(port): lifetime — Part stored in Route borrows from pattern_string_arena.
-// Zig stored borrowed slices; here we keep raw slices via the same arena. The
-// `to_owned_part` helper exists to detach the borrow lifetime when stored in `Route`.
+// `Part` stored in `Route` borrows from the router's own `pattern_string_arena`.
+// Rust cannot express that self-referential borrow, so `to_owned_part` detaches
+// the lifetime when storing into `Route`.
 impl<'a> Part<'a> {
     /// Detach the borrow lifetime so this `Part` can be stored in `Route`.
     ///
     /// # Safety
     /// Every payload slice must point into `FrameworkRouter::pattern_string_arena`
     /// (or other storage that outlives the owning `FrameworkRouter`).
-    /// TODO(refactor): model this with a `'bump` lifetime instead of `'static`.
     #[allow(unsafe_op_in_unsafe_fn)]
     unsafe fn to_owned_part(self) -> Part<'static> {
         // Variant-by-variant detach (no bitcast). `d` stays `unsafe fn` so a
@@ -1248,7 +1234,7 @@ pub struct MatchedParams {
 #[derive(Copy, Clone)]
 pub struct MatchedParamEntry {
     // Borrow from the input `path`/`pattern` buffers; both outlive the
-    // `MatchedParams` stack frame (Zig: `[]const u8`). See `RawSlice` invariant.
+    // `MatchedParams` stack frame. See `RawSlice` invariant.
     pub key: bun_ptr::RawSlice<u8>,
     pub value: bun_ptr::RawSlice<u8>,
 }
@@ -1258,7 +1244,6 @@ impl MatchedParams {
 
     /// Convert the matched params to a JavaScript object
     /// Returns null if there are no params
-    // TODO(port): move to *_jsc
     pub fn to_js(&self, global: &JSGlobalObject) -> JSValue {
         let params_array = self.params.const_slice();
 
@@ -1377,7 +1362,7 @@ impl TinyLog {
 
     pub fn write(&mut self, args: fmt::Arguments<'_>) {
         use std::io::Write as _;
-        // PORT NOTE: BoundedArray exposes no `buffer_mut()`; format into a stack
+        // Note: BoundedArray exposes no `buffer_mut()`; format into a stack
         // scratch buffer (same capacity) and copy into the BoundedArray.
         let mut buf = [0u8; TINY_LOG_CAP];
         let mut cursor: &mut [u8] = &mut buf[..];
@@ -1443,9 +1428,7 @@ impl TinyLog {
     }
 }
 
-/// Local shim — `bun_core::io::Writer` exposes only `write_all`/`print`; the
-/// Zig writer interface had `splatByteAll`/`splatBytesAll`. Implement here so
-/// `TinyLog::print` keeps its body verbatim.
+/// Local shim — `bun_core::io::Writer` exposes only `write_all`/`print`.
 fn writer_splat_byte_all(
     w: &mut bun_core::io::Writer,
     byte: u8,
@@ -1473,9 +1456,6 @@ fn writer_splat_bytes_all(
 }
 
 /// Interface for connecting FrameworkRouter to another codebase
-// PORT NOTE: Zig's `InsertionContext` was an `*anyopaque` + `*const VTable` pair, with `wrap()`
-// generating a comptime vtable per concrete type. Per LIFETIMES.tsv this is BORROW_PARAM →
-// `&mut dyn InsertionHandler`. The trait below replaces the manual vtable.
 pub trait InsertionHandler {
     fn get_file_id_for_router(
         &mut self,
@@ -1494,21 +1474,19 @@ pub trait InsertionHandler {
     ) -> Result<(), AllocError>;
 }
 
-/// Port of Zig `bun.StringHashMapContext` (`std.hash.Wyhash` final4, seed 0).
+/// Hash context (wyhash final4, seed 0) for the `zig_hash_map` rebuild below.
 ///
 /// `scan_inner` walks `DirEntry.data` to discover routes; the resulting child
-/// order is the map's iteration order. In Zig that map is a
-/// `std.HashMapUnmanaged([]const u8, *Entry, StringHashMapContext, 80)`, whose
-/// linear-probe bucket walk is what `test/bake/framework-router.test.ts`
-/// snapshots. The Rust `EntryMap` is a `std::collections::HashMap`, which has
-/// a different layout, so we rebuild into a `zig_hash_map` keyed/hashed
-/// identically before iterating.
+/// order is the map's iteration order, and the linear-probe bucket walk is
+/// what `test/bake/framework-router.test.ts` snapshots. `EntryMap` is a
+/// `std::collections::HashMap`, which has a different layout, so we rebuild
+/// into a `zig_hash_map` keyed/hashed deterministically before iterating.
 struct ZigStringHashContext;
 impl bun_collections::zig_hash_map::HashContext<Box<[u8]>> for ZigStringHashContext {
     #[inline]
     fn ctx_hash(key: &Box<[u8]>) -> u64 {
-        // Zig: `std.hash.Wyhash.hash(0, s)` — `bun_wyhash::hash` is the final4
-        // variant with seed 0. (Don't route through `auto_hash`/`OneShotHasher`
+        // `bun_wyhash::hash` is the wyhash final4 variant with seed 0.
+        // (Don't route through `auto_hash`/`OneShotHasher`
         // here: Rust's `<[u8] as Hash>` mixes in a length prefix, which would
         // shift the bucket layout the snapshot below depends on.)
         bun_wyhash::hash(key)
@@ -1526,7 +1504,6 @@ impl FrameworkRouter {
         r: &mut Resolver,
         ctx: &mut dyn InsertionHandler,
     ) -> Result<(), AllocError> {
-        // PORT NOTE: reshaped for borrowck — Zig held `t: *const Type`; we re-fetch via index.
         let abs_root: Box<[u8]> = self.types[ty.get() as usize].abs_root.clone();
         debug_assert!(!abs_root.ends_with(b"/"));
         debug_assert!(paths::is_absolute(&abs_root));
@@ -1555,15 +1532,14 @@ impl FrameworkRouter {
         let fs_impl = unsafe { core::ptr::addr_of_mut!((*fs).fs) };
 
         if let Some(entries) = dir_info.get_entries_const() {
-            // PORT NOTE: `entries.data` is backed by `std::collections::HashMap`,
-            // whose iteration order differs from Zig's `std.HashMapUnmanaged`.
-            // The route-tree child order is this iteration order (see `insert`),
-            // and `test/bake/framework-router.test.ts` snapshots it. Rebuild into
-            // a Zig-layout map (same wyhash/seed/probe) so the walk matches the
-            // spec. Absent hash collisions (the common case for small dirs) the
-            // bucket order is fully determined by the hash, so re-insertion order
-            // is irrelevant; with collisions it may diverge from Zig's readdir-
-            // order placement, but no test exercises that today.
+            // Note: `entries.data` is backed by `std::collections::HashMap`,
+            // whose iteration order is unspecified. The route-tree child order
+            // is this iteration order (see `insert`), and
+            // `test/bake/framework-router.test.ts` snapshots it. Rebuild into a
+            // `zig_hash_map` (fixed wyhash/seed/probe) so the walk order is
+            // deterministic. Absent hash collisions (the common case for small
+            // dirs) the bucket order is fully determined by the hash, so
+            // re-insertion order is irrelevant.
             let mut zig_order: bun_collections::zig_hash_map::HashMap<
                 Box<[u8]>,
                 *mut bun_resolver::fs::Entry,
@@ -1579,7 +1555,7 @@ impl FrameworkRouter {
                 // outlive this scan and are serialized via `RealFS.entries_mutex`.
                 let file = unsafe { &*file_ptr };
                 let base = file.base();
-                // PORT NOTE: reshaped for borrowck — fetch type fields fresh each iteration.
+                // Note: reshaped for borrowck — fetch type fields fresh each iteration.
                 // SAFETY: `Entry::kind` mutates only the entry's lazily-cached kind; `file_ptr`
                 // is the unique live reference to this entry during the scan, and `fs_impl`
                 // points at the process-global FS implementation.
@@ -1649,11 +1625,10 @@ impl FrameworkRouter {
                         };
 
                         let mut log = TinyLog::empty();
-                        // Spec FrameworkRouter.zig: `defer arena_state.reset(
-                        // .retain_capacity)`. Handled at the end of every arm
-                        // via `reset_retain_with_limit(8M)` — keep the
-                        // `mi_heap` warm between directory entries instead of
-                        // paying `mi_heap_destroy + mi_heap_new` per file.
+                        // The arena is reset at the end of every arm via
+                        // `reset_retain_with_limit(8M)` — keep the `mi_heap`
+                        // warm between directory entries instead of paying
+                        // `mi_heap_destroy + mi_heap_new` per file.
                         let parse_result =
                             t.style
                                 .parse(rel_path, ext, &mut log, t.allow_layouts, arena_state);
@@ -1709,7 +1684,6 @@ impl FrameworkRouter {
                             }
                         };
 
-                        // PERF(port): was comptime bool dispatch on `param_count > 0` — profile if hot
                         let result = if param_count > 0 {
                             let pattern = EncodedPattern::init_from_parts(
                                 parsed.parts,
@@ -1797,11 +1771,8 @@ pub struct StoredParseError {
     pub log: TinyLog,
 }
 
-// TODO(port): jsc.Codegen.JSFrameworkFileSystemRouter — codegen wires toJS/fromJS via #[bun_jsc::JsClass]
-
 impl JSFrameworkRouter {
     pub fn get_bindings(global: &JSGlobalObject) -> JsResult<JSValue> {
-        // TODO(port): jsc.JSObject.create with struct literal — needs builder API
         let obj = JSValue::create_empty_object(global, 2);
         obj.put(
             global,
@@ -1818,7 +1789,7 @@ impl JSFrameworkRouter {
         Ok(obj)
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` — `#[bun_jsc::JsClass]` on the struct
+    // Note: no `#[bun_jsc::host_fn]` — `#[bun_jsc::JsClass]` on the struct
     // emits the construct shim that calls `<Self>::constructor(__g, __f)` directly.
     pub fn constructor(
         global: &JSGlobalObject,
@@ -1840,8 +1811,8 @@ impl JSFrameworkRouter {
             opts.get(global, "style")?.unwrap_or(JSValue::UNDEFINED),
             global,
         )?;
-        // Zig's `errdefer style.deinit()` is implicit: `Style` owns a `Strong` (Drop type),
-        // so `?` on any error path below drops it automatically.
+        // `Style` owns a `Strong` (Drop type), so `?` on any error path below
+        // drops it automatically.
 
         let abs_root: Box<[u8]> = strings::without_trailing_slash(paths::resolve_path::join_abs::<
             paths::platform::Auto,
@@ -1877,9 +1848,8 @@ impl JSFrameworkRouter {
         });
 
         let resolver = &mut global.bun_vm().as_mut().transpiler.resolver;
-        // PORT NOTE: reshaped for borrowck — Zig passes `jsfr` as both the router owner and the
-        // insertion-context. The handler only touches `files`/`stored_parse_errors`, so
-        // split-borrow those two fields into a dedicated context (see `JSFrameworkRouterScanCtx`).
+        // The handler only touches `files`/`stored_parse_errors`, so split-borrow
+        // those two fields into a dedicated context (see `JSFrameworkRouterScanCtx`).
         {
             let JSFrameworkRouter {
                 router,
@@ -1920,7 +1890,6 @@ impl JSFrameworkRouter {
             params: BoundedArray::default(),
         };
         if let Some(index) = self.router.match_slow(path.slice(), &mut params_out) {
-            // PERF(port): was stack-fallback allocator
             let obj = JSValue::create_empty_object(global, 2);
             obj.put(
                 global,
@@ -1947,7 +1916,6 @@ impl JSFrameworkRouter {
 
     #[bun_jsc::host_fn(method)]
     pub fn to_json(&self, global: &JSGlobalObject, _callframe: &CallFrame) -> JsResult<JSValue> {
-        // PERF(port): was stack-fallback allocator
         self.route_to_json(global, RouteIndex::init(0))
     }
 
@@ -2023,7 +1991,6 @@ impl JSFrameworkRouter {
     }
 
     pub fn parse_route_pattern(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-        // PERF(port): was arena bulk-free
         let arena = Arena::new();
 
         if frame.arguments_count() < 2 {
@@ -2094,7 +2061,7 @@ impl JSFrameworkRouter {
     }
 }
 
-// PORT NOTE: free-function host-fn shim — `#[bun_jsc::host_fn]` (Free kind) emits a
+// Note: free-function host-fn shim — `#[bun_jsc::host_fn]` (Free kind) emits a
 // shim that calls the bare ident, so this cannot live inside the `impl` block.
 #[bun_jsc::host_fn]
 pub(crate) fn parse_route_pattern(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
@@ -2103,11 +2070,10 @@ pub(crate) fn parse_route_pattern(global: &JSGlobalObject, frame: &CallFrame) ->
 
 use bun_core::fmt::VecWriter as ByteFmtWriter;
 
-// PORT NOTE: reshaped for borrowck. Zig's `InsertionContext.wrap(JSFrameworkRouter, jsfr)`
-// needs `&mut jsfr.router` (for `scan`) and `&mut *jsfr` (as the handler) simultaneously.
-// The handler only touches `files` / `stored_parse_errors`, so we split-borrow those two
-// fields into a dedicated context struct instead of implementing the trait on
-// `JSFrameworkRouter` itself.
+// `scan` needs `&mut jsfr.router` and the insertion handler simultaneously.
+// The handler only touches `files` / `stored_parse_errors`, so we split-borrow
+// those two fields into a dedicated context struct instead of implementing the
+// trait on `JSFrameworkRouter` itself.
 struct JSFrameworkRouterScanCtx<'a> {
     files: &'a mut Vec<bun_core::String>,
     stored_parse_errors: &'a mut Vec<StoredParseError>,
@@ -2141,10 +2107,6 @@ impl InsertionHandler for JSFrameworkRouterScanCtx<'_> {
         _other_id: OpaqueFileId,
         _file_kind: FileKind,
     ) -> Result<(), AllocError> {
-        // Zig's `InsertionContext.wrap()` emits `@panic("TODO: onRouterCollisionError for " ++ @typeName(T))`
-        // when `T` does not declare `onRouterCollisionError`. JSFrameworkRouter does not declare it.
         panic!("TODO: onRouterCollisionError for JSFrameworkRouter")
     }
 }
-
-// ported from: src/bake/FrameworkRouter.zig
diff --git a/src/runtime/bake/bake_body.rs b/src/runtime/bake/bake_body.rs
index 4cd80cba91c..8d28a1bc91d 100644
--- a/src/runtime/bake/bake_body.rs
+++ b/src/runtime/bake/bake_body.rs
@@ -24,18 +24,18 @@ use bun_paths::{self as paths, PathBuffer};
 pub(crate) use crate::api::js_bundler::Plugin;
 use crate::api::js_bundler::js_bundler::PluginJscExt as _;
 
-// PORT NOTE: parent `mod.rs` already declares `dev_server` / `framework_router`
+// Note: parent `mod.rs` already declares `dev_server` / `framework_router`
 // as sibling modules of this file; pull them in instead of re-declaring (which
 // would duplicate the module tree and fail on `framework_router` having no
 // matching filename).
 use super::{dev_server, framework_router};
 
-// PORT NOTE: `pub use dev_server as DevServer` / `framework_router as
+// Note: `pub use dev_server as DevServer` / `framework_router as
 // FrameworkRouter` are already provided by the parent `mod.rs` (lines 349/369);
 // re-exporting here triggers E0365 because `bake_body` is a private module.
 
-/// `JSValue.getOptional(ZigString.Slice, ..)` — local shim until `bun_jsc`
-/// grows a typed `get_optional`. Returns `None` for missing/null/undefined.
+/// Local shim until `bun_jsc` grows a typed `get_optional`.
+/// Returns `None` for missing/null/undefined.
 fn get_optional_slice(
     target: JSValue,
     global: &JSGlobalObject,
@@ -98,14 +98,14 @@ fn get_function(
 use bun_bundler_jsc::source_map_mode_jsc::source_map_mode_from_js;
 
 /// Convert a `bun_core::Error` into a thrown JS exception in a `JsResult`
-/// context. Mirrors Zig `globalThis.throwError(err, msg)`.
+/// context.
 #[inline]
 fn throw_core_error(global: &JSGlobalObject, e: bun_core::Error, ctx: &'static str) -> JsError {
     global.throw_error(e, ctx)
 }
 
 /// Erase the `'bump` lifetime of an arena-backed slice. Arena-erasure
-/// convention (see file-level TODO(port)): `UserOptions.arena` outlives every
+/// convention (see file-level TODO(lifetime)): `UserOptions.arena` outlives every
 /// borrower, so the bytes are valid for the program-relevant lifetime.
 #[inline(always)]
 pub(crate) fn arena_erase<T: ?Sized>(r: &T) -> &'static T {
@@ -115,9 +115,9 @@ pub(crate) fn arena_erase<T: ?Sized>(r: &T) -> &'static T {
     unsafe { bun_ptr::detach_ref(r) }
 }
 
-/// `arena.dupeZ(u8, bytes)` — copy `bytes` + trailing NUL into the bump arena.
+/// Copy `bytes` plus a trailing NUL into the bump arena.
 /// Returns `&'static ZStr` per the file-level `'static` convention
-/// (arena-backed; lifetime erased — see TODO(port) at top of file).
+/// (arena-backed; lifetime erased — see TODO(lifetime) at top of file).
 pub(crate) fn arena_dupe_z(arena: &Arena, bytes: &[u8]) -> &'static ZStr {
     let buf: &mut [u8] = arena.alloc_slice_fill_default(bytes.len() + 1);
     buf[..bytes.len()].copy_from_slice(bytes);
@@ -132,18 +132,18 @@ pub(crate) fn arena_dupe_z(arena: &Arena, bytes: &[u8]) -> &'static ZStr {
 /// export default { app: ... };
 pub(crate) const API_NAME: &str = "app";
 
-// TODO(port): lifetime — many `&'static [u8]` fields below are actually backed
+// TODO(lifetime): many `&'static [u8]` fields below are actually backed
 // by `UserOptions.arena` (bumpalo::Bump) or `UserOptions.allocations`
 // (StringRefList). `&'static` is used to avoid struct lifetime params per
 // PORTING.md; could thread `'bump` or introduce `ArenaStr`.
 
-/// Zig version of the TS definition 'Bake.Options' in 'bake.d.ts'
+/// Rust version of the TS definition 'Bake.Options' in 'bake.d.ts'
 pub struct UserOptions {
     /// This arena contains some miscellaneous allocations at startup
     pub arena: Arena,
     pub allocations: StringRefList,
 
-    pub root: &'static ZStr, // TODO(port): arena-owned, self-referential with .arena
+    pub root: &'static ZStr, // TODO(lifetime): arena-owned, self-referential with .arena
     pub framework: Framework,
     pub bundler_options: SplitBundlerOptions,
 }
@@ -164,7 +164,6 @@ impl Drop for UserOptions {
 
 impl UserOptions {
     /// Currently, this function must run at the top of the event loop.
-    // TODO(port): narrow error set
     pub fn from_js(config: JSValue, global: &JSGlobalObject) -> JsResult<UserOptions> {
         let arena = Arena::new();
         // errdefer arena.deinit() — handled by Drop
@@ -194,7 +193,7 @@ impl UserOptions {
                         .map_err(|e| throw_core_error(global, e, "Framework::react"))?;
 
                     return Ok(UserOptions {
-                        // TODO(port): self-referential — `root`/`framework` borrow `arena`
+                        // TODO(lifetime): self-referential — `root`/`framework` borrow `arena`
                         root,
                         framework,
                         bundler_options,
@@ -275,12 +274,12 @@ impl StringRefList {
         strings: Vec::new(),
     };
 
-    // PORT NOTE: returned slice borrows JSC-owned storage kept alive by the
+    // Note: returned slice borrows JSC-owned storage kept alive by the
     // `ZigStringSlice` now stored in `self.strings`; it is valid only for as
     // long as `self` is. Callers that store the result in `Framework` /
     // `FileSystemRouterType` / `ServerComponents` fields must thread a `'bump`
     // lifetime (or switch those fields to `Box<[u8]>` / `ArenaStr`) — see the
-    // file-level TODO(port) above. Do NOT paper over this with a `'static`
+    // file-level TODO(lifetime) above. Do NOT paper over this with a `'static`
     // transmute (forbidden per PORTING.md §Forbidden — lifetime extension).
     pub fn track(&mut self, str: ZigStringSlice) -> &'static [u8] {
         self.strings.push(str);
@@ -293,7 +292,7 @@ impl StringRefList {
         // / `ServerComponents` fields that are themselves owned by the same
         // `UserOptions`, so no read outlives the holder. NOT process-lifetime
         // — a real `'bump` lifetime should eventually be threaded here (see
-        // file-level TODO(port)); `assume` makes the lie grep-able until then.
+        // file-level TODO(lifetime)); `assume` makes the lie grep-able until then.
         unsafe { bun_ptr::Interned::assume(slice) }.as_bytes()
     }
 }
@@ -307,7 +306,7 @@ pub struct SplitBundlerOptions {
 }
 
 impl SplitBundlerOptions {
-    // PORT NOTE: was `pub const EMPTY` — `ArrayHashMap::new()` (inside
+    // Note: was `pub const EMPTY` — `ArrayHashMap::new()` (inside
     // `BuildConfigSubset`) is not `const fn`, so this is now a fn-backed
     // default. Callers updated to `SplitBundlerOptions::default()`.
 
@@ -316,9 +315,8 @@ impl SplitBundlerOptions {
         plugin_array: JSValue,
         global: &JSGlobalObject,
     ) -> JsResult<()> {
-        // Spec (bake.zig:149-150): create the Plugin and assign it to
-        // `opts.plugin` BEFORE iterating, so `plugins: []` still leaves
-        // `self.plugin = Some(_)`.
+        // Create the Plugin and assign it to `opts.plugin` BEFORE iterating,
+        // so `plugins: []` still leaves `self.plugin = Some(_)`.
         let plugin: NonNull<Plugin> = match self.plugin {
             Some(p) => p,
             None => {
@@ -455,7 +453,7 @@ impl BuildConfigSubset {
 
 impl Default for BuildConfigSubset {
     fn default() -> Self {
-        // PORT NOTE: was `pub const DEFAULT` — `ArrayHashMap::new()` is not
+        // Note: was `pub const DEFAULT` — `ArrayHashMap::new()` is not
         // `const fn`, so this lives behind `Default` instead.
         BuildConfigSubset {
             loader: None,
@@ -482,10 +480,9 @@ impl Default for BuildConfigSubset {
 /// Full documentation on these fields is located in the TypeScript definitions.
 pub struct Framework {
     pub is_built_in_react: bool,
-    /// Spec (bake.zig:248) is `[]FileSystemRouterType` — a *mutable*
-    /// arena-owned slice that `resolve()` rewrites in place. Stored as an
-    /// owned `Vec` so `#[derive(Clone)]` deep-copies (a shared `&[T]` would
-    /// alias and make `resolve()`'s mutation UB).
+    /// `resolve()` rewrites this in place. Stored as an owned `Vec` so
+    /// `#[derive(Clone)]` deep-copies (a shared `&[T]` would alias and make
+    /// `resolve()`'s mutation UB).
     pub file_system_router_types: Vec<FileSystemRouterType>,
     // static_routers: &'static [&'static [u8]],
     pub server_components: Option<ServerComponents>,
@@ -548,7 +545,7 @@ impl Framework {
             }],
             // .static_routers = arena.alloc_slice_copy(&[b"public"]),
             built_in_modules: {
-                // PORT NOTE: was `ArrayHashMap::from_entries(arena, keys, vals)`;
+                // Note: was `ArrayHashMap::from_entries(arena, keys, vals)`;
                 // that constructor doesn't exist on the heap-backed
                 // `ArrayHashMap` — build it imperatively. `bun.handleOom`.
                 let keys: [&'static [u8]; 3] = [
@@ -606,7 +603,7 @@ impl Framework {
         Ok(fw)
     }
 
-    /// Unopinionated default. PORT NOTE: was `pub const NONE` —
+    /// Unopinionated default. Note: was `pub const NONE` —
     /// `ArrayHashMap::new()` is not `const fn`.
     pub fn none() -> Framework {
         Framework {
@@ -898,7 +895,7 @@ impl Framework {
                     )));
                 }
 
-                let path = match get_optional_string(file, global, b"import", refs, arena)? {
+                let path = match get_optional_string(file, global, b"import", refs)? {
                     Some(p) => p,
                     None => {
                         return Err(global.throw_invalid_arguments(format_args!(
@@ -908,20 +905,18 @@ impl Framework {
                     }
                 };
 
-                let value: BuiltInModule = if let Some(str) =
-                    get_optional_string(file, global, b"path", refs, arena)?
-                {
-                    BuiltInModule::Import(str)
-                } else if let Some(str) = get_optional_string(file, global, b"code", refs, arena)? {
-                    BuiltInModule::Code(str)
-                } else {
-                    return Err(global.throw_invalid_arguments(format_args!(
-                        "'builtInModules[{}]' needs either 'path' or 'code'",
-                        i
-                    )));
-                };
+                let value: BuiltInModule =
+                    if let Some(str) = get_optional_string(file, global, b"path", refs)? {
+                        BuiltInModule::Import(str)
+                    } else if let Some(str) = get_optional_string(file, global, b"code", refs)? {
+                        BuiltInModule::Code(str)
+                    } else {
+                        return Err(global.throw_invalid_arguments(format_args!(
+                            "'builtInModules[{}]' needs either 'path' or 'code'",
+                            i
+                        )));
+                    };
 
-                // PERF(port): was assume_capacity
                 files.put_assume_capacity(path, value);
                 i += 1;
             }
@@ -943,15 +938,16 @@ impl Framework {
                     "Framework can only define up to 256 file-system router types"
                 )));
             }
-            // PORT NOTE: reshaped alloc+index → Vec::push (owned; deep-cloned with Framework)
+            // Note: reshaped alloc+index → Vec::push (owned; deep-cloned with Framework)
             let mut file_system_router_types = Vec::with_capacity(len as usize);
 
             let mut it = array.array_iterator(global)?;
             let mut i: usize = 0;
-            // TODO(port): errdefer for (file_system_router_types[0..i]) |*fsr| fsr.style.deinit();
-            // — Style should impl Drop; bumpalo Vec drop will handle this if so.
+            // On the error path, dropping the `Vec` drops each `Style`, which
+            // releases the `Strong` held by its `JavascriptDefined` arm (the
+            // only owning variant; the named styles are unit-like).
             while let Some(fsr_opts) = it.next()? {
-                let root = match get_optional_string(fsr_opts, global, b"root", refs, arena)? {
+                let root = match get_optional_string(fsr_opts, global, b"root", refs)? {
                     Some(r) => r,
                     None => {
                         return Err(global.throw_invalid_arguments(format_args!(
@@ -960,25 +956,20 @@ impl Framework {
                         )));
                     }
                 };
-                let server_entry_point = match get_optional_string(
-                    fsr_opts,
-                    global,
-                    b"serverEntryPoint",
-                    refs,
-                    arena,
-                )? {
-                    Some(s) => s,
-                    None => {
-                        return Err(global.throw_invalid_arguments(format_args!(
-                            "'fileSystemRouterTypes[{}]' is missing 'serverEntryPoint'",
-                            i
-                        )));
-                    }
-                };
+                let server_entry_point =
+                    match get_optional_string(fsr_opts, global, b"serverEntryPoint", refs)? {
+                        Some(s) => s,
+                        None => {
+                            return Err(global.throw_invalid_arguments(format_args!(
+                                "'fileSystemRouterTypes[{}]' is missing 'serverEntryPoint'",
+                                i
+                            )));
+                        }
+                    };
                 let client_entry_point =
-                    get_optional_string(fsr_opts, global, b"clientEntryPoint", refs, arena)?;
+                    get_optional_string(fsr_opts, global, b"clientEntryPoint", refs)?;
                 let prefix =
-                    get_optional_string(fsr_opts, global, b"prefix", refs, arena)?.unwrap_or(b"/");
+                    get_optional_string(fsr_opts, global, b"prefix", refs)?.unwrap_or(b"/");
                 let ignore_underscores =
                     get_boolean_strict(fsr_opts, global, b"ignoreUnderscores")?.unwrap_or(false);
                 let layouts = get_boolean_strict(fsr_opts, global, b"layouts")?.unwrap_or(false);
@@ -1030,7 +1021,7 @@ impl Framework {
                                 extensions.push(if slice[0] == b'.' {
                                     slice
                                 } else {
-                                    // PERF(port): std.mem.concat into arena
+                                    // Concatenate "." + slice into the arena.
                                     let mut v = bun_alloc::ArenaVec::<u8>::with_capacity_in(
                                         1 + slice.len(),
                                         arena,
@@ -1112,10 +1103,9 @@ impl Framework {
     }
 
     /// Project the fields the bundler reads into the lower-tier
-    /// `bun_bundler::bake_types::Framework` view. Spec bake.zig stores the
-    /// `bake.Framework` pointer directly on `BundleOptions.framework`; in the
-    /// Rust port the bundler crate cannot name `bun_runtime::bake::Framework`
-    /// so it carries a TYPE_ONLY subset that we populate here.
+    /// `bun_bundler::bake_types::Framework` view. The bundler crate cannot
+    /// name `bun_runtime::bake::Framework`, so it carries a TYPE_ONLY subset
+    /// that we populate here.
     pub(crate) fn as_bundler_view(&self) -> bun_bundler::bake_types::Framework {
         use bun_bundler::bake_types as bt;
         let mut built_in_modules = bun_collections::StringArrayHashMap::new();
@@ -1195,22 +1185,19 @@ impl Framework {
         minify_syntax: Option<bool>,
         minify_identifiers: Option<bool>,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig built `ASTMemoryAllocator.Scope` by hand and called
-        // `enter`/`exit`; the Rust port collapses that to `ASTMemoryAllocator::enter`
-        // returning the RAII `Scope`, whose `Drop` runs `exit()` at end-of-fn
-        // (Zig's `defer ast_scope.exit()`).
+        // `ASTMemoryAllocator::enter` returns an RAII `Scope` whose `Drop`
+        // runs `exit()` at end-of-fn.
         let mut ast_memory_allocator = bun_ast::ASTMemoryAllocator::borrowing(arena);
         let _ast_scope = ast_memory_allocator.enter();
 
-        // PORT NOTE: Zig passed `out: *Transpiler` pointing at `= undefined`
-        // memory and assigned `out.* = try Transpiler.init(...)`. In Rust the
-        // caller (`DevServer::init`) hands us an uninitialized slot, so use
-        // `MaybeUninit::write` (no drop of prior bytes) then reborrow as
+        // The caller (`DevServer::init`) hands us an uninitialized slot, so
+        // use `MaybeUninit::write` (no drop of prior bytes) then reborrow as
         // `&mut Transpiler` for the field assignments below.
         let out: &mut bun_bundler::Transpiler = out.write(bun_bundler::Transpiler::init(
             arena,
             log,
-            // TODO(port): std.mem.zeroes(TransformOptions) — verify all-zero is valid
+            // `TransformOptions::default()`: every `Option` is `None`, every
+            // slice empty, every scalar zero/false.
             bun_schema::api::TransformOptions::default(),
             None,
         )?);
@@ -1267,11 +1254,10 @@ impl Framework {
         out.options.minify_identifiers = minify_identifiers.unwrap_or(mode != Mode::Development);
         out.options.minify_whitespace = minify_whitespace.unwrap_or(mode != Mode::Development);
         out.options.css_chunking = true;
-        // Spec bake.zig:778 `out.options.framework = framework` stores a borrowed
-        // `*bake.Framework`. The bundler crate (lower tier) carries a TYPE_ONLY
-        // projection (`bake_types::Framework`); construct it here and give it
-        // arena lifetime so `BundleOptions<'a>` can borrow it for the bundle pass.
-        // PERF(port): interior `Box<[u8]>` in the projection are not dropped by
+        // The bundler crate (lower tier) carries a TYPE_ONLY projection
+        // (`bake_types::Framework`); construct it here and give it arena
+        // lifetime so `BundleOptions<'a>` can borrow it for the bundle pass.
+        // NOTE: interior `Box<[u8]>` in the projection are not dropped by
         // bumpalo — bounded per-session, revisit when `bake_types::BuiltInModule`
         // is reshaped to `&'a [u8]`.
         out.options.framework = Some(&*arena.alloc(self.as_bundler_view()));
@@ -1285,9 +1271,9 @@ impl Framework {
             out.options.env.behavior = bundler_options.env;
             out.options.env.prefix = bundler_options.env_prefix.unwrap_or(b"").into();
         }
-        // Spec bake.zig:788 `out.resolver.opts = out.options` (struct copy). The
-        // resolver crate carries a FORWARD_DECL subset of `BundleOptions`, so
-        // re-project via the dedicated helper rather than `Clone`.
+        // The resolver crate carries a FORWARD_DECL subset of
+        // `BundleOptions`, so re-project via the dedicated helper rather than
+        // `Clone`.
         out.sync_resolver_opts();
 
         out.configure_linker();
@@ -1338,8 +1324,8 @@ impl Framework {
             out.options.asset_naming = b"_bun/[hash].[ext]".as_slice().into();
         }
 
-        // Spec bake.zig:821 — re-sync after define/naming mutations so the
-        // resolver sees the final option set.
+        // Re-sync after define/naming mutations so the resolver sees the
+        // final option set.
         out.sync_resolver_opts();
         Ok(())
     }
@@ -1413,10 +1399,8 @@ fn resolve_or_null(r: &mut bun_resolver::Resolver, path: &[u8]) -> Option<&'stat
     }
 }
 
-/// `FrameworkRouter.Style.fromJS` (FrameworkRouter.zig:159-181). Thin
-/// forwarding shim — the real impl lives on `framework_router::Style::from_js`
-/// now that `FrameworkRouter.rs` is un-gated; kept so the call site in
-/// `Framework::from_js` reads the same as the Zig spec.
+/// Thin forwarding shim — the real impl lives on
+/// `framework_router::Style::from_js`.
 #[inline]
 fn style_from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<framework_router::Style> {
     framework_router::Style::from_js(value, global)
@@ -1427,7 +1411,6 @@ fn get_optional_string(
     global: &JSGlobalObject,
     property: &[u8],
     allocations: &mut StringRefList,
-    arena: &Arena,
 ) -> JsResult<Option<&'static [u8]>> {
     let Some(value) = target.get(global, property)? else {
         return Ok(None);
@@ -1436,11 +1419,10 @@ fn get_optional_string(
         return Ok(None);
     }
     let str = bun_core::OwnedString::new(value.to_bun_string(global)?);
-    let _ = arena; // TODO(port): arena param unused after to_utf8() drops allocator
     Ok(Some(allocations.track(str.to_utf8())))
 }
 
-// PORT NOTE: `HmrRuntime` is defined canonically in the parent `bake/mod.rs`
+// Note: `HmrRuntime` is defined canonically in the parent `bake/mod.rs`
 // (struct with `code: &'static ZStr` + `line_count`); re-export so callers
 // using `bake_body::HmrRuntime` see the same nominal type.
 pub(crate) use super::HmrRuntime;
@@ -1454,17 +1436,13 @@ fn hmr_runtime_init(code: &'static ZStr) -> HmrRuntime {
 
 #[inline(always)]
 pub fn get_hmr_runtime(side: Side) -> HmrRuntime {
-    // `runtime_embed_file!` returns `&'static str` (no NUL). The Zig
-    // `runtimeEmbedFile` (bun.zig:2938) returns `[:0]const u8` from a
-    // `bun.once`-guarded static — read once per process, never freed.
-    // Mirror that with a per-side `OnceLock` holding the NUL-terminated
-    // copy. PORTING.md §Forbidden bans leaking for `&'static`; this is the
+    // `runtime_embed_file!` returns `&'static str` (no NUL). Use a per-side
+    // `OnceLock` holding the NUL-terminated copy — read once per process,
+    // never freed. PORTING.md §Forbidden bans leaking for `&'static`; this is the
     // sanctioned process-lifetime-singleton pattern instead. (Under
     // `cfg(bun_codegen_embed)` the macro expands to `include_str!`, so this
     // costs one extra copy at first call; the cost is negligible vs. keeping
     // a per-call-site `#[cfg]` pair in sync.)
-    // TODO(port): add a `runtime_embed_file_z!` to bun_core that yields
-    // `&'static ZStr` directly so the second copy goes away.
     use std::sync::OnceLock;
     fn nul_terminate(s: &'static str, cell: &'static OnceLock<Box<[u8]>>) -> &'static ZStr {
         let buf = cell.get_or_init(|| {
@@ -1491,7 +1469,7 @@ pub fn get_hmr_runtime(side: Side) -> HmrRuntime {
     })
 }
 
-// PORT NOTE: `Mode`/`Side`/`Graph` are defined canonically in the parent
+// Note: `Mode`/`Side`/`Graph` are defined canonically in the parent
 // `bake/mod.rs` (which itself re-exports `Side`/`Graph` from
 // `bun_bundler::bake_types`). Re-export here so `bake_body::Mode` ≡
 // `crate::bake::Mode` and downstream callers (production.rs, build_command.rs,
@@ -1548,8 +1526,7 @@ pub(crate) fn add_import_meta_defines(
 /// Used as a staging area for building pattern strings.
 pub struct PatternBuffer {
     pub bytes: PathBuffer,
-    // Zig: std.math.IntFittingRange(0, @sizeOf(bun.PathBuffer)) — smallest int
-    // fitting MAX_PATH_BYTES. On Windows MAX_PATH_BYTES = 32767*3+1 = 98302
+    // On Windows MAX_PATH_BYTES = 32767*3+1 = 98302
     // (> u16::MAX), so u32 is required; u16 would truncate the initial index
     // to 32766 and `slice()` would return ~64 KiB of trailing zero bytes.
     pub i: u32,
@@ -1608,5 +1585,3 @@ pub fn print_warning() {
         Output::flush();
     }
 }
-
-// ported from: src/bake/bake.zig
diff --git a/src/runtime/bake/bun-framework-react/index.ts b/src/runtime/bake/bun-framework-react/index.ts
index cdbd2b59429..5ec936eb9a9 100644
--- a/src/runtime/bake/bun-framework-react/index.ts
+++ b/src/runtime/bake/bun-framework-react/index.ts
@@ -1,7 +1,7 @@
 // This file is unused by Bun itself, but rather is a tool for
 // contributors to hack on `bun-framework-react` without needing
 // to compile bun itself. If changes to this are made, please
-// update 'pub fn react' in 'bake.zig'
+// update 'pub fn react' in 'bake_body.rs'
 import type { Bake } from "bun";
 
 export function react(): Bake.Framework {
diff --git a/src/runtime/bake/dev_server/assets.rs b/src/runtime/bake/dev_server/assets.rs
index ef32f57ce85..d76282c7ffe 100644
--- a/src/runtime/bake/dev_server/assets.rs
+++ b/src/runtime/bake/dev_server/assets.rs
@@ -16,11 +16,8 @@ pub(crate) type EntryIndex = bun_core::GenericIndex<u32, AssetsMarker>;
 
 #[derive(Default)]
 pub struct Assets {
-    /// Keys are absolute paths, sharing memory with `IncrementalGraph(.client)`
-    /// key storage in Zig (`replacePath` writes `stable_abs_path` back into
-    /// `key_ptr`). PORT NOTE: `StringArrayHashMap` stores owned `Box<[u8]>`
-    /// keys; the borrow-from-graph optimization is dropped.
-    // PERF(port): keys aliased IncrementalGraph storage in Zig.
+    /// Keys are absolute paths. `StringArrayHashMap` stores owned `Box<[u8]>`
+    /// keys.
     pub path_map: StringArrayHashMap<EntryIndex>,
     /// Content-addressable store. Multiple paths can point to the same content
     /// hash, tracked by `refs`. One ref held to each `StaticRoute` while stored
@@ -49,7 +46,7 @@ impl Assets {
     /// browser caching. The old URL is immediately revoked.
     ///
     /// `abs_path` is not allocated. Ownership of `contents` is transferred to
-    /// this function (Zig: `Ownership is transferred`).
+    /// this function.
     pub fn replace_path(
         &mut self,
         abs_path: &[u8],
@@ -58,11 +55,10 @@ impl Assets {
         content_hash: u64,
     ) -> Result<EntryIndex, bun_alloc::AllocError> {
         debug_assert!(self.owner().magic == Magic::Valid);
-        // Zig: `defer assert(assets.files.count() == assets.refs.items.len);`
-        // PORT NOTE: reshaped for borrowck — invariant re-checked before each return below.
+        // Invariant: `files.count() == refs.len()`, re-checked before each
+        // return below.
 
-        // Zig `std.fmt.bytesToHex(std.mem.asBytes(&content_hash), .lower)` —
-        // hex-encodes the *native-endian bytes* of the u64.
+        // Hex-encodes the *native-endian bytes* of the u64.
         let mut hex_buf = [0u8; 16];
         let hex_len = bun_fmt::bytes_to_hex_lower(&content_hash.to_ne_bytes(), &mut hex_buf);
         scoped_log!(
@@ -76,12 +72,12 @@ impl Assets {
         );
 
         // Captured up-front so borrows of `self.files` / `self.path_map` below don't
-        // overlap with `owner()` (`&self`) calls. Zig: `assets.owner().server orelse unreachable`.
+        // overlap with `owner()` (`&self`) calls.
         let server = self.owner().server;
         debug_assert!(server.is_some());
 
-        // PORT NOTE: reshaped for borrowck — Zig holds `gop` (key/value ptrs into
-        // `path_map`) live across calls that take `&mut self`. Capture `index` /
+        // `gop` holds key/value ptrs into `path_map` and cannot stay live
+        // across calls that take `&mut self`. Capture `index` /
         // `found_existing` and re-derive the value slot at the end instead.
         let gop = self.path_map.get_or_put(abs_path)?;
         let path_index = gop.index;
@@ -94,11 +90,10 @@ impl Assets {
 
         if !found_existing {
             // Locate a stable pointer for the file path.
-            // PORT NOTE: in Zig, `path_map` keys borrow `client_graph`'s interned key storage
-            // (the `gop.key_ptr.* = stable_abs_path` write shared the slice). Rust
-            // `StringArrayHashMap` owns its keys as `Box<[u8]>`, and `get_or_put` already
-            // boxed `abs_path` on insert, so the reassignment is a no-op here — we still call
-            // `insert_empty` for its side effect of registering the file in `client_graph`.
+            // `StringArrayHashMap` owns its keys as `Box<[u8]>`, and
+            // `get_or_put` already boxed `abs_path` on insert, so no key
+            // reassignment is needed — `insert_empty` is still called for its
+            // side effect of registering the file in `client_graph`.
             let owner = self.owner_mut();
             // SAFETY: accessing disjoint field `client_graph` via parent ptr; `assets` (self) is
             // not touched through `owner` for the duration of this borrow.
@@ -109,8 +104,6 @@ impl Assets {
             // When there is one reference to the asset, the entry can be
             // replaced in-place with the new asset.
             if self.refs[entry_index.get_usize()] == 1 {
-                // PORT NOTE: Zig accessed `files.entries.slice()` (MultiArrayList SoA view) and
-                // mutated `.key`/`.value` columns directly. Rust ArrayHashMap exposes keys_mut/values_mut.
                 let prev = self.files.values()[entry_index.get_usize()];
                 // SAFETY: `prev` is a live intrusively-refcounted StaticRoute we hold one ref to.
                 unsafe { StaticRoute::deref_(prev) };
@@ -124,9 +117,7 @@ impl Assets {
                         ..Default::default()
                     },
                 );
-                // Zig: `comptime assert(@TypeOf(slice.items(.hash)[0]) == void);`
-                // PORT NOTE: AutoArrayHashMap<u64, _> stores hashes as `void` (key IS the hash).
-                // The Rust ArrayHashMap<u64, _> upholds the same; nothing to assert at runtime.
+                // `ArrayHashMap<u64, _>` keys the entry on the hash itself.
                 self.needs_reindex = true;
                 debug_assert_eq!(self.files.count(), self.refs.len());
                 return Ok(entry_index);
@@ -151,7 +142,6 @@ impl Assets {
             self.refs.push(1);
         } else {
             self.refs[file_index] += 1;
-            // Zig: `var contents_mut = contents.*; contents_mut.detach();`
             // Release the owned blob on the duplicate-content path.
             contents.detach();
         }
@@ -168,9 +158,9 @@ impl Assets {
         content_hash: u64,
         ref_count: u32,
     ) -> Result<Option<&mut *mut StaticRoute>, bun_alloc::AllocError> {
-        // Zig: `defer assert(assets.files.count() == assets.refs.items.len);`
-        // PORT NOTE: reshaped for borrowck — `gop.value_ptr` borrows `self.files` mutably,
-        // so re-derive the slot via `values_mut()[index]` after the invariant assert.
+        // Invariant: `files.count() == refs.len()`. `gop.value_ptr` borrows
+        // `self.files` mutably, so re-derive the slot via
+        // `values_mut()[index]` after the invariant assert.
         let file_index_gop = self.files.get_or_put(content_hash)?;
         let index = file_index_gop.index;
         let found = file_index_gop.found_existing;
@@ -266,8 +256,8 @@ impl Assets {
 
 impl Drop for Assets {
     fn drop(&mut self) {
-        // Zig `deinit(assets, alloc)`: path_map/files/refs storage is freed by their own Drop;
-        // only the manual StaticRoute derefs remain as a side effect.
+        // path_map/files/refs storage is freed by their own Drop; only the
+        // manual StaticRoute derefs remain.
         for &blob in self.files.values() {
             // SAFETY: we hold one ref to each stored StaticRoute; release it.
             unsafe { StaticRoute::deref_(blob) };
diff --git a/src/runtime/bake/dev_server/incremental_graph.rs b/src/runtime/bake/dev_server/incremental_graph.rs
index 008b17f15c3..90109e3fec1 100644
--- a/src/runtime/bake/dev_server/incremental_graph.rs
+++ b/src/runtime/bake/dev_server/incremental_graph.rs
@@ -1,11 +1,11 @@
 //! `DevServer.IncrementalGraph(side)` — data-oriented module graph with
-//! perfect incremental tracking. Edge lists, chunk receipt, dependency
-//! tracing, and bundle emission ported from `IncrementalGraph.zig`.
+//! perfect incremental tracking: edge lists, chunk receipt, dependency
+//! tracing, and bundle emission.
 //!
-//! The Zig original is `comptime side: bake.Side`-parameterized so `File`
-//! resolves to either `ServerFile` (boundary flags) or `ClientFile` (code +
-//! source map). Stable Rust has no const-generic-enum struct selection, so the
-//! `File` payload is folded into a single struct carrying both field sets and
+//! The graph is parameterized over `bake::Side`; `File` would resolve to
+//! either `ServerFile` (boundary flags) or `ClientFile` (code + source map),
+//! but stable Rust has no const-generic-enum struct selection, so the `File`
+//! payload is folded into a single struct carrying both field sets and
 //! per-side behaviour is dispatched on the `SIDE` const parameter.
 
 use core::mem::offset_of;
@@ -24,12 +24,11 @@ use crate::bake::{self, Side};
 
 /// `bun.GenericIndex(u30, File)` — file index into `bundled_files`.
 ///
-/// Const-generic over `bake::Side` so that `IncrementalGraph(.server).FileIndex`
-/// and `IncrementalGraph(.client).FileIndex` are distinct types as in the Zig
-/// spec.
+/// Const-generic over `bake::Side` so that the server and client graphs'
+/// `FileIndex` are distinct types.
 pub struct SideMarker<const SIDE: bake::Side>;
 pub(crate) type FileIndex<const SIDE: bake::Side> = bun_core::GenericIndex<u32, SideMarker<SIDE>>;
-/// Alias used by `DevServer.route_lookup` (Zig: `IncrementalGraph(.server).FileIndex`).
+/// Alias used by `DevServer.route_lookup`.
 pub(crate) type ServerFileIndex = FileIndex<{ bake::Side::Server }>;
 pub(crate) type ClientFileIndex = FileIndex<{ bake::Side::Client }>;
 
@@ -101,11 +100,9 @@ impl Content {
     }
 }
 
-/// Per-file metadata. Zig defines this as `File = ServerFile | ClientFile`
-/// selected by `comptime side`. Rust folds the union here; per-side fields are
-/// simply unused on the other side.
-// TODO(port): split back into `ServerFile`/`ClientFile` once a trait shim
-// over `Side` selects the per-side layout (saves ~24 bytes/file on server).
+/// Per-file metadata, folded across both sides; per-side fields are simply
+/// unused on the other side (costs ~24 bytes/file on the server graph versus
+/// a per-side layout).
 pub struct File {
     /// Server-side `kind`. For client side this mirrors `content.kind()`.
     pub kind: FileKind,
@@ -160,8 +157,8 @@ impl Default for File {
     }
 }
 
-/// `IncrementalGraph(.server).CurrentChunkSourceMapData`
-/// (IncrementalGraph.zig:305).
+/// Pairs a server file with its source map for the chunk currently being
+/// assembled.
 pub struct CurrentChunkSourceMapData {
     pub file_index: ServerFileIndex,
     pub source_map: packed_map::Shared,
@@ -255,10 +252,9 @@ struct TempLookup {
     seen: bool,
 }
 
-/// `IncrementalGraph(side)`. The Zig original is comptime-parameterized over
-/// `bake.Side` so `File` resolves to `ServerFile`/`ClientFile`. Mirrored here
-/// via `adt_const_params` on `bake::Side`; `File` itself is still the folded
-/// union (see TODO above) until a trait dispatch picks the per-side layout.
+/// Parameterized via `adt_const_params` on `bake::Side`; `File` itself is
+/// still the folded union (see TODO above) until a trait dispatch picks the
+/// per-side layout.
 #[derive(Default)]
 pub struct IncrementalGraph<const SIDE: bake::Side> {
     /// Keys are absolute paths for the "file" namespace (owned). Index = `FileIndex`.
@@ -288,7 +284,8 @@ pub struct IncrementalGraph<const SIDE: bake::Side> {
     pub current_css_files: Vec<u64>,
 }
 
-/// `IncrementalGraph(side).MemoryCost` (IncrementalGraph.zig:414).
+/// Byte-count breakdown of an incremental graph's memory usage (graph
+/// structures, cached code, source maps).
 #[derive(Default, Clone, Copy)]
 pub struct GraphMemoryCost {
     pub graph: usize,
@@ -392,15 +389,13 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         self.current_chunk_source_maps.is_empty()
     }
 
-    /// `IncrementalGraph(side).memoryCostDetailed` (IncrementalGraph.zig:420).
     /// Does NOT count `size_of::<Self>()`.
     pub fn memory_cost_detailed(&self) -> GraphMemoryCost {
         use core::mem::size_of;
         let mut graph: usize = 0;
         let mut code: usize = 0;
         let mut source_maps: usize = 0;
-        // PERF(port): bun_collections::StringArrayHashMap::capacity_in_bytes —
-        // approximate via key+value slice cost.
+        // Approximate the map's memory usage via key+value slice cost.
         graph += self.bundled_files.count() * (size_of::<Box<[u8]>>() + size_of::<File>());
         graph += self.stale_files.bytes().len();
         graph += self.first_dep.capacity() * size_of::<Option<EdgeIndex>>();
@@ -434,7 +429,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         }
     }
 
-    /// `IncrementalGraph(side).reset` (IncrementalGraph.zig:1673).
     /// Clears the per-bundle mutation tracking (`current_chunk_*`) without
     /// touching the persisted file/edge storage.
     pub fn reset(&mut self) {
@@ -452,7 +446,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         self.current_chunk_parts.clear();
     }
 
-    /// `IncrementalGraph(side).ensureStaleBitCapacity` — DevServer.zig:1573.
     /// Grows `stale_files` to cover all currently-known files, filling new
     /// bits with `are_new_files_stale`.
     pub fn ensure_stale_bit_capacity(
@@ -547,7 +540,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         // DirectoryWatchStore.Dep.source_file_path borrows this key; remove
         // any such dependencies before freeing it so they do not dangle.
         {
-            // PORT NOTE: reshaped for borrowck — re-derive the key slice via raw
+            // Note: reshaped for borrowck — re-derive the key slice via raw
             // ptr so the `&mut DevServer.directory_watchers` borrow does not
             // overlap the `&mut self.bundled_files` borrow.
             let key_ptr: *const [u8] =
@@ -564,7 +557,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
 
         // Free the key string and tombstone the slot. Cannot swap-remove since
         // FrameworkRouter / SerializedFailure hold FileIndices into this graph.
-        // TODO(port): freed FileIndex should go on a free-list for reuse.
+        // Tombstoned slots are not reused; a free-list is a pending idea.
         self.bundled_files.keys_mut()[file_index.get() as usize] = Box::default();
         debug_assert!(self.first_dep[file_index.get() as usize].is_none());
         debug_assert!(self.first_import[file_index.get() as usize].is_none());
@@ -574,7 +567,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
     // receiveChunk
     // ────────────────────────────────────────────────────────────────────────
 
-    /// `IncrementalGraph(side).receiveChunk` (IncrementalGraph.zig:475).
     /// Tracks a bundled code chunk for cross-bundle chunks, ensuring it has an
     /// entry in `bundled_files`. For client, takes ownership of the code slice;
     /// for server, the code is kept in `current_chunk_code` until
@@ -615,7 +607,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
             }
         }
 
-        // Dump to filesystem if enabled (Zig: `bun.FeatureFlags.bake_debugging_features`).
+        // Dump to filesystem if enabled.
         #[cfg(feature = "bake_debugging_features")]
         if let ReceiveChunkContent::Js { code, .. } = &content {
             if let Some(dump_dir) = self.dev_dump_dir() {
@@ -639,7 +631,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         if !found_existing {
             *gop.key_ptr = Box::<[u8]>::from(key);
         }
-        // PORT NOTE: drop `gop` borrow before pushing to other Vecs / re-borrowing.
+        // Note: drop `gop` borrow before pushing to other Vecs / re-borrowing.
         if !found_existing {
             self.first_dep.push(None);
             self.first_import.push(None);
@@ -658,7 +650,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
                 let mut is_special_framework_file = false;
 
                 if found_existing {
-                    // PORT NOTE: take the existing slot out so `free_file_content`
+                    // Note: take the existing slot out so `free_file_content`
                     // can borrow `&mut self` while we hold the `File` by value.
                     let mut existing = core::mem::take(
                         &mut self.bundled_files.values_mut()[file_index.get() as usize],
@@ -845,7 +837,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
     // processChunkDependencies
     // ────────────────────────────────────────────────────────────────────────
 
-    /// `IncrementalGraph(side).processChunkDependencies` (IncrementalGraph.zig:726).
     /// Second pass of IncrementalGraph indexing: updates dependency information
     /// for each file and resolves what the HMR roots are.
     pub fn process_chunk_dependencies(
@@ -891,8 +882,8 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
                 self.first_import[file_index.get() as usize] = new_imports;
                 return Ok(());
             }
-            // TODO(port): RSC+SSR dual-index dispatch (`ctx.scbs.getSSRIndex`)
-            // is dead in the Zig spec (commented out at IncrementalGraph.zig:782).
+            // RSC+SSR dual-index dispatch (`ctx.scbs.getSSRIndex`) is
+            // intentionally not implemented.
         }
 
         match mode {
@@ -912,8 +903,8 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
             )?,
         }
 
-        // Clear the old head before freeing so `check_edge_removal` (debug-only
-        // in Zig) wouldn't see a stale reference.
+        // Clear the old head before freeing so `check_edge_removal` wouldn't
+        // see a stale reference.
         self.first_import[file_index.get() as usize] = None;
 
         // '.seen = false' means an import was removed and should be freed.
@@ -949,7 +940,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
 
         let records_len = ctx.import_records[index.get() as usize].len();
         for i in 0..records_len {
-            // PORT NOTE: snapshot the three fields we need so the shared borrow
+            // Note: snapshot the three fields we need so the shared borrow
             // on `ctx.import_records` ends before `process_edge_attachment`
             // takes `&mut ctx`.
             let (flags, src, key) = {
@@ -987,7 +978,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
 
         // Queue avoids stack overflow; tracing bits in `process_edge_attachment`
         // prevent infinite recursion.
-        // PERF(port): was stackFallback(64*u32) — profile if it shows up on a hot path.
         let mut queue: Vec<bun_ast::Index> = Vec::new();
         queue.push(bundler_index);
 
@@ -1124,7 +1114,9 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
     // traceDependencies / traceImports
     // ────────────────────────────────────────────────────────────────────────
 
-    /// `IncrementalGraph(side).traceDependencies` (IncrementalGraph.zig:1120).
+    /// Walks dependents (importers) outward from `file_index`, marking
+    /// visited files in `gts` to find the routes/HMR roots affected by a
+    /// change.
     pub fn trace_dependencies(
         &mut self,
         file_index: FileIndex<SIDE>,
@@ -1226,7 +1218,8 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         Ok(())
     }
 
-    /// `IncrementalGraph(side).traceImports` (IncrementalGraph.zig:1206).
+    /// Walks imports inward from `file_index`, marking visited files in
+    /// `gts` to collect everything a bundle for this file must include.
     pub fn trace_imports(
         &mut self,
         file_index: FileIndex<SIDE>,
@@ -1374,7 +1367,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
             Side::Client => {
                 if found_existing {
                     let mut existing = core::mem::take(&mut self.bundled_files.values_mut()[idx]);
-                    // PORT NOTE: re-derive owned key via `RawSlice` so
+                    // Note: re-derive owned key via `RawSlice` so
                     // `free_file_content` can borrow `&mut self`.
                     let key = bun_ptr::RawSlice::new(&*self.bundled_files.keys()[idx]);
                     self.free_file_content(key.slice(), &mut existing, FreeCssMode::UnrefCss);
@@ -1541,8 +1534,8 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
         let dev = unsafe { self.owner() };
         let fail_owner = serialized_failure::OwnerPacked::new(SIDE, idx as u32);
 
-        // TODO(port): DevServer should get a stdio manager which can process
-        // the error list as it changes while also supporting a REPL.
+        // Errors print straight to the terminal; a stdio manager that could
+        // re-render the error list alongside a REPL is a pending idea.
         let _ = log.print(std::ptr::from_mut(bun_core::Output::error_writer()));
 
         let failure = {
@@ -1643,7 +1636,7 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
             self.stale_files.set(index);
             // Store the graph-owned key, not the incoming `path` (which may be
             // freed before `entry_points` is consumed).
-            // PORT NOTE: re-derive via `RawSlice` so the immutable key borrow
+            // Note: re-derive via `RawSlice` so the immutable key borrow
             // does not conflict with the `&mut entry_points` push below.
             let owned_path = bun_ptr::RawSlice::new(&*self.bundled_files.keys()[index]);
             let owned_path = owned_path.slice();
@@ -1759,7 +1752,6 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
             },
         };
 
-        // PERF(port): was std.heap.stackFallback(65536) — profile if it shows up on a hot path.
         let mut end_list: Vec<u8> = Vec::with_capacity(256);
         // SAFETY: see `owner()`.
         let dev = unsafe { self.owner() };
@@ -1938,10 +1930,10 @@ impl<const SIDE: bake::Side> IncrementalGraph<SIDE> {
                 let mut overlapping_memory_cost: usize = 0;
 
                 for file_index in &self.current_chunk_parts {
-                    // PERF(port): Zig stored borrowed slice headers into
-                    // `bundled_files.keys()`; that is self-referential w.r.t.
-                    // `DevServer`, so the port owns a copy. Paths are short and
-                    // source-map entries are infrequent — profile if hot.
+                    // Borrowing slice headers from `bundled_files.keys()`
+                    // would be self-referential w.r.t. `DevServer`, so own a
+                    // copy. Paths are short and source-map entries are
+                    // infrequent — profile if hot.
                     file_paths.push(Box::<[u8]>::from(&*paths[file_index.get() as usize]));
                     let sm = self.bundled_files.values()[file_index.get() as usize]
                         .source_map
diff --git a/src/runtime/bake/dev_server/lifecycle.rs b/src/runtime/bake/dev_server/lifecycle.rs
index 7cf39563d91..4ae66193b51 100644
--- a/src/runtime/bake/dev_server/lifecycle.rs
+++ b/src/runtime/bake/dev_server/lifecycle.rs
@@ -3,8 +3,7 @@
 //! `Watcher::init::<DevServer>` dispatches through the generic
 //! `WatcherContext` vtable, so the trait methods here are the *only* path the
 //! watcher thread reaches — they forward to the inherent
-//! `DevServer::{on_file_update, on_watch_error}` bodies in `../DevServer.rs`
-//! (ported from `DevServer.zig:4093`/`4153`).
+//! `DevServer::{on_file_update, on_watch_error}` bodies in `../DevServer.rs`.
 
 // `feature = "bake_debugging_features"` is not yet a declared cargo feature; the
 // struct field gate must mirror `mod.rs` so the initializer below stays in sync.
@@ -28,9 +27,8 @@ impl bun_watcher::WatcherContext for DevServer {
         DevServer::on_file_update(self, events, changed_files, watchlist);
     }
 
-    /// DevServer.zig only defines `onWatchError` (not `onError`); the trait's
-    /// default `on_watch_error` would forward here, so route both to the
-    /// inherent path-aware impl rather than emitting a generic warn.
+    /// The trait's default `on_watch_error` would forward here, so route both
+    /// to the inherent path-aware impl rather than emitting a generic warn.
     fn on_error(&mut self, err: bun_sys::Error) {
         DevServer::on_watch_error(self, err);
     }
@@ -41,7 +39,6 @@ impl bun_watcher::WatcherContext for DevServer {
 }
 
 impl WatcherAtomics {
-    /// DevServer.zig `WatcherAtomics.init`.
     pub(crate) fn init(owner: *mut DevServer) -> Self {
         let mk_event = || HotReloadEvent::init_empty(owner);
         WatcherAtomics {
diff --git a/src/runtime/bake/dev_server/mod.rs b/src/runtime/bake/dev_server/mod.rs
index 57114c298eb..b4037a778e6 100644
--- a/src/runtime/bake/dev_server/mod.rs
+++ b/src/runtime/bake/dev_server/mod.rs
@@ -10,7 +10,7 @@
 //!   - `is_file_cached`
 
 #![allow(clippy::module_inception)]
-#![allow(unexpected_cfgs)] // `feature = "bake_debugging_features"` mirrors Zig `bun.FeatureFlags.bake_debugging_features`; not yet a declared cargo feature.
+#![allow(unexpected_cfgs)] // `feature = "bake_debugging_features"` is not yet a declared cargo feature.
 
 use core::sync::atomic::Ordering;
 
@@ -21,8 +21,7 @@ use super::jsc;
 use super::{Graph, Side};
 
 // ─── submodule bodies ────────────────────────────────────────────────────────
-// Each is a faithful port of the `.zig` sibling. Assets body dissolved into
-// `assets.rs`.
+// Assets body dissolved into `assets.rs`.
 #[path = "../DevServer/DirectoryWatchStore.rs"]
 pub(crate) mod directory_watch_store_body;
 #[path = "../DevServer/ErrorReportRequest.rs"]
@@ -97,7 +96,7 @@ pub enum TraceImportGoal {
 }
 
 /// `DevServer.ConsoleLog.Kind` — `enum(u8) { log = 'l', err = 'e' }`.
-/// Discriminants MUST match Zig: `kind as u8` is sent across FFI to
+/// Discriminants MUST NOT change: `kind as u8` is sent across FFI to
 /// `InspectorBunFrontendDevServerAgent__notifyConsoleLog`.
 #[repr(u8)]
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -107,7 +106,8 @@ pub enum ConsoleLogKind {
 }
 
 /// `DevServer.MessageId` — first byte of every server→client HMR frame.
-/// Discriminants MUST match `DevServer.zig` exactly (HMR wire protocol).
+/// Discriminants are the HMR wire protocol and MUST match the client
+/// (`generated.ts`).
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum MessageId {
@@ -130,7 +130,8 @@ impl MessageId {
 }
 
 /// `DevServer.IncomingMessageId` — first byte of every client→server HMR frame.
-/// Discriminants MUST match `DevServer.zig` exactly (HMR wire protocol).
+/// Discriminants are the HMR wire protocol and MUST match the client
+/// (`generated.ts`).
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum IncomingMessageId {
@@ -142,7 +143,8 @@ pub enum IncomingMessageId {
     UnrefSourceMap = b'u',
 }
 
-/// `DevServer.HmrTopic`. Discriminants MUST match `DevServer.zig` exactly.
+/// `DevServer.HmrTopic`. Discriminants are the HMR wire protocol and MUST
+/// match the client.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum HmrTopic {
@@ -158,7 +160,7 @@ impl HmrTopic {
     /// `HmrTopic.max_count` — `@typeInfo(HmrTopic).@"enum".fields.len`.
     pub const MAX_COUNT: usize = 6;
 
-    /// All variants in declaration order — Zig: `std.enums.values(HmrTopic)`.
+    /// All variants in declaration order.
     pub const ALL: &[HmrTopic] = &[
         HmrTopic::HotUpdate,
         HmrTopic::Errors,
@@ -230,9 +232,9 @@ impl IncrementalResult {
         client_components_affected: Vec::new(),
     };
 
-    /// DevServer.zig:3528 `IncrementalResult.reset` — `clearRetainingCapacity()`
-    /// on each list, asserts `failures_removed` was already drained, and
-    /// intentionally leaves `had_adjusted_edges` untouched.
+    /// Clears each list retaining capacity, asserts `failures_removed` was
+    /// already drained, and intentionally leaves `had_adjusted_edges`
+    /// untouched.
     pub fn reset(&mut self) {
         self.framework_routes_affected.clear();
         self.html_routes_soft_affected.clear();
@@ -306,10 +308,10 @@ pub use route_bundle::RouteBundle;
 pub use serialized_failure::SerializedFailure;
 pub use source_map_store::SourceMapStore;
 
-/// Local stand-in for the unported `bun_uws::ResponseLike` trait — Zig's
-/// `resp: anytype` modeled as a generic bound. Method shapes mirror
-/// `bun_uws_sys::Response<SSL>` so the `R`-generic bodies type-check.
-// TODO(port): replace with `bun_uws::ResponseLike` once it lands upstream.
+/// Local response trait — the response type is a generic bound.
+/// Method shapes mirror `bun_uws_sys::Response<SSL>` so the `R`-generic
+/// bodies type-check. `bun_uws` exposes no equivalent trait; if it ever
+/// grows one, this can be replaced by it.
 pub trait ResponseLike {
     fn write_status(&mut self, status: &[u8]);
     fn end(&mut self, data: &[u8], close_connection: bool);
@@ -397,21 +399,20 @@ impl HmrSocket {
 }
 
 /// `DevServer.HotReloadEvent` — produced by the watcher thread.
-// PORT NOTE: Zig's `_: u0 align(std.atomic.cache_line) = 0` first-field trick gives the whole
-// struct cache-line alignment so each inline `WatcherAtomics.events: [3]` element occupies its
-// own cache line, avoiding false sharing on `contention_indicator` between watcher and dev-server
-// threads. 128 matches `std.atomic.cache_line` on x86_64/aarch64 (Bun's tier-1 targets) and
-// absorbs Intel adjacent-line prefetch.
+// Note: cache-line alignment makes each inline `WatcherAtomics.events: [3]`
+// element occupy its own cache line, avoiding false sharing on
+// `contention_indicator` between watcher and dev-server threads. 128 matches
+// the cache line on x86_64/aarch64 (Bun's tier-1 targets) and absorbs Intel
+// adjacent-line prefetch.
 #[repr(align(128))]
 pub struct HotReloadEvent {
     /// BACKREF (LIFETIMES.tsv): inline element of `WatcherAtomics.events: [3]`.
-    /// `*mut` (not `*const`) because `run` mutates the owning DevServer; Zig
-    /// declares `owner: *DevServer`.
+    /// `*mut` (not `*const`) because `run` mutates the owning DevServer.
     pub owner: *mut DevServer,
     pub concurrent_task: bun_event_loop::ConcurrentTask::ConcurrentTask,
     pub files: StringArrayHashMap<()>,
     pub dirs: StringArrayHashMap<()>,
-    /// NUL-joined absolute paths (`ArrayListUnmanaged(u8)` in Zig).
+    /// NUL-joined absolute paths.
     pub extra_files: Vec<u8>,
     pub timer: std::time::Instant,
     /// 1 if referenced, 0 if unreferenced; see `WatcherAtomics`.
@@ -458,7 +459,6 @@ impl HotReloadEvent {
         unsafe { (*self.owner).bun_watcher.thread_lock.assert_locked() };
     }
 
-    /// `HotReloadEvent.processFileList` — HotReloadEvent.zig:78.
     /// Invalidates items in IncrementalGraph, appending all new items to `entry_points`.
     pub fn process_file_list(&mut self, dev: &mut DevServer, entry_points: &mut EntryPointList) {
         // RAII: `ThreadLockGuard` stores a raw `*const ThreadLock` and unlocks on
@@ -482,14 +482,12 @@ impl HotReloadEvent {
 
                 // if a directory watch exists for resolution failures, check those now.
                 if let Some(watcher_index) = dev.directory_watchers.watches.get_index(changed_dir) {
-                    // PORT NOTE: reshaped for borrowck — Zig held `entry` ref while mutating
-                    // `dev.directory_watchers.dependencies` and `self.files` in the loop body.
                     let mut new_chain: Option<u32> = None;
                     let mut it: Option<u32> =
                         Some(dev.directory_watchers.watches.values()[watcher_index].first_dep);
 
                     while let Some(index) = it {
-                        // PORT NOTE: reshaped for borrowck — re-index per iteration instead of
+                        // Note: reshaped for borrowck — re-index per iteration instead of
                         // holding `dep` ref across resolver call + appendFile + freeDependencyIndex.
                         let (source_file_path, specifier, next) = {
                             let dep = &dev.directory_watchers.dependencies[index as usize];
@@ -515,7 +513,7 @@ impl HotReloadEvent {
                             // this resolution result is not preserved as passing it
                             // into BundleV2 is too complicated. the resolution is
                             // cached, anyways.
-                            // PORT NOTE: inlined `append_file` body for disjoint borrow
+                            // Note: inlined `append_file` body for disjoint borrow
                             // (`self.dirs.keys()` is held immutably across this loop).
                             bun_core::handle_oom(self.files.get_or_put(source_file_path.slice()));
                             dev.directory_watchers.free_dependency_index(index);
@@ -547,7 +545,6 @@ impl HotReloadEvent {
         }
 
         let changed_file_paths = self.files.keys();
-        // PORT NOTE: Zig used `inline for` over a 2-tuple; written out as two calls.
         bun_core::handle_oom(
             dev.server_graph
                 .invalidate(changed_file_paths, entry_points),
@@ -600,12 +597,13 @@ impl HotReloadEvent {
         self.extra_files.clear();
     }
 
-    /// `HotReloadEvent.appendFile` — HotReloadEvent.zig:55.
+    /// Records a changed file path in the pending hot-reload event (deduplicated).
     pub fn append_file(&mut self, file_path: &[u8]) {
         bun_core::handle_oom(self.files.get_or_put(file_path));
     }
 
-    /// `HotReloadEvent.appendDir` — HotReloadEvent.zig:58.
+    /// Records a changed directory (and, when present, the changed entry
+    /// within it) in the pending hot-reload event (deduplicated).
     pub fn append_dir(&mut self, dir_path: &[u8], maybe_sub_path: Option<&[u8]>) {
         if dir_path.is_empty() {
             return;
@@ -620,7 +618,6 @@ impl HotReloadEvent {
         }
 
         let ends_with_sep = bun_paths::Platform::AUTO.is_separator(dir_path[dir_path.len() - 1]);
-        // PERF(port): was ensureUnusedCapacity + appendSliceAssumeCapacity — profile if hot.
         self.extra_files.extend_from_slice(if ends_with_sep {
             &dir_path[0..dir_path.len() - 1]
         } else {
@@ -631,8 +628,7 @@ impl HotReloadEvent {
         self.extra_files.push(0);
     }
 
-    /// `HotReloadEvent.run` — HotReloadEvent.zig:173. Main-thread side of the
-    /// watcher → DevServer hand-off.
+    /// Main-thread side of the watcher → DevServer hand-off.
     ///
     /// Takes a raw `*mut` because `first` is an inline element of
     /// `(*first.owner).watcher_atomics.events[_]`; holding a `&mut HotReloadEvent`
@@ -674,7 +670,6 @@ impl HotReloadEvent {
             return;
         }
 
-        // PERF(port): was stack-fallback allocator (4096 bytes) — profile if hot.
         let mut entry_points = EntryPointList::default();
 
         // SAFETY: `first` is live; `&mut *dev` re-borrowed for the call only.
@@ -686,7 +681,7 @@ impl HotReloadEvent {
         // `WatcherAtomics::watcher_acquire_event` before submission.
         let timer = unsafe { (*first).timer };
 
-        // PORT NOTE: raw-ptr loop because `recycle_event_from_dev_server` returns
+        // Note: raw-ptr loop because `recycle_event_from_dev_server` returns
         // a pointer into `dev.watcher_atomics.events`; re-borrow each iteration
         // to avoid aliasing UB.
         let mut current: *mut HotReloadEvent = first;
@@ -735,7 +730,6 @@ impl HotReloadEvent {
         }
 
         if let Err(_err) = dev_ref.start_async_bundle(entry_points, true, timer) {
-            // PORT NOTE: Zig `bun.handleErrorReturnTrace` has no Rust equivalent.
             return;
         }
     }
@@ -745,11 +739,11 @@ impl HotReloadEvent {
 /// rotated between the watcher thread and the main thread.
 pub struct WatcherAtomics {
     pub events: [HotReloadEvent; 3],
-    /// `next_event: std.atomic.Value(NextEvent)` — encodes the `NextEvent`
-    /// `enum(u8) { 0..3 = event index, .waiting, .done }`.
-    // TODO(port): Zig had `align(std.atomic.cache_line)` on this field; Rust cannot align
-    // individual fields — wrap in a `#[repr(align(128))]` newtype if false sharing
-    // shows up in profiles.
+    /// Atomically encodes a `NextEvent`: values 0..3 are an index into
+    /// `events`, plus the `WAITING`/`DONE` sentinels.
+    // Rust cannot align individual fields, so this field is not cache-line
+    // aligned. Wrap in a `#[repr(align(128))]` newtype (init site:
+    // lifecycle.rs) if false sharing ever shows up in profiles.
     pub next_event: core::sync::atomic::AtomicU8,
     /// Watcher-thread-only; index into `events` currently being processed.
     pub current_event: Option<u8>,
@@ -763,9 +757,9 @@ pub struct WatcherAtomics {
 }
 
 /// Stored in `WatcherAtomics::next_event` (an `AtomicU8`). Modeled as a
-/// transparent newtype rather than a `#[repr(u8)] enum` because Zig used an
-/// open enum (`_`) where any other value is an index into the `events` array,
-/// and Rust enums cannot hold unlisted discriminants.
+/// transparent newtype rather than a `#[repr(u8)] enum` because any value
+/// other than the named constants is an index into the `events` array, and
+/// Rust enums cannot hold unlisted discriminants.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct NextEvent(pub u8);
@@ -882,8 +876,7 @@ impl WatcherAtomics {
 
         // Initialize the timer if it is empty.
         if ev_ref.is_empty() {
-            // PORT NOTE: Zig's `std.time.Timer.start()` records a monotonic start time;
-            // we capture `Instant::now()` here and compute elapsed at the read site.
+            // Monotonic start time; elapsed is computed at the read site.
             ev_ref.timer = std::time::Instant::now();
         }
 
@@ -929,10 +922,6 @@ impl WatcherAtomics {
 
         #[cfg(debug_assertions)]
         {
-            // PORT NOTE: Zig asserted `ev.timer` was not the 0xAA debug-undefined
-            // fill pattern. Rust has no such fill (uninitialized memory is never
-            // observed through a typed place), so the byte-scan is dropped — it
-            // could not fire and reading struct padding is itself UB.
             ev_ref.debug_mutex.unlock();
         }
 
@@ -1038,7 +1027,7 @@ impl DirectoryWatchStore {
         unsafe { &mut (*self.owner()).bun_watcher }
     }
 
-    /// `DirectoryWatchStore.freeDependencyIndex` — DirectoryWatchStore.zig.
+    /// Returns a dependency slot to the free list so it can be reused.
     pub fn free_dependency_index(&mut self, index: u32) {
         // Zero out the slot so DevServer.deinit/memoryCost — which iterate
         // `dependencies` without consulting the free list — do not touch the
@@ -1051,7 +1040,6 @@ impl DirectoryWatchStore {
         }
     }
 
-    /// `DirectoryWatchStore.freeEntry` — DirectoryWatchStore.zig:206.
     /// Expects dependency list to be already freed.
     pub fn free_entry(&mut self, entry_index: usize) {
         let entry = self.watches.values()[entry_index];
@@ -1070,7 +1058,7 @@ impl DirectoryWatchStore {
             &[],
         );
 
-        // Zig: alloc.free(store.watches.keys()[entry_index]) — Box key drops on swap_remove_at.
+        // The Box key drops on swap_remove_at.
         let _ = self.watches.swap_remove_at(entry_index);
 
         if entry.dir_fd_owned {
@@ -1111,8 +1099,7 @@ pub mod directory_watch_store {
     pub struct Dep {
         pub next: Option<u32>,
         /// The file used. BORROWED slice into `IncrementalGraph.bundled_files`
-        /// key storage; compared by *pointer identity* (Zig:
-        /// `dep.source_file_path.ptr == file_path.ptr`). The graph calls
+        /// key storage; compared by *pointer identity*. The graph calls
         /// `removeDependenciesForFile` before freeing the key, so the slice
         /// outlives every read — `RawSlice` invariant.
         pub source_file_path: bun_ptr::RawSlice<u8>,
@@ -1146,7 +1133,7 @@ bun_bundler::link_impl_DevServerHandle! {
         finalize_bundle(bv2, result) => {
             // `bv2` borrows the three `Transpiler`s stored inline in `DevServer`
             // (stable heap address); the `'static` is a stand-in for the
-            // DevServer-self lifetime — see `CurrentBundle.bv2` PORT NOTE.
+            // DevServer-self lifetime — see the comment on `CurrentBundle.bv2`.
             super::dev_server_body::finalize_bundle(&mut *this, &mut *bv2.cast(), &mut *result)
                 .map_err(Into::into)
         },
@@ -1158,7 +1145,7 @@ bun_bundler::link_impl_DevServerHandle! {
         put_or_overwrite_asset(path, contents, content_hash) => {
             // `path` was erased from `&bun_resolver::fs::Path<'_>` at the
             // `DevServerHandle::put_or_overwrite_asset_erased` call site. Re-wrap
-            // bytes as an owned blob (Zig spec transferred ownership).
+            // bytes as an owned blob (ownership is transferred).
             let path = &*path.cast::<bun_resolver::fs::Path<'_>>();
             let blob = crate::webcore::blob::Any::from_owned_slice(contents.to_vec());
             (*this).put_or_overwrite_asset(path, blob, content_hash)
@@ -1198,8 +1185,7 @@ bun_bundler::link_impl_DevServerHandle! {
             Ok(())
         },
         register_barrel_export(barrel_path, alias) => {
-            // Zig `persistBarrelExport` (barrel_imports.zig:540) does
-            // `getOrPut(...) catch return` — silently drop on alloc failure.
+            // Silently drop on alloc failure.
             let Ok(gop) = (*this).barrel_needed_exports.get_or_put(barrel_path) else {
                 return;
             };
@@ -1209,7 +1195,7 @@ bun_bundler::link_impl_DevServerHandle! {
 }
 
 impl DevServer {
-    /// Length of `configuration_hash_key` — Zig: `[16]u8`.
+    /// Length of `configuration_hash_key`.
     pub const CONFIGURATION_HASH_KEY_LEN: usize = 16;
 
     /// Construct the erased handle the bundler stores in
@@ -1226,7 +1212,7 @@ impl DevServer {
     }
 }
 
-/// `DirectoryWatchStore.insert` error set — DirectoryWatchStore.zig:101.
+/// `DirectoryWatchStore::insert` error set.
 #[derive(thiserror::Error, Debug)]
 enum DirectoryWatchInsertError {
     #[error("Ignore")]
@@ -1237,7 +1223,8 @@ enum DirectoryWatchInsertError {
 bun_core::oom_from_alloc!(DirectoryWatchInsertError);
 
 impl DirectoryWatchStore {
-    /// `DirectoryWatchStore.trackResolutionFailure` — DirectoryWatchStore.zig:28.
+    /// Registers a directory watch so that a failed import resolution is
+    /// retried when the containing directory changes.
     pub fn track_resolution_failure(
         &mut self,
         import_source: &[u8],
@@ -1313,7 +1300,6 @@ impl DirectoryWatchStore {
         }
     }
 
-    /// `DirectoryWatchStore.insert` — DirectoryWatchStore.zig:101.
     /// `dir_name_to_watch` is cloned; `file_path` must outlive the watch;
     /// `specifier` is cloned.
     fn insert(
@@ -1324,8 +1310,8 @@ impl DirectoryWatchStore {
     ) -> Result<(), DirectoryWatchInsertError> {
         debug_assert!(!specifier.is_empty());
         // TODO: watch the parent dir too.
-        // PORT NOTE: take a raw pointer so the &mut self borrow from owner() does
-        // not overlap subsequent self.* field accesses (Zig has no borrowck here).
+        // Note: take a raw pointer so the &mut self borrow from owner() does
+        // not overlap subsequent self.* field accesses.
         let dev: *mut DevServer = self.owner();
 
         bun_core::scoped_log!(
@@ -1337,11 +1323,10 @@ impl DirectoryWatchStore {
         );
 
         if self.dependencies_free_list.is_empty() {
-            // PERF(port): was ensureUnusedCapacity — profile if hot.
             self.dependencies.reserve(1);
         }
 
-        // PORT NOTE: reshaped for borrowck — capture gop scalars before
+        // Note: reshaped for borrowck — capture gop scalars before
         // calling self methods that need &mut self.
         let gop = self.watches.get_or_put(
             bun_paths::string_paths::without_trailing_slash_windows_path(dir_name_to_watch),
@@ -1371,7 +1356,7 @@ impl DirectoryWatchStore {
             return Ok(());
         }
 
-        // PORT NOTE: `errdefer store.watches.swapRemoveAt(gop.index)` — guard the
+        // Note: `errdefer store.watches.swapRemoveAt(gop.index)` — guard the
         // map via raw ptr so it doesn't conflict with `&mut self` below.
         let watches_ptr: *mut StringArrayHashMap<directory_watch_store::Entry> =
             &raw mut self.watches;
@@ -1400,7 +1385,7 @@ impl DirectoryWatchStore {
             if let Some(fd) = cache_fd {
                 (fd, false)
             } else {
-                // std.posix.toPosixPath — build a NUL-terminated path buffer.
+                // Build a NUL-terminated path buffer.
                 if dir_name_to_watch.len() >= bun_paths::MAX_PATH_BYTES {
                     return Err(DirectoryWatchInsertError::Ignore); // NameTooLong
                 }
@@ -1477,13 +1462,11 @@ impl DirectoryWatchStore {
             index
         } else {
             let index = u32::try_from(self.dependencies.len()).expect("int cast");
-            // PERF(port): was appendAssumeCapacity — profile if hot.
             self.dependencies.push(dep);
             index
         }
     }
 
-    /// `DirectoryWatchStore.removeDependenciesForFile` — DirectoryWatchStore.zig:233.
     /// Removes all dependencies whose `source_file_path` is the exact slice
     /// `file_path`, compared by *pointer identity* since the slice is shared
     /// with `IncrementalGraph.bundled_files`. Called before IncrementalGraph
@@ -1503,7 +1486,7 @@ impl DirectoryWatchStore {
         let mut watch_index = self.watches.count();
         while watch_index > 0 {
             watch_index -= 1;
-            // PORT NOTE: reshaped for borrowck — cannot hold &mut entry across
+            // Note: reshaped for borrowck — cannot hold &mut entry across
             // self.free_dependency_index(); walk by index and re-borrow.
             let mut new_chain: Option<u32> = None;
             let mut it: Option<u32> = Some(self.watches.values()[watch_index].first_dep);
@@ -1511,7 +1494,7 @@ impl DirectoryWatchStore {
                 let dep_next = self.dependencies[index as usize].next;
                 let dep_path = self.dependencies[index as usize].source_file_path;
                 it = dep_next;
-                // Pointer-identity comparison (Zig: `dep.source_file_path.ptr == file_path.ptr`).
+                // Pointer-identity comparison.
                 if dep_path.slice().as_ptr() == file_path.as_ptr() {
                     self.free_dependency_index(index);
                 } else {
diff --git a/src/runtime/bake/dev_server/packed_map.rs b/src/runtime/bake/dev_server/packed_map.rs
index 0cb0d39cb47..fb438fc6d7e 100644
--- a/src/runtime/bake/dev_server/packed_map.rs
+++ b/src/runtime/bake/dev_server/packed_map.rs
@@ -1,10 +1,10 @@
 //! `DevServer.PackedMap` — compact source-map slice (VLQ mappings + escaped
 //! source contents) shared between `IncrementalGraph` files and
-//! `SourceMapStore` entries. Spec: src/runtime/bake/DevServer/PackedMap.zig.
+//! `SourceMapStore` entries.
 
 use std::rc::Rc;
 
-/// Line count newtype (Zig: `bun.GenericIndex(u32, u8)`).
+/// Line count newtype.
 pub(crate) type LineCount = bun_core::GenericIndex<u32, u8>;
 
 /// `PackedMap.end_state` — only the two fields the bundler needs to thread
@@ -62,9 +62,8 @@ impl PackedMap {
 /// should never allocate an object. There is still relevant state for these
 /// files to encode, so a tagged union is used.
 ///
-/// PORT NOTE: Zig `bun.MultiArrayList(Shared)` SoA split buys nothing for a
-/// 2-word payload and `MultiArrayElement` cannot be derived for an enum, so
-/// callers store `Vec<Shared>`.
+/// An SoA split buys nothing for a 2-word payload (and `MultiArrayElement`
+/// cannot be derived for an enum), so callers store `Vec<Shared>`.
 #[derive(Default)]
 pub enum Shared {
     Some(Rc<PackedMap>),
@@ -86,8 +85,8 @@ impl Shared {
         match core::mem::replace(self, Shared::None) {
             Shared::Some(p) => Some(p),
             other => {
-                // PORT NOTE: reshaped for borrowck — Zig only writes `.none`
-                // on the `.some` arm, so restore the original on miss.
+                // Only the `Some` arm consumes the value, so restore the
+                // original on miss.
                 *self = other;
                 None
             }
diff --git a/src/runtime/bake/dev_server/route_bundle.rs b/src/runtime/bake/dev_server/route_bundle.rs
index 4fe8da2b820..3736176cc04 100644
--- a/src/runtime/bake/dev_server/route_bundle.rs
+++ b/src/runtime/bake/dev_server/route_bundle.rs
@@ -10,7 +10,6 @@ use crate::server::{StaticRoute, html_bundle::HTMLBundleRoute};
 /// `bun.GenericIndex(u30, RouteBundle)`.
 pub enum RouteBundleMarker {}
 pub(crate) type Index = bun_core::GenericIndex<u32, RouteBundleMarker>;
-/// `Index.Optional` — packed sentinel in Zig; `Option` here (non-FFI).
 pub(crate) type IndexOptional = Option<Index>;
 
 /// `bun.GenericIndex(u32, u8)` — byte offset into `bundled_html_text`.
@@ -39,7 +38,7 @@ pub struct Html {
     /// refcount via `.initRef(html)` when storing; `.deref()` on drop.
     /// Stored as raw ptr because `HTMLBundleRoute` does not yet impl
     /// `bun_ptr::RefCounted` (gated server-side).
-    // TODO(port): bun_ptr::RefPtr<HTMLBundleRoute> once RefCounted impl is real.
+    // TODO: switch to bun_ptr::RefPtr<HTMLBundleRoute> once the RefCounted impl is real.
     pub html_bundle: *mut HTMLBundleRoute,
     pub bundled_file: incremental_graph::ClientFileIndex,
     pub script_injection_offset: Option<ByteOffset>,
@@ -58,14 +57,14 @@ pub enum Data {
 }
 
 impl Data {
-    /// Zig: `data.framework` payload accessor (asserts active tag).
+    /// `Framework` payload accessor (asserts active variant).
     pub(crate) fn framework(&self) -> &Framework {
         match self {
             Data::Framework(f) => f,
             Data::Html(_) => unreachable!("expected .framework"),
         }
     }
-    /// Zig: `data.html` payload accessor (asserts active tag).
+    /// `Html` payload accessor (asserts active variant).
     pub(crate) fn html(&self) -> &Html {
         match self {
             Data::Html(h) => h,
@@ -81,10 +80,8 @@ impl Data {
 }
 
 impl RouteBundle {
-    /// `RouteBundle.invalidateClientBundle` (RouteBundle.zig:122).
-    ///
-    /// PORT NOTE: takes `&mut SourceMapStore` rather than `&mut DevServer` —
-    /// the Zig body only touches `dev.source_maps`, and the two keystone
+    /// Note: takes `&mut SourceMapStore` rather than `&mut DevServer` —
+    /// only `dev.source_maps` is touched, and the two keystone
     /// `DevServer` structs (`dev_server::DevServer` / `dev_server_body::DevServer`)
     /// both expose that field but cannot be named here without a cycle.
     pub fn invalidate_client_bundle(&mut self, source_maps: &mut source_map_store::SourceMapStore) {
@@ -95,7 +92,7 @@ impl RouteBundle {
             // outstanding `&`/`&mut` borrow exists across this call.
             unsafe { StaticRoute::deref_(bundle.as_ptr()) };
         }
-        // Zig: `std.crypto.random.int(u32)` — OS CSPRNG.
+        // OS CSPRNG.
         self.client_script_generation = {
             let mut buf = [0u8; 4];
             bun_core::csprng(&mut buf);
@@ -116,7 +113,7 @@ impl RouteBundle {
 #[derive(Clone, Copy)]
 pub(crate) enum UnresolvedIndex {
     Framework(framework_router::RouteIndex),
-    /// BACKREF (Zig `*HTMLBundle.Route`): `getOrPutRouteBundle` writes
+    /// BACKREF: `getOrPutRouteBundle` writes
     /// `dev_server_id` back through this pointer and `.initRef(html)` takes
     /// its own ref when stored. Carried as a raw mutable pointer (not `&`/
     /// `&mut`) so the writeback doesn't require a `&const → &mut` cast and
@@ -143,7 +140,7 @@ impl RouteBundle {
         source_map_store::Key(u64::from(self.client_script_generation) << 32)
     }
 
-    /// `RouteBundle.memoryCost` (RouteBundle.zig:137).
+    /// Estimated heap bytes retained by this route bundle, for memory reporting.
     pub fn memory_cost(&self) -> usize {
         let mut cost: usize = core::mem::size_of::<RouteBundle>();
         if let Some(bundle) = self.client_bundle.as_deref() {
diff --git a/src/runtime/bake/dev_server/serialized_failure.rs b/src/runtime/bake/dev_server/serialized_failure.rs
index 77a4cae4c67..80c254d106d 100644
--- a/src/runtime/bake/dev_server/serialized_failure.rs
+++ b/src/runtime/bake/dev_server/serialized_failure.rs
@@ -3,8 +3,6 @@
 //! exceptions as well as bundler errors. A serialized failure carries a handle
 //! on the file or route it came from so the bundler can dismiss/update stale
 //! failures by index instead of resending the whole payload.
-//!
-//! Spec: src/runtime/bake/DevServer/SerializedFailure.zig
 
 use bun_io::Write as _;
 
@@ -16,8 +14,7 @@ use crate::bake::Side;
 ///
 /// Distinct from `Packed` (2-bit kind + 30-bit data) below: this encoding only
 /// covers `Client`/`Server` owners and is used as the `bundling_failures` map
-/// key (Zig hashed via `ArrayHashContextViaOwner`; the port keys the map by
-/// this newtype directly).
+/// key directly.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct OwnerPacked(pub u32);
@@ -61,8 +58,7 @@ impl Owner {
     }
 }
 
-/// Zig: `packed struct(u32) { data: u30, kind: enum(u2) }`
-/// First field at LSB → `data` = bits 0..30, `kind` = bits 30..32.
+/// Packed u32: `data` = bits 0..30, `kind` = bits 30..32.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Packed(u32);
@@ -116,15 +112,13 @@ impl Packed {
     }
 }
 
-// Zig: comptime { assert(@as(u32, @bitCast(Packed{ .kind = .none, .data = 1 })) == 1); }
 const _: () = assert!(Packed::new(PackedKind::None, 1).bits() == 1);
 
 /// Stored in `dev.bundling_failures` keyed by its `OwnerPacked`.
 ///
-/// PERF(port): Zig's `SerializedFailure` is a slice header (`data: []u8`) and
-/// gets shallow-copied between `bundling_failures` and the `failures_added`/
-/// `failures_removed` lists. The Rust port owns `data` as `Box<[u8]>`, so
-/// `Clone` deep-copies — profile if this shows up on a hot path.
+/// PERF: `data` is an owned `Box<[u8]>`, so `Clone` deep-copies between
+/// `bundling_failures` and the `failures_added`/`failures_removed` lists —
+/// profile if this shows up on a hot path.
 #[derive(Clone, Default)]
 pub struct SerializedFailure {
     /// Wire-format bytes (length-prefixed; first 4 bytes encode `Owner.Packed`).
@@ -132,8 +126,7 @@ pub struct SerializedFailure {
 }
 
 impl SerializedFailure {
-    /// `SerializedFailure.getOwner` — decodes the leading 4-byte `Owner.Packed`
-    /// from `data` (Zig: `std.mem.bytesAsValue(Owner.Packed, data[0..4]).decode()`).
+    /// Decodes the leading 4-byte packed owner from `data`.
     pub fn get_owner(&self) -> Owner {
         let raw = u32::from_ne_bytes(
             self.data[0..4]
@@ -143,9 +136,8 @@ impl SerializedFailure {
         Packed::from_bits(raw).decode()
     }
 
-    /// `SerializedFailure.deinit` — releases `data`. The dev-server owns the
-    /// allocator in Zig; here `Box<[u8]>` drop suffices, but we keep the
-    /// signature so call sites stay 1:1 with the spec.
+    /// Releases `data`. `Box<[u8]>` drop suffices; the signature keeps a
+    /// `_dev` parameter so call sites read uniformly.
     pub fn deinit<D>(&self, _dev: &D) {
         // Drop happens via owner; nothing to do for the borrow form used by
         // `index_failures` (which iterates `&SerializedFailure`).
@@ -161,7 +153,6 @@ impl SerializedFailure {
         debug_assert!(!messages.is_empty());
 
         // Avoid small re-allocations without requesting so much from the heap
-        // PERF(port): was stack-fallback (std.heap.stackFallback(65536, dev.arena())) — profile if it shows up on a hot path.
         let mut payload: Vec<u8> = Vec::with_capacity(65536);
         let w = &mut payload;
 
@@ -173,8 +164,7 @@ impl SerializedFailure {
             write_log_msg(msg, w);
         }
 
-        // Zig avoided re-cloning if the stack-fallback had spilled to heap; with
-        // a plain Vec the buffer is always heap-backed, so just take ownership.
+        // The buffer is always heap-backed, so just take ownership.
         Ok(SerializedFailure {
             data: payload.into_boxed_slice(),
         })
@@ -231,11 +221,9 @@ pub enum ErrorKind {
 }
 
 // All "write" functions get a corresponding "read" function in ./client/error.ts
-// Zig: const Writer = std.array_list.Managed(u8).Writer;
 type Writer = Vec<u8>;
 
 fn write_log_msg(msg: &bun_ast::Msg, w: &mut Writer) {
-    // Zig: switch (msg.kind) { inline else => |k| @intFromEnum(@field(ErrorKind, "bundler_log_" ++ @tagName(k))) }
     let kind_byte = match msg.kind {
         bun_ast::Kind::Err => ErrorKind::BundlerLogErr,
         bun_ast::Kind::Warn => ErrorKind::BundlerLogWarn,
diff --git a/src/runtime/bake/dev_server/source_map_store.rs b/src/runtime/bake/dev_server/source_map_store.rs
index 9e39480fc5e..9c3372ca523 100644
--- a/src/runtime/bake/dev_server/source_map_store.rs
+++ b/src/runtime/bake/dev_server/source_map_store.rs
@@ -5,8 +5,6 @@
 //! maps that aren't reachable from IncrementalGraph can still be reached by
 //! a browser tab if it has a callback to a previously loaded chunk; so DevServer
 //! should be aware of it.
-//!
-//! Spec: src/runtime/bake/DevServer/SourceMapStore.zig
 
 use bun_collections::{ArrayHashMap, LinearFifo, linear_fifo::StaticBuffer};
 use bun_core::string_joiner::StringJoiner;
@@ -63,9 +61,6 @@ pub(crate) const WEAK_REF_ENTRY_MAX: usize = 16;
 /// IncrementalGraph stores partial source maps for each file. A
 /// `SourceMapStore.Entry` is the information + refcount holder to
 /// construct the actual JSON file associated with a bundle/hot update.
-// PORT NOTE: Zig's `dev_arena` allocator-handle field is dropped — its sole
-// reader was `Entry.arena()` which fed `paths`/`files` frees in `deinit`.
-// In Rust those are `Box`/`Vec` backed by the global mimalloc.
 #[derive(Default)]
 pub struct Entry {
     /// Sum of:
@@ -73,14 +68,13 @@ pub struct Entry {
     /// - For route bundle client scripts, +1 until invalidation.
     pub ref_count: u32,
     /// Indexes are off by one because this excludes the HMR Runtime.
-    // PORT NOTE: Zig borrowed inner slices from `IncrementalGraph.bundled_files
-    // .keys()`; that is self-referential w.r.t. `DevServer`, so the port stores
-    // owned copies instead. See PERF(port) in `IncrementalGraph::take_source_map`.
+    // Borrowing inner slices from `IncrementalGraph.bundled_files.keys()`
+    // would be self-referential w.r.t. `DevServer`, so owned copies are
+    // stored instead. See `IncrementalGraph::take_source_map`.
     pub paths: Box<[Box<[u8]>]>,
     /// Indexes are off by one because this excludes the HMR Runtime.
-    // PORT NOTE: Zig used `bun.MultiArrayList(PackedMap.Shared)` (SoA over a
-    // tagged union). `MultiArrayElement` cannot be derived for an enum and the
-    // column split buys nothing for a 2-word payload, so this is a plain `Vec`.
+    // An SoA column split buys nothing for a 2-word payload (and
+    // `MultiArrayElement` cannot be derived for an enum), so this is a plain `Vec`.
     pub files: Vec<packed_map::Shared>,
     /// The memory cost can be shared between many entries and IncrementalGraph
     /// so this is only used for eviction logic, to pretend this was the only
@@ -89,11 +83,6 @@ pub struct Entry {
 }
 
 impl Entry {
-    // PORT NOTE: Zig `sourceContents()` was dead code — it indexed
-    // `entry.source_contents` and `entry.file_paths`, fields removed in
-    // 67f0c3e016a (replaced by `paths` + `files`). Zig's lazy compilation
-    // never instantiated it; no callers exist. Dropped rather than stubbed.
-
     /// `SourceMapStore.Entry.renderMappings`.
     pub fn render_mappings(&self, kind: ChunkKind) -> Result<Vec<u8>, bun_core::Error> {
         let mut j = StringJoiner::default();
@@ -117,7 +106,6 @@ impl Entry {
         j.push_static(br#"{"version":3,"sources":["bun://Bun/Bun HMR Runtime""#);
 
         // This buffer is temporary, holding the quoted source paths, joined with commas.
-        // PERF(port): was arena-backed ArrayList; using global Vec since
         // `percent_encode_write` takes `&mut Vec<u8>`.
         let mut source_map_strings: Vec<u8> = Vec::new();
 
@@ -194,9 +182,9 @@ impl Entry {
                 source_map_strings.extend_from_slice(b"\"");
             }
         }
-        // PORT NOTE: Zig `j.pushStatic(source_map_strings.items)` borrows the
-        // arena-backed buffer for the lifetime of `j`; `source_map_strings`
-        // outlives `j.done_with_end()` below so the borrow is sound.
+        // `push_static` borrows the buffer for the lifetime of `j`;
+        // `source_map_strings` outlives `j.done_with_end()` below so the
+        // borrow is sound.
         j.push_static(source_map_strings.as_slice());
         j.push_static(br#"],"sourcesContent":["// (Bun's internal HMR runtime is minified)""#);
         for chunk in map_files {
@@ -248,7 +236,6 @@ impl Entry {
                 &json_bytes,
                 false,
             ) {
-                // PORT NOTE: Zig `bun.handleErrorReturnTrace` is a no-op in Rust.
                 bun_core::output::warn(format_args!("Could not dump bundle: {}", err));
             }
         }
@@ -268,8 +255,6 @@ impl Entry {
             return bun_core::percent_encode_write(utf8_input, out)
                 .map_err(EncodeSourceMapPathError::from);
         }
-        // PORT NOTE: Zig `array_list.writer()` + `writePreQuotedString(..., @TypeOf(writer), writer, ...)`
-        // → `&mut impl bun_io::Write` per PORTING.md §Type map "(comptime X: type, arg: X)".
         bun_js_printer::write_pre_quoted_string::<
             _,
             b'"',
@@ -289,8 +274,8 @@ impl Entry {
         let _ = side;
         let map_files = self.files.as_slice();
 
-        // PORT NOTE: Zig `comptime .init("self[Symbol.for(\"bun:hmr\")]({\n")`
-        // — only `line_count` is read here; the literal has exactly one '\n'.
+        // Only the line count of the prefix matters here; the literal has
+        // exactly one '\n'.
         const HMR_CHUNK_PREFIX: &[u8] = b"self[Symbol.for(\"bun:hmr\")]({\n";
         let runtime_line_count: u32 = match kind {
             ChunkKind::InitialResponse => bake::get_hmr_runtime(Side::Client).line_count,
@@ -361,12 +346,12 @@ impl Entry {
         Ok(())
     }
 
-    /// `SourceMapStore.Entry.deinit` — Rust drop handles `files` (each
-    /// `Shared` decrements its `Rc<PackedMap>`) and `paths` (outer box only;
-    /// inner slices are borrowed from IncrementalGraph and not freed).
+    /// Drop handles `files` (each `Shared` decrements its `Rc<PackedMap>`)
+    /// and `paths` (both the outer box and the owned inner `Box<[u8]>` path
+    /// copies).
     ///
-    /// PORT NOTE: not `impl Drop` — Zig only asserted `ref_count == 0` on the
-    /// explicit `unrefAtIndex` release path. Whole-store teardown and
+    /// Deliberately not `impl Drop` — the `ref_count == 0` assertion belongs
+    /// only on the explicit `unrefAtIndex` release path. Whole-store teardown and
     /// `*out = Entry { .. }` overwrites legitimately drop entries with nonzero
     /// counts, where a `Drop` assertion would diverge from spec and panic.
     pub fn deinit(&mut self) {
@@ -456,9 +441,6 @@ pub struct GetResult<'a> {
     pub file_paths: &'a [Box<[u8]>],
     pub entry_files: &'a [packed_map::Shared],
 }
-// PORT NOTE: Zig `GetResult.deinit` only freed `mappings`; Rust drops it
-// automatically — no `impl Drop` needed.
-
 pub struct SourceMapStore {
     pub entries: ArrayHashMap<Key, Entry>,
     /// When a HTML bundle is loaded, it places a "weak reference" to the
@@ -490,8 +472,7 @@ impl Default for SourceMapStore {
 bun_core::impl_field_parent! { SourceMapStore => DevServer.source_maps; pub fn mut owner; }
 
 impl SourceMapStore {
-    /// `SourceMapStore.empty` (Zig: `pub const empty: Self = .{ ... }`).
-    /// PORT NOTE: ArrayHashMap/LinearFifo have no `const fn` ctors; callers use
+    /// ArrayHashMap/LinearFifo have no `const fn` ctors; callers use
     /// this in lieu of a `const`.
     #[inline]
     pub fn empty() -> Self {
@@ -513,14 +494,13 @@ impl SourceMapStore {
             debug_assert!(ref_count > 0); // invalid state
             *gop.value_ptr = Entry {
                 ref_count,
-                // Zig left these `undefined`; caller fills them.
+                // Caller fills these.
                 overlapping_memory_cost: 0,
                 paths: Box::default(),
                 files: Vec::new(),
             };
             Ok(PutOrIncrementRefCount::Uninitialized(gop.value_ptr))
         } else {
-            // Zig: `bun.debugAssert(ref_count >= 0)` — always true for u32.
             gop.value_ptr.ref_count += ref_count;
             Ok(PutOrIncrementRefCount::Shared(gop.value_ptr))
         }
@@ -542,13 +522,11 @@ impl SourceMapStore {
         let e = &mut self.entries.values_mut()[index];
         e.ref_count -= count;
         if cfg!(debug_assertions) {
-            // PORT NOTE: reshaped for borrowck — read key after mutable borrow ends.
             let rc = e.ref_count;
             let key = self.entries.keys()[index].get();
             map_log!("dec {:x}, {} | {} -> {}", key, count, rc + count, rc);
         }
         if self.entries.values()[index].ref_count == 0 {
-            // Zig: e.deinit(); store.entries.swapRemoveAt(index);
             // `swap_remove_at` drops the Entry, freeing `files`/`paths`;
             // the `ref_count == 0` invariant is the branch condition itself.
             self.entries.swap_remove_at(index);
@@ -564,7 +542,6 @@ impl SourceMapStore {
         };
         entry.ref_count += 1;
         let entry_ref_count = entry.ref_count;
-        // PORT NOTE: reshaped for borrowck — drop `entry` borrow before touching weak_refs/owner.
 
         let mut new_weak_ref_count: u32 = 1;
 
@@ -629,7 +606,6 @@ impl SourceMapStore {
             }
         }
         if !found {
-            // Zig `for { ... } else { entry.ref_count += @intFromEnum(mode); }`
             let entry = self.entries.get_mut(&key).unwrap();
             entry.ref_count += mode as u32;
         }
@@ -655,8 +631,7 @@ impl SourceMapStore {
 
     /// `SourceMapStore.sweepWeakRefs` — pop expired weak-refs, decrement,
     /// reschedule. Called from the high-tier `EventLoopTimer` dispatch with
-    /// the raw `*EventLoopTimer` (Zig recovers the store via
-    /// `@fieldParentPtr("weak_ref_sweep_timer", t)`).
+    /// the raw `*EventLoopTimer`.
     ///
     /// # Safety
     /// `timer` must point to the `weak_ref_sweep_timer` field of a live
@@ -677,14 +652,14 @@ impl SourceMapStore {
         // SAFETY: invariant of `owner()` — store is the `source_maps` field of a live DevServer.
         debug_assert!(unsafe { (*store.owner()).magic } == Magic::Valid);
 
-        // PORT NOTE: Zig compared `i64 expire <= u64 now` with mathematically-correct
-        // mixed-sign semantics (negative expire ⇒ expired). Keep `now` as i64 (already
-        // clamped ≥0) so the comparison stays sign-correct without u64 wrap.
+        // Mixed-sign comparison: a negative `expire` must count as expired.
+        // Keep `now` as i64 (already clamped ≥0) so the comparison stays
+        // sign-correct without u64 wrap.
         let now: i64 = now_ts.sec.max(0);
 
-        // PORT NOTE: Zig `defer store.owner().emitMemoryVisualizerMessageIfNeeded()`
-        // inlined at both returns (a scopeguard cannot capture &mut store across
-        // the loop body without aliasing).
+        // `emitMemoryVisualizerMessageIfNeeded` is inlined at both returns
+        // (a scopeguard cannot capture &mut store across the loop body
+        // without aliasing).
 
         while let Some(item) = store.weak_refs.read_item() {
             if item.expire <= now {
@@ -721,8 +696,8 @@ impl SourceMapStore {
         let vlq_bytes = entry
             .render_mappings(script_id_decoded.kind())
             .expect("OOM");
-        // PERF(port): Zig used arena for both `arena` and `gpa` here;
-        // render_mappings now returns Vec<u8> (global alloc).
+        // PERF: `render_mappings` returns `Vec<u8>` (global alloc); could
+        // use an arena.
 
         match source_map::mapping::parse(
             &vlq_bytes,
diff --git a/src/runtime/bake/hmr-module.ts b/src/runtime/bake/hmr-module.ts
index 93511937734..92cf0ee0f1e 100644
--- a/src/runtime/bake/hmr-module.ts
+++ b/src/runtime/bake/hmr-module.ts
@@ -68,7 +68,7 @@ interface CJSModule {
   require: (id: Id) => unknown;
 }
 
-/** Implementation details must remain in sync with js_parser.zig and bundle_v2.zig */
+/** Implementation details must remain in sync with the parser (src/js_parser) and bundler (src/bundler/bundle_v2.rs) */
 export class HMRModule {
   /** Key in `registry` */
   id: Id;
diff --git a/src/runtime/bake/hmr-runtime-client.ts b/src/runtime/bake/hmr-runtime-client.ts
index 4ee95201f38..a2c411ef5a1 100644
--- a/src/runtime/bake/hmr-runtime-client.ts
+++ b/src/runtime/bake/hmr-runtime-client.ts
@@ -135,8 +135,8 @@ const handlers = {
   [MessageId.hot_update](view) {
     const reader = new DataViewReader(view, 1);
 
-    // The code genearting each list is annotated with equivalent "List n"
-    // comments in DevServer.zig's finalizeBundle function.
+    // The code generating each list is annotated with equivalent "List n"
+    // comments in DevServer.rs's finalize_bundle function.
 
     // List 1
     const serverSideRoutesUpdated = new Set();
diff --git a/src/runtime/bake/mod.rs b/src/runtime/bake/mod.rs
index 3a3f5fe989c..39d4d9f35b9 100644
--- a/src/runtime/bake/mod.rs
+++ b/src/runtime/bake/mod.rs
@@ -47,7 +47,7 @@ pub mod jsc {
 pub const API_NAME: &str = "app";
 
 // ══════════════════════════════════════════════════════════════════════════
-// bake.zig top-level types
+// Top-level types
 // ══════════════════════════════════════════════════════════════════════════
 
 pub use bun_bundler::bake_types::BuiltInModule;
@@ -68,25 +68,22 @@ pub enum Mode {
 
 /// `bake.Framework.ServerComponents`.
 ///
-/// PORT NOTE: string fields are arena-backed at runtime (freed via
-/// `UserOptions.arena.deinit()`, bake.zig:23) but default to static literals
-/// (bake.zig:360-367). `Cow<'static, [u8]>` covers both without leaking.
+/// String fields are arena-backed at runtime but default to static literals.
+/// `Cow<'static, [u8]>` covers both without leaking.
 #[derive(Clone)]
 pub struct ServerComponents {
     pub separate_ssr_graph: bool,
-    /// REQUIRED — spec (bake.zig:360) gives no default; `fromJS` throws if
-    /// `serverRuntimeImportSource` is absent (bake.zig:511-513).
+    /// REQUIRED — `fromJS` throws if `serverRuntimeImportSource` is absent.
     pub server_runtime_import: Cow<'static, [u8]>,
     pub server_register_client_reference: Cow<'static, [u8]>,
     pub server_register_server_reference: Cow<'static, [u8]>,
     pub client_register_server_reference: Cow<'static, [u8]>,
 }
-// PORT NOTE: no `Default` impl — `server_runtime_import` is a required field
-// in the spec (bake.zig:360 has no `= "..."` initializer). Callers must
+// No `Default` impl — `server_runtime_import` is a required field. Callers must
 // supply it explicitly (`Framework::react()` sets `"react-server-dom-bun/server"`).
 impl ServerComponents {
-    /// Construct with the spec defaults for the three `register*` exports
-    /// (bake.zig:362-367); `server_runtime_import` must be supplied.
+    /// Construct with the defaults for the three `register*` exports;
+    /// `server_runtime_import` must be supplied.
     pub fn new(server_runtime_import: Cow<'static, [u8]>) -> Self {
         Self {
             separate_ssr_graph: false,
@@ -113,16 +110,13 @@ impl Default for ReactFastRefresh {
 /// `bake.Framework.FileSystemRouterType`. Full body (with `Style` enum and
 /// `from_js`) lives in the gated `bake_body.rs` draft; only the field set
 /// DevServer touches is named here.
-// PORT NOTE: dropped `#[derive(Clone)]` — `framework_router::Style` is now the
-// body enum (carries `JavascriptDefined(jsc::Strong)`, not `Clone`). Spec
-// `Style` has a `deinit()` (FrameworkRouter.zig), so it was never trivially
-// copyable.
+// Deliberately not `Clone` — `framework_router::Style` is the
+// body enum (carries `JavascriptDefined(jsc::Strong)`, not `Clone`).
 pub struct FileSystemRouterType {
     pub root: Cow<'static, [u8]>,
     pub prefix: Cow<'static, [u8]>,
     pub entry_client: Option<Cow<'static, [u8]>>,
-    /// REQUIRED — spec bake.zig:346 is `[]const u8` (non-optional). `fromJS`
-    /// throws if missing (bake.zig:573-575); `Framework.resolve` (bake.zig:404)
+    /// REQUIRED — `fromJS` throws if missing; `Framework.resolve`
     /// dereferences unconditionally.
     pub entry_server: Cow<'static, [u8]>,
     pub ignore_underscores: bool,
@@ -138,10 +132,8 @@ pub struct FileSystemRouterType {
 /// always arena-allocated, usually owned by the arena in `UserOptions`.
 pub struct Framework {
     pub is_built_in_react: bool,
-    /// Spec (bake.zig:248) is `[]FileSystemRouterType` — a *mutable*
-    /// arena-owned slice that `Framework.resolve` (bake.zig:401-404) rewrites
-    /// in place. Owned `Vec` so `resolve()` can take `&mut` and so the arena
-    /// free in `UserOptions::drop` is mirrored by `Vec::drop`.
+    /// Owned `Vec` so `resolve()` can take `&mut` and rewrite entries in
+    /// place; freed by `Vec::drop`.
     pub file_system_router_types: Vec<FileSystemRouterType>,
     pub server_components: Option<ServerComponents>,
     pub react_fast_refresh: Option<ReactFastRefresh>,
@@ -164,8 +156,7 @@ impl Framework {
     /// TYPE_ONLY view (`bun_bundler::bake_types::Framework`). The bundler is a
     /// lower-tier crate and cannot name `bun_runtime::bake::Framework`; this is
     /// the value `init_transpiler` arena-allocates and hands to
-    /// `out.options.framework` (spec bake.zig:778 `out.options.framework =
-    /// framework`).
+    /// `out.options.framework`.
     pub(crate) fn as_bundler_view(&self) -> bun_bundler::bake_types::Framework {
         use bun_bundler::bake_types as bt;
         let mut built_in_modules = bun_collections::StringArrayHashMap::new();
@@ -209,7 +200,7 @@ impl Framework {
         )
     }
 
-    /// `bake.Framework.initTranspiler` (bake.zig:663). Sets up a per-graph
+    /// Sets up a per-graph
     /// `Transpiler` in place. The full body lives in
     /// `bake_body::Framework::init_transpiler_with_options`; this keystone
     /// version operates on the keystone `BuildConfigSubset` (which omits
@@ -278,17 +269,14 @@ impl Framework {
 
         out.options.production = mode != Mode::Development;
         out.options.tree_shaking = mode != Mode::Development;
-        // Spec `initTranspiler` (bake.zig:681-692) forwards `null,null,null` for
-        // the three minify overrides into `initTranspilerWithOptions`, so the
-        // wrapper always defaults them to `mode != .development` regardless of
-        // `BuildConfigSubset`. User-supplied minify flags are only honored by
-        // `init_transpiler_with_options` (bake_body).
+        // The three minify overrides always default to `mode != Development`
+        // here regardless of `BuildConfigSubset`. User-supplied minify flags
+        // are only honored by `init_transpiler_with_options` (bake_body).
         out.options.minify_syntax = mode != Mode::Development;
         out.options.minify_identifiers = mode != Mode::Development;
         out.options.minify_whitespace = mode != Mode::Development;
         out.options.css_chunking = true;
-        // Spec bake.zig:778 `out.options.framework = framework` stores a borrowed
-        // `*bake.Framework`. The bundler crate (lower tier) carries a TYPE_ONLY
+        // The bundler crate (lower tier) carries a TYPE_ONLY
         // projection (`bake_types::Framework`); construct it here and give it
         // arena lifetime so `BundleOptions<'a>` can borrow it for the bundle pass.
         let framework_view: *mut bun_bundler::bake_types::Framework =
@@ -314,8 +302,7 @@ impl Framework {
             out.options.env.behavior = bundler_options.env;
             out.options.env.prefix = bundler_options.env_prefix.unwrap_or(b"").into();
         }
-        // Spec bake.zig:788 `out.resolver.opts = out.options` (struct copy). The
-        // resolver crate carries a FORWARD_DECL subset of `BundleOptions`, so
+        // The resolver crate carries a FORWARD_DECL subset of `BundleOptions`, so
         // re-project via the dedicated helper rather than `Clone`.
         out.sync_resolver_opts();
 
@@ -366,13 +353,13 @@ impl Framework {
             out.options.asset_naming = b"_bun/[hash].[ext]".as_slice().into();
         }
 
-        // Spec bake.zig:821 — re-sync after define/naming mutations so the
+        // Re-sync after define/naming mutations so the
         // resolver sees the final option set.
         out.sync_resolver_opts();
         Ok(framework_view)
     }
 
-    /// `bake.Framework.resolve` (bake.zig:401). Resolves built-in module
+    /// Resolves built-in module
     /// specifiers and entry points against the resolvers; returns a clone
     /// with resolved paths. Errors written into `r.log`.
     pub fn resolve(
@@ -455,7 +442,7 @@ impl Framework {
                 *path = Cow::Owned(p.text.to_vec());
             }
             Err(err) => {
-                // Spec bake.zig:422 routes through `bun.Output.err` (stderr), not
+                // This routes through `Output::err` (stderr), not
                 // `r.log`. The "Errors written into r.log" doc on `Framework.resolve`
                 // refers to entries the resolver itself pushed; this top-level
                 // "Failed to resolve" line goes to the terminal.
@@ -469,10 +456,8 @@ impl Framework {
         }
     }
 
-    /// `bake.Framework.react_install_command` (bake.zig:373).
     pub const REACT_INSTALL_COMMAND: &str = "bun i react@experimental react-dom@experimental react-server-dom-bun react-refresh@experimental";
 
-    /// `bake.Framework.addReactInstallCommandNote` (bake.zig:375).
     pub fn add_react_install_command_note(log: &mut bun_ast::Log) {
         log.add_msg(bun_ast::Msg {
             kind: bun_ast::Kind::Note,
@@ -504,8 +489,7 @@ pub struct SplitBundlerOptions {
 // ─── bake_body → keystone bridges ────────────────────────────────────────────
 // LAYERING: `UserOptions` (bake_body.rs) carries `&'static [u8]`-backed
 // duplicates of `Framework`/`SplitBundlerOptions`; `DevServer::Options`
-// (DevServer.rs) wants the keystone Cow-backed types defined above. Both
-// mirror the single Zig `bake.Framework`/`bake.SplitBundlerOptions`. Until the
+// (DevServer.rs) wants the keystone Cow-backed types defined above. Until the
 // two struct families unify (tracked by the `convert_file_system_router_type`
 // note in ServerConfig.rs), bridge by-value here so `server/mod.rs` can hand
 // `config.bake` straight into `DevServer::init`. All `&'static [u8]` →
@@ -573,7 +557,7 @@ impl From<bake_body::Framework> for Framework {
 }
 impl From<bake_body::BuildConfigSubset> for BuildConfigSubset {
     fn from(src: bake_body::BuildConfigSubset) -> Self {
-        // PORT NOTE: keystone `BuildConfigSubset` mirrors the field-set
+        // `BuildConfigSubset` mirrors the field-set
         // `Framework::init_transpiler` reads (everything except `loader` /
         // `source_map`, which only `init_transpiler_with_options` honours).
         Self {
@@ -604,7 +588,7 @@ impl From<bake_body::SplitBundlerOptions> for SplitBundlerOptions {
 
 /// `bake.SplitBundlerOptions.BuildConfigSubset`. Full body (with `from_js`)
 /// lives in `bake_body.rs`; this keystone mirror carries every field that
-/// `Framework::init_transpiler` (bake.zig:663→696) reads so DevServer's
+/// `Framework::init_transpiler` reads so DevServer's
 /// per-graph transpilers see bunfig `[serve.static]` define/env/conditions.
 #[derive(Default)]
 pub struct BuildConfigSubset {
@@ -627,7 +611,7 @@ pub struct BuildConfigSubset {
 /// (`pub use super::HmrRuntime;`) so `bake_body::get_hmr_runtime` returns the
 /// same nominal type IncrementalGraph names via `crate::bake::HmrRuntime`.
 pub struct HmrRuntime {
-    /// Spec bake.zig:841 is `[:0]const u8` — NUL-terminated; the sentinel is
+    /// NUL-terminated; the sentinel is
     /// load-bearing where this buffer is handed to JSC/C++ as a C string.
     pub code: &'static bun_core::ZStr,
     pub line_count: u32,
@@ -649,14 +633,9 @@ pub use bake_body::StringRefList;
 // FrameworkRouter
 // ══════════════════════════════════════════════════════════════════════════
 pub mod framework_router {
-    // PORT NOTE: this module used to carry duplicate "keystone" stub structs
-    // (`Route`, `Type`, `FrameworkRouter`, `MatchedParams`, `EncodedPattern`)
-    // alongside the real defs in `framework_router_body` (FrameworkRouter.rs).
-    // The two nominal type sets diverged and forced placeholder shims. The body
-    // module is now fully ported and un-gated, so re-export everything so
-    // `framework_router::X` ≡ `framework_router_body::X` and the real method
-    // bodies (`init_empty`, `match_slow`, `memory_cost`, `to_js`, …) resolve
-    // directly.
+    // Everything is re-exported from `framework_router_body`
+    // (FrameworkRouter.rs) so `framework_router::X` ≡
+    // `framework_router_body::X` and the real method bodies resolve directly.
     /// `generated_js2native.rs` lowers `JSFrameworkRouter.getBindings` to
     /// `framework_router::js_framework_router::get_bindings`; alias the type so
     /// the associated-fn path resolves.
@@ -667,15 +646,11 @@ pub mod framework_router {
         RouteIndex, StaticRouteMap, Style, TinyLog, Type, TypeIndex,
     };
 
-    /// `FrameworkRouter.InsertionContext` — Zig used an `*anyopaque` +
-    /// comptime fn-ptr `VTable` pair with a `wrap(T, ptr)` helper that
-    /// generated trampolines. The Rust port maps that to a trait object
-    /// (`&mut dyn InsertionHandler`); this is the `wrap` shim only, kept so
-    /// callsites read `InsertionContext::wrap(&mut ctx)` like the spec.
+    /// `wrap` shim over the trait-object form (`&mut dyn InsertionHandler`),
+    /// kept so callsites read `InsertionContext::wrap(&mut ctx)`.
     pub(crate) enum InsertionContext {}
     impl InsertionContext {
-        /// Zig: `InsertionContext.wrap(T, ptr)` — comptime vtable generation.
-        /// Port: thin shim over the trait-object form (`&mut dyn InsertionHandler`).
+        /// Thin shim over the trait-object form (`&mut dyn InsertionHandler`).
         #[inline]
         pub(crate) fn wrap<T: InsertionHandler>(ctx: &mut T) -> &mut dyn InsertionHandler {
             ctx
@@ -698,5 +673,3 @@ pub mod production {
 // ══════════════════════════════════════════════════════════════════════════
 pub mod dev_server;
 pub use dev_server as DevServer;
-
-// ported from: src/bake/bake.zig
diff --git a/src/runtime/bake/production.rs b/src/runtime/bake/production.rs
index 011146958f3..5b0f4d695b9 100644
--- a/src/runtime/bake/production.rs
+++ b/src/runtime/bake/production.rs
@@ -43,7 +43,7 @@ bun_core::define_scoped_log!(log, production, visible);
 
 /// Local shim: `bun_core::Error` has no `From<bun_jsc::JsError>` (tier-0 cannot
 /// depend on tier-6). Map every JS-side failure to the `"JSError"` sentinel the
-/// caller already pattern-matches on (production.zig: `error.JSError`).
+/// caller already pattern-matches on.
 #[inline(always)]
 fn js_err(_: bun_jsc::JsError) -> bun_core::Error {
     bun_core::err!("JSError")
@@ -60,17 +60,14 @@ fn side_name(s: bun_bundler::options::Side) -> &'static str {
     }
 }
 
-/// Process-lifetime backing storage for the dotenv singleton (mirrors Zig's
-/// `allocator.create(DotEnv.Map)` + `allocator.create(DotEnv.Loader)` that are
-/// never freed). PORTING.md §Forbidden bans leaking; `OnceLock` owns the
-/// allocation instead. `Loader` self-borrows `Map`, so both live in one cell.
+/// Process-lifetime backing storage for the dotenv singleton; `OnceLock` owns
+/// the allocation. `Loader` self-borrows `Map`, so both live in one cell.
 struct DotenvSingleton {
     map: UnsafeCell<dotenv::Map>,
     loader: UnsafeCell<MaybeUninit<dotenv::Loader<'static>>>,
 }
 // SAFETY: `build_command` runs single-threaded during CLI init; the singleton
-// is set exactly once before any reader exists (same invariant the Zig
-// `pub var instance: ?*Loader` had).
+// is set exactly once before any reader exists.
 unsafe impl Sync for DotenvSingleton {}
 static DOTENV_SINGLETON: OnceLock<DotenvSingleton> = OnceLock::new();
 
@@ -95,9 +92,8 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
             Global::crash();
         }
     };
-    // PORT NOTE: reshaped for borrowck — clone the cwd slice so the PathBuffer
-    // borrow doesn't span the rest of the function (matches `cwd: []const u8`
-    // semantics in the Zig spec since the buffer is never reused).
+    // Note: reshaped for borrowck — clone the cwd slice so the PathBuffer
+    // borrow doesn't span the rest of the function (the buffer is never reused).
     let cwd: Box<[u8]> = Box::from(cwd);
 
     // Create a VM + global for loading the config file, plugins, and
@@ -105,7 +101,6 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
     jsc::initialize(false);
     bun_ast::initialize_store();
 
-    // PERF(port): was MimallocArena bulk-free — VM allocator now global mimalloc.
     let mut arena = Arena::new();
 
     let vm_ptr = VirtualMachine::init_bake(jsc::virtual_machine::Options {
@@ -119,7 +114,7 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
     // unique access for the rest of this function.
     let vm = unsafe { &mut *vm_ptr };
     // defer vm.deinit() — handled by `vm.destroy()` on the unwind path below.
-    // PORT NOTE: pass `vm_ptr` by value into the guard so the drop closure does
+    // Note: pass `vm_ptr` by value into the guard so the drop closure does
     // not borrow the local (`defer!` would capture `&vm_ptr`, which under
     // edition-2024 disjoint-capture rules collides with the `&mut *vm_ptr`
     // re-borrows on the JSError path).
@@ -134,16 +129,14 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
     vm.event_loop_ref().ensure_waker();
     {
         let b = &mut vm.transpiler;
-        // TODO(port): preload/argv are `Vec<Box<[u8]>>` on both sides; clone since
-        // ctx outlives vm but Zig assigned slices directly (no ownership transfer).
-        // Could change VM fields to borrow from ctx.
+        // preload/argv are `Vec<Box<[u8]>>`; clone because the VM owns its
+        // fields. Startup-only, so the copies are not hot.
         vm.preload.clone_from(&ctx.preloads);
         vm.argv.clone_from(&ctx.passthrough);
         vm.arena = NonNull::new(&raw mut arena);
         // vm.allocator = arena.arena() — dropped per §Allocators
-        // Spec production.zig:50: `b.options.install = ctx.install` (raw
-        // `?*const Api.BunInstall` copy). `BundleOptions.install` is now
-        // `Option<NonNull<_>>`, so no lifetime-extension cast is needed.
+        // `BundleOptions.install` is `Option<NonNull<_>>`, so no
+        // lifetime-extension cast is needed.
         let install_ptr = ctx.install.as_deref().map(NonNull::from);
         b.options.install = install_ptr;
         b.resolver.opts.install = install_ptr;
@@ -153,10 +146,10 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
             .offline_mode_setting
             .unwrap_or(OfflineMode::Online)
             == OfflineMode::Offline;
-        // PORT NOTE: `bun_resolver::options::BundleOptions` has no
-        // `prefer_latest_install` field in the Rust port; compute the value once
-        // and assign only to `b.options` (which does carry it). The Zig source
-        // mirrored it onto resolver.opts but the resolver never reads it.
+        // Note: `bun_resolver::options::BundleOptions` has no
+        // `prefer_latest_install` field; compute the value once
+        // and assign only to `b.options` (which does carry it). The resolver
+        // never reads it.
         let prefer_latest = ctx
             .debug
             .offline_mode_setting
@@ -165,8 +158,7 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
         b.options.global_cache = b.resolver.opts.global_cache;
         b.options.prefer_offline_install = b.resolver.opts.prefer_offline_install;
         b.options.prefer_latest_install = prefer_latest;
-        // SAFETY: spec production.zig:56 `b.resolver.env_loader = b.env` — raw
-        // pointer copy. `b.env` is the Transpiler-owned `*mut Loader`; store it
+        // SAFETY: `b.env` is the Transpiler-owned `*mut Loader`; store it
         // as `NonNull` (not `&Loader`) because `configure_defines()` below
         // reborrows the same allocation as `&mut Loader` via `run_env_loader()`,
         // which would alias a live `&Loader` here. The Loader outlives the
@@ -175,9 +167,9 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
         b.options.minify_identifiers = ctx.bundler_options.minify_identifiers;
         b.options.minify_whitespace = ctx.bundler_options.minify_whitespace;
         b.options.ignore_dce_annotations = ctx.bundler_options.ignore_dce_annotations;
-        // PORT NOTE: `bun_resolver::options::BundleOptions` has no
-        // `minify_identifiers`/`minify_whitespace` fields; the Zig mirror onto
-        // resolver.opts is dropped (the resolver never reads them).
+        // Note: `bun_resolver::options::BundleOptions` has no
+        // `minify_identifiers`/`minify_whitespace` fields; resolver.opts does
+        // not carry them (the resolver never reads them).
         b.options.env.behavior = bundler_options::EnvBehavior::LoadAllWithoutInlining;
     }
     vm.event_loop_ref().ensure_waker();
@@ -186,9 +178,7 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
             vm.transpiler.options.no_macros = true;
         }
         MacroOptions::Map(macros) => {
-            // PORT NOTE: Zig spec is `b.options.macro_remap = macros;` — a
-            // shallow struct copy where both maps share the same backing
-            // string slices owned by `ctx`. The two Rust types are nominally
+            // Note: the two map types are nominally
             // distinct (`ArrayHashMap<Box<[u8]>, ArrayHashMap<Box<[u8]>, Box<[u8]>>>`
             // vs `StringArrayHashMap<StringArrayHashMap<Box<[u8]>>>`), so
             // rebuild the resolver-shaped map by cloning value bytes.
@@ -220,17 +210,15 @@ pub fn build_command(ctx: Context) -> Result<(), bun_core::Error> {
     //
     // Declaration order matters: `_api_lock` is bound before `pt` so LIFO drop
     // detaches `pt` (a JSC FFI call) *while the API lock is still held*, then
-    // releases the lock — matching Zig's `defer api_lock.release()` ordering.
+    // releases the lock.
     let _api_lock = unsafe { (*vm.jsc_vm).get_api_lock() };
 
-    // PORT NOTE: `PerThread` owns its data in Rust (Zig held borrowed slices
-    // into `buildWithVm` locals, which is fine in Zig but unrepresentable for a
-    // value living in this frame). Start with an empty placeholder so Drop
+    // Note: `PerThread` owns its data. Start with an empty placeholder so Drop
     // (which detaches the C++-side per-thread pointer) runs in this frame's
     // LIFO order — under the API lock, before the VM is destroyed.
     let mut pt = PerThread::placeholder(vm_ptr);
 
-    // PORT NOTE: reshaped for borrowck — `pt.vm` already borrows `*vm`, so pass
+    // Note: reshaped for borrowck — `pt.vm` already borrows `*vm`, so pass
     // the raw VM pointer and re-borrow inside.
     match build_with_vm(ctx, &cwd, vm_ptr, &mut pt) {
         Ok(()) => {}
@@ -432,7 +420,7 @@ pub(super) fn build_with_vm(
         .unwrap_or(false);
 
     // this is probably wrong
-    // PORT NOTE: process-lifetime dotenv singleton owned via `OnceLock`
+    // Note: process-lifetime dotenv singleton owned via `OnceLock`
     // (PORTING.md §Forbidden: no leaking). `Loader` self-borrows `Map`,
     // so both live in `DOTENV_SINGLETON`.
     let backing = DOTENV_SINGLETON.get_or_init(|| DotenvSingleton {
@@ -450,10 +438,8 @@ pub(super) fn build_with_vm(
     loader.map.put(b"NODE_ENV", b"production")?;
     dotenv::set_instance(std::ptr::from_mut::<dotenv::Loader<'static>>(loader));
 
-    // TODO(port): Zig used `var x: Transpiler = undefined;` + out-param init.
-    // PORTING.md §Exception — out-param constructors: reshape to a returned
-    // value once `init_transpiler_with_options` is reshaped; for now use
-    // `MaybeUninit` to mirror the in-place-init contract.
+    // In-place init via `MaybeUninit` (`init_transpiler_with_options`
+    // keeps the out-param shape shared with the dev-server path).
     let mut client_transpiler = MaybeUninit::<Transpiler>::uninit();
     let mut server_transpiler = MaybeUninit::<Transpiler>::uninit();
     let mut ssr_transpiler = MaybeUninit::<Transpiler>::uninit();
@@ -517,7 +503,7 @@ pub(super) fn build_with_vm(
             transpiler.options.minify_syntax = false;
             transpiler.options.minify_identifiers = false;
             transpiler.options.minify_whitespace = false;
-            // PORT NOTE: `bun_resolver::options::BundleOptions` carries no naming
+            // Note: `bun_resolver::options::BundleOptions` carries no naming
             // templates; the canonical fields live on `transpiler.options`
             // (bun_bundler::options::BundleOptions).
             transpiler.options.entry_naming =
@@ -563,10 +549,10 @@ pub(super) fn build_with_vm(
     let mut root_dir_buf = PathBuffer::uninit();
     let root_dir_path =
         resolve_path::join_abs_string_buf::<platform::Auto>(cwd, &mut root_dir_buf.0, &[b"dist"]);
-    // PORT NOTE: reshaped for borrowck — copy out so root_dir_buf can drop.
+    // Note: reshaped for borrowck — copy out so root_dir_buf can drop.
     let root_dir_path: Box<[u8]> = Box::from(root_dir_path);
 
-    // PORT NOTE: borrowck — `framework` is `&mut options.framework`; reborrow
+    // Note: borrowck — `framework` is `&mut options.framework`; reborrow
     // through it instead of `options.framework` to avoid stacking borrows.
     let mut router_types: Vec<framework_router::Type> =
         Vec::with_capacity(framework.file_system_router_types.len());
@@ -609,7 +595,7 @@ pub(super) fn build_with_vm(
                 .map(|s| Box::<[u8]>::from(*s))
                 .collect(),
             // `Style` is `Clone` (the `JavascriptDefined` arm panics inside
-            // `clone()`, matching the Zig spec's `@panic("TODO")`).
+            // `clone()`).
             style: fsr.style.clone(),
             allow_layouts: fsr.allow_layouts,
             server_file: OpaqueFileId::init(server_file.get()),
@@ -629,8 +615,8 @@ pub(super) fn build_with_vm(
     // `is_built_in_react` via its lower-tier `bake_types::Framework` view.
     // Project once here via the shared helper so the field-shape (e.g.
     // `BuiltInModule` `&'static [u8]` → `Box<[u8]>`) stays in one place.
-    // TODO(port): collapse `bake_body::Framework` into `bun_bundler::bake_types::Framework`
-    // once `FileSystemRouterType`/`framework_router::Style` move down to bun_bundler.
+    // (The two Framework types could only merge if `FileSystemRouterType` /
+    // `framework_router::Style` moved down to bun_bundler.)
     let bundler_framework = framework.as_bundler_view();
 
     let bundled_outputs_list: Vec<OutputFile> = {
@@ -647,14 +633,14 @@ pub(super) fn build_with_vm(
             server_ptr
         };
 
-        // Zig: `.{ .js = vm.event_loop }` — construct the `AnyEventLoop` enum
+        // Construct the `AnyEventLoop` enum
         // value (NOT a pointer-cast: the bundler matches on its discriminant).
         // Lives in this block's stack frame, outliving the bundle call.
         let mut any_loop = bun_event_loop::AnyEventLoop::js(vm.event_loop().cast());
 
-        // Spec production.zig:312 — plain `try`; propagate via `?`. Do NOT
+        // Propagate via `?`. Do NOT
         // catch-and-exit here: the bake path expects this call to succeed for
-        // valid inputs, and any `BuildFailed` indicates a port bug upstream
+        // valid inputs, and any `BuildFailed` indicates a bug upstream
         // (in the bundler), not a user-facing diagnostic to swallow.
         BundleV2::generate_from_bake_production_cli(
             &entry_points,
@@ -679,7 +665,7 @@ pub(super) fn build_with_vm(
     bun_core::pretty_errorln!("Rendering routes");
     Output::flush();
 
-    // Zig: `try std.fs.cwd().makeOpenPath("dist", .{})` — mkdir -p + open.
+    // mkdir -p + open.
     let root_dir = bun_sys::Dir::cwd().make_open_path(b"dist", Default::default())?;
 
     let mut maybe_runtime_file_index: Option<u32> = None;
@@ -1017,7 +1003,7 @@ pub(super) fn build_with_vm(
 
         let route = router.route_ptr(route_index);
         let main_file_route_index = route.file_page.unwrap();
-        // PORT NOTE: reshaped for borrowck — `pt.output_file()` borrows `pt`
+        // Note: reshaped for borrowck — `pt.output_file()` borrows `pt`
         // immutably, but `pt.preload_bundled_module()` below needs `&mut pt`.
         // Fetch the output file fresh at each use site instead of binding it.
 
@@ -1268,8 +1254,7 @@ fn load_module(
     // S012: `JSInternalPromise` (= `JSPromise`) is an `opaque_ffi!` ZST —
     // safe `*mut → &mut` deref via the const-asserted accessor.
     jsc::JSInternalPromise::opaque_mut(promise).set_handled();
-    // PORT NOTE: Zig's `*VirtualMachine` is a freely-aliasing mutable pointer.
-    // We take `*mut VirtualMachine` (not `&VirtualMachine`) so the provenance
+    // Note: we take `*mut VirtualMachine` (not `&VirtualMachine`) so the provenance
     // permits mutation — casting a `&T` to `*mut T` and writing through it is
     // UB. The raw pointer flows from `VirtualMachine::init_bake` unchanged.
     //
@@ -1294,8 +1279,6 @@ fn load_module(
 
 // extern apis:
 
-// TODO: Dedupe
-// TODO(port): move to bake_sys
 unsafe extern "C" {
     safe fn BakeGetDefaultExportFromModule(global: &JSGlobalObject, key: JSValue) -> JSValue;
     safe fn BakeGetModuleNamespace(global: &JSGlobalObject, key: JSValue) -> JSValue;
@@ -1324,7 +1307,6 @@ fn bake_get_on_module_namespace(
 }
 
 // Renders all routes for static site generation by calling the JavaScript implementation.
-// TODO(port): move to bake_sys
 // All args are by-value `JSValue`/`BunString` plus a live `&JSGlobalObject`
 // (UnsafeCell-backed); C++ allocates and returns a non-null `JSPromise*`.
 // No caller-side precondition for the call itself — declare `safe fn`.
@@ -1365,7 +1347,6 @@ pub(super) extern "C" fn BakeToWindowsPath(input: BunString) -> BunString {
     }
     #[cfg(not(unix))]
     {
-        // PERF(port): was stack-fallback alloc
         let input_utf8 = input.to_utf8();
         let input_slice = input_utf8.slice();
         let mut output = bun_paths::w_path_buffer_pool::get();
@@ -1380,7 +1361,6 @@ pub(super) extern "C" fn BakeProdResolve(
     a_str: BunString,
     specifier_str: BunString,
 ) -> BunString {
-    // PERF(port): was stack-fallback alloc (2x PathBuffer)
     let specifier = specifier_str.to_utf8();
 
     if let Some(alias) = bun_resolve_builtins::Alias::get(
@@ -1406,8 +1386,7 @@ pub(super) extern "C" fn BakeProdResolve(
         debug_assert!(strings::has_prefix(referrer.slice(), b"bake:"));
     }
 
-    // `bun.Dirname.dirname(u8, ...) orelse ...` — std.fs.path.dirname semantics
-    // (returns None for the root / no-parent).
+    // dirname semantics: returns None for the root / no-parent.
     let after_scheme = &referrer.slice()[5..];
     let dir = bun_paths::Dirname::dirname(after_scheme).unwrap_or(after_scheme);
 
@@ -1448,11 +1427,8 @@ impl framework_router::InsertionHandler for EntryPointMap {
         _rel_path: &[u8],
         _fail: framework_router::TinyLog,
     ) -> Result<(), bun_alloc::AllocError> {
-        // Zig: `InsertionContext.wrap` compiles this slot to
-        // `@panic("TODO: onRouterSyntaxError for " ++ @typeName(T))` when the
-        // wrapped type lacks the decl (FrameworkRouter.zig:966). EntryPointMap
-        // does not define it, so a malformed route pattern during a production
-        // build must crash loudly rather than be swallowed.
+        // EntryPointMap does not handle this, so a malformed route pattern
+        // during a production build must crash loudly rather than be swallowed.
         bun_core::todo_panic!("onRouterSyntaxError for EntryPointMap")
     }
 
@@ -1485,8 +1461,7 @@ impl framework_router::InsertionHandler for EntryPointMap {
 /// Data used on each rendering thread. Contains all information in the bundle needed to render.
 /// This is referred to as `pt` in variable/field naming, and Bake::ProductionPerThread in C++
 ///
-/// PORT NOTE: Zig held borrowed slices into `buildWithVm` locals; the Rust port
-/// owns the backing storage so the value can outlive `build_with_vm` in the
+/// Owns the backing storage so the value can outlive `build_with_vm` in the
 /// caller's frame without dangling references.
 pub struct PerThread {
     // Shared Data (owned)
@@ -1500,7 +1475,7 @@ pub struct PerThread {
     pub source_maps: StringArrayHashMap<OutputFileIndex>,
 
     // Thread-local
-    // PORT NOTE: Zig's `vm: *jsc.VirtualMachine`. Stored as `BackRef` (the VM
+    // Note: stored as `BackRef` (the VM
     // is process-lifetime and outlives every `PerThread`); `load_module`
     // re-derives a mutable VM via the per-thread singleton, so no write
     // provenance is needed here.
@@ -1508,16 +1483,14 @@ pub struct PerThread {
     /// Indexed by entry point index (OpaqueFileId)
     pub loaded_files: AutoBitSet,
     /// JSArray of JSString, indexed by entry point index (OpaqueFileId)
-    // Zig protects/unprotects this manually; PORTING.md mandates Strong for
-    // JSValue struct fields. `None` mirrors the pre-init `.null` state;
-    // `PerThread::init` fills it. Strong's Drop releases the GC root.
+    // Strong is required for JSValue struct fields. `None` is the pre-init
+    // state; `PerThread::init` fills it. Strong's Drop releases the GC root.
     pub all_server_files: Option<bun_jsc::Strong>,
     /// `attach()` was called and Drop should detach. The placeholder created in
     /// `build_command` before `init` must not call into C++ on drop.
     attached: bool,
 }
 
-// TODO(port): move to bake_sys
 // C++ treats `PerThread` as an opaque pointer (Bake::ProductionPerThread*); the Rust
 // layout is irrelevant across the FFI boundary, so silence the improper_ctypes lint.
 // C++ stores `pt` opaquely on the global (never dereferenced C++-side; null
@@ -1664,7 +1637,6 @@ impl Drop for PerThread {
 /// Given a key, returns the source code to load.
 #[unsafe(no_mangle)]
 pub(super) extern "C" fn BakeProdLoad(pt: *mut PerThread, key: BunString) -> BunString {
-    // PERF(port): was stack-fallback alloc
     // SAFETY: `pt` is the non-null pointer previously attached via
     // BakeGlobalObject__attachPerThreadData; C++ only calls this while attached.
     let pt = unsafe { &*pt };
@@ -1683,7 +1655,6 @@ pub(super) extern "C" fn BakeProdLoad(pt: *mut PerThread, key: BunString) -> Bun
 
 #[unsafe(no_mangle)]
 pub(super) extern "C" fn BakeProdSourceMap(pt: *mut PerThread, key: BunString) -> BunString {
-    // PERF(port): was stack-fallback alloc
     // SAFETY: `pt` is the non-null pointer previously attached via
     // BakeGlobalObject__attachPerThreadData; C++ only calls this while attached.
     let pt = unsafe { &*pt };
@@ -1725,5 +1696,3 @@ impl TypeAndFlags {
 }
 
 // `fn @"export"()` force-reference block dropped — Rust links what's `pub`.
-
-// ported from: src/bake/production.zig
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 498f754c05b..accab9fb352 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -1,12 +1,9 @@
-//! Port of `src/runtime/cli/Arguments.zig`.
-//!
 //! `parse()` runs `clap::parse()` against the per-tag table, handles
 //! `--help`/`-v`/`--revision`, and populates the full `api::TransformOptions`
 //! / `Context` from every recognised flag. All param tables — leaf and
 //! concatenated — are const `&'static [ParamType]` via the
 //! `bun_clap::parse_param!` proc-macro (compile-time spec parsing) plus a
-//! const-fn slice concat (`bun_clap::concat_params!`), matching Zig's comptime
-//! `clap.parseParam(...) ++ ...`.
+//! const-fn slice concat (`bun_clap::concat_params!`).
 
 use bun_options_types::LoaderExt as _;
 
@@ -48,11 +45,8 @@ pub(crate) fn loader_resolver(input: &[u8]) -> Result<api::Loader, bun_core::Err
 /// Resolve `filename` against `cwd`, open it, read its full contents, close it,
 /// and return the buffer.
 ///
-/// PORT NOTE: the Zig original (`std.fs.path.resolve` + `std.posix.toPosixPath`
-/// + `bun.openFileZ` + `readToEndAlloc`) is itself non-idiomatic for the Bun
-/// codebase. Reimplemented on top of `bun_paths::resolve_path` +
-/// `bun_sys::File::read_from`, which is the cross-platform path the rest of the
-/// runtime uses.
+/// Built on `bun_paths::resolve_path` + `bun_sys::File::read_from`, which is
+/// the cross-platform path the rest of the runtime uses.
 pub fn read_file(cwd: &[u8], filename: &[u8]) -> Result<Vec<u8>, bun_core::Error> {
     let mut buf = PathBuffer::uninit();
     let outpath = resolve_path::join_abs_string_buf::<platform::Auto>(cwd, &mut *buf, &[filename]);
@@ -81,8 +75,7 @@ pub(crate) fn resolve_jsx_runtime(s: &[u8]) -> Result<api::JsxRuntime, bun_core:
 pub(crate) type ParamType = clap::Param<clap::Help>;
 
 // ─── param tables ────────────────────────────────────────────────────────────
-// Zig built these at comptime via `clap.parseParam("...") catch unreachable`
-// concatenated with `++`. `bun_clap::parse_param!` expands to a const
+// `bun_clap::parse_param!` expands to a const
 // `Param<Help>` literal, and `concat_params!` is a const-fn slice concat, so
 // every table — leaf and combined — lands in rodata with zero runtime init.
 //
@@ -90,7 +83,6 @@ pub(crate) type ParamType = clap::Param<clap::Help>;
 // both `concat_params!` and `comptime_table!`. The single rodata copy of each
 // is the `static __CONV` / `static __TABLE` inside `comptime_table!` below.
 
-// Zig: `if (Environment.show_crash_trace) debug_params else [_]ParamType{}`.
 // `SHOW_CRASH_TRACE` is a `const bool`, so the dead branch is eliminated.
 macro_rules! maybe_debug_params {
     () => {
@@ -102,10 +94,8 @@ macro_rules! maybe_debug_params {
     };
 }
 
-// PORT NOTE: `builtin.have_error_return_tracing` is a Zig-only concept. Rust
-// has no error-return tracing, but `bun_crash_handler::VERBOSE_ERROR_TRACE`
-// still gates extra crash diagnostics. Expose the flag in crash-trace builds
-// (debug/test/asan), which is the closest analogue.
+// `bun_crash_handler::VERBOSE_ERROR_TRACE` gates extra crash diagnostics.
+// Expose the flag in crash-trace builds (debug/test/asan).
 const VERBOSE_ERROR_TRACE_PARAMS: &[ParamType] = &[parse_param!(
     "--verbose-error-trace             Dump error return traces"
 )];
@@ -374,7 +364,6 @@ pub(crate) const RUN_PARAMS: &[ParamType] = concat_params!(
     BASE_PARAMS_
 );
 
-// Zig: `if (FeatureFlags.bake_debugging_features) [_]ParamType{...} else [_]ParamType{}`.
 const BAKE_DEBUG_PARAMS: &[ParamType] = &[
     parse_param!(
         "--debug-dump-server-files        When --app is set, dump all server files to disk even when building statically"
@@ -620,13 +609,11 @@ pub(crate) const TEST_PARAMS: &[ParamType] = concat_params!(
     BASE_PARAMS_
 );
 
-/// Fallback table for `Command::tag_params` (Zig: `base_params_ ++
-/// runtime_params_ ++ transpiler_params_`).
+/// Fallback table for `Command::tag_params`.
 pub(crate) const BASE_RUNTIME_TRANSPILER_PARAMS: &[ParamType] =
     concat_params!(BASE_PARAMS_, RUNTIME_PARAMS_, TRANSPILER_PARAMS_);
 
 // ─── pre-converted tables (rodata) ───────────────────────────────────────────
-// Zig built these at comptime as part of the `ComptimeClap(Id, params)` type.
 // `comptime_table!` converts `*_PARAMS` → `[Param<usize>; N]` + category counts
 // + short-index entirely at const-eval, so `parse_with_table` does zero runtime
 // conversion / allocation / sorting / locking. perf: `ConvertedTable::build` +
@@ -712,13 +699,9 @@ pub use bun_bunfig::arguments::{load_config, load_config_path, load_config_with_
 
 /// Parse `argv` into `api::TransformOptions` for the given subcommand.
 ///
-/// PORT NOTE: `comptime cmd: Command.Tag` demoted to runtime arg (no
-/// `ConstParamTy` on `Tag`). The Zig original monomorphised over `cmd` so each
-/// subcommand got a dedicated param-table reference and dead-code-eliminated the
-/// other arms; here `command::tag_params(cmd)` does the runtime lookup, and the
-/// per-`cmd` blocks below are guarded by `if matches!(cmd, …)` instead of
-/// `if comptime cmd == …`.
-// PERF(port): was comptime monomorphization.
+/// `command::tag_params(cmd)` does a runtime lookup of the per-subcommand
+/// param table, and the per-`cmd` blocks below are guarded by
+/// `if matches!(cmd, …)`.
 pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> Result<api::TransformOptions, bun_core::Error> {
     let mut diag = clap::Diagnostic::default();
     let table = tag_table(cmd);
@@ -758,16 +741,14 @@ pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> Result<api::TransformOptions,
         }
     }
 
-    // PORT NOTE: Zig gated on `builtin.have_error_return_tracing`; see
-    // `maybe_verbose_error_trace!` above for the Rust mapping.
+    // See `maybe_verbose_error_trace!` above.
     if bun_core::env::SHOW_CRASH_TRACE && args.flag(b"--verbose-error-trace") {
         bun_crash_handler::VERBOSE_ERROR_TRACE.store(true, core::sync::atomic::Ordering::Relaxed);
     }
 
     // ── --cwd ────────────────────────────────────────────────────────────────
-    // PORT NOTE: Zig stored a `[:0]u8` (NUL-terminated, owned). The Rust
-    // `api::TransformOptions.absolute_working_dir` is `Option<Box<[u8]>>`
-    // (sentinel dropped per schema.rs), so we dupe into a plain `Box<[u8]>`.
+    // `api::TransformOptions.absolute_working_dir` is `Option<Box<[u8]>>`,
+    // so we dupe into a plain `Box<[u8]>`.
     let cwd: Box<[u8]> = if let Some(cwd_arg) = args.option(b"--cwd") {
         let mut outbuf = PathBuffer::uninit();
         let cwd_len = bun_sys::getcwd(&mut *outbuf)?;
@@ -950,7 +931,6 @@ pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> Result<api::TransformOptions,
                 if !ctx.preloads.is_empty() {
                     all.append(&mut ctx.preloads);
                 }
-                // PERF(port): was appendSliceAssumeCapacity
                 for p in preloads {
                     all.push(Box::<[u8]>::from(*p));
                 }
@@ -1276,7 +1256,7 @@ pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> Result<api::TransformOptions,
         if let Some(title) = args.option(b"--title") {
             // Static is `Mutex<Option<Box<[u8]>>>` so `process.title = "..."`
             // can drop the previous value; box the argv-borrowed slice up
-            // front (Zig: `CLI.Bun__Node__ProcessTitle = title;`).
+            // front.
             *cli::Bun__Node__ProcessTitle.lock() = Some(title.into());
         }
         if args.flag(b"--zero-fill-buffers") {
@@ -1315,9 +1295,8 @@ pub fn parse(cmd: CommandTag, ctx: Context<'_>) -> Result<api::TransformOptions,
                 core::sync::atomic::Ordering::Relaxed,
             );
         } else {
-            // Spec Arguments.zig: `Bun__Node__UseSystemCA = (Bun__Node__CAStore == .system)`
-            // is written unconditionally; preserve that always-write semantics
-            // even when no CA flag/env was supplied (default `.bundled` ⇒ false).
+            // `Bun__Node__UseSystemCA` is written unconditionally,
+            // even when no CA flag/env was supplied (default bundled ⇒ false).
             Bun__Node__UseSystemCA.store(false, core::sync::atomic::Ordering::Relaxed);
         }
     }
diff --git a/src/runtime/cli/add_command.rs b/src/runtime/cli/add_command.rs
index a29063240e0..32d516cefb4 100644
--- a/src/runtime/cli/add_command.rs
+++ b/src/runtime/cli/add_command.rs
@@ -6,10 +6,7 @@ pub(crate) struct AddCommand;
 
 impl AddCommand {
     pub(crate) fn exec(ctx: command::Context) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         update_package_json_and_install_catch_error(ctx, Subcommand::Add)?;
         Ok(())
     }
 }
-
-// ported from: src/cli/add_command.zig
diff --git a/src/runtime/cli/add_completions.rs b/src/runtime/cli/add_completions.rs
index b3787d8d34a..7c373bcf0a4 100644
--- a/src/runtime/cli/add_completions.rs
+++ b/src/runtime/cli/add_completions.rs
@@ -1,6 +1,6 @@
 // GENERATED: re-run `bun misctools/generate-add-completions.ts` with .rs output
-// (source src/cli/add_completions.zig is auto-generated; do not hand-port the
-// compressed_data blob, FirstLetter/Index tables, or init/getPackages — update the generator.)
+// (do not hand-edit the compressed_data blob, FirstLetter/Index tables, or
+// init/getPackages — update the generator.)
 
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -33,7 +33,7 @@ pub(crate) enum FirstLetter {
     Z = b'z',
 }
 
-/// Largest per-letter package list length (Zig: `pub const biggest_list`).
+/// Largest per-letter package list length.
 pub(crate) const BIGGEST_LIST: usize = 1034;
 
 /// Decompress the package-name table. The compressed blob and Index table are
diff --git a/src/runtime/cli/audit_command.rs b/src/runtime/cli/audit_command.rs
index 233f626c732..6a2c6be484c 100644
--- a/src/runtime/cli/audit_command.rs
+++ b/src/runtime/cli/audit_command.rs
@@ -18,9 +18,8 @@ use bun_url::URL;
 use crate::cli::Command;
 use crate::cli::package_manager_command::PackageManagerCommand;
 
-// TODO(port): in Zig these `[]const u8` fields borrow from the JSON parse arena (and a few are
-// `allocator.dupe`d). Boxed here to avoid a struct lifetime param; revisit if
-// the extra clones show up in profiling.
+// Boxed to avoid a struct lifetime param; the
+// clones are per-vulnerability, terminal-UI-bound, and not perf-relevant.
 struct VulnerabilityInfo {
     severity: Box<[u8]>,
     title: Box<[u8]>,
@@ -36,7 +35,6 @@ struct PackageInfo {
     dependents: Vec<DependencyPath>,
 }
 
-// In Zig this is `PackageInfo.DependencyPath`; hoisted because Rust has no nested struct types.
 struct DependencyPath {
     path: Vec<Box<[u8]>>,
 }
@@ -67,7 +65,7 @@ impl AuditCommand {
         ctx: Command::Context,
     ) -> Result<core::convert::Infallible, bun_core::Error> {
         let cli = CommandLineArguments::parse(Subcommand::Audit)?;
-        // PORT NOTE: `init` consumes `cli`; capture the fields read after it.
+        // Note: `init` consumes `cli`; capture the fields read after it.
         let audit_level = cli.audit_level;
         let production = cli.production;
         let audit_ignore_list = cli.audit_ignore_list;
@@ -123,8 +121,7 @@ impl AuditCommand {
         );
         Output::flush();
 
-        // PORT NOTE: Zig `pm.lockfile.loadFromCwd(pm, ctx.allocator, ctx.log, true)`
-        // is a self-referential split borrow; encapsulated upstream as
+        // Note: a self-referential split borrow; encapsulated upstream as
         // `PackageManager::load_lockfile_from_cwd`.
         {
             let log_level = pm.options.log_level;
@@ -243,9 +240,7 @@ fn build_dependency_tree(
 
             let resolved_name = pkg_names[resolved_pkg_id as usize].slice(buf);
 
-            // PORT NOTE: Zig `getOrPut` then `dupe` key only when not found.
-            // `StringHashMap::get_or_put` always boxes the key on miss, so the
-            // separate `allocator.dupe` is folded in.
+            // `StringHashMap::get_or_put` always boxes the key on miss.
             let result = dependency_tree.get_or_put(resolved_name)?;
             result.value_ptr.push(Box::<[u8]>::from(package_name));
         }
@@ -331,10 +326,10 @@ fn collect_packages_for_audit(
         prod_packages = Some(set);
     }
 
-    // PORT NOTE: reshaped for borrowck — column slices borrow `pm.lockfile`
+    // Note: reshaped for borrowck — column slices borrow `pm.lockfile`
     // immutably for the loop, so resolve `root_id` / `prod_packages` (which
     // need `&mut pm`) above, and split-borrow `pm.options` for the scope lookup
-    // (disjoint from `pm.lockfile`; Zig had no aliasing model).
+    // (disjoint from `pm.lockfile`).
     let options = &pm.options;
     let default_url_hash = options.scope.url_hash;
     let packages = pm.lockfile.packages.slice();
@@ -395,10 +390,8 @@ fn collect_packages_for_audit(
         if !version_exists {
             found_package.versions.push(ver_str);
         }
-        // else: ver_str dropped (Zig: allocator.free)
     }
 
-    // PERF(port): Zig used MutableString with initial capacity 1024.
     let mut body: Vec<u8> = Vec::with_capacity(1024);
     body.push(b'{');
 
@@ -439,14 +432,14 @@ fn send_audit_request(
         return Err(bun_alloc::AllocError);
     }
     // SAFETY: non-null checked above; libdeflate hands back a heap-allocated
-    // compressor that lives until `destroy` (Zig: `*Compressor`).
+    // compressor that lives until `destroy`.
     let compressor = unsafe { &mut *compressor_ptr };
 
     let max_compressed_size = compressor.max_bytes_needed(body, libdeflate::Encoding::Gzip);
     let mut compressed_body = Vec::with_capacity(max_compressed_size);
     let _ = compressor.compress_to_vec(body, &mut compressed_body, libdeflate::Encoding::Gzip);
     // SAFETY: `compressor_ptr` was returned by `Compressor::alloc` and is not
-    // used after this point (Zig: `defer compressor.deinit()`).
+    // used after this point.
     unsafe { libdeflate::Compressor::destroy(compressor_ptr) };
     let final_compressed_body = compressed_body;
 
@@ -488,10 +481,8 @@ fn send_audit_request(
 
     let http_proxy = pm.http_proxy(&url);
 
-    // PORT NOTE: Zig passed `headers.content.ptr.?[0..headers.content.len]`.
     let headers_buf: &[u8] = headers.content.written_slice();
 
-    // PERF(port): Zig used MutableString with initial capacity 1024.
     let mut response_buf = MutableString::init(1024)?;
     // `init_sync` erases lifetimes internally (port-erased raw pointers); all
     // borrowed inputs live on this stack frame past `send_sync()`.
@@ -1013,5 +1004,3 @@ fn print_enhanced_audit_report(
 
     Ok(0)
 }
-
-// ported from: src/cli/audit_command.zig
diff --git a/src/runtime/cli/build_command.rs b/src/runtime/cli/build_command.rs
index fb60095c160..39320a44012 100644
--- a/src/runtime/cli/build_command.rs
+++ b/src/runtime/cli/build_command.rs
@@ -12,12 +12,12 @@ use bun_js_parser::parser::Runtime;
 use bun_options_types::context::MacroOptions;
 use bun_options_types::schema::api;
 use bun_paths::{PathBuffer, resolve_path};
-use bun_sys::{self, Fd, FdExt as _};
+use bun_sys::{self, Fd};
 
 extern crate bun_standalone_graph as bun_standalone_module_graph;
 
-/// `bun.cli.start_time` accessor — Zig had a mutable global; Rust keeps the
-/// single backing `OnceLock` in `bun_core` (written once in `Cli::start`).
+/// `start_time` accessor — the
+/// single backing `OnceLock` lives in `bun_core` (written once in `Cli::start`).
 #[inline]
 fn cli_start_time() -> i128 {
     crate::cli::start_time()
@@ -62,7 +62,6 @@ impl BuildCommand {
             long_running: true,
             ..Default::default()
         });
-        // PERF(port): allocator param dropped — global mimalloc
         let log = ctx.log;
         // SAFETY: `ctx.log` is a long-lived `*mut Log` set up during CLI init
         // and never freed for the duration of the command body.
@@ -94,7 +93,6 @@ impl BuildCommand {
                     Vec::with_capacity(compile_define_keys.len() + define.keys.len());
                 keys.extend(compile_define_keys.iter().map(|s| Box::<[u8]>::from(*s)));
                 keys.append(&mut define.keys);
-                // PERF(port): was appendSliceAssumeCapacity — profile if it shows up on a hot path.
                 let mut values: Vec<Box<[u8]>> =
                     Vec::with_capacity(compile_define_values.len() + define.values.len());
                 values.extend(compile_define_values.iter().map(|s| Box::<[u8]>::from(*s)));
@@ -116,11 +114,11 @@ impl BuildCommand {
             }
         }
 
-        // PORT NOTE: `Transpiler::init` now takes an arena. Process-lifetime —
+        // Note: `Transpiler::init` now takes an arena. Process-lifetime —
         // `exec` never returns until process exit (`exit_or_watch` diverges),
         // so use the shared CLI arena instead of allocating a fresh one.
         let arena: &'static bun_alloc::Arena = crate::cli::cli_arena();
-        // PORT NOTE: `generate_from_cli` takes `&'a mut Transpiler<'a>`, which
+        // Note: `generate_from_cli` takes `&'a mut Transpiler<'a>`, which
         // borrows the transpiler for its full lifetime — dropck then rejects a
         // stack local because the borrow would still be live in its destructor.
         // Allocate in the process-lifetime arena (same rationale as `arena`;
@@ -142,7 +140,7 @@ impl BuildCommand {
             this_transpiler.options.ignore_module_resolution_errors = true;
         }
 
-        // PORT NOTE: clone the first entry point so `outfile` can borrow owned
+        // Note: clone the first entry point so `outfile` can borrow owned
         // storage instead of `this_transpiler.options.entry_points[0]`, which
         // would otherwise hold an immutable borrow of `this_transpiler` across
         // later `&mut self` calls (`configure_defines`, `generate_from_cli`).
@@ -381,8 +379,10 @@ impl BuildCommand {
                 resolve_path::get_if_exists_longest_common_path(&entries).unwrap_or(b".")
             };
 
+            // `bun_sys::Dir` is the owning RAII
+            // handle; its Drop closes the fd when this block ends.
             let dir = match bun_sys::open_dir_at(Fd::cwd(), path) {
-                Ok(d) => d,
+                Ok(d) => bun_sys::Dir { fd: d },
                 Err(err) => {
                     bun_core::pretty_errorln!(
                         "<r><red>{}<r> opening root directory {}",
@@ -392,9 +392,8 @@ impl BuildCommand {
                     Global::exit(1);
                 }
             };
-            // TODO(port): defer dir.close() — using explicit close after use; consider an RAII guard.
 
-            let result = match bun_sys::get_fd_path(dir, &mut src_root_dir_buf) {
+            let result = match bun_sys::get_fd_path(dir.fd, &mut src_root_dir_buf) {
                 Ok(p) => p,
                 Err(err) => {
                     bun_core::pretty_errorln!(
@@ -405,7 +404,6 @@ impl BuildCommand {
                     Global::exit(1);
                 }
             };
-            dir.close();
             break 'brk1 &*result;
         };
 
@@ -435,7 +433,7 @@ impl BuildCommand {
                 .append_slice(&[b"development" as &[u8]])?;
         }
 
-        // PORT NOTE: `resolver.opts` is the canonical
+        // Note: `resolver.opts` is the canonical
         // `bun_resolver::options::BundleOptions` subset, distinct from the
         // bundler-side `BundleOptions<'a>`; re-project the mutated options.
         this_transpiler.sync_resolver_opts();
@@ -452,7 +450,7 @@ impl BuildCommand {
                 this_transpiler.options.no_macros = true;
             }
             MacroOptions::Map(macros) => {
-                // PORT NOTE: `MacroOptions::Map` carries the
+                // Note: `MacroOptions::Map` carries the
                 // `bun_options_types::context::MacroMap` redeclaration; the
                 // bundler-side `options.macro_remap` is the resolver crate's
                 // `StringArrayHashMap` shape. Re-key into that shape here.
@@ -475,16 +473,14 @@ impl BuildCommand {
         let mut client_transpiler: Option<transpiler::Transpiler> = None;
         if this_transpiler.options.server_components {
             let mut ct = transpiler::Transpiler::init(arena, log, ctx.args.clone(), None)?;
-            // PORT NOTE: Zig assigned `client_transpiler.options = this_transpiler.options`
-            // (struct copy). `BundleOptions<'a>` is non-`Clone` in Rust; instead
+            // Note: `BundleOptions<'a>` is non-`Clone`;
             // `Transpiler::init` above rebuilds options from the same `ctx.args`,
             // and the divergent fields are set explicitly below. `client_transpiler`
-            // is currently unused after this block (matching the Zig), so a
+            // is currently unused after this block, so a
             // perfect field-wise copy is not load-bearing.
             ct.options.target = bun_ast::Target::Browser;
             ct.options.server_components = true;
             ct.options.conditions = this_transpiler.options.conditions.clone()?;
-            // TODO(port): narrow error set
             this_transpiler
                 .options
                 .conditions
@@ -493,9 +489,26 @@ impl BuildCommand {
             this_transpiler.options.minify_syntax = true;
             ct.options.minify_syntax = true;
             {
+                use bun_bundler::DefineDataExt as _;
                 use bun_bundler::DefineExt as _;
+                // Feed `--define` entries into
+                // the client transpiler's Define table.
+                let user_defines = match &ctx.args.define {
+                    Some(input) => {
+                        let mut raw = bun_bundler::defines::RawDefines::default();
+                        raw.reserve(input.keys.len() + 4);
+                        for (key, value) in input.keys.iter().zip(input.values.iter()) {
+                            raw.insert(key.as_ref(), value.clone());
+                        }
+                        let drop: Vec<&[u8]> = ctx.args.drop.iter().map(|d| d.as_ref()).collect();
+                        Some(bun_bundler::defines::DefineData::from_input(
+                            &raw, &drop, log_ref, arena,
+                        )?)
+                    }
+                    None => None,
+                };
                 ct.options.define = options::Define::init(
-                    None, // TODO(port): user_defines from ctx.args.define — RawDefines builder pending
+                    user_defines,
                     None,
                     this_transpiler.options.define.drop_debugger,
                     this_transpiler.options.dead_code_elimination
@@ -533,7 +546,7 @@ impl BuildCommand {
         let mut minify_duration: u64 = 0;
         let mut input_code_length: u64 = 0;
 
-        // PORT NOTE: `BundleV2::generate_from_cli` takes `&'a mut Transpiler<'a>`,
+        // Note: `BundleV2::generate_from_cli` takes `&'a mut Transpiler<'a>`,
         // which (with `'a = 'static` from the leaked arena) borrows
         // `this_transpiler` for the rest of its life. Snapshot every options
         // field read after that point so the borrow checker is satisfied.
@@ -703,7 +716,7 @@ impl BuildCommand {
 
         let mut had_err = false;
         'dump: {
-            // Output::flush() runs at end of this block (defer in Zig); see explicit calls below
+            // Output::flush() runs at end of this block; see explicit calls below
             let writer = Output::writer_buffered();
             let mut output_dir: &[u8] = &opt_output_dir;
 
@@ -1110,8 +1123,10 @@ impl BuildCommand {
 
 fn exit_or_watch(code: u8, watch: bool) -> ! {
     if watch {
-        // the watcher thread will exit the process
-        // TODO(port): std.Thread.sleep(maxInt(u64)-1) — verify cross-platform sleep-forever
+        // the watcher thread will exit the process. `std::thread::sleep`
+        // accepts arbitrarily large Durations on every supported platform
+        // (the stdlib loops internally where the OS primitive is narrower),
+        // so this parks the thread for ~584 years — effectively forever.
         std::thread::sleep(std::time::Duration::from_secs(u64::MAX / 1_000_000_000));
     }
     Global::exit(u32::from(code));
@@ -1183,5 +1198,3 @@ fn print_summary(
     Output::print_elapsed_stdout_trim(bundle_elapsed as f64);
     bun_core::prettyln!("  <green>bundle<r>  {} modules", reachable_file_count);
 }
-
-// ported from: src/cli/build_command.zig
diff --git a/src/runtime/cli/bunx_command.rs b/src/runtime/cli/bunx_command.rs
index 41aeb5854d1..92c834d0ec8 100644
--- a/src/runtime/cli/bunx_command.rs
+++ b/src/runtime/cli/bunx_command.rs
@@ -1,4 +1,5 @@
-//! Port of `src/cli/bunx_command.zig`.
+//! `bun x` / `bunx`: resolves a package's executable — installing it into a
+//! shared cache when not already present — and execs it with the given args.
 
 use bun_collections::VecExt;
 use std::io::Write as _;
@@ -35,13 +36,12 @@ pub(crate) struct BunxCommand;
 
 /// bunx-specific options parsed from argv.
 //
-// PORT NOTE: string fields borrow from `argv` (process-lifetime). The porting
-// convention forbids struct lifetime params, so they are typed `&'static [u8]`.
-// TODO(port): lifetime — these borrow argv, not true 'static.
+// Invariant: string fields borrow from `argv`, which is process-lifetime —
+// that is what makes the `&'static [u8]` typing sound here.
 pub struct Options {
     /// CLI arguments to pass to the command being run.
-    // PORT NOTE: `Box<[u8]>` to match `ContextData::passthrough` /
-    // `Run::run_binary`'s `&[Box<[u8]>]` param. Zig was `[]const string`.
+    // `Box<[u8]>` to match `ContextData::passthrough` /
+    // `Run::run_binary`'s `&[Box<[u8]>]` param.
     pub passthrough_list: Vec<Box<[u8]>>,
     /// `bunx <package_name>`
     pub package_name: &'static [u8],
@@ -57,7 +57,6 @@ pub struct Options {
     /// Skip installing the package, only running the target command if its
     /// already downloaded. If its not, `bunx` exits with an error.
     pub no_install: bool,
-    // PORT NOTE: `std.mem.Allocator` param field dropped — global mimalloc.
 }
 
 impl Default for Options {
@@ -100,7 +99,6 @@ impl Options {
 
             if maybe_package_name.is_some() {
                 opts.passthrough_list.push(Box::<[u8]>::from(positional));
-                // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path.
                 i += 1;
                 continue;
             }
@@ -208,9 +206,6 @@ impl Options {
     }
 }
 
-// PORT NOTE: `fn deinit` only freed `passthrough_list`; `Vec` drops automatically,
-// so no explicit `Drop` impl is needed.
-
 #[derive(thiserror::Error, strum::IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum GetBinNameError {
     #[error("NoBinFound")]
@@ -225,16 +220,12 @@ impl BunxCommand {
     /// Adds `create-` to the string, but also handles scoped packages correctly.
     /// Always clones the string in the process.
     ///
-    /// Returned `Vec<u8>` is NUL-terminated: `v[v.len()-1] == 0` and the content
-    /// occupies `v[..v.len()-1]` (matches Zig `[:0]const u8` from `allocSentinel`).
-    // TODO(port): return owned `bun_core::ZString` / `Box<ZStr>` once that type exists,
-    // instead of a Vec<u8> with a trailing-NUL convention.
-    pub(crate) fn add_create_prefix(input: &[u8]) -> Result<Vec<u8>, AllocError> {
+    /// Returns an owned NUL-terminated string.
+    pub(crate) fn add_create_prefix(input: &[u8]) -> Result<bun_core::ZBox, AllocError> {
         const PREFIX_LENGTH: usize = b"create-".len();
 
         if input.is_empty() {
-            // Zig's `dupeZ(u8, "")` yields a 1-byte allocation containing only NUL.
-            return Ok(vec![0u8]);
+            return Ok(bun_core::ZBox::default());
         }
 
         // +1 for the trailing NUL sentinel; vec! zero-initializes so the last byte stays 0.
@@ -248,7 +239,7 @@ impl BunxCommand {
                 new_str[index..index + PREFIX_LENGTH].copy_from_slice(b"create-");
                 new_str[index + PREFIX_LENGTH..input.len() + PREFIX_LENGTH]
                     .copy_from_slice(&input[index..]);
-                return Ok(new_str);
+                return Ok(bun_core::ZBox::from_vec_with_nul(new_str));
             }
             // @org@v -> @org/create@v
             else if let Some(at_i) = strings::index_of_char(&input[1..], b'@') {
@@ -257,20 +248,20 @@ impl BunxCommand {
                 new_str[index..index + PREFIX_LENGTH].copy_from_slice(b"/create");
                 new_str[index + PREFIX_LENGTH..input.len() + PREFIX_LENGTH]
                     .copy_from_slice(&input[index..]);
-                return Ok(new_str);
+                return Ok(bun_core::ZBox::from_vec_with_nul(new_str));
             }
             // @org -> @org/create
             else {
                 new_str[0..input.len()].copy_from_slice(input);
                 new_str[input.len()..input.len() + PREFIX_LENGTH].copy_from_slice(b"/create");
-                return Ok(new_str);
+                return Ok(bun_core::ZBox::from_vec_with_nul(new_str));
             }
         }
 
         new_str[0..PREFIX_LENGTH].copy_from_slice(b"create-");
         new_str[PREFIX_LENGTH..input.len() + PREFIX_LENGTH].copy_from_slice(input);
 
-        Ok(new_str)
+        Ok(bun_core::ZBox::from_vec_with_nul(new_str))
     }
 
     /// 1 day
@@ -310,8 +301,7 @@ impl BunxCommand {
         bun_ast::initialize_store();
 
         let log = transpiler.log_mut();
-        // PORT NOTE: Zig passed `transpiler.allocator` (global mimalloc). The
-        // Rust JSON parser takes a bump arena; everything we keep is cloned
+        // The JSON parser takes a bump arena; everything we keep is cloned
         // into `Box<[u8]>` before returning, so a local arena suffices.
         let bump = bun_alloc::Arena::new();
         let expr = json::parse_package_json_utf8(&source, log, &bump)?;
@@ -355,7 +345,7 @@ impl BunxCommand {
             if let Some(bin_prop) = dirs.expr.as_property(b"bin") {
                 if let Some(dir_name) = bin_prop.expr.as_string(&bump) {
                     let bin_dir = bun_sys::openat_a(dir_fd, dir_name, O::RDONLY | O::DIRECTORY, 0)?;
-                    // Zig: `defer bin_dir.close()` — Fd is non-owning Copy; guard it.
+                    // Fd is non-owning Copy; guard it.
                     let _close_bin_dir = bun_sys::CloseOnDrop::new(bin_dir);
                     let mut iterator = bun_sys::dir_iterator::iterate(bin_dir);
                     let mut entry = iterator.next();
@@ -391,7 +381,6 @@ impl BunxCommand {
         package_name: &[u8],
     ) -> Result<Box<[u8]>, bun_core::Error> {
         let mut subpath = PathBuffer::uninit();
-        // TODO(port): bun.pathLiteral() rewrites '/' to the platform separator at comptime.
         let len = {
             let total = subpath.len();
             let mut cursor: &mut [u8] = &mut subpath[..];
@@ -612,7 +601,6 @@ impl BunxCommand {
         ctx: &mut ContextData,
         argv: &[&'static ZStr],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Don't log stuff
         ctx.debug.silent = true;
 
@@ -686,7 +674,6 @@ impl BunxCommand {
 
         // fast path: they're actually using this interchangeably with `bun run`
         // so we use Bun.which to check
-        // PORT NOTE: out-param init — Zig `var this_transpiler: Transpiler = undefined;`.
         let mut this_transpiler_slot = ::core::mem::MaybeUninit::<Transpiler<'static>>::uninit();
         let mut original_path: Vec<u8> = Vec::new();
 
@@ -729,15 +716,13 @@ impl BunxCommand {
             .get(b"BUN_WHICH_IGNORE_CWD")
             .unwrap_or(b"")
             .to_vec();
-        // PORT NOTE: cloned to drop the borrow on `env_loader.map` before mutating it.
+        // Cloned to drop the borrow on `env_loader.map` before mutating it.
 
         if !ignore_cwd.is_empty() {
             env_loader.map.remove(b"BUN_WHICH_IGNORE_CWD");
         }
 
         let mut path: Vec<u8> = env_loader.get(b"PATH").unwrap().to_vec();
-        // PORT NOTE: reshaped for borrowck — Zig held a borrowed slice into env.map and
-        // later overwrote PATH with a new allocation; here we own PATH as a Vec<u8>.
 
         // `configurePathForRun` builds PATH by appending ORIGINAL_PATH to a set of
         // `*/node_modules/.bin` directories (plus the bun-node shim dir). Capture just
@@ -751,7 +736,7 @@ impl BunxCommand {
             } else {
                 path.clone()
             };
-        // PORT NOTE: cloned to avoid borrowck overlap when PATH is reassigned below.
+        // Cloned to avoid borrowck overlap when PATH is reassigned below.
 
         let display_version: &[u8] = if update_request.version.literal.is_empty() {
             b"latest"
@@ -870,7 +855,6 @@ impl BunxCommand {
 
             break 'brk new_path;
         };
-        // PORT NOTE: `defer ctx.allocator.free(PATH_FOR_BIN_DIRS)` — Vec drops automatically.
 
         // The bunx cache path is at the following location
         //
@@ -886,16 +870,13 @@ impl BunxCommand {
         //   - If you set permission to 777, you run into a potential attack vector
         //     where a user can replace the directory with malicious code.
         //
-        // If this format changes, please update cache clearing code in package_manager_command.zig
+        // If this format changes, please update cache clearing code in package_manager_command.rs
         #[cfg(unix)]
         // SAFETY: getuid() is always safe to call (no preconditions, never fails)
         let uid = unsafe { libc::getuid() };
         #[cfg(windows)]
         let uid = bun_sys::windows::user_unique_id();
 
-        // PORT NOTE: Zig used `switch (PATH.len > 0) { inline else => |path_is_nonzero| ... }`
-        // to monomorphize the format string. Collapsed to a runtime branch.
-        // PERF(port): was comptime bool dispatch — profile if it shows up on a hot path.
         path = {
             let mut v = Vec::new();
             let path_is_nonzero = !path.is_empty();
@@ -924,7 +905,7 @@ impl BunxCommand {
 
         bun_output::scoped_log!(bunx, "bunx_cache_dir: {}", BStr::new(bunx_cache_dir));
 
-        // PORT NOTE: Zig's module-level `var path_buf` is a stack local here so
+        // `path_buf` is a stack local so
         // `bun_which::which`'s returned slice can borrow it for the rest of exec().
         let mut path_buf = PathBuffer::uninit();
         let top_level_dir: &[u8] = fs.top_level_dir;
@@ -943,7 +924,7 @@ impl BunxCommand {
             )
             .map_err(|_| bun_core::err!("PathTooLong"))?;
             let written = buf_total - cursor.len();
-            // PORT NOTE: reshaped for borrowck — re-slice from buffer
+            // Re-slice from the buffer so the borrow on `cursor` ends here.
             // SAFETY: `written` bytes were just initialized above
             unsafe { core::slice::from_raw_parts(absolute_in_cache_dir_buf.as_ptr(), written) }
         };
@@ -977,10 +958,7 @@ impl BunxCommand {
                 //
                 //  1. Try the bin in the current node_modules and then we try the bin in the global cache
                 //
-                // PORT NOTE: Zig kept a single `?[:0]const u8 destination_` and
-                // `orelse`d the cache probe. NLL can't see that the buffer
-                // borrow is dead in the `None` arm, so we fold both probes into
-                // one labeled block instead.
+                // Both probes are folded into one labeled block.
                 let dest_or_cache: Option<&ZStr> = 'find: {
                     // Only use the system-installed version if there is no version specified
                     if update_request.version.literal.is_empty() {
@@ -1047,7 +1025,7 @@ impl BunxCommand {
                                         break 'is_stale false;
                                     }
                                 };
-                                // Zig: `defer fd.close()` — closed explicitly below before
+                                // The fd is closed explicitly below before
                                 // any `break 'is_stale` (no early-return between open & close).
 
                                 let mut io_status_block: win::IO_STATUS_BLOCK =
@@ -1323,10 +1301,9 @@ impl BunxCommand {
                 loop_: bun_jsc::EventLoopHandle::init_mini(
                     bun_event_loop::MiniEventLoop::init_global(
                         // `this_transpiler.env` is the process-lifetime loader
-                        // singleton populated during transpiler init
-                        // (Zig: `initGlobal(this_transpiler.env, null)`).
+                        // singleton populated during transpiler init.
                         //
-                        // PORT NOTE (aliasing): do NOT call `this_transpiler.env_mut()` here —
+                        // Aliasing: do NOT call `this_transpiler.env_mut()` here —
                         // `env_loader` (line 594) is still live and is used again below at the
                         // post-install `Run::run_binary` calls. A second `env_mut()` would
                         // `unsafe { &mut *self.env }` from the raw field, popping `env_loader`'s
@@ -1362,9 +1339,8 @@ impl BunxCommand {
 
         match &spawn_result.status {
             SpawnStatus::Exited(exited) => {
-                // Zig: `if (exit.signal.valid())` — non-exhaustive `enum(u8)`, any
-                // non-zero byte (incl. RT signals >31) is "valid". `signal_code()`
-                // would drop RT signals, so check the raw byte directly.
+                // Any non-zero byte (incl. RT signals >31) is a valid signal.
+                // `signal_code()` would drop RT signals, so check the raw byte directly.
                 if exited.signal != 0 {
                     if bun_core::env_var::feature_flag::BUN_INTERNAL_SUPPRESS_CRASH_IN_BUN_RUN
                         .get()
@@ -1388,9 +1364,7 @@ impl BunxCommand {
                     bun_crash_handler::suppress_reporting();
                 }
 
-                // Zig: `.signaled => |signal| Global.raiseIgnoringPanicHandler(signal)` —
-                // unconditionally noreturn. Zig's `SignalCode` is non-exhaustive
-                // `enum(u8)` so RT signals (>31) are valid payloads; forward the
+                // RT signals (>31) are valid payloads; forward the
                 // raw byte instead of lossy `signal_code()` so this arm always
                 // diverges with the *actual* signal.
                 Global::raise_ignoring_panic_handler_raw(core::ffi::c_int::from(*sig));
@@ -1543,5 +1517,3 @@ impl BunxCommand {
         Global::exit(1);
     }
 }
-
-// ported from: src/cli/bunx_command.zig
diff --git a/src/runtime/cli/ci_info.rs b/src/runtime/cli/ci_info.rs
index 0b62f95686b..49db88695b8 100644
--- a/src/runtime/cli/ci_info.rs
+++ b/src/runtime/cli/ci_info.rs
@@ -3,12 +3,10 @@
 // Main implementation is in src/codegen/ci_info.ts
 
 use bun_core::env_var;
-// PORT NOTE: `@import("ci_info")` was a build.zig-registered generated module (output of
-// src/codegen/ci_info.ts). The Rust build hand-ports the table as `cli::ci_info_generated`.
+// The CI table in `cli::ci_info_generated` mirrors the generated module
+// produced by src/codegen/ci_info.ts.
 use super::ci_info_generated as generated;
 
-// PORT NOTE: `bun.once(fn)` stores the fn at construction and `.call(.{})` invokes it once,
-// caching the result. Mapped here to `bun_core::Once<T>` with `.call(init_fn)` (≈ OnceLock).
 static DETECT_CI_ONCE: bun_core::Once<Option<&'static [u8]>> =
     <bun_core::Once<Option<&'static [u8]>>>::new();
 static IS_CI_ONCE: bun_core::Once<bool> = <bun_core::Once<bool>>::new();
@@ -36,5 +34,3 @@ fn detect_uncached() -> Option<&'static [u8]> {
     }
     generated::detect_uncached_generated()
 }
-
-// ported from: src/cli/ci_info.zig
diff --git a/src/runtime/cli/colon_list_type.rs b/src/runtime/cli/colon_list_type.rs
index c2725e78d12..cd52f300ed8 100644
--- a/src/runtime/cli/colon_list_type.rs
+++ b/src/runtime/cli/colon_list_type.rs
@@ -2,39 +2,31 @@ use bun_core::fmt as bun_fmt;
 use bun_core::strings;
 use bun_core::{Error, Global, err, pretty_errorln};
 
-// Zig: `pub fn ColonListType(comptime t: type, comptime value_resolver: anytype) type`
-//
-// The Zig type-generator takes (a) the value type and (b) a comptime resolver fn,
-// and also branches on `comptime t == bun.schema.api.Loader`. Rust cannot take a
-// fn value as a const generic, so both params collapse into one trait that the
+// The value type and its resolver fn collapse into one trait that the
 // value type implements. Each `T` declares its own resolver and whether it is the
 // schema Loader.
-// TODO(port): if a single `T` ever needs two distinct resolvers, split this back
-// into `<T, R: ValueResolver<T>>` with a PhantomData marker.
 pub(crate) trait ColonListValue: Sized {
-    /// Mirrors `comptime value_resolver(str)`.
+    /// Parses one value from its string form.
     fn resolve_value(input: &[u8]) -> Result<Self, Error>;
 
-    /// Mirrors `if (comptime t == bun.schema.api.Loader)`.
+    /// Whether `T` is the schema `Loader` type.
     const IS_LOADER: bool = false;
 }
 
 pub(crate) struct ColonListType<T: ColonListValue> {
-    // TODO(port): lifetime — keys borrow slices out of CLI argv (process-lifetime
-    // in practice). Uses &'static; may need to thread a `'a` if needed.
+    // Invariant: keys borrow slices out of CLI argv, which is process-lifetime
+    // in practice — that is what makes the `&'static` typing sound.
     pub keys: Vec<&'static [u8]>,
     pub values: Vec<T>,
 }
 
 impl<T: ColonListValue> ColonListType<T> {
-    pub(crate) fn init(count: usize) -> Result<Self, Error> {
-        // PORT NOTE: reshaped — Zig allocs two uninit slices of `count` and
-        // index-assigns in `load`; Rust uses `Vec::with_capacity` + `push`.
+    pub(crate) fn init(count: usize) -> Self {
+        // `Vec::with_capacity` + `push`, which is infallible here.
         let keys = Vec::with_capacity(count);
         let values = Vec::with_capacity(count);
 
-        // TODO(port): narrow error set
-        Ok(ColonListType { keys, values })
+        ColonListType { keys, values }
     }
 
     pub(crate) fn load(&mut self, input: &[&'static [u8]]) -> Result<(), Error> {
@@ -61,26 +53,25 @@ impl<T: ColonListValue> ColonListType<T> {
             }
 
             self.keys.push(&str[0..midpoint]);
-            self.values.push(match T::resolve_value(&str[midpoint + 1..str.len()]) {
-                Ok(v) => v,
-                Err(e) if e == err!("InvalidLoader") => {
-                    // TODO(blocked): bun_ast::Loader (strum::VariantNames derive)
-                    // — `bun_fmt::enum_tag_list::<Loader, false>()` requires the derive; print
-                    // a placeholder list until lower-tier crate adds it.
-                    pretty_errorln!(
-                        "<r><red>error<r><d>:<r> <b>invalid loader {}<r>, expected one of: jsx, js, ts, tsx, css, file, json, jsonc, toml, wasm, napi, base64, dataurl, text, bunsh, sqlite, html, yaml, json5, md",
-                        bun_fmt::quote(&str[midpoint + 1..str.len()]),
-                    );
-                    Global::exit(1);
-                }
-                Err(e) => return Err(e),
-            });
+            self.values
+                .push(match T::resolve_value(&str[midpoint + 1..str.len()]) {
+                    Ok(v) => v,
+                    Err(e) if e == err!("InvalidLoader") => {
+                        pretty_errorln!(
+                            "<r><red>error<r><d>:<r> <b>invalid loader {}<r>, expected one of:{}",
+                            bun_fmt::quote(&str[midpoint + 1..str.len()]),
+                            bun_fmt::enum_tag_list::<bun_ast::Loader, { bun_fmt::SEP_DASH }>(),
+                        );
+                        Global::exit(1);
+                    }
+                    Err(e) => return Err(e),
+                });
         }
         Ok(())
     }
 
     pub(crate) fn resolve(input: &[&'static [u8]]) -> Result<Self, Error> {
-        let mut list = Self::init(input.len())?;
+        let mut list = Self::init(input.len());
         match list.load(input) {
             Ok(()) => {}
             Err(e) if e == err!("InvalidSeparator") => {
@@ -92,5 +83,3 @@ impl<T: ColonListValue> ColonListType<T> {
         Ok(list)
     }
 }
-
-// ported from: src/cli/colon_list_type.zig
diff --git a/src/runtime/cli/create/SourceFileProjectGenerator.rs b/src/runtime/cli/create/SourceFileProjectGenerator.rs
index 223429010f2..f7fd18d618c 100644
--- a/src/runtime/cli/create/SourceFileProjectGenerator.rs
+++ b/src/runtime/cli/create/SourceFileProjectGenerator.rs
@@ -1,5 +1,3 @@
-//! Port of src/cli/create/SourceFileProjectGenerator.zig
-
 use crate::api::bun::process as bun_process;
 use crate::api::bun::process::SignalCodeExt as _;
 use crate::api::bun::process::sync as spawn_sync;
@@ -156,9 +154,6 @@ fn string_with_replacements(
     relative_name: &[u8],
     react_component_export: &[u8],
 ) -> Result<Vec<u8>, bun_alloc::AllocError> {
-    // PORT NOTE: Zig threaded an allocator and reassigned `input` to leaked
-    // intermediate slices. In Rust we own `Vec<u8>` and rebind it; intermediates
-    // are dropped automatically.
     let mut input: Vec<u8> = original_input.to_vec();
 
     if strings::contains(&input, b"REPLACE_ME_WITH_YOUR_REACT_COMPONENT_EXPORT") {
@@ -268,17 +263,12 @@ pub fn generate_files(
     }
 
     // Generate files based on template type
-    // PORT NOTE: Zig used `switch (tag) { inline else => |active| @field(Self, @tagName(active)) }`
-    // to comptime-dispatch to the per-template `files` const and stack-size the
-    // `filenames`/`created_files` arrays. Rust cannot reflect on decl names, so
-    // we route through `Tag::files()` and use heap Vecs sized at runtime.
-    // PERF(port): was comptime monomorphization + stack arrays.
+    // Route through `Tag::files()` and use heap Vecs sized at runtime.
     {
         let files: &'static [TemplateFile] = template.tag().files();
 
         let mut max_filename_len: usize = 0;
-        // PORT NOTE: reshaped for borrowck — Zig kept parallel `[N][]const u8 filenames`
-        // + `[N]bool created_files` arrays of arena-backed slices. Here a single
+        // A single
         // Vec<Option<Vec<u8>>> owns the names; Some(_) doubles as the created flag.
         let mut filenames: Vec<Option<Vec<u8>>> = vec![None; files.len()];
 
@@ -672,10 +662,8 @@ fn find_react_component_export<'r>(bundler: &'r BundleV2<'_>) -> Option<&'r [u8]
             }
 
             if filename[0] >= b'a' && filename[0] <= b'z' {
-                // PORT NOTE: Zig leaked `duped` on the success returns below
-                // (only freed on the fall-through). Route through the process-
-                // lifetime CLI arena to match the returned-slice lifetime; the
-                // fall-through `free` is a no-op (arena-backed).
+                // Route through the process-
+                // lifetime CLI arena to match the returned-slice lifetime.
                 let duped: &'static mut [u8] = crate::cli::cli_arena().alloc_slice_copy(filename);
                 duped[0] -= 32;
                 if js_lexer::is_identifier(duped) {
@@ -743,15 +731,13 @@ fn find_react_component_export<'r>(bundler: &'r BundleV2<'_>) -> Option<&'r [u8]
                         return Some(&duped[0..output_index]);
                     }
                 }
-
-                // Zig: default_allocator.free(duped) — intentionally leaked above; see PORT NOTE.
             }
 
             let Ok(name_to_try) = MutableString::ensure_valid_identifier(filename) else {
                 return None;
             };
             if exports.contains(&name_to_try) {
-                // Zig returns an allocator-owned slice; route through the
+                // Route through the
                 // process-lifetime CLI arena.
                 return Some(crate::cli::cli_dupe(&name_to_try));
             }
@@ -974,7 +960,6 @@ impl Tag {
         }
     }
 
-    /// Replaces Zig's `@field(SourceFileProjectGenerator, @tagName(active)).files`.
     pub fn files(self) -> &'static [TemplateFile] {
         match self {
             Tag::ReactTailwindSpa => react_tailwind_spa::FILES,
@@ -1034,5 +1019,3 @@ impl Logger {
         );
     }
 }
-
-// ported from: src/cli/create/SourceFileProjectGenerator.zig
diff --git a/src/runtime/cli/create_command.rs b/src/runtime/cli/create_command.rs
index 55b52956308..bedb5d1ded7 100644
--- a/src/runtime/cli/create_command.rs
+++ b/src/runtime/cli/create_command.rs
@@ -26,7 +26,7 @@ use bun_zlib as Zlib;
 use crate::Command;
 use crate::cli::which_npm_client::NPMClient;
 
-// PORT NOTE: `cli/create/` has no mod.rs yet; mount the generator directly here
+// `cli/create/` has no mod.rs yet; mount the generator directly here
 // so `SourceFileProjectGenerator::generate(...)` resolves. The submodule itself
 // reaches back into `crate::cli::create_command::Example` via absolute path.
 #[path = "create/SourceFileProjectGenerator.rs"]
@@ -37,7 +37,7 @@ pub mod SourceFileProjectGenerator;
 // thread (sequenced — git thread writes after main is done with it).
 static BUN_PATH_BUF: bun_core::RacyCell<PathBuffer> = bun_core::RacyCell::new(PathBuffer::ZEROED);
 
-// PORT NOTE: bun.OSPathLiteral — `bun_paths` does not (yet) export an
+// bun.OSPathLiteral — `bun_paths` does not (yet) export an
 // `os_path_literal!` macro from this crate's POV. `OSPathSlice` is `[u8]` on
 // POSIX, so byte-string literals coerce directly; the Windows `[u16]` form will
 // need the macro once it lands in `bun_paths` (see src/bun.rs).
@@ -72,9 +72,9 @@ fn exec_task(task_: &[u8], cwd: &[u8], _path: &[u8], npm_client: Option<NPMClien
 
     let npm_args = 2 * usize::from(npm_client.is_some());
     let total = count + npm_args;
-    // Zig fills `alloc(string, total)` by index; in Rust, `set_len` + index-write into
-    // uninitialized `&[u8]` slots is UB (invalid references exist before assignment).
-    // Build with `push` instead — same allocation, no unsafe.
+    // `set_len` + index-write into uninitialized `&[u8]` slots is UB (invalid
+    // references exist before assignment). Build with `push` instead — same
+    // allocation, no unsafe.
     let mut argv: Vec<&[u8]> = Vec::with_capacity(total);
 
     if let Some(ref client) = npm_client {
@@ -113,9 +113,8 @@ fn exec_task(task_: &[u8], cwd: &[u8], _path: &[u8], npm_client: Option<NPMClien
         stderr: spawn_sync::SyncStdio::Inherit,
         stdout: spawn_sync::SyncStdio::Inherit,
         stdin: spawn_sync::SyncStdio::Inherit,
-        // Zig: `.windows = if (Environment.isWindows) .{ .loop = EventLoopHandle.init(
-        //   MiniEventLoop.initGlobal(null, null)) }`. `WindowsOptions::default()` zeroes
-        // `loop_` (UB — null `uv_loop` deref in `spawn_process_windows`), so populate it.
+        // `WindowsOptions::default()` zeroes `loop_` (UB — null `uv_loop` deref
+        // in `spawn_process_windows`), so populate it.
         #[cfg(windows)]
         windows: spawn_sync::WindowsOptions {
             loop_: bun_event_loop::EventLoopHandle::init_mini(
@@ -141,7 +140,6 @@ impl ProgressBuf {
     }
 
     pub(crate) fn print(args: core::fmt::Arguments<'_>) -> Result<&'static [u8], bun_core::Error> {
-        // TODO(port): narrow error set
         Self::BUF_INDEX.with(|i| i.set(i.get() + 1));
         let idx = Self::BUF_INDEX.with(|i| i.get()) % 2;
         Self::BUFS.with_borrow_mut(|bufs| {
@@ -150,20 +148,19 @@ impl ProgressBuf {
             let cap = cursor.len();
             write!(&mut cursor, "{}", args).map_err(|_| bun_core::err!("NoSpaceLeft"))?;
             let written = cap - cursor.len();
-            // SAFETY: thread-local static buffer; lifetime extended for CLI usage. Matches Zig
-            // returning a slice into a module-level static.
+            // SAFETY: the slice points into a thread-local static buffer that
+            // lives for the thread's lifetime; CLI usage prints/copies it before
+            // the buffer is reused.
             let out: &'static [u8] = unsafe { bun_ptr::detach_lifetime(&buf[..written]) };
             Ok(out)
         })
     }
 
-    pub(crate) fn pretty(
-        _fmt: &'static str,
-        args: core::fmt::Arguments<'_>,
-    ) -> Result<&'static [u8], bun_core::Error> {
-        // TODO(port): Output.prettyFmt is a comptime fmt-string transform; the Rust
-        // `pretty_fmt` takes a single rendered payload, so callers should pre-render
-        // `args` with the color template baked in. `_fmt` is retained for API parity.
+    /// `pretty_fmt` post-processes the rendered payload, so callers bake the
+    /// color template into `args` directly. Note: `<tag>` sequences inside
+    /// interpolated arguments (e.g. a user-supplied template name) are also
+    /// rewritten here. Cosmetic-only on adversarial input.
+    pub(crate) fn pretty(args: core::fmt::Arguments<'_>) -> Result<&'static [u8], bun_core::Error> {
         if Output::enable_ansi_colors_stdout() {
             ProgressBuf::print(format_args!("{}", Output::pretty_fmt::<true>(args)))
         } else {
@@ -178,7 +175,9 @@ struct CreateOptions {
     overwrite: bool,
     skip_git: bool,
     skip_package_json: bool,
-    positionals: Box<[&'static [u8]]>, // TODO(port): lifetime — borrows from clap args
+    // `&'static` is sound: entries are duped into the process-lifetime CLI
+    // arena in `parse` (via `crate::cli::cli_dupe`), not borrowed from clap args.
+    positionals: Box<[&'static [u8]]>,
     verbose: bool,
     open: bool,
 }
@@ -199,8 +198,7 @@ impl CreateOptions {
     }
 
     pub(crate) fn parse(_ctx: &Command::Context<'_>) -> Result<CreateOptions, bun_core::Error> {
-        // Zig: `Output.is_verbose = Output.isVerbose();` — Rust has no setter; the
-        // `is_verbose()` accessor reads the env directly each call, so this is a no-op.
+        // The `is_verbose()` accessor reads the env directly each call, so this is a no-op.
         let _ = Output::is_verbose();
 
         let mut diag = clap::Diagnostic::default();
@@ -221,9 +219,9 @@ impl CreateOptions {
         };
 
         let mut opts = CreateOptions {
-            // PORT NOTE: clap positionals borrow from process argv; dupe each
+            // clap positionals borrow from process argv; dupe each
             // entry into the process-lifetime CLI arena to obtain
-            // `&'static [u8]` (mirrors Zig where argv is process-static).
+            // `&'static [u8]`.
             positionals: args
                 .positionals()
                 .iter()
@@ -236,8 +234,9 @@ impl CreateOptions {
         if opts.positionals.len() >= 1
             && (opts.positionals[0] == b"c" || opts.positionals[0] == b"create")
         {
-            // TODO(port): re-slicing Box<[T]> — store as Vec or slice with offset.
-            opts.positionals = opts.positionals[1..].to_vec().into_boxed_slice();
+            let mut v = core::mem::take(&mut opts.positionals).into_vec();
+            v.remove(0);
+            opts.positionals = v.into_boxed_slice();
         }
 
         opts.skip_package_json = args.flag(b"--no-package-json");
@@ -302,11 +301,11 @@ impl CreateCommand {
             supports_ansi_escape_codes: Output::enable_ansi_colors_stderr(),
             ..Default::default()
         };
-        // PORT NOTE: reshaped for borrowck — `Progress::start` returns
+        // `Progress::start` returns
         // `&mut Node` borrowing `progress` exclusively for the node's lifetime.
         // Convert to `*mut` immediately so `progress` and `node` can be used
-        // independently below (matches Zig's pointer semantics; same pattern as
-        // `CreateListExamplesCommand::exec` at the bottom of this file).
+        // independently below (same pattern as `CreateListExamplesCommand::exec`
+        // at the bottom of this file).
         let node: *mut ProgressNode = match example_tag {
             ExampleTag::JslikeFile => progress.start(
                 ProgressBuf::print(format_args!("Analyzing {}", bstr::BStr::new(template)))?,
@@ -328,12 +327,12 @@ impl CreateCommand {
             progress.refresh_rate_ns = (bun_core::time::NS_PER_MS * 8) as u64;
         }
 
-        // PORT NOTE: Zig `defer progress.refresh()`. Capture `*mut Progress` so
+        // Refresh the progress bar on exit. Capture `*mut Progress` so
         // the guard does not hold an exclusive borrow for the whole fn body;
         // `progress` is declared earlier so it is still alive when this drops.
         let progress_ptr: *mut Progress = &raw mut progress;
         let _refresh_on_exit = scopeguard::guard(progress_ptr, |p| {
-            // SAFETY: see PORT NOTE above — `progress` outlives this guard.
+            // SAFETY: see note above — `progress` outlives this guard.
             unsafe { (*p).refresh() };
         });
 
@@ -461,7 +460,7 @@ impl CreateCommand {
 
                 progress.refresh();
 
-                // PORT NOTE: see SKIP_DIRS note re: os_path_literal — Plucker::init
+                // See SKIP_DIRS note re: os_path_literal — Plucker::init
                 // takes `&[OSPathChar]`, which is `&[u8]` on POSIX / `&[u16]` on Windows.
                 #[cfg(not(windows))]
                 let package_json_lit: &OSPathSlice = b"package.json";
@@ -475,19 +474,29 @@ impl CreateCommand {
 
                 let mut archive_context = archiver::Context {
                     pluckers,
-                    all_files: Default::default(), // undefined in Zig
+                    all_files: Default::default(),
                     overwrite_list: bun_collections::StringArrayHashMap::<()>::default(),
                 };
 
                 if !create_options.overwrite {
-                    // TODO(port): blocked_on bun_libarchive::ArchiveAppender impl for
-                    // fs::DirnameStore — Zig passed `FileSystem.DirnameStore` (has
-                    // appendMutable). For now route through the no-op `()` appender.
-                    Archiver::get_overwriting_file_list::<(), 1>(
+                    // The overwrite list boxes its keys itself, so the appender
+                    // only needs to hand back a stable view of the path for that
+                    // copy.
+                    struct OverwriteListAppender {
+                        buf: Vec<u8>,
+                    }
+                    impl bun_libarchive::ArchiveAppender for OverwriteListAppender {
+                        fn append(&mut self, path: &[u8]) -> Result<&[u8], bun_core::Error> {
+                            self.buf.clear();
+                            self.buf.extend_from_slice(path);
+                            Ok(&self.buf)
+                        }
+                    }
+                    Archiver::get_overwriting_file_list::<OverwriteListAppender, 1>(
                         &tarball_buf_list,
                         destination,
                         &mut archive_context,
-                        &mut (),
+                        &mut OverwriteListAppender { buf: Vec::new() },
                     )?;
 
                     for never_conflict_path in NEVER_CONFLICT {
@@ -555,11 +564,9 @@ impl CreateCommand {
                 progress.refresh();
 
                 let abs_template_path = filesystem.abs(&template_parts);
-                // TODO(port): std.fs.openDirAbsolute — use bun_sys directory APIs
-                let _ = bun_sys::OpenDirOptions {
-                    iterate: true,
-                    ..Default::default()
-                };
+                // `Dir::open` routes through `open_dir_at`, which always yields an
+                // iterable handle (`FILE_LIST_DIRECTORY` on Windows; readdir-capable
+                // `O_DIRECTORY` fd on POSIX).
                 let template_dir = match bun_sys::Dir::open(abs_template_path) {
                     Ok(d) => d,
                     Err(err) => {
@@ -575,9 +582,7 @@ impl CreateCommand {
                     }
                 };
 
-                // TODO(port): std.fs.deleteTreeAbsolute — bun_sys lacks an absolute helper;
-                // route through cwd-relative delete_tree (absolute paths bypass dirfd on POSIX).
-                let _ = bun_sys::Dir::cwd().delete_tree(destination);
+                let _ = bun_sys::delete_tree_absolute(destination);
                 let destination_dir__ = match bun_sys::Fd::cwd().make_open_path(destination) {
                     Ok(d) => d,
                     Err(err) => {
@@ -682,7 +687,7 @@ impl CreateCommand {
 
                         package_json_contents =
                             MutableString::init(usize::try_from(size).expect("int cast"))?;
-                        // Zig: list.expandToCapacity() — set len to capacity so the buffer is readable.
+                        // Set len to capacity so the buffer is readable.
                         let cap = package_json_contents.list.capacity();
                         package_json_contents.list.resize(cap, 0);
 
@@ -782,14 +787,12 @@ impl CreateCommand {
                     break 'process_package_json;
                 }
 
-                // Zig builds a `properties_list` here via `fromOwnedSlice(.slice())`,
-                // which *aliases* the BabyList storage so subsequent
-                // `package_json_expr.asProperty(...)` reads still see the data. The
-                // commented-out injection logic below would append to it before the
-                // `moveFromList` round-trip. With those appends disabled the
-                // round-trip is a no-op, so leave `properties` in place — moving it
-                // out would make every `as_property` lookup below see an empty
-                // object and skip dependency detection / install.
+                // The commented-out injection logic below would append to a
+                // properties list and round-trip it back into the object. With
+                // those appends disabled the round-trip is a no-op, so leave
+                // `properties` in place — moving it out would make every
+                // `as_property` lookup below see an empty object and skip
+                // dependency detection / install.
 
                 if log.errors > 0 {
                     let _ = log.print(std::ptr::from_mut(Output::error_writer()));
@@ -802,8 +805,7 @@ impl CreateCommand {
                         let basename = bun_paths::basename(destination);
                         // SAFETY: `destination` is interned in the process-global DirnameStore
                         // (`append_slice` returns `&'static [u8]`); re-erase the borrow lifetime
-                        // to `'static` to match `EString.data: &'static [u8]`. Mirrors Zig's
-                        // `@ptrFromInt(@intFromPtr(...))` cast.
+                        // to `'static` to match `EString.data: &'static [u8]`.
                         s.data = bun_ast::StoreStr::new(unsafe {
                             core::slice::from_raw_parts(basename.as_ptr(), basename.len())
                         });
@@ -1003,16 +1005,13 @@ impl CreateCommand {
                 //     try properties_list.ensureUnusedCapacity(new_properties_count);
                 // }
 
-                // TODO(port): InjectionPrefill — large block of mutable static AST nodes used to
-                // inject "bun"/"macros"/dependency properties into package.json. The Zig code builds
-                // a tree of `E.String`/`E.Object`/`G.Property` values stored in `pub var` statics
-                // and wires their `.properties` lists together at runtime. In Rust, mutable statics
-                // of non-Sync AST types require careful redesign (likely thread_local! + Lazy or
-                // building the tree on the stack/arena per call). Since every consumer of
-                // InjectionPrefill below is commented out except `npx_react_scripts_build` and the
-                // three `.properties =` wiring lines (which themselves only feed commented-out
-                // code), we stub the module here and leave the full structure as a comment for
-                // reference.
+                // InjectionPrefill — AST nodes used to inject "bun"/"macros"/dependency
+                // properties into package.json. Every consumer of it below is
+                // commented out except `npx_react_scripts_build`, so the module is
+                // stubbed here with the full structure preserved as a comment for
+                // reference; if the commented-out injection code is ever revived, the
+                // statics should be rebuilt on the stack/arena per call rather than as
+                // mutable statics of non-Sync AST types.
                 mod injection_prefill {
                     // pub var dependencies_e_string = E.String.init(dependencies_string);
                     // pub var devDependencies_e_string = E.String.init(dev_dependencies_string);
@@ -1078,12 +1077,11 @@ impl CreateCommand {
                     // pub var dev_dependencies_key = js_ast.Expr{ .data = .{ .e_string = &devDependencies_e_string }, .loc = logger.Loc.Empty };
                     // pub var dependencies_key     = js_ast.Expr{ .data = .{ .e_string = &dependencies_e_string },    .loc = logger.Loc.Empty };
 
-                    // TODO(port): these wire up the static objects above; only feeds dead code
-                    pub(crate) fn wire() {
-                        // InjectionPrefill.bun_macro_relay_object.properties = ...fromBorrowedSliceDangerous(bun_macro_relay_properties[0..]);
-                        // InjectionPrefill.bun_macros_relay_object.properties = ...fromBorrowedSliceDangerous(&bun_macros_relay_object_properties);
-                        // InjectionPrefill.bun_macros_relay_only_object.properties = ...fromBorrowedSliceDangerous(&bun_macros_relay_only_object_properties);
-                    }
+                    // The static objects above were wired together at runtime; that
+                    // wiring only feeds the commented-out injection code below:
+                    // InjectionPrefill.bun_macro_relay_object.properties = ...fromBorrowedSliceDangerous(bun_macro_relay_properties[0..]);
+                    // InjectionPrefill.bun_macros_relay_object.properties = ...fromBorrowedSliceDangerous(&bun_macros_relay_object_properties);
+                    // InjectionPrefill.bun_macros_relay_only_object.properties = ...fromBorrowedSliceDangerous(&bun_macros_relay_only_object_properties);
 
                     pub(crate) fn npx_react_scripts_build() -> bun_ast::Expr {
                         bun_ast::Expr::init(
@@ -1093,8 +1091,6 @@ impl CreateCommand {
                     }
                 }
 
-                injection_prefill::wire();
-
                 // if (needs_to_inject_dev_dependency and dev_dependencies == null) {
                 //     var e_object = try ctx.allocator.create(E.Object);
                 //     e_object.* = E.Object{};
@@ -1196,8 +1192,7 @@ impl CreateCommand {
                 // don't do it!
                 // if (has_react_scripts) {
                 //     bail: {
-                //         // ... (large CRA index.html injection block; see Zig source lines 1183-1265)
-                //         // TODO(port): commented-out CRA HTML rewrite logic — preserved verbatim in Zig source
+                //         // ... (large CRA index.html injection block)
                 //     }
                 // }
 
@@ -1207,9 +1202,9 @@ impl CreateCommand {
                     .expect("infallible: variant checked")
                     .is_single_line = false;
 
-                // (Zig: `properties = .moveFromList(&properties_list)` — see note
-                // above; the aliasing round-trip is a no-op while the injection
-                // appends remain commented out, so `properties` is already current.)
+                // (See note above; the aliasing round-trip is a no-op while the
+                // injection appends remain commented out, so `properties` is
+                // already current.)
                 {
                     use bun_ast::ExprData as LExprData;
                     let mut i: usize = 0;
@@ -1302,7 +1297,7 @@ impl CreateCommand {
                         }
 
                         let value = props.slice()[i].value.unwrap();
-                        // PORT NOTE: `as_property` returns an owned `Query`
+                        // `as_property` returns an owned `Query`
                         // (Copy types backed by an arena `StoreRef`). Borrowck
                         // ties any `&[u8]` we pull out of it to the `if let`
                         // scope even though the underlying `EString.data` is
@@ -1493,8 +1488,7 @@ impl CreateCommand {
                 stderr: spawn_sync::SyncStdio::Inherit,
                 stdout: spawn_sync::SyncStdio::Inherit,
                 stdin: spawn_sync::SyncStdio::Inherit,
-                // Zig: `.windows = if (Environment.isWindows) .{ .loop = EventLoopHandle.init(
-                //   MiniEventLoop.initGlobal(null, null)) }`. Default would zero `loop_` → UB.
+                // Default would zero `loop_` → UB.
                 #[cfg(windows)]
                 windows: spawn_sync::WindowsOptions {
                     loop_: bun_event_loop::EventLoopHandle::init_mini(
@@ -1584,7 +1578,6 @@ impl CreateCommand {
             );
         }
 
-        // PORT NOTE: Zig `filesystem.relativeTo(destination)` —
         // `bun_resolver::fs::FileSystem` (the inline shim) has no `relative_to`; call
         // the resolver path helper directly with the singleton's `top_level_dir`.
         let rel_destination =
@@ -1611,8 +1604,6 @@ impl CreateCommand {
             let bun_path_buf = unsafe { &mut *BUN_PATH_BUF.get() };
             if let Some(bin) = which(bun_path_buf, path_env, destination, b"bun") {
                 let argv: [&[u8]; 1] = [bin.as_bytes()];
-                // Zig used `std.process.Child`; PORTING.md bans std::process — route through
-                // bun.spawnSync (`crate::api::bun_process::sync::spawn`).
                 crate::cli::open::open_url(bun_core::zstr!("http://localhost:3000/"));
 
                 let _ = spawn_sync::spawn(&spawn_sync::Options {
@@ -1621,8 +1612,7 @@ impl CreateCommand {
                     stdin: spawn_sync::SyncStdio::Inherit,
                     stdout: spawn_sync::SyncStdio::Inherit,
                     stderr: spawn_sync::SyncStdio::Inherit,
-                    // Zig used `std.process.Child` (no uv loop). PORTING.md routes this through
-                    // `bun.spawnSync`, which on Windows requires a live `loop_` — supply it.
+                    // `bun.spawnSync` on Windows requires a live `loop_` — supply it.
                     #[cfg(windows)]
                     windows: spawn_sync::WindowsOptions {
                         loop_: bun_event_loop::EventLoopHandle::init_mini(
@@ -1819,12 +1809,13 @@ impl CreateCommand {
 
 pub(crate) struct ExtractedInfo {
     pub example_tag: ExampleTag,
-    pub template: &'static [u8], // TODO(port): lifetime — borrows from positionals/static buffer
+    // `&'static` is sound: this borrows either CLI-arena-duped positionals or a
+    // static buffer, both process-lifetime.
+    pub template: &'static [u8],
 }
 
-// PORT NOTE: hoisted from Zig fn-local `const FileCopier = struct { pub fn copy(...) }` inside
-// CreateCommand.exec, because Rust does not allow capturing-closure-style nested fns and the
-// fn body is large.
+// Hoisted out of CreateCommand.exec because Rust does not allow
+// capturing-closure-style nested fns and the fn body is large.
 fn file_copier_copy(
     destination_dir_: &bun_sys::Dir,
     walker: &mut bun_sys::walker_skippable::Walker,
@@ -1868,7 +1859,7 @@ fn file_copier_copy(
                     }
                 }
                 bun_sys::FileKind::File => {
-                    // PORT NOTE: capture `node_` as a raw pointer so the defer closure
+                    // Capture `node_` as a raw pointer so the defer closure
                     // doesn't hold a unique borrow across the error-path `node_.end()` below.
                     let node_ptr: *mut ProgressNode = node_;
                     // SAFETY: `node_` outlives this match arm; single-threaded progress access.
@@ -1963,7 +1954,7 @@ fn file_copier_copy(
                 }
             };
             let _close_out = bun_sys::CloseOnDrop::new(outfile);
-            // PORT NOTE: capture `node_` as a raw pointer so the defer body
+            // Capture `node_` as a raw pointer so the defer body
             // doesn't hold a unique borrow across the error-path `node_.end()` below.
             let node_ptr: *mut ProgressNode = node_;
             // SAFETY: `node_` outlives this loop body; single-threaded progress access.
@@ -1998,7 +1989,6 @@ fn file_copier_copy(
     Ok(())
 }
 
-// PORT NOTE: hoisted from Zig fn-local `const Analyzer = struct {...}` inside runOnEntryPoint.
 struct Analyzer<'a> {
     ctx: &'a Command::Context<'a>,
     example_tag: ExampleTag,
@@ -2038,14 +2028,13 @@ fn run_on_entry_point(
     crate::cli::build_command::BuildCommand::exec(crate::cli::Command::get(), Some(&fetcher))
 }
 
-// `Commands` was a Zig anonymous tuple of three single-element string arrays, used only to
-// drive `inline for` over its three fields in GitHandler.run. In Rust we just iterate the
-// three git command arrays directly (see GitHandler::run).
-
 pub struct Example {
-    pub name: &'static [u8],        // TODO(port): lifetime
-    pub version: &'static [u8],     // TODO(port): lifetime
-    pub description: &'static [u8], // TODO(port): lifetime
+    // `&'static` is sound for these three fields: they borrow either static
+    // literals, the process-lifetime CLI arena (`cli_arena()` — remote
+    // examples JSON), or `filesystem.filename_store` (local examples).
+    pub name: &'static [u8],
+    pub version: &'static [u8],
+    pub description: &'static [u8],
     pub local: bool,
 }
 
@@ -2088,8 +2077,7 @@ static URL_: bun_core::RacyCell<Option<URL<'static>>> = bun_core::RacyCell::new(
 static APP_NAME_BUF: bun_core::RacyCell<[u8; 512]> = bun_core::RacyCell::new([0u8; 512]);
 static GITHUB_REPOSITORY_URL_BUF: bun_core::RacyCell<[u8; 1024]> =
     bun_core::RacyCell::new([0u8; 1024]);
-// PORT NOTE: Zig used a fn-local `var url_buf: [1024]u8` in `Example.fetch`;
-// hoisted to a static so the borrowed slice satisfies `URL<'static>` for
+// Static so the borrowed slice satisfies `URL<'static>` for
 // `AsyncHTTP::init_sync` (single-threaded CLI; same pattern as
 // `GITHUB_REPOSITORY_URL_BUF`).
 static NPM_REGISTRY_URL_BUF: bun_core::RacyCell<[u8; 1024]> = bun_core::RacyCell::new([0u8; 1024]);
@@ -2182,8 +2170,7 @@ impl Example {
                         match entry.kind {
                             bun_sys::FileKind::Directory => {
                                 for skip_dir in SKIP_DIRS {
-                                    // PORT NOTE: `bun.pathLiteral` is a comptime cast to OSPathSlice
-                                    // already applied in the `SKIP_DIRS` literal table; compare directly.
+                                    // `SKIP_DIRS` entries are already OS-path slices; compare directly.
                                     if entry.name.slice() == *skip_dir {
                                         continue 'loop_;
                                     }
@@ -2203,9 +2190,6 @@ impl Example {
                                     )
                                 };
 
-                                // Zig: `folder.accessZ(path, .{ .mode = .read_only })` (std.fs.Dir.accessZ).
-                                // bun_sys exposes `faccessat` for F_OK only; use it as the existence
-                                // gate here. TODO(port): plumb R_OK once bun_sys grows an accessor.
                                 if !bun_sys::faccessat(folder, path).unwrap_or(false) {
                                     continue 'loop_;
                                 }
@@ -2243,10 +2227,11 @@ impl Example {
             repository = &repository[0..i as usize];
         }
 
-        progress.name = ProgressBuf::pretty(
+        progress.name = ProgressBuf::pretty(format_args!(
             "<d>[github] <b>GET<r> <blue>{}/{}<r>",
-            format_args!("{}/{}", bstr::BStr::new(owner), bstr::BStr::new(repository)),
-        )?;
+            bstr::BStr::new(owner),
+            bstr::BStr::new(repository),
+        ))?;
         refresher.refresh();
 
         let mut github_api_domain: &[u8] = b"api.github.com";
@@ -2465,8 +2450,7 @@ impl Example {
 
             let _ = log.print(std::ptr::from_mut(Output::error_writer()));
             Global::exit(1);
-        } // `bun_ast::Expr` cover the same surface (Zig: `asProperty`/
-        // `asString` for parse_utf8-produced UTF-8 literals).
+        }
         let tarball_url: &[u8] = 'brk: {
             if let Some(q) = expr.as_property(b"dist") {
                 if let Some(p) = q.expr.as_property(b"tarball") {
@@ -2597,9 +2581,8 @@ impl Example {
 
         bun_ast::initialize_store();
         let source = bun_ast::Source::init_path_string(b"examples.json", mutable.list.as_slice());
-        // PORT NOTE: Zig passed `ctx.allocator`; ContextData dropped the allocator
-        // field (global mimalloc) — use the process-lifetime CLI arena (examples
-        // slices borrow from it and the CLI exits shortly after).
+        // Use the process-lifetime CLI arena (examples slices borrow from it
+        // and the CLI exits shortly after).
         let bump: &'static bun_alloc::Arena = crate::cli::cli_arena();
         // SAFETY: single-threaded CLI dispatch; no other borrow of the
         // process-static `Cli::LOG_` is live across this scope.
@@ -2708,9 +2691,8 @@ impl CreateListExamplesCommand {
             supports_ansi_escape_codes: Output::enable_ansi_colors_stderr(),
             ..Default::default()
         };
-        // PORT NOTE: `Progress::start` returns `&mut Node` borrowing `progress`; detach
-        // via raw pointer so `progress.refresh()` can re-borrow below (mirrors Zig where
-        // both held independent `*Node`/`*Progress` pointers).
+        // `Progress::start` returns `&mut Node` borrowing `progress`; detach
+        // via raw pointer so `progress.refresh()` can re-borrow below.
         let node: *mut ProgressNode = progress.start(b"Fetching manifest", 0);
         progress.refresh();
 
@@ -2753,7 +2735,7 @@ impl CreateListExamplesCommand {
 struct GitHandler;
 
 static SUCCESS: AtomicU32 = AtomicU32::new(0);
-// Zig used `std.Thread`; bun_threading has no top-level Thread wrapper yet,
+// bun_threading has no top-level Thread wrapper yet,
 // so use std::thread::JoinHandle directly (CLI-only, no JSC interaction).
 // PORTING.md §Global mutable state: written in `spawn`, taken in `wait`, both
 // on the main CLI thread → RacyCell.
@@ -2764,15 +2746,12 @@ impl GitHandler {
     pub(crate) fn spawn(destination: &[u8], path: &[u8], verbose: bool) {
         SUCCESS.store(0, Ordering::Relaxed);
 
-        // TODO(port): std.Thread.spawn — destination/path borrowed across thread; Zig relied on
-        // them being long-lived (filesystem dirname_store / env). Ensure 'static or own.
-        // SAFETY: `destination` lives in `filesystem.dirname_store` and `path` in env loader;
-        // both are 'static for the CLI process. Extend lifetimes to satisfy `spawn`.
-        let destination: &'static [u8] = unsafe { bun_ptr::detach_lifetime(destination) };
-        // SAFETY: `path` is owned by the process-lifetime env loader; valid for `'static`.
-        let path: &'static [u8] = unsafe { bun_ptr::detach_lifetime(path) };
+        // Own copies so the spawned closure is `'static` without any lifetime
+        // extension.
+        let destination: Box<[u8]> = Box::from(destination);
+        let path: Box<[u8]> = Box::from(path);
         let thread = match std::thread::Builder::new()
-            .spawn(move || Self::spawn_thread(destination, path, verbose))
+            .spawn(move || Self::spawn_thread(&destination, &path, verbose))
         {
             Ok(t) => t,
             Err(err) => {
@@ -2835,10 +2814,9 @@ impl GitHandler {
 
         // SAFETY: single-threaded CLI access to module-level static path buffer (note: this fn
         // may run on the git thread; BUN_PATH_BUF is also touched on main thread for `--open`.
-        // The two uses are sequenced — git runs before `--open` block. Matches Zig.)
+        // The two uses are sequenced — git runs before `--open` block.)
         let bun_path_buf = unsafe { &mut *BUN_PATH_BUF.get() };
-        // Zig used `std.process.Child` (no libuv). The Rust port routes through
-        // `bun.spawnSync`, which on Windows drives `uv_spawn` and needs a uv loop. This fn
+        // `bun.spawnSync` on Windows drives `uv_spawn` and needs a uv loop. This fn
         // runs on the dedicated git thread (see `GitHandler::spawn`), so use the
         // *thread-local* `MiniEventLoop` singleton — `init_global` is `thread_local!`-backed,
         // so the main thread's loop is not touched (driving it cross-thread would be libuv UB).
@@ -2864,11 +2842,7 @@ impl GitHandler {
                 bun_core::pretty_errorln!("git backend: {}", bstr::BStr::new(git));
             }
 
-            // same names, just comptime known values
-            // PORT NOTE: Zig used `inline for` over std.meta.fieldNames(@TypeOf(Commands)) to
-            // index into git_commands by tuple field index. We just iterate the array directly.
             for command in git_commands {
-                // Zig used `std.process.Child`; PORTING.md bans std::process — use bun.spawnSync.
                 let _ = spawn_sync::spawn(&spawn_sync::Options {
                     argv: command.iter().map(|s| Box::<[u8]>::from(*s)).collect(),
                     cwd: Box::from(destination),
@@ -2895,5 +2869,3 @@ impl GitHandler {
         Ok(false)
     }
 }
-
-// ported from: src/cli/create_command.zig
diff --git a/src/runtime/cli/discord_command.rs b/src/runtime/cli/discord_command.rs
index 518f9568214..b1fc8e51281 100644
--- a/src/runtime/cli/discord_command.rs
+++ b/src/runtime/cli/discord_command.rs
@@ -5,11 +5,9 @@ pub(crate) struct DiscordCommand;
 impl DiscordCommand {
     const DISCORD_URL: &'static [u8] = b"https://bun.com/discord";
 
-    // TODO(port): narrow error set — body has no fallible calls; `!void` only matches CLI command signature
+    // Infallible body; `Result` only matches the CLI command dispatch signature.
     pub(crate) fn exec() -> Result<(), bun_core::Error> {
         open::open_url(Self::DISCORD_URL);
         Ok(())
     }
 }
-
-// ported from: src/cli/discord_command.zig
diff --git a/src/runtime/cli/exec_command.rs b/src/runtime/cli/exec_command.rs
index 41aef8db739..94b104e7c19 100644
--- a/src/runtime/cli/exec_command.rs
+++ b/src/runtime/cli/exec_command.rs
@@ -12,8 +12,7 @@ use crate::command::Context;
 
 pub(crate) struct ExecCommand;
 
-/// Process-lifetime arena for the exec command's `Transpiler`. Zig passed
-/// `ctx.allocator` (== `bun.default_allocator`); the Rust port threads an
+/// Process-lifetime arena for the exec command's `Transpiler`; threads an
 /// `&'static Arena` per PORTING.md §AST crates. Same `Once`-guarded
 /// `RacyCell<MaybeUninit>` shape as `run_command::runner_arena` (Bump is
 /// `!Sync`, so `OnceLock` cannot hold it directly).
@@ -34,10 +33,9 @@ fn exec_arena() -> &'static bun_alloc::Arena {
 }
 
 impl ExecCommand {
-    // TODO(port): narrow error set
     pub(crate) fn exec(ctx: Context) -> Result<(), bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — clone the positional so `ctx`
-        // can be reborrowed `&mut` for `init_and_run_from_source` below.
+        // Clone the positional so `ctx` can be reborrowed `&mut` for
+        // `init_and_run_from_source` below.
         let script: Box<[u8]> = ctx.positionals[1].clone();
         // this is a hack: make dummy bundler so we can use its `.runEnvLoader()` function to populate environment variables probably should split out the functionality
         let mut bundle = Transpiler::init(
@@ -53,7 +51,7 @@ impl ExecCommand {
             },
             None,
         )?;
-        // PORT NOTE: reshaped for borrowck — read field before &mut method call
+        // Read the field before the `&mut` method call (borrowck).
         let disable_default_env_files = bundle.options.env.disable_default_env_files;
         bundle.run_env_loader(disable_default_env_files)?;
         let mut buf = PathBuffer::uninit();
@@ -105,5 +103,3 @@ impl ExecCommand {
         // }
     }
 }
-
-// ported from: src/cli/exec_command.zig
diff --git a/src/runtime/cli/filter_arg.rs b/src/runtime/cli/filter_arg.rs
index 284315ec4f7..dec268ce715 100644
--- a/src/runtime/cli/filter_arg.rs
+++ b/src/runtime/cli/filter_arg.rs
@@ -22,7 +22,6 @@ fn glob_ignore_fn(val: &[u8]) -> bool {
         return false;
     }
 
-    // PERF(port): Zig used `inline for` over a comptime tuple — plain loop over const slice here.
     for skip in SKIP_LIST {
         if val == *skip {
             return true;
@@ -32,14 +31,14 @@ fn glob_ignore_fn(val: &[u8]) -> bool {
     false
 }
 
-// PORT NOTE: Zig `glob.GlobWalker(globIgnoreFn, glob.walk.DirEntryAccessor, false)` is a
-// comptime type-generator taking (ignore_fn, Accessor type, sentinel: bool). In Rust the
-// ignore filter is a runtime parameter on `init_with_cwd`, and `DirEntryAccessor` lives in
-// `bun_resolver` (it depends on the resolver's DirEntry cache).
+// The ignore filter is a runtime parameter on `init_with_cwd`, and
+// `DirEntryAccessor` lives in `bun_resolver` (it depends on the resolver's
+// DirEntry cache).
 type GlobWalker = glob::GlobWalker<bun_resolver::DirEntryAccessor, false>;
-// TODO(port): self-referential — Iterator borrows the GlobWalker stored alongside it in
-// `PackageFilterIterator`. Forced to `'static` here; see `init_walker` for the unsafe
-// lifetime erasure. TODO(refactor): Pin<Box<Self>> or fold walker+iter into one type.
+// The Iterator borrows the GlobWalker owned by `PackageFilterIterator`. The walker is
+// heap-allocated (`*mut GlobWalker` from `Box::into_raw`) so its address is stable even if
+// the `PackageFilterIterator` itself moves; the borrow is erased to `'static` because the
+// allocation lives until `deinit_walker` drops the iterator first, then frees the walker.
 type GlobWalkerIterator = glob::walk::Iterator<'static, bun_resolver::DirEntryAccessor, false>;
 
 pub(crate) fn get_candidate_package_patterns<'a>(
@@ -48,15 +47,14 @@ pub(crate) fn get_candidate_package_patterns<'a>(
     workdir_: &[u8],
     root_buf: &'a mut PathBuffer,
 ) -> Result<&'a [u8], bun_core::Error> {
-    // TODO(port): narrow error set
     bun_ast::expr::data::Store::create();
     bun_ast::stmt::data::Store::create();
     let _store_guard = bun_ast::StoreResetGuard::new();
 
     let mut workdir = workdir_;
 
-    // PORT NOTE: reshaped Zig `while (true) : (workdir = dirname(workdir) orelse break)` as a
-    // labeled loop with an inner labeled block; `continue` → `break 'body`, `break` → `break 'walk`.
+    // Labeled loop with an inner labeled block; `continue` → `break 'body`,
+    // `break` → `break 'walk`.
     'walk: loop {
         'body: {
             let mut name_buf = PathBuffer::uninit();
@@ -70,7 +68,7 @@ pub(crate) fn get_candidate_package_patterns<'a>(
             log.errors = 0;
             log.warnings = 0;
 
-            // PORT NOTE: `bun.sys.File.toSource` was MOVE_DOWN'd to `bun_ast::to_source`
+            // Note: `bun.sys.File.toSource` was MOVE_DOWN'd to `bun_ast::to_source`
             // (T1 cannot name T2 — see src/sys/File.rs:446).
             let json_source = match bun_ast::to_source(json_path, Default::default()) {
                 Err(err) => match err.get_errno() {
@@ -84,9 +82,9 @@ pub(crate) fn get_candidate_package_patterns<'a>(
             // `defer allocator.free(json_source.contents)` — deleted; `json_source` owns its
             // contents and drops at end of scope.
 
-            // PERF(port): Zig threaded `ctx.allocator` through `parsePackageJSONUTF8`; the Rust
-            // signature takes a `&Bump` arena explicitly. Nodes go through the global Store, so
-            // this only buffers transient parser scratch — fresh per-iteration is fine.
+            // `parse_package_json_utf8` takes a `&Bump` arena explicitly. Nodes go
+            // through the global Store, so this only buffers transient parser
+            // scratch — fresh per-iteration is fine.
             let bump = bun_alloc::Arena::new();
             let json = json::parse_package_json_utf8(&json_source, log, &bump)?;
 
@@ -135,7 +133,6 @@ pub(crate) fn get_candidate_package_patterns<'a>(
             return Ok(&root_buf[0..parent_trimmed.len()]);
         }
 
-        // continue-expression of the Zig `while`
         workdir = match bun_core::dirname(workdir) {
             Some(d) => d,
             None => break 'walk,
@@ -150,10 +147,7 @@ pub(crate) fn get_candidate_package_patterns<'a>(
 }
 
 pub(crate) struct FilterSet {
-    // `std.mem.Allocator param` — deleted (non-AST crate; global mimalloc).
-
-    // TODO: Pattern should be
-    //  union (enum) { name: []const u32, path: []const u32, any_name: void }
+    // TODO: Pattern should be an enum: Name(Vec<u32>) | Path(Vec<u32>) | AnyName.
     pub filters: Vec<Pattern>,
     pub has_name_filters: bool,
     pub match_all: bool,
@@ -167,9 +161,8 @@ pub enum PatternKind {
 }
 
 pub struct Pattern {
-    // PERF(port): in Zig, `.name`-kind patterns borrowed the caller's filter slice and only
-    // `.path`-kind patterns were heap-allocated (see `deinit`). Here both are `Box<[u8]>` so
-    // `Drop` is uniform; revisit if filter-arg construction shows up in profiles.
+    // PERF: both kinds are `Box<[u8]>` so `Drop` is uniform; revisit if
+    // filter-arg construction shows up in profiles.
     pub pattern: Box<[u8]>,
     pub kind: PatternKind,
     // negate: bool = false,
@@ -196,7 +189,6 @@ impl FilterSet {
         filters: &[F],
         cwd_: &[u8],
     ) -> Result<FilterSet, bun_core::Error> {
-        // TODO(port): narrow error set
         let cwd = cwd_;
 
         let mut buf = PathBuffer::uninit();
@@ -229,7 +221,7 @@ impl FilterSet {
             } else {
                 self_.has_name_filters = true;
                 list.push(Pattern {
-                    // PERF(port): Zig borrowed `filter_utf8_` here; we dupe to keep `Pattern` owning.
+                    // PERF: dupe to keep `Pattern` owning.
                     pattern: Box::<[u8]>::from(filter_utf8),
                     kind: PatternKind::Name,
                 });
@@ -239,8 +231,7 @@ impl FilterSet {
         Ok(self_)
     }
 
-    // `pub fn deinit` — deleted: `Vec<Pattern>` drops each `Box<[u8]>` automatically.
-    // The Zig conditionally freed only `.path`-kind patterns; see PERF note on `Pattern.pattern`.
+    // No explicit deinit: `Vec<Pattern>` drops each `Box<[u8]>` automatically.
 
     pub(crate) fn matches_path(&self, path: &[u8]) -> bool {
         for filter in &self.filters {
@@ -266,17 +257,18 @@ impl FilterSet {
 }
 
 pub(crate) struct PackageFilterIterator {
-    // `patterns` and `root_dir` borrow from the caller (Zig: `[]const u8`).
-    // Callers keep them alive for the iterator's lifetime — `RawSlice`
-    // invariant. TODO(refactor): thread a `<'a>` lifetime on the struct instead.
+    // `patterns` and `root_dir` borrow from the caller.
+    // Callers keep them alive for the iterator's lifetime — `RawSlice` invariant.
     patterns: bun_ptr::RawSlice<Box<[u8]>>,
     pattern_idx: usize,
     root_dir: bun_ptr::RawSlice<u8>,
 
-    walker: MaybeUninit<GlobWalker>,
+    // Heap-allocated via `Box::into_raw` so the `iter` borrow stays valid if `self` moves.
+    // Null iff `valid == false` (`init_walker` tears down on failure to keep this).
+    // Owned by `self`; freed in `deinit_walker`.
+    walker: *mut GlobWalker,
     iter: MaybeUninit<GlobWalkerIterator>,
     valid: bool,
-    // `std.mem.Allocator param` — deleted (non-AST crate).
 }
 
 impl PackageFilterIterator {
@@ -284,20 +276,18 @@ impl PackageFilterIterator {
         patterns: &[Box<[u8]>],
         root_dir: &[u8],
     ) -> Result<PackageFilterIterator, bun_core::Error> {
-        // TODO(port): narrow error set (Zig signature was `!PackageFilterIterator` but body is infallible)
         Ok(PackageFilterIterator {
             // Caller keeps `patterns`/`root_dir` alive for the iterator's lifetime — `RawSlice` invariant.
             patterns: bun_ptr::RawSlice::new(patterns),
             pattern_idx: 0,
             root_dir: bun_ptr::RawSlice::new(root_dir),
-            walker: MaybeUninit::uninit(),
+            walker: core::ptr::null_mut(),
             iter: MaybeUninit::uninit(),
             valid: false,
         })
     }
 
     fn walker_next(&mut self) -> Result<Option<glob::walk::MatchedPath>, bun_core::Error> {
-        // TODO(port): narrow error set
         loop {
             // SAFETY: `valid == true` (caller invariant) so `iter` is initialized.
             let iter = unsafe { self.iter.assume_init_mut() };
@@ -314,13 +304,11 @@ impl PackageFilterIterator {
     }
 
     fn init_walker(&mut self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // pattern_idx < patterns.len() checked by caller.
         let pattern: &[u8] = &self.patterns.slice()[self.pattern_idx];
-        // PERF(port): Zig created an `ArenaAllocator` here and handed it to the walker (which takes
-        // ownership). bun_glob's Rust API copies `pattern`/`cwd` internally.
+        // bun_glob copies `pattern`/`cwd` internally.
         let cwd: &[u8] = self.root_dir.slice();
-        // `try (try ...).unwrap()`: outer `?` is the Zig `!`, inner converts `Maybe(Self)` to `!Self`.
+        // outer `?` propagates the error, inner converts `Maybe(Self)` to a Result.
         let walker = GlobWalker::init_with_cwd(
             pattern,
             cwd,
@@ -331,30 +319,38 @@ impl PackageFilterIterator {
             true,
             Some(glob_ignore_fn),
         )??;
-        self.walker.write(walker);
-        // TODO(port): self-referential — `iter.walker` borrows `self.walker`. This is unsound
-        // if `PackageFilterIterator` moves after `init_walker`. TODO(refactor): Pin<Box<Self>> or
-        // fold walker+iter into a single bun_glob type. Erase the lifetime to `'static` for now.
-        // SAFETY: `init_with_cwd` just initialized `self.walker` above; lifetime erased per TODO.
-        let walker_ref =
-            unsafe { &mut *std::ptr::from_mut::<GlobWalker>(self.walker.assume_init_mut()) };
-        self.iter.write(glob::walk::Iterator::new(walker_ref));
+        // Heap-allocate the walker so its address is stable even if `self` moves between
+        // `init_walker` and the iterator's last use. `iter` holds a `'static`-erased `&mut`
+        // into this allocation; `deinit_walker` drops `iter` before freeing the walker.
+        let walker_ptr = Box::into_raw(Box::new(walker));
+        self.walker = walker_ptr;
+        // SAFETY: `walker_ptr` is a live, uniquely-owned heap allocation that outlives `iter`
+        // (freed only in `deinit_walker`, after `iter` is dropped).
+        self.iter
+            .write(glob::walk::Iterator::new(unsafe { &mut *walker_ptr }));
         // SAFETY: just wrote `iter`.
-        unsafe { self.iter.assume_init_mut() }.init()??;
+        let inited: Result<(), bun_core::Error> =
+            (|| Ok(unsafe { self.iter.assume_init_mut() }.init()??))();
+        if let Err(err) = inited {
+            // Tear down `iter` and the walker allocation so `walker` is null again
+            // whenever `valid == false` (the field invariant).
+            self.deinit_walker();
+            return Err(err);
+        }
         Ok(())
     }
 
     fn deinit_walker(&mut self) {
-        // SAFETY: `valid == true` (caller invariant) so both are initialized.
-        // Drop iter first (it borrows walker).
+        // SAFETY: `iter` and `walker` are initialized (caller invariant).
+        // Drop iter first (it borrows the walker allocation), then free the walker.
         unsafe {
             self.iter.assume_init_drop();
-            self.walker.assume_init_drop();
+            drop(Box::from_raw(self.walker));
         }
+        self.walker = core::ptr::null_mut();
     }
 
     pub(crate) fn next(&mut self) -> Result<Option<glob::walk::MatchedPath>, bun_core::Error> {
-        // TODO(port): narrow error set
         loop {
             if !self.valid {
                 // Raw slice pointer `len()` reads only metadata — no deref/autoref needed.
@@ -366,9 +362,9 @@ impl PackageFilterIterator {
                     return Ok(None);
                 }
             }
-            // PORT NOTE: reshaped for borrowck — Zig captured `path` from `walkerNext` then
-            // returned it; here we must end the `&mut self` borrow before re-borrowing on the
-            // else branch. We rely on NLL to make this work; if it doesn't, restructure.
+            // Note: shaped for borrowck — we must end the `&mut self` borrow before
+            // re-borrowing on the else branch. We rely on NLL to make this work; if
+            // it doesn't, restructure.
             if let Some(path) = self.walker_next()? {
                 return Ok(Some(path));
             } else {
@@ -387,5 +383,3 @@ impl Drop for PackageFilterIterator {
         }
     }
 }
-
-// ported from: src/cli/filter_arg.zig
diff --git a/src/runtime/cli/filter_run.rs b/src/runtime/cli/filter_run.rs
index 930185b387b..97e554a7ae9 100644
--- a/src/runtime/cli/filter_run.rs
+++ b/src/runtime/cli/filter_run.rs
@@ -18,15 +18,14 @@ use bun_io::{BufferedReader, ReadState};
 use bun_resolver::package_json::{IncludeDependencies, IncludeScripts};
 use bun_sys as sys;
 
-// TODO(port): several `[]const u8` fields below are leaked in Zig (program exits). In Zig,
-// `script_content` and `combined` alias the same `copy_script` buffer; here they are split
-// into separate owned boxes. Revisit ownership.
+// The string fields below are owned boxes, except `combined` which is interned
+// in the process-lifetime CLI arena.
 struct ScriptConfig {
     package_json_path: Box<[u8]>,
     package_name: Box<[u8]>,
     script_name: Box<[u8]>,
     script_content: Box<[u8]>,
-    combined: &'static ZStr, // TODO(port): lifetime — points into leaked copy_script buffer
+    combined: &'static ZStr, // interned via `cli_dupe` into the process-lifetime CLI arena
     // Owned dep names; `DependencyMap.source_buf` would dangle once the
     // parsed `PackageJSON` (which owns the file bytes) drops.
     deps: Vec<Box<[u8]>>,
@@ -41,17 +40,16 @@ struct ScriptConfig {
     elide_count: Option<usize>,
 }
 
-// Anonymous struct in Zig: `process: ?struct { ptr, status }`
 struct ProcessInfo {
     // Intrusive ref-counted (`ThreadSafeRefCount<Process>`); raw `*mut` matches
-    // `to_process()` and `set_exit_handler` callers (Zig: `*Process`).
+    // `to_process()` and `set_exit_handler` callers.
     ptr: *mut Process,
     status: Status,
 }
 
-// PORT NOTE: `state` is a backref into the owning `State` (which holds `handles: []ProcessHandle`),
-// and `dependents` holds raw pointers into that same `handles` slice. This is self-referential in
-// Zig; kept as raw pointers per LIFETIMES.tsv (BACKREF).
+// `state` is a backref into the owning `State` (which holds `handles: []ProcessHandle`),
+// and `dependents` holds raw pointers into that same `handles` slice. This is
+// self-referential; kept as raw pointers per LIFETIMES.tsv (BACKREF).
 pub(crate) struct ProcessHandle<'a> {
     config: &'a ScriptConfig,
     state: bun_ptr::BackRef<State<'a>>,
@@ -74,8 +72,7 @@ pub(crate) struct ProcessHandle<'a> {
 
 impl<'a> ProcessHandle<'a> {
     fn start(&mut self) -> Result<(), bun_core::Error> {
-        // Copy the BackRef out so the `&mut State` borrow is detached from `self`
-        // (matches Zig's free aliasing of `*State` alongside `*ProcessHandle`).
+        // Copy the BackRef out so the `&mut State` borrow is detached from `self`.
         let mut state_ref = self.state;
         // SAFETY: state backref is valid for the lifetime of the run loop (State outlives all handles).
         let state = unsafe { state_ref.get_mut() };
@@ -97,17 +94,16 @@ impl<'a> ProcessHandle<'a> {
             // Get the envp with the PATH configured
             // There's probably a more optimal way to do this where you have a Vec shared
             // instead of creating a new one for each process
-            // PERF(port): was arena bulk-free (std.heap.ArenaAllocator) — profile if it shows up on a hot path.
             let env_ptr = state.env;
             // SAFETY: state.env is the process-lifetime DotEnv loader (Transpiler::env).
             let env = unsafe { &mut *env_ptr };
-            // PORT NOTE: copy to owned — `original_path` borrows env.map which is
-            // mutated by put() below (Zig aliased freely).
+            // Copy to owned — `original_path` borrows env.map which is
+            // mutated by put() below.
             let original_path: Box<[u8]> = env.map.get(b"PATH").unwrap_or(b"").into();
             let _ = env.map.put(b"PATH", &handle.config.PATH);
-            // Zig: `defer { ... env.map.put("PATH", original_path); }` — restores PATH
-            // unconditionally at block exit (success OR error). Keep the guard armed for the
-            // whole block so `?` early-returns also restore.
+            // Restores PATH unconditionally at block exit (success OR error).
+            // Keep the guard armed for the whole block so `?` early-returns also
+            // restore.
             scopeguard::defer! {
                 // SAFETY: env_ptr valid for the run loop lifetime (see above).
                 let _ = unsafe { (*env_ptr).map.put(b"PATH", &original_path) };
@@ -123,7 +119,7 @@ impl<'a> ProcessHandle<'a> {
                     envp.as_ptr().cast::<*const c_char>(),
                 )
             }??;
-            // `_guard` drops here (or on `?` above), restoring PATH — matches Zig `defer`.
+            // `_guard` drops here (or on `?` above), restoring PATH.
         };
         #[cfg(unix)]
         let (stdout_fd, stderr_fd) = (spawned.stdout, spawned.stderr);
@@ -253,7 +249,7 @@ bun_io::impl_buffered_reader_parent! {
     event_loop      = |this| (*(*this).state.as_ptr()).event_loop_handle.as_event_loop_ctx();
 }
 
-/// `Output.prettyFmt(str, true)` — comptime ANSI-tag expansion in Zig.
+/// Compile-time ANSI-tag expansion.
 macro_rules! fmt {
     ($s:literal) => {
         bun_core::Output::pretty_fmt!($s, true)
@@ -262,7 +258,7 @@ macro_rules! fmt {
 
 struct State<'a> {
     handles: Box<[ProcessHandle<'a>]>,
-    // Raw `*mut` (Zig: `*MiniEventLoop`) — `init_global` returns the
+    // Raw `*mut` — `init_global` returns the
     // thread-local singleton pointer; aliasing &mut would be UB.
     event_loop: *mut MiniEventLoop<'static>,
     /// Typed enum mirror of `event_loop` for the io-layer FilePoll vtable
@@ -273,9 +269,9 @@ struct State<'a> {
     draw_buf: Vec<u8>,
     last_lines_written: usize,
     pretty_output: bool,
-    shell_bin: &'static ZStr, // TODO(port): lifetime — leaked in Zig (findShell/selfExePath)
+    shell_bin: &'static ZStr, // intentionally leaked (process exits)
     aborted: bool,
-    // Raw `*mut` (Zig: `*bun.DotEnv.Loader`) — process-lifetime singleton owned
+    // Raw `*mut` — process-lifetime singleton owned
     // by Transpiler; ProcessHandle::start mutates `env.map` (PATH swap) so a
     // shared borrow won't do, and `&'a mut` would conflict with the Transpiler's
     // own raw-ptr field. Reborrow `&mut *env` at use sites.
@@ -297,7 +293,6 @@ impl<'a> State<'a> {
         handle: &mut ProcessHandle<'a>,
         chunk: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if self.pretty_output {
             handle.buffer.extend_from_slice(chunk);
             let _ = self.redraw(false);
@@ -343,7 +338,6 @@ impl<'a> State<'a> {
     }
 
     fn process_exit(&mut self, handle: &mut ProcessHandle<'a>) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.remaining_scripts -= 1;
         if !self.aborted {
             for &dependent in &handle.dependents {
@@ -448,7 +442,6 @@ impl<'a> State<'a> {
     }
 
     fn redraw(&mut self, is_abort: bool) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if !self.pretty_output {
             return Ok(());
         }
@@ -463,7 +456,7 @@ impl<'a> State<'a> {
                 self.draw_buf.extend_from_slice(b"\x1b[1A\x1b[K");
             }
         }
-        // PORT NOTE: reshaped for borrowck — iterating handles by index since draw_buf is also &mut self.
+        // Reshaped for borrowck — iterating handles by index since draw_buf is also &mut self.
         for idx in 0..self.handles.len() {
             let handle = &self.handles[idx];
             // normally we truncate the output to 10 lines, but on abort we print everything to aid debugging
@@ -620,8 +613,7 @@ impl<'a> State<'a> {
 struct AbortHandler;
 
 static SHOULD_ABORT: AtomicBool = AtomicBool::new(false);
-// PORT NOTE: Zig used a non-atomic `var should_abort = false` set from a signal handler;
-// Rust requires atomics for signal-handler-safe access.
+// Atomic because it is set from a signal handler.
 
 impl AbortHandler {
     #[cfg(unix)]
@@ -661,7 +653,6 @@ impl AbortHandler {
         }
         #[cfg(not(unix))]
         {
-            // TODO(port): move to <area>_sys
             let res = bun_sys::c::SetConsoleCtrlHandler(
                 Some(Self::windows_ctrl_handler),
                 bun_sys::windows::TRUE,
@@ -693,8 +684,8 @@ fn windows_is_terminal() -> bool {
 pub(crate) fn run_scripts_with_filter(
     ctx: Command::Context,
 ) -> Result<core::convert::Infallible, bun_core::Error> {
-    // TODO(port): Zig return type is `!noreturn`; using Result<Infallible, _> for `?` support.
-    // PORT NOTE: own the slice — `ctx` is reborrowed `&mut` for
+    // Never returns normally; Result<Infallible, _> keeps `?` support.
+    // Own the slice — `ctx` is reborrowed `&mut` for
     // `configure_env_for_run` below while `script_name` is still live.
     let script_name_owned: Box<[u8]> = if ctx.positionals.len() > 1 {
         ctx.positionals[1].clone()
@@ -719,7 +710,7 @@ pub(crate) fn run_scripts_with_filter(
     // these things are leaked because we are going to exit
     // When --workspaces is set, we want to match all workspace packages
     // Otherwise use the provided filters
-    // PORT NOTE: `FilterSet::init` takes `&[&[u8]]`; ctx.filters is
+    // `FilterSet::init` takes `&[&[u8]]`; ctx.filters is
     // `Vec<Box<[u8]>>` so build a borrowed-slice view.
     let filters_to_use: Vec<&[u8]> = if ctx.workspaces {
         // Use "*" as filter to match all packages in the workspace
@@ -742,8 +733,8 @@ pub(crate) fn run_scripts_with_filter(
         &mut root_buf,
     )?;
 
-    // TODO(refactor): out-param init — Zig used `var this_transpiler: Transpiler = undefined` and
-    // `configureEnvForRun` writes through it. Per PORTING.md this should be reshaped to
+    // TODO(refactor): out-param init — `configureEnvForRun` writes through the
+    // out-param. Per PORTING.md this should be reshaped to
     // `RunCommand::configure_env_for_run(...) -> Result<Transpiler, _>`; until then
     // pass `&mut MaybeUninit<Transpiler>` (zeroed() is invalid: Transpiler is not #[repr(C)] POD).
     let mut this_transpiler = core::mem::MaybeUninit::<bun_bundler::Transpiler<'static>>::uninit();
@@ -777,8 +768,6 @@ pub(crate) fn run_scripts_with_filter(
             bun_core::warn!("Failed to read package.json\n");
             continue;
         };
-        // TODO(port): PackageJSON::parse signature — enum args are placeholders.
-
         let Some(pkgscripts) = &pkgjson.scripts else {
             continue;
         };
@@ -832,8 +821,7 @@ pub(crate) fn run_scripts_with_filter(
             }
             copy_script.push(0);
 
-            // PORT NOTE: in Zig, `script_content` and `combined` both alias
-            // `copy_script.items`. Route through the process-lifetime CLI arena
+            // Route through the process-lifetime CLI arena
             // and derive the `ZStr` from the arena slice.
             let interned: &'static [u8] = crate::cli::cli_dupe(&copy_script);
             let combined_len = interned.len() - 1;
@@ -910,7 +898,6 @@ pub(crate) fn run_scripts_with_filter(
     };
 
     let handles: Box<[ProcessHandle]> = Vec::with_capacity(scripts.len()).into();
-    // PORT NOTE: reshaped for borrowck — Zig allocates uninit slice then writes each element.
     // We build into a Vec first, but need stable addresses for `&state` backref and `&mut handles[i]`
     // pointers stored in `map`. This is self-referential; raw pointers used below.
 
@@ -937,7 +924,7 @@ pub(crate) fn run_scripts_with_filter(
     };
 
     // initialize the handles
-    // PORT NOTE: self-referential — each `state.handles[i].state` points back at
+    // Self-referential — each `state.handles[i].state` points back at
     // `state`, and `map` stores `*mut ProcessHandle` into `state.handles`. Derive
     // the backref with mutable provenance (`addr_of_mut!`) so writes through it
     // in `ProcessHandle::start` / `State::process_exit` are sound under Stacked
@@ -979,7 +966,7 @@ pub(crate) fn run_scripts_with_filter(
                     ..Default::default()
                 },
                 stream: true,
-                ..Default::default() // TODO(port): SpawnOptions remaining fields
+                ..Default::default()
             },
             start_time: None,
             end_time: None,
@@ -1091,5 +1078,3 @@ fn has_cycle(current: &mut ProcessHandle) -> bool {
     current.visiting = false;
     false
 }
-
-// ported from: src/cli/filter_run.zig
diff --git a/src/runtime/cli/fuzzilli_command.rs b/src/runtime/cli/fuzzilli_command.rs
index 99c997d5891..218599d4ab6 100644
--- a/src/runtime/cli/fuzzilli_command.rs
+++ b/src/runtime/cli/fuzzilli_command.rs
@@ -16,8 +16,7 @@ pub(crate) struct FuzzilliCommand;
 impl FuzzilliCommand {
     #[cold]
     pub(crate) fn exec(_ctx: Command::Context) -> Result<(), bun_core::Error> {
-        // Zig: `if (bun.Environment.enable_fuzzilli) struct { … } else struct {}` —
-        // the dispatch site (`cli/mod.rs`) already gates on `ENABLE_FUZZILLI`, so
+        // The dispatch site (`cli/mod.rs`) already gates on `ENABLE_FUZZILLI`, so
         // this body is unreachable when the flag is off; bail loudly if a caller
         // ever invokes it anyway.
         if !Environment::ENABLE_FUZZILLI {
@@ -91,9 +90,8 @@ impl FuzzilliCommand {
 
             // Run the temp file
             let temp_path: &[u8] = b"/tmp/bun-fuzzilli-reprl.js";
-            // PORT NOTE: Zig calls `Run.boot` (src/bun_js.zig); the Rust port
-            // hosts that entry point on `RunCommand` to avoid the higher-tier
-            // crate cycle (see run_command.rs §`Run`).
+            // The `Run.boot` entry point is hosted on `RunCommand` to avoid the
+            // higher-tier crate cycle (see run_command.rs §`Run`).
             let result = RunCommand::boot(_ctx, temp_path.to_vec().into_boxed_slice(), None);
 
             // `defer fd.close()` — Fd is Copy and has no Drop; close explicitly.
@@ -106,11 +104,8 @@ impl FuzzilliCommand {
 
     #[cfg(unix)]
     fn verify_fd(fd: c_int) -> sys::Maybe<()> {
-        // Zig used `std.posix.fstat` directly; routed through `bun_sys` to
-        // preserve syscall-tagged error info.
+        // Routed through `bun_sys` to preserve syscall-tagged error info.
         let _stat = sys::fstat(Fd::from_native(fd))?;
         Ok(())
     }
 }
-
-// ported from: src/cli/fuzzilli_command.zig
diff --git a/src/runtime/cli/init_command.rs b/src/runtime/cli/init_command.rs
index b737c836b12..b9088b782c3 100644
--- a/src/runtime/cli/init_command.rs
+++ b/src/runtime/cli/init_command.rs
@@ -1,4 +1,5 @@
-//! Port of src/cli/init_command.zig
+//! `bun init`: scaffolds a new project in the current directory
+//! (package.json, tsconfig.json, entry file, README, .gitignore).
 
 use bun_ast::StoreRef;
 use bun_collections::IntegerBitSet;
@@ -14,10 +15,8 @@ use crate::cli as CLI;
 use bun_bundler::options;
 
 // ──────────────────────────────────────────────────────────────────────────
-// RadioChoice trait — replaces Zig's comptime enum reflection in
-// `processRadioButton`. In Zig the function takes `comptime Choices: type`
-// and uses `bun.meta.EnumFields(Choices)` + `@enumFromInt` + the `fmt()`
-// method; in Rust the choice enums implement this trait by hand.
+// RadioChoice trait — the choice enums used by `process_radio_button`
+// implement this trait by hand.
 // ──────────────────────────────────────────────────────────────────────────
 pub(crate) trait RadioChoice: Copy + Sized {
     const COUNT: usize;
@@ -30,11 +29,7 @@ pub(crate) trait RadioChoice: Copy + Sized {
 pub(crate) struct InitCommand;
 
 impl InitCommand {
-    pub(crate) fn prompt(
-        // TODO(port): narrow error set
-        label: &'static str,
-        default: &[u8],
-    ) -> Result<Vec<u8>, Error> {
+    pub(crate) fn prompt(label: &'static str, default: &[u8]) -> Result<Vec<u8>, Error> {
         #[allow(clippy::disallowed_methods)]
         // label is a runtime parameter that may contain <tag> markup
         Output::pretty(format_args!("{}", label));
@@ -60,8 +55,7 @@ impl InitCommand {
             let _ = input.pop();
         }
         if !input.is_empty() {
-            // Zig appends a NUL and returns the slice without it; callers that need
-            // a C string can push a NUL themselves.
+            // Callers that need a C string can push a NUL themselves.
             Ok(input)
         } else {
             input.clear();
@@ -72,8 +66,7 @@ impl InitCommand {
 
     fn process_radio_button<C: RadioChoice>(label: &[u8]) -> Result<C, Error> {
         let colors = Output::enable_ansi_colors_stdout();
-        // PERF(port): Zig builds `choices` at comptime via `bun.meta.EnumFields` +
-        // `Output.prettyFmt(e.fmt(), colors_comptime)`. We build it at runtime once.
+        // PERF: built at runtime once.
         let choices: Vec<Output::PrettyBuf> = (0..C::COUNT)
             .map(|i| {
                 let e = C::from_index(i);
@@ -102,13 +95,10 @@ impl InitCommand {
         let mut initial_draw = true;
         let mut reprint_menu = true;
 
-        // Zig: `std.fs.File.stdin().readerStreaming(&stdin_b)` then `takeByte()`.
         let mut stdin = bun_core::output::stdin_reader();
 
-        // The Zig has `errdefer reprint_menu = false;` followed by a `defer { ... }`
-        // that uses `reprint_menu`. We model both with a single guard whose state we
-        // mutate, and flip `reprint_menu = false` on the error paths before returning.
-        // PORT NOTE: reshaped for borrowck — can't both borrow `selected`/`initial_draw`
+        // `reprint_menu` is flipped to false on the error paths before returning.
+        // Shaped for borrowck — can't both borrow `selected`/`initial_draw`
         // in a scopeguard closure and mutate them in the loop. Instead inline the
         // cleanup at every return point.
         macro_rules! finish {
@@ -138,7 +128,6 @@ impl InitCommand {
             initial_draw = false;
 
             // Print options vertically
-            // PERF(port): was `inline for`.
             for (i, option) in choices.iter().enumerate() {
                 if i == selected.to_index() {
                     if colors {
@@ -182,9 +171,9 @@ impl InitCommand {
                 b'1'..=b'9' => {
                     let choice = (byte - b'1') as usize;
                     if choice < choices.len() {
-                        // PORT NOTE: Zig's `defer` reads `selected`, which is NOT updated
-                        // before `return @enumFromInt(choice)` — so Zig prints the previously
-                        // highlighted option, not the one just picked. Matching Zig verbatim.
+                        // `selected` is intentionally NOT updated before returning,
+                        // so the reprinted menu shows the previously highlighted
+                        // option, not the one just picked (long-standing behavior).
                         finish!(reprint_menu, selected);
                         return Ok(C::from_index(choice));
                     }
@@ -254,7 +243,7 @@ impl InitCommand {
         }
     }
 
-    /// `Choices` must implement `RadioChoice` (Zig: enum with `fmt` method).
+    /// `Choices` must implement `RadioChoice`.
     pub(crate) fn radio<C: RadioChoice>(label: &[u8]) -> Result<C, Error> {
         // Set raw mode to read single characters without echo
         #[cfg(windows)]
@@ -406,7 +395,7 @@ impl InitCommand {
             bun_sys::File::openat(destination_dir, b"package.json", bun_sys::O::RDWR, 0).ok();
         let mut package_json_contents: MutableString = MutableString::init_empty();
         bun_ast::initialize_store();
-        // Arena for JSON parse / Expr building (Zig used the AST store).
+        // Arena for JSON parse / Expr building.
         let bump = bun_alloc::Arena::new();
         'read_package_json: {
             if let Some(pkg) = package_json_file.as_ref() {
@@ -437,7 +426,6 @@ impl InitCommand {
 
                 package_json_contents =
                     MutableString::init(usize::try_from(size).expect("int cast"))?;
-                // Zig: list_mut().expand_to_capacity()
                 package_json_contents
                     .list
                     .resize(usize::try_from(size).expect("int cast"), 0);
@@ -538,14 +526,12 @@ impl InitCommand {
                 }
 
                 // Find any source file
-                // Zig: std.fs.cwd().openDir(".", .{ .iterate = true })
                 let Ok(dir) = bun_sys::open_dir_at(Fd::cwd(), b".") else {
                     break 'infer;
                 };
                 let _close = scopeguard::guard(dir, |d| {
                     let _ = bun_sys::close(d);
                 });
-                // Zig: bun.DirIterator.iterate(.fromStdDir(dir), .u8)
                 let mut it = bun_sys::iterate_dir(dir);
                 while let Some(file) = it.next().map_err(bun_core::Error::from)? {
                     if file.kind != bun_sys::FileKind::File {
@@ -618,7 +604,6 @@ impl InitCommand {
 
         match template {
             Template::ReactBlank | Template::ReactTailwind | Template::ReactTailwindShadcn => {
-                // PERF(port): Zig used `inline ... => |t|` to monomorphize per template.
                 template.write_files_and_run_bun_dev()?;
                 return Ok(());
             }
@@ -943,7 +928,6 @@ impl InitCommand {
 
                 if exists_z(b"package.json") && need_run_bun_install {
                     bun_core::prettyln!("");
-                    // Zig: std.process.Child .{stderr,stdin,stdout}=.Inherit → spawnAndWait
                     let self_exe = bun::self_exe_path()?;
                     let _ = bun::spawn_sync_inherit(&[self_exe.as_bytes(), b"install"])?;
                 }
@@ -971,8 +955,7 @@ impl Assets {
     /// Create a new asset file, overriding anything that already exists. Known
     /// assets will have their contents pre-populated; otherwise the file will be empty.
     ///
-    /// PORT NOTE: Zig looked up `asset_name` via `@hasDecl`/`@field` reflection.
-    /// Rust takes the asset bytes directly; `asset_name` is the filename.
+    /// Takes the asset bytes directly; `asset_name` is the filename.
     fn create(
         asset_name: &[u8],
         asset: &'static [u8],
@@ -991,7 +974,7 @@ impl Assets {
         Self::create_full_with_contents(asset_name, contents, "", is_template, args)
     }
 
-    /// Substitutes Zig-style named placeholders `{[key]s}` in `template` with the
+    /// Substitutes named placeholders `{[key]s}` in `template` with the
     /// corresponding value from `args`.
     fn substitute(template: &[u8], args: &[(&[u8], &[u8])]) -> Vec<u8> {
         let mut out = Vec::with_capacity(template.len());
@@ -1018,7 +1001,7 @@ impl Assets {
     }
 
     fn create_new(filename: &ZStr, contents: &[u8]) -> Result<(), Error> {
-        // Zig: bun.sys.File.makeOpen — creates parent dirs then opens.
+        // Create parent dirs then open.
         if let Some(dir) = bun_core::dirname(filename.as_bytes()) {
             if !dir.is_empty() && dir != b"." {
                 let _ = bun_sys::Dir::cwd().make_path(dir);
@@ -1039,7 +1022,7 @@ impl Assets {
     }
 
     fn create_full(
-        // content of known asset (Zig looked this up by name via `@field`)
+        // content of known asset
         asset: &'static [u8],
         // name of asset file to create
         filename: &[u8],
@@ -1142,7 +1125,7 @@ impl Default for PackageJSONFields {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Radio choice enums (anonymous in Zig, named here)
+// Radio choice enums
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -1231,8 +1214,7 @@ impl DependencyGroup {
         }],
     };
 
-    // PORT NOTE: Zig used comptime array concatenation (`++ blank.devDependencies[0..1].*`).
-    // Rust `const` cannot concat slices; the lists are hand-expanded below.
+    // `const` cannot concat slices; the lists are hand-expanded below.
     pub(crate) const REACT: DependencyGroup = DependencyGroup {
         dependencies: &[
             DependencyNeeded {
@@ -1420,8 +1402,7 @@ impl Template {
     ) -> Result<(), Error> {
         type Rope = bun_ast::E::Rope;
         fields.name = self.name().to_vec();
-        // PORT NOTE: Zig `alloc.create(Rope)` against the default allocator and
-        // never frees; allocate in the process-lifetime CLI arena instead.
+        // Allocate in the process-lifetime CLI arena.
         let key: &mut Rope = crate::cli::cli_arena().alloc(Rope {
             head: bun_ast::Expr::init(bun_ast::E::String::init(b"scripts"), bun_ast::Loc::EMPTY),
             next: core::ptr::null_mut(),
@@ -1625,11 +1606,9 @@ impl Template {
 
         #[cfg(windows)]
         {
-            // Zig: `bun.getenvZAnyCase("USER")` walks `std.os.environ` (bun.zig:913).
             if let Some(user) = bun_core::getenv_z_any_case(bun_core::zstr!("USER")) {
                 let mut pathbuf = path_buffer_pool::get();
-                // Zig: `std.fmt.bufPrintZ(..) catch { return false; }` —
-                // fallible on overflow, do not panic.
+                // Fallible on overflow, do not panic.
                 let path: &ZStr = {
                     use std::io::Write as _;
                     let total = pathbuf.len();
@@ -1680,8 +1659,6 @@ impl Template {
     pub(crate) fn write_files_and_run_bun_dev(self) -> Result<(), Error> {
         Self::create_agent_rule();
 
-        // PERF(port): Zig used `inline for (comptime this.files())` to unroll per
-        // template; we iterate the runtime slice.
         for file in self.files() {
             let path = file.path;
             let contents = file.contents;
@@ -1725,11 +1702,8 @@ impl Template {
         bun_core::pretty!("\n");
         Output::flush();
 
-        // Zig: std.process.Child stdin=.Ignore stdout/stderr=.Inherit → spawnAndWait
-        // TODO(port): spawn_sync_inherit inherits stdin too; full bun.spawnSync
-        // (with Ignore stdin) lives in bun_runtime::api::process::sync.
         let self_exe = bun::self_exe_path()?;
-        let _ = bun::spawn_sync_inherit(&[self_exe.as_bytes(), b"install"])?;
+        let _ = bun::spawn_sync_inherit_no_stdin(&[self_exe.as_bytes(), b"install"])?;
 
         bun_core::prettyln!(
             "\n\
@@ -1756,8 +1730,7 @@ impl Template {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Template file lists (Zig: nested `ReactBlank`/`ReactTailwind`/`ReactShadcn`
-// structs containing `files` consts)
+// Template file lists
 // ──────────────────────────────────────────────────────────────────────────
 
 static REACT_BLANK_FILES: &[TemplateFile] = &[
@@ -1961,7 +1934,7 @@ static REACT_SHADCN_FILES: &[TemplateFile] = &[
 ];
 
 // ──────────────────────────────────────────────────────────────────────────
-// Helpers (Zig: `const exists = bun.sys.exists; const existsZ = bun.sys.existsZ;`)
+// Helpers
 // ──────────────────────────────────────────────────────────────────────────
 
 #[inline]
@@ -1983,5 +1956,3 @@ fn is_safe_entry_point_path(path: &[u8]) -> bool {
 fn exists_z(path: &[u8]) -> bool {
     bun_sys::exists(path)
 }
-
-// ported from: src/cli/init_command.zig
diff --git a/src/runtime/cli/install_command.rs b/src/runtime/cli/install_command.rs
index b51dd86bd4b..8a3fdc9b5c3 100644
--- a/src/runtime/cli/install_command.rs
+++ b/src/runtime/cli/install_command.rs
@@ -25,7 +25,6 @@ impl InstallCommand {
     #[cold]
     #[inline(never)]
     fn handle_error(e: Error) -> Result<(), Error> {
-        // TODO(port): narrow error set
         if e == err!("InstallFailed") || e == err!("InvalidPackageJSON") {
             // SAFETY: `Cli::LOG_` is initialised once during single-threaded
             // startup in `Cli::start()` before any command (including this
@@ -45,7 +44,6 @@ impl InstallCommand {
 // the ~84 MB binary and get faulted in one page at a time.
 #[inline(never)]
 fn install(ctx: &mut ContextData) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let mut cli = CommandLineArguments::parse(Subcommand::Install)?;
 
     // The way this works:
@@ -54,11 +52,9 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
     //    typing in the dependency names
     // 3. Run the install command
     if cli.analyze {
-        // PORT NOTE: hoisted from Zig fn-local `const Analyzer = struct {...}`.
-        // `ctx` is stored as a raw `*mut ContextData` (Zig `Command.Context` is
-        // `*ContextData` — a freely-aliasing pointer); the `on_fetch` callback
+        // `ctx` is stored as a raw `*mut ContextData`; the `on_fetch` callback
         // re-enters the install path while `BuildCommand::exec` still holds the
-        // global `Context`, so a Rust `&mut` here would be aliased UB.
+        // global `Context`, so a `&mut` here would be aliased UB.
         struct Analyzer {
             ctx: *mut ContextData,
             cli: *mut CommandLineArguments,
@@ -71,9 +67,8 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
                 let this = self;
                 // TODO: add separate argument that makes it so positionals[1..] is not done     and instead the positionals are passed
                 //
-                // Process-lifetime storage for the rewritten positionals.
-                // Zig: `bun.default_allocator.alloc(string, keys.len + 1)` with
-                // no matching free — `Global::exit(0)` follows immediately.
+                // Process-lifetime storage for the rewritten positionals —
+                // `Global::exit(0)` follows immediately.
                 // `OnceLock` (not leaking) per PORTING.md §Forbidden.
                 static OWNED_KEYS: std::sync::OnceLock<Vec<Box<[u8]>>> = std::sync::OnceLock::new();
                 static POSITIONALS: std::sync::OnceLock<Vec<&'static [u8]>> =
@@ -114,9 +109,9 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
             }
         }
 
-        // PORT NOTE: `DependenciesScanner.entry_points` is `Box<[Box<[u8]>]>`; Zig
-        // borrowed `cli.positionals[1..]` directly. Clone the argv slices into an
-        // owned buffer (small one-shot list — no perf concern). Captured *before*
+        // `DependenciesScanner.entry_points` is `Box<[Box<[u8]>]>`. Clone the
+        // argv slices into an owned buffer (small one-shot list — no perf
+        // concern). Captured *before*
         // raw-ptr aliasing of `cli` below so the access goes through the live
         // `&mut cli` borrow.
         let entry_points: Box<[Box<[u8]>]> = cli.positionals[1..]
@@ -125,8 +120,7 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
             .collect();
 
         // Derive raw pointers from the existing `&mut` borrows; all subsequent
-        // access to `ctx` / `cli` in this branch goes through these (Zig
-        // `Command.Context` is a freely-aliasing `*ContextData`).
+        // access to `ctx` / `cli` in this branch goes through these.
         let ctx_ptr: *mut ContextData = ctx;
         let mut analyzer = Analyzer {
             ctx: ctx_ptr,
@@ -135,7 +129,6 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
 
         let fetcher = DependenciesScanner::new(&mut analyzer, entry_points);
 
-        // Zig: `bun.cli.BuildCommand.exec(bun.cli.Command.get(), &fetcher)`.
         // `Command.get()` resolves to the same `*ContextData` already held in
         // `ctx`; reborrow through `ctx_ptr` rather than minting a fresh
         // `&'static mut` from the global static (which would alias the
@@ -151,7 +144,6 @@ fn install(ctx: &mut ContextData) -> Result<(), Error> {
 
 #[inline(never)]
 fn install_with_cli(ctx: &mut ContextData, cli: CommandLineArguments) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let subcommand: Subcommand = if cli.positionals.len() > 1 {
         Subcommand::Add
     } else {
@@ -194,5 +186,3 @@ fn install_with_cli(ctx: &mut ContextData, cli: CommandLineArguments) -> Result<
 
     Ok(())
 }
-
-// ported from: src/cli/install_command.zig
diff --git a/src/runtime/cli/install_completions_command.rs b/src/runtime/cli/install_completions_command.rs
index 0316374fea4..7148d2e4dbd 100644
--- a/src/runtime/cli/install_completions_command.rs
+++ b/src/runtime/cli/install_completions_command.rs
@@ -8,18 +8,13 @@ use bun_paths::PathBuffer;
 use bun_paths::WPathBuffer;
 #[cfg(not(windows))]
 use bun_paths::{platform, resolve_path};
-use bun_sys::{self, Dir, E, File};
+use bun_sys::{self, E, File};
 
 use crate::shell_completions::{Shell, ShellCompletionsExt as _};
 
 pub struct InstallCompletionsCommand;
 
 impl InstallCompletionsCommand {
-    pub fn test_path(_: &[u8]) -> Result<Dir, bun_core::Error> {
-        // TODO(port): Zig body is empty (`pub fn testPath(_: string) !std.fs.Dir {}`)
-        unreachable!()
-    }
-
     #[cfg(not(windows))]
     const BUNX_NAME: &'static str = if cfg!(debug_assertions) {
         "bunx-debug"
@@ -159,10 +154,7 @@ impl InstallCompletionsCommand {
             )?;
             // SAFETY: exe_suffix_z ends in NUL
             let bunx_cmd = WStr::from_slice_with_nul(&bunx_cmd_with_z[..]);
-            // TODO: fix this zig bug, it is one line change to a few functions.
-            // const file = try std.fs.createFileAbsoluteW(bunx_cmd, .{});
             let file = File::create_w(bun_sys::Fd::cwd(), bunx_cmd.as_slice())?;
-            // zig: `defer file.close()`
             file.write_all(SCRIPT)?;
         }
         Ok(())
@@ -212,13 +204,11 @@ impl InstallCompletionsCommand {
         )?;
 
         let file = File::create_w(bun_sys::Fd::cwd(), uninstaller_path)?;
-        // zig: `defer file.close()`
         file.write_all(CONTENT)?;
         Ok(())
     }
 
     pub fn exec() -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Fail silently on auto-update.
         let fail_exit_code: u32 = if !env_var::IS_BUN_AUTO_UPDATE.get().unwrap_or(false) {
             1
@@ -232,7 +222,6 @@ impl InstallCompletionsCommand {
 
         let mut shell = Shell::Unknown;
         if let Some(shell_name) = env_var::SHELL.platform_get() {
-            // TODO(port): Shell.fromEnv(@TypeOf(shell_name), shell_name) — generic over u8/u16
             shell = Shell::from_env(shell_name);
         }
 
@@ -543,7 +532,6 @@ impl InstallCompletionsCommand {
 
             debug_assert!(!completions_dir.is_empty());
 
-            // output_dir.createFileZ(filename, .{ .truncate = true })
             let output_file: File = match File::create(output_dir, filename, true) {
                 Ok(f) => f,
                 Err(err) => {
@@ -728,5 +716,3 @@ impl InstallCompletionsCommand {
 
 #[cfg(not(windows))]
 use bun_core::fmt::{buf_print_infallible as buf_print, buf_print_z_infallible as buf_print_z};
-
-// ported from: src/cli/install_completions_command.zig
diff --git a/src/runtime/cli/link_command.rs b/src/runtime/cli/link_command.rs
index 2eda5889e75..51ad95c8e69 100644
--- a/src/runtime/cli/link_command.rs
+++ b/src/runtime/cli/link_command.rs
@@ -32,8 +32,7 @@ fn link(ctx: command::Context) -> Result<(), bun_core::Error> {
         Err(e) if e == err!(MissingPackageJSON) => {
             attempt_to_create_package_json()?;
             // Re-parse argv: `CommandLineArguments` is not `Clone`, and `parse`
-            // is deterministic over process argv. Mirrors Zig passing the
-            // by-value `cli` struct to both `init` calls.
+            // is deterministic over process argv.
             let cli = CommandLineArguments::parse(Subcommand::Link)?;
             pm::init(&mut *ctx, cli, Subcommand::Link)?
         }
@@ -108,7 +107,7 @@ fn link(ctx: command::Context) -> Result<(), bun_core::Error> {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — re-derive `name` here so its
+        // Reshaped for borrowck — re-derive `name` here so its
         // lifetime is tied only to `lockfile.buffers.string_bytes`, decoupled
         // from `package_json_source` (dropped above).
         let name = lockfile.str(&package.name);
@@ -202,7 +201,7 @@ fn link(ctx: command::Context) -> Result<(), bun_core::Error> {
                 if let Err(e) = node_modules.sym_link(
                     FileSystem::instance().top_level_dir_without_trailing_slash(),
                     name,
-                    // Zig: `.{ .is_directory = true }` — std.fs.Dir.SymLinkFlags.
+                    // is_directory
                     true,
                 ) {
                     if manager.options.log_level != LogLevel::Silent {
@@ -222,11 +221,9 @@ fn link(ctx: command::Context) -> Result<(), bun_core::Error> {
             let mut link_dest_buf = PathBuffer::uninit();
             let mut link_rel_buf = PathBuffer::uninit();
 
-            // PORT NOTE: Zig passed `&node_modules_path` for both
-            // `target_node_modules_path` (`*const`) and `node_modules_path`
-            // (`*mut`). Rust forbids `&` + `&mut` to the same value, so resolve
-            // the fd path twice (cheap: one `getFdPath` syscall) into two
-            // independent `AbsPath` buffers.
+            // `target_node_modules_path` (`&`) and `node_modules_path` (`&mut`)
+            // cannot alias the same value, so resolve the fd path twice (cheap:
+            // one `getFdPath` syscall) into two independent `AbsPath` buffers.
             let mut node_modules_path =
                 match <AbsPath>::init_fd_path(Fd::from_std_dir(&node_modules)) {
                     Ok(p) => p,
@@ -310,5 +307,3 @@ fn link(ctx: command::Context) -> Result<(), bun_core::Error> {
 
     Ok(())
 }
-
-// ported from: src/cli/link_command.zig
diff --git a/src/runtime/cli/list-of-yarn-commands.rs b/src/runtime/cli/list-of-yarn-commands.rs
index c28fb33e910..3fd77480e4a 100644
--- a/src/runtime/cli/list-of-yarn-commands.rs
+++ b/src/runtime/cli/list-of-yarn-commands.rs
@@ -1,6 +1,5 @@
-// ComptimeStringMap silently dedups. The v1 list repeats several v2.3 entries
-// verbatim — duplicates dropped here (commented inline) so the macro compiles
-// while keeping .zig↔.rs diffability.
+// The v1 list repeats several v2.3 entries verbatim — duplicates dropped here
+// (commented inline) so the phf macro compiles.
 pub static ALL_YARN_COMMANDS: phf::Set<&'static [u8]> = phf::phf_set! {
     // yarn v2.3 commands
     b"add",
@@ -75,5 +74,3 @@ pub static ALL_YARN_COMMANDS: phf::Set<&'static [u8]> = phf::phf_set! {
     // b"workspace",
     // b"workspaces",
 };
-
-// ported from: src/cli/list-of-yarn-commands.zig
diff --git a/src/runtime/cli/mod.rs b/src/runtime/cli/mod.rs
index 0a4a81e3737..25af3f71c10 100644
--- a/src/runtime/cli/mod.rs
+++ b/src/runtime/cli/mod.rs
@@ -1,4 +1,4 @@
-//! Port of src/runtime/cli/cli.zig — CLI entry point + command dispatch.
+//! CLI entry point + command dispatch.
 //!
 //! `Command::which()` + `HelpCommand` + `print_version_and_exit` compile
 //! against lower-tier crates. `Command::start()` (full dispatch) and
@@ -13,11 +13,9 @@ use bun_core::{pretty, pretty_error, pretty_errorln};
 // ─── compiling submodules ────────────────────────────────────────────────────
 #[path = "ci_info.rs"]
 pub mod ci_info;
-/// Port of the build.zig-registered `@import("ci_info")` module (output of
-/// `src/codegen/ci_info.ts`). The Zig build emits `build/*/codegen/ci_info.zig`
-/// from a static vendor table copied from watson/ci-info@4.0.0; since the Rust
-/// build has no codegen hook for this yet, the table is hand-ported here from
-/// that generated file. Keep in sync with `src/codegen/ci_info.ts`.
+/// CI-provider detection table, copied from watson/ci-info@4.0.0; since the
+/// Rust build has no codegen hook for this yet, the table is maintained by
+/// hand. Keep in sync with `src/codegen/ci_info.ts`.
 pub(crate) mod ci_info_generated {
     use bun_core::{getenv_z, zstr};
 
@@ -225,12 +223,7 @@ pub mod shell_completions;
 #[path = "which_npm_client.rs"]
 pub mod which_npm_client;
 
-// ─── open (minimal open_url; full Editor/EditorContext stays gated) ──────────
-// TODO(port): full `open.rs` (Editor detection/spawn) needs
-// `crate::process::spawn_sync`, `bun_threading::spawn_detached`,
-// `bun_resolver::fs::FileSystem` — none of which are wired on this path yet.
-// `bun discord` only needs `open_url`, so provide a thin print-fallback impl
-// here until the heavy half compiles.
+// ─── open (open_url wrapper; Editor/EditorContext live in open.rs) ───────────
 #[path = "open.rs"]
 mod open_full;
 pub mod open {
@@ -249,24 +242,24 @@ pub mod open {
         Output::flush();
     }
 
-    /// Minimal port of `open.openURL`. The Zig version spawns `OPENER url` and
-    /// only falls back to printing on spawn failure; that path needs
-    /// `bun.spawnSync` (gated). Until then, always take the fallback so
-    /// `bun discord` is usable in headless/CI environments.
+    /// Spawn `OPENER url` with inherited stdio and fall back to printing the
+    /// URL when the spawn fails or the opener exits non-zero (e.g. headless/CI
+    /// environments).
     pub(crate) fn open_url(url: &[u8]) {
-        // TODO(port): wire `bun.spawnSync({ argv: [OPENER, url] })` once the
-        // non-JSC spawn path is un-gated, then only fallback() on error.
-        let _ = OPENER;
-        fallback(url);
+        match bun_core::spawn_sync_inherit(&[OPENER, url]) {
+            Ok(status) if status.is_ok() => {}
+            _ => fallback(url),
+        }
     }
 }
 
-// ─── non-JSC subcommand bodies (heavy; re-gated inside or here) ──────────────
+// ─── non-JSC subcommand bodies ───────────────────────────────────────────────
 // `init_command.rs` pulls bun_json/bun_js_parser/bun_js_printer/bun_bundler +
-// `bun_ast::initialize_store`; `install_completions_command.rs`
-// and `package_manager_command.rs` need bun_install::PackageManager + a real
-// `Command::Context` (blocked on `create_context_data`). Help/print-only paths
-// are handled inline in `Command::start()` below; full bodies stay gated.
+// `bun_ast::initialize_store`; `package_manager_command.rs` needs
+// bun_install::PackageManager + a real `Command::Context` (blocked on
+// `create_context_data`), so its help/print-only paths are handled inline in
+// `Command::start()` below. `install_completions_command.rs` is fully wired
+// via `exec_install_completions` (its `exec()` takes no Context).
 #[path = "init_command.rs"]
 pub mod init_command;
 #[path = "install_completions_command.rs"]
@@ -286,7 +279,7 @@ pub mod test {
     pub use scanner::Scanner;
 
     /// `bun test --changed`: git-diff → bundler module graph → reverse-import
-    /// walk to filter test files. See `test/ChangedFilesFilter.zig`.
+    /// walk to filter test files.
     #[path = "ChangedFilesFilter.rs"]
     pub mod changed_files_filter;
     pub use changed_files_filter as ChangedFilesFilter;
@@ -298,7 +291,7 @@ pub mod test {
     pub use parallel_runner as ParallelRunner;
 
     /// `test/parallel/` submodule directory (no `mod.rs` on disk; declared
-    /// inline so paths stay 1:1 with the Zig directory). `ParallelRunner.rs`
+    /// inline). `ParallelRunner.rs`
     /// re-exports the public entry points from `runner`; the rest are
     /// implementation detail of the coordinator/worker split.
     pub mod parallel {
@@ -329,7 +322,7 @@ pub use bun_bunfig::bunfig;
 pub mod run_command;
 
 // ─── per-subcommand bodies (un-gated for `Command::start` dispatch) ──────────
-// Each maps 1:1 to a `*_command.zig`. Heavy bodies inside re-gate on whatever
+// Heavy bodies inside re-gate on whatever
 // lower-tier crate surface they still need; the dispatch arm just calls
 // `<Mod>Command::exec(ctx)`.
 #[path = "build_command.rs"]
@@ -400,13 +393,13 @@ pub use multi_run as MultiRun;
 
 // ─── crate-local helper for param-table concatenation ────────────────────────
 // `bun_clap::parse_param!` is a real proc-macro (const `Param<Help>` literal),
-// and `bun_clap::concat_params!` is a const-fn slice concat (Zig comptime `++`),
+// and `bun_clap::concat_params!` is a const-fn slice concat,
 // so combined tables (`AUTO_PARAMS`, `RUN_PARAMS`, …) are baked into rodata —
 // no `LazyLock`, no init closure in `.text`, no startup heap allocation.
 pub use ::bun_clap::concat_params;
 
 // ─── process-lifetime globals ────────────────────────────────────────────────
-/// Zig `var start_time: i128 = undefined;` — written once in `Cli::start`
+/// Written once in `Cli::start`
 /// during single-threaded startup, read freely after init. The backing
 /// `OnceLock` lives in `bun_core` (single source of truth); this accessor
 /// remains so existing `crate::cli::start_time()` callers don't churn.
@@ -416,10 +409,9 @@ pub(crate) fn start_time() -> i128 {
 }
 
 #[allow(non_upper_case_globals)]
-// PORT NOTE: Zig `?string` (borrowed slice) → owned `Box<[u8]>` so
+// Owned `Box<[u8]>` so
 // `process.title = "..."` (set_title) drops the previous value instead of
-// leaking. The mutex provides exclusion between `get_title`/`set_title`
-// (Zig: `var title_mutex = bun.Mutex{}`).
+// leaking. The mutex provides exclusion between `get_title`/`set_title`.
 pub(crate) static Bun__Node__ProcessTitle: bun_threading::Guarded<Option<Box<[u8]>>> =
     bun_threading::Guarded::new(None);
 
@@ -434,14 +426,12 @@ pub(crate) static Bun__Node__ProcessTitle: bun_threading::Guarded<Option<Box<[u8
 /// pathology documented for `OnceLock::set` on [`CMD`]). `cli_arena()` is on the
 /// hot `bun <file>` / `bun run <script>` path (via `cli_dupe` / `cli_dupe_z` /
 /// `runner_arena`), so a `LazyLock` there faults a fresh cold page on every
-/// `bun` invocation. Zig's analogue was just a `default_allocator` handle / a
-/// never-`deinit`'d `ArenaAllocator` — a plain cell is the correct shape.
+/// `bun` invocation; a plain cell is the correct shape.
 pub(crate) static CLI_ARENA: bun_core::RacyCell<core::mem::MaybeUninit<bun_alloc::Arena>> =
     bun_core::RacyCell::new(core::mem::MaybeUninit::uninit());
 
-/// Process-lifetime arena for one-shot CLI commands. Zig passed
-/// `bun.default_allocator` (or a per-command `ArenaAllocator` never `deinit`'d)
-/// and let allocations live until exit.
+/// Process-lifetime arena for one-shot CLI commands; allocations live until
+/// exit.
 ///
 /// **Main-thread only.** `MimallocArena`'s `Sync` impl is *contract-only*:
 /// `mi_heap_*` allocation calls are thread-local, and
@@ -459,8 +449,7 @@ pub(crate) fn cli_arena() -> &'static bun_alloc::Arena {
 }
 
 /// Dupe `s` into the process-lifetime CLI arena. Replaces ad-hoc
-/// `s.to_vec().into_boxed_slice()` leaks at CLI sites where Zig used
-/// `allocator.dupe(u8, s)` with the default allocator. Main-thread only
+/// `s.to_vec().into_boxed_slice()` leaks at CLI sites. Main-thread only
 /// (see [`cli_arena`]).
 #[inline]
 pub(crate) fn cli_dupe(s: &[u8]) -> &'static [u8] {
@@ -504,7 +493,7 @@ thread_local! {
 /// `RacyCell`, not `OnceLock`: `OnceLock::set` routes through stdlib's
 /// `#[cold] fn initialize`, which fat-LTO places ~36 MB away from the
 /// startup.order cluster and faults a fresh page on every `bun` invocation.
-/// Zig used a plain `var cmd: ?Tag` here; the write happens before any
+/// The write happens before any
 /// thread is spawned, so a bare cell is the correct shape.
 pub(crate) static CMD: bun_core::RacyCell<Option<command::Tag>> = bun_core::RacyCell::new(None);
 
@@ -550,7 +539,7 @@ pub mod cli {
 
     pub use bun_options_types::compile_target::CompileTarget;
 
-    // Zig `var log_: logger.Log = undefined;` — process-global, init in start().
+    // Process-global, init in start().
     pub(crate) static LOG_: bun_core::RacyCell<core::mem::MaybeUninit<bun_ast::Log>> =
         bun_core::RacyCell::new(core::mem::MaybeUninit::uninit());
 
@@ -582,11 +571,11 @@ pub mod cli {
         // SAFETY: single-threaded process startup; `mimalloc` is already init.
         unsafe { (*super::CLI_ARENA.get()).write(bun_alloc::Arena::new()) };
 
-        // TODO(port): MainPanicHandler wiring.
+        // (The panic hook is installed by `bun_crash_handler::init()` in bun_bin.)
         // SAFETY: just initialized above; single-threaded for the lifetime of `log`.
         let log = unsafe { (*LOG_.get()).assume_init_mut() };
         if let Err(err) = Command::start(log) {
-            // Spec cli.zig:21 — print accumulated diagnostics BEFORE the
+            // Print accumulated diagnostics BEFORE the
             // generic `handle_root_error` "An internal error occurred (..)"
             // message. The bake production path returns `error.BuildFailed`
             // with the actual parse/link errors sitting in `ctx.log` (== this
@@ -602,8 +591,7 @@ pub use cli as Cli;
 
 // ─── debug_flags (resolve/print breakpoints) ─────────────────────────────────
 pub mod debug_flags {
-    // SHOW_CRASH_TRACE-only in Zig; harmless to always declare here.
-    // PORT NOTE: `Vec<&'static [u8]>` (not `&'static [&[u8]]`) so `parse()` can
+    // `Vec<&'static [u8]>` (not `&'static [&[u8]]`) so `parse()` can
     // hand off ownership of the argv-borrowed list without leaking the backing
     // storage. Each `&'static [u8]` element is a process-lifetime argv slice.
     pub(crate) static RESOLVE_BREAKPOINTS: std::sync::OnceLock<Vec<&'static [u8]>> =
@@ -659,9 +647,7 @@ pub mod help_command {
     pub(crate) const PACKAGES_TO_CREATE_FILLER: &[&str] =
         &["next-app", "vite", "astro", "svelte", "elysia"];
 
-    /// `cli_helptext_fmt` from cli.zig.
-    ///
-    /// PORT NOTE: emits the `pretty!`/`pretty_error!` call directly instead of
+    /// Emits the `pretty!`/`pretty_error!` call directly instead of
     /// expanding to a bare literal — `pretty!` captures its template as
     /// `$fmt:expr`, which is opaque to the `pretty_fmt!` proc-macro, so a
     /// nested `cli_helptext_fmt!()` inside `concat!()` would never be flattened.
@@ -712,14 +698,13 @@ pub mod help_command {
         };
     }
 
-    // PORT NOTE: Zig had `comptime reason: Reason` → const generic. Tag/Reason
-    // lack `ConstParamTy` in lower-tier crates, so demoted to a runtime arg.
-    // PERF(port): was comptime monomorphization — profile if hot.
+    // Tag/Reason lack `ConstParamTy` in lower-tier crates, so `reason` is a
+    // runtime arg.
     pub fn print_with_reason(reason: Reason, show_all_flags: bool) {
         let mut rand = bun_core::rand::DefaultPrng::init(
             u64::try_from(bun_core::time::milli_timestamp().max(0)).expect("int cast"),
         );
-        // Zig: rand.uintAtMost(len-1). xoshiro256++ next_u64() % len is close
+        // xoshiro256++ next_u64() % len is close
         // enough for filler-word selection (no rejection sampling needed here).
         let mut pick = |n: usize| (rand.next_u64() as usize) % n;
 
@@ -728,7 +713,7 @@ pub mod help_command {
         let package_remove_i = pick(PACKAGES_TO_REMOVE_FILLER.len());
         let package_create_i = pick(PACKAGES_TO_CREATE_FILLER.len());
 
-        // PORT NOTE: filler tables are `&str` (not `&[u8]`) so the `{:<16}`
+        // The filler tables are `&str` (not `&[u8]`) so the `{:<16}`
         // width spec actually pads — `Display for BStr` writes raw bytes and
         // ignores formatter width/alignment.
         let args = (
@@ -816,12 +801,12 @@ pub use reserved_command as ReservedCommand;
 // ─── Command (Tag + which() + dispatch skeleton) ─────────────────────────────
 pub mod command {
     use super::*;
-    // Self-referential alias so `crate::command::Command` resolves (Zig: `pub const Command = struct {…}`).
+    // Self-referential alias so `crate::command::Command` resolves.
     pub use super::Command;
 
     /// Collect `bun::argv()` into an indexable slice of `&'static ZStr`.
-    /// `Argv` only exposes `.get(i)` / `.iter() -> &[u8]`; several Zig call
-    /// sites (`bun.argv[n..]`) need a sliceable `&[&ZStr]`.
+    /// `Argv` only exposes `.get(i)` / `.iter() -> &[u8]`; several call
+    /// sites need a sliceable `&[&ZStr]`.
     #[inline]
     pub(super) fn argv_zslice() -> Vec<&'static bun_core::ZStr> {
         let a = bun::argv();
@@ -836,14 +821,14 @@ pub mod command {
         Context, ContextData, DebugOptions, HotReload, RuntimeOptions, TestOptions,
     };
 
-    // Zig: `var context_data: ContextData = undefined;` — process-lifetime
+    // Process-lifetime
     // storage, written exactly once in `create_context_data` during
     // single-threaded startup. The pointer to it is published via
     // `bun_options_types::context::set_global` (single source of truth).
     static CONTEXT_DATA: bun_core::RacyCell<core::mem::MaybeUninit<ContextData>> =
         bun_core::RacyCell::new(core::mem::MaybeUninit::uninit());
 
-    /// Zig: `pub fn get() Context` — process-global CLI context handle.
+    /// Process-global CLI context handle.
     #[inline]
     pub fn get() -> Context<'static> {
         // SAFETY: only called after `create_context_data` published the ctx
@@ -855,7 +840,7 @@ pub mod command {
     // Canonical home: src/runtime/cli/mod.rs, inside `pub mod command { ... }`
     // (crate path `bun_runtime::cli::command::{is_bun_x, is_node, which}`).
     //
-    // PORT NOTE (cli.zig:411): the `is_node` branch of `which()` must clear
+    // The `is_node` branch of `which()` must clear
     // `bun_clap::streaming::WARN_ON_UNRECOGNIZED_FLAG` so node-mode argv parsing
     // stays silent on unknown flags.
     // ──────────────────
@@ -969,7 +954,7 @@ pub mod command {
         }
 
         if is_node(argv0) {
-            // Zig cli.zig:411 — node-mode must not warn on flags Bun doesn't know.
+            // Node-mode must not warn on flags Bun doesn't know.
             bun_clap::streaming::WARN_ON_UNRECOGNIZED_FLAG
                 .store(false, core::sync::atomic::Ordering::Relaxed);
             // SAFETY: single-threaded startup
@@ -992,9 +977,8 @@ pub mod command {
 
         type RootCommandMatcher = strings::ExactSizeMatcher<12>;
         let x = RootCommandMatcher::r#match(first_arg_name);
-        // PERF(port): Zig's `switch` over RootCommandMatcher cases compiles to a
-        // jump table on the packed u96; Rust `if x == const` is a chain of
-        // compares — profile if it shows up on a hot path.
+        // PERF: `if x == const` is a chain of compares rather than a jump
+        // table on the packed u96 — profile if it shows up on a hot path.
         if x == RootCommandMatcher::case(b"init") {
             return Tag::InitCommand;
         }
@@ -1117,8 +1101,7 @@ pub mod command {
 
     /// Initialize the process-global `CONTEXT_DATA` and publish it via
     /// `Context::set_global`. Shared by `create_context_data` and the
-    /// standalone-graph fast path in `start()` (Zig: the bare
-    /// `context_data = .{...}; global_cli_ctx = &context_data;` sequence).
+    /// standalone-graph fast path in `start()`.
     fn write_context_no_parse(log: &mut bun_ast::Log) -> &'static mut ContextData {
         // SAFETY: single-threaded CLI startup; first and only write to
         // `CONTEXT_DATA` for the process lifetime. `log` is the `&'static mut`
@@ -1140,14 +1123,12 @@ pub mod command {
 
     /// `ContextData.create` — populates the global ctx and runs `Arguments::parse`.
     ///
-    /// PORT NOTE: Zig had `comptime command: Tag` → const generic. `Tag` lacks
-    /// `ConstParamTy` (lower-tier crate), so demoted to a runtime arg; the only
-    /// comptime-dependent bit was `Tag.uses_global_options.get(command)`, which
-    /// the runtime `USES_GLOBAL_OPTIONS` set covers.
+    /// `Tag` lacks `ConstParamTy` (lower-tier crate), so `cmd` is a runtime
+    /// arg; the runtime `USES_GLOBAL_OPTIONS` set covers per-command gating.
     /// Returns `&'static mut` to the process-global `CONTEXT_DATA`. Sound
     /// because CLI dispatch is single-threaded and this is the sole live
     /// borrow at the time of return; callers thread it down via the `ctx`
-    /// parameter rather than re-deriving (Zig: `Context = *ContextData`).
+    /// parameter rather than re-deriving.
     ///
     /// `#[inline(never)]`: this is the `init` step of the `bun run <script>`
     /// dispatch chain (`exec_auto_or_run → init → RunCommand::exec_with_cfg`)
@@ -1173,9 +1154,6 @@ pub mod command {
         #[cfg(windows)]
         {
             if ctx.debug.hot_reload == HotReload::Watch {
-                // TODO(port): bun_sys::windows::is_watcher_child /
-                // become_watcher_manager — Windows watcher hand-off path.
-
                 {
                     if !bun_sys::windows::is_watcher_child() {
                         bun_sys::windows::become_watcher_manager();
@@ -1210,11 +1188,10 @@ pub mod command {
         // WebView host subprocess entry. Must be before StandaloneModuleGraph,
         // before JSC init, before anything that touches a JS engine. The child
         // runs CFRunLoopRun() as its real main loop — no Bun runtime past this.
-        // Spec: cli.zig:543.
         #[cfg(target_os = "macos")]
         {
             if let Some(fd_str) = bun_core::env_var::BUN_INTERNAL_WEBVIEW_HOST::get() {
-                // Zig: `std.fmt.parseInt(u31, fd_str, 10)` — parse base-10 directly
+                // Parse base-10 directly
                 // from bytes; env var values are `&[u8]`, not assumed UTF-8.
                 let fd: u32 = match bun_core::parse_int::<u32>(fd_str, 10).ok() {
                     Some(v) if v <= i32::MAX as u32 => v,
@@ -1265,9 +1242,8 @@ pub mod command {
         //  * the version check is exact-argv-shape (`len == 2`) so it cannot
         //    intercept `bun <bin> --version`, where the flag belongs to
         //    `<bin>` (the bug the old argv-scan shim had — see the
-        //    NOTE below). The empty-eval check is likewise exact-shape, so it
-        //    matches Zig's post-parse `eval.script.len == 0 &&
-        //    positionals.len == 0` fall-through to `HelpCommand.exec`.
+        //    NOTE below). The empty-eval check is likewise exact-shape, falling
+        //    through to `HelpCommand.exec`.
         {
             let argv = bun::argv();
             let argv0 = argv.get(0).map(bun_core::ZStr::as_bytes).unwrap_or(b"");
@@ -1385,9 +1361,7 @@ pub mod command {
         let offset_for_passthrough: usize;
 
         let ctx: &mut ContextData = 'brk: {
-            // PORT NOTE: Zig calls `bun.initArgv()` eagerly in `main.zig`
-            // before `Cli.start`, which populates `bun_options_argc` from
-            // `BUN_OPTIONS`. The Rust entry (`bun_bin::main`) defers argv
+            // The entry point (`bun_bin::main`) defers argv
             // init to `bun_core::argv()`'s lazy `Once`, so force that init
             // now — otherwise `bun_options_argc()` reads 0 here and the
             // standalone executable silently drops `BUN_OPTIONS` flags.
@@ -1456,16 +1430,19 @@ pub mod command {
     /// pair — kept out-of-line so `start` is a jump table, but *not* `#[cold]`.
     #[inline(never)]
     fn exec_auto_or_run(tag: Tag, log: &mut bun_ast::Log) -> CmdResult {
-        // PORT NOTE: Zig's AutoCommand arm swallows
-        // `error.MissingEntryPoint` from `Command.init` and prints
-        // help. `bun_core::Error` has no variant table yet (stub
-        // — `err!()` collapses to `Error::TODO`), so a name-match
-        // would alias every error. Propagate for now; the empty-
-        // positionals fallthrough below covers the common "no args"
-        // help path anyway.
-        // TODO(port): restore `MissingEntryPoint → HelpCommand::exec()`
-        // once `bun_core::Error` interns names.
-        let ctx = init(tag, log)?;
+        // The AutoCommand arm swallows
+        // `error.MissingEntryPoint` from `Command.init` and prints help;
+        // every other tag (including RunCommand) propagates the error.
+        // Note: nothing currently produces `MissingEntryPoint`; bare
+        // `bun` help is served by the empty-positionals fallthrough. This arm
+        // exists in case a producer is ever added (Arguments.rs).
+        let ctx = match init(tag, log) {
+            Ok(ctx) => ctx,
+            Err(e) if tag == Tag::AutoCommand && e == bun_core::err!("MissingEntryPoint") => {
+                return HelpCommand::exec();
+            }
+            Err(e) => return Err(e),
+        };
         ctx.args.target = Some(bun_options_types::schema::api::Target::Bun);
 
         if ctx.parallel || ctx.sequential {
@@ -1518,8 +1495,7 @@ pub mod command {
     #[cold]
     #[inline(never)]
     fn exec_init() -> CmdResult {
-        // InitCommand parses its own argv (no Context); Zig:
-        //   .InitCommand => return try InitCommand.exec(allocator, bun.argv[@min(2, bun.argv.len)..])
+        // InitCommand parses its own argv (no Context).
         let argv = argv_zslice();
         super::init_command::InitCommand::exec(&argv[2.min(argv.len())..])
     }
@@ -1527,35 +1503,17 @@ pub mod command {
     #[cold]
     #[inline(never)]
     fn exec_install_completions() -> CmdResult {
-        // Minimal port of the non-interactive path: detect $SHELL and
-        // dump the embedded completion script to stdout. Full install
-        // (bunx symlink, fpath/XDG dir search, profile patching) needs
-        // `install_completions_command.rs` un-gated.
+        // The full
+        // exec handles both the non-tty path (dump the embedded completion
+        // script to stdout) and the tty install path (bunx symlink, fpath/XDG
+        // dir search, profile patching).
         for a in bun::argv().iter().skip(2) {
             if matches!(a, b"--help" | b"-h") {
                 tag_print_help(Tag::InstallCompletionsCommand, true);
                 Global::exit(0);
             }
         }
-        use super::shell_completions::ShellCompletionsExt as _;
-        let shell = bun_core::env_var::SHELL::platform_get()
-            .map(super::shell_completions::Shell::from_env)
-            .unwrap_or_default();
-        if matches!(shell, super::shell_completions::Shell::Unknown) {
-            pretty_errorln!(
-                "<r><red>error<r>: Unknown or unsupported shell. Please set $SHELL to one of zsh, fish, or bash."
-            );
-            bun_core::note!("To manually output completions, run 'bun getcompletes'");
-            Output::flush();
-            Global::exit(1);
-        }
-        // `Output::writer()` returns the process-global writer; no raw
-        // deref needed (was `*mut` in an earlier port pass).
-        let writer = Output::writer();
-        let _ = writer.write_all(shell.completions());
-        Output::flush();
-        // TODO(port): tty path → write into shell completions dir
-        // (InstallCompletionsCommand::exec).
+        super::install_completions_command::InstallCompletionsCommand::exec()?;
         Global::exit(0);
     }
 
@@ -1582,7 +1540,7 @@ pub mod command {
     #[cold]
     #[inline(never)]
     fn exec_repl(log: &mut bun_ast::Log) -> CmdResult {
-        // PORT NOTE: Zig inits with .RunCommand here (repl reuses run params).
+        // Inits with RunCommand (repl reuses run params).
         let ctx = init(Tag::RunCommand, log)?;
         super::repl_command::ReplCommand::exec(ctx)
     }
@@ -1658,16 +1616,14 @@ pub mod command {
     }
 
     // ─── helper fns hoisted from `Command.start` (kept out of `start` to keep
-    //     its stack frame small; the original Zig had them as nested closures /
-    //     inline blocks) ─────────────────────────────────────────────────────
+    //     its stack frame small) ────────────────────────────────────────────
 
     const DEFAULT_COMPLETIONS_LIST: &[&[u8]] = &[
         b"build", b"install", b"add", b"run", b"update", b"link", b"unlink", b"remove", b"create",
         b"bun", b"upgrade", b"discord", b"test", b"pm", b"x", b"repl", b"info",
     ];
 
-    // PORT NOTE: Zig concatenated DEFAULT_COMPLETIONS_LIST ++ extras at
-    // comptime; hand-rolled join (small, fixed).
+    // DEFAULT_COMPLETIONS_LIST ++ extras; hand-rolled join (small, fixed).
     const REJECT_LIST: &[&[u8]] = &[
         b"build",
         b"install",
@@ -1700,7 +1656,7 @@ pub mod command {
         use super::shell_completions::ShellCompletions;
 
         let ctx = init(Tag::GetCompletionsCommand, log)?;
-        // PORT NOTE: `ctx.positionals` is `Vec<Box<[u8]>>`; clone into a local
+        // `ctx.positionals` is `Vec<Box<[u8]>>`; clone into a local
         // owned vec so `filter` doesn't borrow `ctx` (passed `&mut` below).
         let positionals: Vec<Box<[u8]>> = ctx.positionals.clone();
         let positionals_refs: Vec<&[u8]> = positionals.iter().map(|b| &**b).collect();
@@ -1916,11 +1872,7 @@ To create a project with the official Next.js scaffolding tool, run\n\
             // without leaking (PORTING.md §Forbidden patterns).
             static CREATE_PREFIX: std::sync::OnceLock<bun_core::ZBox> = std::sync::OnceLock::new();
             let prefixed = BunxCommand::add_create_prefix(template_name)?;
-            bunx_args.push(
-                CREATE_PREFIX
-                    .get_or_init(|| bun_core::ZBox::from_vec_with_nul(prefixed))
-                    .as_zstr(),
-            );
+            bunx_args.push(CREATE_PREFIX.get_or_init(|| prefixed).as_zstr());
             for src in &args[template_name_start..] {
                 bunx_args.push(*src);
             }
@@ -2000,8 +1952,8 @@ To create a project with the official Next.js scaffolding tool, run\n\
         super::pm_view_command::view(pm, package_name, property_path, json_output)
     }
 
-    /// Per-tag clap param table. Runtime dispatch (was const-generic in Zig;
-    /// `Tag` lacks `ConstParamTy` here so demoted to a value param).
+    /// Per-tag clap param table. Runtime dispatch (`Tag` lacks `ConstParamTy`
+    /// here, so `cmd` is a value param).
     pub fn tag_params(cmd: Tag) -> &'static [arguments::ParamType] {
         match cmd {
             Tag::AutoCommand => arguments::AUTO_PARAMS,
@@ -2019,7 +1971,7 @@ To create a project with the official Next.js scaffolding tool, run\n\
         // use [foo] for multiple arguments or flags for foo.
         // use <bar> to emphasize 'bar'
         //
-        // PORT NOTE: every help block here must pass its template as a *string
+        // Every help block here must pass its template as a *string
         // literal* to `pretty!()` so the `pretty_fmt!` proc-macro can rewrite
         // the `<tag>` markers at compile time. Passing a `const &str` through
         // `{}` prints the raw markup.
@@ -2344,8 +2296,7 @@ pub fn print_version_and_exit() -> ! {
     // into a heap `String`, then runs the runtime `<tag>` rewriter into a
     // second `Vec<u8>`, all to print a ~10-byte constant. Write the bytes
     // straight to the buffered stdout writer instead. One `write_all` (the
-    // `\n` is baked into the constant) → one syscall, matching Zig's
-    // `writeAll(version ++ "\n")`.
+    // `\n` is baked into the constant) → one syscall.
     let w = Output::writer();
     let _ = w.write_all(Global::package_json_version_nl.as_bytes());
     Output::flush();
@@ -2361,5 +2312,3 @@ pub fn print_revision_and_exit() -> ! {
     Output::flush();
     Global::exit(0);
 }
-
-// ported from: src/runtime/cli/cli.zig
diff --git a/src/runtime/cli/multi_run.rs b/src/runtime/cli/multi_run.rs
index 6a1d516884e..f1713554a0f 100644
--- a/src/runtime/cli/multi_run.rs
+++ b/src/runtime/cli/multi_run.rs
@@ -17,7 +17,7 @@ use crate::filter_arg as FilterArg;
 use crate::run_command::RunCommand;
 
 // `bun.spawn` (Process/Status/SpawnOptions/Rusage/spawnProcess) —
-// lives under src/runtime/api/bun/process.zig → crate::api::bun::process.
+// lives under crate::api::bun::process.
 #[cfg(unix)]
 use crate::api::bun::process::SpawnResultExt as _;
 use crate::api::bun::process::{
@@ -56,7 +56,7 @@ pub struct PipeReader<'a> {
 impl<'a> PipeReader<'a> {
     fn new(is_stderr: bool) -> Self {
         Self {
-            // BufferedReader::init(This) — Zig passes the parent type for vtable.
+            // BufferedReader::init(This) — the parent type fills the vtable.
             reader: BufferedReader::init::<Self>(),
             handle: ptr::null(),
             is_stderr,
@@ -124,8 +124,7 @@ impl<'a> ProcessHandle<'a> {
         let state = unsafe { &mut *self.state.cast_mut() };
         state.remaining_scripts += 1;
 
-        // TODO(port): argv as null-terminated array of `?[*:0]const u8` — exact ABI for
-        // spawnProcess. Using *const c_char placeholders.
+        // Null-terminated argv array, as required by spawnProcess.
         let argv: [*const c_char; 4] = [
             state.shell_bin.as_ptr().cast::<c_char>(),
             if cfg!(unix) {
@@ -138,9 +137,6 @@ impl<'a> ProcessHandle<'a> {
         ];
 
         self.start_time = Instant::now().into();
-        // TODO(port): narrow error set
-        // PERF(port): was arena bulk-free — envp built into a temporary arena freed at scope
-        // end; allocates on heap here. Profile if it shows up on a hot path.
         let envp;
         let env_ptr = state.env;
         let spawned: SpawnProcessResult = {
@@ -181,7 +177,7 @@ impl<'a> ProcessHandle<'a> {
 
         self.stdout_reader.handle = std::ptr::from_ref(self);
         self.stderr_reader.handle = std::ptr::from_ref(self);
-        // PORT NOTE: compute parent ptrs before calling `set_parent` to avoid
+        // Compute parent ptrs before calling `set_parent` to avoid
         // borrowck seeing two simultaneous &mut borrows of the same field.
         let stdout_parent = (&raw mut self.stdout_reader).cast::<c_void>();
         self.stdout_reader.reader.set_parent(stdout_parent);
@@ -190,8 +186,7 @@ impl<'a> ProcessHandle<'a> {
 
         #[cfg(windows)]
         {
-            // Zig: `this.stdout_reader.reader.source = .{ .pipe = this.options.stdout.buffer }`.
-            // In the Rust port `spawn_process_windows` has *already* reclaimed
+            // `spawn_process_windows` has *already* reclaimed
             // sole ownership of that heap pipe into
             // `WindowsStdioResult::Buffer(Box<uv::Pipe>)` (see
             // src/spawn/process.rs WindowsStdio::Buffer doc). Reconstructing a
@@ -310,7 +305,6 @@ impl<'a> State<'a> {
         self.remaining_scripts == 0
     }
 
-    // TODO(port): narrow error set — was `(std.Io.Writer.Error || bun.OOM)!void`
     fn read_chunk(&mut self, pipe: &mut PipeReader<'a>, chunk: &[u8]) -> Result<(), Error> {
         pipe.line_buffer.extend_from_slice(chunk);
 
@@ -333,7 +327,6 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    // TODO(port): narrow error set — was `std.Io.Writer.Error!void`
     fn write_line_with_prefix(
         &self,
         handle: &ProcessHandle,
@@ -345,7 +338,6 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    // TODO(port): narrow error set — was `std.Io.Writer.Error!void`
     fn write_prefix(&self, handle: &ProcessHandle, writer: &mut OutputWriter) -> Result<(), Error> {
         if self.use_colors {
             writer.write_all(COLORS[handle.color_idx % COLORS.len()])?;
@@ -365,7 +357,6 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    // TODO(port): narrow error set — was `std.Io.Writer.Error!void`
     fn flush_pipe_buffer(
         &self,
         handle: &ProcessHandle<'a>,
@@ -388,12 +379,11 @@ impl<'a> State<'a> {
         Ok(())
     }
 
-    // TODO(port): narrow error set — was `std.Io.Writer.Error!void`
     fn process_exit(&mut self, handle: &mut ProcessHandle<'a>) -> Result<(), Error> {
         self.remaining_scripts -= 1;
 
         // Flush remaining buffers (stdout first, then stderr)
-        // PORT NOTE: reshaped for borrowck — `flush_pipe_buffer` would need both
+        // Reshaped for borrowck — `flush_pipe_buffer` would need both
         // `&ProcessHandle` and `&mut handle.stdout_reader` which overlap. Route
         // through a raw ptr (the State/handle backref pattern is already
         // raw-ptr-based throughout this file).
@@ -450,7 +440,7 @@ impl<'a> State<'a> {
 
         if failed {
             // Pre->main->post chain is broken -- skip group dependents.
-            // PORT NOTE: reshaped for borrowck — clone the dependent ptr slices to avoid
+            // Reshaped for borrowck — clone the dependent ptr slices to avoid
             // borrowing `handle` while iterating self.handles via the raw ptrs.
             let group = handle.group_dependents.clone();
             let next = handle.next_dependents.clone();
@@ -580,7 +570,6 @@ impl AbortHandler {
         }
         #[cfg(not(unix))]
         {
-            // TODO(port): move to <area>_sys
             let res = bun_sys::windows::SetConsoleCtrlHandler(
                 Some(Self::windows_ctrl_handler),
                 bun_sys::windows::TRUE,
@@ -653,7 +642,6 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
     path: &[u8],
     label_prefix: Option<&[u8]>,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     let group_start = configs.len();
 
     let label: Box<[u8]> = if let Some(prefix) = label_prefix {
@@ -763,7 +751,7 @@ fn add_script_configs<V: core::ops::Deref<Target = [u8]>>(
     Ok(())
 }
 
-// TODO(port): `!noreturn` — Zig returns either an error or diverges. Using
+// Returns either an error or diverges:
 // `Result<Infallible, Error>` so callers can `?` it; all Ok paths call Global::exit.
 pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infallible, Error> {
     // Validate flags
@@ -776,7 +764,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
 
     // Collect script names from positionals + passthrough
     // For RunCommand: positionals[0] is "run", skip it. For AutoCommand: no "run" prefix.
-    // PORT NOTE: cloned to owned so the &mut ctx borrow below doesn't conflict.
+    // Cloned to owned so the &mut ctx borrow below doesn't conflict.
     let mut script_names: Vec<Box<[u8]>> = Vec::new();
 
     let mut positionals: &[Box<[u8]>] = &ctx.positionals;
@@ -803,7 +791,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
 
     // Set up the transpiler/environment
     let _ = bun_resolver::fs::FileSystem::init(None)?;
-    // Out-param init pattern — Zig writes into `var this_transpiler: Transpiler = undefined;`
+    // Out-param init pattern.
     let mut this_transpiler_slot =
         ::core::mem::MaybeUninit::<bun_bundler::Transpiler<'static>>::uninit();
     let _ = RunCommand::configure_env_for_run(ctx, &mut this_transpiler_slot, None, true, false)?;
@@ -1175,7 +1163,7 @@ pub(crate) fn run(ctx: &mut Command::ContextData) -> Result<core::convert::Infal
         });
     }
     state.handles = handles.into_boxed_slice();
-    // PORT NOTE: `state` field of each handle was set above as a raw ptr before `state.handles`
+    // The `state` field of each handle was set above as a raw ptr before `state.handles`
     // was assigned — the address of `state` does not change, so the backref remains valid.
 
     // Set up pre->main->post chaining within each group
@@ -1241,5 +1229,3 @@ fn has_runnable_extension(name: &[u8]) -> bool {
     };
     loader.can_be_run_by_bun()
 }
-
-// ported from: src/cli/multi_run.zig
diff --git a/src/runtime/cli/open.rs b/src/runtime/cli/open.rs
index c0b31fdfd97..8d7f8eaf6eb 100644
--- a/src/runtime/cli/open.rs
+++ b/src/runtime/cli/open.rs
@@ -22,7 +22,7 @@ pub(super) const OPENER: &[u8] = b"xdg-open";
 
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, strum::IntoStaticStr, enum_map::Enum)]
-#[strum(serialize_all = "snake_case")] // match Zig @tagName: .vscode → "vscode"
+#[strum(serialize_all = "snake_case")] // Vscode → "vscode"
 pub enum Editor {
     None,
     Sublime,
@@ -37,9 +37,8 @@ pub enum Editor {
     Other,
 }
 
-// PORT NOTE: Zig's `std.EnumMap(Editor, string)` / `std.EnumMap(Editor, []const [:0]const u8)`
-// were comptime-initialized sparse maps. `bin_name` ported per PORTING.md as
-// `enum_map::EnumMap<E, Option<V>>`; `bin_path` kept as a match-fn because of `#[cfg]` gating.
+// Note: `bin_name` is an `enum_map::EnumMap<E, Option<V>>` (sparse map);
+// `bin_path` is a match-fn because of `#[cfg]` gating.
 
 static NAME_MAP: phf::Map<&'static [u8], Editor> = phf::phf_map! {
     b"sublime" => Editor::Sublime,
@@ -87,14 +86,14 @@ impl Editor {
     ) -> Option<Editor> {
         let path_env = env.get(b"PATH")?;
 
-        // PORT NOTE: borrowck — `which` ties its return to `&'a mut *buf`; on a
+        // Note: borrowck — `which` ties its return to `&'a mut *buf`; on a
         // miss we need `buf` again next iteration but NLL conservatively keeps
         // the borrow live (Polonius case). Re-borrow through a raw pointer; on
         // a hit we return immediately so only one `&mut` is ever live.
         let buf_ptr: *mut PathBuffer = buf;
         for &editor in &DEFAULT_PREFERENCE_LIST {
             if let Some(path) = BIN_NAME[editor] {
-                // SAFETY: see PORT NOTE above — exclusive per-iteration reborrow.
+                // SAFETY: see note above — exclusive per-iteration reborrow.
                 if let Some(bin) = which(unsafe { &mut *buf_ptr }, path_env, cwd, path) {
                     *out = bin.as_bytes();
                     return Some(editor);
@@ -133,7 +132,7 @@ impl Editor {
             for path in paths {
                 match bun_sys::File::open_at(bun_sys::Fd::cwd(), path, bun_sys::O::RDONLY, 0) {
                     bun_sys::Result::Ok(opened) => {
-                        let _ = opened.close(); // close error is non-actionable (Zig parity: discarded)
+                        let _ = opened.close(); // close error is non-actionable
                         if let Some(out) = out {
                             *out = path.as_bytes();
                         }
@@ -153,7 +152,7 @@ impl Editor {
         cwd: &[u8],
         out: &mut &'a [u8],
     ) -> Option<Editor> {
-        // PORT NOTE: borrowck — see `by_path` above; same Polonius-case reborrow.
+        // Note: borrowck — see `by_path` above; same Polonius-case reborrow.
         let buf_ptr: *mut PathBuffer = buf;
         for &editor in &DEFAULT_PREFERENCE_LIST {
             // SAFETY: exclusive per-iteration reborrow; we return immediately on hit.
@@ -161,7 +160,7 @@ impl Editor {
                 return Some(editor);
             }
 
-            // PORT NOTE: reshaped for borrowck — by_fallback_path_for_editor writes a
+            // Note: reshaped for borrowck — by_fallback_path_for_editor writes a
             // 'static slice; we widen `out` to accept it via a temporary.
             let mut static_out: &'static [u8] = b"";
             if Self::by_fallback_path_for_editor(editor, Some(&mut static_out)) {
@@ -184,12 +183,10 @@ impl Editor {
         line: Option<&[u8]>,
         column: Option<&[u8]>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut spawned = Box::new(SpawnedEditorContext::default());
-        // errdefer default_allocator.destroy(spawned) — handled by Box Drop on `?`.
 
         let mut cursor = std::io::Cursor::new(&mut spawned.file_path_buf[..]);
-        // PORT NOTE: `args_buf` entries borrow both static strings and `file_path_buf`
+        // Note: `args_buf` entries borrow both static strings and `file_path_buf`
         // (self-referential once boxed). Kept as raw byte-slice ptrs; reconstructed
         // as slices when handed to the child process.
         let mut i: usize = 0;
@@ -248,7 +245,7 @@ impl Editor {
                 cursor.write_all(file).or_write_failed()?;
                 let file_path_len = usize::try_from(cursor.position()).expect("int cast");
 
-                // PORT NOTE: borrowck — `cursor` holds `&mut spawned.file_path_buf`;
+                // Note: borrowck — `cursor` holds `&mut spawned.file_path_buf`;
                 // hoist all writes/position reads above the slice reads so NLL can
                 // end the cursor borrow before we re-borrow `file_path_buf` immutably.
                 let mut end_pos = file_path_len;
@@ -291,9 +288,8 @@ impl Editor {
 
         spawned.argc = i;
         let spawned_ptr = bun_core::heap::into_raw(spawned);
-        // PORT NOTE: Zig used `std.Thread.spawn(.{}, autoClose, .{spawned})` then `.detach()`.
-        // bun_threading has no detached-spawn helper; std::thread::spawn matches semantics
-        // (the JoinHandle is dropped, detaching the thread).
+        // bun_threading has no detached-spawn helper; std::thread::spawn is used
+        // and the JoinHandle is dropped, detaching the thread.
         // SAFETY: `spawned_ptr` is a uniquely-owned Box raw pointer; ownership is
         // transferred to the spawned thread which reconstitutes it via heap::take.
         // Smuggled across the thread boundary as `usize` (`*mut T: !Send`).
@@ -301,8 +297,7 @@ impl Editor {
         std::thread::Builder::new()
             .spawn(move || auto_close(spawned_addr as *mut SpawnedEditorContext))
             .map_err(|_| {
-                // Zig parity: `errdefer default_allocator.destroy(spawned)` (open.zig:234)
-                // covers `try std.Thread.spawn`. After `into_raw`, Box's Drop guard is gone,
+                // After `into_raw`, Box's Drop guard is gone,
                 // so reclaim explicitly on the spawn-failure path.
                 // SAFETY: closure never ran, so we are still the sole owner of `spawned_ptr`.
                 drop(unsafe { bun_core::heap::take(spawned_addr as *mut SpawnedEditorContext) });
@@ -323,7 +318,6 @@ pub(super) const DEFAULT_PREFERENCE_LIST: [Editor; 8] = [
     Editor::Vim,
 ];
 
-// PORT NOTE: was `pub const bin_name: std.EnumMap(Editor, string)` built in a comptime block.
 pub(super) static BIN_NAME: std::sync::LazyLock<enum_map::EnumMap<Editor, Option<&'static [u8]>>> =
     std::sync::LazyLock::new(|| {
         enum_map::EnumMap::from_fn(|k| match k {
@@ -341,7 +335,6 @@ pub(super) static BIN_NAME: std::sync::LazyLock<enum_map::EnumMap<Editor, Option
         })
     });
 
-// PORT NOTE: was `pub const bin_path: std.EnumMap(Editor, []const [:0]const u8)`.
 pub(super) fn bin_path(editor: Editor) -> Option<&'static [&'static ZStr]> {
     #[cfg(target_os = "macos")]
     {
@@ -385,7 +378,7 @@ pub(super) fn bin_path(editor: Editor) -> Option<&'static [&'static ZStr]> {
     }
 }
 
-// PORT NOTE: `buf` stores (ptr, len) pairs because entries point into `file_path_buf`
+// Note: `buf` stores (ptr, len) pairs because entries point into `file_path_buf`
 // (self-referential) as well as caller-provided/static slices. Reconstructed as slices
 // in `auto_close`.
 pub(super) struct SpawnedEditorContext {
@@ -420,8 +413,7 @@ fn auto_close(spawned: *mut SpawnedEditorContext) {
         argv[j] = unsafe { bun_core::ffi::slice(p, l) };
     }
 
-    // FIXME(windows-leak): Zig's autoClose (open.zig:329-335) used std.process.Child
-    // directly (CreateProcessW) and never created a uv loop. The sync::spawn substitution
+    // FIXME(windows-leak): the sync::spawn path
     // requires a `WindowsOptions.loop_`; `MiniEventLoop::init_global` heap-allocates a
     // MiniEventLoop + uv_loop_t into a thread-local that is NEVER torn down. Because this
     // runs on a fresh detached std::thread per `Editor::open()` call, every editor-open on
@@ -454,7 +446,7 @@ fn auto_close(spawned: *mut SpawnedEditorContext) {
 
 pub struct EditorContext {
     pub editor: Option<Editor>,
-    // PORT NOTE: `name`/`path` are never freed in Zig; `path` is backed by
+    // Note: `name`/`path` are never freed; `path` is backed by
     // `Fs.FileSystem.instance.dirname_store` (process-lifetime arena) or aliases `name`.
     pub name: &'static [u8],
     pub path: &'static [u8],
@@ -502,7 +494,6 @@ impl EditorContext {
         line: &[u8],
         column: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut basename_buf = [0u8; 512];
         let mut basename = bun_paths::basename(id);
         if strings::ends_with(basename, b".bun") && basename.len() < 499 {
@@ -535,7 +526,7 @@ impl EditorContext {
 
     pub fn detect_editor(&mut self, env: &mut dot_env::Loader) {
         let mut buf = PathBuffer::uninit();
-        // PORT NOTE: borrowck — `by_path_for_editor`/`by_fallback` tie `out`'s lifetime
+        // Note: borrowck — `by_path_for_editor`/`by_fallback` tie `out`'s lifetime
         // to `&'a mut buf`. On the `false` path NLL conservatively keeps `buf` borrowed
         // (Polonius case). Re-borrow through a raw pointer at each call site; on a hit
         // we return immediately so only one `&mut` is ever live.
@@ -557,7 +548,7 @@ impl EditorContext {
                 if Editor::by_path_for_editor(
                     env,
                     editor_,
-                    // SAFETY: see PORT NOTE above — exclusive per-call reborrow.
+                    // SAFETY: see note above — exclusive per-call reborrow.
                     unsafe { &mut *buf_ptr },
                     Fs::FileSystem::instance().top_level_dir,
                     &mut out,
@@ -588,7 +579,7 @@ impl EditorContext {
             if Editor::by_path_for_editor(
                 env,
                 editor_,
-                // SAFETY: see PORT NOTE above — exclusive per-call reborrow.
+                // SAFETY: see note above — exclusive per-call reborrow.
                 unsafe { &mut *buf_ptr },
                 Fs::FileSystem::instance().top_level_dir,
                 &mut out,
@@ -616,7 +607,7 @@ impl EditorContext {
         // Don't know, so we will just guess based on what exists
         if let Some(editor_) = Editor::by_fallback(
             env,
-            // SAFETY: see PORT NOTE above — exclusive per-call reborrow.
+            // SAFETY: see note above — exclusive per-call reborrow.
             unsafe { &mut *buf_ptr },
             Fs::FileSystem::instance().top_level_dir,
             &mut out,
@@ -632,5 +623,3 @@ impl EditorContext {
         self.editor = Some(Editor::None);
     }
 }
-
-// ported from: src/cli/open.zig
diff --git a/src/runtime/cli/outdated_command.rs b/src/runtime/cli/outdated_command.rs
index a881eed53c8..272b53c6aee 100644
--- a/src/runtime/cli/outdated_command.rs
+++ b/src/runtime/cli/outdated_command.rs
@@ -51,8 +51,7 @@ impl<'a> FilterType<'a> {
             FilterType::Name(pattern)
         }
     }
-    // *NOTE*: Currently `deinit` does nothing since name and path are not
-    // allocated (Zig `deinit` was a no-op → no Drop impl needed).
+    // *NOTE*: name and path are not allocated → no Drop impl needed.
 }
 
 impl OutdatedCommand {
@@ -90,9 +89,8 @@ impl OutdatedCommand {
         original_cwd: &[u8],
         manager: &mut PackageManager,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — Zig calls
-        // `manager.lockfile.loadFromCwd(manager, alloc, manager.log, true)` which
-        // aliases `*PackageManager` with its `*Lockfile` field. Project disjoint
+        // Reshaped for borrowck — `load_from_cwd` would otherwise alias
+        // `PackageManager` with its `lockfile` field. Project disjoint
         // raw pointers from the singleton first; `load_from_cwd` only reads
         // `manager.options` / migration helpers and never re-borrows
         // `manager.lockfile` through the `pm` argument.
@@ -106,8 +104,8 @@ impl OutdatedCommand {
         // SAFETY: `manager.log` is set non-null by `PackageManager::init`.
         let log = unsafe { &mut *log_ptr };
         match lockfile.load_from_cwd::<true>(
-            // SAFETY: see PORT NOTE above — `load_from_cwd` accesses `manager`
-            // fields disjoint from `lockfile` (Zig invariant).
+            // SAFETY: see comment above — `load_from_cwd` accesses `manager`
+            // fields disjoint from `lockfile`.
             Some(unsafe { &mut *pm_ptr }),
             log,
         ) {
@@ -148,8 +146,7 @@ impl OutdatedCommand {
                 Global::crash();
             }
             LoadResult::Ok(_) => {
-                // PORT NOTE: Zig reassigns `manager.lockfile = ok.lockfile`
-                // (pointer field). `load_from_cwd(&mut self, ..)` populates the
+                // `load_from_cwd(&mut self, ..)` populates the
                 // lockfile in place, so the `ok.lockfile: &mut Lockfile` reborrow
                 // is the same storage and no reassignment is needed.
             }
@@ -246,7 +243,7 @@ impl OutdatedCommand {
         // `defer { filter.deinit(allocator); allocator.free(...) }` — implicit via Drop.
 
         // SAFETY: `FileSystem::init` runs during `PackageManager::init` so the
-        // process-singleton is populated; mirrors Zig `FileSystem.instance.top_level_dir`.
+        // process-singleton is populated.
         let top_level_dir = FileSystem::get().top_level_dir;
 
         // move all matched workspaces to front of array
@@ -454,8 +451,8 @@ impl OutdatedCommand {
         let mut max_workspace: usize = 0;
         let mut has_filtered_versions: bool = false;
 
-        // PORT NOTE: reshaped for borrowck — Zig threads `*PackageManager`
-        // into `manifests.byNameAllowExpired`, freely aliasing the receiver.
+        // Reshaped for borrowck — `manifests.byNameAllowExpired` would
+        // otherwise alias the receiver.
         // Hoist the four scalars that path reads into a by-value
         // `DiskCacheCtx` so the loop body holds only disjoint field borrows
         // (`&mut manager.manifests` against `&manager.lockfile` /
@@ -700,7 +697,6 @@ impl OutdatedCommand {
         table.print_column_names();
 
         // Print grouped items sorted by behavior type
-        // PERF(port): was `inline for` over a comptime tuple.
         for group_behavior in [
             Behavior::PROD,
             Behavior::DEV,
@@ -902,5 +898,3 @@ type _AssertImports = (
     package_manager::ManifestCacheOptions<'static>,
     bun_install::package_manifest_map::CacheBehavior,
 );
-
-// ported from: src/cli/outdated_command.zig
diff --git a/src/runtime/cli/pack_command.rs b/src/runtime/cli/pack_command.rs
index 3eff3f0fc53..51244523ce8 100644
--- a/src/runtime/cli/pack_command.rs
+++ b/src/runtime/cli/pack_command.rs
@@ -12,7 +12,7 @@ use bun_install::package_manager::LogLevel;
 use bun_install::package_manager::workspace_package_json_cache as WorkspacePackageJSONCache;
 use bun_install::{Dependency, Lockfile, PackageManager};
 use bun_parsers::json as JSON;
-// PORT NOTE: `WorkspacePackageJSONCache` returns the T2 value-subset
+// Note: `WorkspacePackageJSONCache` returns the T2 value-subset
 // `bun_ast::Expr` (see `bun_install::bun_json`), not the full T4
 // `bun_ast::Expr`. All JSON inspection in this file uses the T2 type;
 // the two T4 sinks (`js_printer::print_json`, `Publish::normalized_package`)
@@ -41,7 +41,6 @@ use bun_sys::{
 // local shims for upstream-stub gaps
 // ───────────────────────────────────────────────────────────────────────────
 
-/// `std.fs.Dir.openDirZ(path, .{ .iterate = true })`.
 #[inline]
 fn dir_open_dir_z(
     dir: &Dir,
@@ -52,7 +51,7 @@ fn dir_open_dir_z(
 }
 
 /// Process-lifetime bump arena for `Expr::as_string*` / `E::EString` data
-/// (Zig: `ctx.allocator`, an arena freed at process exit). `bun_alloc::Arena`
+/// (freed at process exit). `bun_alloc::Arena`
 /// (= `bumpalo::Bump`) is `!Sync`, so a `static LazyLock` is out; store the
 /// arena directly in a `thread_local!` and hand out a `'static` borrow — the
 /// CLI is single-threaded and the slot lives for the thread's lifetime.
@@ -61,8 +60,8 @@ fn pack_bump() -> &'static bun_alloc::Arena {
         static BUMP: bun_alloc::Arena = bun_alloc::Arena::new();
     }
     // SAFETY: `BUMP` is never dropped (thread = process lifetime in `bun pm
-    // pack`), and `Arena` is `!Sync` so no cross-thread aliasing. Erase the
-    // borrow to `'static` to mirror Zig's allocator-owned slices.
+    // pack`), and `Arena` is `!Sync` so no cross-thread aliasing, so the
+    // borrow can be erased to `'static`.
     BUMP.with(|b| unsafe { &*std::ptr::from_ref::<bun_alloc::Arena>(b) })
 }
 
@@ -76,14 +75,13 @@ fn file_to_source_at(dir: &Dir, path: &ZStr) -> bun_sys::Maybe<bun_ast::Source>
     ))
 }
 
-/// `manager.log` deref — Zig: non-optional `*logger.Log`, set once at `init()`.
+/// `manager.log` deref — set once at `init()`.
 /// Raw-pointer receiver so the borrow doesn't conflict with the simultaneous
-/// `&mut workspace_package_json_cache` borrow at the call site (mirrors Zig's
-/// freely-aliased `*PackageManager`).
+/// `&mut workspace_package_json_cache` borrow at the call site.
 #[inline]
 fn pm_log<'a>(m: *mut PackageManager) -> &'a mut bun_ast::Log {
     // SAFETY: `m` came from `&mut PackageManager`; `log` is non-null after
-    // `PackageManager::init()` (Zig: non-optional `*Log`).
+    // `PackageManager::init()`.
     unsafe { &mut *(*m).log }
 }
 /// `manager.workspace_package_json_cache` field projection via raw pointer.
@@ -96,7 +94,7 @@ fn pm_workspace_cache<'a>(
 }
 #[inline]
 fn pm_env(m: &PackageManager) -> *mut bun_dotenv::Loader<'static> {
-    // Zig: non-optional `*DotEnv.Loader`, set during `PackageManager.init`.
+    // Set during `PackageManager::init`.
     m.env
         .map(|p| p.as_ptr())
         .expect("env set by PackageManager::init")
@@ -106,8 +104,7 @@ fn pm_run_scripts(m: &PackageManager) -> bool {
     m.options.do_.run_scripts()
 }
 
-// type aliases matching Zig `string`/`stringZ`
-// (used as `&[u8]` / `&ZStr` at fn boundaries; owned forms use Box<[u8]> / Box<ZStr>)
+// (`&[u8]` / `&ZStr` at fn boundaries; owned forms use Box<[u8]> / Box<ZStr>)
 
 pub struct PackCommand;
 
@@ -218,11 +215,12 @@ impl PackCommand {
         }
 
         let mut lockfile = Lockfile::default();
-        // `log` is non-null after `PackageManager::init()` (Zig: non-optional `*Log`).
+        // `log` is non-null after `PackageManager::init()`.
         let log_ptr: *mut bun_ast::Log = manager.log;
         let manager_ptr: *mut PackageManager = manager;
-        // SAFETY: `manager_ptr`/`log_ptr` came from live `&mut`; reborrowed disjointly
-        // (Zig passed both via the same `*PackageManager` alias).
+        // SAFETY: `manager_ptr`/`log_ptr` came from live `&mut`; reborrowed
+        // disjointly (`log` is a separate allocation from the manager fields
+        // `load_from_cwd` touches).
         let load_from_disk_result = lockfile
             .load_from_cwd::<false>(Some(unsafe { &mut *manager_ptr }), unsafe { &mut *log_ptr });
 
@@ -266,8 +264,7 @@ impl PackCommand {
             LoadResult::NotFound => None,
         };
 
-        // PORT NOTE: Zig packed both `manager` and `lockfile` into `Context` and
-        // freely aliased the `*PackageManager`; here split-borrowing through
+        // Note: split-borrowing through
         // `Context` would conflict with `&mut PackageManager`, so capture the
         // package.json path before constructing `Context`.
         let abs_pkg_json = ZBox::from_bytes(manager.original_package_json_path.as_bytes());
@@ -374,10 +371,9 @@ pub enum PackError<const FOR_PUBLISH: bool> {
     InvalidPackageVersion,
     #[error("MissingPackageJSON")]
     MissingPackageJSON,
-    // The following two are only valid when FOR_PUBLISH == true.
-    // TODO(port): Zig modeled this as a comptime-computed error set union; Rust
-    // const-generic enums cannot conditionally include variants. Could
-    // split into two enums or gate construction.
+    // The following two are only valid when FOR_PUBLISH == true (const-generic
+    // enums cannot conditionally include variants, so both instantiations
+    // share one enum).
     #[error("RestrictedUnscopedPackage")]
     RestrictedUnscopedPackage,
     #[error("PrivatePackage")]
@@ -426,7 +422,7 @@ const DEFAULT_IGNORE_PATTERNS: &[(&[u8], bool)] = &[
 ];
 
 struct PackListEntry {
-    subpath: ZBox, // owned NUL-terminated path (Zig `stringZ`)
+    subpath: ZBox, // owned NUL-terminated path
     size: usize,
 }
 type PackList = Vec<PackListEntry>;
@@ -445,7 +441,6 @@ impl Default for PackQueueItem {
     }
 }
 
-// `std.PriorityQueue(PackQueueItem, void, PackQueueContext.lessThan)` — min-heap by path.
 // `bun_collections` has no `PriorityQueue`; wrap `BinaryHeap` with a reversed `Ord`
 // (BinaryHeap is a max-heap, so invert `strings::order` to pop smallest first).
 impl Ord for PackQueueItem {
@@ -513,7 +508,7 @@ fn iterate_included_project_tree(
     }
 
     let mut ignores: Vec<IgnorePatterns> = Vec::new();
-    let _ = &mut ignores; // unused in this fn body in Zig too (declared but not read)
+    let _ = &mut ignores; // unused in this fn body (declared but not read)
 
     let mut dirs: Vec<DirInfo> = Vec::new();
     dirs.push(DirInfo(Dir::from_fd(root_dir.fd), Box::from(&b""[..]), 1));
@@ -535,7 +530,7 @@ fn iterate_included_project_tree(
 
         let mut dir_iter = DirIterator::iterate(Fd::from_std_dir(&dir));
         'next_entry: while let Some(entry) = dir_iter.next().ok().flatten() {
-            // PORT NOTE: `.unwrap() catch null` → on iterator error, treat as end
+            // On iterator error, treat as end of iteration.
             if entry.kind != bun_sys::FileKind::File && entry.kind != bun_sys::FileKind::Directory {
                 continue;
             }
@@ -726,8 +721,7 @@ fn add_entire_tree(
         }
         ignores.push(IgnorePatterns {
             list: negated_excludes.into_boxed_slice(),
-            // PORT NOTE: Zig stored a borrowed slice into `negated_excludes`;
-            // moved here since it isn't reused below.
+            // Note: `negated_excludes` is moved here since it isn't reused below.
             kind: IgnorePatternsKind::PackageJson,
             depth: 1,
             // always assume no relative path b/c matching is done from the
@@ -861,7 +855,6 @@ fn open_subdir(dir: &Dir, entry_name: &[u8], entry_subpath: &ZStr) -> Dir {
 }
 
 fn entry_subpath(dir_subpath: &[u8], entry_name: &[u8]) -> Result<ZBox, AllocError> {
-    // std.fmt.allocPrintSentinel(allocator, "{s}{s}{s}", ..., 0)
     let sep: &[u8] = if dir_subpath.is_empty() { b"" } else { b"/" };
     let mut buf = Vec::with_capacity(dir_subpath.len() + sep.len() + entry_name.len() + 1);
     buf.extend_from_slice(dir_subpath);
@@ -953,9 +946,9 @@ fn iterate_bundled_deps(
             while let Some(sub_entry) = scoped_iter.next().ok().flatten() {
                 let entry_name = entry_subpath(_entry_name, sub_entry.name.slice_u8())?;
 
-                // PORT NOTE: reshaped for borrowck — Zig iterates `*dep` and
-                // calls `add_bundled_dep(ctx, ...)` mid-loop; in Rust we find
-                // the matching index first, mark it, then call with `&mut ctx`.
+                // Note: reshaped for borrowck — find
+                // the matching index first, mark it, then call
+                // `add_bundled_dep` with `&mut ctx`.
                 let Some(dep_idx) = ctx.bundled_deps.iter().position(|dep| {
                     debug_assert!(dep.from_root_package_json);
                     strings::eql_long(entry_name.as_bytes(), &dep.name, true)
@@ -985,7 +978,7 @@ fn iterate_bundled_deps(
             }
         } else {
             let entry_name = _entry_name;
-            // PORT NOTE: reshaped for borrowck — see comment in scoped branch.
+            // Note: reshaped for borrowck — see comment in scoped branch.
             let Some(dep_idx) = ctx.bundled_deps.iter().position(|dep| {
                 debug_assert!(dep.from_root_package_json);
                 strings::eql_long(entry_name, &dep.name, true)
@@ -1119,7 +1112,7 @@ fn add_bundled_dep(
                             else {
                                 continue;
                             };
-                            // PORT NOTE: `json` here is `bun_ast::Expr`, not the parser AST.
+                            // Note: `json` here is `bun_ast::Expr`, not the parser AST.
 
                             'next_dep: for dep in dependencies.properties.slice() {
                                 if dep.key.is_none() {
@@ -1138,7 +1131,6 @@ fn add_bundled_dep(
                                     continue;
                                 };
 
-                                // allocPrintSentinel(.., "{s}/node_modules/{s}", ..)
                                 let mut dep_subpath_buf: Vec<u8> = Vec::with_capacity(
                                     dir_subpath.len() + "/node_modules/".len() + dep_name.len() + 1,
                                 );
@@ -1237,8 +1229,7 @@ fn add_bundled_dep(
                     }
 
                     if entry_name == b"node_modules" {
-                        // handled by labeled-block fallthrough in Zig: `continue` outer loop
-                        // (see below)
+                        // handled by labeled-block fallthrough below
                     }
                 }
                 if entry_name == b"node_modules" {
@@ -1828,7 +1819,7 @@ impl ArchivePtrExt for *mut Archive {
     }
 }
 
-/// Local `@tagName` for `bun_core::FileKind` (Zig `std.fs.File.Kind` tag names).
+/// Tag names for `bun_core::FileKind`.
 fn file_kind_tag(kind: bun_core::FileKind) -> &'static str {
     use bun_core::FileKind as K;
     match kind {
@@ -1847,8 +1838,7 @@ fn file_kind_tag(kind: bun_core::FileKind) -> &'static str {
 }
 
 /// Heap-allocate a 512 KiB `BufferedFileReader` without materializing it on
-/// the stack. Zig: `allocator.create(BufferedFileReader)` then field-init with
-/// `.buf = undefined`. `Box::new_zeroed` maps to a `calloc` (typically a free
+/// the stack. `Box::new_zeroed` maps to a `calloc` (typically a free
 /// kernel zero-page for this size) and avoids the 512 KiB stack temporary.
 fn new_boxed_buffered_file_reader(file: bun_sys::File) -> Box<BufferedFileReader> {
     // SAFETY: all-zero is a valid bit pattern for `[u8; N]`, `usize`, and
@@ -1863,7 +1853,7 @@ fn new_boxed_buffered_file_reader(file: bun_sys::File) -> Box<BufferedFileReader
 
 /// Re-seat the underlying file and reset the buffer cursor in place — avoids
 /// the 512 KiB stack temporary that `*file_reader = BufferedFileReader { ... }`
-/// would create. Zig: `file_reader.* = .{ .unbuffered_reader = ..., .buf = undefined }`.
+/// would create.
 ///
 /// `unbuffered_reader` is a *view* of a fd that the call site owns (e.g. via
 /// a `CloseOnDrop` or a `File` whose Drop fires after the read loop). The
@@ -1876,8 +1866,8 @@ fn reset_buffered_file_reader(r: &mut BufferedFileReader, file: bun_sys::File) {
     r.end = 0;
 }
 
-/// `BufferedFileReader::read` shim — `bun_sys::File` doesn't impl
-/// `DeprecatedRead`, so route through `bun_sys::read` directly.
+/// `BufferedFileReader::read` shim — `bun_core::deprecated::BufferedReader`
+/// carries no read method, so route through `bun_sys::read` directly.
 #[inline]
 fn buffered_file_reader_read(r: &mut BufferedFileReader, dest: &mut [u8]) -> bun_sys::Maybe<usize> {
     let current = &r.buf[r.start..r.end];
@@ -1920,19 +1910,19 @@ fn opt_pack_gzip_level(m: &PackageManager) -> Option<&[u8]> {
 // pack()
 // ───────────────────────────────────────────────────────────────────────────
 
-// TODO(refactor): Zig used `comptime for_publish: bool` to vary the return type
-// (`Publish.Context(true)` vs `void`). Rust const generics cannot vary return
-// type directly; using an associated-type-like Option for now. Could split
-// into `pack()` and `pack_for_publish()` or use a trait.
+// Const generics cannot vary the
+// return type directly, so both instantiations return an Option that is
+// `Some` only when FOR_PUBLISH == true.
 pub(crate) type PackReturn<'a, const FOR_PUBLISH: bool> = Option<Publish::Context<'a, true>>;
 
 pub(crate) fn pack<const FOR_PUBLISH: bool>(
     ctx: &mut Context<'_>,
     abs_package_json_path: &ZStr,
 ) -> Result<PackReturn<'static, FOR_PUBLISH>, PackError<FOR_PUBLISH>> {
-    // PORT NOTE: reshaped for borrowck — Zig freely aliased `*PackageManager`
-    // alongside `ctx`-whole calls (`run_lifecycle_script(ctx, …)`,
-    // `iterate_bundled_deps(ctx, …)`). Round-trip the field through a raw
+    // Note: reshaped for borrowck —
+    // `ctx`-whole calls (`run_lifecycle_script(ctx, …)`,
+    // `iterate_bundled_deps(ctx, …)`) overlap the manager borrow.
+    // Round-trip the field through a raw
     // pointer so the long-lived `manager` reborrow is decoupled from `ctx`;
     // every interleaved `ctx` access touches disjoint fields (`command_ctx`,
     // `bundled_deps`, `stats`) or only reads `manager` via `pm_*` helpers.
@@ -1942,9 +1932,8 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
     let manager: &mut PackageManager = unsafe { &mut *manager_ptr };
     let log_level = manager.options.log_level;
     let bump = pack_bump();
-    // PORT NOTE: `workspace_package_json_cache` and `log` are disjoint fields on
-    // `PackageManager` but Zig accessed them via the same `*PackageManager`
-    // alias inside one call; route through raw-pointer field projections so the
+    // Note: `workspace_package_json_cache` and `log` are disjoint fields on
+    // `PackageManager`; route through raw-pointer field projections so the
     // two `&mut` borrows don't conflict.
     let mut json = match pm_workspace_cache(manager_ptr).get_with_path(
         pm_log(manager_ptr),
@@ -2042,8 +2031,8 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
         }
     }
 
-    // PORT NOTE: `Transpiler` has no `Default`; Zig used `var t: Transpiler = undefined;`
-    // and `configure_env_for_run` writes the whole struct (out-param constructor).
+    // Note: `Transpiler` has no `Default`;
+    // `configure_env_for_run` writes the whole struct (out-param constructor).
     let mut this_transpiler: core::mem::MaybeUninit<bun_bundler::Transpiler<'static>> =
         core::mem::MaybeUninit::uninit();
 
@@ -2474,16 +2463,15 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
                 package_version,
                 &mut dest_buf[..],
             );
-            // PORT NOTE: `manager`/`command_ctx` reborrowed via raw pointer —
-            // Zig freely aliased `*PackageManager`/`*ContextData` between
-            // `pack::Context` and `Publish::Context`; both are process-lifetime
+            // Note: `manager`/`command_ctx` reborrowed via raw pointer —
+            // both are process-lifetime
             // singletons (see `cli::command::GLOBAL_CLI_CTX`).
             return Ok(Some(Publish::Context {
                 // SAFETY: `manager_ptr` was derived from `&mut *ctx.manager`; the
                 // process-lifetime singleton outlives the returned `Publish::Context`.
                 manager: unsafe { &mut *manager_ptr },
                 // SAFETY: `ctx.command_ctx` aliases the process-lifetime
-                // `GLOBAL_CLI_CTX` singleton (see PORT NOTE above); reborrowed
+                // `GLOBAL_CLI_CTX` singleton (see note above); reborrowed
                 // disjointly from `manager`.
                 command_ctx: unsafe { &mut *std::ptr::from_mut(ctx.command_ctx) },
                 package_name: package_name.into(),
@@ -2577,7 +2565,7 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
         package_version,
         &mut dest_buf[..],
     );
-    // PORT NOTE: reshaped for borrowck — abs_tarball_dest borrows dest_buf
+    // Note: reshaped for borrowck — abs_tarball_dest borrows dest_buf
     let abs_tarball_dest_len = abs_tarball_dest.as_bytes().len();
 
     {
@@ -2623,9 +2611,8 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
             node = Some(progress.start(b"", pack_queue.count() + bundled_pack_queue.count() + 1));
             node.as_mut().expect("infallible: progress active").unit = Progress::Unit::Files;
         }
-        // PORT NOTE: Zig had `defer node.end()` / `defer node.completeOne()`.
-        // The loop bodies' only early exits are `continue` (where the Zig
-        // `defer` still fires) and `Global::crash()` (never returns, no
+        // Note: the loop bodies' only early exits are `continue`
+        // and `Global::crash()` (never returns, no
         // unwinding). `scopeguard` captures of `&mut node` overlap the inline
         // uses below, so call `complete_one()` explicitly at every loop-body
         // exit and `end()` once after the loops.
@@ -2958,7 +2945,7 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
             // process-lifetime singleton outlives the returned `Publish::Context`.
             manager: unsafe { &mut *manager_ptr },
             // SAFETY: `ctx.command_ctx` aliases the process-lifetime
-            // `GLOBAL_CLI_CTX` singleton (see dry-run PORT NOTE above);
+            // `GLOBAL_CLI_CTX` singleton (see dry-run note above);
             // reborrowed disjointly from `manager`.
             command_ctx: unsafe { &mut *std::ptr::from_mut(ctx.command_ctx) },
             package_name: package_name.into(),
@@ -2979,7 +2966,7 @@ pub(crate) fn pack<const FOR_PUBLISH: bool>(
 }
 
 // Helper extracted from repeated `RunCommand.runPackageScriptForeground` blocks.
-// PORT NOTE: hoisted from repeated inline blocks to avoid 5x duplication of the
+// Note: hoisted from repeated inline blocks to avoid 5x duplication of the
 // same `match err { MissingShell, OutOfMemory }` arms. Behavior identical.
 fn run_lifecycle_script<const FOR_PUBLISH: bool>(
     ctx: &Context<'_>,
@@ -2989,9 +2976,8 @@ fn run_lifecycle_script<const FOR_PUBLISH: bool>(
     env: *mut bun_dotenv::Loader<'static>,
     silent: bool,
 ) -> Result<(), PackError<FOR_PUBLISH>> {
-    // PORT NOTE: `ctx.command_ctx` and `env` are reborrowed via raw pointer
-    // because Zig passed `*ContextData` / `*DotEnv.Loader` (freely aliased
-    // process singletons) and `run_package_script_foreground` needs `&mut`
+    // Note: `ctx.command_ctx` and `env` are reborrowed via raw pointer
+    // because `run_package_script_foreground` needs `&mut`
     // for `env.map.put()` while `ctx` only holds `&Context`.
     // SAFETY: both are process-lifetime singletons; no concurrent `&mut` exists
     // while a lifecycle script runs (single-threaded CLI dispatch).
@@ -3062,7 +3048,6 @@ fn tarball_destination<'a>(
         Global::crash();
     }
     if !pack_filename.is_empty() {
-        // bufPrint(dest_buf, "{s}\x00", .{pack_filename})
         if pack_filename.len() + 1 > dest_buf.len() {
             Output::err_generic(
                 "archive filename too long: \"{}\"",
@@ -3089,7 +3074,6 @@ fn tarball_destination<'a>(
             )
         };
 
-        // bufPrint(dest_buf[dir_len_trimmed..], "/{f}\x00", ..)
         let mut cursor = std::io::Cursor::new(&mut dest_buf[dir_len_trimmed..]);
         let res = write!(
             &mut cursor,
@@ -3194,7 +3178,7 @@ fn archive_package_json(
     root_dir: &Dir,
     edited_package_json: &[u8],
 ) -> Result<*mut ArchiveEntry, AllocError> {
-    // Zig: `entry: *Archive.Entry` → `*Archive.Entry` (same pointer after `.clear()`).
+    // `entry` is the same pointer after `.clear()`.
     let entry = ArchiveEntry::opaque_ref(entry);
     let stat = match bun_sys::fstatat(Fd::from_std_dir(root_dir), bun_core::zstr!("package.json")) {
         Ok(s) => s,
@@ -3249,7 +3233,7 @@ fn add_archive_entry(
     print_buf: &mut Vec<u8>,
     bins: &[BinInfo],
 ) -> Result<*mut ArchiveEntry, AllocError> {
-    // Zig: `entry: *Archive.Entry` → `*Archive.Entry` (same pointer after `.clear()`).
+    // `entry` is the same pointer after `.clear()`.
     let entry = ArchiveEntry::opaque_ref(entry);
     write!(
         print_buf,
@@ -3342,7 +3326,7 @@ fn edit_root_package_json(
     json: &mut WorkspacePackageJSONCache::MapEntry,
 ) -> Result<Box<[u8]>, AllocError> {
     use bun_install_types::DependencyGroup;
-    // preserve deps→dev→peer→optional order (matches Zig pack_command.zig:2149 error-message ordering)
+    // preserve deps→dev→peer→optional order (error-message ordering)
     for dependency_group in [
         DependencyGroup::DEPENDENCIES,
         DependencyGroup::DEV,
@@ -3373,7 +3357,6 @@ fn edit_root_package_json(
                         strings::without_prefix_if_possible_comptime(package_spec, b"workspace:")
                     {
                         // TODO: make semver parsing more strict. `^`, `~` are not valid
-                        // (see Zig source for commented-out parsed/valid block)
 
                         if without_workspace_protocol.len() == 1 {
                             // TODO: this might be too strict
@@ -3411,9 +3394,8 @@ fn edit_root_package_json(
                                         b'*' => b"",
                                         _ => unreachable!(),
                                     };
-                                    // Zig: `try std.fmt.allocPrint(allocator, "{s}{}", ...)`.
-                                    // Format on the heap then copy into the pack arena
-                                    // (`ctx.allocator` analog); `EString::init` erases the
+                                    // Format on the heap then copy into the
+                                    // pack arena; `EString::init` erases the
                                     // lifetime.
                                     let tmp = format!(
                                         "{}{}",
@@ -3444,7 +3426,6 @@ fn edit_root_package_json(
                             }
                         }
 
-                        // Zig: `try allocator.dupe(u8, without_workspace_protocol)`.
                         let dup = pack_bump().alloc_slice_copy(without_workspace_protocol);
                         dependency.value =
                             Some(Expr::init(E::EString::init(dup), Default::default()));
@@ -3475,7 +3456,7 @@ fn edit_root_package_json(
                         let catalog_name = Semver::String::init(catalog_name_str, catalog_name_str);
                         let map_buf: &[u8] = lockfile.buffers.string_bytes.as_slice();
 
-                        // PORT NOTE: `CatalogMap::get_group` takes `&mut self`
+                        // Note: `CatalogMap::get_group` takes `&mut self`
                         // (returns `&mut Map`) but `pack` only needs read
                         // access via `&Lockfile`; inline an immutable lookup.
                         let catalog = if catalog_name.is_empty() {
@@ -3523,7 +3504,6 @@ fn edit_root_package_json(
                         };
                         let dep: &Dependency = &catalog.values()[dep_idx];
 
-                        // Zig: `try allocator.dupe(u8, literal.slice(buf))`.
                         let literal =
                             pack_bump().alloc_slice_copy(dep.version.literal.slice(map_buf));
                         dependency.value =
@@ -3581,7 +3561,7 @@ fn edit_root_package_json(
 
 /// A glob pattern used to ignore or include files in the project tree.
 /// Might come from .npmignore, .gitignore, or `files` in package.json
-// PORT NOTE: `CowSliceZ<u8>` is not `Clone`; manual borrow via `as_positive`.
+// Note: `CowSliceZ<u8>` is not `Clone`; manual borrow via `as_positive`.
 pub struct Pattern {
     pub glob: CowString,
     pub flags: PatternFlags,
@@ -4002,8 +3982,7 @@ fn is_unconditionally_included_file(filename: &[u8]) -> bool {
 // TODO: should this be case insensitive on all platforms?
 #[inline]
 fn strings_eql(a: &[u8], b: &'static [u8]) -> bool {
-    // PORT NOTE: Zig's `Environment.isLinux` (builtin.target.os.tag == .linux)
-    // is true on Android too; Rust splits these into distinct target_os values.
+    // Note: Android matches the Linux behavior here (case-sensitive compare).
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
         a == b
@@ -4016,8 +3995,7 @@ fn strings_eql(a: &[u8], b: &'static [u8]) -> bool {
 
 #[inline]
 fn is_special_file_or_variant(filename: &[u8], name: &'static [u8]) -> bool {
-    // PERF(port): Zig used `inline` switch arms for comptime-known length
-    // ranges. Runtime branches here are equivalent for these tiny comparisons.
+    // Runtime branches are fine for these tiny comparisons.
     if filename.len() < name.len() {
         false
     } else if filename.len() == name.len() {
@@ -4265,5 +4243,3 @@ pub mod bindings {
         Ok(result)
     }
 }
-
-// ported from: src/cli/pack_command.zig
diff --git a/src/runtime/cli/package_manager_command.rs b/src/runtime/cli/package_manager_command.rs
index 1ad195c405d..ce33dd1a4ea 100644
--- a/src/runtime/cli/package_manager_command.rs
+++ b/src/runtime/cli/package_manager_command.rs
@@ -26,7 +26,7 @@ use crate::cli::pm_why_command::PmWhyCommand;
 pub use crate::cli::pack_command::PackCommand;
 pub use crate::cli::scan_command::ScanCommand;
 
-// PORT NOTE: Owned snapshot of `Lockfile.Tree.Iterator(.node_modules).Next`.
+// Owned snapshot of `Lockfile.Tree.Iterator(.node_modules).Next`.
 // `tree::IteratorNext` borrows the iterator's internal `path_buf`; we copy
 // into owned storage so the `directories` Vec can outlive each `next()` call.
 pub struct NodeModulesFolder {
@@ -34,15 +34,13 @@ pub struct NodeModulesFolder {
     dependencies: Box<[DependencyID]>,
 }
 
-// PORT NOTE: transient sort-comparator context; lifetime is fn-local (BORROW_PARAM).
+// Transient sort-comparator context; lifetime is fn-local.
 struct ByName<'a> {
     dependencies: &'a [Dependency],
     buf: &'a [u8],
 }
 
 impl<'a> ByName<'a> {
-    // PORT NOTE: Zig pdq takes a strict-less-than predicate; Rust
-    // `sort_unstable_by` requires a total `Ordering`.
     pub(crate) fn cmp(&self, lhs: DependencyID, rhs: DependencyID) -> Ordering {
         self.dependencies[lhs as usize]
             .name
@@ -54,7 +52,7 @@ impl<'a> ByName<'a> {
 pub struct PackageManagerCommand;
 
 impl PackageManagerCommand {
-    // PORT NOTE: takes `LogLevel` instead of `&mut PackageManager` so callers
+    // Takes `LogLevel` instead of `&mut PackageManager` so callers
     // can keep `pm` mutably borrowed by `LoadResult` (which holds
     // `&mut Lockfile` into `pm.lockfile`) across this call.
     pub fn handle_load_lockfile_errors(load_lockfile: &LoadResult<'_>, log_level: LogLevel) {
@@ -79,7 +77,6 @@ impl PackageManagerCommand {
     pub fn print_hash(ctx: Command::Context, file: &File) -> Result<(), bun_core::Error> {
         let cli = CommandLineArguments::parse(Subcommand::Pm)?;
         let (pm, _cwd) = PackageManager::init(ctx, cli, Subcommand::Pm)?;
-        // PORT NOTE: `defer ctx.allocator.free(cwd)` dropped — `_cwd: Box<[u8]>` drops at scope exit.
 
         let bytes = match file.read_to_end() {
             Ok(bytes) => bytes,
@@ -90,7 +87,7 @@ impl PackageManagerCommand {
         };
 
         let log_level = pm.options.log_level;
-        // PORT NOTE: reshaped for borrowck — Zig `pm.lockfile.loadFromBytes(pm, …)`
+        // Reshaped for borrowck — `pm.lockfile.load_from_bytes(pm, …)`
         // is a self-referential split borrow. Derive both halves through `pm`
         // (not the raw `pm_ptr`) so the outer borrow stays on the stack.
         let pm_raw: *mut PackageManager = pm;
@@ -114,8 +111,7 @@ impl PackageManagerCommand {
     }
 
     fn get_subcommand(args_ptr: &mut &'static [&'static [u8]]) -> &'static [u8] {
-        // PORT NOTE: reshaped for borrowck — Zig copied `*args_ptr` to a local,
-        // mutated it, and `defer`-wrote it back. We mutate through `args_ptr`
+        // Mutates through `args_ptr`
         // directly so the reslice persists into `pm.options.positionals`.
         let mut subcommand: &[u8] = if !args_ptr.is_empty() {
             args_ptr[0]
@@ -193,10 +189,9 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
     }
 
     pub fn exec(ctx: Command::Context) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig `std.process.argsAlloc(ctx.allocator)[1..]` → collect
-        // process-static argv (already skips argv[0] internally? no — `Argv`
-        // includes argv[0]) into a borrowed-slice Vec so `&[&[u8]]` callers
-        // (TrustCommand/UntrustedCommand, `left_has_any_in_right`) keep their shape.
+        // `bun_core::argv()` includes argv[0]; skip it and collect into a
+        // borrowed-slice Vec so `&[&[u8]]` callers (TrustCommand/UntrustedCommand,
+        // `left_has_any_in_right`) keep their shape.
         let args_vec: Vec<&'static [u8]> = bun_core::argv().into_iter().skip(1).collect();
         let args: &[&[u8]] = &args_vec;
 
@@ -228,17 +223,16 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
                 return Err(err);
             }
         };
-        // PORT NOTE: `defer ctx.allocator.free(cwd)` — `cwd: Box<[u8]>` drops at scope exit.
 
-        // PORT NOTE: reshaped for borrowck — `pm: &mut PackageManager`;
-        // many Zig call sites alias `pm` and `pm.lockfile` simultaneously. Hold a
-        // raw pointer for those re-entry points (Zig's `*PackageManager` is raw).
+        // Reshaped for borrowck — `pm: &mut PackageManager`;
+        // several call sites need `pm` and `pm.lockfile` simultaneously. Hold a
+        // raw pointer for those re-entry points.
         let pm_ptr: *mut PackageManager = pm;
 
         let mut subcommand: &[u8] = if is_direct_whoami {
             b"whoami"
         } else {
-            // PORT NOTE: Zig `getSubcommand(&pm.options.positionals)` defer-writes the
+            // `get_subcommand` writes the
             // advanced slice back into the field; downstream branches (cache rm, view,
             // version/why/pkg) index `positionals[1]/[2]` *after* that advance. Pass the
             // field itself by `&mut` so the reslice persists.
@@ -316,8 +310,7 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
                 'warner: {
                     if Output::enable_ansi_colors_stderr() {
                         if let Some(path) = env_var::PATH.get() {
-                            // PORT NOTE: `std.mem.tokenizeScalar` skips empty
-                            // segments; mirror with `split` + `filter`.
+                            // skip empty segments
                             let mut path_iter = path
                                 .split(|b| *b == bun_paths::DELIMITER)
                                 .filter(|s| !s.is_empty());
@@ -578,8 +571,7 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
                     dependencies,
                     buf: string_bytes,
                 };
-                // PERF(port): Zig `std.sort.pdq` (unstable pdqsort) — Rust
-                // `sort_unstable_by` is the matching pdqsort; names are
+                // `sort_unstable_by` is pdqsort; names are
                 // unique so stability is irrelevant.
                 sorted_dependencies.sort_unstable_by(|a, b| by_name.cmp(*a, *b));
 
@@ -629,8 +621,8 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
                 }
             }
             let log_level = pm.options.log_level;
-            // PORT NOTE: reshaped for borrowck — Zig
-            // `migration.detectAndLoadOtherLockfile(&pm.lockfile, .cwd(), pm, ctx.log)`
+            // Reshaped for borrowck —
+            // `detect_and_load_other_lockfile(&pm.lockfile, .cwd(), pm, ctx.log)`
             // is a self-referential split borrow. Derive both halves through
             // `pm` (not the raw `pm_ptr`) so the outer borrow stays on the
             // Stacked-Borrows stack.
@@ -655,7 +647,7 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
                 Global::exit(1);
             }
             Self::handle_load_lockfile_errors(&load_lockfile, log_level);
-            // PORT NOTE: reshaped for borrowck — `save_to_disk` needs
+            // Reshaped for borrowck — `save_to_disk` needs
             // `&mut Lockfile` (self) and `&LoadResult` simultaneously, but
             // `LoadResultOk.lockfile` already holds the only `&mut` into the
             // boxed lockfile. Project that field to a raw pointer (no second
@@ -672,8 +664,6 @@ Learn more about these at <magenta>https://bun.com/docs/cli/pm<r>.\n";
             }
             Global::exit(0);
         } else if strings::eql_comptime(subcommand, b"version") {
-            // PORT NOTE: `pm.options.positionals: &'static [&'static [u8]]`
-            // coerces to `&[&[u8]]` (covariant in both lifetimes).
             let positionals: &[&[u8]] = pm.options.positionals;
             PmVersionCommand::exec(ctx, pm, positionals, &cwd)?;
             Global::exit(0);
@@ -711,7 +701,6 @@ fn print_node_modules_folder_structure(
     lockfile: &Lockfile,
     more_packages: &mut [bool],
 ) -> Result<(), bun_core::Error> {
-    // PORT NOTE: `lockfile.allocator` dropped — global mimalloc.
     let resolutions = lockfile.packages.items_resolution();
     let string_bytes = lockfile.buffers.string_bytes.as_slice();
 
@@ -783,8 +772,7 @@ fn print_node_modules_folder_structure(
         dependencies,
         buf: string_bytes,
     };
-    // PERF(port): Zig `std.sort.pdq` (unstable pdqsort) — Rust
-    // `sort_unstable_by` is the matching pdqsort; names are unique so
+    // `sort_unstable_by` is pdqsort; names are unique so
     // stability is irrelevant.
     sorted_dependencies.sort_unstable_by(|a, b| by_name.cmp(*a, *b));
 
@@ -887,5 +875,3 @@ fn print_node_modules_folder_structure(
 }
 
 use bun_core::fmt::buf_print_infallible as buf_print;
-
-// ported from: src/cli/package_manager_command.zig
diff --git a/src/runtime/cli/patch_command.rs b/src/runtime/cli/patch_command.rs
index 8756a2f0e5d..9a2e329d817 100644
--- a/src/runtime/cli/patch_command.rs
+++ b/src/runtime/cli/patch_command.rs
@@ -13,5 +13,3 @@ impl PatchCommand {
         Ok(())
     }
 }
-
-// ported from: src/cli/patch_command.zig
diff --git a/src/runtime/cli/patch_commit_command.rs b/src/runtime/cli/patch_commit_command.rs
index 3478d5b0a9e..a279e16dff6 100644
--- a/src/runtime/cli/patch_commit_command.rs
+++ b/src/runtime/cli/patch_commit_command.rs
@@ -10,5 +10,3 @@ impl PatchCommitCommand {
         Ok(())
     }
 }
-
-// ported from: src/cli/patch_commit_command.zig
diff --git a/src/runtime/cli/pm_pkg_command.rs b/src/runtime/cli/pm_pkg_command.rs
index e9a64800765..c7097e928da 100644
--- a/src/runtime/cli/pm_pkg_command.rs
+++ b/src/runtime/cli/pm_pkg_command.rs
@@ -89,7 +89,6 @@ impl PmPkgCommand {
                 "<r>"
             )
         ));
-        // Note: Zig `{{` / `}}` escapes are for std.fmt; Rust raw string keeps literal braces.
         const HELP_TEXT: &str = r#"  Manage data in package.json
 
 <b>Subcommands<r>:
@@ -155,16 +154,14 @@ impl PmPkgCommand {
         };
 
         let source = Source::init_path_string(path, &contents[..]);
-        // Zig passes the global allocator; use the process-lifetime CLI arena
+        // Use the process-lifetime CLI arena
         // so the returned `Expr` (which may reference arena-owned nodes)
         // outlives this frame. CLI is one-shot.
         let bump: &'static bun_alloc::Arena = crate::cli::cli_arena();
         // SAFETY: CLI dispatch is single-threaded; no other borrow of
         // `ctx.log` is live while `log` is passed to the JSON parser below.
         let log: &mut Log = unsafe { ctx.log_mut() };
-        // const generics mirror Zig `.{ .is_json, .allow_comments,
-        // .allow_trailing_commas, .guess_indentation = true }` with the
-        // remaining JSONOptions fields at their defaults (false).
+        // The remaining JSONOptions fields are at their defaults (false).
         let result = match json::parse_package_json_utf8_with_opts::<
             true,  // IS_JSON
             true,  // ALLOW_COMMENTS
@@ -574,7 +571,6 @@ impl PmPkgCommand {
 
     fn parse_key_path(key: &[u8]) -> Result<Vec<Box<[u8]>>, Error> {
         let mut path_parts: Vec<Box<[u8]>> = Vec::new();
-        // errdefer freeing is implicit via Drop on Vec<Box<[u8]>>
 
         let mut parts = key.split(|b| *b == b'.').filter(|s| !s.is_empty());
 
@@ -658,9 +654,6 @@ impl PmPkgCommand {
                 .unwrap()
                 .put(dummy_bump(), &path_parts[0], expr)?;
 
-            // PORT NOTE: Zig's `path_parts[0] = ""` here was an ownership-transfer hack to neuter
-            // the caller's `defer allocator.free(part)`. That defer is gone (Vec<Box<[u8]>> drops
-            // its elements), so the assignment is deleted.
             return Ok(());
         }
 
@@ -724,11 +717,6 @@ impl PmPkgCommand {
             return Ok(());
         }
 
-        // PORT NOTE: Zig's `path[0] = ""` writes were an ownership-transfer hack to neuter the
-        // caller's `defer allocator.free(part)` (manual move semantics). In Zig, `current_key`
-        // is a VALUE copy of the slice descriptor taken before the clear, so `root.get(current_key)`
-        // still sees the original key. That defer is gone in Rust (Drop handles it), so the
-        // clears are deleted and `path` no longer needs interior mutation here.
         let (head, remaining_path) = path.split_first_mut().unwrap();
         let current_key: &[u8] = head;
 
@@ -887,8 +875,7 @@ impl PmPkgCommand {
             return Ok(false);
         }
         let old_len = old_props.len();
-        // G::Property is !Copy/!Clone in Rust. Zig bitwise-copies each kept
-        // entry and leaves the old buffer to the arena. Mirror that: take the
+        // G::Property is !Copy/!Clone: take the
         // old list, ptr::read kept entries into the new list, then forget the
         // old buffer (CLI is one-shot — leak is intentional, see
         // load_package_json).
@@ -903,7 +890,7 @@ impl PmPkgCommand {
                 }
             }
             // SAFETY: `old` is wrapped in `ManuallyDrop` so each Property is
-            // moved (not duplicated) into `new_props`, matching Zig's value-copy loop.
+            // moved (not duplicated) into `new_props`.
             new_props.append_assume_capacity(unsafe { core::ptr::read(prop) });
         }
         e_obj.properties = new_props;
@@ -954,5 +941,3 @@ impl PmPkgCommand {
 // ───── helpers ────────────────────────────────────────────────────────────
 
 use bun_core::fmt::parse_f64;
-
-// ported from: src/cli/pm_pkg_command.zig
diff --git a/src/runtime/cli/pm_trusted_command.rs b/src/runtime/cli/pm_trusted_command.rs
index 1c887a9dbdd..2ae5568da93 100644
--- a/src/runtime/cli/pm_trusted_command.rs
+++ b/src/runtime/cli/pm_trusted_command.rs
@@ -56,7 +56,7 @@ impl UntrustedCommand {
         );
         Output::flush();
 
-        // PORT NOTE: reshaped for borrowck — `LoadResult` returned by
+        // Reshaped for borrowck — `LoadResult` returned by
         // `load_lockfile_from_cwd` mutably borrows `pm.lockfile`, so all
         // subsequent `pm` access goes through `pm_raw`. Same singleton pattern
         // as `package_manager_command.rs::print_hash`.
@@ -116,8 +116,8 @@ impl UntrustedCommand {
         let mut node_modules_path = AutoAbsPath::init_top_level_dir();
 
         while let Some(node_modules) = tree_iterator.next(None) {
-            // PORT NOTE: Zig `node_modules_path.save()/.restore()` — `ResetScope`
-            // exclusively borrows the path in Rust, so save/restore the length
+            // `ResetScope`
+            // exclusively borrows the path, so save/restore the length
             // explicitly. Restored at end of each iteration; the inner-loop
             // `continue`/`return` paths only need the inner `folder_saved`
             // restore (done immediately after `get_list`).
@@ -207,7 +207,7 @@ impl UntrustedCommand {
 
 pub(crate) struct TrustCommand;
 
-/// Anonymous struct from Zig: value type stored in `scripts_at_depth`.
+/// Value type stored in `scripts_at_depth`.
 struct ScriptInfo {
     package_id: PackageID,
     scripts_list: ScriptsList,
@@ -256,14 +256,14 @@ impl TrustCommand {
             Self::error_expected_args();
         }
 
-        // PORT NOTE: reshaped for borrowck — see `UntrustedCommand::exec`.
+        // Reshaped for borrowck — see `UntrustedCommand::exec`.
         // `load_lockfile` lives until `save_to_disk` near the end, so every
         // `pm`/`pm.lockfile` access in between goes through `pm_raw`.
         let pm_raw: *mut PackageManager = pm;
         let log_level = pm.options.log_level;
         let load_lockfile = pm.load_lockfile_from_cwd::<true>();
         PackageManagerCommand::handle_load_lockfile_errors(&load_lockfile, log_level);
-        // PORT NOTE: `update_lockfile_if_needed` consumes `LoadResult` but we
+        // `update_lockfile_if_needed` consumes `LoadResult` but we
         // need it again for `save_to_disk`; inline the body (it only flips
         // `meta.has_install_script` when `packages_need_update`).
         if matches!(&load_lockfile, LoadResult::Ok(ok) if ok.serializer_result.packages_need_update)
@@ -280,7 +280,6 @@ impl TrustCommand {
         for arg in &args[2..] {
             if !arg.is_empty() && arg[0] != b'-' {
                 packages_to_trust.push(arg);
-                // PERF(port): was appendAssumeCapacity.
             }
         }
         let trust_all =
@@ -461,10 +460,10 @@ impl TrustCommand {
             }
         }
 
-        // PORT NOTE: `scripts_at_depth.values()` is taken twice (run, then
-        // print). Rust can't move `scripts_list: List` out for
+        // `scripts_at_depth.values()` is taken twice (run, then
+        // print). We can't move `scripts_list: List` out for
         // `spawn_package_lifecycle_scripts` and still print it later, so clone
-        // the `List` per spawn (matches the by-value Zig pass).
+        // the `List` per spawn.
         for entry in scripts_at_depth.values().iter().rev() {
             for info in entry.iter() {
                 if info.skip {
@@ -539,7 +538,7 @@ impl TrustCommand {
 
         // SAFETY: `pm_raw` singleton; this scope takes over the descriptor
         // (the original `pm.root_package_json_file` is replaced with INVALID so
-        // its eventual drop is a no-op). Matches Zig's by-value `File` move.
+        // its eventual drop is a no-op).
         let root_file = unsafe {
             let fd = (*pm_raw).root_package_json_file.handle;
             (*pm_raw).root_package_json_file.handle = bun_core::Fd::INVALID;
@@ -556,7 +555,7 @@ impl TrustCommand {
 
         let bump = Bump::new();
         // SAFETY: `ctx.log` set by `Command::init`, non-null for the command.
-        // PORT NOTE (layering): `parse_utf8` returns the T2
+        // Layering: `parse_utf8` returns the T2
         // `bun_ast::Expr`; `PackageJSONEditor` and
         // `js_printer::print_json` consume the T4 `bun_ast::Expr`. Lift
         // once via `From<T2> for T4` (same as `updatePackageJSONAndInstall` /
@@ -636,7 +635,7 @@ impl TrustCommand {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — `save_to_disk` needs `&mut Lockfile`
+        // Reshaped for borrowck — `save_to_disk` needs `&mut Lockfile`
         // and `&LoadResult` simultaneously, but `LoadResultOk.lockfile` already
         // holds the only `&mut`. Same projection pattern as `migrate` in
         // `package_manager_command.rs`.
@@ -710,5 +709,3 @@ impl TrustCommand {
         Ok(())
     }
 }
-
-// ported from: src/cli/pm_trusted_command.zig
diff --git a/src/runtime/cli/pm_update_package_json.rs b/src/runtime/cli/pm_update_package_json.rs
index 2c4d02a8da1..a14d7e37f4a 100644
--- a/src/runtime/cli/pm_update_package_json.rs
+++ b/src/runtime/cli/pm_update_package_json.rs
@@ -1,10 +1,9 @@
 //! MOVE_UP from `bun_install::package_manager::update_package_json_and_install`.
 //!
-//! Zig's `updatePackageJSONAndInstall` (.zig L680-730) lives entirely in
-//! `bun_install`, but its `cli.analyze` branch constructs a
-//! `bun.bundle_v2.BundleV2.DependenciesScanner` and calls
-//! `bun.cli.BuildCommand.exec` — both of which are higher-tier than
-//! `bun_install` in the Rust crate graph (`bun_runtime` → `bun_install`;
+//! `update_package_json_and_install`'s `cli.analyze` branch constructs a
+//! `DependenciesScanner` and calls
+//! `BuildCommand::exec` — both of which are higher-tier than
+//! `bun_install` in the crate graph (`bun_runtime` → `bun_install`;
 //! `bun_runtime` → `bun_bundler`; `bun_install` ↛ `bun_bundler`). The analyze
 //! branch and the `Cli.log_` access in the catch wrapper are therefore hosted
 //! here, and the crate-local body re-enters `bun_install` via the public
@@ -23,7 +22,6 @@ pub fn update_package_json_and_install_catch_error(
     ctx: Context,
     subcommand: Subcommand,
 ) -> Result<(), Error> {
-    // TODO(port): narrow error set
     match update_package_json_and_install(ctx, subcommand) {
         Ok(()) => Ok(()),
         Err(e) if e == err!("InstallFailed") || e == err!("InvalidPackageJSON") => {
@@ -40,9 +38,7 @@ pub fn update_package_json_and_install_catch_error(
 }
 
 pub fn update_package_json_and_install(ctx: Context, subcommand: Subcommand) -> Result<(), Error> {
-    // TODO(port): narrow error set
-    // PERF(port): Zig used `switch (subcommand) { inline else => |cmd| ... }` to monomorphize
-    // `CommandLineArguments.parse` per subcommand. Calling with runtime `subcommand` here; if
+    // Calling with runtime `subcommand` here; if
     // `parse` requires `<const CMD: Subcommand>`, expand to a `match`.
     let mut cli = CommandLineArguments::parse(subcommand)?;
 
@@ -52,8 +48,7 @@ pub fn update_package_json_and_install(ctx: Context, subcommand: Subcommand) ->
     //    typing in the dependency names
     // 3. Run the install command
     if cli.analyze {
-        // PORT NOTE: hoisted from Zig fn-local `const Analyzer = struct {...}`.
-        // `ctx`/`cli` are stored as raw `*mut` (Zig: freely-aliasing `*T`) because
+        // `ctx`/`cli` are stored as raw `*mut` because
         // `BuildCommand::exec` holds `command::get()` (the same `ContextData`) across
         // the `on_fetch` callback, and `DependenciesScanner.entry_points` owns a copy
         // of `cli.positionals[1..]` for the duration of the scan; storing `&mut` here
@@ -71,10 +66,9 @@ pub fn update_package_json_and_install(ctx: Context, subcommand: Subcommand) ->
                 let this = self;
                 // TODO: add separate argument that makes it so positionals[1..] is not done and instead the positionals are passed
                 //
-                // Process-lifetime storage for the rewritten positionals. Zig:
-                // `bun.default_allocator.alloc(string, keys.len + 1)` with no matching
-                // free — `Global::exit(0)` follows immediately. `OnceLock` (not
-                // leaked) per PORTING.md §Forbidden.
+                // Process-lifetime storage for the rewritten positionals —
+                // `Global::exit(0)` follows immediately. `OnceLock` (not
+                // leaked).
                 static OWNED_KEYS: std::sync::OnceLock<Vec<Box<[u8]>>> = std::sync::OnceLock::new();
                 static POSITIONALS: std::sync::OnceLock<Vec<&'static [u8]>> =
                     std::sync::OnceLock::new();
@@ -116,8 +110,8 @@ pub fn update_package_json_and_install(ctx: Context, subcommand: Subcommand) ->
             }
         }
 
-        // PORT NOTE: `DependenciesScanner.entry_points` is `Box<[Box<[u8]>]>`; Zig
-        // borrowed `cli.positionals[1..]` directly. Clone the argv slices into an owned
+        // Note: `DependenciesScanner.entry_points` is `Box<[Box<[u8]>]>`.
+        // Clone the argv slices into an owned
         // buffer (small one-shot list — no perf concern) so `cli` is not borrowed across
         // the `&mut analyzer` setup.
         let entry_points: Box<[Box<[u8]>]> = cli.positionals[1..]
@@ -140,5 +134,3 @@ pub fn update_package_json_and_install(ctx: Context, subcommand: Subcommand) ->
 
     update_package_json_and_install_and_cli(ctx, subcommand, cli)
 }
-
-// ported from: src/install/PackageManager/updatePackageJSONAndInstall.zig
diff --git a/src/runtime/cli/pm_version_command.rs b/src/runtime/cli/pm_version_command.rs
index 9e470d77f13..2a968b2a061 100644
--- a/src/runtime/cli/pm_version_command.rs
+++ b/src/runtime/cli/pm_version_command.rs
@@ -73,7 +73,6 @@ impl PmVersionCommand {
         positionals: &[&[u8]],
         original_cwd: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let package_json_dir = Self::find_package_dir(original_cwd)?;
 
         if positionals.len() <= 1 {
@@ -105,8 +104,7 @@ impl PmVersionCommand {
             package_json_path.as_bytes(),
             &*package_json_contents,
         );
-        // PORT NOTE: Zig passed `ctx.allocator`; Rust ctx dropped allocator (global mimalloc),
-        // so we hand the parser a local bump arena for its scratch allocations.
+        // Hand the parser a local bump arena for its scratch allocations.
         let json_bump = Arena::new();
         let json_result = match JSON::parse_package_json_utf8_with_opts::<
             true,  // IS_JSON
@@ -227,7 +225,6 @@ impl PmVersionCommand {
                 Global::exit(1);
             }
 
-            // Zig used `std.fs.cwd().writeFile`; ported to bun_sys (no std::fs).
             if let Err(err) = bun_sys::File::write_file(
                 Fd::cwd(),
                 package_json_path,
@@ -346,8 +343,7 @@ impl PmVersionCommand {
     }
 
     fn get_current_version(ctx: &command::ContextData, cwd: &[u8]) -> Option<Vec<u8>> {
-        // PORT NOTE: reshaped — Zig returned a slice borrowing from ctx.allocator-owned
-        // package.json bytes (leaked for process lifetime). Return owned Vec<u8> instead.
+        // Returns an owned Vec<u8> (no borrow of the package.json bytes).
         let mut path_buf = PathBuffer::uninit();
         let package_json_path = path::join_abs_string_buf_z::<path_platform::Auto>(
             cwd,
@@ -842,7 +838,6 @@ impl PmVersionCommand {
         }
 
         let commit_message: Vec<u8> = if let Some(msg) = custom_message {
-            // std.mem.replaceOwned(u8, allocator, msg, "%s", version)
             msg.replace(b"%s", version)
         } else {
             fmt_bytes(format_args!("v{}", BStr::new(version)))
@@ -924,7 +919,7 @@ impl PmVersionCommand {
     }
 }
 
-// PORT NOTE: helper for `std.fmt.allocPrint` — builds into Vec<u8> (never `format!`).
+// Builds formatted output into a `Vec<u8>` (never `format!`).
 #[inline]
 fn fmt_bytes(args: core::fmt::Arguments<'_>) -> Vec<u8> {
     let mut v = Vec::new();
@@ -932,8 +927,8 @@ fn fmt_bytes(args: core::fmt::Arguments<'_>) -> Vec<u8> {
     v
 }
 
-// PORT NOTE: build `sync::Options.argv: Vec<Box<[u8]>>` from a slice of byte
-// slices (Zig was `&.{...}` of `[]const u8`).
+// Note: build `sync::Options.argv: Vec<Box<[u8]>>` from a slice of byte
+// slices.
 #[inline]
 fn build_argv(parts: &[&[u8]]) -> Vec<Box<[u8]>> {
     parts.iter().map(|p| Box::<[u8]>::from(*p)).collect()
@@ -949,5 +944,3 @@ fn spawn_windows_options() -> crate::api::bun::process::WindowsOptions {
         ..Default::default()
     }
 }
-
-// ported from: src/cli/pm_version_command.zig
diff --git a/src/runtime/cli/pm_view_command.rs b/src/runtime/cli/pm_view_command.rs
index a9ddd56f2bc..5ddadde3b6f 100644
--- a/src/runtime/cli/pm_view_command.rs
+++ b/src/runtime/cli/pm_view_command.rs
@@ -24,13 +24,12 @@ pub(crate) fn view(
     property_path: Option<&[u8]>,
     json_output: bool,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let bump = Bump::new();
     let (name, mut version) = dependency::split_name_and_version_or_latest('brk: {
         // Extremely best effort.
         if spec_ == b"." || spec_ == b"" {
             if strings::is_npm_package_name(&manager.root_package_json_name_at_time_of_init) {
-                // PORT NOTE: reshaped for borrowck — copy into the function-scope
+                // Note: reshaped for borrowck — copy into the function-scope
                 // bump so `name` doesn't keep `manager` borrowed across the
                 // `&mut self` calls (`http_proxy`, `tls_reject_unauthorized`) below.
                 break 'brk &*bump
@@ -40,8 +39,7 @@ pub(crate) fn view(
             // Try our best to get the package.json name they meant
             'from_package_json: {
                 // `root_dir` is set once by `PackageManager::init()` and points
-                // into the resolver's directory cache for the process lifetime;
-                // mirrors Zig's non-optional `*DirEntry` field.
+                // into the resolver's directory cache for the process lifetime.
                 if !manager.root_dir.has_comptime_query(b"package.json") {
                     break 'from_package_json;
                 }
@@ -53,8 +51,8 @@ pub(crate) fn view(
                     Ok(s) => s,
                     Err(_) => break 'from_package_json,
                 };
-                // PORT NOTE: copy into the function-scope bump so the slice
-                // outlives this block (Zig never frees this allocation either).
+                // Note: copy into the function-scope bump so the slice
+                // outlives this block.
                 let str: &[u8] = bump.alloc_slice_copy(&str);
                 let source = &bun_ast::Source::init_path_string(b"package.json", str);
                 let mut pkg_log = bun_ast::Log::init();
@@ -74,7 +72,7 @@ pub(crate) fn view(
         break 'brk spec_;
     });
 
-    // PORT NOTE: reshaped for borrowck — clone the registry scope so it doesn't
+    // Note: reshaped for borrowck — clone the registry scope so it doesn't
     // keep `manager` borrowed across `http_proxy` / `tls_reject_unauthorized`
     // (`&mut self`) below; matches `outdated_command` / `update_interactive_command`.
     let scope = manager.scope_for_package_name(name).clone();
@@ -188,7 +186,7 @@ pub(crate) fn view(
 
     let versions_len: usize;
 
-    // PORT NOTE: reshaped for borrowck — Zig used a labeled block returning a tuple to reassign (version, manifest)
+    // Note: reshaped for borrowck.
     'brk: {
         'from_versions: {
             if let Some(versions_obj) = json.get_object(b"versions") {
@@ -205,7 +203,7 @@ pub(crate) fn view(
                     if let Some(result) = parsed_manifest.find_by_dist_tag(version) {
                         break 'brk2 result.version;
                     } else {
-                        // Parse as semver query and find best version - exactly like outdated_command.zig line 325
+                        // Parse as semver query and find best version
                         let sliced_literal = Semver::SlicedString::init(version, version);
                         let query = Semver::query::parse(version, sliced_literal)?;
                         // `defer query.deinit()` — handled by Drop
@@ -576,5 +574,3 @@ pub(crate) fn view(
 
     Ok(())
 }
-
-// ported from: src/cli/pm_view_command.zig
diff --git a/src/runtime/cli/pm_why_command.rs b/src/runtime/cli/pm_why_command.rs
index 6073207bdc3..074cba18bef 100644
--- a/src/runtime/cli/pm_why_command.rs
+++ b/src/runtime/cli/pm_why_command.rs
@@ -5,14 +5,12 @@ use bun_install::PackageManager;
 pub(crate) struct PmWhyCommand;
 
 impl PmWhyCommand {
-    // TODO(port): narrow error set
     pub(crate) fn exec(
         _ctx: &command::Context,
         pm: &mut PackageManager,
         positionals: &[&[u8]],
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: Zig `Command.Context` is `*ContextData` (a freely-aliased
-        // raw pointer). `bun pm` dispatch threads it here as `&Command::Context`,
+        // Note: `bun pm` dispatch threads the context here as `&Command::Context`,
         // but `WhyCommand::exec_from_pm` needs `&mut Command::Context` to reach
         // `ctx.log`. Reacquire the process-global handle (same pointee,
         // single-threaded CLI startup) rather than unsafely reborrowing `_ctx`.
@@ -21,5 +19,3 @@ impl PmWhyCommand {
         Ok(())
     }
 }
-
-// ported from: src/cli/pm_why_command.zig
diff --git a/src/runtime/cli/publish_command.rs b/src/runtime/cli/publish_command.rs
index 5146ba531f2..715699dbf4b 100644
--- a/src/runtime/cli/publish_command.rs
+++ b/src/runtime/cli/publish_command.rs
@@ -89,9 +89,8 @@ type SHA512Digest = [u8; sha::SHA512::DIGEST];
 
 pub(crate) struct PublishCommand;
 
-// TODO(port): Zig used `if (directory_publish) ?[]const u8 else void` for the script fields
-// and `if (directory_publish) *DotEnv.Loader else void` for script_env. Rust const generics
-// cannot vary field types; we keep them as Option<> in both instantiations and rely on
+// Const generics cannot vary field types; the script fields and script_env are
+// kept as Option<> in both instantiations and we rely on
 // invariants (always None / never used when DIRECTORY_PUBLISH == false).
 pub struct Context<'a, const DIRECTORY_PUBLISH: bool> {
     pub manager: &'a mut PackageManager,
@@ -325,9 +324,9 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
         let package_json_contents =
             maybe_package_json_contents.ok_or(FromTarballError::MissingPackageJSON)?;
 
-        // PORT NOTE: adopt `package_json_contents` (already an owned `Box<[u8]>`)
+        // Note: adopt `package_json_contents` (already an owned `Box<[u8]>`)
         // into the process-lifetime side-table so the `Source` borrow stays
-        // alive across `normalized_package` (Zig held an arena slice). Zero-copy.
+        // alive across `normalized_package`. Zero-copy.
         let package_json_contents: &'static [u8] = crate::cli::cli_adopt(package_json_contents);
 
         let bump = bun_alloc::Arena::new();
@@ -355,7 +354,7 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
             if let Some(config) = json.get(b"publishConfig") {
                 if manager.options.publish_config.tag.is_empty() {
                     if let Some(tag) = json_get_string_cloned(&config, &bump, b"tag")? {
-                        // PORT NOTE: `PublishConfig.tag` is `&'static [u8]`; dupe the
+                        // Note: `PublishConfig.tag` is `&'static [u8]`; dupe the
                         // bump-owned slice into the process-lifetime CLI arena.
                         manager.options.publish_config.tag = crate::cli::cli_dupe(tag);
                     }
@@ -456,11 +455,8 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
 
     /// `bun publish` without a tarball path. Automatically pack the current workspace and get
     /// information required for publishing
-    // PORT NOTE: Zig declares this on the comptime-generic `Context(directory_publish)`
-    // but only ever instantiates it as `Context(true).fromWorkspace`; lazy comptime
-    // evaluation hid the `pack(true) -> Context(true)` mismatch for the unused
-    // `false` branch. Rust type-checks all monomorphisations, so pin the return
-    // type to the only valid shape. `'static` matches `pack::pack`'s return —
+    // Note: the return type is pinned to `Context<'static, true>`, the only
+    // valid shape. `'static` matches `pack::pack`'s return —
     // the embedded `&mut PackageManager` / `Command::Context` are process-
     // lifetime singletons reborrowed through raw pointers there.
     pub fn from_workspace(
@@ -471,8 +467,8 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
         let manager_ptr: *mut PackageManager = manager;
         let log: &mut bun_ast::Log = manager.log_mut();
         // SAFETY: `manager_ptr` was just derived from `manager: &'a mut PackageManager`;
-        // `log` borrows the disjoint `.log` field, so the aliased `&mut` here mirrors
-        // Zig's freely-aliased `*PackageManager`.
+        // `log` borrows the disjoint `.log` field, so the re-derived `&mut`
+        // never touches memory the live `log` borrow covers.
         let load_from_disk_result =
             lockfile.load_from_cwd::<false>(Some(unsafe { &mut *manager_ptr }), log);
 
@@ -509,7 +505,7 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
             }
         };
 
-        // PORT NOTE: capture the package.json path before constructing
+        // Note: capture the package.json path before constructing
         // `pack::Context` so the `&mut PackageManager` borrow doesn't conflict.
         // SAFETY: `manager_ptr` came from `&'a mut PackageManager`.
         let abs_pkg_json = bun_core::ZBox::from_bytes(
@@ -519,9 +515,9 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
         );
 
         let mut pack_ctx = pack::Context {
-            // SAFETY: `manager_ptr` came from `&'a mut PackageManager`; the
-            // overlapping borrow with `lockfile_ref` mirrors Zig's freely-
-            // aliased `*PackageManager`.
+            // SAFETY: `manager_ptr` came from `&'a mut PackageManager`;
+            // `lockfile_ref` borrows the local `lockfile`, not the manager,
+            // so the re-derived `&mut` is the only live manager borrow.
             manager: unsafe { &mut *manager_ptr },
             command_ctx: ctx,
             lockfile: lockfile_ref,
@@ -537,7 +533,6 @@ impl<'a, const DIRECTORY_PUBLISH: bool> Context<'a, DIRECTORY_PUBLISH> {
 
 impl PublishCommand {
     pub(crate) fn exec(ctx: Command::Context) -> Result<(), Error> {
-        // TODO(port): narrow error set
         bun_core::prettyln!(
             "<r><b>bun publish <r><d>v{}<r>",
             Global::package_json_version_with_sha,
@@ -719,10 +714,9 @@ impl PublishCommand {
                 .put(b"npm_command", b"publish")
                 .map_err(|_| err!(OutOfMemory))?;
 
-            // PORT NOTE: reshaped for borrowck — `command_ctx: &mut ContextData`
+            // Note: reshaped for borrowck — `command_ctx: &mut ContextData`
             // is held by `context`; `run_package_script_foreground` needs
-            // `&mut ContextData` too. Re-derive from the raw pointer (mirrors
-            // Zig's freely-aliased `Command.Context`).
+            // `&mut ContextData` too. Re-derive from the raw pointer.
             let cmd_ctx_ptr: *mut crate::cli::command::ContextData = context.command_ctx;
 
             if let Some(publish_script) = &context.publish_script {
@@ -798,9 +792,8 @@ impl PublishCommand {
             return false;
         }
 
-        // PORT NOTE: `URL::parse` borrows; dupe into the process-lifetime CLI
-        // arena so the URL outlives the local Vec (mirrors `allocPrint`
-        // ownership in the Zig spec).
+        // Note: `URL::parse` borrows; dupe into the process-lifetime CLI
+        // arena so the URL outlives the local Vec.
         let package_url = URL::parse(crate::cli::cli_dupe(&url_buf));
 
         let Ok(mut response_buf) = MutableString::init(1024) else {
@@ -931,8 +924,8 @@ impl PublishCommand {
             return Ok(());
         }
 
-        // PORT NOTE: `AsyncHTTP::init_sync` requires `&'static [u8]` for the
-        // request body (Zig had no lifetimes). Single-shot CLI path — adopt the
+        // Note: `AsyncHTTP::init_sync` requires `&'static [u8]` for the
+        // request body. Single-shot CLI path — adopt the
         // already-owned `Box<[u8]>` (base64-encoded tarball; can be multi-MB)
         // into the process-lifetime side-table. Zero-copy.
         let publish_req_body: &'static [u8] = crate::cli::cli_adopt(
@@ -963,9 +956,8 @@ impl PublishCommand {
             bun_fmt::dependency_url(&ctx.package_name),
         )
         .map_err(|_| AllocError)?;
-        // PORT NOTE: `URL::parse` borrows; dupe into the process-lifetime CLI
-        // arena so the URL outlives `print_buf.clear()` below (Zig's
-        // `allocPrint` owned its buffer).
+        // Note: `URL::parse` borrows; dupe into the process-lifetime CLI
+        // arena so the URL outlives `print_buf.clear()` below.
         let publish_url = URL::parse(crate::cli::cli_dupe(&print_buf));
         print_buf.clear();
 
@@ -1129,8 +1121,8 @@ impl PublishCommand {
             });
 
         loop {
-            // SAFETY: `buffered_stdin()` returns a process-global `*mut`; single-threaded
-            // access here mirrors Zig's `Output.buffered_stdin().reader()`.
+            // SAFETY: `buffered_stdin()` returns a process-global `*mut`; this
+            // loop is the only accessor while it runs (single-threaded CLI path).
             match unsafe { (*Output::buffered_stdin()).reader().read_byte() } {
                 Ok(b'\n') => break,
                 Ok(_) => continue,
@@ -1138,8 +1130,6 @@ impl PublishCommand {
             }
         }
 
-        // PORT NOTE: Zig used `std.process.Child.init(&.{Open.opener, auth_url})
-        // .spawnAndWait()`. Route through `bun.spawnSync` (PORTING.md §Spawning).
         let _ = spawn_sync::spawn(&spawn_sync::Options {
             argv: vec![Box::from(open::OPENER), Box::from(auth_url.as_bytes())],
             envp: None,
@@ -1177,7 +1167,7 @@ impl PublishCommand {
                 let Some(auth_url_str) = json_get_string_cloned(&json, &bump, b"authUrl")? else {
                     break 'try_web;
                 };
-                // PORT NOTE: bump-owned `&[u8]` — dupe into the process-lifetime
+                // Note: bump-owned `&[u8]` — dupe into the process-lifetime
                 // CLI arena so the spawned thread (which outlives `bump`) can
                 // borrow it `'static`.
                 let auth_url_str: &'static ZStr = {
@@ -1285,8 +1275,8 @@ impl PublishCommand {
                 loop {
                     response_buf.reset();
 
-                    // PORT NOTE: Zig copied `done_url`/`auth_headers.entries` by value each
-                    // loop turn; in Rust both move into `init_sync`, so re-clone per iteration.
+                    // Note: `done_url`/`auth_headers.entries` move into
+                    // `init_sync`, so re-clone per iteration.
                     let mut req = http::AsyncHTTP::init_sync(
                         http::Method::GET,
                         done_url.clone(),
@@ -1318,8 +1308,7 @@ impl PublishCommand {
                                     'default: {
                                         let trimmed =
                                             strings::trim(retry, &strings::WHITESPACE_CHARS);
-                                        // PORT NOTE: std.fmt.parseInt(u32, _, 10) — header value is bytes,
-                                        // not UTF-8; use the byte-slice parser per PORTING.md.
+                                        // Header value is bytes, not UTF-8; use the byte-slice parser.
                                         let Ok(seconds) = strings::parse_int::<u32>(trimmed, 10)
                                         else {
                                             break 'default;
@@ -1422,7 +1411,7 @@ impl PublishCommand {
         debug_assert!(json.is_object());
 
         let bump = bun_alloc::Arena::new();
-        // PORT NOTE: `E::String` stores `&'static [u8]` (lifetime erased per the
+        // Note: `E::String` stores `&'static [u8]` (lifetime erased per the
         // parser's Str convention); dupe formatted buffers into the
         // process-lifetime CLI arena so they outlive the AST nodes through printing.
         macro_rules! leak {
@@ -1605,7 +1594,7 @@ impl PublishCommand {
             if entry.kind == bun_sys::EntryKind::Directory {
                 continue;
             }
-            // Zig: `DirIterator.iterate(dir, .u8)` — entry names are UTF-8 on every platform.
+            // Entry names are UTF-8 on every platform.
             let name = entry.name.slice_u8();
             if !is_readme_filename(name) {
                 continue;
@@ -1629,7 +1618,7 @@ impl PublishCommand {
         package_name: &[u8],
         workspace_root: Fd,
     ) -> Result<(), AllocError> {
-        // PORT NOTE: see `normalized_package` — `E::String` stores
+        // Note: see `normalized_package` — `E::String` stores
         // `&'static [u8]` (lifetime erased per the parser's Str convention);
         // dupe into the process-lifetime CLI arena for buffers that flow into AST nodes.
         macro_rules! leak {
@@ -1825,7 +1814,7 @@ impl PublishCommand {
                     let mut iter = DirIterator::iterate(dir);
                     while let Some(entry) = iter.next().ok().flatten() {
                         let (name, subpath): (&'static ZStr, &'static ZStr) = {
-                            // Zig: `DirIterator.iterate(dir, .u8)` — UTF-8 entry name on every platform.
+                            // Entry names are UTF-8 on every platform.
                             let name = entry.name.slice_u8();
                             let mut join: Vec<u8> = Vec::new();
                             write!(
@@ -1839,7 +1828,6 @@ impl PublishCommand {
                             .map_err(|_| AllocError)?;
                             join.push(0);
                             let join_len = join.len() - 1;
-                            // PORT NOTE: reshaped for borrowck — Zig sliced into the same allocation for both name and subpath.
                             // Dupe into the process-lifetime CLI arena (bytes flow into long-lived `E::String` nodes).
                             let interned: &'static [u8] = crate::cli::cli_dupe(&join);
                             // SAFETY: NUL terminator at interned[join_len] (copied from `join`).
@@ -2134,5 +2122,3 @@ impl From<GetOTPError> for PublishError {
         PublishError::OutOfMemory
     }
 }
-
-// ported from: src/cli/publish_command.zig
diff --git a/src/runtime/cli/remove_command.rs b/src/runtime/cli/remove_command.rs
index 6c796433a82..100a85e2b8e 100644
--- a/src/runtime/cli/remove_command.rs
+++ b/src/runtime/cli/remove_command.rs
@@ -6,10 +6,7 @@ pub(crate) struct RemoveCommand;
 
 impl RemoveCommand {
     pub(crate) fn exec(ctx: Context) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         update_package_json_and_install_catch_error(ctx, Subcommand::Remove)?;
         Ok(())
     }
 }
-
-// ported from: src/cli/remove_command.zig
diff --git a/src/runtime/cli/repl.rs b/src/runtime/cli/repl.rs
index fc4edf35a19..26c98b7c558 100644
--- a/src/runtime/cli/repl.rs
+++ b/src/runtime/cli/repl.rs
@@ -33,7 +33,6 @@ use bun_sys::{self as sys, Fd};
 // C++ Bindings
 // ============================================================================
 
-// TODO(port): move to cli_sys / jsc_sys
 // NOTE: `globalObject` is `*const` here because `JSGlobalObject` is an opaque
 // FFI handle (zero Rust-visible bytes). All mutation happens on the C++ side;
 // Rust only ever holds `&JSGlobalObject`, so deriving a `*mut` from that shared
@@ -74,7 +73,6 @@ fn global_clear_exception(global: &JSGlobalObject) {
 
 #[inline]
 fn global_to_js_value(global: &JSGlobalObject) -> JSValue {
-    // Spec JSGlobalObject.zig `toJSValue` — `@enumFromInt(@intFromPtr(globalThis))`.
     JSValue::from_cell(std::ptr::from_ref::<JSGlobalObject>(global))
 }
 
@@ -89,16 +87,16 @@ fn vm_set_execution_forbidden(vm: *mut jsc::VM, forbidden: bool) {
 
 /// Reborrow `&VirtualMachine` as `&mut VirtualMachine`.
 ///
-/// SAFETY: The Zig spec passes `*JSC.VirtualMachine` (mutable, freely-aliasing)
-/// everywhere; `VirtualMachine` is single-threaded per JS thread and the REPL
-/// is the sole driver of `tick()` / `wait_for_promise()` here. The Rust port
-/// stores `&VirtualMachine` for borrowck simplicity and casts at the call site.
+/// SAFETY: `VirtualMachine` is single-threaded per JS thread and the REPL
+/// is the sole driver of `tick()` / `wait_for_promise()` here, so no other
+/// `&mut` to the VM can be live. We store `&VirtualMachine` for borrowck
+/// simplicity and cast at the call site.
 #[inline]
 #[allow(invalid_reference_casting, clippy::mut_from_ref)]
 fn vm_mut<'a>(vm: &'a VirtualMachine) -> &'a mut VirtualMachine {
     // Launder through a raw pointer; rustc's `invalid_reference_casting` lint is
-    // silenced above because the Zig spec's `*JSC.VirtualMachine` is a freely-
-    // aliasing mutable pointer and `VirtualMachine` is `!Sync` single-thread state.
+    // silenced above because `VirtualMachine` is `!Sync` single-thread state and
+    // the REPL is its sole driver here.
     let ptr: *mut VirtualMachine = core::ptr::from_ref(vm).cast_mut();
     // SAFETY: `ptr` is non-null and points to a live `VirtualMachine` (derived from
     // `&'a VirtualMachine`); the REPL is the sole driver on this single JS thread so
@@ -231,7 +229,6 @@ impl History {
     }
 
     pub(crate) fn load(&mut self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let Some(home_path) = env_var::HOME.get() else {
             return Ok(());
         };
@@ -861,7 +858,7 @@ pub(super) struct Repl<'a> {
     pub(super) global: Option<&'a JSGlobalObject>,
 
     // Special REPL variables
-    // PORT NOTE: bare JSValue fields are safe here because Repl is stack-allocated
+    // Note: bare JSValue fields are safe here because Repl is stack-allocated
     // and values are explicitly protect()/unprotect()'d.
     last_result: ProtectedJSValue,
     last_error: ProtectedJSValue,
@@ -983,7 +980,6 @@ impl<'a> Repl<'a> {
             let _ = tty::set_mode(0, tty::Mode::Normal);
 
             // Install SIGINT handler
-            // TODO(port): wrap std.posix.Sigaction in bun_sys
             // SAFETY: zeroed `sigaction` is a valid empty mask + null restorer; we set
             // sa_sigaction/sa_flags below. `act` is valid for the duration of the call.
             unsafe {
@@ -1275,7 +1271,7 @@ impl<'a> Repl<'a> {
             // Temporarily re-enable signal delivery so Ctrl+C can interrupt
             // the blocking waitForPromise call
             self.enable_signals_during_wait();
-            // PORT NOTE: reshaped for borrowck — call disable_signals_during_wait() explicitly on each return path below
+            // Note: reshaped for borrowck — call disable_signals_during_wait() explicitly on each return path below
 
             // Wait for the promise to settle
             vm_mut(vm).wait_for_promise(jsc::AnyPromise::Normal(promise));
@@ -1576,7 +1572,7 @@ impl<'a> Repl<'a> {
             // owning JSC VM handle for this thread.
             jsc::JSPromise::opaque_mut(promise).set_handled();
             self.enable_signals_during_wait();
-            // PORT NOTE: reshaped for borrowck — disable_signals_during_wait called on each path
+            // Note: reshaped for borrowck — disable_signals_during_wait called on each path
             vm_mut(vm).wait_for_promise(jsc::AnyPromise::Normal(promise));
             if vm.jsc_vm().execution_forbidden() {
                 vm_set_execution_forbidden(vm.jsc_vm, false);
@@ -1707,7 +1703,6 @@ impl<'a> Repl<'a> {
 
     /// Write text to clipboard using OSC 52 escape sequence.
     fn copy_to_clipboard_osc52(&self, text: &[u8]) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut it = strings::ANSIIterator::init(text);
         let Some(first) = it.next() else {
             return Ok(());
@@ -1722,10 +1717,8 @@ impl<'a> Repl<'a> {
         } else {
             // Has ANSI sequences - collect clean slices then encode
             let mut clean: Vec<u8> = Vec::with_capacity(text.len());
-            // PERF(port): was assume_capacity
             clean.extend_from_slice(first);
             while let Some(slice) = it.next() {
-                // PERF(port): was assume_capacity
                 clean.extend_from_slice(slice);
             }
             let encoded: Vec<u8> = bun_base64::encode_alloc(&clean);
@@ -1763,7 +1756,6 @@ impl<'a> Repl<'a> {
         };
 
         // Create arena for parsing
-        // PERF(port): was MimallocArena bulk-free — using bumpalo per AST-crate convention
         let arena = bun_alloc::Arena::new();
 
         // Set up parser options with repl_mode enabled
@@ -1776,15 +1768,14 @@ impl<'a> Repl<'a> {
         opts.features.top_level_await = true; // Enable top-level await in REPL
         // Keep `lower_using` at its default (true) here even though JavaScriptCore
         // supports `using` / `await using` natively. The REPL transform in
-        // `ast/repl_transforms.zig` rewrites every top-level `s_local` into a
+        // `js_parser/repl_transforms.rs` rewrites every top-level `s_local` into a
         // hoisted `var` + assignment for cross-input persistence, which would
         // silently discard disposal semantics if `using` declarations survived
         // until that pass. Lowering wraps the declaration in `try/finally` first,
         // which the REPL transform passes through intact.
 
-        // Initialize macro context from transpiler (required for import processing)
-        // PORT NOTE: Zig spec mutates `vm.transpiler` (`*Transpiler`) here; `vm`
-        // is `&VirtualMachine` in this port, so go through `vm_mut` (see its
+        // Initialize macro context from transpiler (required for import processing).
+        // Note: `vm` is `&VirtualMachine` here, so go through `vm_mut` (see its
         // SAFETY comment) to lazily seed the macro context.
         if vm.transpiler.macro_context.is_none() {
             vm_mut(vm).transpiler.macro_context = Some(bun_js_parser::Macro::MacroContext::init(
@@ -1829,10 +1820,8 @@ impl<'a> Repl<'a> {
         let mut buffer_printer = bun_js_printer::BufferPrinter::init(buffer_writer);
 
         // Create symbol map from ast.symbols
-        // PORT NOTE: Zig used `Symbol.NestedList.init(&.{ast.symbols})` (borrows
-        // a stack 1-slot slice). `Map::init_with_one_list` takes ownership of
-        // `ast.symbols` instead — see Symbol.rs PORT NOTE on the dangling-slice
-        // hazard.
+        // Note: `Map::init_with_one_list` takes ownership of `ast.symbols`
+        // — see Symbol.rs note on the dangling-slice hazard.
         let arena = *ast.symbols.allocator();
         let symbols_map = bun_ast::symbol::Map::init_with_one_list(
             core::mem::replace(&mut ast.symbols, bun_alloc::ArenaVec::new_in(arena))
@@ -1876,10 +1865,9 @@ impl<'a> Repl<'a> {
         writer: &mut bun_core::io::Writer,
         enable_colors: bool,
     ) {
-        // PORT NOTE: Zig writes straight through `*std.Io.Writer`. The Rust
-        // `bun_core::io::Writer` vtable doesn't implement `bun_io::Write`, so
-        // buffer through a `Vec<u8>` (which does) and flush in one shot — REPL
-        // error output is tiny.
+        // Note: the `bun_core::io::Writer` vtable doesn't implement
+        // `bun_io::Write`, so buffer through a `Vec<u8>` (which does) and
+        // flush in one shot — REPL error output is tiny.
         let Some(global) = self.global else {
             return;
         };
@@ -1916,7 +1904,7 @@ impl<'a> Repl<'a> {
             return;
         };
         let writer = Output::writer();
-        // PORT NOTE: see `print_js_error_to` — buffer because
+        // Note: see `print_js_error_to` — buffer because
         // `bun_core::io::Writer` doesn't implement `bun_io::Write`.
         let mut buf: Vec<u8> = Vec::new();
         if let Err(err) = jsc::ConsoleObject::format2(
@@ -1951,14 +1939,13 @@ impl<'a> Repl<'a> {
         &mut self,
         vm: Option<&'a VirtualMachine>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.vm = vm;
         if let Some(v) = vm {
             self.global = Some(v.global());
         }
 
         self.setup_terminal();
-        // PORT NOTE: defer self.restoreTerminal() — handled in Drop + explicit call at end
+        // Note: defer self.restoreTerminal() — handled in Drop + explicit call at end
 
         self.history.load()?;
 
@@ -1994,7 +1981,7 @@ impl<'a> Repl<'a> {
                     if self.editor_mode {
                         // Finish editor mode
                         self.print(format_args!("\n"));
-                        // PORT NOTE: reshaped for borrowck — clone editor_buffer slice before evaluate
+                        // Note: reshaped for borrowck — clone editor_buffer slice before evaluate
                         if !self.editor_buffer.is_empty() {
                             let code = core::mem::take(&mut self.editor_buffer);
                             self.evaluate_and_print(&code);
@@ -2069,7 +2056,7 @@ impl<'a> Repl<'a> {
                     self.refresh_line();
                 }
                 Key::ArrowUp | Key::CtrlP => {
-                    // PORT NOTE: reshaped for borrowck — copy line before mutating history
+                    // Note: reshaped for borrowck — copy line before mutating history
                     let cur = self.line_editor.get_line().to_vec();
                     if let Some(prev_line) = self.history.prev(&cur) {
                         let prev_line = prev_line.to_vec();
@@ -2109,10 +2096,9 @@ impl<'a> Repl<'a> {
     }
 
     fn handle_enter(&mut self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.print(format_args!("\n"));
 
-        // PORT NOTE: reshaped for borrowck — copy line out so we can call &mut self methods
+        // Note: reshaped for borrowck — copy line out so we can call &mut self methods
         let line: Vec<u8> = self.line_editor.get_line().to_vec();
 
         if self.editor_mode {
@@ -2248,7 +2234,7 @@ impl<'a> Repl<'a> {
     }
 
     fn handle_tab(&mut self) {
-        // PORT NOTE: reshaped for borrowck — copy line out
+        // Note: reshaped for borrowck — copy line out
         let line: Vec<u8> = self.line_editor.get_line().to_vec();
 
         // Complete REPL commands
@@ -2486,5 +2472,3 @@ fn is_incomplete_code(code: &[u8]) -> bool {
 use crate::api::js_transpiler::is_likely_object_literal;
 
 const VERSION: &str = Environment::VERSION_STRING;
-
-// ported from: src/cli/repl.zig
diff --git a/src/runtime/cli/repl_command.rs b/src/runtime/cli/repl_command.rs
index 468b9e0478d..9cc0e0f19db 100644
--- a/src/runtime/cli/repl_command.rs
+++ b/src/runtime/cli/repl_command.rs
@@ -33,8 +33,6 @@ pub(crate) struct ReplCommand;
 impl ReplCommand {
     #[cold]
     pub(crate) fn exec(ctx: Command::Context<'_>) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-
         // Initialize the REPL
         let mut repl = Repl::init();
         // `defer repl.deinit()` → handled by Drop
@@ -47,7 +45,6 @@ impl ReplCommand {
         ctx: Command::Context<'_>,
         repl: &mut Repl<'r>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Load bunfig if not already loaded
         if !ctx.debug.loaded_bunfig {
             Arguments::load_config_path(
@@ -62,25 +59,22 @@ impl ReplCommand {
         jsc::initialize(true); // true for eval mode
 
         bun_ast::initialize_store();
-        // TODO(port): arena is threaded into VirtualMachine (vm.arena / vm.allocator). Non-AST
-        // crate would normally drop MimallocArena, but VM init protocol requires it. Note
-        // `bun_alloc::Arena` is bumpalo-backed and NOT semantically `bun.allocators.MimallocArena`
-        // (mi_heap wrapper) — TODO(refactor): either have bun_jsc::VirtualMachine own its arena
-        // internally (drop the param) or expose a distinct `bun_alloc::MimallocArena` type.
+        // The arena is threaded into VirtualMachine (vm.arena). `bun_alloc::Arena`
+        // is `MimallocArena` (a per-heap mimalloc wrapper).
         let arena = Arena::new();
 
-        // Validate DNS result order (InitOptions doesn't carry it yet — see TODO below).
-        let _dns_order = DnsOrder::from_string(&ctx.runtime_options.dns_result_order)
+        // Validate DNS result order before VM init; wired onto the VM
+        // post-init below, like run_command.rs.
+        let dns_order = DnsOrder::from_string(&ctx.runtime_options.dns_result_order)
             .unwrap_or_else(|| {
                 bun_core::pretty_errorln!("<r><red>error<r><d>:<r> Invalid DNS result order.");
                 Global::exit(1);
             });
 
-        // Initialize the VM
-        // TODO(port): `jsc::VirtualMachineInitOptions` still lacks `store_fd` /
-        // `eval` / `dns_result_order` (wired post-init below where applicable).
+        // Initialize the VM. `InitOptions` has no allocator field (the VM does
+        // not take a caller-provided allocator in the Rust port; `vm.arena` is
+        // set below).
         let vm: *mut VirtualMachine = VirtualMachine::init(jsc::VirtualMachineInitOptions {
-            // TODO(port): allocator field — VM owns arena allocator; see note above
             transform_options: core::mem::take(&mut ctx.args),
             debugger: core::mem::take(&mut ctx.runtime_options.debugger),
             log: core::ptr::NonNull::new(ctx.log),
@@ -96,13 +90,15 @@ impl ReplCommand {
         unsafe {
             (*vm).preload = core::mem::take(&mut ctx.preloads);
             (*vm).argv = core::mem::take(&mut ctx.passthrough);
+            // `vm.dns_result_order` is a `u8` (see VirtualMachine.rs); set
+            // post-init like run_command.rs since InitOptions doesn't carry it.
+            (*vm).dns_result_order = dns_order as u8;
         }
-        // TODO(port): vm.allocator = vm.arena.arena(); — allocator threading dropped in Rust
-        // (vm.arena assignment moved below ReplRunner construction to avoid move-after-borrow)
+        // There is no per-VM allocator handle; the `vm.arena` assignment itself happens below
+        // ReplRunner construction to avoid a move-after-borrow.
 
         // Configure bundler options
-        // Spec: `b.options.install = ctx.install` (raw `?*const Api.BunInstall`
-        // copy). `BundleOptions.install` is `Option<NonNull<_>>` so no
+        // `BundleOptions.install` is `Option<NonNull<_>>` so no
         // lifetime-extension cast is needed.
         let install_ptr = ctx.install.as_deref().map(core::ptr::NonNull::from);
         b.options.install = install_ptr;
@@ -118,8 +114,9 @@ impl ReplCommand {
             .offline_mode_setting
             .unwrap_or(OfflineMode::Online)
             == OfflineMode::Latest;
-        // TODO(port): blocked_on: bun_resolver::options::BundleOptions::prefer_latest_install —
-        // resolver's forward-decl stub lacks this field; assign directly to b.options below.
+        // The resolver's `BundleOptions` stub has no `prefer_latest_install` field and the
+        // resolver never reads it; only the bundler-side mirror carries it (matches
+        // run_command.rs / production.rs).
         b.options.global_cache = b.resolver.opts.global_cache;
         b.options.prefer_offline_install = b.resolver.opts.prefer_offline_install;
         b.options.prefer_latest_install = prefer_latest;
@@ -151,9 +148,9 @@ impl ReplCommand {
             repl,
             vm,
             arena,
-            // PORT NOTE: ctx is the process-global ContextData; extend the
-            // borrow past the local reborrow lifetime via raw ptr (the runner
-            // never outlives ctx — global_exit() is `!`).
+            // ctx is the process-global ContextData; extend the borrow past the
+            // local reborrow lifetime via raw ptr (the runner never outlives
+            // ctx — global_exit() is `!`).
             eval_script: {
                 let ptr: *const [u8] = &raw const *ctx.runtime_options.eval.script;
                 // SAFETY: ctx.runtime_options.eval.script lives in the process-global
@@ -163,18 +160,16 @@ impl ReplCommand {
             },
             eval_and_print: ctx.runtime_options.eval.eval_and_print,
         };
-        // TODO(port): @constCast(&arena) — vm.arena stores a *mut Arena pointing at runner.arena;
-        // lifetime is the holdAPILock scope (globalExit() never returns so the frame never unwinds).
-        // Assigned AFTER moving `arena` into `runner` — assigning from the pre-move local would
-        // dangle. Model as raw ptr until VM arena ownership is decided.
+        // vm.arena stores a *mut Arena pointing at runner.arena;
+        // lifetime is the holdAPILock scope (globalExit() never returns so the frame never
+        // unwinds). Assigned AFTER moving `arena` into `runner` — assigning from the pre-move
+        // local would dangle.
         // SAFETY: vm is valid for process lifetime (see above); runner.arena is pinned on this
         // stack frame for the holdAPILock scope and global_exit() (`!`) prevents unwind past it.
         unsafe { (*vm).arena = NonNull::new(&raw mut runner.arena) };
 
-        // PORT NOTE: jsc.OpaqueWrap(ReplRunner, ReplRunner.start) — comptime fn-ptr wrapper that
-        // produces an `extern "C" fn(*mut c_void)` thunk. `bun_jsc::opaque_wrap` requires a
-        // type implementing `FnTyped<Ctx>`; rather than depend on that upstream trait, write
-        // the trivial thunk locally.
+        // `bun_jsc::opaque_wrap` requires a type implementing `FnTyped<Ctx>`;
+        // rather than depend on that upstream trait, write the trivial thunk locally.
         extern "C" fn repl_runner_thunk(ctx: *mut c_void) {
             // SAFETY: caller passes `&mut ReplRunner` cast to *mut c_void.
             let runner = unsafe { bun_ptr::callback_ctx::<ReplRunner<'_, '_>>(ctx) };
@@ -207,7 +202,7 @@ impl ReplCommand {
 }
 
 /// Runs the REPL within the VM's API lock
-// PORT NOTE: split lifetimes — `'a` is the stack borrow of the runner/repl,
+// Split lifetimes — `'a` is the stack borrow of the runner/repl,
 // `'r` is the (effectively process-lifetime) VM/global references stored in
 // `Repl<'r>`. Tying them as `&'a mut Repl<'a>` makes the borrow invariant and
 // outlive the local, tripping the borrow checker against `Drop for Repl`.
@@ -286,7 +281,7 @@ impl<'a, 'r> ReplRunner<'a, 'r> {
         if let Some(tz) = unsafe { (*vm.transpiler.env).get(b"TZ") } {
             if !tz.is_empty() {
                 // SAFETY: vm.global is valid; ZigString borrows `tz` for the FFI call duration.
-                // PORT NOTE: `JSGlobalObject::set_time_zone` isn't exposed on the Rust
+                // `JSGlobalObject::set_time_zone` isn't exposed on the Rust
                 // wrapper yet — call the underlying C++ export directly.
                 let _ = unsafe { JSGlobalObject__setTimeZone(vm.global, &ZigString::init(tz)) };
             }
@@ -298,7 +293,7 @@ impl<'a, 'r> ReplRunner<'a, 'r> {
     }
 }
 
-// TODO(port): move to bun_jsc_sys (or wherever bun.cpp externs land)
+// Local extern declarations for C++ exports the bun_jsc wrappers don't expose yet.
 unsafe extern "C" {
     fn Bun__ExposeNodeModuleGlobals(global: *const JSGlobalObject);
     // Local shim for `JSGlobalObject::setTimeZone` (ZigGlobalObject.cpp) until
@@ -311,5 +306,3 @@ unsafe extern "C" {
 
 use bun_bundler::options::EnvBehavior;
 use bun_options_types::offline_mode::OfflineMode;
-
-// ported from: src/cli/repl_command.zig
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index 439fb84d9b6..a98d7bce7f2 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -1,5 +1,3 @@
-//! Port of `src/runtime/cli/run_command.zig`.
-//!
 //! `RunCommand::exec` classifies the first positional as a file path vs. a
 //! package.json script and either boots the JS VM directly (via `Run::boot` →
 //! `VirtualMachine::init` → `Run::start`) or spawns the script body through the
@@ -38,7 +36,7 @@ bun_core::declare_scope!(RUN_LOG, visible);
 
 use bun_core::UnwrapOrOom;
 
-/// Port of `bun.pathLiteral` — picks the POSIX or Windows literal at compile
+/// Picks the POSIX or Windows path literal at compile
 /// time. Local because `bun_paths` does not export a macro form yet.
 macro_rules! path_literal {
     ($posix:literal, $win:literal) => {{
@@ -53,8 +51,7 @@ macro_rules! path_literal {
     }};
 }
 
-/// Process-lifetime arena for the runner's `Transpiler`. Zig passed
-/// `ctx.allocator` (== `bun.default_allocator`); the Rust port threads an
+/// Process-lifetime arena for the runner's `Transpiler`; threads an
 /// `&'static Arena` per PORTING.md §AST crates. Route through the shared
 /// `cli::cli_arena()` (a `LazyLock` — `MimallocArena` is `Sync`).
 #[inline]
@@ -62,8 +59,7 @@ fn runner_arena() -> &'static bun_alloc::Arena {
     crate::cli::cli_arena()
 }
 
-// Passthrough-arg shell escaping (run_command.zig:233-239 → shell.zig
-// escape8Bit). The escape tables + helpers are the lower-tier
+// Passthrough-arg shell escaping. The escape tables + helpers are the lower-tier
 // `bun_shell_parser` crate's canonical copy — import them so future fixes to
 // the shell escaper cannot silently diverge.
 use bun_shell_parser::{escape_8bit, needs_escape_utf8_ascii_latin1};
@@ -75,8 +71,8 @@ impl NpmArgs {
     pub(crate) const PACKAGE_VERSION: &'static [u8] = b"npm_package_version";
 }
 
-/// Runtime knobs `Command::start` passes through; mirrors the Zig
-/// `comptime`-tuple that selected the per-tag exec body.
+/// Runtime knobs `Command::start` passes through to select the per-tag exec
+/// behavior.
 #[derive(Clone, Copy)]
 pub struct ExecCfg {
     pub bin_dirs_only: bool,
@@ -99,7 +95,7 @@ pub struct RunCommand;
 impl RunCommand {
     /// `bun run --help` body.
     pub fn print_help(package_json: Option<&PackageJSON>) {
-        // PORT NOTE: templates are passed as *string literals* so the
+        // templates are passed as *string literals* so the
         // `pretty_fmt!` proc-macro rewrites the `<tag>` color markup at compile
         // time. Routing them through a `const &str` + `{}` prints the raw
         // `<b>`/`<r>` tags verbatim.
@@ -200,9 +196,8 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
 
     /// Find the "best" shell to use. Cached to only run once.
     pub fn find_shell(path: &[u8], cwd: &[u8]) -> Option<&'static ZStr> {
-        // PORT NOTE: Zig used `bun.once` over a module-level `var shell_buf`
-        // (run_command.zig:73). Process-lifetime; written exactly once on the
-        // CLI thread. PORTING.md §Global mutable state: scratch buffer behind
+        // Process-lifetime; written exactly once on the CLI thread.
+        // PORTING.md §Global mutable state: scratch buffer behind
         // a `Once` gate → RacyCell.
         static SHELL_BUF: bun_core::RacyCell<PathBuffer> =
             bun_core::RacyCell::new(PathBuffer::ZEROED);
@@ -232,12 +227,10 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         bun_install::lifecycle_script_runner::replace_package_manager_run(copy_script, script)
     }
 
-    /// Port of `runPackageScriptForeground` (run_command.zig:209). Spawns the
-    /// script body via the bun-shell or system shell and exits on non-zero.
+    /// Spawns the script body via the bun-shell or system shell and exits on
+    /// non-zero.
     ///
-    /// PORT NOTE: `allocator` parameter dropped (PORTING.md §Allocators —
-    /// always global mimalloc); `passthrough` is `&[Box<[u8]>]` to match
-    /// `ctx.passthrough` directly (Zig was `[]const string`).
+    /// `passthrough` is `&[Box<[u8]>]` to match `ctx.passthrough` directly.
     pub fn run_package_script_foreground(
         ctx: &mut ContextData,
         original_script: &[u8],
@@ -315,7 +308,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             // SAFETY: `MiniEventLoop` stores `env` as a raw `*mut`; the loader
             // outlives the call (process-lifetime in `configure_env_for_run`).
             // Erase the loader's borrowed lifetime to `'static` for the
-            // singleton handoff (Zig passed a raw `*DotEnv.Loader`).
+            // singleton handoff.
             let mini = bun_event_loop::MiniEventLoop::init_global(
                 Some(unsafe {
                     &mut *std::ptr::from_mut::<DotEnv::Loader<'_>>(env)
@@ -324,7 +317,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 Some(cwd),
             );
             // SAFETY: `init_global` returns the thread-local singleton as a raw
-            // pointer (Zig `*MiniEventLoop`); reborrow `&'static mut` for the
+            // pointer; reborrow `&'static mut` for the
             // duration of `init_and_run_from_source` — single-threaded mini loop,
             // no aliasing `&mut` exists across this call.
             let mini = unsafe { &mut *mini };
@@ -442,8 +435,8 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
 
         match spawn_result.status {
             SpawnStatus::Exited(exit_code) => {
-                // Zig: `exit_code.signal.valid() && != .SIGINT` — `.signal` is a
-                // raw `u8` here; `signal_code()` range-checks 1..=31 (i.e. valid).
+                // `.signal` is a raw `u8` here; `signal_code()` range-checks
+                // 1..=31 (i.e. valid).
                 if let Some(sig) = spawn_result.status.signal_code() {
                     if sig != bun_core::SignalCode::SIGINT && !silent {
                         pretty_errorln!(
@@ -479,9 +472,9 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             }
 
             SpawnStatus::Signaled(_) => {
-                // Zig: only the *print* is gated on `signal.valid()`;
-                // `suppressReporting` + `raiseIgnoringPanicHandler(signal)`
-                // run unconditionally (run_command.zig:342-353).
+                // Only the *print* is gated on a valid signal code;
+                // `suppress_reporting` + `raise_ignoring_panic_handler`
+                // run unconditionally.
                 let signal_code = spawn_result.status.signal_code();
                 if let Some(sig) = signal_code {
                     if sig != bun_core::SignalCode::SIGINT && !silent {
@@ -504,7 +497,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                     Global::raise_ignoring_panic_handler(sig);
                 }
                 // `.signaled` always carries 1..=31 in practice; fallback only
-                // for type-totality (Zig re-raised the raw u8 unconditionally).
+                // for type-totality.
                 Global::exit(1);
             }
 
@@ -527,13 +520,13 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         Ok(())
     }
 
-    /// Port of `configureEnvForRun` (run_command.zig:772). Allocates a
+    /// Allocates a
     /// process-lifetime `Transpiler`, primes its resolver/env, reads the
     /// top-level `DirInfo`, configures the bundler linker / JSX runtime, and
     /// seeds the `npm_*` env vars.
     ///
     /// Returns a raw `*mut DirInfo` borrowed from the resolver's directory
-    /// cache (process-lifetime; Zig returned `*DirInfo`).
+    /// cache (process-lifetime).
     ///
     /// Hot-path note: the common `bun run <package.json script>` case never
     /// transpiles anything through this `Transpiler` (it shells out / boots a
@@ -597,15 +590,12 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
     ) -> Result<bun_resolver::DirInfoRef, bun_core::Error> {
         let args = ctx.args.clone();
         let env_is_none = env.is_none();
-        // PORT NOTE: process-lifetime arena singleton for the runner's
-        // transpiler. Zig passed `ctx.allocator` (== `bun.default_allocator`);
-        // the Rust port threads an `&'static Arena` per PORTING.md §AST crates.
-        // TODO(port): allocator — collapse once Transpiler::init drops the arena arg.
+        // Process-lifetime arena singleton for the runner's transpiler;
+        // threads an `&'static Arena` per PORTING.md §AST crates.
         let arena: &'static bun_alloc::Arena = runner_arena();
-        // PORT NOTE: out-param constructor — Zig: `var this_transpiler: Transpiler
-        // = undefined;` then `configureEnvForRun` writes the whole struct.
+        // Out-param constructor — `configure_env_for_run` writes the whole struct.
         // `Transpiler` holds `&Arena`/`Box`/enum fields (non-null invariants),
-        // so callers MUST pass a `MaybeUninit` slot (PORTING.md §std.mem.zeroes).
+        // so callers MUST pass a `MaybeUninit` slot.
         this_transpiler.write(Transpiler::init(arena, ctx.log, args, env)?);
         // SAFETY: fully written on the line above.
         let this_transpiler = unsafe { this_transpiler.assume_init_mut() };
@@ -622,8 +612,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         // transpile through this `Transpiler` need it. `configure_linker`'s
         // auto-JSX step reads the cwd `DirInfo` (and, with `load_tsconfig_json`
         // on, its `tsconfig.json`) — keep it ahead of the `read_dir_info` below
-        // so that read populates/uses the same cache entry, matching Zig's
-        // `configureEnvForRun` ordering exactly.
+        // so that read populates/uses the same cache entry.
         if with_linker {
             Self::configure_run_transpiler_linker(this_transpiler);
         }
@@ -680,15 +669,14 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             }
 
             // Always skip default .env files for package.json script runner
-            // (see comment in env_loader.zig:542-548 - the script's own bun instance loads .env)
+            // (the script's own bun instance loads .env)
             let _ = this_transpiler.run_env_loader(true);
         }
 
         // Re-derive after `run_env_loader` — that call creates its own
         // `env_mut()` borrow, which under Stacked Borrows invalidates any
-        // `&mut Loader` derived before it. Zig spec run_command.zig:820-823
-        // re-dereferences `this_transpiler.env` per-statement; mirror that by
-        // taking a fresh borrow here for the remaining env-var seeding.
+        // `&mut Loader` derived before it. Take a fresh borrow here for the
+        // remaining env-var seeding.
         let env_loader = this_transpiler.env_mut();
 
         env_loader
@@ -769,7 +757,6 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 env_loader.map.ensure_unused_capacity(config.count())?;
                 for (k, v) in config.keys().iter().zip(config.values().iter()) {
                     let key = strings::concat(&[b"npm_package_config_", &k[..]]);
-                    // PERF(port): was assume_capacity
                     env_loader.map.put_assume_capacity(&key, *v);
                 }
             }
@@ -780,10 +767,9 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
 
     /// Best-effort default-loader lookup by file extension. Thin forwarder to
     /// `bun_bundler::options::DEFAULT_LOADERS` (the *file-extension*→Loader map
-    /// at options.zig:1041 — NOT `Loader::NAMES`, which is the *loader-name*
+    /// — NOT `Loader::NAMES`, which is the *loader-name*
     /// table and has different membership, e.g. `.sh` is unconditional there
-    /// but Windows-only in `defaultLoaders`). Single source of truth so this
-    /// file cannot drift from options.zig.
+    /// but Windows-only in `DEFAULT_LOADERS`). Single source of truth.
     #[inline]
     fn default_loader_for(target: &[u8]) -> Option<Loader> {
         bun_bundler::options::DEFAULT_LOADERS
@@ -792,15 +778,14 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
     }
 
     /// Shared ctx→transpiler/resolver option projection used by [`boot`] and
-    /// [`boot_standalone`] (bun.js.zig:64-98 / :247-275 — the two bodies are
-    /// byte-identical in Zig).
+    /// [`boot_standalone`].
     fn wire_transpiler_from_ctx(b: &mut Transpiler<'_>, ctx: &mut ContextData) {
         use bun_options_types::context::MacroOptions;
         use bun_options_types::offline_mode::OfflineMode;
 
-        // PORT NOTE: `BundleOptions::install` is a raw `NonNull` backref into
-        // the CLI's `Box<BunInstall>` (process-lifetime — Zig stored the raw
-        // `?*BunInstall`). `as_deref` yields `&BunInstall`, which
+        // `BundleOptions::install` is a raw `NonNull` backref into
+        // the CLI's `Box<BunInstall>` (process-lifetime).
+        // `as_deref` yields `&BunInstall`, which
         // `NonNull::from` converts without the lifetime tie.
         let install_ptr = ctx.install.as_deref().map(::core::ptr::NonNull::from);
         b.options.install = install_ptr;
@@ -811,7 +796,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             .offline_mode_setting
             .unwrap_or(OfflineMode::Online);
         b.resolver.opts.prefer_offline_install = offline == OfflineMode::Offline;
-        // PORT NOTE: resolver's forward-decl `BundleOptions` lacks
+        // resolver's forward-decl `BundleOptions` lacks
         // `prefer_latest_install`; only the bundler-side mirror carries it.
         b.options.global_cache = ctx.debug.global_cache;
         b.options.prefer_offline_install = offline == OfflineMode::Offline;
@@ -821,14 +806,13 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         b.options.minify_identifiers = ctx.bundler_options.minify_identifiers;
         b.options.minify_whitespace = ctx.bundler_options.minify_whitespace;
         b.options.ignore_dce_annotations = ctx.bundler_options.ignore_dce_annotations;
-        // PORT NOTE: resolver's forward-decl `BundleOptions` does not project
-        // `minify_*` (resolver never reads them); Zig assigned both because the
-        // resolver carried the full struct.
+        // resolver's forward-decl `BundleOptions` does not project
+        // `minify_*` (resolver never reads them).
 
         match &mut ctx.debug.macros {
             MacroOptions::Disable => b.options.no_macros = true,
             MacroOptions::Map(macros) => {
-                // PORT NOTE: `ContextData::MacroMap` and
+                // `ContextData::MacroMap` and
                 // `BundleOptions::macro_remap` are both
                 // `ArrayHashMap<Box<[u8]>, ArrayHashMap<Box<[u8]>, Box<[u8]>>>`
                 // but with different hasher contexts (`Auto` vs
@@ -847,7 +831,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         }
     }
 
-    /// `Run.doPreconnect` (bun.js.zig:114) — kick off TCP preconnects for
+    /// Kick off TCP preconnects for
     /// `--preconnect <url>` before the entry module loads.
     fn do_preconnect(preconnect: &[Box<[u8]>]) {
         if preconnect.is_empty() {
@@ -890,7 +874,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         }
     }
 
-    /// Port of `bun_js.Run.bootBunShell` (src/bun.js.zig:142) — run a `.sh`
+    /// Run a `.sh`
     /// entry point through the bun-shell on a `MiniEventLoop` without ever
     /// initializing JSC.
     #[cold]
@@ -903,7 +887,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         ctx: &mut ContextData,
         entry_path: &[u8],
     ) -> Result<crate::shell::ExitCode, bun_core::Error> {
-        // Dummy transpiler so we can load .env (Zig: "this is a hack").
+        // Dummy transpiler so we can load .env.
         let mut args = ctx.args.clone();
         args.write = Some(false);
         args.resolve = Some(api::ResolveMode::Lazy);
@@ -935,7 +919,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         crate::shell::Interpreter::init_and_run_from_file(ctx, mini, entry_path, &src)
     }
 
-    /// Port of `bun_js.Run.boot` (src/bun.js.zig) — `VirtualMachine::init`,
+    /// `VirtualMachine::init`,
     /// hand off CLI state, then enter `Run::start` under the JSC API lock.
     pub(crate) fn boot(
         ctx: &mut ContextData,
@@ -957,9 +941,8 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             Global::exit(exit_code as u32);
         }
 
-        // PORT NOTE: `jsc::initialize(false)` + `Expr/Stmt::Store::create()` +
-        // `MimallocArena::init()` precede VM init in Zig. `bun_jsc::initialize`
-        // is now real (calls `JSCInitialize` over `bun_sys::environ()`); the
+        // `bun_jsc::initialize`
+        // is real (calls `JSCInitialize` over `bun_sys::environ()`); the
         // dispatch hooks (`jsc_hooks::install_jsc_hooks`) are installed by
         // `main.rs` before `Cli::start`, so `VirtualMachine::init` already sees
         // a populated `RuntimeHooks` table.
@@ -979,24 +962,22 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         // SAFETY: `init` returns the unique freshly-boxed VM on this thread.
         let vm = unsafe { &mut *vm_ptr };
 
-        // PORT NOTE: `vm.preload`/`vm.argv` are `Vec<Box<[u8]>>` on both sides;
+        // `vm.preload`/`vm.argv` are `Vec<Box<[u8]>>` on both sides;
         // hand the CLI's vectors over wholesale (process-lifetime, never freed).
         vm.preload = std::mem::take(&mut ctx.preloads);
         vm.argv = std::mem::take(&mut ctx.passthrough);
-        // Zig passes `store_fd = ctx.debug.hot_reload != .none` to `init`;
-        // `InitOptions` lacks the field so set it on the resolver directly.
+        // `InitOptions` has no `store_fd` field, so set it on the resolver directly.
         vm.transpiler.resolver.store_fd = ctx.debug.hot_reload != cli::command::HotReload::None;
-        // PORT NOTE: `vm.dns_result_order` is a `u8` until the b2-cycle widens
-        // it to `bun_dns::Order`; the enum is `#[repr(u8)]` so `as u8` is the
-        // exact `@intFromEnum` Zig would have done.
+        // `vm.dns_result_order` is a `u8` until the b2-cycle widens
+        // it to `bun_dns::Order`; the enum is `#[repr(u8)]` so `as u8` is exact.
         vm.dns_result_order =
             bun_dns::Order::from_string_or_die(&ctx.runtime_options.dns_result_order) as u8;
         // `vm.main` is a BACKREF into these bytes; convert the `Box` to a raw
-        // heap pointer now (Zig: `allocator.dupe` + never-free) so the address
+        // heap pointer now so the address
         // is stable for both `set_main` and the `RUN` write below. The runner
         // never returns, so the allocation is process-lifetime by construction.
         // `mut` because the cron-execution branch below may swap in a synthetic
-        // `cwd/[eval]` path (Zig: `run.entry_path = heap_entry_path`).
+        // `cwd/[eval]` path.
         let mut entry_ptr: *const [u8] = bun_core::heap::into_raw(entry_path);
         // SAFETY: freshly-allocated heap bytes, never freed (see above).
         let entry: &[u8] = unsafe { &*entry_ptr };
@@ -1020,7 +1001,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         } else if !ctx.runtime_options.cron_title.is_empty()
             && !ctx.runtime_options.cron_period.is_empty()
         {
-            // Cron execution mode (bun.js.zig:213-244): wrap the entry point in
+            // Cron execution mode: wrap the entry point in
             // a script that imports the module and calls
             // `default.scheduled(controller)`. The synthetic source is keyed at
             // `cwd/[eval]` so the module loader serves it from `eval_source`.
@@ -1035,10 +1016,9 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 path = bstr::BStr::new(&escaped_path),
                 period = bstr::BStr::new(&escaped_period),
             );
-            // PORT NOTE: process-lifetime (runner never returns) — store both
+            // process-lifetime (runner never returns) — store both
             // the script bytes and the synthetic entry path in the runner arena
-            // so the `Source` stored in the VM can backref into them (Zig:
-            // `allocPrint` + `dupe` + never-free).
+            // so the `Source` stored in the VM can backref into them.
             let cron_script: &'static [u8] =
                 runner_arena().alloc_slice_copy(cron_script.as_bytes());
 
@@ -1055,14 +1035,14 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 heap_entry,
                 cron_script,
             )));
-            // Zig: `run.entry_path = heap_entry_path` — override what
+            // Override what
             // `Run::start` will pass to `vm.load_entry_point`.
             entry_ptr = std::ptr::from_ref::<[u8]>(heap_entry);
             vm.set_main(heap_entry);
         }
 
-        // ctx → transpiler/resolver option mapping (bun.js.zig:247-275).
-        // PORT NOTE: reshaped for borrowck — `b` borrows `vm.transpiler`
+        // ctx → transpiler/resolver option mapping.
+        // reshaped for borrowck — `b` borrows `vm.transpiler`
         // exclusively; `fail_with_build_error(vm)` needs the whole `vm`, so
         // capture the defines result, drop `b`, then branch.
         let defines_ok = {
@@ -1087,7 +1067,6 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             }
         }
 
-        // Zig: `AsyncHTTP.loadEnv(allocator, vm.log, b.env)`.
         // SAFETY: `vm.log` set in `init`; `b.env` is the long-lived
         // `DotEnv::Loader` allocated/retained for the VM (never null after
         // `Transpiler::init`).
@@ -1109,15 +1088,12 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         );
         Self::do_preconnect(&ctx.runtime_options.preconnect);
 
-        // Zig: `vm.main_is_html_entrypoint = (loader orelse
-        //   vm.transpiler.options.loader(ext)) == .html`.
         vm.main_is_html_entrypoint = loader
             .unwrap_or_else(|| vm.transpiler.options.loader(paths::extension(entry)))
             == Loader::Html;
 
         // ── enter `Run::start` under the JSC API lock ──────────────────────
-        // Zig: `vm.global.vm().holdAPILock(&run, OpaqueWrap(Run, Run.start))`.
-        // SAFETY: `RUN` is the process-global singleton (Zig: `var run: Run`);
+        // SAFETY: `RUN` is the process-global singleton;
         // written exactly once here on the main thread before the API-lock
         // trampoline reads it, never freed (`global_exit` ends the process).
         unsafe {
@@ -1127,7 +1103,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
                 entry_path: entry_ptr,
             });
         }
-        // PORT NOTE: `ctx.debug.hot_reload` → `vm.hot_reload` (a `u8` until the
+        // `ctx.debug.hot_reload` → `vm.hot_reload` (a `u8` until the
         // b2-cycle widens it to `cli::HotReload`); `Run::start` re-reads it
         // from `self.ctx` to drive the hot-reloader enable.
         vm.hot_reload = ctx.debug.hot_reload as u8;
@@ -1152,7 +1128,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         Ok(())
     }
 
-    /// Port of `bun_js.Run.bootStandalone` (src/bun.js.zig:27) — entry point for
+    /// Entry point for
     /// `bun build --compile` executables. Mirrors [`boot`] but routes through
     /// `VirtualMachine::init_with_module_graph` and applies the standalone
     /// runtime flags from the embedded graph before entering `Run::start`.
@@ -1178,7 +1154,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             )?;
         }
 
-        // PORT NOTE: layering — `Options::graph` is the resolver's trait object
+        // layering — `Options::graph` is the resolver's trait object
         // (`&'static dyn bun_resolver::StandaloneModuleGraph`); the concrete
         // `bun_standalone_graph::Graph` implements it. The graph is the
         // process-global singleton (`StandaloneModuleGraph::set` in
@@ -1196,9 +1172,9 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             graph: Some(graph_dyn),
             is_main_thread: true,
             smol: ctx.runtime_options.smol,
-            // PORT NOTE: `Options::dns_result_order` is `u8` until the
+            // `Options::dns_result_order` is `u8` until the
             // b2-cycle widens it to `bun_dns::Order`; the enum is
-            // `#[repr(u8)]` so `as u8` matches Zig's `@intFromEnum`.
+            // `#[repr(u8)]` so `as u8` is exact.
             dns_result_order: bun_dns::Order::from_string_or_die(
                 &ctx.runtime_options.dns_result_order,
             ) as u8,
@@ -1212,22 +1188,22 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         vm.argv = std::mem::take(&mut ctx.passthrough);
 
         // `vm.main` is a BACKREF (`*const [u8]`) into `entry_path`'s heap
-        // buffer; convert the `Box` to a raw heap pointer now (Zig:
-        // `allocator.dupe` + never-free) so the address is stable for both
+        // buffer; convert the `Box` to a raw heap pointer now
+        // so the address is stable for both
         // `set_main` and the `RUN` write below. The runner never returns, so
         // the allocation is process-lifetime by construction.
         let entry_ptr: *const [u8] = bun_core::heap::into_raw(entry_path);
         // SAFETY: freshly-allocated heap bytes, never freed (see above).
         vm.set_main(unsafe { &*entry_ptr });
 
-        // PORT NOTE: reshaped for borrowck — `b` borrows `vm.transpiler`
+        // reshaped for borrowck — `b` borrows `vm.transpiler`
         // exclusively; `fail_with_build_error(vm)` needs the whole `vm`, so
         // capture the defines result, drop `b`, then branch.
         let defines_ok = {
             let b = &mut vm.transpiler;
             Self::wire_transpiler_from_ctx(b, ctx);
 
-            // `serve_plugins` / `bunfig_path` (standalone-only; bun.js.zig:80).
+            // `serve_plugins` / `bunfig_path` (standalone-only).
             b.options.serve_plugins = ctx.args.serve_plugins.take().map(Vec::into_boxed_slice);
             b.options.bunfig_path = ::core::mem::take(&mut ctx.args.bunfig_path);
 
@@ -1239,7 +1215,6 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
             crate::run_main::fail_with_build_error(vm);
         }
 
-        // Zig: `AsyncHTTP.loadEnv(allocator, vm.log, b.env)`.
         // SAFETY: `vm.log` set in `init`; `b.env` is the long-lived
         // `DotEnv::Loader` allocated/retained for the VM (never null after
         // `Transpiler::init`).
@@ -1259,7 +1234,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         );
         Self::do_preconnect(&ctx.runtime_options.preconnect);
 
-        // SAFETY: `RUN` is the process-global singleton (Zig: `var run: Run`);
+        // SAFETY: `RUN` is the process-global singleton;
         // written exactly once here on the main thread before the API-lock
         // trampoline reads it, never freed (`global_exit` ends the process).
         unsafe {
@@ -1289,29 +1264,27 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `Run` — port of `src/bun.js.zig` `Run`. The canonical (and only) Rust
+// `Run` — the canonical (and only)
 // definition lives here so the CLI dispatch path can drive the event loop
-// without a crate-cycle; `crate::run_main` re-exports it for callers that
-// expect the Zig `bun.js.Run` namespace.
+// without a crate-cycle; `crate::run_main` re-exports it.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct Run {
-    /// `Command.Context` (a `*ContextData` newtype in Zig). The CLI's
+    /// The CLI's
     /// `ContextData` is parse-once / process-lifetime; `boot()` writes the raw
     /// pointer here so [`Run::start`] can read profiler / preconnect /
     /// hot-reload flags under the API lock without re-threading every field.
     ctx: *mut ContextData,
     vm: *mut VirtualMachine,
-    /// Heap bytes (from `boot`'s `heap::alloc`, matching Zig's
-    /// `allocator.dupe` + never-free) or a borrow into the standalone graph's
+    /// Heap bytes (from `boot`'s `heap::alloc`) or a borrow into the standalone graph's
     /// `entryPoint().name` (from `boot_standalone`). Either way the bytes live
     /// for the process — `Run::start` never returns — so a raw `*const [u8]`
-    /// matches Zig's `entry_path: string` exactly without forcing a `'static`
+    /// works without forcing a `'static`
     /// borrow or a `MaybeUninit` static for `Box<[u8]>`.
     entry_path: *const [u8],
 }
 
-// Zig: `var run: Run = undefined;` — process-global, written once in `boot`.
+// Process-global, written once in `boot`.
 // PORTING.md §Global mutable state: `Run` is `!Sync` (raw ptrs); RacyCell so
 // `boot`/`boot_standalone` can `ptr::write` it on the single CLI thread and
 // the `holdAPILock` trampoline can re-derive `&mut Run` from the static.
@@ -1321,8 +1294,8 @@ static RUN: bun_core::RacyCell<Run> = bun_core::RacyCell::new(Run {
     entry_path: ::core::ptr::slice_from_raw_parts(::core::ptr::null(), 0),
 });
 
-// PORT NOTE: Zig writes `run.any_unhandled = true` from inside the
-// unhandled-rejection callback while `Run::start` holds `&mut self` (via the
+// The unhandled-rejection callback fires
+// while `Run::start` holds `&mut self` (via the
 // `holdAPILock` trampoline). Storing the flag on `Run` and writing through a
 // fresh `&raw mut RUN` would alias that exclusive borrow (PORTING.md
 // §Forbidden — Stacked Borrows UB). Keep it as a sibling static instead so the
@@ -1346,7 +1319,7 @@ impl Run {
         ANY_UNHANDLED.store(true, Ordering::Relaxed);
     }
 
-    /// `Run.addConditionalGlobals` (bun.js.zig:562) — wire `--eval`/`--print`
+    /// Wire `--eval`/`--print`
     /// node-module globals and `--expose-gc` into the JSC global object.
     fn add_conditional_globals(&mut self) {
         unsafe extern "C" {
@@ -1371,9 +1344,8 @@ impl Run {
     /// `Run.start` — load the entry point, run the event loop until idle,
     /// fire `beforeExit`/`exit`, then `globalExit`. Called under the JSC API
     /// lock via `hold_api_lock`.
-    // `printed_…` writes before `global_exit` are intentional Zig-shape.
     fn start(&mut self) -> ! {
-        // PORT NOTE: deref the raw VM/ctx pointers once so the rest of this
+        // deref the raw VM/ctx pointers once so the rest of this
         // body can borrow `vm` and `ctx` alongside `self.entry_path`.
         // SAFETY: `self.vm` is the boxed-and-leaked main-thread VM; `self.ctx`
         // is the CLI's process-lifetime `ContextData`. Both are written by
@@ -1389,11 +1361,11 @@ impl Run {
         vm.hot_reload = ctx.debug.hot_reload as u8;
         vm.on_unhandled_rejection = Run::on_unhandled_rejection_before_close;
 
-        // ── CPU profiler (bun.js.zig:316-331) ──────────────────────────────
+        // ── CPU profiler ────────────────────────────────────────────────────
         if ctx.runtime_options.cpu_prof.enabled {
             let opts = &ctx.runtime_options.cpu_prof;
             // SAFETY: `ctx` is process-lifetime; erase `Box<[u8]>` borrows to
-            // `'static` for `CPUProfilerConfig` (Zig stored borrowed slices).
+            // `'static` for `CPUProfilerConfig`.
             let name: &'static [u8] = unsafe { &*std::ptr::from_ref::<[u8]>(opts.name.as_ref()) };
             // SAFETY: same process-lifetime erasure as `name` above.
             let dir: &'static [u8] = unsafe { &*std::ptr::from_ref::<[u8]>(opts.dir.as_ref()) };
@@ -1410,7 +1382,7 @@ impl Run {
             bun_analytics::features::cpu_profile.fetch_add(1, Ordering::Relaxed);
         }
 
-        // ── Heap profiler (bun.js.zig:333-342) ─────────────────────────────
+        // ── Heap profiler ───────────────────────────────────────────────────
         if ctx.runtime_options.heap_prof.enabled {
             let opts = &ctx.runtime_options.heap_prof;
             // SAFETY: `ctx` is process-lifetime; see CPU-profiler note above.
@@ -1496,7 +1468,7 @@ impl Run {
             }
         }
 
-        // ── hot-reloader enable (bun.js.zig:390-394) ───────────────────────
+        // ── hot-reloader enable ─────────────────────────────────────────────
         match ctx.debug.hot_reload {
             cli::command::HotReload::Hot => {
                 // SAFETY: `self.vm` is the boxed-and-leaked main-thread VM
@@ -1521,7 +1493,6 @@ impl Run {
             _ => {}
         }
 
-        // Zig: `if entry_path == "." { entry_path = fs.top_level_dir }`.
         if entry == b"." {
             // SAFETY: `vm.transpiler.fs` is the process-static `FileSystem`
             // singleton (set in `Transpiler::init`).
@@ -1544,7 +1515,7 @@ impl Run {
                     promise.set_handled();
                     vm.pending_internal_promise_reported_at = vm.hot_reload_counter;
 
-                    // Spec bun.js.zig:407: when --hot/--watch is on (or a user
+                    // When --hot/--watch is on (or a user
                     // `uncaughtException` handler swallowed the error), keep the
                     // process alive instead of hard-exiting on a rejected entry.
                     if vm.hot_reload != 0 || handled {
@@ -1574,8 +1545,7 @@ impl Run {
         // don't run the GC if we don't actually need to
         if vm.is_event_loop_alive() || vm.event_loop_ref().tick_concurrent_with_count() > 0 {
             vm.global().vm().release_weak_refs();
-            // PERF(port): `vm.arena.gc()` — Zig's `MimallocArena.gc()` is
-            // `mi_heap_collect`; `bun_alloc::Arena = bumpalo::Bump` has no
+            // `bun_alloc::Arena = bumpalo::Bump` has no
             // per-heap collect, so this is a no-op unless the arena type
             // changes. Semantically a memory-usage hint, not correctness.
             let _ = vm.global().vm().run_gc(false);
@@ -1603,7 +1573,7 @@ impl Run {
                 vm.report_exception_in_hot_reloaded_module_if_needed();
                 // SAFETY: `event_loop` is a self-pointer into this VM; uniquely
                 // accessed here. Watcher arm keeps the process alive across
-                // reloads (bun.js.zig `start` watcher loop).
+                // reloads.
                 vm.event_loop_ref().tick_possibly_forever();
             }
         } else {
@@ -1645,7 +1615,6 @@ impl Run {
                     }
                     result
                 };
-                // Zig: `to_print.print(vm.global, .Log, .Log)`.
                 // SAFETY: `vals[..1]` is the single stack `to_print`; null
                 // `ctype` routes to the VM's stdout/stderr default.
                 unsafe {
@@ -1799,7 +1768,7 @@ impl RunCommand {
         });
 
         // `entry_path` must outlive the VM (it's stored in `vm.main`); pass an
-        // owned copy by value (Zig: `ctx.allocator.dupe(u8, path)`).
+        // owned copy by value.
         let owned: Box<[u8]> = path.to_vec().into_boxed_slice();
 
         if let Err(err) = Self::boot(ctx, owned, loader) {
@@ -1823,7 +1792,7 @@ impl RunCommand {
         // SAFETY: `ctx.log` was set in `create_context_data` (single-threaded
         // CLI startup) and is process-lifetime.
         //
-        // PORT NOTE: `Log::print` is generic over `IntoLogWrite`, which is
+        // `Log::print` is generic over `IntoLogWrite`, which is
         // implemented for `*mut io::Writer` (not `&mut`). `error_writer()`
         // returns the process-global writer; cast to the raw pointer the
         // trait expects.
@@ -1843,15 +1812,14 @@ impl RunCommand {
     // This path is almost always a path to a user directory. So it cannot be
     // inlined like our uses of /tmp. On Windows use `GetTempPathW` /
     // `RealFS.platformTempDir` instead — this const is POSIX-only and
-    // referencing it on Windows is a compile error (mirrors Zig's
-    // `@compileError` arm).
+    // referencing it on Windows is a compile error.
     //
     // Canonical definition lives in `bun_install::RunCommand` (lower tier so
     // the package manager can use it without depending on `bun_runtime`).
     #[cfg(not(windows))]
     pub const BUN_NODE_DIR: &'static str = bun_install::RunCommand::BUN_NODE_DIR;
 
-    /// Port of `bunNodeFileUtf8` (run_command.zig). Returns the path to the
+    /// Returns the path to the
     /// fake `node` shim that points back at the running `bun` binary.
     pub fn bun_node_file_utf8() -> Result<&'static ZStr, bun_core::Error> {
         #[cfg(not(windows))]
@@ -1895,7 +1863,7 @@ impl RunCommand {
             target_path_buffer[conv_len..total].copy_from_slice(FILE_NAME.as_bytes());
             target_path_buffer[total] = 0;
 
-            // Zig: `allocator.dupeZ` — process-lifetime, never freed. Park the
+            // Park the
             // bytes in the per-process `runner_arena()` instead of leaking
             // (PORTING.md §Forbidden bars per-call leaks).
             let stored: &'static [u8] =
@@ -1906,7 +1874,7 @@ impl RunCommand {
         }
     }
 
-    /// Port of `createFakeTemporaryNodeExecutable` (run_command.zig). Creates
+    /// Creates
     /// `<tmp>/bun-node*/node` and `<tmp>/bun-node*/bun` symlinks (or hard
     /// links on Windows) pointing at the running `bun` binary, then appends
     /// that directory to `path` so child processes resolve `node` to bun.
@@ -1922,7 +1890,7 @@ impl RunCommand {
         bun_install::RunCommand::create_fake_temporary_node_executable(path, optional_bun_path)
     }
 
-    /// Port of `configurePathForRun` (run_command.zig). Prepends workspace
+    /// Prepends workspace
     /// `.bin` dirs + the bun-node shim dir to `PATH` and writes the original
     /// PATH back through `original_path`.
     pub fn configure_path_for_run(
@@ -1959,7 +1927,6 @@ impl RunCommand {
         Ok(())
     }
 
-    /// Port of `configurePathForRunWithPackageJsonDir` (run_command.zig).
     /// Builds a new PATH with `node_modules/.bin` for each ancestor of `cwd`
     /// (plus `package_json_dir` and the bun-node shim dir) prepended, returns
     /// it as an owned buffer, and writes the original PATH out via
@@ -1973,9 +1940,8 @@ impl RunCommand {
         force_using_bun: bool,
     ) -> Result<Vec<u8>, bun_core::Error> {
         let env_loader = this_transpiler.env_mut();
-        // Snapshot PATH up front. In Zig the env map stores borrowed slices into
-        // process environ, so the returned `[]const u8` outlives later `put`s; the
-        // Rust map owns `Box<[u8]>` values, so a borrow would dangle once the
+        // Snapshot PATH up front. The env
+        // map owns `Box<[u8]>` values, so a borrow would dangle once the
         // caller (`configure_path_for_run`) overwrites PATH. Own a copy instead.
         let path: Vec<u8> = env_loader
             .get(b"PATH")
@@ -2017,7 +1983,7 @@ impl RunCommand {
                     + 2; // +2 for path separators, +1 for path delimiter
                 remain = &remain[..i];
             }
-            // Zig `else` clause runs once after the loop ends naturally
+            // final segment once the loop ends naturally
             new_path_len +=
                 strings::without_trailing_slash(remain).len() + b"node_modules.bin".len() + 1 + 2; // +2 for path separators, +1 for path delimiter
         }
@@ -2077,7 +2043,7 @@ impl RunCommand {
                 new_path.push(DELIMITER);
                 remain = &remain[..i];
             }
-            // Zig `else` clause runs once after loop ends naturally
+            // final segment once the loop ends naturally
             new_path.extend_from_slice(strings::without_trailing_slash(remain));
             new_path.extend_from_slice(path_literal!(
                 b"/node_modules/.bin",
@@ -2104,7 +2070,7 @@ impl RunCommand {
         paths::basename(str)
     }
 
-    /// Port of `runBinary` (run_command.zig). On Windows this first probes for
+    /// On Windows this first probes for
     /// a sibling `.bunx` shim and direct-launches it via `BunXFastPath` to
     /// skip the wrapper exe; otherwise (or if the fast path declines) it falls
     /// through to `run_binary_without_bunx_path`.
@@ -2274,7 +2240,7 @@ impl RunCommand {
                     }
 
                     SpawnStatus::Signaled(signal) => {
-                        // Zig: print is gated on `signal.valid()` (1..=31 ⇔
+                        // The print is gated on a valid signal code (1..=31 ⇔
                         // `signal_code.is_some()`); the re-raise is NOT — it
                         // forwards the raw byte unconditionally so the parent
                         // observes the real termination signal (incl. RT 32-64).
@@ -2300,7 +2266,7 @@ impl RunCommand {
 
                     SpawnStatus::Exited(exit_code) => {
                         // A process can be both signaled and exited.
-                        // Zig: gated on `exit_code.signal.valid()` (1..=31).
+                        // Gated on a valid signal code (1..=31).
                         if let Some(sc) = signal_code {
                             if !silent {
                                 pretty_errorln!(
@@ -2382,10 +2348,9 @@ impl RunCommand {
     /// Dispatch `bun run <target>`: classify as file path vs. package.json
     /// script, then either boot the VM or spawn the script.
     ///
-    /// Mirrors Zig `RunCommand.exec(ctx, .{ .bin_dirs_only, .log_errors,
-    /// .allow_fast_run_for_extensions })` — all three knobs are forwarded so
+    /// All three `ExecCfg` knobs are forwarded so
     /// `--if-present` (suppresses missing-script errors) and the Auto-command
-    /// fast-path-by-extension behave exactly per spec.
+    /// fast-path-by-extension behave as expected.
     #[inline]
     pub fn exec(ctx: &mut ContextData, cfg: ExecCfg) -> Result<bool, bun_core::Error> {
         Self::exec_with_cfg(ctx, cfg)
@@ -2401,7 +2366,7 @@ impl RunCommand {
             positionals = &positionals[1..];
         }
 
-        // PORT NOTE: `target_name` borrows `ctx.positionals`, but the boot path
+        // `target_name` borrows `ctx.positionals`, but the boot path
         // mutates `ctx` (takes `preloads`/`passthrough`). Dupe up-front to
         // dodge the borrowck split; the string is short and `exec` is cold.
         let target_name: Box<[u8]> = if !positionals.is_empty() {
@@ -2442,12 +2407,10 @@ impl RunCommand {
             return Ok(true);
         }
 
-        // ── setup (unconditional — zig:1694-1699) ───────────────────────────
-        // PORT NOTE: out-param init — Zig: `var this_transpiler: Transpiler
-        // = undefined;`. `Transpiler` is NOT all-zero-valid POD (holds
+        // ── setup (unconditional) ────────────────────────────────────────────
+        // out-param init — `Transpiler` is NOT all-zero-valid POD (holds
         // `&Arena`/`Box`/enum fields), so use `MaybeUninit` and let
-        // `configure_env_for_run` `.write()` the whole struct (PORTING.md
-        // §std.mem.zeroes).
+        // `configure_env_for_run` `.write()` the whole struct.
         //
         // Use the `_without_linker` variant: nothing reached from here
         // transpiles through `this_transpiler` — the script-string path shells
@@ -2526,9 +2489,9 @@ impl RunCommand {
                             .expect("unreachable");
 
                         // allocate enough to hold "post${scriptname}"
-                        // PORT NOTE: byte 0 is a placeholder so the "pre" slice
+                        // byte 0 is a placeholder so the "pre" slice
                         // (`[1..]`) and the in-place "post" overwrite share one
-                        // buffer (run_command.zig:1749-1794).
+                        // buffer.
                         let mut temp_script_buffer: Vec<u8> =
                             Vec::with_capacity(b"\x00pre".len() + target_name.len());
                         temp_script_buffer.extend_from_slice(b"\x00pre");
@@ -2545,7 +2508,7 @@ impl RunCommand {
                             bstr::BStr::new(package_json_dir)
                         );
 
-                        // PORT NOTE: borrowck reshape — `ctx.passthrough` is a
+                        // borrowck reshape — `ctx.passthrough` is a
                         // field of `ctx` but `run_package_script_foreground`
                         // takes `&mut ContextData`; clone the slice up-front.
                         let passthrough: Vec<Box<[u8]>> = ctx.passthrough.clone();
@@ -2600,7 +2563,7 @@ impl RunCommand {
             }
         }
 
-        // ── module resolution fallback (run_command.zig:1820-1857) ──────────
+        // ── module resolution fallback ───────────────────────────────────────
         // load module and run that module
         // TODO: run module resolution here - try the next condition if the module can't be found
         // SAFETY: `Transpiler::init` always sets `fs` to the process singleton.
@@ -2612,7 +2575,7 @@ impl RunCommand {
             bstr::BStr::new(fs_top_level_dir),
         );
         // Temporarily honor `--preserve-symlinks-main` / NODE_PRESERVE_SYMLINKS_MAIN
-        // for this one resolve. Zig: `defer resolver.opts.preserve_symlinks = saved`.
+        // for this one resolve.
         let resolution: ::core::result::Result<bun_resolver::Result, bun_core::Error> = {
             let saved_preserve = this_transpiler.resolver.opts.preserve_symlinks;
             this_transpiler.resolver.opts.preserve_symlinks =
@@ -2629,7 +2592,7 @@ impl RunCommand {
             ) {
                 ok @ Ok(_) => ok,
                 Err(_) => {
-                    // Retry with explicit `./` prefix (run_command.zig:1832-1836).
+                    // Retry with explicit `./` prefix.
                     let prefixed: Vec<u8> = [b"./".as_slice(), target_name].concat();
                     this_transpiler.resolver.resolve(
                         top_level_dir,
@@ -2658,7 +2621,7 @@ impl RunCommand {
                     .unwrap_or(Loader::Tsx);
                 if loader.can_be_run_by_bun() || loader == Loader::Html || loader == Loader::Md {
                     bun_core::scoped_log!(RUN_LOG, "Resolved to: `{}`", bstr::BStr::new(path.text));
-                    // PORT NOTE: borrowck — `_boot_and_handle_error` takes
+                    // borrowck — `_boot_and_handle_error` takes
                     // `&mut ctx`; copy `path.text` out of the resolver borrow.
                     let text: Box<[u8]> = path.text.to_vec().into_boxed_slice();
                     return Ok(Self::_boot_and_handle_error(ctx, &text, Some(loader)));
@@ -2687,7 +2650,7 @@ impl RunCommand {
             }
         }
 
-        // ── Windows .bunx fast-path (run_command.zig:1862-1888) ─────────────
+        // ── Windows .bunx fast-path ──────────────────────────────────────────
         #[cfg(windows)]
         if bun_core::FeatureFlags::WINDOWS_BUNX_FAST_PATH {
             // SAFETY: process-lifetime static, single-threaded CLI dispatch.
@@ -2724,7 +2687,7 @@ impl RunCommand {
         }
 
         // ── node_modules/.bin / system $PATH fallback ───────────────────────
-        // Zig: run_command.zig:1890-1912 — search the prepended `.bin` dirs
+        // Search the prepended `.bin` dirs
         // (PATH minus ORIGINAL_PATH) unless `--bun` was passed, in which case
         // search the whole stitched PATH.
         {
@@ -2768,7 +2731,7 @@ impl RunCommand {
             return Ok(true);
         }
 
-        // `bun feedback` (run_command.zig:1921-1925).
+        // `bun feedback`.
         // SAFETY: `cli::CMD` is written once during single-threaded CLI
         // startup before any worker thread is spawned; read-only here.
         let current_cmd = unsafe { cli::CMD.read() };
@@ -2827,27 +2790,26 @@ impl RunCommand {
     /// path does not exist / is a directory, so the caller can fall through to
     /// script lookup.
     ///
-    /// PORT NOTE: the Zig version reads `ctx.args.entry_points[0]`; this tier
-    /// has not wired `Arguments::parse` to populate `entry_points` yet, so we
+    /// `Arguments::parse` does not populate `entry_points` yet, so we
     /// take the target slice explicitly.
     fn maybe_open_with_bun_js(ctx: &mut ContextData, target: &[u8]) -> bool {
         if target.is_empty() {
             return false;
         }
 
-        // PORT NOTE (run_command.zig:1586-1640): Zig OPENS the file (rather than
-        // just stat()ing the path), fstat()s the fd, then derives the canonical
-        // absolute path via `bun.getFdPath(fd, &buf)` before booting. The
+        // We OPEN the file (rather than
+        // just stat()ing the path), fstat() the fd, then derive the canonical
+        // absolute path via `get_fd_path` before booting. The
         // get_fd_path step matters: it resolves symlinks so module-relative
         // resolution sees the real location.
         let mut script_name_buf = PathBuffer::uninit();
 
-        // Build a NUL-terminated path to open (mirrors the Zig branching for
+        // Build a NUL-terminated path to open (branching for
         // absolute vs. simple-relative vs. `..`/`~`-prefixed).
         let open_len: usize = if paths::is_absolute(target) {
-            // Zig: `PosixToWinNormalizer.resolveCWD` (prepends the cwd drive
-            // letter on Windows for `/abs` paths) then, on Windows only,
-            // `resolve_path.normalizeString(.., .windows)` to canonicalize
+            // `PosixToWinNormalizer::resolve_cwd` prepends the cwd drive
+            // letter on Windows for `/abs` paths; then, on Windows only,
+            // `normalize_string` canonicalizes
             // separators. Both are no-ops on POSIX (`resolve_cwd` returns the
             // input slice untouched).
             let mut win_resolver = paths::resolve_path::PosixToWinNormalizer::default();
@@ -2892,7 +2854,7 @@ impl RunCommand {
         // `script_name_buf[..open_len]` is init.
         let open_z = bun_core::ZStr::from_buf(&script_name_buf[..], open_len);
 
-        // Open read-only. `catch return false` in Zig.
+        // Open read-only.
         let Ok(fd) = bun_sys::open(open_z, bun_sys::O::RDONLY, 0) else {
             return false;
         };
@@ -2923,7 +2885,7 @@ impl RunCommand {
         });
 
         // Re-derive the canonical absolute path from the open fd (resolves
-        // symlinks). On non-Windows Zig writes back into `script_name_buf`.
+        // symlinks).
         let absolute_script_path: Box<[u8]> = {
             let resolved = match bun_sys::get_fd_path(fd, &mut script_name_buf) {
                 Ok(p) => p,
@@ -2945,9 +2907,9 @@ impl RunCommand {
         bun_core::scoped_log!(RUN_LOG, "Executing from stdin");
 
         // read from stdin
-        // PERF(port): Zig `stackFallback(2048, …)` — could swap to
+        // PERF: could swap to
         // `SmallVec<[u8; 2048]>` if profiled hot; cold CLI path here.
-        // PORT NOTE: `read_to_end_into` is the cursor-relative streaming reader
+        // `read_to_end_into` is the cursor-relative streaming reader
         // (stdin is a pipe/tty, not seekable; `read_to_end` would `pread(0)`).
         let mut list: Vec<u8> = Vec::new();
         if bun_sys::File::stdin().read_to_end_into(&mut list).is_err() {
@@ -2955,7 +2917,6 @@ impl RunCommand {
         }
         ctx.runtime_options.eval.script = list.into_boxed_slice();
 
-        // Zig: `bun.pathLiteral("/[stdin]")`.
         #[cfg(windows)]
         const STDIN_TRIGGER: &[u8] = b"\\[stdin]";
         #[cfg(not(windows))]
@@ -2970,17 +2931,16 @@ impl RunCommand {
         entry_point_buf[cwd_len..cwd_len + STDIN_TRIGGER.len()].copy_from_slice(STDIN_TRIGGER);
         let entry_path = &entry_point_buf[..cwd_len + STDIN_TRIGGER.len()];
 
-        // Zig: prepend "-" to `ctx.passthrough` so `process.argv[1]` matches
+        // Prepend "-" to `ctx.passthrough` so `process.argv[1]` matches
         // Node's `node -` semantics.
         let mut passthrough_list: Vec<Box<[u8]>> = Vec::with_capacity(ctx.passthrough.len() + 1);
         passthrough_list.push(b"-".to_vec().into_boxed_slice());
         passthrough_list.append(&mut ctx.passthrough);
         ctx.passthrough = passthrough_list;
 
-        // Zig: `Run.boot(ctx, dupe(entry_path), null) catch |err| { … }`.
-        // PORT NOTE: NOT routed through `_boot_and_handle_error` — the spec
-        // stdin path (run_command.zig:1740-1749) skips the
-        // `configureAllocator(.long_running=true)` / `.md` checks and prints
+        // NOT routed through `_boot_and_handle_error` — the
+        // stdin path skips the
+        // `configure_allocator(long_running=true)` / `.md` checks and prints
         // `basename(target_name)` (= "-"), not `basename(entry_path)`
         // (= "[stdin]"), in the error message.
         let owned: Box<[u8]> = entry_path.to_vec().into_boxed_slice();
@@ -2990,14 +2950,13 @@ impl RunCommand {
         Ok(true)
     }
 
-    /// Port of `cli.zig`'s `@"bun --eval --print"` — synthetic `cwd/[eval]`
+    /// Synthetic `cwd/[eval]`
     /// entry point + boot. `Arguments::parse` has already stashed the script
     /// in `ctx.runtime_options.eval.script`. Public so `Command::start` can
     /// route the `-e`/`-p` AutoCommand path here without re-implementing the
     /// path-buffer dance.
     pub fn exec_eval(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
-        // Zig: `ctx.passthrough = concat(ctx.positionals, ctx.passthrough)`.
-        // PORT NOTE: prepend positionals into the existing passthrough vec
+        // prepend positionals into the existing passthrough vec
         // (cold path, single allocation).
         if !ctx.positionals.is_empty() {
             let mut merged: Vec<Box<[u8]>> =
@@ -3045,17 +3004,17 @@ impl RunCommand {
             Self::exec_as_if_node_missing_script();
         }
 
-        // PORT NOTE: borrowck — `_boot_and_handle_error` takes `&mut ctx`, so
+        // borrowck — `_boot_and_handle_error` takes `&mut ctx`, so
         // dupe the positional out before the call.
         let filename: Box<[u8]> = ctx.positionals[0].clone();
 
         let normalized: Box<[u8]> = if paths::is_absolute(&filename) {
             filename
         } else {
-            // PORT NOTE (run_command.zig:1976-1984): the spec writes
-            // `path_buf[cwd.len] = std.fs.path.sep_posix` (always `/`, NOT the
-            // platform separator) and then runs the result through
-            // `resolve_path.joinAbsStringBuf(.., .loose)` to collapse `.`/`..`.
+            // Note: write
+            // `cwd_buf[cwd_len] = b'/'` (always `/`, NOT the
+            // platform separator) and then run the result through
+            // `join_abs_string_buf::<Loose>` to collapse `.`/`..`.
             let mut cwd_buf = PathBuffer::uninit();
             let cwd = bun_core::getcwd(&mut cwd_buf)?;
             let cwd_len = cwd.as_bytes().len();
@@ -3069,8 +3028,8 @@ impl RunCommand {
             joined.to_vec().into_boxed_slice()
         };
 
-        // PORT NOTE (run_command.zig:1987-1992): this arm calls `Run.boot`
-        // directly — NOT `_bootAndHandleError` — so it (a) does not call
+        // This arm calls `Run::boot`
+        // directly — NOT `_boot_and_handle_error` — so it (a) does not call
         // `Global::configure_allocator` and (b) uses the
         // `Output.err(err, "Failed to run script \"...\"")` form.
         let basename: Box<[u8]> = paths::basename(&normalized).to_vec().into_boxed_slice();
@@ -3120,14 +3079,13 @@ impl RunCommand {
     }
 }
 
-// Zig: `bun.pathLiteral("/[eval]")` — `pathLiteral` swaps `/` → platform SEP
-// at comptime. Only the leading separator matters here.
+// Only the leading separator matters here.
 #[cfg(windows)]
 const EVAL_TRIGGER: &[u8] = b"\\[eval]";
 #[cfg(not(windows))]
 const EVAL_TRIGGER: &[u8] = b"/[eval]";
 
-/// Port of `escapeForJSString` (bun.js.zig:615) — escape `\ " \n \r \t` for
+/// Escape `\ " \n \r \t` for
 /// embedding in a double-quoted JS string literal. Used by the cron-execution
 /// wrapper script to inline the entry path and cron period.
 fn escape_for_js_string(input: &[u8]) -> Vec<u8> {
@@ -3187,7 +3145,7 @@ impl RemoteImageDownload {
         async_http: *mut bun_http::AsyncHTTP<'static>,
         _result: bun_http::HTTPClientResult<'_>,
     ) {
-        // Mirror sendSyncCallback from AsyncHTTP.zig: the worker's
+        // The worker's
         // ThreadlocalAsyncHTTP is about to be freed, so copy its
         // mutated state back into our owned AsyncHTTP before writing
         // to the channel.
@@ -3198,8 +3156,8 @@ impl RemoteImageDownload {
             let this = &mut *this;
             let async_http = &mut *async_http;
             if let Some(real) = async_http.real {
-                // Zig `real.* = async_http.*;` is a raw bitwise overwrite with
-                // NO destructor on the old value. `ptr::write` preserves that —
+                // Raw bitwise overwrite with
+                // NO destructor on the old value: `ptr::write` —
                 // `*real.as_ptr() = …` would run Drop on the previous
                 // `this.async_http` (whose state the fresh copy still aliases).
                 real.as_ptr().write(::core::ptr::read(async_http));
@@ -3326,7 +3284,6 @@ impl RunCommand {
             let Ok(response_buffer) = bun_core::MutableString::init(8 * 1024) else {
                 continue;
             };
-            // PORT NOTE: Zig wrote `.async_http = undefined` then overwrote it.
             // `AsyncHTTP` holds non-nullable `fn()` pointers (result_callback,
             // task.callback), so `mem::zeroed()` would be instant UB. Allocate
             // an uninit `Box`, write the cheap fields first to obtain stable
@@ -3470,8 +3427,7 @@ impl RunCommand {
                 continue;
             }
             // Dupe d.url for the map key — `collector.urls` owns the backing
-            // PORT NOTE: reshaped — Zig frees `key`/`path` and unlinks on
-            // `put` failure. Check capacity first while `path` is still
+            // bytes. Check capacity first while `path` is still
             // borrowable for `unlink_staged_path`.
             if out_map.try_reserve(1).is_err() {
                 Self::unlink_staged_path(&path);
@@ -3849,7 +3805,7 @@ impl RunCommand {
                             }
                         }
 
-                        // PERF(port): capacity reserved by `ensure_unused_capacity`
+                        // Capacity reserved by `ensure_unused_capacity`
                         // above; `assume_capacity` skips the grow check and
                         // avoids a redundant alloc when the key is a duplicate.
                         let entry_item = results.get_or_put_assume_capacity(Box::from(key));
@@ -3918,11 +3874,10 @@ impl RunCommand {
         this_transpiler.resolver.care_about_bin_folder = false;
         this_transpiler.resolver.care_about_scripts = false;
 
-        // PORT NOTE: `ShellCompletions` stores `&'static [&'static [u8]]`; the
+        // `ShellCompletions` stores `&'static [&'static [u8]]`; the
         // keys interned into `filename_store` / boxed from static tables outlive
         // the process. The owning `results` ArrayHashMap is held in a process-
-        // lifetime arena slot so the borrowed keys remain valid (Zig never
-        // freed it either).
+        // lifetime arena slot so the borrowed keys remain valid.
         let mut all_keys: Vec<&'static [u8]> = results
             .keys()
             .iter()
@@ -3975,14 +3930,13 @@ mod bunx_fast_path_buffers {
     // buffers (bunx fast-path runs once on the main thread) → RacyCell.
     pub(super) static DIRECT_LAUNCH_BUFFER: bun_core::RacyCell<WPathBuffer> =
         bun_core::RacyCell::new(WPathBuffer::ZEROED);
-    // Zig spec (run_command.zig:2014): `var environment_buffer: bun.WPathBuffer`
-    // — same `[PATH_MAX_WIDE]u16` shape as the launch buffer.
+    // Same `[PATH_MAX_WIDE]u16` shape as the launch buffer.
     pub(super) static ENVIRONMENT_BUFFER: bun_core::RacyCell<WPathBuffer> =
         bun_core::RacyCell::new(WPathBuffer::ZEROED);
 }
 
 impl BunXFastPath {
-    /// Port of `appendWindowsArgument` (run_command.zig:2049-2091): convert a
+    /// Convert a
     /// UTF-8 argument to UTF-16, applying Windows command-line quoting/escaping
     /// per the canonical "Everyone quotes command line arguments the wrong way"
     /// rules. Writes into `buffer` and returns the number of u16s written.
@@ -3998,7 +3952,7 @@ impl BunXFastPath {
             return 2;
         }
 
-        // Spec (run_command.zig:2042-2044): trigger quoting only on
+        // Trigger quoting only on
         // space/tab/quote — compare the FULL u16, not the truncated low byte.
         let needs_quote = warg
             .iter()
@@ -4009,7 +3963,7 @@ impl BunXFastPath {
             return warg.len();
         }
 
-        // Fast path: no embedded `"`/`\` → simple wrap (zig:2052-2062).
+        // Fast path: no embedded `"`/`\` → simple wrap.
         let has_quote_or_backslash = warg.iter().any(|&c| c == b'"' as u16 || c == b'\\' as u16);
         if !has_quote_or_backslash {
             buffer[0] = b'"' as u16;
@@ -4108,11 +4062,11 @@ impl BunXFastPath {
             i += 1;
             i += Self::append_windows_argument(&mut command_line[i..], arg);
         }
-        // Zig: `ctx.passthrough = passthrough;` — `direct_launch_callback` →
-        // `Run.boot` reads `vm.argv = ctx.passthrough`, so the assignment must
+        // `direct_launch_callback` →
+        // `Run::boot` reads `vm.argv = ctx.passthrough`, so the assignment must
         // happen before the shim may call back. Current callers pass a clone of
         // `ctx.passthrough` so this is a write-back of identical data, but the
-        // spec contract is that *this* `passthrough` wins.
+        // contract is that *this* `passthrough` wins.
         ctx.passthrough = passthrough.to_vec();
 
         // SAFETY: process-lifetime static, single-threaded CLI dispatch.
@@ -4120,8 +4074,7 @@ impl BunXFastPath {
         let environment = match env.map.write_windows_env_block(&mut env_buf.0) {
             Ok(env) => Some(env),
             Err(_) => {
-                // Spec (run_command.zig:2148) leaks `handle` here via
-                // `catch return`; the shim's `NtClose(metadata_handle)` only
+                // The shim's `NtClose(metadata_handle)` only
                 // runs if `try_startup_from_bun_js` is reached. Close it
                 // explicitly so the slow-path fallback doesn't inherit a
                 // dangling open HANDLE for the process lifetime.
diff --git a/src/runtime/cli/scan_command.rs b/src/runtime/cli/scan_command.rs
index 23b37b0a2c9..0a0123d2a79 100644
--- a/src/runtime/cli/scan_command.rs
+++ b/src/runtime/cli/scan_command.rs
@@ -48,15 +48,13 @@ impl ScanCommand {
             Global::exit(1);
         }
 
-        // Zig: `Output.prettyError(comptime Output.prettyFmt(..., true), .{})` — the
-        // comptime ANSI expansion is folded into `pretty_error`'s runtime tag rewrite.
         bun_core::pretty_error!(
             "<r><b>bun pm scan <r><d>v{}<r>\n",
             Global::package_json_version_with_sha,
         );
         Output::flush();
 
-        // PORT NOTE: reshaped for borrowck — `manager.lockfile.load_from_cwd(&mut self,
+        // Reshaped for borrowck — `manager.lockfile.load_from_cwd(&mut self,
         // Some(manager), log)` would alias `&mut *manager.lockfile` with `&mut *manager`.
         // Project disjoint raw pointers from the singleton first; `load_from_cwd` only
         // reads `manager.options`/migration helpers and never re-borrows `manager.lockfile`.
@@ -68,8 +66,8 @@ impl ScanCommand {
             // no other live `&mut Lockfile` exists at this point.
             let lockfile: &mut Lockfile = unsafe { &mut *(*pm_ptr).lockfile };
             match lockfile.load_from_cwd::<true>(
-                // SAFETY: see PORT NOTE above — `load_from_cwd` accesses `manager`
-                // fields disjoint from `lockfile` (Zig invariant).
+                // SAFETY: see comment above — `load_from_cwd` accesses `manager`
+                // fields disjoint from `lockfile`.
                 Some(unsafe { &mut *pm_ptr }),
                 log,
             ) {
@@ -113,5 +111,3 @@ impl ScanCommand {
         Global::exit(0);
     }
 }
-
-// ported from: src/cli/scan_command.zig
diff --git a/src/runtime/cli/shell_completions.rs b/src/runtime/cli/shell_completions.rs
index 48d87819363..a5ec186f83f 100644
--- a/src/runtime/cli/shell_completions.rs
+++ b/src/runtime/cli/shell_completions.rs
@@ -3,8 +3,7 @@ use bun_core::Output;
 // here so existing `crate::cli::shell_completions::Shell` paths keep working.
 pub use bun_install::ShellCompletions::Shell;
 
-// PORT NOTE: Zig used `@embedFile("completions-bash")` etc. via build-system
-// module aliases. The actual files live at `<repo>/completions/bun.{bash,zsh,fish}`.
+// The actual files live at `<repo>/completions/bun.{bash,zsh,fish}`.
 // The embedded script bodies must stay above the install tier (asset dependency),
 // so `completions()` is an extension trait on the re-exported enum rather than an
 // inherent method.
@@ -27,9 +26,7 @@ impl ShellCompletionsExt for Shell {
     }
 }
 
-// File-level `@This()` struct.
-// PORT NOTE: Zig fields are `[]const []const u8` (borrowed views into either a
-// stack array or arena-allocated storage). `Cow` lets `RunCommand::completions`
+// `Cow` lets `RunCommand::completions`
 // hand back arena-backed `'static` borrows while `bun_getcompletes` supplies an
 // owned `Vec` for the `a` (add-completions) branch — no leaking.
 pub struct ShellCompletions {
@@ -98,5 +95,3 @@ impl ShellCompletions {
         }
     }
 }
-
-// ported from: src/cli/shell_completions.zig
diff --git a/src/runtime/cli/test/ChangedFilesFilter.rs b/src/runtime/cli/test/ChangedFilesFilter.rs
index 3226bffc142..b07b6a9ebcf 100644
--- a/src/runtime/cli/test/ChangedFilesFilter.rs
+++ b/src/runtime/cli/test/ChangedFilesFilter.rs
@@ -41,7 +41,6 @@ use bun_which::which;
 use crate::Command;
 use crate::api::bun_process::sync as spawn_sync;
 
-// PORT NOTE: named `Result` in Zig; kept verbatim for side-by-side diffing.
 // `core::result::Result` is fully qualified throughout this file to avoid the
 // shadow.
 pub struct Result<'a> {
@@ -63,7 +62,6 @@ pub struct Result<'a> {
 /// Filter `test_files` in place to only the entries whose module graph
 /// reaches a changed file. On success, `test_files` is compacted (preserving
 /// order) and the new length is returned via `Result.test_files`.
-// TODO(port): narrow error set
 pub(crate) fn filter<'a>(
     ctx: &Command::Context,
     vm: &mut VirtualMachine,
@@ -128,11 +126,9 @@ pub(crate) fn filter<'a>(
     // log, and we want the runtime transpiler left untouched for actually
     // executing tests afterward.
     //
-    // PORT NOTE: `BundleV2::scan_module_graph_from_cli` takes
+    // `BundleV2::scan_module_graph_from_cli` takes
     // `&'a mut Transpiler<'a>` (invariant), so the arena, log, and transpiler
-    // are process-lifetime. The Zig original does the same — see the comment
-    // after the call about intentionally leaving the ThreadLocalArena and
-    // worker pool alive. Route through the shared CLI arena.
+    // are process-lifetime. Route through the shared CLI arena.
     let arena: &'static Arena = crate::cli::cli_arena();
     let log: &'static mut bun_ast::Log = arena.alloc(bun_ast::Log::new());
 
@@ -159,8 +155,8 @@ pub(crate) fn filter<'a>(
     scan_transpiler.options.tree_shaking = false;
     scan_transpiler.configure_linker();
     let _ = scan_transpiler.configure_defines();
-    // Zig assigns `resolver.opts = options` by value; `Transpiler::init`
-    // already projected resolver.opts, so sync only the fields we changed above.
+    // `Transpiler::init` already projected resolver.opts, so sync only the
+    // fields we changed above.
     scan_transpiler.resolver.opts.target = scan_transpiler.options.target;
     scan_transpiler.resolver.opts.packages = bun_resolver::options::Packages::External;
     scan_transpiler.resolver.opts.output_dir = Box::default();
@@ -227,11 +223,9 @@ pub(crate) fn filter<'a>(
         }
         // All scanned entry points are absolute, and the resolver emits
         // absolute file paths as well.
-        // PERF(port): was putAssumeCapacity — profile if it shows up on a hot path.
         path_to_index.put_assume_capacity(path_text, u32::try_from(idx).unwrap());
         // Copy out of the bundler's arena so the caller can use these paths
         // after the BundleV2 heap is gone.
-        // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path.
         graph_files.push(Box::<[u8]>::from(path_text));
     }
 
@@ -287,7 +281,7 @@ pub(crate) fn filter<'a>(
     // affected, or (b) the test file itself is in the changed set (covers
     // test files that failed to enter the graph for any reason).
     let mut write: usize = 0;
-    // PORT NOTE: reshaped for borrowck — capture len before re-borrowing test_files
+    // reshaped for borrowck — capture len before re-borrowing test_files
     let total = test_files.len();
     debug_assert_eq!(test_files.len(), slot_to_source.len());
     for i in 0..total {
@@ -302,9 +296,7 @@ pub(crate) fn filter<'a>(
         }
     }
 
-    // The Zig original left the BundleV2 alive for the rest of the process —
-    // its AST payload lived in `graph.heap`. In the Rust port `to_ast()`
-    // materializes `Vec<Symbol>` / `Vec<Part>` / `Vec<ImportRecord>` on the
+    // `to_ast()` materializes `Vec<Symbol>` / `Vec<Part>` / `Vec<ImportRecord>` on the
     // global heap and the slab-only `MultiArrayList` drop never frees them, so
     // release the graph columns and the bundler-owned worker pool now that
     // everything needed has been copied out above. The scan transpiler itself
@@ -351,8 +343,9 @@ pub(crate) fn init_watch_trigger() {
             // SAFETY: getpid is always safe.
             let seed: u64 =
                 bun_core::time::milli_timestamp() as u64 ^ unsafe { libc::getpid() } as u64;
+            // wyhash of a time^pid seed; only used to make a unique temp
+            // trigger-file name.
             let rand: u64 = bun_wyhash::hash(&seed.to_ne_bytes());
-            // TODO(port): Zig used DefaultPrng (xoshiro256++); wyhash-of-seed is a placeholder
             let tmpdir = RealFS::tmpdir_path();
             let mut fresh: Vec<u8> = Vec::new();
             {
@@ -369,7 +362,7 @@ pub(crate) fn init_watch_trigger() {
             let fresh = ZBox::from_vec(fresh);
             // Export once so every exec()'d descendant inherits the same
             // path. Adding (not removing) an env var is safe w.r.t.
-            // `std.os.environ`; it simply won't be visible to code that
+            // the environ snapshot; it simply won't be visible to code that
             // iterates the startup-captured slice in this process.
             // SAFETY: both strings are NUL-terminated; setenv copies into libc env storage.
             unsafe {
@@ -391,7 +384,6 @@ pub(crate) fn init_watch_trigger() {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     #[allow(dead_code)]
     pub(crate) fn setenv(name: *const c_char, value: *const c_char, overwrite: c_int) -> c_int;
@@ -440,7 +432,7 @@ fn consume_watch_trigger() -> Option<StringSet> {
             if !sys::exists(path) {
                 continue;
             }
-            let _ = set.insert(path); // OOM-only Result (Zig: catch unreachable)
+            let _ = set.insert(path); // OOM-only Result
         }
         // If every triggering path was a deletion, fall back to git so the
         // user at least gets the same behaviour as the initial run rather
@@ -458,8 +450,6 @@ pub(crate) enum GitError {
     GitNotFound,
     #[error("GitFailed")]
     GitFailed,
-    // PORT NOTE: Zig union'd `std.mem.Allocator.Error` here; allocator params
-    // were dropped (global mimalloc aborts on OOM), so OutOfMemory is gone.
 }
 
 bun_core::named_error_set!(GitError);
@@ -609,7 +599,6 @@ pub(crate) struct GitResult {
 
 fn run_git(git_path: &[u8], cwd: &[u8], args: &[&[u8]]) -> GitResult {
     let mut argv: Vec<&[u8]> = Vec::with_capacity(args.len() + 3);
-    // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path.
     argv.push(git_path);
     // `core.quotePath` (on by default) wraps non-ASCII filenames in quotes
     // and emits octal escapes. We want raw UTF-8 paths so they match the
@@ -629,10 +618,8 @@ fn run_git(git_path: &[u8], cwd: &[u8], args: &[&[u8]]) -> GitResult {
         // Windows rather than spinning up a MiniEventLoop.
         #[cfg(windows)]
         windows: spawn_sync::WindowsOptions {
-            // PORT NOTE: Zig `EventLoopHandle.init(anytype)` accepted a
-            // `*VirtualMachine` and called `vm.eventLoop()` internally; the
-            // Rust split keeps `init` taking the erased `*mut ()` event-loop
-            // pointer directly, so unwrap it here.
+            // `init` takes the erased `*mut ()` event-loop pointer
+            // directly, so unwrap it here.
             loop_: EventLoopHandle::init(VirtualMachine::get().event_loop().cast()),
             ..Default::default()
         },
@@ -692,10 +679,8 @@ fn append_paths(set: &mut StringSet, git_root: &[u8], stdout: &[u8]) {
         // `StringSet.insert` dupes the key internally; abort on OOM rather
         // than propagating so the set can never be left holding a pointer
         // into our stack `buf` on the errdefer cleanup path.
-        let _ = set.insert(abs); // OOM-only Result (Zig: catch unreachable)
+        let _ = set.insert(abs); // OOM-only Result
     }
 }
 
 use crate::Command::HotReload;
-
-// ported from: src/cli/test/ChangedFilesFilter.zig
diff --git a/src/runtime/cli/test/ParallelRunner.rs b/src/runtime/cli/test/ParallelRunner.rs
index a25e567facd..79010bcb336 100644
--- a/src/runtime/cli/test/ParallelRunner.rs
+++ b/src/runtime/cli/test/ParallelRunner.rs
@@ -15,5 +15,3 @@ pub use super::parallel::runner::run_as_coordinator;
 pub use super::parallel::runner::run_as_worker;
 pub use super::parallel::runner::worker_emit_test_done;
 pub use super::parallel::worker::Worker;
-
-// ported from: src/cli/test/ParallelRunner.zig
diff --git a/src/runtime/cli/test/Scanner.rs b/src/runtime/cli/test/Scanner.rs
index 48bdc4b57ca..1b6f8dba137 100644
--- a/src/runtime/cli/test/Scanner.rs
+++ b/src/runtime/cli/test/Scanner.rs
@@ -27,9 +27,12 @@ pub struct Scanner<'a> {
     pub dirs_to_scan: Fifo,
     /// Paths to test files found while scanning.
     pub test_files: Vec<Interned>,
-    // TODO(port): LIFETIMES.tsv classifies as &'a FileSystem, but several call
-    // sites (dirname_store.append, readDirectoryWithIterator) mutate. May need
-    // interior mutability on FileSystem or &'a mut.
+    // dirname_store appends are fine through `&self` (interior-mutable bss
+    // string list), but `read_dir_with_name`/`next` derive `&mut RealFS` from
+    // this `&FileSystem` via lint-silenced `&T` -> `&mut T` casts — that is
+    // UB-adjacent debt, not a settled design. This field should become
+    // `*mut FileSystem` (the shape `Transpiler.fs` already uses; init would
+    // store `transpiler.fs` directly) or RealFS needs interior mutability.
     pub fs: &'a FileSystem,
     pub open_dir_buf: PathBuffer,
     pub scan_dir_buf: PathBuffer,
@@ -38,13 +41,13 @@ pub struct Scanner<'a> {
     pub search_count: usize,
 }
 
-// std.fifo.LinearFifo(ScanEntry, .Dynamic) — ring buffer with readItem/writeItem.
-// VecDeque is the direct equivalent (pop_front / push_back).
+// FIFO queue of scan entries (pop_front / push_back).
 pub(crate) type Fifo = VecDeque<ScanEntry>;
 
 pub struct ScanEntry {
     pub relative_dir: Fd,
-    // TODO(port): lifetime — borrows from FileSystem.dirname_store (process-lifetime arena)
+    // `'static` is sound here: borrows from FileSystem.dirname_store, a
+    // process-lifetime arena that is never reset.
     pub dir_path: &'static [u8],
     pub name: StringOrTinyString,
 }
@@ -67,15 +70,14 @@ impl PartialEq<bun_core::Error> for ScanError {
 }
 
 /// Newtype around `*mut Scanner` so it can satisfy [`DirEntryIterator`]
-/// (whose `next` takes `&self`). Zig passed `*Scanner` directly and called
-/// `.next()` mutably; the raw pointer reproduces that aliasing.
+/// (whose `next` takes `&self`) while still allowing mutable calls.
 #[repr(transparent)]
 struct ScannerDirIter<'a>(*mut Scanner<'a>);
 impl<'a> DirEntryIterator for ScannerDirIter<'a> {
     fn next(&self, entry: &mut fs::Entry, fd: Fd) {
         // SAFETY: `self.0` is `&mut Scanner` for the duration of
         // `read_directory_with_iterator`; no other live `&mut` alias exists
-        // while the resolver walks entries (Zig: `iterator.next(entry, fd)`).
+        // while the resolver walks entries.
         unsafe { (*self.0).next(entry, fd) }
     }
 }
@@ -92,8 +94,8 @@ impl<'a> Scanner<'a> {
             path_ignore_patterns: &[],
             dirs_to_scan: Fifo::new(),
             options: &transpiler.options,
-            // SAFETY: `Transpiler.fs` is the process-singleton `*mut FileSystem`
-            // (Zig `*FileSystem`); it outlives the scanner.
+            // SAFETY: `Transpiler.fs` is the process-singleton `*mut FileSystem`;
+            // it outlives the scanner.
             fs: unsafe { &*transpiler.fs },
             test_files: results,
             open_dir_buf: PathBuffer::uninit(),
@@ -111,7 +113,7 @@ impl<'a> Scanner<'a> {
 
     pub fn scan(&mut self, path_literal: &[u8]) -> Result<(), ScanError> {
         let parts: [&[u8]; 2] = [self.fs.top_level_dir, path_literal];
-        // PORT NOTE: reshaped for borrowck — abs_buf's return keeps a &mut borrow
+        // reshaped for borrowck — abs_buf's return keeps a &mut borrow
         // of scan_dir_buf alive across the &mut self calls below. Capture only the
         // length, then reconstruct a detached slice from the raw buffer pointer.
         let path_len = self.fs.abs_buf(&parts, &mut self.scan_dir_buf).len();
@@ -156,16 +158,14 @@ impl<'a> Scanner<'a> {
                 debug_assert!(fd != Fd::INVALID);
                 // Collect first so `self.next(…)` doesn't overlap the
                 // `entries.data` borrow.
-                // PORT NOTE: this branch is taken when the resolver already has
+                // this branch is taken when the resolver already has
                 // `path` cached (e.g. `run_env_loader`/`read_dir_info` read the
                 // cwd before the scanner runs), so `read_directory_with_iterator`
                 // returned the cached `EntryMap` without invoking `iterator.next`.
-                // Zig walks `std.HashMapUnmanaged` slot order here, which is
-                // deterministic per its linear-probing layout; Rust's SwissTable
-                // iteration order differs even with the same wyhash seed. Sort by
-                // (lowercased) base name so test-file discovery order is stable
-                // across the port — regression/issue/26851 relies on `a_*.test`
-                // running before `b_*.test` under `--bail`.
+                // Hash-map iteration order is not stable. Sort by (lowercased)
+                // base name so test-file discovery order is deterministic —
+                // regression/issue/26851 relies on `a_*.test` running before
+                // `b_*.test` under `--bail`.
                 let mut entry_ptrs: Vec<*mut fs::Entry> = entries.data.values().copied().collect();
                 entry_ptrs.sort_by(|a, b| {
                     // SAFETY: `EntryMap` stores `*mut Entry` into the
@@ -244,16 +244,18 @@ impl<'a> Scanner<'a> {
         name: &[u8],
         handle: Option<bun_sys::Dir>,
     ) -> Result<&'static mut EntriesOption, bun_core::Error> {
-        // PORT NOTE: Zig `readDirectoryWithIterator` takes `*RealFS` and a
-        // duck-typed `*Scanner` iterator. `self.fs` is `&FileSystem` here, but
+        // `read_directory_with_iterator` takes `*mut RealFS` and an
+        // iterator. `self.fs` is `&FileSystem` here, but
         // the underlying `RealFS` is the process singleton and is mutated
         // through `*mut` everywhere else (see `Transpiler.fs: *mut FileSystem`);
-        // cast away `&` to match the Zig calling convention. Serialised by
-        // `RealFS.entries_mutex` inside the callee.
+        // cast away `&` to call it. Serialised by
+        // `RealFS.entries_mutex` inside the callee. This `&T` -> `&mut T` cast
+        // is lint-silenced UB-adjacent debt; the real fix is storing
+        // `Scanner.fs` as `*mut FileSystem` (see the field doc).
         let real_fs = core::ptr::from_ref(&self.fs.fs).cast_mut();
         let iter = ScannerDirIter(std::ptr::from_mut::<Scanner<'a>>(self));
         let raw = handle.map(bun_sys::Dir::into_raw);
-        // SAFETY: see PORT NOTE above — `real_fs` aliases the singleton.
+        // SAFETY: see comment above — `real_fs` aliases the singleton.
         #[allow(invalid_reference_casting)]
         unsafe { &mut *real_fs }.read_directory_with_iterator(name, raw, 0, true, iter)
     }
@@ -353,7 +355,7 @@ impl<'a> Scanner<'a> {
     pub fn next(&mut self, entry: &mut fs::Entry, fd: Fd) {
         let name = entry.base_lowercase();
         self.has_iterated = true;
-        // `Entry::kind` takes `*mut RealFS` (Zig `*Implementation`); cast the
+        // `Entry::kind` takes `*mut RealFS`; cast the
         // shared singleton ref — `kind()` only stat()s through it.
         let real_fs = (&raw const self.fs.fs).cast_mut();
         // SAFETY: entries_mutex held; real_fs points at the process-global RealFS.
@@ -378,7 +380,7 @@ impl<'a> Scanner<'a> {
                 // Prune ignored directory trees early so we never traverse them.
                 if !self.path_ignore_patterns.is_empty() {
                     let parts: [&[u8]; 2] = [entry.dir, entry.base()];
-                    // PORT NOTE: reshaped for borrowck — drop the &mut borrow from
+                    // reshaped for borrowck — drop the &mut borrow from
                     // abs_buf and reborrow open_dir_buf immutably so &self methods
                     // can be called with the slice.
                     let dir_path_len = self.fs.abs_buf(&parts, &mut self.open_dir_buf).len();
@@ -393,8 +395,7 @@ impl<'a> Scanner<'a> {
                 self.dirs_to_scan.push_back(ScanEntry {
                     relative_dir: fd,
                     // SAFETY: StringOrTinyString is repr(C) POD ([u8;31] + u8) with
-                    // no Drop; Zig copied it by value. Upstream type lacks
-                    // Clone/Copy, so bitwise-copy here to match Zig semantics.
+                    // no Drop. Upstream type lacks Clone/Copy, so bitwise-copy here.
                     name: unsafe { core::ptr::read(&raw const entry.base_) },
                     dir_path: entry.dir,
                 });
@@ -411,7 +412,7 @@ impl<'a> Scanner<'a> {
                 }
 
                 let parts: [&[u8]; 2] = [entry.dir, entry.base()];
-                // PORT NOTE: reshaped for borrowck — drop the &mut borrow from
+                // reshaped for borrowck — drop the &mut borrow from
                 // abs_buf and reborrow open_dir_buf immutably so &self methods
                 // below can be called with the slice.
                 let path_len = self.fs.abs_buf(&parts, &mut self.open_dir_buf).len();
@@ -440,5 +441,3 @@ impl<'a> Scanner<'a> {
 }
 
 pub(crate) const TEST_NAME_SUFFIXES: [&[u8]; 4] = [b".test", b"_test", b".spec", b"_spec"];
-
-// ported from: src/cli/test/Scanner.zig
diff --git a/src/runtime/cli/test/parallel/Channel.rs b/src/runtime/cli/test/parallel/Channel.rs
index 8101e829c42..5b9584ad5b4 100644
--- a/src/runtime/cli/test/parallel/Channel.rs
+++ b/src/runtime/cli/test/parallel/Channel.rs
@@ -36,25 +36,20 @@ use bun_sys::windows::libuv as uv;
 
 use super::frame;
 
-/// The Zig version is `fn Channel(comptime Owner: type, comptime owner_field:
-/// []const u8) type`. Rust cannot take a field-name string as a const generic,
-/// so the owner instead implements [`bun_core::IntrusiveField<Channel<Self>>`]
-/// (via `bun_core::intrusive_field!`) plus the two callbacks the Zig called
-/// as `owner().onChannelFrame` / `onChannelDone`.
+/// The owner implements [`bun_core::IntrusiveField<Channel<Self>>`]
+/// (via `bun_core::intrusive_field!`) plus the two callbacks below.
 pub trait ChannelOwner: bun_core::IntrusiveField<Channel<Self>> {
     fn on_channel_frame(&mut self, kind: frame::Kind, rd: &mut frame::Reader<'_>);
     fn on_channel_done(&mut self);
 }
 
-// PORT NOTE: the struct itself carries no `ChannelOwner` bound so that owners
+// The struct itself carries no `ChannelOwner` bound so that owners
 // (Worker, WorkerCommands) can embed `Channel<Self>` as a field before their
 // `impl ChannelOwner` is in scope. Method impls that recover the owner via
 // `IntrusiveField::OFFSET` keep the bound. (Rust also forbids a stricter bound
 // on `Drop` than on the struct, so Drop/Default below are unbounded too.)
 pub struct Channel<Owner> {
     /// Incoming bytes that don't yet form a complete frame.
-    // PORT NOTE: Zig field name is `in`, a Rust keyword — kept via raw ident
-    // so the .zig ↔ .rs diff stays aligned.
     pub r#in: Vec<u8>,
     /// Outgoing bytes the kernel didn't accept yet.
     pub out: Vec<u8>,
@@ -86,8 +81,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
     #[inline]
     fn owner(&mut self) -> &mut Owner {
         // SAFETY: `self` is always embedded at `Owner::OFFSET` inside an
-        // `Owner` that outlives all callbacks (see module doc). Mirrors Zig
-        // `@alignCast(@fieldParentPtr(owner_field, self))`.
+        // `Owner` that outlives all callbacks (see module doc).
         unsafe { &mut *Owner::from_field_ptr(std::ptr::from_mut(self)) }
     }
 }
@@ -120,12 +114,10 @@ impl<Owner: ChannelOwner> Channel<Owner> {
     /// `SocketKind` value of its own. The per-file isolation swap skips
     /// `rare.test_parallel_ipc_group` so the coordinator link survives.
     fn ensure_posix_group(vm: &mut VirtualMachine) -> &mut uws::SocketGroup {
-        // PORT NOTE: borrowck split — `rare_data()` mutably borrows `vm`, but
+        // borrowck split — `rare_data()` mutably borrows `vm`, but
         // the group accessor needs `vm` again for `uws_loop()`. The two touch
         // disjoint storage (the `Box<RareData>` payload vs the loop pointer
-        // field), so a raw-pointer reborrow is sound here. Mirrors Zig's
-        // `vm.rareData().testParallelIpcGroup(vm)` which has no such aliasing
-        // restriction.
+        // field), so a raw-pointer reborrow is sound here.
         let rd: *mut bun_jsc::rare_data::RareData = vm.rare_data();
         // SAFETY: `rd` points into `vm`'s boxed RareData, which outlives this
         // call; the accessor only reads `vm.uws_loop()` (a separate field).
@@ -134,7 +126,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
         // separate processes so there's never more than one Owner type sharing
         // this group.
         if g.vtable.is_none() {
-            // PORT NOTE: cannot use `uws::vtable::make::<PosixHandlers<Owner>>()`
+            // cannot use `uws::vtable::make::<PosixHandlers<Owner>>()`
             // because `bun_uws_sys::vtable::Handler` requires `Self: 'static`
             // and one owner (`WorkerCommands<'a>`) carries a lifetime. The
             // hand-rolled `PosixHandlers::<Owner>::VTABLE` const below mirrors
@@ -178,21 +170,21 @@ impl Default for WindowsBackend {
 impl<Owner: ChannelOwner> Channel<Owner> {
     /// Adopt a duplex fd into the channel and start reading. POSIX: the
     /// socketpair end. Windows: the inherited named-pipe end (worker side).
-    // PORT NOTE: callers (`runner.rs`, `Worker.rs`) only hold `&VirtualMachine`;
+    // callers (`runner.rs`, `Worker.rs`) only hold `&VirtualMachine`;
     // the upstream `rare_data()` / `test_parallel_ipc_group()` accessors require
-    // `&mut`. Take a raw `*const` (matches Zig `*jsc.VirtualMachine`) and cast
+    // `&mut`. Take a raw `*const` and cast
     // away const locally — single-threaded init path. A `&VirtualMachine`
     // parameter would trip `invalid_reference_casting` on the `&T → &mut T`
     // promotion; the raw-pointer route sidesteps that lint while keeping both
     // call sites (which pass `&`/`&mut` and coerce) unchanged.
     pub fn adopt(&mut self, vm: *const VirtualMachine, fd: Fd) -> bool {
-        // PORT NOTE — VM is process-singleton and accessed only from the main
+        // VM is process-singleton and accessed only from the main
         // thread here; route through the safe singleton accessor.
         let _ = vm;
         let vm: &mut VirtualMachine = VirtualMachine::get().as_mut();
         #[cfg(windows)]
         {
-            // ipc=true matches ipc.zig windowsConfigureClient. With ipc=true
+            // With ipc=true
             // libuv wraps reads/writes in its own framing; both ends use it so
             // the wrapping is transparent and our payload bytes pass through
             // unchanged. With ipc=false the parent end (created by uv_spawn for
@@ -223,7 +215,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
             }
             let pipe = bun_core::heap::into_raw(pipe);
             if !self.adopt_pipe(vm, pipe) {
-                // Caller still owns `pipe` on adopt_pipe failure (Zig spec).
+                // Caller still owns `pipe` on adopt_pipe failure.
                 // SAFETY: Box-allocated; close_and_destroy reclaims via heap::take.
                 unsafe { uv::Pipe::close_and_destroy(pipe) };
                 return false;
@@ -255,7 +247,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
     /// `.ipc` extra-fd parent end, or the worker's just-opened pipe). Starts
     /// reading. On failure the caller still owns `pipe`.
     ///
-    /// Unlike ipc.zig's windowsConfigureServer/Client we keep the pipe ref'd:
+    /// We keep the pipe ref'd:
     /// the worker (and the coordinator before workers register process exit
     /// handles) has nothing else keeping `uv_loop_alive()` true, so unref'ing
     /// here makes autoTick() take the tickWithoutIdle (NOWAIT) path and never
@@ -264,10 +256,9 @@ impl<Owner: ChannelOwner> Channel<Owner> {
     /// returning, so the extra ref never holds the process open.
     #[cfg(windows)]
     pub fn adopt_pipe(&mut self, _vm: *const VirtualMachine, pipe: *mut uv::Pipe) -> bool {
-        // PORT NOTE: Zig's `pipe.readStart(self, onAlloc, onError, onRead)`
-        // bakes the three callbacks at comptime; the Rust binding expresses
-        // that via the `StreamReader` trait impl below and routes through
-        // `read_start_ctx`, which stashes `self` in `handle.data`.
+        // The read callbacks are expressed via the `StreamReader` trait impl
+        // below and routed through `read_start_ctx`, which stashes `self` in
+        // `handle.data`.
         // SAFETY: `pipe` is a live, init'ed `Box<Pipe>` allocation owned by the
         // caller; we only borrow it to start reading.
         let rc = unsafe { (*pipe).read_start_ctx::<Self>(core::ptr::from_mut(self)) };
@@ -276,7 +267,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
                 "Channel.adoptPipe: readStart failed: {}",
                 e.name().escape_ascii(),
             );
-            // Caller still owns `pipe` on failure (Zig spec) and is responsible
+            // Caller still owns `pipe` on failure and is responsible
             // for `close_and_destroy`.
             return false;
         }
@@ -332,8 +323,6 @@ impl<Owner: ChannelOwner> Channel<Owner> {
         // so this currently always falls through to submit_windows_write —
         // kept because EBADF/EPIPE here mean the pipe is dead and must not
         // silently drop the frame.
-        // PORT NOTE: Zig `pipe.tryWrite([]const u8) Maybe(usize)` is inlined
-        // here against the low-level `UvStream::try_write(&[uv_buf_t])`.
         let buf = uv::uv_buf_t::init(frame_bytes);
         let rc = pipe.try_write(core::slice::from_ref(&buf));
         let w: usize = match rc.to_error(bun_sys::Tag::try_write) {
@@ -447,9 +436,8 @@ impl<Owner: ChannelOwner> Channel<Owner> {
                     // SAFETY: Box-allocated; close_and_destroy reclaims via heap::take.
                     unsafe { uv::Pipe::close_and_destroy(bun_core::heap::into_raw(p)) };
                 } else {
-                    // TODO(port): Zig left the field set if already closing;
-                    // with Box we cannot put it back without re-taking. May
-                    // need raw *mut uv::Pipe here.
+                    // Already closing: put the Box back; the uv close callback
+                    // finishes the teardown.
                     self.backend.pipe = Some(p);
                 }
             }
@@ -482,7 +470,7 @@ impl<Owner: ChannelOwner> Channel<Owner> {
                 head += 5usize + len as usize;
                 continue;
             };
-            // PORT NOTE: borrowck split — `rd` borrows `self.r#in` while
+            // borrowck split — `rd` borrows `self.r#in` while
             // `owner()` would re-borrow `*self` mutably. Capture the owner raw
             // pointer *before* forming `rd` (so the `&mut *self` reborrow ends
             // immediately), then recover `&mut Owner` from it after. Same
@@ -546,8 +534,7 @@ impl<Owner> Drop for Channel<Owner> {
 pub(crate) struct PosixHandlers<Owner: ChannelOwner>(PhantomData<Owner>);
 
 /// Ext slot type for the usockets vtable: the slot holds a `*mut Channel<Owner>`.
-// PORT NOTE: was an inherent `type Ext` on the impl in the Zig-shaped draft;
-// inherent associated types are unstable in Rust, so it lives as a free alias.
+// Inherent associated types are unstable in Rust, so this lives as a free alias.
 #[cfg(not(windows))]
 pub(crate) type PosixExt<Owner> = *mut Channel<Owner>;
 
@@ -651,10 +638,8 @@ impl<Owner: ChannelOwner> WindowsHandlers<Owner> {
     }
 }
 
-/// Adapter from `UvStream::read_start_ctx` to `WindowsHandlers` — Zig's
-/// `pipe.readStart(self, onAlloc, onError, onRead)` captures the three
-/// callbacks at comptime; Rust expresses that as this trait impl so the
-/// `extern "C"` trampoline stays zero-alloc.
+/// Adapter from `UvStream::read_start_ctx` to `WindowsHandlers`; expressed as
+/// a trait impl so the `extern "C"` trampoline stays zero-alloc.
 #[cfg(windows)]
 impl<Owner: ChannelOwner> uv::StreamReader for Channel<Owner> {
     #[inline]
@@ -686,5 +671,3 @@ impl<Owner: ChannelOwner> uv::StreamReader for Channel<Owner> {
         this.ingest(&[]);
     }
 }
-
-// ported from: src/cli/test/parallel/Channel.zig
diff --git a/src/runtime/cli/test/parallel/Coordinator.rs b/src/runtime/cli/test/parallel/Coordinator.rs
index ea52872f0d4..6f7e722d636 100644
--- a/src/runtime/cli/test/parallel/Coordinator.rs
+++ b/src/runtime/cli/test/parallel/Coordinator.rs
@@ -20,7 +20,7 @@ use super::frame::{self, Frame};
 use super::worker::{PipeRole, Worker, WorkerPipe};
 use crate::test_command::CommandLineReporter;
 
-// PORT NOTE: `bun.spawn.Status` lives in src/runtime/api/bun/process.zig
+// `Status` lives in `crate::api::bun::process`
 // (not the lower-tier `bun_spawn` crate). Worker.exit_status is this type.
 use crate::api::bun::process::Process;
 use crate::api::bun::process::Status as SpawnStatus;
@@ -83,11 +83,11 @@ impl<'a> Coordinator<'a> {
 
     /// The worker (spawned or not) whose range has the most files remaining.
     fn find_steal_victim(&mut self) -> Option<*mut Worker> {
-        // PORT NOTE: callers (assign_work) hold a live `&mut Worker` pointing
+        // Callers (assign_work) hold a live `&mut Worker` pointing
         // into `self.workers`. `iter_mut()` would materialize a second
         // `&mut Worker` for that same slot — instant UB under Stacked Borrows
         // regardless of what the loop body does. Iterate via raw pointers
-        // instead, mirroring Zig's `for (this.workers) |*v|` (raw `*Worker`).
+        // instead.
         let mut victim: Option<*mut Worker> = None;
         let mut most: u32 = 0;
         let base: *mut Worker = self.workers.as_mut_ptr();
@@ -175,9 +175,12 @@ impl<'a> Coordinator<'a> {
         // A prior failed start()'s errdefer leaves ipc.done = true; reset so a
         // retry on the same slot starts with a fresh channel.
         w.ipc = Default::default();
-        // The Zig stores a back-pointer; in Rust this is an intrusive backref (raw ptr).
-        w.out = WorkerPipe::new(PipeRole::Stdout, std::ptr::from_ref::<Worker>(w));
-        w.err = WorkerPipe::new(PipeRole::Stderr, std::ptr::from_ref::<Worker>(w));
+        // Intrusive backref (raw ptr).
+        // Built via from_mut so the stored `*const` carries write provenance:
+        // WorkerPipe::on_read_chunk later mutates the Worker through cast_mut().
+        let w_ptr = std::ptr::from_mut::<Worker>(w).cast_const();
+        w.out = WorkerPipe::new(PipeRole::Stdout, w_ptr);
+        w.err = WorkerPipe::new(PipeRole::Stderr, w_ptr);
         match w.start() {
             Ok(()) => {}
             Err(e) => {
@@ -239,7 +242,7 @@ impl<'a> Coordinator<'a> {
         // directory locality and total steals are O(K log N) instead of O(N).
         // Stealing from not-yet-spawned workers is fine — their range is just
         // an unclaimed reservation.
-        // PORT NOTE: reshaped for borrowck — find_steal_victim returns *mut so
+        // Reshaped for borrowck — find_steal_victim returns *mut so
         // we can borrow `w` and the victim disjointly.
         if let Some(v_ptr) = self.find_steal_victim() {
             // SAFETY: v_ptr points into self.workers. `w` cannot be the victim:
@@ -270,10 +273,10 @@ impl<'a> Coordinator<'a> {
             if self.bail == 1 { "" } else { "s" }
         );
         Output::flush();
-        // PORT NOTE: reachable from on_frame/account_crash with the caller's
+        // Reachable from on_frame/account_crash with the caller's
         // `w: &mut Worker` still live and used afterward; iter_mut() here
         // would create a second `&mut Worker` for `w`'s slot (UB). Iterate
-        // via raw pointers — mirrors Zig `for (this.workers[..]) |*other|`.
+        // via raw pointers.
         let base: *mut Worker = self.workers.as_mut_ptr();
         let n = self.spawned_count as usize;
         for i in 0..n {
@@ -386,7 +389,7 @@ impl<'a> Coordinator<'a> {
                     return;
                 }
 
-                // PORT NOTE: reshaped for borrowck — `summary()` mutably borrows
+                // Reshaped for borrowck — `summary()` mutably borrows
                 // `self.reporter`, so the unhandled-errors counter (also on
                 // `self.reporter.jest`) and `bail_out()` must run after the
                 // summary borrow is released.
@@ -417,8 +420,7 @@ impl<'a> Coordinator<'a> {
                 }
             }
             frame::Kind::RepeatBufs => {
-                // PORT NOTE: Zig `inline for` over a 3-tuple of &mut buffers;
-                // unrolled here because an array of disjoint &mut fields needs
+                // Unrolled because an array of disjoint &mut fields needs
                 // explicit splitting.
                 self.reporter
                     .failures_to_repeat_buf
@@ -455,7 +457,7 @@ impl<'a> Coordinator<'a> {
     }
 
     pub(crate) fn try_reap(&mut self, w: &mut Worker) {
-        // PORT NOTE: SpawnStatus is not Copy (Err arm owns a path); take()
+        // SpawnStatus is not Copy (Err arm owns a path); take()
         // instead of pattern-match-by-copy.
         if w.exit_status.is_none() || !w.ipc.done {
             return;
@@ -501,8 +503,10 @@ impl<'a> Coordinator<'a> {
         let mut respawned = false;
         if !self.bailed && self.has_undispatched_files() {
             w.ipc = Default::default();
-            w.out = WorkerPipe::new(PipeRole::Stdout, std::ptr::from_ref::<Worker>(w));
-            w.err = WorkerPipe::new(PipeRole::Stderr, std::ptr::from_ref::<Worker>(w));
+            // from_mut: keep write provenance on the stored backref (see spawn_worker).
+            let w_ptr = std::ptr::from_mut::<Worker>(w).cast_const();
+            w.out = WorkerPipe::new(PipeRole::Stdout, w_ptr);
+            w.err = WorkerPipe::new(PipeRole::Stderr, w_ptr);
             match w.start() {
                 Ok(()) => {
                     respawned = true;
@@ -519,8 +523,7 @@ impl<'a> Coordinator<'a> {
             }
             // Explicit early release: `w` is a borrowed slot in self.workers, so
             // Drop won't fire until Coordinator teardown. Assigning defaults
-            // drops the old values now (pipe FDs, capture buffer) to match the
-            // Zig's explicit deinit() calls.
+            // drops the old values now (pipe FDs, capture buffer).
             w.ipc = Default::default();
             w.out = WorkerPipe::new(PipeRole::Stdout, core::ptr::null());
             w.err = WorkerPipe::new(PipeRole::Stderr, core::ptr::null());
@@ -570,10 +573,10 @@ impl<'a> Coordinator<'a> {
         // crash when the exit arrives. Runs even if --bail already set
         // `bailed`, since bailOut() only shutdown()s idle workers and would
         // leave inflight ones running past the banner.
-        // PORT NOTE: reachable from reap_worker with the caller's
+        // Reachable from reap_worker with the caller's
         // `w: &mut Worker` still live and used afterward; iter_mut() would
         // create a second `&mut Worker` for `w`'s slot (UB). Iterate via raw
-        // pointers — mirrors Zig `for (this.workers[..]) |*other|`.
+        // pointers.
         let base: *mut Worker = self.workers.as_mut_ptr();
         let n = self.spawned_count as usize;
         for i in 0..n {
@@ -613,10 +616,10 @@ impl<'a> Coordinator<'a> {
     /// Mark every not-yet-dispatched file as failed so `drive()` can exit
     /// instead of spinning when no live worker remains to make progress.
     fn abort_queued_files(&mut self, reason: &[u8]) {
-        // PORT NOTE: reachable from reap_worker/abort_on_worker_panic with the
+        // Reachable from reap_worker/abort_on_worker_panic with the
         // caller's `w: &mut Worker` still live and used afterward; iter_mut()
         // would create a second `&mut Worker` for `w`'s slot (UB). Iterate via
-        // raw pointers — mirrors Zig `for (this.workers) |*w|`.
+        // raw pointers.
         let base: *mut Worker = self.workers.as_mut_ptr();
         let len = self.workers.len();
         for i in 0..len {
@@ -628,7 +631,7 @@ impl<'a> Coordinator<'a> {
             while let Some(idx) = unsafe { (*wp).range.pop_front() } {
                 bun_core::pretty_error!(
                     "<r><red>✗<r> <b>{}<r> <d>({})<r>\n",
-                    // PORT NOTE: reshaped for borrowck — inline rel_path body
+                    // Reshaped for borrowck — inline rel_path body
                     // since `self.workers` is mutably borrowed.
                     bstr::BStr::new(bun_paths::resolve_path::relative(
                         bun_paths::fs::FileSystem::instance().top_level_dir(),
@@ -715,7 +718,7 @@ fn describe_status<'b>(buf: &'b mut [u8; 32], status: &SpawnStatus) -> &'b [u8]
         // SignalCode is non-exhaustive (`_`); @tagName on an unnamed value
         // (e.g. Linux RT signals 32–64) is safety-checked illegal behavior.
         SpawnStatus::Signaled(sig) => {
-            // PORT NOTE: bun_process::Status::Signaled carries the raw u8 (RT
+            // bun_process::Status::Signaled carries the raw u8 (RT
             // signals included); bun_sys::SignalCode wraps it for name lookup.
             if let Some(name) = bun_sys::SignalCode(*sig).name() {
                 name.as_bytes()
@@ -786,7 +789,7 @@ pub mod abort_handler {
         {
             // SAFETY: signal handler installation; PREV_* are written before
             // any read in uninstall(), single-threaded coordinator setup.
-            // PORT NOTE: `&raw mut` + cast (MaybeUninit<T> is repr(transparent))
+            // `&raw mut` + cast (MaybeUninit<T> is repr(transparent))
             // avoids creating &mut to a `static mut` (Rust 2024 hard error).
             unsafe {
                 // SAFETY: POD, zero-valid — sigaction with handler=0/flags=0 is SIG_DFL.
@@ -820,7 +823,7 @@ pub mod abort_handler {
         #[cfg(unix)]
         {
             // SAFETY: PREV_* were initialized by install().
-            // PORT NOTE: `&raw const` + cast avoids creating & to a `static mut`.
+            // `&raw const` + cast avoids creating & to a `static mut`.
             unsafe {
                 libc::sigaction(
                     libc::SIGINT,
@@ -843,5 +846,3 @@ pub mod abort_handler {
         }
     }
 }
-
-// ported from: src/cli/test/parallel/Coordinator.zig
diff --git a/src/runtime/cli/test/parallel/FileRange.rs b/src/runtime/cli/test/parallel/FileRange.rs
index 6faa77fdd6d..5e9b8e2c616 100644
--- a/src/runtime/cli/test/parallel/FileRange.rs
+++ b/src/runtime/cli/test/parallel/FileRange.rs
@@ -44,5 +44,3 @@ impl FileRange {
         Some(stolen)
     }
 }
-
-// ported from: src/cli/test/parallel/FileRange.zig
diff --git a/src/runtime/cli/test/parallel/Frame.rs b/src/runtime/cli/test/parallel/Frame.rs
index c9eb7673332..b5bfa76f614 100644
--- a/src/runtime/cli/test/parallel/Frame.rs
+++ b/src/runtime/cli/test/parallel/Frame.rs
@@ -30,7 +30,7 @@ pub enum Kind {
 impl TryFrom<u8> for Kind {
     type Error = ();
     fn try_from(v: u8) -> Result<Self, ()> {
-        // Mirrors Zig `enum(u8)` int → enum: valid only for declared discriminants.
+        // Int → enum: valid only for declared discriminants.
         Ok(match v {
             0 => Kind::Ready,
             1 => Kind::FileStart,
@@ -139,5 +139,3 @@ impl<'a> Reader<'a> {
         s
     }
 }
-
-// ported from: src/cli/test/parallel/Frame.zig
diff --git a/src/runtime/cli/test/parallel/Worker.rs b/src/runtime/cli/test/parallel/Worker.rs
index 3a0df6a20ce..a1f1bd36bcf 100644
--- a/src/runtime/cli/test/parallel/Worker.rs
+++ b/src/runtime/cli/test/parallel/Worker.rs
@@ -5,13 +5,6 @@
 
 use core::ffi::c_void;
 
-use bun_core::{self, Output};
-use bun_io as r#async;
-use bun_io;
-use bun_jsc as jsc;
-use bun_sys;
-// `bun.spawn` lives under src/runtime/api/bun/process.zig → mounted at
-// `crate::api::bun_process`, re-exported as `crate::api::bun::process`.
 #[cfg(unix)]
 use crate::api::bun::process::PosixStdio as Stdio;
 #[cfg(unix)]
@@ -19,6 +12,11 @@ use crate::api::bun::process::SpawnResultExt as _;
 #[cfg(not(unix))]
 use crate::api::bun::process::WindowsStdio as Stdio;
 use crate::api::bun::process::{self as spawn, Process, Rusage, SpawnOptions, Status};
+use bun_core::{self, Output};
+use bun_io as r#async;
+use bun_io;
+use bun_jsc as jsc;
+use bun_sys;
 
 use super::channel::{Channel, ChannelOwner};
 use super::coordinator::Coordinator;
@@ -26,16 +24,23 @@ use super::file_range::FileRange;
 use super::frame;
 
 pub struct Worker {
-    // TODO(port): LIFETIMES.tsv classifies this BACKREF → *const, but the Zig
-    // mutates through it (live_workers, onWorkerExit, frame). Should use either
-    // *mut or interior mutability on Coordinator.
-    // PORT NOTE: `Coordinator<'a>` carries borrowed slices; the lifetime is
-    // erased to `'static` here because this is a raw backref pointer that is
-    // only ever dereferenced unsafely (constructor casts via `as *const _`).
+    // BACKREF to the owning Coordinator. Stored as `*const` for LIFETIMES.tsv
+    // parity, but mutation sites (`live_workers`, `on_worker_exit`, `frame`)
+    // go through `cast_mut()`. The pointer is created from `&raw mut coord` in
+    // runner.rs, so it carries write provenance (preserved across const casts);
+    // that removes the read-only-provenance layer of UB but does NOT make the
+    // pattern fully sound: runner.rs takes a fresh `&mut coord` to call
+    // `coord.drive()` after the backref is stored, and every backref write
+    // happens during drive(), so the aliasing remains UB-adjacent under
+    // Stacked/Tree Borrows. The full fix is a `*mut` backref (or interior
+    // mutability) threaded through runner.rs/Coordinator.rs together.
+    // `Coordinator<'a>` carries borrowed slices; the lifetime is erased to
+    // `'static` here because this is a raw backref pointer that is only ever
+    // dereferenced unsafely.
     pub coord: *const Coordinator<'static>,
     pub idx: u32,
     // Intrusive-refcounted (`ThreadSafeRefCount`); `to_process` returns a
-    // `heap::alloc`ed `*mut Process`. Matches Zig `?*bun.spawn.Process`.
+    // `heap::alloc`ed `*mut Process`.
     pub process: Option<*mut Process>,
 
     /// Bidirectional IPC over fd 3. POSIX: usockets adopted from a socketpair.
@@ -56,7 +61,7 @@ pub struct Worker {
     /// range has the most remaining — the end is furthest from that worker's
     /// hot region.
     pub range: FileRange,
-    /// `std.time.milliTimestamp()` at the most recent dispatch; drives lazy
+    /// Millisecond timestamp at the most recent dispatch; drives lazy
     /// scale-up.
     pub dispatched_at: i64,
     /// Worker stdout+stderr since the last `test_done`. Flushed atomically
@@ -70,7 +75,6 @@ pub struct Worker {
 }
 
 impl Worker {
-    // TODO(port): narrow error set
     pub fn start(&mut self) -> Result<(), bun_core::Error> {
         debug_assert!(!self.alive);
         let coord_ptr = self.coord;
@@ -106,8 +110,10 @@ impl Worker {
             // Reset to fresh state after deinit so reapWorker's `!respawned`
             // cleanup (which can't tell whether start() ran) doesn't deinit on
             // undefined ArrayList memory.
-            // PORT NOTE: assignment drops the old value (≡ Zig deinit + reinit).
-            let self_ptr: *const Worker = std::ptr::from_ref::<Worker>(this);
+            // Assignment drops the old value. Take the
+            // backref from `&mut` so the stored `*const` keeps write provenance
+            // (on_read_chunk mutates `captured` through it).
+            let self_ptr: *const Worker = std::ptr::from_mut::<Worker>(this).cast_const();
             this.ipc = Channel::default();
             this.out = WorkerPipe::new(PipeRole::Stdout, self_ptr);
             this.err = WorkerPipe::new(PipeRole::Stderr, self_ptr);
@@ -117,7 +123,7 @@ impl Worker {
         {
             // `.buffer` extra_fd creates an AF_UNIX socketpair; the parent end is
             // adopted into a usockets `Channel`.
-            // PORT NOTE: SpawnOptions.extra_fds is `Box<[Stdio]>` (owned) in the
+            // SpawnOptions.extra_fds is `Box<[Stdio]>` (owned) in the
             // Rust port, so the `extra_fd_stdio` field is no longer borrowed here.
             this.extra_fd_stdio = [Stdio::Buffer];
             let options = SpawnOptions {
@@ -137,8 +143,6 @@ impl Worker {
                 linux_pdeathsig: None,
                 ..Default::default()
             };
-            // Zig: `try (try spawnProcess(...)).unwrap()` — outer `?` for the
-            // anyerror, inner map for the bun_sys::Result.
             // SAFETY: `coord.argv`/`coord.envps[..]` are null-terminated
             // C-string arrays with argv[0] non-null; valid for this call.
             let mut spawned = unsafe {
@@ -154,7 +158,6 @@ impl Worker {
             })?;
             let stdout = spawned.stdout;
             let stderr = spawned.stderr;
-            // (Zig `defer spawned.extra_pipes.deinit()` — handled by Drop.)
             let extra_pipes = core::mem::take(&mut spawned.extra_pipes);
             this.process = Some(spawned.to_process(
                 bun_event_loop::EventLoopHandle::init(coord.vm.event_loop().cast()),
@@ -194,7 +197,6 @@ impl Worker {
             use bun_sys::windows::libuv as uv;
 
             let ipc_pipe = bun_core::heap::into_raw(Box::new(bun_core::ffi::zeroed::<uv::Pipe>()));
-            // Zig spec: `errdefer if (this.ipc.backend.pipe == null) ipc_pipe.closeAndDestroy();`
             // The guard owns the raw Box ptr; `close_and_destroy` handles both
             // never-initialized (loop_ null → free directly) and initialized
             // (uv_close + free in callback). Disarmed only after `adopt_pipe`
@@ -206,7 +208,7 @@ impl Worker {
                 unsafe { uv::Pipe::close_and_destroy(p) };
             });
 
-            // PORT NOTE: SpawnOptions.extra_fds is `Box<[Stdio]>` (owned) in the
+            // SpawnOptions.extra_fds is `Box<[Stdio]>` (owned) in the
             // Rust port, so the `extra_fd_stdio` field is no longer borrowed here.
             this.extra_fd_stdio = [Stdio::Ipc(ipc_pipe)];
             let options = SpawnOptions {
@@ -226,8 +228,6 @@ impl Worker {
                 stream: true,
                 ..Default::default()
             };
-            // Zig: `try (try spawnProcess(...)).unwrap()` — outer `?` for the
-            // anyerror, inner map for the bun_sys::Result.
             // SAFETY: `coord.argv`/`coord.envps[..]` are null-terminated
             // C-string arrays with argv[0] non-null; valid for this call.
             let mut spawned = unsafe {
@@ -241,11 +241,9 @@ impl Worker {
                 Output::err(e, "spawnProcess failed for test worker", ());
                 bun_core::err!("SpawnFailed")
             })?;
-            // Zig `defer spawned.extra_pipes.deinit()` only freed the ArrayList
-            // backing (items were raw `*uv.Pipe` with no destructor). The Rust
-            // port made `WindowsStdioResult::Buffer` hold `Box<uv::Pipe>`, and
+            // `WindowsStdioResult::Buffer` holds `Box<uv::Pipe>`, and
             // `spawn_process_windows` does `heap::take(ipc_pipe)` into it — so
-            // the Vec now holds a second `Box` to the SAME heap address that
+            // `extra_pipes` holds a second `Box` to the SAME heap address that
             // `ipc_pipe_guard` / `adopt_pipe` claim. Drain the Vec and release
             // each Box back to a raw ptr so the Vec drop is inert and
             // `ipc_pipe_guard` remains the sole owner across the
@@ -309,7 +307,9 @@ impl Worker {
             }
         }
         this.alive = true;
-        // SAFETY: see coord_ptr note above; mutation requires *mut cast (TODO(port): interior mutability).
+        // SAFETY: see coord_ptr note above; the backref carries write
+        // provenance, but see the `coord` field doc for the residual
+        // &mut-Coordinator-during-drive aliasing caveat.
         unsafe { (*coord_ptr.cast_mut()).live_workers += 1 };
         // SAFETY: `this` is the live `Box<Worker>` slot in
         // `Coordinator.workers`; it outlives `process`.
@@ -342,7 +342,7 @@ impl Worker {
 
     pub fn on_process_exit(&mut self, _: &Process, status: Status, _: &Rusage) {
         self.alive = false;
-        // SAFETY: coord backref valid for worker lifetime; mutation — see field TODO.
+        // SAFETY: coord backref valid for worker lifetime; mutation — see `coord` field doc (provenance caveats).
         unsafe { (*self.coord.cast_mut()).on_worker_exit(self, status) };
     }
 
@@ -365,7 +365,7 @@ impl Worker {
     }
 
     pub fn dispatch(&mut self, file_idx: u32, file: &[u8]) {
-        // SAFETY: coord backref valid; frame mutation — see field TODO.
+        // SAFETY: coord backref valid; frame mutation — see `coord` field doc (provenance caveats).
         let f = unsafe { &mut (*self.coord.cast_mut()).frame };
         f.begin(frame::Kind::Run);
         f.u32_(file_idx);
@@ -376,7 +376,7 @@ impl Worker {
     }
 
     pub fn shutdown(&mut self) {
-        // SAFETY: coord backref valid; frame mutation — see field TODO.
+        // SAFETY: coord backref valid; frame mutation — see `coord` field doc (provenance caveats).
         let f = unsafe { &mut (*self.coord.cast_mut()).frame };
         f.begin(frame::Kind::Shutdown);
         self.ipc.send(f.finish());
@@ -387,7 +387,7 @@ impl Worker {
 
     /// `Channel` owner callback: a decoded frame arrived.
     pub fn on_channel_frame(&mut self, kind: frame::Kind, rd: &mut frame::Reader<'_>) {
-        // SAFETY: coord backref valid; mutation — see field TODO.
+        // SAFETY: coord backref valid; mutation — see `coord` field doc (provenance caveats).
         unsafe { (*self.coord.cast_mut()).on_frame(self, kind, rd) };
     }
 
@@ -403,7 +403,7 @@ impl Worker {
                 let _ = unsafe { (*p).kill(9) };
             }
         }
-        // SAFETY: coord backref valid; mutation — see field TODO.
+        // SAFETY: coord backref valid; mutation — see `coord` field doc (provenance caveats).
         unsafe { (*self.coord.cast_mut()).try_reap(self) };
     }
 }
@@ -418,7 +418,7 @@ bun_spawn::link_impl_ProcessExit! {
 bun_core::intrusive_field!(Worker, ipc: Channel<Worker>);
 impl ChannelOwner for Worker {
     fn on_channel_frame(&mut self, kind: frame::Kind, rd: &mut frame::Reader<'_>) {
-        // SAFETY: coord backref valid; mutation — see field TODO.
+        // SAFETY: coord backref valid; mutation — see `coord` field doc (provenance caveats).
         unsafe { (*self.coord.cast_mut()).on_frame(self, kind, rd) };
     }
 
@@ -431,7 +431,7 @@ impl ChannelOwner for Worker {
                 let _ = unsafe { (*p).kill(9) };
             }
         }
-        // SAFETY: coord backref valid; mutation — see field TODO.
+        // SAFETY: coord backref valid; mutation — see `coord` field doc (provenance caveats).
         unsafe { (*self.coord.cast_mut()).try_reap(self) };
     }
 }
@@ -465,8 +465,14 @@ impl WorkerPipe {
 
     pub fn on_read_chunk(&mut self, chunk: &[u8], _: bun_io::ReadState) -> bool {
         // SAFETY: worker backref valid while WorkerPipe is embedded in Worker.
-        // TODO(port): LIFETIMES.tsv says *const Worker but we mutate `captured`;
-        // may need *mut or Cell/UnsafeCell on Worker.captured.
+        // Mutating `captured` through cast_mut requires write provenance on
+        // the stored pointer; all backref creation sites (the runner.rs
+        // coord_ptr, the Worker.rs start() errdefer guard, and the
+        // Coordinator.rs spawn_worker/respawn sites via
+        // `std::ptr::from_mut(..).cast_const()`) now establish it. The
+        // residual `&mut Coordinator`-during-drive aliasing caveat described
+        // in the `Worker::coord` field doc applies to this backref too. No
+        // other reference to `captured` is live during the read callback.
         unsafe { (*self.worker.cast_mut()).captured.extend_from_slice(chunk) };
         true
     }
@@ -484,8 +490,7 @@ impl Default for WorkerPipe {
     }
 }
 
-// `bun.io.BufferedReader.init(WorkerPipe)` — vtable parent. Maps the Zig
-// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop` decls.
+// `bun_io::BufferedReader` vtable parent.
 // Callbacks touch only fields disjoint from `reader` (worker backref / done
 // flag); worker/coord backrefs are valid for the pipe's lifetime.
 bun_io::impl_buffered_reader_parent! {
@@ -501,9 +506,6 @@ bun_io::impl_buffered_reader_parent! {
 
 impl Drop for WorkerPipe {
     fn drop(&mut self) {
-        // Body intentionally empty: Zig `deinit` only calls `reader.deinit()`,
-        // which Rust handles via `BufferedReader: Drop`.
+        // Body intentionally empty: `BufferedReader: Drop` handles cleanup.
     }
 }
-
-// ported from: src/cli/test/parallel/Worker.zig
diff --git a/src/runtime/cli/test/parallel/aggregate.rs b/src/runtime/cli/test/parallel/aggregate.rs
index 403f62ec6e4..45e07afd8e1 100644
--- a/src/runtime/cli/test/parallel/aggregate.rs
+++ b/src/runtime/cli/test/parallel/aggregate.rs
@@ -21,7 +21,6 @@ use crate::test_command;
 use crate::test_runner::jest::Summary;
 
 fn attr_value(head: &[u8], name: &'static [u8]) -> u32 {
-    // PERF(port): was comptime `" " ++ name ++ "=\""` concat.
     let needle = [b" ", name, b"=\""].concat();
     let Some(idx) = strings::index_of(head, &needle) else {
         return 0;
@@ -155,8 +154,6 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
     paths: &[&[u8]],
     opts: &mut CodeCoverageOptions,
 ) {
-    // PERF(port): was arena bulk-free (std.heap.ArenaAllocator).
-
     let mut by_file: StringArrayHashMap<FileCoverage> = StringArrayHashMap::default();
 
     for &path in paths {
@@ -165,7 +162,7 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
             bun_sys::Result::Err(_) => continue,
         };
         let mut cur: Option<usize> = None; // index into by_file; raw &mut would alias across getOrPut
-        // PORT NOTE: reshaped for borrowck — store index instead of *mut FileCoverage
+        // reshaped for borrowck — store index instead of *mut FileCoverage
         for raw in data.split(|b| *b == b'\n') {
             let line = strings::trim_right(raw, b"\r");
             if line.starts_with(b"SF:") {
@@ -217,8 +214,7 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
         return;
     }
 
-    // Stable output order. Zig's `ArrayHashMap.sort` reorders entries in place;
-    // PORT NOTE: reshaped — ArrayHashMap has no in-place sort yet, so build a
+    // Stable output order. ArrayHashMap has no in-place sort yet, so build a
     // permutation and iterate via `order` everywhere below.
     let mut order: Vec<usize> = (0..by_file.count()).collect();
     {
@@ -253,7 +249,7 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
                 (e,),
             ),
             bun_sys::Result::Ok(f) => {
-                // TODO(port): Zig used a 64KiB-buffered writer adapter; building in Vec then one write_all
+                // Build the whole report in a Vec, then issue one write_all.
                 let mut w: Vec<u8> = Vec::with_capacity(64 * 1024);
                 for &i in &order {
                     let fc = &by_file.values()[i];
@@ -327,8 +323,14 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
         let console = Output::error_writer();
         fn sep<const COLORS: bool>(c: &mut bun_core::io::Writer, n: usize) {
             let _ = c.write_all(Output::pretty_fmt::<COLORS>("<r><d>").as_ref());
-            // TODO(port): splatByteAll equivalent on writer
-            let _ = c.write_all(&vec![b'-'; n + 2]);
+            // Repeat the byte without a heap allocation.
+            const DASHES: [u8; 64] = [b'-'; 64];
+            let mut left = n + 2;
+            while left > 0 {
+                let take = left.min(DASHES.len());
+                let _ = c.write_all(&DASHES[..take]);
+                left -= take;
+            }
             let _ = c.write_all(
                 Output::pretty_fmt::<COLORS>("|---------|---------|-------------------<r>\n")
                     .as_ref(),
@@ -392,7 +394,7 @@ pub(crate) fn merge_coverage_fragments<const ENABLE_COLORS: bool>(
             avg.stmts /= avg_n;
         }
         let _ = console.write_all(&body);
-        // PORT NOTE: bun_core::io::Writer doesn't impl bun_io::Write — buffer
+        // bun_core::io::Writer doesn't impl bun_io::Write — buffer
         // through a Vec then write_all once.
         let mut all_files: Vec<u8> = Vec::new();
         let _ = CoverageReportText::write_format_with_values::<ENABLE_COLORS>(
@@ -424,5 +426,3 @@ fn write_range<const COLORS: bool>(w: &mut impl std::io::Write, first: &mut bool
         let _ = write!(w, "{}{}-{}", Output::pretty_fmt::<COLORS>("<red>"), a, b);
     }
 }
-
-// ported from: src/cli/test/parallel/aggregate.zig
diff --git a/src/runtime/cli/test/parallel/runner.rs b/src/runtime/cli/test/parallel/runner.rs
index 68ea6aa60c0..d264444c031 100644
--- a/src/runtime/cli/test/parallel/runner.rs
+++ b/src/runtime/cli/test/parallel/runner.rs
@@ -30,9 +30,8 @@ use crate::test_command::{self, CommandLineReporter, TestCommand};
 use crate::test_runner::bun_test::FirstLast;
 use bun_options_types::code_coverage_options::CodeCoverageOptions;
 
-// TODO(port): `format_bytes!` placeholder — needs a macro that writes fmt args
-// into a Vec<u8> (no UTF-8 validation). Define in bun_core or use
-// `{ let mut v = Vec::new(); write!(&mut v, ...).unwrap(); v }` inline.
+// Local helper: formats args into a Vec<u8>. The `unwrap` cannot fail —
+// `Write for Vec<u8>` is infallible.
 macro_rules! format_bytes {
     ($($arg:tt)*) => {{
         let mut __v: Vec<u8> = Vec::new();
@@ -47,11 +46,9 @@ macro_rules! format_bytes {
 pub(crate) const DEFAULT_SCALE_UP_AFTER_MS: i64 = 5;
 
 /// Owns the coordinator-side per-run worker temp directory path bytes;
-/// recursively removes it on drop. Mirrors the Zig
-/// `defer if (worker_tmpdir) |d| bun.FD.cwd().deleteTree(d) catch {}`.
-/// Zig stored a `[:0]const u8` whose `.len` excludes the sentinel; here we
-/// store the bare path with no trailing NUL so `path()`/Drop hand the exact
-/// same bytes to `delete_tree` that `make_path` created.
+/// recursively removes it on drop. Stores the bare path with no trailing NUL
+/// so `path()`/Drop hand the exact same bytes to `delete_tree` that
+/// `make_path` created.
 struct WorkerTmpdir(Option<Box<[u8]>>);
 
 impl WorkerTmpdir {
@@ -85,7 +82,6 @@ pub fn run_as_coordinator(
     let vm_ptr = vm;
     // SAFETY: env loader is initialized before the test runner runs.
     let env = unsafe { &mut *(*vm_ptr).transpiler.env };
-    // TODO(port): narrow error set
     let n: u32 = u32::try_from(files.len()).unwrap();
     let k: u32 = ctx.test_options.parallel.min(n);
     if k <= 1 {
@@ -98,12 +94,9 @@ pub fn run_as_coordinator(
         return Ok(false);
     }
 
-    // PERF(port): was arena bulk-free (std.heap.ArenaAllocator).
-
-    // Owned path bytes (Zig: `[:0]const u8` from allocPrintSentinel — the
-    // sentinel was for C interop only, `.len` excluded it). ZStr is a borrow
-    // header; we must own the backing storage here. Drop recursively removes
-    // the directory once the run finishes.
+    // Owned path bytes. ZStr is a borrow header; we must own the backing
+    // storage here. Drop recursively removes the directory once the run
+    // finishes.
     let mut worker_tmpdir = WorkerTmpdir(None);
     // Workers' stderr is a pipe; have them format with ANSI when we will be
     // rendering to a color terminal so streamed lines match serial output.
@@ -217,7 +210,10 @@ pub fn run_as_coordinator(
         cwd: FileSystem::get().top_level_dir,
         argv,
         envps,
-        workers: &mut workers, // TODO(port): lifetime — Coordinator borrows workers slice
+        // Coordinator borrows the workers slice while each Worker holds a raw
+        // backref to the Coordinator; the raw pointers (never a second `&mut`)
+        // are what keep this sound. See the backref patch loop below.
+        workers: &mut workers,
         worker_tmpdir: worker_tmpdir.path(),
         parallel_limit: k,
         scale_up_after_ms: if let Some(d) = ctx.test_options.parallel_delay_ms {
@@ -250,7 +246,14 @@ pub fn run_as_coordinator(
     // Patch the Worker→Coordinator backref now that `coord`'s address is fixed.
     // Access workers through `coord.workers` to avoid a second &mut on the Vec.
     {
-        let coord_ptr = (&raw const coord).cast::<Coordinator<'static>>();
+        // `&raw mut` so the stored `*const` backref keeps write provenance —
+        // Worker mutates the Coordinator through `coord.cast_mut()`. This only
+        // removes the read-only-provenance layer of UB: `coord.drive()` below
+        // is called through a fresh `&mut coord` and the backref writes happen
+        // during drive(), so the aliasing remains UB-adjacent under
+        // Stacked/Tree Borrows. Full fix = `*mut` backref or interior
+        // mutability (see `Worker.coord` field doc).
+        let coord_ptr = (&raw mut coord).cast::<Coordinator<'static>>().cast_const();
         for w in coord.workers.iter_mut() {
             w.coord = coord_ptr;
         }
@@ -297,9 +300,8 @@ pub fn run_as_coordinator(
 fn build_worker_argv(
     ctx: &Command::ContextData,
 ) -> Result<Box<[bun_spawn::CStrPtr]>, bun_core::Error> {
-    // Zig `[:null]?[*:0]const u8` — null-sentinel slice of C-string pointers.
-    // String storage was arena-owned in Zig; route through the process-lifetime
-    // CLI arena (bulk-freed on exit).
+    // Null-sentinel slice of C-string pointers. String storage routes through
+    // the process-lifetime CLI arena (bulk-freed on exit).
     let mut argv: Vec<bun_spawn::CStrPtr> = Vec::new();
     let opts = &ctx.test_options;
 
@@ -351,7 +353,7 @@ fn build_worker_argv(
         argv.push(print_z(format_args!("--seed={}", seed))?);
     }
     // --bail is intentionally NOT forwarded: workers Global.exit(1) on bail
-    // (test_command.zig handleTestCompleted), which the coordinator would
+    // (see test_command.rs handle_test_completed), which the coordinator would
     // misread as a crash. Cross-worker bail is handled at file granularity by
     // the coordinator instead.
     if opts.repeat_count > 0 {
@@ -398,7 +400,7 @@ fn build_worker_argv(
         argv.push(lit(b"--tsconfig-override\0"));
         argv.push(dupe_z(tsconfig));
     }
-    // PORT NOTE: was `inline for` over heterogeneous-ish tuple; all elements are
+    // Was `inline for` over a heterogeneous-ish tuple; all elements are
     // (&'static [u8], &[Box<[u8]>]) so a const array + plain for suffices.
     let multi_value_flags: [(&'static [u8], &[Box<[u8]>]); 6] = [
         (b"--conditions\0", &ctx.args.conditions),
@@ -467,9 +469,7 @@ fn build_worker_argv(
     }
 
     argv.push(core::ptr::null());
-    // Zig: `argv.items[0 .. argv.items.len - 1 :null]` — sentinel slice excluding
-    // the trailing null from len but keeping it as sentinel. Rust callers index
-    // by .len() so we keep the None in the boxed slice.
+    // Callers index by .len(), so keep the trailing null in the boxed slice.
     Ok(argv.into_boxed_slice())
 }
 
@@ -557,7 +557,7 @@ impl ChannelOwner for WorkerCommands {
     }
 }
 
-// PORT NOTE: hoisted from local struct inside run_as_worker — Rust does not
+// Hoisted from a local struct inside run_as_worker — Rust does not
 // support method-bearing local structs that need to be named in a generic call.
 struct WorkerLoop<'a> {
     reporter: &'a mut CommandLineReporter,
@@ -627,8 +627,6 @@ impl<'a> WorkerLoop<'a> {
 
             let after = *self.reporter.summary();
             wf.begin(frame::Kind::FileDone);
-            // PORT NOTE: was `inline for (.{...}) |v| worker_frame.u32_(v)` —
-            // all elements are u32, so a plain array + for loop is equivalent.
             for v in [
                 idx,
                 after.pass - before.pass,
@@ -668,8 +666,9 @@ pub fn run_as_worker(
     vm_ref.test_isolation_enabled = true;
     vm_ref.auto_killer.enabled = true;
 
-    // TODO(port): MimallocArena assigned to vm.arena/vm.allocator — verify
-    // whether Rust VM still needs explicit arena wiring or if this is a no-op.
+    // `vm.arena` is currently a write-only backref: the `MimallocArena.gc()`
+    // reader was dropped from the GC path (see web_worker.rs, which wires its
+    // own arena the same way and notes the dropped read).
     let mut arena = bun_alloc::MimallocArena::new();
     // SAFETY: event_loop pointer is valid while vm lives.
     unsafe { (*vm_ref.event_loop()).ensure_waker() };
@@ -807,8 +806,8 @@ static WORKER_FRAME: bun_core::RacyCell<Frame> = bun_core::RacyCell::new(Frame::
 /// `CommandLineReporter.handleTestCompleted`) can reach the channel.
 // PORTING.md §Global mutable state: single-worker-thread ptr slot → RacyCell.
 static WORKER_CMDS: bun_core::RacyCell<Option<*mut WorkerCommands>> = bun_core::RacyCell::new(None);
-// TODO(port): lifetime — stores a 'a-bound pointer as 'static; sound because
-// the pointee outlives all callers (process exits before it's dropped).
+// Lifetime note: stores an 'a-bound pointer as 'static; sound because the
+// pointee outlives all callers (process exits before it's dropped).
 
 /// Called from `CommandLineReporter.handleTestCompleted` in the worker with the
 /// fully-formatted status line (✓/✗ + scopes + name + duration, including ANSI
@@ -828,5 +827,3 @@ pub fn worker_emit_test_done(file_idx: u32, formatted_line: &[u8]) {
     wf.str(formatted_line);
     cmds.send(wf.finish());
 }
-
-// ported from: src/cli/test/parallel/runner.zig
diff --git a/src/runtime/cli/test_command.rs b/src/runtime/cli/test_command.rs
index 2df3931360e..f95d317a8fc 100644
--- a/src/runtime/cli/test_command.rs
+++ b/src/runtime/cli/test_command.rs
@@ -24,22 +24,21 @@ use bun_ptr::Interned;
 use bun_resolver::fs::FileSystem;
 use bun_sys::{self, Fd, File};
 
-// Debug log scope for test-runner entrypoint loading (Zig: bun.jsc.Jest.bun_test.debug.group).
+// Debug log scope for test-runner entrypoint loading.
 bun_output::declare_scope!(bun_test, hidden);
 
 // ─── coverage façade ────────────────────────────────────────────────────────
 // Thin adapter over `bun_sourcemap_jsc::code_coverage` that preserves the
-// Zig-shaped call paths used in `print_code_coverage` below
-// (`CodeCoverageReport::Text::writeFormat(..., enable_ansi_colors)` took a
-// runtime bool in Zig; the Rust port lifted it to a const generic, so the
-// adapter dispatches). Drop once the body is normalised to call
-// `code_coverage::{text,lcov}` directly with `<ENABLE_ANSI_COLORS>`.
+// legacy call paths used in `print_code_coverage` below (the adapter
+// dispatches the runtime `enable_ansi_colors` bool to the const generic).
+// Drop once the body is normalised to call `code_coverage::{text,lcov}`
+// directly with `<ENABLE_ANSI_COLORS>`.
 mod coverage {
     pub(super) use bun_sourcemap_jsc::code_coverage::{
         ByteRangeMapping, Fraction, Report as CodeCoverageReport, lcov as Lcov,
     };
 
-    /// `std.sort.pdq(..., isLessThan)` adapter — Rust `sort_by` wants `Ordering`.
+    /// Less-than predicate adapted to the `Ordering` shape `sort_by` wants.
     #[inline]
     pub(super) fn is_less_than_cmp(
         a: &&mut ByteRangeMapping,
@@ -114,7 +113,7 @@ mod coverage {
 }
 use coverage::{ByteRangeMapping, CodeCoverageReport, Fraction};
 
-// ─── compat shim: map Zig-shaped paths onto the test_runner crate ────────────
+// ─── compat shim: map legacy paths onto the test_runner crate ────────────────
 // The body was originally written against `bun_jsc::jest::{bun_test, Snapshots,
 // TestRunner}` before `crate::test_runner` existed. Those types now live under
 // `crate::test_runner::*`; the façade below adapts the body's nested-path
@@ -128,12 +127,11 @@ pub use bun_options_types::code_coverage_options::Reporters as CoverageReporters
 
 #[allow(non_snake_case)]
 mod bun_test {
-    //! Façade over `crate::test_runner` that preserves the Zig-shaped paths
+    //! Façade over `crate::test_runner` that preserves the legacy paths
     //! the body uses (`bun_test::Execution::Result`, `bun_test::BasicResult`,
     //! `bun_test::DescribeScope`, …). Drop once the body is normalised.
 
-    /// `add_result()` queue payload — Zig spells it `bun_test.ResultMsg.start`;
-    /// Rust port collapsed it into `RefDataValue`.
+    /// `add_result()` queue payload.
     pub(super) use crate::test_runner::bun_test::RefDataValue as ResultMsg;
     pub(super) use crate::test_runner::bun_test::*;
     pub(super) use crate::test_runner::execution::{
@@ -149,7 +147,6 @@ pub(crate) fn escape_xml(
     str_: &[u8],
     writer: &mut impl bun_io::Write,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let mut last: usize = 0;
     let mut i: usize = 0;
     let len = str_.len();
@@ -206,9 +203,6 @@ pub fn write_test_status_line(
     status: bun_test::Execution::Result,
     writer: &mut impl bun_io::Write,
 ) {
-    // PORT NOTE: was `comptime status` in Zig; `Execution::Result` lacks
-    // `ConstParamTy`, so this is a runtime arg.
-    // PERF(port): was comptime monomorphization — profile if it shows up on a hot path.
     if Output::enable_ansi_colors_stderr() {
         let _ = writer.write_all(&fmt_status_text_line(status, true));
     } else {
@@ -248,9 +242,8 @@ pub struct SuiteInfo {
     pub line_number: u32,
 }
 
-// PORT NOTE: SuiteInfo::deinit only freed `name` when !is_file_suite. With Box<[u8]> the
-// drop is unconditional but harmless (file-suite case stored a borrowed slice in Zig — we
-// dupe it now in begin_test_suite_with_line). // TODO(port): revisit ownership of file name.
+// We dupe the name unconditionally in begin_test_suite_with_line, so the
+// unconditional drop is correct.
 
 #[derive(Default, Clone, Copy)]
 pub struct Metrics {
@@ -309,14 +302,13 @@ impl JunitReporter {
         Box::new(JunitReporter::default())
     }
 
-    // PORT NOTE: `pub const new = bun.TrivialNew(JunitReporter);` → Box::new
+    // `pub const new = bun.TrivialNew(JunitReporter);` → Box::new
 
     fn generate_properties_list(&mut self) -> Result<(), bun_core::Error> {
         struct PropertiesList<'a> {
             ci: &'a [u8],
             commit: &'a [u8],
         }
-        // PERF(port): was arena bulk-free + stack-fallback alloc — profile if it shows up on a hot path.
 
         let ci_buf: Vec<u8>;
         let ci: &[u8] = 'brk: {
@@ -328,7 +320,7 @@ impl JunitReporter {
                             && !github_repository.is_empty()
                         {
                             let mut v = Vec::new();
-                            // PORT NOTE: std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
+                            // Std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
                             let _ = write!(
                                 &mut v,
                                 "{}/{}/actions/runs/{}",
@@ -442,14 +434,14 @@ impl JunitReporter {
             self.contents.extend_from_slice(b"\"");
         } else if !self.current_file.is_empty() {
             self.contents.extend_from_slice(b" file=\"");
-            // PORT NOTE: reshaped for borrowck — clone current_file slice before mutable borrow of contents
+            // Reshaped for borrowck — clone current_file slice before mutable borrow of contents
             let cf = self.current_file.clone();
             escape_xml(&cf, &mut self.contents)?;
             self.contents.extend_from_slice(b"\"");
         }
 
         if line_number > 0 {
-            // PORT NOTE: std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
+            // Std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
             let _ = write!(&mut self.contents, " line=\"{}\"", line_number);
         }
 
@@ -471,7 +463,6 @@ impl JunitReporter {
 
         self.suite_stack.push(SuiteInfo {
             name: Box::<[u8]>::from(name),
-            // TODO(port): Zig stored borrowed `name` for file suites; we dupe always.
             offset_of_attributes,
             metrics: Metrics::default(),
             is_file_suite,
@@ -493,19 +484,17 @@ impl JunitReporter {
         self.current_depth -= 1;
         let suite_info = self.suite_stack.swap_remove(self.suite_stack.len() - 1);
 
-        // PERF(port): was arena bulk-free + stack-fallback alloc — profile if it shows up on a hot path.
-
         let elapsed_time_ms = suite_info.metrics.elapsed_time;
         let elapsed_time_ms_f64: f64 = elapsed_time_ms as f64;
         let elapsed_time_seconds = elapsed_time_ms_f64 / bun::time::MS_PER_S as f64;
 
-        // PORT NOTE: reshaped for borrowck — get hostname first
+        // Reshaped for borrowck — get hostname first
         let hostname = self.get_hostname().map(|h| h.to_vec()).unwrap_or_default();
 
         // Insert the summary attributes
         let mut summary = Vec::new();
         {
-            // PORT NOTE: std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
+            // Std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
             let _ = write!(
                 &mut summary,
                 "tests=\"{}\" assertions=\"{}\" failures=\"{}\" skipped=\"{}\" time=\"{}\" hostname=\"{}\"",
@@ -546,7 +535,7 @@ impl JunitReporter {
         elapsed_ns: u64,
         line_number: u32,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
+        // Std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
         let elapsed_ns_f64: f64 = elapsed_ns as f64;
         let elapsed_ms = elapsed_ns_f64 / bun::time::NS_PER_MS as f64;
 
@@ -720,13 +709,12 @@ impl JunitReporter {
         }
 
         {
-            // PERF(port): was arena bulk-free + stack-fallback alloc — profile if it shows up on a hot path.
             let metrics = self.total_metrics;
             let elapsed_time = (bun::time::nano_timestamp() - bun::start_time()) as f64
                 / bun::time::NS_PER_S as f64;
             let mut summary = Vec::new();
             {
-                // PORT NOTE: std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
+                // Std::io::Write removed; bun_io::Write (top-level) provides write_fmt.
                 let _ = write!(
                     &mut summary,
                     "tests=\"{}\" assertions=\"{}\" failures=\"{}\" skipped=\"{}\" time=\"{}\"",
@@ -780,16 +768,15 @@ impl JunitReporter {
 }
 
 pub struct CommandLineReporter {
-    // TODO(port): `TestRunner<'a>` borrows `TestOptions`/regex from the CLI
-    // ctx; the reporter is held in a `Box` local to `TestCommand::exec` which
-    // never returns before process exit, so `'static` is sound here. Revisit
-    // if the reporter ever becomes scoped.
+    // `TestRunner<'a>` borrows `TestOptions`/regex from the CLI ctx; the
+    // reporter is held in a `Box` local to `TestCommand::exec` which never
+    // returns before process exit, so `'static` is sound here. Revisit if the
+    // reporter ever becomes scoped.
     pub jest: TestRunner<'static>,
     pub last_dot: u32,
     pub prev_file: u64,
     pub repeat_count: u32,
     /// Interior-mut: written from `BunTestRoot::on_before_print` via `&CommandLineReporter`
-    /// (Zig stores `?*CommandLineReporter` and freely mutates; Rust holds `&'a CommandLineReporter`).
     pub last_printed_dot: core::cell::Cell<bool>,
 
     /// When running as a `--parallel` worker, this is the coordinator-assigned
@@ -812,10 +799,6 @@ pub struct ReportersConfig {
     pub junit: Option<Box<JunitReporter>>,
 }
 
-// TODO(port): DotColorMap (std.EnumMap<TestRunner.Test.Status, &str>) and `dots` const
-// initialization — port once Output::RESET / ED / color_map are available in bun_core.
-// type DotColorMap = enum_map::EnumMap<TestRunner::Test::Status, Option<&'static [u8]>>;
-
 impl CommandLineReporter {
     pub fn handle_test_start(_: &mut Self, _: /* TestRunner.Test.ID */ u32) {}
 
@@ -826,7 +809,6 @@ impl CommandLineReporter {
         elapsed_ns: u64,
         writer: &mut impl bun_io::Write,
     ) {
-        // PERF(port): was comptime monomorphization on `status` — profile if it shows up on a hot path.
         let initial_retry_count = test_entry.retry_count;
         let attempts = (initial_retry_count - sequence.remaining_retry_count) + 1;
         let initial_repeat_count = test_entry.repeat_count;
@@ -849,10 +831,10 @@ impl CommandLineReporter {
 
         // Quieter output when claude code is in use.
         if !Output::is_ai_agent() || !status.is_pass(bun_test::PendingMode::PendingIsFail) {
-            // PORT NOTE: Zig comptime `color_code`/`line_color_code` literals are inlined at use
-            // sites below via `if DIM { ... } else { ... }` to avoid runtime `format!`.
+            // `color_code`/`line_color_code` literals are inlined at use sites
+            // below via `if DIM { ... } else { ... }` to avoid runtime `format!`.
 
-            // PORT NOTE: `switch (Output.enable_ansi_colors_stderr) { inline else => |_| ... }` — the
+            // `switch (Output.enable_ansi_colors_stderr) { inline else => |_| ... }` — the
             // captured bool was unused except for monomorphization; collapsed to runtime.
             match status {
                 bun_test::Execution::Result::FailBecauseExpectedAssertionCount => {
@@ -1047,14 +1029,12 @@ impl CommandLineReporter {
         test_entry: &mut bun_test::ExecutionEntry,
         elapsed_ns: u64,
     ) {
-        // PERF(port): was comptime monomorphization on `status` — profile if it shows up on a hot path.
         let Some(cmd_reporter) = buntest.reporter else {
             return;
         };
         // SAFETY: `BunTest.reporter` is `NonNull<CommandLineReporter>` with write
         // provenance from `enter_file`'s `&mut`; single-threaded test runner,
-        // exclusive access for the duration of this callback (mirrors Zig
-        // `?*CommandLineReporter`).
+        // exclusive access for the duration of this callback.
         let cmd_reporter: &mut CommandLineReporter = unsafe { &mut *cmd_reporter.as_ptr() };
         let Some(junit) = cmd_reporter.reporters.junit.as_mut() else {
             return;
@@ -1201,7 +1181,6 @@ impl CommandLineReporter {
                 describe_suite_index += 1;
             }
 
-            // PERF(port): was arena bulk-free + stack-fallback alloc — profile if it shows up on a hot path.
             let mut concatenated_describe_scopes: Vec<u8> = Vec::new();
 
             {
@@ -1263,16 +1242,13 @@ impl CommandLineReporter {
         let initial_length = output_buf.len();
         let writer = &mut output_buf;
 
-        // PORT NOTE: `switch (sequence.result) { inline else => |result| ... }` — Zig comptime
-        // dispatch on enum value. Demoted to runtime match.
-        // PERF(port): was comptime monomorphization — profile if it shows up on a hot path.
         let result = sequence.result;
         if result != bun_test::Execution::Result::SkippedBecauseLabel {
             // SAFETY: `BunTest.reporter` is `NonNull<CommandLineReporter>` with write
             // provenance from `enter_file`'s `&mut`; single-threaded; reporter outlives
             // every BunTest. Scoped to this block so the SharedReadOnly tag is dead
             // before `maybe_print_junit_line` derives `&mut` from the same `NonNull`
-            // (stacked-borrows hygiene — Zig re-reads `buntest.reporter.?` per site).
+            // (stacked-borrows hygiene).
             let reporter_ref: Option<&CommandLineReporter> =
                 buntest.reporter.map(|p| unsafe { &*p.as_ptr() });
             let basic = result.basic_result();
@@ -1311,7 +1287,6 @@ impl CommandLineReporter {
             } else {
                 buntest.bun_test_root.on_before_print();
 
-                // TODO(port): write_test_status_line takes comptime status in Zig
                 if Output::enable_ansi_colors_stderr() {
                     let _ = writer.write_all(&fmt_status_text_line(result, true));
                 } else {
@@ -1344,7 +1319,7 @@ impl CommandLineReporter {
         let formatted_line = &output_buf[initial_length..];
         // SAFETY: `BunTest.reporter` is `NonNull<CommandLineReporter>`; re-derived
         // here (not held across `maybe_print_junit_line`'s `&mut`) per stacked
-        // borrows. Mirrors Zig's per-site `buntest.reporter.?` deref.
+        // borrows.
         let worker_idx = buntest
             .reporter
             .and_then(|p| unsafe { (*p.as_ptr()).worker_ipc_file_idx });
@@ -1454,8 +1429,6 @@ impl CommandLineReporter {
         vm: &mut VirtualMachine,
         opts: &mut CodeCoverageOptions,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): Zig used `comptime reporters: TestCommand.Reporters` (a struct value).
-        // Split into const-generic bools here; could be a const-param struct instead.
         if !REPORTERS_TEXT && !REPORTERS_LCOV {
             return Ok(());
         }
@@ -1466,14 +1439,12 @@ impl CommandLineReporter {
         // SAFETY: thread-local Box pinned for the thread; sole `&mut` for the
         // collection loop below (single-threaded CLI report path).
         let map = unsafe { &mut *map.as_ptr() };
-        // PORT NOTE: Zig bitwise-copied each `ByteRangeMapping` out of the map
-        // (`entry.*`). The Rust struct owns a `MultiArrayList` and is not
-        // `Copy`, so collect mutable borrows into the thread-local map instead
-        // — same observable behaviour, no double-free risk.
+        // `ByteRangeMapping` owns a `MultiArrayList` and is not `Copy`, so
+        // collect mutable borrows into the thread-local map instead — no
+        // double-free risk.
         let mut byte_ranges: Vec<&mut ByteRangeMapping> = Vec::with_capacity(map.len());
         for entry in map.values_mut() {
             byte_ranges.push(entry);
-            // PERF(port): was assume_capacity
         }
 
         if byte_ranges.is_empty() {
@@ -1503,11 +1474,10 @@ impl CommandLineReporter {
         // SAFETY: thread-local Box pinned for the thread; sole `&mut` for the
         // collection loop below (single-threaded CLI report path).
         let map = unsafe { &mut *map.as_ptr() };
-        // PORT NOTE: see `generate_code_coverage` — collect borrows, not bitwise copies.
+        // See `generate_code_coverage` — collect borrows, not bitwise copies.
         let mut byte_ranges: Vec<&mut ByteRangeMapping> = Vec::with_capacity(map.len());
         for entry in map.values_mut() {
             byte_ranges.push(entry);
-            // PERF(port): was assume_capacity
         }
         if byte_ranges.is_empty() {
             return Ok(());
@@ -1531,9 +1501,7 @@ impl CommandLineReporter {
             }
             bun_sys::Result::Ok(f) => f,
         };
-        // TODO(port): file.writer().adaptToNewApi(buf) — Zig's buffered writer adapter
-        // not present on `bun_sys::File`; buffer in a Vec (impl `bun_io::Write`) and
-        // write through in one shot below.
+        // Buffer in a Vec (impl `bun_io::Write`) and write through in one shot below.
         let mut buffered: Vec<u8> = Vec::with_capacity(64 * 1024);
         let writer = &mut buffered;
 
@@ -1579,7 +1547,7 @@ impl CommandLineReporter {
         opts: &mut CodeCoverageOptions,
         byte_ranges: &mut [&mut ByteRangeMapping],
     ) -> Result<(), bun_core::Error> {
-        // `perf::Ctx` ends its span on Drop — Zig's `defer trace.end()` is the binding itself.
+        // `perf::Ctx` ends its span on Drop.
         let _trace = if REPORTERS_TEXT && REPORTERS_LCOV {
             bun::perf::trace("TestCommand.printCodeCoverageLCovAndText")
         } else if REPORTERS_TEXT {
@@ -1587,7 +1555,7 @@ impl CommandLineReporter {
         } else if REPORTERS_LCOV {
             bun::perf::trace("TestCommand.printCodeCoverageLCov")
         } else {
-            // TODO(port): @compileError("No reporters enabled") — could enforce via a const assert.
+            // Unreachable by construction.
             unreachable!("No reporters enabled")
         };
 
@@ -1665,7 +1633,6 @@ impl CommandLineReporter {
             {
                 return Ok(());
             }
-            // writer.writeAll(Output.prettyFmt(" <d>|<r> % Funcs <d>|<r> % Blocks <d>|<r> % Lines <d>|<r> Uncovered Line #s\n", enable_ansi_colors)) catch return;
             if console
                 .write_all(&Output::pretty_fmt::<ENABLE_ANSI_COLORS>(
                     " <d>|<r> % Funcs <d>|<r> % Lines <d>|<r> Uncovered Line #s\n",
@@ -1728,8 +1695,7 @@ impl CommandLineReporter {
                     let mut base64_bytes = [0u8; 8];
                     let mut shortname_buf = [0u8; 512];
                     bun_core::csprng(&mut base64_bytes);
-                    // Spec: `std.fmt.bufPrintZ(..., ".lcov.info.{x}.tmp", .{&base64_bytes})`
-                    // — Zig `{x}` on `*[8]u8` prints contiguous lowercase hex.
+                    // Temp name: `.lcov.info.<lowercase hex of 8 random bytes>.tmp`.
                     let tmpname = {
                         use std::io::Write as _;
                         let mut cursor = &mut shortname_buf[..];
@@ -1766,10 +1732,9 @@ impl CommandLineReporter {
                             Global::exit(1);
                         }
                         bun_sys::Result::Ok(f) => {
-                            // TODO(port): Zig used `f.writer().adaptToNewApi(buf)` (64 KB
-                            // buffered file writer). `bun_sys::File` has no `writer()` yet;
-                            // accumulate in a `Vec<u8>` (impl `bun_io::Write`) and flush to
-                            // the fd via `write_all` on success below.
+                            // Accumulate in a `Vec<u8>` (impl `bun_io::Write`)
+                            // and flush to the fd via `write_all` on success
+                            // below.
                             let buffered: Vec<u8> = Vec::with_capacity(64 * 1024);
                             break 'brk Some((f, path, buffered));
                         }
@@ -1783,7 +1748,7 @@ impl CommandLineReporter {
             |s: &mut Option<(File, &bun_core::ZStr, Vec<u8>)>| {
                 if REPORTERS_LCOV {
                     if let Some((file, name, _)) = s.take() {
-                        let _ = file.close(); // close error is non-actionable (Zig parity: discarded)
+                        let _ = file.close(); // close error is non-actionable
                         let _ = bun_sys::unlink(name);
                     }
                 }
@@ -1891,9 +1856,8 @@ impl CommandLineReporter {
 
             console.write_all(&console_buffer)?;
             console.write_all(&Output::pretty_fmt::<ENABLE_ANSI_COLORS>("<r><d>"))?;
-            // Spec uses `catch return` (NOT `try`) — Zig's `errdefer` does not
-            // fire on a success-return, so disarm the lcov cleanup guard before
-            // the early `Ok(())` (matches Zig: temp file is left for the OS).
+            // Disarm the lcov cleanup guard before the early `Ok(())`; the
+            // temp file is left for the OS.
             if console
                 .splat_byte_all(b'-', max_filepath_length + 2)
                 .is_err()
@@ -1920,8 +1884,7 @@ impl CommandLineReporter {
             // write so an error here still closes + unlinks the temp file.
             if let Some((lcov_file, _, buffered)) = &mut **lcov_guard {
                 if let bun_sys::Result::Err(e) = lcov_file.write_all(buffered) {
-                    // `lcov_guard` drops on this early return → close + unlink
-                    // (mirrors Zig's `errdefer`).
+                    // `lcov_guard` drops on this early return → close + unlink.
                     return Err(bun_core::Error::from(e));
                 }
             }
@@ -1997,15 +1960,13 @@ pub(crate) struct TestCommand;
 
 impl TestCommand {
     // pub use bun_options_types::code_coverage_options::{CodeCoverageOptions, Reporter, Reporters};
-    // PORT NOTE: re-exports moved to top-level `use` per crate map.
+    // Re-exports moved to top-level `use` per crate map.
 
     pub(crate) fn exec(ctx: Command::Context) -> Result<(), bun_core::Error> {
         Output::IS_GITHUB_ACTION.store(
             Output::is_github_action(),
             core::sync::atomic::Ordering::Relaxed,
         );
-        // PORT NOTE: Zig `Output.is_github_action = Output.isGithubAction()` — Rust uses an
-        // AtomicBool global; `is_github_action()` performs the env-based detection.
 
         if !ctx.test_options.test_worker {
             // print the version so you know its doing stuff if it takes a sec
@@ -2039,8 +2000,8 @@ impl TestCommand {
             Output::flush();
         }
 
-        // PORT NOTE: Zig used `ctx.allocator.create` with no destroy. `exec()` never
-        // returns before process exit, so the heap allocation outlives all observers.
+        // `exec()` never returns before process exit, so the heap allocation
+        // outlives all observers.
         // `Loader::init` borrows the map; erase to `'static` via raw pointer round-trip
         // (the map is never freed — process-lifetime singleton).
         let env_map: *mut DotEnv::Map = bun_core::heap::into_raw(Box::new(DotEnv::Map::init()));
@@ -2064,8 +2025,8 @@ impl TestCommand {
         if enable_random {
             ctx.test_options.seed = Some(seed);
         }
-        // PORT NOTE: Zig threads a `std.Random` vtable; Rust `DefaultPrng` is `Copy`, so
-        // pass the prng by value to TestRunner and keep a local copy for shuffling.
+        // `DefaultPrng` is `Copy`, so pass the prng by value to TestRunner
+        // and keep a local copy for shuffling.
         let random_instance: Option<bun::rand::DefaultPrng> = if enable_random {
             Some(bun::rand::DefaultPrng::init(seed as u64))
         } else {
@@ -2073,9 +2034,8 @@ impl TestCommand {
         };
 
         let mut snapshot_file_buf: Vec<u8> = Vec::new();
-        // TODO(port): `Snapshots::ValuesHashMap` is an inherent associated
-        // type alias (unstable); spell out the underlying map until that
-        // stabilises or the alias is hoisted to module scope.
+        // `Snapshots::ValuesHashMap` would be an inherent associated type alias
+        // (unstable in Rust); spell out the underlying map instead.
         let mut snapshot_values: bun_collections::HashMap<u64, Box<[u8]>> =
             bun_collections::HashMap::new();
         let mut snapshot_counts: StringHashMap<usize> = StringHashMap::new();
@@ -2107,10 +2067,9 @@ impl TestCommand {
             .map(|b| unsafe { bun_ptr::detach_lifetime::<u8>(b) })
             .collect();
 
-        // PORT NOTE: Zig used `ctx.allocator.create` with no destroy. PORTING.md
-        // §Forbidden bans leaking; keep an owned `Box` local — `exec()` never
-        // returns before process exit, so the heap allocation outlives all
-        // raw-pointer observers (e.g. `Jest::RUNNER` below).
+        // Keep an owned `Box` local — `exec()` never returns before process
+        // exit, so the heap allocation outlives all raw-pointer observers
+        // (e.g. `Jest::RUNNER` below).
         let mut reporter: Box<CommandLineReporter> = Box::new(CommandLineReporter {
             jest: TestRunner {
                 default_timeout_ms: ctx.test_options.default_timeout_ms,
@@ -2143,7 +2102,7 @@ impl TestCommand {
                     failed: 0,
                     // SAFETY: lifetime-erase to `'static`; the backing locals are
                     // declared in this never-returning frame (`exec()` only exits
-                    // via process exit), mirroring Zig's stack-address capture.
+                    // via process exit).
                     file_buf: unsafe { bun_ptr::detach_lifetime_mut(&mut snapshot_file_buf) },
                     // SAFETY: same never-returning-frame invariant as `file_buf` above.
                     values: unsafe { bun_ptr::detach_lifetime_mut(&mut snapshot_values) },
@@ -2158,9 +2117,9 @@ impl TestCommand {
                     last_error_snapshot_name: None,
                 },
                 bun_test_root: bun_test::BunTestRoot::init(),
-                // PORT NOTE: Zig zero-init defaults; `TestRunner` cannot derive
-                // `Default` because of the `&'a TestOptions` field, so spell the
-                // remaining fields out explicitly.
+                // `TestRunner` cannot derive `Default` because of the
+                // `&'a TestOptions` field, so spell the remaining fields out
+                // explicitly.
                 current_file: jest::CurrentFile::default(),
                 files: jest::FileList::default(),
                 index: jest::FileMap::default(),
@@ -2184,7 +2143,7 @@ impl TestCommand {
             todos_to_repeat_buf: Vec::new(),
             reporters: ReportersConfig::default(),
         });
-        // PORT NOTE: `defer { if (reporter.reporters.junit) |fr| fr.deinit() }` — handled by Drop.
+        // `defer { if (reporter.reporters.junit) |fr| fr.deinit() }` — handled by Drop.
         reporter.repeat_count = ctx.test_options.repeat_count.max(1);
         // SAFETY: single-threaded CLI startup; `reporter` is a `Box` that lives
         // until `exec()` exits the process, so `&mut reporter.jest` remains
@@ -2192,7 +2151,7 @@ impl TestCommand {
         unsafe {
             jest::Jest::RUNNER.write(Some(core::ptr::NonNull::from(&mut reporter.jest)));
         }
-        // PORT NOTE: `reporter.jest.test_options` is initialised in the struct
+        // `reporter.jest.test_options` is initialised in the struct
         // literal above (lifetime-erased); the post-init assignment is dropped.
 
         if ctx.test_options.reporters.junit {
@@ -2215,7 +2174,7 @@ impl TestCommand {
                 // reads ctx.args.{conditions,define,loaders,tsconfig_override,drop,
                 // main_fields,extension_order,env_files,feature_flags,preserve_symlinks,
                 // allow_addons,disable_default_env_files,jsx} after this point to forward
-                // them to workers. Zig spec passes ctx.args by value-copy here.
+                // them to workers.
                 transform_options: ctx.args.clone(),
                 debugger: core::mem::take(&mut ctx.runtime_options.debugger),
                 log: core::ptr::NonNull::new(ctx.log),
@@ -2378,12 +2337,10 @@ impl TestCommand {
             #[cfg(windows)]
             let filter_names: &[&[u8]] = &filter_names_owned;
 
-            // PORT NOTE: on Windows the Zig duped+mutated each filter to swap
-            // `/`→`\` and stored the dup; on POSIX it borrowed straight from
-            // `ctx.positionals`. Rust unifies on a `Vec<&[u8]>` view either
-            // way (already built above as `filter_names_owned`); the Windows
-            // branch additionally needs an owned backing `Vec<Box<[u8]>>` for
-            // the rewritten bytes plus a second view vec over those boxes.
+            // Both platforms use a `Vec<&[u8]>` view (already built above as
+            // `filter_names_owned`); the Windows branch additionally needs an
+            // owned backing `Vec<Box<[u8]>>` for the `/`→`\`-rewritten bytes
+            // plus a second view vec over those boxes.
             #[cfg(windows)]
             let filter_names_normalized_storage: Vec<Box<[u8]>> = {
                 let mut normalized = Vec::with_capacity(filter_names.len());
@@ -2406,9 +2363,8 @@ impl TestCommand {
                 .collect();
             #[cfg(not(windows))]
             let filter_names_normalized: &Vec<&'static [u8]> = &filter_names_owned;
-            // PORT NOTE: Zig's `defer free` on Windows maps to Drop of the
-            // `Vec<Box<[u8]>>` storage above — but Drop never actually runs
-            // here (frame never returns); the storage simply outlives use.
+            // Drop of the `Vec<Box<[u8]>>` storage above never actually runs
+            // (frame never returns); the storage simply outlives use.
             // SAFETY: lifetime-erase the outer borrow; the view vec and (on
             // Windows) its backing storage live in this never-returning frame,
             // and the underlying bytes are either in `ctx` (process-lifetime)
@@ -2416,9 +2372,7 @@ impl TestCommand {
             scanner.filter_names =
                 unsafe { bun_ptr::detach_lifetime(&filter_names_normalized[..]) };
 
-            // PORT NOTE: Zig used `vm.allocator.dupe` (arena-scoped). PORTING.md
-            // §Forbidden bans leaking to satisfy a borrow — own the joined
-            // path in a hoisted buffer and borrow from it.
+            // Own the joined path in a hoisted buffer and borrow from it.
             let dir_to_scan_owned: Vec<u8>;
             let dir_to_scan: &[u8] = 'brk: {
                 if !ctx.debug.test_directory.is_empty() {
@@ -2473,7 +2427,7 @@ impl TestCommand {
         // is not a misconfiguration.
         let mut pass_with_no_tests_from_filter = false;
         let mut changed_module_graph_files: Vec<Box<[u8]>> = Vec::new();
-        // PORT NOTE: defer free handled by Drop.
+        // Defer free handled by Drop.
         let mut test_files: &mut [Interned] = if let Some(changed_since) = &ctx.test_options.changed
         {
             'brk: {
@@ -2483,8 +2437,6 @@ impl TestCommand {
                 if all_test_files.is_empty() {
                     break 'brk &mut all_test_files[..];
                 }
-                // TODO(port): all_test_files ownership vs slicing — reshape to avoid the borrowck workaround.
-
                 let result = match ChangedFilesFilter::filter(
                     &ctx,
                     vm,
@@ -2524,9 +2476,6 @@ impl TestCommand {
         } else {
             &mut all_test_files[..]
         };
-        // TODO(port): test_files type — Zig is `[]PathString` slice into all_test_files or
-        // result.test_files; ownership in Rust needs reshaping. Using &mut [Interned] here.
-
         // --shard=M/N: sort the test files for determinism, then keep only
         // every Nth file starting at M-1. This round-robin distribution
         // keeps shards roughly balanced regardless of how many files there
@@ -2622,12 +2571,12 @@ impl TestCommand {
         if !test_files.is_empty() {
             // Randomize the order of test files if --randomize flag is set
             if let Some(mut rand) = random_instance {
-                // PORT NOTE: `std.Random.shuffle` → Fisher–Yates over `DefaultPrng::next_u64`.
+                // `std.Random.shuffle` → Fisher–Yates over `DefaultPrng::next_u64`.
                 let n = test_files.len();
                 if n > 1 {
                     let mut i = n - 1;
                     while i > 0 {
-                        // Unbiased range via 128-bit mul (Lemire); matches Zig `Random.uintLessThan`.
+                        // Unbiased range via 128-bit mul (Lemire).
                         let j = ((rand.next_u64() as u128 * (i as u128 + 1)) >> 64) as usize;
                         test_files.swap(i, j);
                         i -= 1;
@@ -2667,9 +2616,7 @@ impl TestCommand {
         if ctx.test_options.changed.is_some() && vm.is_watcher_enabled() {
             // SAFETY: `bun_watcher` is the `*mut ImportWatcher` set by
             // `enable_hot_module_reloading`; non-null because
-            // `is_watcher_enabled()` checked it. The `c_void` type is a
-            // jsc/runtime crate-cycle erasure (see field comment in VirtualMachine.rs); the
-            // cast recovers the concrete type.
+            // `is_watcher_enabled()` checked it.
             let watcher =
                 unsafe { &mut *vm.bun_watcher.cast::<jsc::hot_reloader::ImportWatcher>() };
             for path in &changed_module_graph_files {
@@ -2801,8 +2748,7 @@ impl TestCommand {
             pretty_error!("\n");
 
             if coverage_options.enabled && !ran_parallel {
-                // PORT NOTE: nested `switch ... inline else` over 3 runtime bools → 8-way dispatch.
-                // PERF(port): was comptime bool dispatch — profile if it shows up on a hot path.
+                // 8-way dispatch over 3 runtime bools.
                 match (
                     Output::enable_ansi_colors_stderr(),
                     coverage_options.reporters.text,
@@ -3088,9 +3034,9 @@ impl TestCommand {
             }
         }
 
-        // PERF(port): was MimallocArena bulk-free — profile if it shows up on a hot path.
-        // TODO(port): vm_.arena = &arena; vm_.allocator = arena.arena(); — arena threading
-        // dropped here. Reintroduce a bun_alloc::Arena and assign to vm.
+        // No MimallocArena is wired through `vm.arena` on this serial run
+        // path; the parallel worker path in runner.rs does wire one.
+        // Reintroduce here if it shows up in profiles.
         vm_.event_loop_ref().ensure_waker();
         // SAFETY: run_with_api_lock(&self) only acquires the JSC API lock around the
         // closure; ctx holds the unique &mut to the same VM and is the sole mutator.
@@ -3134,7 +3080,7 @@ impl TestCommand {
         let prev_only = reporter.jest.only;
         let reporter_ptr: *mut CommandLineReporter = reporter;
         // SAFETY: `reporter` is caller-owned and outlives this guard; raw-ptr
-        // escape mirrors Zig's `defer` so the closure does not hold a borrowck
+        // escape so the closure does not hold a borrowck
         // lock on `reporter` for the entire function body.
         scopeguard::defer! { unsafe { (*reporter_ptr).jest.only = prev_only; } }
 
@@ -3142,7 +3088,7 @@ impl TestCommand {
         vm.clear_entry_point()?;
 
         // `append_slice` interns into the process-static `FilenameStore` and
-        // returns `&'static [u8]`, matching Zig's `FilenameStore.append`.
+        // returns `&'static [u8]`.
         let file_path: &'static [u8] = FileSystem::instance()
             .filename_store
             .append_slice(resolution.path_pair.primary.text)
@@ -3184,14 +3130,14 @@ impl TestCommand {
             bun_test_root.enter_file(file_id, reporter, should_run_concurrent, first_last);
             let bun_test_root_ptr: *mut bun_test::BunTestRoot = bun_test_root;
             // SAFETY: `bun_test_root` is `&'static mut` from `Jest::runner()`;
-            // raw-ptr escape mirrors Zig `defer bun_test_root.exitFile()` so the
-            // closure does not hold a borrowck lock on it for the loop body.
+            // raw-ptr escape so the closure does not hold a borrowck lock on
+            // it for the loop body.
             scopeguard::defer! { unsafe { (*bun_test_root_ptr).exit_file(); } }
 
             // SAFETY: `set()` reads only `reporter.{worker_ipc_file_idx, reporters}`
             // and writes only `current_file` — disjoint fields. Fresh raw-ptr
-            // split (not the defer-captured `reporter_ptr`) mirrors Zig's
-            // freely-aliasing `*CommandLineReporter` without tripping borrowck.
+            // split (not the defer-captured `reporter_ptr`) keeps the borrows
+            // disjoint without tripping borrowck.
             unsafe {
                 let rp: *mut CommandLineReporter = reporter;
                 (*rp).jest.current_file.set(
@@ -3208,7 +3154,7 @@ impl TestCommand {
                 "loadEntryPointForTestRunner(\"{}\")",
                 bstr::BStr::new(file_path)
             );
-            // PORT NOTE: bun.jsc.Jest.bun_test.debug.group.log → local declare_scope!(bun_test).
+            // Bun.jsc.Jest.bun_test.debug.group.log → local declare_scope!(bun_test).
 
             // need to wake up so autoTick() doesn't wait for 16-100ms after loading the entrypoint
             vm.wakeup();
@@ -3253,8 +3199,8 @@ impl TestCommand {
                             jest::Jest::RUNNER.write(None);
                         }
                         let vm_ptr = std::ptr::from_mut::<VirtualMachine>(vm);
-                        // SAFETY: global_exit diverges; raw-ptr reborrow mirrors Zig
-                        // runWithAPILock(*VM, vm, globalExit).
+                        // SAFETY: global_exit diverges; `vm_ptr` is a fresh
+                        // raw-ptr reborrow of the exclusive `vm` borrow.
                         unsafe { (*vm_ptr).run_with_api_lock(|| (&mut *vm_ptr).global_exit()) };
                     }
 
@@ -3279,7 +3225,7 @@ impl TestCommand {
                 }
                 // `BunTestPtr` is `Rc<BunTestCell>`; clone (refcount++) so the
                 // local `buntest_strong` survives for the post-run drain loop and
-                // the explicit `drop` below (Zig's `defer buntest_strong.deinit()`).
+                // the explicit `drop` below.
                 bun_test::BunTest::run(&buntest_strong, vm.global())?;
 
                 // Process event loop while bun_test tests are running
@@ -3338,5 +3284,3 @@ pub(crate) fn handle_top_level_test_error_before_javascript_start(err: bun_core:
     }
     Global::exit(1);
 }
-
-// ported from: src/cli/test_command.zig
diff --git a/src/runtime/cli/unlink_command.rs b/src/runtime/cli/unlink_command.rs
index 6f4fd6348be..9b3cd52a0f9 100644
--- a/src/runtime/cli/unlink_command.rs
+++ b/src/runtime/cli/unlink_command.rs
@@ -20,21 +20,18 @@ pub(crate) struct UnlinkCommand;
 
 impl UnlinkCommand {
     pub(crate) fn exec(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         unlink(ctx)
     }
 }
 
 fn unlink(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let cli = CommandLineArguments::parse(Subcommand::Unlink)?;
     let (manager, _original_cwd) = match pm::init(&mut *ctx, cli, Subcommand::Unlink) {
         Ok(v) => v,
         Err(e) if e == err!(MissingPackageJSON) => {
             attempt_to_create_package_json()?;
             // Re-parse argv: `CommandLineArguments` is not `Clone`, and `parse`
-            // is deterministic over process argv. Mirrors Zig passing the
-            // by-value `cli` struct to both `init` calls.
+            // is deterministic over process argv.
             let cli = CommandLineArguments::parse(Subcommand::Unlink)?;
             pm::init(&mut *ctx, cli, Subcommand::Unlink)?
         }
@@ -109,7 +106,7 @@ fn unlink(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — `name` borrows `lockfile`; re-derive
+        // Reshaped for borrowck — `name` borrows `lockfile`; re-derive
         // it after the parse block so its lifetime is decoupled from
         // `package_json_source` (dropped above) while remaining a slice into
         // `lockfile.buffers.string_bytes`.
@@ -175,11 +172,10 @@ fn unlink(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
             let mut link_dest_buf = PathBuffer::uninit();
             let mut link_rel_buf = PathBuffer::uninit();
 
-            // PORT NOTE: Zig passed `&node_modules_path` for both
-            // `target_node_modules_path` (`*const`) and `node_modules_path`
-            // (`*mut`). Rust forbids `&` + `&mut` to the same value, so resolve
-            // the fd path twice (cheap: one `getFdPath` syscall) into two
-            // independent `AbsPath` buffers.
+            // `target_node_modules_path` (`&`) and `node_modules_path` (`&mut`)
+            // cannot alias the same value, so resolve the fd path twice
+            // (cheap: one `getFdPath` syscall) into two independent `AbsPath`
+            // buffers.
             let mut node_modules_path =
                 match <AbsPath>::init_fd_path(Fd::from_std_dir(&node_modules)) {
                     Ok(p) => p,
@@ -241,5 +237,3 @@ fn unlink(ctx: &mut ContextData) -> Result<(), bun_core::Error> {
         Global::crash();
     }
 }
-
-// ported from: src/cli/unlink_command.zig
diff --git a/src/runtime/cli/update_command.rs b/src/runtime/cli/update_command.rs
index 3fbc0e17aa3..1c543a8710f 100644
--- a/src/runtime/cli/update_command.rs
+++ b/src/runtime/cli/update_command.rs
@@ -9,8 +9,6 @@ pub(crate) struct UpdateCommand;
 
 impl UpdateCommand {
     pub(crate) fn exec(ctx: Context) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: dropped `ctx.allocator` arg — global mimalloc per §Allocators.
         let cli = CommandLineArguments::parse(Subcommand::Update)?;
 
         if cli.interactive {
@@ -21,5 +19,3 @@ impl UpdateCommand {
         Ok(())
     }
 }
-
-// ported from: src/cli/update_command.zig
diff --git a/src/runtime/cli/update_interactive_command.rs b/src/runtime/cli/update_interactive_command.rs
index e6ac938fe0b..9250567daca 100644
--- a/src/runtime/cli/update_interactive_command.rs
+++ b/src/runtime/cli/update_interactive_command.rs
@@ -23,7 +23,7 @@ use bun_install::{
 use bun_install_types::DependencyGroup;
 use bun_js_printer::{self as js_printer, BufferPrinter, BufferWriter, PrintJsonOptions};
 use bun_resolver::fs::FileSystem;
-// PORT NOTE (layering): `Expr`/`E` here are the *lower-tier* `bun_ast::js_ast`
+// Layering: `Expr`/`E` here are the *lower-tier* `bun_ast::js_ast`
 // types, NOT `bun_js_parser`. `WorkspacePackageJsonCacheEntry.root` is the
 // logger-tier `Expr` (see WorkspacePackageJSONCache.rs), so the catalog-edit
 // helpers below must operate on that type. The earlier draft imported
@@ -86,9 +86,7 @@ struct OutdatedPackage {
     /// Snapshot of `manager.options.scope.url_hash == DEFAULT_URL_HASH &&
     /// manager.scope_for_package_name(name).url_hash == DEFAULT_URL_HASH`.
     ///
-    /// PORT NOTE: Zig stores `*PackageManager` here and reads
-    /// `pkg.manager.options.scope` / `scopeForPackageName(pkg.name)` at render
-    /// time. In Rust the caller's exclusive `&mut PackageManager` in
+    /// The caller's exclusive `&mut PackageManager` in
     /// `update_interactive` is live across the prompt loop, so any
     /// `&PackageManager` derived from a stored back-pointer would alias an
     /// outstanding `&mut` (Stacked-Borrows UB). Both reads are pure
@@ -113,7 +111,8 @@ struct PackageUpdate {
 }
 
 pub(crate) struct CatalogUpdateRequest {
-    // TODO(port): lifetime — these borrow from caller in Zig; using owned for now
+    // Owned copies keep the type lifetime-free (a few small allocations in
+    // an interactive UI).
     package_name: Box<[u8]>,
     new_version: Box<[u8]>,
     catalog_name: Option<Box<[u8]>>,
@@ -173,9 +172,8 @@ impl UpdateInteractiveCommand {
     }
 
     // Helper to update a catalog entry at a specific path in the package.json AST
-    // PORT NOTE: Zig threads `*PackageManager` only for `manager.allocator`;
-    // the Rust port has no per-manager allocator, so the parameter is dropped.
-    // This also avoids overlapping `&mut PackageManager` with the live
+    // No `*PackageManager` parameter: there is no per-manager allocator,
+    // and dropping it avoids overlapping `&mut PackageManager` with the live
     // `&mut MapEntry` borrow of `manager.workspace_package_json_cache` at the
     // call sites (which the previous draft laundered via raw pointers — UB
     // under Stacked Borrows).
@@ -194,7 +192,7 @@ impl UpdateInteractiveCommand {
         buffer_writer.append_newline = preserve_trailing_newline;
         let mut package_json_writer = BufferPrinter::init(buffer_writer);
 
-        // PORT NOTE (layering): `MapEntry.root` is the T2 `bun_ast::Expr`;
+        // Layering: `MapEntry.root` is the T2 `bun_ast::Expr`;
         // `js_printer::print_json` consumes the T4 `bun_ast::Expr`. Lift via
         // the existing `From<T2> for T4` deep-rebuild (same as
         // `updatePackageJSONAndInstall` / pnpm migration). The T2 entry is not
@@ -217,8 +215,7 @@ impl UpdateInteractiveCommand {
             Box::from(package_json_writer.ctx.written_without_trailing_zero());
 
         // Write the updated package.json
-        // PORT NOTE: Zig used `std.fs.cwd().createFile(path).writeAll(..)`; the
-        // Rust port routes through `bun_sys::File::write_file` (cwd-relative
+        // Routes through `bun_sys::File::write_file` (cwd-relative
         // open + write + close) per src/CLAUDE.md.
         let mut path_zbuf = PathBuffer::uninit();
         let path_z = path::resolve_path::z(package_json_path, &mut path_zbuf);
@@ -235,7 +232,7 @@ impl UpdateInteractiveCommand {
         // Update the cache so installWithManager sees the new package.json
         // This is critical - without this, installWithManager will use the cached old version
         //
-        // PORT NOTE: cached `root` AST slices still borrow the *old*
+        // Cached `root` AST slices still borrow the *old*
         // `source.contents`; stash it instead of `mem::forget`-ing so it's
         // freed when the entry drops (`PackageManager::deinit_caches()`).
         let old = core::mem::replace(
@@ -306,7 +303,7 @@ impl UpdateInteractiveCommand {
                 Self::build_package_json_path(root_dir, workspace_path, &mut path_buf);
 
             // Load and parse the package.json
-            // PORT NOTE: reshaped for borrowck — `log_mut()` returns a borrow
+            // Reshaped for borrowck — `log_mut()` returns a borrow
             // decoupled from `&self`, so it can overlap the disjoint
             // `workspace_package_json_cache` field borrow below.
             let log = manager.log_mut();
@@ -365,10 +362,8 @@ impl UpdateInteractiveCommand {
                     preserve_version_prefix(original_version, &update.target_version)?;
 
                 // Update the version using hash map put
-                // PORT NOTE: Zig `Expr.init(E.String, …).clone(allocator)` —
-                // the `.clone(manager.allocator)` re-allocates the `E.String`
-                // *node* outside the resettable Store. `Expr::init` would put
-                // it in the Store, which `install_with_manager` resets via
+                // `Expr::init` would put the `E.String` *node*
+                // in the Store, which `install_with_manager` resets via
                 // `initialize_store()` before re-reading this cached `root`.
                 // Allocate into the entry's own `json_arena` instead so the
                 // node lives as long as the cached AST. The string *bytes* go
@@ -479,7 +474,7 @@ impl UpdateInteractiveCommand {
         original_cwd: &[u8],
         manager: &mut PackageManager,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — capture `log_level` / `ctx.log`
+        // Reshaped for borrowck — capture `log_level` / `ctx.log`
         // before borrowing `&mut manager.lockfile`.
         let not_silent = manager.options.log_level != LogLevel::Silent;
         let ctx_log_ptr: *mut bun_ast::Log = ctx.log;
@@ -523,9 +518,8 @@ impl UpdateInteractiveCommand {
                 Global::crash();
             }
             LoadResult::Ok(_) => {
-                // PORT NOTE: Zig reassigns `manager.lockfile = ok.lockfile`
-                // (pointer field). `load_lockfile_from_cwd` populates
-                // `manager.lockfile` (Box) in place, so no reassignment.
+                // `load_lockfile_from_cwd` populates `manager.lockfile` (Box)
+                // in place, so no reassignment is needed.
             }
         }
 
@@ -551,7 +545,7 @@ impl UpdateInteractiveCommand {
 
         // Get outdated packages
         let mut outdated_packages = Self::get_outdated_packages(manager, &workspace_pkg_ids)?;
-        // PORT NOTE: `defer { allocator.free(...) }` is implicit via Drop on
+        // `defer { allocator.free(...) }` is implicit via Drop on
         // `Vec<OutdatedPackage>` (Box<[u8]> fields).
 
         if outdated_packages.is_empty() {
@@ -702,9 +696,8 @@ impl UpdateInteractiveCommand {
                 // SAFETY: `ROOT_PACKAGE_JSON_PATH` is set once during
                 // `PackageManager::init` (single-threaded CLI startup).
                 let root_pkg_json = unsafe { ROOT_PACKAGE_JSON_PATH.read() };
-                // PORT NOTE: Zig passes `manager.root_dir.dir` (cwd dir handle);
-                // the Rust port of `install_with_manager` takes the original cwd
-                // path slice instead. Snapshot before the `&mut manager` borrow.
+                // `install_with_manager` takes the original cwd path slice.
+                // Snapshot before the `&mut manager` borrow.
                 let root_dir_path: &'static [u8] = manager.root_dir.dir;
                 install_with_manager::install_with_manager(
                     manager,
@@ -848,7 +841,7 @@ impl UpdateInteractiveCommand {
         }
 
         // Add grouped catalog dependencies
-        // PORT NOTE: `StringHashMap` is a Deref newtype over `std::HashMap` with no
+        // `StringHashMap` is a Deref newtype over `std::HashMap` with no
         // owning `IntoIterator`; `.drain()` (via `DerefMut`) yields owned `(K, V)`.
         let mut iter = catalog_map.drain();
         while let Some((_k, catalog_packages)) = iter.next() {
@@ -860,8 +853,8 @@ impl UpdateInteractiveCommand {
                 // Build combined workspace name
                 let mut workspace_names: Vec<u8> = Vec::new();
 
-                // PORT NOTE: Zig checks `if (catalog_packages.len > 0)` again here which is always
-                // true; preserve behavior of the true branch.
+                // `catalog_packages.len > 0` always holds here; this is the
+                // unconditional true branch of that check.
                 if let Some(catalog_name) = &first.catalog_name {
                     workspace_names.extend_from_slice(b"catalog:");
                     workspace_names.extend_from_slice(catalog_name);
@@ -895,9 +888,8 @@ impl UpdateInteractiveCommand {
         manager: &mut PackageManager,
         workspace_pkg_ids: &[PackageID],
     ) -> Result<Vec<OutdatedPackage>, bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — Zig threads `*PackageManager`
-        // into `manifests.byNameAllowExpired`, freely aliasing the receiver.
-        // Hoist the four scalars that path reads into a by-value
+        // Reshaped for borrowck —
+        // hoist the four scalars the manifest-lookup path reads into a by-value
         // `DiskCacheCtx` so the loop body holds only disjoint field borrows
         // (`&mut manager.manifests` against `&manager.lockfile` /
         // `&manager.options`). The returned `OutdatedPackage`s do *not*
@@ -944,8 +936,8 @@ impl UpdateInteractiveCommand {
 
                 let scope = manager.options.scope_for_package_name(package_name).clone();
                 // Snapshot for `OutdatedPackage.uses_default_registry` (see
-                // field PORT NOTE) — Zig defers this to render time via
-                // `pkg.manager`, which we cannot soundly alias.
+                // field comment) — cannot be deferred to render time, since a
+                // stored manager back-pointer cannot be soundly aliased.
                 let uses_default_registry = global_uses_default_registry
                     && manager.options.scope_for_package_name(name_slice).url_hash
                         == default_url_hash;
@@ -1177,18 +1169,8 @@ impl UpdateInteractiveCommand {
         // Try to get terminal size
         #[cfg(unix)]
         {
-            // TODO(port): replace std.posix.system.ioctl with bun_sys
-            // SAFETY: all-zero is a valid Winsize (#[repr(C)] POD, no NonNull/NonZero fields).
-            let mut size: bun_core::Winsize = bun_core::ffi::zeroed();
-            // SAFETY: ioctl with TIOCGWINSZ on stdout fd; size is a valid out-ptr.
-            if unsafe {
-                libc::ioctl(
-                    libc::STDOUT_FILENO,
-                    libc::TIOCGWINSZ,
-                    (&raw mut size).cast::<libc::c_void>(),
-                )
-            } == 0
-            {
+            // TIOCGWINSZ on stdout, routed through the output sink (bun_sys).
+            if let Some(size) = bun_core::output::File::from(bun_core::Fd::stdout()).winsize() {
                 // Reserve space for prompt (1 line) + scroll indicators (2 lines) + some buffer
                 let usable_height = if size.row > 6 { size.row - 4 } else { 20 };
                 return TerminalSize {
@@ -1316,8 +1298,7 @@ impl UpdateInteractiveCommand {
         };
 
         Output::flush();
-        // PORT NOTE: reshaped for borrowck — Zig returns the same `selected` slice via state;
-        // we clone the borrowed slice into an owned Box here.
+        // Reshaped for borrowck — clone the borrowed slice into an owned Box.
         Ok(Box::from(result))
     }
 
@@ -2236,17 +2217,16 @@ fn dep_type_priority(dep_type: &[u8]) -> u8 {
 
 /// Dupe a byte buffer into the process-lifetime CLI arena to obtain a
 /// `'static` slice for storage in `E::EString.data` (the AST `Str` alias is
-/// `&'static [u8]` until `'bump` is threaded through). Mirrors Zig's
-/// `allocator.dupe(u8, ...)` against the singleton `manager.allocator`.
+/// `&'static [u8]` until `'bump` is threaded through).
 #[inline]
 fn leak_dup(bytes: &[u8]) -> &'static [u8] {
     crate::cli::cli_dupe(bytes)
 }
 
 /// Edit catalog definitions in package.json
-// PORT NOTE: Zig threads `manager` only for `manager.allocator`; the Rust port
-// uses a local `Bump` (`E::Object::put` ignores its allocator arg), so the
-// parameter is dropped to keep `update_catalog_definitions` borrowck-clean.
+// No `manager` parameter: a local `Bump` is used instead
+// (`E::Object::put` ignores its allocator arg), which keeps
+// `update_catalog_definitions` borrowck-clean.
 pub(crate) fn edit_catalog_definitions(
     updates: &mut [CatalogUpdateRequest],
     current_package_json: &mut Expr,
@@ -2254,7 +2234,7 @@ pub(crate) fn edit_catalog_definitions(
     // using data store is going to result in undefined memory issues as
     // the store is cleared in some workspace situations. the solution
     // is to always avoid the store
-    // PORT NOTE: `Expr.Disabler` is a debug-only guard around the T4
+    // `Expr.Disabler` is a debug-only guard around the T4
     // `bun_js_parser` Store; the lower-tier `bun_ast::js_ast` `Expr` used
     // here boxes via its own thread-local `DATA_STORE` (see js_ast.rs), so
     // toggling the parser-tier disabler is a no-op for these allocations.
@@ -2282,7 +2262,7 @@ pub(crate) fn edit_catalog_definitions(
 }
 
 /// Where `find_catalog_object` located the existing object — the lookup and
-/// the post-mutate placement use *different* predicates in Zig (see
+/// the post-mutate placement use *different* predicates (see
 /// `update_default_catalog`), so the source must be tracked.
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum CatalogSource {
@@ -2323,17 +2303,14 @@ fn update_default_catalog(
 ) -> Result<(), bun_core::Error> {
     // Get or create the catalog object
     // First check if catalog is under workspaces.catalog
-    // PORT NOTE: reshaped — Zig copies `data.e_object.*` (struct bytes,
-    // aliasing the `Vec` ptr) and writes the mutated copy back via
-    // `parent.put("catalog", Expr.allocate(obj))`. Rust `Vec<T>` has a
-    // `Drop` that frees its buffer, so a shallow copy would double-free.
-    // Instead mutate the existing `StoreRef<E::Object>` in place (`StoreRef`
-    // is `Copy + DerefMut`). Crucially, Zig's *placement* check is looser
-    // than its lookup: it puts under `workspaces.<key>` whenever that key
-    // *exists* (any type), even when the lookup fell back to the root-level
-    // object. Track the lookup source so the in-place fast path is taken only
-    // when source == placement; otherwise re-`put` the mutated arena slot at
-    // the Zig-mandated location.
+    // Mutate the existing `StoreRef<E::Object>` in place (`StoreRef` is
+    // `Copy + DerefMut`); a shallow copy of the object would double-free its
+    // `Vec` buffer. Crucially, the *placement* check is looser than the
+    // lookup: put under `workspaces.<key>` whenever that key *exists* (any
+    // type), even when the lookup fell back to the root-level object. Track
+    // the lookup source so the in-place fast path is taken only when
+    // source == placement; otherwise re-`put` the mutated arena slot at the
+    // placement-mandated location.
     let mut fresh_obj = E::Object::default();
     let (existing, source) = find_catalog_object(package_json, b"catalog");
     {
@@ -2414,7 +2391,7 @@ fn update_named_catalog(
 ) -> Result<(), bun_core::Error> {
     // Get or create the catalogs object
     // First check if catalogs is under workspaces.catalogs (newer structure)
-    // PORT NOTE: reshaped — see `update_default_catalog` for the
+    // Reshaped — see `update_default_catalog` for the
     // shallow-copy-vs-in-place + lookup-vs-placement rationale.
     let mut fresh_catalogs = E::Object::default();
     let (existing_catalogs, source) = find_catalog_object(package_json, b"catalogs");
@@ -2580,5 +2557,3 @@ fn preserve_version_prefix(
     }
     Ok(Box::from(new_version))
 }
-
-// ported from: src/cli/update_interactive_command.zig
diff --git a/src/runtime/cli/upgrade_command.rs b/src/runtime/cli/upgrade_command.rs
index 2853d85554e..5c399eda80c 100644
--- a/src/runtime/cli/upgrade_command.rs
+++ b/src/runtime/cli/upgrade_command.rs
@@ -23,8 +23,8 @@ use crate::api::bun::process::Status;
 use crate::api::bun::process::sync as spawn_sync;
 use crate::cli::Command;
 
-// PORT NOTE: `sync::Options.argv` is `Vec<Box<[u8]>>` (owns its rows). Helper
-// to build it from borrowed slices — Zig was `&.{...}` of `[]const u8`.
+// `sync::Options.argv` is `Vec<Box<[u8]>>` (owns its rows). Helper
+// to build it from borrowed slices.
 #[inline]
 fn build_argv(parts: &[&[u8]]) -> Vec<Box<[u8]>> {
     parts.iter().map(|p| Box::<[u8]>::from(*p)).collect()
@@ -41,7 +41,7 @@ fn spawn_windows_options() -> crate::api::bun::process::WindowsOptions {
     }
 }
 
-// PORT NOTE: `bun_resolver::fs::FileSystem` (the inline canonical type surface
+// `bun_resolver::fs::FileSystem` (the inline canonical type surface
 // in `resolver/lib.rs`) does not yet expose `tmpdir()`; the full impl lives in
 // the un-exported `fs_full` module. Shim it locally — open
 // `RealFS::tmpdir_path()` as a `sys::Dir`, mirroring `RealFS::open_tmp_dir`.
@@ -54,10 +54,9 @@ impl FileSystemTmpdirExt for fs::FileSystem {
     }
 }
 
-// PORT NOTE: `bun.argv` is an `Argv` newtype (not `&[&[u8]]`), so
+// `bun.argv` is an `Argv` newtype (not `&[&[u8]]`), so
 // `strings::contains_any` can't take it directly. Local helper that scans the
-// process argv for an exact match — same semantics as Zig's
-// `strings.containsAny(bun.argv, ..)`.
+// process argv for an exact match.
 #[inline]
 fn argv_contains(target: &[u8]) -> bool {
     bun_core::argv().iter().any(|a| a == target)
@@ -155,7 +154,7 @@ impl Version {
 }
 
 // Exported C symbol — null-terminated
-// PORT NOTE: moved out of `impl Version` — Rust impl blocks cannot hold `static` items.
+// Moved out of `impl Version` — Rust impl blocks cannot hold `static` items.
 // `*const c_char` is `!Sync`, so wrap in the `#[repr(transparent)]` `SyncCStr` newtype
 // (same pattern as `Bun__userAgent` in bun_core::Global) so the C++ side still sees a
 // single `const char*`-sized symbol.
@@ -181,21 +180,13 @@ impl UpgradeCommand {
 
     const DEFAULT_GITHUB_HEADERS: &'static [u8] = b"Acceptapplication/vnd.github.v3+json";
 
-    // PORT NOTE: Zig declared module-level `var` PathBuffers (github_repository_url_buf,
-    // current_executable_buf, unzip_path_buf, tmpdir_path_buf). They are single-use scratch
-    // space; the port uses stack-local `PathBuffer::uninit()` at each call site instead
-    // (reshaped for borrowck). No global state needed.
-
     pub fn get_latest_version<const SILENT: bool>(
         env_loader: &mut DotEnv::Loader,
         refresher: Option<&mut Progress::Progress>,
         mut progress: Option<&mut Progress::Node>,
         use_profile: bool,
     ) -> Result<Option<Version>, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut headers_buf: Vec<u8> = Self::DEFAULT_GITHUB_HEADERS.to_vec();
-        // gonna have to free memory myself like a goddamn caveman due to a thread safety issue with ArenaAllocator
-        // (in Rust: Vec drops automatically; the Zig defer-free is a no-op here)
 
         let mut header_entries: headers::EntryList = headers::EntryList::default();
         let accept = headers::Entry {
@@ -219,10 +210,8 @@ impl UpgradeCommand {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — write into a local Vec instead of static buf.
         // `AsyncHTTP::init_sync` wants `URL<'static>` / `&'static [u8]`, so back
-        // the buffers in the process-lifetime CLI arena (matches the Zig
-        // original which used module-level static buffers).
+        // the buffers in the process-lifetime CLI arena.
         let url_buf: &'static mut Vec<u8> = crate::cli::cli_arena().alloc(Vec::new());
         write!(
             url_buf,
@@ -287,8 +276,10 @@ impl UpgradeCommand {
         async_http.client.flags.reject_unauthorized = env_loader.get_tls_reject_unauthorized();
 
         if !SILENT {
+            // `progress_node` stores an untracked NonNull borrow of the caller's
+            // `progress`; sound because `send_sync` below completes before this
+            // frame returns, so the pointee outlives every use.
             async_http.client.progress_node = Some(NonNull::from(progress.as_deref_mut().unwrap()));
-            // TODO(port): lifetime — progress_node stores a borrow of progress
         }
         let response = async_http.send_sync()?;
 
@@ -302,13 +293,11 @@ impl UpgradeCommand {
         }
 
         let mut log = bun_ast::Log::init();
-        // defer if SILENT log.deinit() — Drop handles this
         let source =
             bun_ast::Source::init_path_string(b"releases.json", metadata_body.list.as_slice());
         bun_ast::initialize_store();
-        // PORT NOTE: `JSON::parse_utf8` needs a bump arena; this is a one-shot
-        // CLI path so use the process-lifetime CLI arena (Zig used the global
-        // Expr/Stmt store which is process-lifetime anyway).
+        // `JSON::parse_utf8` needs a bump arena; this is a one-shot
+        // CLI path so use the process-lifetime CLI arena.
         let bump: &'static Bump = crate::cli::cli_arena();
         let expr = match JSON::parse_utf8(&source, &mut log, bump) {
             Ok(e) => e,
@@ -380,8 +369,8 @@ impl UpgradeCommand {
 
                 bun_core::pretty_errorln!(
                     "JSON Error parsing releases from GitHub: <r><red>tag_name<r> is missing?\n{}",
-                    // Zig spec prints `metadata_body.list.items` here; `version.buf`
-                    // is still empty at this point so using it loses the payload.
+                    // `version.buf` is still empty at this point;
+                    // print the raw payload instead.
                     bstr::BStr::new(metadata_body.list.as_slice())
                 );
                 Global::exit(1);
@@ -394,7 +383,6 @@ impl UpgradeCommand {
             let Some(assets_) = expr.as_property(b"assets") else {
                 break 'get_asset;
             };
-            // PORT NOTE: Zig `Expr.asArray()` returns an iterator; the T2
             // `bun_ast::Expr` only exposes the raw `EArray` payload,
             // so unwrap it and iterate `items` directly.
             let Some(assets) = assets_.expr.data.e_array() else {
@@ -511,8 +499,8 @@ impl UpgradeCommand {
             target_os = "windows"
         )))]
         {
-            // TODO(port): Environment.os.displayString() at comptime
-            "(TODO: Install script for this platform)"
+            // No install script exists for this platform; point at the docs instead.
+            "(no install script for this platform — see https://bun.com/docs/installation)"
         }
     };
 
@@ -546,13 +534,12 @@ impl UpgradeCommand {
     }
 
     fn _exec(ctx: Command::Context) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         HTTP::http_thread::init(&Default::default());
 
         // SAFETY: FileSystem::init returns the process-global singleton; valid for 'static.
         let filesystem = unsafe { &mut *fs::FileSystem::init(None)? };
         let mut env_loader: DotEnv::Loader = {
-            // Zig leaks the map; allocate in the process-lifetime CLI arena.
+            // Allocate in the process-lifetime CLI arena.
             DotEnv::Loader::init(crate::cli::cli_arena().alloc(DotEnv::Map::init()))
         };
         env_loader.load_process()?;
@@ -572,10 +559,9 @@ impl UpgradeCommand {
         let use_profile = argv_contains(b"--profile");
 
         let mut version: Version = if !use_canary {
-            // PORT NOTE: `Progress::start` returns `&mut Node` borrowing `refresher`;
+            // `Progress::start` returns `&mut Node` borrowing `refresher`;
             // leak the Progress and use raw pointers so we can pass both
-            // `&mut refresher` and `&mut progress` to `get_latest_version` (Zig
-            // freely aliased these).
+            // `&mut refresher` and `&mut progress` to `get_latest_version`.
             let refresher: *mut Progress::Progress =
                 bun_core::heap::into_raw(Box::new(Progress::Progress::default()));
             // SAFETY: refresher is a fresh leaked allocation.
@@ -662,7 +648,7 @@ impl UpgradeCommand {
             unsafe { (*progress).unit = Progress::Unit::Bytes };
             // SAFETY: refresher is a leaked Box (process-lifetime); no other &mut is live.
             unsafe { (*refresher).refresh() };
-            // Zig leaks this allocation intentionally — store in CLI arena.
+            // Store in the process-lifetime CLI arena.
             let zip_file_buffer: &'static mut MutableString = crate::cli::cli_arena()
                 .alloc(MutableString::init(version.size.max(1024) as usize)?);
 
@@ -677,10 +663,10 @@ impl UpgradeCommand {
                 None,
                 HTTP::FetchRedirect::Follow,
             ));
-            // `progress` is leaked; AsyncHTTP holds a NonNull into it.
+            // `progress` is intentionally leaked (process-lifetime), so the
+            // untracked NonNull stored in `progress_node` can never dangle.
             async_http.client.progress_node =
                 Some(NonNull::new(progress).expect("leaked Box is non-null"));
-            // TODO(port): lifetime — progress_node stores a borrow of progress
             async_http.client.flags.reject_unauthorized = env_loader.get_tls_reject_unauthorized();
 
             let response = async_http.send_sync()?;
@@ -763,7 +749,7 @@ impl UpgradeCommand {
             };
             let save_dir: sys::Dir = save_dir_it;
 
-            // PORT NOTE: reshaped for borrowck — use a stack-local PathBuffer instead of thread_local
+            // Reshaped for borrowck — use a stack-local PathBuffer instead of thread_local
             let mut tmpdir_path_buf = PathBuffer::uninit();
             let tmpdir_path = match sys::get_fd_path(save_dir.fd(), &mut tmpdir_path_buf) {
                 Ok(p) => p,
@@ -790,8 +776,6 @@ impl UpgradeCommand {
                 Self::EXE_SUBPATH.as_bytes()
             };
 
-            // PORT NOTE: Zig used std.fs.Dir.createFileZ(.{ .truncate = true }); mapped to
-            // Dir::open_file with WRONLY|CREAT|TRUNC.
             let zip_file = match save_dir.open_file(
                 tmpname.as_bytes(),
                 sys::O::WRONLY | sys::O::CREAT | sys::O::TRUNC,
@@ -847,9 +831,6 @@ impl UpgradeCommand {
                     let unzip_argv: [&[u8]; 4] =
                         [unzip_exe.as_bytes(), b"-q", b"-o", tmpname.as_bytes()];
 
-                    // PORT NOTE: Zig used `std.process.Child` directly with all stdio
-                    // set to `.Inherit` and `.spawnAndWait()`. PORTING.md / src/CLAUDE.md
-                    // map this to `bun.spawnSync` → `crate::api::bun::process::sync::spawn`.
                     let unzip_result = match spawn_sync::spawn(&spawn_sync::Options {
                         argv: build_argv(&unzip_argv),
                         envp: None,
@@ -910,9 +891,8 @@ impl UpgradeCommand {
                     .expect("oom");
 
                     let mut buf = PathBuffer::uninit();
-                    // PORT NOTE: separate fallback buffer — Zig reused `buf` for the
-                    // hardcoded path, but Rust borrowck holds `buf` for the lifetime of
-                    // `which`'s returned `Option<&ZStr>` even across the `None` arm.
+                    // Separate fallback buffer — borrowck holds `buf` for the lifetime
+                    // of `which`'s returned `Option<&ZStr>` even across the `None` arm.
                     let mut buf2 = PathBuffer::uninit();
                     let powershell_path: &ZStr = match which(
                         &mut buf,
@@ -996,10 +976,8 @@ impl UpgradeCommand {
                     },
                 ];
 
-                // PORT NOTE: Zig used `std.process.Child.run` with `.max_output_bytes = 512`.
-                // PORTING.md bans `std::process`; mapped to `bun.spawnSync` with
-                // `.stdout = .buffer`. The 512-byte cap is handled below by slicing the
-                // captured stdout (`..min(len, 512)`), matching the Zig diagnostic path.
+                // Diagnostic output is capped at 512 bytes by slicing the captured
+                // stdout below (`..min(len, 512)`).
                 let result: spawn_sync::Result = 'spawn: {
                     let spawned = spawn_sync::spawn(&spawn_sync::Options {
                         argv: build_argv(&verify_argv),
@@ -1012,8 +990,8 @@ impl UpgradeCommand {
                         windows: spawn_windows_options(),
                         ..Default::default()
                     });
-                    // Zig's `catch |err|` arm: any spawn-time failure (allocator/OOM
-                    // surfaces as `bun_core::Error`, posix_spawn surfaces as
+                    // Any spawn-time failure (allocator/OOM surfaces as
+                    // `bun_core::Error`, posix_spawn surfaces as
                     // `bun_sys::Error`) → same diagnostic + cleanup.
                     let err_name: &'static [u8] = match spawned {
                         Ok(Ok(r)) => break 'spawn r,
@@ -1025,11 +1003,10 @@ impl UpgradeCommand {
                         let _ = save_dir_.delete_tree(&version_name);
                     }
 
-                    // Zig matched `error.FileNotFound`; the bun.sys spawn path tags
-                    // it as ENOENT. Accept both to keep snapshot parity across
-                    // the std→bun.sys mapping.
+                    // The spawn path may report a missing file as either
+                    // `FileNotFound` or `ENOENT`; accept both.
                     if err_name == b"FileNotFound" || err_name == b"ENOENT" {
-                        // Zig: std.fs.cwd().access(exe, .{}) — we already chdir'd to tmpdir
+                        // We already chdir'd to tmpdir, so the relative `exe` path works.
                         if sys::exists(exe) {
                             // On systems like NixOS, the FileNotFound is actually the system-wide linker,
                             // as they do not have one (most systems have it at a known path). This is how
@@ -1093,21 +1070,20 @@ impl UpgradeCommand {
                 }
             }
 
-            // PORT NOTE: keep the `&ZStr` form for Windows `sys::rename` (needs
+            // Keep the `&ZStr` form for Windows `sys::rename` (needs
             // a NUL-terminated path); `destination_executable` (bytes view) is
             // used everywhere else.
             #[cfg_attr(not(windows), allow(unused_variables))]
             let destination_executable_z: &ZStr = bun_core::self_exe_path()
                 .map_err(|_| bun_core::err!("UpgradeFailedMissingExecutable"))?;
             let destination_executable: &[u8] = destination_executable_z.as_bytes();
-            // PORT NOTE: reshaped for borrowck — use stack-local buffer.
+            // Reshaped for borrowck — use stack-local buffer.
             // Stacked Borrows: take ONE `*mut u8` over the buffer up front and
             // route every read/write through it. Indexing the `PathBuffer`
             // directly (via Deref/DerefMut) would materialize a fresh `&[u8]`
             // or `&mut [u8]` over the *whole* array, retagging it and
             // invalidating the raw-pointer-derived `&ZStr` views below. The
-            // Zig original freely re-slices a global `var` with no aliasing
-            // model; here the single `buf_ptr` is the shared provenance root.
+            // single `buf_ptr` is the shared provenance root.
             let mut current_executable_buf = PathBuffer::uninit();
             let buf_ptr: *mut u8 = current_executable_buf.as_mut_ptr();
             // SAFETY: `buf_ptr` covers `MAX_PATH_BYTES`; `destination_executable`
@@ -1158,8 +1134,8 @@ impl UpgradeCommand {
             };
             let target_dir: sys::Dir = target_dir_it;
 
-            // PORT NOTE: `move_file_z` wants `&ZStr`; pre-compute a NUL-terminated
-            // copy of `exe` (Zig had it in a sentinel buffer).
+            // `move_file_z` wants `&ZStr`; pre-compute a NUL-terminated
+            // copy of `exe`.
             let mut exe_z_buf = PathBuffer::uninit();
             exe_z_buf[..exe.len()].copy_from_slice(exe);
             exe_z_buf[exe.len()] = 0;
@@ -1197,13 +1173,12 @@ impl UpgradeCommand {
                 if target_stat.st_size == dest_stat.st_size && target_stat.st_size > 0 {
                     let mut input_buf = vec![0u8; target_stat.st_size as usize];
 
-                    // PORT NOTE: `Dir::read_file` (Zig std.fs.Dir.readFile) is open + read_all + close.
                     let target_hash = hash(
                         match target_dir
                             .open_file(target_filename.as_bytes(), sys::O::RDONLY, 0)
                             .and_then(|f| {
                                 let n = f.read_all(&mut input_buf);
-                                let _ = f.close(); // close error is non-actionable (Zig parity: discarded)
+                                let _ = f.close(); // close error is non-actionable
                                 n
                             }) {
                             Ok(n) => &input_buf[..n],
@@ -1221,7 +1196,7 @@ impl UpgradeCommand {
                     let source_hash = hash(
                         match save_dir.open_file(exe, sys::O::RDONLY, 0).and_then(|f| {
                             let n = f.read_all(&mut input_buf);
-                            let _ = f.close(); // close error is non-actionable (Zig parity: discarded)
+                            let _ = f.close(); // close error is non-actionable
                             n
                         }) {
                             Ok(n) => &input_buf[..n],
@@ -1269,7 +1244,7 @@ impl UpgradeCommand {
                         bstr::BStr::new(target_filename.as_bytes())
                     )
                     .expect("oom");
-                    // Zig: `std.fmt.allocPrintSentinel(..., 0)` — owned NUL-terminated string.
+                    // Owned NUL-terminated string.
                     outdated_filename = Some(bun_core::ZBox::from_vec(buf));
                     if let Err(err) = sys::rename(
                         destination_executable_z,
@@ -1334,13 +1309,9 @@ impl UpgradeCommand {
                 let completions_argv: [&[u8]; 2] = [target_filename.as_bytes(), b"completions"];
 
                 let _ = env_loader.map.put(b"IS_BUN_AUTO_UPDATE", b"true");
-                // PORT NOTE: Zig used `std.process.Child.run` with `env_map = std_map.get()`
-                // and discarded the result (`_ = ... catch {}`). `bun.spawnSync` takes the
-                // C-style `[*:null]?[*:0]const u8` envp directly, so build it from the
-                // DotEnv map (`createNullDelimitedEnvMap` equivalent) instead of
-                // round-tripping through `std_env_map`. Output is buffered (matching
-                // `std.process.Child.run`'s default) and silently dropped along with any
-                // spawn error — same as the Zig.
+                // `spawn_sync` takes the C-style `[*:null]?[*:0]const u8` envp
+                // directly, so build it from the DotEnv map. Output is buffered and
+                // silently dropped along with any spawn error.
                 if let Ok(envp) = env_loader.map.create_null_delimited_env_map() {
                     let _ = spawn_sync::spawn(&spawn_sync::Options {
                         argv: build_argv(&completions_argv),
@@ -1405,10 +1376,9 @@ impl UpgradeCommand {
 pub mod upgrade_js_bindings {
     use super::*;
 
-    // Zig spec: module-level `var tempdir_fd: ?bun.FD = null;` — process-global,
-    // not threadlocal. If open/close are invoked from different threads (main vs
-    // worker VM) a `thread_local!` would make the close see `None` and leak the
-    // HANDLE. Match the Zig global with a `RacyCell`; access is test-only and
+    // Process-global, not threadlocal: if open/close are invoked from different
+    // threads (main vs worker VM) a `thread_local!` would make the close see
+    // `None` and leak the HANDLE. Use a `RacyCell`; access is test-only and
     // effectively single-threaded.
     #[cfg(windows)]
     static TEMPDIR_FD: bun_core::RacyCell<Option<sys::Fd>> = bun_core::RacyCell::new(None);
@@ -1421,7 +1391,7 @@ pub mod upgrade_js_bindings {
             jsc::JSFunction::create(
                 global,
                 b"openTempDirWithoutSharingDelete",
-                // PORT NOTE: `#[bun_jsc::host_fn]` emits the C-ABI shim with a
+                // `#[bun_jsc::host_fn]` emits the C-ABI shim with a
                 // `__jsc_host_` prefix.
                 __jsc_host_js_open_temp_dir_without_sharing_delete,
                 1,
@@ -1512,7 +1482,7 @@ pub mod upgrade_js_bindings {
 
             match sys::windows::Win32Error::from_nt_status(rc) {
                 sys::windows::Win32Error::SUCCESS => {
-                    // Zig: `bun.FD.fromNative(fd)` — system-kind handle on Windows.
+                    // System-kind handle on Windows.
                     // SAFETY: test-only helper; access is single-threaded (JS thread).
                     unsafe {
                         TEMPDIR_FD.write(Some(sys::Fd::from_system(fd)));
@@ -1548,5 +1518,3 @@ pub mod upgrade_js_bindings {
         }
     }
 }
-
-// ported from: src/cli/upgrade_command.zig
diff --git a/src/runtime/cli/which_npm_client.rs b/src/runtime/cli/which_npm_client.rs
index 6e881f4748c..fb36aceac03 100644
--- a/src/runtime/cli/which_npm_client.rs
+++ b/src/runtime/cli/which_npm_client.rs
@@ -22,5 +22,3 @@ impl From<Tag> for &'static str {
         t.as_str()
     }
 }
-
-// ported from: src/cli/which_npm_client.zig
diff --git a/src/runtime/cli/why_command.rs b/src/runtime/cli/why_command.rs
index b5d3512c798..8436f052d7a 100644
--- a/src/runtime/cli/why_command.rs
+++ b/src/runtime/cli/why_command.rs
@@ -24,7 +24,6 @@ const PREFIX_MIDDLE: &[u8] = b"  \xE2\x94\x9C\xE2\x94\x80 "; // "  ├─ "
 const PREFIX_CONTINUE: &[u8] = b"  \xE2\x94\x82  "; // "  │  "
 const PREFIX_SPACE: &[u8] = b"     ";
 
-// PORT NOTE: Zig `var max_depth: usize = 100;` is a mutable container-level global.
 // Using AtomicUsize for safe interior mutability on a single-threaded CLI path.
 static MAX_DEPTH: AtomicUsize = AtomicUsize::new(100);
 
@@ -90,8 +89,7 @@ fn get_dependency_type_priority(dep_type: DependencyType) -> u8 {
     }
 }
 
-// PORT NOTE: Zig signature was `fn(void, a, b) bool` (lessThan for std.sort).
-// Kept bool-returning lessThan semantics; call sites wrap into a total Ordering
+// Bool-returning lessThan semantics; call sites wrap into a total Ordering
 // (Less if a<b, Greater if b<a, else Equal — required since Rust 1.81 sort_by
 // panics on non-total comparators).
 fn compare_dependents(a: &DependentInfo, b: &DependentInfo) -> bool {
@@ -132,7 +130,7 @@ enum PatternType {
     Invalid,
 }
 
-// PORT NOTE: fields borrow slices of the input `pattern`; lifetime added even though
+// Fields borrow slices of the input `pattern`; lifetime added even though
 // PORTING.md prefers Box/&'static for []const u8 fields — these are pure views over
 // a caller-owned slice (BORROW_PARAM), never freed, never literal-only.
 struct GlobPattern<'a> {
@@ -275,7 +273,6 @@ impl WhyCommand {
             Global::package_json_version_with_sha
         );
 
-        // PORT NOTE: Zig multiline literal preserved verbatim.
         bun_core::pretty!(
             "Explain why a package is installed\n\
 \n\
@@ -297,7 +294,7 @@ impl WhyCommand {
 
     pub(crate) fn exec(ctx: command::Context) -> Result<(), bun_core::Error> {
         let cli = CommandLineArguments::parse(Subcommand::Why)?;
-        // PORT NOTE: capture the few `cli` fields we read after `init` consumes it.
+        // Capture the few `cli` fields we read after `init` consumes it.
         let positionals = cli.positionals;
         let top_only = cli.top_only;
 
@@ -338,9 +335,7 @@ impl WhyCommand {
         package_pattern: &[u8],
         top_only: bool,
     ) -> Result<(), bun_core::Error> {
-        // PORT NOTE: reshaped for borrowck — Zig calls
-        // `pm.lockfile.loadFromCwd(pm, ctx.allocator, ctx.log, true)` which aliases
-        // `*PackageManager` with `*Lockfile`. Detach the `Box<Lockfile>` from `pm`
+        // Detach the `Box<Lockfile>` from `pm`
         // so `load_from_cwd` can take `Option<&mut PackageManager>` without
         // overlapping the `&mut self` lockfile borrow. `pm.options.depth` is read
         // up front so we never need `pm` again once `lockfile` is borrowed.
@@ -375,18 +370,13 @@ impl WhyCommand {
         let pkg_res_slices = packages.items_resolutions();
         let _pkg_resolution = packages.items_resolution();
 
-        // PERF(port): was arena bulk-free — Zig used ArenaAllocator for all_dependents
-        // and per-dep string dupes. Now using global allocator + Drop.
-
         let mut target_versions: Vec<VersionInfo> = Vec::new();
-        // (defer free loop deleted — Box<[u8]> field + Vec Drop handle it)
 
         let mut all_dependents: HashMap<PackageID, Vec<DependentInfo>> = HashMap::default();
 
         let glob = GlobPattern::init(package_pattern);
 
-        // PORT NOTE: Zig `MultiArrayList<Package>.get(pkg_idx)` returns a row
-        // copy. The Rust column-backed `PackageList` exposes
+        // The column-backed `PackageList` exposes
         // `items_name()` / `items_dependencies()` / … directly, so we read
         // columns by index instead of materialising a `Package` row.
         let pkg_names = packages.items_name();
@@ -497,9 +487,8 @@ impl WhyCommand {
                     bun_core::prettyln!("<d>  └─ (deeper dependencies hidden)<r>");
                 } else {
                     let _ctx_data = TreeContext::init(&all_dependents);
-                    // PORT NOTE: reshaped for borrowck — Zig sorted via mutable
-                    // `dependents.items` while also holding `&all_dependents` in
-                    // ctx_data. Clone the slice to sort independently.
+                    // Clone the slice so it can be sorted while `ctx_data`
+                    // still borrows `all_dependents`.
                     let mut sorted: Vec<DependentInfo> = dependents.clone();
                     sorted.sort_by(cmp_dependents);
 
@@ -606,9 +595,8 @@ fn print_dependency_tree(
     }
 
     ctx.path_tracker.insert(current_pkg_id, depth);
-    // PORT NOTE: reshaped for borrowck — Zig used `defer path_tracker.remove(...)`.
     // All post-insert exit paths below remove explicitly. Error paths are gone
-    // (alloc failures abort under global mimalloc), so no errdefer needed.
+    // (alloc failures abort under global mimalloc).
 
     if let Some(dependents) = ctx.all_dependents.get(&current_pkg_id) {
         let mut sorted_dependents: Vec<DependentInfo> = dependents.clone();
@@ -665,5 +653,3 @@ fn print_dependency_tree(
 
     ctx.path_tracker.remove(&current_pkg_id);
 }
-
-// ported from: src/cli/why_command.zig
diff --git a/src/runtime/crypto/CryptoHasher.rs b/src/runtime/crypto/CryptoHasher.rs
index e5d729b3c1b..72b6c3a6b00 100644
--- a/src/runtime/crypto/CryptoHasher.rs
+++ b/src/runtime/crypto/CryptoHasher.rs
@@ -13,16 +13,14 @@ use crate::crypto::evp::{AlgorithmExt as _, EVP};
 use crate::crypto::{HMAC, create_crypto_error, evp};
 use crate::generated_classes::PropertyName;
 use crate::node::{BlobOrStringOrBuffer, Encoding, StringOrBuffer};
-// `Hashers` = src/sha_hmac/sha.zig (re-exported via bun_sha_hmac::sha::evp::*).
 use bun_sha_hmac::sha as hashers;
 
-// `std.crypto.hash.{sha3,blake2}` — pure-Zig stdlib algos with no BoringSSL
-// streaming context. Per docs/PORTING.md ("prefer a well-tested crates.io dep
-// over hand-porting bit-twiddling"), wire RustCrypto's `sha3`/`blake2` into the
+// sha3/blake2 algorithms with no BoringSSL streaming context:
+// RustCrypto's `sha3`/`blake2` crates are wired into the
 // `ZigHashAlgo` trait below.
 use zig_crypto_algos::{Blake2s256, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 
-// Zig: `const Digest = EVP.Digest;` → `[u8; EVP_MAX_MD_SIZE]`
+// `[u8; EVP_MAX_MD_SIZE]`
 type Digest = evp::Digest;
 
 const EVP_MAX_MD_SIZE_USIZE: usize = boring_ssl::EVP_MAX_MD_SIZE as usize;
@@ -81,7 +79,6 @@ impl CryptoHasher {
     }
 
     // ── Extern: For using only CryptoHasherZig in c++ ──────────────────────
-    // TODO(port): move to <runtime>_sys (these are exported C ABI fns)
 
     #[unsafe(no_mangle)]
     pub extern "C" fn Bun__CryptoHasherExtern__getByName(
@@ -242,10 +239,8 @@ impl CryptoHasher {
         Self::digest_(this, global, output)
     }
 
-    /// `pub const hash = jsc.host_fn.wrapStaticMethod(CryptoHasher, "hash_", false);`
-    ///
-    /// Hand-expanded `wrapStaticMethod` decode for the parameter list
-    /// `(*JSGlobalObject, ZigString, Node.BlobOrStringOrBuffer, ?Node.StringOrBuffer)`.
+    /// Hand-expanded static-method argument decode for the parameter list
+    /// `(algorithm string, input, optional output buffer/encoding)`.
     pub fn hash(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let arguments = callframe.arguments_old::<3>();
         let mut i = 0usize;
@@ -259,7 +254,6 @@ impl CryptoHasher {
             }
         };
 
-        // ZigString
         let algorithm = {
             let Some(string_value) = next_eat() else {
                 return Err(global.throw_invalid_arguments(format_args!("Missing argument")));
@@ -325,7 +319,6 @@ impl CryptoHasher {
 
     #[bun_jsc::host_fn(getter)]
     pub fn get_algorithm(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
-        // Zig: `@tagName(inner.algorithm)` → `AlgorithmExt::tag_cstr` (ASCII).
         let tag: &'static [u8] = match this {
             CryptoHasher::Evp(inner) => inner.get().algorithm.tag_cstr().to_bytes(),
             CryptoHasher::Zig(inner) => inner.get().algorithm.tag_cstr().to_bytes(),
@@ -337,7 +330,7 @@ impl CryptoHasher {
         bun_jsc::bun_string_jsc::create_utf8_for_js(global, tag)
     }
 
-    // PORT NOTE: `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
+    // `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
     // which cannot resolve to an associated fn inside an `impl` block. The shim
     // for this static prop getter is wired by `#[bun_jsc::JsClass]` codegen.
     pub fn get_algorithms(
@@ -402,7 +395,6 @@ impl CryptoHasher {
                     size
                 )));
             }
-            // PORT NOTE: reshaped for borrowck — Zig rebinds the slice into the output buffer.
             // SAFETY: `output_buf.ptr` is the JSC-owned writable backing store
             // (`bytes_len >= size` checked above; not detached since len > 0);
             // borrowed for this frame only. Build the `&mut` directly from the
@@ -471,7 +463,7 @@ impl CryptoHasher {
     }
 
     // Bun.CryptoHasher(algorithm, hmacKey?: string | Buffer)
-    // PORT NOTE: `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
+    // `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
     // which cannot resolve to an associated fn inside an `impl` block. The
     // constructor shim is wired by `#[bun_jsc::JsClass]` codegen.
     pub fn constructor(
@@ -651,8 +643,8 @@ impl CryptoHasher {
                     .expect("OOM"),
             ))),
             CryptoHasher::Hmac(inner) => 'brk: {
-                // R-2: `HMAC::copy` takes `&mut self` (writes nothing — Zig
-                // legacy signature). Project a short `&mut` via `with_mut`;
+                // R-2: `HMAC::copy` takes `&mut self` but writes nothing
+                // (legacy signature). Project a short `&mut` via `with_mut`;
                 // no JS re-entry inside (HMAC_CTX_copy is a pure FFI call).
                 let copy_result = inner.with_mut(|opt| opt.as_mut().map(|h| h.copy()));
                 let Some(result) = copy_result else {
@@ -718,7 +710,7 @@ impl CryptoHasher {
                     boring_ssl::EVP_MAX_MD_SIZE
                 )));
             }
-            // PORT NOTE: reshaped for borrowck.
+            // Reshaped for borrowck.
             // SAFETY: `bytes_len >= EVP_MAX_MD_SIZE` checked above; `output_buf.ptr`
             // is the JSC-owned writable backing store, outliving this frame. Build
             // the `&mut` directly from the raw `*mut u8` field — never via
@@ -726,7 +718,6 @@ impl CryptoHasher {
             output_digest_slice =
                 unsafe { core::slice::from_raw_parts_mut(output_buf.ptr, bytes_len) };
         } else {
-            // Zig: `output_digest_buf = std.mem.zeroes(EVP.Digest);` — already zeroed above.
             output_digest_slice = &mut output_digest_buf;
         }
 
@@ -770,7 +761,7 @@ impl CryptoHasher {
                     return Err(Self::throw_hmac_consumed(global));
                 };
                 // `this.hmac = null; defer hmac.deinit();` — `replace(None)` + Drop on `hmac`.
-                // PORT NOTE: `HMAC::r#final<'a>(&mut self, out: &'a mut [u8]) -> &'a mut [u8]`
+                // `HMAC::r#final<'a>(&mut self, out: &'a mut [u8]) -> &'a mut [u8]`
                 // returns a subslice of `out`, not `self`, so dropping `hmac` at scope end
                 // does not invalidate the returned borrow.
                 break 'brk Ok(hmac.r#final(output_digest_slice));
@@ -787,8 +778,7 @@ impl CryptoHasher {
     }
 
     // `.classes.ts` finalize — runs on mutator thread during lazy sweep. Each
-    // variant's cleanup (`inner.deinit()` in the Zig original, see
-    // https://github.com/oven-sh/bun/issues/3250) is handled by `Drop` on the
+    // variant's cleanup is handled by `Drop` on the
     // variant payloads, so the `JsFinalize` trait default (`drop(self)`) is
     // exactly what's needed; no inherent override.
 }
@@ -803,13 +793,12 @@ pub struct CryptoHasherZig {
     pub digest_length: u8,
 }
 
-/// Trait for the Zig-std hash algorithms used by `CryptoHasherZig`.
-/// Replaces the comptime `(string, type)` table + `@typeInfo` introspection.
+/// Trait for the non-BoringSSL hash algorithms used by `CryptoHasherZig`.
 /// Implemented for each algo in `zig_crypto_algos` below.
 pub trait ZigHashAlgo: Default + Clone + 'static {
     const NAME: &'static [u8];
     const ALGORITHM: evp::Algorithm;
-    /// Replaces `digestLength(Algorithm)` (Shake128→16, Shake256→32, else `T.digest_length`).
+    /// Shake128→16, Shake256→32, else the algorithm's digest length.
     const DIGEST_LENGTH: u8;
     fn init() -> Self {
         Self::default()
@@ -818,10 +807,9 @@ pub trait ZigHashAlgo: Default + Clone + 'static {
     fn final_(&mut self, out: &mut [u8]);
 }
 
-/// Hash-state types for the Zig-stdlib algorithms (`std.crypto.hash.{sha3,blake2}`)
-/// that BoringSSL does not expose as a streaming context. Backed by RustCrypto's
-/// `sha3`/`blake2` crates (same Keccak-p[1600,24] permutation and BLAKE2s as
-/// Zig's `std.crypto`).
+/// Hash-state types for the algorithms that BoringSSL does not expose as a
+/// streaming context. Backed by RustCrypto's `sha3`/`blake2` crates
+/// (Keccak-p[1600,24] permutation and BLAKE2s).
 mod zig_crypto_algos {
     use super::{ZigHashAlgo, evp};
     use sha3::digest::{ExtendableOutputReset, FixedOutputReset, Output, Update};
@@ -834,8 +822,8 @@ mod zig_crypto_algos {
     pub(super) type Shake256 = sha3::Shake256;
     pub(super) type Blake2s256 = blake2::Blake2s256;
 
-    /// Fixed-digest Keccak/BLAKE2 — Zig `T.final(state, *[digest_length]u8)`
-    /// writes exactly `digest_length` bytes; mirror via `FixedOutputReset`.
+    /// Fixed-digest Keccak/BLAKE2 — `final_` writes exactly `DIGEST_LENGTH`
+    /// bytes via `FixedOutputReset`.
     macro_rules! impl_fixed {
         ($ty:ty, $name:literal, $variant:ident, $len:expr) => {
             impl ZigHashAlgo for $ty {
@@ -856,8 +844,8 @@ mod zig_crypto_algos {
         };
     }
 
-    /// SHAKE XOF — Zig `digestLength(Shake128) = 16` / `Shake256 = 32` (the
-    /// Zig stdlib's `Shake.final` squeezes exactly `out.len` bytes).
+    /// SHAKE XOF — default digest lengths: Shake128 = 16, Shake256 = 32;
+    /// `final_` squeezes exactly `out.len` bytes.
     macro_rules! impl_xof {
         ($ty:ty, $name:literal, $variant:ident, $len:expr) => {
             impl ZigHashAlgo for $ty {
@@ -868,8 +856,8 @@ mod zig_crypto_algos {
                     Update::update(self, bytes);
                 }
                 fn final_(&mut self, out: &mut [u8]) {
-                    // Zig `Shake.final(out: []u8)` squeezes exactly `out.len`
-                    // bytes — fill the full slice, not just `DIGEST_LENGTH`.
+                    // Squeeze exactly `out.len` bytes — fill the
+                    // full slice, not just `DIGEST_LENGTH`.
                     ExtendableOutputReset::finalize_xof_reset_into(self, out);
                 }
             }
@@ -885,8 +873,7 @@ mod zig_crypto_algos {
     impl_fixed!(Blake2s256, b"blake2s256", Blake2s256, 32);
 }
 
-/// Expands `$body` once per `(name_literal, Type)` pair from the Zig `algo_map`.
-/// Heterogeneous-type `inline for` → `macro_rules!` per PORTING.md.
+/// Expands the macro once per supported `(name_literal, Type)` pair.
 macro_rules! for_each_zig_algo {
     ($mac:ident $(, $($args:tt)*)?) => {
         $mac!(b"sha3-224",   Sha3_224   $(, $($args)*)?);
@@ -964,7 +951,7 @@ impl CryptoHasherZig {
         let mut h = A::init();
         h.update(input.slice());
 
-        // PORT NOTE: const-generic array length from trait assoc const requires
+        // Const-generic array length from trait assoc const requires
         // `feature(generic_const_exprs)` — use a stack buffer of EVP_MAX_MD_SIZE
         // sliced to A::DIGEST_LENGTH instead.
         let mut out = [0u8; EVP_MAX_MD_SIZE_USIZE];
@@ -1113,9 +1100,8 @@ impl CryptoHasherZig {
 // StaticCryptoHasher
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Trait for `Hashers.*` (src/sha_hmac/sha.zig) — replaces the comptime `Hasher`
-/// type param. `HAS_ENGINE` replaces the Zig `@typeInfo(@TypeOf(Hasher.hash)).fn.params.len == 3`
-/// reflection: when true, `hash()` takes a BoringSSL ENGINE*.
+/// Trait abstracting over the `bun_sha_hmac::sha::evp::*` hasher types.
+/// When `HAS_ENGINE` is true, `hash()` takes a BoringSSL ENGINE*.
 pub trait StaticHasher: 'static {
     const NAME: &'static str;
     const DIGEST: usize;
@@ -1129,16 +1115,15 @@ pub trait StaticHasher: 'static {
     /// # Safety
     /// `engine` must be null (default engine) or a live `ENGINE*`.
     unsafe fn hash(input: &[u8], out: &mut Self::Digest, engine: *mut boring_ssl::ENGINE);
-    /// `@field(jsc.Codegen, "JS" ++ name).getConstructor` — per-monomorphization
-    /// codegen module (`bun_jsc::generated::JS${NAME}`). Replaces the Zig
-    /// `comptime "JS" ++ name` token paste; each `impl_static_hasher!` arm binds
-    /// to the typed wrapper exported by `js_class_module!` for its concrete name.
+    /// Per-monomorphization codegen module (`bun_jsc::generated::JS${NAME}`);
+    /// each `impl_static_hasher!` arm binds to the typed wrapper exported by
+    /// `js_class_module!` for its concrete name.
     fn get_constructor(global: &JSGlobalObject) -> JSValue;
 }
 
 /// Local impls of `StaticHasher` for the upstream `bun_sha_hmac::sha::evp::*`
 /// hasher types. Those types live in another crate so we cannot add inherent
-/// methods; the trait bridges the comptime-style API.
+/// methods; the trait provides the common interface.
 macro_rules! impl_static_hasher {
     ($ty:ty, $name:literal, $js_mod:ident, $len:expr) => {
         impl StaticHasher for $ty {
@@ -1187,10 +1172,9 @@ impl_static_hasher!(hashers::SHA384, "SHA384", JSSHA384, 48);
 impl_static_hasher!(hashers::SHA512, "SHA512", JSSHA512, 64);
 impl_static_hasher!(hashers::SHA512_256, "SHA512_256", JSSHA512_256, 32);
 
-// PORT NOTE: `#[bun_jsc::JsClass]` cannot expand over a generic struct (it emits
-// `*mut StaticCryptoHasher` without `<H>`). In Zig each `StaticCryptoHasher(Hasher, name)`
-// instantiation gets its own `.classes.ts` codegen; the Rust equivalent must apply
-// `JsClass` to each concrete monomorphization (MD4/MD5/SHA1/…) once the macro grows
+// `#[bun_jsc::JsClass]` cannot expand over a generic struct (it emits
+// `*mut StaticCryptoHasher` without `<H>`), so `JsClass` must be applied to
+// each concrete monomorphization (MD4/MD5/SHA1/…) once the macro grows
 // generic/alias support.
 // The per-monomorphization `JsClass` impl + extern shims live in
 // `build/*/codegen/generated_classes.rs` (one block per `pub type` alias below);
@@ -1336,12 +1320,10 @@ impl<H: StaticHasher> StaticCryptoHasher<H> {
         output: Option<ArrayBuffer>,
     ) -> JsResult<JSValue> {
         let mut output_digest_buf: H::Digest = H::new_digest();
-        // PORT NOTE: reshaped for borrowck — Zig used `*Hasher.Digest` rebound into output buffer.
         let output_digest_slice: &mut H::Digest;
         if let Some(output_buf) = &output {
             let bytes_len = output_buf.byte_slice().len();
             if bytes_len < H::DIGEST {
-                // Zig `comptimePrint` → runtime `format_args!`; observable string is identical.
                 return Err(global.throw_invalid_arguments(format_args!(
                     "TypedArray must be at least {} bytes",
                     H::DIGEST
@@ -1409,7 +1391,7 @@ impl<H: StaticHasher> StaticCryptoHasher<H> {
         }
     }
 
-    // PORT NOTE: `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
+    // `#[bun_jsc::host_fn]` (Free) emits a bare `fn_name(g, f)` call,
     // which cannot resolve to an associated fn inside an `impl` block. The
     // constructor shim is wired by per-monomorphization `#[bun_jsc::JsClass]` codegen.
     pub fn constructor(_: &JSGlobalObject, _: &CallFrame) -> JsResult<Box<Self>> {
@@ -1520,7 +1502,6 @@ impl<H: StaticHasher> StaticCryptoHasher<H> {
             // `&[u8].as_ptr()` (Stacked-Borrows UB).
             output_digest_slice = unsafe { &mut *output_buf.ptr.cast::<H::Digest>() };
         } else {
-            // Zig: `output_digest_buf = std.mem.zeroes(Hasher.Digest);` — Default already zeroes.
             output_digest_slice = &mut output_digest_buf;
         }
 
@@ -1535,7 +1516,6 @@ impl<H: StaticHasher> StaticCryptoHasher<H> {
     }
 
     fn digest_to_encoding(&self, global: &JSGlobalObject, encoding: Encoding) -> JsResult<JSValue> {
-        // Zig comptime zero-init loop → new_digest (zeroed [u8; N]).
         let mut output_digest_buf: H::Digest = H::new_digest();
 
         let output_digest_slice: &mut H::Digest = &mut output_digest_buf;
@@ -1555,5 +1535,3 @@ pub type SHA256 = StaticCryptoHasher<hashers::SHA256>;
 pub type SHA384 = StaticCryptoHasher<hashers::SHA384>;
 pub type SHA512 = StaticCryptoHasher<hashers::SHA512>;
 pub type SHA512_256 = StaticCryptoHasher<hashers::SHA512_256>;
-
-// ported from: src/runtime/crypto/CryptoHasher.zig
diff --git a/src/runtime/crypto/EVP.rs b/src/runtime/crypto/EVP.rs
index 87376790128..41d435c6939 100644
--- a/src/runtime/crypto/EVP.rs
+++ b/src/runtime/crypto/EVP.rs
@@ -25,14 +25,12 @@ pub use bun_sha_hmac::evp::Algorithm;
 /// Higher-tier helpers on the lowered `Algorithm` enum (orphan rules prevent an
 /// inherent `impl` on a foreign type, so callers `use evp::AlgorithmExt as _;`).
 pub(crate) trait AlgorithmExt: Copy + Sized {
-    /// NUL-terminated tag name, equivalent to Zig's `@tagName(algorithm)` (which
-    /// yields `[:0]const u8`). Needed for `EVP_get_digestbyname` which reads a
-    /// C string.
+    /// NUL-terminated tag name. Needed for `EVP_get_digestbyname` which reads
+    /// a C string.
     fn tag_cstr(self) -> &'static CStr;
 
-    /// `bun.String` view of every algorithm tag name. Mirrors Zig's comptime
-    /// `EnumArray(Algorithm, bun.String)` table; returned as a flat slice since
-    /// the enum is foreign and cannot derive `enum_map::Enum`.
+    /// `bun.String` view of every algorithm tag name; returned as a flat slice
+    /// since the enum is foreign and cannot derive `enum_map::Enum`.
     fn names() -> &'static [BunString];
 }
 
@@ -59,7 +57,7 @@ impl AlgorithmExt for Algorithm {
             Algorithm::Shake128 => c"shake128",
             Algorithm::Shake256 => c"shake256",
             // upstream enum is `#[non_exhaustive]`; the variant set is closed in
-            // practice (mirrors EVP.zig 1:1).
+            // practice.
             _ => unreachable!("unhandled EVP algorithm variant"),
         }
     }
@@ -98,15 +96,15 @@ const ALL: [Algorithm; 19] = [
     Algorithm::Shake256,
 ];
 
-/// Zig `JSValue.toEnumFromMap`'s comptime `one_of` literal for `EVP.Algorithm` —
-/// `enumFieldNames` joined as `"'a', 'b', … 'y' or 'z'"` (declaration order).
+/// Algorithm names joined as `"'a', 'b', … 'y' or 'z'"` (declaration order),
+/// for "must be one of" error messages.
 pub(crate) const ALGORITHM_ONE_OF: &str = "'blake2b256', 'blake2b512', 'blake2s256', 'md4', 'md5', \
 'ripemd160', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'sha512-224', 'sha512-256', \
 'sha3-224', 'sha3-256', 'sha3-384', 'sha3-512', 'shake128' or 'shake256'";
 
-/// Case-sensitive name → `Algorithm` (Rust port of the Zig `ComptimeStringMap`).
+/// Case-sensitive name → `Algorithm`.
 ///
-/// PERF(port): replaces a `phf::Map`. 32 keys spread across lengths 3..=11
+/// Hand-rolled instead of a `phf::Map`: 32 keys spread across lengths 3..=11
 /// (max bucket = 7) — a length-gated `match` rejects misses on a single `usize`
 /// compare and lets LLVM lower the per-bucket arms to fixed-width loads. The two
 /// densest buckets (len 6 / len 10) get an extra first-byte gate so common
@@ -318,7 +316,6 @@ impl EVP {
     /// # Safety
     /// `engine` must be either null or a valid `ENGINE` pointer.
     pub fn by_name_and_engine(engine: *mut boringssl::ENGINE, name: &[u8]) -> Option<EVP> {
-        // Zig used getWithEql(name, eqlCaseInsensitiveASCIIIgnoreLength).
         if let Some(algorithm) = lookup_ignore_case(name) {
             if let Some(md) = algorithm.md() {
                 // `Algorithm::md()` lives in `bun_sha_hmac`
@@ -328,7 +325,6 @@ impl EVP {
                 return Some(EVP::init(algorithm, md.cast::<boringssl::EVP_MD>(), engine));
             }
 
-            // PORT NOTE: Zig's `@tagName(algorithm)` is `[:0]const u8` (NUL-terminated).
             // strum's `<&'static str>::from(algorithm)` is NOT NUL-terminated, so use the
             // explicit `tag_cstr()` table for the C-string FFI.
             // SAFETY: FFI into BoringSSL; EVP_get_digestbyname expects a NUL-terminated
@@ -374,12 +370,7 @@ impl Drop for EVP {
 
 pub(crate) type Digest = [u8; boringssl::EVP_MAX_MD_SIZE as usize];
 
-// PORT NOTE: Zig nests `PBKDF2`/`pbkdf2` inside the `EVP` struct; the
-// `crypto::EVP` re-export (module alias) lets `crypto::EVP::pbkdf2` resolve
-// through this module. The `pbkdf2` submodule is gated (blocked on bun_jsc
-// arg-parsing surface), so re-export the standalone helper from the parent
-// stub for now.
-// TODO(port): bun_jsc — un-gate `super::pbkdf2` and swap to `pub use super::pbkdf2 as PBKDF2;`.
+// The `crypto::EVP` re-export (module alias) lets `crypto::EVP::pbkdf2` /
+// `crypto::EVP::PBKDF2` resolve through this module.
 pub use super::pbkdf2;
-
-// ported from: src/runtime/crypto/EVP.zig
+pub use super::pbkdf2 as PBKDF2;
diff --git a/src/runtime/crypto/HMAC.rs b/src/runtime/crypto/HMAC.rs
index 59eae441c91..63b0bf66844 100644
--- a/src/runtime/crypto/HMAC.rs
+++ b/src/runtime/crypto/HMAC.rs
@@ -51,7 +51,6 @@ impl HMAC {
     }
 
     pub fn copy(&mut self) -> Result<Box<HMAC>, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut ctx = MaybeUninit::<boringssl::HMAC_CTX>::uninit();
         // SAFETY: HMAC_CTX_init writes the entire struct; ctx is valid uninit memory.
         unsafe { boringssl::HMAC_CTX_init(ctx.as_mut_ptr()) };
@@ -72,7 +71,7 @@ impl HMAC {
     pub fn r#final<'a>(&mut self, out: &'a mut [u8]) -> &'a mut [u8] {
         let mut outlen: c_uint = 0;
         // SAFETY: self.ctx is initialized; out is a valid writable buffer of at least
-        // HMAC_size(&self.ctx) bytes (caller invariant, same as Zig).
+        // HMAC_size(&self.ctx) bytes (caller invariant).
         let _ =
             unsafe { boringssl::HMAC_Final(&raw mut self.ctx, out.as_mut_ptr(), &raw mut outlen) };
         &mut out[..outlen as usize]
@@ -86,5 +85,3 @@ impl Drop for HMAC {
         // bun.destroy(this) is handled by Box<HMAC>'s own Drop.
     }
 }
-
-// ported from: src/runtime/crypto/HMAC.zig
diff --git a/src/runtime/crypto/PBKDF2.rs b/src/runtime/crypto/PBKDF2.rs
index dc5479583ef..da70f16a27a 100644
--- a/src/runtime/crypto/PBKDF2.rs
+++ b/src/runtime/crypto/PBKDF2.rs
@@ -11,8 +11,7 @@ use crate::node::StringOrBuffer;
 use crate::crypto::create_crypto_error;
 use crate::crypto::evp::{self, Algorithm};
 
-// BoringSSL error code; not yet exported by `bun_boringssl_sys`
-// (Zig: src/boringssl_sys/boringssl.zig:6422).
+// BoringSSL error code; not yet exported by `bun_boringssl_sys`.
 const EVP_R_MEMORY_LIMIT_EXCEEDED: u32 = 132;
 
 pub(crate) struct PBKDF2 {
@@ -30,8 +29,8 @@ impl Default for PBKDF2 {
             salt: StringOrBuffer::default(),
             iteration_count: 1,
             length: 0,
-            // PORT NOTE: Zig had no default for `algorithm` (callers always set it).
-            // Sha256 is an arbitrary placeholder so `Default` compiles.
+            // Callers always set `algorithm`; Sha256 is an arbitrary placeholder
+            // so `Default` compiles.
             algorithm: Algorithm::Sha256,
         }
     }
@@ -74,8 +73,8 @@ impl PBKDF2 {
         true
     }
 
-    // Zig `deinit()` only freed `password`/`salt`; both are `StringOrBuffer`
-    // whose `Drop` releases the slice/WTF ref, so the explicit hook is gone —
+    // `password`/`salt` are `StringOrBuffer` whose `Drop` releases the
+    // slice/WTF ref, so no explicit cleanup hook is needed —
     // dropping `PBKDF2` is sufficient for the sync path. The async path holds
     // `ThreadSafe<PBKDF2>`, whose `Drop` additionally unprotects JS-rooted
     // buffers via the `Unprotect` impl below.
@@ -178,7 +177,7 @@ impl PBKDF2 {
                         format_args!("Invalid digest: {}", bstr::BStr::new(name)),
                     )
                     .throw());
-                // `slice` drops here (was `defer slice.deinit()`).
+                // `slice` drops here.
             }
             return Err(bun_jsc::JsError::Thrown);
         };
@@ -190,7 +189,6 @@ impl PBKDF2 {
             length: keylen,
             algorithm,
         };
-        // Zig: `defer { if (globalThis.hasException()) { if (is_async) out.deinitAndUnprotect() else out.deinit(); } }`
         // Non-async path: `StringOrBuffer` fields drop with `out` on early return — no explicit call needed.
         let mut guard = scopeguard::guard(&mut out, |out| {
             if global_this.has_exception() && is_async {
@@ -255,8 +253,8 @@ impl PBKDF2 {
 }
 
 impl bun_jsc::Unprotect for PBKDF2 {
-    /// Zig `PBKDF2.deinitAndUnprotect`, JS-side half — owned slices are
-    /// released by `Drop for StringOrBuffer`.
+    /// JS-side half of cleanup — owned slices are released by
+    /// `Drop for StringOrBuffer`.
     #[inline]
     fn unprotect(&mut self) {
         self.password.unprotect();
@@ -277,8 +275,7 @@ pub(crate) struct Pbkdf2Ctx {
 impl AnyTaskJobCtx for Pbkdf2Ctx {
     fn run(&mut self, _global: *mut JSGlobalObject) {
         let len = usize::try_from(self.pbkdf2.length).expect("int cast");
-        // Zig: `bun.default_allocator.alloc(u8, len) catch { ... }`
-        // Rust `Vec` allocation aborts on OOM; mirror the error path with try_reserve.
+        // `Vec` allocation aborts on OOM; use try_reserve to surface an error instead.
         let mut buf = Vec::new();
         if buf.try_reserve_exact(len).is_err() {
             self.err = Some(EVP_R_MEMORY_LIMIT_EXCEEDED);
@@ -307,7 +304,6 @@ impl AnyTaskJobCtx for Pbkdf2Ctx {
         debug_assert!(output_slice.len() == usize::try_from(self.pbkdf2.length).expect("int cast"));
         // Ownership transfers to JSC (freed via MarkedArrayBuffer_deallocator → mimalloc free).
         let buffer_value = JSValue::create_buffer(global_this, output_slice.leak());
-        // Zig: `this.output = &[_]u8{};` — already done via `mem::take` above.
         promise.resolve(global_this, buffer_value)?;
         Ok(())
     }
@@ -315,7 +311,7 @@ impl AnyTaskJobCtx for Pbkdf2Ctx {
 
 pub(crate) type Job = AnyTaskJob<Pbkdf2Ctx>;
 
-/// Zig `Job.create` — heap-allocate, init the promise, ref the loop, and hand
+/// Heap-allocate, init the promise, ref the loop, and hand
 /// to the work pool. Returns the live job so the caller can read
 /// `(*job).ctx.promise.value()` before the JS-thread completion fires.
 /// Free fn (not `impl Job`) because `AnyTaskJob<_>` is a foreign type.
@@ -344,7 +340,6 @@ pub fn pbkdf2<'a>(
     iteration_count: u32,
     algorithm: Algorithm,
 ) -> Option<&'a [u8]> {
-    // Return type borrows `output`; Zig returned `?[]const u8` aliasing the input.
     let mut pbk = PBKDF2 {
         algorithm,
         password: StringOrBuffer::EncodedSlice(ZigStringSlice::from_utf8_never_free(password)),
@@ -359,5 +354,3 @@ pub fn pbkdf2<'a>(
 
     Some(output)
 }
-
-// ported from: src/runtime/crypto/PBKDF2.zig
diff --git a/src/runtime/crypto/PasswordObject.rs b/src/runtime/crypto/PasswordObject.rs
index c5985ac1c1f..1f83c52820a 100644
--- a/src/runtime/crypto/PasswordObject.rs
+++ b/src/runtime/crypto/PasswordObject.rs
@@ -21,9 +21,8 @@ use bun_threading::work_pool::WorkPool;
 
 use crate::node::StringOrBuffer;
 
-// std.crypto.pwhash — Zig stdlib argon2/bcrypt. API-surface shim lives at
-// `crypto::pwhash` (this dir); vendor impl (Rust `argon2`/`bcrypt` crates or
-// Zig-stdlib staticlib) is wired there, not here.
+// The argon2/bcrypt API-surface shim lives at `crypto::pwhash` (this dir);
+// the implementation is wired there, not here.
 use super::pwhash;
 use bun_sha_hmac::SHA512;
 
@@ -33,9 +32,7 @@ use bun_sha_hmac::SHA512;
 
 pub struct PasswordObject;
 
-impl PasswordObject {
-    // pub const pwhash = std.crypto.pwhash;  — re-export dropped; see `use` above.
-}
+impl PasswordObject {}
 
 #[derive(Copy, Clone, PartialEq, Eq, strum::IntoStaticStr)]
 #[repr(u8)]
@@ -50,18 +47,17 @@ pub enum Algorithm {
     Bcrypt,
 }
 
-/// Zig: `Algorithm.Value = union(Algorithm)`
 #[derive(Copy, Clone)]
 pub enum AlgorithmValue {
     Argon2i(Argon2Params),
     Argon2d(Argon2Params),
     Argon2id(Argon2Params),
     /// bcrypt only accepts "cost"
-    Bcrypt(u8), // Zig: u6
+    Bcrypt(u8),
 }
 
 impl AlgorithmValue {
-    pub const BCRYPT_DEFAULT: u8 = 10; // Zig name has typo `bcrpyt_default`; preserved as const
+    pub const BCRYPT_DEFAULT: u8 = 10;
 
     pub const DEFAULT: AlgorithmValue = AlgorithmValue::Argon2id(Argon2Params::DEFAULT);
 
@@ -78,7 +74,6 @@ impl AlgorithmValue {
 
                 let algorithm_string = algorithm_value.get_zig_string(global_object)?;
 
-                // Zig: ComptimeStringMap.getWithEql(ZigString, ZigString.eqlComptime) —
                 // ZigString may be UTF-16; compare each label via `eql_comptime`.
                 let Some(algo) = algorithm_from_zig_string(&algorithm_string) else {
                     return Err(global_object.throw_invalid_argument_type(
@@ -109,7 +104,6 @@ impl AlgorithmValue {
                             algorithm = AlgorithmValue::Bcrypt(
                                 u8::try_from(rounds).expect("int cast") & 0x3F,
                             );
-                            // Zig: @as(u6, @intCast(rounds))
                         }
 
                         return Ok(algorithm);
@@ -157,7 +151,6 @@ impl AlgorithmValue {
                             argon.memory_cost = u32::try_from(memory_cost).expect("int cast");
                         }
 
-                        // Zig: @unionInit(Algorithm.Value, @tagName(tag), argon)
                         return Ok(match algo {
                             Algorithm::Argon2id => AlgorithmValue::Argon2id(argon),
                             Algorithm::Argon2d => AlgorithmValue::Argon2d(argon),
@@ -204,7 +197,6 @@ impl AlgorithmValue {
     }
 }
 
-/// Zig: `Algorithm.label.getWithEql(input, ZigString.eqlComptime)`.
 /// `bun_core::ZigString` may be UTF-16 so a direct `phf` byte lookup is
 /// unsound; compare each (4-entry) label via the encoding-aware `eql_comptime`.
 fn algorithm_from_zig_string(s: &ZigString) -> Option<Algorithm> {
@@ -290,8 +282,7 @@ impl Algorithm {
     }
 }
 
-/// Zig: `pub const HashError = pwhash.Error || error{UnsupportedAlgorithm};`
-/// Collapsed into bun_core::Error (NonZeroU16 tag). The pwhash shim
+/// `bun_core::Error` (NonZeroU16 tag). The pwhash shim
 /// must `impl From<pwhash::Error> for bun_core::Error`.
 pub(crate) type HashError = bun_core::Error;
 
@@ -325,9 +316,8 @@ impl PasswordObject {
                 let mut outbuf = [0u8; 4096];
                 // bcrypt silently truncates passwords longer than 72 bytes
                 // we use SHA512 to hash the password if it's longer than 72 bytes
-                // PORT NOTE: reshaped for borrowck — Zig aliased `outbuf` for both the
-                // SHA digest and the remaining output slice; here the digest gets its own
-                // 64-byte buffer (SHA512::final wants `&mut [u8; DIGEST]`).
+                // The digest gets its own 64-byte buffer
+                // (SHA512::final wants `&mut [u8; DIGEST]`).
                 let mut digest = [0u8; SHA512::DIGEST];
                 let mut password_to_use = password;
                 let outbuf_slice: &mut [u8];
@@ -335,7 +325,6 @@ impl PasswordObject {
                     let mut sha_512 = SHA512::init();
                     sha_512.update(password);
                     sha_512.r#final(&mut digest);
-                    // sha_512 dropped here (Zig: defer sha_512.deinit())
                     password_to_use = &digest;
                     outbuf_slice = &mut outbuf[SHA512::DIGEST..];
                 } else {
@@ -503,8 +492,7 @@ pub(crate) extern "C" fn JSPasswordObject__create(global_object: &JSGlobalObject
 
 // ─── PasswordOp: generic hash/verify off-thread job ───────────────────────
 //
-// HashJob/HashResult and VerifyJob/VerifyResult in the Zig source are
-// byte-for-byte twins differing only in (a) extra input fields, (b) success
+// Hash and verify jobs differ only in (a) extra input fields, (b) success
 // payload type + JS conversion, (c) the verb in the error message. Collapse
 // both into one `PasswordJob<Op>` / `PasswordResult<Op>` parameterised on a
 // `PasswordOp` carrying exactly those three axes.
@@ -532,7 +520,7 @@ impl PasswordOp for HashOp {
     }
     fn to_js(value: Box<[u8]>, g: &JSGlobalObject) -> JSValue {
         JscZigString::init(&value).to_js(g)
-        // `value` drops here — Zig: defer bun.default_allocator.free(value)
+        // `value` drops here.
     }
 }
 
@@ -559,7 +547,7 @@ impl PasswordOp for VerifyOp {
 }
 
 /// Build the JS `Error` instance for a failed hash/verify, with `code` set
-/// to `PASSWORD_<SCREAMING_SNAKE_ERROR_NAME>` (Zig: `toErrorInstance`).
+/// to `PASSWORD_<SCREAMING_SNAKE_ERROR_NAME>`.
 fn password_error_instance(err: HashError, verb: &str, g: &JSGlobalObject) -> JSValue {
     let mut error_code: Vec<u8> = Vec::new();
     write!(
@@ -816,9 +804,8 @@ pub(crate) fn js_password_object_hash_sync(
         );
     }
 
-    // PORT NOTE: sync path borrows the slice; pass as Box for unified signature.
-    // TODO(port): hash<true> only needs &[u8]; consider splitting sync/async to
-    // avoid the copy. Zig passed the borrowed slice directly.
+    // The sync path only needs `&[u8]`; copy into a Box to share the async
+    // signature.
     JSPasswordObject::hash::<true>(
         global_object,
         Box::<[u8]>::from(string_or_buffer.slice()),
@@ -973,8 +960,8 @@ pub(crate) fn js_password_object_verify_sync(
         return Ok(JSValue::FALSE);
     }
 
-    // TODO(port): sync path only needs &[u8]; copying into Box here to share
-    // signature with async. Zig passed borrowed slices.
+    // The sync path only needs `&[u8]`; copy into Boxes to share the async
+    // signature.
     JSPasswordObject::verify::<true>(
         global_object,
         Box::<[u8]>::from(password.slice()),
@@ -984,5 +971,3 @@ pub(crate) fn js_password_object_verify_sync(
 }
 
 const UNKNOWN_PASSWORD_ALGORITHM_MESSAGE: &str = "unknown algorithm, expected one of: \"bcrypt\", \"argon2id\", \"argon2d\", \"argon2i\" (default is \"argon2id\")";
-
-// ported from: src/runtime/crypto/PasswordObject.zig
diff --git a/src/runtime/crypto/boringssl_jsc.rs b/src/runtime/crypto/boringssl_jsc.rs
index 63501f6356b..4b3b969aa63 100644
--- a/src/runtime/crypto/boringssl_jsc.rs
+++ b/src/runtime/crypto/boringssl_jsc.rs
@@ -36,5 +36,3 @@ pub fn err_to_js(global: &JSGlobalObject, err_code: u32) -> JSValue {
         )
         .to_js()
 }
-
-// ported from: src/runtime/crypto/boringssl_jsc.zig
diff --git a/src/runtime/crypto/mod.rs b/src/runtime/crypto/mod.rs
index 975970af547..d1f385e47a5 100644
--- a/src/runtime/crypto/mod.rs
+++ b/src/runtime/crypto/mod.rs
@@ -25,12 +25,10 @@ pub(crate) fn create_crypto_error(global_this: &JSGlobalObject, err_code: u32) -
     boringssl_jsc::err_to_js(global_this, err_code)
 }
 
-/// For usage in Rust (`src/runtime/crypto/PBKDF2.zig` `pub fn pbkdf2`).
-///
 /// Returns `Some(output)` on success, `None` on BoringSSL error.
-// PORT NOTE: Zig nests `pbkdf2`/`Algorithm` inside the `EVP` struct. Stable
-// Rust has no inherent associated types, so callers reach them via the
-// `evp` module re-exported as `EVP` (see `pub use evp as EVP` below) —
+// Stable Rust has no inherent associated types, so `pbkdf2`/`Algorithm` cannot
+// nest inside the `EVP` struct; callers reach them via the `evp` module
+// re-exported as `EVP` (see `pub use evp as EVP` below) —
 // `EVP::pbkdf2(..)` / `EVP::Algorithm::Sha256` resolve through the module.
 pub fn pbkdf2<'a>(
     output: &'a mut [u8],
@@ -86,13 +84,8 @@ pub use crypto_hasher::SHA384;
 pub use crypto_hasher::SHA512;
 pub use crypto_hasher::SHA512_256;
 
-// Zig nests `Algorithm`/`pbkdf2`/`PBKDF2` inside the `EVP` struct; stable Rust
-// has no inherent associated types, so re-export the module under the struct
-// name. `crypto::EVP::pbkdf2` / `crypto::EVP::Algorithm` resolve via the module,
-// and the struct itself is reachable as `crypto::EVP::EVP` if ever needed.
+// Stable Rust has no inherent associated types, so re-export the module under
+// the struct name. `crypto::EVP::pbkdf2` / `crypto::EVP::Algorithm` resolve via
+// the module, and the struct itself is reachable as `crypto::EVP::EVP` if ever needed.
 pub use evp as EVP;
 pub use hmac::HMAC;
-
-// `comptime { CryptoHasher.Extern.@"export"(); }` — dropped; Rust links what's `pub`.
-
-// ported from: src/runtime/crypto/crypto.zig
diff --git a/src/runtime/crypto/pwhash.rs b/src/runtime/crypto/pwhash.rs
index 11c069b13d9..c03802cfce5 100644
--- a/src/runtime/crypto/pwhash.rs
+++ b/src/runtime/crypto/pwhash.rs
@@ -1,14 +1,10 @@
-//! `std.crypto.pwhash` shim.
+//! Password hashing for `Bun.password` (argon2 / bcrypt). Neither algorithm is
+//! provided by BoringSSL, so this module implements the API surface that
+//! `PasswordObject` consumes (`str_hash` / `str_verify` / `Params` / `Mode` /
+//! `Encoding`) and routes to the pure-Rust `rust-argon2` and `bcrypt` crates
+//! from crates.io.
 //!
-//! Zig's `Bun.password` is built on `std.crypto.pwhash.{argon2, bcrypt}`. Neither
-//! algorithm is provided by BoringSSL, so this module mirrors the Zig stdlib API
-//! surface that `PasswordObject` consumes (`strHash` / `strVerify` / `Params` /
-//! `Mode` / `Encoding`) and routes to the pure-Rust `rust-argon2` and `bcrypt`
-//! crates from crates.io.
-//!
-//! API shape is locked to `vendor/zig/lib/std/crypto/{argon2, bcrypt}.zig` so
-//! the bodies below are a drop-in for the Zig stdlib semantics:
-//!   * argon2: PHC string format only (Zig `strHash` rejects `.crypt`), 32-byte
+//!   * argon2: PHC string format only (`str_hash` rejects `.crypt`), 32-byte
 //!     random salt, 32-byte tag, version 0x13.
 //!   * bcrypt: modular-crypt `$2b$…` 60-byte string for hashing; verification
 //!     additionally accepts the PHC `$bcrypt$…` form (decoded locally — the
@@ -29,7 +25,7 @@ fn phc_ascii_str(s: &[u8]) -> Result<&str, Error> {
     Ok(unsafe { core::str::from_utf8_unchecked(s) })
 }
 
-/// `std.crypto.pwhash.Encoding`
+/// Output string encoding.
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum Encoding {
     /// PHC string format (`$argon2id$v=19$...`).
@@ -48,7 +44,6 @@ pub mod argon2 {
     // it via the absolute `::argon2` path so it doesn't collide with this module.
     use ::argon2 as vendor;
 
-    /// Zig `default_salt_len` / `default_hash_len` (vendor/zig/lib/std/crypto/argon2.zig).
     const DEFAULT_SALT_LEN: usize = 32;
     const DEFAULT_HASH_LEN: u32 = 32;
 
@@ -56,7 +51,7 @@ pub mod argon2 {
     const MAX_VERIFY_MEMORY_COST: u32 = 1 << 22;
     const MAX_VERIFY_PARALLELISM: u32 = 64;
 
-    /// `std.crypto.pwhash.argon2.Mode`
+    /// Argon2 variant.
     #[derive(Copy, Clone, Eq, PartialEq)]
     pub enum Mode {
         Argon2d,
@@ -74,19 +69,19 @@ pub mod argon2 {
         }
     }
 
-    /// `std.crypto.pwhash.argon2.Params` — only the fields Bun touches.
+    /// Argon2 parameters — only the fields Bun touches.
     #[derive(Copy, Clone)]
     pub struct Params {
         /// Time cost (iterations).
         pub t: u32,
         /// Memory cost in KiB.
         pub m: u32,
-        /// Parallelism degree (Zig: u24).
+        /// Parallelism degree.
         pub p: u32,
     }
 
     impl Params {
-        /// `Params.interactive_2id = fromLimits(2, 67108864)` → `t=2, m=67108864/1024`.
+        /// Interactive argon2id preset: `t=2`, `m=67108864/1024` KiB.
         pub const INTERACTIVE_2ID_T: u32 = 2;
         pub const INTERACTIVE_2ID_M: u32 = 67_108_864 / 1024;
 
@@ -97,7 +92,7 @@ pub mod argon2 {
         };
     }
 
-    /// `std.crypto.pwhash.argon2.HashOptions` (allocator field dropped).
+    /// Options for `str_hash`.
     #[derive(Copy, Clone)]
     pub(crate) struct HashOptions {
         pub params: Params,
@@ -105,15 +100,15 @@ pub mod argon2 {
         pub encoding: Encoding,
     }
 
-    /// `std.crypto.pwhash.argon2.VerifyOptions` (allocator field dropped).
+    /// Options for `str_verify`.
     #[derive(Copy, Clone, Default)]
     pub(crate) struct VerifyOptions;
 
     fn map_err(e: &vendor::Error) -> Error {
         use vendor::Error as E;
         match e {
-            // Zig's PhcFormatHasher emits these tags; keep them recognisable so
-            // PasswordObject's `errorName(err)` formatting stays stable.
+            // Keep these tags recognisable so PasswordObject's
+            // `errorName(err)` formatting stays stable.
             E::DecodingFail | E::IncorrectType | E::IncorrectVersion => {
                 bun_core::err!("InvalidEncoding")
             }
@@ -136,19 +131,17 @@ pub mod argon2 {
         }
     }
 
-    /// `std.crypto.pwhash.argon2.strHash` — writes the PHC-encoded hash into
-    /// `out` and returns the populated subslice.
+    /// Writes the PHC-encoded hash into `out` and returns the populated
+    /// subslice.
     pub(crate) fn str_hash<'a>(
         password: &[u8],
         options: HashOptions,
         out: &'a mut [u8],
     ) -> Result<&'a [u8], Error> {
-        // Zig: `switch (options.encoding) { .crypt => return Error.InvalidEncoding, .phc => … }`
         if options.encoding != Encoding::Phc {
             return Err(bun_core::err!("InvalidEncoding"));
         }
 
-        // Zig: `var salt: [default_salt_len]u8 = undefined; crypto.random.bytes(&salt);`
         let mut salt = [0u8; DEFAULT_SALT_LEN];
         getrandom::fill(&mut salt).map_err(|_| bun_core::err!("Unexpected"))?;
 
@@ -159,9 +152,9 @@ pub mod argon2 {
             lanes: options.params.p,
             mem_cost: options.params.m,
             time_cost: options.params.t,
-            // Hashing always runs single-threaded here regardless of `p` —
-            // matches the Zig stdlib, which fans memory across `p` lanes but
-            // computes them on the calling thread.
+            // Hashing always runs single-threaded here regardless of `p`:
+            // memory is fanned across `p` lanes but they are computed on the
+            // calling thread.
             thread_mode: vendor::ThreadMode::Sequential,
             variant: options.mode.to_variant(),
             version: vendor::Version::Version13,
@@ -170,8 +163,7 @@ pub mod argon2 {
         let encoded = vendor::hash_encoded(password, &salt, &config).map_err(|e| map_err(&e))?;
         let bytes = encoded.as_bytes();
 
-        // Zig: `phc_format.serialize(…, buf)` writes into the caller buffer and
-        // errors `NoSpaceLeft` on overflow.
+        // Error `NoSpaceLeft` if the encoded hash overflows the caller buffer.
         if bytes.len() > out.len() {
             return Err(bun_core::err!("NoSpaceLeft"));
         }
@@ -179,20 +171,19 @@ pub mod argon2 {
         Ok(&out[..bytes.len()])
     }
 
-    /// `std.crypto.pwhash.argon2.strVerify`.
+    /// Verify a PHC-encoded argon2 hash.
     pub(crate) fn str_verify(
         encoded_hash: &[u8],
         password: &[u8],
         _options: VerifyOptions,
     ) -> Result<(), Error> {
-        // Zig accepts the encoded hash as `[]const u8` but PHC strings are
-        // 7-bit ASCII; reject non-ASCII input as a decode failure to match
-        // `phc_format.deserialize` behaviour.
+        // PHC strings are 7-bit ASCII; reject non-ASCII input as a decode
+        // failure.
         let encoded = super::phc_ascii_str(encoded_hash)?;
 
-        // Zig (argon2.zig:565-567) only accepts version 0x13: an explicit
-        // `v=` segment that isn't `19` is `InvalidEncoding`, and a missing
-        // `v=` segment still hashes with 0x13 (kdf hard-codes `version`).
+        // Only version 0x13 is accepted: an explicit `v=` segment that isn't
+        // `19` is `InvalidEncoding`, and a missing `v=` segment still hashes
+        // with 0x13.
         // rust-argon2's `verify_encoded` instead accepts `v=16` (computing
         // with Version10) and defaults a missing segment to Version10, so
         // pre-scan and normalise here before delegating.
@@ -217,7 +208,7 @@ pub mod argon2 {
                 std::borrow::Cow::Borrowed(encoded)
             } else {
                 // No `v=` segment — splice in `v=19$` so rust-argon2 hashes
-                // with Version13 like Zig's kdf does.
+                // with Version13.
                 let mut s = String::with_capacity(encoded.len() + 5);
                 s.push_str(&encoded[..=alg_end]);
                 s.push_str("v=19$");
@@ -259,7 +250,7 @@ pub mod argon2 {
         match vendor::verify_encoded(&normalised, password) {
             Ok(true) => Ok(()),
             // `rust-argon2` constant-time compares and returns `Ok(false)` on
-            // mismatch; Zig surfaces this as `error.PasswordVerificationFailed`.
+            // mismatch; surface this as `PasswordVerificationFailed`.
             Ok(false) => Err(bun_core::err!("PasswordVerificationFailed")),
             Err(e) => Err(map_err(&e)),
         }
@@ -271,28 +262,27 @@ pub mod bcrypt {
 
     use ::bcrypt as vendor;
 
-    /// `std.crypto.pwhash.bcrypt.hash_length`
+    /// Length of a modular-crypt bcrypt hash string.
     pub(crate) const HASH_LENGTH: usize = 60;
-    /// Zig `salt_length` / `dk_length` (vendor/zig/lib/std/crypto/bcrypt.zig).
     const SALT_LENGTH: usize = 16;
     const DK_LENGTH: usize = 23;
 
-    /// `std.crypto.pwhash.bcrypt.Params`
+    /// bcrypt parameters.
     #[derive(Copy, Clone)]
     pub struct Params {
-        /// log2 rounds (Zig: u6; clamped 4..=31 by caller).
+        /// log2 rounds (clamped 4..=31 by caller).
         pub rounds_log: u8,
         pub silently_truncate_password: bool,
     }
 
-    /// `std.crypto.pwhash.bcrypt.HashOptions` (allocator field dropped).
+    /// Options for `str_hash`.
     #[derive(Copy, Clone)]
     pub(crate) struct HashOptions {
         pub params: Params,
         pub encoding: Encoding,
     }
 
-    /// `std.crypto.pwhash.bcrypt.VerifyOptions` (allocator field dropped).
+    /// Options for `str_verify`.
     #[derive(Copy, Clone)]
     pub(crate) struct VerifyOptions {
         pub silently_truncate_password: bool,
@@ -304,24 +294,23 @@ pub mod bcrypt {
             E::CostNotAllowed(_) => bun_core::err!("WeakParameters"),
             E::Rand(_) => bun_core::err!("Unexpected"),
             // InvalidHash / InvalidCost / InvalidPrefix / InvalidSaltLen /
-            // InvalidBase64 — all map to Zig's `InvalidEncoding`.
+            // InvalidBase64 — all map to `InvalidEncoding`.
             _ => bun_core::err!("InvalidEncoding"),
         }
     }
 
-    /// `std.crypto.pwhash.bcrypt.strHash` — writes the crypt-encoded hash into
-    /// `out` and returns the populated subslice.
+    /// Writes the crypt-encoded hash into `out` and returns the populated
+    /// subslice.
     pub(crate) fn str_hash<'a>(
         password: &[u8],
         options: HashOptions,
         out: &'a mut [u8],
     ) -> Result<&'a [u8], Error> {
-        // Zig's `CryptFormatHasher.create` checks `buf.len < hash_length` first.
         if out.len() < HASH_LENGTH {
             return Err(bun_core::err!("NoSpaceLeft"));
         }
-        // Bun only ever requests `.crypt`. Zig's `.phc` path emits `$bcrypt$…`
-        // via the PHC serializer, which the Rust `bcrypt` crate does not
+        // Bun only ever requests `.crypt`. A `.phc` request would need the
+        // `$bcrypt$…` PHC serializer, which the Rust `bcrypt` crate does not
         // implement; surface that as an encoding error rather than silently
         // returning the wrong format.
         if options.encoding != Encoding::Crypt {
@@ -330,9 +319,9 @@ pub mod bcrypt {
 
         let cost = u32::from(options.params.rounds_log);
 
-        // Zig's `silently_truncate_password == false` path (bcrypt.zig:473-484)
-        // pre-hashes >72-byte passwords via HMAC-SHA512 keyed by the salt and
-        // never errors; the `bcrypt` crate's `non_truncating_*` instead returns
+        // A `silently_truncate_password == false` implementation would need to
+        // pre-hash >72-byte passwords via HMAC-SHA512 keyed by the salt without
+        // erroring; the `bcrypt` crate's `non_truncating_*` instead returns
         // `Err(Truncation)` (and trips at `>=72`, not `>72`). Bun's only caller
         // (`PasswordObject`) always passes `true` and pre-hashes long passwords
         // itself, so hard-assert here rather than ship a divergent codepath.
@@ -343,12 +332,11 @@ pub mod bcrypt {
         );
 
         // `hash_with_result` → `_hash_password(.., err_on_truncation = false)`:
-        // null-terminates then clamps to 72 bytes, exactly matching Zig's
-        // `State.init` when `silently_truncate_password == true`.
+        // null-terminates then clamps to 72 bytes.
         let parts = vendor::hash_with_result(password, cost).map_err(|e| map_err(&e))?;
 
         // `format_for_version(TwoB)` yields the canonical `$2b$cc$<22 salt><31 hash>`
-        // 60-byte string — identical to Zig's `crypt_format.strHashInternal`.
+        // 60-byte string.
         let encoded = parts.format_for_version(vendor::Version::TwoB);
         let bytes = encoded.as_bytes();
         debug_assert_eq!(bytes.len(), HASH_LENGTH);
@@ -357,7 +345,7 @@ pub mod bcrypt {
         Ok(&out[..bytes.len()])
     }
 
-    /// `std.crypto.pwhash.bcrypt.strVerify`.
+    /// Verify a bcrypt hash (modular-crypt or PHC form).
     pub(crate) fn str_verify(
         encoded_hash: &[u8],
         password: &[u8],
@@ -376,32 +364,30 @@ pub mod bcrypt {
         );
         let _ = options;
 
-        // Zig (bcrypt.zig:794-798) dispatches on prefix:
-        //   `$2…`      → CryptFormatHasher.verify
-        //   otherwise  → PhcFormatHasher.verify (`$bcrypt$r=N$<salt>$<hash>`)
+        // Dispatch on prefix:
+        //   `$2…`      → modular-crypt verify
+        //   otherwise  → PHC verify (`$bcrypt$r=N$<salt>$<hash>`)
         // `PasswordObject::Algorithm::get` sniffs both `$2` *and* `$bcrypt`
         // (PasswordObject.rs:268), so PHC-encoded bcrypt hashes do reach here.
         if !encoded.starts_with("$2") {
             return verify_phc(encoded, password);
         }
 
-        // Crypt path: `CryptFormatHasher.verify` checks `str.len == hash_length`;
-        // the Rust crate does the same inside `split_hash`.
+        // Crypt path: the crate checks `str.len == hash_length` inside
+        // `split_hash`.
         match vendor::verify(password, encoded) {
             Ok(true) => Ok(()),
-            // Zig: `if (!mem.eql(u8, wanted_s[3..], str[3..])) return PasswordVerificationFailed`.
-            // The Rust crate compares only the 23-byte raw digest (constant-time)
-            // and ignores the version prefix, which is the same observable
-            // contract — any `$2a/b/x/y$` hash with matching salt+digest passes.
+            // The crate compares only the 23-byte raw digest (constant-time)
+            // and ignores the version prefix — any `$2a/b/x/y$` hash with
+            // matching salt+digest passes.
             Ok(false) => Err(bun_core::err!("PasswordVerificationFailed")),
             Err(e) => Err(map_err(&e)),
         }
     }
 
-    /// Zig `PhcFormatHasher.verify` — `$bcrypt$r=N$<b64 salt>$<b64 hash>`.
+    /// Verify a PHC-encoded bcrypt hash: `$bcrypt$r=N$<b64 salt>$<b64 hash>`.
     ///
-    /// The Rust `bcrypt` crate has no PHC codec, so parse the string here
-    /// (matching Zig's `phc_format.deserialize` for the `HashResult` shape),
+    /// The Rust `bcrypt` crate has no PHC codec, so parse the string here,
     /// recompute via the raw block cipher, and compare the 23-byte digests.
     fn verify_phc(encoded: &str, password: &[u8]) -> Result<(), Error> {
         let invalid = || bun_core::err!("InvalidEncoding");
@@ -409,12 +395,11 @@ pub mod bcrypt {
         // alg_id
         let rest = encoded.strip_prefix('$').ok_or_else(invalid)?;
         let (alg_id, rest) = rest.split_once('$').ok_or_else(invalid)?;
-        // Zig: `if (!mem.eql(u8, hash_result.alg_id, alg_id)) return PasswordVerificationFailed`
         if alg_id != "bcrypt" {
             return Err(bun_core::err!("PasswordVerificationFailed"));
         }
 
-        // r=N (Zig field is u6; phc_format would reject anything that doesn't fit)
+        // r=N (rounds must fit in 6 bits; checked below)
         let (params, rest) = rest.split_once('$').ok_or_else(invalid)?;
         let rounds_str = params.strip_prefix("r=").ok_or_else(invalid)?;
         let rounds_log: u8 = rounds_str.parse().map_err(|_| invalid())?;
@@ -422,7 +407,7 @@ pub mod bcrypt {
             return Err(invalid());
         }
 
-        // salt / hash — `phc_format.BinValue` uses `std.base64.standard_no_pad`.
+        // salt / hash — standard no-pad base64.
         let (salt_b64, hash_b64) = rest.split_once('$').ok_or_else(invalid)?;
         let decoder = &bun_base64::zig_base64::STANDARD_NO_PAD.decoder;
 
@@ -450,16 +435,15 @@ pub mod bcrypt {
             .decode(&mut expected, hash_b64.as_bytes())
             .map_err(|_| invalid())?;
 
-        // Zig drives the cipher with whatever `rounds_log: u6` it decoded; the
-        // Rust crate's raw `bcrypt()` asserts `cost < 32`, so reject the
+        // The crate's raw `bcrypt()` asserts `cost < 32`, so reject the
         // out-of-range tail here rather than panic. (Values <4 or ≥32 never
         // appear in hashes Bun produced.)
         if !(4..=31).contains(&rounds_log) {
             return Err(bun_core::err!("WeakParameters"));
         }
 
-        // Replicate Zig `bcryptWithTruncation` / the crate's `_hash_password`:
-        // null-terminate then clamp to 72 bytes before feeding the cipher.
+        // Replicate the crate's `_hash_password`: null-terminate then clamp
+        // to 72 bytes before feeding the cipher.
         let mut buf = [0u8; 72];
         let copy_len = password.len().min(72);
         buf[..copy_len].copy_from_slice(&password[..copy_len]);
@@ -467,7 +451,6 @@ pub mod bcrypt {
 
         let computed = vendor::bcrypt(u32::from(rounds_log), salt, &buf[..used]);
 
-        // Zig: `if (!mem.eql(u8, &hash, expected_hash)) return PasswordVerificationFailed`.
         // Compare in constant time like the `$2b$` path (BoringSSL `CRYPTO_memcmp`).
         if bun_boringssl_sys::constant_time_eq(&computed[..DK_LENGTH], &expected) {
             Ok(())
@@ -476,5 +459,3 @@ pub mod bcrypt {
         }
     }
 }
-
-// ported from: vendor/zig/lib/std/crypto/{argon2,bcrypt}.zig
diff --git a/src/runtime/dispatch.rs b/src/runtime/dispatch.rs
index 1ae1c807109..cd79d08ba66 100644
--- a/src/runtime/dispatch.rs
+++ b/src/runtime/dispatch.rs
@@ -3,13 +3,11 @@
 //! Per `docs/PORTING.md` §Dispatch, low-tier crates store
 //! `Task = { tag: TaskTag, ptr: *mut () }` and never name a variant type. This
 //! crate (highest tier) owns **every** variant type, so the actual `match`
-//! loop lives here. LLVM inlines the per-arm direct calls exactly as Zig's
-//! `switch (task.tag()) { inline else => |p| p.run() }` did.
+//! loop lives here, and LLVM inlines the per-arm direct calls.
 //!
 //! Three dispatchers are defined:
-//!   1. [`run_task`] — `bun_event_loop::Task` (~96 variants; src/jsc/Task.zig).
-//!   2. [`run_file_poll`] — `bun_io::FilePoll::Owner` (~13 variants;
-//!      src/aio/posix_event_loop.zig `FilePoll.onUpdate`).
+//!   1. [`run_task`] — `bun_event_loop::Task` (~96 variants).
+//!   2. [`run_file_poll`] — `bun_io::FilePoll::Owner` (~13 variants).
 //!
 //! Low-tier crates declare these as `extern "Rust"`; this crate defines them
 //! `#[no_mangle]` so the linker resolves the call directly — no runtime
@@ -20,9 +18,9 @@
 //!   2. `impl bun_jsc::Taskable for YourType { const TAG = task_tag::YourType; }`;
 //!   3. a match arm here.
 
-// Flat re-export landing pad for `generated_js2native.rs` thunks whose source
-// `.zig` file lives outside `src/runtime/`. Kept in a sibling file so this
-// hot-path module stays focused on the task/timer/poll match loops.
+// Flat re-export landing pad for `generated_js2native.rs` thunks. Kept in a
+// sibling file so this hot-path module stays focused on the task/timer/poll
+// match loops.
 #[path = "dispatch_js2native.rs"]
 pub mod js2native;
 
@@ -171,12 +169,12 @@ use bun_jsc::abort_signal::Timeout as AbortSignalTimeout;
 use bun_io::pipe_writer::PosixPipeWriter; // brings `on_poll` into scope for FileSinkPoll/StaticPipeWriterPoll/etc.
 
 // ════════════════════════════════════════════════════════════════════════════
-// Task dispatch (src/jsc/Task.zig `tickQueueWithCount` switch)
+// Task dispatch
 // ════════════════════════════════════════════════════════════════════════════
 
 /// Per-arm result for [`run_task`]: `Continue` means proceed to drain
 /// microtasks and the next item; `EarlyReturn` is the HotReloadTask special
-/// case (Zig: `counter.* = 0; return;` — microtasks must NOT drain).
+/// case — microtasks must NOT drain.
 pub enum RunTaskResult {
     Continue,
     EarlyReturn,
@@ -184,11 +182,9 @@ pub enum RunTaskResult {
 
 /// Dispatch a single `Task` to its variant's `run`-style entry point.
 ///
-/// This is the body of one iteration of Zig `tickQueueWithCount`'s `while`
-/// loop (the per-item `switch`). The surrounding drain loop + microtask flush
+/// The surrounding drain loop + microtask flush
 /// lives in [`tick_queue_with_count`] below.
-// PERF(startup/dot): `#[inline(never)]` is deliberate. Zig's `inline else`
-// monomorphized every arm into the drain loop, but in Rust `#[inline]` here
+// PERF(startup/dot): `#[inline(never)]` is deliberate. `#[inline]` here
 // bloated `tick_queue_with_count` to ~14 KB of `.text` interleaved with cold
 // shell/bake code, blowing the iTLB fault-around window for `bun <file>`.
 // Keeping `run_task` out-of-line lets `tick_queue_with_count` stay a tight
@@ -228,10 +224,9 @@ pub fn run_task(
             };
         }};
     }
-    /// Zig: `var t = task.get(T).?; defer t.deinit(); try t.runFromJS();`.
-    /// `defer` runs after `try` whether it errored or not, so destroy
-    /// unconditionally then propagate. `JsTerminated` tears down the VM,
-    /// so the destroy ordering is observably equivalent.
+    /// Run the task, destroy it unconditionally (whether or not it errored),
+    /// then propagate. `JsTerminated` tears down the VM, so destroying before
+    /// propagating is safe.
     macro_rules! run_then_destroy {
         ($ty:ty) => {{
             let t = cast_ptr!($ty);
@@ -257,7 +252,6 @@ pub fn run_task(
         // ── erased-callback tasks (low-tier types — real) ────────────────
         task_tag::AnyTask => {
             let any = cast!(AnyTask);
-            // Zig: `any.run() catch |err| reportErrorOrTerminate(global, err)`.
             // `bun_event_loop::ErasedJsError` carries the discriminant; recover
             // the real `JsError` so `Terminated` short-circuits correctly.
             if let Err(err) = any.run() {
@@ -265,7 +259,6 @@ pub fn run_task(
             }
         }
         task_tag::ManagedTask => {
-            // Zig: `any.run() catch |err| reportErrorOrTerminate(global, err)`.
             // SAFETY: `task.ptr` was produced by `heap::alloc` in `ManagedTask::new`
             // and enqueued under `task_tag::ManagedTask`; `run` consumes/frees it.
             if let Err(err) = unsafe { ManagedTask::run(cast_ptr!(ManagedTask)) } {
@@ -273,7 +266,6 @@ pub fn run_task(
             }
         }
         task_tag::CppTask => {
-            // Zig: `any.run(global) catch |err| reportErrorOrTerminate(global, err)`.
             if let Err(err) = cast!(CppTask).run(global) {
                 report_error_or_terminate(global, err)?;
             }
@@ -353,7 +345,6 @@ pub fn run_task(
             cast!(JSCDeferredWorkTask).run()?;
         }
         task_tag::PollPendingModulesTask => {
-            // Zig: `virtual_machine.modules.onPoll()`.
             vm.modules.on_poll();
         }
         task_tag::RuntimeTranspilerStore => {
@@ -361,12 +352,10 @@ pub fn run_task(
             store.run_from_js_thread(el.into(), global, vm.into());
         }
 
-        // ── hot-reload (Zig early-returns from the drain loop) ───────────
+        // ── hot-reload (early-returns from the drain loop) ───────────────
         task_tag::HotReloadTask => {
             let t = cast_ptr!(hot_reloader::HotReloadTask);
-            // Zig: `defer t.deinit(); t.run(); counter.* = 0; return;`.
-            // The task was heap-allocated in `Task::enqueue` (`bun.new`);
-            // `deinit` frees it (`bun.destroy`).
+            // The task was heap-allocated in `Task::enqueue`; `deinit` frees it.
             // SAFETY: tag identifies pointee; live Box'd HotReloadTask.
             unsafe { (*t).run() };
             // SAFETY: paired with heap::alloc in `Task::enqueue`.
@@ -376,7 +365,7 @@ pub fn run_task(
         // ── bake dev-server (cold — hoisted to `run_task_cold`) ──────────
         task_tag::BakeHotReloadEvent => run_task_cold(task),
         task_tag::FSWatchTask => {
-            // Zig: `defer t.deinit(); t.run();` — the task is heap-allocated
+            // The task is heap-allocated
             // (cloned from `FSWatcher.current_task` at enqueue). `deinit` is
             // explicit (not `Drop`) so the embedded `current_task` field never
             // runs it.
@@ -428,8 +417,7 @@ pub fn run_task(
             unreachable!("posix-only");
         }
         task_tag::PosixSignalTask => {
-            // Zig: `PosixSignalTask.runFromJSThread(@intCast(task.asUintptr()), global)`
-            // — `ptr` here is *not* a pointer but a packed signal number.
+            // `ptr` here is *not* a pointer but a packed signal number.
             let _ = core::marker::PhantomData::<PosixSignalTask>;
             bun_jsc::posix_signal_handle::PosixSignalTask::run_from_js_thread(
                 task.ptr as usize as u8,
@@ -437,7 +425,7 @@ pub fn run_task(
             );
         }
         task_tag::NativePromiseContextDeferredDerefTask => {
-            // Zig: `runFromJSThread(@intCast(task.asUintptr()))` — `ptr` packs an int.
+            // `ptr` packs an int, not a pointer.
             NativePromiseContextDeferredDerefTask::run_from_js_thread(task.ptr as usize);
         }
 
@@ -449,8 +437,6 @@ pub fn run_task(
             )?;
         }
         task_tag::BundleV2DeferredBatchTask => {
-            // Zig: `Plugin.drainDeferred` is wrapped in `fromJSHostCallGeneric`
-            // (== `call_check_slow`) and the only caller does `catch return`.
             // `bun_bundler` is JSC-free so the exception-scope check is hoisted
             // to this dispatch arm; without it, `JSBundlerPlugin__drainDeferred`'s
             // THROW_SCOPE is left unchecked and trips JSC exception validation
@@ -468,10 +454,8 @@ pub fn run_task(
             StreamPending::run_from_js_thread(cast_ptr!(StreamPending));
         }
 
-        // ── timer wrappers (declared in the union but never dispatched
-        //    here in Zig either — see Task.zig trailing `else`) ───────────
+        // ── timer wrappers (declared in the union but never dispatched) ──
         task_tag::ImmediateObject | task_tag::TimeoutObject => {
-            // Spec Task.zig:529-535: `bun.Output.panic("Unexpected Task tag: {d}")`.
             // This is a *reachable* producer bug (timer object enqueued as Task),
             // not provable-unreachable — `unreachable_unchecked()` here would be
             // release-build UB. PORTING.md §Dispatch only sanctions UB for the
@@ -480,9 +464,8 @@ pub fn run_task(
         }
 
         _ => {
-            // Spec Task.zig:529-535: controlled `bun.Output.panic` with
-            // diagnostic. A value outside `task_tag::COUNT` is a producer bug,
-            // but the spec treats it as a recoverable crash, not UB.
+            // A value outside `task_tag::COUNT` is a producer bug, but it's
+            // treated as a recoverable crash, not UB.
             panic!("Unexpected Task tag: {}", task.tag.0);
         }
     }
@@ -511,7 +494,7 @@ fn run_task_cold(task: Task) {
     }
     /// Shell builtin tasks: route through `ShellTask::run_from_main_thread`
     /// so the keep-alive ref taken in `ShellTask::schedule` is unref'd before
-    /// the per-builtin body runs (Zig: `InnerShellTask.runFromMainThread`).
+    /// the per-builtin body runs.
     /// The wrapper recovers `&mut Interpreter` from the embedded
     /// `ShellTask.interp` back-ref.
     macro_rules! shell_dispatch {
@@ -520,9 +503,12 @@ fn run_task_cold(task: Task) {
             // `interp` was set at schedule time and outlives the task.
             unsafe { ShellTask::run_from_main_thread::<$ty>(cast_ptr!($ty)) };
         }};
-        // `.task.task.runFromMainThread()` shape (cond-expr wraps an inner
-        // `task: ShellTask`-embedding struct one level deeper). Not a
-        // `ShellTaskCtx` implementor, so unref + interp-recovery are inlined.
+        // Cond-expr wraps an inner `task: ShellTask`-embedding struct one
+        // level deeper. The type *does* implement `ShellTaskCtx`
+        // (with a two-hop `TASK_OFFSET`, needed for `ShellTask::schedule`),
+        // so this arm is behaviorally identical to the plain arm; the unref +
+        // interp-recovery are inlined here only to keep the `.task.task`
+        // shape explicit at the dispatch site.
         (nested $ty:ty) => {{
             let t = cast_ptr!($ty);
             // SAFETY: see above; `task.task` is the embedded ShellTask.
@@ -538,8 +524,6 @@ fn run_task_cold(task: Task) {
     match task.tag {
         // ── shell interpreter ────────────────────────────────────────────
         task_tag::ShellAsync => {
-            // Spec Task.zig:161 `runFromMainThread()` — Rust port routes via
-            // (interp, NodeId).
             // SAFETY: §Dispatch — tag identifies pointee.
             let t = unsafe { &mut *cast_ptr!(crate::shell::dispatch_tasks::ShellAsyncTask) };
             // SAFETY: `interp` set at enqueue; outlives task.
@@ -563,8 +547,6 @@ fn run_task_cold(task: Task) {
             ShellIOReaderAsyncDeinit::run_from_main_thread(t);
         }
         task_tag::ShellCondExprStatTask => {
-            // Spec: `task.get(..).?.task.runFromMainThread()` — one level of
-            // `.task` indirection in Zig too.
             shell_dispatch!(nested ShellCondExprStatTask);
         }
         task_tag::ShellCpTask => shell_dispatch!(ShellCpTask),
@@ -590,7 +572,6 @@ fn run_task_cold(task: Task) {
         }
 
         // ShellYesTask + any tag the hot path mis-routed: producer bug.
-        // Spec Task.zig:529-535 `bun.Output.panic("Unexpected Task tag: {d}")`.
         _ => panic!("Unexpected Task tag: {}", task.tag.0),
     }
 }
@@ -603,7 +584,7 @@ const _: () = assert!(
 );
 
 // ────────────────────────────────────────────────────────────────────────────
-// `tick_queue_with_count` — the full drain loop (Zig `tickQueueWithCount`).
+// `tick_queue_with_count` — the full drain loop.
 // ────────────────────────────────────────────────────────────────────────────
 
 pub fn tick_queue_with_count(
@@ -612,7 +593,7 @@ pub fn tick_queue_with_count(
     counter: &mut u32,
 ) -> Result<(), JsTerminated> {
     // SAFETY: `el.global` is set by VM init before the first tick; live for
-    // the duration of the drain loop (Zig: `this.global`).
+    // the duration of the drain loop.
     let global: &JSGlobalObject = unsafe { el.global.expect("EventLoop.global unset").as_ref() };
     let global_vm = global.vm();
 
@@ -620,9 +601,6 @@ pub fn tick_queue_with_count(
     if el.debug.js_call_count_outside_tick_queue
         > el.debug.drain_microtasks_count_outside_tick_queue
     {
-        // PORT NOTE: Zig `bun.Output.panic` with the long advisory string.
-        // We keep the assert + short message; the full text is debug-only and
-        // can be expanded when `Output::panic` lands.
         panic!(
             "{} JavaScript functions were called outside of the microtask queue without draining microtasks. Use EventLoop.runCallback().",
             el.debug.js_call_count_outside_tick_queue
@@ -631,19 +609,15 @@ pub fn tick_queue_with_count(
     }
 
     while let Some(task) = el.tasks.read_item() {
-        // PORT NOTE: Zig increments `counter` via `defer counter.* += 1;` at
-        // the top of the loop body, so it fires on every scope exit including
-        // the HotReloadTask `return`. Hoisting it before dispatch keeps the
-        // Continue path identical and avoids a scopeguard.
+        // Incremented before dispatch so the count includes every task,
+        // including the one that takes the HotReloadTask early return.
         *counter += 1;
         match run_task(task, el, vm, global)? {
             RunTaskResult::Continue => {}
             RunTaskResult::EarlyReturn => {
-                // Zig: `counter.* = 0; return;` followed by the deferred
-                // `counter.* += 1` (defers run after `return`, LIFO), so the
-                // observable result is `counter == 1`. Caller is
-                // `while tickWithCount(ctx) > 0` — must keep draining after a
-                // hot-reload task. Do NOT set 0 here.
+                // Caller is `while tickWithCount(ctx) > 0` — must keep
+                // draining after a hot-reload task, so report exactly one
+                // task processed. Do NOT set 0 here.
                 *counter = 1;
                 return Ok(());
             }
@@ -655,7 +629,7 @@ pub fn tick_queue_with_count(
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// FilePoll dispatch (src/aio/posix_event_loop.zig `FilePoll.onUpdate` switch)
+// FilePoll dispatch
 // ════════════════════════════════════════════════════════════════════════════
 
 /// Hot-path dispatcher for `bun_io::FilePoll::on_update`. Declared
@@ -686,7 +660,7 @@ pub unsafe fn __bun_run_file_poll(poll: *mut FilePoll, size_or_offset: i64) {
     /// One match-arm body of the poll-tag dispatch. Recovers the typed owner as
     /// a RAW `*mut $Ty` (never `&mut` — re-entrant callees like `DNSResolver`
     /// pick their own deref mode without aliasing UB) then runs `$body`. The
-    /// 1-arg form is the Zig `ptr.as(T).onPoll(size_or_offset, hup)` shape that
+    /// 1-arg form is the plain `on_poll(size_or_offset, hup)` call that
     /// covers most tags.
     macro_rules! poll_arm {
         ($Ty:ty) => {
@@ -718,8 +692,7 @@ pub unsafe fn __bun_run_file_poll(poll: *mut FilePoll, size_or_offset: i64) {
         }
         poll_tag::PARENT_DEATH_WATCHDOG => {
             let wd = owner_as!(bun_io::parent_death_watchdog::ParentDeathWatchdog);
-            // Zig gates this `comptime !Environment.isMac => unreachable`;
-            // mirror with a debug-assert (Linux uses prctl(PR_SET_PDEATHSIG)).
+            // Mac-only — debug-assert elsewhere (Linux uses prctl(PR_SET_PDEATHSIG)).
             #[cfg(target_os = "macos")]
             bun_io::parent_death_watchdog::on_parent_exit(wd);
             #[cfg(not(target_os = "macos"))]
@@ -784,7 +757,6 @@ pub unsafe fn __bun_run_file_poll(poll: *mut FilePoll, size_or_offset: i64) {
         }
 
         poll_tag::NULL => {
-            // Zig: `else => log("onUpdate ... disconnected? (maybe: {s})")`.
             // The low-tier `on_update` already logged before calling the hook
             // when it was null; here we just no-op the unknown tag.
             let _ = (size_or_offset, hup);
@@ -793,15 +765,14 @@ pub unsafe fn __bun_run_file_poll(poll: *mut FilePoll, size_or_offset: i64) {
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// io::Poll dispatch (src/io/io.zig `Poll.onUpdateKqueue`/`onUpdateEpoll` switch)
+// io::Poll dispatch
 // ════════════════════════════════════════════════════════════════════════════
 
 use crate::webcore::blob::read_file::ReadFile;
 use crate::webcore::blob::write_file::WriteFile;
 
 /// `bun_io::__bun_io_pollable_on_ready` body — declared `extern "Rust"` in
-/// `bun_io`. Spec `io.zig:626`: `inline else => |t| this.onReady()` where
-/// `this` is recovered from the embedded `io_poll` field.
+/// `bun_io`. The owner is recovered from the embedded `io_poll` field.
 ///
 /// # Safety
 /// `poll` is the `io_poll` field of a live owner of type `tag`.
@@ -826,7 +797,7 @@ pub(crate) unsafe fn __bun_io_pollable_on_ready(tag: bun_io::PollableTag, poll:
 }
 
 /// `bun_io::__bun_io_pollable_on_io_error` body — declared `extern "Rust"` in
-/// `bun_io`. Spec `io.zig:629`: `this.onIOError(err)`.
+/// `bun_io`.
 ///
 /// # Safety
 /// `poll` is the `io_poll` field of a live owner of type `tag`.
@@ -845,7 +816,7 @@ pub(crate) unsafe fn __bun_io_pollable_on_io_error(
         bun_io::PollableTag::WriteFile => {
             // SAFETY: per fn contract.
             let this = unsafe { bun_core::from_field_ptr!(WriteFile, io_poll, poll) };
-            // PORT NOTE: WriteFile::on_io_error already takes `*mut ()` (it
+            // WriteFile::on_io_error already takes `*mut ()` (it
             // self-recovers via the io_request path elsewhere); reuse that
             // shape rather than reborrowing `&mut`.
             WriteFile::on_io_error(this.cast(), err);
@@ -907,8 +878,7 @@ pub(crate) unsafe fn __bun_cancel_pending_immediate(
 }
 
 /// `__bun_run_wtf_timer` body — cast the low-tier erased `*mut ()` to the real
-/// `crate::timer::WTFTimer` and fire it (spec event_loop.zig:302-306
-/// `imminent_gc_timer.swap(null).?.run(vm)`).
+/// `crate::timer::WTFTimer` and fire it.
 ///
 /// # Safety
 /// `timer` was published by `WTFTimer::update` into `imminent_gc_timer` and
@@ -928,11 +898,11 @@ pub(crate) unsafe fn __bun_run_wtf_timer(
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// EventLoopTimer dispatch (src/event_loop/EventLoopTimer.zig `fire` switch)
+// EventLoopTimer dispatch
 // ════════════════════════════════════════════════════════════════════════════
 
 /// `__bun_fire_timer` body — the tag→`container_of` match for
-/// [`EventLoopTimer::fire`]. Spec EventLoopTimer.zig:170-223.
+/// [`EventLoopTimer::fire`].
 ///
 /// Reached from [`crate::timer::All::drain_timers`] (every due heap timer) and
 /// [`crate::timer::All::get_timeout`] (WTFTimer side-effect).
@@ -1040,7 +1010,6 @@ pub unsafe fn __bun_fire_timer(t: *mut EventLoopTimer, now: *const ElTimespec, v
             }
             #[cfg(not(windows))]
             {
-                // Spec: `UnreachableTimer` on non-Windows.
                 if cfg!(debug_assertions) {
                     unreachable!("WindowsNamedPipe timer on non-Windows");
                 }
@@ -1083,8 +1052,8 @@ pub unsafe fn __bun_fire_timer(t: *mut EventLoopTimer, now: *const ElTimespec, v
                 .timeout_callback())
         }
         EventLoopTimerTag::DevServerSweepSourceMaps => {
-            // Spec: `bun.bake.DevServer.SourceMapStore.sweepWeakRefs(self, now)`
-            // — takes the raw `*EventLoopTimer` and recovers the store inside.
+            // `sweep_weak_refs` takes the raw `*EventLoopTimer` and recovers
+            // the store inside.
             // SAFETY: per fn contract.
             SourceMapStore::sweep_weak_refs(t, unsafe { &*now });
         }
@@ -1094,9 +1063,6 @@ pub unsafe fn __bun_fire_timer(t: *mut EventLoopTimer, now: *const ElTimespec, v
             DevServer::emit_memory_visualizer_message_timer(unsafe { &mut *t }, unsafe { &*now });
         }
         EventLoopTimerTag::BunTest => {
-            // Spec: `BunTestPtr.cloneFromRawUnsafe(@fieldParentPtr("timer", self))`
-            // — bumps the Rc refcount around the callback so the timer can
-            // safely re-enter `BunTest::run`.
             let container = owner!(BunTest, timer);
             // SAFETY: container is the payload of a live `Rc<BunTestCell>`; the
             // strong count is ≥1 (held by `Jest.active_file`).
@@ -1131,9 +1097,9 @@ pub unsafe fn __bun_fire_timer(t: *mut EventLoopTimer, now: *const ElTimespec, v
 }
 
 /// `__bun_js_timer_epoch` body — the tag→`container_of` read for
-/// [`EventLoopTimer::js_timer_epoch`]. Spec EventLoopTimer.zig
-/// `jsTimerInternalsFlags` (returns `internals.flags.epoch` for the three
-/// JS-timer container types, else null). Sits on the heap-compare hot path
+/// [`EventLoopTimer::js_timer_epoch`]. Returns `internals.flags.epoch` for
+/// the three JS-timer container types, else `None`. Sits on the heap-compare
+/// hot path
 /// (`EventLoopTimer::less` → `TimerHeap` meld).
 ///
 /// # Safety
@@ -1150,8 +1116,8 @@ pub unsafe fn __bun_js_timer_epoch(
 }
 
 /// `__bun_tick_queue_with_count` body — declared `extern "Rust"` in
-/// `bun_jsc::event_loop`. `el` is the queue to drain (Zig
-/// `tickQueueWithCount(this, ...)`); for `SpawnSyncEventLoop.tickTasksOnly`
+/// `bun_jsc::event_loop`. `el` is the queue to drain; for
+/// `SpawnSyncEventLoop.tickTasksOnly`
 /// this is the isolated loop, **not** `vm.event_loop()`.
 ///
 /// # Safety
@@ -1229,5 +1195,3 @@ pub(crate) fn __bun_release_task_at_shutdown(task: bun_event_loop::Task) -> bool
         _ => false,
     }
 }
-
-// ported from: src/jsc/Task.zig
diff --git a/src/runtime/dispatch_js2native.rs b/src/runtime/dispatch_js2native.rs
index a6b503fffa5..4af6e63fec5 100644
--- a/src/runtime/dispatch_js2native.rs
+++ b/src/runtime/dispatch_js2native.rs
@@ -16,16 +16,12 @@
 
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 
-// ── src/sql/jsc/{mysql,postgres}.zig ─────────────────────────────────────────
 pub use bun_sql_jsc::mysql::create_binding as sql_jsc_mysql_create_binding;
 pub use bun_sql_jsc::postgres::create_binding as sql_jsc_postgres_create_binding;
 
-// ── src/crash_handler/crash_handler.zig js_bindings.generate ────────────────
-// Zig aliases this to `runtime/api/crash_handler_jsc.zig::js_bindings`; the
-// real body already lives in this crate.
+// The real body already lives in this crate.
 pub use crate::api::crash_handler_jsc::js_bindings::generate as crash_handler_crash_handler_js_bindings_generate;
 
-// ── src/install/**.zig ──────────────────────────────────────────────────────
 pub use bun_install_jsc::dependency_jsc::dependency_from_js as install_dependency_from_js;
 pub use bun_install_jsc::dependency_jsc::tag_infer_from_js as install_dependency_version_tag_infer_from_js;
 pub use bun_install_jsc::hosted_git_info_jsc::js_from_url as install_hosted_git_info_testing_ap_is_js_from_url;
@@ -35,47 +31,39 @@ pub use bun_install_jsc::npm_jsc::architecture_is_match as install_npm_architect
 pub use bun_install_jsc::npm_jsc::operating_system_is_match as install_npm_operating_system_js_function_operating_system_is_match;
 pub use bun_install_jsc::npm_jsc::package_manifest_bindings_generate as install_npm_package_manifest_bindings_generate;
 
-// ── src/ini/ini.zig IniTestingAPIs ──────────────────────────────────────────
-// PORT NOTE: the `*_jsc` bodies were lifted into `bun_install_jsc::ini_jsc`
+// The `*_jsc` bodies live in `bun_install_jsc::ini_jsc`
 // (ini's only JSC consumer is `bun install`'s npmrc loader).
 pub use bun_install_jsc::ini_jsc::ini_testing_load_npmrc_from_js as ini_ini_ini_testing_ap_is_load_npmrc_from_js;
 pub use bun_install_jsc::ini_jsc::ini_testing_parse as ini_ini_ini_testing_ap_is_parse;
 
-// ── src/jsc/*.zig ───────────────────────────────────────────────────────────
 pub use bun_jsc::bindgen_test::get_bindgen_test_functions as jsc_bindgen_test_get_bindgen_test_functions;
 pub use bun_jsc::counters::create_counters_object as jsc_counters_create_counters_object;
 pub use bun_jsc::event_loop::get_active_tasks as jsc_event_loop_get_active_tasks;
 pub use bun_jsc::virtual_machine_exports::Bun__setSyntheticAllocationLimitForTesting as jsc_virtual_machine_exports_bun__set_synthetic_allocation_limit_for_testing;
-// `src/jsc/ipc.zig emitHandleIPCMessage` is implemented in this crate
-// (`ipc_host.rs`) because it dereferences `Subprocess`, a runtime type.
+// `emit_handle_ipc_message` is implemented in this crate (`ipc_host.rs`)
+// because it dereferences `Subprocess`, a runtime type.
 pub use crate::ipc_host::emit_handle_ipc_message as jsc_ipc_emit_handle_ipc_message;
 
-// ── src/string/*.zig ────────────────────────────────────────────────────────
 pub use bun_jsc::bun_string_jsc::js_escape_reg_exp as string_escape_reg_exp_js_escape_reg_exp;
 pub use bun_jsc::bun_string_jsc::js_escape_reg_exp_for_package_name_matching as string_escape_reg_exp_js_escape_reg_exp_for_package_name_matching;
 pub use bun_jsc::bun_string_jsc::unicode_testing_apis::to_utf16_alloc_sentinel as bun_core_string_immutable_unicode_testing_ap_is_to_utf16_alloc_sentinel;
 
-// ── src/patch/patch.zig TestingAPIs ─────────────────────────────────────────
 pub use bun_patch_jsc::testing::patch_apply as patch_patch_testing_ap_is_apply;
 pub use bun_patch_jsc::testing::patch_make_diff as patch_patch_testing_ap_is_make_diff;
 pub use bun_patch_jsc::testing::patch_parse as patch_patch_testing_ap_is_parse;
 
-// ── src/sourcemap/InternalSourceMap.zig TestingAPIs ─────────────────────────
 pub use bun_sourcemap_jsc::internal_jsc::testing_find as sourcemap_internal_source_map_testing_ap_is_find;
 pub use bun_sourcemap_jsc::internal_jsc::testing_from_vlq as sourcemap_internal_source_map_testing_ap_is_from_vlq;
 pub use bun_sourcemap_jsc::internal_jsc::testing_to_vlq as sourcemap_internal_source_map_testing_ap_is_to_vlq;
 
-// ── src/sys/{sys,Error}.zig TestingAPIs ─────────────────────────────────────
 pub use bun_sys_jsc::error_jsc::TestingAPIs::sigaction_layout as sys_sys_testing_ap_is_sigaction_layout;
 pub use bun_sys_jsc::error_jsc::TestingAPIs::sys_error_name_from_libuv as sys_error_testing_ap_is_sys_error_name_from_libuv;
 pub use bun_sys_jsc::error_jsc::TestingAPIs::translate_uv_error_to_e as sys_sys_testing_ap_is_translate_uv_error_to_e;
 
-// ── src/http/{H2Client,H3Client}.zig TestingAPIs ────────────────────────────
 pub use bun_http_jsc::headers_jsc::h2_live_counts as http_h2_client_testing_ap_is_live_counts;
 pub use bun_http_jsc::headers_jsc::h3_quic_live_counts as http_h3_client_testing_ap_is_quic_live_counts;
 
-// ── src/bun.zig getUseSystemCA ──────────────────────────────────────────────
-/// Port of `src/bun.zig:getUseSystemCA`. Lives here (not in `src/bun.rs`)
+/// Lives here (not in `src/bun.rs`)
 /// because the flag it reads — `cli::Arguments::Bun__Node__UseSystemCA` — is
 /// owned by `bun_runtime`; placing the body in a lower crate would invert the
 /// dependency edge.
@@ -88,7 +76,6 @@ pub(crate) fn bun_get_use_system_ca(
     Ok(JSValue::js_boolean(v))
 }
 
-// ── src/css/jsc/css_internals.zig ───────────────────────────────────────────
 mod css {
     pub use bun_css_jsc::css_internals::{
         _test, attr_test, minify_error_test_with_options, minify_test, minify_test_with_options,
@@ -104,7 +91,6 @@ pub use css::prefix_test as css_jsc_css_internals_prefix_test;
 pub use css::prefix_test_with_options as css_jsc_css_internals_prefix_test_with_options;
 pub use css::test_with_options as css_jsc_css_internals_test_with_options;
 
-// ── src/collections/linear_fifo.zig TestingAPIs (test-only) ─────────────────
 // `LinearFifo` has no JSC consumer of its own; this `bun:internal-for-testing`
 // probe lives in `bun_runtime` (which depends on both `bun_collections` and
 // `bun_jsc`) rather than inventing a JSC edge into the collections crate.
diff --git a/src/runtime/dns_jsc/cares_jsc.rs b/src/runtime/dns_jsc/cares_jsc.rs
index a8ece76e7c4..5d54b8cf802 100644
--- a/src/runtime/dns_jsc/cares_jsc.rs
+++ b/src/runtime/dns_jsc/cares_jsc.rs
@@ -13,9 +13,7 @@ use bun_jsc::{
 
 use crate::dns_jsc::options_jsc::{address_to_js, result_to_js};
 
-/// Local shim for the missing `ZigString::to_js` extension — Zig's
-/// `ZigString.fromUTF8(slice).toJS(global)` is equivalent to creating a JS
-/// string directly from UTF-8 bytes.
+/// Create a JS string directly from UTF-8 bytes.
 #[inline]
 fn utf8_to_js(global: &JSGlobalObject, bytes: &[u8]) -> JsResult<JSValue> {
     bun_string_jsc::create_utf8_for_js(global, bytes)
@@ -25,7 +23,7 @@ fn utf8_to_js(global: &JSGlobalObject, bytes: &[u8]) -> JsResult<JSValue> {
 pub(crate) fn hostent_to_js_response(
     this: &mut c_ares::struct_hostent,
     global_this: &JSGlobalObject,
-    lookup_name: &'static [u8], // PERF(port): was comptime monomorphization — profile if hot
+    lookup_name: &'static [u8], // PERF: could be monomorphized per lookup name — profile if hot
 ) -> JsResult<JSValue> {
     if lookup_name == b"cname" {
         // A cname lookup always returns a single record but we follow the common API here.
@@ -69,7 +67,7 @@ pub(crate) fn hostent_to_js_response(
 pub(crate) fn hostent_with_ttls_to_js_response(
     this: &mut c_ares::hostent_with_ttls,
     global_this: &JSGlobalObject,
-    lookup_name: &'static [u8], // PERF(port): was comptime monomorphization — profile if hot
+    lookup_name: &'static [u8], // PERF: could be monomorphized per lookup name — profile if hot
 ) -> JsResult<JSValue> {
     if lookup_name == b"a" || lookup_name == b"aaaa" {
         // SAFETY: this.hostent is a c-ares-owned hostent pointer (non-null on success path).
@@ -93,7 +91,6 @@ pub(crate) fn hostent_with_ttls_to_js_response(
             if addr.is_null() {
                 break;
             }
-            // PORT NOTE: Zig built std.net.Address via .initIp4/.initIp6. Rust
             // bun_dns::Address (= bun_sys::net::Address) only exposes init_posix,
             // so build a sockaddr_in/in6 on the stack and copy through that.
             let addr_string = {
@@ -127,8 +124,6 @@ pub(crate) fn hostent_with_ttls_to_js_response(
             } else {
                 None
             };
-            // PORT NOTE: Zig used `JSValue.createObject2`. No such helper on
-            // `bun_jsc::JSValue`; build via `create_empty_object` + `put`.
             let result_object = JSValue::create_empty_object(global_this, 2);
             result_object.put(global_this, b"address", addr_string);
             result_object.put(
@@ -146,7 +141,7 @@ pub(crate) fn hostent_with_ttls_to_js_response(
 
         Ok(array)
     } else {
-        // Zig: @compileError — the comptime param guaranteed only "a"/"aaaa" reach here.
+        // Callers guarantee only "a"/"aaaa" reach here.
         unreachable!("Unsupported hostent_with_ttls record type");
     }
 }
@@ -196,7 +191,6 @@ pub(crate) fn addr_info_to_js_array(
         while !current.is_null() {
             // SAFETY: current is non-null (loop guard); c-ares owns the linked list.
             let this_node = unsafe { &*current };
-            // PORT NOTE: Zig matched on family and union-viewed std.net.Address.
             // bun_dns::Address::init_posix copies from the raw sockaddr by family,
             // so we hand it `this_node.addr` directly after asserting a known family.
             debug_assert!(
@@ -226,11 +220,10 @@ pub(crate) fn addr_info_to_js_array(
 // ── shared count-then-walk → JS array helper ───────────────────────────────
 //
 // Every `struct_ares_*_reply` is an intrusive singly-linked list with a
-// `.next: *mut Self` field. Zig open-codes the same two-pass walk (count,
-// then `create_empty_array` + `put_index`) once per record type; here we do
-// it once generically. The trait is `unsafe` because impls promise `next()`
+// `.next: *mut Self` field. The two-pass walk (count, then
+// `create_empty_array` + `put_index`) is done once generically here.
+// The trait is `unsafe` because impls promise `next()`
 // is either null or a valid pointer into the same c-ares-owned list.
-// PERF(port): each Zig caller used stack-fallback + arena bulk-free — profile if hot.
 
 /// SAFETY: impls must return null or a valid pointer into the same
 /// c-ares-owned linked list.
@@ -399,8 +392,6 @@ pub(crate) fn txt_reply_to_js_for_any(
 ) -> JsResult<JSValue> {
     let array =
         cares_list_to_js_array(this, global_this, |node, g| utf8_to_js(g, node.txt_bytes()))?;
-    // PORT NOTE: Zig used `JSObject.create(.{ .entries = array }, global)`. No
-    // anon-struct builder on `bun_jsc::JSObject`; use `create_empty_object` + `put`.
     let obj = JSValue::create_empty_object(global_this, 1);
     obj.put(global_this, b"entries", array);
     Ok(obj)
@@ -457,7 +448,7 @@ pub(crate) fn soa_reply_to_js_response(
     global_this: &JSGlobalObject,
     _lookup_name: &'static [u8],
 ) -> JsResult<JSValue> {
-    // PERF(port): was stack-fallback + arena bulk-free — profile if hot
+    // PERF: a stack-fallback buffer + arena bulk-free could help — profile if hot
     soa_reply_to_js(this, global_this)
 }
 
@@ -510,7 +501,7 @@ pub(crate) fn any_reply_to_js_response(
     global_this: &JSGlobalObject,
     _lookup_name: &'static [u8],
 ) -> JsResult<JSValue> {
-    // PERF(port): was stack-fallback + arena bulk-free — profile if hot
+    // PERF: a stack-fallback buffer + arena bulk-free could help — profile if hot
     any_reply_to_js(this, global_this)
 }
 
@@ -522,8 +513,6 @@ fn any_reply_append(
     lookup_name: &'static [u8],
 ) -> JsResult<()> {
     let transformed = if response.is_string() {
-        // PORT NOTE: Zig used `JSObject.create(.{ .value = response }, global)`. No
-        // anon-struct builder on `bun_jsc::JSObject`; use `create_empty_object` + `put`.
         let obj = JSValue::create_empty_object(global_this, 1);
         obj.put(global_this, b"value", response);
         obj
@@ -532,7 +521,7 @@ fn any_reply_append(
         response
     };
 
-    // PERF(port): was comptime ASCII-uppercase of lookup_name — profile if hot
+    // PERF: the ASCII-uppercase of lookup_name could be precomputed — profile if hot
     let mut upper = [0u8; 16];
     let upper = &mut upper[..lookup_name.len()];
     for (dst, &src) in upper.iter_mut().zip(lookup_name) {
@@ -556,9 +545,8 @@ fn any_reply_append_all(
     response: JSValue,
     lookup_name: &'static [u8],
 ) -> JsResult<()> {
-    // PORT NOTE: Zig used `reply: anytype` + `@hasDecl(.., "toJSForAny")` to dispatch between
-    // `toJSForAny` (only `txt`) and `toJSResponse` (everything else). The caller now computes
-    // `response` and passes it in directly — see any_reply_to_js below.
+    // The caller computes `response` (via either `*_to_js_response` or, for txt,
+    // `txt_reply_to_js_for_any`) and passes it in directly — see any_reply_to_js below.
     if response.is_array() {
         let mut iterator = response.array_iterator(global_this)?;
         while let Some(item) = iterator.next()? {
@@ -574,9 +562,8 @@ pub(crate) fn any_reply_to_js(
     this: &mut c_ares::struct_any_reply,
     global_this: &JSGlobalObject,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: Zig used `inline for (@typeInfo(struct_any_reply).@"struct".fields)` to
-    // iterate every `*_reply` field. Rust has no struct reflection, so the field set is
-    // expanded manually here. Keep in lockstep with `c_ares::struct_any_reply`'s fields.
+    // The field set is expanded manually here. Keep in lockstep with
+    // `c_ares::struct_any_reply`'s fields.
     let len: usize = this.a_reply.is_some() as usize
         + this.aaaa_reply.is_some() as usize
         + (!this.mx_reply.is_null()) as usize
@@ -611,8 +598,8 @@ pub(crate) fn any_reply_to_js(
     }
     if !this.txt_reply.is_null() {
         // SAFETY: non-null c-ares-owned linked list head.
-        // PORT NOTE: txt is the only reply type whose Zig struct defines `toJSForAny`, so
-        // `anyReplyAppendAll`'s `@hasDecl(.., "toJSForAny")` branch dispatched to it.
+        // txt is the only reply type with the `to_js_for_any` shape (an `entries`
+        // wrapper object) instead of the plain `to_js_response` shape.
         let response =
             txt_reply_to_js_for_any(unsafe { &mut *this.txt_reply }, global_this, b"txt")?;
         any_reply_append_all(global_this, array, &mut i, response, b"txt")?;
@@ -707,8 +694,8 @@ impl ErrorDeferred {
             bstr::String::static_(b"DNSException").to_js(global_this)?,
         );
 
-        // `self` (and thus self.promise / self.hostname) drops at scope exit — matches
-        // Zig's `defer this.deinit()`; hostname was `take()`n above to avoid double-deref.
+        // `self` (and thus self.promise / self.hostname) drops at scope exit;
+        // hostname was `take()`n above to avoid double-deref.
         Ok(self.promise.reject(global_this, Ok(instance))?)
     }
 
@@ -720,7 +707,7 @@ impl ErrorDeferred {
             global_this: bun_ptr::BackRef<JSGlobalObject>,
         }
         impl Context {
-            // PORT NOTE: `bun_event_loop::ManagedTask::new` expects
+            // `bun_event_loop::ManagedTask::new` expects
             // `fn(*mut T) -> bun_event_loop::JsResult<()>` (low-tier `ErasedJsError`).
             fn callback(this: *mut Context) -> bun_event_loop::JsResult<()> {
                 // SAFETY: `this` is the heap-allocated pointer passed to ManagedTask::new
@@ -748,8 +735,8 @@ impl ErrorDeferred {
     }
 }
 
-// Drop: hostname (bun_core::String) and promise (JSPromiseStrong) drop their own resources.
-// Zig's deinit() additionally did `bun.destroy(this)` — handled by Box drop at the call site.
+// Drop: hostname (bun_core::String) and promise (JSPromiseStrong) drop their own resources;
+// the allocation itself is handled by Box drop at the call site.
 
 pub(crate) fn error_to_deferred(
     this: c_ares::Error,
@@ -818,8 +805,7 @@ pub(crate) fn error_to_js_with_syscall_and_hostname(
 }
 
 // ── canonicalizeIP host fn ─────────────────────────────────────────────────
-// Zig: `@export(&jsc.toJSHostFn(Bun__canonicalizeIP_), .{ .name = "Bun__canonicalizeIP" })`
-// — `#[bun_jsc::host_fn(export = ...)]` emits the C-ABI shim under that link name.
+// `#[bun_jsc::host_fn(export = ...)]` emits the C-ABI shim under that link name.
 #[bun_jsc::host_fn(export = "Bun__canonicalizeIP")]
 pub(crate) fn bun_canonicalize_ip(
     global_this: &JSGlobalObject,
@@ -853,5 +839,3 @@ pub(crate) fn bun_canonicalize_ip(
 
     bun_string_jsc::create_utf8_for_js(global_this, slice)
 }
-
-// ported from: src/runtime/dns_jsc/cares_jsc.zig
diff --git a/src/runtime/dns_jsc/dns.rs b/src/runtime/dns_jsc/dns.rs
index de0e10424e7..a5b5f4403b9 100644
--- a/src/runtime/dns_jsc/dns.rs
+++ b/src/runtime/dns_jsc/dns.rs
@@ -1,5 +1,4 @@
 //! DNS resolver — JSC bindings.
-//! Port of `src/runtime/dns_jsc/dns.zig`.
 
 use core::cell::Cell;
 use core::ffi::{c_char, c_int, c_void};
@@ -54,7 +53,7 @@ pub(crate) mod netc {
 pub(crate) mod netc {
     /// `AI_ADDRCONFIG` (`ws2def.h`). Only consulted when
     /// `BUN_FEATURE_FLAG_DISABLE_ADDRCONFIG` is set; default hints on Windows
-    /// leave `ai_flags = 0` (matches dns.zig — `addrconfig = is_posix`).
+    /// leave `ai_flags = 0`.
     pub(crate) use bun_dns::AI_ADDRCONFIG;
     pub(crate) use bun_libuv_sys::{
         addrinfo, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage,
@@ -207,7 +206,7 @@ pub(super) mod lib_info {
             return unsafe { (*dns_lookup).promise.value() };
         }
 
-        // PERF(port): was StackFallbackAllocator(1024) — profile if it shows up on a hot path.
+        // PERF: a stack-fallback buffer could avoid this heap allocation — profile if it shows up on a hot path.
         let name_z = bun::ZBox::from_bytes(query.name.as_ref());
 
         let request = GetAddrInfoRequest::init(
@@ -280,7 +279,6 @@ pub(super) mod lib_info {
             // TODO: WHAT?????????
             sys::Fd::from_native(i32::MAX - 1),
             Default::default(),
-            // TODO(port): FilePoll generic owner type GetAddrInfoRequest
             Async::Owner::new(
                 Async::posix_event_loop::poll_tag::GET_ADDR_INFO_REQUEST,
                 request.cast(),
@@ -295,7 +293,7 @@ pub(super) mod lib_info {
             unsafe { ctx.platform_event_loop() },
             Async::PollKind::Machport,
             Async::posix_event_loop::OneShotFlag::OneShot,
-            // bitcast u32 mach_port → i32 fd, matches Zig @bitCast
+            // bitcast u32 mach_port → i32 fd
             sys::Fd::from_native(machport as i32),
         );
         debug_assert!(matches!(rc, sys::Result::Ok(_)));
@@ -394,7 +392,7 @@ pub(super) mod lib_uv_backend {
 
         let holder = bun_core::heap::into_raw(Box::new(Holder {
             uv_info,
-            // Zig: `.task = undefined`. `AnyTask.callback` is a non-nullable
+            // `AnyTask.callback` is a non-nullable
             // `fn` pointer, so `MaybeUninit::zeroed().assume_init()` would be
             // instant UB regardless of the overwrite below; use the trapping
             // Default and overwrite in place.
@@ -420,7 +418,6 @@ pub(super) mod lib_uv_backend {
         query: GetAddrInfo,
         global_this: &JSGlobalObject,
     ) -> JsResult<JSValue> {
-        // TODO(port): narrow error set
         let key = get_addr_info_request::PendingCacheKey::init(&query);
 
         let cache =
@@ -570,20 +567,17 @@ impl CacheConfig {
 // ResolveInfoRequest<T> — generic c-ares record request (SRV/SOA/TXT/…)
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Trait standing in for Zig's `(comptime cares_type: type, comptime type_name: []const u8)` pair.
 /// Each c-ares reply struct implements this with its record-type tag.
-// TODO(port): proc-macro — Zig instantiated this per (type, "name") pair via comptime.
 pub trait CAresRecordType: Sized {
     const TYPE_NAME: &'static str;
-    /// `"query" ++ ucfirst(TYPE_NAME)` — Zig built this at comptime; each impl
-    /// carries the precomputed literal so error paths report the right syscall.
+    /// `"query" + ucfirst(TYPE_NAME)` — each impl carries the precomputed
+    /// literal so error paths report the right syscall.
     const SYSCALL: &'static str;
     /// `"pending_{TYPE_NAME}_cache_cares"` — used to reach the matching HiveArray on `Resolver`.
     const CACHE_FIELD: PendingCacheField;
-    /// `@field(NSType, "ns_t_" ++ TYPE_NAME)` — the DNS RR type passed to `ares_query`.
+    /// The DNS RR type passed to `ares_query`.
     const NS_TYPE: c_ares::NSType;
-    /// `cares_type.callbackWrapper(TYPE_NAME, ResolveInfoRequest(..), onCaresComplete)` —
-    /// the `ares_callback` thunk that parses raw reply bytes for this record type
+    /// The `ares_callback` thunk that parses raw reply bytes for this record type
     /// and forwards to `ResolveInfoRequest<Self>::on_cares_complete`. Used as
     /// `ResolveHandler::raw_callback` for the generic `Channel::resolve` dispatch.
     const RAW_CALLBACK: unsafe extern "C" fn(*mut c_void, c_int, c_int, *mut u8, c_int);
@@ -598,7 +592,7 @@ pub trait CAresRecordType: Sized {
 }
 
 pub struct ResolveInfoRequest<T: CAresRecordType> {
-    // TODO(port): lifetime — TSV says BORROW_PARAM → Option<&'a Resolver> (struct gets <'a>); raw ptr until reconciled with intrusive RC
+    // TODO: should be Option<&'a Resolver> (struct gets <'a>); raw ptr until reconciled with intrusive RC
     pub resolver_for_caching: Option<*mut Resolver>,
     pub hash: u64,
     pub cache: CacheConfig,
@@ -716,8 +710,7 @@ impl<T: CAresRecordType> ResolveInfoRequest<T> {
 
 // Wires `ResolveInfoRequest<T>` into `Channel::resolve` — the per-record
 // `T::RAW_CALLBACK` parses the raw DNS reply and calls back into
-// `on_cares_complete`. Zig: `channel.resolve(name, type_name, ResolveInfoRequest(..),
-// request, cares_type, onCaresComplete)`.
+// `on_cares_complete`.
 impl<T: CAresRecordType> c_ares::ResolveHandler for ResolveInfoRequest<T> {
     const LOOKUP_NAME: &'static [u8] = T::TYPE_NAME.as_bytes();
     const NS_TYPE: c_ares::NSType = T::NS_TYPE;
@@ -739,7 +732,7 @@ impl<T: CAresRecordType> c_ares::ResolveHandler for ResolveInfoRequest<T> {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct GetHostByAddrInfoRequest {
-    // TODO(port): lifetime — TSV says BORROW_PARAM → Option<&'a Resolver>; raw ptr for now
+    // TODO: should be Option<&'a Resolver>; raw ptr for now
     pub resolver_for_caching: Option<*mut Resolver>,
     pub hash: u64,
     pub cache: CacheConfig,
@@ -780,12 +773,13 @@ pub mod get_host_by_addr_info_request {
 }
 
 impl GetHostByAddrInfoRequest {
+    /// Reverse lookups always cache through `pending_addr_cache_cares`, so no
+    /// `cache_field` selector is needed (unlike `ResolveInfoRequest::<T>::init`).
     pub(crate) fn init(
         cache: LookupCacheHit<Self>,
         resolver: Option<*mut Resolver>,
         name: &[u8],
         global_this: &JSGlobalObject,
-        cache_field: PendingCacheField,
     ) -> *mut Self {
         let hash = wyhash(name);
         let mut poll_ref = KeepAlive::init();
@@ -821,8 +815,6 @@ impl GetHostByAddrInfoRequest {
                 (*new).lookup = request;
             }
         }
-        // TODO(port): cache_field is always "pending_addr_cache_cares" for this type
-        let _ = cache_field;
         request
     }
 
@@ -888,7 +880,7 @@ impl CAresNameInfo {
     /// SAFETY: `global_this` is a JSC_BORROW backref set at construction (both
     /// `init()` and the inline `head` of `GetNameInfoRequest::init()`) from a
     /// live `&JSGlobalObject`; never null, and the JSGlobalObject outlives every
-    /// in-flight DNS request (Zig spec: `*jsc.JSGlobalObject`, non-optional).
+    /// in-flight DNS request.
     #[inline]
     pub(crate) fn global_this(&self) -> &JSGlobalObject {
         self.global_this.get()
@@ -991,7 +983,7 @@ impl Drop for CAresNameInfo {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct GetNameInfoRequest {
-    // TODO(port): lifetime — TSV says BORROW_PARAM → Option<&'a Resolver>; raw ptr for now
+    // TODO: should be Option<&'a Resolver>; raw ptr for now
     pub resolver_for_caching: Option<*mut Resolver>,
     pub hash: u64,
     pub cache: CacheConfig,
@@ -1133,7 +1125,7 @@ impl c_ares::NameinfoHandler for GetNameInfoRequest {
 
 pub struct GetAddrInfoRequest {
     pub backend: get_addr_info_request::Backend,
-    // TODO(port): lifetime — TSV says BORROW_PARAM → Option<&'a Resolver>; raw ptr for now
+    // TODO: should be Option<&'a Resolver>; raw ptr for now
     pub resolver_for_caching: Option<*mut Resolver>,
     pub hash: u64,
     pub cache: CacheConfig,
@@ -1179,12 +1171,11 @@ pub mod get_addr_info_request {
     #[derive(Default)]
     pub struct BackendLibInfo {
         /// OWNED hive slot from `FilePoll::init` (returned via `FilePoll::deinit`,
-        /// not `Box`/global-alloc — Zig: `?*bun.Async.FilePoll`).
+        /// not `Box`/global-alloc).
         pub file_poll: Option<NonNull<FilePoll>>,
         pub machport: mach_port,
     }
 
-    // TODO(port): move to <area>_sys
     #[cfg(target_os = "macos")]
     unsafe extern "C" {
         fn getaddrinfo_send_reply(
@@ -1285,8 +1276,8 @@ pub mod get_addr_info_request {
                 return;
             }
 
-            // do not free addrinfo when err != 0
-            // https://github.com/ziglang/zig/pull/14242
+            // do not free addrinfo when err != 0: getaddrinfo only allocates the
+            // result list on success, so the out-pointer is unspecified on error.
             let _free = scopeguard::guard(addrinfo, |a| {
                 // SAFETY: `a` was returned by libc::getaddrinfo (non-null per the check above).
                 unsafe { bun_dns::freeaddrinfo(a) }
@@ -1398,7 +1389,7 @@ impl GetAddrInfoRequest {
                 next: None,
             },
             tail: ptr::null_mut(),
-            // Zig: `task: bun.ThreadPool.Task = undefined`. The callback is
+            // The callback is
             // overwritten before scheduling; use a trapping stub so the
             // non-null fn-pointer invariant holds without `mem::zeroed()` UB.
             task: thread_pool::Task {
@@ -1509,13 +1500,10 @@ impl GetAddrInfoRequest {
                 get_addr_info_request::Backend::Libc(
                     get_addr_info_request::LibcBackend::Success(result),
                 ) => {
-                    // `ResultAny` impls `Drop` (frees the list); Zig's `defer any.deinit()`
-                    // is the by-value drop at the end of whichever callee receives `any`.
+                    // `ResultAny` impls `Drop` (frees the list) — the by-value drop
+                    // at the end of whichever callee receives `any`.
                     let any = GetAddrInfoResultAny::List(result);
                     if let Some(resolver) = (*this).resolver_for_caching {
-                        // if (this.cache.entry_cache and result != null and result.?.node != null) {
-                        //     resolver.putEntryInCache(this.hash, this.cache.name_len, result.?);
-                        // }
                         if (*this).cache.pending_cache() {
                             (*resolver).drain_pending_host_native(
                                 (*this).cache.pos_in_pending(),
@@ -1565,9 +1553,6 @@ impl GetAddrInfoRequest {
         // `resolver` (if set) is the live intrusive-RC ctx stored at init time.
         unsafe {
             if let Some(resolver) = (*this).resolver_for_caching {
-                // if (this.cache.entry_cache and result != null and result.?.node != null) {
-                //     resolver.putEntryInCache(this.hash, this.cache.name_len, result.?);
-                // }
                 if (*this).cache.pending_cache() {
                     (*resolver).drain_pending_host_cares(
                         (*this).cache.pos_in_pending(),
@@ -1608,8 +1593,7 @@ impl GetAddrInfoRequest {
             // `uv__malloc`; that block must be released with `uv_freeaddrinfo`
             // (== `uv__free`). `GetAddrInfoResultAny::Addrinfo`'s `Drop` calls
             // `ws2_32!freeaddrinfo`, which is the wrong allocator here and
-            // would corrupt the heap. The Zig spec never frees it on this path
-            // (leak). Convert to an owned `List` immediately, free the libuv
+            // would corrupt the heap. Convert to an owned `List` immediately, free the libuv
             // buffer with the correct deallocator, and pass `List` downstream
             // so `ResultAny::Drop` never sees libuv-owned memory.
             let addrinfo = (*uv_info).addrinfo;
@@ -1649,9 +1633,7 @@ impl GetAddrInfoRequest {
     }
 }
 
-// Wires `GetAddrInfoRequest` into `Channel::get_addr_info`. Zig:
-// `channel.getAddrInfo(query.name, query.port, hints_buf, GetAddrInfoRequest,
-// request, GetAddrInfoRequest.onCaresComplete)`.
+// Wires `GetAddrInfoRequest` into `Channel::get_addr_info`.
 impl c_ares::AddrInfoHandler for GetAddrInfoRequest {
     fn on_addr_info(
         &mut self,
@@ -1687,9 +1669,8 @@ impl CAresReverse {
     ///
     /// SAFETY: `global_this` is a JSC_BORROW backref set from a live
     /// `&JSGlobalObject` in `init()` / `GetHostByAddrInfoRequest::init()`; the
-    /// global outlives every DNS request hung off of it (Zig spec:
-    /// `*jsc.JSGlobalObject`, non-optional), so the pointer is always non-null
-    /// and valid for the lifetime of `self`.
+    /// global outlives every DNS request hung off of it, so the pointer is
+    /// always non-null and valid for the lifetime of `self`.
     #[inline]
     pub(crate) fn global_this(&self) -> &JSGlobalObject {
         self.global_this.get()
@@ -1843,7 +1824,7 @@ impl<T: CAresRecordType> CAresLookup<T> {
     /// SAFETY: `global_this` is a JSC_BORROW backref set at construction (both
     /// `init()` and the inline `head` of `ResolveInfoRequest::init()`) from a
     /// live `&JSGlobalObject`; never null, and the JSGlobalObject outlives every
-    /// in-flight DNS request (Zig spec: `*jsc.JSGlobalObject`, non-optional).
+    /// in-flight DNS request.
     #[inline]
     pub(crate) fn global_this(&self) -> &JSGlobalObject {
         self.global_this.get()
@@ -1858,8 +1839,8 @@ impl<T: CAresRecordType> CAresLookup<T> {
         _timeout: i32,
         result: Option<*mut T>,
     ) {
-        // syscall = "query" + ucfirst(TYPE_NAME) — Zig built this at comptime;
-        // each `CAresRecordType` impl carries the precomputed literal.
+        // syscall = "query" + ucfirst(TYPE_NAME); each `CAresRecordType` impl
+        // carries the precomputed literal.
         let syscall = T::SYSCALL; // e.g. "querySrv"
         // This path is reached when the pending cache is full (`.disabled`),
         // so we own the c-ares result here. The cached path frees it in
@@ -2164,27 +2145,23 @@ impl Drop for GlobalData {
 pub mod internal {
     use super::*;
 
-    // PORTING.md §Global mutable state: lazy env-var memo. Zig comments it as
-    // "racy, but it's okay because the number won't be invalid, just stale" —
-    // that's exactly an `OnceLock<u32>` (idempotent init, safe concurrent read).
+    // PORTING.md §Global mutable state: lazy env-var memo — an `OnceLock<u32>`
+    // (idempotent init, safe concurrent read).
     static MAX_DNS_TIME_TO_LIVE_SECONDS: std::sync::OnceLock<u32> = std::sync::OnceLock::new();
 
     pub(crate) fn get_max_dns_time_to_live_seconds() -> u32 {
         *MAX_DNS_TIME_TO_LIVE_SECONDS.get_or_init(|| {
             let value = env_var::BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS.get();
-            // Zig default for BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS is 30.
             value.unwrap_or(30) as u32
         })
     }
 
     // ───────────── Request ─────────────
 
-    // PORT NOTE: Zig stored a borrowed `[:0]const u8` here and only allocated in
-    // `toOwned()`. We keep a raw borrow on the stack key (constructed in `init`) and
-    // allocate in `to_owned()` before storing on the heap `Request`.
-    // TODO(port): lifetime — model the borrow with `<'a>` once ZStr ownership is settled.
-    pub struct RequestKey {
-        pub host: Option<*const ZStr>, // BORROW until to_owned(); never freed via this field
+    // The stack key borrows the caller's host string; `to_owned()` copies
+    // before storing on the heap `Request`.
+    pub struct RequestKey<'a> {
+        pub host: Option<&'a ZStr>,
         /// Used for getaddrinfo() to avoid glibc UDP port 0 bug, but NOT included in hash
         pub port: u16,
         /// Hash of hostname only - DNS results are port-agnostic
@@ -2202,31 +2179,27 @@ pub mod internal {
         /// Cache-lookup equality: same hash *and* same hostname bytes. The hash
         /// (wyhash, fixed seed) is not collision resistant, so it is only a
         /// fast reject — never the sole match criterion.
-        fn matches(&self, other: &RequestKey) -> bool {
+        fn matches(&self, other: &RequestKey<'_>) -> bool {
             if self.hash != other.hash {
                 return false;
             }
             match (self.host.as_ref(), other.host) {
-                (Some(a), Some(b)) => {
-                    // SAFETY: `other.host` borrows the caller's NUL-terminated
-                    // slice, which outlives the lookup (see `RequestKey.host`).
-                    a.as_bytes() == unsafe { (*b).as_bytes() }
-                }
+                (Some(a), Some(b)) => a.as_bytes() == b.as_bytes(),
                 (None, None) => true,
                 _ => false,
             }
         }
     }
 
-    impl RequestKey {
-        pub fn init(name: Option<&ZStr>, port: u16) -> Self {
+    impl<'a> RequestKey<'a> {
+        pub fn init(name: Option<&'a ZStr>, port: u16) -> Self {
             let hash = if let Some(n) = name {
                 Self::generate_hash(n) // Don't include port
             } else {
                 0
             };
             Self {
-                host: name.map(std::ptr::from_ref::<ZStr>),
+                host: name,
                 hash,
                 port,
             }
@@ -2238,9 +2211,7 @@ pub mod internal {
 
         pub fn to_owned(&self) -> RequestKeyOwned {
             if let Some(host) = self.host {
-                // SAFETY: host borrows the caller's NUL-terminated slice for the stack key's lifetime.
-                let bytes = unsafe { (*host).as_bytes() };
-                let host_copy = bun::ZBox::from_bytes(bytes);
+                let host_copy = bun::ZBox::from_bytes(host.as_bytes());
                 RequestKeyOwned {
                     host: Some(host_copy),
                     hash: self.hash,
@@ -2256,8 +2227,8 @@ pub mod internal {
         }
     }
 
-    // Crosses FFI to usockets via `Bun__addrinfo_getRequestResult` — layout MUST match
-    // Zig's `extern struct { info: ?[*]ResultEntry, err: c_int }` (8-byte thin ptr).
+    // Crosses FFI to usockets via `Bun__addrinfo_getRequestResult` — layout MUST
+    // stay `{ info: ?*ResultEntry, err: c_int }` (8-byte thin ptr).
     #[repr(C)]
     pub struct RequestResult {
         pub info: Option<NonNull<ResultEntry>>, // thin ptr; head of intrusive `ai_next` chain
@@ -2273,7 +2244,6 @@ pub mod internal {
         pub machport: mach_port,
     }
 
-    // TODO(port): move to <area>_sys
     #[cfg(target_os = "macos")]
     unsafe extern "C" {
         fn getaddrinfo_send_reply(
@@ -2387,8 +2357,8 @@ pub mod internal {
 
     const MAX_ENTRIES: usize = 256;
 
-    /// The cache data guarded by `GLOBAL_CACHE`. The Zig code stored a `bun.Mutex`
-    /// adjacent to `cache`/`len`; in Rust the lock owns the data (PORTING.md §Concurrency).
+    /// The cache data guarded by `GLOBAL_CACHE`; the lock owns the data
+    /// (PORTING.md §Concurrency).
     pub(crate) struct GlobalCache {
         pub cache: [*mut Request; MAX_ENTRIES],
         pub len: usize,
@@ -2406,7 +2376,11 @@ pub mod internal {
             }
         }
 
-        fn get(&mut self, key: &RequestKey, timestamp_to_store: &mut u32) -> Option<*mut Request> {
+        fn get(
+            &mut self,
+            key: &RequestKey<'_>,
+            timestamp_to_store: &mut u32,
+        ) -> Option<*mut Request> {
             let mut len = self.len;
             let mut i: usize = 0;
             while i < len {
@@ -2440,7 +2414,7 @@ pub mod internal {
 
         fn is_nearly_full(&self) -> bool {
             // 80% full (value is kind of arbitrary)
-            // Caller already holds GLOBAL_CACHE; the Zig @atomicLoad was redundant.
+            // Caller already holds GLOBAL_CACHE; no atomic load needed.
             self.len * 5 >= self.cache.len() * 4
         }
 
@@ -2546,7 +2520,6 @@ pub mod internal {
         hints_copy
     }
 
-    // TODO(port): move to <area>_sys
     // `Request` is passed opaquely to usockets and round-tripped back into
     // Rust; the C side never dereferences fields, so layout is irrelevant.
     #[allow(improper_ctypes)]
@@ -2697,8 +2670,6 @@ pub mod internal {
                     };
                 }
             }
-            // PORT NOTE: Zig's inner `for ... else { break }` has no `break` in its body,
-            // so the else fires unconditionally — mirrored exactly.
             // the rest of the list is all one address family
             break 'outer;
         }
@@ -2858,10 +2829,9 @@ pub mod internal {
 
         let poll = FilePoll::init(
             crate::api::bun::process::event_loop_handle_to_ctx(loop_),
-            // bitcast u32 mach_port → i32 fd, matches Zig @bitCast
+            // bitcast u32 mach_port → i32 fd
             sys::Fd::from_native(machport as i32),
             Default::default(),
-            // TODO(port): FilePoll generic owner type InternalDNSRequest
             Async::Owner::new(Async::posix_event_loop::poll_tag::REQUEST, req.cast::<()>()),
         );
         // SAFETY: `poll` is a freshly-allocated hive slot; `loop_.r#loop()` is the live uws loop.
@@ -2955,7 +2925,7 @@ pub mod internal {
                         (*req).libinfo.machport = machport;
                         // SAFETY: file_poll was set in lookup_libinfo before the first callback fires.
                         let poll = (*req).libinfo.file_poll.unwrap().as_mut();
-                        // Zig: `@bitCast(machport)` — `as i32` is the same-width bitcast.
+                        // `as i32` is the same-width bitcast of the u32 mach port.
                         poll.fd = sys::Fd::from_native(machport as i32);
                         match poll.register(&mut *Loop::get(), Async::PollKind::Machport, true) {
                             sys::Result::Err(_) => {
@@ -3290,7 +3260,7 @@ pub mod internal {
         unsafe { std::ptr::from_mut::<RequestResult>((*req).result.as_mut().unwrap()) }
     }
 
-    // FFI exports — Zig used `@export` in a `comptime { }` block.
+    // FFI exports.
     #[unsafe(no_mangle)]
     pub(crate) extern "C" fn Bun__addrinfo_set(
         request: *mut Request,
@@ -3345,8 +3315,8 @@ pub use internal::Request as InternalDNSRequest;
 // Resolver — JSC-exposed `dns.Resolver` (m_ctx payload of JSDNSResolver)
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Field selector standing in for Zig's `comptime cache_field: []const u8` /
-/// `std.meta.FieldEnum(Resolver)` — Rust cannot index struct fields by name string.
+/// Field selector for the `pending_*` cache fields on `Resolver` — Rust
+/// cannot index struct fields by name string.
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum PendingCacheField {
     PendingHostCacheCares,
@@ -3368,8 +3338,7 @@ pub enum PendingCacheField {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// CAresRecordType impls — Zig instantiated `ResolveInfoRequest(cares_type, type_name)`
-// per (struct, "tag") pair via comptime; Rust models the (struct, tag) tuple as a
+// CAresRecordType impls — each (struct, tag) pair is modeled as a
 // trait impl. ns/ptr/cname share `struct_hostent` and a/aaaa share
 // `hostent_with_ttls`, so those get `#[repr(transparent)]` newtype wrappers to
 // keep the per-record monomorphizations (and pending caches) distinct.
@@ -3401,8 +3370,7 @@ macro_rules! impl_cares_record_type {
                 unsafe { c_ares::ares_free_data(this.cast::<core::ffi::c_void>()) }
             }
         }
-        // Generic reply handler — forwards to `on_cares_complete`. Zig
-        // monomorphized this via `cares_type.Callback(ResolveInfoRequest(..))`.
+        // Generic reply handler — forwards to `on_cares_complete`.
         impl c_ares::ReplyHandler<$ty> for ResolveInfoRequest<$ty> {
             fn on_reply(
                 &mut self,
@@ -3508,7 +3476,7 @@ impl c_ares::AnyHandler for ResolveInfoRequest<c_ares::struct_any_reply> {
     }
 }
 
-/// Transparent newtype over `struct_hostent` carrying the comptime `type_name` tag.
+/// Transparent newtype over `struct_hostent` carrying the per-record-type `type_name` tag.
 macro_rules! hostent_newtype {
     ($name:ident, $tag:literal, $syscall:literal, $field:ident, $ns_type:ident, $wrapper:ident) => {
         #[repr(transparent)]
@@ -3709,7 +3677,7 @@ pub struct Resolver {
 
 bun_event_loop::impl_timer_owner!(Resolver; from_timer_ptr => event_loop_timer);
 
-/// RAII owner for a scoped `Resolver` refcount bump (Zig: `this.ref(); defer this.deref();`).
+/// RAII owner for a scoped `Resolver` refcount bump.
 /// Constructed via [`Resolver::ref_scope`]; releases the ref on Drop.
 #[must_use = "dropping immediately releases the scoped ref"]
 struct ResolverRefGuard(*mut Resolver);
@@ -3737,8 +3705,8 @@ impl bun_ptr::RefCounted for Resolver {
 
 #[cfg(windows)]
 pub struct UvDnsPoll {
-    // BACKREF — Zig: `parent: *Resolver` (mutable). Stored mut because the poll
-    // callback hands it to `Resolver::deref`, which may write/free `*this`.
+    // BACKREF — stored mut because the poll callback hands it to
+    // `Resolver::deref`, which may write/free `*this`.
     pub parent: *mut Resolver,
     pub socket: c_ares::ares_socket_t,
     pub poll: libuv::uv_poll_t,
@@ -3772,8 +3740,8 @@ pub enum CacheHit {
 }
 
 pub enum LookupCacheHit<R: HasPendingCacheKey> {
-    // PORT NOTE: Zig's `LookupCacheHit(request_type)` referenced `request_type.PendingCacheKey`.
-    // We thread the request type via `R` and resolve `PendingCacheKey` through `HasPendingCacheKey`.
+    // The request type is threaded via `R`; `PendingCacheKey` resolves
+    // through `HasPendingCacheKey`.
     Inflight(*mut R::PendingCacheKey), // BORROW_FIELD
     New(*mut R::PendingCacheKey),      // BORROW_FIELD
     Disabled,
@@ -3787,13 +3755,12 @@ impl<R: HasPendingCacheKey> Clone for LookupCacheHit<R> {
 impl<R: HasPendingCacheKey> Copy for LookupCacheHit<R> {}
 
 /// Associates a request type with its `PendingCacheKey` and the matching `HiveArray`
-/// field on `Resolver`. Stands in for Zig's `request_type.PendingCacheKey` projection
-/// and `@field(resolver, comptime cache_name)` reflection.
+/// field on `Resolver`.
 pub trait HasPendingCacheKey {
     type PendingCacheKey;
 
-    /// Return `&mut @field(resolver, cache_name)` — the per-request-type pending HiveArray.
-    /// `field` is the runtime tag of the comptime field name (some request types are reachable
+    /// Return the per-request-type pending HiveArray field on `Resolver`.
+    /// `field` is the runtime tag selecting which field (some request types are reachable
     /// via more than one field, e.g. `pending_host_cache_{cares,native}`).
     ///
     /// R-2: takes `&Resolver` and projects `&mut` via the field's `JsCell`.
@@ -3924,7 +3891,7 @@ impl HasPendingCacheKey for GetNameInfoRequest {
 
 pub enum ChannelResult<'a> {
     Err(c_ares::Error),
-    Result(&'a mut c_ares::Channel), // BORROW_FIELD — returns this.channel.?
+    Result(&'a mut c_ares::Channel), // BORROW_FIELD — borrows the resolver's `channel` field
 }
 
 // Canonical enum + parser live in `bun_dns` (lower tier so `cli` can parse
@@ -4007,8 +3974,7 @@ impl Resolver {
     /// Takes a raw `*mut Self` (not `&self`) because the final deref must write
     /// through / deallocate `*this`; deriving a `*mut` from a `&self` borrow
     /// and writing through it is UB under Stacked/Tree Borrows. Matches the
-    /// Zig `RefCount.deref(*@This())` signature and the codebase pattern in
-    /// `bun_ptr::RefCount::deref(self_: *mut T)`.
+    /// codebase pattern in `bun_ptr::RefCount::deref(self_: *mut T)`.
     ///
     /// # Safety
     /// `this` must point to a live heap-allocated `Resolver` originating from
@@ -4020,9 +3986,9 @@ impl Resolver {
         unsafe { bun_ptr::RefCount::<Self>::deref(this) };
     }
 
-    /// RAII bracket: bump the intrusive refcount now, drop it on guard Drop.
-    /// Mirrors Zig's `this.ref(); defer this.deref();` so re-entrant c-ares
-    /// callbacks that release their own refs cannot free `*this` mid-call.
+    /// RAII bracket: bump the intrusive refcount now, drop it on guard Drop,
+    /// so re-entrant c-ares callbacks that release their own refs cannot free
+    /// `*this` mid-call.
     ///
     /// Captures a raw `*mut` (not `&self`) so the guard does not borrow the
     /// resolver — gives `deref` proper write provenance for the final
@@ -4104,7 +4070,7 @@ impl Resolver {
     // ───────────── timer / pending bookkeeping ─────────────
 
     pub fn check_timeouts(&self, now: &ElTimespec, vm: &VirtualMachine) {
-        // PORT NOTE: caller (`dispatch.rs::fire_timer`) hands us the event-loop's
+        // Caller (`dispatch.rs::fire_timer`) hands us the event-loop's
         // local `ElTimespec`; `add_timer` works in `bun_core::timespec`. Same
         // `{ sec: i64, nsec: i64 }` layout — convert field-by-field.
         let now = bun::timespec {
@@ -4118,7 +4084,7 @@ impl Resolver {
         // `&Resolver` from their stored ctx without aliasing UB.
         let deref_this = self.as_ctx_ptr();
         scopeguard::defer! {
-            // PORT NOTE (jsc/runtime crate cycle): low-tier `VirtualMachine.timer` is `()`;
+            // jsc/runtime crate cycle: low-tier `VirtualMachine.timer` is `()`;
             // resolve via the high-tier `RuntimeState` hook.
             let state = crate::jsc_hooks::runtime_state();
             // SAFETY: `state` is the boxed per-thread `RuntimeState`; single-threaded JS heap.
@@ -4148,7 +4114,8 @@ impl Resolver {
     }
 
     fn any_requests_pending(&self) -> bool {
-        // TODO(port): Zig used @typeInfo to iterate all `pending_*` fields.
+        // Rust has no field reflection; keep this list in sync with
+        // `Resolver`'s `pending_*` fields.
         macro_rules! check { ($($f:ident),*) => { $( if self.$f.get().used.find_first_set().is_some() { return true; } )* } }
         check!(
             pending_host_cache_cares,
@@ -4193,7 +4160,7 @@ impl Resolver {
             .copied()
             .unwrap_or_else(|| bun::timespec::now(bun::TimespecMockMode::AllowMockedTime));
         let next = now_ts.add_ms(1000);
-        // PORT NOTE: `EventLoopTimer.next` uses the event-loop crate's local
+        // `EventLoopTimer.next` uses the event-loop crate's local
         // `Timespec` (distinct from `bun_core::Timespec`); convert by field.
         self.event_loop_timer.with_mut(|t| {
             t.next = ElTimespec {
@@ -4262,8 +4229,7 @@ impl Resolver {
     }
 
     /// Dispatch to a typed ResolveInfoRequest cache by record type.
-    // PORT NOTE: Zig used `@field(this, "pending_{TYPE_NAME}_cache_cares")` with a comptime
-    // string. Each per-record cache is a distinct monomorphization of
+    // Each per-record cache is a distinct monomorphization of
     // `HiveArray<resolve_info_request::PendingCacheKey<_>, 32>`; `PendingCacheKey<T>` is
     // layout-identical for all `T` (only the `*mut ResolveInfoRequest<T>` payload's pointee
     // type differs), so reinterpreting the field reference at the caller's `T` is sound when
@@ -4352,7 +4318,6 @@ impl Resolver {
         // SAFETY: `self` is the live heap allocation; ref_scope keeps count > 0 across re-entrant callbacks.
         let _g = unsafe { Self::ref_scope(self.as_ctx_ptr()) };
 
-        // TODO(port): generic getKey over T::CACHE_FIELD
         let key = {
             let cache = self.pending_cache_for::<T>(T::CACHE_FIELD);
             // SAFETY: slot at `index` was alloc'd by `get_or_put_into_resolve_pending_cache`.
@@ -4463,7 +4428,6 @@ impl Resolver {
             drop(bun_core::heap::take(key.lookup));
 
             array.ensure_still_alive();
-            // std.c.addrinfo
 
             while let Some(value) = pending {
                 let new_global = (*value.as_ptr()).global_this();
@@ -4535,8 +4499,6 @@ impl Resolver {
                 array.ensure_still_alive();
             }
 
-            // std.c.addrinfo
-
             while let Some(value) = pending {
                 let new_global = (*value.as_ptr()).global_this();
                 pending = (*value.as_ptr()).next;
@@ -4687,8 +4649,8 @@ impl Resolver {
         key: &R::PendingCacheKey,
         field: PendingCacheField,
     ) -> LookupCacheHit<R> {
-        // PORT NOTE: Zig used `@field(this, field)` over a comptime string. We dispatch via
-        // `HasPendingCacheKey::pending_cache`; the body is identical across all `R`.
+        // Dispatch via `HasPendingCacheKey::pending_cache`; the body is
+        // identical across all `R`.
         let cache = R::pending_cache(self, field);
         let mut inflight_iter = cache.used.iter_set();
 
@@ -4856,8 +4818,7 @@ impl Resolver {
         {
             use libuv as uv;
             if !readable && !writable {
-                // cleanup — Zig: `fetchOrderedRemove`; our `remove` is the
-                // ordered, value-returning variant.
+                // cleanup — `remove` is the ordered, value-returning variant.
                 if let Some(entry) = self.polls.with_mut(|p| p.remove(&fd)) {
                     // SAFETY: `entry` is the heap `UvDnsPoll` we inserted below;
                     // libuv takes ownership of the handle until `on_close_uv`
@@ -4947,7 +4908,6 @@ impl Resolver {
             if !poll_entry.found_existing {
                 *poll_entry.value_ptr =
                     FilePoll::init(ctx, sys::Fd::from_native(fd), Default::default(), owner);
-                // TODO(port): FilePoll generic owner type Resolver
             }
 
             // SAFETY: `value_ptr` points at a slot just initialized above (or a
@@ -5029,7 +4989,6 @@ impl Resolver {
                 if record_type_str.length() == 0 {
                     break 'brk RecordType::DEFAULT;
                 }
-                // TODO(port): phf custom hasher — Zig used getWithEql with ZigString.eqlComptime
                 match RECORD_TYPE_MAP.get(record_type_str.to_slice(global_this).slice()) {
                     Some(r) => *r,
                     None => {
@@ -5149,13 +5108,8 @@ impl Resolver {
             return Ok(unsafe { (*cares_reverse).promise.value() });
         }
 
-        let request = GetHostByAddrInfoRequest::init(
-            cache,
-            Some(self.as_ctx_ptr()),
-            ip,
-            global_this,
-            PendingCacheField::PendingAddrCacheCares,
-        );
+        let request =
+            GetHostByAddrInfoRequest::init(cache, Some(self.as_ctx_ptr()), ip, global_this);
 
         // SAFETY: `request` just heap-allocated in `init()`; `tail` points at its inline `head`.
         let promise = unsafe { (*(*request).tail).promise.value() };
@@ -5295,7 +5249,7 @@ impl Resolver {
     }
 
     // ───────── per-record-type global+instance resolve fns ─────────
-    // These are mechanically identical; Zig had one per record type.
+    // These are mechanically identical across record types.
 }
 
 macro_rules! resolve_record_fn {
@@ -5412,7 +5366,6 @@ impl Resolver {
         c_ares::struct_any_reply,
         false
     );
-    // PORT NOTE: resolveTxt/resolveAny used arguments_old(1) in Zig; collapsed into the macro.
 
     pub fn do_resolve_cares<T: CAresRecordType>(
         &self,
@@ -5478,8 +5431,8 @@ impl Resolver {
             ChannelResult::Result(res) => res,
             ChannelResult::Err(err) => {
                 let syscall = bun_core::String::create_atom(&query.name);
-                // PORT NOTE: SystemError has no Default impl upstream; spell out
-                // the Zig field defaults (.empty strings, fd = c_int::MIN).
+                // SystemError has no Default impl upstream; spell out
+                // the field defaults (empty strings, fd = c_int::MIN).
                 let system_error = SystemError {
                     errno: -1,
                     code: bun_core::String::static_(err.code()),
@@ -5589,7 +5542,7 @@ impl Resolver {
 
             // size = strlen(buf+1) + 1
             let size = ip.len() + 1;
-            // PORT NOTE: `bun_core::ZigString` lacks `with_encoding`/`to_js` (those live
+            // `bun_core::ZigString` lacks `with_encoding`/`to_js` (those live
             // on `bun_jsc::zig_string::ZigString`). The formatted bytes here are pure
             // ASCII (IP address + optional port), so `with_encoding()` would be a no-op
             // anyway — borrow as a `bun_core::String` and hand to JS.
@@ -5714,8 +5667,8 @@ impl Resolver {
         value: JSValue,
     ) -> JsResult<c_int> {
         let str_ = value.to_slice(global_this)?;
-        // PORT NOTE: ZigStringSlice has no `into_owned_slice_z`; build the
-        // NUL-terminated buffer inline (Zig: `toOwnedSliceZ`).
+        // ZigStringSlice has no `into_owned_slice_z`; build the
+        // NUL-terminated buffer inline.
         let bytes = str_.slice();
         let mut slice = bytes.to_vec();
         slice.push(0);
@@ -5870,7 +5823,7 @@ impl Resolver {
         }
         // Link the list AFTER the Vec is fully populated (no reallocs past this point).
         for i in 1..entries.len() {
-            // PORT NOTE: reshaped for borrowck — raw ptr to avoid two &mut into entries.
+            // Reshaped for borrowck — raw ptr to avoid two &mut into entries.
             let next: *mut _ = &raw mut entries[i];
             entries[i - 1].next = next;
         }
@@ -6062,8 +6015,8 @@ impl Resolver {
         _frame: &CallFrame,
     ) -> JsResult<JSValue> {
         // SAFETY: bun_vm() returns a live VM pointer for the duration of the call.
-        // PORT NOTE: VirtualMachine.dns_result_order is `u8` upstream (see
-        // jsc/VirtualMachine.rs TODO(port)); cast through Order's repr(u8).
+        // `VirtualMachine.dns_result_order` is stored as a raw `u8` (the jsc
+        // crate cannot depend on this crate's `Order`); cast through Order's repr(u8).
         let raw = global_this.bun_vm().as_mut().dns_result_order;
         let order = match raw {
             4 => Order::Ipv4first,
@@ -6074,7 +6027,7 @@ impl Resolver {
     }
 }
 
-// ───────── JS host-fn FFI exports (Zig: comptime { @export(...) }) ─────────
+// ───────── JS host-fn FFI exports ─────────
 // The #[host_fn] attribute emits the JSC-ABI shim under the Rust function name;
 // re-export each under its `Bun__DNS__*` link name. Mirrors the proc-macro's
 // shim body (see `bun_jsc_macros::host_fn`, `HostFnKind::Free`).
@@ -6131,5 +6084,3 @@ export_host_fn!(
     Resolver::get_runtime_default_result_order_option,
     "JS2Zig___src_runtime_dns_jsc_dns_zig__Resolver_getRuntimeDefaultResultOrderOption"
 );
-
-// ported from: src/runtime/dns_jsc/dns.zig
diff --git a/src/runtime/dns_jsc/mod.rs b/src/runtime/dns_jsc/mod.rs
index 9c5b4c4929f..a843cb49fbb 100644
--- a/src/runtime/dns_jsc/mod.rs
+++ b/src/runtime/dns_jsc/mod.rs
@@ -1,6 +1,6 @@
 //! DNS resolver — JSC bindings (`node:dns`, `Bun.dns`).
 //!
-//! Port of `src/runtime/dns_jsc/dns.zig`. The full body — `Resolver` with the
+//! The full body — `Resolver` with the
 //! c-ares channel, all `resolve*`/`reverse`/`getServers`/`setServers` host
 //! functions, libinfo/libuv/system getaddrinfo backends, and the process-wide
 //! `internal` cache used by the usockets connect path — lives in `dns.rs`
@@ -19,7 +19,7 @@ pub mod cares_jsc; // c-ares reply struct → JSValue bridges
 pub mod options_jsc; // GetAddrInfo.Options ↔ JSValue
 
 // ─── public surface ──────────────────────────────────────────────────────────
-// `dns_body` is the real port of `dns.zig` (c-ares channel, request types,
+// `dns_body` is the real implementation (c-ares channel, request types,
 // Resolver method bodies, `internal` cache). The earlier erased "type-surface"
 // duplicates that lived here have been dissolved — there is one
 // `Resolver`, and `dispatch.rs`'s `from_field_ptr!`/`owner_as!` casts now resolve
diff --git a/src/runtime/dns_jsc/options_jsc.rs b/src/runtime/dns_jsc/options_jsc.rs
index 6cff36ec06d..9a498834499 100644
--- a/src/runtime/dns_jsc/options_jsc.rs
+++ b/src/runtime/dns_jsc/options_jsc.rs
@@ -10,10 +10,9 @@ use bun_dns::{
     PROTOCOL_MAP, Protocol, ResultAny, SOCKET_TYPE_MAP, SocketType,
 };
 use bun_dns::{addr_info_count, address_to_string};
-// PORT NOTE: Zig's `Options.FromJSError` is the error-set union of all the
-// per-field `Invalid*` variants plus `JSError`. The Rust enum lives in
-// `bun_dns` (which has no `bun_jsc` dep), so the `JsError → JSError` mapping is
-// done locally via the `js()` helper below.
+// `FromJSError` is the union of all the per-field `Invalid*` variants plus
+// `JSError`. The enum lives in `bun_dns` (which has no `bun_jsc` dep), so the
+// `JsError → JSError` mapping is done locally via the `js()` helper below.
 use bun_dns::OptionsFromJsError as FromJSError;
 
 #[inline]
@@ -56,9 +55,7 @@ pub(crate) fn options_from_js(
                 return Err(FromJSError::InvalidFlags);
             }
 
-            // TODO(port): Zig coerces to `std.c.AI` (packed struct of bools backed
-            // by c_int). Options.flags in Rust should be an `AIFlags` bitflags
-            // newtype; here we coerce to i32 and store/bit-test as u32.
+            // Coerce to i32 and store/bit-test as u32.
             let flags_int: i32 = js(flags.coerce::<i32>(global))?;
             options.flags = flags_int;
 
@@ -95,7 +92,7 @@ pub(crate) fn family_from_js(
     }
 
     if value.is_string() {
-        // PORT NOTE: `Family.map` is a `ComptimeStringMap` ported as
+        // `Family.map` is a `ComptimeStringMap` ported as
         // `bun_dns::FAMILY_MAP: phf::Map`; `.from_js` comes from
         // `bun_jsc::ComptimeStringMapExt`.
         return match js(FAMILY_MAP.from_js(global, value))? {
@@ -234,8 +231,6 @@ pub(crate) fn result_to_js(this: &GaiResult, global: &JSGlobalObject) -> JsResul
     obj.put(
         global,
         b"family",
-        // PORT NOTE: `this.address.any.family` — Zig's std.net.Address stores a
-        // sockaddr union under `.any` with a `.family` field. The Rust
         // `bun_sys::net::Address` exposes `.family() -> i32`.
         match this.address.family() {
             f if f == super::netc::AF_INET as _ => JSValue::js_number(4.0),
@@ -248,8 +243,7 @@ pub(crate) fn result_to_js(this: &GaiResult, global: &JSGlobalObject) -> JsResul
 }
 
 pub(crate) fn address_to_js(
-    // PORT NOTE: `*const std.net.Address` — `bun_dns::Address` is the
-    // `bun_sys::net::Address` sockaddr wrapper.
+    // `bun_dns::Address` is the `bun_sys::net::Address` sockaddr wrapper.
     address: &bun_dns::Address,
     global: &JSGlobalObject,
 ) -> JsResult<JSValue> {
@@ -277,14 +271,9 @@ pub(crate) fn addr_info_to_js_array(
                 array.put_index(global, j, result_to_js(&result, global)?)?;
                 j += 1;
             }
-            // Zig field name is `.next`; libc crate uses `ai_next`.
             current = this_node.ai_next;
         }
     }
 
     Ok(array)
 }
-
-// (unused import in Zig: `JSError = bun.JSError` — dropped)
-
-// ported from: src/runtime/dns_jsc/options_jsc.zig
diff --git a/src/runtime/ffi/FFIObject.rs b/src/runtime/ffi/FFIObject.rs
index 8180638f6c6..76756c17758 100644
--- a/src/runtime/ffi/FFIObject.rs
+++ b/src/runtime/ffi/FFIObject.rs
@@ -24,8 +24,7 @@ unsafe fn deallocator_from_addr(addr: usize) -> jsc::c::JSTypedArrayBytesDealloc
     unsafe { core::mem::transmute::<usize, jsc::c::JSTypedArrayBytesDeallocator>(addr) }
 }
 
-/// Port of Zig `JSValue.createBufferWithCtx(global, slice, ctx, callback)` —
-/// unlike `JSValue::create_buffer` (which hard-codes `MarkedArrayBuffer_deallocator`),
+/// Unlike `JSValue::create_buffer` (which hard-codes `MarkedArrayBuffer_deallocator`),
 /// this variant passes the caller's (possibly null) deallocator through, so FFI-owned
 /// memory is only freed by the user-supplied callback.
 #[allow(deprecated, non_snake_case)]
@@ -59,10 +58,6 @@ fn create_buffer_with_ctx(
 }
 
 // ── DOM-call C++ put helpers (generated in ZigLazyStaticFunctions-inlines.h) ──
-// In Zig these are `@extern`ed by the comptime `DOMCall(...)` type-generator;
-// here we declare them directly since the `#[bun_jsc::dom_call]` proc-macro is
-// not yet implemented.
-// TODO(port): move to <area>_sys
 #[allow(non_snake_case)]
 unsafe extern "C" {
     fn FFI__ptr__put(global: *mut JSGlobalObject, value: JSValue);
@@ -96,11 +91,9 @@ pub(crate) fn new_cstring(
     }
 }
 
-// TODO(port): `DOMCall("FFI", @This(), "ptr", ...)` is a comptime type-generator that
-// emits a DOMJIT fast-path descriptor + slow-path host fn. Needs a proc-macro
-// or codegen step (`bun_jsc::dom_call!`). Represented here as a const descriptor.
-// PORT NOTE: the `DOMEffect.forRead(.TypedArrayProperties)` argument is consumed by
-// the C++ codegen, not the runtime descriptor; it lives in the generated
+// DOMJIT fast-path descriptor + slow-path host fn, represented here as a const
+// descriptor. The `DOMEffect.forRead(.TypedArrayProperties)` argument is consumed
+// by the C++ codegen, not the runtime descriptor; it lives in the generated
 // `ZigLazyStaticFunctions-inlines.h` already.
 pub(crate) const DOM_CALL: DomCall = DomCall {
     class_name: "FFI",
@@ -109,9 +102,7 @@ pub(crate) const DOM_CALL: DomCall = DomCall {
 };
 
 pub fn to_js(global_object: &JSGlobalObject) -> JSValue {
-    // Zig: `inline for (comptime std.meta.fieldNames(@TypeOf(fields)))` — comptime
-    // reflection over an anonymous struct. Unrolled manually here; keep in sync with
-    // `FIELDS` below.
+    // Unrolled manually; keep in sync with `FIELDS` below.
     let fields = FIELDS();
     let object = JSValue::create_empty_object(global_object, fields.len() + 2);
 
@@ -152,11 +143,10 @@ pub fn to_js(global_object: &JSGlobalObject) -> JSValue {
 pub mod reader {
     use super::*;
 
-    // TODO(port): same DOMCall codegen note as `DOM_CALL` above. In Zig this is an
-    // anonymous struct of 12 `DOMCall(...)` values iterated via `inline for`.
-    // PORT NOTE: the `DOMEffect.forRead(.World)` argument is encoded on the C++ side
-    // (generated `Reader__*__put` in ZigLazyStaticFunctions-inlines.h); the runtime
-    // descriptor here only needs the `put` extern.
+    // Same DOMCall shape as `DOM_CALL` above. The
+    // `DOMEffect.forRead(.World)` argument is encoded on the C++ side
+    // (generated `Reader__*__put` in ZigLazyStaticFunctions-inlines.h); the
+    // runtime descriptor here only needs the `put` extern.
     pub(crate) const DOM_CALLS: &[(&str, DomCall)] = &[
         (
             "u8",
@@ -269,7 +259,6 @@ pub mod reader {
 
     #[inline(always)]
     fn addr_from_args(global_object: &JSGlobalObject, arguments: &[JSValue]) -> JsResult<usize> {
-        // PORT NOTE: hoisted from repeated inline checks; identical body in every reader.
         if arguments.is_empty() || !arguments[0].is_number() {
             return Err(global_object.throw_invalid_arguments(format_args!("Expected a pointer")));
         }
@@ -281,7 +270,7 @@ pub mod reader {
         Ok(arguments[0].as_ptr_address() + off)
     }
 
-    /// Read a `T` from a user-supplied raw address (unaligned, `*align(1)` in Zig).
+    /// Read a `T` from a user-supplied raw address (unaligned).
     ///
     /// Single audited primitive for all `bun:ffi` `read.*` host functions
     /// (slow-path and DOMJIT fast-path alike).
@@ -289,7 +278,7 @@ pub mod reader {
     /// # Safety
     /// `addr` must point to `size_of::<T>()` readable bytes. The address is
     /// JS-supplied and **not validated** — a bad value is UB, matching the
-    /// `bun:ffi` contract (`@as(*align(1) const T, @ptrFromInt(addr)).*`).
+    /// `bun:ffi` contract (an unaligned read of `T` at `addr`).
     #[inline(always)]
     pub(super) unsafe fn read_unaligned_at<T: Copy>(addr: usize) -> T {
         // SAFETY: precondition delegated to caller (see fn-level Safety doc).
@@ -417,10 +406,9 @@ pub mod reader {
         Ok(JSValue::from_uint64_no_truncate(global_object, value))
     }
 
-    // ── fast-path (DOMJIT, no type checks) readers ────────────────────────────
-    // These are `callconv(jsc.conv)` in Zig — called directly from JIT code.
-    // TODO(port): `#[bun_jsc::host_call]` emits the correct ABI ("sysv64" on
-    // win-x64, "C" elsewhere). Raw pointers are intentional (FFI boundary).
+    // The DOMJIT fast-path (no type checks) readers — called directly from
+    // JIT code — live on the C++ side (generated
+    // `ZigLazyStaticFunctions-inlines.h`); only the slow paths above are here.
 }
 
 pub(crate) fn ptr(global_this: &JSGlobalObject, _: JSValue, arguments: &[JSValue]) -> JSValue {
@@ -437,7 +425,6 @@ fn ptr_(global_this: &JSGlobalObject, value: JSValue, byte_offset: Option<JSValu
     }
 
     let Some(array_buffer) = value.as_array_buffer(global_this) else {
-        // PORT NOTE: `JSType` derives `Debug` only; Zig used `@tagName`.
         return global_this.to_invalid_arguments(format_args!(
             "Expected ArrayBufferView but received {:?}",
             value.js_type()
@@ -451,9 +438,6 @@ fn ptr_(global_this: &JSGlobalObject, value: JSValue, byte_offset: Option<JSValu
     }
 
     let mut addr: usize = array_buffer.ptr as usize;
-    // const Sizes = @import("../../jsc/sizes.zig");
-    // assert(addr == @intFromPtr(value.asEncoded().ptr) + Sizes.Bun_FFI_PointerOffsetToTypedArrayVector);
-
     if let Some(off) = byte_offset {
         if !off.is_empty_or_undefined_or_null() {
             if !off.is_number() {
@@ -499,8 +483,13 @@ fn ptr_(global_this: &JSGlobalObject, value: JSValue, byte_offset: Option<JSValu
 
 /// `union(enum)` → Rust enum.
 /// `Slice` carries a raw (ptr, len) because it points at caller-owned FFI memory
-/// of unknown lifetime — never freed by Rust.
-// TODO(port): lifetime — verify all consumers treat this as borrow-of-FFI-memory.
+/// of unknown lifetime.
+// Consumer audit: `new_cstring` copies the bytes into a JS string;
+// `to_array_buffer` wraps the pointer with the caller's optional finalizer and
+// never frees it from Rust; `to_buffer` does the same when a finalizer is
+// given, but WITHOUT one it falls back to `JSValue::create_buffer`, which
+// installs `MarkedArrayBuffer_deallocator` and `mi_free`s the caller-owned
+// slice on GC — free-foreign-memory footgun, see PR #31753.
 enum ValueOrError {
     Err(JSValue),
     Slice(*mut u8, usize),
@@ -525,12 +514,6 @@ fn get_ptr_slice(
         )));
     }
 
-    // if (!std.math.isFinite(num)) {
-    //     return .{ .err = globalThis.toInvalidArguments("ptr must be a finite number.", .{}) };
-    // }
-
-    // Zig: `@as(usize, @bitCast(num))` — `num` is already `usize` (asPtrAddress), so
-    // bitcast is a no-op. Preserved as identity assignment.
     let mut addr: usize = num;
 
     if let Some(byte_off) = byte_offset {
@@ -600,7 +583,7 @@ fn get_ptr_slice(
         }
     }
 
-    // Zig: `bun.span(@as([*:0]u8, @ptrFromInt(addr)))` — scan for NUL terminator.
+    // Scan for the NUL terminator.
     // SAFETY: caller asserts `addr` points at a NUL-terminated C string.
     let len = unsafe { bun_core::ffi::cstr(addr as *const core::ffi::c_char) }
         .to_bytes()
@@ -616,7 +599,6 @@ fn get_cptr(value: JSValue) -> Option<usize> {
             return Some(addr);
         }
     } else if value.is_big_int() {
-        // Zig: `@as(u64, @bitCast(value.toUInt64NoTruncate()))` — already u64; bitcast is no-op.
         let addr: u64 = value.to_uint64_no_truncate();
         if addr > 0 {
             return Some(addr as usize);
@@ -736,9 +718,8 @@ pub(crate) fn to_buffer(
                 ));
             }
 
-            // Spec (FFIObject.zig:596): `jsc.JSValue.createBuffer(globalThis, slice)`
-            // — installs `MarkedArrayBuffer_deallocator` so the slice is `mi_free`d
-            // on GC. Matches Zig exactly (including the free-foreign-memory footgun).
+            // `JSValue::create_buffer` installs `MarkedArrayBuffer_deallocator` so
+            // the slice is `mi_free`d on GC (including the free-foreign-memory footgun).
             Ok(JSValue::create_buffer(global_this, slice))
         }
     }
@@ -749,14 +730,9 @@ pub(crate) fn getter(global_object: &JSGlobalObject, _: &JSObject) -> JSValue {
 }
 
 // ── `fields` host-fn thunks ──────────────────────────────────────────────────
-// Zig `fields` is an anonymous struct of `jsc.host_fn.wrapStaticMethod(...)`
-// values iterated via comptime reflection in `toJS`. `wrapStaticMethod` is a
-// comptime fn-signature reflector that decodes `CallFrame` arguments into the
-// target's parameter types (see src/jsc/host_fn.zig:654). Rust has no
-// `@typeInfo`, so the eight wrappers are unrolled manually here — each body is
-// exactly what `wrapStaticMethod(.., auto_protect=false)` would emit for that
-// signature (only the `*JSGlobalObject` / `JSValue` / `?JSValue` / `ZigString`
-// arms are exercised by this table).
+// The eight wrappers are unrolled manually here; each decodes its `CallFrame`
+// arguments into the target's parameter types (only the `*JSGlobalObject` /
+// `JSValue` / `Option<JSValue>` / `ZigString` arms are exercised by this table).
 
 /// Minimal `ArgumentsSlice::nextEat` — pops the next non-consumed argument.
 /// `wrapStaticMethod`'s arena/protect machinery is unused for the FFI fields
@@ -776,7 +752,7 @@ fn eat_required(
     next_eat(iter).ok_or_else(|| global.throw_invalid_arguments(format_args!("Missing argument")))
 }
 
-/// `wrapStaticMethod` decode arm for `ZigString`.
+/// Decode arm for `ZigString` arguments.
 #[inline]
 fn eat_zig_string(
     global: &JSGlobalObject,
@@ -790,8 +766,8 @@ fn eat_zig_string(
     string_value.get_zig_string(global)
 }
 
-/// Wrap a `JsHostFnZig` body into the raw `JSHostFn` ABI — runtime half of
-/// Zig's `toJSHostFn`. Mints a fresh `unsafe extern jsc.conv fn` per call site
+/// Wrap a `JsHostFnZig` body into the raw `JSHostFn` ABI. Mints a fresh
+/// `unsafe extern jsc.conv fn` per call site
 /// so the address is usable in the static `FIELDS` table (Rust forbids
 /// fn-pointer const generics, so this is a `macro_rules!` rather than a
 /// generic fn). Uses `jsc_host_abi!` so the thunk gets `extern "sysv64"` on
@@ -814,7 +790,7 @@ macro_rules! wrap_host_fn {
 
 mod fields {
     use super::*;
-    // PORT NOTE: `print`/`callback`/`link_symbols`/`close_callback` live on
+    // `print`/`callback`/`link_symbols`/`close_callback` live on
     // `ffi_body::FFI` — not yet hoisted onto the canonical `crate::ffi::FFI`.
     // They are static (no `&self`), so type identity is irrelevant; route to
     // them directly until the two `FFI` structs merge.
@@ -908,7 +884,7 @@ mod fields {
 }
 
 // Represented here as a const slice of (name, JSHostFn) so `to_js` can iterate.
-// PORT NOTE: cannot be `const` — `wrap_host_fn!` expands to a block expression
+// Cannot be `const` — `wrap_host_fn!` expands to a block expression
 // (item + cast), which const-eval rejects in array-literal position. The slice
 // is tiny and only built once in `to_js`, so the runtime cost is nil.
 #[allow(non_snake_case)]
@@ -928,8 +904,5 @@ fn FIELDS() -> [(&'static str, jsc::JSHostFn); 8] {
 const MAX_ADDRESSABLE_MEMORY: usize = u56_max();
 
 const fn u56_max() -> usize {
-    // std.math.maxInt(u56)
     (1usize << 56) - 1
 }
-
-// ported from: src/runtime/ffi/FFIObject.zig
diff --git a/src/runtime/ffi/abi_type.rs b/src/runtime/ffi/abi_type.rs
index 5f3847605ed..331014028b6 100644
--- a/src/runtime/ffi/abi_type.rs
+++ b/src/runtime/ffi/abi_type.rs
@@ -1,7 +1,6 @@
 //! `ABIType` — the FFI C-type tag enum, its label table, and the C/JS
 //! source-code formatters. Single source of truth: must be kept in sync with
-//! `JSFFIFunction.h`. Ported once from `src/runtime/ffi/ffi.zig:2006`
-//! (`pub const ABIType = enum(i32) { ... }`).
+//! `JSFFIFunction.h`.
 
 use core::fmt;
 
@@ -69,7 +68,7 @@ pub enum ABIType {
     Buffer = 20,
 }
 
-/// Zig `ABIType.label` — string-to-tag lookup table for `args:`/`returns:`
+/// String-to-tag lookup table for `args:`/`returns:`
 /// option parsing. Associated `static` items aren't allowed in Rust, so the
 /// table lives at module scope and is re-exposed as `ABIType::LABEL` so callers
 /// can keep using `ABIType::LABEL.get(...)` (auto-deref handles the `&phf::Map`).
@@ -122,8 +121,7 @@ pub static ABI_TYPE_LABEL: phf::Map<&'static [u8], ABIType> = phf::phf_map! {
 // Per-variant string table — single source of truth for the four exhaustive
 // matches that previously lived in typename_label / param_typename_label /
 // ToCFormatter / ToJSFormatter. Indexed by `self as usize` (discriminants are
-// contiguous 0..=20). Zig has no equivalent table; this is a Rust-side
-// deduplication of ffi.zig:2145-2324.
+// contiguous 0..=20).
 // ─────────────────────────────────────────────────────────────────────────────
 
 struct AbiRow {
@@ -192,12 +190,7 @@ impl ABIType {
     /// See [`ABI_TYPE_LABEL`].
     pub const LABEL: &'static phf::Map<&'static [u8], ABIType> = &ABI_TYPE_LABEL;
 
-    // TODO(port): map_to_js_object — Zig builds a comptime "{...}" string from
-    // `map` via EnumMapFormatter. Rust cannot iterate phf at const time;
-    // generate via build.rs or const_format!.
-    pub const MAP_TO_JS_OBJECT: &'static str = "";
-
-    /// Zig `std.enums.fromInt(ABIType, int) orelse ...` — returns `None` for
+    /// Returns `None` for
     /// out-of-range discriminants. The enum is `#[repr(i32)]` with contiguous
     /// values `0..=MAX` plus `Buffer = 20`, so range-check then match.
     #[inline]
diff --git a/src/runtime/ffi/ffi_body.rs b/src/runtime/ffi/ffi_body.rs
index 624ef1017ad..5d8236321a5 100644
--- a/src/runtime/ffi/ffi_body.rs
+++ b/src/runtime/ffi/ffi_body.rs
@@ -66,15 +66,13 @@ fn strings_to_js_array(global: &JSGlobalObject, strs: &[bun_core::String]) -> Js
 
 // `bun_tcc_sys` is an un-gated workspace crate and a direct dep of
 // `bun_runtime`, so import it unconditionally. Runtime availability is governed
-// by `bun_core::Environment::ENABLE_TINYCC` (mirrors Zig
-// `Environment.enable_tinycc`) via the early-return guards in the host-fns
+// by `bun_core::Environment::ENABLE_TINYCC` via the early-return guards in the host-fns
 // below — type resolution for `TCC::{Config, ConfigErr, OutputFormat, State}`
 // must succeed regardless.
 use bun_tcc_sys as TCC;
 
 bun_output::declare_scope!(TCC, visible);
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn pthread_jit_write_protect_np(enable: c_int);
 }
@@ -97,7 +95,6 @@ fn dangerously_run_without_jit_protections<R>(func: impl FnOnce() -> R) -> R {
             unsafe { pthread_jit_write_protect_np(true as c_int) };
         }
     }
-    // PERF(port): was @call(bun.callmod_inline, ...) — profile if it shows up on a hot path.
     func()
 }
 
@@ -109,7 +106,6 @@ struct Offsets {
     js_cell_offset_of_type: u32,
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // Written once by C++ before any Rust read. C++ mutates these bytes, so a
     // plain non-`mut` extern static would assert immutability to the optimizer
@@ -134,7 +130,7 @@ unsafe extern "C" {
     ) -> JSValue;
 }
 
-/// `JSValue.exposed_to_ffi` (JSValue.zig:2467) — raw extern fn pointers fed to
+/// Raw extern fn pointers fed to
 /// the TCC-JIT'd C trampolines via `add_symbol`. Declared locally while the
 /// `bun_jsc::ffi` module stays gated.
 mod exposed_to_ffi {
@@ -220,7 +216,6 @@ impl Default for FFI {
 
 impl FFI {
     pub fn finalize(self: Box<Self>) {
-        // Zig spec (ffi.zig:69): `pub fn finalize(_: *FFI) callconv(.c) void {}` —
         // INTENTIONAL no-op when not closed. Compiled trampolines / dlopen'd
         // symbols may still be reachable from JS after the wrapper is GC'd
         // (e.g. `const { fn } = dlopen(...).symbols`); teardown is owned by
@@ -243,7 +238,7 @@ impl FFI {
 
 struct CompileC {
     source: Source,
-    current_file_for_errors: ZBox, // TODO(port): lifetime — Zig stored borrowed [:0]const u8
+    current_file_for_errors: ZBox,
     libraries: StringArray,
     library_dirs: StringArray,
     include_dirs: StringArray,
@@ -288,10 +283,8 @@ impl Source {
         state: &mut TCC::State,
         current_file_for_errors: &mut ZBox,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         match self {
             Source::File(file) => {
-                // TODO(port): Zig stored borrowed slice
                 *current_file_for_errors = ZBox::from_bytes(file.as_bytes());
                 state
                     .add_file(file)
@@ -317,7 +310,6 @@ impl Source {
 mod stdarg {
     use super::*;
 
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         pub(super) fn ffi_vfprintf(_: *mut c_void, _: *const c_char, ...) -> c_int;
         pub(super) fn ffi_vprintf(_: *const c_char, ...) -> c_int;
@@ -349,8 +341,7 @@ mod stdarg {
         // libc declares these as `FILE *__stdinp;` — `AtomicPtr<c_void>` is
         // `#[repr(C)]` over a single `*mut c_void`, so the extern layout is
         // identical. We never read them; we hand TinyCC the *address* of the
-        // global (matching Zig's `@extern(*anyopaque, .{ .name = "__stdinp" })`)
-        // so JIT'd code that references `__stdoutp` loads the FILE* from there.
+        // global so JIT'd code that references `__stdoutp` loads the FILE* from there.
         unsafe extern "C" {
             #[link_name = "__stdinp"]
             static FFI_STDINP: AtomicPtr<c_void>;
@@ -514,15 +505,13 @@ impl CompileC {
     fn get_system_root_dir_once() {
         #[cfg(target_os = "macos")]
         {
-            // Zig: `bun.spawnSync(&.{ argv = ["xcrun", "-sdk", "macosx",
-            // "-show-sdk-path"], stdout = .buffer, ... })` to auto-detect the
+            // Run `xcrun -sdk macosx -show-sdk-path` to auto-detect the
             // active SDK root. The Rust `bun::spawn_sync` helper isn't ported
             // yet (see install/repository.rs TODO), so use std::process as a
-            // shim — semantics match: inherit env, ignore stdin/stderr,
-            // capture stdout, treat any spawn/exit failure as "not found"
-            // (Zig: `catch return` / `if (process.result.isOK())`).
-            // `Command::new("xcrun")` does PATH lookup like `bun.which`, and
-            // /usr/bin is always in PATH on macOS, matching the Zig fallback.
+            // shim: inherit env, ignore stdin/stderr,
+            // capture stdout, treat any spawn/exit failure as "not found".
+            // `Command::new("xcrun")` does PATH lookup, and
+            // /usr/bin is always in PATH on macOS.
             #[allow(clippy::disallowed_types, clippy::disallowed_methods)]
             let out = match std::process::Command::new("xcrun")
                 .arg("-sdk")
@@ -540,7 +529,6 @@ impl CompileC {
             }
             use bstr::ByteSlice as _;
             let stdout = out.stdout.as_slice();
-            // Zig: `strings.trim(stdout, "\n\r")`
             let trimmed: &[u8] = stdout.trim_with(|c| c == '\n' || c == '\r');
             if trimmed.is_empty() {
                 return;
@@ -620,14 +608,14 @@ impl CompileC {
         &mut self,
         global_this: &JSGlobalObject,
     ) -> Result<NonNull<TCC::State>, bun_core::Error> {
-        // TODO(port): narrow error set (DeferredErrors | JSError | OutOfMemory | JSTerminated)
+        let tcc_options_owned: ZBox;
         let compile_options: &ZStr = if !self.flags.is_empty() {
             &self.flags
         } else if let Some(tcc_options) = env_var::BUN_TCC_OPTIONS.get() {
-            // TODO(port): @ptrCast from []const u8 to [:0]const u8 — env var must be NUL-terminated
-            // SAFETY: env vars are NUL-terminated by the OS; the slice points into
-            // the process env block, so a sentinel byte follows it.
-            unsafe { ZStr::from_raw(tcc_options.as_ptr(), tcc_options.len()) }
+            // Copy into an owned NUL-terminated buffer instead of assuming the
+            // OS env block provides a sentinel byte right after the slice.
+            tcc_options_owned = ZBox::from_bytes(tcc_options);
+            &tcc_options_owned
         } else {
             zstr!("-std=c11 -Wl,--export-all-symbols -g -O2")
         };
@@ -984,7 +972,7 @@ impl StringArray {
 // ─── FFI host functions ─────────────────────────────────────────────────────
 
 impl FFI {
-    // TODO(port): `#[bun_jsc::host_fn]` — the `Free` shim emits a bare
+    // No `#[bun_jsc::host_fn]` here — the `Free` shim it emits is a bare
     // `bun_ffi_cc(__g, __f)` call, which doesn't resolve inside `impl FFI`.
     // The C-ABI shim (`Bun__FFI__cc`) is supplied by the `.classes.ts` codegen.
     pub fn bun_ffi_cc(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
@@ -1212,7 +1200,7 @@ impl FFI {
 
         let obj = JSValue::create_empty_object(global_this, compile_c.symbols.map.len());
         for function in compile_c.symbols.map.values_mut() {
-            // PORT NOTE: clone the name before `compile(&mut self)` so the
+            // Clone the name before `compile(&mut self)` so the
             // immutable borrow of `function.base_name` doesn't overlap.
             let function_name = function.base_name.clone().unwrap();
 
@@ -1260,7 +1248,6 @@ impl FFI {
             functions: JsCell::new(core::mem::take(&mut compile_c.symbols.map)),
             closed: Cell::new(false),
         });
-        // PORT NOTE: reshaped for borrowck — Zig nulled tcc_state and symbols after move
 
         let js_object = lib.to_js(global_this);
         symbols_value_set_cached(js_object, global_this, obj);
@@ -1415,7 +1402,6 @@ impl FFI {
         }
         jsc::mark_binding();
         let mut strs: Vec<bun_core::String> = Vec::with_capacity(symbols.len());
-        // PERF(port): was initCapacity assume_capacity
         for function in symbols.values_mut() {
             let mut arraylist: Vec<u8> = Vec::new();
             if function.print_source_code(&mut arraylist).is_err() {
@@ -1423,7 +1409,6 @@ impl FFI {
                 return Ok(ZigString::init(b"Error while printing code").to_error_instance(global));
             }
             strs.push(bun_core::String::clone_utf8(&arraylist));
-            // PERF(port): was appendAssumeCapacity
         }
 
         let ret = strings_to_js_array(global, &strs)?;
@@ -1472,10 +1457,10 @@ impl FFI {
                 () => b"dylib",
                 #[cfg(windows)]
                 () => b"dll",
-                // TODO(port): wasm @compileError("TODO")
+                // No arm for other targets (e.g. wasm) — the match fails to
+                // compile there.
             };
-            // Spec `ffi.zig:1030` — `ModuleLoader.resolveEmbeddedFile(vm, buf,
-            // name_slice.slice(), ext)` extracts a bunfs-embedded shared
+            // Extract a bunfs-embedded shared
             // library (added via `import lib from "./lib.so" with { type:
             // "file" }` and shipped through `bun build --compile`) to a real
             // on-disk temp file, returning the tmpfile path; libc `dlopen(2)`
@@ -1487,7 +1472,7 @@ impl FFI {
                 ext,
                 &mut filepath_buf[..],
             ) {
-                // Spec `ffi.zig:1041` — NUL-terminate in place so `DynLib::open`
+                // NUL-terminate in place so `DynLib::open`
                 // can pass the slice to libc without copying. `resolve_*_to_buf`
                 // is bounded by `Fs::FileSystem::tmpname` + a tmpdir join (both
                 // fit in `PATH_MAX`), so `filepath_buf[len]` is in bounds.
@@ -1563,7 +1548,7 @@ impl FFI {
 
         for function in symbols.values_mut() {
             let function_name = ZBox::from_bytes(function.base_name.as_ref().unwrap().as_bytes());
-            // PORT NOTE: reshaped for borrowck — clone base_name to drop &function borrow
+            // Reshaped for borrowck — clone base_name to drop &function borrow
 
             // optional if the user passed "ptr"
             if function.symbol_from_dynamic_library.is_none() {
@@ -1757,10 +1742,9 @@ pub(super) fn generate_symbol_for_function(
 
             if val.is_any_int() {
                 let int = val.to_int32();
-                // Zig: `0...ABIType.max` — reject Buffer (20); only the string-label path accepts it.
+                // Reject Buffer (20); only the string-label path accepts it.
                 if let Some(t) = ABIType::from_int(int).filter(|_| int <= ABIType::MAX) {
                     abi_types.push(t);
-                    // PERF(port): was appendAssumeCapacity
                     continue;
                 } else {
                     return Ok(Some(
@@ -1784,7 +1768,6 @@ pub(super) fn generate_symbol_for_function(
                 )));
             };
             abi_types.push(abi);
-            // PERF(port): was appendAssumeCapacity
         }
     }
     // var function
@@ -1800,7 +1783,7 @@ pub(super) fn generate_symbol_for_function(
         if let Some(ret_value) = value.get_truthy(global, "returns")? {
             if ret_value.is_any_int() {
                 let int = ret_value.to_int32();
-                // Zig: `0...ABIType.max` — reject Buffer (20); only the string-label path accepts it.
+                // Reject Buffer (20); only the string-label path accepts it.
                 if let Some(t) = ABIType::from_int(int).filter(|_| int <= ABIType::MAX) {
                     return_type = t;
                     break 'brk;
@@ -1905,7 +1888,6 @@ pub(super) fn generate_symbols(
         function.base_name = Some(base_name);
 
         symbols.insert(&key, function);
-        // PERF(port): was putAssumeCapacity
     }
 
     Ok(None)
@@ -1939,7 +1921,6 @@ impl Default for Function {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn FFICallbackFunctionWrapper_destroy(_: *mut c_void);
 }
@@ -1972,7 +1953,6 @@ impl Function {
 
     fn fail(&mut self, msg: &'static [u8]) {
         if !matches!(self.step, Step::Failed { .. }) {
-            // PORT NOTE: @branchHint(.likely) — Rust has no statement-level hint; left as-is
             self.step = Step::Failed {
                 msg: Box::<[u8]>::from(msg),
                 allocated: false,
@@ -1981,7 +1961,6 @@ impl Function {
     }
 
     pub(crate) fn ffi_header() -> &'static [u8] {
-        // Port of `Function.ffiHeader` (ffi.zig:1517).
         bun_core::runtime_embed_file!(Src, "runtime/ffi/FFI.h").as_bytes()
     }
 
@@ -2019,7 +1998,6 @@ impl Function {
         &mut self,
         napi_env: Option<&napi::NapiEnv>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut source_code: Vec<u8> = Vec::new();
         self.print_source_code(&mut source_code)?;
 
@@ -2118,7 +2096,6 @@ impl Function {
         js_function: JSValue,
         is_threadsafe: bool,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         jsc::mark_binding();
         let mut source_code: Vec<u8> = Vec::new();
         // SAFETY: js_context/js_function are live for the call
@@ -2127,7 +2104,6 @@ impl Function {
 
         #[cfg(all(debug_assertions, unix))]
         'debug_write: {
-            // TODO(port): uses std.posix directly in Zig — keep raw libc here for parity
             // SAFETY: best-effort debug write; failures are swallowed
             unsafe {
                 let fd = libc::open(
@@ -2248,7 +2224,7 @@ impl Function {
         self.step = Step::Compiled(Compiled {
             ptr: symbol.as_ptr().cast::<c_void>(),
             js_function,
-            // SAFETY: opaque-handle storage only (Zig: `?*anyopaque`). Never
+            // SAFETY: opaque-handle storage only. Never
             // dereferenced or written through on the Rust side; stored as
             // NonNull to avoid laundering &T → *mut T provenance.
             js_context: Some(NonNull::from(js_context)),
@@ -2261,7 +2237,6 @@ impl Function {
         &self,
         writer: &mut impl std::io::Write,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if !self.arg_types.is_empty() {
             writer.write_all(b"#define HAS_ARGUMENTS\n")?;
         }
@@ -2419,7 +2394,6 @@ impl Function {
         context_ptr: Option<*mut c_void>,
         writer: &mut impl std::io::Write,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         {
             let ptr = global_object
                 .map(|g| std::ptr::from_ref(g) as usize)
@@ -2546,7 +2520,6 @@ impl Function {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn FFI_Callback_call(_: *mut c_void, _: usize, _: *mut JSValue) -> JSValue;
     fn FFI_Callback_call_0(_: *mut c_void, _: usize, _: *mut JSValue) -> JSValue;
@@ -2571,9 +2544,9 @@ pub enum Step {
 
 pub struct Compiled {
     pub ptr: *mut c_void,
-    // TODO(port): bare JSValue on heap — rooted via JSFFI.symbolsValue own: property; revisit Strong/JsRef.
+    // TODO: bare JSValue on heap — rooted via JSFFI.symbolsValue own: property; revisit Strong/JsRef.
     pub js_function: JSValue,
-    // Zig: `?*anyopaque` — opaque storage, never dereferenced. NonNull avoids
+    // Opaque storage, never dereferenced. NonNull avoids
     // a &T → *mut T cast at the assignment site in compile_callback().
     pub js_context: Option<NonNull<JSGlobalObject>>,
     pub ffi_callback_function_wrapper: Option<NonNull<c_void>>,
@@ -2627,7 +2600,6 @@ static CREATE_COMPILER_RT_DIR_ONCE: Once = Once::new();
 
 impl CompilerRT {
     fn create_compiler_rt_dir() {
-        // Spec ffi.zig:2340 — `Fs.FileSystem.instance.tmpdir() catch return`.
         // `bun_resolver::fs::FileSystem` (the inline canonical surface) doesn't
         // yet expose an inherent `tmpdir()`; reuse the crate-local
         // `FileSystemTmpdirExt` shim already in service for `jsc_hooks`.
@@ -2636,24 +2608,21 @@ impl CompilerRT {
             return;
         };
 
-        // Spec ffi.zig:2341 — `tmpdir.makeOpenPath("bun-cc", .{}) catch return`.
         let Ok(bun_cc) = tmpdir.make_open_path(b"bun-cc", bun_sys::OpenDirOptions::default())
         else {
             return;
         };
 
-        // Spec ffi.zig:2344-2350 — `inline for (decls) |d| bunCC.writeFile(d) catch {}`.
         for (name, source) in CompilerRtSources::SOURCES {
             let name_z = ZBox::from_bytes(name.as_bytes());
             let _ = bun_sys::File::write_file(bun_cc.fd(), name_z.as_zstr(), source);
         }
 
-        // Spec ffi.zig:2351-2352 — `getFdPath(bunCC) catch return`, then `dupeZ`.
         let mut path_buf = PathBuffer::uninit();
         let Ok(path) = bun_sys::get_fd_path(bun_cc.fd(), &mut path_buf) else {
             return;
         };
-        // `bun.handleOom(allocator.dupeZ(u8, path))` — `ZBox::from_bytes` panics on OOM.
+        // `ZBox::from_bytes` panics on OOM.
         let _ = COMPILER_RT_DIR.set(ZBox::from_bytes(&*path));
     }
 
@@ -2797,9 +2766,8 @@ static WORKAROUND: MyFunctionSStructWorkAround = MyFunctionSStructWorkAround {
 
 // ─── exports ────────────────────────────────────────────────────────────────
 
-/// `Bun__FFI__cc` — module-level re-export of `FFI::bun_ffi_cc`. Zig declared
-/// `pub const Bun__FFI__cc = FFI.Bun__FFI__cc;` at file scope so the
-/// `js2native` codegen could resolve it as `crate::ffi::ffi::bun__ffi__cc`.
+/// `Bun__FFI__cc` — module-level re-export of `FFI::bun_ffi_cc`, so the
+/// `js2native` codegen can resolve it as `crate::ffi::ffi::bun__ffi__cc`.
 #[allow(non_snake_case)]
 #[inline]
 pub fn bun__ffi__cc(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
@@ -2816,14 +2784,11 @@ fn make_napi_env_if_needed<'a>(
     // immediate-after `values_mut()` loop at every call site.
     for function in functions {
         if function.needs_napi_env() {
-            // TODO(port): lifetime — makeNapiEnvForFFI returns a heap-allocated env owned by VM
             // SAFETY: C++ returns a non-null fresh NapiEnv; we hand back a shared `&` only.
-            // PORT NOTE: `bun_jsc` exposes `*mut c_void` to avoid an upward dep on
+            // `bun_jsc` exposes `*mut c_void` to avoid an upward dep on
             // `bun_runtime::napi`; the concrete type lives here, so cast at the boundary.
             return Some(unsafe { &*global_this.make_napi_env_for_ffi().cast::<napi::NapiEnv>() });
         }
     }
     None
 }
-
-// ported from: src/runtime/ffi/ffi.zig
diff --git a/src/runtime/ffi/host_fns.rs b/src/runtime/ffi/host_fns.rs
index 9fb07530237..01e5142af37 100644
--- a/src/runtime/ffi/host_fns.rs
+++ b/src/runtime/ffi/host_fns.rs
@@ -32,12 +32,12 @@ unsafe extern "C" {
     ) -> JSValue;
 }
 
-/// `JSValue::getOwn` (JSValue.zig:1578) — own-property lookup. Local thin
+/// Own-property lookup. Local thin
 /// wrapper while `bun_jsc::JSValue::get_own` stays gated.
 #[inline]
 fn get_own(value: JSValue, global: &JSGlobalObject, key: &[u8]) -> JsResult<Option<JSValue>> {
     let key_str = bun_core::String::init(ZigString::init(key));
-    // Zig spec opens a `TopExceptionScope` before the FFI call (the C++ side has a
+    // Open a top exception scope before the FFI call (the C++ side has a
     // ThrowScope whose dtor sets `m_needExceptionCheck`); a post-hoc `has_exception()`
     // would assert under `BUN_JSC_validateExceptionChecks=1`.
     bun_jsc::top_scope!(scope, global);
@@ -51,7 +51,7 @@ fn get_own(value: JSValue, global: &JSGlobalObject, key: &[u8]) -> JsResult<Opti
 // Symbol-spec parsing — generate_symbols / generate_symbol_for_function
 // ══════════════════════════════════════════════════════════════════════════
 
-/// `FFI.generateSymbolForFunction` (FFI.zig:1518) — parse one
+/// Parse one
 /// `{ args, returns, threadsafe, ptr }` spec into a `Function`.
 pub fn generate_symbol_for_function(
     global: &JSGlobalObject,
@@ -80,10 +80,9 @@ pub fn generate_symbol_for_function(
 
             if val.is_any_int() {
                 let int = val.to_int32();
-                // Zig: `0...ABIType.max` — reject Buffer (20); only the string-label path accepts it.
+                // Reject Buffer (20); only the string-label path accepts it.
                 if let Some(t) = ABIType::from_int(int).filter(|_| int <= ABIType::MAX) {
                     abi_types.push(t);
-                    // PERF(port): was appendAssumeCapacity
                     continue;
                 } else {
                     return Ok(Some(
@@ -106,7 +105,6 @@ pub fn generate_symbol_for_function(
                 ))));
             };
             abi_types.push(abi);
-            // PERF(port): was appendAssumeCapacity
         }
     }
 
@@ -121,7 +119,7 @@ pub fn generate_symbol_for_function(
         if let Some(ret_value) = value.get_truthy(global, b"returns")? {
             if ret_value.is_any_int() {
                 let int = ret_value.to_int32();
-                // Zig: `0...ABIType.max` — reject Buffer (20); only the string-label path accepts it.
+                // Reject Buffer (20); only the string-label path accepts it.
                 if let Some(t) = ABIType::from_int(int).filter(|_| int <= ABIType::MAX) {
                     return_type = t;
                     break 'brk;
@@ -188,7 +186,7 @@ pub fn generate_symbol_for_function(
     Ok(None)
 }
 
-/// `FFI.generateSymbols` (FFI.zig:1662) — iterate own-properties of `object`,
+/// Iterate own-properties of `object`,
 /// parsing each value as a `Function` spec.
 pub fn generate_symbols(
     global: &JSGlobalObject,
@@ -230,7 +228,6 @@ pub fn generate_symbols(
         function.base_name = Some(base_name);
 
         symbols.insert(&key, function);
-        // PERF(port): was putAssumeCapacity
     }
 
     Ok(None)
@@ -241,7 +238,7 @@ pub fn generate_symbols(
 // ══════════════════════════════════════════════════════════════════════════
 
 impl Function {
-    /// `Function.printSourceCode` (FFI.zig:2007) — emit the C trampoline that
+    /// Emit the C trampoline that
     /// adapts a JSC host-call frame to the native symbol's ABI.
     pub fn print_source_code(
         &self,
@@ -391,7 +388,7 @@ impl Function {
         Ok(())
     }
 
-    /// `Function.printCallbackSourceCode` (FFI.zig:2170) — emit the C
+    /// Emit the C
     /// trampoline that adapts a native call into a JSC `FFI_Callback_call`.
     pub fn print_callback_source_code(
         &self,
@@ -505,5 +502,3 @@ impl Function {
         Ok(())
     }
 }
-
-// ported from: src/runtime/ffi/FFI.zig
diff --git a/src/runtime/ffi/mod.rs b/src/runtime/ffi/mod.rs
index 940a6a5695b..d6303c44f61 100644
--- a/src/runtime/ffi/mod.rs
+++ b/src/runtime/ffi/mod.rs
@@ -1,17 +1,15 @@
-//! Port of `src/runtime/ffi/FFI.zig` — `Bun.FFI` / `bun:ffi`.
+//! `Bun.FFI` / `bun:ffi`.
 //!
 //! `ABIType` (CType) enum, `FFI`/`Function`/`Step`/`Compiled` structs,
 //! formatters, dlopen data path, and the JSC host-fn entry points
-//! (`open`/`close`/`compile`/`generate_symbols`) are real. TinyCC compile
-//! bodies (`CompileC`, `Function::compile` relocate path) and the remaining
-//! host-fns (`cc`/`linkSymbols`/`callback`) stay gated on `bun_tcc_sys::State`
-//! API.
+//! (`open`/`close`/`compile`/`generate_symbols`) are real. The full TinyCC
+//! compile bodies (`CompileC`, `Function::compile`, `cc`/`linkSymbols`/
+//! `callback`) live in `ffi_body` on top of `bun_tcc_sys::State`.
 
 use core::ffi::{c_char, c_void};
 use core::ptr::NonNull;
 
-use bun_collections::StringArrayHashMap;
-use bun_core::{ZBox, ZStr};
+use bun_core::ZBox;
 
 use crate::jsc::{JSGlobalObject, JSValue};
 
@@ -19,14 +17,14 @@ use crate::jsc::{JSGlobalObject, JSValue};
 mod host_fns;
 pub use host_fns::{generate_symbol_for_function, generate_symbols};
 
-// ─── FFI.zig / FFIObject.zig port modules ────────────────────────────────────
+// ─── implementation modules ──────────────────────────────────────────────────
 
 #[path = "ffi_body.rs"]
-mod ffi_body; // port of FFI.zig
+mod ffi_body;
 
 /// `js2native` codegen resolves `$zig(ffi.zig, Bun__FFI__cc)` to
 /// `crate::ffi::ffi::bun__ffi__cc`; the module name maps the `.zig` basename.
-/// `FFI::bun_ffi_cc` lives in `ffi_body` (the full port) — re-export it under
+/// `FFI::bun_ffi_cc` lives in `ffi_body` — re-export it under
 /// the codegen-expected path so the dispatch table links without forcing the
 /// generator to special-case `ffi/ffi.zig`.
 pub mod ffi {
@@ -36,16 +34,16 @@ pub mod ffi {
 #[path = "FFIObject.rs"]
 pub mod ffi_object_draft;
 
-// TODO(port): bun_tcc_sys::State (compile/relocate/add_symbol/define_symbol)
-pub mod ffi_object {}
+// Canonical name (re-exported by `runtime::api`
+// as `FFIObject`); the module itself still lives under the draft name because
+// `api/BunObject.rs` references `crate::ffi::ffi_object_draft::getter`.
+pub use ffi_object_draft as ffi_object;
 
 // ─── DOMCall slowpath C-ABI exports ──────────────────────────────────────────
-// Zig: `host_fn.DOMCall(class, Container, fn, effect)` emits a `comptime
-// @export(&slowpath, .{ .name = class ++ "__" ++ fn ++ "__slowpath" })` where
-// `slowpath(global, this, args_ptr, args_len)` calls `toJSHostCall(global,
-// @src(), Container.fn, .{ global, this, args[0..len] })`. The bodies live in
-// `ffi_object_draft::reader::*` / `ffi_object_draft::ptr` (already ported);
-// these shims are the missing `@export` wrappers.
+// The C++ DOMJIT side expects a `<class>__<fn>__slowpath` export with
+// signature `slowpath(global, this, args_ptr, args_len)`. The bodies live in
+// `ffi_object_draft::reader::*` / `ffi_object_draft::ptr`;
+// these shims are the exported wrappers.
 mod dom_call_slowpath {
     use super::ffi_object_draft as ffi_object;
     use crate::jsc::{JSGlobalObject, JSValue};
@@ -106,37 +104,10 @@ mod dom_call_slowpath {
     }
 }
 
-// ─── TinyCC handle stub ──────────────────────────────────────────────────────
-// `bun_tcc_sys` currently exposes only an opaque marker; the method-ful
-// `State` (compile_string/relocate/add_symbol/…) is gated. Model the handle
-// as an opaque pointer so `Function`/`FFI` field shapes are real.
-#[allow(non_snake_case)]
-mod TCC {
-    bun_opaque::opaque_ffi! {
-        /// `TCCState*` — Nomicon opaque-FFI pattern.
-        pub struct State;
-    }
-    // Raw extern so the handle can be freed even while the method-ful
-    // `bun_tcc_sys::State` API stays gated. Keep this predicate in sync with
-    // `bun_tcc_sys::tcc_externs!` / `cfg.tinycc` in `scripts/build/config.ts`.
-    // TODO(port): move to <area>_sys
-    #[cfg(not(any(
-        target_os = "android",
-        target_os = "freebsd",
-        all(windows, target_arch = "aarch64")
-    )))]
-    unsafe extern "C" {
-        pub(super) fn tcc_delete(s: *mut State);
-    }
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        all(windows, target_arch = "aarch64")
-    ))]
-    pub(super) unsafe fn tcc_delete(_s: *mut State) {
-        unreachable!("tcc_delete: TinyCC not built on this target (cfg.tinycc = false)");
-    }
-}
+// `bun_tcc_sys` provides the method-ful `State` (compile_string/relocate/
+// add_symbol/…) with per-target link stubs where TinyCC isn't built — see
+// `tcc_externs!` in `src/tcc_sys/tcc.rs`.
+use bun_tcc_sys as TCC;
 
 /// Get the last dynamic-library loading error message in a cross-platform way.
 /// On POSIX systems, this calls `dlerror()`.
@@ -144,9 +115,8 @@ mod TCC {
 /// Returns an owned byte string (heap-copied since `dlerror()`'s storage is
 /// not stable across calls).
 ///
-/// Note: never fails — the Zig `![]const u8` was allocator-fallible only;
-/// `Vec` write! is infallible and the POSIX path is unconditional, so the
-/// `Result` wrapper has been dropped.
+/// Note: never fails — `Vec` write! is infallible and the POSIX path is
+/// unconditional.
 pub(crate) fn get_dl_error() -> Box<[u8]> {
     #[cfg(windows)]
     {
@@ -180,77 +150,9 @@ pub(crate) fn get_dl_error() -> Box<[u8]> {
 
 pub use ffi_body::FFI;
 
-// ─── CompileC ────────────────────────────────────────────────────────────────
-
-pub struct CompileC {
-    pub source: Source,
-    // TODO(port): lifetime — Zig stored borrowed [:0]const u8 into `source`
-    pub current_file_for_errors: &'static ZStr,
-    pub libraries: StringArray,
-    pub library_dirs: StringArray,
-    pub include_dirs: StringArray,
-    pub symbols: SymbolsMap,
-    pub define: Vec<[ZBox; 2]>,
-    /// Flags to replace the default flags
-    pub flags: Option<ZBox>,
-    pub deferred_errors: Vec<Box<[u8]>>,
-}
-
-impl Default for CompileC {
-    fn default() -> Self {
-        Self {
-            source: Source::File(ZBox::from_vec_with_nul(Vec::new())),
-            current_file_for_errors: ZStr::EMPTY,
-            libraries: StringArray::default(),
-            library_dirs: StringArray::default(),
-            include_dirs: StringArray::default(),
-            symbols: SymbolsMap::default(),
-            define: Vec::new(),
-            flags: None,
-            deferred_errors: Vec::new(),
-        }
-    }
-}
-
-pub enum Source {
-    File(ZBox),
-    Files(Vec<ZBox>),
-}
-
-impl Source {
-    pub fn first(&self) -> &ZStr {
-        match self {
-            Source::File(f) => f,
-            Source::Files(files) => files.first().map(|b| b.as_zstr()).unwrap_or(ZStr::EMPTY),
-        }
-    }
-}
-
-#[derive(thiserror::Error, strum::IntoStaticStr, Debug)]
-pub enum DeferredError {
-    #[error("DeferredErrors")]
-    DeferredErrors,
-}
-
-#[derive(Default)]
-pub struct SymbolsMap {
-    pub map: StringArrayHashMap<Function>,
-}
-
-#[derive(Default)]
-pub struct StringArray {
-    pub items: Vec<ZBox>,
-}
-
-impl Drop for StringArray {
-    fn drop(&mut self) {
-        for item in self.items.iter() {
-            // Attempting to free an empty null-terminated slice will crash if it was a default value
-            debug_assert!(!item.is_empty());
-        }
-        // Vec<ZBox> drops itself
-    }
-}
+// The full `CompileC`/`Source`/`SymbolsMap`/`StringArray`/`CompilerRT` port
+// lives in `ffi_body`; the draft duplicates that used to sit here were unused
+// and have been removed.
 
 // ─── Function ────────────────────────────────────────────────────────────────
 
@@ -285,7 +187,6 @@ impl Default for Function {
 // raw C-string pointer (no concurrent writers).
 pub static LIB_DIR_Z: bun_core::RacyCell<*const c_char> = bun_core::RacyCell::new(c"".as_ptr());
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn FFICallbackFunctionWrapper_destroy(_: *mut c_void);
 }
@@ -296,7 +197,7 @@ impl Drop for Function {
         if let Some(state) = self.state.take() {
             // SAFETY: `state` is the live TCCState* allocated for this Function's
             // trampoline; ownership is unique here (taken from self).
-            unsafe { TCC::tcc_delete(state.as_ptr()) };
+            unsafe { TCC::State::destroy(state.as_ptr()) };
         }
         if let Step::Compiled(compiled) = &mut self.step {
             if let Some(wrapper) = compiled.ffi_callback_function_wrapper.take() {
@@ -327,8 +228,9 @@ impl Function {
     }
 
     pub fn ffi_header() -> &'static [u8] {
-        // TODO(port): runtimeEmbedFile fallback when codegen_embed is off
-        include_bytes!("./FFI.h")
+        // Embedded under
+        // `codegen_embed`, reloaded from disk otherwise (dev fast iteration).
+        bun_core::runtime_embed_file!(Src, "runtime/ffi/FFI.h").as_bytes()
     }
 }
 
@@ -342,8 +244,9 @@ pub enum Step {
 
 pub struct Compiled {
     pub ptr: *mut c_void,
-    // TODO(port): bare JSValue on heap — rooted via JSFFI.symbolsValue own:
-    // property; revisit Strong/JsRef once bun_jsc lands
+    // Rooted via the JSFFI `symbolsValue` own-property on the wrapper object;
+    // never written on this draft path (only `ffi_body::Compiled` stores a
+    // live function value).
     pub js_function: JSValue,
     pub js_context: Option<*mut JSGlobalObject>,
     pub ffi_callback_function_wrapper: Option<NonNull<c_void>>,
@@ -374,45 +277,3 @@ impl Step {
 // ═════════════════════════════════════════════════════════════════════════════
 mod abi_type;
 pub use abi_type::{ABI_TYPE_LABEL, ABIType, EnumMapFormatter, ToCFormatter, ToJSFormatter};
-
-// ─── CompilerRT (pure C-ABI helpers + embedded sources) ──────────────────────
-
-pub struct CompilerRT;
-
-pub struct CompilerRtSources;
-impl CompilerRtSources {
-    pub const SOURCES: &'static [(&'static str, &'static [u8])] = &[
-        ("stdbool.h", include_bytes!("./ffi-stdbool.h")),
-        ("stdarg.h", include_bytes!("./ffi-stdarg.h")),
-        ("stdnoreturn.h", include_bytes!("./ffi-stdnoreturn.h")),
-        ("stdalign.h", include_bytes!("./ffi-stdalign.h")),
-        ("tgmath.h", include_bytes!("./ffi-tgmath.h")),
-        ("stddef.h", include_bytes!("./ffi-stddef.h")),
-        ("varargs.h", b"// empty"),
-    ];
-}
-
-impl CompilerRT {
-    /// # Safety
-    /// Caller (TCC-compiled code) guarantees `dest[0..byte_count]` is writable.
-    #[inline(never)]
-    pub unsafe extern "C" fn memset(dest: *mut u8, c: u8, byte_count: usize) {
-        // SAFETY: caller (TCC-compiled code) guarantees `dest[0..byte_count]` is writable.
-        unsafe { core::slice::from_raw_parts_mut(dest, byte_count) }.fill(c);
-    }
-
-    /// # Safety
-    /// Caller (TCC-compiled code) guarantees `dest[0..byte_count]` and
-    /// `source[0..byte_count]` are valid and non-overlapping.
-    #[inline(never)]
-    pub unsafe extern "C" fn memcpy(dest: *mut u8, source: *const u8, byte_count: usize) {
-        // SAFETY: caller (TCC-compiled code) guarantees `dest[0..byte_count]` and
-        // `source[0..byte_count]` are valid and non-overlapping.
-        unsafe {
-            core::slice::from_raw_parts_mut(dest, byte_count)
-                .copy_from_slice(core::slice::from_raw_parts(source, byte_count));
-        }
-    }
-}
-
-// ported from: src/runtime/ffi/FFI.zig
diff --git a/src/runtime/generated_classes.rs b/src/runtime/generated_classes.rs
index 1658c36d981..69979de0cd2 100644
--- a/src/runtime/generated_classes.rs
+++ b/src/runtime/generated_classes.rs
@@ -36,7 +36,7 @@
 
 // Bring BodyMixin into scope so codegen UFCS calls like
 // `Request::get_text(&mut *this, …)` / `Response::get_blob(…)` resolve to the
-// trait default methods (Zig: `BodyMixin(@This())` comptime mixin).
+// trait default methods.
 // NOTE: must be a named import — `as _` only covers `.method()` dot-call
 // resolution, not the `Type::method(…)` qualified-path form the codegen emits.
 use crate::webcore::body::BodyMixin;
diff --git a/src/runtime/hw_exports.rs b/src/runtime/hw_exports.rs
index 5ff629a24b3..dd343b1a658 100644
--- a/src/runtime/hw_exports.rs
+++ b/src/runtime/hw_exports.rs
@@ -1,8 +1,7 @@
-//! phase-d: handwritten Zig `@export` / `export fn` C-ABI symbols whose bodies
+//! phase-d: handwritten C-ABI export symbols whose bodies
 //! live in `bun_jsc::VirtualMachine` but whose link names must be emitted from
 //! a crate that *depends on* `bun_jsc` (so the bodies can call back into the
-//! real `VirtualMachine` struct without inverting the crate DAG). Each fn here
-//! is a 1:1 port of the corresponding `src/jsc/VirtualMachine.zig` body.
+//! real `VirtualMachine` struct without inverting the crate DAG).
 //!
 //! Symbols that already have a Rust `#[export_name]` / `#[no_mangle]` elsewhere
 //! are intentionally **not** re-declared here to avoid duplicate-symbol link
@@ -26,7 +25,7 @@ use core::ffi::c_void;
 use bun_jsc::virtual_machine::VirtualMachine;
 use bun_jsc::{CallFrame, JSGlobalObject, JSInternalPromise, JSValue, ZigStackFrame};
 
-// ─── VirtualMachine.zig ──────────────────────────────────────────────────────
+// ─── VirtualMachine ──────────────────────────────────────────────────────────
 //
 // `#[no_mangle] extern "C"` thunks for these are emitted by
 // `src/codegen/generate-host-exports.ts` into `generated_host_exports.rs`;
@@ -42,9 +41,8 @@ pub fn is_main_thread_vm() -> bool {
 /// `export fn Bun__drainMicrotasksFromJS(global, callframe) callconv(jsc.conv) JSValue`
 ///
 /// Returns plain `JSValue` (not `JsResult`) so the generated thunk is a bare
-/// deref+call with no `ExceptionValidationScope` — matching the .zig spec's
-/// bare `callconv(jsc.conv)` body and the prior `#[bun_jsc::host_call]`
-/// rewrite. `drain_microtasks()` runs arbitrary microtasks; wrapping in a
+/// deref+call with no `ExceptionValidationScope`.
+/// `drain_microtasks()` runs arbitrary microtasks; wrapping in a
 /// scope would trip `assert_exception_presence_matches(false)` if one left an
 /// exception pending while we return `UNDEFINED`.
 // HOST_EXPORT(Bun__drainMicrotasksFromJS)
@@ -109,7 +107,7 @@ pub fn set_override_module_run_main_promise(
     }
 }
 
-/// `@export(&setEntryPointEvalResultESM, .{ .name = "Bun__VM__setEntryPointEvalResultESM" })`
+/// Exported as `Bun__VM__setEntryPointEvalResultESM`.
 // HOST_EXPORT(Bun__VM__setEntryPointEvalResultESM, c)
 pub fn set_entry_point_eval_result_esm(this: &mut VirtualMachine, result: JSValue) {
     // allow esm evaluate to set value multiple times
@@ -121,7 +119,7 @@ pub fn set_entry_point_eval_result_esm(this: &mut VirtualMachine, result: JSValu
     }
 }
 
-/// `@export(&setEntryPointEvalResultCJS, .{ .name = "Bun__VM__setEntryPointEvalResultCJS" })`
+/// Exported as `Bun__VM__setEntryPointEvalResultCJS`.
 // HOST_EXPORT(Bun__VM__setEntryPointEvalResultCJS, c)
 pub fn set_entry_point_eval_result_cjs(this: &mut VirtualMachine, value: JSValue) {
     if !this.entry_point_result.value.has() {
@@ -133,13 +131,12 @@ pub fn set_entry_point_eval_result_cjs(this: &mut VirtualMachine, value: JSValue
     }
 }
 
-/// `@export(&specifierIsEvalEntryPoint, .{ .name = "Bun__VM__specifierIsEvalEntryPoint" })`
+/// Exported as `Bun__VM__specifierIsEvalEntryPoint`.
 // HOST_EXPORT(Bun__VM__specifierIsEvalEntryPoint, c)
 pub fn specifier_is_eval_entry_point(this: &mut VirtualMachine, specifier: JSValue) -> bool {
     if let Some(eval_source) = this.module_loader.eval_source.as_ref() {
         let global = this.global();
-        // Zig: `specifier.toBunString(this.global) catch @panic("unexpected exception")`
-        // followed by `defer specifier_str.deref()`. `bun_core::String` is
+        // `bun_core::String` is
         // `Copy` with NO `Drop`; `OwnedString` is the RAII wrapper that derefs.
         let specifier_str = bun_core::OwnedString::new(
             bun_jsc::bun_string_jsc::from_js(specifier, global).expect("unexpected exception"),
@@ -193,8 +190,7 @@ pub(crate) mod sql_hooks {
         // SAFETY: `heap` is `&runtime_state().timer` (live for the VM); `timer`
         // is a live intrusive heap node owned by the caller. Route through
         // `All::insert` (NOT the raw `.timers` field) so the lock is taken and
-        // `(*timer).state` / `in_heap` bookkeeping is updated — Zig spec is
-        // `vm.timer.insert(&this.timer)`.
+        // `(*timer).state` / `in_heap` bookkeeping is updated.
         unsafe { (*heap.cast::<crate::timer::All>()).insert(timer) };
     }
     unsafe fn timer_remove(heap: *mut c_void, timer: *mut EventLoopTimer) {
@@ -287,7 +283,7 @@ pub(crate) mod sql_hooks {
     };
 }
 
-// ─── bun.js.zig — entry-point promise reactions (used by `--print`) ──────────
+// ─── entry-point promise reactions (used by `--print`) ───────────────────────
 
 // HOST_EXPORT(Bun__onResolveEntryPointResult)
 pub fn on_resolve_entry_point_result(
@@ -295,9 +291,9 @@ pub fn on_resolve_entry_point_result(
     callframe: &CallFrame,
 ) -> bun_jsc::JsResult<JSValue> {
     let result = callframe.argument(0);
-    // SAFETY: `vals[..len]` is the single stack `result`; `ctype` may be null
-    // (the Zig path passes the per-VM ConsoleObject but only the writers are
-    // read off it, and `null` routes to the VM's stdout/stderr default).
+    // SAFETY: `vals[..len]` is the single stack `result`; `ctype` is ignored by
+    // `message_with_type_and_level` (it always resolves the per-VM console via
+    // `vm_console(global)`), so null is fine.
     unsafe {
         bun_jsc::ConsoleObject::message_with_type_and_level(
             core::ptr::null_mut(),
@@ -318,9 +314,9 @@ pub fn on_reject_entry_point_result(
     callframe: &CallFrame,
 ) -> bun_jsc::JsResult<JSValue> {
     let result = callframe.argument(0);
-    // SAFETY: `vals[..len]` is the single stack `result`; `ctype` may be null
-    // (the Zig path passes the per-VM ConsoleObject but only the writers are
-    // read off it, and `null` routes to the VM's stdout/stderr default).
+    // SAFETY: `vals[..len]` is the single stack `result`; `ctype` is ignored by
+    // `message_with_type_and_level` (it always resolves the per-VM console via
+    // `vm_console(global)`), so null is fine.
     unsafe {
         bun_jsc::ConsoleObject::message_with_type_and_level(
             core::ptr::null_mut(),
@@ -335,7 +331,7 @@ pub fn on_reject_entry_point_result(
     bun_core::Global::exit(u32::from(global.bun_vm().as_mut().exit_handler.exit_code));
 }
 
-// ─── bindgenv2 dispatch shims (GeneratedBindings.zig: `bindgen_*_dispatch*`) ─
+// ─── bindgenv2 dispatch shims (`bindgen_*_dispatch*`) ────────────────────────
 //
 // These satisfy the `extern "C"` refs C++ emits from
 // `Generated*Bindings.cpp`. Each forwards to the real Rust port of the named
@@ -371,12 +367,11 @@ pub fn bindgen_bunobject_dispatch_braces(
     arg_input: *const bun_core::String,
     arg_options: *const crate::api::bun_object::r#gen::BracesOptions,
 ) -> JSValue {
-    // SAFETY: `arg_input`/`arg_options` are valid C++ stack locals (see
-    // GeneratedBindings.zig:203 call site).
-    // Zig spec passes `arg_input.*` (bitwise copy of the ref-counted handle,
-    // **no** refcount bump). `bun_core::String` is `Copy` with no `Drop`, so
-    // a plain deref matches that exactly; `braces` only borrows the bytes via
-    // `to_utf8()` and never derefs the handle.
+    // SAFETY: `arg_input`/`arg_options` are valid C++ stack locals.
+    // The C++ caller retains ownership of the ref-counted handle — we take a
+    // bitwise copy with **no** refcount bump. `bun_core::String` is `Copy`
+    // with no `Drop`, so a plain deref does exactly that; `braces` only
+    // borrows the bytes via `to_utf8()` and never derefs the handle.
     let input = unsafe { *arg_input };
     // SAFETY: `arg_options` points to a `BracesOptions` on the C++ caller's stack.
     let opts = unsafe { *arg_options };
@@ -399,8 +394,7 @@ pub fn bindgen_bunobject_dispatch_gc(
 ) -> bool {
     // SAFETY: `arg_force`/`out` are valid C++ stack locals.
     let force = unsafe { *arg_force };
-    // Spec body (GeneratedBindings.zig:212 → BunObject.zig `gc`):
-    // `vm.garbageCollect(force)` — mimalloc cleanup, then sync `runGC(true)`
+    // `garbage_collect(force)`: mimalloc cleanup, then sync `runGC(true)`
     // when `force`, else `collectAsync()` + `heap.size()`.
     // SAFETY: bun_vm() never null for a Bun-owned global.
     unsafe { *out = global.bun_vm().as_mut().garbage_collect(force) };
@@ -408,7 +402,7 @@ pub fn bindgen_bunobject_dispatch_gc(
 }
 
 /// `fmt_jsc.js_bindings.fmtString(code, formatter) -> bun.String`
-/// (highlighter.test.ts internal — see `src/jsc/fmt_jsc.zig`).
+/// (highlighter.test.ts internal).
 ///
 /// # Safety
 /// `arg_code`, `arg_formatter`, and `out` must be valid C++ stack locals.
@@ -433,8 +427,7 @@ pub fn bindgen_fmt_jsc_dispatch_fmt_string(
             true
         }
         // OOM is the one `JsError` variant that does **not** leave a pending
-        // exception on the VM; the Zig spec explicitly throws here before
-        // signalling failure (`error.OutOfMemory => arg_global.throwOutOfMemory()`).
+        // exception on the VM; throw it explicitly before signalling failure.
         Err(bun_jsc::JsError::OutOfMemory) => {
             let _ = global.throw_out_of_memory();
             false
@@ -491,9 +484,9 @@ pub fn bindgen_bindgen_test_dispatch_add(
     }
 }
 
-/// `extern struct` mirror of the Zig codegen's optional-arg communication
-/// buffer (GeneratedBindings.zig:164). Field order is {b_set, d_set, d_value,
-/// b_value} — `extern struct` is declaration-ordered, NOT size-sorted.
+/// `#[repr(C)]` mirror of the bindgen optional-arg communication
+/// buffer. Field order is {b_set, d_set, d_value,
+/// b_value} — declaration-ordered, NOT size-sorted.
 #[repr(C)]
 pub(crate) struct BindgenTestRequiredAndOptionalArgArguments {
     pub b_set: bool,
@@ -696,7 +689,7 @@ pub fn bindgen_node_os_dispatch_set_priority2(
     )
 }
 
-// ─── js2native bindgen create-callback exports (GeneratedJS2Native.zig) ──────
+// ─── js2native bindgen create-callback exports (GeneratedJS2Native.h) ────────
 //
 // `js2native_bindgen_<ns>_<fn>` returns a freshly-minted `JSFunction` wrapping
 // the C++-side `bindgen_<ns>_js<Fn>` host fn. The C++ side already exports the
diff --git a/src/runtime/image/Image.classes.ts b/src/runtime/image/Image.classes.ts
index 3ee7809a0a8..1338eab1c6f 100644
--- a/src/runtime/image/Image.classes.ts
+++ b/src/runtime/image/Image.classes.ts
@@ -13,7 +13,7 @@ export default [
     estimatedSize: true,
     // Strong-ref slot for the input ArrayBuffer/TypedArray so we BORROW its
     // bytes instead of duping in the constructor. While a task is in flight
-    // the JSRef on the Zig side holds a Strong ref to this wrapper, the
+    // the JSRef on the native side holds a Strong ref to this wrapper, the
     // wrapper's sourceJS slot keeps the ArrayBuffer alive, and the buffer is
     // pinned for the task's duration — so the slice stays valid off-thread.
     // (No `hasPendingActivity` polling; the JSRef upgrade/downgrade is
@@ -52,7 +52,7 @@ export default [
       // Terminal async ops — run decode → pipeline → encode on the work pool.
       bytes: { fn: "doBytes", length: 0, async: true },
       buffer: { fn: "doBuffer", length: 0, async: true },
-      // Sharp-compat alias for `buffer()`; same Zig fn, no overhead.
+      // Sharp-compat alias for `buffer()`; same native fn, no overhead.
       toBuffer: { fn: "doBuffer", length: 0, async: true },
       // Encode → fs.writeFile, both off-thread; resolves bytes-written.
       write: { fn: "doWrite", length: 1, async: true },
diff --git a/src/runtime/image/Image.rs b/src/runtime/image/Image.rs
index a9c3f6a4cef..88c52a5988d 100644
--- a/src/runtime/image/Image.rs
+++ b/src/runtime/image/Image.rs
@@ -52,8 +52,7 @@ fn format_name(f: codecs::Format) -> &'static str {
 // provided by `#[bun_jsc::JsClass]` codegen (see PORTING.md §JSC types). The
 // `sourceJS` cached-value accessors are emitted by `generate-classes.ts` into
 // `generated_classes.rs::js_Image`; re-export that module here so callers use
-// `js::source_js_set_cached` / `js::source_js_get_cached` exactly as the Zig
-// did via `js.sourceJSSetCached`.
+// `js::source_js_set_cached` / `js::source_js_get_cached`.
 pub use crate::generated_classes::js_Image as js;
 
 // R-2 (host-fn re-entrancy): every JS-exposed method takes `&self`; per-field
@@ -122,10 +121,10 @@ pub enum Source {
     Blob(Strong),
 }
 
-// `Source::deinit` in Zig only frees owned fields — `Vec<u8>`, `ZString`, and
+// `Vec<u8>`, `ZString`, and
 // `Strong` all implement `Drop`, so no explicit `Drop` body is needed.
 
-// Faithful port of `Image.zig`'s local externs — these C++ helpers are
+// These C++ helpers are
 // Image-specific (they pin/adopt typed-array storage for the off-thread
 // pipeline) and have no `bun_jsc` wrapper.
 unsafe extern "C" {
@@ -232,7 +231,7 @@ impl Default for Modulate {
 /// so the clamp stays in float space.
 ///
 /// Rust `as` already saturates on overflow/NaN, but we keep the explicit
-/// clamp so behaviour matches Zig exactly (NaN → `lo`, not 0).
+/// clamp so NaN maps to `lo`, not 0.
 macro_rules! coerce_int {
     ($T:ty, $x:expr, $lo:expr, $hi:expr) => {{
         let x: f64 = $x;
@@ -254,7 +253,7 @@ const MAX_INPUT_FILE_BYTES: u64 = 256 << 20;
 // ───────────────────────────── lifecycle ────────────────────────────────────
 
 impl Image {
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — `#[bun_jsc::JsClass]` on the
+    // No `#[bun_jsc::host_fn]` here — `#[bun_jsc::JsClass]` on the
     // struct emits the constructor C-ABI shim; the bare attribute would expand
     // to a free-fn call (`constructor(__g, __f)`) that can't resolve in `impl`.
     pub fn constructor(
@@ -675,16 +674,15 @@ impl Image {
     /// the ArrayBuffer's vector each call so a detach between construction and
     /// here surfaces as `None` instead of UAF). For off-thread, see `pin_for_task`.
     fn js_thread_bytes(&self, this_value: JSValue, global: &JSGlobalObject) -> Option<&[u8]> {
-        // TODO(port): lifetime — JsBuffer arm returns a borrow into the JS heap,
-        // not into `self`; may need a different return type.
         match self.source.get() {
             Source::JsBuffer => js::source_js_get_cached(this_value)
                 .and_then(|v: JSValue| v.as_array_buffer(global))
                 .map(|ab| {
                     // SAFETY: `ArrayBuffer` is a view struct (ptr+len); the
-                    // bytes live in the JS heap, not in `ab`. `this_value`
-                    // keeps the buffer alive for this JS-thread call — see fn
-                    // doc + TODO(port) above re: borrow-into-JS-heap.
+                    // bytes live in the JS heap, not in `ab` — the returned
+                    // slice borrows the JS heap with `&self`'s lifetime, which
+                    // is sound only on the JS thread. `this_value` keeps the
+                    // buffer alive for this JS-thread call — see fn doc above.
                     unsafe { &*std::ptr::from_ref::<[u8]>(ab.byte_slice()) }
                 }),
             Source::Owned(b) => Some(b.as_slice()),
@@ -699,8 +697,8 @@ impl Image {
     /// nobody mutates a buffer they just handed to a decoder. The contract is
     /// documented and `.shared`/`.resizable` are refused at construction. The
     /// codec layer is hardened so a hostile mid-decode mutation degrades to
-    /// `DecodeFailed`, not OOB/heap-leak — see `codec_jpeg.zig` cropping +
-    /// post-check, `codec_webp.zig` dim re-check. (If the attacker already runs
+    /// `DecodeFailed`, not OOB/heap-leak — see `codec_jpeg.rs` cropping +
+    /// post-check, `codec_webp.rs` dim re-check. (If the attacker already runs
     /// JS in-process the threat model is moot anyway; the surface that matters
     /// is hostile *bytes*, which the codec validation handles.)
     fn pin_for_task(
@@ -786,18 +784,18 @@ impl Image {
 
 // ───────────────────────── static `Bun.Image.backend` ───────────────────────
 //
-// PORT NOTE: `#[bun_jsc::host_fn(getter|setter)]` expands to a `Self`-taking
+// `#[bun_jsc::host_fn(getter|setter)]` expands to a `Self`-taking
 // shim, but these are *static* class accessors (no receiver). The C-ABI shim
 // is emitted by `.classes.ts` codegen (`generated_classes.rs`) and calls them
 // as `Image::<fn>(…)`, so they live in an inherent `impl` with the codegen's
 // exact arity — including the trailing opaque `PropertyName` it threads
-// through but Zig's `getBackend` ignores.
+// through but `get_backend` ignores.
 
 impl Image {
     pub fn get_backend(global: &JSGlobalObject, _: JSValue, _: PropertyName) -> JsResult<JSValue> {
         // `BACKEND` only ever stores a valid `Backend as u8` discriminant
         // (`set_backend` round-trips through `Backend`); any other value is
-        // corruption — trap (matches Zig's safety-checked `@enumFromInt`).
+        // corruption — trap.
         let b = match codecs::BACKEND.load(core::sync::atomic::Ordering::Relaxed) {
             0 => codecs::Backend::System,
             1 => codecs::Backend::Bun,
@@ -833,7 +831,7 @@ impl Image {
     // layer.
 
     pub fn from_clipboard(global: &JSGlobalObject, _: &CallFrame) -> JsResult<JSValue> {
-        // `comptime codecs.system_backend` → cfg-gated module re-export.
+        // `codecs::system_backend` is a cfg-gated module re-export.
         #[cfg(any(target_os = "macos", windows))]
         {
             use codecs::system_backend;
@@ -1182,11 +1180,11 @@ impl Image {
                 return Err(global.throw(format_args!("Image: source ArrayBuffer was detached")));
             }
         };
-        // PORT NOTE: Zig `defer input.release()` is hoisted below — `input`
+        // The `input` release is hoisted below — `input`
         // moves into `task`, and `run()` is sync with no early returns, so we
         // release via `task.input` after the result is extracted.
-        // PORT NOTE: Zig never calls `PipelineTask.deinit()` on this stack
-        // temporary (only `then()` does — Image.zig:1092). `Drop` here would
+        // Cleanup must not run on this stack
+        // temporary (only `then()` does it). `Drop` here would
         // underflow `pending_tasks` and downgrade `this_ref`, so suppress it.
         let mut task = mem::ManuallyDrop::new(PipelineTask {
             image: std::ptr::from_ref::<Image>(self),
@@ -1200,13 +1198,13 @@ impl Image {
             result: TaskResult::Err(codecs::Error::DecodeFailed),
         });
         task.run();
-        // PORT NOTE: reshaped for borrowck — move `result` out via `replace`
+        // Reshaped for borrowck — move `result` out via `replace`
         // since `task` is behind `ManuallyDrop` deref.
         let result = mem::replace(
             &mut task.result,
             TaskResult::Err(codecs::Error::DecodeFailed),
         );
-        // Zig `defer input.release()` (see PORT NOTE above).
+        // Release `input` (see hoisting note above).
         mem::take(&mut task.input).release();
         match result {
             TaskResult::Encoded { out, format, w, h } => {
@@ -1339,7 +1337,7 @@ impl<'a> BlobReadChain<'a> {
                 let inner = match image.schedule(global, this_value, kind, deliver) {
                     Ok(v) => v,
                     Err(_) => {
-                        // PORT NOTE: `deliver` was moved into `schedule()`; on
+                        // `deliver` was moved into `schedule()`; on
                         // error it has already been dropped there.
                         let _ = outer.reject(
                             global,
@@ -1365,7 +1363,7 @@ impl<'a> ReadBytesHandler for BlobReadChain<'a> {
         // SAFETY: `self` is the `&mut *heap::alloc(chain)` handed to
         // `read_bytes_to_handler` in `start()`; we are the sole consumer on
         // the JS thread. Reconstruct the Box so the body can move fields out
-        // and free the allocation (mirrors Zig `bun.destroy(self)`).
+        // and free the allocation.
         let boxed = unsafe { bun_core::heap::take(std::ptr::from_mut::<Self>(self)) };
         boxed.on_read_bytes_impl(result);
     }
@@ -1405,7 +1403,8 @@ pub struct Input {
     // Borrows pinned ArrayBuffer or `image.source.owned`; the owning `Image`
     // is held via BACKREF for the task's lifetime — `RawSlice` invariant.
     bytes: bun_ptr::RawSlice<u8>,
-    // TODO(port): lifetime — borrows `image.source.path` (NUL-terminated).
+    // Borrows `image.source.path` (NUL-terminated); the owning `Image` is
+    // held via BACKREF for the task's lifetime, same as `bytes` above.
     path: Option<*const ZStr>,
     /// JS value to `unpinArrayBuffer` in `then()`. `.zero` for sources
     /// with no ArrayBuffer to pin (Oversize TA, owned, path, copied).
@@ -1469,7 +1468,6 @@ pub enum Kind {
     Placeholder,
 }
 
-// PORT NOTE: renamed from `Result` to avoid shadowing `core::result::Result`.
 pub enum TaskResult {
     Encoded {
         out: codecs::Encoded,
@@ -1710,7 +1708,7 @@ impl<'a> PipelineTask<'a> {
         // dispatch (`run_from_js` → `destroy`), immediately after this returns.
         // JS thread again — release the per-task pin so user code can
         // transfer/detach the source now.
-        // PORT NOTE: reshaped for borrowck — `PipelineTask: Drop` forbids
+        // Reshaped for borrowck — `PipelineTask: Drop` forbids
         // moving fields out by destructure; `mem::take`/`mem::replace` the
         // owning fields into locals instead so `Drop` still runs on the husk.
         mem::take(&mut self.input).release();
@@ -1727,7 +1725,7 @@ impl<'a> PipelineTask<'a> {
             }
             _ => {}
         }
-        // PORT NOTE: `Drop` forbids moving out of `self.result`; swap in a
+        // `Drop` forbids moving out of `self.result`; swap in a
         // throwaway sentinel (`Err` is `Copy`) and match the owned local.
         let result = mem::replace(
             &mut self.result,
@@ -1794,7 +1792,6 @@ impl<'a> PipelineTask<'a> {
                         promise.resolve(global, <Blob as bun_jsc::JsClass>::to_js(blob, global))?;
                     }
                     tag @ (Deliver::Base64 | Deliver::DataUrl) => {
-                        // PERF(port): was comptime tag dispatch — profile if it shows up on a hot path.
                         // This arm copies the bytes out — re-arm `Encoded::drop` so
                         // the codec allocation is freed at scope exit (RAII), not by
                         // a JS finalizer.
@@ -1856,7 +1853,7 @@ impl<'a> PipelineTask<'a> {
                             Ok(p) => p,
                             Err(_) => return promise.reject(global, Err(jsc::JsError::Thrown)),
                         };
-                        // PORT NOTE: `PathOrBlob::Path` owns its `PathOrFileDescriptor`
+                        // `PathOrBlob::Path` owns its `PathOrFileDescriptor`
                         // and frees on Drop — no explicit `path.deinit()` needed.
                         let write_promise = match crate::webcore::blob::write_file_internal(
                             global,
@@ -1898,7 +1895,7 @@ impl<'a> PipelineTask<'a> {
         let p = &self.pipeline;
         if p.rotate != 0 {
             let next = codecs::rotate(&d.rgba, d.width, d.height, u32::from(p.rotate))?;
-            // PORT NOTE: `bun.default_allocator.free(d.rgba)` — assignment drops
+            // Assignment drops
             // the old `Vec<u8>`/owned buffer.
             d.rgba = next.rgba;
             d.width = next.width;
@@ -1966,11 +1963,11 @@ fn make_placeholder(rgba: &[u8], sw: u32, sh: u32) -> Result<TaskResult, codecs:
     let mut buf = [0u8; thumbhash::MAX_LEN];
     let hash = thumbhash::encode(&mut buf, w, h, pixels);
     let rendered = thumbhash::decode(hash)?;
-    // `defer bun.default_allocator.free(rendered.rgba)` — owned, drops at scope exit.
+    // `rendered.rgba` is owned; drops at scope exit.
     // Placeholder is a synthetic ThumbHash render, not the source image —
     // no ICC profile attaches to it.
     let out = codecs::png::encode(&rendered.rgba, rendered.w, rendered.h, -1, None)?;
-    let _ = owned; // PERF(port): explicit lifetime hint; drops here.
+    let _ = owned; // explicit lifetime hint; drops here.
     Ok(TaskResult::Encoded {
         out,
         format: codecs::Format::Png,
@@ -2034,8 +2031,7 @@ fn apply_orientation(
 impl<'a> Drop for PipelineTask<'a> {
     fn drop(&mut self) {
         // Only reached from `then()` on the JS thread (the `encode_for_body`
-        // stack temporary is wrapped in `ManuallyDrop` — Zig never calls
-        // `deinit()` on that path), so the ref/count touch is safe without
+        // stack temporary is wrapped in `ManuallyDrop`), so the ref/count touch is safe without
         // atomics.
         // `self.deliver.deinit()` — `Strong` Drop on the `WriteDest` arm.
         // SAFETY: `image` is a BACKREF kept alive by the wrapper's Strong
@@ -2049,5 +2045,3 @@ impl<'a> Drop for PipelineTask<'a> {
         // `bun.destroy(this)` — `Box<PipelineTask>` drop is the caller.
     }
 }
-
-// ported from: src/runtime/image/Image.zig
diff --git a/src/runtime/image/backend_coregraphics.rs b/src/runtime/image/backend_coregraphics.rs
index 3deac514bd3..6c3a280137b 100644
--- a/src/runtime/image/backend_coregraphics.rs
+++ b/src/runtime/image/backend_coregraphics.rs
@@ -1,7 +1,7 @@
 //! macOS ImageIO/CoreGraphics backend.
 //!
 //! All framework calls live in `src/jsc/bindings/image_coregraphics_shim.cpp`
-//! — see the header comment there for why (Zig→dlsym'd-function-pointer calls
+//! — see the header comment there for why (dlsym'd-function-pointer calls
 //! into CG segfaulted on x86_64 even after thunking the obvious by-value
 //! struct, so the whole dispatch is in C++ where clang owns the ABI). This
 //! file just allocates the RGBA/output buffers in the global allocator and
@@ -9,7 +9,6 @@
 
 use super::codecs;
 
-/// Zig: `pub const BackendError = codecs.Error || error{BackendUnavailable};`
 #[derive(thiserror::Error, strum::IntoStaticStr, Debug, Copy, Clone, Eq, PartialEq)]
 pub enum BackendError {
     #[error("BackendUnavailable")]
@@ -45,8 +44,8 @@ impl From<codecs::Error> for BackendError {
 bun_core::named_error_set!(BackendError);
 
 impl BackendError {
-    /// Reshape Zig's `(codecs.Error || error{BackendUnavailable})!T` into the
-    /// Rust caller's `Result<Option<T>, codecs::Error>` convention used by
+    /// Reshape into the
+    /// caller's `Result<Option<T>, codecs::Error>` convention used by
     /// `codecs.rs` (`Ok(None)` = BackendUnavailable → fall through to the
     /// pure-Rust codec path).
     #[inline]
@@ -65,7 +64,6 @@ impl BackendError {
     }
 }
 
-// TODO(port): move to runtime_sys (or a dedicated image_sys crate)
 unsafe extern "C" {
     fn bun_coregraphics_decode(
         bytes: *const u8,
@@ -123,7 +121,7 @@ pub fn decode(bytes: &[u8], max_pixels: u64) -> Result<codecs::Decoded, BackendE
         CG_OK => {}
         rc => return Err(map_err(rc)),
     }
-    // PERF(port): Zig used uninitialized alloc; vec![0u8; n] zero-fills — profile if hot.
+    // PERF: vec![0u8; n] zero-fills — profile if hot.
     let mut out = vec![0u8; (w as usize) * (h as usize) * 4];
     // Phase 2: render. The C side re-creates the CGImageSource (cheap — the
     // header parse is the only repeated work) so we don't have to thread an
@@ -179,7 +177,7 @@ pub(crate) fn encode(
         CG_OK => {}
         rc => return Err(map_err(rc)),
     }
-    // PERF(port): Zig used uninitialized alloc — profile if hot.
+    // PERF: zero-fill alloc — profile if hot.
     let mut out = vec![0u8; len];
     // Phase 2: copy out and release the CFData.
     // SAFETY: out has `len` bytes; shim writes ≤ len and updates `len`.
@@ -206,7 +204,6 @@ pub(crate) fn encode(
 // Highway path in `codecs.rs` so the dispatch site is `system_backend.x()
 // .or_else(|_| fallback.x())`.
 
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     #[allow(dead_code)]
     fn bun_coregraphics_scale(
@@ -250,7 +247,7 @@ pub(crate) fn scale(
     if filter != codecs::Filter::Lanczos3 {
         return Err(BackendError::BackendUnavailable);
     }
-    // PERF(port): Zig used uninitialized alloc — profile if hot.
+    // PERF: zero-fill alloc — profile if hot.
     let mut out = vec![0u8; (dw as usize) * (dh as usize) * 4];
     // SAFETY: src has sw*sh*4 bytes (caller invariant); out has dw*dh*4 bytes.
     if unsafe { bun_coregraphics_scale(src.as_ptr(), sw, sh, out.as_mut_ptr(), dw, dh) } != CG_OK {
@@ -261,7 +258,7 @@ pub(crate) fn scale(
 
 #[allow(dead_code)]
 pub(crate) fn rotate(src: &[u8], w: u32, h: u32, quarters: u32) -> Result<Vec<u8>, BackendError> {
-    // PERF(port): Zig used uninitialized alloc — profile if hot.
+    // PERF: zero-fill alloc — profile if hot.
     let mut out = vec![0u8; (w as usize) * (h as usize) * 4];
     // SAFETY: src and out both have w*h*4 bytes.
     if unsafe { bun_coregraphics_rotate90(src.as_ptr(), w, h, out.as_mut_ptr(), quarters) } != CG_OK
@@ -273,7 +270,7 @@ pub(crate) fn rotate(src: &[u8], w: u32, h: u32, quarters: u32) -> Result<Vec<u8
 
 #[allow(dead_code)]
 pub(crate) fn flip(src: &[u8], w: u32, h: u32, horizontal: bool) -> Result<Vec<u8>, BackendError> {
-    // PERF(port): Zig used uninitialized alloc — profile if hot.
+    // PERF: zero-fill alloc — profile if hot.
     let mut out = vec![0u8; (w as usize) * (h as usize) * 4];
     // SAFETY: src and out both have w*h*4 bytes.
     if unsafe { bun_coregraphics_reflect(src.as_ptr(), w, h, out.as_mut_ptr(), horizontal as i32) }
@@ -289,7 +286,6 @@ pub(crate) fn flip(src: &[u8], w: u32, h: u32, horizontal: bool) -> Result<Vec<u
 // the static `Bun.Image.fromClipboard()` accessor calls this synchronously
 // before constructing the Image — the heavy decode still goes to WorkPool).
 
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     #[allow(dead_code)]
     fn bun_coregraphics_clipboard(out: *mut u8, out_len: *mut usize, probe_only: i32) -> i32;
@@ -297,7 +293,6 @@ unsafe extern "C" {
 
 /// `None` ⇔ no image on the pasteboard. Returned bytes are an opaque container
 /// (PNG/TIFF/HEIC/…); feed straight to `new Bun.Image(…)`.
-// Zig error set: `error{BackendUnavailable, OutOfMemory}` — subset of BackendError.
 #[allow(dead_code)]
 pub(crate) fn clipboard() -> Result<Option<Vec<u8>>, BackendError> {
     let mut len: usize = 0;
@@ -308,7 +303,7 @@ pub(crate) fn clipboard() -> Result<Option<Vec<u8>>, BackendError> {
     if len == 0 {
         return Ok(None);
     }
-    // PERF(port): Zig used uninitialized alloc — profile if hot.
+    // PERF: zero-fill alloc — profile if hot.
     let mut out = vec![0u8; len];
     // SAFETY: out has `len` bytes; shim writes ≤ len and updates `len`.
     if unsafe { bun_coregraphics_clipboard(out.as_mut_ptr(), &raw mut len, 0) } != CG_OK {
@@ -327,16 +322,12 @@ pub(crate) fn has_clipboard_image() -> bool {
     }
 }
 
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     #[allow(dead_code)]
     fn bun_coregraphics_clipboard_change_count() -> i64;
 }
-// Zig: `pub const clipboardChangeCount = bun_coregraphics_clipboard_change_count;`
 #[allow(dead_code)]
 pub(crate) fn clipboard_change_count() -> i64 {
     // SAFETY: pure getter, no preconditions.
     unsafe { bun_coregraphics_clipboard_change_count() }
 }
-
-// ported from: src/runtime/image/backend_coregraphics.zig
diff --git a/src/runtime/image/backend_wic.rs b/src/runtime/image/backend_wic.rs
index 5e8c4b93741..67e61fa8963 100644
--- a/src/runtime/image/backend_wic.rs
+++ b/src/runtime/image/backend_wic.rs
@@ -40,12 +40,11 @@ use core::ptr;
 use std::sync::Once;
 
 use crate::image::codecs;
-// TODO(port): move to runtime_sys / bun_sys::windows
 use bun_sys::windows;
 
-/// `codecs::Error || error{BackendUnavailable}`
-// TODO(port): narrow error set — Zig flat-unions codecs::Error with BackendUnavailable;
-// variants used in this file are inlined here. Reconcile with codecs::Error.
+/// `codecs::Error` plus `BackendUnavailable`; the variants used in this file
+/// are inlined here and `split()`
+/// below maps them back onto `codecs::Error` for the caller.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, thiserror::Error, strum::IntoStaticStr)]
 pub enum BackendError {
     #[error("BackendUnavailable")]
@@ -62,8 +61,8 @@ pub enum BackendError {
 use BackendError::*;
 
 impl BackendError {
-    /// Reshape Zig's `(codecs.Error || error{BackendUnavailable})!T` into the
-    /// Rust caller's `Result<Option<T>, codecs::Error>` convention used by
+    /// Reshape into the
+    /// caller's `Result<Option<T>, codecs::Error>` convention used by
     /// `codecs.rs` (`Ok(None)` = BackendUnavailable → fall through to the
     /// pure-Rust codec path).
     #[inline]
@@ -81,15 +80,13 @@ impl BackendError {
 
 bun_core::named_error_set!(BackendError);
 
-// Zig: `dupGlobal` is `error{OutOfMemory}!?[]u8`, flat-unioned into
-// `clipboard()`'s `error{BackendUnavailable, OutOfMemory}` set.
 bun_core::oom_from_alloc!(BackendError);
 
 pub fn decode(bytes: &[u8], max_pixels: u64) -> Result<codecs::Decoded, BackendError> {
     let f = factory()?;
-    // IWICStream::InitializeFromMemory takes a DWORD count; Windows ships
-    // ReleaseSafe so the @intCast below is a process abort, not silent
-    // truncation. Drop to BackendUnavailable so codecs.decode() falls
+    // IWICStream::InitializeFromMemory takes a DWORD count; the checked cast
+    // below is a process abort, not silent truncation.
+    // Drop to BackendUnavailable so codecs.decode() falls
     // through to the static decoder (bmp/gif) or surfaces UnsupportedOn
     // Platform (tiff/heic/avif) instead of crashing on a >4 GiB input.
     if bytes.len() as u64 > u32::MAX as u64 {
@@ -139,17 +136,15 @@ pub fn decode(bytes: &[u8], max_pixels: u64) -> Result<codecs::Decoded, BackendE
     scopeguard::defer! { release(conv.as_ptr()); }
 
     // Compute stride/size in u64 first: with `maxPixels` raised past ~1.07B,
-    // `w * 4` can wrap u32 (0x4000_0001×4 → 4) and Windows ships ReleaseSafe
-    // so the @intCast below is a process abort, not silent truncation.
+    // `w * 4` can wrap u32 (0x4000_0001×4 → 4); the checked cast below is a
+    // process abort, not silent truncation.
     let stride: u64 = (w as u64) * 4;
     let out_len: u64 = stride * (h as u64);
     // CopyPixels takes UINT byte-count + UINT stride — same DWORD ceiling.
     if out_len > u32::MAX as u64 {
         return Err(TooManyPixels);
     }
-    // PERF(port): was uninitialized alloc — profile if it shows up on a hot path.
     let mut out = vec![0u8; usize::try_from(out_len).expect("int cast")];
-    // (errdefer free(out) deleted — Vec drops on `?`/early return)
     if conv.copy_pixels(
         ptr::null(),
         u32::try_from(stride).expect("int cast"),
@@ -373,7 +368,6 @@ struct IUnknown {
 // VARIANT/PROPBAG2 layout is fiddly enough (union padding, BRECORD/DECIMAL
 // arms) that hand-rolling it as `extern struct` is asking for an ABI drift.
 // The C++ shim uses the SDK's own headers; we just hand it the bag pointer.
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     fn bun_wic_propbag_write_f32(props: *mut c_void, name: *const u16, value: f32) -> i32;
     fn bun_wic_propbag_write_u8(props: *mut c_void, name: *const u16, value: u8) -> i32;
@@ -426,8 +420,7 @@ fn release<T>(p: *mut T) {
 /// method, so `decode`/`encode` read as straight-line safe code.
 ///
 /// Not an owning smart pointer — release is still explicit via
-/// `scopeguard::defer! { release(p.as_ptr()) }` at the call site, matching
-/// the Zig original's `defer release(p)` shape. `Copy` so the defer-guard
+/// `scopeguard::defer! { release(p.as_ptr()) }` at the call site. `Copy` so the defer-guard
 /// closure captures a copy and the handle stays usable afterwards.
 #[repr(transparent)]
 struct ComPtr<T>(ptr::NonNull<T>);
@@ -836,7 +829,6 @@ fn container_guid(f: codecs::Format) -> Option<*const GUID> {
 
 // ───────────────────────────── lazy factory ─────────────────────────────────
 
-// TODO(port): move to runtime_sys
 #[link(name = "ole32")]
 unsafe extern "system" {
     fn CoInitializeEx(reserved: *mut c_void, flags: u32) -> HRESULT;
@@ -952,7 +944,6 @@ fn load_factory() {
 // the clipboard omits. Either way the result is bytes the regular Bun.Image
 // decoder understands; nothing is decoded here.
 
-// TODO(port): move to runtime_sys
 #[link(name = "user32")]
 unsafe extern "system" {
     fn OpenClipboard(hwnd: *mut c_void) -> c_int;
@@ -999,7 +990,8 @@ pub(crate) fn has_clipboard_image() -> bool {
     false
 }
 
-// TODO(port): narrow error set — Zig: error{BackendUnavailable, OutOfMemory}!?[]u8
+// The wider `BackendError` type matches the macOS backend so the caller in
+// Image.rs handles both identically.
 pub(crate) fn clipboard() -> Result<Option<Vec<u8>>, BackendError> {
     // hwnd=null associates the open with the current task; fine for read-only.
     // SAFETY: null hwnd is documented as valid.
@@ -1029,7 +1021,7 @@ pub(crate) fn clipboard() -> Result<Option<Vec<u8>>, BackendError> {
     //    and decoder accept it. CF_DIBV5 first (carries alpha mask). The
     //    clipboard is writable by any local process, so treat the payload as
     //    hostile: a 1-byte CF_DIB or a header with biSize≈u32::MAX must drop
-    //    the format, not panic the process (Windows ships ReleaseSafe).
+    //    the format, not panic the process.
     for cf in [CF_DIBV5, CF_DIB] {
         // SAFETY: clipboard is open.
         let h = unsafe { GetClipboardData(cf) };
@@ -1094,11 +1086,8 @@ fn dup_global<const PREFIX: usize>(
         // SAFETY: h is locked.
         let _ = unsafe { GlobalUnlock(h) };
     }
-    // PERF(port): was uninitialized alloc — profile if it shows up on a hot path.
     let mut out = vec![0u8; PREFIX + size];
     // SAFETY: ptr_ points to `size` valid bytes inside the locked HGLOBAL.
     out[PREFIX..].copy_from_slice(unsafe { bun_core::ffi::slice(ptr_, size) });
     Ok(Some(out))
 }
-
-// ported from: src/runtime/image/backend_wic.zig
diff --git a/src/runtime/image/codec_bmp.rs b/src/runtime/image/codec_bmp.rs
index f9222f49a9e..5a414aa37fe 100644
--- a/src/runtime/image/codec_bmp.rs
+++ b/src/runtime/image/codec_bmp.rs
@@ -191,5 +191,3 @@ pub fn decode(bytes: &[u8], max_pixels: u64) -> Result<codecs::Decoded, codecs::
         icc_profile: None,
     })
 }
-
-// ported from: src/runtime/image/codec_bmp.zig
diff --git a/src/runtime/image/codec_gif.rs b/src/runtime/image/codec_gif.rs
index 8c914481e34..b6cbf25593b 100644
--- a/src/runtime/image/codec_gif.rs
+++ b/src/runtime/image/codec_gif.rs
@@ -18,7 +18,7 @@ use super::codecs;
 /// prefixed sub-blocks (≤255 bytes each, terminated by a 0 block), and
 /// codes are LSB-first across byte boundaries — so this pulls one byte at
 /// a time from the sub-block stream into a 32-bit accumulator.
-// PORT NOTE: stack-local helper; `'a` borrows the input byte slice for the
+// Stack-local helper; `'a` borrows the input byte slice for the
 // duration of the decode call.
 struct Bits<'a> {
     src: &'a [u8],
@@ -27,7 +27,6 @@ struct Bits<'a> {
     /// Bytes remaining in the current sub-block. 0 ⇒ need to read a length.
     block: usize,
     acc: u32,
-    // Zig: u5
     nbits: u8,
     /// We hit the 0-length terminator or ran off the end — every subsequent
     /// `read` returns 0 so the LZW loop sees an EOI-shaped value and stops
@@ -248,11 +247,11 @@ fn decode_frame(
     let mut avail: u16 = eoi + 1;
     let mut prev: Option<u16> = None;
 
-    // PERF(port): Zig left this uninitialized; zero-init here for safety.
+    // PERF: zero-init for safety; uninitialized would be faster if hot.
     let mut dict: Box<Dict> = bun_core::boxed_zeroed();
     let mut scratch = [0u8; 4096];
 
-    // PERF(port): Zig left this uninitialized; zero-init here for safety.
+    // PERF: zero-init for safety; uninitialized would be faster if hot.
     let mut idx = vec![0u8; npix];
     let mut written: usize = 0;
 
@@ -383,5 +382,3 @@ fn expand_row(idx: &[u8], out: &mut [u8], pal: &[[u8; 4]; 256]) {
         out[x * 4..][..4].copy_from_slice(&pal[c as usize]);
     }
 }
-
-// ported from: src/runtime/image/codec_gif.zig
diff --git a/src/runtime/image/codec_jpeg.rs b/src/runtime/image/codec_jpeg.rs
index e77fb0816fa..2625d9a388e 100644
--- a/src/runtime/image/codec_jpeg.rs
+++ b/src/runtime/image/codec_jpeg.rs
@@ -10,7 +10,6 @@ use crate::encoded_wrap_free;
 #[allow(non_camel_case_types)]
 type tjhandle = *mut c_void;
 
-// TODO(port): move to libjpeg_turbo_sys (or runtime_sys) crate
 // TJINIT_COMPRESS=0, TJINIT_DECOMPRESS=1.
 unsafe extern "C" {
     pub(crate) fn tj3Init(init_type: c_int) -> tjhandle;
@@ -230,7 +229,6 @@ pub fn decode(
             },
         );
     }
-    // PERF(port): was uninitialized `allocator.alloc(u8, n)` — zero-init here; profile if hot.
     let mut out = vec![0u8; w as usize * ht as usize * 4];
     // SAFETY: `h` is live; src ptr/len come from a valid `&[u8]`; dst is the
     // exclusive `out` buffer sized `w*ht*4` and the explicit pitch + cropping
@@ -370,5 +368,3 @@ pub(crate) fn encode(
         free: encoded_wrap_free!(tj3Free),
     })
 }
-
-// ported from: src/runtime/image/codec_jpeg.zig
diff --git a/src/runtime/image/codec_png.rs b/src/runtime/image/codec_png.rs
index 1efc736dff9..18281eec357 100644
--- a/src/runtime/image/codec_png.rs
+++ b/src/runtime/image/codec_png.rs
@@ -8,7 +8,6 @@ use super::codecs;
 use super::quantize;
 use crate::encoded_wrap_free;
 
-// TODO(port): move to runtime_sys (or a dedicated spng_sys crate)
 bun_opaque::opaque_ffi! { pub struct spng_ctx; }
 
 unsafe extern "C" {
@@ -378,5 +377,3 @@ pub(crate) fn encode_indexed(
         free: encoded_wrap_free!(libc::free),
     })
 }
-
-// ported from: src/runtime/image/codec_png.zig
diff --git a/src/runtime/image/codec_webp.rs b/src/runtime/image/codec_webp.rs
index d1ccd660c6f..7aab8d8901c 100644
--- a/src/runtime/image/codec_webp.rs
+++ b/src/runtime/image/codec_webp.rs
@@ -7,7 +7,6 @@ use core::ptr::NonNull;
 use super::codecs;
 use crate::encoded_wrap_free;
 
-// TODO(port): move to libwebp_sys (or runtime_sys); extern fns declared inline here for now.
 unsafe extern "C" {
     pub(crate) fn WebPGetInfo(data: *const u8, len: usize, w: *mut c_int, h: *mut c_int) -> c_int;
     fn WebPDecodeRGBA(data: *const u8, len: usize, w: *mut c_int, h: *mut c_int) -> *mut u8;
@@ -90,7 +89,6 @@ bun_opaque::opaque_ffi! {
 
 // `WebPDemux()` and `WebPMuxNew()` are `static inline` in the headers and
 // just forward to these version-checked entry points with the ABI constant.
-// TODO(port): move to libwebp_sys
 unsafe extern "C" {
     fn WebPDemuxInternal(
         data: *const WebPData,
@@ -338,5 +336,3 @@ pub(crate) fn encode(
         free: encoded_wrap_free!(WebPFree),
     })
 }
-
-// ported from: src/runtime/image/codec_webp.zig
diff --git a/src/runtime/image/codecs.rs b/src/runtime/image/codecs.rs
index e5bc5ac3a52..279c3adfeb2 100644
--- a/src/runtime/image/codecs.rs
+++ b/src/runtime/image/codecs.rs
@@ -56,7 +56,6 @@ pub enum Backend {
     System = 0,
     Bun = 1,
 }
-// PORT NOTE: `Backend.Map = bun.ComptimeEnumMap(Backend)` → phf map keyed by lowercase variant name.
 pub(crate) static BACKEND_MAP: phf::Map<&'static [u8], Backend> = phf::phf_map! {
     b"system" => Backend::System,
     b"bun" => Backend::Bun,
@@ -72,8 +71,8 @@ impl bun_jsc::FromJsEnum for Backend {
     }
 }
 
-// PORT NOTE: Zig `pub var backend` is read from WorkPool threads + written from JS;
-// "torn read of a 1-byte enum is fine" → relaxed atomic is the safe-Rust spelling.
+// Read from WorkPool threads + written from JS; a torn read of a 1-byte enum
+// is harmless, so a relaxed atomic is sufficient.
 pub(crate) static BACKEND: core::sync::atomic::AtomicU8 =
     core::sync::atomic::AtomicU8::new(if HAS_SYSTEM_BACKEND {
         Backend::System as u8
@@ -81,10 +80,10 @@ pub(crate) static BACKEND: core::sync::atomic::AtomicU8 =
         Backend::Bun as u8
     });
 
-/// Runtime half of the dispatch check; the comptime half is the
+/// Runtime half of the dispatch check; the compile-time half is the
 /// `#[cfg(any(target_os = "macos", windows))]` gate at each call site (types
 /// can't be runtime-conditional, so the two stay separate). On platforms with
-/// no backend the cfg is comptime-dead and this is never referenced.
+/// no backend the cfg is compile-time dead and this is never referenced.
 #[cfg(any(target_os = "macos", windows))]
 #[inline]
 fn use_system() -> bool {
@@ -222,7 +221,6 @@ pub struct Decoded {
     /// colours. See issue #30197.
     pub icc_profile: Option<Vec<u8>>,
 }
-// PORT NOTE: `deinit` only freed owned fields → Drop is automatic via Vec/Option<Vec>.
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error, strum::IntoStaticStr)]
 pub enum Error {
@@ -295,14 +293,11 @@ pub fn decode(bytes: &[u8], max_pixels: u64, hint: DecodeHint) -> Result<Decoded
             };
             // GIF transparency is a binary palette-index flag — the RGB at
             // α=0 is whatever the colour-table slot happened to hold and has
-            // no defined meaning. The static decoder emits `[0,0,0,0]`
-            // (codec_gif.zig: `pal[t] = .{0,0,0,0}`) and ImageIO does the
+            // no defined meaning. The static decoder (codec_gif.rs) emits
+            // `[0,0,0,0]` and ImageIO does the
             // same, but WIC's indexed→32bppRGBA converter expands the palette
-            // entry verbatim, leaving the original RGB with α=0. Zig never
-            // hit this because `bun.windows.GetProcAddressA` widens the
-            // symbol to UTF-16 for the narrow-only Win32 `GetProcAddress`,
-            // so `WICConvertBitmapSource` was never resolved and WIC decode
-            // always fell through to the static path. Normalise here so
+            // entry verbatim, leaving the original RGB with α=0. Normalise
+            // here so
             // every backend yields identical bytes for the same GIF.
             for px in d.rgba.chunks_exact_mut(4) {
                 if px[3] == 0 {
@@ -316,8 +311,7 @@ pub fn decode(bytes: &[u8], max_pixels: u64, hint: DecodeHint) -> Result<Decoded
     }
 }
 
-// PORT NOTE: Zig returned `(Error || error{BackendUnavailable})!Decoded`;
-// reshaped to `Result<Option<Decoded>, Error>` where `Ok(None)` = BackendUnavailable.
+// `Result<Option<Decoded>, Error>` where `Ok(None)` = BackendUnavailable.
 fn decode_via_system(_bytes: &[u8], _max_pixels: u64) -> Result<Option<Decoded>, Error> {
     #[cfg(any(target_os = "macos", windows))]
     if use_system() {
@@ -453,15 +447,16 @@ pub struct EncodeOptions {
     /// pipeline forwards this from the decode step so a non-sRGB source
     /// (P3, Adobe RGB, XYB/Jpegli) preserves its colour meaning through
     /// re-encode. Borrowed; the caller retains ownership.
-    // TODO(port): lifetime — borrowed from caller for the duration of `encode()`;
-    // raw ptr per rule "never put a lifetime param on a struct".
+    // SAFETY invariant: borrowed from the caller and only valid for the
+    // duration of `encode()`; raw ptr instead of a lifetime param per the
+    // repo rule against lifetime params on structs.
     pub icc_profile: Option<NonNull<[u8]>>,
 }
 
 impl Default for EncodeOptions {
     fn default() -> Self {
         Self {
-            format: Format::Png, // TODO(port): Zig has no default for `format`; pick at construction
+            format: Format::Png, // arbitrary; callers set it at construction
             quality: 80,
             lossless: false,
             compression_level: -1,
@@ -501,11 +496,10 @@ impl Drop for Encoded {
     }
 }
 
-/// Adapt a 1-arg C free (`tj3Free`, `WebPFree`, `std.c.free`) to the
+/// Adapt a 1-arg C free (`tj3Free`, `WebPFree`, libc `free`) to the
 /// 2-arg JSC deallocator signature.
-// PORT NOTE: Zig `wrap(comptime f: anytype)` generated a distinct static fn per
-// call site. Rust cannot capture a runtime fn pointer in a non-capturing
-// `extern "C" fn`, so this is a macro that mints a static trampoline per call.
+// Rust cannot capture a runtime fn pointer in a non-capturing `extern "C" fn`,
+// so this is a macro that mints a static trampoline per call site.
 #[macro_export]
 macro_rules! encoded_wrap_free {
     ($f:path) => {{
@@ -626,7 +620,6 @@ pub(crate) static FILTER_MAP: phf::Map<&'static [u8], Filter> = phf::phf_map! {
     b"mks2021" => Filter::Mks2021,
 };
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn bun_image_resize_scratch_size(
         src_w: i32,
@@ -666,7 +659,7 @@ pub(crate) fn resize(
     dh: u32,
     f: Filter,
 ) -> Result<Vec<u8>, Error> {
-    // Zig: `if (@hasDecl(b, "scale"))` — only `backend_coregraphics` provides
+    // Only `backend_coregraphics` provides
     // scale/rotate/flip (vImage); WIC has decode/encode only.
     #[cfg(target_os = "macos")]
     if use_system() {
@@ -712,7 +705,7 @@ pub(crate) fn resize(
     // fits the same block, so this is free.
     block.truncate(out_sz);
     block.shrink_to_fit();
-    // PERF(port): Zig used realloc directly; Vec::shrink_to_fit may not be in-place — profile if hot.
+    // PERF: Vec::shrink_to_fit may not be in-place — profile if hot.
     Ok(block)
 }
 
@@ -778,5 +771,3 @@ pub(crate) fn flip(src: &[u8], w: u32, h: u32, horizontal: bool) -> Result<Vec<u
     };
     Ok(out)
 }
-
-// ported from: src/runtime/image/codecs.zig
diff --git a/src/runtime/image/exif.rs b/src/runtime/image/exif.rs
index 8007d49b48f..8af883da93c 100644
--- a/src/runtime/image/exif.rs
+++ b/src/runtime/image/exif.rs
@@ -205,5 +205,3 @@ fn rd32(b: &[u8], off: usize, big: bool) -> Option<u32> {
         u32::from_le_bytes(bytes)
     })
 }
-
-// ported from: src/runtime/image/exif.zig
diff --git a/src/runtime/image/quantize.rs b/src/runtime/image/quantize.rs
index d24d17069cd..ec1db6865d0 100644
--- a/src/runtime/image/quantize.rs
+++ b/src/runtime/image/quantize.rs
@@ -11,7 +11,6 @@
 
 use bun_alloc::AllocError;
 
-// PORT NOTE: Zig named this `Result`; renamed to avoid shadowing `core::result::Result`.
 pub(crate) struct QuantizeResult {
     /// `[colors][4]u8` RGBA palette.
     pub palette: Box<[u8]>,
@@ -23,10 +22,9 @@ pub(crate) struct QuantizeResult {
     pub has_alpha: bool,
 }
 
-// Zig `deinit` only freed `palette`/`indices`; both are now `Box<[u8]>`, so
+// `palette`/`indices` are `Box<[u8]>`, so
 // `Drop` is automatic — no explicit impl needed.
 
-// PORT NOTE: Zig named this `Box`; renamed to avoid shadowing `std::boxed::Box`.
 #[derive(Clone, Copy)]
 struct ColorBox {
     /// Slice into the shared `order` index buffer.
@@ -38,7 +36,6 @@ struct ColorBox {
 
 impl ColorBox {
     fn widest_channel(self) -> u8 {
-        // PORT NOTE: Zig `u2` → `u8` (Rust has no sub-byte integer types).
         let mut best: u8 = 0;
         let mut span: i32 = -1;
         for c in 0..4usize {
@@ -52,7 +49,6 @@ impl ColorBox {
     }
 }
 
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     fn bun_image_nearest_palette(palette: *const u8, k: u32, r: i32, g: i32, b: i32, a: i32)
     -> u32;
@@ -64,8 +60,8 @@ pub struct Options {
     /// Floyd–Steinberg error diffusion. Hides banding on gradients at the
     /// cost of grain on flat areas; off by default to match Sharp's
     /// `palette:true` default.
-    // PORT NOTE: Zig field default `= false`; Rust has no per-field defaults,
-    // callers must pass explicitly.
+    // No `Default` impl — callers must
+    // pass this explicitly.
     pub dither: bool,
 }
 
@@ -87,7 +83,6 @@ pub(crate) fn quantize(
     }
 
     let mut boxes: Vec<ColorBox> = Vec::with_capacity(want as usize);
-    // PERF(port): was appendAssumeCapacity
     boxes.push(shrink(rgba, &order, 0, n));
 
     while boxes.len() < want as usize {
@@ -114,14 +109,11 @@ pub(crate) fn quantize(
         let ch = b.widest_channel();
         // Partial sort by the chosen channel, then cut at the midpoint.
         let slice = &mut order[b.lo as usize..b.hi as usize];
-        // PORT NOTE: std.sort.pdq + SortCtx.less → slice::sort_unstable_by_key
-        // (also pdqsort). Zig's SortCtx struct is captured by the closure.
         // u32 ×4 overflows past ~1.07B pixels (allowed when the user raises
         // `maxPixels`); the other order-index sites already widen first.
         slice.sort_unstable_by_key(|&p| rgba[p as usize * 4 + ch as usize]);
         let mid = b.lo + (b.hi - b.lo) / 2;
         boxes[pick] = shrink(rgba, &order, b.lo, mid);
-        // PERF(port): was appendAssumeCapacity
         boxes.push(shrink(rgba, &order, mid, b.hi));
     }
 
@@ -204,7 +196,6 @@ fn map_floyd_steinberg(
     let stride: usize = w as usize * 4;
     let mut cur: Vec<i32> = vec![0i32; stride];
     let mut nxt: Vec<i32> = vec![0i32; stride];
-    // (Zig @memset to 0 is folded into vec! init above.)
 
     let mut y: u32 = 0;
     while y < h {
@@ -289,5 +280,3 @@ fn shrink(rgba: &[u8], order: &[u32], lo: u32, hi: u32) -> ColorBox {
     }
     ColorBox { lo, hi, min, max }
 }
-
-// ported from: src/runtime/image/quantize.zig
diff --git a/src/runtime/image/thumbhash.rs b/src/runtime/image/thumbhash.rs
index c9eba9f295d..30d8bc3092b 100644
--- a/src/runtime/image/thumbhash.rs
+++ b/src/runtime/image/thumbhash.rs
@@ -18,7 +18,6 @@ use core::f32::consts::PI;
 pub(crate) const MAX_LEN: usize = 25;
 
 pub(crate) fn encode<'a>(out: &'a mut [u8; MAX_LEN], w: u32, h: u32, rgba: &[u8]) -> &'a mut [u8] {
-    // PORT NOTE: Zig returns `out[0..n]`; mirrored here as a mut sub-slice borrow of `out`.
     debug_assert!(w > 0 && w <= 100 && h > 0 && h <= 100);
     debug_assert!(rgba.len() == (w as usize) * (h as usize) * 4);
 
@@ -34,7 +33,6 @@ pub(crate) fn encode<'a>(out: &'a mut [u8; MAX_LEN], w: u32, h: u32, rgba: &[u8]
         i += 4;
     }
     if avg[3] > 0.0 {
-        // PORT NOTE: reshaped for borrowck — Zig indexed avg[3] inside the loop body.
         let a3 = avg[3];
         for c in &mut avg[0..3] {
             *c /= a3;
@@ -49,7 +47,7 @@ pub(crate) fn encode<'a>(out: &'a mut [u8; MAX_LEN], w: u32, h: u32, rgba: &[u8]
 
     // RGBA → LPQA, compositing transparent pixels onto the average so the DCT
     // doesn't see a black fringe.
-    // PERF(port): was `undefined` stack arrays — profile if it shows up on a hot path.
+    // PERF: heap-allocates the working buffers — profile if it shows up on a hot path.
     let mut l = vec![0.0f32; 100 * 100];
     let mut p = vec![0.0f32; 100 * 100];
     let mut q = vec![0.0f32; 100 * 100];
@@ -104,7 +102,6 @@ pub(crate) fn encode<'a>(out: &'a mut [u8; MAX_LEN], w: u32, h: u32, rgba: &[u8]
     }
 
     let mut odd = false;
-    // PORT NOTE: Zig `inline for` over tuple of &Channel — all same type, plain loop.
     for ch in [&lc, &pc, &qc, &ac] {
         for &f in &ch.ac[0..ch.n] {
             let u: u8 = (15.0 * f).round() as u8;
@@ -144,7 +141,6 @@ impl Default for Channel {
 /// the per-channel max so 4-bit packing is uniform across channels.
 fn dct(chan: &[f32], w: u32, h: u32, nx: u32, ny: u32) -> Channel {
     let mut c = Channel::default();
-    // PERF(port): was `undefined` stack array — profile if it shows up on a hot path.
     let mut fx = [0.0f32; 100];
     let mut cy: u32 = 0;
     while cy < ny {
@@ -241,7 +237,6 @@ pub fn decode(hash: &[u8]) -> Result<Decoded, DecodeError> {
         i: off,
         hi: false,
     };
-    // PERF(port): was `undefined` stack arrays — profile if it shows up on a hot path.
     let mut l_ac = [0.0f32; 49];
     let mut p_ac = [0.0f32; 5];
     let mut q_ac = [0.0f32; 5];
@@ -268,9 +263,7 @@ pub fn decode(hash: &[u8]) -> Result<Decoded, DecodeError> {
     } else {
         32
     };
-    // PORT NOTE: `bun.default_allocator.alloc` → boxed slice (global mimalloc); aborts on OOM.
     let mut rgba = vec![0u8; (w as usize) * (h as usize) * 4].into_boxed_slice();
-    // errdefer free → dropped; Box<[u8]> Drop handles it.
 
     let mut fx = [0.0f32; 7];
     let mut fy = [0.0f32; 7];
@@ -324,7 +317,6 @@ fn idct(ac: &[f32], nx: u32, ny: u32, fx: &[f32; 7], fy: &[f32; 7]) -> f32 {
     v
 }
 
-// PORT NOTE: local borrow-param view; lifetime is fn-scoped to `decode`.
 struct NibbleReader<'a> {
     src: &'a [u8],
     i: usize,
@@ -374,5 +366,3 @@ impl<'a> NibbleReader<'a> {
 fn clamp8(v: f32) -> u8 {
     (v.clamp(0.0, 1.0) * 255.0) as u8
 }
-
-// ported from: src/runtime/image/thumbhash.zig
diff --git a/src/runtime/ipc_host.rs b/src/runtime/ipc_host.rs
index e22a8f8ca23..27d42668437 100644
--- a/src/runtime/ipc_host.rs
+++ b/src/runtime/ipc_host.rs
@@ -1,6 +1,5 @@
 //! JS host entry points for the IPC module that need to name `bun_runtime`
-//! types (`Subprocess`, `Listener`). Spec: `src/jsc/ipc.zig:980-1088` +
-//! `VirtualMachine.zig` `Bun__Process__send_`.
+//! types (`Subprocess`, `Listener`).
 //!
 //! LAYERING: `bun_jsc::ipc` defines the protocol/queue (mode-agnostic) and the
 //! `SendQueueOwner` trait. The host fns here close over the concrete
@@ -213,8 +212,8 @@ pub fn emit_handle_ipc_message(
     Ok(JSValue::UNDEFINED)
 }
 
-// Zig: comptime { const Bun__Process__send = jsc.toJSHostFn(Bun__Process__send_); @export(...) }
-// The #[bun_jsc::host_fn] attribute emits the callconv(jsc.conv) shim and export.
+// The #[bun_jsc::host_fn] attribute emits the jsc-callconv shim and the
+// `Bun__Process__send` export.
 //
 // LAYERING: lives here (not in `bun_jsc::virtual_machine_exports`) because the
 // body — via `do_send` — names `Listener` (`bun_runtime`). The export is a
diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs
index 11dcbe9ef76..e7eac1d2afa 100644
--- a/src/runtime/jsc_hooks.rs
+++ b/src/runtime/jsc_hooks.rs
@@ -61,14 +61,12 @@ use crate::webcore::blob::BlobExt as _;
 /// cached thread-locally so `auto_tick` (which only receives `*mut
 /// VirtualMachine`) can recover it without a field on the low-tier struct.
 ///
-/// PORT NOTE: in Zig these are value fields of `VirtualMachine`
-/// (`vm.timer: api.Timer.All`, `vm.entry_point: ServerEntryPoint`,
-/// `vm.body_value_pool`). The low-tier `VirtualMachine` carries `()`
-/// placeholders for them (see `// TODO(b2-cycle)` markers in
+/// The low-tier `VirtualMachine` carries `()`
+/// placeholders for these fields (see the placeholder field comments in
 /// `VirtualMachine.rs`); until those slots widen to `*mut c_void`, the
 /// thread-local is the recovery path.
 pub struct RuntimeState {
-    /// `bun.api.Timer.All` — setTimeout/setInterval heap + uv timers.
+    /// setTimeout/setInterval heap + uv timers.
     pub timer: timer::All,
     /// `RareData.{mysql,postgresql}_context` — concrete SQL state. The
     /// `bun_jsc::rare_data::RareData` slots for these are opaque ZSTs (cycle
@@ -93,7 +91,7 @@ pub struct RuntimeState {
     /// process-lifetime singletons via `OnceLock`, which a per-VM arena is not).
     pub transpiler_arena: Box<bun_alloc::Arena>,
     /// `vm.body_value_pool` — pooled storage for `Body.Value`
-    /// (`Request.body` payloads). Spec VirtualMachine.zig:45 value field.
+    /// (`Request.body` payloads).
     /// Boxed because `HiveAllocator` is `Fallback<HiveRef<Body::Value, 256>, 256>`
     /// — far too large to construct on the stack inside `Box::new(RuntimeState{..})`.
     pub body_value_pool: Box<crate::webcore::body::HiveAllocator>,
@@ -119,7 +117,7 @@ thread_local! {
 /// Recover this thread's [`RuntimeState`] as a raw pointer. Null only before
 /// `init_runtime_state` has run (e.g. `bun_jsc` unit tests with no high tier).
 ///
-/// PORT NOTE: returns `*mut` (NOT `&'static mut`) — `auto_tick` holds the
+/// Note: returns `*mut` (NOT `&'static mut`) — `auto_tick` holds the
 /// pointer across `timer.get_timeout`/`drain_timers`, which fire JS callbacks
 /// that may re-enter `runtime_state()`. Handing out `&'static mut` would mint
 /// aliased `&mut` to the same allocation (UB per PORTING.md §Forbidden).
@@ -132,7 +130,7 @@ pub(crate) fn runtime_state() -> *mut RuntimeState {
 
 /// Recover this thread's `timer::All` heap as a raw pointer.
 ///
-/// PORT NOTE (b2-cycle): `bun_jsc::VirtualMachine.timer` is a `()` placeholder;
+/// Note: `bun_jsc::VirtualMachine.timer` is a `()` placeholder;
 /// the real `All` lives in [`RuntimeState::timer`] until that slot widens.
 /// Null only before [`init_runtime_state`] has run (e.g. `bun_jsc` unit tests
 /// with no high tier, or `Bun__Timer__getNextID` racing init).
@@ -204,7 +202,7 @@ pub(crate) fn global_dns_data() -> &'static core::cell::OnceCell<Box<crate::dns_
 /// `init_runtime_state`.
 #[inline]
 pub(crate) unsafe fn runtime_state_of(vm: *mut VirtualMachine) -> *mut RuntimeState {
-    // PORT NOTE: raw-place read (no `&VirtualMachine` formed) — this is the
+    // Note: raw-place read (no `&VirtualMachine` formed) — this is the
     // one accessor that may run off the VM's JS thread, which could be inside
     // a `&mut self.transpiler` borrow there; a shared `&*vm` here would alias
     // it (SB/TB-UB).
@@ -213,11 +211,11 @@ pub(crate) unsafe fn runtime_state_of(vm: *mut VirtualMachine) -> *mut RuntimeSt
     unsafe { (*vm).runtime_state.cast::<RuntimeState>() }
 }
 
-/// `RareData.defaultClientSslCtx()` (Spec rare_data.zig:741) — lazy
+/// `RareData.defaultClientSslCtx()` — lazy
 /// default-trust-store client `SSL_CTX*`, shared by every `tls: true` outbound
 /// connection that didn't supply explicit options.
 ///
-/// PORT NOTE: lives here (high tier) because the storage slot
+/// Note: lives here (high tier) because the storage slot
 /// (`RareData.default_client_ssl_ctx`) is in `bun_jsc` but population requires
 /// `RuntimeState.ssl_ctx_cache` (this crate). The cached `SSL_CTX*` is held
 /// for the VM's lifetime so the weak-cache entry never tombstones.
@@ -258,8 +256,7 @@ pub(crate) unsafe fn default_client_ssl_ctx(vm: *mut VirtualMachine) -> *mut bun
 
 /// `RareData.sslCtxCache().getOrCreateOpts(opts, &err)` — RuntimeHooks slot
 /// body. Per-VM digest-keyed weak `SSL_CTX*` cache; returns +1 ref or `None`
-/// on BoringSSL rejection (`err` populated). Spec rare_data.zig
-/// `sslCtxCache().getOrCreateOpts`.
+/// on BoringSSL rejection (`err` populated).
 ///
 /// # Safety
 /// `vm` must be the live per-thread VM; called only from the JS thread.
@@ -283,9 +280,8 @@ unsafe fn ssl_ctx_cache_get_or_create(
 // RuntimeHooks bodies
 // ════════════════════════════════════════════════════════════════════════════
 
-/// `bun.api.Timer.All.init()` + `Body.Value.HiveAllocator.init()` +
-/// `configureDebugger()` — everything `VirtualMachine.init()` does that names
-/// a `bun_runtime` type. Spec VirtualMachine.zig:1313-1322.
+/// Timer state + body hive-allocator + debugger configuration — everything
+/// VM init does that names a `bun_runtime` type.
 ///
 /// Returns `Err` when `Transpiler::init` fails — most notably when the process
 /// cwd was deleted, so `getcwd` yields `ENOENT` (spec `VirtualMachine.init`
@@ -301,20 +297,19 @@ unsafe fn init_runtime_state(
     vm: *mut VirtualMachine,
     opts: &mut InitOptions,
 ) -> Result<OpaqueRuntimeState, bun_core::Error> {
-    // PORT NOTE: do NOT form `&mut *vm` here — the caller
+    // Note: do NOT form `&mut *vm` here — the caller
     // (`VirtualMachine::init`) may still hold a `&mut VirtualMachine` to the
     // same allocation. Dereference per-field via the raw `vm` ptr if needed.
 
-    // PORT NOTE: spec VirtualMachine.zig:1313 —
-    // `uws.Loop.get().internal_loop_data.jsc_vm = vm.jsc_vm` — already done by
+    // Note: `uws.Loop.get().internal_loop_data.jsc_vm = vm.jsc_vm` is already
+    // done by
     // the low tier (`VirtualMachine::init` writes it immediately before calling
     // this hook), so no uws wiring is repeated here.
 
-    // PORT NOTE: `heap::alloc` is paired with `heap::take` in
+    // Note: `heap::alloc` is paired with `heap::take` in
     // [`deinit_runtime_state`] below — called from `VirtualMachine::deinit` /
     // worker `destroy()` via the `RuntimeHooks::deinit_runtime_state` slot.
-    // Spec VirtualMachine.zig stores `timer`/`entry_point` as value fields
-    // freed in worker `destroy()`; PORTING.md §Forbidden permits
+    // PORTING.md §Forbidden permits
     // `into_raw`-without-reclaim only for true process-lifetime singletons via
     // `OnceLock`, which this is not (per-VM / per-Worker-thread).
     let state = bun_core::heap::into_raw(Box::new(RuntimeState {
@@ -327,8 +322,6 @@ unsafe fn init_runtime_state(
         editor_context: Default::default(),
         global_dns_data: core::cell::OnceCell::new(),
         entry_point: ServerEntryPoint::default(),
-        // Zig parity: spec VirtualMachine.zig:1241 threads
-        // `bun.default_allocator` (= global mimalloc) into `Transpiler.init`.
         // `borrowing_default()` wraps `mi_heap_main()` so `Transpiler`-level
         // allocations use the same heap as the global allocator and skip the
         // `mi_heap_new`/`mi_heap_destroy` pair.
@@ -338,21 +331,15 @@ unsafe fn init_runtime_state(
     }));
     RUNTIME_STATE.with(|c| c.set(state));
 
-    // `Timespec::now(.allow_mocked_time)` reads `bun_core::mock_time` directly;
+    // `Timespec::now_allow_mocked_time` reads `bun_core::mock_time` directly;
     // `FakeTimers::CurrentTime::{set,clear}` write that storage so timers
-    // scheduled under `jest.useFakeTimers()` use the mocked epoch
-    // (spec bun.zig:3223 — `getRoughTickCount` consults `FakeTimers.current_time`).
+    // scheduled under `jest.useFakeTimers()` use the mocked epoch.
 
-    // ── vm.transpiler — spec VirtualMachine.zig:1241-1246:
-    //   `Transpiler.init(allocator, log, configureTransformOptionsForBunVM(opts.args), opts.env_loader)`
+    // ── vm.transpiler ────────────────────────────────────────────────────
     // The low-tier `VirtualMachine::init` left this field as zeroed bytes
     // (see the `alloc_zeroed` note); reading it before this write is
     // validity-invariant UB, so write via `ptr::write` (NOT assignment — the
     // zeroed bytes are not a valid `Transpiler` to drop).
-    //
-    // PORT NOTE: Zig's `configureTransformOptionsForBunVM` (jsc/config.zig)
-    // has its body (3 field overwrites) inlined below over the
-    // caller-supplied `opts.transform_options`.
     // SAFETY: `vm.log` was set to a fresh leaked `Box<Log>` by
     // `VirtualMachine::init` immediately before this hook fires.
     let log: *mut bun_ast::Log = unsafe { &*vm }
@@ -378,8 +365,7 @@ unsafe fn init_runtime_state(
         args.write = Some(false);
         args.resolve = Some(api::ResolveMode::Lazy);
         args.target = Some(api::Target::Bun);
-        // PORT NOTE: Zig passed `bun.default_allocator`; the Rust struct
-        // threads `&'a Arena` (`bumpalo::Bump`). The arena lives on
+        // The arena lives on
         // `RuntimeState` (boxed above) so `deinit_runtime_state` reclaims it
         // alongside `timer`/`entry_point` on Worker teardown. The `Box`
         // payload address is stable, so a `'static` borrow is sound for the
@@ -390,7 +376,7 @@ unsafe fn init_runtime_state(
         // `Transpiler` (reclaimed in `deinit_runtime_state` after the VM —
         // and hence `vm.transpiler` — is done).
         let arena: &'static bun_alloc::Arena = unsafe { &*(*state).transpiler_arena };
-        // Spec VirtualMachine.zig:1244 — forward `opts.env_loader` so the VM
+        // Forward `opts.env_loader` so the VM
         // shares the caller's `DotEnv.Loader` (e.g. `bun test` writes
         // `NODE_ENV=test` into it after init).
         match bun_bundler::Transpiler::init(arena, log, args, opts.env_loader.map(|p| p.as_ptr())) {
@@ -398,9 +384,8 @@ unsafe fn init_runtime_state(
                 // SAFETY: `vm` is the unique freshly-boxed VM; `transpiler`
                 // field is zero-init'd uninhabited memory (never dropped).
                 unsafe { ptr::write(ptr::addr_of_mut!((*vm).transpiler), transpiler) };
-                // Spec VirtualMachine.zig:1286-1299 — post-`Transpiler.init`
-                // wiring that runs in the struct-init tail of `VirtualMachine.init`
-                // (BEFORE `JSGlobalObject.create`). `configure_linker` MUST run
+                // Post-`Transpiler.init` wiring that must run BEFORE
+                // `JSGlobalObject.create`. `configure_linker` MUST run
                 // after the `ptr::write` above so the self-referential
                 // `addr_of_mut!(self.options)` etc. captured by `Linker::init`
                 // point at the final `(*vm).transpiler` storage, not the moved-
@@ -411,7 +396,7 @@ unsafe fn init_runtime_state(
                     t.options.emit_dce_annotations = false;
                     t.resolver.store_fd = opts.store_fd;
                     t.resolver.prefer_module_field = false;
-                    // Spec VirtualMachine.zig:1291 — propagate `--preserve-symlinks`
+                    // Propagate `--preserve-symlinks`
                     // from CLI args to the resolver so symlinked node_modules
                     // entries resolve via their link path (peer deps stay reachable).
                     t.resolver.opts.preserve_symlinks = preserve_symlinks;
@@ -422,11 +407,8 @@ unsafe fn init_runtime_state(
                             bun_jsc::async_module::Queue::on_dependency_error,
                         ),
                     };
-                    // Spec: `init` calls `configureLinker()` (auto_jsx=true,
-                    // VirtualMachine.zig:1299) but `initWithModuleGraph` /
-                    // `initWorker`-with-graph call `configureLinkerWithAutoJSX(false)`
-                    // (zig:1172/1470). The Rust port routes all three through this
-                    // hook, so branch on `opts.graph` here — auto_jsx=true would
+                    // Branch on `opts.graph` here — with a module graph,
+                    // auto_jsx=true would
                     // `read_dir_info(cwd)` and cache its tsconfig.json BEFORE
                     // `apply_standalone_runtime_flags` can set
                     // `resolver.opts.load_tsconfig_json = false`, defeating
@@ -439,9 +421,7 @@ unsafe fn init_runtime_state(
                 }
             }
             Err(e) => {
-                // Spec: `try Transpiler.init(...)` bubbles the error out of
-                // `VirtualMachine.init` (VirtualMachine.zig:1241). The most
-                // common trigger is a deleted cwd → `getcwd` ENOENT
+                // The most common trigger is a deleted cwd → `getcwd` ENOENT
                 // (resolver/lib.rs). `vm.transpiler` was never written, so
                 // returning `Err` here leaves it as the zeroed bytes the low
                 // tier allocated — and the caller aborts `init` before anything
@@ -465,20 +445,18 @@ unsafe fn init_runtime_state(
         }
     }
 
-    // PORT NOTE: spec VirtualMachine.zig:1316 `if (opts.is_main_thread)
-    // bun.ParentDeathWatchdog.installOnEventLoop(jsc.EventLoopHandle.init(vm))`
+    // Note: the main-thread `ParentDeathWatchdog.installOnEventLoop` call
     // does NOT live in this hook — `init_runtime_state` fires BEFORE
     // `ensure_waker()` sets `vm.event_loop_handle`, so on macOS the kqueue
     // registration would `.expect("uws event_loop_handle is null")`-panic.
     // The call is inlined in `VirtualMachine::init` itself, immediately after
-    // the `internal_loop_data.jsc_vm` write (matching spec ordering
-    // zig:1313→1316); `bun_jsc` already depends on `bun_io` so no layering
+    // the `internal_loop_data.jsc_vm` write; `bun_jsc` already depends on
+    // `bun_io` so no layering
     // break.
 
-    // Spec VirtualMachine.zig:1321 `vm.configureDebugger(opts.debugger)` —
-    // called by `init`/`initBake`, NOT by `initWorker` (spec :1394-1491). The
-    // Rust port routes worker init through this same hook, so gate on
-    // `worker_ptr` to keep `vm.debugger == None` for workers.
+    // Worker init routes through this same hook but must not configure a
+    // debugger, so gate on `worker_ptr` to keep `vm.debugger == None` for
+    // workers.
     if opts.worker_ptr.is_null() {
         // SAFETY: `vm` is the freshly-boxed unique VM on this thread.
         unsafe { configure_debugger(vm, &opts.debugger) };
@@ -487,7 +465,7 @@ unsafe fn init_runtime_state(
     Ok(state.cast())
 }
 
-/// Spec VirtualMachine.zig:1335 `configureDebugger` — translate the CLI flag /
+/// Translate the CLI flag /
 /// `BUN_INSPECT*` env vars into `vm.debugger = Some(Debugger { .. })` so
 /// `ensure_debugger` (below) actually starts the inspector.
 ///
@@ -569,7 +547,8 @@ unsafe fn configure_debugger(
     // SAFETY: `vm` is the unique freshly-boxed VM; sole writer.
     unsafe { (*vm).debugger = Some(Box::new(debugger)) };
 
-    // Spec :1379 `if (this.isInspectorEnabled())` — always true here.
+    // The inspector is always enabled at this point, so disable the cache
+    // unconditionally.
     bun_jsc::runtime_transpiler_cache::IS_DISABLED
         .store(true, core::sync::atomic::Ordering::Relaxed);
     if mode != Mode::Connect {
@@ -587,8 +566,7 @@ unsafe fn configure_debugger(
 /// Reclaim the per-VM [`RuntimeState`] boxed in [`init_runtime_state`]. Called
 /// from `VirtualMachine::deinit` / worker `destroy()` with the opaque pointer
 /// returned by `init_runtime_state`. Clears the thread-local and drops the
-/// `Box`, freeing `timer` + `entry_point` (spec VirtualMachine.zig: value
-/// fields freed in worker `destroy()`).
+/// `Box`, freeing `timer` + `entry_point`.
 ///
 /// # Safety
 /// `state` must be the exact pointer returned by [`init_runtime_state`] for
@@ -638,10 +616,9 @@ fn generate_entry_point(_vm: &VirtualMachine, watch: bool, entry_path: &[u8]) ->
 }
 
 /// `loadPreloads()` — runs `--preload` scripts. Returns the first rejected
-/// preload promise if any, else null. Spec VirtualMachine.zig:2204-2280.
+/// preload promise if any, else null.
 ///
-/// Errors bubble exactly like Zig's `try this.loadPreloads()` in
-/// `reloadEntryPoint`: resolver `Failure` returns the resolver error,
+/// Error mapping: resolver `Failure` returns the resolver error,
 /// `Pending`/`NotFound` returns `error.ModuleNotFound`,
 /// `JSModuleLoader.import` throwing returns `error.JSError`.
 ///
@@ -650,7 +627,7 @@ fn generate_entry_point(_vm: &VirtualMachine, watch: bool, entry_path: &[u8]) ->
 unsafe fn load_preloads(
     vm: *mut VirtualMachine,
 ) -> Result<*mut JSInternalPromise, bun_core::Error> {
-    // PORT NOTE: reshaped for borrowck — `wait_for_promise` / `event_loop().tick()`
+    // Note: reshaped for borrowck — `wait_for_promise` / `event_loop().tick()`
     // need `&mut VirtualMachine` while we're also iterating `vm.preload` and
     // touching `vm.transpiler.resolver` / `vm.log`. Dereference per-field via
     // the raw `vm` ptr; iterate preloads by index (the `Box<[u8]>` payloads are
@@ -659,7 +636,7 @@ unsafe fn load_preloads(
     // ── is_in_preload guard ─────────────────────────────────────────────
     // SAFETY: per fn contract — `vm` is the live per-thread VM.
     unsafe { (*vm).is_in_preload = true };
-    // PORT NOTE: copy the raw ptr into a guard-owned local so the defer body
+    // Note: copy the raw ptr into a guard-owned local so the defer body
     // doesn't borrow the fn param — later `(*vm).pending_internal_promise = …`
     // would otherwise alias the guard's capture.
     let vm_for_guard = vm;
@@ -670,15 +647,12 @@ unsafe fn load_preloads(
 
     // SAFETY: `vm.global` is set during `VirtualMachine::init` and outlives the VM.
     let global: *mut JSGlobalObject = unsafe { &*vm }.global;
-    // `vm.transpiler` (hence `transpiler.fs`) is always initialized here: spec
-    // VirtualMachine.zig:1240 builds it with `try Transpiler.init(...)`, and the
-    // Rust port matches — `init_runtime_state` returns `Err` on `Transpiler::init`
+    // `vm.transpiler` (hence `transpiler.fs`) is always initialized here:
+    // `init_runtime_state` returns `Err` on `Transpiler::init`
     // failure and `VirtualMachine::init` propagates it via `?`, so a VM that
     // failed to build its transpiler never reaches `load_preloads` (this hook
     // only runs via `reload_entry_point*`, which operate on an already-`Ok` VM).
     let top_level_dir: *const [u8] = Fs::FileSystem::get().top_level_dir;
-    // Spec VirtualMachine.zig:2213 — `if (this.standalone_module_graph == null)
-    // .read_only else .disable`.
     // SAFETY: per fn contract.
     let global_cache = if unsafe { &*vm }.standalone_module_graph.is_none() {
         GlobalCache::read_only
@@ -696,7 +670,7 @@ unsafe fn load_preloads(
         // SAFETY: `preload` points at a live boxed slice for this iteration
         // (heap-stable `Box<[u8]>` payload; nothing below mutates `vm.preload`).
         let preload_slice: &[u8] = unsafe { &*preload };
-        // Spec VirtualMachine.zig:1865 — `normalizeSource`: strip "file://".
+        // Strip "file://".
         let normalized: &[u8] = preload_slice
             .strip_prefix(b"file://".as_slice())
             .unwrap_or(preload_slice);
@@ -714,8 +688,6 @@ unsafe fn load_preloads(
         } {
             ResolveResultUnion::Success(r) => r,
             ResolveResultUnion::Failure(e) => {
-                // Spec VirtualMachine.zig:2216-2226 — `log.addErrorFmt` then
-                // `return e`.
                 // SAFETY: `vm.log` was set to a fresh leaked `Box<Log>` by
                 // `VirtualMachine::init`.
                 if let Some(log) = unsafe { &*vm }.log {
@@ -733,8 +705,6 @@ unsafe fn load_preloads(
                 return Err(e);
             }
             ResolveResultUnion::Pending(_) | ResolveResultUnion::NotFound => {
-                // Spec VirtualMachine.zig:2228-2238 — `log.addErrorFmt` then
-                // `return error.ModuleNotFound`.
                 // SAFETY: see above.
                 if let Some(log) = unsafe { &*vm }.log {
                     // SAFETY: `log` is the unique per-VM `Box<Log>`.
@@ -752,14 +722,12 @@ unsafe fn load_preloads(
         };
 
         // ── import ──────────────────────────────────────────────────────
-        // Spec VirtualMachine.zig:2241 —
-        // `try JSModuleLoader.import(this.global, &String.fromBytes(result.path().?.text))`.
         let path_text = result
             .path()
             .expect("resolver Success result has a primary path")
             .text;
         let module_name = bun_core::String::from_bytes(path_text);
-        // PORT NOTE: use `import_ptr` (not `import`) so the `*mut` we store in
+        // Note: use `import_ptr` (not `import`) so the `*mut` we store in
         // `pending_internal_promise` keeps the FFI's mutable provenance instead
         // of being laundered through `&JSInternalPromise -> *const -> *mut`
         // (UB to write through under Stacked Borrows).
@@ -767,9 +735,9 @@ unsafe fn load_preloads(
         {
             Ok(p) => p.as_ptr(),
             Err(_) => {
-                // Spec: `try` propagates `error.JSError`. The exception is
+                // The exception is
                 // already pending on `global`; bubble the tag so
-                // `reload_entry_point` forwards it like Zig's `try`.
+                // `reload_entry_point` forwards it.
                 return Err(bun_core::err!("JSError"));
             }
         };
@@ -779,12 +747,13 @@ unsafe fn load_preloads(
         let _protected = JSValue::from_cell(promise).protected();
 
         // ── wait ────────────────────────────────────────────────────────
-        // TODO(b2-cycle): HMR `pending_internal_promise` swap loop (spec VirtualMachine.zig:2248-2261) — un-gate with `hot_reloader.rs` / ImportWatcher. Until then, fall through to the non-watcher `wait_for_promise` path below.
+        // HMR `pending_internal_promise` swap loop; non-watcher path uses
+        // `wait_for_promise` directly.
         {
             // SAFETY: per fn contract.
             if unsafe { &*vm }.is_watcher_enabled() {
                 // pending_internal_promise can change if hot module reloading is
-                // enabled (spec VirtualMachine.zig:2248-2261).
+                // enabled.
                 // SAFETY: `el` is the live per-thread event loop.
                 let el = unsafe { &*vm }.event_loop();
                 // SAFETY: `el` is the live per-thread event loop.
@@ -806,8 +775,8 @@ unsafe fn load_preloads(
                     // SAFETY: `pip` is a live JSC heap cell (see above).
                     if unsafe { &*pip }.status() == PromiseStatus::Pending {
                         // SAFETY: per fn contract — short-lived `&mut *vm` for the
-                        // dispatched `auto_tick` hook (same shape as
-                        // `wait_for_promise` below).
+                        // dispatched `auto_tick` hook (same shape as the
+                        // non-watcher `wait_for_promise` arm).
                         unsafe { (*vm).auto_tick() };
                     }
                 }
@@ -818,14 +787,6 @@ unsafe fn load_preloads(
                 // live protected JSC heap cell.
                 unsafe { (*vm).wait_for_promise(AnyPromise::Internal(promise)) };
             }
-        } // end 
-        // PORT NOTE: non-watcher fallback while the HMR loop above is gated.
-        {
-            // SAFETY: `el` is the live per-thread event loop.
-            unsafe { (*(*vm).event_loop()).perform_gc() };
-            // SAFETY: per fn contract — short-lived `&mut *vm`; `promise` is a
-            // live protected JSC heap cell.
-            unsafe { (*vm).wait_for_promise(AnyPromise::Internal(promise)) };
         }
 
         // SAFETY: `promise` is a live (still-protected) JSC heap cell.
@@ -835,13 +796,12 @@ unsafe fn load_preloads(
         // `_protected` drops here → unprotect.
     }
 
-    // Spec VirtualMachine.zig:2275-2278 — under --isolate each test file gets
+    // Under --isolate each test file gets
     // a fresh global, so preloads must re-execute for every file. Otherwise,
     // only load preloads once.
     // SAFETY: per fn contract.
     if !unsafe { &*vm }.test_isolation_enabled {
-        // PORT NOTE: Zig sets `this.preload.len = 0` (truncate without freeing
-        // the backing allocation). `Vec::clear` matches — drops the `Box<[u8]>`
+        // `Vec::clear` drops the `Box<[u8]>`
         // payloads but keeps capacity.
         // SAFETY: per fn contract — `vm` is the live per-thread VM.
         unsafe { (*vm).preload.clear() };
@@ -855,19 +815,12 @@ unsafe fn load_preloads(
 /// # Safety
 /// `vm` is the live per-thread VM.
 unsafe fn ensure_debugger(vm: *mut VirtualMachine, block_until_connected: bool) {
-    // Spec VirtualMachine.zig:2283-2290:
-    //   if (this.debugger != null) {
-    //       try jsc.Debugger.create(this, this.global);
-    //       if (block_until_connected)
-    //           jsc.Debugger.waitForDebuggerIfNecessary(this);
-    //   }
-    //
-    // PORT NOTE: `Debugger::create` / `wait_for_debugger_if_necessary` live in
+    // Note: `Debugger::create` / `wait_for_debugger_if_necessary` live in
     // `bun_jsc::debugger::Debugger` (Debugger.rs); the heavy bodies (futex
     // spin, debugger-thread spawn, deadline poll-loop) are there. This hook
     // is the literal `ensureDebugger` body — it owns the "is a debugger
     // configured?" guard and the `block_until_connected` branch, then
-    // delegates to those two fns exactly as Zig does.
+    // delegates to those two fns.
     // SAFETY: `vm` is the live per-thread VM.
     if unsafe { &*vm }.debugger.is_none() {
         return;
@@ -876,11 +829,9 @@ unsafe fn ensure_debugger(vm: *mut VirtualMachine, block_until_connected: bool)
     // the VM; read the raw ptr before forming `&mut *vm` so the two derefs
     // don't alias.
     let global = unsafe { &*vm }.global;
-    // Zig's `try` bubbles `error.{OutOfMemory,SystemResources}` (thread spawn)
-    // out of `ensureDebugger` into `reloadEntryPoint`/`loadEntryPoint`, which
-    // surfaces it as a process-level error. The hook signature is `()`, so
-    // match by logging via `Output::err` (same shape as the `Transpiler::init`
-    // error path above) and returning without blocking.
+    // `Debugger::create` can fail (OOM / thread-spawn). The hook signature is
+    // `()`, so log via `Output::err` (same shape as the `Transpiler::init`
+    // error path above) and return without blocking.
     // SAFETY: `global` is a live JSC heap cell (`JSGlobalObject`); `vm` is the
     // live per-thread VM (raw-ptr receiver — `create` re-enters JS).
     if let Err(e) = bun_jsc::debugger::Debugger::create(vm, unsafe { &*global }) {
@@ -892,16 +843,16 @@ unsafe fn ensure_debugger(vm: *mut VirtualMachine, block_until_connected: bool)
     }
 }
 
-/// `eventLoop().autoTick()` — spec event_loop.zig:364-420. Needs
+/// `eventLoop().autoTick()`. Needs
 /// `timer::All` for the poll-timeout calculation, hence dispatched here.
 ///
-/// PERF(port): was inline switch — Zig calls `vm.timer.getTimeout` directly;
-/// the one fn-ptr indirection is dwarfed by the kqueue/epoll syscall it gates.
+/// PERF: the one fn-ptr indirection is dwarfed by the kqueue/epoll syscall it
+/// gates.
 ///
 /// # Safety
 /// `vm` is the live per-thread VM.
 unsafe fn auto_tick(vm: *mut VirtualMachine) {
-    // PORT NOTE: reshaped for borrowck — `EventLoop` is a value field of
+    // Note: reshaped for borrowck — `EventLoop` is a value field of
     // `VirtualMachine`, so holding `&mut EventLoop` while also touching VM
     // siblings would alias. Dereference per-field via the raw `vm` ptr.
     // SAFETY: per fn contract — `vm` is the live per-thread VM.
@@ -910,7 +861,7 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
     let loop_ = unsafe { (*el).usockets_loop() };
 
     // ── tick_immediate_tasks ────────────────────────────────────────────
-    // Spec event_loop.zig:368-376. The swap + drain loop is now un-gated in
+    // The swap + drain loop is un-gated in
     // `bun_jsc::event_loop` (per-task body dispatched via `__bun_run_immediate_task`),
     // so `immediate_tasks` after this call reflects next-tick immediates and
     // the `has_pending_immediate` read below is correct.
@@ -925,33 +876,45 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
     // ── pending unref ───────────────────────────────────────────────────
     #[cfg(unix)]
     {
-        // SAFETY: per fn contract.
-        let pending_unref = unsafe { &*vm }.pending_unref_counter;
+        // SAFETY: per fn contract. `swap(0)` so a concurrent
+        // `increment_pending_unref_counter()` (cross-thread, see
+        // `KeepAlive::unref_on_next_tick_concurrently`) can't be lost between
+        // the read and the reset.
+        let pending_unref = unsafe { &*vm }
+            .pending_unref_counter
+            .swap(0, core::sync::atomic::Ordering::Relaxed);
         if pending_unref > 0 {
-            // SAFETY: per fn contract — sole writer on the JS thread.
-            unsafe { (*vm).pending_unref_counter = 0 };
             // SAFETY: `loop_` is the live per-thread uws loop.
             unsafe { (*loop_).unref_count(pending_unref) };
         }
     }
 
     // ── DateHeaderTimer / imminent-GC ───────────────────────────────────
-    // TODO(b2-cycle): `timer::All::update_date_header_timer_if_necessary` —
-    // not yet on the B-2 `All` surface (only insert/remove/update/get_timeout/
-    // drain_timers are real). No-op until the DateHeaderTimer body un-gates.
+    let state = runtime_state();
+    if !state.is_null() {
+        // SAFETY: `state` is the live per-thread `RuntimeState`; `loop_` is the
+        // live per-thread uws loop; `vm` per fn contract. The re-entrant
+        // `All::insert`/`update` inside `DateHeaderTimer::enable` touches only
+        // fields disjoint from `date_header_timer` (raw-ptr-per-field pattern,
+        // same as `Bun__internal_ensureDateHeaderTimerIsEnabled`).
+        unsafe {
+            (*state)
+                .timer
+                .update_date_header_timer_if_necessary(&*loop_, vm)
+        };
+    }
     // SAFETY: `el` is the live per-thread event loop.
     unsafe { (*el).run_imminent_gc_timer() };
 
     // ── poll the I/O loop with the next-timer deadline ──────────────────
-    let state = runtime_state();
     if state.is_null() {
         // No high-tier state (unit test) — fall back to a non-blocking I/O
-        // poll. Spec event_loop.zig:398-413 always polls the uws loop
+        // poll. The uws loop must always be polled
         // (`tickWithTimeout`/`tickWithoutIdle`); `EventLoop::tick()` would only
         // drain JS tasks and never touch kqueue/epoll.
         // SAFETY: `loop_` is the live per-thread uws loop.
         unsafe { (*loop_).tick_without_idle() };
-        // Spec event_loop.zig:419-420 — still run the post-poll hooks.
+        // Still run the post-poll hooks.
         // SAFETY: per fn contract.
         unsafe { (*vm).on_after_event_loop() };
         // SAFETY: `vm.global` is set during `VirtualMachine::init` and outlives the VM.
@@ -959,17 +922,17 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
         return;
     }
 
-    // Spec event_loop.zig:398-403 calls `ctx.timer.getTimeout(..)` ONLY inside
+    // Call `ctx.timer.getTimeout(..)` ONLY inside
     // `if (loop.isActive())` — `get_timeout` has side effects (pops + fires
     // due `WTFTimer` heap entries), so it must stay guarded by `is_active()`
     // rather than running unconditionally.
     {
-        // Spec Timer.zig:251-256 reads `immediate_tasks.items.len` AFTER
+        // Read `immediate_tasks` AFTER
         // `tickImmediateTasks` swaps `next_immediate_tasks` in, so this
         // reflects next-tick immediates (queued during the drain above).
         // SAFETY: `el` is the live per-thread event loop.
         let has_pending_immediate = !unsafe { &*el }.immediate_tasks.is_empty();
-        // Spec Timer.zig:261-268: fold the QUIC deadline into the poll timeout.
+        // Fold the QUIC deadline into the poll timeout.
         // SAFETY: `loop_` is the live per-thread uws loop.
         let quic_next_tick_us = unsafe {
             let ild = &(*loop_).internal_loop_data;
@@ -984,8 +947,8 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
         if unsafe { (*loop_).is_active() } {
             // SAFETY: `el` is the live per-thread event loop.
             unsafe { (*el).process_gc_timer() };
-            // PORT NOTE (§Forbidden aliased-&mut): `get_timeout` may fire a
-            // `WTFTimer` JS callback (spec Timer.zig:281 `min.fire(&now, vm)`).
+            // Note (§Forbidden aliased-&mut): `get_timeout` may fire a
+            // `WTFTimer` JS callback.
             // A re-entrant `setTimeout`/`clearTimeout` reaches
             // `timer::All::insert`/`remove` via `runtime_state()` and would
             // mint a second `&mut timer` if we held `&mut (*state).timer`
@@ -1016,7 +979,7 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
 
     #[cfg(unix)]
     {
-        // PORT NOTE (§Forbidden aliased-&mut): `drain_timers` fires user
+        // Note (§Forbidden aliased-&mut): `drain_timers` fires user
         // `setTimeout` callbacks which may re-enter `timer::All::insert`/
         // `remove` via `runtime_state()`. Pass raw `*mut Self` so no
         // long-lived `&mut (*state).timer` is held across `fire()`;
@@ -1034,7 +997,7 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
     unsafe { (*(*vm).global).handle_rejected_promises() };
 }
 
-/// `eventLoop().autoTickActive()` — spec event_loop.zig:455-493. Same shape as
+/// `eventLoop().autoTickActive()`. Same shape as
 /// [`auto_tick`] but: no `runImminentGCTimer`, no `handleRejectedPromises` at
 /// the tail, and no debug sleep-timer logging. Used by `bun_main` /
 /// `on_before_exit` drain loops where blocking when the loop is idle would
@@ -1043,7 +1006,7 @@ unsafe fn auto_tick(vm: *mut VirtualMachine) {
 /// # Safety
 /// `vm` is the live per-thread VM.
 unsafe fn auto_tick_active(vm: *mut VirtualMachine) {
-    // PORT NOTE: reshaped for borrowck — see `auto_tick` above.
+    // Note: reshaped for borrowck — see `auto_tick` above.
     // SAFETY: per fn contract — `vm` is the live per-thread VM.
     let el: *mut bun_jsc::event_loop::EventLoop = unsafe { &*vm }.event_loop;
     // SAFETY: `el` is the live per-thread event loop (field of `*vm`).
@@ -1059,20 +1022,29 @@ unsafe fn auto_tick_active(vm: *mut VirtualMachine) {
 
     #[cfg(unix)]
     {
-        // SAFETY: per fn contract.
-        let pending_unref = unsafe { &*vm }.pending_unref_counter;
+        // SAFETY: per fn contract. `swap(0)` so a concurrent
+        // `increment_pending_unref_counter()` (cross-thread, see
+        // `KeepAlive::unref_on_next_tick_concurrently`) can't be lost between
+        // the read and the reset.
+        let pending_unref = unsafe { &*vm }
+            .pending_unref_counter
+            .swap(0, core::sync::atomic::Ordering::Relaxed);
         if pending_unref > 0 {
-            // SAFETY: per fn contract — sole writer on the JS thread.
-            unsafe { (*vm).pending_unref_counter = 0 };
             // SAFETY: `loop_` is the live per-thread uws loop.
             unsafe { (*loop_).unref_count(pending_unref) };
         }
     }
 
-    // TODO(b2-cycle): `timer::All::update_date_header_timer_if_necessary` —
-    // not yet on the B-2 `All` surface (see `auto_tick` above).
-
     let state = runtime_state();
+    if !state.is_null() {
+        // SAFETY: see the matching call in `auto_tick` above.
+        unsafe {
+            (*state)
+                .timer
+                .update_date_header_timer_if_necessary(&*loop_, vm)
+        };
+    }
+
     if state.is_null() {
         // SAFETY: `loop_` is the live per-thread uws loop.
         unsafe { (*loop_).tick_without_idle() };
@@ -1099,7 +1071,7 @@ unsafe fn auto_tick_active(vm: *mut VirtualMachine) {
             // SAFETY: `el` is the live per-thread event loop.
             unsafe { (*el).process_gc_timer() };
             // SAFETY: `state` is the live per-thread `RuntimeState`; see
-            // PORT NOTE on `auto_tick` re: aliased-&mut across `fire()`.
+            // Note on `auto_tick` re: aliased-&mut across `fire()`.
             let have_timeout = unsafe {
                 timer::All::get_timeout(
                     &mut (*state).timer,
@@ -1121,7 +1093,7 @@ unsafe fn auto_tick_active(vm: *mut VirtualMachine) {
 
     #[cfg(unix)]
     {
-        // SAFETY: `state` is the live per-thread `RuntimeState`; see PORT NOTE
+        // SAFETY: `state` is the live per-thread `RuntimeState`; see Note
         // on `auto_tick` re: aliased-&mut across `fire()`.
         unsafe { timer::All::drain_timers(&mut (*state).timer, vm.cast()) };
     }
@@ -1133,15 +1105,14 @@ unsafe fn auto_tick_active(vm: *mut VirtualMachine) {
 }
 
 /// `printException` / `printErrorlikeObject` — formats `value` to stderr via
-/// `ConsoleObject::Formatter`. Spec `runErrorHandler` body
-/// (VirtualMachine.zig:2164-2188). Dispatched here so the high tier owns the
+/// `ConsoleObject::Formatter`. Dispatched here so the high tier owns the
 /// formatter.
 fn print_exception(
     vm_ref: &mut VirtualMachine,
     value: JSValue,
     exception_list: Option<&mut bun_jsc::virtual_machine::ExceptionList>,
 ) {
-    // Spec VirtualMachine.zig:2164-2188 — the print half of `runErrorHandler`
+    // The print half of `runErrorHandler`
     // (the `had_errors` save/restore lives in the low-tier caller). Route via
     // the buffered error writer; `defer writer.flush()` becomes a tail call —
     // no early returns below.
@@ -1156,7 +1127,7 @@ fn print_exception(
         vm_ref.print_exception(exception, exception_list, writer, true);
     } else {
         let mut formatter = bun_jsc::console_object::Formatter::new(global);
-        // Spec: `.error_display_level = .full` — `Formatter::new` already
+        // `Formatter::new` already
         // defaults `error_display_level` to `Full` (ConsoleObject.rs:1176).
         let colors = bun_core::Output::enable_ansi_colors_stderr();
         vm_ref.print_errorlike_object(
@@ -1174,7 +1145,7 @@ fn print_exception(
     let _ = writer.flush();
 }
 
-/// `vm.timer.insert(timer)` — Spec Timer.zig `All.insert`. The heap lives in
+/// `vm.timer.insert(timer)` — the heap lives in
 /// [`RuntimeState::timer`]; low-tier callers (`AbortSignal::Timeout`) reach it
 /// through this slot.
 ///
@@ -1209,15 +1180,15 @@ unsafe fn timer_remove(
     unsafe { &mut (*state).timer }.remove(t);
 }
 
-/// `Node.fs.NodeFS{ .vm = … }` lazy creation — Spec VirtualMachine.zig:827.
+/// `Node.fs.NodeFS{ .vm = … }` lazy creation.
 /// The low tier stores the result in `vm.node_fs: Option<*mut c_void>`.
 ///
 /// # Safety
 /// `vm` is the live per-thread VM. The returned box is reclaimed (if at all)
-/// only by VM teardown — Zig leaks it for the main VM as well.
+/// only by VM teardown.
 unsafe fn create_node_fs(vm: *mut VirtualMachine) -> *mut c_void {
     use crate::node::fs::NodeFS;
-    // Spec :829-831 — `.vm` is set only when standalone-module-graph is active
+    // `.vm` is set only when standalone-module-graph is active
     // (it gates the embedded-file `Bun.file()` lookups inside `node:fs`).
     // SAFETY: per fn contract.
     let vm_field = if unsafe { &*vm }.standalone_module_graph.is_some() {
@@ -1232,14 +1203,13 @@ unsafe fn create_node_fs(vm: *mut VirtualMachine) -> *mut c_void {
     .cast::<c_void>()
 }
 
-/// `WebCore.ObjectURLRegistry.singleton().has(specifier["blob:".len..])` —
-/// Spec VirtualMachine.zig:1760.
+/// `WebCore.ObjectURLRegistry.singleton().has(specifier["blob:".len..])`.
 fn has_blob_url(blob_id: &[u8]) -> bool {
     crate::webcore::object_url_registry::ObjectURLRegistry::singleton().has(blob_id)
 }
 
 /// `Response::get_blob_without_call_frame` /
-/// `Request::get_blob_without_call_frame` — spec Macro.zig:331-334. Downcasts
+/// `Request::get_blob_without_call_frame`. Downcasts
 /// `value` to a `Response`/`Request` (whose data shapes + `BodyMixin` impl live
 /// in this crate, above `bun_jsc` / `bun_js_parser_jsc`) and returns its body
 /// Blob wrapped in a resolved Promise; `Ok(None)` to fall through to the
@@ -1265,9 +1235,8 @@ fn body_mixin_get_blob(
     Ok(None)
 }
 
-/// `bun.api.node.process.exit(global, code)` — Spec
-/// `runtime/node/node_process.zig`. Main-thread is `noreturn`; in a worker it
-/// returns and the caller `panic!`s.
+/// `process.exit(code)`. Main-thread is `noreturn`; in a
+/// worker it returns and the caller `panic!`s.
 ///
 /// # Safety
 /// `global` is the live VM global.
@@ -1278,14 +1247,13 @@ unsafe fn process_exit(global: *mut JSGlobalObject, code: u8) {
     crate::node::process::exit(unsafe { &*global }, code);
 }
 
-/// `graph.find(path).?.sourcemap.load()` — Spec VirtualMachine.zig:3875.
+/// `graph.find(path).?.sourcemap.load()`.
 /// Reaches the concrete `bun_standalone_graph::Graph` via its `UnsafeCell`
 /// singleton accessor (proper write provenance) and lazily decodes the
 /// embedded source map for `path`. The returned `Arc` is the caller's strong
-/// ref (Zig's `map.ref()` is the `Arc::clone` the caller performs before
-/// caching it into `source_mappings`).
+/// ref.
 ///
-/// PORT NOTE: do **not** thread the `&'static dyn StandaloneModuleGraph` from
+/// Note: do **not** thread the `&'static dyn StandaloneModuleGraph` from
 /// `vm.standalone_module_graph` here and cast it to `&mut Graph` — that
 /// shared-ref provenance has no write permission, so the resulting `&mut` is
 /// instant UB under Stacked Borrows regardless of `INIT_LOCK`. `Graph::get()`
@@ -1305,8 +1273,8 @@ fn load_standalone_sourcemap(
     unsafe { (*graph).find(path)?.sourcemap.load() }
 }
 
-/// `pt.source_maps.get(filename) → pt.bundled_outputs[idx].value.asSlice()` —
-/// spec sourcemap_jsc/source_provider.zig:24. The body lives here (not in
+/// `pt.source_maps.get(filename) → pt.bundled_outputs[idx].value.asSlice()`.
+/// The body lives here (not in
 /// `bun_sourcemap_jsc`) because `PerThread` names `bun_bundler::OutputFile`;
 /// the low tier holds only the opaque pointer round-tripped through C++.
 ///
@@ -1329,10 +1297,10 @@ unsafe fn bake_per_thread_source_map(
     ))
 }
 
-/// Spec sourcemap_jsc/source_provider.zig:20 `BakeSourceProvider.getExternalData`.
+/// `BakeSourceProvider.getExternalData`.
 /// Link-time-resolved by `bun_sourcemap` (declared `extern "Rust"` there) so
 /// `SavedSourceMap::get_with_content`'s `BakeSourceProvider` branch reaches the
-/// real lookup instead of a stub — Zig had no crate split here. Returns `None`
+/// real lookup instead of a stub. Returns `None`
 /// if not running under a `Bake::GlobalObject` (caller falls back to disk read),
 /// otherwise the bundled `.map` JSON for `source_filename` (or `b""` if absent).
 #[unsafe(no_mangle)]
@@ -1364,8 +1332,8 @@ fn bake_external_sourcemap(source_filename: &[u8]) -> Option<*const [u8]> {
     Some(std::ptr::from_ref::<[u8]>(b""))
 }
 
-/// `node_cluster_binding.handleInternalMessageChild(global, data)` — Spec
-/// VirtualMachine.zig:3960 (`IPCInstance.handleIPCMessage` `.internal` arm).
+/// `node_cluster_binding.handleInternalMessageChild(global, data)` — the
+/// `IPCInstance.handleIPCMessage` `.internal` arm.
 ///
 /// # Safety
 /// `global` is the live VM global; called on the JS thread inside an
@@ -1380,13 +1348,13 @@ unsafe fn handle_ipc_internal_child(global: *mut JSGlobalObject, data: JSValue)
     let _ = crate::node::node_cluster_binding::handle_internal_message_child(global, data);
 }
 
-/// `node_cluster_binding.child_singleton.deinit()` — Spec
-/// VirtualMachine.zig:3972 (`IPCInstance.handleIPCClose`).
+/// `node_cluster_binding.child_singleton.deinit()` —
+/// `IPCInstance.handleIPCClose`.
 ///
 /// Called on the JS thread (the `CHILD_SINGLETON` static is JS-thread-only).
 fn ipc_child_singleton_deinit() {
     // `InternalMsgHolder`'s owned fields (`Strong`s, map, `Vec`) all impl
-    // `Drop`; taking the `Option` runs them — equivalent to Zig `deinit()`.
+    // `Drop`; taking the `Option` runs them.
     // SAFETY: JS-thread-only mutable static (see `child_singleton()` doc).
     unsafe {
         (*crate::node::node_cluster_binding::CHILD_SINGLETON.get()).take();
@@ -1511,10 +1479,10 @@ pub(crate) static __BUN_RUNTIME_HOOKS: RuntimeHooks = RuntimeHooks {
 };
 
 // ════════════════════════════════════════════════════════════════════════════
-// WebWorker / Debugger runtime hooks (spec web_worker.zig / Debugger.zig)
+// WebWorker / Debugger runtime hooks
 // ════════════════════════════════════════════════════════════════════════════
 
-/// `bun.bun_js.applyStandaloneRuntimeFlags(b, graph)` — spec web_worker.zig:552.
+/// Apply the standalone-executable graph's runtime flags to the transpiler.
 ///
 /// # Safety
 /// `transpiler` is the worker VM's live `&mut Transpiler` (not yet visible to
@@ -1539,11 +1507,11 @@ unsafe fn apply_standalone_runtime_flags(
     crate::run_main::apply_standalone_runtime_flags(unsafe { &mut *transpiler }, graph);
 }
 
-/// Spec web_worker.zig:445-476 — parse a Worker's `execArgv` against the
+/// Parse a Worker's `execArgv` against the
 /// `RunCommand` param table and return `!args.flag("--no-addons")`, or `None`
-/// on parse error (Zig's `catch break :parse_new_args`).
+/// on parse error.
 ///
-/// PORT NOTE: the Rust `bun_clap::parse_ex` port currently constrains
+/// Note: the Rust `bun_clap::parse_ex` port currently constrains
 /// `ArgIter<'static>` (parsed values are stored by reference), which would
 /// force leaking the per-call UTF-8 copies of `exec_argv`. Spec only ever
 /// reads the single `--no-addons` flag from the result (per the in-tree
@@ -1577,13 +1545,12 @@ unsafe fn parse_worker_exec_argv_allow_addons(
             no_addons = true;
         }
     }
-    // Spec: `transform_options.allow_addons = !args.flag("--no-addons")` —
-    // override unconditionally on successful parse.
+    // Override `allow_addons` unconditionally on successful parse.
     Some(!no_addons)
 }
 
-/// `jsc.API.cron.CronJob.clearAllForVM(vm, .teardown)` — spec
-/// web_worker.zig:727. Stops every in-process `Bun.cron()` job registered on
+/// `jsc.API.cron.CronJob.clearAllForVM(vm, .teardown)` —
+/// stops every in-process `Bun.cron()` job registered on
 /// this VM and releases the pending-promise ref so the struct frees (the event
 /// loop is dying; settle callbacks will never run).
 fn cron_clear_all_teardown(vm: &mut VirtualMachine) {
@@ -1591,8 +1558,8 @@ fn cron_clear_all_teardown(vm: &mut VirtualMachine) {
     CronJob::clear_all_for_vm::<{ ClearMode::Teardown }>(vm);
 }
 
-/// `jsc.API.cron.CronJob.clearAllForVM(vm, .reload)` — spec
-/// VirtualMachine.zig:815. Same impl as [`cron_clear_all_teardown`] but skips
+/// `jsc.API.cron.CronJob.clearAllForVM(vm, .reload)` —
+/// same impl as [`cron_clear_all_teardown`] but skips
 /// the pending-promise force-release (the event loop survives a hot reload, so
 /// settle callbacks will still run).
 fn cron_clear_all_reload(vm: &mut VirtualMachine) {
@@ -1600,8 +1567,8 @@ fn cron_clear_all_reload(vm: &mut VirtualMachine) {
     CronJob::clear_all_for_vm::<{ ClearMode::Reload }>(vm);
 }
 
-/// `webcore.WebWorker.terminateAllAndWait(timeout_ms)` — spec
-/// VirtualMachine.zig:975. Forwards to the in-crate `bun_jsc::web_worker`
+/// `webcore.WebWorker.terminateAllAndWait(timeout_ms)` —
+/// forwards to the in-crate `bun_jsc::web_worker`
 /// implementation; routed through `RuntimeHooks` because `virtual_machine.rs`
 /// sits below `web_worker.rs` in the module DAG and the wait re-enters
 /// `auto_tick` (this crate) on the worker side.
@@ -1670,8 +1637,8 @@ pub(crate) fn close_isolation_handles(vm: &mut VirtualMachine) {
     }
 }
 
-/// `TestReporterAgent.retroactivelyReportDiscoveredTests(agent)` — spec
-/// Debugger.zig:351-421. When `TestReporter.enable` arrives after test
+/// `TestReporterAgent.retroactivelyReportDiscoveredTests(agent)`.
+/// When `TestReporter.enable` arrives after test
 /// collection has started, walk the already-discovered scope tree, assign
 /// debugger test IDs, and emit `reportTestFoundWithLocation` for each.
 ///
@@ -1717,12 +1684,10 @@ unsafe fn retroactively_report_discovered_tests(agent: *mut bun_jsc::debugger::T
         &mut source_url,
     );
 
-    // Spec: `debug("retroactively reported {} tests", .{max_id})` — the scoped
-    // logger static lives in `bun_jsc::debugger`; `scoped_log!` only accepts an
-    // ident, so it can't name a foreign-crate static. Debug-only line dropped.
+    // A debug-only log of `max_id` was dropped here: `scoped_log!` only accepts
+    // an ident, so it can't name the scoped-logger static in `bun_jsc::debugger`.
     let _ = max_id;
 
-    /// Spec Debugger.zig:376 `retroactivelyReportScope`.
     fn retroactively_report_scope(
         agent: *mut TestReporterHandle,
         scope: &mut DescribeScope,
@@ -1786,7 +1751,7 @@ unsafe fn retroactively_report_discovered_tests(agent: *mut bun_jsc::debugger::T
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// ConsoleObject runtime-type hooks (spec ConsoleObject.zig)
+// ConsoleObject runtime-type hooks
 // ════════════════════════════════════════════════════════════════════════════
 
 /// `Jest.runner.?.bun_test_root.onBeforePrint()` — flush the test reporter's
@@ -1991,7 +1956,7 @@ fn console_print_runtime_object_inner<const C: bool>(
 // LoaderHooks bodies
 // ════════════════════════════════════════════════════════════════════════════
 
-/// `bun.String.createIfDifferent` — `clone_utf8(other)` unless `other` is
+/// `clone_utf8(other)` unless `other` is
 /// byte-equal to `s`, in which case bump `s`'s refcount instead.
 #[inline]
 fn create_if_different(s: &bun_core::String, other: &[u8]) -> bun_core::String {
@@ -2001,8 +1966,8 @@ fn create_if_different(s: &bun_core::String, other: &[u8]) -> bun_core::String {
     bun_core::String::clone_utf8(other)
 }
 
-/// `ModuleLoader.transpileSourceCode(...)` — the runtime-transpiler path.
-/// Port of `src/jsc/ModuleLoader.zig:85-826`: read file → `Transpiler::parse`
+/// `ModuleLoader.transpileSourceCode(...)` — the runtime-transpiler path:
+/// read file → `Transpiler::parse`
 /// → `js_printer::print` → `ResolvedSource`.
 ///
 /// # Safety
@@ -2014,7 +1979,7 @@ unsafe fn transpile_source_code(
     ret: *mut ErrorableResolvedSource,
 ) -> bool {
     // ── Recover (path, loader, module_type, printer) ────────────────────────
-    // PORT NOTE: Zig took these as positional params; the §Dispatch shim packs
+    // The §Dispatch shim packs
     // them into `args.extra`. When null (low-tier `Bun__*` shim entry), the
     // hook recomputes from `specifier` — that path is owned by `transpile_file`
     // and not exercised here, so a null `extra` is a hard error.
@@ -2033,13 +1998,13 @@ unsafe fn transpile_source_code(
         Ok(resolved) => {
             // SAFETY: per fn contract.
             unsafe { *ret = ErrorableResolvedSource::ok(resolved.into_ffi()) };
-            // PORT NOTE: spec calls `resetArena` only on the `Bun__transpileFile`
+            // Note: spec calls `resetArena` only on the `Bun__transpileFile`
             // path, never inside `transpileSourceCode` itself — the
             // `transpile_file` hook owns that. Do NOT reset here.
             true
         }
         Err(e) => {
-            // PORT NOTE: spec ModuleLoader.zig — on `error.ParseError` /
+            // Note: on `error.ParseError` /
             // `error.AsyncModule` the caller (`Bun__transpileFile`) catches and
             // routes through `processFetchLog`. Mirror that: write `.err` so the
             // low tier surfaces it; `process_fetch_log` is invoked by the
@@ -2051,10 +2016,10 @@ unsafe fn transpile_source_code(
     }
 }
 
-/// Inner body of [`transpile_source_code`] — split so the `?`-on-`Result`
-/// flow matches Zig's `try`/`!ResolvedSource` shape (ModuleLoader.zig:99).
+/// Inner body of [`transpile_source_code`] — split for `?`-on-`Result` error
+/// flow.
 ///
-/// PORT NOTE: takes `*mut VirtualMachine` (NOT `&mut`) — the body re-enters
+/// Note: takes `*mut VirtualMachine` (NOT `&mut`) — the body re-enters
 /// `vm.transpiler` while also touching `vm.module_loader` / `vm.bun_watcher`,
 /// which would alias under `&mut` (PORTING.md §Forbidden). Per-field deref via
 /// the raw ptr, mirroring `auto_tick` above.
@@ -2066,7 +2031,7 @@ fn transpile_source_code_inner(
     use Loader as L;
 
     // SAFETY: per fn contract — `extra` is a live `TranspileExtra` for the call.
-    // PORT NOTE: raw-ptr (not `&mut`) so the recursive `.wasm` arm can mutate
+    // Note: raw-ptr (not `&mut`) so the recursive `.wasm` arm can mutate
     // `extra.loader` and re-enter without borrowck seeing aliased `&mut`.
     let path: &Fs::Path = unsafe { &(*extra).path };
     // SAFETY: per fn contract — `extra` is live for the call (see above).
@@ -2080,7 +2045,6 @@ fn transpile_source_code_inner(
     let global_object = args.global_object;
 
     // ── disable_transpiling fast-path for non-JS-like loaders ───────────────
-    // Spec ModuleLoader.zig:102-112.
     if disable_transpilying
         && !(loader.is_java_script_like()
             || matches!(
@@ -2099,7 +2063,6 @@ fn transpile_source_code_inner(
     match loader {
         // ────────────────────────────────────────────────────────────────────
         // JS-like + JSON/TOML/YAML/text/md — the parse→print path.
-        // Spec ModuleLoader.zig:115-593.
         // ────────────────────────────────────────────────────────────────────
         L::Js
         | L::Jsx
@@ -2112,15 +2075,13 @@ fn transpile_source_code_inner(
         | L::Json5
         | L::Text
         | L::Md => {
-            // TODO(b2-blocked): `bun_ast::ASTMemoryAllocator::Scope` — gated in
-            // `bun_js_parser`. Spec :117-119.
-
+            // `bun_ast::ASTMemoryAllocator::Scope`.
             let mut _ast_scope = bun_ast::ast_memory_allocator::Scope::default();
             _ast_scope.enter();
 
             // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
             unsafe { (*jsc_vm).transpiled_count += 1 };
-            // Spec :122 — `Transpiler::reset_store`. Inline only the
+            // `Transpiler::reset_store`. Inline only the
             // block-store half; `AstAlloc` gets its own per-transpile state
             // below, so the side module's long-lived state is not touched.
             bun_ast::Expr::data_store_reset();
@@ -2132,7 +2093,7 @@ fn transpile_source_code_inner(
             let is_main = main.len() == path.text.len() && main_hash == hash && main == path.text;
 
             // ── Arena take/give-back ────────────────────────────────────────
-            // Spec :128-165. Reuse the per-VM arena when free; allocate a
+            // Reuse the per-VM arena when free; allocate a
             // fresh boxed one otherwise. `give_back_arena` is cleared on the
             // ParseError / AsyncModule paths (which hand the arena to the
             // async queue or leak it intentionally for the caller to inspect).
@@ -2147,8 +2108,7 @@ fn transpile_source_code_inner(
             // interior is address-stable across the move).
             let arena_heap: *mut bun_alloc::mimalloc::Heap = arena.heap_ptr();
             let give_back_arena = true;
-            // PORT NOTE: reshaped for borrowck — Zig's `defer` block becomes a
-            // scopeguard so `?`-early-returns still run it.
+            // Note: a scopeguard so `?`-early-returns still run the cleanup.
             let mut arena_guard = scopeguard::guard(
                 (jsc_vm, arena, give_back_arena, args.flags),
                 |(jsc_vm, mut arena, give_back, flags)| {
@@ -2156,27 +2116,24 @@ fn transpile_source_code_inner(
                     // on the same thread, before the hook returns).
                     let slot = unsafe { &mut (*jsc_vm).module_loader.transpile_source_code_arena };
                     if !give_back {
-                        // Spec :146-165 — when `give_back_arena == false` the
-                        // Zig `defer` is a no-op because ownership was already
-                        // transferred (to the AsyncModule queue, or held past
-                        // `processFetchLog` so log spans pointing into it stay
-                        // valid). The ParseError path that flips
-                        // `give_back=false` is LIVE (not gated): the caller
+                        // When `give_back_arena == false`, ownership is held past
+                        // `processFetchLog` so log spans pointing into the
+                        // arena stay valid. (The AsyncModule path never reaches
+                        // here: its enqueue site defuses this guard via
+                        // `ScopeGuard::into_inner` and hands the `Box<Arena>`
+                        // to the queue.) The ParseError path that flips
+                        // `give_back=false` is LIVE: the caller
                         // (`transpile_file` → `process_fetch_log`, spec
                         // :1112-1114) reads `log` entries whose spans point
                         // into arena-owned source bytes. Freeing here would be
                         // a use-after-free.
                         //
-                        // PORT NOTE: we can't widen `TranspileExtra` (lower
-                        // tier) to carry the `Box<Arena>` back, so park it in
-                        // the per-VM slot UN-reset. `transpile_file`'s
-                        // `_reset_arena` guard (`ModuleLoader::reset_arena`,
-                        // spec :1083) runs after `process_fetch_log` and
-                        // resets/reclaims it then — matching the spec lifetime.
-                        // TODO(b2-cycle): once AsyncModule un-gates, the
-                        // enqueue site must `ScopeGuard::into_inner` and hand
-                        // the `Box<Arena>` to the queue instead of reaching
-                        // here.
+                        // We can't widen `TranspileExtra` (lower tier) to carry
+                        // the `Box<Arena>` back, so park it in the per-VM slot
+                        // UN-reset. `transpile_file`'s `_reset_arena` guard
+                        // (`ModuleLoader::reset_arena`) runs after
+                        // `process_fetch_log` and resets/reclaims it then —
+                        // matching the spec lifetime.
                         *slot = Some(arena);
                         return;
                     }
@@ -2188,8 +2145,6 @@ fn transpile_source_code_inner(
                             if unsafe { (*jsc_vm).smol } {
                                 arena.reset();
                             } else {
-                                // Spec ModuleLoader.zig:155
-                                // `.reset(.{.retain_with_limit = 8M})`.
                                 // See `MimallocArena::reset_retain_with_limit`
                                 // for why this is a no-op-until-limit rather
                                 // than a bump-pointer reset (each fresh
@@ -2220,14 +2175,14 @@ fn transpile_source_code_inner(
                                 // ~6 MB anon-rw mid-run footprint that commit
                                 // bfe6056b1e8e shaved off by going to 2 MB —
                                 // accepted: the lint/create-next RSS budget has
-                                // headroom vs the Zig baseline, and the
+                                // headroom, and the
                                 // per-destroy CPU is the bigger lever.
                                 arena.reset_retain_with_limit(8 * 1024 * 1024);
                             }
                         }
                         *slot = Some(arena);
                     }
-                    // else: drop the fresh Box (spec :161-163).
+                    // else: drop the fresh Box.
                 },
             );
             // Per-transpile `AstAlloc` state spilling into the transpile
@@ -2238,11 +2193,10 @@ fn transpile_source_code_inner(
             // arena.
             let ast_alloc_scope = bun_alloc::ast_alloc::ScopedAstAlloc::with_spill(arena_heap);
             // ── Watcher fd / package_json lookup ────────────────────────────
-            // Spec :170-176.
             let mut fd: Option<bun_sys::Fd> = None;
             let mut package_json: Option<&'static bun_watcher::PackageJSON> = None;
             {
-                // SAFETY: `bun_watcher` is the type-erased `*mut ImportWatcher`
+                // SAFETY: `bun_watcher` is the `*mut ImportWatcher`
                 // set during VM init (BACKREF); cast recovers the concrete type.
                 let import_watcher: *mut bun_jsc::ImportWatcher =
                     unsafe { &*jsc_vm }.bun_watcher.cast();
@@ -2252,13 +2206,13 @@ fn transpile_source_code_inner(
                     // `flush_evictions` closes fds and `swap_remove`s), so
                     // snapshot under the watcher mutex — see
                     // `ImportWatcher::snapshot_fd_and_package_json` doc for
-                    // the EBADF race this closes (port improves on Zig spec).
+                    // the EBADF race this closes.
                     let iw = unsafe { &*import_watcher };
                     (fd, package_json) = iw.snapshot_fd_and_package_json(hash);
                 }
             }
 
-            // PORT NOTE / fix: never reuse the watcher's cached fd for the
+            // Note / fix: never reuse the watcher's cached fd for the
             // `--hot` entrypoint. An atomic `rename()` over the entrypoint (the
             // common HMR save pattern) replaces its inode; the watcher entry
             // still holds an fd to the now-unlinked old inode until the
@@ -2275,25 +2229,19 @@ fn transpile_source_code_inner(
             }
 
             // ── RuntimeTranspilerCache ──────────────────────────────────────
-            // Spec :178-182.
-            // PORT NOTE: Zig threaded `output_code_allocator = arena.allocator()`,
-            // `sourcemap_allocator = default_allocator`, `esm_record_allocator =
-            // default_allocator`. The bundler-side `cache::RuntimeTranspilerCache`
-            // dropped those fields per PORTING.md §Allocators (cache buffers use
-            // global mimalloc), so `Default::default()` matches.
             let mut cache = bun_ast::RuntimeTranspilerCache {
                 r#impl: Some(bun_ast::TranspilerCacheImplKind::Jsc),
                 ..Default::default()
             };
 
             // ── Swap `vm.transpiler.log` (and linker/resolver/pm logs) ──────
-            // Spec :184-199. `parse_maybe_return_file_only` writes diagnostics
+            // `parse_maybe_return_file_only` writes diagnostics
             // to `vm.transpiler.log`; the per-call `args.log` is what
             // `Bun__transpileFile` later passes to `process_fetch_log`
-            // (spec :1112-1114). Without this swap, parse errors land in the
+            //. Without this swap, parse errors land in the
             // VM's stale log and the user-visible error formatting reads an
             // empty buffer.
-            // PORT NOTE: `vm.transpiler` is already read live below
+            // Note: `vm.transpiler` is already read live below
             // (`.reset_store()`, `.linker`, `.log` at :338) so the original
             // "uninitialized Transpiler" gate was stale.
             // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
@@ -2325,23 +2273,20 @@ fn transpile_source_code_inner(
                 }
             });
 
-            // Spec :202.
             let is_node_override = specifier.starts_with(node_fallbacks::IMPORT_PATH);
 
-            // Spec :204-207.
             // SAFETY: per fn contract.
             let (macro_mode, has_any_macro_remappings) =
                 unsafe { ((*jsc_vm).macro_mode, (*jsc_vm).has_any_macro_remappings) };
             let macro_remappings = if macro_mode || !has_any_macro_remappings || is_node_override {
                 bun_resolver::package_json::MacroMap::default()
             } else {
-                // PORT NOTE: `MacroMap`'s value type
+                // Note: `MacroMap`'s value type
                 // (`StringArrayHashMap<Box<[u8]>>`) has only the fallible
                 // `clone() -> Result<_, AllocError>` (no trait `Clone`), so
                 // the outer map can't be `clone()`d generically. Re-key
                 // shallowly here matching `bun_bundler::transpiler` and treat
-                // the inner OOM as a process-fatal alloc failure (Zig copied
-                // the struct by value, infallibly).
+                // the inner OOM as a process-fatal alloc failure.
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread
                 // VM and `init_runtime_state` has already `ptr::write`n a
                 // real `Transpiler` into `vm.transpiler` (the `options.jsx` /
@@ -2350,7 +2295,7 @@ fn transpile_source_code_inner(
                 if src.is_empty() {
                     // Hot path: a module with no `--define`/`with { type: "macro" }`
                     // remappings skips the per-entry re-key + per-value fallible
-                    // `clone()` entirely (Zig copied the empty struct by value).
+                    // `clone()` entirely.
                     bun_resolver::package_json::MacroMap::default()
                 } else {
                     let mut m = bun_resolver::package_json::MacroMap::default();
@@ -2361,23 +2306,20 @@ fn transpile_source_code_inner(
                 }
             };
 
-            // Spec :211-215.
             let mut should_close_input_file_fd = fd.is_none();
 
-            // Spec :218-222 — only JS-like loaders get the cjs/esm wrapper hint.
+            // Only JS-like loaders get the cjs/esm wrapper hint.
             let module_type_only_for_wrappables = match loader {
                 L::Js | L::Jsx | L::Ts | L::Tsx => module_type,
                 _ => ModuleType::Unknown,
             };
 
             let mut input_file_fd = bun_sys::Fd::INVALID;
-            // Spec :251-256 `defer { if (should_close_input_file_fd and
-            // input_file_fd != .invalid) input_file_fd.close(); }` — this
-            // `defer` is unconditional in Zig (independent of `give_back_arena`)
+            // The deferred fd close is independent of `give_back_arena`
             // and must fire on every exit path: parse failure, JSON early
             // return, `disable_transpilying`, already_bundled, empty `.cjs`,
             // cache-hit, AsyncModule, the wasm recurse, and the print error.
-            // PORT NOTE: reshaped for borrowck — capture raw pointers so the
+            // Note: reshaped for borrowck — capture raw pointers so the
             // guard does not alias the parser's `file_fd_ptr` /
             // `maybe_watch_file` borrows. **All** later access to
             // `should_close_input_file_fd` / `input_file_fd` MUST go through
@@ -2386,7 +2328,7 @@ fn transpile_source_code_inner(
             // deferred `.close()` (which the parse path always reaches) UB.
             let should_close_ptr: *mut bool = &raw mut should_close_input_file_fd;
             let input_file_fd_ptr: *mut bun_sys::Fd = &raw mut input_file_fd;
-            // PORT NOTE: `scopeguard::defer!` would capture the two `*mut`
+            // Note: `scopeguard::defer!` would capture the two `*mut`
             // locals by-ref in its non-`move` closure, which borrowck then
             // treats as conflicting with the later `&mut *ptr` reborrows below
             // (edition-2021 capture analysis). Thread the raw pointers through
@@ -2410,18 +2352,12 @@ fn transpile_source_code_inner(
             );
 
             // ── Node-fallback virtual source ────────────────────────────────
-            // Spec :258-264.
             let fallback_source: bun_ast::Source;
             let mut virtual_source = args.virtual_source;
             if is_node_override {
                 if let Some(code) = node_fallbacks::contents_from_path(specifier) {
-                    // TODO(port): lifetime — `Fs::Path::init` wants `'static`;
-                    // `specifier` is `&'a [u8]`. Spec stores the `Path` in a
-                    // stack `bun_ast::Source`, so the borrow is sound for the
-                    // call. Un-gate once `Fs::Path<'a>` lands.
-
                     {
-                        // PORT NOTE: `bun_ast::Source::path` is the logger-local
+                        // `bun_ast::Source::path` is the logger-local
                         // `fs::Path` (NOT `bun_resolver::fs::Path`). `specifier`
                         // here is a `node_fallbacks` key — a `&'static [u8]`
                         // literal — so no lifetime erasure needed.
@@ -2446,30 +2382,36 @@ fn transpile_source_code_inner(
             // ════════════════════════════════════════════════════════════════
             // Transpiler::parse — the read-file step happens inside
             // `parse_maybe_return_file_only` (it opens `path` itself when
-            // `virtual_source` is `None`). Spec :225-297.
+            // `virtual_source` is `None`).
             // ════════════════════════════════════════════════════════════════
             {
                 use bun_ast::RuntimeTranspilerCache;
                 use bun_bundler::transpiler::{AlreadyBundled, ParseOptions, ParseResult};
                 use bun_jsc::resolved_source::Tag as ResolvedSourceTag;
 
-                // TODO(b2-cycle): `Debugger::set_breakpoint_on_first_line` +
-                // `runtime_transpiler_store::set_break_point_on_first_line` —
-                // gated; spec gates on `vm.debugger != null && debugger.set_...`.
-                let set_breakpoint_on_first_line = false;
-                let _ = is_main;
-
-                // PORT NOTE: `ParseOptions::path` is `bun_paths::fs::Path<'static>`
+                // Keep the one-shot
+                // `set_break_point_on_first_line()` last so it is only
+                // consumed when the other conditions hold.
+                // SAFETY: per fn contract — leaf-field `&` borrow on
+                // `(*jsc_vm).debugger` (same shape as RuntimeTranspilerStore).
+                let set_breakpoint_on_first_line = is_main
+                    && unsafe { &(*jsc_vm).debugger }
+                        .as_ref()
+                        .map(|d| d.set_breakpoint_on_first_line)
+                        .unwrap_or(false)
+                    && bun_jsc::runtime_transpiler_store::set_break_point_on_first_line();
+
+                // `ParseOptions::path` is `bun_paths::fs::Path<'static>`
                 // (the `'static`-slice flavour used by `bun_ast::Source`), but
                 // `path` here is `bun_resolver::fs::Path<'_>`. The two structs
-                // are field-identical. The resolver entry path interns into
+                // are field-identical (they could be collapsed into one type).
+                // The resolver entry path interns into
                 // `'static` BSSStringList stores, but the `transpile_file`
                 // entry path borrows a heap `Utf8Slice` that drops at frame
                 // exit — so re-intern into the same `FilenameStore` here
                 // instead of transmuting the lifetime (PORTING.md §Forbidden).
-                // TODO(refactor): collapse both `Path` defs into one type.
                 //
-                // PORT NOTE: when `disable_transpilying` is true the
+                // When `disable_transpilying` is true the
                 // `parse_result` is consumed *within this frame* (the
                 // `.print_source` / `.print_source_and_clone` early-return
                 // below reads only `source.contents` then drops it), so the
@@ -2477,8 +2419,7 @@ fn transpile_source_code_inner(
                 // does not deduplicate — leaks one path-len buffer per
                 // `Bun.inspect(new Error)` (inspect-error-leak.test.js). The
                 // borrowed path bytes outlive `parse_result` in that branch,
-                // so reuse them directly. The Zig spec passes `path` by value
-                // with no intern at all (ModuleLoader.zig:90); the intern is a
+                // so reuse them directly. The intern is a
                 // workaround for the async-module queue path only.
                 let parse_path = if disable_transpilying {
                     bun_paths::fs::Path {
@@ -2489,7 +2430,7 @@ fn transpile_source_code_inner(
                         is_symlink: path.is_symlink,
                     }
                 } else {
-                    // PORT NOTE: route through `intern_transpile_path` (dedup)
+                    // Note: route through `intern_transpile_path` (dedup)
                     // instead of `FilenameStore::append_slice` directly — see
                     // that fn's doc for the leak this closes
                     // (require-cache.test.ts "don't leak file paths").
@@ -2528,7 +2469,7 @@ fn transpile_source_code_inner(
                     // SAFETY: `input_file_fd_ptr` points at this frame's
                     // `input_file_fd`; reborrow through the raw pointer so the
                     // `_fd_guard` scopeguard's tag is not invalidated by a
-                    // fresh `&mut` (see PORT NOTE on `_fd_guard`).
+                    // fresh `&mut` (see Note on `_fd_guard`).
                     file_fd_ptr: Some(unsafe { &mut *input_file_fd_ptr }),
                     file_hash: Some(hash),
                     macro_remappings,
@@ -2560,7 +2501,7 @@ fn transpile_source_code_inner(
                     } else {
                         None
                     },
-                    // Spec :249 — strip the CJS wrapper for the eval/stdin
+                    // Strip the CJS wrapper for the eval/stdin
                     // entry point.
                     // SAFETY: `jsc_vm` is the live per-thread VM.
                     remove_cjs_module_wrapper: is_main
@@ -2569,8 +2510,7 @@ fn transpile_source_code_inner(
                     replace_exports: Default::default(),
                 };
 
-                // PORT NOTE: spec uses `comptime switch (disable_transpilying or
-                // loader == .json)` to monomorphize; both arms hit the same
+                // Both the file-only and transpiled arms hit the same
                 // `parse_maybe_return_file_only_allow_shared_buffer` body, so
                 // dispatch at runtime via the const-generic bool.
                 let return_file_only = disable_transpilying || loader == L::Json;
@@ -2591,9 +2531,9 @@ fn transpile_source_code_inner(
                 };
 
                 let Some(mut parse_result) = parse_result else {
-                    // Spec :273-295 — register with watcher even on parse failure.
+                    // Register with watcher even on parse failure.
                     if !disable_transpilying {
-                        // SAFETY: see PORT NOTE on `_fd_guard` — reborrow via
+                        // SAFETY: see Note on `_fd_guard` — reborrow via
                         // the raw pointers so the guard stays valid.
                         maybe_watch_file(
                             jsc_vm,
@@ -2610,7 +2550,7 @@ fn transpile_source_code_inner(
                     return Err(bun_core::err!("ParseError"));
                 };
 
-                // Spec :301-317 — `.wasm` discovered post-parse: recurse with
+                // `.wasm` discovered post-parse: recurse with
                 // the parsed source as virtual.
                 if parse_result.loader == L::Wasm {
                     // SAFETY: per fn contract — `extra` is live for the call;
@@ -2619,7 +2559,7 @@ fn transpile_source_code_inner(
                         (*extra).loader = L::Wasm;
                         (*extra).module_type = ModuleType::Unknown;
                     }
-                    // PORT NOTE: reshaped — spec passes `&parse_result.source`
+                    // Note: reshaped — spec passes `&parse_result.source`
                     // as `virtual_source`; we re-enter via the hook with a
                     // patched `TranspileArgs`. `TranspileArgs` is not `Copy`
                     // (`input_specifier: bun.String`), so rebuild field-wise
@@ -2640,9 +2580,9 @@ fn transpile_source_code_inner(
                     );
                 }
 
-                // Spec :319-336 — register with watcher on success too.
+                // Register with watcher on success too.
                 if !disable_transpilying {
-                    // SAFETY: see PORT NOTE on `_fd_guard` — reborrow via the
+                    // SAFETY: see Note on `_fd_guard` — reborrow via the
                     // raw pointers so the guard stays valid.
                     maybe_watch_file(
                         jsc_vm,
@@ -2656,7 +2596,6 @@ fn transpile_source_code_inner(
                     );
                 }
 
-                // Spec :338-341.
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM;
                 // `transpiler.log` was swapped to non-null `args.log` above.
                 if unsafe { (*(*jsc_vm).transpiler.log).errors > 0 } {
@@ -2666,7 +2605,7 @@ fn transpile_source_code_inner(
 
                 let source = &parse_result.source;
 
-                // Spec :343-351 — raw JSON: hand the source bytes straight to JSC.
+                // Raw JSON: hand the source bytes straight to JSC.
                 if loader == L::Json {
                     return Ok(OwnedResolvedSource::from(ResolvedSource {
                         source_code: bun_core::String::clone_utf8(&source.contents),
@@ -2677,18 +2616,14 @@ fn transpile_source_code_inner(
                     }));
                 }
 
-                // Spec :353-364 — disable_transpiling: return raw source.
+                // disable_transpiling: return raw source.
                 if disable_transpilying {
                     let source_code = match args.flags {
                         FetchFlags::PrintSourceAndClone => {
                             bun_core::String::clone_utf8(&source.contents)
                         }
                         FetchFlags::PrintSource => {
-                            // PORT NOTE: spec ModuleLoader.zig:358 borrows
-                            // (`bun.String.init`) because the bytes live in the
-                            // per-call arena, which is intentionally not reset
-                            // for `.print_source` (ModuleLoader.zig:151). The
-                            // Rust port stores file contents in a Drop-carrying
+                            // The file contents live in a Drop-carrying
                             // `source_contents_backing` on `parse_result`, so a
                             // borrow would dangle once `parse_result` drops on
                             // return. Clone instead — matches the
@@ -2705,7 +2640,7 @@ fn transpile_source_code_inner(
                     }));
                 }
 
-                // Spec :366-384 — JSON/TOML/YAML/JSON5: export as a JS object.
+                // JSON/TOML/YAML/JSON5: export as a JS object.
                 if matches!(loader, L::Json | L::Jsonc | L::Toml | L::Yaml | L::Json5) {
                     // SAFETY: `jsc_vm.global` is set during init and live for
                     // VM lifetime; `global_object` (if non-null) is the live
@@ -2750,11 +2685,9 @@ fn transpile_source_code_inner(
                     }));
                 }
 
-                // Spec :386-398 — already-bundled (bytecode cache hit).
+                // already-bundled (bytecode cache hit).
                 if !matches!(parse_result.already_bundled, AlreadyBundled::None) {
-                    // PORT NOTE: spec stores a default_allocator-owned `[]u8`
-                    // in `ResolvedSource.bytecode_cache` and lets C++ adopt it
-                    // (ModuleLoader.zig:387-398). The Rust port keeps the bytes
+                    // The bytes live
                     // in `AlreadyBundled::Bytecode(Box<[u8]>)`, which would drop
                     // when `parse_result` drops on return — UAF on the C++ side.
                     // Move the variant out and `heap::alloc` so ownership
@@ -2767,8 +2700,7 @@ fn transpile_source_code_inner(
                             if len == 0 {
                                 (core::ptr::null_mut(), 0)
                             } else {
-                                // C++ side becomes the owner (matches Zig
-                                // default_allocator semantics).
+                                // C++ side becomes the owner.
                                 (bun_core::heap::into_raw(bytes).cast::<u8>(), len)
                             }
                         }
@@ -2786,7 +2718,7 @@ fn transpile_source_code_inner(
                     }));
                 }
 
-                // Spec :400-415 — empty .cjs/.cts: synthetic `(function(){})`.
+                // Empty .cjs/.cts: synthetic `(function(){})`.
                 if parse_result.empty && matches!(loader, L::Js | L::Ts) {
                     let ext = bun_paths::extension(source.path.text);
                     if ext == b".cjs" || ext == b".cts" {
@@ -2801,7 +2733,7 @@ fn transpile_source_code_inner(
                     }
                 }
 
-                // Spec :417-466 — RuntimeTranspilerCache hit: skip print.
+                // RuntimeTranspilerCache hit: skip print.
                 // `cache.entry` is `Option<*mut ()>` (type-erased in T2
                 // `bun_js_parser`); the concrete payload is the T6
                 // `bun_jsc::runtime_transpiler_cache::Entry` boxed by
@@ -2814,7 +2746,7 @@ fn transpile_source_code_inner(
                     // in `JSC_PARSER_CACHE_VTABLE.get`; sole owner.
                     let mut entry: Box<CacheEntry> =
                         unsafe { bun_core::heap::take(entry_ptr.cast::<CacheEntry>()) };
-                    // Spec :418-421 — register the cached sourcemap so error
+                    // Register the cached sourcemap so error
                     // stacks remap to original positions even on a cache hit.
                     // SAFETY: per fn contract — `jsc_vm` is the live per-thread
                     // VM; `source_mappings` is only touched from the JS thread.
@@ -2824,21 +2756,20 @@ fn transpile_source_code_inner(
                             list: core::mem::take(&mut entry.sourcemap).into_vec(),
                         },
                     );
-                    // Spec :423-428 — under --isolate, attach the cached ESM
-                    // record so the C++ side caches a `BunTranspiledModule`
-                    // SourceProvider and later files rebuild the module record
-                    // from it instead of re-parsing the transpiled source in
-                    // every fresh global (mirrors RuntimeTranspilerStore.rs).
+                    // Rebuild the cached ESM record for the
+                    // isolation source-provider cache (same shape as
+                    // `RuntimeTranspilerStore`).
                     // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
-                    let module_info: *mut c_void = if unsafe { &*jsc_vm }
+                    let module_info: *mut core::ffi::c_void = if unsafe { &*jsc_vm }
                         .use_isolation_source_provider_cache()
                         && entry.metadata.module_type != CacheModuleType::Cjs
                         && !entry.esm_record.is_empty()
                     {
-                        bun_bundler::analyze_transpiled_module::ModuleInfoDeserialized
-                            ::create_from_cached_record(&entry.esm_record)
-                            .map(|b| bun_core::heap::into_raw(b).cast())
-                            .unwrap_or(core::ptr::null_mut())
+                        bun_bundler::analyze_transpiled_module::ModuleInfoDeserialized::create_from_cached_record(
+                            &entry.esm_record,
+                        )
+                        .map(|b| bun_core::heap::into_raw(b).cast())
+                        .unwrap_or(core::ptr::null_mut())
                     } else {
                         core::ptr::null_mut()
                     };
@@ -2851,13 +2782,12 @@ fn transpile_source_code_inner(
                         }
                     };
                     let is_commonjs_module = entry.metadata.module_type == CacheModuleType::Cjs;
-                    // Spec :448-464 — when the cached entry was detected as
+                    // When the cached entry was detected as
                     // CJS but lives inside a `"type":"module"` package, emit
                     // `package_json_type_module` so the C++ loader applies the
                     // correct evaluation context on cache hits.
                     let tag = if is_commonjs_module && source.path.is_file() {
-                        // Spec ModuleLoader.zig:449 — `package_json orelse
-                        // readDirInfo(dir)`: prefer the watcher's already-
+                        // Prefer the watcher's already-
                         // resolved `PackageJSON` (free under `--watch`/`--hot`)
                         // and only fall back to the resolver dir-info walk
                         // when the watcher had nothing for `hash`. The
@@ -2913,15 +2843,9 @@ fn transpile_source_code_inner(
                     }));
                 }
 
-                // Spec :468-479 — link import records.
+                // Link import records.
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
                 let start_count = unsafe { &*jsc_vm }.transpiler.linker.import_counter;
-                // PORT NOTE: Zig `link(path, &result, origin, .absolute_path,
-                // comptime ignore_runtime=false, comptime is_bun=true)` — the
-                // two trailing comptime bools became const-generics on
-                // `Linker::link`; `import_path_format` stayed runtime
-                // (see `linker.rs` PORT NOTE: `ImportPathFormat` is not
-                // `ConstParamTy`).
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM;
                 // `origin` is read-only and `linker` is JS-thread-exclusive.
                 unsafe {
@@ -2933,7 +2857,7 @@ fn transpile_source_code_inner(
                     )?;
                 }
 
-                // Spec :481-510 — pending imports → AsyncModule queue.
+                // Pending imports → AsyncModule queue.
                 if parse_result.pending_imports.len() > 0 {
                     // SAFETY: per fn contract — `extra` is live for the call.
                     let promise_ptr = unsafe { &*extra }.promise_ptr;
@@ -2948,7 +2872,7 @@ fn transpile_source_code_inner(
                         let buf = core::ptr::from_mut(fs_cache.shared_buffer()).cast_const();
                         // `parse_result.source.contents` borrows the detached buffer's bytes;
                         // ownership moves to the AsyncModule via the arena/parse_result, so the
-                        // swapped-out backing storage must not be freed here (Zig never freed it).
+                        // swapped-out backing storage must not be freed here.
                         let _ = core::mem::ManuallyDrop::new(fs_cache.reset_shared_buffer(buf));
                     }
 
@@ -2995,13 +2919,10 @@ fn transpile_source_code_inner(
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
                 unsafe { (*jsc_vm).transpiler.linker.import_counter = 0 };
 
-                // Spec :516-523.
                 let is_commonjs_module = parse_result.ast.has_commonjs_export_names
                     || parse_result.ast.exports_kind == bun_ast::ExportsKind::Cjs;
-                // Under --isolate, collect the printer's ESM-record analysis so
-                // the cached SourceProvider becomes a `BunTranspiledModule` and
-                // later files rebuild the module record without re-parsing
-                // (mirrors RuntimeTranspilerStore.rs).
+                // Collect the ESM record while printing, for the isolation
+                // source-provider cache (same shape as `RuntimeTranspilerStore`).
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
                 let mut module_info: Option<
                     Box<bun_bundler::analyze_transpiled_module::ModuleInfo>,
@@ -3015,36 +2936,35 @@ fn transpile_source_code_inner(
                 } else {
                     None
                 };
-                // Spec ModuleLoader.zig:523 — the printer doesn't record
-                // top-level-await; propagate it so the cached record keeps the
-                // module's evaluation-promise semantics.
+                // Propagate top-level-await to the
+                // cached module record (see the matching note in
+                // RuntimeTranspilerStore.rs for why this matters under
+                // --isolate / --parallel).
                 if let Some(mi) = module_info.as_deref_mut() {
                     mi.flags.has_tla = !parse_result.ast.top_level_await_keyword.is_empty();
                 }
-                // PORT NOTE: derive `*mut` from a `&mut` borrow (not `&x as
-                // *const _ as *mut _`, which is Stacked-Borrows UB). The
-                // `&mut` borrow ends here; the raw pointer stays valid until
-                // `module_info` is moved/touched again (after the print call).
+                // Derive the `*mut` from a `&mut` borrow (not `&x as *const _
+                // as *mut _`, which is Stacked-Borrows UB). The borrow ends
+                // here; the raw pointer stays valid until `module_info` is
+                // moved/touched again (after `print_with_source_map`).
                 let module_info_ptr: Option<
                     *mut bun_bundler::analyze_transpiled_module::ModuleInfo,
-                > = module_info.as_deref_mut().map(std::ptr::from_mut);
+                > = module_info.as_deref_mut().map(core::ptr::from_mut);
 
                 // ── js_printer::print ───────────────────────────────────────
-                // Spec :525-539.
                 // SAFETY: `extra.source_code_printer` is non-null per `TranspileExtra`
                 // contract.
-                // PORT NOTE: do NOT bind a long-lived `&mut BufferPrinter`
+                // Note: do NOT bind a long-lived `&mut BufferPrinter`
                 // here — the `source_map_handler` / `print_with_source_map`
                 // calls below each rederive `&mut *(*extra).source_code_printer`
                 // from the raw pointer, which would invalidate any earlier
                 // Unique tag under Stacked Borrows. Rederive at each use-site
                 // instead (reset, mapper, print, get_written).
                 unsafe { (*(*extra).source_code_printer).ctx.reset() };
-                // Spec :529-538 — `var mapper = jsc_vm.sourceMapHandler(&printer);
-                // … jsc_vm.transpiler.printWithSourceMap(parse_result, &printer,
-                // .esm_ascii, mapper.get(), module_info)`.
+                // Install the VM's sourcemap handler on the printer, then
+                // print the parse result (ESM, ASCII) with sourcemaps.
                 //
-                // PORT NOTE (borrowck): `source_map_handler` borrows the VM for
+                // Note (borrowck): `source_map_handler` borrows the VM for
                 // the getter's lifetime, but the print call also needs
                 // `&mut vm.transpiler` and `&mut printer`. Per the raw-ptr
                 // aliasing convention at the top of this fn (see fn-level PORT
@@ -3053,7 +2973,7 @@ fn transpile_source_code_inner(
                 // itself only stashes raw pointers (VirtualMachine.rs
                 // `SourceMapHandlerGetter`).
                 //
-                // PORT NOTE (Stacked Borrows): the printer is passed to the
+                // Note (Stacked Borrows): the printer is passed to the
                 // getter as the RAW `*mut BufferPrinter` (`source_map_handler`
                 // takes `*mut`, not `&mut`). When a debugger is attached
                 // (`mode != Connect`), `SourceMapHandlerGetter::
@@ -3086,8 +3006,9 @@ fn transpile_source_code_inner(
                             module_info_ptr,
                         )
                     };
-                    // Spec :524 `errdefer module_info.destroy()` — explicit
-                    // destroy (not Drop) mirrors the async-path error arm.
+                    // The printer never took ownership of `module_info`;
+                    // explicit destroy (not Drop) mirrors the async-path
+                    // error arm.
                     if print_result.is_err() {
                         if let Some(mi) = module_info.take() {
                             mi.destroy();
@@ -3101,7 +3022,20 @@ fn transpile_source_code_inner(
                     unsafe { (*jsc_vm).has_loaded = true };
                 }
 
-                // Spec :553-558 — watcher path uses ref-counted source.
+                // `module_info.asDeserialized()`: finalize the
+                // printer-filled record into the FFI shape consumed by C++
+                // (freed by C++ `~SourceProvider` via
+                // `zig__ModuleInfoDeserialized__deinit` — ZigSourceProvider.cpp;
+                // `ResolvedSource`/`OwnedResolvedSource` never free it, see the
+                // ownership note in ResolvedSource.rs).
+                let module_info: *mut core::ffi::c_void = module_info
+                    .map(|mi| {
+                        use bun_bundler::analyze_transpiled_module::ModuleInfoExt;
+                        bun_core::heap::into_raw(mi.into_deserialized()).cast()
+                    })
+                    .unwrap_or(core::ptr::null_mut());
+
+                // Watcher path uses ref-counted source.
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
                 if unsafe { &*jsc_vm }.is_watcher_enabled() {
                     // SAFETY: `extra.source_code_printer` is non-null per
@@ -3120,20 +3054,15 @@ fn transpile_source_code_inner(
                         )
                     };
                     resolved_source.is_commonjs_module = is_commonjs_module;
-                    resolved_source.module_info = module_info
-                        .map(|mi| {
-                            use bun_bundler::analyze_transpiled_module::ModuleInfoExt;
-                            bun_core::heap::into_raw(mi.into_deserialized()).cast()
-                        })
-                        .unwrap_or(core::ptr::null_mut());
+                    resolved_source.module_info = module_info;
                     return Ok(OwnedResolvedSource::from(resolved_source));
                 }
 
-                // Spec :561-592 — final ResolvedSource.
+                // Final ResolvedSource.
                 let tag = match loader {
                     L::Json | L::Jsonc => ResolvedSourceTag::JsonForObjectLoader,
                     L::Js | L::Jsx | L::Ts | L::Tsx => {
-                        // PORT NOTE: `bun_watcher::PackageJSON` is an opaque
+                        // Note: `bun_watcher::PackageJSON` is an opaque
                         // forward-decl of
                         // `bun_resolver::package_json::PackageJSON`; cast
                         // through to read `module_type`.
@@ -3193,11 +3122,17 @@ fn transpile_source_code_inner(
                 // does, and `r#impl` is `Some(Jsc)` here), so it is always
                 // `None`.
                 debug_assert!(cache.output_code.is_none());
+                let written_len = written.len();
                 let source_code = bun_core::String::clone_latin1(written);
+                // `printer.ctx.buffer.deinit()`: release the
+                // large/--smol print buffer now instead of holding it until the
+                // next transpile. Replacing the printer drops the old buffer
+                // (same shape as RuntimeTranspilerStore).
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
-                if written.len() > 1024 * 1024 * 2 || unsafe { &*jsc_vm }.smol {
-                    // PERF(port): spec deinits the printer buffer; Rust drops on
-                    // next `reset()`. TODO(port): expose `BufferWriter::deinit`.
+                if written_len > 1024 * 1024 * 2 || unsafe { &*jsc_vm }.smol {
+                    *printer =
+                        bun_js_printer::BufferPrinter::init(bun_js_printer::BufferWriter::init());
+                    printer.ctx.append_null_byte = false;
                 }
 
                 // (fd close handled by `_fd_guard` registered above; spec
@@ -3208,34 +3143,47 @@ fn transpile_source_code_inner(
                     specifier: input_specifier.dupe_ref(),
                     source_url: create_if_different(input_specifier, path.text),
                     is_commonjs_module,
-                    // Spec :551 — `module_info.asDeserialized()`; ownership
-                    // transfers to the `ResolvedSource` (the C++ SourceProvider
-                    // frees it via `zig__ModuleInfoDeserialized__deinit`).
-                    module_info: module_info
-                        .map(|mi| {
-                            use bun_bundler::analyze_transpiled_module::ModuleInfoExt;
-                            bun_core::heap::into_raw(mi.into_deserialized()).cast()
-                        })
-                        .unwrap_or(core::ptr::null_mut()),
+                    module_info,
                     tag,
                     ..Default::default()
                 }));
             }
         }
 
-        // Spec :595 — `provideFetch()` should be called.
+        // `provideFetch()` should be called.
         L::Napi => unreachable!("napi modules go through provideFetch()"),
 
         // ────────────────────────────────────────────────────────────────────
-        // .wasm — Spec :636-676.
+        // .wasm
         // ────────────────────────────────────────────────────────────────────
         L::Wasm => {
             // SAFETY: per fn contract.
             let main = unsafe { &*jsc_vm }.main();
             if referrer == b"undefined" && main == path.text {
-                // TODO(b2-blocked): `globalThis.wasmSourceBytes` put +
-                // `@embedFile("../js/wasi-runner.js")` — needs `ArrayBuffer::create`
-                // and a Rust `include_bytes!` of the wasi runner. Spec :638-658.
+                // Stash the WASM bytes on
+                // `globalThis.wasmSourceBytes` so the wasi runner avoids
+                // reading the file twice.
+                if let Some(source) = args.virtual_source {
+                    if !global_object.is_null() {
+                        // SAFETY: null-checked above; `global_object` is the
+                        // live per-thread global.
+                        let global = unsafe { &*global_object };
+                        // Spec — `DecodedJSValue{ .ptr = globalThis }.encode()`:
+                        // a JSGlobalObject is a JSCell, so its pointer encodes
+                        // directly as a JSValue.
+                        let global_value = bun_jsc::DecodedJSValue {
+                            u: bun_jsc::decoded_js_value::EncodedValueDescriptor {
+                                ptr: core::ptr::from_ref(global).cast_mut().cast(),
+                            },
+                        }
+                        .encode();
+                        global_value.put(
+                            global,
+                            b"wasmSourceBytes",
+                            bun_jsc::ArrayBuffer::create_uint8_array(global, &source.contents)?,
+                        );
+                    }
+                }
 
                 {
                     use bun_jsc::resolved_source::Tag as ResolvedSourceTag;
@@ -3250,7 +3198,7 @@ fn transpile_source_code_inner(
                     }));
                 }
             }
-            // Spec :661-675 — recurse as `.file`.
+            // Recurse as `.file`.
             // SAFETY: per fn contract — `extra` is live for the call.
             unsafe {
                 (*extra).loader = L::File;
@@ -3260,18 +3208,16 @@ fn transpile_source_code_inner(
         }
 
         // ────────────────────────────────────────────────────────────────────
-        // .sqlite / .sqlite_embedded — Spec :678-718.
+        // .sqlite / .sqlite_embedded
         // ────────────────────────────────────────────────────────────────────
         L::Sqlite | L::SqliteEmbedded => {
-            // SAFETY: per fn contract.
-            // Spec :680 — `jsc_vm.hot_reload == .hot`. `HotReload` is
-            // `{ none=0, hot=1, watch=2 }` (src/options_types/Context.zig:118);
-            // `!= 0` would also match `.watch`, which is wrong.
-            // TODO(b2-cycle): `hot_reload` is `cli::Command::HotReload` enum
-            // (gated as `u8`); compare to the `.hot` discriminant explicitly.
-            const HOT_RELOAD_HOT: u8 = 1;
+            // The low-tier
+            // `VirtualMachine.hot_reload` slot is a raw `u8`; compare against
+            // the real `HotReload` enum discriminant (`!= 0` would also match
+            // `.watch`, which is wrong).
             // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
-            let hot = unsafe { &*jsc_vm }.hot_reload == HOT_RELOAD_HOT;
+            let hot =
+                unsafe { &*jsc_vm }.hot_reload == bun_options_types::context::HotReload::Hot as u8;
             let sqlite_module_source_code_string: &'static [u8] = if hot {
                 SQLITE_MODULE_SOURCE_HOT
             } else {
@@ -3288,7 +3234,7 @@ fn transpile_source_code_inner(
         }
 
         // ────────────────────────────────────────────────────────────────────
-        // .html — Spec :720-743.
+        // .html
         // ────────────────────────────────────────────────────────────────────
         L::Html => {
             if disable_transpilying {
@@ -3318,7 +3264,7 @@ fn transpile_source_code_inner(
         }
 
         // ────────────────────────────────────────────────────────────────────
-        // Everything else — Spec :745-825 (file loader: `export default <path>`).
+        // Everything else — file loader: `export default <path>`.
         // ────────────────────────────────────────────────────────────────────
         _ => {
             if disable_transpilying {
@@ -3332,7 +3278,7 @@ fn transpile_source_code_inner(
                 }));
             }
 
-            // Spec :756-803 — auto-watch for non-virtual absolute paths.
+            // auto-watch for non-virtual absolute paths.
             'auto_watch: {
                 if args.virtual_source.is_some() {
                     break 'auto_watch;
@@ -3362,7 +3308,7 @@ fn transpile_source_code_inner(
                     bun_sys::Fd::INVALID
                 };
                 let hash = bun_watcher::Watcher::get_hash(path.text);
-                // SAFETY: `bun_watcher` is the type-erased `*mut ImportWatcher`
+                // SAFETY: `bun_watcher` is the `*mut ImportWatcher`
                 // set when `is_watcher_enabled()`; cast recovers the concrete
                 // type.
                 let watcher =
@@ -3378,7 +3324,7 @@ fn transpile_source_code_inner(
                     )
                     .is_err()
                 {
-                    // Spec :785-799 — close the fd we just opened on macOS;
+                    // Close the fd we just opened on macOS;
                     // not a transpile failure (the user didn't open it).
                     #[cfg(target_os = "macos")]
                     if input_fd.is_valid() {
@@ -3388,12 +3334,12 @@ fn transpile_source_code_inner(
                 }
             }
 
-            // Spec :805-823 — `export default <path string>`.
+            // `export default <path string>`.
             use bun_jsc::resolved_source::Tag as ResolvedSourceTag;
             if global_object.is_null() {
                 return Err(bun_core::err!("NotSupported"));
             }
-            // PORT NOTE: tier-6 ctor lives in `bun_jsc::bun_string_jsc` (not on
+            // Note: tier-6 ctor lives in `bun_jsc::bun_string_jsc` (not on
             // `bun_core::String`, which is tier-2); calls
             // `BunString__createUTF8ForJS` under the hood.
             // SAFETY: null-checked above; `global_object` is the live per-thread
@@ -3401,7 +3347,7 @@ fn transpile_source_code_inner(
             let global = unsafe { &*global_object };
             // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
             let value = if !unsafe { &*jsc_vm }.origin.is_empty() {
-                // Spec :805-815 — rewrite `specifier` against `vm.origin` so
+                // Rewrite `specifier` against `vm.origin` so
                 // importing an asset via the file loader yields the public URL,
                 // not the absolute filesystem path.
                 let mut buf = std::string::String::new();
@@ -3411,7 +3357,7 @@ fn transpile_source_code_inner(
                 // need to copy the ~12 borrowed slices out (perf: was a
                 // per-asset-import `url::URL::clone`).
                 let origin = unsafe { &(*jsc_vm).origin };
-                // PORT NOTE: `jsc.API.Bun.getPublicPath` is gated behind a
+                // Note: `jsc.API.Bun.getPublicPath` is gated behind a
                 // private `_jsc_gated` mod in BunObject.rs; it is a thin
                 // wrapper over `get_public_path_with_asset_prefix` with
                 // `dir = VM.top_level_dir`, `asset_prefix = ""`, `.loose`.
@@ -3442,9 +3388,9 @@ fn transpile_source_code_inner(
     }
 }
 
-/// Spec ModuleLoader.zig:273-291 / :319-336 — register the just-opened file
+/// Register the just-opened file
 /// with the dev-server watcher (if enabled, absolute, and not in
-/// `node_modules`). Factored out because the spec inlines it twice.
+/// `node_modules`). Factored out of the two call sites.
 #[inline]
 #[allow(clippy::too_many_arguments)]
 fn maybe_watch_file(
@@ -3471,7 +3417,7 @@ fn maybe_watch_file(
         return;
     }
     *should_close_input_file_fd = false;
-    // SAFETY: `bun_watcher` is the type-erased `*mut ImportWatcher` set when
+    // SAFETY: `bun_watcher` is the `*mut ImportWatcher` set when
     // `is_watcher_enabled()`; cast recovers the concrete type.
     let watcher = unsafe { &mut *(*jsc_vm).bun_watcher.cast::<bun_jsc::ImportWatcher>() };
     let _ = watcher.add_file::<true>(
@@ -3484,7 +3430,7 @@ fn maybe_watch_file(
     );
 }
 
-// Spec ModuleLoader.zig:681-708 — generated `bun:sqlite` import shims.
+// Generated `bun:sqlite` import shims.
 const SQLITE_MODULE_SOURCE_HOT: &[u8] = b"\
 // Generated code
 import {Database} from 'bun:sqlite';
@@ -3513,14 +3459,13 @@ export const __esModule = true;
 export default db;
 ";
 
-/// `ModuleLoader.zig` `jsSyntheticModule(tag, specifier)` — produce a
+/// `jsSyntheticModule(tag, specifier)` — produce a
 /// `ResolvedSource` whose `tag` indexes into the C++ `InternalModuleRegistry`
 /// (the embedded JS modules from `src/js/`). No source text — C++ dispatches
 /// on `.tag` alone.
 ///
-/// PORT NOTE: `name` is the canonical specifier string (e.g. `b"node:fs"`).
-/// Zig threads `ResolvedSource.Tag.@"node:fs"` (a generated `u32` enum); the
-/// Rust side carries the string and resolves to the numeric tag via
+/// Note: `name` is the canonical specifier string (e.g. `b"node:fs"`),
+/// resolved to the numeric tag via
 /// `Tag::from_name` (PHF over the codegen table in `bun_jsc::resolved_source_tag`).
 #[inline]
 fn js_synthetic_module(name: &'static [u8], specifier: &bun_core::String) -> OwnedResolvedSource {
@@ -3535,7 +3480,7 @@ fn js_synthetic_module(name: &'static [u8], specifier: &bun_core::String) -> Own
     })
 }
 
-/// `ModuleLoader.zig` `getHardcodedModule(jsc_vm, specifier, hardcoded)` —
+/// `getHardcodedModule(jsc_vm, specifier, hardcoded)` —
 /// the per-variant body of the builtin-module fast path. Returns `None` when
 /// the variant is recognised but not currently servable (e.g. `bun:main`
 /// before `ServerEntryPoint::generate` has run, or `bun:internal-for-testing`
@@ -3545,15 +3490,15 @@ fn get_hardcoded_module(
     specifier: &bun_core::String,
     hardcoded: HardcodedModule,
 ) -> Option<OwnedResolvedSource> {
-    // TODO(b2-cycle): `bun_analytics::Features::builtin_modules.insert(hardcoded)`
-    // — the `EnumSet<HardcodedModule>` static lives in T5 (`bun_resolve_builtins`)
-    // and is not yet wired into `bun_analytics`.
+    // The analytics-side set stores `&'static str` names
+    // (cycle break — see `bun_analytics::features::BUILTIN_MODULES`), so feed
+    // it the `strum::IntoStaticStr` tag name.
+    bun_analytics::features::insert_builtin_module(<&'static str>::from(hardcoded));
 
     match hardcoded {
         HardcodedModule::BunMain => {
             // Synthetic `bun:main` wrapper — pulls source from this thread's
-            // `RuntimeState.entry_point` (the high-tier home for what Zig
-            // stores as `vm.entry_point`).
+            // `RuntimeState.entry_point`.
             let state = runtime_state();
             if state.is_null() {
                 return None;
@@ -3590,21 +3535,15 @@ fn get_hardcoded_module(
         HardcodedModule::BunWrap => {
             // `Runtime.Runtime.sourceCode()` — the bundler's CJS-interop
             // shim, embedded as a static string in `bun_ast::runtime`.
-
-            // TODO(b2-cycle): `Runtime::source_code()` — `bun_ast::runtime`
-            // is a stub re-export until `runtime.rs` un-gates there.
-            {
-                return Some(OwnedResolvedSource::from(ResolvedSource {
-                    source_code: bun_core::String::init(bun_ast::runtime::Runtime::source_code()),
-                    // +1 each: ~SourceProvider() derefs both.
-                    specifier: specifier.dupe_ref(),
-                    source_url: specifier.dupe_ref(),
-                    ..ResolvedSource::default()
-                }));
-            }
+            return Some(OwnedResolvedSource::from(ResolvedSource {
+                source_code: bun_core::String::init(bun_ast::runtime::Runtime::source_code()),
+                // +1 each: ~SourceProvider() derefs both.
+                specifier: specifier.dupe_ref(),
+                source_url: specifier.dupe_ref(),
+                ..ResolvedSource::default()
+            }));
         }
-        // Zig: `inline else => |tag| jsSyntheticModule(@field(ResolvedSource.Tag, @tagName(tag)), specifier)`
-        // — every other `HardcodedModule` is served straight out of the
+        // Every other `HardcodedModule` is served straight out of the
         // InternalModuleRegistry by tag, with no Rust-side source text.
         other => {
             let name: &'static str = other.into();
@@ -3614,9 +3553,8 @@ fn get_hardcoded_module(
 }
 
 /// `ModuleLoader.fetchBuiltinModule(jsc_vm, specifier)` — `HardcodedModule`
-/// lookup + macro-namespace + standalone-module-graph probe. Port of
-/// `src/jsc/ModuleLoader.zig:1173` `fetchBuiltinModule` and the
-/// `Bun__fetchBuiltinModule` export wrapper at :850.
+/// lookup + macro-namespace + standalone-module-graph probe; also covers the
+/// `Bun__fetchBuiltinModule` export wrapper.
 ///
 /// # Safety
 /// `jsc_vm` is the live per-thread VM; `out` is a valid out-param.
@@ -3627,9 +3565,7 @@ unsafe fn fetch_builtin_module(
     _referrer: &bun_core::String,
     out: *mut ErrorableResolvedSource,
 ) -> FetchBuiltinResult {
-    // PORT NOTE: Zig's `getWithEql(specifier, bun.String.eqlComptime)` walks
-    // the comptime map comparing each key against the (possibly UTF-16)
-    // `bun.String`. The PHF map keys on `&[u8]`, so transcode once up-front;
+    // The PHF map keys on `&[u8]`, so transcode once up-front;
     // builtin specifiers are short ASCII so `to_utf8()` is borrow-only in
     // the common case (`ZigStringSlice` drops without freeing).
     let spec_utf8 = specifier.to_utf8();
@@ -3644,13 +3580,13 @@ unsafe fn fetch_builtin_module(
                 FetchBuiltinResult::Found
             }
             // Recognised builtin but not servable right now → fall through
-            // to filesystem resolution (matches Zig `orelse return false`).
+            // to filesystem resolution.
             None => FetchBuiltinResult::NotFound,
         };
     }
 
     // ── `macro:` namespace ──────────────────────────────────────────────
-    // Spec ModuleLoader.zig:1178-1186. `vm.macro_entry_points` values are
+    // `vm.macro_entry_points` values are
     // `*mut MacroEntryPoint` (gated `bun_bundler::entry_points` type); the
     // map itself is keyed by `i32` hash of the specifier.
     if spec.starts_with(b"macro:") {
@@ -3677,7 +3613,7 @@ unsafe fn fetch_builtin_module(
     }
 
     // ── Standalone-module-graph probe ───────────────────────────────────
-    // Spec ModuleLoader.zig:1189-1228. The VM field is the resolver's
+    // The VM field is the resolver's
     // read-only `&dyn StandaloneModuleGraph`; for `File::to_wtf_string`
     // (mutates the lazy `wtf_string` cache) we need write provenance, so
     // reach the concrete `Graph` via its `UnsafeCell` singleton accessor —
@@ -3695,7 +3631,7 @@ unsafe fn fetch_builtin_module(
             use bun_standalone_graph::StandaloneModuleGraph::ModuleFormat;
 
             if matches!(file.loader, Loader::Sqlite | Loader::SqliteEmbedded) {
-                // Spec ModuleLoader.zig:1193-1202 — distinct from
+                // Distinct from
                 // [`SQLITE_MODULE_SOURCE`]: the standalone-binary path reads
                 // the embedded blob via `readFileSync(import.meta.path)`
                 // (resolved through the `/$bunfs/` virtual root).
@@ -3767,8 +3703,8 @@ export default db;
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// `Bun__transpileFile` helpers — local ports of `options.normalizeSpecifier` /
-// `options.getLoaderAndVirtualSource` (spec bundler/options.zig:909-1040).
+// `Bun__transpileFile` helpers — local copies of `options.normalizeSpecifier` /
+// `options.getLoaderAndVirtualSource`.
 //
 // The canonical Rust port (`bun_bundler::options::get_loader_and_virtual_source`)
 // is ``-gated behind a `VmLoaderCtx` vtable that nothing
@@ -3780,8 +3716,7 @@ export default db;
 // `StringArrayHashMap<bun_ast::Loader>`), so no inter-enum bridge is required.
 // ────────────────────────────────────────────────────────────────────────────
 
-/// `bun.options.Loader.Optional.fromAPI` (spec options.zig) — maps the wire
-/// `bun.schema.api.Loader` (`#[repr(u8)]`, `_none = 254`) discriminant that
+/// Maps the wire `Api::Loader` (`#[repr(u8)]`, `_none = 254`) discriminant that
 /// crosses the C++ boundary as `force_loader: u8` to the runtime
 /// `bun_ast::Loader`. Exhaustive match (any unknown tag — including 0, which
 /// `api::Loader` never uses — collapses to `None`).
@@ -3810,14 +3745,13 @@ fn force_loader_from_api_u8(api_loader: u8) -> Option<Loader> {
         19 => Some(L::Yaml),
         20 => Some(L::Json5),
         21 => Some(L::Md),
-        // 254 = `_none`; everything else is open-tail per schema.zig:325.
+        // 254 = `_none`; everything else is open-tail.
         _ => None,
     }
 }
 
 /// `Fs.Path.loader(&jsc_vm.transpiler.options.loaders)` — re-spelt against
 /// `bun_ast::LoaderHashTable` (= `StringArrayHashMap<bun_ast::Loader>`).
-/// Spec resolver/fs.zig `Path.loader`.
 fn loader_for_path(path: &Fs::Path<'_>, loaders: &bun_ast::LoaderHashTable) -> Option<Loader> {
     if path.is_data_url() {
         return Some(Loader::Dataurl);
@@ -3846,7 +3780,7 @@ fn loader_for_path(path: &Fs::Path<'_>, loaders: &bun_ast::LoaderHashTable) -> O
 }
 
 /// `options.normalizeSpecifier(jsc_vm, slice)` — strip the VM's origin
-/// host/path prefix and split off the `?query`. Spec options.zig:909-941.
+/// host/path prefix and split off the `?query`.
 ///
 /// # Safety
 /// `jsc_vm` is the live per-thread VM.
@@ -3879,7 +3813,7 @@ unsafe fn normalize_specifier_for_loader<'a>(
 }
 
 /// Result of [`get_loader_and_virtual_source`] — mirrors
-/// `options.LoaderResult` (options.zig:944-953).
+/// `options.LoaderResult`.
 struct LoaderResult<'a> {
     loader: Option<Loader>,
     virtual_source: Option<&'a bun_ast::Source>,
@@ -3890,8 +3824,8 @@ struct LoaderResult<'a> {
     package_json: Option<&'a bun_resolver::package_json::PackageJSON>,
 }
 
-/// `options.getLoaderAndVirtualSource` — high-tier body. Spec
-/// options.zig:955-1040. Named `*mut VirtualMachine` directly per the §Dispatch
+/// `options.getLoaderAndVirtualSource` — high-tier body.
+/// Named `*mut VirtualMachine` directly per the §Dispatch
 /// note above (no `VmLoaderCtx` vtable).
 ///
 /// # Safety
@@ -3914,10 +3848,10 @@ unsafe fn get_loader_and_virtual_source<'a>(
         loader_for_path(&path, unsafe { &(*jsc_vm).transpiler.options.loaders });
     let mut virtual_source: Option<&'a bun_ast::Source> = None;
 
-    // Spec :971-979 — synthetic `[eval]`/`[stdin]` source.
+    // Synthetic `[eval]`/`[stdin]` source.
     // SAFETY: per fn contract.
     if let Some(eval_source) = unsafe { &*jsc_vm }.module_loader.eval_source.as_deref() {
-        // PORT NOTE: `bun.pathLiteral("/[eval]")` is `\\[eval]` on Windows; the
+        // Note: the suffix is `\\[eval]` on Windows; the
         // separator-agnostic `Path::sep_any()` check matches both.
         const EVAL: &[u8] = b"[eval]";
         const STDIN: &[u8] = b"[stdin]";
@@ -3935,7 +3869,7 @@ unsafe fn get_loader_and_virtual_source<'a>(
         }
     }
 
-    // Spec :981-1007 — `blob:` ObjectURL → in-memory virtual source.
+    // `blob:` ObjectURL → in-memory virtual source.
     if crate::webcore::object_url_registry::is_blob_url(specifier) {
         match crate::webcore::object_url_registry::ObjectURLRegistry::singleton()
             .resolve_and_dupe(&specifier[b"blob:".len()..])
@@ -3954,7 +3888,7 @@ unsafe fn get_loader_and_virtual_source<'a>(
                 if let Some(filename) = blob.get_file_name() {
                     // Only treat it as a file if it is a `Bun.file()`.
                     if blob.needs_to_read_file() {
-                        // PORT NOTE: borrowck — `Fs::Path<'a>` borrows
+                        // Note: borrowck — `Fs::Path<'a>` borrows
                         // `filename`, which borrows `*blob_to_deinit`. The
                         // caller owns that slot for `'a`, so erase via raw ptr.
                         // SAFETY: `filename` borrows the blob's backing store,
@@ -3982,7 +3916,7 @@ unsafe fn get_loader_and_virtual_source<'a>(
                         )
                     };
                     *virtual_source_to_use = Some(bun_ast::Source {
-                        // PORT NOTE: `bun_ast::Source::path` is the
+                        // Note: `bun_ast::Source::path` is the
                         // logger-local `fs::Path` (NOT `bun_resolver::fs::Path`
                         // — see logger/lib.rs:32-). Re-init from `path.text`.
                         path: bun_paths::fs::Path::init(path_text),
@@ -3996,7 +3930,6 @@ unsafe fn get_loader_and_virtual_source<'a>(
         }
     }
 
-    // Spec :1009-1015.
     if query == b"?raw" {
         loader = Some(Loader::Text);
     }
@@ -4009,7 +3942,7 @@ unsafe fn get_loader_and_virtual_source<'a>(
     // SAFETY: per fn contract.
     let is_main = specifier == unsafe { &*jsc_vm }.main();
 
-    // Spec :1019-1031 — package.json sniff for `.js`/`.ts` module-type.
+    // package.json sniff for `.js`/`.ts` module-type.
     let dir = path.name().dir;
     let is_js_like = loader.map(|l| l.is_java_script_like()).unwrap_or(true);
     let package_json = if is_js_like && bun_paths::is_absolute(dir) {
@@ -4034,14 +3967,13 @@ unsafe fn get_loader_and_virtual_source<'a>(
 }
 
 thread_local! {
-    /// `pub threadlocal var source_code_printer: ?*js_printer.BufferPrinter`
-    /// (spec VirtualMachine.zig:1584). Lazy-init in [`transpile_file`] per
-    /// VirtualMachine.zig:489-494; never freed (process-lifetime singleton —
+    /// Per-thread shared `BufferPrinter`. Lazy-init in [`transpile_file`];
+    /// never freed (process-lifetime singleton —
     /// PORTING.md §Forbidden permits the leak for true thread-local singletons).
     static TRANSPILE_PRINTER: Cell<*mut bun_js_printer::BufferPrinter> =
         const { Cell::new(ptr::null_mut()) };
 
-    /// Dedup cache for [`intern_transpile_path`] — see that fn's PORT NOTE.
+    /// Dedup cache for [`intern_transpile_path`] — see that fn's Note.
     /// `&'static [u8]` keys point into the `FilenameStore` BSS singleton, so
     /// the set itself owns nothing beyond its bucket array.
     static TRANSPILE_PATH_INTERN: core::cell::RefCell<
@@ -4054,9 +3986,8 @@ thread_local! {
 /// equal bytes return the same backing slice instead of appending a fresh
 /// copy each time.
 ///
-/// PORT NOTE: the Zig spec passes `path: Fs.Path` by value into
-/// `transpileSourceCode` with no intern (ModuleLoader.zig:90); the
-/// `bun_paths::fs::Path<'static><'static>` shape forced the Rust port to re-intern on
+/// Note: the
+/// `bun_paths::fs::Path<'static><'static>` shape forces a re-intern on
 /// every call. `BSSStringList::append` does not dedupe, so a `require()`
 /// loop that busts `require.cache` (test/cli/run/require-cache.test.ts —
 /// "files transpiled and loaded don't leak file paths") leaked one path-len
@@ -4071,7 +4002,7 @@ thread_local! {
 /// before this point, and a re-entrant transpile of an arena-resident path
 /// just round-trips its own prior result. For those, skip the content hash and
 /// `HashSet` probe/insert entirely: a pointer-range compare against the store's
-/// backing buffer (`FilenameStore::exists`, == Zig `isSliceInBuffer`) proves
+/// backing buffer (`FilenameStore::exists`) proves
 /// the bytes are already `'static`, so we can widen and return them directly.
 /// Only genuinely-foreign slices (heap-backed `bun.String::to_utf8` views, the
 /// rare overflow-block case) fall back to the dedup map. This is ~0.7%
@@ -4099,12 +4030,12 @@ fn intern_transpile_path(value: &[u8]) -> &'static [u8] {
     })
 }
 
-/// Spec ModuleLoader.zig:879 `const always_sync_modules = .{"reflect-metadata"};`.
+/// Modules that must always transpile on-thread (see [`transpile_file`]).
 const ALWAYS_SYNC_MODULES: &[&[u8]] = &[b"reflect-metadata"];
 
 /// `Bun__transpileFile` body — concurrent-transpiler entry. Returns the
 /// in-flight `JSInternalPromise*` when `allow_promise && async`, else null
-/// (result is in `*ret`). Spec ModuleLoader.zig:881-1120.
+/// (result is in `*ret`).
 ///
 /// PERF: this is the per-`require()` / per-`import` hot-loop root. Its call
 /// chain (-> `parse_maybe_return_file_only_allow_shared_buffer` ->
@@ -4140,27 +4071,25 @@ unsafe fn transpile_file(
 
     let force_loader_type: Option<Loader> = force_loader_from_api_u8(force_loader);
 
-    // Spec :895 — `var log = logger.Log.init(jsc_vm.transpiler.allocator)`.
-    // PORT NOTE: per §Allocators the explicit allocator threads are dropped.
+    // Create a fresh parse log.
+    // Note: per §Allocators the explicit allocator threads are dropped.
     let log = bun_ast::Log::init();
-    // PORT NOTE: reshaped for borrowck — Zig `defer log.deinit()` becomes a
-    // scopeguard so every `return null` path still frees the msg vec.
+    // Note: a scopeguard so every `return null` path still frees the msg vec.
     let mut log = scopeguard::guard(log, |mut l| {
         l.msgs.clear();
     });
 
-    // Spec :897-900 — UTF-8 views over the WTF-backed `bun.String` inputs.
+    // UTF-8 views over the WTF-backed `bun.String` inputs.
     // SAFETY: per fn contract — both pointers are valid for the call.
     let _specifier = unsafe { &*specifier_ptr }.to_utf8();
     // SAFETY: per fn contract — `referrer` is valid for the call.
     let referrer_slice = unsafe { &*referrer }.to_utf8();
 
-    // Spec :902-905 — `type_attribute` may be null (no `with { type }`).
+    // `type_attribute` may be null (no `with { type }`).
     // SAFETY: per fn contract — null or a live `bun.String*`.
     let type_attribute_str: Option<&[u8]> =
         unsafe { type_attribute.as_ref() }.and_then(|s| s.as_utf8());
 
-    // Spec :907-913.
     let mut virtual_source_to_use: Option<bun_ast::Source> = None;
     let mut blob_to_deinit: Option<crate::webcore::Blob> = None;
     // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
@@ -4175,7 +4104,6 @@ unsafe fn transpile_file(
     } {
         Ok(lr) => lr,
         Err(_) => {
-            // Spec :910-912 — `ERR(.MODULE_NOT_FOUND, "Blob not found")`.
             let js = global_ref
                 .err(
                     bun_jsc::ErrCode::ERR_MODULE_NOT_FOUND,
@@ -4189,10 +4117,10 @@ unsafe fn transpile_file(
             return ptr::null_mut();
         }
     };
-    // Spec :914 — `defer if (blob_to_deinit) |*blob| blob.deinit()`.
-    // PORT NOTE: reshaped for borrowck — capture the `is_some()` flag *before*
+    // Deinit the blob (if any) on scope exit.
+    // Note: reshaped for borrowck — capture the `is_some()` flag *before*
     // moving the option into the scopeguard so the `transpile_async` predicate
-    // (spec :980) can still read it without aliasing the guard's `&mut`.
+    // can still read it without aliasing the guard's `&mut`.
     let had_blob = blob_to_deinit.is_some();
     let _blob_guard = scopeguard::guard(blob_to_deinit, |mut slot| {
         if let Some(mut blob) = slot.take() {
@@ -4201,9 +4129,8 @@ unsafe fn transpile_file(
     });
 
     // ── force_loader / require.extensions override ──────────────────────────
-    // Spec :915-939.
     if let Some(loader_type) = force_loader_type {
-        // PORT NOTE: `@branchHint(.unlikely)` dropped (no stable Rust equiv).
+        // Note: `@branchHint(.unlikely)` dropped (no stable Rust equiv).
         debug_assert!(!is_commonjs_require);
         lr.loader = Some(loader_type);
     } else if is_commonjs_require
@@ -4236,7 +4163,6 @@ unsafe fn transpile_file(
     }
 
     // ── module_type sniff from extension / package.json ─────────────────────
-    // Spec :941-969.
     let module_type: ModuleType = 'brk: {
         let ext = lr.path.name().ext;
         // regex /\.[cm][jt]s$/
@@ -4270,12 +4196,10 @@ unsafe fn transpile_file(
         .and_then(|pkg| (!pkg.name.is_empty()).then_some(&*pkg.name));
 
     // ── Concurrent-transpiler dispatch (`transpile_async:` block) ───────────
-    // Spec :975-1028. We only run the transpiler concurrently when we can.
+    // We only run the transpiler concurrently when we can.
     // Today that's: import statements (`import 'foo'`) and import expressions
     // (`import('foo')`).
     'transpile_async: {
-        // PORT NOTE: `comptime bun.FeatureFlags.concurrent_transpiler` — no
-        // Rust mirror yet, but the feature is unconditionally on in Zig builds.
         let concurrent_loader = lr.loader.unwrap_or(Loader::File);
         // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
         let (has_loaded, is_in_preload, plugin_runner_is_none, store_enabled) = unsafe {
@@ -4296,7 +4220,7 @@ unsafe fn transpile_file(
             && plugin_runner_is_none
             && store_enabled
         {
-            // Disgusting workaround (spec :993-1018): polyfills like
+            // Disgusting workaround: polyfills like
             // `reflect-metadata` are CJS-with-side-effects that other ESM
             // depends on synchronously, so they must transpile on-thread.
             if let Some(pkg_name_) = pkg_name {
@@ -4307,7 +4231,6 @@ unsafe fn transpile_file(
                 }
             }
 
-            // Spec :1022-1028.
             // SAFETY: per fn contract — `jsc_vm` / `specifier_ptr` / `referrer`
             // are valid for the call. `lr.path` borrows `_specifier`, which the
             // store immediately heap-duplicates inside `transpile()`.
@@ -4327,9 +4250,9 @@ unsafe fn transpile_file(
     }
 
     // ── Synchronous-loader fallback ────────────────────────────────────────
-    // Spec :1031-1078. PORT NOTE: hoisted out of `unwrap_or_else` into a
+    // Note: hoisted out of `unwrap_or_else` into a
     // labelled block so the `CustomLoader::Custom` arm can write `*ret` and
-    // `return null` from `Bun__transpileFile` itself (spec :1051-1061) — a
+    // `return null` from `Bun__transpileFile` itself — a
     // closure cannot perform a non-local return.
     let synchronous_loader: Loader = 'loader: {
         if let Some(l) = lr.loader {
@@ -4348,7 +4271,6 @@ unsafe fn transpile_file(
                 use bun_jsc::node_module_module::{
                     CustomLoader, find_longest_registered_extension,
                 };
-                // Spec :1043-1064.
                 // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
                 if unsafe {
                     (*jsc_vm).commonjs_custom_extensions.len() > 0
@@ -4392,13 +4314,11 @@ unsafe fn transpile_file(
         }
     };
 
-    // Spec :1083 — `defer jsc_vm.module_loader.resetArena(jsc_vm)`.
+    // Reset the module loader's arena on scope exit.
     // `jsc_vm` is the live per-thread VM (BackRef invariant).
     let _reset_arena = ArenaResetGuard::new(jsc_vm);
 
-    // Spec :1085 + VirtualMachine.zig:489-494 — lazy-init the per-thread
-    // shared printer. PORT NOTE: in Zig `loadExtraEnvAndSourceCodePrinter`
-    // primes `source_code_printer` before the first import; the Rust
+    // Lazy-init the per-thread shared printer.
     // `load_extra_env_and_source_code_printer` calls `ensure_source_code_printer`
     // (VirtualMachine.rs), but prime defensively here on first use too.
     let printer_ptr: *mut bun_js_printer::BufferPrinter = TRANSPILE_PRINTER.with(|cell| {
@@ -4414,7 +4334,6 @@ unsafe fn transpile_file(
     });
 
     // ── `ModuleLoader.transpileSourceCode(...)` ─────────────────────────────
-    // Spec :1085-1116.
     let mut promise: *mut JSInternalPromise = ptr::null_mut();
     let mut extra = TranspileExtra {
         // SAFETY: `TranspileExtra::path` is typed `'static` for the cross-crate
@@ -4452,7 +4371,6 @@ unsafe fn transpile_file(
             promise.cast::<c_void>()
         }
         Err(err) => {
-            // Spec :1100-1115.
             if err == bun_core::err!("AsyncModule") {
                 debug_assert!(!promise.is_null());
                 return promise.cast::<c_void>();
@@ -4461,7 +4379,7 @@ unsafe fn transpile_file(
                 return ptr::null_mut();
             }
             if err == bun_core::err!("JSError") {
-                // Spec :1108 — `globalObject.takeError(error.JSError)` unwraps
+                // `take_error` unwraps
                 // the JSC::Exception to its inner value; the C++ caller
                 // re-wraps via `JSC::Exception::create`, so storing the raw
                 // Exception here would double-wrap and trip
@@ -4513,8 +4431,8 @@ unsafe fn get_hardcoded_module_hook(
     }
 }
 
-/// `LoaderHooks::transpile_virtual_module` body — port of
-/// `Bun__transpileVirtualModule` (spec ModuleLoader.zig:1234-1304). Transpiles
+/// `LoaderHooks::transpile_virtual_module` body —
+/// `Bun__transpileVirtualModule`. Transpiles
 /// plugin-provided source through the per-thread `TRANSPILE_PRINTER`.
 ///
 /// # Safety
@@ -4533,12 +4451,12 @@ unsafe fn transpile_virtual_module(
 
     // SAFETY: per fn contract — `global` is the live JS-thread global.
     let global_ref = unsafe { &*global };
-    // PORT NOTE: `bun_vm_ptr()` returns the FFI `*mut VirtualMachine` directly;
+    // Note: `bun_vm_ptr()` returns the FFI `*mut VirtualMachine` directly;
     // going through `bun_vm() -> &VirtualMachine -> *const -> *mut` would
     // launder provenance through a shared ref and the `&mut *jsc_vm` /
     // transpiler writes below would be UB under Stacked Borrows.
     let jsc_vm: *mut VirtualMachine = global_ref.bun_vm_ptr();
-    // PORT NOTE: spec asserted `jsc_vm.plugin_runner != null` then dropped the
+    // Note: spec asserted `jsc_vm.plugin_runner != null` then dropped the
     // assert ("not required for build.module()") — keep parity (no assert).
 
     // SAFETY: per fn contract — pointers valid for the call.
@@ -4557,8 +4475,8 @@ unsafe fn transpile_virtual_module(
     // `specifier_slice` drops). Same erasure as `transpile_file` above.
     let path: Fs::Path<'static> = unsafe { Fs::Path::init(specifier).into_static() };
 
-    // Spec :1262-1270 — `loader_ != ._none ? fromAPI(loader_) : loaders.get(ext)
-    // orelse (specifier == main ? .js : .file)`.
+    // Pick the loader: the explicit API loader if given, else by file
+    // extension, else `.js` for the main module / `.file` otherwise.
     let loader = if loader_ != api::Loader::_none {
         Loader::from_api(loader_)
     } else {
@@ -4579,7 +4497,7 @@ unsafe fn transpile_virtual_module(
         })
     };
 
-    // Spec :1272-1273 — `defer log.deinit(); defer module_loader.resetArena()`.
+    // Reset the module loader's arena on scope exit.
     // `jsc_vm` is the live per-thread VM (BackRef invariant).
     let _reset_arena = ArenaResetGuard::new(jsc_vm);
 
@@ -4597,7 +4515,6 @@ unsafe fn transpile_virtual_module(
     });
 
     // ── `ModuleLoader.transpileSourceCode(...)` ─────────────────────────────
-    // Spec :1276-1300.
     let mut extra = TranspileExtra {
         path,
         loader,
@@ -4627,12 +4544,11 @@ unsafe fn transpile_virtual_module(
             true
         }
         Err(err) => {
-            // Spec :1289-1299.
             if err == bun_core::err!("PluginError") {
                 return true;
             }
             if err == bun_core::err!("JSError") {
-                // Spec :1292 — `globalObject.takeError(error.JSError)` unwraps
+                // `take_error` unwraps
                 // the JSC::Exception to its inner value (see same note in
                 // `transpile_file` above).
                 let exc = global_ref.take_error(bun_jsc::JsError::Thrown);
@@ -4659,7 +4575,7 @@ unsafe fn transpile_virtual_module(
     }
 }
 
-/// Core of `ModuleLoader.resolveEmbeddedFile` (spec ModuleLoader.zig:33-71):
+/// Core of `ModuleLoader.resolveEmbeddedFile`:
 /// finds an embedded file in the standalone module graph, materializes it to
 /// a real on-disk temp file with `extname`, and writes the resulting absolute
 /// path into `out_buf`. Returns the number of bytes written.
@@ -4677,15 +4593,11 @@ pub(crate) fn resolve_embedded_file_to_buf(
     extname: &[u8],
     out_buf: &mut [u8],
 ) -> Option<usize> {
-    // Spec ModuleLoader.zig:34 — `if (input_path.len == 0) return null`.
     if input_path.is_empty() {
         return None;
     }
 
-    // Spec ModuleLoader.zig:35-36 — `vm.standalone_module_graph orelse return
-    // null` + `graph.find(input_path) orelse return null`.
-    //
-    // PORT NOTE: do NOT downcast the `&'static dyn StandaloneModuleGraph`
+    // Note: do NOT downcast the `&'static dyn StandaloneModuleGraph`
     // stored on `vm` to `&mut Graph` — that shared-ref provenance is
     // read-only (instant UB under Stacked Borrows). Reach the concrete graph
     // via `Graph::get()` which hands out the `UnsafeCell` `*mut` (same path
@@ -4698,27 +4610,21 @@ pub(crate) fn resolve_embedded_file_to_buf(
     let file_name: &[u8] = file.name;
     let file_contents: &[u8] = file.contents.as_bytes();
 
-    // Spec ModuleLoader.zig:43-45 — `tmpname(extname, buf, bun.hash(file.name))`.
     let mut tmpname_buf = bun_paths::path_buffer_pool::get();
     let tmpfilename =
         Fs::FileSystem::tmpname(extname, &mut tmpname_buf[..], bun_wyhash::hash(file_name)).ok()?;
 
-    // Spec ModuleLoader.zig:47 — `bun.fs.FileSystem.instance.tmpdir()`.
     // SAFETY: `FileSystem::instance()` returns the process-global singleton
     // pointer (initialized at startup).
     let tmpdir = (*Fs::FileSystem::instance()).tmpdir().ok()?;
     let tmpdir_fd: bun_sys::Fd = tmpdir.fd;
 
-    // Spec ModuleLoader.zig:50-51 — `bun.Tmpfile.create(tmpdir, tmpfilename)`.
     let tmpfile = bun_sys::Tmpfile::create(tmpdir_fd, tmpfilename).ok()?;
     let tmpfile_fd = tmpfile.fd;
     scopeguard::defer! {
         let _ = bun_sys::close(tmpfile_fd);
     }
 
-    // Spec ModuleLoader.zig:53-67 — `NodeFS.writeFileWithPathBuffer(.{ .data
-    // = .encoded_slice(file.contents), .dirfd = tmpdir, .file = .{ .fd =
-    // tmpfile.fd }, .encoding = .buffer })`.
     let mut scratch = bun_paths::path_buffer_pool::get();
     if bun_sys::write_file_with_path_buffer(
         &mut scratch,
@@ -4737,8 +4643,7 @@ pub(crate) fn resolve_embedded_file_to_buf(
         return None;
     }
 
-    // Spec ModuleLoader.zig:69 — `joinAbsStringBuf(RealFS.tmpdirPath(),
-    // path_buf, &.{tmpfilename}, .auto)`. `join_abs_string_buf` writes into
+    // `join_abs_string_buf` writes into
     // `out_buf` and returns a slice pointing into it; capture the length so
     // the caller knows how many bytes are live.
     let result = bun_paths::resolve_path::join_abs_string_buf::<bun_paths::platform::Auto>(
@@ -4749,12 +4654,12 @@ pub(crate) fn resolve_embedded_file_to_buf(
     Some(result.len())
 }
 
-/// `LoaderHooks::resolve_embedded_node_file` body — port of
-/// `ModuleLoader.resolveEmbeddedFile` (spec ModuleLoader.zig:33-71) for the
+/// `LoaderHooks::resolve_embedded_node_file` body —
+/// `ModuleLoader.resolveEmbeddedFile` for the
 /// `process.dlopen()`-on-a-compiled-executable path. Delegates to
 /// [`resolve_embedded_file_to_buf`] with `extname = "node"` and writes the
 /// resulting on-disk path back into `*in_out_str`
-/// (`bun.String.cloneUTF8(result)`).
+/// (as an owned UTF-8 clone).
 ///
 /// # Safety
 /// `vm` is the live per-thread VM; `in_out_str` is a valid in/out
@@ -4765,7 +4670,6 @@ unsafe fn resolve_embedded_node_file_hook(
     vm: *mut VirtualMachine,
     in_out_str: *mut bun_core::String,
 ) -> bool {
-    // Spec ModuleLoader.zig:1334-1337 — `in_out_str.toUTF8()` + `path_buffer_pool.get()`.
     // SAFETY: per fn contract — `in_out_str` is a valid `bun.String*`.
     let input_path_utf8 = unsafe { &*in_out_str }.to_utf8();
     let input_path = input_path_utf8.slice();
@@ -4776,7 +4680,6 @@ unsafe fn resolve_embedded_node_file_hook(
         return false;
     };
 
-    // Spec ModuleLoader.zig:1339-1340 — `in_out_str.* = bun.String.cloneUTF8(result)`.
     // SAFETY: per fn contract.
     unsafe { *in_out_str = bun_core::String::clone_utf8(&path_buf[..len]) };
     true
@@ -4784,7 +4687,7 @@ unsafe fn resolve_embedded_node_file_hook(
 
 // ════════════════════════════════════════════════════════════════════════════
 // LoaderHooks::resolve — `VirtualMachine.resolveMaybeNeedsTrailingSlash`
-// (spec VirtualMachine.zig:1873-2016) + `_resolve` (spec :1724-1852).
+// + `_resolve`.
 //
 // This is the resolution path behind `Bun__resolveSync`,
 // `Zig__GlobalObject__resolve`, `import.meta.resolve`, and
@@ -4794,9 +4697,9 @@ unsafe fn resolve_embedded_node_file_hook(
 // hence §Dispatch.
 // ════════════════════════════════════════════════════════════════════════════
 
-/// `bun.pathLiteral(s)` — comptime path-separator rewrite. Only the two
-/// `_resolve` callers need it (the `[eval]` / `[stdin]` suffix checks); inline
-/// the const-folded result instead of pulling in the `bun.rs` macro.
+/// Path-separator-adjusted literal suffixes. Only the two
+/// `_resolve` callers need them (the `[eval]` / `[stdin]` suffix checks), so
+/// inline the per-platform constants.
 #[cfg(windows)]
 const EVAL_SUFFIX: &[u8] = b"\\[eval]";
 #[cfg(not(windows))]
@@ -4806,7 +4709,7 @@ const STDIN_SUFFIX: &[u8] = b"\\[stdin]";
 #[cfg(not(windows))]
 const STDIN_SUFFIX: &[u8] = b"/[stdin]";
 
-/// Spec VirtualMachine.zig:1712-1720.
+/// Split off the `?query` suffix.
 #[inline]
 fn normalize_specifier_for_resolution<'a>(
     specifier: &'a [u8],
@@ -4821,16 +4724,16 @@ fn normalize_specifier_for_resolution<'a>(
     }
 }
 
-/// Spec VirtualMachine.zig:1865-1871 — strip a `file://` prefix.
+/// Strip a `file://` prefix.
 #[inline]
 fn normalize_source(source: &[u8]) -> &[u8] {
     source.strip_prefix(b"file://".as_slice()).unwrap_or(source)
 }
 
-/// Port of `VirtualMachine._resolve` (spec VirtualMachine.zig:1724-1852).
+/// `VirtualMachine._resolve`.
 ///
-/// Writes the resolved path/query into `*ret_path` / `*ret_query`. The Zig
-/// `ResolveFunctionResult.result: ?Resolver.Result` field is unused by the
+/// Writes the resolved path/query into `*ret_path` / `*ret_query`. A full
+/// `Resolver::Result` would be unused by the
 /// only caller (`resolveMaybeNeedsTrailingSlash` reads `.path` /
 /// `.query_string` and clones them), so we drop it and return only the slices
 /// the caller actually consumes — avoids materialising the 1KB
@@ -4853,18 +4756,16 @@ unsafe fn _resolve<'a>(
     use bun_jsc::virtual_machine::MAIN_FILE_NAME;
     use bun_resolve_builtins::{Alias, Cfg as AliasCfg};
 
-    // Spec :1732 — `Runtime.Runtime.Imports.alt_name` == `Runtime.Runtime.Imports.Name`
-    // == `"bun:wrap"` (see js_parser/runtime.rs:644-645). Zig compared the
-    // *basename* against `alt_name`; both consts are the bare specifier so a
-    // direct equality on `basename(specifier)` is correct.
+    // `Runtime.Runtime.Imports.alt_name` == `Runtime.Runtime.Imports.Name`
+    // == `"bun:wrap"` (see js_parser/runtime.rs:644-645); both consts are the
+    // bare specifier so a direct equality on `basename(specifier)` is correct.
     if bun_paths::basename(specifier) == b"bun:wrap" {
         *ret_path = b"bun:wrap";
         return Ok(());
     }
 
-    // Spec :1734-1737 — `bun:main` synthetic entry. `entry_point` lives on the
-    // high-tier `RuntimeState` (it was a value field of `VirtualMachine` in
-    // Zig).
+    // `bun:main` synthetic entry. `entry_point` lives on the
+    // high-tier `RuntimeState`.
     if specifier == MAIN_FILE_NAME {
         let state = runtime_state();
         // SAFETY: `state` is the per-thread `RuntimeState` box; null only when
@@ -4875,29 +4776,29 @@ unsafe fn _resolve<'a>(
         }
     }
 
-    // Spec :1738-1741 — `macro:` namespace passes through.
+    // `macro:` namespace passes through.
     if specifier.starts_with(bun_js_parser::Macro::NAMESPACE_WITH_COLON) {
-        // PORT NOTE: Zig duped into `bun.default_allocator`; the caller now
-        // `bun.String.cloneUTF8`s `ret_path` unconditionally (spec :2015), so
-        // returning the borrowed slice is sufficient and avoids the leak
+        // The caller
+        // clones `ret_path` into an owned string unconditionally, so
+        // returning the borrowed slice is sufficient and avoids a leak
         // (PORTING.md §Forbidden (leaking)).
         *ret_path = specifier;
         return Ok(());
     }
 
-    // Spec :1742-1745 — `node_fallbacks` virtual import path.
+    // `node_fallbacks` virtual import path.
     if specifier.starts_with(node_fallbacks::IMPORT_PATH) {
         *ret_path = specifier;
         return Ok(());
     }
 
-    // Spec :1746-1749 — hardcoded builtin alias (`node:fs` etc.).
+    // Hardcoded builtin alias (`node:fs` etc.).
     if let Some(alias) = Alias::get(specifier, Target::Bun, AliasCfg::default()) {
         *ret_path = alias.path.as_bytes();
         return Ok(());
     }
 
-    // Spec :1750-1756 — `[eval]` / `[stdin]` virtual sources.
+    // `[eval]` / `[stdin]` virtual sources.
     // SAFETY: `vm` is the live per-thread VM.
     if unsafe { &*vm }.module_loader.eval_source.is_some()
         && (specifier.ends_with(EVAL_SUFFIX) || specifier.ends_with(STDIN_SUFFIX))
@@ -4906,7 +4807,7 @@ unsafe fn _resolve<'a>(
         return Ok(());
     }
 
-    // Spec :1757-1765 — `blob:` URLs registered via `URL.createObjectURL`.
+    // `blob:` URLs registered via `URL.createObjectURL`.
     if let Some(rest) = specifier.strip_prefix(b"blob:".as_slice()) {
         if crate::webcore::object_url_registry::ObjectURLRegistry::singleton().has(rest) {
             *ret_path = specifier;
@@ -4919,7 +4820,7 @@ unsafe fn _resolve<'a>(
     let is_special_source = source == MAIN_FILE_NAME || bun_js_parser::Macro::is_macro_path(source);
     let mut query_string: &[u8] = b"";
     let normalized_specifier = normalize_specifier_for_resolution(specifier, &mut query_string);
-    // Spec :1771-1778. `Fs.PathName.init(source).dirWithTrailingSlash()` slices
+    // `Fs.PathName.init(source).dirWithTrailingSlash()` slices
     // `source` in place, so the `'a` lifetime is preserved.
     let top_level_dir: &'a [u8] = Fs::FileSystem::get().top_level_dir;
     let source_to_use: &[u8] = if !is_special_source {
@@ -4932,7 +4833,7 @@ unsafe fn _resolve<'a>(
         top_level_dir
     };
 
-    // Spec :1780-1838 — `resolveAndAutoInstall` retry-on-not-found loop.
+    // `resolveAndAutoInstall` retry-on-not-found loop.
     // SAFETY: `resolver.opts.global_cache` is a plain enum field.
     let global_cache = unsafe { &*vm }.transpiler.resolver.opts.global_cache;
     let kind = if is_esm {
@@ -4964,7 +4865,7 @@ unsafe fn _resolve<'a>(
                 }
                 retry_on_not_found = false;
 
-                // Spec :1799-1833 — bust the dir cache for the candidate
+                // Bust the dir cache for the candidate
                 // parent directory and retry once.
                 let mut buf = bun_paths::path_buffer_pool::get();
                 let buster_name: &[u8] = 'name: {
@@ -5009,7 +4910,6 @@ unsafe fn _resolve<'a>(
         }
     };
 
-    // Spec :1840-1842.
     // SAFETY: plain bool/usize fields.
     unsafe {
         if !(*vm).macro_mode {
@@ -5025,19 +4925,19 @@ unsafe fn _resolve<'a>(
     // SAFETY: plain usize field.
     unsafe { (*vm).resolved_count += 1 };
 
-    // PORT NOTE: `result_path.text` is a `&'_ [u8]` borrowed from the
+    // Note: `result_path.text` is a `&'_ [u8]` borrowed from the
     // resolver's interned `'static` BSSStringList stores (see resolver/lib.rs
     // §allocators) — the same store `load_preloads` reads from. Transmute the
     // lifetime to `'a` so the caller can `cloneUTF8` it; the underlying bytes
     // outlive the program.
     // SAFETY: `result_path.text` borrows the resolver's `'static` interned
-    // string store; detaching the borrow lifetime is sound (see PORT NOTE).
+    // string store; detaching the borrow lifetime is sound (see Note).
     *ret_path = unsafe { bun_ptr::detach_lifetime(result_path.text) };
     Ok(())
 }
 
-/// `LoaderHooks::resolve` body — port of
-/// `VirtualMachine.resolveMaybeNeedsTrailingSlash` (spec VirtualMachine.zig:1873-2016).
+/// `LoaderHooks::resolve` body —
+/// `VirtualMachine.resolveMaybeNeedsTrailingSlash`.
 ///
 /// # Safety
 /// `res` / `global` are valid; `query_string` is null or a valid out-param.
@@ -5059,7 +4959,7 @@ unsafe fn resolve_hook(
 
     // SAFETY: per fn contract.
     let global_ref = unsafe { &*global };
-    // PORT NOTE: `bun_vm_ptr()` returns the FFI `*mut VirtualMachine` directly
+    // Note: `bun_vm_ptr()` returns the FFI `*mut VirtualMachine` directly
     // (mutable provenance from C++); we go through a raw ptr (not `&mut`) for
     // the resolver/log writes below to avoid aliasing (PORTING.md §Forbidden —
     // same raw-ptr-per-field style as `load_preloads`/`transpile_source_code`).
@@ -5067,8 +4967,7 @@ unsafe fn resolve_hook(
     // through under Stacked Borrows.
     let vm: *mut VirtualMachine = global_ref.bun_vm_ptr();
 
-    // Spec :1883-1904 — overlong specifier guard. `MAX_PATH_BYTES * 1.5`,
-    // truncated. PORT NOTE: Zig used `@intFromFloat(@trunc(f64(..) * 1.5))`;
+    // Overlong specifier guard. `MAX_PATH_BYTES * 1.5`, truncated:
     // integer `* 3 / 2` is exact for the powers-of-two MAX_PATH_BYTES values.
     const MAX_SPECIFIER_LEN: usize = bun_paths::MAX_PATH_BYTES * 3 / 2;
     if is_a_file_path && specifier.length() > MAX_SPECIFIER_LEN {
@@ -5103,7 +5002,7 @@ unsafe fn resolve_hook(
     let specifier_utf8 = specifier.to_utf8();
     let source_utf8 = source.to_utf8();
 
-    // Spec :1913-1925 — `PluginRunner.onResolveJSC`.
+    // `PluginRunner.onResolveJSC`.
     // SAFETY: `vm` is the live per-thread VM.
     if unsafe { &*vm }.plugin_runner.is_some() {
         use bun_bundler_jsc::PluginRunner as plugin_runner;
@@ -5127,16 +5026,14 @@ unsafe fn resolve_hook(
                     return true;
                 }
                 Ok(None) => {}
-                // Spec: `try` — JS exception was thrown; caller observes it
-                // via the global's exception state, so bail without writing
-                // `res` (matches the `catch return false` contract on every
-                // other `try` in this fn).
+                // JS exception was thrown; caller observes it via the
+                // global's exception state, so bail without writing `res`.
                 Err(_) => return false,
             }
         }
     }
 
-    // Spec :1927-1935 — hardcoded builtin alias fast path. For
+    // Hardcoded builtin alias fast path. For
     // `require.resolve("fs")` (`is_user_require_resolve && node_builtin`) Node
     // returns the bare specifier as-is, not the canonical `node:fs`.
     if let Some(hardcoded) = Alias::get(specifier_utf8.slice(), Target::Bun, AliasCfg::default()) {
@@ -5150,15 +5047,15 @@ unsafe fn resolve_hook(
         return true;
     }
 
-    // Spec :1937-1954 — swap `vm.log` (and resolver/linker/pm logs) to a fresh
-    // local Log so resolver diagnostics don't leak into the VM log. PORT NOTE:
+    // Swap `vm.log` (and resolver/linker/pm logs) to a fresh
+    // local Log so resolver diagnostics don't leak into the VM log. Note:
     // `Resolver.log` is `NonNull<Log>` and `Linker.log` is `*mut Log` (see
     // transpile_source_code's identical swap at jsc_hooks.rs:848-879), so the
     // pointer write is sound; restore via scopeguard so the early-`return
     // false` paths don't leave a dangling stack pointer.
     let mut log = bun_ast::Log::init();
-    // `vm.log` is set unconditionally in `init` and never cleared (Zig stores
-    // `*logger.Log`, always non-null) — the `expect` is infallible.
+    // `vm.log` is set unconditionally in `init` and never cleared — the
+    // `expect` is infallible.
     // SAFETY: per fn contract — `vm` is the live per-thread VM.
     let old_log: core::ptr::NonNull<bun_ast::Log> =
         unsafe { &*vm }.log.expect("vm.log set in init");
@@ -5188,7 +5085,6 @@ unsafe fn resolve_hook(
         }
     }
 
-    // Spec :1955 — `jsc_vm._resolve(...)`.
     let mut result_path: &[u8] = b"";
     let mut result_query: &[u8] = b"";
     // SAFETY: `vm` is the live per-thread VM; the slices borrow
@@ -5204,14 +5100,12 @@ unsafe fn resolve_hook(
             &mut result_query,
         )
     } {
-        // Spec :1956-1999 — synthesise a `ResolveMessage` from the first
+        // Synthesise a `ResolveMessage` from the first
         // `.resolve`-tagged log msg, or fall back to `ResolveMessage::fmt`.
         let msg: bun_ast::Msg = 'brk: {
             for m in log.msgs.iter() {
                 if let bun_ast::Metadata::Resolve(r) = &m.metadata {
                     err = r.err;
-                    // PORT NOTE: Zig moved the msg out (`break :brk m`); the
-                    // Rust `Msg` is `Clone` (Result<Msg, AllocError>).
                     break 'brk m.clone();
                 }
             }
@@ -5250,7 +5144,7 @@ unsafe fn resolve_hook(
         return true;
     }
 
-    // Spec :2002-2010 — write `*query_string`. `result_query` borrows
+    // Write `*query_string`. `result_query` borrows
     // `specifier_utf8`, which is freed when this fn returns; clone into an
     // owned `bun.String`.
     if !query_string.is_null() {
@@ -5264,7 +5158,7 @@ unsafe fn resolve_hook(
         }
     }
 
-    // Spec :2015 — `result.path` may borrow `specifier_utf8` (e.g. `http://`
+    // `result.path` may borrow `specifier_utf8` (e.g. `http://`
     // specifiers the resolver marked external without copying); clone for the
     // same reason. Callers own the resulting ref.
     // SAFETY: per fn contract.
@@ -5288,13 +5182,12 @@ pub(crate) static __BUN_LOADER_HOOKS: LoaderHooks = LoaderHooks {
 // Hook installation
 // ════════════════════════════════════════════════════════════════════════════
 
-// PORT NOTE: the event-loop per-task bodies (`__bun_run_immediate_task` /
+// Note: the event-loop per-task bodies (`__bun_run_immediate_task` /
 // `__bun_run_wtf_timer`) live in [`crate::dispatch`] alongside the other
 // §Dispatch hot-path bodies (`__bun_tick_queue_with_count` / `__bun_run_file_poll`).
 
 /// `bun_io::__bun_get_vm_ctx` body — recover the global event-loop context
-/// for the requested arm. Zig had no crate split here: callers reached
-/// `VirtualMachine.get()` / `MiniEventLoop.global` directly. Declared
+/// for the requested arm. Declared
 /// `extern "Rust"` in `bun_io::posix_event_loop`; link-time resolved.
 #[unsafe(no_mangle)]
 pub(crate) fn __bun_get_vm_ctx(kind: bun_io::AllocatorType) -> bun_io::EventLoopCtx {
@@ -5307,8 +5200,8 @@ pub(crate) fn __bun_get_vm_ctx(kind: bun_io::AllocatorType) -> bun_io::EventLoop
         },
         bun_io::AllocatorType::Mini => {
             // SAFETY: `GLOBAL` is set by `MiniEventLoop::init_global` before
-            // any caller asks for `AllocatorType::Mini` (Zig: `MiniEventLoop.
-            // global` is the only mini loop and is init-once); `mini` is live
+            // any caller asks for `AllocatorType::Mini` (the global mini loop
+            // is the only one and is init-once); `mini` is live
             // for the process and `as_event_loop_ctx` only stores it as a tagged
             // backref.
             let mini = bun_event_loop::MiniEventLoop::GLOBAL.with(|g| g.get());
@@ -5318,10 +5211,9 @@ pub(crate) fn __bun_get_vm_ctx(kind: bun_io::AllocatorType) -> bun_io::EventLoop
     }
 }
 
-/// Spec `Request.zig:62` `dateForHeader`: wrap the header bytes in a
-/// `bun.String`, call `String.parseDate(&s, vm.global)`, return
-/// `@intFromFloat` if finite and non-negative, else `null`. The Zig method
-/// lived on `uws.Request`; in Rust the call site moved UP to this crate (sole
+/// `dateForHeader`: wrap the header bytes in a
+/// `bun.String`, call `String.parseDate(&s, vm.global)`, return the integer
+/// value if finite and non-negative, else `None`. Lives in this crate (sole
 /// caller is `server::FileRoute::on`) so `bun_uws_sys` (T0) has no upward
 /// hook into `bun_jsc`.
 pub fn parse_http_date(value: &[u8]) -> Option<u64> {
@@ -5331,8 +5223,7 @@ pub fn parse_http_date(value: &[u8]) -> Option<u64> {
     // callback (JS thread, VM live).
     let global = unsafe { &*(*vm).global };
     let mut string = bun_core::String::init(value);
-    // PORT NOTE: Zig `dateForHeader` returns `bun.JSError!?u64` and lets the
-    // caller propagate the throw. The only callers — FileRoute / static
+    // The only callers — FileRoute / static
     // routes — treat a throw the same as "header absent / unparsable", so
     // swallow `JsError` here and surface `None`.
     let date_f64 = match bun_jsc::bun_string_jsc::parse_date(&mut string, global) {
@@ -5351,7 +5242,7 @@ pub fn parse_http_date(value: &[u8]) -> Option<u64> {
 }
 
 /// `bun_event_loop::__bun_js_vm_get` body — erased `VirtualMachine::get()` for
-/// `AbstractVM::JsKind`'s `get_vm()`. Zig: `jsc.VirtualMachine.get()` inline.
+/// `AbstractVM::JsKind`'s `get_vm()`.
 /// Declared `extern "Rust"` in `bun_event_loop::MiniEventLoop`; link-time
 /// resolved.
 #[unsafe(no_mangle)]
@@ -5359,8 +5250,7 @@ pub(crate) fn __bun_js_vm_get() -> *mut () {
     bun_jsc::virtual_machine::VirtualMachine::get_mut_ptr().cast()
 }
 
-/// `bun_event_loop::__bun_stdio_blob_store_new` body — Zig rare_data.zig:551
-/// inline `Blob.Store.new(.{ .ref_count = 2, .data = .{ .file = … } })`.
+/// `bun_event_loop::__bun_stdio_blob_store_new` body.
 /// Returns an erased `*mut webcore::blob::Store` with intrusive `ref_count = 2`
 /// (one for `RareData`/`MiniEventLoop`, one for the eventual `Blob` consumer).
 /// Declared `extern "Rust"` in `bun_event_loop::MiniEventLoop`; link-time
@@ -5401,5 +5291,3 @@ pub(crate) fn __bun_stdio_blob_store_deinit(ptr: *mut ()) {
         Store::deref(this);
     }
 }
-
-// ported from: src/jsc/VirtualMachine.zig
diff --git a/src/runtime/lib.rs b/src/runtime/lib.rs
index eb108767d69..0cfd6f57b7f 100644
--- a/src/runtime/lib.rs
+++ b/src/runtime/lib.rs
@@ -26,7 +26,7 @@ pub mod webcore;
 pub mod bake;
 pub mod cli;
 pub mod shell;
-// Port of src/bun.js.zig — `Run::boot` / `Run::boot_standalone`. Mounted here
+// `Run::boot` / `Run::boot_standalone`. Mounted here
 // (not as a separate crate) because every dependency it has is already a dep of
 // `bun_runtime`, and the CLI dispatch in `cli/` needs to call it directly. The
 // original "higher-tier crate" split was speculative; folding it in breaks the
@@ -42,7 +42,7 @@ pub mod napi;
 #[path = "../bun.js.rs"]
 pub mod run_main;
 pub mod timer;
-// `generated_classes_list.zig` lives under `src/jsc/` but every type it
+// `generated_classes_list.rs` lives under `src/jsc/` but every type it
 // aliases is defined in this crate (api/webcore/test_runner/bake) or a
 // same-tier dep, so it is `#[path]`-mounted here to avoid a bun_jsc cycle.
 #[path = "../jsc/generated_classes_list.rs"]
@@ -60,9 +60,9 @@ pub mod test_runner;
 pub mod valkey_jsc;
 
 // ─── crate-root re-exports for `cli/` submodules ────────────────────────────
-// Modules under `src/runtime/cli/**` were ported with crate-root paths
-// (`crate::Command`, `crate::test_command`, `crate::run_command`, …) because
-// the Zig source treats `cli.zig` as the binary root. Surface those names here
+// Modules under `src/runtime/cli/**` use crate-root paths
+// (`crate::Command`, `crate::test_command`, `crate::run_command`, …).
+// Surface those names here
 // so `*_command.rs` and `test/parallel/*.rs` files resolve their
 // `use crate::…` lines without per-file edits.
 pub use cli::{
diff --git a/src/runtime/napi/mod.rs b/src/runtime/napi/mod.rs
index 6434d68fbfb..f5a947f9347 100644
--- a/src/runtime/napi/mod.rs
+++ b/src/runtime/napi/mod.rs
@@ -1,5 +1,4 @@
 //! Node-API (N-API) implementation.
-//! Port of src/napi/napi.zig.
 //!
 //! The full implementation lives in `napi_body.rs` and depends on
 //! `bun_jsc::{AnyTask, ConcurrentTask, Debugger, EventLoop, Strong, Task,
@@ -26,5 +25,3 @@ bun_opaque::opaque_ffi! {
 // TODO(blocked): bun_collections::LinearFifo
 // TODO(blocked): bun_threading::Condvar
 pub struct ThreadsafeFunction(());
-
-// ported from: src/napi/napi.zig
diff --git a/src/runtime/napi/napi_body.rs b/src/runtime/napi/napi_body.rs
index 772096e7c2b..600d9dcfac1 100644
--- a/src/runtime/napi/napi_body.rs
+++ b/src/runtime/napi/napi_body.rs
@@ -1,5 +1,4 @@
 //! Node-API (N-API) implementation.
-//! Port of src/napi/napi.zig.
 
 use core::ffi::{c_char, c_int, c_uint, c_void};
 use core::ptr;
@@ -23,9 +22,8 @@ use bun_threading::work_pool::{IntrusiveWorkTask as _, Task as WorkPoolTask, Wor
 
 // ─── local shims for upstream-crate gaps (see PORTING.md §extension traits) ───
 
-/// Local extension shims for `JSValue` methods that exist in Zig but are not
-/// yet surfaced on the Rust `bun_jsc::JSValue` type. Declared as a trait so the
-/// call sites read identically to the Zig source.
+/// Local extension shims for `JSValue` methods not yet surfaced on the
+/// `bun_jsc::JSValue` type.
 trait JSValueNapiExt {
     fn is_strict_equal(self, other: JSValue, global: &JSGlobalObject) -> jsc::JsResult<bool>;
     fn is_async_context_frame(self) -> bool;
@@ -42,8 +40,8 @@ unsafe extern "C" {
 
 impl JSValueNapiExt for JSValue {
     fn is_strict_equal(self, other: JSValue, global: &JSGlobalObject) -> jsc::JsResult<bool> {
-        // SAFETY: FFI; may run JS (getters on Proxy etc.). Zig: `fromJSHostCallGeneric` →
-        // check_slow (open scope before call, then `returnIfException`).
+        // SAFETY: FFI; may run JS (getters on Proxy etc.); `call_check_slow!` opens the
+        // exception scope before the call and propagates any pending exception.
         bun_jsc::call_check_slow!(global, || unsafe {
             JSC__JSValue__isStrictEqual(self, other, global.as_mut_ptr())
         })
@@ -174,7 +172,7 @@ impl NapiEnv {
 }
 
 // SAFETY: NapiEnv refcount is managed externally by C++ via NapiEnv__ref/NapiEnv__deref;
-// the pointee remains valid while the count is > 0 (Zig: `external_shared_descriptor`).
+// the pointee remains valid while the count is > 0.
 unsafe impl bun_ptr::ExternalSharedDescriptor for NapiEnv {
     unsafe fn ext_ref(this: *mut Self) {
         // SAFETY: caller contract — `this` is a valid C++-owned napi_env.
@@ -279,8 +277,6 @@ impl NapiHandleScope {
 }
 
 /// RAII guard for [`NapiHandleScope::open`] / [`NapiHandleScope::close`].
-/// The Rust spelling of Zig's `var hs = NapiHandleScope.open(env, false);
-/// defer if (hs) |s| NapiHandleScope.close(s, env);`.
 pub(super) struct NapiHandleScopeGuard<'a> {
     scope: *mut NapiHandleScope,
     env: &'a NapiEnv,
@@ -363,7 +359,7 @@ pub(super) enum napi_typedarray_type {
 
 impl napi_typedarray_type {
     pub(super) fn from_js_type(this: jsc::JSType) -> Option<napi_typedarray_type> {
-        // PORT NOTE: jsc::JSType is a newtype struct with associated consts (not an enum),
+        // Note: jsc::JSType is a newtype struct with associated consts (not an enum),
         // so glob-import is unavailable; match on the qualified const paths instead.
         Some(match this {
             jsc::JSType::Int8Array => napi_typedarray_type::int8_array,
@@ -502,7 +498,7 @@ pub(crate) fn write_out<T>(p: *mut T, v: T) {
 // Exported / extern NAPI functions
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): move to napi_sys
+// Implemented in C++ (napi.cpp); declared extern here for Rust-side callers.
 unsafe extern "C" {
     pub(super) fn napi_get_last_error_info(
         env: napi_env,
@@ -583,7 +579,7 @@ pub(super) extern "C" fn napi_create_array_with_length(
     // size_t immediately cast to int as argument to Array::New, then min 0
     // Bit-reinterpret usize as i64 (same width on 64-bit targets).
     let len_i64: i64 = length as i64;
-    let len_i32: i32 = len_i64 as i32; // @truncate
+    let len_i32: i32 = len_i64 as i32; // intentional truncation
     let len: u32 = if len_i32 > 0 { len_i32 as u32 } else { 0 };
 
     let array = match JSValue::create_empty_array(env.to_js(), len as usize) {
@@ -757,7 +753,7 @@ pub(super) extern "C" fn napi_create_string_utf16(
         if !str_.is_null() {
             if NAPI_AUTO_LENGTH == length {
                 // SAFETY: caller guarantees ptr is NUL-terminated when length == NAPI_AUTO_LENGTH.
-                // Port of `bun.strings.span(c.char16_t, str, 0)` — scan to NUL u16.
+                // Scan to the NUL u16 terminator.
                 break 'brk unsafe { bun_core::ffi::wstr_units(str_) };
             } else if length > i32::MAX as usize {
                 return env.invalid_arg();
@@ -803,7 +799,7 @@ pub(super) extern "C" fn napi_create_string_utf16(
     env.ok()
 }
 
-// TODO(port): move to napi_sys
+// Implemented in C++ (napi.cpp); declared extern here for Rust-side callers.
 unsafe extern "C" {
     pub(super) fn napi_create_symbol(
         env: napi_env,
@@ -1002,7 +998,7 @@ pub(super) extern "C" fn napi_get_array_length(
     }
 
     *result = match value.get_length(env.to_js()) {
-        Ok(len) => len as u32, // @truncate
+        Ok(len) => len as u32, // intentional truncation
         Err(_) => return NapiEnv::set_last_error(Some(env), NapiStatus::pending_exception),
     };
     env.ok()
@@ -1375,7 +1371,9 @@ pub(super) extern "C" fn napi_is_arraybuffer(
 }
 
 unsafe extern "C" {
-    // TODO(port): Zig signature has `data: [*]const u8`; N-API spec says `void**` out-param — verify which is the source of truth.
+    // Verified against the C++ implementation (napi.cpp `napi_create_arraybuffer`):
+    // `data` is a `void**` out-param receiving the buffer's data pointer,
+    // matching the N-API spec.
     pub(super) fn napi_create_arraybuffer(
         env: napi_env,
         byte_length: usize,
@@ -1447,8 +1445,7 @@ pub(super) extern "C" fn napi_get_typedarray_info(
     };
     // SAFETY: `maybe_type` is null or a valid exclusive out-param per N-API contract.
     if let Some(ty) = unsafe { maybe_type.as_mut() } {
-        // Zig: `array_buffer.typed_array_type.toTypedArrayType().toNapi()`. The Rust
-        // `ArrayBuffer.typed_array_type` field is already a `JSType`, so map it
+        // The `ArrayBuffer.typed_array_type` field is already a `JSType`, so map it
         // straight to `napi_typedarray_type`.
         let Some(napi_ty) = napi_typedarray_type::from_js_type(array_buffer.typed_array_type)
         else {
@@ -1770,7 +1767,7 @@ pub(super) enum AsyncWorkStatus {
 pub struct napi_async_work {
     pub task: WorkPoolTask,
     pub concurrent_task: ConcurrentTask,
-    // PORT NOTE: BackRef — `enqueue_task` needs `&mut EventLoop`; reborrowed at use sites.
+    // Note: BackRef — `enqueue_task` needs `&mut EventLoop`; reborrowed at use sites.
     pub event_loop: bun_ptr::BackRef<EventLoop>,
     pub global: GlobalRef, // JSC_BORROW (lives for vm lifetime)
     pub env: NapiEnvRef,
@@ -1884,8 +1881,8 @@ impl napi_async_work {
 
     pub fn run_from_js(&mut self, vm: &mut VirtualMachine, global: &JSGlobalObject) {
         // Note: the "this" value here may already be freed by the user in `complete`
-        // PORT NOTE: Zig copied the struct; KeepAlive is not `Copy` in Rust, so
-        // move it out (the original slot may be freed under us by `complete`).
+        // Note: KeepAlive is not `Copy`, so move it out (the original slot may
+        // be freed under us by `complete`).
         let mut poll_ref = core::mem::take(&mut self.poll_ref);
         // KeepAlive::unref needs an event-loop ctx so it cannot impl Drop
         // generically; this is a genuine one-off cleanup.
@@ -1947,7 +1944,6 @@ pub(super) struct napi_node_version {
 // SAFETY: napi_node_version is POD; the *const c_char points at a static literal.
 unsafe impl Sync for napi_node_version {}
 
-// Port of `std.SemanticVersion.parse(bun.Environment.reported_nodejs_version)` at comptime.
 // Splits "MAJOR.MINOR.PATCH" into u32 components at compile time.
 const fn parse_semver_component(s: &str, idx: usize) -> u32 {
     let bytes = s.as_bytes();
@@ -1983,7 +1979,7 @@ pub(super) type napi_async_cleanup_hook =
 
 fn napi_span(ptr: *const u8, len: usize) -> &'static [u8] {
     // SAFETY: caller-supplied C string region; lifetime is the duration of the NAPI call.
-    // We use 'static here to match Zig's `[]const u8` borrow semantics across the FFI boundary.
+    // `'static` is used because the slice never outlives the FFI call.
     if ptr.is_null() {
         return &[];
     }
@@ -2243,9 +2239,8 @@ pub(super) extern "C" fn napi_get_uv_event_loop(
     let loop_out = get_out!(env, loop_);
     #[cfg(windows)]
     {
-        // alignment error is incorrect.
+        // A past alignment assertion here fired spuriously.
         // TODO(@190n) investigate
-        // SAFETY: see Zig — @setRuntimeSafety(false) was used here.
         *loop_out = VirtualMachine::get().uv_loop();
     }
     #[cfg(not(windows))]
@@ -2300,7 +2295,7 @@ extern "C" fn napi_internal_register_cleanup_callback(data: *mut c_void) {
 
 #[unsafe(no_mangle)]
 pub(super) extern "C" fn napi_internal_register_cleanup_zig(env_: napi_env) {
-    // SAFETY: caller guarantees env_ is non-null (Zig used `.?`).
+    // SAFETY: caller guarantees env_ is non-null.
     let env = unsafe { &*env_ };
     env.to_js().bun_vm().as_mut().rare_data().push_cleanup_hook(
         env.to_js(),
@@ -2386,7 +2381,8 @@ pub(super) extern "C" fn napi_internal_enqueue_finalizer(
     hint: *mut c_void,
 ) {
     let Some(fun) = fun else { return };
-    // SAFETY: env may be null per Zig's `orelse return`.
+    // SAFETY: env is either null or a valid pointer per the N-API contract;
+    // null returns early.
     let Some(env_ref) = (unsafe { env.as_ref() }) else {
         return;
     };
@@ -2404,7 +2400,7 @@ pub(super) extern "C" fn napi_internal_enqueue_finalizer(
 // ThreadSafeFunction
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO: generate comptime version of this instead of runtime checking
+// TODO: generate a compile-time version of this instead of runtime checking
 pub struct ThreadSafeFunction {
     /// thread-safe functions can be "referenced" and "unreferenced". A
     /// "referenced" thread-safe function will cause the event loop on the thread
@@ -2423,7 +2419,7 @@ pub struct ThreadSafeFunction {
     // for std.condvar
     pub lock: Mutex,
 
-    // PORT NOTE: BackRef — `enqueue_task`/`drain_microtasks` need `&mut
+    // Note: BackRef — `enqueue_task`/`drain_microtasks` need `&mut
     // EventLoop`; reborrowed at use sites (single JS thread).
     pub event_loop: bun_ptr::BackRef<EventLoop>,
     pub tracker: Debugger::AsyncTaskTracker,
@@ -2571,7 +2567,7 @@ impl ThreadSafeFunction {
                 // TODO: is this boolean necessary? Can we rely just on the closing value?
                 if !self.has_queued_finalizer {
                     self.has_queued_finalizer = true;
-                    // PORT NOTE: replace callback with a no-op variant to drop Strong now.
+                    // Note: replace callback with a no-op variant to drop Strong now.
                     self.callback = TsfnCallback::Js(StrongOptional::empty());
                     self.poll_ref.disable();
                     let self_ptr: *mut Self = self;
@@ -2591,7 +2587,6 @@ impl ThreadSafeFunction {
             // `MutexGuard` holds the lock by raw pointer, so it does not borrow
             // `*self` across the `&mut self` calls below.
             let _g = self.lock.lock_guard();
-            // PORT NOTE: reshaped for borrowck — Zig holds the lock across these reads.
             let was_blocked = self.queue.is_blocked();
             let Some(t) = self.queue.data.read_item() else {
                 // When there are no tasks and the number of threads that have
@@ -2701,8 +2696,7 @@ impl ThreadSafeFunction {
         }
 
         let _ = self.queue.count.fetch_add(1, Ordering::SeqCst);
-        // Zig: bun.handleOom — Rust Vec push aborts on OOM by default.
-        let _ = self.queue.data.write_item(ctx); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = self.queue.data.write_item(ctx); // OOM/capacity failures are fire-and-forget
         self.schedule_dispatch();
         NapiStatus::ok as napi_status
     }
@@ -2735,9 +2729,9 @@ impl ThreadSafeFunction {
         self_.unref();
 
         if let Some(fun) = self_.finalizer_fun {
-            // PORT NOTE: ownership transfer of `env` into the Finalizer. We clone (bumps the
+            // Note: ownership transfer of `env` into the Finalizer. We clone (bumps the
             // external refcount) and let the original drop with the Box below — net refcount
-            // delta is zero, equivalent to the Zig move. Avoids writing a zeroed `NonNull`
+            // delta is zero. Avoids writing a zeroed `NonNull`
             // sentinel back into the field, which is UB for `ExternalShared<T>`.
             let env = self_.env.clone();
             let finalizer = Finalizer {
@@ -2972,7 +2966,6 @@ const NAPI_AUTO_LENGTH: usize = usize::MAX;
 #[cfg(not(windows))]
 mod v8_api {
     use core::ffi::c_void;
-    // TODO(port): move to napi_sys
     unsafe extern "C" {
         pub(super) fn _ZN2v87Isolate10GetCurrentEv() -> *mut c_void;
         pub(super) fn _ZN2v87Isolate13TryGetCurrentEv() -> *mut c_void;
@@ -3077,8 +3070,7 @@ mod v8_api {
     // MSVC-mangled symbol names contain `?@$` and are not valid Rust identifiers, so each entry
     // is exposed under a Rust-safe alias via `#[link_name = "..."]`. The list is purely for DCE
     // suppression / link-time existence checks and has no runtime callers — only the symbol
-    // *address* is taken (see `fix_dead_code_elimination`). Keep in sync with the Zig V8API
-    // windows arm in src/runtime/napi/napi.zig.
+    // *address* is taken (see `fix_dead_code_elimination`).
     #[rustfmt::skip]
     unsafe extern "C" {
         #[link_name = "?TryGetCurrent@Isolate@v8@@SAPEAV12@XZ"]
@@ -3277,7 +3269,6 @@ mod posix_platform_specific_v8_apis {
 
 #[cfg(unix)]
 mod uv_functions_to_export {
-    // TODO(port): move to napi_sys
     unsafe extern "C" {
         pub(super) fn uv_accept();
         pub(super) fn uv_async_init();
@@ -3754,9 +3745,8 @@ pub fn fix_dead_code_elimination() {
     );
 
     // uv_functions_to_export
-    // TODO(port): Zig iterates std.meta.declarations(uv_functions_to_export) — Rust has no
-    // reflection over extern blocks. Script-generate this black_box list from
-    // the `uv_functions_to_export` module above, or rely on `#[used]` static fn-ptr arrays.
+    // This list is hand-maintained — keep it in sync with the
+    // `uv_functions_to_export` module above.
     #[cfg(unix)]
     {
         use uv_functions_to_export::*;
@@ -4081,7 +4071,8 @@ pub fn fix_dead_code_elimination() {
     }
 
     // V8API
-    // TODO(port): Zig iterates std.meta.declarations(V8API) — same reflection caveat as above.
+    // Hand-maintained for the same reason as the uv list above (no reflection
+    // over extern blocks) — keep in sync with the `v8_api` module.
     #[cfg(not(windows))]
     {
         use v8_api::*;
@@ -4314,5 +4305,3 @@ impl NapiFinalizerTask {
         Self::run_on_js_thread(this);
     }
 }
-
-// ported from: src/napi/napi.zig
diff --git a/src/runtime/node.rs b/src/runtime/node.rs
index 16b3f5897be..daac1fc22b0 100644
--- a/src/runtime/node.rs
+++ b/src/runtime/node.rs
@@ -1,11 +1,10 @@
-//! Node.js APIs in Bun. Access this namespace with `bun.api.node`
+//! Node.js APIs in Bun.
 
-// PORT NOTE: the Zig `comptime { _ = @import(...) }` force-reference block maps
-// to explicit `pub mod` declarations below. Rust only compiles a `.rs` file if
-// it is reachable via a `mod` declaration — `#[no_mangle]` alone does NOT make
-// an orphaned file link. Every Windows-only force-referenced sibling
-// (`uv_signal_handle_windows`, `win_watcher`) must have a `#[cfg(windows)]
-// pub mod` entry here or its C-ABI exports will be missing at link time.
+// Rust only compiles a `.rs` file if it is reachable via a `mod` declaration —
+// `#[no_mangle]` alone does NOT make an orphaned file link. Every Windows-only
+// sibling (`uv_signal_handle_windows`, `win_watcher`) must have a
+// `#[cfg(windows)] pub mod` entry here or its C-ABI exports will be missing at
+// link time.
 
 // ─── compiling submodules ─────────────────────────────────────────────────
 #[path = "node/nodejs_error_code.rs"]
@@ -82,10 +81,9 @@ pub mod util {
 }
 pub use util::validators;
 
-// `crate::node::dirent::Kind` shim for dir_iterator.rs / node_fs.rs — the
-// Zig spec exports `Dirent = types.Dirent` and callers reach `.Kind` through
-// it. Rust can't hang an associated module off a struct re-export, so expose
-// a tiny module mirroring that shape.
+// `crate::node::dirent::Kind` shim for dir_iterator.rs / node_fs.rs —
+// callers reach `.Kind` through `Dirent`. Rust can't hang an associated
+// module off a struct re-export, so expose a tiny module mirroring that shape.
 pub mod dirent {
     pub use super::types::Dirent;
     pub use super::types::DirentKind as Kind;
@@ -106,8 +104,7 @@ pub mod path_watcher;
 #[cfg(windows)]
 #[path = "node/win_watcher.rs"]
 pub mod win_watcher;
-// Zig: `comptime { if (Environment.isWindows) _ = @import("./node/uv_signal_handle_windows.zig"); }`
-// — force-references `Bun__UVSignalHandle__init` / `Bun__UVSignalHandle__close`
+// Force-references `Bun__UVSignalHandle__init` / `Bun__UVSignalHandle__close`
 // for C++ (`src/jsc/bindings/BunProcess.cpp`). Must be `mod`-declared or the
 // `#[no_mangle]` exports are never compiled into the binary.
 #[path = "node/node_fs_binding.rs"]
@@ -168,8 +165,8 @@ pub mod zlib {
     pub use super::native_zlib_impl as native_zlib;
     pub use super::native_zstd_impl as native_zstd;
     pub use bun_zlib::NodeMode;
-    // PORT NOTE: the `NativeZlib` / `NativeBrotli` / `NativeZstd` *struct*
-    // re-exports were dropped — those structs live inside each file's private
+    // The `NativeZlib` / `NativeBrotli` / `NativeZstd` *struct* re-exports are
+    // intentionally absent — those structs live inside each file's private
     // `mod _impl { ... }` (JSC-gated) and are not reachable from here. The only
     // consumers (`node_zlib_binding.rs::_impl::Native*`) are themselves gated
     // behind a private `_impl` and resolve through `crate::api::Native*` once
@@ -193,27 +190,23 @@ pub type gid_t = bun_sys::windows::libuv::uv_gid_t;
 /// - "path"
 /// - "errno"
 ///
-/// We can't really use Zig's error handling for syscalls because Node.js expects the "real" errno to be returned
-/// and various issues with std.posix that make it too unstable for arbitrary user input (e.g. how .BADF is marked as unreachable)
-///
 /// Phase F: collapsed from a bespoke `enum Maybe { Err, Result }` into a plain
-/// `core::result::Result` alias. The Zig-parity helper methods (`todo`,
+/// `core::result::Result` alias. The legacy helper methods (`todo`,
 /// `success`, `errno_sys*`, `to_js`, …) move to the [`MaybeExt`] /
 /// [`MaybeSysExt`] / [`MaybeToJsExt`] extension traits below so call sites can
 /// keep using `Maybe::<T>::helper()` while gaining `?` propagation for free.
 pub type Maybe<R, E = bun_sys::Error> = core::result::Result<R, E>;
 
-// `union(enum)` → Rust enum is the tagged union; the explicit `Tag` enum is
-// kept only for source parity with the Zig.
+// The explicit `Tag` enum is kept only for legacy call sites.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum MaybeTag {
     Err,
     Result,
 }
 
-/// Generic helper surface that the Zig `Maybe(R, E)` carried as inherent
-/// methods. `unwrap_or`/`is_ok`/`is_err`/`map_err` are already provided by
-/// `core::result::Result`, so only the Zig-specific constructors remain here.
+/// Generic helper surface for `Maybe(R, E)`.
+/// `unwrap_or`/`is_ok`/`is_err`/`map_err` are already provided by
+/// `core::result::Result`, so only the extra constructors remain here.
 pub trait MaybeExt<R, E>: Sized {
     fn todo() -> Self
     where
@@ -237,8 +230,6 @@ impl<R, E> MaybeExt<R, E> for Maybe<R, E> {
         E: MaybeErrorTodo,
     {
         if cfg!(debug_assertions) {
-            // PORT NOTE: Zig branched on `ReturnType == void` only to vary the
-            // panic message; collapsed to a single panic + type name.
             panic!("TODO: Maybe({})", core::any::type_name::<R>());
         }
         Err(E::todo())
@@ -269,8 +260,8 @@ impl<R, E> MaybeExt<R, E> for Maybe<R, E> {
     where
         R: Default,
     {
-        // PORT NOTE: Zig used `std.mem.zeroes(ReturnType)`. Mapped to
-        // `Default` here since the generic `R` may contain non-POD fields.
+        // `Default` rather than zeroed memory — the generic `R` may contain
+        // non-POD fields.
         Ok(R::default())
     }
 
@@ -283,8 +274,7 @@ impl<R, E> MaybeExt<R, E> for Maybe<R, E> {
     }
 }
 
-/// `Maybe<bool, E>::is_true()` — Zig `if (comptime ReturnType != bool)
-/// @compileError(...)` enforced by impl bound.
+/// `Maybe<bool, E>::is_true()` — restricted to `bool` by the impl bound.
 pub trait MaybeBoolExt {
     fn is_true(self) -> bool;
 }
@@ -301,8 +291,7 @@ pub trait MaybeErrorRetry: Sized {
     fn retry() -> Self;
 }
 
-/// `@hasDecl(E, "todo")` shim — default falls back to `Default::default()`
-/// matching Zig's `ErrorType{}`.
+/// `todo()` shim — default falls back to `Default::default()`.
 pub trait MaybeErrorTodo: Sized + Default {
     fn todo() -> Self {
         Self::default()
@@ -310,9 +299,8 @@ pub trait MaybeErrorTodo: Sized + Default {
 }
 
 /// Extension surface providing `Maybe::todo()` on `bun_sys::Maybe<T>`
-/// (= `core::result::Result<T, bun_sys::Error>`). Zig's `Maybe(T).todo()`
-/// returns `.{ .err = bun.sys.Error.todo() }`; this is the Rust equivalent for
-/// the upstream type-alias form of `Maybe` used throughout `node/`.
+/// (= `core::result::Result<T, bun_sys::Error>`), the type-alias form of
+/// `Maybe` used throughout `node/`.
 pub trait MaybeTodo: Sized {
     fn todo() -> Self;
 }
@@ -326,8 +314,8 @@ impl<T> MaybeTodo for core::result::Result<T, bun_sys::Error> {
 
 // ─── methods that assume `E` carries an errno (i.e. `bun_sys::Error`) ─────
 
-/// Extension surface for `Maybe<R, bun_sys::Error>` carrying the Zig
-/// `Maybe(T)` errno helpers (`aborted`, `init_err_with_p`, `to_array_buffer`,
+/// Extension surface for `Maybe<R, bun_sys::Error>` carrying the
+/// errno helpers (`aborted`, `init_err_with_p`, `to_array_buffer`,
 /// `errno*`). Kept as a trait now that `Maybe` is a `Result` alias and can no
 /// longer host inherent impls.
 pub trait MaybeSysExt<R>: Sized {
@@ -372,7 +360,6 @@ impl<R> MaybeSysExt<R> for Maybe<R, bun_sys::Error> {
     #[inline]
     fn aborted() -> Self {
         Err(bun_sys::Error {
-            // PORT NOTE: Zig `posix.E.INTR` → `SystemErrno::EINTR` (variants keep `E` prefix).
             errno: bun_sys::posix::E::EINTR as bun_sys::ErrorInt,
             syscall: bun_sys::Tag::access,
             ..Default::default()
@@ -403,8 +390,7 @@ impl<R> MaybeSysExt<R> for Maybe<R, bun_sys::Error> {
         use bun_jsc::SysErrorJsc as _;
         match self {
             Ok(r) => {
-                // PORT NOTE: Zig hands the result slice straight to
-                // `ArrayBuffer.fromBytes` and ownership transfers to JSC — the
+                // Ownership of the result slice transfers to JSC — the
                 // GC-installed deallocator (`MarkedArrayBuffer_deallocator`)
                 // calls `mi_free` on the buffer when the JS object is
                 // collected. Leak the `Vec` here to hand the allocation to
@@ -475,8 +461,8 @@ impl<R> MaybeSysExt<R> for Maybe<R, bun_sys::Error> {
         syscall: bun_sys::Tag,
         file_path: impl AsRef<[u8]>,
     ) -> Option<Self> {
-        // PORT NOTE: Zig `@compileError` on `u16` paths is enforced by the
-        // `AsRef<[u8]>` bound — UTF-16 slices won't satisfy it.
+        // UTF-16 (`u16`) paths are rejected at compile time by the
+        // `AsRef<[u8]>` bound.
         #[cfg(windows)]
         {
             if !Rc::IS_NTSTATUS {
@@ -530,7 +516,7 @@ impl<R> MaybeSysExt<R> for Maybe<R, bun_sys::Error> {
         file_path: impl AsRef<[u8]>,
         dest: impl AsRef<[u8]>,
     ) -> Option<Self> {
-        // PORT NOTE: Zig `@compileError` on `u16` paths enforced by `AsRef<[u8]>`.
+        // UTF-16 (`u16`) paths are rejected at compile time by the `AsRef<[u8]>` bound.
         #[cfg(windows)]
         {
             if !Rc::IS_NTSTATUS {
@@ -559,14 +545,12 @@ pub trait MaybeCssExt<R>: Sized {
 impl<R> MaybeCssExt<R> for Maybe<R, bun_css::BasicParseError> {
     #[inline]
     fn to_css_result(self) -> Maybe<R, bun_css::ParseError<bun_css::ParserError>> {
-        // Zig comptime-switched on `ErrorTypeT`; in Rust we express each arm
-        // as a separate trait impl. The `ParseError(ParserError)` and
-        // catch-all arms were `@compileError`s and need no Rust body.
+        // Each error-type arm is expressed as a separate trait impl.
         self.map_err(|e| e.into_default_parse_error())
     }
 }
 
-// ─── to_js: comptime @typeInfo dispatch → trait ───────────────────────────
+// ─── to_js: trait-based dispatch ──────────────────────────────────────────
 
 /// `Maybe::to_js` — extension trait now that `Maybe` is a `Result` alias.
 pub trait MaybeToJsExt {
@@ -586,9 +570,8 @@ where
     }
 }
 
-/// Replaces the Zig `switch (ReturnType) { ... @typeInfo ... }` reflection in
-/// `Maybe.toJS`. Each concrete `R`/`E` opts in by implementing this trait;
-/// the Zig comptime `@typeInfo` arms map to per-type impls below.
+/// `Maybe.toJS` dispatch: each concrete `R`/`E` opts in by implementing this
+/// trait via the per-type impls below.
 pub trait MaybeToJs {
     fn maybe_to_js(
         self,
@@ -637,7 +620,7 @@ impl MaybeToJs for Vec<u8> {
         self,
         global_object: &bun_jsc::JSGlobalObject,
     ) -> bun_jsc::JsResult<bun_jsc::JSValue> {
-        // PORT NOTE: ownership transfers to JSC (freed via
+        // Ownership transfers to JSC (freed via
         // `MarkedArrayBuffer_deallocator` → `mi_free`); see
         // `MaybeSysExt::to_array_buffer` above for the full rationale.
         let bytes: &mut [u8] = Vec::leak(self);
@@ -661,7 +644,7 @@ macro_rules! impl_maybe_to_js_number {
 }
 impl_maybe_to_js_number!(i32, u32, f64, u64, usize);
 
-// `.pointer` (zig string) arm — `ZigString.init(..).withEncoding().toJS(..)`.
+// String arm — `ZigString.init(..).withEncoding().toJS(..)`.
 impl MaybeToJs for &[u8] {
     fn maybe_to_js(
         self,
@@ -685,23 +668,17 @@ impl MaybeToJs for bun_sys::Error {
     }
 }
 
-// PORT NOTE: the Zig `.@"struct" / .@"enum" / .@"opaque" / .@"union"` and
-// non-string `.pointer` arms forwarded to `r.toJS(globalObject)`. In Rust each
-// such `R` implements `MaybeToJs` directly at its definition site (no blanket
-// `@typeInfo` reflection available); add per-type impls alongside the type.
-
-// PORT NOTE: the Zig `Maybe.format` (Display) impl is dropped — `Maybe` is now
-// `core::result::Result`, which already has `Debug`, and a foreign `Display`
-// impl on a foreign type is not expressible. No call sites depended on it.
+// There is no blanket reflection-style impl: each result type `R` that needs
+// `r.toJS(globalObject)` semantics implements `MaybeToJs` directly at its
+// definition site; add per-type impls alongside the type.
 
 // ─── helpers ──────────────────────────────────────────────────────────────
 
 /// Abstracts over the `rc: anytype` parameter of the `errnoSys*` family.
-/// On Windows the Zig checked `@TypeOf(rc) == std.os.windows.NTSTATUS` to
-/// skip the `rc != 0 → null` early-out; that comptime type-compare is
-/// expressed here as the `IS_NTSTATUS` associated const.
+/// On Windows, NTSTATUS rc types skip the `rc != 0 → null` early-out; that
+/// type distinction is expressed here as the `IS_NTSTATUS` associated const.
 ///
-/// `syscall_errno` is the per-type Zig `sys.getErrno(rc)` dispatch: integer
+/// `syscall_errno` is the per-type errno dispatch: integer
 /// rc → libc/Win32 errno, NTSTATUS rc → `translateNTStatusToErrno(rc)`. This
 /// MUST live on the trait — the free `bun_sys::get_errno` on Windows is
 /// unbounded and *ignores `rc`* (reads `GetLastError()`), so routing an
@@ -712,8 +689,7 @@ pub trait SyscallRc: Copy {
     fn syscall_errno(self) -> bun_sys::posix::E;
 }
 
-// Integer rc types: Windows path applies the `rc != 0 → None` short-circuit
-// (Zig spec: `if (rc != 0) return null;` in the non-NTSTATUS arm).
+// Integer rc types: Windows path applies the `rc != 0 → None` short-circuit.
 macro_rules! impl_syscall_rc_int {
     ($($t:ty),* $(,)?) => {$(
         impl SyscallRc for $t {
@@ -734,8 +710,7 @@ impl_syscall_rc_int!(i32, i64, isize, u32, usize);
 #[cfg(windows)]
 impl_syscall_rc_int!(u64);
 
-// Zig: `if (comptime @TypeOf(rc) == std.os.windows.NTSTATUS) {} else { ... }`
-// — NTSTATUS must OPT OUT of the `rc != 0 → None` short-circuit so real NT
+// NTSTATUS must OPT OUT of the `rc != 0 → None` short-circuit so real NT
 // error codes reach `get_errno`. The trait default is `false`, so this impl
 // MUST override `IS_NTSTATUS = true` explicitly.
 #[cfg(windows)]
@@ -747,9 +722,8 @@ impl SyscallRc for bun_sys::windows::NTSTATUS {
     }
     #[inline]
     fn syscall_errno(self) -> bun_sys::posix::E {
-        // Zig windows_errno.zig:286: NTSTATUS arm of `getErrno` →
-        // `bun.windows.translateNTStatusToErrno(rc)`. Do NOT fall through to
-        // `GetLastError()`.
+        // NTSTATUS maps through `translate_ntstatus_to_errno`. Do NOT fall
+        // through to `GetLastError()`.
         bun_sys::windows::translate_ntstatus_to_errno(self)
     }
 }
@@ -761,7 +735,7 @@ pub trait IntoErrInt: Copy {
 
 impl IntoErrInt for bun_sys::posix::E {
     fn into_err_int(self) -> bun_sys::ErrorInt {
-        // @truncate(@intFromEnum(err)) — SystemErrno is #[repr(u16)], ErrorInt = u16.
+        // SystemErrno is #[repr(u16)], ErrorInt = u16.
         self as bun_sys::ErrorInt
     }
 }
@@ -769,7 +743,6 @@ impl IntoErrInt for bun_sys::posix::E {
 #[cfg(windows)]
 impl IntoErrInt for bun_sys::windows::NTSTATUS {
     fn into_err_int(self) -> bun_sys::ErrorInt {
-        // Zig: `@intFromEnum(bun.windows.translateNTStatusToErrno(err))`
         bun_sys::windows::translate_ntstatus_to_errno(self) as bun_sys::ErrorInt
     }
 }
@@ -777,5 +750,3 @@ impl IntoErrInt for bun_sys::windows::NTSTATUS {
 fn translate_to_err_int<Er: IntoErrInt>(err: Er) -> u16 {
     err.into_err_int()
 }
-
-// ported from: src/runtime/node.zig
diff --git a/src/runtime/node/Stat.rs b/src/runtime/node/Stat.rs
index 98a6af3de17..ac4e8912284 100644
--- a/src/runtime/node/Stat.rs
+++ b/src/runtime/node/Stat.rs
@@ -12,11 +12,11 @@ const MS_PER_S: i64 = bun_core::time::MS_PER_S as i64;
 const NS_PER_MS: i64 = bun_core::time::NS_PER_MS as i64;
 
 /// Stats and BigIntStats classes from node:fs
-// PORT NOTE: Zig `fn StatType(comptime big: bool) type` → const-generic struct.
-// Zig's `const Float = if (big) i64 else f64;` cannot be expressed as a
-// const-generic-dependent type alias in stable Rust, so `to_time_ms` is split
-// into `to_time_ms_i64` / `to_time_ms_f64` and called from the appropriate
-// branch in `stat_to_js`. Diff readers should expect this reshape.
+// `BIG` selects the BigIntStats (i64) vs Stats (f64) flavour. A
+// const-generic-dependent type alias (`if BIG { i64 } else { f64 }`) is not
+// expressible in stable Rust, so `to_time_ms` is split into
+// `to_time_ms_i64` / `to_time_ms_f64` and called from the appropriate
+// branch in `stat_to_js`.
 pub struct StatType<const BIG: bool> {
     pub value: PosixStat,
 }
@@ -24,8 +24,7 @@ pub struct StatType<const BIG: bool> {
 type StatTimespec = Timespec;
 
 impl<const BIG: bool> StatType<BIG> {
-    // Zig: `pub const new = bun.TrivialNew(@This());` / `bun.TrivialDeinit(@This())`.
-    // In Rust the default `Box::new` / `Drop` give identical semantics (mimalloc-backed
+    // The default `Box::new` / `Drop` give the needed semantics (mimalloc-backed
     // via the global allocator), so no explicit `new`/`deinit` methods are needed.
 
     #[inline]
@@ -35,16 +34,14 @@ impl<const BIG: bool> StatType<BIG> {
 
     #[inline]
     fn to_nanoseconds(ts: StatTimespec) -> u64 {
-        // PORT NOTE: Zig rebuilt a `bun.timespec` with `@intCast` on each field; since
-        // `StatTimespec == bun.timespec` those casts are identity — call methods on `ts`
-        // directly.
         if ts.sec < 0 {
             return ts.ns_signed().max(0) as u64;
         }
         ts.ns()
     }
 
-    // PORT NOTE: reshaped for const-generic type selection — see struct-level note.
+    // Split into i64/f64 variants for const-generic type selection — see the
+    // struct-level note.
     fn to_time_ms_i64(ts: StatTimespec) -> i64 {
         // On windows, Node.js purposefully misinterprets time values
         // > On win32, time is stored in uint64_t and starts from 1601-01-01.
@@ -249,10 +246,7 @@ impl Stats {
         }
     }
 
-    // PORT NOTE: Zig defined `Stats.toJS` as a `@compileError` guard to force callers
-    // toward `toJSNewlyCreated`. Rust has no inherent-method `compile_error!`; the
-    // method is intentionally omitted so misuse is a hard "no method named `to_js`"
-    // compile error instead.
+    // A `to_js` method is intentionally omitted to force callers toward
+    // `to_js_newly_created` — misuse is a hard "no method named `to_js`"
+    // compile error.
 }
-
-// ported from: src/runtime/node/Stat.zig
diff --git a/src/runtime/node/StatFS.rs b/src/runtime/node/StatFS.rs
index f893876771b..feded77e7e2 100644
--- a/src/runtime/node/StatFS.rs
+++ b/src/runtime/node/StatFS.rs
@@ -10,8 +10,7 @@ pub(crate) type RawStatFS = libc::statfs;
 #[cfg(not(unix))]
 pub(crate) type RawStatFS = bun_sys::StatFS;
 
-// PORT NOTE: Zig `pub fn StatFSType(comptime big: bool) type` picks the field
-// integer type via `const Int = if (big) i64 else i32;`. Stable Rust const
+// The field integer type is i64 ("big") or i32 ("small"). Stable Rust const
 // generics cannot select a field type from a `const BIG: bool`, so we generate
 // the two concrete instantiations with a small macro. The two exported aliases
 // (`StatFSSmall`, `StatFSBig`) are the only call sites.
@@ -82,10 +81,9 @@ macro_rules! define_statfs_type {
                 #[cfg(target_arch = "wasm32")]
                 compile_error!("Unsupported OS");
 
-                // @truncate(@as(i64, @intCast(x))) — @intCast to i64 then @truncate to Int.
-                // PORT NOTE: platform field types vary (u32/i64/u64); `as i64` matches
-                // Zig's @intCast for the in-range values statfs reports, then `as $Int`
-                // is the @truncate (intentional wrap).
+                // Platform field types vary (u32/i64/u64); widen with `as i64`
+                // (lossless for the in-range values statfs reports), then `as $Int`
+                // truncates (intentional wrap).
                 Self {
                     _fstype: (fstype_ as i64) as $Int,
                     _bsize: (bsize_ as i64) as $Int,
@@ -100,7 +98,6 @@ macro_rules! define_statfs_type {
     };
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     pub safe fn Bun__JSBigIntStatFSObjectConstructor(global: &JSGlobalObject) -> JSValue;
     pub safe fn Bun__JSStatFSObjectConstructor(global: &JSGlobalObject) -> JSValue;
@@ -154,9 +151,6 @@ impl StatFS {
         }
     }
 
-    // PORT NOTE: Zig `toJS` body is `@compileError(...)` — intentionally not
-    // callable. Omitted in Rust; callers must use `to_js_newly_created` or call
-    // `to_js` on `StatFSBig`/`StatFSSmall` directly.
+    // A `to_js` method is intentionally omitted; callers must use
+    // `to_js_newly_created` or call `to_js` on `StatFSBig`/`StatFSSmall` directly.
 }
-
-// ported from: src/runtime/node/StatFS.zig
diff --git a/src/runtime/node/assert/myers_diff.rs b/src/runtime/node/assert/myers_diff.rs
index 85363fac5b1..09811c2fe47 100644
--- a/src/runtime/node/assert/myers_diff.rs
+++ b/src/runtime/node/assert/myers_diff.rs
@@ -9,13 +9,12 @@
 use core::fmt;
 use core::marker::PhantomData;
 
-/// Comptime diff configuration. Defaults are usually sufficient.
+/// Diff configuration. Defaults are usually sufficient.
 ///
-/// PORT NOTE: In Zig this is passed as a `comptime opts: Options` struct param.
 /// Rust cannot pass a struct as a const generic on stable, so the only
 /// behaviorally-meaningful field (`check_comma_disparity`) is hoisted to a
 /// `const CHECK_COMMA_DISPARITY: bool` generic on `Differ`. The two sizing
-/// fields only fed `std.heap.stackFallback`, which is dropped (see PERF notes
+/// fields are advisory only and otherwise unused (see PERF notes
 /// in `diff`).
 #[derive(Clone, Copy)]
 pub struct Options {
@@ -60,13 +59,12 @@ type uint = u32;
 #[allow(non_camel_case_types)]
 type int = i64; // must be large enough to hold all valid values of `uint` w/o overflow.
 
-/// PORT NOTE: Zig's `Differ` switches on the concrete `Line` type at comptime
-/// to pick an equality function (char `==` for `u8`/`u16`, `areStrLinesEqual`
-/// for slice types) and to detect "is this a pointer/slice" inside
-/// `backtrack`. Rust expresses both via this trait — implement it for any new
-/// line type instead of extending the type-switch.
+/// `Differ` needs a per-`Line`-type equality function (char `==` for
+/// `u8`/`u16`, string-line equality for slice types) and a way to detect
+/// "is this a pointer/slice" inside `backtrack`. Both are expressed via this
+/// trait — implement it for any new line type.
 pub trait Line: Copy {
-    /// `@typeInfo(Line) == .pointer` in the Zig.
+    /// Whether this line type is a pointer/slice type.
     const IS_POINTER: bool;
     /// Equality with optional trailing-comma tolerance.
     fn line_eq<const CHECK_COMMA_DISPARITY: bool>(a: Self, b: Self) -> bool;
@@ -121,10 +119,8 @@ impl<'a> Line for &'a [u16] {
         matches!(self.last(), Some(&c) if c == u16::from(b','))
     }
 }
-// TODO(port): Zig also accepted `[:0]const u8`, `[:0]u8`, `[]u8`, `[:0]const u16`,
-// `[:0]u16`, `[]u16` — in Rust these all coerce to `&[u8]`/`&[u16]`, so the two
-// slice impls above cover them. Add `&bun_core::ZStr` / `&bun_core::WStr` impls
-// if callers pass those directly.
+// All borrowed byte/char-slice variants coerce to `&[u8]`/`&[u16]`, so the
+// two slice impls above cover them.
 
 /// diffs two sets of lines, returning the minimal number of edits needed to
 /// make them equal.
@@ -147,10 +143,8 @@ impl<'a> Line for &'a [u16] {
 /// - [Node- `myers_diff.js`](https://github.com/nodejs/node/blob/main/lib/internal/assert/myers_diff.js)
 /// - [An O(ND) Difference Algorithm and Its Variations](http://www.xmailserver.org/diff2.pdf)
 ///
-/// PORT NOTE: Zig's `Differ(Line, opts)` is a thin wrapper that picks an `eql`
-/// based on `Line` and delegates to `DifferWithEql`. In Rust the `eql` dispatch
-/// is the `Line` trait, so the two collapse into one type. To supply a custom
-/// equality function (Zig's `DifferWithEql`), implement `Line` for your type.
+/// The `eql` dispatch is the `Line` trait. To supply a custom equality
+/// function, implement `Line` for your type.
 pub struct Differ<L, const CHECK_COMMA_DISPARITY: bool = false>(PhantomData<L>);
 
 /// struct.
@@ -159,17 +153,12 @@ pub type DifferWithEql<L, const CHECK_COMMA_DISPARITY: bool = false> =
 
 impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY> {
     // `V = [-MAX, MAX]`.
-    // PORT NOTE: `graph_initial_size` (Zig) only fed `stackFallback`; dropped.
 
     #[inline]
     pub(crate) fn eql(a: L, b: L) -> bool {
         L::line_eq::<CHECK_COMMA_DISPARITY>(a, b)
     }
 
-    // PORT NOTE: Zig `pub const LineType = L;` would be an inherent associated
-    // type in Rust, which is unstable (rust#8995). Dropped — callers spell `L`
-    // directly via the `Differ<L, ..>` generic param.
-
     /// Compute the shortest edit path (diff) between two sets of lines.
     ///
     /// Returned `Diff` objects borrow from the input slices. Both `actual`
@@ -179,11 +168,6 @@ impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY
     /// - [Node- `myers_diff.js`](https://github.com/nodejs/node/blob/main/lib/internal/assert/myers_diff.js)
     /// - [An O(ND) Difference Algorithm and Its Variations](http://www.xmailserver.org/diff2.pdf)
     pub(crate) fn diff(actual: &[L], expected: &[L]) -> Result<DiffList<L>, Error> {
-        // Edit graph's allocator
-        // PERF(port): was stack-fallback (graph_initial_size bytes) — profile if it shows up on a hot path
-        // Match point trace's allocator
-        // PERF(port): was stack-fallback (opts.initial_trace_capacity bytes) — profile if it shows up on a hot path
-
         // const MAX \in [0, M+N]
         // let V: int array = [-MAX..MAX]. V is a flattened representation of the edit graph.
         let (max, graph_size): (uint, uint) = 'blk: {
@@ -209,15 +193,11 @@ impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY
         };
 
         let mut graph: Vec<uint> = vec![0; graph_size as usize];
-        // (Zig: `defer graph_alloc.free(graph)` — Drop handles it.)
-        // (Zig: `@memset(graph, 0)` — vec! already zeroed.)
-        // graph.len = graph_size; — already sized.
 
         let mut trace: Vec<Box<[uint]>> = Vec::new();
         // reserve enough space for each frame to avoid realloc on ptr list. Lists may end up in the heap, but
         // this list is at the very from (and ∴ on stack).
         trace.reserve_exact((max as usize) + 1);
-        // (Zig: defer { for frame free; trace.deinit() } — Drop handles it.)
 
         // ================================================================
         // ==================== actual implementation =====================
@@ -231,9 +211,7 @@ impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY
             if trace_bytes > MAX_TRACE_BYTES {
                 return Err(Error::DiffTooLarge);
             }
-            // const new_trace = try TraceFrame.initCapacity(trace_alloc, graph.len);
             let new_trace: Box<[uint]> = graph.clone().into_boxed_slice();
-            // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
             trace.push(new_trace);
 
             let diag_start: int = -diff_level;
@@ -338,7 +316,6 @@ impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY
                     }
                 };
 
-                // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path
                 result.push(Diff {
                     kind: DiffKind::Equal,
                     value: line,
@@ -367,7 +344,7 @@ impl<L: Line, const CHECK_COMMA_DISPARITY: bool> Differ<L, CHECK_COMMA_DISPARITY
     }
 }
 
-// shorthands for int casting since I'm tired of writing `@as(int, @intCast(x))` everywhere
+// shorthands for int casting
 #[inline]
 fn u<N: TryInto<uint>>(n: N) -> uint
 where
@@ -397,8 +374,6 @@ where
 #[cfg(test)]
 #[inline]
 fn are_lines_equal<L: Line, const CHECK_COMMA_DISPARITY: bool>(a: L, b: L) -> bool {
-    // PORT NOTE: Zig switched on the concrete type here; the `Line` trait impls
-    // encode the same dispatch.
     L::line_eq::<CHECK_COMMA_DISPARITY>(a, b)
 }
 
@@ -411,8 +386,6 @@ where
     // TODO: check Godbolt
     // if (a.ptr == b.ptr) return true;
 
-    // []const u8 -> u8  (Zig: @typeInfo(T).pointer.child — here `C` is that child.)
-
     if !CHECK_COMMA_DISPARITY {
         return a == b;
     }
@@ -444,9 +417,6 @@ pub enum Error {
 
 bun_core::oom_from_alloc!(Error);
 
-// TODO(port): narrow error set — `From<Error> for bun_core::Error` provided by
-// the `IntoStaticStr` derive convention (see PORTING.md §Type map).
-
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum DiffKind {
     Insert,
@@ -472,17 +442,14 @@ pub struct Diff<T> {
 
 impl<T: PartialEq> Diff<T> {
     pub fn eql(&self, other: &Self) -> bool {
-        // PORT NOTE: Zig used `mem.eql(T, self.value, other.value)` which only
-        // compiles for slice `T`; `PartialEq` covers both slice and char cases.
         self.kind == other.kind && self.value == other.value
     }
 }
 
 impl<T: fmt::Display> fmt::Display for Diff<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO(port): Zig picked a format specifier ({c}/{u}/{s}) based on
-        // @typeInfo(T). For `&[u8]` callers, wrap value in `bstr::BStr::new`
-        // at the call site instead of `from_utf8`.
+        // For `&[u8]` callers, wrap `value` in `bstr::BStr::new` at the call
+        // site to get string (rather than byte-array) output.
         write!(f, "{} {}", self.kind, self.value)
     }
 }
@@ -557,28 +524,6 @@ mod tests {
         ));
     }
 
-    // const CharList = DiffList(u8);
-    // const CDiff = Diff(u8);
-    // const CharDiffer = Differ(u8, .{});
-    //
-    // fn testCharDiff(actual: []const u8, expected: []const u8, expected_diff: []const Diff(u8)) !void {
-    //     const allocator = t.allocator;
-    //     const actual_diff = try CharDiffer.diff(allocator, actual, expected);
-    //     defer actual_diff.deinit();
-    //     try t.expectEqualSlices(Diff(u8), expected_diff, actual_diff.items);
-    // }
-    //
-    // test CharDiffer {
-    //     const TestCase = std.meta.Tuple(&[_]type{ []const CDiff, []const u8, []const u8 });
-    //     const test_cases = &[_]TestCase{
-    //         .{ &[_]CDiff{}, "foo", "foo" },
-    //     };
-    //     for (test_cases) |test_case| {
-    //         const expected_diff, const actual, const expected = test_case;
-    //         try testCharDiff(actual, expected, expected_diff);
-    //     }
-    // }
-
     type StrDiffer<'a> = Differ<&'a [u8], true>;
 
     #[test]
@@ -624,17 +569,14 @@ pub fn split<T>(s: &[T]) -> Vec<&[T]>
 where
     T: PartialEq + Copy + From<u8>,
 {
-    // PORT NOTE: Zig restricted T to u8/u16 via @compileError; the From<u8>
-    // bound expresses the same constraint (need to compare against '\n').
+    // The From<u8> bound restricts T to char-like types (need to compare
+    // against '\n').
     let newline: T = T::from(b'\n');
     //
     // thing
     let mut lines: Vec<&[T]> = Vec::with_capacity(s.len() >> 4);
-    // (Zig: errdefer lines.deinit — Drop handles it.)
     for l in s.split(|c| *c == newline) {
         lines.push(l);
     }
     lines
 }
-
-// ported from: src/runtime/node/assert/myers_diff.zig
diff --git a/src/runtime/node/buffer.rs b/src/runtime/node/buffer.rs
index 9c90e751a35..40f3cd91227 100644
--- a/src/runtime/node/buffer.rs
+++ b/src/runtime/node/buffer.rs
@@ -39,7 +39,7 @@ mod _impl {
                 encoding
             };
 
-            // PORT NOTE: encoder::write_u8/write_u16 take the encoding as a const-generic
+            // encoder::write_u8/write_u16 take the encoding as a const-generic
             // `u8` (stable-Rust workaround for `adt_const_params`) — `dispatch_encoding!`
             // expands the runtime `encoding` into nine monomorphized arms.
             // SAFETY: `s` and `buf` are valid slices derived above; the source/destination
@@ -63,7 +63,6 @@ mod _impl {
                 // SAFETY: caller (`extern "C"` fill) guarantees `s`/`buf` are valid disjoint buffers per the Buffer.fill contract.
                 }, |E| unsafe { encoder::write_u8::<E>(s.as_ptr(), s.len(), buf.as_mut_ptr(), buf.len()) })
             };
-            // Zig writeU8/writeU16 return `!usize`; Rust port returns `Result<usize, _>` so `written` is already usize.
             let Ok(written) = result else {
                 return false;
             };
@@ -121,10 +120,8 @@ mod _impl {
                 _ => {}
             }
 
-            // PORT NOTE: reshaped for borrowck — Zig grew two slices (`contents`, `buf`) into the
-            // same underlying buffer and mutated `contents.len` in place. Here we track offsets
-            // and use copy_within (src/dst share `buf`).
-            // PERF(port): was memcpy (non-overlapping) — profile if memmove-vs-memcpy matters here.
+            // `contents` and the fill destination share the same underlying buffer,
+            // so track offsets and use copy_within (src/dst overlap within `buf`).
             let mut contents_len = written;
             let mut buf_offset = written;
 
@@ -143,5 +140,3 @@ mod _impl {
         }
     }
 } // mod _impl
-
-// ported from: src/runtime/node/buffer.zig
diff --git a/src/runtime/node/dir_iterator.rs b/src/runtime/node/dir_iterator.rs
index 37c8417511c..386934e1df5 100644
--- a/src/runtime/node/dir_iterator.rs
+++ b/src/runtime/node/dir_iterator.rs
@@ -1,9 +1,8 @@
-// This is copied from std.fs.Dir.Iterator
-// The differences are:
-// - it returns errors in the expected format
-// - doesn't mark BADF as unreachable
-// - It borrows the entry name (`RawSlice<u8>`) into the iterator buffer
-// - Windows can be configured to return []const u16
+// Directory iterator:
+// - returns errors in the expected format
+// - doesn't treat BADF as unreachable
+// - borrows the entry name (`RawSlice<u8>`) into the iterator buffer
+// - Windows can be configured to return UTF-16 entry names
 
 #![warn(unused_must_use)]
 
@@ -12,8 +11,7 @@ use core::mem::offset_of;
 use bun_core::{RawSlice, WStr};
 use bun_sys::{self as sys, Fd, Tag};
 
-// `Entry.Kind` in Zig is `jsc.Node.Dirent.Kind` == `std.fs.Dir.Entry.Kind`.
-// In the Rust port that maps to `bun_core::FileKind`, re-exported here as
+// `Entry.Kind` is `bun_core::FileKind`, re-exported here as
 // `bun_sys::EntryKind` (and as `crate::node::types::DirentKind`).
 use bun_sys::EntryKind;
 
@@ -44,8 +42,7 @@ pub struct IteratorResult {
 
 impl IteratorResult {
     /// The entry name as a NUL-terminated `&ZStr` — the POSIX `d_name` is always
-    /// NUL-terminated in the `getdents` buffer (Zig parity: `PathString`'s
-    /// `slice_assume_z`).
+    /// NUL-terminated in the `getdents` buffer.
     #[inline]
     pub fn name_assume_z(&self) -> &bun_core::ZStr {
         let s = self.name.slice();
@@ -58,7 +55,7 @@ pub type Result = sys::Result<Option<IteratorResult>>;
 
 /// The `u16` twin of `IteratorResult.name` (`RawSlice<u16>` + `slice_assume_z()`),
 /// kept separate so callers avoid an `if (Environment.isWindows) ...` split.
-// TODO(port): lifetime — borrows iterator's internal `name_data` buffer; invalidated on next()
+// Lifetime: borrows the iterator's internal `name_data` buffer; invalidated on next().
 pub struct IteratorResultWName {
     // `RawSlice` invariant: the iterator's `name_data` outlives this result
     // (streaming-iterator contract — invalidated on next `next()` call).
@@ -107,7 +104,6 @@ mod platform {
     use super::*;
     use core::ptr::addr_of;
 
-    /// Zig: `buf: [8192]u8 align(@alignOf(posix.system.dirent))`.
     /// Darwin's `struct dirent` (64-bit ino) leads with `d_ino: u64` (align 8);
     /// a bare `[u8; N]` field has alignment 1, so wrap it to force 8-byte
     /// alignment for the *first* record. Subsequent records are only 4-byte
@@ -134,7 +130,7 @@ mod platform {
 
         fn next_darwin(&mut self) -> Result {
             unsafe extern "C" {
-                // Private libsystem symbol; same one Zig's `posix.system.__getdirentries64` hits.
+                // Private libsystem symbol (`__getdirentries64`).
                 // SAFETY precondition: `buf` must be writable for `nbytes` and
                 // `basep` must point to a valid i64 — raw-pointer contract,
                 // cannot be `safe fn`.
@@ -200,8 +196,7 @@ mod platform {
                 // record is shorter than `size_of::<libc::dirent>()` (1048),
                 // so forming a `&libc::dirent` would assert validity past the
                 // record / buffer end. Never materialize a reference — read
-                // each field through the raw pointer (Zig spec:
-                // `*align(1) posix.system.dirent`).
+                // each field through the raw pointer.
                 // SAFETY: self.index < self.end_index <= buf.len(); kernel
                 // wrote a valid (possibly 4-aligned) dirent record here.
                 let entry = unsafe { self.buf.0.as_ptr().add(self.index).cast::<libc::dirent>() };
@@ -256,16 +251,14 @@ mod platform {
     use super::*;
     use core::ptr::addr_of;
 
-    // Zig spec calls `posix.system.getdents()`. The Rust `libc` crate binds
-    // neither `getdents` nor `getdirentries` on FreeBSD, so declare the former
-    // to keep the struct shape and syscall surface mirroring the spec.
+    // The `libc` crate binds neither `getdents` nor `getdirentries` on
+    // FreeBSD, so declare the former here.
     unsafe extern "C" {
         // SAFETY precondition: `buf` must be writable for `nbytes` bytes and
         // dirent-aligned — raw-pointer contract, cannot be `safe fn`.
         fn getdents(fd: core::ffi::c_int, buf: *mut core::ffi::c_char, nbytes: usize) -> isize;
     }
 
-    /// Zig: `buf: [8192]u8 align(@alignOf(posix.system.dirent))`.
     /// FreeBSD's `struct dirent` leads with `ino_t` (u64, align 8); a bare
     /// `[u8; N]` field has alignment 1, so wrap it to force 8-byte alignment.
     #[repr(C, align(8))]
@@ -306,7 +299,7 @@ mod platform {
                     self.end_index = usize::try_from(rc).expect("int cast");
                 }
                 // Records are variable-length; subsequent entries may not be
-                // 8-byte aligned (Zig: `*align(1) posix.system.dirent`). Never
+                // 8-byte aligned. Never
                 // form a `&dirent` — read each field through the raw pointer.
                 // SAFETY: index < end_index ≤ 8192; kernel wrote a valid record.
                 let entry = unsafe { self.buf.0.as_ptr().add(self.index).cast::<libc::dirent>() };
@@ -355,7 +348,6 @@ mod platform {
 mod platform {
     use super::*;
 
-    /// Zig: `buf: [8192]u8 align(@alignOf(linux.dirent64))`.
     /// `dirent64` leads with `d_ino: u64` (align 8); a bare `[u8; N]` field has
     /// alignment 1, so wrap it to force 8-byte alignment of the buffer base.
     /// The kernel pads `d_reclen` to a multiple of 8, so every record stays
@@ -379,8 +371,7 @@ mod platform {
             'start_over: loop {
                 if self.index >= self.end_index {
                     // glibc doesn't expose getdents64; go straight to the
-                    // syscall (matches Zig's `linux.getdents64` raw-syscall
-                    // path).
+                    // raw syscall.
                     // SAFETY: buf is valid for 8192 bytes; fd is a plain c_int.
                     let rc = unsafe {
                         libc::syscall(
@@ -474,8 +465,8 @@ mod platform {
     // this may not always be the case (e.g. due to faulty VM/Sandboxing tools)
     // (Rust raw-pointer reads below use unaligned-safe casts.)
 
-    /// Helper to select `name_data` element type and result type from the const-bool generic.
-    /// Zig: `name_data: if (use_windows_ospath) [257]u16 else [513]u8`.
+    /// Helper to select `name_data` element type (`[u16; 257]` or `[u8; 513]`)
+    /// and result type from the const-bool generic.
     pub trait WindowsOsPath {
         type NameData: Sized;
         type Entry;
@@ -501,7 +492,6 @@ mod platform {
         const IS_U16: bool = false;
         #[inline]
         fn max_name_u16() -> usize {
-            // Zig: (self.name_data.len - 1) / 2
             (513 - 1) / 2
         }
         fn make_entry(
@@ -523,7 +513,6 @@ mod platform {
         const IS_U16: bool = true;
         #[inline]
         fn max_name_u16() -> usize {
-            // Zig: self.name_data.len - 1
             257 - 1
         }
         fn make_entry(
@@ -574,7 +563,8 @@ mod platform {
         /// Optional kernel-side wildcard filter passed to NtQueryDirectoryFile.
         /// Evaluated by FsRtlIsNameInExpression (case-insensitive, supports `*` and `?`).
         /// Only honored on the first call (RestartScan=TRUE); sticky for the handle lifetime.
-        // TODO(port): lifetime — caller-owned UTF-16 slice; stored as raw ptr+len.
+        // Lifetime: caller-owned UTF-16 slice, stored as raw ptr+len; the caller
+        // must keep it alive for the iterator's lifetime.
         pub name_filter: Option<(*const u16, usize)>,
     }
 
@@ -607,8 +597,8 @@ mod platform {
                     };
                     let filter_ptr: *mut UNICODE_STRING = match self.name_filter {
                         Some((ptr, len)) => {
-                            // Zig spec uses @intCast which panics on overflow in safe builds;
-                            // mirror that with try_from rather than `as u16` silent truncation.
+                            // try_from panics on overflow rather than `as u16`
+                            // silent truncation.
                             let len_bytes = u16::try_from(len * 2).expect("name_filter too long");
                             filter_us.Length = len_bytes;
                             filter_us.MaximumLength = len_bytes;
@@ -783,8 +773,7 @@ mod platform {
         pub dir: Fd,
         // NOTE: even if this buffer were aligned to align_of::<dirent_t>(), entries after
         // the first land at `size_of::<dirent_t>() + d_namlen` offsets (arbitrary), so the
-        // header is read via `read_unaligned` below regardless. The Zig original expresses
-        // the same thing with a `*align(1) dirent_t` cast.
+        // header is read via `read_unaligned` below regardless.
         pub buf: [u8; 8192],
         pub cookie: u64,
         pub index: usize,
@@ -834,7 +823,7 @@ mod platform {
                 // dirent header at this offset. The header is NOT naturally aligned (entries are
                 // packed as `[dirent_t][name bytes][dirent_t]...` with no padding between the
                 // variable-length name and the next header), so we must `read_unaligned` rather
-                // than form a `&dirent_t` — matching Zig's `*align(1) w.dirent_t` cast.
+                // than form a `&dirent_t`.
                 let entry: w::dirent_t = unsafe {
                     core::ptr::read_unaligned(
                         self.buf.as_ptr().add(self.index).cast::<w::dirent_t>(),
@@ -879,10 +868,9 @@ pub use platform::NewIterator;
 // Wrapped iterator — selects the underlying `NewIterator<B>` and provides a
 // uniform `init`/`next`/`set_name_filter` surface.
 //
-// Zig parametrized this on a `PathType` enum (`.u8` / `.u16`). Rust's stable
-// const generics don't admit user enums, so we map to a `bool` (`false` ==
-// `.u8`, `true` == `.u16`) and split the `next()` impl per-value to avoid
-// inherent associated types.
+// Parametrized on a `bool` (`false` == u8 paths, `true` == u16 paths) since
+// stable const generics don't admit user enums; the `next()` impl is split
+// per-value to avoid inherent associated types.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -933,7 +921,7 @@ where
                     seek: 0,
                     index: 0,
                     end_index: 0,
-                    // Zig `= undefined`; zero-init avoids Rust's invalid_value lint on [u8; N]
+                    // zero-init avoids the invalid_value lint on [u8; N]
                     buf: platform::DirentBuf([0u8; 8192]),
                     received_eof: false,
                 },
@@ -946,7 +934,7 @@ where
                     dir,
                     index: 0,
                     end_index: 0,
-                    // Zig `= undefined`; zero-init avoids Rust's invalid_value lint on [u8; N]
+                    // zero-init avoids the invalid_value lint on [u8; N]
                     buf: platform::DirentBuf([0u8; 8192]),
                 },
             };
@@ -958,7 +946,7 @@ where
                     dir,
                     index: 0,
                     end_index: 0,
-                    // Zig `= undefined`; zero-init avoids Rust's invalid_value lint on [u8; N]
+                    // zero-init avoids the invalid_value lint on [u8; N]
                     buf: platform::DirentBuf([0u8; 8192]),
                 },
             };
@@ -971,7 +959,7 @@ where
                     index: 0,
                     end_index: 0,
                     first: true,
-                    // Zig `= undefined`; zero-init avoids Rust's invalid_value lint on integer arrays
+                    // zero-init avoids the invalid_value lint on integer arrays
                     buf: [0u8; 8192],
                     // SAFETY: NameData is [u8; 513] or [u16; 257]; zero is a valid bit pattern.
                     name_data: unsafe { bun_core::ffi::zeroed_unchecked() },
@@ -987,7 +975,7 @@ where
                     cookie: 0, // wasi DIRCOOKIE_START
                     index: 0,
                     end_index: 0,
-                    // Zig `= undefined`; zero-init avoids Rust's invalid_value lint on [u8; N]
+                    // zero-init avoids the invalid_value lint on [u8; N]
                     buf: [0u8; 8192],
                 },
             };
@@ -1015,5 +1003,3 @@ where
 {
     NewWrappedIterator::<IS_U16>::init(self_)
 }
-
-// ported from: src/runtime/node/dir_iterator.zig
diff --git a/src/runtime/node/fs_events.rs b/src/runtime/node/fs_events.rs
index 47d9e4f88bd..3632bd62ef1 100644
--- a/src/runtime/node/fs_events.rs
+++ b/src/runtime/node/fs_events.rs
@@ -6,10 +6,8 @@ use bun_collections::VecExt;
 use bun_core::zstr;
 use bun_threading::{Mutex, Semaphore, UnboundedQueue};
 
-// Zig: `const Event = bun.jsc.Node.fs.Watcher.Event` /
-//      `const EventType = @import("./path_watcher.zig").PathWatcher.EventType`.
-// Both siblings are wired into `crate::node`, and intra-crate module cycles are
-// fine in Rust, so import the real shapes instead of mirroring them.
+// Both siblings are wired into `crate::node`, and intra-crate module cycles
+// are fine in Rust, so import the real shapes instead of mirroring them.
 use super::node_fs_watcher::Event;
 use super::path_watcher::EventType;
 
@@ -168,13 +166,8 @@ impl CoreFoundation {
         *FSEVENTS_CF.get_or_init(init_core_foundation)
     }
 
-    // We Actually never deinit it
-    // pub fn deinit(this: *CoreFoundation) void {
-    //     if(this.handle) | ptr| {
-    //         this.handle = null;
-    //         _  = std.c.dlclose(this.handle);
-    //     }
-    // }
+    // We never deinit this: the dlopen handle is intentionally leaked for the
+    // process lifetime.
 }
 
 // Clone/Copy: bitwise OK — `handle` is a leaked dlopen handle held for the
@@ -215,13 +208,8 @@ impl CoreServices {
         *FSEVENTS_CS.get_or_init(init_core_services)
     }
 
-    // We Actually never deinit it
-    // pub fn deinit(this: *CoreServices) void {
-    //     if(this.handle) | ptr| {
-    //         this.handle = null;
-    //         _  = std.c.dlclose(this.handle);
-    //     }
-    // }
+    // We never deinit this: the dlopen handle is intentionally leaked for the
+    // process lifetime.
 }
 
 // Write-once fn-ptr tables; `OnceLock` provides the one-init + acquire/release
@@ -230,7 +218,6 @@ static FSEVENTS_CF: std::sync::OnceLock<CoreFoundation> = std::sync::OnceLock::n
 static FSEVENTS_CS: std::sync::OnceLock<CoreServices> = std::sync::OnceLock::new();
 
 fn init_core_foundation() -> CoreFoundation {
-    // Zig used std.c.dlopen with .{ .LAZY = true, .LOCAL = true }
     let fsevents_cf_handle = bun_sys::dlopen(
         zstr!("/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation"),
         bun_sys::RTLD::LAZY | bun_sys::RTLD::LOCAL,
@@ -329,9 +316,6 @@ impl Task {
         callback(ctx);
     }
 
-    /// Zig: `Task.New(comptime Type, comptime Callback).init(ctx)`
-    /// Rust: `Task::new(ctx, Callback)`
-    // PERF(port): was @call(.always_inline) on the wrapper.
     pub fn new<T>(ctx: &mut T, callback: fn(&mut T)) -> Task {
         Task {
             // SAFETY: fn(&mut T) and fn(*mut ()) have identical single-pointer ABI;
@@ -426,7 +410,6 @@ impl FSEventsLoop {
     }
 
     pub fn init() -> Result<*mut FSEventsLoop, bun_core::Error> {
-        // TODO(port): narrow error set
         let this = bun_core::heap::into_raw(Box::new(FSEventsLoop {
             signal_source: ptr::null_mut(),
             mutex: Mutex::new(),
@@ -467,7 +450,7 @@ impl FSEventsLoop {
         // SAFETY: this is a valid freshly-boxed pointer
         unsafe {
             (*this).signal_source = signal_source;
-            // PORT NOTE: Zig std.Thread.spawn. The raw `this` pointer is moved
+            // The raw `this` pointer is moved
             // into the closure; the FSEventsLoop is heap-allocated and outlives
             // the thread (joined in Drop).
             let this_addr = this as usize;
@@ -607,7 +590,7 @@ impl FSEventsLoop {
         self.has_scheduled_watchers = false;
         let watcher_count = self.watcher_count;
 
-        // PORT NOTE: reshaped for borrowck — defer slicing self.watchers until after
+        // Reshaped for borrowck — defer slicing self.watchers until after
         // the early-exit checks so the &mut self for fsevent_stream/paths doesn't conflict.
 
         let cf = CoreFoundation::get();
@@ -768,8 +751,7 @@ impl FSEventsLoop {
                 return;
             }
         }
-        // PORT NOTE: reshaped for borrowck — enqueue after dropping the guard so we
-        // can take &mut self twice. Zig held the lock through enqueueTaskConcurrent;
+        // Enqueue after dropping the guard so we can take &mut self twice;
         // safe to release first since enqueue only pushes to a lock-free queue and
         // signals CF, and `_schedule` re-acquires the mutex on the CF thread.
         let task = Task::new(self, FSEventsLoop::_schedule);
@@ -779,7 +761,7 @@ impl FSEventsLoop {
     fn unregister_watcher(&mut self, watcher: *mut FSEventsWatcher) {
         {
             let _guard = self.mutex.lock_guard();
-            // PORT NOTE: reshaped for borrowck — capture len before mutable iteration
+            // Reshaped for borrowck — capture len before mutable iteration
             let len = self.watchers.len() as usize;
             let watchers = self.watchers.slice_mut();
             for i in 0..len {
@@ -807,7 +789,7 @@ impl FSEventsLoop {
                 return;
             }
         }
-        // PORT NOTE: reshaped for borrowck — see register_watcher
+        // Reshaped for borrowck — see register_watcher
         let task = Task::new(self, FSEventsLoop::_schedule);
         self.enqueue_task_concurrent(task);
     }
@@ -823,7 +805,7 @@ impl FSEventsLoop {
 impl Drop for FSEventsLoop {
     fn drop(&mut self) {
         // signal close and wait
-        // PORT NOTE: reshaped for borrowck — build Task (stores raw ptr) before re-borrowing &mut self
+        // Reshaped for borrowck — build Task (stores raw ptr) before re-borrowing &mut self
         let stop_task = Task::new(self, FSEventsLoop::_stop);
         self.enqueue_task_concurrent(stop_task);
         if let Some(thread) = self.thread.take() {
@@ -851,7 +833,7 @@ impl Drop for FSEventsLoop {
 }
 
 pub struct FSEventsWatcher {
-    /// Borrowed from the owning `PathWatcher` (Zig: `[]const u8`). The
+    /// Borrowed from the owning `PathWatcher`. The
     /// PathWatcher heap-allocates this watcher and only frees it after `Drop`
     /// (→ `unregister_watcher`) has run, so the bytes outlive every read in
     /// `_events_cb` / `_schedule` — `RawSlice` invariant. The backing buffer is
@@ -860,7 +842,7 @@ pub struct FSEventsWatcher {
     pub path: bun_ptr::RawSlice<u8>,
     pub callback: Callback,
     pub flush_callback: UpdateEndCallback,
-    // Zig: `loop: ?*FSEventsLoop`. Stored as a raw pointer because the loop is
+    // Stored as a raw pointer because the loop is
     // shared with the CFRunLoop thread and mutated through `unregister_watcher`
     // on drop; holding a `&'static FSEventsLoop` and casting it to `*mut` would
     // be UB (write through pointer derived from shared ref). `Cell` so
@@ -933,7 +915,6 @@ pub fn watch(
     update_end: UpdateEndCallback,
     ctx: *mut c_void,
 ) -> Result<Box<FSEventsWatcher>, bun_core::Error> {
-    // TODO(port): narrow error set
     let loop_ = FSEVENTS_DEFAULT_LOOP.load(Ordering::Acquire);
     if let Some(loop_) = NonNull::new(loop_) {
         // SAFETY: `loop_` is the heap-allocated global default loop published
@@ -948,7 +929,7 @@ pub fn watch(
         loop_ = FSEventsLoop::init()?;
         FSEVENTS_DEFAULT_LOOP.store(loop_, Ordering::Release);
         // First loop ever created → arrange `close_and_wait` to run from
-        // `Bun__onExit`. Spec `Global.zig:220` runs it BEFORE
+        // `Bun__onExit`, which runs it BEFORE
         // `runExitCallbacks()`, so push to the pre-exit list rather than
         // the generic atexit list (storage lives in bun_core; forward dep).
         bun_core::Global::add_pre_exit_callback(close_and_wait_on_exit);
@@ -983,5 +964,3 @@ pub(crate) fn close_and_wait() {
         }
     }
 }
-
-// ported from: src/runtime/node/fs_events.zig
diff --git a/src/runtime/node/net/BlockList.rs b/src/runtime/node/net/BlockList.rs
index 321e7a7e20f..34785be26bf 100644
--- a/src/runtime/node/net/BlockList.rs
+++ b/src/runtime/node/net/BlockList.rs
@@ -45,7 +45,6 @@ static SERIALIZED_REFS: Guarded<Vec<usize>> = Guarded::new(Vec::new());
 use crate::node::util::validators;
 use crate::socket::socket_address::{SocketAddress, sockaddr};
 
-// TODO(port): move to <area>_sys — AF_* constants come from translated-c-headers
 use crate::socket::socket_address::inet::{self, AF_INET, AF_INET6};
 
 /// `&ZStr` → `&str` for `format_args!`. IP presentation strings and AF family
@@ -61,16 +60,10 @@ fn z(s: &ZStr) -> &str {
 #[bun_jsc::JsClass]
 #[derive(bun_ptr::ThreadSafeRefCounted)]
 pub struct BlockList {
-    // Intrusive thread-safe refcount (Zig: `bun.ptr.ThreadSafeRefCount`).
+    // Intrusive thread-safe refcount.
     // `ref()`/`deref()` (provided by the derive) bump it; hitting zero drops
     // the `Box` via the trait's default destructor.
     ref_count: bun_ptr::ThreadSafeRefCount<BlockList>,
-    // LIFETIMES.tsv: JSC_BORROW → `&JSGlobalObject`. Stored raw because this
-    // struct is a heap-allocated `m_ctx` payload recovered from C++ via
-    // `*mut Self`; a borrowed lifetime param cannot be threaded through that.
-    // TODO(port): lifetime — field is write-only (assigned in constructor,
-    // never read; `deinit` ignores it).
-    _global_this: *const JSGlobalObject,
     // R-2: interior mutability so every host_fn takes `&self`. All access is
     // serialized by `mutex` (held across every read and every `with_mut`), so
     // the `JsCell` single-thread invariant is upheld even though `BlockList`
@@ -90,8 +83,7 @@ pub struct BlockList {
 }
 
 impl BlockList {
-    // Zig: `bun.ptr.ThreadSafeRefCount(@This(), "ref_count", deinit, .{})`
-    // → trait impl + default destructor (drops the `Box`) provided by
+    // Trait impl + default destructor (drops the `Box`) provided by
     // `#[derive(ThreadSafeRefCounted)]`; inherent forwarders below.
     #[inline]
     pub fn ref_(&self) {
@@ -108,10 +100,9 @@ impl BlockList {
 
     // NOTE: no `#[bun_jsc::host_fn]` — the `#[bun_jsc::JsClass]` derive emits
     // the `${T}Class__construct` C-ABI shim that calls `<Self>::constructor`.
-    pub fn constructor(global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<*mut Self> {
+    pub fn constructor(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<*mut Self> {
         let ptr = bun_core::heap::into_raw(Box::new(Self {
             ref_count: bun_ptr::ThreadSafeRefCount::init(),
-            _global_this: std::ptr::from_ref(global),
             da_rules: JsCell::new(Vec::new()),
             mutex: Mutex::default(),
             estimated_size: AtomicU32::new(0),
@@ -421,7 +412,7 @@ impl BlockList {
             ctx,
             impl_: write_bytes,
         };
-        // Error = `!` (Zig: `error{}`), so no `?` needed.
+        // The writer is infallible, so no `?` needed.
         // Only the address is serialized; deserialize re-derives `*mut Self`
         // via int→ptr cast and never forms `&mut Self` (only `ref_()` +
         // `to_js_ptr`, both `&self`/raw-ptr), so `from_ref` provenance is fine.
@@ -538,5 +529,3 @@ fn _compare_ipv6(l: &inet::sockaddr_in6, r: &inet::sockaddr_in6) -> Ordering {
     let r128 = u128::from_ne_bytes(r.addr).swap_bytes();
     l128.cmp(&r128)
 }
-
-// ported from: src/runtime/node/net/BlockList.zig
diff --git a/src/runtime/node/node_assert.rs b/src/runtime/node/node_assert.rs
index 8d030c090e9..d3bdb9b83b6 100644
--- a/src/runtime/node/node_assert.rs
+++ b/src/runtime/node/node_assert.rs
@@ -73,9 +73,9 @@ pub(crate) fn myers_diff(
         let _actual_utf8 = actual.to_utf8_without_ref();
         let _expected_utf8 = expected.to_utf8_without_ref();
 
-        // PORT NOTE: Zig passes `actual.byteSlice()` / `expected.byteSlice()` here (the
-        // originals), not the just-computed utf8 slices. Preserved verbatim for behavioral
-        // parity; likely a pre-existing bug in the Zig source.
+        // Intentionally diffs the original byte slices, not the just-computed utf8
+        // slices — preserved verbatim for behavioral parity with the original
+        // implementation, which did the same (likely a pre-existing bug there).
         return diff_chars::<u8>(global, actual.byte_slice(), expected.byte_slice());
     }
 
@@ -132,9 +132,8 @@ where
 }
 
 /// Field reflection for `Diff<T>` so [`JSObject::create_null_proto`] can
-/// marshal it. Mirrors Zig's `inline for` over `@typeInfo(Diff(T))`:
-/// `kind` is a fieldless enum → `jsNumber(@intFromEnum)`; `value` routes
-/// through `JSValue::from_any` per `T`.
+/// marshal it: `kind` is a fieldless enum marshalled as its discriminant;
+/// `value` routes through `JSValue::from_any` per `T`.
 impl<T: FromAny + Copy> PojoFields for Diff<T> {
     const FIELD_COUNT: usize = 2;
     fn put_fields(
@@ -161,11 +160,9 @@ fn map_diff_error(global: &JSGlobalObject, err: MyersDiff::Error) -> JsError {
 }
 
 // Ensure `DiffKind`'s discriminants match the JS-side `DiffType` enum
-// (Insert=0, Delete=1, Equal=2). Zig's `@intFromEnum` uses declaration order.
+// (Insert=0, Delete=1, Equal=2).
 const _: () = {
     assert!(DiffKind::Insert as i32 == 0);
     assert!(DiffKind::Delete as i32 == 1);
     assert!(DiffKind::Equal as i32 == 2);
 };
-
-// ported from: src/runtime/node/node_assert.zig
diff --git a/src/runtime/node/node_assert_binding.rs b/src/runtime/node/node_assert_binding.rs
index 0d0f7f1bd71..50ed81af2da 100644
--- a/src/runtime/node/node_assert_binding.rs
+++ b/src/runtime/node/node_assert_binding.rs
@@ -14,8 +14,6 @@ use super::node_assert;
 /// ```
 #[bun_jsc::host_fn]
 pub(crate) fn myers_diff(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-    // PERF(port): was stack-fallback (2KB) + ArenaAllocator bulk-free.
-
     let nargs = frame.arguments_count();
     if nargs < 2 {
         return Err(global.throw_not_enough_arguments("printMyersDiff", 2, nargs as usize));
@@ -74,5 +72,3 @@ pub fn generate(global: &JSGlobalObject) -> JSValue {
 
     exports
 }
-
-// ported from: src/runtime/node/node_assert_binding.zig
diff --git a/src/runtime/node/node_cluster_binding.rs b/src/runtime/node/node_cluster_binding.rs
index 90819740186..19e0e18b953 100644
--- a/src/runtime/node/node_cluster_binding.rs
+++ b/src/runtime/node/node_cluster_binding.rs
@@ -10,7 +10,7 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult, StringJsc as _, Stro
 
 use crate::api::bun::subprocess::Subprocess;
 
-// PORT NOTE: struct moved to `bun_jsc::ipc` (cycle-break per docs/PORTING.md) —
+// Struct moved to `bun_jsc::ipc` (cycle-break per docs/PORTING.md) —
 // `SendQueue` stores one inline so it must live at that tier. Re-exported here so
 // existing `bun_runtime` paths (`node_cluster_binding::InternalMsgHolder`) keep working.
 pub use bun_jsc::ipc::InternalMsgHolder;
@@ -26,9 +26,7 @@ unsafe extern "C" {
     pub(crate) safe fn Process__emitErrorEvent(global: &JSGlobalObject, value: JSValue);
 }
 
-// TODO(port): `pub var` mutable global with !Sync fields (Strong). Only ever accessed on the
-// JS thread; wrap in a JS-thread-local cell or assert const-init of fields.
-// PORT NOTE: ArrayHashMap::new() is not const, so the global is lazily seeded on first
+// ArrayHashMap::new() is not const, so the global is lazily seeded on first
 // access via `child_singleton()`.
 // PORTING.md §Global mutable state: JS-thread-only singleton with `!Sync`
 // fields (`Strong`). RacyCell — single-thread access is the contract.
@@ -43,8 +41,8 @@ pub(crate) static CHILD_SINGLETON: bun_core::RacyCell<Option<InternalMsgHolder>>
 /// must not hold the borrow across a re-entrant `child_singleton()` call.
 #[inline]
 fn child_singleton<'a>() -> &'a mut InternalMsgHolder {
-    // SAFETY: only called on the single JS thread; mirrors Zig `pub var`
-    // access. `RacyCell::get` returns `*mut Option<_>`; the `Option` lives in
+    // SAFETY: only called on the single JS thread.
+    // `RacyCell::get` returns `*mut Option<_>`; the `Option` lives in
     // `'static` storage so the returned `&mut` is valid for any caller-chosen
     // `'a`. Aliasing: each of the three callers borrows for a single
     // statement/block with no nested call to this fn.
@@ -258,10 +256,8 @@ pub(crate) fn handle_internal_message_primary(
     if let Some(p) = message.get(global, "ack")? {
         if !p.is_undefined() {
             let ack = p.to_int32();
-            // PORT NOTE: reshaped for borrowck — Zig copied the Strong out of the
-            // entry, then `defer deinit()` + swapRemove. Here we peek the JSValue
-            // first (ending the immutable borrow), then swap_remove (which drops the
-            // Strong == `defer cbstrong.deinit()`).
+            // Peek the JSValue first (ending the immutable borrow), then
+            // swap_remove (which drops the Strong).
             let entry = ipc_data
                 .internal_msg_queue
                 .callbacks
@@ -353,5 +349,3 @@ pub fn should_ignore_one_disconnect_event_listener(global: &JSGlobalObject) -> b
     let vm = global.bun_vm();
     vm.channel_ref_should_ignore_one_disconnect_event_listener
 }
-
-// ported from: src/runtime/node/node_cluster_binding.zig
diff --git a/src/runtime/node/node_crypto_binding.rs b/src/runtime/node/node_crypto_binding.rs
index 7c25ee7e387..2d40f96f257 100644
--- a/src/runtime/node/node_crypto_binding.rs
+++ b/src/runtime/node/node_crypto_binding.rs
@@ -31,7 +31,7 @@ pub(crate) trait JSValueCryptoExt {
 }
 
 impl JSValueCryptoExt for JSValue {
-    /// Port of `JSValue.isSafeInteger` (JSValue.zig:140) — Number.isSafeInteger semantics.
+    /// `Number.isSafeInteger` semantics.
     #[inline]
     fn is_safe_integer(self) -> bool {
         if self.is_int32() {
@@ -51,9 +51,8 @@ impl JSValueCryptoExt for JSValue {
 }
 
 // ───────────────────────────────────────────────────────────────────────────
-// ExternCryptoJob — Zig `fn ExternCryptoJob(comptime name: []const u8) type`.
-// This does token-pasting to form C symbol names (`Bun__<name>Ctx__runTask`
-// etc.), so a `macro_rules!` is the correct port shape per PORTING.md.
+// ExternCryptoJob — token-pastes C symbol names (`Bun__<name>Ctx__runTask`
+// etc.), so a `macro_rules!` is the right shape.
 // ───────────────────────────────────────────────────────────────────────────
 macro_rules! extern_crypto_job {
     ($Name:ident, $name_str:literal) => {
@@ -108,7 +107,7 @@ macro_rules! extern_crypto_job {
 
             pub(crate) type Job = AnyTaskJob<ExternCtx>;
 
-            // Zig `comptime { @export(...) }` — exported C symbols.
+            // Exported C symbols.
             #[unsafe(export_name = concat!("Bun__", $name_str, "__create"))]
             pub(crate) extern "C" fn __create(
                 global: &JSGlobalObject,
@@ -165,23 +164,20 @@ extern_crypto_job!(DhJob, "DhJob");
 extern_crypto_job!(SignJob, "SignJob");
 
 // ───────────────────────────────────────────────────────────────────────────
-// CryptoJob<Ctx> — Zig `fn CryptoJob(comptime Ctx: type) type`.
+// CryptoJob<Ctx>
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Trait expressing the duck-typed interface Zig's `CryptoJob` expects of `Ctx`.
+/// Trait expressing the interface `CryptoJob` expects of `Ctx`.
 pub trait CryptoJobCtx: Sized {
     fn init(&mut self, global: &JSGlobalObject) -> JsResult<()>;
-    /// Zig calls `ctx.runTask(ctx.result)`; in Rust the impl reads its own
-    /// `result` field directly.
-    // PORT NOTE: reshaped for borrowck — Zig passed `self.result` as a separate arg.
+    /// The impl reads its own `result` field directly.
     fn run_task(&mut self);
     fn run_from_js(&mut self, global: &JSGlobalObject, callback: JSValue);
     fn deinit(&mut self);
 }
 
 /// Adapter binding a [`CryptoJobCtx`] + JS callback into an [`AnyTaskJobCtx`].
-/// `Drop` runs `inner.deinit()` then releases the callback handle, mirroring
-/// the Zig `CryptoJob.deinit` order.
+/// `Drop` runs `inner.deinit()` then releases the callback handle.
 pub struct CallbackCtx<C: CryptoJobCtx> {
     callback: StrongOptional,
     inner: C,
@@ -212,8 +208,8 @@ impl<C: CryptoJobCtx> Drop for CallbackCtx<C> {
     }
 }
 
-/// Zig `CryptoJob.initAndSchedule` — kept as a free fn since `CryptoJob<C>` is
-/// now a type alias for the foreign `AnyTaskJob<_>`.
+/// Kept as a free fn since `CryptoJob<C>` is
+/// a type alias for the foreign `AnyTaskJob<_>`.
 pub(crate) fn crypto_job_init_and_schedule<C: CryptoJobCtx>(
     global: &JSGlobalObject,
     callback: JSValue,
@@ -392,9 +388,8 @@ pub mod random {
                     .throw());
             }
 
-            // Zig: `std.crypto.random.intRangeLessThan(i64, min, max)` — port of
-            // `std.Random.uintLessThan(u64, max - min)` (Lemire's nearly-divisionless
-            // rejection sampling) backed by `bun_core::csprng` (BoringSSL RAND_bytes).
+            // Uniform random in [min, max) via Lemire's nearly-divisionless
+            // rejection sampling, backed by `bun_core::csprng` (BoringSSL RAND_bytes).
             let res: i64 = {
                 let range = (max - min) as u64;
                 debug_assert!(range > 0);
@@ -603,7 +598,7 @@ pub mod random {
                 buf.byte_len,
             )?;
 
-            // Zig keeps `size: usize` here (`buf.byte_len - offset`, both usize). The
+            // `size` is usize (`buf.byte_len - offset`, both usize). The
             // `assert_size` branch is bounded by `MAX_POSSIBLE_LENGTH` (≤ i32::MAX) so widening
             // its `u32` result is lossless; the default branch must NOT truncate to `u32` —
             // a >4 GiB ArrayBuffer remainder would silently fill only `(n % 2^32)` bytes.
@@ -658,7 +653,7 @@ pub mod random {
                 offset = assert_offset(global, offset_value, element_size, buf.byte_len)?;
             }
 
-            // Zig keeps `size: usize` here (`buf.byte_len - offset`, both usize). The
+            // `size` is usize (`buf.byte_len - offset`, both usize). The
             // `assert_size` branch is bounded by `MAX_POSSIBLE_LENGTH` (≤ i32::MAX) so widening
             // its `u32` result is lossless; the default branch must NOT truncate to `u32` —
             // a >4 GiB ArrayBuffer remainder would silently fill only `(n % 2^32)` bytes.
@@ -710,7 +705,7 @@ pub(crate) struct Scrypt {
     // the sync path's drop call `JSValue::unprotect()` on a buffer it never
     // protected, stealing a refcount from any independent protector. The async
     // path releases its protect via `Unprotect for Scrypt` in
-    // `CryptoJobCtx::deinit` instead (Zig: `deinit` vs `deinitSync`).
+    // `CryptoJobCtx::deinit` instead.
     password: StringOrBuffer,
     salt: StringOrBuffer,
     n: u32,
@@ -721,7 +716,8 @@ pub(crate) struct Scrypt {
 
     // used in async mode
     buf: StrongOptional, // Strong.Optional, default .empty
-    // TODO(port): lifetime — `result` borrows the ArrayBuffer backing held alive by `buf`.
+    // Invariant: `result` borrows the ArrayBuffer backing kept alive by `buf`;
+    // `buf` must stay set for as long as `result` is dereferenced.
     result: *mut [u8],
     err: Option<u32>,
 }
@@ -737,10 +733,8 @@ mod _impl {
     use crate::crypto::pbkdf2::{self, PBKDF2};
 
     impl Scrypt {
-        /// Zig: `fromJS(..., comptime is_async: bool) JSError!if (is_async) struct{@This(),JSValue} else @This()`.
-        /// Rust cannot vary the return type on a const-generic bool, so this always returns
-        /// `(Self, JSValue)`; the sync caller ignores the second element.
-        // PORT NOTE: reshaped — return type unified across IS_ASYNC.
+        /// The return type cannot vary on the const-generic bool, so this always
+        /// returns `(Self, JSValue)`; the sync caller ignores the second element.
         pub(crate) fn from_js<const IS_ASYNC: bool>(
             global: &JSGlobalObject,
             call_frame: &CallFrame,
@@ -772,8 +766,7 @@ mod _impl {
                 ));
             };
 
-            // Zig: `errdefer if (is_async) password.deinitAndUnprotect() else password.deinit()`.
-            // The `deinit()` half is `Drop for StringOrBuffer`; only the async branch took a
+            // On error: `Drop for StringOrBuffer` releases the data; only the async branch took a
             // `protect()` (inside `from_js_maybe_async`), so only that branch may unprotect —
             // an unconditional unprotect would steal a refcount on the sync path.
             let password = scopeguard::guard(password, |mut p| {
@@ -925,8 +918,8 @@ mod _impl {
                 result: std::ptr::from_mut::<[u8]>(&mut []),
                 err: None,
             };
-            // Re-arm the errdefer now that ownership moved into `ctx` — Zig's
-            // `errdefer` covers the `validateFunction`/`checkScryptParams` calls below.
+            // Re-arm the error guard now that ownership moved into `ctx` — it
+            // covers the `validateFunction`/`checkScryptParams` calls below.
             let ctx = scopeguard::guard(ctx, |mut c| {
                 if IS_ASYNC {
                     bun_jsc::Unprotect::unprotect(&mut c);
@@ -1091,8 +1084,7 @@ mod _impl {
         }
 
         fn deinit(&mut self) {
-            // Zig `Scrypt.deinit` (async path): `salt/password.deinitAndUnprotect()`.
-            // `Drop for StringOrBuffer` handles the deinit half when `CryptoJob` is freed.
+            // `Drop for StringOrBuffer` releases salt/password when `CryptoJob` is freed.
             bun_jsc::Unprotect::unprotect(self);
             self.buf.deinit();
         }
@@ -1112,11 +1104,10 @@ mod _impl {
     #[bun_jsc::host_fn]
     fn pbkdf2_sync(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let data = PBKDF2::from_js(global_this, call_frame, false)?;
-        // PORT NOTE: Zig had `defer data.deinit()` plus an extra `data.deinit()` on
-        // the OOM branch (double-deinit). `PBKDF2`'s `StringOrBuffer` fields release
-        // on `Drop`, so the local just goes out of scope; the redundant call is gone.
+        // `PBKDF2`'s `StringOrBuffer` fields release on `Drop`, so the local
+        // just goes out of scope.
         let mut data = data;
-        // Zig: `JSValue.createBufferFromLength` → `JSBuffer__bufferFromLength`, which constructs
+        // `create_buffer_from_length` → `JSBuffer__bufferFromLength`, which constructs
         // with `JSBufferSubclassStructure` (a Node.js `Buffer`, not a plain Uint8Array/ArrayBuffer).
         // `pbkdf2Sync()` MUST return a Buffer — `Buffer.isBuffer(result)` and Buffer-only methods
         // (`.toString('hex')`, `.readUInt32BE`, …) depend on it.
@@ -1223,7 +1214,7 @@ mod _impl {
         let mut hashes: CaseInsensitiveAsciiStringArrayHashMap<()> =
             CaseInsensitiveAsciiStringArrayHashMap::new();
 
-        // TODO(dylan-conway): cache the names
+        // Perf idea (dylan-conway): cache the names
         // SAFETY: `for_each_hash` matches the expected callback signature; `&mut hashes` is valid
         // for the duration of the call.
         unsafe {
@@ -1431,5 +1422,3 @@ mod _impl {
 } // mod _impl
 
 pub use _impl::{create_node_crypto_binding_zig, timing_safe_equal};
-
-// ported from: src/runtime/node/node_crypto_binding.zig
diff --git a/src/runtime/node/node_error_binding.rs b/src/runtime/node/node_error_binding.rs
index 315ce73822c..a42d5e8dc02 100644
--- a/src/runtime/node/node_error_binding.rs
+++ b/src/runtime/node/node_error_binding.rs
@@ -3,12 +3,9 @@ use bun_jsc::{CallFrame, JSFunction, JSGlobalObject, JSValue, JsResult, ZigStrin
 
 use super::nodejs_error_code::Code as ErrorCode;
 
-// PORT NOTE: reshaped — Zig's `createSimpleError` is a comptime fn that mints a
-// monomorphized `cbb: fn(*JSGlobalObject) JSError!JSValue` and returns it as a
-// `jsc.JS2NativeFunctionType` const. Rust cannot mint an `fn` item from a const
-// generic fn pointer, so each call site becomes a `pub fn` directly (same shape
-// the `generated_js2native.rs` thunk layer expects). Names stay SCREAMING to
-// match the .zig spec exactly.
+// `create_simple_error!` mints a `pub fn` per error (the shape the
+// `generated_js2native.rs` thunk layer expects). Names stay SCREAMING to
+// match the error-code names.
 //
 // `createFn` was `createErrorInstanceWithCode` / `createTypeErrorInstanceWithCode`
 // — both removed from `JSGlobalObject` upstream; their historical bodies were
@@ -51,5 +48,3 @@ create_simple_error!(
     ErrorCode::ERR_CHILD_CLOSED_BEFORE_REPLY,
     "Child closed before reply received"
 );
-
-// ported from: src/runtime/node/node_error_binding.zig
diff --git a/src/runtime/node/node_fs.rs b/src/runtime/node/node_fs.rs
index d2979cf8098..09caf024833 100644
--- a/src/runtime/node/node_fs.rs
+++ b/src/runtime/node/node_fs.rs
@@ -26,10 +26,8 @@ use bun_threading::UnboundedQueue;
 use bun_threading::work_pool::{IntrusiveWorkTask as _, Task as WorkPoolTask, WorkPool};
 
 // ──────────────────────────────────────────────────────────────────────────
-// `Maybe(T)` shim — Zig's `bun.jsc.Maybe(T)` provides associated helpers
-// (`.success`, `.errnoSys*`, `.getErrno`) on top of the bare `Result<T, Error>`
-// alias that `bun_sys::Maybe<T>` is. `crate::node::Maybe` is now the same
-// `Result` alias, so this is just the file-local extension trait
+// `Maybe(T)` shim — `crate::node::Maybe` is the same `Result<T, Error>` alias
+// as `bun_sys::Maybe<T>`, so this is just the file-local extension trait
 // surface that lets `Maybe::<T>::errno_sys*` / `.get_errno()` resolve.
 // ──────────────────────────────────────────────────────────────────────────
 pub trait MaybeSysResultExt<R>: Sized {
@@ -125,7 +123,7 @@ impl<R> MaybeSysResultExt<R> for Maybe<R> {
     }
 }
 
-/// `bun.jsc.Maybe(void).success` — Zig's unit-success constructor. Only the
+/// Unit-success constructor. Only the
 /// `()` instantiation needs the constant, so bound it separately.
 pub trait MaybeSuccess: Sized {
     const SUCCESS: Self;
@@ -145,8 +143,8 @@ fn to_sys_time_like(t: super::time_like::TimeLike) -> sys::TimeLike {
         nsec: t.tv_nsec as i64,
     }
 }
-// Local namespace shim: dependents in this file spell `ConcurrentTask::create*`
-// (the Zig spelling). The Rust crate exports the *struct* as `ConcurrentTask`
+// Local namespace shim: dependents in this file spell `ConcurrentTask::create*`.
+// The Rust crate exports the *struct* as `ConcurrentTask`
 // inside a same-named module, so re-export the free constructors here under the
 // module name the call sites expect.
 mod ConcurrentTask {
@@ -171,25 +169,22 @@ mod ConcurrentTask {
     }
 }
 
-/// `webcore.Blob.SizeType` — Zig is `u52` (src/runtime/webcore/Blob.zig:60).
+/// `webcore.Blob.SizeType` — logically a 52-bit unsigned integer.
 /// Rust has no native `u52`, so the *storage* width is `u64`, but **never** use
 /// `BlobSizeType::MAX` to mean the spec maximum — that yields `u64::MAX`, which
-/// wraps to `-1` under `as i64` and silently breaks every bounds check that the
-/// Zig spec wrote as `std.math.maxInt(jsc.WebCore.Blob.SizeType)`. Use
+/// wraps to `-1` under `as i64` and silently breaks bounds checks. Use
 /// [`BLOB_SIZE_MAX`] instead.
 type BlobSizeType = u64;
-/// `std.math.maxInt(jsc.WebCore.Blob.SizeType)` == `maxInt(u52)` == 2^52 - 1.
+/// `maxInt(u52)` == 2^52 - 1.
 const BLOB_SIZE_MAX: u64 = (1u64 << 52) - 1;
 
-/// `webcore.RefPtr<AbortSignal>` — JSC's intrusive ref-counted pointer. Zig
-/// stored this as `?*AbortSignal` and called `.ref()`/`.unref()` manually.
-/// Now backed by `bun_ptr::ExternalShared<AbortSignal>` (alias re-exported
+/// `webcore.RefPtr<AbortSignal>` — JSC's intrusive ref-counted pointer.
+/// Backed by `bun_ptr::ExternalShared<AbortSignal>` (alias re-exported
 /// from `bun_jsc`): `Clone` → `ref()`, `Drop` → `unref()`, `Deref` → `&AbortSignal`.
 use bun_jsc::AbortSignalRef;
 
-// PORT NOTE: Zig referenced these via `bun.api.node.*`. These are wired to
-// the real sibling modules under `super::` (rather than a `bun_jsc::node`
-// re-export shim) so this file compiles standalone.
+// Wired to the real sibling modules under `super::` (rather than a
+// `bun_jsc::node` re-export shim) so this file compiles standalone.
 use super::stat::Stats;
 use super::time_like::TimeLike;
 use super::types::{
@@ -197,12 +192,10 @@ use super::types::{
     NameTooLong, PathLike, PathLikeExt as _, PathOrFdExt as _, StringOrBuffer, VectorArrayBuffer,
 };
 // Re-exported publicly: `crate::node::fs::PathOrFileDescriptor` is the
-// canonical path used by `cli/build_command.rs` et al. (mirrors Zig's
-// `bun.api.node.fs.PathOrFileDescriptor`).
+// canonical path used by `cli/build_command.rs` et al.
 pub use super::types::PathOrFileDescriptor;
 
-/// Local alias for the many `node::foo` call sites below — keeps the diff
-/// against `node_fs.zig` readable while routing to `super::*`.
+/// Local alias for the many `node::foo` call sites below, routing to `super::*`.
 mod node {
     pub(super) use super::super::statfs::StatFS;
     pub(super) use super::super::time_like::from_js as time_like_from_js;
@@ -212,7 +205,7 @@ mod node {
     /// `node::mode_from_js` — forwards to the real impl in
     /// `super::types::mode_from_js` (now un-gated). Kept as a thin alias so
     /// the dozens of call sites in `args::*::from_js` keep spelling
-    /// `node::mode_from_js` like the .zig source.
+    /// `node::mode_from_js`.
     #[inline]
     pub(super) fn mode_from_js(
         ctx: &bun_jsc::JSGlobalObject,
@@ -235,8 +228,7 @@ use bun_sys_jsc::ErrorJsc as _;
 
 /// `WorkPoolTask` (aka `bun_threading::thread_pool::Task`) does not derive
 /// `Default` (its `callback` field has no sensible default). Build one with
-/// the intrusive `node` zeroed and the supplied callback. Mirrors Zig's
-/// `.{ .callback = ... }` struct init where unset fields default.
+/// the intrusive `node` zeroed and the supplied callback.
 #[inline]
 fn work_pool_task(callback: unsafe fn(*mut WorkPoolTask)) -> WorkPoolTask {
     WorkPoolTask {
@@ -246,9 +238,7 @@ fn work_pool_task(callback: unsafe fn(*mut WorkPoolTask)) -> WorkPoolTask {
 }
 
 pub use super::node_fs_constant as constants;
-// `Watcher` / `StatWatcher` mirror Zig's `pub const Watcher = @import(
-// "./node_fs_watcher.zig");` / `pub const StatWatcher = @import(
-// "./node_fs_stat_watcher.zig");`. The sibling modules are declared in
+// The `Watcher` / `StatWatcher` sibling modules are declared in
 // `node.rs`; re-export them under the names the `args::Watch` / `watch()`
 // bodies below expect.
 pub use super::node_fs_stat_watcher as StatWatcher;
@@ -256,12 +246,10 @@ pub use super::node_fs_watcher as Watcher;
 
 /// `Binding` is the JSC-class instance that owns the per-thread `NodeFS`
 /// (`super::node_fs_binding::Binding`). Re-exported so the async `create()`
-/// entry points keep their `&mut Binding` signature source-compatible with
-/// `node_fs.zig`.
+/// entry points keep their `&mut Binding` signature.
 pub use super::node_fs_binding::Binding;
 
-/// `jsc.JSPromise.Strong` — re-exported under its Rust crate name. The Zig
-/// source spells this `JSPromise.Strong` (a nested decl), which Rust models as
+/// `jsc.JSPromise.Strong` — re-exported under its Rust crate name:
 /// `bun_jsc::js_promise::Strong` / the `JSPromiseStrong` alias.
 use bun_jsc::JSPromiseStrong;
 
@@ -276,14 +264,13 @@ use bun_resolver::fs::FileSystem;
 #[cfg(windows)]
 use bun_sys::windows::{self, libuv as uv};
 
-// Syscall = bun.sys.sys_uv on Windows, bun.sys otherwise
+// Syscall = `bun_sys::sys_uv` on Windows, `bun_sys` otherwise
 #[cfg(not(windows))]
 use bun_sys as Syscall;
 #[cfg(windows)]
 use bun_sys::sys_uv as Syscall;
 
-/// In-place RAII wrapper for a libuv `fs_t` request (Zig: `var req: uv.fs_t =
-/// uv.fs_t.uninitialized; defer req.deinit();`).
+/// In-place RAII wrapper for a libuv `fs_t` request.
 ///
 /// `scopeguard::guard(fs_t, |mut r| r.deinit())` is *wrong* here: its `Drop`
 /// `ManuallyDrop::take`s the value into the closure parameter, relocating the
@@ -328,18 +315,17 @@ impl core::ops::DerefMut for UvFsReq {
 // Local cross-crate shims
 //
 // These wrap symbols whose canonical home moved under the Rust crate split so
-// the hundreds of call sites below — which mirror `node_fs.zig` 1:1 — don't
+// the hundreds of call sites below don't
 // have to be rewritten per-line. Each is a thin forwarder.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `bun.strings.withoutNTPrefix` — lives in `bun_core::paths`
-/// under the Rust crate split, not at the `strings` root.
+/// Strip the NT object-path prefix — forwards to `bun_core::paths`.
 #[inline]
 fn without_nt_prefix<T: bun_paths::string_paths::Ch>(path: &[T]) -> &[T] {
     bun_paths::string_paths::without_nt_prefix(path)
 }
 
-/// `bun.paths.OSPathLiteral("")` — Zig comptime string→`[:0]const OSPathChar`.
+/// Empty `OSPathChar` literal.
 /// Only the empty-string case is used in this file. `OSPathSliceZ` is a DST
 /// (`ZStr`/`WStr`), so callers borrow it.
 #[inline]
@@ -368,7 +354,7 @@ fn standalone_module_graph_get() -> Option<*mut bun_standalone_graph::Graph> {
 
 /// Local shim for `Maybe(void)::aborted` (node.rs:302). `bun_sys::Maybe` is
 /// `core::result::Result`, which has no `aborted()` constructor; inline the
-/// sentinel error directly so call sites stay shaped like the Zig source.
+/// sentinel error directly.
 #[inline]
 fn abort_err() -> sys::Error {
     sys::Error {
@@ -378,8 +364,8 @@ fn abort_err() -> sys::Error {
     }
 }
 
-/// `bun.sys.Error.withPathLike` — `with_path()` for a `PathOrFileDescriptor`.
-/// On `Fd`, the upstream Zig records the fd; here we just attach the path
+/// `with_path()` for a `PathOrFileDescriptor`.
+/// On `Fd`, records the fd; otherwise attach the path
 /// slice when available (matches the read/write callers in this file, which
 /// only reach this with `Path`).
 #[inline]
@@ -410,7 +396,7 @@ fn encoding_to_node(e: Encoding) -> bun_core::NodeEncoding {
     }
 }
 
-/// `bun.sys.PosixStat` — uv-shaped stat struct. `Stats::init` (from
+/// uv-shaped stat struct. `Stats::init` (from
 /// `super::stat`) takes its sibling `PosixStat` by reference, so route through
 /// that definition rather than `bun_sys::PosixStat` to keep the parameter
 /// type exact. Both are `#[repr(C)]` mirrors of `uv_stat_t`; once
@@ -428,14 +414,13 @@ fn err_from_static(name: &'static str) -> bun_core::Error {
     bun_core::Error::intern(name)
 }
 
-/// `bun.sys.preallocate_supported` / `preallocate_length` — the Zig consts
-/// were dropped in the lib.rs port (only `preallocate_file()` remains). Mirror
-/// the original values from `sys.zig` so the write-file fast path keeps its
-/// guard. 2 MiB matches `node_fs.zig`'s threshold.
+/// `preallocate_supported` / `preallocate_length` — these consts have
+/// no equivalent in `bun_sys` (only `preallocate_file()` exists there), so
+/// define them locally so the write-file fast path keeps its 2 MiB guard.
 const PREALLOCATE_SUPPORTED: bool = cfg!(any(target_os = "linux", target_os = "android"));
 const PREALLOCATE_LENGTH: usize = 2048 * 1024;
 
-/// Zig `PathString.PathInt` — path-length field width; `u32` on the Rust side.
+/// Path-length field width.
 type PathInt = u32;
 
 /// `Syscall.mkdirOSPath` / `Syscall.openatOSPath` — on POSIX `OSPathSliceZ` is
@@ -464,8 +449,7 @@ fn openat_os_path(dirfd: FD, path: &OSPathSliceZ, flags: i32, mode: Mode) -> May
     sys::openat_windows(dirfd, path.as_slice(), flags, mode)
 }
 
-/// `bun.sys.directoryExistsAt` — Zig dispatches on `anytype` element width
-/// (sys.zig:3601 → `existsAtType` picks `toNTPath16` for `[*]const u16`). On
+/// Check whether a directory exists at `(fd, path)` — dispatches on path element width. On
 /// Windows `OSPathSliceZ` is already `&WStr`, so forward to the wide overload
 /// instead of narrowing to UTF-8 and re-widening. POSIX is a forwarder.
 #[inline]
@@ -625,7 +609,7 @@ mod _async_tasks {
                         (this.completion)(
                             this.completion_ctx,
                             // `with_path` already clones into a fresh `Box<[u8]>`; pass the
-                            // existing path slice (Zig duped it explicitly).
+                            // existing path slice.
                             Err(err.with_path(&err.path)),
                         );
                     }
@@ -721,12 +705,10 @@ mod _async_tasks {
             let loop_ = uv::Loop::get();
             task.req.data = core::ptr::from_mut::<Self>(task).cast::<c_void>();
 
-            // PORT NOTE: Zig's `comptime switch (FunctionEnum)` monomorphises this
-            // to a single arm. Rust resolves the match at compile time too (`F` is
-            // a const generic), but each arm's body needs `A` re-asserted to its
-            // concrete `args::*` type — same identity-cast pattern as
-            // `NodeFS::dispatch` (per the `async_::*` aliases, `A == $Args` for the
-            // matched `F`).
+            // The match resolves at compile time (`F` is a const generic), but
+            // each arm's body needs `A` re-asserted to its concrete `args::*`
+            // type — same identity-cast pattern as `NodeFS::dispatch` (per the
+            // `async_::*` aliases, `A == $Args` for the matched `F`).
             macro_rules! args_as {
                 ($Args:ty) => {{
                     debug_assert_eq!(core::mem::size_of::<A>(), core::mem::size_of::<$Args>());
@@ -955,8 +937,7 @@ mod _async_tasks {
             // second overlapping `&mut` (Stacked-Borrows UB). Go through `this.req` instead.
             this.result =
                 NodeFS::uv_dispatch::<R, A, F>(&mut node_fs, &this.args, this.req.result.int());
-            // Zig clones `err` here so its `.path` outlives the stack `node_fs.sync_error_buf`
-            // it borrowed from. In Rust `sys::Error::path` is `Box<[u8]>` boxed at the
+            // `sys::Error::path` is `Box<[u8]>` boxed at the
             // `errno_sys_p` construction site, so no clone is needed — `node_fs` may drop.
             let this_ptr: *mut Self = this;
             this.global_object()
@@ -1028,8 +1009,7 @@ mod _async_tasks {
         pub unsafe fn destroy(this: *mut Self) {
             // SAFETY: caller guarantees `this` is a live Box-leaked allocation
             let this_ref = unsafe { &mut *this };
-            // Zig: `result.err.deinit()` — `bun_sys::Error` frees its path on Drop.
-            // Zig passed `*VirtualMachine`; Rust's KeepAlive takes `EventLoopCtx`.
+            // `bun_sys::Error` frees its path on Drop.
             this_ref.r#ref.unref(bun_io::js_vm_ctx());
             // `args: ThreadSafe<A>` unprotects + drops via `heap::take` below.
             this_ref.promise = JSPromiseStrong::default();
@@ -1044,11 +1024,9 @@ mod _async_tasks {
 
     /// Trait abstracting over Argument types' deinit/toThreadSafe.
     ///
-    /// Zig: every Arguments struct defines `toThreadSafe(self: *@This())` (clone
-    /// any borrowed JS-backed slices so the work-pool callback may run off-thread)
-    /// and most define `deinitAndUnprotect` (free those clones and `unprotect` any
-    /// retained `JSValue`s). The Zig spec dispatches via `@hasDecl`; in Rust the
-    /// trait methods are **required** so missing impls are a compile error rather
+    /// Every Arguments struct defines `to_thread_safe` (clone
+    /// any borrowed JS-backed slices so the work-pool callback may run off-thread).
+    /// The trait methods are **required** so missing impls are a compile error rather
     /// than a silent UAF/leak.
     pub trait FsArgument: Sized + Unprotect {
         const HAVE_ABORT_SIGNAL: bool = false;
@@ -1059,8 +1037,7 @@ mod _async_tasks {
         fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Self>;
         fn to_thread_safe(&mut self);
         /// Consume `self`, protect any JS-backed buffers, and return a guard that
-        /// unprotects on drop. The Rust replacement for Zig's
-        /// `args.toThreadSafe()` / `defer args.deinitAndUnprotect()` pair —
+        /// unprotects on drop —
         /// string/slice ownership is handled by each field's `Drop` (PathLike,
         /// StringOrBuffer, Vec); only the JS-side `unprotect()` needs the guard.
         #[inline]
@@ -1074,8 +1051,8 @@ mod _async_tasks {
     }
 
     /// Forward [`FsArgument`] to the inherent `from_js` / `to_thread_safe`
-    /// methods each `args::*` struct already defines (1:1 with `Arguments.*` in
-    /// `node_fs.zig`). [`Unprotect`] is implemented per-type alongside.
+    /// methods each `args::*` struct already defines.
+    /// [`Unprotect`] is implemented per-type alongside.
     macro_rules! impl_fs_argument {
     ( $( $ty:ty ),+ $(,)? ) => {
         $( impl FsArgument for $ty {
@@ -1083,9 +1060,7 @@ mod _async_tasks {
             #[inline] fn to_thread_safe(&mut self) { <$ty>::to_thread_safe(self) }
         } )+
     };
-    // Fd-only types — Zig has only `toThreadSafe(_: *const @This()) void {}`
-    // and no `deinitAndUnprotect`; spec node_fs.zig:325 falls back to
-    // `deinit()` (a no-op — these hold only `FD`/scalars).
+    // Fd-only types — `to_thread_safe` is a no-op (these hold only `FD`/scalars).
     ( @fd $( $ty:ty ),+ $(,)? ) => {
         $( impl FsArgument for $ty {
             #[inline] fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Self> { <$ty>::from_js(ctx, arguments) }
@@ -1160,9 +1135,7 @@ mod _async_tasks {
         }
     }
 
-    /// Convert an async-FS result payload to a `JSValue`. Mirrors Zig's
-    /// `globalObject.toJS(res)` (a generic `anytype` dispatcher that calls
-    /// `res.toJSNewlyCreated(globalObject)` if it exists, else `res.toJS(...)`).
+    /// Convert an async-FS result payload to a `JSValue`.
     /// Each `ret::*` type implements this by forwarding to its inherent method.
     pub trait FsReturn {
         fn fs_to_js(&mut self, global: &JSGlobalObject) -> JsResult<JSValue>;
@@ -1256,9 +1229,8 @@ mod _async_tasks {
     }
 
     /// `Taskable` glue so `ConcurrentTask::create_from(this)` resolves on the
-    /// generic `AsyncFSTask<R, A, F>`. The Zig source mapped each instantiation to
-    /// a distinct `task_tag::*` via the comptime type-name lookup; the const-
-    /// generic `F` carries that information and `NodeFSFunctionEnum::task_tag()`
+    /// generic `AsyncFSTask<R, A, F>`. The const-
+    /// generic `F` carries the task tag and `NodeFSFunctionEnum::task_tag()`
     /// is `const fn`, so the per-`F` tag is computed at monomorphisation time.
     impl<R, A: Unprotect, const F: NodeFSFunctionEnum> bun_event_loop::Taskable
         for AsyncFSTask<R, A, F>
@@ -1274,8 +1246,7 @@ mod _async_tasks {
 
     pub struct AsyncFSTask<R, A: Unprotect, const F: NodeFSFunctionEnum> {
         pub promise: JSPromiseStrong,
-        /// Wrapped in [`ThreadSafe`] so the paired `unprotect()` runs on drop —
-        /// replaces Zig's explicit `args.deinitAndUnprotect()` in `destroy()`.
+        /// Wrapped in [`ThreadSafe`] so the paired `unprotect()` runs on drop.
         pub args: ThreadSafe<A>,
         pub global_object: bun_ptr::BackRef<JSGlobalObject>,
         pub task: WorkPoolTask,
@@ -1342,8 +1313,7 @@ mod _async_tasks {
 
             let mut node_fs = NodeFS::default();
             this.result = NodeFS::dispatch::<R, A, F>(&mut node_fs, &this.args, Flavor::Async);
-            // Zig clones `err` here so its `.path` outlives the stack `node_fs.sync_error_buf`
-            // it borrowed from. In Rust `sys::Error::path` is `Box<[u8]>` boxed at the
+            // `sys::Error::path` is `Box<[u8]>` boxed at the
             // `errno_sys_p` construction site, so no clone is needed — `node_fs` may drop.
 
             // `bun_vm_concurrently()` skips the JS-thread debug assert and is the
@@ -1410,9 +1380,8 @@ mod _async_tasks {
         pub unsafe fn destroy(this: *mut Self) {
             // SAFETY: caller guarantees `this` is a live Box-leaked allocation
             let this_ref = unsafe { &mut *this };
-            // Zig: `result.err.deinit()` — `bun_sys::Error` frees its path on Drop.
+            // `bun_sys::Error` frees its path on Drop.
             // SAFETY: global_object outlives task; JSC_BORROW per LIFETIMES.tsv.
-            // Zig passed `*VirtualMachine`; Rust's KeepAlive takes `EventLoopCtx`.
             this_ref.r#ref.unref(bun_io::js_vm_ctx());
             // `args: ThreadSafe<A>` unprotects + drops via `heap::take` below.
             this_ref.promise = JSPromiseStrong::default();
@@ -1428,8 +1397,7 @@ mod _async_tasks {
     pub type AsyncCpTask = NewAsyncCpTask<false>;
     pub type ShellAsyncCpTask = NewAsyncCpTask<true>;
 
-    // Zig path was `bun.shell.Interpreter.Builtin.Cp.ShellCpTask`. The Rust shell
-    // port flattens builtins under `crate::shell::builtins::*`. The
+    // The shell flattens builtins under `crate::shell::builtins::*`. The
     // `cp_on_copy`/`cp_on_finish` hooks are inherent methods on that type
     // (cp.rs), called directly below — no trait indirection.
     pub(crate) type ShellCpTask = crate::shell::builtins::cp::ShellCpTask;
@@ -1451,11 +1419,9 @@ mod _async_tasks {
         /// If this task is called by the shell then we shouldn't call this as
         /// it is not threadsafe and is unnecessary as the process will be kept
         /// alive by the shell instance.
-        // PORT NOTE: Zig made the field conditional via `if (!is_shell) … else void`.
-        // Rust keeps the field unconditionally and simply skips `ref_()`/`unref()`
-        // on the `IS_SHELL` path (`KeepAlive::default()` is inert until ref'd).
+        // The field exists unconditionally; the `IS_SHELL` path simply skips
+        // `ref_()`/`unref()` (`KeepAlive::default()` is inert until ref'd).
         pub r#ref: KeepAlive,
-        // PERF(port): was arena bulk-free — profile if hot
         pub tracker: AsyncTaskTracker,
         pub has_result: AtomicBool,
         /// Number of in-flight references to `this`. Starts at 1 for the main
@@ -1482,9 +1448,8 @@ mod _async_tasks {
         /// so shared reads are safe-projected and `as_mut_ptr()` round-trips the
         /// original write provenance for `on_subtask_done`'s `&mut` promotion.
         pub cp_task: bun_ptr::ParentRef<NewAsyncCpTask<IS_SHELL>>,
-        /// Single owned allocation laid out as `<src>\0<dest>\0`. Zig stores two
-        /// `bun.OSPathSliceZ` (sentinel slices) into a single `default_allocator`
-        /// buffer; here ownership is encoded directly as `Box<[OSPathChar]>` and
+        /// Single owned allocation laid out as `<src>\0<dest>\0`. Ownership is
+        /// encoded directly as `Box<[OSPathChar]>` and
         /// the two NUL-terminated views are reconstructed via `src()` / `dest()`.
         path_buf: Box<[OSPathChar]>,
         src_len: usize,
@@ -1657,10 +1622,10 @@ mod _async_tasks {
 
         pub fn create_mini(
             cp_args: args::Cp,
-            // PORT NOTE: `EventLoopHandle::Mini` stores `*mut MiniEventLoop<'static>` (a
+            // `EventLoopHandle::Mini` stores `*mut MiniEventLoop<'static>` (a
             // non-owning erased backref, see `bun_event_loop::AnyEventLoop`). Taking the
             // raw pointer here avoids forcing every caller's `MiniEventLoop` borrow to be
-            // `'static` — Zig passed `*MiniEventLoop` and the task never outlives it.
+            // `'static`; the task never outlives the loop.
             mini: *mut MiniEventLoop<'static>,
             shelltask: *mut ShellCpTask,
         ) -> *mut Self {
@@ -1711,8 +1676,7 @@ mod _async_tasks {
             }
             // The CAS above guarantees exactly one thread reaches this write; the
             // `subtask_count` AcqRel fence in `on_subtask_done` publishes it to the
-            // JS-thread reader. (Zig clones `err.path` here to outlive the caller's
-            // stack buffer; in Rust `sys::Error::path` is already `Box<[u8]>`, so
+            // JS-thread reader. (`sys::Error::path` is already `Box<[u8]>`, so
             // move-assign suffices.)
             self.result.set(result);
         }
@@ -1748,8 +1712,6 @@ mod _async_tasks {
             // provenance from `Box::leak`, so the enqueued callback may safely
             // form `&mut *this` on the JS thread.
             if matches!(this_ref.evtloop, EventLoopHandle::Js { .. }) {
-                // PORT NOTE: `ConcurrentTask::from_callback` expects `fn(*mut T) -> JsResult<()>`;
-                // Zig accepted `fn(*T) JSError!void` directly. Adapt the signature inline.
                 this_ref.evtloop.enqueue_task_concurrent(EventLoopTaskPtr {
                     js: ConcurrentTask::from_callback(this, |p| {
                         // SAFETY: `p` is the `Box::leak`'d task; subtask count hit zero so this
@@ -1779,7 +1741,7 @@ mod _async_tasks {
             if IS_SHELL {
                 // SAFETY: shelltask is set by create_with_shell_task/create_mini and outlives this task
                 // Move the result out — `Maybe<ret::Cp>` (= `Maybe<()>`) has a cheap
-                // `Ok(())` placeholder, mirroring Zig which read the union value once.
+                // `Ok(())` placeholder.
                 let result = core::mem::replace(self.result.get_mut(), Ok(()));
                 let shelltask = self.shelltask.expect("IS_SHELL ⇒ shelltask").as_mut_ptr();
                 // SAFETY: shelltask is non-null in the IS_SHELL specialization and
@@ -1800,7 +1762,7 @@ mod _async_tasks {
             let success = (*self.result.get_mut()).is_ok();
             let promise_value = self.promise.value();
             // Captured as a raw pointer because `Self::destroy(self)` runs *before* the
-            // resolve/reject (matching Zig). The `JSPromise` itself lives on the JS heap
+            // resolve/reject. The `JSPromise` itself lives on the JS heap
             // and is kept alive past `destroy` by `promise_value.ensure_still_alive()`.
             let promise: *mut bun_jsc::JSPromise = self.promise.get();
             let result = match self.result.get_mut() {
@@ -1846,18 +1808,16 @@ mod _async_tasks {
         pub unsafe fn destroy(this: *mut Self) {
             // SAFETY: caller guarantees `this` is a live Box-leaked allocation
             let this_ref = unsafe { &mut *this };
-            // PORT NOTE: Zig `err.deinit()` freed the path slice; Rust `bun_sys::Error`
-            // owns `Box<[u8]>` and frees on Drop (in `heap::take` below).
+            // `bun_sys::Error` owns its path slice (`Box<[u8]>`) and frees it on
+            // Drop (in `heap::take` below).
             if !IS_SHELL {
                 this_ref
                     .r#ref
                     .unref(event_loop_handle_to_ctx(this_ref.evtloop));
             }
             // `args.deinit()` → `Drop` on `args::Cp` (via `heap::take` below).
-            // PORT NOTE: intentional spec divergence — Zig `NewAsyncCpTask.deinit` only
-            // calls `args.deinit()` (no-op for `.buffer`), leaking the `protect()` taken by
-            // `args.toThreadSafe()` when `src`/`dest` are Buffers. `Drop for ThreadSafe<args::Cp>`
-            // releases that protect here, fixing the leak.
+            // `Drop for ThreadSafe<args::Cp>` releases the `protect()` taken by
+            // `to_thread_safe()` when `src`/`dest` are Buffers, so nothing leaks here.
             this_ref.promise = JSPromiseStrong::default();
             // SAFETY: paired with Box::leak in create_with_shell_task()/create_mini()
             drop(unsafe { bun_core::heap::take(this) });
@@ -1922,16 +1882,14 @@ mod _async_tasks {
                         src,
                         dest,
                         if IS_SHELL {
-                            // Shell always forces copy (overwrite allowed). Spec
-                            // (node_fs.zig:758) passes `Copyfile.force` here, but
-                            // that value is `COPYFILE_FICLONE_FORCE` and was a
-                            // no-op in Zig's Windows `_copySingleFileSync` (which
-                            // never checks `isForceClone`). The Rust port added an
-                            // ENOSYS guard for `is_force_clone()` on Windows (see
-                            // the comment at the top of that branch), so passing
-                            // `FORCE` would make every shell `cp file dest` fail
-                            // with ENOSYS. Mode `0` yields the same effective
-                            // behaviour the Zig path had: `shouldnt_overwrite()`
+                            // Shell always forces copy (overwrite allowed).
+                            // `Copyfile::force` is `COPYFILE_FICLONE_FORCE`, and
+                            // `_copy_single_file_sync` has an ENOSYS guard for
+                            // `is_force_clone()` on Windows (see the comment at
+                            // the top of that branch), so passing `FORCE` would
+                            // make every shell `cp file dest` fail with ENOSYS.
+                            // Mode `0` yields the intended behaviour:
+                            // `shouldnt_overwrite()`
                             // is false and `CopyFileW` overwrites.
                             constants::Copyfile::from_raw(0)
                         } else {
@@ -2043,7 +2001,7 @@ mod _async_tasks {
             let this_ref = unsafe { &*this };
             // SAFETY: callers NUL-terminate at src_dir_len/dest_dir_len before calling.
             // Platform-generic — `OSPathBuffer` is `[u16;N]` on Windows, `[u8;N]` on POSIX,
-            // so reconstruct as `&OSPathSliceZ` (Zig: `src_buf[0..src_dir_len :0]`).
+            // so reconstruct as `&OSPathSliceZ`.
             let src = unsafe { OSPathSliceZ::from_raw(src_buf.as_ptr(), src_dir_len as usize) };
             // SAFETY: dest_buf[dest_dir_len] == 0 written by caller
             let dest = unsafe { OSPathSliceZ::from_raw(dest_buf.as_ptr(), dest_dir_len as usize) };
@@ -2057,8 +2015,7 @@ mod _async_tasks {
                 ) {
                     match err.get_errno() {
                         E::EACCES | E::ENAMETOOLONG | E::EROFS | E::EPERM | E::EINVAL => {
-                            // Zig copies `src` into `sync_error_buf` and `.withPath()`s it so
-                            // the borrowed slice outlives the stack frame. `errno_sys_p`
+                            // `errno_sys_p`
                             // already boxed `src.as_bytes()` into `err.path`, so just forward.
                             this_ref.finish_concurrently(err);
                             return false;
@@ -2091,7 +2048,7 @@ mod _async_tasks {
                 FD::INVALID,
                 dest.as_slice(),
                 &mut buf[..],
-                // node_fs.zig:861 `.{ .add_nt_prefix = false }` — `normdest` feeds
+                // No NT prefix — `normdest` feeds
                 // `mkdirRecursiveOSPath` / `CopyFileW` which expect Win32 paths,
                 // not `\??\` NT object paths.
                 sys::NormalizePathWindowsOpts {
@@ -2118,10 +2075,9 @@ mod _async_tasks {
                 }
             }
 
-            // PORT NOTE: `DirIterator.iterate(dir, kind)` (Zig runtime arg) maps to a
-            // const-generic `PathType` in the Rust port. On POSIX directory entries
-            // are always UTF-8, so monomorphise on `PathType::U8` and let the
-            // Windows branch (gated above) handle the wide path.
+            // On POSIX directory entries are always UTF-8, so monomorphise the
+            // const-generic path type on `U8` and let the Windows branch (gated
+            // above) handle the wide path.
             #[cfg(windows)]
             let mut iterator = DirIterator::iterate::<true>(fd);
             #[cfg(not(windows))]
@@ -2276,7 +2232,6 @@ mod _async_tasks {
                     res.clear();
                 }
                 ResultListEntryValue::Buffers(res) => {
-                    // Zig: `bun.default_allocator.free(item.buffer.byteSlice())`.
                     // `MarkedArrayBuffer::destroy` frees the owned byte slice when
                     // `owns_buffer` (set by `Buffer::from_string` in
                     // `ReaddirEntry::append_entry*`).
@@ -2363,15 +2318,14 @@ mod _async_tasks {
             self.global_object.get()
         }
 
-        /// `bun.default_allocator.free(this.root_path.slice())` — paired with the
-        /// `dupeZ` in `create()`. Idempotent (empty `Box` after first call).
+        /// Free `root_path` — paired with the NUL-terminated duplication in
+        /// `create()`. Idempotent (empty `Box` after first call).
         fn free_root_path(&mut self) {
             drop(core::mem::take(&mut self.root_path));
         }
 
         pub fn enqueue(&mut self, basename: &ZStr) {
-            // Spec (node_fs.zig:1058) does `bun.default_allocator.dupeZ(u8, basename)` —
-            // the subtask runs on another thread after the caller's `name_to_copy_z`
+            // The subtask runs on another thread after the caller's `name_to_copy_z`
             // (which points into a per-iteration buffer) has been overwritten, so we
             // must heap-own the bytes here. Freed in ReaddirSubtask::call's cleanup.
             let mut owned = Vec::with_capacity(basename.len() + 1);
@@ -2380,8 +2334,7 @@ mod _async_tasks {
             // NUL-terminated `[bytes.., 0]`; moved into the subtask and freed
             // when `ReaddirSubtask` drops.
             let basename_owned: Box<[u8]> = owned.into_boxed_slice();
-            // Spec (node_fs.zig:1061) `bun.assert(subtask_count.fetchAdd(1, .monotonic) > 0)`
-            // — the fetch_add is load-bearing (refcounts the in-flight subtask). It
+            // The fetch_add is load-bearing (refcounts the in-flight subtask). It
             // MUST run in release builds; only the `> 0` invariant check is debug-only.
             let prev = self.subtask_count.fetch_add(1, Ordering::Relaxed);
             debug_assert!(prev > 0);
@@ -2407,7 +2360,7 @@ mod _async_tasks {
                 ret::ReaddirTag::WithFileTypes => ResultListEntryValue::WithFileTypes(Vec::new()),
                 ret::ReaddirTag::Buffers => ResultListEntryValue::Buffers(Vec::new()),
             };
-            // Zig: `bun.default_allocator.dupeZ(u8, args.path.slice())`. The
+            // The
             // subtasks read `root_path` (NUL-terminated) from the work pool after
             // `args.to_thread_safe()` may have rehomed the original slice, so we
             // must own a NUL-terminated copy. Freed in `finish_concurrently()` or
@@ -2445,20 +2398,15 @@ mod _async_tasks {
         }
 
         pub fn perform_work(&mut self, basename: &ZStr, buf: &mut PathBuffer, is_root: bool) {
-            // PERF(port): was comptime monomorphization on tag — runtime match here
             // SAFETY: `readdir_with_entries_recursive_async` takes `args` and
             // `async_task` separately even though `args == &async_task.args`. The
             // callee never mutates `args` (only `async_task.{root_fd, enqueue}`),
-            // so erase the field borrow through a raw pointer to satisfy borrowck —
-            // mirrors the Zig spec, which passed both freely.
+            // so erase the field borrow through a raw pointer to satisfy borrowck.
             let args_ptr: *const args::Readdir = &raw const *self.args;
             macro_rules! impl_tag {
                 ($T:ty, $variant:ident) => {{
-                    // Zig: `var stack = std.heap.stackFallback(8192, …)` — the
-                    // first ~8 KiB of entries lived on the stack so small
-                    // directories (the common case) never touched the heap until
-                    // `writeResults` cloned with exact capacity. `Vec::new()` here
-                    // instead grew through every power-of-two size class on the
+                    // A bare `Vec::new()` here
+                    // grew through every power-of-two size class on the
                     // heap; under mimalloc-debug each fresh-page realloc runs
                     // `mi_mem_is_zero` over the whole arena page, which dominated
                     // the recursive-readdir perf profile (~15% self-time).
@@ -2528,17 +2476,13 @@ mod _async_tasks {
 
         pub fn write_results<T: IntoResultListEntry>(&mut self, result: &mut Vec<T>) {
             if !result.is_empty() {
-                // Zig cloned because `result` was backed by a stack-fallback
-                // allocator and could not outlive `perform_work`'s frame. In Rust
-                // `result` is already a heap `Vec`, so cloning is a redundant
+                // `result` is already a heap `Vec`, so cloning would be a redundant
                 // alloc+memcpy; just take ownership and trim the over-reservation
-                // from `perform_work` so the queued entry holds exact capacity
-                // (matches Zig's `initCapacity(len)` semantics).
+                // from `perform_work` so the queued entry holds exact capacity.
                 let mut clone: Vec<T> = core::mem::take(result);
                 clone.shrink_to_fit();
                 self.result_list_count
                     .fetch_add(clone.len(), Ordering::Relaxed);
-                // Zig `@unionInit(Value, @tagName(Field), clone)` →
                 // `IntoResultListEntry::into_variant` (trait dispatch on `T`).
                 let list = Box::new(ResultListEntry {
                     next: bun_threading::Link::new(),
@@ -2586,8 +2530,6 @@ mod _async_tasks {
                 // be read by the iterator.
                 let mut to_destroy: Option<*mut ResultListEntry> = None;
 
-                // Zig: `inline else => |tag| { var results = &@field(result_list, @tagName(tag));
-                // results.ensureTotalCapacityPrecise(count); … results.appendSliceAssumeCapacity(field) }`.
                 // `reserve_exact`/`append_from` dispatch on the runtime tag.
                 let cap = self.result_list_count.swap(0, Ordering::Relaxed);
                 self.result_list.reserve_exact(cap);
@@ -2714,15 +2656,15 @@ mod _async_tasks {
             // SAFETY: caller guarantees `this` is a live Box-leaked allocation
             let this_ref = unsafe { &mut *this };
             debug_assert!(this_ref.root_fd == FD::INVALID); // should already have closed it
-            // Zig `err.deinit()` — `bun_sys::Error` frees on Drop; nothing to do.
+            // `bun_sys::Error` frees on Drop; nothing to do.
             let _ = this_ref.pending_err.take();
-            // Zig passed `bunVM()`; Rust `KeepAlive::unref` takes the type-erased
+            // `KeepAlive::unref` takes the type-erased
             // `EventLoopCtx`. Resolve via the global JS-loop hook (single JS thread).
             this_ref.r#ref.unref(bun_io::js_vm_ctx());
             // `args.deinit()` → `Drop` on `args::Readdir` (via `heap::take` below).
             this_ref.free_root_path();
             this_ref.clear_result_list();
-            // Zig `promise.deinit()` — `JSPromiseStrong` releases on Drop (via heap::take below).
+            // `JSPromiseStrong` releases on Drop (via heap::take below).
             // SAFETY: paired with Box::leak in create()
             drop(unsafe { bun_core::heap::take(this) });
         }
@@ -2730,9 +2672,8 @@ mod _async_tasks {
 
     /// Maps a readdir element type to its `ResultListEntryValue` variant.
     ///
-    /// PORT NOTE: Zig used `@unionInit(ResultListEntry.Value, @tagName(tag), clone)`
-    /// inside `writeResults`, dispatching on `comptime ResultType`. Rust can't
-    /// switch on a generic `T`, so the per-type wrapping lives on this trait.
+    /// Rust can't switch on a generic `T` inside `write_results`, so the
+    /// per-type `ResultListEntryValue` wrapping lives on this trait.
     pub trait IntoResultListEntry: Sized {
         fn into_variant(v: Vec<Self>) -> ResultListEntryValue;
     }
@@ -2789,10 +2730,10 @@ pub use _async_tasks::{
 // ──────────────────────────────────────────────────────────────────────────
 // Arguments
 // ──────────────────────────────────────────────────────────────────────────
-// TODO: to improve performance for all of these
-// The tagged unions for each type should become regular unions
-// and the tags should be passed in as comptime arguments to the functions performing the syscalls
-// This would reduce stack size, at the cost of instruction cache misses
+// TODO: to improve performance for all of these, the tagged unions for each
+// type could become untagged unions with the tag passed as a const generic to
+// the functions performing the syscalls. This would reduce stack size, at the
+// cost of instruction cache misses.
 pub mod args {
     use super::*;
 
@@ -2829,7 +2770,7 @@ pub mod args {
                     arguments.next().unwrap_or(JSValue::UNDEFINED),
                 )
             })?;
-            // `errdefer old_path.deinit()` → `Drop for PathLike` on early return.
+            // `Drop for PathLike` runs on early return.
             let new_path = PathLike::from_js(ctx, arguments)?.ok_or_else(|| {
                 ctx.throw_invalid_argument_type_value(
                     b"newPath",
@@ -2868,9 +2809,8 @@ pub mod args {
         }
     }
 
-    /// Shared layout for `fs.writev` / `fs.readv` arguments. Zig keeps two
-    /// byte-identical copy-pasted structs (`Arguments.Writev` / `Arguments.Readv`,
-    /// node_fs.zig:1364-1468); we keep one concrete struct and re-export both
+    /// Shared layout for `fs.writev` / `fs.readv` arguments. One concrete
+    /// struct; we re-export both
     /// names as type aliases so every `args::Writev` / `args::Readv` caller
     /// (UVFSRequest params, `readv`/`writev`/`preadv_inner`/`pwritev_inner`,
     /// uv dispatch arms) is untouched.
@@ -2884,7 +2824,7 @@ pub mod args {
         fn unprotect(&mut self) {
             self.buffers.release();
             self.buffers.value.unprotect();
-            // Zig: `self.buffers.buffers.deinit()` — `Vec` frees on drop.
+            // `self.buffers.buffers`: `Vec` frees on drop.
         }
     }
     impl FdVectorIo {
@@ -2966,8 +2906,8 @@ pub mod args {
     fs_args_path_forwarders!(Chown; path);
     impl Chown {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Chown> {
-            // Zig: `errdefer path.deinit()` — `Drop for PathLike` covers every
-            // error return below (including `try validateInteger`).
+            // `Drop for PathLike` covers every
+            // error return below (including `validate_integer`).
             let path = PathLike::from_js_required(ctx, arguments, "path")?;
             let uid: UidT = 'brk: {
                 let Some(uid_value) = arguments.next() else {
@@ -3062,8 +3002,8 @@ pub mod args {
     fs_args_path_forwarders!(Lutimes; path);
     impl Lutimes {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Lutimes> {
-            // Zig: `errdefer path.deinit()` — `Drop for PathLike` covers the
-            // `try timeLikeFromJS` throws below.
+            // `Drop for PathLike` covers the
+            // `time_like_from_js` throws below.
             let path = PathLike::from_js_required(ctx, arguments, "path")?;
             let atime = node::time_like_from_js(
                 ctx,
@@ -3104,8 +3044,8 @@ pub mod args {
     fs_args_path_forwarders!(Chmod; path);
     impl Chmod {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Chmod> {
-            // Zig: `errdefer path.deinit()` — `Drop for PathLike` covers the
-            // `try modeFromJS` throw below.
+            // `Drop for PathLike` covers the
+            // `mode_from_js` throw below.
             let path = PathLike::from_js_required(ctx, arguments, "path")?;
             let mode_arg = arguments.next().unwrap_or(JSValue::UNDEFINED);
             let mode: Mode = match node::mode_from_js(ctx, mode_arg)? {
@@ -3163,8 +3103,8 @@ pub mod args {
     fs_args_path_forwarders!(StatFS; path);
     impl StatFS {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<StatFS> {
-            // Zig: `errdefer path.deinit()` — `Drop for PathLike` covers the
-            // `try get_boolean_strict` throw below.
+            // `Drop for PathLike` covers the
+            // `get_boolean_strict` throw below.
             let path = PathLike::from_js_required(ctx, arguments, "path")?;
             let big_int = 'brk: {
                 if let Some(next_val) = arguments.next() {
@@ -3201,7 +3141,7 @@ pub mod args {
     fs_args_path_forwarders!(Stat; path);
     impl Stat {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Stat> {
-            // Zig: `errdefer path.deinit()` (node_fs.zig:1756) → `Drop for PathLike`.
+            // `Drop for PathLike` covers the error returns below.
             let path = PathLike::from_js_required(ctx, arguments, "path")?;
             let mut throw_if_no_entry = true;
             let big_int = 'brk: {
@@ -3265,7 +3205,7 @@ pub mod args {
     impl Link {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Link> {
             let old_path = PathLike::from_js_required(ctx, arguments, "oldPath")?;
-            // `errdefer old_path.deinit()` → `Drop for PathLike` on early return.
+            // `Drop for PathLike` runs on early return.
             let new_path = PathLike::from_js_required(ctx, arguments, "newPath")?;
             Ok(Link { old_path, new_path })
         }
@@ -3293,9 +3233,8 @@ pub mod args {
     fs_args_path_forwarders!(Symlink; target_path, new_path);
     impl Symlink {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Symlink> {
-            // Zig: `errdefer old_path.deinit()` (node_fs.zig:1883) → `Drop for PathLike`.
+            // `Drop for PathLike` covers the error returns below.
             let old_path = PathLike::from_js_required(ctx, arguments, "target")?;
-            // Zig: `errdefer new_path.deinit()` (node_fs.zig:1888) → `Drop for PathLike`.
             let new_path = PathLike::from_js_required(ctx, arguments, "path")?;
             // The type argument is only available on Windows and
             // ignored on other platforms. It can be set to 'dir',
@@ -3391,7 +3330,7 @@ pub mod args {
     /// Accepts either an encoding string (`"utf8"`, `"buffer"`, ...) or an options
     /// object with an `.encoding` property. Any other value (including `undefined`
     /// / `null` / numbers / functions) is silently ignored and `default` is returned.
-    /// Mirrors the copy-pasted block in Zig's `Readlink/Realpath/MkdirTemp.fromJS`.
+    /// Shared by `Readlink`/`Realpath`/`MkdirTemp::from_js`.
     pub(super) fn parse_encoding_arg(
         ctx: &JSGlobalObject,
         arguments: &mut ArgumentsSlice,
@@ -3825,7 +3764,7 @@ pub mod args {
             } else {
                 Encoding::Utf8
             };
-            // `errdefer args.deinit()` (node_fs.zig:2491) → `Drop for StringOrBuffer`
+            // `Drop for StringOrBuffer`
             // on `args.buffer` releases the slice on any `?`-propagated JsError.
             let mut args = Write {
                 fd,
@@ -4031,8 +3970,7 @@ pub mod args {
                 ));
             }
             let length_int: i64 = length_float as i64;
-            // Zig (node_fs.zig:2621) compares `i64 > usize` with sign-aware peer
-            // widening, so negative `length_int` falls through to the `< 0` arm
+            // Negative `length_int` must fall through to the `< 0` arm
             // below. Guard the `as usize` cast so it doesn't wrap-to-huge here.
             if length_int > 0 && length_int as usize > buf_len {
                 return Err(ctx.throw_range_error(
@@ -4177,7 +4115,7 @@ pub mod args {
     }
     impl Drop for ReadFile {
         fn drop(&mut self) {
-            // Zig `deinit()`: release the AbortSignal ref taken in `from_js`.
+            // Release the AbortSignal ref taken in `from_js`.
             if let Some(signal) = self.signal.take() {
                 signal.pending_activity_unref();
             }
@@ -4195,8 +4133,8 @@ pub mod args {
             self.path.to_thread_safe();
         }
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<ReadFile> {
-            // `errdefer path.deinit()` → `Drop` on `path` covers every
-            // `?`-propagated JsError below (matches node_fs.zig).
+            // `Drop` on `path` covers every
+            // `?`-propagated JsError below.
             let path = PathOrFileDescriptor::from_js(ctx, arguments)?.ok_or_else(|| {
                 ctx.throw_invalid_arguments(format_args!(
                     "path must be a string or a file descriptor"
@@ -4265,7 +4203,7 @@ pub mod args {
     }
     impl Drop for WriteFile {
         fn drop(&mut self) {
-            // Zig `deinit()`: release the AbortSignal ref taken in `from_js`.
+            // Release the AbortSignal ref taken in `from_js`.
             if let Some(signal) = self.signal.take() {
                 signal.pending_activity_unref();
             }
@@ -4289,8 +4227,8 @@ pub mod args {
             ctx: &JSGlobalObject,
             arguments: &mut ArgumentsSlice,
         ) -> JsResult<WriteFile> {
-            // `errdefer path.deinit()` → `Drop` on `path` covers every
-            // `?`-propagated JsError below (matches node_fs.zig).
+            // `Drop` on `path` covers every
+            // `?`-propagated JsError below.
             let path = PathOrFileDescriptor::from_js(ctx, arguments)?.ok_or_else(|| {
                 ctx.throw_invalid_arguments(format_args!(
                     "path must be a string or a file descriptor"
@@ -4392,8 +4330,11 @@ pub mod args {
                 if arg.is_string() {
                     encoding = Encoding::assert(arg, ctx, encoding).unwrap_or(encoding);
                 } else if arg.is_object() {
-                    // PORT NOTE: Zig calls `getEncoding(arg, ctx)` (two args) — relies on
-                    // Zig's default-param coercion to `Encoding.utf8`. Preserve behaviour.
+                    // `encoding` starts as `Encoding::Buffer` (set above) and is only
+                    // overwritten when `.encoding` is present and valid; `get_encoding`
+                    // errors are swallowed, leaving Buffer. Open question:
+                    // Node documents `'utf8'` as fs.opendir's default encoding —
+                    // possible utf8-vs-buffer divergence, preserved as-is.
                     if let Ok(e) = get_encoding(arg, ctx, encoding) {
                         encoding = e;
                     }
@@ -4481,7 +4422,7 @@ pub mod args {
     impl CopyFile {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<CopyFile> {
             let src = PathLike::from_js_required(ctx, arguments, "src")?;
-            // `errdefer src.deinit()` → `Drop for PathLike` on early return.
+            // `Drop for PathLike` runs on early return.
             let dest = PathLike::from_js_required(ctx, arguments, "dest")?;
             let mut mode = constants::Copyfile::from_raw(0);
             if let Some(arg) = arguments.next() {
@@ -4527,13 +4468,13 @@ pub mod args {
             self.to_thread_safe();
             ThreadSafe::adopt(self)
         }
-        // Zig `deinit()` was gated on `flags.deinit_paths`; in Rust the
+        // The
         // `PathLike::String` arm's `Drop` is a no-op for borrowed `CowSlice`
         // payloads (the only `deinit_paths: false` caller — shell `cp`), so the
-        // flag is vestigial and the explicit hook is gone.
+        // `deinit_paths` flag is vestigial and there is no explicit cleanup hook.
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Cp> {
             let src = PathLike::from_js_required(ctx, arguments, "src")?;
-            // `errdefer src.deinit()` → `Drop for PathLike` on early return.
+            // `Drop for PathLike` runs on early return.
             let dest = PathLike::from_js_required(ctx, arguments, "dest")?;
             let mut recursive = false;
             let mut error_on_exist = false;
@@ -4780,8 +4721,7 @@ pub mod ret {
                     // build an empty array, push `item.toJS(globalObject)` for
                     // each. Ownership of every `Buffer`'s bytes transfers to
                     // JSC via `MarkedArrayBuffer::to_js`; the boxed slice
-                    // itself is freed when `items` drops (Zig: `defer
-                    // bun.default_allocator.free(this.buffers)`).
+                    // itself is freed when `items` drops.
                     let array = JSValue::create_empty_array(global_object, items.len())?;
                     for (i, item) in items.iter().enumerate() {
                         let res = item.to_js(global_object)?;
@@ -4793,10 +4733,9 @@ pub mod ret {
                     Ok(array)
                 }
                 Readdir::Files(items) => {
-                    // `JSValue.fromAny(_, []const bun.String, _)` — dedicated
-                    // arm: `bun.String.toJSArray` then deref every element +
-                    // free the slice (handled by the `FromAny for
-                    // Box<[bun_core::String]>` impl).
+                    // Converted to a JS array, then every element is
+                    // deref'd and the slice freed (handled by the `FromAny
+                    // for Box<[bun_core::String]>` impl).
                     JSValue::from_any(global_object, items)
                 }
             }
@@ -4839,8 +4778,7 @@ pub use ret as Return;
 
 // `#[repr(C)]` pins `sync_error_buf` (a `[u8; N]`, nominal align = 1) at
 // offset 0. The struct's overall alignment is ≥ `align_of::<*const ()>()`
-// (from the `vm` field), so the buffer's address inherits that alignment —
-// the Rust equivalent of Zig's `sync_error_buf: bun.PathBuffer align(@alignOf(u16))`.
+// (from the `vm` field), so the buffer's address inherits that alignment.
 // This is load-bearing on Windows where `sync_error_buf` is reinterpreted as
 // `&mut [u16]` / `&mut WPathBuffer` (see `mkdir_recursive_os_path_impl` and
 // the `os_path_kernel32` callers); a misaligned `&mut [u16]` is instant UB.
@@ -4851,7 +4789,7 @@ pub struct NodeFS {
     /// We want to avoid allocating a new path buffer for every error message so that jsc can clone + GC it.
     /// That means a stack-allocated buffer won't suffice. Instead, we re-use
     /// the heap allocated buffer on the NodeFS struct
-    pub sync_error_buf: PathBuffer, // align(@alignOf(u16)) — enforced via #[repr(C)] + field order, see above
+    pub sync_error_buf: PathBuffer, // must be align_of::<u16>()-aligned — enforced via #[repr(C)] + field order, see above
     pub vm: Option<NonNull<VirtualMachine>>,
 }
 
@@ -4864,7 +4802,7 @@ impl Default for NodeFS {
     }
 }
 
-// `pub type ReturnType = ret;` (Zig: `pub const ReturnType = Return;`) — Rust
+// `pub type ReturnType = ret;` — Rust
 // inherent `type` aliases can't name a module. Expose it as a `pub use` at the
 // containing module level instead so `NodeFS::ReturnType::Foo` callers (none
 // yet in-tree) keep working via `node::fs::ReturnType::Foo`.
@@ -4872,11 +4810,10 @@ pub use ret as ReturnType;
 
 impl NodeFS {
     pub fn access(&mut self, args: &args::Access, _: Flavor) -> Maybe<ret::Access> {
-        // PORT: Zig passes `osPathKernel32(...)` (wide on Windows) into
-        // `Syscall.access(OSPathSliceZ)`. The Rust `bun_sys::access` Windows
+        // The `bun_sys::access` Windows
         // arm takes `&ZStr` and performs the kernel32 widening internally
         // (sys/lib.rs `windows_impl::access`), so feed it the UTF-8 path on
-        // every platform — net behaviour is identical.
+        // every platform.
         let path: &ZStr = if args.path.slice().is_empty() {
             ZStr::EMPTY
         } else {
@@ -4952,10 +4889,10 @@ impl NodeFS {
             if stat_size > stack_buf_len * 16 {
                 // Don't allocate more than 8 MB at a time
                 let clamped_size: usize = stat_size.min(8 * 1024 * 1024);
-                // PORT NOTE: Zig used `bun.default_allocator.alloc(u8, clamped_size)` —
-                // uninitialised heap. `Vec::resize` here was a debug-build hot path
-                // (byte-by-byte `extend_with`); use `expand_to_capacity` to match the spec
-                // (the slab is write-only — `Syscall::read` fills it from the kernel).
+                // The slab must stay uninitialised: `Vec::resize` here was a
+                // debug-build hot path (byte-by-byte `extend_with`). Use
+                // `expand_to_capacity` instead — the slab is write-only,
+                // `Syscall::read` fills it from the kernel.
                 use bun_collections::vec_ext::VecExt as _;
                 if buf_to_free.try_reserve_exact(clamped_size).is_err() {
                     break 'maybe_allocate_large_temp_buf;
@@ -4969,8 +4906,7 @@ impl NodeFS {
         // buf_to_free dropped at scope exit
 
         let mut remain = stat_size as u64;
-        // VERIFY-FIX(round1): Zig `while (cond) {} else {}` runs the else only when
-        // the loop exits because `cond` became false — never on `break`. The
+        // VERIFY-FIX(round1): the
         // `if remain == 0` check below was wrong: `break 'toplevel` after
         // `remain` had already saturated to 0 would still enter the else. Track
         // an explicit `broke` flag instead.
@@ -5162,9 +5098,9 @@ impl NodeFS {
                     // VERIFY-FIX(round1): was `usize` then passed as `&mut (wrote as u64)` —
                     // that wrote into a discarded temporary so the deferred ftruncate
                     // always saw 0. The scopeguard variant also double-borrowed `wrote`.
-                    // The Zig `defer` runs after `copy_file_using_read_write_loop` returns
-                    // into this scope; there are no early returns between open(dest) and
-                    // that call, so inlining the cleanup after is equivalent.
+                    // There are no early returns between open(dest) and the
+                    // `copy_file_using_read_write_loop` call, so inlining the
+                    // cleanup after it is equivalent.
                     let mut wrote: u64 = 0;
                     if args.mode.shouldnt_overwrite() {
                         flags |= sys::O::EXCL;
@@ -5265,13 +5201,12 @@ impl NodeFS {
 
             // FreeBSD 13+ has copy_file_range(2). Try the kernel-side copy
             // first; fall back to read/write on cross-device or unsupported
-            // fd types. std.c declares it returning usize on FreeBSD, so
-            // bitcast to isize before getErrno.
+            // fd types.
             'cfr: loop {
                 // SAFETY: src_fd/dest_fd are valid open fds; copy_file_range is the libc FFI.
-                // Null offsets so the kernel advances the file's seek position — matches
-                // `std.c.copy_file_range(..., null, ..., null, ...)` and keeps the read/write
-                // fallback (which uses the seek position) coherent if we ever break mid-loop.
+                // Null offsets so the kernel advances the file's seek position, keeping the
+                // read/write fallback (which uses the seek position) coherent if we ever
+                // break mid-loop.
                 let rc: isize = unsafe {
                     sys::freebsd::copy_file_range(
                         src_fd.native(),
@@ -5343,8 +5278,8 @@ impl NodeFS {
             // *after* the copy loops below mutate it. As a `usize` captured by-copy
             // the guard always saw 0, and the `&mut (wrote as u64)` call sites
             // wrote into discarded temporaries. `Cell<u64>` lets the guard borrow
-            // by reference while the loops `get`/`set`, matching Zig's `var wrote: u64`
-            // observed by `defer` at scope-exit time.
+            // by reference while the loops `get`/`set`, so the value observed at
+            // scope-exit time is the final one.
             let wrote: core::cell::Cell<u64> = core::cell::Cell::new(0);
             if args.mode.shouldnt_overwrite() {
                 flags |= sys::O::EXCL;
@@ -5858,7 +5793,6 @@ impl NodeFS {
         mode: Mode,
         return_path: bool,
     ) -> Maybe<ret::Mkdir> {
-        // PERF(port): was comptime bool — runtime branch here
         if return_path {
             self.mkdir_recursive_os_path_impl::<(), true>(&(), path, mode)
         } else {
@@ -5934,11 +5868,10 @@ impl NodeFS {
 
         // SAFETY: `NodeFS` is `#[repr(C)]` with `sync_error_buf` at offset 0 and
         // struct alignment ≥ pointer-align (from `vm`), so this address is
-        // ≥ `align_of::<OSPathChar>()`-aligned (the Rust spelling of Zig's
-        // `align(@alignOf(u16))` field annotation). On Windows
+        // ≥ `align_of::<OSPathChar>()`-aligned. On Windows
         // `OSPathBuffer = [u16; PATH_MAX_WIDE]` (65 534 B) which fits inside
         // `PathBuffer` (`MAX_PATH_BYTES` = 98 302 B); on POSIX it is the same
-        // type. The `assert!` below mirrors Zig's `@alignCast` safety check.
+        // type. The `assert!` below verifies the alignment at runtime.
         // Keep the raw `*mut PathBuffer` so error-return paths can re-derive a fresh
         // `&mut PathBuffer` without reborrowing `&mut self` (which would alias
         // `working_mem` under stacked borrows). On every such path `working_mem` is
@@ -5965,9 +5898,8 @@ impl NodeFS {
                 let parent = unsafe { OSPathSliceZ::from_raw(working_mem.as_ptr(), i as usize) };
                 match mkdir_os_path(parent, mode) {
                     Err(err) => {
-                        // PORT NOTE: Zig restores `working_mem[i] = SEP` here, *before*
-                        // the errno match, but Zig's `[:0]u16` sentinel is advisory.
-                        // Rust's `OSPathSliceZ` (`WStr`/`ZStr`) carries a hard
+                        // The SEP-restore must NOT happen before the errno match:
+                        // `OSPathSliceZ` (`WStr`/`ZStr`) carries a hard
                         // `ptr[len] == 0` invariant, and the EEXIST/`_` arms below still
                         // read `parent`. Defer the SEP-restore into each arm so `parent`
                         // is never observed with its terminator clobbered.
@@ -6157,7 +6089,6 @@ impl NodeFS {
                 return Ok(ZigString::dupe_for_js(bytes).expect("oom"));
             }
 
-            // c.getErrno(rc) returns SUCCESS if rc is -1 so we call std.c._errno() directly
             let errno = sys::last_errno();
             Err(sys::Error {
                 errno: errno as _,
@@ -6212,7 +6143,7 @@ impl NodeFS {
                 ..Default::default()
             });
         }
-        // node_fs.zig:4333 — `req.ptrAs(*align(1) bun.StatFS).*`: libuv stores
+        // libuv stores
         // a `uv_statfs_t*` in `req.ptr` on success. The struct is unaligned in
         // the request buffer, hence `read_unaligned`.
         // SAFETY: `rc >= 0` ⇒ libuv populated `req.ptr` with a valid
@@ -6231,8 +6162,7 @@ impl NodeFS {
         debug_assert!(args.position.is_none());
         // `ArrayBuffer` is a `Copy` descriptor over JSC-owned heap bytes; copy the
         // descriptor locally and use the existing safe `byte_slice_mut` accessor
-        // instead of rebuilding a `&mut [u8]` from a `&[u8]` borrow by hand
-        // (matches Zig's `args.buffer.slice()` returning `[]u8`).
+        // instead of rebuilding a `&mut [u8]` from a `&[u8]` borrow by hand.
         let mut view = args.buffer.buffer;
         let mut buf = view.byte_slice_mut();
         let off = (args.offset as usize).min(buf.len());
@@ -6430,7 +6360,7 @@ impl NodeFS {
 
     fn pwritev_inner(&mut self, args: &args::Writev) -> Maybe<ret::Write> {
         let position = args.position.unwrap();
-        // node_fs.zig:4511 — `@ptrCast(args.buffers.buffers.items)`: `PlatformIoVec`
+        // `PlatformIoVec`
         // and `PlatformIoVecConst` are layout-identical (`{ *void, usize }`); the
         // kernel never writes through `iov_base` for pwritev(2).
         // SAFETY: layout-compatible reinterpretation, asserted in `bun_sys`.
@@ -6452,8 +6382,7 @@ impl NodeFS {
     }
 
     fn writev_inner(&mut self, args: &args::Writev) -> Maybe<ret::Write> {
-        // node_fs.zig:4526 — `@ptrCast(args.buffers.buffers.items)` reinterprets
-        // the mutable iovec slice as `iovec_const` for writev(2); the kernel
+        // The mutable iovec slice doubles as `iovec_const` for writev(2); the kernel
         // never writes through `iov_base`. `PlatformIoVec` and
         // `PlatformIoVecConst` are layout-identical (`{ *void, usize }`), so
         // pass the slice through `Syscall::writev` as-is.
@@ -6466,13 +6395,11 @@ impl NodeFS {
     }
 
     pub fn readdir(&mut self, args: &args::Readdir, flavor: Flavor) -> Maybe<ret::Readdir> {
-        // PERF(port): `flavor` was comptime monomorphization — profile if hot
         if flavor != Flavor::Sync {
             if args.recursive {
                 panic!("Assertion failure: this code path should never be reached.");
             }
         }
-        // PERF(port): was comptime monomorphization on (recursive, tag)
         let maybe = match args.tag() {
             ret::ReaddirTag::Buffers => Self::readdir_inner::<Buffer>(
                 &mut self.sync_error_buf,
@@ -6510,7 +6437,6 @@ impl NodeFS {
         basename: &ZStr,
         entries: &mut Vec<T>,
     ) -> Maybe<()> {
-        // node_fs.zig:4568 — `comptime is_u16 = isWindows && (T == bun.String || T == Dirent)`.
         // On Windows, String/Dirent results read native UTF-16 entry names via the
         // wide iterator so surrogate pairs survive; Buffer results (and all POSIX)
         // use the u8 iterator.
@@ -6520,7 +6446,7 @@ impl NodeFS {
         }
 
         let mut dirent_path = BunString::DEAD;
-        // Zig `defer dirent_path.deref()` — cannot express as a scope guard in Rust
+        // `dirent_path.deref()` cannot be expressed as a scope guard
         // (the loop body needs `&mut dirent_path`); deref is idempotent on DEAD/EMPTY
         // so it is called inline on every exit path below instead.
 
@@ -6531,9 +6457,8 @@ impl NodeFS {
                     for item in entries.iter_mut() {
                         item.destroy_entry();
                     }
-                    // PORT NOTE: Zig also `entries.deinit()` here; the caller owns the
-                    // Vec in Rust, but matching the Zig contract we drain it so the
-                    // caller's `T::into_readdir` never sees freed entries.
+                    // The caller owns the Vec; drain it on error so the caller's
+                    // `T::into_readdir` never sees stale entries.
                     entries.clear();
                     dirent_path.deref();
                     return Err(err.with_path(args.path.slice()));
@@ -6567,7 +6492,7 @@ impl NodeFS {
         Ok(())
     }
 
-    /// Windows UTF-16 arm of `readdir_with_entries` (node_fs.zig:4644-4660).
+    /// Windows UTF-16 arm of `readdir_with_entries`.
     /// Only reachable when `T::IS_U16` (String/Dirent); Buffer is `IS_U16 = false`.
     #[cfg(windows)]
     fn readdir_with_entries_u16<T: ReaddirEntry>(
@@ -6580,7 +6505,7 @@ impl NodeFS {
 
         let mut iterator = DirIterator::WrappedIteratorW::init(fd);
 
-        // node_fs.zig:4578 — only allocated when the requested encoding isn't
+        // Only allocated when the requested encoding isn't
         // utf8: the wide name is transcoded to UTF-8 first (matching libuv) and
         // then re-encoded.
         let mut re_encoding_buffer = if args.encoding != Encoding::Utf8 {
@@ -6611,7 +6536,7 @@ impl NodeFS {
             }
 
             let utf16_name = current.name.slice();
-            // Spec (node_fs.zig:4649): the u16 Dirent arm uses `current.kind`
+            // The u16 Dirent arm uses `current.kind`
             // directly — no lstatat fallback (NTFS never returns DT_UNKNOWN).
             T::append_entry_w(
                 entries,
@@ -6635,9 +6560,9 @@ impl NodeFS {
         entries: &mut Vec<T>,
         is_root: bool,
     ) -> Maybe<()> {
-        // PORT NOTE: `root_path` is never mutated for the lifetime of the task, but
+        // `root_path` is never mutated for the lifetime of the task, but
         // borrowck can't see that across `async_task.enqueue(&mut self, …)`. Detach
-        // the slice via raw-pointer round-trip — same bytes Zig's `[]const u8` saw.
+        // the slice via raw-pointer round-trip.
         let root_basename: &[u8] = {
             // `root_path` is NUL-terminated (`[path.., 0]`); the basename
             // excludes the trailing NUL.
@@ -6656,7 +6581,7 @@ impl NodeFS {
         #[cfg(not(windows))]
         let open_res = Syscall::openat(atfd, basename, flags, 0);
         #[cfg(windows)]
-        // windows bun.sys.open does not pass iterable=true
+        // the plain Windows open wrapper does not pass iterable=true
         let open_res = sys::open_dir_at_windows_a(
             atfd,
             basename.as_bytes(),
@@ -6726,10 +6651,8 @@ impl NodeFS {
             };
             let utf8_name = current.name.slice();
 
-            // PORT NOTE: Zig compared `root_path.sliceAssumeZ().ptr == basename.ptr` to
-            // detect "this subtask is the root". The Rust caller passes `is_root`
-            // explicitly, which is the same predicate (root subtask's basename *is*
-            // root_path).
+            // The root subtask's basename *is* root_path; the caller passes
+            // `is_root` explicitly.
             if !is_root
                 && basename.as_bytes().len() + 1 + utf8_name.len() + 1 >= paths::MAX_PATH_BYTES
             {
@@ -6800,7 +6723,7 @@ impl NodeFS {
                     dirent_path_prev = BunString::clone_utf8(path_u8);
                 }
             }
-            // async path: spec uses raw `bun.String.cloneUTF8` (node_fs.zig:4810/4819) — do not apply encoding.
+            // async path: uses raw `BunString::clone_utf8` — do not apply encoding.
             T::append_entry_recursive(
                 entries,
                 utf8_name,
@@ -6823,14 +6746,10 @@ impl NodeFS {
         entries: &mut Vec<T>,
     ) -> Maybe<()> {
         use std::collections::VecDeque;
-        // PERF(port): Zig used `std.heap.stackFallback(128)` for the fifo and
-        // `stackFallback(8192*2)` for basename storage. Rust has no portable
-        // stack-fallback allocator; VecDeque<Vec<u8>> heap-allocates from the
+        // PERF: VecDeque<Vec<u8>> heap-allocates from the
         // first push. Revisit with `smallvec`/arena once profiled.
         let mut stack: VecDeque<Vec<u8>> = VecDeque::new();
-        // Sentinel: an item whose ptr == root_basename.ptr means "root". We
-        // can't compare `Vec<u8>` ptrs against `root_basename` the way Zig
-        // compared `[:0]const u8.ptr`, so use Option: `None` = root.
+        // Sentinel: an empty item means "root" (handled below).
         stack.push_back(Vec::new()); // empty == root marker (handled below)
         let mut first_is_root = true;
 
@@ -6844,8 +6763,7 @@ impl NodeFS {
         });
         // Re-borrow through the guard so `root_fd` stays observable at drop.
         let root_fd: &mut FD = *_close_root;
-        // PORT NOTE: Zig kept `root_fd` as a plain local and closed it in a
-        // bare `defer`. Rust's guard captures `&mut`, so all reads below go
+        // The close guard captures `&mut root_fd`, so all reads below go
         // through the same place.
 
         while let Some(item) = stack.pop_front() {
@@ -6853,11 +6771,9 @@ impl NodeFS {
             first_is_root = false;
             // basename: root_basename for the first iteration, else the queued
             // relative path (NUL-terminated by construction).
-            // PORT NOTE: Zig stored `[:0]const u8` slices and freed them via
-            // `basename_allocator`; here `item` is an owned Vec<u8> (with
-            // trailing NUL stripped below) and is dropped at end-of-loop.
-            // Exclude the trailing NUL we appended at the push site — Zig's `[:0]const u8.len`
-            // already excludes the sentinel, so `joinZBuf` there saw clean bytes.
+            // `item` is an owned Vec<u8> dropped at end-of-loop. Exclude the
+            // trailing NUL we appended at the push site so the join below sees
+            // clean bytes.
             let basename_bytes: &[u8] = if is_root {
                 root_basename.as_bytes()
             } else {
@@ -6948,8 +6864,8 @@ impl NodeFS {
                         // we know for sure it's a directory
                         sys::FileKind::Directory => {
                             if utf8_name.len() + 1 + name_to_copy.len() > paths::MAX_PATH_BYTES { break 'enqueue; }
-                            // PORT NOTE: Zig `basename_allocator.dupeZ` — store with trailing NUL
-                            // so the next iteration can hand it to `openat` as a `&ZStr`.
+                            // Store with trailing NUL so the next iteration can
+                            // hand it to `openat` as a `&ZStr`.
                             let mut owned = Vec::with_capacity(name_to_copy.len() + 1);
                             owned.extend_from_slice(name_to_copy);
                             owned.push(0);
@@ -6991,7 +6907,7 @@ impl NodeFS {
                         );
                     }
                 }
-                // sync path: spec uses `WebCore.encoding.toBunString(.., args.encoding)` (node_fs.zig:4962-4982).
+                // sync path: uses `webcore::encoding::to_bun_string(.., args.encoding)`.
                 T::append_entry_recursive(
                     entries,
                     utf8_name,
@@ -7092,7 +7008,6 @@ impl NodeFS {
     }
 
     pub fn read_file(&mut self, args: &args::ReadFile, flavor: Flavor) -> Maybe<ret::ReadFile> {
-        // PERF(port): `flavor` was comptime monomorphization — profile if hot
         let result = self.read_file_with_options(args, flavor, ReadFileStringType::Default);
         match result {
             Err(err) => Err(err),
@@ -7144,7 +7059,6 @@ impl NodeFS {
         flavor: Flavor,
         string_type: ReadFileStringType,
     ) -> Maybe<ret::ReadFileWithOptions> {
-        // PERF(port): `flavor`/`string_type` were comptime monomorphization in Zig.
         let path_is_path = matches!(args.path, PathOrFileDescriptor::Path(_));
         let fd_maybe_windows: FD = match &args.path {
             PathOrFileDescriptor::Path(p) => {
@@ -7227,12 +7141,10 @@ impl NodeFS {
         // If we manage to read the entire file, we don't need to call stat() at all.
         // This will make it slightly slower to read e.g. 512 KB files, but usually the OS won't return a full 512 KB in one read anyway.
         //
-        // Zig: `var async_stack_buffer: [if (flavor == .sync) 0 else 256*1024]u8`,
-        // and in the sync case borrows `vm.rareData().pipeReadBuffer()` (a per-VM
+        // The sync case borrows `vm.rareData().pipeReadBuffer()` (a per-VM
         // 256 KB heap slab) when a VM is present, otherwise leaves the buffer
         // zero-length so the loop is skipped and we fall through to fstat.
-        // Rust can't put 256 KB on the stack portably, so the async path
-        // heap-allocates instead — same observable behaviour.
+        // The async path heap-allocates a 256 KB buffer instead.
         let mut async_stack_buffer: Vec<u8> = if flavor == Flavor::Sync {
             Vec::new()
         } else {
@@ -7374,11 +7286,10 @@ impl NodeFS {
         if !temporary_read_buffer_before_stat_call.is_empty() {
             buf.extend_from_slice(temporary_read_buffer_before_stat_call);
         }
-        // PORT NOTE: Zig `buf.expandToCapacity()` then indexed `buf.items.ptr[total..cap]`
-        // to read into uninitialised tail. `Vec::resize(cap, 0)` is *not* equivalent in
+        // Read into the uninitialised tail. `Vec::resize(cap, 0)` is *not* equivalent in
         // debug builds: it goes through `extend_with`'s byte-by-byte loop (no memset
-        // specialisation), which dominated `readFileSync` of large files. Match the spec
-        // exactly via `VecExt::expand_to_capacity` (the tail is write-only — `Syscall::read`
+        // specialisation), which dominated `readFileSync` of large files. Use
+        // `VecExt::expand_to_capacity` (the tail is write-only — `Syscall::read`
         // hands it straight to the kernel, which only stores into it).
         use bun_collections::vec_ext::VecExt as _;
         // SAFETY: `u8` has no validity invariant; the buffer is handed straight
@@ -7386,15 +7297,13 @@ impl NodeFS {
         unsafe { buf.expand_to_capacity() };
 
         // Two-phase read: first up to `size`, then keep going until EOF.
-        // PORT NOTE: Zig spelled this as `while (total < size) { ... } else { while (true) { ... } }`.
-        // Rust has no while/else; use an explicit `phase` flag — `phase == 0` is the
-        // size-bounded loop, `phase == 1` is the unbounded tail.
+        // `phase == 0` is the size-bounded loop, `phase == 1` is the unbounded tail.
         let mut phase: u8 = if (total as u64) < size { 0 } else { 1 };
         loop {
             if args.aborted() {
                 return Err(abort_err());
             }
-            // Spec parity (node_fs.zig:5327-5377): when `total == min(buf.capacity, max_size)`
+            // When `total == min(buf.capacity, max_size)`
             // the next read receives an empty slice → returns 0 → `did_succeed = true; break`.
             // Do NOT pre-grow here; growth happens only in the `total > size && amt != 0 &&
             // !has_max_size` arm below.
@@ -7414,8 +7323,7 @@ impl NodeFS {
 
             // There are cases where stat()'s size is wrong or out of date
             if (total as u64) > size && amt != 0 && !has_max_size {
-                // Reset len to the bytes actually read (Zig:
-                // `buf.items.len = total;`). `expand_to_capacity` left
+                // Reset len to the bytes actually read. `expand_to_capacity` left
                 // `len == capacity`, so without this `try_reserve(8192)`
                 // would reallocate every read and RawVec doubling grows
                 // the buffer exponentially (a >256 KB FIFO / proc file
@@ -7442,7 +7350,7 @@ impl NodeFS {
                 phase = 1;
             }
         }
-        let _ = phase; // phase only mirrors Zig's while/else split for source parity
+        let _ = phase; // silence the unused-assignment lint on the final phase value
 
         let final_len = if string_type == ReadFileStringType::NullTerminated {
             total + 1
@@ -7464,8 +7372,7 @@ impl NodeFS {
                 }
             };
         }
-        let _ = did_succeed; // Zig used this only to gate the `defer buf.clearAndFree()`;
-        // Rust drops `buf` on every error-return above.
+        let _ = did_succeed; // `buf` is dropped on every error-return above.
 
         match args.encoding {
             Encoding::Buffer => {
@@ -7695,7 +7602,7 @@ impl NodeFS {
                     ..Default::default()
                 });
             }
-            // Zig: `req.ptrAs(?[*:0]u8)` — `fs_t.ptr` *is* the nullable C
+            // `fs_t.ptr` *is* the nullable C
             // string pointer (libuv stores the realpath result directly), so
             // `ptr_as::<c_char>()` yields the value, not a pointer-to-Option.
             // SAFETY: `rc.errno()` was None ⇒ libuv populated `req.ptr`.
@@ -7712,11 +7619,9 @@ impl NodeFS {
             if variant == RealpathVariant::Emulated {
                 // remove the trailing slash
                 //
-                // PORT NOTE: Zig (`buf[buf.len-1] = 0; buf.len -= 1;`) writes the
-                // NUL back to keep its `[:0]u8` sentinel invariant. In Rust `buf`
-                // is an immutable view and every consumer below copies by length,
-                // so we just shrink the slice — writing through `ptr.cast_mut()`
-                // while `buf` is live would be Stacked-Borrows UB.
+                // `buf` is an immutable view and every consumer below copies by
+                // length, so just shrink the slice — writing a NUL back through
+                // `ptr.cast_mut()` while `buf` is live would be Stacked-Borrows UB.
                 if buf.last() == Some(&b'\\') {
                     buf = &buf[..buf.len() - 1];
                 }
@@ -7825,9 +7730,8 @@ impl NodeFS {
 
     pub fn rmdir(&mut self, args: &args::RmDir, _: Flavor) -> Maybe<ret::Rmdir> {
         if args.recursive {
-            // Zig passed args.path.slice() to std.fs.Dir.openDir/deleteFile/deleteDir,
-            // which on Windows resolve a rooted-but-driveless path ("/tmp/foo")
-            // against the cwd drive via wToPrefixedFileW → RtlGetFullPathName_U.
+            // On Windows a rooted-but-driveless path ("/tmp/foo") must resolve
+            // against the cwd drive.
             // Our dt_* helpers go through Syscall::*at → to_nt_path /
             // normalize_path_windows, which do NOT add the cwd drive, turning
             // "/tmp/foo" into a nonexistent NT name (ENOENT). Pre-resolve with
@@ -7870,7 +7774,7 @@ impl NodeFS {
             // See the matching comment in `rmdir`: pre-resolve the path on
             // Windows so rooted-but-driveless paths ("/tmp/foo") get the cwd
             // drive prepended before reaching the dt_* / Syscall::*at helpers,
-            // which (unlike Zig's std.fs.Dir.*) do not do that themselves.
+            // which do not do that themselves.
             #[cfg(windows)]
             let resolved = args.path.slice_z(&mut self.sync_error_buf).as_bytes();
             #[cfg(not(windows))]
@@ -7890,9 +7794,8 @@ impl NodeFS {
         }
 
         let dest = args.path.slice_z(&mut self.sync_error_buf);
-        // PORT NOTE: Zig used `std.posix.unlinkZ/rmdirZ` (which return Zig error
-        // sets) and then mapped that error set through a *narrow* table to an
-        // errno, defaulting to `EFAULT`. The Rust port goes straight to
+        // The original implementation mapped the unlink/rmdir error through a
+        // *narrow* table to an errno, defaulting to `EFAULT`. We go straight to
         // `bun_sys::unlink`/`libc::rmdir` (raw errno), so route the result
         // through `map_rm_errno_narrow` to preserve the EFAULT fallthrough
         // (e.g. `EISDIR` with `recursive=false` must surface as `EFAULT`).
@@ -7900,9 +7803,9 @@ impl NodeFS {
             let e1 = err1.get_errno();
             // empirically, it seems to return AccessDenied when the
             // file is actually a directory on macOS.
-            // PORT NOTE: Zig checks `error.IsDir|NotDir|AccessDenied`; the
-            // vendored std.posix.unlinkZ maps `.PERM => PermissionDenied`
-            // (not AccessDenied), so raw EPERM is *not* in this set.
+            // Matches the original `IsDir|NotDir|AccessDenied` set; EPERM mapped
+            // to PermissionDenied (not AccessDenied) there, so raw EPERM is
+            // intentionally *not* in this set.
             if args.recursive && matches!(e1, E::EISDIR | E::ENOTDIR | E::EACCES) {
                 if let Some(Err(err2)) = Maybe::<()>::errno_sys_p(
                     // SAFETY: `dest` is NUL-terminated by `slice_z`; rmdir(2) is the libc FFI.
@@ -7979,7 +7882,6 @@ impl NodeFS {
         let mut to_buf = PathBuffer::uninit();
         #[cfg(windows)]
         {
-            // node_fs.zig:5943-6014.
             const UV_FS_SYMLINK_DIR: c_int = 0x0001;
             const UV_FS_SYMLINK_JUNCTION: c_int = 0x0002;
             #[derive(Clone, Copy, PartialEq, Eq)]
@@ -8091,8 +7993,8 @@ impl NodeFS {
     }
 
     fn truncate_inner(&mut self, path: &PathLike, len: u64, flags: i32) -> Maybe<ret::Truncate> {
-        // Zig stores `len` as `u63` so the `i64` cast is always in range; mask to
-        // the same `u63` envelope here rather than `try_from().unwrap()`-panicking
+        // Mask `len` to a `u63` envelope so the `i64` cast is always in range,
+        // rather than `try_from().unwrap()`-panicking
         // on a hostile `> i64::MAX` value.
         let len_i64 = (len & ((1u64 << 63) - 1)) as i64;
         #[cfg(windows)]
@@ -8137,7 +8039,7 @@ impl NodeFS {
 
     pub fn truncate(&mut self, args: &args::Truncate, _: Flavor) -> Maybe<ret::Truncate> {
         match &args.path {
-            // Zig: `args.len` is `u63`; mask off the top bit so the i64 cast can't panic.
+            // Mask off the top bit so the i64 cast can't panic.
             PathOrFileDescriptor::Fd(fd) => {
                 Syscall::ftruncate(*fd, (args.len & ((1u64 << 63) - 1)) as i64)
             }
@@ -8278,8 +8180,7 @@ impl NodeFS {
         match args.create_fs_watcher() {
             // SAFETY: `create_fs_watcher` returns a freshly-heap-allocated
             // `*mut FSWatcher` whose ownership is held by the JS wrapper
-            // (`js_this`); reading `js_this` here mirrors Zig's
-            // `result.js_this` field access on the by-value return.
+            // (`js_this`); only `js_this` is read here.
             Ok(result) => Ok(unsafe { (*result).js_this() }),
             Err(err) => Err(err),
         }
@@ -8345,10 +8246,9 @@ impl NodeFS {
         }
         #[cfg(not(windows))]
         {
-            // PORT NOTE: Zig has no POSIX arm here — every call site is inside
-            // an `if (Environment.isWindows)` branch. On POSIX `OSPathChar == u8`,
-            // so the input is already the canonical byte slice; tie both inputs
-            // to the same `'a` so the borrow checker accepts the passthrough.
+            // On POSIX `OSPathChar == u8`, so the input is already the canonical
+            // byte slice; tie both inputs to the same `'a` so the borrow checker
+            // accepts the passthrough.
             let _ = &mut self.sync_error_buf;
             slice
         }
@@ -8455,8 +8355,7 @@ impl NodeFS {
                         if matches!(err.get_errno(), E::EACCES | E::EPERM) && args.flags.force {
                             break 'try_with_clonefile;
                         }
-                        // Zig copies `src` into `sync_error_buf` and `.withPath()`s it so
-                        // the borrowed slice outlives `src_buf`. `errno_sys_p` already boxed
+                        // `errno_sys_p` already boxed
                         // `src.as_bytes()` into the inner `Error::path`, so just propagate.
                         return err;
                     }
@@ -8480,9 +8379,8 @@ impl NodeFS {
             Ok(_) => {}
         }
 
-        // PORT NOTE: Zig used `.u16` iterator on Windows so `name.slice()` is `[]u16`.
         // The OSPathBuffer copy below is generic over `OSPathChar`, so on Windows
-        // this needs the wide iterator; the u8 path is correct for POSIX.
+        // this needs the wide (u16) iterator; the u8 path is correct for POSIX.
         #[cfg(windows)]
         let mut iterator = DirIterator::WrappedIteratorW::init(fd);
         #[cfg(not(windows))]
@@ -8596,9 +8494,9 @@ impl NodeFS {
 
     fn _cp_symlink(&mut self, src: &ZStr, dest: &ZStr) -> Maybe<ret::CopyFile> {
         let mut target_buf = PathBuffer::uninit();
-        // PORT NOTE: `bun_sys::readlink` returns the byte length on every
+        // `bun_sys::readlink` returns the byte length on every
         // platform (the `Syscall` alias = `sys_uv` on Windows would return the
-        // slice itself); reconstruct the `[:0]const u8` view from `target_buf`.
+        // slice itself); reconstruct the NUL-terminated view from `target_buf`.
         let link_len = match sys::readlink(src, &mut target_buf[..]) {
             Ok(result) => result,
             Err(err) => {
@@ -9031,8 +8929,7 @@ impl NodeFS {
 
             let size: usize = stat_.st_size.max(0) as usize;
 
-            // FreeBSD 13+ has copy_file_range(2). std.c declares it returning
-            // usize on FreeBSD, so bitcast to isize before getErrno.
+            // FreeBSD 13+ has copy_file_range(2).
             let mut off_in: i64 = 0;
             let mut off_out: i64 = 0;
             'cfr: loop {
@@ -9087,10 +8984,8 @@ impl NodeFS {
             if mode.is_force_clone() {
                 // Windows has no copy-on-write `clonefile` equivalent surfaced
                 // here; `COPYFILE_FICLONE_FORCE` must fail rather than silently
-                // fall back to a non-CoW `CopyFileW`. NOTE: the Zig Windows
-                // block (node_fs.zig:6836+) has no such guard and falls through
-                // to `CopyFileW`; this is an intentional divergence to match
-                // Node.js' documented FICLONE_FORCE contract and the
+                // fall back to a non-CoW `CopyFileW`, per
+                // Node.js' documented FICLONE_FORCE contract and matching the
                 // Linux/FreeBSD arms above. Return a concrete ENOSYS rather
                 // than `Maybe::todo()` so debug builds do not panic.
                 return Err(sys::Error {
@@ -9099,7 +8994,7 @@ impl NodeFS {
                     ..Default::default()
                 });
             }
-            // Spec (node_fs.zig:6837-6838) precomputes both ENOENT fallbacks once,
+            // Precompute both ENOENT fallbacks once,
             // before any branch. Re-deriving them inline inside `unwrap_or_else`
             // double-borrows `&mut self` (the outer `errno_sys_p` arg already holds
             // a borrow into `sync_error_buf`).
@@ -9139,8 +9034,8 @@ impl NodeFS {
                     )
                 } == 0
                 {
-                    // Zig `windows.GetLastError()` returns the `Win32Error`
-                    // enum, not the raw DWORD — use the typed wrapper so the
+                    // `Win32Error::get()` returns the typed
+                    // enum, not the raw DWORD, so the
                     // associated-const match arms type-check.
                     let mut err = windows::Win32Error::get();
                     match err {
@@ -9221,7 +9116,7 @@ impl NodeFS {
     }
 
     /// Shared `dest_fd:` block from the mac/linux/freebsd branches of
-    /// `_copySingleFileSync` (node_fs.zig:6528-6555 / 6624-6651 / 6770-6794).
+    /// `_copy_single_file_sync`.
     /// Tries `open(dest, flags, default_permission)`; on ENOENT creates the
     /// parent directory and retries once. Any other error is annotated with
     /// `dest` copied into `sync_error_buf`.
@@ -9288,9 +9183,7 @@ impl NodeFS {
     /// Const-generic dispatch from `NodeFSFunctionEnum` to the matching
     /// `NodeFS::<method>`.
     ///
-    /// PORT NOTE: Zig spells this `@field(NodeFS, @tagName(FunctionEnum))(self,
-    /// args, .async)`. Rust has no field-by-string reflection, so the
-    /// `(R, A, F)` triple is bound by [`NodeFSDispatch`] impls (one per
+    /// The `(R, A, F)` triple is bound by [`NodeFSDispatch`] impls (one per
     /// `NodeFSFunctionEnum` variant); the `where Op<{F}>: NodeFSDispatch<R, A>`
     /// bound proves `R == ret::*` / `A == args::*` for this `F` so no identity
     /// cast is needed.
@@ -9317,7 +9210,7 @@ impl NodeFS {
 
     /// Variant of [`Self::uv_dispatch`] for `uv_callbackreq` — passes the live
     /// `uv::fs_t` through so the handler can read `req.ptr` (only `statfs`
-    /// needs it; node_fs.zig:276-288).
+    /// needs it).
     #[cfg(windows)]
     #[inline]
     pub fn uv_dispatch_req<R, A, const F: NodeFSFunctionEnum>(
@@ -9435,9 +9328,6 @@ pub enum RealpathVariant {
     Emulated,
 }
 
-// PORT NOTE: was `pub enum StringType` inside `impl NodeFS` (Zig allowed
-// nested type decls in struct bodies). Hoisted out — Rust forbids enums in
-// inherent impls.
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum ReadFileStringType {
     Default,
@@ -9452,12 +9342,9 @@ impl MkdirCtx for () {}
 
 /// Trait abstracting over the three readdir entry types.
 ///
-/// PORT NOTE: Zig dispatched on `comptime ExpectedType` inside the loop body
-/// (`switch (ExpectedType) { Dirent => …, Buffer => …, bun.String => … }`).
 /// Rust can't switch on a generic `T` at runtime, so the per-type append
-/// logic is moved onto this trait. `IS_DIRENT` mirrors the
-/// `ExpectedType == jsc.Node.Dirent` predicate so the caller knows whether
-/// it must compute/maintain `dirent_path`.
+/// logic (Dirent / Buffer / String) lives on this trait. `IS_DIRENT` tells
+/// the caller whether it must compute/maintain `dirent_path`.
 pub trait ReaddirEntry: Sized {
     /// `ExpectedType == jsc.Node.Dirent` — whether the caller needs to track
     /// a cached `dirent_path` BunString.
@@ -9466,7 +9353,7 @@ pub trait ReaddirEntry: Sized {
     /// UTF-16 `DirIterator` arm on Windows (`readdir_with_entries` only).
     const IS_U16: bool;
     fn destroy_entry(&mut self);
-    /// Windows-only: append from a UTF-16 directory entry name (node_fs.zig:4644-4660).
+    /// Windows-only: append from a UTF-16 directory entry name.
     /// Non-recursive readdir; `re_encoding_buffer` is the pooled scratch for
     /// `strings::from_w_path` when `encoding != utf8`. Only ever invoked when
     /// `IS_U16` is true — `Buffer`'s impl is a `@compileError`-equivalent
@@ -9491,10 +9378,10 @@ pub trait ReaddirEntry: Sized {
     );
     /// Recursive readdir: `utf8_name` is the bare entry name, `name_to_copy`
     /// is the path *relative to the recursion root* (what Node returns).
-    /// `apply_encoding` distinguishes the sync path (node_fs.zig:4962-4982,
-    /// which honours `args.encoding` via `WebCore.encoding.toBunString`) from
-    /// the async path (node_fs.zig:4800-4821, which uses raw
-    /// `bun.String.cloneUTF8` and ignores the requested encoding).
+    /// `apply_encoding` distinguishes the sync path (which honours
+    /// `args.encoding` via `webcore::encoding::to_bun_string`) from
+    /// the async path (which uses raw
+    /// `BunString::clone_utf8` and ignores the requested encoding).
     fn append_entry_recursive(
         entries: &mut Vec<Self>,
         utf8_name: &[u8],
@@ -9531,7 +9418,6 @@ impl ReaddirEntry for BunString {
         encoding: Encoding,
         re_encoding_buffer: Option<&mut PathBuffer>,
     ) {
-        // node_fs.zig:4655-4662
         match encoding {
             Encoding::Buffer => unreachable!(),
             // in node.js, libuv converts to utf8 before node.js converts those bytes into other stuff
@@ -9591,7 +9477,7 @@ impl ReaddirEntry for Dirent {
         _encoding: Encoding,
         _re_encoding_buffer: Option<&mut PathBuffer>,
     ) {
-        // node_fs.zig:4648-4654 — Windows Dirent always clones the raw UTF-16
+        // Windows Dirent always clones the raw UTF-16
         // name (no re-encoding) and skips the lstatat() DT_UNKNOWN fallback.
         entries.push(Dirent {
             name: BunString::clone_utf16(utf16_name),
@@ -9645,7 +9531,7 @@ impl ReaddirEntry for Buffer {
         _: Encoding,
         _: Option<&mut PathBuffer>,
     ) {
-        // node_fs.zig:4660 `else => @compileError("unreachable")` — Buffer never
+        // Buffer never
         // takes the u16 iterator (`IS_U16 = false`); the call site is gated on
         // `T::IS_U16` so this arm is statically dead.
         unreachable!()
@@ -9663,9 +9549,8 @@ impl ReaddirEntry for Buffer {
     }
 }
 
-// The Zig source has three distinct error→errno tables for rmdir-recursive
-// (node_fs.zig:5757-5788), rm-recursive (node_fs.zig:5789-5824), and rm
-// non-recursive unlinkZ/rmdirZ (node_fs.zig:5842-5887). An earlier draft
+// There are three distinct error→errno tables: rmdir-recursive,
+// rm-recursive, and rm non-recursive unlink/rmdir. An earlier draft
 // collapsed them into one, which silently mapped AccessDenied→EPERM for `rm`
 // (Node returns EACCES there) and widened the narrow table. Split back out
 // per call site.
@@ -9689,8 +9574,8 @@ fn map_anyerror_to_errno(err: bun_core::Error) -> E {
     }
 }
 
-// `rm` recursive (zigDeleteTree) — same shape as the rmdir table above except
-// AccessDenied maps to EACCES, not EPERM (node_fs.zig:5789-5824).
+// `rm` recursive (zig_delete_tree) — same shape as the rmdir table above except
+// AccessDenied maps to EACCES, not EPERM.
 fn map_anyerror_to_errno_rm_tree(err: bun_core::Error) -> E {
     match err.name() {
         "AccessDenied" => E::EACCES,
@@ -9711,16 +9596,11 @@ fn map_anyerror_to_errno_rm_tree(err: bun_core::Error) -> E {
     }
 }
 
-// `rm` non-recursive unlinkZ/rmdirZ fallback — narrower table; anything not
-// listed here falls through to EFAULT (node_fs.zig:5842-5859 / 5870-5887).
+// `rm` non-recursive unlink/rmdir fallback — narrower table; anything not
+// listed here falls through to EFAULT.
 //
-// The Rust port calls `bun_sys::unlink`/`libc::rmdir` which yield a raw errno
-// rather than a Zig error name, so this composes `std.posix.unlinkZ`'s
-// errno→error map with the Zig switch above. Notably the vendored stdlib maps
-// `.PERM => error.PermissionDenied` (NOT `error.AccessDenied`), and
-// `PermissionDenied` is absent from the narrow Zig switch, so raw EPERM —
-// like EISDIR/ENOTDIR/ENOTEMPTY — falls through to EFAULT here to match the
-// composed Zig behavior bit-for-bit.
+// `bun_sys::unlink`/`libc::rmdir` yield a raw errno. Notably raw EPERM —
+// like EISDIR/ENOTDIR/ENOTEMPTY — intentionally falls through to EFAULT here.
 fn map_rm_errno_narrow(e: E) -> E {
     match e {
         E::EACCES => E::EACCES,
@@ -9751,23 +9631,21 @@ pub unsafe extern "C" fn Bun__mkdirp(global_this: &JSGlobalObject, path: *const
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// zigDeleteTree — copied from std.fs.Dir.deleteTree. Returns `FileNotFound`
+// zig_delete_tree — recursive delete-tree. Returns `FileNotFound`
 // instead of ignoring it, which is required to match the behavior of Node.js's
 // `fs.rm` { recursive: true, force: false }.
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: the Zig original is a near-verbatim copy of `std.fs.Dir.deleteTree`
-// operating on `std.fs.Dir` and Zig's named error sets. PORTING.md bans `std::fs`,
-// so this re-implements the same algorithm on top of `bun_sys` primitives
-// (`openat` + `unlinkat`) and *errno* values, then maps the errno back to the
-// Zig-error-set name strings the callers' `map_anyerror_to_errno*` tables expect.
-// The structure (16-slot stack, treat_as_dir flip-flop, close-then-deleteDir,
-// retry-on-DirNotEmpty) is preserved exactly.
+// Implemented on top of
+// `bun_sys` primitives (`openat` + `unlinkat`) and *errno* values, mapping the
+// errno back to the error-set name strings the callers'
+// `map_anyerror_to_errno*` tables expect. The structure: 16-slot stack,
+// treat_as_dir flip-flop, close-then-deleteDir, retry-on-DirNotEmpty.
 
 #[inline]
 fn dt_err(errno: E) -> bun_core::Error {
     // Reverse of the `map_anyerror_to_errno*` tables above — round-trip through
-    // the Zig error-set name so existing callers don't have to change.
+    // the error-set name so existing callers don't have to change.
     err_from_static(match errno {
         E::ENOENT => "FileNotFound",
         E::EACCES => "AccessDenied",
@@ -9821,7 +9699,7 @@ fn dt_delete_file(parent: &sys::Dir, name: &[u8]) -> Result<(), E> {
         Ok(()) => Ok(()),
         Err(e) => {
             let errno = e.get_errno();
-            // Mirror `std.fs.Dir.deleteFileZ`: non-Linux POSIX (macOS/BSD) returns
+            // Non-Linux POSIX (macOS/BSD) returns
             // a *permission* error (EPERM, occasionally EACCES) from `unlinkat(2)`
             // without `AT_REMOVEDIR` when the target is a directory — Linux returns
             // EISDIR directly. Stat to disambiguate so the recursive-rm dir fallback
@@ -9836,10 +9714,8 @@ fn dt_delete_file(parent: &sys::Dir, name: &[u8]) -> Result<(), E> {
                 target_os = "dragonfly",
             ))]
             if matches!(errno, E::EPERM | E::EACCES) {
-                // No-follow stat — exactly `std.fs.Dir.deleteFileZ`'s
-                // `fstatatZ(self.fd, sub_path_c, posix.AT.SYMLINK_NOFOLLOW)`
-                // ("don't follow symlinks to match unlinkat"). `z` (a `&ZStr`,
-                // `Copy`) is still valid — `unlinkat` only borrowed it.
+                // No-follow stat — don't follow symlinks, to match unlinkat.
+                // `z` (a `&ZStr`, `Copy`) is still valid — `unlinkat` only borrowed it.
                 if let Ok(st) = Syscall::lstatat(parent.fd, z) {
                     if sys::S::ISDIR(st.st_mode as u32) {
                         return Err(E::EISDIR);
@@ -9892,9 +9768,9 @@ pub fn zig_delete_tree(
             None => return Ok(()),
         };
 
-    // PERF(port): Zig used a fixed `[16]StackItem` array + `initBuffer`. Rust's
-    // Vec gives the same cap behaviour (`unusedCapacitySlice().len >= 1`) when
-    // pre-reserved to 16, with the bonus that the iterator buffers (8 KB each)
+    // PERF: a Vec
+    // pre-reserved to 16 caps the depth the same way a fixed array would,
+    // with the bonus that the iterator buffers (8 KB each)
     // live on the heap instead of the stack.
     let mut stack: Vec<DeleteTreeStackItem> = Vec::with_capacity(16);
     let close_all = |stack: &mut Vec<DeleteTreeStackItem>| {
@@ -9921,11 +9797,10 @@ pub fn zig_delete_tree(
                 Ok(None) => break,
                 Err(err) => return Err(dt_err(err.get_errno())),
             };
-            // PORT NOTE: `entry.name` borrows the iterator's internal buffer and
-            // is invalidated by the next `next()` call. We copy it once here so
+            // `entry.name` borrows the iterator's internal buffer and
+            // is invalidated by the next `next()` call. Copy it once here so
             // it survives both the push-onto-stack and the deleteDir-after-close
-            // paths — Zig got away with a borrow because its `StackItem.name`
-            // pointed straight into the parent iterator's still-live buffer.
+            // paths.
             let entry_name: Vec<u8> = entry.name.slice().to_vec();
             let mut treat_as_dir = entry.kind == sys::FileKind::Directory;
             'handle_entry: loop {
@@ -9967,10 +9842,10 @@ pub fn zig_delete_tree(
                             treat_as_dir = true;
                             continue 'handle_entry;
                         }
-                        // PORT NOTE: Zig's std.fs error set distinguishes IsDir
-                        // from "EPERM because it's a directory" (Linux returns
-                        // EISDIR; macOS returns EPERM). We only get errno, so
-                        // forward EPERM as PermissionDenied — caller maps it.
+                        // "EPERM because it's a directory" is OS-dependent
+                        // (Linux returns EISDIR; macOS returns EPERM). We only
+                        // get errno, so forward EPERM as PermissionDenied —
+                        // caller maps it.
                         Err(e) => return Err(dt_err(e)),
                     }
                 }
@@ -9997,8 +9872,8 @@ pub fn zig_delete_tree(
             Ok(()) => {}
             Err(E::ENOENT) => {}
             Err(E::ENOTEMPTY) => need_to_retry = true,
-            // PORT NOTE: Zig also matched `error.EXIST` → DirNotEmpty here via
-            // std.fs's deleteDir; mirror that for OSes that report EEXIST.
+            // Some OSes report EEXIST instead of ENOTEMPTY for a non-empty
+            // directory; treat it the same.
             Err(E::EEXIST) => need_to_retry = true,
             Err(e) => return Err(dt_err(e)),
         }
@@ -10032,7 +9907,7 @@ pub fn zig_delete_tree(
                         Err(E::ENOTDIR) => {
                             #[cfg(debug_assertions)]
                             unreachable!();
-                            // Zig: `else => return error.Unexpected` → caller's `else =>` arm = EFAULT.
+                            // "Unexpected" → caller's fallthrough arm = EFAULT.
                             #[cfg(not(debug_assertions))]
                             return Err(err_from_static("Unexpected"));
                         }
@@ -10065,9 +9940,9 @@ fn zig_delete_tree_open_initial_subpath(
         if treat_as_dir {
             return match dt_open_dir(self_, sub_path) {
                 Ok(d) => Ok(Some(d)),
-                // PORT NOTE: Zig surfaced NotDir/FileNotFound here (no fall-
-                // through to deleteFile) — that's the deliberate divergence
-                // from std.fs.Dir.deleteTree this copy exists for.
+                // NotDir/FileNotFound surface here (no fall-through to
+                // deleteFile) — deliberate, so `FileNotFound` propagates
+                // (see the zig_delete_tree banner above).
                 Err(e) => Err(dt_err(e)),
             };
         } else {
@@ -10101,10 +9976,9 @@ fn zig_delete_tree_min_stack_size_with_kind_hint(
         let mut dir_name_buf = PathBuffer::uninit();
         let mut dir_name_len = sub_path.len().min(dir_name_buf.len());
         dir_name_buf[..dir_name_len].copy_from_slice(&sub_path[..dir_name_len]);
-        // PORT NOTE: Zig kept `dir_name: []const u8` aliasing either `sub_path`
-        // or `dir_name_buf`. Rust's borrow checker won't let that alias survive
-        // the `@memcpy` reassignment below, so track `(is_sub_path, len)` and
-        // re-slice on each use.
+        // `dir_name` conceptually aliases either `sub_path` or `dir_name_buf`;
+        // the borrow checker won't let that alias survive the copy/reassignment
+        // below, so track `(is_sub_path, len)` and re-slice on each use.
         let mut dir_name_is_sub_path = true;
 
         // Here we must avoid recursion, in order to provide O(1) memory guarantee of this function.
@@ -10153,7 +10027,7 @@ fn zig_delete_tree_min_stack_size_with_kind_hint(
                             Err(E::ENOTDIR) => {
                                 #[cfg(debug_assertions)]
                                 unreachable!();
-                                // Zig: `else => return error.Unexpected` → caller's `else =>` arm = EFAULT.
+                                // "Unexpected" → caller's fallthrough arm = EFAULT.
                                 #[cfg(not(debug_assertions))]
                                 break 'scan_dir Err(err_from_static("Unexpected"));
                             }
@@ -10194,7 +10068,7 @@ fn zig_delete_tree_min_stack_size_with_kind_hint(
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// NodeFSFunctionEnum — std.meta.DeclEnum(NodeFS)
+// NodeFSFunctionEnum — one variant per NodeFS method
 // ──────────────────────────────────────────────────────────────────────────
 #[derive(Copy, Clone, PartialEq, Eq, core::marker::ConstParamTy)]
 pub enum NodeFSFunctionEnum {
@@ -10242,10 +10116,8 @@ pub enum NodeFSFunctionEnum {
 }
 
 impl NodeFSFunctionEnum {
-    /// Maps each async-FS function to its event-loop [`TaskTag`]. The Zig
-    /// source did this via comptime `@typeName` lookup against the
-    /// `Task.Tag.@"NameOfTask"` table; Rust spells it out (the `tags!` macro
-    /// in `bun_event_loop::task_tag` declares one constant per variant).
+    /// Maps each async-FS function to its event-loop [`TaskTag`] (the `tags!`
+    /// macro in `bun_event_loop::task_tag` declares one constant per variant).
     pub const fn task_tag(self) -> bun_event_loop::TaskTag {
         use bun_event_loop::task_tag;
         match self {
@@ -10293,9 +10165,8 @@ impl NodeFSFunctionEnum {
         }
     }
 
-    /// `"Async" ++ typeBaseName(ArgumentType) ++ "Task"` — Zig built this via
-    /// comptime string concat on `@typeName(ArgumentType)`. Rust has no
-    /// `type_name::<T>()` in `const`, so key off the `F` discriminant instead
+    /// Heap label `"Async<Name>Task"`. Rust has no
+    /// `type_name::<T>()` in `const`, so key off the `F` discriminant
     /// (each `F` is bound to exactly one `args::*` type via `async_::*`).
     pub const fn heap_label(self) -> &'static str {
         macro_rules! lbl { ($($v:ident),+ $(,)?) => { match self { $(Self::$v => concat!("Async", stringify!($v), "Task"),)+ } } }
@@ -10357,18 +10228,15 @@ impl NodeFSFunctionEnum {
     }
 }
 
-/// `i52` — Zig's odd-width integer used for `ReadPosition` coercion bounds and
-/// `JSValue.to(i52)` (JSValue.zig:199).
+/// `i52` — 52-bit integer used for `ReadPosition` coercion bounds.
 #[allow(non_camel_case_types)]
 struct i52;
 impl i52 {
     const MIN: i64 = -(1i64 << 51);
-    /// `JSValue.to(i52)` — `@truncate(@intCast(toInt64()))`. Truncate to the low
-    /// 52 bits and sign-extend bit 51 (matches Zig `@truncate` semantics).
+    /// Truncate to the low
+    /// 52 bits and sign-extend bit 51.
     #[inline]
     fn from_js(v: JSValue) -> i64 {
         (v.to_int64() << 12) >> 12
     }
 }
-
-// ported from: src/runtime/node/node_fs.zig
diff --git a/src/runtime/node/node_fs_binding.rs b/src/runtime/node/node_fs_binding.rs
index 9ac966dfe86..132a9363951 100644
--- a/src/runtime/node/node_fs_binding.rs
+++ b/src/runtime/node/node_fs_binding.rs
@@ -14,19 +14,13 @@ use crate::node::fs::{
 pub(crate) type NodeFSFunction =
     fn(this: &Binding, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue>;
 
-// Zig: `const NodeFSFunctionEnum = std.meta.DeclEnum(node.fs.NodeFS);`
-// PORT NOTE: Rust has no `DeclEnum`/`@field`/`@typeInfo` reflection. The
-// (`args::*`, `ret::*`, `NodeFS::<method>`, `async_::*`) quadruples that the
-// Zig comptime block reflected per `function_name` are spelled out once in
-// `node_fs.rs` (the `NodeFS::dispatch` table + `async_::*` aliases) and reused
-// here via the `node_fs_bindings!` macro at the bottom of this file.
+// The (`args::*`, `ret::*`, `NodeFS::<method>`, `async_::*`) quadruples are
+// spelled out once in `node_fs.rs` (the `NodeFS::dispatch` table +
+// `async_::*` aliases) and reused here via the `node_fs_bindings!` macro at
+// the bottom of this file.
 
 /// Returns bindings to call jsc.Node.fs.NodeFS.<function>.
 /// Async calls use a thread pool.
-// Zig: `fn Bindings(comptime function_name) type { return struct { runSync, runAsync } }`
-// PORT NOTE: collapsed to two free generic fns; the `comptime function_name`
-// becomes a `const F: NodeFSFunctionEnum`, and the reflected `Arguments` /
-// return type become `A: FsArgument` / `R: FsReturn`.
 
 /// `Bindings(FunctionEnum).runSync`.
 fn run_sync<R: FsReturn, A: FsArgument, const F: NodeFSFunctionEnum>(
@@ -82,9 +76,8 @@ fn run_async<A: FsArgument>(
     let mut slice = ManuallyDrop::new(ArgumentsSlice::init(vm, frame.arguments()));
     slice.will_be_async = true;
 
-    // Zig uses a `deinit: bool` flag + conditional `defer` to keep `slice`
-    // alive past return when ownership transfers to the Task. The Rust port
-    // mirrors this with `ManuallyDrop`: dropped only on the early-return
+    // `ManuallyDrop` keeps `slice` alive past return when ownership transfers
+    // to the Task: dropped only on the early-return
     // error/abort branches; on the success path the Task owns `args` (whose
     // protected JSValues are released by `Drop for ThreadSafe<A>` when the
     // Task completes), and `slice` is intentionally not dropped — its
@@ -124,8 +117,8 @@ fn run_async<A: FsArgument>(
         }
     }
 
-    // `switch (comptime function_name) { else => {} }` — the `.cp` /
-    // `.readdir` arms are handled by their dedicated bindings below.
+    // The `cp` / `readdir` operations are handled by their dedicated
+    // bindings below.
     // SAFETY: re-borrow `vm` mutably; the `slice` borrow is no longer used.
     let vm: &mut VirtualMachine = global.bun_vm().as_mut();
     Ok(create_task(global, this, args, vm))
@@ -188,9 +181,8 @@ impl Binding {
 
     // ── Hand-written bindings for ops outside `NodeFSFunctionEnum` ────────
 
-    /// `callAsync(.cp)` — `.cp`'s `Task.create` (Zig) takes the parser arena as
-    /// a 5th arg. The Rust `AsyncCpTask::create` copies its paths via
-    /// `to_thread_safe()` instead, so the arena is dropped with `slice`.
+    /// `callAsync(.cp)` — `AsyncCpTask::create` copies its paths via
+    /// `to_thread_safe()`, so the arena is dropped with `slice`.
     pub fn cp(this: &Self, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         // SAFETY: JS-thread borrow of the per-thread VM; outlives `slice`.
         let vm: &mut VirtualMachine = global.bun_vm().as_mut();
@@ -343,9 +335,8 @@ impl Binding {
     }
 }
 
-/// Generates the `pub const <name> = call{Async,Sync}(.<fn>)` block from the
-/// Zig. Each row supplies the `(args, ret, NodeFSFunctionEnum)` triple that the
-/// Zig comptime reflection derived from `@typeInfo(NodeFS.<fn>)`.
+/// Generates the `pub const <name> = call{Async,Sync}(.<fn>)` block.
+/// Each row supplies the `(args, ret, NodeFSFunctionEnum)` triple for one op.
 macro_rules! node_fs_bindings {
     ( $( $sync:ident / $async_:ident => $F:ident, $Args:ty, $Ret:ty ; )* ) => {
         impl Binding {
@@ -461,5 +452,3 @@ pub(crate) fn create_memfd_for_testing(
         }
     }
 }
-
-// ported from: src/runtime/node/node_fs_binding.zig
diff --git a/src/runtime/node/node_fs_constant.rs b/src/runtime/node/node_fs_constant.rs
index 36c988f5c30..4cb072256d8 100644
--- a/src/runtime/node/node_fs_constant.rs
+++ b/src/runtime/node/node_fs_constant.rs
@@ -1,11 +1,5 @@
 use bun_sys::{O, posix};
 
-// PORT NOTE: the Zig `get(comptime name)` helper used `@hasDecl(bun.O, name)` +
-// `@field(bun.O, name)` to look up an open-flag by string at comptime, with a
-// `@compileError` fallback. Rust has no struct-field reflection; since every
-// call site names a constant that exists on `bun_sys::O`, we reference those
-// constants directly below and drop the helper.
-
 /// Constant for fs.access(). File can be read by the calling process.
 pub const R_OK: i32 = posix::R_OK;
 /// Constant for fs.access(). File can be written by the calling process.
@@ -14,14 +8,12 @@ pub const W_OK: i32 = posix::W_OK;
 pub const X_OK: i32 = posix::X_OK;
 
 // File Copy Constants
-// PORT NOTE: Zig `enum(i32) { _ }` (non-exhaustive, no variants) is a newtype
-// over i32 with associated decls — modelled here as a transparent tuple struct.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Copyfile(pub i32);
 
 impl Copyfile {
-    /// Zig: `@enumFromInt(raw)` — wrap a raw flags value.
+    /// Wrap a raw flags value.
     #[inline]
     pub(crate) const fn from_raw(raw: i32) -> Self {
         Self(raw)
@@ -97,7 +89,6 @@ pub const S_IROTH: i32 = posix::S::IROTH as i32;
 /// Constant for fs.Stats mode property for determining access permissions for a file. File mode indicating executable by others.
 pub const S_IXOTH: i32 = posix::S::IXOTH as i32;
 
-// TODO(port): verify constant types — Zig left these as comptime_int / inherited
-// from bun.O / std.posix.S; align with bun_sys's actual repr (u32 vs i32).
-
-// ported from: src/runtime/node/node_fs_constant.zig
+// Repr check: `posix::R_OK/W_OK/X_OK` are `c_int` and `O::*` are `i32` in
+// bun_sys, used directly; `posix::S::*` is `Mode = u32` whose values are all
+// ≤ 0o170000, so the `as i32` casts above are lossless.
diff --git a/src/runtime/node/node_fs_stat_watcher.rs b/src/runtime/node/node_fs_stat_watcher.rs
index b5abd6f93c0..c0cb7885dbe 100644
--- a/src/runtime/node/node_fs_stat_watcher.rs
+++ b/src/runtime/node/node_fs_stat_watcher.rs
@@ -76,8 +76,7 @@ bun_event_loop::impl_timer_owner!(StatWatcherScheduler; from_timer_ptr => event_
 
 type WatcherQueue = UnboundedQueue<StatWatcher>;
 
-// Intrusive `next`-link accessors for `UnboundedQueue<StatWatcher>` (Zig:
-// `UnboundedQueue(StatWatcher, .next)` reflected on `@field(item, "next")`).
+// Intrusive `next`-link accessors for `UnboundedQueue<StatWatcher>`.
 //
 // SAFETY: all four route through the same `next: *mut StatWatcher` field; the
 // atomic variants reinterpret it as `AtomicPtr<StatWatcher>` (same size/align,
@@ -92,7 +91,7 @@ unsafe impl bun_threading::Linked for StatWatcher {
 
 /// RAII owner of one outstanding [`StatWatcherScheduler`] ref. Adopts the
 /// "task in flight" ref taken in [`StatWatcherScheduler::timer_callback`] and
-/// releases it on Drop. Replaces Zig `defer this.deref()`.
+/// releases it on Drop.
 #[must_use = "dropping immediately releases the adopted ref"]
 struct SchedulerRefGuard(*mut StatWatcherScheduler);
 
@@ -118,8 +117,8 @@ impl Drop for SchedulerRefGuard {
 
 /// RAII owner of one outstanding [`StatWatcher`] ref. Adopts a ref taken
 /// elsewhere (e.g. by `InitialStatTask::create_and_schedule` or
-/// [`StatWatcher::restat`]) and releases it on Drop. Replaces Zig
-/// `defer this.deref()`. Holds a raw pointer so no `&`/`&mut StatWatcher` is
+/// [`StatWatcher::restat`]) and releases it on Drop.
+/// Holds a raw pointer so no `&`/`&mut StatWatcher` is
 /// live across the potential free in `deref`.
 #[must_use = "dropping immediately releases the adopted ref"]
 struct WatcherRefGuard(*mut StatWatcher);
@@ -207,7 +206,8 @@ impl StatWatcherScheduler {
             this_ref.watchers.is_empty(),
             "destroying StatWatcherScheduler while it still has watchers",
         );
-        // SAFETY: matches Zig `bun.destroy(this)` — heap::take drops the allocation.
+        // SAFETY: refcount reached zero, so `this` is the sole remaining
+        // reference; heap::take reclaims and drops the allocation.
         drop(unsafe { bun_core::heap::take(this) });
     }
 
@@ -539,7 +539,7 @@ pub struct StatWatcher {
 
     poll_ref: JsCell<KeepAlive>,
 
-    last_stat: Guarded<PosixStat>, // private field (#last_stat in Zig)
+    last_stat: Guarded<PosixStat>,
 
     scheduler: RefPtr<StatWatcherScheduler>,
 }
@@ -621,7 +621,7 @@ impl StatWatcher {
             Some(p) => p.as_ptr().cast::<StatWatcherScheduler>(),
             None => {
                 let arc = StatWatcherScheduler::init(vm);
-                let raw = arc.into_raw(); // VM owns this ref forever (Zig: never deref'd)
+                let raw = arc.into_raw(); // VM owns this ref forever (never deref'd)
                 // SAFETY: `vm` is live; reborrow rare_data after `init` to avoid
                 // an aliasing `&mut RareData` across the call.
                 *unsafe { (*vm).rare_data() }.node_fs_stat_watcher_scheduler_slot() =
@@ -731,12 +731,14 @@ impl StatWatcher {
         let el_ctx = this_ref.ctx_el_ctx();
         this_ref.poll_ref.with_mut(|p| p.unref(el_ctx));
         this_ref.closed.store(true, Ordering::Relaxed);
-        // `this_value.deinit()` handled by JsRef Drop below; explicit reset for
-        // parity with the Zig (drops the Strong before dealloc).
+        // `this_value.deinit()` handled by JsRef Drop below; explicit reset
+        // drops the Strong before dealloc.
         this_ref.this_value.set(JsRef::empty());
         // `path` freed by ZBox Drop below.
 
-        // SAFETY: matches Zig `bun.default_allocator.destroy(this)`.
+        // SAFETY: the caller is the sole owner (refcount hit zero, or the
+        // error-path scopeguard in `do_watch` holds the only reference);
+        // heap::take reclaims and drops the allocation.
         drop(unsafe { bun_core::heap::take(this) });
     }
 
@@ -1063,8 +1065,7 @@ impl StatWatcher {
     }
 }
 
-// PORT NOTE: hoisted from inline `if (isLinux and supports_statx) ... else brk: { ... }`
-// at two call sites (InitialStatTask::work_pool_callback and StatWatcher::restat) — identical logic.
+// Shared by InitialStatTask::work_pool_callback and StatWatcher::restat — identical logic.
 fn restat_impl(path: &ZStr) -> bun_sys::Maybe<PosixStat> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
@@ -1156,10 +1157,9 @@ impl Arguments {
 }
 
 pub(crate) struct InitialStatTask {
-    // Zig: `watcher: *StatWatcher`. StatWatcher is intrusively ref-counted
-    // (ThreadSafeRefCount m_ctx payload). We hold the strong ref via
-    // `ref_()`/`deref()` and keep the raw `*mut`, mirroring Zig's
-    // `*StatWatcher` aliasing intent.
+    // StatWatcher is intrusively ref-counted (ThreadSafeRefCount m_ctx
+    // payload). We hold the strong ref via `ref_()`/`deref()` and keep the
+    // raw `*mut`.
     watcher: *mut StatWatcher,
     task: WorkPoolTask,
 }
@@ -1185,7 +1185,7 @@ impl InitialStatTask {
     #[allow(clippy::boxed_local)]
     fn run_owned(self: Box<Self>) {
         // `watcher` is a raw `*mut` (Copy), so dropping the Box does not touch
-        // the refcount; matches Zig `bun.destroy(initial_stat_task)`.
+        // the refcount.
         let this: *mut StatWatcher = self.watcher;
         // BACKREF — `this` is kept alive by the intrusive ref taken in
         // `create_and_schedule`. We only need shared access here — `closed` is
@@ -1230,5 +1230,3 @@ impl InitialStatTask {
         // `watcher` is a raw pointer.
     }
 }
-
-// ported from: src/runtime/node/node_fs_stat_watcher.zig
diff --git a/src/runtime/node/node_fs_watcher.rs b/src/runtime/node/node_fs_watcher.rs
index 19a08bfeb35..0327d4c1298 100644
--- a/src/runtime/node/node_fs_watcher.rs
+++ b/src/runtime/node/node_fs_watcher.rs
@@ -53,9 +53,9 @@ pub struct FSWatcher {
     path_watcher: Cell<Option<*mut path_watcher::PathWatcher>>,
     poll_ref: JsCell<KeepAlive>,
     global_this: GlobalRef,
-    // TODO(port): bare JSValue heap field — self-wrapper; consider JsRef.
+    // TODO: bare JSValue heap field — self-wrapper; consider JsRef.
     pub(super) js_this: Cell<JSValue>,
-    // pub(super): read directly by `win_watcher::PathWatcher::emit` (matches Zig `ctx.encoding`).
+    // pub(super): read directly by `win_watcher::PathWatcher::emit`.
     pub(super) encoding: Encoding,
 
     /// User can call close and pre-detach so we need to track this
@@ -126,11 +126,9 @@ pub type FSWatchTask = FSWatchTaskWindows;
 #[cfg(not(windows))]
 pub type FSWatchTask = FSWatchTaskPosix;
 
-// Zig only references `FSWatchTaskPosix` from posix paths, so its lazy
-// compilation never type-checks the body on Windows. Rust type-checks
-// unconditionally, and `Event::Rename`/`Change` carry `StringOrBytesToDecode`
-// on Windows which does not coerce to the `&[u8]` `emit()` expects — gate the
-// whole posix task to keep the Windows build sound.
+// `Event::Rename`/`Change` carry `StringOrBytesToDecode` on Windows, which
+// does not coerce to the `&[u8]` `emit()` expects — gate the whole posix task
+// to keep the Windows build sound.
 #[cfg(not(windows))]
 pub struct FSWatchTaskPosix {
     /// `None` only during `FSWatcher::init` two-phase construction (the task is
@@ -214,7 +212,7 @@ impl FSWatchTaskPosix {
 
         // if false is closed or detached (can still contain valid refs but will not create a new one)
         if self.ctx().ref_task() {
-            // PORT NOTE: reshaped for borrowck — clone self into a heap task, then reset.
+            // Reshaped for borrowck — clone self into a heap task, then reset.
             let that = bun_core::heap::into_raw(Box::new(FSWatchTaskPosix {
                 ctx: self.ctx,
                 count: self.count,
@@ -257,7 +255,7 @@ impl FSWatchTaskPosix {
 
 #[cfg(not(windows))]
 impl FSWatchTaskPosix {
-    /// `FSWatchTaskPosix.deinit` (node_fs_watcher.zig:61). **Not** `impl Drop`:
+    /// `FSWatchTaskPosix.deinit`. **Not** `impl Drop`:
     /// this is only ever called on heap clones produced by `enqueue()` (via the
     /// task dispatcher), never on the embedded `FSWatcher.current_task` field —
     /// the assert below enforces that. A `Drop` impl would also fire on
@@ -285,8 +283,6 @@ impl FSWatchTaskPosix {
 pub type EventPathString = StringOrBytesToDecode;
 #[cfg(not(windows))]
 pub type EventPathString = Box<[u8]>;
-// TODO(port): on posix, `EventPathString` is borrowed `&[u8]` at callback time
-// but owned `Box<[u8]>` after `dupe()`. Consider `Cow<'_, [u8]>`.
 
 pub enum Event {
     Rename(EventPathString),
@@ -325,7 +321,6 @@ impl EventType {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn Bun__domEventNameToJS(global: &JSGlobalObject, event_type: EventType) -> JSValue;
 }
@@ -357,13 +352,11 @@ pub enum StringOrBytesToDecode {
     BytesToFree(Box<[u8]>),
 }
 
-// Zig: `StringOrBytesToDecode.deinit()` (node_fs_watcher.zig:199-207). The
-// `String` arm wraps `bun_core::String`, which is `#[derive(Copy)]` and has NO
-// `Drop` of its own (src/string/lib.rs), so without this impl dropping the
-// enum would silently leak the WTF::StringImpl ref taken by
+// The `String` arm wraps `bun_core::String`, which is `#[derive(Copy)]` and
+// has NO `Drop` of its own (src/string/lib.rs), so without this impl dropping
+// the enum would silently leak the WTF::StringImpl ref taken by
 // `BunString::clone_utf8` in `win_watcher.rs::emit()`. The `BytesToFree` arm's
-// `Box<[u8]>` already frees via its own `Drop`, mirroring the Zig
-// `default_allocator.free(this.bytes_to_free)`.
+// `Box<[u8]>` already frees via its own `Drop`.
 impl Drop for StringOrBytesToDecode {
     fn drop(&mut self) {
         if let Self::String(s) = self {
@@ -372,10 +365,9 @@ impl Drop for StringOrBytesToDecode {
     }
 }
 
-// Zig: `StringOrBytesToDecode{ .bytes_to_free = try default_allocator.dupe(u8, path) }`.
 // `PathWatcher::emit` and `Event::dupe` take a borrowed `&[u8]` rel-path and box
 // it into the owned `bytes_to_free` arm so the Windows task can carry it across
-// the thread hop (matches `FSWatchTaskWindows.run`'s `default_allocator.free`).
+// the thread hop.
 impl From<&[u8]> for StringOrBytesToDecode {
     #[inline]
     fn from(bytes: &[u8]) -> Self {
@@ -443,15 +435,14 @@ impl FSWatchTaskWindows {
         use bun_jsc::StringJsc;
         if ctx.encoding == Encoding::Utf8 {
             let StringOrBytesToDecode::String(s) = path else {
-                // TODO(port): Zig accesses `path.string` unconditionally here
+                // Producer invariant (win_watcher::on_path_update_windows): when
+                // `ctx.encoding == Utf8` the payload is always the `String`
+                // variant, and `encoding` is immutable after init.
                 unreachable!()
             };
-            // PORT NOTE (spec divergence): Zig's `catch return` here
-            // (node_fs_watcher.zig:237) returns from `run()` itself, skipping
-            // `ctx.unrefTask()` at zig:256 and leaving `pending_activity_count`
-            // permanently elevated on a `transferToJS` failure. Returning from
-            // this helper instead lets `run()` fall through to `unref_task()`,
-            // which is the intended fix — the Zig behavior is a refcount leak.
+            // Returning from this helper on `transferToJS` failure lets
+            // `run()` fall through to `unref_task()`, so
+            // `pending_activity_count` is never left permanently elevated.
             let Ok(js) = s.transfer_to_js(&ctx.global_this) else {
                 return;
             };
@@ -471,7 +462,7 @@ impl FSWatchTaskWindows {
         unreachable!("FSWatchTaskWindows::run is windows-only")
     }
 
-    /// `FSWatchTaskWindows.deinit` (node_fs_watcher.zig:259). Explicit, not
+    /// `FSWatchTaskWindows.deinit`. Explicit, not
     /// `impl Drop`, to mirror `FSWatchTaskPosix::deinit` so the dispatcher can
     /// call `FSWatchTask::deinit` uniformly.
     ///
@@ -481,7 +472,7 @@ impl FSWatchTaskWindows {
     pub unsafe fn deinit(this: *mut Self) {
         // `Event` (and `StringOrBytesToDecode`, via its explicit `Drop` impl
         // above which `deref()`s the WTF string) free their payloads via Drop,
-        // so dropping the Box is `event.deinit() + bun.destroy(this)`.
+        // so dropping the Box releases everything.
         // SAFETY: paired with `heap::alloc` at the enqueue site.
         drop(unsafe { bun_core::heap::take(this) });
     }
@@ -606,8 +597,8 @@ impl<'a> Arguments<'a> {
             return Err(ctx
                 .throw_invalid_arguments(format_args!("filename must be a string or TypedArray")));
         };
-        // TODO(port): PathLike Drop — Zig had `defer if (should_deinit_path) path.deinit();`
-        // Once PathLike: Drop, `?` on the error paths below drops it automatically.
+        // `PathLike: Drop` releases the path: `?` on the error paths below
+        // drops `path` automatically.
 
         let mut listener: JSValue = JSValue::ZERO;
         let mut signal: Option<&AbortSignal> = None;
@@ -716,14 +707,13 @@ impl AbortListener for FSWatcher {
 }
 
 impl FSWatcher {
-    /// Read access to the JS wrapper value. Exposed for `NodeFS::watch`, which
-    /// in Zig reads the `js_this` field directly off the by-value `*FSWatcher`.
+    /// Read access to the JS wrapper value. Exposed for `NodeFS::watch`.
     #[inline]
     pub fn js_this(&self) -> JSValue {
         self.js_this.get()
     }
 
-    /// `FSWatcher.initJS` (node_fs_watcher.zig:537). Takes `*mut Self` so the
+    /// `FSWatcher.initJS`. Takes `*mut Self` so the
     /// already-heap-allocated payload can be handed to `${T}__create` via
     /// `to_js_ptr` without re-boxing (see jsc_macros::JsClass).
     ///
@@ -780,15 +770,14 @@ impl FSWatcher {
     /// the wrapper's `m_ptr` — setting `closed = true` and `detach()`-ing.
     /// `Cell::get()` after the callback observes that write because
     /// `UnsafeCell` suppresses `noalias` on `&Self`; the trailing
-    /// `self.close()` then no-ops as in Zig.
+    /// `self.close()` then no-ops.
     pub fn emit_abort(&self, err: JSValue) {
         if self.closed.get() {
             return;
         }
         self.pending_activity_count.fetch_add(1, Ordering::Relaxed);
-        // PORT NOTE: Zig has `defer this.close(); defer this.unrefTask();` — defers run LIFO,
-        // so unref_task() executes before close(). No early returns below, so both calls are
-        // inlined at the end of this function.
+        // unref_task() must execute before close(). No early returns below,
+        // so both calls are inlined at the end of this function.
 
         err.ensure_still_alive();
         let js_this = self.js_this.get();
@@ -821,7 +810,7 @@ impl FSWatcher {
         if self.closed.get() {
             return;
         }
-        // PORT NOTE: reshaped for borrowck — `defer this.close()` moved to fn end.
+        // Reshaped for borrowck — `defer this.close()` moved to fn end.
 
         let js_this = self.js_this.get();
         if !js_this.is_empty() {
@@ -979,7 +968,9 @@ impl FSWatcher {
         } else {
             self.mutex.unlock();
         }
-        // TODO(port): bun.Mutex lock/unlock — verify RAII guard vs manual unlock semantics.
+        // Manual lock/unlock: the lock is released
+        // before `detach()` on the not-closed path and in the else branch — every
+        // path unlocks exactly once. `ref_task`/`unref_task` use the RAII guard.
     }
 
     /// `bun test --isolate` teardown: `close()` minus the `'close'` event (no
@@ -1027,8 +1018,7 @@ impl FSWatcher {
         }
 
         if let Some(signal) = self.signal.replace(None) {
-            // PORT NOTE: Zig `signal.detach(this)` = `cleanNativeBindings` +
-            // `unref`. `AbortSignalRef::Drop` already does the `unref`, so only
+            // `AbortSignalRef::Drop` already does the `unref`, so only
             // remove the listener here to avoid a double-unref.
             signal.clean_native_bindings(ctx_ptr);
         }
@@ -1110,11 +1100,9 @@ impl FSWatcher {
         ctx_ref
             .path_watcher
             .set(if args.signal.is_none_or(|s| !s.aborted()) {
-                // PORT NOTE: Zig passes `comptime callback` / `comptime updateEnd`
-                // and both backends `@compileError` if they aren't exactly
-                // `onPathUpdateFn` / `onUpdateEndFn`. The Windows port dropped
-                // those parameters (only one valid value each), so the call is
-                // cfg-split by arity.
+                // The two backends take different arities (the Windows
+                // backend dropped the callback parameters — only one valid
+                // value each), so the call is cfg-split.
                 #[cfg(windows)]
                 let r = path_watcher::watch(vm_ref, file_path, args.recursive, ctx as *mut c_void);
                 #[cfg(not(windows))]
@@ -1176,5 +1164,3 @@ impl Default for FSWatchTaskPosix {
         }
     }
 }
-
-// ported from: src/runtime/node/node_fs_watcher.zig
diff --git a/src/runtime/node/node_http_binding.rs b/src/runtime/node/node_http_binding.rs
index 84826df7736..26dbeb13a94 100644
--- a/src/runtime/node/node_http_binding.rs
+++ b/src/runtime/node/node_http_binding.rs
@@ -21,7 +21,7 @@ pub(crate) fn get_bun_server_all_closed_promise(
 
     let value = arguments[0];
 
-    // Zig: `inline for` over heterogeneous server types — unrolled manually.
+    // Try each heterogeneous server type in turn.
     macro_rules! try_server {
         ($ty:ty) => {
             if let Some(server) = value.as_::<$ty>() {
@@ -68,5 +68,3 @@ pub(crate) fn set_max_http_header_size(
     bun_http::set_max_http_header_size(num as usize);
     Ok(JSValue::from(bun_http::max_http_header_size()))
 }
-
-// ported from: src/runtime/node/node_http_binding.zig
diff --git a/src/runtime/node/node_net_binding.rs b/src/runtime/node/node_net_binding.rs
index 4e6349004d3..a372cb69151 100644
--- a/src/runtime/node/node_net_binding.rs
+++ b/src/runtime/node/node_net_binding.rs
@@ -11,8 +11,6 @@ use bun_uws as uws;
 use crate::node::util::validators;
 use crate::socket::{Listener, NativeCallbacks, NewSocket, SocketFlags, TCPSocket, TLSSocket};
 
-// Zig: `pub var autoSelectFamilyDefault: bool = true;`
-// PORT NOTE: reshaped for borrowck — Rust forbids safe `static mut`; use AtomicBool.
 pub(crate) static AUTO_SELECT_FAMILY_DEFAULT: AtomicBool = AtomicBool::new(true);
 
 // This is only used to provide the getDefaultAutoSelectFamilyAttemptTimeout and
@@ -109,11 +107,10 @@ pub(crate) fn set_default_auto_select_family_attempt_timeout(global: &JSGlobalOb
     )
 }
 
-// codegen (`generated_js2native.rs`) snake-cases the Zig symbol; alias the
+// codegen (`generated_js2native.rs`) snake-cases the symbol; alias the
 // PascalCase fns so both spellings resolve.
 pub use self::{BlockList as block_list, SocketAddress as socket_address};
 
-// Zig: `pub const SocketAddress = bun.jsc.Codegen.JSSocketAddress.getConstructor;`
 // Forward to the codegen'd `js_${Type}::get_constructor` wrappers — they go through
 // `jsc_abi_extern!` so the extern uses `extern "sysv64"` on win-x64 (matching
 // C++ `JSC_CALLCONV`). A bare `extern "C"` redecl here would be the wrong ABI on
@@ -123,7 +120,6 @@ pub fn SocketAddress(global: &JSGlobalObject) -> JSValue {
     crate::generated_classes::js_SocketAddress::get_constructor(global)
 }
 
-// Zig: `pub const BlockList = jsc.Codegen.JSBlockList.getConstructor;`
 #[allow(non_snake_case)]
 pub fn BlockList(global: &JSGlobalObject) -> JSValue {
     crate::generated_classes::js_BlockList::get_constructor(global)
@@ -134,8 +130,8 @@ pub(crate) fn new_detached_socket(global: &JSGlobalObject, frame: &CallFrame) ->
     let args = frame.arguments_as_array::<1>();
     let is_ssl = args[0].to_boolean();
 
-    // Zig field-default initializer: only `socket`, `ref_count`, `protos`, `handlers` are
-    // specified; the rest take their struct defaults (see `NewSocket` field decls in socket.zig).
+    // Only `socket`, `ref_count`, `protos`, `handlers` are
+    // specified; the rest take their struct defaults.
     fn make<const SSL: bool>(global: &JSGlobalObject) -> JSValue {
         let socket = NewSocket::<SSL>::new(NewSocket::<SSL> {
             socket: Cell::new(uws::NewSocketHandler::<SSL>::DETACHED),
@@ -173,5 +169,3 @@ pub(crate) fn do_connect(global: &JSGlobalObject, frame: &CallFrame) -> JsResult
     let maybe_tls = prev.as_::<TLSSocket>();
     Listener::connect_inner(global, maybe_tcp, maybe_tls, opts)
 }
-
-// ported from: src/runtime/node/node_net_binding.zig
diff --git a/src/runtime/node/node_os.rs b/src/runtime/node/node_os.rs
index e267b4183de..bb04eda2ffa 100644
--- a/src/runtime/node/node_os.rs
+++ b/src/runtime/node/node_os.rs
@@ -2,12 +2,10 @@ use core::ffi::c_int;
 #[cfg(not(windows))]
 use core::ffi::{c_char, c_uint, c_void};
 
-// TODO(port): bun_jsc — using crate-local opaque shim until `bun_jsc` is a dep.
-use crate::jsc::{JSGlobalObject, JSValue, JsResult};
 use bun_core;
 use bun_core::String as BunString;
+use bun_jsc::{JSGlobalObject, JSValue, JsResult};
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn bun_sysconf__SC_NPROCESSORS_ONLN() -> i32;
 }
@@ -23,7 +21,6 @@ pub(crate) struct CPUTimes {
 
 pub(crate) fn freemem() -> u64 {
     // OsBinding.cpp
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         safe fn Bun__Os__getFreeMemory() -> u64;
     }
@@ -60,7 +57,7 @@ mod _impl {
 
     /// Unified error for `cpus_impl_*` so `?` works on both `JsResult` and
     /// `bun_core::Error`/`bun_sys::Error`. The variant payload is discarded by
-    /// `cpus()` (matches Zig's `catch` → throw `SystemError`).
+    /// `cpus()`, which throws a `SystemError`.
     pub(crate) enum OsError {
         Js,
         Any,
@@ -81,8 +78,8 @@ mod _impl {
         }
     }
 
-    /// `bun_jsc::SystemError` has no `Default` (TODO in src/jsc/SystemError.rs).
-    /// Local zero-value matching Zig's extern-struct field defaults.
+    /// `bun_jsc::SystemError` has no `Default` (see src/jsc/SystemError.rs).
+    /// Local zero-value for the extern-struct fields.
     #[inline]
     fn system_error_default() -> SystemError {
         SystemError {
@@ -98,8 +95,8 @@ mod _impl {
     }
 
     /// `bun_core::ZigString` (the `bun_string` crate type) is `repr(C)`-identical
-    /// to the JSC-side `ZigString` but lacks `with_encoding`/`to_js`. Provide them
-    /// locally so call sites match the Zig spec verbatim.
+    /// to the JSC-side `ZigString` but lacks `with_encoding`/`to_js`. Provide
+    /// them locally.
     trait ZigStringJs {
         fn with_encoding(self) -> ZigString;
         fn to_js(&self, global: &JSGlobalObject) -> JSValue;
@@ -107,7 +104,7 @@ mod _impl {
     impl ZigStringJs for ZigString {
         #[inline]
         fn with_encoding(mut self) -> ZigString {
-            // Zig `setOutputEncoding`: if not already 16-bit, mark UTF-8.
+            // If not already 16-bit, mark UTF-8.
             if !self.is_16bit() {
                 self.mark_utf8();
             }
@@ -124,20 +121,17 @@ mod _impl {
         }
     }
 
-    // `bun.HOST_NAME_MAX` (bun.zig) — `std.posix.HOST_NAME_MAX` on unix, 256 on
-    // Windows. Neither `bun_core` nor `bun_sys` re-export it yet; 256 is a safe
-    // upper bound for the stack buffer on every platform.
-    // TODO(port): hoist into `bun_sys` once that crate grows a `HOST_NAME_MAX`.
+    // Neither `bun_core` nor `bun_sys` re-exports HOST_NAME_MAX yet; 256 is a
+    // safe upper bound for the stack buffer on every platform.
     const HOST_NAME_MAX: usize = 256;
 
-    // Generated bindings (`bun.gen.node_os` in Zig, emitted from
-    // `node_os.bind.ts` via `src/codegen/bindgen.ts`). The C++ side
+    // Generated bindings (emitted from `node_os.bind.ts` via
+    // `src/codegen/bindgen.ts`). The C++ side
     // (`GeneratedBindings.cpp`) defines the SYSV-ABI `bindgen_Node_os_js*` host
     // functions, which validate/decode arguments and call back into the
-    // `bindgen_Node_os_dispatch*` Zig (now Rust) entry points. This module ports
-    // the Zig public surface — `js*` extern pointers + `create*Callback` wrappers
-    // + the `UserInfoOptions` dictionary — verbatim from
-    // `src/jsc/bindings/GeneratedBindings.zig`.
+    // `bindgen_Node_os_dispatch*` entry points. This module provides the
+    // public surface: `js*` extern pointers + `create*Callback` wrappers
+    // + the `UserInfoOptions` dictionary.
     pub mod gen_ {
         use super::{BunString, CallFrame, JSGlobalObject, JSValue, ZigString};
         use bun_jsc::host_fn;
@@ -163,8 +157,8 @@ mod _impl {
         }
 
         // Each `create*Callback` is identical modulo (display name, min arg
-        // count, host-fn symbol) — see `bindgen.ts:1538`. Generate them with the
-        // exact triples the Zig codegen would have produced.
+        // count, host-fn symbol) — see `bindgen.ts:1538`. Generate them with
+        // the exact triples the codegen would have produced.
         macro_rules! create_callback {
         ($($fn_name:ident, $js_name:literal, $argc:literal, $sym:ident;)*) => {$(
             pub fn $fn_name(global: &JSGlobalObject) -> JSValue {
@@ -196,9 +190,9 @@ mod _impl {
         }
 
         /// `t.dictionary({ encoding: t.DOMString.default("") })` from
-        /// `node_os.bind.ts`. Mirrors the `extern struct` emitted by bindgen
-        /// (`GeneratedBindings.zig` `node_os.UserInfoOptions`); the C++ side
-        /// passes a pointer to this layout, so it must stay `#[repr(C)]`.
+        /// `node_os.bind.ts`. Mirrors the extern struct emitted by bindgen;
+        /// the C++ side passes a pointer to this layout, so it must stay
+        /// `#[repr(C)]`.
         #[repr(C)]
         pub struct UserInfoOptions {
             pub encoding: BunString,
@@ -213,7 +207,6 @@ mod _impl {
     }
 
     pub(crate) fn create_node_os_binding(global: &JSGlobalObject) -> JsResult<JSValue> {
-        // TODO(port): JSObject::create struct-literal API — define a builder/macro
         let obj = JSValue::create_empty_object(global, 14);
         // SAFETY: pure FFI getter
         obj.put(
@@ -251,7 +244,6 @@ mod _impl {
 
     impl CPUTimes {
         pub(crate) fn to_value(self, global_this: &JSGlobalObject) -> JSValue {
-            // Zig used comptime std.meta.fieldNames + inline for; expand manually.
             let ret = JSValue::create_empty_object(global_this, 5);
             ret.put(
                 global_this,
@@ -311,7 +303,6 @@ mod _impl {
         let values = JSValue::create_empty_array(global_this, 0)?;
         let mut num_cpus: u32 = 0;
 
-        // PERF(port): was stack-fallback alloc (8KB) — profile if it shows up on a hot path.
         let mut file_buf: Vec<u8> = Vec::new();
 
         // Read /proc/stat to get number of CPUs and times
@@ -373,7 +364,6 @@ mod _impl {
                 //NOTE: libuv assumes this is fixed on Linux, not sure that's actually the case
                 let scale: u64 = 10;
 
-                // TODO(port): narrow error set
                 let times = CPUTimes {
                     user: scale * parse_u64(toks.next().ok_or_else(|| bun_core::err!("eol"))?)?,
                     nice: scale * parse_u64(toks.next().ok_or_else(|| bun_core::err!("eol"))?)?,
@@ -566,7 +556,6 @@ mod _impl {
         Ok(values)
     }
 
-    // TODO(port): move to <area>_sys
     #[cfg(any(target_os = "macos", target_os = "freebsd"))]
     unsafe extern "C" {
         safe fn bun_sysconf__SC_CLK_TCK() -> isize;
@@ -715,7 +704,6 @@ mod _impl {
         Ok(values)
     }
 
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         safe fn get_process_priority(pid: i32) -> i32;
     }
@@ -769,7 +757,6 @@ mod _impl {
             // Instead of always using an allocation, first try a stack allocation
             // of 4096, then fallback to heap.
             let mut stack_string_bytes = [0u8; 4096];
-            // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
             let mut heap_bytes: Vec<u8>;
             let mut string_bytes: &mut [u8] = &mut stack_string_bytes[..];
             let mut using_heap = false;
@@ -1080,7 +1067,7 @@ mod _impl {
                 //  the address and cidr values can be slices into this same buffer
                 // e.g. addr_str = "192.168.88.254", cidr_str = "192.168.88.254/24"
                 let mut buf = [0u8; 64];
-                // PORT NOTE: reshaped for borrowck — capture buf base ptr/len before
+                // Reshaped for borrowck — capture buf base ptr/len before
                 // format_ip's mutable borrow, and reduce addr_str to (start, len)
                 // immediately so subsequent buf accesses don't alias the returned slice.
                 let buf_ptr = buf.as_ptr() as usize;
@@ -1298,7 +1285,6 @@ mod _impl {
                 // Format the address and then, if valid, the CIDR suffix; both
                 //  the address and cidr values can be slices into this same buffer
                 // e.g. addr_str = "192.168.88.254", cidr_str = "192.168.88.254/24"
-                // TODO(port): std.net.Address → bun_sys::net::Address
                 let addr_str = bun_fmt::format_ip(
                     // bun_sys::net::Address will do ptrCast depending on the family so this is ok
                     // SAFETY: the address union backs a valid sockaddr_in/sockaddr_in6; pointer derived
@@ -1455,7 +1441,6 @@ mod _impl {
         BunString::clone_utf8(value)
     }
 
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         pub(crate) safe fn set_process_priority(pid: i32, priority: i32) -> i32;
     }
@@ -1753,5 +1738,3 @@ fn slice_to_nul_u16(buf: &[u16]) -> &[u16] {
     let nul = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
     &buf[..nul]
 }
-
-// ported from: src/runtime/node/node_os.zig
diff --git a/src/runtime/node/node_process.rs b/src/runtime/node/node_process.rs
index 1159642fbad..d291e5d0d44 100644
--- a/src/runtime/node/node_process.rs
+++ b/src/runtime/node/node_process.rs
@@ -7,7 +7,6 @@ use bun_core::{self, Environment, Global};
 use bun_jsc::zig_string::ZigString;
 use bun_jsc::{JSGlobalObject, JSValue, ZigStringJsc as _};
 
-// TODO(port): move to <area>_sys — extern decls colocated for now
 unsafe extern "C" {
     safe fn Bun__Process__getArgv(global: &JSGlobalObject) -> JSValue;
     safe fn Bun__Process__getExecArgv(global: &JSGlobalObject) -> JSValue;
@@ -48,13 +47,13 @@ pub(crate) extern "C" fn get_exec_argv(global: &JSGlobalObject) -> JSValue {
 
 // ───────────────────────────── exit ─────────────────────────────
 
-// TODO(@190n) this may need to be noreturn
+// @190n: this may need to be noreturn
 #[unsafe(export_name = "Bun__Process__exit")]
 pub extern "C" fn exit(global_object: &JSGlobalObject, code: u8) {
     let vm = global_object.bun_vm().as_mut();
     vm.exit_handler.exit_code = code;
     if let Some(worker) = vm.worker_ref() {
-        // TODO(@190n) we may need to use requestTerminate or throwTerminationException
+        // @190n: we may need to use requestTerminate or throwTerminationException
         // instead to terminate the worker sooner
         worker.exit();
     } else {
@@ -80,8 +79,7 @@ pub(crate) extern "C" fn Bun__suppressCrashOnProcessKillSelfIfDesired() {
     }
 }
 
-// PORT NOTE: Zig `export const Foo: [*:0]const u8 = "..."` exports a static
-// pointing at rodata. Rust raw-pointer statics are `!Sync`; wrap in a
+// Raw-pointer statics are `!Sync`; wrap in a
 // `#[repr(transparent)]` newtype so the C++ side still sees a single
 // `const char*`-sized symbol.
 #[repr(transparent)]
@@ -162,23 +160,21 @@ mod _impl {
     ) {
         // SAFETY: newvalue is a valid pointer from C++; we consume one ref before
         // returning. `String` is `Copy`, so read it out by value and let
-        // `OwnedString`'s Drop release the ref (Zig: `defer newvalue.deref()`).
+        // `OwnedString`'s Drop release the ref.
         let newvalue = bun_core::OwnedString::new(unsafe { *newvalue });
 
-        // PORT NOTE: `to_owned_slice` is infallible (Vec<u8>) in the Rust port, so
-        // the Zig OOM-throw path is unreachable here.
+        // `to_owned_slice` is infallible (Vec<u8>).
         let new_title: Box<[u8]> = newvalue.to_owned_slice().into_boxed_slice();
 
-        // Zig: `if (old) |slice| allocator.free(slice); Bun__Node__ProcessTitle = new_title;`
-        // — assigning into the `Option<Box<[u8]>>` static drops the previous box.
+        // Assigning into the `Option<Box<[u8]>>` static drops the previous box.
         *crate::cli::Bun__Node__ProcessTitle.lock() = Some(new_title);
     }
 
     // ───────────────────────────── execArgv ─────────────────────────────
 
-    // Zig: `@export(&host_fn.wrap1(createExecArgv), ...)` — the C++ caller
+    // The C++ caller
     // (headers.h) declares `EncodedJSValue Bun__Process__createExecArgv(JSGlobalObject*)`,
-    // not a `JSHostFunctionType`. Hand-roll the wrap1 shim instead of `#[bun_jsc::host_fn]`.
+    // not a `JSHostFunctionType`. Hand-roll the shim instead of `#[bun_jsc::host_fn]`.
     #[unsafe(no_mangle)]
     pub(super) extern "C" fn Bun__Process__createExecArgv(
         global_object: &JSGlobalObject,
@@ -187,7 +183,6 @@ mod _impl {
     }
 
     fn create_exec_argv(global_object: &JSGlobalObject) -> JsResult<JSValue> {
-        // PERF(port): was stack-fallback alloc (4096 bytes) — profile if hot.
         // SAFETY: `bun_vm()` returns the live per-thread VM for this global.
         let vm = global_object.bun_vm();
 
@@ -276,12 +271,8 @@ mod _impl {
 
             // A set of execArgv args consume an extra argument, so we do not want to
             // confuse these with script names.
-            // TODO(port): the Zig builds this set at comptime by iterating
-            // `bun.cli.Arguments.auto_params` and emitting `--long` / `-s` for every
-            // param with `takes_value != .none`. Rust cannot reflect over that list
-            // at compile time, so build the set lazily at runtime from the same
-            // `AUTO_PARAMS` table. Could swap this for a phf::Set via
-            // build.rs or a proc-macro.
+            // Build the set lazily at runtime from the `AUTO_PARAMS` table:
+            // `--long` / `-s` for every param with a value.
             static MAP: std::sync::LazyLock<bun_collections::StringSet> =
                 std::sync::LazyLock::new(|| {
                     let mut set = bun_collections::StringSet::new();
@@ -323,8 +314,6 @@ mod _impl {
         // SAFETY: `bun_vm()` returns the live per-thread VM for this global.
         let vm = global_object.bun_vm();
 
-        // PERF(port): was stack-fallback alloc (32 * sizeof(ZigString) + MAX_PATH_BYTES + 1 + 32) — profile if hot.
-
         let worker: Option<&WebWorker> = vm.worker_ref();
 
         let args_count: usize = match worker {
@@ -340,17 +329,15 @@ mod _impl {
             // Don't break user's code because they did process.argv.slice(2)
             // Even if they didn't type "bun", we still want to add it as argv[0]
             args_list.push(BunString::static_(b"bun"));
-            // PERF(port): was assume_capacity
         } else {
             let exe_path = bun_core::self_exe_path().ok();
             args_list.push(match exe_path {
                 Some(str_) => BunString::borrow_utf8(str_.as_bytes()),
                 None => BunString::static_(b"bun"),
             });
-            // PERF(port): was assume_capacity
         }
 
-        // PORT NOTE: bun.pathLiteral inlined — bun_paths has no path_literal! macro yet.
+        // Per-platform path-separator literal suffixes.
         const EVAL_SUFFIX: &[u8] = if cfg!(windows) {
             b"\\[eval]"
         } else {
@@ -367,24 +354,20 @@ mod _impl {
         {
             if worker.is_some_and(|w| w.eval_mode()) {
                 args_list.push(BunString::static_(b"[worker eval]"));
-                // PERF(port): was assume_capacity
             } else {
                 args_list.push(BunString::borrow_utf8(vm.main()));
-                // PERF(port): was assume_capacity
             }
         }
 
         if let Some(worker) = worker {
             for &arg in worker.argv() {
                 args_list.push(BunString::init(arg));
-                // PERF(port): was assume_capacity
             }
         } else {
             for arg in &vm.argv {
                 let str_ = BunString::borrow_utf8(arg);
                 // https://github.com/yargs/yargs/blob/adb0d11e02c613af3d9427b3028cc192703a3869/lib/utils/process-argv.ts#L1
                 args_list.push(str_);
-                // PERF(port): was assume_capacity
             }
         }
 
@@ -405,8 +388,8 @@ mod _impl {
 
     // ───────────────────────────── cwd ─────────────────────────────
 
-    // Zig: `pub const getCwd = host_fn.wrap1(getCwd_)` — C++ (headers.h) declares
-    // `EncodedJSValue Bun__Process__getCwd(JSGlobalObject*)`. Hand-roll the wrap1
+    // C++ (headers.h) declares
+    // `EncodedJSValue Bun__Process__getCwd(JSGlobalObject*)`. Hand-roll the
     // shim instead of `#[bun_jsc::host_fn]` (caller is not a JSHostFunction).
     #[unsafe(no_mangle)]
     pub(super) extern "C" fn Bun__Process__getCwd(global_object: &JSGlobalObject) -> JSValue {
@@ -421,9 +404,9 @@ mod _impl {
         }
     }
 
-    // Zig: `pub const setCwd = host_fn.wrap2(setCwd_)` — C++ (headers.h) declares
+    // C++ (headers.h) declares
     // `EncodedJSValue Bun__Process__setCwd(JSGlobalObject*, ZigString*)`. Hand-roll
-    // the wrap2 shim; the second arg is the raw `*mut ZigString`, not a CallFrame.
+    // the shim; the second arg is the raw `*mut ZigString`, not a CallFrame.
     #[unsafe(no_mangle)]
     pub(super) extern "C" fn Bun__Process__setCwd(
         global_object: &JSGlobalObject,
@@ -448,7 +431,7 @@ mod _impl {
             return Err(global_object.throw(format_args!("Invalid path")));
         };
 
-        // Zig: `Syscall.chdir(fs.top_level_dir, slice)` — path=cwd, dest=target so the
+        // path=cwd, dest=target so the
         // resulting Node SystemError carries `path: cwd`, `dest: target` and the
         // `chdir '<cwd>' -> '<target>'` message format (test-process-chdir-errormessage).
         let top_level_dir: &[u8] = fs.top_level_dir;
@@ -471,9 +454,9 @@ mod _impl {
                 };
                 fs.top_level_dir_buf[..into_cwd_len].copy_from_slice(&buf[..into_cwd_len]);
                 fs.top_level_dir_buf[into_cwd_len] = 0;
-                // SAFETY: `top_level_dir_buf` is a process-lifetime field of the
-                // FileSystem singleton; the detached borrow matches the Zig
-                // semantics (`top_level_dir = top_level_dir_buf[0..len :0]`).
+                // SAFETY: `top_level_dir_buf` is a process-lifetime field of
+                // the FileSystem singleton, so the detached borrow never
+                // outlives its backing storage.
                 fs.top_level_dir =
                     unsafe { bun_ptr::detach_lifetime(&fs.top_level_dir_buf[..into_cwd_len]) };
 
@@ -486,12 +469,12 @@ mod _impl {
                     fs.top_level_dir =
                         unsafe { bun_ptr::detach_lifetime(&fs.top_level_dir_buf[..len + 1]) };
                 }
-                // Zig has a single `bun.fs.FileSystem.instance.top_level_dir` field that
-                // both this fn writes and `GlobWalker.init` reads. The Rust port split
-                // storage between the resolver's `FileSystem.top_level_dir` (written
-                // above) and `bun_core::TOP_LEVEL_DIR` (read by `bun_paths::fs::
-                // FileSystem::top_level_dir()` → `GlobWalker::init`). Keep them in sync
-                // so a `process.chdir()` before `new Glob(...).scan()` is observed.
+                // The cwd is stored both in the resolver's
+                // `FileSystem.top_level_dir` (written above) and in
+                // `bun_core::TOP_LEVEL_DIR` (read by `bun_paths::fs::
+                // FileSystem::top_level_dir()` → `GlobWalker::init`). Keep them
+                // in sync so a `process.chdir()` before `new Glob(...).scan()`
+                // is observed.
                 bun_core::set_top_level_dir(fs.top_level_dir);
                 #[cfg(windows)]
                 let without_trailing_slash =
@@ -510,7 +493,7 @@ mod _impl {
 
     // ───────────────────────────── Windows env var ─────────────────────────────
 
-    // TODO: switch this to using *bun.wtf.String when it is added
+    // TODO: switch this to a WTF::String-backed type when one is added
     #[cfg(windows)]
     #[unsafe(export_name = "Bun__Process__editWindowsEnvVar")]
     pub(super) extern "C" fn bun_process_edit_windows_env_var(k: BunString, v: BunString) {
@@ -518,11 +501,9 @@ mod _impl {
         if k.tag() == bun_core::Tag::Empty {
             return;
         }
-        // Zig: `k.value.WTFStringImpl` — `value` is a private union field in Rust;
         // `String::{is_8bit,latin1,utf16,length}` dispatch to the WTF impl when
         // `tag == WTFStringImpl` (guaranteed here: C++ caller passes WTF-backed
         // strings and we've already returned on `Empty`).
-        // PERF(port): was stack-fallback alloc (1025 bytes) — profile if hot.
         let mut buf1: Vec<u16> = vec![0u16; k.utf16_byte_length() + 1];
         let mut buf2: Vec<u16> = vec![0u16; v.utf16_byte_length() + 1];
         let len1: usize = if k.is_8bit() {
@@ -557,5 +538,3 @@ mod _impl {
         }
     }
 } // mod _impl
-
-// ported from: src/runtime/node/node_process.zig
diff --git a/src/runtime/node/node_util_binding.rs b/src/runtime/node/node_util_binding.rs
index 78eca21ec7f..5157f3f10e9 100644
--- a/src/runtime/node/node_util_binding.rs
+++ b/src/runtime/node/node_util_binding.rs
@@ -61,7 +61,6 @@ pub(crate) fn extracted_split_new_lines_fast_path_strings_only(
     let str = OwnedString::new(value.to_bun_string(global)?);
 
     match str.encoding() {
-        // `inline .utf16, .latin1 => |encoding| split(encoding, ...)` — runtime → comptime dispatch
         EncodingNonAscii::Utf16 => split(EncodingNonAscii::Utf16, global, &str),
         EncodingNonAscii::Latin1 => split(EncodingNonAscii::Latin1, global, &str),
         EncodingNonAscii::Utf8 => {
@@ -74,7 +73,7 @@ pub(crate) fn extracted_split_new_lines_fast_path_strings_only(
     }
 }
 
-// PERF(port): `encoding` was a comptime parameter (Zig); demoted to runtime
+// PERF: `encoding` is a runtime parameter
 // because `EncodingNonAscii` doesn't derive `ConstParamTy` (would need nightly
 // `adt_const_params`). The hot u8/u16 split is still type-dispatched below.
 fn split(
@@ -82,19 +81,14 @@ fn split(
     global: &JSGlobalObject,
     str: &BunString,
 ) -> JsResult<JSValue> {
-    // PERF(port): was stack-fallback (std.heap.stackFallback(1024)).
-    // Allocator param dropped (non-AST crate uses global mimalloc).
-
-    // `defer { for (lines.items) |out| out.deref(); lines.deinit(alloc); }`
-    // — `Vec<OwnedString>`'s Drop runs `deref()` on every element (covers both
+    // `Vec<OwnedString>`'s Drop runs `deref()` on every element (covers both
     // the success path after `to_js_array` and any `?` early-return). Raw
     // `bun_core::String` is `Copy` and has NO Drop, so a `Vec<BunString>` would
-    // leak; `OwnedString` is the RAII wrapper that mirrors Zig's defer loop.
+    // leak; `OwnedString` is the RAII wrapper that releases each ref.
     let mut lines: Vec<OwnedString> = Vec::new();
 
-    // Zig: `const Char = switch (encoding) { .utf8, .latin1 => u8, .utf16 => u16 };`
-    // PORT NOTE: reshaped — comptime enum cannot select an associated type in
-    // stable Rust; split into two arms over the buffer's element type.
+    // Split into two arms over the buffer's element type (u8 for
+    // utf8/latin1, u16 for utf16).
     match encoding {
         EncodingNonAscii::Utf16 => {
             let buffer: &[u16] = str.utf16();
@@ -174,9 +168,6 @@ pub fn parse_env(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue
     let content = frame.argument(0);
     validators::validate_string(global, content, "content")?;
 
-    // PERF(port): was arena bulk-free (std.heap.ArenaAllocator).
-    // Non-AST crate: arena dropped; Map/Loader use global allocator and Drop.
-
     // `validate_string` above guarantees `content.is_string()`, so
     // `as_string()` returns a non-null live JSString*. `JSString` is an
     // `opaque_ffi!` ZST handle; `opaque_ref` is the centralised deref proof.
@@ -197,5 +188,3 @@ pub fn parse_env(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue
     }
     Ok(obj)
 }
-
-// ported from: src/runtime/node/node_util_binding.zig
diff --git a/src/runtime/node/node_zlib_binding.rs b/src/runtime/node/node_zlib_binding.rs
index 9de778280b3..63b7c71be94 100644
--- a/src/runtime/node/node_zlib_binding.rs
+++ b/src/runtime/node/node_zlib_binding.rs
@@ -21,12 +21,11 @@ bun_output::declare_scope!(zlib, hidden);
 
 // ─── type defs ────────────────────────────────────────────────────────────
 
-/// Zig: `fn CompressionStream(comptime T: type) type { return struct { ... } }`
 /// This is a mixin: methods all take `this: *T` and access fields on `T`
 /// (write_in_progress, pending_close, pending_reset, closed, stream, this_value,
 /// write_result, task, poll_ref, globalThis) plus `T.js.*` codegen accessors and
 /// `T.ref()/deref()`.
-// PORT NOTE: expressed as a marker struct + trait bound. Field accesses on
+// Expressed as a marker struct + trait bound. Field accesses on
 // `T` go through the [`CompressionStreamImpl`] trait below.
 pub(crate) struct CompressionStream<T>(PhantomData<T>);
 
@@ -42,7 +41,7 @@ impl Drop for CountedKeepAlive {
     }
 }
 
-/// Zig: `?[*:0]const u8` for `msg` / `code` — nullable NUL-terminated C strings.
+/// `msg` / `code` are nullable NUL-terminated C strings.
 /// Kept as raw `*const c_char` (not `&'static str`) because zlib (`z_stream.msg`)
 /// and zstd (`ZSTD_getErrorString`) hand back runtime C pointers.
 #[derive(Clone, Copy)]
@@ -76,13 +75,13 @@ impl Error {
 // ─── local shims (upstream-crate gaps) ────────────────────────────────────
 
 /// Local `JSValue::toU32` shim — `bun_jsc::JSValue` doesn't expose `to_u32()`
-/// in this crate's view yet; mirror Zig's `@intFromFloat(value.asNumber())`.
+/// in this crate's view yet.
 #[inline]
 fn jsv_to_u32(v: JSValue) -> u32 {
     v.as_number() as u32
 }
 
-/// Local `std.meta.intToEnum(FlushValue, n)` shim — `bun_zlib::FlushValue` has
+/// Checked u32 → `FlushValue` validation — `bun_zlib::FlushValue` has
 /// no `TryFrom<u32>` impl upstream.
 #[inline]
 fn flush_value_is_valid(n: u32) -> bool {
@@ -197,12 +196,11 @@ pub(crate) fn crc32(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsRe
 }
 
 // ─── CompressionStream mixin trait ────────────────────────────────────────
-// Zig's `CompressionStream(T)` reaches into `T`'s fields directly (comptime
-// duck-typing). Rust can't, so each `Native{Zlib,Brotli,Zstd}` implements this
+// Each `Native{Zlib,Brotli,Zstd}` implements this
 // trait to expose its fields + per-class codegen accessors.
 
 /// Backing-stream surface used by [`CompressionStream`] (zlib / brotli / zstd
-/// `Context` types). Mirrors the Zig `this.stream.*` calls.
+/// `Context` types).
 pub(crate) trait CompressionContext {
     fn set_buffers(&mut self, in_: Option<&[u8]>, out: Option<&mut [u8]>);
     fn set_flush(&mut self, flush: i32);
@@ -262,12 +260,12 @@ pub(crate) trait CompressionStreamImpl: Sized + Taskable + 'static {
     /// SAFETY: caller guarantees `task` points at the `task` field of a live `Self`.
     unsafe fn from_task(task: *mut WorkPoolTask) -> *mut Self;
 
-    // Intrusive refcount (Zig `bun.ptr.RefCount`).
+    // Intrusive refcount.
     fn ref_(&self);
     /// Decrement the intrusive refcount and free `*this` (via `Self::deinit` /
     /// `heap::take`) when it hits zero.
     ///
-    /// PORT NOTE: raw-pointer receiver so the destroy path keeps the
+    /// Raw-pointer receiver so the destroy path keeps the
     /// allocation's full write provenance (routing through `&self` and casting
     /// back to `*mut` would be UB under Stacked Borrows when `Box::from_raw`
     /// reclaims). Every call site that may hit zero (`run_from_js_thread`,
@@ -453,7 +451,6 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
         Ok(JSValue::UNDEFINED)
     }
 
-    // Zig: nested `const AsyncJob = struct { ... }` — namespacing only.
     // Safe fn: coerces to the `WorkPoolTask.callback` field type at the
     // struct-init site in `write` above.
     fn async_job_run_task(task: *mut WorkPoolTask) {
@@ -473,7 +470,7 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
         // (R-2). `ParentRef` Deref collapses the per-site raw deref.
         let this_ref = ParentRef::from(NonNull::new(this).expect("async_job_run: this"));
         let global_this: &JSGlobalObject = this_ref.global_this();
-        // Zig: `bunVMConcurrently()` — thread-safe accessor (skips the
+        // `bun_vm_concurrently()` is the thread-safe accessor (skips the
         // JS-thread debug assert; same backing pointer as `bun_vm()`).
         // BACKREF — `bun_vm_concurrently()` never returns null for a Bun-owned
         // global; wrap once so the `event_loop()` read below is safe Deref.
@@ -483,7 +480,6 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
 
         this_ref.stream().with_mut(|s| s.do_work());
 
-        // Zig: `vm.enqueueTaskConcurrent(ConcurrentTask.create(Task.init(this)))`.
         // SAFETY: `event_loop()` is a self-pointer into a live VM; the
         // `enqueue_task_concurrent` body only touches the lock-free
         // `concurrent_tasks` queue (thread-safe). `this` is the heap-allocated
@@ -513,9 +509,8 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
         let global: &JSGlobalObject = this.global_this();
         // SAFETY: `bun_vm()` never returns null for a Bun-owned global.
         let vm = global.bun_vm();
-        // PORT NOTE: reshaped — Zig used `defer this.deref(); defer
-        // this.poll_ref.unref(vm);` (run at scope exit in reverse order). We
-        // call them explicitly on every return path.
+        // `this.deref()` and `this.poll_ref.unref(vm)` must run on every
+        // return path; we call them explicitly.
 
         this.write_in_progress().set(false);
 
@@ -817,7 +812,6 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
         // runs doWork().
         this.write_in_progress().set(false);
 
-        // Zig: `std.mem.sliceTo(err_.msg, 0) orelse ""`.
         let msg_bytes: &[u8] = if err_.msg.is_null() {
             b""
         } else {
@@ -879,18 +873,6 @@ impl<T: CompressionStreamImpl> CompressionStream<T> {
 /// Expose the [`CompressionStream<T>`] mixin entry points as inherent
 /// associated fns on `T` so the per-class C-ABI thunks emitted by
 /// `generated_classes.rs` (which call `T::write(&mut *this, …)` etc.) resolve.
-///
-/// This is the Rust spelling of Zig's
-/// ```zig
-/// const impl = CompressionStream(@This());
-/// pub const write = impl.write;
-/// pub const writeSync = impl.writeSync;
-/// pub const reset = impl.reset;
-/// pub const close = impl.close;
-/// pub const setOnError = impl.setOnError;
-/// pub const getOnError = impl.getOnError;
-/// pub const finalize = impl.finalize;
-/// ```
 #[macro_export]
 #[doc(hidden)]
 macro_rules! __compression_stream_mixin_reexports {
@@ -966,8 +948,7 @@ macro_rules! __compression_stream_mixin_reexports {
     };
 }
 
-// Zig: `pub const NativeZlib = jsc.Codegen.JSNativeZlib.getConstructor;` (etc.) —
-// in Rust the per-class `JS*` codegen submodules collapse into the generic
+// The per-class `JS*` codegen submodules collapse into the generic
 // `jsc::codegen::js::get_constructor::<T>` helper (see src/jsc/lib.rs `pub mod codegen`).
 #[inline]
 pub(crate) fn native_zlib(global: &JSGlobalObject) -> JSValue {
@@ -984,8 +965,7 @@ pub(crate) fn native_zstd(global: &JSGlobalObject) -> JSValue {
 
 /// Implements [`CompressionContext`] for a `Context` type and
 /// [`CompressionStreamImpl`] for its owning `Native*` struct by delegating to
-/// the inherent methods / fields that already exist on each (mirrors Zig's
-/// comptime duck-typed `CompressionStream(T)` mixin).
+/// the inherent methods / fields that already exist on each.
 ///
 /// All three `Native{Zlib,Brotli,Zstd}` structs share the exact field layout
 /// (`global_this`, `stream`, `poll_ref`, `this_value`,
@@ -1037,8 +1017,8 @@ macro_rules! __impl_compression_stream {
 
             #[inline]
             unsafe fn from_task(task: *mut ::bun_jsc::WorkPoolTask) -> *mut Self {
-                // SAFETY: `task` points at the `task` field of a live `Self`
-                // (Zig `@fieldParentPtr("task", task)`); `from_field_ptr!`
+                // SAFETY: `task` points at the `task` field of a live `Self`;
+                // `from_field_ptr!`
                 // computes the byte offset via `offset_of!(Self, task)`.
                 unsafe { ::bun_core::from_field_ptr!(Self, task, task) }
             }
@@ -1051,7 +1031,7 @@ macro_rules! __impl_compression_stream {
             #[inline] unsafe fn deref(this: *mut Self) {
                 // SAFETY: forwarded trait contract — `this` is live; the
                 // derived `CellRefCounted::deref` routes zero to the per-type
-                // `destroy` (≡ Zig `bun.ptr.RefCount(.., deinit, .{})`).
+                // `destroy`.
                 unsafe { <Self as ::bun_ptr::CellRefCounted>::deref(this) }
             }
 
@@ -1082,5 +1062,3 @@ macro_rules! __impl_compression_stream {
         }
     };
 }
-
-// ported from: src/runtime/node/node_zlib_binding.zig
diff --git a/src/runtime/node/nodejs_error_code.rs b/src/runtime/node/nodejs_error_code.rs
index f7ce7c359f9..9c23d557fe1 100644
--- a/src/runtime/node/nodejs_error_code.rs
+++ b/src/runtime/node/nodejs_error_code.rs
@@ -1111,5 +1111,3 @@ pub enum Code {
     /// Used by node:util parseArgs
     ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL,
 }
-
-// ported from: src/runtime/node/nodejs_error_code.zig
diff --git a/src/runtime/node/path.rs b/src/runtime/node/path.rs
index e8fe78b7cd5..112e1eea9dc 100644
--- a/src/runtime/node/path.rs
+++ b/src/runtime/node/path.rs
@@ -8,14 +8,13 @@ use bun_core::{ZigString, ZigStringSlice, strings};
 use bun_paths::{self, MAX_PATH_BYTES, Platform};
 use bun_sys;
 
-/// Local shim for `bun.String.createUTF8ForJS` over `[T]` (T = u8 | u16).
+/// Create a JS string from a `[T]` slice (T = u8 | u16).
 ///
-/// Zig's `createUTF8ForJS` only accepts `[]const u8`, but the `*JS_T` wrappers
-/// in path.zig are `comptime T`-generic. In practice every JS entry point
-/// converts to UTF-8 first (via `ZigString.toSlice`) and instantiates with
+/// In practice every JS entry point converts to UTF-8 first (via
+/// `ZigString.toSlice`) and instantiates with
 /// `T = u8`, so the `u16` arm is never reached at runtime — but it must still
 /// type-check. Dispatch on `T::IS_U16` and route the cold u16 arm through
-/// `bun.String.cloneUTF16(...).toJS(...)` so the generic body unifies.
+/// a UTF-16 `BunString` clone + `to_js` so the generic body unifies.
 #[inline]
 fn create_js_string_t<T: PathCharCwd>(global: &JSGlobalObject, s: &[T]) -> JsResult<JSValue> {
     use crate::jsc::{StringJsc as _, bun_string_jsc};
@@ -35,7 +34,7 @@ fn create_js_string_t<T: PathCharCwd>(global: &JSGlobalObject, s: &[T]) -> JsRes
 
 // ── Local extension shims for upstream types missing methods (cannot edit upstream crates).
 
-/// `ZigString.trunc(n)` — clamp `len` to `n` (ZigString.zig:580).
+/// `ZigString.trunc(n)` — clamp `len` to `n`.
 trait ZigStringTruncExt {
     fn trunc(&self, len: usize) -> ZigString;
 }
@@ -48,8 +47,7 @@ impl ZigStringTruncExt for ZigString {
     }
 }
 
-/// Pooled path scratch carved from the per-VM [`RarePathBuf`] (mirrors Zig's
-/// `RareData.path_buf.get(min_len, fallback)` `StackFallbackAllocator`).
+/// Pooled path scratch carved from the per-VM [`RarePathBuf`].
 ///
 /// JS is single-threaded, so re-using the lazily-allocated tier across calls is
 /// sound. When the request exceeds the largest tier (32 × `MAX_PATH_BYTES`) —
@@ -117,15 +115,12 @@ impl PathCharCwd for u16 {
     }
 }
 
-/// `bun.strings.literal(T, "...")` — yields a `&'static [T]` for the ASCII literal.
+/// Yields a `&'static [T]` for an ASCII literal.
 #[inline]
 fn l<T: PathCharCwd>(s: &'static [u8]) -> &'static [T] {
     T::lit(s)
 }
 
-/// Taken from Zig 0.11.0 zig/src/resinator/rc.zig
-/// https://github.com/ziglang/zig/blob/776cd673f206099012d789fd5d05d49dd72b9faa/src/resinator/rc.zig#L266
-///
 /// Compares ASCII values case-insensitively, non-ASCII values are compared directly
 fn eql_ignore_case_t<T: PathCharCwd>(a: &[T], b: &[T]) -> bool {
     if !T::IS_U16 {
@@ -134,8 +129,8 @@ fn eql_ignore_case_t<T: PathCharCwd>(a: &[T], b: &[T]) -> bool {
         let b8: &[u8] = bytemuck::cast_slice::<T, u8>(b);
         return strings::eql_case_insensitive_ascii(a8, b8, true);
     }
-    // Zig's `eqlIgnoreCaseT` body for `T == u16` falls through with no return (UB if reached);
-    // in practice the only callers instantiate with `T == u8`. Provide a sound u16 compare so
+    // In practice the only callers instantiate with `T == u8`; provide a sound
+    // u16 compare so
     // the generic body type-checks and behaves correctly if ever exercised.
     if a.len() != b.len() {
         return false;
@@ -145,9 +140,6 @@ fn eql_ignore_case_t<T: PathCharCwd>(a: &[T], b: &[T]) -> bool {
         .all(|(x, y)| to_lower_t(*x) == to_lower_t(*y))
 }
 
-/// Taken from Zig 0.11.0 zig/src/resinator/rc.zig
-/// https://github.com/ziglang/zig/blob/776cd673f206099012d789fd5d05d49dd72b9faa/src/resinator/rc.zig#L266
-///
 /// Lowers ASCII values, non-ASCII values are returned directly
 #[inline]
 fn to_lower_t<T: PathCharCwd>(a_c: T) -> T {
@@ -200,7 +192,6 @@ pub struct PathParsed<'a, T: PathCharCwd> {
     pub name: &'a [T],
 }
 
-// path.zig:2750 — `extern "c" fn PathParsedObject__create(*jsc.JSGlobalObject, jsc.JSValue × 5) jsc.JSValue;`
 // `&JSGlobalObject` is ABI-identical to a non-null pointer; remaining params are
 // by-value `JSValue`, so no caller-side preconditions remain.
 unsafe extern "C" {
@@ -216,9 +207,6 @@ unsafe extern "C" {
 
 impl<'a, T: PathCharCwd> PathParsed<'a, T> {
     pub(crate) fn to_js_object(&self, global_object: &JSGlobalObject) -> JsResult<JSValue> {
-        // PORT NOTE: alias the free-fn module so the Zig-mirrored
-        // `BunString::create_utf8_for_js(...)` call shape resolves (same pattern
-        // as the per-submodule imports below).
         let root = create_js_string_t::<T>(global_object, self.root)?;
         let dir = create_js_string_t::<T>(global_object, self.dir)?;
         let base = create_js_string_t::<T>(global_object, self.base)?;
@@ -245,7 +233,7 @@ pub(crate) const fn max_path_size<T: PathCharCwd>() -> usize {
 
 /// Upper bound of `max_path_size::<T>()` across both `T = u8` and `T = u16` on
 /// the current target. Used for sizing stack buffers where the `T`-dependent
-/// array length can't be expressed as a const-generic (Zig's `[MAX_PATH_SIZE(T):0]T`).
+/// array length can't be expressed as a const-generic.
 const MAX_PATH_SIZE_UPPER: usize = if MAX_PATH_BYTES > bun_paths::PATH_MAX_WIDE {
     MAX_PATH_BYTES
 } else {
@@ -260,7 +248,7 @@ pub(crate) const fn path_size<T: PathCharCwd>() -> usize {
     }
 }
 
-/// Helper: `bun.memmove(dst, src)` — equal-length copy.
+/// Helper: equal-length copy.
 /// (Rust's borrow rules forbid `&mut [T]`/`&[T]` overlap, so memmove ⇒ memcpy.)
 #[inline]
 fn memmove<T: Copy>(dst: &mut [T], src: &[T]) {
@@ -282,7 +270,7 @@ pub(crate) fn posix_cwd_t<T: PathCharCwd>(buf: &mut [T]) -> MaybeBuf<'_, T> {
 
         // Translated from the following JS code:
         //   const cwd = StringPrototypeReplace(process.cwd(), regexp, '/');
-        // PORT NOTE: reshaped for borrowck — cwd already aliases buf, so mutate in place.
+        // cwd already aliases buf, so mutate in place.
         for i in 0..len {
             if cwd[i] == T::from_u8(CHAR_BACKWARD_SLASH) {
                 cwd[i] = T::from_u8(CHAR_FORWARD_SLASH);
@@ -590,7 +578,6 @@ pub fn basename(
     };
 
     if let Some(_suffix_ptr) = suffix_ptr {
-        // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
         validate_string(global_object, _suffix_ptr, format_args!("ext"))?;
     }
 
@@ -599,7 +586,6 @@ pub fn basename(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_string(global_object, path_ptr, format_args!("path"))?;
 
     let path_zstr = path_ptr.get_zig_string(global_object)?;
@@ -607,7 +593,6 @@ pub fn basename(
         return Ok(path_ptr);
     }
 
-    // PERF(port): was stack-fallback — profile if hot
     let path_zslice = path_zstr.to_slice();
 
     let mut suffix_zslice: Option<bun_core::ZigStringSlice> = None;
@@ -816,7 +801,6 @@ pub(crate) fn dirname(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_string(global_object, path_ptr, format_args!("path"))?;
 
     let path_zstr = path_ptr.get_zig_string(global_object)?;
@@ -824,7 +808,6 @@ pub(crate) fn dirname(
         return BunString::create_utf8_for_js(global_object, CHAR_STR_DOT);
     }
 
-    // PERF(port): was stack-fallback — profile if hot
     let path_zslice = path_zstr.to_slice();
     dirname_js_t::<u8>(global_object, is_windows, path_zslice.slice())
 }
@@ -1061,7 +1044,6 @@ pub(crate) fn extname(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_string(global_object, path_ptr, format_args!("path"))?;
 
     let path_zstr = path_ptr.get_zig_string(global_object)?;
@@ -1069,7 +1051,6 @@ pub(crate) fn extname(
         return Ok(path_ptr);
     }
 
-    // PERF(port): was stack-fallback — profile if hot
     let path_zslice = path_zstr.to_slice();
     extname_js_t::<u8>(global_object, is_windows, path_zslice.slice())
 }
@@ -1091,8 +1072,7 @@ fn _format_t<'a, T: PathCharCwd>(
 
     // Translated from the following JS code:
     //   const dir = pathObject.dir || pathObject.root;
-    // PORT NOTE: Zig used `std.mem.eql(u8, dir, root)` (hard-coded u8) which is a latent bug
-    // for `T == u16`; compare as `&[T]` here.
+    // Compare as `&[T]` so the comparison is correct for `T == u16` too.
     let dir_is_root = dir.is_empty() || dir == root;
     let dir_or_root = if dir_is_root { root } else { dir };
     let dir_len = dir_or_root.len();
@@ -1104,14 +1084,14 @@ fn _format_t<'a, T: PathCharCwd>(
     //   const base = pathObject.base ||
     //     `${pathObject.name || ''}${formatExt(pathObject.ext)}`;
     let mut base_len = base.len();
-    // PORT NOTE: reshaped for borrowck — track range into buf instead of slice.
+    // Borrowck: track range into buf instead of slice.
     let base_or_name_ext_range: (usize, usize);
     if base_len > 0 {
         memmove(&mut buf[0..base_len], base);
         base_or_name_ext_range = (0, base_len);
     } else {
         let formatted_ext_len = {
-            // PORT NOTE: reshaped for borrowck — inline format_ext_t to avoid overlapping &mut.
+            // Borrowck: inline format_ext_t to avoid overlapping &mut.
             let ext_len = ext.len();
             if ext_len == 0 {
                 0
@@ -1234,7 +1214,6 @@ pub(crate) fn format(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_object(
         global_object,
         path_object_ptr,
@@ -1242,8 +1221,6 @@ pub(crate) fn format(
         Default::default(),
     )?;
 
-    // PERF(port): was stack-fallback — profile if hot
-
     let mut root: &[u8] = b"";
     let root_slice = if let Some(js_value) = path_object_ptr.get_truthy(global_object, "root")? {
         Some(js_value.to_slice(global_object)?)
@@ -1337,7 +1314,6 @@ pub(crate) fn is_absolute(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_string(global_object, path_ptr, format_args!("path"))?;
 
     let path_zstr = path_ptr.get_zig_string(global_object)?;
@@ -1365,7 +1341,7 @@ pub(crate) fn join_posix_t<'a, T: PathCharCwd>(
     let mut buf_offset: usize;
 
     // Back joined by expandable buf2 in case it is long.
-    // PORT NOTE: reshaped for borrowck — track length instead of slice into buf2.
+    // Borrowck: track length instead of slice into buf2.
     let mut joined_len: usize = 0;
 
     for path in paths {
@@ -1444,7 +1420,7 @@ pub(crate) fn join_windows_t<'a, T: PathCharCwd>(
     let mut buf_offset: usize;
 
     // Backed by expandable buf2 in case it is long.
-    // PORT NOTE: reshaped for borrowck — track ranges instead of slices into buf2.
+    // Borrowck: track ranges instead of slices into buf2.
     let mut joined_len: usize = 0;
     let mut first_part_len: usize = 0;
 
@@ -1585,9 +1561,9 @@ pub fn join(
         return BunString::create_utf8_for_js(global_object, CHAR_STR_DOT);
     }
 
-    // Zig leaks each per-arg `toSlice()` into the arena and bulk-frees at the end;
-    // here the `ZigStringSlice` RAII guards live inline in `owned` for the same
-    // effect. ASCII-only inputs (the common case) borrow the WTF backing without
+    // The `ZigStringSlice` RAII guards live inline in `owned` so every
+    // per-arg `toSlice()` is released at scope exit.
+    // ASCII-only inputs (the common case) borrow the WTF backing without
     // allocating; only non-ASCII triggers a transcode allocation.
     let mut owned: SmallVec<[ZigStringSlice; 8]> = SmallVec::with_capacity(args_len);
 
@@ -1612,7 +1588,7 @@ pub fn join(
     // Derive the `&[u8]` views in a second pass once `owned` is fully built —
     // borrowck then sees `paths` as a plain reborrow of `owned` with no
     // intervening mutation, so no raw-pointer detach is needed. Empty entries
-    // are skipped both here and inside `join_*_t`, matching Zig.
+    // are skipped both here and inside `join_*_t`.
     let paths: SmallVec<[&[u8]; 8]> = owned.iter().map(ZigStringSlice::slice).collect();
     let pool = &mut global_object.bun_vm().as_mut().rare_data().path_buf;
     join_js_t::<u8>(global_object, pool, is_windows, &paths)
@@ -1628,8 +1604,8 @@ fn normalize_string_t<T: PathCharCwd, const PLATFORM: Platform>(
     separator: T,
     buf: &mut [T],
 ) -> usize {
-    // PORT NOTE: returns length into buf (NUL-terminated at buf[len]) instead of `[:0]T` slice,
-    // reshaped for borrowck so callers can re-borrow buf.
+    // Returns length into buf (NUL-terminated at buf[len]) instead of `[:0]T` slice,
+    // so callers can re-borrow buf (borrowck).
     let len = path.len();
     let is_sep_t: fn(T) -> bool = if matches!(PLATFORM, Platform::Posix) {
         is_sep_posix_t::<T>
@@ -1840,7 +1816,7 @@ pub(crate) fn normalize_windows_t<'a, T: PathCharCwd>(path: &[T], buf: &'a mut [
         return if is_sep_t(byte0) {
             l::<T>(CHAR_STR_BACKWARD_SLASH)
         } else {
-            // PORT NOTE: reshaped for borrowck — copy single char into buf since path may not outlive buf.
+            // Borrowck: copy single char into buf since path may not outlive buf.
             buf[0] = byte0;
             &buf[0..1]
         };
@@ -1848,7 +1824,7 @@ pub(crate) fn normalize_windows_t<'a, T: PathCharCwd>(path: &[T], buf: &'a mut [
 
     let mut root_end: usize = 0;
     // Backed by buf.
-    // PORT NOTE: reshaped for borrowck — track device length instead of slice into buf.
+    // Borrowck: track device length instead of slice into buf.
     let mut device_len: Option<usize> = None;
     // Prefix with _ to avoid shadowing the identifier in the outer scope.
     let mut _is_absolute: bool = false;
@@ -2034,7 +2010,6 @@ pub(crate) fn normalize(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     validate_string(global_object, path_ptr, format_args!("path"))?;
     let path_zstr = path_ptr.get_zig_string(global_object)?;
     let len = path_zstr.len;
@@ -2404,7 +2379,6 @@ pub fn parse(
     } else {
         JSValue::UNDEFINED
     };
-    // Supress exeption in zig. It does globalThis.vm().throwError() in JS land.
     crate::node::validators_impl::validate_string(global_object, path_ptr, format_args!("path"))?;
 
     let path_zstr = path_ptr.get_zig_string(global_object)?;
@@ -2412,7 +2386,6 @@ pub fn parse(
         return PathParsed::<u8>::default().to_js_object(global_object);
     }
 
-    // PERF(port): was stack-fallback — profile if hot
     let path_zslice = path_zstr.to_slice();
     parse_js_t::<u8>(global_object, is_windows, path_zslice.slice())
 }
@@ -2436,10 +2409,10 @@ pub(crate) fn relative_posix_t<'a, T: PathCharCwd>(
     let from_orig = resolve_posix_t(&[from], buf2, buf3)?;
     let from_orig_len = from_orig.len();
     // Backed by buf.
-    // PORT NOTE: reshaped for borrowck — resolve into buf, then operate via raw indices.
+    // Borrowck: resolve into buf, then operate via raw indices.
     // resolve_*_t may return a 'static literal (".") instead of a sub-slice of
     // buf; copy it in so indexing `buf[..to_orig_len]` below observes the
-    // resolved value (matches Zig, which captures the returned slice itself).
+    // resolved value.
     let to_orig_len = {
         let (ptr, len) = {
             let r = resolve_posix_t(&[to], buf, buf3)?;
@@ -2581,10 +2554,10 @@ pub(crate) fn relative_windows_t<'a, T: PathCharCwd>(
     let from_orig = resolve_windows_t(&[from], buf2, buf3)?;
     let from_orig_len = from_orig.len();
     // Backed by buf.
-    // PORT NOTE: reshaped for borrowck — resolve into buf, then operate via raw indices.
+    // Borrowck: resolve into buf, then operate via raw indices.
     // resolve_*_t may return a 'static literal (".") instead of a sub-slice of
     // buf; copy it in so indexing `buf[..to_orig_len]` below observes the
-    // resolved value (matches Zig, which captures the returned slice itself).
+    // resolved value.
     let to_orig_len = {
         let (ptr, len) = {
             let r = resolve_windows_t(&[to], buf, buf3)?;
@@ -2862,9 +2835,9 @@ pub(crate) fn resolve_posix_t<'a, T: PathCharCwd>(
         i64::try_from(paths.len() - 1).expect("int cast")
     };
     while i_i64 > -2 && !resolved_absolute {
-        // PORT NOTE: reshaped for borrowck — `path` may borrow from tmp_buf which lives
+        // Borrowck: `path` may borrow from tmp_buf which lives
         // in this scope; copy into buf2 before reusing.
-        // Zig: `[MAX_PATH_SIZE(T):0]T` — sized to the larger of the two T variants.
+        // Sized to the larger of the two T variants.
         let mut tmp_buf: [T; MAX_PATH_SIZE_UPPER];
         let path: &[T] = if i_i64 >= 0 {
             paths[usize::try_from(i_i64).expect("int cast")]
@@ -2950,11 +2923,11 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
     buf2: &mut [T],
 ) -> MaybeSlice<'a, T> {
     let is_sep_t = is_sep_windows_t::<T>;
-    // Zig: `[MAX_PATH_SIZE(T):0]T` — sized to the larger of the two T variants.
+    // Sized to the larger of the two T variants.
     let mut tmp_buf = [T::default(); MAX_PATH_SIZE_UPPER + 1];
 
     // Backed by tmpBuf.
-    // PORT NOTE: reshaped for borrowck — track resolved_device length into tmp_buf.
+    // Borrowck: track resolved_device length into tmp_buf.
     let mut resolved_device_len: usize = 0;
     // Backed by expandable buf2 because resolvedTail may be long.
     // We use buf2 here because resolvePosixT is called by other methods and using
@@ -2974,11 +2947,11 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
     while i_i64 > -2 {
         // Backed by expandable buf2, to not conflict with buf2 backed resolvedTail,
         // because path may be long.
-        // PORT NOTE: reshaped for borrowck — `path` may alias paths[], tmp_buf, or buf2,
+        // Borrowck: `path` may alias paths[], tmp_buf, or buf2,
         // and the loop body subsequently mutates tmp_buf/buf2 while still indexing
         // `path`. Store as raw (ptr, len) and materialize short-lived slices at use
-        // sites; all overlapping moves go through `ptr::copy` (memmove semantics),
-        // matching the Zig original.
+        // sites; all overlapping moves go through `ptr::copy` (memmove
+        // semantics).
         let mut path_ptr: *const T;
         let mut path_len: usize;
         macro_rules! path { () => {
@@ -3014,9 +2987,7 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
                 // `'brk:` block) so the slice it backs stays live across `getenv_w`.
                 // 4 elements (not 3) so the wchar immediately following the 3-char
                 // key is a guaranteed NUL — `getenv_w` forwards `name.as_ptr()` to
-                // `GetEnvironmentVariableW`, which reads an LPCWSTR until NUL. The
-                // Zig spec uses `&[3:0]u16{...}` (sentinel-terminated) for the same
-                // reason.
+                // `GetEnvironmentVariableW`, which reads an LPCWSTR until NUL.
                 let fast_key: [u16; 4];
                 // Windows has the concept of drive-specific current working
                 // directories. If we've resolved a drive letter but not yet an
@@ -3054,26 +3025,21 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
                         // `getenv_w` requires the NUL be addressable via the slice's
                         // pointer (it forwards `.as_ptr()` as LPCWSTR). `buf2` is a
                         // reused arena buffer with arbitrary prior contents past
-                        // `buf_size`, so write the terminator explicitly. Zig spec:
-                        // path.zig declares `key_w: [*:0]const u16` and the sentinel
-                        // is part of the object.
+                        // `buf_size`, so write the terminator explicitly.
                         buf2[buf_size] = T::from_u8(0);
                         // T == u16 when IS_U16; bytemuck statically checks the layout.
                         break 'brk bytemuck::cast_slice::<T, u16>(&buf2[..=buf_size]);
                     }
                     // T == u8 when !IS_U16; bytemuck statically checks the layout.
                     let key8: &[u8] = bytemuck::cast_slice::<T, u8>(&buf2[..buf_size]);
-                    // Zig spec (path.zig:2480-2482) writes `u16Buf[bufSize] = 0;`
-                    // after widening so the LPCWSTR is properly terminated regardless
-                    // of `WPathBuffer::uninit()`'s init state. Do the same here —
-                    // don't rely on `uninit()` happening to zero-fill today.
+                    // Write the NUL after widening so the LPCWSTR is properly
+                    // terminated regardless of `WPathBuffer::uninit()`'s init
+                    // state — don't rely on `uninit()` happening to zero-fill
+                    // today.
                     let n = strings::convert_utf8_to_utf16_in_buffer(&mut u16_buf[..], key8).len();
                     u16_buf[n] = 0;
                     &u16_buf[..=n]
                 };
-                // Zig's std.posix.getenvW has logic to support keys like `=${resolvedDevice}`:
-                // https://github.com/ziglang/zig/blob/7bd8b35a3dfe61e59ffea39d464e84fbcdead29a/lib/std/os.zig#L2126-L2130
-                //
                 // TODO: Enable test once spawnResult.stdout works on Windows.
                 // test/js/node/path/resolve.test.js
                 if let Some(r) = bun_sys::windows::getenv_w(key_w) {
@@ -3132,7 +3098,7 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
         let mut root_end: usize = 0;
         // Backed by tmpBuf or an anonymous buffer.
         let device_buf: [T; 2];
-        // PORT NOTE: same raw-ptr trick as `path` — `device` may alias tmp_buf.
+        // Same raw-ptr trick as `path` — `device` may alias tmp_buf.
         let mut device_ptr: *const T = core::ptr::NonNull::<T>::dangling().as_ptr().cast_const();
         let mut device_len: usize = 0;
         let mut device_in_tmp = false;
@@ -3194,8 +3160,8 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
                             //   device =
                             //     `\\\\${firstPart}\\${StringPrototypeSlice(path, last, j)}`;
                             //   rootEnd = j;
-                            // PORT NOTE: path may alias tmp_buf (cwd branch). The Zig original
-                            // relies on memmove + non-overlapping ranges; use ptr::copy here.
+                            // path may alias tmp_buf (cwd branch); use
+                            // ptr::copy (memmove semantics).
                             buf_size = 2;
                             tmp_buf[0] = T::from_u8(CHAR_BACKWARD_SLASH);
                             tmp_buf[1] = T::from_u8(CHAR_BACKWARD_SLASH);
@@ -3301,7 +3267,7 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
             }
             buf_size = slice_len;
             if slice_len > 0 {
-                // PORT NOTE: path may alias buf2 (env path branch); use ptr::copy.
+                // path may alias buf2 (env path branch); use ptr::copy.
                 // SAFETY: handles overlap.
                 unsafe {
                     core::ptr::copy(path_ptr.add(root_end), buf2.as_mut_ptr(), slice_len);
@@ -3328,8 +3294,7 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
     }
 
     // At this point, the path should be resolved to a full absolute path,
-    // but handle relative paths to be safe (might happen when std.process.cwdAlloc()
-    // fails)
+    // but handle relative paths to be safe (can happen if reading the cwd fails).
 
     // Normalize the tail path
     let normalized_len = normalize_string_t::<T, { Platform::Windows }>(
@@ -3373,7 +3338,6 @@ pub(crate) fn resolve_windows_t<'a, T: PathCharCwd>(
     Ok(l::<T>(CHAR_STR_DOT))
 }
 
-// path.zig:2749 — `extern "c" fn Process__getCachedCwd(*jsc.JSGlobalObject) jsc.JSValue;`
 #[cfg(unix)]
 unsafe extern "C" {
     safe fn Process__getCachedCwd(global: &JSGlobalObject) -> JSValue;
@@ -3423,7 +3387,7 @@ pub(crate) fn resolve_js_t<T: PathCharCwd>(
     buf_len += max_path_size::<T>() + 1;
     buf_len = buf_len.max(path_size::<T>());
     // +2 to account for separator and null terminator during path resolution.
-    // Carve buf/buf2 from one pooled slab (mirrors Zig's RareData path_buf).
+    // Carve buf/buf2 from one pooled slab.
     let mut scratch = PathScratch::<T>::new(pool, (buf_len + 2) * 2);
     let (buf, buf2) = scratch.slice().split_at_mut(buf_len + 2);
     if is_windows {
@@ -3445,7 +3409,7 @@ pub(crate) fn resolve(
     // Borrow each argument's WTF backing as a `ZigStringSlice` (no per-arg
     // `to_owned_slice()` heap copy — ASCII inputs borrow in place, only
     // non-ASCII transcodes). Inline-8 keeps the typical call alloc-free.
-    // Walk back-to-front to preserve Zig's early-out on the first absolute
+    // Walk back-to-front to early-out on the first absolute
     // POSIX path; reverse the borrowed views before handing to `resolve_*_t`.
     let mut owned: SmallVec<[ZigStringSlice; 8]> = SmallVec::new();
     let mut resolved_root = false;
@@ -3505,7 +3469,7 @@ pub(crate) fn to_namespaced_path_windows_t<'a, T: PathCharCwd>(
 ) -> MaybeSlice<'a, T> {
     // validateString of `path` is performed in pub fn toNamespacedPath.
     // Backed by buf.
-    // PORT NOTE: reshaped for borrowck — capture length, then re-borrow buf.
+    // Borrowck: capture length, then re-borrow buf.
     let resolved_len = resolve_windows_t(&[path], buf, buf2)?.len();
 
     let len = resolved_len;
@@ -3534,8 +3498,6 @@ pub(crate) fn to_namespaced_path_windows_t<'a, T: PathCharCwd>(
                 // overwritten by "\\\\?\\UNC\\" which is 8 bytes long.
                 // Use copy_within because resolvedPath and buf overlap.
                 buf.copy_within(0..len, buf_offset);
-                // Equiv to std.os.windows.NamespacePrefix.verbatim
-                // https://github.com/ziglang/zig/blob/dcaf43674e35372e1d28ab12c4c4ff9af9f3d646/lib/std/os/windows.zig#L2358-L2374
                 buf[0] = T::from_u8(CHAR_BACKWARD_SLASH);
                 buf[1] = T::from_u8(CHAR_BACKWARD_SLASH);
                 buf[2] = T::from_u8(CHAR_QUESTION_MARK);
@@ -3561,8 +3523,6 @@ pub(crate) fn to_namespaced_path_windows_t<'a, T: PathCharCwd>(
         // Move all bytes to the right by 4
         // Use copy_within because resolvedPath and buf overlap.
         buf.copy_within(0..len, buf_offset);
-        // Equiv to std.os.windows.NamespacePrefix.verbatim
-        // https://github.com/ziglang/zig/blob/dcaf43674e35372e1d28ab12c4c4ff9af9f3d646/lib/std/os/windows.zig#L2358-L2374
         buf[0] = T::from_u8(CHAR_BACKWARD_SLASH);
         buf[1] = T::from_u8(CHAR_BACKWARD_SLASH);
         buf[2] = T::from_u8(CHAR_QUESTION_MARK);
@@ -3632,13 +3592,11 @@ pub(crate) fn to_namespaced_path(
     to_namespaced_path_js_t::<u8>(global_object, pool, is_windows, path_zslice.slice())
 }
 
-// Zig used `bun.jsc.host_fn.wrap4v(...)` to generate the C-ABI shims. The Rust
-// proc-macro for `wrap4v` is not yet wired, so emit the SYSV-ABI thunks locally.
+// Emit the SYSV-ABI thunks locally.
 // Each wrapper forwards `(global, is_windows, args_ptr, args_len)` and routes the
-// `JsResult<JSValue>` through `host_fn::to_js_host_call` (== Zig `toJSHostCall`).
+// `JsResult<JSValue>` through `host_fn::to_js_host_call`.
 //
-// ABI: `jsc.conv` (src/jsc/jsc.zig) is `.x86_64_sysv` on Windows-x64 and `.c`
-// everywhere else. The C++ side (src/jsc/bindings/Path.cpp) declares these as
+// ABI: The C++ side (src/jsc/bindings/Path.cpp) declares these as
 // `SYSV_ABI`, so on Windows-x64 the wrapper MUST be `extern "sysv64"` — using
 // `extern "C"` there would be the Win64 ABI (RCX/RDX/R8/R9 + shadow space) and
 // would mis-read every argument.
@@ -3697,5 +3655,3 @@ export_path_host_fn! {
     "Bun__Path__resolve" => resolve,
     "Bun__Path__toNamespacedPath" => to_namespaced_path,
 }
-
-// ported from: src/runtime/node/path.zig
diff --git a/src/runtime/node/path_watcher.rs b/src/runtime/node/path_watcher.rs
index 5f9a9e629c2..9e33639dbba 100644
--- a/src/runtime/node/path_watcher.rs
+++ b/src/runtime/node/path_watcher.rs
@@ -2,19 +2,19 @@
 //!
 //! This is deliberately independent of `bun.Watcher` (the bundler/--watch/--hot
 //! watcher). `bun.Watcher` is shaped around a module graph — its WatchItem carries
-//! `options.Loader`, `*PackageJSON`, a `*bun.fs.FileSystem`, and on Windows is pinned
+//! `options.Loader`, `*PackageJSON`, a filesystem handle, and on Windows is pinned
 //! to `top_level_dir`. None of that applies to `fs.watch()`, and routing `fs.watch()`
 //! through it required a 1k-line shim (the old version of this file) full of
 //! lock-ordering workarounds, a WorkPool directory crawler, and a bolted-on FSEvents
 //! side-channel.
 //!
-//! The Windows backend (`win_watcher.zig`, libuv `uv_fs_event`) never went through
+//! The Windows backend (`win_watcher.rs`, libuv `uv_fs_event`) never went through
 //! `bun.Watcher` and is a quarter of the size; this file gives Linux/macOS/FreeBSD
 //! the same shape:
 //!
 //!   PathWatcherManager        process-global, lazy, owns the OS resource
 //!     ├─ Linux:   one inotify fd + one reader thread, wd → PathWatcher map
-//!     ├─ macOS:   delegates to fs_events.zig (one CFRunLoop thread, one FSEventStream)
+//!     ├─ macOS:   delegates to fs_events.rs (one CFRunLoop thread, one FSEventStream)
 //!     └─ FreeBSD: one kqueue fd + one reader thread, fd → PathWatcher map
 //!
 //!   PathWatcher               one per unique (realpath, recursive) — deduped
@@ -91,12 +91,12 @@ pub(crate) struct PathWatcherManager {
     /// don't share — they want different OS registrations on every platform).
     ///
     /// Interior-mutable: written through `&'static PathWatcherManager` while holding
-    /// `mutex`. Zig's `*PathWatcherManager` aliases freely; in Rust the field must be
-    /// `UnsafeCell` so deriving `&mut` from a shared manager reference is defined.
+    /// `mutex`. The field must be `UnsafeCell` so deriving `&mut` from a shared
+    /// manager reference is defined.
     watchers: UnsafeCell<StringArrayHashMap<*mut PathWatcher>>,
 
     /// Platform-specific dispatch maps (inotify wd_map / kqueue entries).
-    /// On macOS this is empty — FSEvents owns its own thread via `fs_events.zig`.
+    /// On macOS this is empty — FSEvents owns its own thread via `fs_events.rs`.
     /// Interior-mutable for the same reason as `watchers`.
     #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
     platform: UnsafeCell<Platform>,
@@ -159,8 +159,8 @@ impl PathWatcherManager {
             return Ok(m);
         }
 
-        // Process-lifetime singleton (Zig: `var default_manager`). Hand the
-        // allocation off via `heap::release`; it is published into
+        // Process-lifetime singleton. Hand the allocation off via
+        // `heap::release`; it is published into
         // `DEFAULT_MANAGER` below and lives until process exit — except on the
         // `Platform::init` error path, which is the one place it is reclaimed.
         let m: &'static mut PathWatcherManager =
@@ -215,7 +215,7 @@ pub struct PathWatcher {
     is_file: bool,
 
     /// JS `FSWatcher` contexts sharing this OS watch. Each gets its own ChangeEvent
-    /// for per-handler duplicate suppression (same as win_watcher.zig). Guarded by
+    /// for per-handler duplicate suppression (same as `win_watcher.rs`). Guarded by
     /// `manager.mutex` on all platforms — every emit path (inotify/kqueue reader
     /// threads and the Darwin FSEvents callback) holds it while iterating, so
     /// attach/detach can never race with dispatch.
@@ -246,8 +246,8 @@ impl EventType {
 
 /// Per-handler duplicate suppression.
 ///
-/// The predicate is intentionally identical to `win_watcher.zig` and the old
-/// `path_watcher.zig` so POSIX and Windows agree on which bursts are coalesced.
+/// The predicate is intentionally identical to `win_watcher.rs`
+/// so POSIX and Windows agree on which bursts are coalesced.
 /// It suppresses only when, within the same millisecond, *both* the hash and
 /// the event type match the previous emission — arguably too aggressive, but
 /// changing it here would diverge from Windows; fixing all three together is
@@ -282,7 +282,7 @@ pub type Callback = fn(ctx: Option<*mut c_void>, event: Event, is_file: bool);
 pub(crate) type UpdateEndCallback = fn(ctx: Option<*mut c_void>);
 
 impl PathWatcher {
-    /// `bun.TrivialNew(PathWatcher)` — heap-allocate and return raw pointer.
+    /// Heap-allocate and return a raw pointer.
     pub(crate) fn new(init: PathWatcher) -> *mut PathWatcher {
         bun_core::heap::into_raw(Box::new(init))
     }
@@ -421,9 +421,7 @@ pub fn watch(
     update_end: UpdateEndCallback,
     ctx: *mut c_void,
 ) -> sys::Result<*mut PathWatcher> {
-    // The callback/updateEnd are comptime so the emit path can call them directly
-    // without an indirect-call-per-event; assert they're what node_fs_watcher passes.
-    // PERF(port): was comptime monomorphization — Zig asserted at compile time.
+    // Assert the callback/updateEnd are what node_fs_watcher passes.
     // Compare against the *exact* fn pointers `FSWatcher` passes (not local wrappers,
     // which would be distinct fn items with distinct addresses).
     debug_assert!(callback as usize == FSWatcher::ON_PATH_UPDATE as usize);
@@ -575,9 +573,7 @@ pub fn watch(
 /// subdirectories. When `dirs_only`, non-directory entries are skipped entirely
 /// (inotify delivers file events on the parent dir's wd so we only need a watch
 /// per directory; kqueue needs an fd per file too). Best-effort — an unreadable
-/// subdirectory just stops that branch (matches Node). Uses `bun.sys` /
-/// `bun.DirIterator` / `bun.path` throughout; no std.fs.
-// PORT NOTE: ctx+comptime cb collapsed to FnMut closure (same monomorphization).
+/// subdirectory just stops that branch (matches Node).
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
 fn walk_subtree<const DIRS_ONLY: bool>(
     abs_dir: &ZStr,
@@ -606,9 +602,7 @@ fn walk_subtree<const DIRS_ONLY: bool>(
         if DIRS_ONLY && child_is_file {
             continue;
         }
-        // Zig: `bun.DirIterator.iterate(dfd, .u8)` — force-u8 mode so `name.slice()`
-        // is `[]const u8` even on Windows. The Rust iterator caches the UTF-8
-        // transcode and exposes it as `slice_u8()`.
+        // The iterator caches the UTF-8 transcode and exposes it as `slice_u8()`.
         let name = entry.name.slice_u8();
         let child_abs =
             join_z_buf::<platform::Posix>(abs_buf.as_mut_slice(), &[abs_dir.as_bytes(), name]);
@@ -624,7 +618,7 @@ fn walk_subtree<const DIRS_ONLY: bool>(
     }
 }
 
-// Platform dispatch alias (Zig: `const Platform = switch (Environment.os) { ... }`).
+// Platform dispatch alias.
 // Android uses the same inotify backend as Linux (bionic exposes the same
 // `inotify_*` libc surface; the kernel ABI is identical).
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -672,7 +666,7 @@ pub(crate) struct Linux {
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 struct WdOwner {
-    /// Raw `*mut` (Zig: `*PathWatcher`). Stored in a long-lived map and mutated
+    /// Raw `*mut`. Stored in a long-lived map and mutated
     /// (`emit`, `platform.wds`) under `manager.mutex`; a `&PathWatcher` here would
     /// make every write-through a const→mut cast (UB). Lifetime: outlives the entry
     /// because `remove_watch` drops all of a watcher's wd entries before `destroy()`.
@@ -749,7 +743,7 @@ impl Linux {
         manager: &'static PathWatcherManager,
         watcher: &mut PathWatcher,
     ) -> sys::Result<()> {
-        // PORT NOTE: reshaped for borrowck — clone path to avoid &/&mut overlap on watcher.
+        // Borrowck: clone path to avoid &/&mut overlap on watcher.
         let root = watcher.path.clone();
         Linux::add_one(manager, watcher, &root, b"")?;
         if watcher.recursive && !watcher.is_file {
@@ -1059,7 +1053,7 @@ impl Linux {
                             abs_buf.as_mut_slice(),
                             &[watcher_path, owner_subpath, name],
                         );
-                        // PORT NOTE: reshaped for borrowck — `rel` may borrow `path_buf`,
+                        // Borrowck: `rel` may borrow `path_buf`,
                         // which `walk_and_add` also borrows. Own it for the call.
                         let rel_owned: Box<[u8]> = Box::from(rel);
                         // These may rehash `wd_map`; `owners` is re-fetched next iteration.
@@ -1089,9 +1083,9 @@ use bun_watcher::inotify_watcher::Event as InotifyEvent;
 // Darwin
 // ────────────────────────────────────────────────────────────────────────────────
 
-/// macOS: delegate to `fs_events.zig`, which already runs one CFRunLoop thread with
+/// macOS: delegate to `fs_events.rs`, which already runs one CFRunLoop thread with
 /// one FSEventStream covering every watched path. The PathWatcher itself is the
-/// FSEventsWatcher's opaque ctx — `fs_events.zig` calls back via `onFSEvent` below,
+/// FSEventsWatcher's opaque ctx — `fs_events.rs` calls back via `onFSEvent` below,
 /// and we fan out to the JS handlers.
 ///
 /// Unlike the old design, FSEvents is used for both files and directories (same as
@@ -1130,7 +1124,7 @@ impl Darwin {
     /// takes `manager.mutex`). Keeping this call outside `manager.mutex` makes the
     /// lock order one-way: fsevents_loop.mutex → manager.mutex.
     fn add_watch(_: &'static PathWatcherManager, watcher: &mut PathWatcher) -> sys::Result<()> {
-        // PORT NOTE: reshaped for borrowck — capture the raw ctx pointer before the
+        // Borrowck: capture the raw ctx pointer before the
         // shared borrow of `watcher.path` so the two don't overlap at the call site.
         let ctx = core::ptr::from_mut::<PathWatcher>(watcher).cast::<c_void>();
         match fsevents::watch(
@@ -1165,8 +1159,7 @@ impl Darwin {
     /// Takes a raw `*mut PathWatcher`: while we block on the FSEvents loop mutex
     /// inside `deinit`, the CF thread may concurrently take `manager.mutex` and
     /// raw-read `(*watcher).manager` (to bail on `None`). Holding a `&mut PathWatcher`
-    /// across that would be aliased-`&mut` UB under Stacked Borrows; Zig's pointer
-    /// model has no such restriction.
+    /// across that would be aliased-`&mut` UB under Stacked Borrows.
     fn remove_watch(_: &'static PathWatcherManager, watcher: *mut PathWatcher) {
         // SAFETY: caller is the sole logical owner (last handler detached, watcher
         // unlinked from the dedup map, `manager` already nulled). Project only the
@@ -1179,7 +1172,7 @@ impl Darwin {
         }
     }
 
-    /// Called from the CFRunLoop thread (`fs_events.zig`'s `_events_cb`) with the
+    /// Called from the CFRunLoop thread (`fs_events.rs`'s `_events_cb`) with the
     /// FSEvents loop mutex held. Take `manager.mutex` so iterating `handlers` can't
     /// race with `watch()`/`detach()` mutating it. The JS thread never holds
     /// `manager.mutex` across a call into FSEvents, so this is deadlock-free.
@@ -1251,7 +1244,7 @@ pub(crate) struct Kqueue {
 
 #[cfg(target_os = "freebsd")]
 struct KqEntry {
-    /// Raw `*mut` (Zig: `*PathWatcher`). See `WdOwner.watcher` — stored long-lived,
+    /// Raw `*mut`. See `WdOwner.watcher` — stored long-lived,
     /// mutated through (`emit`) under `manager.mutex`; outlives the entry because
     /// `remove_watch` clears all of a watcher's entries before `destroy()`.
     watcher: *mut PathWatcher,
@@ -1309,7 +1302,7 @@ impl Kqueue {
         manager: &'static PathWatcherManager,
         watcher: &mut PathWatcher,
     ) -> sys::Result<()> {
-        // PORT NOTE: reshaped for borrowck — clone path to avoid &/&mut overlap.
+        // Borrowck: clone path to avoid &/&mut overlap.
         let root = watcher.path.clone();
         let is_file = watcher.is_file;
         Kqueue::add_one(manager, watcher, &root, b"", is_file)?;
@@ -1529,5 +1522,3 @@ impl WindowsStub {
     #[allow(dead_code)]
     fn remove_watch(_: &'static PathWatcherManager, _: &mut PathWatcher) {}
 }
-
-// ported from: src/runtime/node/path_watcher.zig
diff --git a/src/runtime/node/time_like.rs b/src/runtime/node/time_like.rs
index 3ecc8b3424a..afcc814ea75 100644
--- a/src/runtime/node/time_like.rs
+++ b/src/runtime/node/time_like.rs
@@ -6,8 +6,6 @@ use bun_jsc::{JSGlobalObject, JSType as JsType, JSValue, JsResult};
 pub type TimeLike = f64;
 #[cfg(not(windows))]
 pub type TimeLike = libc::timespec;
-// TODO(port): Zig's `std.posix.timespec` uses field names `sec`/`nsec`; libc::timespec
-// uses `tv_sec`/`tv_nsec`. Confirm bun_sys exposes a wrapper or stick with libc.
 
 const NS_PER_S: f64 = bun_core::time::NS_PER_S as f64;
 #[cfg(not(windows))]
@@ -59,7 +57,7 @@ fn from_seconds(seconds: f64) -> TimeLike {
 #[cfg(not(windows))]
 fn from_seconds(seconds: f64) -> TimeLike {
     libc::timespec {
-        // PORT NOTE: Rust `as` saturates on overflow/NaN where Zig @intFromFloat is UB.
+        // `as` saturates on overflow/NaN.
         tv_sec: seconds as _,
         tv_nsec: (seconds.rem_euclid(1.0) * NS_PER_S) as _,
     }
@@ -121,5 +119,3 @@ fn from_now() -> TimeLike {
         tv_nsec: bun_sys::c::UTIME_NOW as _,
     }
 }
-
-// ported from: src/runtime/node/time_like.zig
diff --git a/src/runtime/node/types.rs b/src/runtime/node/types.rs
index 955167b124c..17dee2dccbe 100644
--- a/src/runtime/node/types.rs
+++ b/src/runtime/node/types.rs
@@ -20,8 +20,8 @@ pub use jsc::MarkedArrayBuffer as Buffer;
 pub use jsc::ArgumentsSlice;
 
 // LAYERING: `Fd::{from_js,from_js_validated,to_js}` are provided by the
-// canonical `bun_sys_jsc::FdJsc` extension trait (full range/type validation
-// per Zig `bun.FD.fromJSValidated`). Re-exported so existing
+// canonical `bun_sys_jsc::FdJsc` extension trait (full range/type
+// validation). Re-exported so existing
 // `crate::node::types::FdJsc` import paths keep resolving.
 pub use bun_sys_jsc::FdJsc;
 
@@ -280,7 +280,7 @@ impl Drop for StringOrBuffer {
 }
 
 impl bun_jsc::Unprotect for BlobOrStringOrBuffer {
-    /// Zig `BlobOrStringOrBuffer.deinitAndUnprotect`, JS-side half — owned
+    /// JS-side half of cleanup — owned
     /// payloads are released by `Drop` (which runs next when held in a
     /// [`bun_jsc::ThreadSafe`]).
     #[inline]
@@ -292,7 +292,7 @@ impl bun_jsc::Unprotect for BlobOrStringOrBuffer {
 }
 
 impl bun_jsc::Unprotect for StringOrBuffer {
-    /// Zig `StringOrBuffer.deinitAndUnprotect`, JS-side half — undo the
+    /// JS-side half of cleanup — undo the
     /// `protect()` taken by [`StringOrBuffer::to_thread_safe`] /
     /// `from_js_maybe_async(.., is_async=true)`. Owned slices are released by
     /// `Drop`.
@@ -313,7 +313,6 @@ impl StringOrBuffer {
         match self {
             Self::String(s) => {
                 s.to_thread_safe();
-                // PORT NOTE: reshaped for borrowck — Zig moves the payload between variants.
                 let str = core::mem::take(s);
                 *self = Self::ThreadsafeString(str);
             }
@@ -357,7 +356,6 @@ impl StringOrBuffer {
             Self::ThreadsafeString(str) | Self::String(str) => str.transfer_to_js(ctx),
             Self::EncodedSlice(encoded_slice) => {
                 let result = jsc::bun_string_jsc::create_utf8_for_js(ctx, encoded_slice.slice());
-                // Zig: `defer { this.encoded_slice.deinit(); this.encoded_slice = .{}; }`
                 *encoded_slice = ZigStringSlice::default();
                 result
             }
@@ -370,7 +368,7 @@ impl StringOrBuffer {
         }
     }
 
-    /// Zig `StringOrBuffer.protect` — mirrors `to_thread_safe` but only
+    /// Mirrors `to_thread_safe` but only
     /// protects the JS-side buffer value (no string conversion).
     #[inline]
     pub fn protect(&self) {
@@ -390,7 +388,7 @@ impl StringOrBuffer {
     }
 
     /// Out-param core of [`from_js_maybe_async`]. Writes the decoded payload
-    /// directly into `*out` (Zig result-location semantics) and returns
+    /// directly into `*out` and returns
     /// `Ok(true)` on success, `Ok(false)` if `value` is not a string/buffer
     /// type. `*out` is left untouched on `Ok(false)` / `Err`.
     ///
@@ -425,7 +423,7 @@ impl StringOrBuffer {
                     str.deref();
 
                     if sliced.underlying.is_empty() {
-                        // PORT NOTE: partial-move out of `SliceWithUnderlyingString` —
+                        // partial-move out of `SliceWithUnderlyingString` —
                         // take `utf8` and leave the rest defaulted (no Drop on the type).
                         *out = Self::EncodedSlice(core::mem::take(&mut sliced.utf8));
                         return Ok(true);
@@ -633,7 +631,7 @@ impl StringOrBuffer {
     }
 }
 
-// `bun.String.encode` — see `crate::webcore::encoding::BunStringEncode`.
+// String encoding — see `crate::webcore::encoding::BunStringEncode`.
 
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -656,8 +654,7 @@ pub enum Encoding {
     Buffer,
 }
 
-// PORT NOTE: Zig used `ComptimeStringMap` (`fromJSCaseInsensitive` /
-// `inMapCaseInsensitive`). With only 13 short keys spread across 7 distinct
+// With only 13 short keys spread across 7 distinct
 // lengths (max 4 keys at len==6) a length-gated byte match beats a
 // `phf::Map`'s hash+probe — see `Encoding::from` below. The case-insensitive
 // entry points lowercase into a stack buffer first.
@@ -706,7 +703,7 @@ impl Encoding {
 
     /// Caller must verify the value is a string
     pub fn from(slice: &[u8]) -> Option<Encoding> {
-        // PERF(port): length-gated match in lieu of `phf::Map` — 13 keys over
+        // PERF: length-gated match in lieu of `phf::Map` — 13 keys over
         // 7 distinct lengths (3..=9, max 4 collisions at len 6). The outer
         // `match len` rejects almost every miss on a single `usize` compare;
         // the inner byte compares are at known fixed lengths so LLVM lowers
@@ -761,7 +758,7 @@ impl Encoding {
 
 impl Encoding {
     pub fn from_js(value: JSValue, global: &JSGlobalObject) -> JsResult<Option<Encoding>> {
-        // PORT NOTE: ComptimeStringMap::fromJSCaseInsensitive — emulated via
+        // ComptimeStringMap::fromJSCaseInsensitive — emulated via
         // `from_bun_string` (stack-buffer narrow + length-gated match; no
         // `to_utf8()` allocation needed for a ≤9-byte ASCII key).
         let str = bun_core::OwnedString::new(bun_core::String::from_js(value, global)?);
@@ -811,13 +808,8 @@ impl Encoding {
             .throw()
     }
 
-    /// Zig `encodeWithSize(comptime size, *const [size]u8)`. In Zig the two
-    /// `encodeWith*` fns differed only in their comptime stack-buffer size
-    /// (`[size*4]u8` vs `[max_size*4]u8`); in Rust both heap-allocate, so the
-    /// match-arm bodies were byte-identical for Base64url/Hex/Buffer/else and
-    /// `size` was unused past the assert. Collapsed into a thin assertion
-    /// wrapper. Kept for Zig-port symmetry; currently has no Rust callers
-    /// (CryptoHasher.rs ported all sites to `encode_with_max_size`).
+    /// Thin assertion wrapper over `encode_with_max_size`; currently has no
+    /// callers (CryptoHasher.rs uses `encode_with_max_size` directly).
     #[inline]
     pub fn encode_with_size(
         self,
@@ -829,8 +821,8 @@ impl Encoding {
         self.encode_with_max_size(global_object, size, input)
     }
 
-    /// Zig `encodeWithMaxSize(comptime max_size, []const u8)`. `max_size` is a
-    /// runtime arg (see `encode_with_size`); callers pass `EVP_MAX_MD_SIZE` etc.
+    /// `max_size` is a runtime arg (see `encode_with_size`); callers pass
+    /// `EVP_MAX_MD_SIZE` etc.
     pub fn encode_with_max_size(
         self,
         global_object: &JSGlobalObject,
@@ -843,8 +835,8 @@ impl Encoding {
             input.len(),
             max_size,
         );
-        // PERF(port): Zig used comptime-sized stack buffers; stable Rust forbids
-        // const-generic arithmetic in array lengths, so we heap-allocate.
+        // Stable Rust forbids const-generic arithmetic in array lengths, so
+        // we heap-allocate.
         match self {
             Self::Base64 => {
                 let encoded_len = bun_core::base64::encode_len(input);
@@ -862,7 +854,6 @@ impl Encoding {
                 Ok(jsc::zig_string::ZigString::init(&buf).to_js(global_object))
             }
             Self::Hex => {
-                // PORT NOTE: Zig used `bufPrint("{x}", input)` into a stack buffer.
                 // The byte-by-byte `write!` formatting machinery is pathologically
                 // slow in debug builds, so encode via LUT directly into the
                 // destination JS string buffer.
@@ -878,7 +869,6 @@ impl Encoding {
                 encoded.transfer_to_js(global_object)
             }
             Self::Buffer => jsc::ArrayBuffer::create_buffer(global_object, input),
-            // PERF(port): was comptime monomorphization (`inline else`) — profile if it shows up on a hot path
             enc => crate::webcore::encoding::to_string(input, global_object, enc),
         }
     }
@@ -889,7 +879,8 @@ impl Encoding {
     }
 }
 
-// TODO(port): move to runtime_sys
+// Externs stay in this crate per PORTING.md §FFI: "If your file has externs
+// and isn't already *_sys, leave them in place".
 unsafe extern "C" {
     safe fn WebCore_BufferEncodingType_toJS(
         global_object: &JSGlobalObject,
@@ -920,8 +911,6 @@ pub enum PathOrBuffer {
 impl PathOrBuffer {
     #[inline]
     pub fn slice(&self) -> &[u8] {
-        // PORT NOTE: Zig only ever returns `self.path.slice()` here regardless of variant —
-        // preserved verbatim (likely a latent bug or this type is unused).
         match self {
             Self::Path(p) => p.slice(),
             Self::Buffer(_) => unreachable!("Zig accessed .path unconditionally"),
@@ -934,12 +923,8 @@ impl PathOrBuffer {
 pub struct CallbackTask<Result> {
     pub callback: jsc::C::JSObjectRef,
     pub option: CallbackTaskOption<Result>,
-    pub success: bool,
 }
 
-// PORT NOTE: Zig uses an untagged `union` discriminated by `success: bool`.
-// Represented here as a Rust enum; callers must keep `success` in sync.
-// TODO(refactor): drop the redundant `success` field entirely.
 pub enum CallbackTaskOption<Result> {
     Err(Box<bun_sys::SystemError>),
     Result(Result),
@@ -950,13 +935,11 @@ where
     CallbackTaskOption<Result>: Default,
 {
     fn default() -> Self {
-        // Zig only sets `success = false` and leaves the rest `undefined`;
-        // Rust requires every field initialized, so zero the callback handle
+        // Zero the callback handle
         // and lean on the `CallbackTaskOption<Result>: Default` bound.
         Self {
             callback: core::ptr::null_mut(),
             option: Default::default(),
-            success: false,
         }
     }
 }
@@ -975,7 +958,7 @@ pub use bun_jsc::node_path::{PathLike, PathOrFileDescriptor};
 /// fit a `WPathBuffer` (`strings::fits_in_wide_path_buffer`). NT caps paths
 /// at `PATH_MAX_WIDE` units, so such a path cannot exist on disk — callers
 /// map this to `false`/`ENAMETOOLONG` as appropriate instead of letting the
-/// conversion overflow (mirrors the Zig-side fix in oven-sh/bun#27775).
+/// conversion overflow (oven-sh/bun#27775).
 #[derive(Debug, Clone, Copy)]
 pub struct NameTooLong;
 
@@ -1055,9 +1038,9 @@ pub(crate) trait PathOrFdExt {
 }
 
 impl PathLikeExt for PathLike {
-    // TODO(port): Zig return type is `if (force) [:0]u8 else [:0]const u8`.
-    // Rust const-generics can't change return mutability; we always return `&ZStr`.
-    // The single force=true caller (if any) needs `&mut ZStr` — handle if it comes up.
+    // Const-generics can't change return mutability, so this always returns
+    // `&ZStr`. A future force=true caller that needs `&mut ZStr` will need a
+    // separate method.
     fn slice_z_with_force_copy<'a, const FORCE: bool>(
         &'a self,
         buf: &'a mut PathBuffer,
@@ -1096,7 +1079,7 @@ impl PathLikeExt for PathLike {
                     // SAFETY: buf[4+n] == 0 written above.
                     return ZStr::from_buf(&buf[..], 4 + n);
                 }
-                // PORT NOTE: reshaped for borrowck — capture the length so
+                // reshaped for borrowck — capture the length so
                 // the `Ok` borrow ends at the match, then re-derive.
                 let resolved_len = match bun_paths::resolve_path::PosixToWinNormalizer::resolve_cwd_with_external_buf_z(buf, sliced) {
                     Ok(res) => Some(res.len()),
@@ -1201,8 +1184,8 @@ impl PathLikeExt for PathLike {
                     return Err(NameTooLong);
                 }
                 // SAFETY: reinterpreting PathBuffer ([u8; N]) as [u16] — 2-byte
-                // alignment is runtime-asserted inside `bytes_as_slice_mut`
-                // (port of Zig `@alignCast`); see PathBuffer doc comment for
+                // alignment is runtime-asserted inside `bytes_as_slice_mut`;
+                // see PathBuffer doc comment for
                 // why the buffer is always sufficiently aligned in practice.
                 let buf_u16 = unsafe { bun_core::bytes_as_slice_mut::<u16>(&mut buf[..]) };
                 return Ok(strings::to_kernel32_path(buf_u16, s));
@@ -1388,7 +1371,6 @@ impl PathLikeExt for PathLike {
         str: &mut bun_core::String,
         will_be_async: bool,
     ) -> JsResult<PathLike> {
-        // TODO(port): narrow error set
         if will_be_async {
             let sliced = str.to_thread_safe_slice();
             let sliced = scopeguard::guard(sliced, |s| s.deinit());
@@ -1507,7 +1489,7 @@ impl Valid {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct VectorArrayBuffer {
-    // PORT NOTE: bare JSValue field — only sound while this lives on the stack.
+    // bare JSValue field — only sound while this lives on the stack.
     // Stored in a stack-local during writev; never heap-allocated.
     pub value: JSValue,
     pub buffers: Vec<PlatformIoVec>,
@@ -1692,11 +1674,11 @@ pub fn mode_from_js(ctx: &JSGlobalObject, value: JSValue) -> JsResult<Option<Mod
 // `crate::node::types::PathOrFileDescriptorSerializeTag` paths keep resolving.
 pub use bun_jsc::node_path::PathOrFileDescriptorSerializeTag;
 
-// PORT NOTE: Zig copies these tagged unions by value freely; the Rust port adds
-// `Drop` for the path-owning variants, so an explicit `dupe()` is provided for
+// The path-owning variants have
+// `Drop`, so an explicit `dupe()` is provided for
 // callers (Blob, Store::File) that need a fresh copy. Ref-counting variants are
 // bumped where the underlying type supports it; otherwise we bitwise-copy
-// (matching Zig semantics) and leave proper ref-counting to a later pass.
+// and leave proper ref-counting to a later pass.
 
 impl PathOrFdExt for PathOrFileDescriptor {
     fn from_js(
@@ -1725,7 +1707,7 @@ impl PathOrFdExt for PathOrFileDescriptor {
 
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Non-exhaustive enum in Zig (`enum(c_int) { ... _ }`) → newtype over c_int.
+/// Non-exhaustive set of flag values; newtype over c_int.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub struct FileSystemFlags(pub c_int);
@@ -1737,10 +1719,9 @@ pub enum FileSystemFlagsKind {
 }
 
 impl FileSystemFlags {
-    // PORT NOTE: `pub type TagType = c_int;` would be an inherent associated
+    // `pub type TagType = c_int;` would be an inherent associated
     // type (unstable). Dropped — callers use `c_int` directly.
 
-    // Named variants from the Zig enum:
     /// Open file for appending. The file is created if it does not exist.
     pub const A: Self = Self(O::APPEND | O::WRONLY | O::CREAT);
     /// Open file for reading. An exception occurs if the file does not exist.
@@ -1802,14 +1783,12 @@ impl FileSystemFlags {
             }
 
             let flags: Option<i32> = 'brk: {
-                // PERF(port): was comptime bool dispatch (`inline else`) — profile if it shows up on a hot path
                 if str.is_16bit() {
                     let chars = str.utf16_slice_aligned();
                     if (chars[0] as u8).is_ascii_digit() {
                         // node allows "0o644" as a string :(
                         let slice = str.to_slice();
                         // slice.deinit() on Drop
-                        // Zig: `@as(i32, @intCast(...))` — release builds wrap.
                         break 'brk strings::parse_int::<Mode>(slice.slice(), 10)
                             .ok()
                             .map(|v| v as i32);
@@ -1821,7 +1800,6 @@ impl FileSystemFlags {
                     }
                 }
 
-                // PORT NOTE: Zig used `ComptimeStringMap.getWithEql(str, ZigString.eqlComptime)`.
                 // Convert the ZigString (≤12 bytes here) to a UTF-8 slice and
                 // dispatch through the length-gated match below.
                 let key_slice = str.to_slice();
@@ -1842,9 +1820,6 @@ impl FileSystemFlags {
     }
 
     /// Equivalent of GetValidFileMode, which is used to implement fs.access and copyFile
-    // PORT NOTE: Zig took `comptime kind: enum { access, copy_file }`; lowered to a
-    // runtime arg here so callers (`node_fs.rs`) can pass it positionally without
-    // needing `adt_const_params` const-generic dispatch.
     pub fn from_js_number_only(
         global: &JSGlobalObject,
         value: JSValue,
@@ -1873,7 +1848,6 @@ impl FileSystemFlags {
                 return Err(global
                     .err(
                         jsc::ErrorCode::OUT_OF_RANGE,
-                        // Zig: comptime std.fmt.comptimePrint — MIN/MAX are literal consts; emit as &'static str.
                         format_args!("mode is out of range: >= 0 and <= 7"),
                     )
                     .throw());
@@ -1885,7 +1859,6 @@ impl FileSystemFlags {
                 return Err(global
                     .err(
                         jsc::ErrorCode::OUT_OF_RANGE,
-                        // Zig: comptime std.fmt.comptimePrint — MIN/MAX are literal consts; emit as &'static str.
                         format_args!("mode is out of range: >= 0 and <= 7"),
                     )
                     .throw());
@@ -1895,7 +1868,6 @@ impl FileSystemFlags {
     }
 }
 
-// PERF(port): Zig used `ComptimeStringMap.getWithEql(str, ZigString.eqlComptime)`.
 // A 44-entry `phf::Map` would work, but the keys are tiny (1..=3 bytes) and
 // cluster heavily by length (6/22/16). phf's hash+probe is dominated by the
 // SipHash of the input slice; a length-gated byte match rejects on a single
@@ -1987,7 +1959,8 @@ pub struct Dirent {
 
 pub type DirentKind = bun_sys::FileKind;
 
-// TODO(port): move to runtime_sys
+// Externs stay in this crate per PORTING.md §FFI: "If your file has externs
+// and isn't already *_sys, leave them in place".
 // `&JSGlobalObject` / `&mut bun_core::String` are ABI-identical to non-null
 // pointers; `Option<&mut *mut JSString>` uses the niche-optimization layout
 // (`*mut *mut JSString`), so the validity proof lives in the type signature.
@@ -2088,5 +2061,3 @@ impl PathOrBlob {
         ))
     }
 }
-
-// ported from: src/runtime/node/types.zig
diff --git a/src/runtime/node/util/parse_args.rs b/src/runtime/node/util/parse_args.rs
index 69a73238bf0..7357928256a 100644
--- a/src/runtime/node/util/parse_args.rs
+++ b/src/runtime/node/util/parse_args.rs
@@ -992,7 +992,6 @@ fn parse_args_impl(
 
     // Phase 0.C: Parse the options definitions
 
-    // PERF(port): was stack-fallback (std.heap.stackFallback(2048, ...)) — profile if hot.
     let mut option_defs: Vec<OptionDefinition> = Vec::new();
 
     if !config_options.is_undefined_or_null() {
@@ -1071,5 +1070,3 @@ fn parse_args_impl(
     result.put(global, ZigString::static_("positionals"), state.positionals);
     Ok(result)
 }
-
-// ported from: src/runtime/node/util/parse_args.zig
diff --git a/src/runtime/node/util/parse_args_utils.rs b/src/runtime/node/util/parse_args_utils.rs
index c7517ccc430..394b0c8170e 100644
--- a/src/runtime/node/util/parse_args_utils.rs
+++ b/src/runtime/node/util/parse_args_utils.rs
@@ -126,9 +126,9 @@ pub(crate) fn is_option_like_value(value: &String) -> bool {
 /// Find the long option associated with a short option. Looks for a configured
 /// `short` and returns the short option itself if a long option is not found.
 /// Example:
-/// ```zig
-/// findOptionByShortName('a', {}) // returns 'a'
-/// findOptionByShortName('b', {
+/// ```text
+/// find_option_by_short_name('a', {}) // returns 'a'
+/// find_option_by_short_name('b', {
 ///   options: { bar: { short: 'b' } }
 /// }) // returns "bar"
 /// ```
@@ -147,5 +147,3 @@ pub(crate) fn find_option_by_short_name(
     }
     long_option_index
 }
-
-// ported from: src/runtime/node/util/parse_args_utils.zig
diff --git a/src/runtime/node/util/validators.rs b/src/runtime/node/util/validators.rs
index 278406e0fb2..1c4553eaa87 100644
--- a/src/runtime/node/util/validators.rs
+++ b/src/runtime/node/util/validators.rs
@@ -18,7 +18,6 @@ pub(crate) fn throw_err_invalid_arg_value(
     global_this: &JSGlobalObject,
     args: fmt::Arguments<'_>,
 ) -> JsError {
-    // Zig: `global.ERR(.INVALID_ARG_VALUE, fmt, args).throw()` — TypeError with `.code = "ERR_INVALID_ARG_VALUE"`.
     global_this
         .err(jsc::ErrorCode::INVALID_ARG_VALUE, args)
         .throw()
@@ -29,16 +28,12 @@ pub(crate) fn throw_err_invalid_arg_type_with_message(
     global_this: &JSGlobalObject,
     args: fmt::Arguments<'_>,
 ) -> JsError {
-    // Zig: `global.ERR(.INVALID_ARG_TYPE, fmt, args).throw()` — TypeError with `.code = "ERR_INVALID_ARG_TYPE"`.
     global_this
         .err(jsc::ErrorCode::INVALID_ARG_TYPE, args)
         .throw()
 }
 
-// PORT NOTE: Zig took `comptime name_fmt: string, name_args: anytype` and did
-// comptime string concatenation (`"The \"" ++ name_fmt ++ "\" ..."`) plus tuple
-// concatenation (`name_args ++ .{expected_type, actual_type}`). Rust cannot
-// concat a caller-supplied format string at compile time, so callers pass the
+// Callers pass the
 // already-formatted name as anything `Display`-able (e.g. `&str` or
 // `format_args!(...)`) and we embed it via `{}`.
 #[cold]
@@ -60,7 +55,6 @@ pub(crate) fn throw_err_invalid_arg_type(
 
 #[cold]
 pub(crate) fn throw_range_error(global_this: &JSGlobalObject, args: fmt::Arguments<'_>) -> JsError {
-    // Zig: `global.ERR(.OUT_OF_RANGE, fmt, args).throw()` — RangeError with `.code = "ERR_OUT_OF_RANGE"`.
     global_this.err(jsc::ErrorCode::OUT_OF_RANGE, args).throw()
 }
 
@@ -100,10 +94,8 @@ fn throw_range_error_min_max<V: bun_core::fmt::OutOfRangeValue>(
     )
 }
 
-// PORT NOTE: Zig had `comptime min_value: ?i64, comptime max_value: ?i64` with a
-// `comptime { @compileError }` bounds check. `Option<i64>` is not a valid const-
-// generic type on stable, so demoted to runtime params + debug_assert.
-// PERF(port): was comptime monomorphization.
+// `Option<i64>` is not a valid const-generic type on stable, so the bounds
+// are runtime params + debug_assert.
 pub(crate) fn validate_integer(
     global_this: &JSGlobalObject,
     value: JSValue,
@@ -243,7 +235,6 @@ pub(crate) fn validate_uint32(
             ),
         ));
     }
-    // Zig: @truncate(@as(u63, @intCast(num))) — bounds check above guarantees 0..=u32::MAX.
     Ok(num as u32)
 }
 
@@ -359,7 +350,6 @@ impl ValidateObjectOptions {
     }
 }
 
-// PERF(port): `options` was `comptime` in Zig (monomorphized per call site).
 pub(crate) fn validate_object(
     global_this: &JSGlobalObject,
     value: JSValue,
@@ -432,7 +422,6 @@ pub(crate) fn validate_array(
         ));
     }
     if let Some(min_length) = min_length {
-        // PORT NOTE: Zig compared `usize < ?i32` (peer-type widened); cast to i64 to match.
         if (value.get_length(global_this)? as i64) < i64::from(min_length) {
             return Err(throw_err_invalid_arg_value(
                 global_this,
@@ -498,14 +487,13 @@ pub(crate) fn validate_function(
     Ok(value)
 }
 
-/// Zig used `@typeInfo(T).@"enum".fields` to iterate variants and match by
-/// `@tagName`. Rust has no field reflection; enums opt in via this trait.
+/// Rust has no field reflection; enums opt in via this trait.
 /// Implementors should typically `#[derive(strum::EnumString, strum::VariantNames)]`
 /// and provide `VALUES_INFO` as the `|`-joined variant names.
 pub(crate) trait StringEnum: Sized {
-    /// `|`-joined list of variant names (matches Zig's comptime-built `values_info`).
+    /// `|`-joined list of variant names.
     const VALUES_INFO: &'static str;
-    /// Match `s` against variant names exactly (Zig: `str.eqlComptime(field.name)`).
+    /// Match `s` against variant names exactly.
     fn from_bun_string(s: &bun_core::String) -> Option<Self>;
 }
 
@@ -514,7 +502,7 @@ pub(crate) fn validate_string_enum<T: StringEnum>(
     value: JSValue,
     name: impl fmt::Display,
 ) -> JsResult<T> {
-    // Zig: `defer str.deref()`. `bun_core::String` is `Copy` with no `Drop`;
+    // `bun_core::String` is `Copy` with no `Drop`;
     // `OwnedString` is the RAII guard that releases the +1 ref on scope exit.
     let str = bun_core::OwnedString::new(value.to_bun_string(global_this)?);
     if let Some(v) = T::from_bun_string(&str) {
@@ -526,5 +514,3 @@ pub(crate) fn validate_string_enum<T: StringEnum>(
         format_args!("{} must be one of: {}", name, T::VALUES_INFO),
     ))
 }
-
-// ported from: src/runtime/node/util/validators.zig
diff --git a/src/runtime/node/uv_signal_handle_windows.rs b/src/runtime/node/uv_signal_handle_windows.rs
index aafdbb32189..a958a708d77 100644
--- a/src/runtime/node/uv_signal_handle_windows.rs
+++ b/src/runtime/node/uv_signal_handle_windows.rs
@@ -70,5 +70,3 @@ pub(crate) extern "C" fn Bun__UVSignalHandle__close(
     unsafe { libuv::uv_close(signal.cast(), Some(free_with_default_allocator)) };
     core::ptr::null_mut()
 }
-
-// ported from: src/runtime/node/uv_signal_handle_windows.zig
diff --git a/src/runtime/node/win_watcher.rs b/src/runtime/node/win_watcher.rs
index 95ac6d11383..f5e95022b99 100644
--- a/src/runtime/node/win_watcher.rs
+++ b/src/runtime/node/win_watcher.rs
@@ -1,6 +1,4 @@
 //! Windows-only filesystem watcher backed by libuv `uv_fs_event_t`.
-//!
-//! Port of `src/runtime/node/win_watcher.zig`.
 
 #![cfg(windows)]
 
@@ -18,9 +16,7 @@ use bun_sys::windows::libuv::UvHandle as _;
 use bun_threading::Mutex;
 
 use super::path_watcher::EventType;
-// Zig: `const onPathUpdateFn = jsc.Node.fs.Watcher.onPathUpdate;` (win_watcher.zig:306) —
-// the callbacks are *associated functions* on `FSWatcher`, not free fns.
-// lower_snake names mirror the Zig `onPathUpdateFn`/`onUpdateEndFn` decls.
+// The callbacks are *associated functions* on `FSWatcher`, not free fns.
 use crate::node::node_fs_watcher::{Event, FSWatcher, StringOrBytesToDecode};
 #[allow(non_upper_case_globals)]
 const on_path_update_fn: fn(Option<*mut c_void>, Event, bool) = FSWatcher::ON_PATH_UPDATE;
@@ -28,16 +24,20 @@ const on_path_update_fn: fn(Option<*mut c_void>, Event, bool) = FSWatcher::ON_PA
 const on_update_end_fn: fn(Option<*mut c_void>) = FSWatcher::on_update_end;
 
 bun_output::declare_scope!(PathWatcherManager, visible);
-// Zig scope name is `.@"fs.watch"`; Rust identifiers cannot contain '.'.
-// TODO(port): declare_scope! should accept the original "fs.watch" string for BUN_DEBUG env matching.
-bun_output::declare_scope!(fs_watch, visible);
+// Rust identifiers cannot contain '.', so
+// the static is declared by hand (instead of via `declare_scope!`) with the
+// tag string, keeping `BUN_DEBUG_fs.watch` env matching and the
+// `[fs.watch]` log prefix.
+#[allow(non_upper_case_globals)]
+pub static fs_watch: bun_output::ScopedLogger =
+    bun_output::ScopedLogger::new("fs.watch", bun_output::Visibility::Visible);
 
 // ──────────────────────────────────────────────────────────────────────────
 
 // PORTING.md §Global mutable state: singleton ptr → `AtomicCell`, guarded by
 // `DEFAULT_MANAGER_MUTEX`. `fs.watch()` is reachable from Worker JS threads
-// (each Worker is its own OS thread + VM), so the unguarded read+write the
-// Zig original gets away with is a data race in Rust. Mirror the posix
+// (each Worker is its own OS thread + VM), so an unguarded read+write
+// would be a data race. Mirror the posix
 // `path_watcher.rs` pattern: every `DEFAULT_MANAGER` access holds the mutex.
 // `AtomicCell<*mut _>` (Acquire/Release on the pointer word) means even an
 // unsynchronized racing reader observes either null or a fully-published
@@ -56,12 +56,12 @@ static DEFAULT_MANAGER_MUTEX: Mutex = Mutex::new();
 // TODO: make this a generic so we can reuse code with path_watcher
 // TODO: we probably should use native instead of libuv abstraction here for better performance
 pub(crate) struct PathWatcherManager {
-    // Keys are owned path bytes (Zig: `bun.StringArrayHashMapUnmanaged`), values are raw heap
+    // Keys are owned path bytes, values are raw heap
     // PathWatcher ptrs. `StringArrayHashMap` lets `get`/`insert` take `&[u8]` borrows.
     watchers: StringArrayHashMap<*mut PathWatcher>,
     // LIFETIMES.tsv: JSC_BORROW → `&VirtualMachine`. The manager is heap-allocated and stored in a
-    // process-global, so we spell the borrow as `'static`.
-    // TODO(port): revisit once VirtualMachine lifetime plumbing lands in bun_jsc.
+    // process-global, so we spell the borrow as `'static`; soundness relies on
+    // the owning VM outliving the manager (watchers are torn down before the VM).
     vm: &'static jsc::VirtualMachineRef,
     deinit_on_last_watcher: bool,
 }
@@ -96,8 +96,7 @@ impl PathWatcherManager {
             self.watchers.swap_remove_at(index);
         }
 
-        // Zig: `defer { if (deinit_on_last_watcher and count == 0) this.deinit(); }`.
-        // No early returns above, so this runs in the same place a defer would — and avoids the
+        // No early returns above, so this runs unconditionally — and avoids the
         // overlapping `&mut self` borrow a closure-based guard would require.
         if self.deinit_on_last_watcher && self.watchers.len() == 0 {
             // SAFETY: self was heap-allocated in `init`; no other live borrows after this point.
@@ -160,7 +159,6 @@ pub(crate) struct ChangeEvent {
 
 impl Default for ChangeEvent {
     fn default() -> Self {
-        // Match Zig field defaults: `hash = 0`, `event_type = .change`, `timestamp = 0`.
         Self {
             hash: 0,
             event_type: EventType::Change,
@@ -224,13 +222,11 @@ impl PathWatcher {
             this.emit_in_progress = true;
 
             for &ctx in this.handlers.keys() {
-                // Zig: `bun.sys.Error` is a value type — implicitly copied per handler.
                 on_path_update_fn(Some(ctx), Event::Error(err.clone()), false);
                 on_update_end_fn(Some(ctx));
             }
 
-            // Zig: `defer this.emit_in_progress = false;` fires AFTER `this.maybeDeinit()`, so
-            // the guard is still `true` when `maybeDeinit` checks it (always a no-op there).
+            // The guard is still `true` when `maybe_deinit` checks it (always a no-op there).
             this.maybe_deinit();
             this.emit_in_progress = false;
             return;
@@ -247,7 +243,7 @@ impl PathWatcher {
             return;
         };
 
-        // @truncate — intentional wrap to bun_watcher::HashType
+        // Intentional wrap to bun_watcher::HashType
         let hash = this.handle.hash(path.as_bytes(), events, status) as bun_watcher::HashType;
         let is_file = !this.handle.is_dir();
         this.emit(
@@ -275,23 +271,17 @@ impl PathWatcher {
         #[cfg(debug_assertions)]
         let mut debug_count: usize = 0;
 
-        // PORT NOTE: reshaped for borrowck — Zig iterates `values()` while indexing `keys()[i]`;
-        // here we snapshot `keys()` length-contract via index iteration.
         for i in 0..self.handlers.len() {
             let event = &mut self.handlers.values_mut()[i];
             if event.emit(hash, timestamp, event_type) {
                 let ctx: *mut FSWatcher = self.handlers.keys()[i].cast::<FSWatcher>();
                 // SAFETY: handlers keys are `*mut FSWatcher` erased to `*mut c_void` in `watch()`.
                 let encoding = unsafe { (*ctx).encoding };
-                // Zig builds the tagged payload `{ .string | .bytes_to_free }` then calls
-                // `event_type.toEvent(..)` — `EventPathString` on Windows is `StringOrBytesToDecode`.
+                // `EventPathString` on Windows is `StringOrBytesToDecode`.
                 let payload = match encoding {
                     crate::node::Encoding::Utf8 => {
                         StringOrBytesToDecode::String(BunString::clone_utf8(path))
                     }
-                    // Zig: `bun.default_allocator.dupeZ(u8, path)` — owned copy; the trailing NUL is
-                    // a sentinel only (slice `.len` excludes it), so `Box<[u8]>::from(path)` is the
-                    // semantic equivalent for the Rust `BytesToFree` payload.
                     _ => StringOrBytesToDecode::BytesToFree(Box::<[u8]>::from(path)),
                 };
                 on_path_update_fn(Some(ctx.cast()), event_type.to_event(payload), is_file);
@@ -324,9 +314,9 @@ impl PathWatcher {
         recursive: bool,
     ) -> sys::Result<*mut PathWatcher> {
         let mut outbuf = PathBuffer::uninit();
-        // Windows `sys::readlink` returns the byte length (`Maybe<usize>`); the link target is
+        // Windows `sys::readlink` returns the byte length; the link target is
         // written into `outbuf[..len]` with `outbuf[len] == 0` (sys_uv NUL-terminates). Reconstruct
-        // the `[:0]const u8` Zig sees from `Maybe([:0]u8)` via `ZStr::from_buf`.
+        // the NUL-terminated string via `ZStr::from_buf`.
         let readlink_result = sys::readlink(path, &mut outbuf);
         let event_path: &ZStr = match readlink_result {
             sys::Result::Err(err) => 'brk: {
@@ -345,9 +335,6 @@ impl PathWatcher {
         // BACKREF field stays raw (LIFETIMES.tsv); capture the pointer once before further &mut use.
         let manager_ptr: *mut PathWatcherManager = manager as *mut PathWatcherManager;
 
-        // PORT NOTE: reshaped for borrowck — Zig uses `getOrPut` with a borrowed key, then
-        // overwrites `key_ptr.*` with an owned dupe on the not-found path. Rust maps own their
-        // keys, so we do lookup-then-insert instead.
         if let Some(&existing) = manager.watchers.get(event_path.as_bytes()) {
             return sys::Result::Ok(existing);
         }
@@ -388,11 +375,9 @@ impl PathWatcher {
             )
         };
         if let Some(err) = start_rc.to_error(sys::Tag::watch) {
-            // `errdefer` doesn't fire on `return .{ .err = ... }` (that's a successful return of a
-            // Maybe(T), not an error-union return). Clean up the map entry and the half-initialized
-            // watcher inline. See #26254.
-            // PORT NOTE: no map entry was inserted yet in the Rust version (see reshape above),
-            // so there is nothing to swap_remove here.
+            // Clean up the half-initialized watcher inline (see #26254). No map
+            // entry was inserted yet (see reshape above), so there is nothing
+            // to swap_remove here.
             // SAFETY: `this` is the freshly heap-allocated pointer above; deinit consumes it.
             unsafe {
                 (*this).manager = None; // prevent deinit() from re-entering unregister_watcher
@@ -404,7 +389,7 @@ impl PathWatcher {
         // SAFETY: handle is open (uv_fs_event_start succeeded); uv_unref only flips the ref flag.
         unsafe { uv::uv_unref(ptr::addr_of_mut!((*this).handle).cast()) };
 
-        // Owned key: dupe of event_path bytes (Zig: `dupeZ` — the sentinel NUL is not part of the
+        // Owned key: dupe of event_path bytes (the sentinel NUL is not part of the
         // slice's `.len`, so the StringArrayHashMap key compares equal to `event_path.as_bytes()`).
         manager.watchers.insert(event_path.as_bytes(), this);
 
@@ -450,7 +435,6 @@ impl PathWatcher {
         // SAFETY: caller guarantees `this` is a live heap-allocated pointer (see `init`).
         let me = unsafe { &mut *this };
         me.handlers.clear();
-        // PERF(port): was clearAndFree (shrinks capacity).
 
         if let Some(manager) = me.manager.take() {
             let path: &ZStr = if !me.handle.path.is_null() {
@@ -486,9 +470,6 @@ pub fn watch(
     vm: &'static jsc::VirtualMachineRef,
     path: &ZStr,
     recursive: bool,
-    // PORT NOTE: Zig takes `comptime callback` / `comptime updateEnd` and `@compileError`s if they
-    // are not exactly `onPathUpdateFn` / `onUpdateEndFn`. There is only one valid value for each,
-    // so the Rust port drops the parameters entirely.
     ctx: *mut c_void,
 ) -> sys::Result<*mut PathWatcher> {
     #[cfg(not(windows))]
@@ -533,5 +514,3 @@ pub fn watch(
     }
     sys::Result::Ok(watcher)
 }
-
-// ported from: src/runtime/node/win_watcher.zig
diff --git a/src/runtime/node/zlib/NativeBrotli.rs b/src/runtime/node/zlib/NativeBrotli.rs
index 8b78f137e15..e6783ed42e8 100644
--- a/src/runtime/node/zlib/NativeBrotli.rs
+++ b/src/runtime/node/zlib/NativeBrotli.rs
@@ -3,7 +3,6 @@ use core::ptr::{self, NonNull};
 
 use bun_brotli::c;
 type Op = c::BrotliEncoderOperation;
-// TODO(port): exact path — Zig: bun.brotli.c.BrotliEncoder.Operation
 
 // ─── type defs (real) ─────────────────────────────────────────────────────
 
@@ -46,12 +45,7 @@ impl Default for Context {
     }
 }
 
-// ─── gated: JsClass payload + host fns + Context method bodies ────────────
-// `NativeBrotli` carries `#[bun_jsc::JsClass]`; `impl Context` calls
-// `Error::init(&str, ..)` and uses brotli-C variant names that diverge from
-// `bun_brotli_sys` (e.g. `BrotliDecoderResult::Error` vs `::err`). Unblocking
-// requires aligning those signatures.
-// TODO(blocked): un-gate once bun_jsc JsClass + Error::init str overload + brotli_c variant names settle.
+// ─── JsClass payload + host fns + Context method bodies ───────────────────
 
 mod _impl {
     use super::*;
@@ -66,8 +60,7 @@ mod _impl {
     use crate::node::node_zlib_binding::{CompressionStream, CountedKeepAlive, Error};
     use crate::node::util::validators;
 
-    // Intrusive refcount: `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`.
-    // In Rust the handle type is `bun_ptr::IntrusiveRc<NativeBrotli>`; the
+    // Intrusive refcount: the handle type is `bun_ptr::IntrusiveRc<NativeBrotli>`; the
     // `ref_count` field below is read/written by that wrapper, and `deinit` is the
     // drop body invoked when the count reaches zero.
 
@@ -85,7 +78,7 @@ mod _impl {
         pub global_this: bun_ptr::BackRef<JSGlobalObject>,
         pub stream: JsCell<Context>,
         pub poll_ref: JsCell<CountedKeepAlive>,
-        // TODO(port): Strong on m_ctx self-ref → JsRef per PORTING.md §JSC (Strong back-ref to own wrapper leaks)
+        // TODO: Strong self-ref on the wrapper → JsRef per PORTING.md §JSC (Strong back-ref to own wrapper leaks)
         pub this_value: JsCell<StrongOptional>, // Strong.Optional — empty-initialised
         pub write_in_progress: Cell<bool>,
         pub pending_close: Cell<bool>,
@@ -94,13 +87,12 @@ mod _impl {
         pub task: JsCell<WorkPoolTask>,
     }
 
-    // `const impl = CompressionStream(@This())` — Zig mixin that provides
     // write / runFromJSThread / writeSync / reset / close / setOnError /
-    // getOnError / finalize / emitError. In Rust these are generic associated
+    // getOnError / finalize / emitError are generic associated
     // fns on `CompressionStream::<NativeBrotli>` (see node_zlib_binding.rs).
 
     impl NativeBrotli {
-        // PORT NOTE: no `#[bun_jsc::host_fn]` — the free-fn shim it emits calls
+        // No `#[bun_jsc::host_fn]` — the free-fn shim it emits calls
         // a bare `constructor(...)` which cannot resolve inside an `impl` block.
         // The `#[bun_jsc::JsClass]` derive already emits the construct shim that
         // calls `<Self>::constructor(__g, __f)`.
@@ -274,8 +266,7 @@ mod _impl {
         }
 
         /// `CellRefCounted::destroy` target (refcount hit zero). Runs `deinit`
-        /// then frees the Box-allocated payload — matches Zig
-        /// `bun.ptr.RefCount(.., deinit, .{}).deref()` → `deinit()` + `bun.destroy(this)`.
+        /// then frees the Box-allocated payload.
         ///
         /// Safe fn: only reachable via the `#[ref_count(destroy = …)]` derive,
         /// whose generated trait `destroy` upholds the sole-owner contract.
@@ -289,16 +280,16 @@ mod _impl {
         /// RefCount destructor body (called when ref_count → 0).
         fn deinit(&mut self) {
             // this_value / poll_ref have Drop impls; explicit calls kept for
-            // ordering parity with Zig.
-            // TODO(port): confirm Strong/CountedKeepAlive Drop ordering is benign
-            // and remove explicit deinit calls.
+            // ordering. The `stream` close below is load-bearing:
+            // `Context` has no Drop, so the brotli encoder/decoder state would
+            // leak without it.
             self.this_value.set(StrongOptional::empty());
             drop(self.poll_ref.replace(CountedKeepAlive::default()));
             self.stream.with_mut(|s| match s.mode {
                 bun_zlib::NodeMode::BROTLI_ENCODE | bun_zlib::NodeMode::BROTLI_DECODE => s.close(),
                 _ => {}
             });
-            // bun.destroy(this) — freeing self is handled by IntrusiveRc / heap::take.
+            // Freeing self is handled by IntrusiveRc / heap::take.
         }
     }
 
@@ -394,7 +385,7 @@ mod _impl {
         pub fn set_buffers(&mut self, in_: Option<&[u8]>, out: Option<&mut [u8]>) {
             self.next_in = in_.map_or(ptr::null(), |p| p.as_ptr());
             self.avail_in = in_.map_or(0, |p| p.len());
-            // PORT NOTE: reshaped for borrowck — compute ptr/len before consuming `out`.
+            // Reshaped for borrowck — compute ptr/len before consuming `out`.
             match out {
                 Some(p) => {
                     self.avail_out = p.len();
@@ -411,7 +402,7 @@ mod _impl {
             // Caller passes a valid BrotliEncoderOperation discriminant (Node
             // zlib constants 0..=3). Exhaustive match — `Op` is `#[repr(u32)]`
             // so the prior `c_int` bit-cast was a width hazard anyway. Out-of-
-            // range traps to match Zig `this.flush = @enumFromInt(flush)`.
+            // range traps.
             self.flush = match flush {
                 0 => Op::process,
                 1 => Op::flush,
@@ -554,8 +545,6 @@ mod _impl {
     crate::__impl_compression_stream!(NativeBrotli, Context, "NativeBrotli");
 
     fn code_for_error(err: c::BrotliDecoderErrorCode2) -> *const core::ffi::c_char {
-        // Zig: `inline for (std.meta.fieldNames(E), std.enums.values(E)) |n, v|
-        //          if (err == v) return "ERR_BROTLI_DECODER_" ++ n;`
         // Rust has no enum reflection — expand the table by hand. Keep in sync
         // with `bun_brotli::c::BrotliDecoderErrorCode2`.
         use c::BrotliDecoderErrorCode2 as E;
@@ -603,7 +592,7 @@ mod _impl {
     }
 
     /// Placeholder for `WorkPoolTask.callback` — overwritten before scheduling
-    /// (see `CompressionStream::write` in node_zlib_binding.rs). Zig: `.callback = undefined`.
+    /// (see `CompressionStream::write` in node_zlib_binding.rs).
     /// Safe fn: coerces to the `WorkPoolTask.callback` field type at the
     /// struct-init site; the body never dereferences the pointer.
     fn noop_task_callback(_task: *mut WorkPoolTask) {}
@@ -612,5 +601,3 @@ mod _impl {
 } // mod _impl
 
 pub use _impl::NativeBrotli;
-
-// ported from: src/runtime/node/zlib/NativeBrotli.zig
diff --git a/src/runtime/node/zlib/NativeZlib.rs b/src/runtime/node/zlib/NativeZlib.rs
index 7fb529ecdf4..f452a45204e 100644
--- a/src/runtime/node/zlib/NativeZlib.rs
+++ b/src/runtime/node/zlib/NativeZlib.rs
@@ -23,7 +23,7 @@ mod _impl {
     use crate::node::util::validators;
 
     /// Placeholder for `WorkPoolTask.callback` — overwritten before scheduling
-    /// (see `CompressionStream::write` in node_zlib_binding.rs). Zig: `.callback = undefined`.
+    /// (see `CompressionStream::write` in node_zlib_binding.rs).
     /// Safe fn: coerces to the `WorkPoolTask.callback` field type at the
     /// struct-init site; the body never dereferences the pointer.
     fn noop_task_callback(_task: *mut WorkPoolTask) {}
@@ -52,12 +52,12 @@ mod _impl {
         pub task: JsCell<WorkPoolTask>,
     }
 
-    // `const impl = CompressionStream(@This())` — Zig comptime mixin that injects
     // write / runFromJSThread / writeSync / reset / close / setOnError / getOnError /
-    // finalize onto this type. In Rust these are provided as inherent methods on
+    // finalize are provided as inherent methods on
     // `CompressionStream::<NativeZlib>` in node_zlib_binding.rs (a generic mixin
-    // struct, not a trait).
-    // TODO(port): verify CompressionStream<T> surface matches the Zig mixin re-exports.
+    // struct, not a trait); `__compression_stream_mixin_reexports!` re-exports the
+    // same JS-exposed surface (write / writeSync / reset / close / setOnError /
+    // getOnError / finalize); runFromJSThread and emitError stay internal.
 
     impl NativeZlib {
         // NB: no `#[bun_jsc::host_fn]` here — the `#[bun_jsc::JsClass]` derive emits
@@ -228,7 +228,7 @@ mod _impl {
 
         /// RefCount destroy callback. Invoked when `ref_count` reaches zero.
         /// Not `Drop` because this is an intrusive-refcounted `m_ctx` payload whose
-        /// box is freed here (`bun.destroy(this)` in Zig).
+        /// box is freed here.
         fn deinit(this: *mut Self) {
             // SAFETY: called exactly once by IntrusiveRc when refcount hits 0; `this`
             // is the heap::alloc pointer produced at construction. `this_value`
@@ -344,7 +344,7 @@ impl Context {
 
     pub fn set_dictionary(&mut self) -> Error {
         use c::NodeMode::*;
-        // PORT NOTE: reshaped for borrowck — capture raw ptr/len before
+        // Reshaped for borrowck — capture raw ptr/len before
         // re-borrowing `self.state` mutably.
         let (dict_ptr, dict_len) = {
             let dict = self.dictionary();
@@ -450,8 +450,8 @@ impl Context {
     }
 
     pub fn set_flush(&mut self, flush: c_int) {
-        // Checked conversion (mirrors Zig debug-mode `@enumFromInt` panic on
-        // out-of-range); transmuting an arbitrary c_int into a Rust enum is UB.
+        // Checked conversion;
+        // transmuting an arbitrary c_int into a Rust enum is UB.
         self.flush = match flush {
             0 => c::FlushValue::NoFlush,
             1 => c::FlushValue::PartialFlush,
@@ -536,7 +536,7 @@ impl Context {
             && self.err == c::ReturnCode::NeedDict
             && !self.dictionary().is_empty()
         {
-            // PORT NOTE: reshaped for borrowck — capture raw ptr/len before
+            // Reshaped for borrowck — capture raw ptr/len before
             // re-borrowing `self.state` mutably.
             let (dict_ptr, dict_len) = {
                 let dict = self.dictionary();
@@ -613,5 +613,3 @@ impl Context {
         self.mode = NONE;
     }
 }
-
-// ported from: src/runtime/node/zlib/NativeZlib.zig
diff --git a/src/runtime/node/zlib/NativeZstd.rs b/src/runtime/node/zlib/NativeZstd.rs
index abebacec68f..c10854169c3 100644
--- a/src/runtime/node/zlib/NativeZstd.rs
+++ b/src/runtime/node/zlib/NativeZstd.rs
@@ -13,7 +13,7 @@ mod _impl {
 
     use crate::node::node_zlib_binding::{CompressionStream, CountedKeepAlive, Error};
     use crate::node::util::validators;
-    // `bun.zlib.NodeMode` — #[repr(u8)] enum shared by all native-zlib stream types.
+    // #[repr(u8)] enum shared by all native-zlib stream types.
     use bun_zlib::NodeMode;
 
     // `jsc.Codegen.JSNativeZstd` cached-property accessors (`mod js`) are emitted
@@ -22,7 +22,7 @@ mod _impl {
     // `src/codegen/generate-classes.ts` for `values: [...]` in `zlib.classes.ts`.
 
     /// Placeholder WorkPoolTask callback — overwritten by CompressionStream::write
-    /// before the task is ever scheduled (mirrors Zig `.{ .callback = undefined }`).
+    /// before the task is ever scheduled.
     /// Safe fn: coerces to the `WorkPoolTask.callback` field type at the
     /// struct-init site; the body never dereferences the pointer.
     fn unset_task_callback(_: *mut WorkPoolTask) {
@@ -36,7 +36,7 @@ mod _impl {
     #[bun_jsc::JsClass]
     #[derive(bun_ptr::CellRefCounted)]
     pub struct NativeZstd {
-        // bun.ptr.RefCount(@This(), "ref_count", deinit, .{}) — intrusive single-thread refcount.
+        // Intrusive single-thread refcount.
         pub ref_count: Cell<u32>,
         // LIFETIMES.tsv: JSC_BORROW. The global outlives this m_ctx payload;
         // `BackRef` centralises the single unsafe deref so the trait impl is safe.
@@ -57,10 +57,9 @@ mod _impl {
     // `pub const js = jsc.Codegen.JSNativeZstd; toJS/fromJS/fromJSDirect = js.*;` — provided by
     // `#[bun_jsc::JsClass]` derive (wires to_js / from_js / from_js_direct).
     //
-    // `const impl = CompressionStream(@This());` and the `pub const write = impl.write; ...` re-exports
-    // resolve through the `CompressionStreamImpl` trait below — `CompressionStream::<NativeZstd>` then
+    // `CompressionStream::<NativeZstd>` (via the `CompressionStreamImpl` trait below)
     // supplies write / run_from_js_thread / write_sync / reset / close / set_on_error / get_on_error /
-    // finalize as the generic mixin, just like the Zig comptime fn.
+    // finalize as the generic mixin.
 
     impl NativeZstd {
         // C-ABI shim is emitted by `#[bun_jsc::JsClass]` (calls `<Self>::constructor`);
@@ -117,8 +116,8 @@ mod _impl {
         pub fn estimated_size(&self) -> usize {
             core::mem::size_of::<Self>()
                 + match self.stream.get().mode {
-                    NodeMode::ZSTD_COMPRESS => 5272, // estimate of bun.c.ZSTD_sizeof_CCtx(self.stream.state)
-                    NodeMode::ZSTD_DECOMPRESS => 95968, // estimate of bun.c.ZSTD_sizeof_DCtx(self.stream.state)
+                    NodeMode::ZSTD_COMPRESS => 5272, // estimate of ZSTD_sizeof_CCtx(self.stream.state)
+                    NodeMode::ZSTD_DECOMPRESS => 95968, // estimate of ZSTD_sizeof_DCtx(self.stream.state)
                     _ => 0,
                 }
         }
@@ -239,9 +238,9 @@ mod _impl {
         }
     }
 
-    // `fn deinit(this: *@This()) void` — called by RefCount when count hits 0.
-    // `poll_ref.deinit()` and `this_value` (Strong) cleanup are handled by their own Drop impls.
-    // `bun.destroy(this)` is the Box free, handled by IntrusiveRc dropping the Box.
+    // Called by RefCount when the count hits 0. `poll_ref` and `this_value`
+    // (Strong) cleanup are handled by their own Drop impls; the Box free is
+    // handled by IntrusiveRc dropping the Box.
     impl Drop for NativeZstd {
         fn drop(&mut self) {
             self.stream.with_mut(|s| match s.mode {
@@ -412,7 +411,7 @@ mod _impl {
                         self.state_ptr().cast(),
                         &raw mut self.output,
                         &raw mut self.input,
-                        // @intCast c_int → ZSTD_EndDirective (c_uint)
+                        // cast c_int → ZSTD_EndDirective (c_uint)
                         self.flush as c_uint,
                     )
                 },
@@ -434,7 +433,7 @@ mod _impl {
         }
 
         pub fn get_error_info(&mut self) -> Error {
-            // PORT NOTE: reshaped `defer this.remaining = 0;` — compute result, then clear, then return.
+            // Compute result, then clear `remaining`, then return.
             let err = c::ZSTD_getErrorCode(self.remaining as usize);
             let result = if err == 0 {
                 Error::OK
@@ -522,7 +521,7 @@ mod _impl {
 
         #[inline]
         fn state_ptr(&self) -> *mut c_void {
-            // Mirrors Zig `@ptrCast(this.state)` on `?*anyopaque` — passes null through if unset.
+            // Passes null through if unset.
             self.state.unwrap_or(ptr::null_mut())
         }
     }
@@ -531,10 +530,7 @@ mod _impl {
     // Stamps `impl CompressionContext for Context`, `impl Taskable`/
     // `CompressionStreamImpl for NativeZstd`, and `pub mod js { … }` so
     // `CompressionStream::<NativeZstd>::*` (write/writeSync/reset/close/
-    // emit_error/…) can reach this struct's fields the way the Zig comptime mixin
-    // did via duck-typed `this.field` access.
+    // emit_error/…) can reach this struct's fields.
     crate::__impl_compression_stream!(NativeZstd, Context, "NativeZstd");
     crate::__compression_stream_mixin_reexports!(NativeZstd);
 } // mod _impl
-
-// ported from: src/runtime/node/zlib/NativeZstd.zig
diff --git a/src/runtime/server/AnyRequestContext.rs b/src/runtime/server/AnyRequestContext.rs
index 3a0ce9d97e3..45cf980931e 100644
--- a/src/runtime/server/AnyRequestContext.rs
+++ b/src/runtime/server/AnyRequestContext.rs
@@ -12,7 +12,6 @@ use super::request_context::RequestContext;
 use super::{DebugHTTPSServer, DebugHTTPServer, HTTPSServer, HTTPServer};
 
 // The six monomorphizations of `NewRequestContext` (ssl × debug × h3).
-// In Zig these are nested as `HTTPServer.RequestContext` etc.
 type HttpCtx = RequestContext<HTTPServer, false, false, false>;
 type HttpsCtx = RequestContext<HTTPSServer, true, false, false>;
 type DebugHttpCtx = RequestContext<DebugHTTPServer, false, true, false>;
@@ -20,10 +19,9 @@ type DebugHttpsCtx = RequestContext<DebugHTTPSServer, true, true, false>;
 type HttpsH3Ctx = RequestContext<HTTPSServer, true, false, true>;
 type DebugHttpsH3Ctx = RequestContext<DebugHTTPSServer, true, true, true>;
 
-// PORT NOTE (§Dispatch): Zig used `bun.ptr.TaggedPointerUnion(...)`. The
-// `bun_ptr::impl_tagged_ptr_union!` macro hits the orphan rule from outside
-// `bun_ptr`, so per §Dispatch store `(tag: u8, ptr: *mut ())` as two fields.
-// PERF(port): was TaggedPointerUnion pack — 8→16 bytes. AnyRequestContext is
+// The `bun_ptr::impl_tagged_ptr_union!` macro hits the orphan rule from
+// outside `bun_ptr`, so store `(tag: u8, ptr: *mut ())` as two fields.
+// A tagged-pointer pack would be 8 bytes instead of 16. AnyRequestContext is
 // stored inside `webcore::Request` (one per in-flight request); if profiling
 // flags the extra 8 bytes, move the impl_tagged_ptr_union! invocation into
 // `bun_ptr` for these six types.
@@ -91,12 +89,11 @@ impl AnyRequestContext {
 }
 
 /// Dispatch `$body` to the concrete RequestContext type behind the tagged
-/// pointer. The pointer types only differ in their comptime parameters
+/// pointer. The pointer types only differ in their const-generic parameters
 /// (ssl/debug/http3), so every method body is identical — this collapses what
 /// used to be six hand-written switch arms per accessor.
 ///
-/// Mirrors Zig's `inline fn dispatch(..., comptime cb: anytype, args)` which
-/// `inline for`s over `Pointer.type_map`. Rust closures cannot be generic over
+/// Rust closures cannot be generic over
 /// `T`, so a macro is the closest structural equivalent.
 // TODO(refactor): if all six ctx types gain a shared `RequestContextLike`
 // trait (with `const IS_H3: bool` + `type Resp`), this macro can become a
@@ -180,7 +177,7 @@ impl AnyRequestContext {
                 // H3 populates url/headers eagerly
                 return;
             }
-            // PORT NOTE: `ctx.req` is `Option<*mut Req<SSL,H3>>` where
+            // `ctx.req` is `Option<*mut Req<SSL,H3>>` where
             // `Req<_,_> = c_void` (erased handle). For non-H3 the underlying
             // type is always `uws::Request`, so the cast is purely nominal.
             ctx.req = Some(req.cast::<c_void>());
@@ -199,10 +196,9 @@ impl AnyRequestContext {
 
     pub fn on_abort(self, response: uws::AnyResponse) {
         dispatch!(self, (), |T, ctx| {
-            // PORT NOTE: Zig does a checked downcast of the `AnyResponse` arm
-            // to `*T.Resp` before forwarding. The Rust `RequestContext::on_abort`
+            // `RequestContext::on_abort`
             // takes `uws::AnyResponse` directly (and re-checks H3 internally),
-            // so forward the enum as-is — the per-variant assert is redundant.
+            // so forward the enum as-is.
             // SAFETY: `ctx` is the live request context this `AnyRequestContext`
             // wraps; `on_abort` only derefs that exact pointer.
             T::on_abort(core::ptr::from_mut::<T>(ctx), response);
@@ -226,8 +222,8 @@ impl AnyRequestContext {
         }))
     }
 
-    /// Mutable access to the attached DevServer. Zig passed `*DevServer`
-    /// freely; the Rust accessor above hands out `&` only. The `Box` slot
+    /// Mutable access to the attached DevServer. The accessor above hands out
+    /// `&` only. The `Box` slot
     /// inside `NewServer` has a stable address, so deriving `&mut` here is
     /// sound as long as the caller upholds the usual single-writer rule on the
     /// JS thread.
@@ -246,5 +242,3 @@ impl AnyRequestContext {
         dispatch!(self, (), |_T, ctx| ctx.deref())
     }
 }
-
-// ported from: src/runtime/server/AnyRequestContext.zig
diff --git a/src/runtime/server/FileResponseStream.rs b/src/runtime/server/FileResponseStream.rs
index fcd5ec45405..cd035486bdc 100644
--- a/src/runtime/server/FileResponseStream.rs
+++ b/src/runtime/server/FileResponseStream.rs
@@ -235,7 +235,6 @@ impl FileResponseStream {
             return false;
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig captured `*max` mutably across the block.
         let (chunk, state) = 'brk: {
             if let Some(max) = self.max_size.as_mut() {
                 let c = &chunk_[..chunk_
@@ -566,10 +565,9 @@ impl FileResponseStream {
     // hand-rolled `ref_guard`/`DerefOnDrop` pair is now `bun_ptr::ScopedRef<Self>`.
 }
 
-// `bun.io.BufferedReader.init(@This())` — vtable parent. Maps the Zig
-// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop` decls.
+// BufferedReader vtable parent.
 // `loop_` delegates to the inherent `r#loop()` which already does the
-// cfg(windows) `.uv_loop` projection (Zig spec: FileResponseStream.zig `loop()`).
+// cfg(windows) `.uv_loop` projection.
 bun_io::impl_buffered_reader_parent! {
     FileResponseStream for FileResponseStream;
     has_on_read_chunk = true;
@@ -616,5 +614,3 @@ fn can_sendfile(resp: AnyResponse, file_type: FileType, length: Option<u64>) ->
         len >= (1 << 20)
     }
 }
-
-// ported from: src/runtime/server/FileResponseStream.zig
diff --git a/src/runtime/server/FileRoute.rs b/src/runtime/server/FileRoute.rs
index 39764eaa190..cc6d4e8d3f0 100644
--- a/src/runtime/server/FileRoute.rs
+++ b/src/runtime/server/FileRoute.rs
@@ -23,7 +23,7 @@ use crate::webcore::{Blob, FetchHeaders, Response};
 #[derive(bun_ptr::CellRefCounted)]
 #[ref_count(destroy = FileRoute::deinit)]
 pub struct FileRoute {
-    // PORT NOTE (§Pointers Rc/Arc default): owned via intrusive refcount; the
+    // Owned via intrusive refcount; the
     // raw `*mut FileRoute` is round-tripped through `FileResponseStream`'s
     // `ctx: *mut c_void` userdata, so `Rc<FileRoute>` is unsuitable. See
     // StaticRoute.rs note re: FFI userdata fallback to RefPtr.
@@ -219,7 +219,6 @@ impl FileRoute {
         let buf = self.headers.buf.as_slice();
 
         debug_assert_eq!(names.len(), values.len());
-        // PORT NOTE: Zig `switch (resp) { inline else => |s, tag| { ... } }` expanded per-variant.
         // S008: variant payloads are ZST opaques — safe `*mut → &mut` deref.
         match resp {
             AnyResponse::SSL(s) => {
@@ -302,7 +301,7 @@ impl FileRoute {
         unsafe { Self::on(this, req, resp, method) };
     }
 
-    // PORT NOTE: takes `*mut FileRoute` (not `&self`) because the
+    // Takes `*mut FileRoute` (not `&self`) because the
     // intrusive-refcounted heap object is captured raw into a `scopeguard`
     // whose closure may free `*this` via `deref()` before the local `&Self`
     // borrow lexically ends. Derive a single `&FileRoute` for all field reads;
@@ -328,10 +327,9 @@ impl FileRoute {
             server.on_pending_request();
             resp.timeout(server.config().idle_timeout);
         }
-        // PORT NOTE: clone the path so the borrow into `this.blob.store`
+        // Clone the path so the borrow into `this.blob.store`
         // doesn't span the scopeguard creation (the guard's closure may free
-        // `*this_ptr` on early-return drop). // PERF(port): was zero-copy
-        // slice — profile if hot.
+        // `*this_ptr` on early-return drop).
         let path_buf: Vec<u8> = match this.blob.store.get().as_ref().unwrap().get_path() {
             Some(p) => p.to_vec(),
             None => {
@@ -372,7 +370,7 @@ impl FileRoute {
         // `fd_owned` tracks whether this function is still responsible for
         // closing the file descriptor and releasing the route ref. Every
         // non-streaming return — bodiless status codes (304/204/205/307/308),
-        // HEAD, non-streamable files, and the two JS-exception `catch return`
+        // HEAD, non-streamable files, and the two JS-exception early-return
         // paths below — hits this defer, so neither the fd nor the route ref
         // (or the server's pending_requests counter) can leak regardless of
         // which branch runs. The streaming path clears `fd_owned` right
@@ -388,19 +386,12 @@ impl FileRoute {
             }
         });
 
-        // PORT NOTE (intentional spec divergence): Zig writes
-        // `req.dateForHeader(..) catch return` — i.e. on a JS parse exception
-        // the handler bails with NO response written (the defer above closes
-        // the fd and decrements the route ref, leaving the client hung until
-        // timeout). That `catch return` is itself flagged as a TODO in the
-        // .zig. `parse_http_date` instead maps a parse failure to `None`, so a
+        // `parse_http_date` maps a parse failure to `None`, so a
         // malformed If-Modified-Since header degrades to "serve the file
-        // unconditionally" — the RFC 9110 §13.1.3-correct behaviour and what
-        // the Zig TODO is asking for. Kept divergent on purpose.
+        // unconditionally" — the RFC 9110 §13.1.3-correct behaviour.
         //
-        // LAYERING: Zig's `req.dateForHeader` was a method on `uws.Request`;
-        // in Rust the parse step lives HERE (T6) because it needs `bun_jsc` —
-        // call site moved up so `bun_uws_sys` (T0) carries no upward hook.
+        // LAYERING: the parse step lives HERE (T6) because it needs `bun_jsc` —
+        // so `bun_uws_sys` (T0) carries no upward hook.
         let input_if_modified_since_date: Option<u64> = req
             .header(b"if-modified-since")
             .and_then(crate::jsc_hooks::parse_http_date);
@@ -408,7 +399,7 @@ impl FileRoute {
         let (can_serve_file, size, file_type, pollable): (bool, u64, FileType, bool) = 'brk: {
             let stat = match bun_sys::fstat(fd) {
                 Ok(s) => s,
-                // PORT NOTE: file_type is `undefined` in Zig here; never read because can_serve_file == false
+                // file_type is never read because can_serve_file == false
                 Err(_) => break 'brk (false, 0, FileType::File, false),
             };
 
@@ -597,5 +588,3 @@ fn on_stream_complete(ctx: *mut c_void, resp: AnyResponse) {
 fn on_stream_error(ctx: *mut c_void, resp: AnyResponse, _err: bun_sys::Error) {
     FileRoute::on_response_complete(ctx.cast::<FileRoute>(), resp);
 }
-
-// ported from: src/runtime/server/FileRoute.zig
diff --git a/src/runtime/server/HTMLBundle.rs b/src/runtime/server/HTMLBundle.rs
index af1500746fd..70d196d0493 100644
--- a/src/runtime/server/HTMLBundle.rs
+++ b/src/runtime/server/HTMLBundle.rs
@@ -29,7 +29,7 @@ use crate::server::server_config::MethodOptional;
 use crate::server::{AnyRoute, AnyServer, GetOrStartLoadResult, ServePluginsCallback, StaticRoute};
 use crate::webcore::AnyBlob;
 
-// `bun.Output.scoped(.HTMLBundle, .hidden)` — wrapped in a sub-module so the
+// Scoped debug logger — wrapped in a sub-module so the
 // `pub static HTMLBundle` doesn't leak alongside the `pub struct HTMLBundle`
 // re-export from `crate::server`.
 mod debug_scope {
@@ -40,9 +40,8 @@ use debug_scope::HTMLBundle as debug;
 // .classes.ts codegen wires toJS/fromJS/fromJSDirect via #[bun_jsc::JsClass].
 // HTMLBundle can be owned by JavaScript as well as any number of Server instances,
 // hence the ref count alongside the JS wrapper.
-// PORT NOTE (§Pointers): `*mut HTMLBundle` is the m_ctx payload of a
+// `*mut HTMLBundle` is the m_ctx payload of a
 // `.classes.ts` wrapper — FFI rule says intrusive `RefPtr`.
-// `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`
 #[derive(bun_ptr::RefCounted)]
 #[ref_count(debug_name = "HTMLBundle")]
 pub struct HTMLBundle {
@@ -87,7 +86,7 @@ const _: () = {
         fn to_js(self, _global: &JSGlobalObject) -> JSValue {
             // HTMLBundle is *only* constructed via `init()` → `IntrusiveRc::new`
             // (heap-boxed, intrusive-refcounted) and wrapped via the inherent
-            // `HTMLBundle::to_js(*mut Self, …)` below. The Zig codegen `toJS`
+            // `HTMLBundle::to_js(*mut Self, …)` below, which
             // wraps the *existing* `*HTMLBundle` allocation; re-boxing a
             // by-value `self` here would split the allocation from its refcount
             // and make `finalize`'s `deref` target the wrong heap block. No
@@ -114,7 +113,7 @@ const _: () = {
 impl HTMLBundle {
     /// Initialize an HTMLBundle given a path.
     pub fn init(global: &JSGlobalObject, path: &[u8]) -> IntrusiveRc<HTMLBundle> {
-        // Zig `try allocator.dupe` was the only fallible op; Box::from aborts on OOM.
+        // Box::from aborts on OOM.
         IntrusiveRc::new(HTMLBundle {
             ref_count: RefCount::init(),
             global,
@@ -127,10 +126,8 @@ impl HTMLBundle {
         bun_ptr::finalize_js_box_noop(self);
     }
 
-    // Zig `deinit`: only `allocator.free(this.path)` + `bun.destroy(this)`.
     // `path: Box<[u8]>` auto-drops; dealloc handled by IntrusiveRc — no explicit Drop body.
 
-    // TODO(port): #[bun_jsc::host_fn(getter)] once codegen attribute lands for this class.
     pub fn get_index(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
         bun_jsc::bun_string_jsc::create_utf8_for_js(global, &this.path)
     }
@@ -148,11 +145,10 @@ pub(crate) type HTMLBundleRoute = Route;
 // (non-Copy). `*mut Route` is recovered from uws userdata and the
 // `JSBundleCompletionTask` backref while a prior `&Route` may still be on the
 // stack — `&mut self` would alias (UB); `&self` + `UnsafeCell` is sound.
-// `bun.ptr.RefCount(Route, "ref_count", Route.deinit, .{ .debug_name = "HTMLBundleRoute" })`
 #[derive(bun_ptr::RefCounted)]
 #[ref_count(debug_name = "HTMLBundleRoute")]
 pub struct Route {
-    // PORT NOTE: FFI userdata — *Route is recovered from uws callback
+    // FFI userdata — *Route is recovered from uws callback
     // userdata (on_aborted, JSBundleCompletionTask backref). §Pointers FFI
     // rule → `bun_ptr::RefPtr<HTMLBundle>` + `impl RefCounted`.
     pub bundle: IntrusiveRc<HTMLBundle>,
@@ -189,7 +185,7 @@ pub enum State {
     Html(*mut StaticRoute),
 }
 
-// PORT NOTE: Zig's `State.deinit` is *only* invoked from `Route.deinit` and the
+// `State::deinit` is *only* invoked from `Route::deinit` and the
 // dev-mode reset in `onAnyRequest`; ordinary `this.state = ...` overwrites in
 // `onComplete`/`onPluginsResolved`/etc. do NOT run it. Mapping it to `impl Drop`
 // would fire on every assignment — in particular `on_complete`'s
@@ -317,8 +313,8 @@ impl Route {
             }
         }
 
-        // Zig `state: switch (this.state) { ... continue :state this.state; }` — one re-dispatch
-        // after `.pending` schedules the bundle.
+        // One re-dispatch
+        // after `Pending` schedules the bundle.
         loop {
             match route.state.get() {
                 State::Pending => {
@@ -329,7 +325,6 @@ impl Route {
                             bstr::BStr::new(req.url())
                         );
                     }
-                    // TODO(dezig-oom): verify route.schedule_bundle is fallible
                     bun_core::handle_oom(route.schedule_bundle(server));
                     continue;
                 }
@@ -377,7 +372,7 @@ impl Route {
                             bstr::BStr::new(req.url())
                         );
                     }
-                    // TODO: use the code from DevServer.zig to render the error
+                    // TODO: use the code from DevServer.rs to render the error
                     resp.end_without_body(true);
                 }
                 State::Html(html) => {
@@ -422,7 +417,6 @@ impl Route {
         &self,
         plugins: Option<NonNull<JSBundler::Plugin>>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // S008: `JSGlobalObject` is an `opaque_ffi!` ZST — safe `*const → &` deref.
         let global = bun_opaque::opaque_deref(self.bundle.global);
         let server = self.server.get().expect("server set");
@@ -432,7 +426,7 @@ impl Route {
         let vm = global.bun_vm().as_mut();
 
         let mut config = JSBundlerConfig::default();
-        // PORT NOTE: `errdefer config.deinit(allocator)` — `Config` owns its fields and
+        // `Config` owns its fields and
         // drops on early-return.
         config.entry_points.insert(&self.bundle.path)?;
         let xform = &vm.transpiler.options.transform_options;
@@ -483,10 +477,8 @@ impl Route {
 
         if let Some(define) = &cli.args.serve_define {
             debug_assert_eq!(define.keys.len(), define.values.len());
-            // PORT NOTE: Zig bulk-set `entries.len` + `@memcpy` + `reIndex` against
-            // `StringArrayHashMap`; Rust `StringMap` exposes only put/insert. Same
-            // result, slightly more hash work.
-            // PERF(port): was bulk reIndex — profile if hot.
+            // `StringMap` exposes only put/insert (no bulk re-index);
+            // profile if hot.
             for (k, v) in define.keys.iter().zip(define.values.iter()) {
                 config.define.put(k, v)?;
             }
@@ -522,7 +514,6 @@ impl Route {
     }
 
     pub fn on_plugins_rejected(&self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         bun_output::scoped_log!(
             debug,
             "HTMLBundleRoute(0x{:x}) plugins rejected",
@@ -545,8 +536,6 @@ impl Route {
                 }
                 let mut log = Log::init();
                 completion_task.log.clone_to_with_recycled(&mut log, true);
-                // PORT NOTE: reshaped for borrowck — Zig wrote
-                // `this.state = .{ .err = ... }` then mutated `this.state.err`.
                 if let Some(server) = self.server.get() {
                     if server.config().is_development() {
                         // `Output.errorWriterBuffered()` → process-global writer;
@@ -591,9 +580,7 @@ impl Route {
                     bun_output::flush();
                 }
 
-                // PORT NOTE: reshaped for borrowck — Zig appended every route in
-                // iteration order then mutably called `html_route.clone()` through
-                // a raw ptr aliasing the route table. `AnyRoute::Static` carries
+                // `AnyRoute::Static` carries
                 // an intrusive `*mut StaticRoute` here; defer appending the HTML
                 // entry-point until after cloning so we retain the sole owner for
                 // the `clone()` mutable borrow. Static routes are keyed by
@@ -602,9 +589,8 @@ impl Route {
                     None;
 
                 // Create static routes for each output file
-                // PORT NOTE: index loop because the SourceMap branch reads a sibling entry.
+                // Index loop because the SourceMap branch reads a sibling entry.
                 for i in 0..output_files.len() {
-                    // TODO(dezig-oom): verify OutputFile::to_blob is fallible
                     let blob =
                         AnyBlob::Blob(bun_core::handle_oom(output_files[i].to_blob(global_this)));
                     let mut headers = Headers::default();
@@ -629,7 +615,6 @@ impl Route {
                         let n = {
                             use std::io::Write as _;
                             let mut cursor = std::io::Cursor::new(&mut hashbuf[..]);
-                            // `bufPrint(&buf, "{f}", .{hexIntLower(hash)}) catch unreachable`
                             write!(
                                 cursor,
                                 "{}",
@@ -689,7 +674,6 @@ impl Route {
                         continue;
                     }
 
-                    // TODO(dezig-oom): verify server.append_static_route is fallible
                     bun_core::handle_oom(server.append_static_route(
                         route_path,
                         AnyRoute::Static(static_route),
@@ -702,10 +686,8 @@ impl Route {
                 });
                 // SAFETY: html_route is a fresh heap::alloc with ref_count=1;
                 // sole owner before registration.
-                // TODO(dezig-oom): verify StaticRoute::clone is fallible
                 let html_route_clone =
                     bun_core::handle_oom(unsafe { &mut *html_route.as_ptr() }.clone(global_this));
-                // TODO(dezig-oom): verify server.append_static_route is fallible
                 bun_core::handle_oom(server.append_static_route(
                     &html_route_path,
                     AnyRoute::Static(html_route),
@@ -713,7 +695,6 @@ impl Route {
                 ));
                 self.state.set(State::Html(html_route_clone));
 
-                // TODO(dezig-oom): verify server.reload_static_routes is fallible
                 if !bun_core::handle_oom(server.reload_static_routes()) {
                     // Server has shutdown, so it won't receive any new requests
                     // TODO: handle this case
@@ -768,7 +749,7 @@ impl Route {
                         .config()
                         .is_development()
                     {
-                        // TODO: use the code from DevServer.zig to render the error
+                        // TODO: use the code from DevServer.rs to render the error
                     } else {
                         // To protect privacy, do not show errors to end users in production.
                         // TODO: Show a generic error page.
@@ -790,10 +771,10 @@ impl Drop for Route {
         debug_assert!(self.pending_responses.get().is_empty());
         // `pending_responses` (Vec) and `bundle` (IntrusiveRc) auto-drop.
         // `state` has no `Drop` glue for the intrusive-pointer variants — release
-        // them explicitly (mirrors Zig `Route.deinit` calling `this.state.deinit()`).
+        // them explicitly.
         // `with_mut` is fine here — refcount==0 so no other `&Route` exists.
         self.state.with_mut(|s| s.deinit());
-        // `bun.destroy(this)` handled by IntrusiveRc dealloc.
+        // The Box free is handled by IntrusiveRc dealloc.
     }
 }
 
@@ -818,7 +799,7 @@ impl Drop for PendingResponse {
         // SAFETY: `route` was a live IntrusiveRc-managed Route when stored;
         // matches the `ref()` taken when this PendingResponse was created.
         unsafe { RefCount::<Route>::deref(self.route) };
-        // `bun.destroy(this)` handled by heap::take caller.
+        // The Box free is handled by the heap::take caller.
     }
 }
 
@@ -839,8 +820,6 @@ impl PendingResponse {
         // `ScopedRef` bumps the count and derefs on every exit path.
         let _keep_route = unsafe { bun_ptr::ScopedRef::new(route_ptr) };
 
-        // PORT NOTE: reshaped for borrowck — Zig accessed this.route.pending_responses through
-        // raw ptr; mutate via raw ptr (single-threaded).
         // SAFETY: single-threaded; Route is alive (we hold a ref). R-2: deref as
         // shared (`&*`); `pending_responses` is `JsCell`-wrapped.
         let route = unsafe { &*route_ptr };
@@ -861,5 +840,3 @@ impl PendingResponse {
         }
     }
 }
-
-// ported from: src/runtime/server/HTMLBundle.zig
diff --git a/src/runtime/server/HTTPStatusText.rs b/src/runtime/server/HTTPStatusText.rs
index 3c3b3cae7c7..7aa1ad01ccc 100644
--- a/src/runtime/server/HTTPStatusText.rs
+++ b/src/runtime/server/HTTPStatusText.rs
@@ -66,5 +66,3 @@ pub fn get(code: u16) -> Option<&'static [u8]> {
         _ => None,
     }
 }
-
-// ported from: src/runtime/server/HTTPStatusText.zig
diff --git a/src/runtime/server/InspectorBunFrontendDevServerAgent.rs b/src/runtime/server/InspectorBunFrontendDevServerAgent.rs
index 2c18c81f992..4e80d066f47 100644
--- a/src/runtime/server/InspectorBunFrontendDevServerAgent.rs
+++ b/src/runtime/server/InspectorBunFrontendDevServerAgent.rs
@@ -1,7 +1,6 @@
 //! `BunFrontendDevServerAgent` is stored inline in `jsc::Debugger`, so the
 //! canonical definition lives in `bun_jsc::debugger` (lower tier). This module
-//! re-exports it for `bun_runtime` callers that ported the Zig
-//! `@import("../runtime/server/InspectorBunFrontendDevServerAgent.zig")` path.
+//! re-exports it for `bun_runtime` callers.
 
 pub use crate::jsc::debugger::{
     BunFrontendDevServerAgent, InspectorBunFrontendDevServerAgentHandle,
@@ -10,5 +9,3 @@ pub use crate::jsc::debugger::{
 // `generate-host-exports.ts`; the safe-signature impl is
 // `bun_jsc::debugger::frontend_dev_server_agent_set_enabled`.
 pub use crate::generated_host_exports::Bun__InspectorBunFrontendDevServerAgent__setEnabled;
-
-// ported from: src/runtime/server/InspectorBunFrontendDevServerAgent.zig
diff --git a/src/runtime/server/NodeHTTPResponse.rs b/src/runtime/server/NodeHTTPResponse.rs
index 01e5c2e6b29..6846999db71 100644
--- a/src/runtime/server/NodeHTTPResponse.rs
+++ b/src/runtime/server/NodeHTTPResponse.rs
@@ -123,7 +123,7 @@ impl Default for UpgradeCTX {
 
 impl UpgradeCTX {
     // this can be called multiple times
-    // PORT NOTE: Zig `deinit` renamed `reset` — mid-lifetime reset, not a destructor (PORTING.md: never expose `pub fn deinit(&mut self)`).
+    // Mid-lifetime reset, not a destructor.
     pub(crate) fn reset(&mut self) {
         // Dropping the taken value frees the old `Box<[u8]>` headers; raw
         // pointers are nulled. Nothing from the old value is reused.
@@ -200,7 +200,7 @@ fn vm_get<'a>() -> &'a mut VirtualMachine {
 }
 
 /// `&mut` to this thread's VM for `Ref::ref/unref` etc. Takes `_global` for
-/// call-site symmetry with the .zig spec but reads the thread-local directly:
+/// call-site symmetry but reads the thread-local directly:
 /// `VirtualMachine::as_mut()` ignores its receiver and re-reads the TLS slot,
 /// so routing through `global.bun_vm()` was pure overhead on the per-request
 /// path (`NodeHTTPResponse__createForJS` disasm showed the `bunVM` FFI result
@@ -274,9 +274,7 @@ extern "C" fn on_auto_flush_trampoline(ctx: *mut c_void) -> bool {
 
 /// Unpack the `AnyServer` tagged-pointer u64 handed across FFI from C++.
 ///
-/// Zig: `AnyServer{ .ptr = AnyServer.Ptr.from(@ptrFromInt(any_server_tag)) }`
-/// where `Ptr = bun.TaggedPointerUnion(.{HTTPServer, HTTPSServer,
-/// DebugHTTPServer, DebugHTTPSServer})`. The packed repr is bits 0..49 = ptr,
+/// The packed repr is bits 0..49 = ptr,
 /// bits 49..64 = tag, with tag = `1024 - index` (see `bun_ptr::tagged_pointer`).
 /// The Rust `AnyServer` stores `(tag, ptr)` unpacked, so map the wire tag back
 /// to `AnyServerTag` here.
@@ -299,8 +297,7 @@ fn any_server_from_packed(packed: u64) -> AnyServer {
 /// `jsc.Codegen.JSNodeHTTPResponse` cached-property accessors.
 /// `codegen_cached_accessors!` emits `on_{data,aborted,writable}_{get,set}_cached`
 /// thin wrappers over the C++ `NodeHTTPResponsePrototype__on*{Get,Set}CachedValue`
-/// `WriteBarrier<Unknown>` slots, named to match the Zig spelling so the
-/// `.zig` ↔ `.rs` diff lines up.
+/// `WriteBarrier<Unknown>` slots.
 pub mod js {
     bun_jsc::codegen_cached_accessors!("NodeHTTPResponse"; onData, onAborted, onWritable);
 }
@@ -388,7 +385,7 @@ impl NodeHTTPResponse {
         let Some(ws_handler) = server.web_socket_handler() else {
             return false;
         };
-        // PORT NOTE: reshaped for borrowck — extend handler lifetime past method calls.
+        // Lifetime-extend the handler past the method calls below.
         // SAFETY: JS-thread only; the server (and its websocket config) outlives this call.
         let ws_handler: &mut crate::server::WebSocketServerHandler =
             unsafe { &mut *std::ptr::from_mut(ws_handler) };
@@ -398,9 +395,6 @@ impl NodeHTTPResponse {
         }
         self.resume_socket();
 
-        // PORT NOTE: Zig `defer { setOnAbortedHandler(); upgrade_context.deinit(); }` inlined at the
-        // tail of this fn (no early returns past this point), so no scopeguard needed.
-
         data_value.ensure_still_alive();
 
         let ws = ServerWebSocket::init(ws_handler, data_value, None);
@@ -470,7 +464,6 @@ impl NodeHTTPResponse {
         drop(sec_websocket_protocol_str);
         drop(sec_websocket_extensions_str);
 
-        // Deferred: equivalent of Zig `defer` block above.
         self.set_on_aborted_handler();
         self.upgrade_context.with_mut(|c| c.reset());
 
@@ -699,7 +692,7 @@ impl NodeHTTPResponse {
         global_object: &JSGlobalObject,
         callframe: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: `arguments_undef::<3>()` returns `Arguments<3>` — a 32-byte
+        // Perf: `arguments_undef::<3>()` returns `Arguments<3>` — a 32-byte
         // `[JSValue; 3]` + `len` aggregate — *by value*, which `cargo asm` shows
         // lowered to a per-`writeHead` `vmovups` stack copy on the node:http hot
         // path. The borrowed `arguments()` slice (ptr+len, 16 bytes) carries the
@@ -757,7 +750,7 @@ impl NodeHTTPResponse {
         // so we always land here with a short JS string. `to_slice()` would do
         // 2×ref + 2×deref FFI (OwnedString + ZigStringSlice::WTF); instead hold
         // the +1 from `to_bun_string` in an `OwnedString` and borrow the bytes
-        // without the inner ref bump (Zig: `defer str.deref()` + `toUTF8`).
+        // without the inner ref bump.
         let status_message_str;
         let status_message_slice;
         let status_message_bytes: &[u8] = if !status_message_value.is_undefined() {
@@ -815,10 +808,9 @@ impl NodeHTTPResponse {
                 b"HM"
             };
 
-            // Zig spec (NodeHTTPResponse.zig:455/491): 256-byte stackFallback +
-            // `{d} {s}` (plain memcpy). The previous Vec + write! + BStr-Display
-            // path showed up at 0.54% incl in perf (core::fmt vtable + BStr UTF-8
-            // chunk-validation). status_code is 100..=999 → always 3 digits.
+            // 256-byte stack buffer + plain memcpy. The previous Vec + write! +
+            // BStr-Display path showed up at 0.54% incl in perf (core::fmt vtable
+            // + BStr UTF-8 chunk-validation). status_code is 100..=999 → always 3 digits.
             let mut itoa_buf = bun_core::fmt::ItoaBuf::new();
             let code = bun_core::fmt::itoa(&mut itoa_buf, status_code);
             let n = code.len() + 1 + message.len();
@@ -911,7 +903,7 @@ pub enum AbortEvent {
 impl NodeHTTPResponse {
     fn handle_abort_or_timeout<const EVENT: AbortEvent>(&self, js_value: JSValue) {
         // defer { if event == abort, raw_response = None }
-        // PORT NOTE: reshaped for borrowck — deferred null moved to explicit tail positions.
+        // The deferred null is moved to explicit tail positions.
 
         if self.flags.get().contains(Flags::REQUEST_HAS_COMPLETED) {
             if EVENT == AbortEvent::Abort {
@@ -969,12 +961,10 @@ impl NodeHTTPResponse {
             self.on_data_or_aborted(b"", true, AbortEvent::Abort, js_this);
         }
 
-        // Deferred tail (Zig defer order is preserved up to one reorder: the
-        // outer `defer raw_response = None` is hoisted above `deref()` because
+        // `raw_response` is cleared before `deref()` because
         // `mark_request_as_done_if_necessary()` + `deref()` can drop the last
         // ref when the JS wrapper has already finalized; nothing between them
-        // reads `raw_response`, so the swap is observably equivalent and
-        // avoids a post-destroy write).
+        // reads `raw_response`, so clearing first avoids a post-destroy write.
         if EVENT == AbortEvent::Abort {
             self.mark_request_as_done_if_necessary();
             self.raw_response.set(None);
@@ -1047,9 +1037,7 @@ impl NodeHTTPResponse {
             self.buffered_request_body_data_during_pause.get().len()
         );
         if self.buffered_request_body_data_during_pause.get().len() > 0 {
-            // Zig spec: `createBuffer` then `.{}` — `bun.ByteList` has no Drop, so the
-            // assignment just forgets the storage and ownership transfers to JSC. A Rust
-            // `Vec` *does* Drop, so the prior `create_buffer(slice_mut)` + `= Vec::new()`
+            // `Vec` Drops, so the prior `create_buffer(slice_mut)` + `= Vec::new()`
             // freed the backing allocation while JSC still pointed at it (mimalloc
             // free-list pointer overwrote the first 8 bytes — test-http-pause.js saw
             // `'�\x01xУ\x02\x00\x00Body from Client'`). Move the Vec out and hand the
@@ -1412,7 +1400,7 @@ impl NodeHTTPResponse {
             });
         }
 
-        // PORT NOTE: re-read raw_response at each use site (R-2: methods that
+        // Re-read raw_response at each use site (R-2: methods that
         // re-enter may clear it).
         let state = self.raw_response.get().unwrap().state();
         if !state.is_response_pending() {
@@ -1460,7 +1448,7 @@ impl NodeHTTPResponse {
             break 'brk None;
         };
 
-        // Construct in place (Zig result-location semantics) — returning
+        // Construct in place — returning
         // `JsResult<Option<StringOrBuffer>>` by value here lowered to ~128B of
         // `vmovups` stack copies per `res.end()`; the `_into` out-param form
         // writes straight into this slot.
@@ -1598,7 +1586,7 @@ impl NodeHTTPResponse {
                         raw_response.on_writable(on_drain_shim, self.as_ctx_ptr());
                     }
 
-                    // PERF(port): @intCast — bounded by min().
+                    // The cast cannot fail: bounded by min().
                     let clamped = i64::try_from(written.min(i64::MAX as usize)).expect("int cast");
                     Ok(JSValue::js_number((-clamped) as f64))
                 }
@@ -1883,7 +1871,7 @@ impl NodeHTTPResponse {
         global_object: &JSGlobalObject,
         callframe: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: borrow the `arguments()` slice (ptr+len) instead of
+        // Perf: borrow the `arguments()` slice (ptr+len) instead of
         // materialising `Arguments<1>` by value — `cork` runs on every
         // `res.end()`, so the small-aggregate copy + bounds branch are pure
         // per-request overhead with no upstream equivalent.
@@ -1920,7 +1908,7 @@ impl NodeHTTPResponse {
         // sound. No `black_box` launder is needed; it was a hard optimization
         // barrier on the node:http hot path (`cork` runs on every `res.end()`)
         // that forced `self` to memory and blocked inlining/regalloc of the
-        // cork prologue, with no equivalent in upstream Zig.
+        // cork prologue.
         let this = bun_ptr::BackRef::from(ptr::NonNull::from(self));
         // BACKREF: `this` is the live `m_ctx` heap payload; `ref_()` keeps it
         // alive across re-entry.
@@ -1932,7 +1920,7 @@ impl NodeHTTPResponse {
         if let Some(raw_response) = raw_response {
             raw_response.corked(|| {
                 // Capture `this` so a `self`-derived pointer reaches the FFI
-                // closure-data slot (see PORT NOTE above).
+                // closure-data slot (see the R-2 note above).
                 let _escape = this;
                 handle_corked(global_object, corked_fn, &mut result, &mut is_exception)
             });
@@ -1985,7 +1973,7 @@ impl NodeHTTPResponse {
         unsafe { drop(bun_core::heap::take(self.as_ctx_ptr())) };
     }
 
-    // Intrusive refcount helpers (mirrors Zig `bun.ptr.RefCount(@This(), ...)` mixin).
+    // Intrusive refcount helpers.
     #[inline]
     pub(crate) fn ref_(&self) {
         self.ref_count.set(self.ref_count.get() + 1);
@@ -2146,12 +2134,10 @@ impl NodeHTTPResponse {
             return false;
         }
 
-        // Zig `seconds.to(c_uint)` is ECMAScript ToUint32 — same bit pattern as
+        // ECMAScript ToUint32 — same bit pattern as
         // ToInt32 reinterpreted as unsigned (negative inputs wrap, e.g. -1 → u32::MAX).
         let secs = (seconds.to_int32() as c_uint).min(255) as u8;
         raw.timeout(secs);
         true
     }
 }
-
-// ported from: src/runtime/server/NodeHTTPResponse.zig
diff --git a/src/runtime/server/RangeRequest.rs b/src/runtime/server/RangeRequest.rs
index 4170653defa..ed5a271df20 100644
--- a/src/runtime/server/RangeRequest.rs
+++ b/src/runtime/server/RangeRequest.rs
@@ -115,8 +115,8 @@ pub fn parse(header: &[u8], total: u64) -> Result {
     parse_raw(header).resolve(total)
 }
 
-// PORT NOTE: Zig passed `req` by value; `bun_uws::AnyRequest::header` borrows
-// `&self` and returns `&[u8]` tied to it, so take `&AnyRequest` here.
+// `bun_uws::AnyRequest::header` borrows `&self` and returns `&[u8]` tied to
+// it, so take `&AnyRequest` here.
 pub(crate) fn from_request(req: &AnyRequest, total: u64) -> Result {
     let Some(h) = req.header(b"range") else {
         return Result::None;
@@ -161,5 +161,3 @@ pub(crate) fn format_content_range(buf: &mut [u8], range: Result, total: Option<
         },
     }
 }
-
-// ported from: src/runtime/server/RangeRequest.zig
diff --git a/src/runtime/server/RequestContext.rs b/src/runtime/server/RequestContext.rs
index 3ed131ba36a..bbaeac780aa 100644
--- a/src/runtime/server/RequestContext.rs
+++ b/src/runtime/server/RequestContext.rs
@@ -36,10 +36,8 @@ impl AdditionalOnAbortCallback {
     }
 }
 
-// PORT NOTE (transport selection): Zig `NewRequestContext` is a comptime
-// type-function over `(ssl_enabled, debug_mode, ThisServer, http3)` and picks
-// `Resp = uws.H3.Response | uws.NewApp(ssl).Response` / `Req = uws.H3.Request |
-// uws.Request` at comptime. Stable Rust cannot drive an associated type from a
+// NOTE (transport selection): the response/request handle types vary with
+// `(ssl_enabled, http3)`. Stable Rust cannot drive an associated type from a
 // const-generic `bool` without specialization, and an early `Transport`
 // helper-trait approach forced `where TransportFor<SSL,H3>: Transport` bounds
 // onto every generic that named `RequestContext` (which Rust then *cannot*
@@ -103,7 +101,6 @@ impl AnyResponseExt for uws::AnyResponse {
 /// frame unwinds), so reads/writes are safe `Cell` ops — no raw `*mut bool`.
 pub type DeferDeinitFlag = bun_ptr::BackRef<core::cell::Cell<bool>>;
 
-// `jsc.WebCore.HTTPServerWritable(ssl_enabled, http3)` — comptime type fn.
 pub type ResponseStream<const SSL_ENABLED: bool, const HTTP3: bool> =
     crate::webcore::streams::HTTPServerWritable<SSL_ENABLED, HTTP3>;
 pub type ResponseStreamJSSink<const SSL_ENABLED: bool, const HTTP3: bool> =
@@ -111,20 +108,22 @@ pub type ResponseStreamJSSink<const SSL_ENABLED: bool, const HTTP3: bool> =
 
 /// This pre-allocates up to 2,048 RequestContext structs.
 /// It costs about 655,632 bytes.
-// TODO(port): bun.HiveArray(RequestContext, if (bun.heap_breakdown.enabled) 0 else 2048).Fallback
+// Capacity 0 when heap-breakdown is enabled routes every allocation through
+// the fallback heap path so the per-type malloc zones can attribute them.
+pub const REQUEST_CONTEXT_POOL_CAPACITY: usize = if bun_alloc::heap_breakdown::ENABLED {
+    0
+} else {
+    2048
+};
 pub type RequestContextStackAllocator<
     ThisServer,
     const SSL: bool,
     const DBG: bool,
     const H3: bool,
-> = bun_collections::hive_array::Fallback<RequestContext<ThisServer, SSL, DBG, H3>, 2048>;
-
-thread_local! {
-    // TODO(port): Zig `pub threadlocal var pool: ?*RequestContextStackAllocator = null;` is
-    // per-monomorphization. Rust thread_local! cannot be generic; Phase B: move into ThisServer
-    // or use a per-instantiation static via macro.
-    static POOL: core::cell::Cell<*mut c_void> = const { core::cell::Cell::new(core::ptr::null_mut()) };
-}
+> = bun_collections::hive_array::Fallback<
+    RequestContext<ThisServer, SSL, DBG, H3>,
+    REQUEST_CONTEXT_POOL_CAPACITY,
+>;
 
 pub struct RequestContext<
     ThisServer,
@@ -139,7 +138,7 @@ pub struct RequestContext<
     pub resp: Option<uws::AnyResponse>,
     pub req: Option<*mut Req<SSL_ENABLED, HTTP3>>,
     pub request_weakref: request::WeakRef,
-    // PORT NOTE: Zig `?*AbortSignal`. `Arc<AbortSignal>` was wrong —
+    // NOTE: `Arc<AbortSignal>` was wrong —
     // `AbortSignal` is an opaque ZST FFI handle; an `Arc` of a ZST never owns
     // the C++ allocation. Store the raw pointer. The request holds TWO counts:
     // the intrusive C++ `RefPtr` (+1 from `AbortSignal::new()`/`ref_()`) and a
@@ -157,8 +156,11 @@ pub struct RequestContext<
 
     /// We can only safely free once the request body promise is finalized
     /// and the response is rejected
-    // TODO(port): bare JSValue heap field — kept alive via manual protect()/unprotect()
-    // (response_protected flag); revisit bun_jsc::Strong in Phase B.
+    // Deliberately a bare JSValue with manual protect()/unprotect() gated by
+    // the `response_protected` flag: plain Blob/InternalBlob
+    // bodies intentionally leave the value unprotected on the hot path and
+    // fall back to `response_weakref` (see its doc below), so a `Strong`
+    // here would root the Response unconditionally and change GC behavior.
     pub response_jsvalue: JSValue,
     pub ref_count: u8,
 
@@ -279,8 +281,8 @@ use bun_jsc::SysErrorJsc as _;
 
 /// RAII: releases one intrusive ref on a [`RequestContext`] at scope exit.
 ///
-/// Replaces the Zig `defer ctx.deref()` pattern in promise-callback host
-/// functions — `NativePromiseContext::take` hands back a +1 ref, and the
+/// In promise-callback host
+/// functions, `NativePromiseContext::take` hands back a +1 ref, and the
 /// callback must drop it on every exit path. Holds the raw pointer (not
 /// `&mut`) so the body can keep using its own `&mut Self` view without
 /// borrowck conflict; the `&mut` is formed only at drop time.
@@ -311,9 +313,7 @@ where
 /// `from_js` returns the C++-owned cell pointer for `value`. The caller must
 /// guarantee that:
 /// - no other Rust `&mut Response` aliasing this cell is live for the
-///   lifetime of the returned reference (the .zig spec returns a raw
-///   `?*Response` with no exclusivity claim — the `&mut` here is a port-side
-///   upgrade), and
+///   lifetime of the returned reference, and
 /// - `value` is kept GC-rooted (ensure_still_alive / protect()) for as long
 ///   as the returned reference is used, so the JSC-owned allocation outlives
 ///   the borrow.
@@ -361,14 +361,13 @@ mod shim {
         // See `signal_aborted` — counted ref keeps pointee live.
         bun_ptr::BackRef::from(s).signal(g, r)
     }
-    /// Release BOTH refcounts the request holds on its AbortSignal, mirroring
-    /// the Zig `defer { signal.pendingActivityUnref(); signal.unref(); }` pair.
+    /// Release BOTH refcounts the request holds on its AbortSignal.
     /// `pending_activity_unref()` drops the GC-visibility count and `unref()`
     /// drops the intrusive C++ `RefPtr` count taken at creation. `s` must not
     /// be dereferenced after this call.
     #[inline]
     pub(super) fn signal_release(s: NonNull<AbortSignal>) {
-        // See `signal_aborted`. Order matches Zig: pending-activity first,
+        // See `signal_aborted`. Order: pending-activity first,
         // then the owning intrusive ref (which may free). `BackRef` is dropped
         // before `unref()` returns, so no dangling deref.
         let signal = bun_ptr::BackRef::from(s);
@@ -426,12 +425,11 @@ use bun_options_types::schema::api as Api;
 
 use bun_js_parser::parser::Runtime::Fallback;
 
-/// PORT NOTE: `Api.JsException` is split across two crates in the Rust port —
+/// NOTE: `Api.JsException` is split across two crates —
 /// `bun_jsc::schema_api::JsException` (carries `stack`, used by
 /// `VirtualMachine::run_error_handler`) and `bun_options_types::schema::api::
-/// JsException` (peechy-encodable, `stack` omitted to break the dep cycle). In
-/// Zig these are the *same* struct, so `runErrorHandler` populates the list and
-/// `Problems.exceptions` consumes it directly. Bridge the two here so the
+/// JsException` (peechy-encodable, `stack` omitted to break the dep cycle).
+/// Bridge the two here so the
 /// fallback page actually carries the captured exceptions instead of an empty
 /// array (react-response.test.ts asserts `exceptions[0].message`).
 fn jsc_exceptions_to_api(list: jsc::ExceptionList) -> Vec<Api::JsException> {
@@ -453,18 +451,17 @@ macro_rules! ctx_log { ($($t:tt)*) => { bun_core::scoped_log!(RequestContext, $(
 macro_rules! stream_log { ($($t:tt)*) => { bun_core::scoped_log!(ReadableStream, $($t)*) }; }
 
 /// Per-monomorphization C-ABI shim table for the four promise-reaction host
-/// fns. Zig's `toJSHostFn(onResolve)` mints a fresh `extern fn` per comptime
-/// instantiation **and `@export`s the same pointer**, so the value passed to
-/// `then_with_value` is identical to the `Bun__HTTPRequestContext*__on*`
-/// symbol that C++'s `GlobalObject::promiseHandlerID` compares against.
+/// fns. The value passed to `then_with_value` must be identical to the
+/// `Bun__HTTPRequestContext*__on*` symbol that C++'s
+/// `GlobalObject::promiseHandlerID` compares against.
 ///
-/// In Rust the `#[no_mangle]` exports cannot live on a generic fn, so they are
+/// The `#[no_mangle]` exports cannot live on a generic fn, so they are
 /// emitted as concrete wrappers by `request_ctx_exports!` below. The trait
 /// impls — also emitted by that macro — point at those *exported* wrappers
 /// (not the inner generic shims), so `Self::ON_RESOLVE` and the C++ side agree
 /// on the function-pointer identity and `promiseHandlerID` resolves.
 ///
-/// PORT NOTE (layering): expressed as a trait (not inherent consts) so
+/// NOTE (layering): expressed as a trait (not inherent consts) so
 /// downstream `where`-clauses that already name it keep type-checking.
 pub trait RequestContextHostFns {
     const ON_RESOLVE: bun_jsc::JSHostFn;
@@ -548,8 +545,7 @@ where
     // `host_on_*::<..>` shims: the function-pointer value is what C++'s
     // `GlobalObject::promiseHandlerID` compares against (ZigGlobalObject.cpp),
     // and the exported wrapper has a different address from the generic it
-    // forwards to. The Zig spec gets this for free because `@export` re-labels
-    // the existing fn; in Rust we route through a const-fn lookup keyed on the
+    // forwards to. We route through a const-fn lookup keyed on the
     // (SSL, DEBUG, H3) tuple so the blanket impl can name concrete exports.
     const ON_RESOLVE: bun_jsc::JSHostFn = exported_host_fns(SSL, DBG, H3).0;
     const ON_REJECT: bun_jsc::JSHostFn = exported_host_fns(SSL, DBG, H3).1;
@@ -619,8 +615,7 @@ where
     }
 
     /// Take the pooled request-body slot out of `self`; the handle's `Drop`
-    /// releases the `+1`. Mirrors the Zig `body.unref()` on `deinit` /
-    /// final body chunk.
+    /// releases the `+1`.
     #[inline]
     fn request_body_take_unref(&mut self) {
         self.request_body.take();
@@ -643,7 +638,7 @@ where
         if let Some(server) = self.server {
             // SAFETY: BACKREF. `ServerLike::vm()` returns `&VirtualMachine`
             // but `drain_microtasks` needs `&mut`; cast through the raw
-            // pointer (Zig held a `*VirtualMachine`).
+            // pointer.
             unsafe {
                 let vm = std::ptr::from_ref::<VirtualMachine>((*server).vm()).cast_mut();
                 (*vm).drain_microtasks();
@@ -714,23 +709,35 @@ where
                     "Expected a native Response object, but received a polyfilled Response object. Bun.serve() only supports native Response objects.",
                 );
             } else if !value.is_empty() && !global_this.has_exception() {
-                // TODO(port): jsc::ConsoleObject::Formatter has no Default;
-                // JSValue::to_fmt lives on a trait not in scope here. Fall back
-                // to the generic message until those land.
-                let _ = value;
-                bun_core::err_generic!("Expected a Response object");
+                let mut formatter = jsc::ConsoleObject::Formatter::new(global_this);
+                formatter.quote_strings = true;
+                bun_core::err_generic!(
+                    "Expected a Response object, but received '{}'",
+                    jsc::console_object::formatter::ZigFormatter::new(&mut formatter, value),
+                );
+                // `formatter` drops here.
             } else {
                 bun_core::err_generic!("Expected a Response object");
             }
 
             Output::flush();
             if !global_this.has_exception() {
-                let _ = writer;
-                // TODO(port): write_trace wants `impl bun_io::Write`; Output::error_writer()
-                // returns a raw `*mut Writer`. Skip the JS stack trace for now.
+                jsc::ConsoleObject::write_trace(writer, global_this);
             }
             Output::flush();
         }
+        // The formatter and `write_trace` above re-enter JS (getters, proxy
+        // traps, Error.prepareStackTrace), which can synchronously abort or
+        // end this request (e.g. AbortController.abort() inside a getter).
+        // We hold `&mut self` for the whole call, matching the rest of this
+        // promise-resolve path (`on_resolve` → `handle_resolve` also re-enter
+        // JS through `&mut`).
+        // The `RequestContextRef` guard taken in `on_resolve` keeps the
+        // allocation alive across the re-entry; re-check the request state so
+        // we never render onto a response that was ended underneath us.
+        if self.is_aborted_or_ended() {
+            return;
+        }
         self.render_missing();
     }
 
@@ -901,7 +908,6 @@ where
         self.ref_count += 1;
     }
 
-    // TODO(port): #[bun_jsc::host_fn] — see note on `on_resolve`.
     pub fn on_reject(_global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         ctx_log!("onReject");
 
@@ -1019,7 +1025,6 @@ where
 
     pub fn render_default_error(
         &mut self,
-        // PERF(port): was arena bulk-free — profile in Phase B
         log: &mut bun_ast::Log,
         err: bun_core::Error,
         exceptions: &[Api::JsException],
@@ -1042,7 +1047,6 @@ where
             reason: Some(Api::FallbackStep::fetch_event_handler),
             cwd: Some(cwd.to_vec().into_boxed_slice()),
             problems: Some(Api::Problems {
-                // Zig: `@truncate(@intFromError(err))`.
                 code: err.as_u16(),
                 name: err.name().as_bytes().to_vec().into_boxed_slice(),
                 exceptions: exceptions.to_vec(),
@@ -1058,9 +1062,12 @@ where
             }),
         });
 
-        // TODO(port): `if (comptime fmt.len > 0)` — fmt::Arguments has no const len; always print.
-        #[allow(clippy::disallowed_methods)] // fmt is a caller-provided Arguments parameter
-        Output::pretty_errorln(fmt);
+        // `fmt::Arguments` has no const len, but an empty format string is
+        // detectable at runtime via `as_str() == Some("")`.
+        if fmt.as_str() != Some("") {
+            #[allow(clippy::disallowed_methods)] // fmt is a caller-provided Arguments parameter
+            Output::pretty_errorln(fmt);
+        }
         Output::flush();
 
         // Explicitly use the global allocator and *not* the arena
@@ -1348,8 +1355,7 @@ where
         let vm = std::ptr::from_ref::<VirtualMachine>(server.vm()).cast_mut();
         let global_this = server.global_this();
         // Drop one ref on every exit path. Declared before the microtask drain
-        // so it runs *after* (LIFO) — matches Zig `defer this.deref()` ordered
-        // after `defer drainMicrotasks()`.
+        // so it runs *after* (LIFO).
         let _ref = RequestContextRef(std::ptr::from_mut::<Self>(this));
         // This is a task in the event loop.
         // If we called into JavaScript, we must drain the microtask queue.
@@ -1523,7 +1529,7 @@ where
         }
 
         // Copy to stack memory to prevent aliasing issues in release builds
-        // PORT NOTE: AnyBlob is not Copy in Rust; reborrow through a raw ptr
+        // NOTE: AnyBlob is not Copy in Rust; reborrow through a raw ptr
         // so the slice borrow doesn't conflict with `&mut self` below.
         // SAFETY: `this.blob`'s backing bytes are owned by the context and
         // outlive `send_writable_bytes_for_blob`; detaching the borrow lets
@@ -1644,15 +1650,13 @@ where
                 if auto_close {
                     fd.close();
                 }
-                // TODO(port): Zig `withPathLike(file.pathlike)` also sets
-                // `.fd` for the Fd arm; `bun_sys::Error` only carries a path
-                // slice, so render the fd as bytes for the error path.
+                // Attach the path for the Path arm and the fd for the Fd arm.
                 let js_err = match &file.pathlike {
                     crate::webcore::node_types::PathOrFileDescriptor::Path(p) => {
                         err.with_path(p.slice()).to_js(global_this)
                     }
-                    crate::webcore::node_types::PathOrFileDescriptor::Fd(_) => {
-                        err.to_js(global_this)
+                    crate::webcore::node_types::PathOrFileDescriptor::Fd(pathlike_fd) => {
+                        err.with_fd(*pathlike_fd).to_js(global_this)
                     }
                 };
                 return self.run_error_handler(js_err);
@@ -1672,21 +1676,21 @@ where
                 if auto_close {
                     fd.close();
                 }
-                // TODO(port): Zig `withPathLike(file.pathlike)` also sets `.fd`
-                // for the Fd arm; `bun_sys::Error::with_path` only carries a
-                // path slice, so the fd arm gets no path attached.
-                let path_bytes: &[u8] = match &file.pathlike {
-                    crate::webcore::node_types::PathOrFileDescriptor::Path(p) => p.slice(),
-                    crate::webcore::node_types::PathOrFileDescriptor::Fd(_) => b"",
-                };
-                let mut sys: jsc::SystemError = bun_sys::Error {
+                // Attach the path for the Path arm and the fd for the Fd arm.
+                let base_err = bun_sys::Error {
                     errno: bun_sys::E::EISDIR as _,
                     syscall: bun_sys::Tag::read,
                     ..Default::default()
-                }
-                .with_path(path_bytes)
-                .to_system_error()
-                .into();
+                };
+                let err = match &file.pathlike {
+                    crate::webcore::node_types::PathOrFileDescriptor::Path(p) => {
+                        base_err.with_path(p.slice())
+                    }
+                    crate::webcore::node_types::PathOrFileDescriptor::Fd(pathlike_fd) => {
+                        base_err.with_fd(*pathlike_fd)
+                    }
+                };
+                let mut sys: jsc::SystemError = err.to_system_error().into();
                 sys.message = BunString::static_("Cannot stream a directory as a response body");
                 return self.run_error_handler(sys.to_error_instance(global_this));
             }
@@ -1896,7 +1900,6 @@ where
     }
 
     /// Tear down a heap `ResponseStreamJSSink` allocated by `do_render_stream`.
-    /// Mirrors Zig `response_stream.detach(); response_stream.sink.destroy()` —
     /// JSSink<T> is `repr(transparent)` so the inner-ptr free matches the
     /// outer allocation.
     fn destroy_sink(ptr: NonNull<ResponseStreamJSSink<SSL_ENABLED, HTTP3>>) {
@@ -1912,7 +1915,7 @@ where
         ctx_log!("doRenderStream");
         // SAFETY: pair is a stack local threaded through cork user-data.
         let pair = unsafe { &mut *pair };
-        // PORT NOTE: reshaped for borrowck — split the two fields up front so
+        // NOTE: reshaped for borrowck — split the two fields up front so
         // `this` and `stream` are independent borrows of `*pair`.
         let this: &mut Self = &mut *pair.this;
         let stream = &mut pair.stream;
@@ -1947,7 +1950,7 @@ where
                 ..Default::default()
             },
         });
-        // PORT NOTE: reshaped for borrowck — own via raw ptr so `this.sink` and the
+        // NOTE: reshaped for borrowck — own via raw ptr so `this.sink` and the
         // local `response_stream` view can coexist with `&mut *this` calls below.
         let response_stream_ptr = bun_core::heap::into_raw_nn(response_stream_box);
         this.sink = Some(response_stream_ptr);
@@ -2069,9 +2072,8 @@ where
                         stream_log!("promise Fulfilled");
                         let mut readable_ref =
                             core::mem::take(&mut this.response_body_readable_stream_ref);
-                        // PORT NOTE: reshaped for borrowck — Zig `defer` runs
-                        // after handle_resolve_stream; emulate by running the
-                        // body first then the deferred cleanup.
+                        // NOTE: cleanup runs after handle_resolve_stream:
+                        // body first, then the deferred cleanup.
                         Self::handle_resolve_stream(this);
                         stream.done(global_this);
                         readable_ref.deinit();
@@ -2670,7 +2672,6 @@ where
         req.end_stream(req.should_close_connection());
     }
 
-    // TODO(port): #[bun_jsc::host_fn] — see note on `on_resolve`.
     pub fn on_resolve_stream(_global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         stream_log!("onResolveStream");
         let args = callframe.arguments_old::<2>();
@@ -2682,7 +2683,6 @@ where
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn] — see note on `on_resolve`.
     pub fn on_reject_stream(
         global_this: &JSGlobalObject,
         callframe: &CallFrame,
@@ -2728,9 +2728,8 @@ where
         }
 
         if let Some(resp) = req.response_weakref.get() {
-            // PORT NOTE: Zig captures `bodyValue` ptr first then derefs after
-            // the stream calls; reordered here for borrowck (semantically
-            // identical — the Zig check reads through the pointer post-detach).
+            // NOTE: the body value is read after the stream calls (the check
+            // observes the post-detach state).
             if let Some(stream) = resp.get_body_readable_stream(global_this) {
                 stream.value.ensure_still_alive();
                 resp.detach_readable_stream(global_this);
@@ -2854,8 +2853,7 @@ where
                 let readable_stream: Option<WebCore::ReadableStream> = 'brk: {
                     if let Some(stream) = lock.readable.get(global_this) {
                         // we hold the stream alive until we're done with it
-                        // PORT NOTE: Zig `= lock.readable` is a bitwise struct copy (no
-                        // dtor); Rust `Strong` is move-only — take() transfers ownership.
+                        // NOTE: `Strong` is move-only — take() transfers ownership.
                         this.response_body_readable_stream_ref =
                             core::mem::take(&mut lock.readable);
                         break 'brk Some(stream);
@@ -2996,7 +2994,7 @@ where
             WebCore::streams::Result::Owned(_) | WebCore::streams::Result::OwnedAndDone(_)
         );
         let is_done = stream.is_done();
-        // PORT NOTE: reshaped for borrowck — the defer reads `stream` through a
+        // NOTE: reshaped for borrowck — the defer reads `stream` through a
         // raw ptr so the body below can keep borrowing it.
         let stream_ptr: *mut WebCore::streams::Result = &raw mut stream;
         // Drop one ref only when the stream signals completion.
@@ -3080,7 +3078,7 @@ where
         if self.is_aborted_or_ended() {
             return;
         }
-        // PORT NOTE: WeakPtr::get borrows `&mut self`, and `do_render_with_body`
+        // NOTE: WeakPtr::get borrows `&mut self`, and `do_render_with_body`
         // also needs `&mut self` plus a `&mut BodyValue` from the response. The
         // response lives in a separate allocation (held by the WeakRef) so the
         // borrows are disjoint at runtime; route through a raw ptr to express that.
@@ -3149,7 +3147,6 @@ where
         // the single audited `&mut VirtualMachine` accessor.
         let vm = server.vm().as_mut();
         if DEBUG_MODE {
-            // PERF(port): was arena bulk-free — profile in Phase B
             let mut exception_list_upstream: jsc::ExceptionList = Vec::new();
             let prev_exception_list = vm.on_unhandled_rejection_exception_list;
             vm.on_unhandled_rejection_exception_list =
@@ -3159,7 +3156,7 @@ where
 
             let exception_list = jsc_exceptions_to_api(exception_list_upstream);
             let log = vm.log_mut().unwrap();
-            // PORT NOTE: format eagerly so `format_args!` doesn't hold an
+            // NOTE: format eagerly so `format_args!` doesn't hold an
             // immutable borrow of `self` across the `&mut self` call.
             let msg = format!(
                 "<r><red>{:?}<r> - <b>{}<r> failed",
@@ -3332,8 +3329,7 @@ where
 
         let (content_type, needs_content_type, content_type_needs_free) =
             get_content_type(response.get_init_headers_mut(), &self.blob);
-        // PORT NOTE: Zig `defer if (content_type_needs_free) content_type.deinit()`.
-        // `MimeType` owns a `Cow<'static, [u8]>`; Drop handles the owned case.
+        // NOTE: `MimeType` owns a `Cow<'static, [u8]>`; Drop handles the owned case.
         // Hold the value past all reads below, then let it drop at scope end.
         let _ct_guard = scopeguard::guard(content_type_needs_free, |_needs| {
             // Drop of `content_type` (moved into closure capture below would
@@ -3355,7 +3351,7 @@ where
 
             self.do_write_status(status);
             self.do_write_headers(&mut headers_);
-            // Zig: `defer headers_.deref()`. `HeadersRef` is RAII — its Drop
+            // `HeadersRef` is RAII — its Drop
             // already calls `WebCore__FetchHeaders__deref`, so an explicit
             // `.deref()` here would resolve (via DerefMut) to the inherent
             // `FetchHeaders::deref` and double-free the C++ object.
@@ -3498,7 +3494,7 @@ where
 
     pub fn render_bytes(&mut self) {
         // copy it to stack memory to prevent aliasing issues in release builds
-        // PORT NOTE: AnyBlob is not Copy in Rust; reborrow through a raw ptr
+        // NOTE: AnyBlob is not Copy in Rust; reborrow through a raw ptr
         // so the slice borrow doesn't conflict with `&mut self` below.
         // SAFETY: `self.blob`'s backing bytes are owned by the context and
         // outlive the `try_end`/`on_writable` calls below; detaching the
@@ -3661,7 +3657,7 @@ where
 
         // This is the start of a task, so it's a good time to drain
         if let Some(body) = this.request_body_mut() {
-            // The up-front maxRequestBodySize check in server.zig only
+            // The up-front maxRequestBodySize check in the server only
             // sees Content-Length. HTTP/3 (and H1 chunked) bodies may
             // omit it, so cap accumulated bytes here too — otherwise a
             // single CL-less stream can grow request_body_buf without
@@ -3712,16 +3708,9 @@ where
 
                 let total = bytes.len() + chunk.len();
                 'getter: {
-                    // if (total <= jsc.WebCore.InlineBlob.available_bytes) {
-                    //     if (total == 0) {
-                    //         body.value = .{ .Empty = {} };
-                    //         break :getter;
-                    //     }
-                    //
-                    //     body.value = .{ .InlineBlob = jsc.WebCore.InlineBlob.concat(bytes.items, chunk) };
-                    //     this.request_body_buf.clearAndFree(this.allocator);
-                    // } else {
-                    // TODO(port): ensureTotalCapacityPrecise can OOM in Zig; Rust Vec aborts.
+                    // TODO: small-body fast path via InlineBlob is not
+                    // implemented; always build an InternalBlob.
+                    // Vec aborts on OOM (repo-wide abort-on-OOM policy).
                     bytes.reserve_exact(total.saturating_sub(bytes.len()));
                     bytes.extend_from_slice(chunk);
                     debug_assert_eq!(bytes.len(), total);
@@ -3729,7 +3718,6 @@ where
                         bytes: core::mem::take(bytes),
                         was_string: false,
                     });
-                    // }
                     break 'getter;
                 }
                 this.request_body_buf = Vec::new();
@@ -3890,13 +3878,13 @@ bun_jsc::jsc_host_abi! {
 }
 
 // ─── per-monomorphization C-ABI exports ──────────────────────────────────────
-// Zig: `comptime { @export(&jsc.toJSHostFn(onResolve), .{ .name = export_prefix ++ "__onResolve" }); ... }`
-// where `export_prefix = "Bun__HTTPRequestContext" ++ (debug ? "Debug" : "") ++ (h3 ? "H3" : ssl ? "TLS" : "")`.
+// The exported symbol name is "Bun__HTTPRequestContext" + (debug ? "Debug" : "")
+// + (h3 ? "H3" : ssl ? "TLS" : "") + "__on*".
 // Rust generics cannot own `#[no_mangle]` symbols, so each of the 6 concrete
 // instantiations × 4 callbacks is spelled out via `request_ctx_exports!`. The
 // generic body lives on the `impl<ThisServer, ..> RequestContext` block above
 // (`on_resolve` / `on_reject` / `on_resolve_stream` / `on_reject_stream`); each
-// shim is the `toJSHostFn` result-mapping (`JsResult<JSValue>` → raw `JSValue`,
+// shim is the result-mapping (`JsResult<JSValue>` → raw `JSValue`,
 // `.zero` on error) over the monomorphic associated fn.
 macro_rules! request_ctx_exports {
     ($(
@@ -3905,7 +3893,7 @@ macro_rules! request_ctx_exports {
     );* $(;)?) => {$(
         // Named C-ABI symbols for the C++ side. The bodies forward to the
         // generic `host_on_*` shims monomorphized at this tuple — `#[no_mangle]`
-        // pins the link name (Zig: `@export(&jsc.toJSHostFn(onResolve), …)`).
+        // pins the link name.
         #[unsafe(no_mangle)]
         #[bun_jsc::host_call]
         pub fn $on_resolve(g: *mut JSGlobalObject, f: *mut CallFrame) -> JSValue {
@@ -4081,9 +4069,8 @@ pub struct SendfileContext {
     pub total: BlobSizeType,
 }
 
-// `NewFlags(comptime debug_mode: bool)` — packed struct(u16). All fields are bool
-// (with two debug-conditional ones), so `bitflags!` over u16 works. The Zig void/padding
-// fields collapse to absent bits in release; here we keep all bits and just gate the
+// All flags are bool (with two debug-conditional ones), so `bitflags!` over u16
+// works. We keep all bits in every build and just gate the
 // `is_web_browser_navigation` / `has_finalized` accessors on the const params.
 bitflags::bitflags! {
     #[derive(Default, Clone, Copy)]
@@ -4222,8 +4209,7 @@ fn get_content_type(headers: Option<&mut FetchHeaders>, blob: &AnyBlob) -> (Mime
                 needs_content_type = false;
 
                 let content_slice = content.to_slice();
-                // Zig: `if (content_slice.allocator.isNull()) null else allocator` —
-                // i.e. dupe only when the latin1/utf16 slice was heap-converted.
+                // Dupe only when the latin1/utf16 slice was heap-converted.
                 let dupe = matches!(content_slice, bun_core::ZigStringSlice::Owned(_));
                 let mt = MimeType::init(
                     content_slice.slice(),
@@ -4255,5 +4241,3 @@ fn get_content_type(headers: Option<&mut FetchHeaders>, blob: &AnyBlob) -> (Mime
 // `NewServer` monomorphizations.
 
 static WELCOME_PAGE_HTML_GZ: &[u8] = include_bytes!("../api/welcome-page.html.gz");
-
-// ported from: src/runtime/server/RequestContext.zig
diff --git a/src/runtime/server/ServerConfig.rs b/src/runtime/server/ServerConfig.rs
index da61463bc2c..590eb66ba30 100644
--- a/src/runtime/server/ServerConfig.rs
+++ b/src/runtime/server/ServerConfig.rs
@@ -17,7 +17,6 @@ use super::{AnyRoute, AnyServer};
 use crate::server::jsc::{JSGlobalObject, JSPropertyIterator, JSValue, JsError, JsResult, Strong};
 use bun_core::fmt as bun_fmt;
 
-// `pub const SSLConfig = @import("../socket/SSLConfig.zig");`
 pub use crate::socket::ssl_config::SSLConfig;
 use crate::socket::ssl_config::SSLConfigFromJs;
 
@@ -26,15 +25,14 @@ pub struct ServerConfig {
     pub idle_timeout: u8, // TODO: should we match websocket default idleTimeout of 120?
     pub has_idle_timeout: bool,
     // TODO: use webkit URL parser instead of bun's
-    // PORT NOTE: Zig stores `base_url: URL` borrowing into `base_uri: []const u8`
-    // (self-referential). Rust keeps only the owned buffer; callers parse on
+    // NOTE: only the owned buffer is stored; callers parse on
     // demand via [`ServerConfig::base_url`] so the borrow lifetime is tied to
-    // `&self` instead of erased to `'static` (PORTING.md §Forbidden — lifetime
-    // extension).
+    // `&self` instead of erased to `'static`.
     pub base_uri: Box<[u8]>,
 
     pub ssl_config: Option<SSLConfig>,
-    // TODO(port): verify Vec<SSLConfig> drops elements; Zig looped + deinit each.
+    // Vec drop runs each element's `Drop`, and `SSLConfig: Drop` calls
+    // `deinit()` (frees the owned C strings).
     pub sni: Option<Vec<SSLConfig>>,
     pub max_request_body_size: usize,
     pub development: DevelopmentOption,
@@ -108,7 +106,7 @@ pub enum Address {
         port: u16,
         hostname: Option<ZBox>,
     },
-    /// Zig `[:0]const u8` — leading NUL is valid (Linux abstract sockets).
+    /// Leading NUL is valid (Linux abstract sockets).
     Unix(ZBox),
 }
 
@@ -121,8 +119,7 @@ impl Default for Address {
     }
 }
 
-// PORT NOTE: Zig `address.deinit(allocator)` freed hostname/unix and reset to .tcp{}.
-// In Rust, ZBox frees on Drop; resetting is `*self = Address::default()`.
+// ZBox frees on Drop; resetting is `*self = Address::default()`.
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum DevelopmentOption {
@@ -146,9 +143,8 @@ impl ServerConfig {
         self.development.is_development()
     }
 
-    /// Parsed view over [`Self::base_uri`]. Replaces the Zig `base_url: URL`
-    /// field, which borrowed self-referentially into `base_uri`.
-    // PERF(port): re-parses on each call. The only out-of-module reader takes
+    /// Parsed view over [`Self::base_uri`].
+    // PERF: re-parses on each call. The only out-of-module reader takes
     // `href` (== `base_uri`) directly; in-module reads happen once in `from_js`.
     #[inline]
     pub fn base_url(&self) -> URL<'_> {
@@ -191,8 +187,6 @@ impl Default for RouteDeclaration {
     }
 }
 
-// PORT NOTE: Zig `RouteDeclaration.deinit` only freed `path`; ZBox drops automatically.
-
 // TODO: rename to StaticRoute.Entry
 pub struct StaticRouteEntry {
     pub path: Box<[u8]>,
@@ -254,28 +248,19 @@ impl ServerConfig {
         }
 
         // sort the cloned static routes by name for determinism
-        // PORT NOTE: Zig `std.mem.sort` takes a strict-weak `lessThan(a,b)` and
-        // tolerates `false`/`false` for equal elements; Rust `sort_by` requires
-        // a total `Ordering`. `is_less_than` ≡ `strings::order(a,b) == Greater`
-        // (descending by path), so the 3-way equivalent is `order(b, a)`.
+        // (descending by path: `order(b, a)`).
         list.sort_by(|a, b| strings::order(&b.path, &a.path));
 
         Ok(())
     }
 
     pub fn clone_for_reloading_static_routes(&mut self) -> Result<ServerConfig, bun_core::Error> {
-        // Zig: `var that = this.*` (bitwise copy) then nulls ONLY {ssl_config,
-        // sni, address, websocket, bake} on `this`, leaving `this` aliasing
-        // every other heap field with `that`. The sole caller is
-        // `self.config = self.config.clone_for_reloading_static_routes()?;`, so
-        // the residual `self` is overwritten by `that` on success without
-        // running `deinit`, and the aliasing is benign.
-        //
-        // Rust cannot alias owned Vec/Box/Strong; instead move every owning
-        // field into `that` and leave the Copy scalars in place on `self` —
-        // matching Zig's observable post-state for `self` (idle_timeout,
-        // development, reuse_port, http1/http3, etc. retained; resources gone) and
-        // ensuring the assignment-drop of the residual `self` is a no-op.
+        // The sole caller is
+        // `self.config = self.config.clone_for_reloading_static_routes()?;`.
+        // Move every owning field into `that` and leave the Copy scalars in
+        // place on `self` (idle_timeout, development, reuse_port, http1/http3,
+        // etc. retained; resources gone), ensuring the assignment-drop of the
+        // residual `self` is a no-op.
         let mut that = ServerConfig {
             address: core::mem::take(&mut self.address),
             idle_timeout: self.idle_timeout,
@@ -318,7 +303,6 @@ impl ServerConfig {
         route: AnyRoute,
         method: MethodOptional,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.static_routes.push(StaticRouteEntry {
             path: Box::<[u8]>::from(path),
             route,
@@ -328,10 +312,8 @@ impl ServerConfig {
     }
 }
 
-// PORT NOTE: Zig `applyStaticRoute` used comptime closures over (ssl, T) passed
-// as C-style fn pointers to uws app.head/any/method. Rust monomorphizes free
-// `extern "C"` fns per `<SSL, T>` and registers them via the raw
-// `c::uws_method_handler` overload — equivalent to the Zig `handler_wrap` struct.
+// NOTE: free `extern "C"` fns are monomorphized per `<SSL, T>` and registered
+// via the raw `c::uws_method_handler` overload.
 
 /// # Safety
 /// `entry` must be a live route pointer that outlives `app` — it is registered
@@ -367,7 +349,7 @@ pub(crate) fn apply_static_route<const SSL: bool, T>(
         let route = user_data.cast::<T>();
         let resp = uws::NewAppResponse::<SSL>::cast_res(resp);
         // `Response<SSL>` is a `#[repr(C)]` opaque over `uws_res`; pointer cast
-        // selects the matching `AnyResponse` variant for the comptime SSL flag.
+        // selects the matching `AnyResponse` variant for the const-generic SSL flag.
         let any_resp = if SSL {
             bun_uws_sys::AnyResponse::SSL(resp.cast())
         } else {
@@ -473,8 +455,8 @@ pub(crate) fn apply_static_route_h3<T>(
     }
 }
 
-/// Per-route trait that `apply_static_route{,_h3}` monomorphizes over —
-/// expresses Zig's `comptime T: type` (`StaticRoute`/`FileRoute`/`HTMLBundle.Route`).
+/// Per-route trait that `apply_static_route{,_h3}` monomorphizes over
+/// (`StaticRoute`/`FileRoute`/`HTMLBundle.Route`).
 /// Receivers are raw `*mut Self` because the route is registered as the uWS
 /// userdata pointer and the inherent impls (`StaticRoute::on_request` etc.) need
 /// `*mut` to mutate state and stash `self` into onAborted callbacks.
@@ -496,10 +478,9 @@ pub(crate) trait StaticRouteLike<const SSL: bool>: 'static {
     );
 }
 
-// PORT NOTE (layering): the original `RequestUnion`/`ResponseUnion` placeholders
-// were duplicates of `bun_uws_sys::AnyRequest`/`AnyResponse` (which already
-// model Zig's `.{ .h1 = req }` / `.{ .SSL = resp }`). Re-export the real types
-// so any straggler reference resolves to the canonical opaque.
+// NOTE (layering): the original `RequestUnion`/`ResponseUnion` placeholders
+// were duplicates of `bun_uws_sys::AnyRequest`/`AnyResponse`. Re-export the
+// real types so any straggler reference resolves to the canonical opaque.
 pub use bun_uws_sys::AnyRequest as RequestUnion;
 pub use bun_uws_sys::AnyResponse as ResponseUnion;
 
@@ -662,8 +643,7 @@ fn get_routes_object(global: &JSGlobalObject, arg: JSValue) -> JsResult<Option<J
 
 /// Bridge `crate::bake::FileSystemRouterType` (Cow-backed, populated by
 /// `server_body::AnyRoute::from_js`) into `bake_body::FileSystemRouterType`
-/// (`&'static [u8]`-backed, consumed by `Framework::auto`). Both mirror Zig's
-/// single `bake.Framework.FileSystemRouterType`; the duplication is a
+/// (`&'static [u8]`-backed, consumed by `Framework::auto`). The duplication is a
 /// layering wart and this conversion stands in for an arena-dupe until the two
 /// structs unify. All bytes are duped into `arena` so the resulting `&'static`
 /// slices live as long as `UserOptions.arena`.
@@ -672,7 +652,7 @@ fn convert_file_system_router_type(
     src: crate::bake::FileSystemRouterType,
 ) -> crate::bake::bake_body::FileSystemRouterType {
     use crate::bake::bake_body as bb;
-    // PORT NOTE: `bb::arena_erase` is the single sanctioned `'bump → 'static`
+    // NOTE: `bb::arena_erase` is the single sanctioned `'bump → 'static`
     // erasure for the `UserOptions.arena` self-referential pattern; bake_body's
     // own `Framework::from_js` / `resolve` use it identically.
     // TODO(refactor): thread a real `'bump` through `bb::Framework`/
@@ -732,8 +712,6 @@ impl ServerConfig {
         };
         let mut has_hostname = false;
 
-        // PORT NOTE: Zig `defer { if !hmr { assert(bake == null) } }` — moved to end of fn.
-
         if env.get(b"NODE_ENV").unwrap_or(b"") == b"production" {
             args.development = DevelopmentOption::Production;
         }
@@ -774,12 +752,10 @@ impl ServerConfig {
         };
 
         if let Some(origin) = &arguments.vm.transpiler.options.transform_options.origin {
-            // Zig: dupeZ — but base_uri is []const u8; the NUL is incidental.
             args.base_uri = Box::<[u8]>::from(origin.as_ref());
         }
 
-        // PORT NOTE: Zig `defer { if global.hasException() { ssl_config.deinit() } }` —
-        // SSLConfig drops automatically when `args` drops on error path.
+        // NOTE: SSLConfig drops automatically when `args` drops on error path.
 
         let Some(arg) = arguments.next() else {
             return Err(global.throw_invalid_arguments(format_args!("Bun.serve expects an object")));
@@ -841,8 +817,6 @@ impl ServerConfig {
             };
             args.had_routes_object = true;
 
-            // PORT NOTE: in Zig the iterator options are a comptime struct; the
-            // Rust port carries them as a runtime arg to `init()`.
             // SAFETY: `get_object()` returned Some, so the pointer is a live JSObject.
             let static_obj: &bun_jsc::JSObject = unsafe { &*static_obj };
             let mut iter = JSPropertyIterator::init(
@@ -857,9 +831,8 @@ impl ServerConfig {
             // iter drops at scope end
 
             let mut init_ctx_ = ServerInitContext {
-                // PORT NOTE: Zig threaded a `std.heap.ArenaAllocator` here; the
-                // Rust `ServerInitContext` dropped that field — bake owns the
-                // arena instead (created below and moved into `UserOptions`).
+                // NOTE: bake owns the arena (created below and moved into
+                // `UserOptions`).
                 dedupe_html_bundle_map: Default::default(),
                 framework_router_list: Vec::new(),
                 js_string_allocations: crate::bake::StringRefList::EMPTY,
@@ -867,21 +840,20 @@ impl ServerConfig {
                 global,
             };
             let init_ctx = &mut init_ctx_;
-            // errdefer { init_ctx.arena.deinit(); init_ctx.framework_router_list.deinit(); }
-            // — arena/Vec are owned locals; drop on `?` automatically. Ownership
+            // arena/Vec are owned locals; drop on `?` automatically. Ownership
             // transfers to args.bake on the success path via mem::take below.
             // (dedupe_html_bundle_map is unused on the success path; drops at scope end.)
 
-            // errdefer { for static_routes |r| r.deinit(); clearAndFree() }
-            // — Vec<StaticRouteEntry> drops elements (which deref route) automatically on error.
+            // Vec<StaticRouteEntry> drops elements (which deref route)
+            // automatically on error.
 
             while let Some(key) = iter.next()? {
-                // PORT NOTE: `to_owned_slice_returning_all_ascii` not yet on
+                // NOTE: `to_owned_slice_returning_all_ascii` not yet on
                 // `bun_core::String`; split into `to_owned_slice()` + `is_all_ascii`.
                 let path_vec = key.to_owned_slice();
                 let is_ascii = strings::is_all_ascii(&path_vec);
                 let path: Box<[u8]> = path_vec.into_boxed_slice();
-                // errdefer free(path) — Box drops on error
+                // The path Box drops on error.
 
                 let value: JSValue = iter.value;
 
@@ -904,8 +876,8 @@ impl ServerConfig {
                 }
 
                 if value == JSValue::FALSE {
-                    // Zig: `dupeZ(u8, path)` — appends a sentinel NUL without
-                    // rejecting interior NULs (which already passed `is_all_ascii`).
+                    // Appends a sentinel NUL without rejecting interior NULs
+                    // (which already passed `is_all_ascii`).
                     let duped = ZBox::from_bytes(&*path);
                     args.negative_routes.push(duped);
                     continue;
@@ -1025,11 +997,8 @@ impl ServerConfig {
                     use crate::bake::bake_body as bb;
                     use bun_options_types::schema::api::DotEnvBehavior;
 
-                    // PORT NOTE: Zig threaded `init_ctx.arena` from
-                    // `ServerInitContext`; the Rust `ServerInitContext` dropped
-                    // that field, so the arena is created here and moved into
-                    // `UserOptions` (same lifetime: lives until `args.bake`
-                    // is dropped).
+                    // NOTE: the arena is created here and moved into
+                    // `UserOptions` (lives until `args.bake` is dropped).
                     let arena = bun_alloc::Arena::new();
 
                     let root = bb::arena_dupe_z(
@@ -1068,7 +1037,7 @@ impl ServerConfig {
 
                     match o.serve_env_behavior {
                         DotEnvBehavior::prefix => {
-                            // PORT NOTE: `serve_env_prefix` is `Option<Box<[u8]>>`
+                            // NOTE: `serve_env_prefix` is `Option<Box<[u8]>>`
                             // owned by the long-lived `transform_options`; dupe
                             // into the arena so the `&'static [u8]` field is
                             // backed by `UserOptions.arena`.
@@ -1100,12 +1069,7 @@ impl ServerConfig {
                             "FrameworkRouter is currently only supported when `development: true`",
                         )));
                     }
-                    // init_ctx.arena drops at scope end
                 }
-            } else {
-                // TODO(port): Zig asserted arena was empty (state.end_index == 0 && first == null).
-                // bumpalo has no equivalent; skip assertion.
-                // init_ctx.arena drops at scope end
             }
         }
 
@@ -1145,7 +1109,7 @@ impl ServerConfig {
                     .throw_invalid_arguments(format_args!("Expected websocket to be an object")));
             }
 
-            // errdefer ssl_config.deinit() — drops with args on error
+            // `ssl_config` drops with args on error.
             args.websocket = Some(super::web_socket_server_context::on_create(
                 global,
                 websocket_object,
@@ -1193,7 +1157,7 @@ impl ServerConfig {
             let host_str = host.to_utf8();
 
             if !host_str.slice().is_empty() {
-                // Zig: `dupeZ(u8, host_str.slice())` — does not reject interior
+                // Does not reject interior
                 // NUL; the C `bind()` consumer will simply truncate at it.
                 let hostname = ZBox::from_bytes(host_str.slice());
                 if let Address::Tcp { hostname: h, .. } = &mut args.address {
@@ -1382,7 +1346,6 @@ impl ServerConfig {
                         if args.ssl_config.is_none() {
                             args.ssl_config = Some(ssl_config);
                         } else {
-                            // Zig: `ssl_config.server_name[0] == 0` (empty C string)
                             if ssl_config.server_name_bytes().unwrap_or(b"").is_empty() {
                                 drop(ssl_config);
                                 return Err(global.throw_invalid_arguments(format_args!(
@@ -1509,7 +1472,6 @@ impl ServerConfig {
                         );
                     }
                 }
-                // Zig: `const original_base_uri = args.base_uri; defer free(original_base_uri);`
                 // `base_url` (and so `hostname`/`pathname`) borrow into the
                 // original allocation; drop the borrow before reassigning.
                 drop(base_url);
@@ -1599,7 +1561,7 @@ impl ServerConfig {
             )));
         }
 
-        // PORT NOTE: deferred assertion from top of fn
+        // NOTE: deferred assertion from top of fn
         if !args.development.is_hmr_enabled() {
             debug_assert!(args.bake.is_none());
         }
@@ -1629,5 +1591,3 @@ pub struct UserRouteBuilder {
     pub route: RouteDeclaration,
     pub callback: Strong, // jsc.Strong.Optional
 }
-
-// ported from: src/runtime/server/ServerConfig.zig
diff --git a/src/runtime/server/ServerWebSocket.rs b/src/runtime/server/ServerWebSocket.rs
index f96e505bd06..5fb0c0e297b 100644
--- a/src/runtime/server/ServerWebSocket.rs
+++ b/src/runtime/server/ServerWebSocket.rs
@@ -17,12 +17,11 @@ use crate::server::web_socket_server_context::HandlerFlags;
 
 bun_output::declare_scope!(WebSocketServer, visible);
 
-// PORT NOTE: `'a` on a `.classes.ts` m_ctx payload is wrong — the JS wrapper
-// outlives any stack frame. LIFETIMES.tsv says BORROW_PARAM but the handler
-// lives in `ServerConfig.websocket` for the server's lifetime. Raw `*const` +
-// SAFETY notes is the runtime shape.
+// No `'a` on a `.classes.ts` m_ctx payload — the JS wrapper outlives any
+// stack frame. The handler lives in `ServerConfig.websocket` for the server's
+// lifetime, so a raw back-pointer + SAFETY notes is the runtime shape.
 //
-// R-2 (PORT_NOTES_PLAN): every uws/JS callback into this socket can re-enter
+// R-2: every uws/JS callback into this socket can re-enter
 // — `on_open` → `ws.cork(JS)` → `ws.close()` → `on_close` mutates `flags` /
 // `this_value` on the SAME `m_ctx`. A `&mut Self` receiver would alias under
 // Stacked Borrows. Receivers therefore take `&self`; per-field interior
@@ -33,14 +32,14 @@ pub struct ServerWebSocket {
     handler: bun_ptr::BackRef<WebSocketServerHandler>,
     this_value: JsCell<JsRef>,
     flags: Cell<Flags>,
-    // PORT NOTE (§Pointers): `?*bun.webcore.AbortSignal` is an opaque C++ type
+    // `AbortSignal` is an opaque C++ type
     // with intrusive WebCore ref-counting (ref/unref) — never `Arc`. The init
     // caller transfers a +1 ref; `finalize`/`on_close` unref it.
     signal: Cell<Option<NonNull<AbortSignal>>>,
 }
 
-// We pack the per-socket data into this struct below
-// Zig: packed struct(u64) { ssl:1, closed:1, opened:1, binary_type:4, packed_websocket_ptr:57 }
+// We pack the per-socket data into this struct below:
+// ssl:1, closed:1, opened:1, binary_type:4, packed_websocket_ptr:57
 #[repr(transparent)]
 #[derive(Copy, Clone, Default)]
 pub struct Flags(u64);
@@ -110,7 +109,7 @@ impl Flags {
             12 => BinaryType::BigInt64Array,
             13 => BinaryType::BigUint64Array,
             // 4-bit field; only `set_binary_type` writes it, so 14/15 indicate
-            // memory corruption — trap (matches Zig's safety-checked enum cast).
+            // memory corruption — trap.
             n => unreachable!("invalid BinaryType {n}"),
         }
     }
@@ -159,8 +158,7 @@ pub mod js {
 ///
 /// `len` is the **byte** length actually written — callers holding an
 /// `ArrayBuffer` view must pass `buffer.slice().len()`, not the typed-array
-/// element count. `suffix` is `"bytes"` or `"bytes string"` to preserve the
-/// Zig log shape (ServerWebSocket.zig ~729-1015).
+/// element count. `suffix` is `"bytes"` or `"bytes string"`.
 #[inline]
 fn send_status_to_js(
     status: SendStatus,
@@ -218,16 +216,14 @@ impl ServerWebSocket {
     // ──────────────────────────────────────────────────────────────────────
     // Shared helpers for the publish*/send* family.
     //
-    // The Zig original (ServerWebSocket.zig publish/publishText/publishBinary/
-    // publish*WithoutTypeChecks) open-codes each of these blocks 5-6× with no
-    // shared helper; the Rust port was a 1:1 transliteration. These collapse
-    // the duplication while remaining byte-identical in observable behaviour —
-    // including the `args_len > 1` guard on `compress` even when compress is
-    // args[2] (Zig parity; do not "fix").
+    // These collapse duplicated per-method blocks while remaining
+    // byte-identical in observable behaviour — including the `args_len > 1`
+    // guard on `compress` even when compress is args[2] (long-standing
+    // user-visible behavior; do not "fix").
     //
     // A unified `publish_prologue` covering the full callframe header was
     // considered and rejected: publishText omits the empty-topic check and
-    // reuses "publish" in its min-args message (both Zig-spec), so a single
+    // reuses "publish" in its min-args message (both user-visible), so a single
     // prologue would either change user-visible errors or carry per-caller
     // bool flags — net more code than three small orthogonal helpers.
     // ──────────────────────────────────────────────────────────────────────
@@ -249,7 +245,7 @@ impl ServerWebSocket {
     }
 
     /// Shared `compress` argument validation for publish*/send*. Preserves the
-    /// Zig `args.len > 1` guard verbatim (even where compress is `args[2]`).
+    /// `args.len > 1` guard verbatim (even where compress is `args[2]`).
     #[inline]
     fn parse_compress_arg(
         global_this: &JSGlobalObject,
@@ -392,7 +388,7 @@ impl ServerWebSocket {
 
         let handler = self.handler();
         let vm = handler.vm();
-        // PORT NOTE: reshaped for borrowck — handler is &'a, mutate via interior helper
+        // The handler is shared (&), so mutate via the interior-mutability helper.
         handler.active_connections_saturating_add(1);
         let global_object = handler.global_object();
         let on_open_handler = handler.on_open;
@@ -506,7 +502,7 @@ impl ServerWebSocket {
         if let Some(promise) = result.as_any_promise() {
             match promise.status() {
                 jsc::js_promise::Status::Rejected => {
-                    // Zig: `_ = promise.result(vm)` — value discarded; the side
+                    // Value discarded; the side
                     // effect (JSC__JSPromise__result) conditionally sets
                     // `isHandledFlag` so this doesn't surface as an
                     // unhandledRejection.
@@ -646,7 +642,7 @@ impl ServerWebSocket {
         }
         let signal = self.signal.take();
 
-        // PORT NOTE: reshaped for borrowck — Zig defer block; downgrade + signal
+        // Downgrade + signal
         // cleanup runs at fn exit. `this_value` is not mutated between here and
         // the deferred `downgrade()`, so hoisting these reads is sound.
         let was_not_empty = self.this_value.get().is_not_empty();
@@ -734,7 +730,7 @@ impl ServerWebSocket {
         Wrap::<ServerType, Self, SSL>::apply(opts)
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the constructor extern shim is
+    // No `#[bun_jsc::host_fn]` here — the constructor extern shim is
     // emitted by `generated_classes.rs`, which calls `<Self>::constructor`
     // directly.
     pub fn constructor(
@@ -1235,7 +1231,6 @@ impl ServerWebSocket {
         self.send_ping(global_this, callframe, "pong", Opcode::Pong)
     }
 
-    // PERF(port): was comptime monomorphization (name + opcode) — profile if hot.
     #[inline]
     fn send_ping(
         &self,
@@ -1494,9 +1489,8 @@ impl ServerWebSocket {
         let mut text_buf = [0u8; 512];
 
         let address_bytes = self.websocket().get_remote_address(&mut buf);
-        // Zig: `std.net.Address.initIp{4,6}(.., 0)` → `bun.fmt.formatIp` (strips
-        // trailing `:port` and `[..]`). Mirror with `SocketAddr{V4,V6}` so
-        // `format_ip`'s strip logic sees the same `addr:port` / `[addr]:port`
+        // `format_ip` strips trailing `:port` and `[..]`. Use `SocketAddr{V4,V6}` so
+        // `format_ip`'s strip logic sees the expected `addr:port` / `[addr]:port`
         // shape — passing a bare `IpAddr` would corrupt IPv6 (no brackets/port,
         // so the rfind(':') strip eats the last hextet).
         let address: std::net::SocketAddr = match address_bytes.len() {
@@ -1519,9 +1513,7 @@ impl ServerWebSocket {
     }
 }
 
-// Zig: `WebSocketBehavior.Wrap(ServerType, @This(), ssl)` duck-types `@This()`
-// for `onOpen`/`onMessage`/etc. via `@hasDecl`. Rust needs an explicit trait
-// impl; delegate straight to the inherent methods above.
+// Delegate straight to the inherent methods above.
 impl WebSocketHandler for ServerWebSocket {
     // R-2: trait keeps `*mut Self` (FFI userdata round-trip needs raw write
     // provenance); the single `&*this` reborrow here is the ONE audited unsafe
@@ -1584,5 +1576,3 @@ impl<'a> Corker<'a> {
         };
     }
 }
-
-// ported from: src/runtime/server/ServerWebSocket.zig
diff --git a/src/runtime/server/StaticRoute.rs b/src/runtime/server/StaticRoute.rs
index d1a142ebcbc..5a038852f9f 100644
--- a/src/runtime/server/StaticRoute.rs
+++ b/src/runtime/server/StaticRoute.rs
@@ -21,7 +21,7 @@ use crate::webcore::headers_ref::any_blob_content_type;
 use crate::webcore::{AnyBlob, FetchHeaders, InternalBlob, Response};
 
 // bun.ptr.RefCount(@This(), "ref_count", deinit, .{}) — single-thread refcount.
-// PORT NOTE (§Pointers): `*StaticRoute` is also passed as uws onAborted/
+// `*StaticRoute` is also passed as uws onAborted/
 // onWritable userdata; the intrusive `ref_count` Cell + `*mut Self` receivers
 // preserve write provenance through the FFI userdata round-trip so the eventual
 // `heap::take` in `deref_` is sound.
@@ -29,8 +29,7 @@ use crate::webcore::{AnyBlob, FetchHeaders, InternalBlob, Response};
 pub struct StaticRoute {
     // TODO: Remove optional. StaticRoute requires a server object or else it will
     // not ensure it is alive while sending a large blob.
-    // `pub(super)` so sibling route modules (HTMLBundle) can construct directly
-    // (Zig `bun.new(StaticRoute, .{ .ref_count = .init(), ... })`).
+    // `pub(super)` so sibling route modules (HTMLBundle) can construct directly.
     pub(super) ref_count: Cell<u32>,
     pub server: Cell<Option<AnyServer>>,
     pub status_code: u16,
@@ -62,7 +61,7 @@ impl<'a> Default for InitFromBytesOptions<'a> {
 impl StaticRoute {
     // pub const ref / deref — intrusive refcount accessors.
     // `ref_()`/`deref()` are provided by `#[derive(CellRefCounted)]`; `deref_`
-    // is kept as a thin alias so existing call sites (and Zig parity) keep
+    // is kept as a thin alias so existing call sites keep
     // working without renaming.
     /// # Safety
     /// `this` must have been produced by `heap::alloc` in one of the
@@ -76,8 +75,7 @@ impl StaticRoute {
     }
 
     /// Ownership of `blob` is transferred to this function.
-    // PORT NOTE: Zig takes `*const AnyBlob` and bit-copies (`blob.*`) into the
-    // route, relying on no-auto-drop. Rust `AnyBlob` has drop glue (e.g.
+    // `AnyBlob` has drop glue (e.g.
     // `InternalBlob.bytes: Vec<u8>`), so a `&AnyBlob` + `ptr::read` would alias
     // and double-free when the caller's value drops. Take by value instead.
     pub fn init_from_any_blob(
@@ -251,7 +249,7 @@ impl StaticRoute {
     // HEAD requests have no body.
     /// # Safety
     /// `this` must point to a live heap-allocated `StaticRoute` produced by one of
-    /// the constructors (write provenance intact). Mirrors Zig `*StaticRoute` receiver.
+    /// the constructors (write provenance intact).
     pub unsafe fn on_head_request(this: *mut Self, mut req: AnyRequest, resp: AnyResponse) {
         // SAFETY: caller contract.
         unsafe {
@@ -468,7 +466,6 @@ impl StaticRoute {
                 &buf[value.offset as usize..][..value.length as usize],
             );
         }
-        // Zig: `if (comptime tag != .H3) ... s.writeHeader("alt-svc", alt)`.
         if !matches!(resp, AnyResponse::H3(_)) {
             if let Some(srv) = self.server.get() {
                 if let Some(alt) = srv.h3_alt_svc() {
@@ -554,7 +551,6 @@ impl StaticRoute {
 
 impl Drop for StaticRoute {
     fn drop(&mut self) {
-        // Zig deinit: blob.detach() + headers.deinit() + bun.destroy(this).
         // Box drop handles the dealloc; Headers has its own Drop.
         self.blob.detach();
     }
diff --git a/src/runtime/server/WebSocketServerContext.rs b/src/runtime/server/WebSocketServerContext.rs
index e793df19576..349517e28fd 100644
--- a/src/runtime/server/WebSocketServerContext.rs
+++ b/src/runtime/server/WebSocketServerContext.rs
@@ -4,9 +4,9 @@ use crate::server::jsc::{JSGlobalObject, JSValue, JsResult, VirtualMachine};
 use bun_uws as uws;
 
 pub struct WebSocketServerContext {
-    // TODO(port): lifetime — Zig leaves this `undefined` and server.zig:2784 assigns it later.
-    // LIFETIMES.tsv = JSC_BORROW; raw ptr until bun_jsc is a dep (shim type is opaque/Copy).
-    pub global_object: *const JSGlobalObject,
+    // Set provisionally in `on_create`; the server overwrites it on
+    // adoption. LIFETIMES.tsv = JSC_BORROW — the global outlives the context.
+    pub global_object: bun_ptr::BackRef<JSGlobalObject>,
     pub handler: Handler,
 
     pub max_payload_length: u32, // default 16MB
@@ -34,7 +34,10 @@ pub struct Handler {
     // LIFETIMES.tsv = STATIC (vm) / JSC_BORROW (global_object) — both outlive the handler.
     pub vm: bun_ptr::BackRef<VirtualMachine>,
     pub global_object: bun_ptr::BackRef<JSGlobalObject>,
-    pub active_connections: usize,
+    /// Mutated through `&Handler` (the field is owned by
+    /// `ServerConfig.websocket` and only ever touched on the JS thread), so
+    /// it's a `Cell`.
+    pub active_connections: core::cell::Cell<usize>,
 
     /// used by publish()
     pub flags: HandlerFlags,
@@ -51,45 +54,31 @@ bitflags::bitflags! {
 }
 
 impl Handler {
-    /// Deref the raw `global_object` pointer.
-    /// SAFETY: `global_object` is set by the server before any websocket
-    /// connection exists and outlives every `ServerWebSocket`.
+    /// `global_object` is a `BackRef` set by the server before any websocket
+    /// connection exists; the global outlives every `ServerWebSocket`.
     #[inline]
     pub fn global_object(&self) -> &JSGlobalObject {
         self.global_object.get()
     }
 
-    /// Deref the raw `vm` pointer.
-    /// SAFETY: `vm` is `'static` per LIFETIMES.tsv (set in `from_js`).
+    /// `vm` is a `BackRef`; the VM is `'static` per LIFETIMES.tsv (set in
+    /// `from_js`).
     #[inline]
     pub fn vm(&self) -> &VirtualMachine {
         self.vm.get()
     }
 
-    /// Zig: `handler.active_connections +|= n` through a `*Handler`.
-    /// PORT NOTE: takes `&self` and casts away const — the field is owned by
-    /// `ServerConfig.websocket` and only ever touched on the JS thread, so the
-    /// data race the borrow-checker would flag here is a false positive.
-    /// TODO(port): convert `active_connections` to `Cell<usize>`.
     #[inline]
     pub fn active_connections_saturating_add(&self, n: usize) {
-        // SAFETY: single-threaded JS heap; see PORT NOTE above. `addr_of!` avoids
-        // materializing an intermediate `&usize` (invalid_reference_casting lint).
-        unsafe {
-            let p = core::ptr::addr_of!(self.active_connections).cast_mut();
-            *p = (*p).saturating_add(n);
-        }
+        self.active_connections
+            .set(self.active_connections.get().saturating_add(n));
     }
 
-    /// Zig: `handler.active_connections -|= n` — see `active_connections_saturating_add`.
+    /// See `active_connections_saturating_add`.
     #[inline]
     pub fn active_connections_saturating_sub(&self, n: usize) {
-        // SAFETY: single-threaded JS heap; see PORT NOTE above. `addr_of!` avoids
-        // materializing an intermediate `&usize` (invalid_reference_casting lint).
-        unsafe {
-            let p = core::ptr::addr_of!(self.active_connections).cast_mut();
-            *p = (*p).saturating_sub(n);
-        }
+        self.active_connections
+            .set(self.active_connections.get().saturating_sub(n));
     }
 
     pub fn run_error_callback(
@@ -106,7 +95,7 @@ impl Handler {
             return;
         }
 
-        // Zig signature is `vm: *jsc.VirtualMachine` (mutable). VirtualMachine is the
+        // VirtualMachine is the
         // process-lifetime singleton (LIFETIMES.tsv = STATIC) and is only touched on the JS
         // thread; `uncaught_exception` needs `&mut` to bump counters / set flags. Derive the
         // mutable pointer from the stored BackRef (== `vm`) rather than casting the
@@ -130,15 +119,13 @@ impl Handler {
             app: None,
             vm: bun_ptr::BackRef::new(VirtualMachine::get()),
             global_object: bun_ptr::BackRef::new(global_object),
-            active_connections: 0,
+            active_connections: core::cell::Cell::new(0),
             flags: HandlerFlags::empty(),
         };
 
         let mut valid = false;
 
-        // PORT NOTE: Zig used `inline for` over a tuple of (key, field-name) pairs with
-        // `@field(handler, pair[1]) = cb`. Rust has no field-by-name reflection, so we
-        // iterate over (key, &mut field) pairs instead — disjoint field borrows are allowed.
+        // NOTE: iterate over (key, &mut field) pairs — disjoint field borrows are allowed.
         let pairs: [(&'static str, &mut JSValue); 7] = [
             ("error", &mut handler.on_error),
             ("message", &mut handler.on_message),
@@ -252,30 +239,27 @@ static DECOMPRESS_TABLE: phf::Map<&'static [u8], i32> = phf::phf_map! {
     b"256KB" => uws::DEDICATED_COMPRESSOR_256KB,
 };
 
-// TODO(port): phf custom hasher — Zig used `.getWithEql(zig_string, ZigString.eqlComptime)`,
-// which compares a ZigString (possibly UTF-16) against the literal keys. Here we go through
-// `ZigString::as_bytes_if_latin1()` (or equivalent) and look up in the phf map; verify
-// UTF-16-backed ZigStrings still match.
+// The key may be a possibly-UTF-16 ZigString. Derive a UTF-8 view
+// first (`to_slice_fast` allocates only for 16-bit-backed strings) so
+// UTF-16-backed option strings like `compression: "16KB"` still match.
 fn lookup_zig_string(
     table: &phf::Map<&'static [u8], i32>,
     key: &bun_core::ZigString,
 ) -> Option<i32> {
-    table.get(key.slice()).copied()
+    let utf8 = key.to_slice_fast();
+    table.get(utf8.slice()).copied()
 }
 
 pub(crate) fn on_create(
     global_object: &JSGlobalObject,
     object: JSValue,
 ) -> JsResult<WebSocketServerContext> {
-    // PORT NOTE: Zig wrote `var server = WebSocketServerContext{};` (all field defaults,
-    // `globalObject`/`handler.vm`/`handler.globalObject` left `undefined`) and then assigned
-    // `server.handler` on the next line. Rust cannot leave `&JSGlobalObject` fields
-    // uninitialized, so we construct the struct with the handler and explicit defaults
-    // up front. The top-level `global_object` is provisionally set to the param; server.zig
-    // overwrites it after `on_create` returns anyway.
+    // Construct the struct with the handler and explicit defaults up front.
+    // The top-level `global_object` is provisionally set to the param; the
+    // server overwrites it after `on_create` returns anyway.
     let handler = Handler::from_js(global_object, object)?;
     let mut server = WebSocketServerContext {
-        global_object,
+        global_object: bun_ptr::BackRef::new(global_object),
         handler,
         max_payload_length: 1024 * 1024 * 16, // 16MB
         max_lifetime: 0,
@@ -443,5 +427,3 @@ pub(crate) fn on_create(
     server.protect();
     Ok(server)
 }
-
-// ported from: src/runtime/server/WebSocketServerContext.zig
diff --git a/src/runtime/server/mod.rs b/src/runtime/server/mod.rs
index 01945a91c90..26b8999d178 100644
--- a/src/runtime/server/mod.rs
+++ b/src/runtime/server/mod.rs
@@ -1,5 +1,3 @@
-//! Port of src/runtime/server/server.zig
-//!
 //! cycle-5: un-gated `NewServer` struct + lifecycle skeleton (start/stop/listen),
 //! `AnyServer` dispatch, `AnyRoute`, and the per-file submodules. JS callback
 //! bodies (`on_request`, `on_upgrade`, `from_js`, …) and methods that need
@@ -121,9 +119,8 @@ pub use server_body::{
 
 // ─── write_status ────────────────────────────────────────────────────────────
 pub fn write_status<const SSL: bool>(resp: *mut uws_sys::NewAppResponse<SSL>, status: u16) {
-    // Zig spec (server.zig:8-16) takes `?*Response` and no-ops on null. The
-    // route handlers (`StaticRoute`/`FileRoute`) call here from completion
-    // paths where the request may already be aborted/detached.
+    // The route handlers (`StaticRoute`/`FileRoute`) call here from completion
+    // paths where the request may already be aborted/detached, so no-op on null.
     if resp.is_null() {
         return;
     }
@@ -143,12 +140,12 @@ pub fn write_status<const SSL: bool>(resp: *mut uws_sys::NewAppResponse<SSL>, st
 }
 
 // ─── AnyRoute ────────────────────────────────────────────────────────────────
-// PORT NOTE (§Pointers): Zig variants are `bun.ptr.RefCount` payloads. All
+// §Pointers: all
 // three concrete route types carry an intrusive `ref_count: Cell<u32>` and are
 // heap-allocated via `heap::alloc`; their pointers round-trip through uws
 // callback userdata (`ctx: *mut c_void`), so `Rc<T>` is unsuitable (would add
 // a second header and break the round-trip). Hold them as raw intrusive
-// pointers — matches Zig `*StaticRoute` / `*FileRoute` / `*HTMLBundle.Route`.
+// pointers.
 pub enum AnyRoute {
     /// Serve a static file — `"/robots.txt": new Response(...)`
     Static(core::ptr::NonNull<StaticRoute>),
@@ -205,7 +202,7 @@ impl AnyRoute {
             AnyRoute::Static(p) => bun_ptr::BackRef::from(*p).server.set(server),
             AnyRoute::File(p) => bun_ptr::BackRef::from(*p).set_server(server),
             AnyRoute::Html(r) => r.data().server.set(server),
-            AnyRoute::FrameworkRouter(_) => {} // DevServer holds its own .server (server.zig:51-58)
+            AnyRoute::FrameworkRouter(_) => {} // DevServer holds its own .server
         }
     }
 
@@ -237,13 +234,10 @@ bitflags::bitflags! {
 /// not a correctness invariant.
 const N_HTTP_METHODS: usize = 36;
 
-/// `fn NewServer(protocol_enum, development_kind) type` — Zig type-generator.
-/// `SSL = (protocol == .https)`, `DEBUG = (development_kind == .debug)`, `HAS_H3 = SSL`.
 pub struct NewServer<const SSL: bool, const DEBUG: bool> {
     pub app: Option<*mut uws_sys::NewApp<SSL>>,
     pub listener: Option<*mut uws_sys::app::ListenSocket<SSL>>,
-    // TODO(port): conditional field — Zig `if (has_h3) ?*H3.App else void`.
-    // Kept as Option; never set when !SSL.
+    // Never set when !SSL.
     pub h3_app: Option<*mut uws_sys::h3::App>,
     pub h3_listener: Option<*mut uws_sys::h3::ListenSocket>,
     /// Cached `h3=":<port>"; ma=86400` for Alt-Svc on H1 responses; formatted
@@ -255,7 +249,7 @@ pub struct NewServer<const SSL: bool, const DEBUG: bool> {
     // `Deref` while keeping the struct `'static` (process-lifetime VM).
     pub vm: bun_ptr::BackRef<jsc::VirtualMachine>,
     pub global_this: *const jsc::JSGlobalObject,
-    /// Packed `bun.ptr.TaggedPointerUnion` wire-format `AnyServer` for this
+    /// Packed tagged-pointer wire-format `AnyServer` for this
     /// server (`u49` heap addr | `u15` variant tag), computed once in
     /// [`Self::init`]. The C++ `node:http` request path needs it on every
     /// request to reconstruct `AnyServer`; it's a pure function of the (stable)
@@ -275,7 +269,6 @@ pub struct NewServer<const SSL: bool, const DEBUG: bool> {
     pub config: ServerConfig,
     pub pending_requests: usize,
     pub request_pool: *mut request_context::RequestContextStackAllocator<Self, SSL, DEBUG, false>,
-    /// Zig: `if (has_h3) *H3RequestContext.RequestContextStackAllocator else void`.
     /// Null until the H3 listen path runs (`HAS_H3 && config.http3`); never
     /// allocated when `!SSL`. Kept as a raw nullable pointer rather than a
     /// conditional field so the struct stays uniform across monomorphizations.
@@ -291,7 +284,7 @@ pub struct NewServer<const SSL: bool, const DEBUG: bool> {
     /// Intrusively-refcounted plugin state. Stored as a `BackRef` (not `Rc`)
     /// because (a) the same `*mut ServePlugins` is smuggled through
     /// `JSValue::then` as a promise context and (b) `ServePlugins` is mutated
-    /// through any owner (Zig spec uses `*ServePlugins` everywhere). The
+    /// through any owner. The
     /// counted ref held here is released in `Drop for NewServer`.
     pub plugins: Option<bun_ptr::BackRef<ServePlugins>>,
 
@@ -314,8 +307,7 @@ pub struct UserRoute<const SSL: bool, const DEBUG: bool> {
 
 impl<const SSL: bool, const DEBUG: bool> Drop for NewServer<SSL, DEBUG> {
     fn drop(&mut self) {
-        // Spec server.zig:deinit — `if (this.plugins) |p| p.deref()`. The
-        // remaining owned fields (config, base_url, h3_alt_svc, dev_server,
+        // The remaining owned fields (config, base_url, h3_alt_svc, dev_server,
         // user_routes, all_closed_promise, on_clienterror) drop automatically.
         if let Some(p) = self.plugins.take() {
             // SAFETY: `plugins` carries the `heap::alloc` provenance from
@@ -325,15 +317,14 @@ impl<const SSL: bool, const DEBUG: bool> Drop for NewServer<SSL, DEBUG> {
     }
 }
 
-// PORT NOTE: Zig `UserRoute.deinit()` only freed `self.route`; RouteDeclaration
-// drops automatically, so an explicit `impl Drop` would double-free.
+// `UserRoute` needs no explicit `impl Drop`: every field drops automatically.
 
 /// Const-generic adapter: `AnyResponse: From<*mut Response<SSL>>` is only
 /// implemented for the two concrete `SSL` values (overlap rules forbid a
 /// blanket impl alongside them), so dispatch at the call boundary.
 #[inline]
 fn any_response_from<const SSL: bool>(resp: *mut uws_sys::NewAppResponse<SSL>) -> uws::AnyResponse {
-    // PORT NOTE: `*mut Response<SSL>` and `*mut Response<true|false>` are
+    // `*mut Response<SSL>` and `*mut Response<true|false>` are
     // distinct types to rustc; route through `.cast()` (the underlying handle
     // is opaque and layout-identical for both instantiations).
     if SSL {
@@ -343,12 +334,10 @@ fn any_response_from<const SSL: bool>(resp: *mut uws_sys::NewAppResponse<SSL>) -
     }
 }
 
-/// HTTP/1 `RequestContext` for a given server monomorphization (Zig:
-/// `RequestContext = NewRequestContext(ssl_enabled, debug_mode, ThisServer)`).
+/// HTTP/1 `RequestContext` for a given server monomorphization.
 pub type ServerRequestContext<const SSL: bool, const DEBUG: bool> =
     request_context::RequestContext<NewServer<SSL, DEBUG>, SSL, DEBUG, false>;
 
-/// `server.zig:CreateJsRequest`.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum CreateJsRequest {
     Yes,
@@ -356,10 +345,10 @@ pub enum CreateJsRequest {
     Bake,
 }
 
-/// `server.zig:PreparedRequest` — bundle of the JS-side `Request`, the heap
+/// Bundle of the JS-side `Request`, the heap
 /// `webcore::Request`, and the per-request `RequestContext`. Only the HTTP/1
-/// instantiation (`PreparedRequestFor(RequestContext)`) is materialized; H3
-/// callers never `save()` (it `@compileError`s in Zig) and the H3 dispatch
+/// instantiation is materialized; H3
+/// callers never `save()` and the H3 dispatch
 /// path is private to `set_routes`.
 pub struct PreparedRequest<const SSL: bool, const DEBUG: bool> {
     pub js_request: JSValue,
@@ -368,7 +357,7 @@ pub struct PreparedRequest<const SSL: bool, const DEBUG: bool> {
 }
 
 impl<const SSL: bool, const DEBUG: bool> PreparedRequest<SSL, DEBUG> {
-    /// `server.zig:PreparedRequest.save` — used by DevServer to defer calling
+    /// Used by DevServer to defer calling
     /// the JS handler until the bundle is actually ready.
     pub fn save(
         self,
@@ -399,8 +388,7 @@ impl<const SSL: bool, const DEBUG: bool> PreparedRequest<SSL, DEBUG> {
 }
 
 /// RAII: on drop, detaches the borrowed stack `uws::Request` from the heap
-/// `webcore::Request` — the Rust spelling of Zig's
-/// `defer request_object.request_context.detachRequest();` so the JS request
+/// `webcore::Request` so the JS request
 /// object never dangles a pointer past the uWS frame it borrowed.
 pub(crate) struct DetachRequestOnDrop(*mut crate::webcore::Request);
 
@@ -524,7 +512,9 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         self.pending_requests += 1;
     }
 
-    /// `server.zig:getURLAsString`.
+    /// Build the server's base URL string (`http(s)://host:port/`, or a
+    /// `unix://`/abstract-socket URL) from the configured listen address.
+    /// Errors only on allocation failure.
     pub fn get_url_as_string(&self) -> Result<bun_core::String, bun_alloc::AllocError> {
         use bun_core::fmt::{URLFormatter, URLProto};
         use std::io::Write as _;
@@ -570,14 +560,16 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         Ok(bun_core::String::clone_utf8(&buf))
     }
 
-    /// `server.zig:jsValueAssertAlive`.
+    /// Return the server's JS object, asserting that the weak ref is still
+    /// alive (callers must only use this while the server JS object is kept
+    /// alive elsewhere).
     pub fn js_value_assert_alive(&self) -> JSValue {
         debug_assert!(self.js_value.is_not_empty());
         self.js_value.try_get().expect("js_value alive")
     }
 
-    /// Per-monomorphization static (Zig: `var did_send_idletimeout_warning_once = false;`).
-    /// PORT NOTE: Rust statics cannot be const-generic; routed through a
+    /// Per-monomorphization static.
+    /// Rust statics cannot be const-generic; routed through a
     /// `&'static AtomicBool` so the four (SSL,DEBUG) instantiations share one
     /// flag — the warning is process-global by intent (printed at most once
     /// regardless of how many servers are running).
@@ -586,8 +578,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         &FLAG
     }
 
-    /// `server.zig:onTimeoutForIdleWarn` — generic over `Ctx::Resp`; the body
-    /// ignores both arguments so a single non-generic shim suffices.
+    /// The body ignores both arguments so a single non-generic shim suffices.
     fn on_timeout_for_idle_warn(_: *mut c_void, _: &mut uws_sys::NewAppResponse<SSL>) {
         if DEBUG && !Self::did_send_idletimeout_warning_once().load(Ordering::Relaxed) {
             if !crate::cli::Command::get().debug.silent {
@@ -599,7 +590,6 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         }
     }
 
-    /// `server.zig:shouldAddTimeoutHandlerForWarning`.
     fn should_add_timeout_handler_for_warning(&self) -> bool {
         if DEBUG {
             if !Self::did_send_idletimeout_warning_once().load(Ordering::Relaxed)
@@ -611,14 +601,13 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         false
     }
 
-    /// `server.zig:prepareJsRequestContext` — the HTTP/1 instantiation
+    /// The HTTP/1 instantiation
     /// (`Ctx == RequestContext`). The `Ctx`-generic `prepareJsRequestContextFor`
     /// is folded directly: const-generic `bool` cannot select an associated
     /// `Req`/`Resp` type in stable Rust without specialization, and the only
     /// other instantiation (H3) populates url/headers eagerly via a separate
     /// codepath. The bake/saved-request callers reached through `AnyServer`
-    /// are HTTP/1-only by construction (`PreparedRequest::save` is
-    /// `@compileError`'d for H3 in Zig).
+    /// are HTTP/1-only by construction.
     ///
     /// # Safety
     /// `this` must point to a live heap-allocated `NewServer` for the duration
@@ -647,8 +636,8 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         // (RFC 9114 §4.2 transfer-encoding check is H3-only — skipped here.)
 
         // Resolve once, reuse for both `has_request_body()` here and the
-        // forward to `RequestContext::create` below. Zig parses inline at both
-        // sites; with `Method::which` now a length-gated match (316a83f) the
+        // forward to `RequestContext::create` below. With `Method::which` now
+        // a length-gated match (316a83f) the
         // second call is cheap, but the resolved value is also what `create`
         // wants — passing `None` made it parse a second time.
         let method = method.or_else(|| bun_http_types::Method::Method::which(req.method()));
@@ -678,7 +667,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
 
         server.on_pending_request();
 
-        // PORT NOTE: `vm.eventLoop().debug.enter()/exit()` is debug-build
+        // `vm.eventLoop().debug.enter()/exit()` is debug-build
         // re-entrancy bookkeeping; `Debug::enter_scope` is the RAII pairing
         // (no-op enter/exit in release builds).
         let vm_ptr = server.vm_mut();
@@ -742,7 +731,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         // SAFETY: slot stays live — both `ctx.request_body` and `Request.body` hold a +1.
         let body_value: *mut crate::webcore::body::Value =
             unsafe { core::ptr::addr_of_mut!((*body_hive.as_ptr()).value) };
-        // Zig: `.body = body.ref()` — bump once so the ctx and JS Request each
+        // Bump once so the ctx and JS Request each
         // own a +1 on the same slot (streamed bytes buffered into the ctx
         // surface on `request.body`/`request.json()`).
         ctx_mut.request_body = Some(body_hive.clone());
@@ -756,7 +745,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         // SAFETY: `signal.ref_()` bumps the intrusive count and returns +1.
         let signal_ref =
             unsafe { jsc::AbortSignalRef::adopt(bun_opaque::opaque_deref_mut(signal).ref_()) };
-        // PORT NOTE (ownership): `Request::new` is `bun.TrivialNew` — the heap
+        // ownership: `Request::new` is `bun.TrivialNew` — the heap
         // allocation is handed to the JS GC via `to_js`/`to_js_for_bake` (C++
         // wrapper finalizer frees it), or, for `CreateJsRequest::No`, retained
         // by `ctx.request_weakref` until `RequestContext::deinit` releases it.
@@ -847,7 +836,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         })
     }
 
-    /// `server.zig:onSavedRequest` — invoke the user's route handler for a
+    /// Invoke the user's route handler for a
     /// request that was deferred (bake bundle-then-serve flow).
     ///
     /// # Safety
@@ -862,7 +851,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
     ) {
         let prepared: PreparedRequest<SSL, DEBUG> = match &req {
             SavedRequestUnion::Stack(r) => {
-                // PORT NOTE: reshaped for borrowck — decouple the inner
+                // reshaped for borrowck — decouple the inner
                 // `&mut uws::Request` lifetime from the `req` match guard.
                 let r = std::ptr::from_ref::<uws::Request>(*r).cast_mut();
                 match Self::prepare_js_request_context(
@@ -896,8 +885,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         let ctx = prepared.ctx;
 
         debug_assert!(!callback.is_empty());
-        // PERF(port): Zig built `[1+N]JSValue` on the stack via comptime concat;
-        // stable Rust forbids `ARG_COUNT + 1` in const-generic array lengths.
+        // PERF: stable Rust forbids `ARG_COUNT + 1` in const-generic array lengths.
         // The conservative GC scan reaches the heap allocation as well as the
         // stack, so a small Vec is sound.
         let mut args: Vec<JSValue> = Vec::with_capacity(ARG_COUNT + 1);
@@ -969,7 +957,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         }
     }
 
-    /// `server.zig:handleRequest` — common tail of `on_request` /
+    /// Common tail of `on_request` /
     /// `on_user_route_request`: hand the user-handler's return value to the
     /// `RequestContext`, then either tear down synchronously or transition to
     /// the async path.
@@ -1030,7 +1018,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         }
     }
 
-    /// `server.zig:onRequest` — dispatch the user `fetch` handler.
+    /// Dispatch the user `fetch` handler.
     ///
     /// # Safety
     /// `this` must point to a live heap-allocated `NewServer` (the userdata
@@ -1074,7 +1062,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         Self::handle_request(this, &should_deinit_context, &prepared, req, response_value);
     }
 
-    /// `server.zig:onUserRouteRequest` — dispatch a per-route handler
+    /// Dispatch a per-route handler
     /// (`routes: { "/path": handler }`).
     ///
     /// # Safety
@@ -1135,7 +1123,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         );
     }
 
-    /// `server.zig:onNodeHTTPRequest` — node:http compat path; thin wrapper
+    /// node:http compat path; thin wrapper
     /// over [`Self::on_node_http_request_with_upgrade_ctx`] with no WS upgrade.
     ///
     /// # Safety
@@ -1151,12 +1139,12 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         Self::on_node_http_request_with_upgrade_ctx(this, req, resp, core::ptr::null_mut());
     }
 
-    /// `server.zig:onNodeHTTPRequestWithUpgradeCtx` — invoke the JS-side
+    /// Invoke the JS-side
     /// `node:http` request handler (`NodeHTTPServer__onRequest_{http,https}`),
-    /// then drive the returned promise / [`NodeHTTPResponse`] through the same
-    /// completion / abort / error paths the Zig spec encodes.
+    /// then drive the returned promise / [`NodeHTTPResponse`] through the
+    /// completion / abort / error paths.
     ///
-    /// PORT NOTE: receiver is `*mut Self` (not `&mut self`) — the body
+    /// receiver is `*mut Self` (not `&mut self`) — the body
     /// re-enters JS (`drain_microtasks`, `then2`) which may call back into
     /// other server methods, so a long-lived `&mut Self` would alias. Each use
     /// site below derives a short-lived borrow that ends before the next
@@ -1220,7 +1208,6 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             },
             None => JSValue::UNDEFINED,
         };
-        // Zig: `this.config.onNodeHTTPRequest` (raw JSValue, may be `.zero`).
         let callback = this_ref
             .config
             .on_node_http_request
@@ -1230,7 +1217,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         // C++ forwards `any_server` to `NodeHTTPResponse::create`, which
         // unpacks it via `any_server_from_packed` (bits 49..64 = variant tag);
         // a raw `*mut Self` would zero those bits and trip the dispatch
-        // `unreachable!`, so the `TaggedPointerUnion` wire format is needed.
+        // `unreachable!`, so the packed tagged-pointer wire format is needed.
         // Computed once in `init()` (stable heap address) — just load it.
         let any_server_packed = this_ref.any_server_packed;
 
@@ -1299,7 +1286,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                             // owned ref held until `deref()` below.
                             let nhr = unsafe { &mut *node_http_response };
                             // Single `Cell` load for all three flag checks (no
-                            // re-entry between them) — Zig reads the packed field once.
+                            // re-entry between them).
                             let nhr_flags = nhr.flags.get();
                             if nhr_flags.contains(NhrFlags::REQUEST_HAS_COMPLETED)
                                 || nhr_flags.contains(NhrFlags::SOCKET_CLOSED)
@@ -1319,7 +1306,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                                 &mut strong_promise,
                                 jsc::StrongOptional::empty(),
                             ));
-                            // PORT NOTE: `#[host_fn(export = …)]` emits its
+                            // `#[host_fn(export = …)]` emits its
                             // C-ABI shim as `__jsc_host_<fn>`; the export name
                             // is link-only.
                             result.then2(
@@ -1357,13 +1344,6 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                             if !nhr_flags.contains(NhrFlags::REQUEST_HAS_COMPLETED)
                                 && raw.state().is_response_pending()
                             {
-                                // PORT NOTE: matches server.zig:2173 verbatim.
-                                // The Zig spec writes a 500 status when
-                                // `isHttpStatusCalled()` is *true* and
-                                // `endStream`s otherwise; NodeHTTPResponse.zig:680
-                                // uses the inverted predicate. The port tracks
-                                // the spec — if the spec is wrong it must be
-                                // fixed there, not silently inverted here.
                                 if raw.state().is_http_status_called() {
                                     raw.write_status(b"500 Internal Server Error");
                                     raw.end_without_body(true);
@@ -1418,7 +1398,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             }
         }
 
-        // PORT NOTE: Zig `defer` cleanup, hoisted out of scopeguards (no early
+        // Cleanup, hoisted out of scopeguards (no early
         // returns above). Reverse-decl order: strong_promise, drain, deref.
         strong_promise.deinit();
         if needs_to_drain {
@@ -1467,8 +1447,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
     }
 
     // `on_reload_from_zig` body lives in `server_body.rs` (`impl NewServer { … }`);
-    // same crate, separate file. Kept there alongside `on_reload`/`reload_static_routes`
-    // so the Zig diff stays side-by-side.
+    // same crate, separate file, alongside `on_reload`/`reload_static_routes`.
 
     pub fn on_static_request_complete(&mut self) {
         self.pending_requests -= 1;
@@ -1489,7 +1468,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         self.config
             .websocket
             .as_ref()
-            .map_or(0, |ws| ws.handler.active_connections as u32)
+            .map_or(0, |ws| ws.handler.active_connections.get() as u32)
     }
 
     pub fn has_active_web_sockets(&self) -> bool {
@@ -1766,7 +1745,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
 
     /// Build the bind/listen failure as a `SystemError` (so JS sees
     /// `err.code`/`err.syscall`) and `globalThis.throwValue` it. The BoringSSL
-    /// error-stack drain (server.zig:1847-1906) is still TODO; the EADDRINUSE/
+    /// error-stack drain is still TODO; the EADDRINUSE/
     /// EACCES paths below cover the node:http `server.listen` error contract.
     #[cold]
     pub fn on_listen_failed(&mut self) {
@@ -1778,9 +1757,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                 port,
                 hostname: _hostname,
             } => {
-                // Zig `Environment.isLinux` is `os.tag == .linux`, which is
-                // also true for Android targets (Zig encodes Android as
-                // linux+android-abi). Rust's `target_os = "linux"` excludes
+                // Rust's `target_os = "linux"` excludes
                 // Android, so match both explicitly.
                 #[cfg(any(target_os = "linux", target_os = "android"))]
                 if bun_sys::get_errno(-1i32) == bun_sys::E::EACCES {
@@ -1850,9 +1827,8 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         self.h3_alt_svc = format!("h3=\":{port}\"; ma=86400")
             .into_bytes()
             .into_boxed_slice();
-        // PORT NOTE: spec increments `Analytics.Features.http3_server`; that
-        // counter is not (yet) declared in `bun_analytics` (the Zig side
-        // dropped it too — see analytics.zig). No-op until it is.
+        // An `http3_server` feature counter is not (yet) declared in
+        // `bun_analytics`. No-op until it is.
     }
 
     // ─── deinit ──────────────────────────────────────────────────────────────
@@ -1879,7 +1855,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             }
         }
 
-        // PORT NOTE: owned-field cleanup (all_closed_promise / user_routes /
+        // owned-field cleanup (all_closed_promise / user_routes /
         // config / on_clienterror / h3_alt_svc / dev_server / plugins) is
         // handled by the heap::take drop below — see `impl Drop for NewServer`.
         if Self::HAS_H3 {
@@ -1914,7 +1890,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         let base_url: Box<[u8]> = bun_core::trim(&config.base_uri, b"/")
             .to_vec()
             .into_boxed_slice();
-        // errdefer free(base_url) — Box drops on Err automatically
+        // `base_url` drops on Err automatically.
 
         let server = bun_core::heap::into_raw(Box::new(Self {
             global_this: std::ptr::from_ref(global),
@@ -1933,10 +1909,9 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             js_value: jsc::JsRef::empty(),
             pending_requests: 0,
             request_pool: <Self as ServerPools<SSL, DEBUG>>::request_pool(),
-            // Zig gates this on `comptime has_h3` (server.zig:1827) so plain
-            // HTTP servers never allocate the ~816 KB H3 pool. We go one step
-            // further and defer to the H3-listen path (`listen()` below) so
-            // HTTPS servers that don't enable `config.http3` don't pay either.
+            // Plain HTTP servers never allocate the ~816 KB H3 pool; defer to
+            // the H3-listen path (`listen()` below) so HTTPS servers that
+            // don't enable `config.http3` don't pay either.
             h3_request_pool: core::ptr::null_mut(),
             all_closed_promise: jsc::JSPromiseStrong::default(),
             listen_callback: jsc::AnyTask::AnyTask {
@@ -1960,13 +1935,12 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             (*server).any_server_packed = AnyServer::from(server.cast_const()).to_packed() as usize;
         }
 
-        // PORT NOTE: Zig captured `&config.bake.?` then did `.config = config.*`,
-        // so the bake options (and the arena that backs `root`) live in
+        // The bake options (and the arena that backs `root`) live in
         // `(*server).config.bake` for the server's lifetime. Initialise
         // DevServer AFTER the server box exists so the `Options::arena` borrow
         // points into the heap-allocated config rather than the caller's
-        // (since-moved) stack slot. `errdefer if (dev_server) |d| d.deinit()`
-        // — `Box<Self>` drop on Err frees the half-built server.
+        // (since-moved) stack slot. On Err, the `Box<Self>` drop frees the
+        // half-built server.
         // SAFETY: `server` is the freshly-boxed `*mut Self`; uniquely owned here.
         if let Some(bake_options) = unsafe { &mut (*server).config.bake } {
             // SAFETY: `server` is the freshly-boxed `*mut Self`; uniquely owned here.
@@ -1981,8 +1955,8 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                 // SAFETY: per-thread VM singleton; STATIC lifetime.
                 vm: jsc::VirtualMachine::get(),
                 // LAYERING: `UserOptions` carries the `bake_body` shapes;
-                // `DevServer::Options` consumes the keystone shapes. In Zig
-                // these are one type — `From` impls in `bake/mod.rs` bridge
+                // `DevServer::Options` consumes the keystone shapes;
+                // `From` impls in `bake/mod.rs` bridge
                 // until the duplicates are collapsed.
                 framework: core::mem::take(&mut bake_options.framework).into(),
                 bundler_options: core::mem::take(&mut bake_options.bundler_options).into(),
@@ -2022,7 +1996,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         let app = bun_opaque::opaque_deref_mut(self.app.unwrap());
         let self_ptr: *mut Self = self;
         let any_server = AnyServer::from(self_ptr.cast_const());
-        // PORT NOTE: reshaped for borrowck — `dev_server` is `Option<Box<..>>`;
+        // reshaped for borrowck — `dev_server` is `Option<Box<..>>`;
         // snapshot the raw `*mut DevServer` so per-iteration `&mut` derives
         // don't conflict with `&mut self.config` / `&mut self.user_routes`.
         let dev_server: Option<*mut crate::bake::DevServer::DevServer> =
@@ -2067,14 +2041,14 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                 len,
             );
             // `to_build` (and its `Strong` callbacks) drops here — AFTER the
-            // C++ factory has re-rooted them inside the RouteList object,
-            // matching server.zig's `for (..) builder.deinit()` ordering.
+            // C++ factory has re-rooted them inside the RouteList object.
             drop(to_build);
         }
 
         // --- 2. WebSocket handler app reference ---
         if let Some(websocket) = self.config.websocket.as_mut() {
-            websocket.global_object = self.global_this;
+            websocket.global_object =
+                bun_ptr::BackRef::new(bun_opaque::opaque_deref(self.global_this));
             websocket.handler.app = Some(std::ptr::from_mut(app).cast::<c_void>());
             websocket
                 .handler
@@ -2087,7 +2061,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         let mut has_any_user_route_for_star_path = false;
         let mut has_any_ws_route_for_star_path = false;
 
-        // PORT NOTE: reshaped for borrowck — `app.ws(..)` reads `to_behavior()`
+        // reshaped for borrowck — `app.ws(..)` reads `to_behavior()`
         // (borrows `self.config.websocket`) while iterating `self.user_routes`.
         // Snapshot as a `BackRef` (pointee = `self.config.websocket`, which is
         // pinned in the server allocation and outlives every use below — the
@@ -2311,8 +2285,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         if needs_plugins && self.plugins.is_none() {
             // SAFETY: `vm_mut()` is the process-static `*mut VirtualMachine`
             // (non-null for the server's lifetime); single-threaded JS context.
-            // PORT NOTE: Zig reads `serve_plugins` by reference (server.zig:2917);
-            // cloning here (not `.take()`) so subsequent `Bun.serve()` calls in
+            // Cloning here (not `.take()`) so subsequent `Bun.serve()` calls in
             // the same process — and `DevServer`'s tailwind-hack probe of the
             // same field — still see the bunfig-configured plugin list.
             if let Some(serve_plugins_config) = jsc::VirtualMachine::get()
@@ -2467,7 +2440,6 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
     /// `set_routes()`, and bind the listen socket. On any failure the server
     /// is `deinit()`ed synchronously and `.zero` is returned with an exception
     /// pending on `global_this`.
-    // TODO(port): make this return JsResult<JSValue> and let the caller errdefer-deinit.
     /// # Safety
     /// `this` must point to the live heap-allocated `NewServer` returned by
     /// [`Self::init`], with no other `&`/`&mut` borrow live for the duration
@@ -2478,7 +2450,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         Self: ServerPools<SSL, DEBUG>,
     {
         httplog!("listen");
-        // PORT NOTE: reshaped for borrowck (PORTING.md §Forbidden — aliased
+        // reshaped for borrowck (PORTING.md §Forbidden — aliased
         // `&mut`). No long-lived `&mut Self` is held across re-derives from
         // `this`; each use site reborrows fresh and the borrow ends before the
         // next derive. The serverName / SNI loop extracts raw `(ptr, len)` so
@@ -2548,8 +2520,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
                 unsafe {
                     (*this).h3_app = h3;
                     // Lazily materialize the ~816 KB H3 request pool now that
-                    // we know an H3 listener will actually exist (Zig:
-                    // server.zig:1827-1836, gated on `comptime has_h3`).
+                    // we know an H3 listener will actually exist.
                     (*this).h3_request_pool = <Self as ServerPools<SSL, DEBUG>>::h3_request_pool();
                 }
             }
@@ -2558,7 +2529,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             route_list_value = unsafe { &mut *this }.set_routes();
 
             // add serverName to the SSL context using the default ssl options
-            // PORT NOTE: extract raw (ptr, len) so no `&self.config` borrow
+            // extract raw (ptr, len) so no `&self.config` borrow
             // outlives the `set_routes()` call below. set_routes() does not
             // touch `config.ssl_config`, so the bytes remain valid.
             let server_name_raw = this_ref
@@ -2609,7 +2580,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             }
 
             // SNI: per-hostname contexts
-            // PORT NOTE: iterate by index and reborrow `&*this` per iteration so
+            // iterate by index and reborrow `&*this` per iteration so
             // the `set_routes()` `&mut` at the bottom of the loop body never
             // overlaps an outstanding `&self.config.sni` borrow.
             let sni_len = this_ref.config.sni.as_ref().map_or(0, |s| s.slice().len());
@@ -2703,7 +2674,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             unsafe { &mut *this }.set_using_custom_expect_handler(true);
         }
 
-        // PORT NOTE: the listen_* trampolines re-derive `&mut *this` synchronously
+        // the listen_* trampolines re-derive `&mut *this` synchronously
         // inside the C callback (writing `self.listener` / `self.h3_listener`).
         // Under Stacked Borrows, holding any `&*this` / `&mut *this` across a
         // listen call would have its tag popped by that re-derive and become UB
@@ -2748,7 +2719,6 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
 
         match addr {
             Addr::Tcp { port, host } => {
-                // diverges from Zig: makes port:0 reliable for H3.
                 // With `{port: 0, http3: true}` we bind TCP:0 (kernel picks N),
                 // then must bind UDP:N for QUIC so Alt-Svc works. UDP:N may
                 // already be held by an unrelated process. When the user asked
@@ -2912,9 +2882,8 @@ mod route_list_cached {
 }
 
 // ─── extern "C" trampolines ──────────────────────────────────────────────────
-// Zig generated these per (UserData, handler) pair at comptime via
-// `RouteHandler(..)`. Rust monomorphizes on the const-generic server params
-// instead; the bodies downcast `user_data` and forward into the typed method.
+// Monomorphized on the const-generic server params;
+// the bodies downcast `user_data` and forward into the typed method.
 mod trampoline {
     use super::*;
     use bun_uws_sys::{ListenSocket as UwsListenSocket, Request as UwsRequest, uws_res};
@@ -3027,8 +2996,7 @@ mod trampoline {
 }
 
 // ─── per-monomorphization request pools ──────────────────────────────────────
-// Zig: `pub threadlocal var pool: ?*RequestContextStackAllocator = null` per
-// `NewRequestContext(..)` instantiation. Rust generics cannot own statics, so
+// Rust generics cannot own statics, so
 // declare one `thread_local!` per concrete (SSL, DEBUG, H3) combo via macro and
 // hand the leaked pointer back through a trait.
 //
@@ -3036,7 +3004,6 @@ mod trampoline {
 // Fallback::{get,put,claim}` take `&mut self` with no internal synchronization;
 // a process-static would race when two `Bun.serve` instances run on distinct
 // Worker threads (each Worker has its own event loop and may host a server).
-// The Zig spec used `threadlocal` for exactly this reason — preserve it.
 pub trait ServerPools<const SSL: bool, const DEBUG: bool>: Sized {
     fn request_pool() -> *mut request_context::RequestContextStackAllocator<Self, SSL, DEBUG, false>;
     fn h3_request_pool()
@@ -3049,7 +3016,6 @@ macro_rules! impl_server_pools {
             fn request_pool() -> *mut request_context::RequestContextStackAllocator<Self, $ssl, $debug, false> {
                 type Pool = request_context::RequestContextStackAllocator<NewServer<$ssl, $debug>, $ssl, $debug, false>;
                 thread_local! {
-                    // Zig: `threadlocal var pool: ?*RequestContextStackAllocator = null`
                     static POOL: core::cell::Cell<*mut Pool> =
                         const { core::cell::Cell::new(core::ptr::null_mut()) };
                 }
@@ -3139,13 +3105,11 @@ mod ffi {
 }
 
 /// Drain the BoringSSL error queue; if non-empty, throw the top error on
-/// `global` and return true. Mirrors `throwSSLErrorIfNecessary` in server.zig.
+/// `global` and return true.
 fn throw_ssl_error_if_necessary(global: &JSGlobalObject) -> bool {
     let err_code = bun_boringssl_sys::ERR_get_error();
     if err_code != 0 {
         let _ = global.throw_value(crate::crypto::create_crypto_error(global, err_code));
-        // PORT NOTE: Zig had `defer ERR_clear_error()`; no early return
-        // between there and here, so a tail call is equivalent.
         bun_boringssl_sys::ERR_clear_error();
         return true;
     }
@@ -3185,7 +3149,7 @@ impl<const SSL: bool, const DEBUG: bool> ServerLike for NewServer<SSL, DEBUG> {
     // `RequestContext::server.vm()` etc.). Without `#[inline]` a generic trait
     // impl is not eligible for cross-crate inlining at all, so each accessor
     // would compile to a real `call` even though the inherent method it
-    // forwards to is itself one instruction. Zig has no trait layer here.
+    // forwards to is itself one instruction.
     #[inline(always)]
     fn global_this(&self) -> &jsc::JSGlobalObject {
         Self::global_this(self)
@@ -3252,12 +3216,12 @@ pub type DebugHTTPServer = NewServer<false, true>;
 pub type DebugHTTPSServer = NewServer<true, true>;
 
 // ─── AnyServer ───────────────────────────────────────────────────────────────
-// PORT NOTE (§Dispatch): Zig used `bun.ptr.TaggedPointerUnion(...)`. The
+// §Dispatch: the
 // `bun_ptr::impl_tagged_ptr_union!` macro would impl a foreign trait for a
 // foreign tuple type (orphan rule), so it can only be invoked from inside
 // `bun_ptr`. Per §Dispatch ("store `(tag: u8, ptr: *mut ())` as two fields"),
 // hand-roll the tag here. AnyServer is cold-path (per-request, not per-tick).
-// PERF(port): was TaggedPointerUnion pack — 8→16 bytes; ~handful of instances.
+// Two fields cost 16 bytes vs 8 for a packed tagged pointer; ~handful of instances.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum AnyServerTag {
@@ -3319,7 +3283,6 @@ impl AnyServer {
 }
 
 /// Dispatch over the four `NewServer` monomorphizations (shared `&` borrow).
-/// Mirrors Zig's `inline switch (ptr.tag()) { inline else => |s| s.method() }`.
 /// Read-only accessors MUST use this form so holding the returned reference
 /// while calling another dispatch method does not materialize an aliasing
 /// `&mut NewServer` (Stacked-Borrows UB).
@@ -3437,11 +3400,11 @@ impl AnyServer {
         }
     }
 
-    /// Re-pack into the Zig `bun.ptr.TaggedPointerUnion` wire format
+    /// Re-pack into the tagged-pointer wire format
     /// (`u49` ptr | `u15` tag) for the C++ FFI boundary. Inverse of
-    /// [`NodeHTTPResponse::any_server_from_packed`]. Tag values mirror Zig's
-    /// `1024 - typeBaseName-index` assignment (declaration order in
-    /// `AnyServer.Ptr = TaggedPointerUnion(.{HTTP, HTTPS, DebugHTTP, DebugHTTPS})`).
+    /// [`NodeHTTPResponse::any_server_from_packed`]. Tag values are
+    /// `1024 - index` in declaration order
+    /// (HTTP, HTTPS, DebugHTTP, DebugHTTPS).
     pub fn to_packed(self) -> u64 {
         let tag: u16 = match self.tag {
             AnyServerTag::HTTPServer => 1024,
@@ -3514,8 +3477,8 @@ impl AnyServer {
         any_server_dispatch_mut!(self, |s| s.on_pending_request())
     }
 
-    /// Dispatch the user `fetch` handler. Mirrors Zig `AnyServer.onRequest`
-    /// (see `server.zig`): un-erase the SSL bool from the tag and downcast
+    /// Dispatch the user `fetch` handler:
+    /// un-erase the SSL bool from the tag and downcast
     /// `AnyResponse` to the matching `NewAppResponse<SSL>` variant.
     pub fn on_request(&self, req: &mut uws_sys::Request, resp: uws::AnyResponse) {
         // `s` is the live `*mut NewServer` carried in `self.ptr`,
@@ -3544,7 +3507,7 @@ impl AnyServer {
             // S012: `NewApp<SSL>` is a ZST opaque — safe `*mut → &mut` via
             // `bun_opaque::opaque_deref_mut` (const-asserted ZST/align-1).
             Some(app) => bun_opaque::opaque_deref_mut(app).num_subscribers(topic),
-            // PORT NOTE: Zig spec uses `app.?` (panic on null). Defensive 0
+            // Defensive 0
             // here for the post-stop window; assert in debug to catch misuse.
             None => {
                 debug_assert!(false, "num_subscribers on server with no app");
@@ -3565,7 +3528,7 @@ impl AnyServer {
             // `bun_opaque::opaque_deref_mut` (const-asserted ZST/align-1).
             Some(app) =>
                 bun_opaque::opaque_deref_mut(app).publish(topic, message, opcode, compress),
-            // PORT NOTE: Zig spec uses `app.?` (panic on null). Defensive false
+            // Defensive false
             // here for the post-stop window; assert in debug to catch misuse.
             None => {
                 debug_assert!(false, "publish on server with no app");
@@ -3582,7 +3545,7 @@ impl AnyServer {
             .map(|ws| &mut ws.handler))
     }
 
-    /// `server.zig:3591` — wraps a stack-lifetime µWS request into a
+    /// Wraps a stack-lifetime µWS request into a
     /// JS-visible `Request` + heap `RequestContext` so it can outlive the
     /// handler frame (used by bake's deferred bundling path).
     pub fn prepare_and_save_js_request_context(
@@ -3610,7 +3573,7 @@ impl AnyServer {
         }))
     }
 
-    /// `server.zig:3574` — invoke the user's route handler for a request that
+    /// Invoke the user's route handler for a request that
     /// was deferred (bake bundle-then-serve flow).
     pub fn on_saved_request<const EXTRA_ARG_COUNT: usize>(
         &self,
@@ -3650,7 +3613,6 @@ impl AnyServer {
         route: AnyRoute,
         method: server_config::MethodOptional,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         any_server_dispatch_mut!(self, |s| s.config.append_static_route(path, route, method))
     }
 
@@ -3675,7 +3637,8 @@ pub mod http_server_agent {
     use bun_jsc::debugger::DebuggerId;
     use bun_jsc::http_server_agent::{HTTPServerAgent, InspectorHTTPServerAgent, Route, RouteType};
 
-    /// `HTTPServerAgent.zig:notifyServerStarted`.
+    /// Assign the server a fresh inspector id and tell the C++ inspector
+    /// agent (if attached) that it started, passing its URL and start time.
     pub fn notify_server_started(this: &mut HTTPServerAgent, mut instance: AnyServer) {
         let Some(agent) = this.agent else { return };
         this.next_server_id = DebuggerId::init(this.next_server_id.get() + 1);
@@ -3695,10 +3658,11 @@ pub mod http_server_agent {
                 instance.ptr.cast(),
             );
         }
-        // PORT NOTE: `BunString` derefs in `Drop`.
+        // `BunString` derefs in `Drop`.
     }
 
-    /// `HTTPServerAgent.zig:notifyServerStopped`.
+    /// Tell the C++ inspector agent (if attached) that the server stopped,
+    /// stamped with the current time.
     pub fn notify_server_stopped(this: &HTTPServerAgent, server: AnyServer) {
         let Some(agent) = this.agent else { return };
         InspectorHTTPServerAgent::notify_server_stopped(
@@ -3708,7 +3672,8 @@ pub mod http_server_agent {
         );
     }
 
-    /// `HTTPServerAgent.zig:notifyServerRoutesUpdated`.
+    /// Rebuild the route list from the server's config and send it to the
+    /// C++ inspector agent (if attached). Errors only on allocation failure.
     pub fn notify_server_routes_updated(
         this: &HTTPServerAgent,
         server: AnyServer,
@@ -3720,8 +3685,7 @@ pub mod http_server_agent {
         let mut routes: Vec<Route> = Vec::new();
         let mut max_id: u32 = 0;
 
-        // PORT NOTE: Zig's `inline switch (server.userRoutes()) { inline else => |list| ... }`
-        // monomorphized over the four `*UserRoute<SSL,DEBUG>` slice types.
+        // Monomorphized over the four `UserRoute<SSL,DEBUG>` slice types.
         // Dispatch through the same macro the rest of `AnyServer` uses.
         any_server_dispatch!(&server, |s| {
             routes
@@ -3772,7 +3736,7 @@ pub mod http_server_agent {
 
 // ─── SavedRequest ────────────────────────────────────────────────────────────
 pub struct SavedRequest {
-    /// Spec server.zig:3261 — `jsc.Strong.Optional`. May be `.empty` until
+    /// May be `.empty` until
     /// `prepare_js_request_context` populates it; `deinit` must tolerate the
     /// empty state.
     pub js_request: jsc::StrongOptional,
@@ -3782,7 +3746,7 @@ pub struct SavedRequest {
 }
 
 impl SavedRequest {
-    /// Spec server.zig `SavedRequest.deinit` — release the JS strong ref and
+    /// Release the JS strong ref and
     /// drop the request-context refcount. `request`/`response` are non-owning.
     pub fn deinit(&mut self) {
         self.js_request.deinit();
@@ -3790,7 +3754,6 @@ impl SavedRequest {
     }
 }
 
-/// `server.zig:SavedRequest.Union`.
 pub enum SavedRequestUnion<'a> {
     /// Direct pointer to a µWebSockets request that is still on the stack.
     Stack(&'a mut uws::Request),
@@ -3826,9 +3789,6 @@ impl Drop for ServerAllConnectionsClosedTask {
 }
 
 impl ServerAllConnectionsClosedTask {
-    /// Spec server.zig `schedule` — `bun.TrivialNew` heap-allocates `this`,
-    /// then `vm.eventLoop().enqueueTask(jsc.Task.init(ptr))`.
-    ///
     /// Use `ManagedTask::new_owned` (not `Task::init`) so a still-pending task
     /// at process exit is freed by `EventLoop::deinit()`. Without this the
     /// `Box` (and its `JSPromiseStrong`) leaks 24 bytes per `server.stop()`
@@ -3848,8 +3808,8 @@ impl ServerAllConnectionsClosedTask {
         ));
     }
 
-    /// Spec server.zig `runFromJSThread` — resolve the `server.stop()` promise
-    /// once uws reports all sockets closed, then `bun.destroy(self)`.
+    /// Resolve the `server.stop()` promise
+    /// once uws reports all sockets closed.
     ///
     /// # Safety
     /// `this` must be the unique owning pointer heap-allocated in
@@ -3862,8 +3822,7 @@ impl ServerAllConnectionsClosedTask {
         httplog!("ServerAllConnectionsClosedTask runFromJSThread");
 
         // SAFETY: `this` was `heap::alloc`'d in `schedule()`; reclaim
-        // ownership (Zig: `bun.destroy(this)` after copying the fields it still
-        // needs onto the stack). Keep the `Box` because `Self` now has a `Drop`
+        // ownership. Keep the `Box` because `Self` has a `Drop`
         // impl, which forbids per-field moves.
         let mut this = unsafe { bun_core::heap::take(this) };
         // S008: `JSGlobalObject` is an `opaque_ffi!` ZST handle — safe
@@ -3873,7 +3832,6 @@ impl ServerAllConnectionsClosedTask {
         let _dispatch = this.tracker.dispatch(global_object);
 
         if !vm.is_shutting_down() {
-            // Zig: `var promise = this.promise; defer promise.deinit();` —
             // `JSPromiseStrong`'s Drop runs when `this` falls out of scope.
             this.promise.resolve(global_object, JSValue::UNDEFINED)?;
         }
diff --git a/src/runtime/server/server_body.rs b/src/runtime/server/server_body.rs
index 5fe2628a107..6182510d5cd 100644
--- a/src/runtime/server/server_body.rs
+++ b/src/runtime/server/server_body.rs
@@ -1,5 +1,3 @@
-//! Port of src/runtime/server/server.zig
-
 use core::ffi::{c_int, c_void};
 use core::mem;
 use core::ptr::NonNull;
@@ -64,8 +62,7 @@ pub(super) use super::server_web_socket::ServerWebSocket;
 pub(super) use super::static_route::StaticRoute;
 
 // ─── RequestCtx trait ────────────────────────────────────────────────────────
-// PORT NOTE: Zig's `NewRequestContext` exposes `Req`/`Resp`/`http3` as comptime
-// associated decls on the generated type. Stable Rust has no inherent
+// NOTE: Stable Rust has no inherent
 // associated types, so the per-monomorphization handle types are surfaced via
 // this local trait. Only `IS_H3` is consumed for control flow; `Req`/`Resp`
 // are erased to `c_void` to match `super::request_context::{Req, Resp}`.
@@ -250,7 +247,7 @@ where
     }
     #[inline]
     fn arm_on_data(&mut self, resp: &mut Self::Resp) {
-        // PORT NOTE: route via the type-erased `AnyResponse::on_data` so the
+        // NOTE: route via the type-erased `AnyResponse::on_data` so the
         // body stays generic over `Ctx::Resp` (H1 SSL/TCP/H3).
         fn handler<S, const SSL_: bool, const DBG_: bool, const H3_: bool>(
             ctx: *mut NewRequestContext<S, SSL_, DBG_, H3_>,
@@ -284,7 +281,7 @@ where
     }
 }
 
-// PORT NOTE: local request/response trait so generic `Ctx::Req` / `Ctx::Resp`
+// NOTE: local request/response trait so generic `Ctx::Req` / `Ctx::Resp`
 // call sites can dispatch to either uWS HTTP/1 or HTTP/3 handle types without
 // touching `bun_uws_sys`. Only the surface `prepare_js_request_context_for`
 // actually needs is exposed.
@@ -410,9 +407,8 @@ pub(super) type ServerH3RequestContext<const SSL: bool, const DEBUG: bool> =
     NewRequestContext<NewServer<SSL, DEBUG>, SSL, DEBUG, true>;
 
 // ─── BunInfo (moved from bun_core::Global) ───────────────────────────────────
-// Spec: src/bun_core/Global.zig:195-210. `generate()` builds the struct and
-// hands it to `JSON.toAST`, which reflects over fields at comptime. Rust has no
-// `@typeInfo`, so this is the hand-expanded reflection output (cf.
+// `generate()` builds the JSON AST by hand instead of reflecting over a
+// struct's fields (cf.
 // `bun_parsers::json::ToAst` derive sketch, json.rs:808-824): an `E.Object`
 // with `bun_version` (string) + `platform` (nested `E.Object` of `os`/`arch`/
 // `version`, enums emitted as `@tagName` strings).
@@ -463,8 +459,7 @@ pub mod BunInfo {
         }
     }
 
-    /// Zig: `pub fn generate(comptime Bundler: type, _: Bundler, allocator) !JSAst.Expr`.
-    /// `Bundler` is an unused comptime witness; `allocator` maps onto the
+    /// `_transpiler` is an unused witness; expressions allocate from the
     /// global expr `Store` used by `Expr::init`.
     pub fn generate<B>(_transpiler: B) -> Result<Expr, bun_core::Error> {
         let info = BunInfo {
@@ -503,7 +498,7 @@ pub mod BunInfo {
 }
 
 // ─── AnyRoute ────────────────────────────────────────────────────────────────
-// PORT NOTE: enum + `memory_cost`/`set_server`/`ref_`/`deref_` live in
+// NOTE: enum + `memory_cost`/`set_server`/`ref_`/`deref_` live in
 // `super` (mod.rs). The `impl` block below adds the JS-facing constructors
 // (`from_js`/`from_options`/…) on the same type — same crate, split by file.
 pub(super) use super::AnyRoute;
@@ -527,7 +522,7 @@ impl AnyRoute {
             &mut path_string,
             false,
         )?);
-        // PORT NOTE: Zig `defer path_string.deref()`. `from_bun_string` clones
+        // NOTE: `from_bun_string` clones
         // the bytes (or bumps the WTF ref) into the PathLike payload, so we can
         // release the source ref immediately — `bun_core::String` has no `Drop`.
         path_string.deref();
@@ -542,8 +537,6 @@ impl AnyRoute {
         //
         let path_slice = path.path().slice();
         let cwd: &[u8] = if StandaloneModuleGraph::is_bun_standalone_file_path(path_slice) {
-            // Zig: targetBasePublicPath(Environment.os, "root/") — comptime concat,
-            // exposed as a const on the Rust side.
             StandaloneModuleGraph::BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX.as_bytes()
         } else {
             FileSystem::instance().top_level_dir
@@ -602,8 +595,6 @@ impl AnyRoute {
     }
 
     /// This is the JS representation of an HTMLImportManifest
-    ///
-    /// See ./src/bundler/HTMLImportManifest.zig
     fn bundled_html_manifest_from_js(
         argument: JSValue,
         init_ctx: &mut ServerInitContext,
@@ -650,7 +641,7 @@ impl AnyRoute {
             // and the process exits with a non-zero status code.
             if let Some(store) = blob.store.get().as_deref() {
                 if let Some(store_path) = store.get_path() {
-                    // PORT NOTE: `sys::exists_at_type` takes `&ZStr`; the store
+                    // NOTE: `sys::exists_at_type` takes `&ZStr`; the store
                     // path is a borrowed byte slice. NUL-terminate into a path
                     // buffer for the syscall.
                     let mut buf = bun_paths::PathBuffer::default();
@@ -708,11 +699,11 @@ impl AnyRoute {
             let entry = init_ctx
                 .dedupe_html_bundle_map
                 .entry(html_bundle.cast_const());
-            // PERF(port): was bun.handleOom — Rust HashMap aborts on OOM
+            // HashMap aborts on OOM (repo-wide abort-on-OOM policy).
             return Ok(Some(match entry {
                 StdEntry::Vacant(v) => {
-                    // Zig stores the rc=1 `Route::init(..)` in the map and
-                    // returns that same value to the caller (the map slot is a
+                    // The rc=1 `Route::init(..)` goes in the map and
+                    // that same value is returned to the caller (the map slot is a
                     // non-owning borrow, freed by `dedupe_html_bundle_map.deinit`
                     // *without* deref). `RefPtr<T>` has no `Drop`, so a bit-copy
                     // here keeps the net refcount at 1 — bumping for the map
@@ -722,7 +713,7 @@ impl AnyRoute {
                     let route = html_bundle::Route::init(html_bundle);
                     // SAFETY: `route.data` is the just-allocated NonNull (rc=1);
                     // wrap without bumping so the map slot stays non-owning
-                    // (`RefPtr<T>` has no `Drop`; this is the bit-copy Zig did).
+                    // (`RefPtr<T>` has no `Drop`; the map slot is a non-owning bit-copy).
                     let borrowed = unsafe { RefPtr::from_raw(route.as_ptr()) };
                     v.insert(borrowed);
                     AnyRoute::Html(route)
@@ -758,7 +749,7 @@ impl AnyRoute {
                     } else {
                         FrameworkRouter::Style::NextjsPages
                     };
-                // errdefer style.deinit() — Style impls Drop; `?` drops it on the error path
+                // Style impls Drop; `?` drops it on the error path.
 
                 if !strings::ends_with(path, b"/*") {
                     return Err(global.throw_invalid_arguments(format_args!(
@@ -767,9 +758,9 @@ impl AnyRoute {
                 }
 
                 // trim the /*
-                // PORT NOTE: `FileSystemRouterType` fields are `Cow<'static,[u8]>`.
-                // Zig stored a borrow into the route key (arena-backed). Rather
-                // than erasing the lifetime through a raw-pointer round-trip
+                // NOTE: `FileSystemRouterType` fields are `Cow<'static,[u8]>`.
+                // Rather
+                // than erasing a lifetime through a raw-pointer round-trip
                 // (banned per PORTING.md), copy the prefix bytes here — the
                 // route table is built once at server startup, so the extra
                 // allocation is cold.
@@ -846,7 +837,7 @@ pub struct ServePlugins {
     ref_count: core::cell::Cell<u32>,
 }
 
-// TODO(port): Reference count is incremented while there are other objects waiting on plugin loads.
+// Reference count is incremented while there are other objects waiting on plugin loads.
 // Maps to bun_ptr::IntrusiveRc<ServePlugins> — *ServePlugins crosses FFI as promise context ptr.
 
 pub enum ServePluginsState {
@@ -856,8 +847,12 @@ pub enum ServePluginsState {
         plugin: Box<JSBundler::Plugin>,
         promise: jsc::JSPromiseStrong,
         html_bundle_routes: Vec<*mut html_bundle::Route>,
-        // TODO(port): LIFETIMES.tsv classifies this BORROW_PARAM → Option<&'a DevServer>;
-        // threading <'a> through ServePluginsState/ServePlugins deferred to Phase B.
+        // LIFETIMES.tsv classifies this BORROW_PARAM (`Option<&'a DevServer>`),
+        // but `ServePlugins` is a refcounted heap object handed across FFI as
+        // a raw promise-context pointer with dynamic lifetime, so a borrowed
+        // `&'a DevServer` cannot be expressed here. Back-reference invariant:
+        // the DevServer outlives the pending plugin load (see the SAFETY
+        // comments at the deref sites in `on_plugins_resolved`/`_rejected`).
         dev_server: Option<NonNull<DevServer>>,
     },
     Loaded(Box<JSBundler::Plugin>),
@@ -970,7 +965,7 @@ impl ServePlugins {
                 ServePluginsState::Err => return Ok(GetOrStartLoadResult::Err),
             }
         }
-        // PORT NOTE: split out of the loop so the `Loaded` arm's borrow of
+        // NOTE: split out of the loop so the `Loaded` arm's borrow of
         // `self.state` doesn't conflict with the `Unqueued` arm's `&mut self`.
         match &mut self.state {
             ServePluginsState::Loaded(plugins) => Ok(GetOrStartLoadResult::Ready(Some(plugins))),
@@ -983,14 +978,14 @@ impl ServePlugins {
         let ServePluginsState::Unqueued(plugin_list) = &self.state else {
             unreachable!()
         };
-        // PORT NOTE: reshaped for borrowck — clone the slice refs so we can mutate self.state below
+        // NOTE: reshaped for borrowck — clone the slice refs so we can mutate self.state below
         let plugin_list: Vec<_> = plugin_list.iter().collect();
         let bunfig_path: &[u8] = &global.bun_vm().transpiler.options.bunfig_path;
         let bunfig_folder: &[u8] = bun_paths::resolve_path::dirname::<
             bun_paths::resolve_path::platform::Auto,
         >(bunfig_path);
 
-        // NOTE: the keep-alive ref/deref pair (Zig: `this.ref(); defer this.deref()`)
+        // NOTE: the keep-alive ref/deref pair
         // lives in the caller (`get_or_load_plugins`), which holds the heap-allocated
         // `*mut ServePlugins` directly. Deriving the guard's pointer from `&mut self`
         // here would give it a tag that is invalidated by the writes to `self.state`
@@ -999,7 +994,6 @@ impl ServePlugins {
         let plugin = JSBundler::Plugin::create(global, bun_jsc::BunPluginTarget::Browser);
         // SAFETY: `Plugin::create` returns a freshly-boxed `*mut Plugin` (single owner).
         let plugin: Box<JSBundler::Plugin> = unsafe { bun_core::heap::take(plugin) };
-        // PERF(port): was stack-fallback alloc
         let mut bunstring_array: Vec<BunString> = Vec::with_capacity(plugin_list.len());
         for raw_plugin in &plugin_list {
             bunstring_array.push(BunString::init(&***raw_plugin));
@@ -1085,7 +1079,7 @@ impl ServePlugins {
         else {
             unreachable!()
         };
-        drop(promise); // Zig: promise.deinit() — Drop on JscStrong releases the slot.
+        drop(promise); // Drop on JscStrong releases the slot.
 
         self.state = ServePluginsState::Loaded(plugin);
         let plugin_ref = match &self.state {
@@ -1097,7 +1091,6 @@ impl ServePlugins {
             // BACKREF: route was ref'd when stored (intrusive +1 keeps it alive
             // for this call). R-2: `on_plugins_resolved` takes `&self`.
             let route_nn = NonNull::new(route).expect("html_bundle::Route ref'd when stored");
-            // Spec server.zig:457 — `bun.handleOom(route.onPluginsResolved(plugin))`
             bun_core::handle_oom(
                 bun_ptr::BackRef::from(route_nn)
                     .on_plugins_resolved(Some(NonNull::from(plugin_ref))),
@@ -1127,7 +1120,7 @@ impl ServePlugins {
             unreachable!()
         };
         drop(plugin); // pending.plugin.deinit()
-        drop(promise); // Zig: promise.deinit() — Drop on JscStrong releases the slot.
+        drop(promise); // Drop on JscStrong releases the slot.
 
         self.state = ServePluginsState::Err;
 
@@ -1150,8 +1143,7 @@ impl ServePlugins {
 }
 
 /// RAII owner of one counted reference to a [`ServePlugins`]. Drops the
-/// reference via [`ServePlugins::deref_`] on scope exit — the Rust spelling of
-/// Zig's `defer this.deref()`.
+/// reference via [`ServePlugins::deref_`] on scope exit.
 ///
 /// Holds the raw `*mut` from [`ServePlugins::init`] so the final `heap::take`
 /// has write/dealloc provenance over the whole allocation. Never construct this
@@ -1228,8 +1220,7 @@ fn fetch_headers_from_js(value: JSValue, global: &JSGlobalObject) -> Option<*mut
     FetchHeaders::cast_(value, global.vm()).map(|p| p.as_ptr())
 }
 
-/// Per-process latch for the dev-mode idle-timeout warning. The Zig source
-/// declares a `var` per-monomorphization static inside `NewServer`, but the
+/// Per-process latch for the dev-mode idle-timeout warning. The
 /// warning is gated on `DEBUG && !silent` and only fires once globally, so a
 /// single shared `AtomicBool` matches user-visible behavior.
 #[inline]
@@ -1238,7 +1229,7 @@ fn did_send_idletimeout_warning_once() -> &'static core::sync::atomic::AtomicBoo
     &FLAG
 }
 
-/// Body of `onTimeoutForIdleWarn` (server.zig) — emits the once-only dev-mode
+/// Emits the once-only dev-mode
 /// warning. Factored out as a free fn so the `RespLike::on_timeout_warn`
 /// closures (which cannot name `NewServer<SSL,DEBUG>`) can call it.
 fn on_timeout_for_idle_warn() {
@@ -1261,7 +1252,7 @@ pub enum PluginsResult<'a> {
 
 // ─── NewServer ───────────────────────────────────────────────────────────────
 // ─── NewServer (canonical type lives in mod.rs) ──────────────────────────────
-// PORT NOTE (unification): the struct, `ServerFlags`, `UserRoute`,
+// NOTE (unification): the struct, `ServerFlags`, `UserRoute`,
 // `CreateJsRequest`, `PreparedRequest`, `SavedRequest`, `SavedRequestUnion`,
 // `ServerAllConnectionsClosedTask`, `AnyServer` and the four type aliases are
 // defined once in `super` (mod.rs). This file contributes additional inherent
@@ -1271,7 +1262,7 @@ pub(super) use super::{
     SavedRequest, ServerFlags, UserRoute,
 };
 
-/// `fn PreparedRequestFor(comptime Ctx: type) type` — generic over the
+/// Generic over the
 /// per-transport `RequestContext` so the same body serves HTTP/1 and HTTP/3.
 /// `super::PreparedRequest<SSL,DEBUG>` is the HTTP/1-concrete instantiation
 /// used by the bake/saved-request path; the generic form here is only reached
@@ -1291,7 +1282,6 @@ impl<'a, Ctx: RequestCtxOps> PreparedRequestFor<'a, Ctx> {
         req: &mut Ctx::Req,
         resp: &mut Ctx::Resp,
     ) -> SavedRequest {
-        // Zig: `if (comptime Ctx.is_h3) @compileError("PreparedRequest.save is HTTP/1-only")`
         debug_assert!(!Ctx::IS_H3, "PreparedRequest.save is HTTP/1-only");
         // By saving a request, all information from `req` must be
         // copied since the provided uws.Request will be re-used for
@@ -1312,7 +1302,7 @@ impl<'a, Ctx: RequestCtxOps> PreparedRequestFor<'a, Ctx> {
 impl<const SSL: bool, const DEBUG: bool> uws_sys::web_socket::WebSocketUpgradeServer<SSL>
     for NewServer<SSL, DEBUG>
 where
-    // PORT NOTE: see the bounded `impl NewServer` below for why these are
+    // NOTE: see the bounded `impl NewServer` below for why these are
     // spelled out — `on_web_socket_upgrade` lives in that impl.
     NewRequestContext<Self, SSL, DEBUG, false>: super::request_context::RequestContextHostFns,
     NewRequestContext<Self, SSL, DEBUG, true>: super::request_context::RequestContextHostFns,
@@ -1370,7 +1360,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
         bun_opaque::opaque_deref_mut(self.app.expect("server not listening"))
     }
 
-    /// `server.zig:notifyInspectorServerStopped`. Unbounded so `deinit()` (in
+    /// Unbounded so `deinit()` (in
     /// the unbounded `impl NewServer` in mod.rs) can call it without naming
     /// the per-transport `RequestContext` bounds.
     pub(super) fn notify_inspector_server_stopped(&mut self) {
@@ -1378,18 +1368,17 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
             bun_core::hint::cold();
             if let Some(debugger) = &self.vm().as_mut().debugger {
                 bun_core::hint::cold();
-                // PORT NOTE (layering): `HTTPServerAgent.notifyServerStopped`
-                // takes `AnyServer` in Zig and unpacks `inspector_server_id`
-                // itself. The Rust port hoists that wrapper to
+                // NOTE (layering): the `HTTPServerAgent.notifyServerStopped`
+                // wrapper lives in
                 // `super::http_server_agent` so this crate-tier call doesn't
                 // re-declare the C ABI.
                 super::http_server_agent::notify_server_stopped(
                     &debugger.http_server_agent,
                     self.as_any_server(),
                 );
-                // Spec: only clear the id once the agent has been notified, so a
+                // Only clear the id once the agent has been notified, so a
                 // call that races a not-yet-attached debugger leaves the id set
-                // for a later retry (server.zig:1738-1749).
+                // for a later retry.
                 self.inspector_server_id = DebuggerId::init(0);
             }
         }
@@ -1398,7 +1387,7 @@ impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG> {
 
 impl<const SSL: bool, const DEBUG: bool> NewServer<SSL, DEBUG>
 where
-    // PORT NOTE (const-generic dispatch): `RequestContextHostFns` (the host-fn
+    // NOTE (const-generic dispatch): `RequestContextHostFns` (the host-fn
     // export table) is blanket-impl'd per (SSL,DBG,H3) tuple in
     // `RequestContext.rs` for `ThisServer: ServerLike`; restating it here lets
     // method bodies name `<NewRequestContext<..> as RequestContextHostFns>::ON_*`
@@ -1419,12 +1408,8 @@ where
         }
     }
 
-    // PORT NOTE: `getPluginsAsync` is referenced from `AnyServer.loadAndResolvePlugins`
-    // (server.zig:3440-3447) but never defined on `ThisServer`. Zig's lazy
-    // compilation means the dispatch arm is dead. The Rust port omits both the
-    // method and the `AnyServer` dispatcher rather than guess a contract that
-    // would silently change behavior if a caller is later wired up. The live
-    // HTMLBundle path goes through `get_or_load_plugins`.
+    // NOTE: there is no `getPluginsAsync` method or `AnyServer` dispatcher;
+    // the live HTMLBundle path goes through `get_or_load_plugins`.
 
     /// Returns:
     /// - .ready if no plugin has to be loaded
@@ -1437,7 +1422,7 @@ where
         if let Some(p) = self.plugins {
             let global = self.global();
             // Keep `*p` alive across re-entrant JS in `load_and_resolve_plugins`
-            // (Zig: `this.ref(); defer this.deref()`). The guard is built from the
+            // The guard is built from the
             // heap-allocated `*mut` directly so its provenance survives the
             // `&mut *p` reborrow below and remains valid for `heap::take` on drop.
             //
@@ -1490,13 +1475,10 @@ where
 
     // ── host_fn.wrapInstanceMethod hand-expansions ───────────────────────
     //
-    // PORT NOTE: Zig's `host_fn.wrapInstanceMethod(ThisServer, "name", false)`
-    // is a comptime type-directed argument decoder (see host_fn.zig:493-648).
-    // The `#[bun_jsc::host_fn(method)]` proc-macro that will eventually
-    // replace it hasn't landed, so the per-type decode arms used by the
-    // server (`ZigString`, `JSValue`, `?JSValue`, `*WebCore.Request`) are
-    // open-coded here. They mirror the Zig branches exactly: same error
-    // messages, same undefined/null handling, same eat order.
+    // NOTE: the `#[bun_jsc::host_fn(method)]` proc-macro that will eventually
+    // replace these hand-expansions hasn't landed, so the per-type decode arms
+    // used by the server (`ZigString`, `JSValue`, `?JSValue`, `*WebCore.Request`)
+    // are open-coded here.
 
     /// `pub const doStop = host_fn.wrapInstanceMethod(ThisServer, "stopFromJS", false)`
     #[bun_jsc::host_fn(method)]
@@ -1545,7 +1527,6 @@ where
     ) -> JsResult<JSValue> {
         let args = callframe.arguments_old::<5>();
         let mut iter = jsc::ArgumentsSlice::init(global.bun_vm_ref(), args.slice());
-        // jsc.ZigString
         let topic_value = iter
             .next_eat()
             .ok_or_else(|| global.throw_invalid_arguments(format_args!("Missing argument")))?;
@@ -1669,7 +1650,6 @@ where
         route: super::AnyRoute,
         method: server_config::MethodOptional,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.config.append_static_route(path, route, method)
     }
 
@@ -1696,7 +1676,7 @@ where
             return Err(global.throw(format_args!("publish requires a non-empty topic")));
         }
 
-        // https://github.com/ziglang/zig/issues/24563
+        // compress defaults to true when the argument is omitted.
         let compress_js = compress_value.unwrap_or(JSValue::TRUE);
         let compress = compress_js.to_boolean();
 
@@ -1712,7 +1692,7 @@ where
                     uws_sys::Opcode::Binary,
                     compress,
                 ) as i32)
-                    * ((buffer.len as u32 & 0x7FFF_FFFF) as i32), // @intCast(@as(u31, @truncate(buffer.len)))
+                    * ((buffer.len as u32 & 0x7FFF_FFFF) as i32), // length truncated to a non-negative i32
             )));
         }
 
@@ -1720,7 +1700,7 @@ where
             let js_string = message_value.to_js_string(global)?;
             let view = js_string.view(global);
             let slice = view.to_slice();
-            // Spec keeps `js_string` alive (server.zig:748), not `message_value`:
+            // Keep `js_string` alive, not `message_value`:
             // when the input was not already a JSString, `to_js_string` allocates
             // a fresh GC cell that is *not* reachable from `message_value`, so a
             // GC during `publish_with_options` could otherwise reclaim the bytes
@@ -1941,13 +1921,13 @@ where
         let mut sec_websocket_protocol = ZigString::EMPTY;
         let mut sec_websocket_extensions = ZigString::EMPTY;
 
-        // Owned backing storage for sec_websocket_* — see server.zig:910 comment.
+        // Owned backing storage for sec_websocket_*.
         // `ZigStringSlice` impls `Drop`; reassignment drops the previous value.
         let mut _sec_websocket_key_owned = bun_core::ZigStringSlice::empty();
         let mut _sec_websocket_protocol_owned = bun_core::ZigStringSlice::empty();
         let mut _sec_websocket_extensions_owned = bun_core::ZigStringSlice::empty();
 
-        // PORT NOTE: `FetchHeaders::fast_get` takes `&mut self` (FFI signature
+        // NOTE: `FetchHeaders::fast_get` takes `&mut self` (FFI signature
         // is `*mut`), so go through the `BodyMixin` accessor which yields a
         // `NonNull` instead of the inherent `&FetchHeaders` getter.
         if let Some(head) = crate::webcore::body::BodyMixin::get_fetch_headers(request) {
@@ -1973,7 +1953,7 @@ where
         // SAFETY: upgrader_ptr is live (ref_() above)
         let upgrader = unsafe { &mut *upgrader_ptr };
         if let Some(req_ptr) = upgrader.req {
-            // PORT NOTE: `RequestContext.req` is type-erased to `*mut c_void`
+            // NOTE: `RequestContext.req` is type-erased to `*mut c_void`
             // (RequestContext.rs:82). `server.upgrade()` is HTTP/1-only — H3
             // contexts have a distinct generic param and `request_context.get`
             // above would have returned None — so the concrete `Req` is always
@@ -2152,8 +2132,8 @@ where
             proto_str.slice(),
             ext_str.slice(),
             // S008: `WebSocketUpgradeContext` is an `opaque_ffi!` ZST — safe
-            // deref (`upgrade_ctx` checked non-null / non-sentinel above,
-            // server.zig:899; the uWS HttpContext owns it for the request's
+            // deref (`upgrade_ctx` checked non-null / non-sentinel above;
+            // the uWS HttpContext owns it for the request's
             // duration).
             Some(bun_opaque::opaque_deref_mut(upgrade_ctx)),
         );
@@ -2161,7 +2141,7 @@ where
         Ok(JSValue::TRUE)
     }
 
-    /// `server.zig:onReloadFromZig`. Swaps the live server's mutable
+    /// Swaps the live server's mutable
     /// configuration (handlers, websocket, routes) with `new_config` and
     /// re-registers routes on the uws app(s). Ownership of moved-in fields
     /// transfers to `self.config`; the caller's `new_config` is left in a
@@ -2188,8 +2168,7 @@ where
         {
             self.config.on_request = new_config.on_request.take();
         }
-        // Zig server.zig:1108: `if (this.config.onNodeHTTPRequest != new_config.onNodeHTTPRequest)`
-        // — swap on any change, *including* clearing to `.zero` when the reload
+        // Swap on any change, *including* clearing to `.zero` when the reload
         // config omits the handler, so subsequent `on_web_socket_upgrade` /
         // `set_routes` stop routing through the node:http path. `take()` yields
         // `None` when the new config omitted it; assignment drops the old Strong.
@@ -2214,7 +2193,7 @@ where
                 if let Some(old_ws) = self.config.websocket.as_ref() {
                     old_ws.unprotect();
                 }
-                ws.global_object = global;
+                ws.global_object = bun_ptr::BackRef::new(global);
                 self.config.websocket = Some(ws);
             } else {
                 // Not adopting it: release the protections taken in
@@ -2230,9 +2209,8 @@ where
             dev_server.html_router.fallback = None;
         }
 
-        // PORT NOTE: Zig drains+frees `this.config.static_routes` then assigns
-        // `new_config.static_routes`. `Vec<StaticRouteEntry>` impls `Drop`, so
-        // a move-assign performs the same free.
+        // NOTE: `Vec<StaticRouteEntry>` impls `Drop`, so
+        // a move-assign frees the old `static_routes`.
         self.config.static_routes = core::mem::take(&mut new_config.static_routes);
         self.config.negative_routes = core::mem::take(&mut new_config.negative_routes);
 
@@ -2263,7 +2241,6 @@ where
     }
 
     pub fn reload_static_routes(&mut self) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set
         if self.app.is_none() {
             // Static routes will get cleaned up when the server is stopped
             return Ok(false);
@@ -2371,10 +2348,10 @@ where
 
             let mut url = URL::parse(temp_url_str);
 
-            // `bun.String.cloneUTF8(url.href)` below makes its own copy, so the
+            // The UTF-8 clone of `url.href` below makes its own copy, so the
             // joined buffer only needs to live through this block. The else arm
             // borrows `temp_url_str` (kept alive by `url_zig_str`) instead of
-            // duping it just to satisfy a uniform `defer free` like the Zig did.
+            // duping it.
             let owned_url_buf: std::borrow::Cow<'_, [u8]> = if url.hostname.is_empty() {
                 std::borrow::Cow::Owned(
                     strings::append(&self.base_url_string_for_joining, url.pathname).into_vec(),
@@ -2393,15 +2370,18 @@ where
 
                 if let Some(headers_) = opts.fast_get(ctx, jsc::BuiltinName::Headers)? {
                     if let Some(headers__) = FetchHeaders::cast_(headers_, ctx.vm()) {
-                        // PORT NOTE: `cast_` returns a *borrow* of the JS
-                        // wrapper's `Ref<FetchHeaders>` without bumping the
-                        // refcount. Zig stores it directly in
-                        // `Request.#headers` (server.zig:1296) and
-                        // `Request.finalizeWithoutDeinit` later calls
-                        // `headers.deref()` — same alloc/free pairing as
-                        // `HeadersRef::adopt` + `Drop`. Kept 1:1 with the
-                        // spec; FetchHeaders has no `ref()` FFI.
-                        // SAFETY: `headers__` is live (rooted by `headers_`).
+                        // NOTE: `cast_` returns the `FetchHeaders*` held by the
+                        // JS `Headers` wrapper (`JSFetchHeaders`'s internal
+                        // `Ref<FetchHeaders>`) without bumping the refcount —
+                        // the FFI surface has `WebCore__FetchHeaders__deref` but
+                        // no `ref()`, so a +1 cannot be taken here. Adopting
+                        // hands that wrapper-held ref to the constructed
+                        // `Request` (via `Request::init2` below): the eventual
+                        // single deref happens when the Request's finalizer
+                        // drops its `headers` field (`HeadersRef::Drop`,
+                        // Response.rs), pairing with the wrapper's +1.
+                        // SAFETY: `headers__` is live (rooted by `headers_`),
+                        // and ownership of one ref transfers as described above.
                         headers = Some(unsafe { HeadersRef::adopt(headers__) });
                     } else if let Some(headers__) = FetchHeaders::create_from_js(ctx, headers_)? {
                         // SAFETY: create_from_js returns a +1 ref.
@@ -2435,11 +2415,8 @@ where
             .flatten()
         {
             // SAFETY: JsClass::from_js returns a live *mut Request.
-            // PORT NOTE: Zig `request_.cloneInto(&existing_request, alloc, ctx, false)`
-            // wrote into a default-initialized `var existing_request: Request = .{}`.
-            // `Request::clone()` (Request.rs:1627) seeds a fully-initialized
-            // sentinel and calls `clone_into(.., preserve_url=false)` — same
-            // observable result without taking `&mut` to uninitialized memory.
+            // NOTE: `Request::clone()` (Request.rs:1627) seeds a fully-initialized
+            // sentinel and calls `clone_into(.., preserve_url=false)`.
             unsafe { (*request_).clone(ctx)? }
         } else {
             // SAFETY: FFI call into JSC C API; `ctx` is a live JSGlobalObject and
@@ -2456,8 +2433,7 @@ where
             );
         };
 
-        // Zig: `var request = Request.new(existing_request)` → raw
-        // `*Request` (TrivialNew). `Request::to_js` stores `self as *mut
+        // `Request::to_js` stores `self as *mut
         // Request` into the JS wrapper, which adopts ownership and frees the
         // allocation in its GC finalizer. Relinquish the `Box` here so the
         // local going out of scope does not also drop it (double-free / UAF).
@@ -2591,7 +2567,7 @@ where
         match &self.config.address {
             server_config::Address::Unix(unix) => {
                 let value = BunString::clone_utf8(unix.as_bytes());
-                // Zig: `defer value.deref();` — must release the cloned ref even
+                // Must release the cloned ref even
                 // on the `to_js` error path.
                 let value = scopeguard::guard(value, |v| v.deref());
                 value.to_js(global)
@@ -2656,7 +2632,6 @@ where
 
     #[bun_jsc::host_fn(getter)]
     pub fn get_hostname(&self, global: &JSGlobalObject) -> JsResult<JSValue> {
-        // TODO(port): narrow error set
         match &self.config.address {
             server_config::Address::Unix(_) => return Ok(JSValue::UNDEFINED),
             server_config::Address::Tcp { .. } => {}
@@ -2792,7 +2767,6 @@ where
         }
         self.pending_requests += 1;
         req.set_yield(false);
-        // PERF(port): was stack-fallback alloc
 
         let buffer_writer = bun_js_printer::BufferWriter::init();
         let mut writer = bun_js_printer::BufferPrinter::init(buffer_writer);
@@ -2976,8 +2950,7 @@ where
         }
 
         // Resolve once, reuse for both `has_request_body()` and the forward to
-        // `Ctx::create`. Zig (server.zig:2438) parses inline at both sites and
-        // forwards the unresolved `method` arg, so `create` parsed again.
+        // `Ctx::create`.
         let method = method.or_else(|| http::Method::which(ReqLike::method(req)));
 
         let request_body_length: Option<usize> = 'request_body_length: {
@@ -3079,10 +3052,9 @@ where
             .jsc_vm()
             .deprecated_report_extra_memory(core::mem::size_of::<Ctx>());
 
-        // `vm.initRequestBodyValue(.{ .Null = {} })` — pooled body slot,
-        // ref_count = 1.
+        // Pooled body slot, ref_count = 1.
         let body_hive = crate::webcore::body::hive_alloc(BodyValue::Null);
-        // Zig: `.body = body.ref()` — ctx and Request each own a +1 on the
+        // The ctx and Request each own a +1 on the
         // same slot. Paired drop in `RequestContext::deinit` / `Request::finalize`.
         ctx.set_request_body(Some(body_hive.clone()));
 
@@ -3091,7 +3063,7 @@ where
         // S008: `AbortSignal` is an `opaque_ffi!` ZST — safe deref.
         bun_opaque::opaque_deref_mut(signal).pending_activity_ref();
 
-        // Zig: `.signal = signal.ref()` — bump once for the Request's owned
+        // Bump once for the Request's owned
         // copy and adopt into RAII so it pairs with `Request::Drop`'s unref.
         // SAFETY: `signal` is live; `ref_()` returns the same non-null ptr +1.
         let signal_for_req = unsafe { jsc::AbortSignalRef::adopt((*signal).ref_()) };
@@ -3119,7 +3091,7 @@ where
                     std::ptr::from_mut(req).cast::<c_void>(),
                 ))
             }));
-            // PORT NOTE: `ReqLike::{url,header}` both borrow `&mut req`; the
+            // NOTE: `ReqLike::{url,header}` both borrow `&mut req`; the
             // returned slices alias the same uWS-owned header buffer. Format
             // the `https://{host}` prefix while `host` is borrowed so the
             // second `&mut req` borrow for `url` is unconflicted.
@@ -3294,7 +3266,7 @@ where
         // duration.
         let this = unsafe { &mut *self_ptr };
         if this.config.on_node_http_request.is_some() {
-            // PORT NOTE: receiver is `*mut Self` (mod.rs) — the callee re-enters
+            // NOTE: receiver is `*mut Self` (mod.rs) — the callee re-enters
             // JS, so a long-lived `&mut self` here would alias on callback.
             Self::on_node_http_request_with_upgrade_ctx(self_ptr, req, resp, upgrade_ctx);
             return;
@@ -3325,18 +3297,18 @@ where
 
         // Pooled body slot, ref_count = 1.
         let body_hive = crate::webcore::body::hive_alloc(BodyValue::Null);
-        // Zig: `.body = body.ref()` — ctx and Request each own a +1 on the
+        // The ctx and Request each own a +1 on the
         // same slot. Paired drop in `RequestContext::deinit` / `Request::finalize`.
         ctx.request_body = Some(body_hive.clone());
 
         let signal = AbortSignal::new(&this.global());
-        // Zig: `ctx.signal = signal; signal.pendingActivityRef();` — the
+        // The
         // RequestContext owns one ref so aborts during the WS-upgrade fallback
         // fetch path propagate.
         ctx.signal = NonNull::new(signal);
         // S008: `AbortSignal` is an `opaque_ffi!` ZST — safe deref.
         bun_opaque::opaque_deref_mut(signal).pending_activity_ref();
-        // Zig: `.signal = signal.ref()` — bump once for the Request's copy and
+        // Bump once for the Request's copy and
         // adopt into RAII so it pairs with `Request::Drop`'s unref.
         // SAFETY: `signal` is live; `ref_()` returns the same non-null ptr +1.
         let signal_for_req = unsafe { jsc::AbortSignalRef::adopt((*signal).ref_()) };
@@ -3404,7 +3376,7 @@ where
         resp: &mut uws_sys::NewAppResponse<SSL>,
     ) {
         if cfg!(debug_assertions) {
-            // PORT NOTE: scoped_log! expands each arg twice (ANSI/no-ANSI branches);
+            // NOTE: scoped_log! expands each arg twice (ANSI/no-ANSI branches);
             // copy to owned buffers so the two `&req` borrows in the expansion
             // don't overlap with the returned slice lifetimes.
             let m = req.method().to_vec();
@@ -3495,7 +3467,7 @@ where
         resp: &mut uws_sys::NewAppResponse<SSL>,
     ) {
         if cfg!(debug_assertions) {
-            // PORT NOTE: see on_chrome_dev_tools_json_request — scoped_log! double-evaluates args.
+            // NOTE: see on_chrome_dev_tools_json_request — scoped_log! double-evaluates args.
             let m = req.method().to_vec();
             let u = req.url().to_vec();
             httplog!("{} - {} 404", BStr::new(&m), BStr::new(&u));
@@ -3769,7 +3741,7 @@ pub(super) fn server_set_max_http_header_size_(
 // `node:http`/`node:https` (`bindings/NodeHTTP.cpp`).
 //
 // NOTE: these are plain `extern "C"` (NOT `#[bun_jsc::host_call]` / sysv64).
-// Zig's `wrap{3,4}` emits `callconv(.c)` and the C++ declarations in
+// The C++ declarations in
 // NodeHTTP.cpp are bare `extern "C"` with no `SYSV_ABI`, so on Windows the
 // caller uses Win64 ABI. Using `host_call` here forced sysv64 on the Rust
 // side, scrambling the `server` argument and tripping the `is_object()` guard.
diff --git a/src/runtime/shell/Builtin.rs b/src/runtime/shell/Builtin.rs
index bfdb39c6ec0..983e0a83b16 100644
--- a/src/runtime/shell/Builtin.rs
+++ b/src/runtime/shell/Builtin.rs
@@ -1,7 +1,5 @@
-//! A builtin command runs inside a `Cmd` state node. In Zig the builtin
-//! recovered its parent `*Cmd` via `container_of`; in the NodeId port the
-//! builtin stores the `NodeId` of its owning Cmd and every method takes
-//! `&Interpreter`.
+//! A builtin command runs inside a `Cmd` state node. The builtin stores the
+//! `NodeId` of its owning Cmd and every method takes `&Interpreter`.
 
 use bun_collections::VecExt;
 use core::ffi::c_char;
@@ -19,7 +17,7 @@ use crate::shell::states::cmd::{Cmd, CmdState};
 use crate::shell::yield_::Yield;
 
 pub struct Builtin {
-    /// Owning Cmd node. Replaces Zig's `@fieldParentPtr("impl", ...)` chain.
+    /// Owning Cmd node.
     pub cmd: NodeId,
     pub kind: Kind,
     /// argv[1..] as NUL-terminated strings (argv[0] is the builtin name).
@@ -31,9 +29,7 @@ pub struct Builtin {
     /// Set by `done()` and stashed by `write_failing_error` so the async
     /// `on_io_writer_chunk` path can recover the intended exit code.
     pub exit_code: Option<ExitCode>,
-    /// Scratch for `fmt_error_arena` (replaces the Zig per-Cmd bump arena).
-    /// One outstanding error string at a time — same constraint as Zig, where
-    /// the arena is reset per-builtin.
+    /// Scratch for `fmt_error_arena`. One outstanding error string at a time.
     pub err_buf: Vec<u8>,
     pub impl_: Impl,
 }
@@ -41,10 +37,7 @@ pub struct Builtin {
 // ──────────────────────────────────────────────────────────────────────────
 // shell_builtins! — single source of truth for the builtin set.
 //
-// Zig (Builtin.zig) gets this for free via comptime reflection: `@tagName`,
-// `std.meta.stringToEnum`, `@unionInit`, and one shared `callImpl` switch
-// cover what Rust hand-unrolled into eight parallel 19-arm matches. This
-// table macro restores the single-definition property: each row declares
+// This table macro keeps the single-definition property: each row declares
 // {Variant, argv0 name, module path, storage shape, usage, posix-gate} once
 // and the macro emits `Kind`, `Impl`, `as_str`, `usage_string`,
 // `from_argv0_raw`, `DISABLED_ON_POSIX`, `make_impl`, `start`,
@@ -59,8 +52,7 @@ pub struct Builtin {
 /// Per-builtin state downcast. Replaces the 17 hand-rolled
 /// `fn state_mut(interp, cmd) -> &mut Self { match Builtin::of_mut(..).impl_ {
 /// Impl::X(v) => v, _ => unreachable!() } }` copies that every
-/// `src/runtime/shell/builtin/*.rs` carried — the Rust analogue of Zig's
-/// per-file `fn bltn(this: *Self) *Builtin { @fieldParentPtr(...) }`.
+/// `src/runtime/shell/builtin/*.rs` carried.
 ///
 /// `extract` is the bare variant projection (knows whether the payload is
 /// boxed in `Impl`); `state_mut` is the convenience entry point every builtin
@@ -89,7 +81,7 @@ macro_rules! shell_builtins {
         #[derive(Clone, Copy, PartialEq, Eq, Debug, strum::IntoStaticStr)]
         pub enum Kind { $( $UV, )* $( $IV, )* $( $BV, )* }
 
-        /// Per-builtin state. In Zig this was a `union(Kind)`; in Rust an enum.
+        /// Per-builtin state.
         pub enum Impl {
             $( $UV, )*
             $( $IV(crate::shell::builtins::$i_mod::$IT), )*
@@ -99,12 +91,10 @@ macro_rules! shell_builtins {
 
         impl Kind {
             /// Builtins disabled on POSIX (delegate to the system binary) unless
-            /// the experimental feature flag is set. Spec: Builtin.zig
-            /// `Kind.DISABLED_ON_POSIX`.
+            /// the experimental feature flag is set.
             pub const DISABLED_ON_POSIX: &'static [Kind] = &[ $( Kind::$PD ),* ];
 
-            /// Lowercase tag for error prefixes (`"{kind}: ..."`). Spec: Zig
-            /// `@tagName(kind)`.
+            /// Lowercase tag for error prefixes (`"{kind}: ..."`).
             pub fn as_str(self) -> &'static str {
                 match self {
                     $( Kind::$UV => $u_name, )*
@@ -113,7 +103,6 @@ macro_rules! shell_builtins {
                 }
             }
 
-            /// Spec: Builtin.zig `Kind.usageString`.
             pub fn usage_string(self) -> &'static [u8] {
                 match self {
                     $( Kind::$UV => $u_usage, )*
@@ -122,8 +111,7 @@ macro_rules! shell_builtins {
                 }
             }
 
-            /// argv[0] → `Kind`, no POSIX gating. Spec: Builtin.zig
-            /// `std.meta.stringToEnum(Kind, str)`.
+            /// argv[0] → `Kind`, no POSIX gating.
             fn from_argv0_raw(s: &[u8]) -> Option<Kind> {
                 $( if s == $u_name.as_bytes() { return Some(Kind::$UV); } )*
                 $( if s == $i_name.as_bytes() { return Some(Kind::$IV); } )*
@@ -157,7 +145,7 @@ macro_rules! shell_builtins {
 
             /// Hoisted dispatch: start the builtin's state machine.
             pub fn start(interp: &Interpreter, cmd: NodeId) -> Yield {
-                // PORT NOTE: reshaped for borrowck — match on a copied Kind, then
+                // Match on a copied Kind, then
                 // call the per-builtin `start(interp, cmd)`. Each builtin reaches its
                 // own state via `Builtin::of_mut(interp, cmd).impl_`.
                 match Self::kind_of(interp, cmd) {
@@ -220,8 +208,8 @@ impl Kind {
             .unwrap_or(false)
     }
 
-    /// Spec: Builtin.zig `Kind.fromStr`. Maps argv[0] to a builtin kind, or
-    /// `None` to fall through to subprocess spawn.
+    /// Maps argv[0] to a builtin kind, or `None` to fall through to
+    /// subprocess spawn.
     pub fn from_argv0(s: &[u8]) -> Option<Kind> {
         let result = Self::from_argv0_raw(s)?;
         if cfg!(windows) || Self::force_enable_on_posix() {
@@ -242,7 +230,7 @@ pub enum IoKind {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// BuiltinIO — Spec: Builtin.zig `BuiltinIO.{Output,Input}`.
+// BuiltinIO
 //
 // Distinct from `IO::OutKind` because builtins can target ArrayBuffer/Blob
 // JS objects (`> ${buf}`) and accumulate into a per-builtin `.buf` when the
@@ -250,17 +238,15 @@ pub enum IoKind {
 // of a local Vec flushed in `done()`, `write_no_io` appends straight to the
 // shell env's captured buffer (one less copy). The variant carries its flush
 // target so `2>&1` (which makes `stderr` a shallow copy of `stdout`) routes
-// stderr writes to `buffered_stdout`, matching the Zig aliasing semantics.
+// stderr writes to `buffered_stdout`.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// One output stream of a builtin (stdout or stderr). Spec: Builtin.zig
-/// `BuiltinIO.Output`.
+/// One output stream of a builtin (stdout or stderr).
 pub enum BuiltinIO {
     /// Async writer (real fd). `needs_io()` returns Some.
     Fd(OutFd),
     /// Captured pipe — writes go to the shell env's `_buffered_{stdout,stderr}`.
-    /// PORT NOTE: Zig kept a local `ArrayList(u8)` here and flushed it in
-    /// `done()`; the NodeId port writes through immediately (see module doc).
+    /// Writes go through immediately (see module doc).
     /// The payload names which shell-env bytelist to append to — set at
     /// `from_out_kind` and copied verbatim by `dup_ref` so `2>&1` keeps
     /// stderr aimed at stdout's buffer.
@@ -273,12 +259,11 @@ pub enum BuiltinIO {
     Ignore,
 }
 
-/// Input stream of a builtin. Spec: Builtin.zig `BuiltinIO.Input`.
+/// Input stream of a builtin.
 pub enum BuiltinInput {
     Fd(Arc<IOReader>),
-    /// Buffer not owned by the builtin (Zig: `array list not owned by this
-    /// type`). In the NodeId port no producer wires this yet; reserved for
-    /// pipeline-from-builtin.
+    /// Buffer not owned by the builtin. No producer wires this yet; reserved
+    /// for pipeline-from-builtin.
     Buf(Vec<u8>),
     ArrayBuf {
         buf: PinnedArrayBuf,
@@ -315,8 +300,8 @@ impl Drop for PinnedArrayBuf {
     }
 }
 
-/// Spec: Builtin.zig `BuiltinIO.Blob` — refcounted wrapper around a
-/// `webcore.Blob`. `Arc` provides the refcount; `Drop` runs `Blob::deinit`.
+/// Refcounted wrapper around a `webcore.Blob`. `Arc` provides the refcount;
+/// `Drop` runs `Blob::deinit`.
 pub struct BuiltinBlob {
     pub blob: crate::webcore::Blob,
 }
@@ -328,11 +313,9 @@ const _: fn() = || {
 };
 
 impl BuiltinIO {
-    /// From the Cmd's IO::OutKind. Spec: Builtin.zig `init` stdin/stdout/stderr
-    /// switch — `.fd` → `dupeRef`, `.pipe` → `.buf`, `.ignore` → `.ignore`.
-    /// `Arc::clone` (via `OutFd: Clone`) IS the `dupeRef` — it bumps the
-    /// `IOWriter` refcount; `Drop` decrements it symmetrically. `target` is
-    /// the shell-env bytelist this stream flushes to (Stdout or Stderr).
+    /// From the Cmd's IO::OutKind. `Arc::clone` (via `OutFd: Clone`) bumps
+    /// the `IOWriter` refcount; `Drop` decrements it symmetrically. `target`
+    /// is the shell-env bytelist this stream flushes to (Stdout or Stderr).
     fn from_out_kind(ok: &OutKind, target: IoKind) -> BuiltinIO {
         match ok {
             OutKind::Fd(fd) => BuiltinIO::Fd(fd.clone()),
@@ -341,12 +324,11 @@ impl BuiltinIO {
         }
     }
 
-    /// Spec: Builtin.zig `BuiltinIO.Output.ref` — bump refcounts and return a
-    /// shallow copy. Only reachable from the `duplicate_out` path, which fires
-    /// before any `.jsbuf` redirect, so `ArrayBuf`/`Blob` are unreachable here.
-    /// The `Buf` target is copied verbatim: in Zig `stderr = stdout.ref().*`
-    /// shallow-copies stdout's ArrayList so stderr writes accumulate in (and
-    /// flush from) stdout's buffer; here that aliasing is the carried `IoKind`.
+    /// Bump refcounts and return a shallow copy. Only reachable from the
+    /// `duplicate_out` path, which fires before any `.jsbuf` redirect, so
+    /// `ArrayBuf`/`Blob` are unreachable here. The `Buf` target is copied
+    /// verbatim so stderr writes accumulate in (and flush from) stdout's
+    /// buffer; that aliasing is the carried `IoKind`.
     fn dup_ref(&self) -> BuiltinIO {
         match self {
             BuiltinIO::Fd(fd) => BuiltinIO::Fd(fd.clone()),
@@ -372,8 +354,6 @@ impl BuiltinIO {
     /// `Builtin.impl_` (disjoint from `stdout`/`stderr`) can write a borrowed
     /// slice without an intermediate heap clone.
     ///
-    /// Spec: Builtin.zig `writeNoIO` (match arm body).
-    ///
     /// # Safety
     /// `shell` must point to the live `ShellExecEnv` owning this builtin
     /// (i.e. `cmd.base.shell`); only dereferenced for the [`BuiltinIO::Buf`]
@@ -391,12 +371,10 @@ impl BuiltinIO {
                 panic!("write_no_io called on fd output; caller must check needs_io()")
             }
             BuiltinIO::Buf(target) => {
-                // PORT NOTE: Zig appended to a local `io.buf` and flushed in
-                // `done()` to `buffered_{stdout,stderr}` keyed on which field
-                // the buffer lives in. The NodeId port writes straight through;
-                // `target` is that field identity, fixed at construction and
-                // preserved across `dup_ref` so `2>&1` lands in stdout's
-                // bytelist (matching Zig's shallow-copied ArrayList aliasing).
+                // Writes go straight through to `buffered_{stdout,stderr}`;
+                // `target` is the destination identity, fixed at construction
+                // and preserved across `dup_ref` so `2>&1` lands in stdout's
+                // bytelist.
                 // SAFETY: caller contract — shell env outlives the Cmd node
                 // (single-threaded); `captured` points into a live
                 // `ShellExecEnv` Bufio.
@@ -410,9 +388,9 @@ impl BuiltinIO {
                 Ok(buf.len())
             }
             BuiltinIO::ArrayBuf { buf: arraybuf, i } => {
-                // Spec: Builtin.zig writeNoIO .arraybuf — `len = buf.len` stays
-                // usize so `i + len > byte_len` is computed at usize width and
-                // cannot overflow. Mirror that here; only the stored cursor is u32.
+                // `len = buf.len` stays usize so `i + len > byte_len` is
+                // computed at usize width and cannot overflow; only the
+                // stored cursor is u32.
                 let idx = *i as usize;
                 let total = arraybuf.array_buffer.byte_len as usize;
                 if idx >= total {
@@ -432,9 +410,8 @@ impl BuiltinIO {
     }
 
     /// Queue `buf` on this stream's IOWriter and arrange for `child`'s
-    /// `on_io_writer_chunk` to fire when the chunk completes. Spec: Builtin.zig
-    /// `BuiltinIO.Output.enqueue` — delegates to `fd.writer.enqueue` passing
-    /// `fd.captured` as the tee bytelist.
+    /// `on_io_writer_chunk` to fire when the chunk completes. Delegates to
+    /// `fd.writer.enqueue` passing `fd.captured` as the tee bytelist.
     ///
     /// `_safeguard` proves the caller checked `needs_io()`.
     pub(crate) fn enqueue(
@@ -449,8 +426,8 @@ impl BuiltinIO {
         }
     }
 
-    /// Spec: Builtin.zig `BuiltinIO.Output.enqueueFmtBltn` — format with the
-    /// optional `"{kind}: "` prefix and enqueue on the underlying IOWriter.
+    /// Format with the optional `"{kind}: "` prefix and enqueue on the
+    /// underlying IOWriter.
     pub(crate) fn enqueue_fmt(
         &mut self,
         child: io_writer::ChildPtr,
@@ -468,7 +445,7 @@ impl BuiltinIO {
 impl BuiltinInput {
     fn from_in_kind(ik: &InKind) -> BuiltinInput {
         match ik {
-            // `Arc::clone` IS the `dupeRef` (bumps the IOReader refcount).
+            // `Arc::clone` bumps the IOReader refcount.
             InKind::Fd(r) => BuiltinInput::Fd(Arc::clone(r)),
             InKind::Ignore => BuiltinInput::Ignore,
         }
@@ -527,8 +504,6 @@ impl Builtin {
     /// `None` (meaning: caller should now call `Builtin::start`). A
     /// `Some(yield)` return means setup wrote a failing error (or threw) and
     /// the caller should propagate that yield instead.
-    ///
-    /// Spec: Builtin.zig `init()`.
     pub fn init(interp: &Interpreter, cmd: NodeId, kind: Kind) -> Option<Yield> {
         use crate::shell::states::cmd::Exec;
 
@@ -541,9 +516,9 @@ impl Builtin {
             for a in me.args.iter().skip(1) {
                 argv.push(a.as_ptr().cast::<c_char>());
             }
-            // Spec: `.fd → dupeRef`. `Arc::clone` (inside `OutFd: Clone` /
-            // `InKind: Clone`) bumps the `IOWriter`/`IOReader` refcount; the
-            // builtin's `Drop` decrements it symmetrically. No double-deref.
+            // `Arc::clone` (inside `OutFd: Clone` / `InKind: Clone`) bumps
+            // the `IOWriter`/`IOReader` refcount; the builtin's `Drop`
+            // decrements it symmetrically. No double-deref.
             (
                 argv,
                 BuiltinInput::from_in_kind(&me.io.stdin),
@@ -567,8 +542,8 @@ impl Builtin {
         Self::init_redirections(interp, cmd, kind)
     }
 
-    /// Spec: Builtin.zig `initRedirections` (lines 413-627). Opens redirect
-    /// files / wires ArrayBuffer & Blob targets / handles `2>&1` (`duplicate_out`).
+    /// Opens redirect files / wires ArrayBuffer & Blob targets / handles
+    /// `2>&1` (`duplicate_out`).
     fn init_redirections(interp: &Interpreter, cmd: NodeId, kind: Kind) -> Option<Yield> {
         // `node` points into the AST arena which outlives every state node (see Cmd::next).
         let node: &ast::Cmd = &*interp.as_cmd(cmd).node;
@@ -587,7 +562,7 @@ impl Builtin {
 
                 // `redirection_file` was NUL-terminated by Expansion; build a
                 // `&ZStr` over it (path = bytes excluding the trailing NUL).
-                // PORT NOTE: reshaped for borrowck — clone path bytes so the
+                // Clone the path bytes so the
                 // `&mut interp` open call below doesn't overlap a borrow into
                 // the Cmd node.
                 let path_buf: Vec<u8> = {
@@ -639,9 +614,6 @@ impl Builtin {
                         (),
                         |_| {},
                         is_pollable_from_mode,
-                        // Spec: passes `ShellSyscall.openat`. The Rust
-                        // `shell_openat` has the matching `(Fd,&ZStr,i32,Mode)`
-                        // signature.
                         shell_openat,
                     );
                     match result {
@@ -699,11 +671,10 @@ impl Builtin {
                     return None;
                 }
 
-                // Spec (Builtin.zig:429/502): the IOWriter receives the
-                // hardcoded platform const `is_pollable` (false on POSIX, true
-                // on Windows); the `var pollable` out-param populated by
-                // `openForWritingImpl` is a dead store in Zig and is ignored
-                // here too so polling behaviour matches the spec exactly.
+                // The IOWriter receives the hardcoded platform const
+                // `is_pollable` (false on POSIX, true on Windows); the
+                // `pollable` out-param populated by `open_for_writing_impl`
+                // is intentionally ignored.
                 let _ = pollable;
                 let redirect_writer = IOWriter::init(
                     redirfd,
@@ -779,7 +750,6 @@ impl Builtin {
                     // SAFETY: returned a live JSC-owned `*mut Value` borrowed
                     // from a Response/Request wrapper.
                     let body = unsafe { &mut *body };
-                    // Spec: `body.* == .Blob and !body.Blob.needsToReadFile()`.
                     let is_file_blob = matches!(body, crate::webcore::body::Value::Blob(b)
                         if !b.needs_to_read_file());
                     if (redirect.stdout() || redirect.stderr()) && !is_file_blob {
@@ -850,7 +820,7 @@ impl Builtin {
         None
     }
 
-    /// Spec: Cmd.zig `writeFailingError` — sets the owning Cmd's state to
+    /// Sets the owning Cmd's state to
     /// `WaitingWriteErr` and writes to the *Cmd's* `io.stderr` (not the
     /// builtin's, which may already have been redirected). Hoisted here
     /// because `init_redirections` and `Cmd::transition_to_exec` (the
@@ -864,7 +834,7 @@ impl Builtin {
         let mut buf = Vec::new();
         let _ = buf.write_fmt(args);
         if let Some(_safeguard) = interp.as_cmd(cmd).io.stderr.needs_io() {
-            // Spec: `enqueueCb(ctx)` — only the `.fd` arm transitions state.
+            // Only the `Fd` arm transitions state.
             interp.as_cmd_mut(cmd).state = CmdState::WaitingWriteErr;
             let child = io_writer::ChildPtr::new(cmd, io_writer::WriterTag::Cmd);
             // SAFETY: `OutKind::Fd` guaranteed by `needs_io()`.
@@ -892,12 +862,10 @@ impl Builtin {
     }
 
     /// Finish the builtin with `exit_code` and signal the owning Cmd.
-    /// Spec: Builtin.zig `done`.
     pub fn done(interp: &Interpreter, cmd: NodeId, exit_code: ExitCode) -> Yield {
         Self::of_mut(interp, cmd).exit_code = Some(exit_code);
-        // PORT NOTE: Zig `done` flushes `.buf` into `shell.buffered_stdout()`
-        // here. The NodeId port writes through immediately in `write_no_io`,
-        // so there is nothing to flush.
+        // Output is written through immediately in `write_no_io`, so there
+        // is nothing to flush here.
         Cmd::on_exec_done(interp, cmd, exit_code)
     }
 
@@ -925,8 +893,8 @@ impl Builtin {
         Self::of(interp, cmd).kind
     }
 
-    /// Spec: Builtin.zig `readStdinNoIO`. Returns the bytes available on
-    /// stdin when it is *not* an async fd (arraybuf / piped buf / blob).
+    /// Returns the bytes available on stdin when it is *not* an async fd
+    /// (arraybuf / piped buf / blob).
     pub fn read_stdin_no_io<'a>(interp: &'a Interpreter, cmd: NodeId) -> &'a [u8] {
         match &Self::of(interp, cmd).stdin {
             BuiltinInput::ArrayBuf { buf, .. } => buf.slice(),
@@ -939,8 +907,7 @@ impl Builtin {
     /// Write `buf` to stdout/stderr without going through IOWriter (the
     /// stream is a captured buffer / arraybuffer / blob / /dev/null).
     ///
-    /// Spec: Builtin.zig `writeNoIO`. Returns `Err(ENOSPC)` when an
-    /// ArrayBuffer target is already full (Zig: `Maybe(usize).initErr`).
+    /// Returns `Err(ENOSPC)` when an ArrayBuffer target is already full.
     /// **WARNING**: caller must have checked `needs_io() == None` first.
     pub fn write_no_io(
         interp: &Interpreter,
@@ -951,7 +918,7 @@ impl Builtin {
         if buf.is_empty() {
             return Ok(0);
         }
-        // PORT NOTE: reshaped for borrowck — split-borrow the Cmd so `shell`
+        // Split-borrow the Cmd so `shell`
         // and the builtin's stdout/stderr are accessible simultaneously.
         let cmd_node = interp.as_cmd_mut(cmd);
         let shell = cmd_node.base.shell;
@@ -976,8 +943,7 @@ impl Builtin {
         interp.as_cmd(cmd).base.shell()
     }
 
-    /// The owning `Cmd` state node. Spec: Builtin.zig `parentCmd` (Zig used
-    /// `@fieldParentPtr`; in the NodeId port the builtin already stores `cmd`).
+    /// The owning `Cmd` state node.
     #[inline]
     pub fn parent_cmd<'a>(interp: &'a Interpreter, cmd: NodeId) -> &'a Cmd {
         interp.as_cmd(cmd)
@@ -988,8 +954,7 @@ impl Builtin {
         interp.as_cmd_mut(cmd)
     }
 
-    /// Event loop handle (forwarded from the interpreter). Spec: Builtin.zig
-    /// `eventLoop` → `parentCmd().base.eventLoop()`.
+    /// Event loop handle (forwarded from the interpreter).
     #[inline]
     pub fn event_loop(
         interp: &Interpreter,
@@ -998,27 +963,22 @@ impl Builtin {
         interp.event_loop
     }
 
-    /// Spec: Builtin.zig `throw` → `parentCmd().base.throw(err)`. In the
-    /// NodeId port the interpreter owns the throw path directly.
+    /// The interpreter owns the throw path directly.
     #[inline]
     pub fn throw(interp: &Interpreter, _cmd: NodeId, err: crate::shell::ShellErr) {
         interp.throw(err);
     }
 
-    /// Cwd fd of the owning Cmd's shell env. Spec: Builtin.zig `this.cwd` /
-    /// `parentCmd().base.shell.cwd_fd`.
+    /// Cwd fd of the owning Cmd's shell env.
     #[inline]
     pub fn cwd(interp: &Interpreter, cmd: NodeId) -> bun_sys::Fd {
         Self::shell(interp, cmd).cwd_fd
     }
 
-    /// Format `"{kind}: {fmt}"` into a fresh heap buffer. Spec: Builtin.zig
-    /// `fmtErrorArena` (Zig allocates from the Cmd's bump arena; we use a
-    /// `Vec` — the per-builtin arena isn't ported yet).
+    /// Format `"{kind}: {fmt}"` into a fresh heap buffer.
     ///
     /// Stored on the `Builtin` so the returned `&[u8]` borrow stays valid
-    /// across the immediate `write_no_io` / `enqueue` call (matches the Zig
-    /// arena lifetime).
+    /// across the immediate `write_no_io` / `enqueue` call.
     pub fn fmt_error_arena<'a>(
         interp: &'a Interpreter,
         cmd: NodeId,
@@ -1036,9 +996,8 @@ impl Builtin {
         &me.err_buf
     }
 
-    /// Error messages formatted to match bash. Spec: Builtin.zig
-    /// `taskErrorToString` (the `bun.shell.ShellErr` arm — dispatches on the
-    /// variant; `.sys` recurses into the `jsc.SystemError` formatter).
+    /// Error messages formatted to match bash. Dispatches on the variant;
+    /// `Sys` recurses into the system-error formatter.
     pub fn shell_err_to_string<'a>(
         interp: &'a Interpreter,
         cmd: NodeId,
@@ -1048,8 +1007,7 @@ impl Builtin {
         use crate::shell::ShellErr;
         match err {
             ShellErr::Sys(sys) => {
-                // Spec: Builtin.zig `taskErrorToString` (the `jsc.SystemError`
-                // arm) — `"{message}\n"` or `"{message}: {path}\n"`.
+                // `"{message}\n"` or `"{message}: {path}\n"`.
                 if sys.path.is_empty() {
                     Self::fmt_error_arena(
                         interp,
@@ -1091,9 +1049,8 @@ impl Builtin {
         }
     }
 
-    /// Error messages formatted to match bash. Spec: Builtin.zig
-    /// `taskErrorToString` (the `Syscall.Error` arm) — maps the errno through
-    /// `bun.sys.coreutils_error_map` so output matches GNU coreutils
+    /// Error messages formatted to match bash. Maps the errno through
+    /// `bun_sys::coreutils_error_map` so output matches GNU coreutils
     /// (e.g. `ENOENT` → "No such file or directory"); falls back to
     /// `"unknown error {errno}"` when unmapped.
     pub fn task_error_to_string<'a>(
@@ -1133,9 +1090,6 @@ impl Builtin {
     /// (`illegal option` / usage / `unsupported option`), runs `set_wait_err`
     /// so the per-builtin state machine can move to its `WaitingWriteErr`
     /// variant, then writes the message to stderr and finishes with exit 1.
-    ///
-    /// Spec: open-coded `switch (e)` in cat.zig:45, mkdir.zig:52, cp.zig:74,
-    /// touch.zig:33 — Zig duplicates this per builtin; hoisted once here.
     pub fn fail_parse(
         interp: &Interpreter,
         cmd: NodeId,
@@ -1169,8 +1123,7 @@ impl Builtin {
 
     /// Write `buf` to stderr (async if needed) then finish with `exit_code`.
     /// Shared helper for builtins whose only failure path is "print error and
-    /// exit". Spec: per-builtin `writeFailingError` in Zig — hoisted here so
-    /// the NodeId-style builtins don't each repeat the needs_io branch.
+    /// exit", so each builtin doesn't repeat the needs_io branch.
     ///
     /// Stashes `exit_code` on the `Builtin` so the async path
     /// (`on_io_writer_chunk`) can finish with it; callers that need to mark a
@@ -1184,7 +1137,7 @@ impl Builtin {
         Self::of_mut(interp, cmd).exit_code = Some(exit_code);
         if let Some(safeguard) = Self::of(interp, cmd).stderr.needs_io() {
             let child = io_writer::ChildPtr::new(cmd, io_writer::WriterTag::Builtin);
-            // PORT NOTE: reshaped for borrowck — clone buf so the &mut on
+            // Clone buf so the &mut on
             // `stderr` doesn't overlap a borrow into `err_buf`.
             let owned = buf.to_vec();
             return Self::of_mut(interp, cmd)
@@ -1196,11 +1149,8 @@ impl Builtin {
     }
 }
 
-// `deinit`: Spec Builtin.zig `deinit` — per-impl cleanup + `stdin/stdout/
-// stderr.deref()`. In the Rust port every `Impl` variant owns its state via
-// `Box`/`Vec`/`Arc`, and `BuiltinIO`/`BuiltinInput` hold `Arc<IOWriter>` /
-// `Arc<IOReader>` / `ArrayBufferStrong` / `Arc<BuiltinBlob>` whose `Drop`
-// already decrements the refcount. So `deinit` is fully covered by `Drop` on
-// `Box<Builtin>` (called from `Cmd::deinit`). No explicit body needed.
-
-// ported from: src/shell/Builtin.zig
+// Cleanup: every `Impl` variant owns its state via `Box`/`Vec`/`Arc`, and
+// `BuiltinIO`/`BuiltinInput` hold `Arc<IOWriter>` / `Arc<IOReader>` /
+// `ArrayBufferStrong` / `Arc<BuiltinBlob>` whose `Drop` already decrements
+// the refcount. So cleanup is fully covered by `Drop` on `Box<Builtin>`
+// (called from `Cmd::deinit`). No explicit deinit needed.
diff --git a/src/runtime/shell/EnvMap.rs b/src/runtime/shell/EnvMap.rs
index 57bad51a0d6..53693524e62 100644
--- a/src/runtime/shell/EnvMap.rs
+++ b/src/runtime/shell/EnvMap.rs
@@ -6,12 +6,10 @@ pub struct EnvMap {
     map: EnvMapInner,
 }
 
-// PORT NOTE: Zig used `std.ArrayHashMap(K, V, Context, store_hash=true)`.
-// `bun_collections::ArrayHashMap` already takes a `C: ArrayHashContext<K>` param.
 pub(crate) type Iterator<'a> = Iter<'a, EnvStr, EnvStr>;
 
-// PORT NOTE: Zig calls this `MapType`. Renamed to avoid rustc confusing it with the
-// unrelated mmap `sys::c::MapType` / `sys::posix::MapType` in diagnostic suggestions.
+// Named `EnvMapInner` to avoid rustc confusing it with the unrelated mmap
+// `sys::c::MapType` / `sys::posix::MapType` in diagnostic suggestions.
 type EnvMapInner = ArrayHashMap<EnvStr, EnvStr, EnvMapContext>;
 
 #[derive(Default)]
@@ -21,7 +19,6 @@ impl ArrayHashContext<EnvStr> for EnvMapContext {
     fn hash(&self, s: &EnvStr) -> u32 {
         #[cfg(windows)]
         {
-            // Zig: `bun.CaseInsensitiveASCIIStringContext.hash(undefined, s.slice())`.
             return <array_hash_map::CaseInsensitiveAsciiStringContext as ArrayHashContext<[u8]>>::hash(
                 &array_hash_map::CaseInsensitiveAsciiStringContext::default(),
                 s.slice(),
@@ -36,7 +33,6 @@ impl ArrayHashContext<EnvStr> for EnvMapContext {
     fn eql(&self, a: &EnvStr, b: &EnvStr, _b_index: usize) -> bool {
         #[cfg(windows)]
         {
-            // Zig: `bun.CaseInsensitiveASCIIStringContext.eql` → `eqlCaseInsensitiveASCIIICheckLength`.
             // Must be length-checked: "PATH" must NOT match "PATHEXT".
             return bun_core::strings::eql_case_insensitive_asciii_check_length(
                 a.slice(),
@@ -78,7 +74,6 @@ impl EnvMap {
     /// NOTE: This will `.ref()` value, so you should `defer value.deref()` it
     /// before handing it to this function!!!
     pub fn insert(&mut self, key: EnvStr, val: EnvStr) {
-        // PORT NOTE: `bun.handleOom` → `.expect("OOM")` (abort-on-OOM is the Rust default).
         let result = self.map.get_or_put(key).expect("OOM");
         if !result.found_existing {
             key.ref_();
@@ -121,7 +116,7 @@ impl EnvMap {
         new
     }
 
-    // PORT NOTE: allocator param dropped (global mimalloc); identical to `clone` now.
+    // With a single global allocator (mimalloc), this is identical to `clone`.
     pub fn clone_with_allocator(&self) -> EnvMap {
         self.clone()
     }
@@ -147,5 +142,3 @@ impl Drop for EnvMap {
         // map storage freed by its own Drop
     }
 }
-
-// ported from: src/shell/EnvMap.zig
diff --git a/src/runtime/shell/EnvStr.rs b/src/runtime/shell/EnvStr.rs
index d52a0d55801..e6421bae591 100644
--- a/src/runtime/shell/EnvStr.rs
+++ b/src/runtime/shell/EnvStr.rs
@@ -13,7 +13,7 @@ use super::ref_counted_str::RefCountedStr;
 
 bun_core::declare_scope!(EnvStrLog, hidden);
 
-/// Packed `u128` layout (Zig `packed struct(u128)`, LSB-first):
+/// Packed `u128` layout (LSB-first):
 /// - bits  0..48  : `ptr` (u48)
 /// - bits 48..64  : `tag` (u16)
 /// - bits 64..128 : `len` (usize)
@@ -57,8 +57,8 @@ impl EnvStr {
     #[inline]
     fn tag(self) -> Tag {
         // Only constructed via `pack` with a valid `Tag` discriminant (0..=2);
-        // any other value is corruption — trap (matches Zig's safety-checked
-        // `@enumFromInt`) rather than silently folding to `Empty`.
+        // any other value is corruption — trap rather than silently folding
+        // to `Empty`.
         match ((self.0 >> TAG_SHIFT) & TAG_MASK) as u16 {
             0 => Tag::Empty,
             1 => Tag::Refcounted,
@@ -88,9 +88,8 @@ impl EnvStr {
             return Self::pack(0, Tag::Empty, 0);
         }
 
-        // PORT NOTE: Zig was `bun.handleOom(bun.default_allocator.dupe(u8, old_str))`.
-        // Global mimalloc + abort-on-OOM is the Rust default; ownership of the
-        // duplicated bytes transfers to RefCountedStr.
+        // Global mimalloc aborts on OOM; ownership of the duplicated bytes
+        // transfers to RefCountedStr.
         let str: Box<[u8]> = Box::<[u8]>::from(old_str);
         let len = str.len();
         Self::pack(
@@ -100,33 +99,29 @@ impl EnvStr {
         )
     }
 
-    pub fn init_ref_counted(str: &[u8]) -> EnvStr {
-        // TODO(port): Zig `initRefCounted([]const u8)` hands the slice to RefCountedStr which
-        // assumes ownership of the backing allocation. Revisit RefCountedStr::init ownership
-        // contract (caller-allocated vs. dupe-on-init).
+    /// Takes ownership of the backing allocation (hands the slice to
+    /// `RefCountedStr` without copying). Use [`Self::dupe_ref_counted`] to
+    /// copy a borrowed slice instead.
+    pub fn init_ref_counted(str: Box<[u8]>) -> EnvStr {
         if str.is_empty() {
             return Self::pack(0, Tag::Empty, 0);
         }
 
-        // PORT NOTE: Zig left `len` defaulted to 0 here (only `ptr` + `tag` set); the slice
-        // length is recovered via RefCountedStr::byte_slice(). Preserve that.
-        // PORT NOTE: Zig handed the borrowed slice to RefCountedStr which assumed ownership
-        // of its backing allocation. Rust cannot transfer ownership through `&[u8]`, so we
-        // dupe here; revisit `init_ref_counted`'s ownership contract (likely
-        // change the param to `Box<[u8]>`).
+        // NOTE: `len` is left 0 here (only `ptr` + `tag` set); the slice
+        // length is recovered via RefCountedStr::byte_slice().
         Self::pack(
-            to_ptr(RefCountedStr::init(Box::<[u8]>::from(str)) as *const c_void),
+            to_ptr(RefCountedStr::init(str) as *const c_void),
             Tag::Refcounted,
             0,
         )
     }
 
     pub fn slice(&self) -> &[u8] {
-        // PORT NOTE: the returned slice borrows either external memory (Tag::Slice) or the
+        // NOTE: the returned slice borrows either external memory (Tag::Slice) or the
         // RefCountedStr buffer. Tying the return lifetime to `&self` prevents the caller from
         // conjuring `&'static [u8]` (PORTING.md §Forbidden: lifetime-extension via raw-pointer
         // deref). `EnvStr` is still `Copy`, so this is a best-effort bound — the caller is
-        // responsible for keeping the backing storage alive (same contract as Zig's `slice()`).
+        // responsible for keeping the backing storage alive.
         match self.tag() {
             Tag::Empty => b"",
             Tag::Slice => self.cast_slice(),
@@ -188,7 +183,9 @@ impl EnvStr {
         // SAFETY: tag == Slice guarantees `ptr` was derived from a valid `[*]const u8` of
         // length `len` whose lifetime is managed elsewhere (caller contract of init_slice).
         // The returned borrow is tied to `&self` so callers cannot pick `'static`.
-        // TODO(port): strict-provenance — ptr was round-tripped through an integer.
+        // Provenance: the packed-tagged-value design round-trips the pointer
+        // through an integer by construction (exposed provenance), so this is
+        // not strict-provenance clean and cannot be without unpacking EnvStr.
         unsafe { core::slice::from_raw_parts(self.ptr() as usize as *const u8, self.len()) }
     }
 
@@ -207,9 +204,6 @@ impl Default for EnvStr {
 
 #[inline]
 fn to_ptr(ptr_val: *const c_void) -> u64 {
-    // Zig: bitcast usize→[8]u8, take low 6 bytes, bitcast→u48.
-    // Equivalent to masking the low 48 bits of the address.
+    // Masks the low 48 bits of the address.
     (ptr_val as usize as u64) & ((1u64 << 48) - 1)
 }
-
-// ported from: src/shell/EnvStr.zig
diff --git a/src/runtime/shell/IO.rs b/src/runtime/shell/IO.rs
index e618768bb3a..4f42a9fc341 100644
--- a/src/runtime/shell/IO.rs
+++ b/src/runtime/shell/IO.rs
@@ -1,7 +1,6 @@
 //! Carries stdin/stdout/stderr for a state node.
 //!
-//! In the NodeId-arena port `IO` is a plain `Clone` value (the Zig version
-//! used intrusive refcounts on `IOReader`/`IOWriter`; here those are `Arc`).
+//! `IO` is a plain `Clone` value; `IOReader`/`IOWriter` are `Arc`-refcounted.
 
 use bun_collections::VecExt;
 use core::fmt;
@@ -30,14 +29,14 @@ impl fmt::Display for IO {
 }
 
 impl IO {
-    /// Zig `copy` = `ref()` + struct copy. With `Arc` fields, `Clone`
-    /// increments refcounts and copies the struct in one step.
+    /// With `Arc` fields, `Clone` increments refcounts and copies the struct
+    /// in one step.
     #[inline]
     pub fn copy(&self) -> IO {
         self.clone()
     }
 
-    /// Spec: IO.zig `memoryCost` — sum of stdin/stdout/stderr.
+    /// Sum of stdin/stdout/stderr.
     pub fn memory_cost(&self) -> usize {
         let mut size = core::mem::size_of::<IO>();
         size += self.stdin.memory_cost();
@@ -46,7 +45,7 @@ impl IO {
         size
     }
 
-    /// Spec: IO.zig `to_subproc_stdio`. Maps the state-node IO triple onto
+    /// Maps the state-node IO triple onto
     /// `subproc::Stdio` for [`ShellSubprocess::spawn_async`], and stashes the
     /// owning `IOWriter` Arcs on `shellio` so [`PipeReader`]'s captured-writer
     /// path can tee subprocess output back into the JS-side buffers.
@@ -126,7 +125,6 @@ impl fmt::Display for OutKind {
 }
 
 impl InKind {
-    /// Spec: IO.zig `InKind.memoryCost`.
     pub(crate) fn memory_cost(&self) -> usize {
         match self {
             InKind::Fd(r) => r.memory_cost(),
@@ -134,7 +132,6 @@ impl InKind {
         }
     }
 
-    /// Spec: IO.zig `InKind.to_subproc_stdio`.
     pub(crate) fn to_subproc_stdio(&self) -> Stdio {
         match self {
             InKind::Fd(r) => Stdio::Fd(r.fd()),
@@ -144,7 +141,6 @@ impl InKind {
 }
 
 impl OutFd {
-    /// Spec: IO.zig `OutKind.Fd.memoryCost`.
     pub(crate) fn memory_cost(&self) -> usize {
         let mut cost = self.writer.memory_cost();
         if let Some(captured) = self.captured {
@@ -157,7 +153,6 @@ impl OutFd {
 }
 
 impl OutKind {
-    /// Spec: IO.zig `OutKind.memoryCost`.
     pub(crate) fn memory_cost(&self) -> usize {
         match self {
             OutKind::Fd(fd) => fd.memory_cost(),
@@ -175,23 +170,19 @@ impl OutKind {
         }
     }
 
-    /// Spec: IO.zig `OutKind.to_subproc_stdio`. Retains the `IOWriter` Arc on
+    /// Retains the `IOWriter` Arc on
     /// `shellio` so the subprocess's `PipeReader::captured_writer` can drain
     /// captured bytes into it after the spawn returns.
     pub(crate) fn to_subproc_stdio(&self, shellio: &mut Option<std::sync::Arc<IOWriter>>) -> Stdio {
         match self {
             OutKind::Fd(val) => {
-                // Spec: `shellio.* = val.writer.dupeRef()`.
                 *shellio = Some(std::sync::Arc::clone(&val.writer));
                 if let Some(cap) = val.captured {
                     Stdio::Capture(Capture { buf: cap })
                 } else {
-                    // Spec (IO.zig:178) reads `val.writer.fd.get()` — an
-                    // optional that becomes empty once the fd has been handed
-                    // off to libuv. `IOWriter::fd()` (IOWriter.rs) encodes
-                    // that same state by returning `Fd::INVALID` after
-                    // hand-off, so the sentinel compare here is the port of
-                    // the optional unwrap, not a fresh invariant.
+                    // `IOWriter::fd()` (IOWriter.rs) returns `Fd::INVALID`
+                    // once the fd has been handed off to libuv, so the
+                    // sentinel compare here checks for that hand-off state.
                     let fd = val.writer.fd();
                     if fd != bun_sys::Fd::INVALID {
                         Stdio::Fd(fd)
@@ -208,5 +199,3 @@ impl OutKind {
         }
     }
 }
-
-// ported from: src/shell/IO.zig
diff --git a/src/runtime/shell/IOReader.rs b/src/runtime/shell/IOReader.rs
index 6c4ab19becc..ef0b3dd3876 100644
--- a/src/runtime/shell/IOReader.rs
+++ b/src/runtime/shell/IOReader.rs
@@ -1,8 +1,6 @@
 //! Similar to `IOWriter` but for reading.
 //!
-//! *NOTE* This type is reference counted (via `Arc` in the Rust port). The
-//! Zig version queued deinitialization onto the event loop to prevent bugs;
-//! see the `Drop` impl note for the Rust equivalent.
+//! *NOTE* This type is reference counted via `Arc`; see the `Drop` impl note.
 
 use core::cell::UnsafeCell;
 #[cfg(not(windows))]
@@ -14,13 +12,12 @@ use crate::shell::interpreter::{EventLoopHandle, Interpreter, NodeId};
 use crate::shell::yield_::Yield;
 
 // ──────────────────────────────────────────────────────────────────────────
-// ChildPtr (NodeId-arena port of Zig TaggedPointerUnion<{Cat}>)
+// ChildPtr
 // ──────────────────────────────────────────────────────────────────────────
 
 /// In the NodeId-arena port, listeners are identified by `(NodeId, ReaderTag)`
 /// — the node id of the owning Cmd plus a tag saying which builtin impl to
-/// dispatch the `on_read_chunk`/`on_reader_done` callback to. Replaces the
-/// Zig `TaggedPtrUnion<(Cat,)>`.
+/// dispatch the `on_read_chunk`/`on_reader_done` callback to.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub struct ChildPtr {
     pub node: NodeId,
@@ -33,15 +30,13 @@ pub enum ReaderTag {
     Cat,
 }
 
-/// Spec: IOReader.zig `Readers = SmolList(ChildPtr, 4)`.
-// PERF(port): was inline-4 small-vec — profile if hot.
+// PERF: an inline small-vec may be worth it — profile if hot.
 type Readers = Vec<ChildPtr>;
 
 // ──────────────────────────────────────────────────────────────────────────
 // IOReader
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Spec: IOReader.zig `ReaderImpl = bun.io.BufferedReader`.
 pub(crate) type ReaderImpl = bun_io::BufferedReader;
 
 struct State {
@@ -51,8 +46,7 @@ struct State {
     err: Option<sys::SystemError>,
     /// The raw `sys::Error` that produced `err`. `SystemError` is not `Clone`
     /// in the Rust port yet, so we keep the source error to re-derive a fresh
-    /// `SystemError` per callee in `on_reader_done_cb` (Spec IOReader.zig:189
-    /// passes `this.err` ref'd to each child).
+    /// `SystemError` per callee in `on_reader_done_cb`.
     raw_err: Option<sys::Error>,
     evtloop: EventLoopHandle,
     #[cfg(windows)]
@@ -82,8 +76,7 @@ unsafe impl Send for IOReader {}
 unsafe impl Sync for IOReader {}
 
 impl IOReader {
-    /// Spec: IOReader.zig `__deinit` (body `AsyncDeinitReader` posts back to
-    /// main). Drops the last strong ref so the underlying `BufferedReader`
+    /// Drops the last strong ref so the underlying `BufferedReader`
     /// closes on the JS thread.
     ///
     /// # Safety
@@ -102,7 +95,8 @@ impl IOReader {
     #[inline]
     #[allow(clippy::mut_from_ref)] // interior mutability via UnsafeCell; single-threaded
     fn state(&self) -> &mut State {
-        // SAFETY: single-threaded; matches Zig `*IOReader` model.
+        // SAFETY: shell is single-threaded; no overlapping borrow of `state`
+        // escapes a callback (see struct doc comment).
         unsafe { &mut *self.state.get() }
     }
 
@@ -124,8 +118,7 @@ impl IOReader {
 
     /// Bump our own Arc strong count. Held across re-entrant `run_yield` calls
     /// whose child callback may drop the last external ref and free us
-    /// mid-method. Spec gets the same guarantee from `asyncDeinit`'s next-tick
-    /// hop (IOReader.zig:197); here we keep a strong ref on the stack instead.
+    /// mid-method.
     #[inline]
     fn keepalive(&self) -> std::sync::Arc<IOReader> {
         self.state()
@@ -162,7 +155,7 @@ impl IOReader {
                 interp: None,
             }),
         });
-        // PORT NOTE: set the parent backref after Arc allocation so the
+        // NOTE: set the parent backref after Arc allocation so the
         // address is stable.
         let parent: *const IOReader = std::sync::Arc::as_ptr(&this);
         // SAFETY: `Arc::as_ptr` yields `*const IOReader`, but every field of
@@ -217,7 +210,7 @@ impl IOReader {
         self.state().evtloop.as_event_loop_ctx()
     }
 
-    /// Only does things on windows. Spec: IOReader.zig `setReading`.
+    /// Only does things on windows.
     #[inline]
     fn set_reading(&self, reading: bool) {
         #[cfg(windows)]
@@ -227,7 +220,7 @@ impl IOReader {
         let _ = reading;
     }
 
-    /// Idempotent function to start the reading. Spec: IOReader.zig `start`.
+    /// Idempotent function to start the reading.
     pub fn start(&self) -> Yield {
         self.state().started = true;
         #[cfg(not(windows))]
@@ -261,7 +254,7 @@ impl IOReader {
         }
     }
 
-    /// Spec: IOReader.zig `addReader`. Only adds if not already present.
+    /// Only adds if not already present.
     pub fn add_reader(&self, reader: ChildPtr) {
         let s = self.state();
         if !s.readers.contains(&reader) {
@@ -269,7 +262,7 @@ impl IOReader {
         }
     }
 
-    /// Spec: IOReader.zig `removeReader`.
+    /// Unregister a listener; no-op if it was never added.
     pub fn remove_reader(&self, reader: ChildPtr) {
         let s = self.state();
         if let Some(idx) = s.readers.iter().position(|r| *r == reader) {
@@ -277,20 +270,19 @@ impl IOReader {
         }
     }
 
-    /// Spec: IOReader.zig `onReadChunk` (the `BufferedReader.onReadChunk` hook).
+    /// The `BufferedReader.onReadChunk` hook.
     fn on_read_chunk_cb(&self, chunk: &[u8], has_more: bun_io::ReadState) -> bool {
         // `dispatch_read_chunk` → `Cat::on_io_reader_chunk` may drop the last
         // external Arc; hold one across the whole body so the trailing
         // `state()` accesses (and `run_yield`'s re-read of `interp`) see live
-        // memory. Spec gets this from `asyncDeinit`'s next-tick hop.
+        // memory.
         let _keepalive = self.keepalive();
         self.set_reading(false);
-        // PORT NOTE: reshaped for borrowck — `dispatch_read_chunk`/`run_yield`
+        // NOTE: reshaped for borrowck — `dispatch_read_chunk`/`run_yield`
         // both re-derive `state()` (and the interpreter callback may re-enter
         // `add_reader`/`remove_reader`), so we must NOT hold a long-lived
         // `&mut State` across the dispatch. Re-derive `state()` per access
-        // instead, mirroring Zig's `this.readers.len()`/`this.readers.get(i)`
-        // pattern (IOReader.zig:143-153).
+        // instead.
         let mut i = 0usize;
         while i < self.state().readers.len() {
             let r = self.state().readers[i];
@@ -307,11 +299,11 @@ impl IOReader {
         let should_continue = has_more != bun_io::ReadState::Eof;
         if should_continue && !self.state().readers.is_empty() {
             self.set_reading(true);
-            // PORT NOTE: Spec IOReader.zig:159-167 calls
-            // `this.reader.registerPoll()` (posix) / `startWithCurrentPipe()`
-            // (windows) here. In Rust this would re-derive a second
-            // `&mut ReaderImpl` while the bun_io read loop still holds one on
-            // its stack (PipeReader.rs aliasing contract) — Stacked-Borrows UB.
+            // NOTE: no explicit re-arm (`registerPoll()` on posix /
+            // `startWithCurrentPipe()` on windows) here: that would re-derive
+            // a second `&mut ReaderImpl` while the bun_io read loop still
+            // holds one on its stack (PipeReader.rs aliasing contract) —
+            // Stacked-Borrows UB.
             // On posix the re-arm is redundant: the read loop re-registers
             // itself after the callback returns based on the `bool` we return
             // (PipeReader.rs:731/755/846/920/986). On Windows the re-arm is
@@ -326,41 +318,38 @@ impl IOReader {
         should_continue
     }
 
-    /// Spec: IOReader.zig `onReaderError`.
     fn on_reader_error(&self, err: &sys::Error) {
         // `dispatch_reader_done` may drop the last external Arc; keep `self`
-        // alive across the loop. Spec gets this from `asyncDeinit`'s hop.
+        // alive across the loop.
         let _keepalive = self.keepalive();
         self.set_reading(false);
         let s = self.state();
         s.err = Some(err.to_shell_system_error());
         s.raw_err = Some(err.clone());
-        // PORT NOTE: reshaped for borrowck — copy out before dispatching.
+        // NOTE: reshaped for borrowck — copy out before dispatching.
         let readers: Vec<ChildPtr> = s.readers.clone();
         let interp = s.interp;
         for r in readers {
-            // Spec: `e.ref()` then pass — re-derive a fresh SystemError per
-            // callee instead (see IOWriter.on_error note).
+            // Re-derive a fresh SystemError per callee (see
+            // IOWriter.on_error note).
             let ee = err.to_shell_system_error();
             self.run_yield(dispatch_reader_done(r, Some(ee), interp));
         }
     }
 
-    /// Spec: IOReader.zig `onReaderDone`.
     fn on_reader_done_cb(&self) {
         // `dispatch_reader_done` → `Cat::on_io_reader_done` drops Cat's
         // `Arc<IOReader>`; if that was the last external ref, `self` is freed
         // mid-loop and `run_yield`'s `state().interp` reads 0xdfdf poison.
-        // Hold a strong ref across the body. Spec: `asyncDeinit` next-tick hop.
+        // Hold a strong ref across the body.
         let _keepalive = self.keepalive();
         self.set_reading(false);
         let s = self.state();
         let readers: Vec<ChildPtr> = s.readers.clone();
         let interp = s.interp;
-        // Spec IOReader.zig:189-193: pass `this.err` (ref'd) if set.
-        // `SystemError` isn't `Clone` in the Rust port yet, so we kept the
-        // source `sys::Error` (which IS `Clone`) and re-derive a fresh
-        // `SystemError` per callee — same approach as `on_reader_error`.
+        // `SystemError` isn't `Clone` yet, so we keep the source `sys::Error`
+        // (which IS `Clone`) and re-derive a fresh `SystemError` per callee —
+        // same approach as `on_reader_error`.
         let raw_err = s.raw_err.clone();
         for r in readers {
             let ee = raw_err.as_ref().map(|e| e.to_shell_system_error());
@@ -390,7 +379,7 @@ impl IOReader {
 // no `&mut IOReader` is materialized, satisfying the init() *const→*mut
 // invariant. Aliasing with the caller's live `&mut ReaderImpl` is handled by
 // the state/reader UnsafeCell split — callbacks touch only `state`, never
-// `reader()`. `loop_` spec: IOReader.zig `loop()`.
+// `reader()`.
 bun_io::impl_buffered_reader_parent! {
     ShellIoReader for IOReader;
     has_on_read_chunk = true;
@@ -402,16 +391,15 @@ bun_io::impl_buffered_reader_parent! {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Drop (replaces Zig RefCount.deref → asyncDeinit → asyncDeinitCallback)
+// Drop
 // ──────────────────────────────────────────────────────────────────────────
 
 impl Drop for IOReader {
     fn drop(&mut self) {
-        // Spec: IOReader.zig `asyncDeinitCallback`. The async hop guarded
-        // against being deref'd from inside a read callback while
-        // BufferedReader is still iterating; with `Arc` the last ref drops
-        // after the callback returns.
-        // TODO(port): revisit if a child callback can drop the last Arc while
+        // With `Arc` the last ref drops after the callback returns, so this
+        // does not run from inside a read callback while BufferedReader is
+        // still iterating.
+        // TODO: revisit if a child callback can drop the last Arc while
         // BufferedReader is still on the stack — would need the
         // EventLoopTask hop once the shell EventLoopHandle shim is real.
         let s = self.state.get_mut();
@@ -477,5 +465,3 @@ fn dispatch_reader_done(
         }
     }
 }
-
-// ported from: src/shell/IOReader.zig
diff --git a/src/runtime/shell/IOWriter.rs b/src/runtime/shell/IOWriter.rs
index 0e3a94c98df..239c2bb3a27 100644
--- a/src/runtime/shell/IOWriter.rs
+++ b/src/runtime/shell/IOWriter.rs
@@ -25,13 +25,12 @@ use crate::shell::interpreter::{EventLoopHandle, Interpreter, NodeId};
 use crate::shell::yield_::Yield;
 
 // ──────────────────────────────────────────────────────────────────────────
-// ChildPtr (NodeId-arena port of Zig TaggedPointerUnion)
+// ChildPtr
 // ──────────────────────────────────────────────────────────────────────────
 
 /// In the NodeId-arena port, a "writer child" is `(NodeId, WriterTag)` — the
 /// id of the owning state node plus a tag saying which `on_io_writer_chunk`
-/// impl to dispatch to. Replaces Zig's `TaggedPtrUnion<(Builtin, Cmd,
-/// Pipeline, …, PipeReader.CapturedWriter)>`.
+/// impl to dispatch to.
 ///
 /// The one tag that does **not** live in the NodeId arena is
 /// `WriterTag::Subproc` (the `subproc::CapturedWriter` embedded inside a
@@ -64,7 +63,7 @@ impl ChildPtr {
     }
 
     /// Construct a `ChildPtr` targeting a `subproc::CapturedWriter` (lives
-    /// outside the NodeId arena, recovered via `container_of` in the Zig).
+    /// outside the NodeId arena).
     #[inline]
     pub(crate) fn subproc_capture(cw: *mut core::ffi::c_void) -> ChildPtr {
         ChildPtr {
@@ -109,7 +108,7 @@ pub struct Flags {
 
 /// One queued chunk: which child enqueued it, how many bytes (in `buf`), how
 /// many of those have been written so far, and an optional `Vec<u8>` to tee
-/// into. Spec: IOWriter.zig `Writer`.
+/// into.
 struct Writer {
     ptr: ChildPtr,
     len: usize,
@@ -146,8 +145,7 @@ impl Writer {
     }
 }
 
-/// Spec: IOWriter.zig `Writers = SmolList(Writer, 2)`.
-// PERF(port): was inline-2 small-vec — profile if hot; smallvec crate.
+// PERF: an inline small-vec may be worth it — profile if hot; smallvec crate.
 type Writers = Vec<Writer>;
 
 /// ~128kb. We shrink `buf` when we reach the last writer, but if that never
@@ -158,22 +156,19 @@ const SHRINK_THRESHOLD: usize = 1024 * 128;
 // IOWriter
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Spec: IOWriter.zig `WriterImpl = bun.io.BufferedWriter(IOWriter, …)`.
 #[cfg(not(windows))]
 pub(crate) type WriterImpl = bun_io::pipe_writer::PosixBufferedWriter<IOWriter>;
 #[cfg(windows)]
 pub(crate) type WriterImpl = bun_io::pipe_writer::WindowsBufferedWriter<IOWriter>;
 
-/// Spec: IOWriter.zig `Poll = WriterImpl` — the `FilePoll.Owner` payload type
-/// (`@field(Owner.Tag, @typeName(ShellBufferedWriter))` arm in
-/// `posix_event_loop.zig`).
+/// The `FilePoll.Owner` payload type for `SHELL_BUFFERED_WRITER`.
 #[allow(dead_code)]
 pub(crate) type Poll = WriterImpl;
 
 /// Poll-dispatch entry for `SHELL_BUFFERED_WRITER`. Holds an extra Arc strong
 /// ref across `on_poll` so child `onIOWriterChunk` callbacks (via `bump()`)
 /// can drop the last external ref without freeing `self` while PipeWriter is
-/// still on the stack. Spec uses an async-deinit hop for the same guarantee.
+/// still on the stack.
 #[cfg(not(windows))]
 pub fn on_poll(writer: &mut Poll, size_hint: isize, hup: bool) {
     use bun_io::pipe_writer::PosixPipeWriter;
@@ -186,18 +181,14 @@ pub fn on_poll(writer: &mut Poll, size_hint: isize, hup: bool) {
 }
 
 impl IOWriter {
-    /// Spec: IOWriter.zig `runFromMainThread` — explicitly a no-op
-    /// (`// this is unused`). Kept only because `task_tag::ShellIOWriter`
-    /// exists in the Zig task-tag enum and the Rust dispatch table mirrors it.
-    /// No code path enqueues this tag.
+    /// Explicitly a no-op. Kept only because `task_tag::ShellIOWriter`
+    /// exists in the task-tag dispatch table. No code path enqueues this tag.
     pub fn run_from_main_thread(_this: *mut IOWriter) {
-        // intentionally empty — see spec. No unsafe operations; the pointer
-        // is never dereferenced.
+        // intentionally empty. No unsafe operations; the pointer is never
+        // dereferenced.
     }
 
-    /// Spec: IOWriter.zig `__deinit` (the body `AsyncDeinitWriter` posts back
-    /// to main). Tears down the underlying `WriterImpl` and drops the last
-    /// strong ref.
+    /// Tears down the underlying `WriterImpl` and drops the last strong ref.
     ///
     /// # Safety
     /// `this` must be the `Arc::as_ptr` of a live `Arc<IOWriter>` whose strong
@@ -212,7 +203,7 @@ impl IOWriter {
 }
 
 /// Mutable state. Wrapped in `UnsafeCell` so `Arc<IOWriter>`-shared callers can
-/// mutate via `&self` (single-threaded shell; matches Zig `*IOWriter` model).
+/// mutate via `&self` (single-threaded shell).
 struct State {
     writer: WriterImpl,
     fd: Fd,
@@ -234,8 +225,7 @@ struct State {
     self_weak: std::sync::Weak<IOWriter>,
     /// Backref to the owning interpreter for async-poll callbacks (which must
     /// drive `Yield::run`). Set by the first `enqueue`/`set_interp`; `None`
-    /// until then. Spec: implicit in Zig (children held `*Interpreter` via
-    /// `@fieldParentPtr`).
+    /// until then.
     interp: Option<bun_ptr::ParentRef<Interpreter>>,
 }
 
@@ -243,8 +233,8 @@ pub struct IOWriter {
     state: UnsafeCell<State>,
 }
 
-// SAFETY: shell is single-threaded; `Arc` is used purely for refcounting (Zig
-// used `bun.ptr.RefCount`). No cross-thread access.
+// SAFETY: shell is single-threaded; `Arc` is used purely for refcounting.
+// No cross-thread access.
 unsafe impl Send for IOWriter {}
 // SAFETY: see `Send` — single-threaded, `Arc` is used only for refcounting; no
 // concurrent `&IOWriter` access occurs.
@@ -252,8 +242,8 @@ unsafe impl Sync for IOWriter {}
 
 impl IOWriter {
     /// SAFETY: single-threaded; no overlapping `&mut State` may be live across
-    /// a re-entrant `enqueue` from a child callback (Zig had the same hazard
-    /// and guards via the `Yield` trampoline).
+    /// a re-entrant `enqueue` from a child callback (the `Yield` trampoline
+    /// runs child callbacks after the borrow is dropped).
     #[inline]
     #[allow(clippy::mut_from_ref)]
     fn state(&self) -> &mut State {
@@ -264,8 +254,7 @@ impl IOWriter {
 
     /// Bump our own Arc strong count. Held across re-entrant `run_yield` calls
     /// whose child callback may drop the last external ref and free us
-    /// mid-method. Spec gets the same guarantee from `asyncDeinit`'s next-tick
-    /// hop; here we keep a strong ref on the stack instead.
+    /// mid-method; the stack-held strong ref prevents that.
     #[inline]
     fn keepalive(&self) -> std::sync::Arc<IOWriter> {
         self.state()
@@ -376,7 +365,6 @@ impl IOWriter {
 
     // ── start ────────────────────────────────────────────────────────────
 
-    /// Spec: IOWriter.zig `__start`.
     fn __start(&self) -> sys::Result<()> {
         let s = self.state();
         crate::shell_log!("IOWriter(fd={}) __start()", s.fd);
@@ -440,19 +428,16 @@ impl IOWriter {
         }
         #[cfg(windows)]
         {
-            // Spec: PipeWriter.zig:919-924 — when `Source::open` produced a uv
-            // pipe/tty, libuv has TAKEN OWNERSHIP of the underlying HANDLE
+            // When `Source::open` produced a uv pipe/tty, libuv has TAKEN
+            // OWNERSHIP of the underlying HANDLE
             // (`uv_pipe_open`/`uv_tty_init`) and `uv_close` (issued by
-            // `s.writer.close()` in Drop) will close it. Zig records this via
-            // `rawfd.take()` on the `*MovableIfWindowsFd` it passes to
-            // `writer.start`, nulling `this.fd` so `deinitOnMainThread`'s
-            // `if (this.fd.isValid()) this.fd.close()` is a no-op. The Rust
-            // port stores a plain `Fd` and `BaseWindowsPipeWriter::start`
-            // drops the `take()` (TODO at PipeWriter.rs:1277), so disarm the
-            // Drop close here instead. The `Source::File`/`SyncFile` case
-            // (incl. the EBADF→`start_with_file` fallback above, which
-            // `return`s early) keeps `s.fd` valid: with `owns_fd=false`
-            // PipeWriter does NOT close it there, so Drop must.
+            // `s.writer.close()` in Drop) will close it.
+            // `BaseWindowsPipeWriter::start` does not invalidate the stored
+            // fd (TODO at PipeWriter.rs:1277), so disarm the Drop close here
+            // instead. The `Source::File`/`SyncFile` case (incl. the
+            // EBADF→`start_with_file` fallback above, which `return`s early)
+            // keeps `s.fd` valid: with `owns_fd=false` PipeWriter does NOT
+            // close it there, so Drop must.
             if matches!(
                 s.writer.source,
                 Some(bun_io::Source::Pipe(_) | bun_io::Source::Tty(_))
@@ -463,7 +448,7 @@ impl IOWriter {
         #[cfg(not(windows))]
         {
             use bun_io::FilePollFlag;
-            // PORT NOTE: re-derive `state()` — the EINVAL/EPERM fallback paths
+            // NOTE: re-derive `state()` — the EINVAL/EPERM fallback paths
             // above re-enter `__start()` and mutate `writer.handle`, which
             // invalidates `s` under Stacked Borrows.
             let s = self.state();
@@ -484,7 +469,7 @@ impl IOWriter {
         Ok(())
     }
 
-    /// Idempotent write call. Spec: IOWriter.zig `write`.
+    /// Idempotent write call.
     fn write(&self) -> WriteOutcome {
         let s = self.state();
         #[cfg(not(windows))]
@@ -492,9 +477,9 @@ impl IOWriter {
 
         if !s.started {
             crate::shell_log!("IOWriter(fd={}) starting", s.fd);
-            // Set before on_error: the callback chain may deref to 0 and
-            // asyncDeinit's never-started fast-path would synchronously
-            // destroy us mid-on_error.
+            // Set before on_error: the callback chain may drop the last Arc
+            // strong ref, and `Drop` would then run synchronously
+            // mid-on_error.
             s.started = true;
             if let Err(e) = self.__start() {
                 self.on_error(&e);
@@ -502,7 +487,7 @@ impl IOWriter {
             }
             #[cfg(not(windows))]
             {
-                // PORT NOTE: `__start()` re-derives `state()` (and may mutate
+                // NOTE: `__start()` re-derives `state()` (and may mutate
                 // `writer.handle` on the EINVAL/EPERM fallback paths), which
                 // invalidates the `s` borrow under Stacked Borrows. Re-derive.
                 let s = self.state();
@@ -536,7 +521,7 @@ impl IOWriter {
         {
             debug_assert!(matches!(s.writer.handle, bun_io::pipes::PollOrFd::Poll(_)));
             if let Some(poll) = s.writer.get_poll() {
-                // Spec: `poll.isWatching()` — `is_registered() && !needs_rearm`.
+                // `is_watching()` = `is_registered() && !needs_rearm`.
                 // NOT `is_registered()`: after a one-shot fire that drains
                 // everything (no `register_poll()`), `PollWritable` stays set
                 // but `NeedsRearm` is set → `is_registered()` would return
@@ -556,7 +541,6 @@ impl IOWriter {
     // ── queue management ────────────────────────────────────────────────
 
     /// Cancel the chunks enqueued by the given child by marking them as dead.
-    /// Spec: IOWriter.zig `cancelChunks`.
     pub fn cancel_chunks(&self, ptr: ChildPtr) {
         let s = self.state();
         if s.writers.is_empty() {
@@ -575,7 +559,6 @@ impl IOWriter {
 
     /// Skips over dead children and increments `total_bytes_written` by the
     /// amount they would have written so the buf is skipped as well.
-    /// Spec: IOWriter.zig `skipDead`.
     fn skip_dead(&self) {
         let s = self.state();
         while s.writer_idx < s.writers.len() {
@@ -594,7 +577,7 @@ impl IOWriter {
         s.total_bytes_written >= s.buf.len()
     }
 
-    /// Only does things on windows. Spec: IOWriter.zig `setWriting`.
+    /// Only does things on windows.
     #[inline]
     fn set_writing(&self, writing: bool) {
         #[cfg(windows)]
@@ -607,7 +590,7 @@ impl IOWriter {
     // ── buffer slicing ──────────────────────────────────────────────────
 
     /// Returns the buffer of data that needs to be written for the *current*
-    /// writer. Spec: IOWriter.zig `getBuffer`.
+    /// writer.
     fn get_buffer(&self) -> &[u8] {
         let result = self.get_buffer_impl();
         #[cfg(windows)]
@@ -624,7 +607,7 @@ impl IOWriter {
     }
 
     fn get_buffer_impl(&self) -> &[u8] {
-        // PORT NOTE: reshaped for borrowck — re-derive `state()` after
+        // NOTE: reshaped for borrowck — re-derive `state()` after
         // `skip_dead()` instead of holding one `&mut State` across it.
         {
             let s = self.state();
@@ -656,9 +639,8 @@ impl IOWriter {
 
     /// Advance past `current_writer`, shrinking `buf` if appropriate, and
     /// return the `Yield` for the child's `on_io_writer_chunk` callback.
-    /// Spec: IOWriter.zig `bump`.
     fn bump(&self, current_idx: usize) -> Yield {
-        // PORT NOTE: reshaped for borrowck — `skip_dead()` re-derives `state()`,
+        // NOTE: reshaped for borrowck — `skip_dead()` re-derives `state()`,
         // so we must drop `s` before calling it and re-derive after, otherwise
         // two `&mut State` are live simultaneously (UB under Stacked Borrows).
         let (is_dead, written, child_ptr) = {
@@ -684,8 +666,7 @@ impl IOWriter {
         } else if s.total_bytes_written >= SHRINK_THRESHOLD {
             s.buf.drain_front(s.total_bytes_written);
             s.total_bytes_written = 0;
-            // Spec: `this.writers.truncate(this.writer_idx)` — drops the
-            // *prefix* (Zig SmolList.truncate shifts down). Vec::drain(..idx).
+            // Drop the *prefix* of the writers queue: Vec::drain(..idx).
             s.writers.drain(..s.writer_idx);
             s.writer_idx = 0;
             if cfg!(debug_assertions) && !s.writers.is_empty() {
@@ -705,7 +686,7 @@ impl IOWriter {
 
     // ── file write (non-pollable sync path) ─────────────────────────────
 
-    /// Spec: IOWriter.zig `doFileWrite`. POSIX-only.
+    /// POSIX-only.
     #[cfg(not(windows))]
     fn do_file_write(&self) -> Yield {
         // `drain_buffered_data`/`on_error` below re-enter the interpreter and
@@ -728,7 +709,7 @@ impl IOWriter {
         debug_assert!(!buf.is_empty());
 
         let result = drain_buffered_data(self, buf, u32::MAX as usize);
-        // PORT NOTE: re-derive `state()` after `drain_buffered_data` (which may
+        // NOTE: re-derive `state()` after `drain_buffered_data` (which may
         // have called `on_error`) instead of holding a stale `&mut`.
         let amt = match result {
             bun_io::WriteResult::Done(amt) => amt,
@@ -768,10 +749,10 @@ impl IOWriter {
 
     // ── poll callback ───────────────────────────────────────────────────
 
-    /// Spec: IOWriter.zig `onWritePollable` (the `BufferedWriter.onWrite`
-    /// hook). Runs on the event loop when the fd is writable.
+    /// The `BufferedWriter.onWrite` hook. Runs on the event loop when the fd
+    /// is writable.
     fn on_write_pollable(&self, amount: usize, status: bun_io::WriteStatus) {
-        // PORT NOTE: `set_writing` re-derives `state()` on Windows, which would
+        // NOTE: `set_writing` re-derives `state()` on Windows, which would
         // invalidate `s` under Stacked Borrows; do it before binding `s`
         // (matches the ordering in `on_error`).
         self.set_writing(false);
@@ -791,7 +772,7 @@ impl IOWriter {
             s.total_bytes_written += amount;
             s.writers[idx].written += amount;
             if status == bun_io::WriteStatus::EndOfFile {
-                // PORT NOTE: inline `is_last_idx` instead of calling
+                // NOTE: inline `is_last_idx` instead of calling
                 // `self.is_last_idx(idx)` — that re-derives `state()` while `s`
                 // is still live, which is two simultaneous `&mut State` (UB).
                 let last = idx == s.writers.len().saturating_sub(1);
@@ -803,9 +784,9 @@ impl IOWriter {
                 if !not_fully_written {
                     return;
                 }
-                // Other end of the socket/pipe closed and we got EPIPE.
-                // (See the long comment in IOWriter.zig for the `ls | echo`
-                // example.) Quick hack: have all writers see an error.
+                // Other end of the socket/pipe closed and we got EPIPE
+                // (e.g. `ls | echo`). Quick hack: have all writers see an
+                // error.
                 s.flags.broken_pipe = true;
                 self.broken_pipe_for_writers();
                 return;
@@ -820,7 +801,7 @@ impl IOWriter {
         if !wrote_everything && s.writer_idx < s.writers.len() {
             #[cfg(windows)]
             {
-                // PORT NOTE: inline `set_writing(true)` instead of calling the
+                // NOTE: inline `set_writing(true)` instead of calling the
                 // helper — the helper re-derives `state()` while `s` is live,
                 // which is two simultaneous `&mut State` (UB under Stacked
                 // Borrows). Same discipline as the top of this fn.
@@ -835,11 +816,10 @@ impl IOWriter {
         }
     }
 
-    /// Spec: IOWriter.zig `brokenPipeForWriters`.
     fn broken_pipe_for_writers(&self) {
         let s = self.state();
         debug_assert!(s.flags.broken_pipe);
-        // PORT NOTE: reshaped for borrowck — collect targets first so we don't
+        // NOTE: reshaped for borrowck — collect targets first so we don't
         // hold `&mut s.writers` across `cancel_chunks`/`run_yield`.
         let mut targets: Vec<ChildPtr> = Vec::new();
         for w in &s.writers[s.writer_idx..] {
@@ -866,7 +846,6 @@ impl IOWriter {
         s.writer_idx = 0;
     }
 
-    /// Spec: IOWriter.zig `onError`.
     fn on_error(&self, err: &sys::Error) {
         let _keepalive = self.keepalive();
         self.set_writing(false);
@@ -879,7 +858,7 @@ impl IOWriter {
         // may have been freed; only notify the still-pending ones, dedup'd.
         let mut seen: Vec<ChildPtr> = Vec::with_capacity(64);
         let start = s.writer_idx;
-        // PORT NOTE: reshaped for borrowck — copy out the child ptrs first.
+        // NOTE: reshaped for borrowck — copy out the child ptrs first.
         let pending: Vec<ChildPtr> = s.writers[start..]
             .iter()
             .filter(|w| !w.is_dead())
@@ -890,10 +869,9 @@ impl IOWriter {
                 continue;
             }
             seen.push(ptr);
-            // Spec: `if (this.err) |*e| e.ref();` — `SystemError` in the Rust
-            // port owns `bun_core::String`s by value (no shared refcount yet),
-            // so re-derive a fresh one per callee instead of cloning the stored
-            // error.
+            // `SystemError` owns `bun_core::String`s by value (no shared
+            // refcount yet), so re-derive a fresh one per callee instead of
+            // cloning the stored error.
             let ee = err.to_shell_system_error();
             self.run_yield(Yield::OnIoWriterChunk {
                 child: ptr,
@@ -931,7 +909,6 @@ impl IOWriter {
 
     // ── enqueue ─────────────────────────────────────────────────────────
 
-    /// Spec: IOWriter.zig `handleBrokenPipe`.
     fn handle_broken_pipe(&self, ptr: ChildPtr) -> Option<Yield> {
         if self.state().flags.broken_pipe {
             let err = sys::Error::from_code(E::EPIPE, sys::Tag::write).to_system_error();
@@ -944,7 +921,6 @@ impl IOWriter {
         None
     }
 
-    /// Spec: IOWriter.zig `enqueueFile`.
     #[cfg(not(windows))]
     fn enqueue_file(&self) -> Yield {
         let s = self.state();
@@ -959,7 +935,6 @@ impl IOWriter {
     }
 
     /// You MUST have already added the data to `self.buf`!
-    /// Spec: IOWriter.zig `enqueueInternal`.
     fn enqueue_internal(&self) -> Yield {
         debug_assert!(!self.state().flags.broken_pipe);
         #[cfg(not(windows))]
@@ -970,13 +945,12 @@ impl IOWriter {
             WriteOutcome::Suspended => Yield::suspended(),
             #[cfg(not(windows))]
             WriteOutcome::IsActuallyFile => self.enqueue_file(),
-            // FIXME (matches Zig)
             WriteOutcome::Failed => Yield::failed(),
         }
     }
 
     /// Queue `buf` for writing; when the chunk completes (or errors),
-    /// `child`'s `on_io_writer_chunk` fires. Spec: IOWriter.zig `enqueue`.
+    /// `child`'s `on_io_writer_chunk` fires.
     pub fn enqueue(&self, child: ChildPtr, bytelist: Option<*mut Vec<u8>>, buf: &[u8]) -> Yield {
         if let Some(y) = self.handle_broken_pipe(child) {
             return y;
@@ -999,7 +973,7 @@ impl IOWriter {
         self.enqueue_internal()
     }
 
-    /// Spec: IOWriter.zig `enqueueFmtBltn` — prefix `"{kind}: "` then format.
+    /// Prefix `"{kind}: "` then format.
     pub fn enqueue_fmt_bltn(
         &self,
         child: ChildPtr,
@@ -1014,10 +988,9 @@ impl IOWriter {
             let _ = write!(&mut s.buf, "{}: ", k.as_str());
         }
         let _ = s.buf.write_fmt(args);
-        // Spec: Zig writes into `buf` *before* checking broken_pipe in
-        // `enqueueFmt`; mirror that ordering (the bytes are dead but the
-        // buffer will be cleared on the error path anyway).
-        // PORT NOTE: inline `handle_broken_pipe` instead of calling the helper —
+        // `buf` is written *before* checking broken_pipe (the bytes are dead
+        // on the error path but the buffer will be cleared there anyway).
+        // NOTE: inline `handle_broken_pipe` instead of calling the helper —
         // the helper re-derives `state()` while `s` is still live, which is two
         // simultaneous `&mut State` (UB under Stacked Borrows).
         if s.flags.broken_pipe {
@@ -1038,7 +1011,8 @@ impl IOWriter {
         self.enqueue_internal()
     }
 
-    /// Spec: IOWriter.zig `enqueueFmt`.
+    /// Format `args` into the write buffer and enqueue the resulting chunk
+    /// for `child` (no builtin-name prefix).
     pub fn enqueue_fmt(
         &self,
         child: ChildPtr,
@@ -1085,7 +1059,6 @@ bun_io::impl_buffered_writer_parent! {
 // drainBufferedData / tryWrite (POSIX file path)
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Spec: IOWriter.zig `tryWriteWithWriteFn`.
 #[cfg(not(windows))]
 fn try_write_with_write_fn(
     fd: Fd,
@@ -1113,7 +1086,6 @@ fn try_write_with_write_fn(
     bun_io::WriteResult::Wrote(offset)
 }
 
-/// Spec: IOWriter.zig `drainBufferedData`.
 /// TODO: This function and `try_write_with_write_fn` are copy-pastes from
 /// PipeWriter; it would be nice to not have to do that.
 #[cfg(not(windows))]
@@ -1154,16 +1126,14 @@ fn drain_buffered_data(
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Drop (replaces Zig RefCount.deref → asyncDeinit → deinitOnMainThread)
+// Drop
 // ──────────────────────────────────────────────────────────────────────────
 
 impl Drop for IOWriter {
     fn drop(&mut self) {
-        // Spec: IOWriter.zig `deinitOnMainThread`. The Zig version hopped to
-        // the next tick when `started` to avoid PipeWriter touching us after
-        // free; with `Arc` the last ref drops *after* the callback returns, so
-        // the synchronous path is safe.
-        // TODO(port): if a PipeWriter callback is on the stack when the last
+        // With `Arc` the last ref drops *after* the callback returns, so the
+        // synchronous path is safe (PipeWriter cannot touch us after free).
+        // TODO: if a PipeWriter callback is on the stack when the last
         // Arc drops (possible via re-entrant child deinit), we need the async
         // hop. Revisit once `bun_event_loop::EventLoopTask` is wired to the
         // shell's `EventLoopHandle` shim.
@@ -1216,13 +1186,12 @@ pub(crate) fn on_io_writer_chunk(
         WriterTag::CondExpr => {
             cond_expr::CondExpr::on_io_writer_chunk(interp, child.node, written, err)
         }
-        // `Interpreter.If` is not in the spec's `ChildPtrRaw` union (IOWriter.zig
-        // :765-793) — it never enqueues to an IOWriter.
+        // `Interpreter.If` never enqueues to an IOWriter.
         WriterTag::If => {
             crate::shell::interpreter::unreachable_state("IOWriter.onIOWriterChunk", "If")
         }
-        // Spec dispatches to `subproc.PipeReader.CapturedWriter`; that lives
-        // outside the NodeId arena (heap-allocated PipeReader), so the target
+        // The target is the subprocess PipeReader's `CapturedWriter`; it
+        // lives outside the NodeId arena (heap-allocated PipeReader), so it
         // is carried in `child.raw` instead of `child.node`.
         WriterTag::Subproc => {
             let _ = interp;
@@ -1237,5 +1206,3 @@ pub(crate) fn on_io_writer_chunk(
         }
     }
 }
-
-// ported from: src/shell/IOWriter.zig
diff --git a/src/runtime/shell/ParsedShellScript.rs b/src/runtime/shell/ParsedShellScript.rs
index 9723e16baca..388bb4e9e74 100644
--- a/src/runtime/shell/ParsedShellScript.rs
+++ b/src/runtime/shell/ParsedShellScript.rs
@@ -21,9 +21,7 @@ use super::{EnvMap, EnvStr, Interpreter};
 #[bun_jsc::JsClass(no_constructor)]
 pub struct ParsedShellScript {
     pub args: JsCell<Option<Box<ShellArgs>>>,
-    /// allocated with arena in jsobjs
-    // PORT NOTE: in Zig this Vec's backing storage lives in `args.arena` (self-referential
-    // with the `args` field). Uses a global-alloc Vec here; revisit if profiling shows
+    // Uses a global-alloc Vec; revisit if profiling shows
     // the extra alloc matters. JSValues here are GC-rooted via `toJSWithValues` codegen
     // (own: array on the C++ wrapper), so storing them on the Rust heap is sound.
     pub jsobjs: JsCell<Vec<JSValue>>,
@@ -76,8 +74,7 @@ impl ParsedShellScript {
         self.estimated_size_for_gc
     }
 
-    // PORT NOTE: reshaped from 5 out-params to a returned tuple; Zig used out-params
-    // because the caller pre-declares slots. Rust callers destructure the tuple.
+    // Returns a tuple; callers destructure it.
     pub fn take(
         &self,
         _global: &JSGlobalObject,
@@ -170,12 +167,12 @@ impl ParsedShellScript {
             let keyslice = key.to_owned_slice();
             // errdefer free(keyslice) — Drop on early-return handles this.
             let value_str = value.get_zig_string(global)?;
-            // `ZigString::to_owned_slice` is infallible in the Rust port (global alloc
-            // aborts on OOM); Zig wrapped in `bun.handleOom`.
+            // `ZigString::to_owned_slice` is infallible (global alloc aborts
+            // on OOM).
             let slice = value_str.to_owned_slice();
-            let keyref = EnvStr::init_ref_counted(&keyslice);
+            let keyref = EnvStr::init_ref_counted(keyslice.into_boxed_slice());
             // defer keyref.deref() — done below (insert refs again).
-            let valueref = EnvStr::init_ref_counted(&slice);
+            let valueref = EnvStr::init_ref_counted(slice.into_boxed_slice());
             // defer valueref.deref() — done below.
 
             env.insert(keyref, valueref);
@@ -221,9 +218,8 @@ fn create_parsed_shell_script_impl(
     callframe: &CallFrame,
     marked_argument_buffer: &mut MarkedArgumentBuffer,
 ) -> JsResult<JSValue> {
-    // Zig: `defer if (needs_to_free_shargs) shargs.deinit()` — semantically `errdefer` on an
-    // owned local. Box<ShellArgs> drops automatically on every early `return`/`?` below, so
-    // no scopeguard is needed (PORTING.md: errdefer-on-owned-local → delete).
+    // Box<ShellArgs> drops automatically on every early `return`/`?` below,
+    // so no scopeguard is needed.
     let mut shargs: Box<ShellArgs> = ShellArgs::init();
 
     let arguments_ = callframe.arguments_old::<2>();
@@ -235,14 +231,13 @@ fn create_parsed_shell_script_impl(
     let template_args_js = arguments[1];
     let mut template_args = template_args_js.array_iterator(global)?;
 
-    // PERF(port): was std.heap.stackFallback(@sizeOf(bun.String) * 4, arena) — profile if hot.
-    // Zig: `defer { for jsstrings |s| s.deref(); jsstrings.deinit() }` — handled by
-    // `JsStrings`'s `Drop` (per-element `bun.String::deref()` then Vec free).
+    // PERF: a stack-fallback allocation may be worth it — profile if hot.
+    // Cleanup is handled by `JsStrings`'s `Drop` (per-element
+    // `bun.String::deref()` then Vec free).
     let mut jsstrings = JsStrings::with_capacity(4);
 
-    // PORT NOTE: in Zig `jsobjs` and `script` are allocated from `shargs.arena_allocator()`.
-    // Shell is an AST crate (arena-backed); uses global Vec here to sidestep the
-    // self-referential borrow against `shargs` (it later moves into `ParsedShellScript`).
+    // Uses global Vecs here to sidestep a self-referential borrow against
+    // `shargs`'s arena (it later moves into `ParsedShellScript`).
     let mut jsobjs: Vec<JSValue> = Vec::new();
     let mut script: Vec<u8> = Vec::new();
     shell_cmd_from_js(
@@ -255,7 +250,7 @@ fn create_parsed_shell_script_impl(
         marked_argument_buffer,
     )?;
 
-    // PORT NOTE: reshaped for borrowck — `out_parser`/`out_lex_result` borrow
+    // Reshaped for borrowck — `out_parser`/`out_lex_result` borrow
     // `shargs.__arena`, so they're scoped to a block that ends before
     // `shargs.script_ast = script` below. The arena reference is taken via raw
     // pointer so the `&shargs` borrow doesn't outlive the call (the returned
@@ -319,5 +314,3 @@ fn create_parsed_shell_script_impl(
     bun_analytics::features::shell.fetch_add(1, Ordering::Relaxed);
     Ok(this_jsvalue)
 }
-
-// ported from: src/shell/ParsedShellScript.zig
diff --git a/src/runtime/shell/RefCountedStr.rs b/src/runtime/shell/RefCountedStr.rs
index f48f3986f7f..80101468474 100644
--- a/src/runtime/shell/RefCountedStr.rs
+++ b/src/runtime/shell/RefCountedStr.rs
@@ -4,15 +4,12 @@ bun_core::declare_scope!(RefCountedEnvStr, hidden);
 
 pub struct RefCountedStr {
     pub(super) refcount: Cell<u32>,
-    // PORT NOTE: Zig stored `[*]const u8` + `u32` len; Rust holds the owning
-    // `Box<[u8]>` directly so `byte_slice`/`free_str` need no raw-parts rebuild.
+    // Owning `Box<[u8]>`, so `byte_slice`/`free_str` need no raw-parts rebuild.
     data: Box<[u8]>,
 }
 
 impl RefCountedStr {
-    // PORT NOTE: Zig `init` takes a `[]const u8` whose backing storage was allocated
-    // with `bun.default_allocator` and transfers ownership of it. In Rust we accept a
-    // `Box<[u8]>` (global mimalloc) and store it directly.
+    // Takes ownership of `slice` (global mimalloc) and stores it directly.
     pub fn init(slice: Box<[u8]>) -> *mut RefCountedStr {
         bun_core::scoped_log!(RefCountedEnvStr, "init: {}", bstr::BStr::new(&*slice));
         // bun.handleOom(bun.default_allocator.create(...)) → Box::new (aborts on OOM)
@@ -30,7 +27,7 @@ impl RefCountedStr {
         self.refcount.set(self.refcount.get() + 1);
     }
 
-    // PORT NOTE: takes `*mut Self` because reaching refcount==0 deallocates the
+    // Takes `*mut Self` because reaching refcount==0 deallocates the
     // `Box<Self>` that backs `this`; a `&self` borrow would dangle across that drop.
     pub unsafe fn deref(this: *mut RefCountedStr) {
         // SAFETY: caller guarantees `this` was produced by `init` and is still
@@ -44,7 +41,7 @@ impl RefCountedStr {
         }
     }
 
-    // PORT NOTE: not `impl Drop` — this is the intrusive-rc self-destroy path
+    // Not `impl Drop` — this is the intrusive-rc self-destroy path
     // (`bun.default_allocator.destroy(this)`), which must deallocate the Box backing `self`.
     unsafe fn deinit(this: *mut RefCountedStr) {
         // SAFETY: refcount just reached 0; `this` is uniquely owned and was Box-allocated in `init`.
@@ -74,5 +71,3 @@ impl Default for RefCountedStr {
         }
     }
 }
-
-// ported from: src/shell/RefCountedStr.zig
diff --git a/src/runtime/shell/Yield.rs b/src/runtime/shell/Yield.rs
index 7ce794baf87..c011e1e9240 100644
--- a/src/runtime/shell/Yield.rs
+++ b/src/runtime/shell/Yield.rs
@@ -32,7 +32,9 @@ pub enum Yield {
     OnIoWriterChunk {
         child: crate::shell::io_writer::ChildPtr,
         written: usize,
-        // TODO(port): bun_jsc::SystemError — opaque until jsc compiles.
+        // `bun_sys::SystemError`, consistent with the rest of the shell
+        // subsystem (IOWriter/IOReader/Builtin); converted to a JS error at
+        // the throw boundary.
         err: Option<bun_sys::SystemError>,
     },
     /// Execution is waiting on async IO (epoll/kqueue/uv). The caller's task
@@ -63,7 +65,7 @@ impl Yield {
 }
 
 thread_local! {
-    /// Debug-only re-entrancy guard. See Zig `_dbg_catch_exec_within_exec`.
+    /// Debug-only re-entrancy guard.
     static DBG_CATCH_EXEC_WITHIN_EXEC: Cell<usize> = const { Cell::new(0) };
 }
 
@@ -108,12 +110,11 @@ impl Yield {
         // We start cmd1, return to the pipeline, start cmd2, etc. — so we keep
         // a small stack of pipeline NodeIds to resume.
         //
-        // PERF(port): was stack-fallback alloc (4 inline) — profile if hot;
-        // smallvec::SmallVec<[NodeId; 4]> is the right shape.
+        // PERF: profile if hot; smallvec::SmallVec<[NodeId; 4]> would avoid
+        // the heap allocation.
         let mut pipeline_stack: Vec<NodeId> = Vec::with_capacity(4);
 
-        // Zig used a labelled `state: switch` as a tail-call trampoline. Rust
-        // lowers it to `loop { state = match state { ... } }`.
+        // Tail-call trampoline: `loop { state = match state { ... } }`.
         let mut state = self;
         loop {
             state = match state {
@@ -162,5 +163,3 @@ impl Yield {
         None
     }
 }
-
-// ported from: src/shell/Yield.zig
diff --git a/src/runtime/shell/builtin/basename.rs b/src/runtime/shell/builtin/basename.rs
index 68d14b9090a..221c95717cd 100644
--- a/src/runtime/shell/builtin/basename.rs
+++ b/src/runtime/shell/builtin/basename.rs
@@ -69,5 +69,3 @@ impl Basename {
         }
     }
 }
-
-// ported from: src/shell/builtin/basename.zig
diff --git a/src/runtime/shell/builtin/cat.rs b/src/runtime/shell/builtin/cat.rs
index 043617f67aa..7c3d26b952a 100644
--- a/src/runtime/shell/builtin/cat.rs
+++ b/src/runtime/shell/builtin/cat.rs
@@ -19,21 +19,18 @@ pub struct Cat {
 pub enum CatState {
     #[default]
     Idle,
-    /// Spec cat.zig `.exec_stdin`.
     ExecStdin {
         in_done: bool,
         chunks_queued: usize,
         chunks_done: usize,
         errno: ExitCode,
     },
-    /// Spec cat.zig `.exec_filepath_args`.
     ExecFilepathArgs {
         /// Index into argv where filepath args start.
         args_start: usize,
         /// Current index into the filepath args.
         idx: usize,
-        /// Per-file reader (Spec: `reader: ?*IOReader`). Dropping the `Arc`
-        /// IS the Zig `r.deref()`.
+        /// Per-file reader.
         reader: Option<Arc<IOReader>>,
         chunks_queued: usize,
         chunks_done: usize,
@@ -93,7 +90,6 @@ impl Cat {
         Self::next(interp, cmd)
     }
 
-    /// Spec: cat.zig `writeFailingError`.
     fn write_failing_error(
         interp: &Interpreter,
         cmd: NodeId,
@@ -111,9 +107,8 @@ impl Cat {
         Builtin::done(interp, cmd, exit_code)
     }
 
-    /// Spec: cat.zig `next`.
     pub fn next(interp: &Interpreter, cmd: NodeId) -> Yield {
-        // PORT NOTE: reshaped for borrowck — read scalars, drop borrow, act.
+        // Read scalars, drop the borrow, then act.
         enum Branch {
             Stdin,
             FileArg { args_start: usize, idx: usize },
@@ -143,9 +138,8 @@ impl Cat {
                     {
                         *in_done = true;
                     }
-                    // PORT NOTE: reshaped for borrowck — copy stdin bytes so
-                    // the &mut on `stdout`/`write_no_io` doesn't overlap a
-                    // borrow of `stdin`.
+                    // Copy stdin bytes so the &mut on `stdout`/`write_no_io`
+                    // doesn't overlap a borrow of `stdin`.
                     let buf = Builtin::read_stdin_no_io(interp, cmd).to_vec();
                     if let Some(safeguard) = Builtin::of(interp, cmd).stdout.needs_io() {
                         let child = ChildPtr::new(cmd, WriterTag::Builtin);
@@ -156,8 +150,7 @@ impl Cat {
                     let _ = Builtin::write_no_io(interp, cmd, IoKind::Stdout, &buf);
                     return Builtin::done(interp, cmd, 0);
                 }
-                // Spec: `this.bltn().stdin.fd.addReader(this); return ...start()`.
-                // PORT NOTE: reshaped for borrowck — clone the `Arc<IOReader>`
+                // Clone the `Arc<IOReader>`
                 // out of `stdin` so we hold no borrow of `interp` across
                 // `start()` (which may re-enter via the raw interp backref).
                 let interp_ptr: *mut Interpreter = interp.as_ctx_ptr();
@@ -176,7 +169,7 @@ impl Cat {
                 let argc = Builtin::of(interp, cmd).args_slice().len();
                 let n_files = argc - args_start;
                 if idx >= n_files {
-                    // Spec: `exec.deinit()` — drop the reader if any.
+                    // Drop the reader if any.
                     if let CatState::ExecFilepathArgs { reader, .. } =
                         &mut Self::state_mut(interp, cmd).state
                     {
@@ -184,7 +177,6 @@ impl Cat {
                     }
                     return Builtin::done(interp, cmd, 0);
                 }
-                // Spec: `if (exec.reader) |r| { r.deref(); exec.reader = null }`.
                 if let CatState::ExecFilepathArgs { reader, .. } =
                     &mut Self::state_mut(interp, cmd).state
                 {
@@ -205,8 +197,7 @@ impl Cat {
                     Err(e) => {
                         let buf =
                             Builtin::task_error_to_string(interp, cmd, Kind::Cat, &e).to_vec();
-                        // Spec: `defer exec.deinit()` — reader was already
-                        // taken to `None` above.
+                        // The reader was already taken to `None` above.
                         return Self::write_failing_error(interp, cmd, &buf, 1);
                     }
                 };
@@ -241,7 +232,6 @@ impl Cat {
         }
     }
 
-    /// Spec: cat.zig `onIOWriterChunk`.
     pub fn on_io_writer_chunk(
         interp: &Interpreter,
         cmd: NodeId,
@@ -249,7 +239,6 @@ impl Cat {
         err: Option<bun_sys::SystemError>,
     ) -> Yield {
         if let Some(e) = err {
-            // Spec: `defer e.deref(); @intCast(@intFromEnum(e.getErrno()))`.
             let errno = e.get_errno() as ExitCode;
             e.deref();
             let rchild = ReaderChildPtr {
@@ -257,8 +246,8 @@ impl Cat {
                 tag: ReaderTag::Cat,
             };
             // Writing to stdout errored: cancel everything and finish.
-            // PORT NOTE: reshaped for borrowck — pull the reader `Arc` out of
-            // state before calling `remove_reader`, then drop it (= Zig deref).
+            // Pull the reader `Arc` out of
+            // state before calling `remove_reader`, then drop it.
             match &mut Self::state_mut(interp, cmd).state {
                 CatState::ExecStdin {
                     in_done,
@@ -268,14 +257,12 @@ impl Cat {
                     *st_errno = errno;
                     let was_done = core::mem::replace(in_done, true);
                     if !was_done {
-                        // Spec: `if (stdin.needsIO()) stdin.fd.removeReader(this)`.
                         if let BuiltinInput::Fd(r) = &Builtin::of(interp, cmd).stdin {
                             r.remove_reader(rchild);
                         }
                     }
                 }
                 CatState::ExecFilepathArgs { reader, .. } => {
-                    // Spec: `r.removeReader(this); exec.deinit()`.
                     if let Some(r) = reader.take() {
                         r.remove_reader(rchild);
                     }
@@ -327,7 +314,6 @@ impl Cat {
         }
     }
 
-    /// Spec: cat.zig `onIOReaderChunk`.
     pub fn on_io_reader_chunk(
         interp: &Interpreter,
         cmd: NodeId,
@@ -353,7 +339,6 @@ impl Cat {
         Yield::done()
     }
 
-    /// Spec: cat.zig `onIOReaderDone`.
     pub fn on_io_reader_done(
         interp: &Interpreter,
         cmd: NodeId,
@@ -361,7 +346,6 @@ impl Cat {
     ) -> Yield {
         let errno: ExitCode = err
             .map(|e| {
-                // Spec: `defer e.deref(); @intCast(@intFromEnum(e.getErrno()))`.
                 let n = e.get_errno() as ExitCode;
                 e.deref();
                 n
@@ -402,7 +386,7 @@ impl Cat {
                 *in_done = true;
                 if errno != 0 {
                     if *out_done || !stdout_needs_io {
-                        // Spec: `exec.deinit()` — drop the reader ref.
+                        // Drop the reader ref.
                         *reader = None;
                         Step::Done(errno)
                     } else {
@@ -418,7 +402,6 @@ impl Cat {
             CatState::Done | CatState::WaitingWriteErr | CatState::Idle => Step::Suspend,
         };
         if cancel {
-            // Spec: `this.bltn().stdout.fd.writer.cancelChunks(this)`.
             let wchild = ChildPtr::new(cmd, WriterTag::Builtin);
             if let BuiltinIO::Fd(fd) = &Builtin::of(interp, cmd).stdout {
                 fd.writer.cancel_chunks(wchild);
@@ -470,5 +453,3 @@ impl FlagParser for Opts {
         }
     }
 }
-
-// ported from: src/shell/builtin/cat.zig
diff --git a/src/runtime/shell/builtin/cd.rs b/src/runtime/shell/builtin/cd.rs
index 40e2017952d..daed43368ec 100644
--- a/src/runtime/shell/builtin/cd.rs
+++ b/src/runtime/shell/builtin/cd.rs
@@ -112,5 +112,3 @@ impl Cd {
         Builtin::done(interp, cmd, 1)
     }
 }
-
-// ported from: src/shell/builtin/cd.zig
diff --git a/src/runtime/shell/builtin/cp.rs b/src/runtime/shell/builtin/cp.rs
index 631b855248f..854e2bb415f 100644
--- a/src/runtime/shell/builtin/cp.rs
+++ b/src/runtime/shell/builtin/cp.rs
@@ -49,16 +49,14 @@ pub struct ExecState {
 
 /// On Windows it is possible to get an EBUSY error very simply by running
 /// `cp myfile.txt myfile.txt mydir/` — two tasks race for the same dest. Bun
-/// ignores the EBUSY if at least one task succeeded for that dest. Spec:
-/// cp.zig `EbusyState`.
+/// ignores the EBUSY if at least one task succeeded for that dest.
 #[derive(Default)]
 pub struct EbusyState {
     pub tasks: Vec<*mut ShellCpTask>,
     pub idx: usize,
     pub main_exit_code: ExitCode,
     /// Absolute target paths that some task copied successfully — used to
-    /// suppress a sibling task's EBUSY on the same target. Spec: cp.zig
-    /// `EbusyState.absolute_targets` (`StringArrayHashMapUnmanaged(void)`).
+    /// suppress a sibling task's EBUSY on the same target.
     pub absolute_targets: bun_collections::StringSet,
     pub absolute_srcs: bun_collections::StringSet,
 }
@@ -122,7 +120,7 @@ impl Cp {
                         let act = if !exec.ebusy.tasks.is_empty() {
                             Action::Ebusy(exit_code)
                         } else {
-                            // Spec: `exec.ebusy.deinit()` — Drop handles it.
+                            // `Drop` frees the ebusy state here.
                             Action::Done(exit_code)
                         };
                         #[cfg(not(windows))]
@@ -212,16 +210,15 @@ impl Cp {
         Self::next(interp, cmd)
     }
 
-    /// Spec: cp.zig `ignoreEbusyErrorIfPossible`. Windows-only post-processing
-    /// of tasks that failed with EBUSY: if some other task already succeeded
+    /// Windows-only post-processing of tasks that failed with EBUSY: if some
+    /// other task already succeeded
     /// for the same absolute src/tgt, the EBUSY is benign and the task is
     /// dropped; otherwise its error is surfaced via `print_shell_cp_task`.
     #[cfg(windows)]
     fn ignore_ebusy_error_if_possible(interp: &Interpreter, cmd: NodeId) -> Yield {
         loop {
-            // PORT NOTE: reshaped for borrowck — pop tasks one at a time
-            // (Zig iterated `tasks.items[idx..]` and bumped `idx` on the
-            // first non-ignorable hit so a re-entry resumes there).
+            // Pop tasks one at a time; `idx` is bumped on the first
+            // non-ignorable hit so a re-entry resumes there.
             let next = {
                 let State::Ebusy(eb) = &mut Self::state_mut(interp, cmd).state else {
                     unreachable!()
@@ -258,12 +255,11 @@ impl Cp {
             unreachable!()
         };
         let exit_code = eb.main_exit_code;
-        // Spec: `state.ebusy.state.deinit()` — Drop handles the sets/vec.
+        // `Drop` frees the ebusy sets/vec here.
         Self::state_mut(interp, cmd).state = State::Done;
         Builtin::done(interp, cmd, exit_code)
     }
 
-    /// Spec: cp.zig `onShellCpTaskDone`.
     pub(crate) fn on_shell_cp_task_done(interp: &Interpreter, cmd: NodeId, task: *mut ShellCpTask) {
         if let State::Exec(exec) = &mut Self::state_mut(interp, cmd).state {
             exec.tasks_count -= 1;
@@ -274,15 +270,11 @@ impl Cp {
             let tref = unsafe { &mut *task };
             if let State::Exec(exec) = &mut Self::state_mut(interp, cmd).state {
                 if let Some(err) = &tref.err {
-                    // Spec: cp.zig — defer the task to the ebusy phase.
-                    // PORT NOTE: cp.zig L215-221 reads
-                    //   `err.* == .sys and err.sys.getErrno() == .BUSY and (tgt_match) or (src_match)`
-                    // Zig `and` binds tighter than `or`, so this parses as
-                    //   `(is_sys && errno==BUSY && tgt_match) || src_match`
+                    // Defer the task to the ebusy phase. Note the precedence:
+                    //   `(is_sys && errno==EBUSY && tgt_match) || src_match`
                     // i.e. ANY sys error whose `path` equals `src_absolute` is
-                    // deferred regardless of errno. We mirror that precedence
-                    // exactly here for spec parity (even though it is almost
-                    // certainly a latent precedence bug upstream).
+                    // deferred regardless of errno; preserved deliberately for
+                    // compatibility.
                     let is_ebusy = matches!(err, ShellErr::Sys(sys)
                         if (sys.get_errno() == bun_sys::E::EBUSY
                                 && tref.tgt_absolute.as_deref()
@@ -308,12 +300,11 @@ impl Cp {
         Self::print_shell_cp_task(interp, cmd, task).run(interp);
     }
 
-    /// Spec: cp.zig `printShellCpTask`.
     fn print_shell_cp_task(interp: &Interpreter, cmd: NodeId, task: *mut ShellCpTask) -> Yield {
         // SAFETY: task was heap-allocated in create(); reclaim.
         let mut task = unsafe { bun_core::heap::take(task) };
-        // Spec: cp.zig `task.takeOutput()`. The lock is uncontended here (all
-        // work-pool subtasks have finished) but the data lives inside it.
+        // The lock is uncontended here (all work-pool subtasks have
+        // finished) but the data lives inside it.
         let output = core::mem::take(&mut *task.verbose_output.lock());
         let output_task = OutputTask::<Cp>::new(cmd, OutputSrc::Arrlist(output));
 
@@ -322,7 +313,7 @@ impl Cp {
             if let State::Exec(exec) = &mut Self::state_mut(interp, cmd).state {
                 exec.err = Some(e);
             }
-            // Spec: else-arm `e.deinit()` — `e` drops here when not stored.
+            // `e` drops here when not stored.
             s
         });
         OutputTask::<Cp>::start(output_task, interp, errstr.as_deref())
@@ -391,7 +382,7 @@ impl OutputTaskVTable for Cp {
     }
 }
 
-/// Spec: cp.zig `ShellCpTask`. Resolves src/tgt to absolute paths, decides
+/// Resolves src/tgt to absolute paths, decides
 /// which POSIX `cp` synopsis applies, then hands off to the node:fs async cp
 /// implementation.
 pub struct ShellCpTask {
@@ -403,11 +394,9 @@ pub struct ShellCpTask {
     pub src_absolute: Option<Vec<u8>>,
     pub tgt_absolute: Option<Vec<u8>>,
     pub cwd_path: Vec<u8>,
-    /// Spec: cp.zig `verbose_output_lock` + `verbose_output`. `cp_on_copy` is
-    /// invoked from work-pool threads (concurrently per copied file) while the
-    /// directory walk is still fanning out, so the buffer must live inside the
-    /// mutex — Zig's split lock-then-mutate pattern would alias `&mut self` in
-    /// Rust.
+    /// `cp_on_copy` is invoked from work-pool threads (concurrently per
+    /// copied file) while the directory walk is still fanning out, so the
+    /// buffer must live inside the mutex.
     pub verbose_output: bun_threading::Guarded<Vec<u8>>,
     pub err: Option<ShellErr>,
     pub task: ShellTask,
@@ -443,12 +432,11 @@ impl ShellCpTask {
         bun_core::heap::into_raw(task)
     }
 
-    /// Spec: cp.zig `onCopyImpl` — appends `"{src} -> {dest}\n"` to the verbose
+    /// Appends `"{src} -> {dest}\n"` to the verbose
     /// buffer (printed to stdout once the cp finishes). Called from work-pool
     /// threads; serialised via `verbose_output`'s mutex.
     fn on_copy_impl(&self, src: &[u8], dest: &[u8]) {
         let mut out = self.verbose_output.lock();
-        // PORT NOTE: Zig used `writer.print("{s} -> {s}\n", .{src, dest})`.
         out.reserve(src.len() + dest.len() + 5);
         out.extend_from_slice(src);
         out.extend_from_slice(b" -> ");
@@ -456,7 +444,7 @@ impl ShellCpTask {
         out.push(b'\n');
     }
 
-    /// Spec: cp.zig `cpOnCopy`. Called from the node:fs `NewAsyncCpTask<true>`
+    /// Called from the node:fs `NewAsyncCpTask<true>`
     /// work-pool thread for every successfully-copied file. Records the pair
     /// for `-v`; on Windows the paths arrive as WTF-16 and are transcoded.
     /// Takes `&self` because subtasks fan out concurrently — the only mutated
@@ -479,7 +467,7 @@ impl ShellCpTask {
         }
     }
 
-    /// Spec: cp.zig `cpOnFinish` → `onSubtaskFinish`. Called when the node:fs
+    /// Called when the node:fs
     /// async cp completes (success or first error). Records the error (if any)
     /// and re-queues this `ShellCpTask` onto the JS thread so the interpreter
     /// can drain `verbose_output` / surface the error.
@@ -499,9 +487,9 @@ impl ShellCpTask {
         }
     }
 
-    /// Spec: cp.zig `schedule` — `WorkPool.schedule(&this.task)`. Unlike most
-    /// shell builtins this does NOT use the generic [`ShellTask::schedule`]
-    /// trampoline (which auto-enqueues back to main on return): on the
+    /// Unlike most shell builtins this does NOT use the generic
+    /// [`ShellTask::schedule`] trampoline (which auto-enqueues back to main
+    /// on return): on the
     /// success path the [`ShellAsyncCpTask`](crate::node::fs::ShellAsyncCpTask)
     /// owns the bounce-back via `cp_on_finish`, so an unconditional post would
     /// double-enqueue. The embedded [`ShellTask`] is reused for its
@@ -522,7 +510,7 @@ impl ShellCpTask {
         }
     }
 
-    /// Spec: cp.zig `runFromThreadPool` — recover `*ShellCpTask` from the
+    /// Recover `*ShellCpTask` from the
     /// intrusive `*WorkPoolTask`, run the impl, and on error post back
     /// immediately (success path defers the post to `cp_on_finish`).
     unsafe fn work_pool_callback(task: *mut crate::shell::interpreter::WorkPoolTask) {
@@ -542,26 +530,23 @@ impl ShellCpTask {
         }
     }
 
-    /// Spec: cp.zig `enqueueToEventLoop`. Post this task to the main-thread
+    /// Post this task to the main-thread
     /// concurrent queue; routed by `dispatch.rs` → [`run_from_main_thread`].
     ///
     /// # Safety
     /// `this` is the live `heap::alloc`'d task; not touched again on this
     /// thread after return.
     unsafe fn enqueue_to_event_loop(this: *mut ShellCpTask) {
-        // Reuse the generic `ShellTask` post-back (identical to Zig's manual
-        // `concurrent_task.{js,mini}.from(...)` + enqueue).
+        // Reuse the generic `ShellTask` post-back.
         // SAFETY: caller contract.
         unsafe { ShellTask::on_finish::<ShellCpTask>(this) };
     }
 
-    /// Spec: cp.zig `hasTrailingSep`.
     fn has_trailing_sep(path: &[u8]) -> bool {
         path.last()
             .is_some_and(|&c| resolve_path::Platform::AUTO.is_separator(c))
     }
 
-    /// Spec: cp.zig `isDir`.
     fn is_dir(path: &bun_core::ZStr) -> bun_sys::Maybe<bool> {
         #[cfg(windows)]
         {
@@ -580,8 +565,8 @@ impl ShellCpTask {
         }
     }
 
-    /// Spec: cp.zig `runFromThreadPoolImpl`. Resolves src/tgt to absolute
-    /// paths, classifies them per the three POSIX `cp` synopses
+    /// Resolves src/tgt to absolute paths, classifies them per the three
+    /// POSIX `cp` synopses
     /// (<https://man7.org/linux/man-pages/man1/cp.1p.html>), then hands off to
     /// the node:fs async cp implementation.
     fn run_from_thread_pool_impl(&mut self) -> Option<ShellErr> {
@@ -592,9 +577,8 @@ impl ShellCpTask {
         // We have to give an absolute path to our cp implementation for it to
         // work with cwd.
         let src: &bun_core::ZStr = if Platform::AUTO.is_absolute(&self.src) {
-            // PORT NOTE: `self.src` is the bare argv bytes (no NUL); the Zig
-            // path is `[:0]const u8` so `break :brk this.src` was already
-            // NUL-terminated. Re-terminate via the thread-local join buffer.
+            // `self.src` is the bare argv bytes (no NUL); re-terminate via
+            // the thread-local join buffer.
             resolve_path::join_z::<platform::Auto>(&[&self.src])
         } else {
             resolve_path::join_z::<platform::Auto>(&[&self.cwd_path, &self.src])
@@ -718,8 +702,6 @@ impl ShellCpTask {
             },
         };
 
-        // PORT NOTE: Zig passed an `ArenaAllocator` for the async-cp
-        // bookkeeping; the Rust `NewAsyncCpTask` owns its allocations.
         match self.task.event_loop {
             EventLoopHandle::Js { .. } => {
                 let vm_ptr = self
@@ -729,9 +711,8 @@ impl ShellCpTask {
                     .cast::<bun_jsc::virtual_machine::VirtualMachine>();
                 // SAFETY: `Js` arm always has a live VM (set at interpreter
                 // construction); accessed read-only here for the
-                // global-object handle and event-loop pointer — same as Zig's
-                // `event_loop.js.getVmImpl()` from the work-pool thread.
-                // PORT NOTE: reshaped for borrowck — read the raw `global`
+                // global-object handle and event-loop pointer.
+                // Read the raw `global`
                 // field instead of `vm.global()` so the `&mut VirtualMachine`
                 // passed below doesn't overlap a `&JSGlobalObject` borrow.
                 let (global, vm) = unsafe { (&*(*vm_ptr).global, &mut *vm_ptr) };
@@ -773,9 +754,9 @@ impl crate::shell::interpreter::ShellTaskCtx for ShellCpTask {
     const TASK_OFFSET: usize = core::mem::offset_of!(Self, task);
     fn run_from_thread_pool(_this: &mut Self) {
         // Not reached: `ShellCpTask::schedule` installs `work_pool_callback`
-        // directly (cp.zig does NOT use `InnerShellTask` — the generic
-        // trampoline auto-posts back, which would double-enqueue when the
-        // `ShellAsyncCpTask` later calls `cp_on_finish`).
+        // directly (the generic trampoline auto-posts back, which would
+        // double-enqueue when the `ShellAsyncCpTask` later calls
+        // `cp_on_finish`).
         debug_assert!(
             false,
             "ShellCpTask scheduled via ShellTask::schedule; use ShellCpTask::schedule"
@@ -856,5 +837,3 @@ impl FlagParser for Opts {
         }
     }
 }
-
-// ported from: src/shell/builtin/cp.zig
diff --git a/src/runtime/shell/builtin/dirname.rs b/src/runtime/shell/builtin/dirname.rs
index a7f90198199..4edfdb2db59 100644
--- a/src/runtime/shell/builtin/dirname.rs
+++ b/src/runtime/shell/builtin/dirname.rs
@@ -72,5 +72,3 @@ impl Dirname {
         Builtin::done(interp, cmd, exit)
     }
 }
-
-// ported from: src/shell/builtin/dirname.zig
diff --git a/src/runtime/shell/builtin/echo.rs b/src/runtime/shell/builtin/echo.rs
index 65fd37d0c6a..ee1163375e0 100644
--- a/src/runtime/shell/builtin/echo.rs
+++ b/src/runtime/shell/builtin/echo.rs
@@ -69,7 +69,7 @@ impl Echo {
                     if thearg.last() == Some(&b'\n') {
                         has_leading_newline = true;
                     }
-                    // Collapse a trailing run of '\n'; matches Zig's trimSubsequentLeadingChars.
+                    // Collapse a trailing run of '\n'.
                     out.extend_from_slice(bun_core::strings::trim_subsequent_leading_chars(
                         thearg, b'\n',
                     ));
diff --git a/src/runtime/shell/builtin/exit.rs b/src/runtime/shell/builtin/exit.rs
index 9ae18ede8a5..767cbe4b2bd 100644
--- a/src/runtime/shell/builtin/exit.rs
+++ b/src/runtime/shell/builtin/exit.rs
@@ -33,9 +33,8 @@ impl Exit {
                 return Self::fail(interp, cmd, b"exit: too many arguments\n");
             }
         };
-        // TODO(port): bash `exit` should unwind the whole script, not just the
-        // current Cmd. The Zig version sets a flag on the interpreter; preserve
-        // that once `Interpreter::request_exit` exists.
+        // Intentional divergence from bash: this completes only the current
+        // Cmd rather than unwinding the whole script.
         Builtin::done(interp, cmd, code)
     }
 
@@ -59,5 +58,3 @@ fn parse_exit_code(s: &[u8]) -> Option<crate::shell::ExitCode> {
     // %256 is bash semantics — keep wrapper fn.
     bun_core::fmt::parse_decimal::<u64>(s).map(|n| (n % 256) as crate::shell::ExitCode)
 }
-
-// ported from: src/shell/builtin/exit.zig
diff --git a/src/runtime/shell/builtin/export.rs b/src/runtime/shell/builtin/export.rs
index 24137e504c1..4e7d74c65cf 100644
--- a/src/runtime/shell/builtin/export.rs
+++ b/src/runtime/shell/builtin/export.rs
@@ -33,7 +33,7 @@ impl Export {
                 Some(eq) => (&s[..eq], &s[eq + 1..]),
                 None => (s, &b""[..]),
             };
-            // Spec (export.zig): argv backing is freed when the Cmd retires,
+            // The argv backing is freed when the Cmd retires,
             // so the key/value MUST be duplicated into ref-counted storage —
             // `init_slice` here would leave dangling EnvStr in `export_env`.
             let label = EnvStr::dupe_ref_counted(name);
@@ -84,5 +84,3 @@ impl Export {
         Builtin::done(interp, cmd, err.map_or(0, |_| 1))
     }
 }
-
-// ported from: src/shell/builtin/export.zig
diff --git a/src/runtime/shell/builtin/false_.rs b/src/runtime/shell/builtin/false_.rs
index 220ee0415c0..172f63f39dd 100644
--- a/src/runtime/shell/builtin/false_.rs
+++ b/src/runtime/shell/builtin/false_.rs
@@ -19,5 +19,3 @@ impl False {
         Yield::done()
     }
 }
-
-// ported from: src/shell/builtin/false_.zig
diff --git a/src/runtime/shell/builtin/ls.rs b/src/runtime/shell/builtin/ls.rs
index 12e4d3b62ce..978adf9b9d8 100644
--- a/src/runtime/shell/builtin/ls.rs
+++ b/src/runtime/shell/builtin/ls.rs
@@ -41,8 +41,8 @@ pub struct ExecState {
     pub output_queue: std::collections::VecDeque<*mut OutputTask<Ls>>,
 }
 
-/// Custom parse error for invalid options. Spec: ls.zig `Opts.ParseError` (ls
-/// uses its own per-byte parser, not the shared `FlagParser`).
+/// Custom parse error for invalid options (ls uses its own per-byte parser,
+/// not the shared `FlagParser`).
 pub enum LsParseError {
     /// Carries an owned 1-byte copy of the offending flag char.
     IllegalOption(Box<[u8]>),
@@ -61,8 +61,7 @@ impl Ls {
     }
 
     pub(crate) fn next(interp: &Interpreter, cmd: NodeId) -> Yield {
-        // PORT NOTE: reshaped for borrowck — match on a tag, drop the
-        // borrow, then act.
+        // Match on a tag, drop the borrow, then act.
         enum Tag {
             Idle,
             Exec,
@@ -207,8 +206,6 @@ impl Ls {
         Self::next(interp, cmd)
     }
 
-    /// Spec: ls.zig `onShellLsTaskDone`.
-    ///
     /// # Safety
     /// `task` must be a live heap allocation produced by
     /// [`ShellLsTask::create`]; ownership is reclaimed here.
@@ -237,7 +234,7 @@ impl Ls {
         OutputTask::<Ls>::start(output_task, interp, errstr.as_deref()).run(interp);
     }
 
-    /// Spec: ls.zig `parseOpts` / `parseFlags`. Returns the index of the
+    /// Returns the index of the
     /// first non-flag arg, or `None` if there are no positional args.
     fn parse_opts(interp: &Interpreter, cmd: NodeId) -> Result<Option<usize>, LsParseError> {
         let argc = Builtin::of(interp, cmd).args_slice().len();
@@ -274,8 +271,7 @@ impl Ls {
                 b'R' => opts.recursive = true,
                 b'r' => opts.reverse_order = true,
                 b'1' => opts.one_file_per_line = true,
-                // The remaining short flags are recognised but currently no-op
-                // (mirrors Zig — most fields exist only for parsing parity).
+                // The remaining short flags are recognised but currently no-op.
                 b'b' | b'B' | b'c' | b'C' | b'D' | b'f' | b'F' | b'g' | b'G' | b'h' | b'H'
                 | b'i' | b'I' | b'k' | b'L' | b'm' | b'n' | b'N' | b'o' | b'p' | b'q' | b'Q'
                 | b's' | b'S' | b't' | b'T' | b'u' | b'U' | b'v' | b'w' | b'x' | b'X' | b'Z' => {}
@@ -368,14 +364,14 @@ pub enum ResultKind {
     Idk,
 }
 
-/// Spec: ls.zig `ShellLsTask`. Opens the path, iterates its entries (or
+/// Opens the path, iterates its entries (or
 /// prints the path itself for files / `-d`), accumulating into `output`.
 pub(crate) struct ShellLsTask {
     pub cmd: NodeId,
     pub opts: Opts,
     pub print_directory: bool,
     /// Shared atomic counter (lives in `ExecState` inside `Box<Ls>`; address
-    /// is stable for the lifetime of the Exec state). Spec: `*atomic.Value(usize)`.
+    /// is stable for the lifetime of the Exec state).
     pub task_count: *const AtomicUsize,
     pub cwd: bun_sys::Fd,
     pub path: ZBox,
@@ -423,7 +419,7 @@ impl ShellLsTask {
         bun_core::heap::into_raw(task)
     }
 
-    /// Spec: ls.zig `ShellLsTask.enqueue`. Spawns a subtask for a recursively
+    /// Spawns a subtask for a recursively
     /// discovered subdirectory.
     fn enqueue(&mut self, name: &[u8]) {
         let new_path = self.join(name);
@@ -438,9 +434,9 @@ impl ShellLsTask {
         );
         // SAFETY: `task_count` points into the `Box<Ls>` ExecState which
         // outlives every in-flight task (see `next`). `subtask` is freshly
-        // heap-allocated; spec ls.zig `enqueue` calls `subtask.schedule()` =
-        // raw `WorkPool.schedule` (no keep-alive ref) — runs on a worker
-        // thread with no JS-VM thread-local.
+        // heap-allocated and scheduled via raw `WorkPool::schedule` (no
+        // keep-alive ref) — it runs on a worker thread with no JS-VM
+        // thread-local.
         unsafe {
             (*self.task_count).fetch_add(1, Ordering::Relaxed);
             (*subtask).print_directory = true;
@@ -448,13 +444,12 @@ impl ShellLsTask {
         }
     }
 
-    /// Spec: ls.zig `ShellLsTask.join`.
     fn join(&self, child: &[u8]) -> ZBox {
         if !self.is_absolute {
             // If relative paths enabled, stdlib join is preferred over
             // ResolvePath.joinBuf because it doesn't try to normalize the path.
-            // Spec: `std.fs.path.joinZ` — its `isSep` accepts both '/' and '\'
-            // on Windows, so `["foo/", "bar"]` → `foo/bar` (no extra sep).
+            // On Windows both '/' and '\' count as separators here, so
+            // `["foo/", "bar"]` → `foo/bar` (no extra sep).
             let parent = self.path.as_bytes();
             let mut v = Vec::with_capacity(parent.len() + 1 + child.len());
             v.extend_from_slice(parent);
@@ -471,7 +466,6 @@ impl ShellLsTask {
         ZBox::from_bytes(out)
     }
 
-    /// Spec: ls.zig `ShellLsTask.run`.
     pub(crate) fn run_from_thread_pool(this: &mut ShellLsTask) {
         // Cache current time once per task for timestamp formatting.
         if this.opts.long_listing {
@@ -545,7 +539,6 @@ impl ShellLsTask {
         this.output.push(b'\n');
     }
 
-    /// Spec: ls.zig `shouldSkipEntry`.
     fn should_skip_entry(&self, name: &[u8]) -> bool {
         if self.opts.show_all {
             return false;
@@ -562,7 +555,6 @@ impl ShellLsTask {
         false
     }
 
-    /// Spec: ls.zig `addEntry`.
     // TODO more complex output like multi-column
     fn add_entry(&mut self, name: &[u8], dir_fd: bun_sys::Fd) {
         if self.should_skip_entry(name) {
@@ -577,7 +569,6 @@ impl ShellLsTask {
         }
     }
 
-    /// Spec: ls.zig `addEntryLong`.
     fn add_entry_long(&mut self, name: &[u8], dir_fd: bun_sys::Fd) {
         // Use lstatat to not follow symlinks (so symlinks show as 'l' type).
         let name_z = ZBox::from_bytes(name);
@@ -625,14 +616,12 @@ impl ShellLsTask {
         self.output.push(b'\n');
     }
 
-    /// Spec: ls.zig `addDotEntriesIfNeeded`.
     fn add_dot_entries_if_needed(&mut self, dir_fd: bun_sys::Fd) {
         // `add_entry()` already checks if we can add "." and ".." to the result.
         self.add_entry(b".", dir_fd);
         self.add_entry(b"..", dir_fd);
     }
 
-    /// Spec: ls.zig `errorWithPath`.
     fn error_with_path(&self, err: &bun_sys::Error) -> bun_sys::Error {
         err.with_path(self.path.as_bytes())
     }
@@ -648,7 +637,6 @@ impl ShellLsTask {
     }
 }
 
-/// Spec: ls.zig `getFileTypeChar`.
 fn get_file_type_char(mode: u32) -> u8 {
     let file_type = mode & (S::IFMT as u32);
     match file_type {
@@ -662,7 +650,6 @@ fn get_file_type_char(mode: u32) -> u8 {
     }
 }
 
-/// Spec: ls.zig `formatPermissions`.
 fn format_permissions(mode: u32) -> [u8; 9] {
     let mut perms = [b'-'; 9];
     // Owner permissions.
@@ -734,7 +721,7 @@ fn format_permissions(mode: u32) -> [u8; 9] {
     perms
 }
 
-/// Spec: ls.zig `formatTime`. Format as `"Mon DD HH:MM"` for recent files
+/// Format as `"Mon DD HH:MM"` for recent files
 /// (within ~6 months) or `"Mon DD  YYYY"` for older files.
 fn format_time(timestamp: i64, now_secs: u64) -> [u8; 12] {
     const MONTH_NAMES: [&str; 12] = [
@@ -771,8 +758,7 @@ fn format_time(timestamp: i64, now_secs: u64) -> [u8; 12] {
 }
 
 /// Howard Hinnant's `civil_from_days` — converts days-since-1970-01-01 to a
-/// proleptic-Gregorian (year, month[1..=12], day[1..=31]). Port of the calendar
-/// arithmetic Zig gets from `std.time.epoch`.
+/// proleptic-Gregorian (year, month[1..=12], day[1..=31]).
 fn civil_from_days(z: i64) -> (i32, u8, u8) {
     let z = z + 719_468;
     let era = z.div_euclid(146_097);
@@ -802,8 +788,8 @@ impl crate::shell::interpreter::ShellTaskCtx for ShellLsTask {
     }
 }
 
-/// Spec: ls.zig `Opts`. Only the fields the current port actually consults
-/// are kept; the rest are recognised by `parse_flag` but not stored.
+/// Only the fields actually consulted are kept; the rest are recognised by
+/// `parse_flag` but not stored.
 #[derive(Clone, Copy, Default)]
 pub struct Opts {
     /// `-a`, `--all` — do not ignore entries starting with `.`
@@ -821,5 +807,3 @@ pub struct Opts {
     /// `-1` — list one file per line
     pub one_file_per_line: bool,
 }
-
-// ported from: src/shell/builtin/ls.zig
diff --git a/src/runtime/shell/builtin/mkdir.rs b/src/runtime/shell/builtin/mkdir.rs
index 66965d07b64..a47d53443ff 100644
--- a/src/runtime/shell/builtin/mkdir.rs
+++ b/src/runtime/shell/builtin/mkdir.rs
@@ -31,9 +31,9 @@ pub struct Exec {
     pub tasks_done: usize,
     pub output_waiting: u16,
     pub output_done: u16,
-    /// Index into `Builtin::args` where filepath args start (replaces Zig's
-    /// borrowed `args: []const [*:0]const u8` slice — storing the index keeps
-    /// the lifetime tied to the Cmd's argv without a self-reference).
+    /// Index into `Builtin::args` where filepath args start (storing the
+    /// index keeps the lifetime tied to the Cmd's argv without a
+    /// self-reference).
     pub args_start: usize,
     pub err: Option<bun_sys::Error>,
     /// FIFO of in-flight OutputTask pointers awaiting an IOWriter chunk
@@ -41,7 +41,7 @@ pub struct Exec {
     /// directly (IOWriter.rs is out of scope here): `write_err`/`write_out`
     /// push, `on_io_writer_chunk` pops and forwards to
     /// `OutputTask::on_io_writer_chunk` so the box is reclaimed and the
-    /// writeErr→writeOut→onDone state machine runs (spec mkdir.zig:134/150).
+    /// writeErr→writeOut→onDone state machine runs.
     pub output_queue: std::collections::VecDeque<*mut OutputTask<Mkdir>>,
 }
 
@@ -87,7 +87,7 @@ impl Mkdir {
     }
 
     pub(crate) fn next(interp: &Interpreter, cmd: NodeId) -> Yield {
-        // PORT NOTE: reshaped for borrowck — read scalars, drop the borrow,
+        // NOTE: reshaped for borrowck — read scalars, drop the borrow,
         // then act.
         let action = match &mut Self::state_mut(interp, cmd).state {
             State::Idle => panic!("Invalid state"),
@@ -156,9 +156,8 @@ impl Mkdir {
         Self::next(interp, cmd)
     }
 
-    /// Spec: mkdir.zig `onShellMkdirTaskDone`. The caller
-    /// ([`ShellMkdirTask::run_from_main_thread`]) owns the heap allocation and
-    /// drops it after this returns.
+    /// The caller ([`ShellMkdirTask::run_from_main_thread`]) owns the heap
+    /// allocation and drops it after this returns.
     pub(crate) fn on_shell_mkdir_task_done(
         interp: &Interpreter,
         cmd: NodeId,
@@ -198,11 +197,11 @@ impl OutputTaskVTable for Mkdir {
             exec.output_waiting += 1;
         }
         if let Some(safeguard) = Builtin::of(interp, cmd).stderr.needs_io() {
-            // TODO(port): IOWriter ChildPtr for OutputTask — needs a
-            // dedicated WriterTag once OutputTask is dispatchable. Until then
-            // stash `child` on `output_queue` so `on_io_writer_chunk` can
-            // route the completion back to the OutputTask state machine and
-            // reclaim the box (spec mkdir.zig:134 enqueues with childptr).
+            // OutputTask has no `WriterTag` of its own (it is not directly
+            // dispatchable as an IOWriter child), so the enqueue is tagged
+            // `WriterTag::Builtin` and `child` is stashed on `output_queue`;
+            // `on_io_writer_chunk` pops it to route the completion back to
+            // the OutputTask state machine and reclaim the box.
             if let State::Exec(exec) = &mut Self::state_mut(interp, cmd).state {
                 exec.output_queue.push_back(child);
             }
@@ -234,7 +233,7 @@ impl OutputTaskVTable for Mkdir {
         }
         if let Some(safeguard) = Builtin::of(interp, cmd).stdout.needs_io() {
             // See write_err — stash `child` so the chunk callback routes to
-            // OutputTask::on_io_writer_chunk (spec mkdir.zig:150).
+            // OutputTask::on_io_writer_chunk.
             if let State::Exec(exec) = &mut Self::state_mut(interp, cmd).state {
                 exec.output_queue.push_back(child);
             }
@@ -262,14 +261,14 @@ impl OutputTaskVTable for Mkdir {
     }
 }
 
-/// Spec: mkdir.zig `ShellMkdirTask`. Runs `mkdir`/`mkdir -p` on a worker
+/// Runs `mkdir`/`mkdir -p` on a worker
 /// thread, then bounces back to the main thread.
 pub(crate) struct ShellMkdirTask {
     /// Owning Cmd node (the mkdir builtin's id).
     pub cmd: NodeId,
     pub opts: Opts,
-    /// Owned copy of the target path (Zig borrowed from argv; we own to avoid
-    /// threading a lifetime through the WorkPool).
+    /// Owned copy of the target path (owned to avoid threading a lifetime
+    /// through the WorkPool).
     pub filepath: Vec<u8>,
     pub cwd_path: Vec<u8>,
     pub created_directories: Vec<u8>,
@@ -299,7 +298,6 @@ impl ShellMkdirTask {
         bun_core::heap::into_raw(task)
     }
 
-    /// Spec: mkdir.zig `runFromThreadPool`.
     pub(crate) fn run_from_thread_pool(this: &mut ShellMkdirTask) {
         use bun_paths::{Platform, platform, resolve_path};
         // We have to give an absolute path to our mkdir implementation for it
@@ -369,10 +367,10 @@ impl bun_event_loop::Taskable for ShellMkdirTask {
     const TAG: bun_event_loop::TaskTag = bun_event_loop::task_tag::ShellMkdirTask;
 }
 
-/// Spec: mkdir.zig `MkdirVerboseVTable` — collects each created directory into
+/// Collects each created directory into
 /// `created_directories` (newline-separated) when `-v` is set. Passed by value
 /// to `NodeFS::mkdir_recursive_impl`; `on_create_dir` writes through the raw
-/// back-ref because the trait method takes `&self` (Zig: `*@This()`).
+/// back-ref because the trait method takes `&self`.
 struct MkdirVerboseVTable {
     inner: *mut Vec<u8>,
     active: bool,
@@ -434,7 +432,7 @@ impl FlagParser for Opts {
             self.parents = true;
             return Some(ParseFlagResult::ContinueParsing);
         }
-        // Note: Zig has the same `--vebose` typo (mkdir.zig:497).
+        // Note: the `--vebose` typo is intentional (kept for compatibility).
         if flag == b"--vebose" {
             self.verbose = true;
             return Some(ParseFlagResult::ContinueParsing);
@@ -459,5 +457,3 @@ impl FlagParser for Opts {
         }
     }
 }
-
-// ported from: src/shell/builtin/mkdir.zig
diff --git a/src/runtime/shell/builtin/mv.rs b/src/runtime/shell/builtin/mv.rs
index c65114707a4..9393e20798b 100644
--- a/src/runtime/shell/builtin/mv.rs
+++ b/src/runtime/shell/builtin/mv.rs
@@ -45,7 +45,7 @@ pub enum MvState {
     Err,
 }
 
-/// Spec: mv.zig `Opts.ParseError` — mv uses its own simpler parser.
+/// mv uses its own simpler parser.
 pub(crate) enum MvParseError {
     IllegalOption(&'static [u8]),
     ShowUsage,
@@ -56,7 +56,6 @@ impl Mv {
         Self::next(interp, cmd)
     }
 
-    /// Spec: mv.zig `writeFailingError`.
     fn write_failing_error(
         interp: &Interpreter,
         cmd: NodeId,
@@ -74,9 +73,8 @@ impl Mv {
         Builtin::done(interp, cmd, exit_code)
     }
 
-    /// Spec: mv.zig `next`.
     pub(crate) fn next(interp: &Interpreter, cmd: NodeId) -> Yield {
-        // PORT NOTE: reshaped for borrowck — read tag, drop borrow, act.
+        // Read the tag, drop the borrow, then act.
         enum Tag {
             Idle,
             CheckTarget,
@@ -143,7 +141,7 @@ impl Mv {
                 let maybe_fd: Option<bun_sys::Fd> = match result.unwrap() {
                     Ok(fd) => fd,
                     Err(e) => {
-                        // Spec mv.zig:228-247 — only ENOENT (rename to a
+                        // Only ENOENT (rename to a
                         // new path) is acceptable, and only with exactly
                         // one source. Any other errno (EACCES, ELOOP, …)
                         // is reported and fails regardless of source count.
@@ -299,7 +297,6 @@ impl Mv {
         }
     }
 
-    /// Spec: mv.zig `checkTargetTaskDone`.
     pub(crate) fn check_target_task_done(interp: &Interpreter, cmd: NodeId) {
         if let MvState::CheckTarget(t) = &mut Self::state_mut(interp, cmd).state {
             t.done = true;
@@ -307,7 +304,6 @@ impl Mv {
         Self::next(interp, cmd).run(interp);
     }
 
-    /// Spec: mv.zig `batchedMoveTaskDone`.
     pub(crate) fn batched_move_task_done(interp: &Interpreter, cmd: NodeId, task_idx: usize) {
         let (all_done, had_err) = {
             let MvState::Executing {
@@ -335,8 +331,7 @@ impl Mv {
                     MvState::Executing { err, .. } => err.take().unwrap(),
                     _ => unreachable!(),
                 };
-                // Spec mv.zig:374 — `writeFailingError(buf, err.errno)`: the
-                // failing rename's errno becomes the shell exit code.
+                // The failing rename's errno becomes the shell exit code.
                 let exit_code = e.errno as ExitCode;
                 let buf = Builtin::task_error_to_string(interp, cmd, Kind::Mv, &e).to_vec();
                 Self::write_failing_error(interp, cmd, &buf, exit_code).run(interp);
@@ -347,7 +342,6 @@ impl Mv {
         }
     }
 
-    /// Spec: mv.zig `parseOpts` + `parseFlags`.
     fn parse_opts(interp: &Interpreter, cmd: NodeId) -> Result<(), MvParseError> {
         let argc = Builtin::of(interp, cmd).args_slice().len();
         if argc == 0 {
@@ -406,7 +400,7 @@ impl Mv {
 }
 
 impl Drop for Mv {
-    /// Spec: mv.zig `deinit` — close the directory fd opened by
+    /// Close the directory fd opened by
     /// `ShellMvCheckTargetTask` (`openat(target, O_RDONLY|O_DIRECTORY)`).
     /// `bun_sys::Fd` is `Copy` with no `Drop`, so without this every
     /// `mv srcs... dir/` leaks one open fd.
@@ -423,7 +417,7 @@ enum MvFlag {
     IllegalOption(&'static [u8]),
 }
 
-/// Spec: mv.zig `ShellMvCheckTargetTask`. `openat(target, O_RDONLY|O_DIRECTORY)`
+/// `openat(target, O_RDONLY|O_DIRECTORY)`
 /// on a worker thread to learn whether the destination is a directory.
 pub struct ShellMvCheckTargetTask {
     pub cmd: NodeId,
@@ -437,7 +431,6 @@ pub struct ShellMvCheckTargetTask {
 }
 
 impl ShellMvCheckTargetTask {
-    /// Spec: mv.zig `ShellMvCheckTargetTask.runFromThreadPool`.
     pub(crate) fn run_from_thread_pool(this: &mut ShellMvCheckTargetTask) {
         let flags = bun_sys::O::RDONLY | bun_sys::O::DIRECTORY;
         this.result = Some(match shell_openat(this.cwd, &this.target, flags, 0) {
@@ -449,12 +442,11 @@ impl ShellMvCheckTargetTask {
     }
 }
 
-/// Spec: mv.zig `ShellMvBatchedTask`. renameat() each source into the target.
+/// renameat() each source into the target.
 pub struct ShellMvBatchedTask {
     pub cmd: NodeId,
     /// Index into `MvState::Executing::tasks` so the main-thread completion
-    /// can route to `Mv::batched_move_task_done` (Zig used `*ShellMvBatchedTask`
-    /// directly via `container_of`).
+    /// can route to `Mv::batched_move_task_done`.
     pub idx: usize,
     pub sources: Vec<ZBox>,
     pub target: ZBox,
@@ -473,7 +465,6 @@ pub struct ShellMvBatchedTask {
 impl ShellMvBatchedTask {
     pub(crate) const BATCH_SIZE: usize = 5;
 
-    /// Spec: mv.zig `ShellMvBatchedTask.runFromThreadPool`.
     pub(crate) fn run_from_thread_pool(this: &mut ShellMvBatchedTask) {
         // Moving multiple entries into a directory.
         if this.sources.len() > 1 {
@@ -504,8 +495,7 @@ impl ShellMvBatchedTask {
         // Bounce-back is posted by `shell_task_trampoline`.
     }
 
-    /// Spec: mv.zig `ShellMvBatchedTask.moveInDir` — `renameat(cwd, src,
-    /// target_fd, basename(src))`. Reshaped for borrowck: free fn over the
+    /// `renameat(cwd, src, target_fd, basename(src))`. A free fn over the
     /// fields it touches so `src` can borrow `self.sources[_]` while `self.err`
     /// is written by the caller.
     fn move_in_dir(
@@ -527,15 +517,12 @@ impl ShellMvBatchedTask {
         buf[len] = 0;
         let path_in_dir = ZStr::from_buf(buf.as_slice(), len);
         bun_sys::renameat(cwd, src, target_fd, path_in_dir).map_err(|e| {
-            // Spec mv.zig:122-128 — surface `target/basename(src)` as the
-            // failing path. `with_path` heap-clones, so the Zig
-            // `err_path_owned` bookkeeping is unnecessary here (`Drop` frees).
+            // Surface `target/basename(src)` as the failing path.
             let joined = resolve_path::join_z::<bun_paths::platform::Auto>(&[target, base]);
             e.with_path(joined.as_bytes())
         })
     }
 
-    /// Spec: mv.zig `ShellMvBatchedTask.moveMultipleIntoDir`.
     fn move_multiple_into_dir(&mut self) {
         let mut buf = PathBuffer::uninit();
         // `target_fd` is always Some when sources.len() > 1 — `next` rejected
@@ -629,5 +616,3 @@ impl Default for Opts {
         }
     }
 }
-
-// ported from: src/shell/builtin/mv.zig
diff --git a/src/runtime/shell/builtin/pwd.rs b/src/runtime/shell/builtin/pwd.rs
index d75b6b70153..354c7e9682e 100644
--- a/src/runtime/shell/builtin/pwd.rs
+++ b/src/runtime/shell/builtin/pwd.rs
@@ -79,5 +79,3 @@ impl Pwd {
         Builtin::done(interp, cmd, if kind == WaitKind::Stderr { 1 } else { 0 })
     }
 }
-
-// ported from: src/shell/builtin/pwd.zig
diff --git a/src/runtime/shell/builtin/rm.rs b/src/runtime/shell/builtin/rm.rs
index 15f2307818c..441fc7f743a 100644
--- a/src/runtime/shell/builtin/rm.rs
+++ b/src/runtime/shell/builtin/rm.rs
@@ -1,5 +1,3 @@
-//! Port of src/shell/builtin/rm.zig
-
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
 
 use bun_core::{ZBox, ZStr};
@@ -28,7 +26,6 @@ pub enum RmState {
         idx: u32,
         wait_write_err: bool,
     },
-    /// Spec rm.zig `.exec`.
     Exec(ExecState),
     Done {
         exit_code: ExitCode,
@@ -109,10 +106,9 @@ impl Rm {
         Self::next(interp, cmd)
     }
 
-    /// Spec: rm.zig `next`.
     pub(crate) fn next(interp: &Interpreter, cmd: NodeId) -> Yield {
         loop {
-            // PORT NOTE: reshaped for borrowck — read tag, drop borrow, act.
+            // Read the tag, drop the borrow, then act.
             enum Tag {
                 Idle,
                 ParseOpts(u32, bool),
@@ -215,7 +211,7 @@ impl Rm {
                                     let dirname =
                                         resolve_path::dirname::<platform::Auto>(normalized);
                                     if dirname.is_empty() {
-                                        // PORT NOTE: reshaped for borrowck — copy resolved before
+                                        // Copy resolved before
                                         // re-borrowing `interp` mutably.
                                         let resolved_owned = resolved.to_vec();
                                         if let Some(safeguard) =
@@ -372,7 +368,6 @@ impl Rm {
         Builtin::done(interp, cmd, 1)
     }
 
-    /// Spec: rm.zig `writeFailingError`.
     fn write_failing_error(
         interp: &Interpreter,
         cmd: NodeId,
@@ -390,7 +385,6 @@ impl Rm {
         Builtin::done(interp, cmd, exit_code)
     }
 
-    /// Spec: rm.zig `onIOWriterChunk`.
     pub(crate) fn on_io_writer_chunk(
         interp: &Interpreter,
         cmd: NodeId,
@@ -425,8 +419,6 @@ impl Rm {
         }
     }
 
-    /// Spec: rm.zig `onShellRmTaskDone`.
-    ///
     /// # Safety
     /// `task` must be a live `heap::alloc`'d [`ShellRmTask`]; main thread.
     pub(crate) fn on_shell_rm_task_done(interp: &Interpreter, cmd: NodeId, task: *mut ShellRmTask) {
@@ -438,7 +430,7 @@ impl Rm {
 
         // SAFETY: `task` is live; exclusive on main thread until decr above runs.
         let task_err = unsafe { (*task).err.get_mut().take() };
-        // PORT NOTE: reshaped for borrowck — format the error string before
+        // Format the error string before
         // stashing the error on `exec` (formatting needs &mut interp).
         let errstr: Option<Vec<u8>> = task_err
             .as_ref()
@@ -493,7 +485,7 @@ impl Rm {
         }
     }
 
-    /// Spec: rm.zig `writeVerbose`. Flushes a `DirTask`'s buffered list of
+    /// Flushes a `DirTask`'s buffered list of
     /// deleted paths to stdout, then frees the DirTask (non-root) and releases
     /// the pending-main-callback count taken in `DirTask::post_run`.
     fn write_verbose(interp: &Interpreter, cmd: NodeId, verbose: *mut DirTask) -> Yield {
@@ -548,7 +540,6 @@ impl Rm {
         Yield::done()
     }
 
-    /// Spec: rm.zig `parseFlag`.
     fn parse_flag(opts: &mut Opts, flag: &[u8]) -> RmParseFlag {
         if flag.is_empty() || flag[0] != b'-' {
             return RmParseFlag::Done;
@@ -652,17 +643,13 @@ pub enum EntryKindHint {
     File,
 }
 
-/// Spec: rm.zig `ShellRmTask`. One per filepath argument; owns the root
+/// One per filepath argument; owns the root
 /// [`DirTask`] and tracks the cross-thread error state.
 pub struct ShellRmTask {
     pub cmd: NodeId,
     pub opts: Opts,
     pub cwd: bun_sys::Fd,
-    // PORT NOTE: rm.zig also keeps a Windows-only `cwd_path` populated from
-    // `Syscall.getFdPath(cwd)` on the root task, but it is never read (set and
-    // freed only). The Rust port drops it: keeping it required a Windows
-    // `get_fd_path` call whose only observable effect was the error path.
-    /// PORT NOTE: in Zig the root DirTask is an inline field. Here it lives in
+    /// The root DirTask lives in
     /// its own `heap::alloc`'d allocation so that `&ShellRmTask` (held as
     /// the `&self` receiver throughout `remove_entry*`) never overlaps the
     /// `&mut DirTask` borrows those methods take on the root — embedding it
@@ -675,7 +662,7 @@ pub struct ShellRmTask {
     /// outlives every in-flight `ShellRmTask`.
     pub error_signal: bun_ptr::BackRef<AtomicBool>,
     /// Backref into `Rm::ExecState.output_count` so [`verbose_deleted`] can
-    /// bump it from worker threads (Zig: `this.rm.state.exec.incrementOutputCount`).
+    /// bump it from worker threads.
     output_count: bun_ptr::BackRef<AtomicUsize>,
     /// Main-thread callbacks that must complete before this task can be freed:
     /// always one for `on_shell_rm_task_done` (via `finish_concurrently`), plus
@@ -690,8 +677,8 @@ pub struct ShellRmTask {
     pub task: ShellTask,
 }
 
-/// Spec: rm.zig `ShellRmTask.DirTask`. One per directory in the recursive
-/// walk; root and children alike are heap-allocated (see PORT NOTE on
+/// One per directory in the recursive
+/// walk; root and children alike are heap-allocated (see the comment on
 /// [`ShellRmTask::root_task`]).
 pub struct DirTask {
     pub task_manager: *mut ShellRmTask,
@@ -734,7 +721,7 @@ impl ShellRmTask {
     ) -> *mut ShellRmTask {
         let root_path_z = ZBox::from_bytes(root_path);
         let join_style = JoinStyle::from_path(root_path);
-        // Separate allocation — see PORT NOTE on `root_task`.
+        // Separate allocation — see the comment on `root_task`.
         let root_task = bun_core::heap::into_raw(Box::new(DirTask {
             // task_manager is fixed up below once we have the ShellRmTask address.
             task_manager: core::ptr::null_mut(),
@@ -774,9 +761,9 @@ impl ShellRmTask {
         raw
     }
 
-    /// Spec: rm.zig `schedule` — `WorkPool.schedule(&this.task)`. Unlike most
-    /// shell builtins this does NOT use the generic [`ShellTask::schedule`]
-    /// trampoline (which auto-enqueues back to main on return): the recursive
+    /// Unlike most shell builtins this does NOT use the generic
+    /// [`ShellTask::schedule`] trampoline (which auto-enqueues back to main
+    /// on return): the recursive
     /// DirTask tree owns the bounce-back via [`finish_concurrently`].
     ///
     /// # Safety
@@ -794,8 +781,8 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `workPoolCallback` — recover `*ShellRmTask` from the
-    /// intrusive `*WorkPoolTask` and run the root DirTask.
+    /// Recover `*ShellRmTask` from the intrusive `*WorkPoolTask` and run the
+    /// root DirTask.
     unsafe fn work_pool_callback(task: *mut WorkPoolTask) {
         // SAFETY: `task` is the first `#[repr(C)]` field of `ShellTask`, which
         // is embedded in `ShellRmTask` at `TASK_OFFSET`. `this` is a live
@@ -807,7 +794,7 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `finishConcurrently` — post this task to the main-thread
+    /// Post this task to the main-thread
     /// concurrent queue; routed by `dispatch.rs` → [`run_from_main_thread`].
     ///
     /// # Safety
@@ -829,8 +816,6 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `decrPendingAndMaybeDeinit`.
-    ///
     /// # Safety
     /// `this` is a live `heap::alloc`'d task; main thread.
     pub unsafe fn decr_pending_and_maybe_deinit(this: *mut ShellRmTask) {
@@ -853,7 +838,7 @@ impl ShellRmTask {
         self.error_signal.get()
     }
 
-    /// Spec: rm.zig `enqueue` — joins `path` onto `parent_dir.path` and spawns
+    /// Joins `path` onto `parent_dir.path` and spawns
     /// a child DirTask.
     fn enqueue(
         &self,
@@ -871,7 +856,7 @@ impl ShellRmTask {
         self.enqueue_no_join(parent_dir, new_path, kind_hint);
     }
 
-    /// Spec: rm.zig `enqueueNoJoin`. Takes ownership of `path`.
+    /// Takes ownership of `path`.
     fn enqueue_no_join(&self, parent: *mut DirTask, path: ZBox, kind_hint: EntryKindHint) {
         if self.error_signal().load(Ordering::SeqCst) {
             return;
@@ -905,8 +890,6 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `verboseDeleted`.
-    ///
     /// Takes `dir_task` as a raw pointer (not `&mut DirTask`) so callers in
     /// `remove_entry*` — which already hold `&self: &ShellRmTask` and a
     /// `&ZStr` borrowed from `dir_task.path` — never materialise an aliasing
@@ -936,7 +919,7 @@ impl ShellRmTask {
         Ok(())
     }
 
-    /// Spec: rm.zig `bufJoin` — join into `buf` honoring [`join_style`].
+    /// Join into `buf` honoring [`join_style`].
     fn buf_join<'a>(&self, buf: &'a mut bun_paths::PathBuffer, parts: &[&[u8]]) -> &'a ZStr {
         if self.join_style == JoinStyle::Posix {
             resolve_path::join_z_buf::<platform::Posix>(buf.as_mut_slice(), parts)
@@ -945,15 +928,14 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `join` — owned ZBox.
+    /// Join to an owned ZBox.
     fn join(&self, parts: &[&[u8]], is_absolute: bool) -> ZBox {
         if !is_absolute {
             // If relative paths enabled, stdlib join is preferred over
             // ResolvePath.joinBuf because it doesn't try to normalize.
-            // Spec: `std.fs.path.joinZ(alloc, parts)` — concatenate with
-            // platform separator, collapsing only adjacent separators.
-            // On Windows `std.fs.path.isSep` matches BOTH `/` and `\`, so do
-            // the same here when deciding whether to insert/strip a separator.
+            // Concatenate with the platform separator, collapsing only
+            // adjacent separators. On Windows BOTH `/` and `\` count as
+            // separators when deciding whether to insert/strip one.
             #[cfg(windows)]
             let is_sep = |c: u8| c == b'/' || c == b'\\';
             #[cfg(not(windows))]
@@ -979,14 +961,11 @@ impl ShellRmTask {
         ZBox::from_bytes(resolve_path::join::<platform::Auto>(parts))
     }
 
-    /// Spec: rm.zig `errorWithPath`.
     #[inline]
     fn error_with_path(&self, e: &bun_sys::Error, path: &[u8]) -> bun_sys::Error {
         e.with_path(path)
     }
 
-    /// Spec: rm.zig `removeEntry`.
-    ///
     /// Returns `Ok(true)` when [`remove_entry_dir`] published
     /// `need_to_wait = true` on `dir_task`. Once that store is visible, a
     /// child finishing on another thread may run
@@ -995,9 +974,7 @@ impl ShellRmTask {
     /// [`ShellRmTask`]). Callers must therefore treat `dir_task` as
     /// potentially-freed when this returns `Ok(true)`. The bool is threaded
     /// out locally instead of re-reading the atomic so the caller never
-    /// dereferences `dir_task` to find out — the Zig spec re-reads
-    /// `deleting_after_waiting_for_children` after this returns, which is the
-    /// same race; the Rust port closes it.
+    /// dereferences `dir_task` to find out.
     fn remove_entry(&self, dir_task: *mut DirTask, is_absolute: bool) -> bun_sys::Maybe<bool> {
         let mut waiting = false;
         let mut buf = bun_paths::PathBuffer::uninit();
@@ -1020,8 +997,6 @@ impl ShellRmTask {
         Ok(waiting)
     }
 
-    /// Spec: rm.zig `removeEntryDir`.
-    ///
     /// `need_to_wait_out` is set to `true` immediately before the
     /// `need_to_wait` atomic store that hands `dir_task` off to its children;
     /// see [`remove_entry`] for why the caller needs this on its own stack
@@ -1140,10 +1115,8 @@ impl ShellRmTask {
                 }
                 _ => {
                     let name = current.name.slice_u8();
-                    // PORT NOTE: reshaped for borrowck — Zig passed both the
-                    // joined slice (borrowing `buf`) and `buf` itself to
-                    // `removeEntryFile`. Copy the join into an owned ZBox so
-                    // `buf` is free to be re-borrowed by the vtable callback.
+                    // Copy the join into an owned ZBox so `buf` is free to
+                    // be re-borrowed by the vtable callback.
                     let file_path = {
                         let joined = self.buf_join(buf, &[path.as_bytes(), name]);
                         ZBox::from_bytes(joined.as_bytes())
@@ -1205,7 +1178,7 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `removeEntryDirAfterChildren`. Returns `Ok(true)` if the
+    /// Returns `Ok(true)` if the
     /// directory was deleted (or force-ignored), `Ok(false)` if a subtask was
     /// enqueued and the caller should not run `post_run` yet.
     fn remove_entry_dir_after_children(&self, dir_task: *mut DirTask) -> bun_sys::Maybe<bool> {
@@ -1254,7 +1227,6 @@ impl ShellRmTask {
         }
     }
 
-    /// Spec: rm.zig `removeEntryFile`.
     fn remove_entry_file<V: RemoveFileHandler>(
         &self,
         parent_dir_task: *mut DirTask,
@@ -1370,8 +1342,6 @@ impl DirTask {
         };
     }
 
-    /// Spec: rm.zig `DirTask.runFromThreadPoolImpl`.
-    ///
     /// # Safety
     /// `this` is a live DirTask (root or heap child); the calling worker
     /// thread has exclusive access to its non-atomic fields.
@@ -1386,12 +1356,6 @@ impl DirTask {
         // thread has exclusive access to its non-atomic fields (`task_manager`
         // / `parent_task` / `path` / `is_absolute`). `tm_ptr` is live until
         // `pending_main_callbacks` hits 0.
-        //
-        // PORT NOTE: rm.zig:560-577 also resolves `cwd_path` here on Windows
-        // via `Syscall.getFdPath`. That field is dead state (never read), so
-        // the Rust port drops the block entirely rather than calling a
-        // Windows path resolver whose only effect would be to fail the task
-        // on error.
         let (tm_ptr, is_absolute): (*mut ShellRmTask, bool) = unsafe {
             let tm_ptr = (*this).task_manager;
             let abs = Platform::AUTO.is_absolute((*this).path.as_bytes());
@@ -1415,15 +1379,14 @@ impl DirTask {
             }
         };
 
-        // PORT NOTE: rm.zig re-reads `this.deleting_after_waiting_for_children`
-        // here to decide whether to skip `postRun`. That load (and `postRun`'s
-        // own `need_to_wait` load) is a use-after-free race: once
-        // `remove_entry_dir` publishes `need_to_wait = true`, the last child
-        // may run `delete_after_waiting_for_children(this)` → `post_run` →
-        // `deinit` (or, for the root, the main thread may drop the whole
-        // `ShellRmTask`) before we get here. The Rust port instead threads the
-        // hand-off out as a stack-local bool via `remove_entry`'s return value
-        // and never touches `this` again when set. When `waiting` is false the
+        // Re-reading `this` here to decide whether to skip `post_run` would
+        // be a use-after-free race: once `remove_entry_dir` publishes
+        // `need_to_wait = true`, the last child may run
+        // `delete_after_waiting_for_children(this)` → `post_run` → `deinit`
+        // (or, for the root, the main thread may drop the whole
+        // `ShellRmTask`) before we get here. So the hand-off is threaded out
+        // as a stack-local bool via `remove_entry`'s return value and `this`
+        // is never touched again when set. When `waiting` is false the
         // hand-off never happened, so `deleting_after_waiting_for_children`
         // (only ever stored by a child that observed `need_to_wait == true`)
         // is necessarily false and `post_run` is both safe and required.
@@ -1435,8 +1398,6 @@ impl DirTask {
         }
     }
 
-    /// Spec: rm.zig `DirTask.postRun`.
-    ///
     /// # Safety
     /// `this` is a live DirTask; called from a worker thread that just
     /// finished its body.
@@ -1473,7 +1434,7 @@ impl DirTask {
                     // finished, while the parent was still in `remove_entry_dir`.
                     let p = &*me.parent_task;
                     let tasks_left = p.subtask_count.fetch_sub(1, Ordering::SeqCst);
-                    // PORT NOTE: rm.zig uses `.monotonic` here, but that is a
+                    // Relaxed ordering here would be a
                     // formal data race on the parent's non-atomic
                     // `deleted_entries`: the parent thread may have appended
                     // verbose paths for plain-file children *after* scheduling
@@ -1511,8 +1472,6 @@ impl DirTask {
         // Otherwise need to wait.
     }
 
-    /// Spec: rm.zig `DirTask.deleteAfterWaitingForChildren`.
-    ///
     /// # Safety
     /// `this` is a live DirTask; called from a worker thread.
     unsafe fn delete_after_waiting_for_children(this: *mut DirTask) {
@@ -1547,7 +1506,7 @@ impl DirTask {
         }
     }
 
-    /// Spec: rm.zig `DirTask.queueForWrite` — post this DirTask to the main
+    /// Post this DirTask to the main
     /// thread for [`Rm::write_verbose`].
     ///
     /// # Safety
@@ -1562,7 +1521,7 @@ impl DirTask {
         let (me, event_loop) = unsafe {
             let me = &mut *this;
             if me.deleted_entries.is_empty() {
-                // Spec: deinit non-root and bail. The pending count was already
+                // Deinit non-root and bail. The pending count was already
                 // taken so release it again. Capture before the decrement —
                 // dropping the ShellRmTask drops the root DirTask, so for the
                 // root `me` may dangle immediately after.
@@ -1590,7 +1549,7 @@ impl DirTask {
         event_loop.enqueue_task_concurrent(task_ptr);
     }
 
-    /// Spec: rm.zig `DirTask.runFromMainThread` — flush verbose output.
+    /// Flush verbose output.
     ///
     /// Reached only via `runtime::dispatch::run_task` for
     /// `task_tag::ShellRmDirTask` (or the mini-loop trampoline below), which
@@ -1608,8 +1567,6 @@ impl DirTask {
         Rm::write_verbose(interp, cmd, this).run(interp);
     }
 
-    /// Spec: rm.zig `DirTask.deinit`.
-    ///
     /// # Safety
     /// `this` is a live heap-allocated (non-root) DirTask; reclaimed once.
     unsafe fn deinit(this: *mut DirTask) {
@@ -1628,7 +1585,7 @@ fn dir_task_run_from_main_thread_mini(this: *mut DirTask, _: *mut ()) {
     DirTask::run_from_main_thread(this);
 }
 
-// ── RemoveFileHandler — Zig `vtable: anytype` lowered to a trait ───────────
+// ── RemoveFileHandler ───────────────────────────────────────────────────────
 
 trait RemoveFileHandler {
     fn on_is_dir(
@@ -1784,9 +1741,8 @@ impl crate::shell::interpreter::ShellTaskCtx for ShellRmTask {
     const TASK_OFFSET: usize = core::mem::offset_of!(Self, task);
     fn run_from_thread_pool(_this: &mut Self) {
         // Not reached: `ShellRmTask::schedule` installs `work_pool_callback`
-        // directly (rm.zig does NOT use `InnerShellTask` — the generic
-        // trampoline auto-posts back, which would race the recursive DirTask
-        // tree's own `finish_concurrently`).
+        // directly (the generic trampoline auto-posts back, which would race
+        // the recursive DirTask tree's own `finish_concurrently`).
         debug_assert!(
             false,
             "ShellRmTask scheduled via ShellTask::schedule; use ShellRmTask::schedule"
@@ -1797,5 +1753,3 @@ impl crate::shell::interpreter::ShellTaskCtx for ShellRmTask {
         Self::run_from_main_thread(this, interp)
     }
 }
-
-// ported from: src/shell/builtin/rm.zig
diff --git a/src/runtime/shell/builtin/seq.rs b/src/runtime/shell/builtin/seq.rs
index cee97b29ae3..a383c157f13 100644
--- a/src/runtime/shell/builtin/seq.rs
+++ b/src/runtime/shell/builtin/seq.rs
@@ -162,9 +162,8 @@ impl Seq {
 
     fn do_(interp: &Interpreter, cmd: NodeId) -> Yield {
         let needs_io = Builtin::of(interp, cmd).stdout.needs_io().is_some();
-        // PORT NOTE: reshaped for borrowck — render entirely into a local
-        // Vec, then either enqueue it or write_no_io it. Zig wrote each
-        // number directly when !needs_io; we buffer once for simplicity.
+        // Render entirely into a local Vec, then either enqueue it or
+        // write_no_io it; we buffer once for simplicity.
         let (start, end, incr, sep, term) = {
             let me = Self::state_mut(interp, cmd);
             (me.start, me.end, me.increment, me.separator, me.terminator)
@@ -176,7 +175,8 @@ impl Seq {
         } else {
             current >= end
         } {
-            // TODO(port): verify Rust `{}` f32 formatting matches Zig `{d}`.
+            // Rust `{}` for f32 prints the shortest decimal that round-trips
+            // (no exponent, no trailing ".0").
             let _ = write!(&mut out, "{}", current);
             out.extend_from_slice(sep.slice());
             let next = current + incr;
@@ -196,7 +196,7 @@ impl Seq {
             Self::state_mut(interp, cmd).buf = out;
             let safeguard = Builtin::of(interp, cmd).stdout.needs_io().unwrap();
             let child = ChildPtr::new(cmd, WriterTag::Builtin);
-            // PORT NOTE: reshaped for borrowck — clone the slice so the &mut
+            // NOTE: reshaped for borrowck — clone the slice so the &mut
             // on stdout doesn't alias `buf`.
             let buf = Self::state_mut(interp, cmd).buf.clone();
             return Builtin::of_mut(interp, cmd)
@@ -232,5 +232,3 @@ impl Seq {
 fn parse_f32(bytes: &[u8]) -> Option<f32> {
     bun_core::fmt::parse_f32(bytes)
 }
-
-// ported from: src/shell/builtin/seq.zig
diff --git a/src/runtime/shell/builtin/touch.rs b/src/runtime/shell/builtin/touch.rs
index bd9571b4774..6faa724faa1 100644
--- a/src/runtime/shell/builtin/touch.rs
+++ b/src/runtime/shell/builtin/touch.rs
@@ -148,8 +148,6 @@ impl Touch {
         Self::next(interp, cmd)
     }
 
-    /// Spec: touch.zig `onShellTouchTaskDone`.
-    ///
     /// # Safety
     /// `task` must be a live heap allocation produced by
     /// [`ShellTouchTask::create`]; ownership is reclaimed here.
@@ -242,8 +240,7 @@ impl OutputTaskVTable for Touch {
     }
 }
 
-/// Spec: touch.zig `ShellTouchTask`. utimes() the path (creating it on
-/// ENOENT) on a worker thread.
+/// utimes() the path (creating it on ENOENT) on a worker thread.
 pub struct ShellTouchTask {
     pub cmd: NodeId,
     pub opts: Opts,
@@ -274,7 +271,7 @@ impl ShellTouchTask {
         bun_core::heap::into_raw(task)
     }
 
-    /// Spec: touch.zig `runFromThreadPool`. utimes() the path; on ENOENT
+    /// utimes() the path; on ENOENT
     /// fall back to `open(O_CREAT|O_WRONLY, 0o664)`.
     pub fn run_from_thread_pool(this: &mut ShellTouchTask) {
         use bun_paths::resolve_path::{self, Platform, platform};
@@ -292,9 +289,8 @@ impl ShellTouchTask {
             )
         };
 
-        // Zig went via `NodeFS{}.utimes(args, .sync)`; that wrapper just
-        // forwards to `Syscall.utimens` (uv_fs_utime on Windows), so call
-        // the bun_sys layer directly to avoid the heavyweight NodeFS state.
+        // Call the bun_sys layer directly (uv_fs_utime on Windows) to avoid
+        // the heavyweight NodeFS state.
         let milliseconds = bun_core::time::milli_timestamp();
         let atime = bun_sys::TimeLike {
             sec: milliseconds.div_euclid(1_000),
@@ -320,7 +316,7 @@ impl ShellTouchTask {
             }
         }
         // Worker→main bounce-back is posted by `shell_task_trampoline` after
-        // this returns (Zig: `event_loop.enqueueTaskConcurrent(...)`).
+        // this returns.
     }
 
     /// # Safety
@@ -395,5 +391,3 @@ impl FlagParser for Opts {
         }
     }
 }
-
-// ported from: src/shell/builtin/touch.zig
diff --git a/src/runtime/shell/builtin/true_.rs b/src/runtime/shell/builtin/true_.rs
index 14485321124..378ced843f6 100644
--- a/src/runtime/shell/builtin/true_.rs
+++ b/src/runtime/shell/builtin/true_.rs
@@ -18,5 +18,3 @@ impl True {
         Yield::done()
     }
 }
-
-// ported from: src/shell/builtin/true_.zig
diff --git a/src/runtime/shell/builtin/which.rs b/src/runtime/shell/builtin/which.rs
index 6f734d48c99..0a395138006 100644
--- a/src/runtime/shell/builtin/which.rs
+++ b/src/runtime/shell/builtin/which.rs
@@ -195,7 +195,7 @@ impl Which {
     /// Look up `$PATH` from the export env and the cwd from the shell env.
     fn path_and_cwd(interp: &Interpreter, cmd: NodeId) -> (Vec<u8>, Vec<u8>) {
         let shell = Builtin::shell(interp, cmd);
-        // `EnvMap::get` refs the returned string; balance it (Zig: `defer PATH.deref()`).
+        // `EnvMap::get` refs the returned string; balance it.
         let path = shell
             .export_env
             .get(EnvStr::init_slice(b"PATH"))
@@ -212,11 +212,8 @@ impl Which {
         Builtin::of(interp, cmd).arg_bytes(idx).to_vec()
     }
 
-    /// Spec: which.zig — `bun.which(path_buf, PATH, cwd, arg)`.
     fn resolve(path_env: &[u8], cwd: &[u8], arg: &[u8]) -> Option<Vec<u8>> {
         let mut path_buf = bun_paths::path_buffer_pool::get();
         bun_which::which(&mut *path_buf, path_env, cwd, arg).map(|z| z.as_bytes().to_vec())
     }
 }
-
-// ported from: src/shell/builtin/which.zig
diff --git a/src/runtime/shell/builtin/yes.rs b/src/runtime/shell/builtin/yes.rs
index 16e3ae7986d..f8627dc5cc0 100644
--- a/src/runtime/shell/builtin/yes.rs
+++ b/src/runtime/shell/builtin/yes.rs
@@ -25,7 +25,7 @@ pub struct Yes {
     /// out to ~BUFSIZ.
     pub buffer: Vec<u8>,
     pub buffer_used: usize,
-    /// Zig: `task: YesTask = undefined` — populated in `start()`.
+    /// Populated in `start()`.
     pub task: Option<YesTask>,
 }
 
@@ -60,7 +60,6 @@ impl Yes {
         let mut copies = bufalloc / copysize;
         while copies > 1 {
             let to_copy = copysize.min(bufalloc - filled);
-            // PORT NOTE: Zig @memcpy on disjoint subslices → copy_within.
             buf.copy_within(0..to_copy, filled);
             filled += to_copy;
             copies -= 1;
@@ -89,15 +88,11 @@ impl Yes {
     }
 
     /// Write 4 chunks then bounce to the event loop so we don't hog the main
-    /// thread. Spec: yes.zig `writeNoIO`.
+    /// thread.
     fn write_no_io_loop(interp: &Interpreter, cmd: NodeId) -> Yield {
-        // Spec: yes.zig `writeOnceNoIO` — `.err` arm formats via
-        // `fmtErrorArena(.yes, "{s}\n", .{e.name()})` and routes through
-        // `writeFailingError`.
-        //
         // Split-borrow the Cmd so the tiled buffer (in `impl_`) and `stdout`
-        // are accessible simultaneously — Zig passes `this.buffer[0..]`
-        // zero-copy, and matching that matters for `yes` throughput.
+        // are accessible simultaneously — the buffer is written zero-copy,
+        // which matters for `yes` throughput.
         let err = {
             let cmd_node = interp.as_cmd_mut(cmd);
             let shell = cmd_node.base.shell;
@@ -147,7 +142,7 @@ impl Yes {
     ) -> Yield {
         let child = ChildPtr::new(cmd, WriterTag::Builtin);
         // `stdout` and `impl_` are disjoint fields of `Builtin` — split-borrow
-        // so the tiled buffer is enqueued zero-copy (Zig passes a slice).
+        // so the tiled buffer is enqueued zero-copy.
         let (stdout, yes) = Self::split_stdout_state(Builtin::of_mut(interp, cmd));
         stdout.enqueue(child, &yes.buffer[..yes.buffer_used], safeguard)
     }
@@ -169,8 +164,8 @@ impl Yes {
         e: Option<bun_sys::SystemError>,
     ) -> Yield {
         if let Some(e) = e {
-            // Spec: yes.zig `defer e.deref()` — release the SystemError's
-            // owned BunString fields (no `Drop` impl on `bun_sys::SystemError`).
+            // Release the SystemError's owned BunString fields (no `Drop`
+            // impl on `bun_sys::SystemError`).
             e.deref();
             Self::state_mut(interp, cmd).state = State::Err;
             return Builtin::done(interp, cmd, 1);
@@ -193,16 +188,14 @@ impl Yes {
     }
 }
 
-// PORT NOTE: Zig `deinit` freed `buffer` and ended the alloc scope. In the
-// Rust port `buffer: Vec<u8>` drops with the owning `Box<Yes>`; no explicit
-// `Drop` impl needed (PORTING.md §Allocators).
+// `buffer: Vec<u8>` drops with the owning `Box<Yes>`; no explicit `Drop` impl
+// needed (PORTING.md §Allocators).
 
 /// Re-queues `yes` onto the event loop after a burst of no-IO writes so we
-/// don't block the main thread forever. Spec: yes.zig `YesTask`.
+/// don't block the main thread forever.
 #[repr(C)]
 pub struct YesTask {
-    /// Back-ref to the owning [`Interpreter`] (NodeId-arena port replaces
-    /// Zig's `container_of` chain).
+    /// Back-ref to the owning [`Interpreter`].
     pub interp: *mut Interpreter,
     pub cmd: NodeId,
     pub evtloop: EventLoopHandle,
@@ -214,8 +207,6 @@ impl Taskable for YesTask {
 }
 
 impl YesTask {
-    /// Spec: yes.zig `YesTask.enqueue`.
-    ///
     /// # Safety
     /// `this` must point to a live `YesTask` whose storage is stable until the
     /// enqueued task fires (it lives inside `Box<Yes>` in the interpreter
@@ -250,8 +241,6 @@ impl YesTask {
         }
     }
 
-    /// Spec: yes.zig `YesTask.runFromMainThread`.
-    ///
     /// `this` must be a live `YesTask` whose storage is stable inside
     /// `Box<Yes>` in the interpreter arena, with `interp` initialised by
     /// [`Yes::start`]. Reached only via the concurrent-task dispatch installed
@@ -262,7 +251,7 @@ impl YesTask {
         Yes::write_no_io_loop(interp, cmd).run(interp);
     }
 
-    /// Spec: yes.zig `YesTask.runFromMainThreadMini`. Signature matches
+    /// Signature matches
     /// [`AnyTaskWithExtraContext::from`](bun_event_loop::AnyTaskWithExtraContext::AnyTaskWithExtraContext::from)'s
     /// callback shape (`fn(*mut T, *mut ())`).
     fn run_from_main_thread_mini(this: *mut Self, _: *mut ()) {
@@ -271,5 +260,3 @@ impl YesTask {
         Self::run_from_main_thread(unsafe { &*this })
     }
 }
-
-// ported from: src/shell/builtin/yes.zig
diff --git a/src/runtime/shell/dispatch_tasks.rs b/src/runtime/shell/dispatch_tasks.rs
index b4c4b70180f..ad65e64d9f0 100644
--- a/src/runtime/shell/dispatch_tasks.rs
+++ b/src/runtime/shell/dispatch_tasks.rs
@@ -1,22 +1,18 @@
 //! Forward-decl shell task types referenced by `runtime::dispatch::run_task`.
 //!
-//! The Zig spec (`src/jsc/Task.zig`) names ~16 shell task structs in its
-//! 96-arm switch. The Rust shell port collapsed several into the NodeId-arena
-//! state machine (`interpreter.rs`) and gated the rest behind
-//! `interpreter_body_gated.rs`. The high-tier dispatcher must still cast the
-//! erased `Task.ptr` to a concrete type and call the per-type entry point, so
-//! the shapes are declared here. Bodies that already exist elsewhere re-export
-//! through this module; the rest carry the spec-faithful body inline (mostly
-//! `runFromMainThread()` → resume the parent state via NodeId).
-//!
-//! Spec: `src/shell/interpreter.zig` + per-builtin `src/shell/interpreter/*.zig`.
+//! Several shell task types collapsed into the NodeId-arena state machine
+//! (`interpreter.rs`); the rest are gated behind `interpreter_body_gated.rs`.
+//! The high-tier dispatcher must still cast the erased `Task.ptr` to a
+//! concrete type and call the per-type entry point, so the shapes are
+//! declared here. Bodies that already exist elsewhere re-export through this
+//! module; the rest carry the body inline (mostly `run_from_main_thread()` →
+//! resume the parent state via NodeId).
 
 use crate::shell::interpreter::{Interpreter, NodeId, ShellTask};
 use bun_jsc::ConcurrentTask::ConcurrentTask;
 
 /// Task payload for [`ShellAsync`](crate::shell::states::r#async::Async)'s
-/// bounce back to the main thread. In Zig the `Async` state struct *is* the
-/// task; in the Rust NodeId-arena port the state lives in `interp.nodes`, so
+/// bounce back to the main thread. The state lives in `interp.nodes`, so
 /// the enqueued payload is `(interp, node)`.
 #[repr(C)]
 pub(crate) struct ShellAsyncTask {
@@ -25,7 +21,7 @@ pub(crate) struct ShellAsyncTask {
     pub concurrent_task: ConcurrentTask,
 }
 
-/// Spec: `Interpreter.Cmd.ShellAsyncSubprocessDone`. Posted from the
+/// Posted from the
 /// subprocess exit handler back to the JS thread to resume the owning `Cmd`.
 #[repr(C)]
 pub(crate) struct ShellAsyncSubprocessDone {
@@ -36,8 +32,6 @@ pub(crate) struct ShellAsyncSubprocessDone {
 }
 
 impl ShellAsyncSubprocessDone {
-    /// Spec: interpreter.zig `ShellAsyncSubprocessDone.runFromMainThread`.
-    ///
     /// Reached only via `runtime::dispatch::run_task` for
     /// `task_tag::ShellAsyncSubprocessDone`, which always passes the
     /// `heap::alloc` payload enqueued by `ShellSubprocess::on_process_exit`.
@@ -62,7 +56,7 @@ impl ShellAsyncSubprocessDone {
     }
 }
 
-/// Spec: `Interpreter.AsyncDeinitWriter` (`IOWriter.AsyncDeinit`). Defers
+/// Defers
 /// dropping an [`IOWriter`](crate::shell::io_writer::IOWriter) to the main
 /// thread so its `Drop` doesn't race the writer thread.
 #[repr(C)]
@@ -90,7 +84,8 @@ impl AsyncDeinitWriter {
     }
 }
 
-/// Spec: `Interpreter.AsyncDeinitReader` (`IOReader.AsyncDeinit`).
+/// Defers dropping an [`IOReader`](crate::shell::io_reader::IOReader) to the
+/// main thread so its `Drop` doesn't race the reader thread.
 #[repr(C)]
 pub(crate) struct AsyncDeinitReader {
     pub reader: *mut crate::shell::io_reader::IOReader,
@@ -116,8 +111,8 @@ impl AsyncDeinitReader {
     }
 }
 
-/// Spec: `Interpreter.CondExpr.ShellCondExprStatTask`. Wraps an inner
-/// [`ShellTask`] (the Zig spec dispatches via `.task.runFromMainThread()`).
+/// Stat task backing shell conditional expressions (`[ -f x ]` etc.). Wraps an
+/// inner [`ShellTask`].
 #[repr(C)]
 pub(crate) struct ShellCondExprStatTask {
     pub task: CondExprStatInner,
@@ -129,6 +124,10 @@ pub(crate) struct CondExprStatInner {
     pub cond: NodeId,
     pub stat: bun_sys::Result<bun_sys::Stat>,
     pub path: Vec<u8>,
+    /// The shell env's cwd fd, captured at schedule time so
+    /// `run_from_thread_pool` can
+    /// `statat` without touching the interpreter off-thread.
+    pub cwd_fd: bun_sys::Fd,
 }
 
 impl ShellCondExprStatTask {
@@ -150,13 +149,13 @@ impl ShellCondExprStatTask {
     }
 }
 
-/// Spec: `Interpreter.Expansion.ShellGlobTask.Err`.
+/// Error result of a glob-expansion task.
 pub enum ShellGlobErr {
     Syscall(bun_sys::Error),
     Unknown(bun_core::Error),
 }
 
-/// Spec: `Interpreter.Expansion.ShellGlobTask`.
+/// Glob-expansion task run off the JS thread during word expansion.
 #[repr(C)]
 pub(crate) struct ShellGlobTask {
     pub task: ShellTask,
@@ -195,7 +194,8 @@ impl crate::shell::interpreter::ShellTaskCtx for ShellGlobTask {
 }
 
 impl ShellGlobTask {
-    /// Spec: Expansion.zig `ShellGlobTask.createOnMainThread` + `schedule`.
+    /// Heap-allocate the glob task for `expansion` and schedule it on the
+    /// work pool; the allocation is freed in `run_from_main_thread`.
     pub(crate) fn create_and_schedule(
         interp: &Interpreter,
         expansion: NodeId,
@@ -215,7 +215,6 @@ impl ShellGlobTask {
         unsafe { ShellTask::schedule::<ShellGlobTask>(this) };
     }
 
-    /// Spec: Expansion.zig `ShellGlobTask.walkImpl`.
     fn walk_impl(
         walker: &mut bun_glob::BunGlobWalkerZ,
         result: &mut Vec<Vec<u8>>,
@@ -243,11 +242,9 @@ impl ShellGlobTask {
     }
 }
 
-/// Spec: `Interpreter.Builtin.Rm.ShellRmTask.DirTask`. A child node in the
+/// A child node in the
 /// recursive rm tree-walk; posts back to main when its subtree is empty.
 /// Re-export: the real DirTask lives in `builtins::rm` (full recursive
 /// tree-walk node). `dispatch.rs` calls `ShellRmDirTask::run_from_main_thread`
 /// for the verbose-write bounce-back.
 pub use crate::shell::builtins::rm::DirTask as ShellRmDirTask;
-
-// ported from: src/shell/interpreter.zig
diff --git a/src/runtime/shell/interpreter.rs b/src/runtime/shell/interpreter.rs
index 3afc49f4dfe..693b33fa798 100644
--- a/src/runtime/shell/interpreter.rs
+++ b/src/runtime/shell/interpreter.rs
@@ -7,27 +7,22 @@
 //!    performance reasons and also to leverage Bun's existing IO/FS code
 //! 2. We try to use non-blocking IO operations as much as possible so the
 //!    shell does not block the main JS thread
-//! 3. The Zig original has no coroutines
 //!
 //! The idea is that this is a tree-walking interpreter — except instead of
 //! iteratively walking the AST, we build a tree of state-machine nodes so we
 //! can suspend/resume without blocking the main thread, driven in
 //! continuation-passing style by `Yield::run`.
 //!
-//! ## NodeId arena (Rust port)
+//! ## NodeId arena
 //!
-//! In Zig every state-machine node holds a `*Parent` back-pointer and calls
-//! `parent.childDone(this, exit)`. That pattern is borrow-checker hostile in
-//! Rust (overlapping `&mut` of parent and child).
+//! A parent/child back-pointer tree would be borrow-checker hostile
+//! (overlapping `&mut` of parent and child), so all state nodes live in a
+//! flat `Vec<Node>` owned by the `Interpreter`. Nodes refer to each other
+//! (and to their parent) by `NodeId` — a `u32` index. Dispatch is a single
+//! hoisted `match` on the parent's tag (`Interpreter::child_done`), which
+//! keeps the per-tick hot path inlined (see PORTING.md §Dispatch hot-path).
 //!
-//! The Rust port stores all state nodes in a flat `Vec<Node>` owned by the
-//! `Interpreter`. Nodes refer to each other (and to their parent) by `NodeId`
-//! — a `u32` index. Dispatch is a single hoisted `match` on the parent's tag
-//! (`Interpreter::child_done`), which keeps the per-tick hot path inlined the
-//! same way Zig's `inline else` did (see PORTING.md §Dispatch hot-path).
-//!
-//! State methods that previously took `(&mut self)` and reached into
-//! `self.parent` now take `(&mut Interpreter, this: NodeId)` and look their
+//! State methods take `(&mut Interpreter, this: NodeId)` and look their
 //! own data up via `interp.node_mut(this)` / `interp.nodes[this]`.
 
 use bun_collections::VecExt;
@@ -76,8 +71,7 @@ pub(crate) use shell_log as log;
 // NodeId arena
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Index into `Interpreter::nodes`. Replaces every `*Parent` / `*Child`
-/// back-pointer in the Zig state-machine tree.
+/// Index into `Interpreter::nodes`.
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct NodeId(pub u32);
@@ -105,8 +99,7 @@ impl fmt::Display for NodeId {
     }
 }
 
-/// One slot in the interpreter's state arena. The Zig version heap-allocated
-/// each state struct individually via `parent.create(T)`; in Rust they all
+/// One slot in the interpreter's state arena. All state structs
 /// live as enum variants in a single `Vec<Node>` so the only outstanding
 /// borrow at any time is `&mut Interpreter`.
 pub enum Node {
@@ -144,7 +137,7 @@ impl Node {
     }
 
     /// Every state struct embeds a `Base` header at a known field; this is the
-    /// hoisted accessor (replaces Zig's structural duck-typing on `.base`).
+    /// hoisted accessor.
     pub fn base(&self) -> Option<&Base> {
         match self {
             Node::Free => None,
@@ -181,7 +174,7 @@ impl Node {
 }
 
 /// Generate `Interpreter::as_<kind>{,_mut}` typed accessors. These panic on
-/// tag mismatch — same contract as Zig's `child.as(Ty).?`.
+/// tag mismatch.
 macro_rules! node_accessors {
     ($($variant:ident => $ty:ty, $get:ident, $get_mut:ident);* $(;)?) => {
         impl Interpreter {
@@ -236,10 +229,11 @@ node_accessors! {
 pub type ExitCode = u16;
 pub type Pipe = [Fd; 2];
 
-/// Stand-in for the shell's `SmolList<T, N>` (inline small-vec). The real
-/// implementation lives in `shell_body.rs` (gated); state nodes only need
-/// `push`/`len`/indexing, which `Vec` provides.
-// TODO(port): replace with shell_body::SmolList once parser un-gates.
+/// Stand-in for the shell's `SmolList<T, N>` (inline small-vec). The parser's
+/// `bun_shell_parser::parse::SmolList` is arena-backed (its heap variant
+/// allocates from the parse arena, which the interpreter frees eagerly — see
+/// `take_args`), so it cannot back long-lived interpreter fields like
+/// `async_pids`. `Vec` is the deliberate choice here.
 pub type SmolList<T, const N: usize> = Vec<T>;
 
 #[repr(u8)]
@@ -306,12 +300,16 @@ pub struct Interpreter {
 
     pub args: JsCell<Box<ShellArgs>>,
 
-    /// JS objects used as input for the shell script. Owned storage (the Zig
-    /// `ArrayList(JSValue).items` borrow becomes `Vec` ownership in the port —
-    /// `create_shell_interpreter` moves the parsed-script's vec in here).
-    // TODO(port): GC root — bare JSValue heap storage is invisible to the
-    // conservative stack scan. Switch to MarkedArgumentBuffer or root via the
-    // wrapper's visitChildren.
+    /// JS objects used as input for the shell script. Owned storage —
+    /// `create_shell_interpreter` moves the parsed-script's vec in here.
+    ///
+    /// GC liveness: this `Vec` is heap storage invisible to the conservative
+    /// scan, but it is a duplicate of a rooted copy — `Bun__createShellInterpreter`
+    /// (ShellBindings.cpp) copies the same values into the C++
+    /// `JSShellInterpreter` wrapper's `jsvalueArray` (`valuesArray: true` in
+    /// Shell.classes.ts), which the generated `visitChildren` visits. The
+    /// wrapper outlives the run (`this_jsvalue` + `hasPendingActivity`), and
+    /// the mini-event-loop path always passes an empty vec.
     pub jsobjs: Vec<crate::jsc::JSValue>,
 
     pub root_shell: JsCell<ShellExecEnv>,
@@ -376,15 +374,14 @@ pub enum CleanupState {
 // ────────────────────────────────────────────────────────────────────────────
 
 impl ShellArgs {
-    /// Spec: interpreter.zig `ShellArgs.init` — fresh arena + zeroed AST.
     /// Heap-allocated (returned as `Box`) because the interpreter stores
     /// `Box<ShellArgs>` and state nodes hold `*const ast::*` into the arena;
     /// the box must not move once `parse()` has filled `script_ast`.
     pub fn init() -> Box<ShellArgs> {
         Box::new(ShellArgs {
             __arena: bun_alloc::Arena::new(),
-            // Zig: `.script_ast = undefined` — overwritten by `parse()` before
-            // `run()`. An empty stmt list is a safe placeholder.
+            // Overwritten by `parse()` before `run()`. An empty stmt list is
+            // a safe placeholder.
             script_ast: ast::Script { stmts: &[] },
         })
     }
@@ -421,9 +418,7 @@ impl ShellArgs {
         self.script_ast = ast::Script { stmts };
     }
 
-    /// Spec: interpreter.zig `ShellArgs.memoryCost`.
-    /// PORT NOTE: Zig walks `script_ast.memoryCost()`; the Rust port reports
-    /// the arena's `allocated_bytes()` instead (a superset — tokens + strpool
+    /// Reports the arena's `allocated_bytes()` (a superset — tokens + strpool
     /// + AST nodes). This is for GC `estimatedSize` reporting only, where
     /// over-approximation is preferable to a tree walk on a lifetime-erased
     /// AST mirror.
@@ -432,14 +427,12 @@ impl ShellArgs {
     }
 }
 
-/// `shell.Result(T)` — Zig's `union(enum) { result: T, err: ShellErr }`.
 /// Only used by the construction path (`Interpreter::init`).
 pub type ShellResult<T> = Result<T, ShellErr>;
 
 impl Interpreter {
-    /// Spec: interpreter.zig `ThisInterpreter.parse` — lex `src` (ASCII or
-    /// Unicode), build a `Parser`, and return the root `ast::Script`. Tokens
-    /// and AST nodes are bump-allocated into `arena`.
+    /// Lex `src` (ASCII or Unicode), build a `Parser`, and return the root
+    /// `ast::Script`. Tokens and AST nodes are bump-allocated into `arena`.
     ///
     /// On lex error, `out_lex_err` is populated and `ParseError::Lex` returned
     /// so the caller can `combineErrors()` for diagnostics; on parse error
@@ -481,8 +474,6 @@ impl Interpreter {
         out_parser.as_mut().unwrap().parse()
     }
 
-    /// Spec: interpreter.zig `ThisInterpreter.init` + `initImpl`.
-    ///
     /// Builds the root `ShellExecEnv` (export env from the event loop's
     /// `DotEnv::Loader`, cwd from `getcwd()`, cwd_fd from `open(O_DIRECTORY)`),
     /// dups stdin into an `IOReader`, and heap-allocates the interpreter.
@@ -490,12 +481,12 @@ impl Interpreter {
     /// `run()`) upgrades them to real `IOWriter`s unless `quiet` was set.
     ///
     /// On success the returned box owns `shargs`; on error `shargs` is
-    /// dropped (Zig: `defer shargs.deinit()` in the caller).
+    /// dropped.
     ///
-    /// PORT NOTE: `allocator` parameter dropped (always global mimalloc).
-    /// `ctx` is stored for `bun run` argv access from builtins (Zig
-    /// `command_ctx`); held as a raw pointer because the interpreter outlives
-    /// any single `&mut ContextData` borrow.
+    /// Note: `allocator` parameter dropped (always global mimalloc).
+    /// `ctx` is stored for `bun run` argv access from builtins; held as a raw
+    /// pointer because the interpreter outlives any single `&mut ContextData`
+    /// borrow.
     // `ShellErr` is the shared shell-wide error type defined in `shell_body.rs`;
     // boxing it here would change `pub fn` signatures across every
     // `?`-propagating shell caller.
@@ -509,7 +500,7 @@ impl Interpreter {
         cwd_: Option<&[u8]>,
     ) -> ShellResult<Box<Interpreter>> {
         // ── export_env ─────────────────────────────────────────────────────
-        // Zig: on `.js` event loop, take `export_env_` (or empty); on `.mini`,
+        // On the `.js` event loop, take `export_env_` (or empty); on `.mini`,
         // populate from `event_loop.env()` (the loop's `DotEnv::Loader`).
         let export_env = if matches!(event_loop, EventLoopHandle::Js { .. }) {
             export_env_.unwrap_or_else(EnvMap::init)
@@ -530,17 +521,15 @@ impl Interpreter {
 
         // ── cwd / cwd_fd ───────────────────────────────────────────────────
         // Hoisted PathBuffer so the error's borrowed `.path` stays valid until
-        // we've converted it to an owned `ShellErr` (Zig hoists for the same
-        // reason). Heap-pooled (not stack) per spec — on Windows
-        // `MAX_PATH_BYTES` is ~96 KiB and `init` runs from JS-triggered paths
-        // that may already be deep on the stack (interpreter.zig:913-914).
+        // we've converted it to an owned `ShellErr`. Heap-pooled (not stack) —
+        // on Windows `MAX_PATH_BYTES` is ~96 KiB and `init` runs from
+        // JS-triggered paths that may already be deep on the stack.
         let mut pathbuf = bun_paths::path_buffer_pool::get();
         let cwd_len = match bun_sys::getcwd(&mut pathbuf[..]) {
             Ok(n) => n,
             Err(e) => return Err(ShellErr::new_sys(&e)),
         };
-        // NUL-terminate for `open()` and so `__cwd` matches Zig's `[:0]` shape
-        // (downstream `cwd()` strips the trailing 0).
+        // NUL-terminate for `open()`; downstream `cwd()` strips the trailing 0.
         pathbuf[cwd_len] = 0;
         let cwd_z = bun_core::ZStr::from_buf(pathbuf.as_slice(), cwd_len);
 
@@ -556,7 +545,6 @@ impl Interpreter {
         // ── stdin ──────────────────────────────────────────────────────────
         log!("Duping stdin");
         let stdin_fd_res = if bun_core::output::stdio::is_stdin_null() {
-            // Zig `bun.sys.openNullDevice()`.
             #[cfg(unix)]
             {
                 bun_sys::open(
@@ -616,13 +604,8 @@ impl Interpreter {
             async_commands_executing: Cell::new(0),
             global_this: Cell::new(core::ptr::null_mut()),
             flags: Cell::new(InterpreterFlags::default()),
-            // PORT NOTE — intentional spec-bug fix: Zig declares
-            // `exit_code: ?ExitCode = 0` (the *non-null* value 0), so its
-            // `asyncCmdDone`'s `exit_code != null` check is always true and
-            // can fire `finish(0)` before the root script has actually
-            // returned. Rust starts at `None` so `async_cmd_done` only
-            // finishes once `on_root_child_done` has recorded the real exit
-            // code. The matching Zig fix is tracked upstream.
+            // Starts at `None` so `async_cmd_done` only finishes once
+            // `on_root_child_done` has recorded the real exit code.
             exit_code: Cell::new(None),
             this_jsvalue: Cell::new(crate::jsc::JSValue::ZERO),
             cleanup_state: Cell::new(CleanupState::NeedsFullCleanup),
@@ -639,20 +622,16 @@ impl Interpreter {
             r.set_interp(interp_ptr);
         }
 
-        // ── optional cwd override (Zig `init` tail) ────────────────────────
+        // ── optional cwd override ───────────────────────────────────────────
         if let Some(c) = cwd_ {
-            // Spec interpreter.zig:921-930: `root_shell.changeCwdImpl(interp,
-            // c, true)`; on failure, deref root_io + deinit root_shell + free.
-            // The interpreter parameter is unused (`_` in spec) so we don't
-            // pass it (avoids the obvious self-borrow).
+            // On failure, deref root_io + deinit root_shell + free.
             if let Err(e) = interpreter
                 .root_shell
                 .with_mut(|rs| rs.change_cwd_impl(c, true))
             {
-                // Spec: `root_io.deref(); root_shell.deinitImpl(false, true);
-                // allocator.destroy(interpreter)`. `deinit_from_exec` performs
-                // exactly that teardown (drops `root_io` Arcs, frees env maps,
-                // closes `cwd_fd`, consumes the box).
+                // `deinit_from_exec` performs the full teardown (drops
+                // `root_io` Arcs, frees env maps, closes `cwd_fd`, consumes
+                // the box).
                 interpreter.deinit_from_exec();
                 return Err(ShellErr::new_sys(&e));
             }
@@ -661,24 +640,21 @@ impl Interpreter {
         Ok(interpreter)
     }
 
-    /// Spec: interpreter.zig `#deinitFromExec` — full teardown for the
-    /// standalone (`MiniEventLoop`) path. Drops root IO refcounts, frees the
-    /// root shell env, and consumes the box.
+    /// Full teardown for the standalone (`MiniEventLoop`) path. Drops root IO
+    /// refcounts, frees the root shell env, and consumes the box.
     fn deinit_from_exec(self) {
         log!("deinit interpreter");
         self.this_jsvalue.set(crate::jsc::JSValue::ZERO);
         // `root_io` holds `Arc<IOReader>`/`Arc<IOWriter>`; replacing with
-        // default drops the refs (Zig: `root_io.deref()`).
+        // default drops the refs.
         self.root_io.set(IO::default());
-        // Spec: `root_shell.deinitImpl(false, true)` — free buffered IO, env
+        // Free buffered IO, env
         // maps, cwd fd; do NOT free the struct itself (it's embedded).
         self.root_shell.with_mut(|rs| rs.deinit_embedded(true));
-        // `vm_args_utf8` slices Drop themselves (ZigStringSlice has a Drop
+        // `vm_args_utf8` slices Drop themselves (`ZigStringSlice` has a Drop
         // impl that derefs the WTF backing); the Vec frees on box drop.
     }
 
-    /// Spec: interpreter.zig `initAndRunFromFile`.
-    ///
     /// Standalone-shell entrypoint for `bun <file>.sh`: parse `src` (already
     /// read by the caller), construct an interpreter on a `MiniEventLoop`,
     /// drive it to completion, and return the exit code. Differs from
@@ -694,16 +670,14 @@ impl Interpreter {
         Self::init_and_run_impl(ctx, mini, bun_paths::basename(path), src, None, false)
     }
 
-    /// Spec: interpreter.zig `initAndRunFromSource`.
-    ///
     /// Standalone-shell entrypoint for `bun run <script>` / `bun exec` when
     /// `--shell=bun`: parse `src`, construct an interpreter on a
     /// `MiniEventLoop`, drive it to completion via `mini.tick()`, and return
     /// the script's exit code. `path_for_errors` is only used in diagnostics.
     ///
     /// On any init/parse/run error this prints to stderr and `exit(1)`s
-    /// directly (matching Zig); the `Result` only carries lexer/parser
-    /// errors that escaped without a diagnostic (Zig `return err`).
+    /// directly; the `Result` only carries lexer/parser errors that escaped
+    /// without a diagnostic.
     pub fn init_and_run_from_source(
         ctx: &mut bun_options_types::context::ContextData,
         mini: &'static mut bun_event_loop::MiniEventLoop::MiniEventLoop<'static>,
@@ -717,7 +691,7 @@ impl Interpreter {
     /// Shared body for `init_and_run_from_file` / `init_and_run_from_source`.
     /// `from_source` gates the analytics bump and the extra "script " word in
     /// the parse-error diagnostic — the only two behavioural deltas between
-    /// the two Zig spec functions.
+    /// the two entrypoints.
     fn init_and_run_impl(
         ctx: &mut bun_options_types::context::ContextData,
         mini: &'static mut bun_event_loop::MiniEventLoop::MiniEventLoop<'static>,
@@ -801,9 +775,8 @@ impl Interpreter {
         }
 
         // ── tick until done ────────────────────────────────────────────────
-        // Zig: `mini.tick(&is_done, IsDone.isDone)` where `isDone` reads
-        // `interp.flags.done`. The closure captures a raw pointer so borrowck
-        // doesn't see an overlap with `tick`'s `&mut self` on `mini`.
+        // The closure captures a raw pointer so borrowck doesn't see an
+        // overlap with `tick`'s `&mut self` on `mini`.
         let interp_ptr: *const Interpreter = &raw const *interp;
         mini.tick(core::ptr::null_mut(), |_ctx| {
             // SAFETY: `interp` lives in this stack frame for the whole tick
@@ -820,18 +793,13 @@ impl Interpreter {
 
 // ──────────────────────────────────────────────────────────────────────────
 // shell_state_dispatch! — single source of truth for the StateKind→handler
-// table. Zig (`interpreter.zig:1527 StatePtrUnion`) derives `start`/`next`/
-// `childDone` from one `inline for (tags)` over a comptime type tuple; the
-// Rust port hand-unrolled that into three parallel 11-arm matches. This
-// macro restores the single-table property: each row declares
-// `Variant [=> HandlerType]` once and the macro emits `child_done`,
-// `next_node`, and `start_node`. Same precedent as `shell_builtins!`
-// (Builtin.rs).
+// table: each row declares `Variant [=> HandlerType]` once and the macro
+// emits `child_done`, `next_node`, and `start_node`. Same precedent as
+// `shell_builtins!` (Builtin.rs).
 //
-// PERF(port): expands to the *same* literal `match` arms as the hand-written
-// version — direct calls per arm so LLVM inlines the hot states
-// (Stmt/Pipeline/Cmd) exactly as Zig's `inline else` did. No vtable, no
-// extra indirection.
+// PERF: expands to literal `match` arms — direct calls per arm so LLVM
+// inlines the hot states (Stmt/Pipeline/Cmd). No vtable, no extra
+// indirection.
 //
 // Invoked once, inside `impl Interpreter` below. `deinit_node` is kept
 // hand-rolled for now (irregular Async/Free arms) — see the NOTE there.
@@ -846,8 +814,7 @@ macro_rules! shell_state_dispatch {
     // ── internal: emit the three dispatch fns from the normalized table ──
     (@norm [ $( ($v:ident, $h:ident) )+ ]) => {
         /// Signal to `parent` that `child` finished with `exit_code`. This is the
-        /// single hoisted `match` that replaces every per-state
-        /// `parent.childDone(this, exit)` call in Zig.
+        /// single hoisted `match` dispatching on the parent's state tag.
         pub fn child_done(&self, parent: NodeId, child: NodeId, exit_code: ExitCode) -> Yield {
             if parent == NodeId::INTERPRETER {
                 return self.on_root_child_done(child, exit_code);
@@ -919,9 +886,8 @@ impl Interpreter {
 
     // ── arena management ───────────────────────────────────────────────────
 
-    /// Allocate a fresh slot in the node arena and return its id. Replaces
-    /// Zig's `parent.create(T)` (which heap-allocated via the parent's
-    /// allocator). Reuses freed slots when available.
+    /// Allocate a fresh slot in the node arena and return its id. Reuses
+    /// freed slots when available.
     pub fn alloc_node(&self, node: Node) -> NodeId {
         if let Some(slot) = self.free_list.with_mut(|f| f.pop()) {
             // SAFETY: no other borrow of `nodes` is live across this store.
@@ -935,12 +901,12 @@ impl Interpreter {
         })
     }
 
-    /// Free a slot. Replaces Zig's `parent.destroy(this)`. The node's own
+    /// Free a slot. The node's own
     /// `deinit` (which closes IO, derefs the shell env, etc.) must run first;
     /// this only recycles the storage.
     pub fn free_node(&self, id: NodeId) {
         // Guard: callers may have stored `NodeId::NONE` in `currently_executing`
-        // when `spawn_expr` failed (Subshell init error path). Spec never
+        // when `spawn_expr` failed (Subshell init error path). Nothing
         // touches `currently_executing` on that path, so the later
         // `deinit_node`/`free_node` is a no-op there too.
         if id == NodeId::NONE || id == NodeId::INTERPRETER {
@@ -1016,12 +982,10 @@ impl Interpreter {
         Subshell,
     }
 
-    /// Init + start a child state node for an `ast::Expr`. Replaces the
-    /// per-variant `match` Zig inlines at each callsite (Stmt.zig:64-112,
-    /// Binary.zig:64-112). For `.subshell`, dupes the parent shell env first
-    /// (Zig `Subshell.initDupeShellState`); all other variants borrow `shell`.
+    /// Init + start a child state node for an `ast::Expr`. For `.subshell`,
+    /// dupes the parent shell env first; all other variants borrow `shell`.
     ///
-    /// Note: `Async` must NOT call this — Async.zig restricts its child to
+    /// Note: `Async` must NOT call this — `Async` restricts its child to
     /// pipeline/cmd/if/condexpr and inits without starting (see `Async::next`).
     pub fn spawn_expr(
         &self,
@@ -1038,7 +1002,7 @@ impl Interpreter {
             ast::Expr::If(i) => If::init(self, shell, *i, parent, io),
             ast::Expr::CondExpr(c) => CondExpr::init(self, shell, *c, parent, io),
             ast::Expr::Subshell(s) => {
-                // Zig `Subshell.initDupeShellState`: Stmt/Binary callers dupe
+                // Stmt/Binary callers dupe
                 // the env here so `Subshell::start`/`next` can use `base.shell`
                 // as-is. (Pipeline dupes itself and calls `Subshell::init`
                 // directly, so it does NOT go through this path.)
@@ -1048,13 +1012,10 @@ impl Interpreter {
                     Ok(id) => id,
                     Err(e) => {
                         self.throw(ShellErr::new_sys(&e));
-                        // Spec: Zig's `Binary.makeChild` returns `null` here and
-                        // the caller falls through as if the subshell exited 0
-                        // (Binary.zig:55-61, 130-134); Stmt.zig returns `.failed`
-                        // without touching `currently_executing`. Return `None`
-                        // so callers leave `currently_executing` unset — matches
-                        // the Zig fallthrough exactly (no `NodeId::NONE` sentinel
-                        // needed in `deinit_node`/`free_node` for this path).
+                        // Callers fall through as if the subshell exited 0.
+                        // Return `None` so callers leave `currently_executing`
+                        // unset (no `NodeId::NONE` sentinel needed in
+                        // `deinit_node`/`free_node` for this path).
                         return (None, Yield::failed());
                     }
                 }
@@ -1065,8 +1026,7 @@ impl Interpreter {
         (Some(child), y)
     }
 
-    /// Run the per-state cleanup, then recycle the slot. Replaces every
-    /// `child.deinit()` + `parent.destroy(child)` pair in Zig.
+    /// Run the per-state cleanup, then recycle the slot.
     pub fn deinit_node(&self, id: NodeId) {
         // Guard the `NodeId::NONE` sentinel: `spawn_expr` returns it on
         // Subshell init failure, and Stmt/Binary `currently_executing` may
@@ -1149,7 +1109,6 @@ impl Interpreter {
         self.root_io.get()
     }
 
-    /// Spec: interpreter.zig `#computeEstimatedSizeForGC` (interpreter.zig:752).
     pub fn compute_estimated_size_for_gc(&self) -> usize {
         let mut size = core::mem::size_of::<Interpreter>();
         size += self.args.get().memory_cost();
@@ -1164,12 +1123,11 @@ impl Interpreter {
         size
     }
 
-    /// Spec: interpreter.zig `memoryCost`.
     pub fn memory_cost(&self) -> usize {
         self.compute_estimated_size_for_gc()
     }
 
-    /// Spec: interpreter.zig `estimatedSize`. Codegen-called accessor.
+    /// Codegen-called accessor.
     pub fn estimated_size(&self) -> usize {
         self.estimated_size_for_gc.get()
     }
@@ -1191,9 +1149,9 @@ impl Interpreter {
         Some(crate::jsc::JSGlobalObject::opaque_ref(g))
     }
 
-    /// Spec: interpreter.zig `throwShellErr(err, event_loop)` — `mini` prints
-    /// and exits(1); `js` raises a JS exception. Dispatch on `global_this`
-    /// (set only on the JS event-loop path by `create_shell_interpreter`).
+    /// `mini` prints and exits(1); `js` raises a JS exception. Dispatch on
+    /// `global_this` (set only on the JS event-loop path by
+    /// `create_shell_interpreter`).
     pub fn throw(&self, err: ShellErr) {
         let Some(global) = self.global_this_ref() else {
             // Mini event loop — diverges (exit 1).
@@ -1204,8 +1162,7 @@ impl Interpreter {
 
     // ── run loop ───────────────────────────────────────────────────────────
 
-    /// Spec: interpreter.zig `setupIOBeforeRun` + `setupIOBeforeRunImpl`
-    /// (interpreter.zig:1177-1223). When `!quiet`, dup stdout/stderr (or open
+    /// When `!quiet`, dup stdout/stderr (or open
     /// the null device if the process was started with that stream closed),
     /// wrap each in an `IOWriter`, and install them as `root_io.stdout/stderr`
     /// so command output reaches the terminal. On the JS event loop the
@@ -1262,7 +1219,7 @@ impl Interpreter {
         // SAFETY: `interp_ptr` is the live `Interpreter` being initialized.
         stderr_writer.set_interp(interp_ptr);
 
-        // Spec: `if (event_loop == .js)` — hook captured buffers so the JS
+        // On the JS event loop, hook captured buffers so the JS
         // `Bun.$` API can read stdout/stderr after completion. The mini path
         // does not capture (it writes straight to the dup'd fd).
         let (cap_out, cap_err) = if matches!(event_loop, EventLoopHandle::Js { .. }) {
@@ -1308,10 +1265,9 @@ impl Interpreter {
             std::ptr::from_ref(self) as usize,
             exit_code
         );
-        // Spec interpreter.zig:1289 — `defer decrPendingActivityFlag(...)`
-        // unconditionally. Paired with the increment in `run_from_js`; harmless
-        // wrap on the mini path (flag is only read from the JS GC
-        // `hasPendingActivity()` hook).
+        // Decrement pending activity unconditionally on exit. Paired with the
+        // increment in `run_from_js`; harmless wrap on the mini path (flag is
+        // only read from the JS GC `hasPendingActivity()` hook).
         // R-2: `&self` lets the guard borrow the atomic directly — no raw-ptr
         // dance needed (the previous reshape existed only for `&mut self`).
         struct DecrOnDrop<'a>(&'a AtomicU32);
@@ -1369,7 +1325,7 @@ impl Interpreter {
         Yield::done()
     }
 
-    /// Spec: interpreter.zig `runFromJS`. JS-host entrypoint — sets up root IO
+    /// JS-host entrypoint — sets up root IO
     /// (unless quiet), spawns the root `Script` node, and starts ticking.
     pub fn run_from_js(
         &self,
@@ -1405,7 +1361,7 @@ impl Interpreter {
         Ok(crate::jsc::JSValue::UNDEFINED)
     }
 
-    /// Spec: interpreter.zig `#derefRootShellAndIOIfNeeded`. Idempotent
+    /// Idempotent
     /// teardown of `root_io`/`root_shell` for the JS event-loop path; called
     /// from `finish()` (success) and `run_from_js()` (early error). Guards on
     /// `cleanup_state` so a later `finalize()` doesn't double-free.
@@ -1430,14 +1386,12 @@ impl Interpreter {
         if self.this_jsvalue.get() != crate::jsc::JSValue::ZERO {
             // Cannot be safely called multiple times.
             // `root_io` holds `Arc<IOReader>`/`Arc<IOWriter>`; replacing with
-            // default drops the refs (Zig: `root_io.deref()`).
+            // default drops the refs.
             self.root_io.set(IO::default());
             self.root_shell.with_mut(|rs| rs.deinit_embedded(false));
         }
 
-        // PORT NOTE: free the parse arena eagerly. Zig's `args.__arena` is a
-        // lightweight `std.heap.ArenaAllocator` (a few KB), so leaving it for
-        // the GC finalizer is fine there. The Rust port's `bun_alloc::Arena` is
+        // Note: free the parse arena eagerly. `bun_alloc::Arena` is
         // a `MimallocArena` (a full `mi_heap_t`): every shell parse pulls
         // several fresh 64 KiB pages, and with `MI_DEBUG=3` each page-init
         // runs `mi_assert_expensive(mi_mem_is_zero(page, 64 KiB))`. Under the
@@ -1463,7 +1417,7 @@ impl Interpreter {
         self.cleanup_state.set(CleanupState::RuntimeCleaned);
     }
 
-    /// Spec: interpreter.zig `deinitFromFinalizer`. GC finalizer body — runs
+    /// GC finalizer body — runs
     /// whatever teardown `finish()` didn't, then frees the box.
     ///
     /// # Safety
@@ -1519,10 +1473,10 @@ impl Interpreter {
         this.keep_alive.with_mut(|k| k.disable());
         // `args: Box<ShellArgs>` and `vm_args_utf8: Vec<ZigStringSlice>` drop
         // with the box; `ZigStringSlice` has a `Drop` impl that derefs its
-        // WTF backing (Zig: per-item `str.deinit()` + list deinit).
+        // WTF backing.
     }
 
-    /// Spec: interpreter.zig `setQuiet` — JS `interp.setQuiet()`.
+    /// JS `interp.setQuiet()`.
     pub fn set_quiet(
         &self,
         _: &crate::jsc::JSGlobalObject,
@@ -1536,7 +1490,7 @@ impl Interpreter {
         Ok(crate::jsc::JSValue::UNDEFINED)
     }
 
-    /// Spec: interpreter.zig `setCwd` — JS `interp.setCwd(path)`.
+    /// JS `interp.setCwd(path)`.
     pub fn set_cwd(
         &self,
         global_this: &crate::jsc::JSGlobalObject,
@@ -1557,7 +1511,7 @@ impl Interpreter {
         Ok(crate::jsc::JSValue::UNDEFINED)
     }
 
-    /// Spec: interpreter.zig `setEnv` — JS `interp.setEnv({ FOO: "bar" })`.
+    /// JS `interp.setEnv({ FOO: "bar" })`.
     pub fn set_env(
         &self,
         global_this: &crate::jsc::JSGlobalObject,
@@ -1593,11 +1547,8 @@ impl Interpreter {
             let keyslice = key.to_owned_slice();
             let value_str = value.get_zig_string(global_this)?;
             let slice = value_str.to_owned_slice();
-            // PORT NOTE: Zig `initRefCounted` adopts the slice; the Rust
-            // `init_ref_counted` dups (see EnvStr.rs TODO), so the `Vec`s drop
-            // here without leaking. TODO(refactor): revisit the ownership contract.
-            let keyref = EnvStr::init_ref_counted(&keyslice);
-            let valueref = EnvStr::init_ref_counted(&slice);
+            let keyref = EnvStr::init_ref_counted(keyslice.into_boxed_slice());
+            let valueref = EnvStr::init_ref_counted(slice.into_boxed_slice());
             self.root_shell
                 .with_mut(|rs| rs.export_env.insert(keyref, valueref));
             keyref.deref();
@@ -1607,7 +1558,6 @@ impl Interpreter {
         Ok(crate::jsc::JSValue::UNDEFINED)
     }
 
-    /// Spec: interpreter.zig `isRunning`.
     pub fn is_running(
         &self,
         _: &crate::jsc::JSGlobalObject,
@@ -1616,7 +1566,6 @@ impl Interpreter {
         Ok(crate::jsc::JSValue::js_boolean(self.has_pending_activity()))
     }
 
-    /// Spec: interpreter.zig `getStarted`.
     pub fn get_started(
         &self,
         _: &crate::jsc::JSGlobalObject,
@@ -1627,7 +1576,6 @@ impl Interpreter {
         ))
     }
 
-    /// Spec: interpreter.zig `getBufferedStdout`.
     pub fn get_buffered_stdout(
         &self,
         global_this: &crate::jsc::JSGlobalObject,
@@ -1638,7 +1586,6 @@ impl Interpreter {
         )
     }
 
-    /// Spec: interpreter.zig `getBufferedStderr`.
     pub fn get_buffered_stderr(
         &self,
         global_this: &crate::jsc::JSGlobalObject,
@@ -1649,7 +1596,7 @@ impl Interpreter {
         )
     }
 
-    /// Spec: interpreter.zig `finalize`. GC finalizer hook — called from the
+    /// GC finalizer hook — called from the
     /// generated C++ `JSShellInterpreter::~JSShellInterpreter` via
     /// `host_fn::host_fn_finalize`.
     pub fn finalize(self: Box<Self>) {
@@ -1660,7 +1607,7 @@ impl Interpreter {
         unsafe { Self::deinit_from_finalizer(Box::into_raw(self)) };
     }
 
-    /// Spec: interpreter.zig `hasPendingActivity`. GC `hasPendingActivity()`.
+    /// GC `hasPendingActivity()` hook.
     pub fn has_pending_activity(&self) -> bool {
         self.has_pending_activity.load(Ordering::SeqCst) > 0
     }
@@ -1681,9 +1628,8 @@ impl Interpreter {
         );
     }
 
-    /// Spec: interpreter.zig `getVmArgsUtf8`. Lazily caches the worker's
-    /// `argv` as UTF-8 slices so `$@`/`$N` expansion (Expansion.zig) can index
-    /// without re-converting on every reference.
+    /// Lazily caches the worker's `argv` as UTF-8 slices so `$@`/`$N`
+    /// expansion can index without re-converting on every reference.
     pub fn get_vm_args_utf8(&self, argv: &[bun_core::WTFStringImpl], idx: u8) -> &[u8] {
         self.vm_args_utf8.with_mut(|v| {
             if v.len() != argv.len() {
@@ -1698,7 +1644,7 @@ impl Interpreter {
         self.vm_args_utf8.get()[idx as usize].slice()
     }
 
-    /// Spec: Expansion.zig `expandVarArgv`. Appends the value of `$N` to
+    /// Appends the value of `$N` to
     /// `out`. Takes the relevant interpreter fields by-part so callers can
     /// split-borrow alongside the node arena.
     ///
@@ -1789,7 +1735,7 @@ impl Interpreter {
     }
 }
 
-/// Spec: interpreter.zig `ioToJSValue`. Moves the captured stdout/stderr
+/// Moves the captured stdout/stderr
 /// `Vec<u8>` into a JS `Buffer` (ownership transfers to JSC's deallocator)
 /// and resets the source to empty.
 fn io_to_js_value(
@@ -1798,22 +1744,18 @@ fn io_to_js_value(
 ) -> crate::jsc::JSValue {
     // SAFETY: `buf` points into a live `ShellExecEnv` (root or borrowed).
     let bytelist = core::mem::take(unsafe { &mut *buf });
-    // PORT NOTE: Zig wraps in `jsc.Node.Buffer{ .buffer = ArrayBuffer.fromBytes
-    // (..., .Uint8Array) }.toNodeBuffer(global)`. `MarkedArrayBuffer::
-    // to_node_buffer` is the same `JSBuffer__bufferFromPointerAndLengthAndDeinit`
-    // call; we hand it the moved-out `Vec<u8>` storage directly. The
+    // The moved-out `Vec<u8>` storage is handed to JSC directly; the
     // `Vec<u8>` value itself is `mem::forget`-ed since JSC now owns the bytes.
     let mut bytelist = core::mem::ManuallyDrop::new(bytelist);
     crate::jsc::JSValue::create_buffer(global_this, bytelist.slice_mut())
 }
 
-/// Spec: interpreter.zig `throwShellErr(e, event_loop)`. On the mini event
+/// On the mini event
 /// loop this prints to stderr and `exit(1)`s (diverges); on the JS event loop
 /// it raises a JS exception via [`ShellErr::throw_js`] and returns
 /// `JsError::Thrown`.
-// PORT NOTE: takes ownership (Zig passed `*const ShellErr` because both arms
-// consume; Rust expresses that as by-value). `global` is `Option` because the
-// mini arm has no global; on the JS arm callers always pass `Some`.
+// `global` is `Option` because the mini arm has no global; on the JS arm
+// callers always pass `Some`.
 pub fn throw_shell_err(
     e: ShellErr,
     event_loop: EventLoopHandle,
@@ -1865,7 +1807,6 @@ impl Default for Bufio {
 }
 
 impl Bufio {
-    /// Spec: interpreter.zig `Bufio.memoryCost` (interpreter.zig:429).
     pub fn memory_cost(&self) -> usize {
         match self {
             Bufio::Owned(o) => o.memory_cost(),
@@ -1886,7 +1827,6 @@ pub enum ShellExecEnvKind {
 }
 
 impl ShellExecEnv {
-    /// Spec: interpreter.zig `ShellExecEnv.memoryCost` (interpreter.zig:449).
     pub fn memory_cost(&self) -> usize {
         let mut size = core::mem::size_of::<ShellExecEnv>();
         size += self.shell_env.memory_cost();
@@ -1896,8 +1836,7 @@ impl ShellExecEnv {
         size += self.__prev_cwd.capacity();
         size += self._buffered_stderr.memory_cost();
         size += self._buffered_stdout.memory_cost();
-        // PORT NOTE: Zig `async_pids.memoryCost()` walks the SmolList; the
-        // Rust shim is `Vec`, so report its heap capacity directly.
+        // `async_pids` is a `Vec`; report its heap capacity directly.
         size += self.async_pids.capacity() * core::mem::size_of::<PidT>();
         size
     }
@@ -1969,7 +1908,7 @@ impl ShellExecEnv {
         }
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.dupeForSubshell`. Heap-allocates a
+    /// Heap-allocates a
     /// fresh env for a subshell/pipeline child: dups `cwd_fd`, clones
     /// `shell_env`/`export_env`, gives it a fresh empty `cmd_local_env`, and
     /// borrows or owns buffered stdout/stderr per `kind` (subshell/pipeline
@@ -1985,7 +1924,7 @@ impl ShellExecEnv {
 
         let dupedfd = bun_sys::dup(self.cwd_fd)?;
 
-        // Spec (interpreter.zig dupeForSubshell): for `.fd` with a captured
+        // For `.fd` with a captured
         // buffer, borrow that; for `.ignore`, own a fresh one; for `.pipe`,
         // own when normal/cmd_subst, borrow parent's when subshell/pipeline.
         let bufio_for = |out: &OutKind, parent_buf: *mut Vec<u8>| -> Bufio {
@@ -2023,8 +1962,7 @@ impl ShellExecEnv {
         Ok(bun_core::heap::into_raw(duped))
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.deinit` — wraps `deinitImpl(true,
-    /// true)` for the heap-allocated subshell/pipeline-child case.
+    /// Teardown for the heap-allocated subshell/pipeline-child case.
     ///
     /// # Safety
     /// `this` must have been returned by `dupe_for_subshell` (or otherwise
@@ -2035,19 +1973,16 @@ impl ShellExecEnv {
         log!("[ShellExecEnv] deinit 0x{:x}", this as usize);
         // SAFETY: precondition above. Reclaim the Box; `Drop` for the env
         // maps / vecs / owned `Bufio` runs on drop. Only `cwd_fd` needs an
-        // explicit close (Zig: `closefd(this.cwd_fd)`).
+        // explicit close.
         let boxed = unsafe { bun_core::heap::take(this) };
         closefd(boxed.cwd_fd);
         // EnvMap/Vec/Vec<u8> drop impls free their storage; `Bufio::Borrowed`
-        // is a raw ptr so its drop is a no-op (matches Zig's
-        // `if (== .owned) clearAndFree`).
+        // is a raw ptr so its drop is a no-op.
         drop(boxed);
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.deinitImpl(false, free_buffered_io)`
-    /// — teardown for the *embedded* root env (held by value in `Interpreter`;
-    /// `destroy_this = false`). The Rust `deinit_impl(this: *mut)` covers the
-    /// `destroy_this = true` heap-allocated subshell case.
+    /// Teardown for the *embedded* root env (held by value in `Interpreter`).
+    /// `deinit_impl(this: *mut)` covers the heap-allocated subshell case.
     pub fn deinit_embedded(&mut self, free_buffered_io: bool) {
         log!(
             "[ShellExecEnv] deinit 0x{:x}",
@@ -2072,14 +2007,14 @@ impl ShellExecEnv {
         self.cwd_fd = bun_sys::Fd::INVALID;
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.changePrevCwd` — `cd -`.
+    /// `cd -`.
     #[inline]
     pub fn change_prev_cwd(&mut self) -> bun_sys::Result<()> {
-        // PORT NOTE: reshaped for borrowck — `prev_cwd()` borrows `self`, so
+        // Note: reshaped for borrowck — `prev_cwd()` borrows `self`, so
         // copy into a stack buffer before the `&mut self` call. Bounded by the
         // ENAMETOOLONG check inside `change_cwd_impl` (same 4 KiB).
-        // Spec uses `ResolvePath.join_buf` (`[4096]u8` on every platform); do
-        // NOT use `bun_paths::PathBuffer` here — on Windows that is ~96 KiB of
+        // Use a `[4096]u8` buffer on every platform; do NOT use
+        // `bun_paths::PathBuffer` here — on Windows that is ~96 KiB of
         // zero-filled stack, and `change_cwd_impl` stacks another on top.
         let mut buf = [0u8; 4096];
         let prev = self.prev_cwd();
@@ -2088,17 +2023,13 @@ impl ShellExecEnv {
         self.change_cwd_impl(&buf[..n], false)
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.changeCwd` — thin `in_init = false`
-    /// wrapper. The Zig version is `anytype` over `[:0]const u8` / `[]const u8`;
-    /// we accept the un-terminated slice and let `change_cwd_impl` re-NUL into
-    /// its join buffer (the sentinel fast-path is a memcpy either way).
+    /// Thin `in_init = false` wrapper. Accepts the un-terminated slice and
+    /// lets `change_cwd_impl` re-NUL into its join buffer.
     #[inline]
     pub fn change_cwd(&mut self, new_cwd: &[u8]) -> bun_sys::Result<()> {
         self.change_cwd_impl(new_cwd, false)
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.changeCwdImpl`.
-    ///
     /// Resolves `new_cwd_` (absolute, or relative to current `cwd()`), opens it
     /// with `O_DIRECTORY`, and on success rotates `__cwd`/`__prev_cwd`/`cwd_fd`.
     /// Always writes `PWD` into `export_env`; `OLDPWD` is written only when
@@ -2106,11 +2037,10 @@ impl ShellExecEnv {
     pub fn change_cwd_impl(&mut self, new_cwd_: &[u8], in_init: bool) -> bun_sys::Result<()> {
         let is_abs = bun_paths::is_absolute(new_cwd_);
 
-        // Spec interpreter.zig:620 bounds-checks against `ResolvePath.join_buf`
-        // — a `[4096]u8` threadlocal on *every* platform. Do NOT use
-        // `bun_paths::PathBuffer` here: on Windows that is `MAX_PATH_BYTES =
-        // 32767*3+1` ≈ 96 KiB of zero-filled stack per `cd`, and the
-        // `>= buf.len()` check would diverge from the Zig ENAMETOOLONG bound.
+        // Bounds-check against a `[4096]u8` buffer on *every* platform. Do NOT
+        // use `bun_paths::PathBuffer` here: on Windows that is `MAX_PATH_BYTES
+        // = 32767*3+1` ≈ 96 KiB of zero-filled stack per `cd`, and the
+        // `>= buf.len()` check would change the ENAMETOOLONG bound.
         let mut buf = [0u8; 4096];
         let required_len = if is_abs {
             new_cwd_.len()
@@ -2130,10 +2060,9 @@ impl ShellExecEnv {
             buf[new_cwd_.len()] = 0;
             new_cwd_.len()
         } else {
-            // Spec interpreter.zig:637-640 — `ResolvePath.joinZ(&.{cwd, new_cwd_},
-            // .auto)` normalizes `.`/`..` so the stored `$PWD`/`$OLDPWD` strings
-            // reflect the resolved path (not `<cwd>/..`).
-            // PORT NOTE: reshaped for borrowck — capture only the joined length
+            // `join_z_buf` normalizes `.`/`..` so the stored `$PWD`/`$OLDPWD`
+            // strings reflect the resolved path (not `<cwd>/..`).
+            // Note: reshaped for borrowck — capture only the joined length
             // so the borrow on `buf` is released before stripping below.
             let mut n = {
                 let existing_cwd = self.cwd();
@@ -2144,8 +2073,8 @@ impl ShellExecEnv {
                 .as_bytes()
                 .len()
             };
-            // remove trailing separator (spec interpreter.zig:643-653 — Windows
-            // checks `\\` first then falls through to `/`; POSIX only `/`).
+            // remove trailing separator (Windows checks `\\` first then falls
+            // through to `/`; POSIX only `/`).
             #[cfg(windows)]
             if n > 1 && buf[n - 1] == b'\\' {
                 n -= 1;
@@ -2174,7 +2103,7 @@ impl ShellExecEnv {
         self.__prev_cwd.extend_from_slice(&self.__cwd[..]);
 
         self.__cwd.clear();
-        // include trailing NUL (spec: `new_cwd[0 .. new_cwd.len + 1]`).
+        // include trailing NUL.
         self.__cwd.extend_from_slice(&buf[..new_cwd_len + 1]);
 
         debug_assert_eq!(*self.__cwd.last().unwrap(), 0);
@@ -2182,10 +2111,10 @@ impl ShellExecEnv {
 
         self.cwd_fd = new_cwd_fd;
 
-        // Spec interpreter.zig:685-688: only `OLDPWD` is gated on `!in_init`;
+        // Only `OLDPWD` is gated on `!in_init`;
         // `PWD` is written unconditionally so the very first env (built during
         // `init()` with `in_init = true`) still exports the resolved cwd.
-        // PORT NOTE: reshaped for borrowck — materialize the EnvStr (which
+        // Note: reshaped for borrowck — materialize the EnvStr (which
         // erases the slice lifetime into a packed ptr) before taking
         // `&mut self.export_env`.
         use crate::shell::env_str::EnvStr;
@@ -2200,12 +2129,10 @@ impl ShellExecEnv {
         Ok(())
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.assignVar`.
-    ///
     /// Routes `label = value` into one of the three env maps depending on
     /// where the assignment appeared (`FOO=1 cmd` → cmd-local, bare `FOO=1` →
     /// shell, `export FOO=1` → exported). NOTE: `EnvMap::insert` `.ref()`s the
-    /// value, so callers should `defer value.deref()` per the Zig contract.
+    /// value, so callers should deref `value` after the call.
     pub fn assign_var(
         &mut self,
         label: crate::shell::env_str::EnvStr,
@@ -2219,8 +2146,6 @@ impl ShellExecEnv {
         }
     }
 
-    /// Spec: interpreter.zig `ShellExecEnv.getHomedir`.
-    ///
     /// Looks up `$HOME` (`$USERPROFILE` on Windows) in `shell_env` first, then
     /// `export_env`. Falls back to `""` (or `/data/local/tmp` on Android) so
     /// `cd` with no args / `~` expansion never sees a null.
@@ -2288,14 +2213,14 @@ impl CowFd {
         new
     }
 
-    /// Spec: `CowFd.dup` — fresh `CowFd` wrapping a `dup()`'d fd. Errors
+    /// Fresh `CowFd` wrapping a `dup()`'d fd. Errors
     /// surface the syscall error (the freshly-allocated box is dropped).
     pub fn dup(&self) -> bun_sys::Result<*mut CowFd> {
         let fd = bun_sys::dup(self.__fd)?;
         Ok(Self::init(fd))
     }
 
-    /// Spec: `CowFd.use` — copy-on-write borrow. If nobody is currently
+    /// Copy-on-write borrow. If nobody is currently
     /// writing through this fd, mark it in-use and return it (refcount +1);
     /// otherwise hand out a fresh `dup()`.
     pub fn use_(&mut self) -> bun_sys::Result<*mut CowFd> {
@@ -2307,7 +2232,7 @@ impl CowFd {
         self.dup()
     }
 
-    /// Spec: `CowFd.doneUsing` — paired with [`use_`].
+    /// Paired with [`use_`].
     pub fn done_using(&mut self) {
         self.being_used = false;
     }
@@ -2316,7 +2241,7 @@ impl CowFd {
         self.refcount += 1;
     }
 
-    /// Spec: `CowFd.dupeRef` — bump refcount and return the same pointer.
+    /// Bump refcount and return the same pointer.
     pub fn dupe_ref(&mut self) -> *mut CowFd {
         self.ref_();
         self
@@ -2332,9 +2257,7 @@ impl CowFd {
         unsafe {
             (*this).refcount -= 1;
             if (*this).refcount == 0 {
-                // Spec `CowFd.deinit` (interpreter.zig:192-196): close the fd
-                // before freeing. `closefd` tolerates EBADF like Zig's
-                // `closeAllowingBadFileDescriptor`.
+                // Close the fd before freeing; `closefd` tolerates EBADF.
                 closefd((*this).__fd);
                 drop(bun_core::heap::take(this));
             }
@@ -2351,7 +2274,7 @@ pub use crate::shell::io_reader::IOReader;
 pub use crate::shell::io_writer::IOWriter;
 pub use crate::shell::states::assigns::AssignCtx;
 
-/// Spec: `bun.sys.openNullDevice()` (sys.zig:3865) — open `/dev/null` `O_RDWR`
+/// Open `/dev/null` `O_RDWR`
 /// on POSIX, `nul` on Windows. Used when a stdio stream was closed at process
 /// start so we have *something* to dup into the shell's root IO. Must be
 /// writable: `setup_io_before_run` installs the result as the stdout/stderr
@@ -2367,15 +2290,12 @@ fn open_null_device() -> bun_sys::Result<Fd> {
     }
     #[cfg(windows)]
     {
-        // Spec uses `sys_uv.open("nul", 0, 0)` — flags `0` is `O_RDONLY` in
-        // libuv's encoding, but Windows NUL is bidirectional regardless.
+        // Windows NUL is bidirectional regardless of the open flags.
         bun_sys::open(bun_core::ZStr::from_static(b"nul\0"), bun_sys::O::RDWR, 0)
     }
 }
 
-/// Spec: interpreter.zig `isPollable` (interpreter.zig:2116-2124).
-///
-/// PORT NOTE: spec takes a pre-cached `mode` from `event_loop.stdout().data
+/// Note: takes a pre-cached `mode` from `event_loop.stdout().data
 /// .file.mode`; `EventLoopHandle` is still a shim, so we `fstat` the (already
 /// dup'd) fd here instead. On `fstat` failure we conservatively return `false`
 /// (non-pollable → synchronous write path), matching Windows behavior.
@@ -2404,7 +2324,6 @@ fn is_pollable(fd: Fd) -> bool {
     }
 }
 
-/// Spec: interpreter.zig `isPollableFromMode` (interpreter.zig:2126-2134).
 /// Same test as [`is_pollable`] minus the `isatty()` check — used when the
 /// caller already has a cached `st_mode` (e.g. from `Builtin` stdio setup) and
 /// no fd is at hand.
@@ -2431,7 +2350,6 @@ pub fn is_pollable_from_mode(mode: bun_sys::Mode) -> bool {
     }
 }
 
-/// Spec: interpreter.zig `closefd` → `fd.closeAllowingBadFileDescriptor`.
 /// Tolerates EBADF (already-closed) so cleanup paths that may double-close
 /// don't panic; skips stdin/stdout/stderr.
 pub fn closefd(fd: Fd) {
@@ -2439,7 +2357,6 @@ pub fn closefd(fd: Fd) {
     let _ = fd.close_allowing_bad_file_descriptor(None);
 }
 
-/// Spec: interpreter.zig `ShellSyscall.dup` (interpreter.zig:1931-1939).
 /// Same as `bun_sys::dup` on POSIX; on Windows the duped handle is converted
 /// to a libuv-owned fd via `makeLibUVOwnedForSyscall(.dup, .close_on_fail)` so
 /// the IOWriter/IOReader uv-based async write/read paths receive a uv fd
@@ -2457,7 +2374,6 @@ pub fn shell_dup(fd: Fd) -> bun_sys::Result<Fd> {
     }
 }
 
-/// Spec: interpreter.zig `ShellSyscall.getPath` (interpreter.zig:1823-1858).
 /// Windows-only: rewrite shell paths so POSIX-absolute `/foo` resolves onto
 /// `dirfd`'s drive root, `/dev/null` maps to `NUL`, and relative paths are
 /// joined against `dirfd`'s real path. Returns a NUL-terminated slice that
@@ -2476,9 +2392,9 @@ fn shell_get_path<'a>(
             let dirpath = bun_sys::get_fd_path(dirfd, buf).map_err(|e| e.with_fd(dirfd))?;
             bun_paths::resolve_path::windows_filesystem_root(dirpath).len()
         };
-        // Spec: `copyForwards(buf[0..root], source_root)` — `dirpath` already
-        // occupies `buf[0..]` and the root is its prefix, so that copy is a
-        // no-op here. Splice `to[1..]` after the root.
+        // `dirpath` already
+        // occupies `buf[0..]` and the root is its prefix, so no copy is
+        // needed. Splice `to[1..]` after the root.
         let to_tail = &to.as_bytes()[1..];
         let end = source_root_len + to_tail.len();
         buf[source_root_len..end].copy_from_slice(to_tail);
@@ -2489,8 +2405,8 @@ fn shell_get_path<'a>(
         return Ok(to);
     }
     // Relative: resolve dirfd → path, then join.
-    // PORT NOTE: reshaped for borrowck — Zig's `joinZBuf(buf, &.{dirpath, to})`
-    // reads `dirpath` (a slice of `buf`) while writing `buf`; copy `dirpath`
+    // Note: a single-buffer join would read `dirpath` (a slice of `buf`)
+    // while writing `buf`; copy `dirpath`
     // out first so the mutable borrow on `buf` is exclusive.
     let dirpath = bun_sys::get_fd_path(dirfd, buf)
         .map_err(|e| e.with_fd(dirfd))?
@@ -2500,7 +2416,6 @@ fn shell_get_path<'a>(
     >(&mut buf[..], &[&dirpath, to.as_bytes()]))
 }
 
-/// Spec: interpreter.zig `ShellSyscall.statat` (interpreter.zig:1861-1877).
 /// Windows: rewrite the path via `shell_get_path` then `bun_sys::stat`, tagging
 /// the error with the *original* `path_` (not the rewritten one). POSIX: plain
 /// `bun_sys::fstatat(dir, path_)`.
@@ -2518,7 +2433,6 @@ pub fn shell_statat(dir: Fd, path_: &bun_core::ZStr) -> bun_sys::Result<bun_sys:
     }
 }
 
-/// Spec: interpreter.zig `ShellSyscall.openat` (interpreter.zig:1881-1918).
 /// POSIX: `bun_sys::openat` with the error tagged `.with_path(path)`.
 /// Windows: for `O_DIRECTORY` opens, rewrite POSIX-absolute paths via
 /// `shell_get_path` and use `openDirAtWindowsA(.iterable=true)` +
@@ -2566,11 +2480,8 @@ pub fn shell_openat(
         }
         let mut buf = bun_paths::path_buffer_pool::get();
         let p = shell_get_path(dir, path, &mut buf)?;
-        // Spec interpreter.zig:1904-1909: `return bun.sys.open(p, flags, perm)`
-        // — no `makeLibUVOwnedForSyscall` here. `bun_sys::open` on Windows
-        // routes through `sys_uv` and already yields a uv-owned fd; the
-        // trailing `if (isWindows) makeLibUVOwned` in the Zig source is dead
-        // code (the Windows block early-returns before it).
+        // No `makeLibUVOwnedForSyscall` here: `bun_sys::open` on Windows
+        // routes through `sys_uv` and already yields a uv-owned fd.
         return bun_sys::open(p, flags, perm);
     }
     #[cfg(not(windows))]
@@ -2579,12 +2490,10 @@ pub fn shell_openat(
     }
 }
 
-/// Spec: interpreter.zig `ShellSyscall.open` (interpreter.zig:1920-1929).
 /// `bun_sys::open` already routes through `sys_uv` on Windows (returns a uv
 /// fd), so unlike `openat`'s NT-handle directory path this needs no explicit
-/// `makeLibUVOwnedForSyscall` — the dead `if (isWindows)` tail in the Zig
-/// source is unreachable after the early `return bun.sys.open(...)`.
-// no Zig callers yet; ported for ShellSyscall surface parity
+/// `makeLibUVOwnedForSyscall`.
+// no callers yet; kept for syscall-wrapper surface parity
 pub fn shell_open(
     file_path: &bun_core::ZStr,
     flags: i32,
@@ -2603,10 +2512,10 @@ pub fn shell_open(
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// Builtin flag-parsing infra (Spec: interpreter.zig `ParseError` / `FlagParser`)
+// Builtin flag-parsing infra
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Custom parse error for invalid options. Spec: interpreter.zig `ParseError`.
+/// Custom parse error for invalid options.
 ///
 /// Payload slices borrow from the builtin's argv (NUL-terminated arena strings)
 /// or are `'static` literals; the builtin formats them into an error message
@@ -2633,7 +2542,6 @@ impl ParseError {
     }
 }
 
-/// Spec: interpreter.zig `ParseFlagResult`.
 pub enum ParseFlagResult {
     ContinueParsing,
     Done,
@@ -2642,25 +2550,14 @@ pub enum ParseFlagResult {
     ShowUsage,
 }
 
-/// Spec: interpreter.zig `unsupportedFlag` (interpreter.zig:2063-2065) returns
-/// the comptime-concatenated `"unsupported option, please open a GitHub issue
-/// -- " ++ name ++ "\n"`. Every caller then wraps that AGAIN in the same
-/// prefix via `fmtErrorArena`, so Zig's stderr prints the prefix twice.
-///
-/// PORT NOTE — intentional spec-bug fix: we return just `name` and let the
-/// caller's `fmt_error_arena` add the prefix once. This diverges from Zig's
-/// observable doubled output; update Zig (or any snapshot tests asserting the
-/// doubled message) rather than reproducing the duplication here. Reproducing
-/// it would require runtime allocation (leaking is forbidden — see
-/// PORTING.md §Forbidden) since Rust can't comptime-concat a non-const arg.
+/// Returns just `name` and lets the caller's `fmt_error_arena` add the
+/// "unsupported option" prefix once.
 #[inline]
 pub const fn unsupported_flag(name: &'static [u8]) -> *const [u8] {
     std::ptr::from_ref::<[u8]>(name)
 }
 
 /// Per-builtin opts type implements this to plug into `FlagParser::parse_flags`.
-/// Spec: interpreter.zig `FlagParser(comptime Opts)` — the Zig version is a
-/// type-generator; in Rust the per-opts hooks are a trait.
 pub trait FlagParser {
     /// Handle a `--long` flag. Return `None` to fall through to short parsing.
     fn parse_long(&mut self, flag: &[u8]) -> Option<ParseFlagResult>;
@@ -2668,8 +2565,7 @@ pub trait FlagParser {
     fn parse_short(&mut self, ch: u8, smallflags: &[u8], i: usize) -> Option<ParseFlagResult>;
 }
 
-/// Spec: interpreter.zig `FlagParser.parseFlags`. Returns the trailing
-/// non-flag args (`args[idx..]`) on success.
+/// Returns the trailing non-flag args (`args[idx..]`) on success.
 pub fn parse_flags<'a, O: FlagParser>(
     opts: &mut O,
     args: &'a [*const core::ffi::c_char],
@@ -2693,7 +2589,6 @@ pub fn parse_flags<'a, O: FlagParser>(
     Err(ParseError::ShowUsage)
 }
 
-/// Spec: interpreter.zig `FlagParser.parseFlag`.
 fn parse_one_flag<O: FlagParser>(opts: &mut O, flag: &[u8]) -> ParseFlagResult {
     if flag.is_empty() || flag[0] != b'-' {
         return ParseFlagResult::Done;
@@ -2716,13 +2611,13 @@ fn parse_one_flag<O: FlagParser>(opts: &mut O, flag: &[u8]) -> ParseFlagResult {
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// OutputTask (Spec: interpreter.zig `OutputTask` / `OutputSrc`)
+// OutputTask
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Spec: interpreter.zig `OutputSrc`. Owned bytes a builtin's async sub-task
+/// Owned bytes a builtin's async sub-task
 /// produced off-thread, queued for stdout once back on the main thread.
 pub enum OutputSrc {
-    /// `std.ArrayListUnmanaged(u8)` — owned, freed on drop.
+    /// Owned, freed on drop.
     Arrlist(Vec<u8>),
     /// Heap slice owned by us (freed on drop).
     OwnedBuf(Box<[u8]>),
@@ -2748,8 +2643,7 @@ pub enum OutputTaskState {
     Done,
 }
 
-/// Spec: interpreter.zig `OutputTask` vtable. In Zig this is a comptime struct
-/// of fn pointers; here it's a trait the parent builtin implements. All hooks
+/// Vtable trait the parent builtin implements. All hooks
 /// take `(&mut Interpreter, NodeId)` (NodeId style — the parent builtin lives
 /// inside the interpreter's node arena).
 ///
@@ -2773,13 +2667,12 @@ pub trait OutputTaskVTable: Sized {
     fn on_done(interp: &Interpreter, cmd: NodeId) -> Yield;
 }
 
-/// A task that can write to stdout and/or stderr. Spec: interpreter.zig
-/// `OutputTask(Parent, vtable)`.
+/// A task that can write to stdout and/or stderr.
 ///
 /// Heap-allocated (`heap::alloc`) so the IOWriter can hold a raw pointer to
 /// it across async chunks; freed by `deinit`.
 pub struct OutputTask<P: OutputTaskVTable> {
-    /// Owning Cmd node (the builtin's `cmd` id). Replaces Zig's `*Parent`.
+    /// Owning Cmd node (the builtin's `cmd` id).
     pub parent: NodeId,
     pub output: OutputSrc,
     pub state: OutputTaskState,
@@ -2796,8 +2689,6 @@ impl<P: OutputTaskVTable> OutputTask<P> {
         })
     }
 
-    /// Spec: interpreter.zig `OutputTask.start`.
-    ///
     /// Takes the freshly-constructed task by `Box` (callers always pair `new`
     /// → `start`), leaks it to the raw `*mut Self` the IOWriter callback chain
     /// needs, and drives the first state transition. The box is reclaimed by
@@ -2833,7 +2724,6 @@ impl<P: OutputTaskVTable> OutputTask<P> {
         }
     }
 
-    /// Spec: interpreter.zig `OutputTask.next`.
     pub unsafe fn next(this: *mut Self, interp: &Interpreter) -> Yield {
         // SAFETY: caller contract — see `start`.
         unsafe {
@@ -2859,7 +2749,6 @@ impl<P: OutputTaskVTable> OutputTask<P> {
         }
     }
 
-    /// Spec: interpreter.zig `OutputTask.onIOWriterChunk`.
     pub unsafe fn on_io_writer_chunk(
         this: *mut Self,
         interp: &Interpreter,
@@ -2867,13 +2756,12 @@ impl<P: OutputTaskVTable> OutputTask<P> {
         _err: Option<bun_sys::SystemError>,
     ) -> Yield {
         log!("OutputTask(0x{:x}) onIOWriterChunk", this as usize);
-        // Zig derefs the SystemError; in Rust drop handles it.
         // SAFETY: `this` is the live heap-allocated `OutputTask` guaranteed by
         // this fn's caller contract; forwarded unchanged to `next`.
         unsafe { Self::next(this, interp) }
     }
 
-    /// Spec: interpreter.zig `OutputTask.deinit` — fires `on_done` then frees.
+    /// Fires `on_done` then frees.
     unsafe fn deinit(this: *mut Self, interp: &Interpreter) -> Yield {
         // SAFETY: `this` was heap-allocated in `new`; reclaim and drop.
         let me = unsafe { bun_core::heap::take(this) };
@@ -2886,21 +2774,18 @@ impl<P: OutputTaskVTable> OutputTask<P> {
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// ShellTask (Spec: interpreter.zig `ShellTask`)
+// ShellTask
 // ────────────────────────────────────────────────────────────────────────────
 
-/// Thread-pool task wrapper used by mv/rm/ls/mkdir/touch/cp builtins. Spec:
-/// interpreter.zig `ShellTask(Ctx, runFromThreadPool, runFromMainThread, log)`.
+/// Thread-pool task wrapper used by mv/rm/ls/mkdir/touch/cp builtins.
 ///
-/// The Zig version is a type-generator over the parent ctx + two fn pointers;
-/// here it's a trait the per-builtin task struct implements. The Zig
-/// `@fieldParentPtr("task", task)` chain (WorkPoolTask → InnerShellTask → Ctx)
-/// is reproduced via `core::mem::offset_of!` in [`ShellTaskCtx::TASK_OFFSET`]
-/// + the `#[repr(C)]` first-field guarantee on [`ShellTask::task`].
+/// A trait the per-builtin task struct implements. The container-of chain
+/// (WorkPoolTask → ShellTask → Ctx) is built from `core::mem::offset_of!` in
+/// [`ShellTaskCtx::TASK_OFFSET`] + the `#[repr(C)]` first-field guarantee on
+/// [`ShellTask::task`].
 ///
 /// `Taskable` is a supertrait so [`ShellTask::on_finish`] can build the
-/// JS-side `ConcurrentTask` (Zig: `concurrent_task.js.from(ctx, .manual_deinit)`
-/// resolved the tag via comptime `@typeName(Ctx)`).
+/// JS-side `ConcurrentTask`.
 pub trait ShellTaskCtx: Sized + bun_event_loop::Taskable {
     /// Byte offset of the embedded `task: ShellTask` field within `Self`.
     /// Implementors define this as `core::mem::offset_of!(Self, task)`.
@@ -2916,8 +2801,7 @@ pub trait ShellTaskCtx: Sized + bun_event_loop::Taskable {
     /// thread pool hands the callback. `WorkPoolTask` is the first
     /// `#[repr(C)]` field of [`ShellTask`], so the `WorkPoolTask*` and
     /// `ShellTask*` coincide; one `byte_sub(TASK_OFFSET)` walks back to the
-    /// outer `Self` (Zig: the two-hop `@fieldParentPtr` chain in
-    /// `InnerShellTask.runFromThreadPool`).
+    /// outer `Self`.
     ///
     /// Provided so the two opt-out builtins (`cp`/`rm`, which install a
     /// custom `work_pool_callback` and bypass [`shell_task_trampoline`]) can
@@ -2946,15 +2830,14 @@ pub struct ShellTask {
     pub task: WorkPoolTask,
     pub event_loop: EventLoopHandle,
     pub keep_alive: bun_io::KeepAlive,
-    /// Back-ref to the owning [`Interpreter`]. The Zig original threaded the
-    /// interpreter through each builtin's parent-ptr chain; the Rust port uses
-    /// a NodeId arena, so the high-tier dispatch (`runtime::dispatch::run_task`)
-    /// recovers `&mut Interpreter` from this field instead. Set at
-    /// `ShellTask::new`; cleared (raw-ptr) only when the task is freed.
+    /// Back-ref to the owning [`Interpreter`]. The high-tier dispatch
+    /// (`runtime::dispatch::run_task`) recovers `&mut Interpreter` from this
+    /// field. Set at `ShellTask::new`; cleared (raw-ptr) only when the task
+    /// is freed.
     pub interp: *mut Interpreter,
     /// Intrusive concurrent-task node for the worker→main bounce. JS arm holds
     /// a [`ConcurrentTask`](bun_event_loop::ConcurrentTask::ConcurrentTask),
-    /// mini arm holds an `AnyTaskWithExtraContext` (Zig: `jsc.EventLoopTask`).
+    /// mini arm holds an `AnyTaskWithExtraContext`.
     pub concurrent_task: bun_event_loop::EventLoopTask,
 }
 
@@ -2974,7 +2857,7 @@ impl ShellTask {
         }
     }
 
-    /// Spec: interpreter.zig `InnerShellTask.schedule`. Installs the per-`C`
+    /// Installs the per-`C`
     /// trampoline and hands the intrusive task to the global [`WorkPool`].
     ///
     /// SAFETY: `ctx` must be a live heap allocation that embeds this
@@ -2992,10 +2875,9 @@ impl ShellTask {
     }
 
     /// Install the per-`C` trampoline and hand the intrusive task to
-    /// [`WorkPool`] WITHOUT a `keep_alive.ref` — for tasks that the Zig spec
-    /// schedules via raw `WorkPool.schedule(&this.task)` (e.g. ls.zig
-    /// `ShellLsTask.schedule`, called recursively from a worker thread where
-    /// no JS-thread VM thread-local exists).
+    /// [`WorkPool`] WITHOUT a `keep_alive.ref` — for tasks scheduled
+    /// recursively from a worker thread where no JS-thread VM thread-local
+    /// exists (e.g. `ls`).
     ///
     /// SAFETY: same as [`Self::schedule`].
     pub unsafe fn schedule_no_ref<C: ShellTaskCtx>(ctx: *mut C) {
@@ -3011,7 +2893,7 @@ impl ShellTask {
         }
     }
 
-    /// Spec: interpreter.zig `InnerShellTask.onFinish`. Called from the worker
+    /// Called from the worker
     /// thread once `C::run_from_thread_pool` returns; enqueues the embedded
     /// concurrent task so the main thread re-enters via
     /// [`run_from_main_thread`](Self::run_from_main_thread) (which performs the
@@ -3034,16 +2916,14 @@ impl ShellTask {
             let event_loop = (*this).event_loop;
             let task_ptr = match &mut (*this).concurrent_task {
                 EventLoopTask::Js(ct) => {
-                    // Zig: `concurrent_task.js.from(ctx, .manual_deinit)` —
-                    // tag resolved via `C: Taskable`.
+                    // Tag resolved via `C: Taskable`.
                     ct.from(ctx, AutoDeinit::ManualDeinit);
                     EventLoopTaskPtr {
                         js: std::ptr::from_mut(ct),
                     }
                 }
                 EventLoopTask::Mini(at) => {
-                    // Zig: `concurrent_task.mini.from(this, "runFromMainThreadMini")`.
-                    // Rust passes the monomorphised callback explicitly.
+                    // Pass the monomorphised callback explicitly.
                     EventLoopTaskPtr {
                         mini: at.from(this, shell_task_run_from_main_thread_mini::<C>),
                     }
@@ -3054,12 +2934,11 @@ impl ShellTask {
         event_loop.enqueue_task_concurrent(task_ptr);
     }
 
-    /// Spec: interpreter.zig `InnerShellTask.runFromMainThread`. Unrefs the
+    /// Unrefs the
     /// event-loop keep-alive paired with [`schedule`], then dispatches to
     /// `C::run_from_main_thread`. The high-tier `runtime::dispatch::run_task`
     /// `shell_dispatch!` arm calls this so the ref/unref pairing is kept at
-    /// the seam (Zig: `this.ref.unref(this.event_loop)` before
-    /// `runFromMainThread_(ctx)`).
+    /// the seam.
     ///
     /// # Safety
     /// `ctx` must be a live heap allocation that embeds a `ShellTask` at
@@ -3079,11 +2958,11 @@ impl ShellTask {
     }
 }
 
-/// Spec: interpreter.zig `runFromThreadPool` — recover `*Ctx` from the
+/// Recover `*Ctx` from the
 /// intrusive `*WorkPoolTask`, run the user body, then post back to main.
 unsafe fn shell_task_trampoline<C: ShellTaskCtx>(task: *mut WorkPoolTask) {
     // SAFETY: `task` is the first `#[repr(C)]` field of `ShellTask`, which is
-    // embedded in `C` at `TASK_OFFSET` (Zig: two `container_of` hops). `ctx`
+    // embedded in `C` at `TASK_OFFSET`. `ctx`
     // remains the live heap allocation handed to `schedule`.
     unsafe {
         let ctx = C::from_work_task(task);
@@ -3094,8 +2973,7 @@ unsafe fn shell_task_trampoline<C: ShellTaskCtx>(task: *mut WorkPoolTask) {
     }
 }
 
-/// Spec: interpreter.zig `InnerShellTask.runFromMainThreadMini` — mini-loop
-/// `AnyTaskWithExtraContext` callback shape (`fn(*mut T, *mut ())`).
+/// Mini-loop `AnyTaskWithExtraContext` callback shape (`fn(*mut T, *mut ())`).
 fn shell_task_run_from_main_thread_mini<C: ShellTaskCtx>(this: *mut ShellTask, _: *mut ()) {
     // SAFETY: `this` is the `ShellTask` embedded in a live `C` at `TASK_OFFSET`;
     // mini-loop dispatch runs on the main thread.
@@ -3122,7 +3000,6 @@ pub fn unreachable_state(context: &str, state: &str) -> ! {
 
 // ─── createShellInterpreter ─────────────────────────────────────────────────
 // Host fn for `Bun.$` template tag — `BunObject_callback_createShellInterpreter`.
-// Port of `Interpreter.createShellInterpreter` (interpreter.zig:773).
 
 // C++ side (`ShellBindings.cpp`) takes `void* ptr` — `Interpreter` is opaque
 // across the boundary, layout is irrelevant. Defined `extern "C" SYSV_ABI`.
@@ -3197,14 +3074,13 @@ pub fn create_shell_interpreter(
         ShellResult::Ok(i) => i,
         ShellResult::Err(e) => {
             // shargs/jsobjs were consumed by `init` and dropped on its error
-            // path; export_env likewise (Zig: `defer shargs.deinit()` in caller).
+            // path; export_env likewise.
             return Err(e.throw_js(global));
         }
     };
 
     if global.has_exception() {
-        // Spec interpreter.zig:828-834: `interpreter.finalize()` →
-        // `deinitFromFinalizer` derefs root_io and closes `root_shell.cwd_fd`.
+        // `deinit_from_finalizer` derefs root_io and closes `root_shell.cwd_fd`.
         // Neither `Interpreter` nor `ShellExecEnv` implements `Drop`, so a plain
         // box drop would leak the raw `cwd_fd`; run the explicit teardown.
         interpreter.deinit_from_exec();
@@ -3241,5 +3117,3 @@ pub fn create_shell_interpreter(
     bun_analytics::features::shell.fetch_add(1, Ordering::Relaxed);
     Ok(js_value)
 }
-
-// ported from: src/shell/interpreter.zig
diff --git a/src/runtime/shell/mod.rs b/src/runtime/shell/mod.rs
index 9584e502cd7..41adb7cc422 100644
--- a/src/runtime/shell/mod.rs
+++ b/src/runtime/shell/mod.rs
@@ -1,11 +1,8 @@
-//! Port of src/shell/shell.zig + interpreter.zig
 //! Shell lexer, parser, AST, and tree-walking state-machine interpreter.
 //!
-//! ## NodeId arena architecture (Rust port)
+//! ## NodeId arena architecture
 //!
-//! The Zig interpreter uses parent-pointer mixin structs (`*Parent` back-refs
-//! everywhere — borrow-checker hostile). The Rust port replaces this with an
-//! **arena + NodeId index** scheme:
+//! Inter-node back-references use an **arena + NodeId index** scheme:
 //!
 //! - `Interpreter` owns `nodes: Vec<Node>` (a flat arena of state nodes)
 //! - Each state struct stores `parent: NodeId` (a `u32` index), NOT `*Parent`
@@ -20,8 +17,7 @@
 
 #[path = "shell_body.rs"]
 pub mod shell_body;
-// Codegen (`generated_js2native.rs`) addresses this as `crate::shell::shell::*`
-// (Zig path `src/runtime/shell/shell.zig`).
+// Codegen (`generated_js2native.rs`) addresses this as `crate::shell::shell::*`.
 pub use shell_body as shell;
 
 // ─── submodules ──────────────────────────────────────────────────────────────
@@ -177,11 +173,10 @@ pub mod ast {
     pub type CmdOrAssigns = p::CmdOrAssigns<'static>;
 }
 
-// Canonical 4-variant error enum (shell.zig `ShellErr`). Defined in
+// Canonical 4-variant shell error enum. Defined in
 // `shell_body.rs` and re-exported so subproc/state nodes use the same type.
 pub use shell_body::ShellErr;
 
-/// Spec: shell.zig `bun.shell.Result(T)`.
 pub type Result<T, E = ShellErr> = core::result::Result<T, E>;
 
 pub use parsed_shell_script::ParsedShellScript;
@@ -195,5 +190,3 @@ pub use parsed_shell_script::ParsedShellScript;
 /// Distinct from [`ShellSubprocess`](subproc::ShellSubprocess), the shell
 /// interpreter's internal process node.
 pub type Subprocess = crate::api::bun::subprocess::Subprocess<'static>;
-
-// ported from: src/shell/shell.zig
diff --git a/src/runtime/shell/shell_body.rs b/src/runtime/shell/shell_body.rs
index b8da8871c2f..858fb9769f0 100644
--- a/src/runtime/shell/shell_body.rs
+++ b/src/runtime/shell/shell_body.rs
@@ -1,4 +1,3 @@
-//! Port of src/shell/shell.zig
 //! Shell lexer, parser, AST, and JS-bridge utilities for Bun's shell.
 
 #![allow(non_camel_case_types, non_snake_case, clippy::too_many_arguments)]
@@ -22,17 +21,15 @@ use bun_sys::{self as sys, Fd, SystemError};
 
 // ───────────────────────────── re-exports ─────────────────────────────
 
-pub use super::interpreter as interpret; // ./interpreter.zig → crate::shell::interpret
-pub use super::subproc; // ./subproc.zig — declared once in `shell/mod.rs`
+pub use super::interpreter as interpret;
+pub use super::subproc; // declared once in `shell/mod.rs`
 
 pub use super::{EnvMap, EnvStr, ParsedShellScript};
 pub use interpret::{ExitCode, Interpreter, unreachable_state};
-pub use subproc::ShellSubprocess as Subprocess;
-// In Zig these hang off `Interpreter` as namespaced decls; in Rust they are
-// sibling modules re-exported through `interpret`.
 pub use interpret::{IOReader, IOWriter};
+pub use subproc::ShellSubprocess as Subprocess;
 
-pub use super::yield_; // ./Yield.zig
+pub use super::yield_;
 pub use yield_::Yield;
 
 // ─── lexer / parser / AST (moved down to bun_shell_parser) ──────────────────
@@ -51,7 +48,7 @@ pub use bun_shell_parser::parse::{
     needs_escape_utf8_ascii_latin1, needs_escape_utf16,
 };
 
-// Spec: `bun.glob.GlobWalker(null, true)` → SyscallAccessor + sentinel paths.
+// Glob walker configured for SyscallAccessor + sentinel (NUL-terminated) paths.
 pub type GlobWalker = bun_glob::BunGlobWalkerZ;
 
 pub const SUBSHELL_TODO_ERROR: &str = "Subshells are not implemented, please open GitHub issue!";
@@ -78,13 +75,11 @@ pub enum ShellErr {
 }
 
 impl ShellErr {
-    /// Spec `ShellErr.newSys(bun.sys.Error)` — wrap a low-level syscall error.
+    /// Wrap a low-level syscall error.
     pub fn new_sys(e: &sys::Error) -> Self {
         ShellErr::Sys(e.to_shell_system_error())
     }
     /// Spec `ShellErr.newSys(jsc.SystemError)` — already JS-shaped.
-    /// (Zig `newSys(e: anytype)` dispatched on `@TypeOf(e)`; Rust splits the
-    /// two arms into `new_sys` / `from_system`.)
     pub fn from_system(e: SystemError) -> Self {
         ShellErr::Sys(e)
     }
@@ -101,7 +96,7 @@ impl ShellErr {
             }
             ShellErr::Custom(custom) => {
                 let err_value = BunString::clone_utf8(&custom).to_error_instance(global);
-                // `custom: Box<[u8]>` drops here (Zig: `allocator.free(this.custom)`).
+                // `custom: Box<[u8]>` drops here.
                 global.throw_value(err_value)
             }
             ShellErr::InvalidArguments { val } => {
@@ -121,7 +116,6 @@ impl ShellErr {
                     err.message,
                     err.path
                 );
-                // Zig: `defer this.deinit()` → `.sys => this.sys.deref()`.
                 err.deref();
             }
             ShellErr::Custom(custom) => {
@@ -147,8 +141,8 @@ impl ShellErr {
     }
 
     /// Spec `ShellErr.deinit`. Explicit release for callers that drop a
-    /// `ShellErr` without throwing it (mirrors Zig's manual `deinit`; the
-    /// `Box<[u8]>` arms free on ordinary drop, so only `.sys` needs work).
+    /// `ShellErr` without throwing it (the `Box<[u8]>` arms free on ordinary
+    /// drop, so only `.sys` needs work).
     pub fn deinit(self) {
         if let ShellErr::Sys(sys) = self {
             sys.deref();
@@ -169,8 +163,7 @@ impl fmt::Display for ShellErr {
     }
 }
 
-// PORT NOTE: no `impl Drop for ShellErr`. Zig's `ShellErr.deinit` is *manual*
-// and asymmetric — `throwJS` deliberately skips `.sys.deref()` because
+// Note: no `impl Drop for ShellErr`. Release is *manual* and asymmetric — `throwJS` deliberately skips `.sys.deref()` because
 // `toErrorInstance` already consumed those refs. An unconditional `Drop` would
 // re-introduce the double-deref. Ownership is instead expressed by `throw_js` /
 // `throw_mini` / `deinit` taking `self` by value; the `Box<[u8]>` payloads free
@@ -186,7 +179,7 @@ pub enum ShellResult<T> {
 
 impl<T: Default> ShellResult<T> {
     pub fn success() -> Self {
-        // PORT NOTE: Zig used std.mem.zeroes(T). PORTING.md forbids zeroed::<T>() for generic T
+        // PORTING.md forbids zeroed::<T>() for generic T
         // (no #[repr(C)] POD guarantee, may contain NonNull/NonZero/enum). Default is the safe
         // mapping; dropped `const` since Default::default is not const-callable on generic T.
         ShellResult::Result(T::default())
@@ -286,8 +279,6 @@ impl<'a> GlobalJS<'a> {
 
     #[inline]
     pub fn enqueue_task_concurrent_wait_pid<T: bun_event_loop::Taskable>(self, task: *mut T) {
-        // Spec shell.zig GlobalJS.enqueueTaskConcurrentWaitPid:
-        //   `globalThis.bunVMConcurrently().enqueueTaskConcurrent(ConcurrentTask.create(Task.init(task)))`
         // SAFETY: bun_vm_concurrently() returns a valid &VirtualMachine; we need &mut for the
         // intrusive concurrent queue push (which is itself thread-safe). The VM outlives the call.
         let vm = self
@@ -313,8 +304,6 @@ impl<'a> GlobalJS<'a> {
 
     #[inline]
     pub fn platform_event_loop(self) -> &'a PlatformEventLoop {
-        // Spec shell.zig GlobalJS.platformEventLoop → JsVM.platformEventLoop:
-        //   posix: `vm.event_loop_handle.?`; windows: `vm.uvLoop()`.
         let vm = self.event_loop_ctx();
         #[cfg(windows)]
         // SAFETY: uv_loop() returns the live libuv loop owned by the VM; lifetime tied to 'a.
@@ -397,15 +386,11 @@ impl<'a> GlobalMini<'a> {
     pub fn enqueue_task_concurrent_wait_pid<T: 'static>(
         self,
         task: *mut T,
-        // PORT NOTE: Zig `.from(task, "runFromMainThreadMini")` resolves the callback by
-        // comptime decl-name lookup. Rust cannot reflect on a method by string, so callers
-        // pass `T::run_from_main_thread_mini` explicitly (mirrors AnyTaskWithExtraContext::from).
+        // Callers pass `T::run_from_main_thread_mini` explicitly (see
+        // `AnyTaskWithExtraContext::from`).
         run_from_main_thread_mini: fn(*mut T, *mut ()),
     ) {
         use bun_jsc::AnyTaskWithExtraContext::AnyTaskWithExtraContext;
-        // Spec shell.zig GlobalMini.enqueueTaskConcurrentWaitPid:
-        //   `var anytask = create(AnyTaskWithExtraContext); _ = anytask.from(task, "runFromMainThreadMini");
-        //    mini.enqueueTaskConcurrent(anytask);`
         let anytask = bun_core::heap::into_raw(Box::new(AnyTaskWithExtraContext::default()));
         // SAFETY: `anytask` was just heap-allocated and is exclusively owned here.
         unsafe { (*anytask).from(task, run_from_main_thread_mini) };
@@ -436,8 +421,6 @@ impl<'a> GlobalMini<'a> {
 
     #[inline]
     pub fn platform_event_loop(self) -> &'a PlatformEventLoop {
-        // Spec shell.zig GlobalMini.platformEventLoop → MiniVM.platformEventLoop:
-        //   posix: `mini.loop`; windows: `mini.loop.uv_loop`.
         #[cfg(windows)]
         // SAFETY: see `MiniEventLoop::loop_ptr()` invariant; `uv_loop` is its
         // embedded libuv loop, set once by `us_create_loop` and immutable.
@@ -493,8 +476,8 @@ impl CmdEnvKey<'_> {
 
 impl<'a> CmdEnvIter<'a> {
     pub fn from_env(env: &'a mut bun_collections::StringArrayHashMap<Box<ZStr>>) -> Self {
-        // PORT NOTE: `iterator()` borrows `&mut self`; rebind through a raw ptr so the
-        // struct can hold both the map ref and the iterator (Zig had no aliasing rules).
+        // Note: `iterator()` borrows `&mut self`; rebind through a raw ptr so the
+        // struct can hold both the map ref and the iterator.
         let env_ptr: *mut _ = env;
         // SAFETY: `env` outlives `'a` and is not mutated through `self.env` while `iter`
         // walks the backing arrays.
@@ -506,19 +489,16 @@ impl<'a> CmdEnvIter<'a> {
         self.env.len()
     }
 
-    pub fn next(&mut self) -> Result<Option<CmdEnvEntry<'a>>, bun_core::Error> {
-        // TODO(port): narrow error set — Zig sig is `!?Entry` but body never errors.
-        let Some(entry) = self.iter.next() else {
-            return Ok(None);
-        };
-        Ok(Some(CmdEnvEntry {
+    pub fn next(&mut self) -> Option<CmdEnvEntry<'a>> {
+        let entry = self.iter.next()?;
+        Some(CmdEnvEntry {
             key: CmdEnvKey {
                 val: &**entry.key_ptr,
             },
             value: CmdEnvValue {
                 val: &**entry.value_ptr,
             },
-        }))
+        })
     }
 }
 
@@ -599,8 +579,8 @@ pub mod test {
         }
     }
 
-    // ─── JSON serialization (port of `std.json.fmt(test_tokens, .{})`) ──────
-    // Zig: `union(TokenTag)` → `{"Tag":payload}`; void payload → `{"Tag":{}}`.
+    // ─── JSON serialization of test tokens ──────────────────────────────────
+    // Tagged variants serialize as `{"Tag":payload}`; unit payloads as `{"Tag":{}}`.
     use bun_shell_parser::json_fmt::{encode_json_string, write_redirect_flags};
     use core::fmt::Write as _;
 
@@ -664,7 +644,7 @@ pub mod test {
         }
     }
 
-    /// `Display` adapter mirroring `std.json.fmt(test_tokens.items, .{})`.
+    /// `Display` adapter that renders the token list as a JSON array.
     pub fn tokens_json_fmt<'b>(tokens: &'b [TestToken<'_>]) -> impl core::fmt::Display + 'b {
         struct Fmt<'a, 'b>(&'b [TestToken<'a>]);
         impl core::fmt::Display for Fmt<'_, '_> {
@@ -688,8 +668,7 @@ pub use test as Test;
 
 /// RAII owner for the `bun.String` array threaded through `shell_cmd_from_js` →
 /// `Interpreter::parse`. `bun.String` is `Copy` (no `Drop`) for FFI, so the
-/// per-element `deref()` from Zig's `defer { for (jsstrings.items) |bunstr|
-/// bunstr.deref(); jsstrings.deinit(); }` must be explicit. Wrapping the `Vec`
+/// per-element `deref()` must be explicit. Wrapping the `Vec`
 /// avoids the unit-state `scopeguard` + raw-pointer-reborrow pattern that is UB
 /// under Stacked Borrows (PORTING.md §Idiom-map: `defer <side effect>`).
 pub struct JsStrings(pub Vec<BunString>);
@@ -729,7 +708,7 @@ pub fn shell_cmd_from_js(
     string_args: JSValue,
     template_args: &mut JSArrayIterator,
     // SAFETY: every JSValue pushed into out_jsobjs is also appended to marked_argument_buffer
-    // (a GC root); the heap-backed Vec is index storage only, mirroring the Zig 1:1.
+    // (a GC root); the heap-backed Vec is index storage only.
     out_jsobjs: &mut Vec<JSValue>,
     jsstrings: &mut Vec<BunString>,
     out_script: &mut Vec<u8>,
@@ -752,7 +731,7 @@ pub fn shell_cmd_from_js(
                     return Err(global.throw(format_args!("Shell script is missing JSValue arg")));
                 }
             };
-            // PORT NOTE: builder holds &mut out_script/jsstrings; NLL releases the
+            // Note: builder holds &mut out_script/jsstrings; NLL releases the
             // borrow here (builder is reassigned below before next use).
             handle_template_value(
                 global,
@@ -1027,9 +1006,8 @@ impl<'a> ShellSrcBuilder<'a> {
         &mut self,
         utf8: &[u8],
     ) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set
         let invalid = simdutf::validate::utf8(utf8);
-        // PORT NOTE: Zig variable name `invalid` is misleading — it holds the validity bool.
+        // Note: the name `invalid` is misleading — it holds the validity bool.
         if !invalid {
             return Ok(false);
         }
@@ -1049,7 +1027,8 @@ impl<'a> ShellSrcBuilder<'a> {
         let size = simdutf::length::utf8::from::utf16::le(utf16);
         self.outbuf.reserve(size);
         strings::convert_utf16_to_utf8_append(self.outbuf, utf16);
-        // TODO(port): error mapping — Zig propagates encoding error directly.
+        // Infallible: invalid UTF-16 takes the WTF-8 fallback inside the
+        // conversion, and Rust aborts on OOM.
         Ok(())
     }
 
@@ -1065,8 +1044,7 @@ impl<'a> ShellSrcBuilder<'a> {
             self.append_utf8_impl(&latin1[..non_ascii_idx as usize])?;
         }
 
-        // Zig reassigns `self.outbuf.* = allocateLatin1IntoUTF8WithList(self.outbuf.*, …)`;
-        // mirror that by moving the Vec out, transforming, and storing back.
+        // Move the Vec out, transform it, and store it back.
         let len = self.outbuf.len();
         let buf = core::mem::take(self.outbuf);
         *self.outbuf = strings::allocate_latin1_into_utf8_with_list(buf, len, latin1);
@@ -1120,9 +1098,8 @@ pub mod testing_apis {
             let utf8str = bunstr.to_utf8();
 
             for disabled in crate::shell::builtin::Kind::DISABLED_ON_POSIX {
-                // Spec uses Zig `@tagName` (lowercase). `strum::IntoStaticStr`
-                // would yield the PascalCase variant name ("Cp"), so use
-                // `Kind::as_str` which mirrors the lowercase tag.
+                // `strum::IntoStaticStr` would yield the PascalCase variant name
+                // ("Cp"), so use `Kind::as_str` for the lowercase name.
                 if utf8str.slice() == disabled.as_str().as_bytes() {
                     return Ok(JSValue::TRUE);
                 }
@@ -1131,7 +1108,6 @@ pub mod testing_apis {
         }
     }
 
-    /// Spec shell.zig `TestingAPIs.shellLex` (`MarkedArgumentBuffer.wrap(_shellLex)`).
     /// Codegen (`generated_js2native.rs`) wraps this with `host_fn_result`, so we
     /// expose the bare `JsHostFnZig` signature here and do the buffer scope inline.
     pub fn shell_lex(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
@@ -1163,7 +1139,6 @@ pub mod testing_apis {
             }
         };
         let mut template_args = template_args_js.array_iterator(global)?;
-        // PERF(port): was stack-fallback (4 BunString) — profile if hot.
         let mut jsstrings = JsStrings::with_capacity(4);
         // SAFETY: every JSValue pushed here is also rooted in marked_argument_buffer.
         let mut jsobjs: Vec<JSValue> = Vec::new();
@@ -1207,13 +1182,14 @@ pub mod testing_apis {
             test_tokens.push(test_tok);
         }
 
-        // Spec: `std.fmt.allocPrint(..., "{f}", .{std.json.fmt(test_tokens.items, .{})})`.
         let str = format!("{}", test::tokens_json_fmt(&test_tokens[..]));
         let bun_str = BunString::from_bytes(str.as_bytes());
         bun_str.to_js(global)
     }
 
-    /// Spec shell.zig `TestingAPIs.shellParse` (`MarkedArgumentBuffer.wrap(_shellParse)`).
+    /// Testing API: parse the shell template-string arguments and return the
+    /// AST as a JSON string (or throw on a parse error). Arguments are pinned
+    /// in a `MarkedArgumentBuffer` for GC safety while parsing.
     pub fn shell_parse(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         MarkedArgumentBuffer::new(|buf| shell_parse_impl(global, callframe, buf))
     }
@@ -1243,7 +1219,6 @@ pub mod testing_apis {
             }
         };
         let mut template_args = template_args_js.array_iterator(global)?;
-        // PERF(port): was stack-fallback
         let mut jsstrings = JsStrings::with_capacity(4);
         // SAFETY: every JSValue pushed here is also rooted in marked_argument_buffer.
         let mut jsobjs: Vec<JSValue> = Vec::new();
@@ -1271,8 +1246,7 @@ pub mod testing_apis {
         ) {
             Ok(a) => a,
             Err(err) => {
-                // Spec: shell.zig TestingAPIs.shellParse — `if (err == ParseError.Lex)`
-                // ⇔ out_lex_result was populated by `parse()`.
+                // `out_lex_result` is populated by `parse()` only on lex errors.
                 if let Some(lex) = out_lex_result.as_ref() {
                     let str = lex.combine_errors(&arena);
                     return Err(global.throw_pretty(format_args!("{}", bstr::BStr::new(str))));
@@ -1287,7 +1261,6 @@ pub mod testing_apis {
             }
         };
 
-        // Spec: `std.fmt.allocPrint(..., "{f}", .{std.json.fmt(script_ast, .{})})`.
         // `crate::shell::ast::Script` is a `'static`-erased alias of
         // `bun_shell_parser::ast::Script`, so it formats directly.
         let str = format!(
@@ -1298,10 +1271,8 @@ pub mod testing_apis {
     }
 }
 pub use testing_apis as TestingAPIs;
-// `generated_js2native.rs` snake-cases Zig's `TestingAPIs` as `testing_ap_is`
+// `generated_js2native.rs` snake-cases `TestingAPIs` as `testing_ap_is`
 // (the codegen splits on capitalisation runs).
 pub use testing_apis as testing_ap_is;
 
 pub use subproc::ShellSubprocess;
-
-// ported from: src/shell/shell.zig
diff --git a/src/runtime/shell/states/Assigns.rs b/src/runtime/shell/states/Assigns.rs
index ecfedd475e3..7ff8313d7d3 100644
--- a/src/runtime/shell/states/Assigns.rs
+++ b/src/runtime/shell/states/Assigns.rs
@@ -127,8 +127,7 @@ impl Assigns {
         let label = node.slice()[*idx as usize].label;
         *idx += 1;
 
-        // Join multi-word expansions with a single space (Spec: Assigns.zig
-        // childDone). `ExpansionOut` stores all words contiguously in `buf`
+        // Join multi-word expansions with a single space. `ExpansionOut` stores all words contiguously in `buf`
         // with `bounds` marking inter-word offsets, so the merged value is
         // `buf` with a space inserted at each boundary.
         let value: Vec<u8> = if out.bounds.is_empty() {
@@ -145,7 +144,7 @@ impl Assigns {
             merged
         };
 
-        let value_ref = EnvStr::init_ref_counted(&value);
+        let value_ref = EnvStr::init_ref_counted(value.into_boxed_slice());
         interp.as_assigns_mut(this).base.shell_mut().assign_var(
             EnvStr::init_slice(label),
             value_ref,
@@ -161,5 +160,3 @@ impl Assigns {
         interp.as_assigns_mut(this).base.end_scope();
     }
 }
-
-// ported from: src/shell/states/Assigns.zig
diff --git a/src/runtime/shell/states/Async.rs b/src/runtime/shell/states/Async.rs
index 4ce72659492..e7424ab7db7 100644
--- a/src/runtime/shell/states/Async.rs
+++ b/src/runtime/shell/states/Async.rs
@@ -17,7 +17,11 @@ pub struct Async {
     pub io: IO,
     pub state: AsyncState,
     pub event_loop: EventLoopHandle,
-    // TODO(port): bun_jsc::EventLoopTask — concurrent_task field
+    /// Heap payload for the main-thread bounce. The node lives in the
+    /// reallocatable `Interpreter::nodes` arena, so the intrusive
+    /// concurrent-task node must live in a stable heap allocation instead.
+    /// Allocated in `init`, freed in `actually_deinit`.
+    task: *mut crate::shell::dispatch_tasks::ShellAsyncTask,
 }
 
 #[derive(Default, strum::IntoStaticStr)]
@@ -42,13 +46,22 @@ impl Async {
             .async_commands_executing
             .set(interp.async_commands_executing.get() + 1);
         let evtloop = interp.event_loop;
-        interp.alloc_node(Node::Async(Async {
+        let id = interp.alloc_node(Node::Async(Async {
             base: Base::new(StateKind::Async, parent, shell),
             node: bun_ptr::BackRef::new(node),
             io,
             state: AsyncState::Idle,
             event_loop: evtloop,
-        }))
+            task: core::ptr::null_mut(),
+        }));
+        // The payload needs the NodeId, so it's allocated after the node.
+        interp.as_async_mut(id).task =
+            bun_core::heap::alloc(crate::shell::dispatch_tasks::ShellAsyncTask {
+                interp: interp.as_ctx_ptr(),
+                node: id,
+                concurrent_task: Default::default(),
+            });
+        id
     }
 
     pub fn start(interp: &Interpreter, this: NodeId) -> Yield {
@@ -94,12 +107,10 @@ impl Async {
                     let me = interp.as_async(this);
                     (me.base.shell, me.io.clone(), me.node)
                 };
-                // Spec (Async.zig next() `.exec` arm, child==null): init the
-                // child WITHOUT starting it, store it, enqueue self, return
+                // Init the child WITHOUT starting it, store it, enqueue self, return
                 // suspended. The child is started on the NEXT event-loop tick
                 // via the `StartChild` arm above. Restricted to
-                // pipeline/cmd/if/condexpr — other Expr variants panic
-                // (Async.zig:102-104).
+                // pipeline/cmd/if/condexpr — other Expr variants panic.
                 let child = match node.get() {
                     ast::Expr::Pipeline(p) => Pipeline::init(interp, shell, *p, this, io),
                     ast::Expr::Cmd(c) => Cmd::init(interp, shell, *c, this, io),
@@ -138,9 +149,39 @@ impl Async {
         Yield::suspended()
     }
 
-    fn enqueue_self(_interp: &Interpreter, _this: NodeId) {
-        // TODO(port): bun_jsc::EventLoopHandle/EventLoopTask — schedule
-        // `run_from_main_thread` on the JS or mini event loop.
+    /// Bounce `run_from_main_thread` through the event loop so the async body runs on subsequent ticks while the
+    /// parent proceeds.
+    fn enqueue_self(interp: &Interpreter, this: NodeId) {
+        use bun_event_loop::{ConcurrentTask::AutoDeinit, EventLoopTaskPtr};
+        let me = interp.as_async_mut(this);
+        let task = me.task;
+        debug_assert!(!task.is_null());
+        match me.event_loop {
+            EventLoopHandle::Js { .. } => {
+                // SAFETY: `task` is the live heap payload allocated in `init`
+                // and freed only in `actually_deinit`. The embedded
+                // `ConcurrentTask` is reused for each bounce and is never
+                // in-flight twice: every enqueue is dispatched (dequeued)
+                // before the state machine can enqueue again.
+                unsafe {
+                    let ct = (*task).concurrent_task.from(task, AutoDeinit::ManualDeinit);
+                    me.event_loop.enqueue_task_concurrent(EventLoopTaskPtr {
+                        js: std::ptr::from_mut(ct),
+                    });
+                }
+            }
+            EventLoopHandle::Mini(_) => {
+                // The payload embeds only the JS-arm `ConcurrentTask`, so the
+                // mini arm heap-allocates an auto-deinit wrapper per bounce
+                // (same shape as `GlobalMini::enqueue_task_concurrent_wait_pid`).
+                let any = bun_jsc::AnyTaskWithExtraContext::AnyTaskWithExtraContext::from_callback_auto_deinit(
+                    task,
+                    run_from_main_thread_mini,
+                );
+                me.event_loop
+                    .enqueue_task_concurrent(EventLoopTaskPtr { mini: any });
+            }
+        }
     }
 
     /// `deinit` is purposefully empty: an `Async` appears "done" to its parent
@@ -148,6 +189,13 @@ impl Async {
     /// happens in `actually_deinit` once the background body finishes.
     pub fn actually_deinit(interp: &Interpreter, this: NodeId) {
         let me = interp.as_async_mut(this);
+        if !me.task.is_null() {
+            // SAFETY: allocated in `init`; the final bounce that reached
+            // `async_cmd_done` (and thus here) has already been dequeued and
+            // dispatched, so nothing else references the payload.
+            drop(unsafe { bun_core::heap::take(me.task) });
+            me.task = core::ptr::null_mut();
+        }
         me.base.end_scope();
     }
 
@@ -163,4 +211,23 @@ enum NextAction {
     Finish,
 }
 
-// ported from: src/shell/states/Async.zig
+// `runtime::dispatch::run_task`'s `task_tag::ShellAsync` arm casts the
+// enqueued pointer back to `ShellAsyncTask`; both sides MUST agree.
+impl bun_event_loop::Taskable for crate::shell::dispatch_tasks::ShellAsyncTask {
+    const TAG: bun_event_loop::TaskTag = bun_event_loop::task_tag::ShellAsync;
+}
+
+/// Mini-loop trampoline.
+fn run_from_main_thread_mini(
+    task: *mut crate::shell::dispatch_tasks::ShellAsyncTask,
+    _: *mut core::ffi::c_void,
+) {
+    // SAFETY: `task` is the live payload owned by the Async node; it is freed
+    // only in `actually_deinit`, which runs at the tail of this bounce chain
+    // (after the final `next()` dispatch), and `interp` outlives every node.
+    unsafe {
+        let interp = &*(*task).interp;
+        let node = (*task).node;
+        Async::run_from_main_thread(interp, node);
+    }
+}
diff --git a/src/runtime/shell/states/Base.rs b/src/runtime/shell/states/Base.rs
index 40191129b37..0c33e0f4eb5 100644
--- a/src/runtime/shell/states/Base.rs
+++ b/src/runtime/shell/states/Base.rs
@@ -1,10 +1,8 @@
 //! Base header struct embedded in every state-machine node.
 //!
-//! In Zig this carried `interpreter: *Interpreter` and `shell: *ShellExecEnv`
-//! back-pointers. In the NodeId-arena port the interpreter is passed as
-//! `&Interpreter` to every method, so only `parent: NodeId` and the
-//! `*mut ShellExecEnv` (which may be owned or borrowed — see field doc) are
-//! stored here.
+//! The interpreter is passed as `&Interpreter` to every method, so only
+//! `parent: NodeId` and the `*mut ShellExecEnv` (which may be owned or
+//! borrowed — see field doc) are stored here.
 
 use crate::shell::interpreter::{NodeId, ShellExecEnv, StateKind};
 
@@ -12,16 +10,14 @@ pub struct Base {
     pub kind: StateKind,
     /// Index of the parent node in `Interpreter::nodes`, or
     /// `NodeId::INTERPRETER` if the parent is the interpreter itself.
-    /// Replaces Zig's `parent: ParentPtr` tagged-pointer back-ref.
     pub parent: NodeId,
     /// Borrowed or owned in specific cases — affects whether this node must
     /// `deinit` it. Owned when created via `dupe_for_subshell` (Script,
     /// pipeline children, subshells, command substitutions); otherwise
     /// borrows the parent's env.
-    // TODO(port): lifetime — enum Owned(Box)/Borrowed once ShellExecEnv body
-    // is un-gated. Kept raw because the env may outlive this node's slot
-    // (shared across multiple children) and is freed by the owning node, not
-    // by Drop on Base.
+    // Kept raw (not an Owned(Box)/Borrowed enum) because the env may outlive
+    // this node's slot (shared across multiple children) and is freed by the
+    // owning node, not by Drop on Base.
     pub shell: *mut ShellExecEnv,
 }
 
@@ -34,9 +30,7 @@ impl Base {
         }
     }
 
-    /// No-op kept for call-site parity. Zig used this to flush the per-node
-    /// debug allocation scope; Rust ownership (`EnvStr`, `Box`, `Vec`) makes
-    /// that tracking redundant.
+    /// No-op kept for call-site parity.
     #[inline]
     pub fn end_scope(&mut self) {}
 
@@ -63,5 +57,3 @@ pub enum TryError {
     #[error("Sys")]
     Sys,
 }
-
-// ported from: src/shell/states/Base.zig
diff --git a/src/runtime/shell/states/Binary.rs b/src/runtime/shell/states/Binary.rs
index 94f1783deab..3da8ab94e8e 100644
--- a/src/runtime/shell/states/Binary.rs
+++ b/src/runtime/shell/states/Binary.rs
@@ -97,5 +97,3 @@ impl Binary {
         interp.as_binary_mut(this).base.end_scope();
     }
 }
-
-// ported from: src/shell/states/Binary.zig
diff --git a/src/runtime/shell/states/Cmd.rs b/src/runtime/shell/states/Cmd.rs
index f2c851a5190..805aeaff461 100644
--- a/src/runtime/shell/states/Cmd.rs
+++ b/src/runtime/shell/states/Cmd.rs
@@ -27,11 +27,10 @@ pub struct Cmd {
     pub redirection_fd: Option<*mut CowFd>,
     pub exec: Exec,
     pub exit_code: Option<ExitCode>,
-    /// PORT NOTE: in Zig this guarded the `spawn_arena` (an `ArenaAllocator`
-    /// holding argv/env scratch). The Rust port heap-allocates argv as
-    /// `Vec<Vec<u8>>` so there is no arena to free, but the flag is kept to
-    /// preserve `bufferedOutputClose`'s control-flow split (post-spawn vs
-    /// pre-spawn completion).
+    /// There is no spawn arena to free (argv is heap-allocated as
+    /// `Vec<Vec<u8>>`), but the flag is kept to preserve
+    /// `bufferedOutputClose`'s control-flow split (post-spawn vs pre-spawn
+    /// completion).
     pub spawn_arena_freed: bool,
 }
 
@@ -71,22 +70,19 @@ impl Cmd {
     }
 }
 
-/// Spec: Cmd.zig `Exec.subproc` anonymous struct.
 pub struct SubprocExec {
     pub child: *mut ShellSubprocess,
     pub buffered_closed: BufferedIoClosed,
     /// NodeId-arena backrefs so the legacy `&mut self` subprocess callbacks
     /// (`buffered_output_close` / `on_exit`) can hand a [`Yield`] back to the
-    /// trampoline. The Zig version called `this.next().run()` directly; here
-    /// the `Cmd` lives inside `interp.nodes`, so we stash the indices and
+    /// trampoline. The `Cmd` lives inside `interp.nodes`, so we stash the
+    /// indices and
     /// return `Yield::Next(this_id)` for the caller (`PipeReader::run_yield`)
     /// to drive.
     pub interp: *mut Interpreter,
     pub this_id: NodeId,
 }
 
-/// Spec: Cmd.zig `BufferedIoClosed`.
-///
 /// Tracks which subprocess stdio pipes are still open. Each `Option` is `None`
 /// if that fd was *not* piped (e.g. inherited / fd-backed), so it never gates
 /// completion. `Some(state)` means it was piped and must reach `Closed` before
@@ -124,7 +120,7 @@ impl Drop for BufferedIoState {
 }
 
 impl BufferedIoClosed {
-    /// Spec: `BufferedIoClosed.fromStdio`.
+    /// Build the per-fd closed/buffering state from the command's `Stdio` triple.
     pub(crate) fn from_stdio(io: &[Stdio; 3]) -> Self {
         const STDIN_NO: usize = 0;
         const STDOUT_NO: usize = 1;
@@ -148,7 +144,7 @@ impl BufferedIoClosed {
         }
     }
 
-    /// Spec: `BufferedIoClosed.allClosed`.
+    /// True once stdin, stdout, and stderr have all been closed.
     pub(crate) fn all_closed(&self) -> bool {
         let stdin_closed = self.stdin.unwrap_or(true);
         let stdout_closed = self.stdout.as_ref().is_none_or(BufferedIoState::closed);
@@ -164,12 +160,12 @@ impl BufferedIoClosed {
         ret
     }
 
-    /// Spec: `BufferedIoClosed.close` `.stdin` arm.
+    /// Mark stdin closed.
     pub(crate) fn close_stdin(&mut self) {
         self.stdin = Some(true);
     }
 
-    /// Spec: `BufferedIoClosed.close` `.stdout`/`.stderr` arms.
+    /// Close the stdout/stderr side.
     ///
     /// `readable` is the subprocess's `stdout`/`stderr` `Readable`; if it was
     /// a pipe its buffered bytes are taken (ownership moves into
@@ -258,7 +254,6 @@ impl Cmd {
                     continue;
                 }
                 CmdState::ExpandingAssigns => {
-                    // Spec (Cmd.zig childDone Assigns arm): assigns → redirect.
                     interp.as_cmd_mut(this).state = CmdState::ExpandingRedirect { idx: 0 };
                     continue;
                 }
@@ -284,7 +279,6 @@ impl Cmd {
                         // "already expanded" re-entry (`idx > 0`).
                         _ => {}
                     }
-                    // Spec (Cmd.zig next() expanding_redirect done): → args.
                     interp.as_cmd_mut(this).state = CmdState::ExpandingArgs { idx: 0 };
                     continue;
                 }
@@ -322,7 +316,9 @@ impl Cmd {
         }
     }
 
-    /// Spec: Cmd.zig `onIOWriterChunk` (lines 355-362).
+    /// IOWriter completion callback for the error message written in
+    /// `WaitingWriteErr`: throw on write failure, otherwise finish the Cmd
+    /// with exit code 1.
     pub fn on_io_writer_chunk(
         interp: &Interpreter,
         this: NodeId,
@@ -348,11 +344,11 @@ impl Cmd {
         exit_code: ExitCode,
     ) -> Yield {
         let child_kind = interp.node(child).kind();
-        // Spec (Cmd.zig childDone lines 364-398): a nonzero exit from an
+        // A nonzero exit from an
         // Assigns or Expansion child aborts the command — write the failing
         // error to stderr and finish with exit 1. Do NOT advance idx.
         if exit_code != 0 && matches!(child_kind, StateKind::Assign | StateKind::Expansion) {
-            // Spec (Cmd.zig childDone 384-396): pull the expansion error out
+            // Pull the expansion error out
             // before deiniting the child, then write it to stderr via
             // `writeFailingError("{f}\n", err)` and finish with exit 1.
             let err = if matches!(child_kind, StateKind::Expansion) {
@@ -379,7 +375,7 @@ impl Cmd {
                 CmdState::ExpandingArgs { ref mut idx } => {
                     *idx += 1;
                     let new_idx = *idx;
-                    // Spec (Cmd.zig childDone 400-409): when the sole
+                    // When the sole
                     // `name_and_args` atom is a `.simple == .cmd_subst`, stash
                     // `e.out_exit_code` so an empty-argv command consisting
                     // only of `$(cmd)` propagates `cmd`'s exit code via the
@@ -400,11 +396,11 @@ impl Cmd {
                             interp.as_cmd_mut(this).exit_code = Some(out.out_exit_code);
                         }
                     }
-                    // PORT NOTE: Zig used `out.bounds` to split into multiple
-                    // argv words (glob/IFS); preserved here verbatim.
+                    // `out.bounds` splits the expansion into multiple argv
+                    // words (glob/IFS).
                     let me = interp.as_cmd_mut(this);
                     if out.bounds.is_empty() {
-                        // Spec (Expansion.zig pushCurrentOut 652): an empty
+                        // An empty
                         // expansion that did *not* see a `""` literal pushes
                         // no arg at all — `$unset` vanishes, only `""` yields
                         // an empty argv word.
@@ -422,7 +418,7 @@ impl Cmd {
                 }
                 CmdState::ExpandingRedirect { ref mut idx } => {
                     *idx += 1;
-                    // Spec (Expansion.zig pushCurrentOut): NUL-terminate a
+                    // NUL-terminate a
                     // non-empty result; leave an empty expansion empty so the
                     // ambiguous-redirect check in `Builtin::init_redirections`
                     // still fires.
@@ -439,20 +435,17 @@ impl Cmd {
         Yield::Next(this)
     }
 
-    /// Spec: Cmd.zig `transitionToExecStateAndYield()` + `initSubproc()` up
-    /// through the `Builtin.Kind.fromStr` branch. Resolves argv[0] to a
-    /// builtin or falls through to subprocess spawn (still gated).
+    /// Resolves argv[0] to a builtin or falls through to subprocess spawn
+    /// (still gated).
     fn transition_to_exec(interp: &Interpreter, this: NodeId) -> Yield {
         // NUL-terminate every arg so builtins can borrow them as `*const c_char`.
-        // (Zig stored argv as `[*:0]const u8`; the Rust port collected them as
-        // `Vec<u8>` from Expansion.)
         for a in &mut interp.as_cmd_mut(this).args {
             if a.last() != Some(&0) {
                 a.push(0);
             }
         }
 
-        // Spec (Cmd.zig initSubproc lines 442-456): empty/null argv[0] → exit
+        // Empty/null argv[0] → exit
         // with the exit code from a sole command-substitution (stashed by
         // `child_done` from `Expansion::out_exit_code`), else 0.
         let first_arg: Vec<u8> = {
@@ -479,8 +472,8 @@ impl Cmd {
             return Builtin::start(interp, this);
         }
 
-        // ── Subprocess path (Spec: Cmd.zig `initSubproc` lines 487-546) ────
-        // PORT NOTE: `SpawnArgs` borrows only the local `arena` (its
+        // ── Subprocess path ─────────────────────────────────────────────────
+        // `SpawnArgs` borrows only the local `arena` (its
         // `interp`/`argv` fields are raw pointers), so `interp: &mut
         // Interpreter` is freely re-borrowable at every step before
         // `spawn_async`. Re-enter the arena via `interp.as_cmd{,_mut}(this)`
@@ -499,7 +492,7 @@ impl Cmd {
         // SAFETY: `shell_ptr` is the live env owned by this Cmd's scope chain.
         spawn_args.cwd = unsafe { &*shell_ptr }.cwd();
 
-        // Resolve argv[0] via PATH (`bun_which::which`). Spec lines 487-498.
+        // Resolve argv[0] via PATH (`bun_which::which`).
         let resolved: Option<Vec<u8>> = {
             let mut path_buf = bun_paths::path_buffer_pool::get();
             match bun_which::which(&mut *path_buf, spawn_args.path, spawn_args.cwd, &first_arg) {
@@ -513,9 +506,8 @@ impl Cmd {
             }
         };
         let Some(mut resolved) = resolved else {
-            // Spec (Cmd.zig:493): writeFailingError("bun: command not found:
-            // {s}\n") → `.waiting_write_err` → onIOWriterChunk →
-            // `parent.childDone(this, 1)`.
+            // writeFailingError("bun: command not found: {s}\n") →
+            // `.waiting_write_err` → onIOWriterChunk → `parent.childDone(this, 1)`.
             drop(spawn_args);
             return Builtin::cmd_write_failing_error(
                 interp,
@@ -552,7 +544,7 @@ impl Cmd {
         resolved.push(0);
         interp.as_cmd_mut(this).args[0] = resolved;
 
-        // Fill env from export_env + cmd_local_env. Spec lines 502-506.
+        // Fill env from export_env + cmd_local_env.
         {
             let env = interp.as_cmd_mut(this).base.shell_mut();
             let mut iter = env.export_env.iterator();
@@ -561,14 +553,14 @@ impl Cmd {
             spawn_args.fill_env::<false>(&mut iter);
         }
 
-        // Convert shell IO → subprocess stdio. Spec lines 509-511.
+        // Convert shell IO → subprocess stdio.
         let mut shellio = ShellIO::default();
         interp
             .as_cmd(this)
             .io
             .to_subproc_stdio(&mut spawn_args.stdio, &mut shellio);
 
-        // Spec lines 513-515 / 548-640: apply file/jsbuf/`2>&1` redirects on
+        // Apply file/jsbuf/`2>&1` redirects on
         // top of the IO-derived stdio.
         match Self::init_subproc_redirections(interp, this, &mut spawn_args.stdio) {
             Ok(None) => {}
@@ -659,7 +651,7 @@ impl Cmd {
         }
 
         // Read the subprocess back via the arena instead of holding `child_out`
-        // across the call (spec: `.result => this.exec.subproc.child`).
+        // across the call.
         let child: *mut ShellSubprocess = match &interp.as_cmd(this).exec {
             Exec::Subproc(sub) => sub.child,
             _ => unreachable!(),
@@ -668,14 +660,13 @@ impl Cmd {
         // pointer into `*child_out` (== `sub.child`); valid until `Cmd::deinit`
         // reclaims the box. Single-threaded.
         let subproc = unsafe { &mut *child };
-        // Spec order (Cmd.zig 531-533): `subproc.ref()` precedes
-        // `spawn_arena_freed = true; arena.deinit()`.
+        // Ordering: `subproc.ref()` precedes `spawn_arena_freed = true`.
         subproc.r#ref();
         interp.as_cmd_mut(this).spawn_arena_freed = true;
         drop(arena);
 
         if did_exit_immediately {
-            // Spec lines 535-544. `watch()` failed → process already gone.
+            // `watch()` failed → process already gone.
             let process = subproc.proc();
             if process.has_exited() {
                 let status = process.status.clone();
@@ -700,7 +691,7 @@ impl Cmd {
         Yield::suspended()
     }
 
-    /// Spec: Cmd.zig `initRedirections` (lines 548-640). Applies the AST
+    /// Applies the AST
     /// redirect (`> file`, `< ${blob}`, `2>&1`, …) onto the subprocess stdio
     /// triple. Returns `Ok(Some(yield))` when the redirect failed and a
     /// failing-error write was queued; `Err` when a JS exception was raised.
@@ -883,7 +874,6 @@ impl Cmd {
         Yield::Next(this)
     }
 
-    /// Spec: interpreter.zig `ShellAsyncSubprocessDone.runFromMainThread` body.
     /// Main-thread re-entry for a subprocess exit posted from off-thread —
     /// equivalent to [`Self::on_exec_done`] but drives the trampoline itself
     /// since the dispatcher discards the [`Yield`].
@@ -900,7 +890,7 @@ impl Cmd {
             // SAFETY: `fd` is the +1 ref held in `me.redirection_fd`.
             CowFd::deref(fd);
         }
-        // Spec (Cmd.zig deinit lines 715-730): tear down the running exec.
+        // Tear down the running exec.
         match core::mem::take(&mut me.exec) {
             Exec::None => {}
             Exec::Builtin(b) => drop(b),
@@ -922,23 +912,22 @@ impl Cmd {
             // subprocess box was returned. Nothing to tear down.
             Exec::Subproc(_) => {}
         }
-        // PORT NOTE: spec frees `spawn_arena` here unless `spawn_arena_freed`.
-        // Argv/env are heap-owned `Vec`s in the port; nothing arena-backed to
-        // free.
+        // Argv/env are heap-owned `Vec`s; there is no spawn arena to free (see
+        // `spawn_arena_freed`).
         // `base.shell` is borrowed (or, when parent is Pipeline, freed by
         // `Pipeline::child_done` before this runs) — never freed here.
         me.base.end_scope();
     }
 
     // ── Subprocess callbacks (legacy `*Cmd` backref shape) ────────────────
-    // Spec: Cmd.zig `bufferedInputClose` / `bufferedOutputClose` / `onExit`.
     // `ShellSubprocess` / `PipeReader` hold a `*mut Cmd` backref and call
     // these via `&mut self`. The NodeId-arena port stashes `(interp, this_id)`
     // on `SubprocExec` so the resulting `Yield` can be driven by the caller's
     // `PipeReader::run_yield` without aliasing `&Interpreter` against
     // `&mut self`.
 
-    /// Spec: Cmd.zig `hasFinished`.
+    /// True once the command has both an exit code and (for subprocesses)
+    /// all buffered stdio closed.
     pub fn has_finished(&self) -> bool {
         log!("Cmd has_finished exit_code={:?}", self.exit_code);
         if self.exit_code.is_none() {
@@ -951,14 +940,16 @@ impl Cmd {
         }
     }
 
-    /// Spec: Cmd.zig `bufferedInputClose`.
+    /// Mark the subprocess's buffered stdin as closed.
     pub fn buffered_input_close(&mut self) {
         if let Exec::Subproc(sub) = &mut self.exec {
             sub.buffered_closed.close_stdin();
         }
     }
 
-    /// Spec: Cmd.zig `bufferedOutputClose`.
+    /// Mark the subprocess's buffered stdout/stderr as closed (flushing the
+    /// captured bytes into the shell buffers); if that makes the command
+    /// finished, transition to `Done` and yield back to the trampoline.
     pub fn buffered_output_close(
         &mut self,
         kind: OutKind,
@@ -969,15 +960,10 @@ impl Cmd {
             OutKind::Stderr => self.buffered_output_close_stderr(err),
         }
         if self.has_finished() {
-            // Spec: `if (!spawn_arena_freed)` enqueues a
-            // `ShellAsyncSubprocessDone` task; else returns
-            // `parent.childDone(this, exit_code)` directly. Both paths land in
-            // `Cmd::next` → `CmdState::Done` → `interp.child_done(...)`. In
-            // the NodeId-arena port we set `state = Done` and hand the Yield
-            // back to the caller (`PipeReader::run_yield`), which drives the
-            // trampoline with the `*mut Interpreter` it already holds —
-            // semantically the `else` branch (post-spawn `spawn_arena_freed`
-            // is always true by the time a pipe closes).
+            // Set `state = Done` and hand the Yield back to the caller
+            // (`PipeReader::run_yield`), which drives the trampoline with the
+            // `*mut Interpreter` it already holds, landing in `Cmd::next` →
+            // `CmdState::Done` → `interp.child_done(...)`.
             self.state = CmdState::Done;
             let this_id = match &self.exec {
                 Exec::Subproc(sub) => sub.this_id,
@@ -985,7 +971,7 @@ impl Cmd {
                 // through `Builtin::done` → `on_exec_done`.
                 _ => return Yield::suspended(),
             };
-            // PORT NOTE: the `!spawn_arena_freed` arm
+            // The `!spawn_arena_freed` arm
             // (`ShellAsyncSubprocessDone::enqueue`) is unreachable here in
             // practice — `initSubproc` sets `spawn_arena_freed = true` before
             // any pipe can close. Kept as the same `Yield::Next` since the
@@ -996,7 +982,6 @@ impl Cmd {
         Yield::suspended()
     }
 
-    /// Spec: Cmd.zig `bufferedOutputCloseStdout`.
     fn buffered_output_close_stdout(&mut self, err: Option<bun_sys::SystemError>) {
         debug_assert!(matches!(self.exec, Exec::Subproc(_)));
         log!("cmd close buffered stdout");
@@ -1010,9 +995,8 @@ impl Cmd {
         // Raw deref keeps the borrow disjoint from `sub.buffered_closed` below.
         // SAFETY: `child` is the live subprocess owned by this Cmd.
         let child = unsafe { &mut *sub.child };
-        // Spec: tee into the JS-side captured buffer if `io.stdout == .fd`
-        // with a `captured` slot and the redirect didn't send stdout
-        // elsewhere.
+        // Tee into the JS-side captured buffer if stdout is an fd with a
+        // `captured` slot and the redirect didn't send stdout elsewhere.
         if let IoOutKind::Fd(fd) = &self.io.stdout {
             // SAFETY: single-threaded; the captured `Vec<u8>` lives in the
             // owning `ShellExecEnv` and no other borrow of it is live here.
@@ -1034,7 +1018,6 @@ impl Cmd {
         child.close_io(StdioKind::Stdout);
     }
 
-    /// Spec: Cmd.zig `bufferedOutputCloseStderr`.
     fn buffered_output_close_stderr(&mut self, err: Option<bun_sys::SystemError>) {
         debug_assert!(matches!(self.exec, Exec::Subproc(_)));
         log!("cmd close buffered stderr");
@@ -1069,15 +1052,15 @@ impl Cmd {
         child.close_io(StdioKind::Stderr);
     }
 
-    /// Spec: Cmd.zig `onExit` — called by `ShellSubprocess::on_process_exit`.
+    /// Called by `ShellSubprocess::on_process_exit`.
     pub fn on_exit(&mut self, exit_code: ExitCode) {
         self.exit_code = Some(exit_code);
         let has_finished = self.has_finished();
         log!("cmd exit code={} has_finished={}", exit_code, has_finished);
         if has_finished {
             self.state = CmdState::Done;
-            // Spec: `this.next().run()`. In the NodeId-arena port `self` lives
-            // inside `interp.nodes`, so we resume via the stashed backrefs.
+            // `self` lives inside `interp.nodes`, so resume via the stashed
+            // backrefs.
             let (interp, this_id) = match &self.exec {
                 Exec::Subproc(sub) => (sub.interp, sub.this_id),
                 _ => return,
@@ -1095,7 +1078,6 @@ impl Cmd {
     }
 }
 
-/// Spec: Cmd.zig `setStdioFromRedirect`.
 fn set_stdio_from_redirect(stdio: &mut [Stdio; 3], flags: ast::RedirectFlags, fd: bun_sys::Fd) {
     if flags.stdin() {
         stdio[0] = Stdio::Fd(fd);
@@ -1112,5 +1094,3 @@ fn set_stdio_from_redirect(stdio: &mut [Stdio; 3], flags: ast::RedirectFlags, fd
         }
     }
 }
-
-// ported from: src/shell/states/Cmd.zig
diff --git a/src/runtime/shell/states/CondExpr.rs b/src/runtime/shell/states/CondExpr.rs
index 4e89f64231a..9b97b81232d 100644
--- a/src/runtime/shell/states/CondExpr.rs
+++ b/src/runtime/shell/states/CondExpr.rs
@@ -50,8 +50,7 @@ impl CondExpr {
     }
 
     pub(crate) fn next(interp: &Interpreter, this: NodeId) -> Yield {
-        // Spec: CondExpr.zig `next()` — expand each arg via Expansion, then
-        // evaluate the operator.
+        // Expand each arg via Expansion, then evaluate the operator.
         loop {
             let (shell, node) = {
                 let me = interp.as_condexpr(this);
@@ -92,14 +91,14 @@ impl CondExpr {
         }
     }
 
-    /// Spec: CondExpr.zig `commandImplStart`. Evaluates the operator against
+    /// Evaluates the operator against
     /// the expanded `args` and returns the resulting exit code.
     fn command_impl_start(interp: &Interpreter, this: NodeId, op: ast::CondExprOp) -> Yield {
         use ast::CondExprOp as Op;
         let parent = interp.as_condexpr(this).base.parent;
         match op {
             Op::DashC | Op::DashD | Op::DashF => {
-                // Spec: empty expansion or empty path → exit 1 (bash always
+                // Empty expansion or empty path → exit 1 (bash always
                 // gives 1; Windows `stat("")` can succeed and return cwd's
                 // stat, so the empty-path check must be explicit).
                 let path_empty = {
@@ -109,12 +108,9 @@ impl CondExpr {
                 if path_empty {
                     return interp.child_done(parent, this, 1);
                 }
-                // PORT NOTE: spec posts a `ShellCondExprStatTask` to the
-                // thread pool then resumes via `.stat_complete`. The async
-                // task plumbing isn't wired into the NodeId trampoline yet,
-                // so call `shell_statat` synchronously and evaluate inline.
-                // TODO(port): route through ShellCondExprStatTask once
-                // ShellTask scheduling is un-gated.
+                // Post a
+                // `ShellCondExprStatTask` to the thread pool; the result comes
+                // back on the main thread via `on_stat_task_done`.
                 let (cwd_fd, mut path) = {
                     let me = interp.as_condexpr(this);
                     let cwd_fd = me.base.shell().cwd_fd;
@@ -123,22 +119,8 @@ impl CondExpr {
                 if path.last() != Some(&0) {
                     path.push(0);
                 }
-                let z = bun_core::ZStr::from_buf(&path, path.len() - 1);
-                let stat = crate::shell::interpreter::shell_statat(cwd_fd, z);
-                let exit = match stat {
-                    Err(_) => 1, // Spec: "bash always gives exit code 1".
-                    Ok(st) => {
-                        let mode = st.st_mode as _;
-                        let ok = match op {
-                            Op::DashF => bun_sys::S::ISREG(mode),
-                            Op::DashD => bun_sys::S::ISDIR(mode),
-                            Op::DashC => bun_sys::S::ISCHR(mode),
-                            _ => unreachable!(),
-                        };
-                        if ok { 0 } else { 1 }
-                    }
-                };
-                interp.child_done(parent, this, exit)
+                interp.as_condexpr_mut(this).state = CondExprState::WaitingStat;
+                Self::do_stat(interp, this, cwd_fd, path)
             }
             Op::DashZ => {
                 let exit = {
@@ -184,13 +166,15 @@ impl CondExpr {
                     !ast::CondExprOp::is_supported(op),
                     "supported CondExprOp not handled in command_impl_start"
                 );
-                // Spec: unsupported op is unreachable (parser rejects it).
+                // Unsupported op is unreachable (parser rejects it).
                 interp.child_done(parent, this, 1)
             }
         }
     }
 
-    /// Spec: CondExpr.zig `onIOWriterChunk` (lines 267-279).
+    /// IOWriter completion callback for the error message written in
+    /// `WaitingWriteErr`: on write failure finish with the errno as the exit
+    /// code, otherwise finish with exit code 1.
     pub(crate) fn on_io_writer_chunk(
         interp: &Interpreter,
         this: NodeId,
@@ -199,8 +183,7 @@ impl CondExpr {
     ) -> Yield {
         let parent = interp.as_condexpr(this).base.parent;
         if let Some(e) = err {
-            // Spec: `@intFromEnum(err.?.getErrno())` — recover the positive
-            // errno (`to_shell_system_error` negated it).
+            // Recover the positive errno (`to_shell_system_error` negated it).
             let exit_code: ExitCode = e.errno.unsigned_abs() as ExitCode;
             return interp.child_done(parent, this, exit_code);
         }
@@ -216,7 +199,7 @@ impl CondExpr {
         )
     }
 
-    /// Spec: CondExpr.zig `onStatTaskComplete`. Main-thread re-entry for the
+    /// Main-thread re-entry for the
     /// off-thread `stat`/`lstat` posted by a unary file-test operator.
     pub(crate) fn on_stat_task_done(
         interp: &Interpreter,
@@ -224,8 +207,7 @@ impl CondExpr {
         stat: &bun_sys::Result<bun_sys::Stat>,
         path: &[u8],
     ) {
-        // Spec: CondExpr.zig `onStatTaskComplete` + `.stat_complete` arm of
-        // `next()` — evaluate `op` against the stat result.
+        // Evaluate `op` against the stat result.
         let _ = path;
         debug_assert!(matches!(
             interp.as_condexpr(this).state,
@@ -258,13 +240,22 @@ impl CondExpr {
         exit_code: ExitCode,
     ) -> Yield {
         // Child is always an Expansion that produced one arg.
-        // Spec: CondExpr.zig `childDone` — on nonzero, write the failing
-        // error and finish; otherwise collect the expanded word and advance.
+        // On nonzero exit, write the failing error and finish; otherwise
+        // collect the expanded word and advance.
         if exit_code != 0 {
-            // TODO(port): writeFailingError("{f}\n", err) — IOWriter path.
+            // Pull the expansion error out before deiniting the child, then
+            // write the failing error.
+            let err = Expansion::take_err(interp, child);
             interp.deinit_node(child);
+            if let Some(err) = err {
+                let y = Self::write_failing_error(interp, this, format_args!("{}\n", err));
+                err.deinit();
+                return y;
+            }
+            // Defensive fallback — finish via `writeFailingError` with exit 1.
+            debug_assert!(false, "Expansion child failed without an error");
             let parent = interp.as_condexpr(this).base.parent;
-            return interp.child_done(parent, this, exit_code);
+            return interp.child_done(parent, this, 1);
         }
         let out = Expansion::take_out(interp, child);
         interp.deinit_node(child);
@@ -278,6 +269,78 @@ impl CondExpr {
         Yield::Next(this)
     }
 
+    /// Heap-allocate a `ShellCondExprStatTask`
+    /// and hand it to the work pool; `run_from_thread_pool` performs the
+    /// `statat`, then the main thread resumes via
+    /// `ShellCondExprStatTask::run_from_main_thread` → `on_stat_task_done`.
+    /// `path` is NUL-terminated by the caller.
+    fn do_stat(interp: &Interpreter, this: NodeId, cwd_fd: bun_sys::Fd, path: Vec<u8>) -> Yield {
+        use crate::shell::dispatch_tasks::{CondExprStatInner, ShellCondExprStatTask};
+        use crate::shell::interpreter::ShellTask;
+        debug_assert!(path.last() == Some(&0));
+        let mut task = ShellTask::new(interp.event_loop);
+        task.interp = interp.as_ctx_ptr();
+        let stat_task = bun_core::heap::alloc(ShellCondExprStatTask {
+            task: CondExprStatInner {
+                task,
+                cond: this,
+                // Placeholder — always overwritten by `run_from_thread_pool`
+                // before the main thread reads it.
+                stat: Err(Default::default()),
+                path,
+                cwd_fd,
+            },
+        });
+        // SAFETY: `stat_task` is a fresh heap allocation embedding `ShellTask`
+        // at `TASK_OFFSET`; consumed (heap::take) in
+        // `ShellCondExprStatTask::run_from_main_thread`.
+        unsafe { ShellTask::schedule::<ShellCondExprStatTask>(stat_task) };
+        Yield::suspended()
+    }
+
+    /// Same shape as `Builtin::cmd_write_failing_error`: `.fd` stderr
+    /// enqueues an async
+    /// write and parks in `WaitingWriteErr` (resumed by
+    /// `on_io_writer_chunk`); otherwise append to the captured stderr buffer
+    /// and finish with exit 1.
+    fn write_failing_error(
+        interp: &Interpreter,
+        this: NodeId,
+        args: core::fmt::Arguments<'_>,
+    ) -> Yield {
+        use crate::shell::io::OutKind;
+        use crate::shell::io_writer;
+        use std::io::Write as _;
+        let mut buf = Vec::new();
+        let _ = buf.write_fmt(args);
+        if interp.as_condexpr(this).io.stderr.needs_io().is_some() {
+            // Only the fd arm transitions state.
+            interp.as_condexpr_mut(this).state = CondExprState::WaitingWriteErr;
+            let child = io_writer::ChildPtr::new(this, io_writer::WriterTag::CondExpr);
+            // `OutKind::Fd` guaranteed by `needs_io()`.
+            if let OutKind::Fd(fd) = &interp.as_condexpr(this).io.stderr {
+                return fd.writer.enqueue(child, fd.captured, &buf);
+            }
+            unreachable!()
+        }
+        // No-IO path: append to the shell env's captured stderr and finish
+        // synchronously with exit 1 (matches `on_io_writer_chunk`).
+        if let OutKind::Pipe = &interp.as_condexpr(this).io.stderr {
+            // SAFETY: single trampoline frame; no other borrow of the env's
+            // (or its parent's) stderr buffer is live.
+            let stderr = unsafe {
+                interp
+                    .as_condexpr_mut(this)
+                    .base
+                    .shell_mut()
+                    .buffered_stderr_mut()
+            };
+            stderr.extend_from_slice(&buf);
+        }
+        let parent = interp.as_condexpr(this).base.parent;
+        interp.child_done(parent, this, 1)
+    }
+
     pub(crate) fn deinit(interp: &Interpreter, this: NodeId) {
         log!("CondExpr {} deinit", this);
         let me = interp.as_condexpr_mut(this);
@@ -286,4 +349,32 @@ impl CondExpr {
     }
 }
 
-// ported from: src/shell/states/CondExpr.zig
+// `runtime::dispatch::run_task`'s `task_tag::ShellCondExprStatTask` arm casts
+// the enqueued pointer back to `ShellCondExprStatTask`; both sides MUST agree.
+impl bun_event_loop::Taskable for crate::shell::dispatch_tasks::ShellCondExprStatTask {
+    const TAG: bun_event_loop::TaskTag = bun_event_loop::task_tag::ShellCondExprStatTask;
+}
+
+impl crate::shell::interpreter::ShellTaskCtx
+    for crate::shell::dispatch_tasks::ShellCondExprStatTask
+{
+    // The `ShellTask` is embedded one level down (`.task.task`); the dispatch
+    // arm (`shell_dispatch!(nested ...)`) walks the same two hops.
+    const TASK_OFFSET: usize =
+        core::mem::offset_of!(crate::shell::dispatch_tasks::ShellCondExprStatTask, task)
+            + core::mem::offset_of!(crate::shell::dispatch_tasks::CondExprStatInner, task);
+
+    fn run_from_thread_pool(this: &mut Self) {
+        let inner = &mut this.task;
+        debug_assert!(inner.path.last() == Some(&0));
+        let z = bun_core::ZStr::from_buf(&inner.path, inner.path.len() - 1);
+        inner.stat = crate::shell::interpreter::shell_statat(inner.cwd_fd, z);
+    }
+
+    fn run_from_main_thread(this: *mut Self, interp: &Interpreter) {
+        // Delegates to the inherent fn in `dispatch_tasks.rs` (which consumes
+        // the heap allocation). The dispatch arm calls the inherent fn
+        // directly; this trait method exists to satisfy `ShellTaskCtx`.
+        crate::shell::dispatch_tasks::ShellCondExprStatTask::run_from_main_thread(this, interp);
+    }
+}
diff --git a/src/runtime/shell/states/Expansion.rs b/src/runtime/shell/states/Expansion.rs
index 4cc203a2a58..26181fd9711 100644
--- a/src/runtime/shell/states/Expansion.rs
+++ b/src/runtime/shell/states/Expansion.rs
@@ -20,16 +20,15 @@ pub struct Expansion {
     pub io: IO,
     pub state: ExpansionState,
     /// Index of the next sub-atom to expand. For `Atom::Simple` this is 0/1;
-    /// for `Atom::Compound` it walks `c.atoms`. Spec: Expansion.zig `word_idx`.
+    /// for `Atom::Compound` it walks `c.atoms`.
     pub word_idx: u32,
-    /// Output sink the parent provided. The Zig version stored a
-    /// `*anyopaque + vtable` so any parent could receive expanded strings;
-    /// in the NodeId port the parent is reachable via `base.parent`, so the
-    /// sink is just a buffer the parent reads back on `child_done`.
+    /// Output sink the parent provided. The parent is reachable via
+    /// `base.parent`, so the sink is just a buffer the parent reads back on
+    /// `child_done`.
     pub out: ExpansionOut,
     /// Working buffer for the *current* word being assembled. When a word
     /// boundary is hit (IFS split / glob result), it is flushed into `out`
-    /// via `push_current_out`. Spec: Expansion.zig `current_out`.
+    /// via `push_current_out`.
     pub current_out: Vec<u8>,
     /// Byte offsets in `current_out` written by literal metacharacter atoms
     /// (`Asterisk`/`DoubleAsterisk`/`BraceBegin`/`Comma`/`BraceEnd`). Only
@@ -42,14 +41,14 @@ pub struct Expansion {
     /// Whether the in-flight command substitution was `"$(...)"` (no IFS
     /// splitting on its result). Only meaningful while `state == CmdSubst`.
     pub cmd_subst_quoted: bool,
-    /// Spec: Expansion.zig `has_quoted_empty`. Set when a `""`/`''` literal
+    /// Set when a `""`/`''` literal
     /// was seen so an *empty* expansion is still pushed as an argv word.
     /// Without this, `$unset` and `""` are indistinguishable in
     /// [`ExpansionOut`] (both → `buf=[], bounds=[]`) and Cmd would push an
     /// empty arg for unset vars — diverging from POSIX field-splitting.
     pub has_quoted_empty: bool,
-    /// Exit code of a sole-command-substitution arg. Spec: Expansion.zig
-    /// `out_exit_code` — propagated to `Cmd` so `$(false)` as argv0 fails.
+    /// Exit code of a sole-command-substitution arg — propagated to `Cmd`
+    /// so `$(false)` as argv0 fails.
     pub out_exit_code: ExitCode,
 }
 
@@ -62,7 +61,7 @@ pub enum ExpansionState {
     Glob,
     BraceExpand,
     Done,
-    /// Spec: Expansion.zig `.err`. The parent inspects this on
+    /// The parent inspects this on
     /// `child_done(_, 1)` to print the message.
     Err(Box<ShellErr>),
 }
@@ -72,12 +71,12 @@ pub struct ExpansionOut {
     pub buf: Vec<u8>,
     /// Word boundaries within `buf` (for IFS splitting / glob results).
     pub bounds: Vec<u32>,
-    /// Spec: `Expansion.out_exit_code`. Set when the atom is a sole `$(…)`
+    /// Set when the atom is a sole `$(…)`
     /// that exited non-zero, so [`Cmd::child_done`] can propagate it as the
     /// command's exit code when that substitution was argv0 and argv is
     /// otherwise empty.
     pub out_exit_code: ExitCode,
-    /// Spec: Expansion.zig `has_quoted_empty`. When `buf`/`bounds` are both
+    /// When `buf`/`bounds` are both
     /// empty, this distinguishes `""` (push one empty arg) from `$unset`
     /// (push no arg). See [`Expansion::has_quoted_empty`].
     pub has_quoted_empty: bool,
@@ -123,7 +122,7 @@ impl Expansion {
         Yield::Next(this)
     }
 
-    /// Spec: Expansion.zig `next()` + `expandVarAndCmdSubst()`. Walks the
+    /// Walks the
     /// atom, appending no-IO expansions to `current_out` and yielding to a
     /// child `Script` whenever a `$(...)` is encountered. Re-entered after
     /// `child_done` advances `word_idx`.
@@ -151,8 +150,7 @@ impl Expansion {
                 ExpansionState::BraceExpand => {
                     Self::do_brace_expand(me);
                     // brace + glob composes: after pushing the literal brace
-                    // variants, glob the original pattern (Zig re-enters the
-                    // `.glob` state). The normal glob path likewise calls
+                    // variants, glob the original pattern. The normal glob path likewise calls
                     // `transition_to_glob_state` directly (see below).
                     if matches!(me.state, ExpansionState::Glob) {
                         return Self::transition_to_glob_state(interp, this);
@@ -169,7 +167,7 @@ impl Expansion {
             let atom = node.get();
             let atoms_len = atom.atoms_len();
             // Leading `~` in a compound is skipped during the walk and
-            // post-processed below (Spec: Expansion.zig next() lines 186-203).
+            // post-processed below.
             let leading_tilde = matches!(atom, ast::Atom::Compound(c)
                 if c.atoms.first().is_some_and(|a| matches!(a, ast::SimpleAtom::Tilde)));
             if me.word_idx == 0 && leading_tilde {
@@ -199,7 +197,7 @@ impl Expansion {
                     continue;
                 }
                 // ── Command substitution: spawn a Script with stdout piped
-                //    into a fresh owned buffer. Spec: expandVarAndCmdSubst.
+                //    into a fresh owned buffer.
                 let ast::SimpleAtom::CmdSubst(sub) = simple else {
                     unreachable!()
                 };
@@ -239,7 +237,7 @@ impl Expansion {
                         me.current_out.splice(0..0, home.slice().iter().copied());
                     }
                     Some(_) => me.current_out.insert(0, b'~'),
-                    // Spec (Expansion.zig 199-202): `~""` expands to $HOME,
+                    // `~""` expands to $HOME,
                     // but `~$unset` expands to nothing (word is dropped).
                     None if me.has_quoted_empty => {
                         me.current_out.extend_from_slice(home.slice());
@@ -259,7 +257,7 @@ impl Expansion {
                 }
                 home.deref();
             }
-            // Spec (Expansion.zig next() lines 209-221): brace expansion
+            // Brace expansion
             // first, then glob, else flush as a single word.
             if atom.has_brace_expansion() {
                 me.state = ExpansionState::BraceExpand;
@@ -280,7 +278,7 @@ impl Expansion {
         interp.child_done(parent, this, exit)
     }
 
-    /// Spec: Expansion.zig `.braces` arm. Re-tokenize `current_out` (the
+    /// Re-tokenize `current_out` (the
     /// fully-expanded word with `{`/`,`/`}` markers preserved by
     /// `expand_simple_no_io`) and push each variant as a separate argv word.
     fn do_brace_expand(me: &mut Expansion) {
@@ -334,14 +332,13 @@ impl Expansion {
                 me.state = ExpansionState::Err(Box::new(ShellErr::Custom(msg.into_bytes().into())));
                 return;
             }
-            // Spec: error.UnexpectedToken → panic. Mirror it.
+            // An unexpected token from brace expansion is a parser bug.
             panic!("unexpected error from Braces.expand: {e:?}");
         }
         drop(arena);
 
-        // Spec lines 268-279: push each variant as its own word. The Zig
-        // version NUL-terminated then `out.pushResult`; the NodeId port
-        // records word boundaries via `bounds` instead.
+        // Push each variant as its own word; word boundaries are recorded
+        // via `bounds`.
         for s in expanded {
             if !me.out.buf.is_empty() {
                 me.out.bounds.push(me.out.buf.len() as u32);
@@ -352,7 +349,7 @@ impl Expansion {
         let node = me.node;
         let atom = node.get();
         if atom.has_glob_expansion() {
-            // brace + glob composes (Zig re-enters the `.glob` state). Keep
+            // brace + glob composes. Keep
             // `current_out` (the original pattern, e.g. `src/*.{ts,tsx}`) so
             // the glob walker brace-expands and globs it; its matches are
             // appended after the literal brace variants already pushed above.
@@ -423,7 +420,7 @@ impl Expansion {
         pattern
     }
 
-    /// Spec: Expansion.zig `transitionToGlobState`. Kick off an off-thread
+    /// Kick off an off-thread
     /// glob walk for the assembled pattern in `current_out`.
     fn transition_to_glob_state(interp: &Interpreter, this: NodeId) -> Yield {
         use crate::shell::dispatch_tasks::ShellGlobTask;
@@ -455,7 +452,7 @@ impl Expansion {
         Yield::suspended()
     }
 
-    /// Spec: Expansion.zig `expandSimpleNoIO`. Appends the no-IO expansion of
+    /// Appends the no-IO expansion of
     /// one [`ast::SimpleAtom`] to `out`. Returns `true` for `CmdSubst` so the
     /// caller spawns a `Script` for it.
     fn expand_simple_no_io(
@@ -473,8 +470,7 @@ impl Expansion {
         match atom {
             ast::SimpleAtom::Text(txt) => out.extend_from_slice(txt),
             ast::SimpleAtom::QuotedEmpty => {
-                // Spec: Expansion.zig `expandSimpleNoIO` sets
-                // `has_quoted_empty = true` so an empty word is still pushed
+                // Sets `has_quoted_empty = true` so an empty word is still pushed
                 // as an arg. The flag is *required* — without it Cmd cannot
                 // tell `""` (one empty arg) from `$unset` (no arg), since
                 // both leave `out.buf` empty.
@@ -532,7 +528,7 @@ impl Expansion {
         false
     }
 
-    /// Spec: Expansion.zig `pushCurrentOut`. Flush `current_out` into `out`
+    /// Flush `current_out` into `out`
     /// as the next argv word. The word boundary is recorded as the *previous*
     /// end-offset so the consumer's `[prev..bound]` slicing reconstructs each
     /// word and the trailing `[prev..]` slice yields the final one.
@@ -544,7 +540,6 @@ impl Expansion {
         me.meta_offsets.clear();
     }
 
-    /// Spec: Expansion.zig `postSubshellExpansion` + `convertNewlinesToSpaces`.
     /// Newlines→spaces, trim, then split on whitespace runs into separate
     /// argv words.
     fn post_subshell_expansion(me: &mut Expansion, mut stdout: Vec<u8>) {
@@ -614,7 +609,7 @@ impl Expansion {
         .clone();
 
         // Propagate the exit code if the *whole* atom was a single `$(...)`
-        // (so `$(false)` as argv0 fails the command). Spec: childDone:517.
+        // (so `$(false)` as argv0 fails the command).
         let sole_cmd_subst = matches!(
             interp.as_expansion(this).node.get(),
             ast::Atom::Simple(ast::SimpleAtom::CmdSubst(_))
@@ -643,7 +638,7 @@ impl Expansion {
         Yield::Next(this)
     }
 
-    /// Spec: Expansion.zig `onGlobWalkDone`. Main-thread re-entry for the
+    /// Main-thread re-entry for the
     /// off-thread glob walker — splice each match as a separate word into
     /// `out` then resume the atom-walk trampoline.
     pub fn on_glob_walk_done(
@@ -665,7 +660,7 @@ impl Expansion {
         };
 
         if result.is_empty() || walk_err.is_some() {
-            // Spec lines 559-578: in variable assignments a no-match glob
+            // In variable assignments a no-match glob
             // expands to the literal pattern; otherwise it's an error.
             let parent = interp.as_expansion(this).base.parent;
             let in_assign = matches!(interp.node(parent).kind(), StateKind::Assign)
@@ -696,7 +691,7 @@ impl Expansion {
 
         {
             let me = interp.as_expansion_mut(this);
-            // Spec lines 580-588: push each match as its own argv word. The
+            // Push each match as its own argv word. The
             // walker arena owns the strings, so they were `to_vec`'d already.
             for entry in result {
                 if !me.out.buf.is_empty() {
@@ -744,5 +739,3 @@ impl Expansion {
         out
     }
 }
-
-// ported from: src/shell/states/Expansion.zig
diff --git a/src/runtime/shell/states/If.rs b/src/runtime/shell/states/If.rs
index fd89a01ba6e..8129bd80039 100644
--- a/src/runtime/shell/states/If.rs
+++ b/src/runtime/shell/states/If.rs
@@ -79,9 +79,8 @@ impl If {
     pub fn next(interp: &Interpreter, this: NodeId) -> Yield {
         let parent = interp.as_if(this).base.parent;
         loop {
-            // PORT NOTE: reshaped for borrowck — we read/mutate `state` via a
-            // short-lived borrow, decide an action, then drop the borrow
-            // before calling back into `interp`.
+            // Read/mutate `state` via a short-lived borrow, decide an action,
+            // then drop the borrow before calling back into `interp`.
             let action = {
                 let me = interp.as_if_mut(this);
                 // Copy the BackRef out so `n` borrows a local, leaving `me`
@@ -210,5 +209,3 @@ pub enum Action {
     Done(ExitCode),
     SpawnStmt(*const ast::Stmt),
 }
-
-// ported from: src/shell/states/If.zig
diff --git a/src/runtime/shell/states/Pipeline.rs b/src/runtime/shell/states/Pipeline.rs
index d6f0f7848eb..9af94e67b06 100644
--- a/src/runtime/shell/states/Pipeline.rs
+++ b/src/runtime/shell/states/Pipeline.rs
@@ -93,7 +93,7 @@ impl Pipeline {
     /// Cmd/Assigns/Subshell/If/CondExpr with stdin/stdout wired to the right
     /// pipe ends.
     ///
-    /// Spec (Pipeline.zig `next()` `.starting_cmds`): spawns exactly ONE child
+    /// Spawns exactly ONE child
     /// per call and returns that child's `start()` Yield. The trampoline's
     /// `drain_pipelines` (Yield.rs) re-enters `Pipeline::next` to spawn the
     /// next child once the current one suspends — so every child's start-yield
@@ -104,7 +104,7 @@ impl Pipeline {
             (me.node, me.base.shell, interp.event_loop)
         };
         let items: &[ast::PipelineItem] = node.items;
-        // Spec (Pipeline.zig setupCommands): assigns inside a pipeline are
+        // Assigns inside a pipeline are
         // no-ops — they're not counted, not duped, not started. `cmd_count`
         // here is the number of *runnable* children.
         let cmd_count = items
@@ -113,7 +113,7 @@ impl Pipeline {
             .count();
 
         if cmd_count == 0 {
-            // Spec (Pipeline.zig start()): empty pipeline finishes with 0.
+            // An empty pipeline finishes with 0.
             // Return `Next(this)` so the trampoline sees `is_done`, removes us
             // from the pipeline stack, and `next()` bubbles to the parent.
             // Calling `child_done(parent, ..)` directly here would free this
@@ -126,7 +126,7 @@ impl Pipeline {
         if idx == 0 && interp.as_pipeline(this).cmds.is_none() {
             let mut pipes: Vec<Pipe> = Vec::with_capacity(cmd_count.saturating_sub(1));
             for _ in 0..cmd_count.saturating_sub(1) {
-                // Spec (Pipeline.zig initializePipes 291-313): on POSIX use a
+                // On POSIX use a
                 // UNIX stream socketpair via `socketpairForShell` — on macOS
                 // that variant intentionally skips SO_NOSIGPIPE so the
                 // subprocess writing to a closed read end is killed by SIGPIPE
@@ -145,8 +145,8 @@ impl Pipeline {
                         }
                         // Leave `StartingCmds` so `drain_pipelines` doesn't
                         // re-enter `next_starting` and retry the failing
-                        // syscall in a loop (spec: setupCommands → start →
-                        // .waiting_write_err → suspended).
+                        // syscall in a loop; stay suspended until the error
+                        // write completes.
                         interp.as_pipeline_mut(this).state = PipelineState::WaitingWriteErr;
                         interp.throw(ShellErr::new_sys(&e));
                         return Yield::failed();
@@ -178,7 +178,7 @@ impl Pipeline {
 
         // Build per-child IO: stdin from prev pipe read end (or parent
         // stdin for first), stdout to this pipe write end (or parent stdout
-        // for last), stderr inherited. Spec: Pipeline.zig readPipe/writePipe.
+        // for last), stderr inherited.
         let interp_ptr: *mut Interpreter = interp.as_ctx_ptr();
         let child_io = {
             let me = interp.as_pipeline(this);
@@ -193,8 +193,7 @@ impl Pipeline {
             let stdout = if cmd_count == 1 || cmd_idx == cmd_count - 1 {
                 me.io.stdout.clone()
             } else {
-                // Spec (Pipeline.zig writePipe 320-324):
-                // `.is_socket = bun.Environment.isPosix` — the POSIX
+                // `is_socket` is set on POSIX — the POSIX
                 // pipe is actually a socketpair end (see above).
                 let w = IOWriter::init(
                     pipes[cmd_idx][1],
@@ -227,7 +226,7 @@ impl Pipeline {
         } {
             Ok(d) => d,
             Err(e) => {
-                // Spec (Pipeline.zig setupCommands 132-140): on dupe failure,
+                // On dupe failure,
                 // close the pipe ends not yet wrapped in an IOReader/IOWriter,
                 // deref `cmd_io`, transition to `.waiting_write_err`, and
                 // suspend. Without the state transition `drain_pipelines`
@@ -269,7 +268,9 @@ impl Pipeline {
         interp.start_node(child)
     }
 
-    /// Spec: Pipeline.zig `onIOWriterChunk` (lines 206-217).
+    /// IOWriter completion callback for the error message written in
+    /// `WaitingWriteErr`: throw on write failure, otherwise finish the
+    /// pipeline with exit code 1.
     pub fn on_io_writer_chunk(
         interp: &Interpreter,
         this: NodeId,
@@ -316,17 +317,13 @@ impl Pipeline {
             (me.exited_count >= n && n > 0, n)
         };
         // We duped a ShellExecEnv per child in `next_starting`. Cmd/If/CondExpr
-        // do NOT free `base.shell` in their own `deinit`, so free it here
-        // (spec: Pipeline.zig childDone() lines 236-250). Subshell frees its
-        // own; Assigns is skipped per spec.
+        // do NOT free `base.shell` in their own `deinit`, so free it here.
+        // Subshell frees its own; Assigns is skipped.
         Self::deinit_child_duped_env(interp, child);
         interp.deinit_node(child);
         if all_done {
             // Exit code = last command's exit code (bash semantics).
-            // Spec (Pipeline.zig childDone 258-266): the back-scan loop is
-            // `var i = len-1; while (i > 0) : (i -= 1)` — note `> 0`, not
-            // `>= 0` — so for a single-runnable pipeline the loop body never
-            // runs and `last_exit_code` stays 0. Mirror that exactly: only
+            // For a single-runnable pipeline `last_exit_code` stays 0: only
             // inspect `cmds[len-1]` when `len >= 2`.
             let exit = {
                 let me = interp.as_pipeline(this);
@@ -346,7 +343,7 @@ impl Pipeline {
     }
 
     /// Free the per-child env duped in `next_starting` for child kinds that
-    /// don't free `base.shell` themselves (spec: Pipeline.zig childDone()).
+    /// don't free `base.shell` themselves.
     fn deinit_child_duped_env(interp: &Interpreter, child: NodeId) {
         let kind = interp.node(child).kind();
         if matches!(
@@ -384,5 +381,3 @@ impl Pipeline {
         me.base.end_scope();
     }
 }
-
-// ported from: src/shell/states/Pipeline.zig
diff --git a/src/runtime/shell/states/Script.rs b/src/runtime/shell/states/Script.rs
index e1365d0837b..bf90f02af94 100644
--- a/src/runtime/shell/states/Script.rs
+++ b/src/runtime/shell/states/Script.rs
@@ -72,8 +72,6 @@ impl Script {
             *idx += 1;
             (i, me.base.shell)
         };
-        // PORT NOTE: reshaped for borrowck — captured idx/shell into locals
-        // before re-borrowing interp for Stmt::init.
         let stmt_node = Self::stmt_at(interp, this, idx);
         let io = interp.as_script(this).io.clone();
         let stmt = Stmt::init(interp, shell, stmt_node, this, io);
@@ -118,7 +116,7 @@ impl Script {
             // The shell env is owned by the parent when the parent is the
             // Interpreter or a Subshell; otherwise this Script represents a
             // command substitution which duped from the parent and must
-            // deinitialize it (Zig: `this.base.shell.deinit()`).
+            // deinitialize it.
             if !me.base.shell.is_null() {
                 // SAFETY: `me.base.shell` is the duped env this Script owned;
                 // null-checked and exclusively held here.
@@ -156,5 +154,3 @@ impl Script {
         &raw const me.node.stmts[idx]
     }
 }
-
-// ported from: src/shell/states/Script.zig
diff --git a/src/runtime/shell/states/Stmt.rs b/src/runtime/shell/states/Stmt.rs
index 9241bc27e7f..aff6c0d6281 100644
--- a/src/runtime/shell/states/Stmt.rs
+++ b/src/runtime/shell/states/Stmt.rs
@@ -81,7 +81,6 @@ impl Stmt {
             me.idx += 1;
             me.currently_executing = None;
         }
-        // Zig: `defer child.deinit();` — child is not used below.
         // Async children are *not* freed here (they outlive their parent's
         // notion of "done"); see `Async`'s empty `deinit`.
         if !matches!(interp.node(child).kind(), StateKind::Async) {
@@ -103,5 +102,3 @@ impl Stmt {
         me.node.exprs.len()
     }
 }
-
-// ported from: src/shell/states/Stmt.zig
diff --git a/src/runtime/shell/states/Subshell.rs b/src/runtime/shell/states/Subshell.rs
index aba0e1ce07a..02269bc3c30 100644
--- a/src/runtime/shell/states/Subshell.rs
+++ b/src/runtime/shell/states/Subshell.rs
@@ -46,7 +46,7 @@ impl Subshell {
         }))
     }
 
-    /// Zig `Subshell.initDupeShellState` — dupe the parent env and `init`.
+    /// Dupe the parent env and `init`.
     /// Called by Stmt/Binary via `Interpreter::spawn_expr`. Pipeline does
     /// NOT use this (it dupes per-child itself and calls `init` directly).
     ///
@@ -82,7 +82,7 @@ impl Subshell {
         log!("Subshell {} next state={}", this, state_tag);
         match interp.as_subshell(this).state {
             SubshellState::Idle => {
-                // Spec (Subshell.zig start()): spawn Script directly with
+                // Spawn Script directly with
                 // `this.base.shell`. The env was already duped at construction
                 // (by `init_dupe_shell_state` or by Pipeline) — do NOT dupe
                 // again here.
@@ -92,8 +92,9 @@ impl Subshell {
                 };
                 let script_node: *const ast::Script = &raw const node.get().script;
                 interp.as_subshell_mut(this).state = SubshellState::Exec;
-                // TODO(port): apply `(*node).redirect` / `redirect_flags`
-                // to `io` once IOWriter redirect open is wired.
+                // `node.redirect` is always `None` here: the parser rejects
+                // subshells with redirections ("Subshells with redirections
+                // are currently not supported", shell_parser/parse.rs).
                 let script = Script::init(interp, shell, script_node, this, io);
                 Script::start(interp, script)
             }
@@ -106,7 +107,6 @@ impl Subshell {
         }
     }
 
-    /// Spec: Subshell.zig `onIOWriterChunk` (lines 163-174).
     pub(crate) fn on_io_writer_chunk(
         interp: &Interpreter,
         this: NodeId,
@@ -154,5 +154,3 @@ impl Subshell {
         me.base.end_scope();
     }
 }
-
-// ported from: src/shell/states/Subshell.zig
diff --git a/src/runtime/shell/subproc.rs b/src/runtime/shell/subproc.rs
index 5c18b75af28..7051305d3e7 100644
--- a/src/runtime/shell/subproc.rs
+++ b/src/runtime/shell/subproc.rs
@@ -1,5 +1,3 @@
-// const IPC = @import("../jsc/ipc.zig");
-
 use core::ffi::{c_char, c_void};
 use std::sync::Arc;
 
@@ -32,7 +30,7 @@ use enumset::EnumSet;
 use crate::api::bun_spawn::stdio::{self, Stdio};
 use crate::shell::util::OutKind;
 
-/// Local helper: `OutKind` → tag-name string for logs (Zig `@tagName`).
+/// Local helper: `OutKind` → tag-name string for logs.
 #[inline]
 fn out_kind_str(k: OutKind) -> &'static str {
     match k {
@@ -41,7 +39,7 @@ fn out_kind_str(k: OutKind) -> &'static str {
     }
 }
 
-/// Raw `*mut T` into an `Arc<T>` payload (Zig intrusive `*PipeReader` shape).
+/// Raw `*mut T` into an `Arc<T>` payload.
 ///
 /// Returns a **raw pointer**, not `&mut T`: an `(&Arc<T>) -> &mut T` accessor
 /// is unsound by construction — it lets two `&mut T` (or a `&mut T` and a
@@ -93,10 +91,9 @@ mod __pipe_reader_thread_confined {
 
 /// Mutably borrow a `RefPtr<StaticPipeWriter>` payload.
 ///
-/// `RefPtr` only exposes `&T` via `Deref`; the shell is single-threaded so
-/// the Zig spec mutates through any `*StaticPipeWriter` alias. Localises the
-/// `(*buffer.as_ptr()).method()` pattern at the five `Writable::Buffer`
-/// callsites.
+/// `RefPtr` only exposes `&T` via `Deref`; the shell is single-threaded.
+/// Localises the `(*buffer.as_ptr()).method()` pattern at the five
+/// `Writable::Buffer` callsites.
 ///
 /// # Safety
 /// Caller must ensure no other `&`/`&mut StaticPipeWriter` to the same
@@ -124,19 +121,16 @@ pub use crate::api::bun_spawn::stdio::Stdio as StdioReexport;
 pub use JscSubprocess::StdioKind;
 
 use crate::shell::ShellErr;
-// pub const ShellSubprocess = NewShellSubprocess(.js);
-// pub const ShellSubprocessMini = NewShellSubprocess(.mini);
 
 #[cfg(windows)]
 pub type StdioResult = WindowsStdioResult;
 #[cfg(not(windows))]
 pub type StdioResult = Option<Fd>;
 
-/// RAII handle owning one intrusive ref on a heap `FileSink` (Zig's
-/// `Writable.pipe: *FileSink`). `FileSink` carries its own
-/// `#[derive(CellRefCounted)]` refcount and is allocated via `Box::into_raw`
-/// in `FileSink::create*`, so it cannot live behind an `Arc`. Drop derefs
-/// (and frees on last ref), matching Zig's `pipe.deref()` on teardown.
+/// RAII handle owning one intrusive ref on a heap `FileSink`. `FileSink`
+/// carries its own `#[derive(CellRefCounted)]` refcount and is allocated via
+/// `Box::into_raw` in `FileSink::create*`, so it cannot live behind an `Arc`.
+/// Drop derefs (and frees on last ref) on teardown.
 pub struct FileSinkPtr(core::ptr::NonNull<FileSink>);
 
 impl FileSinkPtr {
@@ -158,8 +152,7 @@ impl FileSinkPtr {
         self.0.as_ptr()
     }
 
-    /// Mutably borrow the payload. Shell is single-threaded; mirrors Zig's
-    /// `*FileSink` mutation through any alias.
+    /// Mutably borrow the payload. Shell is single-threaded.
     ///
     /// # Safety
     /// Caller must ensure no overlapping `&`/`&mut` to the `FileSink` is live.
@@ -209,8 +202,7 @@ pub struct ShellIO {
     pub stderr: Option<Arc<IOWriter>>,
 }
 
-// PORT NOTE: Zig's `ShellIO.ref/deref` bumped intrusive IOWriter refcounts
-// without producing a handle. With `Arc<IOWriter>` the only correct way to
+// Note: with `Arc<IOWriter>` the only correct way to
 // retain is to *clone the Arc and keep it*; a freestanding `ref()` that
 // discards the clone is a no-op. Callers hold their own `Arc` clones and
 // `ShellIO`'s `Drop` releases them — no explicit ref/deref methods.
@@ -267,7 +259,7 @@ pub struct ShellSubprocess {
     /// Intrusively ref-counted process (`bun_ptr::ThreadSafeRefCount`).
     /// Stored raw because `Process` methods take `&mut self` and `RefPtr`
     /// only implements `Deref`; the shell is single-threaded so raw mutable
-    /// access mirrors the Zig `*Process` pattern.
+    /// access is sound.
     pub process: *mut Process,
 
     pub stdin: Writable,
@@ -287,7 +279,7 @@ bitflags::bitflags! {
         const IS_SYNC                = 1 << 0;
         const KILLED                 = 1 << 1;
         const WAITING_FOR_ONEXIT     = 1 << 2;
-        // remaining 5 bits unused (matches Zig `_: u5 = 0`)
+        // remaining 5 bits unused
     }
 }
 
@@ -403,10 +395,6 @@ impl ShellSubprocess {
         self.proc().kill(u8::try_from(sig).expect("int cast"))
     }
 
-    // fn has_called_getter(self: &Subprocess, comptime getter: @Type(.enum_literal)) -> bool {
-    //     return self.observable_getters.contains(getter);
-    // }
-
     fn close_process(&mut self) {
         let process = core::mem::replace(&mut self.process, core::ptr::null_mut());
         if process.is_null() {
@@ -417,9 +405,8 @@ impl ShellSubprocess {
         unsafe {
             (*process).set_exit_handler_default();
             (*process).close();
-            // Spec: `this.process.deref()` — release the intrusive ref taken
-            // by `spawn_result.toProcess`. `*mut Process` has no Drop, so this
-            // must be explicit.
+            // Release the intrusive ref taken by `to_process`. `*mut Process`
+            // has no Drop, so this must be explicit.
             bun_ptr::ThreadSafeRefCount::<Process>::deref(process);
         }
     }
@@ -450,9 +437,6 @@ impl ShellSubprocess {
             StdioKind::Stdout => self.stdout.finalize(),
             StdioKind::Stderr => self.stderr.finalize(),
         }
-        // } else {
-        // @field(self, @tagName(io)).close();
-        // }
     }
 
     // This must only be run once per Subprocess
@@ -468,16 +452,16 @@ impl ShellSubprocess {
         match kind {
             StdioKind::Stdin => match &mut self.stdin {
                 Writable::Pipe(pipe) => {
-                    // Mirrors Zig `this.stdin.pipe.signal.clear()` — DerefMut
-                    // on the owning `&mut FileSinkPtr` encapsulates the access.
+                    // DerefMut on the owning `&mut FileSinkPtr` encapsulates
+                    // the access.
                     pipe.signal.with_mut(|s| s.clear());
-                    // FileSinkPtr::drop derefs (Zig: `pipe.deref()`).
+                    // FileSinkPtr::drop derefs.
                     self.stdin = Writable::Ignore;
                 }
                 Writable::Buffer(_) => {
                     self.on_static_pipe_writer_done();
                     // RefPtr has no Drop — move it out before reassigning so the
-                    // create ref is actually released (mirrors Zig `buffer.deref()`).
+                    // create ref is actually released.
                     if let Writable::Buffer(buffer) =
                         core::mem::replace(&mut self.stdin, Writable::Ignore)
                     {
@@ -546,7 +530,7 @@ impl ShellSubprocess {
                 if let Readable::Pipe(pipe) = r {
                     // `start()` failed before any reader callback registered,
                     // so the `Arc` is expected to be uniquely held. Write
-                    // unconditionally (matching Zig spec) rather than via
+                    // unconditionally rather than via
                     // `Arc::get_mut`, which would silently skip the state
                     // transition if a future change bumped the strong count.
                     debug_assert_eq!(Arc::strong_count(pipe), 1);
@@ -610,15 +594,13 @@ impl ShellSubprocess {
     ) -> sh::Result<()> {
         const IS_SYNC: bool = false;
 
-        // Owns the `K=V\0` storage when inheriting the parent env. Zig used the
-        // spawn-local arena freed at function exit; here the struct keeps the
-        // buffers alive until after `spawn_process` returns (the raw pointers
-        // pushed into `env_array` borrow `inherited_env_storage.storage`).
+        // Owns the `K=V\0` storage when inheriting the parent env. The struct
+        // keeps the buffers alive until after `spawn_process` returns (the raw
+        // pointers pushed into `env_array` borrow `inherited_env_storage.storage`).
         let inherited_env_storage: Option<bun_dotenv::NullDelimitedEnvMap> =
             if !spawn_args.override_env && spawn_args.env_array.is_empty() {
-                // spawn_args.env_array.items = jsc_vm.transpiler.env.map.createNullDelimitedEnvMap(allocator);
                 let envmap = bun_core::handle_oom(event_loop.create_null_delimited_env_map());
-                // PORT NOTE: `as_slice()` *includes* the trailing null; strip it —
+                // Note: `as_slice()` *includes* the trailing null; strip it —
                 // the common tail below re-appends one null terminator.
                 let entries = envmap.as_slice();
                 spawn_args
@@ -697,8 +679,7 @@ impl ShellSubprocess {
         }
 
         // Backref so PipeReader callbacks can drive `Yield::run` from async I/O
-        // completion. Zig threads this implicitly via `Base.interpreter`; the
-        // NodeId-arena port plumbs it explicitly through `SpawnArgs`.
+        // completion; plumbed explicitly through `SpawnArgs`.
         let interp = spawn_args.interp;
         // argv is built by the caller (Cmd::transition_to_exec) from
         // `Cmd.args`, NUL-terminated and null-sentinel-terminated, so this
@@ -717,7 +698,7 @@ impl ShellSubprocess {
             )
         } {
             Err(err) => {
-                // Zig: `spawn_options.deinit()`. WindowsSpawnOptions has no Drop
+                // WindowsSpawnOptions has no Drop
                 // (its Stdio::Buffer/Ipc carry FFI-owned `*mut uv::Pipe` already
                 // `uv_pipe_init`ed by spawn_process_windows before uv_spawn fails),
                 // so an implicit `drop(spawn_options)` is a no-op and leaks the
@@ -757,7 +738,7 @@ impl ShellSubprocess {
 
         let mut spawn_result = spawn_result;
 
-        // PORT NOTE: Stdio impls Drop, so move out via mem::replace instead of clone.
+        // Note: Stdio impls Drop, so move out via mem::replace instead of clone.
         let stdio0 = core::mem::replace(&mut stdio_guard[0], Stdio::Ignore);
         let stdio1 = core::mem::replace(&mut stdio_guard[1], Stdio::Ignore);
         let stdio2 = core::mem::replace(&mut stdio_guard[2], Stdio::Ignore);
@@ -769,8 +750,7 @@ impl ShellSubprocess {
 
         // Two-phase init: allocate the Subprocess slot first so the stable
         // `*mut Subprocess` is available to `Writable::init` / `Readable::init`
-        // (they store it on StaticPipeWriter / PipeReader as a backref). Zig
-        // does `allocator.create()` then assigns the struct literal in place.
+        // (they store it on StaticPipeWriter / PipeReader as a backref).
         let mut slot = Box::<Subprocess>::new_uninit();
         let subprocess: *mut Subprocess = slot.as_mut_ptr();
         // SAFETY: `out_subproc` points at the `SubprocExec.child` slot inside
@@ -844,7 +824,6 @@ impl ShellSubprocess {
         });
         let _ = scopeguard::ScopeGuard::into_inner(stdio_guard);
 
-        // Spec: `subprocess.stdin.pipe.signal = Signal.init(&subprocess.stdin)`.
         // Wire the FileSink's close-signal back to the enclosing `Writable` so
         // `Writable::on_close` (drops the `Arc<FileSink>`) runs when the sink
         // finishes. `stdin` lives inside the Box-allocated `Subprocess` at a
@@ -1042,7 +1021,7 @@ impl Writable {
     ) -> Result<Writable, WritableInitError> {
         assert_stdio_result!(result);
 
-        // PORT NOTE: `Stdio` impls Drop, so we cannot partially move out via
+        // Note: `Stdio` impls Drop, so we cannot partially move out via
         // match (E0509). Dispatch on `&mut` and `mem::take` / ManuallyDrop the
         // non-Copy payloads.
         let mut stdio = stdio;
@@ -1052,8 +1031,7 @@ impl Writable {
                 Stdio::Pipe | Stdio::ReadableStream(_) => {
                     if let StdioResult::Buffer(buf) = result {
                         // Ownership of the `Box<uv::Pipe>` transfers into the
-                        // FileSink's writer (Zig: `result.buffer` is the same
-                        // heap pointer the sink takes over).
+                        // FileSink's writer.
                         let uv_pipe: *mut _ = bun_core::heap::into_raw(buf);
                         let pipe_ptr = FileSink::create_with_pipe(event_loop, uv_pipe);
 
@@ -1065,7 +1043,7 @@ impl Writable {
                             bun_sys::Result::Ok(()) => {}
                             bun_sys::Result::Err(_err) => {
                                 // SAFETY: pipe_ptr is live with refcount 1;
-                                // deref frees it (Zig: `pipe.deref()`).
+                                // deref frees it.
                                 unsafe { FileSink::deref(pipe_ptr) };
                                 return Err(WritableInitError::UnexpectedCreatingStdin);
                             }
@@ -1168,8 +1146,7 @@ impl Writable {
                 Stdio::Memfd(memfd) => {
                     debug_assert!(memfd.is_valid());
                     let fd = *memfd;
-                    // Ownership of the fd transfers to `Writable::Memfd` (Zig
-                    // sets `stdio_consumed = true` to suppress `Stdio.deinit`).
+                    // Ownership of the fd transfers to `Writable::Memfd`.
                     // Swap in `Ignore` and suppress the old value's destructor
                     // so `Stdio::Drop` doesn't close the fd we just took
                     // (`stdio = Stdio::Ignore` alone would drop+close the old
@@ -1190,22 +1167,10 @@ impl Writable {
         }
     }
 
-    // PORT NOTE: `Writable::toJS` from the Zig spec is intentionally **not**
-    // ported. It references `subprocess.flags.has_stdin_destructor_called` and
-    // `subprocess.weak_file_sink_stdin_ptr`, neither of which exist on
-    // `ShellSubprocess` — the function is dead under Zig's lazy compilation
-    // (copy-pasted from the JSC `Subprocess`, never instantiated). The shell
-    // never exposes its stdin Writable to JS.
+    // Note: there is intentionally no `Writable::toJS` here — the shell never
+    // exposes its stdin Writable to JS.
 
     pub fn finalize(&mut self) {
-        // PORT NOTE: Zig recovered `*Subprocess` via `container_of` to gate on
-        // `subprocess.this_jsvalue != .zero`. That field is never assigned on
-        // ShellSubprocess (dead code path under Zig lazy compilation) and was
-        // dropped from the port, so the parent-pointer recovery is unnecessary.
-        // Computing it would also require materialising a `&Subprocess` while
-        // `&mut self` (== `&mut subprocess.stdin`) is live — an aliasing
-        // violation under Stacked Borrows even if never read.
-
         match self {
             Writable::Pipe(_) => {
                 // deref via drop-on-reassign
@@ -1214,8 +1179,8 @@ impl Writable {
             Writable::Buffer(buffer) => {
                 // SAFETY: single-threaded; temporary `&mut` for the call only.
                 unsafe { buffer_mut(buffer) }.update_ref(false);
-                // Spec: `this.buffer.deref()` but does NOT reassign `this.*` —
-                // the variant tag is left as `.buffer`. RefPtr's Drop (on
+                // Intentionally does NOT reassign `*self` — the variant tag is
+                // left as `Writable::Buffer`. RefPtr's Drop (on
                 // Subprocess teardown) handles the final deref.
             }
             Writable::Memfd(fd) => {
@@ -1303,11 +1268,8 @@ impl Readable {
         }
     }
 
-    // PORT NOTE: `Readable::toSlice` from the Zig spec is intentionally **not**
-    // ported. Its `.pipe` arm writes `this.pipe.buffer.fifo.close_on_empty_read`,
-    // a field that does not exist on `PipeReader` (pre-BufferedReader-rewrite
-    // leftover) — the function is dead under Zig's lazy compilation and has no
-    // callers. Subprocess output is read via `PipeReader::buffered_output`.
+    // Note: there is intentionally no `Readable::toSlice` here — subprocess
+    // output is read via `PipeReader::buffered_output`.
 
     #[allow(clippy::too_many_arguments)]
     pub fn init(
@@ -1323,7 +1285,7 @@ impl Readable {
     ) -> Readable {
         assert_stdio_result!(result);
 
-        // PORT NOTE: `Stdio` impls Drop, so dispatch on `&mut` and `mem::take`
+        // Note: `Stdio` impls Drop, so dispatch on `&mut` and `mem::take`
         // Default-able payloads instead of partial moves (E0509).
         let mut stdio = stdio;
         #[cfg(windows)]
@@ -1373,8 +1335,7 @@ impl Readable {
                 Stdio::Blob(_) => Readable::Ignore,
                 Stdio::Memfd(memfd) => {
                     let fd = *memfd;
-                    // Ownership of the fd transfers to `Readable::Memfd` (Zig sets
-                    // `stdio_consumed = true` to suppress `Stdio.deinit`). Swap in
+                    // Ownership of the fd transfers to `Readable::Memfd`. Swap in
                     // `Ignore` and suppress the old value's destructor so
                     // `Stdio::Drop` doesn't close the fd we just took.
                     let _ =
@@ -1467,10 +1428,8 @@ pub struct SpawnArgs<'a> {
     /// Must include the trailing null sentinel.
     pub argv: Vec<*const c_char>,
     /// Backref so [`PipeReader`] async-I/O callbacks can drive
-    /// [`Yield::run`]. Zig threaded the interpreter implicitly via
-    /// `Base.interpreter`; the NodeId-arena port drops that field, so the
-    /// spawning `Cmd` passes it explicitly here and it is plumbed through
-    /// `Readable::init` → `PipeReader::create`.
+    /// [`Yield::run`]. The spawning `Cmd` passes it explicitly here and it is
+    /// plumbed through `Readable::init` → `PipeReader::create`.
     pub interp: *mut crate::shell::interpreter::Interpreter,
 
     pub override_env: bool,
@@ -1515,9 +1474,8 @@ impl EnvMapIterKey<'_> {
 }
 
 pub struct EnvMapIterValue {
-    /// Zig stores `[:0]const u8` allocated from the spawn arena. Port owns the
-    /// NUL-terminated copy directly — `ZBox` is the `allocator.dupeZ` analogue.
-    // PERF(port): arena allocSentinel — profile if hot.
+    /// Owns the NUL-terminated copy directly via `ZBox`.
+    // PERF: could come from the spawn arena instead — profile if hot.
     pub val: bun_core::ZBox,
 }
 
@@ -1603,7 +1561,7 @@ impl<'a> SpawnArgs<'a> {
         env_iter: &mut crate::shell::env_map::Iterator<'_>,
     ) {
         self.override_env = true;
-        // PORT NOTE: `bun_collections::array_hash_map::Iter` doesn't impl
+        // Note: `bun_collections::array_hash_map::Iter` doesn't impl
         // `ExactSizeIterator`; use `size_hint` for the reservation.
         self.env_array
             .reserve_exact(env_iter.size_hint().0.saturating_sub(self.env_array.len()));
@@ -1617,7 +1575,7 @@ impl<'a> SpawnArgs<'a> {
             let key = entry.key_ptr.slice();
             let value = entry.value_ptr.slice();
 
-            // Spec: `std.fmt.allocPrintSentinel(arena, "{s}={s}", .{key, value}, 0)`.
+            // Build a NUL-terminated `key=value` string in the spawn arena.
             // Bumpalo owns the bytes; freed when the spawn arena is reset.
             let len = key.len() + 1 + value.len();
             // `self.arena: &'a Arena` is `Copy`, so binding it yields the full
@@ -1666,11 +1624,8 @@ pub struct PipeReader {
     /// `IOWriter::interp` / `IOReader::interp` for the same pattern. Wired
     /// from `Cmd::interp` at `PipeReader::create` time.
     pub interp: *mut crate::shell::interpreter::Interpreter,
-    // ref_count: handled by Arc<PipeReader> per LIFETIMES.tsv.
-    // TODO(port): Zig uses intrusive bun.ptr.RefCount and recovers *PipeReader via
-    // `container_of` from CapturedWriter — incompatible with Arc's header layout.
-    // Should switch to bun_ptr::IntrusiveRc<PipeReader> + Cell<u32> ref_count
-    // and update Readable::Pipe accordingly.
+    // ref_count: handled by Arc<PipeReader>; mutation through shared handles
+    // goes via the `arc_as_mut_ptr` interior-mutability helper below.
 }
 
 pub enum BufferedOutput {
@@ -1706,7 +1661,7 @@ impl BufferedOutput {
     pub fn append(&mut self, bytes: &[u8]) {
         match self {
             BufferedOutput::Bytelist(b) => {
-                let _ = b.append_slice(bytes); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                let _ = b.append_slice(bytes); // OOM/capacity: fire-and-forget
             }
             BufferedOutput::ArrayBuffer { buf, i } => {
                 let array_buf_slice = buf.slice_mut();
@@ -1740,7 +1695,7 @@ impl Drop for BufferedOutput {
 
 pub struct CapturedWriter {
     pub dead: bool,
-    /// `None` iff `dead == true` (Zig leaves the field undefined when dead).
+    /// `None` iff `dead == true`.
     pub writer: Option<Arc<IOWriter>>,
     pub written: usize,
     pub err: Option<SystemError>,
@@ -1884,7 +1839,6 @@ impl CapturedWriter {
 
 impl Drop for CapturedWriter {
     fn drop(&mut self) {
-        // PORT NOTE: Zig called `e.deref()` on the SystemError; in Rust the
         // `bun_sys::SystemError` strings drop themselves.
         let _ = self.err.take();
         // self.writer Arc drops automatically.
@@ -1898,13 +1852,13 @@ impl PipeReader {
             Arc::as_ptr(&self) as usize,
             out_kind_str(self.out_type)
         );
-        // Spec: `this.process = null; this.deref();` — clear the backref so any
+        // Clear the backref so any
         // late `on_reader_done`/`on_reader_error` after the Subprocess is freed
         // can't follow it. Arc only yields `&Self`; write through the
         // allocation pointer (single-threaded shell, no live `&`/`&mut` here).
         // SAFETY: see `arc_as_mut_ptr` rationale; field is a plain `Option<*mut _>`.
         unsafe { (*arc_as_mut_ptr(&self)).process = None };
-        // Dropping `self` releases the strong ref (Zig `this.deref()`).
+        // Dropping `self` releases the strong ref.
     }
 
     pub fn is_done(&self) -> bool {
@@ -1969,8 +1923,8 @@ impl PipeReader {
         //
         // `PipeReader` is deliberately `!Send + !Sync` (raw `*mut Interpreter`
         // / `*mut ShellSubprocess` fields); thread confinement is enforced at
-        // compile time by `__pipe_reader_thread_confined`, so the `Arc` is the
-        // Zig intrusive-refcount shape, not a cross-thread handle. `Rc` would
+        // compile time by `__pipe_reader_thread_confined`, so the `Arc` is a
+        // refcount, not a cross-thread handle. `Rc` would
         // change the `pub fn create -> Arc<PipeReader>` ABI.
         #[allow(clippy::arc_with_non_send_sync)]
         let arc = Arc::new(PipeReader {
@@ -2001,16 +1955,14 @@ impl PipeReader {
 
         #[cfg(windows)]
         {
-            // Zig aliases the same `*uv.Pipe` heap pointer in both
-            // `stdio_result.buffer` and `reader.source.pipe`. With
-            // `Box<uv::Pipe>` we cannot alias, so ownership transfers to
-            // `reader.source` (`stdio_result` is never read again on Windows —
-            // `start()` goes through `start_with_current_pipe`).
+            // With `Box<uv::Pipe>` the pipe cannot be aliased, so ownership
+            // transfers to `reader.source` (`stdio_result` is never read again
+            // on Windows — `start()` goes through `start_with_current_pipe`).
             this.reader.source = match core::mem::take(&mut this.stdio_result) {
                 StdioResult::Buffer(buf) => Some(bun_io::Source::Pipe(buf)),
                 StdioResult::BufferFd(fd) => {
                     // `Fd` is Copy; restore so `stdio_result` keeps reflecting
-                    // the spawn outcome (Zig leaves it in place).
+                    // the spawn outcome.
                     this.stdio_result = StdioResult::BufferFd(fd);
                     Some(bun_io::Source::File(bun_io::Source::open_file(fd)))
                 }
@@ -2048,7 +2000,6 @@ impl PipeReader {
                 #[cfg(unix)]
                 {
                     // TODO: are these flags correct
-                    // Spec: `poll.flags.insert(.socket); reader.flags.socket = true`.
                     if let Some(poll) = self.reader.handle.get_poll() {
                         poll.set_flag(bun_io::FilePollFlag::Socket);
                     }
@@ -2062,7 +2013,6 @@ impl PipeReader {
         }
     }
 
-    // TODO(port): move to shell_jsc
     pub const TO_JS: fn(Arc<Self>, &JSGlobalObject) -> jsc::JsResult<JSValue> =
         Self::to_readable_stream;
 
@@ -2103,9 +2053,9 @@ impl PipeReader {
     }
 
     /// Reconstruct an owning `Arc<Self>` from the raw parent pointer the
-    /// `BufferedReader` stored at `set_parent` time. Mirrors the Zig
-    /// `this.ref(); defer this.deref();` keepalive in `onReaderDone` /
-    /// `onReaderError`: the returned guard keeps the allocation alive across
+    /// `BufferedReader` stored at `set_parent` time. Keepalive for
+    /// `on_reader_done` / `on_reader_error`:
+    /// the returned guard keeps the allocation alive across
     /// `run_yield` (which may free the owning `Cmd`) and `on_close_io` (which
     /// drops the `Readable::Pipe` strong ref). Dropping the guard is the
     /// matching deref and may free `self`.
@@ -2128,10 +2078,9 @@ impl PipeReader {
     /// `try_signal_done_to_cmd` / `run_yield_with` calls — both reach back
     /// into this same allocation via the `Readable::Pipe` `Arc` clone.
     ///
-    /// NOTE: this does **not** gate on `is_done()` — Zig spec
-    /// `onReaderError` (subproc.zig:1369) runs unconditionally. The
-    /// `is_done()` early-return is `onReaderDone`-only and lives in
-    /// [`on_reader_done`].
+    /// NOTE: this does **not** gate on `is_done()` — the error path runs
+    /// unconditionally. The `is_done()` early-return is `on_reader_done`-only
+    /// and lives in [`on_reader_done`].
     fn finish_after_state_set(guard: &Arc<Self>) {
         let me = arc_as_mut_ptr(guard);
         // Snapshot `interp` *before* the Cmd call: `try_signal_done_to_cmd`
@@ -2174,7 +2123,7 @@ impl PipeReader {
             let me = unsafe { &mut *arc_as_mut_ptr(&guard) };
             let owned = me.to_owned_slice();
             me.state = PipeReaderState::Done(owned);
-            // Spec subproc.zig:1245 — `onReaderDone` (only) waits for the
+            // `on_reader_done` (only) waits for the
             // captured-writer tee to drain before signalling.
             if !me.is_done() {
                 return;
@@ -2237,13 +2186,13 @@ impl PipeReader {
                             me.state = old;
                         }
                         PipeReaderState::Pending => {
-                            // unreachable after is_done() guard; mirror Zig.
+                            // unreachable after is_done() guard.
                             me.state = PipeReaderState::Err(Some(Box::new(e)));
                         }
                     }
                 }
-                // PORT NOTE: Zig ref'd + cloned the SystemError; `bun_sys::SystemError`
-                // isn't ref-counted nor `Clone`. Move it out (the only reader of
+                // `bun_sys::SystemError` isn't ref-counted nor `Clone`.
+                // Move it out (the only reader of
                 // `state.Err` after this point is `Drop`, which tolerates `None`).
                 if let PipeReaderState::Err(slot) = &mut me.state {
                     slot.take().map(|b| *b)
@@ -2295,8 +2244,7 @@ impl PipeReader {
             return Box::default();
         }
         out.into_boxed_slice()
-        // PERF(port): Zig returned out.items (len < cap) without shrinking; into_boxed_slice
-        // may realloc to shrink. Profile if hot.
+        // PERF: into_boxed_slice may realloc to shrink. Profile if hot.
     }
 
     pub fn update_ref(&mut self, add: bool) {
@@ -2309,14 +2257,12 @@ impl PipeReader {
         }
     }
 
-    // TODO(port): move to shell_jsc
     pub fn to_readable_stream(
         this: Arc<Self>,
         global_object: &JSGlobalObject,
     ) -> jsc::JsResult<JSValue> {
-        // PORT NOTE: Zig `defer this.deinit()` — `this: Arc<Self>` dropping at
-        // scope end (all paths, including `?`) is that deref. Consumes the
-        // caller's +1 strong ref.
+        // `this: Arc<Self>` dropping at scope end (all paths, including `?`)
+        // releases the ref. Consumes the caller's +1 strong ref.
         let me = arc_as_mut_ptr(&this);
         let _consume_on_return = this;
 
@@ -2356,7 +2302,6 @@ impl PipeReader {
         }
     }
 
-    // TODO(port): move to shell_jsc
     pub fn to_buffer(&mut self, global_this: &JSGlobalObject) -> JSValue {
         match &mut self.state {
             PipeReaderState::Done(bytes) => {
@@ -2419,19 +2364,17 @@ impl PipeReader {
     }
 
     // Helper accessor used above to paper over Arc<PipeReader> interior mutability.
-    // TODO(port): remove once IntrusiveRc + Cell-wrapped fields land.
     //
     // Takes `*mut Self` (not `&self`) because `Arc<PipeReader>` only yields
     // `&Self`, and casting `&Self as *const Self as *mut Self` to write through is
     // immediate UB — shared-ref provenance is read-only. Callers obtain the pointer
     // via `Arc::as_ptr(&arc).cast_mut()`, which projects from the Arc allocation's
-    // original `NonNull` without materializing a `&Self`, mirroring Zig's intrusive
-    // `*PipeReader` (bun.ptr.RefCount) which is freely mutated through any alias.
+    // original `NonNull` without materializing a `&Self`.
     // The JS-thread single-mutator invariant means no live `&`/`&mut` to these
     // fields exists when this runs.
     unsafe fn take_done_buffer(this: *mut Self) -> Box<[u8]> {
-        // SAFETY: see block comment above. Mirrors onCloseIO:
-        //   out.* = .{ .buffer = pipe.state.done }; pipe.state = .{ .done = &.{} };
+        // SAFETY: see block comment above. Swaps the done buffer out, leaving
+        // an empty one in its place.
         // `ptr::replace` reads/writes through the raw field pointer without
         // materializing a `&mut Self` (on_reader_done may still hold one on the
         // caller's stack via the BufferedReader parent backref).
@@ -2474,7 +2417,6 @@ impl Drop for PipeReader {
         }
 
         if let PipeReaderState::Err(slot) = &mut self.state {
-            // PORT NOTE: Zig `e.deref()`; Rust drops via take().
             *slot = None;
         }
 
@@ -2518,14 +2460,13 @@ macro_rules! assert_stdio_result {
 }
 pub(crate) use assert_stdio_result;
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // `_PATH_DEFPATH` string literal emitted from C; immutable, load-time
     // initialized, never null. Reading the pointer value has no precondition.
     pub safe static BUN_DEFAULT_PATH_FOR_SPAWN: *const c_char;
 }
 
-// IntoStaticStr for PipeReaderState (used in logs as @tagName).
+// IntoStaticStr for PipeReaderState (used in logs as the variant name).
 impl From<&PipeReaderState> for &'static str {
     fn from(s: &PipeReaderState) -> &'static str {
         match s {
@@ -2535,5 +2476,3 @@ impl From<&PipeReaderState> for &'static str {
         }
     }
 }
-
-// ported from: src/shell/subproc.zig
diff --git a/src/runtime/shell/util.rs b/src/runtime/shell/util.rs
index 577326bac23..54255a2676d 100644
--- a/src/runtime/shell/util.rs
+++ b/src/runtime/shell/util.rs
@@ -5,10 +5,7 @@ pub enum OutKind {
     Stderr,
 }
 
-// Spec (util.zig): `pub const Stdio = bun.spawn.Stdio;` — the user-facing
-// stdio union with `isPiped()` from `runtime/api/bun/spawn/stdio.zig`, NOT the
+// The user-facing stdio type from `crate::api::bun_spawn::stdio`, NOT the
 // low-level `PosixStdio`/`WindowsStdio` spawn-option shape that the
 // `bun_spawn` *crate* re-exports under the same name.
 pub use crate::api::bun_spawn::stdio::Stdio;
-
-// ported from: src/shell/util.zig
diff --git a/src/runtime/socket/Handlers.rs b/src/runtime/socket/Handlers.rs
index df148474690..b14a8ea08b9 100644
--- a/src/runtime/socket/Handlers.rs
+++ b/src/runtime/socket/Handlers.rs
@@ -52,16 +52,14 @@ pub struct Handlers {
     /// `Strong` is never borrowed across a reentrant call.
     pub promise: JsCell<Strong>, // Strong.Optional → bun_jsc::Strong (Drop deallocates the slot)
 
-    // Zig: gated on `bun.Environment.ci_assert`.
     #[cfg(debug_assertions)]
     pub protection_count: u32,
 }
 
-// PORT NOTE: bare JSValue fields are heap-stored here, but Zig keeps them alive via
-// JSC protect()/unprotect() (GC roots), not stack scanning — so this is sound.
+// Bare JSValue fields are heap-stored here, but they are kept alive via JSC
+// protect()/unprotect() (GC roots), not stack scanning — so this is sound.
 
 /// Expands `$body` once per callback field with `$f` bound to the field ident.
-/// Mirrors Zig `inline for (callback_fields) |field| { @field(x, field) ... }`.
 macro_rules! for_each_callback_field {
     ($self:expr, |$f:ident| $body:block) => {{
         {
@@ -224,14 +222,13 @@ impl Handlers {
                     listen_socket
                         .poll_ref
                         .with_mut(|p| p.unref(bun_io::js_vm_ctx()));
+                    // `deinit` empties the Strong slot in place; the field stays valid.
                     listen_socket.strong_self.with_mut(|s| s.deinit());
-                    // PORT NOTE: Zig `strong_self.deinit()` → StrongOptional::deinit; field stays valid (empty)
                 }
             } else {
                 // Client-mode Handlers is heap-allocated per-connection
-                // (Listener::connect_inner via `heap::alloc`). Zig does
-                // `this.deinit(); vm.allocator.destroy(this);` here — match
-                // that: free in place so callers that only hold a `*mut`
+                // (Listener::connect_inner via `heap::alloc`).
+                // Free in place so callers that only hold a `*mut`
                 // (and thus can't `drop(Box)`) don't leak the allocation or
                 // its `protect()`ed JSValues. Caller must still null its
                 // field when this returns true.
@@ -277,7 +274,6 @@ impl Handlers {
         is_server: bool,
     ) -> JsResult<Handlers> {
         let generated = GeneratedSocketConfigHandlers::from_js(global_object, opts)?;
-        // PORT NOTE: `defer generated.deinit()` — Drop handles it
         Self::from_generated(global_object, &generated, is_server)
     }
 
@@ -401,7 +397,6 @@ impl Handlers {
 
 impl Drop for Handlers {
     fn drop(&mut self) {
-        // Zig deinit: unprotect() + promise.deinit() + this.* = undefined
         self.unprotect();
         if self.vm.is_shutting_down() {
             // `~VM` may have already torn down the HandleSet that
@@ -456,9 +451,9 @@ pub struct SocketConfig {
 }
 
 impl SocketConfig {
-    // PORT NOTE: Zig `deinit()` → Drop is automatic (all owned fields impl Drop).
-    // Zig `deinitExcludingHandlers()` preserves `handlers` at the same address so
-    // outstanding `*Handlers` stay valid. Kept as explicit method.
+    // Full teardown is handled by Drop (all owned fields impl Drop).
+    // `deinit_excluding_handlers` preserves `handlers` at the same address so
+    // outstanding `*Handlers` stay valid.
 
     /// Deinitializes everything except `handlers`.
     pub fn deinit_excluding_handlers(&mut self) {
@@ -511,7 +506,6 @@ impl SocketConfig {
                     SSLConfig::from_generated(vm_mut, global, ssl)?
                 }
             };
-            // PORT NOTE: `errdefer bun.memory.deinit(&ssl)` — ssl drops on `?`
             break 'blk SocketConfig {
                 hostname_or_unix: ZigStringSlice::empty(),
                 port: None,
@@ -529,7 +523,8 @@ impl SocketConfig {
                 ipv6_only: false,
             };
         };
-        // PORT NOTE: `errdefer result.deinit()` — result drops on `?` (Handlers::Drop unprotects)
+        // On any `?` below, `result` drops and `Handlers::Drop` unprotects its
+        // JSValues — no manual error-path cleanup needed.
 
         if result.fd.is_some() {
             // If a user passes a file descriptor then prefer it over hostname or unix
@@ -545,7 +540,6 @@ impl SocketConfig {
                 || slice.starts_with(b"sock://")
             {
                 let without_prefix = slice[7..].to_vec();
-                // PORT NOTE: reshaped for borrowck — drop borrow of slice before reassigning
                 result.hostname_or_unix = ZigStringSlice::init_owned(without_prefix);
             }
         } else if let Some(hostname) = generated.hostname.get() {
@@ -590,11 +584,8 @@ impl SocketConfig {
         is_server: bool,
     ) -> JsResult<SocketConfig> {
         let generated = GeneratedSocketConfig::from_js(global_object, opts)?;
-        // PORT NOTE: `defer generated.deinit()` — Drop handles it
         Self::from_generated(vm, global_object, &generated, is_server)
     }
 }
 
 use bun_jsc::generated::SocketConfigTls as GeneratedTls;
-
-// ported from: src/runtime/socket/Handlers.zig
diff --git a/src/runtime/socket/Listener.rs b/src/runtime/socket/Listener.rs
index 00514d67519..eab91ab25ce 100644
--- a/src/runtime/socket/Listener.rs
+++ b/src/runtime/socket/Listener.rs
@@ -57,7 +57,7 @@ fn vm_ssl_ctx_cache() -> *mut crate::api::SSLContextCache::SSLContextCache {
     unsafe { core::ptr::addr_of_mut!((*state).ssl_ctx_cache) }
 }
 
-// `jsc.Codegen.JSListener.toJS` — route through the codegen'd wrapper so we
+// Route through the codegen'd `toJS` wrapper so we
 // can hand the C++ side an already-heap-allocated `*mut Listener` (the
 // embedded `group` is linked into the loop's intrusive list at its final
 // address before this call, so the `Box::new`-then-move that the `#[JsClass]`
@@ -93,7 +93,7 @@ pub struct Listener {
 #[derive(Clone, Copy, Default)]
 pub enum ListenerType {
     Uws(*mut uws_sys::ListenSocket),
-    /// Raw heap pointer (not `Box`) to match .zig:31 `*WindowsNamedPipeListeningContext`.
+    /// Raw heap pointer (not `Box`) to a `WindowsNamedPipeListeningContext`.
     /// The context's address is registered with libuv (`uv_pipe.data`) for the
     /// lifetime of the handle, so we must never assert `noalias` over it via a
     /// Box move or `&mut Listener` that transitively covers the context — that
@@ -127,7 +127,7 @@ pub enum UnixOrHost {
 }
 
 impl UnixOrHost {
-    // PORT NOTE: deinit() deleted — Box<[u8]> fields auto-drop.
+    // Note: deinit() deleted — Box<[u8]> fields auto-drop.
 }
 
 impl Listener {
@@ -161,7 +161,7 @@ impl Listener {
         // returns `active_connections = 0`, but existing accepted sockets each hold a +1 via
         // `markActive`. Without this, closing any of them after reload would underflow the
         // counter (panic in safe builds, wrap in release).
-        // PORT NOTE: Zig `this.handlers.deinit()` — Drop handles unprotect; assignment below drops old.
+        // Note: Drop handles unprotect; assignment below drops old.
         this.handlers.with_mut(|h| {
             let active_connections = h.active_connections.get();
             *h = handlers;
@@ -171,7 +171,7 @@ impl Listener {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: no #[bun_jsc::host_fn] — BunObject.rs::static_adapters owns the
+    // Note: no #[bun_jsc::host_fn] — BunObject.rs::static_adapters owns the
     // C-ABI shim (it extracts `opts` from the CallFrame and calls this directly).
     pub fn listen(global: &JSGlobalObject, opts: JSValue) -> JsResult<JSValue> {
         log!("listen");
@@ -185,8 +185,12 @@ impl Listener {
         let socket_config = SocketConfig::from_js(vm, opts, global, true)?;
         #[cfg(windows)]
         let mut socket_config = socket_config;
-        // PORT NOTE: `defer socket_config.deinitExcludingHandlers()` — handled by Drop on SocketConfig
-        // (excluding handlers, which are moved out below). // TODO(port): verify SocketConfig Drop semantics
+        // Teardown handled by Drop on SocketConfig
+        // (excluding handlers, which are moved out below). Verified: on early-error
+        // paths the whole SocketConfig drops (Handlers::drop unprotects);
+        // on success both arms move `handlers` out via `ptr::read` and suppress
+        // the source's drop (`mem::forget` / `ManuallyDrop`) after extracting the
+        // other owned fields, so handlers are dropped exactly once.
 
         // Only deinit handlers if there's an error; otherwise we put them in a `Listener` and
         // need them to stay alive.
@@ -202,14 +206,14 @@ impl Listener {
             if let Some(pipe_name) =
                 normalize_pipe_name(socket_config.hostname_or_unix.slice(), buf.as_mut_slice())
             {
-                // PORT NOTE: reshaped — `pipe_name` borrows `buf`; copy to an owned
+                // Note: reshaped — `pipe_name` borrows `buf`; copy to an owned
                 // buffer so the borrow ends before we move `socket_config` below.
                 let mut pipe_buf = PathBuffer::uninit();
                 let pipe_len = pipe_name.len();
                 pipe_buf[..pipe_len].copy_from_slice(pipe_name);
 
-                // PORT NOTE: Zig `intoOwnedSlice` — transfer the allocation out
-                // of `socket_config` so the `mem::forget` below doesn't leak it.
+                // Transfer the allocation out of `socket_config` so the
+                // `mem::forget` below doesn't leak it.
                 let connection = UnixOrHost::Unix(
                     core::mem::take(&mut socket_config.hostname_or_unix)
                         .into_vec()
@@ -218,7 +222,7 @@ impl Listener {
 
                 vm.event_loop_ref().ensure_waker();
 
-                // PORT NOTE: by-value move of Handlers — see the non-pipe arm below
+                // Note: by-value move of Handlers — see the non-pipe arm below
                 // for rationale on `ptr::read` + `mem::forget`.
                 // SAFETY: socket_config.handlers is valid; we forget socket_config to avoid double-drop.
                 let handlers_moved: Handlers = unsafe { core::ptr::read(&socket_config.handlers) };
@@ -265,13 +269,12 @@ impl Listener {
                         ));
                     }
                     Err(_) => {
-                        // On error, clean up everything `this` owns *except* `this.handlers`: the outer
-                        // `errdefer handlers.deinit()` already unprotects those JSValues, and `this.handlers`
-                        // is a by-value copy of the same struct, so calling `this.deinit()` here would
-                        // unprotect the same callbacks a second time.
-                        // PORT NOTE: in this port `handlers` was *moved* (not copied), so we
-                        // recover it from the box before freeing and let it drop here for the
-                        // same single-unprotect effect.
+                        // On error, clean up everything `this` owns *except* `this.handlers`:
+                        // those JSValues must only be unprotected once, so calling
+                        // `this.deinit()` here would unprotect the same callbacks a second
+                        // time. `handlers` was *moved* into the box, so we
+                        // recover it from the box before freeing and let it drop here for a
+                        // single-unprotect effect.
                         this_ref.strong_data.with_mut(|s| s.deinit());
                         // SAFETY: reclaim the Box we leaked via into_raw; drops connection,
                         // protos, and (the moved) handlers exactly once.
@@ -297,8 +300,7 @@ impl Listener {
         // Allocate the Listener up front so the embedded `group` has its final
         // address before we hand it to listen() (it's linked into the loop's
         // intrusive list).
-        // PORT NOTE: by-value move of Handlers. Zig copied the struct then ran
-        // `deinitExcludingHandlers()` on the original. Here we read the handlers
+        // Note: by-value move of Handlers. Read the handlers
         // out by raw ptr and prevent double-drop by clearing the source via
         // `deinit_excluding_handlers` + `mem::forget`.
         let mut socket_config = core::mem::ManuallyDrop::new(socket_config);
@@ -307,8 +309,8 @@ impl Listener {
             unsafe { core::ptr::read(&raw const socket_config.handlers) };
         let protos_taken = socket_config.ssl.as_mut().and_then(|s| s.take_protos());
         let default_data = socket_config.default_data;
-        // PORT NOTE: Zig `intoOwnedSlice` — transfer the allocation out of
-        // `socket_config` so the `mem::forget` below doesn't leak it.
+        // Transfer the allocation out of `socket_config` so the `mem::forget`
+        // below doesn't leak it.
         let hostname_owned: Box<[u8]> = core::mem::take(&mut socket_config.hostname_or_unix)
             .into_vec()
             .into_boxed_slice();
@@ -317,7 +319,7 @@ impl Listener {
 
         let this: *mut Listener = bun_core::heap::into_raw(Box::new(Listener {
             handlers: JsCell::new(handlers_moved),
-            // Placeholder until `this_ref.connection = connection` below; Zig used `undefined`.
+            // Placeholder until `this_ref.connection = connection` below.
             // Cannot `mem::zeroed()` a Rust enum (UB).
             connection: UnixOrHost::Fd(Fd::invalid()),
             ssl: ssl_enabled,
@@ -338,12 +340,12 @@ impl Listener {
         // this.group → head_sockets → us_socket_t` once the only pointer into the
         // group lives inside a mimalloc page. Registering the embedded group as a
         // root region restores reachability for the accepted sockets' allocations.
-        // Paired unregister in `deinit()` (and the errdefer below).
+        // Paired unregister in `deinit()` (and the cleanup guard below).
         bun_core::asan::register_root_region(
             this_ref.group.as_ptr().cast::<c_void>(),
             size_of::<uws::SocketGroup>(),
         );
-        // errdefer: on any early return below, tear down the half-built Listener.
+        // Cleanup guard: on any early return below, tear down the half-built Listener.
         // Disarmed via `into_inner` once ownership transfers to the JS wrapper.
         let cleanup = scopeguard::guard(this, |this| {
             // SAFETY: this is still the sole owner on the error path
@@ -380,14 +382,13 @@ impl Listener {
             uws::SocketKind::BunListenerTcp
         };
 
-        // errdefer bun.default_allocator.free(hostname) — Box<[u8]> drops on error path automatically
+        // The `hostname` Box<[u8]> drops on error path automatically
         let mut connection: UnixOrHost = if let Some(port_) = port {
             UnixOrHost::Host {
                 host: hostname_owned,
                 port: port_,
             }
         } else if let Some(fd) = fd_opt {
-            // PORT NOTE: hostname is dropped here (Zig leaked it on this arm — same behavior not preserved)
             drop(hostname_owned);
             UnixOrHost::Fd(fd)
         } else {
@@ -448,7 +449,7 @@ impl Listener {
             }
         };
         if listen_socket.is_null() {
-            // PORT NOTE: reshaped for borrowck — extract hostname bytes for error formatting
+            // Note: reshaped for borrowck — extract hostname bytes for error formatting
             let hostname_bytes: &[u8] = match &connection {
                 UnixOrHost::Host { host, .. } => host,
                 UnixOrHost::Unix(u) => u,
@@ -530,8 +531,7 @@ impl Listener {
             handlers: Cell::new(NonNull::new(listener.handlers.as_ptr())),
             socket: Cell::new(uws::NewSocketHandler::<SSL>::DETACHED),
             protos: JsCell::new(listener.protos.clone()),
-            // PORT NOTE: Zig shared the listener's slice (`owned_protos = false`);
-            // here `protos` is `Option<Box<[u8]>>` so we clone instead of borrow.
+            // `protos` is `Option<Box<[u8]>>` so we clone the listener's slice.
             flags: Cell::new(SocketFlags::empty()),
             owned_ssl_ctx: Cell::new(None),
             this_value: JsCell::new(jsc::JsRef::empty()),
@@ -555,7 +555,7 @@ impl Listener {
         this_socket
     }
 
-    /// Called from `dispatch.zig` `BunListener.onOpen` for every accepted socket.
+    /// Called from `BunListener::on_open` (uws dispatch) for every accepted socket.
     /// Allocates the `NewSocket` wrapper, stashes it in the socket ext, then
     /// re-stamps the kind to `.bun_socket_{tcp,tls}` so subsequent events route
     /// straight to `BunSocket` (the listener arm only fires once per accept).
@@ -573,7 +573,8 @@ impl Listener {
             handlers: Cell::new(NonNull::new(listener.handlers.as_ptr())),
             socket: Cell::new(socket),
             protos: JsCell::new(listener.protos.clone()),
-            // TODO(port): protos borrow semantics — Zig shared the listener's slice; here we clone.
+            // `protos` is `Option<Box<[u8]>>` so each accepted socket clones
+            // the listener's slice; one small allocation per accept.
             flags: Cell::new(SocketFlags::empty()), // owned_protos = false (cloned above)
             owned_ssl_ctx: Cell::new(None),
             this_value: JsCell::new(jsc::JsRef::empty()),
@@ -634,10 +635,9 @@ impl Listener {
                 global.throw_invalid_arguments(format_args!("hostname pattern cannot be empty"))
             );
         }
-        // NUL-terminate for the C `const char*` parameter. Zig used
-        // `dupeZ` + raw `.ptr` (Listener.zig:377), which tolerates interior
-        // NULs — the C SNI tree just truncates at the first one. Build the
-        // `&CStr` via `from_ptr` to match that instead of asserting via
+        // NUL-terminate for the C `const char*` parameter. Interior NULs are
+        // tolerated — the C SNI tree just truncates at the first one. Build the
+        // `&CStr` via `from_ptr` to allow that instead of asserting via
         // `ZStr::as_cstr()`. `server_name_z` must outlive the
         // remove_server_name/add_server_name calls below.
         let server_name_z = bun_core::ZBox::from_bytes(server_name_bytes);
@@ -658,7 +658,7 @@ impl Listener {
             let vm = VirtualMachine::get().as_mut();
             SSLConfig::from_js(vm, global, tls)?
         } {
-            // PORT NOTE: `defer cfg.deinit()` — handled by Drop on SSLConfig
+            // Note: `cfg` cleanup handled by Drop on SSLConfig
             let mut create_err = uws::create_bun_socket_error_t::none;
             // SAFETY: `vm_ssl_ctx_cache()` returns the per-thread cache; only
             // touched from the JS thread so the `&mut` is unique.
@@ -742,8 +742,6 @@ impl Listener {
             Self::unlink_unix_socket_path(this);
         }
 
-        // PORT NOTE: Zig `defer switch (listener) {...}` — moved to end of fn body for same ordering.
-
         if this.handlers.get().active_connections.get() == 0 {
             this.poll_ref.with_mut(|p| p.unref(bun_io::js_vm_ctx()));
             this.strong_self
@@ -838,7 +836,7 @@ impl Listener {
         }
 
         // connection / protos: dropped by heap::take below
-        // PORT NOTE: Zig `this.handlers.deinit()` — Drop on Handlers handles unprotect.
+        // Drop on Handlers handles unprotect.
         // SAFETY: reclaim the Box allocated in listen()
         drop(unsafe { bun_core::heap::take(this) });
     }
@@ -878,11 +876,10 @@ impl Listener {
             ListenerType::Uws(uws_listener) => {
                 // S008: `ListenSocket` is an `opaque_ffi!` ZST — safe deref.
                 let socket = bun_opaque::opaque_deref_mut(uws_listener).socket::<false>();
-                // Zig: `uws_listener.socket(false).fd().toJSWithoutMakingLibUVOwned()`.
                 // On Windows the listening socket fd is a system-kind SOCKET
                 // handle; routing it through `.uv()` panics for anything but
-                // stdio. The sys_jsc helper branches on kind exactly like
-                // fd_jsc.zig (system→u64, uv→i32, posix→i32).
+                // stdio. The sys_jsc helper branches on kind
+                // (system→u64, uv→i32, posix→i32).
                 use bun_sys_jsc::FdJsc as _;
                 socket.fd().to_js_without_making_lib_uv_owned()
             }
@@ -919,7 +916,7 @@ impl Listener {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: no #[bun_jsc::host_fn] — BunObject.rs::static_adapters owns the
+    // Note: no #[bun_jsc::host_fn] — BunObject.rs::static_adapters owns the
     // C-ABI shim (it extracts `opts` from the CallFrame and calls this directly).
     pub fn connect(global: &JSGlobalObject, opts: JSValue) -> JsResult<JSValue> {
         Self::connect_inner(global, None, None, opts)
@@ -937,12 +934,12 @@ impl Listener {
         let vm = VirtualMachine::get().as_mut();
 
         // is_server=false: this is the client connect path. Handlers.mode must be
-        // .client so markInactive() takes the allocator.destroy branch — the
-        // .server branch does @fieldParentPtr("handlers", this) to reach a
-        // Listener, but here handlers live in a standalone allocator.create()
-        // block (see below), so that would read past the allocation.
+        // .client so markInactive() takes the destroy branch — the
+        // .server branch recovers the containing Listener from the handlers
+        // field pointer, but here handlers live in a standalone heap
+        // allocation (see below), so that would read past the allocation.
         let mut socket_config = SocketConfig::from_js(vm, opts, global, false)?;
-        // PORT NOTE: `defer socket_config.deinitExcludingHandlers()` — Drop on SocketConfig
+        // Note: `socket_config` cleanup (excluding handlers) handled by Drop on SocketConfig
 
         let port = socket_config.port;
         let ssl_enabled = socket_config.ssl.is_some();
@@ -953,13 +950,12 @@ impl Listener {
         let connection: UnixOrHost = 'blk: {
             if let Some(fd_) = opts.get_truthy(global, "fd")? {
                 if fd_.is_number() {
-                    // TODO(port): `JSValue::as_file_descriptor` — using direct int decode for now.
                     let fd = Fd::from_uv(fd_.to_int32());
                     break 'blk UnixOrHost::Fd(fd);
                 }
             }
-            // PORT NOTE: Zig `intoOwnedSlice` — transfer the allocation out of
-            // `socket_config` so the later `mem::forget` doesn't leak it.
+            // Transfer the allocation out of `socket_config` so the later
+            // `mem::forget` doesn't leak it.
             let host: Box<[u8]> = core::mem::take(&mut socket_config.hostname_or_unix)
                 .into_vec()
                 .into_boxed_slice();
@@ -969,7 +965,7 @@ impl Listener {
                 UnixOrHost::Unix(host)
             }
         };
-        // errdefer connection.deinit() — Box drops on error path
+        // `connection` Box drops on error path
 
         // Resolve the prebuilt SSL_CTX before the platform branches so the Windows
         // named-pipe path can adopt it. node:tls passes the native SecureContext as
@@ -993,7 +989,6 @@ impl Listener {
                 owned_ssl_ctx = NonNull::new(unsafe { (*sc).borrow() });
             }
         }
-        // errdefer if (owned_ssl_ctx) |c| BoringSSL.SSL_CTX_free(c);
         let mut ssl_ctx_guard = scopeguard::guard(owned_ssl_ctx, |c| {
             if let Some(c) = c {
                 // SAFETY: FFI — c is a live SSL_CTX* with one owned ref from borrow()/get_or_create()
@@ -1009,7 +1004,7 @@ impl Listener {
             use bun_sys::FdExt as _;
 
             let mut buf = PathBuffer::uninit();
-            // PORT NOTE: reshaped for borrowck — `normalize_pipe_name` borrows
+            // Note: reshaped for borrowck — `normalize_pipe_name` borrows
             // `buf` for the returned slice; store length and re-borrow after the
             // `connection` match drops.
             let mut pipe_name_len: Option<usize> = None;
@@ -1048,7 +1043,7 @@ impl Listener {
             if is_named_pipe {
                 default_data.ensure_still_alive();
 
-                // PORT NOTE: by-value move of Handlers — see `listen()` for rationale.
+                // Note: by-value move of Handlers — see `listen()` for rationale.
                 // SAFETY: socket_config.handlers is valid; we forget socket_config below.
                 let handlers_moved: Handlers = unsafe { core::ptr::read(&socket_config.handlers) };
                 let mut ssl_taken = socket_config.ssl.take();
@@ -1135,11 +1130,11 @@ impl Listener {
                     // Transfer the borrowed CTX into the pipe's SSLWrapper. From
                     // here it owns the ref on every path (initWithCTX adopts on
                     // success, initTLSWrapper frees on failure), so null our local
-                    // before the call so the errdefer above can't double-free.
+                    // before the call so the cleanup guard above can't double-free.
                     let ctx_for_pipe =
                         core::mem::replace(&mut *ssl_ctx_guard, None).map(|p| p.as_ptr());
-                    // PORT NOTE: re-borrow connection from the socket field — `connection`
-                    // was moved into `tls` above (single allocation in Zig, aliased read).
+                    // Note: re-borrow connection from the socket field — `connection`
+                    // was moved into `tls` above.
                     let named_pipe_result = match tls_ref.connection.get().as_ref().unwrap() {
                         UnixOrHost::Unix(_) => WindowsNamedPipeContext::connect(
                             global,
@@ -1284,12 +1279,12 @@ impl Listener {
                 }
             }
         }
-        // (errdefer for owned_ssl_ctx already armed at the earlier lookup site;
+        // (cleanup guard for owned_ssl_ctx already armed at the earlier lookup site;
         // duplicating it here would double-free on error.)
 
         default_data.ensure_still_alive();
 
-        // PORT NOTE: by-value move of Handlers. See `listen()` for rationale.
+        // Note: by-value move of Handlers. See `listen()` for rationale.
         let mut socket_config = core::mem::ManuallyDrop::new(socket_config);
         // SAFETY: socket_config.handlers is valid; ManuallyDrop suppresses the second drop.
         let handlers_moved: Handlers =
@@ -1308,10 +1303,10 @@ impl Listener {
             .with_mut(|p| p.set(global, promise_value));
         let handlers_ptr: *mut Handlers = bun_core::heap::into_raw(handlers_box);
 
-        // Ownership of the SSL_CTX is about to move into the socket; disarm the errdefer.
+        // Ownership of the SSL_CTX is about to move into the socket; disarm the guard.
         let owned_ssl_ctx = scopeguard::ScopeGuard::into_inner(ssl_ctx_guard);
 
-        // PORT NOTE: `switch (ssl_enabled) { inline else => |is_ssl_enabled| {...} }` —
+        // Note: `switch (ssl_enabled) { inline else => |is_ssl_enabled| {...} }` —
         // dispatched to a const-generic helper for monomorphization.
         if ssl_enabled {
             connect_finish::<true>(
@@ -1370,9 +1365,8 @@ impl Listener {
             16 => global.common_strings().ipv6(),
             _ => return Ok(JSValue::UNDEFINED),
         };
-        // .zig: `std.net.Address.initIp{4,6}` → `bun.fmt.formatIp` (which strips
-        // `:port` and `[]`). Mirror with `SocketAddrV{4,6}` so `format_ip`'s
-        // strip logic sees the same `addr:port` / `[addr]:port` shape.
+        // Format with `SocketAddrV{4,6}` so `format_ip`'s strip logic sees the
+        // expected `addr:port` / `[addr]:port` shape.
         let formatted: &[u8] = match address_bytes.len() {
             4 => bun_core::fmt::format_ip(
                 &std::net::SocketAddrV4::new(
@@ -1404,8 +1398,7 @@ impl Listener {
     }
 }
 
-// PORT NOTE: hoisted from `switch (ssl_enabled) { inline else => |is_ssl_enabled| {...} }` body
-// in connect_inner. // PERF(port): was comptime bool dispatch — preserved via const generic.
+// Note: hoisted from the body of connect_inner; dispatched via const generic.
 fn connect_finish<const IS_SSL: bool>(
     global: &JSGlobalObject,
     maybe_previous: Option<*mut NewSocket<IS_SSL>>,
@@ -1421,7 +1414,7 @@ fn connect_finish<const IS_SSL: bool>(
     let socket: *mut NewSocket<IS_SSL> = if let Some(prev_ptr) = maybe_previous {
         // SAFETY: caller passes a live NewSocket<IS_SSL>
         let prev = unsafe { &*prev_ptr };
-        // TODO(port): `JsRef::is_not_empty` — assert non-empty wrapper.
+        debug_assert!(prev.this_value.get().is_not_empty());
         if let Some(prev_handlers) = prev.handlers.get() {
             // Only free the previous Handlers when no callback scope is still
             // holding it. If a `data`/`close` handler synchronously re-entered
@@ -1479,7 +1472,7 @@ fn connect_finish<const IS_SSL: bool>(
             twin: JsCell::new(None),
         })
     };
-    // Ownership moved into `socket`; disarm the errdefer.
+    // Ownership moved into `socket`; disarm the guard.
     // (owned_ssl_ctx consumed above)
     // SAFETY: socket is a valid heap pointer
     let socket_ref = unsafe { &*socket };
@@ -1496,8 +1489,7 @@ fn connect_finish<const IS_SSL: bool>(
     // socket hangs forever with no connect/error/close. Upgrade here so the
     // in-flight connect pins the wrapper. (Same guard as `mark_active`; no-op
     // on the fresh-allocation path where `get_this_value` already
-    // `set_strong`'d.) Intentionally diverges from the Zig spec, which has
-    // the same race.
+    // `set_strong`'d.)
     if socket_ref.this_value.get().is_not_empty() {
         socket_ref.this_value.with_mut(|r| r.upgrade(global));
     }
@@ -1506,9 +1498,8 @@ fn connect_finish<const IS_SSL: bool>(
         f.set(SocketFlags::ALLOW_HALF_OPEN, allow_half_open);
         socket_ref.flags.set(f);
     }
-    // PORT NOTE: Zig stored `connection` in the socket field and passed the same
-    // value to doConnect (single allocation, aliased read). `do_connect` now
-    // reads `self.connection` directly so no second borrow is needed here.
+    // Note: `do_connect` reads `self.connection` directly so no second
+    // borrow is needed here.
     if socket_ref.do_connect().is_err() {
         let errno = if port.is_none() {
             bun_sys::SystemErrno::ENOENT as c_int
@@ -1638,14 +1629,10 @@ impl WindowsNamedPipeListeningContext {
         };
         if result.is_err() {
             // connection dropped
-            // PORT NOTE: Zig (Listener.zig:994) calls `client.deinit()` synchronously here,
-            // freeing the ctx before returning from the libuv connection callback. We instead
-            // release the only ref, which goes 1→0 → schedule_deinit → next-tick free. The
-            // deferred path is kept because `get_accepted_by` may have already `uv_pipe_init`'d
+            // Release the only ref, which goes 1→0 → schedule_deinit → next-tick free. The
+            // deferred path is required because `get_accepted_by` may have already `uv_pipe_init`'d
             // the client's inner handle on the loop; freeing the backing storage in-callback
-            // before `uv_close` completes is the exact pattern libuv forbids. Drop semantics
-            // match Zig's `deinit` (socket.deref() then named_pipe.deinit()), so this is a
-            // timing divergence only.
+            // before `uv_close` completes is the exact pattern libuv forbids.
             // SAFETY: `client` was just allocated via `WindowsNamedPipeContext::create`
             // with refcount==1; releasing the only ref schedules deinit.
             unsafe { WindowsNamedPipeContext::deref(client) };
@@ -1692,7 +1679,7 @@ impl WindowsNamedPipeListeningContext {
         ssl_config: Option<&SSLConfig>,
         listener: *mut Listener,
     ) -> Result<*mut WindowsNamedPipeListeningContext, bun_core::Error> {
-        // `bun.TrivialNew` — heap-allocate at the final address so libuv can
+        // Heap-allocate at the final address so libuv can
         // store a pointer back into `uv_pipe`.
         let this = bun_core::heap::into_raw(Box::new(WindowsNamedPipeListeningContext {
             uv_pipe: bun_core::ffi::zeroed(),
@@ -1704,7 +1691,7 @@ impl WindowsNamedPipeListeningContext {
         // SAFETY: just allocated, non-null, exclusive.
         let this_ref = unsafe { &mut *this };
 
-        // errdefer: once the uv pipe handle is registered with the loop it must be closed via
+        // Cleanup guard: once the uv pipe handle is registered with the loop it must be closed via
         // uv_close; before that point we can free the struct directly. `deinit()` also
         // frees the SSL context if one was created. State `.1` flips once `uv_pipe_init`
         // succeeds; disarmed via `into_inner` on success.
@@ -1780,5 +1767,3 @@ impl WindowsNamedPipeListeningContext {
         }
     }
 }
-
-// ported from: src/runtime/socket/Listener.zig
diff --git a/src/runtime/socket/SSLConfig.rs b/src/runtime/socket/SSLConfig.rs
index 0566ebeab74..5eca5b4d3a5 100644
--- a/src/runtime/socket/SSLConfig.rs
+++ b/src/runtime/socket/SSLConfig.rs
@@ -1,7 +1,7 @@
 //! DEDUP(D202): the `SSLConfig` struct, its `Clone`/`Drop`/`Default`/hash/
 //! equality/registry impls, and `as_usockets*`/`for_client_verification` were
-//! double-ported (here and in `bun_http::ssl_config`). The lower-tier
-//! `bun_http` copy is canonical (JSC-free, matches the Zig `?[*:0]const u8`
+//! duplicated (here and in `bun_http::ssl_config`). The lower-tier
+//! `bun_http` copy is canonical (JSC-free, nullable NUL-terminated C-string
 //! field layout); this module now re-exports it and keeps ONLY the
 //! JSC-dependent constructors (`from_js` / `from_generated` / blob+path
 //! readers) plus the WebSocket C-ABI exports, which need `bun_jsc` /
@@ -32,7 +32,7 @@ pub use bun_http::ssl_config::{
 // ReadFromBlobError
 // ──────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: cannot derive `thiserror::Error` because `JsError` is not
+// Cannot derive `thiserror::Error` because `JsError` is not
 // `std::error::Error`/`Display`. Manual `From<JsError>` instead.
 #[derive(Debug)]
 pub(crate) enum ReadFromBlobError {
@@ -153,7 +153,7 @@ impl SSLConfigFromJs for SSLConfig {
         generated: &jsc::generated::SSLConfig,
     ) -> JsResult<Option<SSLConfig>> {
         let mut result = SSLConfig::zero();
-        // errdefer result.deinit() — handled by Drop on error-path `?`
+        // `result` cleanup handled by Drop on error-path `?`
         let mut any = false;
 
         if let Some(passphrase) = generated.passphrase.get() {
@@ -249,19 +249,19 @@ pub fn from_js(
 
 // ── handlePath / handleFile helpers ──────────────────────────────────
 
-// PERF(port): was comptime monomorphization (comptime field: []const u8) —
-// demoted to runtime &'static str since only used in cold error message.
+// `field` is a runtime &'static str (not monomorphized) since it is only
+// used in a cold error message.
 fn handle_path(
     global: &JSGlobalObject,
     field: &'static str,
     string: &bun_core::String,
 ) -> JsResult<*const c_char> {
     let name = string.to_owned_slice_z();
-    // Zig: `std.posix.system.access(name, F_OK) != 0`. `bun_sys::access`
-    // routes to `access(2)` on POSIX and `GetFileAttributesW` on Windows
-    // (via `sys_uv`), so this is the cross-platform existence probe.
+    // `bun_sys::access` routes to `access(2)` on POSIX and
+    // `GetFileAttributesW` on Windows (via `sys_uv`), so this is the
+    // cross-platform existence probe.
     if bun_sys::access(&name, bun_sys::posix::F_OK).is_err() {
-        // errdefer: free_sensitive(name) — zero before drop. Route through
+        // Error path: free_sensitive(name) — zero before drop. Route through
         // the canonical helper so the secure-zero core stays single-sourced.
         // SAFETY: `zbox_into_raw` yields a `default_alloc::malloc`-backed,
         // NUL-terminated buffer whose ownership we now hold exclusively.
@@ -315,8 +315,8 @@ fn handle_file(
             }
         },
     )?;
-    // errdefer free_sensitive(single) — on the only fallible op below (alloc),
-    // Rust aborts on OOM, so no errdefer needed.
+    // The only fallible op below is alloc, and Rust aborts on OOM, so no
+    // error-path zeroing is needed.
     Ok(Some(vec![single].into_boxed_slice()))
 }
 
@@ -328,7 +328,7 @@ fn handle_file_array(
         return Ok(None);
     }
     let mut result: Vec<*const c_char> = Vec::with_capacity(elements.len());
-    // errdefer { free_sensitive each; drop result } — need zeroing on error:
+    // Error path: free_sensitive each, then drop result — need zeroing on error:
     let mut guard = scopeguard::guard(&mut result, |r| {
         for p in r.drain(..) {
             // SAFETY: every pushed `p` came from `handle_single_file` →
@@ -337,7 +337,6 @@ fn handle_file_array(
         }
     });
     for elem in elements {
-        // PERF(port): was appendAssumeCapacity
         guard.push(handle_single_file(
             global,
             match elem {
@@ -359,7 +358,6 @@ fn handle_file_array(
     Ok(Some(core::mem::take(result).into_boxed_slice()))
 }
 
-// PORT NOTE: Zig used an anonymous `union(enum)` param; named here.
 enum SingleFile<'a> {
     String(bun_core::String),
     Buffer(&'a mut jsc::JSCArrayBuffer),
@@ -383,8 +381,8 @@ fn handle_single_file(
 // ──────────────────────────────────────────────────────────────────────────
 // WebSocket C-ABI exports (parseSSLConfig / freeSSLConfig)
 //
-// LAYERING: ground truth is `src/http_jsc/websocket_client/
-// WebSocketUpgradeClient.zig::parseSSLConfig`, but `SSLConfig::from_js`
+// LAYERING: the consumer is `src/http_jsc/websocket_client/
+// WebSocketUpgradeClient.rs`, but `SSLConfig::from_js`
 // dereferences Blob / JSCArrayBuffer / node_fs values (tier-6) and lives in
 // this crate. `bun_runtime → bun_http_jsc`, so hosting the export here breaks
 // the cycle without an opaque stub. The boxed payload is the canonical
@@ -420,7 +418,7 @@ pub(crate) extern "C" fn Bun__WebSocket__parseSSLConfig(
 /// Exported for C++ so error/early-return paths in JSWebSocket.cpp and
 /// WebSocket.cpp can release ownership without leaking the heap allocation
 /// (and all duped cert/key/CA strings inside it) when `connect()` never
-/// hands the pointer off to a Zig upgrade client.
+/// hands the pointer off to an upgrade client.
 ///
 /// # Safety
 /// `config` must be null or a pointer previously returned by
@@ -435,5 +433,3 @@ pub(crate) unsafe extern "C" fn Bun__WebSocket__freeSSLConfig(
     // is being transferred back. `heap::take` handles the null case.
     drop(unsafe { bun_core::heap::take(config) });
 }
-
-// ported from: src/runtime/socket/SSLConfig.zig
diff --git a/src/runtime/socket/SocketAddress.rs b/src/runtime/socket/SocketAddress.rs
index e24c8bdb37e..39224146fc9 100644
--- a/src/runtime/socket/SocketAddress.rs
+++ b/src/runtime/socket/SocketAddress.rs
@@ -13,15 +13,13 @@ use bun_cares_sys::c_ares as ares;
 use bun_core::{OwnedString, String as BunString, ZStr};
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsClass, JsError, JsResult, StringJsc, URL};
 
-// `pub const js = jsc.Codegen.JSSocketAddress;` + toJS/fromJS/fromJSDirect
-// → handled by the JsClass derive; codegen wires toJS/fromJS/fromJSDirect.
+// The JsClass derive / codegen wires toJS/fromJS/fromJSDirect.
 // R-2 (host-fn re-entrancy): every JS-exposed method takes `&self`; the one
 // field written from a host_fn-reachable path (`_presentation`, lazily filled
 // by `address()`) is `Cell`-wrapped (`BunString` is `Copy`). `_addr` is
 // read-only after construction and stays bare.
 #[bun_jsc::JsClass]
 pub struct SocketAddress {
-    // NOTE: not std.net.Address b/c .un is huge and we don't use it.
     // NOTE: not C.sockaddr_storage b/c it's _huge_. we need >= 28 bytes for sockaddr_in6,
     // but sockaddr_storage is 128 bytes.
     /// @internal
@@ -46,7 +44,6 @@ impl Default for SocketAddress {
 }
 
 impl SocketAddress {
-    // `pub const new = bun.TrivialNew(SocketAddress);`
     pub fn new(init: SocketAddress) -> Box<SocketAddress> {
         Box::new(init)
     }
@@ -104,7 +101,7 @@ impl Options {
 
         // required. Validated by `validatePort`.
         let _port: u16 = if let Some(p) = obj.get(global, "port")? {
-            // PORT NOTE: Zig `JSValue.isFinite()`; Rust shim until landed in bun_jsc.
+            // Note: shim until `JSValue::is_finite` lands in bun_jsc.
             if !(p.is_number() && p.as_number().is_finite()) {
                 return Err(Self::throw_bad_port(global, p));
             }
@@ -150,7 +147,7 @@ impl Options {
     }
 
     fn throw_bad_port(global: &JSGlobalObject, port_: JSValue) -> JsError {
-        // `defer ty.deref()` → OwnedString (returned by determine_specific_type) releases the +1.
+        // OwnedString (returned by determine_specific_type) releases the +1.
         let Ok(ty) = JSGlobalObject::determine_specific_type(global, port_) else {
             return global
                 .err(
@@ -178,11 +175,11 @@ impl SocketAddress {
     /// ### `SocketAddress.parse(input: string): SocketAddress | undefined`
     /// Parse an address string (with an optional `:port`) into a `SocketAddress`.
     /// Returns `undefined` if the input is invalid.
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the macro's free-fn arm emits a
+    // Note: no `#[bun_jsc::host_fn]` here — the macro's free-fn arm emits a
     // bare `parse(__g, __f)` call which doesn't resolve inside an `impl` block.
     // The C-ABI shim is wired by the `.classes.ts` codegen / `JsClass` derive.
     pub fn parse(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
-        // `defer input.deref()` → OwnedString releases the +1 from BunString::from_js
+        // OwnedString releases the +1 from BunString::from_js
         let input: OwnedString = {
             let input_arg = callframe.argument(0);
             if !input_arg.is_string() {
@@ -194,8 +191,7 @@ impl SocketAddress {
         };
 
         const PREFIX: &str = "http://";
-        // PERF(port): was comptime bool dispatch (`switch (input.is8Bit()) { inline else => |is_8_bit| ... }`) — profile if it shows up on a hot path.
-        // `defer url_str.deref()` → OwnedString releases the +1 from create_uninitialized_*
+        // OwnedString releases the +1 from create_uninitialized_*
         let url_str: OwnedString = if input.is_8bit() {
             let from_chars = input.latin1();
             let (str, to_chars) =
@@ -216,7 +212,6 @@ impl SocketAddress {
         let Some(url_ptr) = URL::from_string(url_str.get()) else {
             return Ok(JSValue::UNDEFINED);
         };
-        // `defer url.deinit()`
         // SAFETY: URL::from_string returns an owned C++ heap pointer; freed exactly once via destroy().
         let _url_guard = scopeguard::guard(url_ptr, |p| unsafe { URL::destroy(p.as_ptr()) });
         // `_url_guard` keeps the C++ allocation live for this scope, so the
@@ -239,10 +234,9 @@ impl SocketAddress {
         // - "[::1]" -> "::1"
         // - "0x.0x.0" -> "0.0.0.0"
         let paddr = host.latin1(); // presentation address
-        // PORT NOTE: Zig used `std.net.Ip{4,6}Address.parse`; Rust port uses
-        // `ares_inet_pton` (already linked) to fill the sockaddr in place.
-        // `std.net.Ip6Address.parse` accepts a `%scope` suffix and populates
-        // `scope_id`; `ares_inet_pton` does not, so we strip and parse it here.
+        // Uses `ares_inet_pton` (already linked) to fill the sockaddr in place.
+        // A `%scope` suffix populates `scope_id`, but
+        // `ares_inet_pton` does not accept it, so we strip and parse it here.
         // (WHATWG URL host parsing rejects zone identifiers, so in practice
         // `URL::host_()` should not yield one — handled defensively.)
         let addr = if paddr[0] == b'[' && paddr[paddr.len() - 1] == b']' {
@@ -251,7 +245,7 @@ impl SocketAddress {
             if let Some(pct) = inner.iter().position(|&b| b == b'%') {
                 let zone = &inner[pct + 1..];
                 inner = &inner[..pct];
-                // Numeric zone → scope_id directly (matches std.net.Ip6Address.parse).
+                // Numeric zone → scope_id directly.
                 // Non-numeric zone would require if_nametoindex; treat as invalid here.
                 scope_id = match bun_core::fmt::parse_int::<u32>(zone, 10).ok() {
                     Some(id) => id,
@@ -295,7 +289,7 @@ impl SocketAddress {
     /// ### `SocketAddress.isSocketAddress(value: unknown): value is SocketAddress`
     /// Returns `true` if `value` is a `SocketAddress`. Subclasses and similarly-shaped
     /// objects are not considered `SocketAddress`s.
-    // PORT NOTE: no `#[bun_jsc::host_fn]` — free-fn arm emits bare ident; see `parse`.
+    // Note: no `#[bun_jsc::host_fn]` — free-fn arm emits bare ident; see `parse`.
     pub fn is_socket_address(_global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let value = callframe.argument(0);
         Ok(JSValue::from(
@@ -317,7 +311,7 @@ impl SocketAddress {
     ///
     /// ## References
     /// - [Node docs](https://nodejs.org/api/net.html#new-netsocketaddressoptions)
-    // PORT NOTE: no `#[bun_jsc::host_fn]` — free-fn arm emits bare ident; see `parse`.
+    // Note: no `#[bun_jsc::host_fn]` — free-fn arm emits bare ident; see `parse`.
     pub fn constructor(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<Box<SocketAddress>> {
         let options_obj = frame.argument(0);
         if options_obj.is_undefined() {
@@ -325,7 +319,6 @@ impl SocketAddress {
                 _addr: sockaddr::LOOPBACK_V4,
                 _presentation: Cell::new(BunString::empty()),
                 // ._presentation = WellKnownAddress::loopback_v4(),
-                // ._presentation = BunString::from_js(global.common_strings().loopback_v4()) catch unreachable,
             }));
         }
         options_obj.ensure_still_alive();
@@ -387,11 +380,8 @@ impl SocketAddress {
 
         // We need a zero-terminated cstring for `ares_inet_pton`, which forces us to
         // copy the string.
-        // PERF(port): was stack-fallback — Zig used std.heap.stackFallback(64, bun.default_allocator).
+        // PERF: could use a small stack buffer with heap fallback.
 
-        // NOTE: `zig translate-c` creates semantically invalid code for `C.ntohs`.
-        // Switch back to `htons(options.port)` when this issue gets resolved:
-        // https://github.com/ziglang/zig/issues/22804
         let addr: sockaddr = match options.family {
             AF::INET => {
                 let mut sin: inet::sockaddr_in = inet::sockaddr_in {
@@ -403,7 +393,7 @@ impl SocketAddress {
                 if let Some(address_str) = options.address {
                     presentation = address_str;
                     let slice = presentation.to_owned_slice_z();
-                    // `defer alloc.free(slice)` → Box<ZStr> drops at scope exit
+                    // Box<ZStr> drops at scope exit
                     pton(
                         global,
                         inet::AF_INET,
@@ -505,10 +495,9 @@ impl SocketAddress {
 
 impl Drop for SocketAddress {
     fn drop(&mut self) {
-        // Zig `deinit`: `this._presentation.deref()` then `destroy(this)`.
         // `bun_core::String` is `Copy` (no Drop), so the +1 on the cached
         // presentation must be released explicitly here. `deref()` on a `.Dead`
-        // string is a no-op, matching the Zig spec.
+        // string is a no-op.
         self._presentation.get().deref();
     }
 }
@@ -540,7 +529,6 @@ impl SocketAddress {
         let mut addr_str = self.address();
         let port = self.port();
         let is_v6 = self.family() == AF::INET6;
-        // `defer this._presentation = .dead;`
         let _guard = scopeguard::guard(&self._presentation, |p| p.set(BunString::dead()));
         Ok(JSSocketAddressDTO__create(
             global,
@@ -575,7 +563,6 @@ impl SocketAddress {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn JSSocketAddressDTO__create(
         global_object: &JSGlobalObject,
@@ -608,8 +595,8 @@ impl SocketAddress {
     /// and `::`, respectively).
     ///
     /// ### TODO
-    /// - replace `addressToString` in `dns.zig` w this
-    /// - use this impl in server.zig
+    /// - replace `addressToString` in the dns module with this
+    /// - use this impl in the server module
     pub fn address(&self) -> BunString {
         let cached = self._presentation.get();
         if cached.tag() != bun_core::Tag::Dead {
@@ -647,8 +634,8 @@ impl SocketAddress {
         JSValue::js_number(f64::from(this.family().int()))
     }
 
-    /// NOTE: zig std uses posix values only, while this returns whatever the
-    /// system uses. Do not compare to `std.posix.AF`.
+    /// NOTE: this returns whatever address-family value the system uses,
+    /// which may differ across platforms.
     pub fn family(&self) -> AF {
         // NOTE: sockaddr_in and sockaddr_in6 have the same layout for family.
         // `sa_family_t` width varies (u8 on Darwin/the BSDs, u16 on Linux/
@@ -670,8 +657,6 @@ impl SocketAddress {
     /// Get the port number in host byte order.
     pub fn port(&self) -> u16 {
         // NOTE: sockaddr_in and sockaddr_in6 have the same layout for port.
-        // NOTE: `zig translate-c` creates semantically invalid code for `C.ntohs`.
-        // Switch back to `ntohs` when this issue gets resolved: https://github.com/ziglang/zig/issues/22804
         u16::from_be(self._addr.port_raw())
     }
 
@@ -701,8 +686,8 @@ impl SocketAddress {
 
     #[bun_jsc::host_fn(method)]
     pub fn to_json(this: &Self, global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
-        // PORT NOTE: Zig used an anon struct with `jsc.JSObject.create`; Rust
-        // requires a `PojoFields` impl, so use a local struct.
+        // `jsc.JSObject.create` requires a `PojoFields` impl, so use a local
+        // struct.
         struct ToJson {
             address: JSValue,
             family: JSValue,
@@ -733,30 +718,29 @@ impl SocketAddress {
     }
 }
 
-// PERF(port): was comptime monomorphization (`comptime af: c_int`) — profile if it shows up on a hot path.
 fn pton(global: &JSGlobalObject, af: c_int, addr: &ZStr, dst: *mut c_void) -> JsResult<()> {
+    use bun_jsc::js_global_object::SysErrOptions;
     // SAFETY: addr is NUL-terminated, dst points to a valid in_addr/in6_addr
     match unsafe { ares::ares_inet_pton(af, addr.as_ptr(), dst) } {
-        0 => Err(global
-            .err(
-                bun_jsc::ErrorCode::ERR_INVALID_IP_ADDRESS,
-                format_args!("Invalid socket address"),
-            )
-            .throw()),
-
-        // TODO: figure out proper way to convert a c errno into a js exception
-        // TODO(port): Zig set `.errno = std.c._errno().*` on the thrown SystemError;
-        // `JSGlobalObject::throw_sys_error` / `SysErrOptions` are not yet on the
-        // active stub, so the errno property is dropped for now.
-        -1 => {
-            let _ = bun_sys::last_errno();
-            Err(global
-                .err(
-                    bun_jsc::ErrorCode::ERR_INVALID_IP_ADDRESS,
-                    format_args!("Invalid socket address"),
-                )
-                .throw())
-        }
+        0 => Err(global.throw_sys_error(
+            &SysErrOptions {
+                code: bun_jsc::ErrorCode::ERR_INVALID_IP_ADDRESS,
+                errno: None,
+                name: None,
+            },
+            format_args!("Invalid socket address"),
+        )),
+
+        // Open question: the proper way to
+        // convert a C errno into a JS exception.
+        -1 => Err(global.throw_sys_error(
+            &SysErrOptions {
+                code: bun_jsc::ErrorCode::ERR_INVALID_IP_ADDRESS,
+                errno: Some(bun_sys::last_errno()),
+                name: None,
+            },
+            format_args!("Invalid socket address"),
+        )),
         1 => Ok(()),
         _ => unreachable!(),
     }
@@ -778,7 +762,6 @@ fn pton_noerr(af: c_int, addr: &[u8], dst: *mut c_void) -> bool {
 
 // =============================================================================
 
-// FIXME: c-headers-for-zig casts AF_* and PF_* to `c_int` when it should be `comptime_int`
 #[repr(u16)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum AF {
@@ -794,7 +777,7 @@ impl AF {
 
     pub(crate) fn from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<AF> {
         if value.is_string() {
-            // `defer fam_str.deref()` → OwnedString releases the +1 from BunString::from_js
+            // OwnedString releases the +1 from BunString::from_js
             let fam_str = OwnedString::new(BunString::from_js(value, global)?);
             if fam_str.length() != 4 {
                 return Err(global.throw_invalid_argument_property_value(
@@ -1001,7 +984,6 @@ impl sockaddr {
     }
 
     // I'd bet money endianness is going to screw us here.
-    // Zig name: `@"127.0.0.1"`
     pub(crate) const LOOPBACK_V4: sockaddr = sockaddr {
         sin: inet::sockaddr_in {
             family: inet::AF_INET as inet::sa_family_t,
@@ -1012,7 +994,6 @@ impl sockaddr {
     };
     // TODO: check that `::` is all zeroes on all platforms. Should correspond
     // to `IN6ADDR_ANY_INIT`.
-    // Zig name: `@"::"`
     pub(crate) const ANY_V6: sockaddr = sockaddr {
         sin6: inet::sockaddr_in6 {
             family: inet::AF_INET6 as inet::sa_family_t,
@@ -1032,17 +1013,22 @@ impl sockaddr {
 // =============================================================================
 
 // The same types are defined in a bunch of different places. We should probably unify them.
-// TODO(port): comptime static asserts — Rust const_assert! once inet types are concrete
-// const _: () = assert!(mem::size_of::<inet::socklen_t>() == mem::size_of::<bun_sys::posix::socklen_t>());
-// const _: () = assert!(mem::align_of::<inet::socklen_t>() == mem::align_of::<bun_sys::posix::socklen_t>());
-// const _: () = assert!(AF::INET.int() == ares::AF::INET);
-// const _: () = assert!(AF::INET6.int() == ares::AF::INET6);
+// Compile-time checks: socklen_t shape parity + AF constant parity with c-ares.
+#[cfg(not(windows))]
+const _: () = {
+    assert!(mem::size_of::<inet::socklen_t>() == mem::size_of::<libc::socklen_t>());
+    assert!(mem::align_of::<inet::socklen_t>() == mem::align_of::<libc::socklen_t>());
+};
+const _: () = {
+    assert!(AF::INET as c_int == ares::AF::INET);
+    assert!(AF::INET6 as c_int == ares::AF::INET6);
+};
 
 #[cfg(windows)]
 pub mod inet {
     #![allow(non_camel_case_types)]
     use bun_sys::windows::ws2_32 as ws2;
-    // PORT NOTE: `bun_windows_sys::ws2_32` does not currently surface
+    // Note: `bun_windows_sys::ws2_32` does not currently surface
     // `INET6_ADDRSTRLEN` / `ADDRESS_FAMILY` / `USHORT`; mirror the
     // `ws2ipdef.h` / `ws2def.h` values locally so the Windows build
     // resolves without widening the leaf crate.
@@ -1065,5 +1051,3 @@ pub mod inet {
     pub use bun_sys::posix::AF::{INET as AF_INET, INET6 as AF_INET6};
     pub type socklen_t = super::ares::ares_socklen_t;
 }
-
-// ported from: src/runtime/socket/SocketAddress.zig
diff --git a/src/runtime/socket/UpgradedDuplex.rs b/src/runtime/socket/UpgradedDuplex.rs
index b656f1b369d..62673254475 100644
--- a/src/runtime/socket/UpgradedDuplex.rs
+++ b/src/runtime/socket/UpgradedDuplex.rs
@@ -48,12 +48,11 @@ bun_event_loop::impl_timer_owner!(UpgradedDuplex; from_timer_ptr => event_loop_t
 #[derive(Default)]
 pub struct CertError {
     pub error_no: i32,
-    // Owned NUL-terminated copies (Zig: `[:0]const u8` allocated via `dupeZ`, freed in deinit).
-    // `None` represents the Zig default `""`.
+    // Owned NUL-terminated copies. `None` represents the default `""`.
     pub code: Option<Box<CStr>>,
     pub reason: Option<Box<CStr>>,
 }
-// Zig `CertError.deinit` only freed `code`/`reason`; `Box<CStr>` drops automatically — no explicit Drop needed.
+// `Box<CStr>` drops automatically — no explicit Drop needed.
 
 type WrapperType = SSLWrapper<*mut UpgradedDuplex>;
 
@@ -74,11 +73,9 @@ use crate::jsc_hooks::timer_all_mut as timer_all;
 
 /// Lazily create-and-cache a JS host-function callback in `slot`.
 ///
-/// All four `get_js_handlers` slots follow the identical pattern from
-/// `UpgradedDuplex.zig:getJSHandlers` (lines 268/287/306/324):
+/// All four `get_js_handlers` slots follow the identical pattern:
 /// `NewFunctionWithData(global, null, 0, fn, self)` → `ensureStillAlive` →
-/// redundant `setFunctionData(self)` → `Strong.Optional.create`. The
-/// redundant `set_function_data` is preserved verbatim from the Zig source.
+/// redundant `setFunctionData(self)` → `Strong.Optional.create`.
 #[inline]
 fn lazy_js_handler(
     slot: &mut StrongOptional,
@@ -136,13 +133,12 @@ impl UpgradedDuplex {
         bun_output::scoped_log!(UpgradedDuplex, "onClose");
         // SAFETY: SSLWrapper handlers ctx is `self as *mut Self`; live for the wrapper's lifetime.
         let this = unsafe { &mut *this };
-        // Zig: `defer this.deinit();` — runs after the two calls below.
 
         (this.handlers.on_close)(this.handlers.ctx);
         // closes the underlying duplex
         this.call_write_or_end(None, false);
 
-        // Early teardown (Zig calls deinit explicitly here; struct itself is dropped later by parent).
+        // Early teardown (struct itself is dropped later by parent).
         this.teardown();
     }
 
@@ -159,7 +155,6 @@ impl UpgradedDuplex {
         // global is set in `from()` whenever origin is set.
         let Some(global) = self.global else { return };
 
-        // Zig `JSValue.getFunction` — `.get()` + callable check (`catch return orelse return`).
         let name = if msg_more { "write" } else { "end" };
         let write_or_end = match duplex.get(&global, name) {
             Ok(Some(f)) if f.is_callable() => f,
@@ -207,8 +202,7 @@ impl UpgradedDuplex {
     }
 
     fn on_internal_receive_data(&mut self, data: &[u8]) {
-        // PORT NOTE: reshaped for borrowck — Zig borrowed `wrapper` then called
-        // `self.resetTimeout()` (which needs &mut self). Reordered: reset first, then borrow.
+        // Note: reset the timeout first, then borrow `wrapper` (borrowck).
         if self.wrapper.is_some() {
             self.reset_timeout();
             if let Some(wrapper) = &mut self.wrapper {
@@ -310,7 +304,6 @@ impl UpgradedDuplex {
         ssl_options: &crate::server::server_config::SSLConfig,
         is_client: bool,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.wrapper = Some(super::ssl_wrapper::init(
             ssl_options,
             is_client,
@@ -337,7 +330,6 @@ impl UpgradedDuplex {
         ctx: *mut bun_boringssl_sys::SSL_CTX,
         is_client: bool,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // errdefer SSL_CTX_free(ctx) — free the adopted ref on the error path only.
         let ctx_guard = scopeguard::guard(ctx, |ctx| {
             // SAFETY: ctx is a valid SSL_CTX* with one ref adopted by this fn.
@@ -442,7 +434,8 @@ impl UpgradedDuplex {
                 .reason
                 .as_deref()
                 .map_or(c"".as_ptr(), |c| c.as_ptr()),
-            // TODO(port): us_bun_verify_error_t may have more fields; Zig used implicit defaults.
+            // `struct us_bun_verify_error_t` (libusockets.h) has exactly these
+            // three fields: { int error; const char* code; const char* reason }.
         }
     }
 
@@ -462,7 +455,7 @@ impl UpgradedDuplex {
         }
 
         // reschedule the timer
-        // PORT NOTE: `EventLoopTimer.next` is the lower-tier `ElTimespec` stub;
+        // Note: `EventLoopTimer.next` is the lower-tier `ElTimespec` stub;
         // bridge from `bun_core::Timespec` until the lower tier switches.
         let next =
             bun_core::Timespec::ms_from_now(bun_core::TimespecMockMode::AllowMockedTime, ms as i64);
@@ -629,5 +622,3 @@ pub(crate) extern "C" fn UpgradedDuplex__ssl(this: *const c_void) -> *mut bun_bo
             .unwrap_or(core::ptr::null_mut())
     }
 }
-
-// ported from: src/runtime/socket/UpgradedDuplex.zig
diff --git a/src/runtime/socket/WindowsNamedPipe.rs b/src/runtime/socket/WindowsNamedPipe.rs
index f2d26137295..59aa37d69bf 100644
--- a/src/runtime/socket/WindowsNamedPipe.rs
+++ b/src/runtime/socket/WindowsNamedPipe.rs
@@ -48,7 +48,6 @@ use crate::timer::{ElTimespec, EventLoopTimer, EventLoopTimerState};
 
 bun_output::declare_scope!(WindowsNamedPipe, visible);
 
-// Zig `pub const CertError = UpgradedDuplex.CertError;`
 pub type CertError = crate::socket::upgraded_duplex::CertError;
 
 type WrapperType = SSLWrapper<*mut WindowsNamedPipe>;
@@ -57,7 +56,7 @@ use crate::jsc_hooks::timer_all_mut as timer_all;
 
 pub struct WindowsNamedPipe {
     pub wrapper: Option<WrapperType>,
-    /// Non-owning alias of the heap `uv::Pipe` (Zig: `?*uv.Pipe`). The owning
+    /// Non-owning alias of the heap `uv::Pipe`. The owning
     /// `Box<uv::Pipe>` is leaked in [`from`] and adopted by
     /// `self.writer.source` (`Source::Pipe`) inside [`start`]; this field only
     /// ever observes/null-checks the handle, never frees it.
@@ -65,8 +64,9 @@ pub struct WindowsNamedPipe {
     pub pipe: Option<NonNull<uv::Pipe>>, // any duplex
     #[cfg(not(windows))]
     pub pipe: (),
-    // TODO(port): lifetime — JSC_BORROW; VM outlives this struct. Using &'static for now;
-    // create a timeout version that doesn't need the jsc VM
+    /// The per-thread VM singleton outlives this struct (it is torn down only
+    /// at thread exit, after every named pipe is closed), so `&'static` is the
+    /// honest model here rather than a threaded lifetime.
     pub vm: &'static VirtualMachine,
     /// Typed enum mirror of `vm.event_loop()` for the io-layer FilePoll vtable
     /// (`bun_io::EventLoopHandle` wraps `*const EventLoopHandle`).
@@ -183,8 +183,7 @@ impl WindowsNamedPipe {
     /// adopts it (before adoption it is the leaked `Box` from [`from`]).
     /// Single JS thread; the writer never holds a competing `&mut uv::Pipe`
     /// across a call into this struct, so the borrow is exclusive for its
-    /// duration. FFI-adjacent: this is the libuv-handle raw-pointer deref the
-    /// Zig `this.pipe.?` does implicitly.
+    /// duration. FFI-adjacent: this is a libuv-handle raw-pointer deref.
     #[cfg(windows)]
     #[inline]
     fn pipe_mut(&mut self) -> Option<&mut uv::Pipe> {
@@ -205,10 +204,6 @@ impl WindowsNamedPipe {
     /// `handle_queue` with no `uv_close` ever scheduled (loop never drains).
     /// `close_and_destroy` covers both states via its `loop_.is_null()` branch.
     ///
-    /// PORT NOTE: the Zig spec has the same gap (WindowsNamedPipe.zig
-    /// L334-401); this is a deliberate divergence to plug a pre-existing leak,
-    /// not a transcription mismatch.
-    ///
     /// MUST NOT be called once `start_with_pipe` has adopted the allocation
     /// (would double-free against `writer.source`'s `Box`).
     #[cfg(windows)]
@@ -242,10 +237,10 @@ impl WindowsNamedPipe {
         &mut spare[..suggested_size]
     }
 
-    // PORT NOTE: takes `nread` (not the libuv `buffer` slice) because that
+    // takes `nread` (not the libuv `buffer` slice) because that
     // slice points *into* `self.incoming` — see `StreamReader::on_read` below
-    // for the Stacked-Borrows split. The Zig `is_slice_in_buffer` debug assert
-    // is dropped: libuv guarantees the read buffer is the one returned from
+    // for the Stacked-Borrows split. No "is slice in buffer" debug assert:
+    // libuv guarantees the read buffer is the one returned from
     // `on_read_alloc`, and we no longer hold the original pointer here.
     #[cfg(windows)]
     fn on_read(&mut self, nread: usize) {
@@ -265,8 +260,6 @@ impl WindowsNamedPipe {
         //   (b) call `receive_data` through a raw `*mut WrapperType` so no
         //       outer `&mut self.wrapper` Unique tag is held across the
         //       re-entrant retag (raw-ptr-per-field pattern, see jsc_hooks.rs).
-        // The Zig original aliases freely (`wrapper.receiveData(data)` while
-        // `data` points into `this.incoming`); Rust needs the explicit detach.
         let mut data = core::mem::take(&mut self.incoming);
 
         if let Some(w) = self.wrapper_ptr() {
@@ -308,7 +301,7 @@ impl WindowsNamedPipe {
         } else {
             (self.handlers.on_data)(self.handlers.ctx, data.as_slice());
         }
-        // Zig: `this.incoming.len = 0` — restore the (cleared) allocation so
+        // Restore the (cleared) allocation so
         // the next `on_read_alloc` reuses it instead of growing from empty.
         data.clear();
         self.incoming = data;
@@ -332,7 +325,7 @@ impl WindowsNamedPipe {
                 // unref after sending all data
                 #[cfg(windows)]
                 if let Some(source) = self.writer.source.as_mut() {
-                    // Zig: `source.pipe.unref()` — Rust `Source` is an enum;
+                    // `Source` is an enum;
                     // `unref()` matches the active variant (always `Pipe` here
                     // via `start_with_pipe`).
                     source.unref();
@@ -425,15 +418,13 @@ impl WindowsNamedPipe {
         bun_output::scoped_log!(WindowsNamedPipe, "onClose");
         #[cfg(windows)]
         {
-            // PORT NOTE: `self.pipe` is a non-owning `NonNull` alias of the
+            // `self.pipe` is a non-owning `NonNull` alias of the
             // `Box<uv::Pipe>` owned by `writer.source`. By the time the writer
             // invokes this `on_close` hook it has already `take()`n that Box and
             // scheduled `uv_close` → `Box::from_raw` on it (PipeWriter::close),
             // so the alias is about to dangle. Clear it here so later
             // `pipe_mut()` callers (e.g. `pause_stream` exported to JS) observe
-            // `None` instead of a freed pointer. The Zig spec's `onPipeClose`
-            // (which would null `this.pipe`) is dead code there too — the
-            // writer's `.onClose` slot is wired to `onClose`, not `onPipeClose`.
+            // `None` instead of a freed pointer.
             self.pipe = None;
         }
         if !self.flags.is_closed() {
@@ -441,8 +432,6 @@ impl WindowsNamedPipe {
             // Drop the non-owning alias now: the writer's `close()` has
             // already handed the Box off to libuv's async close callback (or
             // will), so any later `pause_stream()` would deref freed memory.
-            // (Zig leaves `this.pipe` dangling here — its `onPipeClose` is
-            // dead code; we diverge to avoid the latent UAF.)
             #[cfg(windows)]
             {
                 self.pipe = None;
@@ -458,8 +447,7 @@ impl WindowsNamedPipe {
                 // ref because we have pending data
                 #[cfg(windows)]
                 if let Some(source) = self.writer.source.as_mut() {
-                    // Zig: `source.pipe.ref()` — see `on_write` for the
-                    // enum-vs-union note.
+                    // See `on_write` for the active-variant note.
                     source.ref_();
                 }
                 if self.flags.disconnected() {
@@ -603,13 +591,13 @@ impl WindowsNamedPipe {
         handlers: Handlers,
         vm: &'static VirtualMachine,
     ) -> WindowsNamedPipe {
-        // Zig: `if (Environment.isPosix) @compileError(...)` — the whole fn is
-        // now `#[cfg(windows)]`-gated so POSIX builds never see `uv::Pipe`.
+        // The whole fn is `#[cfg(windows)]`-gated so POSIX builds never see
+        // `uv::Pipe`.
         WindowsNamedPipe {
             vm,
             event_loop_handle: bun_jsc::EventLoopHandle::init(vm.event_loop().cast::<()>()),
-            // Leak the `Box` and keep only a non-owning `NonNull` alias (Zig:
-            // `?*uv.Pipe`). Ownership of the allocation is later transferred to
+            // Leak the `Box` and keep only a non-owning `NonNull` alias.
+            // Ownership of the allocation is later transferred to
             // `self.writer.source` via `start_with_pipe` in `start()`, which
             // re-materialises the `Box` and is responsible for freeing it.
             pipe: Some(NonNull::from(Box::leak(pipe))),
@@ -620,9 +608,6 @@ impl WindowsNamedPipe {
             incoming: Vec::new(),
             ssl_error: CertError::default(),
             connect_req: bun_core::ffi::zeroed::<uv::uv_connect_t>(),
-            // Zig: `.{ .next = .epoch, .tag = .WindowsNamedPipe }` with field
-            // defaults `state = .PENDING`, `heap = .{}`, `in_heap = .none` —
-            // exactly what `init_paused` produces.
             event_loop_timer: EventLoopTimer::init_paused(EventLoopTimerTag::WindowsNamedPipe),
             current_timeout: 0,
             flags: Flags::DISCONNECTED, // disconnected: bool = true is the only non-false default
@@ -653,8 +638,8 @@ impl WindowsNamedPipe {
 
     #[cfg(windows)]
     fn on_connect(&mut self, status: uv::ReturnCode) {
-        // PORT NOTE: reshaped — Zig `defer this.deref()` cannot be a scopeguard here (would need
-        // to capture &mut self alongside body uses). Call deref() explicitly at each return.
+        // A deref-on-exit scopeguard would need to capture &mut self alongside
+        // body uses; call deref() explicitly at each return.
 
         #[cfg(windows)]
         if let Some(pipe) = self.pipe_mut() {
@@ -662,14 +647,13 @@ impl WindowsNamedPipe {
         }
 
         if let Some(err) = status.to_error(bun_sys::Tag::connect) {
-            // PORT NOTE: divergence from Zig spec — on async connect failure the
+            // On async connect failure the
             // leaked `Box<uv::Pipe>` was never adopted by `writer.source`
             // (`start_with_pipe` only runs on the success branch below), so
             // `on_error → close → writer.end()` is a no-op for it. Reclaim it
             // here via `discard_unadopted_pipe` (which schedules `uv_close` and
             // `Box::from_raw`s in the callback), mirroring the synchronous
-            // early-error paths in `connect`/`open`/`get_accepted_by`. The Zig
-            // original leaks the init'd `uv_pipe_t` in this path.
+            // early-error paths in `connect`/`open`/`get_accepted_by`.
             self.discard_unadopted_pipe();
             self.on_error(err);
             self.deref();
@@ -872,7 +856,7 @@ impl WindowsNamedPipe {
         }
 
         // BORROW_PARAM: `connect()` takes `&mut self.connect_req`, a `*mut c_void`
-        // context, and `&mut self.pipe` simultaneously (Zig: all `*T` alias freely).
+        // context, and `&mut self.pipe` simultaneously.
         // Derive `ctx` first via `addr_of_mut!` (no intermediate `&mut Self` retag),
         // then project `req`/`pipe` *from `ctx`* so all three share one provenance
         // root — taking `&mut self.connect_req` followed by `self as *mut Self`
@@ -988,7 +972,6 @@ impl WindowsNamedPipe {
         ssl_options: &SSLConfig,
         is_client: bool,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         self.flags.set_is_ssl(true);
         if self.start(is_client) {
             self.wrapper = Some(ssl_wrapper::init(
@@ -1034,7 +1017,6 @@ impl WindowsNamedPipe {
             };
             self.pipe_mut().unwrap().unref();
             // raw self-ptr first to dodge the &mut self.writer / &mut *self overlap
-            // (Zig: `this.writer.setParent(this)` — `this` is already `*WindowsNamedPipe`).
             let this: *mut Self = core::ptr::from_mut(self);
             self.writer.set_parent(this);
             // SAFETY: `start_with_pipe`'s contract is "Box-allocated pointer;
@@ -1296,7 +1278,7 @@ impl WindowsNamedPipe {
         }
 
         // reschedule the timer
-        // PORT NOTE: `EventLoopTimer.next` is the lower-tier `ElTimespec` stub;
+        // `EventLoopTimer.next` is the lower-tier `ElTimespec` stub;
         // bridge from `bun_core::Timespec` until the lower tier switches.
         let next = timespec::ms_from_now(bun_core::TimespecMockMode::AllowMockedTime, ms as i64);
         self.event_loop_timer.next = ElTimespec {
@@ -1313,7 +1295,7 @@ impl WindowsNamedPipe {
     }
 
     /// Free internal resources, it can be called multiple times.
-    // PORT NOTE: Zig `pub fn deinit` → private idempotent helper invoked from on_close and Drop.
+    // Private idempotent helper invoked from on_close and Drop.
     // Owned fields (writer, wrapper, ssl_error) free themselves via their own Drop impls; only
     // the side effects (timer cancel, read_stop, take()) remain explicit here.
     fn release_resources(&mut self) {
@@ -1326,15 +1308,13 @@ impl WindowsNamedPipe {
             // succeeds and is a no-op if not reading.
             unsafe { (*stream).read_stop() };
         }
-        // Zig: `this.writer.deinit()` → `closeWithoutReporting(); outgoing.deinit();
-        // current_payload.deinit();`. The earlier port skipped
-        // `closeWithoutReporting()` on the assumption that "the source is already
+        // "The source is already
         // closed by the time on_close reaches here (that close is what fired the
-        // callback)" — true ONLY for the writer-initiated close path
+        // callback)" is true ONLY for the writer-initiated close path
         // (`WindowsStreamingWriterParent::on_close`). It is FALSE when we arrive
         // via `ssl_on_close` (TLS close_notify): the underlying `uv_pipe_t` is
         // still open and in libuv's handle_queue, so without an explicit close
-        // here the HANDLE outlives Zig's by ≥ one event-loop tick (until the
+        // here the HANDLE survives ≥ one extra event-loop tick (until the
         // embedding context's refcount hits 0 and `WindowsStreamingWriter::Drop`
         // finally runs). Inline `close_without_reporting()` (private on the
         // writer) so the source pipe is `uv_close`d NOW; the `get_fd() != INVALID`
@@ -1423,8 +1403,8 @@ bun_io::impl_streaming_writer_parent! {
     deref      = |this| (&mut *this).deref(),
 }
 
-/// Port of the three `comptime` fn-pointer args to Zig `stream.readStart(this,
-/// onReadAlloc, onReadError, onRead)` — Rust bakes them into a trait so the
+/// The three `stream.readStart` callbacks (alloc/error/read) baked into a
+/// trait so the
 /// `extern "C"` libuv trampoline is monomorphised over `WindowsNamedPipe`.
 #[cfg(windows)]
 impl uv::StreamReader for WindowsNamedPipe {
@@ -1434,10 +1414,8 @@ impl uv::StreamReader for WindowsNamedPipe {
     }
     #[inline]
     fn on_read_error(this: &mut Self, err: core::ffi::c_int) {
-        // Zig: `ReturnCodeI64.init(nreads).errEnum() orelse .CANCELED` — but
-        // `errEnum()` returns `null` ONLY for non-negative values, and the
-        // trampoline only reaches this arm when `nreads < 0`, so the `orelse`
-        // is dead in spec. For any negative code `translateUVErrorToE` already
+        // The trampoline only reaches this arm when `nreads < 0`, and for any
+        // negative code `translate_uv_error_to_e` already
         // yields a concrete `E` (falling back to `UNKNOWN` for unmapped
         // codes). Pass it straight through; do NOT remap UNKNOWN→CANCELED.
         let e = bun_sys::windows::translate_uv_error_to_e(err);
@@ -1457,5 +1435,3 @@ impl uv::StreamReader for WindowsNamedPipe {
         WindowsNamedPipe::on_read(unsafe { &mut *this }, nread);
     }
 }
-
-// ported from: src/runtime/socket/WindowsNamedPipe.zig
diff --git a/src/runtime/socket/WindowsNamedPipeContext.rs b/src/runtime/socket/WindowsNamedPipeContext.rs
index 0a07146c902..547e4b82fbd 100644
--- a/src/runtime/socket/WindowsNamedPipeContext.rs
+++ b/src/runtime/socket/WindowsNamedPipeContext.rs
@@ -26,12 +26,12 @@ pub struct WindowsNamedPipeContext {
     // Intrusive refcount; on zero → `schedule_deinit` (deferred free), not
     // immediate `Box::from_raw`.
     ref_count: Cell<u32>,
-    // PORT NOTE: `socket` deref'd manually in `Drop` before `named_pipe` field-drop
-    // — matches Zig `deinit` order (socket.deref() then named_pipe.deinit()).
+    // `socket` is deref'd manually in `Drop` before the `named_pipe` field
+    // drops — teardown order must stay socket.deref() then named_pipe deinit.
     socket: SocketType,
     /// `pub(super)` so `WindowsNamedPipeListeningContext::on_client_connect`
     /// (sibling module) can call `get_accepted_by` on the freshly-created
-    /// client — Zig had no field visibility.
+    /// client.
     pub(super) named_pipe: WindowsNamedPipe,
 
     // task used to deinit the context in the next tick, vm is used to enqueue the task
@@ -59,7 +59,7 @@ pub enum EventState {
     None,
 }
 
-/// Zig: `union(enum) { tls: *TLSSocket, tcp: *TCPSocket, none }` — raw
+/// Raw
 /// intrusive-refcounted pointers (see `NewSocket::ref_`/`deref`). `Copy` so
 /// matching by value avoids `&self.socket` aliasing `&mut self.named_pipe`.
 #[derive(Copy, Clone)]
@@ -69,8 +69,7 @@ pub enum SocketType {
     None,
 }
 
-/// Zig: `TLSSocket.Socket.fromNamedPipe(&this.named_pipe)` where
-/// `Socket = uws.NewSocketHandler(ssl)`.
+/// Build a `uws::NewSocketHandler` from the wrapped named pipe.
 ///
 /// Takes a raw `*mut WindowsNamedPipe` (NOT `&mut`) because every caller is a
 /// `NamedPipeHandlers` callback invoked *from* `WindowsNamedPipe::on_*`, which
@@ -321,8 +320,7 @@ impl WindowsNamedPipeContext {
         };
         #[cfg(not(windows))]
         {
-            // Zig: `if (Environment.isPosix) @compileError(...)` on `WindowsNamedPipe::from` —
-            // on POSIX `crate::socket::WindowsNamedPipeContext` is aliased to `()` (see mod.rs)
+            // On POSIX `crate::socket::WindowsNamedPipeContext` is aliased to `()` (see mod.rs)
             // so no caller can reach `create()`. This arm exists only so the module
             // type-checks; matches the sibling `WindowsNamedPipe::open`/`connect` POSIX arms.
             let _ = (vm, this, handlers, socket);
@@ -334,9 +332,7 @@ impl WindowsNamedPipeContext {
                 let pipe = Box::new(bun_core::ffi::zeroed::<uv::Pipe>());
                 WindowsNamedPipe::from(pipe, handlers, vm)
             };
-            // Zig: `jsc.AnyTask.New(WindowsNamedPipeContext, runEvent).init(this)` — the
-            // comptime-callback `New<T>` wrapper is not yet expressible on stable Rust,
-            // so build the erased AnyTask directly.
+            // Build the erased AnyTask directly.
             let task = AnyTask {
                 ctx: ptr::NonNull::new(this.cast::<c_void>()),
                 callback: |ctx| {
@@ -363,8 +359,7 @@ impl WindowsNamedPipeContext {
                 );
             }
 
-            // Zig: `switch (socket) { .tls => |tls| tls.ref(), .tcp => |tcp| tcp.ref(), ... }`
-            // — take a +1 intrusive ref so the wrapped JS socket outlives this context.
+            // Take a +1 intrusive ref so the wrapped JS socket outlives this context.
             // SAFETY: caller passes a live socket pointer; `ref_` only bumps the count.
             match_socket!(socket, |s: NewSocket<SSL>| unsafe { (*s).ref_() });
 
@@ -388,7 +383,8 @@ impl WindowsNamedPipeContext {
 
         let this = WindowsNamedPipeContext::create(global_this, socket);
 
-        // PORT NOTE: reshaped for borrowck — errdefer references `socket` which was moved into `this`
+        // The error-path guard reaches `socket` through `this` because it was
+        // moved into `this` by `create()`.
         let mut guard = scopeguard::guard(this, |this| {
             // SAFETY: `this` is live; create() returned it and no deref has fired yet.
             // +1 ref held on the inner socket; live until `Self::deref` below.
@@ -459,7 +455,7 @@ impl WindowsNamedPipeContext {
 impl Drop for WindowsNamedPipeContext {
     fn drop(&mut self) {
         bun_output::scoped_log!(WindowsNamedPipeContext, "deinit");
-        // Zig `deinit`: deref the wrapped socket, then `named_pipe.deinit()`.
+        // Deref the wrapped socket, then let `named_pipe` drop.
         match_socket!(
             core::mem::replace(&mut self.socket, SocketType::None),
             // SAFETY: +1 ref taken in `create()`; this is the matching release.
@@ -468,5 +464,3 @@ impl Drop for WindowsNamedPipeContext {
         // `named_pipe` drops via field destructor after this.
     }
 }
-
-// ported from: src/runtime/socket/WindowsNamedPipeContext.zig
diff --git a/src/runtime/socket/mod.rs b/src/runtime/socket/mod.rs
index 5e1bc0ba6c1..431a6f072d6 100644
--- a/src/runtime/socket/mod.rs
+++ b/src/runtime/socket/mod.rs
@@ -1,8 +1,6 @@
-//! Port of `src/runtime/socket/socket.zig`.
-//!
 //! TCP/TLS socket JS bindings (`Bun.connect` / `Bun.listen` socket wrappers).
 //!
-//! The full method-body port lives in `socket_body.rs`; this module wires the
+//! The full method bodies live in `socket_body.rs`; this module wires the
 //! submodules together and re-exports the canonical type surface so
 //! `crate::api` and the dispatch / handler layers see one set of types.
 
@@ -37,7 +35,6 @@ pub mod windows_named_pipe_context;
 pub mod ssl_wrapper {
     pub use bun_uws::ssl_wrapper::*;
 
-    /// Zig `init(ssl_options: jsc.API.ServerConfig.SSLConfig, ...)`.
     /// Thin wrapper over `SSLWrapper::init_from_options` so callers in this
     /// tier can keep passing `&SSLConfig` directly.
     pub fn init<T: Copy>(
@@ -118,7 +115,7 @@ pub mod socket {
 // ─── RawSocketEvents glue ────────────────────────────────────────────────────
 // `uws_handlers::RawSocketEvents<SSL>` is the raw-pointer dispatch trait the
 // vtable layer requires of `api::NewSocket<SSL>` (routed via `RawPtrHandler`,
-// not `PtrHandler`). PORT NOTE (noalias re-entrancy): the inherent `on_*`
+// not `PtrHandler`). Noalias re-entrancy: the inherent `on_*`
 // methods take `this: *mut Self` precisely so no `&mut NewSocket` is held
 // across `callback.call` (JS can re-derive `&mut Self` via the wrapper's
 // `m_ptr` and mutate `flags`/`handlers`/`ref_count`); a `&mut self` argument
@@ -186,5 +183,3 @@ impl<const SSL: bool> uws_handlers::RawSocketEvents<SSL> for NewSocket<SSL> {
         let _ = unsafe { NewSocket::on_handshake(this, s, ok, err) };
     }
 }
-
-// ported from: src/runtime/socket/socket.zig
diff --git a/src/runtime/socket/socket_body.rs b/src/runtime/socket/socket_body.rs
index 2b19038d2cf..e29bfb98a03 100644
--- a/src/runtime/socket/socket_body.rs
+++ b/src/runtime/socket/socket_body.rs
@@ -1,5 +1,3 @@
-//! Port of `src/runtime/socket/socket.zig`.
-//!
 //! TCP/TLS socket JS bindings (`Bun.connect` / `Bun.listen` socket wrappers).
 
 use core::cell::Cell;
@@ -9,7 +7,7 @@ use core::ptr::{self, NonNull};
 use bun_io::KeepAlive;
 use bun_jsc::JsCell;
 use bun_ptr::IntrusiveRc;
-// PORT NOTE: do NOT `use bun_boringssl_sys::SSL` here — it shadows the
+// do NOT `use bun_boringssl_sys::SSL` here — it shadows the
 // `const SSL: bool` generic param in `NewSocket<SSL>` below, making rustc
 // resolve `<SSL>` as a type arg (E0747). Use the qualified path instead.
 use bun_boringssl_sys::SSL_CTX;
@@ -127,9 +125,7 @@ extern "C" fn select_alpn_callback(
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Generic socket wrapper. `SSL = false` → `TCPSocket`, `SSL = true` → `TLSSocket`.
-///
-/// In Zig this is `fn NewSocket(comptime ssl: bool) type { return struct {...} }`.
-// PORT NOTE: `#[bun_jsc::JsClass]` cannot be applied here — the proc-macro
+// `#[bun_jsc::JsClass]` cannot be applied here — the proc-macro
 // emits monomorphic `impl JsClass for NewSocket` (no generics) and a single
 // set of `${Name}__fromJS`/`__create` externs, but this type maps to TWO
 // codegen classes (`JSTCPSocket` / `JSTLSSocket`). The codegen accessors are
@@ -153,8 +149,6 @@ pub struct NewSocket<const SSL: bool> {
 
     pub flags: Cell<Flags>,
     pub ref_count: bun_ptr::RefCount<Self>, // intrusive — see `bun_ptr::IntrusiveRc<Self>`
-    // Zig: `handlers: ?*Handlers` — a freely-aliased mutable raw pointer.
-    //
     // OWNERSHIP: in **server** mode this points at `&mut listener.handlers`
     // (the embedded `Listener.handlers` field — Listener.rs:34) so
     // `container_of`-style offset arithmetic in `get_listener` and
@@ -190,16 +184,16 @@ pub struct NewSocket<const SSL: bool> {
     /// expects at index 0). The encrypted half holds a ref on the raw half
     /// here so a single `onClose` can retire both — no `Handlers.clone()`,
     /// no second context.
-    // PORT NOTE: LIFETIMES.tsv says `Option<Rc<Self>>`, but `*Self` is stored in
+    // LIFETIMES.tsv says `Option<Rc<Self>>`, but `*Self` is stored in
     // a uws ext slot (FFI) and is intrusively refcounted — PORTING.md mandates
     // IntrusiveRc, never Rc, when *T crosses FFI.
     pub twin: JsCell<Option<IntrusiveRc<Self>>>,
 }
 
-/// Associated `Socket` handler type (Zig: `pub const Socket = uws.NewSocketHandler(ssl)`).
+/// Associated `Socket` handler type.
 pub(super) type SocketHandler<const SSL: bool> = uws::NewSocketHandler<SSL>;
 
-// Intrusive refcount mixin (Zig: `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`).
+// Intrusive refcount mixin.
 impl<const SSL: bool> bun_ptr::RefCounted for NewSocket<SSL> {
     type DestructorCtx = ();
     unsafe fn get_ref_count(this: *mut Self) -> *mut bun_ptr::RefCount<Self> {
@@ -234,7 +228,7 @@ impl<const SSL: bool> NewSocket<SSL> {
 
     // ─────────────────────────────────────────────────────────────────────────
 
-    // Intrusive refcount API (Zig: `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`).
+    // Intrusive refcount API.
     pub fn ref_(&self) {
         // SAFETY: `self` is live; `RefCount::ref_` only reads/writes the
         // embedded `ref_count` Cell (interior-mutable), so `&self`→`*mut`
@@ -253,7 +247,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         unsafe { bun_ptr::RefCount::<Self>::deref(self.as_ctx_ptr()) };
     }
 
-    // ── codegen accessors (Zig: `pub const js = if (!ssl) jsc.Codegen.JSTCPSocket else jsc.Codegen.JSTLSSocket`) ──
+    // ── codegen accessors ──
     // `#[bun_jsc::JsClass]` can't express the per-monomorphisation symbol
     // dispatch, so these hand-roll the `if (ssl) js_TLSSocket else js_TCPSocket`
     // split and route through the codegen'd safe wrappers.
@@ -321,7 +315,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         if !matches!(self.native_callback.get(), NativeCallbacks::None) {
             return false;
         }
-        // Zig `h2.ref()` — IntrusiveRc holds the +1 by construction (caller
+        // IntrusiveRc holds the +1 by construction (caller
         // passes ownership of the handle), so no explicit inc here.
         self.native_callback.set(callback);
         true
@@ -342,11 +336,9 @@ impl<const SSL: bool> NewSocket<SSL> {
 
     /// Connect to `self.connection` (must be `Some`). Reads the field directly
     /// rather than taking it by-ref so the single caller in `connect_finish`
-    /// doesn't need a disjoint borrow (the Zig original satisfied this via an
-    /// aliased pointer read).
+    /// doesn't need a disjoint borrow.
     pub fn do_connect(&self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
-        // Zig: `this.ref(); defer this.deref();` — keep `self` alive across the
+        // Keep `self` alive across the
         // re-entrant connect path. `ScopedRef` stores a raw `*mut Self` (no
         // borrow held across the body) and derefs on Drop.
         // SAFETY: `self` is live until guard drop; all writes go through
@@ -384,7 +376,6 @@ impl<const SSL: bool> NewSocket<SSL> {
         use super::listener::UnixOrHost;
         match self.connection.get() {
             Some(UnixOrHost::Host { host, port }) => {
-                // PERF(port): was stack-fallback alloc — profile if hot.
                 // getaddrinfo doesn't accept bracketed IPv6.
                 let raw: &[u8] = host;
                 let clean = if raw.len() > 1 && raw[0] == b'[' && raw[raw.len() - 1] == b']' {
@@ -424,7 +415,6 @@ impl<const SSL: bool> NewSocket<SSL> {
                 );
             }
             Some(UnixOrHost::Unix(u)) => {
-                // PERF(port): was stack-fallback alloc — profile if hot.
                 let s = group.connect_unix(
                     kind,
                     ssl_ctx,
@@ -442,9 +432,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             Some(UnixOrHost::Fd(f)) => {
                 // `LIBUS_SOCKET_DESCRIPTOR` is `c_int` on POSIX, `SOCKET`
                 // (`usize`) on Windows; `Fd::native()` is `c_int` / HANDLE
-                // (`*mut c_void`) respectively. The Zig spec passes
-                // `f.native()` verbatim (Zig's descriptor type *is*
-                // `*anyopaque`); cast to bridge the Rust-side `usize` alias.
+                // (`*mut c_void`) respectively; cast to bridge the Rust-side `usize` alias.
                 let s = group.from_fd(
                     kind,
                     ssl_ctx,
@@ -469,7 +457,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         Ok(())
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — that macro's free-fn shim
+    // no `#[bun_jsc::host_fn]` here — that macro's free-fn shim
     // emits a bare `constructor(...)` call which doesn't resolve inside an
     // `impl<const SSL: bool>` block. The codegen `JsClass` derive owns the
     // constructor link name, so the placeholder shim isn't needed.
@@ -594,7 +582,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         }
     }
 
-    /// PORT NOTE (noalias re-entrancy): takes `this: *mut Self`, NOT
+    /// Noalias re-entrancy: takes `this: *mut Self`, NOT
     /// `&mut self`. `callback.call(...)` re-enters JS which can call
     /// `socket.write()`/`socket.end()`/`socket.reload()` on this same wrapper
     /// via the JS object's `m_ptr`, re-deriving a `&mut NewSocket` and mutating
@@ -630,7 +618,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             return;
         }
         this.ref_();
-        // PORT NOTE: reshaped for borrowck — explicit deref at end instead of `defer`.
+        // reshaped for borrowck — explicit deref at end instead of a scope guard.
         this.internal_flush();
         log!(
             "onWritable buffered_data_for_node_net {}",
@@ -699,7 +687,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         }
     }
 
-    /// Zig `getHandlers(this) *Handlers` — returns the raw, freely-aliased
+    /// Returns the raw, freely-aliased
     /// pointer. **Do not** materialise a long-lived `&mut Handlers` from this
     /// across any `callback.call(...)` / `resolve_promise` / `reject_promise`
     /// boundary: JS may synchronously reenter `socket.reload()` which
@@ -749,14 +737,13 @@ impl<const SSL: bool> NewSocket<SSL> {
         );
         // Ensure the socket is still alive for any defer's we have
         this.ref_();
-        // PORT NOTE: Zig's first `defer this.deref()` is declared here, before
-        // clear_and_free/unrefOnNextTick — keep it as its own guard so the
+        // Declared before clear_and_free/unrefOnNextTick — its own guard so the
         // ref_() above is balanced even if those calls unwind.
         let _outer_deref = scopeguard::guard(this.as_ctx_ptr(), |p| {
             // SAFETY: `p` is the live `*mut Self`; shared reborrow, fields celled.
             unsafe { (*p).deref() };
         });
-        // PORT NOTE: reshaped for borrowck — explicit cleanup at end of fn.
+        // reshaped for borrowck — explicit cleanup at end of fn.
         this.buffered_data_for_node_net
             .with_mut(|b| b.clear_and_free());
 
@@ -782,7 +769,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             |(p, nd, h)| {
                 // SAFETY: `p` is the live `*mut Self`; shared reborrow, fields celled.
                 unsafe {
-                    // Zig defer order (reverse-declaration): needs_deref → markInactive.
+                    // Order: needs_deref → markInactive.
                     if nd {
                         (*p).deref();
                     }
@@ -856,10 +843,10 @@ impl<const SSL: bool> NewSocket<SSL> {
         // that way if we need to call the error handler, we can
         let captured_handlers = handlers.as_ptr();
         let scope = Handlers::enter_ref(handlers);
-        // PORT NOTE: `let _ = guard` would drop *immediately* (end of
+        // `let _ = guard` would drop *immediately* (end of
         // statement, not end of scope) and run `scope.exit()` before the
         // user's onConnectError callback. Bind to a named `_`-prefixed
-        // local so it lives to end of scope like Zig's `defer`.
+        // local so it lives to end of scope.
         let _scope_guard = scopeguard::guard(
             (this.as_ctx_ptr(), scope, captured_handlers),
             |(p, sc, h)| {
@@ -938,7 +925,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         }
 
         // `_scope_guard` (declared after `cleanup`) drops first → scope.exit();
-        // then `cleanup` → needs_deref/markInactive/deref. Matches Zig defer LIFO.
+        // then `cleanup` → needs_deref/markInactive/deref.
         Ok(())
     }
 
@@ -1072,7 +1059,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         );
         // Ensure the socket remains alive until this is finished
         this.ref_();
-        // PORT NOTE: reshaped for borrowck — explicit deref at end.
+        // reshaped for borrowck — explicit deref at end.
 
         // update the internal socket instance to the one that was just connected
         // This socket must be replaced because the previous one is a connecting socket not a uSockets socket
@@ -1386,7 +1373,7 @@ impl<const SSL: bool> NewSocket<SSL> {
                     Ok(v) => v,
                     Err(e) => {
                         // `Scope` has no Drop — balance event_loop().enter() and
-                        // active_connections before propagating (Zig: `defer if (scope.exit()) ...`).
+                        // active_connections before propagating.
                         if scope.exit() {
                             this.handlers.set(None);
                         }
@@ -1450,7 +1437,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             // letting `IntrusiveRc::drop` release a *second* time.
             unsafe { Self::on_close(raw, socket, err, reason).ok() };
         }
-        // PORT NOTE: reshaped for borrowck — `defer this.deref()` + `defer markInactive()`.
+        // reshaped for borrowck — deref + markInactive run explicitly at the end.
         // Capture the `Handlers` pointer that was paired with the
         // `IS_ACTIVE` flag *before* the user's close callback runs. The
         // callback may synchronously re-enter `Bun.connect({ socket: this })`
@@ -1631,7 +1618,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             return JSValue::UNDEFINED;
         }
 
-        // Zig: `@fieldParentPtr("handlers", handlers)`. Server-mode
+        // Server-mode
         // `this.handlers` is set to `&mut listener.handlers` (the embedded
         // `Listener.handlers` field — Listener.rs:34 / Listener.rs on_create),
         // so subtracting the field offset recovers the parent `Listener*`.
@@ -1792,8 +1779,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             return Ok(JSValue::UNDEFINED);
         };
         // `format_ip` expects `addr:port` / `[addr]:port` shape (it strips
-        // `:port` and brackets), so pass a `SocketAddr` like Zig's
-        // `std.net.Address.initIp{4,6}(.., 0)` — bare `IpAddr` corrupts IPv6.
+        // `:port` and brackets), so pass a `SocketAddr` — bare `IpAddr` corrupts IPv6.
         let address: std::net::SocketAddr = match address_bytes.len() {
             4 => std::net::SocketAddrV4::new(
                 std::net::Ipv4Addr::from(<[u8; 4]>::try_from(address_bytes).unwrap()),
@@ -1946,7 +1932,7 @@ impl<const SSL: bool> NewSocket<SSL> {
 
         let args = callframe.arguments_undef::<2>();
         this.ref_();
-        // PORT NOTE: reshaped for borrowck — explicit deref at end.
+        // reshaped for borrowck — explicit deref at end.
         let result = match this.write_or_end_buffered::<true>(global, args.ptr[0], args.ptr[1]) {
             WriteResult::Fail => JSValue::ZERO,
             WriteResult::Success { wrote, total } => {
@@ -1977,7 +1963,6 @@ impl<const SSL: bool> NewSocket<SSL> {
             return self.write_or_end::<IS_END>(global, &mut values, true);
         }
 
-        // PERF(port): was stack-fallback alloc — profile if hot.
         let allow_string_object = true;
         let buffer: StringOrBuffer = if data_value.is_undefined() {
             StringOrBuffer::EMPTY
@@ -2080,11 +2065,10 @@ impl<const SSL: bool> NewSocket<SSL> {
                         }
 
                         if !remaining_in_input_data.is_empty() {
-                            // Zig parity: result intentionally discarded
+                            // Result intentionally discarded
                             let _ = self
                                 .buffered_data_for_node_net
                                 .with_mut(|b| b.append_slice(remaining_in_input_data));
-                            // PERF(port): was assume_capacity — profile if hot.
                         }
 
                         break 'brk rc;
@@ -2093,7 +2077,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             }
 
             // slower-path: clone the data, do one write.
-            // Zig parity: result intentionally discarded
+            // Result intentionally discarded
             let _ = self
                 .buffered_data_for_node_net
                 .with_mut(|b| b.append_slice(buffer.slice()));
@@ -2163,7 +2147,6 @@ impl<const SSL: bool> NewSocket<SSL> {
             return WriteResult::Fail;
         }
 
-        // PERF(port): was stack-fallback alloc — profile if hot.
         let buffer: BlobOrStringOrBuffer = if args[0].is_undefined() {
             BlobOrStringOrBuffer::StringOrBuffer(StringOrBuffer::EMPTY)
         } else {
@@ -2195,8 +2178,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             return WriteResult::Fail;
         }
 
-        // PORT NOTE: was `comptime if (is_end) "end" else "write"` in Zig; Rust
-        // can't reference an outer `const` generic in a nested `const` item
+        // Rust can't reference an outer `const` generic in a nested `const` item
         // (E0401), so precompute the full label per branch.
         let label: &'static str = if IS_END { "Socket.end" } else { "Socket.write" };
 
@@ -2321,7 +2303,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             if !remaining.is_empty() {
                 let _ = self
                     .buffered_data_for_node_net
-                    .with_mut(|b| b.append_slice(remaining)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    .with_mut(|b| b.append_slice(remaining)); // OOM/capacity: fire-and-forget
             }
         }
 
@@ -2500,7 +2482,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         }
 
         this.ref_();
-        // PORT NOTE: reshaped for borrowck — explicit deref at end.
+        // reshaped for borrowck — explicit deref at end.
 
         let result = match this.write_or_end::<true>(global, args.mut_(), false) {
             WriteResult::Fail => JSValue::ZERO,
@@ -2563,7 +2545,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             }
         }
         this_ref.detach_native_callback();
-        // PORT NOTE: Zig `JSRef.deinit()` → reset to empty (Strong drops on assign).
+        // Reset to empty (Strong drops on assign).
         this_ref.this_value.set(JsRef::empty());
 
         this_ref
@@ -2635,7 +2617,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             .get(global, "socket")?
             .ok_or_else(|| global.throw(format_args!("Expected \"socket\" option")))?;
 
-        // In Zig `this_handlers.* = handlers` overwrites the pointee so the
+        // Overwrite the pointee so the
         // listener + all sockets observe the new callbacks. `this.handlers` is
         // a raw `*mut Handlers` (server: `&mut listener.handlers`; client:
         // `heap::alloc`), so writing through it has valid provenance.
@@ -2663,7 +2645,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         // allocation is live; raw-pointer-only access; see `get_handlers` contract.
         unsafe {
             let active_connections = (*p).active_connections.get();
-            core::ptr::drop_in_place(p); // Zig: this_handlers.deinit()
+            core::ptr::drop_in_place(p);
             core::ptr::write(p, handlers);
             (*p).mode = prev_mode;
             (*p).active_connections.set(active_connections);
@@ -2674,10 +2656,9 @@ impl<const SSL: bool> NewSocket<SSL> {
 
     #[bun_jsc::host_fn(getter)]
     pub fn get_fd(this: &Self, _global: &JSGlobalObject) -> JSValue {
-        // Zig: `return this.socket.fd().toJSWithoutMakingLibUVOwned();`
         // On Windows the fd is a system-kind SOCKET handle; routing it through
         // `.uv()` panics for anything but stdio. The sys_jsc helper branches on
-        // kind exactly like fd_jsc.zig (system→u64, uv→i32, posix→i32).
+        // kind (system→u64, uv→i32, posix→i32).
         use bun_sys_jsc::FdJsc as _;
         this.socket.get().fd().to_js_without_making_lib_uv_owned()
     }
@@ -2712,9 +2693,6 @@ impl<const SSL: bool> NewSocket<SSL> {
         // adopt; the old `isDetached()/isNamedPipe()` guard let those
         // through and the `.connected` payload read below would then be
         // illegal-union-access on a `.connecting` socket.
-        // PORT NOTE: Zig `InternalSocket.get()` returns `?*us_socket_t` (Some
-        // only for `.connected`); inline the match here since the Rust
-        // `bun_uws::InternalSocket` lacks `get()`.
         let uws::InternalSocket::Connected(raw_socket) = this.socket.get().socket else {
             return Err(global.throw_invalid_arguments(format_args!(
                 "upgradeTLS requires an established socket"
@@ -2745,11 +2723,10 @@ impl<const SSL: bool> NewSocket<SSL> {
         }
         // 9 .protect()'d JS callbacks live in `handlers`; every error/throw
         // from here until they're moved into `tls.handlers` would leak them.
-        // The flag flips once ownership transfers so the errdefer is a no-op
+        // The flag flips once ownership transfers so the guard is a no-op
         // on success.
         let mut handlers_guard = scopeguard::guard(Some(handlers), |h| {
-            // PORT NOTE: Zig `handlers.deinit()` → `Drop for Handlers`
-            // (unprotect + Strong drop). Explicit drop for clarity.
+            // `Drop for Handlers` (unprotect + Strong drop). Explicit drop for clarity.
             drop(h);
         });
 
@@ -2759,8 +2736,7 @@ impl<const SSL: bool> NewSocket<SSL> {
         // `tls:` options. Either way `owned_ctx` holds one ref we drop in
         // deinit; SSL_new() takes its own.
         //
-        // Zig: `errdefer if (owned_ctx) |c| SSL_CTX_free(c)` — by-name
-        // capture. The local lives INSIDE the guard so all reads/writes go
+        // The local lives INSIDE the guard so all reads/writes go
         // through `*owned_ctx` (DerefMut); capturing `&mut owned_ctx as *mut _`
         // and then writing the local by name would pop the guard's pointer
         // tag under Stacked Borrows and make the closure deref UB on a
@@ -2829,7 +2805,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             // Per-VM weak cache: `tls:true` and `{servername}`-only hit
             // the same CTX as `Bun.connect`; an inline CA dedupes across
             // every upgradeTLS that names it.
-            // PORT NOTE: `bun_jsc::rare_data::RareData::ssl_ctx_cache()` returns
+            // `bun_jsc::rare_data::RareData::ssl_ctx_cache()` returns
             // the high-tier opaque ZST stub (cycle-break); the concrete
             // `SSLContextCache` lives on this thread's `RuntimeState`.
             let cache = {
@@ -2872,13 +2848,13 @@ impl<const SSL: bool> NewSocket<SSL> {
         let handlers_taken = handlers_guard.take().unwrap();
         scopeguard::ScopeGuard::into_inner(handlers_guard);
         let vm = handlers_taken.vm;
-        // Zig: `bun.default_allocator.create(Handlers)` — client-mode
+        // Client-mode
         // `Handlers` is a standalone heap allocation that
         // `Handlers::mark_inactive` later frees via `heap::take`.
         let handlers_ptr = bun_core::heap::into_raw_nn(Box::new(handlers_taken));
 
         // Ownership of the +1 `SSL_CTX` ref transfers into `tls.owned_ssl_ctx`
-        // below; defuse the errdefer so a later `?` doesn't double-free.
+        // below; defuse the guard so a later `?` doesn't double-free.
         let owned_ctx_taken = scopeguard::ScopeGuard::into_inner(owned_ctx);
 
         let cfg = ssl_opts.as_ref();
@@ -2938,14 +2914,12 @@ impl<const SSL: bool> NewSocket<SSL> {
                 }
                 // tls.deinit drops the owned_ctx ref. Null the handlers field
                 // first so `TLSSocket::deinit` doesn't double-destroy the
-                // `Handlers` we're about to free explicitly (Zig sequences
-                // `tls.deref()` then `handlers_ptr.deinit(); destroy(handlers_ptr)`).
+                // `Handlers` we're about to free explicitly.
                 // SAFETY: sole owner of the fresh allocation.
                 unsafe {
                     (*tls_ptr).handlers.set(None);
                     (*tls_ptr).deref();
                 }
-                // Zig: `handlers_ptr.deinit(); allocator.destroy(handlers_ptr)`.
                 // `Handlers` has a `Drop` impl that runs `deinit` (unprotect).
                 // SAFETY: `handlers_ptr` is the `heap::alloc` allocation
                 // created above; sole owner here.
@@ -2984,7 +2958,7 @@ impl<const SSL: bool> NewSocket<SSL> {
             // active_connections=1 it holds is transferring to `raw`.
             this.this_value.with_mut(|r| r.downgrade());
         }
-        // Zig `defer this.deref()` — must run on EVERY exit past this point,
+        // Must run on EVERY exit past this point,
         // including the `?` early-returns from `create_empty_array`/`put_index`
         // below, or we leak one ref on the retired TCP wrapper.
         let _this_deref = scopeguard::guard(this.as_ctx_ptr(), |p| {
@@ -3090,12 +3064,11 @@ impl<const SSL: bool> NewSocket<SSL> {
     }
 
     // ──────────────────────────────────────────────────────────────────────
-    // TLS-only accessor methods. In Zig these are `pub const X = if (ssl) ...
-    // else fallback`. Rust cannot const-select inherent methods on a const
+    // TLS-only accessor methods. Rust cannot const-select inherent methods on a const
     // generic bool, so these are all forwarding methods that branch on `SSL`
     // at runtime (monomorphised away).
     //
-    // PORT NOTE: rustc does not unify `NewSocket<SSL>` with `NewSocket<true>`
+    // rustc does not unify `NewSocket<SSL>` with `NewSocket<true>`
     // inside an `if SSL { .. }` block. The cast is sound because both
     // monomorphisations have identical layout and the branch only runs when
     // `SSL == true` (so `Self` *is* `TLSSocket`).
@@ -3430,7 +3403,7 @@ bitflags::bitflags! {
 
 impl Default for Flags {
     fn default() -> Self {
-        // Zig default: `owned_protos: bool = true`, all others false.
+        // Default: `owned_protos` true, all others false.
         Flags::OWNED_PROTOS
     }
 }
@@ -3482,7 +3455,6 @@ pub(super) struct DuplexUpgradeContext {
     /// on success, freed in `deinit` if Close races ahead of StartTLS.
     pub owned_ctx: Option<*mut SSL_CTX>,
     pub is_open: bool,
-    // Zig private field `#mode`.
     mode: SocketMode,
 }
 
@@ -3597,7 +3569,7 @@ impl DuplexUpgradeContext {
         let socket = self.duplex_socket();
 
         if let Some(tls) = self.tls.take() {
-            // `tls.onClose` consumes the +1 we hold (its `defer this.deref()`
+            // `tls.onClose` consumes the +1 we hold (its scope-exit deref
             // is the ext-slot/owner pin). Null our pointer first so the
             // `deinitInNextTick` → `deinit` path doesn't deref it a second
             // time — that's the over-deref behind the cross-file
@@ -3733,7 +3705,7 @@ impl DuplexUpgradeContext {
             // `heap::take` free below — no protector spans the dealloc.
             let this_ref = unsafe { &mut *this };
             if let Some(tls) = this_ref.tls.take() {
-                // Zig `tls.deref()` — release the owner's +1.
+                // Release the owner's +1.
                 tls.deref();
             }
             // Close raced ahead of StartTLS — drop the unconsumed config.
@@ -3743,7 +3715,7 @@ impl DuplexUpgradeContext {
                 unsafe { boringssl_sys::SSL_CTX_free(ctx) };
             }
         }
-        // PORT NOTE: Zig `self.upgrade.deinit()` — `UpgradedDuplex` cleanup
+        // `UpgradedDuplex` cleanup
         // runs via `Drop` when `heap::take(this)` frees the containing
         // struct below; an explicit call here would double-free.
         // SAFETY: heap-allocated in `js_upgrade_duplex_to_tls`; this is the
@@ -3791,7 +3763,6 @@ pub fn js_upgrade_duplex_to_tls(
     // controls lifecycle (markInactive expects a Listener parent when .server).
     // The TLS direction (client vs server) is controlled by DuplexUpgradeContext.mode.
     let handlers = Handlers::from_js(global, socket_obj, false)?;
-    // PORT NOTE: Zig `handlers.deinit()` → `Drop for Handlers`.
     let mut handlers_guard = scopeguard::guard(Some(handlers), |h| {
         drop(h);
     });
@@ -3801,7 +3772,6 @@ pub fn js_upgrade_duplex_to_tls(
     // duplex/named-pipe path shares one `SSL_CTX_new` with everyone else.
     // node:net wraps `[buntls]`'s return as `opts.tls.secureContext`; userland
     // may also pass it top-level. Same lookup as `upgradeTLS` above.
-    // Zig: `errdefer if (owned_ctx) |c| SSL_CTX_free(c)` — by-name capture.
     // The local lives INSIDE the guard so all reads/writes go through
     // `*owned_ctx` (DerefMut); capturing `&mut owned_ctx as *mut _` and then
     // writing the local by name would invalidate the guard's pointer tag
@@ -3868,7 +3838,7 @@ pub fn js_upgrade_duplex_to_tls(
     } else {
         crate::socket::SocketMode::Client
     };
-    // Zig: `bun.default_allocator.create(Handlers)` — client-mode `Handlers`
+    // Client-mode `Handlers`
     // is a standalone heap allocation that `Handlers::mark_inactive` later
     // frees via `heap::take`.
     let handlers_ptr = bun_core::heap::into_raw_nn(Box::new(handlers_taken));
@@ -3899,7 +3869,7 @@ pub fn js_upgrade_duplex_to_tls(
     TLSSocket::data_set_cached(tls_js_value, global, default_data);
 
     // Ownership of the +1 `SSL_CTX` ref transfers into
-    // `DuplexUpgradeContext.owned_ctx` below; defuse the errdefer.
+    // `DuplexUpgradeContext.owned_ctx` below; defuse the guard.
     let owned_ctx_taken = scopeguard::ScopeGuard::into_inner(owned_ctx);
 
     // `DuplexUpgradeContext` is self-referential: `task.ctx` and
@@ -3909,7 +3879,7 @@ pub fn js_upgrade_duplex_to_tls(
     // (`=` would Drop the placeholder; `zeroed()` is an invalid value).
     // Allocate uninit, leak to a raw pointer for the stable address, then
     // field-write everything in place — `upgrade` last, once the address is
-    // known. Mirrors Zig `bun.new(...)` then `.upgrade = .from(...)`.
+    // known.
     let duplex_context: *mut DuplexUpgradeContext = bun_core::heap::into_raw(Box::new(
         core::mem::MaybeUninit::<DuplexUpgradeContext>::uninit(),
     ))
@@ -3919,9 +3889,8 @@ pub fn js_upgrade_duplex_to_tls(
     unsafe {
         ptr::addr_of_mut!((*duplex_context).tls).write(Some(IntrusiveRc::from_raw(tls)));
         ptr::addr_of_mut!((*duplex_context).vm).write(VirtualMachine::get());
-        // Zig: `jsc.AnyTask.New(DuplexUpgradeContext, runEvent).init(ctx)`.
-        // Rust's `AnyTask::New` can't take a comptime callback (see AnyTask.rs
-        // PORT NOTE), so hand-write the `*mut c_void → run_event` shim.
+        // `AnyTask::New` can't take the callback as a type parameter (see the
+        // notes in AnyTask.rs), so hand-write the `*mut c_void → run_event` shim.
         ptr::addr_of_mut!((*duplex_context).task).write(AnyTask {
             ctx: NonNull::new(duplex_context.cast::<c_void>()),
             callback: |p| {
@@ -3997,7 +3966,7 @@ pub fn js_upgrade_duplex_to_tls(
     if dc.ssl_config.is_none() {
         drop(ssl_opts.take());
     }
-    // Disarm the errdefer — either moved into duplexContext or just
+    // Disarm the guard — either moved into duplexContext or just
     // freed above; both the move-target and the deinit case must not see it
     // freed again on a later throw.
     let _ = ssl_opts;
@@ -4113,8 +4082,7 @@ pub fn js_set_socket_options(global: &JSGlobalObject, callframe: &CallFrame) ->
 
     #[cfg(unix)]
     {
-        // TODO(port): Zig used `bun.sys.setsockopt`; not yet surfaced in
-        // `bun_sys`, so call libc directly with the same `Maybe` shape.
+        // `bun_sys` exposes no public wrapper, so call libc directly.
         let setsockopt = |level: libc::c_int, opt: libc::c_int| -> Option<sys::Error> {
             let val: libc::c_int = buffer_size;
             // SAFETY: libc FFI; `val` lives for the call.
@@ -4158,5 +4126,3 @@ pub fn js_set_socket_options(global: &JSGlobalObject, callframe: &CallFrame) ->
 
     Ok(JSValue::UNDEFINED)
 }
-
-// ported from: src/runtime/socket/socket.zig
diff --git a/src/runtime/socket/tls_socket_functions.rs b/src/runtime/socket/tls_socket_functions.rs
index 74ed013f7d7..72065cffb71 100644
--- a/src/runtime/socket/tls_socket_functions.rs
+++ b/src/runtime/socket/tls_socket_functions.rs
@@ -146,8 +146,8 @@ pub(super) mod ffi {
         // ── EVP / EC ──────────────────────────────────────────────────────
         pub(crate) safe fn EVP_PKEY_id(pkey: &EVP_PKEY) -> c_int;
         pub(crate) safe fn EVP_PKEY_bits(pkey: &EVP_PKEY) -> c_int;
-        // Returns a +1 `EC_KEY*` (caller owns; the sole call site mirrors the
-        // Zig spec and intentionally leaks it). The only pointer arg is an
+        // Returns a +1 `EC_KEY*` (caller owns; the sole call site
+        // intentionally leaks it). The only pointer arg is an
         // opaque-ZST `&EVP_PKEY`, so the call itself has no precondition.
         pub(crate) safe fn EVP_PKEY_get1_EC_KEY(pkey: &EVP_PKEY) -> *mut EC_KEY;
         // Result is borrowed from `key`; opaque-ZST ref ⇒ no caller precondition.
@@ -211,10 +211,9 @@ pub(super) mod ffi {
 }
 use crate::node::StringOrBuffer;
 
-// In Zig this file is a mixin of free functions over `jsc.API.TLSSocket`.
 // The `#[bun_jsc::host_fn]` shims live on `NewSocket<SSL>` in `socket_body.rs`
 // and forward into these free helpers — keep them as plain `fn`s.
-// PORT NOTE: this file is `mod`-included from BOTH `socket/mod.rs` and
+// this file is `mod`-included from BOTH `socket/mod.rs` and
 // `socket/socket_body.rs`; `super::TLSSocket` resolves to the parent's
 // `NewSocket<true>` in either compilation, whereas the absolute path
 // `crate::api::TLSSocket` always picked the `mod.rs` shape and broke the
@@ -267,7 +266,7 @@ pub(super) fn set_servername(
         .get_zig_string(global)?
         .to_owned_slice()
         .into_boxed_slice();
-    // Drop replaces the old value (Zig manually freed `old`).
+    // Drop replaces the old value.
     this.server_name.set(Some(slice));
 
     let host = this.server_name.get().as_deref().unwrap();
@@ -732,7 +731,6 @@ pub(super) fn export_keying_material(
     if args.len > 2 {
         let context_arg = args.ptr[2];
 
-        // PERF(port): was arena bulk-free.
         if let Some(sb) = StringOrBuffer::from_js(global, context_arg)? {
             let context_slice = sb.slice();
 
@@ -941,7 +939,6 @@ pub(super) fn set_session(
     }
 
     let session_arg = args.ptr[0];
-    // PERF(port): was arena bulk-free.
 
     if let Some(sb) = StringOrBuffer::from_js(global, session_arg)? {
         let session_slice = sb.slice();
@@ -1110,6 +1107,13 @@ extern "C" fn always_allow_ssl_verify_callback(
 #[inline(never)]
 fn get_ssl_exception(global: &JSGlobalObject, default_message: &[u8]) -> JSValue {
     let mut zig_str = ZigString::init(b"");
+    // Backing storage for the formatted "OpenSSL ..." message. Declared at
+    // function scope so it outlives `to_error_instance` below. The string is
+    // tagged UTF-8 (`init_utf8`) so that `to_error_instance` takes the copying
+    // path (`fromUTF8ReplacingInvalidSequences`); an UNTAGGED ZigString would
+    // be wrapped with `StringImpl::createWithoutCopying` and the JS Error's
+    // message would dangle into this freed Vec.
+    let mut formatted: Vec<u8> = Vec::new();
     let mut output_buf: [u8; 4096] = [0; 4096];
 
     output_buf[0] = 0;
@@ -1162,24 +1166,17 @@ fn get_ssl_exception(global: &JSGlobalObject, default_message: &[u8]) -> JSValue
 
     if written > 0 {
         let message = &output_buf[0..written];
-        let mut formatted: Vec<u8> = Vec::with_capacity(b"OpenSSL ".len() + message.len());
+        formatted.reserve(b"OpenSSL ".len() + message.len());
         {
             use std::io::Write;
             let _ = write!(&mut formatted, "OpenSSL {}", ::bstr::BStr::new(message));
         }
-        // TODO(port): Zig leaks `formatted` into a global-marked ZigString; ownership semantics unclear.
-        // `Interned::leak_vec` makes the process-lifetime leak explicit (the
-        // bytes are never reclaimed). NOTE: `mark_global()` below tells JSC the
-        // bytes are mimalloc-owned and may be freed via `mi_free`, but
-        // `leak_vec` allocates with Rust's global allocator — allocator
-        // mismatch if JSC ever adopts the buffer. `to_error_instance` clones
-        // the string, so today the leaked bytes are simply never freed; the
-        // `mark_global` is dead weight matching Zig 1:1 (see TODO below).
-        zig_str = ZigString::init(bun_ptr::Interned::leak_vec(formatted).as_bytes());
-        let mut encoded_str = zig_str.with_encoding();
-        encoded_str.mark_global();
-        // TODO(port): Zig discards encoded_str and continues using zig_str — possible upstream bug; matching Zig 1:1.
-        let _ = encoded_str;
+        // `zig_str` borrows `formatted`, which lives until this function
+        // returns. The UTF-8 tag is what makes `to_error_instance` clone the
+        // bytes (untagged strings are wrapped without copying — see
+        // Zig::toString in src/jsc/bindings/helpers.h), matching the
+        // "Ensure we clone it" pattern in JSGlobalObject::create_error_instance.
+        zig_str = ZigString::init_utf8(&formatted);
 
         // We shouldn't *need* to do this but it's not entirely clear.
         boringssl::ERR_clear_error();
@@ -1190,7 +1187,9 @@ fn get_ssl_exception(global: &JSGlobalObject, default_message: &[u8]) -> JSValue
     }
 
     // store the exception in here
-    // toErrorInstance clones the string
+    // (UTF-8-tagged strings are cloned by toErrorInstance; the untagged
+    // `default_message` fallback is wrapped without copying, which is safe
+    // because callers pass static literals)
     let exception = zig_str.to_error_instance(global);
 
     // reference it in stack memory
@@ -1198,5 +1197,3 @@ fn get_ssl_exception(global: &JSGlobalObject, default_message: &[u8]) -> JSValue
 
     exception
 }
-
-// ported from: src/runtime/socket/tls_socket_functions.zig
diff --git a/src/runtime/socket/udp_socket.rs b/src/runtime/socket/udp_socket.rs
index c8cf1f33b15..760d4fdaeb0 100644
--- a/src/runtime/socket/udp_socket.rs
+++ b/src/runtime/socket/udp_socket.rs
@@ -28,7 +28,7 @@ use crate::socket::socket_address::inet::{self, INET6_ADDRSTRLEN, sockaddr_in, s
 
 bun_output::declare_scope!(UdpSocket, visible);
 
-/// Local shim for Zig `bun.sys.Maybe(void).errnoSys(rc, tag)` — `bun_sys::Result`
+/// Local errno-classification shim — `bun_sys::Result`
 /// is a plain `core::result::Result` alias in Rust and has no associated
 /// `errno_sys` constructor.
 ///
@@ -37,7 +37,7 @@ bun_output::declare_scope!(UdpSocket, visible);
 /// negative EAI codes from `connect` — is "not a libc errno", so callers
 /// handle it themselves).
 ///
-/// Windows semantics (src/runtime/node.zig:227-233): for any non-NTSTATUS
+/// Windows semantics: for any non-NTSTATUS
 /// integer `rc`, `if (rc != 0) return null` — i.e. *every* non-zero rc
 /// (including `-1` / `SOCKET_ERROR`) falls through to the caller's own EAI /
 /// WSA handling rather than synthesising an errno. This matters for the
@@ -51,9 +51,8 @@ fn errno_sys(rc: c_int, tag: bun_sys::Tag) -> Option<bun_sys::Error> {
         if rc != 0 {
             return None;
         }
-        // rc == 0 → fall through to `sys.getErrno(rc)` in Zig, which on
-        // Windows reads CRT `_errno()`. Zig then matches `.SUCCESS => null`,
-        // so a zero errno must still yield `None`.
+        // rc == 0 → read the CRT `_errno()`;
+        // a zero errno must still yield `None`.
         let errno_val = bun_sys::last_errno();
         if errno_val == 0 {
             return None;
@@ -343,7 +342,7 @@ impl UDPSocketConfig {
             ..Default::default()
         };
 
-        // errdefer config.deinit() — Drop on `config` handles this on `?` paths.
+        // `config` cleanup: Drop handles this on `?` paths.
 
         if let Some(socket) = options.get_truthy(global_this, "socket")? {
             if !socket.is_object() {
@@ -368,9 +367,6 @@ impl UDPSocketConfig {
                 };
             }
 
-            // PORT NOTE: `inline for (handlers)` over [("data","on_data"),("drain","on_drain"),
-            // ("error","on_error")] with `@field(UDPSocket.js.gc, handler.1)` — unrolled because
-            // Rust cannot index struct fields by runtime/const string.
             macro_rules! handler {
                 ($name:literal, $set:path) => {
                     if let Some(value) = socket.get_truthy(global_this, $name)? {
@@ -439,10 +435,10 @@ struct ConnectInfo {
     port: u16,
 }
 
-/// `jsc.Codegen.JSUDPSocket` — `.classes.ts` cached accessors.
+/// `.classes.ts` codegen cached accessors.
 ///
-/// `values: ["on_data", "on_drain", "on_error"]` (GC-tracked WriteBarrier slots
-/// — Zig: `js.gc.on_*.{get,set}`) plus the `cache: true` getters
+/// `values: ["on_data", "on_drain", "on_error"]` (GC-tracked WriteBarrier slots)
+/// plus the `cache: true` getters
 /// `address` / `remoteAddress` (cleared on connect to invalidate the JS-side
 /// memo). All resolve to the C++ `UDPSocketPrototype__${prop}{Get,Set}CachedValue`
 /// shims via [`bun_jsc::codegen_cached_accessors!`].
@@ -467,7 +463,7 @@ pub struct UDPSocket {
     pub loop_: *mut uws::Loop,
 
     // Read-only back-reference to the owning JS global; the VM/global strictly
-    // outlives every socket it creates (see Zig spec: `globalThis: *JSGlobalObject`).
+    // outlives every socket it creates.
     pub global_this: BackRef<JSGlobalObject>,
     pub this_value: JsCell<JsRef>,
 
@@ -520,7 +516,7 @@ impl UDPSocket {
         // borrow — every mutated field is `Cell`/`JsCell`.
         let this = unsafe { &*this_ptr };
 
-        // errdefer { closed = true; close socket; downgrade this_value }
+        // Error-path guard: { closed = true; close socket; downgrade this_value }
         // Release the strong reference so the JS wrapper can be garbage
         // collected, which will in turn call finalize() to free this struct.
         // Without this, failed config parsing or bind would leave the wrapper
@@ -547,7 +543,7 @@ impl UDPSocket {
             }
         });
 
-        // PORT NOTE: `JsClass::to_js(self)` boxes by value, but we already own
+        // `JsClass::to_js(self)` boxes by value, but we already own
         // the heap allocation in `this_ptr` and need to keep that exact pointer
         // (it is stashed as the uws user_data). Route through the
         // `#[bun_jsc::JsClass]`-generated `to_js_ptr` inherent method, which
@@ -643,7 +639,7 @@ impl UDPSocket {
                 .set(Some(ConnectInfo { port: connect.port }));
         }
 
-        // Disarm errdefer.
+        // Disarm the error-path guard.
         scopeguard::ScopeGuard::into_inner(guard);
 
         this.poll_ref.with_mut(|p| p.ref_(bun_io::js_vm_ctx()));
@@ -752,9 +748,7 @@ impl UDPSocket {
         }
 
         let enabled = arguments[0].to_boolean();
-        // Spec: udp_socket.zig:424 uses bare `.?`, but the same file's
-        // `setAnyTTL` (zig:593) / `setMembership` (zig:450) guard with
-        // `orelse throw` — on Windows the Rust port can observe
+        // On Windows we can observe
         // `closed=false && socket=None` here (panic seen in
         // test-dgram-multicast-loopback.js). Throw EBADF to match the
         // `closed` branch above instead of panicking.
@@ -1014,11 +1008,10 @@ impl UDPSocket {
             )));
         }
 
-        // Zig spec uses `var addr: sockaddr.storage = undefined;`. `parse_addr`
-        // only writes the leading sockaddr_in/in6 prefix (≤28 bytes), so the
-        // remaining 100+ bytes stay uninitialized. Zig permits that (only
-        // written fields are read), but in Rust producing a `sockaddr_storage`
-        // value via `assume_init()` from a partially-initialized `MaybeUninit`
+        // `parse_addr` only writes the leading sockaddr_in/in6 prefix (≤28
+        // bytes), leaving the remaining 100+ bytes uninitialized; producing a
+        // `sockaddr_storage` value via `assume_init()` from a
+        // partially-initialized `MaybeUninit`
         // is UB. Zero-initialize instead — matches `set_membership` and is
         // semantically equivalent (the C side reads only `ss_family` + the
         // address-family-specific fields `parse_addr` populated).
@@ -1081,7 +1074,6 @@ impl UDPSocket {
         callframe: &CallFrame,
         function: fn(&mut uws::udp::Socket, i32) -> c_int,
     ) -> JsResult<JSValue> {
-        // PERF(port): was comptime monomorphization — profile if hot.
         if this.closed.get() {
             return Err(global_this.throw_value(
                 bun_sys::Error::from_code_int(
@@ -1202,7 +1194,6 @@ impl UDPSocket {
 
         let len = if connected { array_len } else { array_len / 3 };
 
-        // PERF(port): was arena bulk-free — profile if hot.
         let mut payload_vals: Vec<JSValue> = Vec::with_capacity(len);
         payload_vals.resize(len, JSValue::ZERO);
         let mut payloads: Vec<*const u8> = vec![core::ptr::null(); len];
@@ -1289,8 +1280,8 @@ impl UDPSocket {
         // pointers stay valid. An ArrayBuffer detached during phase 1 now
         // reports a zero-length slice rather than a dangling pointer.
         let empty: &'static [u8] = b"";
-        // Zig kept `ZigString.Slice` lifetimes in the arena; here we collect
-        // them into a Vec so the borrowed bytes live until `socket.send()`.
+        // Collect the slices into a Vec so the borrowed bytes live until
+        // `socket.send()`.
         let mut string_slices: Vec<ZigStringSlice> = Vec::with_capacity(len);
         for (slice_idx, val) in payload_vals.iter().enumerate() {
             // Hoisted so the returned `slice()` borrow lives past the `'brk` block
@@ -1300,7 +1291,7 @@ impl UDPSocket {
             let slice: &[u8] = 'brk: {
                 if let Some(ref array_buffer) = array_buffer {
                     // `byteSlice()` returns `&.{}` for a detached view; its
-                    // `.ptr` is Zig's zero-length sentinel which the kernel
+                    // `.ptr` is a zero-length sentinel which the kernel
                     // rejects with EFAULT even though `iov_len == 0`. Hand
                     // sendmmsg a valid static address instead.
                     if array_buffer.is_detached() {
@@ -1477,8 +1468,7 @@ impl UDPSocket {
                         #[cfg(windows)]
                         {
                             // Windows: zone identifier is a numeric scope id, not an
-                            // interface name (`fe80::1%5`). Mirrors Zig
-                            // `str.substring(percent+1).toInt32()` + `std.math.cast(u32, ..)`.
+                            // interface name (`fe80::1%5`).
                             // toInt32 → BunString__toInt32 → WTF::parseIntegerAllowingTrailingJunk<int32_t>:
                             // skip leading ASCII whitespace, optional '-' (no '+'), parse leading
                             // decimal digits, ignore trailing junk; nullopt on no-digits/overflow.
@@ -1589,7 +1579,7 @@ impl UDPSocket {
             // `s->on_close(s)`), which re-derives `&UDPSocket` from the uws
             // user pointer. R-2: with `&self` + `Cell`/`JsCell` the sibling
             // shared borrow is sound; the (idempotent) downgrade is hoisted
-            // because `on_close` repeats it. Spec: udp_socket.zig:915-920.
+            // because `on_close` repeats it.
             this.this_value.with_mut(|r| r.downgrade());
             // `Socket` is an `opaque_ffi!` ZST — `opaque_mut` is the safe deref.
             uws::udp::Socket::opaque_mut(socket).close();
@@ -1735,7 +1725,7 @@ impl UDPSocket {
         drop(unsafe { bun_core::heap::take(this) });
     }
 
-    // PORT NOTE: no `#[bun_jsc::host_fn]` — the macro's free-fn shim emits a
+    // No `#[bun_jsc::host_fn]` — the macro's free-fn shim emits a
     // bare `js_connect(..)` call which doesn't resolve inside an `impl` block.
     // The codegen `JsClass` derive owns the link name, so the shim isn't needed.
     pub fn js_connect(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
@@ -1793,7 +1783,7 @@ impl UDPSocket {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: see `js_connect` — codegen `JsClass` derive owns the link name.
+    // See `js_connect` — codegen `JsClass` derive owns the link name.
     pub fn js_disconnect(
         global_object: &JSGlobalObject,
         call_frame: &CallFrame,
@@ -1839,8 +1829,7 @@ fn get_us_error<const USE_WSA: bool>(res: c_int, tag: bun_sys::Tag) -> Option<bu
         }
 
         if USE_WSA {
-            // Zig: `bun.windows.WSAGetLastError()` returns `?SystemErrno`; the
-            // Rust wrapper (src/sys/windows/mod.rs) already maps `SystemErrno`
+            // The wrapper (src/sys/windows/mod.rs) already maps `SystemErrno`
             // → `E` for us, so `e` is `bun_sys::E` here.
             if let Some(e) = bun_sys::windows::WSAGetLastError() {
                 if e != bun_sys::E::SUCCESS {
@@ -1862,5 +1851,3 @@ fn get_us_error<const USE_WSA: bool>(res: c_int, tag: bun_sys::Tag) -> Option<bu
         errno_sys(res, tag)
     }
 }
-
-// ported from: src/runtime/socket/udp_socket.zig
diff --git a/src/runtime/socket/uws_dispatch.rs b/src/runtime/socket/uws_dispatch.rs
index b0a026fa044..34da2883bba 100644
--- a/src/runtime/socket/uws_dispatch.rs
+++ b/src/runtime/socket/uws_dispatch.rs
@@ -19,24 +19,19 @@ use bun_uws_sys::{ConnectingSocket, SocketKind, us_bun_verify_error_t, us_socket
 
 use super::uws_handlers as handlers;
 
-// (Zig had a `comptime { _ = us_dispatch_*; }` force-reference block here to
-// keep the exports in the link even if nothing in Zig calls them. Rust links
-// every `#[no_mangle] pub extern "C"` symbol unconditionally, so it is dropped.)
-
-/// kind → vtable. Rust kinds get a comptime-generated `Trampolines<H>` vtable
+/// kind → vtable. Rust kinds get a monomorphized `Trampolines<H>` vtable
 /// (so the call is *still* indirect by one pointer, but the table itself is
 /// `.rodata` and there's exactly one per kind — not one per connection). C++
 /// kinds use the per-group vtable since the handler closure differs per App.
 ///
 /// `Invalid` is intentionally null so a missed `kind` stamp crashes here
 /// instead of dispatching into the wrong handler.
-// PERF(port): Zig built this at comptime into .rodata. `LazyLock` adds a
+// PERF: `LazyLock` adds a
 // once-init branch; once `vtable::make` is `const fn`, switch to a plain
 // `static`/`const`.
 //
-// PORT NOTE: Zig used `std.EnumArray(SocketKind, ?*const VTable)`. `SocketKind`
-// is `#[repr(u8)]` with dense 0..N discriminants (see uws/lib.rs), so a plain
-// array indexed by `kind as usize` is the exact equivalent — no `enum_map`
+// `SocketKind` is `#[repr(u8)]` with dense 0..N discriminants (see uws/lib.rs),
+// so a plain array indexed by `kind as usize` works — no `enum_map`
 // derive needed on the upstream type.
 const SOCKET_KIND_COUNT: usize = SocketKind::UwsWsTls as usize + 1;
 
@@ -86,7 +81,6 @@ fn vt(s: *mut us_socket_t) -> &'static VTable {
     let kind = s.kind();
     match kind {
         SocketKind::Invalid => {
-            // TODO(port): bun.Output.panic formatting (group={*})
             panic!("us_socket_t with kind=invalid (group={:p})", s.raw_group())
         }
         // Per-group vtable: uWS C++ installs a different `HttpContext<SSL>*`
@@ -111,7 +105,6 @@ fn vtc(c: *mut ConnectingSocket) -> &'static VTable {
     let kind = c.kind();
     match kind {
         SocketKind::Invalid => {
-            // TODO(port): bun.Output.panic formatting
             panic!("us_connecting_socket_t with kind=invalid")
         }
         SocketKind::Dynamic
@@ -211,13 +204,10 @@ pub(crate) unsafe extern "C" fn us_dispatch_ssl_raw_tap(
         // guarantees the buffer outlives this call.
         let slice =
             unsafe { core::slice::from_raw_parts(data, usize::try_from(len).expect("len >= 0")) };
-        // Zig: `raw.onData(TLSSocket.Socket.from(s), data[..])` where
-        // `Socket = uws.NewSocketHandler(ssl)`. SAFETY: `twin` holds a live +1
+        // SAFETY: `twin` holds a live +1
         // ref to the `[raw, _]` half; dispatch is single-threaded so no aliasing
         // `&mut` exists. `on_data` takes `*mut Self` (noalias re-entrancy fix).
         unsafe { TLSSocket::on_data(raw, NewSocketHandler::<true>::from(s), slice) };
     }
     s
 }
-
-// ported from: src/runtime/socket/uws_dispatch.zig
diff --git a/src/runtime/socket/uws_handlers.rs b/src/runtime/socket/uws_handlers.rs
index cb65e79ef19..d91a3d903bc 100644
--- a/src/runtime/socket/uws_handlers.rs
+++ b/src/runtime/socket/uws_handlers.rs
@@ -31,9 +31,7 @@ use bun_sql_jsc::postgres;
 /// pending-exception slot — there's nowhere for the C event loop to propagate
 /// them — so we just don't lose the unwind.
 ///
-/// Zig used `@typeInfo(@TypeOf(result)) == .error_union` to branch at comptime;
-/// in Rust we express the same with a tiny trait specialised on `()` and
-/// `Result<(), E>`.
+/// A tiny trait specialised on `()` and `Result<(), E>` handles both shapes.
 #[inline]
 fn swallow<R: Swallow>(result: R) {
     result.swallow();
@@ -53,18 +51,15 @@ impl<E> Swallow for Result<(), E> {
     }
 }
 
-/// Replaces the Zig `if (@hasDecl(T, "onX")) this.onX(..)` pattern: a trait
-/// with default no-op methods that each owner type overrides for the events it
-/// actually handles. The `<const SSL: bool>` parameter mirrors the Zig
-/// `comptime ssl: bool` so a type can opt into different behaviour per
-/// transport (and so `NewSocketHandler<SSL>` is nameable in signatures).
+/// A trait with default no-op methods that each owner type overrides for the
+/// events it actually handles. The `<const SSL: bool>` parameter lets a type
+/// opt into different behaviour per transport (and so `NewSocketHandler<SSL>`
+/// is nameable in signatures).
 ///
 /// All methods default to `Ok(())`; `swallow` collapses both `()` and
 /// `Result<(), _>` so consumer impls may return either — but to avoid
 /// associated-type contortions every default returns `bun_jsc::JsResult<()>`
 /// and plain-`void` consumers just `Ok(())`.
-// TODO(port): if a consumer's `on_*` is infallible, the trait default forces a
-// `Result` wrap; revisit once consumer crates are ported.
 pub trait SocketEvents<const SSL: bool> {
     fn on_open(&mut self, _s: NewSocketHandler<SSL>) -> bun_jsc::JsResult<()> {
         Ok(())
@@ -401,7 +396,7 @@ impl<const SSL: bool> RawSocketEvents<SSL> for websocket_upgrade_client::NewHttp
 }
 
 impl<const SSL: bool> RawSocketEvents<SSL> for websocket_client::WebSocket<SSL> {
-    // Zig: no `onOpen` decl — adoption of an already-connected socket.
+    // No `on_open` override — adoption of an already-connected socket.
 
     unsafe fn on_data(this: *mut Self, _s: NewSocketHandler<SSL>, data: &[u8]) {
         // SAFETY: caller upholds the `RawSocketEvents` contract — `this` points
@@ -446,28 +441,24 @@ impl<const SSL: bool> RawSocketEvents<SSL> for websocket_client::WebSocket<SSL>
 
 // ── SocketEvents / NsSocketEvents impls ─────────────────────────────────────
 //
-// In Zig the consumer types carry `onOpen`/`onData`/… as inherent decls and
-// `@hasDecl` filters at comptime. Rust expresses that as a trait with default
+// A trait with default
 // no-ops; each consumer type opts in with an `impl` that overrides only the
 // events it actually handles. `api::NewSocket`'s real impl lives in
 // `socket/mod.rs` (bridges to inherent methods).
 
 /// Forwards `NsSocketEvents` to the inherent `on_*` methods on a driver's
-/// `SocketHandler<SSL>` namespace type. Mirrors Zig's single
-/// `NsHandler(Owner, H, ssl)` generic (uws_handlers.zig:154), which used
-/// `@hasDecl` + a comptime `swallow` to absorb both `void` and `!void`
-/// returns; here `swallow()` (specialised on `()` and `Result<(), E>` above)
-/// does the same, so one expansion covers drivers whose inherent fns are
+/// `SocketHandler<SSL>` namespace type. `swallow()` (specialised on `()` and
+/// `Result<(), E>` above) absorbs both infallible and fallible
+/// returns, so one expansion covers drivers whose inherent fns are
 /// infallible (postgres, mysql) and those returning `JsTerminatedResult<()>`
 /// (valkey). The dispatcher (`NsHandler: VHandler`) `swallow`s the trait
 /// result anyway, so swallowing one frame earlier is behaviour-preserving.
 ///
 /// `on_long_timeout` is intentionally NOT forwarded — no driver defines it,
-/// so the trait default fires (matches Zig's `@hasDecl` short-circuit).
+/// so the trait default fires.
 ///
 /// `on_handshake` reads the inherent `ON_HANDSHAKE: Option<fn(..)>` const —
-/// Zig's `pub const onHandshake = if (ssl) onHandshake_ else null;` pattern,
-/// where the `null` arm meant "leave the slot unbound" so the dispatcher's
+/// `None` means "leave the slot unbound" so the dispatcher's
 /// no-op default fires for plain TCP.
 macro_rules! impl_ns_socket_events_forward {
     ($Owner:ty, $Handler:ty) => {
@@ -539,7 +530,7 @@ impl_ns_socket_events_forward!(
 impl_ns_socket_events_forward!(js_valkey::JSValkeyClient, js_valkey::SocketHandler<SSL>);
 
 // ── Bun.connect / Bun.listen ────────────────────────────────────────────────
-// PORT NOTE (noalias re-entrancy): routed through `RawPtrHandler`, not
+// Noalias re-entrancy: routed through `RawPtrHandler`, not
 // `PtrHandler`. `NewSocket::on_*` re-enter JS (`socket.write/end/reload`) which
 // re-derives `&mut NewSocket` via the wrapper's `m_ptr`; a `&mut NewSocket`
 // argument formed by `PtrHandler` and protected through the dispatch frame
@@ -688,9 +679,7 @@ pub trait NsSocketEvents<Owner, const SSL: bool> {
     ) -> bun_jsc::JsResult<()> {
         Ok(())
     }
-    /// Zig guarded this with `@TypeOf(H.onHandshake) != @TypeOf(null)` — i.e.
-    /// some adapters explicitly set `onHandshake = null`. Default no-op covers
-    /// that case.
+    /// Default no-op covers adapters that leave the handshake slot unbound.
     fn on_handshake(
         _this: &mut Owner,
         _s: NewSocketHandler<SSL>,
@@ -796,10 +785,8 @@ where
 // type we forgot to name.
 pub struct HTTPClient<const SSL: bool>;
 
-// Zig's `fwd` helper used `@field` + `@call` to dispatch by name; Rust has no
-// field-by-string reflection, so each event is written out. The
-// `@TypeOf(@field(H, name)) != @TypeOf(null)` guard becomes simply not setting
-// `HAS_ON_*` for events the upstream `Handler<SSL>` doesn't define.
+// Each event is written out by hand; `HAS_ON_*` is simply left unset
+// for events the upstream `Handler<SSL>` doesn't define.
 type HttpH<const SSL: bool> = bun_http::http_context::Handler<SSL>;
 
 impl<const SSL: bool> VHandler for HTTPClient<SSL> {
@@ -898,7 +885,7 @@ pub type Valkey<const SSL: bool> =
 
 // ── Bun.spawn IPC / process.send() ──────────────────────────────────────────
 // Ext is `*IPC.SendQueue` for both child-side `process.send` and parent-side
-// `Bun.spawn({ipc})`. Handlers live in `ipc.zig` as free functions, not
+// `Bun.spawn({ipc})`. The IPC handlers are free functions, not
 // methods on SendQueue, so we adapt manually instead of via PtrHandler.
 pub struct SpawnIPC;
 
@@ -942,5 +929,3 @@ impl VHandler for SpawnIPC {
         IpcH::on_end(this, IpcS::from(s));
     }
 }
-
-// ported from: src/runtime/socket/uws_handlers.zig
diff --git a/src/runtime/socket/uws_jsc.rs b/src/runtime/socket/uws_jsc.rs
index 86506d320cf..c67dea4333b 100644
--- a/src/runtime/socket/uws_jsc.rs
+++ b/src/runtime/socket/uws_jsc.rs
@@ -80,7 +80,8 @@ pub fn create_bun_socket_error_to_js(
 pub use bun_jsc::system_error::verify_error_to_js;
 
 // ── AnyWebSocket.getTopicsAsJSArray ────────────────────────────────────────
-// TODO(port): move to bun_uws_sys
+// Declared inline; migrate into `bun_uws_sys` with the rest of the
+// WebSocket FFI surface.
 unsafe extern "C" {
     // Opaque-handle (`RawWebSocket` is an `opaque_ffi!` ZST — `&mut` carries no
     // `noalias`, dereferences zero bytes) + live `&JSGlobalObject`
@@ -125,12 +126,9 @@ pub(crate) unsafe extern "C" fn us_socket_buffered_js_write(
     // dereferenced to `&mut` at each point of use. The JS calls below
     // (`from_js_with_encoding_value_allow_request_response`, `throw_*`) can re-enter
     // `JSNodeHTTPServerSocket.write` on the same socket, which would alias a long-lived
-    // `&mut *socket` / `&mut *buffer` under Stacked Borrows. The Zig spec uses raw
-    // pointers (`*uws.us_socket_t` / `*us_socket_stream_buffer_t`) with no uniqueness
-    // assertion, so we mirror that here.
+    // `&mut *socket` / `&mut *buffer` under Stacked Borrows, so raw pointers with
+    // no uniqueness assertion are used throughout.
 
-    // PERF(port): was stack-fallback (std.heap.stackFallback(16 * 1024)) — profile if hot.
-    //
     // Convert `data`/`encoding` BEFORE materializing the stream buffer into an owning
     // `Vec<u8>`: the conversion can run arbitrary JS (toString/Symbol.toPrimitive,
     // Request/Response body coercion) which can re-enter this function on the same
@@ -176,8 +174,8 @@ pub(crate) unsafe extern "C" fn us_socket_buffered_js_write(
     let mut stream_buffer = unsafe { &mut *buffer }.to_stream_buffer();
     let mut total_written: usize = 0;
 
-    // PORT NOTE: Zig `defer { buffer.update(stream_buffer); buffer.wrote(total_written); }`
-    // reshaped as a labeled block + post-block cleanup so the side effects run on every
+    // Labeled block + post-block cleanup so the `buffer.update` / `buffer.wrote`
+    // side effects run on every
     // exit path without a scopeguard borrow conflict.
     let result: JSValue = 'body: {
         let data_slice = node_buffer.slice();
@@ -222,5 +220,3 @@ pub(crate) unsafe extern "C" fn us_socket_buffered_js_write(
     }
     result
 }
-
-// ported from: src/runtime/socket/uws_jsc.zig
diff --git a/src/runtime/test_runner/Collection.rs b/src/runtime/test_runner/Collection.rs
index 18222c351e5..e249a0f5a33 100644
--- a/src/runtime/test_runner/Collection.rs
+++ b/src/runtime/test_runner/Collection.rs
@@ -42,7 +42,7 @@ pub struct QueuedDescribe {
     /// `Collection.active_scope` and mutated through).
     new_scope: NonNull<DescribeScope>,
 }
-// Zig `deinit` only called `callback.deinit()`; `Strong: Drop` covers it — no explicit Drop needed.
+// `Strong: Drop` covers cleanup — no explicit Drop needed.
 
 impl Collection {
     /// # Safety
@@ -87,8 +87,7 @@ impl Collection {
         }
     }
 
-    // Zig `deinit` freed root_scope, drained both queues calling item.deinit(), and freed
-    // filter_buffer. All of that is covered by field Drop (Box, Vec<QueuedDescribe>, Vec<u8>).
+    // Cleanup is covered by field Drop (Box, Vec<QueuedDescribe>, Vec<u8>).
     // No explicit `impl Drop for Collection` needed.
 
     /// Immutable view of the currently-active describe scope.
@@ -127,7 +126,6 @@ impl Collection {
         let _g = group::begin();
 
         debug_assert!(!self.locked);
-        // PORT NOTE: Zig used `bunTest().gpa` for Strong.init; allocator param dropped.
 
         if let Some(cb) = callback {
             group::log(format_args!(
@@ -196,24 +194,23 @@ impl Collection {
         let _formatter = make_formatter(global_this);
 
         // append queued callbacks, in reverse order because items will be pop()ed from the end
-        // PORT NOTE: reshaped for borrowck — Zig indexed `items[i]` then clearRetainingCapacity;
         // drain(..).rev() moves each item out exactly once and leaves capacity intact.
         for item in this.current_scope_callback_queue.drain(..).rev() {
             // SAFETY: `new_scope` points into `root_scope`'s Box-allocated tree, which outlives
             // every queued item; short-lived read, no aliasing `&mut` is live here.
             if unsafe { item.new_scope.as_ref() }.failed {
                 // if there was an error in the describe callback, don't run any describe callbacks in this scope
-                drop(item); // Zig: item.deinit() — Strong released here
+                drop(item); // Strong released here
             } else {
                 this.describe_callback_queue.push(item);
             }
         }
-        // PERF(port): was clearRetainingCapacity — drain(..) retains capacity.
+        // `drain(..)` retains the queue's capacity.
 
         while !this.describe_callback_queue.is_empty() {
             group::log(format_args!("runOne -> call next"));
             let first = this.describe_callback_queue.pop().unwrap();
-            // `defer first.deinit()` — handled by Drop at end of loop body / continue.
+            // `first` cleanup handled by Drop at end of loop body / continue.
 
             // SAFETY: `active_scope` points into `root_scope`'s Box-allocated tree, which outlives
             // every queued item; short-lived read, no aliasing `&mut` is live here.
@@ -266,5 +263,3 @@ impl Collection {
         HandleUncaughtExceptionResult::ShowUnhandledErrorInDescribe // unhandled because it needs to exit with code 1
     }
 }
-
-// ported from: src/test_runner/Collection.zig
diff --git a/src/runtime/test_runner/DoneCallback.rs b/src/runtime/test_runner/DoneCallback.rs
index a2aee866bda..10cb136bd20 100644
--- a/src/runtime/test_runner/DoneCallback.rs
+++ b/src/runtime/test_runner/DoneCallback.rs
@@ -3,7 +3,7 @@ use bun_core::String as BunString;
 
 use crate::test_runner::bun_test::{group_begin, BunTest, RefDataPtr};
 
-#[bun_jsc::JsClass(no_construct, no_constructor)] // codegen wires to_js / from_js (Zig: jsc.Codegen.JSDoneCallback)
+#[bun_jsc::JsClass(no_construct, no_constructor)] // codegen wires to_js / from_js
 pub struct DoneCallback {
     /// Some = not called yet. None = done already called, no-op.
     pub r#ref: Option<RefDataPtr>,
@@ -20,7 +20,7 @@ impl DoneCallback {
 
         // `RefDataPtr` = `RefPtr<RefData>` has NO `Drop` impl (see
         // src/ptr/ref_count.rs) — must explicitly decrement before the Box
-        // frees the allocation. Zig: `if (this.ref) |ref| ref.deref();`.
+        // frees the allocation.
         if let Some(r) = self.r#ref.take() {
             r.deref();
         }
@@ -54,8 +54,7 @@ impl DoneCallback {
 }
 
 // Raw C-ABI shim for [`BunTest::bun_test_done_callback`] so it can be passed
-// as a `JSHostFn` pointer to `JSFunction::create` (Zig used comptime
-// `toJSHostFn`; Rust mints the thunk explicitly and routes the result through
+// as a `JSHostFn` pointer to `JSFunction::create` (the thunk routes the result through
 // `to_js_host_fn_result` for `JsResult` → `JSValue` mapping + debug exception
 // assertions).
 bun_jsc::jsc_host_abi! {
@@ -68,5 +67,3 @@ bun_jsc::jsc_host_abi! {
         bun_jsc::to_js_host_fn_result(global, BunTest::bun_test_done_callback(global, callframe))
     }
 }
-
-// ported from: src/test_runner/DoneCallback.zig
diff --git a/src/runtime/test_runner/Execution.rs b/src/runtime/test_runner/Execution.rs
index 861518aa43e..a803a5a1fc8 100644
--- a/src/runtime/test_runner/Execution.rs
+++ b/src/runtime/test_runner/Execution.rs
@@ -51,8 +51,8 @@ use super::bun_test::{
 use crate::cli::test_command;
 
 // ── local shims for upstream Timespec methods not yet ported ───────────────
-// Zig: `bun.timespec.now(.force_real_time)` etc. — bun_core exposes the
-// generic `now(mode)` form; wrap the convenience names here.
+// bun_core exposes only the generic `now(mode)` form; wrap the convenience
+// names here.
 pub(crate) trait TimespecExt {
     fn now_force_real_time() -> Timespec;
     fn ms_from_now_force_real_time(interval: i64) -> Timespec;
@@ -84,10 +84,9 @@ bun_core::declare_scope!(jest, visible);
 
 pub struct Execution {
     pub groups: Box<[ConcurrentGroup]>,
-    // PORT NOTE: was `pub(self)`; widened so `RefDataValue::sequence` can
+    // was `pub(self)`; widened so `RefDataValue::sequence` can
     // split-borrow `groups`/`sequences` without re-entering `sequences_mut`.
     /// the entries themselves are owned by BunTest, which owns Execution.
-    // Zig: `#sequences` (private field)
     pub sequences: Box<[ExecutionSequence]>,
     pub group_index: usize,
 }
@@ -289,18 +288,14 @@ impl Execution {
         }
     }
 
-    // Zig `deinit` only freed `groups` and `#sequences` via the parent allocator.
-    // Both are now `Box<[T]>` and drop automatically — no explicit Drop impl needed.
+    // `groups` / `sequences` are `Box<[T]>` and drop automatically — no explicit Drop impl needed.
 
-    pub fn load_from_order(&mut self, order: &mut Order::Order) -> JsResult<()> {
+    /// Infallible: the `Vec` → `Box<[T]>` conversion cannot fail.
+    pub fn load_from_order(&mut self, order: &mut Order::Order) {
         debug_assert!(self.groups.is_empty());
         debug_assert!(self.sequences.is_empty());
-        // Zig: bun.safety.CheckedAllocator asserts that order's lists used the same gpa.
-        // In Rust the global allocator is unified — nothing to check.
         self.groups = core::mem::take(&mut order.groups).into_boxed_slice();
         self.sequences = core::mem::take(&mut order.sequences).into_boxed_slice();
-        // TODO(port): narrow error set — Zig `try toOwnedSlice()` was OOM-only; Rust Vec→Box is infallible.
-        Ok(())
     }
 
     pub fn handle_timeout(&mut self, global_this: &JSGlobalObject) -> JsResult<()> {
@@ -310,7 +305,7 @@ impl Execution {
         //   kill any dangling processes
         // when using test.concurrent(), we can't do this because it could kill multiple tests at once.
         if let Some(current_group) = self.active_group() {
-            // PORT NOTE: reshaped for borrowck — capture range, drop &mut group, re-borrow sequences
+            // reshaped for borrowck — capture range, drop &mut group, re-borrow sequences
             let (start, end) = (current_group.sequence_start, current_group.sequence_end);
             let sequences = &self.sequences[start..end];
             if sequences.len() == 1 {
@@ -376,7 +371,6 @@ impl Execution {
                     _ => unreachable!(),
                 };
 
-                // Zig: gated on `bun.Environment.ci_assert`.
                 // SAFETY: sequence_ptr points into this.sequences; valid while BunTest is alive.
                 debug_assert!(unsafe { sequence_ptr.as_ref() }.active_entry.is_some());
                 Execution::advance_sequence(buntest_ptr, sequence_ptr, group_ptr);
@@ -390,7 +384,7 @@ impl Execution {
                     }
                 }
                 // this sequence is complete; execute the next sequence
-                // PORT NOTE: re-slice from `this` each iteration via the group's range; carry
+                // re-slice from `this` each iteration via the group's range; carry
                 // `group` as NonNull so no `&mut ConcurrentGroup` aliases `&mut Execution`.
                 loop {
                     // SAFETY: group_ptr points into this.groups (disjoint from this.sequences).
@@ -504,8 +498,7 @@ impl Execution {
         Some((NonNull::from(sequence), NonNull::from(group)))
     }
 
-    /// `sequence` / `group` are carried as `NonNull` (raw-pointer semantics, matching the Zig
-    /// spec's `*ExecutionSequence` / `*ConcurrentGroup`) because they point into
+    /// `sequence` / `group` are carried as `NonNull` (raw-pointer semantics) because they point into
     /// `buntest.execution.{sequences,groups}` and would otherwise alias any live `&mut Execution`.
     fn advance_sequence(
         buntest: NonNull<BunTest>,
@@ -536,7 +529,6 @@ impl Execution {
                 sequence.active_entry = nn(entry.next);
             }
         } else {
-            // Zig: gated on `bun.Environment.ci_assert`.
             debug_assert!(false, "can't call advanceSequence on a completed sequence");
         }
 
@@ -610,8 +602,8 @@ impl Execution {
             let entry = unsafe { entry_ptr.as_ref() };
             scoped_log!(
                 jest,
-                "Running test: \"{}\"",
-                // TODO(port): std.zig.fmtString — escapes string for display; using BStr for now
+                "Running test: {:?}",
+                // `BStr`'s `Debug` impl quotes and escapes for display.
                 bstr::BStr::new(entry.base.name.as_deref().unwrap_or(b"(unnamed)"))
             );
 
@@ -679,7 +671,7 @@ impl Execution {
             if sequence.test_entry.is_some() || sequence.result != Result::Pass {
                 // SAFETY: deref parent BunTest at point-of-use. `sequence` aliases
                 // `buntest.execution.sequences[i]`; `handle_test_completed`'s signature still takes
-                // both `&mut BunTest` and `&mut ExecutionSequence` (TODO(refactor): reshape callee).
+                // both `&mut BunTest` and `&mut ExecutionSequence` (callee could be reshaped to avoid this).
                 test_command::CommandLineReporter::handle_test_completed(
                     unsafe { &mut *buntest.as_ptr() },
                     sequence,
@@ -765,7 +757,7 @@ impl Execution {
         // not exist (https://github.com/oven-sh/bun/issues/23705).
         // Zeroing all entries matches Jest (SnapshotState.clear() on test_retry,
         // jestjs/jest#7493). Concurrent tests never touch the counts map — see
-        // SnapshotInConcurrentGroup in expect.zig.
+        // SnapshotInConcurrentGroup in expect.rs.
         if let Some(runner) = super::jest::Jest::runner() {
             runner.snapshots.reset_counts();
         }
@@ -829,7 +821,7 @@ pub(crate) fn step_group(
 
     loop {
         // Carry the active group as NonNull so it does not alias `&mut Execution` re-derived
-        // inside step_group_one (Zig spec uses raw `*ConcurrentGroup`).
+        // inside step_group_one.
         let group_ptr: NonNull<ConcurrentGroup> = match this.active_group() {
             Some(g) => NonNull::from(g),
             None => return Ok(StepResult::Complete),
@@ -1078,5 +1070,3 @@ fn step_sequence_one(
         return Ok(None); // run again
     }
 }
-
-// ported from: src/test_runner/Execution.zig
diff --git a/src/runtime/test_runner/Order.rs b/src/runtime/test_runner/Order.rs
index 9d8f05bb1aa..00f6a69fd33 100644
--- a/src/runtime/test_runner/Order.rs
+++ b/src/runtime/test_runner/Order.rs
@@ -10,10 +10,10 @@ use super::execution::{ConcurrentGroup, ExecutionSequence};
 pub struct Order {
     pub groups: Vec<ConcurrentGroup>,
     pub sequences: Vec<ExecutionSequence>,
-    // TODO(port): Zig stored `arena: std.mem.Allocator` here. test_runner is not an
-    // AST/arena crate per PORTING.md, so the field is dropped and `bun.create(arena, ...)`
-    // calls below become `heap::alloc(Box::new(...))`. In Zig these ExecutionEntry
-    // clones were bulk-freed by the arena; revisit ownership.
+    // The ExecutionEntry clones below are allocated via `heap::into_raw(Box::new(...))`;
+    // `BunTest` collects them into
+    // `cloned_hook_entries` after `generate_order_describe` and reclaims the Box
+    // headers (without running `Drop`) in `Drop for BunTest`.
     pub previous_group_was_concurrent: bool,
     pub cfg: Config,
 }
@@ -42,19 +42,18 @@ impl Order {
     pub fn generate_all_order(&mut self, entries: &[Box<ExecutionEntry>]) -> JsResult<AllOrderResult> {
         let start = self.groups.len();
         for entry_box in entries.iter() {
-            // Zig signature is `[]const *ExecutionEntry` (immutable slice of *mutable* pointers).
             // Callers (e.g. BunTestRoot.hook_scope) only hold `&` access to the Vec, so we accept
-            // `&[Box<_>]` and recover each Box's heap pointer as *mut — the Zig code mutates
-            // through the pointer, not the slice. SAFETY: each Box<ExecutionEntry> is live and
-            // uniquely owned by the DescribeScope tree; writing through *mut matches the Zig
-            // `*ExecutionEntry` mutation contract. The pointer is obtained via `box_inner_mut`
+            // `&[Box<_>]` and recover each Box's heap pointer as *mut to mutate through the
+            // pointer, not the slice. SAFETY: each Box<ExecutionEntry> is live and
+            // uniquely owned by the DescribeScope tree, and no other reference into it is live
+            // while we write, so the raw-pointer writes are sound. The pointer is obtained via `box_inner_mut`
             // (see below) so rustc's `invalid_reference_casting` lint does not see a local
             // `&T as *const T as *mut T` chain; field writes use raw deref to avoid materializing
             // a long-lived `&mut`.
             let entry: *mut ExecutionEntry = box_inner_mut(&**entry_box);
             // SAFETY: `entry` is the heap address of a live `Box<ExecutionEntry>` uniquely owned by
-            // the DescribeScope tree (see paragraph above); raw-ptr field writes uphold the Zig
-            // `*ExecutionEntry` mutation contract without materializing a long-lived `&mut`.
+            // the DescribeScope tree (see paragraph above); raw-ptr field writes avoid
+            // materializing a long-lived `&mut`.
             unsafe {
                 if bun_core::Environment::CI_ASSERT && (*entry).added_in_phase != AddedInPhase::Preload {
                     debug_assert!((*entry).next.is_none());
@@ -98,7 +97,7 @@ impl Order {
         }
 
         // gather children
-        // PORT NOTE: reshaped for borrowck — iterate by index since generate_order_sub borrows &mut self.
+        // reshaped for borrowck — iterate by index since generate_order_sub borrows &mut self.
         let scope_only = current.base.only;
         for i in 0..current.entries.len() {
             if scope_only == Only::Contains && current.entries[i].base().only == Only::No {
@@ -150,11 +149,12 @@ impl Order {
                 let mut i: usize = p.before_each.len();
                 while i > 0 {
                     let src: *const ExecutionEntry = &raw const *p.before_each[i - 1];
-                    // PERF(port): was arena bulk-free — Zig allocated this clone in `this.arena`.
-                    // TODO(port): ownership — heap::alloc leaks without the arena; decide whether
-                    // test_runner keeps an arena or tracks these for cleanup.
-                    // SAFETY: bitwise copy of *ExecutionEntry — matches Zig `bun.create(arena, T, src.*)`.
-                    // The clone is leaked (heap::alloc) so its Strong/Box fields are never dropped twice.
+                    // Ownership: `BunTest` collects these clones into `cloned_hook_entries`
+                    // (the post-`generate_order_describe` walk) and frees only the Box
+                    // headers in `Drop for BunTest` — `Drop` must not run on the bitwise
+                    // copy or the originals' Strong/Box fields would be freed twice.
+                    // SAFETY: `src` is valid for reads; `Drop` never runs on the bitwise copy
+                    // (see ownership note above), so duplicated owning fields are not double-freed.
                     let cloned = bun_core::heap::into_raw(Box::new(unsafe { core::ptr::read(src) }));
                     list.prepend(cloned);
                     i -= 1;
@@ -174,8 +174,8 @@ impl Order {
                 let p = unsafe { &*p_ptr };
                 for entry in p.after_each.iter() {
                     let src: *const ExecutionEntry = &raw const **entry;
-                    // PERF(port): was arena bulk-free — see note above.
-                    // SAFETY: bitwise copy of *ExecutionEntry — matches Zig `bun.create(arena, T, src.*)`.
+                    // SAFETY: `src` is valid for reads; `Drop` never runs on the bitwise copy
+                    // (see ownership note above), so duplicated owning fields are not double-freed.
                     let cloned = bun_core::heap::into_raw(Box::new(unsafe { core::ptr::read(src) }));
                     list.append(cloned);
                 }
@@ -222,7 +222,6 @@ impl Order {
         sequences_start: usize,
         sequences_end: usize,
     ) -> JsResult<()> {
-        // PORT NOTE: reshaped for borrowck — Zig used `defer this.previous_group_was_concurrent = concurrent;`.
         // We capture the old value first, then assign immediately so it applies on every exit path.
         let prev_was_concurrent = self.previous_group_was_concurrent;
         self.previous_group_was_concurrent = concurrent;
@@ -264,15 +263,14 @@ impl AllOrderResult {
 
 pub struct Config {
     pub always_use_hooks: bool,
-    // TODO(port): `std.Random` interface mapped to the concrete `DefaultPrng` (xoshiro256++);
-    // bun_core has no type-erased Random vtable yet and the only call site seeds a DefaultPrng.
+    // The only call site seeds a concrete `DefaultPrng` (xoshiro256++), so
+    // no type-erased Random vtable is needed.
     pub randomize: Option<bun_core::rand::DefaultPrng>,
 }
 
-/// Exact port of `std.Random.shuffleWithIndex(T, buf, usize)` (vendor/zig/lib/std/Random.zig).
 /// Forward Fisher-Yates: `i` from 0 to len-2, `j = intRangeLessThan(usize, i, len)`.
-/// Must produce the identical permutation to Zig for the same xoshiro256++ state so that
-/// `bun test --randomize --seed=N` is reproducible across the Zig and Rust ports.
+/// Must produce the identical permutation for the same xoshiro256++ state across Bun
+/// versions so that `bun test --randomize --seed=N` stays reproducible.
 fn shuffle_with_index<T>(r: &mut bun_core::rand::DefaultPrng, buf: &mut [T]) {
     if buf.len() < 2 {
         return;
@@ -316,8 +314,7 @@ fn uint_less_than(r: &mut bun_core::rand::DefaultPrng, less_than: u64) -> u64 {
 
 /// Recover the heap pointer behind a `Box<T>` as `*mut T` given the inner `&T`.
 ///
-/// Zig's `[]const *T` is an immutable slice of *mutable* pointers; the closest Rust shape we
-/// can accept from callers is `&[Box<T>]`, but we still need to mutate through each element.
+/// Callers hand us `&[Box<T>]`, but we still need to mutate through each element.
 /// Going through this helper breaks the intraprocedural dataflow that the
 /// `invalid_reference_casting` deny-by-default lint tracks (it would otherwise flag the
 /// `&T -> *const T -> *mut T -> &mut T` chain at the call site). The provenance caveat is
@@ -364,5 +361,3 @@ impl EntryList {
         }
     }
 }
-
-// ported from: src/test_runner/Order.zig
diff --git a/src/runtime/test_runner/ScopeFunctions.rs b/src/runtime/test_runner/ScopeFunctions.rs
index b5e1c36423a..52a454333cb 100644
--- a/src/runtime/test_runner/ScopeFunctions.rs
+++ b/src/runtime/test_runner/ScopeFunctions.rs
@@ -13,8 +13,8 @@ use crate::test_runner::jest;
 // so call sites read `let _g = group_log::begin();` and drop calls `end()`. The underlying
 // `group` module exposes `begin_msg`/`end`/`log` taking `fmt::Arguments`.
 //
-// Zig `groupLog.begin(@src())` (debug.zig) emits the call-site `file:line:col: fn_name` so
-// each scope is traceable in BUN_DEBUG output. `begin()` is `#[track_caller]` and forwards
+// The call-site `file:line:col` prefix makes
+// each scope traceable in BUN_DEBUG output. `begin()` is `#[track_caller]` and forwards
 // `core::panic::Location::caller()` so each call site logs its own source location instead
 // of collapsing to a single static string.
 mod group_log {
@@ -24,8 +24,7 @@ mod group_log {
     #[track_caller]
     pub(super) fn begin() -> group::GroupGuard {
         let loc = core::panic::Location::caller();
-        // Mirrors Zig `group.begin(@src())` → `"<file>:<line>:<col>: <fn_name>"` (ANSI-coloured
-        // in debug.zig). Rust's `Location` has no `fn_name`, so we emit `file:line:col` which
+        // `Location` has no `fn_name`, so we emit `file:line:col` which
         // still gives per-call-site identity in the group-log trace.
         group::begin_msg(core::format_args!(
             "\x1b[36m{}\x1b[37m:\x1b[93m{}\x1b[37m:\x1b[33m{}\x1b[m",
@@ -207,49 +206,50 @@ pub(crate) fn call_as_function(global: &JSGlobalObject, frame: &CallFrame) -> Js
                 break;
             }
 
-            // PORT NOTE: Zig keeps a parallel `ArrayList(Strong)` to root each element across
-            // the format_label/bind allocations below. `bun_jsc::MarkedArgumentBuffer` only
-            // exposes a scoped-closure constructor (no `as_slice`/`len`), so for Phase D we
-            // use a plain `Vec<JSValue>` mirroring Zig's `args_list_raw`. The outer `iter`
-            // keeps `this.each` alive; per-element rooting is a TODO once Strong<JSValue>
-            // lands in bun_jsc.
-            // TODO(port): root args via Strong / MarkedArgumentBuffer once upstream surface exists.
-            let mut args_list: Vec<JSValue> = Vec::new();
-
-            if item.is_array() {
-                // Spread array as args_list (matching Jest & Vitest)
-                let mut item_iter = item.array_iterator(global)?;
-                let mut idx: usize = 0;
-                while let Some(array_item) = item_iter.next()? {
-                    args_list.push(array_item);
-                    idx += 1;
+            // Root the gathered args for the GC across the `format_label`/`bind`
+            // allocations below. `MarkedArgumentBuffer` stack-roots every appended
+            // value for the duration of the closure; the plain `Vec<JSValue>`
+            // mirrors it because `format_label`/`bind` need a slice view (the
+            // buffer exposes no `as_slice`/`len`).
+            bun_jsc::MarkedArgumentBuffer::new(|rooted| -> JsResult<()> {
+                rooted.append(item);
+                let mut args_list: Vec<JSValue> = Vec::new();
+
+                if item.is_array() {
+                    // Spread array as args_list (matching Jest & Vitest)
+                    let mut item_iter = item.array_iterator(global)?;
+                    while let Some(array_item) = item_iter.next()? {
+                        rooted.append(array_item);
+                        args_list.push(array_item);
+                    }
+                } else {
+                    args_list.push(item);
                 }
-                let _ = idx;
-            } else {
-                args_list.push(item);
-            }
 
-            let formatted_label: Option<Vec<u8>> = if let Some(desc) = args.description.as_deref() {
-                Some(jest::format_label(global, desc, args_list.as_slice(), test_idx)?.into_vec())
-            } else {
-                None
-            };
+                let formatted_label: Option<Vec<u8>> = if let Some(desc) = args.description.as_deref() {
+                    Some(jest::format_label(global, desc, args_list.as_slice(), test_idx)?.into_vec())
+                } else {
+                    None
+                };
 
-            let bound = if let Some(cb) = args.callback {
-                Some(JSValueTestExt::bind(cb, global, item, &BunString::static_str("cb"), 0.0, args_list.as_slice())?)
-            } else {
-                None
-            };
-            this.enqueue_describe_or_test_callback(
-                bun_test_ptr,
-                global,
-                frame,
-                bound,
-                formatted_label.as_deref(),
-                &args.options,
-                callback_length.saturating_sub(args_list.len()),
-                line_no,
-            )?;
+                let bound = if let Some(cb) = args.callback {
+                    Some(JSValueTestExt::bind(cb, global, item, &BunString::static_str("cb"), 0.0, args_list.as_slice())?)
+                } else {
+                    None
+                };
+                this.enqueue_describe_or_test_callback(
+                    // Explicit reborrow: the closure must not move the `&mut`
+                    // (it is reused on later loop iterations).
+                    &mut *bun_test_ptr,
+                    global,
+                    frame,
+                    bound,
+                    formatted_label.as_deref(),
+                    &args.options,
+                    callback_length.saturating_sub(args_list.len()),
+                    line_no,
+                )
+            })?;
 
             test_idx += 1;
         }
@@ -269,7 +269,6 @@ pub(crate) fn call_as_function(global: &JSGlobalObject, frame: &CallFrame) -> Js
     Ok(JSValue::UNDEFINED)
 }
 
-// `filterNames` in Zig is generic over a duck-typed `Rem` with `writeEnd`.
 trait WriteEnd {
     fn write_end(&mut self, write: &[u8]);
 }
@@ -294,8 +293,7 @@ impl<'a> WriteEnd for Write<'a> {
         }
         let dst_start = self.buf.len() - write.len();
         self.buf[dst_start..].copy_from_slice(write);
-        // PORT NOTE: reshaped for borrowck — Zig reassigns the slice in place;
-        // here we shrink via `take` + reslice.
+        // shrink via `take` + reslice (borrowck-friendly).
         let buf = core::mem::take(&mut self.buf);
         self.buf = &mut buf[..dst_start];
     }
@@ -354,7 +352,6 @@ impl ScopeFunctions {
         let mut test_id_for_debugger: i32 = 0;
         if let Some(debugger) = (*vm).debugger.as_mut() {
             if debugger.test_reporter_agent.is_enabled() {
-                // Zig: fn-local `struct { var max_test_id_for_debugger: i32 = 0; }` — process-global static.
                 static MAX_TEST_ID_FOR_DEBUGGER: AtomicI32 = AtomicI32::new(0);
                 let id = MAX_TEST_ID_FOR_DEBUGGER.fetch_add(1, Ordering::Relaxed) + 1;
                 let mut name = BunString::init(description.unwrap_or(b"(unnamed)"));
@@ -396,7 +393,7 @@ impl ScopeFunctions {
         match self.mode {
             Mode::Describe => {
                 // SAFETY: active_scope is a valid cursor into root_scope's tree for the lifetime of Collection.
-                let new_scope = unsafe { bun_test.collection.active_scope.as_mut() }.append_describe(description, base)?;
+                let new_scope = unsafe { bun_test.collection.active_scope.as_mut() }.append_describe(description, base);
                 bun_test.collection.enqueue_describe_callback(new_scope, callback)?;
             }
             Mode::Test => {
@@ -408,14 +405,14 @@ impl ScopeFunctions {
                     if let Some(filter_regex) = reporter.jest.filter_regex {
                         group_log::log(format_args!("matches_filter begin"));
                         debug_assert!(bun_test.collection.filter_buffer.is_empty());
-                        // PORT NOTE: reshaped for borrowck — clear at end via explicit call below.
+                        // reshaped for borrowck — clear at end via explicit call below.
 
                         // SAFETY: active_scope is a valid cursor into root_scope's tree for the lifetime of Collection.
                         let active_scope: &DescribeScope = unsafe { bun_test.collection.active_scope.as_ref() };
 
                         let mut len = Measure { len: 0 };
                         filter_names(&mut len, description, Some(active_scope));
-                        // PORT NOTE: Zig `addManyAsSlice` — extend by `len.len` zero bytes and
+                        // Extend by `len.len` zero bytes and
                         // hand back the freshly-appended tail as `&mut [u8]`.
                         let start = bun_test.collection.filter_buffer.len();
                         bun_test.collection.filter_buffer.resize(start + len.len, 0);
@@ -526,7 +523,6 @@ pub struct ParseArgumentsResult {
     pub callback: Option<JSValue>,
     pub options: ParseArgumentsOptions,
 }
-// PORT NOTE: Zig `deinit` only freed `description`; `Vec<u8>` drops automatically.
 
 #[derive(Default, Clone, Copy)]
 pub struct ParseArgumentsOptions {
@@ -568,9 +564,9 @@ fn get_description(
     }
 
     if description.is_class(global) {
-        // PORT NOTE: upstream `JSValue::get_class_name` writes into an out-param
-        // ZigString instead of returning one (unlike Zig's `className` which
-        // returns by value). Adapt locally rather than touching bun_jsc.
+        // upstream `JSValue::get_class_name` writes into an out-param
+        // ZigString instead of returning one. Adapt locally rather than
+        // touching bun_jsc.
         let mut description_class_name = bun_core::ZigString::EMPTY;
         description.get_class_name(global, &mut description_class_name)?;
 
@@ -683,7 +679,7 @@ pub fn parse_arguments(
         callback: result_callback,
         options: ParseArgumentsOptions::default(),
     };
-    // errdefer result.deinit() — handled by Drop on early return.
+    // `result` cleanup handled by Drop on early return.
 
     let mut timeout_option: Option<f64> = None;
 
@@ -705,7 +701,7 @@ pub fn parse_arguments(
             if !retries.is_number() {
                 return Err(global.throw(format_args!("{}() expects retry to be a number", signature)));
             }
-            // std.math.lossyCast(u32, f64) — Rust `as` saturates on overflow/NaN.
+            // Lossy cast: Rust `as` saturates on overflow/NaN.
             result.options.retry = Some(retries.as_number() as u32);
         }
         if let Some(repeats) = options.get(global, "repeats")? {
@@ -757,8 +753,7 @@ pub fn parse_arguments(
 // `js::each_set_cached` is the codegen'd setter for the C++ `m_each` WriteBarrier
 // (see jest.classes.ts `values: ["each"]`).
 //
-// Hand-expansion of what `src/codegen/generate-classes.ts` emits into
-// `ZigGeneratedClasses.zig` for `pub const JSScopeFunctions = struct { ... }`:
+// Hand-expansion of the cached-value accessors `src/codegen/generate-classes.ts` emits:
 // `eachSetCached` / `eachGetCached` thin-wrap the C++-side
 // `ScopeFunctionsPrototype__each{Set,Get}CachedValue` shims, which write/read the
 // `JSC::WriteBarrier<Unknown> m_each` slot on the JSCell wrapper so the GC visits
@@ -823,9 +818,8 @@ pub(crate) fn bind(value: JSValue, global: &JSGlobalObject, name: BunString) ->
 }
 
 /// Local shim for `JSValue::setPrototypeDirect` (not yet on `bun_jsc::JSValue`).
-/// Mirrors Zig `bun.cpp.Bun__JSValue__setPrototypeDirect` — `[[ZIG_EXPORT(check_slow)]]`,
+/// The C++ `Bun__JSValue__setPrototypeDirect` is `[[ZIG_EXPORT(check_slow)]]`,
 /// so we manually surface any pending exception as `JsError::Thrown`.
-// TODO(port): land as inherent `JSValue::set_prototype_direct` in bun_jsc.
 #[track_caller]
 fn set_prototype_direct(value: JSValue, prototype: JSValue, global: &JSGlobalObject) -> JsResult<()> {
     // `[[ZIG_EXPORT(check_slow)]]`. C++ side reads `value.getObject()` so
@@ -847,8 +841,7 @@ pub(crate) fn create_bound(
 }
 
 // These enum types live on `bun_test::BaseScopeCfg` (`self_mode`, `self_concurrent`).
-// The Zig spec named them `SelfMode`/`SelfConcurrent`; bun_test.rs ported them as
-// `ScopeMode`/`ConcurrentMode`. Alias here so the bodies read like the spec.
+// bun_test.rs names them `ScopeMode`/`ConcurrentMode`; alias here for brevity.
 use crate::test_runner::bun_test::{ScopeMode as SelfMode, ConcurrentMode as SelfConcurrent};
 // `TestReporterKind` in the spec is `bun_jsc::debugger::TestType` (Test/Describe).
 use bun_jsc::debugger::TestType as TestReporterKind;
@@ -864,5 +857,3 @@ fn scope_mode_str(m: SelfMode) -> &'static str {
         SelfMode::FilteredOut => "filtered_out",
     }
 }
-
-// ported from: src/test_runner/ScopeFunctions.zig
diff --git a/src/runtime/test_runner/bun_test.rs b/src/runtime/test_runner/bun_test.rs
index 38f5f418011..a59d41f484d 100644
--- a/src/runtime/test_runner/bun_test.rs
+++ b/src/runtime/test_runner/bun_test.rs
@@ -14,10 +14,8 @@ use crate::cli::test_command::CommandLineReporter;
 use super::execution::TimespecExt as _;
 
 bun_core::declare_scope!(bun_test_group, hidden);
-// `group` in the Zig is `debug.group` (an Output.scoped). The macro form differs;
-// callers use `group_log!` / `group_begin!` / `group_end!` below.
-/// Thin macro over `debug::group::begin()` so call sites stay `group_begin!()`
-/// (Zig: `group.begin(@src())` — Rust uses `#[track_caller]` for source loc).
+// Callers use `group_log!` / `group_begin!` / `group_end!` below.
+/// Thin macro over `debug::group::begin()` so call sites stay `group_begin!()`.
 macro_rules! group_begin {
     () => {
         $crate::test_runner::debug::group::begin()
@@ -87,7 +85,8 @@ pub mod js_fns {
         global_this: &JSGlobalObject,
         cfg: &GetActiveCfg<'a>,
     ) -> JsResult<&'static mut BunTestRoot> {
-        // TODO(port): lifetime — Jest.runner is a process-global; modeled as an unbounded `&mut` here.
+        // `Jest.runner` is a process-global that outlives every caller, so the
+        // unbounded `&'static mut` is the honest model here.
         let Some(runner) = Jest::runner() else {
             return Err(global_this.throw(format_args!(
                 "Cannot use {} outside of the test runner. Run \"bun test\" to run tests.",
@@ -121,7 +120,7 @@ pub mod js_fns {
 
     /// Tags accepted by `generic_hook`. Superset of `DescribeScope::HookTag`
     /// (adds `OnTestFinished`).
-    // PORT NOTE: was a const-generic param (`adt_const_params` is unstable);
+    // was a const-generic param (`adt_const_params` is unstable);
     // reshaped to runtime dispatch with per-tag thin host_fn wrappers below.
     #[derive(Copy, Clone, PartialEq, Eq, strum::IntoStaticStr)]
     pub enum GenericHookTag {
@@ -146,7 +145,7 @@ pub mod js_fns {
                 Self::OnTestFinished => None,
             }
         }
-        /// `@tagName(tag) ++ "()"` — comptime string, so a const per-variant table.
+        /// Per-variant signature string: the tag name plus `"()"`.
         const fn sig(self) -> &'static [u8] {
             match self {
                 Self::BeforeAll => b"beforeAll()",
@@ -158,20 +157,18 @@ pub mod js_fns {
         }
     }
 
-    // Zig: `fn genericHook(comptime tag) type { return struct { pub fn hookFn(...) } }`
-    // PORT NOTE: reshaped — `adt_const_params` is unstable, so the body takes
-    // `tag` at runtime and 5 thin `#[host_fn]` wrappers below supply the
-    // per-tag entry points (one fn per JS function, matching Zig's comptime
-    // monomorphization for JSFunction::create).
+    // `adt_const_params` is unstable, so the body takes `tag` at runtime and
+    // 5 thin `#[host_fn]` wrappers below supply the per-tag entry points
+    // (one fn per JS function so JSFunction::create gets a distinct address).
     pub fn generic_hook_impl(
         tag: GenericHookTag,
         global_this: &JSGlobalObject,
         call_frame: &CallFrame,
     ) -> JsResult<JSValue> {
-        {
-            let _g = group_begin!();
-            // errdefer group.log("ended in error", .{}) — handled by ? paths implicitly logging
-            // TODO(port): errdefer side-effect log on error path
+        let _g = group_begin!();
+        // Run the body in a closure so every error exit funnels through the
+        // log below before the group guard closes.
+        let result = (|| -> JsResult<JSValue> {
 
             let tag_name: &'static str = tag.into();
             let sig_bytes: &'static [u8] = tag.sig();
@@ -182,7 +179,6 @@ pub mod js_fns {
                 Signature::Str(sig_bytes),
                 ScopeFunctions::ParseArgumentsCfg { callback: ScopeFunctions::CallbackMode::Require, kind: ScopeFunctions::FunctionKind::Hook },
             )?;
-            // defer args.deinit() → Drop
 
             let has_done_parameter = if let Some(callback) = args.callback {
                 callback.get_length(global_this)? > 0
@@ -316,7 +312,6 @@ pub mod js_fns {
                         (*append_point).next = Some(new_item_ptr);
                     }
                     bun_test.extra_execution_entries.push(new_item_ptr);
-                    // PERF(port): was bun.handleOom(append) — Vec::push aborts on OOM
 
                     Ok(JSValue::UNDEFINED)
                 }
@@ -325,12 +320,15 @@ pub mod js_fns {
                     tag_name
                 ))),
             }
+        })();
+        if result.is_err() {
+            crate::test_runner::debug::group::log("ended in error");
         }
+        result
     }
 
     /// Per-tag `#[host_fn]` entry points (one fn per JS function so
-    /// `JSFunction::create` gets a distinct address). Replaces Zig's
-    /// `genericHook(comptime tag).hookFn` type-generator.
+    /// `JSFunction::create` gets a distinct address).
     pub mod generic_hook {
         use super::*;
         macro_rules! hook {
@@ -354,11 +352,9 @@ pub mod js_fns {
 /// Compat alias for sibling drafts (jest.rs) that referenced `bun_test::HookKind`.
 pub use js_fns::GenericHookTag as HookKind;
 
-/// `bun.ptr.shared.WithOptions(*BunTest, .{ .allow_weak = true, .Allocator = bun.DefaultAllocator })`
-/// → `Rc<BunTestCell>` (single-thread, weak-capable, interior-mutable).
+/// `Rc<BunTestCell>`: single-thread, weak-capable, interior-mutable shared handle.
 ///
-/// Zig's `BunTestPtr.get()` hands back a freely-aliasing `*BunTest`; the Rust
-/// port mutates through this handle pervasively (re-entrantly via JS callbacks).
+/// Code mutates through this handle pervasively (re-entrantly via JS callbacks).
 /// `Rc<T>` does **not** wrap `T` in `UnsafeCell`, so the previous
 /// `Rc::as_ptr(&rc) as *mut T` + write was UB. The payload now lives in an
 /// explicit `UnsafeCell` so all writes go through interior-mutable provenance.
@@ -367,8 +363,8 @@ pub type BunTestPtrWeak = Weak<BunTestCell>;
 pub type BunTestPtrOptional = Option<Rc<BunTestCell>>;
 
 /// `UnsafeCell` newtype so `Rc<BunTestCell>` permits mutation of the shared
-/// `BunTest` (Zig: `*BunTest` aliases freely; Rust requires `UnsafeCell` for
-/// any write reachable through a shared/`*const` path).
+/// `BunTest` (`UnsafeCell` is required for any write reachable through a
+/// shared/`*const` path).
 #[repr(transparent)]
 pub struct BunTestCell(UnsafeCell<BunTest>);
 
@@ -378,14 +374,11 @@ impl BunTestCell {
         Rc::new(Self(UnsafeCell::new(bt)))
     }
 
-    /// Zig `BunTestPtr.get()` → `*BunTest`.
-    ///
     /// Returns `&mut` because every call site mutates. The borrow is derived
     /// from `UnsafeCell::get()` so provenance is valid for writes even while
     /// other `Rc`/`Weak` handles exist.
     ///
-    /// **Aliasing contract:** the test runner is single-threaded and this is
-    /// the moral equivalent of Zig's freely-aliasing `*T`. Callers must not
+    /// **Aliasing contract:** the test runner is single-threaded. Callers must not
     /// hold the returned `&mut` across a re-entrancy point (JS callback,
     /// `Collection::step`, `Execution::step`, `BunTest::run`) that itself calls
     /// `.get()` — re-derive afterwards instead. Prefer [`as_ptr`](Self::as_ptr)
@@ -519,7 +512,7 @@ impl BunTestRoot {
         // call's reborrow; the next `Jest::runner()` hands out a fresh
         // an exclusive `&mut TestRunner`, invalidating that tag, so later derefs at
         // `BunTest::run`/`on_uncaught_exception` would be use-after-invalidation
-        // under Stacked Borrows. Zig (.zig:178) just passes a stable `*BunTestRoot`.
+        // under Stacked Borrows.
         // SAFETY: single-threaded; `RUNNER` outlives every BunTest. Field
         // projection via `addr_of_mut!` creates no intermediate `&mut TestRunner`,
         // and `addr_of_mut!` on a live struct field is never null.
@@ -527,11 +520,10 @@ impl BunTestRoot {
             .map(|p| unsafe { NonNull::new_unchecked(core::ptr::addr_of_mut!((*p.as_ptr()).bun_test_root)) })
             .unwrap_or_else(|| NonNull::from(&mut *self));
 
-        // Zig: active_file = .new(undefined); active_file.get().?.init(...)
-        // TODO(port): in-place init — Rc::new_cyclic or two-phase init may be
-        // needed because BunTest stores a backref to BunTestRoot.
-        // PORT NOTE: Zig stores `?*CommandLineReporter` (raw, untracked); the
-        // reporter is the global `CommandLineReporter` owned by
+        // BunTest stores a backref to BunTestRoot, but the backref is the
+        // `stable_root` raw pointer above (not an `Rc`), so plain construction
+        // works without `Rc::new_cyclic`/two-phase init.
+        // The reporter is the global `CommandLineReporter` owned by
         // `test_command::exec` which outlives every `BunTest`. `exit_file()`
         // nulls this before the file is dropped.
         let reporter_ptr = NonNull::from(&mut *reporter);
@@ -633,11 +625,10 @@ pub struct BunTest {
     pub bun_test_root: bun_ptr::BackRef<BunTestRoot>,
     pub in_run_loop: bool,
     // gpa / arena_allocator / arena dropped — see §Allocators (non-AST crate)
-    // PERF(port): was arena bulk-free for per-file scratch
     pub file_id: FileId,
     /// null if the runner has moved on to the next file but a strong reference to BunTest is still keeping it alive
     ///
-    /// PORT NOTE: Zig stores `?*CommandLineReporter` (raw, mutable). Stored as
+    /// Stored as
     /// `NonNull` (not `&`) so callbacks (`handle_test_completed`, junit writer,
     /// uncaught-exception handler) can write through it without deriving `&mut`
     /// from `&` (UB). The reporter is owned by `test_command::exec`'s stack
@@ -686,8 +677,8 @@ impl BunTest {
             first_last,
             extra_execution_entries: Vec::new(),
             cloned_hook_entries: Vec::new(),
-            // PORT NOTE: `EventLoopTimer` has no `Default`; `init_paused` sets
-            // `next = EPOCH, state = PENDING` (matches Zig's zero-init).
+            // `EventLoopTimer` has no `Default`; `init_paused` sets
+            // `next = EPOCH, state = PENDING`.
             timer: EventLoopTimer::init_paused(EventLoopTimerTag::BunTest),
             wants_wakeup: false,
         }
@@ -751,7 +742,6 @@ impl BunTest {
         is_catch: bool,
     ) -> JsResult<()> {
         let _g = group_begin!();
-        // TODO(port): errdefer group.log("ended in error")
 
         let [result, this_ptr] = callframe.arguments_as_array::<2>();
         if this_ptr.is_empty_or_undefined_or_null() {
@@ -769,7 +759,7 @@ impl BunTest {
                 pending.swap_remove(pos);
             }
         }
-        // defer refdata.deref() — RefPtr<T> currently has NO Drop impl (src/ptr/ref_count.rs),
+        // refdata.deref() at scope exit — RefPtr<T> currently has NO Drop impl (src/ptr/ref_count.rs),
         // so scope-exit drop is a silent no-op. Decrement the intrusive count explicitly so
         // (a) RefData::destructor frees the box + Weak<BunTest>, and (b) a paired done() callback
         // observes has_one_ref()==true on its turn instead of hanging.
@@ -797,7 +787,7 @@ impl BunTest {
         Ok(())
     }
 
-    // PORT NOTE: `#[bun_jsc::host_fn]` proc-macro emits a free-fn wrapper that
+    // `#[bun_jsc::host_fn]` proc-macro emits a free-fn wrapper that
     // calls the annotated item by bare name; that lookup fails for associated
     // fns inside `impl` blocks. The extern-"C" trampoline is wired separately
     // (see the gated `Bun__TestScope__Describe2__*` statics below), so the
@@ -845,9 +835,9 @@ impl BunTest {
         let Some(ref_in) = ref_in else {
             return Ok(JSValue::UNDEFINED);
         };
-        // defer this.ref = null → already taken above
-        // defer ref_in.deref() — RefPtr<T> currently has NO Drop impl, so decrement the
-        // intrusive count explicitly at scope exit (mirrors .zig:472). Without this the
+        // `this.ref` was already taken above.
+        // RefPtr<T> currently has NO Drop impl, so decrement the
+        // intrusive count explicitly at scope exit. Without this the
         // paired promise then/catch path never sees has_one_ref()==true and the RefData leaks.
         let ref_in = scopeguard::guard(ref_in, |r: RefDataPtr| r.deref());
 
@@ -931,13 +921,11 @@ impl BunTest {
     }
 
     pub fn add_result(&mut self, result: RefDataValue) {
-        let _ = self.result_queue.write_item(result); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-        // PERF(port): was bun.handleOom — Vec/Deque push aborts on OOM
+        let _ = self.result_queue.write_item(result); // OOM/capacity: fire-and-forget
     }
 
     pub fn run(this_strong: &BunTestPtr, global_this: &JSGlobalObject) -> JsResult<()> {
         let _g = group_begin!();
-        // Zig: `const this = this_strong.get().?` — a freely-aliasing `*BunTest`.
         // `Collection::step` / `Execution::step` re-enter and call `.get()` on
         // the same `Rc`, so we keep a raw `*mut` (via `UnsafeCell`) and reborrow
         // per-use instead of holding one long-lived `&mut` that would alias.
@@ -952,7 +940,7 @@ impl BunTest {
             }
             (*this).in_run_loop = true;
         }
-        // Zig: `defer this.in_run_loop = false`. The guard captures the raw ptr
+        // The guard captures the raw ptr
         // (not a `&mut bool`) so no `&mut` is held across the loop body.
         let _reset = scopeguard::guard(this, |p| {
             // SAFETY: `p` is the same `UnsafeCell`-derived ptr; `this_strong`
@@ -1010,7 +998,7 @@ impl BunTest {
                 bun_core::scoped_log!(bun_test_group, "-> removing existing timer");
                 vm_timer().remove(&raw mut self.timer);
             }
-            // PORT NOTE: `EventLoopTimer.next` uses the event-loop crate's local
+            // `EventLoopTimer.next` uses the event-loop crate's local
             // `Timespec` (distinct from `bun_core::Timespec`); convert by field.
             self.timer.next = ElTimespec { sec: min_timeout.sec, nsec: min_timeout.nsec };
             if self.timer.next != ElTimespec::EPOCH {
@@ -1028,9 +1016,8 @@ impl BunTest {
     fn _advance(&mut self, _global_this: &JSGlobalObject) -> JsResult<Advance> {
         let _g = group_begin!();
         bun_core::scoped_log!(bun_test_group, "advance from {}", <&'static str>::from(self.phase));
-        // PORT NOTE: capture `self.phase` by raw ptr so the deferred log doesn't
-        // hold a `&self` borrow across the `self.phase = …` writes below
-        // (Zig `defer` closes over `*BunTest` by pointer, not by borrow).
+        // capture `self.phase` by raw ptr so the deferred log doesn't
+        // hold a `&self` borrow across the `self.phase = …` writes below.
         let phase_ptr: *const Phase = &raw const self.phase;
         scopeguard::defer! {
             // SAFETY: `self` outlives this guard (drops at end of this fn body).
@@ -1068,16 +1055,14 @@ impl BunTest {
                 } else {
                     None
                 };
-                // PORT NOTE: Zig `prng.random()` yields a `std.Random` interface
-                // wrapper; the Rust `Order::Config.randomize` takes the PRNG
-                // itself (`Option<DefaultPrng>`), so pass it through directly.
+                // `Order::Config.randomize` takes the PRNG itself
+                // (`Option<DefaultPrng>`), so pass it through directly.
                 let should_randomize = per_file_prng.take();
 
                 let mut order = Order::Order::init(Order::Config {
                     always_use_hooks: self.collection.root_scope.base.only == Only::No && !has_filter,
                     randomize: should_randomize,
                 });
-                // defer order.deinit() → Drop
 
                 let root = self.bun_test_root.get();
                 let beforeall_order: Order::AllOrderResult = if self.first_last.first {
@@ -1115,7 +1100,7 @@ impl BunTest {
                 };
                 afterall_order.set_failure_skip_to(&mut order);
 
-                self.execution.load_from_order(&mut order)?;
+                self.execution.load_from_order(&mut order);
                 debug::dump_order(&self.execution)?;
                 Ok(Advance::Cont)
             }
@@ -1205,7 +1190,7 @@ impl BunTest {
             }
         }
 
-        // Zig: `var dcb_ref: ?*RefData = null;` — a raw observer alias, NOT a
+        // `dcb_ref` is a raw observer alias, NOT a
         // counted handle. The single +1 from `ref()` is owned by
         // `dcb_data.ref`; `dcb_ref` just remembers the address so the
         // pending-promise branch can `dupe()` it and the tail can branch on
@@ -1245,8 +1230,8 @@ impl BunTest {
                         let this_ref: RefDataPtr = if let Some(dcb_ref_value) = dcb_ref {
                             // SAFETY: `dcb_ref_value` aliases the live RefData
                             // owned by `dcb_data.r#ref` (set just above; GC
-                            // roots `done_callback` for this frame). Zig:
-                            // `dcb_ref_value.dupe()` — bump 1→2.
+                            // roots `done_callback` for this frame). Bump the
+                            // refcount 1→2.
                             unsafe { bun_ptr::IntrusiveRc::init_ref(dcb_ref_value.as_ptr()) }
                         } else {
                             Self::ref_(this_strong, cfg_data)
@@ -1374,14 +1359,9 @@ impl Drop for BunTest {
             let _ = unsafe { Box::from_raw(entry.cast::<core::mem::ManuallyDrop<ExecutionEntry>>()) };
         }
         // execution, collection, result_queue: dropped automatically
-        // PERF(port): was arena bulk-free (arena_allocator.deinit)
     }
 }
 
-// `export const Bun__TestScope__Describe2__bunTestThen = jsc.toJSHostFn(bunTestThen);`
-//
-// PORT NOTE: Zig's `export const X = jsc.toJSHostFn(f)` mints a *function*
-// symbol named `X` (the comptime wrapper is inlined into a fresh fn item).
 // `ZigGlobalObject::promiseHandlerID` (C++) compares the fn-ptr passed to
 // `JSValue::then` against `&Bun__TestScope__Describe2__bunTestThen` by
 // identity, so the Rust thunk MUST be the symbol itself — exporting a
@@ -1427,9 +1407,10 @@ pub struct EntryData {
 pub enum RefDataValue {
     Start,
     Collection {
-        // LIFETIMES.tsv: BORROW_PARAM &'a DescribeScope — but stored across async
-        // boundaries (promise .then); falling back to UNKNOWN-class NonNull.
-        // TODO(port): lifetime
+        // A borrowed `&'a DescribeScope` cannot work here: the pointer is stored
+        // across async boundaries (promise .then), so no thread-able lifetime
+        // exists. The scope is kept alive by the collection tree (Box-ed entries
+        // under root_scope, owned by BunTest) until Phase::Done.
         active_scope: core::ptr::NonNull<DescribeScope>,
     },
     Execution {
@@ -1448,7 +1429,7 @@ impl RefDataValue {
     pub fn sequence<'a>(&self, buntest: &'a mut BunTest) -> Option<&'a mut Execution::ExecutionSequence> {
         let RefDataValue::Execution { group_index, entry_data } = self else { return None };
         let entry_data = (*entry_data)?;
-        // PORT NOTE: reshaped for borrowck — `ConcurrentGroup::sequences_mut`
+        // reshaped for borrowck — `ConcurrentGroup::sequences_mut`
         // borrows `&mut Execution` while `group()` already holds a borrow into
         // `execution.groups`. Read `(sequence_start, sequence_end)` first, then
         // index `execution.sequences` directly.
@@ -1500,7 +1481,7 @@ impl fmt::Display for RefDataValue {
     }
 }
 
-// `bun.ptr.RefCount(RefData, "ref_count", #destroy, .{})` — intrusive single-thread refcount.
+// Intrusive single-thread refcount.
 #[derive(bun_ptr::RefCounted)]
 #[ref_count(destroy = Self::destroy)]
 pub struct RefData {
@@ -1534,8 +1515,9 @@ impl RefData {
 
 pub struct RunTestsTask {
     pub weak: BunTestPtrWeak,
+    // `GlobalRef` (not a borrow): the JSGlobalObject is stored across the task
+    // tick, and the VM keeps it alive until shutdown.
     pub global_this: GlobalRef,
-    // TODO(port): lifetime — JSGlobalObject borrow stored across task tick
     pub phase: RefDataValue,
 }
 impl RunTestsTask {
@@ -1548,8 +1530,7 @@ impl RunTestsTask {
         // SAFETY: `this` was produced by `heap::into_raw` in `run_next_tick` and
         // is invoked exactly once by `ManagedTask`; ownership is reclaimed here.
         let this = unsafe { bun_core::heap::take(this.as_ptr()) };
-        // defer bun.destroy(this) → Box drops at end of scope
-        // defer this.weak.deinit() → Weak drops with Box
+        // Box drops at end of scope; the Weak drops with it.
         let Some(strong) = this.weak.upgrade() else { return Ok(()) };
         if let Err(e) = BunTest::run(&strong, &this.global_this) {
             // SAFETY: `&mut` derived via `UnsafeCell` after `run` returned; sole
@@ -1579,7 +1560,7 @@ pub enum HandleUncaughtExceptionResult {
 }
 
 pub type ResultQueue = LinearFifo<RefDataValue, bun_collections::linear_fifo::DynamicBuffer<RefDataValue>>;
-// PORT NOTE: bun.LinearFifo(.Dynamic) → second generic is the buffer strategy.
+// bun.LinearFifo(.Dynamic) → second generic is the buffer strategy.
 
 pub enum StepResult {
     Waiting { timeout: Timespec },
@@ -1652,7 +1633,7 @@ pub enum ScopeMode {
 }
 
 impl ScopeMode {
-    /// Port of Zig `@tagName`.
+    /// Lowercase variant name (e.g. "skip", "filtered_out") for labels/diagnostics.
     pub fn tag_name(self) -> &'static str {
         match self {
             Self::Normal => "normal",
@@ -1672,7 +1653,7 @@ pub enum Only {
 }
 
 impl Only {
-    /// Port of Zig `@tagName`.
+    /// Lowercase variant name (e.g. "yes", "contains") for labels/diagnostics.
     pub fn tag_name(self) -> &'static str {
         match self {
             Self::No => "no",
@@ -1728,7 +1709,7 @@ impl BaseScope {
         self.has_callback = has_callback;
         if let Some(parent) = self.parent {
             // SAFETY: parent backref valid; tree is single-threaded and parent
-            // outlives child. `parent` is `*mut` (Zig: `?*DescribeScope`).
+            // outlives child.
             let parent = unsafe { &mut *parent };
             if self.only != Only::No {
                 parent.mark_contains_only();
@@ -1801,17 +1782,17 @@ impl DescribeScope {
         }
     }
 
+    /// Infallible: `Vec::push` aborts on OOM.
     pub fn append_describe(
         &mut self,
         name_not_owned: Option<&[u8]>,
         base: BaseScopeCfg,
-    ) -> JsResult<&mut DescribeScope> {
+    ) -> &mut DescribeScope {
         let mut child = Self::create(BaseScope::init(base, name_not_owned, Some(std::ptr::from_mut(self)), false));
         child.base.propagate(false);
         self.entries.push(TestScheduleEntry::Describe(child));
-        // TODO(port): narrow error set
         match self.entries.last_mut().unwrap() {
-            TestScheduleEntry::Describe(d) => Ok(&mut **d),
+            TestScheduleEntry::Describe(d) => &mut **d,
             _ => unreachable!(),
         }
     }
@@ -1996,13 +1977,10 @@ impl Default for RunOneResult {
 }
 
 pub use super::timers::fake_timers::FakeTimers;
-// PORT NOTE: Zig nested types (`Execution.ConcurrentGroup`, `Order.Cfg`, …) are
-// top-level items in the sibling Rust modules. Alias the *modules* under the
-// Zig struct names so `Execution::ConcurrentGroup` / `Order::AllOrderResult`
+// Module aliases so `Execution::ConcurrentGroup` / `Order::AllOrderResult`
 // resolve as module paths without per-reference rewrites.
 pub use super::execution as Execution;
 pub use super::debug;
 pub use super::scope_functions as ScopeFunctions;
 pub use super::order as Order;
 
-// ported from: src/test_runner/bun_test.zig
diff --git a/src/runtime/test_runner/debug.rs b/src/runtime/test_runner/debug.rs
index 66a6f444907..74486c9399d 100644
--- a/src/runtime/test_runner/debug.rs
+++ b/src/runtime/test_runner/debug.rs
@@ -23,9 +23,9 @@ pub(crate) fn dump_describe(describe: &DescribeScope) -> JsResult<()> {
     if !group::get_log_enabled() {
         return Ok(());
     }
-    // TODO(port): std.zig.fmtString escaping — using BStr Debug-ish display for now
+    // `BStr`'s `Debug` impl quotes and escapes the name.
     let _guard = group::begin_msg(format_args!(
-        "describe \"{}\" (concurrent={}, mode={}, only={}, has_callback={})",
+        "describe {:?} (concurrent={}, mode={}, only={}, has_callback={})",
         bstr::BStr::new(describe.base.name.as_deref().unwrap_or(b"(unnamed)")),
         describe.base.concurrent,
         describe.base.mode.tag_name(),
@@ -56,7 +56,7 @@ pub(crate) fn dump_test(current: &ExecutionEntry, label: &[u8]) -> JsResult<()>
         return Ok(());
     }
     let _guard = group::begin_msg(format_args!(
-        "{} \"{}\" (concurrent={}, only={})",
+        "{} {:?} (concurrent={}, only={})",
         bstr::BStr::new(label),
         bstr::BStr::new(current.base.name.as_deref().unwrap_or(b"(unnamed)")),
         current.base.concurrent,
@@ -86,7 +86,7 @@ pub(crate) fn dump_order(this: &Execution) -> JsResult<()> {
             let mut current_entry: Option<NonNull<ExecutionEntry>> = sequence.first_entry;
             while let Some(entry_ptr) = current_entry {
                 // SAFETY: linked-list nodes are owned by the Execution and remain valid for the
-                // duration of this read-only dump (Zig: ?*ExecutionEntry walked via .next).
+                // duration of this read-only dump.
                 let entry = unsafe { entry_ptr.as_ref() };
                 group::log(format_args!(
                     "ExecutionEntry \"{}\" (concurrent={}, mode={}, only={}, has_callback={})",
@@ -114,7 +114,7 @@ pub mod group {
         let _ = write!(writer, "\x1b[m");
     }
 
-    // PORT NOTE: Zig used plain mutable globals; using atomics for Rust safety (debug-only path).
+    // Atomics for safety (debug-only path).
     static INDENT: AtomicUsize = AtomicUsize::new(0);
     static LAST_WAS_START: AtomicBool = AtomicBool::new(false);
 
@@ -138,7 +138,6 @@ pub mod group {
     }
 
     /// RAII guard returned by [`begin`] / [`begin_msg`]; calls [`end`] on drop.
-    /// Mirrors Zig's `group.beginMsg(...); defer group.end();` pattern.
     #[must_use = "binding this guard keeps the log group open until end of scope"]
     pub(crate) struct GroupGuard(());
 
@@ -148,9 +147,8 @@ pub mod group {
         }
     }
 
-    /// Port of Zig's `begin(@src())`. Uses `#[track_caller]` so the source
-    /// location is taken from the *call site* (file/line/column), matching
-    /// `std.builtin.SourceLocation` minus `fn_name` (Rust has no stable equivalent).
+    /// Uses `#[track_caller]` so the source
+    /// location is taken from the *call site* (file/line/column).
     #[track_caller]
     pub(crate) fn begin() -> GroupGuard {
         let loc = core::panic::Location::caller();
@@ -176,8 +174,7 @@ pub mod group {
             LAST_WAS_START.store(true, Ordering::Relaxed);
         }
         // Guard returned unconditionally; `end()` is itself gated on
-        // `get_log_enabled()` so the disabled path stays a symmetric no-op
-        // (matches Zig's unconditional `defer group.end()`).
+        // `get_log_enabled()` so the disabled path stays a symmetric no-op.
         GroupGuard(())
     }
 
@@ -186,10 +183,10 @@ pub mod group {
             return;
         }
         INDENT.fetch_sub(1, Ordering::Relaxed);
-        // Zig: `defer last_was_start = false;` — read-then-clear, so a single swap suffices.
+        // Read-then-clear, so a single swap suffices.
         let last_was_start = LAST_WAS_START.swap(false, Ordering::Relaxed);
         if last_was_start {
-            return; // std.fs.File.stdout().writer().print("\x1b[A", .{}) catch {};
+            return;
         }
 
         let mut buf: Vec<u8> = Vec::new();
@@ -204,7 +201,7 @@ pub mod group {
     }
 
     /// Accepts anything `Display` so callers can pass either `&str` literals or
-    /// `format_args!(...)` (Zig's `log(fmt, args)` is variadic; Rust callers use both forms).
+    /// `format_args!(...)`.
     pub(crate) fn log(args: impl fmt::Display) {
         if !get_log_enabled() {
             return;
@@ -217,5 +214,3 @@ pub mod group {
         LAST_WAS_START.store(false, Ordering::Relaxed);
     }
 }
-
-// ported from: src/test_runner/debug.zig
diff --git a/src/runtime/test_runner/diff/diff_match_patch.rs b/src/runtime/test_runner/diff/diff_match_patch.rs
index 549204d1851..8eb3737caba 100644
--- a/src/runtime/test_runner/diff/diff_match_patch.rs
+++ b/src/runtime/test_runner/diff/diff_match_patch.rs
@@ -99,7 +99,6 @@ impl fmt::Display for Diff<u8> {
     }
 }
 
-/// Zig: `pub fn DMP(comptime Unit: type) type { return struct { ... } }`
 #[derive(Clone, Copy)]
 pub(crate) struct DiffMatchPatch<Unit: DiffUnit> {
     pub config: Config,
@@ -108,10 +107,8 @@ pub(crate) struct DiffMatchPatch<Unit: DiffUnit> {
 
 pub(crate) type DiffList<Unit> = Vec<Diff<Unit>>;
 
-/// Zig: `pub const DiffError = error{OutOfMemory};`
 pub(crate) type DiffError = AllocError;
 
-/// Zig: `const DMPUsize = DMP(usize);`
 pub(crate) type DmpUsize = DiffMatchPatch<usize>;
 
 impl<Unit: DiffUnit> Default for DiffMatchPatch<Unit> {
@@ -148,9 +145,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
         self.diff_internal(before, after, check_lines, deadline)
     }
 
-    // Zig `deinitDiffList` / `freeRangeDiffList` deleted: bodies only freed owned
-    // `Box<[Unit]>` fields (now handled by `Drop`); range-free callsites inlined as `drain`.
-
     fn diff_internal(
         &self,
         before: &[Unit],
@@ -165,7 +159,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
                 let mut diffs: DiffList<Unit> = Vec::new();
                 if !before.is_empty() {
                     diffs.reserve(1);
-                    // PERF(port): was assume_capacity
                     diffs.push(Diff {
                         operation: Operation::Equal,
                         text: dupe(before),
@@ -193,7 +186,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
 
         if !common_prefix.is_empty() {
             diffs.reserve(1);
-            // PERF(port): was insertAssumeCapacity
             diffs.insert(
                 0,
                 Diff {
@@ -204,7 +196,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
         }
         if !common_suffix.is_empty() {
             diffs.reserve(1);
-            // PERF(port): was assume_capacity
             diffs.push(Diff {
                 operation: Operation::Equal,
                 text: dupe(common_suffix),
@@ -266,7 +257,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
             } else {
                 Operation::Insert
             };
-            // PERF(port): was assume_capacity
             diffs.push(Diff {
                 operation: op,
                 text: dupe(&long_text[0..index]),
@@ -316,7 +306,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
 
             // Merge the results.
             diffs.reserve(1);
-            // PERF(port): was assume_capacity
             diffs.push(Diff {
                 operation: Operation::Equal,
                 text: half_match.common_middle,
@@ -507,7 +496,7 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
             }
 
             // Walk the front path one step.
-            // PERF(port): @intCast — bare `as usize` kept for v1/v2/before/after indexing
+            // Bare `as usize` kept for v1/v2/before/after indexing
             // in this hot Myers inner loop.
             let mut k1 = -d + k1start;
             while k1 <= d - k1end {
@@ -550,7 +539,7 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
             }
 
             // Walk the reverse path one step.
-            // PERF(port): @intCast — bare `as usize` kept for v1/v2/before/after indexing
+            // Bare `as usize` kept for v1/v2/before/after indexing
             // in this hot Myers inner loop.
             let mut k2: isize = -d + k2start;
             while k2 <= d - k2end {
@@ -699,7 +688,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
                     // Upon reaching an equality, check for prior redundancies.
                     if count_delete >= 1 && count_insert >= 1 {
                         // Delete the offending records and add the merged ones.
-                        // PORT NOTE: Zig freeRangeDiffList + replaceRangeAssumeCapacity → drain
                         diffs.drain(
                             pointer - count_delete - count_insert
                                 ..pointer - count_delete - count_insert
@@ -710,7 +698,6 @@ impl<Unit: DiffUnit> DiffMatchPatch<Unit> {
                         let sub_diff =
                             self.diff_internal(&text_delete, &text_insert, false, deadline)?;
                         let sub_len = sub_diff.len();
-                        // PERF(port): was ensureUnusedCapacity + addManyAtAssumeCapacity + @memcpy
                         diffs.splice(pointer..pointer, sub_diff);
                         pointer += sub_len;
                     }
@@ -737,12 +724,11 @@ pub(crate) struct HalfMatchResult<Unit: DiffUnit> {
 }
 // `deinit` → Drop handles `Box<[Unit]>` fields automatically.
 
-pub(crate) struct LinesToCharsResult<Unit: DiffUnit> {
+pub(crate) struct LinesToCharsResult<'a, Unit: DiffUnit> {
     pub chars_1: Box<[usize]>,
     pub chars_2: Box<[usize]>,
-    // TODO(port): lifetime — borrows slices from the input texts; raw ptr here
-    // (no struct lifetime params). May promote to BORROW_PARAM in LIFETIMES.tsv.
-    pub line_array: Vec<*const [Unit]>,
+    /// Borrows line slices from the input texts.
+    pub line_array: Vec<&'a [Unit]>,
 }
 // `deinit` → Drop handles all fields automatically.
 
@@ -753,20 +739,20 @@ pub(crate) struct LinesToCharsResult<Unit: DiffUnit> {
 /// @return Three element Object array, containing the encoded text1, the
 ///     encoded text2 and the List of unique strings.  The zeroth element
 ///     of the List of unique strings is intentionally blank.
-pub(crate) fn diff_lines_to_chars<Unit: DiffUnit>(
-    text1: &[Unit],
-    text2: &[Unit],
-) -> Result<LinesToCharsResult<Unit>, DiffError> {
-    let mut line_array: Vec<*const [Unit]> = Vec::new();
-    // TODO(port): `bun.StringHashMapUnmanaged(usize)` keyed by borrowed `&[u8]` —
-    // `bun_collections::StringHashMap` may need a `&[u8]`-borrowing variant.
+pub(crate) fn diff_lines_to_chars<'a, Unit: DiffUnit>(
+    text1: &'a [Unit],
+    text2: &'a [Unit],
+) -> Result<LinesToCharsResult<'a, Unit>, DiffError> {
+    let mut line_array: Vec<&'a [Unit]> = Vec::new();
+    // `bun_collections::StringHashMap` copies each key into an owned
+    // `Box<[u8]>` (one allocation per unique line).
     let mut line_hash: StringHashMap<usize> = StringHashMap::default();
     // e.g. line_array[4] == "Hello\n"
     // e.g. line_hash.get("Hello\n") == 4
 
     // "\x00" is a valid character, but various debuggers don't like it.
     // So we'll insert a junk entry to avoid generating a null character.
-    line_array.push(std::ptr::from_ref::<[Unit]>(&[]));
+    line_array.push(&[]);
 
     // Allocate 2/3rds of the space for text1, the rest for text2.
     let chars1 = diff_lines_to_chars_munge(text1, &mut line_array, &mut line_hash)?;
@@ -785,9 +771,9 @@ pub(crate) fn diff_lines_to_chars<Unit: DiffUnit>(
 /// @param lineHash Map of strings to indices.
 /// @param maxLines Maximum length of lineArray.
 /// @return Encoded string.
-fn diff_lines_to_chars_munge<Unit: DiffUnit>(
-    text: &[Unit],
-    line_array: &mut Vec<*const [Unit]>,
+fn diff_lines_to_chars_munge<'a, Unit: DiffUnit>(
+    text: &'a [Unit],
+    line_array: &mut Vec<&'a [Unit]>,
     line_hash: &mut StringHashMap<usize>,
 ) -> Result<Box<[usize]>, DiffError> {
     if TypeId::of::<Unit>() != TypeId::of::<u8>() {
@@ -820,10 +806,10 @@ fn diff_lines_to_chars_munge<Unit: DiffUnit>(
                 line = &text[usize::try_from(line_start).unwrap()..];
                 line_end = isize::try_from(text.len()).unwrap();
             }
-            line_array.push(std::ptr::from_ref::<[Unit]>(line));
+            line_array.push(line);
             // Unit == u8 verified above; bytemuck statically checks the layout.
             let line_u8: &[u8] = bytemuck::cast_slice::<Unit, u8>(line);
-            // TODO(port): StringHashMap key ownership — Zig stored a borrowed slice.
+            // `put_assume_capacity` copies the key into an owned `Box<[u8]>`.
             line_hash.put_assume_capacity(line_u8, line_array.len() - 1);
             chars.push(line_array.len() - 1);
         }
@@ -838,7 +824,7 @@ fn diff_lines_to_chars_munge<Unit: DiffUnit>(
 /// @param lineArray List of unique strings.
 pub(crate) fn diff_chars_to_lines<Unit: DiffUnit>(
     char_diffs: &DiffList<usize>,
-    line_array: &[*const [Unit]],
+    line_array: &[&[Unit]],
 ) -> Result<DiffList<Unit>, DiffError> {
     let mut diffs: DiffList<Unit> = Vec::with_capacity(char_diffs.len());
     let mut text: Vec<Unit> = Vec::new();
@@ -846,11 +832,9 @@ pub(crate) fn diff_chars_to_lines<Unit: DiffUnit>(
     for d in char_diffs.iter() {
         let mut j: usize = 0;
         while j < d.text.len() {
-            // SAFETY: line_array entries borrow from input texts which outlive this call.
-            text.extend_from_slice(unsafe { &*line_array[d.text[j]] });
+            text.extend_from_slice(line_array[d.text[j]]);
             j += 1;
         }
-        // PERF(port): was assume_capacity
         diffs.push(Diff {
             operation: d.operation,
             text: core::mem::take(&mut text).into_boxed_slice(),
@@ -908,7 +892,6 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                                 nt.extend_from_slice(&text_insert[0..common_length]);
                                 diffs[ii].text = nt.into_boxed_slice();
                             } else {
-                                // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                                 diffs.insert(
                                     0,
                                     Diff {
@@ -922,7 +905,7 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                             text_delete.drain(0..common_length);
                         }
                         // Factor out any common suffixies.
-                        // @ZigPort this seems very wrong
+                        // TODO: this seems very wrong
                         common_length = diff_common_suffix(&text_insert, &text_delete);
                         if common_length != 0 {
                             diffs[pointer].text = concat(&[
@@ -936,12 +919,10 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                     // Delete the offending records and add the merged ones.
                     pointer -= count_delete + count_insert;
                     if count_delete + count_insert > 0 {
-                        // PORT NOTE: freeRangeDiffList + replaceRangeAssumeCapacity → drain
                         diffs.drain(pointer..pointer + count_delete + count_insert);
                     }
 
                     if !text_delete.is_empty() {
-                        // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                         diffs.insert(
                             pointer,
                             Diff {
@@ -952,7 +933,6 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                         pointer += 1;
                     }
                     if !text_insert.is_empty() {
-                        // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                         diffs.insert(
                             pointer,
                             Diff {
@@ -1008,7 +988,6 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                 diffs[pointer].text = pt;
                 let p1t = concat(&[&diffs[pointer - 1].text, &diffs[pointer + 1].text]);
                 diffs[pointer + 1].text = p1t;
-                // PORT NOTE: freeRangeDiffList + replaceRangeAssumeCapacity → remove
                 diffs.remove(pointer - 1);
                 changes = true;
             } else if diffs[pointer].text.starts_with(&diffs[pointer + 1].text) {
@@ -1017,7 +996,6 @@ pub(crate) fn diff_cleanup_merge<Unit: DiffUnit>(
                 let next_len = diffs[pointer + 1].text.len();
                 let pt = concat(&[&diffs[pointer].text[next_len..], &diffs[pointer + 1].text]);
                 diffs[pointer].text = pt;
-                // PORT NOTE: freeRangeDiffList + replaceRangeAssumeCapacity → remove
                 diffs.remove(pointer + 1);
                 changes = true;
             }
@@ -1041,7 +1019,7 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
     // Stack of indices where equalities are found.
     let mut equalities: Vec<isize> = Vec::new();
     // Always equal to equalities[equalitiesLength-1][1]
-    // PORT NOTE: reshaped for borrowck — owned copy of last_equality
+    // reshaped for borrowck — owned copy of last_equality
     let mut last_equality: Option<Box<[Unit]>> = None;
     let mut pointer: isize = 0; // Index of current position.
     // Number of characters that changed prior to the equality.
@@ -1075,7 +1053,6 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
                 {
                     let eq_idx = usize::try_from(equalities[equalities.len() - 1]).unwrap();
                     // Duplicate record.
-                    // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                     diffs.insert(
                         eq_idx,
                         Diff {
@@ -1123,7 +1100,7 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
     while usize::try_from(pointer).unwrap() < diffs.len() {
         let p = usize::try_from(pointer).unwrap();
         if diffs[p - 1].operation == Operation::Delete && diffs[p].operation == Operation::Insert {
-            // PORT NOTE: reshaped for borrowck — take owned copies of deletion/insertion
+            // reshaped for borrowck — take owned copies of deletion/insertion
             let deletion: Box<[Unit]> = core::mem::take(&mut diffs[p - 1].text);
             let insertion: Box<[Unit]> = core::mem::take(&mut diffs[p].text);
             let overlap_length1: usize = diff_common_overlap(&deletion, &insertion);
@@ -1134,7 +1111,6 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
                 {
                     // Overlap found.
                     // Insert an equality and trim the surrounding edits.
-                    // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                     diffs.insert(
                         p,
                         Diff {
@@ -1146,7 +1122,7 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
                     diffs[p + 1].text = dupe(&insertion[overlap_length1..]);
                     pointer += 1;
                 } else {
-                    // PORT NOTE: restore taken values (no-op in Zig).
+                    // restore taken values.
                     diffs[p - 1].text = deletion;
                     diffs[p].text = insertion;
                 }
@@ -1156,7 +1132,6 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
                 {
                     // Reverse overlap found.
                     // Insert an equality and swap and trim the surrounding edits.
-                    // PERF(port): was ensureUnusedCapacity + insertAssumeCapacity
                     diffs.insert(
                         p,
                         Diff {
@@ -1172,7 +1147,7 @@ pub(crate) fn diff_cleanup_semantic<Unit: DiffUnit>(
                     diffs[p + 1].text = new_plus;
                     pointer += 1;
                 } else {
-                    // PORT NOTE: restore taken values (no-op in Zig).
+                    // restore taken values.
                     diffs[p - 1].text = deletion;
                     diffs[p].text = insertion;
                 }
@@ -1221,7 +1196,6 @@ pub(crate) fn diff_cleanup_semantic_lossless<Unit: DiffUnit>(
                 edit.extend_from_slice(&common_string);
                 edit.extend_from_slice(&not_common);
 
-                // Zig: equality_2.insertSlice(0, common_string)
                 equality_2.splice(0..0, common_string.iter().copied());
             }
 
@@ -1431,7 +1405,6 @@ fn diff_common_suffix<Unit: DiffUnit>(before: &[Unit], after: &[Unit]) -> usize
     n
 }
 
-// TODO(port): replace with bun_core time source. `std::time` not on the I/O ban list.
 fn milli_timestamp() -> u64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
@@ -1502,15 +1475,6 @@ mod tests {
         ); // Unicode
     }
 
-    // TODO(port): the Zig source has ~1400 lines of additional tests for
-    // diffHalfMatch, diffLinesToChars, diffCharsToLines, diffCleanupMerge,
-    // diffCleanupSemanticLossless, rebuildtexts, diffBisect, diff,
-    // diffLineMode, diffCleanupSemantic, diffCleanupEfficiency. They were
-    // wrapped in `checkAllAllocationFailures` (Zig OOM-injection harness)
-    // which has no Rust equivalent (global allocator aborts on OOM). Port
-    // the assertions directly; the test data is preserved in the
-    // .zig source.
-
     fn rebuildtexts(diffs: &DiffList<u8>) -> [Box<[u8]>; 2] {
         let mut text: [Vec<u8>; 2] = [Vec::new(), Vec::new()];
         for my_diff in diffs.iter() {
@@ -1589,5 +1553,3 @@ mod tests {
         );
     }
 }
-
-// ported from: src/test_runner/diff/diff_match_patch.zig
diff --git a/src/runtime/test_runner/diff/printDiff.rs b/src/runtime/test_runner/diff/printDiff.rs
index d5afae65754..e63f70810ad 100644
--- a/src/runtime/test_runner/diff/printDiff.rs
+++ b/src/runtime/test_runner/diff/printDiff.rs
@@ -51,7 +51,6 @@ pub fn print_diff_main(
     writer: &mut impl Write,
     config: &DiffConfig,
 ) -> std::fmt::Result {
-    // PERF(port): was arena bulk-free — all intermediate Vecs below were arena-allocated in Zig.
     if not {
         match config.enable_ansi_colors {
             true => write!(
@@ -175,7 +174,7 @@ pub fn print_diff_main(
         diff_segments = new_diff_segments;
 
         // Forward pass: unskip segments after non-equal segments
-        // PORT NOTE: reshaped for borrowck (capture len before mutable slice borrow)
+        // reshaped for borrowck (capture len before mutable slice borrow)
         let len = diff_segments.len();
         for i in 0..len {
             if diff_segments[i].mode != DiffSegmentMode::Equal {
@@ -292,8 +291,8 @@ pub enum DiffSegmentMode {
     Modified,
 }
 
-// TODO(port): lifetime — `removed`/`inserted` borrow from caller input and diff_match_patch output;
-// in Zig these were arena-backed slices. Revisit ownership.
+// `removed`/`inserted` borrow from caller input and diff_match_patch output
+// (tracked by `'a`).
 #[derive(Copy, Clone)]
 pub struct DiffSegment<'a> {
     pub removed: &'a [u8],
@@ -396,7 +395,7 @@ fn print_truncated_line(
     }
 
     if config.enable_ansi_colors {
-        writer.write_str(colors::BRIGHT_WHITE)?; // preserve SGR 97 — Zig printDiff.zig:177
+        writer.write_str(colors::BRIGHT_WHITE)?; // preserve SGR 97
     }
     // The context is shown on both sides, so we truncate line.len - 2 * context
     write!(
@@ -643,7 +642,6 @@ pub fn print_diff(
     diff_segments: &[DiffSegment<'_>],
     config: &DiffConfig,
 ) -> std::fmt::Result {
-    // PERF(port): was arena bulk-free.
     let mut removed_line_number: usize = 1;
     let mut inserted_line_number: usize = 1;
     let mut removed_diff_lines: usize = 0;
@@ -653,8 +651,8 @@ pub fn print_diff(
 
     let mut was_skipped = false;
     for (i, segment) in diff_segments.iter().enumerate() {
-        // PORT NOTE: Zig `defer { removed_line_number += ...; inserted_line_number += ...; }` —
-        // applied at the end of the loop body and before `continue` below.
+        // `removed_line_number` / `inserted_line_number` are bumped at the end
+        // of the loop body and before `continue` below.
 
         if (was_skipped && !segment.skip) || (has_skipped_segments && i == 0 && !segment.skip) {
             // have to calculate the length of the non-skipped segment
@@ -682,7 +680,6 @@ pub fn print_diff(
             DiffSegmentMode::Equal => {
                 if segment.skip {
                     was_skipped = true;
-                    // defer:
                     removed_line_number += segment.removed_line_count;
                     inserted_line_number += segment.inserted_line_count;
                     continue;
@@ -715,7 +712,6 @@ pub fn print_diff(
             }
         }
 
-        // defer:
         removed_line_number += segment.removed_line_count;
         inserted_line_number += segment.inserted_line_count;
     }
@@ -724,5 +720,3 @@ pub fn print_diff(
 
     print_diff_footer(writer, config, removed_diff_lines, inserted_diff_lines)
 }
-
-// ported from: src/test_runner/diff/printDiff.zig
diff --git a/src/runtime/test_runner/diff_format.rs b/src/runtime/test_runner/diff_format.rs
index d193a6c7d41..cc2650028c9 100644
--- a/src/runtime/test_runner/diff_format.rs
+++ b/src/runtime/test_runner/diff_format.rs
@@ -44,7 +44,6 @@ impl<'a> fmt::Display for DiffFormatter<'a> {
                 flush: false,
                 quote_strings: true,
             };
-            // Zig: @as([*]const JSValue, @ptrCast(&received)), 1  → 1-element slice
             let _ = JestPrettyFormat::format(
                 MessageLevel::Debug,
                 global_this,
@@ -87,7 +86,7 @@ impl<'a> fmt::Display for DiffFormatter<'a> {
 /// C++ bridge for `BunAnalyzeTranspiledModule.cpp` — renders a diff between the
 /// JSC-parsed module record and Bun's transpiler output when they disagree.
 ///
-/// Ported from `src/bundler_jsc/analyze_jsc.zig`. Lives here (not in
+/// Lives here (not in
 /// `bun_bundler_jsc::analyze_jsc`) because `DiffFormatter` is a `bun_runtime`
 /// type and `bun_bundler_jsc` is a lower-tier crate that cannot depend on it;
 /// the `extern "C"` symbol resolves the same at link time regardless of which
@@ -112,8 +111,5 @@ pub(crate) extern "C" fn zig__renderDiff(
         global_this: Some(global_this),
         ..Default::default()
     };
-    // Zig: `Output.errorWriter().print("DIFF:\n{any}\n", .{formatter}) catch {};`
     let _ = bun_core::output::error_writer().print(format_args!("DIFF:\n{}\n", formatter));
 }
-
-// ported from: src/test_runner/diff_format.zig
diff --git a/src/runtime/test_runner/expect.rs b/src/runtime/test_runner/expect.rs
index 4412f2728f1..bcfd3b587de 100644
--- a/src/runtime/test_runner/expect.rs
+++ b/src/runtime/test_runner/expect.rs
@@ -43,8 +43,8 @@ pub struct Expect {
 }
 
 
-// PORT NOTE: Zig `enum(u2)`; Rust has no `u2`. Stored packed inside `Flags(u8)`
-// bits 0..2, so `repr(u8)` here only governs the standalone discriminant size.
+// Stored packed inside `Flags(u8)` bits 0..2, so `repr(u8)` here only
+// governs the standalone discriminant size.
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, Default)]
 pub enum Promise {
@@ -70,7 +70,6 @@ pub enum AsymmetricMatcherConstructorType {
     InstanceOf = 9,
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn AsymmetricMatcherConstructorType__fromJS(
         global_object: *const JSGlobalObject,
@@ -83,7 +82,7 @@ impl AsymmetricMatcherConstructorType {
         // C++ side opens `DECLARE_THROW_SCOPE` and returns -1 ⟺ threw; under
         // `BUN_JSC_validateExceptionChecks=1` its dtor sets `m_needExceptionCheck`, so
         // open a validation scope here and assert the sentinel/exception biconditional
-        // (Zig: `bun.cpp.AsymmetricMatcherConstructorType__fromJS` is `zero_is_throw`-shaped
+        // (`AsymmetricMatcherConstructorType__fromJS` is `zero_is_throw`-shaped
         // with -1 as the sentinel).
         bun_jsc::validation_scope!(scope, global_object);
         // SAFETY: FFI call with valid &JSGlobalObject; JSValue is Copy/repr(transparent)
@@ -108,7 +107,7 @@ impl AsymmetricMatcherConstructorType {
 }
 
 /// note: keep this struct in sync with C++ implementation (at bindings.cpp)
-// Zig: packed struct(u8) { promise: u2, not: bool, asymmetric_matcher_constructor_type: u5 }
+// Bit layout: promise (bits 0..2), not (bit 2), asymmetric_matcher_constructor_type (bits 3..8).
 #[repr(transparent)]
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
 pub struct Flags(pub u8);
@@ -123,9 +122,8 @@ impl Flags {
 
     #[inline]
     pub fn promise(self) -> Promise {
-        // PORT NOTE: Zig `enum(u2)` tolerates the unused bit pattern 3 inside a
-        // packed struct; Rust does not — transmuting an out-of-range
-        // discriminant is instant UB. `Flags` is fed from C++ via
+        // The unused bit pattern 3 is representable in the packed bits but
+        // is not a valid discriminant — transmuting it would be instant UB. `Flags` is fed from C++ via
         // `from_bitset`/`decode`, so the bits are not statically constrained.
         match self.0 & Self::PROMISE_MASK {
             1 => Promise::Resolves,
@@ -148,9 +146,8 @@ impl Flags {
     }
     #[inline]
     pub fn asymmetric_matcher_constructor_type(self) -> AsymmetricMatcherConstructorType {
-        // PORT NOTE: Zig `enum(u5)` with 10 variants — values 10..=31 are
-        // representable in the packed bits but are not valid Rust
-        // discriminants, and `Flags` arrives from C++ via `from_bitset`, so
+        // Values 10..=31 are representable in the packed bits but are not
+        // valid discriminants, and `Flags` arrives from C++ via `from_bitset`, so
         // a checked match is required (transmute would be UB).
         match self.0 >> Self::AMCT_SHIFT {
             0 => AsymmetricMatcherConstructorType::None,
@@ -204,10 +201,9 @@ impl Expect {
         } else {
             // in concurrent group or otherwise failed to get the sequence; increment the expect call count in the reporter directly
             if let Some(reporter) = buntest.reporter {
-                // SAFETY: Zig source mutates `reporter.summary()` directly; the
-                // field is `Option<NonNull<CommandLineReporter>>` (Zig
-                // `?*CommandLineReporter`), owned by `test_command` for the
-                // process lifetime, never aliased mutably elsewhere here.
+                // SAFETY: `reporter` is `Option<NonNull<CommandLineReporter>>`,
+                // owned by `test_command` for the process lifetime, never
+                // aliased mutably elsewhere here.
                 unsafe {
                     let s = (*reporter.as_ptr()).summary();
                     s.expectations = s.expectations.saturating_add(1);
@@ -226,13 +222,11 @@ impl Expect {
         args: &'static str,
         not: bool,
     ) -> &'static str {
-        // .zig:103-109 comptime-concats `received ++ [not.] ++ matcher_name ++ (args)`
-        // into rodata. Rust has no comptime string concat across runtime call
-        // sites (all ~188 callers pass literals, but the `not` bool is runtime
+        // Rust has no compile-time string concat across runtime call sites (all ~188 callers pass literals, but the `not` bool is runtime
         // in some), so emulate via a process-lifetime intern table: each
         // unique (matcher, args, not) triple is rendered exactly once and the
-        // boxed str is owned by the static `CACHE` for the rest of the process
-        // — same lifetime semantics as the Zig comptime result. Returning
+        // boxed str is owned by the static `CACHE` for the rest of the
+        // process. Returning
         // `&'static str` keeps the ~188 call sites and `throw()`'s `signature:
         // &'static str` parameter unchanged.
         use bun_collections::HashMap;
@@ -266,16 +260,13 @@ impl Expect {
         matcher_name: impl fmt::Display,
         matcher_params: impl fmt::Display,
         flags: Flags,
-        // PORT NOTE: Zig took `comptime message_fmt: string` + `message_args` and
-        // concatenated `message_fmt` onto the signature template before
-        // substitution. Rust can't splice runtime args into a const format
+        // Rust can't splice runtime args into a const format
         // string, so callers pre-render the message body (prose + args) into a
         // single `fmt::Arguments` here. `<tag>` markers in the rendered body
         // are still rewritten by `throw_pretty`'s post-render `pretty_fmt_rt`
         // pass, so the prose may contain `<r>`/`<red>`/etc.
         message: fmt::Arguments<'_>,
     ) -> JsError {
-        // PERF(port): was comptime bool dispatch on Output.enable_ansi_colors_stderr — profile if hot.
         let colors = Output::enable_ansi_colors_stderr();
         let chain: &'static str = match flags.promise() {
             Promise::Resolves => {
@@ -316,13 +307,8 @@ impl Expect {
                 }
             }
         };
-        // PERF(port): was comptime bool dispatch on use_default_label — profile if hot.
-        // PORT NOTE: expect.zig:119-128 binds `use_default_label = !custom_label.isEmpty()`
-        // and so prints the *signature* when a custom label is present and the
-        // (empty) `{custom_label}` when it is absent — a misnamed variable in
-        // the Zig spec. The condition below intentionally matches the correct
-        // semantics of `Expect.throw` (expect.zig:373-379) instead: empty label
-        // → default signature header, non-empty label → user's label header.
+        // Matches the semantics of `Expect.throw`: empty label → default
+        // signature header, non-empty label → user's label header.
         if custom_label.is_empty() {
             global_this.throw_pretty(format_args!(
                 "<d>expect(<r><red>received<r><d>).<r>{chain}{matcher_name}<d>(<r>{matcher_params}<d>)<r>\n\n{message}",
@@ -332,7 +318,7 @@ impl Expect {
         }
     }
 
-    // PORT NOTE: `host_fn(getter)` shim passes `(&Self, &JSGlobalObject)` only,
+    // `host_fn(getter)` shim passes `(&Self, &JSGlobalObject)` only,
     // but these getters also need `this_value` (returned to JS for chaining).
     // The shim is omitted (codegen owns the actual link name). R-2: mutation
     // of `flags` goes through `Cell` so the receiver is `&Self`.
@@ -341,7 +327,7 @@ impl Expect {
         this_value
     }
 
-    // PORT NOTE: see `get_not` — `host_fn(getter)` shim signature mismatch.
+    // see `get_not` — `host_fn(getter)` shim signature mismatch.
     pub fn get_resolves(
         this: &Self,
         this_value: JSValue,
@@ -356,7 +342,7 @@ impl Expect {
         Ok(this_value)
     }
 
-    // PORT NOTE: see `get_not` — `host_fn(getter)` shim signature mismatch.
+    // see `get_not` — `host_fn(getter)` shim signature mismatch.
     pub fn get_rejects(
         this: &Self,
         this_value: JSValue,
@@ -375,8 +361,8 @@ impl Expect {
         &self,
         global_this: &JSGlobalObject,
         this_value: JSValue,
-        // PORT NOTE: Zig took `[]const u8`; every caller passes a string literal,
-        // so accept `&str` (BStr::new below takes `AsRef<[u8]>`, so no copy).
+        // Every caller passes a string literal, so accept `&str`
+        // (BStr::new below takes `AsRef<[u8]>`, so no copy).
         matcher_name: &str,
         matcher_params_fmt: &'static str,
     ) -> JsResult<JSValue> {
@@ -388,8 +374,7 @@ impl Expect {
         };
         value.ensure_still_alive();
 
-        // PERF(port): was comptime bool dispatch — profile if hot.
-        #[allow(clippy::disallowed_methods)] // template is a runtime parameter (Zig comptime param)
+        #[allow(clippy::disallowed_methods)] // template is a runtime parameter
         let matcher_params = Output::pretty_fmt_rt(matcher_params_fmt, Output::enable_ansi_colors_stderr());
         Self::process_promise(
             self.custom_label.clone(),
@@ -414,7 +399,6 @@ impl Expect {
         matcher_params: impl fmt::Display,
         silent: bool,
     ) -> JsResult<JSValue> {
-        // PERF(port): was comptime monomorphization on `silent` and `resolution` — profile if hot.
         match flags.promise() {
             resolution @ (Promise::Resolves | Promise::Rejects) => {
                 if let Some(promise) = value.as_any_promise() {
@@ -563,7 +547,6 @@ impl Expect {
     }
 
     pub fn get_snapshot_name(&self, hint: &[u8]) -> Result<Vec<u8>, bun_core::Error> {
-        // TODO(port): narrow error set
         let parent = self.parent.as_ref().ok_or_else(|| bun_core::err!("NoTest"))?;
         let buntest_strong = parent.bun_test().ok_or_else(|| bun_core::err!("TestNotActive"))?;
         let buntest = buntest_strong.get();
@@ -628,7 +611,6 @@ impl Expect {
     #[allow(clippy::boxed_local)]
     pub fn finalize(mut self: Box<Self>) {
         self.custom_label.deref();
-        // .zig:331 `if (this.parent) |parent| parent.deref();`
         // RefDataPtr = RefPtr<RefData> has NO `Drop` impl (src/ptr/ref_count.rs)
         // so the Box drop below would leak the +1 — release explicitly.
         if let Some(parent) = self.parent.take() {
@@ -636,7 +618,7 @@ impl Expect {
         }
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let arguments_ = callframe.arguments_old::<2>();
         let arguments = arguments_.slice();
@@ -660,9 +642,10 @@ impl Expect {
         } else {
             None
         };
-        // errdefer: scopeguard would deinit active_execution_entry_ref on error;
-        // here ownership moves into Expect on success, and Box drop handles error path.
-        // TODO(port): errdefer — verify no leak path between here and to_js()
+        // The ref
+        // moves into `Expect` below and `to_js()` is infallible, so there is no
+        // error path between ref creation and the wrapper taking ownership; from
+        // then on `Expect::finalize` derefs `parent` (RefDataPtr has no Drop).
 
         let expect = Expect {
             flags: Cell::new(Flags::default()),
@@ -693,10 +676,8 @@ impl Expect {
         signature: &'static str,
         args: fmt::Arguments<'_>,
     ) -> JsResult<JSValue> {
-        // TODO(port): Zig comptime-concats `signature ++ fmt` into a single
-        // pretty template; Rust has no comptime string concat across runtime
-        // call sites, so render at runtime. Revisit with const_format if the
-        // matcher set ever passes literal-only fmt strings.
+        // No compile-time string concat across runtime call sites, so
+        // render at runtime.
         Err(if self.custom_label.is_empty() {
             global_this.throw_pretty(format_args!("{signature}{args}"))
         } else {
@@ -705,7 +686,7 @@ impl Expect {
     }
 
     /// Legacy 4-arg form used by a handful of internal call sites in this file
-    /// (snapshot/mock helpers) that were ported with a separate `fmt` literal.
+    /// (snapshot/mock helpers) that take a separate `fmt` literal.
     /// Folds `fmt` into `args` and delegates.
     #[inline]
     pub fn throw_fmt(
@@ -715,10 +696,9 @@ impl Expect {
         _fmt: &'static str,
         args: fmt::Arguments<'_>,
     ) -> JsResult<JSValue> {
-        // `_fmt` was the Zig comptime template tail (e.g. "\n\n{s}\n"). Rust
-        // cannot interpolate a runtime-literal format string, so every caller
-        // bakes the rendered tail (literal text + substitutions) into `args`
-        // and passes the original Zig template here only for documentation.
+        // Rust cannot interpolate a runtime-literal format string, so every
+        // caller bakes the rendered tail (literal text + substitutions) into
+        // `args`; `_fmt` is kept only for documentation.
         // If `args` is empty but `_fmt` is not, a caller forgot to migrate.
         debug_assert!(
             _fmt.is_empty() || args.as_str() != Some(""),
@@ -727,7 +707,7 @@ impl Expect {
         self.throw(global_this, signature, args)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn constructor(global_this: &JSGlobalObject, _frame: &CallFrame) -> JsResult<*mut Expect> {
         Err(global_this.throw(format_args!("expect() cannot be called with new")))
     }
@@ -739,7 +719,7 @@ impl Expect {
         global_this: &JSGlobalObject,
         call_frame: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: `defer this.postMatch(globalThis)` — guard owns the `&Self` and calls
+        // The guard owns the `&Self` and calls
         // post_match on drop so it runs on every exit path.
         let this = scopeguard::guard(self, |t| t.post_match(global_this));
 
@@ -786,7 +766,7 @@ impl Expect {
         global_this: &JSGlobalObject,
         call_frame: &CallFrame,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: `defer this.postMatch(globalThis)` — guard owns the `&Self` borrow
+        // The guard owns the `&Self` borrow
         // so `post_match` runs on every exit.
         let this = scopeguard::guard(self, |t| t.post_match(global_this));
 
@@ -921,7 +901,7 @@ impl Expect {
         trimmed_buf: &'a mut [u8],
     ) -> TrimResult<'a> {
         debug_assert!(trimmed_buf.len() == str_in.len());
-        // PORT NOTE: reshaped for borrowck — track dst as an index into trimmed_buf instead of a moving slice
+        // reshaped for borrowck — track dst as an index into trimmed_buf instead of a moving slice
         let mut src = str_in;
         let trimmed_buf_len = trimmed_buf.len();
         let mut dst_idx: usize = 0;
@@ -942,7 +922,6 @@ impl Expect {
             .position(|&ch| ch != b' ' && ch != b'\t')
             .unwrap_or(src.len());
         let indent_str = &src[..indent_len];
-        // TODO(port): give_up_2 borrows both str_in and indent_str; with dst_idx tracking we can rebuild it at each return site
         macro_rules! give_up_2 {
             () => {
                 TrimResult { trimmed: str_in, start_indent: Some(indent_str), end_indent: Some(indent_str) }
@@ -1008,11 +987,10 @@ impl Expect {
         // done
         TrimResult {
             trimmed: &trimmed_buf[..trimmed_buf_len - (trimmed_buf_len - dst_idx)],
-            // PORT NOTE: equivalent to trimmed_buf[0 .. trimmed_buf.len - dst.len]; with index tracking dst.len == trimmed_buf_len - dst_idx
+            // equivalent to trimmed_buf[0 .. trimmed_buf.len - dst.len]; with index tracking dst.len == trimmed_buf_len - dst_idx
             start_indent: Some(indent_str),
             end_indent: Some(&str_in[end_indent..]),
         }
-        // TODO(port): borrowck — returning slices of both str_in and trimmed_buf; verify lifetime 'a covers both
     }
 
     pub fn inline_snapshot(
@@ -1062,7 +1040,6 @@ impl Expect {
             } else {
                 runner.snapshots.failed += 1;
                 let signature = Self::get_signature(fn_name, "<green>expected<r>", false);
-                // TODO(port): comptime string concatenation signature ++ "\n\n{f}\n"
                 let diff_format = DiffFormatter {
                     received_string: Some(&pretty_value),
                     expected_string: Some(trim_res.trimmed),
@@ -1099,12 +1076,12 @@ impl Expect {
 
             // 1. find the src loc of the snapshot
             let srcloc = call_frame.get_caller_src_loc(global_this);
-            // .zig:763 `defer srcloc.str.deref();` — bun_core::String is Copy
+            // bun_core::String is Copy
             // with no Drop, so wrap in the RAII guard to release the +1 on
             // every exit path (including the early returns below).
             let _srcloc_str_guard = bun_core::OwnedString::new(srcloc.str);
             let file_id = buntest.file_id;
-            // PORT NOTE: MultiArrayList::get requires MultiArrayElement (derive pending);
+            // MultiArrayList::get requires MultiArrayElement (derive pending);
             // use the column accessor which already compiles in jest.rs.
             let fget_source_path_text = runner.files.items_source()[file_id as usize].path.text;
 
@@ -1118,7 +1095,7 @@ impl Expect {
                         "\n\n<b>Matcher error<r>: Inline snapshot matchers must be called from the test file:\n  Expected to be called from file: <green>{:?}<r>\n  {} called from file: <red>{:?}<r>\n",
                         bstr::BStr::new(fget_source_path_text),
                         fn_name,
-                        // TODO(port): std.zig.fmtString — escaped string display
+                        // `{:?}` on BStr renders a quoted, escaped string
                         bstr::BStr::new(srcloc.str.to_utf8().slice()),
                     ),
                 );
@@ -1159,7 +1136,6 @@ impl Expect {
             if !value.jest_deep_match(prop_matchers, global_this, true)? {
                 // TODO: print diff with properties from propertyMatchers
                 let signature = Self::get_signature(fn_name, "<green>propertyMatchers<r>", false);
-                // TODO(port): comptime string concatenation
                 let mut formatter = ConsoleObject::Formatter::new(global_this);
                 return Err(global_this.throw_pretty(format_args!(
                     "{signature}\n\nExpected <green>propertyMatchers<r> to match properties from received object\n\nReceived: {}\n",
@@ -1198,7 +1174,7 @@ impl Expect {
                     return Err(global_this.throw(format_args!("Snapshot matchers cannot be used outside of a test")));
                 };
                 let buntest = buntest_strong.get();
-                // PORT NOTE: MultiArrayList::get requires MultiArrayElement (derive pending); use column accessor.
+                // MultiArrayList::get requires MultiArrayElement (derive pending); use column accessor.
                 let test_file_path = runner.files.items_source()[buntest.file_id as usize].path.text;
                 let test_file_path = bstr::BStr::new(test_file_path);
                 return Err(match err {
@@ -1244,7 +1220,7 @@ impl Expect {
         };
 
         if let Some(saved_value) = existing_value {
-            // PORT NOTE: clone to owned to release the &mut borrow on runner.snapshots
+            // clone to owned to release the &mut borrow on runner.snapshots
             // before mutating passed/failed counters below.
             let saved_value: Vec<u8> = saved_value.to_vec();
             if strings::eql_long(&pretty_value, &saved_value, true) {
@@ -1254,7 +1230,6 @@ impl Expect {
 
             runner.snapshots.failed += 1;
             let signature = Self::get_signature(fn_name, "<green>expected<r>", false);
-            // TODO(port): comptime string concatenation signature ++ "\n\n{f}\n"
             let diff_format = DiffFormatter {
                 received_string: Some(&pretty_value),
                 expected_string: Some(&saved_value),
@@ -1267,7 +1242,7 @@ impl Expect {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
     pub fn get_static_not(
         global_this: &JSGlobalObject,
         _: JSValue,
@@ -1278,7 +1253,7 @@ impl Expect {
         ExpectStatic::create(global_this, f)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
     pub fn get_static_resolves_to(
         global_this: &JSGlobalObject,
         _: JSValue,
@@ -1289,7 +1264,7 @@ impl Expect {
         ExpectStatic::create(global_this, f)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen; static getter has no `&self`.
     pub fn get_static_rejects_to(
         global_this: &JSGlobalObject,
         _: JSValue,
@@ -1300,43 +1275,43 @@ impl Expect {
         ExpectStatic::create(global_this, f)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn any(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectAny::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn anything(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectAnything::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn close_to(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectCloseTo::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn object_containing(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectObjectContaining::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn string_containing(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectStringContaining::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn string_matching(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectStringMatching::call(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn array_containing(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         ExpectArrayContaining::call(global_this, call_frame)
     }
 
     /// Implements `expect.extend({ ... })`
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn extend(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args_ = call_frame.arguments_old::<1>();
         let args = args_.slice();
@@ -1387,9 +1362,8 @@ impl Expect {
                 // Even though they point to the same native functions for all matchers,
                 // multiple instances are created because each instance will hold the matcher_fn as a property
 
-                // PORT NOTE: Zig used `toJSHostFn(applyCustomMatcher)` (comptime fn-ptr
-                // wrapping). Rust's `to_js_host_fn` returns an opaque closure, so emit
-                // an explicit C-ABI shim and pass its address.
+                // `to_js_host_fn` returns an opaque closure, so emit an
+                // explicit C-ABI shim and pass its address.
                 bun_jsc::jsc_host_abi! {
                     unsafe fn __apply_custom_matcher_shim(
                         g: *mut bun_jsc::JSGlobalObject,
@@ -1403,9 +1377,8 @@ impl Expect {
                 let host_fn_ptr: bun_jsc::JSHostFn = __apply_custom_matcher_shim;
                 // SAFETY: FFI call with valid global, &bun_core::String, host-fn ptr, and JSValue.
                 // C++ takes the function pointer **by value** (`NativeFunctionPtr`), not a
-                // pointer-to-function-pointer — the Zig `*const jsc.JSHostFn` is itself the
-                // function-pointer type (Zig fn types aren't pointers), whereas Rust's
-                // `JSHostFn` already is, so pass it directly.
+                // pointer-to-function-pointer — `JSHostFn` already is the
+                // function-pointer type, so pass it directly.
                 let wrapper_fn = unsafe {
                     Bun__JSWrappingFunction__create(
                         global_this,
@@ -1436,8 +1409,7 @@ impl Expect {
     ) -> JsError {
         let mut formatter = ConsoleObject::Formatter::new(global_this).with_quote_strings(true);
 
-        // PERF(port): was comptime bool dispatch on `Output.enable_ansi_colors_stderr` —
-        // template has no `<tag>` markers so the runtime branch is a no-op anyway.
+        // The template has no `<tag>` markers so the colors branch is a no-op anyway.
         let err = global_this.create_error_instance(format_args!(
             "Unexpected return from matcher function `{}`.\n\
              Matcher functions should return an object in the following format:\n  \
@@ -1446,12 +1418,12 @@ impl Expect {
             matcher_name,
             result.to_fmt(&mut formatter),
         ));
-        // TODO(port): handle JsResult from toJS in throw path
-        err.put(
-            global_this,
-            b"name",
-            bun_core::String::static_("InvalidMatcherError").to_js(global_this).unwrap_or(JSValue::UNDEFINED),
-        );
+        match bun_core::String::static_("InvalidMatcherError").to_js(global_this) {
+            Ok(name) => err.put(global_this, b"name", name),
+            // An exception (e.g. OOM) is already pending from to_js; propagate it
+            // instead of throwing the partially-constructed error.
+            Err(js_err) => return js_err,
+        }
         global_this.throw_value(err)
     }
 
@@ -1467,7 +1439,7 @@ impl Expect {
         silent: bool,
     ) -> JsResult<bool> {
         // prepare the this object
-        // PORT NOTE: JsClass::to_js takes `self` by value and boxes internally.
+        // JsClass::to_js takes `self` by value and boxes internally.
         let matcher_context_jsvalue = ExpectMatcherContext { flags }.to_js(global_this);
         matcher_context_jsvalue.ensure_still_alive();
 
@@ -1528,7 +1500,6 @@ impl Expect {
         if pass || silent { return Ok(pass); }
 
         // handle failure
-        // .zig:1100-1101 `var message_text = bun.String.dead; defer message_text.deref();`
         // bun_core::String is Copy with no Drop, so wrap in OwnedString to
         // release the +1 returned by to_bun_string/from_js on scope exit.
         let message_text: bun_core::OwnedString = if message.is_undefined() {
@@ -1540,7 +1511,7 @@ impl Expect {
                 debug_assert!(message.is_callable()); // checked above
             }
 
-            // .zig:1112 `callWithGlobalThis` — pass the global object itself as `this`.
+            // Pass the global object itself as `this`.
             let message_result = message.call_with_global_this(global_this, &[])?;
             bun_core::OwnedString::new(bun_core::String::from_js(message_result, global_this)?)
         };
@@ -1562,7 +1533,7 @@ impl Expect {
 
     /// Function that is run for either `expect.myMatcher()` call or `expect().myMatcher` call,
     /// and we can known which case it is based on if the `callFrame.this()` value is an instance of Expect
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn apply_custom_matcher(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         // SAFETY: bun_vm() returns the live VM pointer for this global.
         let _gc = global_this.bun_vm().as_mut().auto_gc_on_drop();
@@ -1623,8 +1594,7 @@ impl Expect {
 
         // prepare the args array
         let args = call_frame.arguments();
-        // PERF(port): was stack-fallback allocator — profile if hot.
-        // PORT NOTE: MarkedArgumentBuffer::new is scoped (closure-borrow); collect into a Vec
+        // MarkedArgumentBuffer::new is scoped (closure-borrow); collect into a Vec
         // since execute_custom_matcher takes &[JSValue].
         let mut matcher_args: Vec<JSValue> = Vec::with_capacity(args.len() + 1);
         matcher_args.push(value);
@@ -1637,14 +1607,14 @@ impl Expect {
         Ok(this_value)
     }
 
-    // Zig: `pub const addSnapshotSerializer = notImplementedStaticFn;` — Rust has no associated
-    // const-fn aliases that satisfy `Expect::add_snapshot_serializer(..)` UFCS, so forward.
+    // Rust has no associated const-fn aliases that satisfy
+    // `Expect::add_snapshot_serializer(..)` UFCS, so forward.
     #[inline]
     pub fn add_snapshot_serializer(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         Self::not_implemented_static_fn(global_this, call_frame)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn has_assertions(global_this: &JSGlobalObject, _call_frame: &CallFrame) -> JsResult<JSValue> {
         // SAFETY: bun_vm() returns the live VM pointer for this global.
         let _gc = global_this.bun_vm().as_mut().auto_gc_on_drop();
@@ -1664,7 +1634,7 @@ impl Expect {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn assertions(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         // SAFETY: bun_vm() returns the live VM pointer for this global.
         let _gc = global_this.bun_vm().as_mut().auto_gc_on_drop();
@@ -1720,7 +1690,7 @@ impl Expect {
         Err(global_this.throw(format_args!("Not implemented")))
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn not_implemented_static_fn(global_this: &JSGlobalObject, _: &CallFrame) -> JsResult<JSValue> {
         Err(global_this.throw(format_args!("Not implemented")))
     }
@@ -1730,7 +1700,7 @@ impl Expect {
         Err(global_this.throw(format_args!("Not implemented")))
     }
 
-    // PORT NOTE: Zig `notImplementedStaticProp` is a static-prop getter
+    // `not_implemented_static_prop` is a static-prop getter
     // (`(globalThis, JSValue, JSValue)`, no `*Expect` receiver). The
     // `host_fn(getter)` shape was wrong (it injects `&Self`). Unreferenced by
     // codegen today, so kept as a plain assoc fn matching the static ABI.
@@ -1742,7 +1712,7 @@ impl Expect {
         global_this.bun_vm().auto_garbage_collect();
     }
 
-    /// RAII for Zig's `defer this.postMatch(globalThis)`. The returned guard holds the
+    /// The returned guard holds the
     /// `&Expect` borrow, re-lends it via `Deref`, and calls `post_match` on drop so every
     /// exit path (success, `?`, explicit `return Err`) triggers the GC sweep.
     pub fn post_match_guard<'a>(&'a self, global: &'a JSGlobalObject) -> PostMatchGuard<'a> {
@@ -1777,7 +1747,7 @@ impl Expect {
         Ok((this, value, not))
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn do_unreachable(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let arg = callframe.arguments_old::<1>().ptr[0];
 
@@ -1798,8 +1768,8 @@ impl Expect {
 }
 
 /// RAII guard returned by [`Expect::post_match_guard`]. Holds an `&Expect` for the
-/// duration of a matcher body and runs `post_match` on drop — the Rust shape of Zig's
-/// `defer this.postMatch(globalThis)` shared by every `expect().toX()` matcher.
+/// duration of a matcher body and runs `post_match` on drop —
+/// shared by every `expect().toX()` matcher.
 /// R-2: shared borrow only (no `DerefMut`); all `Expect` methods reachable from a
 /// matcher body take `&self`.
 pub struct PostMatchGuard<'a> {
@@ -1887,9 +1857,9 @@ impl ExpectStatic {
         Ok(value)
     }
 
-    // PORT NOTE: codegen passes `(&mut *this, this_value, global)` for `this: true` getters
+    // codegen passes `(&mut *this, this_value, global)` for `this: true` getters
     // (jest.classes.ts); the `#[host_fn(getter)]` proc-macro emits a 2-arg shim, so we drop
-    // it here and match the generated signature directly. `this_value` is unused (Zig ignores it).
+    // it here and match the generated signature directly. `this_value` is unused.
     pub fn get_not(this: &Self, _this_value: JSValue, global_this: &JSGlobalObject) -> JsResult<JSValue> {
         let mut flags = this.flags;
         flags.set_not(!this.flags.not());
@@ -2026,8 +1996,8 @@ impl_asymmetric_matcher_class!(
 
 // ─── unary-predicate matcher scaffold ────────────────────────────────────
 // Dedups the 22 hand-rolled `expect/toBe*.rs` files (~1270 LOC → ~300 LOC) and
-// fixes two latent port bugs (throw_fmt wrapper drop; post_match-before-throw
-// ordering). Mirrors the Zig per-file scaffold exactly.
+// fixes two latent bugs (throw_fmt wrapper drop; post_match-before-throw
+// ordering).
 impl Expect {
     /// Shared scaffold for zero-arg `expect(v).toBeX()` matchers whose pass/fail
     /// is a pure infallible predicate on the received `JSValue` and whose failure
@@ -2068,7 +2038,7 @@ impl Expect {
     /// `increment_expect_call_counter`, UTF-8 slice + predicate, `not`-xor, dual
     /// formatter, `get_signature`, `throw`.
     ///
-    /// Normalizes the inherited Zig inconsistency where `toInclude` passed `""`
+    /// Normalizes an inherited inconsistency where `toInclude` passed `""`
     /// to `get_value`'s `matcher_params` while the other two passed
     /// `"<green>expected<r>"` — all three now use the latter (matches the
     /// signature already used in their failure messages).
@@ -2143,14 +2113,14 @@ impl Expect {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Shared skeleton for the 8 jest-extended `toContain{Key,Keys,AllKeys,AnyKeys,
-// Value,Values,AllValues,AnyValues}` matchers. ~70% of each Zig body was the
+// Value,Values,AllValues,AnyValues}` matchers. ~70% of each matcher body was the
 // same boilerplate (post_match defer, arg-count check, expect-counter,
 // get_value, `.not` flip, dual-formatter failure throw); only the pass-loop
 // differs. Sibling to `run_unary_predicate` / `run_string_affix_matcher`.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Where `expected.is_array()` runs relative to `get_value` — observable when
-/// both would throw (Keys-family Zig validates *after*, Values-family *before*).
+/// both would throw (Keys-family validates *after*, Values-family *before*).
 #[derive(Clone, Copy)]
 pub enum ExpectedArray {
     /// `toContainKey` / `toContainValue`: scalar `expected`, no array check.
@@ -2197,8 +2167,7 @@ impl Expect {
     /// [`ExpectedArray`]), `.not` flip, and the dual-formatter failure throw —
     /// and delegates only the per-matcher pass-loop to `body`.
     ///
-    /// On pass, returns `frame.this()` (the original Zig matchers all returned
-    /// `thisValue`, not `undefined`).
+    /// On pass, returns `frame.this()` (`thisValue`, not `undefined`).
     pub fn contain_matcher(
         &self,
         global: &JSGlobalObject,
@@ -2365,7 +2334,7 @@ pub struct ExpectAnything {
 }
 
 impl ExpectAnything {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, _: &CallFrame) -> JsResult<JSValue> {
         let anything_js_value = ExpectAnything { flags: Cell::new(Flags::default()) }.to_js(global_this);
         anything_js_value.ensure_still_alive();
@@ -2382,7 +2351,7 @@ pub struct ExpectStringMatching {
 }
 
 impl ExpectStringMatching {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args = call_frame.arguments();
 
@@ -2407,7 +2376,7 @@ pub struct ExpectCloseTo {
 }
 
 impl ExpectCloseTo {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args_buf = call_frame.arguments_old::<2>();
         let args = args_buf.slice();
@@ -2446,7 +2415,7 @@ pub struct ExpectObjectContaining {
 }
 
 impl ExpectObjectContaining {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args_buf = call_frame.arguments_old::<1>();
         let args = args_buf.slice();
@@ -2472,7 +2441,7 @@ pub struct ExpectStringContaining {
 }
 
 impl ExpectStringContaining {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args_buf = call_frame.arguments_old::<1>();
         let args = args_buf.slice();
@@ -2498,7 +2467,7 @@ pub struct ExpectAny {
 }
 
 impl ExpectAny {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let _arguments = call_frame.arguments_old::<1>();
         let arguments: &[JSValue] = &_arguments.ptr[.._arguments.len];
@@ -2544,7 +2513,7 @@ pub struct ExpectArrayContaining {
 }
 
 impl ExpectArrayContaining {
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, call_frame: &CallFrame) -> JsResult<JSValue> {
         let args_buf = call_frame.arguments_old::<1>();
         let args = args_buf.slice();
@@ -2647,10 +2616,8 @@ impl ExpectCustomAsymmetricMatcher {
 
         // prepare the args array as `[received, ...captured_args]`
         let args_count = captured_args.get_length(global_this)?;
-        // PERF(port): was stack-fallback allocator — profile if hot.
         let mut matcher_args: Vec<JSValue> = Vec::with_capacity((args_count as usize).saturating_add(1));
         matcher_args.push(received);
-        // PERF(port): was assume_capacity
         for i in 0..args_count {
             matcher_args.push(captured_args.get_index(global_this, i as u32)?);
         }
@@ -2687,7 +2654,6 @@ impl ExpectCustomAsymmetricMatcher {
             global_this.clear_exception();
             return Ok(false);
         }
-        // TODO(port): narrow error set (JsError → bun_core::Error mapping)
         match err {
             JsError::OutOfMemory => Err(bun_core::Error::OUT_OF_MEMORY),
             _ => Err(bun_core::Error::UNEXPECTED),
@@ -2702,7 +2668,6 @@ impl ExpectCustomAsymmetricMatcher {
         writer: &mut (impl bun_io::Write + ?Sized),
         dont_throw: bool,
     ) -> Result<bool, bun_core::Error> {
-        // TODO(port): narrow error set (mixes JsError and io::Error)
         let Some(matcher_fn) = expect_custom_asymmetric_matcher_js::matcher_fn_get_cached(this_value) else { return Ok(false) };
         let fn_value = match matcher_fn.get(global_this, "toAsymmetricMatcher") {
             Ok(v) => v,
@@ -2711,7 +2676,6 @@ impl ExpectCustomAsymmetricMatcher {
         if let Some(fn_value) = fn_value {
             if fn_value.js_type().is_function() {
                 let Some(captured_args) = expect_custom_asymmetric_matcher_js::captured_args_get_cached(this_value) else { return Ok(false) };
-                // PERF(port): was stack-fallback allocator — profile if hot.
                 let args_len = match captured_args.get_length(global_this) {
                     Ok(n) => n,
                     Err(e) => return Self::maybe_clear(global_this, e, dont_throw),
@@ -2723,7 +2687,7 @@ impl ExpectCustomAsymmetricMatcher {
                 };
                 loop {
                     match iter.next() {
-                        Ok(Some(arg)) => args.push(arg), // PERF(port): was assume_capacity
+                        Ok(Some(arg)) => args.push(arg),
                         Ok(None) => break,
                         Err(e) => return Self::maybe_clear(global_this, e, dont_throw),
                     }
@@ -2745,11 +2709,9 @@ impl ExpectCustomAsymmetricMatcher {
 
     #[bun_jsc::host_fn(method)]
     pub fn to_asymmetric_matcher(&self, global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
-        // PERF(port): was stack-fallback allocator — profile if hot.
         let mut mutable_string = bun_core::MutableString::init_2048()?;
 
-        // PORT NOTE: Zig call site (expect.zig:1772) omits the `comptime dontThrow`
-        // arg — dead/ill-typed in the spec. With `false`, JS exceptions surface
+        // With `false`, JS exceptions surface
         // through `maybe_clear` as `Error::UNEXPECTED` while remaining set on
         // the VM; only allocation failures map to OOM. Propagate accordingly
         // instead of clobbering with a fresh OutOfMemory throw.
@@ -2767,9 +2729,7 @@ impl ExpectCustomAsymmetricMatcher {
             let slice: &[u8] = mutable_string.slice();
             return bun_core::String::init(slice).to_js(global_this);
         }
-        // PORT NOTE: Zig (expect.zig:1776) passes `this: *ExpectCustomAsymmetricMatcher`
-        // where `printValue` expects a `JSValue` — dead/ill-typed in the spec.
-        // The intent is to pretty-print the matcher instance itself, available
+        // Pretty-print the matcher instance itself, available
         // here as `callframe.this()`.
         ExpectMatcherUtils::print_value(global_this, callframe.this(), None)
     }
@@ -2838,11 +2798,10 @@ impl ExpectMatcherUtils {
         color_or_null: Option<&'static str>,
     ) -> JsResult<JSValue> {
         use std::io::Write as _;
-        // TODO(port): narrow error set
-        // PERF(port): was stack-fallback allocator — profile if hot.
         let mut mutable_string = bun_core::MutableString::init_2048()?;
 
-        // TODO(port): BufferedWriter wrapper
+        // MutableString already writes to an in-memory Vec, so no extra
+        // buffering layer is needed.
         let writer = mutable_string.writer();
 
         if let Some(color) = color_or_null {
@@ -2911,7 +2870,7 @@ impl ExpectMatcherUtils {
                 (),
             ));
         }
-        // .zig:1907 `defer matcher_name.deref();` — `to_bun_string` returns +1;
+        // `to_bun_string` returns +1;
         // bun_core::String is `Copy` with no `Drop`, so wrap in `OwnedString`.
         let matcher_name = bun_core::OwnedString::new(arguments[0].to_bun_string(global_this)?);
 
@@ -2959,7 +2918,7 @@ impl ExpectMatcherUtils {
             not: is_not,
         };
 
-        // .zig:1948-1955 builds `getSignature("{f}", "<green>expected<r>", is_not) ++ "\n\n{f}\n"`
+        // Builds `getSignature("{f}", "<green>expected<r>", is_not) ++ "\n\n{f}\n"`
         // and substitutes `(matcher_name, diff_formatter)` into the two `{f}`
         // slots, then runs `Output.prettyFmt` over the *template* before
         // substitution. `pretty_fmt!` rewrites only the `<tag>` markers in
@@ -2967,7 +2926,6 @@ impl ExpectMatcherUtils {
         // `diff_formatter` are spliced in afterwards (matches `throw_pretty`'s
         // render-then-rewrite ordering, since Display output here contains no
         // `<tag>` literals).
-        // PERF(port): Zig used a 2048-byte stack-fallback MutableString — profile if hot.
         let colors = Output::enable_ansi_colors_stderr();
         let head: &'static str = if colors {
             bun_core::pretty_fmt!("<d>expect(<r><red>received<r><d>).<r>", true)
@@ -3017,11 +2975,11 @@ impl ExpectTypeOf {
         Self::create(global_this)
     }
 
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn constructor(global_this: &JSGlobalObject, _: &CallFrame) -> JsResult<*mut ExpectTypeOf> {
         Err(global_this.throw(format_args!("expectTypeOf() cannot be called with new")))
     }
-    // PORT NOTE: extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
+    // extern shim emitted by `#[bun_jsc::JsClass]` codegen (TypeClass__construct/__call); bare `#[host_fn]` cannot target an associated fn without a receiver.
     pub fn call(global_this: &JSGlobalObject, _: &CallFrame) -> JsResult<JSValue> {
         Self::create(global_this)
     }
@@ -3031,7 +2989,6 @@ pub mod mock {
     use super::*;
     use bun_jsc::ComptimeStringMapExt as _;
 
-    // TODO(port): move to <area>_sys
     // C++: `JSC::EncodedJSValue JSMockFunction__get{Calls,Returns}(
     //         JSC::JSGlobalObject*, EncodedJSValue)` — `[[ZIG_EXPORT(zero_is_throw)]]`.
     // The leading `globalThis` parameter is load-bearing: the body opens a
@@ -3151,14 +3108,14 @@ pub mod mock {
         Ok(value.get(global_this, "value")?.unwrap_or(JSValue::UNDEFINED))
     }
 
-    // PORT NOTE: split lifetimes — `&'a mut Formatter<'a>` is the invariant-borrow trap
+    // split lifetimes — `&'a mut Formatter<'a>` is the invariant-borrow trap
     // (forces the &mut to live as long as the Formatter's own param, which outlives the
     // local). `'g` tracks the JSGlobalObject borrow inside Formatter; `'a` is the short
     // &mut borrow held by this struct.
     pub(crate) struct AllCallsWithArgsFormatter<'a, 'g> {
         pub global_this: &'g JSGlobalObject,
         pub calls: JSValue,
-        // PORT NOTE: reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
+        // reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
         pub formatter: core::cell::RefCell<&'a mut ConsoleObject::Formatter<'g>>,
     }
 
@@ -3204,23 +3161,23 @@ pub mod mock {
     }
 
     impl ReturnStatus {
-        // Zig: bun.ComptimeEnumMap(ReturnStatus)
         pub(crate) const MAP: phf::Map<&'static [u8], ReturnStatus> = phf::phf_map! {
             b"throw" => ReturnStatus::Throw,
             b"return" => ReturnStatus::Return,
             b"incomplete" => ReturnStatus::Incomplete,
         };
-        // TODO(port): ComptimeEnumMap.fromJS — wrap phf lookup with JS string extraction
+        // JS string extraction + lookup is provided by `ComptimeStringMapExt::from_js`
+        // (see `jest_mock_return_object_type`).
     }
 
     // Formatter for when there are multiple returns or errors
-    // PORT NOTE: split lifetimes — `&'f mut Formatter<'g>` instead of `&'a mut Formatter<'a>`.
+    // split lifetimes — `&'f mut Formatter<'g>` instead of `&'a mut Formatter<'a>`.
     // The single-lifetime form makes the mut-borrow invariant in `'a` and forces the borrow to
     // last for the Formatter's whole lifetime, tripping dropck (E0597) at the call site.
     pub(crate) struct AllCallsFormatter<'g, 'f> {
         pub global_this: &'g JSGlobalObject,
         pub returns: JSValue,
-        // PORT NOTE: reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
+        // reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
         pub formatter: core::cell::RefCell<&'f mut ConsoleObject::Formatter<'g>>,
     }
 
@@ -3267,12 +3224,12 @@ pub mod mock {
         }
     }
 
-    // PORT NOTE: split lifetimes — see AllCallsFormatter above for rationale (avoids the
+    // split lifetimes — see AllCallsFormatter above for rationale (avoids the
     // `&'a mut T<'a>` invariance trap that locks the Formatter borrow for its entire life).
     pub struct SuccessfulReturnsFormatter<'g, 'f> {
         pub global_this: &'g JSGlobalObject,
         pub successful_returns: &'f Vec<JSValue>,
-        // PORT NOTE: reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
+        // reshaped for borrowck — Display::fmt takes &self but we need &mut Formatter
         pub formatter: core::cell::RefCell<&'f mut ConsoleObject::Formatter<'g>>,
     }
 
@@ -3305,14 +3262,12 @@ fn get_custom_matcher_fn(this_value: JSValue, global_this: &JSGlobalObject) -> O
     if matcher_fn.is_empty() { None } else { Some(matcher_fn) }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     fn Bun__JSWrappingFunction__create(
         global_this: *const JSGlobalObject,
         symbol_name: *const bun_core::String,
         // C++: `Bun::NativeFunctionPtr` — a bare `EncodedJSValue (*)(JSGlobalObject*, CallFrame*)`.
-        // Zig spells this `*const jsc.JSHostFn` because Zig fn types need a `*const` to
-        // become pointers; Rust's `JSHostFn` is already the pointer type, so no extra `*const`.
+        // Rust's `JSHostFn` is already the pointer type, so no extra `*const`.
         function_pointer: bun_jsc::JSHostFn,
         wrapped_fn: JSValue,
         strong: bool,
@@ -3391,8 +3346,4 @@ mod tests {
             "\n\"æ™\n\n!!!!*5897yhduN\"'\\`Il\"\n".as_bytes(),
         );
     }
-
-    // TODO(port): fuzz test — std.testing.fuzz(testOne, .{})
 }
-
-// ported from: src/test_runner/expect.zig
diff --git a/src/runtime/test_runner/expect/toBe.rs b/src/runtime/test_runner/expect/toBe.rs
index fdf0afb927d..3e257b363d4 100644
--- a/src/runtime/test_runner/expect/toBe.rs
+++ b/src/runtime/test_runner/expect/toBe.rs
@@ -34,11 +34,9 @@ impl Expect {
 
         // handle failure
         let mut formatter = super::make_formatter(global_this);
-        // `defer formatter.deinit()` — handled by Drop
+        // formatter cleanup handled by Drop
 
-        // Zig: `switch (this.custom_label.isEmpty()) { inline else => |has_custom_label| { ... } }`
-        // The comptime bool is only used to select a literal format string; demote to runtime.
-        // PERF(port): was comptime bool dispatch — profile if hot.
+        // The bool is only used to select a literal format string.
         let has_custom_label = this.custom_label.is_empty();
 
         if not {
@@ -52,8 +50,8 @@ impl Expect {
 
         let signature = Expect::get_signature("toBe", "<green>expected<r>", false);
         if left.jest_deep_equals(right, global_this)? || left.jest_strict_deep_equals(right, global_this)? {
-            // Zig builds `fmt` via comptime `++` on `has_custom_label`; Rust format strings must
-            // be literals, so branch the call instead.
+            // Rust format strings must be literals, so branch the call on
+            // `has_custom_label` instead.
             if !has_custom_label {
                 return this.throw(
                     global_this,
@@ -87,10 +85,10 @@ impl Expect {
             return this.throw(global_this, signature, format_args!("\n\n{}\n", diff_format));
         }
 
-        // PORT NOTE: Zig shares one `*Formatter` across both `toFmt` calls; in Rust the
-        // `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
-        // the same backing formatter. Use a second formatter for the received value —
-        // `make_formatter` is a trivial struct init with no shared state between values.
+        // The `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters
+        // cannot alias the same backing formatter. Use a second formatter for the
+        // received value — `make_formatter` is a trivial struct init with no shared
+        // state between values.
         let mut formatter2 = super::make_formatter(global_this);
         return this.throw(
             global_this,
@@ -104,4 +102,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBe.zig
diff --git a/src/runtime/test_runner/expect/toBeArray.rs b/src/runtime/test_runner/expect/toBeArray.rs
index 7ab6b141b16..734d9f5465e 100644
--- a/src/runtime/test_runner/expect/toBeArray.rs
+++ b/src/runtime/test_runner/expect/toBeArray.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_array, "toBeArray", |v| v.js_type().is_array());
-// ported from: src/test_runner/expect/toBeArray.zig
diff --git a/src/runtime/test_runner/expect/toBeArrayOfSize.rs b/src/runtime/test_runner/expect/toBeArrayOfSize.rs
index 38f8bfc8a01..464e5bdd543 100644
--- a/src/runtime/test_runner/expect/toBeArrayOfSize.rs
+++ b/src/runtime/test_runner/expect/toBeArrayOfSize.rs
@@ -2,14 +2,15 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_array_of_size(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // Zig: `defer this.postMatch(globalThis);`
-    // PORT NOTE: reshaped for borrowck — scopeguard::defer! would hold &mut *this for the whole fn.
+    // scopeguard::defer! would hold &mut *this for the whole fn, so use the
+    // post-match guard instead.
     let this = this.post_match_guard(global);
 
     let this_value = frame.this();
@@ -43,11 +44,9 @@ pub(crate) fn to_be_array_of_size(
     }
 
     let mut formatter = super::make_formatter(global);
-    // Zig: `defer formatter.deinit();` — handled by Drop.
     let received = value.to_fmt(&mut formatter);
 
     if not {
-        // PERF(port): was comptime getSignature.
         let signature = get_signature("toBeArrayOfSize", "", true);
         return this.throw_fmt(
             global,
@@ -57,7 +56,6 @@ pub(crate) fn to_be_array_of_size(
         );
     }
 
-    // PERF(port): was comptime getSignature.
     let signature = get_signature("toBeArrayOfSize", "", false);
     this.throw_fmt(
         global,
@@ -67,4 +65,3 @@ pub(crate) fn to_be_array_of_size(
     )
 }
 
-// ported from: src/test_runner/expect/toBeArrayOfSize.zig
diff --git a/src/runtime/test_runner/expect/toBeBoolean.rs b/src/runtime/test_runner/expect/toBeBoolean.rs
index a1ead0007b9..9442c7ff03b 100644
--- a/src/runtime/test_runner/expect/toBeBoolean.rs
+++ b/src/runtime/test_runner/expect/toBeBoolean.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_boolean, "toBeBoolean", |v| v.is_boolean());
-// ported from: src/test_runner/expect/toBeBoolean.zig
diff --git a/src/runtime/test_runner/expect/toBeCloseTo.rs b/src/runtime/test_runner/expect/toBeCloseTo.rs
index 6cff91dc1f4..ba133753732 100644
--- a/src/runtime/test_runner/expect/toBeCloseTo.rs
+++ b/src/runtime/test_runner/expect/toBeCloseTo.rs
@@ -73,10 +73,10 @@ impl Expect {
             return Ok(JSValue::UNDEFINED);
         }
 
-        // Zig shares one `*Formatter` (raw pointer) across both `toFmt` calls; in Rust
-        // `ZigFormatter` holds `&'a mut Formatter`, so two live adapters cannot alias the same
-        // backing formatter. Use a second formatter for the received value — `make_formatter` is
-        // a trivial struct init and the formatters carry no shared state between values.
+        // The `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters
+        // cannot alias the same backing formatter. Use a second formatter for the
+        // received value — `make_formatter` is a trivial struct init and the
+        // formatters carry no shared state between values.
         let mut formatter = super::make_formatter(global);
         let mut formatter2 = super::make_formatter(global);
         // `defer formatter.deinit()` — handled by Drop.
@@ -100,8 +100,7 @@ impl Expect {
             RECEIVED_DIFFERENCE,
         );
 
-        // TODO(refactor): Zig `this.throw(global, signature, fmt, .{args})` passes fmt-string +
-        // tuple separately. Rust `format_args!` requires a literal fmt string, so SUFFIX_FMT cannot
+        // TODO(refactor): `format_args!` requires a literal fmt string, so SUFFIX_FMT cannot
         // be threaded as a runtime arg. Decide `Expect::throw` signature — likely
         // `fn throw(&self, &JSGlobalObject, &str, fmt::Arguments) -> JsResult<JSValue>` and inline
         // SUFFIX_FMT into the `format_args!` call (or make `throw!` a macro).
@@ -131,4 +130,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeCloseTo.zig
diff --git a/src/runtime/test_runner/expect/toBeDate.rs b/src/runtime/test_runner/expect/toBeDate.rs
index ab7615631cc..40378a7dd46 100644
--- a/src/runtime/test_runner/expect/toBeDate.rs
+++ b/src/runtime/test_runner/expect/toBeDate.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_date, "toBeDate", |v| v.is_date());
-// ported from: src/test_runner/expect/toBeDate.zig
diff --git a/src/runtime/test_runner/expect/toBeDefined.rs b/src/runtime/test_runner/expect/toBeDefined.rs
index 526d74c0fa8..beb9c1a4368 100644
--- a/src/runtime/test_runner/expect/toBeDefined.rs
+++ b/src/runtime/test_runner/expect/toBeDefined.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_defined, "toBeDefined", |v| !v.is_undefined());
-// ported from: src/test_runner/expect/toBeDefined.zig
diff --git a/src/runtime/test_runner/expect/toBeEmpty.rs b/src/runtime/test_runner/expect/toBeEmpty.rs
index 4cb62050eee..aaf15206b21 100644
--- a/src/runtime/test_runner/expect/toBeEmpty.rs
+++ b/src/runtime/test_runner/expect/toBeEmpty.rs
@@ -4,7 +4,8 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSPropertyIterator, JSPropertyIteratorO
 
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_empty(
     this: &Expect,
     global: &JSGlobalObject,
@@ -44,8 +45,7 @@ pub(crate) fn to_be_empty(
                         "Expected value to be a string, object, or iterable"
                     )));
                 };
-                // Zig: `cell.toObject(globalThis)` — `value` is the same cell, so use the
-                // JSValue ToObject path directly.
+                // `value` is the same cell, so use the JSValue ToObject path directly.
                 let object = value.to_object(global)?;
                 let props_iter = JSPropertyIterator::init(
                     global,
@@ -107,4 +107,3 @@ pub(crate) fn to_be_empty(
     )))
 }
 
-// ported from: src/test_runner/expect/toBeEmpty.zig
diff --git a/src/runtime/test_runner/expect/toBeEmptyObject.rs b/src/runtime/test_runner/expect/toBeEmptyObject.rs
index 3ebc4f01046..ac1177a3f72 100644
--- a/src/runtime/test_runner/expect/toBeEmptyObject.rs
+++ b/src/runtime/test_runner/expect/toBeEmptyObject.rs
@@ -1,7 +1,8 @@
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_empty_object(
     this: &Expect,
     global: &JSGlobalObject,
@@ -39,4 +40,3 @@ pub(crate) fn to_be_empty_object(
     )
 }
 
-// ported from: src/test_runner/expect/toBeEmptyObject.zig
diff --git a/src/runtime/test_runner/expect/toBeEven.rs b/src/runtime/test_runner/expect/toBeEven.rs
index 214be639168..ce1a2eedad1 100644
--- a/src/runtime/test_runner/expect/toBeEven.rs
+++ b/src/runtime/test_runner/expect/toBeEven.rs
@@ -20,4 +20,3 @@ impl Expect {
         })
     }
 }
-// ported from: src/test_runner/expect/toBeEven.zig
diff --git a/src/runtime/test_runner/expect/toBeFalse.rs b/src/runtime/test_runner/expect/toBeFalse.rs
index c1adc58b66d..25b2f7ef9f6 100644
--- a/src/runtime/test_runner/expect/toBeFalse.rs
+++ b/src/runtime/test_runner/expect/toBeFalse.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_false, "toBeFalse", |v| v.is_boolean() && !v.to_boolean());
-// ported from: src/test_runner/expect/toBeFalse.zig
diff --git a/src/runtime/test_runner/expect/toBeFalsy.rs b/src/runtime/test_runner/expect/toBeFalsy.rs
index 3100dac595b..9741262145b 100644
--- a/src/runtime/test_runner/expect/toBeFalsy.rs
+++ b/src/runtime/test_runner/expect/toBeFalsy.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_falsy, "toBeFalsy", |v| !v.to_boolean());
-// ported from: src/test_runner/expect/toBeFalsy.zig
diff --git a/src/runtime/test_runner/expect/toBeFinite.rs b/src/runtime/test_runner/expect/toBeFinite.rs
index 6b120b18dd2..71dbddbeafe 100644
--- a/src/runtime/test_runner/expect/toBeFinite.rs
+++ b/src/runtime/test_runner/expect/toBeFinite.rs
@@ -2,4 +2,3 @@ crate::unary_predicate_matcher!(to_be_finite, "toBeFinite", |v| v.is_number() &&
     let n = v.as_number();
     n.is_finite() && !n.is_nan()
 });
-// ported from: src/test_runner/expect/toBeFinite.zig
diff --git a/src/runtime/test_runner/expect/toBeFunction.rs b/src/runtime/test_runner/expect/toBeFunction.rs
index 9152c37e42b..a7c0f7faf05 100644
--- a/src/runtime/test_runner/expect/toBeFunction.rs
+++ b/src/runtime/test_runner/expect/toBeFunction.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_function, "toBeFunction", |v| v.is_callable());
-// ported from: src/test_runner/expect/toBeFunction.zig
diff --git a/src/runtime/test_runner/expect/toBeGreaterThan.rs b/src/runtime/test_runner/expect/toBeGreaterThan.rs
index 477483bffb2..3ed5aa2acc3 100644
--- a/src/runtime/test_runner/expect/toBeGreaterThan.rs
+++ b/src/runtime/test_runner/expect/toBeGreaterThan.rs
@@ -8,4 +8,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeGreaterThan.zig
diff --git a/src/runtime/test_runner/expect/toBeGreaterThanOrEqual.rs b/src/runtime/test_runner/expect/toBeGreaterThanOrEqual.rs
index beaea9835e1..6b02e8847a3 100644
--- a/src/runtime/test_runner/expect/toBeGreaterThanOrEqual.rs
+++ b/src/runtime/test_runner/expect/toBeGreaterThanOrEqual.rs
@@ -8,4 +8,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeGreaterThanOrEqual.zig
diff --git a/src/runtime/test_runner/expect/toBeInstanceOf.rs b/src/runtime/test_runner/expect/toBeInstanceOf.rs
index 028786fdba9..02f9d2f211f 100644
--- a/src/runtime/test_runner/expect/toBeInstanceOf.rs
+++ b/src/runtime/test_runner/expect/toBeInstanceOf.rs
@@ -3,18 +3,19 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_instance_of(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: reshaped for borrowck (was `defer this.postMatch(globalThis)`).
+    // Reshaped for borrowck (was `defer this.postMatch(globalThis)`).
     // Run the matcher body in an inner closure so `this` is released when it returns,
     // then call `post_match` exactly once on every exit path (success or throw).
     let res = (|| -> JsResult<JSValue> {
     let this_value = frame.this();
-    // PORT NOTE: collapsed `arguments_old(1)` + ptr/len slice into a single &[JSValue].
+    // Collapsed `arguments_old(1)` + ptr/len slice into a single &[JSValue].
     let arguments_ = frame.arguments_old::<1>(); let arguments: &[JSValue] = arguments_.slice();
 
     if arguments.len() < 1 {
@@ -49,16 +50,14 @@ pub(crate) fn to_be_instance_of(
     }
 
     // handle failure
-    // PORT NOTE: two live `to_fmt(&mut Formatter)` wrappers alias the same formatter under
+    // Two live `to_fmt(&mut Formatter)` wrappers alias the same formatter under
     // borrowck — use a second Formatter for the second value (matches toBe.rs / toInclude.rs).
     let mut formatter2 = super::make_formatter(global);
     let expected_fmt = expected_value.to_fmt(&mut formatter);
     let value_fmt = value.to_fmt(&mut formatter2);
     if not {
-        // PORT NOTE: Zig built the fmt string via comptime `++` concatenation of
-        // `expected_line`/`received_line` consts; inlined here because Rust `concat!`
+        // `expected_line`/`received_line` are inlined here because Rust `concat!`
         // only accepts literals (and `format_args!` needs a literal anyway).
-        // TODO(port): get_signature should be a `const fn` (was `comptime` in Zig).
         let signature = get_signature("toBeInstanceOf", "<green>expected<r>", true);
         return this.throw(
             global,
@@ -84,4 +83,3 @@ pub(crate) fn to_be_instance_of(
     res
 }
 
-// ported from: src/test_runner/expect/toBeInstanceOf.zig
diff --git a/src/runtime/test_runner/expect/toBeInteger.rs b/src/runtime/test_runner/expect/toBeInteger.rs
index a139b4707d5..cc7931d49d3 100644
--- a/src/runtime/test_runner/expect/toBeInteger.rs
+++ b/src/runtime/test_runner/expect/toBeInteger.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_integer, "toBeInteger", |v| v.is_any_int());
-// ported from: src/test_runner/expect/toBeInteger.zig
diff --git a/src/runtime/test_runner/expect/toBeLessThan.rs b/src/runtime/test_runner/expect/toBeLessThan.rs
index bb3eb927922..9b6823d1d2e 100644
--- a/src/runtime/test_runner/expect/toBeLessThan.rs
+++ b/src/runtime/test_runner/expect/toBeLessThan.rs
@@ -8,4 +8,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeLessThan.zig
diff --git a/src/runtime/test_runner/expect/toBeLessThanOrEqual.rs b/src/runtime/test_runner/expect/toBeLessThanOrEqual.rs
index f1694ea19dc..301c59f2c34 100644
--- a/src/runtime/test_runner/expect/toBeLessThanOrEqual.rs
+++ b/src/runtime/test_runner/expect/toBeLessThanOrEqual.rs
@@ -8,4 +8,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeLessThanOrEqual.zig
diff --git a/src/runtime/test_runner/expect/toBeNaN.rs b/src/runtime/test_runner/expect/toBeNaN.rs
index 036d842b35c..aceaca96c65 100644
--- a/src/runtime/test_runner/expect/toBeNaN.rs
+++ b/src/runtime/test_runner/expect/toBeNaN.rs
@@ -1,3 +1,2 @@
 // codegen snake-cases `toBeNaN` → `to_be_na_n`
 crate::unary_predicate_matcher!(to_be_na_n, "toBeNaN", |v| v.is_number() && v.as_number().is_nan());
-// ported from: src/test_runner/expect/toBeNaN.zig
diff --git a/src/runtime/test_runner/expect/toBeNegative.rs b/src/runtime/test_runner/expect/toBeNegative.rs
index 8366c26960b..caf0c230aea 100644
--- a/src/runtime/test_runner/expect/toBeNegative.rs
+++ b/src/runtime/test_runner/expect/toBeNegative.rs
@@ -2,4 +2,3 @@ crate::unary_predicate_matcher!(to_be_negative, "toBeNegative", |v| v.is_number(
     let n = v.as_number();
     n.round() < 0.0 && !n.is_infinite() && !n.is_nan()
 });
-// ported from: src/test_runner/expect/toBeNegative.zig
diff --git a/src/runtime/test_runner/expect/toBeNil.rs b/src/runtime/test_runner/expect/toBeNil.rs
index d66def6154f..61cf9ffc62e 100644
--- a/src/runtime/test_runner/expect/toBeNil.rs
+++ b/src/runtime/test_runner/expect/toBeNil.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_nil, "toBeNil", |v| v.is_undefined_or_null());
-// ported from: src/test_runner/expect/toBeNil.zig
diff --git a/src/runtime/test_runner/expect/toBeNull.rs b/src/runtime/test_runner/expect/toBeNull.rs
index d69324b3bb5..51ca0b1c535 100644
--- a/src/runtime/test_runner/expect/toBeNull.rs
+++ b/src/runtime/test_runner/expect/toBeNull.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_null, "toBeNull", |v| v.is_null());
-// ported from: src/test_runner/expect/toBeNull.zig
diff --git a/src/runtime/test_runner/expect/toBeNumber.rs b/src/runtime/test_runner/expect/toBeNumber.rs
index a76d3cd06a9..b32e5808a73 100644
--- a/src/runtime/test_runner/expect/toBeNumber.rs
+++ b/src/runtime/test_runner/expect/toBeNumber.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_number, "toBeNumber", |v| v.is_number());
-// ported from: src/test_runner/expect/toBeNumber.zig
diff --git a/src/runtime/test_runner/expect/toBeObject.rs b/src/runtime/test_runner/expect/toBeObject.rs
index 45b6ee629bd..66aaeba27f9 100644
--- a/src/runtime/test_runner/expect/toBeObject.rs
+++ b/src/runtime/test_runner/expect/toBeObject.rs
@@ -10,10 +10,9 @@ impl Expect {
         frame: &CallFrame,
     ) -> JsResult<JSValue> {
         let this = self;
-        // Zig: `defer this.postMatch(globalThis);`
-        // PORT NOTE: reshaped for borrowck (was `defer this.postMatch`) — wrap the
-        // body in an inner closure and call `post_match` after it returns, so every
-        // exit path (incl. `?` early-returns) is covered without a raw `*mut Expect`.
+        // Wrap the body in an inner
+        // closure and call `post_match` after it returns, so every exit path
+        // (incl. `?` early-returns) is covered without a raw `*mut Expect`.
         let result = (|| -> JsResult<JSValue> {
         let this_value = frame.this();
         let value: JSValue = this.get_value(global, this_value, "toBeObject", "")?;
@@ -27,7 +26,6 @@ impl Expect {
             return Ok(this_value);
         }
 
-        // Zig: `defer formatter.deinit();` — handled by Drop.
         let mut formatter = super::make_formatter(global);
         let received = value.to_fmt(&mut formatter);
 
@@ -58,4 +56,3 @@ impl Expect {
     }
 }
 
-// ported from: src/test_runner/expect/toBeObject.zig
diff --git a/src/runtime/test_runner/expect/toBeOdd.rs b/src/runtime/test_runner/expect/toBeOdd.rs
index ea64edd9b4a..d2dfc634c1d 100644
--- a/src/runtime/test_runner/expect/toBeOdd.rs
+++ b/src/runtime/test_runner/expect/toBeOdd.rs
@@ -22,4 +22,3 @@ impl Expect {
         })
     }
 }
-// ported from: src/test_runner/expect/toBeOdd.zig
diff --git a/src/runtime/test_runner/expect/toBeOneOf.rs b/src/runtime/test_runner/expect/toBeOneOf.rs
index 81afeb1c979..a9689d2e455 100644
--- a/src/runtime/test_runner/expect/toBeOneOf.rs
+++ b/src/runtime/test_runner/expect/toBeOneOf.rs
@@ -25,11 +25,12 @@ extern "C" fn same_value_iterator(
     };
     if eq {
         *entry.pass = true;
-        // TODO(perf): break out of the `forEach` when a match is found
+        // PERF: break out of the `forEach` when a match is found
     }
 }
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_one_of(
     this: &Expect,
     global_this: &JSGlobalObject,
@@ -82,15 +83,13 @@ pub(crate) fn to_be_one_of(
     }
 
     // handle failure
-    // PORT NOTE: Zig shares one `*Formatter` across both `toFmt` calls; in Rust the
-    // `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
-    // the same backing formatter. Use a second formatter for the second value (matches toBe.rs).
+    // The `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters
+    // cannot alias the same backing formatter. Use a second formatter for the
+    // second value (matches toBe.rs).
     let mut formatter = super::make_formatter(global_this);
     let mut formatter2 = super::make_formatter(global_this);
     if not {
-        // TODO(port): get_signature was `comptime` in Zig — ensure it is `const fn` so this stays compile-time.
         let signature = get_signature("toBeOneOf", "<green>expected<r>", true);
-        // PORT NOTE: Zig `{f}` fmt specifier mapped to Rust `{}` (Display); `++` mapped to concat!.
         return this.throw(
             global_this,
             signature,
@@ -121,4 +120,3 @@ pub(crate) fn to_be_one_of(
     );
 }
 
-// ported from: src/test_runner/expect/toBeOneOf.zig
diff --git a/src/runtime/test_runner/expect/toBePositive.rs b/src/runtime/test_runner/expect/toBePositive.rs
index cc5e8306f9a..c18f260c633 100644
--- a/src/runtime/test_runner/expect/toBePositive.rs
+++ b/src/runtime/test_runner/expect/toBePositive.rs
@@ -2,4 +2,3 @@ crate::unary_predicate_matcher!(to_be_positive, "toBePositive", |v| v.is_number(
     let n = v.as_number();
     n.round() > 0.0 && !n.is_infinite() && !n.is_nan()
 });
-// ported from: src/test_runner/expect/toBePositive.zig
diff --git a/src/runtime/test_runner/expect/toBeString.rs b/src/runtime/test_runner/expect/toBeString.rs
index ee40fd7493d..c4152ab7926 100644
--- a/src/runtime/test_runner/expect/toBeString.rs
+++ b/src/runtime/test_runner/expect/toBeString.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_string, "toBeString", |v| v.is_string());
-// ported from: src/test_runner/expect/toBeString.zig
diff --git a/src/runtime/test_runner/expect/toBeSymbol.rs b/src/runtime/test_runner/expect/toBeSymbol.rs
index ee5ae0a342f..44e1c2ab350 100644
--- a/src/runtime/test_runner/expect/toBeSymbol.rs
+++ b/src/runtime/test_runner/expect/toBeSymbol.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_symbol, "toBeSymbol", |v| v.is_symbol());
-// ported from: src/test_runner/expect/toBeSymbol.zig
diff --git a/src/runtime/test_runner/expect/toBeTrue.rs b/src/runtime/test_runner/expect/toBeTrue.rs
index 3ef8af9975a..62a1cc9e1c4 100644
--- a/src/runtime/test_runner/expect/toBeTrue.rs
+++ b/src/runtime/test_runner/expect/toBeTrue.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_true, "toBeTrue", |v| v.is_boolean() && v.to_boolean());
-// ported from: src/test_runner/expect/toBeTrue.zig
diff --git a/src/runtime/test_runner/expect/toBeTruthy.rs b/src/runtime/test_runner/expect/toBeTruthy.rs
index 2df35299a3e..e6bc0af2096 100644
--- a/src/runtime/test_runner/expect/toBeTruthy.rs
+++ b/src/runtime/test_runner/expect/toBeTruthy.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_truthy, "toBeTruthy", |v| v.to_boolean());
-// ported from: src/test_runner/expect/toBeTruthy.zig
diff --git a/src/runtime/test_runner/expect/toBeTypeOf.rs b/src/runtime/test_runner/expect/toBeTypeOf.rs
index 6d314c06577..6726efd7695 100644
--- a/src/runtime/test_runner/expect/toBeTypeOf.rs
+++ b/src/runtime/test_runner/expect/toBeTypeOf.rs
@@ -13,7 +13,8 @@ static JS_TYPE_OF_MAP: phf::Map<&'static [u8], &'static [u8]> = phf::phf_map! {
     b"undefined" => b"undefined",
 };
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_type_of(
     this: &Expect,
     global: &JSGlobalObject,
@@ -74,7 +75,7 @@ pub(crate) fn to_be_type_of(
     }
 
     let mut formatter = super::make_formatter(global);
-    // PORT NOTE: ZigFormatter borrows &mut Formatter for its lifetime; need a second formatter
+    // ZigFormatter borrows &mut Formatter for its lifetime; need a second formatter
     // so `received` and `expected_str` can coexist in one format_args!.
     let mut formatter2 = super::make_formatter(global);
     // `defer formatter.deinit()` — handled by Drop.
@@ -115,5 +116,3 @@ pub(crate) fn to_be_type_of(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toBeTypeOf.zig
diff --git a/src/runtime/test_runner/expect/toBeUndefined.rs b/src/runtime/test_runner/expect/toBeUndefined.rs
index 75a8051f31c..834c71b85f9 100644
--- a/src/runtime/test_runner/expect/toBeUndefined.rs
+++ b/src/runtime/test_runner/expect/toBeUndefined.rs
@@ -1,2 +1 @@
 crate::unary_predicate_matcher!(to_be_undefined, "toBeUndefined", |v| v.is_undefined());
-// ported from: src/test_runner/expect/toBeUndefined.zig
diff --git a/src/runtime/test_runner/expect/toBeValidDate.rs b/src/runtime/test_runner/expect/toBeValidDate.rs
index af04b086dbf..c9491e79594 100644
--- a/src/runtime/test_runner/expect/toBeValidDate.rs
+++ b/src/runtime/test_runner/expect/toBeValidDate.rs
@@ -4,7 +4,8 @@ use super::make_formatter;
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_be_valid_date(
     this: &Expect,
     global: &JSGlobalObject,
@@ -41,5 +42,3 @@ pub(crate) fn to_be_valid_date(
         format_args!("\n\nReceived: <red>{}<r>\n", received),
     )
 }
-
-// ported from: src/test_runner/expect/toBeValidDate.zig
diff --git a/src/runtime/test_runner/expect/toBeWithin.rs b/src/runtime/test_runner/expect/toBeWithin.rs
index cb4fc951ccf..3de2c0c4170 100644
--- a/src/runtime/test_runner/expect/toBeWithin.rs
+++ b/src/runtime/test_runner/expect/toBeWithin.rs
@@ -57,10 +57,8 @@ impl Expect {
             return Ok(JSValue::UNDEFINED);
         }
 
-        // Zig: .{ .globalThis = globalThis, .quote_strings = true } — make_formatter sets quote_strings.
-        // PORT NOTE: Zig aliased one `*Formatter` for all three fmt adapters; Rust `to_fmt`
-        // takes `&mut Formatter` so three live adapters need three formatters (matches
-        // toBeLessThan.rs / toContainEqual.rs).
+        // `to_fmt` takes `&mut Formatter` and the adapter holds the borrow, so three
+        // live adapters need three formatters (matches toBeLessThan.rs / toContainEqual.rs).
         let mut formatter = super::make_formatter(global);
         let mut formatter2 = super::make_formatter(global);
         let mut formatter3 = super::make_formatter(global);
@@ -112,5 +110,3 @@ impl Expect {
         )
     }
 }
-
-// ported from: src/test_runner/expect/toBeWithin.zig
diff --git a/src/runtime/test_runner/expect/toContain.rs b/src/runtime/test_runner/expect/toContain.rs
index fc3ec1805b2..ea9926fe4c8 100644
--- a/src/runtime/test_runner/expect/toContain.rs
+++ b/src/runtime/test_runner/expect/toContain.rs
@@ -27,8 +27,8 @@ impl Expect {
         expected.ensure_still_alive();
         let mut pass = false;
 
-        // FFI/BACKREF: erased to *mut c_void for for_each userdata; raw ptrs match the Zig
-        // `*JSGlobalObject` / `*bool` fields and avoid a struct lifetime param.
+        // FFI/BACKREF: erased to *mut c_void for for_each userdata; raw ptrs
+        // avoid a struct lifetime param.
         struct ExpectedEntry {
             global: *const JSGlobalObject,
             expected: JSValue,
@@ -71,7 +71,7 @@ impl Expect {
             ) {
                 debug_assert!(!entry_.is_null());
                 // SAFETY: entry_ is &mut ExpectedEntry on the caller's stack, threaded through
-                // for_each as opaque userdata; non-null asserted above (Zig `entry_.?`).
+                // for_each as opaque userdata; non-null asserted above.
                 let entry = unsafe { bun_ptr::callback_ctx::<ExpectedEntry>(entry_) };
                 // SAFETY: entry.global was set from `std::ptr::from_ref(global)` on the caller's
                 // stack frame, which outlives the synchronous for_each this callback runs inside.
@@ -106,13 +106,11 @@ impl Expect {
         }
 
         // handle failure
-        // PORT NOTE: Zig shares one Formatter across both `to_fmt` calls; in Rust each
-        // `to_fmt` borrows `&mut Formatter` for the lifetime of the returned wrapper, so
-        // create a second Formatter (cheap struct init, no shared state) to satisfy borrowck.
+        // Each `to_fmt` borrows `&mut Formatter` for the lifetime of the returned wrapper,
+        // so a second Formatter (cheap struct init, no shared state) satisfies borrowck.
         let mut formatter = super::make_formatter(global);
         let mut formatter2 = super::make_formatter(global);
         if not {
-            // PERF(port): was comptime getSignature — would require `get_signature` to be `const fn` / use `const_format`.
             let signature = get_signature("toContain", "<green>expected<r>", true);
             return this.throw(
                 global,
@@ -128,7 +126,6 @@ impl Expect {
             );
         }
 
-        // PERF(port): was comptime getSignature — would require `get_signature` to be `const fn` / use `const_format`.
         let signature = get_signature("toContain", "<green>expected<r>", false);
         this.throw(
             global,
@@ -145,5 +142,3 @@ impl Expect {
         )
     }
 }
-
-// ported from: src/test_runner/expect/toContain.zig
diff --git a/src/runtime/test_runner/expect/toContainAllKeys.rs b/src/runtime/test_runner/expect/toContainAllKeys.rs
index 4660a9d7eea..3ea43b7130e 100644
--- a/src/runtime/test_runner/expect/toContainAllKeys.rs
+++ b/src/runtime/test_runner/expect/toContainAllKeys.rs
@@ -26,4 +26,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainAllKeys.zig
diff --git a/src/runtime/test_runner/expect/toContainAllValues.rs b/src/runtime/test_runner/expect/toContainAllValues.rs
index 2f19f4ebe8e..754f912587c 100644
--- a/src/runtime/test_runner/expect/toContainAllValues.rs
+++ b/src/runtime/test_runner/expect/toContainAllValues.rs
@@ -25,4 +25,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainAllValues.zig
diff --git a/src/runtime/test_runner/expect/toContainAnyKeys.rs b/src/runtime/test_runner/expect/toContainAnyKeys.rs
index 2957dc98241..028fffd3e3e 100644
--- a/src/runtime/test_runner/expect/toContainAnyKeys.rs
+++ b/src/runtime/test_runner/expect/toContainAnyKeys.rs
@@ -19,4 +19,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainAnyKeys.zig
diff --git a/src/runtime/test_runner/expect/toContainAnyValues.rs b/src/runtime/test_runner/expect/toContainAnyValues.rs
index 6510e38561c..742525a5b3a 100644
--- a/src/runtime/test_runner/expect/toContainAnyValues.rs
+++ b/src/runtime/test_runner/expect/toContainAnyValues.rs
@@ -24,4 +24,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainAnyValues.zig
diff --git a/src/runtime/test_runner/expect/toContainEqual.rs b/src/runtime/test_runner/expect/toContainEqual.rs
index 3bebfaedc63..c4384459e52 100644
--- a/src/runtime/test_runner/expect/toContainEqual.rs
+++ b/src/runtime/test_runner/expect/toContainEqual.rs
@@ -24,11 +24,12 @@ extern "C" fn deep_equals_iterator(
     };
     if eq {
         *entry.pass = true;
-        // TODO(perf): break out of the `forEach` when a match is found
+        // PERF: break out of the `forEach` when a match is found
     }
 }
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_contain_equal(
     this: &Expect,
     global: &JSGlobalObject,
@@ -104,8 +105,8 @@ pub(crate) fn to_contain_equal(
     }
 
     // handle failure
-    // PORT NOTE: Zig shared one Formatter for both `toFmt` calls; Rust borrowck forbids two
-    // live `&mut formatter` borrows, so allocate a second Formatter for the expected value.
+    // Two live `&mut formatter` borrows cannot coexist, so allocate a second
+    // Formatter for the expected value.
     let mut formatter = super::make_formatter(global);
     let mut formatter2 = super::make_formatter(global);
     let value_fmt = value.to_fmt(&mut formatter);
@@ -132,5 +133,3 @@ pub(crate) fn to_contain_equal(
         format_args!("{}{}", expected_fmt, value_fmt),
     )
 }
-
-// ported from: src/test_runner/expect/toContainEqual.zig
diff --git a/src/runtime/test_runner/expect/toContainKey.rs b/src/runtime/test_runner/expect/toContainKey.rs
index f6992bb00ef..51f43b2a5f1 100644
--- a/src/runtime/test_runner/expect/toContainKey.rs
+++ b/src/runtime/test_runner/expect/toContainKey.rs
@@ -15,4 +15,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainKey.zig
diff --git a/src/runtime/test_runner/expect/toContainKeys.rs b/src/runtime/test_runner/expect/toContainKeys.rs
index 67d6867d0db..f83c8adf14c 100644
--- a/src/runtime/test_runner/expect/toContainKeys.rs
+++ b/src/runtime/test_runner/expect/toContainKeys.rs
@@ -20,4 +20,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainKeys.zig
diff --git a/src/runtime/test_runner/expect/toContainValue.rs b/src/runtime/test_runner/expect/toContainValue.rs
index 815c1548c8d..759376a5aa5 100644
--- a/src/runtime/test_runner/expect/toContainValue.rs
+++ b/src/runtime/test_runner/expect/toContainValue.rs
@@ -15,4 +15,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainValue.zig
diff --git a/src/runtime/test_runner/expect/toContainValues.rs b/src/runtime/test_runner/expect/toContainValues.rs
index aba051a0f64..4ec57184808 100644
--- a/src/runtime/test_runner/expect/toContainValues.rs
+++ b/src/runtime/test_runner/expect/toContainValues.rs
@@ -22,4 +22,3 @@ impl Expect {
             })
     }
 }
-// ported from: src/test_runner/expect/toContainValues.zig
diff --git a/src/runtime/test_runner/expect/toEndWith.rs b/src/runtime/test_runner/expect/toEndWith.rs
index b845a16f344..f6d710b6662 100644
--- a/src/runtime/test_runner/expect/toEndWith.rs
+++ b/src/runtime/test_runner/expect/toEndWith.rs
@@ -5,4 +5,3 @@ use super::Expect;
 pub(crate) fn to_end_with(this: &Expect, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     this.run_string_affix_matcher(global, frame, "toEndWith", "end with", strings::ends_with)
 }
-// ported from: src/test_runner/expect/toEndWith.zig
diff --git a/src/runtime/test_runner/expect/toEqual.rs b/src/runtime/test_runner/expect/toEqual.rs
index 8fefa3aa36d..8cc083a3f7c 100644
--- a/src/runtime/test_runner/expect/toEqual.rs
+++ b/src/runtime/test_runner/expect/toEqual.rs
@@ -49,5 +49,3 @@ impl Expect {
         this.throw(global, signature, format_args!("\n\n{}\n", diff_formatter))
     }
 }
-
-// ported from: src/test_runner/expect/toEqual.zig
diff --git a/src/runtime/test_runner/expect/toEqualIgnoringWhitespace.rs b/src/runtime/test_runner/expect/toEqualIgnoringWhitespace.rs
index 32b3304256f..c8d3ecafb46 100644
--- a/src/runtime/test_runner/expect/toEqualIgnoringWhitespace.rs
+++ b/src/runtime/test_runner/expect/toEqualIgnoringWhitespace.rs
@@ -1,14 +1,15 @@
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 
-// PORT NOTE: std.ascii.isWhitespace includes VT (0x0B); Rust's u8::is_ascii_whitespace does not.
-// Zig matches ' ' and '\t'..'\r' (0x09–0x0D).
+// Matches ' ' and '\t'..'\r' (0x09–0x0D) — includes VT (0x0B), which Rust's
+// u8::is_ascii_whitespace does not.
 #[inline]
 fn is_zig_whitespace(b: u8) -> bool {
     matches!(b, b' ' | b'\t' | b'\n' | 0x0B | 0x0C | b'\r')
 }
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
+// Free fn (this module can't open `impl Expect`); bridged into `impl Expect` by the
+// `__forward_matcher!` macro in expect.rs, where the JsClass codegen host_fn shim picks it up.
 pub(crate) fn to_equal_ignoring_whitespace(
     this: &Expect,
     global: &JSGlobalObject,
@@ -36,7 +37,6 @@ pub(crate) fn to_equal_ignoring_whitespace(
     let mut pass = value.is_string() && expected.is_string();
 
     if pass {
-        // Zig passed `default_allocator`; drop per §Allocators.
         let value_slice = value.to_slice(global)?;
         let expected_slice = expected.to_slice(global)?;
         // `defer ….deinit()` deleted — Drop handles it.
@@ -89,7 +89,7 @@ pub(crate) fn to_equal_ignoring_whitespace(
     }
 
     // handle failure
-    // PORT NOTE: `to_fmt` returns a `ZigFormatter<'a, 'b>` that mutably borrows the
+    // `to_fmt` returns a `ZigFormatter<'a, 'b>` that mutably borrows the
     // backing formatter. Use a second formatter for the received value — `make_formatter` is
     // cheap (no alloc) and this matches sibling matchers (toContainEqual, toBeCloseTo).
     let mut formatter = super::make_formatter(global);
@@ -99,7 +99,6 @@ pub(crate) fn to_equal_ignoring_whitespace(
     let value_fmt = value.to_fmt(&mut formatter2);
 
     if not {
-        // TODO(port): get_signature must be `const fn` (was `comptime` in Zig).
         let signature = Expect::get_signature("toEqualIgnoringWhitespace", "<green>expected<r>", true);
         return this.throw(
             global,
@@ -121,5 +120,3 @@ pub(crate) fn to_equal_ignoring_whitespace(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toEqualIgnoringWhitespace.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenCalled.rs b/src/runtime/test_runner/expect/toHaveBeenCalled.rs
index afe63e92a67..ddebfb26eab 100644
--- a/src/runtime/test_runner/expect/toHaveBeenCalled.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenCalled.rs
@@ -1,7 +1,6 @@
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_called(
     this: &Expect,
     global: &JSGlobalObject,
@@ -10,7 +9,7 @@ pub(crate) fn to_have_been_called(
     bun_jsc::mark_binding!();
     let (this, calls, _value) =
         this.mock_prologue(global, frame.this(), "toHaveBeenCalled", "", super::mock::MockKind::Calls)?;
-    // arg-check after prologue: counter bump + post_match still fire on bad-arity (matches Zig defer order).
+    // arg-check after prologue: counter bump + post_match still fire on bad-arity.
     if !frame.arguments_as_array::<1>()[0].is_undefined() {
         return Err(global.throw_invalid_arguments(format_args!(
             "toHaveBeenCalled() must not have an argument"
@@ -30,7 +29,6 @@ pub(crate) fn to_have_been_called(
 
     // handle failure
     if not {
-        // TODO(port): `comptime getSignature(...)` — ensure Expect::get_signature is `const fn`
         let signature = Expect::get_signature("toHaveBeenCalled", "", true);
         return this.throw(
             global,
@@ -60,5 +58,3 @@ pub(crate) fn to_have_been_called(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveBeenCalled.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenCalledOnce.rs b/src/runtime/test_runner/expect/toHaveBeenCalledOnce.rs
index 0a6a10b9eaa..1d1f99e6b15 100644
--- a/src/runtime/test_runner/expect/toHaveBeenCalledOnce.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenCalledOnce.rs
@@ -2,7 +2,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_called_once(
     this: &Expect,
     global: &JSGlobalObject,
@@ -59,5 +58,3 @@ pub(crate) fn to_have_been_called_once(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveBeenCalledOnce.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenCalledTimes.rs b/src/runtime/test_runner/expect/toHaveBeenCalledTimes.rs
index 12f8f9a6dc2..c903e69ae19 100644
--- a/src/runtime/test_runner/expect/toHaveBeenCalledTimes.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenCalledTimes.rs
@@ -2,7 +2,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_called_times(
     this: &Expect,
     global: &JSGlobalObject,
@@ -38,32 +37,34 @@ pub(crate) fn to_have_been_called_times(
 
     // handle failure
     if not {
-        let signature: &str = get_signature("toHaveBeenCalledTimes", "<green>expected<r>", true);
-        return this.throw_fmt(
+        let signature = get_signature("toHaveBeenCalledTimes", "<green>expected<r>", true);
+        return this.throw(
             global,
             signature,
-            concat!(
-                "\n\n",
-                "Expected number of calls: not <green>{d}<r>\n",
-                "Received number of calls: <red>{d}<r>\n"
+            format_args!(
+                concat!(
+                    "\n\n",
+                    "Expected number of calls: not <green>{}<r>\n",
+                    "Received number of calls: <red>{}<r>\n"
+                ),
+                times,
+                calls.get_length(global)?,
             ),
-            format_args!("{}, {}", times, calls.get_length(global)?),
         );
-        // TODO(refactor): Expect.throw signature — Zig passes (fmt_literal, args_tuple); Rust
-        // side likely wants a single format_args!. Reconcile.
     }
 
-    let signature: &str = get_signature("toHaveBeenCalledTimes", "<green>expected<r>", false);
-    this.throw_fmt(
+    let signature = get_signature("toHaveBeenCalledTimes", "<green>expected<r>", false);
+    this.throw(
         global,
         signature,
-        concat!(
-            "\n\n",
-            "Expected number of calls: <green>{d}<r>\n",
-            "Received number of calls: <red>{d}<r>\n"
+        format_args!(
+            concat!(
+                "\n\n",
+                "Expected number of calls: <green>{}<r>\n",
+                "Received number of calls: <red>{}<r>\n"
+            ),
+            times,
+            calls.get_length(global)?,
         ),
-        format_args!("{}, {}", times, calls.get_length(global)?),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveBeenCalledTimes.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenCalledWith.rs b/src/runtime/test_runner/expect/toHaveBeenCalledWith.rs
index e133f98631b..defb78cb26f 100644
--- a/src/runtime/test_runner/expect/toHaveBeenCalledWith.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenCalledWith.rs
@@ -4,7 +4,6 @@ use super::DiffFormatter;
 use super::mock;
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_called_with(
     this: &Expect,
     global: &JSGlobalObject,
@@ -102,8 +101,7 @@ pub(crate) fn to_have_been_called_with(
     }
 
     // If there are multiple calls, list them all to help debugging.
-    // PORT NOTE: reshaped for borrowck — Zig shares one `&formatter` between to_fmt and
-    // list_formatter; in Rust the AllCallsWithArgsFormatter holds an exclusive borrow, so
+    // The AllCallsWithArgsFormatter holds an exclusive borrow of the formatter, so
     // we allocate a second ConsoleObject formatter for the list.
     let mut list_fmt = super::make_formatter(global);
     let list_formatter = mock::AllCallsWithArgsFormatter {
@@ -112,10 +110,6 @@ pub(crate) fn to_have_been_called_with(
         formatter: core::cell::RefCell::new(&mut list_fmt),
     };
 
-    // TODO(port): Output.prettyFmt comptime color dispatch — Zig branches on
-    // `Output.enable_ansi_colors_stderr` to substitute/strip `<green>`/`<red>` tags at comptime.
-    // Re-expand to `if b { throw::<true>() } else { throw::<false>() }` once `bun_core::pretty_fmt!` exists.
-    // PERF(port): was comptime bool dispatch (`switch inline else`) — profile if hot.
     this.throw(
         global,
         signature,
@@ -127,5 +121,3 @@ pub(crate) fn to_have_been_called_with(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveBeenCalledWith.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenLastCalledWith.rs b/src/runtime/test_runner/expect/toHaveBeenLastCalledWith.rs
index cf8553b8341..735c24befba 100644
--- a/src/runtime/test_runner/expect/toHaveBeenLastCalledWith.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenLastCalledWith.rs
@@ -3,7 +3,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::DiffFormatter;
 use super::{Expect, get_signature};
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_last_called_with(
     this: &Expect,
     global: &JSGlobalObject,
@@ -92,5 +91,3 @@ pub(crate) fn to_have_been_last_called_with(
     };
     this.throw(global, signature, format_args!("\n\n{}\n", diff_format))
 }
-
-// ported from: src/test_runner/expect/toHaveBeenLastCalledWith.zig
diff --git a/src/runtime/test_runner/expect/toHaveBeenNthCalledWith.rs b/src/runtime/test_runner/expect/toHaveBeenNthCalledWith.rs
index d5dcc10c178..fe270de99f3 100644
--- a/src/runtime/test_runner/expect/toHaveBeenNthCalledWith.rs
+++ b/src/runtime/test_runner/expect/toHaveBeenNthCalledWith.rs
@@ -2,7 +2,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::DiffFormatter;
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_been_nth_called_with(
     this: &Expect,
     global: &JSGlobalObject,
@@ -112,5 +111,3 @@ pub(crate) fn to_have_been_nth_called_with(
         format_args!("\n\nCall #{}:\n{}\n", nth_call_num, diff_format),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveBeenNthCalledWith.zig
diff --git a/src/runtime/test_runner/expect/toHaveLastReturnedWith.rs b/src/runtime/test_runner/expect/toHaveLastReturnedWith.rs
index b7a07ca3c5d..750bd4b81ee 100644
--- a/src/runtime/test_runner/expect/toHaveLastReturnedWith.rs
+++ b/src/runtime/test_runner/expect/toHaveLastReturnedWith.rs
@@ -1,12 +1,10 @@
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::FormatterTestExt;
 use bun_jsc::console_object::Formatter;
-// TODO(port): verify path for JSMockFunction__getReturns FFI binding
 
 use super::DiffFormatter;
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_last_returned_with(
     this: &Expect,
     global_this: &JSGlobalObject,
@@ -108,8 +106,7 @@ pub(crate) fn to_have_last_returned_with(
         return this.throw(global_this, signature, format_args!("\n\n{}\n", diff_format));
     }
 
-    // PORT NOTE: Zig shares one `*Formatter` across both `toFmt` calls; in Rust the
-    // `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
+    // The `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
     // the same backing formatter. Use a second formatter for the received value —
     // `make_formatter` is a trivial struct init with no shared state between values.
     let mut formatter2 = super::make_formatter(global_this);
@@ -123,5 +120,3 @@ pub(crate) fn to_have_last_returned_with(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveLastReturnedWith.zig
diff --git a/src/runtime/test_runner/expect/toHaveLength.rs b/src/runtime/test_runner/expect/toHaveLength.rs
index cbf9f212a0b..feedb825882 100644
--- a/src/runtime/test_runner/expect/toHaveLength.rs
+++ b/src/runtime/test_runner/expect/toHaveLength.rs
@@ -3,7 +3,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_length(
     this: &Expect,
     global: &JSGlobalObject,
@@ -80,7 +79,6 @@ pub(crate) fn to_have_length(
 
     // handle failure
     if not {
-        // PERF(port): was comptime getSignature — const fn evaluated at compile time
         let signature: &str = get_signature("toHaveLength", "<green>expected<r>", true);
         return this.throw(
             global,
@@ -89,7 +87,6 @@ pub(crate) fn to_have_length(
         );
     }
 
-    // PERF(port): was comptime getSignature — const fn evaluated at compile time
     let signature: &str = get_signature("toHaveLength", "<green>expected<r>", false);
     this.throw(
         global,
@@ -100,5 +97,3 @@ pub(crate) fn to_have_length(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveLength.zig
diff --git a/src/runtime/test_runner/expect/toHaveNthReturnedWith.rs b/src/runtime/test_runner/expect/toHaveNthReturnedWith.rs
index 754a335acc2..8367a6e9c85 100644
--- a/src/runtime/test_runner/expect/toHaveNthReturnedWith.rs
+++ b/src/runtime/test_runner/expect/toHaveNthReturnedWith.rs
@@ -3,7 +3,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::DiffFormatter;
 use super::{Expect, get_signature};
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_nth_returned_with(
     this: &Expect,
     global: &JSGlobalObject,
@@ -70,7 +69,6 @@ pub(crate) fn to_have_nth_returned_with(
     let mut formatter2 = super::make_formatter(global);
     // defer formatter.deinit() — handled by Drop
 
-    // TODO(port): get_signature should be a const fn returning &'static str (was `comptime getSignature(...)`)
     let signature = get_signature("toHaveNthReturnedWith", "<green>n<r>, <green>expected<r>", false);
 
     if this.flags.get().not() {
@@ -138,5 +136,3 @@ pub(crate) fn to_have_nth_returned_with(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveNthReturnedWith.zig
diff --git a/src/runtime/test_runner/expect/toHaveProperty.rs b/src/runtime/test_runner/expect/toHaveProperty.rs
index 8cd8f323c4d..c7888375793 100644
--- a/src/runtime/test_runner/expect/toHaveProperty.rs
+++ b/src/runtime/test_runner/expect/toHaveProperty.rs
@@ -4,13 +4,12 @@ use bun_core::ZigString;
 use super::DiffFormatter;
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_property(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: `defer this.postMatch(globalThis)` — guard owns `this` and calls post_match on drop.
+    // `defer this.postMatch(globalThis)` — guard owns `this` and calls post_match on drop.
     let this = scopeguard::guard(this, |this| this.post_match(global));
 
     let this_value = frame.this();
@@ -69,8 +68,7 @@ pub(crate) fn to_have_property(
     }
 
     // handle failure
-    // PORT NOTE: Zig shares one `*Formatter` across both `to_fmt` calls; in Rust each `to_fmt`
-    // takes `&mut Formatter`, so use a second formatter for the second value (matches toBe.rs /
+    // Each `to_fmt` takes `&mut Formatter`, so use a second formatter for the second value (matches toBe.rs /
     // toInclude.rs / toStartWith.rs).
     let mut formatter = super::make_formatter(global);
     let mut formatter2 = super::make_formatter(global);
@@ -140,5 +138,3 @@ pub(crate) fn to_have_property(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toHaveProperty.zig
diff --git a/src/runtime/test_runner/expect/toHaveReturned.rs b/src/runtime/test_runner/expect/toHaveReturned.rs
index b3248f85865..a5ea4977318 100644
--- a/src/runtime/test_runner/expect/toHaveReturned.rs
+++ b/src/runtime/test_runner/expect/toHaveReturned.rs
@@ -19,9 +19,7 @@ impl Mode {
     }
 }
 
-// PERF(port): Zig used a `comptime mode` parameter (anonymous enum) so the two callers were
-// monomorphized; stable Rust forbids enum const-generic params (`adt_const_params`). Passed as a
-// runtime value here — the body branches on it only on cold/error paths.
+// `mode` is a runtime parameter — the body branches on it only on cold/error paths.
 #[inline]
 fn to_have_returned_times_fn(
     this: &Expect,
@@ -42,7 +40,6 @@ fn to_have_returned_times_fn(
 
     let expected_success_count: i32 = if mode == Mode::ToHaveReturned {
         if arguments.len() > 0 && !arguments[0].is_undefined() {
-            // PERF(port): Zig used comptime `@tagName(mode) ++ "..."`; runtime fmt on error path.
             return Err(global.throw_invalid_arguments(format_args!(
                 "{}() must not have an argument",
                 mode.tag_name()
@@ -85,8 +82,6 @@ fn to_have_returned_times_fn(
         return Ok(JSValue::UNDEFINED);
     }
 
-    // Zig: `switch (not) { inline else => |is_not| ... }` — runtime bool → comptime dispatch.
-    // PERF(port): Zig computed `getSignature` at comptime; runtime here (error path, cold).
     let signature = Expect::get_signature(mode.tag_name(), "<green>expected<r>", not);
     // `throw` runs pretty_fmt over the *rendered* string, so `<`/`>` in these
     // operands must be backslash-escaped to survive the tag pass.
@@ -132,5 +127,3 @@ impl Expect {
         to_have_returned_times_fn(self, global, callframe, Mode::ToHaveReturnedTimes)
     }
 }
-
-// ported from: src/test_runner/expect/toHaveReturned.zig
diff --git a/src/runtime/test_runner/expect/toHaveReturnedTimes.rs b/src/runtime/test_runner/expect/toHaveReturnedTimes.rs
index f51d1dce076..716fc85132b 100644
--- a/src/runtime/test_runner/expect/toHaveReturnedTimes.rs
+++ b/src/runtime/test_runner/expect/toHaveReturnedTimes.rs
@@ -12,5 +12,3 @@ pub fn to_have_returned_times(
 ) -> JsResult<JSValue> {
     Expect::to_have_returned_times(this, global, callframe)
 }
-
-// ported from: src/test_runner/expect/toHaveReturnedTimes.zig
diff --git a/src/runtime/test_runner/expect/toHaveReturnedWith.rs b/src/runtime/test_runner/expect/toHaveReturnedWith.rs
index 7008b33a182..d6bcd036583 100644
--- a/src/runtime/test_runner/expect/toHaveReturnedWith.rs
+++ b/src/runtime/test_runner/expect/toHaveReturnedWith.rs
@@ -4,7 +4,6 @@ use super::DiffFormatter;
 use super::mock;
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_have_returned_with(
     this: &Expect,
     global: &JSGlobalObject,
@@ -22,10 +21,9 @@ pub(crate) fn to_have_returned_with(
     let calls_count = u32::try_from(returns.get_length(global)?).unwrap();
     let mut pass = false;
 
-    // Zig: std.array_list.Managed(JSValue) — heap-backed list of JSValue.
-    // PORTING.md §JSC types: heap-backed Vec<JSValue> is not stack-scanned by JSC's conservative GC;
+    // A heap-backed Vec<JSValue> is not stack-scanned by JSC's conservative GC;
     // however every value pushed here is also reachable via the `returns` JSArray (kept live on the
-    // stack), so a plain Vec mirrors the Zig spec safely. SuccessfulReturnsFormatter expects &Vec.
+    // stack), so a plain Vec is safe. SuccessfulReturnsFormatter expects &Vec.
     let mut successful_returns: Vec<JSValue> = Vec::new();
 
     let mut has_errors = false;
@@ -95,8 +93,7 @@ pub(crate) fn to_have_returned_with(
             return this.throw(global, signature, format_args!("\n\n{}\n", diff_format));
         }
 
-        // PORT NOTE: Zig shares one `*Formatter` across both `toFmt` calls; in Rust the
-        // `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
+        // The `ZigFormatter` adapter holds `&'a mut Formatter`, so two live adapters cannot alias
         // the same backing formatter. Use a second formatter for the received value —
         // `make_formatter` is a trivial struct init with no shared state between values.
         let mut formatter2 = super::make_formatter(global);
@@ -111,7 +108,7 @@ pub(crate) fn to_have_returned_with(
         );
     }
 
-    // PORT NOTE: list_formatter holds &mut Formatter via RefCell, so a separate formatter is
+    // list_formatter holds &mut Formatter via RefCell, so a separate formatter is
     // required for the inline `expected.to_fmt` argument used alongside it in the same format_args!.
     let mut list_fmt = super::make_formatter(global);
 
@@ -122,10 +119,6 @@ pub(crate) fn to_have_returned_with(
             returns,
             formatter: core::cell::RefCell::new(&mut list_fmt),
         };
-        // TODO(port): Output.prettyFmt comptime color dispatch — Zig branches on
-        // `Output.enable_ansi_colors_stderr` to substitute/strip `<green>`/`<r>` tags at comptime.
-        // `Expect::throw` → `throw_pretty` handles tag substitution at runtime, so collapse both arms.
-        // PERF(port): was comptime bool dispatch (`switch inline else`).
         return this.throw(
             global,
             signature,
@@ -144,10 +137,6 @@ pub(crate) fn to_have_returned_with(
             successful_returns: &successful_returns,
             formatter: core::cell::RefCell::new(&mut list_fmt),
         };
-        // TODO(port): Output.prettyFmt comptime color dispatch — Zig branches on
-        // `Output.enable_ansi_colors_stderr` to substitute/strip `<green>`/`<red>` tags at comptime.
-        // `Expect::throw` → `throw_pretty` handles tag substitution at runtime, so collapse both arms.
-        // PERF(port): was comptime bool dispatch (`switch inline else`).
         return this.throw(
             global,
             signature,
@@ -160,5 +149,3 @@ pub(crate) fn to_have_returned_with(
         );
     }
 }
-
-// ported from: src/test_runner/expect/toHaveReturnedWith.zig
diff --git a/src/runtime/test_runner/expect/toInclude.rs b/src/runtime/test_runner/expect/toInclude.rs
index 89e7fafe8cc..270097d61f8 100644
--- a/src/runtime/test_runner/expect/toInclude.rs
+++ b/src/runtime/test_runner/expect/toInclude.rs
@@ -5,4 +5,3 @@ use super::Expect;
 pub(crate) fn to_include(this: &Expect, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     this.run_string_affix_matcher(global, frame, "toInclude", "include", strings::contains)
 }
-// ported from: src/test_runner/expect/toInclude.zig
diff --git a/src/runtime/test_runner/expect/toIncludeRepeated.rs b/src/runtime/test_runner/expect/toIncludeRepeated.rs
index da08b0adca7..a8c8573bc88 100644
--- a/src/runtime/test_runner/expect/toIncludeRepeated.rs
+++ b/src/runtime/test_runner/expect/toIncludeRepeated.rs
@@ -62,7 +62,7 @@ impl Expect {
 
         let expect_string_as_str_owned = expect_string.to_slice_or_null(global)?;
         let sub_string_as_str_owned = substring.to_slice_or_null(global)?;
-        // defer .deinit() → handled by Drop
+        // cleanup handled by Drop
 
         let expect_string_as_str = expect_string_as_str_owned.slice();
         let sub_string_as_str = sub_string_as_str_owned.slice();
@@ -73,7 +73,7 @@ impl Expect {
             )));
         }
 
-        // std.mem.count(u8, haystack, needle) — non-overlapping occurrence count
+        // Non-overlapping occurrence count.
         let actual_count = expect_string_as_str.find_iter(sub_string_as_str).count();
         let mut pass = actual_count == count_as_num as usize;
 
@@ -84,20 +84,18 @@ impl Expect {
             return Ok(JSValue::UNDEFINED);
         }
 
-        // PORT NOTE: Zig aliased one `*Formatter` for all three fmt adapters; Rust `to_fmt` takes
-        // `&mut Formatter` and the returned adapter holds that borrow live, so three concurrent
-        // adapters need three formatters. `make_formatter` is a trivial struct init with no shared
-        // state between values.
+        // `to_fmt` takes `&mut Formatter` and the returned adapter holds that borrow live, so
+        // three concurrent adapters need three formatters. `make_formatter` is a trivial struct
+        // init with no shared state between values.
         let mut formatter = super::make_formatter(global);
         let mut formatter2 = super::make_formatter(global);
         let mut formatter3 = super::make_formatter(global);
-        // defer formatter.deinit() → handled by Drop
+        // formatter cleanup handled by Drop
         let expect_string_fmt = expect_string.to_fmt(&mut formatter);
         let substring_fmt = substring.to_fmt(&mut formatter2);
         let times_fmt = count.to_fmt(&mut formatter3);
 
-        // PORT NOTE: Zig builds `"\n\n" ++ expected_line ++ received_line` at comptime via named
-        // consts; Rust `concat!` only accepts literal tokens (not `const` items), so the pieces are
+        // `concat!` only accepts literal tokens (not `const` items), so the message pieces are
         // inlined directly below instead of bound to RECEIVED_LINE/EXPECTED_LINE locals.
         if not {
             if count_as_num == 0 {
@@ -174,5 +172,3 @@ impl Expect {
         }
     }
 }
-
-// ported from: src/test_runner/expect/toIncludeRepeated.zig
diff --git a/src/runtime/test_runner/expect/toMatch.rs b/src/runtime/test_runner/expect/toMatch.rs
index a63057093ba..c7beace723e 100644
--- a/src/runtime/test_runner/expect/toMatch.rs
+++ b/src/runtime/test_runner/expect/toMatch.rs
@@ -3,7 +3,6 @@ use super::JSValueTestExt;
 
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_match(
     this: &Expect,
     global: &JSGlobalObject,
@@ -53,15 +52,13 @@ pub(crate) fn to_match(
     }
 
     // handle failure
-    // PORT NOTE: Zig shares one Formatter across both `to_fmt` calls; in Rust each
-    // `to_fmt` borrows `&mut Formatter` for the lifetime of the returned wrapper, so
+    // Each `to_fmt` borrows `&mut Formatter` for the lifetime of the returned wrapper, so
     // we need a second Formatter for the second value (matches toContain.rs / toBe.rs).
     let mut formatter2 = super::make_formatter(global);
     let expected_fmt = expected_value.to_fmt(&mut formatter);
     let value_fmt = value.to_fmt(&mut formatter2);
 
     if not {
-        // TODO(port): `comptime getSignature(...)` — ensure `get_signature` is `const fn` (or macro) returning &'static str.
         let signature = Expect::get_signature("toMatch", "<green>expected<r>", true);
         return this.throw(
             global,
@@ -93,5 +90,3 @@ pub(crate) fn to_match(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toMatch.zig
diff --git a/src/runtime/test_runner/expect/toMatchInlineSnapshot.rs b/src/runtime/test_runner/expect/toMatchInlineSnapshot.rs
index 2580ef565c0..1bf737fd5e6 100644
--- a/src/runtime/test_runner/expect/toMatchInlineSnapshot.rs
+++ b/src/runtime/test_runner/expect/toMatchInlineSnapshot.rs
@@ -3,13 +3,12 @@ use bun_core::ZigString;
 
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_match_inline_snapshot(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: `defer this.postMatch(globalThis)` — wrap `this` in a scopeguard that owns the
+    // `defer this.postMatch(globalThis)` — wrap `this` in a scopeguard that owns the
     // &mut Expect and runs post_match on drop, so the body can borrow through DerefMut without
     // overlapping with the deferred call (matches toThrowErrorMatchingInlineSnapshot.rs).
     let this = scopeguard::guard(this, |this| this.post_match(global));
@@ -98,5 +97,3 @@ pub(crate) fn to_match_inline_snapshot(
         "toMatchInlineSnapshot",
     )
 }
-
-// ported from: src/test_runner/expect/toMatchInlineSnapshot.zig
diff --git a/src/runtime/test_runner/expect/toMatchObject.rs b/src/runtime/test_runner/expect/toMatchObject.rs
index 74eaee1f875..411363d53c2 100644
--- a/src/runtime/test_runner/expect/toMatchObject.rs
+++ b/src/runtime/test_runner/expect/toMatchObject.rs
@@ -2,7 +2,6 @@ use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult};
 use super::DiffFormatter;
 use super::{get_signature, Expect};
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_match_object(
     this: &Expect,
     global: &JSGlobalObject,
@@ -65,5 +64,3 @@ pub(crate) fn to_match_object(
     let signature: &str = get_signature("toMatchObject", "<green>expected<r>", false);
     this.throw(global, signature, format_args!("\n\n{}\n", diff_formatter))
 }
-
-// ported from: src/test_runner/expect/toMatchObject.zig
diff --git a/src/runtime/test_runner/expect/toMatchSnapshot.rs b/src/runtime/test_runner/expect/toMatchSnapshot.rs
index 7ba68f792c0..cae5037fada 100644
--- a/src/runtime/test_runner/expect/toMatchSnapshot.rs
+++ b/src/runtime/test_runner/expect/toMatchSnapshot.rs
@@ -4,13 +4,12 @@ use bun_core::ZigString;
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_match_snapshot(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: reshaped for borrowck — `defer this.postMatch(globalThis)` is expressed by
+    // reshaped for borrowck — post-match cleanup is expressed by
     // wrapping `this` in a scopeguard so `post_match` runs on every exit path while we still
     // deref through the guard for the body.
     let this = scopeguard::guard(this, |this| this.post_match(global));
@@ -23,7 +22,6 @@ pub(crate) fn to_match_snapshot(
 
     let not = this.flags.get().not();
     if not {
-        // PERF(port): was `comptime getSignature(...)` — would require `get_signature` to be `const fn`.
         let signature = get_signature("toMatchSnapshot", "", true);
         return this.throw_fmt(
             global,
@@ -34,7 +32,6 @@ pub(crate) fn to_match_snapshot(
     }
 
     let Some(buntest_strong) = this.bun_test() else {
-        // PERF(port): was `comptime getSignature(...)` — would require `get_signature` to be `const fn`.
         let signature = get_signature("toMatchSnapshot", "", true);
         return this.throw_fmt(
             global,
@@ -43,7 +40,7 @@ pub(crate) fn to_match_snapshot(
             format_args!("\n\n<b>Matcher error<r>: Snapshot matchers cannot be used outside of a test\n"),
         );
     };
-    let _ = buntest_strong; // Drop at scope exit replaces `defer buntest_strong.deinit()`.
+    let _ = buntest_strong; // released by Drop at scope exit.
 
     let mut hint_string: ZigString = ZigString::EMPTY;
     let mut property_matchers: Option<JSValue> = None;
@@ -65,7 +62,6 @@ pub(crate) fn to_match_snapshot(
         }
         _ => {
             if !arguments[0].is_object() {
-                // PERF(port): was `comptime getSignature(...)` — would require `get_signature` to be `const fn`.
                 let signature =
                     get_signature("toMatchSnapshot", "<green>properties<r><d>, <r>hint", false);
                 return this.throw_fmt(
@@ -92,7 +88,7 @@ pub(crate) fn to_match_snapshot(
     }
 
     let hint = hint_string.to_slice();
-    // `defer hint.deinit()` — Drop handles it.
+    // `hint` cleanup handled by Drop.
 
     let value: JSValue = this.get_value(
         global,
@@ -103,5 +99,3 @@ pub(crate) fn to_match_snapshot(
 
     Expect::snapshot(&**this, global, value, property_matchers, hint.slice(), "toMatchSnapshot")
 }
-
-// ported from: src/test_runner/expect/toMatchSnapshot.zig
diff --git a/src/runtime/test_runner/expect/toSatisfy.rs b/src/runtime/test_runner/expect/toSatisfy.rs
index 40f4b06dc28..813cbb5cac9 100644
--- a/src/runtime/test_runner/expect/toSatisfy.rs
+++ b/src/runtime/test_runner/expect/toSatisfy.rs
@@ -4,7 +4,6 @@ use bun_core::ZigString;
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_satisfy(this: &Expect, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     // toSatisfy bypasses get_value (no .resolves/.rejects handling), so it cannot use
     // the full `matcher_prelude`; only the post_match guard mechanism unifies.
@@ -50,11 +49,10 @@ pub(crate) fn to_satisfy(this: &Expect, global: &JSGlobalObject, frame: &CallFra
         return Ok(JSValue::UNDEFINED);
     }
 
-    // PORT NOTE: `defer formatter.deinit()` dropped — Formatter impls Drop.
+    // Formatter impls Drop.
     let mut formatter = super::make_formatter(global);
 
     if not {
-        // PERF(port): was `comptime getSignature(...)` — could const-eval the signature.
         let signature = get_signature("toSatisfy", "<green>expected<r>", true);
         return this.throw(
             global,
@@ -63,11 +61,9 @@ pub(crate) fn to_satisfy(this: &Expect, global: &JSGlobalObject, frame: &CallFra
         );
     }
 
-    // PERF(port): was `comptime getSignature(...)` — could const-eval the signature.
     let signature = get_signature("toSatisfy", "<green>expected<r>", false);
 
-    // PORT NOTE: reshaped for borrowck — Zig held two `*Formatter` aliases via `toFmt`;
-    // Rust `to_fmt(&mut Formatter)` borrows exclusively, so use a second formatter for the
+    // `to_fmt(&mut Formatter)` borrows exclusively, so use a second formatter for the
     // received value (matches the toBeGreaterThan.rs pattern).
     let mut formatter2 = super::make_formatter(global);
     this.throw(
@@ -80,5 +76,3 @@ pub(crate) fn to_satisfy(this: &Expect, global: &JSGlobalObject, frame: &CallFra
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toSatisfy.zig
diff --git a/src/runtime/test_runner/expect/toStartWith.rs b/src/runtime/test_runner/expect/toStartWith.rs
index bec23bbaad7..68487e94f13 100644
--- a/src/runtime/test_runner/expect/toStartWith.rs
+++ b/src/runtime/test_runner/expect/toStartWith.rs
@@ -5,4 +5,3 @@ use super::Expect;
 pub(crate) fn to_start_with(this: &Expect, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     this.run_string_affix_matcher(global, frame, "toStartWith", "start with", strings::starts_with)
 }
-// ported from: src/test_runner/expect/toStartWith.zig
diff --git a/src/runtime/test_runner/expect/toStrictEqual.rs b/src/runtime/test_runner/expect/toStrictEqual.rs
index 66fb0397282..9c246be1022 100644
--- a/src/runtime/test_runner/expect/toStrictEqual.rs
+++ b/src/runtime/test_runner/expect/toStrictEqual.rs
@@ -51,5 +51,3 @@ impl Expect {
         this.throw(global, signature, format_args!("\n\n{}\n", diff_formatter))
     }
 }
-
-// ported from: src/test_runner/expect/toStrictEqual.zig
diff --git a/src/runtime/test_runner/expect/toThrow.rs b/src/runtime/test_runner/expect/toThrow.rs
index 11cd6430cdd..db44625079a 100644
--- a/src/runtime/test_runner/expect/toThrow.rs
+++ b/src/runtime/test_runner/expect/toThrow.rs
@@ -10,13 +10,12 @@ use super::ExpectAny;
 use super::expect_any_js;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_throw(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // `defer this.postMatch(globalThis)` — scopeguard owns the &mut Expect and runs
+    // The scopeguard owns the &mut Expect and runs
     // post_match on drop; the body re-borrows `this` through Deref/DerefMut so post_match
     // runs on every exit path (Ok and Err alike).
     let this = scopeguard::guard(this, |t| t.post_match(global));
@@ -67,7 +66,6 @@ pub(crate) fn to_throw(
     let did_throw = result_.is_some();
 
     if not {
-        // PERF(port): was comptime — get_signature should be const fn returning &'static str
         let signature: &'static str = get_signature("toThrow", "<green>expected<r>", true);
 
         if !did_throw {
@@ -409,8 +407,7 @@ pub(crate) fn to_throw(
     let result = return_value_from_function;
     let mut formatter = Formatter::new(global).with_quote_strings(true);
     let mut formatter2 = super::make_formatter(global);
-    // PORT NOTE: Zig `received_line` was concatenated via `++` into each fmt string
-    // below; Rust `format_args!` only accepts literals so the value is inlined at each site.
+    // `format_args!` only accepts literal fmt strings, so `received_line` is inlined at each site.
     // received_line = "Received function did not throw\nReceived value: <red>{f}<r>\n"
 
     if expected_value.is_empty() || expected_value.is_undefined() {
@@ -475,5 +472,3 @@ pub(crate) fn to_throw(
         ),
     )
 }
-
-// ported from: src/test_runner/expect/toThrow.zig
diff --git a/src/runtime/test_runner/expect/toThrowErrorMatchingInlineSnapshot.rs b/src/runtime/test_runner/expect/toThrowErrorMatchingInlineSnapshot.rs
index b9cdac919fa..4849a213f37 100644
--- a/src/runtime/test_runner/expect/toThrowErrorMatchingInlineSnapshot.rs
+++ b/src/runtime/test_runner/expect/toThrowErrorMatchingInlineSnapshot.rs
@@ -3,14 +3,12 @@ use bun_core::ZigString;
 
 use super::Expect;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_throw_error_matching_inline_snapshot(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // Zig: `defer this.postMatch(globalThis);`
-    // PORT NOTE: reshaped for borrowck — guard owns the &mut and Derefs to it.
+    // The guard owns the &mut, Derefs to it, and runs post_match on Drop.
     let this = scopeguard::guard(this, |t| t.post_match(global));
 
     let this_value = frame.this();
@@ -54,13 +52,12 @@ pub(crate) fn to_throw_error_matching_inline_snapshot(
         }
     }
 
-    // Zig: `expected_string.toSlice(default_allocator)` + `defer expected.deinit()`.
-    // Allocator param dropped; the returned slice owns its buffer and frees on Drop.
+    // The returned slice owns its buffer and frees on Drop.
     let expected = expected_string.to_slice();
 
     let expected_slice: Option<&[u8]> = if has_expected { Some(expected.slice()) } else { None };
 
-    // PORT NOTE: reshaped for borrowck — hoist get_value out so the two &mut self
+    // reshaped for borrowck — hoist get_value out so the two &mut self
     // receivers don't overlap.
     let received = this.get_value(
         global,
@@ -87,5 +84,3 @@ pub(crate) fn to_throw_error_matching_inline_snapshot(
         "toThrowErrorMatchingInlineSnapshot",
     )
 }
-
-// ported from: src/test_runner/expect/toThrowErrorMatchingInlineSnapshot.zig
diff --git a/src/runtime/test_runner/expect/toThrowErrorMatchingSnapshot.rs b/src/runtime/test_runner/expect/toThrowErrorMatchingSnapshot.rs
index 107cc468106..a89d4c59025 100644
--- a/src/runtime/test_runner/expect/toThrowErrorMatchingSnapshot.rs
+++ b/src/runtime/test_runner/expect/toThrowErrorMatchingSnapshot.rs
@@ -4,14 +4,13 @@ use bun_core::ZigString;
 use super::Expect;
 use super::get_signature;
 
-// TODO(port): #[bun_jsc::host_fn(method)] — must be inside `impl Expect`; shim wired by JsClass codegen
 pub(crate) fn to_throw_error_matching_snapshot(
     this: &Expect,
     global: &JSGlobalObject,
     frame: &CallFrame,
 ) -> JsResult<JSValue> {
-    // PORT NOTE: Zig `defer this.postMatch(globalThis)` — guard runs post_match on Drop for every
-    // exit path (early `return Err`, `?`, fall-through), matching Zig semantics.
+    // The guard runs post_match on Drop for every exit path
+    // (early `return Err`, `?`, fall-through).
     let this = this.post_match_guard(global);
 
     let this_value = frame.this();
@@ -40,7 +39,6 @@ pub(crate) fn to_throw_error_matching_snapshot(
             format_args!("\n\n<b>Matcher error<r>: Snapshot matchers cannot be used outside of a test\n"),
         );
     };
-    // Zig: `defer bunTest_strong.deinit();` — handled by Drop.
     let _ = &bun_test_strong;
 
     let mut hint_string: ZigString = ZigString::EMPTY;
@@ -69,7 +67,6 @@ pub(crate) fn to_throw_error_matching_snapshot(
     }
 
     let hint = hint_string.to_slice();
-    // Zig: `defer hint.deinit();` — handled by Drop.
 
     let Some(value): Option<JSValue> = this.fn_to_err_string_or_undefined(
         global,
@@ -92,5 +89,3 @@ pub(crate) fn to_throw_error_matching_snapshot(
 
     this.snapshot(global, value, None, hint.slice(), "toThrowErrorMatchingSnapshot")
 }
-
-// ported from: src/test_runner/expect/toThrowErrorMatchingSnapshot.zig
diff --git a/src/runtime/test_runner/harness/fixtures.rs b/src/runtime/test_runner/harness/fixtures.rs
index 6f0f5af5b81..4d03be16665 100644
--- a/src/runtime/test_runner/harness/fixtures.rs
+++ b/src/runtime/test_runner/harness/fixtures.rs
@@ -1,18 +1,9 @@
-//! Ported from src/test_runner/harness/fixtures.zig
 
 use phf::phf_map;
 
-// TODO(port): Zig source has a duplicate `"simple-component.tsx"` entry (lines 5-6); phf rejects
-// duplicate keys at compile time so the second one is dropped here. Verify upstream intent.
 pub static FIXTURES: phf::Map<&'static [u8], &'static [u8]> = phf_map! {
     b"package.json" => include_bytes!("./fixtures/package.json"),
     b"tsconfig.json" => include_bytes!("./fixtures/tsconfig.json"),
     b"simple-component.js" => include_bytes!("./fixtures/simple-component.js"),
     b"simple-component.tsx" => include_bytes!("./fixtures/simple-component.tsx"),
 };
-
-
-
-
-
-// ported from: src/test_runner/harness/fixtures.zig
diff --git a/src/runtime/test_runner/harness/recover.rs b/src/runtime/test_runner/harness/recover.rs
index 6ff1d625bd2..ecf4d2949d3 100644
--- a/src/runtime/test_runner/harness/recover.rs
+++ b/src/runtime/test_runner/harness/recover.rs
@@ -6,21 +6,18 @@
 
 use core::cell::Cell;
 
-// TODO(port): move externs to <area>_sys crate
-
 #[cfg(windows)]
 type Context = bun_sys::windows::CONTEXT;
 #[cfg(all(target_os = "linux", target_env = "musl"))]
 type Context = musl::jmp_buf;
 #[cfg(not(any(windows, all(target_os = "linux", target_env = "musl"))))]
-type Context = libc::ucontext_t; // TODO(port): std.c.ucontext_t — confirm libc crate vs bun_sys::c
+type Context = libc::ucontext_t;
 
 thread_local! {
     static TOP_CTX: Cell<Option<*const Context>> = const { Cell::new(None) };
 }
 
 /// RAII guard that restores `TOP_CTX` to a saved previous value on drop.
-/// Replaces the Zig `defer top_ctx = prev_ctx;` in `call`/`call_for_test`.
 struct TopCtxRestore {
     prev: Option<*const Context>,
 }
@@ -44,11 +41,6 @@ pub fn panicked() {
     }
 }
 
-// PORT NOTE: Zig's `ExtErrType`/`ReturnType` were comptime @typeInfo helpers
-// that extended the callee's error set with `error.Panic`. In Rust,
-// `bun_core::Error` is a NonZeroU16 tag space that already covers every error
-// name (including `Panic` via `bun_core::err!("Panic")`), so the type-level
-// extension collapses and the helpers are dropped.
 
 pub fn call_for_test(
     test_func: fn() -> Result<(), bun_core::Error>,
@@ -71,10 +63,10 @@ pub fn call_for_test(
 /// Calls `func`, guarding from runtime errors.
 /// Returns `error.Panic` when recovers from runtime error.
 /// Otherwise returns the return value of func.
-// PORT NOTE: Zig signature was `call(func: anytype, args: anytype)` with
-// `@call(.auto, func, args)`. Rust cannot forward an arbitrary heterogeneous
-// argument tuple without variadics; callers should wrap the invocation in a
-// closure. Return type uses bun_core::Error (see ExtErrType note above).
+// Rust cannot forward an arbitrary heterogeneous argument tuple without
+// variadics; callers should wrap the invocation in a closure. The return type
+// uses bun_core::Error, which already covers every error name (including
+// `Panic` via `bun_core::err!("Panic")`).
 pub fn call<T>(
     func: impl FnOnce() -> Result<T, bun_core::Error>,
 ) -> Result<T, bun_core::Error> {
@@ -96,7 +88,7 @@ pub fn call<T>(
 // windows
 #[cfg(windows)]
 unsafe extern "system" {
-    // TODO(port): move to bun_sys::windows (ntdll)
+    // ntdll.dll; bun_sys::windows::ntdll_context only declares the capture half.
     pub fn RtlRestoreContext(
         ContextRecord: *const CONTEXT,
         ExceptionRecord: *const EXCEPTION_RECORD, // nullable
@@ -113,14 +105,18 @@ unsafe extern "C" {
 #[cfg(all(target_os = "linux", target_env = "musl"))]
 mod musl {
     use core::ffi::c_int;
-    // TODO(port): Zig used @cImport(@cInclude("setjmp.h")).jmp_buf — confirm
-    // exact musl jmp_buf size/align per target arch. This is a
-    // STACK VALUE (`var ctx = std.mem.zeroes(Context); setjmp(&ctx)`), not an
-    // opaque handle, so it must reserve real storage — a ZST would let setjmp
-    // scribble past the allocation. 32×u64 over-reserves vs every musl arch.
+    // This is a STACK VALUE (a zeroed `Context` lives on the caller's stack and
+    // setjmp writes into it), not an opaque handle, so it must reserve real
+    // storage — a ZST would let
+    // setjmp scribble past the allocation. musl's full `jmp_buf` is
+    // `{ __jmp_buf __jb; unsigned long __fl; unsigned long __ss[16]; }`, where
+    // `__jmp_buf` is 8 longs on x86_64 and 22 longs on aarch64 — i.e. 25 and 39
+    // longs total respectively. 64×u64 (512 bytes) over-reserves the full
+    // struct on every musl arch; alignment of `long` is at most 8, so
+    // align(16) over-aligns.
     #[repr(C, align(16))]
     pub(super) struct jmp_buf {
-        _buf: [u64; 32],
+        _buf: [u64; 64],
     }
     unsafe extern "C" {
         pub(super) fn setjmp(env: *mut jmp_buf) -> c_int;
@@ -142,9 +138,8 @@ unsafe fn get_context(ctx: *mut Context) {
     }
     #[cfg(not(any(windows, all(target_os = "linux", target_env = "musl"))))]
     {
-        // Zig called std.debug.getContext(ctx) which wraps getcontext(3).
-        // The `libc` crate omits the binding on Darwin and the BSDs; declare
-        // locally (uniform across all unix targets).
+        // The `libc` crate omits the getcontext(3) binding on Darwin and the
+        // BSDs; declare it locally (uniform across all unix targets).
         unsafe extern "C" { fn getcontext(ucp: *mut libc::ucontext_t) -> core::ffi::c_int; }
         // SAFETY: ctx is a valid, writable, properly-aligned ucontext_t (caller contract).
         let _ = unsafe { getcontext(ctx) };
@@ -175,19 +170,18 @@ unsafe fn set_context(ctx: *const Context) -> ! {
 
 /// Panic handler that if there is a recover call in current thread continues
 /// from recover call. Otherwise calls the default panic.
-/// Install at root source file as `pub const panic = @import("recover").panic;`
-// TODO(port): Zig exposed this as `std.debug.FullPanic(handler)` — a type
-// installed at the root file as `pub const panic`. Rust has no equivalent
-// declarative panic-handler slot; wire this via `std::panic::set_hook`
-// (or a `#[panic_handler]` in no_std) at startup.
+///
+/// Rust has no declarative panic-handler slot, so any caller adopting this
+/// module must invoke this from a hook installed via `std::panic::set_hook`
+/// at startup.
 pub fn panic(msg: &[u8], first_trace_addr: Option<usize>) -> ! {
     panicked();
-    // TODO(port): std.debug.defaultPanic — route to bun_core's default panic.
+    // `first_trace_addr` is unused: `bun_core::Output::panic` lowers to
+    // `core::panic!`, and Rust's panic machinery captures its own backtrace at
+    // the panic site rather than starting from a caller-supplied address.
     let _ = first_trace_addr;
     bun_core::Output::panic(format_args!("{}", bstr::BStr::new(msg)));
 }
 
 #[cfg(windows)]
 use bun_sys::windows::{CONTEXT, EXCEPTION_RECORD};
-
-// ported from: src/test_runner/harness/recover.zig
diff --git a/src/runtime/test_runner/jest.rs b/src/runtime/test_runner/jest.rs
index 32cb7692e61..a2a3f8ffdeb 100644
--- a/src/runtime/test_runner/jest.rs
+++ b/src/runtime/test_runner/jest.rs
@@ -50,8 +50,7 @@ impl CurrentFile {
             return;
         }
         if reporter.reporters.dots || reporter.reporters.only_failures {
-            // PORT NOTE: Zig's freeAndClear() freed the old allocations; in Rust,
-            // assigning into the Box<[u8]> fields below drops the previous values.
+            // Assigning into the Box<[u8]> fields below drops the previous values.
             self.title = Box::<[u8]>::from(title);
             self.prefix = Box::<[u8]>::from(prefix);
             self.repeat_info.count = repeat_count;
@@ -122,13 +121,14 @@ pub struct TestRunner<'a> {
     /// shuffle PRNG from hash(seed, file_path) so within-file test order is
     /// independent of which worker (and which prior files) ran it.
     pub randomize_seed: Option<u32>,
-    // TODO(port): lifetime — likely borrowed from test_options
+    /// Borrowed view over `ctx.test_options.concurrent_test_glob` (owned
+    /// `Vec<Box<[u8]>>` with process lifetime); see the detach in
+    /// `test_command.rs` where this is populated.
     pub concurrent_test_glob: Option<&'a [&'a [u8]]>,
     pub last_file: u64,
     pub bail: u32,
     pub max_concurrency: u32,
 
-    // PORT NOTE: `std.mem.Allocator param` field deleted — global mimalloc.
     pub drainer: jsc::AnyTask::AnyTask,
 
     pub has_pending_tests: bool,
@@ -164,7 +164,7 @@ impl<'a> TestRunner<'a> {
         {
             return bun_core::Timespec::EPOCH;
         }
-        // PORT NOTE: bun_event_loop carries a local Timespec stub with the
+        // bun_event_loop carries a local Timespec stub with the
         // same `{sec, nsec}` shape as bun_core::Timespec; convert by field
         // until the lower tier unifies on bun_core::Timespec (see
         // src/runtime/timer/mod.rs ElTimespec alias).
@@ -289,22 +289,21 @@ bun_collections::multi_array_columns! {
         log: bun_ast::Log,
     }
 }
-// PORT NOTE: Zig used ArrayIdentityContext; u32 keys hash as identity in bun_collections.
+// u32 keys hash as identity in bun_collections.
 pub(crate) type FileMap = ArrayHashMap<u32, u32>;
 
 #[allow(non_snake_case)]
 pub mod Jest {
     use super::*;
 
-    // Zig `pub var runner: ?*TestRunner = null`.
-    // PORTING.md §Global mutable state: JS-VM-thread-only singleton; RacyCell
+    // JS-VM-thread-only singleton; RacyCell
     // over `Option<NonNull<_>>` so direct `.read()` projections in
     // `snapshot.rs` etc. keep their shape.
     pub(crate) static RUNNER: bun_core::RacyCell<Option<NonNull<TestRunner<'static>>>> =
         bun_core::RacyCell::new(None);
 
     pub(crate) fn runner() -> Option<&'static mut TestRunner<'static>> {
-        // SAFETY: single-threaded JS VM; matches Zig's unguarded global access.
+        // SAFETY: RUNNER is only ever accessed from the single JS VM thread.
         unsafe { RUNNER.read().map(|p| &mut *p.as_ptr()) }
     }
 
@@ -313,7 +312,7 @@ pub mod Jest {
     /// `&BunTestRoot`, `&mut BunTest`) is already live — see
     /// `BunTestRoot::on_before_print` / `BunTest::enter_file`.
     pub(crate) fn runner_ptr() -> Option<NonNull<TestRunner<'static>>> {
-        // SAFETY: single-threaded JS VM; matches Zig's unguarded global access.
+        // SAFETY: RUNNER is only ever accessed from the single JS VM thread.
         unsafe { RUNNER.read() }
     }
 
@@ -450,7 +449,6 @@ pub mod Jest {
         fake_timers::put_timers_fns(global_object, jest, vi);
     }
 
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         pub(crate) safe fn Bun__Jest__testModuleObject(global: &JSGlobalObject) -> JSValue;
     }
@@ -522,7 +520,7 @@ pub mod on_unhandled_rejection {
         rejection: JSValue,
     ) {
         if let Some(buntest_strong) = bun_test::clone_active_strong() {
-            // PORT NOTE: `defer buntest_strong.deinit()` — Rc::drop handles this.
+            // `buntest_strong` released by Rc drop.
             // SAFETY: single-threaded JS VM; `buntest_strong` is the only handle
             // dereferenced for this scope and is dropped before `BunTest::run`
             // re-borrows. Const→mut projection is centralized in `buntest_as_mut`
@@ -530,7 +528,7 @@ pub mod on_unhandled_rejection {
             let buntest = unsafe { bun_test::buntest_as_mut(&buntest_strong) };
             // mark unhandled errors as belonging to the currently active test. note that this can be misleading.
             let mut current_state_data = buntest.get_current_state_data();
-            // PORT NOTE: split entry()/sequence() borrows via raw-ptr capture (per-use reborrow).
+            // split entry()/sequence() borrows via raw-ptr capture (per-use reborrow).
             let entry_ptr: Option<*mut bun_test::ExecutionEntry> = current_state_data
                 .entry(buntest)
                 .map(std::ptr::from_mut::<bun_test::ExecutionEntry>);
@@ -549,11 +547,10 @@ pub mod on_unhandled_rejection {
                 &current_state_data,
             );
             buntest.add_result(current_state_data);
-            if let Err(e) = bun_test::BunTest::run(&buntest_strong, global_object) {
-                // TODO(blocked_on: bun_jsc::JSGlobalObject::report_uncaught_exception_from_error):
-                // the inherent method lives in the cfg-gated JSGlobalObject.rs impl.
-                let _ = e;
-            }
+            // `report_unhandled` reports the uncaught exception, with a guard
+            // for `Terminated` (which carries no pending exception to take).
+            use bun_jsc::JsResultExt as _;
+            bun_test::BunTest::run(&buntest_strong, global_object).report_unhandled(global_object);
             return;
         }
 
@@ -576,7 +573,6 @@ fn consume_arg(
     arg: JSValue,
     fallback: &[u8],
 ) -> JsResult<()> {
-    // TODO(port): narrow error set
     if should_write {
         let owned_slice = arg.to_slice_or_null(global_this)?;
         array_list.extend_from_slice(owned_slice.slice());
@@ -595,7 +591,6 @@ pub(crate) fn format_label(
     function_args: &[JSValue],
     test_idx: usize,
 ) -> JsResult<Box<[u8]>> {
-    // TODO(port): narrow error set
     let mut idx: usize = 0;
     let mut args_idx: usize = 0;
     let mut list: Vec<u8> = Vec::with_capacity(label.len());
@@ -634,7 +629,6 @@ pub(crate) fn format_label(
                 let var_path = &label[var_start..var_end];
                 let value = function_args[0].get_if_property_exists_from_path(
                     global_this,
-                    // TODO(port): move to *_jsc
                     bun_core::String::init(var_path).to_js(global_this)?,
                 )?;
                 if !value.is_empty_or_undefined_or_null() {
@@ -645,7 +639,7 @@ pub(crate) fn format_label(
                         list.extend_from_slice(owned_slice.slice());
                     } else {
                         let mut formatter = crate::test_runner::expect::make_formatter(global_this);
-                        // PORT NOTE: `defer formatter.deinit()` — Drop handles this.
+                        // formatter cleanup handled by Drop.
                         write!(&mut list, "{}", value.to_fmt(&mut formatter)).unwrap();
                     }
                     idx = var_end;
@@ -713,7 +707,7 @@ pub(crate) fn format_label(
                 }
                 b'j' | b'o' => {
                     let mut str = bun_core::String::empty();
-                    // PORT NOTE: `defer str.deref()` — Drop handles this.
+                    // `str` released by Drop.
                     // Use jsonStringifyFast for SIMD-optimized serialization
                     current_arg.json_stringify_fast(global_this, &mut str)?;
                     let owned_slice = str.to_owned_slice();
@@ -752,7 +746,6 @@ pub(crate) fn format_label(
 pub(crate) fn capture_test_line_number(callframe: &CallFrame, global_this: &JSGlobalObject) -> u32 {
     if let Some(runner) = Jest::runner() {
         if runner.test_options.reporters.junit {
-            // TODO(port): move to <area>_sys
             unsafe extern "C" {
                 fn Bun__CallFrame__getLineNumber(
                     callframe: *const CallFrame,
@@ -765,6 +758,3 @@ pub(crate) fn capture_test_line_number(callframe: &CallFrame, global_this: &JSGl
     }
     0
 }
-
-
-// ported from: src/test_runner/jest.zig
diff --git a/src/runtime/test_runner/mod.rs b/src/runtime/test_runner/mod.rs
index dd7f5a3099d..5b16e24b857 100644
--- a/src/runtime/test_runner/mod.rs
+++ b/src/runtime/test_runner/mod.rs
@@ -91,8 +91,8 @@ pub mod expect {
     pub use super::expect_core::mock;
     pub use super::diff_format::DiffFormatter;
 
-    /// `Expect.js.*GetCached` / `*SetCached` accessors (Zig: `Expect.js.capturedValueGetCached`
-    /// etc., generate-classes.ts `cache: true` slots from jest.classes.ts:226). Exposed as a
+    /// `Expect.js.*GetCached` / `*SetCached` accessors (generate-classes.ts
+    /// `cache: true` slots from jest.classes.ts). Exposed as a
     /// sibling `js` module so matcher drafts can write `super::js::captured_value_get_cached(..)`
     /// — `Expect::js::..` does not resolve in Rust (no inherent associated modules).
     pub mod js {
@@ -112,8 +112,7 @@ pub mod expect {
         Expect::get_signature(matcher_name, args, not)
     }
 
-    /// Const-context twin of `get_signature` — Zig's `getSignature` is a
-    /// `comptime` fn (.zig:103-109) that concatenates string literals. Rust
+    /// Const-context twin of `get_signature`. Rust
     /// has no const-fn string concat, so call sites that need a `&'static
     /// str` constant (e.g. inside `const_format::concatcp!`) use this macro
     /// instead. `use super::get_signature;` imports both the fn (value
@@ -146,8 +145,8 @@ pub mod expect {
     use bun_jsc::console_object::Formatter;
     use bun_jsc::console_object::formatter::ZigFormatter;
 
-    /// `value.to_fmt(&mut formatter)` → `Display` adapter (Zig
-    /// `value.toFmt(&formatter)`). Returns the `ZigFormatter` wrapper.
+    /// `value.to_fmt(&mut formatter)` → `Display` adapter. Returns the
+    /// `ZigFormatter` wrapper.
     pub trait JSValueTestExt {
         fn to_fmt<'a, 'b>(self, f: &'a mut Formatter<'b>) -> ZigFormatter<'a, 'b>;
         fn jest_deep_equals(self, other: JSValue, global: &JSGlobalObject) -> JsResult<bool>;
@@ -199,7 +198,6 @@ pub mod expect {
         }
         #[inline]
         fn jest_snapshot_pretty_format<W: bun_io::Write>(self, out: &mut W, global: &JSGlobalObject) -> JsResult<()> {
-            // Port of Zig `JSValue.jestSnapshotPrettyFormat` (JSValue.zig:562).
             use super::pretty_format::{JestPrettyFormat, FormatOptions, MessageLevel};
             let fmt_options = FormatOptions {
                 enable_colors: false,
@@ -215,12 +213,11 @@ pub mod expect {
                 out,
                 fmt_options,
             )?;
-            // Zig: `try out.flush()` — `FormatOptions.flush` is false, so the
-            // formatter does not flush internally; a buffered `out` would
-            // otherwise drop trailing snapshot bytes. Propagate the writer
-            // error as a thrown JS error so the caller's `.is_err()` branch
-            // (expect.rs `to_match_snapshot_value_kind`) fires, matching the
-            // Zig `!void` contract.
+            // `FormatOptions.flush` is false, so the formatter does not flush
+            // internally; a buffered `out` would otherwise drop trailing
+            // snapshot bytes. Propagate the writer error as a thrown JS error
+            // so the caller's `.is_err()` branch
+            // (expect.rs `to_match_snapshot_value_kind`) fires.
             out.flush().map_err(|e| global.throw_error(e, "snapshot writer flush failed"))?;
             Ok(())
         }
@@ -310,13 +307,13 @@ pub mod expect {
         }
     }
 
-    /// Result of `JSValue::as_big_int_compare` (Zig `JSBigInt.CompareResult`).
+    /// Result of `JSValue::as_big_int_compare`.
     #[derive(Copy, Clone, PartialEq, Eq)]
     pub enum BigIntCompare { LessThan, Equal, GreaterThan, Undefined }
 
     /// Two-argument `throw_*` adapters — matcher modules call
-    /// `global.throw_pretty(FMT, format_args!(FMT, ..))` (Zig's `comptime fmt`
-    /// + `args`). Rust's `Arguments<'_>` already encloses the format string,
+    /// `global.throw_pretty(FMT, format_args!(FMT, ..))`.
+    /// Rust's `Arguments<'_>` already encloses the format string,
     /// so the leading `&str` is redundant; these shims drop it and forward to
     /// the bun_jsc inherents (`throw_pretty` runs the `<r>/<d>` → ANSI/strip
     /// pass at runtime; `throw`/`throw_invalid_arguments` do not).
@@ -352,9 +349,8 @@ pub mod expect {
     }
 
     // ── numeric ordering matchers (toBe{Greater,Less}Than[OrEqual]) ───────
-    // Four near-identical Zig matchers (toBeGreaterThan.zig:1-59 etc.) are
-    // copy-pasted upstream; collapse to one body parameterised by relation.
-    // Rust-side dedup, not a parity restore.
+    // The four matchers are near-identical; collapse to one body
+    // parameterised by relation.
 
     #[derive(Copy, Clone)]
     pub(super) enum OrderingRelation { Gt, Ge, Lt, Le }
@@ -393,7 +389,7 @@ pub mod expect {
             }
         }
         /// `other.asBigIntCompare(value)` arm — operands swapped, so the
-        /// relation is mirrored (Zig writes this out longhand per-matcher).
+        /// relation is mirrored.
         #[inline]
         fn cmp_bigint_rev(self, r: BigIntCompare) -> bool {
             use BigIntCompare::*;
@@ -408,7 +404,7 @@ pub mod expect {
 
     impl Expect {
         /// Shared body for `toBeGreaterThan` / `toBeGreaterThanOrEqual` /
-        /// `toBeLessThan` / `toBeLessThanOrEqual`. The four upstream Zig files
+        /// `toBeLessThan` / `toBeLessThanOrEqual`. The four matchers
         /// differ only in `name`, the `>`/`>=`/`<`/`<=` operator, and which
         /// `BigIntCompare` arms count as a pass — all of which `rel` encodes.
         pub(super) fn numeric_ordering_matcher(
@@ -605,5 +601,3 @@ cfg_jsc! {
     pub use pretty_format::JestPrettyFormat;
     pub use snapshot::Snapshots;
 }
-
-// ported from: src/runtime/test_runner/
diff --git a/src/runtime/test_runner/pretty_format.rs b/src/runtime/test_runner/pretty_format.rs
index 695fab0d872..7f2a0dfafe6 100644
--- a/src/runtime/test_runner/pretty_format.rs
+++ b/src/runtime/test_runner/pretty_format.rs
@@ -19,7 +19,7 @@ use crate::webcore::BlobExt as _;
 /// `.as_bytes()` method — covering all three call shapes in this file
 /// (`format_args!("{}", …)`, `writer.write_all(&…)`, `….as_bytes()`).
 #[inline]
-#[allow(clippy::disallowed_methods)] // template is a runtime parameter (Zig comptime param)
+#[allow(clippy::disallowed_methods)] // template is a runtime parameter
 fn pretty_fmt_const<const ENABLE_ANSI_COLORS: bool>(s: &str) -> PrettyStr {
     PrettyStr(Output::pretty_fmt_rt(s, ENABLE_ANSI_COLORS).0)
 }
@@ -44,9 +44,9 @@ impl core::fmt::Display for PrettyStr {
 
 use bun_jsc::c_api::{JSObjectGetPropertyAtIndex, JSObjectGetProxyTarget};
 
-/// `Expect*.js.*GetCached` accessors (Zig: `ExpectAny.js.constructorValueGetCached` etc.)
-/// — generate-classes.ts emits these per-type for `cache: true` props
-/// (jest.classes.ts). The Rust port has no inherent associated modules, so each
+/// `Expect*.js.*GetCached` accessors — generate-classes.ts emits these
+/// per-type for `cache: true` props (jest.classes.ts).
+/// Rust has no inherent associated modules, so each
 /// matcher gets a sibling `expect_js::*` module the same way `mod.rs` does for
 /// `Expect`.
 mod expect_js {
@@ -78,8 +78,11 @@ pub enum EventType {
     CloseEvent,
     ErrorEvent,
     OpenEvent,
+    // This variant absorbs any
+    // unrecognized event name. Values are only ever constructed via the MAP
+    // lookup below (never transmuted from a raw u8), so no other catch-all is
+    // needed.
     Unknown = 254,
-    // TODO(port): Zig non-exhaustive enum (`_`); other values are valid u8.
 }
 
 impl EventType {
@@ -119,7 +122,6 @@ pub enum MessageLevel {
     Error = 2,
     Debug = 3,
     Info = 4,
-    // TODO(port): Zig non-exhaustive enum (`_`).
 }
 
 #[repr(u32)]
@@ -139,7 +141,6 @@ pub enum MessageType {
     Profile = 11,
     ProfileEnd = 12,
     Image = 13,
-    // TODO(port): Zig non-exhaustive enum (`_`).
 }
 
 #[derive(Copy, Clone, Default)]
@@ -160,8 +161,7 @@ impl JestPrettyFormat {
         options: FormatOptions,
     ) -> JsResult<()> {
         let mut fmt: Formatter;
-        // Zig: defer { if (fmt.map_node) |node| { node.data = fmt.map; node.data.clearRetainingCapacity(); node.release(); } }
-        // (.zig:79-85). Realized as `impl Drop for Formatter` below — the pool
+        // `impl Drop for Formatter` below releases the pool map — the pool
         // node is acquired lazily inside `print_as` and swapped back on every
         // exit path of this function (early return, `?` propagation, happy path).
 
@@ -186,8 +186,7 @@ impl JestPrettyFormat {
                     let _ = writer.write_all(b"\n");
                 }
             } else {
-                // Zig: `defer { if (options.flush) writer.flush() catch {} }`
-                // (.zig:123-125) — fires on `try` propagation too. Wrap the
+                // The flush must fire on `?` propagation too. Wrap the
                 // fallible body and flush before bubbling the result.
                 let result: JsResult<()> = (|| {
                     if options.enable_colors {
@@ -210,9 +209,8 @@ impl JestPrettyFormat {
             return Ok(());
         }
 
-        // Zig: `defer { if (options.flush) writer.flush() catch {} }` (.zig:152-154)
-        // — fires on every exit including `try` propagation from `Tag.get` /
-        // `fmt.format`. Wrap the fallible body and flush before bubbling.
+        // The flush must fire on every exit including `?` propagation from
+        // `Tag::get` / `fmt.format`. Wrap the fallible body and flush before bubbling.
         fmt = Formatter::new(global);
         fmt.remaining_values = &vals[..len][1..];
         fmt.quote_strings = options.quote_strings;
@@ -287,8 +285,8 @@ impl JestPrettyFormat {
 pub mod visited {
     use super::*;
 
-    // PORT NOTE: JSValue keys live on heap; safe because every visited value is also
-    // on the stack frame during format() — conservative scan still sees them. Mirrors Zig 1:1.
+    // JSValue keys live on heap; safe because every visited value is also
+    // on the stack frame during format() — conservative scan still sees them.
     //
     // `HashMap<JSValue, ()>` is a foreign type, so we cannot impl the foreign
     // `ObjectPoolType` trait on it directly (orphan rule). A `#[repr(transparent)]`
@@ -313,9 +311,8 @@ pub mod visited {
         }
     }
 
-    // `ObjectPool<T, ..>` requires `T: ObjectPoolType`. Mirrors Zig's
-    // `ObjectPool(Map, Map.init, true, 16)` — `INIT` allocates an empty map,
-    // `reset` is `clearRetainingCapacity` (handled by callers via `.clear()`).
+    // `ObjectPool<T, ..>` requires `T: ObjectPoolType` — `INIT` allocates an empty map,
+    // `reset` clears retaining capacity (handled by callers via `.clear()`).
     impl bun_collections::pool::ObjectPoolType for Map {
         const INIT: Option<fn() -> Result<Self, bun_core::Error>> =
             Some(|| Ok(Map::default()));
@@ -325,7 +322,7 @@ pub mod visited {
         }
     }
 
-    // Mirrors Zig's `ObjectPool(Map, Map.init, true, 16)` — thread-local free
+    // Thread-local free
     // list, capped at 16 nodes. `object_pool!` wires the per-monomorphization
     // storage; without it `ObjectPool<Map, true, 16>` defaults to
     // `UnwiredStorage` which panics on first `get_node()`.
@@ -380,8 +377,6 @@ impl<'a> Formatter<'a> {
     }
 }
 
-// Mirrors the top-level Zig defer in `JestPrettyFormat.format` (.zig:79-85):
-// `defer { if (fmt.map_node) |node| { node.data = fmt.map; node.data.clearRetainingCapacity(); node.release(); } }`
 // The node is acquired lazily inside `print_as` via `visited::Pool::get_node()`;
 // releasing here covers every exit path of `format` (early `len == 1` return,
 // `?` propagation from `Tag::get`/`fmt.format`, and the happy path) without
@@ -403,11 +398,9 @@ impl Drop for Formatter<'_> {
     }
 }
 
-/// `Display` adapter equivalent to Zig's `JestPrettyFormat.Formatter.ZigFormatter`.
+/// `Display` adapter for formatting a single [`JSValue`].
 ///
-/// The Zig spec (`pretty_format.zig:243-263`) takes `self: ZigFormatter` *by
-/// value* with a raw `*Formatter` field, so writing through `self.formatter.*`
-/// carries no aliasing constraint. `Display::fmt` only gives us `&self`, so the
+/// `Display::fmt` only gives us `&self`, so the
 /// mutable handle is parked behind a `Cell` and moved out for the duration of
 /// the call — this preserves unique-borrow provenance without the
 /// `&shared → *const → *mut` cast that would be UB under Stacked Borrows.
@@ -433,14 +426,13 @@ impl core::fmt::Display for ZigFormatter<'_, '_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         // Move the unique `&mut Formatter` out of the cell for the body;
         // re-seat it (and clear `remaining_values`) on the way out so the
-        // adapter mirrors Zig's `defer` and stays reusable.
+        // adapter stays reusable.
         let formatter: &mut Formatter<'_> = self
             .formatter
             .take()
             .expect("ZigFormatter::fmt re-entered or used after consumption");
 
-        // PORT NOTE (.zig:249): `self.formatter.remaining_values = &[_]JSValue{self.value}` —
-        // assigning a stack-local slice into `Formatter<'b>` would require `'b: 'local`,
+        // Assigning a stack-local slice into `Formatter<'b>` would require `'b: 'local`,
         // which borrowck rejects. The single-value path never reads `remaining_values`
         // (only `StringPossiblyFormatted` consumes it, and `ZigFormatter` always emits a
         // single tag), so leaving it `&[]` is observationally equivalent.
@@ -455,7 +447,6 @@ impl core::fmt::Display for ZigFormatter<'_, '_> {
                 .map_err(|_| core::fmt::Error)
         })();
 
-        // Mirrors Zig `defer self.formatter.remaining_values = &.{}`.
         formatter.remaining_values = &[];
         self.formatter.set(Some(formatter));
         result
@@ -689,8 +680,9 @@ impl<'a> Formatter<'a> {
         slice_: S,
         global_this: &'a JSGlobalObject,
     ) where
+        // The sole caller here passes a
+        // UTF-8 byte slice (`to_slice`), so only the byte path is needed.
         S: AsRef<[u8]>,
-        // TODO(port): Zig `Slice` is generic over u8/u16; this draft handles bytes only.
     {
         let mut writer = WrappedWriter::new(writer_);
         let mut slice = slice_.as_ref();
@@ -874,7 +866,7 @@ impl<'a> Formatter<'a> {
     }
 }
 
-// PORT NOTE: split lifetimes — `&'a mut Formatter<'a>` is invariant and forces
+// split lifetimes — `&'a mut Formatter<'a>` is invariant and forces
 // the borrow of `self` at the call site to outlive `'a`, cascading into bogus
 // borrowck errors throughout `print_as`. Using a distinct `'f` for the
 // Formatter's own lifetime keeps the iter borrow local.
@@ -1051,7 +1043,7 @@ impl<'a, 'f, W: bun_io::Write, const ENABLE_ANSI_COLORS: bool>
         if tag.cell.is_hidden() {
             return;
         }
-        // PORT NOTE: reshaped for borrowck — `handle_first_property` needs `&mut *ctx`,
+        // reshaped for borrowck — `handle_first_property` needs `&mut *ctx`,
         // so the split borrows of `ctx.formatter`/`ctx.writer` are taken *after* it.
         if ctx.i == 0 {
             let parent = ctx.parent;
@@ -1065,7 +1057,7 @@ impl<'a, 'f, W: bun_io::Write, const ENABLE_ANSI_COLORS: bool>
         let this = &mut *ctx.formatter;
         let mut writer = WrappedWriter::new(&mut *ctx.writer);
 
-        // PORT NOTE: defer ctx.i += 1 — incremented at end of fn.
+        // ctx.i is incremented at end of fn.
         if ctx.i > 0 {
             if ctx.always_newline || this.always_newline_scope || this.good_time_for_a_new_line() {
                 writer.write_all(b"\n");
@@ -1169,7 +1161,7 @@ impl<'a> Formatter<'a> {
         if self.failed {
             return Ok(());
         }
-        // PORT NOTE: reshaped for borrowck — `WrappedWriter` borrows both writer_
+        // reshaped for borrowck — `WrappedWriter` borrows both writer_
         // and &mut self.estimated_line_length; we use a local wrapper and sync
         // `failed` at scope exit. estimated_line_length is unused by WrappedWriter
         // methods in this file, so we leave it None here.
@@ -1177,16 +1169,15 @@ impl<'a> Formatter<'a> {
 
         if FORMAT.can_have_circular_references() {
             if self.map_node.is_none() {
-                // PORT NOTE: `visited::Pool::get()` returns an RAII `PoolGuard` that
-                // would release on scope exit; the Zig spec stashes the raw node on
-                // `self` and releases it from `JestPrettyFormat::format`'s defer, so
+                // `visited::Pool::get()` returns an RAII `PoolGuard` that
+                // would release on scope exit; instead the raw node is stashed on
+                // `self` and released from `JestPrettyFormat::format`'s tail, so
                 // take the raw node directly. `data` is initialized by
                 // `Map::INIT` (see `visited::Map: ObjectPoolType`).
                 let node = core::ptr::NonNull::new(visited::Pool::get_node())
                     .expect("ObjectPool::get_node never returns null");
                 self.map_node = Some(node);
-                // PORT NOTE: Zig (.zig:878-880) does a struct copy aliasing the same
-                // backing buffer. Rust takes the map here and swaps it back into
+                // Take the map here and swap it back into
                 // `node.data` at release time (see JestPrettyFormat::format tail),
                 // so the pooled allocation is retained across uses.
                 // SAFETY: see above.
@@ -1205,15 +1196,14 @@ impl<'a> Formatter<'a> {
                 if writer.failed {
                     self.failed = true;
                 }
-                // Mirrors .zig:884-887 — return BEFORE the remove() defer is registered,
+                // Return BEFORE the remove() cleanup below is reached,
                 // so the parent frame's entry stays in the map.
                 return Ok(());
             }
         }
 
-        // PORT NOTE: Zig `defer { if (Format.canHaveCircularReferences()) _ = this.map.remove(value); }`
-        // (.zig:890-894) is realized by wrapping the match in a closure and unconditionally
-        // calling `self.map.remove(&value)` after it returns (Ok or Err). A scopeguard
+        // Wrap the match in a closure and unconditionally
+        // call `self.map.remove(&value)` after it returns (Ok or Err). A scopeguard
         // cannot be used here because it would hold `&mut self` across the match body.
         let result: JsResult<()> = (|| {
             match FORMAT {
@@ -1278,9 +1268,8 @@ impl<'a> Formatter<'a> {
 
                         writer.write_all(b"\"");
                         let mut remaining = str;
-                        // `ZigString::char_at` returns u16; Zig's `'\\'`/`'\r'` are
-                        // comptime_int so they coerce. Mirror with explicit u16
-                        // consts so the match arms type-check (.zig:955-969).
+                        // `ZigString::char_at` returns u16; use explicit u16
+                        // consts so the match arms type-check.
                         const BACKSLASH: u16 = b'\\' as u16;
                         const CR: u16 = b'\r' as u16;
                         const LF: u16 = b'\n' as u16;
@@ -1320,9 +1309,8 @@ impl<'a> Formatter<'a> {
                         if has_newline {
                             writer.write_all(b"\n");
                         }
-                        // PORT NOTE: Zig registers the `<r>` reset as a `defer` (.zig:942-943)
-                        // before the body, so it fires AFTER the trailing `\n` at .zig:975.
-                        // Emit it last here to keep byte-for-byte parity with colored output.
+                        // The `<r>` reset must come AFTER the trailing `\n`
+                        // to keep byte-for-byte parity with colored output.
                         if ENABLE_ANSI_COLORS {
                             writer.write_all(pretty_fmt_const::<true>("<r>").as_bytes());
                         }
@@ -1415,7 +1403,7 @@ impl<'a> Formatter<'a> {
                             pretty_fmt_const::<ENABLE_ANSI_COLORS>("<r>"),
                         ));
                     } else {
-                        // Zig `"{d}"` preserves the sign bit on -0; WTF::dtoa does not.
+                        // WTF::dtoa drops the sign bit on -0; preserve it.
                         let mut dtoa_buf = [0u8; 124];
                         let dtoa =
                             bun_fmt::FormatDouble::dtoa_with_negative_zero(&mut dtoa_buf, num);
@@ -1543,10 +1531,9 @@ impl<'a> Formatter<'a> {
                         let prev_quote_strings = self.quote_strings;
                         self.quote_strings = true;
 
-                        // PORT NOTE: Zig registers `defer this.indent -|= 1` (.zig:1120) and
-                        // `defer this.quote_strings = prev_quote_strings` (.zig:1128) so state is
-                        // restored even when `Tag.get` / `format` throw. Wrap the fallible body in
-                        // a closure and restore unconditionally afterward to match.
+                        // `indent` and `quote_strings` must be
+                        // restored even when `Tag::get` / `format` throw. Wrap the fallible body in
+                        // a closure and restore unconditionally afterward.
                         let inner: JsResult<()> = (|| {
                             {
                                 // SAFETY: `r#ref` is a live JSObjectRef for `value`; index 0 is
@@ -1647,7 +1634,7 @@ impl<'a> Formatter<'a> {
                     self.add_for_new_line(1);
                 }
                 Tag::Private => {
-                    // .zig:1190-1278 — per-type `writeFormat` dispatch for Bun-native cells.
+                    // Per-type `write_format` dispatch for Bun-native cells.
                     // Downcast via the `JsClass`/FFI hooks on each type; the `write_format`
                     // bodies re-enter this formatter through the `ConsoleFormatter` impl
                     // below for nested values, so the byte sink is wrapped in `AsFmt` (a
@@ -1891,7 +1878,7 @@ impl<'a> Formatter<'a> {
                     writer.print(format_args!("\n{} {{\n", map_name));
                     {
                         self.indent += 1;
-                        // PORT NOTE: hoist global_this (Copy &ref) before iter mutably
+                        // hoist global_this (Copy &ref) before iter mutably
                         // borrows `self`/`writer.ctx`; NLL releases both once `iter`
                         // is dead after `for_each` returns.
                         let global = self.global_this;
@@ -1904,8 +1891,8 @@ impl<'a> Formatter<'a> {
                             (&raw mut iter).cast::<c_void>(),
                             MapIterator::<W, ENABLE_ANSI_COLORS>::for_each,
                         );
-                        // PORT NOTE: Zig `defer this.indent -|= 1` / `defer this.quote_strings = prev`
-                        // run on every exit, including thrown exceptions — restore before propagating.
+                        // `indent` / `quote_strings` must be restored on every exit,
+                        // including thrown exceptions — restore before propagating.
                         self.indent = self.indent.saturating_sub(1);
                         self.quote_strings = prev_quote_strings;
                         result?;
@@ -1947,8 +1934,8 @@ impl<'a> Formatter<'a> {
                             (&raw mut iter).cast::<c_void>(),
                             SetIterator::<W, ENABLE_ANSI_COLORS>::for_each,
                         );
-                        // PORT NOTE: Zig `defer this.indent -|= 1` / `defer this.quote_strings = prev`
-                        // run on every exit, including thrown exceptions — restore before propagating.
+                        // `indent` / `quote_strings` must be restored on every exit,
+                        // including thrown exceptions — restore before propagating.
                         self.indent = self.indent.saturating_sub(1);
                         self.quote_strings = prev_quote_strings;
                         result?;
@@ -2027,9 +2014,8 @@ impl<'a> Formatter<'a> {
                         self.indent += 1;
                         let old_quote_strings = self.quote_strings;
                         self.quote_strings = true;
-                        // PORT NOTE: Zig registers `defer this.indent -|= 1` and
-                        // `defer this.quote_strings = old_quote_strings` here so state
-                        // is restored even when `fastGet` / `Tag.get` / `format` throw.
+                        // `indent` and `quote_strings` must be
+                        // restored even when `fast_get` / `Tag::get` / `format` throw.
                         // Wrap the fallible body and restore unconditionally afterward.
                         let inner: JsResult<()> = (|| {
                         self.write_indent(writer.ctx).expect("unreachable");
@@ -2126,9 +2112,6 @@ impl<'a> Formatter<'a> {
                     let tag_name_slice: ZigStringSlice;
                     let mut is_tag_kind_primitive = false;
 
-                    // PORT NOTE: defer if (tag_name_slice.isAllocated()) tag_name_slice.deinit()
-                    // — ZigString::Slice has Drop in Rust.
-
                     if let Some(type_value) = value.get(self.global_this, "type")? {
                         let _tag = Tag::get(type_value, self.global_this)?;
 
@@ -2198,8 +2181,7 @@ impl<'a> Formatter<'a> {
                         let prev_quote_strings = self.quote_strings;
                         self.quote_strings = true;
 
-                        // PORT NOTE: Zig registers `defer this.quote_strings = prev_quote_strings`
-                        // (and nested `defer this.indent -|= 1` scopes) so state is restored on
+                        // `quote_strings` (and nested `indent` scopes) must be restored on
                         // every exit, including thrown exceptions. Wrap the fallible body in a
                         // closure (Ok(true) ⇒ children path printed the closing tag, so the
                         // trailing " />" is skipped) and restore unconditionally afterward.
@@ -2222,9 +2204,8 @@ impl<'a> Formatter<'a> {
                                     props_iter.len - usize::from(children_prop.is_some());
 
                                 let loop_result: JsResult<()> = (|| {
-                                // PORT NOTE: `JSPropertyIterator::i` is private upstream;
-                                // track the 1-based iteration index locally (matches the
-                                // post-`next()` value of the Zig spec's `props_iter.i`).
+                                // `JSPropertyIterator::i` is private upstream;
+                                // track the 1-based iteration index locally.
                                 let mut iter_i: usize = 0;
                                 while let Some(prop) = props_iter.next()? {
                                     iter_i += 1;
@@ -2489,9 +2470,8 @@ impl<'a> Formatter<'a> {
 
                     let iter_i = iter.i;
                     let iter_always_newline = iter.always_newline;
-                    // PORT NOTE: Zig `defer this.always_newline_scope = prev` /
-                    // `defer this.quote_strings = prev` run on every exit — restore
-                    // before propagating any exception from the property iterator.
+                    // `always_newline_scope` / `quote_strings` must be restored on every
+                    // exit — restore before propagating any exception from the property iterator.
                     self.always_newline_scope = prev_always_newline_scope;
                     self.quote_strings = prev_quote_strings;
                     result?;
@@ -2656,13 +2636,12 @@ impl<'a> Formatter<'a> {
         global_this: &'a JSGlobalObject,
     ) -> JsResult<()> {
         let prev_global_this = self.global_this;
-        // PORT NOTE: defer this.globalThis = prevGlobalThis — restored at end.
+        // `self.global_this` is restored to the previous value at the end.
         self.global_this = global_this;
 
-        // This looks incredibly redundant. We make the JestPrettyFormat.Formatter.Tag a
-        // comptime var so we have to repeat it here. The rationale there is
-        // it _should_ limit the stack usage because each version of the
-        // function will be relatively small
+        // This looks incredibly redundant. Each tag variant dispatches to its
+        // own small formatting function; that _should_ limit the stack usage
+        // because each version of the function will be relatively small.
         let r = match result.tag {
             Tag::StringPossiblyFormatted => self
                 .print_as::<W, { Tag::StringPossiblyFormatted }, ENABLE_ANSI_COLORS>(
@@ -2827,10 +2806,8 @@ impl bun_jsc::ConsoleFormatter for Formatter<'_> {
 }
 
 /// Duck-type surface that [`JestPrettyFormat::print_asymmetric_matcher`] needs
-/// from a formatter. Spec `pretty_format.zig:2005` takes the formatter via
-/// `anytype`, so it monomorphises over both `JestPrettyFormat.Formatter` and
-/// `ConsoleObject.Formatter`. This trait is the Rust spelling of that
-/// duck-typing — implemented for both [`Formatter`] (this module) and
+/// from a formatter. This trait is
+/// implemented for both [`Formatter`] (this module) and
 /// [`bun_jsc::console_object::Formatter`] so the same body serves the test
 /// runner *and* `console.log`'s `.Private` arm (via the
 /// `RuntimeHooks::console_print_runtime_object` hook).
@@ -2930,8 +2907,8 @@ impl JestPrettyFormat {
         M: AsymmetricMatcherFormatter,
         W: bun_io::Write,
     {
-        // PORT NOTE: Zig (.zig:2005-2013) passes both `*WrappedWriter` and the raw inner
-        // writer, which alias. In Rust that would be two live `&mut W` to the same target
+        // Passing both the `WrappedWriter` and the raw inner writer
+        // would be two live `&mut W` to the same target
         // (UB / borrowck violation), so we accept only the wrapped writer and reach the
         // raw `&mut W` via `writer.ctx` for `print_as` calls — single borrow chain.
 
@@ -3100,5 +3077,3 @@ impl JestPrettyFormat {
         Ok(true)
     }
 }
-
-// ported from: src/test_runner/pretty_format.zig
diff --git a/src/runtime/test_runner/snapshot.rs b/src/runtime/test_runner/snapshot.rs
index b1bbfbc7534..d125baed524 100644
--- a/src/runtime/test_runner/snapshot.rs
+++ b/src/runtime/test_runner/snapshot.rs
@@ -29,13 +29,15 @@ pub struct Snapshots<'a> {
     pub failed: usize,
 
     pub file_buf: &'a mut Vec<u8>,
-    // PORT NOTE: LIFETIMES.tsv said `HashMap<usize, String>`; overridden per §Strings (data is bytes) → Box<[u8]>.
-    // Key is u64 to match `bun.hash` (Zig uses IdentityContext(usize) but hash returns u64; avoids narrowing cast).
+    // LIFETIMES.tsv said `HashMap<usize, String>`; overridden per §Strings (data is bytes) → Box<[u8]>.
+    // Key is u64 to match `bun.hash`'s return type (avoids a narrowing cast).
     pub values: &'a mut HashMap<u64, Box<[u8]>>,
-    // PORT NOTE: LIFETIMES.tsv said `HashMap<String, usize>`; Zig is `bun.StringHashMap(usize)` → byte-keyed wyhash map.
     pub counts: &'a mut StringHashMap<usize>,
     pub _current_file: Option<File>,
-    // TODO(port): lifetime — borrows Jest.runner.files[..].source.path; BACKREF (not owned, never freed).
+    /// Read-only backref into `Jest::RUNNER.files[..].source.path` (not owned
+    /// here, never freed): the runner is process-global and its files are
+    /// never freed mid-run, so the pointee outlives `self`. Only dereferenced
+    /// via `as_ref()` in `get_snapshot_file` (see the SAFETY comments there).
     pub snapshot_dir_path: Option<core::ptr::NonNull<[u8]>>,
     pub inline_snapshots_to_write: &'a mut IndexMap<FileId, Vec<InlineSnapshotToWrite>>,
     pub last_error_snapshot_name: Option<Box<[u8]>>,
@@ -53,7 +55,7 @@ impl<'a> Snapshots<'a> {
     const SNAPSHOTS_DIR_NAME: &'static [u8] = b"__snapshots__/";
 }
 
-// PORT NOTE: hoisted out of `impl Snapshots` — inherent associated types are unstable.
+// hoisted out of `impl Snapshots` — inherent associated types are unstable.
 pub type ValuesHashMap = HashMap<u64, Box<[u8]>>;
 
 pub struct InlineSnapshotToWrite {
@@ -101,10 +103,8 @@ impl<'a> Snapshots<'a> {
     }
 
     pub fn add_count(&mut self, expect: &Expect, hint: &[u8]) -> Result<(Vec<u8>, usize), Error> {
-        // TODO(port): narrow error set
         self.total += 1;
         let snapshot_name = expect.get_snapshot_name(hint)?;
-        // PORT NOTE: reshaped for borrowck — Zig's getOrPut returns key_ptr/value_ptr together.
         // bun_collections::StringHashMap::get_or_put can't hand out `key_ptr`, so return the
         // owned `snapshot_name` (same bytes as the interned key) instead.
         let gop = self
@@ -126,7 +126,6 @@ impl<'a> Snapshots<'a> {
         target_value: &[u8],
         hint: &[u8],
     ) -> Result<Option<&[u8]>, Error> {
-        // TODO(port): narrow error set
         let buntest_strong = expect
             .bun_test()
             .ok_or_else(|| bun_core::err!("SnapshotFailed"))?;
@@ -134,7 +133,7 @@ impl<'a> Snapshots<'a> {
         match self.get_snapshot_file(bun_test.file_id)? {
             bun_sys::Result::Ok(()) => {}
             bun_sys::Result::Err(err) => {
-                // PORT NOTE: `bun_sys::Tag` is a newtype-struct with assoc consts (lowercase),
+                // `bun_sys::Tag` is a newtype-struct with assoc consts (lowercase),
                 // not an enum — match arms require structural-eq; use if-chain instead.
                 return Err(if err.syscall == bun_sys::Tag::mkdir {
                     bun_core::err!("FailedToMakeSnapshotDirectory")
@@ -158,7 +157,7 @@ impl<'a> Snapshots<'a> {
         name_with_counter.extend_from_slice(counter_string);
 
         let name_hash: u64 = hash(&name_with_counter);
-        // PORT NOTE: reshaped for borrowck — `get` then early-return borrows `*self.values`
+        // reshaped for borrowck — `get` then early-return borrows `*self.values`
         // immutably for the whole fn body (NLL limitation with returned borrows), preventing
         // the later `insert`. Probe with `contains_key` first; re-lookup on hit.
         if self.values.contains_key(&name_hash) {
@@ -208,7 +207,6 @@ impl<'a> Snapshots<'a> {
     }
 
     pub fn parse_file(&mut self, file: &File) -> Result<(), Error> {
-        // TODO(port): narrow error set
         if self.file_buf.is_empty() {
             return Ok(());
         }
@@ -220,12 +218,11 @@ impl<'a> Snapshots<'a> {
             vm.transpiler.options.jsx.clone(),
             bun_ast::Loader::Js,
         );
-        // PERF(port): Zig used `this.allocator` (default_allocator). Thread a per-call arena
-        // since js_parser is bump-allocated in the Rust port.
+        // Thread a per-call arena — js_parser is bump-allocated.
         let arena = bun_alloc::Arena::new();
         let mut temp_log = bun_ast::Log::init();
 
-        // PORT NOTE: do NOT call `Jest::runner()` here — it hands out an exclusive ref to the global TestRunner,
+        // do NOT call `Jest::runner()` here — it hands out an exclusive ref to the global TestRunner,
         // and `self: &mut Snapshots` is a live borrow of that same TestRunner's `.snapshots`
         // field. Retagging the whole TestRunner would invalidate `self` under Stacked Borrows.
         // Project the disjoint `.files` sibling through the raw `RUNNER` pointer instead.
@@ -288,7 +285,7 @@ impl<'a> Snapshots<'a> {
                 match &mut stmt.data {
                     bun_ast::StmtData::SExpr(expr) => {
                         if let bun_ast::ExprData::EBinary(e_binary) = &mut expr.value.data {
-                            // PORT NOTE: deref `StoreRef` once to a plain `&mut E::Binary`
+                            // deref `StoreRef` once to a plain `&mut E::Binary`
                             // so the borrow checker can see `.left`/`.right` as disjoint
                             // field projections (custom `DerefMut` blocks split-borrows
                             // otherwise).
@@ -296,7 +293,7 @@ impl<'a> Snapshots<'a> {
                             if e_binary.op == bun_ast::Op::Code::BinAssign {
                                 let (left, right) = (&mut e_binary.left, &mut e_binary.right);
                                 if let bun_ast::ExprData::EIndex(e_index) = &mut left.data {
-                                    // PORT NOTE: split-borrow `index`/`target` so we can take
+                                    // split-borrow `index`/`target` so we can take
                                     // `&mut` on `index` (EString::slice needs &mut) while reading
                                     // `target` immutably.
                                     let target_is_exports = matches!(
@@ -328,13 +325,11 @@ impl<'a> Snapshots<'a> {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig's chained `.data == .x and .data.x.y == ...` becomes nested if-let.
         let _ = &mut ast;
         Ok(())
     }
 
     pub fn write_snapshot_file(&mut self) -> Result<(), Error> {
-        // TODO(port): narrow error set
         if let Some(file) = self._current_file.take() {
             file.file
                 .write_all(self.file_buf)
@@ -344,7 +339,6 @@ impl<'a> Snapshots<'a> {
             self.file_buf.shrink_to_fit();
 
             self.values.clear();
-            // PERF(port): Zig clearAndFree() also releases capacity; HashMap::clear keeps it.
 
             self.counts.clear();
         }
@@ -356,7 +350,6 @@ impl<'a> Snapshots<'a> {
         file_id: FileId,
         value: InlineSnapshotToWrite,
     ) -> Result<(), Error> {
-        // TODO(port): narrow error set
         let list = self
             .inline_snapshots_to_write
             .entry(file_id)
@@ -366,20 +359,16 @@ impl<'a> Snapshots<'a> {
     }
 
     pub fn write_inline_snapshots(&mut self) -> Result<bool, Error> {
-        // TODO(port): narrow error set
-        // PERF(port): was arena bulk-free per iteration — profile if it shows up on a hot path.
-        // TODO(port): js_parser/lexer APIs likely still require `&Bump`; arena threading not done here.
-
-        // PORT NOTE: `success` is a Cell so the per-iteration `defer if (log.errors > 0)` guard
+        // `success` is a Cell so the per-iteration error-check guard
         // closure can flip it without holding a &mut across the loop body.
         let success = core::cell::Cell::new(true);
         // SAFETY: see `parse_file` — thread-local VM singleton, short-lived reborrow.
         let vm = VirtualMachine::get().as_mut();
 
-        // PERF(port): was arena bulk-free per iteration — reset() inside the loop.
+        // The arena is reset() inside the loop, bulk-freeing per-iteration scratch.
         let mut arena = bun_alloc::Arena::new();
 
-        // PORT NOTE: reshaped for borrowck — iterate by index to allow &mut access to values while reading keys.
+        // reshaped for borrowck — iterate by index to allow &mut access to values while reading keys.
         let file_ids: Vec<FileId> = self.inline_snapshots_to_write.keys().to_vec();
         for file_id in file_ids {
             arena.reset();
@@ -388,8 +377,8 @@ impl<'a> Snapshots<'a> {
                 .get_mut(&file_id)
                 .expect("unreachable");
 
-            // Zig: `defer if (log.errors > 0) { log.print(...); success = false; }`
-            // Runs on every exit of the loop body (continue, fall-through, AND `?` early-return).
+            // The guard runs on every exit of the loop body (continue,
+            // fall-through, AND `?` early-return).
             let mut log = scopeguard::guard(bun_ast::Log::init(), |log| {
                 if log.errors > 0 {
                     let _ = log.print(std::ptr::from_mut::<bun_core::io::Writer>(
@@ -411,7 +400,7 @@ impl<'a> Snapshots<'a> {
             });
 
             // 2. load file text
-            // PORT NOTE: avoid `Jest::runner()` (would alias `&mut TestRunner` over the live
+            // avoid `Jest::runner()` (would alias `&mut TestRunner` over the live
             // `&mut self` / `ils_info` borrow of `runner.snapshots`). See comment in `parse_file`.
             // SAFETY: see `parse_file` — raw-pointer projection to disjoint `.files` field.
             let test_file_source = unsafe {
@@ -542,8 +531,8 @@ impl<'a> Snapshots<'a> {
                     }
                     next_start += fn_name.len();
 
-                    // PORT NOTE: Zig passed `&log` to both `Lexer.initWithoutReading` and
-                    // `TSXParser.init` (aliasing `*Log`). Rust forbids two live `&'a mut Log`;
+                    // `Lexer.initWithoutReading` and `TSXParser.init` both need the same
+                    // `Log`, but Rust forbids two live `&'a mut Log`;
                     // derive a raw pointer so borrowck doesn't track the lexer/parser borrow,
                     // matching the pattern in `js_parser::Parser::init`. The unique `&mut`
                     // logically lives inside `parser.lexer`; `log.add_error_fmt` calls below
@@ -566,14 +555,12 @@ impl<'a> Snapshots<'a> {
                         lexer.step();
                     }
                     lexer.next()?;
-                    // PORT NOTE: `ParserOptions` isn't `Clone`; rebuild per-iteration
-                    // (Zig passed by value-copy).
+                    // `ParserOptions` isn't `Clone`; rebuild per-iteration.
                     let opts = js_parser::ParserOptions::init(
                         vm.transpiler.options.jsx.clone(),
                         bun_ast::Loader::Js,
                     );
-                    // PORT NOTE: `P::init` takes an out-param (Zig:
-                    // `var p: ParserType = undefined; try ParserType.init(.., &p)`)
+                    // `P::init` takes an out-param
                     // since 9a98701c980c — `P` is ~5 KiB and the previous
                     // `let p = P::init(..)?` shape forced 2-3 by-value moves.
                     // Mirror `init_p!` from `js_parser/parse/parse_entry.rs` here
@@ -797,8 +784,7 @@ impl<'a> Snapshots<'a> {
                 result_text.extend_from_slice(b"`");
 
                 if ils.is_added {
-                    // PORT NOTE: Zig spec does `Jest.runner.?.snapshots.added += 1` (snapshot.zig:461),
-                    // but `runner.snapshots` *is* `*self`. Going back through `Jest::runner()` would
+                    // `runner.snapshots` *is* `*self`: going back through `Jest::runner()` would
                     // create a second `&mut Snapshots` aliasing `self` (UB) and invalidate `ils_info`.
                     self.added += 1;
                 }
@@ -846,11 +832,10 @@ impl<'a> Snapshots<'a> {
     }
 
     fn get_snapshot_file(&mut self, file_id: FileId) -> Result<bun_sys::Result<()>, Error> {
-        // TODO(port): narrow error set
         if self._current_file.is_none() || self._current_file.as_ref().unwrap().id != file_id {
             self.write_snapshot_file()?;
 
-            // PORT NOTE: avoid `Jest::runner()` (aliases `&mut TestRunner` over live `&mut self`).
+            // avoid `Jest::runner()` (aliases `&mut TestRunner` over live `&mut self`).
             // SAFETY: see `parse_file` — raw-pointer projection to disjoint `.files` field.
             let test_file_source = unsafe {
                 let p = Jest::RUNNER.read().expect("Jest runner not set").as_ptr();
@@ -940,5 +925,3 @@ impl<'a> Snapshots<'a> {
         Ok(bun_sys::Result::Ok(()))
     }
 }
-
-// ported from: src/test_runner/snapshot.zig
diff --git a/src/runtime/test_runner/timers/FakeTimers.rs b/src/runtime/test_runner/timers/FakeTimers.rs
index ff76d52f82c..a7ffb525edf 100644
--- a/src/runtime/test_runner/timers/FakeTimers.rs
+++ b/src/runtime/test_runner/timers/FakeTimers.rs
@@ -10,7 +10,7 @@ use crate::timer::{
     TimerObjectInternals, TimeoutObject, TimerHeap,
 };
 
-// TODO(port): move to test_runner_sys / jsc_sys
+// JSMock C++ bindings (fake timers are only used by bun:test, so these stay local).
 unsafe extern "C" {
     safe fn JSMock__setOverridenDateNow(global: &JSGlobalObject, value: f64);
     safe fn JSMock__getCurrentUnixTimeMs() -> f64;
@@ -26,9 +26,8 @@ pub struct FakeTimers {
     pub timers: TimerHeap,
 }
 
-// PORT NOTE: Zig `pub var current_time: struct { ... } = .{}` — anonymous-typed mutable global.
-// Reshaped: `offset_lock` + `offset_raw` folded into `RwLock<Timespec>`; `date_now_offset`
-// stored as `AtomicU64` (f64 bits) so the static is `Sync` without `static mut`.
+// `date_now_offset` is stored as `AtomicU64` (f64 bits) so the static is `Sync`
+// without `static mut`.
 pub struct CurrentTime {
     /// starts at 0. offset in milliseconds.
     offset_raw: RwLock<Timespec>,
@@ -51,15 +50,13 @@ impl CurrentTime {
         Some(value)
     }
 
-    // PORT NOTE: Zig took `v: struct { offset: *const timespec, js: ?f64 = null }` —
-    // anonymous param struct inlined as separate args. LIFETIMES.tsv: offset = BORROW_PARAM → &Timespec.
     pub fn set(&self, global: &JSGlobalObject, offset: &Timespec, js: Option<f64>) {
         let vm = global.bun_vm().as_mut();
         {
             *self.offset_raw.write() = *offset;
         }
-        // Mirror into T0 storage so `Timespec::now(.allow_mocked_time)` sees
-        // the fake clock (spec bun.zig:3223 — `getRoughTickCount`).
+        // Mirror into T0 storage so `Timespec::now(AllowMockedTime)` sees
+        // the fake clock.
         bun_core::mock_time::set(offset.ns() as i64);
         let timespec_ms: f64 = offset.ms() as f64;
         let mut date_now_offset = f64::from_bits(self.date_now_offset.load(Ordering::Relaxed));
@@ -70,9 +67,6 @@ impl CurrentTime {
         // SAFETY: FFI call into C++ JSMock; global is a valid &JSGlobalObject
         JSMock__setOverridenDateNow(global, date_now_offset + timespec_ms);
 
-        // PORT NOTE: Zig stored `@bitCast(v.offset.ns())` (i128 → u128). The Rust
-        // `VirtualMachine.overridden_performance_now` is `Option<u64>` and
-        // `Timespec::ns()` already returns `u64`, so no bitcast needed.
         vm.overridden_performance_now = Some(offset.ns());
     }
 
@@ -123,7 +117,7 @@ impl FakeTimers {
 
     pub fn is_active(&self) -> bool {
         self.assert_locked();
-        // defer assertValid(.locked) — re-checked at fn exit
+        // validity re-checked at fn exit
         let r = self.active;
         self.assert_locked();
         r
@@ -161,8 +155,7 @@ impl FakeTimers {
     /// Marking `state = CANCELLED` alone strands the `Box<TimeoutObject>`: its
     /// refcount sticks at 2 (wrapper +1 from `init_with`, heap +1 from
     /// `reschedule`) and `internals.this_value` still GC-roots the wrapper, so
-    /// neither side ever frees. The Zig spec (FakeTimers.zig:81-89) has the
-    /// same gap.
+    /// neither side ever frees.
     #[must_use]
     fn clear(&mut self) -> Vec<core::ptr::NonNull<TimerObjectInternals>> {
         self.assert_locked();
@@ -189,7 +182,7 @@ impl FakeTimers {
         pinned
     }
 
-    // PORT NOTE (noalias re-entrancy): `execute_*` / `fire` do NOT take
+    // noalias re-entrancy: `execute_*` / `fire` do NOT take
     // `&mut self`. `EventLoopTimer::fire` dispatches into JS; a `setInterval`
     // callback's reschedule (`timer::All::update` → `insert_lock_held` →
     // `(*timer_all()).fake_timers.timers.insert`) writes back into *this
@@ -525,12 +518,9 @@ const FAKE_TIMERS_FNS: &[(&str, u32, JSHostFn)] = &[
 pub(crate) const TIMER_FNS_COUNT: usize = FAKE_TIMERS_FNS.len();
 
 pub(crate) fn put_timers_fns(global: &JSGlobalObject, jest: JSValue, vi: JSValue) {
-    // PORT NOTE: Zig `inline for` over homogeneous tuples → plain `for` over const slice.
     for &(name, arity, func) in FAKE_TIMERS_FNS {
         let jsvalue = JSFunction::create(global, name, func, arity, Default::default());
         vi.put(global, name.as_bytes(), jsvalue);
         jest.put(global, name.as_bytes(), jsvalue);
     }
 }
-
-// ported from: src/test_runner/timers/FakeTimers.zig
diff --git a/src/runtime/timer/DateHeaderTimer.rs b/src/runtime/timer/DateHeaderTimer.rs
index a3d6a961c05..195fbf15489 100644
--- a/src/runtime/timer/DateHeaderTimer.rs
+++ b/src/runtime/timer/DateHeaderTimer.rs
@@ -30,5 +30,3 @@ pub(super) extern "C" fn Bun__internal_ensureDateHeaderTimerIsEnabled(loop_: *mu
         unsafe { (*timer_all()).update_date_header_timer_if_necessary(loop_ref, vm_ptr) };
     }
 }
-
-// ported from: src/runtime/timer/DateHeaderTimer.zig
diff --git a/src/runtime/timer/EventLoopDelayMonitor.rs b/src/runtime/timer/EventLoopDelayMonitor.rs
index de064600111..06173233d08 100644
--- a/src/runtime/timer/EventLoopDelayMonitor.rs
+++ b/src/runtime/timer/EventLoopDelayMonitor.rs
@@ -10,7 +10,7 @@ pub(super) extern "C" fn Timer_enableEventLoopDelayMonitoring(
 ) {
     // SAFETY: vm is a valid non-null pointer passed from C++.
     let vm = unsafe { &mut *vm };
-    // PORT NOTE (jsc/runtime crate cycle): `vm.timer` is `()` — recover `All` via runtime_state().
+    // `vm.timer` is `()` (jsc/runtime crate cycle) — recover `All` via runtime_state().
     let state = crate::jsc_hooks::runtime_state();
     // SAFETY: `runtime_state()` is non-null after `bun_runtime::init()`; single
     // JS thread, raw-ptr-per-field re-entry pattern (jsc_hooks.rs).
@@ -30,5 +30,3 @@ pub(super) extern "C" fn Timer_disableEventLoopDelayMonitoring(vm: *mut VirtualM
     // SAFETY: see `Timer_enableEventLoopDelayMonitoring`.
     unsafe { (*state).timer.event_loop_delay.disable(vm) };
 }
-
-// ported from: src/runtime/timer/EventLoopDelayMonitor.zig
diff --git a/src/runtime/timer/ImmediateObject.rs b/src/runtime/timer/ImmediateObject.rs
index 5f332afdd5f..b2cb178b46c 100644
--- a/src/runtime/timer/ImmediateObject.rs
+++ b/src/runtime/timer/ImmediateObject.rs
@@ -20,7 +20,7 @@ impl ImmediateObject {
         Self::init_with(global, id, Kind::SetImmediate, 0, callback, arguments)
     }
 
-    /// Spec ImmediateObject.zig `runImmediateTask` — thin forwarder to
+    /// Thin forwarder to
     /// `internals.run_immediate_task`. Reached from `bun_jsc::event_loop`
     /// via `__bun_run_immediate_task` (definer in [`crate::dispatch`]).
     ///
@@ -52,5 +52,3 @@ impl ImmediateObject {
         }
     }
 }
-
-// ported from: src/runtime/timer/ImmediateObject.zig
diff --git a/src/runtime/timer/TimeoutObject.rs b/src/runtime/timer/TimeoutObject.rs
index 4315481fea1..cab9f633212 100644
--- a/src/runtime/timer/TimeoutObject.rs
+++ b/src/runtime/timer/TimeoutObject.rs
@@ -13,7 +13,7 @@ use super::Kind;
 pub mod js {
     // One `${snake}_get_cached` / `${snake}_set_cached` pair per cached prop,
     // each wrapping `TimeoutPrototype__${prop}{Get,Set}CachedValue` and mapping
-    // `.zero` → `None` on the get side (matches Zig `${name}GetCached`).
+    // `.zero` → `None` on the get side.
     bun_jsc::codegen_cached_accessors!(
         "Timeout";
         arguments,
@@ -35,7 +35,7 @@ impl TimeoutObject {
         global: &JSGlobalObject,
         id: i32,
         kind: Kind,
-        interval: u32, // Zig: u31
+        interval: u32,
         callback: JSValue,
         arguments: JSValue,
     ) -> JSValue {
@@ -113,5 +113,3 @@ impl TimeoutObject {
         js::idle_start_set_cached(this_value, global, value);
     }
 }
-
-// ported from: src/runtime/timer/TimeoutObject.zig
diff --git a/src/runtime/timer/Timer.rs b/src/runtime/timer/Timer.rs
index 51601c3f9fe..26c235420cc 100644
--- a/src/runtime/timer/Timer.rs
+++ b/src/runtime/timer/Timer.rs
@@ -1,7 +1,7 @@
 //! Timer subsystem JS-facing surface: setTimeout/setInterval/setImmediate/
 //! Bun.sleep/clear* host functions.
 //!
-//! PORT NOTE: this file is loaded as `pub mod timer;` from `mod.rs` (codegen
+//! this file is loaded as `pub mod timer;` from `mod.rs` (codegen
 //! path `crate::timer::timer::*`). The canonical struct definitions (`All`,
 //! `Kind`, `Maps`, `TimeoutObject`, `ImmediateObject`, `TimerObjectInternals`,
 //! `DateHeaderTimer`, …) live in `mod.rs`; this module only adds the JS-facing
@@ -52,7 +52,7 @@ impl All {
         vm: *mut VirtualMachine,
     ) {
         if loop_.should_enable_date_header_timer() {
-            // PORT NOTE: `is_date_timer_active()` is private to mod.rs; inline.
+            // `is_date_timer_active()` is private to mod.rs; inline.
             if self.date_header_timer.event_loop_timer.state != EventLoopTimerState::ACTIVE {
                 // SAFETY: caller contract guarantees `vm` is valid.
                 unsafe {
@@ -107,7 +107,6 @@ impl All {
                     )
                 }
             }
-            // std.fmt gives us "nan" but Node.js wants "NaN".
             TimeoutWarning::TimeoutNaNWarning => {
                 debug_assert!(countdown.is_nan());
                 BunString::ascii(const_format::concatcp!("NaN is not a number", SUFFIX).as_bytes())
@@ -154,16 +153,19 @@ impl All {
         overflow_behavior: CountdownOverflowBehavior,
         warn: bool,
     ) -> JsResult<u32> {
-        // TODO(port): Zig return type is `u31`; using u32 here, callers must respect the [0, i32::MAX] range.
+        // Both match arms below enforce the [0, i32::MAX] range (Clamp
+        // saturates to i32::MAX; OneMs yields either 1 or a value already
+        // validated to be <= i32::MAX), so callers always receive a value
+        // in that range.
         // We don't deal with nesting levels directly
         // but we do set the minimum timeout to be 1ms for repeating timers
         let countdown_double = countdown.to_number(global_this)?;
         let countdown_int: u32 = match overflow_behavior {
             CountdownOverflowBehavior::Clamp => {
-                // std.math.lossyCast(u31, countdown_double): saturating cast to [0, i32::MAX]
-                // Rust `as` saturates float→int; clamp upper to u31 max.
+                // Saturating cast to [0, i32::MAX]: Rust `as` saturates
+                // float→int and maps NaN→0,
+                // so `setTimeout(fn, NaN)` behaves like `setTimeout(fn, 0)`.
                 (countdown_double as u32).min(i32::MAX as u32)
-                // TODO(port): verify NaN→0 behavior matches std.math.lossyCast
             }
             CountdownOverflowBehavior::OneMs => {
                 if !(countdown_double >= 1.0 && countdown_double <= i32::MAX as f64) {
@@ -302,8 +304,6 @@ impl All {
     }
 
     fn remove_timer_by_id(&mut self, id: i32) -> Option<*mut TimeoutObject> {
-        // PORT NOTE: Zig `fetchSwapRemove` returns the entry; ArrayHashMap
-        // exposes `get_index` + `swap_remove_at`, so combine them.
         let value: *mut EventLoopTimer = if let Some(idx) = self.maps.set_timeout.get_index(&id) {
             self.maps.set_timeout.swap_remove_at(idx).1
         } else {
@@ -338,8 +338,8 @@ impl All {
                 // Primitive string only (JSType::String) — boxed `new String(..)`
                 // must fall through to `from_js` below and be a no-op, matching
                 // Node.js array-index semantics.
-                // RAII for Zig's `defer string.deref()` — `to_bun_string` returns
-                // a +1 ref and there are several early `return Ok(())` exits below.
+                // RAII deref on drop — `to_bun_string` returns a +1 ref
+                // and there are several early `return Ok(())` exits below.
                 let string = bun_core::OwnedString::new(timer_id_value.to_bun_string(global_this)?);
                 // Custom parseInt logic. I've done this because Node.js is very strict about string
                 // parameters to this function: they can't have leading whitespace, trailing
@@ -379,7 +379,7 @@ impl All {
                             }
                         }};
                     }
-                    // PORT NOTE: bun_core::String has no `encoding()` accessor;
+                    // bun_core::String has no `encoding()` accessor;
                     // dispatch on `is_utf16()` and treat the 8-bit case via
                     // `latin1()` (digit chars are in the ASCII range either way).
                     if string.is_utf16() {
@@ -444,13 +444,11 @@ impl All {
 
 // ════════════════════════════════════════════════════════════════════════════
 // Method bodies on canonical sibling types (`mod.rs` definitions).
-// Ported from DateHeaderTimer.zig.
 // ════════════════════════════════════════════════════════════════════════════
 
 // `TimeoutObject::{init, from_js}` and `ImmediateObject::{init, from_js}` now
-// live in `super::{timeout_object, immediate_object}` (canonical ports of
-// `TimeoutObject.zig` / `ImmediateObject.zig`); the inherent `init` constructor
-// and the `JsClass`-derived `from_js` are re-exported via
+// live in `super::{timeout_object, immediate_object}`; the inherent `init`
+// constructor and the `JsClass`-derived `from_js` are re-exported via
 // `super::{TimeoutObject, ImmediateObject}`.
 
 impl DateHeaderTimer {
@@ -467,7 +465,7 @@ impl DateHeaderTimer {
     pub(super) unsafe fn enable(&mut self, vm: *mut VirtualMachine, now: &Timespec) {
         debug_assert!(self.event_loop_timer.state != EventLoopTimerState::ACTIVE);
 
-        // PORT NOTE: `EventLoopTimer.next` is the lower-tier `ElTimespec` stub
+        // `EventLoopTimer.next` is the lower-tier `ElTimespec` stub
         // (same `{sec,nsec}` layout) until bun_event_loop switches to bun_core::Timespec.
         let last_update = Timespec {
             sec: self.event_loop_timer.next.sec,
@@ -512,10 +510,7 @@ pub fn drain_timers_export(vm: *mut VirtualMachine) {
     unsafe { (*all).drain_timers(vm.cast::<()>()) };
 }
 
-// Zig used `jsc.host_fn.wrapN(...)` + `@export` to generate these C-ABI shims.
-// `wrapN` reflects on the Zig fn signature and emits an `extern "C" fn` that
-// forwards through `toJSHostCall` (ExceptionValidationScope + JsResult→JSValue
-// normalization). Rust has no signature reflection; `generate-host-exports.ts`
+// `generate-host-exports.ts`
 // scrapes the `// HOST_EXPORT` markers below and emits the seven thunks into
 // `generated_host_exports.rs`, each routing through `host_fn::host_fn_result`.
 //
@@ -597,10 +592,8 @@ pub mod internal_bindings {
         let _ = global_this;
         let _ = call_frame;
         let now = Timespec::now(TimespecMockMode::AllowMockedTime).ms();
-        // PORT NOTE: bun_jsc::JSValue has no `js_number_from_int64`; route via
+        // bun_jsc::JSValue has no `js_number_from_int64`; route via
         // `js_number(f64)` (i64 → f64 is lossless for the millisecond range).
         Ok(JSValue::js_number(now as f64))
     }
 }
-
-// ported from: src/runtime/timer/Timer.zig
diff --git a/src/runtime/timer/WTFTimer.rs b/src/runtime/timer/WTFTimer.rs
index fed2d7e1d97..c0ee848c43c 100644
--- a/src/runtime/timer/WTFTimer.rs
+++ b/src/runtime/timer/WTFTimer.rs
@@ -1,11 +1,10 @@
 //! `WTFTimer` — a timer created by WTF (WebKit) code and invoked by Bun's
 //! event loop. Backs `WTF::RunLoop::TimerBase` on the Bun runloop.
 //!
-//! PORT NOTE (jsc/runtime crate cycle): Zig stores `vm: *VirtualMachine` and reaches the
-//! timer heap via `vm.timer.{remove,update}`. The low-tier
-//! `bun_jsc::VirtualMachine.timer` is a `()` placeholder, so this port
-//! resolves the heap through [`crate::jsc_hooks::runtime_state`] instead —
-//! the same pattern `TimerObjectInternals` uses.
+//! jsc/runtime crate cycle: the low-tier `bun_jsc::VirtualMachine.timer` is a
+//! `()` placeholder, so this module resolves the timer heap through
+//! [`crate::jsc_hooks::runtime_state`] instead — the same pattern
+//! `TimerObjectInternals` uses.
 
 use core::ffi::c_void;
 use core::ptr::{self, NonNull};
@@ -40,7 +39,10 @@ impl RunLoopTimer {
 
 /// A timer created by WTF code and invoked by Bun's event loop.
 pub struct WTFTimer {
-    // TODO(port): lifetime — backref to the owning VirtualMachine; never owned here.
+    // Backref to the owning VirtualMachine (captured from the thread-local VM
+    // in `WTFTimer__create`); never owned here. The C++ `RunLoop::TimerBase`
+    // that owns this wrapper lives on the VM's run loop, so the VM outlives
+    // the timer.
     vm: NonNull<VirtualMachine>,
     // FFI handle into WebKit's RunLoop::TimerBase; owned by C++.
     run_loop_timer: NonNull<RunLoopTimer>,
@@ -68,7 +70,7 @@ pub(crate) unsafe extern "C" fn WTFTimer__runIfImminent(vm: *mut VirtualMachine)
 }
 
 impl WTFTimer {
-    /// Spec WTFTimer.zig `run` — fire the underlying `RunLoop::TimerBase`,
+    /// Fire the underlying `RunLoop::TimerBase`,
     /// removing `self` from the timer heap first if it's currently scheduled.
     /// Reached from `bun_jsc::event_loop` via `__bun_run_wtf_timer`
     /// (definer in [`crate::dispatch`]).
@@ -107,8 +109,7 @@ impl WTFTimer {
         }
         // `imminent` is a `BackRef` into the VM's event loop, which outlives this timer.
         let loaded = self.imminent.load(Ordering::SeqCst);
-        // Zig: `(load orelse return false) == this` — null can never equal `this`,
-        // so a single pointer compare suffices.
+        // Null can never equal `this`, so a single pointer compare suffices.
         loaded.cast_const().cast::<WTFTimer>() == ptr::from_ref(self)
     }
 
@@ -117,7 +118,7 @@ impl WTFTimer {
         let _g = self.lock.lock_guard();
         if self.event_loop_timer.state == EventLoopTimerState::ACTIVE {
             let next = &self.event_loop_timer.next;
-            // PORT NOTE: bun_event_loop carries a local `Timespec` stub; re-pack
+            // bun_event_loop carries a local `Timespec` stub; re-pack
             // into bun_core::Timespec to call `duration`.
             let until = Timespec {
                 sec: next.sec,
@@ -228,8 +229,7 @@ impl WTFTimer {
         }
     }
 
-    /// Spec WTFTimer.zig `fire` — `EventLoopTimer.fire` dispatch arm body for
-    /// `Tag::WTFTimer`.
+    /// `EventLoopTimer.fire` dispatch arm body for `Tag::WTFTimer`.
     ///
     /// # Safety
     /// `this` is the container of an `EventLoopTimer` just popped from
@@ -299,7 +299,6 @@ pub(crate) unsafe extern "C" fn WTFTimer__create(run_loop_timer: *mut RunLoopTim
             },
             run_loop_timer: NonNull::new_unchecked(run_loop_timer),
             repeat: false,
-            // Zig: `@enumFromInt(vm.initial_script_execution_context_identifier)`
             script_execution_context_id: ScriptExecutionContextIdentifier(
                 vm_ref.initial_script_execution_context_identifier as u32,
             ),
@@ -335,9 +334,6 @@ pub(crate) unsafe extern "C" fn WTFTimer__cancel(this: *mut WTFTimer) {
     unsafe { WTFTimer::cancel(this) };
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     safe fn WTFTimer__fire(this: NonNull<RunLoopTimer>);
 }
-
-// ported from: src/runtime/timer/WTFTimer.zig
diff --git a/src/runtime/timer/mod.rs b/src/runtime/timer/mod.rs
index adc157bd754..3da015b92d2 100644
--- a/src/runtime/timer/mod.rs
+++ b/src/runtime/timer/mod.rs
@@ -23,10 +23,10 @@ use bun_threading::Mutex;
 pub use bun_event_loop::EventLoopTimer::{
     EventLoopTimer, InHeap, IntrusiveField, State as EventLoopTimerState, Tag as EventLoopTimerTag,
 };
-// TODO(port): bun_event_loop carries a local `Timespec` stub instead of
+// bun_event_loop carries a local `Timespec` stub instead of
 // `bun_core::Timespec`. Same `{sec: i64, nsec: i64}` shape; alias it here so
-// `fire()`/`next` accesses type-check without a transmute. Remove once the
-// lower tier switches to `bun_core::Timespec`.
+// `fire()`/`next` accesses type-check without a transmute.
+// TODO: remove this alias once the lower tier switches to `bun_core::Timespec`.
 pub(crate) use bun_event_loop::EventLoopTimer::Timespec as ElTimespec;
 
 use crate::jsc::JSValue;
@@ -42,10 +42,10 @@ pub mod timer;
 // ─── impl_timer_object! ──────────────────────────────────────────────────────
 // Shared scaffold for `TimeoutObject` / `ImmediateObject`: both are a
 // `#[JsClass]` payload of `{ref_count, event_loop_timer, internals}` whose
-// JS-facing host-fns are pure forwarders to `TimerObjectInternals`. Zig kept
-// two hand-duplicated files; this macro emits the byte-identical parts so each
-// `*.rs` file holds only its type-specific surface (`init`, `do_refresh`,
-// cached-prop accessors, `run_immediate_task`).
+// JS-facing host-fns are pure forwarders to `TimerObjectInternals`. The macro
+// emits the parts shared by both types so each `*.rs` file holds only its
+// type-specific surface (`init`, `do_refresh`, cached-prop accessors,
+// `run_immediate_task`).
 //
 // Emits, at the call-site module path (so `#[JsClass]`/`#[host_fn]` produce the
 // same extern symbol names as before — `Timeout__create`, `TimeoutPrototype__*`,
@@ -75,8 +75,7 @@ macro_rules! impl_timer_object {
 
         ::bun_event_loop::impl_timer_owner!($T; from_timer_ptr => event_loop_timer);
 
-        // `bun.ptr.RefCount(@This(), "ref_count", deinit, .{})` — intrusive
-        // single-thread refcount mixin.
+        // Intrusive single-thread refcount mixin.
         impl ::bun_ptr::RefCounted for $T {
             type DestructorCtx = ();
             #[inline]
@@ -96,22 +95,18 @@ macro_rules! impl_timer_object {
             fn default() -> Self {
                 Self {
                     ref_count: ::bun_ptr::RefCount::init(),
-                    // Zig: `.{ .next = .epoch, .tag = .$T }` — `init_paused`
-                    // is exactly that (next=EPOCH, state=PENDING, heap zeroed).
+                    // `init_paused`: next=EPOCH, state=PENDING, heap zeroed.
                     event_loop_timer: super::EventLoopTimer::init_paused(
                         super::EventLoopTimerTag::$tag,
                     ),
-                    // PORT NOTE: Zig left `internals = undefined` and assigned
-                    // in `init()`; Rust default-constructs then overwrites —
-                    // same observable behavior.
+                    // Default-constructed here, then overwritten in `init()`.
                     internals: super::TimerObjectInternals::default(),
                 }
             }
         }
 
         impl $T {
-            // Zig: `pub const ref = RefCount.ref; pub const deref = RefCount.deref;`
-            // — re-export the mixin's ops as inherent fns so
+            // Re-export the refcount mixin's ops as inherent fns so
             // `TimerObjectInternals`'s `container_of` dispatch resolves.
 
             /// Increment the intrusive refcount.
@@ -137,7 +132,7 @@ macro_rules! impl_timer_object {
             }
 
             /// Shared body of `TimeoutObject::init` / `ImmediateObject::init`:
-            /// `bun.new(Self, .{...})` → `to_js_ptr` → `internals.init` →
+            /// heap-allocate → `to_js_ptr` → `internals.init` →
             /// inspector `did_schedule_async_call`. The per-type `init` fn
             /// picks `kind`/`interval` and forwards here.
             pub fn init_with(
@@ -148,7 +143,7 @@ macro_rules! impl_timer_object {
                 callback: ::bun_jsc::JSValue,
                 arguments: ::bun_jsc::JSValue,
             ) -> ::bun_jsc::JSValue {
-                // `bun.new(Self, .{...})` ⇒ heap-allocate; `*mut Self` is the
+                // Heap-allocate; `*mut Self` is the
                 // `m_ctx` payload of the codegen'd JSCell wrapper. Ownership
                 // transfers to the wrapper via `to_js_ptr`; freed by
                 // `deref → deinit → heap::take`.
@@ -158,8 +153,7 @@ macro_rules! impl_timer_object {
                 // shim; `payload` is a fresh heap allocation whose ownership
                 // transfers to the GC wrapper.
                 let js_value = unsafe { Self::to_js_ptr(payload, global) };
-                // Zig codegen: `bun.assert(value__.as($T).? == this)` —
-                // round-trip ABI check.
+                // Round-trip ABI check.
                 debug_assert!(
                     <Self as ::bun_jsc::JsClass>::from_js(js_value) == Some(payload),
                     concat!($js_name, "__create ABI mismatch"),
@@ -184,8 +178,7 @@ macro_rules! impl_timer_object {
             }
 
             /// Called via `RefCounted::destructor` when the refcount reaches
-            /// zero. Not `impl Drop`: this fn frees the backing `Box` itself
-            /// (Zig: `bun.destroy(self)`).
+            /// zero. Not `impl Drop`: this fn frees the backing `Box` itself.
             ///
             /// # Safety
             /// `this` must be the unique owner (refcount == 0) of a
@@ -288,16 +281,14 @@ mod date_header_timer_draft;
 mod event_loop_delay_monitor_draft;
 
 // ─── TimerHeap ───────────────────────────────────────────────────────────────
-// Zig: `heap.Intrusive(EventLoopTimer, void, EventLoopTimer.less)`.
-//
-// Real intrusive pairing-heap (meld/remove/combine_siblings) ported in
+// Real intrusive pairing-heap (meld/remove/combine_siblings) implemented in
 // `bun_io::heap::Intrusive`. `EventLoopTimer` now embeds the real
 // `bun_io::heap::IntrusiveField` and impls `HeapNode` in its defining crate
 // (`bun_event_loop`), so the orphan-rule block is gone. `TimerHeap` is a thin
 // newtype that adapts `*mut T` ↔ `Option<*mut T>` for the existing call-sites
 // (`All::insert/remove/next/get_timeout`).
 
-/// `void` context for the heap comparator — Zig passes `{}`.
+/// Stateless context for the heap comparator.
 #[derive(Default)]
 pub(crate) struct TimerHeapCtx;
 
@@ -410,7 +401,7 @@ impl DateHeaderTimer {
         crate::jsc_hooks::timer_all()
     }
 
-    /// Spec DateHeaderTimer.zig `run` — refresh the cached `Date:` header and
+    /// Refresh the cached `Date:` header and
     /// reschedule for 1s later iff there are active connections.
     pub(crate) fn run(&mut self, vm: &mut bun_jsc::virtual_machine::VirtualMachine) {
         self.event_loop_timer.state = EventLoopTimerState::FIRED;
@@ -445,7 +436,9 @@ impl DateHeaderTimer {
 }
 
 pub struct EventLoopDelayMonitor {
-    // TODO(port): bare JSValue heap field — see EventLoopDelayMonitor.rs PORT NOTE
+    // TODO: bare `JSValue` heap field with no Strong/visitChildren rooting —
+    // the histogram object can be GC'd while `monitorEventLoopDelay` is active.
+    // Needs JsRef-style rooting.
     js_histogram: JSValue,
     pub event_loop_timer: EventLoopTimer,
     pub resolution_ms: i32,
@@ -507,7 +500,7 @@ impl EventLoopDelayMonitor {
         unsafe { (*Self::timer_all()).remove(elt) };
     }
 
-    /// Spec EventLoopDelayMonitor.zig `onFire` — record `now - last_fire_ns`
+    /// Record `now - last_fire_ns`
     /// into the JS histogram and reschedule.
     pub(crate) fn on_fire(
         &mut self,
@@ -565,14 +558,14 @@ pub use timer_object_internals::{Flags as TimerFlags, TimerObjectInternals};
 
 /// `jsc.WebCore.AbortSignal.Timeout` — real struct lives in `bun_jsc` (which
 /// this crate depends on). Re-exported here so `All::update`'s
-/// `@fieldParentPtr` epoch-bump and `dispatch::fire_timer` resolve the same
+/// field-parent-pointer epoch-bump and `dispatch::fire_timer` resolve the same
 /// `event_loop_timer`/`flags` offsets the low tier wrote.
 pub use crate::jsc::abort_signal::Timeout as AbortSignalTimeout;
 
 pub use self::immediate_object::ImmediateObject;
 pub use self::timeout_object::TimeoutObject;
 
-/// Spec EventLoopTimer.zig:145 `jsTimerInternalsFlags` — recover the
+/// Recover the
 /// [`TimerFlags`] slot for the three JS-timer container tags
 /// (`TimeoutObject` / `ImmediateObject` / `AbortSignalTimeout`), else `None`.
 ///
@@ -603,7 +596,7 @@ pub(crate) unsafe fn js_timer_flags_ptr(
                 let parent = ImmediateObject::from_timer_ptr(t);
                 addr_of!((*parent).internals.flags).cast()
             }
-            // Spec EventLoopTimer.zig:157-160 — `AbortSignal.Timeout` stores
+            // `AbortSignal.Timeout` stores
             // `flags` directly (not under `.internals`, not `Cell`-wrapped).
             EventLoopTimerTag::AbortSignalTimeout => {
                 let parent = AbortSignalTimeout::from_timer_ptr(t);
@@ -635,7 +628,7 @@ pub struct All {
     /// Whether we have emitted a warning for passing NaN for the timeout duration
     pub warned_not_number: bool,
     /// Incremented when timers are scheduled or rescheduled. See
-    /// TimerObjectInternals.epoch. Zig u25 — masked on increment.
+    /// TimerObjectInternals.epoch. Masked to 25 bits on increment.
     pub epoch: u32,
     pub immediate_ref_count: i32,
     #[cfg(windows)]
@@ -671,7 +664,7 @@ impl All {
 
     pub fn insert(&mut self, timer: *mut EventLoopTimer) {
         self.lock.lock();
-        // PORT NOTE: bun_threading::Mutex is lock()/unlock(), not RAII.
+        // Note: bun_threading::Mutex is lock()/unlock(), not RAII.
         let r = self.insert_lock_held(timer);
         self.lock.unlock();
         r
@@ -679,7 +672,7 @@ impl All {
 
     fn insert_lock_held(&mut self, timer: *mut EventLoopTimer) {
         // SAFETY: caller guarantees `timer` is a valid live EventLoopTimer.
-        // PORT NOTE (§Forbidden aliased-&mut): `TimerHeap::insert` forms a
+        // Note (§Forbidden aliased-&mut): `TimerHeap::insert` forms a
         // fresh `&mut EventLoopTimer` via `(*a).heap()` for the same
         // allocation, so we must NOT hold a `&mut *timer` across that call.
         // Read `tag` and write `state`/`in_heap` via raw deref instead.
@@ -703,16 +696,15 @@ impl All {
         }
     }
 
-    /// Spec Timer.zig:125-152 `ensureUVTimer` — lazily `uv_timer_init` the
+    /// Lazily `uv_timer_init` the
     /// per-`All` libuv timer, then (re)start it for the soonest heap deadline.
     /// On Windows there is no epoll/kqueue fallback; this `uv_timer_t` is the
     /// ONLY thing that wakes `uv_run` for JS timers.
     ///
-    /// PORT NOTE (jsc/runtime crate cycle): Zig recovers `*VirtualMachine` via
-    /// `@fieldParentPtr("timer", this)` (the VM that *owns* this `All`) and
-    /// reads `vm.uvLoop()` == `vm.event_loop_handle`. In Rust `All` is a field
+    /// Note (jsc/runtime crate cycle): `All` is a field
     /// of `RuntimeState` (not `VirtualMachine`) and `RuntimeState` carries no
-    /// back-pointer, so the lazy-init block falls back to the calling thread's
+    /// back-pointer to the owning VM, so the lazy-init block falls back to the
+    /// calling thread's
     /// TLS VM/loop. That equivalence holds **only** on the owning JS thread;
     /// `All.lock` exists precisely because `insert`/`update` may be entered
     /// cross-thread (WTFTimer), where TLS would resolve to the wrong loop or
@@ -721,12 +713,12 @@ impl All {
     /// (`uv_handle_get_loop`), so the hot path is TLS-free and always targets
     /// the loop the timer was actually registered on.
     ///
-    /// TODO(port): thread `vm: *mut VirtualMachine` through
-    /// `insert`/`insert_lock_held`/`update` (matching the Zig signature) once
+    /// TODO: thread `vm: *mut VirtualMachine` through
+    /// `insert`/`insert_lock_held`/`update` once
     /// the `RuntimeHooks::timer_insert` slot widens — see jsc_hooks.rs.
     #[cfg(windows)]
     fn ensure_uv_timer(&mut self) {
-        // Spec: `vm` is `@fieldParentPtr("timer", this)` — i.e. the OWNING VM,
+        // `vm` here means the OWNING VM (the one this timer is embedded in),
         // not the calling thread's. Guard the TLS fallback so a cross-thread
         // caller fails loudly instead of silently arming a fresh `uv_loop_t`
         // on the wrong thread.
@@ -773,7 +765,7 @@ impl All {
         }
     }
 
-    /// Spec Timer.zig:154-159 `onUVTimer` — libuv timer callback; drain due
+    /// libuv timer callback; drain due
     /// timers then re-arm for the next deadline. Only ever invoked by libuv
     /// (coerces to the `uv_timer_cb` fn-pointer type at the `Timer::start`
     /// call site); body wraps its derefs explicitly.
@@ -802,14 +794,13 @@ impl All {
 
     fn remove_lock_held(&mut self, timer: *mut EventLoopTimer) {
         // SAFETY: caller guarantees `timer` is a valid live EventLoopTimer.
-        // PORT NOTE (§Forbidden aliased-&mut): `TimerHeap::remove` forms a
+        // Note (§Forbidden aliased-&mut): `TimerHeap::remove` forms a
         // fresh `&mut EventLoopTimer` via `(*v).heap()` for the same
         // allocation, so we must NOT hold a `&mut *timer` across that call.
         // Read `in_heap` and write the post-remove bookkeeping via raw deref.
         match unsafe { (*timer).in_heap } {
             InHeap::None => {
                 // can't remove a timer that was not inserted
-                // Zig: gated on `bun.Environment.ci_assert`.
                 debug_assert!(false);
             }
             // SAFETY: timer is in `self.timers` per `in_heap`
@@ -831,7 +822,7 @@ impl All {
     /// provenance for its tag (see [`js_timer_flags_ptr`]).
     // `timer` must stay `*mut`: the body forms only short-lived `&mut *timer`
     // so re-entrant `remove_lock_held` does not alias an outstanding `&mut`
-    // (see PORT NOTEs below); contract is documented in `# Safety`.
+    // (see Notes below); contract is documented in `# Safety`.
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn update(&mut self, timer: *mut EventLoopTimer, time: &Timespec) {
         self.lock.lock();
@@ -845,21 +836,22 @@ impl All {
 
         // SAFETY: `timer` is still a valid live EventLoopTimer; safe to derive
         // an exclusive reference now that no other borrow is outstanding.
+        // `time` cannot alias `timer.next`: `time` is a `&bun_core::Timespec`
+        // while `next` is `ElTimespec` — distinct types, so safe code cannot
+        // construct the alias. Re-add a
+        // `debug_assert!(!core::ptr::eq(time as *const _ as *const u8, &raw const (*timer).next as *const u8))`
+        // when the Timespec types unify (see the ElTimespec alias TODO at the
+        // top of this file).
         let timer_ref = unsafe { &mut *timer };
-        // PORT NOTE: Zig asserts `&timer.next != time` (threadsafety); the
-        // EventLoopTimer.Timespec and bun_core::Timespec are distinct types
-        // until the lower tier unifies them, so the pointer-compare is moot
-        // here. Re-add once `bun_event_loop` switches to `bun_core::Timespec`.
         timer_ref.next.sec = time.sec;
         timer_ref.next.nsec = time.nsec;
 
-        // Spec Timer.zig:117-120: bump the global epoch and write it back
+        // Bump the global epoch and write it back
         // into the per-timer flags so equal-deadline JS timers fire in
         // refresh order.
         // SAFETY: `timer` is live (caller contract); `timer_ref`'s last use
         // is above so the raw `(*timer).tag` read inside is SB-clean.
         if let Some(flags) = unsafe { js_timer_flags_ptr(timer) } {
-            // Zig: `epoch: u25` with `+%= 1`.
             self.epoch = self.epoch.wrapping_add(1) & ((1u32 << 25) - 1);
             // SAFETY: exclusive under `self.lock`; `flags` points into the
             // live container recovered above.
@@ -873,7 +865,7 @@ impl All {
     /// Called from `EventLoop::auto_tick` to compute the epoll/kqueue timeout.
     /// Returns `true` if `spec` was written.
     ///
-    /// PORT NOTE (b2): `vm` is erased per §Dispatch (the caller is in
+    /// Note (b2): `vm` is erased per §Dispatch (the caller is in
     /// `bun_jsc::event_loop` which can't name `bun_runtime`). The two reads
     /// it needs — `event_loop.immediate_tasks.len()` and the QUIC tick — are
     /// passed in pre-computed until the cycle is broken.
@@ -899,7 +891,7 @@ impl All {
         #[cfg(not(unix))]
         let _ = has_pending_immediate;
 
-        // PORT NOTE (§Forbidden aliased-&mut): the WTFTimer arm below calls
+        // Note (§Forbidden aliased-&mut): the WTFTimer arm below calls
         // `(*min).fire(...)` → `WTFTimer__fire` → C++ may call back into
         // `WTFTimer__update` → `(*runtime_state()).timer.update(...)`, minting
         // a fresh `&mut All` to this same allocation while the outer
@@ -907,12 +899,11 @@ impl All {
         // convert `self` to a raw pointer up-front and form *short-lived*
         // `&mut *this` borrows only around `peek()`/`delete_min()`, dropping
         // them before `fire()` so no `&mut All` is held across the re-entrant
-        // call. Spec Timer.zig:247 takes `*All` (raw pointer) for the same
-        // reason.
+        // call.
         //
-        // TODO(port): same caveat as `drain_timers` — the call-site auto-ref
+        // TODO: same caveat as `drain_timers` — the call-site auto-ref
         // still creates a `&mut All` for the call frame; switch the signature
-        // to `this: *mut Self` (see jsc_hooks.rs:525).
+        // to `this: *mut Self` (see the `get_timeout` call sites in jsc_hooks.rs).
         let this: *mut Self = self;
         let mut maybe_now: Option<Timespec> = None;
         loop {
@@ -922,7 +913,7 @@ impl All {
                 break;
             };
             // SAFETY: peek returns a live heap node.
-            // PORT NOTE (§Forbidden aliased-&mut): `delete_min()` writes
+            // Note (§Forbidden aliased-&mut): `delete_min()` writes
             // `(*min).heap` through a fresh `&mut EventLoopTimer`, so we must
             // NOT hold a `&mut *min` across it. Read `next`/`tag` via raw
             // deref and fire via raw deref (mirroring `drain_timers`).
@@ -1025,8 +1016,7 @@ impl All {
     // not_unsafe_ptr_arg_deref is a false positive on opaque-token forwarding.
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn drain_timers(&mut self, vm: *mut () /* erased *mut VirtualMachine */) {
-        // PORT NOTE (§Forbidden aliased-&mut): spec Timer.zig:346-354 takes
-        // `*All` (raw pointer) because fired handlers re-enter `vm.timer`
+        // Note (§Forbidden aliased-&mut): fired handlers re-enter `vm.timer`
         // (e.g. setInterval reschedule → `vm.timer.update(...)`, `cancel()` →
         // `vm.timer.remove(...)`). In Rust those re-entrant calls resolve to
         // `(*runtime_state()).timer.{update,remove}()`, minting a fresh
@@ -1037,7 +1027,7 @@ impl All {
         // re-entrant call (mirroring the raw-ptr pattern in
         // `TimerObjectInternals::run_immediate_task`).
         //
-        // TODO(port): the call-site auto-ref at jsc_hooks.rs (`(*state).timer
+        // TODO: the call-site auto-ref at jsc_hooks.rs (`(*state).timer
         // .drain_timers(...)`) still creates a `&mut All` for the call frame
         // itself; switch it to `All::drain_timers(core::ptr::addr_of_mut!(
         // (*state).timer), vm)` and change this signature to `this: *mut Self`.
@@ -1050,7 +1040,7 @@ impl All {
             let Some(t) = (unsafe { &mut *this }).next(&mut has_set_now, &mut now) else {
                 break;
             };
-            // PORT NOTE: re-pack into bun_event_loop's local Timespec stub
+            // Note: re-pack into bun_event_loop's local Timespec stub
             // until the lower tier unifies on bun_core::Timespec.
             let el_now = ElTimespec {
                 sec: now.sec,
@@ -1080,12 +1070,12 @@ impl All {
             unsafe { &mut *uws_loop }.ref_();
             #[cfg(windows)]
             {
-                // Spec Timer.zig:168-179: lazy-init the idle handle and start
+                // Lazy-init the idle handle and start
                 // it with a no-op callback so `uv_run` does not block in poll
                 // while immediates are pending (matches Node.js).
                 if self.uv_idle.data.is_null() {
                     self.uv_idle.init(uv::Loop::get());
-                    // PORT NOTE: Zig stashes `vm` here; only used as a
+                    // Note: `data` is only used as a
                     // non-null "initialized" sentinel — never dereferenced.
                     self.uv_idle.data = bun_jsc::virtual_machine::VirtualMachine::get_mut_ptr()
                         .cast::<core::ffi::c_void>();
@@ -1105,7 +1095,7 @@ impl All {
         let _ = uws_loop;
     }
 
-    /// Spec Timer.zig:175-177 — empty `uv_idle` callback. Its presence alone
+    /// Empty `uv_idle` callback. Its presence alone
     /// keeps `uv_run` from blocking in the poll phase; the body is a no-op.
     /// No preconditions (the handle pointer is unused), so the fn is safe; the
     /// safe fn item coerces into the `uv_idle_cb` fn-pointer slot.
@@ -1129,12 +1119,11 @@ impl All {
             #[cfg(not(windows))]
             // SAFETY: caller passes the VM's live uws loop
             unsafe { &mut *uws_loop }.ref_();
-            // Spec Timer.zig:207-213 calls `this.uv_timer.ref()` unconditionally
-            // (no `data != null` guard). Invariant: every path that reaches a
-            // positive `active_timer_count` first inserts a timer, and `insert`
+            // `uv_timer.ref()` is intentionally unconditional (no `data !=
+            // null` guard). Invariant: every path that reaches a positive
+            // `active_timer_count` first inserts a timer, and `insert`
             // → `ensure_uv_timer` lazily `uv_timer_init`s the handle. Guarding
-            // here would silently drop the ref and let the loop exit early, so
-            // match Zig exactly.
+            // here would silently drop the ref and let the loop exit early.
             #[cfg(windows)]
             self.uv_timer.ref_();
         } else if old > 0 && new <= 0 {
@@ -1305,10 +1294,9 @@ impl Default for ID {
 impl ID {
     #[inline]
     pub(crate) fn async_id(self) -> u64 {
-        // Zig `@bitCast(extern struct { i32, u32 })`: 8 bytes, field order
-        // `id` then `kind`. Reassemble via native-endian byte concat so the
-        // value matches the prior bitcast on every supported target without
-        // relying on struct-layout reinterpretation.
+        // Layout: 8 bytes, `id` (i32) then `kind` (u32). Reassemble via
+        // native-endian byte concat so the value is stable on every supported
+        // target without relying on struct-layout reinterpretation.
         let mut bytes = [0u8; 8];
         bytes[..4].copy_from_slice(&self.id.to_ne_bytes());
         bytes[4..].copy_from_slice(&(self.kind as u32).to_ne_bytes());
@@ -1318,5 +1306,3 @@ impl ID {
 
 const US_PER_S: i64 = bun_core::time::US_PER_S as i64;
 const NS_PER_US: i64 = bun_core::time::NS_PER_US as i64;
-
-// ported from: src/runtime/timer/Timer.zig
diff --git a/src/runtime/timer/timer_object_internals.rs b/src/runtime/timer/timer_object_internals.rs
index 5d499f5eed3..2a657013945 100644
--- a/src/runtime/timer/timer_object_internals.rs
+++ b/src/runtime/timer/timer_object_internals.rs
@@ -16,7 +16,7 @@ use crate::jsc::{
     generated::{JSImmediate, JSTimeout},
 };
 use core::cell::Cell;
-// PORT NOTE: `bun_jsc::VirtualMachine` is a *module* alias; the struct lives at
+// Note: `bun_jsc::VirtualMachine` is a *module* alias; the struct lives at
 // `virtual_machine::VirtualMachine`.
 use crate::jsc::virtual_machine::VirtualMachine;
 
@@ -30,7 +30,7 @@ use super::{
 pub struct TimerObjectInternals {
     /// Identifier for this timer that is exposed to JavaScript (by `+timer`).
     pub id: i32,
-    pub interval: Cell<u32>, // Zig: u31
+    pub interval: Cell<u32>,
     pub this_value: JsCell<JsRef>,
     pub flags: Cell<Flags>,
     /// `bun test --isolate` generation this timer was created in.
@@ -176,10 +176,8 @@ impl TimerObjectInternals {
         .async_id()
     }
 
-    /// Spec TimerObjectInternals.zig `setEnableKeepingEventLoopAlive`.
-    ///
-    /// PORT NOTE (jsc/runtime crate cycle): Zig reaches `vm.timer` (a value field of
-    /// `VirtualMachine`); the low-tier `bun_jsc::VirtualMachine.timer` is `()`,
+    /// Note (jsc/runtime crate cycle): the low-tier
+    /// `bun_jsc::VirtualMachine.timer` is `()`,
     /// so resolve `Timer::All` via the per-thread `RuntimeState` instead.
     fn set_enable_keeping_event_loop_alive(&self, vm: *mut VirtualMachine, enable: bool) {
         if self.flags.get().is_keeping_event_loop_alive() == enable {
@@ -206,18 +204,18 @@ impl TimerObjectInternals {
         }
     }
 
-    /// Spec TimerObjectInternals.zig `run` — invoke the JS callback via the
+    /// Invoke the JS callback via the
     /// C++ `Bun__JSTimeout__call` thunk (which handles exceptions internally).
     /// Returns `true` if an exception was thrown.
     ///
-    /// PORT NOTE (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
+    /// Note (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
     /// The JS callback can re-enter `cancel()`/`do_refresh()` on this same
     /// object via a fresh `&mut Self` derived from the JS wrapper's `m_ptr`.
     /// With `&mut self` here, LLVM's `noalias` lets it keep `self.flags` in a
     /// register across the FFI call, so `set_in_callback(false)`'s RMW
     /// clobbers the `has_cleared_timer` bit that `cancel()` set — the interval
-    /// re-fires forever. Zig's `*TimerObjectInternals` has no aliasing
-    /// guarantee; mirror that with a raw pointer.
+    /// re-fires forever. A raw pointer carries no aliasing guarantee, so use
+    /// one here.
     ///
     /// # Safety
     /// `this` points at a live `TimerObjectInternals` embedded in its parent
@@ -251,15 +249,12 @@ impl TimerObjectInternals {
         // runs (re-entrant `_destroyed` getter reads it via a different pointer).
         s.update_flags(|f| f.set_in_callback(true));
         let result = Bun__JSTimeout__call(global, timer, callback, arguments);
-        // PORT NOTE: reshaped for borrowck — Zig `defer this.flags.in_callback = false`
-        // moved to tail; no early returns between set and clear.
+        // No early returns between the `in_callback` set and this clear.
         // `Cell<Flags>` RMW: must reload `flags` from memory — re-entrant
         // `cancel()` may have set `has_cleared_timer` / cleared
         // `is_keeping_event_loop_alive`.
         s.update_flags(|f| f.set_in_callback(false));
 
-        // PORT NOTE: Zig `defer { if isInspectorEnabled() didDispatch }` —
-        // moved to tail (no early returns above).
         // SAFETY: as above.
         if unsafe { (*vm).is_inspector_enabled() } {
             Debugger::did_dispatch_async_call(global, Debugger::AsyncCallType::DOMTimer, async_id);
@@ -268,22 +263,21 @@ impl TimerObjectInternals {
         result
     }
 
-    /// Spec TimerObjectInternals.zig `init` — out-param constructor; `self` is
+    /// Out-param constructor; `self` is
     /// the embedded `internals` field of a freshly `heap::alloc`'d
     /// `ImmediateObject`/`TimeoutObject`. Cannot be
     /// reshaped to `-> Self` because the body needs the parent pointer to
     /// enqueue/reschedule before returning.
     ///
-    /// PORT NOTE (jsc/runtime crate cycle): `vm.timer.epoch` resolved via `runtime_state()`
+    /// Note (jsc/runtime crate cycle): `vm.timer.epoch` resolved via `runtime_state()`
     /// (low-tier `VirtualMachine.timer` is `()`).
-    // TODO(port): in-place init — see ImmediateObject::init / TimeoutObject::init.
     pub fn init(
         &mut self,
         timer: JSValue,
         global: &JSGlobalObject,
         id: i32,
         kind: Kind,
-        interval: u32, // Zig: u31
+        interval: u32,
         callback: JSValue,
         arguments: JSValue,
     ) {
@@ -346,14 +340,14 @@ impl TimerObjectInternals {
         self.this_value.with_mut(|r| r.set_strong(timer, global));
     }
 
-    /// Spec TimerObjectInternals.zig `runImmediateTask`. Returns `true` if an
+    /// Returns `true` if an
     /// exception was thrown.
     ///
-    /// PORT NOTE (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
+    /// Note (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
     /// `Self::run` re-enters JS which can `cancel()`/`do_refresh()` this same
     /// object via the JS wrapper's `m_ptr`. With `&mut self` LLVM may cache
     /// `self.flags`/`event_loop_timer().state` across the call and clobber the
-    /// re-entrant write (see `run()` doc). Mirror Zig's `*Self` with a raw
+    /// re-entrant write (see `run()` doc). Use a raw
     /// pointer; helper calls `(*this).foo()` materialise short-lived `&mut`
     /// scoped to each statement only — none span the JS call.
     ///
@@ -418,9 +412,8 @@ impl TimerObjectInternals {
             // above pins the parent across re-entrancy.
             let result =
                 unsafe { Self::run(this, global_this, timer, callback, arguments, async_id, vm) };
-            // PORT NOTE: Zig `defer { if state == .FIRED deref(); deref(); }` —
-            // moved to tail of this block; `Self::run` has no early return so
-            // ordering is preserved. After the second `deref()` `*this` may be
+            // `Self::run` has no early return so the deref ordering below is
+            // preserved. After the second `deref()` `*this` may be
             // freed; do not touch it past this block.
             // Fresh read: re-entrant `cancel()`/`refresh()` may have changed
             // `state` (`ref_()` above pins the parent).
@@ -451,27 +444,26 @@ impl TimerObjectInternals {
         s.deref();
     }
 
-    /// Spec TimerObjectInternals.zig `fire` — `EventLoopTimer.fire` dispatch
+    /// `EventLoopTimer.fire` dispatch
     /// arm body for `Tag::TimeoutObject`/`Tag::ImmediateObject`. Pops the JS
     /// timer, invokes its callback via `run()`, then either reschedules
     /// (setInterval / `t._repeat`) or releases the heap ref.
     ///
-    /// PORT NOTE: takes `*mut VirtualMachine` (NOT `&mut`) — the body calls
+    /// Note: takes `*mut VirtualMachine` (NOT `&mut`) — the body calls
     /// `vm.event_loop().enter()` then re-enters JS which may itself touch the
     /// VM/EventLoop (and `(*runtime_state()).timer` via `cancel()`/`refresh()`);
     /// aliased `&mut` would be UB. Dereference per-use under `// SAFETY:`.
-    /// Spec Timer.zig:346 takes `*All`/`*VirtualMachine` for the same reason.
     ///
-    /// PORT NOTE (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
+    /// Note (noalias re-entrancy): takes `*mut Self`, NOT `&mut self`.
     /// `Self::run` re-enters JS which can `cancel()`/`do_refresh()` this same
     /// object via the JS wrapper's `m_ptr`. With `&mut self` LLVM may cache
     /// `self.flags`/`event_loop_timer().state` across the call and dead-store
     /// the post-call reloads in `should_reschedule_timer`/`is_timer_done` —
-    /// the interval re-fires forever. Mirror Zig's `*Self` with a raw pointer;
+    /// the interval re-fires forever. Use a raw pointer;
     /// helper calls `(*this).foo()` materialise short-lived `&mut` scoped to
     /// each statement only — none span the JS call.
     ///
-    /// PORT NOTE (jsc/runtime crate cycle): `vm.timer` resolved via
+    /// Note (jsc/runtime crate cycle): `vm.timer` resolved via
     /// `crate::jsc_hooks::runtime_state()` — low-tier `VirtualMachine.timer`
     /// is `()` (see `set_enable_keeping_event_loop_alive`).
     ///
@@ -570,7 +562,7 @@ impl TimerObjectInternals {
         {
             // Ensure it stays alive for this scope.
             s.ref_();
-            // PORT NOTE: Zig `defer this.deref()` — moved to the end of this
+            // The matching `deref()` is at the end of this
             // block. Every path through the labelled-block + `is_timer_done`
             // tail reaches it (no `return` between here and the deref).
 
@@ -686,7 +678,7 @@ impl TimerObjectInternals {
                 s.deref();
             }
 
-            // PORT NOTE: Zig `defer this.deref()` — end of pinned scope. After
+            // End of pinned scope. After
             // this `*this` may be freed; do not touch past this block.
             s.deref();
         }
@@ -696,11 +688,11 @@ impl TimerObjectInternals {
         unsafe { (*(*vm).event_loop()).exit() };
     }
 
-    /// Spec TimerObjectInternals.zig `convertToInterval` — a `setTimeout` whose
+    /// A `setTimeout` whose
     /// `t._repeat` was assigned promotes itself to a `setInterval` after its
     /// first fire (Node `lib/internal/timers.js:613`).
     ///
-    /// PORT NOTE: takes `vm` explicitly instead of `global.bun_vm()` so the
+    /// Note: takes `vm` explicitly instead of `global.bun_vm()` so the
     /// raw-ptr contract from `fire()` is preserved (no fresh `&mut VM`).
     /// `&self` (not `&mut`) — all writes go through `Cell`/`JsCell`; the sole
     /// caller (`fire()`) holds only a `&Self`.
@@ -714,7 +706,6 @@ impl TimerObjectInternals {
         debug_assert!(self.flags.get().kind() == Kind::SetTimeout);
 
         let new_interval: u32 = if let Some(num) = repeat.get_number() {
-            // Zig: `if (num < 1 or num > maxInt(u31)) 1 else @intFromFloat(num)`
             if num < 1.0 || num > f64::from(u32::MAX >> 1) {
                 1
             } else {
@@ -735,7 +726,6 @@ impl TimerObjectInternals {
         self.reschedule(timer, vm, global);
     }
 
-    /// Spec TimerObjectInternals.zig `shouldRescheduleTimer`.
     fn should_reschedule_timer(&self, repeat: JSValue, idle_timeout: JSValue) -> bool {
         if self.flags.get().kind() == Kind::SetInterval && repeat.is_null() {
             return false;
@@ -748,11 +738,11 @@ impl TimerObjectInternals {
         true
     }
 
-    /// Spec TimerObjectInternals.zig `reschedule` — re-insert the parent's
+    /// Re-insert the parent's
     /// `EventLoopTimer` into the heap at `now + interval`. Called from
     /// `init()`, `do_refresh()`, and `convert_to_interval()` above.
     ///
-    /// PORT NOTE (jsc/runtime crate cycle): `vm.timer` resolved via `runtime_state()`.
+    /// Note (jsc/runtime crate cycle): `vm.timer` resolved via `runtime_state()`.
     pub fn reschedule(
         &self,
         timer: JSValue,
@@ -809,15 +799,15 @@ impl TimerObjectInternals {
         }
     }
 
-    /// Spec TimerObjectInternals.zig `deinit` — final teardown invoked by the
+    /// Final teardown invoked by the
     /// parent container's intrusive-refcount destructor (`{Timeout,Immediate}
     /// Object::deref` when the count hits zero). Unlinks the parent from every
     /// `Timer::All` data structure it may still be reachable from so the
     /// imminent `heap::take` free cannot leave a dangling
     /// `*mut EventLoopTimer` in the heap or a leaked keep-alive count.
     ///
-    /// PORT NOTE: `this_value.deinit()` (Zig line 499) is intentionally NOT
-    /// called here — `JsRef: Drop` runs when the parent `Box` is reclaimed
+    /// Note: an explicit `this_value` release is intentionally NOT
+    /// done here — `JsRef: Drop` runs when the parent `Box` is reclaimed
     /// immediately after this returns, performing the same release.
     /// `ref_count.assertNoRefs()` is likewise omitted: the only caller is the
     /// `n == 1` branch of `deref`, so the count is provably zero.
@@ -849,13 +839,19 @@ impl TimerObjectInternals {
         if self.flags.get().has_accessed_primitive() {
             // SAFETY: as above — fresh `&mut` to `.timer.maps` for this call.
             let map = unsafe { (*state).timer.maps.get(kind) };
-            // PORT NOTE: Zig follows up with a shrink-and-free heuristic
-            // (>256 KiB slack ⇒ `shrinkAndFree`); `bun_collections::ArrayHashMap`
-            // exposes neither `capacity()` nor `shrink_and_free()`, so the
-            // reclamation is omitted. Correctness is unaffected — the entry is
-            // gone — only the high-watermark capacity lingers.
-            // TODO(port): plumb a `shrink_to_fit` once `ArrayHashMap` grows one.
-            if map.remove(&self.id).is_none() && kind == Kind::SetInterval {
+            if map.remove(&self.id).is_some() {
+                // If this map got
+                // large, shrink it back down. Keys are i32, values are one
+                // pointer (~12 bytes per entry), so 21,000 timers accessed by
+                // ID ≈ 252 KiB; reclaim once the slack exceeds 256 KiB.
+                const ENTRY_SIZE: usize =
+                    core::mem::size_of::<i32>() + core::mem::size_of::<*mut EventLoopTimer>();
+                let allocated_bytes = map.capacity() * ENTRY_SIZE;
+                let used_bytes = map.count() * ENTRY_SIZE;
+                if allocated_bytes - used_bytes > 256 * 1024 {
+                    map.shrink_and_free(map.count() + 8);
+                }
+            } else if kind == Kind::SetInterval {
                 // A `setTimeout` promoted to a `setInterval` by
                 // `convert_to_interval()` keeps the entry minted by
                 // `toPrimitive` in `maps.set_timeout`. Remove it from there
@@ -899,7 +895,6 @@ impl TimerObjectInternals {
         unsafe { (*self.event_loop_timer()).state = state };
     }
 
-    /// Spec TimerObjectInternals.zig `doRef`.
     pub fn do_ref(&self, _global: &JSGlobalObject, this_value: JSValue) -> JsResult<JSValue> {
         this_value.ensure_still_alive();
 
@@ -920,7 +915,6 @@ impl TimerObjectInternals {
         Ok(this_value)
     }
 
-    /// Spec TimerObjectInternals.zig `doUnref`.
     pub fn do_unref(&self, _global: &JSGlobalObject, this_value: JSValue) -> JsResult<JSValue> {
         this_value.ensure_still_alive();
 
@@ -934,7 +928,6 @@ impl TimerObjectInternals {
         Ok(this_value)
     }
 
-    /// Spec TimerObjectInternals.zig `doRefresh`.
     pub fn do_refresh(
         &self,
         global_object: &JSGlobalObject,
@@ -964,24 +957,23 @@ impl TimerObjectInternals {
         Ok(this_value)
     }
 
-    /// Spec TimerObjectInternals.zig `hasRef`.
     pub fn has_ref(&self) -> JsResult<JSValue> {
         Ok(JSValue::from(
             self.flags.get().is_keeping_event_loop_alive(),
         ))
     }
 
-    /// Spec TimerObjectInternals.zig `toPrimitive` — first access mints an
+    /// First access mints an
     /// `id → *mut EventLoopTimer` entry in `All.maps` so `clearTimeout(+t)` /
     /// `clearImmediate(+t)` (numeric-id form) can resolve it.
     ///
-    /// PORT NOTE (jsc/runtime crate cycle): `vm.timer.maps` resolved via `runtime_state()`.
+    /// Note (jsc/runtime crate cycle): `vm.timer.maps` resolved via `runtime_state()`.
     pub fn to_primitive(&self) -> JsResult<JSValue> {
         if !self.flags.get().has_accessed_primitive() {
             self.update_flags(|f| f.set_has_accessed_primitive(true));
             let state = crate::jsc_hooks::runtime_state();
             debug_assert!(!state.is_null(), "RuntimeState not installed");
-            // PORT NOTE: reshaped for borrowck — capture `event_loop_timer` ptr
+            // Note: reshaped for borrowck — capture `event_loop_timer` ptr
             // before borrowing `(*state).timer.maps`.
             let elt = self.event_loop_timer();
             // SAFETY: `state` is the boxed per-thread `RuntimeState`;
@@ -997,7 +989,7 @@ impl TimerObjectInternals {
         Ok(JSValue::js_number(f64::from(self.id)))
     }
 
-    /// Spec TimerObjectInternals.zig `getDestroyed` — getter for `_destroyed`
+    /// Getter for `_destroyed`
     /// on JS Timeout and Immediate objects.
     pub fn get_destroyed(&self) -> bool {
         if self.flags.get().has_cleared_timer() {
@@ -1012,7 +1004,7 @@ impl TimerObjectInternals {
         }
     }
 
-    /// Spec TimerObjectInternals.zig `finalize` — `.classes.ts` finalizer hook.
+    /// `.classes.ts` finalizer hook.
     /// Runs on the mutator thread during lazy sweep; do not touch any
     /// `JSValue`/`Strong` content here.
     pub fn finalize(&self) {
@@ -1020,10 +1012,10 @@ impl TimerObjectInternals {
         self.deref();
     }
 
-    /// Spec TimerObjectInternals.zig `cancel` — `clearTimeout`/`clearInterval`
+    /// `clearTimeout`/`clearInterval`
     /// / `clearImmediate` / `Timeout#[Symbol.dispose]` body.
     ///
-    /// PORT NOTE: takes `*mut VirtualMachine` (NOT `&mut`) — callers hand over
+    /// Note: takes `*mut VirtualMachine` (NOT `&mut`) — callers hand over
     /// `global.bun_vm()` (raw ptr) and the body forwards to
     /// `set_enable_keeping_event_loop_alive` which already uses the raw-ptr
     /// contract. `vm.timer` resolved via `runtime_state()` (jsc/runtime crate cycle).
@@ -1053,5 +1045,3 @@ impl TimerObjectInternals {
         }
     }
 }
-
-// ported from: src/runtime/timer/TimerObjectInternals.zig
diff --git a/src/runtime/valkey_jsc/ValkeyCommand.rs b/src/runtime/valkey_jsc/ValkeyCommand.rs
index d63faaec251..fcd1412a89a 100644
--- a/src/runtime/valkey_jsc/ValkeyCommand.rs
+++ b/src/runtime/valkey_jsc/ValkeyCommand.rs
@@ -6,14 +6,14 @@ use super::protocol_jsc::{ToJSOptions, resp_value_to_js_with_options};
 
 type Slice = bun_core::ZigStringSlice;
 
-// PORT NOTE: callers in `js_valkey_functions.rs` construct
+// Note: callers in `js_valkey_functions.rs` construct
 // `Vec<crate::node::types::BlobOrStringOrBuffer>` directly, so `Args::Args` must accept
 // that exact type. The upstream `bun_jsc::Node::BlobOrStringOrBuffer` re-export is a
 // stub; use the real in-crate definition (which already provides `slice()` /
 // `byte_length()`).
 type BlobOrStringOrBuffer = crate::node::types::BlobOrStringOrBuffer;
 
-// PORT NOTE: `Command` is a transient view struct (Zig `deinit` is a no-op); fields
+// Note: `Command` is a transient view struct; fields
 // borrow caller-owned data for the duration of serialization.
 #[derive(Copy, Clone)]
 pub struct Command<'a> {
@@ -57,7 +57,6 @@ impl<'a> Args<'a> {
 
 impl<'a> Command<'a> {
     pub fn write(&self, writer: &mut impl bun_io::Write) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         // Serialize as RESP array format directly
         write!(writer, "*{}\r\n", 1 + self.args.len())?;
         write!(writer, "${}\r\n", self.command.len())?;
@@ -92,30 +91,19 @@ impl<'a> Command<'a> {
     }
 
     pub fn byte_length(&self) -> usize {
-        // Zig: std.fmt.count — DiscardingWriter is bun_io's byte-counting null sink.
+        // DiscardingWriter is bun_io's byte-counting null sink.
         let mut counter = bun_io::DiscardingWriter::default();
         self.write(&mut counter).expect("unreachable");
         counter.count
     }
 
     pub fn serialize(&self) -> Result<Box<[u8]>, bun_core::Error> {
-        // TODO(port): narrow error set
         let mut buf: Vec<u8> = Vec::with_capacity(self.byte_length());
         self.write(&mut buf)?;
         Ok(buf.into_boxed_slice())
     }
 }
 
-impl<'a> core::fmt::Display for Command<'a> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        // TODO(port): RESP bytes may not be valid UTF-8; Zig used the byte-writer protocol.
-        // Route Display through a byte-writing adapter or drop Display entirely.
-        let mut buf: Vec<u8> = Vec::new();
-        self.write(&mut buf).map_err(|_| core::fmt::Error)?;
-        write!(f, "{}", bstr::BStr::new(&buf))
-    }
-}
-
 /// Command stored in offline queue when disconnected
 pub struct Entry {
     pub serialized_data: Box<[u8]>, // Pre-serialized RESP protocol bytes
@@ -123,7 +111,7 @@ pub struct Entry {
     pub promise: Promise,
 }
 
-// Zig: `pub const Queue = bun.LinearFifo(Entry, .Dynamic);` — inherent associated
+// Inherent associated
 // types are unstable on stable Rust, so expose as a sibling module alias instead.
 pub mod entry {
     pub(crate) type Queue = super::LinearFifo<super::Entry, super::DynamicBuffer<super::Entry>>;
@@ -132,10 +120,9 @@ pub mod entry {
 impl Entry {
     // Create an Offline by serializing the Valkey command directly
     pub fn create(command: &Command<'_>, promise: Promise) -> Result<Entry, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Entry {
             serialized_data: command.serialize()?,
-            // TODO(markovejnovic): We should be calling .check against command here but due
+            // We should be calling .check against command here but due
             // to a hack introduced to let SUBSCRIBE work, we are not doing that for now.
             meta: command.meta,
             promise,
@@ -143,8 +130,6 @@ impl Entry {
     }
 }
 
-// Zig `Entry.deinit` only freed `serialized_data`; `Box<[u8]>` drops automatically.
-
 bitflags::bitflags! {
     #[repr(transparent)]
     #[derive(Clone, Copy, PartialEq, Eq)]
@@ -159,13 +144,13 @@ bitflags::bitflags! {
 
 impl Default for Meta {
     fn default() -> Self {
-        // Zig field defaults: supports_auto_pipelining = true, rest false.
+        // supports_auto_pipelining defaults to true, rest false.
         Meta::SUPPORTS_AUTO_PIPELINING
     }
 }
 
-// PERF(port): was `phf::Set<&[u8]>`. 16 entries spread across 9 distinct
-// lengths (max 4 per bucket), so a length-gated match beats the phf hash:
+// PERF: 16 entries spread across 9 distinct
+// lengths (max 4 per bucket), so a length-gated match beats a phf hash set:
 // the outer `usize` compare rejects almost everything before any byte
 // compare, and within a bucket the known-equal-length lets LLVM lower the
 // `==` to a single wide load/compare. See clap::find_param (12577e958d71)
@@ -239,15 +224,13 @@ impl Promise {
     }
 }
 
-// Zig `Promise.deinit` only called `self.promise.deinit()`; JSPromiseStrong's Drop handles it.
-
 // Command+Promise pair for tracking which command corresponds to which promise
 pub struct PromisePair {
     pub meta: Meta,
     pub promise: Promise,
 }
 
-// Zig: `pub const Queue = bun.LinearFifo(PromisePair, .Dynamic);` — see `entry` note above.
+// See `entry` note above.
 pub mod promise_pair {
     pub(crate) type Queue =
         super::LinearFifo<super::PromisePair, super::DynamicBuffer<super::PromisePair>>;
@@ -263,5 +246,3 @@ impl PromisePair {
         Ok(())
     }
 }
-
-// ported from: src/runtime/valkey_jsc/ValkeyCommand.zig
diff --git a/src/runtime/valkey_jsc/ValkeyContext.rs b/src/runtime/valkey_jsc/ValkeyContext.rs
index 9fa820f6c71..72fea893c78 100644
--- a/src/runtime/valkey_jsc/ValkeyContext.rs
+++ b/src/runtime/valkey_jsc/ValkeyContext.rs
@@ -5,8 +5,3 @@
 
 #[derive(Default)]
 pub struct ValkeyContext;
-
-// Zig had `pub fn deinit(_: *@This()) void {}` — empty body, no side effects.
-// Per PORTING.md: empty deinit → no `impl Drop` needed (Rust drops fields automatically).
-
-// ported from: src/runtime/valkey_jsc/ValkeyContext.zig
diff --git a/src/runtime/valkey_jsc/index.rs b/src/runtime/valkey_jsc/index.rs
index d6f07e25faf..92a2a92fb8b 100644
--- a/src/runtime/valkey_jsc/index.rs
+++ b/src/runtime/valkey_jsc/index.rs
@@ -18,7 +18,4 @@ pub use super::valkey::Options;
 pub use super::valkey::Protocol;
 pub use super::valkey::Status;
 pub use super::valkey::ValkeyClient;
-// ValkeyCommand.zig is a file-as-struct; in Rust the module itself is the namespace.
 pub use super::valkey_command as Command;
-
-// ported from: src/runtime/valkey_jsc/index.zig
diff --git a/src/runtime/valkey_jsc/js_valkey.rs b/src/runtime/valkey_jsc/js_valkey.rs
index e49158ec2a3..10061bd594b 100644
--- a/src/runtime/valkey_jsc/js_valkey.rs
+++ b/src/runtime/valkey_jsc/js_valkey.rs
@@ -23,7 +23,7 @@ use bun_jsc::url::URL;
 use bun_valkey::valkey_protocol as protocol;
 
 /// `bun.JSTerminated!T`
-// PORT NOTE: widened to `JsResult<T>` to match `valkey.rs`; narrow once
+// Widened to `JsResult<T>` to match `valkey.rs`; can be narrowed once
 // `ValkeyClient::{fail,on_open,on_close,start}` are tightened to the
 // `jsc::JsTerminatedResult` alias from `bun_jsc::event_loop`.
 type JsTerminatedResult<T> = jsc::JsResult<T>;
@@ -32,8 +32,8 @@ type JsTerminatedResult<T> = jsc::JsResult<T>;
 /// alias) back to the spec'd `bun.JSTerminated!void`. The inner client only
 /// ever propagates `JsError::Terminated` (originating from `JSPromise::reject`
 /// / `resolve`); the other variants are unreachable on this path.
-// PORT NOTE: while `JsTerminatedResult` is widened to `JsResult` (see above),
-// this is effectively identity-with-OOM-crash. Once both aliases tighten to
+// While `JsTerminatedResult` is widened to `JsResult` (see above), this is
+// effectively identity-with-OOM-crash. Once both aliases tighten to
 // `jsc::JsTerminatedResult`, restore the `JsTerminated::JSTerminated` mapping.
 #[inline]
 fn narrow_terminated(r: JsResult<()>) -> JsTerminatedResult<()> {
@@ -58,7 +58,6 @@ fn vm_event_loop_ctx() -> bun_io::EventLoopCtx {
 
 /// Scope-guarded `ref/deref` over a raw pointer — sidesteps the
 /// `scopeguard`-captures-`&self` borrowck conflict that pervades this file.
-/// Mirrors Zig's `defer this.deref()` which had no aliasing restriction.
 // R-2: takes `*const` now that every `JSValkeyClient` method is `&self`;
 // `deref()` (and `ref_()`) already only need a shared receiver.
 #[inline]
@@ -88,10 +87,9 @@ pub struct SubscriptionCtx {
     pub original_enable_auto_pipelining: bool,
 }
 
-/// `jsc.Codegen.JSRedisClient` — the generate-classes.ts output now emits a
+/// The generate-classes.ts output emits a
 /// `js_RedisClient` module with snake-case `*_set_cached`/`*_get_cached`
-/// free-fns plus `to_js`/`from_js`. Re-exported here as `Js` (mirrors Zig's
-/// `pub const js = jsc.Codegen.JSRedisClient`).
+/// free-fns plus `to_js`/`from_js`. Re-exported here as `Js`.
 pub use crate::generated_classes::js_RedisClient as Js;
 
 // SAFETY: `SubscriptionCtx` lives at `JSValkeyClient._subscription_ctx`
@@ -185,8 +183,6 @@ impl SubscriptionCtx {
         }
 
         // Existing is guaranteed to be an array of callbacks.
-        // This check is necessary because crossing between Zig and C++ is necessary because Zig
-        // doesn't know that C++ is side-effect-free.
         if cfg!(debug_assertions) {
             debug_assert!(existing.is_array());
         }
@@ -230,7 +226,6 @@ impl SubscriptionCtx {
         let _guard = scopeguard::guard(parent_br, |p| {
             p.on_new_subscription_callback_insert();
         });
-        // PORT NOTE: Zig `defer` ≡ scopeguard-on-drop here.
         let map = self.subscription_callback_map();
 
         let handlers_array: JSValue;
@@ -335,7 +330,7 @@ impl SubscriptionCtx {
         Ok(self.parent().client.get().flags.finalized || !self.has_subscriptions(global_object)?)
     }
 
-    // PORT NOTE: cannot be Drop — takes global_object param. Exposed as explicit
+    // Cannot be `Drop` — takes a `global_object` param. Exposed as explicit
     // `close` per PORTING.md (never expose `pub fn deinit`).
     pub fn close(&self, global_object: &JSGlobalObject) {
         if cfg!(debug_assertions) {
@@ -358,7 +353,7 @@ impl SubscriptionCtx {
 // ───────────────────────────────────────────────────────────────────────────
 
 /// Valkey client wrapper for JavaScript
-// PORT NOTE: `#[bun_jsc::JsClass]` is hand-rolled in `mod.rs` (the codegen
+// `#[bun_jsc::JsClass]` is hand-rolled in `mod.rs` (the codegen
 // macro's 2-arg `constructor` shim doesn't fit the `js_this` flow here).
 // R-2 (host-fn re-entrancy): every JS-exposed method takes `&self`; per-field
 // interior mutability via `Cell` (Copy) / `JsCell` (non-Copy). The codegen
@@ -367,7 +362,7 @@ impl SubscriptionCtx {
 // `#[repr(transparent)]`, so `from_field_ptr!`/`owner!` recovery (dispatch.rs,
 // `ValkeyClient::parent`) sees identical offsets.
 //
-// `#[repr(C)]`: declared layout must match the Zig original — `client` MUST be
+// `#[repr(C)]`: `client` MUST be
 // at offset 0. `ValkeyClient::parent()` recovers the outer pointer via
 // `from_field_ptr!`, but belt-and-suspenders against any path that assumes
 // `*mut JSValkeyClient` and `*mut ValkeyClient` alias (the socket ext slot did
@@ -463,7 +458,7 @@ impl JSValkeyClient {
     }
 
     // Factory function to create a new Valkey client from JS
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the free-fn shim it emits
+    // No `#[bun_jsc::host_fn]` here — the free-fn shim it emits
     // calls `constructor(...)` unqualified (fails inside `impl`). Codegen
     // wires the constructor via `RedisClientImpl::constructor` (see
     // generated_classes.rs), which passes the freshly-allocated wrapper cell
@@ -501,7 +496,7 @@ impl JSValkeyClient {
         // `defer url_str.deref();` — bun_core::String drops on scope exit.
         let mut fallback_url_buf = [0u8; 2048];
 
-        // Parse and validate the URL using URL.zig's fromString which returns null for invalid URLs
+        // Parse and validate the URL using `URL::from_string`, which returns null for invalid URLs
         // TODO(markovejnovic): The following check for :// is a stop-gap. It is my expectation
         // that URL.fromString returns null if the protocol is not specified. This is not, in-fact,
         // the case right now and I do not understand why. It will take some work in JSC to
@@ -531,8 +526,7 @@ impl JSValkeyClient {
                 use std::io::Write;
                 let mut cursor = &mut fallback_url_buf[..];
                 let start_len = cursor.len();
-                // PORT NOTE: bufPrintZ NUL-terminates; we don't need the NUL here since we
-                // immediately re-parse via fromUTF8.
+                // No NUL terminator needed here — we immediately re-parse via fromUTF8.
                 if write!(&mut cursor, "valkey://").is_err()
                     || cursor.write_all(url_byte_slice).is_err()
                 {
@@ -553,7 +547,7 @@ impl JSValkeyClient {
                 }
             }
         };
-        // SAFETY: `from_utf8` heap-allocates; release on scope exit (Zig: `defer parsed_url.deinit()`).
+        // SAFETY: `from_utf8` heap-allocates; release on scope exit.
         let _parsed_url_drop =
             scopeguard::guard(parsed_url, |p| unsafe { URL::destroy(p.as_ptr()) });
         // `_parsed_url_drop` keeps the heap `URL` live for this scope, so the
@@ -666,9 +660,8 @@ impl JSValkeyClient {
             let pass_sp = b.append_count(password_utf8.slice());
             let host_sp = b.append_count(hostname_slice);
             connection_strings = b.move_to_slice();
-            // PORT NOTE: in Zig these were `&[u8]` slices into
-            // `connection_strings` (self-referential). The Rust `ValkeyClient`
-            // owns each field as `Box<[u8]>`, so re-slice from the pointers.
+            // `ValkeyClient` owns each field as an independent
+            // `Box<[u8]>`, so re-slice from the pointers.
             username = Box::<[u8]>::from(user_sp.slice(&connection_strings));
             password = Box::<[u8]>::from(pass_sp.slice(&connection_strings));
             hostname = Box::<[u8]>::from(host_sp.slice(&connection_strings));
@@ -683,7 +676,7 @@ impl JSValkeyClient {
 
         bun_core::analytics::Features::VALKEY.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
 
-        // PORT NOTE: Zig used `undefined` for _subscription_ctx; initialized later by `create()`.
+        // `_subscription_ctx` is a placeholder here; properly initialized later by `create()`.
         Ok(JSValkeyClient::new(JSValkeyClient {
             ref_count: bun_ptr::RefCount::init(),
             _subscription_ctx: JsCell::new(SubscriptionCtx::default()),
@@ -778,12 +771,11 @@ impl JSValkeyClient {
         let client = self.client.get();
         let sub_ctx = self._subscription_ctx.get();
 
-        // PORT NOTE: in Zig, `username`/`password`/`address.hostname` are sub-slices
-        // into the single `connection_strings` allocation, so the spec dupes
-        // `connection_strings` once and `rebaseSlice`s the sub-slices into the copy.
-        // The Rust `ValkeyClient` (see valkey.rs:290-299) instead owns each field
-        // as an independent `Box<[u8]>`, so the rebase arithmetic would compute a
-        // garbage offset and read OOB. Clone each owned buffer directly.
+        // `ValkeyClient` (see valkey.rs:290-299) owns `username`/`password`/
+        // `address.hostname` as independent `Box<[u8]>`s rather than sub-slices
+        // of the single `connection_strings` allocation, so rebase arithmetic
+        // against `connection_strings` would compute a garbage offset and read
+        // OOB. Clone each owned buffer directly.
         let connection_strings_copy: Box<[u8]> = Box::<[u8]>::from(&client.connection_strings[..]);
         let username: Box<[u8]> = Box::<[u8]>::from(&client.username[..]);
         let password: Box<[u8]> = Box::<[u8]>::from(&client.password[..]);
@@ -931,17 +923,12 @@ impl JSValkeyClient {
     }
 
     pub fn get_or_create_subscription_ctx(&self) -> JsResult<&SubscriptionCtx> {
-        // PORT NOTE: Zig treats _subscription_ctx as Optional here but the field is not
-        // optional in the struct definition above. Original:
-        //   `if (this._subscription_ctx) |*ctx| { return ctx; }`
-        // Preserve the return-existing intent so we don't unconditionally reinit.
+        // Return the existing ctx so we don't unconditionally reinit.
         if self._subscription_ctx.get().is_subscriber {
             return Ok(self._subscription_ctx.get());
         }
 
         // Save the original flag values and create a new subscription context
-        // (Zig passed extra args to SubscriptionCtx.init that don't exist on the fn — preserved
-        // as-is via the standard init.)
         self._subscription_ctx.set(SubscriptionCtx::init(self)?);
 
         // We need to make sure we disable the offline queue, but we actually want to make sure
@@ -1057,7 +1044,7 @@ impl JSValkeyClient {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: `onconnect`/`onclose` are declared with `this: true` in
+    // `onconnect`/`onclose` are declared with `this: true` in
     // valkey.classes.ts, so the codegen thunk passes the JS wrapper cell as
     // `this_value` (between `&self` and `global`). No `host_fn` attribute —
     // the extern "C" shim lives in generated_classes.rs. Setter now returns
@@ -1091,7 +1078,7 @@ impl JSValkeyClient {
             bun_core::TimespecMockMode::AllowMockedTime,
             i64::from(next_timeout_ms),
         );
-        // PORT NOTE: `bun_event_loop::Timespec` is a local stub distinct from
+        // `bun_event_loop::Timespec` is a local stub distinct from
         // `bun_core::Timespec`; convert by fields until they are unified.
         timer.with_mut(|t| {
             t.next = Timer::Timespec {
@@ -1509,8 +1496,7 @@ impl JSValkeyClient {
         struct Holder {
             // BACKREF — JSValkeyClient is intrusively ref-counted (RefCount + @fieldParentPtr
             // recovery in SubscriptionCtx::parent). The `self.ref_()` above / `(*ctx).deref()`
-            // in run() keep it alive across the task hop, exactly as the Zig does.
-            // PORT NOTE: LIFETIMES.tsv lists this as SHARED; update to BACKREF.
+            // in run() keep it alive across the task hop.
             ctx: *const JSValkeyClient,
             task: jsc::AnyTask::AnyTask,
         }
@@ -1585,7 +1571,7 @@ impl JSValkeyClient {
         let _d = deref_guard(self);
 
         let is_tls = self.client.get().tls != valkey::TLS::None;
-        // PORT NOTE: `vm.rare_data()` needs `&mut VirtualMachine`; `client.vm`
+        // `vm.rare_data()` needs `&mut VirtualMachine`; `client.vm`
         // is `&'static`. Cast through raw — the per-thread VM is single-owner
         // on the JS thread, and `valkey_group` only touches the embedded
         // `SocketGroup` field + `vm.uws_loop()` (disjoint from anything we
@@ -1602,8 +1588,6 @@ impl JSValkeyClient {
             }
         };
 
-        // PORT NOTE: reshaped for borrowck — the Zig matched on `self.client.tls`
-        // and called `self.client_fail`/`on_valkey_close` from inside the arm.
         // Populate `_secure` first, then handle the failure branch outside the
         // borrow of `self.client.tls`.
         let tls_ctx_failed = if let valkey::TLS::Custom(ref custom) = self.client.get().tls {
@@ -1663,7 +1647,7 @@ impl JSValkeyClient {
                 (*p).update_poll_ref();
             }
         });
-        // PORT NOTE: the socket ext slot is typed `ExtSlot<JSValkeyClient>`
+        // The socket ext slot is typed `ExtSlot<JSValkeyClient>`
         // (uws_handlers.rs `Valkey<SSL> = NsHandler<JSValkeyClient, …>`); store
         // the OUTER pointer, not the inner `ValkeyClient`, or dispatch will
         // mis-type and re-offset it (`on_open` → `this.client_mut()` adds
@@ -1844,8 +1828,7 @@ impl JSValkeyClient {
     }
 }
 
-// PORT NOTE: Zig's `pub const X = fns.X;` × ~160 binds each command host-fn
-// into the JSValkeyClient namespace. In Rust those are already inherent
+// The ~160 command host-fns are inherent
 // methods on `JSValkeyClient` via the `impl JSValkeyClient` block in
 // `js_valkey_functions.rs`, so no re-export is needed (and `pub use` of impl
 // methods is not legal Rust). Keep `fns` referenced so the sibling module is
@@ -1855,17 +1838,16 @@ impl JSValkeyClient {
 // SocketHandler
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Referenced by `dispatch.zig` (kind = `.valkey[_tls]`).
+/// uWS socket-event handler for the Valkey client (kind = `.valkey[_tls]`).
 pub struct SocketHandler<const SSL: bool>;
 
-// PORT NOTE: Zig `const SocketType = uws.NewSocketHandler(ssl)` is an inherent
-// associated type, which is unstable in Rust. Use a module-level alias instead
+// Inherent associated types are unstable in Rust, so use a module-level alias
 // and refer to it as `SocketType<SSL>` inside the impl.
 type SocketType<const SSL: bool> = uws::NewSocketHandler<SSL>;
 
 impl<const SSL: bool> SocketHandler<SSL> {
     fn _socket(s: SocketType<SSL>) -> Socket {
-        // PORT NOTE: `NewSocketHandler<SSL>` only differs by const generic; the
+        // `NewSocketHandler<SSL>` only differs by const generic; the
         // `socket` field is identical. Re-wrap the inner `InternalSocket` into
         // the right `AnySocket` variant.
         if SSL {
@@ -1950,7 +1932,7 @@ impl<const SSL: bool> SocketHandler<SSL> {
                 }
                 if !hostname.is_empty()
                     // SAFETY: in the TLS handshake-success path the socket's native
-                    // handle is a live `SSL*`; Zig calls `@ptrCast` on it directly.
+                    // handle is a live `SSL*`.
                     && !boringssl::check_server_identity(unsafe { &mut *ssl_ptr }, hostname)
                 {
                     let err = this
@@ -2194,5 +2176,3 @@ impl Options {
         Ok(this)
     }
 }
-
-// ported from: src/runtime/valkey_jsc/js_valkey.zig
diff --git a/src/runtime/valkey_jsc/js_valkey_functions.rs b/src/runtime/valkey_jsc/js_valkey_functions.rs
index f05657ab9bd..5789403e5d6 100644
--- a/src/runtime/valkey_jsc/js_valkey_functions.rs
+++ b/src/runtime/valkey_jsc/js_valkey_functions.rs
@@ -30,7 +30,6 @@ const fn bname(b: &'static [u8]) -> &'static str {
 
 fn require_not_subscriber(this: &JSValkeyClient, function_name: &[u8]) -> JsResult<()> {
     if this.is_subscriber() {
-        // Zig: `this.globalObject.ERR(.REDIS_INVALID_STATE, fmt, .{function_name}).throw()`
         // `global_object: GlobalRef` derefs safely (BACKREF — VM-owned global outlives client).
         let global: &JSGlobalObject = &this.global_object;
         return Err(global
@@ -48,7 +47,6 @@ fn require_not_subscriber(this: &JSValkeyClient, function_name: &[u8]) -> JsResu
 
 fn require_subscriber(this: &JSValkeyClient, function_name: &[u8]) -> JsResult<()> {
     if !this.is_subscriber() {
-        // Zig: `this.globalObject.ERR(.REDIS_INVALID_STATE, fmt, .{function_name}).throw()`
         // `global_object: GlobalRef` derefs safely (BACKREF — VM-owned global outlives client).
         let global: &JSGlobalObject = &this.global_object;
         return Err(global
@@ -80,7 +78,7 @@ fn from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<Option<JSArgumen
 
 /// Shim around `protocol::valkey_error_to_js` that:
 /// 1. accepts whatever error type `JSValkeyClient::send` currently returns
-///    (presently `bun_core::Error`; the Zig spec uses an open `!` set) and
+///    (presently `bun_core::Error`) and
 ///    converts it to `RedisError` so the user-visible error code matches the
 ///    real failure variant, and
 /// 2. wraps the resulting `JSValue` in `Ok` for use in `JsResult<JSValue>`
@@ -135,7 +133,7 @@ fn send_cmd(
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// compile: comptime command generators
+// compile: command generators
 // ──────────────────────────────────────────────────────────────────────────
 
 pub(crate) mod compile {
@@ -162,16 +160,14 @@ pub(crate) mod compile {
     }
 }
 
-// PORT NOTE: The Zig `compile.@"(...)"(...)` comptime type-generators take
-// `comptime []const u8` params (not expressible as Rust const generics on
-// stable). Each generator is ported as a `macro_rules!` that emits a
-// `#[bun_jsc::host_fn(method)]` inside the `impl JSValkeyClient` block.
-// Names: @"()"→cmd_noargs!, @"(key: RedisKey)"→cmd_key!,
-// @"(key: RedisKey, ...args: RedisKey[])"→cmd_key_varargs!,
-// @"(key: RedisKey, value: RedisValue)"→cmd_key_value!,
-// @"(key: RedisKey, value: RedisValue, value2: RedisValue)"→cmd_key_value_value2!,
-// @"(...strings: string[])"→cmd_strings_varargs!,
-// @"(key: RedisKey, value: RedisValue, ...args: RedisValue)"→cmd_key_value_varargs!
+// Note: each command-shape generator is a `macro_rules!` that emits a
+// `#[bun_jsc::host_fn(method)]` inside the `impl JSValkeyClient` block:
+// cmd_noargs! (), cmd_key! (key: RedisKey),
+// cmd_key_varargs! (key: RedisKey, ...args: RedisKey[]),
+// cmd_key_value! (key: RedisKey, value: RedisValue),
+// cmd_key_value_value2! (key: RedisKey, value: RedisValue, value2: RedisValue),
+// cmd_strings_varargs! (...strings: string[]),
+// cmd_key_value_varargs! (key: RedisKey, value: RedisValue, ...args: RedisValue)
 
 macro_rules! cmd_noargs {
     ($fn_name:ident, $name:literal, $command:literal, $state:ident) => {
@@ -445,7 +441,6 @@ macro_rules! cmd_key_value_varargs {
 impl JSValkeyClient {
     #[bun_jsc::host_fn(method)]
     pub fn js_send(this: &Self, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-        // Zig: `defer command.deref()`.
         let command = OwnedString::new(frame.argument(0).to_bun_string(global)?);
 
         let args_array = frame.argument(1);
@@ -456,7 +451,6 @@ impl JSValkeyClient {
         let mut args: Vec<JSArgument> = Vec::with_capacity(iter.len as usize);
 
         while let Some(arg_js) = iter.next()? {
-            // PERF(port): was assume_capacity
             let Some(v) = from_js(global, arg_js)? else {
                 return Err(global.throw_invalid_argument_type(
                     "sendCommand",
@@ -473,7 +467,7 @@ impl JSValkeyClient {
             args: CommandArgs::Args(&args),
             meta: CommandMeta::default(),
         };
-        // PORT NOTE: reshaped for borrowck (cmd.meta = cmd.meta.check(&cmd))
+        // Note: reshaped for borrowck (cmd.meta = cmd.meta.check(&cmd))
         let checked_meta = cmd.meta.check(&cmd);
         cmd.meta = checked_meta;
         // Send command with slices directly
@@ -531,13 +525,11 @@ impl JSValkeyClient {
         require_not_subscriber(this, b"set")?;
 
         let args_view = frame.arguments();
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
             return Err(global.throw_invalid_argument_type("set", "key", "string or buffer"));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         let Some(value) = from_js(global, frame.argument(1))? else {
@@ -547,7 +539,6 @@ impl JSValkeyClient {
                 "string or buffer or number",
             ));
         };
-        // PERF(port): was assume_capacity
         args.push(value);
 
         if args_view.len() > 2 {
@@ -555,7 +546,6 @@ impl JSValkeyClient {
                 if arg.is_undefined_or_null() {
                     break;
                 }
-                // PERF(port): was assume_capacity
                 let Some(v) = from_js(global, *arg)? else {
                     return Err(global.throw_invalid_argument_type(
                         "set",
@@ -694,13 +684,11 @@ impl JSValkeyClient {
             return Err(global.throw(format_args!("SREM requires at least a key and one member")));
         }
 
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
             return Err(global.throw_invalid_argument_type("srem", "key", "string or buffer"));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         for arg in &args_view[1..] {
@@ -714,7 +702,6 @@ impl JSValkeyClient {
                     "string or buffer",
                 ));
             };
-            // PERF(port): was assume_capacity
             args.push(value);
         }
         send_cmd(
@@ -738,7 +725,6 @@ impl JSValkeyClient {
         require_not_subscriber(this, b"srandmember")?;
 
         let args_view = frame.arguments();
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
@@ -748,7 +734,6 @@ impl JSValkeyClient {
                 "string or buffer",
             ));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         // Optional count argument
@@ -760,7 +745,6 @@ impl JSValkeyClient {
                     "number or string",
                 ));
             };
-            // PERF(port): was assume_capacity
             args.push(count_arg);
         }
         send_cmd(
@@ -799,13 +783,11 @@ impl JSValkeyClient {
         require_not_subscriber(this, b"spop")?;
 
         let args_view = frame.arguments();
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
             return Err(global.throw_invalid_argument_type("spop", "key", "string or buffer"));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         // Optional count argument
@@ -817,7 +799,6 @@ impl JSValkeyClient {
                     "number or string",
                 ));
             };
-            // PERF(port): was assume_capacity
             args.push(count_arg);
         }
         send_cmd(
@@ -841,13 +822,11 @@ impl JSValkeyClient {
             return Err(global.throw(format_args!("SADD requires at least a key and one member")));
         }
 
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
             return Err(global.throw_invalid_argument_type("sadd", "key", "string or buffer"));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         for arg in &args_view[1..] {
@@ -861,7 +840,6 @@ impl JSValkeyClient {
                     "string or buffer",
                 ));
             };
-            // PERF(port): was assume_capacity
             args.push(value);
         }
         send_cmd(
@@ -911,13 +889,11 @@ impl JSValkeyClient {
             return Err(global.throw(format_args!("HMGET requires at least a key and one field")));
         }
 
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let Some(key) = from_js(global, frame.argument(0))? else {
             return Err(global.throw_invalid_argument_type("hmget", "key", "string or buffer"));
         };
-        // PERF(port): was assume_capacity
         args.push(key);
 
         let second_arg = frame.argument(1);
@@ -970,7 +946,6 @@ impl JSValkeyClient {
     pub fn hincrby(this: &Self, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         require_not_subscriber(this, b"hincrby")?;
 
-        // Zig: `defer key.deref()` / `defer field.deref()` / `defer value.deref()`.
         let key = OwnedString::new(frame.argument(0).to_bun_string(global)?);
         let field = OwnedString::new(frame.argument(1).to_bun_string(global)?);
         let value = OwnedString::new(frame.argument(2).to_bun_string(global)?);
@@ -999,7 +974,6 @@ impl JSValkeyClient {
     ) -> JsResult<JSValue> {
         require_not_subscriber(this, b"hincrbyfloat")?;
 
-        // Zig: `defer key.deref()` / `defer field.deref()` / `defer value.deref()`.
         let key = OwnedString::new(frame.argument(0).to_bun_string(global)?);
         let field = OwnedString::new(frame.argument(1).to_bun_string(global)?);
         let value = OwnedString::new(frame.argument(2).to_bun_string(global)?);
@@ -1019,7 +993,6 @@ impl JSValkeyClient {
         )
     }
 
-    // PERF(port): `command` was a comptime []const u8 — demoted to runtime &'static [u8]
     fn hset_impl(
         this: &Self,
         global: &JSGlobalObject,
@@ -1028,7 +1001,6 @@ impl JSValkeyClient {
     ) -> JsResult<JSValue> {
         require_not_subscriber(this, command)?;
 
-        // Zig: `defer key.deref()`.
         let key = OwnedString::new(frame.argument(0).to_bun_string(global)?);
 
         let second_arg = frame.argument(1);
@@ -1040,12 +1012,7 @@ impl JSValkeyClient {
         if second_arg.is_object() && !second_arg.is_array() {
             // Pattern 1: Object/Record - hset(key, {field: value, ...})
             let Some(obj) = second_arg.get_object() else {
-                return Err(global.throw_invalid_argument_type(
-                    // TODO(port): command is bytes; throw_invalid_argument_type expects &str
-                    bname(command),
-                    "fields",
-                    "object",
-                ));
+                return Err(global.throw_invalid_argument_type(bname(command), "fields", "object"));
             };
 
             let mut object_iter = JSPropertyIterator::init(
@@ -1061,13 +1028,11 @@ impl JSValkeyClient {
 
             while let Some(field_name) = object_iter.next()? {
                 let field_slice = field_name.to_utf8();
-                // PERF(port): was assume_capacity
                 args.push(field_slice);
 
                 let value_str = object_iter.value.to_bun_string(global)?;
-                // PERF(port): was assume_capacity
                 args.push(value_str.to_utf8());
-                // Zig: `defer value_str.deref()` — `to_utf8()` already bumped
+                // `to_utf8()` already bumped
                 // (or copied) the ref the slice needs, so release ours now.
                 value_str.deref();
             }
@@ -1084,7 +1049,6 @@ impl JSValkeyClient {
 
             while let Some(field_js) = iter.next()? {
                 let field_str = field_js.to_bun_string(global)?;
-                // PERF(port): was assume_capacity
                 args.push(field_str.to_utf8());
                 field_str.deref();
 
@@ -1094,7 +1058,6 @@ impl JSValkeyClient {
                     )));
                 };
                 let value_str = value_js.to_bun_string(global)?;
-                // PERF(port): was assume_capacity
                 args.push(value_str.to_utf8());
                 value_str.deref();
             }
@@ -1119,7 +1082,6 @@ impl JSValkeyClient {
             let mut i: u32 = 1;
             while i < args_count {
                 let arg_str = frame.argument(i as usize).to_bun_string(global)?;
-                // PERF(port): was assume_capacity
                 args.push(arg_str.to_utf8());
                 arg_str.deref();
                 i += 1;
@@ -1227,7 +1189,6 @@ impl JSValkeyClient {
     // Implement ping (send a PING command with an optional message)
     #[bun_jsc::host_fn(method)]
     pub fn ping(this: &Self, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-        // PORT NOTE: reshaped from Zig stack-array + slice pattern to Option<JSArgument>
         let message: Option<JSArgument> = if !frame.argument(0).is_undefined_or_null() {
             // Only use the first argument if provided, ignore any additional arguments
             let Some(m) = from_js(global, frame.argument(0))? else {
@@ -1655,7 +1616,6 @@ impl JSValkeyClient {
         require_not_subscriber(this, b"publish")?;
 
         let args_view = frame.arguments();
-        // PERF(port): was stack-fallback
         let mut args: Vec<JSArgument> = Vec::with_capacity(args_view.len());
 
         let arg0 = frame.argument(0);
@@ -1664,7 +1624,6 @@ impl JSValkeyClient {
         }
         let channel = from_js(global, arg0)?.expect("unreachable");
 
-        // PERF(port): was assume_capacity
         args.push(channel);
 
         let arg1 = frame.argument(1);
@@ -1672,7 +1631,6 @@ impl JSValkeyClient {
             return Err(global.throw_invalid_argument_type("publish", "message", "string"));
         }
         let message = from_js(global, arg1)?.expect("unreachable");
-        // PERF(port): was assume_capacity
         args.push(message);
         send_cmd(
             this,
@@ -1688,7 +1646,6 @@ impl JSValkeyClient {
     #[bun_jsc::host_fn(method)]
     pub fn subscribe(this: &Self, global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         let [channel_or_many, handler_callback] = frame.arguments_as_array::<2>();
-        // PERF(port): was stack-fallback
         let mut redis_channels: Vec<JSArgument> = Vec::with_capacity(1);
 
         if !handler_callback.is_callable() {
@@ -1713,15 +1670,14 @@ impl JSValkeyClient {
                         "string",
                     ));
                 };
-                // PERF(port): was assume_capacity
                 redis_channels.push(channel);
 
                 // What we do here is add our receive handler. Notice that this doesn't really do anything until the
                 // "SUBSCRIBE" command is sent to redis and we get a response.
                 //
-                // TODO(markovejnovic): This is less-than-ideal, still, because this assumes a happy path. What happens if
-                //                      the SUBSCRIBE command fails? We have no way to roll back the addition of the
-                //                      handler.
+                // This is less-than-ideal, still, because this assumes a happy path. What happens if
+                // the SUBSCRIBE command fails? We have no way to roll back the addition of the
+                // handler.
                 this._subscription_ctx.get().upsert_receive_handler(
                     global,
                     channel_arg,
@@ -1733,7 +1689,6 @@ impl JSValkeyClient {
             let Some(channel) = from_js(global, channel_or_many)? else {
                 return Err(global.throw_invalid_argument_type("subscribe", "channel", "string"));
             };
-            // PERF(port): was assume_capacity
             redis_channels.push(channel);
 
             this._subscription_ctx.get().upsert_receive_handler(
@@ -1777,7 +1732,6 @@ impl JSValkeyClient {
         global: &JSGlobalObject,
         redis_channels: &[JSArgument],
     ) -> JsResult<JSValue> {
-        // TODO(port): narrow error set
         send_cmd(
             this,
             global,
@@ -1800,7 +1754,6 @@ impl JSValkeyClient {
 
         let args_view = frame.arguments();
 
-        // PERF(port): was stack-fallback
         let mut redis_channels: Vec<JSArgument> = Vec::with_capacity(1);
 
         // If no arguments, unsubscribe from all channels
@@ -1850,7 +1803,6 @@ impl JSValkeyClient {
             // unsubscribe from. This s important since this list is used to send
             // the UNSUBSCRIBE command to redis. Without this, we would end up
             // unsubscribing from all channels.
-            // PERF(port): was assume_capacity
             let Some(ch) = from_js(global, channel)? else {
                 return Err(global.throw_invalid_argument_type("unsubscribe", "channel", "string"));
             };
@@ -1917,7 +1869,6 @@ impl JSValkeyClient {
                         "string",
                     ));
                 };
-                // PERF(port): was assume_capacity
                 redis_channels.push(channel);
                 // Clear the handlers for this channel
                 this._subscription_ctx
@@ -1929,7 +1880,6 @@ impl JSValkeyClient {
             let Some(channel) = from_js(global, channel_or_many)? else {
                 return Err(global.throw_invalid_argument_type("unsubscribe", "channel", "string"));
             };
-            // PERF(port): was assume_capacity
             redis_channels.push(channel);
             // Clear the handlers for this channel
             this._subscription_ctx
@@ -1988,5 +1938,3 @@ impl JSValkeyClient {
 
     // cluster(subcommand: "KEYSLOT", key: RedisKey)
 }
-
-// ported from: src/runtime/valkey_jsc/js_valkey_functions.zig
diff --git a/src/runtime/valkey_jsc/mod.rs b/src/runtime/valkey_jsc/mod.rs
index ebf11c31762..8b9bae0480e 100644
--- a/src/runtime/valkey_jsc/mod.rs
+++ b/src/runtime/valkey_jsc/mod.rs
@@ -1,6 +1,6 @@
 //! Valkey/Redis client — JSC bindings.
 //!
-//! Module layout mirrors `src/runtime/valkey_jsc/index.zig`: the protocol
+//! Module layout: the protocol
 //! state machine lives in [`valkey`] (`ValkeyClient`), the `.classes.ts`
 //! wrapper in [`js_valkey`] (`JSValkeyClient`), and the ~200 prototype
 //! methods in [`js_valkey_functions`]. RESP wire-format parsing is in the
@@ -47,10 +47,10 @@ pub use valkey::{Options, Protocol, Status, ValkeyClient};
 pub use valkey_context::ValkeyContext;
 
 // ── ValkeyCommand ────────────────────────────────────────────────────────────
-// Zig's `ValkeyCommand.zig` is a file-as-struct: it is both the namespace
+// `ValkeyCommand` is both a namespace
 // *and* the `Command` type. Expose a `valkey_command` module that re-exports
 // the body's items so `command::PromisePair` / `command::Entry` resolve, and
-// alias it as `ValkeyCommand` for callers that match the Zig spelling.
+// alias it as `ValkeyCommand` for callers that use that spelling.
 pub mod valkey_command {
     pub use super::valkey_command_body::{Entry, Meta, Promise, PromisePair, entry, promise_pair};
     // `index.rs` re-exports `super::valkey_command::ValkeyCommand`.
diff --git a/src/runtime/valkey_jsc/protocol_jsc.rs b/src/runtime/valkey_jsc/protocol_jsc.rs
index 9cc5c806935..a26a981fd16 100644
--- a/src/runtime/valkey_jsc/protocol_jsc.rs
+++ b/src/runtime/valkey_jsc/protocol_jsc.rs
@@ -1,4 +1,4 @@
-//! `to_js` bridges for the RESP protocol types in `valkey/valkey_protocol.zig`.
+//! `to_js` bridges for the RESP protocol types.
 //! The protocol parser, `RESPValue` union, and `ValkeyReader` stay in
 //! `valkey/`; only the `JSGlobalObject`/`JSValue`-touching conversions live
 //! here so `valkey/` is JSC-free.
@@ -8,8 +8,7 @@ use bun_valkey::valkey_protocol::{RESPValue, RedisError};
 
 // keep `protocol` referenced for sibling drafts
 
-/// Zig: `valkeyErrorToJS(global, message: ?[]const u8, err)`.
-/// All Rust callers always provide a message (never `None`), so the parameter
+/// All callers always provide a message, so the parameter
 /// is `impl AsRef<[u8]>` to accept `&str`, `&[u8]`, `&[u8; N]`, `&Box<[u8]>`
 /// uniformly without forcing `Some(..)` at every call site.
 pub fn valkey_error_to_js(
@@ -130,8 +129,7 @@ pub fn resp_value_to_js_with_options(
             for entry in entries.iter_mut() {
                 let js_key =
                     resp_value_to_js_with_options(&mut entry.key, global, ToJSOptions::default())?;
-                // Zig: `js_obj.putMayBeIndex(global, &key_str, value)` — no Rust binding yet,
-                // so route through `put_to_property_key` which performs the same
+                // Route through `put_to_property_key`, which performs
                 // index-vs-string property dispatch on the JSValue key.
                 let _ = js_key.to_bun_string(global)?; // preserve toString side-effect/exception path
                 let js_value = resp_value_to_js_with_options(&mut entry.value, global, options)?;
@@ -175,5 +173,3 @@ pub fn resp_value_to_js_with_options(
         }
     }
 }
-
-// ported from: src/runtime/valkey_jsc/protocol_jsc.zig
diff --git a/src/runtime/valkey_jsc/valkey.rs b/src/runtime/valkey_jsc/valkey.rs
index 214b8a18b79..ee38d918fdb 100644
--- a/src/runtime/valkey_jsc/valkey.rs
+++ b/src/runtime/valkey_jsc/valkey.rs
@@ -25,17 +25,14 @@ pub use super::valkey_context as ValkeyContext;
 /// spelling here so the generated `pub use` and prototype thunks resolve.
 pub use super::js_valkey_body::JSValkeyClient as RedisClient;
 
-// TODO(port): narrow error set — Zig `bun.JSTerminated!T` is `error{ Terminated }!T`.
-// Currently uses JsResult<T> (Thrown | OutOfMemory | Terminated).
 type JsTerminated<T> = bun_jsc::JsResult<T>;
 
 bun_output::define_scoped_log!(debug, Redis, visible);
 
 /// Connection flags to track Valkey client state
 pub struct ConnectionFlags {
-    // TODO(markovejnovic): I am not a huge fan of these flags. I would
-    // consider refactoring them into an enumerated state machine, as that
-    // feels significantly more natural compared to a bag of booleans.
+    // These flags could be refactored into an enumerated state machine, which
+    // would read more naturally than a bag of booleans.
     pub is_authenticated: bool,
     pub is_manually_closed: bool,
     pub is_selecting_db_internal: bool,
@@ -92,9 +89,6 @@ impl Status {
 }
 
 pub use super::valkey_command_body as Command_;
-// PORT NOTE: Zig `pub const Command = @import("./ValkeyCommand.zig");` re-exports the module
-// AND uses `Command` as the struct type (file-as-struct). In Rust the type lives at
-// `super::valkey_command_body::Command`.
 
 /// Valkey protocol types (standalone, TLS, Unix socket)
 #[derive(Copy, Clone, Eq, PartialEq)]
@@ -106,7 +100,7 @@ pub enum Protocol {
 }
 
 impl Protocol {
-    // PORT NOTE: `static` items are not allowed in `impl` blocks; phf maps are
+    // Note: `static` items are not allowed in `impl` blocks; phf maps are
     // const-constructible, so this is an associated const (still `Protocol::MAP`).
     pub const MAP: phf::Map<&'static [u8], Protocol> = phf::phf_map! {
         b"valkey" => Protocol::Standalone,
@@ -139,9 +133,6 @@ pub enum TLS {
 }
 
 impl TLS {
-    // PORT NOTE: Zig `deinit` only called `ssl_config.deinit()`. SSLConfig should impl Drop,
-    // making this enum's Drop automatic. (No explicit Drop impl needed if SSLConfig: Drop.)
-
     pub(crate) fn reject_unauthorized(&self, vm: &VirtualMachine) -> bool {
         match self {
             TLS::Custom(ssl_config) => ssl_config.reject_unauthorized != 0,
@@ -152,8 +143,7 @@ impl TLS {
 }
 
 // Call sites only ever compare against `TLS::None` / `TLS::Enabled`; `SSLConfig`
-// doesn't (and shouldn't) implement `PartialEq`, so compare by discriminant —
-// matches Zig's tagged-union `==` semantics for tag checks.
+// doesn't (and shouldn't) implement `PartialEq`, so compare by discriminant.
 impl PartialEq for TLS {
     fn eq(&self, other: &Self) -> bool {
         core::mem::discriminant(self) == core::mem::discriminant(other)
@@ -189,8 +179,6 @@ impl Default for Options {
 }
 
 pub enum Address {
-    // TODO(port): in Zig these slices borrow from `ValkeyClient.connection_strings`
-    // (self-referential). Uses owned Box<[u8]> instead; revisit if it shows up as hot.
     Unix(Box<[u8]>),
     Host { host: Box<[u8]>, port: u16 },
 }
@@ -203,7 +191,7 @@ impl Address {
         }
     }
 
-    /// Spec valkey.zig `Address.connect` — open a TCP/TLS/Unix socket via
+    /// Open a TCP/TLS/Unix socket via
     /// `uws::Socket{TLS,TCP}::connect_*_group`.
     ///
     /// `Owner` is the userdata pointer stashed in the socket ext (the
@@ -217,10 +205,6 @@ impl Address {
         ssl_ctx: Option<*mut SslCtx>,
         is_tls: bool,
     ) -> Result<AnySocket, bun_core::Error> {
-        // TODO(port): narrow error set
-        // PORT NOTE: Zig used `switch (is_tls) { inline else => |tls| ... }` to comptime-dispatch
-        // SocketTLS vs SocketTCP. Expanded to runtime if/else.
-        // PERF(port): was comptime bool dispatch — profile if hot
         if is_tls {
             let kind = SocketKind::ValkeyTls;
             let sock = match self {
@@ -277,9 +261,8 @@ pub struct ValkeyClient {
     pub queue: command::entry::Queue,
 
     // Connection parameters
-    // TODO(port): in Zig, password/username/address.hostname are views into `connection_strings`
-    // (self-referential). Uses owned Box<[u8]> instead; `connection_strings` retained for
-    // structural parity but may be redundant.
+    // `connection_strings` is retained because `js_valkey.rs` still slices it
+    // when constructing/duplicating clients.
     pub password: Box<[u8]>,
     pub username: Box<[u8]>,
     pub database: u32,
@@ -298,7 +281,6 @@ pub struct ValkeyClient {
     pub max_retries: u32, // Maximum retry attempts
 
     pub flags: ConnectionFlags,
-    // PORT NOTE: `std.mem.Allocator param` deleted (non-AST crate; global mimalloc).
 
     // Auto-pipelining
     pub auto_flusher: AutoFlusher,
@@ -322,7 +304,6 @@ pub(crate) struct DeferredFailure {
 
 impl DeferredFailure {
     pub(crate) fn run(self) -> JsTerminated<()> {
-        // PORT NOTE: Zig `defer { free(message); destroy(this) }` — both handled by Box<Self> drop.
         debug!("running deferred failure");
         let mut this = self;
         let err = valkey_error_to_js(&this.global_this, &*this.message, this.err);
@@ -336,10 +317,7 @@ impl DeferredFailure {
 
     pub(crate) fn enqueue(self: Box<Self>) {
         debug!("enqueueing deferred failure");
-        // PORT NOTE: Zig `jsc.ManagedTask.New(DeferredFailure, run).init(this)` collapses to
-        // `ManagedTask::new(ptr, cb)` per src/event_loop/ManagedTask.rs. The Box is leaked into
-        // a raw pointer here and reconstituted inside the trampoline (mirrors Zig's
-        // `default_allocator.create`/`destroy` pair).
+        // The Box is leaked into a raw pointer here and reconstituted inside the trampoline.
         fn run_raw(ptr: *mut DeferredFailure) -> bun_event_loop::JsResult<()> {
             // SAFETY: `ptr` was produced by `heap::alloc` below; we are the sole owner.
             let this = unsafe { bun_core::heap::take(ptr) };
@@ -353,8 +331,7 @@ impl DeferredFailure {
     }
 }
 
-/// Read the parser's current byte offset. Mirrors direct `reader.pos` field
-/// access in the Zig implementation (Zig struct fields are public).
+/// Read the parser's current byte offset.
 #[inline]
 fn reader_pos(reader: &protocol::ValkeyReader<'_>) -> usize {
     reader.pos()
@@ -368,9 +345,7 @@ bun_core::impl_field_parent! { ValkeyClient => JSValkeyClient.client; fn parent;
 
 impl ValkeyClient {
     /// Clean up resources used by the Valkey client
-    // TODO(port): cannot be `Drop` — takes a JSGlobalObject param and has JS side effects.
-    // Renamed from Zig `deinit` per PORTING.md (never expose `pub fn deinit(&mut self)`).
-    // TODO(refactor): decide whether this becomes `finalize()` for the .classes.ts payload.
+    // Cannot be `Drop` — takes a JSGlobalObject param and has JS side effects.
     pub fn shutdown(&mut self, global_object_or_finalizing: Option<&JSGlobalObject>) {
         let mut pending =
             core::mem::replace(&mut self.in_flight, command::promise_pair::Queue::init());
@@ -383,32 +358,33 @@ impl ValkeyClient {
                 RedisError::ConnectionClosed,
             );
             while let Some(mut pair) = pending.read_item() {
-                let _ = pair.reject_command(global_this, object); // TODO: properly propagate exception upwards
+                // Any exception from the reject is swallowed so
+                // every remaining pending command still gets rejected at shutdown.
+                let _ = pair.reject_command(global_this, object);
             }
 
             while let Some(mut offline_cmd) = commands.read_item() {
-                let _ = offline_cmd.promise.reject(global_this, Ok(object)); // TODO: properly propagate exception upwards
-                // PORT NOTE: `offline_cmd.deinit()` — Entry/Box<[u8]> drops automatically.
+                // Same as above: swallow reject exceptions so the whole queue drains.
+                let _ = offline_cmd.promise.reject(global_this, Ok(object));
+                // Note: `offline_cmd.deinit()` — Entry/Box<[u8]> drops automatically.
             }
         } else {
             // finalizing. we can't call into JS.
             while let Some(pair) = pending.read_item() {
-                // PORT NOTE: `pair.promise.deinit()` — JSPromiseStrong drops automatically.
+                // Note: `pair.promise.deinit()` — JSPromiseStrong drops automatically.
                 drop(pair);
             }
 
             while let Some(offline_cmd) = commands.read_item() {
-                // PORT NOTE: `offline_cmd.promise.deinit()` / `offline_cmd.deinit()` —
+                // Note: `offline_cmd.promise.deinit()` / `offline_cmd.deinit()` —
                 // JSPromiseStrong / Box<[u8]> drop automatically.
                 drop(offline_cmd);
             }
         }
 
-        // PORT NOTE: `allocator.free(connection_strings)` and `write_buffer/read_buffer.deinit()`
+        // Note: `allocator.free(connection_strings)` and `write_buffer/read_buffer.deinit()`
         // and `tls.deinit()` are handled by Drop on the owning fields. Only the side-effecting
         // unregister remains explicit.
-        // Note there is no need to deallocate username, password and hostname since they are
-        // within the connection_strings buffer (in Zig; see TODO on field decls).
         drop(pending);
         drop(commands);
         self.unregister_auto_flusher();
@@ -438,14 +414,11 @@ impl ValkeyClient {
         }
 
         self.ref_();
-        // TODO(port): errdefer/defer pattern — `ref/deref` reshaped without scopeguard to
-        // satisfy borrowck (closure would alias `&mut self`). Could revisit with a raw-ptr guard.
 
         // Start draining the command queue
         let mut total_bytelength: usize = 0;
 
-        // PORT NOTE: reshaped for borrowck — Zig held `to_process` slice while mutating
-        // `in_flight`. We compute the count first, then drain by `read_item`.
+        // We compute the count first, then drain by `read_item`.
         let pipelineable_count: usize = {
             let to_process = self.queue.readable_slice(0);
             let mut total: usize = 0;
@@ -477,7 +450,7 @@ impl ValkeyClient {
                 .write(&cmd.serialized_data)
                 .unwrap_or_oom();
             // Free the serialized data since we've copied it to the write buffer
-            // PORT NOTE: `allocator.free(command.serialized_data)` — Box<[u8]> drops here.
+            // Note: `allocator.free(command.serialized_data)` — Box<[u8]> drops here.
         }
 
         let _ = self.flush_data();
@@ -544,7 +517,7 @@ impl ValkeyClient {
     ) -> JsTerminated<()> {
         let mut pending = core::mem::replace(pending_ptr, command::promise_pair::Queue::init());
         let mut entries = core::mem::replace(entries_ptr, command::entry::Queue::init());
-        // PORT NOTE: `defer pending.deinit()` / `defer entries.deinit()` — handled by Drop.
+        // Note: `defer pending.deinit()` / `defer entries.deinit()` — handled by Drop.
 
         // Reject commands in the command queue
         while let Some(mut command_pair) = pending.read_item() {
@@ -553,7 +526,7 @@ impl ValkeyClient {
 
         // Reject commands in the offline queue
         while let Some(mut cmd) = entries.read_item() {
-            // PORT NOTE: `defer cmd.deinit(allocator)` — Entry should impl Drop.
+            // Note: `defer cmd.deinit(allocator)` — Entry should impl Drop.
             cmd.promise.reject(global_this, Ok(jsvalue))?;
         }
         Ok(())
@@ -800,7 +773,7 @@ impl ValkeyClient {
                         return Ok(());
                     }
                 };
-                // PORT NOTE: `defer value.deinit(allocator)` — RESPValue should impl Drop.
+                // Note: `defer value.deinit(allocator)` — RESPValue should impl Drop.
 
                 let bytes_consumed = reader_pos(&reader) - before_read_pos;
                 if bytes_consumed == 0 && !remaining_buffer.is_empty() {
@@ -815,8 +788,6 @@ impl ValkeyClient {
                 self.reply_scanner.reset();
 
                 let mut value_to_handle = value; // Use temp var for defer
-                // TODO(port): narrow error set — Zig caller passes err to fail() which takes RedisError;
-                // `handle_response` now returns JsResult<()> so propagate directly.
                 self.handle_response(&mut value_to_handle)?;
 
                 if self.status == Status::Disconnected || self.flags.failed {
@@ -859,7 +830,7 @@ impl ValkeyClient {
                 }
             };
             // Successfully read a full message from the stack data
-            // PORT NOTE: `defer value.deinit(allocator)` — RESPValue should impl Drop.
+            // Note: `defer value.deinit(allocator)` — RESPValue should impl Drop.
 
             let bytes_consumed = reader_pos(&reader) - before_read_pos;
             if bytes_consumed == 0 {
@@ -876,7 +847,6 @@ impl ValkeyClient {
 
             // Handle the successfully parsed response
             let mut value_to_handle = value; // Use temp var for defer
-            // TODO(port): narrow error set — see buffer-path note above.
             self.handle_response(&mut value_to_handle)?;
 
             // Check connection status after handling
@@ -1047,9 +1017,6 @@ impl ValkeyClient {
 
     /// Handle Valkey protocol response
     fn handle_response(&mut self, value: &mut RESPValue) -> JsTerminated<()> {
-        // TODO(port): narrow error set — Zig return type was `!void` (inferred); body mixes
-        // JsError/JSTerminated (from `fail`/`handle_subscribe_response`). Unified to JsResult<()>;
-        // callers no longer wrap in `fail()` (see on_data).
         // Special handling for the initial HELLO response
         if !self.flags.is_authenticated {
             self.handle_hello_response(value)?;
@@ -1123,7 +1090,6 @@ impl ValkeyClient {
         // The reaosn we consume pairs is that a SUBSCRIBE message may actually be followed by a number of SUBSCRIBE
         // responses which indicate all the channels we have connected to. As a stop-gap, we currently ignore the
         // actual of content of the SUBSCRIBE responses and just resolve the first one with the count of channels.
-        // TODO(markovejnovic): Do better.
         if should_consume_promise_pair {
             pair_maybe = self.in_flight.read_item();
         }
@@ -1330,7 +1296,7 @@ impl ValkeyClient {
 
         if self.connection_ready() && self.write_buffer.remaining().is_empty() {
             // Optimization: avoid cloning the data an extra time.
-            // PORT NOTE: `defer allocator.free(data)` — `data: Box<[u8]>` drops at scope end.
+            // Note: `defer allocator.free(data)` — `data: Box<[u8]>` drops at scope end.
 
             let wrote = self.socket.write(&data);
             let unwritten = &data[usize::try_from(wrote.max(0)).expect("int cast")..];
@@ -1345,15 +1311,13 @@ impl ValkeyClient {
 
         // Write the pre-serialized data directly to the output buffer
         let _ = self.write(&data).unwrap_or_oom();
-        // PORT NOTE: `bun.default_allocator.free(data)` — Box<[u8]> drops here.
+        // Note: `bun.default_allocator.free(data)` — Box<[u8]> drops here.
 
         true
     }
 
     pub fn on_writable(&mut self) {
         self.ref_();
-        // TODO(port): borrowck — scopeguard capturing `&mut self` aliases `send_next_command`.
-        // Reshaped to plain ref/deref bracketing; could use a raw-ptr guard instead.
         self.send_next_command();
         self.deref();
     }
@@ -1363,7 +1327,6 @@ impl ValkeyClient {
         command: &Command,
         mut promise: command::Promise,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let can_pipeline = command
             .meta
             .contains(command::Meta::SUPPORTS_AUTO_PIPELINING)
@@ -1428,7 +1391,6 @@ impl ValkeyClient {
         global_this: &JSGlobalObject,
         command: &Command,
     ) -> Result<*mut JSPromise, bun_core::Error> {
-        // TODO(port): narrow error set
         // FIX: Check meta before using it for routing decisions
         let mut checked_command = *command;
         checked_command.meta = command.meta.check(command);
@@ -1497,9 +1459,7 @@ impl ValkeyClient {
     }
 
     /// Get a writer for the connected socket
-    // TODO(port): Zig returned `std.Io.GenericWriter(*ValkeyClient, RedisError, write)`.
-    // In Rust, ValkeyClient itself can serve as the writer (see `write` below). TODO(refactor):
-    // decide whether to impl `bun_io::Write` directly or return a thin wrapper.
+    // ValkeyClient itself serves as the writer (see `write` below).
     pub fn writer(&mut self) -> &mut Self {
         self
     }
@@ -1601,9 +1561,8 @@ impl bun_io::Write for WriteBufWriter<'_> {
 }
 
 // Local extension trait providing `.unwrap_or_oom()` on `Result<T, E>`.
-// Zig: `catch bun.outOfMemory()` / `bun.handleOom(expr)`. No shared `UnwrapOrOom`
-// trait exists yet (bun_alloc has none); delegate to `bun_core::handle_oom` so
-// every call site keeps its method-chain shape.
+// No shared `UnwrapOrOom` trait exists yet (bun_alloc has none); delegate to
+// `bun_core::handle_oom` so every call site keeps its method-chain shape.
 trait UnwrapOrOom {
     type Output;
     fn unwrap_or_oom(self) -> Self::Output;
@@ -1616,5 +1575,3 @@ impl<T, E> UnwrapOrOom for core::result::Result<T, E> {
         bun_core::handle_oom(self)
     }
 }
-
-// ported from: src/runtime/valkey_jsc/valkey.zig
diff --git a/src/runtime/webcore.rs b/src/runtime/webcore.rs
index ca2dce61732..84bf9d6e545 100644
--- a/src/runtime/webcore.rs
+++ b/src/runtime/webcore.rs
@@ -2,9 +2,6 @@
 
 use core::ptr::NonNull;
 
-// NOTE(port): the Zig `comptime { _ = @import("./webcore/prompt.zig"); _ = @import("./webcore/TextEncoder.zig"); }`
-// force-reference block is dropped — Rust links what's `pub`. (See PORTING.md §Don't translate.)
-
 // ─── submodules under ./webcore/ ─────────────────────────────────────────────
 // `#[path]` is relative to the dir containing this file (`src/runtime/`).
 
@@ -33,7 +30,7 @@ pub mod text_encoder;
 #[path = "webcore/TextEncoderStreamEncoder.rs"]
 pub mod text_encoder_stream_encoder;
 
-// ─── flat re-exports (mirror Zig `pub const X = @import(...)`) ───────────────
+// ─── flat re-exports ─────────────────────────────────────────────────────────
 pub use bun_jsc::js_error_code::DOMExceptionCode;
 pub use bun_jsc::web_worker;
 pub use s3_stat::S3Stat;
@@ -81,8 +78,8 @@ pub mod jsc {
 // Forward the real `bun_s3_signing` types so `s3_stub::X` and
 // `bun_s3_signing::X` are the *same* type (avoids
 // `s3_stub::ACL`-vs-`bun_s3_signing::ACL` mismatches across modules).
-// Remaining names without a real definition stay as opaque unit structs.
-// TODO(port): bun_s3 — replace with real crate once it exists.
+// Remaining names without a real definition stay as opaque unit structs until
+// a real `bun_s3` crate exists.
 pub mod s3_stub {
     macro_rules! opaque { ($($n:ident),* $(,)?) => {$(
         #[derive(Debug, Default)] pub struct $n;
@@ -114,13 +111,9 @@ pub mod node_types {
 pub use crate::jsc::AbortSignal;
 
 // ─── AutoFlusher (webcore tier) ──────────────────────────────────────────────
-// `bun.jsc.WebCore.AutoFlusher` — port of `src/event_loop/AutoFlusher.zig`.
-//
 // The lower-tier `bun_event_loop::auto_flusher` takes a `&mut DeferredTaskQueue`
-// directly to avoid an event_loop→jsc upward dependency. This tier restores the
-// original Zig signature (`vm: *jsc.VirtualMachine`) and reaches the queue via
-// `vm.event_loop().deferred_tasks`, so call sites in `FileSink` /
-// `HTTPServerWritable` keep their Zig shape.
+// directly to avoid an event_loop→jsc upward dependency. This tier takes a
+// `&VirtualMachine` and reaches the queue via `vm.event_loop().deferred_tasks`.
 pub use bun_event_loop::auto_flusher;
 use bun_event_loop::deferred_task_queue::DeferredRepeatingTask;
 
@@ -131,8 +124,7 @@ pub struct AutoFlusher {
     pub registered: core::cell::Cell<bool>,
 }
 
-/// Zig duck-types on `this.auto_flusher` + `Type.onAutoFlush`; modeled as a
-/// trait. Implemented below for `FileSink` and `HTTPServerWritable<_, _>`.
+/// Implemented below for `FileSink` and `HTTPServerWritable<_, _>`.
 pub trait HasAutoFlusher: Sized {
     fn auto_flusher(&self) -> &AutoFlusher;
     /// `Type.onAutoFlush` — `DeferredRepeatingTask` ABI after `@ptrCast`
@@ -160,8 +152,7 @@ impl AutoFlusher {
 
     #[inline]
     fn erased_cb<T: HasAutoFlusher>() -> DeferredRepeatingTask {
-        // Zig `@ptrCast(&Type.onAutoFlush)` — modeled as a monomorphic
-        // `extern "C"` trampoline (no fn-ptr transmute across ABIs).
+        // A monomorphic `extern "C"` trampoline (no fn-ptr transmute across ABIs).
         unsafe extern "C" fn trampoline<T: HasAutoFlusher>(ctx: *mut core::ffi::c_void) -> bool {
             // SAFETY: `ctx` is exactly the `*mut T` registered via
             // `erased_ctx` below; `DeferredTaskQueue::run` feeds it back
@@ -199,9 +190,8 @@ impl AutoFlusher {
         vm: &jsc::VirtualMachine,
     ) {
         debug_assert!(this.auto_flusher().registered.get());
-        // PORT NOTE: Zig `bun.assert(expr)` evaluates `expr` unconditionally;
-        // only the *check* is debug-gated. Do not wrap the side-effecting call
-        // in `debug_assert!`.
+        // Do not wrap the side-effecting call in `debug_assert!`;
+        // only the *check* is debug-gated.
         let removed = vm
             .event_loop_ref()
             .deferred_tasks
@@ -316,17 +306,15 @@ pub use file_sink::FileSink;
 pub use byte_blob_loader::ByteBlobLoader;
 pub use byte_stream::ByteStream;
 
-// TODO: make this JSGlobalObject local for better security
-// Zig: `bun.ObjectPool(bun.ByteList, null, true, 8)` — `null` init goes on
-// `ObjectPoolType` (already impl'd for `Vec<u8>` in bun_collections), `true`
-// is THREADSAFE, `8` is MAX_COUNT. `object_pool!` wires the per-monomorphization
+// TODO: make this pool per-JSGlobalObject so recycled buffers are not shared
+// across realms (the pool is process-global).
+// `object_pool!` wires the per-monomorphization
 // thread-local storage; the bare `ObjectPool<Vec<u8>, true, 8>` alias used to
 // default to `UnwiredStorage` and panic on first `get_if_exists()`/`full()`
 // from `streams::HTTPSServerWritable::send`.
 bun_collections::object_pool!(pub ByteListPool: Vec<u8>, threadsafe, 8);
 
 // ─── compiling submodules ────────────────────────────────────────────────────
-// Zig: `pub const FetchHeaders = @import("../jsc/FetchHeaders.zig").FetchHeaders;` (opaque {}).
 // Re-export the crate-local jsc shim's opaque type until `bun_jsc::fetch_headers`
 // is green; the shim's `#[repr(transparent)] struct FetchHeaders(usize)` matches the
 // opaque-handle ABI used by the `WebCore__FetchHeaders__*` extern fns.
@@ -362,7 +350,7 @@ pub mod script_execution_context;
 #[doc(hidden)]
 #[path = "webcore/s3/multipart_options.rs"]
 pub mod multipart_options_impl;
-// PORT NOTE: inner `#[path]` inside an inline `mod s3 { }` resolves relative to
+// Note: inner `#[path]` inside an inline `mod s3 { }` resolves relative to
 // `<this-file's-dir>/s3/`, which would point at `src/runtime/s3/...` (does not
 // exist). Declare the file mods at this level (where `#[path]` is relative to
 // `src/runtime/`) and re-export them under `s3`.
@@ -389,15 +377,14 @@ pub mod s3 {
     pub use super::multipart_options_impl::MultiPartUploadOptions;
     // Forward the credential / enum stubs so `crate::webcore::s3::{ACL, ...}`
     // resolves for S3Client.rs (its `crate::s3` path is being migrated here).
-    // TODO(port): replace with real bun_s3 types once that crate exists.
+    // These come from `s3_stub` until a real `bun_s3` crate exists.
     pub use super::s3_stub::{
         ACL, S3Credentials, S3CredentialsWithOptions, S3DeleteResult, S3DownloadStreamWrapper,
         S3HttpSimpleTask, S3ListObjectsOptions, S3ListObjectsResult, S3SimpleRequestResult,
         StorageClass,
     };
 
-    // PORT NOTE: `client` is the umbrella re-export hub (matches Zig's `s3/client.zig`
-    // which `pub const X = @import(...)`-s every sibling). It pulls in `simple_request`
+    // Note: `client` is the umbrella re-export hub. It pulls in `simple_request`
     // / `download_stream` / `list_objects` / `multipart` transitively.
     pub use super::__s3_client as client;
     pub use super::__s3_credentials_jsc as credentials_jsc;
@@ -411,20 +398,11 @@ pub mod s3 {
 #[path = "webcore/streams.rs"]
 pub mod streams;
 
-// NOTE(port): the Zig `comptime { WebSocketClient.exportAll(); ... }` block forces export of
-// `extern "C"` symbols from `src/http/websocket_http_client.zig`. In Rust, those become
-// `#[unsafe(no_mangle)] pub extern "C" fn` in `bun_http::websocket_http_client` and need no
-// force-reference here. Dropped per PORTING.md §Don't translate.
-
 pub enum PathOrFileDescriptor {
-    // PORT NOTE: `jsc.ZigString.Slice` → `bun_core::zig_string::Slice` (= `ZigStringSlice`).
     Path(bun_core::zig_string::Slice),
     Fd(bun_sys::Fd),
 }
 
-// NOTE(port): Zig `deinit` only called `this.path.deinit()` for the `.path` arm. In Rust the
-// variant payload's `Drop` runs automatically, so no explicit `impl Drop` is needed.
-
 #[derive(Default)]
 pub struct Pipe {
     pub ctx: Option<NonNull<()>>,
@@ -440,10 +418,8 @@ impl Pipe {
 
 pub type Function = fn(ctx: NonNull<()>, stream: streams::Result);
 
-// TODO(port): Zig `Wrap(comptime Type, comptime function)` takes a *comptime fn pointer* as a
-// generic argument, which stable Rust cannot express. Reshaped: callers implement `PipeHandler`
-// for their type instead of passing a free fn. TODO(refactor): audit call sites
-// (`Wrap(Foo, Foo.onPipe).init(self)` → `Wrap::<Foo>::init(self)`).
+// Callers implement `PipeHandler` for their type instead of passing a free fn
+// (`Wrap::<Foo>::init(self)`).
 pub(crate) trait PipeHandler {
     fn on_pipe(&mut self, stream: streams::Result);
 }
@@ -481,5 +457,3 @@ pub enum Lifetime {
     /// When reading from a fifo like STDIN/STDERR
     Temporary,
 }
-
-// ported from: src/runtime/webcore.zig
diff --git a/src/runtime/webcore/ArrayBufferSink.rs b/src/runtime/webcore/ArrayBufferSink.rs
index 72c96eca575..4f0bd90b1a4 100644
--- a/src/runtime/webcore/ArrayBufferSink.rs
+++ b/src/runtime/webcore/ArrayBufferSink.rs
@@ -5,9 +5,8 @@ use bun_jsc::{ArrayBuffer, JSGlobalObject, JSType, JSValue, JsResult};
 use bun_sys as syscall;
 
 pub type JSSink = sink::JSSink<ArrayBufferSink>;
-// PORT NOTE: Zig passes the literal "ArrayBufferSink" as a 2nd comptime arg to
-// `Sink.JSSink()`; in Rust the symbol-name concatenation lives in the
-// `JsSinkAbi` impl in `Sink.rs` (see `array_buffer_sink_abi`).
+// The "ArrayBufferSink" symbol-name concatenation lives in the `JsSinkAbi`
+// impl in `Sink.rs` (see `array_buffer_sink_abi`).
 
 #[derive(Default)]
 pub struct ArrayBufferSink {
@@ -15,10 +14,9 @@ pub struct ArrayBufferSink {
     // allocator field dropped — global mimalloc (non-AST crate, see PORTING.md §Allocators)
     pub done: bool,
     pub signal: Signal,
-    // PORT NOTE: Zig `?Sink` stores a `*anyopaque` (raw, manually-managed
-    // lifetime). The Rust `Sink<'a>` was ported with a borrow; using `'static`
-    // here recovers the Zig semantics (caller is responsible for the pointee
-    // outliving every dispatch). No call site sets `next` to non-`None` today.
+    // `Sink<'a>` carries a borrow; `'static` here means the caller is
+    // responsible for the pointee outliving every dispatch. No call site sets
+    // `next` to non-`None` today.
     pub next: Option<Sink<'static>>,
     pub streaming: bool,
     pub as_uint8array: bool,
@@ -26,8 +24,6 @@ pub struct ArrayBufferSink {
 
 impl ArrayBufferSink {
     pub fn connect(&mut self, signal: Signal) {
-        // PORT NOTE: Zig asserts `this.reader == null` but there is no `reader`
-        // field on this struct (dead Zig assert; lazy compilation never reaches it).
         self.signal = signal;
     }
 
@@ -65,7 +61,7 @@ impl ArrayBufferSink {
         _wait: bool,
     ) -> bun_sys::Result<JSValue> {
         if self.streaming {
-            // TODO: properly propagate exception upwards (matches Zig `catch .zero`).
+            // TODO: properly propagate exception upwards.
             let value: JSValue = if self.as_uint8array {
                 ArrayBuffer::create::<{ JSType::Uint8Array }>(global_this, self.bytes.slice())
                     .unwrap_or(JSValue::ZERO)
@@ -80,7 +76,7 @@ impl ArrayBufferSink {
         Ok(JSValue::js_number(0.0))
     }
 
-    // PORT NOTE: NOT a `host_fn_finalize` target — JSSink uses its own
+    // NOT a `host_fn_finalize` target — JSSink uses its own
     // `${abi_name}__finalize` thunk (generated_jssink.rs), which calls
     // the trait `JsSinkType::finalize(&mut self)`; that forwards here. The
     // `Box<Self>` contract applies only to generate-classes.ts classes.
@@ -109,7 +105,7 @@ impl ArrayBufferSink {
         }))
     }
 
-    // PORT NOTE: in-place init (JSSink m_ctx slot) — codegen calls this on a
+    // In-place init (JSSink m_ctx slot) — codegen calls this on a
     // pre-allocated slot.
     pub fn construct(this: &mut core::mem::MaybeUninit<Self>) {
         this.write(ArrayBufferSink {
@@ -157,9 +153,9 @@ impl ArrayBufferSink {
             return next.write_utf16(data);
         }
         let bytes = data.slice();
-        // Mirrors Zig `@ptrCast(@alignCast(data.slice().ptr))` — caller
-        // guarantees the byte slice is u16-aligned and has even length when the
-        // stream encoding is UTF-16. bytemuck checks both at runtime.
+        // The caller guarantees the byte slice is u16-aligned and has even
+        // length when the stream encoding is UTF-16. bytemuck checks both at
+        // runtime.
         let utf16: &[u16] = bytemuck::cast_slice(bytes);
         let len = match self.bytes.write_utf16(utf16) {
             Ok(len) => len,
@@ -182,7 +178,7 @@ impl ArrayBufferSink {
     /// [`ArrayBufferSink::init`] or the JSSink codegen path) and not yet freed.
     pub unsafe fn destroy(this: *mut Self) {
         // SAFETY: reclaiming ownership drops `bytes` (Vec<u8> impls Drop) and
-        // frees the box, matching Zig `this.bytes.deinit(...); bun.destroy(this)`.
+        // frees the box.
         drop(unsafe { bun_core::heap::take(this) });
     }
 
@@ -192,9 +188,7 @@ impl ArrayBufferSink {
         as_uint8array: bool,
     ) -> JsResult<JSValue> {
         if self.streaming {
-            // PORT NOTE: Zig calls `ArrayBuffer.create()` here without `catch`
-            // (dead path under Zig's lazy compilation). Propagate the JS
-            // exception explicitly in Rust.
+            // Propagate the JS exception explicitly.
             let value: JSValue = if as_uint8array {
                 ArrayBuffer::create::<{ JSType::Uint8Array }>(global_this, self.bytes.slice())?
             } else {
@@ -204,8 +198,7 @@ impl ArrayBufferSink {
             return Ok(value);
         }
 
-        // `defer this.bytes = bun.Vec<u8>.empty` + `try toOwnedSlice` →
-        // take ownership, leave empty in place.
+        // Take ownership of the bytes, leaving an empty Vec in place.
         let mut bytes = core::mem::take(&mut self.bytes);
         // `to_js_unchecked`, not `to_js`: `to_js`'s `mi_is_in_heap_region`
         // probe skips the deallocator when the global allocator isn't mimalloc.
@@ -271,9 +264,8 @@ impl crate::webcore::sink::JsSinkType for ArrayBufferSink {
         Self::memory_cost(self)
     }
     fn finalize(&mut self) {
-        // Zig: ArrayBufferSink.finalize destroys the heap allocation; the
-        // `JSSink::finalize` C export owns that path. The trait impl here is
-        // the *inner* finalize.
+        // The `JSSink::finalize` C export owns destroying the heap
+        // allocation; the trait impl here is the *inner* finalize.
         Self::finalize(std::ptr::from_mut::<Self>(self));
     }
     fn construct(this: &mut core::mem::MaybeUninit<Self>) {
@@ -318,5 +310,3 @@ impl crate::webcore::sink::JsSinkType for ArrayBufferSink {
 }
 
 crate::impl_sink_handler!(ArrayBufferSink);
-
-// ported from: src/runtime/webcore/ArrayBufferSink.zig
diff --git a/src/runtime/webcore/BakeResponse.rs b/src/runtime/webcore/BakeResponse.rs
index 2c7c9f7a99b..88a02f514a1 100644
--- a/src/runtime/webcore/BakeResponse.rs
+++ b/src/runtime/webcore/BakeResponse.rs
@@ -152,7 +152,6 @@ bun_jsc::jsc_host_abi! {
         global_object: &JSGlobalObject,
         call_frame: &CallFrame,
     ) -> JSValue {
-        // PERF(port): was @call(bun.callmod_inline, ...).
         bun_jsc::to_js_host_call(global_object, || construct_render(global_object, call_frame))
     }
 }
@@ -175,8 +174,7 @@ pub(crate) fn construct_render(
     assert_streaming_disabled(global_this, async_local_storage, b"Response.render")?;
 
     // Validate arguments
-    // PORT NOTE: `arguments` is a fixed [JSValue; 2] so `.len() < 1` is
-    // comptime-false in Zig too; kept for structural fidelity.
+    // `arguments` is a fixed [JSValue; 2] so `.len() < 1` is always false.
     #[allow(clippy::len_zero)]
     if arguments.len() < 1 {
         return Err(global_this.throw_invalid_arguments(format_args!(
@@ -257,5 +255,3 @@ fn assert_streaming_disabled(
     }
     Ok(())
 }
-
-// ported from: src/runtime/webcore/BakeResponse.zig
diff --git a/src/runtime/webcore/Blob.rs b/src/runtime/webcore/Blob.rs
index fcb3c42cbdf..49348281ff4 100644
--- a/src/runtime/webcore/Blob.rs
+++ b/src/runtime/webcore/Blob.rs
@@ -63,9 +63,8 @@ pub mod write_file;
 /// callback to `ArrayBuffer::to_js_with_context`; the `ctx` is a raw `Store*`
 /// produced by `StoreRef::into_raw()`.
 ///
-/// Mirrors Zig `jsc.array_buffer.BlobArrayBuffer_deallocator`; defined here
-/// (rather than in `bun_jsc`) because `Store` is a `bun_runtime` type and the
-/// `bun_jsc` copy is a forward-dep placeholder.
+/// Defined here (rather than in `bun_jsc`) because `Store` is a `bun_runtime`
+/// type and the `bun_jsc` copy is a forward-dep placeholder.
 ///
 /// Body wraps its only privileged op (`Store::deref`) locally; a safe
 /// `extern "C" fn` coerces to the `JSTypedArrayBytesDeallocator` pointer
@@ -94,8 +93,8 @@ pub enum ReadBytesResult {
     Err(Box<bun_jsc::SystemError>),
 }
 
-/// Trait extracted from the Zig `comptime Handler: type` pattern in
-/// `read_bytes_to_handler` — the body only requires `on_read_bytes`.
+/// Handler trait for `read_bytes_to_handler` — the body only requires
+/// `on_read_bytes`.
 pub trait ReadBytesHandler {
     fn on_read_bytes(&mut self, result: ReadBytesResult);
 }
@@ -396,7 +395,7 @@ pub trait BlobExt {
 }
 
 /// C-ABI trampoline for `Blob::shared_view` so C++ (`ZigGeneratedClasses`)
-/// can read blob bytes. Mirrors Zig `Blob.sharedView`'s `(ptr,len)` shape.
+/// can read blob bytes.
 ///
 /// # Safety
 /// `this` must be a live `*const Blob` (the codegen `m_ctx` payload obtained
@@ -423,7 +422,7 @@ impl BlobExt for Blob {
         Some(bun_core::form_data::AsyncFormData::init(encoding))
     }
 
-    /// `Function` is the comptime `*WithBytes` callback (Zig: `comptime Function: anytype`).
+    /// `Function` is the `*WithBytes` callback.
     /// Modeled as a [`read_file::ReadFileToJs`] impl so the wrapped fn-pointer
     /// monomorphizes per call site without `fn_traits`.
     fn do_read_from_s3<F: read_file::ReadFileToJs>(
@@ -431,7 +430,7 @@ impl BlobExt for Blob {
         global: &JSGlobalObject,
     ) -> JsTerminatedResult<JSValue> {
         debug!("doReadFromS3");
-        // Zig: `WrappedFn.wrapped` — adapt `(b, g, bytes)` → `(b, g, bytes, .clone)`
+        // Adapt `(b, g, bytes)` → `(b, g, bytes, .clone)`
         // and route through `to_js_host_call` so the exception scope is asserted.
         fn wrapped<F: read_file::ReadFileToJs>(
             b: &Blob,
@@ -496,8 +495,8 @@ impl BlobExt for Blob {
             // The garbage collector runs on memory allocations
             // The JSPromise is the next GC'd memory allocation.
             // This shouldn't really fix anything, but it's a little safer.
-            // PORT NOTE: `JSPromiseStrong.strong` is private; `init` creates the
-            // JSPromise *and* the strong handle in one step, matching the Zig.
+            // `JSPromiseStrong.strong` is private; `init` creates the
+            // JSPromise *and* the strong handle in one step.
             // SAFETY: handler was just boxed; sole owner.
             unsafe { (*handler).promise = jsc::JSPromiseStrong::init(global) };
             // SAFETY: same `handler` as above; still solely owned here.
@@ -587,7 +586,7 @@ impl BlobExt for Blob {
                         // SystemError so the callback has one shape to handle.
                         crate::webcore::__s3_client::S3DownloadResult::NotFound(e)
                         | crate::webcore::__s3_client::S3DownloadResult::Failure(e) => {
-                            // PORT NOTE: reshaped for borrowck — `t.done` moves
+                            // reshaped for borrowck — `t.done` moves
                             // `t`, so build the SystemError (cloning the path
                             // out of `t.blob.store`) before the call.
                             let err = bun_jsc::SystemError {
@@ -612,7 +611,7 @@ impl BlobExt for Blob {
             });
             t.poll.ref_(bun_io::js_vm_ctx());
             let proxy = http_proxy_href(global);
-            // PORT NOTE: reshaped for borrowck — `heap::alloc(t)` moves `t`,
+            // reshaped for borrowck — `heap::alloc(t)` moves `t`,
             // so clone the `Rc<S3Credentials>` out (cheap ref bump)
             // and stash `path` as a raw `*const [u8]` whose backing store is
             // kept alive by the same `t.blob` now owned by the heap task.
@@ -662,7 +661,7 @@ impl BlobExt for Blob {
         }
         // In-memory or detached.
         let view = self.shared_view();
-        let owned = view.to_vec(); // PERF(port): was allocator.dupe — global mimalloc
+        let owned = view.to_vec();
         // SAFETY: caller-owned ctx.
         H::on_read_bytes(unsafe { &mut *ctx }, ReadBytesResult::Ok(owned));
         Ok(())
@@ -857,8 +856,7 @@ impl BlobExt for Blob {
         // SAFETY: `store` is the sole +1 on this freshly-allocated Store.
         unsafe {
             (*store.as_ptr()).mime_type = bun_http_types::MimeType::Compact::from(
-                // Zig: `MimeType.Compact.from(.@"application/x-www-form-urlencoded")` —
-                // the bare tag, *without* `;charset=UTF-8` (charset promotion is
+                // The bare tag, *without* `;charset=UTF-8` (charset promotion is
                 // Compact::to_mime_type's job, applied when read).
                 bun_http_types::MimeType::Table::from_mime_literal(
                     "application/x-www-form-urlencoded",
@@ -882,7 +880,6 @@ impl BlobExt for Blob {
             // SAFETY: bun_vm() never returns null for a Bun-owned global.
             let random = global_this.bun_vm().as_mut().rare_data().next_uuid().bytes;
             boundary_buf[..BOUNDARY_PREFIX.len()].copy_from_slice(BOUNDARY_PREFIX);
-            // Zig `{x}` on `[16]u8` emits 32 contiguous lowercase-hex chars.
             bun_core::fmt::bytes_to_hex_lower(&random, &mut boundary_buf[BOUNDARY_PREFIX.len()..]);
             &boundary_buf
         };
@@ -897,7 +894,7 @@ impl BlobExt for Blob {
         // string entry 8, plus 3 for the closing boundary.
         context.joiner.reserve(form_data.count() * 13 + 3);
 
-        // PORT NOTE (layering): `bun_jsc::DOMFormData::for_each` yields the
+        // `bun_jsc::DOMFormData::for_each` yields the
         // lower-tier `bun_jsc::dom_form_data::FormDataEntry`, whose `blob`
         // field is `&bun_jsc::WebCore::Blob` (the forward-decl). The native
         // pointer the C++ hands us is the `m_ctx` `*mut Blob`; reinterpret it
@@ -1070,7 +1067,7 @@ impl BlobExt for Blob {
                                     if cfg!(debug_assertions) {
                                         panic!("this shouldn't be reachable.");
                                     }
-                                    // Zig: `0x{x}` — pretty_fmt! doesn't rewrite `{x}`,
+                                    // pretty_fmt! doesn't rewrite `{x}`,
                                     // so use the Rust hex spec inline.
                                     bun_core::write_pretty!(
                                         writer,
@@ -1192,8 +1189,7 @@ impl BlobExt for Blob {
                     global_this.throw_invalid_arguments(format_args!("chunkSize must be a number"))
                 );
             }
-            // PERF(port): Zig used @truncate to i52 then @intCast to SizeType.
-            // `(x << 12) >> 12` on i64 reproduces `@as(i52, @truncate(x))` exactly
+            // `(x << 12) >> 12` on i64 truncates to a sign-extended i52
             // (arithmetic right-shift sign-extends bit 51), so negatives clamp to 0
             // via `.max(0)` instead of becoming the 52-bit zero-extended mask.
             let v = (recommended_chunk_size_value.to_int64() << 12) >> 12;
@@ -1371,8 +1367,7 @@ impl BlobExt for Blob {
                 return Err(global_this.throw_invalid_argument_type("write", "options", "object"));
             }
         }
-        // Zig: `var blob_internal: PathOrBlob = .{ .blob = this.* }` — a raw
-        // bitwise copy with NO ref bumps; `write_file_internal` then `dupe()`s
+        // A borrowed view with NO ref bumps; `write_file_internal` then `dupe()`s
         // its own owned `destination_blob` from it.
         let mut blob_internal = PathOrBlob::Blob(Box::new(self.borrowed_view()));
         write_file_internal(
@@ -1451,12 +1446,10 @@ impl BlobExt for Blob {
             };
             let proxy_url = proxy.map(|p| p.href);
 
-            // Zig: `(if (extra_options != null) aws_options.credentials.dupe()
-            // else s3.getCredentials())` — when no JS overrides were supplied,
-            // hand the store's *base* credentials to the upload (Zig passes the
-            // shared pointer; Rust's `upload_stream` consumes an `IntrusiveRc`
-            // by value, so the else-arm heap-dupes from the store's `Arc`
-            // instead of from the `aws_options` clone).
+            // When no JS overrides were supplied, hand the store's *base*
+            // credentials to the upload (`upload_stream` consumes an
+            // `IntrusiveRc` by value, so the else-arm heap-dupes from the
+            // store's `Arc` instead of from the `aws_options` clone).
             return crate::webcore::__s3_client::upload_stream(
                 if extra_options.is_some() {
                     aws_options.credentials.dupe()
@@ -1605,7 +1598,7 @@ impl BlobExt for Blob {
                         bun_core::ZigStringSlice::init_dupe(p.slice()).expect("oom"),
                     ),
                 };
-                // input_path drops at scope exit (Zig: `defer input_path.deinit()`).
+                // input_path drops at scope exit.
 
                 let stream_start = streams::Start::FileSink(streams::FileSinkOptions {
                     input_path,
@@ -1739,7 +1732,7 @@ impl BlobExt for Blob {
 
     fn get_writer(&self, global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let arguments_ = callframe.arguments_old::<1>();
-        // Zig indexes the fixed-size buffer (`arguments.ptr[0]`), not the
+        // Index the fixed-size buffer (`arguments.ptr[0]`), not the
         // len-bounded view, so the slot reads `.zero` when no arg was passed
         // instead of panicking on `arguments[0]`.
         let arg0 = arguments_.ptr[0];
@@ -1754,8 +1747,7 @@ impl BlobExt for Blob {
 
         let store = self.store().expect("infallible: store present").clone();
         if self.is_s3() {
-            // PORT NOTE: reshaped for borrowck — Zig holds `*const S3` while
-            // also mutating `this.content_type*`. Borrow `s3` through the
+            // Borrow `s3` through the
             // cloned `store: StoreRef` (independent of `self`) so the
             // content-type writes below don't conflict.
             let s3 = store.data.as_s3();
@@ -1932,9 +1924,8 @@ impl BlobExt for Blob {
                 return Err(global_this.throw_value(err.to_js(global_this)));
             }
 
-            // #53265: `FileSink::to_js` takes its own per-wrapper +1 (Rust port
-            // makes this explicit; Zig's `toJS` *transfers* init's +1). Release
-            // init's +1 here so the accounting matches Zig — otherwise the
+            // #53265: `FileSink::to_js` takes its own per-wrapper +1. Release
+            // init's +1 here — otherwise the
             // sink starts at rc=2 and the writer-close path's net deref balance
             // is off by one against `~JSFileSink`'s `finalize`.
             let js = sink_mut.to_js(global_this);
@@ -1964,7 +1955,7 @@ impl BlobExt for Blob {
                 ),
             };
 
-            // PORT NOTE: `webcore::PathOrFileDescriptor` is not `Clone`; build user
+            // `webcore::PathOrFileDescriptor` is not `Clone`; build user
             // options first, then move `input_path` in once.
             let mut stream_start = if has_args && arg0.is_object() {
                 streams::Start::from_js_with_tag::<{ streams::StartTag::FileSink }>(
@@ -2052,7 +2043,7 @@ impl BlobExt for Blob {
     /// https://w3c.github.io/FileAPI/#slice-method-algo
     fn get_slice(&self, global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let mut arguments_ = callframe.arguments_old::<3>();
-        // PORT NOTE: index the full fixed-3 array (Zig writes args[2] regardless of len).
+        // index the full fixed-3 array (args[2] is written below regardless of len).
         let args = &mut arguments_.ptr[..];
 
         if self.size.get() == 0 {
@@ -2067,7 +2058,7 @@ impl BlobExt for Blob {
         // If the optional end parameter is not used, let relativeEnd be size.
         let mut relative_end: i64 = i64::try_from(self.size.get()).expect("int cast");
 
-        // PORT NOTE: Zig mutates the fixed-3 args array in place to shift string arg into [2].
+        // Mutate the fixed-3 args array in place to shift the string arg into [2].
         if args[0].is_string() {
             args[2] = args[0];
             args[1] = JSValue::ZERO;
@@ -2201,7 +2192,7 @@ impl BlobExt for Blob {
         }
         if value.is_string() {
             let _old_name = self.name.replace(BunString::empty());
-            // errdefer this.name = bun.String.empty — handled by the replace above.
+            // error rollback of `name` is handled by the replace above.
             self.name.set(BunString::from_js(value, global_this)?);
             // We don't need to increment the reference count since try_from_js already did it.
             bun_jsc::generated::JSBlob::name_set_cached(js_this, global_this, value);
@@ -2231,13 +2222,12 @@ impl BlobExt for Blob {
     fn get_last_modified(&self, _: &JSGlobalObject) -> JSValue {
         if let Some(store) = self.store.get() {
             if matches!(store.data, store::Data::File(_)) {
-                // PORT NOTE: do not hold a pattern-bound `&File` across
+                // do not hold a pattern-bound `&File` across
                 // `resolve_file_stat` — it materializes `&mut File` on the same
                 // memory (Stacked Borrows UB; the optimizer may legally cache the
                 // pre-call `last_modified` and return the stale `INIT_TIMESTAMP`).
                 // Re-read via `StoreRef::data_mut` (raw-ptr-backed accessor) after
-                // the mutating call. Mirrors Zig, which re-loads
-                // `store.data.file.*` each time.
+                // the mutating call.
                 let last_modified = store.data_mut().as_file().last_modified;
                 // last_modified can be already set during read.
                 if last_modified == jsc::INIT_TIMESTAMP && !self.is_s3() {
@@ -2364,7 +2354,7 @@ impl BlobExt for Blob {
             self.size.set(0);
             return;
         };
-        // PORT NOTE: dispatch on the copied `DataTag` rather than
+        // dispatch on the copied `DataTag` rather than
         // `match &store.data { File(file) => … }`. The latter goes through
         // `StoreRef::Deref → &Store → &Data` (no `UnsafeCell`), and that shared
         // borrow is live across the arm body where `resolve_file_stat`
@@ -2419,14 +2409,14 @@ impl BlobExt for Blob {
     }
 
     /// Non-mutating variant of [`resolve_size`]: returns the `(offset, size)` that
-    /// `resolve_size` would assign without touching `self`. Ported for callers
-    /// (e.g. `ByteBlobLoader::setup`) that in Zig copied the whole `Blob` value
-    /// (`var blobe = blob.*; blobe.resolveSize();`) — `Blob` is not `Clone` in Rust.
+    /// `resolve_size` would assign without touching `self`. For callers
+    /// (e.g. `ByteBlobLoader::setup`) that need the resolved size of a `Blob`
+    /// they don't own mutably — `Blob` is not `Clone`.
     fn resolved_size(&self) -> (SizeType, SizeType) {
         let Some(store) = self.store.get() else {
             return (self.offset.get(), 0);
         };
-        // PORT NOTE: see `resolve_size` — dispatch on the copied tag and re-read
+        // see `resolve_size` — dispatch on the copied tag and re-read
         // via `StoreRef::data_mut` after `resolve_file_stat` so no
         // `Deref`-produced `&Data`/`&File` is live across the mutating call.
         match store.data_mut().tag() {
@@ -2589,7 +2579,7 @@ impl BlobExt for Blob {
                 if let Ok(result) =
                     crate::allocators::linux_mem_fd_allocator::LinuxMemFdAllocator::create(bytes_)
                 {
-                    // PORT NOTE: spell out all fields — `..Default::default()` would
+                    // spell out all fields — `..Default::default()` would
                     // attempt a partial move out of `Store` which has a `Drop` impl.
                     let store = StoreRef::from(Store::new(Store {
                         data: store::Data::Bytes(result),
@@ -2619,7 +2609,7 @@ impl BlobExt for Blob {
         Self::try_create(bytes_, global_this, was_string).expect("oom")
     }
 
-    // PORT NOTE: non-generic `init_with_store(StoreRef, ...)` / `init_empty` removed —
+    // non-generic `init_with_store(StoreRef, ...)` / `init_empty` removed —
     // duplicates of the generic `init_with_store<S: Into<StoreRef>>` / `init_empty` below
     // (E0592). All `StoreRef` callers resolve to the generic via the reflexive `Into` impl.
 
@@ -2627,7 +2617,7 @@ impl BlobExt for Blob {
     // It is a move
     #[inline]
     fn transfer(&self) {
-        // Zig: `this.store = null` without `.deref()`. The receiver already
+        // No `.deref()` here: the receiver already
         // holds the same `*Store`; leak our +1 into theirs.
         if let Some(s) = self.take_store() {
             let _ = s.into_raw();
@@ -2640,7 +2630,7 @@ impl BlobExt for Blob {
     /// the Store's byte buffer with **mutable provenance** (derived through
     /// `StoreRef::as_ptr()` → the original `heap::alloc` tag), suitable for
     /// the `*_with_bytes` paths that hand the buffer to JSC as a writable
-    /// ArrayBuffer backing. Mirrors Zig `@constCast(this.sharedView())` without
+    /// ArrayBuffer backing, without
     /// laundering a `&[u8]` through `as *const _ as *mut _` (which would carry
     /// read-only provenance and make the downstream `&mut *buf` retag UB).
     ///
@@ -2732,14 +2722,11 @@ impl BlobExt for Blob {
 
         if bom == Some(strings::BOM::Utf16Le) {
             let _free = (LIFETIME == Lifetime::Temporary).then(|| TemporaryBytes(raw_bytes));
-            // Mirrors Zig `bun.reinterpretSlice(u16, buf)`: drop a trailing odd byte
-            // (`@divTrunc`).
-            // +1 WTF ref; `OwnedString` releases it on scope exit (Zig: `defer out.deref()`).
+            // Reinterpret as u16: drop a trailing odd byte.
+            // +1 WTF ref; `OwnedString` releases it on scope exit.
             //
-            // ZIG PARITY: this branch intentionally does NOT `self.detach()` for
-            // `Lifetime::Transfer` — `Blob.zig` `toStringWithBytes` (UTF-16LE arm)
-            // returns without detaching, unlike `toJSONWithBytes`. Any change to
-            // that asymmetry belongs upstream in the Zig source, not here.
+            // This branch intentionally does NOT `self.detach()` for
+            // `Lifetime::Transfer`, unlike the toJSON path.
             let buf = &buf[..buf.len() & !1];
             let out = match bytemuck::try_cast_slice::<u8, u16>(buf) {
                 Ok(units) => OwnedString::new(BunString::clone_utf16(units)),
@@ -2812,8 +2799,7 @@ impl BlobExt for Blob {
                 })
             }
             Lifetime::Transfer => {
-                // Zig: `const store = this.store.?` (no ref bump) → `this.transfer()`
-                // (sets null, no deref). Cloning the StoreRef here would bump the
+                // Cloning the StoreRef here would bump the
                 // intrusive count by +1 *and* `transfer()` would leak the original
                 // +1, leaving an unmatched ref. Move the existing ref out instead;
                 // `into_raw` then hands that single ref to JSC.
@@ -2845,8 +2831,7 @@ impl BlobExt for Blob {
                 // if there was a UTF-8 BOM, we need to clone the buffer because
                 // external doesn't support this case here yet.
                 if buf.len() != raw_slice.len() {
-                    // +1 WTF ref; `OwnedString` releases it on scope exit
-                    // (Zig: `defer { free; out.deref() }`).
+                    // +1 WTF ref; `OwnedString` releases it on scope exit.
                     let out = OwnedString::new(BunString::clone_latin1(buf));
                     // SAFETY: `Temporary` ⇒ caller passed a leaked `Box<[u8]>`.
                     unsafe { drop(bun_core::heap::take(raw_bytes)) };
@@ -2871,12 +2856,11 @@ impl BlobExt for Blob {
                 .map_err(Into::into);
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig @constCast'd shared_view().
         // `shared_view_raw` yields a `*mut [u8]` with mutable provenance (via
-        // `StoreRef::as_ptr`), avoiding the const→mut cast. `to_string_with_bytes`
+        // `StoreRef::as_ptr`), avoiding a const→mut cast. `to_string_with_bytes`
         // only ever reads through it (`&*raw_bytes`); the sole write path —
         // `heap::take` in the `Temporary` arm — is statically unreachable
-        // below. Mirrors Zig `@constCast(this.sharedView())`.
+        // below.
         let view_ptr = self.shared_view_raw();
         if view_ptr.len() == 0 {
             return Ok(ZigString::EMPTY.to_js(global));
@@ -2897,7 +2881,7 @@ impl BlobExt for Blob {
             },
             // UB guard: `Temporary` would `heap::take(view_ptr)`, but
             // `view_ptr` points at a store-owned interior slice (not a leaked
-            // `Box<[u8]>`). No Zig caller passes `.temporary` to `toString`;
+            // `Box<[u8]>`). No caller passes `Temporary` to `to_string`;
             // the leaked-buffer path calls `to_string_with_bytes` directly.
             Lifetime::Temporary => {
                 unreachable!("Blob::to_string: store-owned bytes are never Temporary")
@@ -2917,7 +2901,7 @@ impl BlobExt for Blob {
 
         // `shared_view_raw` yields a `*mut [u8]` with mutable provenance (via
         // `StoreRef::as_ptr`). `to_json_with_bytes` only reads through it for the
-        // non-`Temporary` lifetimes below. Mirrors Zig `@constCast(this.sharedView())`.
+        // non-`Temporary` lifetimes below.
         let view_ptr = self.shared_view_raw();
         match lifetime {
             // SAFETY: `view_ptr` is the store-backed view from `shared_view_raw`;
@@ -2935,7 +2919,7 @@ impl BlobExt for Blob {
             },
             // UB guard: `Temporary` would `heap::take(view_ptr)`, but
             // `view_ptr` points at a store-owned interior slice (not a leaked
-            // `Box<[u8]>`). No Zig caller passes `.temporary` to `toJSON`; the
+            // `Box<[u8]>`). No caller passes `Temporary` to `to_json`; the
             // leaked-buffer path calls `to_json_with_bytes` directly.
             Lifetime::Temporary => {
                 unreachable!("Blob::to_json: store-owned bytes are never Temporary")
@@ -2967,9 +2951,8 @@ impl BlobExt for Blob {
         }
 
         if bom == Some(strings::BOM::Utf16Le) {
-            // Mirrors Zig `bun.reinterpretSlice(u16, buf)`: drop a trailing odd byte
-            // (`@divTrunc`).
-            // +1 WTF ref; `OwnedString` releases it on scope exit (Zig: `defer out.deref()`).
+            // Reinterpret as u16: drop a trailing odd byte.
+            // +1 WTF ref; `OwnedString` releases it on scope exit.
             let buf = &buf[..buf.len() & !1];
             let mut out = match bytemuck::try_cast_slice::<u8, u16>(buf) {
                 Ok(units) => OwnedString::new(BunString::clone_utf16(units)),
@@ -2983,7 +2966,7 @@ impl BlobExt for Blob {
                     OwnedString::new(BunString::clone_utf16(&units))
                 }
             };
-            // PORT NOTE: Zig used `defer { free; detach }`. Reshaped to compute the
+            // Compute the
             // result first, then perform the deferred work explicitly — capturing
             // `&mut self` in a scopeguard closure conflicts with later uses below.
             let result = out.to_js_by_parse_json(global);
@@ -3006,7 +2989,6 @@ impl BlobExt for Blob {
         let _free = (LIFETIME == Lifetime::Temporary).then(|| TemporaryBytes(raw_bytes));
 
         if could_be_all_ascii.is_none() || !could_be_all_ascii.unwrap() {
-            // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
             if let Some(external) = strings::to_utf16_alloc(buf, false, false).ok().flatten() {
                 if LIFETIME != Lifetime::Temporary {
                     self.set_is_ascii_flag(false);
@@ -3037,7 +3019,7 @@ impl BlobExt for Blob {
             return ZigString::init(b"Invalid encoding").to_error_instance(global);
         };
 
-        // PORT NOTE: `crate::webcore::form_data::Encoding` re-exports
+        // `crate::webcore::form_data::Encoding` re-exports
         // `bun_core::form_data::Encoding` — same type, no re-tagging needed.
         // SAFETY: `buf` is valid for reads for the duration of this call (either a
         // leaked Box for `Temporary` or a store-backed view otherwise);
@@ -3118,7 +3100,6 @@ impl BlobExt for Blob {
                             // SAFETY: `Clone` arm reads only; `buf` is store-backed.
                             if bun::is_slice_in_buffer(unsafe { &*buf }, allocated) {
                                 if let Some(memfd) = LinuxMemFdAllocator::from(bytes.allocator()) {
-                                    // Zig: `allocator.ref(); defer allocator.deref();`
                                     // Hold a ref across the FFI call so a concurrent
                                     // store-deref cannot close the fd mid-mmap.
                                     // SAFETY: `memfd` is the live Box-allocated ptr
@@ -3168,7 +3149,7 @@ impl BlobExt for Blob {
                 // SAFETY: `from_bytes` only records ptr+len into the FFI struct; the
                 // pointer is then handed to JSC as an external buffer backing whose
                 // lifetime is the cloned `store` ref above. No Rust-side `&` to the
-                // Store bytes is live across this reborrow. Mirrors Zig `@constCast`.
+                // Store bytes is live across this reborrow.
                 jsc::ArrayBuffer::from_bytes(unsafe { &mut *buf }, TYPED_ARRAY_VIEW)
                     .to_js_with_context(
                         global,
@@ -3183,8 +3164,7 @@ impl BlobExt for Blob {
                     self.detach();
                     return Err(global.throw_out_of_memory());
                 }
-                // Move the existing +1 out (Zig: `this.store.?` then `transfer()`
-                // nulls without deref). Cloning then `transfer()` would leak a ref.
+                // Move the existing +1 out. Cloning then `transfer()` would leak a ref.
                 let store = self.take_store().expect("transfer with null store");
                 // SAFETY: see `Share` arm. After `take()` the store ref is moved
                 // out of `self`, so JSC becomes the sole owner via the deallocator.
@@ -3204,7 +3184,7 @@ impl BlobExt for Blob {
                     return Err(global.throw_out_of_memory());
                 }
                 // SAFETY: `Temporary` ⇒ `buf` is a leaked `Box<[u8]>` we exclusively own;
-                // ownership is transferred to JSC (Zig: `JSC.MarkedArrayBuffer.fromBytes`).
+                // ownership is transferred to JSC.
                 // `to_js_unchecked`: `to_js`'s heap-region probe would skip the deallocator
                 // for a non-mimalloc buffer, but `Temporary` is always default-allocator.
                 jsc::ArrayBuffer::from_bytes(unsafe { &mut *buf }, TYPED_ARRAY_VIEW)
@@ -3244,14 +3224,12 @@ impl BlobExt for Blob {
             .map_err(Into::into);
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig @constCast'd shared_view().
         // `shared_view_raw` yields a `*mut [u8]` with mutable provenance (via
         // `StoreRef::as_ptr`). The `Clone` arm only reads (`&*buf`);
         // `Share`/`Transfer` hand the ptr to JSC as an external ArrayBuffer
         // backing via FFI and materialize `&mut *buf` to record ptr+len, which
         // is sound now that the provenance is writable. The `Temporary` arm
-        // (`heap::take`) is statically unreachable below. Mirrors Zig
-        // `@constCast(this.sharedView())`.
+        // (`heap::take`) is statically unreachable below.
         let view_ptr = self.shared_view_raw();
         if view_ptr.len() == 0 {
             return jsc::ArrayBuffer::create::<TYPED_ARRAY_VIEW>(global, b"");
@@ -3278,8 +3256,8 @@ impl BlobExt for Blob {
             },
             // UB guard: `Temporary` would `heap::take(view_ptr)`, but
             // `view_ptr` points at a store-owned interior slice (not a leaked
-            // `Box<[u8]>`). No Zig caller passes `.temporary` to
-            // `toArrayBufferView`; the leaked-buffer path calls
+            // `Box<[u8]>`). No caller passes `Temporary` to
+            // `to_array_buffer_view`; the leaked-buffer path calls
             // `to_array_buffer_view_with_bytes` directly.
             Lifetime::Temporary => {
                 unreachable!("Blob::to_array_buffer_view: store-owned bytes are never Temporary")
@@ -3299,13 +3277,11 @@ impl BlobExt for Blob {
             return self.do_read_from_s3::<ToFormDataWithBytesFn>(global);
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig @constCast'd shared_view().
         // `shared_view_raw` yields a `*mut [u8]` with mutable provenance (via
         // `StoreRef::as_ptr`). It is *only ever read* by
         // `to_form_data_with_bytes` (`FormData::to_js` takes `&[u8]`). Note: the
         // Store is intrusively shared (`ref_count: AtomicU32`); `&mut self` does
-        // NOT imply exclusive ownership of the underlying bytes. Mirrors Zig
-        // `@constCast(this.sharedView())`.
+        // NOT imply exclusive ownership of the underlying bytes.
         let view_ptr = self.shared_view_raw();
         if view_ptr.len() == 0 {
             return Ok(jsc::DOMFormData::create(global));
@@ -3319,7 +3295,6 @@ impl BlobExt for Blob {
         global: &JSGlobalObject,
         arg: JSValue,
     ) -> JsResult<Blob> {
-        // Zig: `comptime move: bool, comptime require_array: bool`.
         match (MOVE, REQUIRE_ARRAY) {
             (true, false) => Self::from_js_move(global, arg),
             (false, false) => Self::from_js_clone_optional_array(global, arg),
@@ -3384,12 +3359,10 @@ impl BlobExt for Blob {
                 | jsc::JSType::StringObject
                 | jsc::JSType::DerivedStringObject => {
                     if !fail_if_top_value_is_not_typed_array_like {
-                        // +1 WTF ref; `OwnedString` releases it on scope exit
-                        // (Zig: `defer str.deref()`). `to_owned_slice` only
+                        // +1 WTF ref; `OwnedString` releases it on scope exit.
+                        // `to_owned_slice` only
                         // borrows `&self` — it does not consume the ref.
                         let str = OwnedString::new(top_value.to_bun_string(global)?);
-                        // PORT NOTE: Zig `toOwnedSliceReturningAllASCII` collapsed into
-                        // `to_owned_slice` + a SIMD ASCII scan; identical observable result.
                         let bytes = str.to_owned_slice();
                         let ascii = strings::is_all_ascii(&bytes);
                         return Ok(Blob::init_with_all_ascii(bytes, global, ascii));
@@ -3427,11 +3400,10 @@ impl BlobExt for Blob {
                                 // Move the store without bumping its refcount, but take
                                 // independent ownership of name/content_type so the
                                 // source's eventual finalize() doesn't double-free them.
-                                // PORT NOTE: Zig did a raw bitwise copy then `transfer()`
-                                // (null without deref) → net 0 on the store refcount.
-                                // Mirror that by *taking* the StoreRef out of `blob`
-                                // (no clone, no into_raw leak) and field-copying the
-                                // rest, deep-owning `name`/`content_type`.
+                                // *Take* the StoreRef out of `blob`
+                                // (no clone, no into_raw leak) and field-copy the
+                                // rest, deep-owning `name`/`content_type` — net 0 on
+                                // the store refcount.
                                 let content_type = if blob.content_type_allocated.get() {
                                     bun_core::heap::into_raw(
                                         blob.content_type_slice().to_vec().into_boxed_slice(),
@@ -3446,7 +3418,7 @@ impl BlobExt for Blob {
                                     ),
                                     size: Cell::new(blob.size.get()),
                                     offset: Cell::new(blob.offset.get()),
-                                    store: JsCell::new(blob.take_store()), // ← the move (Zig: copy + transfer)
+                                    store: JsCell::new(blob.take_store()), // ← the move
                                     content_type: Cell::new(content_type),
                                     content_type_allocated: Cell::new(
                                         blob.content_type_allocated.get(),
@@ -3474,14 +3446,12 @@ impl BlobExt for Blob {
                             // buffers instead — regardless of `MOVE`.
                             return Ok(artifact.blob.dupe());
                         } else {
-                            // PORT NOTE: Zig checked `sliced.allocator.get()` to
-                            // detect an owned (heap) slice; `ZigStringSlice`
-                            // collapsed the allocator-vtable into an enum, so
-                            // dispatch on the variant. Zig passes
+                            // Dispatch on the `ZigStringSlice` variant to detect an
+                            // owned (heap) slice. Pass
                             // `is_all_ascii = false` here (the slice came from
                             // an arbitrary DOMWrapper coercion, not a known-ASCII
-                            // source) and *falls through* — no `return` — when
-                            // there's no allocator (i.e. the empty slice), letting
+                            // source) and *fall through* — no `return` — for a
+                            // non-owned (i.e. empty) slice, letting
                             // the joiner path below handle it.
                             let sliced = current.to_slice_clone(global)?;
                             if matches!(sliced, ZigStringSlice::Owned(_)) {
@@ -3507,10 +3477,10 @@ impl BlobExt for Blob {
             }
         }
 
-        // PERF(port): was stack-fallback(1024) alloc. Every value pushed here is
+        // Every value pushed here is
         // reachable from `arg` (rooted by `_keep: EnsureStillAlive` above) via the
-        // JS object graph, so a heap `Vec<JSValue>` is GC-safe and restores Zig's
-        // unbounded capacity (the prior `BoundedArray<_, 128>` panicked on overflow).
+        // JS object graph, so a heap `Vec<JSValue>` is GC-safe with
+        // unbounded capacity (a prior `BoundedArray<_, 128>` panicked on overflow).
         let mut stack: Vec<JSValue> = Vec::new();
         let mut joiner = bun_core::string_joiner::StringJoiner::default();
         let mut could_have_non_ascii = false;
@@ -3523,9 +3493,7 @@ impl BlobExt for Blob {
                 | jsc::JSType::DerivedStringObject => {
                     let sliced = current.to_slice(global)?;
                     could_have_non_ascii = could_have_non_ascii || !sliced.is_wtf_backed();
-                    // PORT NOTE: Zig handed `allocator` to the joiner so it could
-                    // free in-place; `StringJoiner::push` dropped that param, so
-                    // clone into the joiner and let `sliced` drop normally.
+                    // Clone into the joiner and let `sliced` drop normally.
                     joiner.push_cloned(sliced.slice());
                 }
 
@@ -3820,10 +3788,9 @@ impl BlobExt for Blob {
             PathOrFileDescriptor::Path(_) => {
                 #[cfg(windows)]
                 if path_or_fd.path().slice() == b"/dev/null" {
-                    // Zig: `path_or_fd.deinit()` then re-assign. In Rust the
-                    // assignment below drops the old `PathLike` (releasing the
-                    // caller-owned path), so the explicit deinit is folded into
-                    // the `*path_or_fd = …` write.
+                    // The assignment below drops the old `PathLike` (releasing
+                    // the caller-owned path) as part of the `*path_or_fd = …`
+                    // write.
                     *path_or_fd =
                         PathOrFileDescriptor::Path(crate::webcore::node_types::PathLike::String(
                             // Heap-dupe: this buffer is freed by `Blob.Store.deinit`.
@@ -3835,7 +3802,7 @@ impl BlobExt for Blob {
 
                 // SAFETY: bun_vm() is live for the duration of a host call.
                 if global_this.bun_vm().standalone_module_graph.is_some() {
-                    // PORT NOTE (layering): `vm.standalone_module_graph` is a
+                    // `vm.standalone_module_graph` is a
                     // type-erased `&dyn` so `bun_jsc` doesn't depend on
                     // `bun_standalone_graph`. The concrete `Graph` is the sole
                     // implementor and lives in a process-lifetime `OnceLock`;
@@ -3849,9 +3816,7 @@ impl BlobExt for Blob {
                     if let Some(file) = unsafe { &mut *graph }.find(path_or_fd.path().slice()) {
                         use crate::api::standalone_graph_jsc::FileJsc as _;
                         let blob = file.file_blob(global_this).dupe();
-                        // Zig: `defer { if (path_or_fd.path != .string) {
-                        //   path_or_fd.deinit(); path_or_fd.* = .{ .path = .{ .string = empty } };
-                        // } }` — release a SliceWithUnderlying / encoded-slice
+                        // Release a SliceWithUnderlying / encoded-slice
                         // path the graph short-circuit would otherwise leak.
                         // The reassignment below drops the old payload via
                         // `Drop for PathLike`; no explicit `.deinit()` needed.
@@ -3881,8 +3846,7 @@ impl BlobExt for Blob {
                     // `RareData::{stdin,stdout,stderr}()` return the cached
                     // `webcore::blob::Store` erased to `*mut c_void` (the
                     // low-tier crate cannot name the high-tier type — see
-                    // `STDIO_BLOB_STORE_CTOR`). Cast back and take a counted
-                    // ref (Zig: `store.ref(); return Blob.initWithStore(store, …)`).
+                    // `STDIO_BLOB_STORE_CTOR`). Cast back and take a counted ref.
                     let erased = match tag {
                         bun_sys::Stdio::StdIn => vm.rare_data().stdin(),
                         bun_sys::Stdio::StdErr => vm.rare_data().stderr(),
@@ -3915,7 +3879,6 @@ impl BlobExt for Blob {
 
     /// Takes ownership of `self` by value. Invalidates `self`.
     fn take_ownership(&mut self) -> Blob {
-        // PORT NOTE: Zig writes `self.* = undefined` after the copy.
         let mut result = std::mem::take(self);
         result.set_not_heap_allocated();
         result
@@ -3961,8 +3924,8 @@ pub enum FormDataEntry<'a> {
     },
 }
 
-/// Carries `Function(ctx, bytes)` at the type level — Zig's
-/// `comptime Function: anytype` becomes a trait impl so `run` can be taken as a
+/// Carries `Function(ctx, bytes)` at the type level —
+/// a trait impl so `run` can be taken as a
 /// plain `fn(*mut c_void, ReadFileResultType)` thunk, monomorphized per `(C, F)`.
 pub trait InternalReadFileFn<C> {
     fn call(ctx: *mut C, bytes: read_file::ReadFileResultType);
@@ -3975,11 +3938,10 @@ where
     F: InternalReadFileFn<C>,
 {
     /// Type-erased thunk: `handler` is the `*mut C` ctx that was passed into
-    /// `ReadFile`/`ReadFileUV` cast to `*anyopaque`. Mirrors Zig
-    /// `Function(bun.cast(Context, handler), bytes)`.
+    /// `ReadFile`/`ReadFileUV` cast to `*mut c_void`.
     pub fn run(handler: *mut c_void, bytes: read_file::ReadFileResultType) {
-        // SAFETY: every call site passes a `*mut C` (Zig `*Handler`) round-tripped
-        // through `*anyopaque`; `bun.cast` is the inverse pointer cast.
+        // SAFETY: every call site passes a `*mut C` round-tripped
+        // through `*mut c_void`; this is the inverse pointer cast.
         F::call(handler.cast::<C>(), bytes);
     }
 }
@@ -3990,9 +3952,8 @@ where
 
 /// Stack-local helper for `Blob::from_dom_form_data`. `boundary` borrows the
 /// caller's `hex_buf` and `global_this` borrows the incoming `&JSGlobalObject`;
-/// both strictly outlive this struct (Zig spec: `[]const u8` / non-optional
-/// `*jsc.JSGlobalObject`), so they are stored as plain references rather than
-/// raw pointers.
+/// both strictly outlive this struct, so they are stored as plain references
+/// rather than raw pointers.
 struct FormDataContext<'a> {
     joiner: StringJoiner<'a>,
     boundary: &'a [u8], // borrowed; outlives the joiner
@@ -4023,8 +3984,7 @@ fn escape_form_data_name(bytes: &[u8]) -> Option<Box<[u8]>> {
 impl FormDataContext<'_> {
     /// Append the UTF-8 view of a form-data string without copying it: the
     /// borrowed case points into a WTF string owned by the `DOMFormData` being
-    /// serialized, which outlives `joiner.done()` in `from_dom_form_data`
-    /// (Zig: `joiner.push(slice, slice.allocator.get())`); an owned slice
+    /// serialized, which outlives `joiner.done()` in `from_dom_form_data`; an owned slice
     /// (UTF-16 / non-ASCII Latin-1 conversion) transfers its allocation to the
     /// joiner. When `escape` is set, `"`/CR/LF are percent-encoded into a copy.
     fn push_string_slice(joiner: &mut StringJoiner<'_>, slice: ZigStringSlice, escape: bool) {
@@ -4076,7 +4036,7 @@ impl FormDataContext<'_> {
                 joiner.push_static(b"\"\r\n");
 
                 // Borrowed from the blob, which the `DOMFormData` keeps alive
-                // past `joiner.done()` (Zig used `pushStatic` here too).
+                // past `joiner.done()`.
                 let blob_ct = blob.content_type_slice();
                 let content_type: &[u8] = if !blob_ct.is_empty()
                     && !blob_ct.iter().any(|&b| matches!(b, b'\r' | b'\n'))
@@ -4108,11 +4068,9 @@ impl FormDataContext<'_> {
                         }
                         store::Data::File(file) => {
                             // TODO: make this async + lazy
-                            // PORT NOTE (layering): Zig used the per-VM cached
-                            // `globalThis.bunVM().nodeFS()`. That accessor is not
-                            // yet ported on `VirtualMachine`, so use a fresh stack
+                            // Use a fresh stack
                             // `NodeFS` (it is stateless aside from a path scratch
-                            // buffer; the per-VM cache is purely a perf reuse).
+                            // buffer; a per-VM cache would be purely a perf reuse).
                             let mut node_fs = crate::node::fs::NodeFS::default();
                             // `ReadFile` has `Drop`; can't use FRU `..Default::default()`.
                             let mut rf_args = crate::node::fs::args::ReadFile::default();
@@ -4130,8 +4088,7 @@ impl FormDataContext<'_> {
                                 Ok(mut result) => {
                                     joiner.push_cloned(result.slice());
                                     // StringOrBuffer::Drop is a no-op for Buffer; release
-                                    // the readFile allocation explicitly (Zig handed its
-                                    // allocator to the joiner instead).
+                                    // the readFile allocation explicitly.
                                     if let crate::node::types::StringOrBuffer::Buffer(buf) =
                                         &mut result
                                     {
@@ -4143,7 +4100,7 @@ impl FormDataContext<'_> {
                         store::Data::Bytes(_) => {
                             // SAFETY: borrowed from the blob's store, which the
                             // `DOMFormData` entry keeps alive until after
-                            // `joiner.done()` (Zig used `pushStatic` here too).
+                            // `joiner.done()`.
                             joiner.push(unsafe { bun_ptr::detach_lifetime(blob.shared_view()) });
                         }
                     }
@@ -4165,8 +4122,8 @@ impl FormDataContext<'_> {
 
 struct StructuredCloneWriter {
     ctx: *mut c_void,
-    // callconv(jsc.conv) — codegen `WriteBytesFn` cfg-splits to `"sysv64"`
-    // on Windows-x64, `"C"` elsewhere.
+    // JSC host-fn calling convention: codegen `WriteBytesFn` cfg-splits to
+    // `"sysv64"` on Windows-x64, `"C"` elsewhere.
     impl_: crate::generated_classes::WriteBytesFn,
 }
 
@@ -4179,8 +4136,7 @@ impl StructuredCloneWriter {
     }
 }
 
-// Zig used std.Io.GenericWriter over StructuredCloneWriter; map onto
-// `bun_io::Write` so `write_int_le` / `write_all` work directly.
+// Implement `bun_io::Write` so `write_int_le` / `write_all` work directly.
 impl bun_io::Write for StructuredCloneWriter {
     fn write_all(&mut self, bytes: &[u8]) -> Result<(), bun_core::Error> {
         StructuredCloneWriter::write(self, bytes);
@@ -4188,9 +4144,9 @@ impl bun_io::Write for StructuredCloneWriter {
     }
 }
 
-// Only ever called with f64 (Blob.last_modified). Zig generic `comptime FloatType`
-// collapses to a concrete impl here because Rust forbids `[u8; size_of::<F>()]`
-// without `generic_const_exprs`. `@bitCast` → native-endian bytes.
+// Only ever called with f64 (Blob.last_modified). A concrete impl
+// because Rust forbids `[u8; size_of::<F>()]`
+// without `generic_const_exprs`. Bit-cast → native-endian bytes.
 fn write_float<W: bun_io::Write>(value: f64, writer: &mut W) -> Result<(), bun_core::Error> {
     writer.write_all(&value.to_ne_bytes())
 }
@@ -4228,7 +4184,7 @@ fn _on_structured_clone_deserialize<B: AsRef<[u8]>>(
     let mut content_type = read_slice(reader, content_type_len as usize)?;
     // Ownership transfers to `blob.content_type` at the end of the success
     // path below; until then `content_type`'s Drop is responsible for it.
-    // (errdefer → automatic Drop on `?`.)
+    // (error cleanup is automatic Drop on `?`.)
 
     let content_type_was_set: bool = reader.read_int_le::<u8>()? != 0;
 
@@ -4262,7 +4218,7 @@ fn _on_structured_clone_deserialize<B: AsRef<[u8]>>(
                         bytes_store.stored_name = name.into_boxed_slice();
                     }
                 }
-                // else: `name` drops here (Zig: `if (!consumed) free(name)`).
+                // else: `name` drops here.
 
                 if version == 2 {
                     break 'versions;
@@ -4291,8 +4247,7 @@ fn _on_structured_clone_deserialize<B: AsRef<[u8]>>(
                 PathOrFileDescriptorSerializeTag::Path => {
                     let path_len = reader.read_int_le::<u32>()?;
                     let path = read_slice(reader, path_len as usize)?;
-                    // Zig heap-allocates `path` and hands the allocation to
-                    // the store (freed by `Store.deinit`). The owned `CowSlice`
+                    // The owned `CowSlice`
                     // adopts the `Box<[u8]>` so the store frees it in
                     // `PathLike::drop`; borrowing here would drop `path` at scope
                     // end and leave the store dangling.
@@ -4413,7 +4368,7 @@ pub extern "C" fn Blob__setAsFile(this: &mut Blob, path_str: &mut BunString) {
     if let Some(store) = this.store() {
         if let store::Data::Bytes(bytes) = &mut store.data_mut() {
             if bytes.stored_name.is_empty() {
-                // Zig: `path_str.toUTF8Bytes(allocator)` → owned heap slice
+                // Owned heap slice
                 // owned by `stored_name` (`Box<[u8]>`) and freed by `Bytes::Drop`.
                 bytes.stored_name = path_str.to_owned_slice().into_boxed_slice();
             }
@@ -4477,7 +4432,6 @@ pub fn mkdir_if_not_exists<T: MkdirpTarget>(
     err_path: &[u8],
 ) -> Retry {
     if err.get_errno() == bun_sys::E::ENOENT && this.mkdirp_if_not_exists() {
-        // Zig: `std.fs.path.dirname(path_string)` → `bun_core::dirname` (Option-returning).
         if let Some(dirname) = bun_core::dirname(path_string.as_bytes()) {
             let mut node_fs = node::fs::NodeFS::default();
             match node_fs.mkdir_recursive(&node::fs::args::Mkdir {
@@ -4504,10 +4458,10 @@ pub fn mkdir_if_not_exists<T: MkdirpTarget>(
     Retry::No
 }
 
-/// Local shim for Zig's `bun.sys.Error.withPathLike` — `bun_sys::Error` only
-/// exposes `with_path(&[u8])` on the Rust side, so route through the
+/// `bun_sys::Error` only
+/// exposes `with_path(&[u8])`, so route through the
 /// `PathOrFileDescriptor`'s slice when it's a path and leave the error
-/// unchanged for fds (matching Zig, which formats the fd into the message).
+/// unchanged for fds.
 #[inline]
 fn sys_error_with_path_like(
     err: &bun_sys::Error,
@@ -4519,8 +4473,8 @@ fn sys_error_with_path_like(
     }
 }
 
-/// Trait extracted from the Zig `anytype` receiver of `mkdir_if_not_exists`.
-/// The Zig body uses `@hasField` to optionally write `errno` / `opened_fd`.
+/// Receiver trait for `mkdir_if_not_exists`; impls optionally
+/// write `errno` / `opened_fd` via the defaulted setters.
 pub trait MkdirpTarget {
     fn mkdirp_if_not_exists(&self) -> bool;
     fn set_mkdirp_if_not_exists(&mut self, v: bool);
@@ -4553,7 +4507,7 @@ fn write_file_with_empty_source_to_destination(
         .store()
         .expect("infallible: store present")
         .clone();
-    // PORT NOTE: `scopeguard::guard(&mut *destination_blob, …)` would hold an
+    // `scopeguard::guard(&mut *destination_blob, …)` would hold an
     // exclusive borrow for the entire function, blocking the immut reads below
     // (`content_type_or_mime_type`). Capture a raw pointer instead — the
     // `&mut Blob` parameter outlives this stack frame, and the closure runs
@@ -4568,7 +4522,7 @@ fn write_file_with_empty_source_to_destination(
             // TODO: make this async
             // `VirtualMachine::node_fs()` currently returns `*mut c_void`; the
             // typed `&mut NodeFS` accessor isn't wired yet, so use a fresh
-            // `NodeFS` (matches Zig — it carries no per-call state for
+            // `NodeFS` (it carries no per-call state for
             // `truncate`/`mkdir_recursive`).
             let mut node_fs = node::fs::NodeFS::default();
             let mut result = node_fs.truncate(
@@ -4601,7 +4555,6 @@ fn write_file_with_empty_source_to_destination(
                                 }
                                 let dirpath: &[u8] = match &file.pathlike {
                                     PathOrFileDescriptor::Path(path) => {
-                                        // Zig: `std.fs.path.dirname` — Option-returning.
                                         match bun_core::dirname(path.slice()) {
                                             Some(d) => d,
                                             None => break 'err,
@@ -4646,7 +4599,7 @@ fn write_file_with_empty_source_to_destination(
                                         break 'err;
                                     }
                                     bun_sys::Result::Ok(f) => {
-                                        let _ = f.close(); // close error is non-actionable (Zig parity: discarded)
+                                        let _ = f.close(); // close error is non-actionable
                                         return Ok(JSPromise::resolved_promise_value(
                                             ctx,
                                             JSValue::js_number(0.0),
@@ -4783,8 +4736,8 @@ pub fn write_file_with_source_destination(
             global_this: ctx,
         }));
 
-        // Zig passes `destination_blob.*` / `source_blob.*` (raw struct copy,
-        // +0 store ref) and `WriteFile.create` then calls `store.?.ref()`.
+        // The borrowed views below are +0 on the store ref;
+        // `WriteFile::create` takes its own ref.
         #[cfg(windows)]
         {
             let promise = JSPromise::create(ctx);
@@ -4821,9 +4774,8 @@ pub fn write_file_with_source_destination(
             .expect("unreachable");
             let task = write_file_mod::WriteFileTask::create_on_js_thread(ctx, file_copier);
             // Defer promise creation until we're just about to schedule the task.
-            // PORT NOTE: Zig wrote `promise.strong.set(ctx, promise_value)` directly;
             // `JSPromiseStrong.strong` is private in `bun_jsc`, so use `init` (which
-            // creates the JSPromise *and* the strong handle in one step) instead.
+            // creates the JSPromise *and* the strong handle in one step).
             // SAFETY: write_file_promise was just produced by heap::alloc above; sole owner.
             unsafe { (*write_file_promise).promise = jsc::JSPromiseStrong::init(ctx) };
             // SAFETY: same `write_file_promise` as above; still solely owned here.
@@ -4859,7 +4811,6 @@ pub fn write_file_with_source_destination(
                 options.mode,
             );
             file_copier.schedule();
-            // PORT NOTE: Zig returned `file_copier.promise.value()` directly.
             // `ConcurrentPromiseTask` is consumed by the work-pool and freed via
             // `ManualDeinit` → `destroy(*mut Self)`, so hand ownership over as a
             // raw pointer (paired with `heap::take` in `destroy()`).
@@ -5092,7 +5043,7 @@ pub fn write_file_internal(
             "Bun.write(pathOrFdOrBlob, blob) expects a Blob-y thing to write"
         )));
     }
-    // PORT NOTE: Zig copies `path_or_blob_.*`; Blob is non-Clone, so reborrow.
+    // Blob is non-Clone, so reborrow.
     let path_or_blob = &mut *path_or_blob_;
     if let PathOrBlob::Blob(ref blob) = *path_or_blob {
         let Some(blob_store) = blob.store.get() else {
@@ -5111,7 +5062,7 @@ pub fn write_file_internal(
     } else {
         None
     };
-    // PORT NOTE: Zig manually ref/deref's; StoreRef clone+drop achieves the same.
+    // StoreRef clone+drop keeps the store alive for the duration of this call.
     let _input_store_hold = input_store;
 
     if let Some(mkdir) = options.mkdirp_if_not_exists {
@@ -5144,8 +5095,7 @@ pub fn write_file_internal(
             if data.is_string() {
                 let len = data.get_length(global_this)?;
                 if len < 256 * 1024 {
-                    // +1 WTF ref; `OwnedString` releases it on scope exit
-                    // (Zig: `defer str.deref()`).
+                    // +1 WTF ref; `OwnedString` releases it on scope exit.
                     let str = OwnedString::new(data.to_bun_string(global_this)?);
                     let pathlike: PathOrFileDescriptor = match &*path_or_blob {
                         PathOrBlob::Path(p) => p.clone(),
@@ -5230,9 +5180,8 @@ pub fn write_file_internal(
 
     // TODO: implement a writev() fast path
     let source_blob: Blob = 'brk: {
-        // PORT NOTE: Zig has two near-identical arms for `Response` and
-        // `Request`. Both expose `get_body_value()` /
-        // `get_body_readable_stream()`; collapse into one helper that takes the
+        // `Response` and `Request` both expose `get_body_value()` /
+        // `get_body_readable_stream()`; one helper takes the
         // body-value pointer and a `get_stream` closure.
         let mut body_dispatch =
             |body_value: *mut webcore::body::Value,
@@ -5321,7 +5270,7 @@ pub fn write_file_internal(
                         let task =
                             bun_core::heap::into_raw(Box::new(WriteFileWaitFromLockedValueTask {
                                 global_this: bun_ptr::BackRef::new(global_this),
-                                // Zig moves `destination_blob` by value into the task
+                                // Move `destination_blob` by value into the task.
                                 file_blob: core::mem::replace(
                                     &mut destination_blob,
                                     Blob::init_empty(global_this),
@@ -5367,11 +5316,11 @@ pub fn write_file_internal(
 
         break 'brk Blob::get::<false, false>(global_this, data)?;
     };
-    // Zig: `defer source_blob.detach();`
+    // Detach the source blob on scope exit.
     let mut source_blob = scopeguard::guard(source_blob, |b| b.detach());
 
     let destination_store = destination_blob.store.get().clone();
-    // PORT NOTE: Zig manually ref/deref's; StoreRef clone+drop covers this.
+    // StoreRef clone+drop keeps the destination store alive across the call.
     let _dest_hold = destination_store;
 
     write_file_with_source_destination(
@@ -5505,8 +5454,7 @@ fn write_string_to_file_fast<const NEEDS_OPEN: bool>(
     // Declared before the truncate guard so it drops *after* it (close runs last).
     let _close = NEEDS_OPEN.then(|| bun_sys::CloseOnDrop::new(fd));
 
-    // PORT NOTE: Zig used `defer` which can read locals at unwind time.
-    // Rust scopeguard's closure captures borrows at construction, conflicting
+    // scopeguard's closure captures borrows at construction, conflicting
     // with later `written += ...` / `truncate = false`. Route through `Cell`
     // so the guard and the loop body share `&Cell<_>` (no mutable-borrow conflict).
     let truncate = core::cell::Cell::new(NEEDS_OPEN || str.is_empty());
@@ -5678,8 +5626,8 @@ pub fn jsdom_file_construct_(
     }
     {
         use bun_jsc::StringJsc as _;
-        // +1 WTF ref; `OwnedString` releases it at scope exit (Zig:
-        // `defer name_value_str.deref()`). Every consumer below either
+        // +1 WTF ref; `OwnedString` releases it at scope exit.
+        // Every consumer below either
         // copies bytes (`to_owned_slice`) or takes its own ref (`dupe_ref`).
         let name_value_str = OwnedString::new(BunString::from_js(args[1], global_this)?);
 
@@ -5804,14 +5752,14 @@ pub fn construct_bun_file(
 
     if let PathOrFileDescriptor::Path(ref p) = path {
         if p.slice().starts_with(b"s3://") {
-            // PORT NOTE (layering): `webcore::node_types::PathLike` re-exports
+            // `webcore::node_types::PathLike` re-exports
             // `crate::node::types::PathLike`, so no conversion is needed —
-            // clone the path (Zig consumed it; the Rust `path` drops at scope exit).
+            // clone the path (`path` drops at scope exit).
             return S3File::construct_internal_js(global_object, p.clone(), options);
         }
     }
-    // PORT NOTE: Zig `defer path.deinitAndUnprotect()` — sync path took no
-    // `protect()`, so `Drop for PathOrFileDescriptor` suffices.
+    // The sync path took no `protect()`, so `Drop for PathOrFileDescriptor`
+    // suffices to release `path`.
 
     let blob = Blob::find_or_create_file_from_path(&mut path, global_object, false);
 
@@ -5878,10 +5826,9 @@ pub fn to_stream_with_offset(
     )
 }
 
-// Zig doesn't let you pass a function with a comptime argument to a
-// runtime-known function. In Rust the comptime `Lifetime` collapses to a
+// The `Lifetime` collapses to a
 // captured constant inside `JSPromise::wrap`'s `FnOnce(&JSGlobalObject)`, so
-// the dedicated `lifetimeWrap` helper from Zig is folded into each call site.
+// no dedicated wrap helper is needed at each call site.
 
 // ──────────────────────────────────────────────────────────────────────────
 // S3BlobDownloadTask
@@ -6063,7 +6010,7 @@ pub struct FileStreamWrapper {
     pub readable_stream_ref: webcore::readable_stream::ReadableStreamStrong,
     // LIFETIMES.tsv: SHARED — but FileSink uses an intrusive single-thread refcount
     // (`ref_`/`deref`) and crosses FFI as a raw pointer, so this stays `*mut`
-    // rather than `Arc<T>` (matches Zig `sink: *jsc.WebCore.FileSink`).
+    // rather than `Arc<T>`.
     pub sink: *mut webcore::FileSink,
 }
 
@@ -6096,9 +6043,8 @@ pub fn on_file_stream_reject_request_stream(
     callframe: &CallFrame,
 ) -> JsResult<JSValue> {
     let args = callframe.arguments_old::<2>();
-    // PORT NOTE: Zig defers `this.sink.deref()` here but does NOT call `this.deinit()`
-    // (leaks the wrapper). We take ownership via Box so Drop runs `sink.deref()`
-    // and frees the wrapper — same observable effect on the sink, fixes the leak.
+    // Take ownership via Box so Drop runs `sink.deref()`
+    // and frees the wrapper.
     // SAFETY: the trailing argument is the `FileStreamWrapper*` boxed and passed
     // through `then()` from the resolve path; we are the sole consumer here.
     let mut this: Box<FileStreamWrapper> = unsafe {
@@ -6116,9 +6062,9 @@ pub fn on_file_stream_reject_request_stream(
     Ok(JSValue::UNDEFINED)
 }
 
-// C-ABI shims for `JSValue::then` (mirrors Zig `toJSHostFn`). The Rust-side
+// C-ABI shims for `JSValue::then`. The Rust-side
 // host fns above are `JSHostFnZig`; `then()` wants the raw `JSHostFn` shape.
-// Exported under the Zig `@export` names so C++ (`BunPromiseInlines.h`) links
+// Exported under the legacy symbol names so C++ (`BunPromiseInlines.h`) links
 // the same symbol it does today.
 bun_jsc::jsc_host_abi! {
     #[unsafe(export_name = "Bun__FileStreamWrapper__onResolveRequestStream")]
@@ -6147,15 +6093,11 @@ bun_jsc::jsc_host_abi! {
     }
 }
 
-// PORT NOTE: the local `AnyPromiseResultExt` shim was removed —
+// the local `AnyPromiseResultExt` shim was removed —
 // `bun_jsc::AnyPromise::result` is an inherent method (and `JSInternalPromise`
 // is a transparent alias for `JSPromise`), so the `.result(vm)` call below
 // resolves directly upstream.
 
-// TODO(port): @export of jsc::to_js_host_fn wrappers under
-// "Bun__FileStreamWrapper__onResolveRequestStream" / "...Reject..." names.
-// The `#[bun_jsc::host_fn]` attribute should support a `link_name = "..."` arg.
-
 // ──────────────────────────────────────────────────────────────────────────
 // getSliceFrom / getSlice / type/name/lastModified/size getters
 // ──────────────────────────────────────────────────────────────────────────
@@ -6347,13 +6289,13 @@ pub use crate::webcore::Lifetime as BlobLifetime;
 // `bun_jsc`. Only Blob-local extension traits remain here.
 // ──────────────────────────────────────────────────────────────────────────
 mod zigstring_blob_ext {
-    /// Local shim for `ZigString.Slice` allocator-identity queries that the
-    /// `bun_core::ZigStringSlice` enum collapsed away. Used by
+    /// Local shim for allocator-identity queries on
+    /// `bun_core::ZigStringSlice`. Used by
     /// `from_js_without_defer_gc` to decide whether a converted slice was
     /// freshly heap-allocated (=> may contain non-ASCII UTF-8) or is a
     /// borrowed WTF Latin-1 view (=> already known ASCII-safe).
     pub(super) trait ZigStringSliceBlobExt {
-        /// Zig `slice.isWTFAllocator()` — true iff the bytes are backed by a
+        /// True iff the bytes are backed by a
         /// `WTF::StringImpl` ref (i.e. no UTF-8 transcoding happened).
         fn is_wtf_backed(&self) -> bool;
     }
@@ -6387,7 +6329,7 @@ impl Drop for TemporaryBytes {
     }
 }
 
-// Marker types for the comptime fn dispatch through do_read_file/do_read_from_s3.
+// Marker types for static fn dispatch through do_read_file/do_read_from_s3.
 // Each implements `ReadFileToJs` so a plain fn-pointer monomorphizes per `*WithBytes` body.
 pub struct ToStringWithBytesFn;
 pub struct ToJsonWithBytesFn;
@@ -6482,7 +6424,7 @@ impl read_file::ReadFileToJs for ToFormDataWithBytesFn {
 // Any (AnyBlob)
 // ──────────────────────────────────────────────────────────────────────────
 
-// Mirrors Zig's `AnyBlob` tagged union and is constructed/matched by-value
+// Constructed/matched by-value
 // across many crates (spawn stdio, shell, ReadableStream, DevServer, fetch);
 // boxing the `Blob` arm would change the public ABI in all of them.
 #[allow(clippy::large_enum_variant)]
@@ -6582,7 +6524,7 @@ impl Any {
                 if matches!(s.data, store::Data::Bytes(_)) && s.has_one_ref() {
                     // `StoreRef` exposes interior-mutable `data_mut()` (no DerefMut).
                     let internal = s.data_mut().as_bytes_mut().to_internal_blob();
-                    // PORT NOTE: Zig deref's the store; StoreRef::drop on replace handles it.
+                    // StoreRef::drop on the replace below releases the store ref.
                     blob.free_content_type();
                     *self = Any::InternalBlob(internal);
                     return;
@@ -6644,7 +6586,7 @@ impl Any {
         action: streams::BufferActionTag,
     ) -> Result<JSValue, jsc::JsTerminated> {
         // `JSPromise::wrap` takes a `FnOnce(&JSGlobalObject) -> JsResult<JSValue>`;
-        // capture `self`/`action` in the closure (Zig threaded an args tuple).
+        // capture `self`/`action` in the closure.
         JSPromise::wrap(global_this, |g| self.to_action_value(g, action))
     }
 
@@ -6654,8 +6596,6 @@ impl Any {
         global_this: &JSGlobalObject,
         action: streams::BufferActionTag,
     ) -> Result<(), jsc::JsTerminated> {
-        // Zig: `promise.wrap(globalThis, toActionValue, .{ this, globalThis, action })`.
-        //
         // Must route through `AnyPromise::wrap` (NOT open-coded resolve/reject):
         // it opens a `top_scope!` and calls `to_action_value` via
         // `JSC__AnyPromise__wrap` → `to_js_host_call`, so the C++ ThrowScope inside
@@ -6684,7 +6624,7 @@ impl Any {
             }
             Any::WTFStringImpl(impl_) => {
                 // Adopts a +1 WTF ref; `OwnedString` releases it on every exit
-                // path (Zig: `defer str.deref()`).
+                // path.
                 let mut str = OwnedString::new(BunString::adopt_wtf_impl(core::mem::replace(
                     impl_,
                     core::ptr::null_mut(),
@@ -6752,8 +6692,7 @@ impl Any {
                 Ok(owned)
             }
             Any::WTFStringImpl(impl_) => {
-                // Adopts a +1 WTF ref; `OwnedString` releases it on scope exit
-                // (Zig: `defer str.deref()`).
+                // Adopts a +1 WTF ref; `OwnedString` releases it on scope exit.
                 let str = OwnedString::new(BunString::adopt_wtf_impl(core::mem::replace(
                     impl_,
                     core::ptr::null_mut(),
@@ -6799,8 +6738,7 @@ impl Any {
             }
             Any::WTFStringImpl(impl_) => {
                 // Adopts a +1 WTF ref; `OwnedString` releases it on scope exit,
-                // after `out_bytes` (which borrows it) is consumed below
-                // (Zig: `defer str.deref()`).
+                // after `out_bytes` (which borrows it) is consumed below.
                 let str = OwnedString::new(BunString::adopt_wtf_impl(core::mem::replace(
                     impl_,
                     core::ptr::null_mut(),
@@ -6832,7 +6770,7 @@ impl Any {
 
 impl Any {
     pub fn store(&self) -> Option<&Store> {
-        // Spec (Blob.zig:4651-4657) returns a borrow with no refcount change.
+        // Returns a borrow with no refcount change.
         if let Any::Blob(b) = self {
             return b.store.get().as_deref();
         }
@@ -6842,7 +6780,7 @@ impl Any {
     pub fn content_type(&self) -> &[u8] {
         match self {
             Any::Blob(b) => b.content_type_slice(),
-            // PORT NOTE: MimeType::TEXT is `const` — see Internal::content_type.
+            // MimeType::TEXT is `const` — see Internal::content_type.
             Any::WTFStringImpl(_) => b"text/plain;charset=utf-8",
             Any::InternalBlob(ib) => ib.content_type(),
         }
@@ -6941,7 +6879,7 @@ impl Internal {
             return Ok(return_value);
         } else if bytes_without_bom.len() != self.bytes.len() {
             // If there was a UTF8 BOM, we clone it.
-            // +1 WTF ref; `OwnedString` releases it on scope exit (Zig: `defer out.deref()`).
+            // +1 WTF ref; `OwnedString` releases it on scope exit.
             let out = OwnedString::new(BunString::clone_latin1(&self.bytes[3..]));
             self.bytes = Vec::new();
             return out.to_js(global_this);
@@ -6985,7 +6923,7 @@ impl Internal {
     }
 
     pub fn content_type(&self) -> &'static [u8] {
-        // PORT NOTE: MimeType::{TEXT,OTHER} are `const` (not `static`), so
+        // MimeType::{TEXT,OTHER} are `const` (not `static`), so
         // borrowing `.value` would borrow a temporary. Inline the literals
         // (matches `MimeType::init_comptime` values).
         if self.was_string {
@@ -7012,8 +6950,8 @@ pub type InlineIntSize = u8;
 
 impl Inline {
     const REAL_BLOB_SIZE: usize = core::mem::size_of::<Blob>();
-    // PORT NOTE: Zig `pub const IntSize = u8` — inherent assoc types are nightly-only;
-    // hoisted to module-level `InlineIntSize` above.
+    // Inherent assoc types are nightly-only;
+    // the int-size alias is hoisted to module-level `InlineIntSize` above.
     pub const AVAILABLE_BYTES: usize = Self::REAL_BLOB_SIZE - core::mem::size_of::<u8>() - 1 - 1;
 
     pub fn concat(first: &[u8], second: &[u8]) -> Inline {
@@ -7073,7 +7011,7 @@ impl Inline {
     }
 
     pub fn content_type(&self) -> &'static [u8] {
-        // PORT NOTE: see Internal::content_type — MimeType consts are `const`, not `static`.
+        // see Internal::content_type — MimeType consts are `const`, not `static`.
         if self.was_string {
             b"text/plain;charset=utf-8"
         } else {
@@ -7135,9 +7073,8 @@ bun_jsc::jsc_host_abi! {
 // ──────────────────────────────────────────────────────────────────────────
 
 // TODO: move to bun_sys?
-/// Generic file-open helper used by ReadFile/WriteFile/CopyFile state machines.
-/// In Zig this is a `fn(comptime This: type) type` that adds methods over `*This`.
-/// In Rust we model it as a trait the target implements.
+/// Generic file-open helper used by ReadFile/WriteFile/CopyFile state machines,
+/// modeled as a trait the target implements.
 pub trait FileOpener: Sized {
     /// Override if you need different open flags; defaults to RDONLY.
     const OPEN_FLAGS: i32 = bun_sys::O::RDONLY;
@@ -7149,11 +7086,10 @@ pub trait FileOpener: Sized {
     fn set_system_error(&mut self, e: jsc::SystemError);
     /// Either `self.file_store.pathlike` or `self.file_blob.store.data.file.pathlike`.
     fn pathlike(&self) -> &PathOrFileDescriptor;
-    /// Zig: `if (@hasField(This, "mkdirp_if_not_exists")) ... mkdirIfNotExists(...)`.
     /// Implementors that have a `mkdirp_if_not_exists` field (`WriteFile`,
     /// `CopyFile`) override this to call [`mkdir_if_not_exists`]; everyone else
     /// (e.g. `ReadFile`) keeps the default `Retry::No`, so the open path falls
-    /// straight through to the error branch as in the Zig spec.
+    /// straight through to the error branch.
     fn try_mkdirp(
         &mut self,
         _err: bun_sys::Error,
@@ -7167,8 +7103,7 @@ pub trait FileOpener: Sized {
     #[cfg(windows)]
     fn req(&mut self) -> &mut bun_libuv_sys::uv_fs_t;
     /// Stash/retrieve the open completion callback across the libuv async hop.
-    /// Zig captured this at comptime (`comptime Callback`) so the generated
-    /// `WrappedCallback` was monomorphic; Rust can't const-generic over fn
+    /// Rust can't const-generic over fn
     /// pointers, so the implementor stores it on `self` (e.g. next to `req`).
     #[cfg(windows)]
     fn set_open_callback(&mut self, cb: fn(&mut Self, Fd));
@@ -7187,7 +7122,7 @@ pub trait FileOpener: Sized {
         {
             use bun_sys::ReturnCodeExt as _;
             // Monomorphic libuv completion thunk — recovers `*mut Self` from
-            // `req.data`, mirrors Zig's `WrappedCallback.callback`.
+            // `req.data`.
             extern "C" fn wrapped_callback<S: FileOpener>(req: *mut bun_libuv_sys::uv_fs_t) {
                 use bun_sys::ReturnCodeExt as _;
                 // SAFETY: `req.data` was set to `self as *mut Self` below before
@@ -7233,8 +7168,7 @@ pub trait FileOpener: Sized {
             // Stash `self` on the request BEFORE dispatch. libuv never touches
             // `req.data`, so pre-setting is safe; doing it after `uv_fs_open`
             // is a UAF when the call fails synchronously and `callback` frees
-            // `self` (ReadFileUV::on_finish → finalize → heap::take). The Zig
-            // spec at Blob.zig:4956 has this ordering bug; we diverge to fix it.
+            // `self` (ReadFileUV::on_finish → finalize → heap::take).
             req.data = self_ptr.cast();
             // SAFETY: loop_/req are live for the duration of the async open;
             // req.data is consumed by `wrapped_callback::<Self>` above.
@@ -7278,7 +7212,6 @@ pub trait FileOpener: Sized {
                         break;
                     }
                     bun_sys::Result::Err(err) => {
-                        // Zig: `if (@hasField(This, "mkdirp_if_not_exists")) switch (mkdirIfNotExists(...)) { ... }`.
                         if err.get_errno() == bun_sys::E::ENOENT {
                             match self.try_mkdirp(err.clone(), path, path_string.slice()) {
                                 Retry::Continue => continue,
@@ -7363,9 +7296,8 @@ pub trait FileCloser: Sized {
     fn on_close_io_request(task: *mut bun_jsc::WorkPoolTask);
 
     fn do_close(&mut self, is_allowed_to_close_fd: bool) -> bool {
-        // PORT NOTE: Zig nests `if (@hasField(This, "io_request")) { if (this.close_after_io) … }`.
-        // `@hasField` is comptime (constant per concrete `Self`), so swapping the
-        // order is sound and lets us finish the immutable `self` reads before
+        // Check `close_after_io()` before `io_request()` so the immutable
+        // `self` reads finish before
         // taking the `&mut self` borrow via `io_request()`.
         if self.close_after_io() {
             self.state().store(
@@ -7373,7 +7305,6 @@ pub trait FileCloser: Sized {
                 core::sync::atomic::Ordering::SeqCst,
             );
             if let Some(io_request) = self.io_request() {
-                // Zig: `@atomicStore(?*const fn, &io_request.callback, scheduleClose, .seq_cst)`.
                 // The io thread reads `callback` after popping from its MPSC
                 // queue; a plain store here is a data race. `bun_io::Request::
                 // store_callback_seq_cst` lowers to a volatile write + SeqCst
@@ -7417,5 +7348,3 @@ pub mod external_shared_descriptor {
 /// struct into `bun_jsc::webcore_types`, so the canonical alias lives in
 /// `bun_jsc::bindgen`; re-export it here for `bun_runtime` callers.
 pub use bun_jsc::bindgen::BindgenBlob;
-
-// ported from: src/runtime/webcore/Blob.zig
diff --git a/src/runtime/webcore/Body.rs b/src/runtime/webcore/Body.rs
index 73e8cbb0a46..d255480c039 100644
--- a/src/runtime/webcore/Body.rs
+++ b/src/runtime/webcore/Body.rs
@@ -15,7 +15,7 @@ use crate::webcore::{
 };
 use bun_core::Output;
 use bun_http_types::MimeType::MimeType;
-// Re-export so callers can write `body::InternalBlob` (mirrors Zig nested-type access).
+// Re-export so callers can write `body::InternalBlob`.
 use crate::jsc::HTTPHeaderName;
 pub use crate::webcore::InternalBlob;
 use crate::webcore::form_data::AsyncFormDataExt as _;
@@ -45,7 +45,7 @@ pub(super) fn wtf_impl(s: &WTFStringImpl) -> &WTFStringImplStruct {
 /// Mutable view of a [`Blob`]'s backing `Store` through its
 /// `JsCell<Option<StoreRef>>` field. Centralises the per-site raw
 /// `(*blob.store.get()…as_ptr()).mime_type = …` deref under the same
-/// invariant `StoreRef::data_mut` already documents: Zig-semantics
+/// invariant `StoreRef::data_mut` already documents:
 /// shared-mutable interior, single-threaded JS event-loop, no concurrent
 /// `&Store` outstanding for the borrow's duration.
 #[inline]
@@ -109,7 +109,6 @@ bun_core::declare_scope!(BodyValue, visible);
 bun_core::declare_scope!(BodyMixin, visible);
 bun_core::declare_scope!(BodyValueBufferer, visible);
 
-// TODO(port): `bun.JSTerminated!T` is a narrower error set than `bun.JSError`; using JsResult for now.
 type JsTerminated<T> = jsc::JsResult<T>;
 
 // R-2 (host-fn re-entrancy): `Body` is embedded inline in JS-exposed
@@ -211,7 +210,7 @@ impl Body {
                 blob.write_format::<F, W, ENABLE_ANSI_COLORS>(formatter, writer)?;
             }
             v @ (Value::InternalBlob(_) | Value::WTFStringImpl(_)) => {
-                // Zig calls `this.value.size()` *inside* this arm only — do not hoist:
+                // Do not hoist a generic `self.value.size()` call out of this arm:
                 // for `.Blob` it would stat the file, for `.Locked` it would deref the
                 // global. Compute the size from the matched payload directly.
                 let size = match v {
@@ -246,7 +245,7 @@ impl Body {
     }
 }
 
-// TODO(port): not a clean Drop — Value::reset mutates self to Null/Used and is called explicitly
+// Not a clean Drop — Value::reset mutates self to Null/Used and is called explicitly
 // at specific protocol points (e.g. resolve()). PORTING.md forbids `pub fn deinit(&mut self)`;
 // renamed to `reset()` since it cannot take `self` by value (in-place state transition).
 impl Body {
@@ -264,7 +263,7 @@ pub struct PendingValue {
     pub readable: webcore::readable_stream::Strong,
     // writable: webcore::Sink
 
-    // PORT NOTE: LIFETIMES.tsv JSC_BORROW → `&JSGlobalObject`, but `Value::Locked`
+    // LIFETIMES.tsv JSC_BORROW → `&JSGlobalObject`, but `Value::Locked`
     // is stored on heap (Body in Request/Response m_ctx). Dropped the `<'a>`
     // lifetime per PORTING.md §Type map (no lifetime params on structs);
     // raw ptr until we pick `&'static` vs a JSC handle.
@@ -297,8 +296,8 @@ impl PendingValue {
 }
 
 impl Default for PendingValue {
-    /// PORT NOTE: Zig requires `global` to be set; callers using `..Default::default()`
-    /// must initialize `global` explicitly. Null here is the only viable Rust default.
+    /// Callers using `..Default::default()` must initialize `global`
+    /// explicitly. Null here is the only viable default.
     fn default() -> Self {
         Self {
             promise: None,
@@ -477,8 +476,7 @@ impl Action {
     }
 }
 
-/// Tag-only equality (mirrors Zig union-tag comparison `action != .none`).
-/// `GetFormData` payload is ignored.
+/// Tag-only equality. `GetFormData` payload is ignored.
 impl PartialEq for Action {
     fn eq(&self, other: &Self) -> bool {
         core::mem::discriminant(self) == core::mem::discriminant(other)
@@ -488,9 +486,6 @@ impl PartialEq for Action {
 /// Per-class codegen'd cached-slot accessors for the `body` and `stream`
 /// JS-side properties, plus the weak `JsRef` back-pointer. Both `Request` and
 /// `Response` forward these 1:1 to `bun_jsc::generated::JS{Request,Response}`.
-///
-/// Replaces Zig's `T.js.bodyGetCached` / `T.js.gc.stream.{get,set,clear}` /
-/// `this.#js_ref.tryGet()` comptime duck-typing.
 pub(crate) trait BodyOwnerJs {
     /// `self.js_ref.get().try_get()` — the live JS wrapper, if any.
     fn js_ref(&self) -> Option<JSValue>;
@@ -508,8 +503,8 @@ pub(crate) trait BodyOwnerJs {
 /// This is a duplex stream!
 #[derive(bun_core::EnumTag)]
 #[enum_tag(existing = Tag)]
-// Mirrors the Zig `Body.Value` union and is pooled inline in `HiveRef` slots; boxing
-// `Blob` would change construction/match sites across many files and defeat the pool.
+// Pooled inline in `HiveRef` slots; boxing `Blob` would change
+// construction/match sites across many files and defeat the pool.
 #[allow(clippy::large_enum_variant)]
 pub enum Value {
     Blob(Blob),
@@ -544,9 +539,9 @@ pub enum Value {
     ///     })
     ///
     /// This works for .json(), too.
-    // PORT NOTE: `bun_core::WTFStringImpl` = `*mut WTFStringImplStruct` — a Copy raw
+    // `bun_core::WTFStringImpl` = `*mut WTFStringImplStruct` — a Copy raw
     // pointer to an *intrusively* refcounted WTF::StringImpl. We hold the +1 directly
-    // (no Arc) and ref/deref explicitly at the same points Zig does (from_js / clone /
+    // (no Arc) and ref/deref explicitly at fixed points (from_js / clone /
     // use_ / to_blob_if_possible / reset / use_as_any_blob*).
     WTFStringImpl(WTFStringImpl),
     /// Single-use Blob
@@ -570,8 +565,8 @@ pub(crate) type HiveRef = bun_collections::HiveRef<Value, POOL_SIZE>;
 pub(crate) type HiveAllocator = bun_collections::hive_array::Fallback<HiveRef, POOL_SIZE>;
 pub(crate) type BodyHiveHandle = bun_collections::HiveRefHandle<Value, POOL_SIZE>;
 
-/// Spec `VirtualMachine.zig:255 initRequestBodyValue` — moves `value` into a
-/// pooled `HiveRef` slot and returns an owning handle (ref_count = 1).
+/// Moves `value` into a pooled `HiveRef` slot and returns an owning handle
+/// (ref_count = 1).
 pub(crate) fn hive_alloc(value: Value) -> BodyHiveHandle {
     let state = crate::jsc_hooks::runtime_state();
     debug_assert!(!state.is_null(), "hive_alloc before init_runtime_state");
@@ -595,8 +590,8 @@ pub enum Tag {
     Null,
 }
 
-// Mirrors the Zig `Body.Value.ValueError` union and is constructed/matched across
-// several modules; boxing `SystemError` would ripple through those callers.
+// Constructed/matched across several modules; boxing `SystemError` would
+// ripple through those callers.
 #[allow(clippy::large_enum_variant)]
 pub enum ValueError {
     AbortReason(CommonAbortReason),
@@ -610,12 +605,11 @@ pub enum ValueError {
 }
 
 impl ValueError {
-    // TODO(port): not a clean Drop — resets self to safe-empty in place. Renamed from `deinit`
+    // Not a clean Drop — resets self to safe-empty in place. Renamed from `deinit`
     // per PORTING.md (never expose `pub fn deinit(&mut self)`).
     pub fn reset(&mut self) {
         match self {
-            // PORT NOTE: Zig `system_error.deref()` released the bun.String
-            // fields; in Rust those are dropped by the assignment below.
+            // The bun.String fields are dropped by the assignment below.
             ValueError::SystemError(_system_error) => {}
             ValueError::Message(message) => message.deref(),
             ValueError::TypeError(message) => message.deref(),
@@ -669,9 +663,7 @@ impl ValueError {
     pub fn dupe(&self, global_object: &JSGlobalObject) -> Self {
         match self {
             // `.clone()` on BunString/SystemError already bumps the refcount (paired
-            // with their Drop deref). Zig did `var v = this.*; v.ref();` (bitwise copy
-            // + one bump) — `.clone()` alone is the Rust equivalent. An extra `.ref_()`
-            // here would leak +1 per dupe.
+            // with their Drop deref); an extra `.ref_()` here would leak +1 per dupe.
             ValueError::SystemError(e) => ValueError::SystemError(e.dupe()),
             ValueError::Message(m) => ValueError::Message(m.clone()),
             ValueError::TypeError(m) => ValueError::TypeError(m.clone()),
@@ -694,13 +686,12 @@ impl ValueError {
 impl Value {
     /// Downcast a `JSValue` to the `Body.Value` it owns, if any.
     ///
-    /// Port of the `Body.Value` special-case in `JSValue.as()` (JSValue.zig:449):
     /// `Body.Value` is not itself a JS class — it lives inside a `Request` or
     /// `Response` wrapper — so the generic `JSValue::as_::<T: JsClass>()` path
     /// cannot be used. Instead, try both wrapper classes and return the inner
     /// body pointer.
     ///
-    /// Returns a raw pointer (mirrors Zig `?*Body.Value`); the storage is owned
+    /// Returns a raw pointer; the storage is owned
     /// by the JSC heap cell and outlives the call only as long as `value` is
     /// kept alive by the caller.
     pub fn from_request_or_response(value: JSValue) -> Option<*mut Value> {
@@ -743,9 +734,8 @@ impl Value {
     pub fn to_blob_if_possible(&mut self) {
         if let Value::WTFStringImpl(str) = *self {
             if let Some(bytes) = wtf_impl(&str).to_utf8_if_needed() {
-                // Zig: `fromOwnedSlice(@constCast(bytes.slice()))` — the UTF-8 buffer is
-                // already heap-owned by the slice wrapper; transfer it (no copy).
-                // Zig's `defer str.deref()` is now handled by `Value::drop` on the
+                // The UTF-8 buffer is already heap-owned by the slice wrapper;
+                // transfer it (no copy). The deref is handled by `Value::drop` on the
                 // overwritten `WTFStringImpl` variant — do NOT deref explicitly here.
                 *self = Value::InternalBlob(InternalBlob {
                     bytes: bytes.into_vec(),
@@ -809,8 +799,7 @@ impl Value {
         }
     }
 
-    /// Shorthand constructor for the `Blob` variant (mirrors Zig
-    /// `Body.Value{ .Blob = ... }` field-init syntax used by callers).
+    /// Shorthand constructor for the `Blob` variant.
     #[inline]
     pub fn blob(b: Blob) -> Value {
         Value::Blob(b)
@@ -844,7 +833,7 @@ impl Value {
             Value::Empty => ReadableStream::empty(global_this),
             Value::Null => Ok(JSValue::NULL),
             Value::InternalBlob(_) | Value::Blob(_) | Value::WTFStringImpl(_) => {
-                // Zig: `defer blob.detach()` — must run on every exit incl. `?` paths.
+                // `deinit` must run on every exit incl. `?` paths.
                 let blob = scopeguard::guard(self.use_(), |mut b| b.deinit());
                 blob.resolve_size();
                 let blob_size = blob.size.get();
@@ -880,8 +869,7 @@ impl Value {
                 // `to_readable_stream()` below (freed by the GC finalizer).
                 let reader = webcore::readable_stream::NewSource::<ByteStream>::new_mut(
                     webcore::readable_stream::NewSource {
-                        // Zig: `.context = undefined` then `reader.context.setup()`; Rust
-                        // default-constructs (ByteStream::default == post-setup state).
+                        // `ByteStream::default()` is the post-setup state.
                         context: ByteStream::default(),
                         global_this: Some(bun_ptr::BackRef::new(global_this)),
                         ..Default::default()
@@ -955,8 +943,7 @@ impl Value {
 
             debug_assert!(str.tag() == bun_core::Tag::WTFStringImpl);
 
-            // Zig accessed `str.value.WTFStringImpl` directly; `leak_wtf_impl()` transfers
-            // the +1 ref out of the bun_core::String wrapper.
+            // `leak_wtf_impl()` transfers the +1 ref out of the bun_core::String wrapper.
             return Ok(Value::WTFStringImpl(str.leak_wtf_impl()));
         }
 
@@ -968,8 +955,8 @@ impl Value {
                     return Ok(Value::Empty);
                 }
 
-                // PORT NOTE: Zig threw "Failed to clone ArrayBufferView" on OOM; Rust's
-                // global allocator aborts on OOM, so the error path is unreachable.
+                // The global allocator aborts on OOM, so a "Failed to clone
+                // ArrayBufferView" error path is unreachable.
                 return Ok(Value::InternalBlob(InternalBlob {
                     bytes: bytes.to_vec(),
                     was_string: false,
@@ -1059,12 +1046,10 @@ impl Value {
             Ok(b) => b,
             Err(_err) => {
                 if !global_this.has_exception() {
-                    // PORT NOTE: Zig matched `error.InvalidArguments` here for an
-                    // "Expected an Array" message. With `REQUIRE_ARRAY = false` that
-                    // branch is unreachable in Zig's `Blob.get` too (the only
-                    // `error.InvalidArguments` producer is gated on `require_array`),
-                    // and every other failure path throws first (sets the exception).
-                    // The Rust `JsResult` collapse is therefore semantics-preserving.
+                    // With `REQUIRE_ARRAY = false` an "Expected an Array" branch is
+                    // unreachable (the only `error.InvalidArguments` producer is gated
+                    // on `require_array`), and every other failure path throws first
+                    // (sets the exception).
                     return Err(
                         global_this.throw_invalid_arguments(format_args!("Invalid Body object"))
                     );
@@ -1089,7 +1074,7 @@ impl Value {
         &mut self,
         new: &mut Value,
         global: &JSGlobalObject,
-        // Zig: `?*FetchHeaders` — opaque C++ handle, mutated via FFI. Taking
+        // Opaque C++ handle, mutated via FFI. Taking
         // `NonNull` (not `&`/`&mut`) avoids manufacturing aliased Rust borrows.
         headers: Option<NonNull<FetchHeaders>>,
     ) -> JsTerminated<()> {
@@ -1144,7 +1129,7 @@ impl Value {
                     Action::GetFormData(form_data_slot) => 'inner: {
                         let mut blob = new.use_as_any_blob();
                         let Some(async_form_data) = form_data_slot.take() else {
-                            // Zig: `defer blob.detach()` covers the `try promise.reject(...)` error path.
+                            // `blob.detach()` below covers the reject error path too.
                             let r = promise.reject(
                                 global,
                                 ZigString::init(
@@ -1168,7 +1153,7 @@ impl Value {
                         // SAFETY: `Blob::new` returns a freshly heap-allocated *mut Blob.
                         let blob = unsafe { &mut *blob_ptr };
                         if let Some(fetch_headers) = headers {
-                            // `headers` is a live C++ FetchHeaders handle (Zig: `?*FetchHeaders`);
+                            // `headers` is a live C++ FetchHeaders handle;
                             // `FetchHeaders` is an opaque ZST FFI handle (S008) — safe deref.
                             let fetch_headers =
                                 bun_opaque::opaque_deref_mut(fetch_headers.as_ptr());
@@ -1227,7 +1212,7 @@ impl Value {
 
         match self {
             Value::Blob(b) => {
-                // PORT NOTE: `Value` has `Drop`, so we cannot move the `Blob` out by
+                // `Value` has `Drop`, so we cannot move the `Blob` out by
                 // value (E0509). `mem::take` leaves a default `Blob` whose `deinit()`
                 // (run by `Value::drop` on the assignment below) is a no-op.
                 let new_blob = core::mem::take(b);
@@ -1258,13 +1243,12 @@ impl Value {
                 // SAFETY: VirtualMachine::get() returns the live per-thread VM.
                 let global = VirtualMachine::get().global();
                 let new_blob = if let Some(allocated_slice) = wtf_ref.to_utf8_if_needed() {
-                    // Zig: `fromOwnedSlice(@constCast(allocated_slice.slice()))` — transfer
-                    // ownership of the heap-allocated UTF-8 buffer (no copy).
+                    // Transfer ownership of the heap-allocated UTF-8 buffer (no copy).
                     Blob::init(allocated_slice.into_vec(), global)
                 } else {
                     Blob::init(wtf_ref.latin1_slice().to_vec(), global)
                 };
-                // Zig: `defer wtf.deref()` — release the +1 the body held.
+                // Release the +1 the body held.
                 wtf_ref.deref();
                 new_blob
             }
@@ -1279,8 +1263,8 @@ impl Value {
             //     *self = Value::Used;
             //     new_blob
             // }
-            // PORT NOTE: Zig passed `undefined` for global_this; `Blob::default()` leaves
-            // `global_this` null which matches the don't-care contract here.
+            // `Blob::default()` leaves `global_this` null which matches the
+            // don't-care contract here.
             _ => Blob::default(),
         }
     }
@@ -1300,8 +1284,8 @@ impl Value {
                     return None;
                 }
             }
-            // Zig: `.Locked => this.Locked.toAnyBlobAllowPromise() orelse return null` — on Some
-            // it falls through to `this.* = .{ .Used = {} }` below. `?` on Option early-returns None.
+            // `?` on the Option early-returns None; on Some it falls through
+            // to the `*self = Value::Used` assignment below.
             Value::Locked(l) => l.to_any_blob_allow_promise()?,
             _ => return None,
         };
@@ -1312,7 +1296,7 @@ impl Value {
 
     pub fn use_as_any_blob(&mut self) -> AnyBlob {
         let was_null = matches!(self, Value::Null);
-        // PORT NOTE: `Value` has `Drop`, so we cannot `mem::replace` then
+        // `Value` has `Drop`, so we cannot `mem::replace` then
         // destructure by value (E0509). Match by `&mut` and `mem::take` the
         // payload; the trailing `*self = Used/Null` runs `Value::drop` on the
         // emptied/residual variant (no-op for taken Blob/InternalBlob, releases
@@ -1324,11 +1308,10 @@ impl Value {
                 let str = *str;
                 let wtf_ref = wtf_impl(&str);
                 if let Some(utf8) = wtf_ref.to_utf8_if_needed() {
-                    // Zig: `defer str.deref()` — handled by `Value::drop` on the
+                    // The deref is handled by `Value::drop` on the
                     // assignment below (the variant is still `WTFStringImpl(str)`).
                     break 'brk AnyBlob::InternalBlob(InternalBlob {
-                        // Zig: `fromOwnedSlice(@constCast(utf8.slice()))` — transfer
-                        // ownership of the heap-allocated UTF-8 buffer (no copy).
+                        // Transfer ownership of the heap-allocated UTF-8 buffer (no copy).
                         bytes: utf8.into_vec(),
                         was_string: true,
                     });
@@ -1351,7 +1334,7 @@ impl Value {
 
     pub fn use_as_any_blob_allow_non_utf8_string(&mut self) -> AnyBlob {
         let was_null = matches!(self, Value::Null);
-        // PORT NOTE: see `use_as_any_blob` — match by `&mut` to avoid E0509.
+        // see `use_as_any_blob` — match by `&mut` to avoid E0509.
         let any_blob: AnyBlob = match self {
             Value::Blob(b) => AnyBlob::Blob(core::mem::take(b)),
             Value::InternalBlob(b) => AnyBlob::InternalBlob(core::mem::take(b)),
@@ -1378,7 +1361,7 @@ impl Value {
         global: &JSGlobalObject,
     ) -> JsTerminated<()> {
         if let Value::Locked(_) = self {
-            // PORT NOTE: reshaped for borrowck + E0509 (`Value` has `Drop`) — `mem::take`
+            // reshaped for borrowck + E0509 (`Value` has `Drop`) — `mem::take`
             // the `PendingValue` out (leaves `Locked(default)`, whose Drop is a no-op on
             // an empty readable), then overwrite with `Error`.
             let mut locked = match self {
@@ -1390,13 +1373,13 @@ impl Value {
                 unreachable!()
             };
 
-            // Zig: `defer strong_readable.deinit()` — must run on every exit incl. `?` paths.
+            // `deinit` must run on every exit incl. `?` paths.
             let strong_readable =
                 scopeguard::guard(core::mem::take(&mut locked.readable), |mut r| r.deinit());
 
             if let Some(promise_value) = locked.promise.take() {
-                // Zig: `defer promise_value.ensureStillAlive(); defer promise_value.unprotect();`
-                // — non-Drop side effect (GC root decrement) that must run even if
+                // `unprotect` + `ensure_still_alive` are non-Drop side effects
+                // (GC root decrement) that must run even if
                 // reject_with_async_stack errors.
                 let promise_value = scopeguard::guard(promise_value, |p| {
                     p.unprotect();
@@ -1443,7 +1426,7 @@ impl Value {
         )
     }
 
-    // PORT NOTE: mutates self to Null and is called explicitly at specific protocol points.
+    // mutates self to Null and is called explicitly at specific protocol points.
     // Renamed from `deinit` per PORTING.md (never expose `pub fn deinit(&mut self)`). Now
     // delegates the actual resource release to `Drop` (below) via assignment, so a later
     // `HiveArray::put()` → `drop_in_place` on the resulting `Null` is a guaranteed no-op
@@ -1465,12 +1448,11 @@ impl Value {
     }
 }
 
-/// Spec: `Body.Value.deinit` (Body.zig). Runs when a `HiveRef<Value>` slot is
-/// recycled (`HiveArray::Fallback::put` → `drop_in_place`) — Zig's
-/// `if @hasDecl(T, "deinit") this.value.deinit()` in `HiveRef::unref` was
-/// mapped to `T::drop` in the Rust port (see `bun_collections::HiveRef::unref`),
-/// so without this impl `Request`/`Response` GC finalization leaked
-/// `WTFStringImpl` refs / `Blob` stores / `InternalBlob` buffers (H3 elysia rss).
+/// Runs when a `HiveRef<Value>` slot is recycled
+/// (`HiveArray::Fallback::put` → `drop_in_place`; see
+/// `bun_collections::HiveRef::unref`). Without this impl `Request`/`Response`
+/// GC finalization leaked `WTFStringImpl` refs / `Blob` stores /
+/// `InternalBlob` buffers (H3 elysia rss).
 ///
 /// Unlike `reset()` this never reassigns `*self` (it's already being torn
 /// down), so calling `reset()` first then dropping (or dropping a `Null`
@@ -1500,7 +1482,7 @@ impl Value {
         owned_readable: Option<&mut ReadableStream>,
     ) -> JsResult<Value> {
         let Value::Locked(locked) = self else {
-            // TODO(port): Zig assumed self.* == .Locked at entry (caller guarantees).
+            // Caller guarantees `self` is `Locked` at entry.
             unreachable!("tee() called on non-Locked Value");
         };
         if let Some(readable) = owned_readable {
@@ -1572,7 +1554,7 @@ impl Value {
             _ => {}
         }
 
-        // PORT NOTE: reshaped for borrowck — re-borrow locked after the early *self = Null path above.
+        // reshaped for borrowck — re-borrow locked after the early *self = Null path above.
         let Value::Locked(locked) = self else {
             unreachable!()
         };
@@ -1646,8 +1628,7 @@ impl Value {
 // JSC-integration: extract / BodyMixin (host-fn methods) / ValueBufferer.
 // ────────────────────────────────────────────────────────────────────────────
 
-// PORT NOTE: Zig `ArrayBufferSink.JSSink` is a nested type from `Sink.JSSink(@This(), name)`.
-// Rust uses a free generic `sink::JSSink<T>` (inherent associated types are unstable).
+// `sink::JSSink<T>` is a free generic (inherent associated types are unstable).
 type ArrayBufferJSSink = sink::JSSink<ArrayBufferSink>;
 
 // https://github.com/WebKit/webkit/blob/main/Source/WebCore/Modules/fetch/FetchBody.cpp#L45
@@ -1663,9 +1644,9 @@ pub(crate) fn extract(global_this: &JSGlobalObject, value: JSValue) -> JsResult<
 // Mixin
 // ────────────────────────────────────────────────────────────────────────────
 
-/// `pub fn Mixin(comptime Type: type) type` → trait with provided methods.
+/// Mixin trait with provided methods.
 /// Implementers supply `get_body_value`, `get_fetch_headers`, `get_form_data_encoding`,
-/// and optionally override `get_body_readable_stream` (Zig `@hasDecl` check).
+/// and optionally override `get_body_readable_stream`.
 ///
 /// R-2 (host-fn re-entrancy): every JS-exposed method takes `&self`. The
 /// codegen shim still emits `this: &mut T` — `&mut T`
@@ -1677,7 +1658,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
     /// short and do not hold it across a call that re-enters JS.
     #[allow(clippy::mut_from_ref)]
     fn get_body_value(&self) -> &mut Value;
-    /// Zig: `Type.getFetchHeaders(this) -> ?*FetchHeaders`. `FetchHeaders` is an
+    /// `FetchHeaders` is an
     /// opaque, intrusively-refcounted C++ handle whose accessors take `&mut self`
     /// (FFI signature is `*mut`). Returning `NonNull` instead of `&FetchHeaders`
     /// avoids deriving `&mut T` from `&T` at the call sites (UB).
@@ -1688,11 +1669,10 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
     // Twin methods (identical for Request/Response). These were previously
     // open-coded in both files against `js_gen::*` / `js::*` directly; the
     // [`BodyOwnerJs`] forwarders erase the per-class codegen module so the
-    // bodies can live here once. Zig had the same shape via comptime
-    // `T.js.gc.stream.*` duck-typing.
+    // bodies can live here once.
     // ────────────────────────────────────────────────────────────────────
 
-    /// Zig: `getBodyReadableStream`. JS-side `js.gc.stream` cache is the
+    /// JS-side `js.gc.stream` cache is the
     /// source of truth; fall back to the native `Locked.readable` slot.
     fn get_body_readable_stream(&self, global_object: &JSGlobalObject) -> Option<ReadableStream> {
         if let Some(js_ref) = self.js_ref() {
@@ -1713,21 +1693,19 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         None
     }
 
-    /// Zig: `detachReadableStream` — clear both the JS-side cache and the
+    /// Clear both the JS-side cache and the
     /// native `Locked.readable` strong ref.
     fn detach_readable_stream(&self, global_object: &JSGlobalObject) {
         if let Some(js_ref) = self.js_ref() {
-            // Zig `js.gc.stream.clear(...)` → `set(.zero)`.
             Self::stream_set_cached(js_ref, global_object, JSValue::ZERO);
         }
         if let Value::Locked(locked) = self.get_body_value() {
-            // `mem::take` swaps in `Default` and drops the old value —
-            // equivalent to Zig's `old.deinit(); ... = .{}`.
+            // `mem::take` swaps in `Default` and drops the old value.
             let _ = core::mem::take(&mut locked.readable);
         }
     }
 
-    /// Zig: `checkBodyStreamRef`. Migrate any `Locked.readable` strong ref
+    /// Migrate any `Locked.readable` strong ref
     /// into the GC-traced `js.gc.stream` slot to break the cycle (the JS
     /// wrapper owns the stream; native side must not hold it strongly).
     fn check_body_stream_ref(&self, global_object: &JSGlobalObject) {
@@ -1830,7 +1808,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
     }
 
     fn get_body_used(&self, global_object: &JSGlobalObject) -> JSValue {
-        // PORT NOTE: reshaped for borrowck — `get_body_readable_stream` needs `&self`,
+        // reshaped for borrowck — `get_body_readable_stream` needs `&self`,
         // so we can't hold a `match` borrow on `get_body_value()` across it.
         let used = match self.get_body_value() {
             Value::Used => true,
@@ -1875,7 +1853,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
                 {
                     return Ok(handle_body_already_used(global_object));
                 }
-                // PORT NOTE: reshaped for borrowck
+                // reshaped for borrowck
                 let _ = locked;
                 let value = self.get_body_value();
                 value.to_blob_if_possible();
@@ -2011,7 +1989,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
                 }
                 let value = self.get_body_value();
                 value.to_blob_if_possible();
-                let _ = readable; // not consumed in this branch in Zig either
+                let _ = readable; // not consumed in this branch
             }
             let value = self.get_body_value();
             if let Value::Locked(locked) = value {
@@ -2041,7 +2019,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         let value = self.get_body_value();
         if let Value::Locked(_locked) = value {
             let owned_readable = self.get_body_readable_stream(global_object);
-            // PORT NOTE: reshaped for borrowck — re-borrow after self method call.
+            // reshaped for borrowck — re-borrow after self method call.
             let value = self.get_body_value();
             let Value::Locked(locked) = value else {
                 unreachable!()
@@ -2054,7 +2032,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         }
 
         let mut blob: AnyBlob = value.use_as_any_blob();
-        // PORT NOTE: `encoder.encoding` is `bun_core::form_data::Encoding`; convert
+        // `encoder.encoding` is `bun_core::form_data::Encoding`; convert
         // to the `webcore::form_data::Encoding` shape FormData::to_js expects.
         let encoding = match encoder.encoding {
             bun_core::form_data::Encoding::URLEncoded => webcore::form_data::Encoding::URLEncoded,
@@ -2138,7 +2116,7 @@ pub(crate) trait BodyMixin: BodyOwnerJs + Sized {
         let blob = unsafe { &mut *blob_ptr };
         if blob.content_type().is_empty() {
             if let Some(fetch_headers) = BodyMixin::get_fetch_headers(self) {
-                // `fetch_headers` is a live C++ FetchHeaders handle (Zig: `?*FetchHeaders`);
+                // `fetch_headers` is a live C++ FetchHeaders handle;
                 // `FetchHeaders` is an opaque ZST FFI handle (S008) — safe deref.
                 let fetch_headers = bun_opaque::opaque_deref_mut(fetch_headers.as_ptr());
                 if let Some(content_type) = fetch_headers.fast_get(HTTPHeaderName::ContentType) {
@@ -2214,11 +2192,8 @@ impl<'a> Drop for ValueBufferer<'a> {
 
         if let Some(mut buffer_stream) = self.js_sink.take() {
             buffer_stream.detach_self(self.global);
-            // PORT NOTE: Zig `wrapper.sink.destroy()` frees the JSSink wrapper
-            // allocation (sink is at offset 0). In Rust the wrapper is a
-            // `Box<JSSink<ArrayBufferSink>>`; dropping it frees the box and
-            // runs `Vec<u8>`'s Drop — equivalent without the fragile
-            // sub-field-pointer free.
+            // The wrapper is a `Box<JSSink<ArrayBufferSink>>`; dropping it
+            // frees the box and runs `Vec<u8>`'s Drop.
             drop(buffer_stream);
         }
     }
@@ -2246,7 +2221,6 @@ impl<'a> ValueBufferer<'a> {
         value: &mut Value,
         owned_readable_stream: Option<ReadableStream>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set — Zig used inferred `!void` with StreamAlreadyUsed/InvalidStream/etc.
         value.to_blob_if_possible();
 
         match value {
@@ -2261,8 +2235,7 @@ impl<'a> ValueBufferer<'a> {
             }
             Value::Error(err) => {
                 bun_core::scoped_log!(BodyValueBufferer, "Error");
-                // Zig passed the union by bitwise value (no destructors). In Rust the
-                // payload (BunString / Strong) owns refs and has Drop, so a `ptr::read`
+                // The payload (BunString / Strong) owns refs and has Drop, so a `ptr::read`
                 // bitwise copy would manufacture a second owner → double-deref when both
                 // sides drop. Produce a properly ref-bumped duplicate instead.
                 let err_copy = err.dupe(self.global);
@@ -2277,8 +2250,7 @@ impl<'a> ValueBufferer<'a> {
 
                 if is_pending {
                     if let AnyBlob::Blob(blob) = &mut input {
-                        // PORT NOTE: Zig `comptime Function: anytype` becomes a ZST
-                        // `InternalReadFileFn<C>` impl so `do_read_file_internal` can
+                        // The ZST `InternalReadFileFn<C>` impl lets `do_read_file_internal`
                         // monomorphize a `fn(*mut c_void, ReadFileResultType)` thunk.
                         struct LoadFileAdapter;
                         impl<'b> blob::InternalReadFileFn<ValueBufferer<'b>> for LoadFileAdapter {
@@ -2406,13 +2378,11 @@ impl<'a> ValueBufferer<'a> {
     fn handle_reject_stream(&mut self, err: JSValue, is_async: bool) {
         if let Some(mut wrapper) = self.js_sink.take() {
             wrapper.detach_self(self.global);
-            // PORT NOTE: see `Drop` impl — dropping the Box frees the wrapper
-            // and runs `Vec<u8>`'s Drop (≡ Zig `wrapper.sink.destroy()`).
+            // see `Drop` impl — dropping the Box frees the wrapper
+            // and runs `Vec<u8>`'s Drop.
             drop(wrapper);
         }
-        // Zig: `var ref = ...; defer ref.deinit(); sink.onFinishedBuffering(..., .{ .JSValue = ref }, ...);`
-        // — Zig's bitwise pass + `defer deinit` is only safe because Zig has no Drop. In
-        // Rust `jsc::strong::Optional` owns a GC root; `ptr::read`-duplicating it would
+        // `jsc::strong::Optional` owns a GC root; `ptr::read`-duplicating it would
         // double-deinit. Transfer the single owner directly to the callback; the callback
         // (or its returned `ValueError`'s Drop) is responsible for releasing it.
         let ref_ = jsc::strong::Optional::create(err, self.global);
@@ -2441,11 +2411,10 @@ impl<'a> ValueBufferer<'a> {
         };
         let readable_stream = 'brk: {
             if let Some(stream) = locked.readable.get(self.global) {
-                // keep the stream alive until we're done with it
-                // Zig: `sink.readable_stream_ref = locked.readable;` — bitwise struct
-                // copy that aliases the same Strong. Transfer ownership: `*value =
-                // .Used` below would otherwise drop `locked.readable` anyway, so
-                // moving the existing GC root preserves the Zig refcount balance.
+                // keep the stream alive until we're done with it.
+                // Transfer ownership: `*value = .Used` below would otherwise
+                // drop `locked.readable` anyway, so moving the existing GC
+                // root preserves the refcount balance.
                 self.readable_stream_ref = core::mem::take(&mut locked.readable);
                 break 'brk Some(stream);
             }
@@ -2516,7 +2485,7 @@ impl<'a> ValueBufferer<'a> {
             }
         }
 
-        // PORT NOTE: reshaped for borrowck — re-borrow locked after possible *value = Used above.
+        // reshaped for borrowck — re-borrow locked after possible *value = Used above.
         let Value::Locked(locked) = value else {
             unreachable!()
         };
@@ -2526,8 +2495,9 @@ impl<'a> ValueBufferer<'a> {
             let readable = value
                 .to_readable_stream(self.global)
                 .map_err(|_| bun_core::err!("JSError"))?;
-            // TODO(port): Zig propagated bun.JSError here via `try`; bufferLockedBodyValue's
-            // inferred error set includes JSError. Mapping to bun_core::Error for now.
+            // The JS exception value is
+            // flattened to a string-coded error because `run`'s callers consume
+            // `bun_core::Error` (the exception itself stays pending on the VM).
             readable.ensure_still_alive();
             readable.protect();
             return self.buffer_locked_body_value(value, None);
@@ -2560,15 +2530,13 @@ impl<'a> ValueBufferer<'a> {
     }
 }
 
-// PORT NOTE: Zig's `Pipe.Wrap(Type, fn)` took a comptime fn pointer; the Rust
-// `webcore::Wrap<T>` reshape requires `T: PipeHandler`.
+// `webcore::Wrap<T>` requires `T: PipeHandler`.
 impl<'a> crate::webcore::PipeHandler for ValueBufferer<'a> {
     fn on_pipe(&mut self, stream: streams::Result) {
         self.on_stream_pipe(stream)
     }
 }
 
-// comptime { @export(...) } → no_mangle extern "C" exports.
 // `#[bun_jsc::host_fn]` on on_resolve_stream/on_reject_stream emits the JSC ABI shim;
 // these no_mangle re-exports point at those shims under the C names the C++ side expects.
 bun_jsc::jsc_host_abi! {
@@ -2597,5 +2565,3 @@ bun_jsc::jsc_host_abi! {
         jsc::to_js_host_fn_result(global, ValueBufferer::on_reject_stream(global, callframe))
     }
 }
-
-// ported from: src/runtime/webcore/Body.zig
diff --git a/src/runtime/webcore/ByteBlobLoader.rs b/src/runtime/webcore/ByteBlobLoader.rs
index e5cd2de98d4..faa44d8ba1d 100644
--- a/src/runtime/webcore/ByteBlobLoader.rs
+++ b/src/runtime/webcore/ByteBlobLoader.rs
@@ -18,9 +18,8 @@ pub struct ByteBlobLoader {
     /// https://github.com/oven-sh/bun/issues/14988
     /// Necessary for converting a ByteBlobLoader from a Blob -> back into a Blob
     /// Especially for DOMFormData, where the specific content-type might've been serialized into the data.
-    // TODO(port): Zig stored either an owned dupe or a borrowed slice from `blob` gated by
-    // `content_type_allocated`. Collapsed to always-owned `Box<[u8]>`; the flag is kept for
-    // structural parity (transferred to Blob in to_any_blob).
+    // Always-owned `Box<[u8]>`; the flag is kept because it is
+    // transferred to Blob in to_any_blob.
     pub content_type: Box<[u8]>,
     pub content_type_allocated: bool,
 }
@@ -40,9 +39,7 @@ impl Default for ByteBlobLoader {
     }
 }
 
-// Zig `NewSource(@This(), "Blob", onStart, onPull, onCancel, deinit, null, drain,
-// memoryCost, toBufferedValue)` is a comptime type-returning fn that wires callbacks. In Rust
-// this becomes a generic `ReadableStreamSource<Ctx>` where `Ctx` impls `SourceContext`.
+// A generic `ReadableStreamSource<Ctx>` where `Ctx` impls `SourceContext`.
 pub type Source = readable_stream::NewSource<ByteBlobLoader>;
 
 impl readable_stream::SourceContext for ByteBlobLoader {
@@ -82,14 +79,11 @@ bun_core::impl_field_parent! { ByteBlobLoader => Source.context; pub fn parent_c
 
 impl ByteBlobLoader {
     pub fn setup(&mut self, blob: &Blob, user_chunk_size: blob::SizeType) {
-        // TODO(port): in-place init — `self` is a pre-allocated slot inside `Source`
+        // In-place init — `self` is a pre-allocated slot inside `Source`.
         let store = blob.store.get().as_ref().unwrap().clone();
-        // PORT NOTE: Zig did `var blobe = blob.*; blobe.resolveSize();` — `Blob` is not
-        // `Clone` in Rust, so use the non-mutating `resolved_size()` helper instead.
+        // `Blob` is not `Clone`, so use the non-mutating `resolved_size()` helper.
         let (offset, size) = blob.resolved_size();
-        // Zig borrowed `blob.content_type` when `!blob.content_type_allocated`
-        // and tracked ownership via the flag. The Rust port collapsed
-        // `content_type` to an always-owned `Box<[u8]>` (we dupe in both
+        // `content_type` is an always-owned `Box<[u8]>` (we dupe in both
         // arms), so the flag must be `true` whenever the box is non-empty —
         // it's later transferred verbatim to a `Blob` in `to_any_blob`, and a
         // `false` there strands the `into_raw`'d allocation behind
@@ -164,8 +158,7 @@ impl ByteBlobLoader {
     }
 
     pub fn to_any_blob(&mut self, global: &JSGlobalObject) -> Option<blob::Any> {
-        // PORT NOTE: reshaped for borrowck — Zig captured `store` then called detachStore();
-        // here we take ownership via detach_store() up front.
+        // Take ownership via detach_store() up front.
         let store = self.detach_store()?;
         if self.offset == 0 && self.remain == store.size() && self.content_type.is_empty() {
             // SAFETY: `StoreRef` deref is `&Store`; `to_any_blob` needs `&mut` to move bytes out.
@@ -238,8 +231,7 @@ impl ByteBlobLoader {
         let take = 16384usize.min(temporary.len().min(self.remain as usize));
         let temporary = &temporary[..take];
 
-        // Zig: `Vec<u8>.fromBorrowedSliceDangerous(temporary).clone(allocator)` — collapse to a
-        // single owning copy (avoids the `ManuallyDrop` borrow dance).
+        // A single owning copy (avoids a `ManuallyDrop` borrow dance).
         let cloned = Vec::<u8>::from_slice(temporary);
         self.offset = self.offset.saturating_add(cloned.len() as blob::SizeType);
         self.remain = self.remain.saturating_sub(cloned.len() as blob::SizeType);
@@ -275,5 +267,3 @@ impl ByteBlobLoader {
         0
     }
 }
-
-// ported from: src/runtime/webcore/ByteBlobLoader.zig
diff --git a/src/runtime/webcore/ByteStream.rs b/src/runtime/webcore/ByteStream.rs
index c6b2a8f9b02..792d132a4e5 100644
--- a/src/runtime/webcore/ByteStream.rs
+++ b/src/runtime/webcore/ByteStream.rs
@@ -26,8 +26,8 @@ pub struct ByteStream {
     pub pending: JsCell<streams::Pending>,
     pub done: Cell<bool>,
     /// Borrowed view into a JS `Uint8Array` passed from `on_pull`; kept alive by `pending_value`.
-    // TODO(port): lifetime — raw fat slice ptr because the backing store is JS-heap-owned and
-    // rooted via `pending_value: Strong`. Never freed by Rust.
+    // Raw fat slice ptr because the backing store is JS-heap-owned and rooted via
+    // `pending_value: Strong`. Never freed by Rust.
     pub pending_buffer: Cell<*mut [u8]>,
     pub pending_value: JsCell<StrongOptional>, // jsc.Strong.Optional
     pub offset: Cell<usize>,
@@ -58,7 +58,7 @@ impl Default for ByteStream {
     }
 }
 
-/// `webcore.ReadableStream.NewSource(@This(), "Bytes", onStart, onPull, onCancel, deinit, null, drain, memoryCost, toBufferedValue)`
+/// ReadableStream source backed by a ByteStream.
 pub type Source = readable_stream::NewSource<ByteStream>;
 
 impl readable_stream::SourceContext for ByteStream {
@@ -109,11 +109,11 @@ impl ByteStream {
         core::ptr::slice_from_raw_parts_mut(core::ptr::NonNull::<u8>::dangling().as_ptr(), 0)
     }
 
-    /// Init-time reset (Zig: write into `undefined`). Runs before the JS
+    /// Init-time reset. Runs before the JS
     /// wrapper exists, so `&mut self` is sound here (R-2 exemption).
     pub(crate) fn setup(&mut self) {
-        // Called immediately after `ByteStream::default()` construction (Zig
-        // wrote into `undefined`); the old value owns nothing the new one
+        // Called immediately after `ByteStream::default()` construction;
+        // the old value owns nothing the new one
         // reuses, so dropping it is the intended reset.
         drop(core::mem::take(self));
     }
@@ -161,8 +161,7 @@ impl ByteStream {
     pub(crate) fn on_data(&self, stream: streams::Result) -> Result<(), bun_jsc::JsTerminated> {
         bun_jsc::mark_binding!();
         if self.done.get() {
-            // PORT NOTE: Zig frees `stream.owned.slice()` / `stream.owned_and_done.slice()` here
-            // via `allocator.free` when the variant is owned. In Rust the owned `Vec<u8>`/`Vec`
+            // The owned `Vec<u8>`/`Vec`
             // payload drops implicitly at the `return` below — no explicit `drop` needed.
             self.has_received_last_chunk.set(stream.is_done());
 
@@ -190,8 +189,8 @@ impl ByteStream {
 
         if self.buffer_action.get().is_some() {
             if let streams::Result::Err(err) = &stream {
-                // PORT NOTE: Zig `defer { ... }` block — runs after `action.reject`. Reordered
-                // here as explicit post-reject cleanup since `?` would skip it.
+                // Explicit post-reject cleanup; runs after `action.reject`
+                // (`?` would skip it).
                 bun_output::scoped_log!(ByteStream, "ByteStream.onData err  action.reject()");
 
                 let global = self.parent_const().global_this();
@@ -233,8 +232,7 @@ impl ByteStream {
                             "ByteStream.onData owned_and_done and action.fulfill()"
                         );
 
-                        // Zig: `std.array_list.Managed(u8).fromOwnedSlice(bun.default_allocator, @constCast(chunk))`
-                        // PORT NOTE: reshaped for borrowck — move the owned Vec<u8> into `buffer`
+                        // Move the owned Vec<u8> into `buffer`
                         // directly instead of round-tripping through `chunk` (which would borrow
                         // `stream`).
                         self.buffer.set(owned.move_to_list_managed());
@@ -250,16 +248,16 @@ impl ByteStream {
 
                 self.buffer
                     .with_mut(|b| b.extend_from_slice(stream.slice()));
-                // Zig `defer { if owned* allocator.free(stream.slice()) }` — owned `Vec<u8>`
+                // The owned `Vec<u8>`
                 // payload of `stream` is freed by its Drop glue at the explicit `drop` below
-                // (Temporary* variants are non-owning `RawSlice` and so are left alone, matching Zig).
+                // (Temporary* variants are non-owning `RawSlice` and so are left alone).
                 drop(stream);
                 let mut blob = self.to_any_blob().unwrap();
                 return action.fulfill(self.parent_const().global_this(), &mut blob);
             } else {
                 self.buffer
                     .with_mut(|b| b.extend_from_slice(stream.slice()));
-                // Zig: `if owned* allocator.free(stream.slice())` — owned `Vec<u8>` payload of
+                // The owned `Vec<u8>` payload of
                 // `stream` is freed by its Drop glue (Temporary* are non-owning `RawSlice`, left alone).
                 drop(stream);
             }
@@ -323,8 +321,8 @@ impl ByteStream {
 
             let remaining = &chunk[to_copy_len..];
             if !remaining.is_empty() && !chunk.is_empty() {
-                // PORT NOTE: `chunk` borrows `stream`; passing both requires re-slicing inside
-                // `append`. Zig passes `base_address = chunk` for the free path.
+                // `chunk` borrows `stream`; passing both requires re-slicing inside
+                // `append`.
                 self.append(stream, to_copy_len)
                     .unwrap_or_else(|_| panic!("Out of memory while copying request body"));
             }
@@ -351,21 +349,17 @@ impl ByteStream {
         &self,
         stream: streams::Result,
         offset: usize,
-        // PORT NOTE: Zig `base_address: []const u8` + `allocator` params dropped — `base_address`
-        // was only used for `allocator.free(@constCast(base_address))`, which is the Drop of the
-        // owned `stream` payload in Rust.
     ) -> Result<(), bun_alloc::AllocError> {
         if self.buffer.get().capacity() == 0 {
             match stream {
                 streams::Result::Owned(mut owned) | streams::Result::OwnedAndDone(mut owned) => {
-                    // Zig: `owned.moveToListManaged(allocator)` — moves the buffer, no copy.
+                    // `move_to_list_managed` moves the buffer, no copy.
                     self.buffer.set(owned.move_to_list_managed());
                     self.offset.set(self.offset.get() + offset);
                 }
                 streams::Result::TemporaryAndDone(temp) | streams::Result::Temporary(temp) => {
                     let chunk = &temp.slice()[offset..];
                     let mut buf = Vec::with_capacity(chunk.len());
-                    // PERF(port): was appendSliceAssumeCapacity.
                     buf.extend_from_slice(chunk);
                     self.buffer.set(buf);
                 }
@@ -387,7 +381,7 @@ impl ByteStream {
             streams::Result::OwnedAndDone(owned) | streams::Result::Owned(owned) => {
                 self.buffer
                     .with_mut(|b| b.extend_from_slice(&owned.slice()[offset..]));
-                // Zig: `allocator.free(@constCast(base_address))` — `owned: Vec<u8>` drops here.
+                // `owned: Vec<u8>` drops here.
             }
             streams::Result::Err(err) => {
                 if self.buffer_action.get().is_some() {
@@ -457,15 +451,13 @@ impl ByteStream {
             return streams::Result::Done;
         }
 
-        // TODO(port): lifetime — storing a raw borrow of a JS-owned buffer; rooted by `set_value`.
+        // Raw borrow of a JS-owned buffer; rooted by `set_value`.
         self.pending_buffer.set(std::ptr::from_mut::<[u8]>(buffer));
         self.set_value(view);
 
         // R-2: `JsCell::as_ptr` yields the stable `*mut Pending` that the
         // returned `streams::Result::Pending` raw-backref needs.
         streams::Result::Pending(self.pending.as_ptr())
-        // TODO(port): `streams::Result::Pending` carries `*streams.Result.Pending` in Zig (raw
-        // backref). TODO(refactor): decide on `NonNull<streams::Pending>` vs index.
     }
 
     pub(crate) fn on_cancel(&self) {
@@ -541,8 +533,8 @@ impl ByteStream {
             }
         }
         if let Some(action) = self.buffer_action.replace(None) {
-            // PORT NOTE: Zig `action.deinit()` only deinits the JSPromiseStrong payload of each
-            // variant; JSPromiseStrong implements Drop, so dropping the enum is equivalent.
+            // JSPromiseStrong implements Drop, so dropping the enum releases
+            // each variant's JSPromiseStrong payload.
             drop(action);
         }
         // Enclosing `Box<NewSource<ByteStream>>` is freed by the caller
@@ -611,5 +603,3 @@ impl ByteStream {
         Ok(self.buffer_action.get().as_ref().unwrap().value())
     }
 }
-
-// ported from: src/runtime/webcore/ByteStream.zig
diff --git a/src/runtime/webcore/CookieMap.rs b/src/runtime/webcore/CookieMap.rs
index 8303367eae3..0a109ab7410 100644
--- a/src/runtime/webcore/CookieMap.rs
+++ b/src/runtime/webcore/CookieMap.rs
@@ -9,7 +9,6 @@ bun_opaque::opaque_ffi! {
     pub struct CookieMap;
 }
 
-// TODO(port): move to runtime_sys (or webcore_sys) — extern decls belong in the *_sys crate
 unsafe extern "C" {
     // Reference params discharge the non-null/aligned preconditions; `JSGlobalObject`
     // wraps `UnsafeCell` so `&JSGlobalObject` permits C++ interior mutation.
@@ -104,5 +103,3 @@ impl Drop for CookieMapRef {
         CookieMap__deref(self)
     }
 }
-
-// ported from: src/runtime/webcore/CookieMap.zig
diff --git a/src/runtime/webcore/Crypto.rs b/src/runtime/webcore/Crypto.rs
index 0d9c2128237..558419b5e3f 100644
--- a/src/runtime/webcore/Crypto.rs
+++ b/src/runtime/webcore/Crypto.rs
@@ -12,8 +12,6 @@ use crate::node::Encoding;
 #[derive(Default)]
 pub struct Crypto {}
 
-// Zig: `comptime { _ = CryptoObject__create; }` — force-reference block, dropped.
-
 impl Crypto {
     #[bun_jsc::host_fn(method)]
     pub fn timing_safe_equal(
@@ -25,9 +23,9 @@ impl Crypto {
     }
 
     // DOMJIT fast path — non-standard signature (typed-array args unwrapped by codegen).
-    // TODO(port): Zig return type is bare `JSValue` but the error branch returns
-    // `ERR(..).throw()` (a `bun.JSError`). Mirroring as JsResult<JSValue> here; verify
-    // DOMJIT shim expectations.
+    // DOMJIT operations report failure by throwing on the VM and returning the empty
+    // value (`JSValue::ZERO`); the generated wrapper returns the raw EncodedJSValue and
+    // the JIT checks for a pending exception after the call.
     pub fn timing_safe_equal_without_type_checks(
         &self,
         global: &JSGlobalObject,
@@ -40,9 +38,8 @@ impl Crypto {
         let len = array_a.len();
 
         if array_b.len() != len {
-            // TODO(port): see note above re: return type — DOMJIT shim expects bare JSValue
-            // but the Zig error branch returns `bun.JSError`. Mirror by throwing then
-            // returning the encoded error-builder JSValue.
+            // Throw, then return the empty value — the DOMJIT wrapper surfaces the
+            // pending exception (the C-ABI shim encodes it as zero).
             let _ = global
                 .err(
                     bun_jsc::ErrorCode::CRYPTO_TIMING_SAFE_EQUAL_LENGTH,
@@ -98,15 +95,14 @@ impl Crypto {
         global: &JSGlobalObject,
         array: &JSUint8Array,
     ) -> JSValue {
-        // Zig `array.slice()` yields `[]u8` (mutable). `JSUint8Array::slice()` takes
+        // `JSUint8Array::slice()` takes
         // `&mut self`; use ptr()/len() (which take `&self`) to avoid the &mut requirement.
         // SAFETY: JSC guarantees `ptr()` is valid for `len()` writable bytes while the
         // typed-array cell is alive; `ffi::slice_mut` tolerates `(null, 0)` for detached.
         random_data(global, unsafe {
             bun_core::ffi::slice_mut(array.ptr(), array.len())
         });
-        // Zig: @enumFromInt(@as(i64, @bitCast(@intFromPtr(array)))) — encode the cell
-        // pointer back into a JSValue.
+        // Encode the cell pointer back into a JSValue.
         JSValue::from_encoded(std::ptr::from_ref::<JSUint8Array>(array) as usize)
     }
 
@@ -137,7 +133,7 @@ impl Crypto {
         // randomUUID must have been called already many times before this kicks
         // in so we can skip the rare_data pointer check.
         // SAFETY: `bun_vm()` never returns null for a Bun-owned global.
-        // NOTE(port): upstream lacks `rare_data_unchecked`; `rare_data()` lazy-inits anyway.
+        // `rare_data()` lazy-inits, so no unchecked accessor is needed.
         let uuid = global.bun_vm().as_mut().rare_data().next_uuid();
 
         uuid.print(
@@ -175,7 +171,6 @@ fn random_data(global: &JSGlobalObject, slice: &mut [u8]) {
     }
 }
 
-// Zig: `comptime { @export(&jsc.toJSHostFn(Bun__randomUUIDv7_), .{ .name = "Bun__randomUUIDv7" }) }`
 // The #[bun_jsc::host_fn] attribute macro emits the `extern "C"` shim with the
 // correct calling convention and `#[unsafe(no_mangle)]` under the exported name.
 #[bun_jsc::host_fn(export = "Bun__randomUUIDv7")]
@@ -259,7 +254,6 @@ pub(crate) fn bun_random_uuid_v7(
     encoding.encode_with_max_size(global, 32, &uuid.bytes)
 }
 
-// Zig: `comptime { @export(&jsc.toJSHostFn(Bun__randomUUIDv5_), .{ .name = "Bun__randomUUIDv5" }) }`
 #[bun_jsc::host_fn(export = "Bun__randomUUIDv5")]
 pub(crate) fn bun_random_uuid_v5(
     global: &JSGlobalObject,
@@ -310,7 +304,7 @@ pub(crate) fn bun_random_uuid_v5(
     let name_value = arguments.ptr[0];
     let namespace_value = arguments.ptr[1];
 
-    // `name` is a ZigString.Slice in Zig (borrow-or-own UTF-8). Port as bun_core::ZigStringSlice.
+    // `bun_core::ZigStringSlice` is a borrow-or-own UTF-8 slice.
     let name: bun_core::ZigStringSlice = 'brk: {
         if name_value.is_string() {
             let name_str = bun_core::OwnedString::new(name_value.to_bun_string(global)?);
@@ -398,10 +392,7 @@ pub(crate) fn bun_random_uuid_v5(
 pub(crate) extern "C" fn CryptoObject__create(global: &JSGlobalObject) -> JSValue {
     bun_jsc::mark_binding!();
 
-    // PORTING.md: allocator.create(T) → Box::new. Box::new aborts on OOM, so the
-    // Zig `catch return globalThis.throwOutOfMemoryValue()` arm is unreachable.
+    // Box::new aborts on OOM, so an out-of-memory throw arm is unreachable.
     // `JsClass::to_js` boxes `self` internally and transfers ownership to the JS wrapper.
     Crypto::default().to_js(global)
 }
-
-// ported from: src/runtime/webcore/Crypto.zig
diff --git a/src/runtime/webcore/EncodingLabel.rs b/src/runtime/webcore/EncodingLabel.rs
index a0a6b7c33bf..453e3fe05a9 100644
--- a/src/runtime/webcore/EncodingLabel.rs
+++ b/src/runtime/webcore/EncodingLabel.rs
@@ -236,5 +236,3 @@ static STRING_MAP: phf::Map<&'static [u8], EncodingLabel> = phf::phf_map! {
     b"x-user-defined" => EncodingLabel::XUserDefined,
     b"replacement" => EncodingLabel::Replacement,
 };
-
-// ported from: src/runtime/webcore/EncodingLabel.zig
diff --git a/src/runtime/webcore/FileReader.rs b/src/runtime/webcore/FileReader.rs
index 56b9d2896fd..e8ff33bd177 100644
--- a/src/runtime/webcore/FileReader.rs
+++ b/src/runtime/webcore/FileReader.rs
@@ -18,7 +18,7 @@ use crate::webcore::streams;
 
 bun_core::declare_scope!(FileReader, visible);
 
-// TODO(port): `pending_view` and the `Js`/`Temporary` variants below borrow into a
+// `pending_view` and the `Js`/`Temporary` variants below borrow into a
 // JS-owned typed-array buffer kept alive by `pending_value: Strong` / `ensure_still_alive`.
 // Represented as unbounded `&mut [u8]` / `&[u8]` here to keep function bodies
 // readable; TODO(refactor): replace with a proper raw-slice wrapper (BACKREF lifetime).
@@ -42,7 +42,7 @@ pub struct FileReader {
     pub done: Cell<bool>,
     pub pending: JsCell<streams::Pending>,
     pub pending_value: JsCell<Strong>, // Strong.Optional
-    // TODO(port): `&'static mut [u8]` forge — borrows a JS typed-array buffer
+    // TODO(refactor): `&'static mut [u8]` forge — borrows a JS typed-array buffer
     // that GC can move/collect, and `&'static mut` asserts uniqueness the GC
     // does not honour. `bun_ptr::Interned` is read-only by construction so
     // does NOT cover this; tracked under the sibling `static-widen-mut`
@@ -79,8 +79,7 @@ impl Default for FileReader {
             total_readed: Cell::new(0),
             started: Cell::new(false),
             waiting_for_on_reader_done: Cell::new(false),
-            // TODO(port): event_loop has no Zig default; callers must overwrite before use
-            // sentinel only; never dispatched (overwritten before use).
+            // Sentinel only; never dispatched (callers must overwrite before use).
             event_loop: Cell::new(EventLoopHandle::init(core::ptr::null_mut())),
             lazy: JsCell::new(Lazy::None),
             buffered: JsCell::new(Vec::new()),
@@ -98,7 +97,7 @@ pub const TAG: readable_stream::Tag = readable_stream::Tag::File;
 #[derive(strum::IntoStaticStr)]
 pub enum ReadDuringJSOnPullResult {
     None,
-    // TODO(port): `&'static mut` forge — sibling `static-widen-mut` pattern;
+    // TODO(refactor): `&'static mut` forge — sibling `static-widen-mut` pattern;
     // see note on `FileReader::pending_view`.
     Js(&'static mut [u8]),
     AmountRead(usize),
@@ -118,8 +117,8 @@ impl ReadDuringJSOnPullResult {
 pub enum Lazy {
     None,
     /// Intrusively-refcounted `*Blob.Store`. Uses `StoreRef` (not `Arc`) so the
-    /// raw pointer carries mutable provenance from `heap::alloc`, matching
-    /// Zig's `*Blob.Store` direct-field-write usage in `openFileBlob`.
+    /// raw pointer carries mutable provenance from `heap::alloc` for the
+    /// direct field writes in `open_file_blob`.
     Blob(blob::StoreRef),
 }
 
@@ -141,7 +140,6 @@ impl Default for OpenedFileBlob {
     }
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     pub safe fn open_as_nonblocking_tty(fd: i32, flags: i32) -> i32;
 }
@@ -219,10 +217,6 @@ impl Lazy {
                 || (matches!(&file.pathlike, PathOrFileDescriptor::Fd(pl_fd)
                         if pl_fd.stdio_tag().is_some() && sys::isatty(*pl_fd)))
             {
-                // var termios = std.mem.zeroes(std.posix.termios);
-                // _ = std.c.tcgetattr(fd.cast(), &termios);
-                // bun.C.cfmakeraw(&termios);
-                // _ = std.c.tcsetattr(fd.cast(), std.posix.TCSA.NOW, &termios);
                 file.is_atty = Some(true);
             }
 
@@ -244,7 +238,7 @@ impl Lazy {
                 is_nonblocking = false;
             }
 
-            // sys.zig:isPollable — `S.ISFIFO(mode) or S.ISSOCK(mode)`
+            // pollable: `S.ISFIFO(mode) or S.ISSOCK(mode)`
             this.pollable = (sys::S::ISFIFO(mode) || sys::S::ISSOCK(mode))
                 || is_nonblocking
                 || file.is_atty.unwrap_or(false);
@@ -277,8 +271,8 @@ impl Lazy {
     }
 }
 
-// `bun.io.BufferedReader.init(@This())` — vtable parent. Maps the Zig
-// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop` decls.
+// BufferedReader vtable parent: wires the
+// `onReadChunk`/`onReaderDone`/`onReaderError`/`loop`/`eventLoop` callbacks.
 //
 // R-2: every mutated field on `FileReader` is `Cell`/`JsCell`/`UnsafeCell`-
 // backed, so materializing `&FileReader` via `(&*this)` does not assert Unique
@@ -293,7 +287,7 @@ bun_io::impl_buffered_reader_parent! {
     on_reader_error = |this, err| (&*this).on_reader_error(err);
     loop_ = |this| {
         let ev = (&*this).event_loop.get();
-        // Spec FileReader.zig:163: `this.eventLoop().loop()` → libuv
+        // The event loop is a libuv
         // `uv_loop_t*` on Windows. `.cast()` reconciles the impl-declared
         // `bun_uws_sys::Loop` nominal with `bun_io::Loop` (= `uv::Loop`).
         #[cfg(windows)] { ev.uv_loop().cast() }
@@ -307,7 +301,8 @@ impl FileReader {
     /// `UnsafeCell` note on the field declaration — this is the single point
     /// through which all `self.reader` access flows so vtable-callback
     /// re-entrancy and outer `&mut FileReader` borrows both root at the cell.
-    /// SAFETY: single-threaded; matches Zig `*FileReader` aliasing model.
+    /// SAFETY: single-threaded (JS event loop); the cell is the sole
+    /// SharedReadWrite root — see the unsafe block below.
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn reader(&self) -> &mut IOReader {
@@ -328,10 +323,8 @@ impl FileReader {
         self.event_loop().native_loop()
     }
 
-    // TODO(port): in-place init — `self` is the `context` field of an already-allocated
-    // `Source`; the Zig writes `this.* = FileReader{...}` then reads `parent()`. Note the
-    // Zig struct literal omits `event_loop` (no default) — likely dead code or relies on
-    // a quirk; preserved as-is.
+    // In-place init — `self` is the `context` field of an already-allocated
+    // `Source`; `event_loop` is set to its real value right after the reset.
     // R-2: kept `&mut self` — init-time constructor that runs before any
     // host-fn could re-enter; `*self =` requires unique access.
     pub fn setup(&mut self, fd: Fd) {
@@ -364,17 +357,14 @@ impl FileReader {
         if let Lazy::Blob(store) = self.lazy.replace(Lazy::None) {
             // `StoreRef::data_mut` encapsulates the raw-pointer deref under the
             // `StoreRef` liveness invariant (single-threaded JS event loop; we
-            // hold the only mutating handle). Matches Zig's `*Blob.Store`
-            // direct field access.
+            // hold the only mutating handle).
             match store.data_mut() {
                 blob::store::Data::S3(_) | blob::store::Data::Bytes(_) => {
                     panic!("Invalid state in FileReader: expected file ")
                 }
                 blob::store::Data::File(file) => {
-                    // PORT NOTE: reshaped for borrowck — Zig `defer { deref; lazy = none }`
-                    // is hoisted after the match below since both arms fall through.
                     let open_result = Lazy::open_file_blob(file);
-                    // drop the StoreRef (Zig: this.lazy.blob.deref()); `lazy` was already cleared above
+                    // drop the StoreRef; `lazy` was already cleared above
                     drop(store);
                     match open_result {
                         Err(err) => {
@@ -471,8 +461,7 @@ impl FileReader {
             let r = self.reader();
             if let Some(poll) = r.handle.get_poll() {
                 // `bun_io::FilePoll` is an opaque vtable wrapper; flag
-                // mutation goes through `set_flag(FilePollFlag)` instead of the
-                // direct `aio::FilePoll.flags.insert(...)` field write in Zig.
+                // mutation goes through `set_flag(FilePollFlag)`.
                 if file_type == FileType::Socket || r.flags.contains(PosixFlags::SOCKET) {
                     poll.set_flag(bun_io::FilePollFlag::Socket);
                 } else {
@@ -540,7 +529,7 @@ impl FileReader {
     // Only side-effect teardown lives here. Owned fields (buffered: Vec, reader:
     // BufferedReader, pending_value: Strong, lazy: Arc) drop when the caller
     // (`NewSource::decrement_count`) reclaims the `Box<Source>` *after* this
-    // returns. Freeing the parent here (Zig: `this.parent().deinit()`) would
+    // returns. Freeing the parent here would
     // deallocate the storage backing `&self` while the borrow is still live
     // — a dangling-reference UAF — so ownership release stays with the caller.
     fn deinit(&self) {
@@ -588,8 +577,8 @@ impl FileReader {
             return false;
         }
         let mut close = false;
-        // PORT NOTE: Zig `defer if (close) this.reader.close();` — handled at each return
-        // site below via `close_if_needed`. Reshaped for borrowck (scopeguard would alias &mut self).
+        // The close-on-exit is handled at each return
+        // site below via `close_if_needed` (a scopeguard would alias &mut self).
         macro_rules! close_if_needed {
             () => {
                 if close {
@@ -623,8 +612,7 @@ impl FileReader {
         // we still hold `&self` and mutate `self.buffered`/`self.pending` etc.
         // interleaved with reads/clears of `*reader_buffer`. Holding a `&mut Vec` here
         // would be the aliased-&mut forbidden pattern (PORTING.md §Forbidden patterns).
-        // Spec FileReader.zig:337 `const reader_buffer = this.reader.buffer();` is a Zig
-        // raw `*std.ArrayList(u8)` with no aliasing rules; we mirror that with a raw ptr
+        // Use a raw ptr
         // and deref only at the exact use sites below.
         let reader_buffer: *mut Vec<u8> = self.reader().buffer();
 
@@ -637,7 +625,7 @@ impl FileReader {
                     if in_progress.len() >= buf.len() && !has_more {
                         in_progress[0..buf.len()].copy_from_slice(buf);
                         let remaining: *mut [u8] = &raw mut in_progress[buf.len()..];
-                        // SAFETY: lifetime laundering matches the field's TODO(port) note.
+                        // SAFETY: lifetime laundering — see the `static-widen-mut` note on `ReadDuringJSOnPullResult::Js`.
                         let remaining = unsafe { &mut *remaining };
                         *riop = ReadDuringJSOnPullResult::Js(remaining);
                     } else if !in_progress.is_empty() && !has_more {
@@ -667,8 +655,7 @@ impl FileReader {
                 return true;
             }
 
-            // PORT NOTE: reshaped for borrowck — Zig `defer { clear; run() }` becomes a
-            // labeled block computing `ret`, then cleanup + run + return.
+            // A labeled block computes `ret`, then cleanup + run + return.
             let ret: bool = 'pending: {
                 let global = self.parent_global();
                 let mut pending_array_buffer = self
@@ -685,7 +672,7 @@ impl FileReader {
                         self.buffered.set(unsafe { mem::take(&mut *reader_buffer) }); // moveToUnmanaged
                     }
 
-                    // PORT NOTE: nested `defer buffer.clearAndFree` folded into the arms.
+                    // nested `defer buffer.clearAndFree` folded into the arms.
                     let buffer = self.buffered.replace(Vec::new());
                     if !buffer.is_empty() {
                         if pending_buf.len() >= buffer.len() {
@@ -811,7 +798,7 @@ impl FileReader {
     }
 
     pub fn on_pull(&self, buffer: &'static mut [u8], array: JSValue) -> streams::Result {
-        // TODO(port): lifetime — `buffer` borrows a JS typed array kept alive by `array`.
+        // `buffer` borrows a JS typed array kept alive by `array`.
         array.ensure_still_alive();
         let _keep = EnsureStillAlive(array);
         let drained = self.drain();
@@ -874,8 +861,7 @@ impl FileReader {
                 .set(ReadDuringJSOnPullResult::Js(buffer));
             self.reader().read();
 
-            // PORT NOTE: Zig `defer this.read_inside_on_pull = .none` — replaced via
-            // replace so the field is reset before matching, covering all return paths.
+            // `replace` resets the field before matching, covering all return paths.
             let pulled = self
                 .read_inside_on_pull
                 .replace(ReadDuringJSOnPullResult::None);
@@ -902,7 +888,7 @@ impl FileReader {
                     if self.reader().is_done() {
                         return streams::Result::Done;
                     }
-                    // PORT NOTE: fallthrough — but `buffer` was moved into read_inside_on_pull.
+                    // fallthrough — but `buffer` was moved into read_inside_on_pull.
                     // Recover it from `remaining_buf` (amount_read == 0 ⇒ same slice).
                     let global = self.parent_global();
                     self.pending_value.with_mut(|p| p.set(&global, array));
@@ -932,7 +918,7 @@ impl FileReader {
                     return streams::Result::Owned(Vec::<u8>::move_from_list(buffered));
                 }
                 _ => {
-                    // Spec FileReader.zig:544 `else => {}` falls through to set
+                    // Falls through to set
                     // `pending_view = buffer`. The only variants reaching this arm
                     // are `None` (impossible — we just stored `Js(buffer)` above and
                     // `on_read_chunk` never sets `None`) and `AmountRead` (never
@@ -1044,8 +1030,10 @@ impl FileReader {
     pub fn set_raw_mode(&self, _flag: bool) -> sys::Result<()> {
         #[cfg(not(windows))]
         {
-            // TODO(port): comptime string concat with Environment.os.displayString()
-            panic!("FileReader.setRawMode must not be called on this platform");
+            panic!(
+                "FileReader.setRawMode must not be called on {}",
+                std::env::consts::OS
+            );
         }
         #[cfg(windows)]
         {
@@ -1087,7 +1075,7 @@ impl FileReader {
 pub type Source = readable_stream::NewSource<FileReader>;
 
 // Intrusive backref: `self` is always the `context` field of a heap-allocated
-// `Source` (Zig `@fieldParentPtr("context", this)`). Returns `*mut Source`
+// `Source`. Returns `*mut Source`
 // (NOT `&mut Source`) because `self` IS the `context` field — materializing
 // `&mut Source` would alias the live `&self` borrow. Callers deref in a tight
 // `unsafe { (*ptr).method() }` scope and never hold `&mut Source` across other
@@ -1108,7 +1096,7 @@ impl readable_stream::SourceContext for FileReader {
     }
     fn on_pull(&mut self, buf: &mut [u8], arr: JSValue) -> streams::Result {
         // SAFETY: lifetime laundering — `buf` borrows a JS typed array kept alive
-        // by `arr` (see TODO(port) note at top of file).
+        // by `arr` (see the lifetime note at the top of the file).
         let buf = unsafe { &mut *std::ptr::from_mut::<[u8]>(buf) };
         Self::on_pull(self, buf, arr)
     }
@@ -1140,7 +1128,7 @@ impl readable_stream::SourceContext for FileReader {
 }
 
 // Local shim: `bun_io::ReadState` doesn't derive `IntoStaticStr` (upstream crate);
-// mirrors Zig `@tagName(state)` for the scoped log only.
+// used for the scoped log only.
 #[inline]
 fn read_state_tag(state: ReadState) -> &'static str {
     match state {
@@ -1162,5 +1150,3 @@ fn is_slice_in_vec_capacity(slice: &[u8], vec: &Vec<u8>) -> bool {
     let buf_start = vec.as_ptr() as usize;
     buf_start <= slice_start && (slice_start + slice.len()) <= (buf_start + vec.capacity())
 }
-
-// ported from: src/runtime/webcore/FileReader.zig
diff --git a/src/runtime/webcore/FileSink.rs b/src/runtime/webcore/FileSink.rs
index fa323d5816a..970c5e5f500 100644
--- a/src/runtime/webcore/FileSink.rs
+++ b/src/runtime/webcore/FileSink.rs
@@ -82,8 +82,7 @@ pub struct FileSink {
 // rather than `Rc<T>`.
 
 /// RAII owner of one intrusive ref on a `FileSink`. Drops the ref (and frees
-/// the allocation if it was the last) on scope exit. Replaces the Zig
-/// `self.ref(); defer self.deref();` pair without borrowing `self`.
+/// the allocation if it was the last) on scope exit, without borrowing `self`.
 struct FileSinkRef(*mut FileSink);
 
 impl FileSinkRef {
@@ -188,18 +187,17 @@ pub extern "C" fn FileSink__assertLive(_ptr: *const c_void) {}
 pub mod testing_apis {
     use super::*;
 
-    // TODO(port): #[bun_jsc::host_fn]
     pub fn file_sink_live_count(_global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
         Ok(JSValue::js_number(LIVE_COUNT.load(Ordering::Relaxed) as f64))
     }
 }
-// `generated_js2native.rs` snake-cases Zig's `TestingAPIs` as `testing_ap_is`
+// `generated_js2native.rs` snake-cases `TestingAPIs` as `testing_ap_is`
 // (acronym splitter treats `AP|Is` as two words); alias so both resolve.
 pub use testing_apis as testing_ap_is;
 
-/// Port of `bun.sys.isPollable` (sys.zig:4162) — `bun_sys` does not yet export
-/// this helper, so re-derive it locally from `S_IFMT`. Windows always returns
-/// `false` (the spec gates on `bun.Environment.isWindows`).
+/// `bun_sys` does not yet export
+/// an isPollable helper, so re-derive it locally from `S_IFMT`. Windows always
+/// returns `false`.
 fn is_pollable(mode: sys::Mode) -> bool {
     #[cfg(windows)]
     {
@@ -213,9 +211,9 @@ fn is_pollable(mode: sys::Mode) -> bool {
     }
 }
 
-/// `bun.io.StreamingWriter(@This(), opaque { onClose, onWritable, onError, onWrite })`.
-/// The Zig passes a comptime vtable via an `opaque {}` with decls; in Rust the
-/// parent type implements the handler trait directly.
+/// Streaming-writer vtable wiring: the
+/// parent type implements the handler trait
+/// (onClose / onWritable / onError / onWrite) directly.
 pub type IOWriter = bun_io::StreamingWriter<FileSink>;
 pub type Poll = IOWriter;
 
@@ -304,7 +302,7 @@ pub extern "C" fn Bun__ForceFileSinkToBeSynchronousForProcessObjectStdio(
     };
     // SAFETY: `from_js` returned a live `*mut JSSink<FileSink>` (= ThisSink); the
     // first field is `sink: FileSink`, so `&(*this_ptr).sink` recovers the
-    // wrapped `*FileSink` (Zig: `@ptrCast(@alignCast(JSSink.fromJS(...) orelse return))`).
+    // wrapped `*FileSink`.
     let this: &FileSink = unsafe { &(*this_ptr).sink };
 
     #[cfg(not(windows))]
@@ -325,7 +323,7 @@ pub extern "C" fn Bun__ForceFileSinkToBeSynchronousForProcessObjectStdio(
                     bun_io::Source::Pipe(pipe) => {
                         // SAFETY: `pipe` is a live `Box<uv::Pipe>` owned by `writer.source`;
                         // `uv_pipe_t` is `#[repr(C)]` with `uv_stream_t` as its first field
-                        // (libuv handle subtyping), so the pointer cast is valid (Zig: `@ptrCast(pipe)`).
+                        // (libuv handle subtyping), so the pointer cast is valid.
                         let rc = unsafe {
                             uv::uv_stream_set_blocking(
                                 (&mut **pipe) as *mut uv::Pipe as *mut uv::uv_stream_t,
@@ -339,7 +337,7 @@ pub extern "C" fn Bun__ForceFileSinkToBeSynchronousForProcessObjectStdio(
                     bun_io::Source::Tty(tty) => {
                         // SAFETY: `tty` is a live `NonNull<uv_tty_t>` (heap or static stdin tty);
                         // `uv_tty_t` embeds `uv_stream_t` as its first field, so the cast is the
-                        // libuv handle-subtype downcast (Zig: `@ptrCast(tty)`).
+                        // libuv handle-subtype downcast.
                         let rc = unsafe {
                             uv::uv_stream_set_blocking(tty.as_ptr().cast::<uv::uv_stream_t>(), 1)
                         };
@@ -638,8 +636,8 @@ impl FileSink {
             event_loop_handle: evtloop,
             // SAFETY: `pipe` is a live `*mut uv::Pipe` provided by the caller.
             // `UvHandle::fd()` returns the raw `uv_os_fd_t` (HANDLE on Windows);
-            // Zig's `HandleMixin.fd` maps INVALID_HANDLE_VALUE → `bun.invalid_fd`
-            // and otherwise tags kind=system via `.fromNative`.
+            // INVALID_HANDLE_VALUE maps to `Fd::INVALID`, anything else is
+            // tagged as a system handle.
             fd: Cell::new(match unsafe { (*pipe).fd() } {
                 h if h == uv::INVALID_HANDLE_VALUE => Fd::INVALID,
                 h => Fd::from_system(h),
@@ -655,9 +653,8 @@ impl FileSink {
         this
     }
 
-    // No `#[cfg(not(windows))]` arm: Zig's `@compileError` is lazy (fires only if
-    // called on POSIX), but Rust's `compile_error!` is eager. Omitting the fn on
-    // POSIX yields the equivalent "no associated function" compile error at call sites.
+    // No `#[cfg(not(windows))]` arm: omitting the fn on POSIX yields a
+    // "no associated function" compile error at call sites.
 
     pub fn create(event_loop_: impl Into<EventLoopHandle>, fd: Fd) -> *mut FileSink {
         let evtloop: EventLoopHandle = event_loop_.into();
@@ -682,8 +679,7 @@ impl FileSink {
             return sys::Result::Ok(());
         }
 
-        // PORT NOTE: reshaped for borrowck — Zig passed `self` + a closure that
-        // mutated `self.force_sync`. Split into a local capture and apply after.
+        // reshaped for borrowck — split into a local capture and apply after.
         // R-2: out-params for `bun_io::open_for_writing` are local then `Cell::set`.
         let mut force_sync_out = self.force_sync.get();
         let mut pollable_out = self.pollable.get();
@@ -876,7 +872,7 @@ impl FileSink {
         self.run_pending_later.has.set(true);
         if let EventLoopHandle::Js { owner } = self.event_loop() {
             self.ref_();
-            // `jsc.Task.init(&this.run_pending_later)` — the comptime type→tag
+            // The type→tag
             // map lives in `crate::dispatch`; the resolved tag for
             // `*FlushPendingTask` is `task_tag::FlushPendingFileSinkTask`.
             // Ptr identity only — `run_from_js_thread` recovers `*mut FileSink`
@@ -985,8 +981,8 @@ impl FileSink {
     }
 
     pub fn finalize(&mut self) {
-        // TODO(port): `.classes.ts` finalize — see PORTING.md §JSC. Runs during
-        // lazy sweep; must not touch live JS cells.
+        // `.classes.ts` finalize — see PORTING.md §JSC. Runs during lazy sweep;
+        // must not touch live JS cells.
 
         // ── #53265 magic check (must be FIRST — before any field deref) ──────
         #[cfg(windows)]
@@ -1072,9 +1068,7 @@ impl FileSink {
         // `ref_count=1` and that +1 belongs to the wrapper it's about to be
         // stored in, so no extra `ref_()` there.
         //
-        // PORT NOTE: Zig's `FileSink.toJS` does *not* `self.ref()` — it relies
-        // on the caller's existing +1 transferring to the wrapper. The Rust
-        // port makes the per-wrapper +1 explicit so the protocol is locally
+        // The per-wrapper +1 is explicit so the protocol is locally
         // verifiable (N wrappers ⇒ N `ref_()` ⇒ N `finalize` ⇒ N `deref()`),
         // **but** that means callers that allocate via `init`/`create` and
         // then `to_js()` must `deref()` once to release init's +1 (see
@@ -1180,8 +1174,9 @@ impl FileSink {
         this
     }
 
-    // TODO(port): in-place init — `construct` is called by JSSink codegen on a
-    // pre-allocated `m_ctx` slot. May need `&mut MaybeUninit<Self>`.
+    // Called by JSSink codegen on a pre-allocated `m_ctx` slot via
+    // `JsSinkType::construct(&mut MaybeUninit<Self>)`, which `write`s this
+    // by-value result into the slot.
     pub fn construct() -> FileSink {
         let this = FileSink {
             ref_count: Cell::new(1),
@@ -1285,8 +1280,8 @@ impl FileSink {
             // wrapper finalize already ran, vs (b) keep-alive still set →
             // process_send's ref was the only one, vs (c) `done` never set →
             // end_from_js Wrote arm took a different path. The 3-tracer audit
-            // (w9qxc9jg1) verified the static ladder is balanced 4:4 with
-            // Zig; this captures the dynamic state.
+            // (w9qxc9jg1) verified the static ladder is balanced 4:4;
+            // this captures the dynamic state.
             let state = format!(
                 "STATE: must_be_kept_alive={} done={} started={} fd={:?} written={} \
                  pending.state={} owns_fd={} writer.is_done={} writer.has_pending={} \
@@ -1309,8 +1304,7 @@ impl FileSink {
         }
         #[cfg(windows)]
         self_.magic.set(FILESINK_DEAD);
-        // PORT NOTE: pending/readable_stream/js_sink_ref are dropped by Box drop
-        // below; explicit `.deinit()` calls from the Zig are subsumed.
+        // pending/readable_stream/js_sink_ref are dropped by Box drop below.
         if let Some(global) = self_.js_global() {
             // SAFETY: `bun_vm()` is non-null when `js_global()` returned Some.
             let vm = global.bun_vm().as_mut();
@@ -1329,7 +1323,7 @@ impl FileSink {
     pub fn to_js_with_destructor(
         &mut self,
         global_this: &JSGlobalObject,
-        // PORT NOTE: `sink::DestructorPtr` is `TaggedPtrUnion<(Detached, Detached)>`
+        // `sink::DestructorPtr` is `TaggedPtrUnion<(Detached, Detached)>`
         // which does not satisfy `bun_ptr::TypeList` yet (sibling Sink.rs); accept
         // the encoded usize directly until that lands.
         destructor: Option<usize>,
@@ -1528,16 +1522,16 @@ impl FileSink {
         }
     }
 
-    // Helper for struct-init defaults (Zig field defaults).
-    // TODO(port): replace with `impl Default for FileSink` once all field types
-    // implement `Default`; kept private to avoid exposing a half-initialized state.
+    // Helper for struct-init defaults. `EventLoopHandle` has
+    // no `Default`, so `impl Default for FileSink` is not possible; kept private
+    // to avoid exposing a half-initialized state.
     fn default_fields() -> FileSink {
         FileSink {
             ref_count: Cell::new(1),
             #[cfg(windows)]
             magic: Cell::new(FILESINK_LIVE),
             writer: JsCell::new(IOWriter::default()),
-            // PORT NOTE: `EventLoopHandle` has no `Default`; null Js variant is the
+            // `EventLoopHandle` has no `Default`; null Js variant is the
             // closest sentinel — every constructor overwrites this field.
             // SAFETY: sentinel only; never dispatched (overwritten before use).
             event_loop_handle: EventLoopHandle::init(core::ptr::null_mut()),
@@ -1619,7 +1613,6 @@ impl FileSink {
     }
 }
 
-// TODO(port): #[bun_jsc::host_fn]
 fn on_resolve_stream(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
     bun_core::scoped_log!(FileSink, "onResolveStream");
     let args = callframe.arguments();
@@ -1631,7 +1624,6 @@ fn on_resolve_stream(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsR
     Ok(JSValue::UNDEFINED)
 }
 
-// TODO(port): #[bun_jsc::host_fn]
 fn on_reject_stream(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
     bun_core::scoped_log!(FileSink, "onRejectStream");
     let args = callframe.arguments();
@@ -1660,7 +1652,7 @@ impl FileSink {
 
         self.readable_stream
             .set(readable_stream::Strong::init(*stream, global_this));
-        // PORT NOTE: reshaped for borrowck — re-derive `signal_ptr` after
+        // reshaped for borrowck — re-derive `signal_ptr` after
         // assigning `readable_stream`. `JsCell::as_ptr` yields the stable
         // address of the inner `Signal` (`#[repr(transparent)]` over
         // `UnsafeCell`).
@@ -1670,10 +1662,9 @@ impl FileSink {
         // JSValue bits back through this `void**`.
         let signal_ptr: *mut *mut c_void =
             unsafe { (&raw mut (*self.signal.as_ptr()).ptr).cast::<*mut c_void>() };
-        // Zig parity (FileSink.zig:801-802): only the transient `_guard` above
+        // Only the transient `_guard` above
         // — NO per-wrapper +1 for the controller. df4f2c44 added a `ref_()`
-        // here under the (false) premise that Zig refs per-wrapper; it does
-        // not. The JS builtins always call `controller.end()`/`.close()`
+        // here, which was wrong: the JS builtins always call `controller.end()`/`.close()`
         // (`${controller}__end/close` → `controller->detach()` → m_sinkPtr=null)
         // before GC, so the controller's dtor never reaches `finalize` and
         // that +1 was never balanced — pure leak on every `assign_to_stream`,
@@ -1690,7 +1681,7 @@ impl FileSink {
 
         if !promise_result.is_empty_or_undefined_or_null() {
             if let Some(promise) = promise_result.as_any_promise() {
-                // PORT NOTE: `bun_jsc::AnyPromise` (the active raw-ptr variant in
+                // `bun_jsc::AnyPromise` (the active raw-ptr variant in
                 // lib.rs) does not yet expose `status()`/`result()`; recover the
                 // underlying `JSPromise` (JSInternalPromise subclasses JSPromise
                 // in C++, so the cast is layout-safe).
@@ -1705,7 +1696,7 @@ impl FileSink {
                             .with_mut(|w| w.enable_keeping_process_alive(self.io_evtloop()));
                         self.ref_();
                         // TODO: properly propagate exception upwards
-                        // PORT NOTE: `JSValue::then` takes already-wrapped C-ABI
+                        // `JSValue::then` takes already-wrapped C-ABI
                         // host fns; the `toJSHostFunction` step is the manual
                         // shims at the bottom of this file.
                         promise_result.then(
@@ -1733,9 +1724,8 @@ impl FileSink {
     }
 }
 
-// `comptime { @export(&jsc.toJSHostFn(onResolveStream), ...) }`
 // `#[bun_jsc::host_fn]` proc-macro is not yet ported, so emit the
-// `callconv(jsc.conv)` shim by hand and export under the C symbol names the
+// JSC host-function ABI shim by hand and export under the C symbol names the
 // C++ side expects.
 //
 // IMPORTANT: these MUST be exported as *function* symbols (not as `static`
@@ -1745,9 +1735,6 @@ impl FileSink {
 // `Zig::GlobalObject::promiseHandlerID`. A `pub static …: JSHostFn = shim`
 // exports the address of an 8-byte data slot, which never equals the shim's
 // code address → RELEASE_ASSERT_NOT_REACHED at runtime.
-//
-// TODO(refactor): replace with `#[bun_jsc::host_fn]` and gate on an
-// `export_cpp_apis` feature.
 bun_jsc::jsc_host_abi! {
     #[unsafe(export_name = "Bun__FileSink__onResolveStream")]
     unsafe fn on_resolve_stream_shim(
@@ -1779,6 +1766,4 @@ bun_jsc::jsc_host_abi! {
     }
 }
 
-// ported from: src/runtime/webcore/FileSink.zig
-
 // ─── DIAGNOSTIC: FileSink layout probe (Windows fs-promises Strong corruption) ───
diff --git a/src/runtime/webcore/FormData.rs b/src/runtime/webcore/FormData.rs
index 383f855fb14..7bbe91c67fc 100644
--- a/src/runtime/webcore/FormData.rs
+++ b/src/runtime/webcore/FormData.rs
@@ -1,11 +1,10 @@
-//! HTML `FormData` parsing + JS bridge. Moved from `url/url.zig` because the
-//! struct is webcore (fetch Body) and JSC-heavy; `url/` is JSC-free.
+//! HTML `FormData` parsing + JS bridge.
 
 use bun_collections::ArrayHashMap;
 use bun_core::{self, declare_scope, err, scoped_log};
 use bun_core::{ZigString, ZigStringSlice, strings};
 use bun_jsc::{
-    AnyPromise, CallFrame, DOMFormData, JSGlobalObject, JSValue, JsError, JsResult,
+    AnyPromise, CallFrame, DOMFormData, JSGlobalObject, JSValue, JsError, JsResult, JsTerminated,
     ZigStringJsc as _,
 };
 use bun_semver::{self, SlicedString};
@@ -16,16 +15,13 @@ use crate::webcore::BlobExt as _;
 
 declare_scope!(FormData, visible);
 
-pub struct FormData {
-    pub fields: Map,
-    // TODO(port): lifetime — borrows into caller-owned input; could lift
-    // to `&'a [u8]` once borrowck threads through callers.
-    pub buffer: *const [u8],
+pub struct FormData<'a> {
+    pub fields: Map<'a>,
+    /// Borrows into caller-owned input.
+    pub buffer: &'a [u8],
 }
 
-pub type Map = ArrayHashMap<bun_semver::String, FieldEntry>;
-// PORT NOTE: Zig used `bun.Semver.String.ArrayHashContext` + store_hash=false;
-// `bun_collections::ArrayHashMap` is wyhash-keyed — TODO(port): confirm context match.
+pub type Map<'a> = ArrayHashMap<bun_semver::String, FieldEntry<'a>>;
 
 // `Encoding`, `get_boundary`, and `AsyncFormData` are JSC-free and live in the
 // lower-tier `bun_core::form_data` so `Body`/`Request`/`Response` can name them
@@ -36,13 +32,23 @@ pub use bun_core::form_data::{AsyncFormData, Encoding, get_boundary};
 /// JSC-touching extension on `AsyncFormData` (lives in this crate because it
 /// needs `JSGlobalObject` + `AnyPromise`).
 pub trait AsyncFormDataExt {
-    fn to_js(&self, global: &JSGlobalObject, data: &[u8], promise: AnyPromise) -> JsResult<()>;
+    fn to_js(
+        &self,
+        global: &JSGlobalObject,
+        data: &[u8],
+        promise: AnyPromise,
+    ) -> Result<(), JsTerminated>;
 }
 
 impl AsyncFormDataExt for AsyncFormData {
-    // TODO(port): `bun.JSTerminated!void` — mapped to `JsResult<()>`; could
-    // narrow to a `Terminated`-only error set if one exists.
-    fn to_js(&self, global: &JSGlobalObject, data: &[u8], promise: AnyPromise) -> JsResult<()> {
+    // Only a VM-termination error can escape
+    // (JS exceptions are routed into the promise rejection above).
+    fn to_js(
+        &self,
+        global: &JSGlobalObject,
+        data: &[u8],
+        promise: AnyPromise,
+    ) -> Result<(), JsTerminated> {
         if let Encoding::Multipart(b) = &self.encoding {
             if b.is_empty() {
                 scoped_log!(
@@ -76,20 +82,19 @@ impl AsyncFormDataExt for AsyncFormData {
 /// Raw slice into the input buffer. Not using `bun.Semver.String` because
 /// file bodies are binary data that can contain null bytes, which
 /// Semver.String's inline storage treats as terminators.
-pub struct Field {
-    // TODO(port): lifetime — borrows into caller-owned input buffer (binary
-    // body slice, never freed here); could lift to `&'a [u8]`.
-    pub value: *const [u8],
+pub struct Field<'a> {
+    /// Borrows into the caller-owned input buffer (binary body slice).
+    pub value: &'a [u8],
     pub filename: bun_semver::String,
     pub content_type: bun_semver::String,
     pub is_file: bool,
     pub zero_count: u8,
 }
 
-impl Default for Field {
+impl Default for Field<'_> {
     fn default() -> Self {
         Field {
-            value: std::ptr::from_ref::<[u8]>(b""),
+            value: b"",
             filename: bun_semver::String::default(),
             content_type: bun_semver::String::default(),
             is_file: false,
@@ -98,9 +103,9 @@ impl Default for Field {
     }
 }
 
-pub enum FieldEntry {
-    Field(Field),
-    List(Vec<Field>),
+pub enum FieldEntry<'a> {
+    Field(Field<'a>),
+    List(Vec<Field<'a>>),
 }
 
 #[repr(C)]
@@ -120,8 +125,7 @@ impl Default for FieldExternal {
     }
 }
 
-impl FormData {
-    // TODO(port): narrow error set
+impl FormData<'_> {
     pub fn to_js(
         global: &JSGlobalObject,
         input: &[u8],
@@ -139,16 +143,12 @@ impl FormData {
     }
 }
 
-// Zig: `@export(&jsc.toJSHostFn(fromMultipartData), .{ .name = "FormData__jsFunctionFromMultipartData" })`
 #[bun_jsc::host_fn(export = "FormData__jsFunctionFromMultipartData")]
 pub fn from_multipart_data(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-    // PORT NOTE: `jsc.markBinding(@src())` dropped — debug-only source marker.
-
     let args = frame.arguments_old::<2>();
     let input_value = args.ptr[0];
     let boundary_value = args.ptr[1];
     let boundary_slice: ZigStringSlice;
-    // PORT NOTE: `defer boundary_slice.deinit()` — handled by `Drop`.
 
     let mut encoding = Encoding::URLEncoded;
 
@@ -173,7 +173,6 @@ pub fn from_multipart_data(global: &JSGlobalObject, frame: &CallFrame) -> JsResu
         }
     }
     let input_slice: ZigStringSlice;
-    // PORT NOTE: `defer input_slice.deinit()` — handled by `Drop`.
     // Keep the `ArrayBuffer` view alive for the duration of `input`'s borrow.
     let input_array_buffer;
     let input: &[u8];
@@ -199,7 +198,6 @@ pub fn from_multipart_data(global: &JSGlobalObject, frame: &CallFrame) -> JsResu
     }
 }
 
-// TODO(port): narrow error set
 pub fn to_js_from_multipart_data(
     global: &JSGlobalObject,
     input: &[u8],
@@ -218,22 +216,19 @@ pub fn to_js_from_multipart_data(
     }
 
     impl<'a> Wrapper<'a> {
-        fn on_entry(wrap: &mut Self, name: bun_semver::String, field: &Field, buf: &[u8]) {
-            // SAFETY: `field.value` points into `buf` (caller-owned input), valid for this call.
-            let value_str: &[u8] = unsafe { &*field.value };
+        fn on_entry(wrap: &mut Self, name: bun_semver::String, field: &Field<'_>, buf: &[u8]) {
+            let value_str: &[u8] = field.value;
             let key = ZigString::init_utf8(name.slice(buf));
 
             if field.is_file {
                 let filename_str = field.filename.slice(buf);
 
-                // PORT NOTE: dropped `bun.default_allocator` arg.
                 let mut blob = Blob::create(value_str, wrap.global, false);
                 let filename = ZigString::init_utf8(filename_str);
 
-                // PORT NOTE: Zig used a labeled `:brk` block returning a borrowed
-                // `[]const u8`. `MimeType.value` is now `Cow<'static,[u8]>`, so
-                // split the two ownership cases instead of unifying through a
-                // single `&[u8]` (avoids borrowing a temporary).
+                // `MimeType.value` is `Cow<'static,[u8]>`, so split the two
+                // ownership cases instead of unifying through a single
+                // `&[u8]` (avoids borrowing a temporary).
                 if !field.content_type.is_empty() {
                     let ct = field.content_type.slice(buf);
                     blob.content_type_allocated.set(true);
@@ -280,11 +275,8 @@ pub fn to_js_from_multipart_data(
                     (&raw mut blob).cast::<c_void>(),
                     &filename,
                 );
-                // PORT NOTE: Zig `defer blob.detach()` — no early returns in
-                // this branch, so call explicitly at scope end.
                 // `append_blob` dupes the content type, so the copy boxed above
-                // is solely owned by this stack-local and must be released here
-                // (Zig stored a borrowed slice and had nothing to free).
+                // is solely owned by this stack-local and must be released here.
                 blob.detach();
                 blob.free_content_type();
             } else {
@@ -315,20 +307,19 @@ pub fn to_js_from_multipart_data(
     Ok(form_data_value)
 }
 
-// TODO(port): narrow error set
 pub fn for_each_multipart_entry<C>(
     input: &[u8],
     boundary: &[u8],
     ctx: &mut C,
-    mut iterator: impl FnMut(&mut C, bun_semver::String, &Field, &[u8]),
+    mut iterator: impl FnMut(&mut C, bun_semver::String, &Field<'_>, &[u8]),
 ) -> Result<(), bun_core::Error> {
     let mut slice = input;
     let subslicer = SlicedString::init(input, input);
 
     let mut buf = [0u8; 76];
     {
-        // PORT NOTE: hand-rolled `std.fmt.bufPrint(&buf, "--{s}--", .{boundary})`
-        // — boundary is raw bytes, not guaranteed UTF-8, so avoid `core::fmt`.
+        // Hand-rolled `--{boundary}--` formatting — boundary is raw bytes,
+        // not guaranteed UTF-8, so avoid `core::fmt`.
         let need = boundary.len() + 4;
         if need > buf.len() {
             return Err(err!("boundary is too long"));
@@ -344,7 +335,7 @@ pub fn for_each_multipart_entry<C>(
         slice = &slice[..final_boundary_index];
     }
 
-    // PORT NOTE: hand-rolled `std.fmt.bufPrint(&buf, "--{s}\r\n", .{boundary})`.
+    // Hand-rolled `--{boundary}\r\n` formatting (same raw-bytes caveat).
     // Length check already passed above (same `boundary.len() + 4`).
     let sep_len = boundary.len() + 4;
     buf[..2].copy_from_slice(b"--");
@@ -470,5 +461,3 @@ pub fn for_each_multipart_entry<C>(
 
     Ok(())
 }
-
-// ported from: src/runtime/webcore/FormData.zig
diff --git a/src/runtime/webcore/ObjectURLRegistry.rs b/src/runtime/webcore/ObjectURLRegistry.rs
index 1976411a0bf..c24d351528b 100644
--- a/src/runtime/webcore/ObjectURLRegistry.rs
+++ b/src/runtime/webcore/ObjectURLRegistry.rs
@@ -9,9 +9,7 @@ use bun_threading::Guarded;
 use crate::webcore::Blob;
 use crate::webcore::BlobExt as _;
 
-// PORT NOTE: reshaped for borrowck — Zig had separate `lock: bun.Mutex` and
-// `map: AutoHashMap` fields with manual lock()/unlock() around every access.
-// In Rust the map is wrapped in a `Guarded` (mutex + value).
+// The map is wrapped in a `Guarded` (mutex + value).
 //
 // Key is `[u8; 16]` (the UUID bytes) rather than `UUID` directly because
 // upstream `bun_jsc::UUID` does not yet derive `Hash + Eq`; using the raw
@@ -49,9 +47,8 @@ impl Entry {
 
 impl Drop for Entry {
     fn drop(&mut self) {
-        // Zig `Entry.deinit`: `this.blob.deinit(); bun.destroy(this);`.
         self.blob.deinit();
-        // `bun.destroy(this)` ↔ `Box<Entry>` drop.
+        // The allocation itself is freed by the `Box<Entry>` drop.
     }
 }
 
@@ -90,7 +87,7 @@ impl ObjectURLRegistry {
         let Some(uuid) = uuid_from_pathname(pathname) else {
             return;
         };
-        // Box<Entry> dropped here (was `entry.value.deinit()` in Zig)
+        // Box<Entry> dropped here
         let _ = self.map.lock().remove(&uuid.bytes);
     }
 
@@ -141,7 +138,7 @@ pub(crate) fn bun_revoke_object_url(
         );
     }
     // `to_bun_string` returns a +1 ref; `bun_core::String` is `Copy` (no Drop),
-    // so wrap in `OwnedString` for scope-exit `deref()` — Zig's `defer str.deref()`.
+    // so wrap in `OwnedString` for scope-exit `deref()`.
     let str = bun_core::OwnedString::new(
         arguments.ptr[0]
             .to_bun_string(global_object)
@@ -152,7 +149,7 @@ pub(crate) fn bun_revoke_object_url(
     }
 
     let slice = str.to_utf8_without_ref();
-    // `defer slice.deinit()` → ZigStringSlice Drop
+    // released by ZigStringSlice Drop
 
     let sliced = slice.slice();
     if sliced.len() < b"blob:".len() + UUID::STRING_LENGTH {
@@ -176,8 +173,7 @@ pub(crate) fn js_function_resolve_object_url(
         return Ok(JSValue::UNDEFINED);
     }
     // `to_bun_string` returns a +1 ref; wrap in `OwnedString` so every exit
-    // path (exception, non-blob prefix, success) releases it — Zig's
-    // `defer str.deref()`.
+    // path (exception, non-blob prefix, success) releases it.
     let str = bun_core::OwnedString::new(arguments.ptr[0].to_bun_string(global_object)?);
 
     if global_object.has_exception() {
@@ -201,5 +197,3 @@ pub(crate) const SPECIFIER_LEN: usize = b"blob:".len() + UUID::STRING_LENGTH;
 pub(crate) fn is_blob_url(url: &[u8]) -> bool {
     url.len() >= SPECIFIER_LEN && strings::has_prefix_comptime(url, b"blob:")
 }
-
-// ported from: src/runtime/webcore/ObjectURLRegistry.zig
diff --git a/src/runtime/webcore/ReadableStream.rs b/src/runtime/webcore/ReadableStream.rs
index 6ed7c561201..637b437a23b 100644
--- a/src/runtime/webcore/ReadableStream.rs
+++ b/src/runtime/webcore/ReadableStream.rs
@@ -24,7 +24,7 @@ pub struct Strong {
     held: bun_jsc::strong::Optional, // jsc.Strong.Optional = .empty
 }
 
-/// Re-export under the qualified name callers expect (Zig: `webcore.ReadableStream.Strong`).
+/// Re-export under the qualified name callers expect.
 pub type ReadableStreamStrong = Strong;
 
 impl Default for Strong {
@@ -74,8 +74,6 @@ impl Strong {
     }
 
     // deinit: body only calls held.deinit() → handled by Drop on bun_jsc::Strong.
-    // Commented-out Zig:
-    //   if (this.held.get()) |val| { ReadableStream__detach(val, this.held.globalThis.?); }
 
     pub(crate) fn tee(&mut self, global: &JSGlobalObject) -> JsResult<Option<ReadableStream>> {
         if let Some(stream) = self.get(global) {
@@ -90,7 +88,6 @@ impl Strong {
 }
 
 // ─── extern fns ──────────────────────────────────────────────────────────────
-// TODO(port): move to runtime_sys / bun_jsc_sys
 
 unsafe extern "C" {
     /// C++ writes the two teed-stream JSValues into the out-params; reference
@@ -193,8 +190,6 @@ impl ReadableStream {
                 // R-2: `lazy`/`started` are `JsCell`/`Cell`; shared borrow suffices.
                 let blobby = self.ptr.file().expect("matched File");
                 if let webcore::file_reader::Lazy::Blob(store) = blobby.lazy.get() {
-                    // `store.clone()` carries the +1 that Zig's explicit `blob.store.?.ref()`
-                    // provided after the raw-pointer copy in `initWithStore`.
                     let blob = Blob::init_with_store(store.clone(), global_this);
                     // it should be lazy, file shouldn't have opened yet.
                     debug_assert!(!blobby.started.get());
@@ -266,9 +261,7 @@ impl ReadableStream {
     /// Decrement Source ref count and detach the underlying stream if ref count is zero
     /// be careful, this can invalidate the stream do not call this multiple times
     /// this is meant to be called only once when we are done consuming the stream or from the ReadableStream.Strong.deinit
-    pub fn detach_if_possible(&self, _global: &JSGlobalObject) {
-        // (intentionally empty in Zig)
-    }
+    pub fn detach_if_possible(&self, _global: &JSGlobalObject) {}
 
     pub fn is_disturbed(&self, global_object: &JSGlobalObject) -> bool {
         is_disturbed_value(self.value, global_object)
@@ -311,7 +304,6 @@ impl ReadableStream {
                 // SAFETY: tag == Bytes ⇒ ptr is a non-null *ByteStream from C++.
                 ptr: Source::Bytes(ptr.cast::<ByteStream>()),
             }),
-            // .HTTPRequest / .HTTPSRequest commented out in Zig
             _ => None,
         })
     }
@@ -324,7 +316,6 @@ impl ReadableStream {
 
     pub fn from_owned_slice(
         global_this: &JSGlobalObject,
-        // Zig: `bytes: []u8` — owned slice; accept Vec<u8> / Box<[u8]> alike.
         bytes: impl Into<Vec<u8>>,
         recommended_chunk_size: webcore::blob::SizeType,
     ) -> JsResult<JSValue> {
@@ -343,9 +334,6 @@ impl ReadableStream {
         };
         match &store.data {
             webcore::blob::store::Data::Bytes(_) => {
-                // PORT NOTE: Zig left `context: undefined` then called `setup()` to initialize
-                // in place. Rust constructs with `Default` (no UB) and `setup()` overwrites
-                // the entire struct via `*self = ByteBlobLoader { ... }`.
                 let reader = NewSource::<ByteBlobLoader>::new_mut(NewSource {
                     global_this: Some(bun_ptr::BackRef::new(global_this)),
                     context: ByteBlobLoader::default(),
@@ -367,8 +355,6 @@ impl ReadableStream {
                         } else {
                             None
                         },
-                        // `store.clone()` is the RAII +1 equivalent of Zig's `store.ref()`
-                        // after the raw `.lazy = .{ .blob = store }` assignment.
                         lazy: bun_jsc::JsCell::new(webcore::file_reader::Lazy::Blob(store.clone())),
                         ..Default::default()
                     },
@@ -423,7 +409,6 @@ impl ReadableStream {
                             global_this.bun_vm().as_mut().event_loop().cast(),
                         )),
                         start_offset: Some(offset),
-                        // `store.clone()` is the RAII +1 equivalent of Zig's `store.ref()`.
                         lazy: bun_jsc::JsCell::new(webcore::file_reader::Lazy::Blob(store.clone())),
                         ..Default::default()
                     },
@@ -450,7 +435,6 @@ impl ReadableStream {
             },
             ..Default::default()
         });
-        // PORT NOTE: reshaped for borrowck — Zig passed `&source.context` as both reader-parent and self.
         let ctx_ptr: *mut FileReader = &raw mut source.context;
         source
             .context
@@ -580,15 +564,10 @@ impl Source {
 
 // ─── NewSource ───────────────────────────────────────────────────────────────
 //
-// Zig: `pub fn NewSource(comptime Context: type, comptime name_: []const u8,
-//                        comptime onStart, onPull, onCancel, deinit_fn,
-//                        setRefUnrefFn?, drainInternalBuffer?, memoryCostFn?,
-//                        toBufferedValue?) type { return struct {...} }`
-//
-// Rust: the comptime fn-pointer bundle becomes a trait `SourceContext` that
-// each `Context` type implements; `NewSource<C>` is the generic struct.
+// Each `Context` type implements the `SourceContext` trait; `NewSource<C>` is
+// the generic struct over it.
 
-/// Trait capturing the comptime fn params of Zig's `NewSource(...)`.
+/// Per-context configuration and callbacks for `NewSource<C>`.
 pub trait SourceContext: Sized {
     /// `name_` — used to look up `jsc.Codegen.JS{NAME}InternalReadableStreamSource`.
     const NAME: &'static str;
@@ -596,7 +575,6 @@ pub trait SourceContext: Sized {
     const SUPPORTS_REF: bool = false;
 
     // ─── codegen accessors (`.classes.ts` → `generated_classes.rs`) ───────────
-    // Zig: `js = @field(jsc.Codegen, "JS" ++ name ++ "InternalReadableStreamSource")`.
     // Each context binds its per-type codegen module via `source_context_codegen!`.
     /// `js_${NAME}InternalReadableStreamSource::to_js` — `ptr` is the
     /// type-erased `*mut NewSource<Self>` (cast inside the macro impl).
@@ -622,10 +600,10 @@ pub trait SourceContext: Sized {
         false
     }
 
-    /// `setRefUnrefFn` — default no-op (Zig: `?fn`, null ⇒ ref/unref are no-ops).
+    /// `setRefUnrefFn` — default no-op.
     fn set_ref_unref(&mut self, _enable: bool) {}
 
-    /// `drainInternalBuffer` — default returns empty (Zig: `?fn`, null ⇒ `.{}`).
+    /// `drainInternalBuffer` — default returns empty.
     fn drain_internal_buffer(&mut self) -> Vec<u8> {
         Vec::<u8>::default()
     }
@@ -644,25 +622,26 @@ pub trait SourceContext: Sized {
         None
     }
 
-    /// `@hasDecl(Context, "setRawMode")` — default: not present.
     /// Returns `None` if the context type does not support raw mode.
-    // TODO(port): Zig used @compileError when absent + codegen referenced; Rust default panics never reached if codegen omits it.
+    /// The `None` default is only reachable if codegen wires `setRawMode` for
+    /// a context that does not implement it (see `set_raw_mode_from_js`).
     fn set_raw_mode(&mut self, _flag: bool) -> Option<bun_sys::Result<()>> {
         None
     }
 
-    /// `@hasDecl(Context, "setFlowing")` — default no-op.
+    /// Default no-op.
     fn set_flowing(&mut self, _flag: bool) {}
 }
 
-// TODO(port): #[bun_jsc::JsClass] — codegen name is "JS{C::NAME}InternalReadableStreamSource".
-// The Zig `js = @field(jsc.Codegen, ...)` + toJS/fromJS/fromJSDirect aliases are wired by the
-// derive; cached-property accessors (pendingPromiseSetCached, onDrainCallback{Get,Set}Cached)
-// are emitted by the .classes.ts generator.
+// Hand-wired JSC class (the `#[bun_jsc::JsClass]` derive cannot be used on a
+// type generic over `C`): codegen name is "JS{C::NAME}InternalReadableStreamSource".
+// The toJS/fromJS/fromJSDirect aliases are wired
+// manually below; cached-property accessors (pendingPromiseSetCached,
+// onDrainCallback{Get,Set}Cached) are emitted by the .classes.ts generator.
 //
 // `repr(C)` keeps `context` at offset 0: C++ `wrapped()` returns `*mut NewSource<C>` and
-// [`ReadableStream::from_js`] casts that straight to `*mut C` (matching Zig, where `context`
-// is the first field). With Rust's default repr the field is reordered and the cast reads
+// [`ReadableStream::from_js`] casts that straight to `*mut C`.
+// With Rust's default repr the field is reordered and the cast reads
 // adjacent fields as the loader, returning empty bodies.
 #[repr(C)]
 pub struct NewSource<C: SourceContext> {
@@ -671,7 +650,9 @@ pub struct NewSource<C: SourceContext> {
     pub ref_count: u32,
     pub pending_err: Option<syscall::Error>,
     pub close_handler: Option<fn(Option<*mut c_void>)>,
-    // TODO(port): lifetime — TSV class UNKNOWN
+    /// Borrowed opaque context for native `close_handler`s (never
+    /// owned/freed here). The JS path stores
+    /// `on_js_close` and leaves this `None` — see [`Self::on_close`].
     pub close_ctx: Option<NonNull<c_void>>,
     pub close_jsvalue: bun_jsc::strong::Optional,
     /// R-2: cleared via `&self` from `FetchTasklet::clear_stream_cancel_handler`
@@ -710,9 +691,7 @@ impl<C: SourceContext + Default> Default for NewSource<C> {
 }
 
 // ─── per-type codegen accessors ──────────────────────────────────────────────
-// Zig: `js = @field(jsc.Codegen, "JS" ++ name ++ "InternalReadableStreamSource")`
-// resolves to a *per-type* generated module; in Rust there is no inherent
-// associated-module syntax, so each `SourceContext` impl carries the codegen
+// Each `SourceContext` impl carries the per-type codegen
 // extern symbols as associated consts (bound via `source_context_codegen!`).
 // The `.classes.ts` → `.rs` generator (when re-run with Rust output) is expected
 // to emit those `const JS_*` bindings directly.
@@ -803,15 +782,14 @@ impl<C: SourceContext> NewSource<C> {
             .get()
     }
 
-    /// `bun.TrivialNew(@This())` — heap-allocate and hand back the raw pointer.
+    /// Heap-allocate and hand back the raw pointer.
     ///
     /// Ownership is **not** retained by Rust: the returned pointer is intended to
     /// be installed as the JS wrapper's `m_ctx` via [`Self::to_readable_stream`]
     /// (or [`NewSourceCodegen::to_js`]), after which the GC finalizer drives
     /// teardown through [`Self::decrement_count`] → context `deinit_fn` →
     /// [`Self::deinit`]. Dropping a `Box` here would free the allocation while
-    /// the JS cell still points at it (UAF), so this mirrors Zig's `TrivialNew`
-    /// exactly and returns `*mut Self`.
+    /// the JS cell still points at it (UAF), so this returns `*mut Self`.
     pub fn new(init: Self) -> *mut Self {
         bun_core::heap::into_raw(Box::new(init))
     }
@@ -832,7 +810,6 @@ impl<C: SourceContext> NewSource<C> {
         // lifetime is correct (no Rust owner will drop underneath the borrow).
         unsafe { &mut *Self::new(init) }
     }
-    // `bun.TrivialDeinit(@This())` → see `deinit()` below.
 
     pub fn pull(&mut self, buf: &mut [u8]) -> streams::Result {
         self.context.on_pull(buf, JSValue::ZERO)
@@ -884,8 +861,7 @@ impl<C: SourceContext> NewSource<C> {
             return;
         }
         if let Some(close) = self.close_handler.take() {
-            // Zig: `if (close == &JSReadableStreamSource.onClose)` — identity check
-            // against the *exact* fn pointer stored by `set_on_close_from_js`, so the
+            // Identity check against the *exact* fn pointer stored by `set_on_close_from_js`, so the
             // JS path receives `self` (not `close_ctx`, which is unset on that path).
             if close as usize == Self::on_js_close as fn(Option<*mut c_void>) as usize {
                 Self::on_js_close(Some(std::ptr::from_mut(self).cast::<c_void>()));
@@ -913,7 +889,7 @@ impl<C: SourceContext> NewSource<C> {
     }
 
     /// Release one reference. If the count hits zero, runs context teardown and
-    /// **frees the allocation** (`bun.destroy(this)`).
+    /// **frees the allocation**.
     ///
     /// Takes a raw pointer (not `&mut self`) because the zero-refcount path
     /// deallocates `*this`; holding a live `&mut Self` across that drop would be
@@ -967,7 +943,6 @@ impl<C: SourceContext> NewSource<C> {
         ReadableStream::from_native(global_this, out_value)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)]
     pub fn set_raw_mode_from_js(
         this: &mut Self,
         global: &JSGlobalObject,
@@ -978,12 +953,10 @@ impl<C: SourceContext> NewSource<C> {
         match this.context.set_raw_mode(flag == JSValue::TRUE) {
             Some(Ok(())) => Ok(JSValue::UNDEFINED),
             Some(Err(e)) => Ok(e.to_js(global)),
-            // Zig: @compileError("setRawMode is not implemented on " ++ @typeName(Context))
             None => unreachable!("setRawMode is not implemented on {}", C::NAME),
         }
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)]
     pub fn set_flowing_from_js(
         this: &mut Self,
         _global: &JSGlobalObject,
@@ -999,15 +972,14 @@ impl<C: SourceContext> NewSource<C> {
         self.context.memory_cost_fn() + core::mem::size_of::<Self>()
     }
 
-    // `bun.TrivialDeinit(@This())` is folded into [`Self::decrement_count`]'s
+    // Teardown is folded into [`Self::decrement_count`]'s
     // zero-refcount path. A `&mut self` deinit here would free the storage
     // backing the live `self` borrow (dangling UAF), so the drop is performed
     // there via raw `*mut Self` instead.
 }
 
 // ─── codegen-facing inherent methods ─────────────────────────────────────────
-// Zig: `pub const drainFromJS = JSReadableStreamSource.drain;` etc. — the
-// `.classes.ts` → `generated_classes.rs` thunks call these by exact name on
+// The `.classes.ts` → `generated_classes.rs` thunks call these by exact name on
 // `NewSource<C>` (aliased as `{Blob,Bytes,File}InternalReadableStreamSource`).
 impl<C: SourceContext> NewSource<C> {
     pub fn pull_from_js(
@@ -1053,17 +1025,12 @@ impl<C: SourceContext> NewSource<C> {
         flags: JSValue,
         mut result: streams::Result,
     ) -> JsResult<JSValue> {
-        // PORT NOTE: Zig matches on the union and falls through to `result.toJS`
-        // for non-handled tags; here `result` is consumed by `to_js(&mut self)`.
         match &result {
             streams::Result::Err(err) => match err {
                 streams::StreamError::Error(e) => {
                     Err(global_this.throw_value(e.to_js(global_this)))
                 }
-                // Zig's else arm reads `err.JSValue` directly — implicitly assumes only
-                // `.Error`/`.JSValue` reach `processResult` (would safety-panic on
-                // `.WeakJSValue`/`.AbortReason`). Preserve the intent (always throw on
-                // `.err`) defensively via `to_js_weak`, which handles all four variants
+                // Always throw on `.err`: `to_js_weak` handles all four variants
                 // and reports whether the value was strong-protected (needs `unprotect()`).
                 _ => {
                     let (js_err, was_strong) = err.to_js_weak(global_this);
@@ -1228,7 +1195,7 @@ impl<C: SourceContext> NewSource<C> {
         Ok(JSValue::UNDEFINED)
     }
 
-    // PORT NOTE: text/arrayBuffer/blob/bytes/json all share the same body modulo
+    // text/arrayBuffer/blob/bytes/json all share the same body modulo
     // `BufferActionTag`. Collapsed into one helper to avoid 5× drift.
     fn to_buffered_value_from_js(
         &mut self,
@@ -1287,5 +1254,3 @@ impl<C: SourceContext> NewSource<C> {
         self.to_buffered_value_from_js(global_this, call_frame, streams::BufferActionTag::Json)
     }
 }
-
-// ported from: src/runtime/webcore/ReadableStream.zig
diff --git a/src/runtime/webcore/Request.rs b/src/runtime/webcore/Request.rs
index 21454047a29..47def811a4c 100644
--- a/src/runtime/webcore/Request.rs
+++ b/src/runtime/webcore/Request.rs
@@ -43,7 +43,7 @@ impl bun_ptr::weak_ptr::HasWeakPtrData for Request {
 }
 pub(crate) type WeakRef = bun_ptr::WeakPtr<Request>;
 
-// PORT NOTE: hand-rolled `JsClass` impl (proc-macro `#[bun_jsc::JsClass]`
+// Hand-rolled `JsClass` impl (proc-macro `#[bun_jsc::JsClass]`
 // not yet wired for Request). Routes through the codegen'd
 // `crate::generated_classes::js_Request` wrappers — no local extern decls.
 const _: () = {
@@ -57,11 +57,10 @@ const _: () = {
             js::from_js_direct(value).map(|p| p.as_ptr())
         }
         fn to_js(self, global: &bun_jsc::JSGlobalObject) -> bun_jsc::JSValue {
-            // Route through the inherent `Request::to_js` so the Zig override
-            // semantics (Request.zig:229-236) are preserved for generic
-            // `<T: JsClass>::to_js` callers too: `calculate_estimated_byte_size`,
-            // `js_ref = .init_weak(...)`, and `check_body_stream_ref` must all
-            // run, otherwise the wrapper reports size 0 and any Locked-body
+            // Route through the inherent `Request::to_js` so generic
+            // `<T: JsClass>::to_js` callers also run `calculate_estimated_byte_size`,
+            // `js_ref = .init_weak(...)`, and `check_body_stream_ref` —
+            // otherwise the wrapper reports size 0 and any Locked-body
             // ReadableStream is never migrated into the GC slot.
             let ptr = bun_core::heap::into_raw(Box::new(self));
             // SAFETY: `ptr` is a freshly-leaked heap allocation; the inherent
@@ -87,11 +86,10 @@ pub struct Request {
     pub url: bun_core::OwnedStringCell,
 
     headers: JsCell<Option<HeadersRef>>,
-    // PORT NOTE: Zig `?*AbortSignal` with manual `ref()`/`unref()`. AbortSignal
-    // is an opaque C++ handle with intrusive WebCore refcounting — `Arc` of an
-    // opaque ZST is meaningless (its payload address is not the C++ object).
-    // `AbortSignalRef` wraps `NonNull<AbortSignal>` and routes Clone/Drop to
-    // the C++ ref/unref.
+    // AbortSignal is an opaque C++ handle with intrusive WebCore refcounting —
+    // `Arc` of an opaque ZST is meaningless (its payload address is not the
+    // C++ object). `AbortSignalRef` wraps `NonNull<AbortSignal>` and routes
+    // Clone/Drop to the C++ ref/unref.
     pub signal: JsCell<Option<AbortSignalRef>>,
     /// Owning `+1` handle into the per-VM `Body::Value` hive pool. The
     /// `Request` and (when served by `Bun.serve`) the `RequestContext` each
@@ -109,9 +107,7 @@ pub struct Request {
     pub internal_event_callback: JsCell<InternalJSEventCallback>,
 }
 
-// PORT NOTE: Zig was `packed struct(u8)` (u2+u3+u2+bool = 8 bits). Fields are
-// enums + 1 bool, so the canonical port would be `#[repr(transparent)]` u8 +
-// shift accessors. Kept as a `#[repr(C)]` 4-byte struct to preserve direct
+// A `#[repr(C)]` 4-byte struct for direct
 // field access — `Request` is only ever passed to C++ by **pointer** with size
 // reported via the codegen'd `Request__ZigStructSize`, so the absolute size is
 // not ABI-locked. `#[repr(C)]` + `assert_ffi_layout!` make the layout
@@ -142,7 +138,7 @@ impl Default for Flags {
 pub use js_gen::from_js;
 pub use js_gen::from_js_direct;
 
-// `pub const new = bun.TrivialNew(@This());` → Box::new (global mimalloc).
+// Heap-allocates via Box::new (global mimalloc).
 impl Request {
     #[inline]
     pub fn new(v: Request) -> Box<Request> {
@@ -151,8 +147,7 @@ impl Request {
 }
 
 // Wire the codegen'd cached `body`/`stream` JS slot accessors + weak `js_ref`
-// so the [`BodyMixin`] twin defaults can run generically (Zig:
-// `T.js.bodyGetCached` / `T.js.gc.stream.*` / `this.#js_ref.tryGet()`).
+// so the [`BodyMixin`] twin defaults can run generically.
 impl crate::webcore::body::BodyOwnerJs for Request {
     #[inline]
     fn js_ref(&self) -> Option<JSValue> {
@@ -183,7 +178,7 @@ impl BodyMixin for Request {
     }
     #[inline]
     fn get_fetch_headers(&self) -> Option<core::ptr::NonNull<FetchHeaders>> {
-        // Zig: `?*FetchHeaders` — opaque C++ handle. Return the raw `*mut`
+        // Opaque C++ handle. Return the raw `*mut`
         // directly (via `HeadersRef::as_ptr`) so the provenance is mutable;
         // going through `as_deref()` would derive it from a `&FetchHeaders`
         // and make the later `as_mut()` UB under Stacked Borrows.
@@ -202,7 +197,6 @@ impl BodyMixin for Request {
 
 // ─── un-gated header accessors & simple getters ─────────────────────────────
 impl Request {
-    /// Zig: `pub fn getBodyValue(this: *Request) *Body.Value`.
     /// Inherent shim; `impl BodyMixin for Request` supplies the real trait method.
     #[inline]
     #[allow(clippy::mut_from_ref)]
@@ -210,14 +204,12 @@ impl Request {
         self.body_value_mut()
     }
 
-    /// Zig: `this.#body.value` (immutable view).
+    /// Immutable view of the body value.
     #[inline]
     pub(crate) fn body_value(&self) -> &BodyValue {
         &self.body
     }
 
-    /// Zig: `&this.#body.value`.
-    ///
     /// R-2: `&self` → `&mut` through the slot's raw pointer. The slot is shared
     /// with `RequestContext.request_body` but never `&mut`-borrowed concurrently
     /// (single-threaded event-loop sequencing). Keep the borrow short.
@@ -269,10 +261,8 @@ impl Request {
         } else {
             // we don't have a request context, so we need to create an empty headers object
             self.headers.set(Some(HeadersRef::create_empty()));
-            // PORT NOTE: reshaped for borrowck — Zig read `blob.content_type`
-            // through `self.body_value()` while holding `self.headers`. Snapshot the
-            // pointer first; `Blob.content_type` is a raw `*const [u8]` that
-            // stays valid across the field borrow.
+            // Snapshot the pointer first; `Blob.content_type` is a raw
+            // `*const [u8]` that stays valid across the field borrow.
             let content_type: Option<*const [u8]> = match self.body_value() {
                 BodyValue::Blob(blob) => Some(blob.content_type.get()),
                 BodyValue::Locked(locked) => match locked.readable.get(global_this) {
@@ -416,8 +406,8 @@ impl Request {
             return;
         }
 
-        // Zig spec: `seconds.to(c_uint)` → `JSValue.toU32` (clamps via JS ToUint32 rules,
-        // not signed wrap-then-reinterpret like `to_int32() as c_uint` would do).
+        // `JSValue.toU32` clamps via JS ToUint32 rules,
+        // not signed wrap-then-reinterpret like `to_int32() as c_uint` would do.
         self.set_timeout(seconds.to_u32() as c_uint);
     }
 
@@ -427,8 +417,6 @@ impl Request {
     }
 }
 
-// `comptime { _ = Request__clone; ... }` force-reference block → drop. Rust links what's pub.
-
 // NOTE: `EventType` and `impl InternalJSEventCallback` are defined once below
 // (near the struct decl); the duplicate block that used to live here was
 // removed to resolve E0034 ambiguity.
@@ -462,7 +450,6 @@ impl Request {
         let Some(content_type_slice) = self.get_content_type()? else {
             return Ok(None);
         };
-        // `defer content_type_slice.deinit()` → Drop on ZigString::Slice
         let Some(encoding) = crate::webcore::form_data::Encoding::get(content_type_slice.slice())
         else {
             return Ok(None);
@@ -483,10 +470,9 @@ impl Request {
         let Some(info) = self.request_context.get_remote_socket_info() else {
             return Ok(None);
         };
-        // Zig: `jsc.JSSocketAddress.create` → SocketAddress DTO POJO. Zig's
-        // `JSSocketAddress.create` is infallible, but the Rust port routes
-        // through `create_utf8_for_js` which can throw — propagate, don't
-        // swallow, so we never return `None` while a JS exception is pending.
+        // `create_dto` routes through `create_utf8_for_js` which can throw —
+        // propagate, don't swallow, so we never return `None` while a JS
+        // exception is pending.
         crate::socket::socket_address::SocketAddress::create_dto(
             global_object,
             &info.ip,
@@ -536,7 +522,6 @@ impl Request {
     }
 }
 
-// TODO(port): move to runtime_sys
 // Request is opaque on the C++ side; see note on the JsClass extern block above.
 // C++ side defines `extern "C" SYSV_ABI` (JSBunRequest.cpp).
 bun_jsc::jsc_abi_extern! {
@@ -561,15 +546,12 @@ impl Request {
                 std::ptr::from_ref::<Request>(self).cast_mut(),
             )
         })
-        // TODO(port): `@src()` argument dropped — fromJSHostCall location tracking TBD
     }
 }
 
-// TODO(port): move to runtime_sys
 unsafe extern "C" {
     #[link_name = "Bun__getParamsIfBunRequest"]
     safe fn Bun__getParamsIfBunRequest(this_value: JSValue) -> JSValue;
-    // Zig: `extern "JS"` — JS-side builtin.
 }
 
 impl Request {
@@ -583,10 +565,9 @@ impl Request {
         F: bun_jsc::ConsoleFormatter,
         W: core::fmt::Write,
     {
-        // PORT NOTE: return type narrowed to `core::fmt::Result` (matches
+        // Return type narrowed to `core::fmt::Result` (matches
         // Response::write_format / Blob::write_format). Funnel JsError /
-        // AllocError through `fmt::Error`; Zig's `anyerror!void` carried no
-        // payload either.
+        // AllocError through `fmt::Error`.
         let js_err = |_: JsError| core::fmt::Error;
 
         let params_object = Bun__getParamsIfBunRequest(this_value);
@@ -603,9 +584,8 @@ impl Request {
             bun_fmt::size(self.body_value_mut().size() as usize, Default::default())
         )?;
         {
-            // Zig: `formatter.indent += 1; defer formatter.indent -|= 1;` — RAII guard
-            // restores indent on every exit incl. `?` error paths. Shadows `formatter`
-            // for the block; auto-derefs to `&mut F`.
+            // RAII guard restores indent on every exit incl. `?` error paths.
+            // Shadows `formatter` for the block; auto-derefs to `&mut F`.
             let mut formatter = bun_jsc::IndentScope::new(&mut *formatter);
 
             formatter.write_indent(writer)?;
@@ -613,8 +593,7 @@ impl Request {
                 Output::pretty_fmt::<ENABLE_ANSI_COLORS>("<r>method<d>:<r> \"").as_ref(),
             )?;
 
-            // Zig: `bun.asByteSlice(@tagName(this.method))` — wire-form token
-            // (e.g. "M-SEARCH"), not the Rust Debug variant identifier.
+            // Wire-form token (e.g. "M-SEARCH"), not the Rust Debug variant identifier.
             writer.write_str(self.method.as_str())?;
             writer.write_str("\"")?;
             formatter
@@ -630,7 +609,6 @@ impl Request {
                 writer,
                 "{}",
                 format_args!(
-                    // TODO(port): comptime Output.prettyFmt with embedded {f} — needs const_format
                     "{}{}{}",
                     Output::pretty_fmt::<ENABLE_ANSI_COLORS>("\"<b>"),
                     self.url.get(),
@@ -721,10 +699,8 @@ impl Request {
 
     pub fn mime_type(&self) -> &[u8] {
         if let Some(headers) = self.headers_mut().as_mut() {
-            // TODO(port): Zig has `try` here but fn returns plain `string` — preserved as
-            // non-fallible; FetchHeaders.fastGet may need to be infallible in Rust.
             if let Some(content_type) = headers.fast_get(HTTPHeaderName::ContentType) {
-                // PORT NOTE: `fast_get` returns a `ZigString` by value whose
+                // `fast_get` returns a `ZigString` by value whose
                 // bytes borrow the FetchHeaders' WTF::String storage (NOT the
                 // local). `ZigString::slice` ties the borrow to the local
                 // `content_type`; detach and re-anchor on `self` so the
@@ -735,7 +711,7 @@ impl Request {
             }
         }
 
-        // PORT NOTE: upstream `bun_http_types::MimeType::{OTHER,TEXT}` are `const` items
+        // Upstream `bun_http_types::MimeType::{OTHER,TEXT}` are `const` items
         // (not `static`), so `&CONST.value` borrows a temporary `Cow` and cannot be
         // returned. Mirror their `init_comptime` byte literals here as `'static` slices.
         const MIME_OTHER_VALUE: &[u8] = b"application/octet-stream";
@@ -786,7 +762,7 @@ impl Request {
         let js_signal = AbortSignal::create(global_this);
         js_signal.ensure_still_alive();
         if let Some(signal) = AbortSignal::ref_from_js(js_signal) {
-            // `ref_from_js` already bumped the C++ refcount (Zig: `signal.ref()`).
+            // `ref_from_js` already bumped the C++ refcount.
             self.signal.set(Some(signal));
         }
         js_signal
@@ -806,7 +782,7 @@ impl Request {
 
         self.url.set(BunString::empty());
 
-        // Zig: `signal.unref()` — AbortSignalRef::Drop unrefs the C++ handle.
+        // AbortSignalRef::Drop unrefs the C++ handle.
         self.signal.set(None);
         // internal_event_callback.deinit() → Drop on Strong inside; explicit take to match timing
         self.internal_event_callback
@@ -826,8 +802,7 @@ impl Request {
             // Hot path: no outstanding weak refs. Reclaim and drop the whole
             // allocation in one shot — `Box::from_raw`'s drop runs
             // `drop_in_place` over every field (headers / url / signal /
-            // js_ref / internal_event_callback) once, matching Zig's
-            // plain-store `finalizeWithoutDeinit` without the 4× `Cell::set`
+            // js_ref / internal_event_callback) once, without the 4× `Cell::set`
             // read-write-drop round-trips the old `finalize_without_deinit()`
             // call performed here before re-dropping the (now-empty) fields.
             // SAFETY: `this` is the live Box-allocated payload.
@@ -1063,9 +1038,7 @@ impl Request {
             reported_estimated_size: Cell::new(0),
             internal_event_callback: JsCell::new(InternalJSEventCallback::default()),
         };
-        // Zig `defer { if (!success) { req.finalizeWithoutDeinit(); _ = req.#body.unref(); }
-        //               if (req.#body != body) { _ = body.unref(); } }`
-        // PORT NOTE: reshaped for borrowck — scopeguard cannot capture `&mut req` while the
+        // A scopeguard cannot capture `&mut req` while the
         // fn body also uses it. Cleanup is invoked at each early-return site via `bail!`.
         let cleanup = |req: &mut Request,
                        body_seed_ptr: *mut crate::webcore::body::HiveRef,
@@ -1231,8 +1204,6 @@ impl Request {
 
                     if !fields.contains(Fields::Headers) {
                         if let Some(headers) = response.get_init_headers_mut() {
-                            // Zig: `req.#headers = try headers.cloneThis(globalThis);
-                            //       fields.insert(.headers);`
                             // The flag is set unconditionally once `getInitHeaders()` yielded a
                             // value, even if `cloneThis` returns null — so a later arg can't
                             // repopulate headers from a different source.
@@ -1249,7 +1220,7 @@ impl Request {
 
                     if !fields.contains(Fields::Url) {
                         // `Response::url()` returns a bitwise `Copy` of the underlying
-                        // `bun.String` (no ref bump). Zig spec is `response.url.dupeRef()`,
+                        // `bun.String` (no ref bump),
                         // so take a +1 ref before storing — `req.url` is later released by
                         // `finalize_without_deinit` / the bail!-path `deref()`.
                         let url = response.url();
@@ -1315,7 +1286,7 @@ impl Request {
                         // first value
                     }
                     Ok(None) => {
-                        // Preserve Zig short-circuit ordering: only probe
+                        // Short-circuit ordering: only probe
                         // `implementsToString` (which performs JS property
                         // lookup with observable side effects) when the first
                         // two guards already hold.
@@ -1353,7 +1324,7 @@ impl Request {
                         if let Some(signal) = AbortSignal::ref_from_js(signal_) {
                             // Keep it alive
                             signal_.ensure_still_alive();
-                            // `ref_from_js` already ref'd (Zig: `signal.ref()`).
+                            // `ref_from_js` already ref'd.
                             req.signal.set(Some(signal));
                         } else {
                             if !global_this.has_exception() {
@@ -1505,7 +1476,7 @@ impl Request {
                         .unwrap()
                         .fast_has(HTTPHeaderName::ContentType)
                 {
-                    // PORT NOTE: reshaped for borrowck — split borrow of req.body and req.headers
+                    // Reshaped for borrowck — split borrow of req.body and req.headers
                     let ct_ptr: *const [u8] = ct;
                     match req.headers_mut().as_mut().unwrap().put(
                         HTTPHeaderName::ContentType,
@@ -1564,17 +1535,16 @@ impl Request {
         // allocator param dropped (global mimalloc)
         let _ = self.ensure_url();
         let body_ = self.clone_body_value_via_cached_stream(global_this)?;
-        // errdefer body_.deinit() → deleted; BodyValue: Drop frees on `?` error path
+        // BodyValue's Drop frees `body_` on the `?` error path
         let body = body::hive_alloc(body_);
-        // Last fallible call. Zig hoists `url` above this with an
-        // `errdefer if (!preserve_url) url.deref()`; we instead sink the url
-        // computation below it so no guard is needed at all — `BunString` is
+        // Last fallible call. The url computation is sunk below it
+        // so no guard is needed at all — `BunString` is
         // `Copy` with no `Drop`, so an early return here leaves `req.url`
         // untouched and still owned by the caller's `finalize_without_deinit`.
         // `body` (a `BodyHiveHandle`) drops on the `?` error path below,
-        // releasing its +1 — Zig's `errdefer body.unref()`.
+        // releasing its +1.
         let headers = self.clone_headers(global_this)?;
-        // errdefer if (headers) |_h| _h.deref() → Arc drop on error path is automatic
+        // `headers` is released automatically on the error path via its drop glue
         let url = if preserve_url {
             // Bitwise copy — the `ptr::write` below overwrites the old slot;
             // `BunString` has no `Drop`, so the stale `req.url` bits are discarded
@@ -1584,10 +1554,10 @@ impl Request {
             self.url.get().dupe_ref()
         };
 
-        // Zig `req.* = Request{...}` is a raw bit-overwrite — no destructors run
-        // on the old `*req`. Match that with `ptr::write` so future Drop impls
-        // on `JsRef` / `strong::Optional` don't fire on the caller's sentinel.
-        // The old `req.body` hive ref is NOT unref'd here (Zig doesn't either):
+        // `ptr::write` is a raw bit-overwrite — no destructors run on the old
+        // `*req`, so Drop impls on `JsRef` / `strong::Optional` don't fire on
+        // the caller's sentinel.
+        // The old `req.body` hive ref is intentionally NOT unref'd here:
         // `clone()` seeds it with a dangling sentinel, and `construct_into`
         // releases its seed via the ptr-equality arm of its `cleanup`.
         // `url` was bitwise-copied above (preserve_url) or is the empty
@@ -1614,7 +1584,7 @@ impl Request {
         }
 
         if let Some(signal) = self.signal.get() {
-            // `AbortSignalRef::clone` → C++ `ref()` (matches Zig `signal.ref()`).
+            // `AbortSignalRef::clone` → C++ `ref()`.
             req.signal.set(Some(signal.clone()));
         }
         Ok(())
@@ -1622,8 +1592,7 @@ impl Request {
 
     pub fn clone(&self, global_this: &JSGlobalObject) -> JsResult<Box<Request>> {
         // allocator param dropped (global mimalloc)
-        // Zig does `Request.new(undefined)` then clone_into bit-overwrites the
-        // whole struct. clone_into `ptr::write`s the new fields over the seed
+        // `clone_into` `ptr::write`s the new fields over the seed
         // without reading or dropping it.
         let mut req = Box::new(Request {
             url: OwnedStringCell::new(BunString::empty()),
@@ -1644,7 +1613,7 @@ impl Request {
             reported_estimated_size: Cell::new(0),
             internal_event_callback: JsCell::new(InternalJSEventCallback::default()),
         });
-        // errdefer bun.destroy(req) → Box<Request> drops on error path automatically
+        // Box<Request> drops on the error path automatically
         self.clone_into(&mut req, global_this, false)?;
         Ok(req)
     }
@@ -1659,8 +1628,7 @@ pub struct InternalJSEventCallback {
     pub function: jsc::strong::Optional, // jsc.Strong.Optional → bun_jsc::Strong
 }
 
-/// Re-export of `NodeHTTPResponse.AbortEvent` (Zig: `pub const EventType =
-/// jsc.API.NodeHTTPResponse.AbortEvent`).
+/// Re-export of `NodeHTTPResponse.AbortEvent`.
 pub type EventType = crate::server::node_http_response::AbortEvent;
 
 impl InternalJSEventCallback {
@@ -1726,12 +1694,10 @@ impl Request {
 
     /// Mutable access to the already-materialized headers (does NOT lazily
     /// create from the underlying uWS request — see `get_fetch_headers_unless_empty`
-    /// for that). Mirrors Zig `Request.getFetchHeaders` returning `?*FetchHeaders`.
+    /// for that).
     #[inline]
     #[allow(clippy::mut_from_ref)]
     pub fn get_fetch_headers_mut(&self) -> Option<&mut FetchHeaders> {
         self.headers_mut().as_deref_mut()
     }
 }
-
-// ported from: src/runtime/webcore/Request.zig
diff --git a/src/runtime/webcore/Response.rs b/src/runtime/webcore/Response.rs
index 9391d20acba..7d514ce504b 100644
--- a/src/runtime/webcore/Response.rs
+++ b/src/runtime/webcore/Response.rs
@@ -19,14 +19,13 @@ use super::blob::Internal as InternalBlob;
 use super::body::{Body, BodyMixin, Value as BodyValue};
 use super::{FetchHeaders, ReadableStream, Request};
 
-// PORT NOTE: codegen (`generated_classes.rs`) re-exports `Blob` from
-// `crate::webcore::response` because the Zig `.classes.ts` source path is
+// Codegen (`generated_classes.rs`) re-exports `Blob` from
+// `crate::webcore::response` because the `.classes.ts` source path is
 // `bun.jsc.WebCore.response.Blob`. Keep this `pub use` so that resolves.
 pub use super::blob::Blob;
 use bun_ptr::weak_ptr::WeakPtrData;
 
 // C++ helper functions for AsyncLocalStorage integration
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     pub safe fn Response__getAsyncLocalStorageStore(
         global: &JSGlobalObject,
@@ -42,11 +41,10 @@ unsafe extern "C" {
 /// RAII handle to a C++-owned `WebCore::FetchHeaders`.
 ///
 /// Holds exactly one ref on the C++ intrusive refcount; `Drop` releases it via
-/// `WebCore__FetchHeaders__deref`. This is the Rust shape for Zig's
-/// `?*FetchHeaders` field + manual `headers.deref()` in `deinit()` — NOT a
-/// `std::rc::Rc` (the payload lives on the C++ heap and is opaque here).
+/// `WebCore__FetchHeaders__deref`. NOT a `std::rc::Rc` (the payload lives on
+/// the C++ heap and is opaque here).
 ///
-/// Intentionally not `Clone`: the only "share" operation the Zig surface
+/// Intentionally not `Clone`: the only "share" operation the surface
 /// exposes is `clone_this()`, which deep-copies a fresh `FetchHeaders` on the
 /// C++ side. Transferring ownership is by-move.
 #[repr(transparent)]
@@ -136,9 +134,7 @@ impl Drop for HeadersRef {
 // `from_js` / `from_js_direct` / `to_js` / `get_constructor` /
 // `dangerously_set_ptr` plus the cached-accessor pairs (`body_*_cached`,
 // `headers_*_cached`, `url_*_cached`, `statusText_*_cached`,
-// `stream_*_cached`). Zig's `js.gc.stream.{get,set,clear}` flatten to
-// `stream_{get,set}_cached`; `clear` is `set(.., .zero)` (see
-// ZigGeneratedClasses.zig `gc.clear`).
+// `stream_*_cached`).
 //
 // IMPORTANT: do NOT re-introduce `crate::webcore::jsc::codegen::JSResponse`
 // here — that module is a placeholder stub whose `to_js_unchecked` returns
@@ -148,9 +144,9 @@ pub mod js {
     pub use bun_jsc::generated::JSResponse::*;
 }
 // NOTE: toJS is overridden below.
-// Zig: `pub const fromJS = js.fromJS;` — typed re-exports. The `js::` module
-// erases the payload to `*mut ()` (Response is defined above the `bun_jsc`
-// crate, so `js_class_module!` can't name it); cast at this boundary.
+// Typed re-exports. The `js::` module erases the payload to `*mut ()`
+// (Response is defined above the `bun_jsc` crate, so `js_class_module!`
+// can't name it); cast at this boundary.
 #[inline]
 pub fn from_js(value: JSValue) -> Option<*mut Response> {
     js::from_js(value).map(<*mut ()>::cast::<Response>)
@@ -182,7 +178,7 @@ bun_jsc::impl_js_class_via_generated!(Response => bun_jsc::generated::JSResponse
 pub struct Response {
     body: JsCell<Body>,
     init: JsCell<Init>,
-    // PORT NOTE: `OwnedString` is `#[repr(transparent)]` over `BunString`, so
+    // `OwnedString` is `#[repr(transparent)]` over `BunString`, so
     // the C ABI layout is unchanged. We use it (not raw `BunString`) so the
     // field's drop glue actually releases the WTF refcount — `BunString` is
     // `Copy` and has no `Drop`.
@@ -226,8 +222,7 @@ impl bun_ptr::weak_ptr::HasWeakPtrData for Response {
 pub(crate) type WeakRef = bun_ptr::WeakPtr<Response>;
 
 // Wire the codegen'd cached `body`/`stream` JS slot accessors + weak `js_ref`
-// so the [`BodyMixin`] twin defaults can run generically (Zig:
-// `T.js.bodyGetCached` / `T.js.gc.stream.*` / `this.#js_ref.tryGet()`).
+// so the [`BodyMixin`] twin defaults can run generically.
 impl crate::webcore::body::BodyOwnerJs for Response {
     #[inline]
     fn js_ref(&self) -> Option<JSValue> {
@@ -251,10 +246,10 @@ impl crate::webcore::body::BodyOwnerJs for Response {
     }
 }
 
-// BodyMixin(@This()) is a comptime type fn that generates getText/
+// BodyMixin is a trait with default methods providing getText/
 // getBody/getBytes/getBodyUsed/getJSON/getArrayBuffer/getBlob/getBlobWithoutCallFrame/
 // getFormData over any type exposing getBodyValue()/getFormDataEncoding()/etc.
-// In Rust this is a trait with default methods; Response implements it.
+// Response implements it.
 
 impl BodyMixin for Response {
     #[inline]
@@ -263,7 +258,7 @@ impl BodyMixin for Response {
     }
     #[inline]
     fn get_fetch_headers(&self) -> Option<core::ptr::NonNull<FetchHeaders>> {
-        // Zig: `?*FetchHeaders` — opaque C++ handle. Return the raw `*mut`
+        // Opaque C++ handle. Return the raw `*mut`
         // directly (via `HeadersRef::as_ptr`) so the provenance is mutable;
         // going through `as_deref()` would derive it from a `&FetchHeaders`
         // and make the later `as_mut()` UB under Stacked Borrows.
@@ -298,8 +293,7 @@ impl Response {
             init.method = method;
             init.status_code = status_code;
             // Assigning over an `OwnedString` runs its `Drop`, which `deref()`s the
-            // previous WTF impl — matching Zig's explicit `status_text.deref()`
-            // before reassignment (Response.zig:54).
+            // previous WTF impl.
             init.status_text = OwnedString::new(status_text);
         });
     }
@@ -315,9 +309,8 @@ impl Response {
         self.init.get().status_code
     }
 
-    /// Borrowed (+0) — bitwise copy of the inner `BunString`, matching Zig's
-    /// `getInitStatusText` (Response.zig:67). Caller must NOT `deref()` the
-    /// result; call `.clone()` on it if a +1 is needed.
+    /// Borrowed (+0) — bitwise copy of the inner `BunString`. Caller must NOT
+    /// `deref()` the result; call `.clone()` on it if a +1 is needed.
     #[inline]
     pub fn get_init_status_text(&self) -> BunString {
         self.init.get().status_text.get()
@@ -327,8 +320,7 @@ impl Response {
     #[inline]
     pub fn set_url(&self, url: BunString) {
         // Assigning over an `OwnedString` runs its `Drop`, which `deref()`s the
-        // previous WTF impl — matching Zig's explicit `this.#url.deref()`
-        // before reassignment (Response.zig:70).
+        // previous WTF impl.
         self.url.set(OwnedString::new(url));
     }
 
@@ -337,13 +329,12 @@ impl Response {
         self.url.get().to_utf8()
     }
 
-    /// Internal accessor: borrowed (+0) bitwise copy of the URL string,
-    /// matching Zig's `getUrl` (Response.zig:77). Caller must NOT `deref()`
-    /// the result; call `.clone()` on it if a +1 is needed.
+    /// Internal accessor: borrowed (+0) bitwise copy of the URL string.
+    /// Caller must NOT `deref()` the result; call `.clone()` on it if a +1 is
+    /// needed.
     ///
-    /// PORT NOTE: Zig had both `getUrl()` (returns the string) and `getURL()`
-    /// (the JS getter). They collide under snake_case, so the JS getter keeps
-    /// `get_url` (codegen calls that name) and this becomes `url()`.
+    /// The JS getter keeps `get_url` (codegen calls that name); this internal
+    /// accessor is `url()`.
     #[inline]
     pub fn url(&self) -> BunString {
         self.url.get().get()
@@ -580,7 +571,7 @@ impl Response {
     }
 
     pub fn header(&self, name: HTTPHeaderName) -> Option<ZigString> {
-        // PORT NOTE: reshaped for borrowck — `FetchHeaders::fast_get` takes
+        // reshaped for borrowck — `FetchHeaders::fast_get` takes
         // `&mut self` (FFI writes through an out-param), so we return the
         // owned `ZigString` instead of a borrowed slice. Callers do
         // `.slice()` themselves. R-2 escape hatch via `init_mut()`.
@@ -592,8 +583,7 @@ impl Response {
         status_code >= 200 && status_code <= 299
     }
 
-    // PORT NOTE: Zig `getURL` (JS getter). The Zig `getUrl` accessor became `url()`
-    // above; codegen calls this exact name.
+    // JS getter; codegen calls this exact name.
     pub fn get_url(this: &Self, global_this: &JSGlobalObject) -> JsResult<JSValue> {
         // https://developer.mozilla.org/en-US/docs/Web/API/Response/url
         this.url.get().to_js(global_this)
@@ -685,10 +675,10 @@ impl Response {
         F: bun_jsc::ConsoleFormatter,
         W: core::fmt::Write,
     {
-        // PORT NOTE: return type narrowed to `core::fmt::Result`. The trait
+        // return type narrowed to `core::fmt::Result`. The trait
         // methods produce `fmt::Error`/`JsError`/`bun_core::Error`; none of
         // those convert into the others, so funnel everything through
-        // `fmt::Error` (Zig's `anyerror!void` carried no payload either).
+        // `fmt::Error`.
         let js_err = |_: JsError| core::fmt::Error;
 
         writeln!(
@@ -835,11 +825,11 @@ impl Response {
 
     pub fn clone_value(&self, global_this: &JSGlobalObject) -> JsResult<Response> {
         let body = Body::new(self.clone_body_value_via_cached_stream(global_this)?);
-        // errdefer body.deinit() — `Body` has NO `Drop`; arm a guard so the
-        // `?` below releases the cloned body payload (Response.zig:433).
+        // `Body` has NO `Drop`; arm a guard so the
+        // `?` below releases the cloned body payload.
         let body = scopeguard::guard(body, |b| b.reset());
         let init = self.init.get().clone(global_this)?;
-        // errdefer init.deinit() — Init's drop glue (HeadersRef + OwnedString)
+        // Init's drop glue (HeadersRef + OwnedString)
         // handles cleanup on `?` below
         Ok(Response {
             body: JsCell::new(scopeguard::ScopeGuard::into_inner(body)),
@@ -859,9 +849,6 @@ impl Response {
     fn destroy(this: *mut Response) {
         // SAFETY: called from unref() when ref_count hits 0; this is the unique owner
         unsafe {
-            // Mirrors Zig `destroy` (Response.zig:457-460): `init.deinit()` /
-            // `body.deinit()` / `url.deref()` / `js_ref.deinit()`.
-            //
             // We assign safe-empty values rather than `drop_in_place` so the
             // struct stays in a valid (all-empty) state if `on_finalize()`
             // returns false and the allocation outlives this call until the
@@ -886,8 +873,7 @@ impl Response {
                 // Do NOT use heap::take — that would re-run field drop glue
                 // on init/url/js_ref. They are now safe-empty so the second drop
                 // would be a no-op, but it is still wasted work and fragile under
-                // future field additions. Zig's `bun.destroy()` only frees the
-                // allocation; match that with a raw dealloc.
+                // future field additions; free the allocation with a raw dealloc.
                 let layout = std::alloc::Layout::new::<Response>();
                 std::alloc::dealloc(this.cast::<u8>(), layout);
             }
@@ -943,12 +929,11 @@ impl Response {
         let mut args =
             bun_jsc::ArgumentsSlice::init(global_this.bun_vm(), &args_list.ptr[0..args_list.len]);
 
-        // PORT NOTE: Zig tracked `did_succeed` and manually deinit'd body/init
-        // on failure. `Init`'s field drop glue (HeadersRef + OwnedString)
+        // `Init`'s field drop glue (HeadersRef + OwnedString)
         // releases its refs on `?`. `Body` has NO `Drop` and its
         // `WTFStringImpl` arm is a raw `*mut` (no drop glue), so wrap the
-        // stack value in a scopeguard that calls `body.reset()` (Zig's
-        // `body.deinit`) on early return; disarmed before `heap::alloc`.
+        // stack value in a scopeguard that calls `body.reset()`
+        // on early return; disarmed before `heap::alloc`.
         let response = scopeguard::guard(
             Response {
                 body: JsCell::new(Body::new(BodyValue::Empty)),
@@ -992,18 +977,17 @@ impl Response {
             }
 
             if !str.is_empty() {
-                // PORT NOTE: `bun_core::String.value` is private; use
+                // `bun_core::String.value` is private; use
                 // `leak_wtf_impl()` to take ownership of the +1 ref as a raw
                 // `*mut WTFStringImplStruct`. `String` is intentionally
-                // non-`Drop`, so consuming it here is the same as Zig's
-                // bitwise field read.
+                // non-`Drop`, so consuming it here is a plain bitwise read.
                 let wtf = str.leak_wtf_impl();
                 debug_assert!(!wtf.is_null());
                 // `json_stringify_fast` populated a WTF-backed string; `wtf` is a
                 // live +1 impl pointer until we deref/transfer it below.
                 let wtf_ref = super::body::wtf_impl(&wtf);
                 if let Some(bytes) = wtf_ref.to_utf8_if_needed() {
-                    // We took +1 via leak_wtf_impl; release it now (Zig: `defer str.deref()`).
+                    // We took +1 via leak_wtf_impl; release it now.
                     wtf_ref.deref();
                     response
                         .body
@@ -1014,7 +998,6 @@ impl Response {
                             was_string: true,
                         }));
                 } else {
-                    // Zig moves the WTFStringImpl pointer bitwise (no ref/deref).
                     // We already hold the +1 from `leak_wtf_impl`; transfer it
                     // into the body value.
                     response.body.get().value.set(BodyValue::WTFStringImpl(wtf));
@@ -1110,8 +1093,7 @@ impl Response {
                 url_string = url_string_value.get_zig_string(global_this)?;
             }
             url_string_slice = url_string.to_slice();
-            // PORT NOTE: Zig tracked `did_succeed` and manually deinit'd body/init on
-            // failure. In Rust, `Init`'s drop glue (HeadersRef + OwnedString)
+            // `Init`'s drop glue (HeadersRef + OwnedString)
             // handles cleanup on `?`.
 
             if let Some(arg_init) = args.next_eat() {
@@ -1122,7 +1104,7 @@ impl Response {
                         Self::validate_redirect_status_code(global_this, arg_init.to_int32())?;
                     response.init.with_mut(|i| i.status_code = status);
                 } else if let Some(init) = Init::init(global_this, arg_init)? {
-                    // errdefer response.init.deinit() — handled by Init's drop glue on `?` below
+                    // cleanup is handled by Init's drop glue on `?` below
                     response.init.set(init);
 
                     let status = response.init.get().status_code;
@@ -1141,8 +1123,7 @@ impl Response {
         };
 
         let headers = response.get_or_create_headers(global_this)?;
-        // PORT NOTE: reshaped for borrowck — Zig assigned response.init.headers = ...
-        // then re-borrowed; here get_or_create_headers already populated init.headers.
+        // `get_or_create_headers` already populated init.headers.
         headers.put(
             HTTPHeaderName::Location,
             url_string_slice.slice(),
@@ -1172,9 +1153,8 @@ impl Response {
         Ok(js_value)
     }
 
-    // TODO(port): codegen — constructor signature includes js_this (the pre-allocated
-    // JS wrapper). The `#[bun_jsc::host_fn]` macro needs a `constructor` variant that
-    // passes the wrapper through.
+    // Hand-written: the constructor signature includes js_this (the pre-allocated
+    // JS wrapper), which `#[bun_jsc::host_fn]` has no variant for.
     pub fn constructor(
         global_this: &JSGlobalObject,
         callframe: &CallFrame,
@@ -1256,7 +1236,7 @@ impl Response {
             }
             return Err(bun_jsc::JsError::Thrown);
         };
-        // errdefer init.deinit() — Init's field drop glue (HeadersRef + OwnedString)
+        // Init's field drop glue (HeadersRef + OwnedString)
         // handles cleanup on `?` below
 
         if global_this.has_exception() {
@@ -1267,24 +1247,20 @@ impl Response {
             if arguments[0].is_undefined_or_null() {
                 break 'brk Body::new(BodyValue::Null);
             }
-            // PORT NOTE: `Body::extract` is a free fn re-exported as `body::extract`.
+            // `Body::extract` is a free fn re-exported as `body::extract`.
             super::body::extract(global_this, arguments[0])?
         };
-        // errdefer body.deinit() — `Body` has NO `Drop`; arm a guard so the
-        // error returns below release the extracted body payload
-        // (Response.zig:758).
+        // `Body` has NO `Drop`; arm a guard so the
+        // error returns below release the extracted body payload.
         let body = scopeguard::guard(body, |b| b.reset());
 
         if global_this.has_exception() {
             return Err(bun_jsc::JsError::Thrown);
         }
 
-        // Perform the only remaining fallible op BEFORE heap-allocating: Zig
-        // keeps `errdefer _init.deinit()` / `errdefer body.deinit()` active
-        // across `bun.new` (Response.zig:744,758), so on `headers.put` failure
-        // body+init are freed (only the bare struct leaks). Doing it on stack
-        // locals lets `?` trigger the scopeguard and `init`'s drop glue and
-        // avoids leaking the heap allocation entirely.
+        // Perform the only remaining fallible op BEFORE heap-allocating:
+        // doing it on stack locals lets `?` trigger the scopeguard and
+        // `init`'s drop glue and avoids leaking the heap allocation entirely.
         if let BodyValue::Blob(blob) = body.value.get() {
             if let Some(headers) = init.headers.as_deref_mut() {
                 let content_type = blob.content_type_slice();
@@ -1315,8 +1291,7 @@ impl Response {
     }
 }
 
-// PORT NOTE: Zig had an explicit `Init.deinit()` (Response.zig:880-889) which
-// deref'd `headers` and `status_text`. In Rust, `headers: Option<HeadersRef>`
+// `headers: Option<HeadersRef>`
 // has `Drop` (releases the C++ ref) and `status_text: OwnedString` has `Drop`
 // (releases the WTF ref) — `BunString` itself is `Copy` and has NO `Drop`, so
 // the field MUST be `OwnedString` for auto-generated drop glue to perform the
@@ -1345,8 +1320,8 @@ impl Default for Init {
 impl Init {
     pub fn clone(&self, ctx: &JSGlobalObject) -> JsResult<Init> {
         let headers = match &self.headers {
-            // PORT NOTE: Zig `head.cloneThis(ctx)` returns `?*FetchHeaders` (deep
-            // copy on the C++ side, may be null on OOM/throw). Flatten the
+            // `clone_this` does a deep copy on the C++ side and may return
+            // null on OOM/throw. Flatten the
             // `Option<HeadersRef>` so a null clone leaves `headers` empty.
             Some(head) => head.clone_this(ctx)?,
             None => None,
@@ -1364,7 +1339,7 @@ impl Init {
             status_code: 200,
             ..Default::default()
         };
-        // errdefer result.deinit() — Init's drop glue (HeadersRef + OwnedString)
+        // Init's drop glue on `result` (HeadersRef + OwnedString)
         // handles cleanup on `?` below
 
         if !response_init.is_cell() {
@@ -1406,7 +1381,7 @@ impl Init {
         }
 
         if let Some(headers) = response_init.fast_get(global_this, BuiltinName::headers)? {
-            // PORT NOTE: `JSValue::as_::<FetchHeaders>()` requires `JsClass`;
+            // `JSValue::as_::<FetchHeaders>()` requires `JsClass`;
             // FetchHeaders is a hand-bound opaque, so use its dedicated
             // `cast()` (wraps `WebCore__FetchHeaders__cast_`).
             if let Some(orig) = FetchHeaders::cast(headers) {
@@ -1467,7 +1442,6 @@ impl Init {
     }
 }
 
-// PORT NOTE: Zig @"404"/@"200" — Rust idents cannot start with a digit
 pub fn status_404(global_this: &JSGlobalObject) -> *mut Response {
     empty_with_status(global_this, 404)
 }
@@ -1489,6 +1463,4 @@ fn empty_with_status(_global: &JSGlobalObject, status: u16) -> *mut Response {
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/API/Headers
-// TODO: move to http.zig. this has nothing to do with jsc or WebCore
-
-// ported from: src/runtime/webcore/Response.zig
+// TODO: move to the http module. this has nothing to do with jsc or WebCore
diff --git a/src/runtime/webcore/ResumableSink.rs b/src/runtime/webcore/ResumableSink.rs
index e0023881619..900bc7c5163 100644
--- a/src/runtime/webcore/ResumableSink.rs
+++ b/src/runtime/webcore/ResumableSink.rs
@@ -22,9 +22,7 @@ declare_scope!(ResumableSink, visible);
 /// Trait capturing the codegen'd JS-side accessors for a ResumableSink class
 /// (e.g. `jsc.Codegen.JSResumableFetchSink`).
 ///
-/// Models the Zig `comptime js: type` param, which carries a codegen module
-/// (a bag of free fns) by value. Rust generics carry types, not modules, so
-/// each monomorphization implements this trait by delegating to the matching
+/// Each monomorphization implements this trait by delegating to the matching
 /// `bun_jsc::generated::JS*` module — see [`impl_resumable_sink_js!`] below.
 pub trait ResumableSinkJs {
     fn to_js(this: *mut (), global: &JSGlobalObject) -> JSValue;
@@ -39,8 +37,7 @@ pub trait ResumableSinkJs {
 }
 
 /// Trait capturing the per-`Context` callbacks the sink invokes.
-/// In Zig these are `Context.writeRequestData` / `Context.writeEndRequest`.
-// Spec ResumableSink.zig:35 stores `context: *Context` (mutable). The only
+// The only
 // in-tree impls (FetchTasklet / S3UploadStreamWrapper) mutate self in both
 // callbacks (e.g. `detachSink`, `deref`, clearing `endPromise`), so these
 // MUST be `&mut self`.
@@ -153,7 +150,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
         context: *mut Context,
         ref_count: u32,
     ) -> *mut Self {
-        // `bun.TrivialNew(@This())` — heap-allocate via the global mimalloc;
+        // Heap-allocate via the global mimalloc;
         // `Self::deref_` reclaims via `heap::take` when the count hits 0.
         let this: *mut Self = bun_core::heap::into_raw(Box::new(Self {
             ref_count: Cell::new(ref_count),
@@ -169,8 +166,8 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
         let this_ref = unsafe { &mut *this };
 
         if stream.is_locked(global_this) || stream.is_disturbed(global_this) {
-            // PORT NOTE: `SystemError` has no `Default` impl upstream — spell out
-            // every field with its Zig default (SystemError.zig:1).
+            // `SystemError` has no `Default` impl upstream — spell out
+            // every field explicitly.
             let err = SystemError {
                 errno: 0,
                 code: BunString::static_(<&'static str>::from(ErrorCode::ERR_STREAM_CANNOT_PIPE)),
@@ -185,8 +182,8 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
             err_instance.ensure_still_alive();
             this_ref.status = Status::Done;
             Self::on_end(this_ref.context, Some(err_instance));
-            // SAFETY: `this` allocated above; may free here (see Zig — caller
-            // gets a dangling ptr in the error path and must not deref it).
+            // SAFETY: `this` allocated above; may free here — the caller gets
+            // a dangling ptr in the error path and must not deref it.
             unsafe { Self::deref_(this) };
             return this;
         }
@@ -214,8 +211,6 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
                     };
 
                     let bytes = byte_stream.drain();
-                    // PORT NOTE: `defer bytes.deinit(bun.default_allocator)` deleted — `bytes`
-                    // owns its buffer and Drop frees it.
                     scoped_log!(ResumableSink, "onWrite {}", bytes.len());
                     let _ = Self::on_write(this_ref.context, bytes.slice());
                     Self::on_end(this_ref.context, err);
@@ -225,7 +220,6 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
                 }
                 // We can pipe but we also wanna to drain as much as possible first
                 let bytes = byte_stream.drain();
-                // PORT NOTE: `defer bytes.deinit(...)` deleted — Drop frees it.
                 // lets write and see if we can still pipe or if we have backpressure
                 if bytes.len() > 0 {
                     scoped_log!(ResumableSink, "onWrite {}", bytes.len());
@@ -234,8 +228,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
                     let _ = Self::on_write(this_ref.context, bytes.slice());
                 }
                 this_ref.status = Status::Piped;
-                // PORT NOTE: jsc.WebCore.Pipe.Wrap(@This(), onStreamPipe).init(this) — the
-                // Zig comptime fn-ptr param is reshaped as a `PipeHandler` impl on `Self`
+                // The pipe callback is a `PipeHandler` impl on `Self`
                 // (see `impl PipeHandler` below); `Wrap::<Self>::init` erases `this` into
                 // the Pipe's ctx ptr.
                 byte_stream.pipe.set(Wrap::<Self>::init(this_ref));
@@ -333,7 +326,6 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
             )));
         };
 
-        // PORT NOTE: `defer sb.deinit()` deleted — StringOrBuffer impls Drop.
         let bytes = sb.slice();
         scoped_log!(ResumableSink, "jsWrite {}", bytes.len());
         match Self::on_write(this.context, bytes) {
@@ -474,15 +466,12 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
     }
 
     fn on_stream_pipe(&mut self, mut stream: StreamResult) {
-        // PORT NOTE: Zig `onStreamPipe(this, stream, allocator)` frees
-        // `.owned`/`.owned_and_done` payloads with the *caller-supplied*
-        // allocator. The Rust `Pipe`/`PipeHandler` reshape drops the allocator
-        // param because every producer (`ByteStream::on_data` — the sole `Pipe`
-        // call site) allocates with `bun.default_allocator`, which is the same
-        // global mimalloc that `Vec::<u8>::clear_and_free()` frees with. The
-        // `defer { switch }` is hoisted to the tail below (after `end_pipe`)
-        // since `StreamResult` has no `Drop` and `stream` is a stack local
-        // independent of `self`.
+        // No allocator param is needed: every producer (`ByteStream::on_data`
+        // — the sole `Pipe` call site) allocates with the same global mimalloc
+        // that `Vec::<u8>::clear_and_free()` frees with. The
+        // `.owned`/`.owned_and_done` payload is freed at the tail below (after
+        // `end_pipe`) since `StreamResult` has no `Drop` and `stream` is a
+        // stack local independent of `self`.
         let chunk = stream.slice();
         scoped_log!(ResumableSink, "onWrite {}", chunk.len());
 
@@ -507,7 +496,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
             // `self` may now be dangling — do NOT touch it past this point.
         }
 
-        // Zig `defer { owned.deinit(allocator) }` — see allocator note above.
+        // Free the owned payload — see allocator note above.
         if let StreamResult::Owned(owned) | StreamResult::OwnedAndDone(owned) = &mut stream {
             owned.clear_and_free();
         }
@@ -560,7 +549,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
         }
     }
 
-    // Intrusive refcount helpers (`bun.ptr.RefCount(@This(), "ref_count", deinit, .{})`).
+    // Intrusive refcount helpers.
     // `ref_()`/`deref()` are provided by `#[derive(CellRefCounted)]`; `deref_` is
     // kept as a thin alias so existing raw-pointer call sites (s3::client) keep
     // compiling without churn.
@@ -572,8 +561,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> ResumableSink<Js, Conte
 }
 
 // Satisfies `Wrap<T: PipeHandler>` so `Wrap::<Self>::init` can erase `*mut Self`
-// into a `Pipe`. Mirrors Zig `Pipe.Wrap(@This(), onStreamPipe)` where the
-// comptime fn-ptr param is fixed to `on_stream_pipe`.
+// into a `Pipe`; the handler is fixed to `on_stream_pipe`.
 impl<Js: ResumableSinkJs, Context: ResumableSinkContext> PipeHandler
     for ResumableSink<Js, Context>
 {
@@ -585,8 +573,7 @@ impl<Js: ResumableSinkJs, Context: ResumableSinkContext> PipeHandler
 
 impl<Js: ResumableSinkJs, Context: ResumableSinkContext> Drop for ResumableSink<Js, Context> {
     fn drop(&mut self) {
-        // Zig `deinit`: detachJS + stream.deinit() + bun.destroy(this).
-        // `bun.destroy` is the Box free (handled by deref_); stream Drop is automatic.
+        // The Box free is handled by `deref_`; stream Drop is automatic.
         self.detach_js();
     }
 }
@@ -599,7 +586,7 @@ pub enum ResumableSinkBackpressure {
 }
 
 /// Wire a zero-sized marker type to the matching `bun_jsc::generated::JS*`
-/// codegen module so it can stand in for the Zig `comptime js: type` param.
+/// codegen module so it can stand in for the JS-accessor type param.
 /// The marker is uninhabited (`enum {}`) — it carries the trait impl only.
 macro_rules! impl_resumable_sink_js {
     ($($name:ident),* $(,)?) => {$(
@@ -646,9 +633,8 @@ macro_rules! impl_resumable_sink_js {
 }
 impl_resumable_sink_js!(JSResumableFetchSink, JSResumableS3UploadSink);
 
-// Forward to the inherent methods on each Context type. The Zig spec uses
-// duck-typed `Context.writeRequestData` / `Context.writeEndRequest`; in Rust we
-// satisfy the trait bound by delegating to those inherent impls.
+// Forward to the inherent methods on each Context type; the trait bound is
+// satisfied by delegating to those inherent impls.
 // (S3UploadStreamWrapper's impl lives next to its struct in s3/client.rs.)
 impl ResumableSinkContext for FetchTasklet {
     #[inline]
@@ -671,5 +657,3 @@ unsafe extern "C" {
         sink: JSValue,
     ) -> JSValue;
 }
-
-// ported from: src/runtime/webcore/ResumableSink.zig
diff --git a/src/runtime/webcore/S3Client.rs b/src/runtime/webcore/S3Client.rs
index b2cdd646630..0e6cba37d08 100644
--- a/src/runtime/webcore/S3Client.rs
+++ b/src/runtime/webcore/S3Client.rs
@@ -30,14 +30,14 @@ macro_rules! pfmt {
 // `bun_s3_signing::S3Credentials` exposes `guessRegion` / `guessBucket` as
 // FREE fns and the JS-options parser lives in
 // `runtime/webcore/s3/credentials_jsc.rs`. Surface them as associated fns via
-// an extension trait so call sites keep their Zig shape
+// an extension trait so call sites can use the associated-fn shape
 // (`S3Credentials.guessRegion(...)` / `.getCredentialsWithOptions(...)`).
 pub(crate) trait S3CredentialsExt {
     fn guess_region(endpoint: &[u8]) -> &[u8];
     fn guess_bucket(endpoint: &[u8]) -> Option<&[u8]>;
     #[allow(clippy::too_many_arguments)]
     fn get_credentials_with_options(
-        // PORT NOTE: takes `&S3Credentials` (not by-value) — `bun_s3_signing::S3Credentials`
+        // Takes `&S3Credentials` (not by-value) — `bun_s3_signing::S3Credentials`
         // has a private `ref_count` field and no `Clone`, so callers holding a borrow
         // (e.g. `&IntrusiveRc<S3Credentials>` deref) cannot produce an owned copy. The
         // real impl in `s3/credentials_jsc.rs` deep-copies internally.
@@ -104,7 +104,6 @@ where
     writer.write_str("\n")?;
 
     {
-        // Zig: `formatter.indent += 1; defer formatter.indent -|= 1;`.
         // `IndentScope` shadows the borrow and restores indent on `Drop`, so a
         // `?` early-return below still leaves the formatter at its original
         // depth (observable when `print_as` throws and the caller continues
@@ -251,13 +250,13 @@ impl Drop for S3Client {
         // `IntrusiveRc<T>` is `bun_ptr::RefPtr<T>`, which has no `Drop` impl
         // of its own (only `ScopedRef<T>` does), so the +1 taken by
         // `aws_options.credentials.dupe()` in `constructor` must be released
-        // explicitly. Mirrors Zig `S3Client.deinit`: `this.credentials.deref()`.
+        // explicitly.
         self.credentials.deref();
     }
 }
 
 impl S3Client {
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — the `#[bun_jsc::JsClass]`
+    // No `#[bun_jsc::host_fn]` here — the `#[bun_jsc::JsClass]`
     // derive on the struct emits `S3ClientClass__construct` which calls
     // `<S3Client>::constructor` directly.
     pub(crate) fn constructor(
@@ -361,8 +360,8 @@ impl S3Client {
             }
         };
         let options = args.next_eat();
-        // Zig: `Blob.new(try ...)` — heap-promote and mark `ref_count = 1` so
-        // the JSS3File wrapper's `finalize` knows to `bun.destroy(blob)`.
+        // `Blob::new` heap-promotes and marks `ref_count = 1` so
+        // the JSS3File wrapper's `finalize` knows to free the blob.
         let blob = crate::webcore::blob::Blob::new(
             S3File::construct_s3_file_with_s3_credentials_and_options(
                 global,
@@ -375,7 +374,7 @@ impl S3Client {
                 ptr.request_payer,
             )?,
         );
-        // Zig: `blob.toJS(globalThis)` — runs `calculateEstimatedByteSize()`
+        // `to_js` runs `calculateEstimatedByteSize()`
         // before wrapping the heap Blob in a JSS3File so JSC sees the correct
         // GC pressure. Route through `BlobExt::to_js` (the `&mut self` method
         // that owns the heap pointer), same as `S3File::construct_internal_js`.
@@ -591,10 +590,8 @@ impl S3Client {
             ptr.storage_class,
             ptr.request_payer,
         )?;
-        // PORT NOTE: reshaped for borrowck — Zig copied `blob` into `blob_internal`
-        // by value while `defer blob.detach()` was still armed on the original.
-        // Here we move into `PathOrBlob` directly; cleanup of the moved-out
-        // value is handled by `Drop`.
+        // Move into `PathOrBlob` directly; cleanup of the moved-out value is
+        // handled by `Drop`.
         let mut blob_internal = crate::webcore::node_types::PathOrBlob::Blob(Box::new(blob));
         crate::webcore::blob::write_file_internal(
             global,
@@ -631,7 +628,6 @@ impl S3Client {
             ptr.request_payer,
         )?;
 
-        // Zig: `blob.store.?.data.s3.listObjects(blob.store.?, globalThis, object_keys, options)`.
         let store = blob.store.get().as_ref().unwrap();
         store
             .data
@@ -672,7 +668,6 @@ impl S3Client {
             ptr.storage_class,
             ptr.request_payer,
         )?;
-        // Zig: `blob.store.?.data.s3.unlink(blob.store.?, globalThis, options)`.
         let store = blob.store.get().as_ref().unwrap();
         store.data.as_s3().unlink(store, global, options)
     }
@@ -759,7 +754,6 @@ impl S3Client {
             &existing_credentials,
         )?;
 
-        // Zig: `blob.store.?.data.s3.listObjects(blob.store.?, globalThis, object_keys, options)`.
         let store = blob.store.get().as_ref().unwrap();
         store
             .data
@@ -771,5 +765,3 @@ impl S3Client {
 // `FormatTag` / `JSType` are the ConsoleObject formatter enums
 // (`.Double`, `.NumberObject`), re-exported at the `bun_jsc` crate root.
 use bun_jsc::{FormatTag, JSType};
-
-// ported from: src/runtime/webcore/S3Client.zig
diff --git a/src/runtime/webcore/S3File.rs b/src/runtime/webcore/S3File.rs
index 35cb9596ac4..8122390ea10 100644
--- a/src/runtime/webcore/S3File.rs
+++ b/src/runtime/webcore/S3File.rs
@@ -114,7 +114,7 @@ pub(crate) fn presign(global: &JSGlobalObject, callframe: &CallFrame) -> JsResul
 
     // accept a path or a blob
     let path_or_blob = PathOrBlob::from_js_no_copy(global, &mut args)?;
-    // errdefer: PathOrBlob impls Drop in Rust — path variant cleaned up automatically on `?`
+    // PathOrBlob impls Drop — path variant cleaned up automatically on `?`
 
     if let PathOrBlob::Blob(blob) = &path_or_blob {
         if blob.store.get().is_none()
@@ -238,7 +238,7 @@ pub fn write(global: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue
             )
         }
         PathOrBlob::Blob(blob) => {
-            // PORT NOTE: reshaped for borrowck — match consumes path_or_blob; rebuild to pass &mut PathOrBlob
+            // Reshaped for borrowck — match consumes path_or_blob; rebuild to pass &mut PathOrBlob
             let mut pob = PathOrBlob::Blob(blob);
             blob::write_file_internal(
                 global,
@@ -372,17 +372,15 @@ pub(crate) fn construct_s3_file_with_s3_credentials_and_options(
         if aws_options.changed_credentials {
             break 'brk blob::Store::init_s3(path, None, aws_options.credentials).expect("oom");
         } else {
-            // PORT NOTE: Zig `initS3WithReferencedCredentials` bumps the
-            // intrusive ref on `default_credentials` (a `*S3Credentials`).
-            // The Rust `Store::S3` field is `Rc<S3Credentials>` (separate rc
+            // The `Store::S3` field is `Rc<S3Credentials>` (separate rc
             // layer), so we can't share the existing intrusive allocation —
             // deep-clone the value instead and let `init_s3` `Rc::new` it.
-            // PERF(port): was intrusive ref-bump (no copy) — profile if hot
-            // once Store.rs migrates `Rc<S3Credentials>` → `IntrusiveRc`.
+            // PERF: profile if hot once Store.rs migrates
+            // `Rc<S3Credentials>` → `IntrusiveRc`.
             break 'brk blob::Store::init_s3(path, None, default_credentials.clone()).expect("oom");
         }
     };
-    // errdefer store.deinit() — handled by Drop on early return
+    // store cleanup on early return is handled by Drop
     store.data.as_s3_mut().options = aws_options.options;
     store.data.as_s3_mut().acl = aws_options.acl;
     store.data.as_s3_mut().storage_class = aws_options.storage_class;
@@ -402,7 +400,7 @@ pub(crate) fn construct_s3_file_with_s3_credentials_and_options(
                         blob.content_type_was_set.set(true);
                         // SAFETY: bun_vm() returns the live VM raw ptr.
                         if let Some(entry) = global.bun_vm().as_mut().mime_type(str.slice()) {
-                            // PORT NOTE: `MimeType.value` is `Cow<'static, [u8]>`; the
+                            // `MimeType.value` is `Cow<'static, [u8]>`; the
                             // canonical-table hit (via `Compact::to_mime_type`) is always
                             // `Borrowed(&'static)`. If a future table source ever yields
                             // `Owned`, hand the buffer to the blob's allocated-content-type
@@ -449,7 +447,7 @@ pub(crate) fn construct_s3_file_with_s3_credentials(
         global,
     )?;
     let mut store = blob::Store::init_s3(path, None, aws_options.credentials).expect("oom");
-    // errdefer store.deinit() — handled by Drop on early return
+    // store cleanup on early return is handled by Drop
     store.data.as_s3_mut().options = aws_options.options;
     store.data.as_s3_mut().acl = aws_options.acl;
     store.data.as_s3_mut().storage_class = aws_options.storage_class;
@@ -469,7 +467,7 @@ pub(crate) fn construct_s3_file_with_s3_credentials(
                         blob.content_type_was_set.set(true);
                         // SAFETY: bun_vm() returns the live VM raw ptr.
                         if let Some(entry) = global.bun_vm().as_mut().mime_type(str.slice()) {
-                            // PORT NOTE: `MimeType.value` is `Cow<'static, [u8]>`; the
+                            // `MimeType.value` is `Cow<'static, [u8]>`; the
                             // canonical-table hit (via `Compact::to_mime_type`) is always
                             // `Borrowed(&'static)`. If a future table source ever yields
                             // `Owned`, hand the buffer to the blob's allocated-content-type
@@ -573,7 +571,6 @@ impl S3BlobStatTask {
                     .resolve(global, JSValue::js_number(stat_result.size as f64))?;
             }
             s3::S3StatResult::NotFound(err) | s3::S3StatResult::Failure(err) => {
-                // TODO(port): Zig binds same payload name for .not_found and .failure arms; verify NotFound carries an error payload
                 let value = s3_error_to_js_with_async_stack(
                     &err,
                     global,
@@ -705,12 +702,11 @@ impl S3BlobStatTask {
         Ok(promise)
     }
 
-    // deinit: store.deref() + promise.deinit() + bun.destroy(this) — all handled by Box<Self> Drop
+    // Teardown (store deref, promise deinit, freeing the box) is handled by Box<Self> Drop.
 }
 
-// PORT NOTE: `Method.fromJS` lives in `bun_http_jsc` so `bun_http_types` stays
-// JSC-free. Thin local alias keeps the `getPresignUrlFrom` body diff-stable
-// against the Zig.
+// `Method.fromJS` lives in `bun_http_jsc` so `bun_http_types` stays
+// JSC-free. Thin local alias for the `getPresignUrlFrom` body.
 #[inline]
 fn method_from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<Option<Method>> {
     bun_http_jsc::method_jsc::from_js(global, value)
@@ -734,7 +730,6 @@ pub(crate) fn get_presign_url_from(
     let mut expires: usize = 86400; // 1 day default
 
     let s3 = this.store.get().as_ref().unwrap().data.as_s3();
-    // Zig: `.{ .credentials = s3.getCredentials().*, .request_payer = s3.request_payer }`.
     // `acl`/`storage_class`/`content_*` deliberately stay at their `None`
     // defaults here — they are only seeded from the store when extra_options
     // is provided (via `getCredentialsWithOptions` below).
@@ -821,9 +816,9 @@ pub(crate) fn get_bucket_name(this: &Blob) -> Option<&[u8]> {
     Some(bucket)
 }
 
-// PORT NOTE: `#[bun_jsc::host_fn(getter|method)]` requires `Self` (impl-block
+// `#[bun_jsc::host_fn(getter|method)]` requires `Self` (impl-block
 // context). These are free fns on `*Blob` exported manually as `JSS3File__*`
-// (see `@export` block below) and called as `s3_file::get_*` from `Blob::get_*`,
+// (see the `exports` block below) and called as `s3_file::get_*` from `Blob::get_*`,
 // so the proc-macro shim is not used here — the raw ABI shim is hand-wired.
 pub(crate) fn get_bucket(this: &Blob, global: &JSGlobalObject) -> JsResult<JSValue> {
     if let Some(name) = get_bucket_name(this) {
@@ -928,7 +923,8 @@ pub(crate) fn construct_internal(
     construct_s3_file_internal(global, path, args.next_eat())
 }
 
-// TODO(port): callconv(jsc.conv) — #[bun_jsc::host_fn] macro emits the raw ABI shim; @export name handled below
+// Hand-written ABI shim: returns `*mut Blob` (codegen constructor contract),
+// which `#[bun_jsc::host_fn]` does not model; the exported symbol name is wired below.
 pub(crate) fn construct(global: &JSGlobalObject, callframe: &CallFrame) -> *mut Blob {
     match construct_internal(global, callframe) {
         Ok(b) => b,
@@ -949,7 +945,7 @@ pub(crate) fn has_instance(_: JSValue, _global: &JSGlobalObject, value: JSValue)
     blob.is_s3()
 }
 
-// @export block — symbols exported with C linkage and JSC calling convention.
+// Symbols exported with C linkage and JSC calling convention.
 // JSS3File__presign     -> raw shim wrapping get_presign_url (method-with-context)
 // JSS3File__construct   -> construct
 // JSS3File__hasInstance -> has_instance
@@ -959,8 +955,7 @@ pub(crate) fn has_instance(_: JSValue, _global: &JSGlobalObject, value: JSValue)
 pub mod exports {
     use super::*;
 
-    /// `@export(&hasInstance, .{ .name = "JSS3File__hasInstance" })` —
-    /// `customHasInstance` hook (`callconv(jsc.conv)`, `(EncodedJSValue,
+    /// `customHasInstance` hook (JSC calling convention, `(EncodedJSValue,
     /// *JSGlobalObject, EncodedJSValue) -> bool`).
     #[unsafe(no_mangle)]
     #[bun_jsc::host_call]
@@ -972,16 +967,16 @@ pub mod exports {
         super::has_instance(this, global, value)
     }
 
-    /// `@export(&construct, .{ .name = "JSS3File__construct" })` — bare ctor,
-    /// not routed through `toJSHostFn` (returns `?*Blob`, not `JSValue`).
+    /// Bare ctor, not routed through `toJSHostFn` (returns a nullable
+    /// `*mut Blob`, not `JSValue`).
     #[unsafe(no_mangle)]
     #[bun_jsc::host_call]
     pub(crate) fn JSS3File__construct(global: &JSGlobalObject, callframe: &CallFrame) -> *mut Blob {
         super::construct(global, callframe)
     }
 
-    /// `@export(&getBucket, .{ .name = "JSS3File__bucket" })` — getter
-    /// (`callconv(jsc.conv)`, takes `*Blob, *JSGlobalObject`, returns JSValue).
+    /// Getter (JSC calling convention; takes `*Blob, *JSGlobalObject`,
+    /// returns JSValue).
     #[unsafe(no_mangle)]
     #[bun_jsc::host_call]
     pub(crate) fn JSS3File__bucket(this: *mut Blob, global: *mut JSGlobalObject) -> JSValue {
@@ -990,7 +985,7 @@ pub mod exports {
         bun_jsc::to_js_host_call(global, || super::get_bucket(this, global))
     }
 
-    /// `@export(&jsc.toJSHostFnWithContext(Blob, getPresignUrl), ...)`.
+    /// Method-with-context shim wrapping `get_presign_url`.
     #[unsafe(no_mangle)]
     #[bun_jsc::host_call]
     pub(crate) fn JSS3File__presign(
@@ -1003,8 +998,6 @@ pub mod exports {
         bun_jsc::to_js_host_call(global, || super::get_presign_url(this, global, callframe))
     }
 
-    /// `@export(&getStat, .{ .name = "JSS3File__stat" })` — direct
-    /// `callconv(jsc.conv)` method (Zig body already swallows JsError → .zero).
     #[unsafe(no_mangle)]
     #[bun_jsc::host_call]
     pub(crate) fn JSS3File__stat(
@@ -1018,7 +1011,6 @@ pub mod exports {
     }
 }
 
-// TODO(port): move to <area>_sys
 // C++ side defines `SYSV_ABI EncodedJSValue` (JSS3File.cpp).
 bun_jsc::jsc_abi_extern! {
     safe fn BUN__createJSS3File(global: &JSGlobalObject, callframe: &CallFrame) -> JSValue;
@@ -1036,5 +1028,3 @@ bun_jsc::jsc_abi_extern! {
 pub(crate) fn create_js_s3_file(global: &JSGlobalObject, callframe: &CallFrame) -> JSValue {
     BUN__createJSS3File(global, callframe)
 }
-
-// ported from: src/runtime/webcore/S3File.zig
diff --git a/src/runtime/webcore/S3Stat.rs b/src/runtime/webcore/S3Stat.rs
index 926eb1ee482..3387b793b5b 100644
--- a/src/runtime/webcore/S3Stat.rs
+++ b/src/runtime/webcore/S3Stat.rs
@@ -24,7 +24,7 @@ impl S3Stat {
         global: &JSGlobalObject,
     ) -> JsResult<Box<Self>> {
         // `bun_core::String` is `Copy` (no `Drop`); wrap in `OwnedString` so the
-        // Zig `defer date_str.deref()` runs on both the `Ok` and `?`-error paths.
+        // string is deref'd on both the `Ok` and `?`-error paths.
         let mut date_str = OwnedString::new(BunString::init(last_modified));
         let last_modified = bun_jsc::bun_string_jsc::parse_date(&mut date_str, global)?;
 
@@ -62,11 +62,9 @@ impl Drop for S3Stat {
         // `bun_core::String` is `#[derive(Copy)]` with NO `Drop` impl
         // (src/string/lib.rs), so dropping the Box alone would leak the +1
         // WTFStringImpl refs taken by `clone_utf8` in `init`. Release them
-        // explicitly, mirroring Zig's `this.etag.deref(); this.contentType.deref();`.
+        // explicitly.
         // The default `JsFinalize::finalize` (`drop(self)`) runs this on GC.
         self.etag.deref();
         self.content_type.deref();
     }
 }
-
-// ported from: src/runtime/webcore/S3Stat.zig
diff --git a/src/runtime/webcore/ScriptExecutionContext.rs b/src/runtime/webcore/ScriptExecutionContext.rs
index 0efa4618a4d..e7846487d04 100644
--- a/src/runtime/webcore/ScriptExecutionContext.rs
+++ b/src/runtime/webcore/ScriptExecutionContext.rs
@@ -25,5 +25,3 @@ impl IdentifierExt for Identifier {
         self.global_object().is_some()
     }
 }
-
-// ported from: src/runtime/webcore/ScriptExecutionContext.zig
diff --git a/src/runtime/webcore/Sink.rs b/src/runtime/webcore/Sink.rs
index 0db7f68045d..4a028e0d2dd 100644
--- a/src/runtime/webcore/Sink.rs
+++ b/src/runtime/webcore/Sink.rs
@@ -7,18 +7,17 @@ use bun_core::strings;
 use bun_jsc::{JSGlobalObject, JSValue};
 use bun_sys::{self as sys, Error as SysError};
 
-// PORT NOTE: re-export the real ArrayBufferSink so `crate::webcore::sink::ArrayBufferSink`
+// Re-export the real ArrayBufferSink so `crate::webcore::sink::ArrayBufferSink`
 // resolves to the full type (with `bytes`/`signal`/`destroy`) for Body.rs.
 pub use crate::webcore::array_buffer_sink::ArrayBufferSink;
 
 crate::impl_js_sink_abi!(ArrayBufferSink, "ArrayBufferSink");
 
 impl JSSink<ArrayBufferSink> {
-    /// Port of Zig `JSSink.detach` (Sink.zig) for the `ArrayBufferSink`
-    /// instantiation. Unprotects the controller cell stashed in `signal.ptr`
+    /// Unprotects the controller cell stashed in `signal.ptr`
     /// and tells C++ to drop its back-pointer. Called from
     /// `Body::ValueBufferer` Drop / reject paths.
-    // PORT NOTE: renamed from `detach` to avoid colliding with the generic
+    // Renamed from `detach` to avoid colliding with the generic
     // `JSSink<T: JsSinkAbi>::detach(signal, global)` associated fn — Rust
     // forbids same-name items across impl blocks for the same type even with
     // different signatures (E0592).
@@ -34,7 +33,7 @@ pub use crate::webcore::file_sink::FileSink;
 
 /// A `Sink` is a hand-rolled vtable-based writable stream sink.
 pub struct Sink<'a> {
-    // LIFETIMES.tsv: BORROW_PARAM — Sink.zig:26-28 initWithType stores handler param;
+    // LIFETIMES.tsv: BORROW_PARAM — init_with_type stores the handler borrow;
     // no deinit, end() only dispatches
     pub ptr: &'a mut (),
     pub vtable: VTable,
@@ -43,23 +42,24 @@ pub struct Sink<'a> {
 }
 
 impl<'a> Sink<'a> {
-    // TODO(port): `pending` uses @ptrFromInt(0xaaaaaaaa) as a sentinel non-null pointer
-    // and `vtable: undefined`. Cannot express as `&'a mut ()` safely; should
-    // re-evaluate `ptr` field type (likely `NonNull<c_void>` for the vtable-erased
-    // pattern) or provide `Sink::pending()` constructing with a dangling NonNull.
+    // `ptr` stays `&'a mut ()`: a reference to a
+    // zero-sized type only needs a non-null, aligned address, so a dangling
+    // pointer is a *valid* `&mut ()` (the same rule `Box<()>` relies on).
     pub fn pending() -> Sink<'static> {
-        // SAFETY: sentinel address never dereferenced; status == Closed gates all dispatch
-        // so neither `ptr` nor `vtable` is used before being overwritten by init_with_type.
+        // SAFETY: `()` is zero-sized, so `NonNull::dangling()` (non-null,
+        // aligned) is valid to reborrow as `&mut ()`; nothing is ever read or
+        // written through it. status == Closed gates all dispatch so neither
+        // `ptr` nor `vtable` is used before being overwritten by init_with_type.
         //
-        // The Zig original used `vtable: undefined`. In Rust, both `zeroed()` and
+        // Both `zeroed()` and
         // `MaybeUninit::uninit().assume_init()` are immediate UB for a struct of
         // non-nullable `fn` pointers (niche-bearing). Instead we install a *valid*
         // sentinel vtable whose entries unconditionally panic — this keeps the value
-        // well-formed at all times and turns any accidental dispatch (the bug Zig's
-        // `undefined` would have hidden) into a loud, deterministic crash.
+        // well-formed at all times and turns any accidental dispatch
+        // into a loud, deterministic crash.
         unsafe {
             Sink {
-                ptr: &mut *(0xaaaa_aaaa_usize as *mut ()),
+                ptr: &mut *core::ptr::NonNull::<()>::dangling().as_ptr(),
                 vtable: VTable::PENDING,
                 status: Status::Closed,
                 used: false,
@@ -82,7 +82,6 @@ pub enum Data {
 }
 
 /// Trait capturing the duck-typed methods `VTable::wrap` expects on `Wrapped`.
-/// Zig used `@hasDecl`/direct method calls; Rust expresses this as a trait bound.
 pub trait SinkHandler {
     fn write(&mut self, data: &streams::Result) -> streams::result::Writable;
     fn write_latin1(&mut self, data: &streams::Result) -> streams::result::Writable;
@@ -94,12 +93,6 @@ pub trait SinkHandler {
 /// Generates the boilerplate `impl SinkHandler for $Ty` that forwards every
 /// trait method to the same-named **inherent** method on `$Ty`.
 ///
-/// Mirrors Zig `Sink.VTable.wrap(comptime Wrapped)` (src/runtime/webcore/Sink.zig:105-146),
-/// which builds the vtable by comptime duck-typing on `Wrapped.{write,writeLatin1,
-/// writeUTF16,end,connect}` — no per-type forwarding shim exists in Zig. The
-/// five hand-written Rust impls were pure port artifacts of needing nominal
-/// trait impls; this macro restores the single-definition shape.
-///
 /// `connect`: the inherent fn returns `()` (and may take `&self` *or* `&mut self`
 /// — `&mut → &` coerces); the trait wants `bun_sys::Result<()>`, so the macro
 /// wraps it in `Ok(())`.
@@ -170,14 +163,12 @@ pub fn init_with_type<T: SinkHandler>(handler: &mut T) -> Sink<'_> {
 }
 
 pub fn init<T: SinkHandler>(handler: &mut T) -> Sink<'_> {
-    // Zig: initWithType(std.meta.Child(@TypeOf(handler)), handler) — Rust generics
-    // already name the pointee type, so this collapses to init_with_type.
     init_with_type(handler)
 }
 
 impl<'a> Sink<'a> {
     /// Associated-fn alias of the free `init<T>` so callers can write
-    /// `webcore::Sink::init(self)` (matches the Zig `Sink.init(self)` shape).
+    /// `webcore::Sink::init(self)`.
     pub fn init<T: SinkHandler>(handler: &mut T) -> Sink<'_> {
         init_with_type(handler)
     }
@@ -186,10 +177,9 @@ impl<'a> Sink<'a> {
 pub struct UTF8Fallback;
 
 // `Sink::UTF8Fallback` is referenced as `webcore::Sink::UTF8Fallback` by
-// html_rewriter (Zig nested-type style). Expose via inherent-impl associated
+// html_rewriter. Expose via inherent-impl associated
 // type alias once inherent associated types are stable; for now consumers
 // should reference `crate::webcore::sink::UTF8Fallback` directly.
-// TODO(port): inherent associated type — `impl Sink { pub type UTF8Fallback = UTF8Fallback; }`.
 
 impl UTF8Fallback {
     const STACK_SIZE: usize = 1024;
@@ -199,7 +189,6 @@ impl UTF8Fallback {
         input: &streams::Result,
         write_fn: fn(&mut Ctx, &streams::Result) -> streams::result::Writable,
     ) -> streams::result::Writable {
-        // PERF(port): `write_fn` was `comptime anytype` (monomorphized); now a fn pointer.
         let str_ = input.slice();
         if strings::is_all_ascii(str_) {
             return write_fn(ctx, input);
@@ -222,13 +211,15 @@ impl UTF8Fallback {
         }
 
         {
-            // Zig: bun.default_allocator.alloc(u8, str.len) catch return .{ .err = Syscall.Error.oom }
-            // TODO(port): allocation-failure handling — Rust Vec aborts on OOM (no unwind);
-            // should route through bun_alloc fallible alloc to preserve `.err = oom`.
-            let mut slice = vec![0u8; str_.len()];
-            slice[..str_.len()].copy_from_slice(str_);
+            // Allocate fallibly so memory pressure surfaces as `.err = oom`
+            // instead of aborting the process.
+            let mut slice: Vec<u8> = Vec::new();
+            if slice.try_reserve_exact(str_.len()).is_err() {
+                return streams::result::Writable::Err(SysError::oom());
+            }
+            slice.extend_from_slice(str_);
 
-            strings::replace_latin1_with_utf8(&mut slice[..str_.len()]);
+            strings::replace_latin1_with_utf8(&mut slice[..]);
             if input.is_done() {
                 write_fn(
                     ctx,
@@ -250,7 +241,6 @@ impl UTF8Fallback {
         input: &streams::Result,
         write_fn: fn(&mut Ctx, &streams::Result) -> streams::result::Writable,
     ) -> streams::result::Writable {
-        // PERF(port): `write_fn` was `comptime anytype` (monomorphized); now a fn pointer.
         let bytes = input.slice();
         // input.slice() is guaranteed by caller to be u16-aligned UTF-16 bytes;
         // bytemuck checks alignment + even length at runtime.
@@ -273,11 +263,19 @@ impl UTF8Fallback {
         }
 
         {
-            // TODO(port): allocation-failure handling — `bun_core::strings::to_utf8_alloc`
-            // re-exports the bun_core variant which aborts on OOM (returns Vec<u8>, not
-            // Result). Should route through a fallible allocator to preserve
-            // `.err = oom`.
-            let allocated = strings::to_utf8_alloc(str_);
+            // UTF-8 (and the WTF-8 lone-surrogate fallback) needs at most 3
+            // bytes per UTF-16 code unit; reserving that fallibly up front
+            // (plus the 16-byte slack `to_utf8_append_to_list` asks for) makes
+            // the append below allocation-free, so memory pressure surfaces
+            // as `.err = oom` instead of aborting the process.
+            let Some(worst_case) = str_.len().checked_mul(3).and_then(|n| n.checked_add(16)) else {
+                return streams::result::Writable::Err(SysError::oom());
+            };
+            let mut allocated: Vec<u8> = Vec::new();
+            if allocated.try_reserve_exact(worst_case).is_err() {
+                return streams::result::Writable::Err(SysError::oom());
+            }
+            strings::to_utf8_append_to_list(&mut allocated, str_);
             if input.is_done() {
                 write_fn(
                     ctx,
@@ -313,7 +311,7 @@ pub struct VTable {
 }
 
 impl VTable {
-    /// Sentinel vtable used for `Sink::pending()` (Zig: `vtable: undefined`).
+    /// Sentinel vtable used for `Sink::pending()`.
     ///
     /// VTable's fields are bare `fn(...)` pointers — a niche-bearing non-nullable type — so
     /// producing one via `MaybeUninit::uninit().assume_init()` or `mem::zeroed()` is
@@ -449,7 +447,7 @@ impl<'a> Sink<'a> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// JSSink — Zig: `fn JSSink(comptime SinkType, comptime abi_name) type`
+// JSSink
 //
 // Rust cannot pass a `&str` const-generic for symbol-name concatenation in
 // `#[link_name]`, so the per-abi extern set is supplied via `JsSinkAbi`
@@ -458,10 +456,9 @@ impl<'a> Sink<'a> {
 // `@hasField` checks become associated consts on `JsSinkType`.
 // ──────────────────────────────────────────────────────────────────────────
 
-/// `Sink.JSSink(SinkType, abi_name)` — generic sink-to-JS wrapper. In Zig this
-/// is a comptime type-generator; here it is a plain generic over
+/// Generic sink-to-JS wrapper: a plain generic over
 /// `T: JsSinkType + JsSinkAbi` with host-fn bodies in the `impl` block below.
-// `repr(transparent)`: the Zig `ThisSink = struct { sink: SinkType }` is
+// `repr(transparent)`: the value is
 // allocated as the JSSink wrapper but freed via `this.sink.destroy()` (the
 // inner address). With `transparent` the inner and outer share Layout, so
 // `heap::take` on the inner pointer (e.g. `HTTPServerWritable::destroy`)
@@ -472,10 +469,8 @@ pub struct JSSink<T> {
 }
 
 // ─── Canonical JsSinkAbi codegen ────────────────────────────────────────────
-// Rust equivalent of Zig `Sink.JSSink(comptime SinkType, comptime abi_name)`'s
-// `@extern(.{ .name = abi_name ++ "__fn" })` block (Sink.zig:253-344). Const-
-// generic `&'static str` cannot drive `#[link_name]`, so the abi name is taken
-// as a macro literal and `concat!`-ed — exactly mirroring `abi_name ++ "__…"`.
+// Const-generic `&'static str` cannot drive `#[link_name]`, so the abi name is
+// taken as a macro literal and `concat!`-ed.
 //
 // `decl_js_sink_externs!` emits the 7-fn extern set into a named submodule;
 // `impl_js_sink_abi!` wraps it in a 1:1-forwarding `JsSinkAbi` impl. The
@@ -610,7 +605,7 @@ pub trait JsSinkAbi {
 }
 
 /// `from_js_extern` encodes two distinct failure types using 0 and 1. Any other
-/// value is `*ThisSink`. (Zig non-exhaustive `enum(usize)` → matched-by-const.)
+/// value is `*ThisSink`.
 pub mod from_js_result {
     /// The sink has been closed and the wrapped type is freed.
     pub const DETACHED: usize = 0;
@@ -660,10 +655,7 @@ impl<T: JsSinkAbi> JSSink<T> {
     }
 
     /// `JSSink.detach(globalThis)` — disconnect the C++ controller cell stashed
-    /// in `signal.ptr` (a JSValue's encoded bits, see `SinkSignal::init`). Port
-    /// of `Sink.JSSink.detach` (Sink.zig) for the `HAS_SIGNAL = true` path; the
-    /// `@hasField(SinkType, "signal")` early-return is folded into the caller
-    /// by passing the `Signal` directly.
+    /// in `signal.ptr` (a JSValue's encoded bits, see `SinkSignal::init`).
     pub fn detach(signal: &mut Signal, _global: &crate::webcore::jsc::JSGlobalObject) {
         use crate::webcore::jsc::JSValue;
         let Some(ptr) = signal.ptr else { return }; // is_dead()
@@ -672,13 +664,13 @@ impl<T: JsSinkAbi> JSSink<T> {
         // encoded JSValue bits (never a real Rust pointer); bitcast back.
         let value = JSValue::from_encoded(ptr.as_ptr() as usize);
         value.unprotect();
-        // Zig: `detachPtr(globalThis, value) catch {}` — `${abi}__detachPtr`
+        // `${abi}__detachPtr`
         // calls the JS `onClose` callback via the bare `JSC::call(...)`
         // overload (no NakedPtr/TopExceptionScope of its own), so
         // `executeCallImpl`'s ThrowScope is the outermost scope and its dtor
         // `simulateThrow()` leaves `m_needExceptionCheck` set. Wrap in a
-        // TopExceptionScope (matching Zig's `fromJSHostCallGeneric`) so the
-        // verifier is satisfied; discard the result like `catch {}`.
+        // TopExceptionScope so the
+        // verifier is satisfied; discard the result.
         // TODO: properly propagate exception upwards.
         let _ = ::bun_jsc::call_check_slow(_global, || T::detach_ptr_extern(value));
     }
@@ -688,8 +680,7 @@ impl<T: JsSinkAbi> JSSink<T> {
 /// a `streams::Signal`. The pointer stored in `Signal.ptr` is the encoded
 /// JSValue bits, never dereferenced; vtable thunks bitcast back and call the
 /// generated `${abi_name}__onClose` / `__onReady` externs.
-// PORT NOTE: Zig nested-type `JSSink(SinkType, abi).SinkSignal` would be an
-// inherent associated type in Rust (unstable). Expose as a free generic and
+// Inherent associated types are unstable, so this is a free generic;
 // let each caller alias via `type SinkSignal = sink::SinkSignal<Self>;`.
 #[repr(C)]
 pub struct SinkSignal<T>(core::marker::PhantomData<T>);
@@ -697,15 +688,14 @@ pub struct SinkSignal<T>(core::marker::PhantomData<T>);
 impl<T: JsSinkAbi> SinkSignal<T> {
     pub fn init(cpp: crate::webcore::jsc::JSValue) -> Signal {
         use crate::webcore::jsc::JSValue;
-        // PORT NOTE: bypass `Signal::init_with_type` (which would form a fake
+        // Bypass `Signal::init_with_type` (which would form a fake
         // `&mut SinkSignal<T>` ref); build the vtable directly so `this` stays
-        // a raw bit-pattern (`@setRuntimeSafety(false)` in Zig).
+        // a raw bit-pattern.
         fn close<T: JsSinkAbi>(this: *mut c_void, _err: Option<SysError>) {
             // `this` is the JSValue bits stashed by `init`; bitcast back.
             let cpp = JSValue::from_encoded(this as usize);
-            // Zig (Sink.zig:265-268): `onClose` wraps the extern in
-            // `fromJSHostCallGeneric` so the C++ ThrowScope's `simulateThrow()`
-            // is satisfied; route through the same path here.
+            // `call_check_slow` satisfies the C++ ThrowScope's
+            // `simulateThrow()`.
             // TODO: this should be got from a parameter / properly propagate exception upwards.
             let global = ::bun_jsc::virtual_machine::VirtualMachine::get().global();
             let _ =
@@ -733,9 +723,8 @@ impl<T: JsSinkAbi> SinkSignal<T> {
 }
 
 /// Trait collecting every method `JSSink` may call on the wrapped `SinkType`.
-/// Zig used `@hasDecl(SinkType, "...")` to make most of these optional; Rust
-/// models that with default method bodies. Associated `const`s replace
-/// `@hasField` checks.
+/// Most of these are optional, modeled with default method bodies and
+/// associated `const` gates.
 pub trait JsSinkType: Sized {
     const NAME: &'static str;
     /// Mirrors `@hasDecl(SinkType, "construct")`.
@@ -782,8 +771,7 @@ pub trait JsSinkType: Sized {
     }
     fn flush_from_js(&mut self, _global: &JSGlobalObject, _wait: bool) -> sys::Result<JSValue> {
         // Guarded by `HAS_FLUSH_FROM_JS`; default impl delegates to `flush()`
-        // (returning undefined on success) so the non-override path matches
-        // Zig's `!@hasDecl(SinkType, "flushFromJS")` arm — buffered bytes are
+        // (returning undefined on success) so buffered bytes are
         // still flushed even if a caller bypasses `js_flush`.
         self.flush().map(|()| JSValue::UNDEFINED)
     }
@@ -798,22 +786,22 @@ pub trait JsSinkType: Sized {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// JSSink<T> generic host-fn glue (port of Sink.zig `JSSink(SinkType, abi)`)
+// JSSink<T> generic host-fn glue
 //
 // The codegen (`generate-jssink.ts`) emits `#[no_mangle] extern "C"` thunks
 // for `${name}__{construct,write,end,flush,start,getInternalFd,memoryCost,
 // finalize,close,endWithSink,updateRef}` that call these. Keeping the host-fn
 // validation here (instead of on each `SinkType`) avoids the inherent-method
-// name collision with the inner `write/end/flush/start` and matches Zig's
-// layering exactly: the JSSink wrapper owns the JS-facing surface, the
+// name collision with the inner `write/end/flush/start`: the JSSink
+// wrapper owns the JS-facing surface, the
 // SinkType owns the streaming logic.
 //
 // This is the SOLE implementation. The earlier `macro_rules! js_sink`
 // reference port has been deleted — it was never instantiated, half its bodies
 // no longer type-checked against the current `bun_jsc` surface, and every fn
 // it defined is superseded by this generic `impl` + `decl_js_sink_externs!` /
-// `impl_js_sink_abi!`. `write_utf8` is intentionally NOT re-added: it is
-// unexported in Zig, has no lut entry, and no C++ caller.
+// `impl_js_sink_abi!`. `write_utf8` is intentionally NOT re-added: it has
+// no lut entry and no C++ caller.
 // ──────────────────────────────────────────────────────────────────────────
 
 impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
@@ -854,7 +842,6 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
             return Err(global.throw_illegal_constructor(T::NAME));
         }
 
-        // Zig: `bun.new(SinkType, undefined)` then `this.construct(allocator)`.
         let mut this: Box<core::mem::MaybeUninit<T>> = Box::new(core::mem::MaybeUninit::uninit());
         T::construct(&mut *this);
         // SAFETY: JsSinkType::construct fully initializes `*this` (contract).
@@ -863,7 +850,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         Ok(value)
     }
 
-    /// `${abi_name}__write` host-fn body. Port of `Sink.zig::JSSink.write`.
+    /// `${abi_name}__write` host-fn body.
     pub fn js_write(
         global: &crate::webcore::jsc::JSGlobalObject,
         frame: &crate::webcore::jsc::CallFrame,
@@ -942,7 +929,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
             .to_js(global))
     }
 
-    /// `${abi_name}__flush` host-fn body. Port of `Sink.zig::JSSink.flush`.
+    /// `${abi_name}__flush` host-fn body.
     pub fn js_flush(
         global: &crate::webcore::jsc::JSGlobalObject,
         frame: &crate::webcore::jsc::CallFrame,
@@ -957,9 +944,6 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
             return Err(global.throw_value(err));
         }
 
-        // PORT NOTE: Zig's `defer { if (done) unprotect() }` — `unprotect` is a
-        // no-op in the current port, so the guard is folded out.
-
         if T::HAS_FLUSH_FROM_JS {
             let wait = frame.arguments_count() > 0
                 && frame.argument(0).is_boolean()
@@ -976,7 +960,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         }
     }
 
-    /// `${abi_name}__start` host-fn body. Port of `Sink.zig::JSSink.start`.
+    /// `${abi_name}__start` host-fn body.
     pub fn js_start(
         global: &crate::webcore::jsc::JSGlobalObject,
         frame: &crate::webcore::jsc::CallFrame,
@@ -992,7 +976,6 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
             return Err(global.throw_value(err));
         }
 
-        // Zig: `if (@hasField(streams.Start, abi_name)) Start.fromJSWithTag(...) else Start.fromJS(...)`
         let config = if frame.arguments_count() > 0 {
             match T::START_TAG {
                 Some(tag) => {
@@ -1010,7 +993,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         }
     }
 
-    /// `${abi_name}__end` host-fn body. Port of `Sink.zig::JSSink.end`.
+    /// `${abi_name}__end` host-fn body.
     pub fn js_end(
         global: &crate::webcore::jsc::JSGlobalObject,
         frame: &crate::webcore::jsc::CallFrame,
@@ -1036,9 +1019,9 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         // sweeps.
         //
         // 13f9cff9 added an eager `detach_ptr_extern + finalize()` in the
-        // non-pending else-branch as a #53265 defense. That diverges from Zig
-        // (`JSSink.end` host-fn never detaches; only `${name}__doClose` does)
-        // and breaks Node `.end()` idempotency: child_process stdin teardown
+        // non-pending else-branch as a #53265 defense. But the `end` host-fn
+        // must not detach (only `${name}__doClose` does), and the eager detach
+        // breaks Node `.end()` idempotency: child_process stdin teardown
         // calls `.end()` → eager-detach → subsequent `.ref()`/`.unref()`/
         // `.end()` from the Writable destroy path hit `get_this` → DETACHED →
         // "already been closed" (8+ [new] in #53781). Reverted; the #53265
@@ -1052,13 +1035,13 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         result
     }
 
-    /// `${abi_name}__finalize` body. Port of `Sink.zig::JSSink.finalize`.
+    /// `${abi_name}__finalize` body.
     #[inline]
     pub fn js_finalize(this: &mut T) {
         this.finalize();
     }
 
-    /// `${abi_name}__close` body. Port of `Sink.zig::JSSink.close` — called from
+    /// `${abi_name}__close` body — called from
     /// `${controller}__close` and `${name}__doClose` in JSSink.cpp with a raw
     /// `m_sinkPtr` (not a host-fn callframe), so exceptions become `.zero`.
     pub fn js_close(
@@ -1090,7 +1073,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         }
     }
 
-    /// `${abi_name}__endWithSink` body. Port of `Sink.zig::JSSink.endWithSink` —
+    /// `${abi_name}__endWithSink` body —
     /// called from `JSReadable${name}Controller__end` with a raw `m_sinkPtr`.
     pub fn js_end_with_sink(
         this: &mut T,
@@ -1118,7 +1101,7 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
         }
     }
 
-    /// `${abi_name}__updateRef` body. Port of `Sink.zig::JSSink.updateRef`.
+    /// `${abi_name}__updateRef` body.
     #[inline]
     pub fn js_update_ref(this: &mut T, value: bool) {
         bun_core::mark_binding!();
@@ -1149,11 +1132,11 @@ impl<T: JsSinkType + JsSinkAbi> JSSink<T> {
 // ──────────────────────────────────────────────────────────────────────────
 
 bun_opaque::opaque_ffi! {
-    /// Zig: `const Detached = opaque {};` used only as a TaggedPointerUnion type-tag.
+    /// Used only as a `TaggedPointerUnion` type-tag.
     pub struct Detached;
 }
 
-// PORT NOTE: `bun_ptr::impl_tagged_ptr_union!` would impl the foreign
+// `bun_ptr::impl_tagged_ptr_union!` would impl the foreign
 // `TypeList` trait for a tuple type, hitting orphan rules from this crate.
 // Hand-roll a local marker struct + impls instead (matches the
 // `AnyServerTypes` pattern in server_body.rs). The second variant
@@ -1201,19 +1184,18 @@ pub extern "C" fn Bun__onSinkDestroyed(ptr_value: *mut c_void, sink_ptr: *mut c_
         return;
     }
 
-    // TODO(port): TaggedPtrUnion tag matching — Zig uses `@typeName(Detached)` /
-    // `@typeName(Subprocess)` as tag values via `@field(DestructorPtr.Tag, ...)`.
-    // bun_collections::TaggedPtrUnion should expose typed `as::<T>() -> Option<&mut T>`.
+    // `is::<Detached>()` covers the typed member and the Subprocess arm is
+    // matched by `is_valid()` below.
     if ptr.is::<Detached>() {
         return;
     }
     if ptr.is_valid() {
-        // TODO(port): `Subprocess<'_>` cannot implement `UnionMember` (lifetime
-        // param), so it isn't part of `DestructorPtr`'s type list yet — cast the raw
-        // pointer directly until the second variant is restored.
+        // `Subprocess<'_>` cannot implement `UnionMember` (lifetime param), so
+        // it isn't part of `DestructorPtr`'s type list — cast the raw pointer
+        // directly (see `destructor_ptr_subprocess`, which encodes it).
         //
-        // Spec Sink.zig:641 `ptr.as(Subprocess)` → `TaggedPointer.get`, which
-        // masks to the low 49 address bits. `DestructorPtr::ptr()` is
+        // The decoded pointer must be
+        // masked to the low 49 address bits. `DestructorPtr::ptr()` is
         // `TaggedPtr::to()` and *preserves* the tag bits (round-trip encoding),
         // so casting that would hand `on_stdin_destroyed` a pointer with
         // `0x07fe…` in the high word and ASAN SEGVs on the first field load.
@@ -1228,5 +1210,3 @@ pub extern "C" fn Bun__onSinkDestroyed(ptr_value: *mut c_void, sink_ptr: *mut c_
     }
     bun_core::debug_warn!("Unknown sink type");
 }
-
-// ported from: src/runtime/webcore/Sink.zig
diff --git a/src/runtime/webcore/TextDecoder.rs b/src/runtime/webcore/TextDecoder.rs
index ff2bed95b83..aa9e7039f8e 100644
--- a/src/runtime/webcore/TextDecoder.rs
+++ b/src/runtime/webcore/TextDecoder.rs
@@ -18,7 +18,7 @@ const UNICODE_REPLACEMENT_U16: u16 = strings::UNICODE_REPLACEMENT as u16;
 #[derive(Default, Clone, Copy)]
 pub struct Buffered {
     pub buf: [u8; 3],
-    pub len: u8, // Zig: u2
+    pub len: u8,
 }
 
 impl Buffered {
@@ -98,10 +98,6 @@ impl TextDecoder {
         ZigString::init(EncodingLabel::get_label(self.encoding)).to_js(global_this)
     }
 
-    // const Vector16 = std.meta.Vector(16, u16);
-    // const max_16_ascii: Vector16 = @splat(@as(u16, 127));
-    // PORT NOTE: SIMD vector constants are unused in this file's hot paths in current Zig.
-
     #[inline(always)]
     fn process_code_unit_utf16(
         &self,
@@ -226,8 +222,8 @@ impl TextDecoder {
             false
         };
 
-        // PORT NOTE: hoisted out of the labeled block — `ArrayBuffer::slice` borrows
-        // from the by-value `ArrayBuffer`, so it must outlive the `'input_slice` block.
+        // Hoisted out of the labeled block — `ArrayBuffer::slice` borrows from
+        // the by-value `ArrayBuffer`, so it must outlive the `'input_slice` block.
         let array_buffer;
         let input_slice: &[u8] = 'input_slice: {
             if arguments.is_empty() || arguments[0].is_undefined() {
@@ -244,7 +240,7 @@ impl TextDecoder {
             )));
         };
 
-        // switch (!stream) { inline else => |flush| ... } — runtime bool → comptime dispatch
+        // Dispatch the runtime `stream` bool to a const-generic flush parameter.
         if !stream {
             self.decode_slice::<true>(global_this, input_slice)
         } else {
@@ -282,7 +278,7 @@ impl TextDecoder {
                 let mut bytes = vec![0u16; out_length].into_boxed_slice();
 
                 let out = strings::copy_cp1252_into_utf16(&mut bytes, buffer_slice);
-                // PERF(port): heap::alloc transfers a tight allocation (no excess capacity).
+                // The boxed slice is a tight allocation (no excess capacity).
                 // SAFETY: `bytes` was allocated by the global allocator; `into_raw`
                 // transfers ownership of the buffer to JSC's external-string finalizer.
                 Ok(unsafe {
@@ -294,7 +290,6 @@ impl TextDecoder {
                 })
             }
             EncodingLabel::Utf8 => {
-                // PORT NOTE: reshaped for borrowck — Zig used a labeled tuple-destructuring block.
                 let maybe_without_bom =
                     if !self.ignore_bom && buffer_slice.starts_with(b"\xef\xbb\xbf") {
                         &buffer_slice[3..]
@@ -323,7 +318,7 @@ impl TextDecoder {
                     deinit = false;
                 }
 
-                // switch (this.fatal) { inline else => |fail_if_invalid| ... }
+                // Dispatch the runtime `fatal` bool to a const-generic parameter.
                 let maybe_decode_result = if self.fatal {
                     strings::to_utf16_alloc_maybe_buffered::<true, FLUSH>(input)
                 } else {
@@ -373,7 +368,7 @@ impl TextDecoder {
                         drop(decoded);
                         return Ok(ZigString::EMPTY.to_js(global_this));
                     }
-                    // PERF(port): Vec::leak may retain excess capacity vs Zig's items.ptr — profile if it shows up on a hot path.
+                    // PERF: Vec::leak may retain excess capacity — profile if it shows up on a hot path.
                     let ptr = decoded.leak().as_mut_ptr();
                     // SAFETY: `ptr` was leaked from a global-allocator `Vec<u16>`;
                     // ownership transfers to JSC's external-string finalizer.
@@ -411,8 +406,8 @@ impl TextDecoder {
                     return Err(global_this
                         .err(
                             jsc::ErrorCode::ERR_ENCODING_INVALID_ENCODED_DATA,
-                            // Zig: `@tagName(utf16_encoding)` → "UTF-16LE" / "UTF-16BE"
-                            // (NOT `get_label()`, which is lowercase "utf-16le"/"utf-16be").
+                            // "UTF-16LE" / "UTF-16BE" (NOT `get_label()`,
+                            // which is lowercase "utf-16le"/"utf-16be").
                             format_args!(
                                 "The encoded data was not valid {} data",
                                 if big_endian { "UTF-16BE" } else { "UTF-16LE" }
@@ -429,7 +424,7 @@ impl TextDecoder {
                 // Transfer ownership of the backing allocation to JSC; freed via
                 // free_global_string -> mi_free when the string is collected.
                 let len = decoded.len();
-                // PERF(port): Vec::leak may retain excess capacity vs Zig's items.ptr — profile if it shows up on a hot path.
+                // PERF: Vec::leak may retain excess capacity — profile if it shows up on a hot path.
                 let ptr = decoded.leak().as_mut_ptr();
                 // SAFETY: `ptr` was leaked from a global-allocator `Vec<u16>`;
                 // ownership transfers to JSC's external-string finalizer.
@@ -469,7 +464,7 @@ impl TextDecoder {
                 let result = codec.decode(buffer_slice, FLUSH, self.fatal);
                 // `bun_core::String` is `#[derive(Copy)]` with NO `Drop` impl, and
                 // `DecodeResult` has none either — wrap the +1 ref in `OwnedString`
-                // so it derefs on scope exit (matches Zig `defer result.result.deref()`).
+                // so it derefs on scope exit.
                 let result_str = OwnedString::new(result.result);
 
                 // A flushing decode ends the stream. Per WHATWG Encoding the
@@ -565,5 +560,3 @@ impl TextDecoder {
         Ok(bun_core::heap::into_raw(TextDecoder::new(decoder)))
     }
 }
-
-// ported from: src/runtime/webcore/TextDecoder.zig
diff --git a/src/runtime/webcore/TextEncoder.rs b/src/runtime/webcore/TextEncoder.rs
index 49c7670906b..0cd30dcf542 100644
--- a/src/runtime/webcore/TextEncoder.rs
+++ b/src/runtime/webcore/TextEncoder.rs
@@ -281,8 +281,7 @@ pub(crate) unsafe extern "C" fn TextEncoder__encodeInto16(
     // SAFETY: caller guarantees input_ptr[0..input_len] is valid UTF-16 data
     let input = unsafe { core::slice::from_raw_parts(input_ptr, input_len) };
     let result: strings::EncodeIntoResult = strings::copy_utf16_into_utf8(output, input);
-    // Zig `@bitCast([2]u32 → u64)`: field 0 (`read`) at byte offset 0, field 1 (`written`)
-    // at offset 4. Compose via native-endian bytes — identical bit pattern, no `unsafe`.
+    // Pack `read` at byte offset 0 and `written` at offset 4 via native-endian bytes — no `unsafe`.
     let mut b = [0u8; 8];
     b[..4].copy_from_slice(&result.read.to_ne_bytes());
     b[4..].copy_from_slice(&result.written.to_ne_bytes());
@@ -304,12 +303,9 @@ pub(crate) unsafe extern "C" fn TextEncoder__encodeInto8(
     // SAFETY: caller guarantees input_ptr[0..input_len] is valid Latin-1 data
     let input = unsafe { core::slice::from_raw_parts(input_ptr, input_len) };
     let result: strings::EncodeIntoResult = strings::copy_latin1_into_utf8(output, input);
-    // Zig `@bitCast([2]u32 → u64)`: field 0 (`read`) at byte offset 0, field 1 (`written`)
-    // at offset 4. Compose via native-endian bytes — identical bit pattern, no `unsafe`.
+    // Pack `read` at byte offset 0 and `written` at offset 4 via native-endian bytes — no `unsafe`.
     let mut b = [0u8; 8];
     b[..4].copy_from_slice(&result.read.to_ne_bytes());
     b[4..].copy_from_slice(&result.written.to_ne_bytes());
     u64::from_ne_bytes(b)
 }
-
-// ported from: src/runtime/webcore/TextEncoder.zig
diff --git a/src/runtime/webcore/TextEncoderStreamEncoder.rs b/src/runtime/webcore/TextEncoderStreamEncoder.rs
index d7eb9c00df6..2d80dc3c63c 100644
--- a/src/runtime/webcore/TextEncoderStreamEncoder.rs
+++ b/src/runtime/webcore/TextEncoderStreamEncoder.rs
@@ -16,7 +16,7 @@ pub struct TextEncoderStreamEncoder {
 }
 
 impl TextEncoderStreamEncoder {
-    // PORT NOTE: no `#[bun_jsc::host_fn]` here — that macro's free-fn arm emits
+    // No `#[bun_jsc::host_fn]` here — that macro's free-fn arm emits
     // a bare `constructor(...)` which cannot resolve inside an `impl`. The
     // `#[bun_jsc::JsClass]` derive already emits the `<Self>::constructor` shim.
     pub(crate) fn constructor(
@@ -73,10 +73,8 @@ impl TextEncoderStreamEncoder {
         // 278.00 ms   13.0%    278.00 ms           simdutf::arm64::implementation::utf8_length_from_latin1(char const*, unsigned long) const
         //
         //
-        // TODO(port): Zig threw a JS OOM exception on alloc failure; Rust Vec aborts on OOM.
         let mut buffer: Vec<u8> = Vec::with_capacity(input.len() + prepend_replacement_len);
         if prepend_replacement_len > 0 {
-            // PERF(port): was appendSliceAssumeCapacity
             buffer.extend_from_slice(&[0xef, 0xbf, 0xbd]);
         }
 
@@ -93,16 +91,14 @@ impl TextEncoderStreamEncoder {
             remain = &remain[result.read as usize..];
 
             if result.written == 0 && result.read == 0 {
-                // TODO(port): Zig threw a JS OOM exception on alloc failure; Rust Vec aborts on OOM.
                 buffer.reserve(2);
             } else if buffer.len() == buffer.capacity() && !remain.is_empty() {
-                // TODO(port): Zig threw a JS OOM exception on alloc failure; Rust Vec aborts on OOM.
                 buffer.ensure_total_capacity(buffer.len() + remain.len() + 1);
             }
         }
 
         if cfg!(debug_assertions) {
-            // wrap in comptime if so simdutf isn't called in a release build here.
+            // guarded so simdutf isn't called in a release build here.
             debug_assert!(
                 buffer.len()
                     == (simdutf::length::utf8::from::latin1(input) + prepend_replacement_len)
@@ -174,7 +170,6 @@ impl TextEncoderStreamEncoder {
 
         let length = simdutf::length::utf8::from::utf16::le(remain);
 
-        // TODO(port): Zig threw a JS OOM exception on alloc failure; Rust Vec aborts on OOM.
         let mut buf: Vec<u8> = Vec::with_capacity(
             length
                 + match prepend {
@@ -184,7 +179,6 @@ impl TextEncoderStreamEncoder {
         );
 
         if let Some(pre) = &prepend {
-            // PERF(port): was appendSliceAssumeCapacity
             buf.extend_from_slice(&pre.bytes[0..pre.len as usize]);
         }
 
@@ -238,5 +232,3 @@ impl TextEncoderStreamEncoder {
         }
     }
 }
-
-// ported from: src/runtime/webcore/TextEncoderStreamEncoder.zig
diff --git a/src/runtime/webcore/blob/Store.rs b/src/runtime/webcore/blob/Store.rs
index 9671cb306d8..1594dd78e82 100644
--- a/src/runtime/webcore/blob/Store.rs
+++ b/src/runtime/webcore/blob/Store.rs
@@ -35,8 +35,6 @@ pub use bun_jsc::webcore_types::store::{
     Bytes, Data, DataTag, File, S3, SerializeTag, Store, StoreRef,
 };
 
-// TODO(port): IdentityContext(u64) hasher — bun_collections::HashMap needs an
-// identity-hasher variant; load factor 80 is the std default in Zig.
 pub type Map = HashMap<u64, *mut Store>;
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -119,7 +117,7 @@ pub trait BytesExt {
 
 /// Shared mime-sniffing fallback for the `init_*` constructors below: derive a
 /// `MimeType` from the path's extension, returning `None` for empty paths or
-/// unknown extensions (Zig's `brk:` block in `initS3*`/`initFile`).
+/// unknown extensions.
 #[inline]
 fn mime_from_path_ext(sliced: &[u8]) -> Option<MimeType> {
     if sliced.is_empty() {
@@ -208,7 +206,6 @@ impl StoreExt for Store {
 
     /// Adopt an mmap'd region — no copy. The store's `Bytes` payload owns the
     /// mapping; when the refcount drops to zero, `Bytes::drop` calls `munmap`.
-    /// Mirrors Zig `Store.init(ptr[0..len], .{ .vtable = MmapFreeInterface.vtable })`.
     #[cfg(unix)]
     fn init_mmap(slice: &'static mut [u8]) -> StoreRef {
         StoreRef::from(Store::new(Store {
@@ -219,12 +216,7 @@ impl StoreExt for Store {
         }))
     }
 
-    // PORT NOTE: Zig `deinit` body became `impl Drop for Store` below. The manual
-    // `allocator.free(file.pathlike.path.slice())` / `s3.deinit(allocator)` paths are
-    // now handled by the owned types' own `Drop` impls.
-
     fn serialize(&self, writer: &mut impl bun_io::Write) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         match &self.data {
             Data::File(file) => {
                 let pathlike_tag: PathOrFileDescriptorSerializeTag =
@@ -237,8 +229,7 @@ impl StoreExt for Store {
 
                 match &file.pathlike {
                     PathOrFileDescriptor::Fd(fd) => {
-                        // PORT NOTE: Zig `writer.writeStruct(fd)` writes the raw
-                        // bytes of the FD wrapper. `bun_sys::Fd` is
+                        // Write the raw bytes of the FD wrapper. `bun_sys::Fd` is
                         // `#[repr(transparent)]` over an integer (`i32` posix /
                         // `u64` windows), so its native-endian byte image is
                         // exactly the inner field's `to_ne_bytes()`.
@@ -280,17 +271,13 @@ impl FileExt for File {
     fn unlink(&self, global_this: &JSGlobalObject) -> JsResult<JSValue> {
         match &self.pathlike {
             PathOrFileDescriptor::Path(path_like) => {
-                // PORT NOTE: Zig `slice.toOwned()` / `toSliceClone()` are
-                // fallible only on OOM; the Rust ports return the slice
-                // directly (mimalloc aborts on OOM), so no `?`.
                 let encoded_slice = match path_like {
                     PathLike::EncodedSlice(slice) => {
                         bun_core::ZigStringSlice::Owned(slice.slice().to_vec())
                     }
                     _ => ZigString::from_utf8(path_like.slice()).to_slice_clone(),
                 };
-                // Zig passes `undefined` for the `*Binding` arg (it is unused in
-                // `AsyncFSTask::create`).
+                // The `*Binding` arg is unused in `AsyncFSTask::create`.
                 let binding = node_fs::Binding::default();
                 // SAFETY: `bun_vm()` returns the live per-global VM pointer; the
                 // task is created on the JS thread that owns it.
@@ -322,12 +309,10 @@ impl S3Ext for S3 {
         options: Option<JSValue>,
         global_object: &JSGlobalObject,
     ) -> JsResult<S3CredentialsWithOptions> {
-        // Zig: `S3Credentials.getCredentialsWithOptions(this.getCredentials().*, this.options,
-        // options, this.acl, this.storage_class, this.request_payer, globalObject)`.
-        // The Rust associated fn (surfaced via `S3CredentialsExt` in `webcore/S3Client.rs`)
+        // The associated fn (surfaced via `S3CredentialsExt` in `webcore/S3Client.rs`)
         // takes `&S3Credentials` instead of by-value because `S3Credentials` carries a
         // private intrusive ref-count and cannot be struct-copied; the impl deep-copies
-        // internally, matching the Zig `.*` value-copy semantics.
+        // internally.
         use crate::webcore::s3_client::S3CredentialsExt as _;
         S3Credentials::get_credentials_with_options(
             self.get_credentials(),
@@ -387,7 +372,7 @@ impl S3Ext for S3 {
             }
         }
 
-        // PORT NOTE: Wrapper.deinit body deleted — store.deref() handled by StoreRef::drop,
+        // Wrapper.deinit body deleted — store.deref() handled by StoreRef::drop,
         // promise.deinit() handled by JSPromiseStrong::drop, bun.destroy(wrap) handled by
         // heap::take + drop in resolve().
 
@@ -412,7 +397,7 @@ impl S3Ext for S3 {
             bun_core::heap::into_raw(Wrapper::new(Wrapper {
                 promise,
                 // SAFETY: `store` is a live heap `Store`; `retained` bumps the
-                // intrusive refcount (Zig: `store.ref()`).
+                // intrusive refcount.
                 store: unsafe { StoreRef::retained(NonNull::from(store)) },
                 global: bun_ptr::BackRef::new(global_this),
             }))
@@ -461,7 +446,6 @@ impl S3Ext for S3 {
                         let list_result_js = match list_result.to_js(global_object) {
                             Ok(v) => v,
                             Err(e) => {
-                                // Zig: `catch return self.promise.reject(global, error.JSError)`
                                 return self_.promise.reject(global_object, Err(e));
                             }
                         };
@@ -483,7 +467,7 @@ impl S3Ext for S3 {
             }
         }
 
-        // PORT NOTE: Wrapper.deinit/destroy bodies deleted — store.deref() via StoreRef::drop,
+        // Wrapper.deinit/destroy bodies deleted — store.deref() via StoreRef::drop,
         // promise.deinit() via JSPromiseStrong::drop, resolvedlistOptions.deinit() via
         // S3ListObjectsOptions::drop, bun.destroy(self) via heap::take + drop.
 
@@ -503,17 +487,15 @@ impl S3Ext for S3 {
 
         let options = s3_client::get_list_objects_options_from_js(global_this, list_options)?;
 
-        // PORT NOTE: Zig passed `options` by-value to both `bun.S3.listObjects`
-        // and `Wrapper.resolvedlistOptions` (implicit struct copy).
-        // `S3ListObjectsOptions` is not `Clone` in Rust (owns `Utf8Slice`s);
+        // `S3ListObjectsOptions` is not `Clone` (it owns `Utf8Slice`s);
         // box the wrapper first so the options live on the heap, then hand a
         // borrow to `list_objects` (which only reads them synchronously to
         // build the search-params string). The wrapper retains ownership for
-        // `Drop` after the async callback — matching Zig's `deinit()`.
+        // `Drop` after the async callback.
         let wrapper = bun_core::heap::into_raw(Box::new(Wrapper {
             promise,
             // SAFETY: `store` is a live heap `Store`; `retained` bumps the
-            // intrusive refcount (Zig: `store.ref()`).
+            // intrusive refcount.
             store: unsafe { StoreRef::retained(NonNull::from(store)) },
             resolved_list_options: options,
             global: bun_ptr::BackRef::new(global_this),
@@ -535,7 +517,6 @@ impl S3Ext for S3 {
 
 impl BytesExt for Bytes {
     /// Adopt an mmap'd region. `Drop` (`allocator.free`) will `munmap` it.
-    /// Mirrors Zig `Store.init(ptr[0..len], .{ .vtable = MmapFreeInterface.vtable })`.
     #[cfg(unix)]
     fn init_mmap(slice: &'static mut [u8]) -> Bytes {
         // Stateless allocator vtable whose `free` munmap's. Same pattern as
@@ -566,14 +547,12 @@ impl BytesExt for Bytes {
     }
 
     fn from_array_list(list: Vec<u8>) -> Result<Bytes, bun_core::Error> {
-        // TODO(port): Zig signature returns `!*Bytes` but body returns `Bytes` by value —
-        // mirroring the by-value return here.
+        // `Bytes` is returned by value — the caller decides where it lives.
         Ok(Bytes::init(list))
     }
 
     fn to_internal_blob(&mut self) -> super::Internal {
-        // Zig built an `array_list.Managed(u8)` over the same allocator and
-        // zeroed self. `Internal.bytes` is `Vec<u8>` (global allocator), so
+        // `Internal.bytes` is `Vec<u8>` (global allocator), so
         // round-trip only when the storage *is* the global allocator; otherwise
         // copy + free through the original allocator (e.g. memfd → munmap).
         let bytes = if self.ptr.is_none() {
@@ -608,7 +587,7 @@ impl BytesExt for Bytes {
     }
 }
 
-/// `array_buffer.zig:BlobArrayBuffer_deallocator` — JSC `ArrayBuffer` external
+/// JSC `ArrayBuffer` external
 /// deallocator callback for buffers backed by a `Blob.Store`. C++ stashes a
 /// `*mut Store` as the deallocator context; this releases that ref.
 #[unsafe(no_mangle)]
diff --git a/src/runtime/webcore/blob/copy_file.rs b/src/runtime/webcore/blob/copy_file.rs
index a3e2a1ba1d3..831c84a0bee 100644
--- a/src/runtime/webcore/blob/copy_file.rs
+++ b/src/runtime/webcore/blob/copy_file.rs
@@ -22,9 +22,8 @@ use core::ffi::c_int;
 use core::ffi::c_void;
 use core::marker::ConstParamTy;
 
-// Local conversion: `bun_sys::SystemError` -> `bun_jsc::SystemError`. Both mirror
-// the same Zig `jsc.SystemError` extern struct; map field-by-field because the
-// two Rust definitions order their fields differently.
+// Local conversion: `bun_sys::SystemError` -> `bun_jsc::SystemError`. Mapped
+// field-by-field because the two definitions order their fields differently.
 fn to_jsc_system_error(e: &SystemError) -> jsc::SystemError {
     jsc::SystemError {
         errno: e.errno,
@@ -45,7 +44,9 @@ fn to_jsc_system_error(e: &SystemError) -> jsc::SystemError {
 pub struct CopyFile<'a> {
     pub destination_file_store: store::File,
     pub source_file_store: store::File,
-    // TODO(port): lifetime — heap-allocated across threads; Arc vs raw needs review
+    // `StoreRef` is the thread-safe refcounted handle;
+    // it keeps the stores — and the path slices the `File` clones borrow — alive
+    // while this task is on the work pool.
     pub store: Option<StoreRef>,
     pub source_store: Option<StoreRef>,
     pub offset: SizeType,
@@ -60,7 +61,7 @@ pub struct CopyFile<'a> {
     pub read_off: SizeType,
 
     // per LIFETIMES.tsv: JSC_BORROW → &JSGlobalObject
-    // TODO(port): lifetime — this struct is Box-allocated and crosses threads;
+    // TODO(refactor): lifetime — this struct is Box-allocated and crosses threads;
     // `'a` here is unsound in practice. Likely should be *const JSGlobalObject.
     pub global_this: &'a JSGlobalObject,
 
@@ -218,7 +219,6 @@ impl<'a> CopyFile<'a> {
     }
 
     pub fn do_open_file<const WHICH: IOWhich>(&mut self) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut path_buf1 = PathBuffer::uninit();
         // open source file first
         // if it fails, we don't want the extra destination file hanging out
@@ -252,7 +252,7 @@ impl<'a> CopyFile<'a> {
 
         if matches!(WHICH, IOWhich::Both | IOWhich::Destination) {
             loop {
-                // PORT NOTE: detach `dest` lifetime from `self` (borrowck) — slice_z
+                // detach `dest` lifetime from `self` (borrowck) — slice_z
                 // copies into path_buf1, so build the ZStr directly from the buffer.
                 let dest_len = {
                     let s = self.destination_file_store.pathlike.path().slice();
@@ -337,8 +337,6 @@ impl<'a> CopyFile<'a> {
             // outlives this guard (dropped before fn return); disjoint fields.
             unsafe { *read_len_slot = *total_written_slot as SizeType };
         }
-        // TODO(refactor): defer captures &mut to disjoint field via raw ptr;
-        // reshape to set read_len at each return site instead.
 
         let mut has_unset_append = false;
 
@@ -504,7 +502,7 @@ impl<'a> CopyFile<'a> {
 
                     self.system_error = Some(
                         bun_sys::Error {
-                            // PORT NOTE: @intCast is identity here (E repr == Error.Int); bare `as` matches Zig @intFromEnum.
+                            // bare `as` is lossless here (E repr == Error.Int).
                             errno: bun_sys::E::EINVAL as bun_sys::ErrorInt,
                             syscall: USE.tag(),
                             ..Default::default()
@@ -516,7 +514,7 @@ impl<'a> CopyFile<'a> {
                 errno => {
                     self.system_error = Some(
                         bun_sys::Error {
-                            // PORT NOTE: @intCast is identity here (E repr == Error.Int); bare `as` matches Zig @intFromEnum.
+                            // bare `as` is lossless here (E repr == Error.Int).
                             errno: errno as bun_sys::ErrorInt,
                             syscall: USE.tag(),
                             ..Default::default()
@@ -591,7 +589,7 @@ impl<'a> CopyFile<'a> {
         let mut dest_buf = PathBuffer::uninit();
 
         loop {
-            // PORT NOTE: reshaped for borrowck — `slice_z(&'a self, &'a mut buf)`
+            // reshaped for borrowck — `slice_z(&'a self, &'a mut buf)`
             // ties the returned `&ZStr` to `self`, which would conflict with
             // the `&mut self` borrow `mkdir_if_not_exists` needs below. The
             // bytes live in `dest_buf`, so capture the length and re-borrow
@@ -781,7 +779,7 @@ impl<'a> CopyFile<'a> {
                 self.destination_file_store.pathlike,
                 PathOrFileDescriptor::Fd(_)
             ) {
-                // (empty in Zig)
+                // nothing to do for the Fd case
             }
 
             let stat: Stat = match stat_ {
@@ -944,22 +942,16 @@ impl<'a> CopyFile<'a> {
     }
 }
 
-impl Drop for CopyFile<'_> {
-    fn drop(&mut self) {
-        if let PathOrFileDescriptor::Path(p) = &self.source_file_store.pathlike {
-            if p.is_string() && self.system_error.is_none() {
-                // TODO(port): the Zig frees the path slice here. In Rust, ownership of
-                // `source_file_store.pathlike.path` should be encoded in the type so
-                // Drop handles it. Verify Store::File path ownership.
-            }
-        }
-        // self.store.?.deref() — Arc drop is automatic
-        // bun.destroy(this) — Box drop is automatic
-    }
-}
+// Ownership is encoded in the types, so cleanup is all field `Drop`:
+// `source_file_store.pathlike` is a `PathLike` clone that is independently
+// droppable — `PathLike::clone` dupes owned string buffers (freed by the
+// clone's own `CowSlice` drop), bumps refs for WTF-backed slices, and only
+// shares the backing for borrowed-string/Buffer variants (whose owner is kept
+// alive by the `source_store` `StoreRef`). Each clone's field `Drop` frees
+// exactly what it owns; the `StoreRef`s release just their Store refcounts on
+// drop. No explicit `Drop` impl is needed.
 
-// Port of `bun.sys.preallocate_supported` / `bun.sys.preallocate_length` (sys.zig).
-// Kept local until bun_sys exports them; values match crate::node::fs.
+// Kept local until bun_sys exports these; values match crate::node::fs.
 #[cfg(not(windows))]
 const PREALLOCATE_SUPPORTED: bool = cfg!(any(target_os = "linux", target_os = "android"));
 #[cfg(not(windows))]
@@ -1000,7 +992,7 @@ pub struct CopyFileWindows<'a> {
     pub mkdirp_if_not_exists: bool,
     pub destination_mode: Option<Mode>,
     // per LIFETIMES.tsv: JSC_BORROW → &jsc::EventLoop
-    // TODO(port): lifetime — heap-allocated and re-entered from libuv callbacks;
+    // TODO(refactor): lifetime — heap-allocated and re-entered from libuv callbacks;
     // likely should be *const jsc::EventLoop.
     pub event_loop: &'a jsc::event_loop::EventLoop,
 
@@ -1037,7 +1029,6 @@ impl Default for ReadWriteLoop {
             must_close_destination_fd: false,
             written: 0,
             read_buf: Vec::new(),
-            // Zig: `.{ .base = undefined, .len = 0 }`
             uv_buf: libuv::uv_buf_t {
                 len: 0,
                 base: core::ptr::null_mut(),
@@ -1046,9 +1037,8 @@ impl Default for ReadWriteLoop {
     }
 }
 
-// PORT NOTE: Zig defines `ReadWriteLoop.start/read` taking both `*ReadWriteLoop` and
-// `*CopyFileWindows`, but in Rust the former is a subobject of the latter, so passing
-// both as `&mut` is aliasing UB. These are hoisted onto `CopyFileWindows` so the
+// `ReadWriteLoop` is a subobject of `CopyFileWindows`, so passing both as
+// `&mut` would be aliasing UB. These are hoisted onto `CopyFileWindows` so the
 // borrow checker can see `self.read_write_loop` / `self.io_request` / `self.event_loop`
 // as disjoint field accesses through a single `&mut self`.
 #[cfg(windows)]
@@ -1061,7 +1051,7 @@ impl<'a> CopyFileWindows<'a> {
 
     fn read_write_loop_read(&mut self) -> bun_sys::Result<()> {
         self.read_write_loop.read_buf.clear();
-        // PORT NOTE: reshaped for borrowck — Zig's `allocatedSlice()` is the full capacity slice.
+        // reshaped for borrowck — use the full capacity slice.
         let cap = self.read_write_loop.read_buf.capacity();
         self.read_write_loop.uv_buf = libuv::uv_buf_t {
             len: cap as libuv::ULONG,
@@ -1146,7 +1136,7 @@ extern "C" fn on_read(req: *mut libuv::fs_t) {
 
     let source_fd = this.read_write_loop.source_fd;
     let destination_fd = this.read_write_loop.destination_fd;
-    // PORT NOTE: reshaped for borrowck — `read_buf.items` is `Vec` len-slice.
+    // reshaped for borrowck — `read_buf.items` is `Vec` len-slice.
     let read_buf = &mut this.read_write_loop.read_buf;
 
     let event_loop = this.event_loop;
@@ -1428,7 +1418,7 @@ impl<'a> CopyFileWindows<'a> {
 
         let mut pathbuf1 = PathBuffer::uninit();
         let mut pathbuf2 = PathBuffer::uninit();
-        // PORT NOTE: capture the raw `self` pointer before borrowing the file
+        // capture the raw `self` pointer before borrowing the file
         // stores. `slice_z` ties the returned `&ZStr` lifetime to `&self`, so
         // `new_path`/`old_path` keep `self.{destination,source}_file_store`
         // borrowed across the `uv_fs_copyfile` call below; taking
@@ -1568,14 +1558,14 @@ impl<'a> CopyFileWindows<'a> {
 
     pub fn throw(&mut self, err: bun_sys::Error) {
         let global_this = self.event_loop.global_ref();
-        // PORT NOTE: `swap()` returns a `&mut JSPromise` into a GC-owned cell (not into
+        // `swap()` returns a `&mut JSPromise` into a GC-owned cell (not into
         // `self`), but its lifetime is elided to `&mut self`. Decay to a raw pointer so
         // borrowck doesn't tie it to `self` across `destroy` below.
         let promise = JSPromise::opaque_mut(self.promise.swap());
         let err_instance = err.to_js_with_async_stack(global_this, promise);
 
         // SAFETY: VM-owned event loop is valid for the process lifetime; `enter_scope`
-        // calls enter() now and exit() on drop (RAII for Zig's `loop.enter(); defer loop.exit();`).
+        // calls enter() now and exit() on drop.
         let _guard = unsafe {
             jsc::event_loop::EventLoop::enter_scope(self.event_loop as *const _ as *mut _)
         };
@@ -1600,7 +1590,7 @@ impl<'a> CopyFileWindows<'a> {
             ) {
                 self.written_bytes = written;
                 let mut pathbuf = PathBuffer::uninit();
-                // PORT NOTE (borrowck): `slice_z` ties the returned `&ZStr` to
+                // Borrowck: `slice_z` ties the returned `&ZStr` to
                 // `&self.destination_file_store`, which would conflict with the
                 // `core::ptr::from_mut(self)` below. Capture the raw C pointer now —
                 // it points either into the stack-local `pathbuf` or into the
@@ -1634,7 +1624,7 @@ impl<'a> CopyFileWindows<'a> {
                 };
 
                 // chmod failed to start - reject the promise to report the error.
-                // PORT NOTE: previously `transmute::<c_int, SystemErrno>(errno)` — wrong on
+                // previously `transmute::<c_int, SystemErrno>(errno)` — wrong on
                 // two counts: `errno` is `u16` (size mismatch with `c_int`), and libuv
                 // negative codes are NOT `SystemErrno` discriminants on Windows. Route
                 // through `Error::from_uv_rc` so `from_libuv` is set and translation is
@@ -1657,11 +1647,11 @@ impl<'a> CopyFileWindows<'a> {
 
     fn resolve_promise(&mut self, written: usize) {
         let global_this = self.event_loop.global_ref();
-        // PORT NOTE: see `throw` — re-type the GC cell via the ZST opaque deref so it
+        // see `throw` — re-type the GC cell via the ZST opaque deref so it
         // outlives `destroy(self)` for borrowck.
         let promise = JSPromise::opaque_mut(self.promise.swap());
         // SAFETY: VM-owned event loop is valid for the process lifetime; `enter_scope`
-        // calls enter() now and exit() on drop (RAII for Zig's `loop.enter(); defer loop.exit();`).
+        // calls enter() now and exit() on drop.
         let _guard = unsafe {
             jsc::event_loop::EventLoop::enter_scope(self.event_loop as *const _ as *mut _)
         };
@@ -1703,7 +1693,7 @@ impl<'a> CopyFileWindows<'a> {
     fn mkdirp(&mut self) {
         bun_sys::syslog!("mkdirp");
         self.mkdirp_if_not_exists = false;
-        // PORT NOTE (borrowck): compute the raw path slice pointer up-front so the
+        // Borrowck: compute the raw path slice pointer up-front so the
         // immutable borrow of `self.destination_file_store` ends before we take
         // `core::ptr::from_mut(self)` for `completion_ctx` below.
         let path: *const [u8] = {
@@ -1739,9 +1729,8 @@ impl<'a> CopyFileWindows<'a> {
         self.event_loop.unref_concurrently();
 
         if let Some(err) = self.err.take() {
-            // PORT NOTE: Zig `var err2 = err; err2.deinit();` freed the borrowed path; in
-            // Rust `bun_sys::Error.path` is an owned `Box<[u8]>` and is dropped with `err`
-            // inside `throw`.
+            // `bun_sys::Error.path` is an owned `Box<[u8]>` and is dropped with
+            // `err` inside `throw`.
             self.throw(err);
             return;
         }
@@ -1833,7 +1822,7 @@ fn on_mkdirp_complete_concurrent(ctx: *mut (), err_: bun_sys::Maybe<()>) {
         bun_sys::Result::Err(e) => Some(e),
         bun_sys::Result::Ok(()) => None,
     };
-    // PORT NOTE: `bun_event_loop::JsResult` carries the low-tier `ErasedJsError`; shim the
+    // `bun_event_loop::JsResult` carries the low-tier `ErasedJsError`; shim the
     // callback signature to match `ManagedTask::new`'s `fn(*mut T) -> JsResult<()>`.
     fn call_erased(this: *mut CopyFileWindows<'_>) -> bun_event_loop::JsResult<()> {
         // SAFETY: `this` is the heap-allocated `CopyFileWindows` passed to
@@ -1878,13 +1867,9 @@ fn unsupported_non_regular_file_error() -> SystemError {
         ..SystemError::default()
     }
 }
-// TODO(port): Zig had these as `const` values; SystemError contains bun.String which
-// is not const-constructible in Rust. Using fns here. Consider lazy_static / OnceLock.
+// `SystemError` contains `bun_core::String`, which is not const-constructible,
+// so these are constructor fns instead of `const` values.
 
 pub type CopyFilePromiseTask<'a> =
     jsc::concurrent_promise_task::ConcurrentPromiseTask<'a, CopyFile<'a>>;
-// TODO(port): Zig `CopyFilePromiseTask.EventLoopTask` — exact Rust associated-type
-// path depends on bun_jsc::ConcurrentPromiseTask shape; using `jsc::EventLoopTask` for now.
 pub type CopyFilePromiseTaskEventLoopTask = jsc::EventLoopTask;
-
-// ported from: src/runtime/webcore/blob/copy_file.zig
diff --git a/src/runtime/webcore/blob/read_file.rs b/src/runtime/webcore/blob/read_file.rs
index 3a848c5f879..a79cdc06134 100644
--- a/src/runtime/webcore/blob/read_file.rs
+++ b/src/runtime/webcore/blob/read_file.rs
@@ -47,11 +47,8 @@ macro_rules! log {
 // NewReadFileHandler
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig: `pub fn NewReadFileHandler(comptime Function: anytype) type`
-///
-/// `F` provides the comptime callback that converts the read bytes to a JSValue.
-/// Modelled as a trait so each instantiation monomorphizes like the Zig
-/// type-generator did.
+/// `F` provides the callback that converts the read bytes to a JSValue.
+/// Modelled as a trait so each instantiation monomorphizes.
 pub trait ReadFileToJs {
     /// `by` carries the caller's allocation provenance unchanged:
     /// `Lifetime::Temporary` ⇒ a `Box::<[u8]>::into_raw` the callee MUST take
@@ -78,12 +75,10 @@ impl<'a, F: ReadFileToJs> NewReadFileHandler<'a, F> {
     }
 }
 
-/// Models Zig's `comptime callback: fn(ctx: Context, bytes: ReadFileResultType) bun.JSTerminated!void`
-/// (and `comptime Handler: type` for `ReadFileUV.start`). Monomorphized per
+/// Completion callback for a file read. Monomorphized per
 /// call-site type so the erased shim calls `C::run` directly and
-/// `on_complete_ctx` carries the **raw** `*mut C` — no heap wrapper, matching
-/// the Zig spec where any code introspecting `onCompleteCtx` sees the original
-/// context pointer.
+/// `on_complete_ctx` carries the **raw** `*mut C` — no heap wrapper, so any
+/// code introspecting `on_complete_ctx` sees the original context pointer.
 pub trait ReadFileCompletion {
     /// # Safety
     /// `ctx` must be a heap-allocated `Self` whose ownership is transferred to
@@ -98,7 +93,7 @@ impl<'a, F: ReadFileToJs> ReadFileCompletion for NewReadFileHandler<'a, F> {
     ) -> jsc::JsTerminatedResult<()> {
         // SAFETY: handler was heap-allocated by doReadFile(); we take ownership here.
         let mut handler = unsafe { bun_core::heap::take(handler) };
-        // PORT NOTE: `Strong::swap()` ties the returned `&mut JSPromise` to
+        // `Strong::swap()` ties the returned `&mut JSPromise` to
         // `&mut self`, but the promise is GC-heap-owned and outlives `handler`.
         // Decay to a raw pointer so `handler` can be dropped before resolution.
         let promise: *mut jsc::JSPromise = handler.promise.swap();
@@ -112,10 +107,8 @@ impl<'a, F: ReadFileToJs> ReadFileCompletion for NewReadFileHandler<'a, F> {
                     blob.size
                         .set((bytes.len() as SizeType).min(blob.size.get()));
                 }
-                // Zig defined a local `WrappedFn` struct to adapt the comptime
-                // `Function` into the `toJSHostCall` shape; Rust closures + the
-                // `#[track_caller]` `to_js_host_call` inside `AnyPromise::wrap`
-                // give the same source-location/exception-scope behaviour.
+                // The `#[track_caller]` `to_js_host_call` inside `AnyPromise::wrap`
+                // provides the source-location/exception-scope behaviour.
                 AnyPromise::Normal(promise).wrap(global_this, move |g| {
                     F::call(&blob, g, bytes, Lifetime::Temporary)
                 })?;
@@ -143,8 +136,8 @@ pub struct ReadFileRead {
     /// Always a `Box::<[u8]>::into_raw` from the producer's read buffer
     /// (`Vec::into_boxed_slice()` so layout is exactly `(ptr, len)`). Every
     /// consumer reclaims via `heap::take` — there is no borrow case left
-    /// (Zig's `is_temporary = false` arm is unreachable here; only the two
-    /// finishers below construct this type and both hand off owned bytes).
+    /// (only the two finishers below construct this type and both hand off
+    /// owned bytes).
     /// Stored as a raw pointer rather than `Box<[u8]>` because the
     /// `NewReadFileHandler` consumer forwards it straight into
     /// `to_*_with_bytes::<Temporary>(*mut [u8])`, which itself decides whether
@@ -153,8 +146,8 @@ pub struct ReadFileRead {
     pub total_size: SizeType,
 }
 
-/// Zig: `SystemError.Maybe(ReadFileRead)`
-// Mirrors the Zig union and is constructed/matched in Blob.rs and Body.rs;
+/// Result-or-error union for a completed read.
+// Constructed/matched in Blob.rs and Body.rs;
 // boxing the Err arm would change the cross-file callback ABI for no real win.
 #[allow(clippy::large_enum_variant)]
 pub enum ReadFileResultType {
@@ -212,8 +205,7 @@ pub struct ReadFile {
 
 bun_threading::intrusive_work_task!(ReadFile, task);
 
-// Zig: `pub const getFd = FileOpener(@This()).getFd;` / `doClose = FileCloser(@This()).doClose;`
-// — modeled as trait impls; the default methods on the traits provide the bodies.
+// The default methods on the FileOpener/FileCloser traits provide the bodies.
 impl FileOpener for ReadFile {
     fn opened_fd(&self) -> Fd {
         self.opened_fd
@@ -296,7 +288,7 @@ impl FileCloser for ReadFile {
             let this = unsafe { bun_ptr::callback_ctx::<ReadFile>(ctx.cast()) };
             <ReadFile as FileCloser>::on_io_request_closed(this);
         }
-        // PORT NOTE: reshaped for borrowck — compute the parent raw pointer
+        // reshaped for borrowck — compute the parent raw pointer
         // before mutably borrowing `io_poll` so the two borrows do not overlap.
         let ctx = std::ptr::from_mut::<ReadFile>(this).cast::<()>();
         let fd = this.opened_fd;
@@ -340,9 +332,7 @@ impl ReadFile {
         }
     }
 
-    // Zig: `if (Environment.isWindows) @compileError("…")` — Zig analyzes this
-    // lazily (only fires if a Windows caller reaches it). Rust's `compile_error!`
-    // is eager, so we gate the whole fn instead; Windows callers use ReadFileUV.
+    // Not for Windows; Windows callers use ReadFileUV.
     #[cfg(not(windows))]
     pub fn create_with_ctx(
         store: StoreRef,
@@ -351,7 +341,6 @@ impl ReadFile {
         off: SizeType,
         max_len: SizeType,
     ) -> Result<Box<ReadFile>, Error> {
-        // TODO(port): narrow error set
         // store.ref() — `StoreRef` carries the +1; held in `self.store`.
         let file_store = store.data.as_file().clone();
         let read_file = Box::new(ReadFile {
@@ -395,13 +384,13 @@ impl ReadFile {
         max_len: SizeType,
         context: *mut C,
     ) -> Result<Box<ReadFile>, Error> {
-        // Zig used a local `Handler` struct whose `run` calls the comptime
-        // `callback` and swallows the JSTerminated error. `ReadFileCompletion`
-        // monomorphizes per `C`, so `handler_run::<C>` is that local struct's
-        // `run` and `on_complete_ctx` is the unwrapped `*mut C` — exactly the
-        // Zig layout (no extra heap box, nothing to leak on the `Err` path).
+        // `ReadFileCompletion`
+        // monomorphizes per `C`, so `handler_run::<C>` calls `C::run` directly
+        // and `on_complete_ctx` is the unwrapped `*mut C` — no extra heap box,
+        // nothing to leak on the `Err` path.
         fn handler_run<C: ReadFileCompletion>(ctx: *mut c_void, bytes: ReadFileResultType) {
-            // TODO(port): properly propagate exception upwards (matches Zig TODO).
+            // The JsTerminated error is intentionally swallowed.
+            // TODO: propagate the exception.
             // SAFETY: `ctx` is the `*mut C` passed unmodified through
             // `on_complete_ctx`; ownership transfers per `ReadFileCompletion::run`.
             let _ = unsafe { C::run(ctx.cast::<C>(), bytes) };
@@ -483,7 +472,6 @@ impl ReadFile {
     pub fn wait_for_readable(&mut self) {
         bloblog!("ReadFile.waitForReadable");
         self.close_after_io = true;
-        // Zig: @atomicStore on the callback fn-pointer field.
         self.io_request
             .store_callback_seq_cst(Self::on_request_readable);
         if !self.io_request.scheduled {
@@ -496,7 +484,6 @@ impl ReadFile {
     /// `do_read_loop` can carry it across the `&mut self` `do_read` call
     /// without two live `&mut` covering overlapping memory (Stacked-Borrows
     /// UB). The slice is materialised only at the syscall boundary.
-    // PORT NOTE: Zig indexed raw ptr range `items.ptr[items.len..capacity]`.
     #[cfg(not(windows))]
     fn remaining_buffer(&mut self, stack_buffer: &mut [u8]) -> (*mut u8, usize) {
         // `spare_capacity_mut()` is the safe spelling of
@@ -608,7 +595,7 @@ impl ReadFile {
 
         let mut this = this;
         let _store = this.store.take().unwrap();
-        // PORT NOTE: reshaped for borrowck — take buffer out so it survives `drop(this)`.
+        // reshaped for borrowck — take buffer out so it survives `drop(this)`.
         let buf = core::mem::take(&mut this.buffer);
 
         // `_store` is dropped at end of scope (= store.deref()).
@@ -621,9 +608,8 @@ impl ReadFile {
             return Ok(());
         }
 
-        // Zig hands `buffer.items` as a raw slice with `is_temporary = true`;
-        // receiver takes ownership. Normalize to `Box<[u8]>` so every consumer
-        // can reclaim via `heap::take` with a matching layout.
+        // The receiver takes ownership. Normalize to `Box<[u8]>` so every
+        // consumer can reclaim via `heap::take` with a matching layout.
         cb(
             cb_ctx,
             ReadFileResultType::Result(ReadFileRead {
@@ -750,8 +736,7 @@ impl ReadFile {
         // so we should check specifically that its a regular file before trusting the size.
         if self.size == 0 && bun_sys::is_regular_file(self.file_store.mode) {
             self.buffer = Vec::new();
-            // PORT NOTE: Zig wrote `byte_store = ByteStore.init(buffer.items, …)`
-            // (a non-owning view); Rust `Bytes` owns its allocation, so leave it
+            // `Bytes` owns its allocation, so leave `byte_store`
             // default — `then()` reads `self.buffer` directly.
             self.byte_store = ByteStore::default();
 
@@ -816,13 +801,13 @@ impl ReadFile {
             //
             // 64 KB is large, but since this is running in a thread
             // with it's own stack, it should have sufficient space.
-            // PORT NOTE: hoisted out of the loop and zero-initialized once — the
+            // hoisted out of the loop and zero-initialized once — the
             // one-time 64 KB memset is negligible next to the per-iteration
             // syscall, and avoids the `MaybeUninit<u8>` → `&mut [u8]` cast (uninit
             // bytes behind a `&[u8]` is technically UB even when never read).
             let mut stack_buffer = [0u8; 64 * 1024];
             while self.state.load(Ordering::Relaxed) == ClosingState::Running as u8 {
-                // PORT NOTE: reshaped for borrowck — keep the read target as a raw
+                // reshaped for borrowck — keep the read target as a raw
                 // (ptr, len) across the `&mut self` `do_read` call; no `&mut [u8]`
                 // to `self.buffer`'s spare capacity is ever live alongside
                 // `&mut self`.
@@ -849,7 +834,6 @@ impl ReadFile {
                         } else {
                             self.buffer.reserve(read.len());
                         }
-                        // PERF(port): was appendSliceAssumeCapacity — profile if hot.
                         self.buffer.extend_from_slice(read);
                     } else {
                         // record the amount of data read
@@ -920,9 +904,8 @@ impl ReadFile {
             if self.buffer.len() + 16_000 < self.buffer.capacity() {
                 self.buffer.shrink_to_fit();
             }
-            // PORT NOTE: Zig also wrote `byte_store = ByteStore.init(buffer.items, …)` —
-            // a non-owning alias of `buffer`. Rust `Bytes` is owning, and `then()`
-            // delivers `self.buffer` directly, so skip the alias to avoid a double-free.
+            // `Bytes` is owning, and `then()` delivers `self.buffer` directly,
+            // so do not also stash it in `byte_store` — that would double-free.
             self.on_finish();
         }
     }
@@ -955,13 +938,10 @@ pub struct ReadFileUV<'a> {
     pub is_regular_file: bool,
 
     pub req: libuv::fs_t,
-    /// Stash for the open completion callback across the libuv async hop
-    /// (Zig captured it at comptime in `FileOpener.getFdByOpening`).
+    /// Stash for the open completion callback across the libuv async hop.
     open_callback: fn(&mut Self, Fd),
 }
 
-// Zig: `pub const getFd = FileOpener(@This()).getFd;` /
-//      `pub const doClose = FileCloser(@This()).doClose;`
 #[cfg(windows)]
 impl<'a> FileOpener for ReadFileUV<'a> {
     fn opened_fd(&self) -> Fd {
@@ -1006,12 +986,10 @@ impl<'a> FileCloser for ReadFileUV<'a> {
         self.loop_
     }
 
-    // Zig `FileCloser` gates the `close_after_io` / `io_request` / `io_poll` /
-    // `state` / `task` accesses on `@hasField(This, "io_request")`, which is
-    // **false** for `ReadFileUV` (its libuv request field is `req`, not
-    // `io_request`). So `do_close` falls straight to the close-fd branch and
-    // none of the methods below are ever reached — these mark genuinely dead
-    // code paths, not unported stubs.
+    // `ReadFileUV` has no `io_request` field (its libuv request field is
+    // `req`), so `do_close` falls straight to the close-fd branch and
+    // none of the methods below are ever reached — these are genuinely dead
+    // code paths.
     fn close_after_io(&self) -> bool {
         false
     }
@@ -1043,9 +1021,8 @@ impl<'a> FileCloser for ReadFileUV<'a> {
 
 #[cfg(windows)]
 impl<'a> ReadFileUV<'a> {
-    /// Typed entry — mirrors Zig `start(event_loop, store, off, max_len,
-    /// comptime Handler, handler: *anyopaque)`: caller passes the already-erased
-    /// `*anyopaque`; `H` (via turbofish) supplies `Handler.run` through the
+    /// Typed entry: caller passes the already-erased
+    /// context pointer; `H` (via turbofish) supplies the run thunk through the
     /// `ReadFileUvHandler` blanket impl.
     pub fn start<H>(
         event_loop: *mut EventLoop,
@@ -1061,14 +1038,14 @@ impl<'a> ReadFileUV<'a> {
             store,
             off,
             max_len,
-            // Zig: @ptrCast(&Handler.run) — erase the typed handler to the C ABI cb.
+            // Erase the typed handler to the C ABI cb.
             H::run as ReadFileOnReadFileCallback,
             handler,
         )
     }
 
     /// Raw entry — caller already has the type-erased `(fn, *anyopaque)` pair
-    /// (Zig `NewInternalReadFileHandler` path). Shares the body with `start`.
+    /// Shares the body with `start`.
     pub fn start_with_ctx(
         event_loop: *mut EventLoop,
         store: StoreRef,
@@ -1084,8 +1061,8 @@ impl<'a> ReadFileUV<'a> {
         let event_loop: &'a EventLoop = unsafe { &*event_loop };
         let file_store = store.data.as_file().clone();
         let this = Box::new(ReadFileUV {
-            // Zig: `event_loop.virtual_machine.uvLoop()` — projected through the
-            // helper to avoid materializing a `&VirtualMachine`.
+            // Projected through the helper to avoid materializing a
+            // `&VirtualMachine`.
             loop_: event_loop.uv_loop().cast(),
             event_loop,
             file_store,
@@ -1141,11 +1118,11 @@ impl<'a> ReadFileUV<'a> {
             })
         };
 
-        // Zig order: cb() runs BEFORE the defer block (store.deref / req.deinit /
-        // bun.destroy / event_loop.unref). Preserve that — cb may inspect store.
+        // cb() must run BEFORE the cleanup below (store deref / req.deinit /
+        // box drop / event_loop.unref) — cb may inspect store.
         cb(cb_ctx, result);
 
-        // Zig defer block — store.deref runs via StoreRef's Drop when the Box drops.
+        // store.deref runs via StoreRef's Drop when the Box drops.
         this_box.req.deinit();
         drop(this_box);
         // Release the event loop reference now that we're done
@@ -1282,7 +1259,7 @@ impl<'a> ReadFileUV<'a> {
         // Special files might report a size of > 0, and be wrong.
         // so we should check specifically that its a regular file before trusting the size.
         if this.size == 0 && this.is_regular_file {
-            // Zig: `ByteStore.init(this.buffer.items, ..)` — buffer is empty here,
+            // buffer is empty here,
             // so move it (Vec<u8>) into the owning ByteStore rather than borrow.
             this.byte_store = ByteStore::init(core::mem::take(&mut this.buffer));
             this.on_finish();
@@ -1400,7 +1377,6 @@ impl<'a> ReadFileUV<'a> {
 
             // We are done reading.
             let owned = core::mem::take(&mut self.buffer).into_boxed_slice();
-            // PORT NOTE: Vec::into_boxed_slice cannot fail; Zig caught OOM here.
             self.byte_store = ByteStore::init_owned(owned);
             self.on_finish();
         }
@@ -1428,7 +1404,6 @@ impl<'a> ReadFileUV<'a> {
         if result.int() == 0 {
             // We are done reading.
             let owned = core::mem::take(&mut this.buffer).into_boxed_slice();
-            // PORT NOTE: Vec::into_boxed_slice cannot fail; Zig caught OOM here.
             this.byte_store = ByteStore::init_owned(owned);
             this.on_finish();
             return;
@@ -1446,8 +1421,7 @@ impl<'a> ReadFileUV<'a> {
     }
 }
 
-/// Trait modeling the `comptime Handler: type` parameter of `ReadFileUV.start`.
-/// Zig `@ptrCast(&Handler.run)` erases the typed ctx to `*anyopaque`; here the
+/// Handler for `ReadFileUV.start`: the
 /// implementor supplies the already-erased thunk.
 pub trait ReadFileUvHandler {
     fn run(ctx: *mut c_void, bytes: ReadFileResultType);
@@ -1455,8 +1429,7 @@ pub trait ReadFileUvHandler {
 
 /// Any `ReadFileCompletion` is usable as a `ReadFileUV` handler — the libuv
 /// path stores the same `(ctx, run)` pair, just without the JSTerminated
-/// return (Zig swallowed it via `catch {}` in the POSIX path; the UV path's
-/// `Handler.run` is `void`-returning by contract).
+/// return (the UV path's run thunk is `void`-returning by contract).
 impl<C: ReadFileCompletion> ReadFileUvHandler for C {
     fn run(ctx: *mut c_void, bytes: ReadFileResultType) {
         // SAFETY: `ctx` is the `*mut C` passed unmodified through
@@ -1464,5 +1437,3 @@ impl<C: ReadFileCompletion> ReadFileUvHandler for C {
         let _ = unsafe { <C as ReadFileCompletion>::run(ctx.cast::<C>(), bytes) };
     }
 }
-
-// ported from: src/runtime/webcore/blob/read_file.zig
diff --git a/src/runtime/webcore/blob/write_file.rs b/src/runtime/webcore/blob/write_file.rs
index a381bb3ab9d..f49196680e5 100644
--- a/src/runtime/webcore/blob/write_file.rs
+++ b/src/runtime/webcore/blob/write_file.rs
@@ -21,8 +21,10 @@ use crate::webcore::body;
 
 bun_output::declare_scope!(WriteFile, hidden);
 
-// TODO(port): SystemError::Maybe(T) is a tagged { result: T } | { err: SystemError } union;
-// modeled here as a plain Rust enum. Verify layout if it crosses FFI.
+// A tagged result-or-error union. Modeled
+// as a plain Rust enum: it only ever travels through the Rust fn-pointer
+// callbacks below (`WriteFileOnWriteFileCallback`), never across FFI, so the
+// layout is unconstrained.
 pub enum WriteFileResultType {
     Result(SizeType),
     Err(Box<SystemError>),
@@ -61,7 +63,7 @@ pub struct WriteFile {
     pub io_task: Option<*mut WriteFileTask>,
     pub io_poll: io::Poll,
     pub io_request: io::Request,
-    pub state: AtomicU8, // std.atomic.Value(ClosingState)
+    pub state: AtomicU8, // ClosingState
 
     pub on_complete_ctx: *mut c_void,
     pub on_complete_callback: WriteFileOnWriteFileCallback,
@@ -76,8 +78,7 @@ bun_threading::intrusive_work_task!(WriteFile, task);
 bun_io::intrusive_io_request!(WriteFile, io_request);
 
 // ──────────────────────────────────────────────────────────────────────────
-// Zig: `pub const getFd = FileOpener(@This()).getFd;`
-//      `pub const doClose = FileCloser(WriteFile).doClose;`
+// FileOpener / FileCloser
 // ──────────────────────────────────────────────────────────────────────────
 
 impl FileOpener for WriteFile {
@@ -113,7 +114,6 @@ impl FileOpener for WriteFile {
         path: &bun_core::ZStr,
         display_path: &[u8],
     ) -> Retry {
-        // Zig: `if (@hasField(This, "mkdirp_if_not_exists")) switch (mkdirIfNotExists(...)) { ... }`
         mkdir_if_not_exists(self, &err, path, display_path)
     }
     #[cfg(windows)]
@@ -194,7 +194,7 @@ impl FileCloser for WriteFile {
             let this = unsafe { bun_ptr::callback_ctx::<WriteFile>(ctx.cast()) };
             <WriteFile as FileCloser>::on_io_request_closed(this);
         }
-        // PORT NOTE: reshaped for borrowck — compute the parent raw pointer
+        // reshaped for borrowck — compute the parent raw pointer
         // before mutably borrowing `io_poll` so the two borrows do not overlap.
         let ctx = std::ptr::from_mut::<WriteFile>(this).cast::<()>();
         let fd = this.opened_fd;
@@ -272,7 +272,6 @@ impl WriteFile {
 
     pub fn wait_for_writable(&mut self) {
         self.close_after_io = true;
-        // Zig: `@atomicStore(?*const fn, &self.io_request.callback, &onRequestWritable, .seq_cst)`.
         self.io_request
             .store_callback_seq_cst(Self::on_request_writable);
         if !self.io_request.scheduled {
@@ -308,11 +307,9 @@ impl WriteFile {
             close_after_io: false,
             mkdirp_if_not_exists,
         }));
-        // PORT NOTE: Zig follows with `file_blob.store.?.ref()` because the Zig
-        // caller bitwise-copies `Blob` (no ref bump, no dtor) and `bun.destroy`
-        // in `then` does not deref. In Rust the caller passes a `+1` Blob (via
+        // No explicit store ref bump: the caller passes a `+1` Blob (via
         // `borrowed_view()`'s `StoreRef::clone`) and `heap::take(this)` in
-        // `then` runs `StoreRef::drop`, so the explicit ref/deref pair is
+        // `then` runs `StoreRef::drop`, so the ref/deref pair is
         // folded into RAII.
         Ok(write_file)
     }
@@ -324,10 +321,9 @@ impl WriteFile {
         callback: WriteFileOnWriteFileCallback,
         mkdirp_if_not_exists: bool,
     ) -> Result<*mut WriteFile, Error> {
-        // PORT NOTE: Zig generated a per-`Type` `Handler.run` thunk that
-        // `@ptrCast` the *anyopaque ctx back. In Rust the caller supplies a
-        // `*mut c_void`-typed callback directly (see `WriteFilePromise::run`)
-        // so the thunk collapses to a `.cast()` on `context`.
+        // The caller supplies a
+        // `*mut c_void`-typed callback directly (see `WriteFilePromise::run`),
+        // so this is just a `.cast()` on `context`.
         WriteFile::create_with_ctx(
             file_blob,
             bytes_blob,
@@ -337,8 +333,7 @@ impl WriteFile {
         )
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig passed `buffer: []const u8` borrowed from
-    // self.bytes_blob alongside &mut self. Take (off, len) here and re-derive the slice
+    // reshaped for borrowck — take (off, len) here and re-derive the slice
     // internally so callers don't hold a borrow of self across the &mut self call.
     pub fn do_write(&mut self, off: usize, len: usize, wrote: &mut usize) -> bool {
         let fd = self.opened_fd;
@@ -385,12 +380,10 @@ impl WriteFile {
         let cb_ctx = this.on_complete_ctx;
         let system_error = this.system_error.take();
         let total_written = this.total_written;
-        // Zig: `this.bytes_blob.store.?.deref(); this.file_blob.store.?.deref();
-        //       bun.destroy(this);`
-        // Folded into RAII: dropping the `Box` runs `WriteFile`'s field-drop
+        // Cleanup is RAII: dropping the `Box` runs `WriteFile`'s field-drop
         // glue, which drops `bytes_blob.store`/`file_blob.store: Option<
-        // StoreRef>` → `Store::deref()` — exactly one deref each, same as
-        // the spec. (An earlier explicit `detach()` here was a no-op; the
+        // StoreRef>` → `Store::deref()` — exactly one deref each.
+        // (An earlier explicit `detach()` here was a no-op; the
         // bun-write-leak.test.ts failure was the ASAN debug build's ~320 MB
         // baseline RSS exceeding the fixture's 256 MB absolute threshold,
         // not an unbalanced ref.)
@@ -556,7 +549,7 @@ impl WriteFile {
     fn do_write_loop_posix(&mut self) {
         while self.state.load(Ordering::Relaxed) == ClosingState::Running as u8 {
             let remain_full = self.bytes_blob.shared_view();
-            // PORT NOTE: reshaped for borrowck — capture len/offset before mut borrow
+            // reshaped for borrowck — capture len/offset before mut borrow
             let off = self.total_written.min(remain_full.len());
             let remain_len = remain_full.len() - off;
 
@@ -615,7 +608,7 @@ mod windows_impl {
     use core::ptr::null_mut;
 
     use bun_io::{self as aio, IntrusiveUvFs as _, KeepAlive};
-    // `bun_jsc::EventLoop`/`ManagedTask` are *modules* (Zig-style namespace
+    // `bun_jsc::EventLoop`/`ManagedTask` are *modules* (namespace
     // re-exports); the structs live one level deeper.
     use bun_jsc::{ConcurrentTask, ManagedTask::ManagedTask, event_loop::EventLoop};
     use bun_sys::ReturnCodeExt as _;
@@ -699,8 +692,7 @@ mod windows_impl {
                 owned_fd: false,
             });
             // SAFETY: just allocated, sole owner until returned.
-            // PORT NOTE: Zig's `file_blob.store.?.ref()` / `bytes_blob.store.?.ref()`
-            // are omitted — the Rust caller passes `+1` Blobs via
+            // No explicit store ref bumps — the caller passes `+1` Blobs via
             // `borrowed_view()` and `deinit` releases them via
             // `heap::take → StoreRef::drop`.
             //
@@ -966,14 +958,13 @@ mod windows_impl {
                 .pathlike
                 .path()
                 .slice();
-            // LIFETIME: `AsyncMkdirp::new` returns `Box<Self>`. In Zig (write_file.zig:486)
-            // `.new(...)` is `bun.TrivialNew`, which yields a raw `*AsyncMkdirp` with no
-            // destructor — the allocation is intentionally leaked here and freed by
-            // `work_pool_callback` after invoking `completion`. In Rust the temporary
+            // LIFETIME: `AsyncMkdirp::new` returns `Box<Self>`. The allocation
+            // is intentionally leaked here and freed by `work_pool_callback`
+            // after invoking `completion`. A temporary
             // `Box` would drop at end-of-statement, freeing the allocation immediately
             // after `schedule()` stashes a raw `*mut WorkPoolTask` into the work pool,
             // so the worker thread would dereference freed memory. `Box::leak` hands
-            // ownership to the work-pool/completion path, matching the Zig lifetime.
+            // ownership to the work-pool/completion path.
             Box::leak(crate::node::fs::async_::AsyncMkdirp::new(
                 crate::node::fs::async_::AsyncMkdirp {
                     completion: Self::on_mkdirp_complete_concurrent,
@@ -997,8 +988,8 @@ mod windows_impl {
             // SAFETY: caller contract — `this` is live.
             let err = unsafe { (*this).err.take() };
             if let Some(err_) = err {
-                // PORT NOTE: Zig `defer bun.default_allocator.free(err_.path)` — handled by Drop of
-                // sys::Error.path (owned Box<[u8]>); no explicit free needed.
+                // `sys::Error.path` is an owned `Box<[u8]>` freed by its Drop;
+                // no explicit free needed.
                 // SAFETY: caller contract — `this` is live; `throw` consumes it.
                 match unsafe { Self::throw(this, err_) } {
                     WriteFileWindowsError::WriteFileWindowsDeinitialized => {}
@@ -1018,7 +1009,7 @@ mod windows_impl {
 
         /// `ManagedTask`-shaped trampoline for [`on_mkdirp_complete`]: takes
         /// `*mut Self` and returns the event-loop `JsResult<()>` (always `Ok`;
-        /// the inner body already swallows `JSTerminated` per the Zig spec).
+        /// the inner body already swallows `JSTerminated`).
         fn on_mkdirp_complete_task(this: *mut WriteFileWindows) -> bun_event_loop::JsResult<()> {
             // SAFETY: `this` is the live Box-allocated `WriteFileWindows` whose
             // pointer was stashed in `on_mkdirp_complete_concurrent` below;
@@ -1256,9 +1247,8 @@ mod windows_impl {
                 if fd > 0 && (*this).owned_fd {
                     aio::Closer::close(Fd::from_uv(fd), (*this).io_request.loop_);
                 }
-                // PORT NOTE: Zig `file_blob.store.?.deref()` / `bytes_blob.store.?.deref()`
-                // are subsumed by `StoreRef::drop` when the Box is reclaimed below
-                // (paired with the RAII note in `create_with_ctx`).
+                // The store derefs happen via `StoreRef::drop` when the Box is
+                // reclaimed below (paired with the RAII note in `create_with_ctx`).
                 (*this).poll_ref.disable();
                 // (*this).io_request is a valid uv_fs_t embedded in this struct; uv_fs_req_cleanup
                 // is safe on a zeroed or previously-used req.
@@ -1276,7 +1266,7 @@ mod windows_impl {
             callback: WriteFileOnWriteFileCallback,
             mkdirp_if_not_exists: bool,
         ) -> Result<*mut WriteFileWindows, WriteFileWindowsError> {
-            // PORT NOTE: see `WriteFile::create` — caller supplies an erased
+            // see `WriteFile::create` — caller supplies an erased
             // `*mut c_void` callback directly; `context` is just `.cast()`ed.
             WriteFileWindows::create_with_ctx(
                 file_blob,
@@ -1300,7 +1290,8 @@ pub struct WriteFilePromise {
 impl WriteFilePromise {
     pub fn run(handler: *mut c_void, count: WriteFileResultType) -> Result<(), JsTerminated> {
         let handler = handler.cast::<Self>();
-        // SAFETY: handler is a Box-allocated WriteFilePromise (see Blob.zig:1172); consumed here.
+        // SAFETY: handler is the Box-allocated WriteFilePromise created in
+        // Blob.rs (`heap::into_raw(Box::new(WriteFilePromise { .. }))`); consumed here.
         // `swap()` releases the Strong's handle slot and yields a GC-owned `*mut JSPromise`,
         // which stays valid past `drop(heap::take(handler))`.
         let (promise, global_this): (*mut JSPromise, &JSGlobalObject) = unsafe {
@@ -1359,7 +1350,8 @@ impl WriteFileWaitFromLockedValueTask {
         value: &mut body::Value,
     ) -> Result<(), JsTerminated> {
         let this = this.as_ptr();
-        // SAFETY: this is a Box-allocated task (see Blob.zig:1581).
+        // SAFETY: this is the Box-allocated task created in Blob.rs
+        // (`heap::into_raw(Box::new(WriteFileWaitFromLockedValueTask { .. }))`).
         let this_ref = unsafe { &mut *this };
         // `get()` returns a GC-owned cell, valid past `heap::take(this)`.
         let promise: &mut JSPromise = &mut *this_ref.promise.get();
@@ -1367,10 +1359,7 @@ impl WriteFileWaitFromLockedValueTask {
         // (must coexist with `&mut this_ref` and survive `heap::take(this)`).
         let global_ref = this_ref.global_this;
         let global_this = global_ref.get();
-        // PORT NOTE: Zig `var file_blob = this.file_blob;` is a non-owning
-        // bitwise copy — both bindings alias the same `*Store` with no ref
-        // bump, and `bun.destroy(this)` later frees raw memory without running
-        // field destructors. In Rust `heap::take(this)` *does* drop fields,
+        // `heap::take(this)` drops fields,
         // so leaving the `StoreRef` in `this.file_blob` would double-deref it.
         // Move ownership out instead; the `Locked` arm — the only path that
         // keeps `this` alive for a future callback — moves it back so the next
@@ -1423,9 +1412,7 @@ impl WriteFileWaitFromLockedValueTask {
                     }
                 };
 
-                // PORT NOTE: Zig `defer bun.destroy(this); defer this.promise.deinit();
-                // defer file_blob.detach();` — defers run in reverse order at scope
-                // exit. Reclaim the Box now so it drops last; `file_blob` (a local
+                // Reclaim the Box now so it drops last; `file_blob` (a local
                 // declared after) drops first.
                 // SAFETY: `this` was Box-allocated (see Self::new). `this_ref` is dead
                 // past this point — all further field access goes through `_this_box`.
@@ -1456,5 +1443,3 @@ impl WriteFileWaitFromLockedValueTask {
         Ok(())
     }
 }
-
-// ported from: src/runtime/webcore/blob/write_file.zig
diff --git a/src/runtime/webcore/encoding.rs b/src/runtime/webcore/encoding.rs
index 1f19c4d3cb3..2bc37bf9489 100644
--- a/src/runtime/webcore/encoding.rs
+++ b/src/runtime/webcore/encoding.rs
@@ -23,9 +23,8 @@ fn create_external_globally_allocated_utf16(bytes: Vec<u16>) -> BunString {
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// PORT NOTE: Zig used `comptime encoding: Encoding`. Stable Rust does not allow
-// enum-typed const generics without `#![feature(adt_const_params)]`, so per
-// PORTING.md we reshape to `const ENCODING: u8` and reconstitute the enum
+// Stable Rust does not allow enum-typed const generics without
+// `#![feature(adt_const_params)]`, so we use `const ENCODING: u8` and reconstitute the enum
 // inside each body via `encoding_from_u8(ENCODING)` (the optimizer folds the
 // match since `ENCODING` is a monomorphized constant).
 // ────────────────────────────────────────────────────────────────────────────
@@ -61,8 +60,7 @@ mod enc {
 }
 
 // ────────────────────────────────────────────────────────────────────────────
-// `dispatch_encoding!` — Rust spelling of Zig's `switch (enc) { inline else
-// => |e| f(..., e) }`. Expands a runtime [`Encoding`] into nine monomorphized
+// `dispatch_encoding!` — expands a runtime [`Encoding`] into nine monomorphized
 // arms, binding the discriminant as a `const $E: u8` usable in const-generic
 // position (`f::<$E>(..)`). Stable-Rust workaround for `adt_const_params`.
 //
@@ -183,7 +181,7 @@ pub(crate) unsafe extern "C" fn Bun__encoding__constructFromLatin1(
     // Ownership of the allocation transfers to JSC: `create_buffer` registers the
     // pointer with `MarkedArrayBuffer_deallocator`, which frees it on GC. Wrapping
     // in `ManuallyDrop` prevents Rust from also freeing it at scope exit (which
-    // would be a use-after-free + double-free). Mirrors encoding.zig:42-54.
+    // would be a use-after-free + double-free).
     // SAFETY: forwarded from this fn's contract.
     let mut slice = core::mem::ManuallyDrop::new(unsafe {
         dispatch_encoding!(encoding_from_u8(encoding), {
@@ -206,7 +204,7 @@ pub(crate) unsafe extern "C" fn Bun__encoding__constructFromUTF16(
     // Ownership of the allocation transfers to JSC: `create_buffer` registers the
     // pointer with `MarkedArrayBuffer_deallocator`, which frees it on GC. Wrapping
     // in `ManuallyDrop` prevents Rust from also freeing it at scope exit (which
-    // would be a use-after-free + double-free). Mirrors encoding.zig:56-69.
+    // would be a use-after-free + double-free).
     // SAFETY: forwarded from this fn's contract.
     let mut slice = core::mem::ManuallyDrop::new(unsafe {
         dispatch_encoding!(encoding_from_u8(encoding), {
@@ -251,10 +249,6 @@ pub(crate) unsafe extern "C" fn Bun__encoding__toString(
     }
 }
 
-// pub fn writeUTF16AsUTF8(utf16: [*]const u16, len: usize, to: [*]u8, to_len: usize) callconv(.c) i32 {
-//     return @intCast(i32, strings.copyUTF16IntoUTF8(to[0..to_len], []const u16, utf16[0..len]).written);
-// }
-
 pub(crate) fn to_string(
     input: &[u8],
     global_object: &JSGlobalObject,
@@ -317,16 +311,14 @@ pub(crate) fn to_bun_string_from_owned_slice(input: Vec<u8>, encoding: Encoding)
                 return BunString::empty();
             }
 
-            // Allocate a fresh u16-aligned Vec and copy the bytes. The Zig
-            // original reinterpreted the owned `[]u8` as `[]u16` (with
-            // `@alignCast`), but the equivalent in Rust — rebuilding a
-            // `Vec<u16>` from a `Vec<u8>`'s raw parts — violates `Vec`'s
+            // Allocate a fresh u16-aligned Vec and copy the bytes. Rebuilding a
+            // `Vec<u16>` from a `Vec<u8>`'s raw parts would violate `Vec`'s
             // Layout contract: alloc happened with align 1, but the eventual
             // dealloc as `Vec<u16>` uses align 2. mimalloc gives us aligned
-            // pointers in practice, so this didn't crash, but it's UB on
+            // pointers in practice, so that wouldn't crash, but it's UB on
             // paper and an allocator change could surface it. Mirrors
-            // `construct_from_u16`'s utf16le arm, which fixed the symmetric
-            // Zig pattern for the same reason.
+            // `construct_from_u16`'s utf16le arm, which avoids the same
+            // reinterpret for the same reason.
             let mut as_u16 = vec![0u16; usable_len / 2];
             let dst: &mut [u8] = bytemuck::cast_slice_mut(&mut as_u16);
             dst.copy_from_slice(&input[..usable_len]);
@@ -469,8 +461,7 @@ pub(crate) fn to_bun_string_comptime<const ENCODING: u8>(input: &[u8]) -> BunStr
 /// allocation, no finalizer). Large outputs are encoded into a mimalloc-backed
 /// buffer wrapped in an external WTF string, because cycling large blocks
 /// through WTF's string allocator on every call is measurably more expensive
-/// than letting mimalloc reuse them (this mirrors the original Zig
-/// implementation of `Buffer.toString("base64")`).
+/// than letting mimalloc reuse them.
 fn encode_base64_to_bun_string(input: &[u8], url_safe: bool) -> BunString {
     // Output size above which the external-string strategy is used.
     const EXTERNAL_MIN_LEN: usize = 32 * 1024;
@@ -515,7 +506,6 @@ fn encode_base64_to_bun_string(input: &[u8], url_safe: bool) -> BunString {
     create_external_globally_allocated_latin1(to)
 }
 
-// TODO(port): narrow error set — Zig signature is `!usize` but body never fails.
 /// # Safety
 /// `input` must be valid for reading `len` bytes and `to_ptr` must be valid for
 /// writing `to_len` bytes; the two ranges must not overlap.
@@ -530,11 +520,6 @@ pub(crate) unsafe fn write_u8<const ENCODING: u8>(
     }
 
     // TODO: increase temporary buffer size for larger amounts of data
-    // defer {
-    //     if (comptime encoding.isBinaryToText()) {}
-    // }
-
-    // if (comptime encoding.isBinaryToText()) {}
 
     // SAFETY: caller guarantees `input[..len]` and `to_ptr[..to_len]` are valid; len/to_len > 0.
     let (input_slice, to_slice) = unsafe {
@@ -585,10 +570,9 @@ pub(crate) unsafe fn write_u8<const ENCODING: u8>(
                 let written = strings::copy_latin1_into_utf16(output, buf).written as usize;
                 Ok(written * 2)
             } else {
-                // PORT NOTE: Zig used `[]align(1) u16` and a generic Buffer type. Rust
-                // `&mut [u16]` requires natural alignment, so inline the (trivial) widen
-                // loop with `write_unaligned` for the misaligned-dest case — matches
-                // `copyLatin1IntoUTF16` body 1:1 (each Latin-1 byte → one u16).
+                // Rust `&mut [u16]` requires natural alignment, so inline the
+                // (trivial) widen loop for the misaligned-dest case
+                // (each Latin-1 byte → one u16).
                 let written = buf.len().min(out_units);
                 for i in 0..written {
                     to_slice[i * 2..i * 2 + 2].copy_from_slice(&(buf[i] as u16).to_ne_bytes());
@@ -659,7 +643,6 @@ pub(crate) fn encode_into_from8<const ENCODING: u8>(
     unsafe { write_u8::<ENCODING>(input.as_ptr(), input.len(), to.as_mut_ptr(), to.len()) }
 }
 
-// TODO(port): narrow error set
 /// # Safety
 /// `input` must be valid for reading `len` `u16`s and `to` must be valid for
 /// writing `to_len` bytes. For `Ucs2`/`Utf16le` the ranges may overlap (memmove
@@ -675,8 +658,8 @@ pub(crate) unsafe fn write_u16<const ENCODING: u8, const ALLOW_PARTIAL_WRITE: bo
     }
 
     // NOTE: Do NOT eagerly materialize `&[u16]` / `&mut [u8]` slices over `input`/`to` here.
-    // The Ucs2/Utf16le arm is spec'd to accept overlapping input/output (Zig uses
-    // `bun.memmove` at encoding.zig:391/400). Building a `&mut [u8]` whose memory is also
+    // The Ucs2/Utf16le arm is spec'd to accept overlapping input/output (it copies with
+    // memmove semantics). Building a `&mut [u8]` whose memory is also
     // covered by a live `&[u16]` would violate `slice::from_raw_parts_mut`'s exclusive-access
     // contract (aliased-&mut UB). Each arm below constructs only the slice views it needs,
     // and the Ucs2/Utf16le arm stays raw-pointer-only.
@@ -729,9 +712,6 @@ pub(crate) unsafe fn write_u16<const ENCODING: u8, const ALLOW_PARTIAL_WRITE: bo
                 let input_u8 = input.cast::<u8>();
                 // SAFETY: ranges may overlap; use ptr::copy (memmove).
                 unsafe { core::ptr::copy(input_u8, to, fixed_len) };
-                // PORT NOTE: Zig wrote `to[0..written]` from `input_u8[0..fixed_len]` (mismatched
-                // lengths into bun.memmove). Preserving fixed_len bytes copied as that is what is
-                // returned; revisit if behavior diverges.
                 Ok(fixed_len)
             }
         }
@@ -765,15 +745,6 @@ pub(crate) unsafe fn write_u16<const ENCODING: u8, const ALLOW_PARTIAL_WRITE: bo
     }
 }
 
-// PORT NOTE: Zig `constructFrom(comptime T: type, input: []const T, ...)` dispatched on
-// T == u8 vs u16 to constructFromU8/constructFromU16. A u8-only wrapper here would silently
-// drop the u16 path, so the generic entry point is omitted — callers use `construct_from_u8`
-// / `construct_from_u16` directly.
-// TODO(port): if a generic entry point is needed, introduce a sealed trait
-// `ConstructFromEncoding` impl'd for u8/u16 so
-// `construct_from<T: ConstructFromEncoding, const ENCODING: u8>(input: &[T]) -> Vec<u8>`
-// dispatches correctly.
-
 /// # Safety
 /// `input` must be valid for reading `len` bytes.
 pub(crate) unsafe fn construct_from_u8<const ENCODING: u8>(
@@ -789,7 +760,6 @@ pub(crate) unsafe fn construct_from_u8<const ENCODING: u8>(
 
     match encoding_from_u8(ENCODING) {
         Encoding::Buffer => {
-            // TODO(port): Zig returned &[] on OOM; Rust aborts.
             let mut to = vec![0u8; len];
             to.copy_from_slice(input_slice);
             to
@@ -808,9 +778,8 @@ pub(crate) unsafe fn construct_from_u8<const ENCODING: u8>(
         Encoding::Ucs2 | Encoding::Utf16le => {
             // Each Latin-1 byte widens to one native-endian u16 code unit
             // (`copy_latin1_into_utf16` is exactly that loop). Write the bytes
-            // directly into a `Vec<u8>` so we never depend on the allocator-
-            // layout-dependent `Vec<u16> → Vec<u8>` header reinterpret the Zig
-            // original relied on (`sliceAsBytes` over a heap allocation).
+            // directly into a `Vec<u8>` so we never depend on an allocator-
+            // layout-dependent `Vec<u16> → Vec<u8>` header reinterpret.
             let mut to = vec![0u8; len * 2];
             for (out, &b) in to.chunks_exact_mut(2).zip(input_slice) {
                 out.copy_from_slice(&u16::from(b).to_ne_bytes());
@@ -836,7 +805,7 @@ pub(crate) unsafe fn construct_from_u8<const ENCODING: u8>(
         }
 
         Encoding::Base64 | Encoding::Base64url => {
-            const TRIM_CHARS: &[u8] = b"\r\n\t \x0B"; // \x0B = std.ascii.control_code.vt
+            const TRIM_CHARS: &[u8] = b"\r\n\t \x0B"; // \x0B = vertical tab
             let slice = strings::trim(input_slice, TRIM_CHARS);
             if slice.is_empty() {
                 return Vec::new();
@@ -886,10 +855,9 @@ pub(crate) unsafe fn construct_from_u16<const ENCODING: u8>(
         }
         // string is already encoded, just need to copy the data
         Encoding::Ucs2 | Encoding::Utf16le => {
-            // `input_slice: &[u16]` is the source bytes verbatim — copy them out.
-            // The Zig original allocated u16-aligned then reinterpreted the Vec
-            // header to u8, which is allocator-layout-dependent in Rust; a fresh
-            // u8 Vec sidesteps that and matches the returned `Vec<u8>` layout.
+            // `input_slice: &[u16]` is the source bytes verbatim — copy them
+            // out into a fresh u8 Vec (a `Vec<u16>` header reinterpret would be
+            // allocator-layout-dependent).
             bytemuck::cast_slice::<u16, u8>(input_slice).to_vec()
         }
 
@@ -921,7 +889,7 @@ pub(crate) unsafe fn construct_from_u16<const ENCODING: u8>(
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `bun.String.encodeInto` / `bun.String.encode` / `ZigString.encodeWithAllocator`
+// `String` / `ZigString` encoding extension traits.
 //
 // Hosted here (not on `bun_core::String`) because the encoder bodies above
 // (`encodeIntoFrom{8,16}` / `constructFrom{U8,U16}`) belong to `bun_runtime`;
@@ -945,8 +913,8 @@ fn construct_from_u16_dyn(input: &[u16], encoding: Encoding) -> Vec<u8> {
     dispatch_encoding!(encoding, |E| unsafe { construct_from_u16::<E>(p, n) })
 }
 
-/// Runtime-dispatch wrapper over [`encode_into_from16`] (Zig passed
-/// `comptime allow_partial_write = true` from `String.encodeInto`).
+/// Runtime-dispatch wrapper over [`encode_into_from16`] (passes
+/// `ALLOW_PARTIAL_WRITE = true`).
 fn encode_into_from16_dyn(
     input: &[u16],
     to: &mut [u8],
@@ -964,8 +932,8 @@ fn encode_into_from8_dyn(
     dispatch_encoding!(encoding, |E| encode_into_from8::<E>(input, to))
 }
 
-/// `bun.String.{encodeInto,encode}` (string.zig:630-644). Extension trait —
-/// see module note above for why this lives in `bun_runtime`.
+/// Extension trait — see module note above for why this lives in
+/// `bun_runtime`.
 pub trait BunStringEncode {
     fn encode_into(&self, out: &mut [u8], enc: Encoding) -> Result<usize, bun_core::Error>;
     fn encode(&self, enc: Encoding) -> Vec<u8>;
@@ -978,22 +946,19 @@ impl BunStringEncode for bun_core::String {
             return encode_into_from16_dyn(self.utf16(), out, enc);
         }
         if self.is_utf8() {
-            // Zig: `@panic("TODO")` — UTF-8 source path was never implemented
-            // (string.zig:636). Match Zig behaviour.
+            // The UTF-8 source path was never implemented.
             unreachable!("String.encodeInto from UTF-8 source — unimplemented in Zig");
         }
         encode_into_from8_dyn(self.latin1(), out, enc)
     }
 
-    /// `bun.String.encode` (string.zig:642) —
-    /// `self.toZigString().encodeWithAllocator(allocator, enc)`.
+    /// Encode `self` with the given encoding.
     fn encode(&self, enc: Encoding) -> Vec<u8> {
         self.to_zig_string().encode_with_allocator(enc)
     }
 }
 
-/// `ZigString.encodeWithAllocator` (ZigString.zig). Extension trait — encoder
-/// bodies live in this crate.
+/// `ZigString` encoding. Extension trait — encoder bodies live in this crate.
 pub trait ZigStringEncode {
     fn encode_with_allocator(&self, enc: Encoding) -> Vec<u8>;
     #[inline]
@@ -1011,5 +976,3 @@ impl ZigStringEncode for bun_core::ZigString {
         }
     }
 }
-
-// ported from: src/runtime/webcore/encoding.zig
diff --git a/src/runtime/webcore/fetch.rs b/src/runtime/webcore/fetch.rs
index 437d46c6852..e1e4441351d 100644
--- a/src/runtime/webcore/fetch.rs
+++ b/src/runtime/webcore/fetch.rs
@@ -34,7 +34,7 @@ pub(crate) const FETCH_TYPE_ERROR_STRING_VALUES: [&str; 8] = [
 pub(crate) const FETCH_TYPE_ERROR_STRINGS: [&str; 8] = FETCH_TYPE_ERROR_STRING_VALUES;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Re-export: FetchTasklet lives in ./fetch/FetchTasklet.zig
+// Re-export: FetchTasklet lives in ./fetch/FetchTasklet.rs
 // ──────────────────────────────────────────────────────────────────────────
 
 #[path = "fetch/FetchTasklet.rs"]
@@ -115,10 +115,9 @@ pub(crate) fn s3_credentials_from_env(
     )
 }
 
-/// RAII guard for the `+1` `AbortSignal` ref taken in `extract_signal`. Zig had
-/// `defer { if (signal) |sig| sig.unref(); }` covering every exit path; this is
-/// the Rust equivalent. `take()` disarms the guard when ownership is handed to
-/// `FetchOptions`.
+/// RAII guard for the `+1` `AbortSignal` ref taken in `extract_signal`,
+/// released on every exit path. `take()` disarms the guard when ownership is
+/// handed to `FetchOptions`.
 struct SignalRef(Option<NonNull<AbortSignal>>);
 impl SignalRef {
     #[inline]
@@ -138,8 +137,8 @@ impl Drop for SignalRef {
 }
 
 /// RAII guard for the `+1` `FetchHeaders` ref returned by
-/// `FetchHeaders::create_from_js`. Zig had `defer { if (fetch_headers_to_deref) |fh| fh.deref() }`;
-/// this releases the ref on every exit path of `extract_headers`.
+/// `FetchHeaders::create_from_js`; releases the ref on every exit path of
+/// `extract_headers`.
 struct FetchHeadersRef(Option<NonNull<FetchHeaders>>);
 impl Drop for FetchHeadersRef {
     fn drop(&mut self) {
@@ -152,7 +151,7 @@ impl Drop for FetchHeadersRef {
     }
 }
 
-/// `Blob.Any` accessor shim — Zig union-field access `body.AnyBlob.Blob`.
+/// `Blob.Any` accessor shim.
 trait AnyBlobExt {
     fn blob(&self) -> &Blob;
 }
@@ -200,7 +199,7 @@ fn data_url_response(data_url_: DataURL, global_this: &JSGlobalObject) -> JSValu
 
     let mut allocated = false;
     let mime_type = MimeType::MimeType::init(data_url.mime_type, true, Some(&mut allocated));
-    // PORT NOTE: `mime_type.value` is `Cow<'static, [u8]>`; Blob.content_type is
+    // `mime_type.value` is `Cow<'static, [u8]>`; Blob.content_type is
     // `*const [u8]` discriminated by `content_type_allocated` (Blob's Drop reclaims
     // via `heap::take` when set). Use `heap::alloc` (paired alloc/free), not
     // leaking.
@@ -255,12 +254,9 @@ pub(crate) fn bun_fetch_preconnect(
         ));
     }
 
-    // `href_from_js` returns a +1 (`Bun::toStringRef`); Zig released it via
-    // `defer url_str.deref()`. `bun_core::String` is `Copy` with no `Drop`, so
-    // wrap in `OwnedString` for the scope-exit deref.
+    // `href_from_js` returns a +1 (`Bun::toStringRef`). `bun_core::String` is
+    // `Copy` with no `Drop`, so wrap in `OwnedString` for the scope-exit deref.
     let url_str = bun_core::OwnedString::new(jsc::URL::href_from_js(arguments[0], global_object)?);
-    // (Zig's post-hoc `hasException()` is redundant here — `href_from_js` already
-    // returns `JsResult` and is `?`-propagated.)
 
     if url_str.tag() == BunStringTag::Dead {
         return Err(global_object
@@ -280,7 +276,7 @@ pub(crate) fn bun_fetch_preconnect(
             .throw());
     }
 
-    // PORT NOTE: bun.handleOom(url_str.toOwnedSlice(...)) → to_owned_slice() aborts on OOM.
+    // bun.handleOom(url_str.toOwnedSlice(...)) → to_owned_slice() aborts on OOM.
     // `preconnect` takes a `URL<'static>` that borrows a `Box<[u8]>` href and
     // assumes ownership when `is_url_owned == true` (it reconstructs the Box
     // to free it). Hand the allocation off via `heap::alloc`.
@@ -320,7 +316,7 @@ pub(crate) fn bun_fetch_preconnect(
         return Err(global_object.throw_invalid_arguments(format_args!("Invalid port")));
     }
 
-    // PORT NOTE: `preconnect` is a free fn in `bun_http::async_http`. Ownership
+    // `preconnect` is a free fn in `bun_http::async_http`. Ownership
     // of `href_raw` transfers here (`is_url_owned: true`).
     http::async_http::preconnect(url, true);
     Ok(JSValue::UNDEFINED)
@@ -366,7 +362,7 @@ pub(crate) fn node_http_client(ctx: &JSGlobalObject, callframe: &CallFrame) -> J
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// URLType (local enum inside fetchImpl in Zig)
+// URLType
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -413,7 +409,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
     let mut headers: Option<Headers> = None;
 
-    // PORT NOTE: hoist the one `&mut vm` accessor before `args` takes an
+    // hoist the one `&mut vm` accessor before `args` takes an
     // immutable borrow of `vm` for the rest of the function.
     let vm_verbose_fetch = vm.get_verbose_fetch();
 
@@ -448,7 +444,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
     let mut range: Option<bun_core::ZBox> = None;
     let mut unix_socket_path: ZigStringSlice = ZigStringSlice::empty();
 
-    // PORT NOTE: Zig freely reassigns `url_proxy_buffer` while `url`/`proxy`
+    // `url_proxy_buffer` gets reassigned while `url`/`proxy`
     // still point into it (or into the buffer about to replace it). Detach the
     // borrow-checker by parsing through a raw-pointer slice; the caller is
     // responsible for keeping the backing allocation alive (it always becomes
@@ -457,7 +453,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         ($slice:expr) => {{
             let s: &[u8] = $slice;
             // SAFETY: `s` points into a Vec that is immediately adopted as
-            // `url_proxy_buffer` (or already is it); see PORT NOTE above.
+            // `url_proxy_buffer` (or already is it); see note above.
             ZigURL::parse(unsafe { bun_ptr::detach_lifetime(s) })
         }};
     }
@@ -467,9 +463,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
     let mut reject_unauthorized = vm.get_tls_reject_unauthorized();
     let mut check_server_identity: JSValue = JSValue::ZERO;
 
-    // PORT NOTE: the Zig `defer { ... }` block here freed signal/unix_socket_path/
-    // url_proxy_buffer/headers/body/hostname/range/ssl_config on every exit path.
-    // In Rust, all of these are owning types whose Drop runs on early return
+    // signal/unix_socket_path/url_proxy_buffer/headers/body/hostname/range/
+    // ssl_config are all owning types whose Drop runs on early return
     // (`signal` via `SignalRef`).
 
     let options_object: Option<JSValue> = 'brk: {
@@ -482,8 +477,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         break 'brk None;
     };
 
-    // PORT NOTE: kept as raw `*mut Request` because the body re-borrows it
-    // multiple times across long-lived option/init reads (Zig had no borrowck).
+    // kept as raw `*mut Request` because the body re-borrows it
+    // multiple times across long-lived option/init reads.
     let request: Option<*mut Request> = 'brk: {
         if first_arg.is_cell() {
             if let Some(request_) = first_arg.as_direct::<Request>() {
@@ -502,7 +497,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
     }
 
     // If it's NOT a Request or a subclass of Request, treat the first argument as a URL.
-    // (`StringOrURL::from_js` returns `JsResult` — Zig's post-hoc `hasException()` is dead.)
     let url_str_optional = if first_arg.as_::<Request>().is_none() {
         StringOrURL::from_js(first_arg, global_this)?
     } else {
@@ -522,8 +516,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         break 'brk None;
     };
 
-    // Every arm carries a +1 (`from_js`/`dupe_ref`/`StringOrURL::from_js`); Zig
-    // released it via `defer url_str.deref()`. `bun_core::String` is `Copy`
+    // Every arm carries a +1 (`from_js`/`dupe_ref`/`StringOrURL::from_js`).
+    // `bun_core::String` is `Copy`
     // with NO `Drop`, so wrap in `OwnedString` for the scope-exit deref —
     // without it the +1 leaks the WTFStringImpl, and when the input JS string
     // is a substring sharing an `ExternalStringImpl` (e.g. a slice of a
@@ -569,7 +563,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
     if url_str.has_prefix_comptime(b"data:") {
         let url_slice = url_str.to_utf8_without_ref();
-        // PORT NOTE: `defer url_slice.deinit()` → Drop.
+        // `defer url_slice.deinit()` → Drop.
 
         let data_url = match DataURL::parse_without_check(url_slice.slice()) {
             Ok(d) => d,
@@ -584,15 +578,15 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             }
         };
         let mut data_url = data_url;
-        // `data_url_response` `dupe_ref()`s this, so a borrowed view (no extra
-        // ref) is what Zig passed; `url_str`'s scope-exit deref balances it.
+        // `data_url_response` `dupe_ref()`s this, so pass a borrowed view (no
+        // extra ref); `url_str`'s scope-exit deref balances it.
         data_url.url = url_str.get();
         return Ok(data_url_response(data_url, global_this));
     }
 
-    // PORT NOTE: `ZigURL::from_string` returns `OwnedURL` (owns href buffer); we
+    // `ZigURL::from_string` returns `OwnedURL` (owns href buffer); we
     // immediately move that buffer into `url_proxy_buffer` and re-parse `url` to
-    // borrow it, mirroring Zig's `url.href` ownership transfer.
+    // borrow it.
     let owned_url = match ZigURL::from_string(&url_str) {
         Ok(u) => u,
         Err(_) => {
@@ -647,7 +641,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(decompression_value) = obj.get(global_this, "decompress")? {
@@ -716,7 +709,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(tls) = obj.get(global_this, "tls")? {
@@ -774,12 +766,10 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(socket_path) = obj.get(global_this, "unix")? {
                     if socket_path.is_string() && socket_path.get_length(ctx)? > 0 {
-                        // PORT NOTE: Zig `toSliceCloneWithAllocator` ≈ `to_slice_clone`.
                         break 'extract_unix_socket_path socket_path.to_slice_clone(global_this)?;
                     }
                 }
@@ -802,7 +792,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             options_object.unwrap_or(JSValue::ZERO),
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(protocol_val) = obj.get(global_this, "protocol")? {
@@ -834,7 +823,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(timeout_value) = obj.get(global_this, "timeout")? {
@@ -871,7 +859,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 match obj.get_optional_enum::<FetchRedirect>(global_this, "redirect") {
@@ -900,7 +887,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(keepalive_value) = obj.get(global_this, "keepalive")? {
@@ -931,7 +917,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
 
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(verb) = obj.get(global_this, "verbose")? {
@@ -958,13 +943,12 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
     // proxy: string | { url: string, headers?: Headers } | undefined;
     let mut proxy_headers: Option<Headers> = None;
-    // PORT NOTE: `defer if (proxy_headers) |*hdrs| hdrs.deinit();` → Headers impls Drop.
+    // `defer if (proxy_headers) |*hdrs| hdrs.deinit();` → Headers impls Drop.
     url_proxy_buffer = 'extract_proxy: {
         let objects_to_try = [
             options_object.unwrap_or(JSValue::ZERO),
             request_init_object.unwrap_or(JSValue::ZERO),
         ];
-        // PERF(port): was `inline for` — plain loop, profile if hot
         for obj in objects_to_try {
             if !obj.is_empty() {
                 if let Some(proxy_arg) = obj.get(global_this, "proxy")? {
@@ -982,8 +966,6 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                                 ),
                             );
                         }
-                        // PORT NOTE: `defer href.deref()` → Drop.
-                        // std.fmt.allocPrint(allocator, "{s}{f}", .{ url_proxy_buffer, href })
                         let mut buffer: Vec<u8> = Vec::with_capacity(url_proxy_buffer.len());
                         buffer.extend_from_slice(&url_proxy_buffer);
                         write!(&mut buffer, "{}", href).expect("write to Vec cannot fail");
@@ -996,7 +978,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                         }
 
                         proxy = Some(parse_url_detached!(&buffer[url_len..]));
-                        // PORT NOTE: allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
+                        // allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
                         break 'extract_proxy buffer;
                     }
                     // Handle object format: proxy: { url: "http://proxy.example.com:8080", headers?: Headers }
@@ -1019,7 +1001,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                                             ),
                                         );
                                     }
-                                    // PORT NOTE: `defer href.deref()` → Drop.
+                                    // `defer href.deref()` → Drop.
                                     let mut buffer: Vec<u8> =
                                         Vec::with_capacity(url_proxy_buffer.len());
                                     buffer.extend_from_slice(&url_proxy_buffer);
@@ -1034,7 +1016,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                                     }
 
                                     proxy = Some(parse_url_detached!(&buffer[url_len..]));
-                                    // PORT NOTE: allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
+                                    // allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
                                     url_proxy_buffer = buffer;
 
                                     // Get the headers from the proxy object (optional)
@@ -1056,7 +1038,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                                                 FetchHeaders::create_from_js(ctx, headers_value)?
                                             {
                                                 // `create_from_js` returns a +1-ref NonNull<FetchHeaders>;
-                                                // RAII guard releases it on scope exit (≡ Zig `defer fh.deref()`).
+                                                // RAII guard releases it on scope exit.
                                                 let _guard = FetchHeadersRef(Some(fetch_hdrs));
                                                 let fetch_hdrs = bun_ptr::BackRef::from(fetch_hdrs);
                                                 proxy_headers = Some(from_fetch_headers(
@@ -1246,9 +1228,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
     // headers: Headers | undefined;
     headers = 'extract_headers: {
-        // Zig: `defer { if (fetch_headers_to_deref) |fh| fh.deref() }` — releases
-        // the +1 from `create_from_js` on every exit path (including the
-        // `has_exception()` early returns below).
+        // Releases the +1 from `create_from_js` on every exit path (including
+        // the `has_exception()` early returns below).
         let mut fetch_headers_to_deref = FetchHeadersRef(None);
 
         let fetch_headers: Option<*mut FetchHeaders> = 'brk: {
@@ -1336,7 +1317,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
             if let Some(upgrade_) = headers_ref.fast_get(HTTPHeaderName::Upgrade) {
                 let upgrade = upgrade_.to_slice();
-                // PORT NOTE: `defer upgrade.deinit()` → Drop.
+                // `defer upgrade.deinit()` → Drop.
                 let slice = upgrade.slice();
                 if slice != b"h2" && slice != b"h2c" {
                     upgraded_connection = true;
@@ -1380,11 +1361,9 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
     // We don't pass along headers, we ignore method, we ignore status code...
     // But it's better than status quo.
     if url_type != URLType::Remote {
-        // PORT NOTE: `defer unix_socket_path.deinit()` → Drop on scope exit.
+        // `defer unix_socket_path.deinit()` → Drop on scope exit.
         let mut path_buf = PathBuffer::uninit();
         let mut path_buf2 = PathBuffer::uninit();
-        // TODO(port): std.io.fixedBufferStream + PercentEncoding.decode writer plumbing.
-        // The Zig threads a writer over path_buf2; here we call a slice-based decode.
         let decoded_len = match PercentEncoding::decode_into(
             &mut path_buf2[..],
             match url_type {
@@ -1401,7 +1380,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         let url_path_decoded = &path_buf2[0..decoded_len as usize];
 
         let url_string: BunString;
-        // PORT NOTE: `defer url_string.deref()` → Drop.
+        // `defer url_string.deref()` → Drop.
 
         // This can be a blob: url or a file: url.
         let blob_to_use: Blob = 'blob: {
@@ -1463,8 +1442,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                 #[cfg(windows)]
                 let mut cwd_buf = PathBuffer::uninit();
                 #[cfg(windows)]
-                // `bun_sys::getcwd` returns the byte length written into `cwd_buf`
-                // (Zig `bun.getcwd` returns the slice directly); slice it here.
+                // `bun_sys::getcwd` returns the byte length written into
+                // `cwd_buf`; slice it here.
                 let cwd: &[u8] = match bun_sys::getcwd(&mut cwd_buf) {
                     Ok(len) => &cwd_buf[..len],
                     Err(err) => {
@@ -1505,7 +1484,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
             url_string = jsc::URL::file_url_from_string(BunString::borrow_utf8(temp_file_path));
 
-            // PORT NOTE: `find_or_create_file_from_path` is typed against the
+            // `find_or_create_file_from_path` is typed against the
             // `crate::webcore::node_types` stub (until it's swapped to a
             // re-export of `crate::node::types`); construct that variant here.
             let mut pathlike = crate::webcore::node_types::PathOrFileDescriptor::Path(
@@ -1572,11 +1551,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         ));
     }
 
-    // PORT NOTE: Zig kept a separate `http_body = body` shallow alias and later
-    // detached `body` after `FetchTasklet.queue`. With Rust move semantics the
-    // alias is unnecessary: `body` is mutated in place for the sendfile/readfile
-    // paths and then *moved* into `FetchOptions`, so the trailing `body.detach()`
-    // and the debug ref-count check that depended on the alias are dropped.
+    // `body` is mutated in place for the sendfile/readfile paths and then
+    // *moved* into `FetchOptions`.
 
     if body.is_s3() {
         'prepare_body: {
@@ -1597,7 +1573,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                         global_this,
                     )),
                 );
-                // PORT NOTE: Zig `defer old.detach()`. HTTPRequestBody has no Drop
+                // HTTPRequestBody has no Drop
                 // impl, so a bare `drop(old)` would leak the S3 Blob.Store ref.
                 old.detach();
                 break 'prepare_body;
@@ -1607,18 +1583,17 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                     global_this,
                     global_this.create_error_instance(format_args!("Failed to start s3 stream")),
                 );
-            // PORT NOTE: Zig fetch.zig calls `body.detach()` here. HTTPRequestBody has no
-            // Drop impl, so a bare `drop(body)` would leak the S3 Blob.Store ref.
+            // HTTPRequestBody has no Drop impl, so a bare `drop(body)` would
+            // leak the S3 Blob.Store ref.
             body.detach();
             return Ok(rejected_value);
         }
     }
     if body.needs_to_read_file() {
         'prepare_body: {
-            // PORT NOTE: Zig used the VM's `nodeFS().sync_error_buf` as scratch
-            // for `path.sliceZ()`; we use a local `PathBuffer` instead (the
-            // `vm.node_fs()` accessor is gated behind a jsc↔runtime cycle and
-            // the buffer is just NUL-termination scratch).
+            // A local `PathBuffer` serves as NUL-termination scratch for
+            // `path.slice_z()` (the `vm.node_fs()` accessor is gated behind a
+            // jsc↔runtime cycle).
             let mut open_path_buf = PathBuffer::uninit();
             let opened_fd_res: bun_sys::Result<bun_sys::Fd> = {
                 let store = body.store().expect("needs_to_read_file implies store");
@@ -1679,8 +1654,8 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                     };
                     let blob_offset = body.any_blob().blob().offset.get();
 
-                    // PORT NOTE: `http::SendFile` fields are `usize`; blob sizes/offsets
-                    // are `blob::SizeType` (u64). Zig's `@intCast` ↔ `as usize` here.
+                    // `http::SendFile` fields are `usize`; blob sizes/offsets
+                    // are `blob::SizeType` (u64) — hence the `as usize` casts.
                     let mut sf = http::SendFile {
                         fd: opened_fd,
                         remain: (blob_offset + original_size) as usize,
@@ -1715,10 +1690,9 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             // TODO: make this async + lazy
             let blob_offset = body.any_blob().blob().offset.get();
             let blob_size = body.any_blob().blob().size.get();
-            // PORT NOTE: Zig used `globalThis.bunVM().nodeFS()`; that accessor is
-            // a jsc↔runtime cycle. `read_file` with an `Fd` path only touches
-            // `self.sync_error_buf` for path-variant inputs, so a fresh `NodeFS`
-            // is sufficient here.
+            // The `vm.node_fs()` accessor is a jsc↔runtime cycle. `read_file`
+            // with an `Fd` path only touches `self.sync_error_buf` for
+            // path-variant inputs, so a fresh `NodeFS` is sufficient here.
             let mut node_fs = node::fs::NodeFS::default();
             // `ReadFile` has `Drop`; can't use FRU `..Default::default()`.
             let mut rf_args = node::fs::args::ReadFile::default();
@@ -1775,7 +1749,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             storage_class: None,
             ..Default::default()
         };
-        // PORT NOTE: `defer credentialsWithOptions.deinit()` → Drop.
+        // `defer credentialsWithOptions.deinit()` → Drop.
 
         if let Some(options) = options_object {
             if let Some(s3_options) = options.get_truthy(global_this, "s3")? {
@@ -1798,7 +1772,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
         if let HTTPRequestBody::ReadableStream(ref readable_stream) = body {
             // we cannot direct stream to s3 we need to use multi part upload
-            // PORT NOTE: `defer body.ReadableStream.deinit()` → Drop on `body` scope exit.
+            // `defer body.ReadableStream.deinit()` → Drop on `body` scope exit.
 
             if method != Method::PUT && method != Method::POST {
                 return Ok(
@@ -1813,7 +1787,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             let promise = jsc::JSPromiseStrong::init(global_this);
             let promise_value = promise.value();
 
-            // PORT NOTE: `S3StreamWrapper.url` borrows `url_proxy_buffer`; box
+            // `S3StreamWrapper.url` borrows `url_proxy_buffer`; box
             // the buffer first (stable heap address) and re-parse so the
             // detached-lifetime slices remain valid after the Vec → Box move.
             let owned_buffer: Box<[u8]> = core::mem::take(&mut url_proxy_buffer).into_boxed_slice();
@@ -1838,18 +1812,17 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                 promise,
                 global: global_this,
             });
-            // Shim: Zig used `@ptrCast(&Wrapper.resolve)` to erase both the
-            // `*@This()` payload type and the `JSTerminated!void` error union when
-            // coercing to `?*const fn (S3UploadResult, *anyopaque) void`. In Rust we
-            // can't safely transmute away the `Result` return, so erase it explicitly.
+            // Shim: erases both the payload type and the `Result` return when
+            // coercing to the `fn (S3UploadResult, *mut c_void)` callback shape.
             fn s3_stream_wrapper_resolve(result: s3::S3UploadResult<'_>, ctx: *mut libc::c_void) {
                 // SAFETY: ctx was produced by `heap::alloc(s3_stream)` below; the
-                // 'static lifetime is a raw-pointer fiction matching the Zig @ptrCast.
+                // 'static lifetime is a raw-pointer fiction (the pointee's real
+                // lifetime is managed by the resolve callback itself).
                 let _ = S3StreamWrapper::resolve(result, ctx.cast::<S3StreamWrapper<'static>>());
             }
-            // Zig: `credentialsWithOptions.credentials.dupe()` — heap-allocate a
-            // fresh intrusive-refcounted copy. `upload_stream` adopts the ref by
-            // value (no extra bump) and the MultiPartUpload derefs on completion.
+            // `dupe()` heap-allocates a fresh intrusive-refcounted copy.
+            // `upload_stream` adopts the ref by value (no extra bump) and the
+            // MultiPartUpload derefs on completion.
             let _ = s3::upload_stream(
                 credentials_with_options.credentials.dupe(),
                 s3_path,
@@ -1866,7 +1839,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                 Some(s3_stream_wrapper_resolve),
                 bun_core::heap::into_raw(s3_stream).cast::<libc::c_void>(),
             )?;
-            // PORT NOTE: url/url_proxy_buffer ownership moved into s3_stream above.
+            // url/url_proxy_buffer ownership moved into s3_stream above.
             return Ok(promise_value);
         }
         if method == Method::POST {
@@ -1891,19 +1864,14 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
                 );
             }
         };
-        // PORT NOTE: `defer result.deinit()` → Drop.
+        // `defer result.deinit()` → Drop.
 
         if let Some(proxy_) = &proxy {
             // proxy and url are in the same buffer lets replace it
             let old_buffer = core::mem::take(&mut url_proxy_buffer);
-            // PORT NOTE: `defer allocator.free(old_buffer)` → drop(old_buffer) at end of scope.
+            // `defer allocator.free(old_buffer)` → drop(old_buffer) at end of scope.
             let mut buffer = vec![0u8; result.url.len() + proxy_.href.len()];
             buffer[0..result.url.len()].copy_from_slice(&result.url);
-            // PORT NOTE: upstream Zig (fetch.zig:1373) has `buffer[proxy_.href.len..]`
-            // which is an off-by-one typo — it only happens to not crash because
-            // `bun.copy` debug-asserts `dest.len >= src.len` rather than equality.
-            // `copy_from_slice` requires exact length, so we use the correct
-            // `result.url.len()` offset (the obvious upstream fix).
             buffer[result.url.len()..].copy_from_slice(proxy_.href);
             url_proxy_buffer = buffer;
 
@@ -1912,7 +1880,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
             drop(old_buffer);
         } else {
             // replace headers and url of the request
-            // PORT NOTE: allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
+            // allocator.free(url_proxy_buffer) — old Vec dropped on reassign.
             url_proxy_buffer = core::mem::take(&mut result.url).into();
             url = parse_url_detached!(&url_proxy_buffer[..]);
             // result.url = ""; — fetch now owns this (mem::take above)
@@ -1949,7 +1917,7 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
 
     let promise_val = promise.value();
 
-    // PORT NOTE: `FetchOptions.{url,proxy}` are `ZigURL<'static>` borrowing the
+    // `FetchOptions.{url,proxy}` are `ZigURL<'static>` borrowing the
     // `url_proxy_buffer: Box<[u8]>` stored alongside them — a self-referential
     // struct. `Vec::into_boxed_slice` may realloc when `cap > len` (the
     // proxy-string path above triggers this), so the existing `url`/`proxy`
@@ -2014,27 +1982,23 @@ fn fetch_impl<const ALLOW_GET_BODY: bool>(
         // see https://github.com/oven-sh/bun/issues/2985
         promise,
     );
-    // PORT NOTE: `catch |err| bun.handleOom(err)` — FetchTasklet::queue aborts on OOM.
+    // `catch |err| bun.handleOom(err)` — FetchTasklet::queue aborts on OOM.
 
-    // PORT NOTE: Zig followed with a debug ref-count assertion on `body.store()`
-    // and a `body.detach()` reset. With Rust move semantics `body` has been
-    // *moved* into `FetchOptions` (no shallow alias), so neither applies — the
-    // FetchTasklet now owns the single live reference.
+    // `body` has been *moved* into `FetchOptions`; the FetchTasklet now owns
+    // the single live reference.
 
     Ok(promise_val)
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// S3 ReadableStream upload Wrapper (was a fn-local struct in Zig)
-// PORT NOTE: hoisted to module level — Rust does not allow `impl` blocks
-// inside fn bodies for types referenced by external fn pointers.
+// S3 ReadableStream upload Wrapper — module level because Rust does not allow
+// `impl` blocks inside fn bodies for types referenced by external fn pointers.
 // ──────────────────────────────────────────────────────────────────────────
 
 struct S3StreamWrapper<'a> {
     promise: jsc::JSPromiseStrong,
     url: ZigURL<'a>,
     _url_proxy_buffer: Box<[u8]>,
-    // LIFETIMES.tsv: src/runtime/webcore/fetch.zig · Wrapper · global · JSC_BORROW → &JSGlobalObject
     global: &'a JSGlobalObject,
 }
 
@@ -2047,7 +2011,7 @@ impl<'a> S3StreamWrapper<'a> {
         // ownership here exactly once on the resolve callback.
         let mut self_ = unsafe { bun_core::heap::take(self_) };
         let global = self_.global;
-        // PORT NOTE: `defer bun.destroy(self)` + `defer free(url_proxy_buffer)` →
+        // `defer bun.destroy(self)` + `defer free(url_proxy_buffer)` →
         // Box<Self> and Box<[u8]> Drop at end of scope.
         match result {
             s3::S3UploadResult::Success => {
@@ -2103,8 +2067,6 @@ impl<'a> S3StreamWrapper<'a> {
 fn set_headers(headers: &mut Option<Headers>, new_headers: &[picohttp::Header]) {
     let old = headers.take();
     *headers = Some(Headers::from_pico_http_headers(new_headers));
-    // PORT NOTE: `if (old) |*h| h.deinit()` → Drop on `old`.
+    // `if (old) |*h| h.deinit()` → Drop on `old`.
     drop(old);
 }
-
-// ported from: src/runtime/webcore/fetch.zig
diff --git a/src/runtime/webcore/fetch/FetchTasklet.rs b/src/runtime/webcore/fetch/FetchTasklet.rs
index 80d9490a2c2..dbd9ba71d0d 100644
--- a/src/runtime/webcore/fetch/FetchTasklet.rs
+++ b/src/runtime/webcore/fetch/FetchTasklet.rs
@@ -37,7 +37,7 @@ use crate::webcore::{
 };
 
 use bun_jsc::JsTerminatedResult;
-// PORT NOTE: `bun_event_loop::JsResult` (cycle-broken erased error) — used by
+// `bun_event_loop::JsResult` (cycle-broken erased error) — used by
 // ConcurrentTask/AnyTask callbacks at the tier-3 layer.
 type ElJsResult<T> = bun_event_loop::JsResult<T>;
 
@@ -56,9 +56,9 @@ pub(crate) type ResumableSink = ResumableFetchSink;
 #[derive(bun_ptr::ThreadSafeRefCounted)]
 #[ref_count(destroy = FetchTasklet::deinit)]
 pub struct FetchTasklet {
-    // PORT NOTE: ResumableSink is intrusively refcounted (`ref_count: Cell<u32>` +
+    // ResumableSink is intrusively refcounted (`ref_count: Cell<u32>` +
     // heap::alloc); `Arc` can't be mutably borrowed for `cancel/drain`, so model
-    // as a raw pointer like Zig's `?*ResumableSink`.
+    // as a raw pointer.
     pub sink: Option<*mut ResumableSink>,
     // Self-referential: borrows from `request_body` / `request_headers` owned
     // by sibling fields, so the lifetime is erased to `'static`.
@@ -68,10 +68,9 @@ pub struct FetchTasklet {
     pub javascript_vm: &'static VirtualMachine,
     pub global_this: GlobalRef,
     pub request_body: HTTPRequestBody,
-    // PORT NOTE: ThreadSafeStreamBuffer is intrusively refcounted (`ref_count: AtomicU32`,
+    // ThreadSafeStreamBuffer is intrusively refcounted (`ref_count: AtomicU32`,
     // starts at 2) and shared with the HTTP thread via raw ptr; `Arc` can't be mutably
-    // borrowed for `acquire/release`. Model as a raw pointer like Zig's
-    // `?*http.ThreadSafeStreamBuffer`.
+    // borrowed for `acquire/release`. Model as a raw pointer.
     pub request_body_streaming_buffer: Option<core::ptr::NonNull<ThreadSafeStreamBuffer>>,
 
     /// buffer being used by AsyncHTTP
@@ -81,7 +80,7 @@ pub struct FetchTasklet {
     /// response weak ref we need this to track the response JS lifetime
     pub response: jsc::Weak<FetchTasklet>,
     /// native response ref if we still need it when JS is discarted
-    // PORT NOTE: Response is intrusively refcounted; raw ptr matches Zig `?*Response`.
+    // Response is intrusively refcounted; modeled as a raw ptr.
     pub native_response: Option<*mut Response>,
     pub ignore_data: bool,
     /// stream strong ref if any is available
@@ -100,8 +99,8 @@ pub struct FetchTasklet {
     /// We always clone url and proxy (if informed)
     pub url_proxy_buffer: Box<[u8]>,
 
-    // PORT NOTE: WebCore::AbortSignal is C++-refcounted (intrusive). Model as
-    // raw ptr like Zig's `?*AbortSignal`; ref/unref via `bun_jsc::AbortSignal`
+    // WebCore::AbortSignal is C++-refcounted (intrusive). Model as
+    // raw ptr; ref/unref via `bun_jsc::AbortSignal`
     // methods (see clear_abort_signal / queue).
     pub signal: Option<*mut AbortSignal>,
     pub signals: Signals,
@@ -139,7 +138,7 @@ pub enum HTTPRequestBody {
 
 impl Default for HTTPRequestBody {
     fn default() -> Self {
-        // PORT NOTE: Zig `= .{ .AnyBlob = .{} }`; `Blob` has no `const EMPTY`
+        // `Blob` has no `const EMPTY`
         // (non-Copy fields), so use the runtime `Default` instead of a const.
         HTTPRequestBody::AnyBlob(AnyBlob::Blob(Blob::default()))
     }
@@ -190,7 +189,7 @@ impl HTTPRequestBody {
         }
         if let BodyValue::Locked(locked) = &mut body_value {
             if locked.readable.has() {
-                // PORT NOTE: `BodyValue` now has `Drop` (H3), so we cannot move
+                // `BodyValue` now has `Drop` (H3), so we cannot move
                 // `l.readable` out by value (E0509). `mem::take` leaves a default
                 // readable; `Value::drop` on the residual `Locked` then runs
                 // `readable.deinit()` on that default — a no-op.
@@ -204,7 +203,7 @@ impl HTTPRequestBody {
             if !readable.is_empty_or_undefined_or_null() {
                 if let BodyValue::Locked(l) = &mut body_value {
                     if l.readable.has() {
-                        // See PORT NOTE above re: E0509 and `Value::drop`.
+                        // See note above re: E0509 and `Value::drop`.
                         return Ok(HTTPRequestBody::ReadableStream(core::mem::take(
                             &mut l.readable,
                         )));
@@ -412,18 +411,14 @@ impl FetchTasklet {
         );
     }
 
-    // PORT NOTE: ConcurrentTask::from_callback takes `fn(*mut T) -> bun_event_loop::JsResult<()>`
-    // (cycle-broken erased error); Zig coerced `error{}!void` automatically.
+    // ConcurrentTask::from_callback takes `fn(*mut T) -> bun_event_loop::JsResult<()>`
+    // (cycle-broken erased error).
     fn deinit_callback(this: *mut FetchTasklet) -> ElJsResult<()> {
         // SAFETY: enqueued with last ref; exclusive access on main thread
         unsafe { FetchTasklet::deinit(this) };
         Ok(())
     }
 
-    // PORT NOTE: Zig `pub fn init(_: std.mem.Allocator) anyerror!FetchTasklet { return FetchTasklet{}; }`
-    // was dead code — `FetchTasklet{}` would not compile if analyzed (promise/mutex/tracker lack
-    // defaults). All callers use `get()` directly. Dropped in the port.
-
     fn clear_sink(&mut self) {
         if let Some(sink) = self.sink.take() {
             // SAFETY: sink came from init_exact_refs; FetchTasklet holds one ref.
@@ -461,8 +456,7 @@ impl FetchTasklet {
             drop(certificate);
         }
 
-        // PORT NOTE: Zig `entries.deinit()` + `buf.deinit()`; Rust drop on
-        // assignment runs the same cleanup. MultiArrayList has no `clear()`.
+        // Drop on assignment runs the cleanup. MultiArrayList has no `clear()`.
         self.request_headers = Headers::default();
 
         if let Some(http_) = self.http.as_mut() {
@@ -497,7 +491,6 @@ impl FetchTasklet {
         self.clear_sink();
     }
 
-    // XXX: in Zig 'fn (*FetchTasklet) error{}!void' coerces to 'fn (*FetchTasklet) bun.JSError!void' but 'fn (*FetchTasklet) void' does not
     /// SAFETY: `this` must be the last reference (ref_count == 0) and have been allocated via heap::alloc.
     unsafe fn deinit(this: *mut FetchTasklet) {
         bun_output::scoped_log!(FetchTasklet, "deinit");
@@ -649,7 +642,7 @@ impl FetchTasklet {
             success,
             self.result.has_more
         );
-        // PORT NOTE: Zig `defer { if (buffer_reset) ...reset() }` runs on `try` failure paths too.
+        // The reset must run on `?` failure paths too.
         // Capture a raw ptr so the defer can reset on every exit (incl. `?`) without holding a
         // long-lived &mut borrow of self.
         let scheduled_buf: *mut MutableString = &raw mut self.scheduled_response_buffer;
@@ -662,11 +655,11 @@ impl FetchTasklet {
         }
 
         if !success {
-            // Zig: `var need_deinit = true; defer if (need_deinit) err.deinit();` — `ValueError`
+            // `ValueError`
             // has no `Drop` (it's reset-in-place, see Body.rs), so the Strong installed by
             // `to_js` would leak on the sink-cancel / no-response / `?` exits. Hold it in a
             // scopeguard and defuse via `into_inner` when ownership is transferred to
-            // `to_error_instance` (the `need_deinit = false` arm).
+            // `to_error_instance`.
             let mut err = scopeguard::guard(self.on_reject(), |mut e| e.reset());
             let mut js_err = JSValue::ZERO;
             // if we are streaming update with error
@@ -687,11 +680,11 @@ impl FetchTasklet {
             }
             // if we are buffering resolve the promise
             if let Some(response) = self.current_response_mut() {
-                // body value now owns the error (Zig: `need_deinit = false`)
+                // body value now owns the error
                 let err = scopeguard::ScopeGuard::into_inner(err);
                 let body = response.get_body_value();
-                // PORT NOTE: Body.rs aliases its `JsTerminated<T>` to `JsResult<T>` for
-                // now; narrow back to the real `JsTerminated` here (Zig: `try body.toErrorInstance`).
+                // Body.rs aliases its `JsTerminated<T>` to `JsResult<T>` for
+                // now; narrow back to the real `JsTerminated` here.
                 body.to_error_instance(err, &global_this)
                     .map_err(|_| bun_jsc::JsTerminated::JSTerminated)?;
             }
@@ -748,9 +741,9 @@ impl FetchTasklet {
             if !self.result.has_more {
                 let scheduled_response_buffer =
                     core::mem::take(&mut self.scheduled_response_buffer.list);
-                // PORT NOTE: `body` (&mut response.body.value) and `get_fetch_headers()`
+                // `body` (&mut response.body.value) and `get_fetch_headers()`
                 // (&response.init.headers) are disjoint fields, but borrowck can't see
-                // through the accessor methods. Hold `body` as a raw ptr (Zig pattern).
+                // through the accessor methods. Hold `body` as a raw ptr.
                 let body: *mut BodyValue = response.get_body_value();
                 // done resolve body
                 let old = core::mem::replace(
@@ -781,7 +774,7 @@ impl FetchTasklet {
                     // erase the borrow into a raw NonNull. Disjoint from `body` (response.init vs
                     // response.body) and outlives this block.
                     let headers = response.get_fetch_headers().map(core::ptr::NonNull::from);
-                    // PORT NOTE: Body.rs aliases its `JsTerminated<T>` to `JsResult<T>` for
+                    // Body.rs aliases its `JsTerminated<T>` to `JsResult<T>` for
                     // now; narrow back to the real `JsTerminated` here.
                     // SAFETY: `body` points into `response.body`, disjoint from `headers`
                     // (response.init); both live for this block.
@@ -820,7 +813,7 @@ impl FetchTasklet {
         }
 
         let global_this = self.global_this;
-        // PORT NOTE: reshaped for borrowck — Zig defer block split into explicit cleanup at each return
+        // explicit cleanup at each return (a closure keeps borrowck happy)
         let cleanup = |this: &mut FetchTasklet| {
             this.mutex.unlock();
             // if we are not done we wait until the next call
@@ -849,7 +842,7 @@ impl FetchTasklet {
         if self.is_waiting_request_stream_start && self.result.can_stream {
             // start streaming
             self.start_request_stream();
-            // Intentionally diverges from Zig: makes wpt-h2 number-chunk test deterministic.
+            // Makes wpt-h2 number-chunk test deterministic.
             // `assignStreamIntoResumableSink` kicks off `await reader.read()`; an invalid
             // chunk type (e.g. a JS number) throws inside `sink.write` and lands in
             // `writeEndRequest` → `abort_reason` on the next microtask. Drain now so the
@@ -989,8 +982,8 @@ impl FetchTasklet {
             return Ok(());
         }
 
-        // Intentionally diverges from Zig (paired with the microtask drain after
-        // startRequestStream above): the request-body sink may have set `abort_reason`
+        // Paired with the microtask drain after
+        // startRequestStream above: the request-body sink may have set `abort_reason`
         // via writeEndRequest while the HTTP result is still a success — server HEADERS
         // raced ahead of the scheduled shutdown. Reject with that reason instead of
         // resolving a 200 Response. Makes wpt-h2 number-chunk test deterministic.
@@ -1028,7 +1021,7 @@ impl FetchTasklet {
                 sink.cancel(err_js);
             }
             // `to_js` leaves `value` in the `JSValue(Strong)` state (Body.rs:547). Move
-            // that Strong out (Zig: `break :brk value.JSValue`) instead of allocating a
+            // that Strong out instead of allocating a
             // second one — `ValueError` has no `Drop`, so the inner Strong would leak.
             let BodyValueError::JSValue(strong) = value else {
                 unreachable!("ValueError::to_js leaves self in JSValue state");
@@ -1227,7 +1220,7 @@ impl FetchTasklet {
 
         if let Some(signal) = self.abort_signal() {
             if let Some(reason) = signal.reason_if_aborted(&self.global_this) {
-                // PORT NOTE: `AbortReason::to_body_value_error` lives in bun_jsc but
+                // `AbortReason::to_body_value_error` lives in bun_jsc but
                 // would forward-depend on bun_runtime; reconstruct the trivial
                 // mapping at the call site (per AbortSignal.rs note).
                 let out = match reason {
@@ -1249,8 +1242,8 @@ impl FetchTasklet {
             return;
         };
         // `signal` is a live C++-owned WebCore::AbortSignal*; we hold one ref
-        // (taken in `fetch.zig` before populating FetchOptions). Order matches Zig
-        // `clearAbortSignal`: cleanNativeBindings first, then defer{unref+pendingUnref}.
+        // (taken in `fetch.rs` before populating FetchOptions). Order matters:
+        // cleanNativeBindings first, then unref + pending_activity_unref.
         // S008: `AbortSignal` is an `opaque_ffi!` ZST — safe `*const → &`.
         let signal = bun_opaque::opaque_deref(signal);
         signal.clean_native_bindings(std::ptr::from_mut(self).cast::<c_void>());
@@ -1489,8 +1482,8 @@ impl FetchTasklet {
             )),
         };
 
-        // PORT NOTE: `jsc::SystemError` has no `Default` impl upstream — spell out
-        // every field with its Zig default (SystemError.zig:1).
+        // `jsc::SystemError` has no `Default` impl upstream — spell out
+        // every field's default.
         let fetch_error = jsc::SystemError {
             errno: 0,
             code,
@@ -1531,7 +1524,7 @@ impl FetchTasklet {
         }
 
         this.mutex.lock();
-        // PORT NOTE: Zig `defer this.mutex.unlock()` — reshaped to explicit unlock at each return
+        // explicit unlock at each return
         // (no `?` paths between lock and unlock, so a guard is unnecessary).
         let size_hint = this.get_size_hint();
 
@@ -1613,7 +1606,7 @@ impl FetchTasklet {
         let metadata = self.metadata.as_ref().unwrap();
         let http_response = &metadata.response;
         self.is_waiting_body = self.result.has_more;
-        // PORT NOTE: reshaped for borrowck — capture metadata fields before to_body_value() takes &mut self
+        // reshaped for borrowck — capture metadata fields before to_body_value() takes &mut self
         let headers = FetchHeaders::create_from_pico_headers(http_response.headers.list);
         let status_code = http_response.status_code as u16;
         // status_text and url must NOT be atomized: the Response can be
@@ -1707,14 +1700,12 @@ impl FetchTasklet {
         fetch_options: FetchOptions,
         promise: jsc::JSPromiseStrong,
     ) -> Result<*mut FetchTasklet, BunError> {
-        // TODO(port): narrow error set
         // SAFETY: bun_vm() returns the FFI `*mut VirtualMachine`; the VM outlives
         // this tasklet (process-lifetime singleton on the JS thread).
         let jsc_vm: &'static VirtualMachine = global_this.bun_vm();
         let mut fetch_tasklet = Box::new(FetchTasklet {
             sink: None,
-            // PORT NOTE: Zig used `bun.new(AsyncHTTP, undefined)` then `init()` below.
-            // Rust `AsyncHTTP` has no `Default`/zero-init; defer the Box until
+            // `AsyncHTTP` has no `Default`/zero-init; defer the Box until
             // `AsyncHTTP::init` produces the value.
             http: None,
             result: HTTPClientResult::default(),
@@ -1758,17 +1749,15 @@ impl FetchTasklet {
 
         fetch_tasklet.tracker.did_schedule(global_this);
 
-        // PORT NOTE: Zig followed with `if (request_body.store()) |store| store.ref()`.
-        // That +1 balanced fetch.zig's local `body` (bitwise-copied into `http_body`)
-        // calling `body.detach()` after `queue()` returned. In Rust, `body` is *moved*
-        // through `FetchOptions` into `request_body` (no shallow alias, no post-queue
-        // detach), so the StoreRef already carries the caller's +1 — bumping it again
-        // here leaked one ref per Blob-backed body (issue: fetch-leak fixture #5 RSS
-        // growth). `clear_data() → request_body.detach()` releases it.
+        // `body` is *moved* through `FetchOptions` into `request_body` (no
+        // shallow alias, no post-queue detach), so the StoreRef already carries
+        // the caller's +1 — bumping it again here leaked one ref per
+        // Blob-backed body (issue: fetch-leak fixture #5 RSS growth).
+        // `clear_data() → request_body.detach()` releases it.
         //
-        // NB: fixture-5's stream/iterator Promise-count overshoot is a pre-existing
-        // Zig spec bug (paused ResumableFetchSink ref-cycle when the server never
-        // reads the body), not a port divergence — tracked upstream.
+        // NB: fixture-5's stream/iterator Promise-count overshoot is a
+        // pre-existing bug (paused ResumableFetchSink ref-cycle when the server
+        // never reads the body).
 
         let mut url = fetch_options.url;
         let mut proxy: Option<ZigURL> = None;
@@ -1788,7 +1777,7 @@ impl FetchTasklet {
                 // env_proxy.href may be a slice into a RefCountedEnvValue's bytes which can
                 // be freed by a subsequent `process.env.HTTP_PROXY = "..."` assignment while
                 // this fetch is in flight on the HTTP thread. Clone it into url_proxy_buffer
-                // alongside the request URL — the same pattern fetch.zig uses for the explicit
+                // alongside the request URL — the same pattern used for the explicit
                 // `fetch(url, { proxy: "..." })` option.
                 if !env_proxy.href.is_empty() {
                     let old_url_len = url.href.len();
@@ -1810,7 +1799,6 @@ impl FetchTasklet {
                     let buf = unsafe { &*buf_ptr };
                     url = ZigURL::parse(&buf[0..old_url_len]);
                     proxy = Some(ZigURL::parse(&buf[old_url_len..]));
-                    // TODO(port): self-referential borrow into url_proxy_buffer; needs raw ptr or owned URL.
                 } else {
                     proxy = Some(env_proxy);
                 }
@@ -1831,9 +1819,9 @@ impl FetchTasklet {
         let fetch_tasklet = unsafe { &mut *fetch_tasklet_ptr };
 
         // This task gets queued on the HTTP thread.
-        // PORT NOTE: `AsyncHTTP::init` takes several `&'static [u8]` borrows
-        // (headers_buf, request_body, hostname) that in Zig were plain slices
-        // into FetchTasklet-owned storage. The tasklet is now heap-pinned via
+        // `AsyncHTTP::init` takes several `&'static [u8]` borrows
+        // (headers_buf, request_body, hostname) that point into
+        // FetchTasklet-owned storage. The tasklet is heap-pinned via
         // `heap::alloc`, so erase the borrow lifetimes through raw pointers.
         // SAFETY: `fetch_tasklet_ptr` is a stable heap allocation that outlives
         // the AsyncHTTP (dropped together in `deinit`); the slices below borrow
@@ -1860,11 +1848,10 @@ impl FetchTasklet {
             // SAFETY: see block note above — same `FetchTasklet` owner.
             .map(|s| unsafe { bun_ptr::Interned::assume(s) }.as_bytes());
         let response_buffer: *mut MutableString = &raw mut fetch_tasklet.response_buffer;
-        // PORT NOTE: Zig passed `fetch_options.headers.entries` by value (shallow
-        // struct copy → shared backing storage). `MultiArrayList` in Rust owns its
+        // `MultiArrayList` owns its
         // allocation, so clone; AsyncHTTP::init clones again for the client.
         let header_entries = bun_core::handle_oom(fetch_tasklet.request_headers.entries.clone());
-        // PORT NOTE: `url` is moved into `AsyncHTTP::init`; capture the one
+        // `url` is moved into `AsyncHTTP::init`; capture the one
         // post-move query (`is_http()`, debug-assert only) up front.
         let url_is_http = url.is_http();
 
@@ -1913,7 +1900,7 @@ impl FetchTasklet {
         fetch_tasklet.is_waiting_request_stream_start = is_stream;
         if is_stream {
             // Intrusive `ref_count` starts at 2 (one for the main thread, one for the HTTP
-            // thread) so handing the same raw pointer to both sides matches Zig's ownership.
+            // thread), so the same raw pointer can be handed to both sides.
             let buffer = ThreadSafeStreamBuffer::new(ThreadSafeStreamBuffer::default());
             // SAFETY: fresh heap allocation from `ThreadSafeStreamBuffer::new` (heap::alloc);
             // exclusively owned here until shared below.
@@ -1958,7 +1945,6 @@ impl FetchTasklet {
         if let Some(signal) = fetch_tasklet.signal {
             // `signal` is a live C++-owned WebCore::AbortSignal* (already ref'd by
             // the caller before populating `fetch_options.signal`).
-            // Zig: `signal.pendingActivityRef(); fetch_tasklet.signal = signal.listen(...)`.
             // `add_listener` returns `self`, so the field already holds the right ptr.
             // S008: `AbortSignal` is an `opaque_ffi!` ZST — safe `*const → &`.
             let signal = bun_opaque::opaque_deref(signal);
@@ -2010,7 +1996,6 @@ impl FetchTasklet {
     }
 
     /// This is ALWAYS called from the main thread
-    // PORT NOTE: in Zig 'fn (*FetchTasklet) error{}!void' coerces to 'fn (*FetchTasklet) bun.JSError!void';
     // ConcurrentTask::from_callback expects `fn(*mut T) -> bun_event_loop::JsResult<()>`.
     pub(crate) fn resume_request_data_stream(this: *mut FetchTasklet) -> ElJsResult<()> {
         let this_ref = Self::from_raw_mut(this);
@@ -2046,7 +2031,7 @@ impl FetchTasklet {
         if self.signal_aborted() {
             return ResumableSinkBackpressure::Done;
         }
-        // PORT NOTE: reshaped for borrowck — read sink HWM (Copy) before
+        // reshaped for borrowck — read sink HWM (Copy) before
         // borrowing the stream buffer so `self` is unborrowed during the
         // mutex critical section below.
         let high_water_mark: usize = match self.sink_mut() {
@@ -2064,7 +2049,7 @@ impl FetchTasklet {
         // if we have backpressure the onWritable will drain the buffer
         let needs_schedule = stream_buffer.is_empty();
         if self.skip_chunked_framing() {
-            let _ = stream_buffer.write(data); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = stream_buffer.write(data); // OOM/capacity: fire-and-forget
         } else {
             //16 is the max size of a hex number size that represents 64 bits + 2 for the \r\n
             let mut formated_size_buffer = [0u8; 18];
@@ -2075,8 +2060,7 @@ impl FetchTasklet {
                 let written = 18 - cursor.len();
                 &formated_size_buffer[..written]
             };
-            let _ = stream_buffer.ensure_unused_capacity(formated_size.len() + data.len() + 2); // OOM/capacity: Zig aborts; port keeps fire-and-forget
-            // PERF(port): was assume_capacity
+            let _ = stream_buffer.ensure_unused_capacity(formated_size.len() + data.len() + 2); // OOM/capacity: fire-and-forget
             stream_buffer.write_assume_capacity(formated_size);
             stream_buffer.write_assume_capacity(data);
             stream_buffer.write_assume_capacity(b"\r\n");
@@ -2125,7 +2109,7 @@ impl FetchTasklet {
                 // the lock guard drops.
                 let _ = thread_safe_stream_buffer
                     .lock()
-                    .write(http::END_OF_CHUNKED_HTTP1_1_ENCODING_RESPONSE_BODY); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                    .write(http::END_OF_CHUNKED_HTTP1_1_ENCODING_RESPONSE_BODY); // OOM/capacity: fire-and-forget
             }
             if let Some(http_) = self.http.as_mut() {
                 http::http_thread()
@@ -2150,7 +2134,6 @@ impl FetchTasklet {
         fetch_options: FetchOptions,
         promise: jsc::JSPromiseStrong,
     ) -> Result<*mut FetchTasklet, BunError> {
-        // TODO(port): narrow error set
         http::http_thread::init(&http::http_thread::InitOpts::default());
         let node = Self::get(global, fetch_options, promise)?;
 
@@ -2186,11 +2169,11 @@ impl FetchTasklet {
 
         task_ref.mutex.lock();
         // we need to unlock before task.deref();
-        // PORT NOTE: reshaped for borrowck — explicit unlock + deref at end instead of nested defers
-        // Zig: `task.http.?.* = async_http.*; task.http.?.response_buffer = async_http.response_buffer;`
-        // — bitwise struct copy of HTTP-thread state back into the JS-side instance.
-        // `AsyncHTTP` is not `Copy` in Rust (`HTTPClient: Drop`, owned Vecs), so use the
-        // explicit field-subset sync; see `AsyncHTTP::sync_progress_from` for the field list.
+        // explicit unlock + deref at end instead of nested defers.
+        // Sync HTTP-thread state back into the JS-side instance via an
+        // explicit field-subset copy (`AsyncHTTP` is not `Copy`:
+        // `HTTPClient: Drop`, owned Vecs); see `AsyncHTTP::sync_progress_from`
+        // for the field list.
         // SAFETY: `async_http` is the HTTP-thread copy passed by `on_async_http_callback`;
         // it is alive for the duration of this call and not mutated concurrently (HTTP
         // thread is blocked in the callback).
@@ -2209,8 +2192,7 @@ impl FetchTasklet {
             result.body.as_ref().map(|b| b.list.len()).unwrap_or(0)
         );
 
-        // Zig: `task.response_buffer = result.body.?.*` — verify the aliasing invariant
-        // that makes that bitwise copy a no-op (see PORT NOTE below at the original site).
+        // Verify the aliasing invariant (see comment below).
         debug_assert!(
             result
                 .body
@@ -2224,8 +2206,8 @@ impl FetchTasklet {
         let prev_can_stream = task_ref.result.can_stream;
         // SAFETY: lifetime erasure — `HTTPClientResult<'a>` borrows the
         // `*mut MutableString` we passed into `AsyncHTTP::init` (which lives
-        // in `self.response_buffer` for the FetchTasklet's lifetime). Zig had
-        // no lifetime here; widen `'_` → `'static` to store it.
+        // in `self.response_buffer` for the FetchTasklet's lifetime); widen
+        // `'_` → `'static` to store it.
         task_ref.result = unsafe { result.detach_lifetime() };
         // can_stream is a one-shot signal to start the request body stream; don't let a
         // later coalesced result clobber it before the JS thread sees it.
@@ -2251,8 +2233,7 @@ impl FetchTasklet {
         task_ref.body_size = task_ref.result.body_size;
 
         let success = task_ref.result.is_success();
-        // PORT NOTE: Zig `task.response_buffer = result.body.?.*` is a bitwise self-copy of
-        // the Vec header — `result.body` always aliases `task_ref.response_buffer` (the
+        // `result.body` always aliases `task_ref.response_buffer` (the
         // `*mut MutableString` passed to `AsyncHTTP::init` at FetchTasklet::create flows
         // through `HTTPClient.state.body_out_str` and back out in the result). Asserted
         // above before the lifetime-erasing assignment; the bytes are already in place, so
@@ -2420,10 +2401,10 @@ pub struct FetchOptions {
 
 impl Default for FetchOptions {
     fn default() -> Self {
-        // PORT NOTE: Zig FetchOptions had per-field defaults for the optional half of the struct;
-        // the required fields (method/headers/body/url/bools/unix_socket_path/globalThis) had none.
-        // We supply zero-values for those so callers can use `..Default::default()` struct-update
-        // syntax while still overriding the required fields explicitly.
+        // Zero-values for the required fields
+        // (method/headers/body/url/bools/unix_socket_path/globalThis) so
+        // callers can use `..Default::default()` struct-update syntax while
+        // still overriding the required fields explicitly.
         Self {
             method: Method::GET,
             headers: Headers::default(),
@@ -2453,5 +2434,3 @@ impl Default for FetchOptions {
         }
     }
 }
-
-// ported from: src/runtime/webcore/fetch/FetchTasklet.zig
diff --git a/src/runtime/webcore/prompt.rs b/src/runtime/webcore/prompt.rs
index e1199a576c7..480245da05c 100644
--- a/src/runtime/webcore/prompt.rs
+++ b/src/runtime/webcore/prompt.rs
@@ -16,7 +16,6 @@ fn alert(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
 
     // 2. If the method was invoked with no arguments, then let message be the empty string; otherwise, let message be the method's first argument.
     if has_message {
-        // PERF(port): was stack-fallback (2048 bytes) — profile if it shows up on a hot path.
         let message = arguments[0].to_slice(global)?;
 
         if !message.slice().is_empty() {
@@ -51,7 +50,6 @@ fn alert(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     Output::flush();
 
     // 7. Optionally, pause while waiting for the user to acknowledge the message.
-    // Zig: `std.fs.File.stdin().readerStreaming(&[1]u8)` — unbuffered byte reader.
     let mut reader = Output::stdin_reader();
     loop {
         let Ok(byte) = reader.take_byte() else { break };
@@ -74,7 +72,6 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     let has_message = !arguments.is_empty();
 
     if has_message {
-        // PERF(port): was stack-fallback (1024 bytes) — profile if it shows up on a hot path.
         // 2. Set message to the result of normalizing newlines given message.
         // *  Not pertinent to a server runtime so we will just let the terminal handle this.
 
@@ -108,7 +105,6 @@ fn confirm(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     Output::flush();
 
     // 6. Pause until the user responds either positively or negatively.
-    // Zig: `std.fs.File.stdin().readerStreaming(&[1024]u8)` — byte reader.
     let mut reader = Output::stdin_reader();
 
     let Ok(first_byte) = reader.take_byte() else {
@@ -177,8 +173,7 @@ pub mod prompt {
         Io,
     }
 
-    /// `reader: anytype` in the Zig — the only method called is `readByte()`.
-    /// Bound on a small trait exposing `read_byte() -> Result<u8, _>`; the only
+    /// Small trait exposing `read_byte() -> Result<u8, _>`; the only
     /// concrete impl is the process-global `BufferedStdin`.
     pub trait ReadByte {
         type Error;
@@ -193,8 +188,8 @@ pub mod prompt {
         }
     }
 
-    /// Adapted from `std.io.Reader.readUntilDelimiterArrayList` to only append
-    /// and assume capacity.
+    /// Reads bytes until `delimiter` (exclusive), erroring with `StreamTooLong`
+    /// once `max_size` bytes have been appended.
     pub fn read_until_delimiter_array_list_append_assume_capacity<R: ReadByte>(
         reader: &mut R,
         array_list: &mut Vec<u8>,
@@ -212,13 +207,12 @@ pub mod prompt {
                 return Ok(());
             }
 
-            // PERF(port): was assume_capacity
             array_list.push(byte);
         }
     }
 
-    /// Adapted from `std.io.Reader.readUntilDelimiterArrayList` to always append
-    /// and not resize.
+    /// Reads bytes until `delimiter` (exclusive), appending to `array_list`
+    /// with no size limit.
     fn read_until_delimiter_array_list_infinity<R: ReadByte>(
         reader: &mut R,
         array_list: &mut Vec<u8>,
@@ -240,7 +234,6 @@ pub mod prompt {
     pub(crate) fn call(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         let arguments = frame.arguments_old::<3>();
         let arguments = arguments.slice();
-        // PERF(port): was stack-fallback (2048 bytes) — profile if it shows up on a hot path.
         let output = Output::writer();
         let has_message = !arguments.is_empty();
         let has_default = arguments.len() >= 2;
@@ -339,14 +332,10 @@ pub mod prompt {
             }
         }
 
-        // PERF(port): was stack-fallback allocator backing this Vec
         let mut input: Vec<u8> = Vec::with_capacity(2048);
-        // Note: Zig returned `.null` on OOM here; Rust `Vec::with_capacity` aborts on OOM.
 
-        // PERF(port): was assume_capacity
         input.push(first_byte);
         if let Some(second) = second_byte {
-            // PERF(port): was assume_capacity
             input.push(second);
         }
 
@@ -367,7 +356,6 @@ pub mod prompt {
             }
 
             input.ensure_total_capacity(4096);
-            // Note: Zig returned `.null` on OOM here; Rust `reserve` aborts on OOM.
 
             if let Err(e2) = read_until_delimiter_array_list_append_assume_capacity(
                 &mut *reader,
diff --git a/src/runtime/webcore/s3/client.rs b/src/runtime/webcore/s3/client.rs
index 1f48ec8e142..9f3778cdd3a 100644
--- a/src/runtime/webcore/s3/client.rs
+++ b/src/runtime/webcore/s3/client.rs
@@ -10,7 +10,7 @@ use bun_jsc::{GlobalRef, JSGlobalObject, JSValue, JsResult, StringJsc};
 
 use bun_core::strings;
 
-// Re-exports (thin aliases matching the Zig file's top-level `pub const X = @import(...)`)
+// Re-exports (thin aliases)
 pub use crate::webcore::s3::download_stream::S3HttpDownloadStreamingTask;
 pub use crate::webcore::s3::multipart::{self, MultiPartUpload};
 pub use crate::webcore::s3::multipart_options::MultiPartUploadOptions;
@@ -18,10 +18,10 @@ pub use bun_s3_signing::acl::ACL;
 pub use bun_s3_signing::storage_class::StorageClass;
 
 pub use bun_s3_signing::error as Error;
-// PORT NOTE: `throwSignError` / `getJSSignError` live in `error_jsc.zig` (jsc-side
+// `throw_sign_error` / `get_js_sign_error` live in `error_jsc.rs` (jsc-side
 // of the s3_signing error tables). The pure error module is `bun_s3_signing::error`;
-// the jsc helpers are mounted here as a child module so the umbrella re-export hub
-// matches the Zig `s3/client.zig` shape.
+// the jsc helpers are mounted here as a child module of this umbrella
+// re-export hub.
 #[path = "error_jsc.rs"]
 pub mod error_jsc;
 pub use error_jsc::S3ErrorJsc;
@@ -178,10 +178,9 @@ pub(crate) fn delete(
 
 pub(crate) fn list_objects(
     this: &S3Credentials,
-    // PORT NOTE: Zig took `S3ListObjectsOptions` by-value (implicit struct
-    // copy at the call site). The Rust struct owns `Utf8Slice`s and is not
+    // The struct owns `Utf8Slice`s and is not
     // `Clone`, but this fn only reads fields synchronously to build the
-    // search-params string — borrow instead so the caller (Store::S3::
+    // search-params string — borrow so the caller (Store::S3::
     // list_objects) can retain ownership in its async Wrapper for `Drop`.
     list_options: &S3ListObjectsOptions,
     callback: fn(S3ListObjectsResult, *mut c_void) -> JsTerminatedResult<()>,
@@ -190,37 +189,37 @@ pub(crate) fn list_objects(
 ) -> JsTerminatedResult<()> {
     let mut search_params: Vec<u8> = Vec::<u8>::default();
 
-    let _ = search_params.append_slice(b"?"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+    let _ = search_params.append_slice(b"?"); // OOM/capacity: fire-and-forget
 
-    if let Some(continuation_token) = list_options.continuation_token.as_deref() {
+    if let Some(continuation_token) = list_options.continuation_token.as_ref().map(|s| s.slice()) {
         let mut buff = vec![0u8; continuation_token.len() * 3];
         let encoded =
             encode_uri_component::<true>(continuation_token, &mut buff).expect("unreachable");
-        // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        // OOM/capacity: fire-and-forget
         let _ = search_params.append_fmt(format_args!(
             "continuation-token={}",
             bstr::BStr::new(encoded)
         ));
     }
 
-    if let Some(delimiter) = list_options.delimiter.as_deref() {
+    if let Some(delimiter) = list_options.delimiter.as_ref().map(|s| s.slice()) {
         let mut buff = vec![0u8; delimiter.len() * 3];
         let encoded = encode_uri_component::<true>(delimiter, &mut buff).expect("unreachable");
 
         if list_options.continuation_token.is_some() {
             let _ =
-                search_params.append_fmt(format_args!("&delimiter={}", bstr::BStr::new(encoded))); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                search_params.append_fmt(format_args!("&delimiter={}", bstr::BStr::new(encoded))); // OOM/capacity: fire-and-forget
         } else {
             let _ =
-                search_params.append_fmt(format_args!("delimiter={}", bstr::BStr::new(encoded))); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+                search_params.append_fmt(format_args!("delimiter={}", bstr::BStr::new(encoded))); // OOM/capacity: fire-and-forget
         }
     }
 
     if list_options.encoding_type.is_some() {
         if list_options.continuation_token.is_some() || list_options.delimiter.is_some() {
-            let _ = search_params.append_slice(b"&encoding-type=url"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = search_params.append_slice(b"&encoding-type=url"); // OOM/capacity: fire-and-forget
         } else {
-            let _ = search_params.append_slice(b"encoding-type=url"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = search_params.append_slice(b"encoding-type=url"); // OOM/capacity: fire-and-forget
         }
     }
 
@@ -229,9 +228,9 @@ pub(crate) fn list_objects(
             || list_options.delimiter.is_some()
             || list_options.encoding_type.is_some()
         {
-            let _ = search_params.append_fmt(format_args!("&fetch-owner={}", fetch_owner)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = search_params.append_fmt(format_args!("&fetch-owner={}", fetch_owner)); // OOM/capacity: fire-and-forget
         } else {
-            let _ = search_params.append_fmt(format_args!("fetch-owner={}", fetch_owner)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+            let _ = search_params.append_fmt(format_args!("fetch-owner={}", fetch_owner)); // OOM/capacity: fire-and-forget
         }
     }
 
@@ -240,25 +239,25 @@ pub(crate) fn list_objects(
         || list_options.encoding_type.is_some()
         || list_options.fetch_owner.is_some()
     {
-        let _ = search_params.append_slice(b"&list-type=2"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = search_params.append_slice(b"&list-type=2"); // OOM/capacity: fire-and-forget
     } else {
-        let _ = search_params.append_slice(b"list-type=2"); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = search_params.append_slice(b"list-type=2"); // OOM/capacity: fire-and-forget
     }
 
     if let Some(max_keys) = list_options.max_keys {
-        let _ = search_params.append_fmt(format_args!("&max-keys={}", max_keys)); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = search_params.append_fmt(format_args!("&max-keys={}", max_keys)); // OOM/capacity: fire-and-forget
     }
 
-    if let Some(prefix) = list_options.prefix.as_deref() {
+    if let Some(prefix) = list_options.prefix.as_ref().map(|s| s.slice()) {
         let mut buff = vec![0u8; prefix.len() * 3];
         let encoded = encode_uri_component::<true>(prefix, &mut buff).expect("unreachable");
-        let _ = search_params.append_fmt(format_args!("&prefix={}", bstr::BStr::new(encoded))); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = search_params.append_fmt(format_args!("&prefix={}", bstr::BStr::new(encoded))); // OOM/capacity: fire-and-forget
     }
 
-    if let Some(start_after) = list_options.start_after.as_deref() {
+    if let Some(start_after) = list_options.start_after.as_ref().map(|s| s.slice()) {
         let mut buff = vec![0u8; start_after.len() * 3];
         let encoded = encode_uri_component::<true>(start_after, &mut buff).expect("unreachable");
-        let _ = search_params.append_fmt(format_args!("&start-after={}", bstr::BStr::new(encoded))); // OOM/capacity: Zig aborts; port keeps fire-and-forget
+        let _ = search_params.append_fmt(format_args!("&start-after={}", bstr::BStr::new(encoded))); // OOM/capacity: fire-and-forget
     }
 
     let result = match this.sign_request::<true>(
@@ -299,7 +298,7 @@ pub(crate) fn list_objects(
     let headers = bun_http::Headers::from_pico_http_headers(result.headers());
 
     let task_ptr = bun_core::heap::into_raw(Box::new(S3HttpSimpleTask {
-        // Zig used `= undefined`; written below via `MaybeUninit::write` before any read.
+        // Written below via `MaybeUninit::write` before any read.
         http: core::mem::MaybeUninit::uninit(),
         range: None,
         sign_result: result,
@@ -311,6 +310,7 @@ pub(crate) fn list_objects(
         result: bun_http::HTTPClientResult::default(),
         concurrent_task: Default::default(),
         proxy_url: Box::default(),
+        body: Box::default(),
         poll_ref: bun_io::KeepAlive::init(),
     }));
     // SAFETY: just allocated, non-null
@@ -431,7 +431,7 @@ pub(crate) fn writable_stream(
     storage_class: Option<StorageClass>,
     request_payer: bool,
 ) -> JsResult<JSValue> {
-    // Local callback wrapper (Zig: `const Wrapper = struct { pub fn callback(...) }`)
+    // Local callback wrapper
     fn wrapper_callback(result: S3UploadResult, sink: &mut NetworkSink) -> JsTerminatedResult<()> {
         // `global_this` is a `BackRef` set at construction; copy it so the
         // re-borrow does not hold `&sink` across the `&mut sink` calls below.
@@ -443,7 +443,7 @@ pub(crate) fn writable_stream(
             // SAFETY: `bun_vm()` returns the live per-thread VM pointer.
             let event_loop = global.bun_vm().as_mut().event_loop();
             // SAFETY: event_loop is initialised for the lifetime of the VM.
-            // RAII: `enter()` now, `exit()` on drop (Zig: `defer event_loop.exit()`).
+            // RAII: `enter()` now, `exit()` on drop.
             let _exit_guard = unsafe { bun_jsc::event_loop::EventLoop::enter_scope(event_loop) };
             match result {
                 S3UploadResult::Success => {
@@ -474,7 +474,7 @@ pub(crate) fn writable_stream(
     }
 
     // Thunks adapting typed callbacks to the erased `*mut c_void` signatures stored on
-    // MultiPartUpload (Zig used `@ptrCast` on the fn ptrs directly).
+    // MultiPartUpload.
     fn wrapper_callback_thunk(result: S3UploadResult, ctx: *mut c_void) -> JsTerminatedResult<()> {
         // SAFETY: ctx was set to `response_stream: *mut NetworkSink` below.
         wrapper_callback(result, unsafe { bun_ptr::callback_ctx::<NetworkSink>(ctx) })
@@ -492,7 +492,7 @@ pub(crate) fn writable_stream(
     // `credentials` ref adopted by value — moved into the MultiPartUpload below.
     // JSC_BORROW: `global_this` outlives the task (it owns the VM/heap that owns the JS
     // objects which keep the task alive); stored via `GlobalRef` in the heap-allocated
-    // MultiPartUpload, matching the Zig pointer field.
+    // MultiPartUpload.
     let global_static = GlobalRef::from(global_this);
     let part_size = options.part_size;
     let task_ptr: *mut MultiPartUpload = bun_core::heap::into_raw(Box::new(MultiPartUpload {
@@ -509,8 +509,7 @@ pub(crate) fn writable_stream(
         poll_ref: KeepAlive::init(),
         // SAFETY (JSC_BORROW): VirtualMachine::get() returns the live per-thread VM; it
         // outlives every MultiPartUpload (the VM owns the heap that owns the JS objects
-        // keeping this task alive). Dereference to `&'static` for storage, matching the
-        // Zig pointer field.
+        // keeping this task alive). Dereference to `&'static` for storage.
         vm: VirtualMachine::get(),
         global_this: global_static,
         buffered: StreamBuffer::default(),
@@ -537,7 +536,7 @@ pub(crate) fn writable_stream(
 
     task.poll_ref.ref_(bun_io::js_vm_ctx());
 
-    // `NetworkSink.new(.{...}).toSink()` — heap-allocate; `JSSink<NetworkSink>` is layout-
+    // Heap-allocate; `JSSink<NetworkSink>` is layout-
     // compatible (`{ sink: NetworkSink }`) so the cast in `to_sink()` is just a pointer reinterpret.
     let response_stream: *mut NetworkSink =
         bun_core::heap::into_raw(NetworkSink::new(NetworkSink {
@@ -579,7 +578,6 @@ pub struct S3UploadStreamWrapper {
 /// finalizer body when the last ref is released.
 pub type S3UploadStreamWrapperRef = *mut S3UploadStreamWrapper;
 
-// Zig: `pub const ResumableSink = @import("../ResumableSink.zig").ResumableS3UploadSink;`
 // Inherent associated types are unstable; expose as a module-level alias instead.
 pub(crate) type ResumableSink = ResumableS3UploadSink;
 
@@ -646,7 +644,7 @@ impl S3UploadStreamWrapper {
     pub(crate) fn write_end_request(&mut self, err: Option<JSValue>) {
         bun_output::scoped_log!(S3UploadStream, "writeEndRequest {}", err.is_some());
         self.detach_sink();
-        // PORT NOTE: reshaped for borrowck — Zig used `defer this.deref()`
+        // scope-exit deref via guard (keeps borrowck happy)
         let _deref_guard = scopeguard::guard(std::ptr::from_mut::<Self>(self), |s| {
             // SAFETY: s points to self which is alive for the duration of the guard; deref_
             // decrements ref_count and may free self only after all borrows above are released
@@ -667,14 +665,14 @@ impl S3UploadStreamWrapper {
                 }); // TODO: properly propagate exception upwards
             }
         } else {
-            // Zig spec: `_ = bun.handleOom(this.task.writeBytes("", true))` — abort on OOM.
+            // abort on OOM
             let _ = self.task_mut().write_bytes(b"", true).expect("OOM");
         }
     }
 
     pub(crate) fn resolve(result: S3UploadResult, self_: &mut Self) -> JsTerminatedResult<()> {
         bun_output::scoped_log!(S3UploadStream, "resolve");
-        // PORT NOTE: reshaped for borrowck — Zig used `defer self.deref()`
+        // scope-exit deref via guard (keeps borrowck happy)
         let _deref_guard = scopeguard::guard(std::ptr::from_mut::<Self>(self_), |s| {
             // SAFETY: s points to self_ which is alive for the duration of the guard; deref_
             // decrements ref_count and may free self only after all borrows above are released
@@ -724,7 +722,7 @@ impl ResumableSinkContext for S3UploadStreamWrapper {
 }
 
 impl Drop for S3UploadStreamWrapper {
-    /// Zig: `fn deinit(this: *@This())` — RefCount finalizer body. Allocation is freed by
+    /// RefCount finalizer body. Allocation is freed by
     /// `deref_()` when the last ref is dropped; this `Drop` only handles side effects.
     fn drop(&mut self) {
         bun_output::scoped_log!(S3UploadStream, "deinit {}", self.sink.is_some());
@@ -778,9 +776,9 @@ pub fn upload_stream(
             )
             .to_js());
         }
-        // TODO(port): Zig used `inline .File, .Bytes => |stream|` — File/Bytes payload types
-        // differ (`*FileReader` vs `*ByteStream`), so the inline-captured `stream` has different
-        // types per arm. Manual unroll once both have a `.pending` accessor.
+        // The File/Bytes payload types
+        // differ (`*FileReader` vs `*ByteStream`), so the arms are
+        // unrolled here.
         ReadableStreamPtr::Bytes(_) => {
             // BACKREF: see `Source::bytes()` — payload live while the
             // ReadableStream JS wrapper is rooted. R-2: `pending` is `JsCell`.
@@ -841,7 +839,7 @@ pub fn upload_stream(
     }
 
     // Thunks adapting typed callbacks to the erased `*mut c_void` signatures stored on
-    // MultiPartUpload (Zig used `@ptrCast` on the fn ptrs directly).
+    // MultiPartUpload.
     fn resolve_thunk(result: S3UploadResult, ctx: *mut c_void) -> JsTerminatedResult<()> {
         // SAFETY: ctx was set to `*mut S3UploadStreamWrapper` below.
         S3UploadStreamWrapper::resolve(result, unsafe {
@@ -857,12 +855,8 @@ pub fn upload_stream(
         );
     }
 
-    // PORT NOTE: Zig calls `this.ref()` *before* the is_disturbed/Invalid/pending-err early
-    // returns above (client.zig:465), leaking a credential ref on every early-return path.
-    // Here `credentials` is owned-by-value and explicitly `.deref()`ed on each early
-    // return — strictly an improvement.
-    //
-    // `credentials` ref adopted by value — moved into the MultiPartUpload below.
+    // `credentials` is owned-by-value and explicitly `.deref()`ed on each early
+    // return above; the ref is adopted by value — moved into the MultiPartUpload below.
     // SAFETY (JSC_BORROW): see `writable_stream` for rationale.
     let global_static = GlobalRef::from(global_this);
     let task_ptr: *mut MultiPartUpload = bun_core::heap::into_raw(Box::new(MultiPartUpload {
@@ -878,8 +872,7 @@ pub fn upload_stream(
         credentials,
         poll_ref: KeepAlive::init(),
         // SAFETY (JSC_BORROW): VirtualMachine::get() returns the live per-thread VM; it
-        // outlives every MultiPartUpload. Dereference to `&'static` for storage, matching
-        // the Zig pointer field.
+        // outlives every MultiPartUpload. Dereference to `&'static` for storage.
         vm: VirtualMachine::get(),
         global_this: global_static,
         buffered: StreamBuffer::default(),
@@ -1038,7 +1031,7 @@ pub(crate) fn download_stream(
             response_buffer: MutableString::default(),
             mutex: Default::default(),
             reported_response_buffer: MutableString::default(),
-            // Zig: `state: State.AtomicType = .init(@bitCast(State{}))` — `State{}` defaults
+            // `State::default()` sets
             // `has_more = true` (bit 48). Passing 0 here would start the task with
             // `has_more == false`, tripping the `assert(state.has_more)` in
             // `process_http_callback` on the very first HTTP-thread callback.
@@ -1143,7 +1136,7 @@ pub fn readable_stream(
             request_err: Option<Error::S3Error>,
             self_: &mut Self,
         ) -> JsTerminatedResult<()> {
-            // PORT NOTE: reshaped for borrowck — Zig used `defer if (!has_more) self.deinit()`
+            // scope-exit cleanup via guard (keeps borrowck happy)
             let _guard = scopeguard::guard(std::ptr::from_mut::<Self>(self_), move |s| {
                 if !has_more {
                     // SAFETY: s is a live Box-allocated pointer (heap::alloc in S3DownloadStreamWrapper::new);
@@ -1236,7 +1229,7 @@ pub fn readable_stream(
     }
 
     impl Drop for S3DownloadStreamWrapper {
-        /// Zig: `fn deinit(self: *@This())`. readable_stream_ref / path are freed by their own field Drop.
+        /// readable_stream_ref / path are freed by their own field Drop.
         fn drop(&mut self) {
             self.clear_stream_cancel_handler();
         }
@@ -1244,7 +1237,7 @@ pub fn readable_stream(
 
     // SAFETY (JSC_BORROW): `global_this` outlives the wrapper (it owns the JS heap that
     // owns the readable stream which keeps the wrapper reachable via cancel_ctx); store as
-    // `'static` for the heap-allocated wrapper, matching the Zig pointer field.
+    // `'static` for the heap-allocated wrapper.
     let global_static = GlobalRef::from(global_this);
 
     // Ownership of the heap-allocated NewSource transfers to the JS wrapper (m_ctx) via
@@ -1297,5 +1290,3 @@ pub fn readable_stream(
     }
     Ok(readable_value)
 }
-
-// ported from: src/runtime/webcore/s3/client.zig
diff --git a/src/runtime/webcore/s3/credentials_jsc.rs b/src/runtime/webcore/s3/credentials_jsc.rs
index a23e70590d8..1002a9956bd 100644
--- a/src/runtime/webcore/s3/credentials_jsc.rs
+++ b/src/runtime/webcore/s3/credentials_jsc.rs
@@ -21,10 +21,8 @@ use bun_url::URL;
 /// The intermediate `BunString` is `deref()`ed before return; the returned
 /// `ZigStringSlice` owns (or independently refs) its bytes.
 ///
-/// * `strict = true`  — non-string throws `ERR_INVALID_ARG_TYPE` keyed on `key`
-///   (credentials_jsc.zig behaviour).
-/// * `strict = false` — non-string is silently ignored (list_objects.zig
-///   behaviour).
+/// * `strict = true`  — non-string throws `ERR_INVALID_ARG_TYPE` keyed on `key`.
+/// * `strict = false` — non-string is silently ignored.
 pub(crate) fn get_truthy_string_utf8(
     opts: JSValue,
     global: &JSGlobalObject,
@@ -53,15 +51,13 @@ pub(crate) fn get_truthy_string_utf8(
     Ok(Some(utf8))
 }
 
-// PORT NOTE: Zig stores `str.toUTF8()` results in `_*_slice` fields and then
-// borrows `.slice()` into `credentials.*` — a self-referential struct. The
-// Rust `S3Credentials` fields are owned `Box<[u8]>`, so for credential strings
-// we deep-copy into the `Box` directly and skip the `_*_slice` ownership
+// `S3Credentials` fields are owned `Box<[u8]>`, so credential strings are
+// deep-copied into the `Box` directly with no `_*_slice` ownership
 // indirection. For `content_disposition` / `content_type` / `content_encoding`
-// (typed `Option<*const [u8]>` in `S3CredentialsWithOptions`) we keep the Zig
-// shape: `_*_slice` owns the bytes, the raw fat-pointer borrows them. The
-// underlying heap allocation does not move when the struct is returned by
-// value, so the pointer remains valid for the struct's lifetime.
+// (typed `Option<*const [u8]>` in `S3CredentialsWithOptions`), `_*_slice` owns
+// the bytes and the raw fat-pointer borrows them. The underlying heap
+// allocation does not move when the struct is returned by value, so the
+// pointer remains valid for the struct's lifetime.
 
 const ACL_ONE_OF: &str = "\"private\", \"public-read\", \"public-read-write\", \"aws-exec-read\", \
 \"authenticated-read\", \"bucket-owner-read\", \"bucket-owner-full-control\", \"log-delivery-write\"";
@@ -81,9 +77,9 @@ pub(crate) fn get_credentials_with_options(
 ) -> JsResult<S3CredentialsWithOptions> {
     bun_analytics::features::s3.fetch_add(1, Ordering::Relaxed);
     // get ENV config
-    // PORT NOTE: Zig takes `this` by value (struct copy). `S3Credentials`
-    // carries an intrusive ref-count and is not `Copy`; `Clone` performs the
-    // matching deep field copy with a fresh ref-count.
+    // `S3Credentials`
+    // carries an intrusive ref-count and is not `Copy`; `Clone` performs a
+    // deep field copy with a fresh ref-count.
     let mut new_credentials = S3CredentialsWithOptions {
         credentials: this.clone(),
         options: default_options,
@@ -297,5 +293,3 @@ pub(crate) fn get_credentials_with_options(
 fn contains_newline_or_cr(value: &[u8]) -> bool {
     strings::index_of_any(value, b"\r\n").is_some()
 }
-
-// ported from: src/runtime/webcore/s3/credentials_jsc.zig
diff --git a/src/runtime/webcore/s3/download_stream.rs b/src/runtime/webcore/s3/download_stream.rs
index d4fa94bc48b..17e6b5b33aa 100644
--- a/src/runtime/webcore/s3/download_stream.rs
+++ b/src/runtime/webcore/s3/download_stream.rs
@@ -16,8 +16,8 @@ use bun_threading::Mutex;
 bun_core::declare_scope!(S3, hidden);
 
 pub struct S3HttpDownloadStreamingTask {
-    // PORT NOTE: `MaybeUninit` because `AsyncHTTP` contains non-null references, so the Zig
-    // `= undefined`-then-init pattern can't use `mem::zeroed()` here (mirrors `S3HttpSimpleTask`).
+    // `MaybeUninit` because `AsyncHTTP` contains non-null references, so
+    // `mem::zeroed()` can't be used here (mirrors `S3HttpSimpleTask`).
     pub http: core::mem::MaybeUninit<AsyncHTTP<'static>>,
     /// JSC_BORROW: per-thread VM singleton, outlives every task. `None` only in
     /// the inert `Default` placeholder (overwritten before the task escapes).
@@ -41,17 +41,17 @@ pub struct S3HttpDownloadStreamingTask {
     pub proxy_url: Box<[u8]>,
 }
 
-// Hot-dispatch tag for `ConcurrentTask::from` (Zig: variant of `jsc.Task` TaggedPointerUnion).
+// Hot-dispatch tag for `ConcurrentTask::from`.
 impl Taskable for S3HttpDownloadStreamingTask {
     const TAG: TaskTag = task_tag::S3HttpDownloadStreamingTask;
 }
 
 impl Default for S3HttpDownloadStreamingTask {
     fn default() -> Self {
-        // PORT NOTE: only the Zig-defaulted fields (`has_schedule_callback` .. `concurrent_task`)
+        // only the fields `has_schedule_callback` .. `concurrent_task`
         // are observed via this path; the rest are placeholders that the caller (client.rs
-        // `..Default::default()`) overwrites before the task pointer escapes. `http` is zeroed
-        // to mirror Zig's `= undefined` + later overwrite (see S3HttpSimpleTask PORT NOTE).
+        // `..Default::default()`) overwrites before the task pointer escapes
+        // (see S3HttpSimpleTask in simple_request.rs).
         Self {
             // never read — fully overwritten by `AsyncHTTP::init` before first use.
             http: core::mem::MaybeUninit::uninit(),
@@ -62,7 +62,6 @@ impl Default for S3HttpDownloadStreamingTask {
             callback: |_, _, _, _| {},
             range: None,
             proxy_url: Box::default(),
-            // — Zig field defaults —
             has_schedule_callback: AtomicBool::new(false),
             signal_store: bun_http::signals::Store::default(),
             signals: Signals::default(),
@@ -77,7 +76,6 @@ impl Default for S3HttpDownloadStreamingTask {
 }
 
 impl S3HttpDownloadStreamingTask {
-    // Zig: `pub const new = bun.TrivialNew(@This());`
     pub fn new(init: Self) -> Box<Self> {
         Box::new(init)
     }
@@ -98,7 +96,7 @@ impl S3HttpDownloadStreamingTask {
             _ => true,
         };
 
-        // PORT NOTE: reshaped for borrowck — `code`/`message` borrow from
+        // reshaped for borrowck — `code`/`message` borrow from
         // `self.reported_response_buffer`, so we compute the chunk after the
         // borrow scope ends rather than inside the labeled block.
         let chunk: MutableString = 'brk: {
@@ -140,16 +138,14 @@ impl S3HttpDownloadStreamingTask {
                         }
                     }
 
+                    // `code`/`message` borrow `self.reported_response_buffer`;
+                    // the callback consumes them before any reset/deinit.
                     err = Some(S3Error { code, message });
-                    // TODO(port): S3Error field lifetimes — `code`/`message` borrow
-                    // `self.reported_response_buffer`; callback consumes them before reset/deinit.
                 }
                 break 'brk MutableString::default();
             } else {
-                // PORT NOTE: Zig copies the MutableString struct by value here (shallow copy of
-                // ptr+len+cap), then `.reset()` zeros the source — i.e. an ownership transfer.
-                // `core::mem::take` gives the same observable semantics in Rust without the
-                // transient aliasing the Zig code relied on.
+                // `core::mem::take` transfers ownership of the buffer, leaving an
+                // empty MutableString behind.
                 let buffer = core::mem::take(&mut self.reported_response_buffer);
                 break 'brk buffer;
             }
@@ -194,8 +190,8 @@ impl S3HttpDownloadStreamingTask {
         // the state is atomic let's load it once
         let state = self_.get_state();
         let has_more = state.has_more();
-        // Zig `defer { this.mutex.unlock(); if (!has_more) this.deinit(); }` — keep as a scopeguard
-        // so any future early-exit / unwind through `report_progress` still unlocks + deinits.
+        // Use a scopeguard so any future early-exit / unwind through
+        // `report_progress` still unlocks + deinits.
         let this_ptr = this;
         scopeguard::defer! {
             // SAFETY: `this_ptr` was allocated via `Box::new` in `Self::new`; once
@@ -221,8 +217,8 @@ impl S3HttpDownloadStreamingTask {
     fn update_state(
         &mut self,
         async_http: &mut AsyncHTTP<'static>,
-        // PORT NOTE: reshaped for borrowck — Zig passed `result` by value; Rust borrows so the
-        // caller (process_http_callback) can still read `result.body` afterward.
+        // borrowed so the caller (process_http_callback) can still read
+        // `result.body` afterward.
         result: &HTTPClientResult,
         state: &mut State,
     ) -> bool {
@@ -238,10 +234,8 @@ impl S3HttpDownloadStreamingTask {
                 0
             });
             if state.status_code() == 0 {
-                // PORT NOTE: Zig explicitly `deinit()`s `certificate_info` / `metadata` here.
-                // In the Rust port both types free their owned buffers via `Drop`, and
-                // `HTTPClientResult` is dropped by the caller after this returns, so the
-                // explicit-free calls become no-ops.
+                // `certificate_info` / `metadata` free their owned buffers via `Drop`
+                // when `HTTPClientResult` is dropped by the caller after this returns.
                 if let Some(m) = &result.metadata {
                     state.set_status_code(m.response.status_code);
                 }
@@ -252,11 +246,11 @@ impl S3HttpDownloadStreamingTask {
             }
             // store the new state
             self.set_state(*state);
-            // TODO(port): Zig does `this.http = async_http.*;` (struct copy). Confirm
-            // AsyncHTTP copy/move semantics in Rust.
-            // SAFETY: `async_http` points to a live AsyncHTTP owned by the HTTP thread; Zig does a
-            // plain struct copy (`this.http = async_http.*`) — bitwise read+write matches that.
-            // `self.http` was previously initialised in `execute_s3_streaming_download`.
+            // SAFETY: `async_http` points to a live AsyncHTTP owned by the HTTP thread; a
+            // bitwise read+write copies its current state into `self.http` without running
+            // destructors (the HTTP thread retains ownership of the source until the request
+            // completes). `self.http` was previously initialised in
+            // `execute_s3_streaming_download`.
             unsafe { core::ptr::write(self.http.as_mut_ptr(), core::ptr::read(async_http)) };
         }
         wait_until_done
@@ -270,14 +264,16 @@ impl S3HttpDownloadStreamingTask {
         result: HTTPClientResult,
     ) -> bool {
         // lets lock and unlock to be safe we know the state is not in the middle of a callback when locked
-        self.mutex.lock();
-        // Zig `defer this.mutex.unlock();` — handled at every return below.
-        // TODO(port): replace with RAII MutexGuard once bun_threading::Mutex exposes one.
-        let unlock = |s: &mut Self| s.mutex.unlock();
+        // The RAII guard unlocks on every
+        // return path. The guard holds the mutex by raw pointer (see
+        // `Mutex::lock_guard`), so `&mut self` stays freely usable while
+        // locked, and it drops before this fn returns — strictly before the
+        // task can be freed by the main thread.
+        let _guard = self.mutex.lock_guard();
 
         // remember the state is atomic load it once, and store it again
         let mut state = self.get_state();
-        // old state should have more otherwise its a http.zig bug
+        // old state should have more otherwise it's an HTTP-client bug
         debug_assert!(state.has_more());
         let is_done = !result.has_more;
         let wait_until_done = self.update_state(async_http, &result, &mut state);
@@ -293,23 +289,20 @@ impl S3HttpDownloadStreamingTask {
 
         if should_enqueue {
             if let Some(body) = result.body {
-                // .zig:207 does `this.response_buffer = body.*;`, but `body` is
-                // `&this.response_buffer` (see http/client.zig:600), so that line is a no-op
-                // self-assign in Zig. In Rust, a `ptr::read` + assign here would run Drop on the
-                // old `self.response_buffer`, freeing the Vec allocation that `body` (and the
-                // freshly-stored value) still point at — a use-after-free / double-free. The net
-                // effect of .zig:207-211 is: append `body`'s bytes to `reported_response_buffer`,
-                // then reset the buffer. Do exactly that, operating on `body` directly.
+                // `body` is `&this.response_buffer`, so a `ptr::read` + assign here would
+                // run Drop on the old `self.response_buffer`, freeing the Vec allocation
+                // that `body` (and the freshly-stored value) still point at — a
+                // use-after-free / double-free. Instead, append `body`'s bytes to
+                // `reported_response_buffer`, then reset the buffer, operating on `body`
+                // directly.
                 if !body.list.as_slice().is_empty() {
                     let _ = self.reported_response_buffer.write(body.list.as_slice());
                 }
                 body.reset();
                 if self.reported_response_buffer.list.as_slice().is_empty() && !is_done {
-                    unlock(self);
                     return false;
                 }
             } else if !is_done {
-                unlock(self);
                 return false;
             }
             if let Err(has_schedule_callback) = self.has_schedule_callback.compare_exchange(
@@ -319,18 +312,15 @@ impl S3HttpDownloadStreamingTask {
                 Ordering::Relaxed,
             ) {
                 if has_schedule_callback {
-                    unlock(self);
                     return false;
                 }
             }
-            unlock(self);
             return true;
         }
-        unlock(self);
         false
     }
 
-    /// this is the callback from the http.zig AsyncHTTP is always called from the HTTPThread
+    /// this is the AsyncHTTP callback and is always called from the HTTPThread
     ///
     /// # Safety
     /// `this` must be a live heap pointer produced by `Self::new`, valid for the duration of the
@@ -366,7 +356,7 @@ impl S3HttpDownloadStreamingTask {
 
 impl Drop for S3HttpDownloadStreamingTask {
     fn drop(&mut self) {
-        // PORT NOTE: KeepAlive::unref now takes an aio EventLoopCtx; the JS-loop ctx is fetched
+        // KeepAlive::unref now takes an aio EventLoopCtx; the JS-loop ctx is fetched
         // via the global hook (registered by crate::init) — same pattern as
         // `S3HttpSimpleTask::drop` in simple_request.rs.
         self.poll_ref.unref(bun_io::posix_event_loop::get_vm_ctx(
@@ -377,16 +367,15 @@ impl Drop for S3HttpDownloadStreamingTask {
         // SAFETY: `http` is always initialised before the task is scheduled / dropped.
         let http = unsafe { self.http.assume_init_mut() };
         http.clear_data();
-        // Zig shared one EntryList allocation between task.headers / request_headers /
-        // client.header_entries; Rust `init` clones, so free the two copies clear_data() skips.
+        // `init` clones the EntryList into task.headers / request_headers /
+        // client.header_entries, so free the two copies clear_data() skips.
         // (Same fix as `S3HttpSimpleTask::drop` in simple_request.rs.)
         http.request_headers = Default::default();
         http.client.header_entries = Default::default();
     }
 }
 
-/// Zig: `packed struct(u64)` — not all-bool, so manual bitfield over a transparent u64.
-/// Layout (LSB-first, matching Zig packed-struct bit order):
+/// Manual bitfield over a transparent u64. Layout (LSB-first):
 ///   bits  0..32 : status_code (u32)
 ///   bits 32..48 : request_error (u16)
 ///   bit  48     : has_more (bool)
@@ -435,5 +424,3 @@ impl Default for State {
         State(1u64 << State::HAS_MORE_SHIFT)
     }
 }
-
-// ported from: src/runtime/webcore/s3/download_stream.zig
diff --git a/src/runtime/webcore/s3/error_jsc.rs b/src/runtime/webcore/s3/error_jsc.rs
index fa32941d5f4..535fe781fbe 100644
--- a/src/runtime/webcore/s3/error_jsc.rs
+++ b/src/runtime/webcore/s3/error_jsc.rs
@@ -1,4 +1,4 @@
-//! JSC bridges for `s3_signing/error.zig`. The pure error-code/message tables
+//! JSC bridges for S3 signing errors. The pure error-code/message tables
 //! stay in `s3_signing/`; the `*JSGlobalObject`-taking variants live here.
 
 use bun_core::String as BunString;
@@ -8,7 +8,7 @@ use bun_s3_signing::error::{self as s3_error, get_sign_error_message};
 
 pub use s3_error::S3Error;
 
-// PORT NOTE: `get_sign_error_message` returns `&'static [u8]` of ASCII literals; reinterpret as
+// `get_sign_error_message` returns `&'static [u8]` of ASCII literals; reinterpret as
 // `&str` for the `format_args!`-taking `JSGlobalObject::err()` builder.
 #[inline]
 fn msg(bytes: &'static [u8]) -> &'static str {
@@ -141,8 +141,8 @@ impl JSS3Error {
         }
     }
 
-    // Zig `deinit` only deref'd the three `bun.String` fields; `bun_core::String: Drop`
-    // handles that automatically, so no explicit `Drop` impl is needed here.
+    // The three `bun_core::String` fields deref themselves via `Drop`, so no
+    // explicit `Drop` impl is needed here.
 
     pub(crate) fn to_error_instance(self, global: &JSGlobalObject) -> JSValue {
         // `defer this.deinit()` → `self` is consumed and dropped at scope exit.
@@ -150,7 +150,6 @@ impl JSS3Error {
     }
 }
 
-// TODO(port): move to <area>_sys
 // C++ side defines `SYSV_ABI JSC::EncodedJSValue` (S3Error.cpp).
 bun_jsc::jsc_abi_extern! {
     // C++ copies the three `BunString` fields out and does not write through
@@ -183,7 +182,7 @@ pub(crate) fn s3_error_to_js_with_async_stack(
 }
 
 /// Method-syntax extension over [`S3Error`] so call sites in `S3File` /
-/// `blob::Store` keep the Zig-spec spelling `err.to_js_with_async_stack(…)`.
+/// `blob::Store` can use the spelling `err.to_js_with_async_stack(…)`.
 /// Forwards to the free fn above; returns `JsResult` because the consuming
 /// `JSPromiseStrong::reject` takes `JsResult<JSValue>`.
 pub trait S3ErrorJsc {
@@ -215,5 +214,3 @@ impl S3ErrorJsc for S3Error<'_> {
         ))
     }
 }
-
-// ported from: src/runtime/webcore/s3/error_jsc.zig
diff --git a/src/runtime/webcore/s3/list_objects.rs b/src/runtime/webcore/s3/list_objects.rs
index 1143e73bbf1..76f286e996c 100644
--- a/src/runtime/webcore/s3/list_objects.rs
+++ b/src/runtime/webcore/s3/list_objects.rs
@@ -5,37 +5,25 @@ use bun_jsc::{JSGlobalObject, JSValue, JsResult};
 // Shared S3 option-string ladder (get_truthy → is_string → from_js → to_utf8).
 use super::__s3_credentials_jsc::get_truthy_string_utf8;
 use bun_core::{ZigStringSlice as Utf8Slice, strings};
-use bun_ptr::RawSlice;
 
 pub struct S3ListObjectsOptions {
-    // Self-referential views: these borrow from the corresponding
-    // `_field: Utf8Slice` below. In Zig the slice and its backing storage are
-    // separate fields; `RawSlice` encodes the non-owning contract so callers
-    // read `.as_deref()` instead of open-coding `unsafe { &*p }`.
-    pub continuation_token: Option<RawSlice<u8>>,
-    pub delimiter: Option<RawSlice<u8>>,
-    pub encoding_type: Option<RawSlice<u8>>,
+    // Each `Utf8Slice` owns (or ref-holds) its backing storage; readers go
+    // through `.slice()`.
+    pub continuation_token: Option<Utf8Slice>,
+    pub delimiter: Option<Utf8Slice>,
+    pub encoding_type: Option<Utf8Slice>,
     pub fetch_owner: Option<bool>,
     pub max_keys: Option<i64>,
-    pub prefix: Option<RawSlice<u8>>,
-    pub start_after: Option<RawSlice<u8>>,
-
-    // TODO(port): Utf8Slice<'_> lifetime — Zig's ZigString.Slice owns or
-    // ref-holds its backing WTFStringImpl; modeled as 'static here. Pick
-    // the real lifetime / collapse the dual fields.
-    pub _continuation_token: Option<Utf8Slice>,
-    pub _delimiter: Option<Utf8Slice>,
-    pub _encoding_type: Option<Utf8Slice>,
-    pub _prefix: Option<Utf8Slice>,
-    pub _start_after: Option<Utf8Slice>,
+    pub prefix: Option<Utf8Slice>,
+    pub start_after: Option<Utf8Slice>,
 }
 
-// Zig deinit only forwarded to each Utf8Slice field's deinit; Rust handles
-// that via field Drop, so no explicit `impl Drop` is needed here.
+// Each Utf8Slice field cleans up via Drop, so no explicit `impl Drop` is
+// needed here.
 
-// PORT NOTE: result structs borrow slices out of the input `xml: &[u8]`
-// passed to `parse_s3_list_objects_result`. The Zig code never frees these
-// (they alias the request body buffer). Represented with an explicit `'a` —
+// result structs borrow slices out of the input `xml: &[u8]`
+// passed to `parse_s3_list_objects_result` (they alias the request body
+// buffer). Represented with an explicit `'a` —
 // the borrow is unambiguous and any other encoding (Box / raw ptr) would
 // misrepresent ownership. The caller keeps `xml` alive for the result's
 // lifetime (result is consumed by toJS before the response body is freed).
@@ -47,8 +35,7 @@ struct ObjectOwner<'a> {
 
 pub struct S3ListObjectsContents<'a> {
     key: &'a [u8],
-    // Zig: ?bun.ptr.OwnedIn([]const u8, MaybeOwned(DefaultAllocator)) —
-    // i.e. a maybe-owned slice. Cow<'a, [u8]> is the direct equivalent.
+    // a maybe-owned slice.
     etag: Option<Cow<'a, [u8]>>,
     checksum_type: Option<&'a [u8]>,
     checksum_algorithme: Option<&'a [u8]>,
@@ -58,8 +45,6 @@ pub struct S3ListObjectsContents<'a> {
     owner: Option<ObjectOwner<'a>>,
 }
 
-// Zig deinit only freed `etag` when owned; Cow handles that in Drop.
-
 pub struct S3ListObjectsV2Result<'a> {
     pub name: Option<&'a [u8]>,
     pub prefix: Option<&'a [u8]>,
@@ -75,8 +60,8 @@ pub struct S3ListObjectsV2Result<'a> {
     pub contents: Option<Vec<S3ListObjectsContents<'a>>>,
 }
 
-// Zig deinit freed `contents` items (etag) + the two ArrayLists. All handled
-// by Drop on Vec / Cow; no explicit Drop impl needed.
+// `contents` items (etag) + the two Vecs are all handled by Drop on
+// Vec / Cow; no explicit Drop impl needed.
 
 impl<'a> S3ListObjectsV2Result<'a> {
     pub(crate) fn to_js(&self, global_object: &JSGlobalObject) -> JsResult<JSValue> {
@@ -185,9 +170,8 @@ impl<'a> S3ListObjectsV2Result<'a> {
     }
 }
 
-// PORT NOTE: Zig signature was `!S3ListObjectsV2Result` but the only `try`
-// sites were allocations (Vec::push / alloc) which abort on OOM in Rust, so
-// this is now infallible.
+// Infallible: the only fallible operations are allocations
+// (Vec::push / alloc), which abort on OOM.
 pub fn parse_s3_list_objects_result(xml: &[u8]) -> S3ListObjectsV2Result<'_> {
     let mut result = S3ListObjectsV2Result {
         contents: None,
@@ -311,8 +295,7 @@ pub fn parse_s3_list_objects_result(xml: &[u8]) -> S3ListObjectsV2Result<'_> {
                                     {
                                         let input = &xml[i..i + __tag_end];
 
-                                        // std.mem.replacementSize / std.mem.replace
-                                        // for "&quot;" → "\""
+                                        // unescape "&quot;" → "\""
                                         let output =
                                             strings::replace_owned(input, b"&quot;", b"\"");
                                         if output.len() != input.len() {
@@ -526,7 +509,7 @@ pub fn parse_s3_list_objects_result(xml: &[u8]) -> S3ListObjectsV2Result<'_> {
         if !contents.is_empty() {
             result.contents = Some(contents);
         }
-        // else branch: Vec drops itself (Zig: contents.deinit())
+        // else branch: Vec drops itself
 
         if !common_prefixes.is_empty() {
             result.common_prefixes = Some(common_prefixes);
@@ -549,12 +532,6 @@ pub fn get_list_objects_options_from_js(
         max_keys: None,
         prefix: None,
         start_after: None,
-
-        _continuation_token: None,
-        _delimiter: None,
-        _encoding_type: None,
-        _prefix: None,
-        _start_after: None,
     };
 
     if !list_options.is_object() {
@@ -564,23 +541,20 @@ pub fn get_list_objects_options_from_js(
     if let Some(slice) =
         get_truthy_string_utf8(list_options, global_this, b"continuationToken", false)?
     {
-        list_objects_options.continuation_token = Some(RawSlice::new(slice.slice()));
-        list_objects_options._continuation_token = Some(slice);
+        list_objects_options.continuation_token = Some(slice);
     }
 
     if let Some(slice) = get_truthy_string_utf8(list_options, global_this, b"delimiter", false)? {
-        list_objects_options.delimiter = Some(RawSlice::new(slice.slice()));
-        list_objects_options._delimiter = Some(slice);
+        list_objects_options.delimiter = Some(slice);
     }
 
     if let Some(slice) = get_truthy_string_utf8(list_options, global_this, b"encodingType", false)?
     {
-        list_objects_options.encoding_type = Some(RawSlice::new(slice.slice()));
-        list_objects_options._encoding_type = Some(slice);
+        list_objects_options.encoding_type = Some(slice);
     }
 
-    // PORT NOTE: `JSValue::get_boolean_loose` is not yet exposed in bun_jsc; emulate via
-    // `get_truthy` + `to_boolean()` (matches Zig getBooleanLoose semantics for truthy values).
+    // `JSValue::get_boolean_loose` is not yet exposed in bun_jsc; emulate via
+    // `get_truthy` + `to_boolean()`.
     if let Some(val) = list_options.get_truthy(global_this, b"fetchOwner")? {
         list_objects_options.fetch_owner = Some(val.to_boolean());
     }
@@ -592,16 +566,12 @@ pub fn get_list_objects_options_from_js(
     }
 
     if let Some(slice) = get_truthy_string_utf8(list_options, global_this, b"prefix", false)? {
-        list_objects_options.prefix = Some(RawSlice::new(slice.slice()));
-        list_objects_options._prefix = Some(slice);
+        list_objects_options.prefix = Some(slice);
     }
 
     if let Some(slice) = get_truthy_string_utf8(list_options, global_this, b"startAfter", false)? {
-        list_objects_options.start_after = Some(RawSlice::new(slice.slice()));
-        list_objects_options._start_after = Some(slice);
+        list_objects_options.start_after = Some(slice);
     }
 
     Ok(list_objects_options)
 }
-
-// ported from: src/runtime/webcore/s3/list_objects.zig
diff --git a/src/runtime/webcore/s3/multipart.rs b/src/runtime/webcore/s3/multipart.rs
index 81c1348be02..d8b4d16bd1e 100644
--- a/src/runtime/webcore/s3/multipart.rs
+++ b/src/runtime/webcore/s3/multipart.rs
@@ -108,9 +108,9 @@ use bun_s3_signing::credentials::S3Credentials;
 use bun_s3_signing::error::S3Error;
 use bun_s3_signing::storage_class::StorageClass;
 
-// PORT NOTE: file-level mods are declared flat in `webcore.rs` via `#[path]`, so
-// `super` here is `crate::webcore`, not the `s3` directory. Route through the
-// `s3` re-export hub instead.
+// File-level mods are declared flat in `webcore.rs` via `#[path]`, so `super`
+// here is `crate::webcore`, not the `s3` directory. Route through the `s3`
+// re-export hub instead.
 use crate::webcore::ResumableSinkBackpressure;
 use crate::webcore::s3::multipart_options::MultiPartUploadOptions;
 use crate::webcore::s3::simple_request::{
@@ -148,9 +148,8 @@ pub struct MultiPartUpload {
     pub content_type: Option<Box<[u8]>>,
     pub content_disposition: Option<Box<[u8]>>,
     pub content_encoding: Option<Box<[u8]>>,
-    // PORT NOTE: in Zig this is a self-referential slice into `uploadid_buffer`.
-    // Duped into an owned Box here to avoid self-referential struct.
-    // PERF(port): was zero-copy slice into uploadid_buffer — profile if hot.
+    // Duped into an owned Box here to avoid a self-referential struct
+    // (a slice into `uploadid_buffer`).
     pub upload_id: Box<[u8]>,
     pub uploadid_buffer: MutableString,
 
@@ -182,8 +181,8 @@ impl MultiPartUpload {
 
     // bun.ptr.RefCount(Self, "ref_count", deinit, .{}) — intrusive refcount.
     // `ref_()`/`deref()` are provided by `#[derive(CellRefCounted)]`.
-    // PORT NOTE: inherent associated types (`pub type Ref = ...` inside `impl`)
-    // are unstable; the alias lives at module scope as `MultiPartUploadRef`.
+    // Inherent associated types (`pub type Ref = ...` inside `impl`) are
+    // unstable; the alias lives at module scope as `MultiPartUploadRef`.
     /// # Safety
     /// `this` must be a live heap-allocated `MultiPartUpload` created via
     /// `heap::alloc` with a non-zero intrusive refcount.
@@ -257,7 +256,7 @@ impl UploadPart {
         // SAFETY: callback context — `this` is the `*mut UploadPart` passed in `perform()`
         let this = unsafe { &mut *this };
         // Copy the BackRef out so the `&mut MultiPartUpload` borrow is detached
-        // from `this` (Zig held both `*UploadPart` and `*MultiPartUpload` freely).
+        // from `this`.
         let mut ctx_ref = this.ctx;
         // SAFETY: ctx is a live BACKREF while a part is in flight (part holds a ref on ctx)
         let ctx = unsafe { ctx_ref.get_mut() };
@@ -296,7 +295,7 @@ impl UploadPart {
                         this.part_number
                     );
                     this.free_allocated_slice();
-                    // PORT NOTE: `defer this.ctx.deref()` reordered after fail()
+                    // The ctx deref must run after fail():
                     let ctx_ptr = this.ctx.as_ptr();
                     // SAFETY: ctx_ptr is a live BACKREF; part still holds a ref on ctx until deref_ below
                     let r = unsafe { (*ctx_ptr).fail(err) };
@@ -321,7 +320,7 @@ impl UploadPart {
                 this.state = PartState::NotAssigned;
                 // mark as available
                 ctx.available.set(this.index as usize);
-                // PORT NOTE: `defer this.ctx.deref()` reordered after drainEnqueuedParts()
+                // The ctx deref must run after drain_enqueued_parts():
                 let ctx_ptr = this.ctx.as_ptr();
                 // drain more
                 // SAFETY: ctx_ptr is a live BACKREF; part still holds a ref on ctx until deref_ below
@@ -395,10 +394,9 @@ impl UploadPart {
 
 impl Drop for MultiPartUpload {
     fn drop(&mut self) {
-        // Zig `deinit`
         scoped_log!(S3MultiPartUpload, "deinit");
         // queue: Box<[UploadPart]> — dropped automatically (parts' raw `data` already freed during lifecycle)
-        // PORT NOTE: KeepAlive::unref takes an `EventLoopCtx` (aio cycle-break vtable),
+        // KeepAlive::unref takes an `EventLoopCtx` (aio cycle-break vtable),
         // not `&VirtualMachine`. Route through the global hook like simple_request does.
         let _ = self.vm;
         self.poll_ref.unref(bun_io::posix_event_loop::get_vm_ctx(
@@ -406,8 +404,7 @@ impl Drop for MultiPartUpload {
         ));
         // path, proxy, content_type, content_disposition, content_encoding — Box dropped automatically
         // `IntrusiveRc<T>` (= `RefPtr<T>`) has no `Drop` — release the +1 the
-        // constructing `writable_stream`/`upload_stream` adopted (Zig:
-        // `this.credentials.deref()`).
+        // constructing `writable_stream`/`upload_stream` adopted.
         self.credentials.deref();
         // uploadid_buffer: MutableString — Drop
         // multipart_etags: Vec<UploadPartResult> — Drop (each etag Box<[u8]> freed)
@@ -520,7 +517,6 @@ impl MultiPartUpload {
         };
 
         let part_number = self.current_part_number;
-        // PORT NOTE: `defer this.currentPartNumber += 1` hoisted before return
         self.current_part_number += 1;
 
         let queue_item = &mut self.queue.as_mut().unwrap()[index];
@@ -651,7 +647,7 @@ impl MultiPartUpload {
         } else if self.state == State::SinglefileStarted {
             self.state = State::Finished;
             // single file upload no need to commit
-            // PORT NOTE: `defer this.deref()` reordered after callback
+            // The deref must run after the callback:
             let r = (self.callback)(S3UploadResult::Success, self.callback_context);
             // SAFETY: `self` is a live heap-allocated `MultiPartUpload` (intrusive RC).
             MultiPartUpload::deref_(self);
@@ -667,7 +663,7 @@ impl MultiPartUpload {
         this: *mut c_void,
     ) -> JsTerminatedResult<()> {
         let this = this.cast::<Self>();
-        // PORT NOTE: `defer this.deref()` — `adopt` consumes the prior +1 on Drop.
+        // `adopt` consumes the prior +1 on Drop.
         // SAFETY: callback context — a ref was taken before the request was queued.
         let _deref_guard = unsafe { bun_ptr::ScopedRef::<Self>::adopt(this) };
         // SAFETY: callback context — `this` is live (a ref was taken before the request)
@@ -689,7 +685,7 @@ impl MultiPartUpload {
             S3DownloadResult::Success(response) => {
                 // response.body is bun.MutableString — `list` is a Vec<u8>
                 let slice = response.body.list.as_slice();
-                // PERF(port): Zig stored body and sliced upload_id into it; here we dupe upload_id
+                // PERF: upload_id is duped out of the body instead of slicing into it
                 if let Some(start) = strings::index_of(slice, b"<UploadId>") {
                     let value_start = start + b"<UploadId>".len();
                     if let Some(end) = strings::index_of(slice, b"</UploadId>") {
@@ -759,7 +755,7 @@ impl MultiPartUpload {
                     return Ok(());
                 }
                 this_ref.state = State::Finished;
-                // PORT NOTE: `defer this.deref()` reordered after callback
+                // The deref must run after the callback:
                 let r =
                     (this_ref.callback)(S3UploadResult::Failure(err), this_ref.callback_context);
                 // SAFETY: `this` is live (final-step ref held until this deref).
@@ -768,7 +764,7 @@ impl MultiPartUpload {
             }
             S3CommitResult::Success => {
                 this_ref.state = State::Finished;
-                // PORT NOTE: `defer this.deref()` reordered after callback
+                // The deref must run after the callback:
                 let r = (this_ref.callback)(S3UploadResult::Success, this_ref.callback_context);
                 // SAFETY: `this` is live (final-step ref held until this deref).
                 MultiPartUpload::deref_(this);
@@ -926,7 +922,7 @@ impl MultiPartUpload {
             return Ok(());
         }
         // need to split in multiple parts because of the size
-        // PORT NOTE: `defer if (buffered.isEmpty()) buffered.reset()` hoisted to after the loop;
+        // The "reset buffered if empty" cleanup runs after the loop;
         // early-return paths either reset buffered to default (already empty) or leave it non-empty (no-op).
 
         while self.buffered.is_not_empty() {
@@ -945,7 +941,7 @@ impl MultiPartUpload {
             if self.buffered.cursor == 0 && self.buffered.size() == len {
                 // we need to know the allocated size to free the memory later
                 let allocated_size = self.buffered.memory_cost();
-                // PORT NOTE: reshaped for borrowck — capture raw slice ptr before calling enqueue_part(&mut self)
+                // Capture a raw slice ptr before calling enqueue_part(&mut self) to satisfy the borrow checker.
                 let slice_ptr = std::ptr::from_ref::<[u8]>(self.buffered.slice());
                 // raw slice pointer carries its length in metadata; no deref needed
                 let slice_len = slice_ptr.len();
@@ -963,13 +959,12 @@ impl MultiPartUpload {
 
                     // queue is not full, we can clear the buffer part now owns the data
                     // if its full we will retry later
-                    // SAFETY: ownership of buffered's allocation transferred to the part above.
-                    // The Zig spec does `this.buffered = .{}` which overwrites WITHOUT running a
-                    // destructor, releasing the allocation to the UploadPart created via
-                    // enqueue_part(..., needs_clone=false). In Rust, assigning a fresh
-                    // StreamBuffer would Drop the old one and free the Vec<u8> backing storage,
-                    // leaving UploadPart.data dangling (UAF on perform(), double-free on
-                    // free_allocated_slice). Take + forget so the part remains sole owner.
+                    // SAFETY: ownership of buffered's allocation transferred to the
+                    // UploadPart created via enqueue_part(..., needs_clone=false) above.
+                    // Assigning a fresh StreamBuffer would Drop the old one and free the
+                    // Vec<u8> backing storage, leaving UploadPart.data dangling (UAF on
+                    // perform(), double-free on free_allocated_slice). Take + forget so
+                    // the part remains sole owner.
                     let _ = core::mem::ManuallyDrop::new(core::mem::take(&mut self.buffered));
                     return Ok(());
                 }
@@ -983,7 +978,7 @@ impl MultiPartUpload {
                 return Ok(());
             }
 
-            // PORT NOTE: reshaped for borrowck — capture raw slice ptr before calling enqueue_part(&mut self)
+            // Capture a raw slice ptr before calling enqueue_part(&mut self) to satisfy the borrow checker.
             let slice_ptr = &raw const self.buffered.slice()[..len];
             // allocated size is the slice len because we dupe the buffer
             // SAFETY: slice_ptr borrows self.buffered which is not mutated until after enqueue_part dupes it
@@ -1081,10 +1076,8 @@ impl MultiPartUpload {
         self.available.mask == IntegerBitSet::<{ Self::MAX_QUEUE_SIZE }>::init_full().mask
     }
 
-    // PORT NOTE: Zig used `comptime encoding: enum {bytes, latin1, utf16}`. Rust's
-    // adt_const_params (enum-valued const generics) is unstable, so take it as a
-    // plain runtime arg — the three thin wrappers below pass a constant, so the
-    // optimizer still specializes each branch.
+    // The encoding is a plain runtime arg — the three thin wrappers below
+    // pass a constant, so the optimizer still specializes each branch.
     fn write(
         &mut self,
         encoding: WriteEncoding,
@@ -1189,5 +1182,3 @@ pub(crate) enum WriteEncoding {
     Latin1,
     Utf16,
 }
-
-// ported from: src/runtime/webcore/s3/multipart.zig
diff --git a/src/runtime/webcore/s3/multipart_options.rs b/src/runtime/webcore/s3/multipart_options.rs
index 5ffda9c9898..9e5bbfb0e7a 100644
--- a/src/runtime/webcore/s3/multipart_options.rs
+++ b/src/runtime/webcore/s3/multipart_options.rs
@@ -3,8 +3,4 @@
 // re-export so `crate::webcore::s3::multipart_options::MultiPartUploadOptions`
 // and `bun_s3_signing::MultiPartUploadOptions` resolve to the SAME type — see
 // the E0308 "distinct types" note this previously tripped in fetch.rs.
-//
-// Source of truth: src/runtime/webcore/s3/multipart_options.zig
 pub use bun_s3_signing::MultiPartUploadOptions;
-
-// ported from: src/runtime/webcore/s3/multipart_options.zig
diff --git a/src/runtime/webcore/s3/simple_request.rs b/src/runtime/webcore/s3/simple_request.rs
index 3a17eb4985e..986715dbe10 100644
--- a/src/runtime/webcore/s3/simple_request.rs
+++ b/src/runtime/webcore/s3/simple_request.rs
@@ -21,12 +21,10 @@ use bun_url::URL;
 
 use crate::webcore::s3::list_objects;
 
-// PORT NOTE: result/options structs below carry borrowed slices that are valid only for the
-// duration of the callback invocation (Zig comments say "not owned and need to be copied if used
-// after this callback"). They take an explicit `<'a>` because they are ephemeral stack-only
+// The result/options structs below carry borrowed slices that are valid only for the
+// duration of the callback invocation (not owned; they must be copied if used
+// after the callback). They take an explicit `<'a>` because they are ephemeral stack-only
 // callback payloads (never heap-stored) — the borrow lifetime accurately models ownership.
-// TODO(port): revisit `<'a>` vs raw `*const [u8]` for callback payload structs if borrowck
-// reshaping proves cleaner.
 
 #[derive(Default)]
 pub struct S3StatSuccess<'a> {
@@ -66,7 +64,7 @@ pub enum S3UploadResult<'a> {
     Failure(S3Error<'a>),
 }
 
-// PORT NOTE: manual Debug because upstream `S3Error` (bun_s3_signing) doesn't derive Debug and
+// manual Debug because upstream `S3Error` (bun_s3_signing) doesn't derive Debug and
 // we may not edit that crate from here. Only the variant tag is needed for `scoped_log!`.
 impl core::fmt::Debug for S3UploadResult<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -110,11 +108,11 @@ pub enum S3PartResult<'a> {
 }
 
 pub struct S3HttpSimpleTask {
-    // PORT NOTE: `http` is `MaybeUninit` because (a) Zig initialises it as `= undefined` and
-    // overwrites it later — `AsyncHTTP` contains `&'static [u8]` and `fn(...)` fields, so a
-    // zeroed/default value would be instant UB; and (b) Zig's `deinit` only calls
-    // `http.clearData()`, never a full destructor, and `httpCallback` does a no-drop bitwise
-    // overwrite. Wrapping in `MaybeUninit` lets us match those semantics exactly: write-without-
+    // `http` is `MaybeUninit` because (a) it is initialised late —
+    // `AsyncHTTP` contains `&'static [u8]` and `fn(...)` fields, so a
+    // zeroed/default value would be instant UB; and (b) `Drop` only calls
+    // `http.clear_data()`, never a full destructor, and `http_callback` does a no-drop bitwise
+    // overwrite. Wrapping in `MaybeUninit` makes both possible: write-without-
     // drop on assignment, and `clear_data()`-only in `Drop`. Invariant: `http` is initialised by
     // `execute_simple_s3_request` before the task pointer escapes, so every later access (in
     // `http_callback` / `Drop`) may `assume_init`.
@@ -127,7 +125,7 @@ pub struct S3HttpSimpleTask {
     pub callback_context: *mut c_void,
     pub callback: Callback,
     pub response_buffer: MutableString,
-    // PORT NOTE: `'static` here because `result.body` (when set) points at our own
+    // `'static` here because `result.body` (when set) points at our own
     // `response_buffer` — self-referential, so the borrow lives as long as the task.
     pub result: HTTPClientResult<'static>,
     pub concurrent_task: ConcurrentTask,
@@ -136,6 +134,10 @@ pub struct S3HttpSimpleTask {
     /// by a concurrent process.env.HTTP_PROXY write while the HTTP thread is
     /// in flight, so we must own our copy for the task's lifetime.
     pub proxy_url: Box<[u8]>,
+    /// Owned copy of the request body. The HTTP thread reads the body slice
+    /// concurrently for the lifetime of the request, so the task owns its own
+    /// copy instead of borrowing caller memory.
+    pub body: Box<[u8]>,
     pub poll_ref: KeepAlive,
 }
 
@@ -143,8 +145,8 @@ impl Taskable for S3HttpSimpleTask {
     const TAG: TaskTag = task_tag::S3HttpSimpleTask;
 }
 
-// PORT NOTE: Zig only defaults `response_buffer`/`result`/`concurrent_task`; Rust's
-// `..Default::default()` requires the whole struct to be Default, so the remaining fields get
+// `..Default::default()` requires the whole struct to be Default, so beyond
+// `response_buffer`/`result`/`concurrent_task` the remaining fields get
 // inert placeholders that callers always overwrite (see client.rs / execute_simple_s3_request).
 impl Default for S3HttpSimpleTask {
     fn default() -> Self {
@@ -163,6 +165,7 @@ impl Default for S3HttpSimpleTask {
             concurrent_task: ConcurrentTask::default(),
             range: None,
             proxy_url: Box::default(),
+            body: Box::default(),
             poll_ref: KeepAlive::default(),
         }
     }
@@ -223,8 +226,7 @@ impl Callback {
     }
 }
 
-// PORT NOTE: Zig used `comptime error_type` and an enum const-generic. Stable Rust forbids
-// enum const params (`adt_const_params` is unstable), so this is a runtime parameter — the
+// `error_type` is a runtime parameter — the
 // branch is on an error path, no perf concern.
 #[derive(PartialEq, Eq, Clone, Copy)]
 enum ErrorType {
@@ -243,7 +245,6 @@ impl S3HttpSimpleTask {
         let mut message: &[u8] = b"an unexpected error has occurred";
         let mut has_error_code = false;
         if let Some(err) = self.result.fail {
-            // TODO(port): result.fail is anyerror (bun_core::Error) — .name() returns &'static str
             code = err.name().as_bytes();
             has_error_code = true;
         } else if let Some(body) = &self.result.body {
@@ -314,8 +315,6 @@ impl S3HttpSimpleTask {
                     }
                 }
             }
-            // PORT NOTE: Zig precedence: `!has_error and status == 200 or status == 206`
-            // is `(!has_error && status == 200) || status == 206` — preserved verbatim.
             if (!has_error && status == 200) || status == 206 {
                 return Ok(false);
             }
@@ -337,8 +336,8 @@ impl S3HttpSimpleTask {
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn on_response(this: *mut Self) -> JsTerminatedResult<()> {
         // SAFETY: `this` was produced by `S3HttpSimpleTask::new` (heap::alloc) and ownership is
-        // reclaimed here exactly once via the ConcurrentTask `.manual_deinit` contract. Dropping
-        // `this` at scope exit replaces Zig's `defer this.deinit()`.
+        // reclaimed here exactly once via the ConcurrentTask `.manual_deinit` contract;
+        // `this` is dropped at scope exit.
         let mut this = unsafe { bun_core::heap::take(this) };
 
         if !this.result.is_success() {
@@ -346,7 +345,7 @@ impl S3HttpSimpleTask {
             return Ok(());
         }
         debug_assert!(this.result.metadata.is_some());
-        // PORT NOTE: reshaped for borrowck — borrow response once, dispatch on a copy of `callback`.
+        // reshaped for borrowck — borrow response once, dispatch on a copy of `callback`.
         let response = &this.result.metadata.as_ref().unwrap().response;
         match this.callback {
             Callback::Stat(callback) => match response.status_code {
@@ -376,8 +375,8 @@ impl S3HttpSimpleTask {
             Callback::ListObjects(callback) => match response.status_code {
                 200 => {
                     if let Some(body) = &this.result.body {
-                        // PORT NOTE: parse_s3_list_objects_result is now infallible (alloc-only
-                        // failure modes abort in Rust), so the Zig `catch` arm is unreachable.
+                        // parse_s3_list_objects_result is infallible (alloc-only
+                        // failure modes abort).
                         let success =
                             list_objects::parse_s3_list_objects_result(body.list.as_slice());
                         callback(
@@ -398,7 +397,7 @@ impl S3HttpSimpleTask {
             Callback::Download(callback) => match response.status_code {
                 200 | 204 | 206 => {
                     let body = core::mem::take(&mut this.response_buffer);
-                    // PORT NOTE: re-borrow response after &mut access to response_buffer
+                    // re-borrow response after &mut access to response_buffer
                     let response = &this.result.metadata.as_ref().unwrap().response;
                     callback(
                         S3DownloadResult::Success(S3DownloadSuccess {
@@ -436,7 +435,7 @@ impl S3HttpSimpleTask {
         Ok(())
     }
 
-    /// this is the callback from the http.zig AsyncHTTP is always called from the HTTPThread
+    /// this is the AsyncHTTP callback and is always called from the HTTPThread
     ///
     /// # Safety
     /// `this` must be a live heap pointer produced by `S3HttpSimpleTask::new` and exclusively
@@ -458,24 +457,23 @@ impl S3HttpSimpleTask {
         // SAFETY: `result.body` (the only borrowed field) points at `this.response_buffer`, which
         // lives for the task's lifetime — extending to `'static` here is sound for self-reference.
         this.result = unsafe { result.detach_lifetime() };
-        // PORT NOTE: Zig does `this.http = async_http.*` (bitwise struct overwrite, no destructor
-        // on either side). `AsyncHTTP` transitively owns Drop types (`HTTPClient`, header
-        // `EntryList`s), so a plain Rust `=` here would (a) drop the old `this.http`, freeing heap
+        // `AsyncHTTP` transitively owns Drop types (`HTTPClient`, header
+        // `EntryList`s), so a plain `=` here would (a) drop the old `this.http`, freeing heap
         // buffers that `*async_http` (a bitwise clone created by the HTTP thread) still aliases,
         // and (b) leave the http-thread side to drop them again → double-free. We instead write
-        // through `MaybeUninit` to suppress the LHS drop and match Zig's overwrite semantics
-        // exactly. Ownership of the inner heap data conceptually transfers here; the http-thread
-        // side must free only its outer allocation (TrivialDeinit), mirroring AsyncHTTP.zig.
+        // through `MaybeUninit` to suppress the LHS drop, doing a bitwise struct overwrite
+        // with no destructor on either side. Ownership of the inner heap data conceptually
+        // transfers here; the http-thread side must free only its outer allocation
+        // (TrivialDeinit).
         // SAFETY: `async_http` is a valid live pointer for the duration of this callback;
         // `this.http` was previously initialised in `execute_simple_s3_request`.
         unsafe { core::ptr::write(this.http.as_mut_ptr(), core::ptr::read(async_http)) };
-        // PORT NOTE: Zig's `this.response_buffer = async_http.response_buffer.*` is a no-op
-        // bitwise self-copy (`async_http.response_buffer == &this.response_buffer`). In Rust the
-        // equivalent `=` would drop the live Vec before re-installing a stale bitwise duplicate
-        // (UAF + double-free), so we simply omit it — `this.response_buffer` already holds the
-        // body.
+        // `async_http.response_buffer == &this.response_buffer`, so copying it back would be
+        // a self-assignment: the `=` would drop the live Vec before re-installing a stale
+        // bitwise duplicate (UAF + double-free), so we simply omit it —
+        // `this.response_buffer` already holds the body.
         if is_done {
-            // PORT NOTE: compute the raw self-pointer before borrowing `this.concurrent_task`
+            // compute the raw self-pointer before borrowing `this.concurrent_task`
             // to avoid a stacked-borrows / aliasing diagnostic on `*this`.
             let this_ptr = std::ptr::from_mut::<Self>(this);
             let task = core::ptr::NonNull::from(
@@ -499,9 +497,9 @@ impl Drop for S3HttpSimpleTask {
         // Side effects beyond freeing owned fields (which Rust drops automatically):
         // - poll_ref.unref(vm)
         // - http.clearData()
-        // Owned-field frees from the Zig deinit (response_buffer, headers, sign_result, range,
+        // Owned-field frees (response_buffer, headers, sign_result, range,
         // proxy_url, result.certificate_info, result.metadata) are handled by their own Drop impls.
-        // PORT NOTE: KeepAlive::unref takes an aio EventLoopCtx; the JS-loop ctx is fetched via
+        // KeepAlive::unref takes an aio EventLoopCtx; the JS-loop ctx is fetched via
         // the global hook (registered by crate::init) — same pattern as
         // `event_loop_handle_to_ctx` in process.rs.
         self.poll_ref.unref(bun_io::posix_event_loop::get_vm_ctx(
@@ -509,18 +507,18 @@ impl Drop for S3HttpSimpleTask {
         ));
         // SAFETY: `http` is always initialised before the task pointer escapes (see
         // `execute_simple_s3_request`); `Drop` only runs via `on_response` after that point.
-        // Zig's `deinit` calls only `http.clearData()` and never runs a full AsyncHTTP destructor,
+        // Only `http.clear_data()` runs here — never a full AsyncHTTP destructor —
         // so we intentionally do NOT `assume_init_drop` here.
         let http = unsafe { self.http.assume_init_mut() };
         http.clear_data();
-        // Zig shared one EntryList allocation between task.headers / request_headers /
-        // client.header_entries; Rust `init` clones, so free the two copies clear_data() skips.
+        // `init` clones the EntryList into task.headers / request_headers /
+        // client.header_entries, so free the two copies clear_data() skips.
         http.request_headers = Default::default();
         http.client.header_entries = Default::default();
     }
 }
 
-// PORT NOTE: callers in `client.rs` / `multipart.rs` were translated with three different
+// callers in `client.rs` / `multipart.rs` were translated with three different
 // names for the request-options struct (`Options`, `S3RequestOptions`, `S3SimpleRequestOptions`)
 // and two for the callback enum. Alias them here so the call sites compile without churn.
 pub type Options<'a> = S3SimpleRequestOptions<'a>;
@@ -589,7 +587,7 @@ pub(crate) fn execute_simple_s3_request(
     ) {
         Ok(r) => r,
         Err(sign_err) => {
-            // options.range drops here automatically (Zig: bun.default_allocator.free(range_))
+            // options.range drops here automatically
             drop(options.range);
             let error_code_and_message = get_sign_error_code_and_message(sign_err.into());
             callback.fail(
@@ -622,7 +620,7 @@ pub(crate) fn execute_simple_s3_request(
     };
 
     let task_ptr = S3HttpSimpleTask::new(S3HttpSimpleTask {
-        // Zig used `= undefined`; written below via `MaybeUninit::write` before any read.
+        // written below via `MaybeUninit::write` before any read.
         http: core::mem::MaybeUninit::uninit(),
         sign_result: result,
         callback_context,
@@ -634,6 +632,7 @@ pub(crate) fn execute_simple_s3_request(
         result: HTTPClientResult::default(),
         concurrent_task: ConcurrentTask::default(),
         proxy_url: Box::default(),
+        body: Box::<[u8]>::from(options.body),
         poll_ref: KeepAlive::init(),
     });
     // SAFETY: `task_ptr` is a freshly heap-allocated pointer; exclusive access here.
@@ -651,21 +650,16 @@ pub(crate) fn execute_simple_s3_request(
     // SAFETY: lifetime extension — `url`, `headers_buf`, and `proxy_url` borrow from
     // heap-allocated fields of `*task` (sign_result.url / headers.buf / proxy_url) which the task
     // outlives. AsyncHTTP::init wants `'static` borrows because the HTTP thread reads them
-    // concurrently; they remain valid until `task` is dropped in `on_response`. The Zig source
-    // passed raw slices with the same ownership contract.
+    // concurrently; they remain valid until `task` is dropped in `on_response`.
     let url = URL::parse(unsafe { bun_ptr::detach_lifetime_ref(&*task.sign_result.url) });
     // SAFETY: same lifetime-extension invariant as `url` above — `task.headers.buf` is heap-owned
     // by `*task` and outlives the AsyncHTTP request.
     let headers_buf: &'static [u8] =
         unsafe { bun_ptr::detach_lifetime(task.headers.buf.as_slice()) };
-    // SAFETY: lifetime extension — unlike the borrows above, `body` is NOT stored in the task —
-    // it is caller-owned (e.g. multipart upload part data / multipart_upload_list). The Zig source
-    // (.zig:431) passes the caller's slice directly with the same implicit contract: every call
-    // site keeps `body` alive until the request completes. This is the PORTING.md-forbidden
-    // lifetime-extension pattern, retained verbatim to match Zig semantics.
-    // TODO(port): take body as `*const [u8]` in AsyncHTTP::init (or store an owned copy on the
-    // task) to drop the `'static` pretence.
-    let body: &'static [u8] = unsafe { bun_ptr::detach_lifetime(options.body) };
+    // SAFETY: same lifetime-extension invariant as `url` above — `task.body` is a heap-owned
+    // `Box<[u8]>` field of `*task` (an owned copy of the caller's slice) and outlives the
+    // AsyncHTTP request; it is freed only when `task` is dropped in `on_response`.
+    let body: &'static [u8] = unsafe { bun_ptr::detach_lifetime(&*task.body) };
     let http_proxy = if !task.proxy_url.is_empty() {
         // SAFETY: same lifetime-extension invariant as `url` above — `task.proxy_url` is a
         // heap-owned `Box<[u8]>` field of `*task` and outlives the AsyncHTTP request.
@@ -707,5 +701,3 @@ pub(crate) fn execute_simple_s3_request(
     bun_http::HTTPThread::schedule(batch);
     Ok(())
 }
-
-// ported from: src/runtime/webcore/s3/simple_request.zig
diff --git a/src/runtime/webcore/streams.rs b/src/runtime/webcore/streams.rs
index 77c158342b6..dedc030ef92 100644
--- a/src/runtime/webcore/streams.rs
+++ b/src/runtime/webcore/streams.rs
@@ -16,7 +16,7 @@ use crate::webcore::blob::Any as AnyBlob;
 use crate::webcore::sink::Sink;
 use crate::webcore::{AutoFlusher, ByteListPool};
 
-// PORT NOTE: scope statics renamed with `Log` suffix so they don't collide with
+// scope statics renamed with `Log` suffix so they don't collide with
 // the `HTTPServerWritable<SSL,H3>` / `NetworkSink` *types* defined below
 // (RequestContext was blocked on this name clash).
 bun_core::declare_scope!(HTTPServerWritableLog, visible);
@@ -33,8 +33,8 @@ pub mod bun_s3 {
     pub use crate::webcore::s3::MultiPartUpload;
 }
 
-/// `Blob.SizeType` is `u52` in Zig; the Rust port uses `u64` (see `webcore::blob::SizeType`).
-// PORT NOTE: alias the canonical `webcore::BlobSizeType` so `SignalVTable.ready`'s
+/// `Blob.SizeType` is `u64` (see `webcore::blob::SizeType`).
+// alias the canonical `webcore::BlobSizeType` so `SignalVTable.ready`'s
 // fn-pointer signature is structurally identical to callers that name the public
 // re-export (e.g. `sink::SinkSignal::init`).
 type BlobSizeType = crate::webcore::BlobSizeType;
@@ -95,10 +95,10 @@ impl Start {
             Start::ChunkSize(chunk) => Ok(JSValue::from(chunk)),
             Start::Err(err) => Err(err.throw(global_this)),
             Start::OwnedAndDone(list) => {
-                // PORT NOTE: Zig captures `|list|` by bitwise copy with no destructor and
-                // hands the allocation to JSC (no-copy + MarkedArrayBuffer_deallocator). In
-                // Rust `list` is an owned Vec whose Drop would free the same buffer →
-                // double-free. Suppress Drop via ManuallyDrop so JSC is the sole owner.
+                // The allocation is handed to JSC (no-copy +
+                // MarkedArrayBuffer_deallocator). `list` is an owned Vec whose Drop would
+                // free the same buffer → double-free. Suppress Drop via ManuallyDrop so
+                // JSC is the sole owner.
                 let mut list = core::mem::ManuallyDrop::new(list);
                 let ab = ArrayBuffer::from_bytes(list.slice_mut(), JSType::Uint8Array);
                 ab.to_js(global_this)
@@ -117,10 +117,8 @@ impl Start {
 
         if let Some(chunk_size) = value.get(global_this, b"chunkSize")? {
             if chunk_size.is_number() {
-                // Zig: `@as(Blob.SizeType, @intCast(@truncate(@as(i52, chunkSize.toInt64()))))`
-                // — `@truncate` to i52 then `@intCast` to u32. Low-32-bit wrap matches that
-                // for the in-range values JS can produce; revisit if exact i52 sign-extension
-                // semantics matter.
+                // Low-32-bit wrap is correct for the in-range values JS can produce;
+                // revisit if exact i52 sign-extension semantics matter.
                 return Ok(Start::ChunkSize(chunk_size.to_int64() as BlobSizeType));
             }
         }
@@ -128,11 +126,9 @@ impl Start {
         Ok(Start::Empty)
     }
 
-    /// Runtime-tag dispatcher for `from_js_with_tag`. Zig calls
-    /// `Start.fromJSWithTag(..., comptime tag)` from `JSSink.start` via
-    /// `@field(streams.Start, abi_name)`; Rust models the per-sink tag as
-    /// `JsSinkType::START_TAG` (a runtime `Option<StartTag>`) so we re-enter
-    /// the const-generic body via this match.
+    /// Runtime-tag dispatcher for `from_js_with_tag`. The per-sink tag is
+    /// `JsSinkType::START_TAG` (a runtime `Option<StartTag>`); this match
+    /// re-enters the tag-specific body.
     pub fn from_js_with_runtime_tag(
         global_this: &JSGlobalObject,
         value: JSValue,
@@ -177,9 +173,9 @@ impl Start {
                 let mut chunk_size: BlobSizeType = 0;
                 let mut empty = true;
 
-                // TODO(port): Zig used `getOwn`; `bun_jsc::JSValue::get_own` not yet
-                // exported — `get` walks the prototype chain. Swap once available.
-                if let Some(val) = value.get(global_this, b"asUint8Array")? {
+                if let Some(val) =
+                    value.get_own(global_this, &bun_core::String::static_str("asUint8Array"))?
+                {
                     if val.is_boolean() {
                         as_uint8array = val.to_boolean();
                         empty = false;
@@ -198,7 +194,6 @@ impl Start {
                 {
                     if chunk_size_val.is_number() {
                         empty = false;
-                        // Zig: `@intCast(@max(0, @as(i51, @truncate(toInt64()))))`
                         chunk_size = 0i64.max(chunk_size_val.to_int64()) as BlobSizeType;
                     }
                 }
@@ -218,7 +213,6 @@ impl Start {
                     value.fast_get(global_this, jsc::BuiltinName::HighWaterMark)?
                 {
                     if chunk_size_val.is_number() {
-                        // Zig: `@intCast(@max(0, @as(i51, @truncate(toInt64()))))`
                         chunk_size = 0i64.max(chunk_size_val.to_int64()) as BlobSizeType;
                     }
                 }
@@ -235,8 +229,6 @@ impl Start {
                     return Ok(Start::FileSink(FileSinkOptions {
                         chunk_size,
                         input_path: crate::webcore::PathOrFileDescriptor::Path(
-                            // Zig `path.toSlice(globalThis, allocator)` — allocator param
-                            // folded into the owning `ZigStringSlice`.
                             path.to_slice(global_this)?,
                         ),
                         ..Default::default()
@@ -284,7 +276,6 @@ impl Start {
                 {
                     if chunk_size_val.is_number() {
                         empty = false;
-                        // Zig: `@intCast(@max(256, @as(i51, @truncate(toInt64()))))`
                         chunk_size = 256i64.max(chunk_size_val.to_int64()) as BlobSizeType;
                     }
                 }
@@ -294,9 +285,8 @@ impl Start {
                 }
             }
             _ => {
-                // Zig: `@compileError("Unsupported tag " ++ @tagName(tag))` — const-generic
-                // monomorphization makes this dead for valid TAG; runtime unreachable
-                // until `generic_const_exprs` lets us hoist to a compile error.
+                // Dead for every valid TAG; runtime unreachable until
+                // `generic_const_exprs` lets us hoist to a compile error.
                 unreachable!("Unsupported StartTag");
             }
         }
@@ -310,13 +300,15 @@ impl Start {
 // ──────────────────────────────────────────────────────────────────────────
 
 pub enum StreamResult {
-    // TODO(port): BORROW_PARAM `&'a mut Pending` — self-referential via Pending.result; using raw ptr
+    // Self-referential: the pointee's `Pending.result` points back at this value, so a
+    // `&'a mut Pending` borrow can't be expressed; raw pointer with the BORROW_PARAM
+    // contract (pointee strictly outlives this result).
     Pending(*mut Pending),
     Err(StreamError),
     Done,
     Owned(Vec<u8>),
     OwnedAndDone(Vec<u8>),
-    // PORT NOTE: `temporary*` payloads are borrowed slices into caller-owned
+    // `temporary*` payloads are borrowed slices into caller-owned
     // memory that strictly outlives the synchronous consumer call. Stored as
     // `RawSlice<u8>` (raw fat pointer, no Drop) — the consumer must copy
     // before returning and never retain the slice. See `RawSlice` invariant.
@@ -327,7 +319,8 @@ pub enum StreamResult {
 }
 
 impl StreamResult {
-    // TODO(port): not Drop — Result is bitwise-copied in to_js() shutdown path; ownership is contextual.
+    // Intentionally not Drop — Result is bitwise-copied in the to_js() shutdown path, so
+    // ownership is contextual and a Drop impl would double-free.
     // Named `release` (not `deinit`) per PORTING.md — `pub fn deinit` is forbidden as a public API.
     pub fn release(&mut self) {
         match self {
@@ -388,8 +381,8 @@ pub enum ResultTag {
 
 impl StreamResult {
     pub fn slice16(&self) -> &[u16] {
-        // Caller guarantees bytes are u16-aligned and even length (mirrors Zig
-        // @ptrCast/@alignCast); bytemuck checks both at runtime.
+        // Caller guarantees bytes are u16-aligned and even length;
+        // bytemuck checks both at runtime.
         bytemuck::cast_slice(self.slice())
     }
 
@@ -407,7 +400,8 @@ impl StreamResult {
 // ─── Result.Writable ─────────────────────────────────────────────────────
 
 pub enum Writable {
-    // TODO(port): BORROW_PARAM `&'a mut WritablePending` — self-referential via WritablePending.result; using raw ptr
+    // Self-referential via WritablePending.result (see StreamResult::Pending above);
+    // raw pointer with the BORROW_PARAM contract.
     Pending(*mut WritablePending),
     Err(SysError),
     Done,
@@ -437,8 +431,8 @@ impl Default for WritablePending {
     }
 }
 
-// PORT NOTE: Zig `WritablePending.deinit` / `WritableFuture.deinit` only deinit the owned
-// JSPromiseStrong field — JSPromiseStrong implements Drop, so no explicit Drop impl is needed here.
+// `WritablePending` / `WritableFuture` only own the JSPromiseStrong field —
+// JSPromiseStrong implements Drop, so no explicit Drop impl is needed here.
 
 pub enum WritableFuture {
     None,
@@ -479,7 +473,7 @@ pub struct WritableHandler {
 
 pub type WritableHandlerFn = fn(ctx: *mut c_void, result: Writable);
 
-/// Trait replacing Zig's `comptime handler_fn` — implementors provide the callback.
+/// Implementors provide the write-completion callback.
 pub trait WritablePendingCallback {
     fn on_handle(&mut self, result: Writable);
 }
@@ -504,10 +498,8 @@ impl WritablePending {
     /// `consumed` and pins the state at `Pending` so a later `run()` resolves
     /// the buffered amount.
     ///
-    /// PORT NOTE: Zig html_rewriter calls `pending.applyBackpressure(allocator,
-    /// &this.output, pending, bytes)` — that decl never existed in Zig (the
-    /// caller is dead code there). This is the minimal real implementation
-    /// matching that call shape.
+    /// This is the minimal implementation matching the html_rewriter
+    /// call shape.
     pub fn apply_backpressure(&mut self, _output: &mut Sink<'_>, bytes: &[u8]) {
         self.consumed = self.consumed.saturating_add(bytes.len() as BlobSizeType);
         self.state = PendingState::Pending;
@@ -532,7 +524,7 @@ impl WritablePending {
                     ctx: h.ctx,
                     handler: h.handler,
                 });
-                // PORT NOTE: Zig left self.result intact (bitwise copy); reset to Done here —
+                // Reset self.result to Done here —
                 // verify no caller reads it after run().
                 (h.handler)(h.ctx, core::mem::replace(&mut self.result, Writable::Done));
             }
@@ -628,7 +620,8 @@ pub struct Pending {
 impl Default for Pending {
     fn default() -> Self {
         Self {
-            // TODO(port): Zig `future: Future = undefined` — using Handler with null ctx as placeholder
+            // A Handler with null ctx is the inert placeholder;
+            // always overwritten before the future is invoked.
             future: PendingFuture::Handler(PendingHandler {
                 ctx: core::ptr::null_mut(),
                 handler: |_, _| {},
@@ -639,7 +632,7 @@ impl Default for Pending {
     }
 }
 
-/// Trait replacing Zig's `comptime handler_fn` for Result.Pending.
+/// Implementors provide the callback for Result.Pending.
 pub trait PendingCallback {
     fn on_handle(&mut self, result: StreamResult);
 }
@@ -672,10 +665,8 @@ impl Pending {
         }
 
         let clone = Box::new(core::mem::take(self));
-        // PORT NOTE: Zig copied *self then reset only state+result (zig:451-452);
-        // `mem::take` already resets `state`/`result`/`future` via `Default`, so the
-        // explicit re-assignments are unnecessary here. Zig left `future` untouched —
-        // no reader observes it after this.
+        // `mem::take` resets `state`/`result`/`future` via `Default`;
+        // no reader observes `future` after this.
         // VM event loop is a singleton; temporary `&mut` is the sole borrow
         // for the duration of `enqueue_task` (no re-entry into Rust).
         // `Task::from_boxed` owns the `Box → *mut` leak; the matching
@@ -704,7 +695,8 @@ impl bun_event_loop::Taskable for Pending {
 
 pub enum PendingFuture {
     Promise {
-        // TODO(port): JSC_BORROW *mut JSPromise — GC-rooted via protect/unprotect
+        // JSC_BORROW: raw `*mut JSPromise`, GC-rooted via protect/unprotect (protected when
+        // stored, unprotected when the future is fulfilled or deinitialized).
         promise: *mut JSPromise,
         // JSC_BORROW: process-lifetime VM global; safe `Deref` via `BackRef`.
         global_this: BackRef<JSGlobalObject>,
@@ -771,7 +763,7 @@ impl Pending {
                 StreamResult::fulfill_promise(&mut self.result, *promise, global_this);
             }
             PendingFuture::Handler(h) => {
-                // PORT NOTE: Zig left self.result intact (bitwise copy); reset to Done here —
+                // Reset self.result to Done here —
                 // verify no caller reads it after run().
                 (h.handler)(
                     h.ctx,
@@ -801,8 +793,8 @@ impl StreamResult {
     ) {
         // dropped (only used for read-only `event_loop()`) before any re-entrant call.
         let vm = global_this.bun_vm();
-        // PORT NOTE: Zig holds `loop` and `promise` across re-entrant resolve/reject.
-        // In Rust a long-lived `&mut EventLoop` / `&mut JSPromise` would alias any
+        // A long-lived `&mut EventLoop` / `&mut JSPromise` held across
+        // re-entrant resolve/reject would alias any
         // `&mut` the re-entered JS path materializes through `vm.event_loop()` or the
         // same promise. `event_loop_ref()` is the audited safe accessor that forms a
         // fresh temporary `&mut EventLoop` per call so no two `&mut` are live at once.
@@ -811,7 +803,7 @@ impl StreamResult {
         let _unprotect = jsc::js_value::Protected::adopt(JSPromise::opaque_ref(promise).to_js());
 
         vm.event_loop_ref().enter();
-        // PORT NOTE: cannot capture &mut event_loop in scopeguard while also using
+        // cannot capture &mut event_loop in scopeguard while also using
         // `promise` (borrowck); call exit() explicitly on each path instead.
 
         match result {
@@ -862,18 +854,15 @@ impl StreamResult {
 
     pub fn to_js(&mut self, global_this: &JSGlobalObject) -> JsResult<JSValue> {
         if VirtualMachine::get().is_shutting_down() {
-            // Zig copies `*this` to `that` and calls `that.deinit()` — a bitwise move of
-            // ownership out of `*this` followed by free. `release()` is the port of `deinit`;
-            // call it on `self` so `.owned`/`.owned_and_done` ByteLists are freed and
-            // `.err.JSValue` is unprotected instead of leaking on the shutdown path.
+            // `release()` frees `.owned`/`.owned_and_done` ByteLists and
+            // unprotects `.err.JSValue` instead of leaking on the shutdown path.
             self.release();
             return Ok(JSValue::ZERO);
         }
 
         match self {
             StreamResult::Owned(list) => {
-                // PORT NOTE: Zig overwrites `result.* = .{ .temporary = .{} }` with no
-                // destructor after handing the buffer to JSC. In Rust the later
+                // The buffer is handed to JSC; the later
                 // `*result = Temporary(...)` in fulfill_promise drops the old Vec,
                 // double-freeing the allocation now owned by JSC. Move it out and suppress
                 // Drop so JSC's MarkedArrayBuffer_deallocator is the sole owner.
@@ -882,15 +871,23 @@ impl StreamResult {
                 ab.to_js(global_this)
             }
             StreamResult::OwnedAndDone(list) => {
-                // PORT NOTE: see Owned arm above — same ownership transfer to JSC.
+                // see Owned arm above — same ownership transfer to JSC.
                 let mut taken = core::mem::ManuallyDrop::new(core::mem::take(list));
                 let ab = ArrayBuffer::from_bytes(taken.slice_mut(), JSType::Uint8Array);
                 ab.to_js(global_this)
             }
             StreamResult::Temporary(temp) | StreamResult::TemporaryAndDone(temp) => {
-                // TODO(port): JSValue::create_uninitialized_uint8_array — falls
-                // back to ArrayBuffer::create (copies) until the no-init path lands.
-                ArrayBuffer::create::<{ JSType::Uint8Array }>(global_this, temp.slice())
+                // Allocate an uninitialized Uint8Array and
+                // memcpy the temporary chunk into it — avoids the extra zeroing that
+                // `ArrayBuffer::create` would do.
+                let temp_slice = temp.slice();
+                let array =
+                    JSValue::create_uninitialized_uint8_array(global_this, temp_slice.len())?;
+                let mut buf = array
+                    .as_array_buffer(global_this)
+                    .expect("freshly created Uint8Array has a backing buffer");
+                buf.slice_mut()[..temp_slice.len()].copy_from_slice(temp_slice);
+                Ok(array)
             }
             StreamResult::IntoArray(array) => Ok(JSValue::from(array.len)),
             StreamResult::IntoArrayAndDone(array) => Ok(JSValue::from(array.len)),
@@ -1018,8 +1015,7 @@ impl Default for SignalVTable {
     }
 }
 
-/// Trait replacing Zig's `@hasDecl(Wrapped, "onClose")` duck-typing.
-/// Default methods named `on_*` mirror the Zig fallback to `close`/`ready`/`start`.
+/// Implementors provide the `on_close`/`on_ready`/`on_start` callbacks.
 pub trait SignalHandler {
     fn on_close(&mut self, err: Option<SysError>);
     fn on_ready(&mut self, amount: Option<BlobSizeType>, offset: Option<BlobSizeType>);
@@ -1045,11 +1041,10 @@ impl SignalVTable {
             unsafe { bun_ptr::callback_ctx::<W>(this) }.on_start();
         }
 
-        // PORT NOTE: Zig used `comptime &VTable.wrap(Type)` for a static address.
         // Rust cannot const-promote a generic-dependent struct literal to
         // `&'static`, so the vtable is stored by-value in `Signal` instead
-        // (three fn pointers — same size as the Zig `*const VTable` payload
-        // would dereference to anyway).
+        // (three fn pointers — same size as the pointed-to payload a
+        // `&'static VTable` would dereference to anyway).
         SignalVTable {
             close: on_close::<W>,
             ready: on_ready::<W>,
@@ -1062,8 +1057,9 @@ impl SignalVTable {
 // HTTPServerWritable
 // ──────────────────────────────────────────────────────────────────────────
 
-// TODO(port): type-level branch `if (http3) uws.H3.Response else uws.NewApp(ssl).Response`
-// requires associated-type trait keyed on const generics. Using opaque c_void for now.
+// Selecting the response type from the const generics would require an
+// associated-type trait keyed on them. The pointer is kept opaque at the
+// type level; all dispatch happens at runtime through `any_res()` / `uws::AnyResponse`.
 pub type UwsResponse<const SSL: bool, const HTTP3: bool> = c_void;
 
 pub struct HTTPServerWritable<const SSL: bool, const HTTP3: bool> {
@@ -1075,7 +1071,7 @@ pub struct HTTPServerWritable<const SSL: bool, const HTTP3: bool> {
     pub is_listening_for_abort: bool,
     pub wrote: BlobSizeType,
 
-    // PORT NOTE: allocator field dropped — global mimalloc per §Allocators
+    // allocator field dropped — global mimalloc per §Allocators
     pub done: bool,
     pub signal: Signal,
     pub pending_flush: Option<*mut JSPromise>,
@@ -1156,7 +1152,7 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
     } else {
         "HTTPResponseSink"
     };
-    // PORT NOTE: associated const with const-generic if — requires `#![feature(generic_const_exprs)]` or a trait-based dispatch.
+    // associated const with const-generic if — requires `#![feature(generic_const_exprs)]` or a trait-based dispatch.
 }
 
 /// Per-monomorphization JSSink wrapper alias. Mirrors
@@ -1224,7 +1220,6 @@ impl<const SSL: bool, const HTTP3: bool> crate::webcore::sink::JsSinkAbi
 
 impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
     /// Const-generic → runtime dispatch for the type-erased `res` field.
-    /// Mirrors Zig's `const UWSResponse = if (http3) uws.H3.Response else uws.NewApp(ssl).Response`.
     #[inline]
     fn any_res(&self) -> Option<uws::AnyResponse> {
         let res = self.res?;
@@ -1282,7 +1277,7 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
             );
             return false;
         };
-        // PORT NOTE: Zig holds `res` across `handleFirstWriteIfNecessary`, whose
+        // `res` is held across `handleFirstWriteIfNecessary`, whose
         // callback (RequestContext.renderMetadata) writes status/headers through
         // the same uWS response. `AnyResponse` is `Copy` and dispatches to
         // zero-sized opaque handles, so reusing `res` across the re-entrant
@@ -1369,7 +1364,7 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
             );
             return false;
         };
-        // `res` is `Copy` (raw uWS handle); see PORT NOTE in
+        // `res` is `Copy` (raw uWS handle); see the note in
         // `send_without_auto_flusher` re: holding it across `on_first_write`.
 
         if self.requested_end && !res.state().is_http_write_called() {
@@ -1424,8 +1419,7 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
     }
 
     fn readable_slice(&self) -> &[u8] {
-        // Zig `this.buffer.ptr[this.offset..this.buffer.len]`; `handle_wrote`
-        // maintains `offset <= buffer.len()`.
+        // `handle_wrote` maintains `offset <= buffer.len()`.
         &self.buffer[self.offset as usize..]
     }
 
@@ -1446,10 +1440,12 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
         // if we do, it will cause this to be delayed until the next call, each time
         // TODO: should we break it in smaller chunks?
         let to_write = (write_offset as BlobSizeType).min(self.buffer.len() as BlobSizeType - 1);
-        // PORT NOTE: reshaped for borrowck — capture chunk len before send()
+        // Capture the chunk length before send.
+        // `send_readable` re-slices the buffer at call time, which observes any
+        // mutation send's internals perform. The length is used only for
+        // `total_written` and the empty check.
         let chunk_start = to_write as usize;
         let chunk_len = self.readable_slice().len().saturating_sub(chunk_start);
-        // TODO(port): Zig slices readableSlice()[to_write..]; recompute after potential mutation in send
         // if we have nothing to write, we are done
         if chunk_len == 0 {
             if self.done {
@@ -1859,7 +1855,7 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
 
     fn register_auto_flusher(&mut self) {
         let Some(res) = self.any_res() else { return };
-        // Match streams.zig:1231 — reset per-enqueue so a long stream of
+        // Reset per-enqueue so a long stream of
         // sub-highWaterMark writes between auto-flushes still bumps the idle
         // timeout.
         res.reset_timeout();
@@ -1954,8 +1950,6 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
 
             self.buffer = Vec::<u8>::default();
             self.pooled_buffer = None;
-            // PORT NOTE: Zig `pooled.release()` → Rust `ObjectPool::release(node)`
-            // (the Node `Parent` back-ref was dropped in the port; see pool.rs).
             // SAFETY: `pooled` was obtained from `ByteListPool::get_node` and is
             // exclusively owned by this stream; `data` was rewritten just above,
             // so it is initialized. Ownership returns to the pool.
@@ -1971,8 +1965,9 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
         }
     }
 
-    pub fn flush_promise(&mut self) -> JsResult<()> {
-        // TODO(port): narrow error set — Zig: bun.JSTerminated!void
+    /// Only VM termination
+    /// escapes; promise resolution cannot raise an ordinary JS exception here.
+    pub fn flush_promise(&mut self) -> core::result::Result<(), jsc::JsTerminated> {
         if let Some(prom) = self.pending_flush.take() {
             bun_core::scoped_log!(HTTPServerWritableLog, "flushPromise()");
 
@@ -1983,8 +1978,8 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
                 global_this,
                 JSValue::js_number(self.wrote.saturating_sub(self.wrote_at_start_of_flush) as f64),
             );
-            // PORT NOTE: Zig `defer this.wrote_at_start_of_flush = this.wrote` reads `this.wrote`
-            // at scope exit (AFTER resolve, which may reenter JS and mutate `wrote`). Read it here,
+            // `this.wrote_at_start_of_flush = this.wrote` must read `this.wrote`
+            // AFTER resolve, which may reenter JS and mutate `wrote`. Read it here,
             // not before the call.
             //
             // R-2 noalias mitigation (PORT_NOTES_PLAN R-2; precedent
@@ -1992,14 +1987,14 @@ impl<const SSL: bool, const HTTP3: bool> HTTPServerWritable<SSL, HTTP3> {
             // and `resolve()` receives nothing derived from `self`, so LLVM is
             // licensed to forward the `self.wrote` read used in the
             // `js_number(...)` argument above into this assignment — defeating
-            // the very ordering the PORT NOTE exists to preserve. ASM-verified
+            // the very ordering the note above exists to preserve. ASM-verified
             // PROVEN_CACHED. Launder `self` so the post-resolve `wrote` read
             // goes through an opaque pointer.
             let this: *mut Self = core::hint::black_box(core::ptr::from_mut(self));
             // SAFETY: `this` is the live heap payload (refcounted via the JS
             // wrapper); momentary access only.
             unsafe { (*this).wrote_at_start_of_flush = (*this).wrote };
-            return Ok(result?);
+            return result;
         }
         Ok(())
     }
@@ -2072,9 +2067,9 @@ pub type H3ResponseSink = HTTPServerWritable<true, true>;
 // ──────────────────────────────────────────────────────────────────────────
 
 pub struct NetworkSink {
-    // TODO(port): SHARED Option<Arc<MultiPartUpload>> per LIFETIMES.tsv — but Zig calls task.deref()
-    // (intrusive refcount). Stored as `BackRef` (set-once, counted ref keeps the
-    // pointee alive while `Some`; released in `detach_writable`). TODO(refactor): confirm Arc vs IntrusiveArc.
+    // Stored as `BackRef`
+    // (set-once); while `Some` the sink holds a counted ref on the intrusively
+    // ref-counted `MultiPartUpload`, released in `detach_writable`.
     pub task: Option<BackRef<bun_s3::MultiPartUpload>>,
     pub signal: Signal,
     // JSC_BORROW: process-lifetime VM global; safe `Deref` via `BackRef`.
@@ -2188,12 +2183,13 @@ impl NetworkSink {
         }
     }
 
+    /// Narrowed like
+    /// `flushPromise`; promise resolution only fails on VM termination.
     pub fn on_writable(
         task: &mut bun_s3::MultiPartUpload,
         this: &mut NetworkSink,
         flushed: u64,
-    ) -> JsResult<()> {
-        // TODO(port): narrow error set — Zig: bun.JSTerminated!void
+    ) -> core::result::Result<(), jsc::JsTerminated> {
         bun_core::scoped_log!(
             NetworkSinkLog,
             "onWritable flushed: {} state: {}",
@@ -2426,12 +2422,9 @@ pub type NetworkSinkJSSink = crate::webcore::sink::JSSink<NetworkSink>;
 // BufferAction
 // ──────────────────────────────────────────────────────────────────────────
 //
-// Zig models this as `union(enum) { text/arrayBuffer/blob/bytes/json: JSPromise.Strong }`
-// purely so `switch (this.*) { inline else => |p| ... }` gives a one-line forwarder and
-// `@typeInfo(...).tag_type` gives a free Tag enum. In Rust neither shortcut exists, and
-// every variant carries the *same* payload, so the idiomatic shape is `{tag, payload}`.
+// Every variant carries the *same* payload, so the idiomatic shape is `{tag, payload}`.
 // No caller pattern-matches on the variant — they only read `.tag()` or forward to the
-// promise — so this is layout-only, behaviour-identical.
+// promise.
 
 pub struct BufferAction {
     tag: BufferActionTag,
@@ -2499,7 +2492,6 @@ impl BufferAction {
     }
 }
 
-// PORT NOTE: Zig `BufferAction.deinit` only deinits the JSPromiseStrong payload.
 // JSPromiseStrong implements Drop, so the struct drops it automatically — no explicit
 // `impl Drop for BufferAction` needed.
 
@@ -2511,8 +2503,10 @@ pub enum ReadResult {
     Pending,
     Err(SysError),
     Done,
+    // Ownership of the slice is contextual: consumers compare `slice.ptr != buf.ptr` to
+    // decide whether the bytes are owned or alias the caller's buffer, so a raw slice
+    // pointer (no Drop) is the only honest representation.
     Read(*mut [u8]),
-    // TODO(port): `[]u8` field — ownership depends on `slice.ptr != buf.ptr` check; using raw slice ptr
 }
 
 impl ReadResult {
@@ -2539,8 +2533,8 @@ impl ReadResult {
             ReadResult::Err(err) => StreamResult::Err(StreamError::Error(err)),
             ReadResult::Done => StreamResult::Done,
             ReadResult::Read(slice) => 'brk: {
-                // PORT NOTE: Zig's `slice` may point at the same allocation as
-                // `buf` (it checks `slice.ptr != buf.ptr`). Forming `&mut *slice`
+                // `slice` may point at the same allocation as
+                // `buf` (we check `slice.ptr != buf.ptr`). Forming `&mut *slice`
                 // while the `buf: &mut [u8]` parameter is live would violate
                 // Rust's aliasing rules in the `!owned` case. Stay on raw
                 // pointers: `<*mut [u8]>::len()` reads only the fat-pointer
@@ -2551,8 +2545,8 @@ impl ReadResult {
                 let owned = slice_ptr.cast_const() != buf.as_ptr();
                 let done = is_done || (close_on_empty && slice_len == 0);
 
-                // Zig `bun.Vec<u8>.fromOwnedSlice(slice)` adopts an existing heap
-                // allocation by pointer/len (cap = len). The contract is: when
+                // An existing heap allocation is adopted
+                // by pointer/len (cap = len). The contract is: when
                 // `slice.ptr != buf.ptr` the slice IS a default-allocator heap
                 // allocation whose ownership is being transferred into the
                 // StreamResult, and downstream `Result.release()` frees it via
@@ -2587,5 +2581,3 @@ impl ReadResult {
         }
     }
 }
-
-// ported from: src/runtime/webcore/streams.zig
diff --git a/src/runtime/webcore/wasm_streaming.rs b/src/runtime/webcore/wasm_streaming.rs
index 34b28942775..ea8df6b44ee 100644
--- a/src/runtime/webcore/wasm_streaming.rs
+++ b/src/runtime/webcore/wasm_streaming.rs
@@ -1,7 +1,7 @@
-//! `Zig__GlobalObject__getBodyStreamOrBytesForWasmStreaming` — moved UP from
-//! `bun_jsc::JSGlobalObject` because the body inspects `Response`/`Body`/
+//! `Zig__GlobalObject__getBodyStreamOrBytesForWasmStreaming` — lives here rather
+//! than in `bun_jsc::JSGlobalObject` because the body inspects `Response`/`Body`/
 //! `Blob`/`ReadableStream`, which are `bun_runtime` types (forward-dep of
-//! `bun_jsc`). The Zig original lives in `src/jsc/JSGlobalObject.zig:871`.
+//! `bun_jsc`).
 //!
 //! C++ calls this via `jsc.host_fn.wrap3` — i.e. plain C ABI with the three
 //! original arguments, returning a possibly-empty `JSValue` (empty == thrown).
@@ -26,7 +26,6 @@ unsafe extern "C" {
     );
 }
 
-/// Spec `JSGlobalObject.zig:871 getBodyStreamOrBytesForWasmStreaming`.
 pub(crate) fn get_body_stream_or_bytes_for_wasm_streaming(
     this: &JSGlobalObject,
     response_value: JSValue,
@@ -64,7 +63,7 @@ pub(crate) fn get_body_stream_or_bytes_for_wasm_streaming(
                 )
                 .throw());
         }
-        // `content_type_slice` drops here (Zig: `ZigString` is a borrow, no deinit needed).
+        // `content_type_slice` drops here.
     }
 
     if !response.is_ok() {
@@ -88,9 +87,9 @@ pub(crate) fn get_body_stream_or_bytes_for_wasm_streaming(
             .throw());
     }
 
-    // PORT NOTE: reshaped for borrowck — Zig holds `body = response.getBodyValue()` as
-    // a single live pointer through `getBodyReadableStream`; in Rust that overlaps two
-    // `&mut` borrows of `response`, so we re-borrow per use and capture scalars.
+    // Holding `body = response.get_body_value()` as a single live pointer
+    // through `getBodyReadableStream` would overlap two `&mut` borrows
+    // of `response`, so we re-borrow per use and capture scalars.
     {
         let body = response.get_body_value();
         if let BodyValue::Error(err) = body {
@@ -126,7 +125,6 @@ pub(crate) fn get_body_stream_or_bytes_for_wasm_streaming(
         // (using any_blob.slice() would return a bogus empty slice)
 
         // Logic from JSC.WebCore.Body.Value.toReadableStream
-        // Zig: `var blob = any_blob.Blob;` — the union payload, by value.
         let AnyBlob::Blob(blob) = any_blob else {
             unreachable!("Any::store() returned Some, so this is the Blob variant");
         };
@@ -150,9 +148,8 @@ pub(crate) fn get_body_stream_or_bytes_for_wasm_streaming(
     Ok(JSValue::NULL)
 }
 
-/// `jsc.host_fn.wrap3(getBodyStreamOrBytesForWasmStreaming)` — plain C ABI
-/// shim: returns `.zero` on thrown exception (matches `wrapN` semantics in
-/// `src/jsc/host_fn.zig`).
+/// Plain C ABI
+/// shim: returns `.zero` on thrown exception.
 ///
 /// # Safety
 /// `this` must be a valid, live `JSGlobalObject` pointer for the duration of
diff --git a/src/runtime/webview/ChromeBackend.cpp b/src/runtime/webview/ChromeBackend.cpp
index 59292fd6df1..6562810592b 100644
--- a/src/runtime/webview/ChromeBackend.cpp
+++ b/src/runtime/webview/ChromeBackend.cpp
@@ -91,7 +91,7 @@ namespace CDP {
 
 using namespace JSC;
 
-// From ChromeProcess.zig. Returns the parent's socketpair fd (bidirectional).
+// Implemented in ChromeProcess.rs. Returns the parent's socketpair fd (bidirectional).
 // path overrides auto-detection; extraArgv (count entries, each NUL-
 // terminated) appends after core flags. All pointers nullable.
 extern "C" int32_t Bun__Chrome__ensure(Zig::GlobalObject*, const char* userDataDir,
@@ -293,7 +293,7 @@ bool Transport::ensureSpawned(Zig::GlobalObject* zig, const WTF::String& userDat
     m_mode = TransportMode::Pipe;
 
     // Empty string ≠ null. WTF::String() utf8's to an empty CString (not
-    // isNull), which on the Zig side passes "" into --user-data-dir= and
+    // isNull), which the spawner passes as "" into --user-data-dir= and
     // Chrome falls back to the default profile → ProcessSingleton abort.
     WTF::CString dir = userDataDir.utf8();
     WTF::CString pathC = path.utf8();
@@ -360,7 +360,7 @@ void Transport::send(uint32_t cdpId, Command&& cmd)
 
 // --- WebSocket transport ----------------------------------------------------
 // Native-callback trampolines. Plain C function pointers (not capturing
-// lambdas) — the ctx arg is the Transport* singleton. Zig's CppWebSocket
+// lambdas) — the ctx arg is the Transport* singleton. The CppWebSocket
 // wrapper already does eventLoop.enter()/exit() around the extern "C"
 // call, so any JS these end up running (settle → resolve → .then()) is
 // already in the right execution context.
@@ -1737,7 +1737,7 @@ void close(JSWebView* view)
 
 } // namespace CDP
 
-// Called from ChromeProcess.zig's onProcessExit. Idempotent with onClose.
+// Called from ChromeProcess.rs's onProcessExit. Idempotent with onClose.
 extern "C" void Bun__Chrome__died(int32_t signo)
 {
     auto& t = CDP::transport();
diff --git a/src/runtime/webview/ChromeProcess.rs b/src/runtime/webview/ChromeProcess.rs
index e50cc260a1c..e9c4ebae510 100644
--- a/src/runtime/webview/ChromeProcess.rs
+++ b/src/runtime/webview/ChromeProcess.rs
@@ -3,7 +3,7 @@
 //! host process — Chrome IS the IPC peer. One fewer hop than WKWebView.
 //!
 //! Parent death → Chrome's pipe read EOFs → Chrome exits. Same lifetime
-//! coupling as HostProcess.zig's socket EOF path.
+//! coupling as HostProcess.rs's socket EOF path.
 //!
 //! fd layout (child):
 //!   3 = Chrome reads CDP commands from us  (parent writes → child reads)
@@ -47,15 +47,15 @@ use bun_which::which;
 declare_scope!(Chrome, hidden);
 
 pub struct ChromeProcess {
-    // Intrusive refcount (`.deref()` called in on_process_exit); kept raw to
-    // match Zig `*bun.spawn.Process`.
+    // Intrusive refcount (`.deref()` called in on_process_exit); kept raw
+    // because the refcount, not this struct, owns the allocation.
     process: NonNull<Process>,
 }
 
 // PORTING.md §Global mutable state: JS-thread-only singleton ptr → AtomicPtr.
 // Only accessed from the JS thread (exported fns are called from C++ on the
 // mutator thread; on_process_exit runs on the event loop thread which is the
-// same thread). Relaxed ordering matches the Zig non-atomic var.
+// same thread), so Relaxed ordering suffices.
 static INSTANCE: core::sync::atomic::AtomicPtr<ChromeProcess> =
     core::sync::atomic::AtomicPtr::new(ptr::null_mut());
 
@@ -304,7 +304,7 @@ fn find_playwright_shell() -> Option<ZBox> {
     let cache_dir = resolve_path::join_string_buf_z::<platform::Auto>(&mut dir_buf[..], &parts);
 
     let fd = bun_sys::open(cache_dir, O::RDONLY | O::DIRECTORY, 0).ok()?;
-    // PORT NOTE: `defer fd.close()` — Fd has no Drop; close explicitly on all
+    // `defer fd.close()` — Fd has no Drop; close explicitly on all
     // exit paths via scopeguard.
     let _fd_guard = scopeguard::guard(fd, |fd| fd.close());
 
@@ -324,7 +324,7 @@ fn find_playwright_shell() -> Option<ZBox> {
         if entry.kind != bun_sys::EntryKind::Directory {
             continue;
         }
-        // Zig spec: `bun.DirIterator.iterate(fd, .u8)` — request UTF-8 names
+        // The iterator requests UTF-8 names
         // even on Windows. `slice_u8()` is the cross-platform `&[u8]` borrow.
         let name = entry.name.slice_u8();
         if !name.starts_with(PREFIX) {
@@ -403,8 +403,6 @@ fn spawn(
     stderr_inherit: bool,
 ) -> Result<Fd, bun_core::Error> {
     {
-        // PERF(port): was arena bulk-free — all temp strings now individually heap-allocated.
-
         let chrome = find_chrome(explicit_path).ok_or_else(|| bun_core::err!("ChromeNotFound"))?;
         scoped_log!(
             Chrome,
@@ -529,16 +527,14 @@ fn spawn(
             ..SpawnOptions::default()
         };
 
-        // TODO(port): narrow error set — outer Result + inner bun_sys::Result
         // SAFETY: `argv`/`env` are local null-terminated C-string arrays with
         // argv[0] non-null; valid for this call.
         let spawned =
             unsafe { bun_spawn::spawn_process(&opts, argv.as_ptr(), env.as_ptr().cast()) }??;
 
-        // PORT NOTE: reshaped for borrowck — Zig's errdefer stays armed past
-        // this point (and would re-close fds on the WatchFailed path below);
-        // we disarm here and close explicitly on that path instead.
-        // TODO(port): verify Zig errdefer double-close of fds[1] on WatchFailed is intentional/idempotent.
+        // Disarm the cleanup guard here and close each fd exactly once on the
+        // WatchFailed path below; keeping it armed would re-close the
+        // already-closed fds[1] there.
         let fds = scopeguard::ScopeGuard::into_inner(fds);
 
         // Parent doesn't need the child's end. POSIX_SPAWN_CLOEXEC_DEFAULT
@@ -569,8 +565,7 @@ fn spawn(
             }
             Err(e) => {
                 scoped_log!(Chrome, "watch failed: {}", e);
-                // SAFETY: drop the strong ref we hold (Zig: `process.deref()`),
-                // then reclaim the Box (Zig: `bun.destroy(self)`).
+                // SAFETY: drop the strong ref we hold, then reclaim the Box.
                 unsafe {
                     Process::deref(process.as_ptr());
                     drop(bun_core::heap::take(self_ptr));
@@ -587,7 +582,6 @@ fn spawn(
 }
 
 // Implemented in ChromeBackend.cpp. Rejects all pending CDP promises.
-// TODO(port): move to <runtime>_sys
 unsafe extern "C" {
     fn Bun__Chrome__died(signo: i32);
 }
@@ -722,5 +716,3 @@ pub(crate) unsafe extern "C" fn Bun__Chrome__autoDetect(out_buf: *mut u8, out_ca
     }
     0
 }
-
-// ported from: src/runtime/webview/ChromeProcess.zig
diff --git a/src/runtime/webview/HostProcess.rs b/src/runtime/webview/HostProcess.rs
index 9b1746094fa..c66996ac321 100644
--- a/src/runtime/webview/HostProcess.rs
+++ b/src/runtime/webview/HostProcess.rs
@@ -34,8 +34,8 @@ use {
 declare_scope!(WebViewHost, hidden);
 
 pub struct HostProcess {
-    // Intrusive refcount (`.deref()` called in on_process_exit); kept raw to
-    // match Zig `*bun.spawn.Process`.
+    // Intrusive refcount (`.deref()` called in on_process_exit); kept raw
+    // because the refcount, not this struct, owns the allocation.
     process: NonNull<Process>,
 }
 
@@ -137,8 +137,6 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
     }
     #[cfg(target_os = "macos")]
     {
-        // PERF(port): was arena bulk-free (std.heap.ArenaAllocator) — profile if it shows up on a hot path.
-
         // Both ends nonblocking — parent uses usockets; child sets O_NONBLOCK
         // again after dup2 (socketpair flags are per-fd, not per-pair).
         let fds: [Fd; 2] = bun_sys::socketpair(
@@ -147,7 +145,7 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
             0,
             true, // .nonblocking
         )?;
-        // errdefer fds[0].close() — rolls back on any error below.
+        // fd0_guard rolls back fds[0] on any error below.
         let fd0_guard = scopeguard::guard(fds[0], |fd| fd.close());
         // fds[1] is closed by spawnProcess after dup2 into the child.
 
@@ -155,7 +153,7 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
 
         // Child sees fd 3 (first extra_fd → 3+0). The env var is the only
         // signal; no argv changes so `ps` shows a normal `bun` invocation.
-        // Same pattern as NODE_CHANNEL_FD in js_bun_spawn_bindings.zig.
+        // Same pattern as NODE_CHANNEL_FD in js_bun_spawn_bindings.rs.
         // SAFETY: vm is the per-thread VirtualMachine (valid for the call);
         // `transpiler.env` is set during VM init and lives for VM lifetime.
         let base = unsafe { (*(*vm).transpiler.env).map.create_null_delimited_env_map() }?;
@@ -164,9 +162,7 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
         // var, then re-terminate.
         let base_entries = &base_slice[..base_slice.len().saturating_sub(1)];
         let mut env: Vec<*const c_char> = Vec::with_capacity(base_entries.len() + 2);
-        // PERF(port): was appendSliceAssumeCapacity.
         env.extend(base_entries.iter().copied());
-        // PERF(port): was appendAssumeCapacity.
         env.push(c"BUN_INTERNAL_WEBVIEW_HOST=3".as_ptr());
         env.push(ptr::null());
 
@@ -221,13 +217,12 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
             }
             Err(e) => {
                 scoped_log!(WebViewHost, "watch failed: {}", e);
-                // SAFETY: drop the strong ref we hold (Zig: `process.deref()`),
-                // then reclaim the Box (Zig: `bun.destroy(self)`).
+                // SAFETY: drop the strong ref we hold, then reclaim the Box.
                 unsafe {
                     Process::deref(process.as_ptr());
                     drop(bun_core::heap::take(self_ptr));
                 }
-                // fd0_guard (errdefer at the top) closes fds[0]; don't double-close here.
+                // fd0_guard (declared at the top) closes fds[0]; don't double-close here.
                 return Err(bun_core::err!("WatchFailed"));
             }
         }
@@ -245,5 +240,3 @@ fn spawn(vm: *mut VirtualMachine, stdout_inherit: bool, stderr_inherit: bool) ->
 unsafe extern "C" {
     fn Bun__WebViewHost__childDied(signo: i32);
 }
-
-// ported from: src/runtime/webview/HostProcess.zig
diff --git a/src/runtime/webview/JSWebView.cpp b/src/runtime/webview/JSWebView.cpp
index e4aa304e62a..4c248ceb524 100644
--- a/src/runtime/webview/JSWebView.cpp
+++ b/src/runtime/webview/JSWebView.cpp
@@ -32,7 +32,7 @@ using namespace WebViewProto;
 // isReachableFromOpaqueRoots predicate reads the atomic activity count:
 // under `bun test` the closure → view → m_pendingNavigate → promise →
 // reaction → closure cycle has no external root (the test-function promise
-// goes out of Zig scope after runTestCallback returns). This IS the root.
+// goes out of scope after runTestCallback returns). This IS the root.
 // ---------------------------------------------------------------------------
 
 class JSWebViewWeakOwner final : public JSC::WeakHandleOwner {
diff --git a/src/runtime/webview/WebKitBackend.cpp b/src/runtime/webview/WebKitBackend.cpp
index 870ea165454..cd961d74c42 100644
--- a/src/runtime/webview/WebKitBackend.cpp
+++ b/src/runtime/webview/WebKitBackend.cpp
@@ -39,7 +39,7 @@ namespace WK {
 using namespace JSC;
 using namespace WebViewProto;
 
-// Spawn + process-exit watch in Zig (reuses bun.spawn.Process / EVFILT_PROC).
+// Spawn + process-exit watch implemented in HostProcess.rs (EVFILT_PROC).
 extern "C" int32_t Bun__WebViewHost__ensure(Zig::GlobalObject*, bool stdoutInherit, bool stderrInherit);
 extern "C" void* Blob__fromMmapWithType(JSC::JSGlobalObject*, uint8_t* ptr, size_t len, const char* mime);
 extern "C" JSC::EncodedJSValue SYSV_ABI Blob__create(Zig::GlobalObject*, void* impl);
@@ -131,7 +131,7 @@ bool HostClient::ensureSpawned(Zig::GlobalObject* zig, bool stdoutInherit, bool
 {
     if (sock && !dead) return true;
 
-    // Host died (rejectAllAndMarkDead ran). The Zig side cleared its
+    // Host died (rejectAllAndMarkDead ran). HostProcess.rs cleared its
     // instance in onProcessExit, so Bun__WebViewHost__ensure will spawn a
     // fresh child. Clear stale state and try again — the old rx/txQueue
     // bytes are for the dead socket.
@@ -212,7 +212,7 @@ void HostClient::onWritable()
 
 // Open + mmap the child-written shm segment. The child already munmapped
 // its side before sendReply, so we're the sole mapper. O_RDWR + PROT_WRITE
-// because the Zig allocator wrapper poisons with @memset(undefined) in
+// because the child's allocator poisons the buffer in
 // safe builds BEFORE the vtable free (which munmap's) — a PROT_READ
 // mapping SIGBUS'd on that poison. MAP_SHARED is required for POSIX shm
 // objects on macOS — MAP_PRIVATE returns EINVAL (the kernel's posix_shm
@@ -665,7 +665,7 @@ void close(JSWebView* view)
 } // namespace WK
 } // namespace Bun
 
-// Called from Zig's onProcessExit (EVFILT_PROC). The socket onClose may or
+// Called from HostProcess.rs's onProcessExit (EVFILT_PROC). The socket onClose may or
 // may not have fired (crash = no FIN). Idempotent with onClose.
 extern "C" void Bun__WebViewHost__childDied(int32_t signo)
 {
@@ -678,10 +678,8 @@ extern "C" void Bun__WebViewHost__childDied(int32_t signo)
 
 #else // !OS(DARWIN)
 
-// HostProcess.zig references this unconditionally via @extern; Zig's dead-code
-// elimination doesn't trigger because the TaggedPointer dispatch switch in
-// process.zig pulls in all ProcessExitHandler arms. spawn() itself is gated
-// on Environment.isMac so this is never called.
+// HostProcess.rs references this symbol unconditionally. spawn() itself is
+// gated on macOS so this is never called.
 extern "C" void Bun__WebViewHost__childDied(int32_t) {}
 
 #endif // OS(DARWIN)
diff --git a/src/runtime/webview/WebKitBackend.h b/src/runtime/webview/WebKitBackend.h
index 878e5c310af..46ce8b6daa0 100644
--- a/src/runtime/webview/WebKitBackend.h
+++ b/src/runtime/webview/WebKitBackend.h
@@ -38,7 +38,7 @@ enum class VirtualKey : uint8_t;
 namespace WK {
 
 // One per process. Lazy-spawned on first WebView construction via
-// Bun__WebViewHost__ensure (Zig side, reuses bun.spawn.Process).
+// Bun__WebViewHost__ensure (implemented in HostProcess.rs).
 struct HostClient {
     us_socket_t* sock = nullptr;
     Zig::GlobalObject* global = nullptr;
diff --git a/src/runtime/webview/host_main.cpp b/src/runtime/webview/host_main.cpp
index b9974b1e77e..67649279755 100644
--- a/src/runtime/webview/host_main.cpp
+++ b/src/runtime/webview/host_main.cpp
@@ -1,7 +1,7 @@
-// WebView host subprocess entry point. Reached via cli.zig when
+// WebView host subprocess entry point. Reached from CLI startup when
 // BUN_INTERNAL_WEBVIEW_HOST is set. Runs CFRunLoopRun() as the real main
 // loop — CF manages ignoreWakeUps correctly when it owns the loop. No
-// JSC, no VM, no Zig runtime past the env check.
+// JSC, no VM, no runtime past the env check.
 //
 // Parent death → socket read() returns 0 → CFRunLoopStop → process exits.
 
@@ -348,7 +348,7 @@ static void cfCallback(CFFileDescriptorRef, CFOptionFlags flags, void*)
 } // namespace Bun
 
 // ---------------------------------------------------------------------------
-// Entry. cli.zig calls this before anything else when BUN_INTERNAL_WEBVIEW_HOST
+// Entry. CLI startup calls this before anything else when BUN_INTERNAL_WEBVIEW_HOST
 // is set. Never returns.
 // ---------------------------------------------------------------------------
 extern "C" [[noreturn]] void Bun__WebView__hostMain(int fd)
diff --git a/src/runtime/webview/mod.rs b/src/runtime/webview/mod.rs
index 4c26efa4703..3169cfe662e 100644
--- a/src/runtime/webview/mod.rs
+++ b/src/runtime/webview/mod.rs
@@ -1,6 +1,6 @@
 //! WebView host-process management. macOS uses a `WKWebView`-backed host
-//! subprocess (HostProcess.zig); other platforms drive Chrome over the CDP
-//! pipe (ChromeProcess.zig). The C++ backends (WebKitBackend.cpp /
+//! subprocess; other platforms drive Chrome over the CDP
+//! pipe. The C++ backends (WebKitBackend.cpp /
 //! ChromeBackend.cpp) own the usockets client and frame protocol; this module
 //! only spawns/watches the child.
 
diff --git a/src/s3_signing/acl.rs b/src/s3_signing/acl.rs
index 98598a7791c..e92bee15f49 100644
--- a/src/s3_signing/acl.rs
+++ b/src/s3_signing/acl.rs
@@ -44,5 +44,3 @@ impl ACL {
         b"log-delivery-write" => ACL::LogDeliveryWrite,
     };
 }
-
-// ported from: src/s3_signing/acl.zig
diff --git a/src/s3_signing/credentials.rs b/src/s3_signing/credentials.rs
index a3de8b5fe2a..683e3988c1f 100644
--- a/src/s3_signing/credentials.rs
+++ b/src/s3_signing/credentials.rs
@@ -15,7 +15,7 @@ bun_core::declare_scope!(AWS, visible);
 
 use bun_core::fmt::buf_print;
 
-/// `std.fmt.allocPrint` equivalent: build into a fresh Vec<u8>.
+/// Format into a fresh `Vec<u8>` and return it.
 macro_rules! alloc_print {
     ($($arg:tt)*) => {{
         let mut v: Vec<u8> = Vec::new();
@@ -40,7 +40,7 @@ fn pico_header_new(name: &[u8], value: &[u8]) -> PicoHeader {
 // MultiPartUploadOptions
 // Moved from bun_runtime::webcore::s3::multipart_options.
 // Pure config (no JSC deps), so it lives here at the signing tier; runtime
-// re-exports it. Source of truth: src/runtime/webcore/s3/multipart_options.zig
+// re-exports it.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy, Debug)]
@@ -85,10 +85,7 @@ impl Default for MultiPartUploadOptions {
 // ──────────────────────────────────────────────────────────────────────────
 // AWSSignatureCache — storage moved DOWN from `bun_jsc::rare_data`.
 //
-// Zig (`credentials.zig:485`) reached `jsc.VirtualMachine.getMainThreadVM()
-// orelse get()).rareData().awsCache` inline. The "per-VM" placement was
-// nominal: the lookup always picked the *main-thread* VM, so the cache was
-// process-global in practice. Hosting it here as a `static` makes the
+// The cache is process-global. Hosting it here as a `static` makes the
 // layering honest — `bun_s3_signing` reads its own data, no upward hook.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -96,9 +93,8 @@ use bun_collections::StringArrayHashMap;
 use bun_core::Mutex;
 
 /// Memoised SigV4 derived signing key, keyed by `(numeric_day,
-/// region+service+secret)`. PORTING.md §Concurrency: lock owns the data — Zig
-/// had a sidecar `bun.Mutex` next to `cache`/`date`; here the mutex wraps
-/// both.
+/// region+service+secret)`. The lock owns the data — the mutex wraps both
+/// `cache` and `date`.
 #[derive(Default)]
 pub struct AWSSignatureCache(Mutex<AWSSignatureCacheInner>);
 
@@ -112,11 +108,8 @@ impl AWSSignatureCache {
     /// Returns the cached 32-byte derived signing key for `key` if it was set
     /// for `numeric_day`.
     ///
-    /// PORT NOTE: Zig returned `cache.getKey(key)` (a borrow into map storage)
-    /// past `lock.unlock()` — racy against a concurrent `set` rehashing the
-    /// map. Return the 32-byte *value* by copy instead; the only consumer
-    /// (`sign` below) wants the digest, and a fixed-size copy avoids handing
-    /// out a guard.
+    /// Returns the 32-byte *value* by copy; the only consumer (`sign` below)
+    /// wants the digest, and a fixed-size copy avoids handing out a guard.
     pub fn get(&self, numeric_day: u64, key: &[u8]) -> Option<[u8; DIGESTED_HMAC_256_LEN]> {
         let inner = self.0.lock();
         if inner.date == 0 || inner.date != numeric_day {
@@ -130,8 +123,7 @@ impl AWSSignatureCache {
         if inner.date == 0 {
             inner.cache = StringArrayHashMap::new();
         } else if inner.date != numeric_day {
-            // day changed so we clean the old cache
-            // PORT NOTE: Zig freed each key explicitly; StringArrayHashMap with
+            // day changed so we clean the old cache; StringArrayHashMap with
             // owned Box<[u8]> keys drops them on clear.
             inner.cache.clear();
         }
@@ -140,11 +132,9 @@ impl AWSSignatureCache {
     }
 }
 
-// Drop: `StringArrayHashMap` drops its owned `Box<[u8]>` keys automatically;
-// Zig's `deinit { date = 0; clean(); cache.deinit() }` is fully covered.
+// Drop: `StringArrayHashMap` drops its owned `Box<[u8]>` keys automatically.
 
-/// Process-global instance. Zig hung this off `RareData` but always reached it
-/// via `getMainThreadVM()`, so it was a singleton in practice.
+/// Process-global instance.
 /// `StringArrayHashMap::new` is not `const`, so lazy-init the inner on first
 /// use; the outer `Mutex` itself is const-constructible.
 static AWS_SIGNATURE_CACHE: std::sync::LazyLock<AWSSignatureCache> =
@@ -160,11 +150,10 @@ fn aws_cache_set(day: u64, key: &[u8], digest: [u8; DIGESTED_HMAC_256_LEN]) {
     AWS_SIGNATURE_CACHE.set(day, key, digest)
 }
 
-/// BoringSSL `ENGINE*` for `EVP_Digest`. Zig lazily `ENGINE_new()`'d one per
-/// VM via `RareData::boringEngine`; BoringSSL's `EVP_Digest` ignores the
+/// BoringSSL `ENGINE*` for `EVP_Digest`. BoringSSL's `EVP_Digest` ignores the
 /// `impl` argument entirely (it's an OpenSSL-compat shim — see
 /// `vendor/boringssl/include/openssl/digest.h`: "BoringSSL does not support
-/// engines"). Passing null is bit-identical, so the upward hook is dropped.
+/// engines"), so passing null is fine.
 #[inline]
 fn boring_engine() -> *mut bun_sha_hmac::sha::ffi::ENGINE {
     core::ptr::null_mut()
@@ -175,8 +164,7 @@ fn boring_engine() -> *mut bun_sha_hmac::sha::ffi::ENGINE {
 // ──────────────────────────────────────────────────────────────────────────
 
 // `bun.ptr.RefCount(...)` mixin → IntrusiveRc handles ref/deref; when count hits
-// zero the boxed allocation is dropped, which drops the Box<[u8]> fields. The
-// Zig `deinit` body only freed those fields + `bun.destroy(this)`, so no
+// zero the boxed allocation is dropped, which drops the Box<[u8]> fields, so no
 // explicit Drop body is needed here.
 #[derive(bun_ptr::RefCounted)]
 pub struct S3Credentials {
@@ -195,8 +183,7 @@ pub struct S3Credentials {
     pub virtual_hosted_style: bool,
 }
 
-// PORT NOTE: Zig `S3Credentials` is a value type with `[]const u8` fields and is
-// freely copied (e.g. `default_credentials.*`). The Rust port owns its bytes via
+// `S3Credentials` owns its bytes via
 // `Box<[u8]>`, so a manual `Clone` deep-copies them and resets `ref_count` — the
 // intrusive count only applies to heap (`IntrusiveRc`) instances; a fresh value
 // must start at 1.
@@ -272,12 +259,9 @@ impl S3Credentials {
             + self.bucket.len()
     }
 
-    // `hash_const` DELETED — dead code (no callers in Rust or Zig). If
+    // `hash_const` DELETED — dead code (no callers). If
     // resurrected: `bun_wyhash::hash_ascii_lowercase(0, acl)`.
 
-    // Zig: `pub const getCredentialsWithOptions = @import("../runtime/webcore/s3/credentials_jsc.zig").getCredentialsWithOptions;`
-    // Deleted per PORTING.md — *_jsc alias; the JS-facing fn lives in the *_jsc crate.
-
     pub fn dupe(&self) -> IntrusiveRc<S3Credentials> {
         IntrusiveRc::new(S3Credentials {
             ref_count: RefCount::init(),
@@ -443,8 +427,8 @@ impl S3Credentials {
                 break 'brk_host v.into_boxed_slice();
             }
         };
-        let _ = endpoint_owned; // PORT NOTE: in Zig `endpoint` was reassigned for later reuse; not read after this point.
-        // errdefer free(host) — Box<[u8]> drops on `?`.
+        let _ = endpoint_owned; // not read after this point.
+        // `host` (Box<[u8]>) drops on `?`.
 
         let normalized_path: &[u8] = 'brk: {
             if self.virtual_hosted_style {
@@ -469,7 +453,7 @@ impl S3Credentials {
 
         let date_result = get_amz_date();
         let amz_date: Box<[u8]> = date_result.date;
-        // errdefer free(amz_date) — Box<[u8]> drops on `?`.
+        // `amz_date` (Box<[u8]>) drops on `?`.
 
         let amz_day = &amz_date[0..8];
         let request_payer = sign_options.request_payer;
@@ -510,7 +494,7 @@ impl S3Credentials {
                     ),
                 )
                 .map_err(|_| SignError::NoSpaceLeft)?;
-                // PORT NOTE: was `bun_jsc::VirtualMachine::get*().rare_data().aws_cache()`.
+                // was `bun_jsc::VirtualMachine::get*().rare_data().aws_cache()`.
                 // Storage moved DOWN — `AWS_SIGNATURE_CACHE` is a process static here.
                 if let Some(cached) = aws_cache_get(date_result.numeric_day, key) {
                     break 'brk_sign cached;
@@ -554,10 +538,9 @@ impl S3Credentials {
                     [0..DIGESTED_HMAC_256_LEN]
                     .try_into()
                     .expect("infallible: size matches");
-                // PORT NOTE: intentionally diverges from Zig. In Zig, `key` is a slice into
-                // `tmp_buffer` which has since been overwritten by the `AWS4{secret}` bufPrint,
-                // so Zig passes corrupted bytes to `cache.set` (latent bug → cache never hits).
-                // We recompute the correct `{region}{service}{secret}` key here.
+                // The earlier `key` was a slice into `tmp_buffer`, which has since been
+                // overwritten by the `AWS4{secret}` buf_print, so recompute the correct
+                // `{region}{service}{secret}` key here before caching.
                 let key = buf_print(
                     &mut tmp_buffer,
                     format_args!(
@@ -679,7 +662,7 @@ impl S3Credentials {
                     .map_err(|_| SignError::NoSpaceLeft)?;
                 };
                 let mut sha_digest = [0u8; bun_sha_hmac::SHA256::DIGEST];
-                // PORT NOTE: was `bun_jsc::VirtualMachine::get().rare_data().boring_engine()`;
+                // was `bun_jsc::VirtualMachine::get().rare_data().boring_engine()`;
                 // BoringSSL ignores the ENGINE arg, so pass null (see `boring_engine()` doc).
                 // SAFETY: `boring_engine()` returns null (default engine).
                 unsafe { bun_sha_hmac::SHA256::hash(canonical, &mut sha_digest, boring_engine()) };
@@ -787,7 +770,7 @@ impl S3Credentials {
                 )
                 .map_err(|_| SignError::NoSpaceLeft)?;
                 let mut sha_digest = [0u8; bun_sha_hmac::SHA256::DIGEST];
-                // PORT NOTE: was `bun_jsc::VirtualMachine::get().rare_data().boring_engine()`;
+                // was `bun_jsc::VirtualMachine::get().rare_data().boring_engine()`;
                 // BoringSSL ignores the ENGINE arg, so pass null (see `boring_engine()` doc).
                 // SAFETY: `boring_engine()` returns null (default engine).
                 unsafe { bun_sha_hmac::SHA256::hash(canonical, &mut sha_digest, boring_engine()) };
@@ -825,11 +808,11 @@ impl S3Credentials {
                 .into_boxed_slice();
             }
         };
-        // errdefer free(authorization) — Box<[u8]> drops on `?`.
+        // `authorization` (Box<[u8]>) drops on `?`.
 
         if sign_query {
             // defer free(host); defer free(amz_date); — drop at scope exit.
-            // PORT NOTE: SignResult implements Drop, so struct-update `..default()`
+            // SignResult implements Drop, so struct-update `..default()`
             // is forbidden; mutate a default in place instead.
             let mut r = SignResult::default();
             r.acl = sign_options.acl;
@@ -862,7 +845,7 @@ impl S3Credentials {
         )
         .into_boxed_slice();
 
-        // PORT NOTE: SignResult implements Drop, so struct-update `..default()` is forbidden.
+        // SignResult implements Drop, so struct-update `..default()` is forbidden.
         let mut result = SignResult::default();
         result.amz_date = amz_date;
         result.host = host;
@@ -872,7 +855,7 @@ impl S3Credentials {
         result.request_payer = request_payer;
         result.url = url;
         result._headers_len = 4;
-        // TODO(port): self-referential — _headers borrows from owned Box<[u8]> fields on SignResult.
+        // Self-referential: _headers borrows from owned Box<[u8]> fields on SignResult.
         // bun_picohttp::Header stores raw `*const u8, len` (verified), so the heap pointers stay
         // valid across SignResult moves. SAFETY relies on the Box<[u8]> fields not being mutated
         // after the corresponding header is written.
@@ -951,9 +934,7 @@ fn get_amz_date() -> DateResult {
     // the code below is the same as new Date(Date.now()).toISOString()
     // Date.now() ISO string via JS removed; uses libc gmtime_r
 
-    // Create UTC timestamp
-    // TODO(port): Zig used std.time.milliTimestamp() + std.time.epoch helpers. Could move to
-    // bun_core::time equivalents; using std::time here is OK (not banned).
+    // Create UTC timestamp.
     let secs: u64 = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
@@ -975,10 +956,8 @@ fn get_amz_date() -> DateResult {
     }
 }
 
-// Port of Zig std.time.epoch.{EpochSeconds, EpochDay, YearAndDay} → Gregorian Y/M/D from
-// Unix-epoch seconds. Uses Howard Hinnant's `civil_from_days` algorithm (public domain),
-// which is what Zig's stdlib derives from. Matches credentials.zig:116-123 exactly for the
-// fields getAMZDate consumes.
+// Gregorian Y/M/D from Unix-epoch seconds, using Howard Hinnant's
+// `civil_from_days` algorithm (public domain).
 fn epoch_to_utc_components(secs: u64) -> (u32, u32, u32, u32, u32, u32, u64) {
     // returns (year, month(1-based), day(1-based), hours, minutes, seconds, seconds_into_day)
     let day_seconds = secs % 86_400;
@@ -1020,7 +999,7 @@ pub struct SignResult {
     pub acl: Option<ACL>,
     pub storage_class: Option<StorageClass>,
     pub request_payer: bool,
-    // TODO(port): self-referential — entries borrow from the Box<[u8]> fields above. PicoHeader
+    // Self-referential: entries borrow from the Box<[u8]> fields above. PicoHeader
     // must be a raw (ptr,len) pair; see note in sign_request.
     pub _headers: [PicoHeader; Self::MAX_HEADERS],
     pub _headers_len: u8,
@@ -1070,7 +1049,7 @@ impl Default for SignResult {
 
 impl Drop for SignResult {
     fn drop(&mut self) {
-        // Zig used bun.freeSensitive (zero-before-free) for secrets.
+        // Zero-before-free for secrets.
         zero_sensitive(&mut self.amz_date);
         zero_sensitive(&mut self.session_token);
         zero_sensitive(&mut self.content_disposition);
@@ -1078,7 +1057,7 @@ impl Drop for SignResult {
         zero_sensitive(&mut self.host);
         zero_sensitive(&mut self.authorization);
         zero_sensitive(&mut self.url);
-        // content_md5 was a plain free in Zig; Box drop handles it.
+        // content_md5 is not sensitive; Box drop handles it.
     }
 }
 
@@ -1103,7 +1082,7 @@ impl Default for SignQueryOptions {
     }
 }
 
-// PORT NOTE: transient param-pack struct; lifetime added because every field is a caller-owned
+// transient param-pack struct; lifetime added because every field is a caller-owned
 // borrow. PORTING.md discourages struct lifetimes, but raw pointers here would be strictly worse.
 #[derive(Clone, Copy)]
 pub struct SignOptions<'a> {
@@ -1184,7 +1163,7 @@ pub fn encode_uri_component<'b, const ENCODE_SLASH: bool>(
     input: &[u8],
     buffer: &'b mut [u8],
 ) -> Result<&'b [u8], EncodeError> {
-    // PORT NOTE: returns a borrow into `buffer`; caller must not reuse buffer while result is live.
+    // returns a borrow into `buffer`; caller must not reuse buffer while result is live.
     let mut written: usize = 0;
 
     for &c in input {
@@ -1283,8 +1262,8 @@ pub struct S3CredentialsWithOptions {
     pub options: MultiPartUploadOptions,
     pub acl: Option<ACL>,
     pub storage_class: Option<StorageClass>,
-    // Self-referential views: these `?[]const u8` fields are NOT freed in Zig
-    // `deinit`; they borrow into the sibling `_*_slice: ZigStringSlice` fields
+    // Self-referential views: these fields are non-owning;
+    // they borrow into the sibling `_*_slice: ZigStringSlice` fields
     // below. `RawSlice` encodes that non-owning contract (and gives callers
     // `.as_deref()` instead of an open-coded `unsafe { &*p }`).
     pub content_disposition: Option<RawSlice<u8>>,
@@ -1307,17 +1286,13 @@ pub struct S3CredentialsWithOptions {
     pub _content_encoding_slice: Option<bun_core::ZigStringSlice>,
 }
 
-// `deinit` only called .deinit() on each Option<ZigStringSlice>; ZigStringSlice impls Drop, so
-// the body is empty — no explicit Drop needed.
+// ZigStringSlice impls Drop, so no explicit Drop needed.
 
 // ──────────────────────────────────────────────────────────────────────────
-// SignedHeaders — runtime port of Zig comptime lookup table
+// SignedHeaders
 // ──────────────────────────────────────────────────────────────────────────
 
 /// Headers must be in alphabetical order per AWS Signature V4 spec.
-// TODO(port): Zig `packed struct(u7)` (all-bool fields). Kept as a plain struct for
-// readability of `key.field` accesses in SignedHeaders/CanonicalRequest; could move to
-// bitflags!/`#[repr(transparent)] u8`. `bits()` below preserves the u7 layout.
 #[derive(Clone, Copy, Default)]
 pub(crate) struct SignedHeadersKey {
     pub content_disposition: bool,
@@ -1332,8 +1307,7 @@ pub(crate) struct SignedHeadersKey {
 struct SignedHeaders;
 
 impl SignedHeaders {
-    // PERF(port): Zig builds a comptime [128]&'static str table via string concatenation.
-    // Rust cannot concat &str in a const loop, so we build at runtime into a caller buffer.
+    // Built at runtime into a caller buffer.
     // Could switch to a build.rs-generated static table if profiling shows this matters.
     fn get(key: SignedHeadersKey, buf: &mut [u8; 256]) -> &[u8] {
         let mut n = 0usize;
@@ -1373,15 +1347,13 @@ impl SignedHeaders {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// CanonicalRequest — runtime port of Zig comptime format-string dispatch
+// CanonicalRequest
 // ──────────────────────────────────────────────────────────────────────────
 
 struct CanonicalRequest;
 
 impl CanonicalRequest {
-    // PERF(port): Zig generates 128 monomorphized format strings and dispatches via
-    // `switch (bits) { inline 0..127 => |idx| ... }`. We build the canonical request at
-    // runtime with conditional writes. Same output bytes; profile if hot.
+    // Builds the canonical request at runtime with conditional writes; profile if hot.
     pub(crate) fn format<'b>(
         buf: &'b mut [u8],
         key: SignedHeadersKey,
@@ -1466,5 +1438,3 @@ impl CanonicalRequest {
 fn contains_newline_or_cr(value: &[u8]) -> bool {
     strings::index_of_any(value, b"\r\n").is_some()
 }
-
-// ported from: src/s3_signing/credentials.zig
diff --git a/src/s3_signing/error.rs b/src/s3_signing/error.rs
index 93f5e8b07fc..f8c5ac8566f 100644
--- a/src/s3_signing/error.rs
+++ b/src/s3_signing/error.rs
@@ -5,9 +5,6 @@ pub struct ErrorCodeAndMessage {
     pub message: &'static [u8],
 }
 
-// PERF(port): was `comptime err: anyerror` — demoted to runtime; profile if hot.
-// PORT NOTE: Zig return type was `[:0]const u8` (sentinel-terminated literal); only
-// caller stores into `[]const u8`, so the sentinel is dropped here.
 pub fn get_sign_error_message(e: Error) -> &'static [u8] {
     match e {
         e if e == err!("MissingCredentials") => b"Missing S3 credentials. 'accessKeyId', 'secretAccessKey', 'bucket', and 'endpoint' are required",
@@ -49,18 +46,15 @@ pub fn get_sign_error_code_and_message(e: Error) -> ErrorCodeAndMessage {
     }
 }
 
-// PORT NOTE: `getJSSignError` / `throwSignError` re-exports from
-// `../runtime/webcore/s3/error_jsc.zig` deleted — in Rust these live as
-// extension-trait methods in the `*_jsc` crate (see PORTING.md §Idiom map).
+// `getJSSignError` / `throwSignError` live as extension-trait methods in the
+// `*_jsc` crate (see PORTING.md §Idiom map).
 
-// PORT NOTE: Zig `S3Error { code: []const u8, message: []const u8 }` carries borrowed slices
-// that are valid only for the duration of the callback invocation (callers parse them out of an
-// XML response body). Field ownership is *not* `'static` — modeled with an explicit `<'a>`.
+// `code` / `message` are borrowed slices valid only for the duration of the
+// callback invocation (callers parse them out of an XML response body). Field
+// ownership is *not* `'static` — modeled with an explicit `<'a>`.
 pub struct S3Error<'a> {
     pub code: &'a [u8],
     pub message: &'a [u8],
-    // PORT NOTE: `toJS` / `toJSWithAsyncStack` aliases to `error_jsc.zig` deleted —
-    // implemented as extension-trait methods in the `*_jsc` crate.
+    // `toJS` / `toJSWithAsyncStack` are implemented as extension-trait methods
+    // in the `*_jsc` crate.
 }
-
-// ported from: src/s3_signing/error.zig
diff --git a/src/s3_signing/storage_class.rs b/src/s3_signing/storage_class.rs
index 5c3a969d264..0d291f75dc1 100644
--- a/src/s3_signing/storage_class.rs
+++ b/src/s3_signing/storage_class.rs
@@ -45,5 +45,3 @@ impl StorageClass {
         b"SNOW" => StorageClass::SNOW,
     };
 }
-
-// ported from: src/s3_signing/storage_class.zig
diff --git a/src/safety/CriticalSection.rs b/src/safety/CriticalSection.rs
index 1467b182bc5..69c467c0b48 100644
--- a/src/safety/CriticalSection.rs
+++ b/src/safety/CriticalSection.rs
@@ -43,7 +43,7 @@ use super::thread_id::{
 pub struct CriticalSection {
     #[cfg(debug_assertions)]
     internal_state: State,
-    // When not enabled, this is a zero-sized type (Zig: `void`).
+    // When not enabled, this is a zero-sized type.
 }
 
 #[cfg(debug_assertions)]
@@ -80,7 +80,7 @@ struct State {
     /// the owner).
     #[cfg(debug_assertions)]
     owner_trace: StoredTrace,
-    // When traces are disabled, this is a zero-sized type (Zig: `void`).
+    // When traces are disabled, this is a zero-sized type.
     /// Number of nested calls to `lockShared`/`lockExclusive` performed on the owner thread.
     /// Only accessed on the owner thread.
     owned_count: u32,
@@ -122,8 +122,7 @@ impl State {
             Ok(_) => {
                 #[cfg(debug_assertions)]
                 {
-                    // PORT NOTE: Zig passes `@returnAddress()` here; no stable Rust
-                    // equivalent. `None` lets capture() use the current frame.
+                    // `None` lets capture() use the current frame.
                     self.owner_trace = StoredTrace::capture(None);
                 }
                 current_id
@@ -259,5 +258,3 @@ impl CriticalSection {
         self.internal_state.unlock();
     }
 }
-
-// ported from: src/safety/CriticalSection.zig
diff --git a/src/safety/ThreadLock.rs b/src/safety/ThreadLock.rs
index e47b5beb891..6ff5ef59be9 100644
--- a/src/safety/ThreadLock.rs
+++ b/src/safety/ThreadLock.rs
@@ -2,5 +2,3 @@
 // required by `bun_ptr::RefCount` and `bun_threading::RawMutex`). Re-export so
 // `bun_safety::ThreadLock` callers keep working.
 pub use bun_core::{ThreadLock, ThreadLockGuard};
-
-// ported from: src/safety/ThreadLock.zig
diff --git a/src/safety/alloc.rs b/src/safety/alloc.rs
index 481edff9109..8a9e22c20cd 100644
--- a/src/safety/alloc.rs
+++ b/src/safety/alloc.rs
@@ -1,10 +1,8 @@
-//! Allocator-identity safety checks (Zig: `bun.safety.alloc`).
+//! Allocator-identity safety checks.
 //!
-//! Zig's `std.mem.Allocator` is a `{ ptr: *anyopaque, vtable: *const VTable }`
-//! pair; this module compares those two words to catch a single unmanaged
-//! container being driven by mismatched allocators. The Rust port uses
-//! [`bun_alloc::StdAllocator`] (the literal `{ptr, vtable}` struct) so the
-//! comparison semantics are identical — no fat-pointer transmutes.
+//! [`bun_alloc::StdAllocator`] is a literal `{ptr, vtable}` struct; this
+//! module compares those two words to catch a single unmanaged container
+//! being driven by mismatched allocators — no fat-pointer transmutes.
 //!
 //! Higher-tier `is_instance` checks (`MimallocArena`, `LinuxMemFdAllocator`,
 //! `CachedBytecode`, `bundle_v2`, `heap_breakdown::Zone`, arena vtable)
@@ -104,10 +102,8 @@ pub fn assert_eq_fmt(alloc1: StdAllocator, alloc2: StdAllocator, args: fmt::Argu
 /// methods). (Exception: methods like `clone` which explicitly accept any allocator should not call
 /// any methods on this type.)
 pub struct CheckedAllocator {
-    // Zig: `#allocator: if (enabled) NullableAllocator else void = if (enabled) .init(null)`
     #[cfg(debug_assertions)]
     allocator: NullableAllocator,
-    // Zig: `#trace: if (traces_enabled) StoredTrace else void = if (traces_enabled) StoredTrace.empty`
     #[cfg(debug_assertions)]
     trace: StoredTrace,
 }
@@ -142,9 +138,8 @@ impl CheckedAllocator {
             self.allocator = NullableAllocator::init(Some(alloc));
             #[cfg(debug_assertions)]
             {
-                // PORT NOTE: Zig passes `@returnAddress()`. Rust has no stable
-                // equivalent; `None` lets `StoredTrace::capture` start from the
-                // immediate caller frame instead.
+                // `None` lets `StoredTrace::capture` start from the
+                // immediate caller frame.
                 self.trace = StoredTrace::capture(None);
             }
         } else {
@@ -207,9 +202,9 @@ impl CheckedAllocator {
         {
             let new_std = new_alloc.allocator();
 
-            // PORT NOTE: Zig uses `defer self.* = .init(new_std)`. A scopeguard
-            // would need a `&mut self` capture overlapping the reads below, so
-            // the assignment is hoisted to both early returns instead.
+            // A scopeguard would need a `&mut self` capture overlapping the
+            // reads below, so the assignment is hoisted to both early returns
+            // instead.
             let Some(old_allocator) = self.allocator.get() else {
                 *self = Self::init(new_std);
                 return;
@@ -233,14 +228,10 @@ impl CheckedAllocator {
     }
 }
 
-/// Zig's `transferOwnership` accepts `*MimallocArena | *const MimallocArena |
-/// MimallocArena.Borrowed` via `anytype` + comptime switch and calls
-/// `.allocator()` on the result. `MimallocArena` lives in `bun_runtime` (above
-/// this crate), so callers implement this trait there.
+/// `MimallocArena` lives in `bun_runtime` (above this crate), so callers
+/// implement this trait there.
 pub trait AsMimallocArenaAllocator {
     fn allocator(&self) -> StdAllocator;
 }
 
 pub const ENABLED: bool = cfg!(debug_assertions);
-
-// ported from: src/safety/alloc.zig
diff --git a/src/safety/lib.rs b/src/safety/lib.rs
index 58d8e8c1490..4beff9e10fe 100644
--- a/src/safety/lib.rs
+++ b/src/safety/lib.rs
@@ -19,8 +19,7 @@ pub mod thread_id;
 // `CachedBytecode`, `bundle_v2`, `heap_breakdown::Zone`)
 // directly. Instead of an erased fn-ptr hook, those crates push their
 // `&'static AllocatorVTable` addresses here at init; `alloc::has_ptr` then
-// does a plain pointer-equality scan. This is the same predicate Zig's
-// `is_instance` checks compute (vtable identity), just with the *data* moved
+// does a plain pointer-equality scan (vtable identity), with the *data* moved
 // down rather than the *code* called up.
 // ──────────────────────────────────────────────────────────────────────────
 
@@ -32,9 +31,8 @@ use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 /// crates at startup via [`register_alloc_vtable`].
 ///
 /// Lock-free fixed-capacity array: writes happen once at init, reads sit on
-/// `has_ptr()` (called from `CheckedAllocator` on debug paths). The Zig spec
-/// is a chain of inline `ptr_eq` against compile-time-known vtable addresses,
-/// so a Relaxed scan over ≤16 words matches that cost profile.
+/// `has_ptr()` (called from `CheckedAllocator` on debug paths); a Relaxed
+/// scan over ≤16 words keeps the check cheap.
 const KNOWN_ALLOC_CAP: usize = 16;
 static KNOWN_ALLOC_VTABLES: [AtomicPtr<()>; KNOWN_ALLOC_CAP] =
     [const { AtomicPtr::new(null_mut()) }; KNOWN_ALLOC_CAP];
@@ -96,5 +94,3 @@ pub fn dump_stored_trace(trace: &bun_core::StoredTrace) {
         },
     );
 }
-
-// ported from: src/safety/safety.zig
diff --git a/src/safety/thread_id.rs b/src/safety/thread_id.rs
index 9b88a1a27c1..5d234299dfd 100644
--- a/src/safety/thread_id.rs
+++ b/src/safety/thread_id.rs
@@ -1,5 +1,3 @@
 //! Re-export of the canonical OS thread-id ladder, sunk into tier-0
 //! `bun_core` so `bun_core::ThreadLock` / `ThreadCell` share the impl.
 pub use bun_core::thread_id::{AtomicThreadId, INVALID, ThreadId, current};
-
-// ported from: src/safety/thread_id.zig
diff --git a/src/semver/SemverQuery.rs b/src/semver/SemverQuery.rs
index 06b7f51d908..65a52e8825c 100644
--- a/src/semver/SemverQuery.rs
+++ b/src/semver/SemverQuery.rs
@@ -8,7 +8,7 @@ use bun_core::strings;
 use crate::range::{Comparator, Op as RangeOp};
 use crate::{Range, SlicedString, Version, version};
 
-// Re-export sub-namespace mirroring Zig's `Query.Token.Wildcard` path so
+// Re-export sub-namespace so
 // `crate::query::token::Wildcard` resolves for sibling modules.
 pub mod token {
     pub use super::{Token, TokenTag, Wildcard};
@@ -173,8 +173,8 @@ pub struct List {
 
 // SAFETY: `tail` is a self-referential backref into the `head.next` chain owned
 // by this `List` (see `and_range`); it never aliases data owned by another
-// thread. Zig models this as a plain `*Query` and freely sends `Group`/`List`
-// across the lockfile thread pool. Auto-`!Send` from `NonNull` is overly
+// thread, so the whole structure moves between threads as a unit (the lockfile
+// thread pool relies on this). Auto-`!Send` from `NonNull` is overly
 // conservative here.
 unsafe impl Send for List {}
 // SAFETY: `tail` is only dereferenced through `&mut self` (see `and_range`);
@@ -356,8 +356,8 @@ pub struct Group {
     pub head: List,
     // BACKREF: alias into self.head.next chain
     pub tail: Option<NonNull<List>>,
-    /// Borrowed view into the caller's source buffer (Zig: `input: string = ""`).
-    /// Stored as a raw fat pointer per PORTING.md §`[]const u8` struct-field
+    /// Borrowed view into the caller's source buffer.
+    /// Stored as a raw fat pointer
     /// (parser-owned, never freed) so `Group` carries no lifetime parameter and
     /// can be embedded in lockfile types (`NpmInfo`). Only dereferenced in
     /// `json_stringify`; caller must keep the source buffer alive for that call.
@@ -368,10 +368,10 @@ pub struct Group {
 
 // SAFETY: `tail` is a self-referential backref into the `head.next` chain owned
 // by this `Group` (see `or_version`); `input` is a lifetime-erased borrow into
-// the caller's source buffer (PORTING.md §`[]const u8` struct-field) and is
+// the caller's source buffer and is
 // only dereferenced under the same single-thread parse/stringify call. Neither
-// pointer aliases data owned by another thread. Zig models both as plain
-// pointers and freely sends `Group` across the lockfile/resolver thread pool;
+// pointer aliases data owned by another thread, so the whole structure moves
+// between threads as a unit (the lockfile/resolver thread pool relies on this);
 // auto-`!Send` from `NonNull`/`*const` is overly conservative here.
 unsafe impl Send for Group {}
 // SAFETY: `tail` is only dereferenced through `&mut self` and `input` points
@@ -442,24 +442,20 @@ impl Group {
     }
 
     pub fn json_stringify(&self, writer: &mut impl core::fmt::Write) -> fmt::Result {
-        // TODO(port): std.json.encodeJsonString — needs a JSON string encoder in bun_core/serde.
         let temp = {
             use std::io::Write as _;
             let mut v: Vec<u8> = Vec::new();
             // SAFETY: `input` points into the parse source buffer which the
-            // caller must keep alive for the lifetime of this Group (Zig
-            // stored a bare `[]const u8` with the same contract).
+            // caller must keep alive for the lifetime of this Group (see the
+            // `input` field doc).
             let input = unsafe { &*self.input };
             let _ = write!(&mut v, "{}", self.fmt(input));
             v
         };
-        // TODO(port): writes raw bytes; should JSON-escape.
-        writer.write_str("\"")?;
-        write!(writer, "{}", bstr::BStr::new(&temp))?;
-        writer.write_str("\"")
+        bun_core::fmt::encode_json_string(writer, &temp)
     }
 
-    // PORT NOTE: `deinit` deleted — `next: Option<Box<..>>` chains are freed by the
+    // `deinit` deleted — `next: Option<Box<..>>` chains are freed by the
     // iterative `Drop` impls on `Query` and `List`.
 
     pub fn get_exact_version(&self) -> Option<Version> {
@@ -506,7 +502,6 @@ impl Group {
             && self.head.head.range.left.op == RangeOp::Eql
     }
 
-    /// Zig name: `@"is *"`
     pub fn is_star(&self) -> bool {
         let left = &self.head.head.range.left;
         self.head.head.range.right.op == RangeOp::Unset
@@ -1120,5 +1115,3 @@ pub fn parse(input: &[u8], sliced: SlicedString) -> Result<Group, AllocError> {
 
     Ok(list)
 }
-
-// ported from: src/semver/SemverQuery.zig
diff --git a/src/semver/SemverRange.rs b/src/semver/SemverRange.rs
index a23698b527c..b24f716eeb5 100644
--- a/src/semver/SemverRange.rs
+++ b/src/semver/SemverRange.rs
@@ -29,8 +29,8 @@ impl fmt::Display for Range {
         }
 
         if self.right.op == Op::Unset {
-            // TODO(port): Zig used `{}` on Comparator directly but Comparator has no
-            // top-level `format` in the source — likely dead/broken upstream. Mirroring shape.
+            // Effectively dead path;
+            // the real formatting path is the buffered `Range::fmt(buf)` Formatter below.
             write!(f, "{}", ComparatorDisplay)
         } else {
             write!(f, "{} {}", ComparatorDisplay, ComparatorDisplay,)
@@ -38,11 +38,13 @@ impl fmt::Display for Range {
     }
 }
 
-// PORT NOTE: helper for Range's Display impl above (Zig relied on default struct formatting).
+// Helper for Range's Display impl above.
 struct ComparatorDisplay;
 impl fmt::Display for ComparatorDisplay {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO(port): no buffer available here; upstream Zig path appears unused.
+        // Intentionally emits nothing: no source buffer is available here, so the
+        // version's prerelease/build slices can't be rendered. Use `Comparator::fmt(buf)`
+        // (the buffered Formatter) for real output; this mirrors the unused upstream path.
         Ok(())
     }
 }
@@ -281,5 +283,3 @@ impl fmt::Display for ComparatorFormatter<'_> {
         write!(f, "{}", self.comparator.version.fmt(self.buffer))
     }
 }
-
-// ported from: src/semver/SemverRange.zig
diff --git a/src/semver/Version.rs b/src/semver/Version.rs
index 35fdd2ab395..8431e1c86e1 100644
--- a/src/semver/Version.rs
+++ b/src/semver/Version.rs
@@ -11,14 +11,14 @@ use crate::query::token::Wildcard;
 pub type Version = VersionType<u64>;
 
 // ──────────────────────────────────────────────────────────────────────────
-// VersionInt — trait capturing the operations the Zig generic needed on
-// `comptime IntType: type`. Only u32 and u64 are instantiated.
+// VersionInt — trait capturing the operations the generic version type needs
+// from its integer parameter. Only u32 and u64 are instantiated.
 // ──────────────────────────────────────────────────────────────────────────
 
 pub trait VersionInt: Copy + Default + Eq + Ord + fmt::Display + 'static {
     const ZERO: Self;
     const MAX: Self;
-    /// Zig: `_tag_padding: [if (IntType == u32) 4 else 0]u8` — explicit zeroed
+    /// Explicit zeroed
     /// padding so lockfile byte-serialization is deterministic.
     type TagPadding: Copy + Default + 'static;
     fn parse_ascii(s: &[u8]) -> Option<Self>;
@@ -30,7 +30,6 @@ impl VersionInt for u64 {
     type TagPadding = [u8; 0];
     #[inline]
     fn parse_ascii(s: &[u8]) -> Option<Self> {
-        // Semantics match Zig `std.fmt.parseUnsigned(u64, s, 10) catch null`:
         // None for empty, any non-[0-9] byte, or overflow. Callers rely on
         // the non-digit None case for pre-release identifier ordering
         // (semver identifiers are `[0-9A-Za-z-]+`, so `_` never appears).
@@ -58,15 +57,14 @@ pub struct VersionType<T: VersionInt> {
     pub major: T,
     pub minor: T,
     pub patch: T,
-    // Zig: `_tag_padding: [if (IntType == u32) 4 else 0]u8 = .{0} ** ...` —
-    // explicit zeroed bytes so the alignment gap before `tag` is deterministic
-    // for lockfile serialization (see padding_checker.zig).
+    // Explicit zeroed bytes so the alignment gap before `tag` is deterministic
+    // for lockfile serialization.
     #[doc(hidden)]
     pub _tag_padding: T::TagPadding,
     pub tag: Tag,
 }
 
-// Layout must match Zig `extern struct` exactly (lockfile binary format).
+// Layout is load-bearing (lockfile binary format).
 const _: () = {
     assert!(core::mem::size_of::<Tag>() == 32);
     assert!(core::mem::align_of::<Tag>() == 8);
@@ -254,8 +252,8 @@ impl<T: VersionInt> VersionType<T> {
                     | b'\t'
                     | b'\n'
                     | b'\r'
-                    | 0x0B // std.ascii.control_code.vt
-                    | 0x0C // std.ascii.control_code.ff
+                    | 0x0B // vertical tab
+                    | 0x0C // form feed
 
                     // version separators
                     | b'v'
@@ -492,8 +490,8 @@ impl<T: VersionInt> VersionType<T> {
                 | b'\t'
                 | b'\n'
                 | b'\r'
-                | 0x0B // std.ascii.control_code.vt
-                | 0x0C // std.ascii.control_code.ff
+                | 0x0B // vertical tab
+                | 0x0C // form feed
 
                 // version separators
                 | b'v'
@@ -696,8 +694,6 @@ impl<T: VersionInt> VersionType<T> {
             return match T::parse_ascii(&bytes[0..byte_i as usize]) {
                 Some(v) => Some(v),
                 None => {
-                    // TODO(port): Output.prettyErrorln with @errorName — Rust parse
-                    // error doesn't carry a Zig-style tag name.
                     bun_core::pretty_errorln!(
                         "ERROR parsing version: \"{}\", bytes: {}",
                         bstr::BStr::new(input),
@@ -1079,9 +1075,8 @@ impl Tag {
         } else {
             let pre_slice = self.pre.slice(slice);
             buf[..pre_slice.len()].copy_from_slice(pre_slice);
-            // PORT NOTE: reshaped for borrowck — Zig does
-            // `String.init(buf.*, buf.*[0..pre_slice.len])` then advances buf.
-            // We capture the init args before advancing.
+            // reshaped for borrowck —
+            // capture the init args before advancing `buf`.
             pre = SemverString::init(buf, &buf[0..pre_slice.len()]);
             *buf = &mut core::mem::take(buf)[pre_slice.len()..];
         }
@@ -1265,5 +1260,3 @@ impl<T: VersionInt> Default for ParseResult<T> {
         }
     }
 }
-
-// ported from: src/semver/Version.zig
diff --git a/src/semver/lib.rs b/src/semver/lib.rs
index d9e22be18bf..3e0fd629010 100644
--- a/src/semver/lib.rs
+++ b/src/semver/lib.rs
@@ -8,7 +8,7 @@ pub use crate::version::VersionType;
 pub use crate::semver_query::Query;
 pub use crate::semver_range::Range;
 pub use crate::sliced_string::SlicedString;
-// PORT NOTE: `SemverObject` re-export from `../semver_jsc/` deleted — *_jsc
+// `SemverObject` re-export from `../semver_jsc/` deleted — *_jsc
 // extension traits live in the `bun_semver_jsc` crate, not here.
 
 #[path = "SemverQuery.rs"]
@@ -21,7 +21,7 @@ pub mod version;
 pub use crate::semver_query as query;
 pub use crate::semver_range as range;
 
-/// Duck-typed surface for `Lockfile::str` (src/install/lockfile.zig:`str`): any
+/// Duck-typed surface for `Lockfile::str`: any
 /// value that can project itself into a string-bytes buffer. Implemented by
 /// `String` / `ExternalString` (and any other `slice(buf)`-shaped types).
 pub trait Slicable {
@@ -44,7 +44,7 @@ impl Slicable for crate::external_string::ExternalString {
 pub use crate::semver_string as string;
 
 // ──────────────────────────────────────────────────────────────────────────
-// StringBuilder — trait abstracting `comptime StringBuilder: type` callers
+// StringBuilder — trait abstracting the builder type used by callers
 // in Version::count / Version::clone_into. Concrete impl is
 // `semver_string::Builder`; higher-tier crates may provide their own.
 // ──────────────────────────────────────────────────────────────────────────
@@ -52,8 +52,8 @@ pub trait StringBuilder {
     fn count(&mut self, slice_: &[u8]);
     fn append<T: crate::semver_string::BuilderStringType>(&mut self, slice_: &[u8]) -> T;
 
-    /// Convenience wrapper for `append::<String>` so callers ported from Zig's
-    /// `builder.append(String, s)` don't each need a local adapter trait.
+    /// Convenience wrapper for `append::<String>` so callers
+    /// don't each need a local adapter trait.
     #[inline]
     fn append_string(&mut self, s: &[u8]) -> crate::semver_string::String {
         self.append::<crate::semver_string::String>(s)
@@ -78,7 +78,6 @@ impl StringBuilder for crate::semver_string::Builder {
 
 // ══════════════════════════════════════════════════════════════════════════
 // MOVE-IN: bun_install_types::sliced_string → bun_semver::sliced_string
-// Ground truth: src/install_types/SlicedString.zig
 // ══════════════════════════════════════════════════════════════════════════
 pub mod sliced_string {
     use super::external_string::ExternalString;
@@ -155,7 +154,6 @@ pub mod sliced_string {
 
 // ══════════════════════════════════════════════════════════════════════════
 // MOVE-IN: bun_install_types::external_string → bun_semver::external_string
-// Ground truth: src/install_types/ExternalString.zig
 // ══════════════════════════════════════════════════════════════════════════
 pub mod external_string {
     use core::cmp::Ordering;
@@ -188,7 +186,7 @@ pub mod external_string {
         pub fn from(in_: &[u8]) -> ExternalString {
             ExternalString {
                 value: String::init(in_, in_),
-                // `bun.Wyhash.hash(0, in)` — std.hash.Wyhash with seed 0, same as `bun.hash`
+                // Wyhash with seed 0.
                 hash: bun_wyhash::hash(in_),
             }
         }
@@ -225,7 +223,6 @@ pub mod external_string {
 
 // ══════════════════════════════════════════════════════════════════════════
 // MOVE-IN: bun_install_types::semver_string → bun_semver::semver_string
-// Ground truth: src/install_types/SemverString.zig
 // ══════════════════════════════════════════════════════════════════════════
 pub mod semver_string {
     use core::cmp::Ordering;
@@ -251,7 +248,7 @@ pub mod semver_string {
 
     impl fmt::Debug for String {
         // Buffer-relative `String` cannot be sliced without its arena, so debug
-        // output mirrors Zig's struct dump: the raw 8-byte handle. Callers that
+        // output is the raw 8-byte handle. Callers that
         // want the resolved text use `.fmt(buf)` / `.slice(buf)` instead.
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             f.debug_struct("String")
@@ -263,7 +260,7 @@ pub mod semver_string {
     // https://en.wikipedia.org/wiki/Intel_5-level_paging
     // https://developer.arm.com/documentation/101811/0101/Address-spaces-in-AArch64#:~:text=0%2DA%2C%20the%20maximum%20size,2%2DA.
     // X64 seems to need some of the pointer bits
-    // Zig: `const max_addressable_space = u63;` — Rust has no u63; use a mask for the @truncate semantics.
+    // Pointers are truncated to 63 bits via this mask.
     const MAX_ADDRESSABLE_SPACE_MASK: u64 = (1u64 << 63) - 1;
 
     const _: () = assert!(
@@ -278,8 +275,8 @@ pub mod semver_string {
             bytes: [0, 0, 0, 0, 0, 0, 0, 0],
         };
 
-        /// Create an inline string
-        // TODO(port): make const fn once `init` is const-evaluable; Zig used `comptime` block.
+        /// Create an inline string (`init`'s
+        /// pointer-packing path keeps this from being a `const fn`).
         pub fn from(inlinable_buffer: &'static [u8]) -> String {
             debug_assert!(
                 !(inlinable_buffer.len() > Self::MAX_INLINE_LEN
@@ -344,7 +341,7 @@ pub mod semver_string {
             }
         }
 
-        // PORT NOTE: `hashContext`/`arrayHashContext` (took *Lockfile) intentionally NOT moved
+        // `hashContext`/`arrayHashContext` (took *Lockfile) intentionally NOT moved
         // down — they would create a back-edge to bun_install. The HashContext/ArrayHashContext
         // structs themselves live here; the Lockfile-taking convenience constructors stay in
         // bun_install (or bun_install_types) as inherent helpers there.
@@ -480,7 +477,7 @@ pub mod semver_string {
         }
 
         pub fn init_append(buf: &mut Vec<u8>, in_: &[u8]) -> Result<String, AllocError> {
-            // PERF(port): Zig used `try buf.appendSlice(allocator, in)`; Vec::extend_from_slice
+            // Vec::extend_from_slice
             // panics on OOM under the global mimalloc allocator instead of returning an error.
             buf.extend_from_slice(in_);
             let items = buf.as_slice();
@@ -528,7 +525,6 @@ pub mod semver_string {
                     match self.bytes[0] {
                         0 => 0,
                         _ => {
-                            // PERF(port): was `inline while` (manually unrolled) — profile if hot.
                             let mut i: usize = 0;
                             while i < self.bytes.len() {
                                 if self.bytes[i] == 0 {
@@ -550,12 +546,12 @@ pub mod semver_string {
         #[inline]
         pub fn ptr(self) -> Pointer {
             let bits: u64 = u64::from_ne_bytes(self.bytes);
-            // @as(u63, @truncate(bits)) → mask off bit 63
+            // mask off bit 63
             let masked: u64 = bits & MAX_ADDRESSABLE_SPACE_MASK;
             Pointer::from_bits(masked)
         }
 
-        // PORT NOTE: `toJS` deleted — lives in bun_semver_jsc (tier-6; deferred to Pass C).
+        // `toJS` deleted — lives in bun_semver_jsc (tier-6; deferred to Pass C).
 
         // String must be a pointer because we reference it as a slice. It will become a dead pointer if it is copied.
         #[inline]
@@ -566,7 +562,6 @@ pub mod semver_string {
                     match self.bytes[0] {
                         0 => b"",
                         _ => {
-                            // PERF(port): was `inline while` (manually unrolled) — profile if hot.
                             let mut i: usize = 0;
                             while i < self.bytes.len() {
                                 if self.bytes[i] == 0 {
@@ -589,7 +584,7 @@ pub mod semver_string {
     }
 
     // ── String.Buf ────────────────────────────────────────────────────────
-    // PORT NOTE: `Buf::init(lockfile: *const Lockfile)` intentionally NOT moved down — would
+    // `Buf::init(lockfile: *const Lockfile)` intentionally NOT moved down — would
     // create a back-edge to bun_install. Higher-tier callers construct `Buf` via struct literal.
     pub struct Buf<'a> {
         pub bytes: &'a mut Vec<u8>,
@@ -824,7 +819,7 @@ pub mod semver_string {
             }
         }
 
-        /// Bit-reinterpret as `u64` (Zig `@bitCast`). `#[repr(C)]` lays out `off` at byte
+        /// Bit-reinterpret as `u64`. `#[repr(C)]` lays out `off` at byte
         /// offset 0 and `len` at offset 4; composing via native-endian byte arrays is
         /// byte-identical to a raw bitcast.
         #[inline]
@@ -849,7 +844,6 @@ pub mod semver_string {
     // ── String.Builder ────────────────────────────────────────────────────
 
     /// Trait abstracting over `String` and `ExternalString` for `Builder::append*` methods.
-    /// Replaces Zig's `comptime Type: type` + `switch (Type)` dispatch.
     pub trait BuilderStringType: Sized {
         fn from_init(allocated: &[u8], slice_: &[u8], hash: u64) -> Self;
         fn from_pooled(value: String, hash: u64) -> Self;
@@ -873,7 +867,6 @@ pub mod semver_string {
         }
     }
 
-    // Zig: `std.HashMap(u64, String, IdentityContext(u64), 80)`.
     #[derive(Default)]
     pub struct StringPool {
         map: HashMap<u64, String, bun_collections::IdentityContext<u64>>,
@@ -894,12 +887,12 @@ pub mod semver_string {
         pub fn contains(&self, hash: u64) -> bool {
             self.map.contains_key(&hash)
         }
-        /// Zig `HashMap.capacity()` — number of slots reservable without rehash.
+        /// Number of slots reservable without rehash.
         #[inline]
         pub fn capacity(&self) -> usize {
             self.map.capacity()
         }
-        /// Zig `HashMap.ensureTotalCapacity(n)` — pre-reserve so `n` entries
+        /// Pre-reserve so `n` entries
         /// fit without rehash.
         #[inline]
         pub fn ensure_total_capacity(&mut self, n: usize) -> Result<(), AllocError> {
@@ -947,7 +940,7 @@ pub mod semver_string {
         #[inline]
         pub fn allocated_slice(&self) -> &[u8] {
             if self.cap > 0 {
-                // SAFETY mirror: Zig did `this.ptr.?[0..this.cap]` — caller guarantees allocate() ran when cap > 0
+                // caller guarantees allocate() ran when cap > 0
                 &self.ptr.as_ref().expect("allocate() not called")[0..self.cap]
             } else {
                 &[]
@@ -955,14 +948,13 @@ pub mod semver_string {
         }
 
         pub fn allocate(&mut self) -> Result<(), AllocError> {
-            // PERF(port): Zig used uninitialized alloc; using zeroed Box<[u8]> here — profile if hot.
+            // PERF: zeroed Box<[u8]> here — profile if hot.
             let ptr_ = vec![0u8; self.cap].into_boxed_slice();
             self.ptr = Some(ptr_);
             Ok(())
         }
 
         pub fn append<T: BuilderStringType>(&mut self, slice_: &[u8]) -> T {
-            // PERF(port): was @call(bun.callmod_inline, ...) — relying on #[inline] / LLVM inlining
             self.append_with_hash::<T>(slice_, Self::string_hash(slice_))
         }
 
@@ -982,7 +974,7 @@ pub mod semver_string {
                 debug_assert!(self.ptr.is_some()); // must call allocate first
             }
 
-            // PORT NOTE: reshaped for borrowck — compute final slice range, then borrow once.
+            // reshaped for borrowck — compute final slice range, then borrow once.
             let start = self.len;
             let end = self.cap;
             {
@@ -1010,7 +1002,7 @@ pub mod semver_string {
                 debug_assert!(self.ptr.is_some()); // must call allocate first
             }
 
-            // PORT NOTE: reshaped for borrowck
+            // reshaped for borrowck
             let start = self.len;
             let end = self.cap;
             {
@@ -1038,7 +1030,7 @@ pub mod semver_string {
                 debug_assert!(self.ptr.is_some()); // must call allocate first
             }
 
-            // PORT NOTE: reshaped for borrowck — get_or_put borrows self.string_pool while we also need
+            // reshaped for borrowck — get_or_put borrows self.string_pool while we also need
             // &mut self.ptr; capture scalars first, then re-borrow.
             let start = self.len;
             let cap = self.cap;
@@ -1073,5 +1065,3 @@ pub mod semver_string {
         "String types must be the same size",
     );
 }
-
-// ported from: src/semver/semver.zig
diff --git a/src/semver_jsc/SemverObject.rs b/src/semver_jsc/SemverObject.rs
index 384224b0aa9..be524c0e2cf 100644
--- a/src/semver_jsc/SemverObject.rs
+++ b/src/semver_jsc/SemverObject.rs
@@ -18,8 +18,7 @@ pub fn create(global: &JSGlobalObject) -> JSValue {
 
 #[bun_jsc::host_fn]
 pub(crate) fn order(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-    // PERF(port): was ArenaAllocator + stackFallback(512) — profile if it shows up on a hot path.
-    // (allocator params dropped; to_slice() owns its buffer and Drops)
+    // `to_slice()` owns its buffer and frees it on Drop.
 
     let arguments = frame.arguments_old::<2>();
     let arguments = arguments.slice();
@@ -71,8 +70,6 @@ pub(crate) fn order(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSVa
 
 #[bun_jsc::host_fn]
 pub(crate) fn satisfies(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
-    // PERF(port): was ArenaAllocator + stackFallback(512) — profile if it shows up on a hot path.
-
     let arguments = frame.arguments_old::<2>();
     let arguments = arguments.slice();
     if arguments.len() < 2 {
@@ -99,7 +96,7 @@ pub(crate) fn satisfies(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<
 
     let left_version = left_result.version.min();
 
-    // `Query::parse` can only fail with OOM (Zig: `try` propagates allocator error).
+    // `Query::parse` can only fail with OOM.
     let right_group = match query::parse(
         right.slice(),
         SlicedString::init(right.slice(), right.slice()),
@@ -118,5 +115,3 @@ pub(crate) fn satisfies(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<
         left.slice(),
     )))
 }
-
-// ported from: src/semver_jsc/SemverObject.zig
diff --git a/src/semver_jsc/SemverString_jsc.rs b/src/semver_jsc/SemverString_jsc.rs
index b499b2a89c9..dc5c9325641 100644
--- a/src/semver_jsc/SemverString_jsc.rs
+++ b/src/semver_jsc/SemverString_jsc.rs
@@ -13,5 +13,3 @@ impl SemverStringJsc for SemverString {
         bun_string_jsc::create_utf8_for_js(global, self.slice(buffer))
     }
 }
-
-// ported from: src/semver_jsc/SemverString_jsc.zig
diff --git a/src/sha_hmac/hmac.rs b/src/sha_hmac/hmac.rs
index 4f03c2a533f..6517f828179 100644
--- a/src/sha_hmac/hmac.rs
+++ b/src/sha_hmac/hmac.rs
@@ -36,5 +36,3 @@ pub fn generate<'a>(
 
     Some(&out[..outlen as usize])
 }
-
-// ported from: src/sha_hmac/hmac.zig
diff --git a/src/sha_hmac/lib.rs b/src/sha_hmac/lib.rs
index 911a3d40cad..a64dd03bf3a 100644
--- a/src/sha_hmac/lib.rs
+++ b/src/sha_hmac/lib.rs
@@ -6,7 +6,7 @@ pub mod sha;
 // Convenience re-export so dependents can write `crate::evp::Algorithm`.
 pub use sha::evp;
 
-// Crate-root re-exports mirroring Zig's flat `bun.sha.*` / `bun.hmac.*` surface
+// Crate-root re-exports
 // so dependents can write `bun_sha_hmac::SHA256` / `bun_sha_hmac::generate`.
 pub use hmac::generate;
 pub use sha::{Algorithm, MD4, MD5, MD5_SHA1, SHA1, SHA224, SHA256, SHA384, SHA512, SHA512_256};
diff --git a/src/sha_hmac/sha.rs b/src/sha_hmac/sha.rs
index df0049d39cb..7b8ae05ef75 100644
--- a/src/sha_hmac/sha.rs
+++ b/src/sha_hmac/sha.rs
@@ -29,8 +29,8 @@ pub mod ffi {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Digest-length constants (Zig pulled these from `std.crypto.hash.*.digest_length`;
-// Rust has no stdlib equivalents, so the literal values are inlined here).
+// Digest-length constants (Rust has no stdlib equivalents, so the literal
+// values are inlined here).
 // ──────────────────────────────────────────────────────────────────────────
 const SHA1_DIGEST_LENGTH: usize = 20;
 const SHA256_DIGEST_LENGTH: usize = 32;
@@ -38,15 +38,13 @@ const SHA384_DIGEST_LENGTH: usize = 48;
 const SHA512_DIGEST_LENGTH: usize = 64;
 const SHA512_256_DIGEST_LENGTH: usize = 32;
 
-/// Zig: `fn NewHasher(comptime digest_size, comptime ContextType, Full, Init, Update, Final) type`
-///
-/// The Zig function returns an anonymous struct type parameterised by a context
-/// type and four FFI function *values* (passed as `anytype`). Stable Rust cannot
+/// Generates a hasher type parameterised by a context
+/// type and four FFI functions. Stable Rust cannot
 /// take function items as const-generic parameters, and the call sites are pure
 /// token-pasting of BoringSSL symbol names, so this is expressed as a
 /// `macro_rules!` type-generator.
-// TODO(port): inherent associated type `Digest = [u8; N]` requires nightly
-// `inherent_associated_types`; callers should use `[u8; <Name>::DIGEST]` for now.
+// An inherent associated type `Digest = [u8; N]` would require nightly
+// `inherent_associated_types`; callers spell `[u8; <Name>::DIGEST]` instead.
 macro_rules! new_hasher {
     (
         $name:ident,
@@ -103,11 +101,8 @@ macro_rules! new_hasher {
     };
 }
 
-/// Zig: `fn NewEVP(comptime digest_size, comptime MDName: []const u8) type`
-///
-/// `MDName` is used via `@field(BoringSSL, MDName)()` — comptime reflection to
-/// resolve a function by string name. That is token-pasting; expressed here by
-/// passing the BoringSSL `EVP_*` md-getter as an ident.
+/// Generates an EVP-backed hasher type;
+/// the BoringSSL `EVP_*` md-getter is passed as an ident.
 macro_rules! new_evp {
     ($name:ident, $digest_size:expr, $md_fn:ident) => {
         #[repr(C)]
@@ -203,12 +198,11 @@ pub mod evp {
     new_evp!(Blake2, 256 / 8, EVP_blake2b256);
 
     // ──────────────────────────────────────────────────────────────────────
-    // evp::Algorithm — moved from bun_jsc::api::bun::crypto.
-    //   source: src/runtime/crypto/EVP.zig (`pub const Algorithm = enum { ... }`)
-    //   moved here so `csrf` and `sha_hmac::hmac` can name it without
+    // evp::Algorithm — moved from bun_jsc::api::bun::crypto,
+    //   so `csrf` and `sha_hmac::hmac` can name it without
     //   depending upward on bun_jsc/bun_runtime.
     //   Only the enum + `md()` are lowered; `names` (needs bun.String) and
-    //   the comptime string map stay in the higher-tier EVP wrapper.
+    //   the name-lookup map stay in the higher-tier EVP wrapper.
     // ──────────────────────────────────────────────────────────────────────
 
     /// We do this to avoid asking BoringSSL what the digest name is, because
@@ -352,5 +346,3 @@ pub mod hashers {
         boringssl_sys::RIPEMD160_Final
     );
 }
-
-// ported from: src/sha_hmac/sha.zig
diff --git a/src/shell_parser/braces.rs b/src/shell_parser/braces.rs
index aa9402810f8..a16c0becc48 100644
--- a/src/shell_parser/braces.rs
+++ b/src/shell_parser/braces.rs
@@ -2,7 +2,7 @@ use core::ptr;
 
 use bun_alloc::ArenaVecExt as _;
 use bun_alloc::{AllocError, Arena as Bump};
-// PORT NOTE: `bun.SmallList` lives in `bun_css` (higher tier). Semantically it
+// `bun.SmallList` lives in `bun_css` (higher tier). Semantically it
 // is `smallvec::SmallVec` (inline-N, heap-spill). PORTING.md §Collections.
 use self::StringEncoding as Encoding;
 use bun_alloc::ArenaVec as BumpVec;
@@ -10,7 +10,7 @@ use bun_core::SmolStr;
 use smallvec::SmallVec;
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Moved from `bun_shell` (src/shell/shell.zig):
+// Moved from `bun_shell`:
 //   StringEncoding, SrcAscii, SrcUnicode, ShellCharIter, CharIter, has_eq_sign
 // These live here so `bun_shell` (higher tier) can depend on `shell_parser`
 // without a back-edge. `bun_shell` re-exports these under its old paths.
@@ -20,7 +20,7 @@ use bun_core::immutable::CodePoint; // i32
 use bun_core::immutable::{CodepointIterator, Cursor};
 use bun_core::strings;
 
-/// Zig: `pub const StringEncoding = enum { ascii, wtf8, utf16 };`
+/// Encoding of the shell input bytes being expanded.
 #[derive(Clone, Copy, PartialEq, Eq, core::marker::ConstParamTy)]
 pub enum StringEncoding {
     Ascii,
@@ -33,12 +33,11 @@ pub enum StringEncoding {
 // Copy: bitwise OK — `bytes` borrows caller-owned input (BACKREF, non-owning).
 #[derive(Copy, Clone)]
 struct SrcAscii {
-    bytes: *const [u8], // PORT NOTE: raw slice ptr — Zig held a borrowed `[]const u8`; lifetime erased (BACKREF).
+    bytes: *const [u8], // raw slice ptr — borrowed caller input; lifetime erased (BACKREF).
     i: usize,
 }
 
-/// Zig: `packed struct(u8) { char: u7, escaped: bool = false }`.
-// PERF(port): widened `char` to u32 so ascii/unicode share one `InputChar` shape and
+// PERF: `char` is u32 so ascii/unicode share one `InputChar` shape and
 // `ShellCharIter<const E>` needs no type-level branching on `E`. Could split per
 // encoding if profiling shows it matters.
 #[derive(Copy, Clone)]
@@ -49,7 +48,7 @@ pub struct InputChar {
 
 #[derive(Copy, Clone)]
 struct AsciiIndexValue {
-    char: u32, // u7 in Zig
+    char: u32,
     escaped: bool,
 }
 
@@ -63,7 +62,7 @@ impl SrcAscii {
     }
     #[inline]
     fn bytes(&self) -> &[u8] {
-        // SAFETY: `bytes` outlives the iter by construction (caller contract, same as Zig).
+        // SAFETY: `bytes` outlives the iter by construction (caller contract).
         unsafe { &*self.bytes }
     }
     #[inline]
@@ -97,7 +96,7 @@ impl SrcAscii {
 // ─── SrcUnicode ────────────────────────────────────────────────────────────
 
 struct SrcUnicode {
-    iter: CodepointIterator<'static>, // PORT NOTE: lifetime erased; see SrcAscii.bytes note.
+    iter: CodepointIterator<'static>, // lifetime erased; see SrcAscii.bytes note.
     cursor: Cursor,
     next_cursor: Cursor,
 }
@@ -119,7 +118,7 @@ impl SrcUnicode {
         }
     }
     fn init(bytes: &[u8]) -> Self {
-        // SAFETY: erase lifetime — caller guarantees `bytes` outlives the iter (same as Zig).
+        // SAFETY: erase lifetime — caller guarantees `bytes` outlives the iter.
         let bytes: &'static [u8] =
             unsafe { core::slice::from_raw_parts(bytes.as_ptr(), bytes.len()) };
         let iter = CodepointIterator::init(bytes);
@@ -177,7 +176,7 @@ pub enum ShellCharIterState {
     Double,
 }
 
-// PERF(port): Zig selected `Src` at comptime via `switch (encoding)`. Rust const
+// PERF: Rust const
 // generics can't pick a field type from an enum value without an aux trait, so we
 // store both arms in a small enum and branch at runtime. Could split into three
 // `impl CharIter for ShellCharIter<{StringEncoding::*}>` blocks if profiling
@@ -219,7 +218,7 @@ impl<const E: StringEncoding> ShellCharIter<E> {
 }
 
 impl<const E: StringEncoding> CharIter for ShellCharIter<E> {
-    // PERF(port): Zig used `u7` for ascii; unified to u32 (see InputChar note).
+    // PERF: unified to u32 for ascii and unicode (see InputChar note).
     type CodepointType = u32;
     type InputChar = InputChar;
 
@@ -341,7 +340,7 @@ impl<const E: StringEncoding> CharIter for ShellCharIter<E> {
                 }
             }
             // We checked `self.state == .Single` above so this is impossible.
-            // PORT NOTE: was `unreachable_unchecked()`; the lexer is on a
+            // was `unreachable_unchecked()`; the lexer is on a
             // cold path so trade the elided check for a defined panic.
             ShellCharIterState::Single => unreachable!(),
         }
@@ -355,7 +354,8 @@ impl<const E: StringEncoding> CharIter for ShellCharIter<E> {
 
 // ─── has_eq_sign ───────────────────────────────────────────────────────────
 
-/// Zig: `pub fn hasEqSign(str: []const u8) ?u32`.
+/// Returns the index of the first `=` in the string, if any
+/// (codepoint-aware for non-ASCII input).
 pub fn has_eq_sign(str_: &[u8]) -> Option<u32> {
     if strings::is_all_ascii(str_) {
         return bun_core::immutable::index_of_char(str_, b'=');
@@ -378,7 +378,7 @@ bun_core::declare_scope!(BRACES, visible);
 
 /// Using u16 because anymore tokens than that results in an unreasonably high
 /// amount of brace expansion (like around 32k variants to expand)
-// PORT NOTE: Zig `packed struct(u32)` — two u16 fields packed into a u32.
+// Two u16 fields packed into a u32.
 #[repr(transparent)]
 #[derive(Default, Copy, Clone)]
 struct ExpansionVariant(u32);
@@ -399,7 +399,7 @@ impl ExpansionVariant {
     }
 }
 
-#[derive(Default, Copy, Clone)]
+#[derive(Default, Copy, Clone, PartialEq, Eq)]
 pub struct ExpansionVariants {
     pub idx: u16,
     pub end: u16,
@@ -415,9 +415,39 @@ pub enum Token {
     Eof,
 }
 
-// PORT NOTE: Zig copied the union by value (bitwise SmolStr copy with shared
-// heap backing). The Rust port deep-copies via `from_slice` so the parser can
-// own its token. PERF(port): extra alloc on heap-backed SmolStr — profile if hot.
+impl PartialEq for Token {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Token::Open(a), Token::Open(b)) => a == b,
+            (Token::Comma, Token::Comma) => true,
+            // Compare text content; content comparison is the intended semantics.
+            (Token::Text(a), Token::Text(b)) => a.slice() == b.slice(),
+            (Token::Close, Token::Close) => true,
+            (Token::Eof, Token::Eof) => true,
+            _ => false,
+        }
+    }
+}
+impl Eq for Token {}
+
+impl core::fmt::Debug for Token {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Token::Open(v) => f
+                .debug_struct("Open")
+                .field("idx", &v.idx)
+                .field("end", &v.end)
+                .finish(),
+            Token::Comma => f.write_str("Comma"),
+            Token::Text(s) => write!(f, "Text({:?})", bstr::BStr::new(s.slice())),
+            Token::Close => f.write_str("Close"),
+            Token::Eof => f.write_str("Eof"),
+        }
+    }
+}
+
+// Deep-copies via `from_slice` so the parser can own
+// its token. PERF: extra alloc on heap-backed SmolStr — profile if hot.
 impl Clone for Token {
     fn clone(&self) -> Self {
         match self {
@@ -454,11 +484,11 @@ impl Token {
 }
 
 // ─── JSON debug formatters ───────────────────────────────────────────────────
-// Port of Zig's `std.json.fmt(tokens)` / `std.json.fmt(ast_node)` used by
-// `Bun.$.braces(str, {tokenize:true})` / `{parse:true}` (debug-only). Zig's
-// reflection-driven JSON encoder emits tagged unions as `{"<tag>": <payload>}`
-// and bare-payload structs by field; reproduce that shape so the JS-visible
-// output is byte-compatible.
+// Used by
+// `Bun.$.braces(str, {tokenize:true})` / `{parse:true}` (debug-only). The
+// encoder emits tagged unions as `{"<tag>": <payload>}`
+// and bare-payload structs by field, so the JS-visible
+// output shape stays stable.
 
 fn json_escape_into(out: &mut Vec<u8>, s: &[u8]) {
     // debug-only path; canonical's run-batched write_str preserves verbatim
@@ -530,7 +560,7 @@ fn ast_group_to_json(group: &ast::Group, out: &mut Vec<u8>) {
     if group.bubble_up.is_null() {
         out.extend_from_slice(b"null");
     } else {
-        // Zig's std.json.fmt encodes `?*T` as the pointer address.
+        // Optional pointers are encoded as the pointer address.
         let _ = write!(out, "{}", group.bubble_up as usize);
     }
     out.extend_from_slice(b",\"bubble_up_next\":");
@@ -573,7 +603,7 @@ pub mod ast {
 
     pub enum GroupAtoms {
         Single(Atom),
-        // PORT NOTE: bump-owned slice; raw because Group has raw backrefs (see bubble_up).
+        // bump-owned slice; raw because Group has raw backrefs (see bubble_up).
         Many(*mut [Atom]),
     }
 
@@ -595,7 +625,7 @@ pub mod ast {
     }
 
     pub struct Expansion {
-        // PORT NOTE: bump-owned mutable slice; raw because expand_nested writes
+        // bump-owned mutable slice; raw because expand_nested writes
         // bubble_up backrefs into elements while recursing through the parent.
         pub variants: *mut [Group],
     }
@@ -676,9 +706,17 @@ pub fn expand(
 // `expansion.variants` slices are bump-owned and outlive this call. The function
 // writes `bubble_up` backrefs (raw pointers) into child Groups and re-enters the
 // parent through them; raw-pointer access is used throughout to avoid creating
-// overlapping `&mut` borrows. Mirrors Zig pointer semantics 1:1.
-// TODO(port): audit aliasing soundness (no long-lived `&mut` is held across
-// recursion, only raw derefs).
+// overlapping `&mut` borrows.
+//
+// Aliasing audit: no reference is held across a recursive call. The shared
+// borrows created from raw pointers (`&(*root).atoms` match scrutinees,
+// `&(*many)[i_]`, `expansion`) are consumed before recursion — `variants` is
+// hoisted to a raw pointer copy ahead of the variant loop, and every arm that
+// recurses either tail-returns or returns immediately after its loop. Writes
+// during recursion target only `Group` structs (the stack root or bump-owned
+// `variants` elements), never the `[Atom]` slices a caller frame borrowed
+// from, and bubble-up re-entry always resumes past the caller's in-progress
+// atom index, so no frame's expansion is mutated while it is on the stack.
 unsafe fn expand_nested(
     root: *mut ast::Group,
     out: &mut [Vec<u8>],
@@ -686,7 +724,7 @@ unsafe fn expand_nested(
     out_key_counter: &mut u16,
     start: u32,
 ) -> Result<(), ExpandError> {
-    // SAFETY: see fn doc comment — raw-pointer derefs mirror Zig pointer semantics;
+    // SAFETY: see fn doc comment —
     // bump-owned Groups outlive this call, no overlapping `&mut` borrows are held.
     unsafe {
         if let ast::GroupAtoms::Single(_) = (*root).atoms {
@@ -723,9 +761,8 @@ unsafe fn expand_nested(
                 }
                 ast::GroupAtoms::Single(ast::Atom::Expansion(expansion)) => {
                     let length = out[usize::from(out_key)].len();
-                    // PORT NOTE: reshaped for borrowck — snapshot prefix once; Zig re-sliced
-                    // out[out_key].items[0..length] each iteration (same bytes).
-                    // PERF(port): extra Vec alloc for prefix snapshot — profile if hot.
+                    // reshaped for borrowck — snapshot prefix once.
+                    // PERF: extra Vec alloc for prefix snapshot — profile if hot.
                     let prefix: Vec<u8> = out[usize::from(out_key)][..length].to_vec();
                     let variants = expansion.variants;
                     let variants_len = variants.len();
@@ -774,8 +811,7 @@ unsafe fn expand_nested(
                 }
                 ast::Atom::Expansion(expansion) => {
                     let length = out[usize::from(out_key)].len();
-                    // PORT NOTE: reshaped for borrowck — see above.
-                    // PERF(port): extra Vec alloc for prefix snapshot — profile if hot.
+                    // reshaped for borrowck — see above.
                     let prefix: Vec<u8> = out[usize::from(out_key)][..length].to_vec();
                     let variants = expansion.variants;
                     let variants_len = variants.len();
@@ -846,8 +882,7 @@ fn expand_flat(
                 let skip_over_idx = variants[variants.len() - 1].end();
 
                 let starting_len = out[usize::from(out_key)].len();
-                // PORT NOTE: reshaped for borrowck — snapshot prefix once.
-                // PERF(port): extra Vec alloc for prefix snapshot — profile if hot.
+                // reshaped for borrowck — snapshot prefix once.
                 let prefix: Vec<u8> = out[usize::from(out_key)][..starting_len].to_vec();
                 for (i, variant) in variants.iter().enumerate() {
                     let new_key = if i == 0 {
@@ -888,7 +923,7 @@ fn expand_flat(
 }
 
 // FIXME error location
-// PORT NOTE: lifetime on transient parser struct; `tokens`/`bump` borrowed from caller
+// lifetime on transient parser struct; `tokens`/`bump` borrowed from caller
 // for the parse() call only — not an AST node.
 pub struct Parser<'a> {
     current: usize,
@@ -907,7 +942,6 @@ impl<'a> Parser<'a> {
 
     pub fn parse(&mut self) -> Result<ast::Group, ParserError> {
         check_brace_group_count(self.tokens)?;
-        // PERF(port): was stack-fallback alloc (@sizeOf(AST.Atom)) — profile if hot.
         let mut nodes: BumpVec<'a, ast::Atom> = BumpVec::new_in(self.bump);
         while !self.r#match(TokenTag::Eof) {
             match self.parse_atom()? {
@@ -951,7 +985,6 @@ impl<'a> Parser<'a> {
             if self.r#match(TokenTag::Eof) {
                 break;
             }
-            // PERF(port): was stack-fallback alloc (@sizeOf(AST.Atom)) — profile if hot.
             let mut group: BumpVec<'a, ast::Atom> = BumpVec::new_in(self.bump);
             let mut close = false;
             while !self.r#match(TokenTag::Eof) {
@@ -1019,7 +1052,6 @@ impl<'a> Parser<'a> {
 
     fn match_any(&mut self, toktags: &[TokenTag]) -> bool {
         let peeked = self.peek().tag();
-        // PERF(port): was `inline for` — profile if hot.
         for &tag in toktags {
             if peeked == tag {
                 let _ = self.advance();
@@ -1083,8 +1115,8 @@ pub fn calculate_expanded_amount(tokens: &[Token]) -> u32 {
 }
 
 fn build_expansion_table_alloc(tokens: &mut [Token]) -> Result<Vec<ExpansionVariant>, ParserError> {
-    // PERF(port): was arena bulk-free — Zig fed the same allocator to Parser and this
-    // table; table is local POD dropped at end of expand(), so global Vec is logic-neutral.
+    // PERF: the table is local POD dropped at the end of expand(), so a
+    // plain global-allocator Vec is logic-neutral here.
     let mut table: Vec<ExpansionVariant> = Vec::new();
     build_expansion_table(tokens, &mut table)?;
     Ok(table)
@@ -1222,7 +1254,7 @@ impl<const ENCODING: Encoding> NewLexer<ENCODING> {
             let escaped = input.escaped;
 
             if !escaped {
-                // PORT NOTE: `char` is u32 (CodepointType unified across encodings).
+                // `char` is u32 (CodepointType unified across encodings).
                 match char {
                     c if c == u32::from(b'{') => {
                         brace_stack.push(u32::try_from(self.tokens.len()).expect("int cast"));
@@ -1276,8 +1308,7 @@ impl<const ENCODING: Encoding> NewLexer<ENCODING> {
         let mut i: u32 = 0;
         let mut j: u32 = 1;
         while (i as usize) < self.tokens.len() && (j as usize) < self.tokens.len() {
-            // PORT NOTE: reshaped for borrowck — Zig held two `&mut` into self.tokens
-            // simultaneously. We branch on tags first, then borrow once.
+            // reshaped for borrowck — branch on tags first, then borrow once.
             let itok_is_text = matches!(self.tokens[i as usize], Token::Text(_));
             let jtok_is_text = matches!(self.tokens[j as usize], Token::Text(_));
 
@@ -1420,10 +1451,7 @@ mod tests {
             let TestCase(src, expected) = test_case;
             // NOTE: don't use arena here so that we can test for memory leaks
             let result = Lexer::tokenize(src).unwrap();
-            // TODO(port): Token needs PartialEq for this assertion (SmolStr: PartialEq).
-            assert_eq!(result.tokens.len(), expected.len());
+            assert_eq!(result.tokens, expected);
         }
     }
 }
-
-// ported from: src/shell_parser/braces.zig
diff --git a/src/shell_parser/json_fmt.rs b/src/shell_parser/json_fmt.rs
index 57df35d4a83..528c0b9904f 100644
--- a/src/shell_parser/json_fmt.rs
+++ b/src/shell_parser/json_fmt.rs
@@ -1,7 +1,5 @@
-//! JSON serialization for the shell AST, matching Zig `std.json.fmt(v, .{})`.
+//! JSON serialization for the shell AST.
 //!
-//! Port of the implicit serialization the Zig side gets for free via
-//! `std.json.Stringify.write` reflection (vendor/zig/lib/std/json/Stringify.zig).
 //! Only the testing APIs (`shellInternals.lex` / `.parse`) consume this, so the
 //! shape is dictated by `test/js/bun/shell/{lex,parse}.test.ts`:
 //!   - struct           → `{"field":value,...}` in field-declaration order
@@ -48,7 +46,7 @@ fn write_array<W: Write, T>(
 }
 
 // ───────────────────────────── RedirectFlags ──────────────────────────
-// Zig: `packed struct(u8)` → struct serialization in field-declaration order.
+// Struct serialization in field-declaration order.
 
 pub fn write_redirect_flags(w: &mut impl Write, r: RedirectFlags) -> fmt::Result {
     w.write_str("{\"stdin\":")?;
@@ -305,7 +303,7 @@ fn write_compound_atom(w: &mut impl Write, c: &CompoundAtom<'_>) -> fmt::Result
 
 // ───────────────────────────── Display adapters ──────────────────────────
 
-/// `Display` adapter mirroring Zig's `std.json.fmt(script_ast, .{})`.
+/// `Display` adapter that JSON-serializes a `Script` AST.
 pub fn script_json_fmt<'a, 'b>(script: &'b Script<'a>) -> impl fmt::Display + 'b {
     ScriptJsonFmt(script)
 }
diff --git a/src/shell_parser/lib.rs b/src/shell_parser/lib.rs
index 4ae5b472de3..04705d131a9 100644
--- a/src/shell_parser/lib.rs
+++ b/src/shell_parser/lib.rs
@@ -11,7 +11,7 @@ pub use braces::{
 };
 
 // ─── lexer / parser / AST ───────────────────────────────────────────────────
-// Port of `shell.zig` lex/parse — moved down from `bun_runtime::shell::shell_body`
+// Shell lex/parse — moved down from `bun_runtime::shell::shell_body`
 // so `Interpreter::parse` can consume it without the JSC bridge.
 #[path = "parse.rs"]
 pub mod parse;
diff --git a/src/shell_parser/parse.rs b/src/shell_parser/parse.rs
index 7117e01a14a..104120b2bb3 100644
--- a/src/shell_parser/parse.rs
+++ b/src/shell_parser/parse.rs
@@ -1,4 +1,4 @@
-//! Port of src/shell/shell.zig — lexer, parser, AST.
+//! Shell lexer, parser, AST.
 //! Extracted from `shell_body.rs` so the parser compiles in the lower-tier
 //! `bun_shell_parser` crate (no `bun_jsc` dependency). `Interpreter::parse`
 //! in `bun_runtime` consumes these via `bun_shell_parser::*`.
@@ -13,8 +13,7 @@ use bun_alloc::Arena as Bump;
 use bun_alloc::ArenaVecExt as _;
 use bun_core::{String as BunString, immutable as strings};
 
-// PORT NOTE: `strings::Cursor` (immutable.zig CodepointIterator.Cursor). Aliased
-// as `CodepointCursor` so the body reads identically to the Zig source.
+// `strings::Cursor` aliased as `CodepointCursor` for readability.
 type CodepointCursor = strings::Cursor;
 
 /// Opaque stand-in for `bun_jsc::JSValue` — the parser only *stores* the
@@ -60,13 +59,12 @@ impl From<ParseError> for bun_core::Error {
 pub mod ast {
     use super::*;
 
-    // Re-export so `ast::SmolList<T, N>` resolves for downstream state nodes
-    // (mirrors Zig's nesting where `SmolList` lives under the AST namespace).
+    // Re-export so `ast::SmolList<T, N>` resolves for downstream state nodes.
     pub use super::SmolList;
 
-    // PORT NOTE: Zig AST nodes hold `[]T` slices (ptr+len, copyable). The Rust
-    // port uses `&'arena [T]` so the whole tree is `Clone`/`Copy`-able like
-    // Zig — required by `Atom::merge` and `SmolList::init_with_slice`.
+    // AST nodes hold `&'arena [T]` slices so the whole tree is
+    // `Clone`/`Copy`-able — required by `Atom::merge` and
+    // `SmolList::init_with_slice`.
 
     #[derive(Copy, Clone)]
     pub struct Script<'arena> {
@@ -115,7 +113,7 @@ pub mod ast {
     }
 
     #[derive(Clone, Copy, PartialEq, Eq, strum::IntoStaticStr)]
-    // PORT NOTE: must match Zig `@tagName(AST.Expr.Tag)` exactly — used in
+    // The snake_case tag names are used in
     // user-visible parser errors (see add_error_expected_pipeline_item).
     #[strum(serialize_all = "snake_case")]
     pub(crate) enum ExprTag {
@@ -623,8 +621,8 @@ pub mod ast {
             self.contains(Self::DUPLICATE_OUT)
         }
 
-        // PORT NOTE: shell.zig RedirectFlags.isEmpty() — bitflags already
-        // generates `is_empty()`; expose under the Zig spelling for parity.
+        // bitflags already generates `is_empty()`; expose under this
+        // spelling too for callers that use it.
         #[inline]
         pub fn isEmpty(self) -> bool {
             self.bits() == 0
@@ -650,20 +648,11 @@ pub mod ast {
             }
         }
 
-        // TODO(port): Zig fns @"2>&1"/@"1>&2" reference nonexistent `.duplicate` field — likely dead code.
-        pub fn two_gt_amp_one() -> RedirectFlags {
-            Self::STDERR | Self::DUPLICATE_OUT
-        }
-        pub fn one_gt_amp_two() -> RedirectFlags {
-            Self::STDOUT | Self::DUPLICATE_OUT
-        }
-
         pub fn to_flags(self) -> i32 {
-            // Spec: shell.zig `RedirectFlags.toFlags()` uses `bun.O.{RDONLY,...}`.
             // `bun_shell_parser` is sys-tier-free so it cannot depend on
             // `bun_sys::O`; mirror those constants here. On POSIX `bun.O.*` is
             // `libc::O_*`. On Windows `bun.O.*` is the *Linux-shaped octal*
-            // values (sys.zig:188-213) — NOT MSVCRT `_O_*` — because
+            // values — NOT MSVCRT `_O_*` — because
             // `bun_sys::open` → `sys_uv::open` → `uv::O::from_bun_o` bit-tests
             // against those exact values. Using `libc::O_CREAT` (0x100) /
             // `libc::O_APPEND` (0x8) on Windows silently dropped CREAT/APPEND
@@ -762,7 +751,6 @@ pub mod ast {
             use SimpleAtom as SA;
             match (&self, right) {
                 (Atom::Simple(l), Atom::Simple(r)) => {
-                    // PORT NOTE: Zig `try allocator.alloc(SimpleAtom, 2)` —
                     // bumpalo has no fill_default for non-Default types, so
                     // seed with `QuotedEmpty` then overwrite.
                     let atoms = bump.alloc_slice_fill_with(2, |_| SimpleAtom::QuotedEmpty);
@@ -889,8 +877,6 @@ pub mod ast {
         pub script: Script<'arena>,
         pub quoted: bool,
     }
-    // TODO(port): Script contains &'arena mut — Clone is wrong; revisit.
-
     impl<'arena> CmdSubst<'arena> {
         pub fn memory_cost(&self) -> usize {
             let mut cost = size_of::<Self>();
@@ -976,7 +962,6 @@ pub struct ParserError<'bump> {
 }
 
 type ParseResult<T> = Result<T, bun_core::Error>;
-// TODO(port): narrow error set — Zig uses inferred error sets that include ParseError + OOM.
 
 impl<'bump> Parser<'bump> {
     pub fn new(
@@ -1000,15 +985,14 @@ impl<'bump> Parser<'bump> {
     /// If you make a subparser and call some fallible functions on it, you need to catch the errors
     /// and call `.continue_from_subparser()`, otherwise errors will not propagate upwards to the parent.
     pub fn make_subparser(&mut self, kind: SubshellKind) -> Parser<'bump> {
-        // PORT NOTE: reshaped for borrowck — Zig copies `self.errors` (the ArrayList struct) into
-        // the subparser by value, then writes it back in continue_from_subparser. We move it out
-        // via mem::take and restore it later.
+        // reshaped for borrowck — `self.errors` is moved out
+        // via mem::take and restored in continue_from_subparser.
         Parser {
             strpool: self.strpool,
             tokens: self.tokens,
             js_string_ranges: self.js_string_ranges,
             alloc: self.alloc,
-            // PORT NOTE: reshaped for borrowck — Zig copies the slice value; we move the
+            // reshaped for borrowck — move the
             // exclusive borrow into the subparser and restore it in continue_from_subparser.
             jsobjs: core::mem::take(&mut self.jsobjs),
             current: self.current,
@@ -1093,7 +1077,6 @@ impl<'bump> Parser<'bump> {
                     "Background commands \"&\" are not supported yet."
                 ))?;
                 return Err(ParseError::Unsupported.into());
-                // (large block of commented-out async-handling code in Zig — omitted)
             }
             exprs.push(expr);
         }
@@ -1726,7 +1709,6 @@ impl<'bump> Parser<'bump> {
     }
 
     fn parse_atom(&mut self) -> ParseResult<Option<ast::Atom<'bump>>> {
-        // PERF(port): was stack-fallback (1 SimpleAtom) — profile if hot.
         let mut atoms = bun_alloc::ArenaVec::with_capacity_in(1, self.alloc);
         let mut has_brace_open = false;
         let mut has_brace_close = false;
@@ -2022,7 +2004,6 @@ impl<'bump> Parser<'bump> {
     }
 
     fn match_any_comptime(&mut self, toktags: &[TokenTag]) -> bool {
-        // PERF(port): was comptime monomorphization — profile if hot.
         let peeked = self.peek().tag();
         for &tag in toktags {
             if peeked == tag {
@@ -2066,7 +2047,6 @@ impl<'bump> Parser<'bump> {
     }
 
     fn peek_any_comptime_ifclausetok(&self, toktags: &[IfClauseTok]) -> bool {
-        // PERF(port): was comptime monomorphization — profile if hot.
         self.peek_any_ifclausetok(toktags)
     }
 
@@ -2133,8 +2113,8 @@ impl<'bump> Parser<'bump> {
     }
 
     fn add_error(&mut self, args: fmt::Arguments<'_>) -> ParseResult<()> {
-        // PORT NOTE: bumpalo::collections::Vec<u8> doesn't impl io::Write.
-        // Format into a stack String, then bump-copy. PERF(port): collapse to
+        // bumpalo::collections::Vec<u8> doesn't impl io::Write.
+        // Format into a stack String, then bump-copy. TODO: collapse to
         // a bumpalo `String` writer once available.
         let s = bun_alloc::ArenaString::from_str_in(&std::fmt::format(args), self.alloc);
         let msg = s.into_bump_str().as_bytes();
@@ -2322,8 +2302,8 @@ impl TextRange {
 
 impl Token {
     pub fn as_human_readable(self, strpool: &[u8]) -> &[u8] {
-        // PORT NOTE: Zig builds varargv_strings as a 10x[2]u8 stack array; in Rust we'd need
-        // a thread_local or to return Cow. Use a static lookup instead.
+        // Building these on the stack would need
+        // a thread_local or a Cow return type. Use a static lookup instead.
         const VARARGV_STRINGS: [&[u8]; 10] = [
             b"$0", b"$1", b"$2", b"$3", b"$4", b"$5", b"$6", b"$7", b"$8", b"$9",
         ];
@@ -2539,8 +2519,7 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
 
     fn make_sublexer(&mut self, kind: SubShellKind) -> Self {
         log!("[lex] make sublexer");
-        // PORT NOTE: reshaped for borrowck — Zig copies ArrayLists by value (shared backing buffer
-        // until reallocation). In Rust we move them out via mem::take and restore in
+        // reshaped for borrowck — move the lists out via mem::take and restore in
         // continue_from_sublexer.
         let bump = self.strpool.bump();
         let mut sublexer = Self {
@@ -2557,7 +2536,7 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
             word_start: self.word_start,
             j: self.j,
             delimit_quote: false,
-            // PORT NOTE: reshaped for borrowck — move the exclusive borrow into the sublexer
+            // reshaped for borrowck — move the exclusive borrow into the sublexer
             // and restore it in continue_from_sublexer (avoids aliased &mut).
             string_refs: core::mem::take(&mut self.string_refs),
             jsobjs_len: self.jsobjs_len,
@@ -2585,7 +2564,7 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
     }
 
     fn make_snapshot(&self) -> BacktrackSnapshot<'bump, ENCODING> {
-        // PORT NOTE: explicit `'bump` so the snapshot borrows the arena, not
+        // explicit `'bump` so the snapshot borrows the arena, not
         // `&self` — otherwise holding a snapshot would freeze the lexer.
         BacktrackSnapshot {
             chars: self.chars,
@@ -2612,8 +2591,8 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
     pub fn lex(&mut self) -> Result<(), LexerError> {
         loop {
             // Fast path: bulk-consume runs of non-special bytes in Normal state.
-            // Zig's `switch (char)` compiles to a jump table even in debug; the
-            // Rust guard-arm chain below does not, so a 1 MiB literal word (see
+            // The guard-arm chain below does not compile to a jump table in
+            // debug, so a 1 MiB literal word (see
             // shell-leak-args.test.ts) walks ~20 guard comparisons per byte and
             // overruns the test timeout. This block mirrors what the slow path
             // would do for any byte NOT in SPECIAL_CHARS_TABLE: append to
@@ -3005,7 +2984,6 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
                             return Ok(());
                         }
                         c if (u32::from(b'0')..=u32::from(b'9')).contains(&c) => {
-                            // PERF(port): was `comptime for ('0'..'9') |c| assertSpecialChar(c);`
                             if self.chars.state != CharState::Normal {
                                 break 'escaped;
                             }
@@ -3158,9 +3136,8 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
                 if fell_through {
                     continue;
                 }
-                // PORT NOTE: Zig has `continue;` after the switch in `else escaped:`, but only when
-                // the case did NOT `break :escaped`. We model that with `fell_through`. Cases that
-                // break 'escaped fall through to appendCharToStrPool below.
+                // `fell_through` marks cases that should re-enter the loop;
+                // cases that break 'escaped fall through to appendCharToStrPool below.
             }
             // Treat newline preceded by backslash as whitespace
             else if char == u32::from(b'\n') {
@@ -3190,12 +3167,12 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
 
     fn append_char_to_str_pool(&mut self, char: u32) -> Result<(), LexerError> {
         if ENCODING == StringEncoding::Ascii {
-            // PERF(port): @intCast — ENCODING==Ascii guarantees char < 256
+            // ENCODING==Ascii guarantees char < 256
             self.strpool.push(u8::try_from(char).expect("int cast"));
             self.j += 1;
         } else {
             if char <= 0x7F {
-                // PERF(port): @intCast — guarded by char <= 0x7F
+                // guarded by char <= 0x7F
                 self.strpool.push(u8::try_from(char).expect("int cast"));
                 self.j += 1;
                 return Ok(());
@@ -3449,11 +3426,9 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
         let start = self.strpool.len();
         if bunstr.is_utf16() {
             let utf16 = bunstr.utf16();
-            // PORT NOTE: Zig calls simdutf for the exact length then
-            // `convertUTF16ToUTF8Append` directly into the bump-backed
-            // ArrayList. The Rust transcoding helpers in bun_core take
+            // The transcoding helpers in bun_core take
             // `&mut Vec<u8>` (global allocator), so go through a scratch Vec
-            // and copy. PERF(port): re-unify once a bumpalo-aware transcoder
+            // and copy. PERF: re-unify once a bumpalo-aware transcoder
             // lands in bun_core.
             let mut scratch: Vec<u8> = Vec::with_capacity(utf16.len() * 3);
             bun_core::convert_utf16_to_utf8_append(&mut scratch, utf16);
@@ -3469,7 +3444,7 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
                 if non_ascii_idx > 0 {
                     self.strpool.extend_from_slice(&bytes[..non_ascii_idx]);
                 }
-                // PORT NOTE: `allocateLatin1IntoUTF8WithList` round-trips
+                // `allocateLatin1IntoUTF8WithList` round-trips
                 // through a std Vec; encode directly here instead (same
                 // mapping: 0x00–0x7F passthrough, 0x80–0xFF → 2-byte UTF-8).
                 self.strpool.reserve((bytes.len() - non_ascii_idx) * 2);
@@ -3783,8 +3758,8 @@ impl<'bump, const ENCODING: StringEncoding> Lexer<'bump, ENCODING> {
 
 // ───────────────────────────── ShellCharIter / Src ─────────────────────────────
 
-/// Unified InputChar — Zig had two layouts (packed u8 for ascii, struct for unicode).
-/// In Rust we use one struct; CodepointType is u32 in both (ascii values fit in u7).
+/// Unified InputChar — one struct for both encodings;
+/// CodepointType is u32 in both (ascii values fit in u7).
 // TODO(perf): if the packed-u8 layout matters for perf, specialize via const generic.
 #[derive(Clone, Copy)]
 pub struct InputChar {
@@ -3820,7 +3795,8 @@ impl<'a> SrcAscii<'a> {
             return None;
         }
         Some(SrcAsciiIndexValue(self.bytes[self.i] & 0x7F))
-        // TODO(port): Zig @intCast to u7 — high bit truncated; assumes ASCII input.
+        // `& 0x7F` truncates to 7 bits; callers
+        // must guarantee ASCII input.
     }
 
     #[inline]
@@ -3839,11 +3815,10 @@ impl<'a> SrcAscii<'a> {
 
 pub(crate) type CodepointIterator<'a> = strings::UnsignedCodepointIterator<'a>;
 
-// PORT NOTE: Zig holds a `CodepointIterator` by value (whose only state used
-// by `next(cursor)` is `bytes`). The Rust `NewCodePointIterator` lacks
+// `NewCodePointIterator` lacks
 // `Clone`/`Copy`, so store the underlying `&[u8]` instead and rebuild the
 // iterator on demand — keeps `SrcUnicode` (and thus `BacktrackSnapshot`)
-// `Copy` like the Zig original.
+// `Copy`.
 #[derive(Clone, Copy)]
 pub struct SrcUnicode<'a> {
     pub bytes: &'a [u8],
@@ -4109,7 +4084,7 @@ pub fn is_valid_var_name(var_name: &[u8]) -> bool {
         return false;
     }
 
-    // PORT NOTE: `Cursor.c` is `i32` (`CodePoint`). Widen to `u32` for the
+    // `Cursor.c` is `i32` (`CodePoint`). Widen to `u32` for the
     // ASCII-range matches below; negative sentinel never matches anyway.
     match cursor.c as u32 {
         c if c == u32::from(b'=') || (u32::from(b'0')..=u32::from(b'9')).contains(&c) => {
@@ -4156,7 +4131,7 @@ fn is_valid_var_name_ascii(var_name: &[u8]) -> bool {
     true
 }
 
-// PORT NOTE: shell.zig declares a `stderr_mutex: bun.Mutex` here. It is only
+// A `stderr_mutex` is only
 // used by the `Test` namespace's debug-dump path (gated to `bun_runtime`), so
 // the lower-tier parser crate omits it.
 
@@ -4222,7 +4197,6 @@ pub const SPECIAL_CHARS: [u8; 34] = [
     SPECIAL_JS_CHAR,
 ];
 
-// PORT NOTE: Zig uses `bit_set.IntegerBitSet(256)`. The Rust
 // `bun_collections::IntegerBitSet<N>` is single-`usize`-backed (≤64 bits), so a
 // 256-entry membership table is materialised as `[bool; 256]` instead — same
 // O(1) byte-indexed lookup, const-evaluable.
@@ -4317,8 +4291,8 @@ pub fn escape_utf16<const ADD_QUOTES: bool>(
                 i += 1;
                 break 'brk c as u32;
             }
-            // PORT NOTE: Zig calls `bun.strings.utf16Codepoint` (never sets `.fail`),
-            // so the `is_invalid` early-return is dead in spec; use the non-FFFD variant.
+            // `utf16_codepoint` never sets `.fail`,
+            // so an `is_invalid` early-return would be dead; use the non-FFFD variant.
             let ret = strings::utf16_codepoint(&str[i..]);
             i += ret.len as usize;
             ret.code_point
@@ -4514,8 +4488,7 @@ impl<T, const INLINED_MAX: usize> SmolListInlined<T, INLINED_MAX> {
     }
 }
 
-// PORT NOTE: Zig's `SmolList.memoryCost` branched on `@hasDecl(T, "memoryCost")`
-// at comptime. Expressed as a trait + per-type forwarding impls below.
+// Per-type memory-cost dispatch is expressed as a trait + forwarding impls below.
 pub trait MemoryCost {
     fn memory_cost(&self) -> usize;
 }
@@ -4593,7 +4566,8 @@ impl<T, const INLINED_MAX: usize> SmolList<T, INLINED_MAX> {
         SmolList::Heap(heap)
     }
 
-    // TODO(port): jsonStringify — wire up serde or a custom JSON writer.
+    // JSON serialization lives in `json_fmt.rs` (`write_stmt_smol` writes the
+    // slice as a JSON array).
 
     #[inline]
     pub fn len(&self) -> usize {
@@ -4639,12 +4613,15 @@ impl<T, const INLINED_MAX: usize> SmolList<T, INLINED_MAX> {
                     return;
                 }
                 let new_len = inlined.len as usize - starting_idx;
-                // Rotate the suffix to the front; the old prefix lands at
-                // `[new_len..]` and is abandoned by the len adjust (same
-                // leak-on-Drop caveat as the original `ptr::copy` version —
-                // see `clear_retaining_capacity` TODO; all current `T` are
-                // arena-backed and `!Drop`).
+                // Rotate the suffix to the front; the rotated-out prefix
+                // lands at `[new_len..]` and must be dropped before the len
+                // adjust so `T: Drop` elements are not leaked (matching
+                // `clear_retaining_capacity` and the `Drop` impl).
                 inlined.slice_mut().rotate_left(starting_idx);
+                // SAFETY: `slice_mut` covers exactly the initialized prefix;
+                // `[new_len..]` are the elements being discarded, and the len
+                // adjust below makes them unobservable afterwards.
+                unsafe { core::ptr::drop_in_place(&raw mut inlined.slice_mut()[new_len..]) };
                 inlined.len = u32::try_from(new_len).expect("int cast");
             }
             SmolList::Heap(heap) => {
@@ -4727,7 +4704,10 @@ impl<T, const INLINED_MAX: usize> SmolList<T, INLINED_MAX> {
     pub fn clear_retaining_capacity(&mut self) {
         match self {
             SmolList::Inlined(i) => {
-                // TODO(port): drop initialized elements if T: Drop
+                // SAFETY: `slice_mut` covers exactly the initialized prefix
+                // (first `len` elements); dropping it then resetting `len`
+                // leaves no element observable twice.
+                unsafe { core::ptr::drop_in_place(i.slice_mut()) };
                 i.len = 0;
             }
             SmolList::Heap(h) => h.clear(),
@@ -4762,11 +4742,16 @@ impl<T, const N: usize> core::ops::Index<usize> for SmolList<T, N> {
 
 impl<T, const N: usize> Drop for SmolList<T, N> {
     fn drop(&mut self) {
-        if let SmolList::Heap(_) = self {
-            // Vec drops itself
+        // Heap: the Vec drops itself.
+        // Inlined: drop the initialized prefix so `T: Drop` elements are not
+        // leaked.
+        if let SmolList::Inlined(i) = self {
+            // SAFETY: `slice_mut` covers exactly the initialized prefix
+            // (first `len` elements); we are in `drop`, so nothing observes
+            // the elements afterwards.
+            unsafe { core::ptr::drop_in_place(i.slice_mut()) };
+            i.len = 0;
         }
-        // Inlined: TODO(port): drop initialized elements if T: Drop. Zig deinit only freed heap.
-        // Reset to zeroes is implicit.
     }
 }
 
diff --git a/src/simdutf_sys/simdutf.rs b/src/simdutf_sys/simdutf.rs
index 974133b67c5..0059b4bb118 100644
--- a/src/simdutf_sys/simdutf.rs
+++ b/src/simdutf_sys/simdutf.rs
@@ -13,7 +13,7 @@ impl SIMDUTFResult {
     }
 }
 
-// Zig: `enum(i32) { ..., _ }` — the `_` arm means *any* i32 is a valid bit
+// Any i32 is a valid bit
 // pattern (C++ may return values outside the named set). A `#[repr(i32)] enum`
 // in Rust would be UB on unknown discriminants, so we use a transparent newtype
 // with associated consts instead.
@@ -843,5 +843,3 @@ pub mod base64 {
         }
     }
 }
-
-// ported from: src/simdutf_sys/simdutf.zig
diff --git a/src/sourcemap/Chunk.rs b/src/sourcemap/Chunk.rs
index aa0875c6790..b7e87959f7a 100644
--- a/src/sourcemap/Chunk.rs
+++ b/src/sourcemap/Chunk.rs
@@ -136,13 +136,11 @@ fn print_source_map_contents_json<const ASCII_ONLY: bool>(
     Ok(())
 }
 
-// NOTE: `SourceMapFormat<T>`/`SourceMapFormatCtx` are kept for source-level
-// parity with Zig's `SourceMapFormat(Type)` shape, but `VLQSourceMap` is the
-// only implementor and `NewBuilder`'s hot methods are now concretized on it
+// NOTE: `VLQSourceMap` is the only `SourceMapFormatCtx` implementor and
+// `NewBuilder`'s hot methods are concretized on it
 // (see the `impl NewBuilder<VLQSourceMap>` block below).
 
 /// Trait capturing the methods `SourceMapFormat<T>` forwards to its `ctx`.
-/// In Zig this was structural (comptime duck typing on `Type`).
 pub trait SourceMapFormatCtx: Sized {
     fn init(prepend_count: bool) -> Self;
     fn append_line_separator(&mut self) -> Result<(), bun_core::Error>;
@@ -189,9 +187,8 @@ impl<T: SourceMapFormatCtx> SourceMapFormat<T> {
 
     #[inline]
     pub fn get_buffer(&mut self) -> &mut MutableString {
-        // PORT NOTE: Zig returned `MutableString` by value (struct copy sharing
-        // the same backing allocation). Rust returns `&mut` to avoid a
-        // double-ownership footgun; callers mutate in place.
+        // Returns `&mut` to avoid a double-ownership footgun;
+        // callers mutate in place.
         self.ctx.get_buffer()
     }
 
@@ -244,10 +241,8 @@ impl SourceMapFormatCtx for VLQSourceMap {
 
     // PERF: `#[inline(always)]` — fat-LTO/CGU=1 was *not* inlining this trait
     // method into `add_source_mapping` (objdump showed 3× `call` per mapping;
-    // 11.77% of `append` samples on the `push %rbp` prologue). Zig's
-    // `Chunk.zig:107` wrapper is `pub inline fn` and the whole chain folds
-    // into `addSourceMapping`. Forcing it leaves only the 64-mapping
-    // `flush_window` out-of-line.
+    // 11.77% of `append` samples on the `push %rbp` prologue). Forcing it
+    // leaves only the 64-mapping `flush_window` out-of-line.
     #[inline(always)]
     fn append_line_separator(&mut self) -> Result<(), bun_core::Error> {
         if let Some(b) = &mut self.internal {
@@ -287,8 +282,7 @@ impl SourceMapFormatCtx for VLQSourceMap {
 
     fn get_buffer(&mut self) -> &mut MutableString {
         if let Some(b) = &mut self.internal {
-            // PORT NOTE: Zig did `this.data = b.finalize().*; b.finalized = null;`
-            // i.e. move the finalized buffer out and clear the builder.
+            // Move the finalized buffer out and clear the builder.
             self.data = b.finalize_take();
             self.internal = None;
         }
@@ -311,9 +305,8 @@ impl SourceMapFormatCtx for VLQSourceMap {
 pub struct NewBuilder<T: SourceMapFormatCtx> {
     pub source_map: SourceMapFormat<T>,
     /// `ManuallyDrop` because in the bundler `printWithWriter` path this is a
-    /// shallow bitwise copy of `LinkerGraph.files[i].line_offset_table` (Zig
-    /// passed the unmanaged `MultiArrayList` header by value and never
-    /// `deinit`s on that path). The runtime/transpiler `printAst`/`printCommonJS`
+    /// shallow bitwise copy of `LinkerGraph.files[i].line_offset_table` and
+    /// must not be dropped here. The runtime/transpiler `printAst`/`printCommonJS`
     /// paths now defer table construction (see `lazy_line_offset_tables`), so
     /// this is left `EMPTY` there.
     pub line_offset_tables: core::mem::ManuallyDrop<line_offset_table::List<bun_alloc::AstAlloc>>,
@@ -328,7 +321,7 @@ pub struct NewBuilder<T: SourceMapFormatCtx> {
     /// `columns_for_non_ascii` payload bulk-free with the worker arena instead
     /// of needing a per-file teardown loop. Runtime/transpiler callers leave
     /// this `EMPTY` and use the `Global`-backed `lazy_line_offset_tables` below.
-    /// Mirrors the Zig transpiler, which only builds the table on demand:
+    /// Building the table only on demand means
     /// modules that emit no source mappings (asset/JSON shims, empty modules,
     /// fully-stripped files) never pay the full-source scan + `MultiArrayList`
     /// allocation. Unlike `line_offset_tables` (a `ManuallyDrop` bitwise alias
@@ -360,8 +353,7 @@ pub struct NewBuilder<T: SourceMapFormatCtx> {
     /// pointer is stable across moves of `Self`. `&'static` is a lifetime
     /// erasure of that self-borrow — threading a real `'a` would infect every
     /// `Printer<'a, …>` instantiation for a field that's only ever read in
-    /// `add_source_mapping`. Populated lazily on the first mapping (Zig caches
-    /// it eagerly in `Printer.init`, js_printer.zig:5459); reset to `&[]` when
+    /// `add_source_mapping`. Populated lazily on the first mapping; reset to `&[]` when
     /// the lazy table is generated so it re-derives against the new storage.
     pub line_offset_table_byte_offset_list: &'static [u32],
     /// Cached `byte_offset_to_first_non_ascii` column; same lifetime invariant
@@ -386,9 +378,8 @@ pub struct NewBuilder<T: SourceMapFormatCtx> {
 }
 
 impl<T: SourceMapFormatCtx + Default> Default for NewBuilder<T> {
-    /// Zig field-defaults; the Zig caller (`get_source_map_builder`) returned
-    /// `undefined` when source maps are disabled, so this only needs to be
-    /// inert (never read) — but we zero everything for sanity.
+    /// `get_source_map_builder` returns this when source maps are disabled, so
+    /// it only needs to be inert (never read) — but we zero everything for sanity.
     fn default() -> Self {
         Self {
             source_map: SourceMapFormat { ctx: T::default() },
@@ -449,7 +440,7 @@ pub type SourceMapper<T> = SourceMapFormat<T>;
 // `flush_window`, and downstream crates emit a plain `call`.
 //
 // `#[inline(never)]` is kept on the cross-crate entry points only
-// (`generate_chunk` matches Zig's `noinline`; `add_source_mapping` is the
+// (`generate_chunk`; `add_source_mapping` is the
 // per-token call site from the printer).
 //
 // `update_generated_line_and_column` is split: the `#[inline]` wrapper holds
@@ -457,10 +448,8 @@ pub type SourceMapper<T> = SourceMapFormat<T>;
 // length and return), so it folds into both callers and the per-token path
 // stays a single function with `generated_column`/`last_generated_update` in
 // registers — no `call`+`ret`, no argument/return spill per emitted token.
-// (In the Zig build LLVM folds `updateGeneratedLineAndColumn` wholesale into
-// `addSourceMapping`; as a standalone `pub fn` in Rust it was kept out of
-// line and showed up as its own profile symbol — the call overhead the Zig
-// build doesn't pay.) The rare newline/non-ASCII case tail-calls
+// (As a standalone `pub fn` it was kept out of line and showed up as its own
+// profile symbol.) The rare newline/non-ASCII case tail-calls
 // `update_generated_line_and_column_slow`, which is `#[inline(never)] #[cold]`
 // and lives once in this crate, adjacent to `flush_window`. The concrete
 // (non-generic) impl is what pins one copy per CGU.
@@ -468,8 +457,8 @@ impl NewBuilder<VLQSourceMap> {
     #[inline(never)]
     pub fn generate_chunk(&mut self, output: &[u8]) -> Chunk {
         self.update_generated_line_and_column(output);
-        // PORT NOTE: reshaped for borrowck — capture scalars before borrowing
-        // `source_map` mutably via `get_buffer`.
+        // Capture scalars before borrowing `source_map` mutably via
+        // `get_buffer`, to satisfy the borrow checker.
         if self.prepend_count {
             let count = self.source_map.get_count();
             let approx = self.approximate_input_line_count;
@@ -479,9 +468,8 @@ impl NewBuilder<VLQSourceMap> {
             buffer.list[8..16].copy_from_slice(&(count as u64).to_ne_bytes());
             buffer.list[16..24].copy_from_slice(&(approx as u64).to_ne_bytes());
         } else {
-            // Zig calls `getBuffer()` unconditionally (which finalizes the
-            // internal builder). `take_buffer()` below also finalizes, so the
-            // effect is preserved.
+            // Finalize the internal builder eagerly; `take_buffer()` below
+            // also finalizes, so the effect is preserved.
             let _ = self.source_map.get_buffer();
         }
         Chunk {
@@ -553,7 +541,7 @@ impl NewBuilder<VLQSourceMap> {
 
             match c {
                 14..=127 => {
-                    // Hot path: Zig uses unchecked `@intCast` here. `i` is bounded by
+                    // Hot path: `i` is bounded by
                     // `slice.len()` (itself a sub-slice indexed by a `u32` offset), and
                     // column deltas are bounded by that same length, so these casts
                     // cannot truncate in practice. Keep the bound check in debug only.
@@ -703,9 +691,7 @@ impl NewBuilder<VLQSourceMap> {
         // active — `line_offset_tables` (a `ManuallyDrop<MultiArrayList>`) or
         // `lazy_line_offset_tables` (built once just above) — and both are kept
         // live and un-resized for the builder's lifetime, so the slice stays
-        // valid across moves of `self`. Zig caches this in `Printer.init`
-        // (js_printer.zig:5459, "costs 1ms according to Instruments"); we
-        // lazy-init here on the first mapping to keep the fix self-contained.
+        // valid across moves of `self`. We lazy-init here on the first mapping.
         if self.line_offset_table_byte_offset_list.len() != list_len {
             let (start, first_na) = match &self.lazy_line_offset_tables {
                 Some(t) => (
@@ -720,7 +706,7 @@ impl NewBuilder<VLQSourceMap> {
             };
             // SAFETY: lifetime widened to `'static` per the invariant above —
             // the backing table outlives every `add_source_mapping` call and is
-            // never reallocated. Same shape as Zig's cached `[]const u32`.
+            // never reallocated.
             self.line_offset_table_byte_offset_list =
                 unsafe { core::slice::from_raw_parts(start.as_ptr(), start.len()) };
             // SAFETY: same invariant as above — backing table outlives every
@@ -797,5 +783,3 @@ impl NewBuilder<VLQSourceMap> {
 }
 
 pub type Builder = NewBuilder<VLQSourceMap>;
-
-// ported from: src/sourcemap/Chunk.zig
diff --git a/src/sourcemap/InternalSourceMap.rs b/src/sourcemap/InternalSourceMap.rs
index 71187b392f8..9e2463dbc9e 100644
--- a/src/sourcemap/InternalSourceMap.rs
+++ b/src/sourcemap/InternalSourceMap.rs
@@ -184,9 +184,10 @@ impl InternalSourceMap {
     }
 
     #[inline]
-    pub fn stream(self) -> &'static [u8] {
-        // TODO(port): lifetime — this borrows the blob for as long as `self.data`
-        // is valid; callers in this file only use the slice while `self` is live.
+    pub fn stream(&self) -> &[u8] {
+        // The slice borrows `self` (a Copy view over the blob); the blob
+        // outlives every view by construction, so tying the slice to the view
+        // borrow is conservative.
         // SAFETY: stream_offset..total_len is within the blob (validated by
         // is_valid_blob / producer).
         unsafe {
@@ -200,9 +201,9 @@ impl InternalSourceMap {
     /// Only call this when the blob was heap-allocated by `Builder`/`from_vlq` (e.g.
     /// entries in `SavedSourceMap`). Do NOT call on views over the standalone
     /// module graph section or any other borrowed memory.
-    // TODO(port): conditional ownership — intentionally NOT `impl Drop` because
-    // `InternalSourceMap` is a Copy view and may borrow non-owned memory. Could
-    // split into an owning newtype with `impl Drop`.
+    // Intentionally NOT `impl Drop`: `InternalSourceMap` is a Copy view and
+    // may borrow non-owned memory (e.g. the standalone module graph section),
+    // so ownership is the caller's responsibility here.
     pub fn free_owned(self) {
         // SAFETY: caller guarantees the blob was produced by Builder/from_vlq via
         // the global allocator with this exact length.
@@ -221,8 +222,7 @@ impl InternalSourceMap {
     /// Sanity-check a blob's outer header against its actual length. See the
     /// module-level [`is_valid_blob`] for details.
     ///
-    /// Associated-fn alias so callers can write `InternalSourceMap::is_valid_blob(..)`
-    /// (Zig: `pub fn isValidBlob` is a decl on the file-struct `@This()`).
+    /// Associated-fn alias so callers can write `InternalSourceMap::is_valid_blob(..)`.
     #[inline]
     pub fn is_valid_blob(blob: &[u8]) -> bool {
         is_valid_blob(blob)
@@ -231,8 +231,7 @@ impl InternalSourceMap {
     /// Decode a standard VLQ "mappings" string and re-encode it as an
     /// `InternalSourceMap` blob. See the module-level [`from_vlq`] for details.
     ///
-    /// Associated-fn alias so callers can write `InternalSourceMap::from_vlq(..)`
-    /// (Zig: `pub fn fromVLQ` is a decl on the file-struct `@This()`).
+    /// Associated-fn alias so callers can write `InternalSourceMap::from_vlq(..)`.
     #[inline]
     pub fn from_vlq(vlq: &[u8], input_line_count_hint: u32) -> Result<Box<[u8]>, FromVlqError> {
         from_vlq(vlq, input_line_count_hint)
@@ -316,13 +315,12 @@ const MAX_VARINT_LEN: usize = 5;
 
 // PERF: force-inline so the per-delta loops in `flush_window` see the 1-byte
 // fast path branchlessly and LLVM can hoist the `buf_ptr.add(w)` arithmetic.
-// Zig leaves this to LLVM (single-CGU); Rust needs the hint across CGUs.
+// The hint is needed for inlining across CGUs.
 #[inline(always)]
 fn write_varint(buf: *mut u8, signed: i32) -> usize {
     let mut v = zigzag_encode(signed);
     let mut i: usize = 0;
     loop {
-        // PERF(port): @intCast — masked to 7 bits, provably in-range
         let mut byte: u8 = (v & 0x7f) as u8;
         v >>= 7;
         if v != 0 {
@@ -389,8 +387,10 @@ mod win_hdr {
 
 /// Parses a window header and steps through its deltas in order. Exception
 /// streams are consumed in order, so a reader is forward-only.
-// TODO(port): lifetime — `bytes`/`base`/`src_idx_mask` borrow the blob; kept as
-// raw pointers to avoid struct lifetime params.
+// Invariant: `bytes`/`base`/`src_idx_mask` point into the blob and are only
+// valid while the blob is live. They are raw pointers (not lifetimes) because
+// readers are stored in lifetime-less caches (`FindCacheSlot`, `Cursor`) that
+// follow `InternalSourceMap`'s Copy-view design.
 #[derive(Copy, Clone)]
 struct WindowReader {
     bytes: *const [u8],
@@ -425,7 +425,7 @@ impl WindowReader {
 
     #[inline]
     fn bytes<'a>(&self) -> &'a [u8] {
-        // PORT NOTE: returns an unbound lifetime so callers can mutate other
+        // returns an unbound lifetime so callers can mutate other
         // `self` fields while holding the slice — `self.bytes` is a raw `*const [u8]`
         // pointing into the blob, not into `self`, so this is sound.
         // SAFETY: `bytes` was set from `InternalSourceMap.stream()` which is
@@ -586,7 +586,6 @@ impl Default for FindCacheSlot {
             data: ptr::null(),
             sync_idx: 0,
             decoded_count: 0,
-            // PERF(port): was `undefined` init — profile if hot.
             reader: WindowReader::DANGLING,
             decoded: [State::default(); SYNC_INTERVAL],
         }
@@ -764,7 +763,6 @@ impl InternalSourceMap {
         let sync_idx = self.locate_window(target_line, target_col)?;
 
         let mut state = State::default();
-        // PERF(port): was `undefined` init — profile if hot.
         let mut reader = WindowReader::DANGLING;
         self.seed_window(sync_idx, &mut state, &mut reader);
 
@@ -807,7 +805,6 @@ impl Cursor {
             map,
             state: State::default(),
             peek: None,
-            // PERF(port): was `undefined` init — profile if hot.
             reader: WindowReader::DANGLING,
             sync_idx: 0,
             has_state: false,
@@ -892,7 +889,6 @@ impl InternalSourceMap {
         let mut idx: u32 = 0;
         while idx < n_sync {
             let mut state = State::default();
-            // PERF(port): was `undefined` init — profile if hot.
             let mut reader = WindowReader::DANGLING;
             self.seed_window(idx, &mut state, &mut reader);
             emit_vlq(&state, &mut prev, &mut generated_line, out);
@@ -932,8 +928,8 @@ fn emit_vlq(
 // (`generated_line`, `pending_generated_line_delta`, `count`, `pending_n` —
 // 13 bytes) lands at offset 0 in the head cache line, with `sync_entries`'
 // NonNull ptr (the `Option<Builder>` niche) immediately after in the *same*
-// line. The inlined `VLQSourceMap::append`/`append_line_separator` (Chunk.zig
-// 103/107 are `pub inline fn`) thus touch one line on the fast path instead of
+// line. The inlined `VLQSourceMap::append`/`append_line_separator`
+// thus touch one line on the fast path instead of
 // straddling the five 256-byte `pending_*` lanes. (benches: lint/create-vue)
 //
 // The pending window is stored column-wise — five parallel `[i32; SYNC_INTERVAL]`
@@ -1003,7 +999,7 @@ impl Builder {
         // SAFETY: invariant `pending_n < SYNC_INTERVAL` between flushes — the
         // tail of this fn flushes (resetting to 0) the moment it would reach
         // SYNC_INTERVAL, so on entry `pending_n <= SYNC_INTERVAL-1`. Elides the
-        // per-mapping bounds check (Zig stores into `self.pending[n]` unchecked).
+        // per-mapping bounds check.
         unsafe {
             *self.pending_generated_line.get_unchecked_mut(i) = generated_line;
             *self.pending_generated_column.get_unchecked_mut(i) = current.generated_column;
@@ -1032,7 +1028,7 @@ impl Builder {
         let src_idx = &self.pending_source_index[..nn];
         let orig_line = &self.pending_original_line[..nn];
         let orig_col = &self.pending_original_column[..nn];
-        // PERF(port): @intCast — win_stream is bounded by total mapping count × ~5B/mapping;
+        // win_stream is bounded by total mapping count × ~5B/mapping;
         // u32 overflow would mean a >4 GiB sourcemap stream, unreachable in practice.
         debug_assert!(self.win_stream.len() <= u32::MAX as usize);
         let start_off: u32 = self.win_stream.len() as u32;
@@ -1183,7 +1179,7 @@ impl Builder {
         } else {
             0
         };
-        // PERF(port): @intCast — n_deltas <= 63, MAX_VARINT_LEN == 5, so each
+        // n_deltas <= 63, MAX_VARINT_LEN == 5, so each
         // length field is <= 315 bytes < u16::MAX. Drop the panic edge so the hot
         // window-emit path has no unwind landing pads.
         debug_assert!(gen_col_len <= u16::MAX as usize);
@@ -1235,8 +1231,6 @@ impl Builder {
     /// count, input line count) so this path flows through the existing
     /// `Chunk.buffer` plumbing unchanged.
     pub fn finalize(&mut self) -> &mut MutableString {
-        // PORT NOTE: reshaped for borrowck — Zig early-returns `&self.finalized.?`
-        // before populating; we check first then fall through to the trailing borrow.
         if self.finalized.is_none() {
             self.flush_window();
 
@@ -1245,7 +1239,6 @@ impl Builder {
             let total: usize = stream_offset as usize + self.win_stream.len() + STREAM_TAIL_PAD;
 
             let mut out = MutableString::init_empty();
-            // Zig: `out.list.resize(allocator, total)` leaves new bytes undefined.
             // Every byte in [0..total) is written below: [0..24] zero-filled,
             // [24..32] header u32s, [32..32+sync_bytes] sync table memcpy,
             // [stream_offset..stream_offset+win_stream.len()] stream memcpy,
@@ -1282,7 +1275,7 @@ impl Builder {
         self.finalized.as_mut().unwrap()
     }
 
-    /// Move the finalized buffer out (Zig: `b.finalize().*` then `b.finalized = null`).
+    /// Move the finalized buffer out.
     pub fn finalize_take(&mut self) -> MutableString {
         let _ = self.finalize();
         self.finalized.take().unwrap()
@@ -1398,7 +1391,7 @@ pub fn from_vlq(vlq: &[u8], input_line_count_hint: u32) -> Result<Box<[u8]>, Fro
         });
     }
 
-    // PORT NOTE: reshaped for borrowck — capture `builder.count` before borrowing
+    // reshaped for borrowck — capture `builder.count` before borrowing
     // `builder.finalized` mutably.
     let mapping_count: u64 = builder.count as u64;
     let out = builder.finalize();
@@ -1414,8 +1407,3 @@ pub fn from_vlq(vlq: &[u8], input_line_count_hint: u32) -> Result<Box<[u8]>, Fro
     builder.finalized = None;
     Ok(owned)
 }
-
-// `pub const TestingAPIs = @import("../sourcemap_jsc/internal_jsc.zig").TestingAPIs;`
-// deleted — *_jsc alias; extension-trait lives in bun_sourcemap_jsc.
-
-// ported from: src/sourcemap/InternalSourceMap.zig
diff --git a/src/sourcemap/LineOffsetTable.rs b/src/sourcemap/LineOffsetTable.rs
index 23bb22d26e1..6558fbb1c44 100644
--- a/src/sourcemap/LineOffsetTable.rs
+++ b/src/sourcemap/LineOffsetTable.rs
@@ -40,7 +40,7 @@ pub type List<A = Global> = MultiArrayList<LineOffsetTable<A>, A>;
 
 /// Typed SoA column accessors on [`List`] (= `MultiArrayList<LineOffsetTable>`).
 ///
-/// Mirrors Zig `list.items(.byte_offset_to_start_of_line)`. Can't be an
+/// Can't be an
 /// inherent impl (orphan rules — `MultiArrayList` lives in `bun_collections`),
 /// so it's an extension trait; same pattern as `mapping::MappingColumns`.
 pub trait LineOffsetTableColumns {
@@ -93,9 +93,6 @@ impl LineOffsetTable {
     /// (≈90-120M cycles) doing a fresh bounds-checked binary search every
     /// call; this short-circuits to a couple of compares for the common case
     /// and falls back to the binary search otherwise.
-    ///
-    /// Zig spec (`LineOffsetTable.zig:20`) only has the binary search; this is
-    /// a deliberate divergence — strictly cheaper, identical result.
     #[inline]
     pub fn find_line_with_hint(offsets: &[u32], loc: Loc, hint: u32) -> i32 {
         debug_assert!(loc.start > -1);
@@ -157,9 +154,8 @@ impl LineOffsetTable {
         Self::generate_in::<Global>(contents, approximate_line_count)
     }
 
-    // PORT NOTE: Zig threaded `std.mem.Allocator` through MultiArrayList/Vec.
-    // Callers in Zig pass mixed allocators (printer/bundler arenas vs VM default
-    // allocator in CodeCoverage.zig); the bundler routes `A = AstAlloc` so the
+    // Callers pass mixed allocators (printer/bundler arenas vs VM default
+    // allocator in code coverage): the bundler routes `A = AstAlloc` so the
     // table bulk-frees with the per-worker AST heap, everyone else uses
     // [`generate`] (`A = Global`).
     pub fn generate_in<A: Allocator + Copy + Default + 'static>(
@@ -179,25 +175,22 @@ impl LineOffsetTable {
         // the idea here is:
         // we want to avoid re-allocating this array _most_ of the time
         // when lines _do_ have unicode characters, they probably still won't be longer than 255 much
-        // PERF(port): Zig used `std.heap.stackFallback(@sizeOf(i32)*256)` — a 256-slot stack
-        // buffer with heap spill. The direct Rust equivalent is `SmallVec<[i32; 256]>`: inline
-        // storage stays on-stack, `into_vec()` at hand-over does the same "dupe if stack-owned,
-        // move if spilled" branch Zig does, and `mem::take` resets to a fresh inline buffer
+        // PERF: `SmallVec<[i32; 256]>` is a 256-slot stack buffer with heap spill: inline
+        // storage stays on-stack, `into_vec()` at hand-over dupes if stack-owned and
+        // moves if spilled, and `mem::take` resets to a fresh inline buffer
         // (zero alloc). Previously this was a heap `Vec::with_capacity(120)` re-primed via
         // `mem::replace` per non-ASCII line, which showed up as one mi_malloc(480) per such
-        // line under `generate` (2× self-time vs Zig on lint/create-vite).
+        // line under `generate` (lint/create-vite).
         let mut columns_for_non_ascii: SmallVec<[i32; 256]> = SmallVec::new();
 
-        // Hoist the base pointer so per-iteration offset math is a single sub + truncate,
-        // matching Zig's `@truncate(@intFromPtr(remaining.ptr) - @intFromPtr(contents.ptr))`.
+        // Hoist the base pointer so per-iteration offset math is a single sub + truncate.
         let base = contents.as_ptr() as usize;
 
         let mut remaining = contents;
         while !remaining.is_empty() {
             let b0 = remaining[0];
             let len_ = strings::wtf8_byte_sequence_length_with_invalid(b0);
-            // Zig passes `remaining.ptr[0..4]` (unchecked 4-byte view) to decodeWTF8RuneT,
-            // which only reads `len_` bytes. After the SIMD skip below lands, the loop head
+            // After the SIMD skip below lands, the loop head
             // is overwhelmingly an ASCII '\r'/'\n' or a non-ASCII lead byte, so keep the
             // 1-byte path branch-only and confine the zero+min+copy pad to the cold
             // multibyte arm.
@@ -265,8 +258,7 @@ impl LineOffsetTable {
                         continue;
                     }
 
-                    // Zig used a stack-fallback allocator and duped onto `allocator` only when
-                    // stack-owned, then reset the fixed buffer. The SmallVec scratch reuses its
+                    // The SmallVec scratch reuses its
                     // inline storage across lines; copy out into an `A`-backed box only when a
                     // line had non-ASCII bytes. ASCII-only lines (almost all of them) store an
                     // empty dangling box and leave the scratch untouched.
@@ -337,5 +329,3 @@ impl LineOffsetTable {
         Ok(list)
     }
 }
-
-// ported from: src/sourcemap/LineOffsetTable.zig
diff --git a/src/sourcemap/Mapping.rs b/src/sourcemap/Mapping.rs
index 77fdb83c60d..42c4e75c6e5 100644
--- a/src/sourcemap/Mapping.rs
+++ b/src/sourcemap/Mapping.rs
@@ -99,8 +99,7 @@ impl Default for ListValue {
     }
 }
 
-/// Dispatch a single body over both `ListValue` arms — Rust's spelling of Zig's
-/// `switch (this.impl) { inline else => |*list| ... }`. `$body` is duplicated
+/// Dispatch a single body over both `ListValue` arms. `$body` is duplicated
 /// textually so each arm monomorphizes over its own `MultiArrayList<T>`; the
 /// arms therefore need NOT have a common element type, only a common `$body`
 /// result type. Match-ergonomics governs the borrow: pass `&v` / `&mut v` and
@@ -141,8 +140,9 @@ impl List {
             return Ok(());
         }
 
-        // PORT NOTE: reshaped for borrowck — move the without_names list out, build the
-        // with_names list, then assign back. The old list drops at end of scope.
+        // Move the without_names list out, build the with_names list, then
+        // assign back (satisfies the borrow checker). The old list drops at
+        // end of scope.
         let ListValue::WithoutNames(without_names) = core::mem::replace(
             &mut self.r#impl,
             ListValue::WithNames(MultiArrayList::default()),
@@ -154,9 +154,9 @@ impl List {
         with_names.ensure_total_capacity(without_names.len())?;
         // `without_names` drops at end of scope (was `defer without_names.deinit(allocator)`).
 
-        // PORT NOTE: Zig set_len + per-column memcpy. Rust MultiArrayList has no
+        // MultiArrayList has no
         // public `set_len`; rebuild element-wise (capacity already reserved, so no
-        // realloc). PERF(port): revisit once typed mut-column accessors exist.
+        // realloc). PERF: revisit once typed mut-column accessors exist.
         for i in 0..without_names.len() {
             with_names.append_assume_capacity(without_names.get(i).to_named());
         }
@@ -362,10 +362,8 @@ impl Lookup {
         }
 
         if bun_paths::is_absolute(base_filename) {
-            // PORT NOTE: Zig passed runtime `.auto` Platform; bun_paths exposes
-            // const-generic `PlatformT` only. `platform::Auto` is a cfg-selected
-            // type alias (Posix on unix, Windows on windows), which is what
-            // `.auto` resolved to at comptime anyway.
+            // `platform::Auto` is a cfg-selected
+            // type alias (Posix on unix, Windows on windows).
             let dir = bun_paths::resolve_path::dirname::<bun_paths::platform::Auto>(base_filename);
             return Some(bun_core::String::clone_utf8(
                 bun_paths::resolve_path::join_abs::<bun_paths::platform::Auto>(dir, name),
@@ -427,9 +425,8 @@ impl Lookup {
             let name: &[u8] = &source_map.external_source_names[index];
 
             let mut buf = bun_paths::PathBuffer::uninit();
-            // PORT NOTE: Zig passed runtime `.auto` / `.loose`; bun_paths
-            // exposes const-generic `PlatformT` ZSTs. `platform::Auto` is
-            // cfg-selected (Posix on unix, Windows on windows) — same result.
+            // `platform::Auto` is
+            // cfg-selected (Posix on unix, Windows on windows).
             let dir = bun_paths::resolve_path::dirname::<bun_paths::platform::Auto>(base_filename);
             let normalized = bun_paths::resolve_path::join_abs_string_buf_z::<
                 bun_paths::platform::Loose,
@@ -745,5 +742,3 @@ pub fn parse(
     psm.input_line_count = input_line_count;
     ParseResult::Success(psm)
 }
-
-// ported from: src/sourcemap/Mapping.zig
diff --git a/src/sourcemap/ParsedSourceMap.rs b/src/sourcemap/ParsedSourceMap.rs
index 5ae7c9b6b29..a964735a206 100644
--- a/src/sourcemap/ParsedSourceMap.rs
+++ b/src/sourcemap/ParsedSourceMap.rs
@@ -47,7 +47,7 @@ pub struct ParsedSourceMap {
 
 impl Drop for ParsedSourceMap {
     fn drop(&mut self) {
-        // Spec ParsedSourceMap.zig:105 `deinit`: when the mappings are backed
+        // When the mappings are backed
         // by an `InternalSourceMap` blob the blob is *owned* (allocated by
         // `SavedSourceMap::put_mappings`) unless this is the
         // standalone-module-graph case where the bytes live in the embedded
@@ -79,7 +79,7 @@ impl Default for ParsedSourceMap {
     }
 }
 
-#[repr(u8)] // Zig: enum(u2) — Rust has no u2; packed into SourceContentPtr by shift below
+#[repr(u8)] // packed into 2 bits of SourceContentPtr by shift below
 #[derive(Copy, Clone, Eq, PartialEq)]
 enum SourceProviderKind {
     Zig = 0,
@@ -131,8 +131,7 @@ impl AnySourceProvider {
     }
 }
 
-/// Zig: `packed struct(u64) { load_hint: SourceMapLoadHint, kind: SourceProviderKind, data: u60 }`
-/// Field order is low-bit-first: bits 0..2 = load_hint, bits 2..4 = kind, bits 4..64 = data.
+/// Bit-packed, low-bit-first: bits 0..2 = load_hint, bits 2..4 = kind, bits 4..64 = data.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct SourceContentPtr(u64);
@@ -218,8 +217,8 @@ impl SourceContentPtr {
     }
 
     pub fn provider(self) -> Option<AnySourceProvider> {
-        // Zig returns `?AnySourceProvider` but every match arm yields a value; the
-        // optionality is implicit (data == 0 ⇒ null pointer). Preserve that here.
+        // Every match arm yields a value; the
+        // optionality is implicit (data == 0 ⇒ null pointer).
         let data = self.data() as usize;
         match self.kind() {
             SourceProviderKind::Zig => Some(AnySourceProvider::Zig(data as *mut SourceProviderMap)),
@@ -234,18 +233,17 @@ impl SourceContentPtr {
 }
 
 impl ParsedSourceMap {
-    /// Thread-safe ref-count helpers (Zig: `ThreadSafeRefCount.ref/deref`).
+    /// Thread-safe ref-count helpers.
     ///
-    /// PORT NOTE: Zig uses an *intrusive* count (`bun.new` + embedded
-    /// `ref_count`, freed via `bun.destroy`). The Rust port allocates every
-    /// table-stored `ParsedSourceMap` via `Arc::into_raw` (see
+    /// Every
+    /// table-stored `ParsedSourceMap` is allocated via `Arc::into_raw` (see
     /// `SavedSourceMap::get_with_content` and `ParseUrl.map:
     /// Option<Arc<ParsedSourceMap>>`), so the strong count lives in the `Arc`
     /// header *before* the data pointer. Reconstituting that pointer with
     /// `heap::take` would free an interior offset and trips
     /// `mi_validate_block_from_ptr` (mimalloc free.c:123). Route through
     /// `Arc::{increment,decrement}_strong_count` instead — same observable
-    /// `ref()`/`deref()` semantics as the Zig spec, with the allocator that
+    /// `ref()`/`deref()` semantics, with the allocator that
     /// actually owns the bytes. The embedded `ref_count` field is kept for
     /// layout/ABI parity but is NOT the live counter.
     ///
@@ -275,9 +273,6 @@ impl ParsedSourceMap {
     /// `mapping::List`. Ownership of the blob transfers to the returned value
     /// (freed in `Drop`) unless the caller subsequently sets
     /// [`Self::is_standalone_module_graph`].
-    ///
-    /// Mirrors Zig `SourceMap.ParsedSourceMap{ .internal = ism, .input_line_count
-    /// = ism.inputLineCount() }` struct-init at the standalone-graph load site.
     pub fn from_internal(internal: InternalSourceMap) -> Self {
         Self {
             ref_count: AtomicU32::new(1),
@@ -375,15 +370,6 @@ impl ParsedSourceMap {
     }
 }
 
-// PORT NOTE: Zig `deinit` conditionally skipped freeing `internal` when
-// `is_standalone_module_graph` (the blob borrows bytes from the standalone
-// module graph section). The current `InternalSourceMap` stub has no Drop, so
-// the conditional is a no-op. When `InternalSourceMap.rs` is un-gated, retype
-// the field to `Option<core::mem::ManuallyDrop<InternalSourceMap>>` and drop
-// it explicitly only when `!is_standalone_module_graph` — do NOT use
-// `mem::forget` (PORTING.md §Forbidden).
-// `mappings` and `external_source_names` are dropped automatically.
-
 pub struct VlqsFmt<'a>(&'a ParsedSourceMap);
 
 impl<'a> fmt::Display for VlqsFmt<'a> {
@@ -392,5 +378,3 @@ impl<'a> fmt::Display for VlqsFmt<'a> {
         self.0.write_vlqs(&mut adapter).map_err(|_| fmt::Error)
     }
 }
-
-// ported from: src/sourcemap/ParsedSourceMap.zig
diff --git a/src/sourcemap/lib.rs b/src/sourcemap/lib.rs
index 0523119adfc..2d58dd7c90b 100644
--- a/src/sourcemap/lib.rs
+++ b/src/sourcemap/lib.rs
@@ -29,9 +29,8 @@ pub use line_offset_table::{LineOffsetTable, LineOffsetTableColumns};
 pub use mapping::{Lookup as MappingLookup, Mapping};
 pub use parsed_source_map::{ParsedSourceMap, SourceContentPtr};
 
-// SAFETY: `ParsedSourceMap` was `bun.ptr.ThreadSafeRefCount` in the Zig
-// original and is shared across threads via the thread-safe `SavedSourceMap`
-// store (its `ref_count` is an `AtomicU32`). The auto-trait inference fails
+// SAFETY: `ParsedSourceMap` is shared across threads via the thread-safe
+// `SavedSourceMap` store (its `ref_count` is an `AtomicU32`). The auto-trait inference fails
 // only because `SourceContentPtr` packs raw provider pointers; those are
 // opaque handles that are never dereferenced off the JS thread.
 unsafe impl Send for ParsedSourceMap {}
@@ -51,7 +50,6 @@ pub use internal_source_map::InternalSourceMap;
 // only ever sees it as a pointer.
 bun_opaque::opaque_ffi! { pub struct BakeSourceProvider; }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // C++ accessor is read-only (`provider->source()`). Taking `*const` avoids
     // casting away const from the `&self` borrow below; any interior mutation
@@ -62,14 +60,13 @@ unsafe extern "C" {
 
 unsafe extern "Rust" {
     /// Link-time-resolved by `bun_runtime::jsc_hooks` (same pattern as
-    /// `__BUN_RUNTIME_HOOKS`). Spec sourcemap_jsc/source_provider.zig:20
-    /// `BakeSourceProvider.getExternalData` — looks up the bundled `.map`
+    /// `__BUN_RUNTIME_HOOKS`). Looks up the bundled `.map`
     /// JSON for `source_filename` via the live `Bake::GlobalObject`'s
     /// `PerThread.source_maps`. Returns `None` if not running under Bake
     /// (caller falls back to disk read), or `Some("")` if the table has no
     /// entry. The slice borrows `PerThread.bundled_outputs` (lives for the
     /// bake build session, which outlives any error-stack source-map
-    /// resolution). Zig had no crate split here.
+    /// resolution).
     static __BUN_BAKE_EXTERNAL_SOURCEMAP: fn(source_filename: &[u8]) -> Option<*const [u8]>;
 }
 
@@ -114,8 +111,7 @@ impl BakeSourceProvider {
     }
 }
 
-// PORT NOTE: Zig dispatched via `comptime SourceProviderKind: type` + `@hasDecl`;
-// Rust uses a trait per PORTING.md §Dispatch.
+// Dispatch via a trait per PORTING.md §Dispatch.
 impl SourceProvider for BakeSourceProvider {
     const HAS_EXTERNAL_DATA: bool = true;
 
@@ -148,7 +144,7 @@ pub struct SourceMapState {
     pub original_column: i32,
 }
 
-/// Top-level `SourceMap` struct (was `@This()` in Zig).
+/// Top-level `SourceMap` struct.
 #[derive(Default)]
 pub struct SourceMap {
     pub sources: Vec<Box<[u8]>>,
@@ -233,7 +229,7 @@ pub struct LineColumnOffset {
     pub columns: Ordinal,
 }
 
-// Spec sourcemap.zig:548 — Zig field defaults are `.start`, not `.invalid`
+// Field defaults are `START`, not invalid
 // (bun_core::Ordinal::default() is INVALID, so derive(Default) would be wrong).
 impl Default for LineColumnOffset {
     #[inline]
@@ -423,7 +419,6 @@ pub(crate) fn append_mapping_to_buffer(
         writable = &mut writable[1..];
     }
 
-    // PERF(port): was `inline for` — plain loop relies on LLVM unroll
     for item in &vlqs {
         let n = item.len as usize;
         writable[..n].copy_from_slice(item.slice());
@@ -451,7 +446,6 @@ impl core::fmt::Display for DebugIDFormatter {
 // This is used for files that were pre-bundled with `bun build --target=bun --sourcemap`
 bun_opaque::opaque_ffi! { pub struct SourceProviderMap; }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // `SourceProviderMap` is an UnsafeCell-backed opaque ZST (Rust holds zero
     // bytes of it), so `&SourceProviderMap` carries no `readonly`/`noalias` —
@@ -497,7 +491,6 @@ pub struct DevServerSourceMapData {
     pub length: usize,
 }
 
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // Both C++ accessors are read-only (`provider->source()` /
     // `provider->sourceMapJSON()`). Taking `*const` avoids casting away
@@ -561,8 +554,7 @@ impl SourceProvider for DevServerSourceProvider {
 // ── SourceProvider trait + get_source_map_impl ─────────────────────────────
 
 /// Abstraction over `SourceProviderMap` / `DevServerSourceProvider` /
-/// `BakeSourceProvider` — Zig used `comptime SourceProviderKind: type` plus
-/// `@hasDecl` checks; in Rust this is a trait with default-`None` optional
+/// `BakeSourceProvider` — a trait with default-`None` optional
 /// methods so each provider only overrides what it actually has.
 pub trait SourceProvider {
     fn get_source_slice(&self) -> bun_core::String;
@@ -580,9 +572,9 @@ pub trait SourceProvider {
         None
     }
 
-    /// Mirrors Zig `comptime SourceProviderKind == DevServerSourceProvider`.
+    /// `true` only for `DevServerSourceProvider`.
     const IS_DEV_SERVER: bool = false;
-    /// Mirrors `@hasDecl(SourceProviderKind, "getExternalData")`.
+    /// `true` only for providers that implement `get_external_data`.
     const HAS_EXTERNAL_DATA: bool = false;
 }
 
@@ -600,7 +592,6 @@ pub fn get_source_map_impl<P: SourceProvider + ?Sized>(
     //
     // TODO: Experiment in debug builds calculating how much stack space we have left and using that to
     //       adjust the size
-    // PERF(port): was stack-fallback (1024) + ArenaAllocator
     let arena = bun_alloc::Arena::new();
 
     let (new_load_hint, mut parsed): (SourceMapLoadHint, ParseUrl) = 'parsed: {
@@ -697,7 +688,7 @@ pub fn get_source_map_impl<P: SourceProvider + ?Sized>(
                 }
 
                 let mut load_path_buf = bun_paths::path_buffer_pool::get();
-                // Zig wrote `+ 4` but we also need a trailing NUL for the
+                // `+ 4` for ".map" plus a trailing NUL for the
                 // `&ZStr` open path; reserve `+ 5`.
                 if source_filename.len() + 5 > load_path_buf.len() {
                     break 'try_external;
@@ -710,10 +701,8 @@ pub fn get_source_map_impl<P: SourceProvider + ?Sized>(
                 let load_path =
                     bun_core::ZStr::from_buf(&load_path_buf[..], source_filename.len() + 4);
 
-                // PORT NOTE: Zig passed the arena allocator; the Rust
-                // `bun_sys::File::read_from` returns an owned `Vec<u8>`. The
-                // arena was only used to free the bytes on scope exit, which
-                // `Vec` Drop already does.
+                // `bun_sys::File::read_from` returns an owned `Vec<u8>`,
+                // freed on scope exit by `Vec`'s Drop.
                 let data = match bun_sys::File::read_from(bun_core::Fd::cwd(), load_path) {
                     Ok(data) => data,
                     Err(_) => break 'try_external,
@@ -753,7 +742,6 @@ pub fn get_source_map_impl<P: SourceProvider + ?Sized>(
         return None;
     };
     if let Some(ptr) = parsed.map.as_mut() {
-        // PORT NOTE: Zig mutates `ptr.underlying_provider` after `bun.new`.
         // The Arc is freshly created in `parse_json` and we hold the only ref
         // here, so `Arc::get_mut` succeeds. (PORTING.md §Pointers — no raw
         // *mut cast through Arc::as_ptr.)
@@ -809,8 +797,8 @@ pub mod SavedSourceMap {
 // retrieval. Moved down from `bun_standalone_graph` so `ParsedSourceMap` can
 // name `Loaded` without an upward dep.
 //
-// Zig nests `Header` / `Loaded` inside the struct; Rust models that namespace
-// as a module so `crate::SerializedSourceMap::Loaded` resolves as a path.
+// `Header` / `Loaded` are namespaced
+// in a module so `crate::SerializedSourceMap::Loaded` resolves as a path.
 #[allow(non_snake_case)]
 pub mod SerializedSourceMap {
     use bun_core::StringPointer;
@@ -838,7 +826,7 @@ pub mod SerializedSourceMap {
     impl SerializedSourceMap {
         #[inline]
         pub(crate) fn header(self) -> Header {
-            // Zig: `*align(1) const Header` — read_unaligned because the blob
+            // read_unaligned because the blob
             // sits at an arbitrary offset inside the executable.
             // SAFETY: callers guarantee `bytes.len() >= size_of::<Header>()`.
             unsafe { core::ptr::read_unaligned(self.bytes.as_ptr().cast::<Header>()) }
@@ -873,9 +861,8 @@ pub mod SerializedSourceMap {
 
     impl Loaded {
         pub(crate) fn source_file_contents(&mut self, index: usize) -> Option<&[u8]> {
-            // PORT NOTE: reshaped for borrowck — Zig checked the cache, then
-            // wrote and re-read in the same scope. Here we populate first if
-            // empty, then take a single borrow at the end.
+            // Populate first if
+            // empty, then take a single borrow at the end (borrowck-friendly).
             if self.decompressed_files[index].is_none() {
                 let sp = self.map.compressed_source_file_at(index);
                 let compressed_file = sp.slice(self.map.bytes);
@@ -939,7 +926,6 @@ impl SourceMapPieces {
         // the joiner's node allocator contains string join nodes as well as some vlq encodings
         // it doesnt contain json payloads or source code, so 16kb is probably going to cover
         // most applications.
-        // PERF(port): was stack-fallback (16384)
         let mut j = bun_core::string_joiner::StringJoiner::default();
 
         j.push_static(&self.prefix);
@@ -1028,13 +1014,12 @@ pub fn parse_url(
     source: &[u8],
     hint: ParseUrlResultHint,
 ) -> Result<ParseUrl, bun_core::Error> {
-    // TODO(port): narrow error set
     let json_bytes: &[u8] = 'json_bytes: {
         const DATA_PREFIX: &[u8] = b"data:application/json";
 
         'try_data_url: {
             if source.starts_with(DATA_PREFIX) && source.len() > DATA_PREFIX.len() + 1 {
-                // PORT NOTE: `scoped_log!(SourceMap, ...)` dropped — `SourceMap`
+                // `scoped_log!(SourceMap, ...)` dropped — `SourceMap`
                 // names the top-level struct in this module; the debug scope
                 // lives in `mapping::SourceMap` and `scoped_log!` only takes a
                 // bare ident. Debug-only log; revisit if scopes become path-able.
@@ -1084,7 +1069,6 @@ pub fn parse_json(
     use bun_ast::StoreResetGuard as DataStoreScope;
     use std::sync::Arc;
 
-    // TODO(port): narrow error set
     let json_src = bun_ast::Source::init_path_string("sourcemap.json", source);
     let mut log = bun_ast::Log::init();
     // `defer log.deinit()` → Drop
@@ -1140,8 +1124,7 @@ pub fn parse_json(
 
     let source_only = matches!(hint, ParseUrlResultHint::SourceOnly(_));
 
-    // PORT NOTE: reshaped for borrowck — Zig used a counted index `i` with
-    // errdefer freeing the prefix; Rust `Vec<Box<[u8]>>` drops automatically.
+    // `Vec<Box<[u8]>>` drops automatically on error.
     let source_paths_slice: Option<Vec<Box<[u8]>>> = if !source_only {
         let mut v: Vec<Box<[u8]>> = Vec::with_capacity(sources_content.items.len_u32() as usize);
         for item in sources_paths.items.slice() {
@@ -1196,7 +1179,6 @@ pub fn parse_json(
 
                             let str = estr.string(arena)?;
 
-                            // PERF(port): was assume_capacity
                             names_list.push(bun_semver::String::init_append_if_needed(
                                 &mut names_buffer,
                                 str,
@@ -1212,8 +1194,10 @@ pub fn parse_json(
 
         let mut psm = map_data;
         psm.external_source_names = source_paths_slice.unwrap();
-        // TODO(port): ParsedSourceMap was ThreadSafeRefCount in Zig; ported as `Arc`.
-        // Confirm whether an intrusive Arc is required for FFI.
+        // ParsedSourceMap is `Arc`-managed in the Rust port; the embedded
+        // `ref_count` field is layout parity only and FFI ref/deref routes
+        // through `Arc::{increment,decrement}_strong_count` (see
+        // `ParsedSourceMap::ref_`).
         Some(Arc::new(psm))
     } else {
         None
@@ -1278,7 +1262,6 @@ pub fn append_source_map_chunk<'a>(
     start_state_: SourceMapState,
     source_map_: &'a [u8],
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     let mut prev_end_state = prev_end_state_;
     let mut start_state = start_state_;
     // Handle line breaks in between this mapping and the previous one
diff --git a/src/sourcemap_jsc/CodeCoverage.rs b/src/sourcemap_jsc/CodeCoverage.rs
index ee18a3292c0..4211602d374 100644
--- a/src/sourcemap_jsc/CodeCoverage.rs
+++ b/src/sourcemap_jsc/CodeCoverage.rs
@@ -114,15 +114,14 @@ impl Report {
     }
 }
 
-// Report::deinit only freed owned containers; Rust drops Bitset/Vec/Vec fields automatically.
-// Note: source_url is NOT freed, matching the Zig deinit (caller owns it).
+// Bitset/Vec/Vec fields drop automatically.
+// Note: source_url is NOT freed (caller owns it).
 
 pub mod text {
     use super::*;
-    // PORT NOTE: Zig `Output.prettyFmt(fmt, comptime bool)` is a comptime string
-    // rewrite. The `pretty_fmt!` macro only accepts literal `true`/`false` today,
+    // The `pretty_fmt!` macro only accepts literal `true`/`false` today,
     // so call the runtime rewriter for the `ENABLE_COLORS` const-generic sites.
-    // PERF(port): runtime `pretty_fmt` allocates a small Vec per call — if hot,
+    // PERF: runtime `pretty_fmt` allocates a small Vec per call — if hot,
     // hoist into `const` once the proc-macro lands.
     use bun_core::output::pretty_fmt;
 
@@ -235,7 +234,7 @@ pub mod text {
         let mut prev_line: usize = 0;
         let mut is_first = true;
 
-        // PORT NOTE: `concat!(pretty_fmt!(..), "{}")` requires a literal; split into a
+        // `concat!(pretty_fmt!(..), "{}")` requires a literal; split into a
         // prefix `write_all` + plain `write!` so the const-generic `ENABLE_COLORS` can
         // route through the runtime rewriter.
         let red = pretty_fmt::<ENABLE_COLORS>("<red>");
@@ -331,8 +330,7 @@ pub mod lcov {
 
         // ** Track all executable lines **
         // Executable lines that were not hit should be marked as 0
-        // PORT NOTE: Zig cloned the bitset before iterating; `DynamicBitSet::iterator`
-        // borrows `&self` so the clone is unnecessary.
+        // `DynamicBitSet::iterator` borrows `&self`, so no clone is needed.
         let mut iter = report.executable_lines.iterator::<true, true>();
 
         // ** Branch coverage not supported yet, since JSC does not support those yet. ** //
@@ -356,7 +354,6 @@ pub mod lcov {
     }
 }
 
-// TODO(port): move to sourcemap_jsc_sys
 unsafe extern "C" {
     fn CodeCoverage__withBlocksAndFunctions(
         vm: *mut VM,
@@ -385,8 +382,7 @@ impl<'a> Generator<'a> {
         let this = unsafe { &mut *this };
         // The C++ side (CodeCoverage.cpp) invokes this callback with `(nullptr, 0, 0)` when
         // basicBlocks is empty. `core::slice::from_raw_parts` requires a non-null, aligned
-        // pointer even for zero-length slices, so we must bail before constructing the slice
-        // (matches the Zig spec, which early-returns on `blocks.len == 0`).
+        // pointer even for zero-length slices, so we must bail before constructing the slice.
         if blocks_len == 0 {
             return;
         }
@@ -403,7 +399,7 @@ impl<'a> Generator<'a> {
             return;
         }
 
-        // PORT NOTE: Zig assigns the slice by value with no ownership transfer here.
+        // No ownership transfer here:
         // `from_utf8_never_free` already detaches the lifetime by design, and
         // `generate_report_from_blocks` only borrows `&self`, so no &/&mut overlap.
         let source_url =
@@ -430,8 +426,11 @@ pub struct ByteRangeMapping {
     pub source_url: ZigStringSlice,
 }
 
-// TODO(port): IdentityContext(u64) hasher — key is already a wyhash, hash fn should be identity
-pub type ByteRangeMappingHashMap = bun_collections::HashMap<u64, ByteRangeMapping>;
+// Keys are already wyhashes (`bun_wyhash::hash` of the source URL — see
+// `ByteRangeMapping__find`), so use the identity context instead of
+// re-hashing them.
+pub type ByteRangeMappingHashMap =
+    bun_collections::HashMap<u64, ByteRangeMapping, bun_collections::IdentityContext<u64>>;
 
 thread_local! {
     // Lazily-initialized per-thread map. Stored behind `Box` so the address of the
@@ -469,7 +468,7 @@ fn thread_map_opt() -> Option<NonNull<ByteRangeMappingHashMap>> {
 }
 
 impl ByteRangeMapping {
-    /// Zig: `pub threadlocal var map: ?*HashMap = null;` — read-only accessor
+    /// Read-only accessor
     /// for the per-thread `ByteRangeMappingHashMap`. Returns `None` if no
     /// coverage data was recorded on this thread.
     ///
@@ -496,11 +495,9 @@ impl ByteRangeMapping {
 
         let mut executable_lines: Bitset;
         let mut lines_which_have_executed: Bitset;
-        // PORT NOTE: Zig's `SavedSourceMap.get` returns a `?*ParsedSourceMap` with a +1
-        // intrusive ref (Zig: `defer if (parsed_mappings_) |p| p.deref()`). The Rust port
-        // models this as `Option<Arc<ParsedSourceMap>>`, so the +1 is released
-        // automatically when `parsed_mappings_` drops at scope exit — no explicit guard
-        // is required.
+        // `SavedSourceMap::get` returns an `Option<Arc<ParsedSourceMap>>`, so the
+        // +1 ref is released automatically when `parsed_mappings_` drops at scope
+        // exit — no explicit guard is required.
         let parsed_mappings_: Option<std::sync::Arc<ParsedSourceMap>> =
             // SAFETY: `VirtualMachine::get()` returns the live singleton `*mut VirtualMachine`
             // with full write provenance; dereference to call the `&mut self` accessor.
@@ -841,8 +838,8 @@ impl ByteRangeMapping {
     }
 }
 
-// ByteRangeMapping::deinit only freed line_offset_table; Rust drops it automatically.
-// source_url is NOT freed, matching Zig deinit.
+// line_offset_table drops automatically.
+// source_url is NOT freed (caller owns it).
 
 #[unsafe(no_mangle)]
 pub(crate) extern "C" fn ByteRangeMapping__generate(
@@ -919,7 +916,7 @@ pub(crate) extern "C" fn ByteRangeMapping__findExecutedLines(
 
     let mut coverage_fraction = Fraction::default();
 
-    // PORT NOTE: std.Io.Writer.Allocating → Vec<u8> byte buffer (bun_io::Write target).
+    // std.Io.Writer.Allocating → Vec<u8> byte buffer (bun_io::Write target).
     let mut buf: Vec<u8> = Vec::new();
 
     if text::write_format::<false>(
@@ -953,5 +950,3 @@ pub struct Block {
     pub start_line: u32,
     pub end_line: u32,
 }
-
-// ported from: src/sourcemap_jsc/CodeCoverage.zig
diff --git a/src/sourcemap_jsc/JSSourceMap.rs b/src/sourcemap_jsc/JSSourceMap.rs
index fb97b8d5d01..f937a880c03 100644
--- a/src/sourcemap_jsc/JSSourceMap.rs
+++ b/src/sourcemap_jsc/JSSourceMap.rs
@@ -9,9 +9,9 @@ use bun_core::{self as bstring, strings};
 use bun_jsc::{CallFrame, JSGlobalObject, JSValue, JsResult, StringJsc as _, bun_string_jsc};
 use bun_sourcemap::{Mapping, Ordinal, ParseResult, ParsedSourceMap, mapping};
 
-// TODO(port): bun_jsc::JsClass — `#[bun_jsc::JsClass]` derive proc-macro not yet
-// implemented; the codegen-provided `to_js`/`from_js`/cached-setter accessors are
-// stubbed below until generate-classes.ts emits Rust.
+// generate-classes.ts does not emit Rust accessors yet, so the
+// `to_js`/cached-setter helpers below forward to the codegen-emitted C++
+// symbols by hand.
 pub struct JSSourceMap {
     pub sourcemap: Arc<ParsedSourceMap>,
     pub sources: Box<[bstring::String]>,
@@ -19,10 +19,9 @@ pub struct JSSourceMap {
 }
 
 /// TODO: when we implement --enable-source-map CLI flag, set this to true.
-// PORT NOTE: Zig `pub var @"--enable-source-maps"` — mutable global; use AtomicBool for safe mutation.
+// Mutable global; AtomicBool for safe mutation.
 pub(crate) static ENABLE_SOURCE_MAPS: AtomicBool = AtomicBool::new(false);
 
-/// Zig: `comptime { @export(&jsFunctionFindSourceMap, .{ .name = "Bun__JSSourceMap__find" }) }`
 #[bun_jsc::host_fn(export = "Bun__JSSourceMap__find")]
 pub(crate) fn find_source_map(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     // Node.js doesn't enable source maps by default.
@@ -39,7 +38,7 @@ pub(crate) fn find_source_map(global: &JSGlobalObject, frame: &CallFrame) -> JsR
         return Ok(JSValue::UNDEFINED);
     }
 
-    // PORT NOTE: reshaped for borrowck — `source_url_slice` borrows `source_url_string`;
+    // reshaped for borrowck — `source_url_slice` borrows `source_url_string`;
     // explicit deref/deinit calls become Drop on reassignment.
     let mut source_url_string = bun_string_jsc::from_js(source_url_value, global)?;
     let mut source_url_slice = source_url_string.to_utf8();
@@ -79,15 +78,11 @@ pub(crate) fn find_source_map(global: &JSGlobalObject, frame: &CallFrame) -> JsR
     let Some(source_map) = vm.source_mappings().get(source_url) else {
         return Ok(JSValue::UNDEFINED);
     };
-    // Zig: `bun.default_allocator.alloc(bun.String, 1) catch return globalObject.throwOutOfMemory()`
-    // Rust Box allocation aborts on OOM (handleOom semantics).
+    // Box allocation aborts on OOM (handleOom semantics).
     let fake_sources_array: Box<[bstring::String]> = Box::new([source_url_string.dupe_ref()]);
 
-    // PORT NOTE: Zig stores an intrusive `*ParsedSourceMap` (+1 ref from
-    // `SavedSourceMap.get`) and `deinit` calls `sourcemap.deref()`. The Rust
-    // port models that ownership as `Arc<ParsedSourceMap>` (LIFETIMES.tsv);
-    // `SavedSourceMap::get` already hands back the +1 as an `Arc`, and `Drop`
-    // on the field releases it — no manual `deref_()` needed.
+    // `SavedSourceMap::get` hands back a +1 ref as an `Arc<ParsedSourceMap>`;
+    // `Drop` on the field releases it — no manual `deref_()` needed.
     let this = Box::new(JSSourceMap {
         sourcemap: source_map,
         sources: fake_sources_array,
@@ -97,7 +92,6 @@ pub(crate) fn find_source_map(global: &JSGlobalObject, frame: &CallFrame) -> JsR
 }
 
 impl JSSourceMap {
-    // TODO(port): verify JsClass constructor signature (Box<Self> vs *mut Self return)
     pub fn constructor(
         global: &JSGlobalObject,
         frame: &CallFrame,
@@ -119,8 +113,6 @@ impl JSSourceMap {
         }
 
         // Parse the payload to create a proper sourcemap
-        // PORT NOTE: Zig used a local ArenaAllocator solely for `mappings_str` UTF-8 transcode;
-        // Rust `to_utf8()` owns its buffer, so the arena is dropped entirely.
 
         // Extract mappings string from payload
         let Some(mappings_value) = payload_arg.get_stringish(global, b"mappings")? else {
@@ -185,24 +177,20 @@ impl JSSourceMap {
         });
 
         if !payload_arg.is_empty() {
-            // TODO(port): codegen accessor — js.payloadSetCached
             Self::payload_set_cached(this_value, global, payload_arg);
         }
         if !line_lengths.is_empty() {
-            // TODO(port): codegen accessor — js.lineLengthsSetCached
             Self::line_lengths_set_cached(this_value, global, line_lengths);
         }
 
         Ok(source_map)
     }
 
-    // ── codegen accessors (provided by `#[bun_jsc::JsClass]` once it lands) ──
-    // TODO(port): bun_jsc::JsClass — generate-classes.ts emits the real
-    // `*_set_cached`/`to_js` thunks; these forward to extern stubs so the
-    // constructor body type-checks today.
+    // ── codegen accessors ──
+    // generate-classes.ts emits the C++ side of `*SetCachedValue`/`__create`;
+    // these thunks forward to those extern symbols by hand.
     #[inline]
     fn to_js(this: Box<Self>, global: &JSGlobalObject) -> JSValue {
-        // Codegen body (ZigGeneratedClasses.zig:21141): `SourceMap__create(global, this)`.
         // SAFETY: `global` is live; `this` is the freshly-constructed payload whose
         // ownership transfers to the C++ JSCell wrapper (`m_ctx`). The extern takes
         // an erased `*mut ()` (matching `src/jsc/generated.rs::__create`) since
@@ -240,13 +228,11 @@ impl JSSourceMap {
     }
 
     // The cached value should handle this.
-    // TODO(port): bun_jsc::host_fn — `#[bun_jsc::host_fn(getter)]`
     pub fn get_payload(&self, _global: &JSGlobalObject) -> JsResult<JSValue> {
         Ok(JSValue::UNDEFINED)
     }
 
     // The cached value should handle this.
-    // TODO(port): bun_jsc::host_fn — `#[bun_jsc::host_fn(getter)]`
     pub fn get_line_lengths(&self, _global: &JSGlobalObject) -> JsResult<JSValue> {
         Ok(JSValue::UNDEFINED)
     }
@@ -275,7 +261,6 @@ impl JSSourceMap {
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): bun_jsc::host_fn — `#[bun_jsc::host_fn(method)]`
     pub fn find_origin(
         this: &Self,
         global: &JSGlobalObject,
@@ -305,7 +290,6 @@ impl JSSourceMap {
         })
     }
 
-    // TODO(port): bun_jsc::host_fn — `#[bun_jsc::host_fn(method)]`
     pub fn find_entry(
         this: &Self,
         global: &JSGlobalObject,
@@ -350,22 +334,18 @@ fn get_line_column(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<[i32;
     ])
 }
 
-// TODO(port): move to sourcemap_jsc_sys (or bun_jsc_sys)
-//
 // Codegen-emitted helpers (`SourceMap__create`, `*SetCachedValue`) are defined
 // in ZigGeneratedClasses.cpp with `extern JSC_CALLCONV` (= `"C" SYSV_ABI` on
 // Windows-x64), so they must be imported via `jsc_abi_extern!` to get the
 // matching `extern "sysv64"` cfg-arm — plain `extern "C"` here would call them
 // with the win64 ABI and corrupt arguments.
 bun_jsc::jsc_abi_extern! {
-    // Codegen-emitted constructor thunk (`js.toJS` → `SourceMap__create` in
-    // ZigGeneratedClasses.zig); ownership of `ctx` transfers to the C++ JSCell.
+    // Codegen-emitted constructor thunk; ownership of `ctx` transfers to the C++ JSCell.
     // `ctx` is type-erased to `*mut ()` (C++ stores it as `void* m_ctx`) to keep
     // the extern FFI-safe — `JSSourceMap` itself has Rust-only field layout.
     fn SourceMap__create(globalObject: *mut JSGlobalObject, ctx: *mut ()) -> JSValue;
 
-    // Codegen-emitted cached-value setters (see `js.payloadSetCached` in
-    // JSSourceMap.zig); name matches generated_classes.ts output.
+    // Codegen-emitted cached-value setters; names match generated_classes.ts output.
     fn SourceMapPrototype__payloadSetCachedValue(
         thisValue: JSValue,
         globalObject: *mut JSGlobalObject,
@@ -400,8 +380,3 @@ unsafe extern "C" {
         name: JSValue,
     ) -> JSValue;
 }
-
-// `js = jsc.Codegen.JSSourceMap` and `fromJS`/`fromJSDirect`/`toJS` re-exports are
-// provided by the `#[bun_jsc::JsClass]` derive; no manual re-export needed.
-
-// ported from: src/sourcemap_jsc/JSSourceMap.zig
diff --git a/src/sourcemap_jsc/internal_jsc.rs b/src/sourcemap_jsc/internal_jsc.rs
index 88b630c14fb..ff312be6dfd 100644
--- a/src/sourcemap_jsc/internal_jsc.rs
+++ b/src/sourcemap_jsc/internal_jsc.rs
@@ -8,7 +8,6 @@ use bun_sourcemap::internal_source_map::{self, InternalSourceMap};
 pub(crate) struct TestingAPIs;
 
 impl TestingAPIs {
-    // TODO(port): bun_jsc::host_fn — proc-macro attribute not yet implemented.
     pub(crate) fn from_vlq(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
         let vlq_str = bun_core::OwnedString::new(frame.argument(0).to_bun_string(global)?);
         let vlq = vlq_str.to_utf8();
@@ -59,7 +58,6 @@ impl TestingAPIs {
         };
 
         let obj = JSValue::create_empty_object(global, 5);
-        // PORT NOTE: stub `JSValue::put` takes `&[u8]` directly (Zig used `ZigString.static_`).
         obj.put(
             global,
             b"generatedLine",
@@ -104,5 +102,3 @@ pub fn testing_to_vlq(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JS
 pub fn testing_find(global: &JSGlobalObject, frame: &CallFrame) -> JsResult<JSValue> {
     TestingAPIs::find(global, frame)
 }
-
-// ported from: src/sourcemap_jsc/internal_jsc.zig
diff --git a/src/sourcemap_jsc/source_provider.rs b/src/sourcemap_jsc/source_provider.rs
index 5109ca9eac1..29663864201 100644
--- a/src/sourcemap_jsc/source_provider.rs
+++ b/src/sourcemap_jsc/source_provider.rs
@@ -1,8 +1,7 @@
 //! `BakeSourceProvider` — the only `*SourceProvider` variant whose external
 //! sourcemap lookup needs the live `Bake::GlobalObject`. The opaque + its
 //! `get_external_data` live here so `src/sourcemap/` has no JSC types;
-//! `get_source_map_impl` calls it via a trait bound (Zig used
-//! `@hasDecl(SourceProviderKind, "getExternalData")`).
+//! `get_source_map_impl` calls it via a trait bound.
 
 use bun_core::String as BunString;
 use bun_jsc::JSGlobalObject;
@@ -35,7 +34,7 @@ impl BakeSourceProvider {
     }
 
     pub fn to_source_content_ptr(&self) -> source_map::parsed_source_map::SourceContentPtr {
-        // PORT NOTE: `bun_sourcemap` defines its own opaque `BakeSourceProvider` so it
+        // `bun_sourcemap` defines its own opaque `BakeSourceProvider` so it
         // can name the pointer without a tier-6 dep. Both are `#[repr(C)]` ZST opaques
         // for the same C++ type, so the pointer cast is layout-correct.
         source_map::parsed_source_map::SourceContentPtr::from_bake_provider(
@@ -56,7 +55,7 @@ impl BakeSourceProvider {
         // SAFETY: `global` is a `Bake::GlobalObject` (checked above), so the
         // attached `PerThread*` is non-null and live for the bake build session.
         let pt = unsafe { BakeGlobalObject__getPerThreadData(global) };
-        // PORT NOTE: `PerThread`'s fields name `bun_bundler::OutputFile`, which
+        // `PerThread`'s fields name `bun_bundler::OutputFile`, which
         // lives above this crate (forward-dep cycle). The field access
         // (`pt.source_maps.get(filename)` →
         // `pt.bundled_outputs[idx].value.asSlice()`) is dispatched through the
@@ -91,8 +90,6 @@ impl BakeSourceProvider {
     }
 }
 
-// PORT NOTE: Zig dispatched via `comptime SourceProviderKind: type` + `@hasDecl`;
-// Rust uses a trait per PORTING.md §Dispatch.
 impl SourceProvider for BakeSourceProvider {
     const HAS_EXTERNAL_DATA: bool = true;
 
@@ -108,5 +105,3 @@ impl SourceProvider for BakeSourceProvider {
         Self::get_external_data(self, source_filename)
     }
 }
-
-// ported from: src/sourcemap_jsc/source_provider.zig
diff --git a/src/spawn/lib.rs b/src/spawn/lib.rs
index fbd42b83e07..136c7616406 100644
--- a/src/spawn/lib.rs
+++ b/src/spawn/lib.rs
@@ -1,5 +1,5 @@
-//! `bun_spawn` — process-spawn implementation extracted from
-//! `src/runtime/api/bun/process.zig` so that `bun_install`, `bun_jsc`, and
+//! `bun_spawn` — process-spawn implementation, extracted so that
+//! `bun_install`, `bun_jsc`, and
 //! `bun_patch` can construct/track child processes without depending on
 //! `bun_runtime` (cycle: `bun_runtime → bun_install`/`bun_jsc`).
 //!
@@ -11,10 +11,6 @@
 //! (`ThreadSafeRefCount`), `bun_io` (`BufferedWriter`), `bun_event_loop`,
 //! `bun_threading`, and `bun_crash_handler` — none of which depend back on
 //! this crate, so no cycle.
-//!
-//! Zig source of truth: `src/runtime/api/bun/process.zig`,
-//! `src/runtime/api/bun/spawn.zig`,
-//! `src/runtime/api/bun/subprocess/StaticPipeWriter.zig`.
 
 use core::ffi::c_char;
 
@@ -44,13 +40,11 @@ pub mod posix_spawn {
 }
 
 /// `Process` / `Poller` / `WaiterThread` / `spawn_process` / `sync` /
-/// `Status` / `SpawnOptions` / `SpawnResult`. Port of
-/// `src/runtime/api/bun/process.zig`.
+/// `Status` / `SpawnOptions` / `SpawnResult`.
 #[path = "process.rs"]
 pub mod process;
 
-/// Generic `StaticPipeWriter<P>` (`jsc.Subprocess.NewStaticPipeWriter`).
-/// Port of `src/runtime/api/bun/subprocess/StaticPipeWriter.zig`.
+/// Generic `StaticPipeWriter<P>`.
 #[path = "static_pipe_writer.rs"]
 pub mod static_pipe_writer;
 
@@ -143,7 +137,7 @@ pub mod windows {
     pub type UvPipePtr = *mut bun_sys::windows::libuv::Pipe;
 }
 
-/// `bun.spawnSync` (process.zig `pub const sync`).
+/// Blocking (synchronous) spawn helpers.
 pub mod sync {
     #[cfg(windows)]
     pub use crate::process::WindowsOptions;
@@ -169,8 +163,7 @@ pub mod subprocess {
     pub use crate::process::StdioKind;
     pub use crate::static_pipe_writer::{StaticPipeWriter, StaticPipeWriterProcess};
 
-    /// Port of `bun.jsc.Subprocess.StdioResult` (subprocess.zig). On POSIX the
-    /// Zig type is `?bun.FD`; on Windows it is the `WindowsStdioResult` union.
+    /// On POSIX this is `Option<Fd>`; on Windows it is the `WindowsStdioResult` union.
     #[cfg(not(windows))]
     pub type StdioResult = Option<Fd>;
     #[cfg(windows)]
@@ -187,11 +180,11 @@ pub mod subprocess {
         crate::process::WindowsStdioResult::BufferFd(fd)
     }
 
-    /// Port of `bun.jsc.Subprocess.Source` — the in-memory payload that a
+    /// The in-memory payload that a
     /// `StaticPipeWriter` drains into the child's stdin/extra-fd.
     ///
-    /// The Zig original is a tagged union over `Blob`/`ArrayBuffer`/detached;
-    /// at this tier those are JSC-owned and unreachable, so the high-tier
+    /// `Blob`/`ArrayBuffer` payloads are JSC-owned and unreachable at this
+    /// tier, so the high-tier
     /// variants are carried via a `Box<dyn SourceData>` (per-object vtable —
     /// §Dispatch cold path). `bun_install` uses [`Source::from_owned_bytes`].
     pub enum Source {
@@ -218,18 +211,17 @@ pub mod subprocess {
             Self::OwnedBytes(bytes)
         }
 
-        /// Zig: `Source.slice()`.
         pub fn slice(&self) -> &[u8] {
             match self {
                 Source::OwnedBytes(b) => b,
                 Source::Any(s) => s.slice(),
-                // Zig: `else => @panic("Invalid source")` — slice() after detach() is a bug.
+                // slice() after detach() is a bug.
                 Source::Detached => unreachable!("Source::slice on Detached"),
             }
         }
 
-        /// Zig: `Source.detach()` — release the payload and flip to
-        /// `.Detached`. Calling `slice()` afterwards is invalid (panics).
+        /// Release the payload and flip to
+        /// `Detached`. Calling `slice()` afterwards is invalid (panics).
         pub fn detach(&mut self) {
             if let Source::Any(s) = self {
                 s.detach();
@@ -248,14 +240,11 @@ pub mod subprocess {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `std.process.Child.run` shim — port of the blocking `run` helper used by
-// `bun_install::repository::exec` (src/install/repository.zig:360). Per
-// `src/CLAUDE.md` ("Prefer `bun.spawnSync` over `std.process.Child`") and the
-// `std::process` ban in PORTING.md, this is rewritten on top of
-// [`sync::spawn`] (= `bun.spawnSync`).
+// Blocking `run` helper used by `bun_install::repository::exec`. Per the
+// `std::process` ban in PORTING.md, this is built on top of [`sync::spawn`].
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Port of `std.process.Child.Term`.
+/// Child process termination status.
 #[derive(Clone, Copy, Debug)]
 pub enum Term {
     Exited(u32),
@@ -264,46 +253,44 @@ pub enum Term {
     Unknown(u32),
 }
 
-/// Options for [`run`] — port of `std.process.Child.RunOptions` (subset used
-/// by `repository.zig`).
+/// Options for [`run`].
 #[derive(Clone, Copy)]
 pub struct RunOptions<'a> {
     pub argv: &'a [&'a [u8]],
     pub env_map: &'a bun_sys::EnvMap,
 }
 
-/// Result of [`run`] — port of `std.process.Child.RunResult`.
+/// Result of [`run`].
 pub struct RunResult {
     pub term: Term,
     pub stdout: Vec<u8>,
     pub stderr: Vec<u8>,
 }
 
-/// Port of `std.process.Child.run` — blocking spawn that captures stdout/stderr.
+/// Blocking spawn that captures stdout/stderr.
 ///
-/// The argv/envp marshalling mirrors `std.process.Child.spawnPosix`: each arg
+/// argv/envp marshalling: each arg
 /// is NUL-terminated, the array is NULL-terminated, and env entries are
 /// flattened to `KEY=VALUE\0`.
 #[cfg_attr(windows, allow(unreachable_code, unused_variables, unused_mut))]
 pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Error> {
-    // Windows: Zig's `std.process.Child.run` (the spec for this fn) calls
-    // `CreateProcessW`+`ReadFile` directly — no libuv. `process::sync::spawn`
+    // Windows: `process::sync::spawn`
     // below is libuv-based on Windows and reads `options.windows.loop_` to get
     // the `uv_loop_t*`, but the only caller (`repository::exec`) runs on a
     // ThreadPool worker thread that has no event loop; supplying one via
     // `MiniEventLoop::init_global` from a worker thread would create a second
     // `us_loop` wrapping the *process-global* `uv_default_loop()` and then
     // `uv_run` it concurrently with the main install thread (libuv UB). Route
-    // through `std::process` here instead to faithfully port the Zig spec —
+    // through `std::process` here instead —
     // the PORTING.md `std::process` ban is about not bypassing Bun's event
-    // loop, which is exactly what the Zig call site already does intentionally
-    // for off-thread `git`.
+    // loop, which is exactly what this off-thread `git` call site does
+    // intentionally.
     #[cfg(windows)]
     {
         use std::ffi::OsString;
         use std::os::windows::ffi::OsStringExt;
 
-        // `std.process.Child.spawnWindows` decodes argv as WTF-8 → WTF-16; use
+        // Decode argv as WTF-8 → WTF-16 with
         // the simdutf-backed converter (no slash normalization — argv carries
         // URLs, not just filesystem paths).
         fn to_os(b: &[u8]) -> OsString {
@@ -314,8 +301,7 @@ pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Er
 
         let mut iter = opts.argv.iter();
         let argv0 = iter.next().ok_or(bun_core::err!("FileNotFound"))?;
-        // `Command::new` does PATH/PATHEXT lookup on Windows, matching
-        // `std.process.Child.spawnWindows`'s `windowsCreateProcessPathExt`.
+        // `Command::new` does PATH/PATHEXT lookup on Windows.
         let mut cmd = std::process::Command::new(to_os(argv0));
         for arg in iter {
             cmd.arg(to_os(arg));
@@ -343,18 +329,16 @@ pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Er
         });
     }
 
-    // `std.process.Child.spawnPosix` resolves `argv[0]` against `$PATH` (it
-    // calls `posix.execvpeZ_expandArg0`). `process::sync::spawn` below execs
-    // via `execve` (no PATH search), so do the lookup here. Use the *child's*
-    // env PATH — that's what Zig's expandArg0 walks.
+    // `process::sync::spawn` below execs
+    // via `execve` (no PATH search), so resolve `argv[0]` against `$PATH`
+    // here. Use the *child's* env PATH.
     let mut argv0_buf = bun_core::PathBuffer::uninit();
     let mut argv0_storage: Option<Box<[u8]>> = None;
     'argv0: {
         let Some(&first) = opts.argv.first() else {
             break 'argv0;
         };
-        // Only PATH-search bare names — Zig's expandArg0 expands only when no
-        // separator is present.
+        // Only PATH-search bare names (no separator present).
         if first.contains(&b'/') {
             break 'argv0;
         }
@@ -408,18 +392,15 @@ pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Er
         stdout: process::sync::SyncStdio::Buffer,
         stderr: process::sync::SyncStdio::Buffer,
         argv0: argv0_ptr,
-        // Zig `std.process.Child.run` (the spec for this fn) spawns via raw
-        // `CreateProcessW`+`ReadFile` and needs no uv loop. The Rust port
-        // routes through `process::sync::spawn` → `spawn_process_windows`,
-        // which *does* read `options.windows.loop_` to get the `uv_loop_t*`.
-        // `WindowsOptions::default()` leaves `loop_` zeroed (Zig: `= undefined`),
+        // `process::sync::spawn` → `spawn_process_windows`
+        // reads `options.windows.loop_` to get the `uv_loop_t*`.
+        // `WindowsOptions::default()` leaves `loop_` zeroed,
         // so the deref segfaults at the `uv_loop` field offset. Supply the
         // thread's mini event loop — `init_global` is idempotent and, for the
         // sole caller (`repository.exec` under `bun add`/`install`), returns
         // the `MiniEventLoop` the PackageManager already published into
         // `GLOBAL` (PackageManager.rs:2110), matching what other install-side
-        // `bun.spawnSync` callers pass (`.loop = EventLoopHandle.init(
-        // jsc.MiniEventLoop.initGlobal(env, null))`).
+        // sync-spawn callers pass.
         #[cfg(windows)]
         windows: process::sync::WindowsOptions {
             loop_: EventLoopHandle::init_mini(bun_event_loop::MiniEventLoop::init_global(
@@ -430,7 +411,7 @@ pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Er
         ..Default::default()
     };
 
-    // `!Maybe(Result)` → outer `Result<_, bun_core::Error>` for the Zig `try`,
+    // Outer `Result<_, bun_core::Error>` for hard errors,
     // inner `Maybe` for the syscall error.
     let result = process::sync::spawn(&sync_opts)??;
 
@@ -438,8 +419,8 @@ pub fn run(opts: RunOptions<'_>) -> core::result::Result<RunResult, bun_core::Er
     drop(envp);
     drop(env_buf);
 
-    // Map `bun.spawn.Status` → `std.process.Child.Term` (the subset
-    // `repository.exec` matches on — `.Exited`/else).
+    // Map `Status` → `Term` (the subset
+    // `repository.exec` matches on — `Exited`/else).
     let term = match result.status {
         Status::Exited(e) => Term::Exited(u32::from(e.code)),
         Status::Signaled(sig) => Term::Signal(u32::from(sig)),
diff --git a/src/spawn/process.rs b/src/spawn/process.rs
index 347f5ba2ebd..7a5382817c1 100644
--- a/src/spawn/process.rs
+++ b/src/spawn/process.rs
@@ -27,8 +27,7 @@ use uv::{UvHandle as _, UvStream as _};
 #[cfg(unix)]
 use bun_spawn_sys::posix_spawn::posix_spawn;
 /// `posix_spawn::WaitPidResult` — re-exported from `bun_spawn_sys`. `status`
-/// is `u32` there (Zig `c_int` reinterpreted via the `W*` macros);
-/// `Status::from` casts before matching.
+/// is `u32` there; `Status::from` casts before matching.
 #[cfg(unix)]
 pub use posix_spawn::WaitPidResult;
 #[cfg(windows)]
@@ -135,9 +134,8 @@ pub struct Process {
 }
 
 impl Drop for Process {
-    /// Zig `Process.deinit`: `this.poller.deinit(); bun.destroy(this)`. The
-    /// `bun.destroy` half is the `heap::take` in `destructor` above; this
-    /// `Drop` body covers the `poller.deinit()` call.
+    /// The allocation itself is freed by the `heap::take` in `destructor`
+    /// above; this `Drop` body covers the `poller.deinit()` call.
     fn drop(&mut self) {
         self.poller.deinit();
     }
@@ -171,7 +169,7 @@ impl Process {
         self.status.signal_code()
     }
 
-    /// Intrusive ref-count helpers (Zig: `ref_count.ref()/deref()`). Kept on
+    /// Intrusive ref-count helpers. Kept on
     /// `&mut self` to match call-site shape; the actual op is atomic on the
     /// embedded `ThreadSafeRefCount` so the mutable borrow is conservative.
     #[inline]
@@ -195,9 +193,7 @@ impl Process {
     }
 
     /// Bridge `self.event_loop` (`EventLoopHandle`) to `bun_io::EventLoopCtx`
-    /// for FilePoll/KeepAlive calls. Zig used `anytype` and dispatched at
-    /// comptime; the Rust port split this into two erased layers, so we
-    /// reconstitute the aio-level ctx here.
+    /// for FilePoll/KeepAlive calls; reconstitutes the aio-level ctx here.
     #[inline]
     fn event_loop_ctx(&self) -> bun_io::EventLoopCtx {
         event_loop_handle_to_ctx(self.event_loop)
@@ -223,10 +219,9 @@ impl Process {
     /// runs the exit logic, and `on_exit_uv` re-derives `&mut Process` from
     /// the heap-root `data` pointer. A `&mut self` argument carries a
     /// Stacked-Borrows protector for the call's full duration, so that
-    /// re-derivation would pop the protected tag → instant UB. Zig used
-    /// `@fieldParentPtr` (no aliasing model), so this was sound there.
+    /// re-derivation would pop the protected tag → instant UB.
     pub unsafe fn update_status_on_windows(this: *mut Process) {
-        // Zig: `onExitUV(&this.poller.uv, 0, 0)`. Inlined here with
+        // Run the exit logic inline with
         // exit_status=0 / term_signal=0 (→ `Exited{0,0}`) instead of
         // round-tripping through `on_exit_uv`'s `data`-ptr lookup, which
         // would create a second `&mut Process` aliasing the one below.
@@ -427,8 +422,7 @@ impl Process {
             let watchfd = self.pid;
 
             let poll: *mut FilePoll = if matches!(self.poller, Poller::Fd(_)) {
-                // already have a poll
-                // PORT NOTE: reshaped for borrowck — take existing pointer out
+                // already have a poll; take the existing pointer out
                 core::mem::replace(&mut self.poller, Poller::Detached)
                     .into_fd()
                     .unwrap()
@@ -499,8 +493,7 @@ impl Process {
 
     #[cfg(windows)]
     extern "C" fn on_exit_uv(process: *mut uv::uv_process_t, exit_status: i64, term_signal: c_int) {
-        // Zig recovers `*Process` via `@fieldParentPtr("uv", process)` →
-        // `@fieldParentPtr("poller", ..)`. A Rust default-repr `enum` has no
+        // A Rust default-repr `enum` has no
         // stable variant-payload offset, so the back-pointer is stored in
         // `uv_process_t.data` (set in `spawn_process_windows` immediately
         // after the handle is zeroed).
@@ -525,8 +518,6 @@ impl Process {
         } else {
             0
         };
-        // Zig: `if (term_signal > 0 and term_signal < @intFromEnum(SignalCode.SIGSYS))
-        //   @enumFromInt(term_signal) else null` — upper-bound exclusive of SIGSYS.
         let signal_code: Option<u8> =
             if term_signal > 0 && term_signal < bun_core::SignalCode::SIGSYS as c_int {
                 Some(term_signal as u8)
@@ -545,9 +536,8 @@ impl Process {
             this.close();
             this.on_exit(Status::Signaled(sig), &rusage);
         } else if exit_status >= 0 {
-            // Zig spec compares `exit_code >= 0` (a `u8` tautology) here; the
-            // intended check — per the `else` arm's comment — is on the signed
-            // libuv `exit_status`, so a negative `-UV_E*` reaches the Err arm.
+            // The check is on the signed libuv `exit_status`, so a negative
+            // `-UV_E*` reaches the Err arm.
             this.close();
             this.on_exit(
                 Status::Exited(Exited {
@@ -662,11 +652,10 @@ impl Process {
     pub fn kill(&mut self, signal: u8) -> Maybe<()> {
         #[cfg(unix)]
         {
-            // Spec process.zig:550 — `.waiter_thread, .fd => kill(); else => {}`.
             // Detached is a deliberate no-op: spawnSync's `read_all()` runs
-            // before `watch_or_reap()` installs the poller, but Zig relies on
-            // the first `recv_non_block` returning EAGAIN (yes hasn't written
-            // yet) so the maxBuffer overflow fires from the event-loop poll
+            // before `watch_or_reap()` installs the poller; the first
+            // `recv_non_block` returns EAGAIN (yes hasn't written yet) so the
+            // maxBuffer overflow fires from the event-loop poll
             // tick *after* the Fd poller is armed. Do not widen this match to
             // mask spawn-maxbuf.test.ts — the async-path hang there has a
             // different root cause (poller is already Fd when `on_max_buffer`
@@ -716,17 +705,15 @@ impl Process {
     }
 }
 
-// PORT NOTE: not `Copy` — `bun_sys::Error` carries `Box<[u8]>` path/dest. The
-// Zig `union(enum)` is copyable because its `.err` arm borrows the path; the
-// Rust port owns it (see Error.rs TODO). Callers use `.clone()`.
+// Not `Copy` — `bun_sys::Error` carries `Box<[u8]>` path/dest.
+// Callers use `.clone()`.
 #[derive(Clone, Default)]
 pub enum Status {
     #[default]
     Running,
     Exited(Exited),
-    /// Raw signal byte. Zig: `.signaled: bun.SignalCode` where `SignalCode` is a
-    /// *non-exhaustive* `enum(u8) { …, _ }`, so any `u8` (incl. Linux RT signals
-    /// 32..=64) is a valid payload. `bun_core::SignalCode` is exhaustive 1..=31,
+    /// Raw signal byte — any `u8` (incl. Linux RT signals 32..=64) is a valid
+    /// payload. `bun_core::SignalCode` is exhaustive 1..=31,
     /// so storing it here would force lossy `Signaled→Exited` rewrites for RT
     /// signals — observable as `{exitCode:0, signal:null}` in JS. Carry the raw
     /// byte and range-check in `signal_code()` instead.
@@ -737,8 +724,8 @@ pub enum Status {
 #[derive(Clone, Copy, Default)]
 pub struct Exited {
     pub code: u8,
-    /// Raw signal number. `0` means "no signal" (Zig: `enum(u8) { @"0" = 0, … }`
-    /// open enum). `SignalCode` discriminants are 1..=31; storing it as the
+    /// Raw signal number. `0` means "no signal".
+    /// `SignalCode` discriminants are 1..=31; storing it as the
     /// enum and transmuting `0` would be UB. Convert via `Status::signal_code`.
     pub signal: u8,
 }
@@ -761,7 +748,7 @@ impl Status {
                 if result.pid != pid {
                     return None;
                 }
-                // `posix_spawn::WaitPidResult.status` is `u32` (Zig bitcasts);
+                // `posix_spawn::WaitPidResult.status` is `u32`;
                 // libc's W* helpers want `c_int`.
                 let status = result.status as c_int;
 
@@ -790,8 +777,7 @@ impl Status {
                 signal: signal.unwrap_or(0),
             }));
         } else if let Some(sig) = signal {
-            // Zig: `.{ .signaled = @enumFromInt(signal.?) }` — non-exhaustive enum,
-            // any byte is valid. Carry the raw byte; `signal_code()` range-checks.
+            // Any byte is valid. Carry the raw byte; `signal_code()` range-checks.
             return Some(Status::Signaled(sig));
         }
 
@@ -808,8 +794,7 @@ impl Status {
     }
 }
 
-/// Local shim for `bun.SignalCode.toExitCode` (lives in `src/sys/SignalCode.zig`).
-/// Upstream `bun_core::SignalCode` does not yet expose this — see SignalCode.zig:53.
+/// Local shim — `bun_core::SignalCode` does not yet expose this.
 /// Shell-convention: 128 + signal number for signals 1..=31, else `None`.
 pub trait SignalCodeExt {
     fn to_exit_code(self) -> Option<u8>;
@@ -846,7 +831,7 @@ impl core::fmt::Display for Status {
 #[cfg(unix)]
 pub enum PollerPosix {
     /// Hive-allocated `bun_io::FilePoll` slot. Pointer (not `Box`) because the
-    /// poll lives in `Store` (Zig: `*FilePoll`); freed via `FilePoll::deinit`,
+    /// poll lives in `Store`; freed via `FilePoll::deinit`,
     /// never via Rust `drop`.
     Fd(core::ptr::NonNull<FilePoll>),
     WaiterThread(KeepAlive),
@@ -855,11 +840,11 @@ pub enum PollerPosix {
 
 #[cfg(unix)]
 impl PollerPosix {
-    /// Zig `PollerPosix.deinit` (process.zig:689-695). NOT `impl Drop`: Zig
-    /// reassigns this union freely (`this.poller = .detached`, `.waiter_thread`,
-    /// etc.) without running cleanup at each assignment, and `close()` already
-    /// performs the same teardown explicitly. A `Drop` impl would double-free
-    /// the hive slot on those reassignments. Called only from `Process` drop.
+    /// NOT `impl Drop`: this enum is reassigned freely (`self.poller =
+    /// Poller::Detached`, `Poller::WaiterThread(..)`, etc.) and `close()`
+    /// already performs the same teardown explicitly before reassigning. A
+    /// `Drop` impl would double-free the hive slot on those reassignments.
+    /// Called only from `Process` drop.
     pub fn deinit(&mut self) {
         // Route the `Fd` arm through the centralized `fd_poll_mut()` accessor
         // instead of open-coding the `NonNull` deref here.
@@ -948,8 +933,7 @@ pub enum PollerWindows {
 
 #[cfg(windows)]
 impl PollerWindows {
-    /// Zig `PollerWindows.deinit` (process.zig:736). Not `Drop` — see
-    /// `PollerPosix::deinit`.
+    /// Not `Drop` — see `PollerPosix::deinit`.
     pub fn deinit(&mut self) {
         if let PollerWindows::Uv(p) = self {
             debug_assert!(p.is_closed());
@@ -1011,10 +995,9 @@ pub mod waiter_thread_posix {
 
     pub type ProcessQueue = NewQueue<Process>;
 
-    /// Zig: `fn NewQueue(comptime T: type) type` → generic struct.
     pub struct NewQueue<T: 'static> {
         pub queue: ConcurrentQueue<T>,
-        // PORT NOTE: Zig active list holds raw `*T` whose strong ref was taken
+        // The active list holds raw `*T` whose strong ref was taken
         // by the caller before `append()` (Process::watch does `self.ref_()`).
         // The matching `deref()` happens in `on_wait_pid_from_waiter_thread`.
         //
@@ -1042,7 +1025,7 @@ pub mod waiter_thread_posix {
     }
 
     /// Intrusive node pushed onto `ConcurrentQueue` from the JS thread and
-    /// drained on the waiter thread (`TrivialNew`/`TrivialDeinit` in Zig).
+    /// drained on the waiter thread.
     pub struct TaskQueueEntry<T: 'static> {
         pub process: *mut T,
         pub next: bun_threading::Link<TaskQueueEntry<T>>,
@@ -1123,11 +1106,9 @@ pub mod waiter_thread_posix {
 
     /// Trait abstracting `process.pid` / `process.event_loop` /
     /// `process.onWaitPidFromWaiterThread` for generic `T` (only `Process`
-    /// today). The Zig `comptime @TypeOf` switch in `append` is the moral
-    /// equivalent.
+    /// today).
     pub trait ProcessLike: 'static {
-        /// `jsc::Task` tag for this `T`'s `ResultTask` — Zig derived this at
-        /// comptime via `TaggedPointerUnion`; Rust callers supply it.
+        /// `jsc::Task` tag for this `T`'s `ResultTask`; callers supply it.
         const TASK_TAG: TaskTag;
         fn pid(&self) -> PidT;
         fn event_loop(&self) -> EventLoopHandle;
@@ -1190,7 +1171,6 @@ pub mod waiter_thread_posix {
                     }
                     // SAFETY: task was heap-allocated in append().
                     let task = unsafe { bun_core::heap::take(task) };
-                    // PERF(port): was assume_capacity
                     active.push(task.process);
                 }
             }
@@ -1251,7 +1231,7 @@ pub mod waiter_thread_posix {
                                         )),
                                     );
                                 }
-                                // PORT NOTE: `out` is now owned by the mini queue;
+                                // `out` is now owned by the mini queue;
                                 // freed in `run_from_main_thread_mini`.
                             }
                         }
@@ -1269,7 +1249,7 @@ pub mod waiter_thread_posix {
 
     const STACK_SIZE: usize = 512 * 1024;
 
-    // Singleton — Zig `pub var instance: WaiterThread = .{};`. The waiter
+    // Singleton. The waiter
     // thread is the sole mutator of `js_process.active`; producers only touch
     // the lock-free `queue`. Wrapped so the address is stable for the SIGCHLD
     // handler / waiter loop without taking `&mut` to a `static mut`.
@@ -1473,7 +1453,7 @@ impl WaiterThread {
 
 #[cfg(windows)]
 pub struct WindowsSpawnResult {
-    // Raw intrusive pointer (mirrors Zig `?*Process`). `Process` is intrusively
+    // Raw intrusive pointer. `Process` is intrusively
     // ref-counted via `bun_ptr::ThreadSafeRefCount` and recovered via
     // `uv_process_t.data` in the libuv callbacks; allocation is `heap::alloc`
     // and destruction is `heap::take` (see `ThreadSafeRefCounted::destructor`).
@@ -1533,9 +1513,7 @@ impl Drop for WindowsSpawnResult {
         // Any `Buffer(Box<uv::Pipe>)` still held here was `uv_pipe_init`'d in
         // `spawn_process_windows` and is linked into the loop's handle queue;
         // auto-dropping the Box would deallocate a live handle and the next
-        // `uv_run` would walk freed memory. Zig's `StdioResult.buffer` is a
-        // raw `*uv.Pipe` (drop is a no-op leak), so the Rust port's `Box`
-        // tightened a leak into UB. Route un-consumed pipes through
+        // `uv_run` would walk freed memory. Route un-consumed pipes through
         // `uv_close` (free in the close callback). Slots already consumed via
         // `.take()` are `Unavailable` and skip this.
         //
@@ -1646,9 +1624,8 @@ impl Default for WindowsOptions {
         Self {
             verbatim_arguments: false,
             hide_window: true,
-            // Zig spec (process.zig:1172): `loop: jsc.EventLoopHandle = undefined`
-            // — every `bun.spawnSync` call site sets it explicitly. Mirroring
-            // that with a zeroed handle here keeps `..Default::default()` usable
+            // Every `bun.spawnSync` call site sets `loop_` explicitly. A
+            // zeroed handle here keeps `..Default::default()` usable
             // for the other fields. `spawn_process_windows` (the sole consumer)
             // asserts non-null at the read site so a forgotten `loop_` panics
             // with a pointed message instead of segfaulting at the `.uv_loop`
@@ -1679,14 +1656,14 @@ pub enum WindowsStdio {
 
 #[cfg(windows)]
 impl WindowsStdio {
-    /// Explicit destructor — matches Zig `WindowsSpawnOptions.Stdio.deinit`.
+    /// Explicit destructor.
     ///
     /// **Not** `Drop`: `spawn_process_windows` takes `&WindowsSpawnOptions`
     /// (immutable borrow) and transfers sole ownership of the `Buffer`/`Ipc`
     /// pipe into `WindowsStdioResult::Buffer` via `heap::take`. An auto-Drop
     /// here would then double-free the same `*mut uv::Pipe` when the borrowed
     /// `WindowsSpawnOptions` (or the `to_spawn_options` temporary) goes out of
-    /// scope. Zig has no auto-destructor on this union; callers invoke
+    /// scope. Callers invoke
     /// `deinit()` only on the *error* path where ownership was never taken.
     pub fn deinit(&mut self) {
         match self {
@@ -1704,11 +1681,10 @@ impl WindowsStdio {
 
 // WindowsSpawnOptions: no Drop. `WindowsStdio` holds FFI-owned `*mut uv::Pipe`
 // whose ownership is transferred to `WindowsStdioResult` on success; callers
-// must invoke `WindowsSpawnOptions::deinit` explicitly on the error path (Zig spec).
+// must invoke `WindowsSpawnOptions::deinit` explicitly on the error path.
 #[cfg(windows)]
 impl WindowsSpawnOptions {
-    /// Explicit destructor — matches Zig `WindowsSpawnOptions.deinit`
-    /// (process.zig:1193). Closes and frees the heap-allocated `uv::Pipe`
+    /// Explicit destructor. Closes and frees the heap-allocated `uv::Pipe`
     /// handles for `Buffer`/`Ipc` stdio.
     ///
     /// **Not** `Drop`: on the *success* path `spawn_process_windows` transfers
@@ -1835,9 +1811,8 @@ mod spawn_process_body {
         // SAFETY: argv is null-terminated, argv[0] is non-null
         uv_process_options.file = options.argv0.unwrap_or_else(|| unsafe { *argv });
         uv_process_options.exit_cb = Some(Process::on_exit_uv);
-        // PERF(port): was stack-fallback allocator (8192)
-        // `WindowsOptions::default()` leaves `loop_` zeroed (Zig: `= undefined`;
-        // every `bun.spawnSync` call site sets it explicitly). A zeroed
+        // `WindowsOptions::default()` leaves `loop_` zeroed (every
+        // `bun.spawnSync` call site sets it explicitly). A zeroed
         // `EventLoopHandle` is discriminant 0 (`Js`) with a null inner pointer,
         // so `platform_event_loop()` returns null and the deref below segfaults
         // at the `.uv_loop` field offset. Catch that with a clear panic instead
@@ -1860,14 +1835,11 @@ mod spawn_process_body {
         // SAFETY: cwd_buf[options.cwd.len()] == 0 written above
         let cwd = bun_core::ZStr::from_buf(&cwd_buf[..], options.cwd.len());
 
-        // PORT NOTE: Zig spec passes `cwd.ptr` unconditionally, but every Zig
-        // `bun.spawnSync` Windows caller sets `.cwd` explicitly so the latent
-        // empty-cwd path is never hit there. The Rust port routes
-        // `git_diff_internal` (originally `std.process.Child`, which inherits cwd)
-        // through here with `Options::default()` → `cwd = ""`. libuv treats a
+        // `git_diff_internal` reaches here
+        // with `Options::default()` → `cwd = ""`. libuv treats a
         // non-NULL `cwd` as explicit and hands `L""` to `CreateProcessW`, which
         // fails with `ERROR_DIRECTORY` → `UV_ENOENT`. Map empty to NULL so libuv
-        // inherits the parent cwd, matching `std.process.Child` semantics.
+        // inherits the parent cwd.
         uv_process_options.cwd = if options.cwd.is_empty() {
             core::ptr::null()
         } else {
@@ -1876,9 +1848,8 @@ mod spawn_process_body {
 
         let mut uv_files_to_close: Vec<uv::uv_file> = Vec::new();
 
-        // defer: close uv_files_to_close — handled at each return site below.
-        // PORT NOTE: Zig's `errdefer failed = true` + `defer { if (failed) ... }`
-        // pair is flattened to explicit cleanup calls at each error return; no
+        // defer: close uv_files_to_close — handled at each return site below
+        // via explicit cleanup calls at each error return; no
         // `failed` flag is needed.
 
         if let Some(hpcon) = options.pseudoconsole {
@@ -1915,8 +1886,6 @@ mod spawn_process_body {
         let mut dup_src: Option<u32> = None;
         let mut dup_tgt: Option<u32> = None;
 
-        // PORT NOTE: Zig uses `inline for (0..3)` for comptime fd_i; we use a runtime loop.
-        // PERF(port): was comptime monomorphization — profile if it shows up on a hot path.
         for fd_i in 0..3usize {
             let pipe_flags = uv::UV_CREATE_PIPE | uv::UV_READABLE_PIPE | uv::UV_WRITABLE_PIPE;
             let stdio: &mut uv::uv_stdio_container_t = &mut stdio_containers[fd_i];
@@ -1955,9 +1924,7 @@ mod spawn_process_body {
                     }
                     WindowsStdio::Path(path) => {
                         let mut req = uv::fs_t::uninitialized();
-                        // Zig: `defer { for (uv_files_to_close) |fd| Closer.close(fd) }`
-                        // covers EVERY exit path including `try toPosixPath`. Rust
-                        // replaced the defer with manual cleanup calls, so `?` here
+                        // Cleanup is via manual calls at each exit path, so `?` here
                         // would leak any fds opened by earlier loop iterations.
                         let path_z = match bun_sys::to_posix_path(path) {
                             Ok(p) => p,
@@ -2128,9 +2095,8 @@ mod spawn_process_body {
         unsafe {
             // SAFETY: all-zero is valid uv::Process
             (*process).poller = Poller::Uv(bun_core::ffi::zeroed_unchecked());
-            // Back-pointer for `on_exit_uv` / `on_close_uv` (replaces Zig
-            // `@fieldParentPtr`, which has no sound Rust equivalent for default-repr
-            // enum variant payloads). Every libuv handle starts with `data: *mut c_void`.
+            // Back-pointer for `on_exit_uv` / `on_close_uv`.
+            // Every libuv handle starts with `data: *mut c_void`.
             let Poller::Uv(ref mut uv_proc) = (*process).poller else {
                 unreachable!()
             };
@@ -2223,7 +2189,7 @@ mod spawn_process_body {
                         // SAFETY: stdio.data.stream is the same `*mut uv::Pipe`
                         // produced by `heap::alloc` in create_zeroed_pipe and
                         // stored in `options.{stdin,stdout,stderr}`. `WindowsStdio`
-                        // has no `Drop` (deinit is explicit, Zig spec), so
+                        // has no `Drop` (deinit is explicit), so
                         // reconstructing the Box here is the *sole* ownership
                         // transfer — the borrowed `options` dropping later is a
                         // no-op on the raw pointer.
@@ -2241,7 +2207,6 @@ mod spawn_process_body {
         for (i, input) in options.extra_fds.iter().enumerate() {
             match input {
                 WindowsStdio::Ipc(_) | WindowsStdio::Buffer(_) => {
-                    // PERF(port): was assume_capacity
                     // SAFETY: sole ownership transfer of the heap-allocated
                     // uv::Pipe; `WindowsStdio` has no Drop (explicit `deinit`).
                     result.extra_pipes.push(WindowsStdioResult::Buffer(unsafe {
@@ -2269,7 +2234,7 @@ mod spawn_process_body {
     pub mod sync {
         use super::*;
         // `Options.windows` is `WindowsOptions` on Windows; surface it under the
-        // `…::process::sync` path (the Zig namespace shape). A `pub use super::…`
+        // `…::process::sync` path. A `pub use super::…`
         // re-export trips E0365 here because the `use super::*` glob has already
         // bound the name privately and rustc treats the explicit re-export as
         // re-exporting that private binding; a type alias sidesteps the conflict.
@@ -2405,7 +2370,7 @@ mod spawn_process_body {
             pub chunks: Vec<Box<[u8]>>,
             /// Buffer handed to libuv by `on_alloc`; reclaimed (truncated) by
             /// `on_read`. Prevents the per-read leak that copying `data` into a
-            /// fresh Box would cause (Zig pushes the *same* allocation).
+            /// fresh Box would cause.
             pending_alloc: Option<Box<[u8]>>,
             pub pipe: Box<uv::Pipe>,
             pub err: bun_sys::E,
@@ -2431,7 +2396,7 @@ mod spawn_process_body {
             }
 
             fn on_read(this: &mut SyncWindowsPipeReader, data: &[u8]) {
-                // Zig: `chunks.append(@constCast(data))` — `data` *is* the buffer
+                // `data` *is* the buffer
                 // `on_alloc` returned, sliced to `nread`. Reclaim that allocation
                 // (debug-assert it's the same pointer), truncate to the read
                 // length, and push — no copy, no leak.
@@ -2452,13 +2417,10 @@ mod spawn_process_body {
             }
 
             // ── libuv C trampolines ──────────────────────────────────────────
-            // PORT NOTE: Zig's `StreamMixin.readStart` (libuv.zig:3067) takes
-            // `comptime alloc_cb / error_cb / read_cb` and emits one monomorphised
-            // `extern "C"` wrapper pair per (Context, callback-triple). Stable Rust
-            // can't take fn-pointers as const generics, but here there is exactly
+            // There is exactly
             // one call site, so we hand-write the wrapper pair against
             // `SyncWindowsPipeReader` and call `on_alloc` / `on_read` / `on_error`
-            // *directly* — no runtime fn-ptr stash, matching the Zig codegen.
+            // *directly* — no runtime fn-ptr stash.
             unsafe extern "C" fn uv_alloc_cb(
                 req: *mut uv::uv_handle_t,
                 suggested_size: usize,
@@ -2525,9 +2487,8 @@ mod spawn_process_body {
                 let context = this_ref.context;
                 // Move ownership of the chunk allocations out *before* dropping
                 // `this`, otherwise the callback would observe freed buffers.
-                // Mirrors Zig process.zig:2009-2011, where `destroy(this)` only
-                // frees the struct bytes and the ArrayList items survive to be
-                // freed later by `flattenOwnedChunks`.
+                // The chunk allocations survive to be freed later by
+                // `flatten_owned_chunks`.
                 let chunks: Vec<Box<[u8]>> = core::mem::take(&mut this_ref.chunks);
                 let err = if this_ref.err == bun_sys::E::CANCELED {
                     bun_sys::E::SUCCESS
@@ -2558,8 +2519,7 @@ mod spawn_process_body {
                         .read_start(Some(Self::uv_alloc_cb), Some(Self::uv_read_cb))
                         .to_error(bun_sys::Tag::listen)
                     {
-                        // Intentionally leak `this` (matches Zig process.zig, which has
-                        // no cleanup on this branch). The boxed `uv::Pipe` was already
+                        // Intentionally leak `this`. The boxed `uv::Pipe` was already
                         // `uv_pipe_init`'d by the spawn path and is linked into the
                         // loop's handle queue; freeing it here without `uv_close()`
                         // would leave a dangling `uv_handle_t`. The sole caller
@@ -2595,7 +2555,7 @@ mod spawn_process_body {
             pub stdout: Vec<Box<[u8]>>,
             pub err: bun_sys::E,
             pub waiting_count: u8,
-            /// Intrusive-refcounted (Zig: `*Process`). Allocated via
+            /// Intrusive-refcounted. Allocated via
             /// `heap::alloc` in `to_process`; freed when the embedded
             /// `ThreadSafeRefCount` hits zero. Stored raw — `Arc<Process>` would
             /// give only `*const` provenance and make `&mut *` writes UB.
@@ -2614,8 +2574,7 @@ mod spawn_process_body {
             /// (which holds a protector-guarded `&mut Process` in its frame).
             /// Re-deriving a `&mut Process` from the independent `self.process`
             /// root would pop that protected tag under Stacked Borrows, so we
-            /// take the already-live pointer instead. Mirrors Zig
-            /// `this.process.detach(); this.process.deref();` (process.zig:2037).
+            /// take the already-live pointer instead.
             pub fn on_process_exit(
                 this: *mut SyncWindowsProcess,
                 process: *mut Process,
@@ -2686,8 +2645,7 @@ mod spawn_process_body {
             let process: *mut Process = spawned.to_process((), true);
             let _detach_guard = scopeguard::guard(process, |process| {
                 // SAFETY: sole owner during sync spawn; loop has drained, so no
-                // uv callback holds a competing `&mut Process`. Mirrors Zig defer
-                // `{ process.detach(); process.deref(); }`.
+                // uv callback holds a competing `&mut Process`.
                 unsafe {
                     (*process).detach();
                     Process::deref(process);
@@ -2726,7 +2684,7 @@ mod spawn_process_body {
                     Err(err) => return Ok(Err(err)),
                     Ok(process) => process,
                 };
-            // Single-pointer ownership (mirrors Zig `bun.TrivialNew`): the
+            // Single-pointer ownership: the
             // `heap::alloc` result is the *only* root for this allocation. Every
             // field access below — including those inside uv callbacks fired from
             // `tick()` — goes through `this_ptr`, so no Box auto-deref ever
@@ -2742,9 +2700,7 @@ mod spawn_process_body {
                     status: None,
                 }));
             // SAFETY: `(*this_ptr).process` was just produced by `to_process` (sole
-            // owner, mutable provenance from heap::alloc). Mirrors Zig:
-            // `this.process.ref(); this.process.setExitHandler(this);
-            //  this.process.enableKeepingEventLoopAlive();`
+            // owner, mutable provenance from heap::alloc).
             unsafe {
                 let p = &mut *(*this_ptr).process;
                 p.ref_();
@@ -2817,7 +2773,7 @@ mod spawn_process_body {
                 }
             };
             // SAFETY: drop the ref taken above, then reclaim the SyncWindowsProcess
-            // allocation. Mirrors Zig `this.process.deref(); destroy(this);`.
+            // allocation.
             unsafe {
                 Process::deref((*this_ptr).process);
                 drop(bun_core::heap::take(this_ptr));
@@ -2846,8 +2802,8 @@ mod spawn_process_body {
         }
 
         pub fn spawn(options: &Options) -> core::result::Result<Maybe<Result>, bun_core::Error> {
-            // [*:null]?[*:0]const u8
-            // SAFETY: std.c.environ is the C environ array
+            // SAFETY: `bun_sys::environ_ptr` returns the live, NULL-terminated C
+            // `environ` array when no envp override is provided.
             let envp: *const *const c_char = options.envp.unwrap_or_else(bun_sys::environ_ptr);
             let argv = &options.argv;
             let mut string_builder = bun_core::StringBuilder::default();
@@ -2902,8 +2858,7 @@ mod spawn_process_body {
 
         /// RAII guard around `Bun__registerSignalsForForwarding`: registers on
         /// construction, unregisters and restores the crash-handler signal
-        /// disposition on drop. Replaces the Zig
-        /// `defer { Bun__unregisterSignalsForForwarding(); crash_handler.resetOnPosix(); }`.
+        /// disposition on drop.
         #[cfg(unix)]
         struct SignalForwarding;
         #[cfg(unix)]
@@ -2942,7 +2897,6 @@ mod spawn_process_body {
 
         #[cfg(unix)]
         unsafe extern "C" {
-            // TODO(port): move to runtime_sys
             // All by-value c_int/pid_t args; the kernel validates fd/pid/signal —
             // no memory-safety preconditions, so `safe fn` (Rust 2024) discharges
             // the link-time proof here and callers need no unsafe block.
@@ -3069,7 +3023,7 @@ mod spawn_process_body {
             // Snapshot pre-existing direct children so the disarm defer can tell
             // subreaper-adopted orphans (ppid==us) apart from `Bun.spawn` siblings
             // (also ppid==us). Typically empty — `bun run`/`bunx` have no JS VM —
-            // but spawnSync can run inside a live VM (ffi.zig xcrun probe).
+            // but spawnSync can run inside a live VM (the FFI xcrun probe).
             #[cfg(any(target_os = "linux", target_os = "android"))]
             let mut siblings_buf = [0 as libc::pid_t; 64];
             #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -3188,7 +3142,7 @@ mod spawn_process_body {
                     jc.restore();
                     // pgroup → tracked uniqueids (macOS). Do NOT call the
                     // getpid()-rooted `killDescendants()` here — `spawnSync` can be
-                    // reached from inside a live VM (ffi.zig xcrun probe, etc.) and
+                    // reached from inside a live VM (the FFI xcrun probe, etc.) and
                     // that would SIGKILL the user's unrelated `Bun.spawn` children.
                     // The full-tree walk runs from `onProcessExit` when the whole
                     // process is actually exiting.
@@ -3213,10 +3167,6 @@ mod spawn_process_body {
                     }
                 }
             });
-            // TODO(refactor): errdefer — the above scopeguards capture `jc`/`no_orphans_kq`/
-            // `siblings` by reference while still mutated below. Restructure into a single
-            // RAII state struct (or run cleanup inline at each return).
-
             Bun__sendPendingSignalIfNecessary();
 
             let mut out: [Vec<u8>; 2] = [Vec::new(), Vec::new()];
@@ -3225,8 +3175,8 @@ mod spawn_process_body {
                 process.stderr.unwrap_or(Fd::INVALID),
             ];
             let mut success = false;
-            // defer cleanup — handled at end / via guards below
-            // TODO(port): errdefer — manual cleanup at each error return below
+            // defer cleanup — handled at end / via guards below; error returns
+            // run their cleanup manually
 
             let mut out_fds_to_wait_for: [Fd; 2] = [
                 process.stdout.unwrap_or(Fd::INVALID),
@@ -3686,9 +3636,6 @@ mod spawn_process_body {
                 let restore = scopeguard::guard(old_mask, |old| {
                     libc::sigprocmask(libc::SIG_SETMASK, &raw const old, core::ptr::null_mut());
                 });
-                // TODO(port): kernel sigset_t vs libc sigset_t — Zig uses
-                // std.os.linux.sigemptyset/sigaddset for the signalfd mask. Could
-                // use the raw syscall with a u64 mask instead.
                 let fd = {
                     // SAFETY: POD, zero-valid — sigemptyset overwrites it immediately.
                     let mut kmask: libc::sigset_t = bun_core::ffi::zeroed();
@@ -3943,5 +3890,3 @@ pub use spawn_process_body::spawn_process_posix;
 pub use spawn_process_body::spawn_process_windows;
 
 pub use spawn_process_body::sync;
-
-// ported from: src/runtime/api/bun/process.zig
diff --git a/src/spawn/static_pipe_writer.rs b/src/spawn/static_pipe_writer.rs
index eb0e1bef6ea..1bed391aa04 100644
--- a/src/spawn/static_pipe_writer.rs
+++ b/src/spawn/static_pipe_writer.rs
@@ -15,9 +15,8 @@ bun_output::declare_scope!(StaticPipeWriter, hidden);
 
 /// Trait bound for the owning process type `P` of [`StaticPipeWriter`].
 ///
-/// Zig's `NewStaticPipeWriter(comptime ProcessType)` duck-types
-/// `process.onCloseIO(.stdin)`; in Rust we require this trait so the
-/// generic `BufferedWriter<StaticPipeWriter<P>>` field can satisfy its
+/// This trait lets the
+/// generic `BufferedWriter<StaticPipeWriter<P>>` field satisfy its
 /// `PosixBufferedWriterParent`/`WindowsBufferedWriterParent` bound for all `P`.
 ///
 /// Method takes `*mut Self` (not `&mut self`) because the writer is a field of
@@ -29,12 +28,9 @@ pub trait StaticPipeWriterProcess {
     unsafe fn on_close_io(this: *mut Self, kind: StdioKind);
 }
 
-/// Zig: `pub fn NewStaticPipeWriter(comptime ProcessType: type) type { return struct { ... } }`
-///
 /// Generic over the owning process type (e.g. `Subprocess`, `ShellSubprocess`).
 /// `P` must expose `fn on_close_io(&mut self, kind: StdioKind)`.
-// Zig: `const WriterRefCount = bun.ptr.RefCount(@This(), "ref_count", _deinit, .{});`
-// `_deinit` maps to `impl Drop` below; the final `bun.destroy` (Box free) is
+// Cleanup lives in `impl Drop` below; the final Box free is
 // the derive's default destructor (`drop(heap::take(this))`).
 #[derive(bun_ptr::RefCounted)]
 pub struct StaticPipeWriter<P: StaticPipeWriterProcess> {
@@ -49,25 +45,19 @@ pub struct StaticPipeWriter<P: StaticPipeWriterProcess> {
     /// True while `start()`'s `+1` ref is outstanding.
     pub started: bool,
     /// Slice into `self.source`'s storage, advanced as bytes are written.
-    // TODO(refactor): self-borrow into `self.source`; consider storing an
-    // offset+len pair and re-slicing from `self.source` instead of a raw self-pointer.
-    // `RawSlice` (typed `*const [u8]` with safe `.slice()`) replaces the raw fat
-    // pointer so the per-access unsafe derefs are gone; the backing storage
-    // (`self.source`) outlives `self` by construction.
+    ///
+    /// Self-borrow invariant: this aliases `self.source`'s storage, which
+    /// outlives `self` by construction; every path that detaches/frees the
+    /// source (`on_error`, `on_close`, `Drop`) must reset this to
+    /// `RawSlice::EMPTY` first. `RawSlice` (typed `*const [u8]` with safe
+    /// `.slice()`) keeps the per-access unsafe derefs out of the call sites.
     pub buffer: RawSlice<u8>,
 }
 
-// Zig: `const print = bun.Output.scoped(.StaticPipeWriter, .visible);`
-// NOTE: `print` is declared but never used in the Zig source; the file-level
-// `log` (hidden) is what's actually called. We declare a single hidden scope above.
-
-/// Zig: `pub const IOWriter = bun.io.BufferedWriter(@This(), struct { ... })`
-///
-/// The Zig callback-struct (`onWritable = null`, `getBuffer`, `onClose`, `onError`,
-/// `onWrite`) maps to a handler trait that `StaticPipeWriter<P>` implements; the
+/// The writer's callbacks (`getBuffer`, `onClose`, `onError`, `onWrite`) map
+/// to a handler trait that `StaticPipeWriter<P>` implements; the
 /// inherent methods below are the callback bodies.
 pub type IOWriter<P> = BufferedWriter<StaticPipeWriter<P>>;
-/// Zig: `pub const Poll = IOWriter;`
 pub type Poll<P> = IOWriter<P>;
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -122,12 +112,8 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
         }
     }
 
-    /// Zig: `pub fn create(event_loop: anytype, subprocess: *ProcessType, result: StdioResult, source: Source) *This`
-    ///
-    /// PORT NOTE: Zig's `anytype` dispatched on type (`EventLoopHandle`,
-    /// `*VirtualMachine`, `*MiniEventLoop`) inside `EventLoopHandle.init`. The
-    /// Rust port splits that into separate overloads, so callers resolve to an
-    /// `EventLoopHandle` before calling and we accept it directly.
+    /// Callers resolve to an `EventLoopHandle` before calling and we accept
+    /// it directly.
     pub fn create(
         event_loop: EventLoopHandle,
         subprocess: *mut P,
@@ -148,10 +134,9 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
         let this_ref = unsafe { &mut *this };
         #[cfg(windows)]
         {
-            // Zig: `this.writer.setPipe(this.stdio_result.buffer)` — on Windows
-            // `StdioResult` is the `WindowsStdioResult` union and Zig reads the
-            // `.buffer` field unchecked (caller invariant). Enforce that
-            // invariant here: any other arm is a logic bug, not a silent no-op.
+            // On Windows `StdioResult` is the `WindowsStdioResult` union and
+            // the caller invariant is that the `Buffer` arm is set. Enforce
+            // that here: any other arm is a logic bug, not a silent no-op.
             // Ownership of the boxed `uv::Pipe` transfers into the writer's
             // `Source::Pipe`, so we move it out (replacing with `Unavailable`)
             // and `heap::alloc` it (set_pipe re-wraps via `heap::take`).
@@ -178,10 +163,10 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
             "StaticPipeWriter(0x{:x}) start()",
             std::ptr::from_ref(self) as usize
         );
-        // Zig `this.ref()` — intrusive-refcount increment.
+        // Intrusive-refcount increment.
         // SAFETY: `self` is a live `Self` (created via `create()`/`heap::alloc`).
         unsafe { RefCount::<Self>::ref_(std::ptr::from_mut::<Self>(self)) };
-        // TODO(port): self-borrow — see `buffer` field note.
+        // Self-borrow into `self.source` — see `buffer` field invariant.
         self.buffer = RawSlice::new(self.source.slice());
         #[cfg(windows)]
         {
@@ -199,7 +184,7 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
         }
         #[cfg(not(windows))]
         {
-            // Zig: `this.stdio_result.?` — on POSIX `StdioResult` is `?bun.FD`.
+            // On POSIX `StdioResult` is an `Option<Fd>`.
             match self.writer.start(self.stdio_result.unwrap(), true) {
                 bun_sys::Result::Err(err) => {
                     // start() failed: `started` stays false so no release
@@ -214,8 +199,7 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
                     self.started = true;
                     #[cfg(unix)]
                     {
-                        // Zig: `const poll = this.writer.handle.poll; poll.flags.insert(.socket);`
-                        // `handle` is `PollOrFd` (enum) in Rust; flag mutation goes
+                        // `handle` is `PollOrFd` (enum); flag mutation goes
                         // through the FilePoll vtable shim.
                         if let Some(poll) = self.writer.handle.get_poll() {
                             poll.set_flag(bun_io::FilePollFlag::Socket);
@@ -309,13 +293,14 @@ impl<P: StaticPipeWriterProcess> StaticPipeWriter<P> {
     }
 }
 
-/// Zig: `fn _deinit(this: *This) void` — the `RefCount` destructor callback.
-/// `bun.destroy(this)` (the heap free) is handled by `IntrusiveRc` after `drop` returns.
+/// The `RefCount` destructor callback.
+/// The heap free is handled by `IntrusiveRc` after `drop` returns.
 impl<P: StaticPipeWriterProcess> Drop for StaticPipeWriter<P> {
     fn drop(&mut self) {
         self.writer.end();
+        // `buffer` aliases `self.source`'s storage; clear it before detach()
+        // frees that storage (upholds the field's documented invariant).
+        self.buffer = RawSlice::EMPTY;
         self.source.detach();
     }
 }
-
-// ported from: src/runtime/api/bun/subprocess/StaticPipeWriter.zig
diff --git a/src/spawn_sys/lib.rs b/src/spawn_sys/lib.rs
index d23ca3c9b41..83d0e5511d7 100644
--- a/src/spawn_sys/lib.rs
+++ b/src/spawn_sys/lib.rs
@@ -26,7 +26,6 @@ use core::ffi::c_char;
 // ──────────────────────────────────────────────────────────────────────────
 
 /// posix_spawn(2) FFI wrappers (Actions / Attr / spawn_z / wait4).
-/// Port of `src/runtime/api/bun/spawn.zig`.
 #[path = "posix_spawn.rs"]
 pub mod posix_spawn;
 
@@ -36,7 +35,7 @@ pub mod posix_spawn;
 pub mod spawn_process;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Canonical FFI type aliases — Zig `?[*:0]const u8` ↔ Rust `*const c_char`
+// Canonical FFI type aliases for nullable C-string pointers (`*const c_char`)
 //
 // **Never** spell these as `Option<*const c_char>`: raw pointers are already
 // nullable, and `Option<*const T>` does *not* enjoy the null-pointer-niche
@@ -148,8 +147,7 @@ pub mod pdeathsig {
     static INSTALL_THREAD: OnceLock<ThreadId> = OnceLock::new();
 
     /// Arm the default. Records the calling thread so `should_default` only
-    /// returns `true` for spawns issued from that thread (matches Zig
-    /// `ParentDeathWatchdog` semantics). Idempotent.
+    /// returns `true` for spawns issued from that thread. Idempotent.
     pub fn set_default(enabled: bool) {
         if enabled {
             let _ = INSTALL_THREAD.set(std::thread::current().id());
diff --git a/src/spawn_sys/posix_spawn.rs b/src/spawn_sys/posix_spawn.rs
index 1892dec3789..3ea3a40570b 100644
--- a/src/spawn_sys/posix_spawn.rs
+++ b/src/spawn_sys/posix_spawn.rs
@@ -13,16 +13,15 @@ use bun_core::{Error, err};
 use bun_sys as sys;
 use bun_sys::Fd;
 
-// `std.posix.system` — `bun_sys::c` only re-exports a thin slice of libc
+// `bun_sys::c` only re-exports a thin slice of libc
 // (no `posix_spawn*`/`waitpid`/`wait4`). Use the `libc` crate directly here;
 // `bun_sys::c` can re-export these later and this `use` swaps back.
-// TODO(port): swap to `bun_sys::c as system` once it forwards posix_spawn.
 #[cfg(unix)]
 use libc as system;
 
 // ── Darwin spawn extensions missing from the `libc` crate ────────────────
-// Values/signatures match <spawn.h> on macOS 14 SDK; Zig's translate-c picks
-// these up via `bun.c`, but the Rust `libc` crate omits the `_np` variants.
+// Values/signatures match <spawn.h> on macOS 14 SDK; the `libc` crate omits
+// the `_np` variants.
 #[cfg(target_os = "macos")]
 mod darwin_spawn_np {
     use core::ffi::{c_char, c_int};
@@ -41,16 +40,15 @@ mod darwin_spawn_np {
     }
 }
 
-// `std.posix.{errno, fd_t, mode_t, pid_t, toPosixPath, unexpectedErrno}` —
 // `bun_sys::posix` currently exposes only `mode_t`/`S`/`E`/`errno()` (the
 // MOVE_DOWN stub from `bun_errno`). Shim the remainder locally so this file
 // is self-contained; delete in favour of `bun_sys::posix::*` once that module
 // widens.
 #[cfg(unix)]
 use self::posix_compat::{Errno, errno};
-use self::posix_compat::{fd_t, pid_t, to_posix_path};
 #[cfg(target_os = "macos")]
-use self::posix_compat::{mode_t, unexpected_errno};
+use self::posix_compat::{errno_from_posix_spawn, mode_t, unexpected_errno};
+use self::posix_compat::{fd_t, pid_t, to_posix_path};
 
 #[allow(non_camel_case_types)]
 mod posix_compat {
@@ -59,13 +57,13 @@ mod posix_compat {
     use core::ffi::c_int;
     use std::ffi::CString;
 
-    /// `std.posix.fd_t` — native fd backing int.
+    /// Native fd backing int.
     // posix_spawn file actions use libc `int` fds on the C side
     // (`posix_spawn_bun.cpp`). On POSIX `FdNative == c_int`; on Windows
     // `FdNative` is HANDLE, but this code path is unreachable there — keep
     // the C-ABI type so the struct compiles unchanged.
     pub(super) type fd_t = core::ffi::c_int;
-    /// `std.posix.pid_t`.
+    /// Native process id type.
     #[cfg(unix)]
     pub(super) type pid_t = libc::pid_t;
     #[cfg(not(unix))]
@@ -73,7 +71,7 @@ mod posix_compat {
     #[cfg(target_os = "macos")]
     pub(super) use bun_sys::posix::mode_t;
 
-    /// `std.posix.E` — errno enum with **unprefixed** variant names. The real
+    /// Errno enum with **unprefixed** variant names. The real
     /// `bun_errno::posix::E` aliases `SystemErrno` (E-prefixed); local newtype
     /// keeps the body's `Errno::SUCCESS`/`NOMEM`/... matches intact.
     #[cfg(unix)]
@@ -93,12 +91,10 @@ mod posix_compat {
         pub(super) const NAMETOOLONG: Errno = Errno(libc::ENAMETOOLONG);
         pub(super) const INTR: Errno = Errno(libc::EINTR);
     }
-    /// `std.posix.errno(rc)` — Zig: with libc, `rc == -1 ⇒ read __errno`,
-    /// else `.SUCCESS`. The `posix_spawn*` family instead returns the errno
-    /// **directly** (0 on success). This helper conflates both call
-    /// conventions to match the .zig source 1:1; see TODO(port) below.
-    // TODO(port): split into `errno_from_posix_spawn(rc)` (rc IS errno) vs
-    // `errno_from_ret(rc)` (rc == -1 ⇒ read libc errno) and route call sites.
+    /// Decode a syscall return: with libc, `rc == -1 ⇒ read __errno`,
+    /// else `.SUCCESS`. For syscalls using the conventional return style
+    /// (`wait4`, etc.) — NOT for `posix_spawn*`, which returns the errno
+    /// directly; use [`errno_from_posix_spawn`] there.
     #[cfg(unix)]
     #[inline]
     pub(super) fn errno(rc: c_int) -> Errno {
@@ -108,12 +104,20 @@ mod posix_compat {
         Errno::SUCCESS
     }
 
-    /// `std.posix.toPosixPath` — copy into a NUL-terminated buffer.
+    /// The `posix_spawn*` family returns the errno **directly** (0 on
+    /// success, nonzero errno on failure — never -1/`__errno`).
+    #[cfg(target_os = "macos")]
+    #[inline]
+    pub(super) fn errno_from_posix_spawn(rc: c_int) -> Errno {
+        Errno(rc)
+    }
+
+    /// Copy a path into a NUL-terminated buffer.
     pub(super) fn to_posix_path(path: &[u8]) -> Result<CString, Error> {
         CString::new(path).map_err(|_| err!("Unexpected"))
     }
 
-    /// `std.posix.unexpectedErrno` — Zig logs + returns `error.Unexpected`.
+    /// Returns an "Unexpected" error for an errno we don't handle.
     #[cfg(target_os = "macos")]
     pub(super) fn unexpected_errno(_e: Errno) -> Error {
         err!("Unexpected")
@@ -161,7 +165,6 @@ pub mod bun_spawn {
 
     impl Actions {
         pub fn init() -> Result<Actions, Error> {
-            // TODO(port): narrow error set
             Ok(Actions::default())
         }
 
@@ -211,8 +214,8 @@ pub mod bun_spawn {
         }
 
         pub fn chdir(&mut self, path: &[u8]) -> Result<(), Error> {
-            // previous buffer (if any) is dropped by assignment
-            // TODO(port): CString::new rejects interior NUL; Zig dupeZ did not check
+            // previous buffer (if any) is dropped by assignment.
+            // CString::new errors on interior NUL.
             self.chdir_buf = Some(CString::new(path).map_err(|_| err!("Unexpected"))?);
             Ok(())
         }
@@ -230,7 +233,7 @@ pub mod bun_spawn {
     }
 
     impl Default for Attr {
-        // Must match Zig field defaults (spawn.zig Attr): `pty_slave_fd: i32 = -1`.
+        // `pty_slave_fd` must default to `-1`.
         // `#[derive(Default)]` would yield `0` (stdin), which makes `spawn_z` take
         // the PTY path and call setsid()+ioctl(TIOCSCTTY, 0) in the child.
         fn default() -> Self {
@@ -255,11 +258,10 @@ pub mod bun_spawn {
         pub(crate) fn set(&mut self, flags: u16) -> Result<(), Error> {
             self.flags = flags;
             // FreeBSD's <spawn.h> has no POSIX_SPAWN_SETSID; bun-spawn.cpp
-            // calls setsid() in the child for `detached`, which process.zig
-            // sets directly on this struct BEFORE calling set(). Preserve
-            // that value when the flag bit isn't available.
-            // TODO(port): Zig used `@hasDecl(bun.c, "POSIX_SPAWN_SETSID")`; approximated
-            // here as unix-not-freebsd. Should use a build-time cfg from bindgen.
+            // calls setsid() in the child for `detached`, which the spawn
+            // path sets directly on this struct BEFORE calling set(). Preserve
+            // that value when the flag bit isn't available. (The platforms
+            // that define it are enumerated explicitly.)
             #[cfg(any(target_os = "linux", target_os = "android"))]
             {
                 // glibc/musl/bionic <spawn.h> all define POSIX_SPAWN_SETSID as 0x80;
@@ -282,7 +284,6 @@ pub mod bun_spawn {
     }
 }
 
-// mostly taken from zig's posix_spawn.zig
 pub mod posix_spawn {
     #[cfg(unix)]
     use super::bun_spawn;
@@ -338,7 +339,7 @@ pub mod posix_spawn {
         pub fn init() -> Result<PosixSpawnAttr, Error> {
             let mut attr = core::mem::MaybeUninit::<system::posix_spawnattr_t>::uninit();
             // SAFETY: posix_spawnattr_init writes into attr on SUCCESS
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawnattr_init(attr.as_mut_ptr())
             }))?;
             Ok(PosixSpawnAttr {
@@ -350,11 +351,10 @@ pub mod posix_spawn {
         }
 
         pub fn set(&mut self, flags: u16) -> Result<(), Error> {
-            // Zig: `@as(c_short, @bitCast(flags))` — `as` between same-width
-            // signed/unsigned is the bitcast.
+            // `as` between same-width signed/unsigned is a bitcast.
             let flags_s: c_short = flags as c_short;
             // SAFETY: self.attr is a live posix_spawnattr_t
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawnattr_setflags(&raw mut self.attr, flags_s)
             }))
         }
@@ -376,7 +376,7 @@ pub mod posix_spawn {
         }
     }
 
-    // TODO(port): move to runtime_sys
+    // Implemented in src/jsc/bindings/spawn.cpp.
     #[cfg(target_os = "macos")]
     unsafe extern "C" {
         fn posix_spawnattr_reset_signals(attr: *mut system::posix_spawnattr_t) -> c_int;
@@ -393,7 +393,7 @@ pub mod posix_spawn {
             let mut actions =
                 core::mem::MaybeUninit::<system::posix_spawn_file_actions_t>::uninit();
             // SAFETY: posix_spawn_file_actions_init writes into actions on SUCCESS
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawn_file_actions_init(actions.as_mut_ptr())
             }))?;
             Ok(PosixSpawnActions {
@@ -409,10 +409,9 @@ pub mod posix_spawn {
             flags: u32,
             mode: mode_t,
         ) -> Result<(), Error> {
-            // Zig: `@as(c_int, @bitCast(flags))`
             let flags_c: c_int = flags as c_int;
             // SAFETY: self.actions is live; path is NUL-terminated
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawn_file_actions_addopen(
                     &raw mut self.actions,
                     fd.native(),
@@ -425,7 +424,7 @@ pub mod posix_spawn {
 
         pub(crate) fn close(&mut self, fd: Fd) -> Result<(), Error> {
             // SAFETY: self.actions is live
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawn_file_actions_addclose(&raw mut self.actions, fd.native())
             }))
         }
@@ -436,7 +435,7 @@ pub mod posix_spawn {
             }
 
             // SAFETY: self.actions is live
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 system::posix_spawn_file_actions_adddup2(
                     &raw mut self.actions,
                     fd.native(),
@@ -447,7 +446,7 @@ pub mod posix_spawn {
 
         pub(crate) fn inherit(&mut self, fd: Fd) -> Result<(), Error> {
             // SAFETY: self.actions is live
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 super::darwin_spawn_np::posix_spawn_file_actions_addinherit_np(
                     &raw mut self.actions,
                     fd.native(),
@@ -463,7 +462,7 @@ pub mod posix_spawn {
         // deliberately not pub
         fn chdir_z(&mut self, path: &CStr) -> Result<(), Error> {
             // SAFETY: self.actions is live; path is NUL-terminated
-            spawn_errno(errno(unsafe {
+            spawn_errno(errno_from_posix_spawn(unsafe {
                 super::darwin_spawn_np::posix_spawn_file_actions_addchdir_np(
                     &raw mut self.actions,
                     path.as_ptr(),
@@ -486,9 +485,8 @@ pub mod posix_spawn {
     pub(crate) type Actions = bun_spawn::Actions;
     #[cfg(unix)]
     pub(crate) type Attr = bun_spawn::Attr;
-    // TODO(port): not(unix) Actions/Attr aliased PosixSpawn* in the Zig
-    // draft, but Windows goes through `process.rs::spawn_process_windows`
-    // (libuv), never these. Leave undeclared on Windows for now.
+    // No not(unix) Actions/Attr aliases: Windows goes through
+    // `process.rs::spawn_process_windows` (libuv) and never reaches these.
 
     // The #[repr(C)] request mirrors + extern decl live in `bun_core::spawn_ffi`
     // (single source of truth for bun-spawn.cpp's `bun_spawn_request_t`). The
@@ -510,7 +508,7 @@ pub mod posix_spawn {
         // SAFETY: path is NUL-terminated; argv/envp are NULL-terminated arrays of C strings
         let rc =
             unsafe { posix_spawn_bun(&raw mut pid, path.as_ptr(), &raw const req, argv, envp) };
-        let _ = &mut req; // keep req alive across the call (matches Zig taking &req of a local copy)
+        let _ = &mut req; // keep req alive across the call
 
         if cfg!(debug_assertions) {
             // SAFETY: argv has at least one element (the NULL terminator)
@@ -544,7 +542,7 @@ pub mod posix_spawn {
             }
         };
         sys::Result::Err(sys::Error {
-            // @truncate(@intFromEnum(@as(std.c.E, @enumFromInt(rc))))
+            // posix_spawn* returns the errno value directly.
             errno: rc as sys::ErrorInt,
             syscall: SYSCALL_POSIX_SPAWN,
             path: arg0.into(),
@@ -573,11 +571,6 @@ pub mod posix_spawn {
             || cfg!(target_os = "freebsd")
             || (cfg!(target_os = "macos") && pty_slave_fd >= 0);
 
-        // TODO(port): cfg-gate platform-only field access — the body below touches
-        // bun_spawn::Actions/Attr fields that don't exist on the not(unix) Actions/Attr
-        // alias; cfg!() above keeps both arms in the type-checker. May need to
-        // restructure (linux/freebsd fall-through after this block is statically
-        // unreachable but rustc can't prove it from the runtime `use_bun_spawn` bool).
         #[cfg(unix)]
         if use_bun_spawn {
             return spawn_bun(
@@ -813,8 +806,8 @@ pub mod posix_spawn {
     ) -> sys::Result<WaitPidResult> {
         type PidStatus = c_int;
         let mut status: PidStatus = 0;
-        // PORT NOTE: reshaped for borrowck — Zig passes the same `?*Rusage` every loop
-        // iteration via @ptrCast(usage); convert once to a raw ptr that is Copy.
+        // Convert the `Option<&mut Rusage>` once to a raw pointer (which is
+        // Copy) so the retry loop can pass it on every iteration.
         let usage_ptr: *mut system::rusage = match usage {
             Some(u) => std::ptr::from_mut::<process::Rusage>(u).cast(),
             None => ptr::null_mut(),
@@ -852,5 +845,3 @@ pub mod posix_spawn {
 
 #[cfg(unix)]
 use crate::spawn_process as process;
-
-// ported from: src/runtime/api/bun/spawn.zig
diff --git a/src/spawn_sys/spawn_process.rs b/src/spawn_sys/spawn_process.rs
index 1f26dd5de98..30683346363 100644
--- a/src/spawn_sys/spawn_process.rs
+++ b/src/spawn_sys/spawn_process.rs
@@ -39,14 +39,13 @@ pub type FdT = i32;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub type PidFdType = FdT;
 #[cfg(not(any(target_os = "linux", target_os = "android")))]
-pub type PidFdType = (); // u0 in Zig
+pub type PidFdType = ();
 
 // ──────────────────────────────────────────────────────────────────────────
 // Rusage — platform-uniform resource-usage struct
 //
-// One Bun-level type per target, mirroring Zig's `bun.spawn.Rusage`
-// (process.zig:72-97). On every Unix this is `libc::rusage` — Rust's libc
-// crate, unlike Zig's `std.posix`, *does* define `rusage` on FreeBSD with
+// One Bun-level type per target. On every Unix this is `libc::rusage` —
+// the libc crate defines `rusage` on FreeBSD with
 // the standard `ru_*` field names, so no hand-rolled FreeBSD struct is
 // needed. On Windows it is the value-typed `WinRusage` below (NOT
 // `uv_rusage_t` — that is vendor FFI ABI in `bun_libuv_sys` and stays
@@ -65,10 +64,10 @@ pub struct WinRusage {
     pub utime: WinTimeval,
     pub stime: WinTimeval,
     pub maxrss: u64,
-    // ixrss, idrss, isrss, minflt, majflt, nswap: u0 in Zig — zero-sized, omitted
+    // ixrss, idrss, isrss, minflt, majflt, nswap: always zero — omitted
     pub inblock: u64,
     pub oublock: u64,
-    // msgsnd, msgrcv, nsignals, nvcsw, nivcsw: u0 in Zig — zero-sized, omitted
+    // msgsnd, msgrcv, nsignals, nvcsw, nivcsw: always zero — omitted
 }
 
 pub type IoCounters = bun_windows_sys::IO_COUNTERS;
@@ -109,13 +108,12 @@ pub fn uv_getrusage(process: &mut bun_libuv_sys::uv_process_t) -> WinRusage {
     } != 0
     {
         // FILETIME is in 100-nanosecond ticks. 1 s = 10_000_000 ticks; 1 µs =
-        // 10 ticks. The Zig spec (process.zig:53) computes the sub-second part
-        // as `temp % 1_000_000`, which is unit-mismatched: it takes a 100-ns
-        // tick count modulo a microsecond denominator, so a 178 125 µs run
-        // (1_781_250 ticks) reports as 781_250 µs. That over-report is what
-        // tips the "does not use 100% cpu > install" test (`cpuTime.total <
-        // 750_000`) on Windows aarch64. Diverge from spec and convert
-        // correctly: `(ticks % 10_000_000) / 10`.
+        // 10 ticks. A `temp % 1_000_000` computation here would be
+        // unit-mismatched (a 100-ns tick count modulo a microsecond
+        // denominator): a 178 125 µs run (1_781_250 ticks) would report as
+        // 781_250 µs, which is what tips the "does not use 100% cpu >
+        // install" test (`cpuTime.total < 750_000`) on Windows aarch64.
+        // Convert correctly: `(ticks % 10_000_000) / 10`.
         let mut temp: u64 =
             ((kerneltime.dwHighDateTime as u64) << 32) | kerneltime.dwLowDateTime as u64;
         if temp > 0 {
@@ -157,8 +155,8 @@ pub fn rusage_zeroed() -> Rusage {
 
 /// Platform-uniform field accessors over [`Rusage`]. The underlying alias has
 /// divergent field names (`ru_*` on every Unix `libc::rusage`; bare names on
-/// `WinRusage` with several `u0`/absent counters). This trait gives JS-facing
-/// getters one cfg-free body, matching the Zig spec's uniform names.
+/// `WinRusage` with several always-zero/absent counters). This trait gives
+/// JS-facing getters one cfg-free body with uniform names.
 pub trait RusageFields {
     fn utime_sec(&self) -> i64;
     fn utime_usec(&self) -> i64;
@@ -259,7 +257,7 @@ impl RusageFields for WinRusage {
     fn maxrss_(&self) -> f64 {
         self.maxrss as f64
     }
-    // Zig declares these as `u0` on Windows — always zero.
+    // These counters do not exist on Windows — always zero.
     #[inline]
     fn ixrss_(&self) -> f64 {
         0.0
@@ -369,7 +367,7 @@ impl Default for PosixSpawnOptions {
 }
 
 impl PosixSpawnOptions {
-    /// No-op — matches Zig `PosixSpawnOptions.deinit` (process.zig:1104).
+    /// No-op.
     /// Exists for cfg-parity with `WindowsSpawnOptions::deinit`, which closes
     /// heap-allocated `uv::Pipe` handles on the spawn error path.
     #[inline]
@@ -487,12 +485,14 @@ impl PosixSpawnResult {
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
     fn pidfd_flags_for_linux() -> u32 {
-        // pidfd_nonblock only supported in 5.10+. The Zig path consults
-        // `analytics.kernel_version()` (semver compare); until that helper is
-        // ported, optimistically request NONBLOCK and rely on the EINVAL retry
-        // below to fall back on older kernels.
-        // TODO(port): wire bun_analytics::kernel_version() once available.
-        bun_sys::O::NONBLOCK as u32
+        // PIDFD_NONBLOCK is only supported on kernel 5.10+ (the EINVAL retry
+        // in `pifd_from_pid` still covers misdetection by retrying with 0).
+        let kernel = bun_core::linux_kernel_version();
+        if (kernel.major, kernel.minor) >= (5, 10) {
+            bun_sys::O::NONBLOCK as u32
+        } else {
+            0
+        }
     }
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -573,29 +573,25 @@ impl PosixSpawnResult {
 // spawn_process_posix — the fd/action plumbing + posix_spawn call
 // ──────────────────────────────────────────────────────────────────────────
 
-// Apple `<spawn.h>` extensions not exported by the `libc` crate (Zig: `bun.c.*`).
+// Apple `<spawn.h>` extensions not exported by the `libc` crate.
 #[cfg(target_os = "macos")]
 pub(crate) const POSIX_SPAWN_CLOEXEC_DEFAULT: i32 = 0x4000; // _POSIX_SPAWN_CLOEXEC_DEFAULT
 #[cfg(target_os = "macos")]
 pub(crate) const POSIX_SPAWN_SETEXEC: i32 = 0x0040; // POSIX_SPAWN_SETEXEC
 
-/// RAII fd cleanup matching the Zig `defer` (process.zig:1393-1403) and
-/// `errdefer` (process.zig:1407-1411) in `spawnProcessPosix`. The `defer`
-/// runs on *every* exit (set CLOEXEC on `to_set_cloexec`, then close
-/// `to_close_at_end`); the `errdefer` additionally closes `to_close_on_error`
-/// on error returns. `on_error` is disarmed on the success path.
+/// RAII fd cleanup for `spawn_process_posix`. On *every* exit it sets
+/// CLOEXEC on `to_set_cloexec`, then closes `to_close_at_end`; on error
+/// returns it additionally closes `to_close_on_error`. `on_error` is
+/// disarmed on the success path.
 ///
 /// This exists so that bare `?` on `actions.*` propagates without leaking
 /// the parent-side socketpair ends pushed earlier in the loop.
 ///
-/// PORT NOTE (intentional divergence): Zig's `errdefer` only fires on
-/// error-union returns (`try` failures), *not* on `return .{.err = ..}` value
-/// returns — so in the spec, socketpair/set_nonblocking/spawn_z value-error
-/// paths leak `to_close_on_error`. This guard initializes `on_error = true`
-/// and is only disarmed after `spawn_z` succeeds, deliberately widening the
-/// cleanup to cover those value-error returns as well. The fds in
-/// `to_close_on_error` are parent-side ends never handed back to the caller on
-/// any error path, so closing them is the correct behavior.
+/// The guard initializes `on_error = true` and is only disarmed after
+/// `spawn_z` succeeds, so socketpair/set_nonblocking/spawn_z value-error
+/// returns (`return Ok(Err(..))`) are covered as well as `?` failures. The
+/// fds in `to_close_on_error` are parent-side ends never handed back to the
+/// caller on any error path, so closing them is the correct behavior.
 #[cfg(unix)]
 struct PosixSpawnFdGuard {
     to_set_cloexec: Vec<Fd>,
@@ -711,9 +707,7 @@ pub unsafe fn spawn_process_posix(
     }
     let mut spawned = PosixSpawnResult::default();
     let mut extra_fds: Vec<ExtraPipe> = Vec::new();
-    // errdefer extra_fds.deinit() — Vec drops on ?
-    // PERF(port): was stack-fallback allocator (2048)
-    // Zig `defer` + `errdefer` cleanup → owned by an RAII guard so every `?`
+    // Cleanup is owned by an RAII guard so every `?`
     // (and every explicit `return Ok(Err(..))`) runs it. See PosixSpawnFdGuard.
     let mut cleanup = PosixSpawnFdGuard {
         to_set_cloexec: Vec::new(),
@@ -731,8 +725,8 @@ pub unsafe fn spawn_process_posix(
     }
 
     let stdio_options: [&PosixStdio; 3] = [&options.stdin, &options.stdout, &options.stderr];
-    // PORT NOTE: reshaped for borrowck — Zig holds [3]*?bun.FD into spawned;
-    // we index spawned.{stdin,stdout,stderr} via a helper closure instead.
+    // Reshaped for borrowck: we
+    // index spawned.{stdin,stdout,stderr} via a helper closure.
     let mut dup_stdout_to_stderr: bool = false;
 
     // The label is only referenced from the Linux memfd fast-path below.
diff --git a/src/sql/lib.rs b/src/sql/lib.rs
index 7856b816912..23d7875262b 100644
--- a/src/sql/lib.rs
+++ b/src/sql/lib.rs
@@ -94,9 +94,8 @@ pub mod mysql {
         pub mod stmt_prepare_ok_packet;
 
         // ── flat re-exports for `bun_sql_jsc` ──────────────────────────────
-        // sql_jsc names most of these via `bun_sql::mysql::protocol::Foo`
-        // (mirroring Zig's flat `MySQLProtocol.zig` namespace), so surface
-        // them here as well as via their leaf modules.
+        // sql_jsc names most of these via `bun_sql::mysql::protocol::Foo`,
+        // so surface them here as well as via their leaf modules.
         pub use any_mysql_error::{AnyMySQLError, Error};
         pub use auth_switch_request::AuthSwitchRequest;
         pub use auth_switch_response::AuthSwitchResponse;
@@ -115,7 +114,7 @@ pub mod mysql {
         pub use ssl_request::SSLRequest;
         pub use stack_reader::StackReader;
         pub use stmt_prepare_ok_packet::StmtPrepareOKPacket;
-        // `protocol::FieldType` (Zig re-export of mysql_types.FieldType).
+        // `protocol::FieldType` (re-export of mysql_types.FieldType).
         pub use crate::mysql::mysql_types::FieldType;
     }
 
@@ -243,9 +242,8 @@ pub mod postgres {
     pub use tls_status::TLSStatus;
     pub use types::tag::Tag;
 
-    // PascalCase module aliases — Zig callers used `PostgresProtocol.Foo` /
-    // `PostgresTypes.Int4` / `SocketMonitor.write` directly; sql_jsc still
-    // names them that way.
+    // PascalCase module aliases — sql_jsc names these as `PostgresProtocol.Foo` /
+    // `PostgresTypes.Int4` / `SocketMonitor.write`.
     pub use postgres_protocol as PostgresProtocol;
     pub use postgres_types as PostgresTypes;
     pub use socket_monitor as SocketMonitor;
diff --git a/src/sql/mysql/AuthMethod.rs b/src/sql/mysql/AuthMethod.rs
index 250b1782587..7b74ea22553 100644
--- a/src/sql/mysql/AuthMethod.rs
+++ b/src/sql/mysql/AuthMethod.rs
@@ -13,7 +13,6 @@ impl AuthMethod {
         auth_data: &[u8],
         buf: &'a mut [u8; 32],
     ) -> Result<&'a mut [u8], bun_core::Error> {
-        // TODO(port): narrow error set
         if password.is_empty() {
             return Ok(&mut []);
         }
@@ -52,11 +51,9 @@ impl AuthMethod {
     }
 }
 
-// bun.ComptimeEnumMap(AuthMethod) — keys are exactly the Zig @tagName variant names
+// Keys are exactly the wire-protocol plugin names.
 static MAP: phf::Map<&'static [u8], AuthMethod> = phf::phf_map! {
     b"mysql_native_password" => AuthMethod::MysqlNativePassword,
     b"caching_sha2_password" => AuthMethod::CachingSha2Password,
     b"sha256_password" => AuthMethod::Sha256Password,
 };
-
-// ported from: src/sql/mysql/AuthMethod.zig
diff --git a/src/sql/mysql/Capabilities.rs b/src/sql/mysql/Capabilities.rs
index b6ea941bb99..7d91fc866d6 100644
--- a/src/sql/mysql/Capabilities.rs
+++ b/src/sql/mysql/Capabilities.rs
@@ -1,10 +1,9 @@
 // MySQL capability flags
 //
-// PORT NOTE: The Zig original is a file-level struct of `bool` fields (NOT a
-// `packed struct(u32)`), with explicit bit-value constants and comptime field
-// iteration for `toInt`/`fromInt`/`format`. We keep the same shape — a plain
-// struct of bools — and unroll the comptime loops explicitly. Field names stay
-// SCREAMING_SNAKE_CASE because `format` emits them verbatim.
+// Modeled as a plain struct of `bool` fields (NOT a `packed struct(u32)`-style
+// bitfield), with explicit bit-value constants and
+// hand-unrolled field loops for `to_int`/`from_int`/`Display`. Field names stay
+// SCREAMING_SNAKE_CASE because `Display` emits them verbatim.
 // (non_snake_case / non_upper_case_globals allowed at crate root.)
 
 use core::fmt;
@@ -80,9 +79,6 @@ impl Capabilities {
     const _CLIENT_SSL_VERIFY_SERVER_CERT: u32 = 1073741824; // 1 << 30
     const _CLIENT_REMEMBER_OPTIONS: u32 = 2147483648; // 1 << 31
 
-    // PORT NOTE: the Zig `comptime { _ = .{...} }` block only force-referenced
-    // the constants above; dropped per PORTING.md §Don't translate.
-
     pub fn reject(&mut self) {
         self.CLIENT_ZSTD_COMPRESSION_ALGORITHM = false;
         self.MULTI_FACTOR_AUTHENTICATION = false;
@@ -102,7 +98,7 @@ impl Capabilities {
     pub fn to_int(self) -> u32 {
         let mut value: u32 = 0;
 
-        // PORT NOTE: unrolled `inline for (fields) |field| { if @field(this, field) value |= @field(Capabilities, "_" ++ field) }`
+        // Keep in sync with the Capabilities field list above.
         if self.CLIENT_LONG_PASSWORD {
             value |= Self::_CLIENT_LONG_PASSWORD;
         }
@@ -204,7 +200,7 @@ impl Capabilities {
     }
 
     pub fn from_int(flags: u32) -> Capabilities {
-        // PORT NOTE: unrolled `inline for (std.meta.fieldNames(Capabilities)) |field| { @field(this, field) = (_CONST & flags) != 0 }`
+        // Keep in sync with the Capabilities field list above.
         Capabilities {
             CLIENT_LONG_PASSWORD: (Self::_CLIENT_LONG_PASSWORD & flags) != 0,
             CLIENT_FOUND_ROWS: (Self::_CLIENT_FOUND_ROWS & flags) != 0,
@@ -269,11 +265,10 @@ impl Capabilities {
     }
 }
 
-// Zig: pub fn format(self, writer: *std.Io.Writer) !void
 impl fmt::Display for Capabilities {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut first = true;
-        // PORT NOTE: unrolled `inline for (std.meta.fieldNames(Capabilities)) |field| { if @field(self, field) { ... writer.writeAll(field) } }`
+        // Keep in sync with the Capabilities field list above.
         macro_rules! emit {
             ($field:ident) => {
                 if self.$field {
@@ -321,5 +316,3 @@ impl fmt::Display for Capabilities {
         Ok(())
     }
 }
-
-// ported from: src/sql/mysql/Capabilities.zig
diff --git a/src/sql/mysql/ConnectionState.rs b/src/sql/mysql/ConnectionState.rs
index afdbbe9a9c5..19d1fd8437a 100644
--- a/src/sql/mysql/ConnectionState.rs
+++ b/src/sql/mysql/ConnectionState.rs
@@ -8,5 +8,3 @@ pub enum ConnectionState {
     Connected,
     Failed,
 }
-
-// ported from: src/sql/mysql/ConnectionState.zig
diff --git a/src/sql/mysql/MySQLParam.rs b/src/sql/mysql/MySQLParam.rs
index 77943f5d66c..5ea914a56b3 100644
--- a/src/sql/mysql/MySQLParam.rs
+++ b/src/sql/mysql/MySQLParam.rs
@@ -10,5 +10,3 @@ pub struct Param {
     pub r#type: FieldType,
     pub flags: ColumnFlags,
 }
-
-// ported from: src/sql/mysql/MySQLParam.zig
diff --git a/src/sql/mysql/MySQLQueryResult.rs b/src/sql/mysql/MySQLQueryResult.rs
index 36df1ddb731..a8f98ca0132 100644
--- a/src/sql/mysql/MySQLQueryResult.rs
+++ b/src/sql/mysql/MySQLQueryResult.rs
@@ -4,5 +4,3 @@ pub struct MySQLQueryResult {
     pub affected_rows: u64,
     pub is_last_result: bool,
 }
-
-// ported from: src/sql/mysql/MySQLQueryResult.zig
diff --git a/src/sql/mysql/MySQLRequest.rs b/src/sql/mysql/MySQLRequest.rs
index 8588cdda478..6c6ebebc037 100644
--- a/src/sql/mysql/MySQLRequest.rs
+++ b/src/sql/mysql/MySQLRequest.rs
@@ -7,7 +7,6 @@ pub fn execute_query<Context: WriterContext>(
     query: &[u8],
     writer: NewWriter<Context>,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     bun_core::scoped_log!(
         MySQLRequest,
         "executeQuery len: {} {}",
@@ -27,7 +26,6 @@ pub fn prepare_request<Context: WriterContext>(
     query: &[u8],
     writer: NewWriter<Context>,
 ) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
     bun_core::scoped_log!(MySQLRequest, "prepareRequest {}", bstr::BStr::new(query));
     let mut packet = writer.start(0)?;
     writer.int1(CommandType::COM_STMT_PREPARE as u8)?;
@@ -36,5 +34,3 @@ pub fn prepare_request<Context: WriterContext>(
     packet.end()?;
     Ok(())
 }
-
-// ported from: src/sql/mysql/MySQLRequest.zig
diff --git a/src/sql/mysql/MySQLTypes.rs b/src/sql/mysql/MySQLTypes.rs
index 3148eb20239..9d01779e7a3 100644
--- a/src/sql/mysql/MySQLTypes.rs
+++ b/src/sql/mysql/MySQLTypes.rs
@@ -1,10 +1,10 @@
 use strum::IntoStaticStr;
 
-// TODO(port): Zig source is `enum(u8) { ..., _ }` (non-exhaustive — any u8 is a valid
-// CharacterSet). A Rust `#[repr(u8)] enum` is UB for unnamed discriminants. Either
-// (a) keep this enum and guarantee all decode sites range-check before `from_raw`, or
-// (b) switch to `#[repr(transparent)] pub struct CharacterSet(pub u8)` with associated
-// consts. `label()` below already assumes out-of-range values are possible.
+// On the wire any u8 is a valid
+// CharacterSet. This Rust enum is exhaustive, so constructing it from a raw
+// wire byte is only allowed through a checked constructor — never `transmute`.
+// The live decode path uses the separate non-exhaustive `protocol::CharacterSet`
+// type (protocol/CharacterSet.rs); nothing decodes into this enum.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, IntoStaticStr)]
 pub enum CharacterSet {
@@ -253,8 +253,9 @@ impl Default for CharacterSet {
 
 // MySQL field types
 // https://dev.mysql.com/doc/dev/mysql-server/latest/binary__log__types_8h.html#a8935f33b06a3a88ba403c63acd806920
-// TODO(port): Zig source is `enum(u8) { ..., _ }` (non-exhaustive). See note on CharacterSet
-// above — same decision applies (range-checked `from_raw` vs newtype-over-u8).
+// On the wire any u8 is possible. This Rust enum is
+// exhaustive: all wire decoding must go through the range-checked `from_raw`
+// below (returns `None` for unknown bytes) — never `transmute`.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, IntoStaticStr)]
 pub enum FieldType {
@@ -292,12 +293,11 @@ pub enum FieldType {
 }
 
 impl FieldType {
-    // Zig: `pub const fromJS = @import("../../sql_jsc/mysql/MySQLValue.zig").fieldTypeFromJS;`
-    // Deleted per PORTING.md — `from_js` is provided as an extension-trait method in the
+    // `from_js` is provided as an extension-trait method in the
     // `bun_sql_jsc` crate; the base type carries no JSC dependency.
 
-    /// Decode a raw protocol byte. Zig `FieldType` is a non-exhaustive
-    /// `enum(u8)` so `@enumFromInt` accepts any byte; this Rust enum is
+    /// Decode a raw protocol byte. On the wire any byte is possible; this
+    /// Rust enum is
     /// exhaustive, so unknown bytes return `None` instead of producing an
     /// invalid discriminant. LLVM folds the contiguous arms to two range
     /// checks.
@@ -356,9 +356,7 @@ impl FieldType {
     }
 }
 
-// Zig: `pub const Value = @import("../../sql_jsc/mysql/MySQLValue.zig").Value;`
-// Deleted per PORTING.md — `*_jsc` re-export alias; callers in Rust import
-// `bun_sql_jsc::mysql::mysql_value::Value` directly.
+// Callers import `bun_sql_jsc::mysql::mysql_value::Value` directly.
 
 pub(crate) type MySQLInt32 = Int4;
 pub(crate) type MySQLInt64 = Int8;
@@ -366,5 +364,3 @@ pub(crate) type MySQLInt64 = Int8;
 pub type Int3 = u32;
 pub type Int4 = u32;
 pub type Int8 = u64;
-
-// ported from: src/sql/mysql/MySQLTypes.zig
diff --git a/src/sql/mysql/QueryStatus.rs b/src/sql/mysql/QueryStatus.rs
index 4d26cc08f18..104f44afaf2 100644
--- a/src/sql/mysql/QueryStatus.rs
+++ b/src/sql/mysql/QueryStatus.rs
@@ -20,5 +20,3 @@ impl Status {
         (self as u8) > (Status::Pending as u8) && (self as u8) < (Status::Success as u8)
     }
 }
-
-// ported from: src/sql/mysql/QueryStatus.zig
diff --git a/src/sql/mysql/SSLMode.rs b/src/sql/mysql/SSLMode.rs
index 05ddbfc82bc..99f59a7f50b 100644
--- a/src/sql/mysql/SSLMode.rs
+++ b/src/sql/mysql/SSLMode.rs
@@ -7,5 +7,3 @@ pub enum SSLMode {
     VerifyCa = 3,
     VerifyFull = 4,
 }
-
-// ported from: src/sql/mysql/SSLMode.zig
diff --git a/src/sql/mysql/StatusFlags.rs b/src/sql/mysql/StatusFlags.rs
index 24840719b65..4d674390566 100644
--- a/src/sql/mysql/StatusFlags.rs
+++ b/src/sql/mysql/StatusFlags.rs
@@ -41,10 +41,8 @@ pub struct StatusFlags {
 
 impl fmt::Display for StatusFlags {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // PORT NOTE: the Zig `format` iterates `std.meta.fieldNames(StatusFlags)` and
-        // prints each field whose type is `bool`. `StatusFlags` has only one field
-        // (`_value: u16`), so the Zig loop is a no-op at comptime. Preserved as a
-        // no-op here; likely dead code left over from when this was a packed struct.
+        // Intentionally a no-op; likely dead code left over from when this
+        // was a packed struct of bools.
         let _first = true;
         Ok(())
     }
@@ -63,5 +61,3 @@ impl StatusFlags {
         Self { _value: flags }
     }
 }
-
-// ported from: src/sql/mysql/StatusFlags.zig
diff --git a/src/sql/mysql/TLSStatus.rs b/src/sql/mysql/TLSStatus.rs
index 27124ddfe19..77f1bfd0a27 100644
--- a/src/sql/mysql/TLSStatus.rs
+++ b/src/sql/mysql/TLSStatus.rs
@@ -11,5 +11,3 @@ pub enum TLSStatus {
     SslFailed,
     SslOk,
 }
-
-// ported from: src/sql/mysql/TLSStatus.zig
diff --git a/src/sql/mysql/protocol/AnyMySQLError.rs b/src/sql/mysql/protocol/AnyMySQLError.rs
index e8a5031b346..a2d8d39c774 100644
--- a/src/sql/mysql/protocol/AnyMySQLError.rs
+++ b/src/sql/mysql/protocol/AnyMySQLError.rs
@@ -1,6 +1,6 @@
 // NOTE: not `thiserror::Error` — that derive requires a per-variant `#[error("...")]`
-// attr. We hand-roll Display via `IntoStaticStr` so the message == the variant name
-// (matching Zig `@errorName`), and impl `std::error::Error` manually below.
+// attr. We hand-roll Display via `IntoStaticStr` so the message == the variant name,
+// and impl `std::error::Error` manually below.
 #[derive(strum::IntoStaticStr, strum::EnumString, Debug, Copy, Clone, Eq, PartialEq)]
 pub enum Error {
     ConnectionClosed,
@@ -23,6 +23,7 @@ pub enum Error {
     Overflow,
 
     WrongNumberOfParametersProvided,
+    TooManyParameters,
 
     UnsupportedColumnType,
 
@@ -46,8 +47,8 @@ pub enum Error {
 
 bun_core::impl_tag_error!(Error);
 
-/// Zig callers name this `AnyMySQLError` (the file basename); the Rust enum is
-/// `Error` per convention. Re-export both spellings so cross-crate `use` lines
+/// The Rust enum is `Error` per convention; re-export the `AnyMySQLError`
+/// spelling as well so cross-crate `use` lines
 /// (`bun_sql::mysql::protocol::any_mysql_error::AnyMySQLError`) resolve.
 pub type AnyMySQLError = Error;
 
@@ -63,8 +64,5 @@ impl From<bun_core::Error> for Error {
     }
 }
 
-// NOTE: `pub const mysqlErrorToJS = @import("../../../sql_jsc/...").mysqlErrorToJS;`
-// is a *_jsc alias — deleted per PORTING.md. `mysql_error_to_js` lives in
+// NOTE: `mysql_error_to_js` lives in
 // `bun_sql_jsc::mysql::protocol::any_mysql_error_jsc` as an extension fn.
-
-// ported from: src/sql/mysql/protocol/AnyMySQLError.zig
diff --git a/src/sql/mysql/protocol/Auth.rs b/src/sql/mysql/protocol/Auth.rs
index 497764b1646..113debd11bc 100644
--- a/src/sql/mysql/protocol/Auth.rs
+++ b/src/sql/mysql/protocol/Auth.rs
@@ -17,7 +17,6 @@ bun_core::declare_scope!(Auth, hidden);
 pub mod mysql_native_password {
     use super::*;
 
-    // TODO(port): narrow error set
     pub(crate) fn scramble(password: &[u8], nonce: &[u8]) -> Result<[u8; 20], bun_core::Error> {
         // SHA1( password ) XOR SHA1( nonce + SHA1( SHA1( password ) ) ) )
         let mut stage1 = [0u8; 20];
@@ -35,10 +34,10 @@ pub mod mysql_native_password {
         }
 
         // Stage 1: SHA1(password)
-        // TODO(port): Zig passed `jsc.VirtualMachine.get().rareData().boringEngine()`;
-        // engine is optional and bun_jsc is higher-tier — pass null (matches
-        // bun_install::integrity / bun_exe_format::macho precedent). Revisit if
-        // profiling shows the engine matters here (it accelerates HW SHA only).
+        // The boringssl engine is optional and bun_jsc is higher-tier, so pass null
+        // (matches bun_install::integrity / bun_exe_format::macho precedent).
+        // The engine only accelerates hardware SHA; null is functionally
+        // identical.
         // SAFETY: engine is null (default).
         unsafe { SHA1::hash(password, &mut stage1, core::ptr::null_mut()) };
 
@@ -67,7 +66,6 @@ pub mod mysql_native_password {
 pub mod caching_sha2_password {
     use super::*;
 
-    // TODO(port): narrow error set
     pub(crate) fn scramble(password: &[u8], nonce: &[u8]) -> Result<[u8; 32], bun_core::Error> {
         // XOR(SHA256(password), SHA256(SHA256(SHA256(password)), nonce))
         let mut digest1 = [0u8; 32];
@@ -76,7 +74,7 @@ pub mod caching_sha2_password {
         let mut result: [u8; 32] = [0u8; 32];
 
         // SHA256(password)
-        // TODO(port): see note in mysql_native_password::scramble re: ENGINE*.
+        // Null ENGINE — see note in mysql_native_password::scramble.
         // SAFETY: engine is null (default).
         unsafe { SHA256::hash(password, &mut digest1, core::ptr::null_mut()) };
 
@@ -101,7 +99,7 @@ pub mod caching_sha2_password {
         Ok(result)
     }
 
-    // Zig: `enum(u8) { success = 0x03, continue_auth = 0x04, _ }` — non-exhaustive,
+    // Any wire byte is possible (success = 0x03, continue_auth = 0x04),
     // so represent as a transparent u8 newtype rather than a closed Rust enum.
     #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -130,10 +128,9 @@ pub mod caching_sha2_password {
     }
 
     impl Response {
-        // Zig `deinit` only freed `self.data` — Data's own Drop handles that, so no
-        // explicit Drop impl needed here.
+        // `Data`'s own Drop frees `self.data`, so no explicit Drop impl is
+        // needed here.
 
-        // TODO(port): narrow error set
         pub fn decode_internal<Context: ReaderContext>(
             &mut self,
             reader: NewReader<Context>,
@@ -150,7 +147,7 @@ pub mod caching_sha2_password {
             Ok(())
         }
 
-        // Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
+        // See the Decode trait in src/sql/mysql/protocol/NewReader.rs
         pub fn decode<Context: ReaderContext>(
             &mut self,
             reader: NewReader<Context>,
@@ -175,7 +172,6 @@ pub mod caching_sha2_password {
         // https://mariadb.com/kb/en/sha256_password-plugin/#rsa-encrypted-password
         // RSA encrypted value of XOR(password, seed) using server public key (RSA_PKCS1_OAEP_PADDING).
 
-        // TODO(port): narrow error set
         pub fn write_internal<Context: WriterContext>(
             &self,
             writer: NewWriter<Context>,
@@ -200,7 +196,6 @@ pub mod caching_sha2_password {
                 return Err(err!("InvalidPublicKey"));
             }
             // 1024 is overkill but lets cover all cases
-            // PERF(port): was stack-fallback (1024-byte stack buf with heap overflow path) — profile if hot.
             let needed_len = password.len() + 1;
             let mut plain_password = vec![0u8; needed_len];
             plain_password[0..password.len()].copy_from_slice(password);
@@ -270,7 +265,6 @@ pub mod caching_sha2_password {
             // SAFETY: *rsa is a valid RSA*.
             let rsa_size = unsafe { boringssl::c::RSA_size(*rsa) } as usize;
             // should never ne bigger than 4096 but lets cover all cases
-            // PERF(port): was stack-fallback (4096-byte stack buf with heap overflow path) — profile if hot.
             let mut encrypted_password = vec![0u8; rsa_size];
 
             // SAFETY: plain_password and encrypted_password are valid for the given
@@ -296,7 +290,7 @@ pub mod caching_sha2_password {
             Ok(())
         }
 
-        // Zig `writeWrap(@This(), ...)` — see src/sql/mysql/protocol/NewWriter.rs
+        // See src/sql/mysql/protocol/NewWriter.rs
         pub fn write<Context: WriterContext>(
             &self,
             writer: NewWriter<Context>,
@@ -311,9 +305,8 @@ pub mod caching_sha2_password {
     }
 
     impl PublicKeyResponse {
-        // Zig `deinit` only freed `self.data` — Data's own Drop handles that.
+        // `Data`'s own Drop frees `self.data`.
 
-        // TODO(port): narrow error set
         pub fn decode_internal<Context: ReaderContext>(
             &mut self,
             reader: NewReader<Context>,
@@ -337,7 +330,6 @@ pub mod caching_sha2_password {
     pub struct PublicKeyRequest;
 
     impl PublicKeyRequest {
-        // TODO(port): narrow error set
         pub fn write_internal<Context: WriterContext>(
             &self,
             writer: NewWriter<Context>,
@@ -346,7 +338,7 @@ pub mod caching_sha2_password {
             Ok(())
         }
 
-        // Zig `writeWrap(@This(), ...)` — see src/sql/mysql/protocol/NewWriter.rs
+        // See src/sql/mysql/protocol/NewWriter.rs
         pub fn write<Context: WriterContext>(
             &self,
             writer: NewWriter<Context>,
@@ -355,5 +347,3 @@ pub mod caching_sha2_password {
         }
     }
 }
-
-// ported from: src/sql/mysql/protocol/Auth.zig
diff --git a/src/sql/mysql/protocol/AuthSwitchRequest.rs b/src/sql/mysql/protocol/AuthSwitchRequest.rs
index e6796651aae..2b8b090f614 100644
--- a/src/sql/mysql/protocol/AuthSwitchRequest.rs
+++ b/src/sql/mysql/protocol/AuthSwitchRequest.rs
@@ -7,7 +7,7 @@ pub struct AuthSwitchRequest {
     pub header: u8,
     pub plugin_name: Data,
     pub plugin_data: Data,
-    // TODO(port): Zig u24 — no native Rust u24; using u32 (value always fits in 24 bits)
+    /// Wire format is a 3-byte int; the value always fits in 24 bits.
     pub packet_size: u32,
 }
 
@@ -22,11 +22,9 @@ impl Default for AuthSwitchRequest {
     }
 }
 
-// NOTE: Zig `deinit` only called `plugin_name.deinit()` / `plugin_data.deinit()`.
-// `Data` owns its own cleanup via `Drop`, so no explicit `impl Drop` is needed here.
+// NOTE: `Data` owns its own cleanup via `Drop`, so no explicit `impl Drop` is needed here.
 
 impl AuthSwitchRequest {
-    // TODO(port): narrow error set (Zig: error.InvalidAuthSwitchRequest + reader errors)
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
@@ -53,7 +51,6 @@ impl AuthSwitchRequest {
     }
 }
 
-// Zig: `pub const decode = decoderWrap(AuthSwitchRequest, decodeInternal).decode;`
 impl AuthSwitchRequest {
     pub fn decode<Context: ReaderContext>(
         &mut self,
@@ -62,5 +59,3 @@ impl AuthSwitchRequest {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/mysql/protocol/AuthSwitchRequest.zig
diff --git a/src/sql/mysql/protocol/AuthSwitchResponse.rs b/src/sql/mysql/protocol/AuthSwitchResponse.rs
index db951de4e73..b810ea0902a 100644
--- a/src/sql/mysql/protocol/AuthSwitchResponse.rs
+++ b/src/sql/mysql/protocol/AuthSwitchResponse.rs
@@ -5,23 +5,21 @@ use crate::shared::Data;
 
 #[derive(Default)]
 pub struct AuthSwitchResponse {
-    pub auth_response: Data, // = .{ .empty = {} } → Data::default()
+    pub auth_response: Data,
 }
 
-// Zig `deinit` only forwarded to `self.auth_response.deinit()`; `Data: Drop` handles
-// that automatically, so no explicit `impl Drop` is needed here.
+// `Data: Drop` cleans up `auth_response` automatically, so no explicit
+// `impl Drop` is needed here.
 
 impl AuthSwitchResponse {
     pub fn write_internal<C: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<C>,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         writer.write(self.auth_response.slice())?;
         Ok(())
     }
 
-    // Zig: `pub const write = writeWrap(AuthSwitchResponse, writeInternal).write;`
     pub fn write<C: super::new_writer::WriterContext>(
         &self,
         context: C,
@@ -29,5 +27,3 @@ impl AuthSwitchResponse {
         self.write_internal(NewWriter { wrapped: context })
     }
 }
-
-// ported from: src/sql/mysql/protocol/AuthSwitchResponse.zig
diff --git a/src/sql/mysql/protocol/CharacterSet.rs b/src/sql/mysql/protocol/CharacterSet.rs
index 1b4097b7120..d4e49f593d0 100644
--- a/src/sql/mysql/protocol/CharacterSet.rs
+++ b/src/sql/mysql/protocol/CharacterSet.rs
@@ -1,263 +1,355 @@
-use strum::{FromRepr, IntoStaticStr};
+// MySQL collation/character-set id. Any wire byte is a legal value, named or
+// not, so this is a `#[repr(transparent)]` newtype over `u8` —
+// unknown ids coming off the wire are preserved instead of being collapsed to
+// a known variant, and constructing one is never UB.
+#[repr(transparent)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub struct CharacterSet(pub u8);
 
-// TODO(port): Zig source is a non-exhaustive `enum(u8)` (trailing `_`), meaning it may
-// legally hold any u8 value not listed below. A Rust `#[repr(u8)] enum` makes that UB.
-// If callers ever construct this from an arbitrary wire byte, either add an
-// `Unknown(u8)` path at the construction site or switch to `#[repr(transparent)] struct(u8)`
-// with associated consts.
-#[allow(non_camel_case_types)]
-#[repr(u8)]
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, IntoStaticStr, FromRepr)]
-pub enum CharacterSet {
-    big5_chinese_ci = 1,
-    latin2_czech_cs = 2,
-    dec8_swedish_ci = 3,
-    cp850_general_ci = 4,
-    latin1_german1_ci = 5,
-    hp8_english_ci = 6,
-    koi8r_general_ci = 7,
-    latin1_swedish_ci = 8,
-    latin2_general_ci = 9,
-    swe7_swedish_ci = 10,
-    ascii_general_ci = 11,
-    ujis_japanese_ci = 12,
-    sjis_japanese_ci = 13,
-    cp1251_bulgarian_ci = 14,
-    latin1_danish_ci = 15,
-    hebrew_general_ci = 16,
-    tis620_thai_ci = 18,
-    euckr_korean_ci = 19,
-    latin7_estonian_cs = 20,
-    latin2_hungarian_ci = 21,
-    koi8u_general_ci = 22,
-    cp1251_ukrainian_ci = 23,
-    gb2312_chinese_ci = 24,
-    greek_general_ci = 25,
-    cp1250_general_ci = 26,
-    latin2_croatian_ci = 27,
-    gbk_chinese_ci = 28,
-    cp1257_lithuanian_ci = 29,
-    latin5_turkish_ci = 30,
-    latin1_german2_ci = 31,
-    armscii8_general_ci = 32,
-    utf8mb3_general_ci = 33,
-    cp1250_czech_cs = 34,
-    ucs2_general_ci = 35,
-    cp866_general_ci = 36,
-    keybcs2_general_ci = 37,
-    macce_general_ci = 38,
-    macroman_general_ci = 39,
-    cp852_general_ci = 40,
-    latin7_general_ci = 41,
-    latin7_general_cs = 42,
-    macce_bin = 43,
-    cp1250_croatian_ci = 44,
-    utf8mb4_general_ci = 45,
-    utf8mb4_bin = 46,
-    latin1_bin = 47,
-    latin1_general_ci = 48,
-    latin1_general_cs = 49,
-    cp1251_bin = 50,
-    cp1251_general_ci = 51,
-    cp1251_general_cs = 52,
-    macroman_bin = 53,
-    utf16_general_ci = 54,
-    utf16_bin = 55,
-    utf16le_general_ci = 56,
-    cp1256_general_ci = 57,
-    cp1257_bin = 58,
-    cp1257_general_ci = 59,
-    utf32_general_ci = 60,
-    utf32_bin = 61,
-    utf16le_bin = 62,
-    binary = 63,
-    armscii8_bin = 64,
-    ascii_bin = 65,
-    cp1250_bin = 66,
-    cp1256_bin = 67,
-    cp866_bin = 68,
-    dec8_bin = 69,
-    greek_bin = 70,
-    hebrew_bin = 71,
-    hp8_bin = 72,
-    keybcs2_bin = 73,
-    koi8r_bin = 74,
-    koi8u_bin = 75,
-    utf8mb3_tolower_ci = 76,
-    latin2_bin = 77,
-    latin5_bin = 78,
-    latin7_bin = 79,
-    cp850_bin = 80,
-    cp852_bin = 81,
-    swe7_bin = 82,
-    utf8mb3_bin = 83,
-    big5_bin = 84,
-    euckr_bin = 85,
-    gb2312_bin = 86,
-    gbk_bin = 87,
-    sjis_bin = 88,
-    tis620_bin = 89,
-    ucs2_bin = 90,
-    ujis_bin = 91,
-    geostd8_general_ci = 92,
-    geostd8_bin = 93,
-    latin1_spanish_ci = 94,
-    cp932_japanese_ci = 95,
-    cp932_bin = 96,
-    eucjpms_japanese_ci = 97,
-    eucjpms_bin = 98,
-    cp1250_polish_ci = 99,
-    utf16_unicode_ci = 101,
-    utf16_icelandic_ci = 102,
-    utf16_latvian_ci = 103,
-    utf16_romanian_ci = 104,
-    utf16_slovenian_ci = 105,
-    utf16_polish_ci = 106,
-    utf16_estonian_ci = 107,
-    utf16_spanish_ci = 108,
-    utf16_swedish_ci = 109,
-    utf16_turkish_ci = 110,
-    utf16_czech_ci = 111,
-    utf16_danish_ci = 112,
-    utf16_lithuanian_ci = 113,
-    utf16_slovak_ci = 114,
-    utf16_spanish2_ci = 115,
-    utf16_roman_ci = 116,
-    utf16_persian_ci = 117,
-    utf16_esperanto_ci = 118,
-    utf16_hungarian_ci = 119,
-    utf16_sinhala_ci = 120,
-    utf16_german2_ci = 121,
-    utf16_croatian_ci = 122,
-    utf16_unicode_520_ci = 123,
-    utf16_vietnamese_ci = 124,
-    ucs2_unicode_ci = 128,
-    ucs2_icelandic_ci = 129,
-    ucs2_latvian_ci = 130,
-    ucs2_romanian_ci = 131,
-    ucs2_slovenian_ci = 132,
-    ucs2_polish_ci = 133,
-    ucs2_estonian_ci = 134,
-    ucs2_spanish_ci = 135,
-    ucs2_swedish_ci = 136,
-    ucs2_turkish_ci = 137,
-    ucs2_czech_ci = 138,
-    ucs2_danish_ci = 139,
-    ucs2_lithuanian_ci = 140,
-    ucs2_slovak_ci = 141,
-    ucs2_spanish2_ci = 142,
-    ucs2_roman_ci = 143,
-    ucs2_persian_ci = 144,
-    ucs2_esperanto_ci = 145,
-    ucs2_hungarian_ci = 146,
-    ucs2_sinhala_ci = 147,
-    ucs2_german2_ci = 148,
-    ucs2_croatian_ci = 149,
-    ucs2_unicode_520_ci = 150,
-    ucs2_vietnamese_ci = 151,
-    ucs2_general_mysql500_ci = 159,
-    utf32_unicode_ci = 160,
-    utf32_icelandic_ci = 161,
-    utf32_latvian_ci = 162,
-    utf32_romanian_ci = 163,
-    utf32_slovenian_ci = 164,
-    utf32_polish_ci = 165,
-    utf32_estonian_ci = 166,
-    utf32_spanish_ci = 167,
-    utf32_swedish_ci = 168,
-    utf32_turkish_ci = 169,
-    utf32_czech_ci = 170,
-    utf32_danish_ci = 171,
-    utf32_lithuanian_ci = 172,
-    utf32_slovak_ci = 173,
-    utf32_spanish2_ci = 174,
-    utf32_roman_ci = 175,
-    utf32_persian_ci = 176,
-    utf32_esperanto_ci = 177,
-    utf32_hungarian_ci = 178,
-    utf32_sinhala_ci = 179,
-    utf32_german2_ci = 180,
-    utf32_croatian_ci = 181,
-    utf32_unicode_520_ci = 182,
-    utf32_vietnamese_ci = 183,
-    utf8mb3_unicode_ci = 192,
-    utf8mb3_icelandic_ci = 193,
-    utf8mb3_latvian_ci = 194,
-    utf8mb3_romanian_ci = 195,
-    utf8mb3_slovenian_ci = 196,
-    utf8mb3_polish_ci = 197,
-    utf8mb3_estonian_ci = 198,
-    utf8mb3_spanish_ci = 199,
-    utf8mb3_swedish_ci = 200,
-    utf8mb3_turkish_ci = 201,
-    utf8mb3_czech_ci = 202,
-    utf8mb3_danish_ci = 203,
-    utf8mb3_lithuanian_ci = 204,
-    utf8mb3_slovak_ci = 205,
-    utf8mb3_spanish2_ci = 206,
-    utf8mb3_roman_ci = 207,
-    utf8mb3_persian_ci = 208,
-    utf8mb3_esperanto_ci = 209,
-    utf8mb3_hungarian_ci = 210,
-    utf8mb3_sinhala_ci = 211,
-    utf8mb3_german2_ci = 212,
-    utf8mb3_croatian_ci = 213,
-    utf8mb3_unicode_520_ci = 214,
-    utf8mb3_vietnamese_ci = 215,
-    utf8mb3_general_mysql500_ci = 223,
-    utf8mb4_unicode_ci = 224,
-    utf8mb4_icelandic_ci = 225,
-    utf8mb4_latvian_ci = 226,
-    utf8mb4_romanian_ci = 227,
-    utf8mb4_slovenian_ci = 228,
-    utf8mb4_polish_ci = 229,
-    utf8mb4_estonian_ci = 230,
-    utf8mb4_spanish_ci = 231,
-    utf8mb4_swedish_ci = 232,
-    utf8mb4_turkish_ci = 233,
-    utf8mb4_czech_ci = 234,
-    utf8mb4_danish_ci = 235,
-    utf8mb4_lithuanian_ci = 236,
-    utf8mb4_slovak_ci = 237,
-    utf8mb4_spanish2_ci = 238,
-    utf8mb4_roman_ci = 239,
-    utf8mb4_persian_ci = 240,
-    utf8mb4_esperanto_ci = 241,
-    utf8mb4_hungarian_ci = 242,
-    utf8mb4_sinhala_ci = 243,
-    utf8mb4_german2_ci = 244,
-    utf8mb4_croatian_ci = 245,
-    utf8mb4_unicode_520_ci = 246,
-    utf8mb4_vietnamese_ci = 247,
-    gb18030_chinese_ci = 248,
-    gb18030_bin = 249,
-    gb18030_unicode_520_ci = 250,
+#[allow(non_upper_case_globals)]
+impl CharacterSet {
+    pub const big5_chinese_ci: CharacterSet = CharacterSet(1);
+    pub const latin2_czech_cs: CharacterSet = CharacterSet(2);
+    pub const dec8_swedish_ci: CharacterSet = CharacterSet(3);
+    pub const cp850_general_ci: CharacterSet = CharacterSet(4);
+    pub const latin1_german1_ci: CharacterSet = CharacterSet(5);
+    pub const hp8_english_ci: CharacterSet = CharacterSet(6);
+    pub const koi8r_general_ci: CharacterSet = CharacterSet(7);
+    pub const latin1_swedish_ci: CharacterSet = CharacterSet(8);
+    pub const latin2_general_ci: CharacterSet = CharacterSet(9);
+    pub const swe7_swedish_ci: CharacterSet = CharacterSet(10);
+    pub const ascii_general_ci: CharacterSet = CharacterSet(11);
+    pub const ujis_japanese_ci: CharacterSet = CharacterSet(12);
+    pub const sjis_japanese_ci: CharacterSet = CharacterSet(13);
+    pub const cp1251_bulgarian_ci: CharacterSet = CharacterSet(14);
+    pub const latin1_danish_ci: CharacterSet = CharacterSet(15);
+    pub const hebrew_general_ci: CharacterSet = CharacterSet(16);
+    pub const tis620_thai_ci: CharacterSet = CharacterSet(18);
+    pub const euckr_korean_ci: CharacterSet = CharacterSet(19);
+    pub const latin7_estonian_cs: CharacterSet = CharacterSet(20);
+    pub const latin2_hungarian_ci: CharacterSet = CharacterSet(21);
+    pub const koi8u_general_ci: CharacterSet = CharacterSet(22);
+    pub const cp1251_ukrainian_ci: CharacterSet = CharacterSet(23);
+    pub const gb2312_chinese_ci: CharacterSet = CharacterSet(24);
+    pub const greek_general_ci: CharacterSet = CharacterSet(25);
+    pub const cp1250_general_ci: CharacterSet = CharacterSet(26);
+    pub const latin2_croatian_ci: CharacterSet = CharacterSet(27);
+    pub const gbk_chinese_ci: CharacterSet = CharacterSet(28);
+    pub const cp1257_lithuanian_ci: CharacterSet = CharacterSet(29);
+    pub const latin5_turkish_ci: CharacterSet = CharacterSet(30);
+    pub const latin1_german2_ci: CharacterSet = CharacterSet(31);
+    pub const armscii8_general_ci: CharacterSet = CharacterSet(32);
+    pub const utf8mb3_general_ci: CharacterSet = CharacterSet(33);
+    pub const cp1250_czech_cs: CharacterSet = CharacterSet(34);
+    pub const ucs2_general_ci: CharacterSet = CharacterSet(35);
+    pub const cp866_general_ci: CharacterSet = CharacterSet(36);
+    pub const keybcs2_general_ci: CharacterSet = CharacterSet(37);
+    pub const macce_general_ci: CharacterSet = CharacterSet(38);
+    pub const macroman_general_ci: CharacterSet = CharacterSet(39);
+    pub const cp852_general_ci: CharacterSet = CharacterSet(40);
+    pub const latin7_general_ci: CharacterSet = CharacterSet(41);
+    pub const latin7_general_cs: CharacterSet = CharacterSet(42);
+    pub const macce_bin: CharacterSet = CharacterSet(43);
+    pub const cp1250_croatian_ci: CharacterSet = CharacterSet(44);
+    pub const utf8mb4_general_ci: CharacterSet = CharacterSet(45);
+    pub const utf8mb4_bin: CharacterSet = CharacterSet(46);
+    pub const latin1_bin: CharacterSet = CharacterSet(47);
+    pub const latin1_general_ci: CharacterSet = CharacterSet(48);
+    pub const latin1_general_cs: CharacterSet = CharacterSet(49);
+    pub const cp1251_bin: CharacterSet = CharacterSet(50);
+    pub const cp1251_general_ci: CharacterSet = CharacterSet(51);
+    pub const cp1251_general_cs: CharacterSet = CharacterSet(52);
+    pub const macroman_bin: CharacterSet = CharacterSet(53);
+    pub const utf16_general_ci: CharacterSet = CharacterSet(54);
+    pub const utf16_bin: CharacterSet = CharacterSet(55);
+    pub const utf16le_general_ci: CharacterSet = CharacterSet(56);
+    pub const cp1256_general_ci: CharacterSet = CharacterSet(57);
+    pub const cp1257_bin: CharacterSet = CharacterSet(58);
+    pub const cp1257_general_ci: CharacterSet = CharacterSet(59);
+    pub const utf32_general_ci: CharacterSet = CharacterSet(60);
+    pub const utf32_bin: CharacterSet = CharacterSet(61);
+    pub const utf16le_bin: CharacterSet = CharacterSet(62);
+    pub const binary: CharacterSet = CharacterSet(63);
+    pub const armscii8_bin: CharacterSet = CharacterSet(64);
+    pub const ascii_bin: CharacterSet = CharacterSet(65);
+    pub const cp1250_bin: CharacterSet = CharacterSet(66);
+    pub const cp1256_bin: CharacterSet = CharacterSet(67);
+    pub const cp866_bin: CharacterSet = CharacterSet(68);
+    pub const dec8_bin: CharacterSet = CharacterSet(69);
+    pub const greek_bin: CharacterSet = CharacterSet(70);
+    pub const hebrew_bin: CharacterSet = CharacterSet(71);
+    pub const hp8_bin: CharacterSet = CharacterSet(72);
+    pub const keybcs2_bin: CharacterSet = CharacterSet(73);
+    pub const koi8r_bin: CharacterSet = CharacterSet(74);
+    pub const koi8u_bin: CharacterSet = CharacterSet(75);
+    pub const utf8mb3_tolower_ci: CharacterSet = CharacterSet(76);
+    pub const latin2_bin: CharacterSet = CharacterSet(77);
+    pub const latin5_bin: CharacterSet = CharacterSet(78);
+    pub const latin7_bin: CharacterSet = CharacterSet(79);
+    pub const cp850_bin: CharacterSet = CharacterSet(80);
+    pub const cp852_bin: CharacterSet = CharacterSet(81);
+    pub const swe7_bin: CharacterSet = CharacterSet(82);
+    pub const utf8mb3_bin: CharacterSet = CharacterSet(83);
+    pub const big5_bin: CharacterSet = CharacterSet(84);
+    pub const euckr_bin: CharacterSet = CharacterSet(85);
+    pub const gb2312_bin: CharacterSet = CharacterSet(86);
+    pub const gbk_bin: CharacterSet = CharacterSet(87);
+    pub const sjis_bin: CharacterSet = CharacterSet(88);
+    pub const tis620_bin: CharacterSet = CharacterSet(89);
+    pub const ucs2_bin: CharacterSet = CharacterSet(90);
+    pub const ujis_bin: CharacterSet = CharacterSet(91);
+    pub const geostd8_general_ci: CharacterSet = CharacterSet(92);
+    pub const geostd8_bin: CharacterSet = CharacterSet(93);
+    pub const latin1_spanish_ci: CharacterSet = CharacterSet(94);
+    pub const cp932_japanese_ci: CharacterSet = CharacterSet(95);
+    pub const cp932_bin: CharacterSet = CharacterSet(96);
+    pub const eucjpms_japanese_ci: CharacterSet = CharacterSet(97);
+    pub const eucjpms_bin: CharacterSet = CharacterSet(98);
+    pub const cp1250_polish_ci: CharacterSet = CharacterSet(99);
+    pub const utf16_unicode_ci: CharacterSet = CharacterSet(101);
+    pub const utf16_icelandic_ci: CharacterSet = CharacterSet(102);
+    pub const utf16_latvian_ci: CharacterSet = CharacterSet(103);
+    pub const utf16_romanian_ci: CharacterSet = CharacterSet(104);
+    pub const utf16_slovenian_ci: CharacterSet = CharacterSet(105);
+    pub const utf16_polish_ci: CharacterSet = CharacterSet(106);
+    pub const utf16_estonian_ci: CharacterSet = CharacterSet(107);
+    pub const utf16_spanish_ci: CharacterSet = CharacterSet(108);
+    pub const utf16_swedish_ci: CharacterSet = CharacterSet(109);
+    pub const utf16_turkish_ci: CharacterSet = CharacterSet(110);
+    pub const utf16_czech_ci: CharacterSet = CharacterSet(111);
+    pub const utf16_danish_ci: CharacterSet = CharacterSet(112);
+    pub const utf16_lithuanian_ci: CharacterSet = CharacterSet(113);
+    pub const utf16_slovak_ci: CharacterSet = CharacterSet(114);
+    pub const utf16_spanish2_ci: CharacterSet = CharacterSet(115);
+    pub const utf16_roman_ci: CharacterSet = CharacterSet(116);
+    pub const utf16_persian_ci: CharacterSet = CharacterSet(117);
+    pub const utf16_esperanto_ci: CharacterSet = CharacterSet(118);
+    pub const utf16_hungarian_ci: CharacterSet = CharacterSet(119);
+    pub const utf16_sinhala_ci: CharacterSet = CharacterSet(120);
+    pub const utf16_german2_ci: CharacterSet = CharacterSet(121);
+    pub const utf16_croatian_ci: CharacterSet = CharacterSet(122);
+    pub const utf16_unicode_520_ci: CharacterSet = CharacterSet(123);
+    pub const utf16_vietnamese_ci: CharacterSet = CharacterSet(124);
+    pub const ucs2_unicode_ci: CharacterSet = CharacterSet(128);
+    pub const ucs2_icelandic_ci: CharacterSet = CharacterSet(129);
+    pub const ucs2_latvian_ci: CharacterSet = CharacterSet(130);
+    pub const ucs2_romanian_ci: CharacterSet = CharacterSet(131);
+    pub const ucs2_slovenian_ci: CharacterSet = CharacterSet(132);
+    pub const ucs2_polish_ci: CharacterSet = CharacterSet(133);
+    pub const ucs2_estonian_ci: CharacterSet = CharacterSet(134);
+    pub const ucs2_spanish_ci: CharacterSet = CharacterSet(135);
+    pub const ucs2_swedish_ci: CharacterSet = CharacterSet(136);
+    pub const ucs2_turkish_ci: CharacterSet = CharacterSet(137);
+    pub const ucs2_czech_ci: CharacterSet = CharacterSet(138);
+    pub const ucs2_danish_ci: CharacterSet = CharacterSet(139);
+    pub const ucs2_lithuanian_ci: CharacterSet = CharacterSet(140);
+    pub const ucs2_slovak_ci: CharacterSet = CharacterSet(141);
+    pub const ucs2_spanish2_ci: CharacterSet = CharacterSet(142);
+    pub const ucs2_roman_ci: CharacterSet = CharacterSet(143);
+    pub const ucs2_persian_ci: CharacterSet = CharacterSet(144);
+    pub const ucs2_esperanto_ci: CharacterSet = CharacterSet(145);
+    pub const ucs2_hungarian_ci: CharacterSet = CharacterSet(146);
+    pub const ucs2_sinhala_ci: CharacterSet = CharacterSet(147);
+    pub const ucs2_german2_ci: CharacterSet = CharacterSet(148);
+    pub const ucs2_croatian_ci: CharacterSet = CharacterSet(149);
+    pub const ucs2_unicode_520_ci: CharacterSet = CharacterSet(150);
+    pub const ucs2_vietnamese_ci: CharacterSet = CharacterSet(151);
+    pub const ucs2_general_mysql500_ci: CharacterSet = CharacterSet(159);
+    pub const utf32_unicode_ci: CharacterSet = CharacterSet(160);
+    pub const utf32_icelandic_ci: CharacterSet = CharacterSet(161);
+    pub const utf32_latvian_ci: CharacterSet = CharacterSet(162);
+    pub const utf32_romanian_ci: CharacterSet = CharacterSet(163);
+    pub const utf32_slovenian_ci: CharacterSet = CharacterSet(164);
+    pub const utf32_polish_ci: CharacterSet = CharacterSet(165);
+    pub const utf32_estonian_ci: CharacterSet = CharacterSet(166);
+    pub const utf32_spanish_ci: CharacterSet = CharacterSet(167);
+    pub const utf32_swedish_ci: CharacterSet = CharacterSet(168);
+    pub const utf32_turkish_ci: CharacterSet = CharacterSet(169);
+    pub const utf32_czech_ci: CharacterSet = CharacterSet(170);
+    pub const utf32_danish_ci: CharacterSet = CharacterSet(171);
+    pub const utf32_lithuanian_ci: CharacterSet = CharacterSet(172);
+    pub const utf32_slovak_ci: CharacterSet = CharacterSet(173);
+    pub const utf32_spanish2_ci: CharacterSet = CharacterSet(174);
+    pub const utf32_roman_ci: CharacterSet = CharacterSet(175);
+    pub const utf32_persian_ci: CharacterSet = CharacterSet(176);
+    pub const utf32_esperanto_ci: CharacterSet = CharacterSet(177);
+    pub const utf32_hungarian_ci: CharacterSet = CharacterSet(178);
+    pub const utf32_sinhala_ci: CharacterSet = CharacterSet(179);
+    pub const utf32_german2_ci: CharacterSet = CharacterSet(180);
+    pub const utf32_croatian_ci: CharacterSet = CharacterSet(181);
+    pub const utf32_unicode_520_ci: CharacterSet = CharacterSet(182);
+    pub const utf32_vietnamese_ci: CharacterSet = CharacterSet(183);
+    pub const utf8mb3_unicode_ci: CharacterSet = CharacterSet(192);
+    pub const utf8mb3_icelandic_ci: CharacterSet = CharacterSet(193);
+    pub const utf8mb3_latvian_ci: CharacterSet = CharacterSet(194);
+    pub const utf8mb3_romanian_ci: CharacterSet = CharacterSet(195);
+    pub const utf8mb3_slovenian_ci: CharacterSet = CharacterSet(196);
+    pub const utf8mb3_polish_ci: CharacterSet = CharacterSet(197);
+    pub const utf8mb3_estonian_ci: CharacterSet = CharacterSet(198);
+    pub const utf8mb3_spanish_ci: CharacterSet = CharacterSet(199);
+    pub const utf8mb3_swedish_ci: CharacterSet = CharacterSet(200);
+    pub const utf8mb3_turkish_ci: CharacterSet = CharacterSet(201);
+    pub const utf8mb3_czech_ci: CharacterSet = CharacterSet(202);
+    pub const utf8mb3_danish_ci: CharacterSet = CharacterSet(203);
+    pub const utf8mb3_lithuanian_ci: CharacterSet = CharacterSet(204);
+    pub const utf8mb3_slovak_ci: CharacterSet = CharacterSet(205);
+    pub const utf8mb3_spanish2_ci: CharacterSet = CharacterSet(206);
+    pub const utf8mb3_roman_ci: CharacterSet = CharacterSet(207);
+    pub const utf8mb3_persian_ci: CharacterSet = CharacterSet(208);
+    pub const utf8mb3_esperanto_ci: CharacterSet = CharacterSet(209);
+    pub const utf8mb3_hungarian_ci: CharacterSet = CharacterSet(210);
+    pub const utf8mb3_sinhala_ci: CharacterSet = CharacterSet(211);
+    pub const utf8mb3_german2_ci: CharacterSet = CharacterSet(212);
+    pub const utf8mb3_croatian_ci: CharacterSet = CharacterSet(213);
+    pub const utf8mb3_unicode_520_ci: CharacterSet = CharacterSet(214);
+    pub const utf8mb3_vietnamese_ci: CharacterSet = CharacterSet(215);
+    pub const utf8mb3_general_mysql500_ci: CharacterSet = CharacterSet(223);
+    pub const utf8mb4_unicode_ci: CharacterSet = CharacterSet(224);
+    pub const utf8mb4_icelandic_ci: CharacterSet = CharacterSet(225);
+    pub const utf8mb4_latvian_ci: CharacterSet = CharacterSet(226);
+    pub const utf8mb4_romanian_ci: CharacterSet = CharacterSet(227);
+    pub const utf8mb4_slovenian_ci: CharacterSet = CharacterSet(228);
+    pub const utf8mb4_polish_ci: CharacterSet = CharacterSet(229);
+    pub const utf8mb4_estonian_ci: CharacterSet = CharacterSet(230);
+    pub const utf8mb4_spanish_ci: CharacterSet = CharacterSet(231);
+    pub const utf8mb4_swedish_ci: CharacterSet = CharacterSet(232);
+    pub const utf8mb4_turkish_ci: CharacterSet = CharacterSet(233);
+    pub const utf8mb4_czech_ci: CharacterSet = CharacterSet(234);
+    pub const utf8mb4_danish_ci: CharacterSet = CharacterSet(235);
+    pub const utf8mb4_lithuanian_ci: CharacterSet = CharacterSet(236);
+    pub const utf8mb4_slovak_ci: CharacterSet = CharacterSet(237);
+    pub const utf8mb4_spanish2_ci: CharacterSet = CharacterSet(238);
+    pub const utf8mb4_roman_ci: CharacterSet = CharacterSet(239);
+    pub const utf8mb4_persian_ci: CharacterSet = CharacterSet(240);
+    pub const utf8mb4_esperanto_ci: CharacterSet = CharacterSet(241);
+    pub const utf8mb4_hungarian_ci: CharacterSet = CharacterSet(242);
+    pub const utf8mb4_sinhala_ci: CharacterSet = CharacterSet(243);
+    pub const utf8mb4_german2_ci: CharacterSet = CharacterSet(244);
+    pub const utf8mb4_croatian_ci: CharacterSet = CharacterSet(245);
+    pub const utf8mb4_unicode_520_ci: CharacterSet = CharacterSet(246);
+    pub const utf8mb4_vietnamese_ci: CharacterSet = CharacterSet(247);
+    pub const gb18030_chinese_ci: CharacterSet = CharacterSet(248);
+    pub const gb18030_bin: CharacterSet = CharacterSet(249);
+    pub const gb18030_unicode_520_ci: CharacterSet = CharacterSet(250);
 }
 
 impl CharacterSet {
     pub const DEFAULT: CharacterSet = CharacterSet::utf8mb4_general_ci;
 
-    /// Safely construct from a raw protocol byte. Zig's `CharacterSet` is a
-    /// NON-exhaustive `enum(u8)` so `@enumFromInt` is defined for any byte;
-    /// this Rust enum is exhaustive, so unknown discriminants fall back to
-    /// `DEFAULT` via the strum-generated `from_repr` exhaustive match (no
-    /// hand-maintained range list, no `transmute`).
-    /// TODO(port): switch to `#[repr(transparent)] struct(u8)` newtype to keep
-    /// the unknown value (matching Zig semantics) instead of falling back.
+    /// Construct from a raw protocol byte: every byte is valid and unknown
+    /// ids are kept
+    /// as-is (they round-trip back onto the wire unchanged).
     pub const fn from_raw(b: u8) -> Self {
-        match Self::from_repr(b) {
-            Some(cs) => cs,
-            None => Self::DEFAULT,
-        }
+        Self(b)
+    }
+
+    /// The raw wire byte.
+    pub const fn to_int(self) -> u8 {
+        self.0
     }
 
     pub fn label(self) -> &'static str {
-        let n = self as u8;
-        if n < 100 && n > 0 {
-            return <&'static str>::from(self);
+        match self.0 {
+            1 => "big5_chinese_ci",
+            2 => "latin2_czech_cs",
+            3 => "dec8_swedish_ci",
+            4 => "cp850_general_ci",
+            5 => "latin1_german1_ci",
+            6 => "hp8_english_ci",
+            7 => "koi8r_general_ci",
+            8 => "latin1_swedish_ci",
+            9 => "latin2_general_ci",
+            10 => "swe7_swedish_ci",
+            11 => "ascii_general_ci",
+            12 => "ujis_japanese_ci",
+            13 => "sjis_japanese_ci",
+            14 => "cp1251_bulgarian_ci",
+            15 => "latin1_danish_ci",
+            16 => "hebrew_general_ci",
+            18 => "tis620_thai_ci",
+            19 => "euckr_korean_ci",
+            20 => "latin7_estonian_cs",
+            21 => "latin2_hungarian_ci",
+            22 => "koi8u_general_ci",
+            23 => "cp1251_ukrainian_ci",
+            24 => "gb2312_chinese_ci",
+            25 => "greek_general_ci",
+            26 => "cp1250_general_ci",
+            27 => "latin2_croatian_ci",
+            28 => "gbk_chinese_ci",
+            29 => "cp1257_lithuanian_ci",
+            30 => "latin5_turkish_ci",
+            31 => "latin1_german2_ci",
+            32 => "armscii8_general_ci",
+            33 => "utf8mb3_general_ci",
+            34 => "cp1250_czech_cs",
+            35 => "ucs2_general_ci",
+            36 => "cp866_general_ci",
+            37 => "keybcs2_general_ci",
+            38 => "macce_general_ci",
+            39 => "macroman_general_ci",
+            40 => "cp852_general_ci",
+            41 => "latin7_general_ci",
+            42 => "latin7_general_cs",
+            43 => "macce_bin",
+            44 => "cp1250_croatian_ci",
+            45 => "utf8mb4_general_ci",
+            46 => "utf8mb4_bin",
+            47 => "latin1_bin",
+            48 => "latin1_general_ci",
+            49 => "latin1_general_cs",
+            50 => "cp1251_bin",
+            51 => "cp1251_general_ci",
+            52 => "cp1251_general_cs",
+            53 => "macroman_bin",
+            54 => "utf16_general_ci",
+            55 => "utf16_bin",
+            56 => "utf16le_general_ci",
+            57 => "cp1256_general_ci",
+            58 => "cp1257_bin",
+            59 => "cp1257_general_ci",
+            60 => "utf32_general_ci",
+            61 => "utf32_bin",
+            62 => "utf16le_bin",
+            63 => "binary",
+            64 => "armscii8_bin",
+            65 => "ascii_bin",
+            66 => "cp1250_bin",
+            67 => "cp1256_bin",
+            68 => "cp866_bin",
+            69 => "dec8_bin",
+            70 => "greek_bin",
+            71 => "hebrew_bin",
+            72 => "hp8_bin",
+            73 => "keybcs2_bin",
+            74 => "koi8r_bin",
+            75 => "koi8u_bin",
+            76 => "utf8mb3_tolower_ci",
+            77 => "latin2_bin",
+            78 => "latin5_bin",
+            79 => "latin7_bin",
+            80 => "cp850_bin",
+            81 => "cp852_bin",
+            82 => "swe7_bin",
+            83 => "utf8mb3_bin",
+            84 => "big5_bin",
+            85 => "euckr_bin",
+            86 => "gb2312_bin",
+            87 => "gbk_bin",
+            88 => "sjis_bin",
+            89 => "tis620_bin",
+            90 => "ucs2_bin",
+            91 => "ujis_bin",
+            92 => "geostd8_general_ci",
+            93 => "geostd8_bin",
+            94 => "latin1_spanish_ci",
+            95 => "cp932_japanese_ci",
+            96 => "cp932_bin",
+            97 => "eucjpms_japanese_ci",
+            98 => "eucjpms_bin",
+            99 => "cp1250_polish_ci",
+            _ => "(unknown)",
         }
-
-        "(unknown)"
     }
 }
 
@@ -266,5 +358,3 @@ impl Default for CharacterSet {
         Self::DEFAULT
     }
 }
-
-// ported from: src/sql/mysql/protocol/CharacterSet.zig
diff --git a/src/sql/mysql/protocol/ColumnDefinition41.rs b/src/sql/mysql/protocol/ColumnDefinition41.rs
index c8976bbcbc9..1ad228e0416 100644
--- a/src/sql/mysql/protocol/ColumnDefinition41.rs
+++ b/src/sql/mysql/protocol/ColumnDefinition41.rs
@@ -1,4 +1,5 @@
 use crate::mysql::mysql_types::FieldType;
+use crate::mysql::protocol::any_mysql_error::Error as AnyMySQLError;
 use crate::mysql::protocol::new_reader::{NewReader, ReaderContext};
 use crate::shared::column_identifier::ColumnIdentifier;
 use crate::shared::data::Data;
@@ -43,7 +44,6 @@ impl Default for ColumnDefinition41 {
 }
 
 bitflags::bitflags! {
-    // Zig `packed struct` field order is LSB-first; `_padding: u2` rounds to 16 bits.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
     pub struct ColumnFlags: u16 {
         const NOT_NULL         = 1 << 0;
@@ -75,15 +75,11 @@ impl ColumnFlags {
     }
 }
 
-// Zig `deinit` only deinit'd owned `Data`/`ColumnIdentifier` fields — their `Drop` impls
-// handle that automatically in Rust, so no explicit `impl Drop` is needed here.
-
 impl ColumnDefinition41 {
-    // TODO(port): narrow error set
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: &mut NewReader<Context>,
-    ) -> Result<bool, bun_core::Error> {
+    ) -> Result<bool, AnyMySQLError> {
         // Length encoded strings
         self.catalog = reader.encode_len_string()?;
         bun_core::scoped_log!(
@@ -126,25 +122,18 @@ impl ColumnDefinition41 {
         self.fixed_length_fields_length = reader.encoded_len_int()?;
         self.character_set = reader.int::<u16>()?;
         self.column_length = reader.int::<u32>()?;
-        // PORT NOTE: Zig FieldType is a NON-exhaustive `enum(u8)` so `@enumFromInt` accepts
-        // any byte. Rust `#[repr(u8)] enum` is exhaustive, so unknown bytes go through
-        // `from_raw`'s match and error here instead. This diverges from Zig (which keeps
-        // the value) but is sound; if a new server sends an unknown type, we fail loudly
-        // rather than carry an invalid discriminant. TODO(port): switch FieldType to a
-        // `#[repr(transparent)] struct(u8)` newtype to match Zig's non-exhaustive
-        // semantics exactly.
+        // `FieldType` is an exhaustive `#[repr(u8)]` enum, so an unknown wire byte
+        // fails the whole query with `UnsupportedColumnType` rather than being
+        // carried through and served as a raw/string cell. Resolves once
+        // `FieldType` becomes a non-exhaustive newtype-over-u8 (see MySQLTypes.rs).
         let type_byte = reader.int::<u8>()?;
-        self.column_type = FieldType::from_raw(type_byte)
-            .ok_or_else(|| bun_core::err!("UnknownMySQLFieldType"))?;
+        self.column_type =
+            FieldType::from_raw(type_byte).ok_or(AnyMySQLError::UnsupportedColumnType)?;
         self.flags = ColumnFlags::from_int(reader.int::<u16>()?);
         self.decimals = reader.int::<u8>()?;
 
-        // PORT NOTE: Zig called `name_or_index.deinit()` before reassigning; in Rust the
-        // assignment below drops the previous value automatically.
-        // PORT NOTE: reshaped for borrowck — Zig passed `this.name` by value; pass by ref here.
-        // PORT NOTE: `ColumnIdentifier::init` consumes its `Data` (Zig moved by-value
-        // and `errdefer name.deinit()`). We can't move `self.name` while `&mut self`
-        // is borrowed, so feed it a Temporary view of the same bytes.
+        // `ColumnIdentifier::init` consumes its `Data`. We can't move `self.name`
+        // while `&mut self` is borrowed, so feed it a Temporary view of the same bytes.
         //
         // The server re-sends column definitions on every COM_STMT_EXECUTE, so a
         // reused prepared statement re-decodes into the same slot once per query.
@@ -158,7 +147,8 @@ impl ColumnDefinition41 {
         let mut changed = false;
         if !unchanged {
             let name_view = Data::Temporary(bun_ptr::RawSlice::new(self.name.slice()));
-            let rebuilt = ColumnIdentifier::init(name_view)?;
+            let rebuilt =
+                ColumnIdentifier::init(name_view).map_err(|_| AnyMySQLError::OutOfMemory)?;
             changed = match (&self.name_or_index, &rebuilt) {
                 (ColumnIdentifier::Index(prev), ColumnIdentifier::Index(curr)) => prev != curr,
                 _ => true,
@@ -173,15 +163,10 @@ impl ColumnDefinition41 {
         Ok(changed)
     }
 
-    // TODO(refactor): `decoderWrap(ColumnDefinition41, decodeInternal).decode` is a comptime
-    // type-generator that produces a `.decode` wrapper. Consider expressing as a trait impl
-    // (e.g. `impl Decode for ColumnDefinition41`) or a macro from `new_reader`.
     pub fn decode<Context: ReaderContext>(
         &mut self,
         reader: &mut NewReader<Context>,
-    ) -> Result<bool, bun_core::Error> {
+    ) -> Result<bool, AnyMySQLError> {
         self.decode_internal(reader)
     }
 }
-
-// ported from: src/sql/mysql/protocol/ColumnDefinition41.zig
diff --git a/src/sql/mysql/protocol/CommandType.rs b/src/sql/mysql/protocol/CommandType.rs
index e2e3ae1662e..efb6b1d429b 100644
--- a/src/sql/mysql/protocol/CommandType.rs
+++ b/src/sql/mysql/protocol/CommandType.rs
@@ -34,5 +34,3 @@ pub enum CommandType {
     COM_BINLOG_DUMP_GTID = 0x1e,
     COM_RESET_CONNECTION = 0x1f,
 }
-
-// ported from: src/sql/mysql/protocol/CommandType.zig
diff --git a/src/sql/mysql/protocol/EOFPacket.rs b/src/sql/mysql/protocol/EOFPacket.rs
index d8c5e08fea9..4e48441a07b 100644
--- a/src/sql/mysql/protocol/EOFPacket.rs
+++ b/src/sql/mysql/protocol/EOFPacket.rs
@@ -1,4 +1,5 @@
 use super::super::status_flags::StatusFlags;
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::new_reader::{NewReader, ReaderContext};
 
 pub struct EOFPacket {
@@ -21,11 +22,10 @@ impl EOFPacket {
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyMySQLError> {
         self.header = reader.int::<u8>()?;
         if self.header != 0xfe {
-            return Err(bun_core::err!("InvalidEOFPacket"));
+            return Err(AnyMySQLError::InvalidEOFPacket);
         }
 
         self.warnings = reader.int::<u16>()?;
@@ -34,14 +34,11 @@ impl EOFPacket {
     }
 }
 
-// Zig: pub const decode = decoderWrap(EOFPacket, decodeInternal).decode;
 impl EOFPacket {
     pub fn decode<Context: ReaderContext>(
         &mut self,
         context: Context,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/mysql/protocol/EOFPacket.zig
diff --git a/src/sql/mysql/protocol/EncodeInt.rs b/src/sql/mysql/protocol/EncodeInt.rs
index e54c6a79953..90224bc7f8b 100644
--- a/src/sql/mysql/protocol/EncodeInt.rs
+++ b/src/sql/mysql/protocol/EncodeInt.rs
@@ -88,5 +88,3 @@ pub fn decode_length_int(bytes: &[u8]) -> Option<DecodedLengthInt> {
         }),
     }
 }
-
-// ported from: src/sql/mysql/protocol/EncodeInt.zig
diff --git a/src/sql/mysql/protocol/ErrorPacket.rs b/src/sql/mysql/protocol/ErrorPacket.rs
index 913a0cd9b1e..6ec46355616 100644
--- a/src/sql/mysql/protocol/ErrorPacket.rs
+++ b/src/sql/mysql/protocol/ErrorPacket.rs
@@ -1,3 +1,4 @@
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::new_reader::{NewReader, ReaderContext};
 use crate::shared::Data;
 
@@ -21,28 +22,24 @@ impl Default for ErrorPacket {
     }
 }
 
-// Zig `deinit` only freed `error_message`; `Data: Drop` handles that automatically.
-
 pub struct MySQLErrorOptions {
-    // TODO(port): verify lifetime — Zig `[]const u8` field with no deinit; assuming static literal
+    // Every constructor (error_packet_jsc.rs, any_mysql_error_jsc.rs) passes a
+    // `b"ERR_..."` literal, so `'static` holds.
     pub code: &'static [u8],
     pub errno: Option<u16>,
     pub sql_state: Option<[u8; 5]>,
 }
 
-// No `impl Default` — Zig `code: []const u8` has no default, so `.{}` is invalid there too.
-
 // `createMySQLError` lives in bun_sql_jsc::mysql::protocol::error_packet_jsc — *_jsc alias deleted.
 
 impl ErrorPacket {
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyMySQLError> {
         self.header = reader.int::<u8>()?;
         if self.header != 0xff {
-            return Err(bun_core::err!("InvalidErrorPacket"));
+            return Err(AnyMySQLError::InvalidErrorPacket);
         }
 
         self.error_code = reader.int::<u16>()?;
@@ -63,22 +60,19 @@ impl ErrorPacket {
             reader.skip(-1);
         }
 
-        // Read the error message (rest of packet)
-        // PORT NOTE: reshaped for borrowck — capture peek().len() before mut call
+        // Read the error message (rest of packet).
+        // Reshaped for borrowck — capture peek().len() before the mut call.
         let remaining = reader.peek().len();
         self.error_message = reader.read(remaining)?;
         Ok(())
     }
 }
 
-// Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
 pub fn decode<Context: ReaderContext>(
     this: &mut ErrorPacket,
     reader: NewReader<Context>,
-) -> Result<(), bun_core::Error> {
+) -> Result<(), AnyMySQLError> {
     this.decode_internal(reader)
 }
 
 // `toJS` lives in bun_sql_jsc::mysql::protocol::error_packet_jsc — *_jsc alias deleted.
-
-// ported from: src/sql/mysql/protocol/ErrorPacket.zig
diff --git a/src/sql/mysql/protocol/HandshakeResponse41.rs b/src/sql/mysql/protocol/HandshakeResponse41.rs
index 54ecac8ed81..a57468d00a0 100644
--- a/src/sql/mysql/protocol/HandshakeResponse41.rs
+++ b/src/sql/mysql/protocol/HandshakeResponse41.rs
@@ -1,5 +1,6 @@
 // Client authentication response
 
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::character_set::CharacterSet;
 use super::encode_int::encode_length_int;
 use super::new_writer::NewWriter;
@@ -21,16 +22,11 @@ pub struct HandshakeResponse41 {
     pub sequence_id: u8,
 }
 
-// Zig `deinit` only freed owned fields (Data values + connect_attrs keys/values).
-// In Rust, `Data: Drop` and `StringHashMap<Box<[u8]>>: Drop` handle this automatically,
-// so no explicit `impl Drop` is needed.
-
 impl HandshakeResponse41 {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &mut self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyMySQLError> {
         let mut packet = writer.start(self.sequence_id)?;
 
         self.capability_flags.CLIENT_CONNECT_ATTRS = self.connect_attrs.len() > 0;
@@ -50,7 +46,7 @@ impl HandshakeResponse41 {
         writer.int4(self.max_packet_size)?;
 
         // Write character set (1 byte)
-        writer.int1(self.character_set as u8)?;
+        writer.int1(self.character_set.to_int())?;
 
         // Write 23 bytes of padding
         writer.write(&[0u8; 23])?;
@@ -106,13 +102,10 @@ impl HandshakeResponse41 {
         Ok(())
     }
 
-    // Zig `writeWrap(@This(), ...)` — see src/sql/mysql/protocol/NewWriter.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &mut self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/mysql/protocol/HandshakeResponse41.zig
diff --git a/src/sql/mysql/protocol/HandshakeV10.rs b/src/sql/mysql/protocol/HandshakeV10.rs
index 14dc12c199a..bcae2ba4b2b 100644
--- a/src/sql/mysql/protocol/HandshakeV10.rs
+++ b/src/sql/mysql/protocol/HandshakeV10.rs
@@ -3,6 +3,7 @@
 use crate::mysql::Capabilities;
 use crate::mysql::StatusFlags;
 use crate::mysql::protocol::CharacterSet;
+use crate::mysql::protocol::any_mysql_error::Error as AnyMySQLError;
 use crate::mysql::protocol::new_reader::{NewReader, ReaderContext};
 use crate::shared::Data;
 
@@ -34,19 +35,15 @@ impl Default for HandshakeV10 {
     }
 }
 
-// Zig `deinit` only frees owned fields (`server_version`, `auth_plugin_name`); Rust drops
-// `Data` / `Box<[u8]>` fields automatically, so no explicit `impl Drop` is needed.
-
 impl HandshakeV10 {
-    // TODO(port): narrow error set
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         // Protocol version
         self.protocol_version = reader.int::<u8>()?;
         if self.protocol_version != 10 {
-            return Err(bun_core::err!("UnsupportedProtocolVersion"));
+            return Err(AnyMySQLError::UnsupportedProtocolVersion);
         }
 
         // Server version (null-terminated string)
@@ -66,8 +63,7 @@ impl HandshakeV10 {
         // Capability flags (lower 2 bytes)
         let capabilities_lower = reader.int::<u16>()?;
 
-        // Character set — Zig uses non-exhaustive `enum(u8)` so any byte is valid;
-        // Rust enum is exhaustive, so route through the range-checked constructor.
+        // Character set — any byte is valid; unknown collation ids are preserved.
         self.character_set = CharacterSet::from_raw(reader.int::<u8>()?);
 
         // Status flags
@@ -102,7 +98,4 @@ impl HandshakeV10 {
     }
 }
 
-// Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
 pub use self::HandshakeV10 as _DecoderWrapTarget;
-
-// ported from: src/sql/mysql/protocol/HandshakeV10.zig
diff --git a/src/sql/mysql/protocol/LocalInfileRequest.rs b/src/sql/mysql/protocol/LocalInfileRequest.rs
index 16cb9d06ecc..a45c08f95d7 100644
--- a/src/sql/mysql/protocol/LocalInfileRequest.rs
+++ b/src/sql/mysql/protocol/LocalInfileRequest.rs
@@ -1,10 +1,11 @@
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::new_reader::{NewReader, ReaderContext};
 use crate::shared::Data;
 
 pub struct LocalInfileRequest {
     pub filename: Data,
-    // TODO(port): Zig `u24` — Rust has no native u24; using u32. Verify wire-format
-    // callers populate this from the 3-byte MySQL packet length correctly.
+    // Callers populate this from `PacketHeader.length`, the 3-byte
+    // MySQL packet length (always <= 0xFFFFFF), so `u32` holds it losslessly.
     pub packet_size: u32,
 }
 
@@ -12,37 +13,30 @@ impl Default for LocalInfileRequest {
     fn default() -> Self {
         Self {
             filename: Data::Empty,
-            // packet_size has no Zig default; caller must set before decode.
+            // Caller must set packet_size before decode.
             packet_size: 0,
         }
     }
 }
 
-// Zig `deinit` only called `this.filename.deinit()`; `Data` owns its drop, so no
-// explicit `impl Drop` is needed here.
-
 impl LocalInfileRequest {
-    // TODO(port): narrow error set
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         let header = reader.int::<u8>()?;
         if header != 0xFB {
-            return Err(bun_core::err!("InvalidLocalInfileRequest"));
+            return Err(AnyMySQLError::InvalidLocalInfileRequest);
         }
 
         self.filename = reader.read((self.packet_size - 1) as usize)?;
         Ok(())
     }
 
-    // Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
     pub fn decode<Context: ReaderContext>(
         &mut self,
         context: Context,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/mysql/protocol/LocalInfileRequest.zig
diff --git a/src/sql/mysql/protocol/NewReader.rs b/src/sql/mysql/protocol/NewReader.rs
index c0c49eba9ea..f4790d47c6a 100644
--- a/src/sql/mysql/protocol/NewReader.rs
+++ b/src/sql/mysql/protocol/NewReader.rs
@@ -2,13 +2,7 @@ use super::any_mysql_error::Error as AnyMySQLError;
 use super::encode_int::decode_length_int;
 use crate::shared::data::Data;
 
-/// Trait capturing the structural interface that Zig's `NewReaderWrap` took as
-/// seven comptime fn params (`markMessageStartFn_`, `peekFn_`, `skipFn_`,
-/// `ensureCapacityFn_`, `readFunction_`, `readZ_`, `setOffsetFromStart_`).
-///
-/// In Zig, `NewReader(Context)` reflected `Context.markMessageStart` etc. via
-/// `@hasDecl`; in Rust the trait bound IS that check (see PORTING.md §Comptime
-/// reflection).
+/// Structural interface a reader context must provide for protocol decoding.
 pub trait ReaderContext: Copy {
     fn mark_message_start(self);
     // `&self` (not `self`) so the returned borrow can be tied to the context's
@@ -21,22 +15,12 @@ pub trait ReaderContext: Copy {
     fn set_offset_from_start(self, offset: usize);
 }
 
-// PORT NOTE: Zig's `NewReaderWrap(Context, fn, fn, fn, fn, fn, fn, fn) type`
-// returned an anonymous `struct { wrapped: Context, ... }`. In Rust the comptime
-// fn-pointer params collapse into the `ReaderContext` trait above, and the
-// returned struct becomes this generic wrapper. `NewReader(Context)` (which
-// checked `@hasDecl(Context, "is_wrapped")` to avoid double-wrapping) is
-// subsumed: callers name `NewReader<C>` directly and the type system prevents
-// accidental double-wrap.
 #[derive(Clone, Copy)]
 pub struct NewReader<C: ReaderContext> {
     pub wrapped: C,
 }
 
 impl<C: ReaderContext> NewReader<C> {
-    // PORT NOTE: Zig `pub const Ctx = Context` — in Rust the generic param `C` IS
-    // the name; inherent associated types are unstable, so callers name `C` directly.
-
     pub const IS_WRAPPED: bool = true;
 
     pub fn mark_message_start(self) {
@@ -52,7 +36,6 @@ impl<C: ReaderContext> NewReader<C> {
     }
 
     pub fn skip(self, count: impl TryInto<isize>) {
-        // Zig: skipFn(this.wrapped, @as(isize, @intCast(count)))
         self.wrapped
             .skip(count.try_into().ok().expect("skip count fits in isize"));
     }
@@ -81,26 +64,24 @@ impl<C: ReaderContext> NewReader<C> {
         let data = self.read(I::SIZE)?;
         // `defer data.deinit()` → Drop on scope exit
         if I::SIZE == 1 {
-            // Zig: if (comptime Int == u8) return data.slice()[0]
             return Ok(I::from_ne_slice(&data.slice()[..1]));
         }
-        // Zig: @bitCast(data.slice()[0..size].*) — native-endian byte reinterpretation
+        // Native-endian byte reinterpretation.
         Ok(I::from_ne_slice(&data.slice()[..I::SIZE]))
     }
 
-    /// Zig `reader.int(u24)`. MySQL's binary result-row protocol transmits
-    /// `MYSQL_TYPE_INT24` as a fixed 4-byte field; Zig consumes `@sizeOf(u24)`
-    /// (== 4, ABI size rounds 24 bits up to 4-byte alignment) and decodes the
-    /// low 3 bytes. Consuming only 3 leaves the cursor 1 byte behind and
-    /// corrupts every subsequent column.
+    /// MySQL's binary result-row protocol transmits `MYSQL_TYPE_INT24` as a
+    /// fixed 4-byte field; consume all 4 bytes and decode the low 3.
+    /// Consuming only 3 leaves the cursor 1 byte behind and corrupts every
+    /// subsequent column.
     pub fn int_u24(self) -> Result<u32, AnyMySQLError> {
         let data = self.read(4)?;
         let s = data.slice();
         Ok(u32::from_le_bytes([s[0], s[1], s[2], 0]))
     }
 
-    /// Zig `reader.int(i24)` — consume 4 bytes (see [`Self::int_u24`]), decode
-    /// the low 3 little-endian bytes and sign-extend to i32.
+    /// Consume 4 bytes (see [`Self::int_u24`]), decode the low 3
+    /// little-endian bytes and sign-extend to i32.
     pub fn int_i24(self) -> Result<i32, AnyMySQLError> {
         let data = self.read(4)?;
         let s = data.slice();
@@ -125,43 +106,24 @@ impl<C: ReaderContext> NewReader<C> {
         Err(AnyMySQLError::InvalidEncodedInteger)
     }
 
-    pub fn encoded_len_int_with_size(self, size: &mut usize) -> Result<u64, bun_core::Error> {
-        // TODO(port): narrow error set
+    pub fn encoded_len_int_with_size(self, size: &mut usize) -> Result<u64, AnyMySQLError> {
         if let Some(result) = decode_length_int(self.peek()) {
             self.skip(result.bytes_read);
             *size += result.bytes_read;
             return Ok(result.value);
         }
-        Err(bun_core::err!("InvalidEncodedInteger"))
+        Err(AnyMySQLError::InvalidEncodedInteger)
     }
 }
 
-/// Helper trait replacing Zig's `comptime Int: type` + `@typeInfo(Int).int.bits`
-/// reflection in `int()`. The canonical native-endian int codec lives in
-/// `bun_core`; re-exported here under the protocol-local name so callers
-/// (`int<I: ReadableInt>()` and `bun_sql::ReadableInt`) keep their paths.
+/// The canonical native-endian int codec lives in `bun_core`; re-exported here
+/// under the protocol-local name so callers (`int<I: ReadableInt>()` and
+/// `bun_sql::ReadableInt`) keep their paths.
 /// MySQL's u24/i24 are NOT routed through this trait — see `int_u24`/`int_i24`.
 pub use bun_core::NativeEndianInt as ReadableInt;
 
-/// Zig: `fn NewReader(comptime Context: type) type` — returned `Context` unchanged
-/// if it already had `is_wrapped`, else `NewReaderWrap(Context, Context.fn...)`.
-///
-/// In Rust this is just the `NewReader<C>` struct above; the `@hasDecl` early-return
-/// is unnecessary because Rust callers name the concrete type. Kept as a type alias
-/// for diff parity.
 pub type NewReaderOf<C> = NewReader<C>;
 
-// ─── decoderWrap ──────────────────────────────────────────────────────────────
-//
-// Zig: `fn decoderWrap(comptime Container, comptime decodeFn) type` returned a
-// struct with `decode` / `decodeAllocator` that auto-wrapped `context` into
-// `.{ .wrapped = context }` when `Context` lacked `is_wrapped`.
-//
-// PORT NOTE: the `@hasDecl(Context, "is_wrapped")` branch collapses — in Rust,
-// callers either already have a `NewReader<C>` or a bare `C: ReaderContext`, and
-// `Into<NewReader<C>>` covers both. The allocator-taking variant drops its
-// `std.mem.Allocator` param per PORTING.md §Allocators (non-AST crate).
-
 impl<C: ReaderContext> From<C> for NewReader<C> {
     fn from(wrapped: C) -> Self {
         Self { wrapped }
@@ -181,15 +143,10 @@ pub trait Decode: Sized {
         self.decode_internal(context.into())
     }
 
-    // Zig `decodeAllocator` — allocator param deleted (global mimalloc).
     fn decode_allocator<C: ReaderContext>(
         &mut self,
         context: impl Into<NewReader<C>>,
     ) -> Result<(), AnyMySQLError> {
-        // TODO(port): some Zig decodeFn callees took (this, allocator, Context, ctx);
-        // confirm none need a distinct arena before unifying with `decode`.
         self.decode_internal(context.into())
     }
 }
-
-// ported from: src/sql/mysql/protocol/NewReader.zig
diff --git a/src/sql/mysql/protocol/NewWriter.rs b/src/sql/mysql/protocol/NewWriter.rs
index fe2dd9a4d09..44b61d22a63 100644
--- a/src/sql/mysql/protocol/NewWriter.rs
+++ b/src/sql/mysql/protocol/NewWriter.rs
@@ -6,10 +6,7 @@ use bun_core::String as BunString;
 
 bun_core::declare_scope!(NewWriter, hidden);
 
-/// Zig's `NewWriterWrap` passes `offsetFn`/`writeFn`/`pwriteFn` as comptime
-/// fn-pointer params. In Rust those become required methods on a trait that
-/// `Context` implements; `NewWriter(Context)` then just calls them through the
-/// trait bound.
+/// Structural interface a writer context must provide for protocol encoding.
 pub trait WriterContext: Copy {
     fn offset(self) -> usize;
     fn write(self, bytes: &[u8]) -> Result<(), AnyMySQLError>;
@@ -102,16 +99,11 @@ impl<C: WriterContext> NewWriterWrap<C> {
         self.write(&[value])
     }
 
-    /// Zig: `Query.zig` calls `writer.writeNullBitmap(this.params)` on the
-    /// `NewWriter` value. The Zig source never defines this on `NewWriterWrap`
-    /// (lazy compilation: the params branch is never instantiated for COM_QUERY
-    /// in practice), but Rust must have it to typecheck. Mirrors the bitmap
-    /// logic from `PreparedStatement.zig::writeNullBitmap`, keyed on
-    /// `Data::Empty` instead of `Value::Null`.
+    /// Write the NULL bitmap for `params`, keyed on `Data::Empty`. This branch
+    /// is never taken for COM_QUERY in practice.
     pub fn write_null_bitmap(self, params: &[crate::shared::Data]) -> Result<(), AnyMySQLError> {
         let bitmap_bytes = params.len().div_ceil(8);
-        // PERF(port): Zig sized this from `(u16::MAX / 8) + 1` on the stack;
-        // here a small Vec keeps stack usage bounded for the never-taken path.
+        // A small Vec keeps stack usage bounded for the never-taken path.
         let mut null_bitmap = vec![0u8; bitmap_bytes];
         for (i, param) in params.iter().enumerate() {
             if matches!(param, crate::shared::Data::Empty) {
@@ -146,19 +138,14 @@ impl<C: WriterContext> NewWriterWrap<C> {
     }
 }
 
-/// In Zig, `NewWriter(Context)` returns `Context` unchanged when it already has
-/// `is_wrapped`, otherwise wraps it via `NewWriterWrap`. Rust cannot branch on a
-/// type-level decl, so callers that already hold a `NewWriterWrap<C>` should use
-/// it directly; this alias covers the wrapping case.
-// TODO(refactor): @hasDecl(Context, "is_wrapped") short-circuit — ensure no
-// caller double-wraps; if needed, model via a `MySQLWriter` trait with a blanket
-// impl for `NewWriterWrap<C>`.
+/// Callers that already hold a `NewWriterWrap<C>` should use it directly; this
+/// alias covers the wrapping case.
+// TODO(refactor): ensure no caller double-wraps; if needed, model via a
+// `MySQLWriter` trait with a blanket impl for `NewWriterWrap<C>`.
 pub type NewWriter<C> = NewWriterWrap<C>;
 
-/// Zig's `writeWrap(Container, writeFn)` returns a struct with a `write` method
-/// that auto-wraps a raw context into `NewWriterWrap` before forwarding to
-/// `writeFn`. In Rust this is a free helper that the per-packet `write` impls
-/// call directly.
+/// Wraps a raw context into `NewWriterWrap` before forwarding to the
+/// per-packet `write` impl.
 #[inline]
 pub fn write_wrap<Container, C, F>(
     this: &mut Container,
@@ -171,5 +158,3 @@ where
 {
     write_fn(this, NewWriterWrap { wrapped: context })
 }
-
-// ported from: src/sql/mysql/protocol/NewWriter.zig
diff --git a/src/sql/mysql/protocol/OKPacket.rs b/src/sql/mysql/protocol/OKPacket.rs
index aad11923f86..872ba0a8a2c 100644
--- a/src/sql/mysql/protocol/OKPacket.rs
+++ b/src/sql/mysql/protocol/OKPacket.rs
@@ -1,5 +1,6 @@
 // OK Packet
 use crate::mysql::StatusFlags;
+use crate::mysql::protocol::any_mysql_error::Error as AnyMySQLError;
 use crate::mysql::protocol::new_reader::{NewReader, ReaderContext};
 use crate::shared::Data;
 
@@ -14,24 +15,18 @@ pub struct OKPacket {
     pub packet_size: u32,
 }
 
-// Zig field defaults: header=0x00, affected_rows=0, last_insert_id=0, status_flags={},
-// warnings=0, info=.empty, session_state_changes=.empty. `packet_size` has NO default
-// (caller must supply it), so no `Default` impl — consider adding `OKPacket::new(packet_size)`.
-
-// Zig `deinit` only called `this.info.deinit()` and `this.session_state_changes.deinit()`.
-// `Data` owns its buffer and has `Drop`, so Rust drops fields automatically — no explicit
-// `impl Drop` needed.
+// `packet_size` must be supplied by the caller, so no `Default` impl —
+// consider adding `OKPacket::new(packet_size)`.
 
 impl OKPacket {
-    // TODO(port): narrow error set (InvalidOKPacket + reader errors)
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         let mut read_size: usize = 5; // header + status flags + warnings
         self.header = reader.int::<u8>()?;
         if self.header != 0x00 && self.header != 0xfe {
-            return Err(bun_core::err!("InvalidOKPacket"));
+            return Err(AnyMySQLError::InvalidOKPacket);
         }
 
         // Affected rows (length encoded integer)
@@ -48,14 +43,10 @@ impl OKPacket {
         // Info (EOF-terminated string)
         if !reader.peek().is_empty() && (self.packet_size as usize) > read_size {
             let remaining = (self.packet_size as usize) - read_size;
-            // Zig: @truncate(remaining) — intentional wrap to reader.read's arg type
             self.info = reader.read(remaining as _)?;
         }
         Ok(())
     }
 }
 
-// Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
 pub use self::OKPacket as _DecoderWrapTarget;
-
-// ported from: src/sql/mysql/protocol/OKPacket.zig
diff --git a/src/sql/mysql/protocol/PacketHeader.rs b/src/sql/mysql/protocol/PacketHeader.rs
index 760ec63188b..b1261152d51 100644
--- a/src/sql/mysql/protocol/PacketHeader.rs
+++ b/src/sql/mysql/protocol/PacketHeader.rs
@@ -32,5 +32,3 @@ impl PacketHeader {
         ]
     }
 }
-
-// ported from: src/sql/mysql/protocol/PacketHeader.zig
diff --git a/src/sql/mysql/protocol/PacketType.rs b/src/sql/mysql/protocol/PacketType.rs
index a639635e57d..89bf82db28e 100644
--- a/src/sql/mysql/protocol/PacketType.rs
+++ b/src/sql/mysql/protocol/PacketType.rs
@@ -1,7 +1,6 @@
-// PORT NOTE: Zig source is a non-exhaustive `enum(u8)` (trailing `_`), meaning
-// any u8 value is a valid PacketType. A Rust `#[repr(u8)] enum` would make
-// unlisted values UB on transmute, so this is ported as a transparent u8
-// newtype with associated consts instead.
+// Any u8 value is a valid PacketType (the wire can carry unlisted bytes). A
+// Rust `#[repr(u8)] enum` would make unlisted values UB on transmute, so this
+// is a transparent u8 newtype with associated consts instead.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct PacketType(pub u8);
@@ -19,5 +18,3 @@ impl PacketType {
 
     pub const AUTH_SWITCH: u8 = 0xfe;
 }
-
-// ported from: src/sql/mysql/protocol/PacketType.zig
diff --git a/src/sql/mysql/protocol/PreparedStatement.rs b/src/sql/mysql/protocol/PreparedStatement.rs
index 17f5812d6b1..a86530e67fb 100644
--- a/src/sql/mysql/protocol/PreparedStatement.rs
+++ b/src/sql/mysql/protocol/PreparedStatement.rs
@@ -18,14 +18,13 @@ pub struct PrepareOK {
 }
 
 impl PrepareOK {
-    // TODO(port): narrow error set
     pub fn decode_internal<C: ReaderContext>(
         &mut self,
         reader: NewReader<C>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), any_mysql_error::Error> {
         self.status = reader.int::<u8>()?;
         if self.status != 0 {
-            return Err(bun_core::err!("InvalidPrepareOKPacket"));
+            return Err(any_mysql_error::Error::InvalidPrepareOKPacket);
         }
 
         self.statement_id = reader.int::<u32>()?;
@@ -36,11 +35,10 @@ impl PrepareOK {
         Ok(())
     }
 
-    // Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
     pub fn decode<C: ReaderContext>(
         &mut self,
         reader: NewReader<C>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), any_mysql_error::Error> {
         self.decode_internal(reader)
     }
 }
@@ -60,13 +58,11 @@ pub struct Execute<'a> {
     pub params: ExecuteParams<'a>,
 }
 
-/// Stand-in for the `params: []Value` field while `Value` lives in the
-/// higher-tier `bun_sql_jsc` crate. Carries the borrowed slice as raw bytes so
-/// `len()` is real; encoding goes through the `is_null` / `to_data` hooks
-/// which the jsc-side caller fills in. TODO(refactor): replace this with a trait
-/// or move `Execute` itself up-tier (matches the Query::Execute precedent of
-/// taking `&mut [Data]`).
-// TODO(port): bun_sql_jsc::mysql::mysql_value::Value
+/// `Value` (`bun_sql_jsc::mysql::mysql_value::Value`) lives in the
+/// higher-tier `bun_sql_jsc` crate, which this crate cannot depend on. The
+/// borrowed slice is carried behind a context pointer so `len` is real;
+/// encoding goes through the `is_null` / `to_data` hooks the jsc-side caller
+/// fills in.
 pub struct ExecuteParams<'a> {
     pub len: usize,
     pub ctx: *mut core::ffi::c_void,
@@ -81,7 +77,6 @@ pub struct ExecuteParams<'a> {
     pub _marker: core::marker::PhantomData<&'a ()>,
 }
 
-// PORT NOTE: Zig `deinit` freed `params` (and each Value inside) via default_allocator.
 // Ownership of params stays with the caller (borrowed slice) — no Drop here.
 
 impl<'a> Execute<'a> {
@@ -146,7 +141,6 @@ impl<'a> Execute<'a> {
                 }
 
                 let value = (self.params.to_data)(self.params.ctx, i, param_type.r#type)?;
-                // PORT NOTE: Zig `defer value.deinit()` — handled by Drop on `value`.
                 if param_type.r#type.is_binary_format_supported() {
                     writer.write(value.slice())?;
                 } else {
@@ -157,7 +151,6 @@ impl<'a> Execute<'a> {
         Ok(())
     }
 
-    // Zig `writeWrap(@This(), ...)` — see src/sql/mysql/protocol/NewWriter.rs
     pub fn write<C: WriterContext>(
         &self,
         writer: NewWriter<C>,
@@ -165,5 +158,3 @@ impl<'a> Execute<'a> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/mysql/protocol/PreparedStatement.zig
diff --git a/src/sql/mysql/protocol/Query.rs b/src/sql/mysql/protocol/Query.rs
index 26aa2364f3c..098b4c70d64 100644
--- a/src/sql/mysql/protocol/Query.rs
+++ b/src/sql/mysql/protocol/Query.rs
@@ -1,5 +1,6 @@
 use crate::mysql::mysql_param::Param;
 use crate::mysql::mysql_types::FieldType;
+use crate::mysql::protocol::any_mysql_error::Error as AnyMySQLError;
 use crate::mysql::protocol::column_definition41::ColumnFlags;
 use crate::mysql::protocol::command_type::CommandType;
 use crate::mysql::protocol::new_writer::{NewWriter, WriterContext};
@@ -7,7 +8,7 @@ use crate::shared::data::Data;
 
 bun_core::declare_scope!(MySQLQuery, visible);
 
-// PORT NOTE: Execute is a transient builder that borrows query/params/param_types
+// Execute is a transient builder that borrows query/params/param_types
 // from the caller for the duration of a single write() call. Most protocol
 // message structs avoid lifetime params; this one carries an explicit `'a`
 // because none of Box / &'static / raw fit a borrow-only message builder.
@@ -19,17 +20,15 @@ pub struct Execute<'a> {
     pub param_types: &'a [Param],
 }
 
-// PORT NOTE: Zig `deinit` iterated `params` and called `param.deinit()` on each.
-// In Rust, `Data` owns its resources via `Drop`, and `Execute` only borrows the
-// slice, so the slice owner is responsible for cleanup. No `Drop` impl here.
-// TODO(port): verify caller of Execute handles Data cleanup after write.
+// `Data` owns its resources via `Drop`, and `Execute` only borrows the
+// slice, so the slice owner is responsible for cleanup (each `Data`'s `Drop`
+// runs when the owning slice is dropped after `write`).
 
 impl<'a> Execute<'a> {
-    // TODO(port): narrow error set
     pub fn write_internal<C: WriterContext>(
         &self,
         writer: NewWriter<C>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         let mut packet = writer.start(0)?;
         writer.int1(CommandType::COM_QUERY as u8)?;
         writer.write(self.query)?;
@@ -55,8 +54,7 @@ impl<'a> Execute<'a> {
                 let param_name = {
                     use std::io::Write;
                     let mut cursor = std::io::Cursor::new(&mut param_name_buf[..]);
-                    write!(&mut cursor, ":p{}", i)
-                        .map_err(|_| bun_core::err!("TooManyParameters"))?;
+                    write!(&mut cursor, ":p{}", i).map_err(|_| AnyMySQLError::TooManyParameters)?;
                     let len = usize::try_from(cursor.position()).expect("int cast");
                     &param_name_buf[..len]
                 };
@@ -76,7 +74,6 @@ impl<'a> Execute<'a> {
                     "Write param type {} len {} hex {:02x?}",
                     <&'static str>::from(param_type.r#type),
                     value.len(),
-                    // TODO(port): Zig `{x}` hex-dumps the slice; verify formatting matches
                     value,
                 );
                 if param_type.r#type.is_binary_format_supported() {
@@ -90,27 +87,16 @@ impl<'a> Execute<'a> {
         Ok(())
     }
 
-    // Zig: `pub const write = writeWrap(Execute, writeInternal).write;`
-    // PORT NOTE: Zig's `writeWrap` constructs a `NewWriter` around a raw context
-    // and calls `write_internal`. Here `writer` is already wrapped, so forward
-    // directly — `write_wrap`'s only job (the wrapping) is done by the caller.
-    pub fn write<C: WriterContext>(&self, writer: NewWriter<C>) -> Result<(), bun_core::Error> {
+    // `writer` is already wrapped, so forward directly.
+    pub fn write<C: WriterContext>(&self, writer: NewWriter<C>) -> Result<(), AnyMySQLError> {
         self.write_internal(writer)
     }
 }
 
-// Zig: `writer: anytype` — body calls .start/.int1/.write. Bound on the
-// concrete `NewWriter<C>` shape (the only `anytype` instantiation in-tree).
-pub fn execute<C: WriterContext>(
-    query: &[u8],
-    writer: NewWriter<C>,
-) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
+pub fn execute<C: WriterContext>(query: &[u8], writer: NewWriter<C>) -> Result<(), AnyMySQLError> {
     let mut packet = writer.start(0)?;
     writer.int1(CommandType::COM_QUERY as u8)?;
     writer.write(query)?;
     packet.end()?;
     Ok(())
 }
-
-// ported from: src/sql/mysql/protocol/Query.zig
diff --git a/src/sql/mysql/protocol/ResultSetHeader.rs b/src/sql/mysql/protocol/ResultSetHeader.rs
index 4da16b1205e..f62e7680d2f 100644
--- a/src/sql/mysql/protocol/ResultSetHeader.rs
+++ b/src/sql/mysql/protocol/ResultSetHeader.rs
@@ -1,3 +1,4 @@
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::new_reader::{NewReader, ReaderContext};
 
 #[derive(Default)]
@@ -9,22 +10,16 @@ impl ResultSetHeader {
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyMySQLError> {
         // Field count (length encoded integer)
         self.field_count = reader.encoded_len_int()?;
         Ok(())
     }
 
-    // TODO(refactor): `decoderWrap(ResultSetHeader, decodeInternal).decode` is a Zig comptime
-    // type-function that wraps `decode_internal` over an anyopaque-backed reader. Consider
-    // replacing this with the trait/impl that `new_reader::decoder_wrap` exposes.
     pub fn decode<Context: ReaderContext>(
         &mut self,
         context: Context,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/mysql/protocol/ResultSetHeader.zig
diff --git a/src/sql/mysql/protocol/SSLRequest.rs b/src/sql/mysql/protocol/SSLRequest.rs
index 0386baaa698..82784e4aafd 100644
--- a/src/sql/mysql/protocol/SSLRequest.rs
+++ b/src/sql/mysql/protocol/SSLRequest.rs
@@ -2,6 +2,7 @@
 // SSLRequest
 
 use crate::mysql::Capabilities;
+use crate::mysql::protocol::any_mysql_error::Error as AnyMySQLError;
 use crate::mysql::protocol::character_set::CharacterSet;
 use crate::mysql::protocol::new_writer::NewWriter;
 
@@ -27,14 +28,10 @@ impl Default for SSLRequest {
 }
 
 impl SSLRequest {
-    // Zig: pub fn deinit(_: *SSLRequest) void {}
-    // Empty deinit → no Drop impl needed.
-
-    // TODO(port): narrow error set
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &mut self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         let mut packet = writer.start(1)?;
 
         self.capability_flags.CLIENT_CONNECT_ATTRS = self.has_connection_attributes;
@@ -53,7 +50,7 @@ impl SSLRequest {
         writer.int4(self.max_packet_size)?;
 
         // Write character set (1 byte)
-        writer.int1(self.character_set as u8)?;
+        writer.int1(self.character_set.to_int())?;
 
         // Write 23 bytes of padding
         writer.write(&[0u8; 23])?;
@@ -61,8 +58,4 @@ impl SSLRequest {
         packet.end()?;
         Ok(())
     }
-
-    // Zig `writeWrap(@This(), ...)` — see src/sql/mysql/protocol/NewWriter.rs
 }
-
-// ported from: src/sql/mysql/protocol/SSLRequest.zig
diff --git a/src/sql/mysql/protocol/StackReader.rs b/src/sql/mysql/protocol/StackReader.rs
index 3b1e2b5d85d..d996366948d 100644
--- a/src/sql/mysql/protocol/StackReader.rs
+++ b/src/sql/mysql/protocol/StackReader.rs
@@ -114,5 +114,3 @@ impl<'a> ReaderContext for StackReader<'a> {
         Self::set_offset_from_start(&self, offset)
     }
 }
-
-// ported from: src/sql/mysql/protocol/StackReader.zig
diff --git a/src/sql/mysql/protocol/StmtPrepareOKPacket.rs b/src/sql/mysql/protocol/StmtPrepareOKPacket.rs
index 7d02fedc3b8..054eb45c61d 100644
--- a/src/sql/mysql/protocol/StmtPrepareOKPacket.rs
+++ b/src/sql/mysql/protocol/StmtPrepareOKPacket.rs
@@ -1,3 +1,4 @@
+use super::any_mysql_error::Error as AnyMySQLError;
 use super::new_reader::{NewReader, ReaderContext};
 
 #[derive(Default)]
@@ -11,14 +12,13 @@ pub struct StmtPrepareOKPacket {
 }
 
 impl StmtPrepareOKPacket {
-    // TODO(port): narrow error set
     pub fn decode_internal<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.status = reader.int::<u8>()?;
         if self.status != 0 {
-            return Err(bun_core::err!("InvalidPrepareOKPacket"));
+            return Err(AnyMySQLError::InvalidPrepareOKPacket);
         }
 
         self.statement_id = reader.int::<u32>()?;
@@ -31,13 +31,10 @@ impl StmtPrepareOKPacket {
         Ok(())
     }
 
-    // Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
     pub fn decode<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyMySQLError> {
         self.decode_internal(reader)
     }
 }
-
-// ported from: src/sql/mysql/protocol/StmtPrepareOKPacket.zig
diff --git a/src/sql/postgres/AnyPostgresError.rs b/src/sql/postgres/AnyPostgresError.rs
index dd1fb2fdd9a..b813753b7b1 100644
--- a/src/sql/postgres/AnyPostgresError.rs
+++ b/src/sql/postgres/AnyPostgresError.rs
@@ -1,10 +1,10 @@
-// Variant names intentionally match the Zig error tags 1:1 (including
-// SCREAMING_CASE) so that `IntoStaticStr` yields the same string as Zig's
-// `@errorName`, which JS `error.code` / snapshot tests depend on.
+// Variant names (including SCREAMING_CASE) are exactly the strings that
+// `IntoStaticStr` yields, which JS `error.code` / snapshot tests depend on —
+// do not rename them.
 // NOTE: not `thiserror::Error` — that derive requires a per-variant
 // `#[error("...")]` attr (and would conflict with the manual Display below).
-// We hand-roll Display via `IntoStaticStr` so the message == the variant name
-// (matching Zig `@errorName`), and impl `std::error::Error` manually.
+// We hand-roll Display via `IntoStaticStr` so the message == the variant name,
+// and impl `std::error::Error` manually.
 #[allow(non_camel_case_types)]
 #[derive(Debug, Copy, Clone, Eq, PartialEq, strum::IntoStaticStr, strum::EnumString)]
 pub enum AnyPostgresError {
@@ -106,9 +106,5 @@ impl Default for PostgresErrorOptions<'_> {
     }
 }
 
-// Zig re-exported `createPostgresError` / `postgresErrorToJS` from
-// `src/sql_jsc/postgres/error_jsc.zig` here. Per PORTING.md, `*_jsc` alias
-// re-exports are deleted: in Rust those live as extension-trait methods in
-// the `bun_sql_jsc` crate and the base crate has no mention of jsc.
-
-// ported from: src/sql/postgres/AnyPostgresError.zig
+// `createPostgresError` / `postgresErrorToJS` live as extension-trait methods
+// in the `bun_sql_jsc` crate; the base crate has no mention of jsc.
diff --git a/src/sql/postgres/CommandTag.rs b/src/sql/postgres/CommandTag.rs
index df1680df76a..f430d842c7f 100644
--- a/src/sql/postgres/CommandTag.rs
+++ b/src/sql/postgres/CommandTag.rs
@@ -50,8 +50,7 @@ enum KnownCommand {
 }
 
 impl KnownCommand {
-    // Zig: bun.ComptimeEnumMap(KnownCommand) — comptime perfect hash over
-    // @tagName bytes. 8 keys is too small for `phf` to pay for itself (its
+    // 8 keys is too small for `phf` to pay for itself (its
     // SipHash + double indirect dominate); a length-gated byte compare is
     // branch-predictable and lets LLVM lower each arm to a single wide
     // integer compare. Within every length bucket the first byte is already
@@ -115,7 +114,7 @@ impl<'a> CommandTag<'a> {
                     let second_space = second_space as usize;
                     remaining = &remaining[(second_space + 1).min(remaining.len())..];
                     // Postgres wire is pure base-10 ASCII so radix-0/`_`/sign
-                    // widening is unreachable; @errorName parity via .name().
+                    // widening is unreachable.
                     match bun_core::fmt::parse_int::<u64>(remaining, 0) {
                         Ok(n) => break 'brk n,
                         Err(err) => {
@@ -157,5 +156,3 @@ impl<'a> CommandTag<'a> {
         }
     }
 }
-
-// ported from: src/sql/postgres/CommandTag.zig
diff --git a/src/sql/postgres/PostgresProtocol.rs b/src/sql/postgres/PostgresProtocol.rs
index 183c6f0c465..4b4aeb1be50 100644
--- a/src/sql/postgres/PostgresProtocol.rs
+++ b/src/sql/postgres/PostgresProtocol.rs
@@ -1,14 +1,11 @@
 use crate::postgres::types::int_types::int4;
 
-// `std.mem.toBytes(Int32(n))` — Zig's `Int32` casts `n` to `int4` (u32) and
-// `@byteSwap`s it to network order; `toBytes` then bit-casts to `[4]u8`. The net
-// result is just the big-endian byte representation of `n`.
+// The big-endian (network-order) byte representation of `n`.
 #[inline(always)]
 const fn to_bytes(n: int4) -> [u8; 4] {
     n.to_be_bytes()
 }
 
-// `[_]u8{tag} ++ toBytes(Int32(n))` — Zig comptime array concat.
 #[inline(always)]
 const fn tag_len(tag: u8, n: int4) -> [u8; 5] {
     let b = to_bytes(n);
@@ -29,8 +26,7 @@ pub const NO_DATA: [u8; 5] = tag_len(b'n', 4);
 pub fn write_query<Context: WriterContext>(
     query: &[u8],
     writer: &mut NewWriter<Context>,
-) -> Result<(), bun_core::Error> {
-    // TODO(port): narrow error set
+) -> Result<(), crate::postgres::AnyPostgresError> {
     let count: u32 =
         core::mem::size_of::<u32>() as u32 + u32::try_from(query.len()).expect("int cast") + 1;
     let header: [u8; 5] = {
@@ -75,5 +71,3 @@ pub use crate::postgres::protocol::stack_reader::StackReader;
 pub use crate::postgres::protocol::startup_message::StartupMessage;
 pub use crate::postgres::protocol::write_wrap::WriteWrap;
 pub use crate::shared::column_identifier::ColumnIdentifier;
-
-// ported from: src/sql/postgres/PostgresProtocol.zig
diff --git a/src/sql/postgres/PostgresTypes.rs b/src/sql/postgres/PostgresTypes.rs
index 483f3608965..a95a30062bd 100644
--- a/src/sql/postgres/PostgresTypes.rs
+++ b/src/sql/postgres/PostgresTypes.rs
@@ -1,8 +1,5 @@
-// PORT NOTE: the Zig file re-exported `bool`, `bytea`, `date`, `json`, `string`
-// from `../../sql_jsc/postgres/types/*.zig`. Per PORTING.md (Idiom map, last
-// row), `*_jsc` alias re-exports are deleted — `to_js`/`from_js` live as
-// extension-trait methods in the `bun_sql_jsc` crate, and the base crate has
-// no mention of jsc.
+// `to_js`/`from_js` for these types live as extension-trait methods in the
+// `bun_sql_jsc` crate; this base crate intentionally has no jsc dependency.
 
 pub use super::any_postgres_error::AnyPostgresError;
 pub use super::types::tag::Tag;
@@ -14,5 +11,3 @@ pub use int_types::short as PostgresShort;
 pub use int_types::{Int4, Int8, Short, int4, int8, short};
 
 use super::types::int_types;
-
-// ported from: src/sql/postgres/PostgresTypes.zig
diff --git a/src/sql/postgres/SSLMode.rs b/src/sql/postgres/SSLMode.rs
index c969616b3fe..99f59a7f50b 100644
--- a/src/sql/postgres/SSLMode.rs
+++ b/src/sql/postgres/SSLMode.rs
@@ -7,5 +7,3 @@ pub enum SSLMode {
     VerifyCa = 3,
     VerifyFull = 4,
 }
-
-// ported from: src/sql/postgres/SSLMode.zig
diff --git a/src/sql/postgres/SocketMonitor.rs b/src/sql/postgres/SocketMonitor.rs
index 4e83a1e8f1b..451cdef930d 100644
--- a/src/sql/postgres/SocketMonitor.rs
+++ b/src/sql/postgres/SocketMonitor.rs
@@ -1,9 +1,8 @@
 bun_core::declare_scope!(SocketMonitor, visible);
 
 /// Stamps out a debug-only socket-traffic dump module. The reader and writer
-/// variants were byte-identical modulo the env var checked and the log message;
-/// Zig kept two files because file-scope structs can't be cheaply parameterized,
-/// but `macro_rules!` collapses them in the Rust port.
+/// variants are byte-identical modulo the env var checked and the log message,
+/// so `macro_rules!` collapses them into one definition.
 #[cfg(debug_assertions)]
 macro_rules! debug_socket_monitor {
     ($env:path, $msg:literal) => {
@@ -14,21 +13,17 @@ macro_rules! debug_socket_monitor {
 
         bun_core::declare_scope!(Postgres, visible);
 
-        // Zig used a bare module-level `var file: std.fs.File = undefined;`
-        // initialized once by `load`. PORTING.md §Concurrency: OnceLock for
-        // write-once globals.
+        // Initialized once by `load`; OnceLock for write-once globals.
         static FILE: OnceLock<File> = OnceLock::new();
 
         pub(crate) static ENABLED: AtomicBool = AtomicBool::new(false);
 
-        // Zig: `pub var check = std.once(load);` — callers do `check.call()`.
-        // Rust's `Once` does not capture the fn; callers do `CHECK.call_once(load)`.
+        // `Once` does not capture the fn; callers do `CHECK.call_once(load)`.
         pub(crate) static CHECK: Once = Once::new();
 
         pub(crate) fn load() {
             if let Some(monitor) = $env.get() {
                 ENABLED.store(true, Ordering::Relaxed);
-                // Zig called `std.fs.cwd().createFile(monitor, .{ .truncate = true })`.
                 let f = match File::create(bun_sys::Fd::cwd(), monitor, /* truncate = */ true) {
                     Ok(f) => f,
                     Err(_) => {
@@ -94,7 +89,3 @@ pub fn read(data: &[u8]) {
         }
     }
 }
-
-// ported from: src/sql/postgres/SocketMonitor.zig
-// ported from: src/sql/postgres/DebugSocketMonitorReader.zig
-// ported from: src/sql/postgres/DebugSocketMonitorWriter.zig
diff --git a/src/sql/postgres/Status.rs b/src/sql/postgres/Status.rs
index 56aabad07ba..b7f8628e62b 100644
--- a/src/sql/postgres/Status.rs
+++ b/src/sql/postgres/Status.rs
@@ -8,5 +8,3 @@ pub enum Status {
     Connected,
     Failed,
 }
-
-// ported from: src/sql/postgres/Status.zig
diff --git a/src/sql/postgres/TLSStatus.rs b/src/sql/postgres/TLSStatus.rs
index bbc4d835a64..c1eb6f181b1 100644
--- a/src/sql/postgres/TLSStatus.rs
+++ b/src/sql/postgres/TLSStatus.rs
@@ -10,5 +10,3 @@ pub enum TLSStatus {
     SslNotAvailable,
     SslOk,
 }
-
-// ported from: src/sql/postgres/TLSStatus.zig
diff --git a/src/sql/postgres/protocol/ArrayList.rs b/src/sql/postgres/protocol/ArrayList.rs
index 105162b347b..d0c2da8f078 100644
--- a/src/sql/postgres/protocol/ArrayList.rs
+++ b/src/sql/postgres/protocol/ArrayList.rs
@@ -21,7 +21,6 @@ impl<'a> ArrayList<'a> {
     }
 }
 
-// PORT NOTE: Zig methods took `@This()` by value (a `*ArrayList(u8)` is Copy).
 // `WriterContext` requires `Copy`, so the context wraps a `BackRef` to the
 // caller's `Vec<u8>`; the `'a` borrow is the safety invariant (Vec outlives ctx).
 #[derive(Clone, Copy)]
@@ -67,5 +66,3 @@ impl<'a> WriterContext for ArrayListCtx<'a> {
 }
 
 pub type Writer<'a> = NewWriter<ArrayListCtx<'a>>;
-
-// ported from: src/sql/postgres/protocol/ArrayList.zig
diff --git a/src/sql/postgres/protocol/Authentication.rs b/src/sql/postgres/protocol/Authentication.rs
index ce654b00b58..a00a6ebe0ea 100644
--- a/src/sql/postgres/protocol/Authentication.rs
+++ b/src/sql/postgres/protocol/Authentication.rs
@@ -1,4 +1,5 @@
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 use crate::shared::Data;
 use bun_ptr::RawSlice;
 
@@ -53,35 +54,33 @@ impl Drop for Authentication {
 }
 
 impl Authentication {
-    // PORT NOTE: reshaped from out-param `fn(this: *@This(), ...) !void` to `-> Result<Self, _>`.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         reader: &mut NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let message_length = reader.length()?;
 
         match reader.int4()? {
             0 => {
                 if message_length != 8 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 Ok(Authentication::Ok)
             }
             2 => {
                 if message_length != 8 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 Ok(Authentication::KerberosV5)
             }
             3 => {
                 if message_length != 8 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 Ok(Authentication::ClearTextPassword)
             }
             5 => {
                 if message_length != 12 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 let salt_data = reader.bytes(4)?;
                 // `defer salt_data.deinit()` — handled by Drop on `Data` at scope exit.
@@ -90,28 +89,28 @@ impl Authentication {
             }
             7 => {
                 if message_length != 8 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 Ok(Authentication::GSS)
             }
 
             8 => {
                 if message_length < 9 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 let bytes = reader.read((message_length - 8) as usize)?;
                 Ok(Authentication::GSSContinue { data: bytes })
             }
             9 => {
                 if message_length != 8 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 Ok(Authentication::SSPI)
             }
 
             10 => {
                 if message_length < 9 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 reader.skip((message_length - 8) as usize)?;
                 Ok(Authentication::SASL)
@@ -119,10 +118,9 @@ impl Authentication {
 
             11 => {
                 if message_length < 9 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 let bytes = reader.bytes((message_length - 8) as usize)?;
-                // errdefer { bytes.deinit(); } — `Data: Drop` frees on `?` early-return.
 
                 let mut r: Option<RawSlice<u8>> = None;
                 let mut i: Option<RawSlice<u8>> = None;
@@ -160,9 +158,9 @@ impl Authentication {
                     bun_core::scoped_log!(Postgres, "Missing i");
                 }
 
-                let r = r.ok_or_else(|| bun_core::err!("InvalidMessage"))?;
-                let s = s.ok_or_else(|| bun_core::err!("InvalidMessage"))?;
-                let i = i.ok_or_else(|| bun_core::err!("InvalidMessage"))?;
+                let r = r.ok_or(AnyPostgresError::InvalidMessage)?;
+                let s = s.ok_or(AnyPostgresError::InvalidMessage)?;
+                let i = i.ok_or(AnyPostgresError::InvalidMessage)?;
 
                 Ok(Authentication::SASLContinue(SASLContinue {
                     data: bytes,
@@ -174,7 +172,7 @@ impl Authentication {
 
             12 => {
                 if message_length < 9 {
-                    return Err(bun_core::err!("InvalidMessageLength"));
+                    return Err(AnyPostgresError::InvalidMessageLength);
                 }
                 let remaining: usize = (message_length - 8) as usize;
 
@@ -186,12 +184,9 @@ impl Authentication {
         }
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(&mut NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/Authentication.zig
diff --git a/src/sql/postgres/protocol/BackendKeyData.rs b/src/sql/postgres/protocol/BackendKeyData.rs
index 65b405fa2f9..df6dcdb58ed 100644
--- a/src/sql/postgres/protocol/BackendKeyData.rs
+++ b/src/sql/postgres/protocol/BackendKeyData.rs
@@ -1,4 +1,5 @@
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
 #[derive(Default)]
 pub struct BackendKeyData {
@@ -7,27 +8,23 @@ pub struct BackendKeyData {
 }
 
 impl BackendKeyData {
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 
-    // TODO(port): narrow error set
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         if !reader.expect_int::<u32>(12)? {
-            return Err(crate::postgres::AnyPostgresError::InvalidBackendKeyData.into());
+            return Err(AnyPostgresError::InvalidBackendKeyData);
         }
 
         Ok(Self {
-            // @bitCast i32 -> u32: same-width signed→unsigned `as` cast preserves bits.
+            // i32 -> u32: same-width signed→unsigned `as` cast preserves bits.
             process_id: reader.int4()?,
             secret_key: reader.int4()?,
         })
     }
 }
-
-// ported from: src/sql/postgres/protocol/BackendKeyData.zig
diff --git a/src/sql/postgres/protocol/Close.rs b/src/sql/postgres/protocol/Close.rs
index 1e7caee6c5f..c2b854eb0ce 100644
--- a/src/sql/postgres/protocol/Close.rs
+++ b/src/sql/postgres/protocol/Close.rs
@@ -1,5 +1,6 @@
 use super::new_writer::NewWriter;
 use super::portal_or_prepared_statement::PortalOrPreparedStatement;
+use crate::postgres::AnyPostgresError;
 
 /// Close (F)
 /// Byte1('C')
@@ -18,15 +19,13 @@ impl<'a> Close<'a> {
     fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let p = &self.p;
         let count: u32 = core::mem::size_of::<u32>() as u32
             + 1
             + u32::try_from(p.slice().len()).expect("int cast")
             + 1;
-        // PORT NOTE: Zig source builds `[_]u8{'C'} ++ @byteSwap(count) ++ [_]u8{p.tag()}`;
-        // intent is 'C' · big-endian u32 count · tag byte. Reshaped to a fixed 6-byte buffer.
+        // 'C' · big-endian u32 count · tag byte, in a fixed 6-byte buffer.
         let mut header = [0u8; 6];
         header[0] = b'C';
         header[1..5].copy_from_slice(&count.to_be_bytes());
@@ -37,13 +36,10 @@ impl<'a> Close<'a> {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/Close.zig
diff --git a/src/sql/postgres/protocol/CommandComplete.rs b/src/sql/postgres/protocol/CommandComplete.rs
index 2fec0705b73..8226deb3a32 100644
--- a/src/sql/postgres/protocol/CommandComplete.rs
+++ b/src/sql/postgres/protocol/CommandComplete.rs
@@ -13,13 +13,9 @@ impl Default for CommandComplete {
     }
 }
 
-// Zig `deinit` only called `this.command_tag.deinit()`; `Data` owns its own
-// `Drop`, so no explicit `Drop` impl is needed here.
-
 impl CommandComplete {
-    // PORT NOTE: Zig body is the out-param-constructor pattern (`this.* = .{...}`),
-    // which PORTING.md normally reshapes to `fn(...) -> Result<Self, E>`. Kept as
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
+    // Intentionally `&mut self` (not `-> Result<Self, E>`) to fit the
+    // `DecoderWrap` decode contract — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         &mut self,
         mut reader: NewReader<Container>,
@@ -32,7 +28,6 @@ impl CommandComplete {
         Ok(())
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         &mut self,
         context: Container,
@@ -40,5 +35,3 @@ impl CommandComplete {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/CommandComplete.zig
diff --git a/src/sql/postgres/protocol/CopyData.rs b/src/sql/postgres/protocol/CopyData.rs
index 39783c230f3..2f798ed82ea 100644
--- a/src/sql/postgres/protocol/CopyData.rs
+++ b/src/sql/postgres/protocol/CopyData.rs
@@ -1,5 +1,6 @@
 use super::new_reader::NewReader;
 use super::new_writer::NewWriter;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::int32;
 use crate::shared::Data;
 
@@ -9,35 +10,31 @@ pub struct CopyData {
 }
 
 impl CopyData {
-    // PORT NOTE: out-param constructor (`this.* = .{...}`) reshaped to return Self.
-    // TODO(port): narrow error set
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         let length = reader.length()?;
 
         let data = reader.read(usize::try_from(length.saturating_sub(5)).expect("int cast"))?;
         Ok(Self { data })
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         &mut self,
         reader: NewReader<Container>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         *self = Self::decode_internal(reader)?;
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         let data = self.data.slice();
         let count: u32 =
             u32::try_from(core::mem::size_of::<u32>() + data.len() + 1).expect("int cast");
-        // Zig: [_]u8{'d'} ++ toBytes(Int32(count)) — `int32` returns big-endian [u8;4].
+        // `int32` returns big-endian [u8; 4].
         let count_bytes = int32(count);
         let header: [u8; 5] = [
             b'd',
@@ -51,13 +48,10 @@ impl CopyData {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/CopyData.zig
diff --git a/src/sql/postgres/protocol/CopyFail.rs b/src/sql/postgres/protocol/CopyFail.rs
index 3bdc0cfcfa2..1d2d90f607e 100644
--- a/src/sql/postgres/protocol/CopyFail.rs
+++ b/src/sql/postgres/protocol/CopyFail.rs
@@ -1,3 +1,4 @@
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::int32;
 use crate::shared::Data;
 
@@ -17,41 +18,28 @@ impl Default for CopyFail {
 }
 
 impl CopyFail {
-    // PORT NOTE: Zig signature is `fn decodeInternal(this: *@This(), ...) !void` with
-    // `this.* = .{...}` body — the out-param-constructor pattern. Reshaped to return
-    // `Result<Self, _>` per PORTING.md (Rust has NRVO for error unions).
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let _ = reader.int4()?;
 
         let message = reader.read_z()?;
         Ok(Self { message })
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
-
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let message = self.message.slice();
         let count: u32 =
             u32::try_from(core::mem::size_of::<u32>() + message.len() + 1).expect("int cast");
-        // Zig: `[_]u8{'f'} ++ toBytes(Int32(count))` — runtime array concat into [5]u8.
-        // `std.mem.toBytes` reinterprets the Int32 (big-endian i32 newtype) as raw bytes.
         let mut header = [0u8; 5];
         header[0] = b'f';
-        // `int32(count)` returns big-endian `[u8; 4]` (mirrors std.mem.toBytes(Int32(count))).
+        // `int32(count)` returns big-endian `[u8; 4]`.
         header[1..5].copy_from_slice(&int32(count));
         writer.write(&header)?;
         writer.string(message)?;
         Ok(())
     }
-
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
 }
-
-// ported from: src/sql/postgres/protocol/CopyFail.zig
diff --git a/src/sql/postgres/protocol/CopyInResponse.rs b/src/sql/postgres/protocol/CopyInResponse.rs
index 9a6598feece..9269d282152 100644
--- a/src/sql/postgres/protocol/CopyInResponse.rs
+++ b/src/sql/postgres/protocol/CopyInResponse.rs
@@ -9,11 +9,9 @@ impl CopyInResponse {
     ) -> Result<(), bun_core::Error> {
         drop(reader);
         let _ = self;
-        // Zig: bun.Output.panic("TODO: not implemented {s}", .{bun.meta.typeBaseName(@typeName(@This()))})
         bun_core::output::panic(format_args!("TODO: not implemented {}", "CopyInResponse"));
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         &mut self,
         context: Container,
@@ -21,5 +19,3 @@ impl CopyInResponse {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/CopyInResponse.zig
diff --git a/src/sql/postgres/protocol/CopyOutResponse.rs b/src/sql/postgres/protocol/CopyOutResponse.rs
index 989be2143c0..2352ece23cd 100644
--- a/src/sql/postgres/protocol/CopyOutResponse.rs
+++ b/src/sql/postgres/protocol/CopyOutResponse.rs
@@ -1,27 +1,25 @@
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
 pub struct CopyOutResponse;
 
 impl CopyOutResponse {
-    // TODO(port): narrow error set
+    // COPY TO is not supported yet.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         &mut self,
         reader: NewReader<Container>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         drop(reader);
         let _ = self;
         bun_core::output::panic(format_args!("TODO: not implemented {}", "CopyOutResponse",));
     }
 }
 
-// Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
 impl CopyOutResponse {
     pub fn decode<Container: super::new_reader::ReaderContext>(
         &mut self,
         context: Container,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/CopyOutResponse.zig
diff --git a/src/sql/postgres/protocol/DataRow.rs b/src/sql/postgres/protocol/DataRow.rs
index ad01fd0b8f3..fd33eeea4f1 100644
--- a/src/sql/postgres/protocol/DataRow.rs
+++ b/src/sql/postgres/protocol/DataRow.rs
@@ -2,12 +2,8 @@ use crate::postgres::AnyPostgresError;
 use crate::postgres::protocol::new_reader::{NewReader, ReaderContext};
 use crate::shared::Data;
 
-// Zig: `context: anytype` + `comptime forEach: fn(@TypeOf(context), u32, ?*Data) AnyPostgresError!bool`
-// Opaque-context pattern (PORTING.md §anytype): unbounded `<C>`; context is forwarded by value
-// to the callback each iteration, so require `C: Copy`.
-// `comptime ContextType: type, reader: NewReader(ContextType)` is the paired-param spelling of a
-// generic reader → `reader: &mut NewReader<R>`.
-// `comptime forEach: fn(...)` → `impl FnMut` (monomorphized, matches Zig comptime).
+// The opaque context is forwarded by value to the callback each iteration,
+// so require `C: Copy`.
 pub fn decode<C: Copy, R: ReaderContext>(
     context: C,
     reader: &mut NewReader<R>,
@@ -52,5 +48,3 @@ pub fn decode<C: Copy, R: ReaderContext>(
 }
 
 pub(crate) const NULL_INT4: u32 = 4294967295;
-
-// ported from: src/sql/postgres/protocol/DataRow.zig
diff --git a/src/sql/postgres/protocol/DecoderWrap.rs b/src/sql/postgres/protocol/DecoderWrap.rs
index d8cabac4b35..f6c2ebc4b7d 100644
--- a/src/sql/postgres/protocol/DecoderWrap.rs
+++ b/src/sql/postgres/protocol/DecoderWrap.rs
@@ -1,18 +1,10 @@
 use super::new_reader::{NewReader, ReaderContext};
 use crate::postgres::any_postgres_error::AnyPostgresError;
 
-// PORT NOTE: reshaped for Rust — Zig's `DecoderWrap(comptime Container: type,
-// comptime decodeFn: anytype) type` curries a comptime fn value into a generated
-// struct. Rust cannot take a fn value as a type-level parameter on stable, so
-// `decodeFn` becomes a required trait method `decode_fn` on `Container` and the
-// generated struct becomes a blanket-impl'd extension trait. Call sites change
-// from `pub const decode = DecoderWrap(Self, decodeInternal).decode;` to
-// `impl DecoderWrap for Self { fn decode_fn<C>(...) { decodeInternal(...) } }`.
+// Extension trait with a blanket-provided `decode`: implementors write
+// `impl DecoderWrap for Self { fn decode_fn<C>(...) { decode_internal(...) } }`.
 // TODO(refactor): revisit once `NewReader<C>`'s trait bounds are settled.
 pub trait DecoderWrap: Sized {
-    /// The Zig `decodeFn(this, comptime Context, NewReader(Context){ .wrapped = context })`.
-    /// Paired `(comptime Context: type, reader: NewReader(Context))` collapses to a
-    /// single generic `reader: NewReader<C>` per PORTING.md.
     fn decode_fn<C: ReaderContext>(&mut self, reader: NewReader<C>)
     -> Result<(), AnyPostgresError>;
 
@@ -20,5 +12,3 @@ pub trait DecoderWrap: Sized {
         self.decode_fn(NewReader::<C> { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/DecoderWrap.zig
diff --git a/src/sql/postgres/protocol/Describe.rs b/src/sql/postgres/protocol/Describe.rs
index 5d66f7d5217..f3929955e63 100644
--- a/src/sql/postgres/protocol/Describe.rs
+++ b/src/sql/postgres/protocol/Describe.rs
@@ -1,5 +1,6 @@
 use super::new_writer::NewWriter;
 use super::portal_or_prepared_statement::PortalOrPreparedStatement;
+use crate::postgres::AnyPostgresError;
 
 pub struct Describe<'a> {
     pub p: PortalOrPreparedStatement<'a>,
@@ -9,8 +10,7 @@ impl<'a> Describe<'a> {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let message = self.p.slice();
         writer.write(b"D")?;
         let length = writer.length()?;
@@ -20,13 +20,10 @@ impl<'a> Describe<'a> {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/Describe.zig
diff --git a/src/sql/postgres/protocol/ErrorResponse.rs b/src/sql/postgres/protocol/ErrorResponse.rs
index 4daf8698769..0930a1601a7 100644
--- a/src/sql/postgres/protocol/ErrorResponse.rs
+++ b/src/sql/postgres/protocol/ErrorResponse.rs
@@ -1,5 +1,6 @@
 use core::fmt;
 
+use crate::postgres::AnyPostgresError;
 use crate::postgres::protocol::field_message::FieldMessage;
 use crate::postgres::protocol::new_reader::NewReader;
 
@@ -17,21 +18,13 @@ impl fmt::Display for ErrorResponse {
     }
 }
 
-// Zig `deinit` only frees owned fields (per-element `message.deinit()` then
-// `messages.deinit(bun.default_allocator)`); Vec<FieldMessage> + FieldMessage's
-// Drop handle both automatically, so no explicit Drop impl is needed.
-
 impl ErrorResponse {
-    // PORT NOTE: reshaped from `(this: *@This(), ...) !void` out-param constructor
-    // to `-> Result<Self, E>`; the Zig `remaining_bytes == 0` branch left `this.*`
-    // at its default-init state, so we return `Self::default()` there.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let mut remaining_bytes = reader.length()?;
         if remaining_bytes < 4 {
-            return Err(bun_core::err!("InvalidMessageLength"));
+            return Err(AnyPostgresError::InvalidMessageLength);
         }
         remaining_bytes = remaining_bytes.saturating_sub(4);
 
@@ -43,16 +36,11 @@ impl ErrorResponse {
         Ok(Self::default())
     }
 
-    // Zig DecoderWrap takes a raw `context` and wraps it as `NewReader{.wrapped=context}`.
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
 }
 
-// Zig `pub const toJS = @import("../../../sql_jsc/...").toJS;` alias deleted —
 // `to_js` lives on an extension trait in the `bun_sql_jsc` crate.
-
-// ported from: src/sql/postgres/protocol/ErrorResponse.zig
diff --git a/src/sql/postgres/protocol/Execute.rs b/src/sql/postgres/protocol/Execute.rs
index e6ca46f948f..d7d749cdbd0 100644
--- a/src/sql/postgres/protocol/Execute.rs
+++ b/src/sql/postgres/protocol/Execute.rs
@@ -1,5 +1,6 @@
 use super::new_writer::NewWriter;
 use super::portal_or_prepared_statement::PortalOrPreparedStatement;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::Int4;
 
 pub struct Execute<'a> {
@@ -20,8 +21,7 @@ impl<'a> Execute<'a> {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         writer.write(b"E")?;
         let length = writer.length()?;
         if let PortalOrPreparedStatement::Portal(portal) = &self.p {
@@ -34,13 +34,10 @@ impl<'a> Execute<'a> {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/Execute.zig
diff --git a/src/sql/postgres/protocol/FieldDescription.rs b/src/sql/postgres/protocol/FieldDescription.rs
index 0e61462bd79..f8012575def 100644
--- a/src/sql/postgres/protocol/FieldDescription.rs
+++ b/src/sql/postgres/protocol/FieldDescription.rs
@@ -16,7 +16,7 @@ pub struct FieldDescription {
 impl Default for FieldDescription {
     fn default() -> Self {
         Self {
-            name_or_index: ColumnIdentifier::Name(Default::default()), // .{ .name = .{ .empty = {} } }
+            name_or_index: ColumnIdentifier::Name(Default::default()),
             table_oid: 0,
             column_index: 0,
             type_oid: 0,
@@ -27,18 +27,15 @@ impl Default for FieldDescription {
 
 impl FieldDescription {
     pub fn type_tag(&self) -> types::Tag {
-        // `types::Tag` is a `#[repr(transparent)] struct(Short)` newtype (Zig
-        // models the OID enum as non-exhaustive `enum(short){…,_}`), so wrap
-        // the truncated value directly.
+        // `types::Tag` is a `#[repr(transparent)] struct(Short)` newtype over
+        // the OID, so wrap the truncated value directly.
         types::Tag(self.type_oid as Short)
     }
 
-    // PORT NOTE: reshaped out-param constructor (`this.* = .{...}`) into a value-returning fn.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         reader: &mut NewReader<Container>,
     ) -> Result<Self, AnyPostgresError> {
         let name = reader.read_z()?;
-        // errdefer name.deinit() — deleted: `name` drops on `?` automatically.
 
         // Field name (null-terminated string)
         let field_name = ColumnIdentifier::init(name).map_err(|_| AnyPostgresError::OutOfMemory)?;
@@ -75,10 +72,4 @@ impl FieldDescription {
     }
 }
 
-// Zig: `pub fn deinit` only deinits the owned `name_or_index` field.
-// In Rust, `ColumnIdentifier` impls `Drop`, so field-drop is implicit — no explicit `Drop` needed.
-
-// Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
 pub use self::FieldDescription as _DecoderWrapTarget;
-
-// ported from: src/sql/postgres/protocol/FieldDescription.zig
diff --git a/src/sql/postgres/protocol/FieldMessage.rs b/src/sql/postgres/protocol/FieldMessage.rs
index a785defc4c1..47967a306ab 100644
--- a/src/sql/postgres/protocol/FieldMessage.rs
+++ b/src/sql/postgres/protocol/FieldMessage.rs
@@ -4,8 +4,8 @@ use bun_core::String;
 
 use super::field_type::FieldType;
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
-/// Zig: `union(FieldType)` — every variant carries a `bun.String`.
 pub enum FieldMessage {
     Severity(String),
     LocalizedSeverity(String),
@@ -29,7 +29,6 @@ pub enum FieldMessage {
 
 impl fmt::Display for FieldMessage {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Zig: `switch (this) { inline else => |str| writer.print("{f}", .{str}) }`
         match self {
             FieldMessage::Severity(s)
             | FieldMessage::LocalizedSeverity(s)
@@ -53,15 +52,10 @@ impl fmt::Display for FieldMessage {
     }
 }
 
-// Zig `deinit` called `.deref()` on the payload `bun.String`. In Rust,
-// `bun_core::String`'s own `Drop` performs the deref, so no explicit `Drop`
-// impl is needed here — dropping the enum drops the payload.
-
 impl FieldMessage {
     pub fn decode_list<Context: super::new_reader::ReaderContext>(
         mut reader: NewReader<Context>,
-    ) -> Result<Vec<FieldMessage>, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Vec<FieldMessage>, AnyPostgresError> {
         let mut messages: Vec<FieldMessage> = Vec::new();
         loop {
             let field_int: u8 = reader.int::<u8>()?;
@@ -111,5 +105,3 @@ impl FieldMessage {
         })
     }
 }
-
-// ported from: src/sql/postgres/protocol/FieldMessage.zig
diff --git a/src/sql/postgres/protocol/FieldType.rs b/src/sql/postgres/protocol/FieldType.rs
index 93139dc45dd..a2f17e351bf 100644
--- a/src/sql/postgres/protocol/FieldType.rs
+++ b/src/sql/postgres/protocol/FieldType.rs
@@ -1,8 +1,7 @@
-// PORT NOTE: Zig source is a *non-exhaustive* `enum(u8)` (trailing `_`), meaning
-// any `u8` value is a valid `FieldType` and unknown bytes from the wire must
+// Any `u8` value is a valid `FieldType` and unknown bytes from the wire must
 // round-trip. A `#[repr(u8)] enum` in Rust is exhaustive — transmuting an
-// unlisted byte into it is UB. So this is ported as a transparent `u8` newtype
-// with associated consts for the known field codes.
+// unlisted byte into it is UB — so this is a transparent `u8` newtype with
+// associated consts for the known field codes.
 
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
@@ -77,5 +76,3 @@ impl From<FieldType> for u8 {
         t.0
     }
 }
-
-// ported from: src/sql/postgres/protocol/FieldType.zig
diff --git a/src/sql/postgres/protocol/NegotiateProtocolVersion.rs b/src/sql/postgres/protocol/NegotiateProtocolVersion.rs
index 51126352739..7d7ffc50f00 100644
--- a/src/sql/postgres/protocol/NegotiateProtocolVersion.rs
+++ b/src/sql/postgres/protocol/NegotiateProtocolVersion.rs
@@ -2,6 +2,7 @@ use bun_core::String;
 
 use super::super::types::int_types::Int4;
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
 #[derive(Default)]
 pub struct NegotiateProtocolVersion {
@@ -10,11 +11,9 @@ pub struct NegotiateProtocolVersion {
 }
 
 impl NegotiateProtocolVersion {
-    // PORT NOTE: reshaped from out-param `fn(this: *@This(), ...) !void` to `-> Result<Self, E>`.
-    // TODO(port): narrow error set
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         let length = reader.length()?;
         debug_assert!(length >= 4);
 
@@ -28,7 +27,6 @@ impl NegotiateProtocolVersion {
         this.unrecognized_options.reserve(
             (unrecognized_options_count as usize).saturating_sub(this.unrecognized_options.len()),
         );
-        // errdefer { for ... option.deinit(); list.deinit(allocator) } — deleted:
         // Vec<bun_core::String> drops each element on the `?` error path automatically.
         for _ in 0..unrecognized_options_count {
             let option = reader.read_z()?;
@@ -38,11 +36,8 @@ impl NegotiateProtocolVersion {
             // `defer option.deinit()` — deleted; `option` drops at end of iteration.
             this.unrecognized_options
                 .push(String::clone_utf8(option.slice()));
-            // PERF(port): was appendAssumeCapacity — profile if it shows up on a hot path.
         }
 
         Ok(this)
     }
 }
-
-// ported from: src/sql/postgres/protocol/NegotiateProtocolVersion.zig
diff --git a/src/sql/postgres/protocol/NewReader.rs b/src/sql/postgres/protocol/NewReader.rs
index cb7b1362fae..60769fa0f2b 100644
--- a/src/sql/postgres/protocol/NewReader.rs
+++ b/src/sql/postgres/protocol/NewReader.rs
@@ -3,10 +3,7 @@ use crate::postgres::types::int_types::{PostgresInt32, PostgresShort};
 use crate::shared::Data;
 use bun_core::String as BunString;
 
-/// Trait capturing the methods `NewReaderWrap` expected as comptime fn params.
-/// Zig passed these as `comptime fn(ctx: Context) ...` arguments and `NewReader`
-/// filled them in from `Context.markMessageStart`, `Context.peek`, etc. — i.e.
-/// structural duck-typing. In Rust the trait bound IS that check.
+/// Trait capturing the methods `NewReaderWrap` requires of its wrapped context.
 pub trait ReaderContext {
     fn mark_message_start(&mut self);
     fn peek(&self) -> &[u8];
@@ -16,10 +13,9 @@ pub trait ReaderContext {
     fn read_z(&mut self) -> Result<Data, AnyPostgresError>;
 }
 
-/// Helper trait for `int<Int>()` / `peek_int<Int>()` — Zig used `@sizeOf(Int)`,
-/// `@bitCast`, and `@byteSwap` to read a big-endian integer of arbitrary width.
-/// Rust has no std trait for `from_be_bytes`, so we mint a tiny one.
-// TODO(port): consider moving to a shared int-read helper if other protocol files need it
+/// Helper trait for `int<Int>()` / `peek_int<Int>()` — reads a big-endian
+/// integer of arbitrary width. Rust has no std trait for `from_be_bytes`,
+/// so we mint a tiny one.
 pub trait ProtocolInt: Sized + Copy + Eq {
     const SIZE: usize;
     fn from_be_slice(bytes: &[u8]) -> Self;
@@ -40,9 +36,8 @@ macro_rules! impl_protocol_int {
 }
 impl_protocol_int!(u8, i8, u16, i16, u32, i32, u64, i64);
 
-// Blanket impl so `NewReaderWrap<&mut C>` works — Zig passed the wrapped struct
-// by-value (implicit copy) through the dispatch loop; in Rust the inner
-// `Context` is non-`Copy` (holds `&mut usize`), so callers reborrow instead.
+// Blanket impl so `NewReaderWrap<&mut C>` works — the inner `Context` is
+// non-`Copy` (holds `&mut usize`), so callers reborrow instead.
 impl<C: ReaderContext + ?Sized> ReaderContext for &mut C {
     #[inline]
     fn mark_message_start(&mut self) {
@@ -70,8 +65,6 @@ impl<C: ReaderContext + ?Sized> ReaderContext for &mut C {
     }
 }
 
-// Zig: `fn NewReaderWrap(comptime Context: type, comptime markMessageStartFn_, ...) type { return struct { wrapped: Context, ... } }`
-// The fn-pointer params collapse into the `ReaderContext` trait bound.
 pub struct NewReaderWrap<Context: ReaderContext> {
     pub wrapped: Context,
 }
@@ -80,8 +73,7 @@ pub type Ctx<Context> = Context;
 
 impl<Context: ReaderContext> NewReaderWrap<Context> {
     /// Reborrow as `NewReaderWrap<&mut Context>` so the same reader can be
-    /// passed by-value into per-message handlers across loop iterations
-    /// (Zig relied on implicit struct copy of the pointer-carrying wrapper).
+    /// passed by-value into per-message handlers across loop iterations.
     #[inline]
     pub fn reborrow(&mut self) -> NewReaderWrap<&mut Context> {
         NewReaderWrap {
@@ -139,8 +131,6 @@ impl<Context: ReaderContext> NewReaderWrap<Context> {
         if slice.len() < Int::SIZE {
             return Err(AnyPostgresError::ShortRead);
         }
-        // Zig special-cased `Int == u8` to skip the byte-swap; `from_be_slice`
-        // for a 1-byte int is already a no-op swap, so no branch needed here.
         Ok(Int::from_be_slice(&slice[0..Int::SIZE]))
     }
 
@@ -153,7 +143,6 @@ impl<Context: ReaderContext> NewReaderWrap<Context> {
     }
 
     pub fn expect_int<Int: ProtocolInt>(&mut self, value: Int) -> Result<bool, AnyPostgresError> {
-        // PERF(port): `value` was `comptime comptime_int` — profile if it shows up on a hot path.
         let actual = self.int::<Int>()?;
         Ok(actual == value)
     }
@@ -168,35 +157,31 @@ impl<Context: ReaderContext> NewReaderWrap<Context> {
 
     pub fn length(&mut self) -> Result<PostgresInt32, AnyPostgresError> {
         let expected = self.int::<PostgresInt32>()?;
-        // PORT NOTE: Zig `expected > -1` — `int4` is u32 so always nonnegative; preserved
-        // as the saturating sub guarding underflow when len < 4.
+        // `int4` is u32 so always nonnegative; the saturating sub guards
+        // underflow when len < 4.
         self.ensure_capacity(expected.saturating_sub(4) as usize)?;
 
         Ok(expected)
     }
 
-    // Zig: `pub const bytes = read;`
     #[inline]
     pub fn bytes(&mut self, count: usize) -> Result<Data, AnyPostgresError> {
         self.read(count)
     }
 
+    /// Returns a `BunString` that BORROWS the connection read buffer.
+    ///
+    /// Invariant: callers must not hold the returned `BunString` past the next
+    /// buffer fill — `borrow_utf8` stores a raw pointer with no lifetime, so
+    /// the string is only valid until more data is read into the buffer.
+    /// (The bytes live in the connection buffer, not the `Data` wrapper.)
     pub fn string(&mut self) -> Result<BunString, AnyPostgresError> {
         let result = self.read_z()?;
-        // PORT NOTE: Zig `borrowUTF8` borrows `result.slice()` then drops `result`
-        // via `defer result.deinit()`. `Data` here is `Temporary` (points into the
-        // connection buffer), so the bytes outlive the `Data` wrapper itself;
-        // `borrow_utf8` stores a raw pointer (no lifetime) so this matches Zig
-        // semantics 1:1. TODO(audit): no caller may hold the returned
-        // `BunString` past the next buffer fill.
         Ok(BunString::borrow_utf8(result.slice()))
     }
 }
 
 // (duplicate blanket impl + reborrow removed — defined above at L47/L69)
 
-// Zig: `pub fn NewReader(comptime Context: type) type { return NewReaderWrap(Context, Context.markMessageStart, ...); }`
 // The trait bound on `NewReaderWrap` already enforces the method set, so this is a plain alias.
 pub type NewReader<Context> = NewReaderWrap<Context>;
-
-// ported from: src/sql/postgres/protocol/NewReader.zig
diff --git a/src/sql/postgres/protocol/NewWriter.rs b/src/sql/postgres/protocol/NewWriter.rs
index f08a36b5256..811968b3d14 100644
--- a/src/sql/postgres/protocol/NewWriter.rs
+++ b/src/sql/postgres/protocol/NewWriter.rs
@@ -1,17 +1,14 @@
 use crate::postgres::any_postgres_error::AnyPostgresError;
 use crate::postgres::types::int_types::{PostgresInt32, PostgresInt64, int32};
 
-/// Trait expressing the structural requirements that Zig's `NewWriterWrap`
-/// took as comptime fn-pointer params (`offsetFn_`, `writeFunction_`,
-/// `pwriteFunction_`). In Zig those were passed explicitly; in Rust the
-/// trait bound IS that binding.
+/// Trait expressing the structural requirements `NewWriter` places on its
+/// wrapped context.
 pub trait WriterContext: Copy {
     fn offset(self) -> usize;
     fn write(self, bytes: &[u8]) -> Result<(), AnyPostgresError>;
     fn pwrite(self, bytes: &[u8], offset: usize) -> Result<(), AnyPostgresError>;
 }
 
-/// Zig: `fn NewWriterWrap(comptime Context, offsetFn, writeFn, pwriteFn) type { return struct { wrapped: Context, ... } }`
 #[derive(Copy, Clone)]
 pub struct NewWriter<C: WriterContext> {
     pub wrapped: C,
@@ -38,9 +35,6 @@ impl<C: WriterContext> LengthWriter<C> {
 }
 
 impl<C: WriterContext> NewWriter<C> {
-    // Zig: `pub const Ctx = Context;` — in Rust the generic param `C` is the name.
-    // Zig: `pub const WrappedWriter = @This();` — `Self`.
-
     #[inline]
     pub fn write(self, data: &[u8]) -> Result<(), AnyPostgresError> {
         C::write(self.wrapped, data)
@@ -67,7 +61,6 @@ impl<C: WriterContext> NewWriter<C> {
     }
 
     pub fn int4(self, value: PostgresInt32) -> Result<(), AnyPostgresError> {
-        // Zig: std.mem.asBytes(&@byteSwap(value)) — i.e. big-endian bytes
         self.write(&value.to_be_bytes())
     }
 
@@ -80,7 +73,6 @@ impl<C: WriterContext> NewWriter<C> {
     }
 
     pub fn f64(self, value: f64) -> Result<(), AnyPostgresError> {
-        // Zig: @byteSwap(@as(u64, @bitCast(value)))
         self.write(&value.to_bits().to_be_bytes())
     }
 
@@ -92,7 +84,6 @@ impl<C: WriterContext> NewWriter<C> {
     where
         T: TryInto<u16>,
     {
-        // Zig: anytype → @typeInfo int check → std.math.cast(u16, ..) orelse error.TooManyParameters
         let v: u16 = value
             .try_into()
             .map_err(|_| AnyPostgresError::TooManyParameters)?;
@@ -123,8 +114,7 @@ impl<C: WriterContext> NewWriter<C> {
         self.int4(PostgresInt32::MAX)
     }
 
-    // PORT NOTE: Zig name is `String` (capital S); snake_cased it collides with
-    // `string(&[u8])` above. Renamed to `bun_string`.
+    // Named `bun_string` (not `string`) to avoid colliding with `string(&[u8])` above.
     pub fn bun_string(self, value: &bun_core::String) -> Result<(), AnyPostgresError> {
         if value.is_empty() {
             self.write(&[0u8])?;
@@ -142,13 +132,8 @@ impl<C: WriterContext> NewWriter<C> {
     }
 }
 
-// Zig: `pub fn NewWriter(comptime Context: type) type { return NewWriterWrap(Context, Context.offset, Context.write, Context.pwrite); }`
-// In Rust this is just `NewWriter<C>` where `C: WriterContext` — the trait
-// already binds `offset`/`write`/`pwrite` to the context's inherent methods.
-// Kept as a constructor helper for callsite parity.
+// Constructor helper for callsite convenience.
 #[inline]
 pub fn new_writer<C: WriterContext>(ctx: C) -> NewWriter<C> {
     NewWriter { wrapped: ctx }
 }
-
-// ported from: src/sql/postgres/protocol/NewWriter.zig
diff --git a/src/sql/postgres/protocol/NoticeResponse.rs b/src/sql/postgres/protocol/NoticeResponse.rs
index 3f59aabaeb6..07fb345f33e 100644
--- a/src/sql/postgres/protocol/NoticeResponse.rs
+++ b/src/sql/postgres/protocol/NoticeResponse.rs
@@ -1,20 +1,19 @@
 use super::field_message::FieldMessage;
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
 #[derive(Default)]
 pub struct NoticeResponse {
     pub messages: Vec<FieldMessage>,
 }
 
-// Zig `deinit` only freed owned fields (per-message deinit + list free).
 // Vec<FieldMessage> drops each element (FieldMessage's Drop) and the buffer
 // automatically, so no explicit Drop body is needed.
 
 impl NoticeResponse {
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let mut remaining_bytes = reader.length()?;
         remaining_bytes = remaining_bytes.saturating_sub(4);
 
@@ -26,15 +25,11 @@ impl NoticeResponse {
         Ok(Self::default())
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 }
 
-// Zig `toJS` re-export from sql_jsc deleted per PORTING.md — `to_js` lives as
-// an extension-trait method in the bun_sql_jsc crate.
-
-// ported from: src/sql/postgres/protocol/NoticeResponse.zig
+// `to_js` lives as an extension-trait method in the bun_sql_jsc crate.
diff --git a/src/sql/postgres/protocol/NotificationResponse.rs b/src/sql/postgres/protocol/NotificationResponse.rs
index 6964558c8e4..8be370f79d1 100644
--- a/src/sql/postgres/protocol/NotificationResponse.rs
+++ b/src/sql/postgres/protocol/NotificationResponse.rs
@@ -1,4 +1,5 @@
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::postgres_types::Int4;
 
 #[derive(Default)]
@@ -8,17 +9,13 @@ pub struct NotificationResponse {
     pub payload: Vec<u8>,
 }
 
-// PORT NOTE: Zig `deinit` only freed `channel`/`payload` via `clearAndFree(bun.default_allocator)`.
-// `Vec<u8>` (= `Vec<u8>`) owns its allocation and frees on Drop, so no explicit `impl Drop`
+// `Vec<u8>` owns its allocation and frees on Drop, so no explicit `impl Drop`
 // is needed here.
 
 impl NotificationResponse {
-    // PORT NOTE: reshaped from out-param `fn(this: *@This(), ...) !void` with `this.* = .{...}`
-    // to a value-returning constructor (PORTING.md §Ground rules, out-param exception).
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let length = reader.length()?;
         debug_assert!(length >= 4);
 
@@ -27,20 +24,17 @@ impl NotificationResponse {
             channel: reader
                 .read_z()?
                 .to_owned()
-                .map_err(|_| bun_core::err!(OutOfMemory))?,
+                .map_err(|_| AnyPostgresError::OutOfMemory)?,
             payload: reader
                 .read_z()?
                 .to_owned()
-                .map_err(|_| bun_core::err!(OutOfMemory))?,
+                .map_err(|_| AnyPostgresError::OutOfMemory)?,
         })
     }
 
-    // Zig: `pub const decode = DecoderWrap(NotificationResponse, decodeInternal).decode;`
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/NotificationResponse.zig
diff --git a/src/sql/postgres/protocol/ParameterDescription.rs b/src/sql/postgres/protocol/ParameterDescription.rs
index 4bd55a44a03..ecb869990dd 100644
--- a/src/sql/postgres/protocol/ParameterDescription.rs
+++ b/src/sql/postgres/protocol/ParameterDescription.rs
@@ -1,3 +1,4 @@
+use crate::postgres::AnyPostgresError;
 use crate::postgres::postgres_types::Int4;
 use crate::postgres::protocol::new_reader::NewReader;
 
@@ -7,11 +8,9 @@ pub struct ParameterDescription {
 }
 
 impl ParameterDescription {
-    // TODO(port): narrow error set
-    // PORT NOTE: out-param constructor (`this.* = .{...}`) reshaped to return Self.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         let mut remaining_bytes = reader.length()?;
         remaining_bytes = remaining_bytes.saturating_sub(4);
         let _ = remaining_bytes;
@@ -31,23 +30,19 @@ impl ParameterDescription {
         Ok(Self { parameters })
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 }
 
-// workaround for zig compiler TODO
-// PORT NOTE: Zig returned `[]align(1) const Int4`; Rust cannot form an unaligned `&[i32]`,
-// so we reinterpret as `&[[u8; 4]]` (align 1) and let the caller `from_ne_bytes` each element.
+// Rust cannot form an unaligned `&[i32]`, so we reinterpret as `&[[u8; 4]]`
+// (align 1) and let the caller `from_ne_bytes` each element.
 fn to_int32_slice(slice: &[u8]) -> &[[u8; core::mem::size_of::<Int4>()]] {
     // `[u8; 4]` has align 1 and is `AnyBitPattern`, so this is a safe bytemuck
-    // cast. Truncate any trailing `len % 4` bytes first to match Zig's
-    // `bytesAsSlice` semantics (cast_slice would panic on a remainder).
+    // cast. Truncate any trailing `len % 4` bytes first (cast_slice would
+    // panic on a remainder).
     let n = core::mem::size_of::<Int4>();
     bun_core::cast_slice(&slice[..slice.len() - slice.len() % n])
 }
-
-// ported from: src/sql/postgres/protocol/ParameterDescription.zig
diff --git a/src/sql/postgres/protocol/ParameterStatus.rs b/src/sql/postgres/protocol/ParameterStatus.rs
index 5bcf7c7ca0b..28656277470 100644
--- a/src/sql/postgres/protocol/ParameterStatus.rs
+++ b/src/sql/postgres/protocol/ParameterStatus.rs
@@ -1,4 +1,5 @@
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 use crate::shared::Data;
 
 #[derive(Default)]
@@ -7,16 +8,12 @@ pub struct ParameterStatus {
     pub value: Data,
 }
 
-// Zig `deinit` only forwards to `name.deinit()` / `value.deinit()`; in Rust those
-// fields drop automatically, so no explicit `impl Drop` is needed.
+// The fields drop automatically, so no explicit `impl Drop` is needed.
 
 impl ParameterStatus {
-    // PORT NOTE: reshaped from out-param `fn(this: *@This(), ...) !void` to
-    // value-returning constructor per PORTING.md.
-    // TODO(port): narrow error set
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         let length = reader.length()?;
         debug_assert!(length >= 4);
 
@@ -26,12 +23,9 @@ impl ParameterStatus {
         })
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/ParameterStatus.zig
diff --git a/src/sql/postgres/protocol/Parse.rs b/src/sql/postgres/protocol/Parse.rs
index c1be7c72d80..501cfa4cabb 100644
--- a/src/sql/postgres/protocol/Parse.rs
+++ b/src/sql/postgres/protocol/Parse.rs
@@ -2,12 +2,13 @@ use core::mem::size_of;
 
 use super::new_writer::NewWriter;
 use super::z_helpers::z_count;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::{Int4, int32};
 
-// PORT NOTE: Zig `deinit` is a no-op (`_ = this;`), so all three slice fields are
-// borrowed for the lifetime of the write. Most protocol message structs avoid
-// lifetime params, but none of Box / &'static / raw fit a transient borrow-only
-// message builder, so this struct carries an explicit `'a`.
+// All three slice fields are borrowed for the lifetime of the write. Most
+// protocol message structs avoid lifetime params, but none of Box / &'static /
+// raw fit a transient borrow-only message builder, so this struct carries an
+// explicit `'a`.
 #[derive(Default)]
 pub struct Parse<'a> {
     pub name: &'a [u8],
@@ -15,17 +16,14 @@ pub struct Parse<'a> {
     pub params: &'a [Int4],
 }
 
-// Zig `pub fn deinit(this: *Parse) void { _ = this; }` — no-op, so no `Drop` impl.
-
 impl<'a> Parse<'a> {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let parameters = self.params;
         if parameters.len() > u16::MAX as usize {
-            return Err(bun_core::err!("TooManyParameters"));
+            return Err(AnyPostgresError::TooManyParameters);
         }
         let count: usize = size_of::<u32>()
             + size_of::<u16>()
@@ -33,9 +31,8 @@ impl<'a> Parse<'a> {
             + z_count(self.name).max(1)
             + z_count(self.query).max(1);
 
-        // Zig: `[_]u8{'P'} ++ toBytes(Int32(count))` — 1 tag byte + 4 length bytes.
-        // `std.mem.toBytes` is native-endian raw bytes of the value; `Int32(count)`
-        // is the PostgresTypes big-endian wrapper, so the on-wire layout matches.
+        // 1 tag byte + 4 length bytes; `int32(count)` produces the big-endian
+        // on-wire encoding.
         let mut header = [0u8; 1 + size_of::<u32>()];
         header[0] = b'P';
         header[1..].copy_from_slice(&int32(count));
@@ -49,13 +46,10 @@ impl<'a> Parse<'a> {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/Parse.zig
diff --git a/src/sql/postgres/protocol/PasswordMessage.rs b/src/sql/postgres/protocol/PasswordMessage.rs
index 3546f190da2..31d675f6b97 100644
--- a/src/sql/postgres/protocol/PasswordMessage.rs
+++ b/src/sql/postgres/protocol/PasswordMessage.rs
@@ -1,3 +1,4 @@
+use crate::postgres::AnyPostgresError;
 use crate::postgres::protocol::new_writer::NewWriter;
 use crate::postgres::types::int_types::int32;
 use crate::shared::Data;
@@ -14,34 +15,29 @@ impl Default for PasswordMessage {
     }
 }
 
-// Zig `deinit` only calls `this.password.deinit()`; `Data` owns its buffer and
-// implements `Drop`, so no explicit `Drop` impl is needed here.
+// `Data` owns its buffer and implements `Drop`, so no explicit `Drop` impl is
+// needed here.
 
 impl PasswordMessage {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let password = self.password.slice();
         let count: usize = core::mem::size_of::<u32>() + password.len() + 1;
-        // Zig: `[_]u8{'p'} ++ toBytes(Int32(count))` — comptime array concat.
         let mut header = [0u8; 5];
         header[0] = b'p';
-        // `int32(count)` already returns the big-endian `[u8; 4]` (mirrors std.mem.toBytes(Int32(count))).
+        // `int32(count)` returns the big-endian `[u8; 4]`.
         header[1..5].copy_from_slice(&int32(count));
         writer.write(&header)?;
         writer.string(password)?;
         Ok(())
     }
 
-    // Zig: `pub const write = WriteWrap(@This(), writeInternal).write;`
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/PasswordMessage.zig
diff --git a/src/sql/postgres/protocol/PortalOrPreparedStatement.rs b/src/sql/postgres/protocol/PortalOrPreparedStatement.rs
index df7d7863e7e..5bfb288dbc8 100644
--- a/src/sql/postgres/protocol/PortalOrPreparedStatement.rs
+++ b/src/sql/postgres/protocol/PortalOrPreparedStatement.rs
@@ -18,5 +18,3 @@ impl<'a> PortalOrPreparedStatement<'a> {
         }
     }
 }
-
-// ported from: src/sql/postgres/protocol/PortalOrPreparedStatement.zig
diff --git a/src/sql/postgres/protocol/ReadyForQuery.rs b/src/sql/postgres/protocol/ReadyForQuery.rs
index 6ad35f8c761..b2ad7bb20fb 100644
--- a/src/sql/postgres/protocol/ReadyForQuery.rs
+++ b/src/sql/postgres/protocol/ReadyForQuery.rs
@@ -1,5 +1,6 @@
 use super::new_reader::NewReader;
 use super::transaction_status_indicator::TransactionStatusIndicator;
+use crate::postgres::AnyPostgresError;
 
 pub struct ReadyForQuery {
     pub status: TransactionStatusIndicator,
@@ -14,11 +15,9 @@ impl Default for ReadyForQuery {
 }
 
 impl ReadyForQuery {
-    // PORT NOTE: reshaped out-param constructor (`this.* = .{...}`) to return Self.
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<Self, AnyPostgresError> {
         let length = reader.length()?;
         debug_assert!(length >= 4);
 
@@ -30,12 +29,9 @@ impl ReadyForQuery {
         })
     }
 
-    // Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
     pub fn decode<Container: super::new_reader::ReaderContext>(
         context: Container,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         Self::decode_internal(NewReader { wrapped: context })
     }
 }
-
-// ported from: src/sql/postgres/protocol/ReadyForQuery.zig
diff --git a/src/sql/postgres/protocol/RowDescription.rs b/src/sql/postgres/protocol/RowDescription.rs
index f3abbcab62f..7c4ca5d5292 100644
--- a/src/sql/postgres/protocol/RowDescription.rs
+++ b/src/sql/postgres/protocol/RowDescription.rs
@@ -1,31 +1,26 @@
 use super::field_description::FieldDescription;
 use super::new_reader::NewReader;
+use crate::postgres::AnyPostgresError;
 
 #[derive(Default)]
 pub struct RowDescription {
     pub fields: Box<[FieldDescription]>,
 }
 
-// `pub fn deinit` → `impl Drop`: the Zig body only loops `field.deinit()` then
-// `default_allocator.free(this.fields)`. With `fields: Box<[FieldDescription]>`,
-// Rust drops each element then frees the slice automatically — no explicit Drop
-// needed.
+// With `fields: Box<[FieldDescription]>`, Rust drops each element then frees
+// the slice automatically — no explicit Drop needed.
 
 impl RowDescription {
-    // PORT NOTE: out-param constructor (`this.* = .{...}`) reshaped to return `Result<Self, _>`.
-    // TODO(port): narrow error set
     pub fn decode_internal<Container: super::new_reader::ReaderContext>(
         mut reader: NewReader<Container>,
-    ) -> Result<Self, bun_core::Error> {
+    ) -> Result<Self, AnyPostgresError> {
         let mut remaining_bytes = reader.length()?;
         remaining_bytes = remaining_bytes.saturating_sub(4);
         let _ = remaining_bytes;
 
         let field_count: usize = usize::from(reader.short()?);
 
-        // PORT NOTE: Zig allocates an uninit slice, fills it in-place, and uses
-        // an `errdefer` to deinit the filled prefix + free on failure. Reshaped
-        // to `Vec::push` so `?` drops already-decoded elements automatically.
+        // `Vec::push` so `?` drops already-decoded elements automatically.
         let mut fields: Vec<FieldDescription> = Vec::with_capacity(field_count);
         for _ in 0..field_count {
             fields.push(FieldDescription::decode_internal::<Container>(&mut reader)?);
@@ -36,7 +31,3 @@ impl RowDescription {
         })
     }
 }
-
-// Zig `DecoderWrap(@This(), ...)` — see src/sql/postgres/protocol/DecoderWrap.rs
-
-// ported from: src/sql/postgres/protocol/RowDescription.zig
diff --git a/src/sql/postgres/protocol/SASLInitialResponse.rs b/src/sql/postgres/protocol/SASLInitialResponse.rs
index 7facf43d346..9e349523e0d 100644
--- a/src/sql/postgres/protocol/SASLInitialResponse.rs
+++ b/src/sql/postgres/protocol/SASLInitialResponse.rs
@@ -1,3 +1,4 @@
+use crate::postgres::AnyPostgresError;
 use crate::postgres::protocol::new_writer::NewWriter;
 use crate::postgres::types::int_types::int32;
 use crate::shared::Data;
@@ -23,8 +24,7 @@ impl SASLInitialResponse {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let mechanism = self.mechanism.slice();
         let data = self.data.slice();
         let count: usize = core::mem::size_of::<u32>()
@@ -44,8 +44,4 @@ impl SASLInitialResponse {
         writer.write(data)?;
         Ok(())
     }
-
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
 }
-
-// ported from: src/sql/postgres/protocol/SASLInitialResponse.zig
diff --git a/src/sql/postgres/protocol/SASLResponse.rs b/src/sql/postgres/protocol/SASLResponse.rs
index b98e9328355..6db2d3066f9 100644
--- a/src/sql/postgres/protocol/SASLResponse.rs
+++ b/src/sql/postgres/protocol/SASLResponse.rs
@@ -1,4 +1,5 @@
 use super::new_writer::NewWriter;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::int32;
 use crate::shared::Data;
 
@@ -14,13 +15,11 @@ impl SASLResponse {
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
+    ) -> Result<(), AnyPostgresError> {
         let data = self.data.slice();
         let count: usize = core::mem::size_of::<u32>() + data.len();
         let mut header = [0u8; 5];
         header[0] = b'p';
-        // std.mem.toBytes(Int32(count)) — Int32 byte-swaps to network order, then take native bytes
         // `int32(count)` already returns the big-endian `[u8; 4]`.
         header[1..5].copy_from_slice(&int32(count));
         writer.write(&header)?;
@@ -28,13 +27,10 @@ impl SASLResponse {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: &mut NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/SASLResponse.zig
diff --git a/src/sql/postgres/protocol/StackReader.rs b/src/sql/postgres/protocol/StackReader.rs
index d82331b31e4..411f746af09 100644
--- a/src/sql/postgres/protocol/StackReader.rs
+++ b/src/sql/postgres/protocol/StackReader.rs
@@ -56,8 +56,8 @@ impl<'a> StackReader<'a> {
         }
 
         self.skip(count);
-        // PORT NOTE: reshaped for borrowck — copy the &'a [u8] out before slicing so the
-        // returned Data borrows 'a, not &mut self.
+        // Copy the &'a [u8] out before slicing so the returned Data borrows 'a,
+        // not &mut self.
         let buffer: &'a [u8] = self.buffer;
         Ok(Data::Temporary(bun_ptr::RawSlice::new(
             &buffer[offset..*self.offset],
@@ -65,8 +65,8 @@ impl<'a> StackReader<'a> {
     }
 
     pub fn read_z(&mut self) -> Result<Data, AnyPostgresError> {
-        // PORT NOTE: reshaped for borrowck — inline `peek()` so `remaining` borrows 'a
-        // (via the Copy &'a [u8]) instead of &self, allowing `self.skip()` below.
+        // Inline `peek()` so `remaining` borrows 'a (via the Copy &'a [u8])
+        // instead of &self, allowing `self.skip()` below.
         let buffer: &'a [u8] = self.buffer;
         let remaining = &buffer[*self.offset..];
         if let Some(zero) = strings::index_of_char(remaining, 0) {
@@ -99,5 +99,3 @@ impl<'a> ReaderContext for StackReader<'a> {
         Self::read_z(self)
     }
 }
-
-// ported from: src/sql/postgres/protocol/StackReader.zig
diff --git a/src/sql/postgres/protocol/StartupMessage.rs b/src/sql/postgres/protocol/StartupMessage.rs
index c662a07fcc9..4b6a1ef4747 100644
--- a/src/sql/postgres/protocol/StartupMessage.rs
+++ b/src/sql/postgres/protocol/StartupMessage.rs
@@ -2,6 +2,7 @@ use core::mem::size_of;
 
 use super::new_writer::NewWriter;
 use super::z_helpers::z_field_count;
+use crate::postgres::AnyPostgresError;
 use crate::postgres::types::int_types::{int4, int32};
 use crate::shared::Data;
 
@@ -22,11 +23,10 @@ impl Default for StartupMessage {
 }
 
 impl StartupMessage {
-    // TODO(port): narrow error set
     pub fn write_internal<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         let user = self.user.slice();
         let database = self.database.slice();
         let options = self.options.slice();
@@ -64,13 +64,10 @@ impl StartupMessage {
         Ok(())
     }
 
-    // Zig `WriteWrap(@This(), ...)` — see src/sql/postgres/protocol/WriteWrap.rs
     pub fn write<Context: super::new_writer::WriterContext>(
         &self,
         writer: NewWriter<Context>,
-    ) -> Result<(), bun_core::Error> {
+    ) -> Result<(), AnyPostgresError> {
         self.write_internal(writer)
     }
 }
-
-// ported from: src/sql/postgres/protocol/StartupMessage.zig
diff --git a/src/sql/postgres/protocol/TransactionStatusIndicator.rs b/src/sql/postgres/protocol/TransactionStatusIndicator.rs
index 0e319b16b70..dde65563635 100644
--- a/src/sql/postgres/protocol/TransactionStatusIndicator.rs
+++ b/src/sql/postgres/protocol/TransactionStatusIndicator.rs
@@ -1,7 +1,6 @@
-// PORT NOTE: Zig source is `enum(u8) { ..., _ }` — a *non-exhaustive* enum, meaning any
-// u8 value is valid storage (the `_` arm). A Rust `#[repr(u8)] enum` would be UB for
-// values outside {I, T, E}, so this is ported as a transparent u8 newtype with
-// associated consts instead.
+// Any u8 value is valid storage (the wire can carry bytes outside {I, T, E}).
+// A Rust `#[repr(u8)] enum` would be UB for such values, so this is a
+// transparent u8 newtype with associated consts instead.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub struct TransactionStatusIndicator(pub u8);
@@ -10,5 +9,3 @@ impl TransactionStatusIndicator {
     /// if idle (not in a transaction block)
     pub(crate) const I: Self = Self(b'I');
 }
-
-// ported from: src/sql/postgres/protocol/TransactionStatusIndicator.zig
diff --git a/src/sql/postgres/protocol/WriteWrap.rs b/src/sql/postgres/protocol/WriteWrap.rs
index 493ca2b287f..e7af91df4b1 100644
--- a/src/sql/postgres/protocol/WriteWrap.rs
+++ b/src/sql/postgres/protocol/WriteWrap.rs
@@ -3,12 +3,10 @@ use core::marker::PhantomData;
 use crate::postgres::any_postgres_error::AnyPostgresError;
 use crate::postgres::protocol::new_writer::{NewWriter, WriterContext};
 
-// Zig: `fn WriteWrap(comptime Container: type, comptime writeFn: anytype) type { return struct { ... } }`
-//
-// `writeFn` is a comptime *value* (a function) bound at type-construction time, not passed
-// per-call. Stable Rust cannot take a fn as a const generic, so we model it as a ZST type
-// parameter `F: WriteFn<Container>` — callers supply a unit struct that impls the trait.
-// This keeps `write(this, context)` 2-arg, matching the Zig signature for side-by-side diff.
+// `writeFn` is bound at type-construction time, not passed per-call. Stable
+// Rust cannot take a fn as a const generic, so we model it as a ZST type
+// parameter `F: WriteFn<Container>` — callers supply a unit struct that impls
+// the trait. This keeps `write(this, context)` 2-arg.
 // TODO(refactor): check call sites and consider flattening this to a trait directly on
 // `Container` (a provided `write` method) instead of a zero-sized generic struct.
 pub trait WriteFn<Container> {
@@ -25,11 +23,7 @@ impl<Container, F: WriteFn<Container>> WriteWrap<Container, F> {
         this: &mut Container,
         context: Ctx,
     ) -> Result<(), AnyPostgresError> {
-        // Zig passed `Context` (the type) as an explicit arg; in Rust the generic `<Ctx>`
-        // IS that arg (see PORTING.md §Comptime reflection — `@TypeOf` is dropped).
         F::call(this, NewWriter { wrapped: context })?;
         Ok(())
     }
 }
-
-// ported from: src/sql/postgres/protocol/WriteWrap.zig
diff --git a/src/sql/postgres/protocol/zHelpers.rs b/src/sql/postgres/protocol/zHelpers.rs
index e1bb2937f9f..26f5af40de2 100644
--- a/src/sql/postgres/protocol/zHelpers.rs
+++ b/src/sql/postgres/protocol/zHelpers.rs
@@ -13,5 +13,3 @@ pub(crate) fn z_field_count(prefix: &[u8], slice: &[u8]) -> usize {
 
     z_count(prefix)
 }
-
-// ported from: src/sql/postgres/protocol/zHelpers.zig
diff --git a/src/sql/postgres/types/Tag.rs b/src/sql/postgres/types/Tag.rs
index 7ad1b51792d..a1b5f4e6e34 100644
--- a/src/sql/postgres/types/Tag.rs
+++ b/src/sql/postgres/types/Tag.rs
@@ -58,9 +58,9 @@
 
 use super::int_types::short as Short;
 
-// Zig: `enum(short) { ..., _ }` — non-exhaustive (any `short` value is a valid `Tag`).
-// A `#[repr(i16)] enum` cannot hold arbitrary values, so model as a transparent newtype
-// with associated consts.
+// Non-exhaustive: any `short` value is a valid `Tag`. A `#[repr(i16)] enum`
+// cannot hold arbitrary values, so model as a transparent newtype with
+// associated consts.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct Tag(pub Short);
@@ -295,25 +295,22 @@ impl Tag {
         0
     }
 
-    // Zig: pub const toJSTypedArrayType / toJS / fromJS = @import("../../../sql_jsc/...").*;
-    // Deleted per PORTING.md — these become extension-trait methods in `bun_sql_jsc`.
+    // `toJSTypedArrayType` / `toJS` / `fromJS` are extension-trait methods in
+    // `bun_sql_jsc`.
 
-    // PORT NOTE: `byteArrayType` / `pgArrayType` / `PostgresBinarySingleDimensionArray`
-    // are not ported. The Zig version overlaid an `extern struct` of i32 fields onto a
-    // `[]const u8` wire buffer via `@ptrCast(@alignCast(@constCast(...)))` and byte-swapped
-    // in place. In Rust that is UB on two axes: (1) the recv buffer carries no 4-byte
-    // alignment guarantee, and (2) writing through a pointer derived from `&[u8]` violates
-    // Stacked Borrows / lets LLVM elide the writes via the `readonly` parameter attribute
-    // (observed: release-asan left `len` un-swapped → 192MB OOB memcpy in SQLClient.cpp).
-    // The sole caller — `bun_sql_jsc::postgres::DataCell::from_bytes_typed_array` — instead
-    // does explicit unaligned field reads + copies into an owned buffer. See that function
-    // for the wire layout and the original `.int4_array => i32` / `.float4_array => f32`
-    // element-type mapping.
+    // There is deliberately no in-place overlay of a struct of i32 fields onto
+    // the `&[u8]` wire buffer here. That would be UB on two axes: (1) the recv
+    // buffer carries no 4-byte alignment guarantee, and (2) writing through a
+    // pointer derived from `&[u8]` violates Stacked Borrows / lets LLVM elide
+    // the writes via the `readonly` parameter attribute (observed:
+    // release-asan left `len` un-swapped → 192MB OOB memcpy in SQLClient.cpp).
+    // Instead, `bun_sql_jsc::postgres::DataCell::from_bytes_typed_array` does
+    // explicit unaligned field reads + copies into an owned buffer. See that
+    // function for the wire layout and the `.int4_array => i32` /
+    // `.float4_array => f32` element-type mapping.
 }
 
-// Zig: `fn PostgresBinarySingleDimensionArray(comptime T: type) type { return extern struct { ... } }`
-// Not ported — see PORT NOTE on `Tag` above. Kept here only as documentation of the
-// wire header shape the Zig code overlaid:
+// Documentation of the binary single-dimension-array wire header shape:
 //
 //   struct array_int4 {
 //     int4_t ndim;        /* Number of dimensions */
@@ -325,13 +322,11 @@ impl Tag {
 //     int4_t first_value; /* Beginning of integer data */
 //   };
 
-/// `@bitCast(@byteSwap(@as(Int, @bitCast(val))))` — wire-order byte swap for
-/// the element types the Zig `PostgresBinarySingleDimensionArray` was instantiated
-/// with (`i32` / `f32`; see Zig `byteArrayType`). Used by
-/// `bun_sql_jsc::postgres::DataCell::from_bytes_typed_array`. Replaces the old
-/// generic `byte_swap_same_size` `transmute_copy` shim with safe
-/// `to_bits`/`from_bits`, and the per-element `ptr::{read,write}_unaligned`
-/// casts with safe `from_ne_bytes`/`to_ne_bytes` slice round-trips.
+/// Wire-order byte swap for the binary-array element types (`i32` / `f32`).
+/// Used by `bun_sql_jsc::postgres::DataCell::from_bytes_typed_array`. Uses safe
+/// `to_bits`/`from_bits` instead of a `transmute_copy` shim, and safe
+/// `from_ne_bytes`/`to_ne_bytes` slice round-trips instead of per-element
+/// `ptr::{read,write}_unaligned` casts.
 pub trait WireByteSwap: Copy {
     fn wire_byte_swap(self) -> Self;
     /// Safe replacement for `ptr::read_unaligned(bytes.as_ptr().cast::<Self>())`:
@@ -383,5 +378,3 @@ impl WireByteSwap for f64 {
         out.copy_from_slice(&self.to_ne_bytes());
     }
 }
-
-// ported from: src/sql/postgres/types/Tag.zig
diff --git a/src/sql/postgres/types/int_types.rs b/src/sql/postgres/types/int_types.rs
index 62eb935fc26..fbabd363349 100644
--- a/src/sql/postgres/types/int_types.rs
+++ b/src/sql/postgres/types/int_types.rs
@@ -17,9 +17,6 @@ pub fn int32<T>(value: T) -> [u8; 4]
 where
     int4: TryFrom<T>,
 {
-    // @intCast → checked narrowing; @byteSwap → .swap_bytes(); @bitCast to [4]u8 → .to_ne_bytes()
     let v: int4 = int4::try_from(value).ok().expect("@intCast");
     v.swap_bytes().to_ne_bytes()
 }
-
-// ported from: src/sql/postgres/types/int_types.zig
diff --git a/src/sql/shared/ColumnIdentifier.rs b/src/sql/shared/ColumnIdentifier.rs
index 11510a155a8..1d173c1da93 100644
--- a/src/sql/shared/ColumnIdentifier.rs
+++ b/src/sql/shared/ColumnIdentifier.rs
@@ -41,5 +41,3 @@ impl ColumnIdentifier {
 
 // `deinit` dropped: the only work was `name.deinit()`, which Rust handles via
 // `Data: Drop` when the `Name` variant is dropped.
-
-// ported from: src/sql/shared/ColumnIdentifier.zig
diff --git a/src/sql/shared/ConnectionFlags.rs b/src/sql/shared/ConnectionFlags.rs
index 18777548745..b06ab88756a 100644
--- a/src/sql/shared/ConnectionFlags.rs
+++ b/src/sql/shared/ConnectionFlags.rs
@@ -16,5 +16,3 @@ impl Default for ConnectionFlags {
         Self::empty()
     }
 }
-
-// ported from: src/sql/shared/ConnectionFlags.zig
diff --git a/src/sql/shared/Data.rs b/src/sql/shared/Data.rs
index 9fc30ae3ad7..fe8880f2f1f 100644
--- a/src/sql/shared/Data.rs
+++ b/src/sql/shared/Data.rs
@@ -8,10 +8,11 @@ pub(crate) type InlineStorage = BoundedArray<u8, 15>;
 #[derive(Default)]
 pub enum Data {
     Owned(Vec<u8>),
-    // TODO(port): lifetime — `Temporary` borrows external bytes (see `substring`, which
-    // returns a `Data` aliasing `self`). Stored as a `RawSlice` (encapsulated fat
-    // pointer; safe `.slice()` projection under the borrowed-backing-outlives-holder
-    // invariant). TODO(refactor): revisit whether a `<'a>` lifetime on `Data` is acceptable.
+    // `Temporary` borrows external bytes (see `substring`, which returns a
+    // `Data` aliasing `self`). Stored as a `RawSlice` (encapsulated fat
+    // pointer; safe `.slice()` projection). Invariant: the borrowed backing
+    // bytes must outlive the holder — `Data` carries no lifetime, so this is
+    // enforced by callers, not the compiler.
     Temporary(RawSlice<u8>),
     InlineStorage(InlineStorage),
     #[default]
@@ -54,7 +55,7 @@ impl Data {
     pub fn zdeinit(&mut self) {
         match self {
             Data::Owned(owned) => {
-                // Zero bytes before deinit — Zig `bun.freeSensitive`.
+                // Zero bytes before freeing.
                 let s = owned.slice_mut();
                 // SAFETY: `s` is an exclusive `&mut [u8]`; `len` bytes valid for writes.
                 unsafe { bun_alloc::secure_zero(s.as_mut_ptr(), s.len()) };
@@ -103,8 +104,6 @@ impl Data {
     }
 }
 
-// PORT NOTE: Zig `deinit` freed `Owned`'s buffer. In Rust, `Vec<T>: Drop`
-// already frees on drop, so an explicit `impl Drop for Data` is redundant (and
-// would prevent moving fields out in `to_owned`). The other variants own no heap.
-
-// ported from: src/sql/shared/Data.zig
+// `Vec<T>: Drop` already frees on drop, so an explicit `impl Drop for Data` is
+// redundant (and would prevent moving fields out in `to_owned`). The other
+// variants own no heap.
diff --git a/src/sql/shared/SQLQueryResultMode.rs b/src/sql/shared/SQLQueryResultMode.rs
index e313a480001..79547c1a519 100644
--- a/src/sql/shared/SQLQueryResultMode.rs
+++ b/src/sql/shared/SQLQueryResultMode.rs
@@ -1,5 +1,3 @@
-// PORT NOTE: Zig uses `enum(u2)`; Rust has no `u2` repr, so we use the smallest
-// available (`u8`). Only 3 variants, so layout/ABI is unaffected for any consumer.
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum SQLQueryResultMode {
@@ -7,5 +5,3 @@ pub enum SQLQueryResultMode {
     Values = 1,
     Raw = 2,
 }
-
-// ported from: src/sql/shared/SQLQueryResultMode.zig
diff --git a/src/sql_jsc/Cargo.toml b/src/sql_jsc/Cargo.toml
index 810e8974e9c..d2979e9384c 100644
--- a/src/sql_jsc/Cargo.toml
+++ b/src/sql_jsc/Cargo.toml
@@ -21,6 +21,7 @@ enum-map.workspace = true
 enumset.workspace = true
 libc.workspace = true
 bitflags.workspace = true
+bun_analytics.workspace = true
 bun_base64.workspace = true
 bun_boringssl.workspace = true
 bun_boringssl_sys.workspace = true
diff --git a/src/sql_jsc/jsc.rs b/src/sql_jsc/jsc.rs
index a5c5ed99526..820dc183384 100644
--- a/src/sql_jsc/jsc.rs
+++ b/src/sql_jsc/jsc.rs
@@ -83,8 +83,7 @@ pub use bun_jsc::system_error::verify_error_to_js;
 // `bun_runtime::socket::uws_jsc::create_bun_socket_error_to_js`, but importing
 // it would cycle (`bun_runtime` depends on this crate). The body only needs
 // `bun_uws` + `bun_boringssl_sys` + `bun_jsc` (all lower-tier), so it is hosted
-// here for the SQL connection `createInstance` paths. Matches
-// `src/runtime/socket/uws_jsc.zig`.
+// here for the SQL connection `createInstance` paths.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `BoringSSL.ERR_toJS` — formats the packed error code into a JS Error with
@@ -160,12 +159,6 @@ pub(crate) trait JSGlobalObjectSqlExt {
     /// only need shared access.
     fn sql_vm(&self) -> &VirtualMachine;
     fn sql_vm_ptr(&self) -> *mut VirtualMachine;
-
-    // PORT NOTE: `validate_integer_range` / `validate_big_int_range` /
-    // `gregorian_date_time_to_ms` were duplicated here while gated in
-    // `bun_jsc`; all three are now inherent on `bun_jsc::JSGlobalObject`, so
-    // the trait copies are removed (inherent methods always win in
-    // resolution, so the trait versions were dead code anyway).
 }
 
 impl JSGlobalObjectSqlExt for JSGlobalObject {
@@ -268,8 +261,8 @@ fn hooks() -> &'static SqlRuntimeHooks {
 }
 
 /// Per-VM SQL state — the concrete crate::mysql::MySQLContext /
-/// crate::postgres::PostgresSQLContext that the Zig RareData carried as
-/// value fields. The bun_jsc::rare_data::RareData slots for these are opaque
+/// crate::postgres::PostgresSQLContext.
+/// The bun_jsc::rare_data::RareData slots for these are opaque
 /// (cycle break: bun_jsc cannot name bun_sql_jsc types), so the storage lives
 /// in bun_runtime::jsc_hooks::RuntimeState.sql_rare and is reached via
 /// [VirtualMachineSqlExt::sql_state].
@@ -399,8 +392,7 @@ impl TimerHeap {
 
 // ──────────────────────────────────────────────────────────────────────────
 // AutoFlusher — thin VM-taking wrapper over
-// bun_jsc::event_loop::EventLoop::deferred_tasks (Zig
-// AutoFlusher.registerDeferredMicrotaskWithType).
+// bun_jsc::event_loop::EventLoop::deferred_tasks.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Default, Debug)]
@@ -408,8 +400,7 @@ pub struct AutoFlusher {
     pub registered: bool,
 }
 
-/// Zig's free fns take (comptime Type: type, this: *Type) and duck-type on
-/// this.auto_flusher + Type.onAutoFlush. SQL connection types implement this.
+/// SQL connection types implement this to participate in deferred flushing.
 pub trait HasAutoFlush: Sized {
     fn on_auto_flush(this: *mut Self) -> bool;
 }
@@ -458,7 +449,7 @@ pub mod api {
         use super::*;
 
         /// Owning handle to a `Box<bun_runtime::socket::SSLConfig>`. `None` =
-        /// the default-constructed config (Zig: `.{}`) — callers that pass
+        /// the default-constructed config — callers that pass
         /// `tls: true` get an SSLConfig with no overrides.
         #[derive(Default)]
         pub struct SSLConfig(Option<NonNull<c_void>>);
@@ -501,9 +492,8 @@ pub mod api {
                 }
             }
 
-            /// `SSLConfig.fromJS(vm, global, value)` — VM is accepted for API
-            /// parity with the Zig signature but unused (the hook recovers it
-            /// from `global`).
+            /// `SSLConfig.fromJS(vm, global, value)` — VM is accepted but
+            /// unused (the hook recovers it from `global`).
             pub fn from_js<V>(
                 _vm: V,
                 global: &JSGlobalObject,
@@ -536,10 +526,9 @@ pub mod api {
                 }
             }
         }
-        // Zig-style PascalCase alias.
         pub use SSLConfig as SslConfig;
     }
-    /// Zig: `jsc.API.ServerConfig.SSLConfig` — PascalCase namespace alias.
+    /// PascalCase namespace alias.
     #[allow(non_snake_case)]
     pub mod ServerConfig {
         pub use super::server_config::SSLConfig;
@@ -830,7 +819,7 @@ macro_rules! put_host_functions {
 impl JSFunction {
     /// Accepts either a raw [`JSHostFn`] (C-ABI) or a safe Rust
     /// `fn(&JSGlobalObject, &CallFrame) -> JSValue` / `-> JsResult<JSValue>`
-    /// via [`IntoJSHostFn`] (Zig: `jsc.toJSHostFn(fn)`).
+    /// via [`IntoJSHostFn`].
     pub(crate) fn create<M, F: IntoJSHostFn<M>>(
         global: &JSGlobalObject,
         name: &str,
@@ -859,7 +848,7 @@ impl JSFunction {
 
 pub mod call_frame {
     use super::*;
-    /// `Node.ArgumentsSlice` — cursor over a `&[JSValue]` (CallFrame.zig:289).
+    /// Cursor over a `&[JSValue]`.
     pub(crate) struct ArgumentsSlice<'a> {
         remaining: &'a [JSValue],
         _vm: *const c_void,
@@ -868,15 +857,14 @@ pub mod call_frame {
         /// Generic over the VM handle so it accepts both the local
         /// [`VirtualMachine`] and `bun_jsc`'s (callers pass `global.bun_vm()`,
         /// which returns a raw `*mut VirtualMachineRef`). The VM is not
-        /// dereferenced — it's only carried for API parity with the Zig
-        /// `Node.ArgumentsSlice` shape — so it's accepted by-value and dropped.
+        /// dereferenced, so it's accepted by-value and dropped.
         pub(crate) fn init<V>(_vm: V, slice: &'a [JSValue]) -> Self {
             Self {
                 remaining: slice,
                 _vm: core::ptr::null(),
             }
         }
-        /// Zig `nextEat` (CallFrame.zig) — return the head **and** advance.
+        /// Return the head **and** advance.
         #[inline]
         pub(crate) fn next_eat(&mut self) -> Option<JSValue> {
             let (first, rest) = self.remaining.split_first()?;
diff --git a/src/sql_jsc/lib.rs b/src/sql_jsc/lib.rs
index 973229ea957..4d25a4a93b4 100644
--- a/src/sql_jsc/lib.rs
+++ b/src/sql_jsc/lib.rs
@@ -3,7 +3,7 @@
 
 // ──────────────────────────────────────────────────────────────────────────
 // Module tree wired with explicit `#[path]` attrs (files use PascalCase
-// basenames, mirroring the Zig sources).
+// basenames).
 // ──────────────────────────────────────────────────────────────────────────
 
 // Local signature-compatible stubs for the JSC surface this crate names.
diff --git a/src/sql_jsc/mysql.rs b/src/sql_jsc/mysql.rs
index 6d6dc597c15..dce47d0571f 100644
--- a/src/sql_jsc/mysql.rs
+++ b/src/sql_jsc/mysql.rs
@@ -27,8 +27,7 @@ pub fn create_binding(global_object: &JSGlobalObject) -> JSValue {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Submodule tree (files use PascalCase basenames, mirroring the Zig sources;
-// wired via `#[path]`).
+// Submodule tree (files use PascalCase basenames; wired via `#[path]`).
 // ──────────────────────────────────────────────────────────────────────────
 
 #[path = "mysql/MySQLContext.rs"]
@@ -92,5 +91,3 @@ pub use my_sql_context::MySQLContext;
 pub use my_sql_query::MySQLQuery;
 pub use my_sql_request_queue::MySQLRequestQueue;
 pub use my_sql_statement::MySQLStatement;
-
-// ported from: src/sql_jsc/mysql.zig
diff --git a/src/sql_jsc/mysql/JSMySQLConnection.rs b/src/sql_jsc/mysql/JSMySQLConnection.rs
index 6fb2f49287f..8c3925b1cec 100644
--- a/src/sql_jsc/mysql/JSMySQLConnection.rs
+++ b/src/sql_jsc/mysql/JSMySQLConnection.rs
@@ -23,7 +23,7 @@ use bun_uws::{self as uws, AnySocket, NewSocketHandler, SocketTCP};
 use super::js_mysql_query::JSMySQLQuery;
 use crate::mysql::protocol::any_mysql_error_jsc::mysql_error_to_js;
 use crate::mysql::protocol::error_packet_jsc::ErrorPacketJsc;
-// PORT NOTE: `my_sql_connection::MySQLConnection` (the protocol-layer struct)
+// `my_sql_connection::MySQLConnection` (the protocol-layer struct)
 // is intentionally NOT imported by name — that ident is taken in this module's
 // value namespace by the `declare_scope!` static and in the type namespace by
 // the `pub use JSMySQLConnection as MySQLConnection` re-export below.
@@ -33,7 +33,7 @@ use super::protocol::result_set::{self as ResultSet};
 
 bun_core::declare_scope!(MySQLConnection, visible);
 
-// PORT NOTE: #[bun_jsc::JsClass] proc-macro is not applied because this type
+// The #[bun_jsc::JsClass] proc-macro is not applied because this type
 // already has its `to_js`/`from_js` wired through `crate::jsc::codegen::
 // js_mysql_connection` (which owns the extern symbols) — the hand-rolled
 // `impl crate::jsc::JsClass` below forwards to those. `crate::jsc` re-exports
@@ -108,8 +108,7 @@ impl Drop for DerefOnDrop {
 
 impl JSMySQLConnection {
     /// RAII pair for `ref_()` / `deref()`: bumps the intrusive refcount now and
-    /// releases it on drop. Replaces the Zig `this.ref(); defer this.deref();`
-    /// idiom. The guard stashes a raw pointer (not `&Self`) so no Rust
+    /// releases it on drop. The guard stashes a raw pointer (not `&Self`) so no Rust
     /// reference is held across the potential free in `deref()`; the `&self`
     /// receiver here is only borrowed for the bump itself.
     #[inline]
@@ -343,9 +342,7 @@ impl JSMySQLConnection {
         });
     }
 
-    // TODO(port): #[bun_jsc::host_fn] — free-fn shim emitted inside an
-    // `impl` block tries to call `constructor()` unqualified; re-enable once the
-    // proc-macro emits `Self::constructor` for receiverless impl items.
+    // Exported via the `.classes.ts` codegen (`MySQLConnectionClass__construct`).
     pub fn constructor(
         global_object: &JSGlobalObject,
         _callframe: &CallFrame,
@@ -363,11 +360,11 @@ impl JSMySQLConnection {
     }
 
     pub fn close(&self) {
-        // Zig `this.ref(); defer { updateReferenceType(); deref(); }`. Re-enter
-        // through a `ParentRef` (lifetime-erased `&Self`) so no Rust borrow is
-        // held across the potential free in `deref()`. Guard drop order is
-        // LIFO: `_ref` (deref) drops last, after `update_reference_type()` has
-        // run, so `*p` is still live when the defer body executes.
+        // Re-enter through a `ParentRef` (lifetime-erased `&Self`) so no Rust
+        // borrow is held across the potential free in `deref()`. Guard drop
+        // order is LIFO: `_ref` (deref) drops last, after
+        // `update_reference_type()` has run, so `*p` is still live when the
+        // defer body executes.
         let p = ParentRef::new(self);
         let _ref = self.ref_guard();
         scopeguard::defer! {
@@ -388,8 +385,8 @@ impl JSMySQLConnection {
         if self.vm().is_shutting_down() {
             return self.close();
         }
-        // Zig `this.ref(); defer this.deref();` — raw-pointer RAII guard so no
-        // reference is live across the potential free.
+        // Raw-pointer RAII guard so no reference is live across the potential
+        // free.
         let _ref = self.ref_guard();
         let _loop_guard = self.event_loop().entered();
         self.ensure_js_value_is_alive();
@@ -410,7 +407,7 @@ impl JSMySQLConnection {
     ///
     /// Raw-pointer-shaped (not `&mut self`): ends in `heap::take(this)`, and a
     /// `&mut self` protector live across the dealloc would be UB under Stacked
-    /// Borrows — direct mapping of Zig's `fn deinit(this: *@This())`.
+    /// Borrows.
     fn deinit(this: *mut Self) {
         // SAFETY: routed only through `CellRefCounted::destroy` (refcount==0);
         // `this` is the live `heap::alloc` ptr from `create_instance`, sole
@@ -546,12 +543,9 @@ impl JSMySQLConnection {
         let options_str = bun_core::OwnedString::new(arguments[7].to_bun_string(global_object)?);
         let path_str = bun_core::OwnedString::new(arguments[8].to_bun_string(global_object)?);
 
-        // PORT NOTE: Zig packed all five strings into one `StringBuilder`-owned
-        // arena and handed `[]const u8` slices into it to `MySQLConnection.init`.
-        // The Rust `init` takes `Box<[u8]>` per field (each separately owned),
-        // so we just copy each string into its own allocation. `options_buf`
-        // (the original arena handle, kept only so `cleanup()` could free it)
-        // becomes an empty box.
+        // `init` takes `Box<[u8]>` per field (each separately owned), so we
+        // copy each string into its own allocation. `options_buf` becomes an
+        // empty box.
         let username: Box<[u8]> = Box::from(username_str.to_utf8_without_ref().slice());
         let password: Box<[u8]> = Box::from(password_str.to_utf8_without_ref().slice());
         let database: Box<[u8]> = Box::from(database_str.to_utf8_without_ref().slice());
@@ -683,18 +677,15 @@ impl JSMySQLConnection {
 
     bun_jsc::poll_ref_hostfns!(field = poll_ref, ctx = vm_ctx);
 
-    // TODO(port): #[bun_jsc::host_fn(getter)] — see JsClass note above.
     pub fn get_connected(this: &Self, _: &JSGlobalObject) -> JSValue {
         JSValue::from(this.connection.get().status == my_sql_connection::Status::Connected)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn do_flush(this: &Self, _: &JSGlobalObject, _: &CallFrame) -> JsResult<JSValue> {
         this.register_auto_flusher();
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn do_close(
         this: &Self,
         _global_object: &JSGlobalObject,
@@ -702,9 +693,8 @@ impl JSMySQLConnection {
     ) -> JsResult<JSValue> {
         this.stop_timers();
 
-        // Zig `defer this.updateReferenceType();` — R-2: `&Self` is `Copy`, so
-        // the scopeguard closure captures a shared reborrow and the body's
-        // `connection_mut()` borrow is non-overlapping.
+        // R-2: `&Self` is `Copy`, so the scopeguard closure captures a shared
+        // reborrow and the body's `connection_mut()` borrow is non-overlapping.
         scopeguard::defer! {
             this.update_reference_type();
         }
@@ -769,7 +759,6 @@ impl JSMySQLConnection {
     }
 
     fn fail_fmt(&self, error_code: AnyMySQLErrorT, args: core::fmt::Arguments<'_>) {
-        // bun.handleOom(std.fmt.allocPrint(...)) → write into Vec<u8>
         let mut message: Vec<u8> = Vec::new();
         {
             use std::io::Write;
@@ -781,11 +770,9 @@ impl JSMySQLConnection {
     }
 
     fn fail_with_js_value(&self, value: JSValue) {
-        // Zig `this.ref(); defer { ...; updateReferenceType(); deref(); }` —
-        // runs on every exit path. Re-enter through a raw pointer so no
+        // Runs on every exit path. Re-enter through a raw pointer so no
         // reference is live across the potential free in `deref()`. LIFO drop
-        // order: the `defer!` body runs first, then `_ref` releases the count
-        // — matches Zig.
+        // order: the `defer!` body runs first, then `_ref` releases the count.
         let p = ParentRef::new(self);
         let _ref = self.ref_guard();
         scopeguard::defer! {
@@ -870,11 +857,11 @@ impl JSMySQLConnection {
     ) -> Result<(), OnResultRowError> {
         let result_mode = request.get_result_mode();
         let mut structure: JSValue = JSValue::UNDEFINED;
-        // PORT NOTE: `MySQLStatement::structure(&mut self) -> &CachedStructure`
+        // `MySQLStatement::structure(&mut self) -> &CachedStructure`
         // would keep `*statement` exclusively borrowed for the lifetime of the
         // returned ref, blocking the `&statement.columns` / `fields_flags` reads
-        // below. Stash a `ParentRef` (lifetime-erased `&T`; Zig holds it by
-        // value) and `as_deref` at the `to_js` call site — `*statement`
+        // below. Stash a `ParentRef` (lifetime-erased `&T`)
+        // and `as_deref` at the `to_js` call site — `*statement`
         // outlives this fn (held via `request`'s intrusive ref), satisfying
         // the `ParentRef` liveness invariant.
         let cached_structure: Option<ParentRef<CachedStructure>> = match result_mode {
@@ -887,7 +874,6 @@ impl JSMySQLConnection {
             ResultMode::Raw | ResultMode::Values => None,
         };
         let fields_flags = statement.fields_flags;
-        // PERF(port): was stack-fallback allocator (4096 bytes)
         let mut row = ResultSet::Row {
             global_object: &self.global_object,
             columns: &statement.columns,
@@ -994,21 +980,18 @@ impl JSMySQLConnection {
     pub fn get_statement_from_signature_hash(
         &self,
         signature_hash: u64,
-    ) -> Result<my_sql_connection::PreparedStatementsMapGetOrPutResult<'_>, bun_core::Error> {
-        // TODO(port): narrow error set — `get_or_put` currently yields `AllocError`.
-        self.connection_mut()
-            .statements
-            .get_or_put(signature_hash)
-            .map_err(|_| bun_core::err!("OutOfMemory"))
+    ) -> Result<my_sql_connection::PreparedStatementsMapGetOrPutResult<'_>, bun_core::AllocError>
+    {
+        self.connection_mut().statements.get_or_put(signature_hash)
     }
 }
 
-/// Referenced by `dispatch.zig` (kind = `.mysql[_tls]`).
+/// uSockets event handlers for the MySQL connection (plain and TLS).
 pub struct SocketHandler<const SSL: bool>;
 
-// PORT NOTE: Zig's `pub const SocketType = uws.NewSocketHandler(ssl)` is an
-// inherent associated type, which is unstable in Rust (`feature(inherent_associated_types)`).
-// Spell out `NewSocketHandler<SSL>` at every use site instead.
+// Inherent associated types are unstable in Rust
+// (`feature(inherent_associated_types)`), so spell out
+// `NewSocketHandler<SSL>` at every use site instead.
 impl<const SSL: bool> SocketHandler<SSL> {
     fn _socket(s: NewSocketHandler<SSL>) -> AnySocket {
         if SSL {
@@ -1049,7 +1032,6 @@ impl<const SSL: bool> SocketHandler<SSL> {
             }
         };
         if !handshake_was_successful {
-            // ssl_error.toJS(this.#globalObject) catch return
             let Ok(v) = crate::jsc::verify_error_to_js(&ssl_error, &this.global_object) else {
                 return;
             };
@@ -1068,7 +1050,7 @@ impl<const SSL: bool> SocketHandler<SSL> {
         _: i32,
         _: Option<*mut c_void>,
     ) {
-        // Zig `defer this.deref();` — releases the socket ref taken in on_open.
+        // Releases the socket ref taken in on_open.
         // RAII guard adopts that existing ref (no `ref_()` here); raw-pointer
         // shaped so no reference outlives the potential free.
         let _ref = DerefOnDrop(this.as_ctx_ptr());
@@ -1090,10 +1072,9 @@ impl<const SSL: bool> SocketHandler<SSL> {
     }
 
     pub fn on_data(this: &JSMySQLConnection, _: NewSocketHandler<SSL>, data: &[u8]) {
-        // Zig `this.ref(); defer this.deref();` + `defer { resetConnectionTimeout(); ... }`.
         // Both guards re-enter via raw pointer so no reference is live across
         // the potential free. Guard drop order is LIFO, so `_ref` (deref) runs
-        // last — matches Zig.
+        // last.
         let p = ParentRef::new(this);
         let _ref = this.ref_guard();
 
@@ -1148,13 +1129,10 @@ use bun_sql::shared::sql_query_result_mode::SQLQueryResultMode as ResultMode;
 // pub const js = jsc.Codegen.JSMySQLConnection; — re-exported via `use ... as js` above.
 // fromJS / fromJSDirect / toJS — provided by #[bun_jsc::JsClass] derive.
 
-/// Zig re-export pattern: `MySQLQuery.zig` / `MySQLRequestQueue.zig` /
-/// `JSMySQLQuery.zig` import the JS-wrapper type under the bare
+/// Sibling modules import the JS-wrapper type under the bare
 /// `MySQLConnection` name (the connection state-machine struct lives in
 /// `my_sql_connection`). Surface the alias here so `super::js_mysql_connection::
 /// MySQLConnection` resolves to this type, not the protocol-layer struct.
 pub use JSMySQLConnection as MySQLConnection;
 
 pub type Writer = my_sql_connection::Writer;
-
-// ported from: src/sql_jsc/mysql/JSMySQLConnection.zig
diff --git a/src/sql_jsc/mysql/JSMySQLQuery.rs b/src/sql_jsc/mysql/JSMySQLQuery.rs
index b227b92d769..efd43032645 100644
--- a/src/sql_jsc/mysql/JSMySQLQuery.rs
+++ b/src/sql_jsc/mysql/JSMySQLQuery.rs
@@ -16,7 +16,7 @@ use bun_sql::shared::sql_query_result_mode::SQLQueryResultMode;
 use super::js_mysql_connection::MySQLConnection;
 use crate::mysql::protocol::any_mysql_error_jsc::mysql_error_to_js;
 use crate::postgres::command_tag_jsc::CommandTagJsc as _;
-// PORT NOTE: `my_sql_query` exports both the `MySQLQuery` *struct* and a
+// `my_sql_query` exports both the `MySQLQuery` *struct* and a
 // `declare_scope!`-generated `MySQLQuery` *static* (ScopedLogger). Importing
 // the name once pulls in both namespaces, so the `debug!` macro below resolves
 // against the imported static — no second `declare_scope!` here.
@@ -25,10 +25,11 @@ use super::my_sql_statement::MySQLStatement;
 
 bun_core::define_scoped_log!(debug, MySQLQuery);
 
-// TODO(port): #[bun_jsc::JsClass] — proc-macro emits shims typed against
-// `bun_jsc::{JSGlobalObject, CallFrame, JSValue, JsError}`, which are distinct
-// from this crate's local `crate::jsc::*` mirror types until `crate::jsc`
-// becomes `pub use bun_jsc as jsc;` (see lib.rs TODO). Re-enable then.
+// The `#[bun_jsc::JsClass]` derive is intentionally not applied: this type's
+// JS wiring (`to_js`/`from_js`, the exported `MySQLQueryPrototype__*` /
+// `MySQLQueryClass__*` wrappers) is owned by the `.classes.ts` codegen
+// (`generated_classes.rs` calls the inherent methods below directly), so the
+// derive's placeholder shims would be redundant dead code.
 //
 // R-2 (host-fn re-entrancy): every JS-exposed method takes `&self`; per-field
 // interior mutability via `Cell` (Copy) / `JsCell` (non-Copy). The codegen
@@ -66,9 +67,7 @@ impl JSMySQLQuery {
         core::mem::size_of::<Self>()
     }
 
-    // TODO(port): #[bun_jsc::host_fn] — free-fn shim emitted inside an
-    // `impl` block tries to call `constructor()` unqualified; re-enable once the
-    // proc-macro emits `Self::constructor` for receiverless impl items.
+    // Exported via the `.classes.ts` codegen (`MySQLQueryClass__construct`).
     pub fn constructor(
         global_this: &JSGlobalObject,
         _callframe: &CallFrame,
@@ -91,7 +90,7 @@ impl JSMySQLQuery {
         bun_ptr::finalize_js_box(self, |this| this.this_value.with_mut(|v| v.finalize()));
     }
 
-    // — same proc-macro limitation as `constructor` above.
+    // Reached from JS via `put_host_functions!` in `mysql.rs`.
     pub fn create_instance(
         global_this: &JSGlobalObject,
         callframe: &CallFrame,
@@ -166,7 +165,6 @@ impl JSMySQLQuery {
         Ok(this_value)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn do_run(
         this: &Self,
         global_object: &JSGlobalObject,
@@ -208,7 +206,6 @@ impl JSMySQLQuery {
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn do_cancel(
         _this: &Self,
         _global_object: &JSGlobalObject,
@@ -219,7 +216,6 @@ impl JSMySQLQuery {
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn do_done(
         _this: &Self,
         _global_object: &JSGlobalObject,
@@ -229,7 +225,6 @@ impl JSMySQLQuery {
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn set_mode_from_js(
         this: &Self,
         global_object: &JSGlobalObject,
@@ -241,7 +236,7 @@ impl JSMySQLQuery {
         }
 
         let mode_value = js_mode.coerce::<i32>(global_object)?;
-        // PORT NOTE: `std.meta.intToEnum` → manual range match (no `TryFrom<i32>`
+        // Manual range match (no `TryFrom<i32>`
         // on `SQLQueryResultMode`; it's a plain `#[repr(u8)]` enum).
         let mode = match mode_value {
             0 => SQLQueryResultMode::Objects,
@@ -257,7 +252,6 @@ impl JSMySQLQuery {
         Ok(JSValue::UNDEFINED)
     }
 
-    // TODO(port): #[bun_jsc::host_fn(method)] — see JsClass note above.
     pub fn set_pending_value_from_js(
         this: &Self,
         _global_object: &JSGlobalObject,
@@ -466,9 +460,7 @@ impl JSMySQLQuery {
         {
             debug!("run failed to execute query");
             if !global_object.has_exception() {
-                // PORT NOTE: Zig `return globalObject.throwValue(...)` returns
-                // `error.JSError` into the `AnyMySQLError.Error!void` set; in
-                // Rust we throw for side-effect and map to the enum variant.
+                // Throw for side-effect and map to the enum variant.
                 let _ = global_object.throw_value(mysql_error_to_js(
                     global_object,
                     "failed to execute query",
@@ -625,10 +617,7 @@ impl JSMySQLQuery {
     }
 }
 
-// TODO(port): @export(&jsc.toJSHostFn(createInstance), .{ .name = "MySQLQuery__createInstance" })
-// — the #[bun_jsc::host_fn] macro on `create_instance` should emit this with
-// #[unsafe(no_mangle)] under the name "MySQLQuery__createInstance"; verify codegen wiring.
+// JS reaches `create_instance` through `put_host_functions!` in `mysql.rs`;
+// nothing on the C++ side references it, so no extern export exists.
 
 pub use js::{from_js, from_js_direct, to_js};
-
-// ported from: src/sql_jsc/mysql/JSMySQLQuery.zig
diff --git a/src/sql_jsc/mysql/MySQLConnection.rs b/src/sql_jsc/mysql/MySQLConnection.rs
index 2f3a1b94f24..cf8e88453a6 100644
--- a/src/sql_jsc/mysql/MySQLConnection.rs
+++ b/src/sql_jsc/mysql/MySQLConnection.rs
@@ -1,5 +1,5 @@
 use crate::jsc::{JSValue, VirtualMachineSqlExt as _};
-use bun_collections::{HashMap, OffsetByteList, VecExt};
+use bun_collections::{HashMap, IdentityContext, OffsetByteList, VecExt};
 use bun_uws::{self as uws, AnySocket as Socket, SslCtx};
 
 use bun_sql::mysql::Capabilities;
@@ -40,8 +40,8 @@ use crate::mysql::my_sql_request_queue::MySQLRequestQueue;
 use crate::mysql::my_sql_statement::{self as mysql_statement, MySQLStatement, Param};
 
 pub use bun_sql::mysql::protocol::error_packet::ErrorPacket;
-// Zig: `pub const Status = ConnectionState;` — re-export so callers can write
-// `my_sql_connection::Status::Connected` without naming `bun_sql`.
+// Re-export so callers can write `my_sql_connection::Status::Connected`
+// without naming `bun_sql`.
 pub use bun_sql::mysql::connection_state::ConnectionState as Status;
 
 use crate::jsc::api::server_config::SSLConfig;
@@ -72,10 +72,9 @@ pub struct MySQLConnection {
     _auth_state: AuthState,
 
     auth_data: Vec<u8>,
-    // TODO(perf): in Zig, database/user/password/options are sub-slices into options_buf
-    // (single backing allocation; only options_buf is freed in cleanup()). Per the
-    // `[]const u8 struct field → look at deinit` rule, only options_buf should be
-    // Box<[u8]>; the others should be ranges/raw `*const [u8]` into it. Restore the
+    // PERF: database/user/password/options could be sub-slices into options_buf
+    // (single backing allocation). Only options_buf would need to be
+    // Box<[u8]>; the others could be ranges into it. Restore the
     // single-buffer layout and revert init()'s database/username/password/options
     // params from Box<[u8]> back to &[u8] (1 caller-side alloc, not 5).
     database: Box<[u8]>,
@@ -126,8 +125,7 @@ impl Default for MySQLConnection {
 }
 
 // SAFETY: `MySQLConnection` is the `connection` field embedded inside
-// `JSMySQLConnection` (Zig: `@fieldParentPtr("#connection", this)`); never
-// constructed standalone.
+// `JSMySQLConnection`; never constructed standalone.
 bun_core::impl_field_parent! { MySQLConnection => JSMySQLConnection.connection; fn js_connection_ref; fn get_js_connection; }
 
 impl MySQLConnection {
@@ -231,7 +229,7 @@ impl MySQLConnection {
         Ok(())
     }
 
-    /// PORT NOTE: reshaped for borrowck — `self.queue.advance(js_connection)`
+    /// reshaped for borrowck — `self.queue.advance(js_connection)`
     /// would alias `&mut self.queue` with `&mut JSMySQLConnection` (which
     /// embeds `self`). Route through a single raw root:
     /// `MySQLRequestQueue::advance` takes only `*mut JSMySQLConnection` and
@@ -306,8 +304,7 @@ impl MySQLConnection {
             // release it here (mirrors PostgresSQLConnection::deinit). Silently
             // dropping the `*mut` would leak every MySQLStatement.
             // SAFETY: every value inserted into `statements` is a live boxed
-            // `MySQLStatement` with the map holding one ref (Zig:
-            // `stmt.deref()`).
+            // `MySQLStatement` with the map holding one ref.
             unsafe { MySQLStatement::deref(*stmt) };
         }
         drop(statements);
@@ -336,7 +333,7 @@ impl MySQLConnection {
             .mysql_socket_group::<true>();
 
         // SAFETY: `secure` is set to a live `SSL_CTX*` before TLS upgrade is
-        // requested (Zig: `this.#secure.?`).
+        // requested.
         let ssl_ctx = unsafe {
             &mut *self
                 .secure
@@ -350,8 +347,7 @@ impl MySQLConnection {
             // `tls_config` for the connection lifetime.
             Some(unsafe { bun_core::ffi::cstr(server_name) })
         };
-        // Zig: `@sizeOf(?*JSMySQLConnection)` — `?*T` is an 8-byte null-niche
-        // optional. The Rust layout-equivalent is `Option<NonNull<T>>`; using
+        // `Option<NonNull<T>>` is an 8-byte null-niche optional; using
         // `Option<*mut T>` here would request 16 bytes (separate discriminant)
         // and desync with the trampoline reader (uws_handlers.rs) which reads
         // the slot as `Option<NonNull<_>>`.
@@ -376,7 +372,6 @@ impl MySQLConnection {
         // `adopt_tls`; ext storage was sized for
         // `Option<NonNull<JSMySQLConnection>>` above. One `&mut` reborrow
         // drives both safe inherent methods (`ext` / `start_tls_handshake`).
-        // Zig: `ext(?*JSMySQLConnection).* = this.getJSConnection()`.
         let sock = unsafe { &mut *new_socket };
         *sock.ext::<Option<core::ptr::NonNull<JSMySQLConnection>>>() =
             core::ptr::NonNull::new(js_connection);
@@ -478,15 +473,15 @@ impl MySQLConnection {
 
     pub fn read_and_process_data(&mut self, data: &[u8]) -> Result<(), AnyMySQLError> {
         self.flags.insert(ConnectionFlags::IS_PROCESSING_DATA);
-        // PORT NOTE: reshaped for borrowck — Zig `defer this.flags.is_processing_data = false`
-        // is hand-inlined before every return below (scopeguard would need &mut self.flags).
+        // The flag clear is hand-inlined before every return below
+        // (scopeguard would need &mut self.flags).
         // Clear the timeout.
         self.socket.set_timeout(0);
 
         SocketMonitor::read(data);
 
         if self.read_buffer.remaining().is_empty() {
-            // PORT NOTE: StackReader takes `&Cell<usize>` (interior mutability)
+            // StackReader takes `&Cell<usize>` (interior mutability)
             // so the post-error read of `offset`/`consumed` doesn't conflict.
             let consumed = core::cell::Cell::new(0usize);
             let offset = core::cell::Cell::new(0usize);
@@ -514,9 +509,7 @@ impl MySQLConnection {
                             .write(&data[offset.get()..])
                             .unwrap_or_else(|_| panic!("failed to write to read buffer"));
                     } else {
-                        if cfg!(debug_assertions) {
-                            // TODO(port): bun.handleErrorReturnTrace — no Rust equivalent
-                        }
+                        bun_core::handle_error_return_trace(err);
                         self.flags.remove(ConnectionFlags::IS_PROCESSING_DATA);
                         return Err(err);
                     }
@@ -532,7 +525,7 @@ impl MySQLConnection {
             self.read_buffer
                 .write(data)
                 .unwrap_or_else(|_| panic!("failed to write to read buffer"));
-            // PORT NOTE: reshaped for borrowck — `self.process_packets(self.buffered_reader())`
+            // reshaped for borrowck — `self.process_packets(self.buffered_reader())`
             // borrows `&mut self` twice. Construct the reader first; it holds a
             // `*mut Self` so the second borrow doesn't conflict.
             let reader = self.buffered_reader();
@@ -541,9 +534,7 @@ impl MySQLConnection {
                 Err(err) => {
                     debug!("processPackets with buffer: {}", <&'static str>::from(err));
                     if err != any_mysql_error::Error::ShortRead {
-                        if cfg!(debug_assertions) {
-                            // TODO(port): @errorReturnTrace — no Rust equivalent
-                        }
+                        bun_core::handle_error_return_trace(err);
                         self.flags.remove(ConnectionFlags::IS_PROCESSING_DATA);
                         return Err(err);
                     }
@@ -589,7 +580,6 @@ impl MySQLConnection {
             reader
                 .ensure_capacity(packet_length)
                 .map_err(|_| AnyMySQLError::ShortRead)?;
-            // PORT NOTE: Zig `defer reader.setOffsetFromStart(packet_length)` —
             // `NewReader<C>: Copy` so the scopeguard captures by copy; the inner
             // `C` writes through a raw pointer so the offset update still lands.
             // Always skip the full packet, we dont care about padding or unread bytes.
@@ -663,7 +653,7 @@ impl MySQLConnection {
             "Handshake\n   Server Version: {}\n   Connection ID:  {}\n   Character Set:  {} ({})\n   Server Capabilities:   [ {} ] 0x{:08x}\n   Negotiated Capabilities: [ {} ] 0x{:08x}\n   Status Flags:   [ {} ]\n",
             bstr::BStr::new(self.server_version.slice()),
             self.connection_id,
-            self.character_set as u32,
+            u32::from(self.character_set.to_int()),
             bstr::BStr::new(self.character_set.label()),
             handshake.capability_flags,
             handshake.capability_flags.to_int(),
@@ -762,8 +752,7 @@ impl MySQLConnection {
 
         match status {
             ConnectionState::Connected => {
-                // PORT NOTE: spec spelling — Zig defines `onConnectionEstabilished`
-                // (sic, JSMySQLConnection.zig:654 / MySQLConnection.zig:491).
+                // `on_connection_estabilished` spelling is intentional (sic).
                 self.js_connection_ref().on_connection_estabilished();
             }
             _ => {}
@@ -773,7 +762,7 @@ impl MySQLConnection {
     pub fn handle_auth<C: ReaderContext>(
         &mut self,
         reader: NewReader<C>,
-        header_length: u32, // u24 in Zig
+        header_length: u32, // u24 on the wire
     ) -> Result<(), AnyMySQLError> {
         let first_byte = reader.int::<u8>()?;
         reader.skip(-1isize);
@@ -937,7 +926,7 @@ impl MySQLConnection {
     pub fn handle_command<C: ReaderContext>(
         &mut self,
         reader: NewReader<C>,
-        header_length: u32, // u24 in Zig
+        header_length: u32, // u24 on the wire
     ) -> Result<(), AnyMySQLError> {
         // Get the current request if any
         let Some(request) = self.queue.current_ref() else {
@@ -945,7 +934,7 @@ impl MySQLConnection {
             return Err(AnyMySQLError::UnexpectedPacket);
         };
         // Queue holds a ref on every request; bump it for the body's duration so
-        // re-entrant `deref()` cannot free it (Zig: `defer request.deref()`).
+        // re-entrant `deref()` cannot free it.
         let _request_guard = request.ref_guard();
         // `ThisPtr::get` borrows the local `request` (Copy), not `*self`, so the
         // shared `&JSMySQLQuery` is sound across the `&mut self` calls below.
@@ -959,12 +948,14 @@ impl MySQLConnection {
 
         // Handle based on request type
         if let Some(statement) = request.get_statement() {
-            // Only the `status` discriminant is needed below; read it and drop
-            // the `&mut MySQLStatement` borrow immediately so `request` /
-            // `&mut self` are unconstrained inside the match arms (no raw-ptr
-            // downgrade needed for a single Copy field read).
-            // TODO(port): MySQLStatement intrusive ref_/deref_ (bun_ptr).
-            // Skipped here; the queue's ref on `request` keeps the statement
+            // The match reads `statement.status` (Copy), and the Failed arm
+            // also reads `statement.error_response.*` through this borrow to
+            // build an owned packet copy. The statement borrow ends (NLL)
+            // before any `&mut self` call or re-entrant JS, so `request` /
+            // `&mut self` stay unconstrained where the arms mutate the queue
+            // (no raw-ptr downgrade needed).
+            // MySQLStatement intrusive ref_/deref_ (bun_ptr) is deliberately
+            // skipped here; the queue's ref on `request` keeps the statement
             // alive for the duration of this call.
             match statement.status {
                 mysql_statement::Status::Pending => {
@@ -979,23 +970,30 @@ impl MySQLConnection {
                     self.handle_result_set(reader, header_length)?;
                 }
                 mysql_statement::Status::Failed => {
-                    // PORT NOTE: reshaped for borrowck — Zig `defer this.flushQueue()`
-                    // moved to explicit call after `on_error_packet` below.
+                    // `Data` is not `Clone`, so deep-copy the
+                    // message bytes into an owned packet up front — re-entrant
+                    // JS in `on_error_packet` may release the statement, so
+                    // the packet handed to it must not borrow into it.
+                    let error_response = ErrorPacket {
+                        header: statement.error_response.header,
+                        error_code: statement.error_response.error_code,
+                        sql_state_marker: statement.error_response.sql_state_marker,
+                        sql_state: statement.error_response.sql_state,
+                        error_message: Data::create(statement.error_response.error_message.slice())
+                            .unwrap_or(Data::Empty),
+                    };
+                    // The queue flush is an explicit call after
+                    // `on_error_packet` below.
                     self.flags.insert(ConnectionFlags::IS_READY_FOR_QUERY);
                     self.queue.mark_as_ready_for_query();
                     self.queue.mark_current_request_as_finished(request);
-                    // TODO(port): ErrorPacket is not Clone in bun_sql; the
-                    // Zig passes statement.error_response by value (struct copy).
-                    // Send a default packet as a placeholder until ErrorPacket
-                    // grows Clone or a borrowed-variant overload lands.
-                    //
                     // R-2: `on_error_packet` is `&self`; route through the
                     // audited `js_connection_ref()` container_of accessor (one
                     // centralised unsafe). `*self` sits inside the parent's
                     // `JsCell`, so re-entrant `connection_mut()` does not alias
                     // this outer shared borrow.
                     self.js_connection_ref()
-                        .on_error_packet(Some(request), &ErrorPacket::default());
+                        .on_error_packet(Some(request), &error_response);
                     let _ = self.flush_queue();
                 }
             }
@@ -1133,7 +1131,7 @@ impl MySQLConnection {
     pub fn handle_prepared_statement<C: ReaderContext>(
         &mut self,
         mut reader: NewReader<C>,
-        header_length: u32, // u24 in Zig
+        header_length: u32, // u24 on the wire
     ) -> Result<(), AnyMySQLError> {
         debug!("handlePreparedStatement");
         let first_byte = reader.int::<u8>()?;
@@ -1144,7 +1142,7 @@ impl MySQLConnection {
             return Err(AnyMySQLError::UnexpectedPacket);
         };
         // Queue holds a ref on every request; bump it for the body's duration so
-        // re-entrant `deref()` cannot free it (Zig: `defer request.deref()`).
+        // re-entrant `deref()` cannot free it.
         let _request_guard = request.ref_guard();
         // `ThisPtr::get` borrows the local `request` (Copy), not `*self`.
         let request: &JSMySQLQuery = request.get();
@@ -1209,9 +1207,8 @@ impl MySQLConnection {
 
                 // Read parameter definitions if any
                 if ok.num_params > 0 {
-                    // Zig: bun.default_allocator.alloc(Param, n) — slots are
-                    // overwritten as param-definition packets arrive, so the
-                    // initial value is a placeholder.
+                    // Slots are overwritten as param-definition packets
+                    // arrive, so the initial value is a placeholder.
                     statement.params = (0..ok.num_params as usize)
                         .map(|_| Param {
                             r#type: FieldType::MYSQL_TYPE_NULL,
@@ -1236,18 +1233,18 @@ impl MySQLConnection {
                 debug!("handlePreparedStatement ERROR");
                 let mut err = ErrorPacket::default();
                 err.decode_internal(reader)?;
-                // PORT NOTE: reshaped for borrowck — Zig `defer this.queue.advance(connection)`
-                // moved to explicit call after `on_error_packet` below.
+                // The queue advance is an explicit call after
+                // `on_error_packet` below.
                 self.flags.insert(ConnectionFlags::IS_READY_FOR_QUERY);
                 statement.status = mysql_statement::Status::Failed;
                 // err.error_message is a Data{ .temporary = ... } slice into the socket read
                 // buffer which will be overwritten by the next packet. The statement is cached
                 // in this.statements and its error_response may be read later via
                 // stmt.error_response.toJS(), so we must own a copy of the message bytes.
-                // Zig: `statement.error_response = err;` (struct copy) then overwrite
-                // `error_message` with an owned dupe. ErrorPacket lacks Clone in bun_sql
-                // (Data is not Clone), so reconstruct field-by-field — the scalar fields
-                // (header / error_code / sql_state) are all Copy.
+                // ErrorPacket lacks Clone in bun_sql (Data is not Clone), so
+                // reconstruct field-by-field with an owned dupe of the message
+                // — the scalar fields (header / error_code / sql_state) are
+                // all Copy.
                 statement.error_response = ErrorPacket {
                     header: err.header,
                     error_code: err.error_code,
@@ -1283,7 +1280,7 @@ impl MySQLConnection {
         Ok(())
     }
 
-    // PORT NOTE: reshaped for borrowck — `request` comes from `self.queue` so
+    // reshaped for borrowck — `request` comes from `self.queue` so
     // passing `&mut self` alongside `&mut JSMySQLQuery` would alias. `request`
     // is `&JSMySQLQuery` (R-2: fully interior-mutable, so a shared borrow is
     // sound across the re-entrant `on_query_result` callback). The statement is
@@ -1304,7 +1301,7 @@ impl MySQLConnection {
             status_flags.to_int(),
             is_last_result
         );
-        // PORT NOTE: Zig `defer this.flushQueue()` moved to explicit tail call.
+        // The queue flush is an explicit tail call.
         self.flags
             .set(ConnectionFlags::IS_READY_FOR_QUERY, is_last_result);
         if is_last_result {
@@ -1346,7 +1343,7 @@ impl MySQLConnection {
     fn handle_result_set<C: ReaderContext>(
         &mut self,
         mut reader: NewReader<C>,
-        header_length: u32, // u24 in Zig
+        header_length: u32, // u24 on the wire
     ) -> Result<(), AnyMySQLError> {
         let first_byte = reader.int::<u8>()?;
         debug!("handleResultSet: {:02x}", first_byte);
@@ -1358,7 +1355,7 @@ impl MySQLConnection {
             return Err(AnyMySQLError::UnexpectedPacket);
         };
         // Queue holds a ref on every request; bump it for the body's duration so
-        // re-entrant `deref()` cannot free it (Zig: `defer request.deref()`).
+        // re-entrant `deref()` cannot free it.
         let _request_guard = request.ref_guard();
         // `ThisPtr::get` borrows the local `request` (Copy), not `*self`.
         let request: &JSMySQLQuery = request.get();
@@ -1376,8 +1373,7 @@ impl MySQLConnection {
             PacketType::ERROR => {
                 let mut err = ErrorPacket::default();
                 err.decode_internal(reader)?;
-                // PORT NOTE: reshaped for borrowck — Zig `defer this.flushQueue()`
-                // moved to explicit tail call.
+                // The queue flush is an explicit tail call.
                 if let Some(statement) = request.get_statement() {
                     statement.reset();
                 }
@@ -1450,9 +1446,9 @@ impl MySQLConnection {
                             // the already-freed columns again (use-after-free / double-free).
                             statement.columns = Vec::new();
                         }
-                        // Zig: `try bun.default_allocator.alloc(ColumnDefinition41, header.field_count)`
-                        // — fallible. field_count is server-controlled (lenenc int up to 2^64-1),
-                        // so a panicking `collect()` would let a malicious/buggy server crash us.
+                        // Fallible allocation: field_count is server-controlled
+                        // (lenenc int up to 2^64-1), so a panicking `collect()`
+                        // would let a malicious/buggy server crash us.
                         let field_count = usize::try_from(header.field_count)
                             .map_err(|_| AnyMySQLError::OutOfMemory)?;
                         let mut columns = Vec::new();
@@ -1574,7 +1570,6 @@ impl From<FlushQueueError> for bun_core::Error {
 // Writer / Reader — protocol-layer adapters wrapping the connection's
 // OffsetByteList buffers. Hold `*mut MySQLConnection` (Copy) so they satisfy
 // `bun_sql::mysql::protocol::new_{reader,writer}::{Reader,Writer}Context: Copy`.
-// This matches the Zig semantics where both wrap `*MySQLConnection`.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[derive(Clone, Copy)]
@@ -1593,7 +1588,7 @@ impl Writer {
         //
         // Raw-pointer field projection (`addr_of_mut!`) avoids materializing
         // an intermediate `&mut MySQLConnection`, which could alias the
-        // caller's own `&mut self` (see the PORT NOTE on `Reader` below).
+        // caller's own `&mut self` (see the aliasing note on `Reader` below).
         // Callers never touch `write_buffer` through `&mut self` while a
         // `Writer` is live, so no two `&mut OffsetByteList` coexist.
         unsafe { &mut *core::ptr::addr_of_mut!((*self.connection).write_buffer) }
@@ -1630,13 +1625,12 @@ pub struct Reader {
     pub connection: *mut MySQLConnection,
 }
 
-// PORT NOTE (aliasing): `Reader` is constructed from `&mut MySQLConnection`
+// Aliasing: `Reader` is constructed from `&mut MySQLConnection`
 // and then threaded through `process_packets(&mut self, reader)` — i.e. the
 // raw `*mut` and a live `&mut self` coexist. Materializing a whole-struct
 // `&mut MySQLConnection` here would alias that `&mut self` (Stacked Borrows
 // UB). Instead the accessors below project only the specific field(s) the
-// reader touches via `addr_of_mut!`, matching `Writer` above and Zig's
-// freely-aliasing `*MySQLConnection` semantics.
+// reader touches via `addr_of_mut!`, matching `Writer` above.
 impl Reader {
     #[inline]
     #[allow(clippy::mut_from_ref)]
@@ -1707,7 +1701,7 @@ impl ReaderContext for Reader {
             return Err(AnyMySQLError::ShortRead);
         }
 
-        // PORT NOTE: reshaped for borrowck — capture detached slice before skip().
+        // reshaped for borrowck — capture detached slice before skip().
         let slice = bun_ptr::RawSlice::new(&remaining[0..count]);
         self.skip(isize::try_from(count).expect("int cast"));
         Ok(Data::Temporary(slice))
@@ -1730,13 +1724,11 @@ impl ReaderContext for Reader {
 // `JSMySQLConnection::on_query_result(MySQLQueryResult)` without conversion.
 pub use bun_sql::mysql::MySQLQueryResult as QueryResult;
 
-// TODO(port): IdentityContext(u64) hasher — bun_collections::HashMap should support identity hash for u64 keys
-pub(crate) type PreparedStatementsMap = HashMap<u64, *mut MySQLStatement>;
+// Keys are already wyhash values, so identity hash avoids re-hashing.
+pub(crate) type PreparedStatementsMap = HashMap<u64, *mut MySQLStatement, IdentityContext<u64>>;
 /// Result of `PreparedStatementsMap::get_or_put` — surfaced for
 /// `JSMySQLConnection::get_statement_from_signature_hash`.
 pub(crate) type PreparedStatementsMapGetOrPutResult<'a> =
     bun_collections::hash_map::GetOrPutResult<'a, *mut MySQLStatement>;
 
 const MAX_PIPELINE_SIZE: usize = u16::MAX as usize; // about 64KB per connection
-
-// ported from: src/sql_jsc/mysql/MySQLConnection.zig
diff --git a/src/sql_jsc/mysql/MySQLContext.rs b/src/sql_jsc/mysql/MySQLContext.rs
index 47fc381a231..ae43273b45a 100644
--- a/src/sql_jsc/mysql/MySQLContext.rs
+++ b/src/sql_jsc/mysql/MySQLContext.rs
@@ -3,13 +3,12 @@ use crate::jsc::{CallFrame, JSGlobalObject, JSValue, StrongOptional, VirtualMach
 #[repr(C)]
 #[derive(Default)]
 pub struct MySQLContext {
-    // Zig: `Strong.Optional = .empty` → `StrongOptional::empty()` (Default).
     pub on_query_resolve_fn: StrongOptional,
     pub on_query_reject_fn: StrongOptional,
 }
 
-// TODO(port): bun_jsc::host_fn proc-macro
-// (Zig: `@export(&JSC.toJSHostFn(init), .{ .name = "MySQLContext__init" })`).
+// The binding object is built in Rust (`mysql.rs` registers this fn through
+// `put_host_functions!`/`IntoJSHostFn`), so no C symbol is needed.
 pub(crate) fn init(global: &JSGlobalObject, frame: &CallFrame) -> JSValue {
     // `bun_vm()` → `&'static VirtualMachine` (per-thread singleton); `as_mut()`
     // is the canonical safe escape hatch for the shrinking set of `&mut self`
@@ -19,5 +18,3 @@ pub(crate) fn init(global: &JSGlobalObject, frame: &CallFrame) -> JSValue {
     ctx.on_query_reject_fn.set(global, frame.argument(1));
     JSValue::UNDEFINED
 }
-
-// ported from: src/sql_jsc/mysql/MySQLContext.zig
diff --git a/src/sql_jsc/mysql/MySQLQuery.rs b/src/sql_jsc/mysql/MySQLQuery.rs
index fadf5f72af2..8432a8a249c 100644
--- a/src/sql_jsc/mysql/MySQLQuery.rs
+++ b/src/sql_jsc/mysql/MySQLQuery.rs
@@ -28,8 +28,7 @@ bun_core::define_scoped_log!(debug, MySQLQuery, visible);
 
 pub struct MySQLQuery {
     // Intrusive refcount (`MySQLStatement::ref_` / `::deref`). Null = none.
-    // Zig uses `bun.ptr.RefCount` and mutates `stmt.status` / `stmt.execution_flags`
-    // in place; the connection's `PreparedStatementsMap` also stores `*mut MySQLStatement`,
+    // The connection's `PreparedStatementsMap` also stores `*mut MySQLStatement`,
     // so this pointer participates in the same intrusive ownership graph (each holder
     // owns one ref).
     statement: *mut MySQLStatement,
@@ -39,7 +38,6 @@ pub struct MySQLQuery {
     flags: Flags,
 }
 
-/// Zig: `packed struct(u8) { bigint, simple, pipelined: bool, result_mode: SQLQueryResultMode, _padding: u3 }`
 /// Not all fields are `bool`, so per PORTING.md this is a transparent `u8` with shift accessors.
 #[repr(transparent)]
 #[derive(Copy, Clone, Default)]
@@ -76,7 +74,7 @@ impl Flags {
     fn result_mode(self) -> SQLQueryResultMode {
         // result_mode bits were written from a valid SQLQueryResultMode
         // discriminant (`set_result_mode`); the unreachable 4th bit-state
-        // traps (matches Zig's safety-checked `@enumFromInt`).
+        // traps.
         match (self.0 & Self::RESULT_MODE_MASK) >> Self::RESULT_MODE_SHIFT {
             0 => SQLQueryResultMode::Objects,
             1 => SQLQueryResultMode::Values,
@@ -155,7 +153,7 @@ impl MySQLQuery {
     /// `statement` is a raw `*mut MySQLStatement` (not `&mut`) because the sole caller,
     /// `run_prepared_query`, must derive it from `self.statement` and then call this
     /// `&mut self` method — a `&mut MySQLStatement` rooted in `*self` would overlap that
-    /// reborrow. The Zig original (.zig:59) likewise passes an independent `*MySQLStatement`.
+    /// reborrow.
     fn bind_and_execute<C: WriterContext>(
         &mut self,
         writer: NewWriter<C>,
@@ -216,8 +214,7 @@ impl MySQLQuery {
         // SAFETY: `statement` was copied from `self.statement` by `run_prepared_query`;
         // the intrusive ref held there keeps the allocation alive across this call. The
         // caller passes the raw pointer before reborrowing `self`, so this is the only
-        // live mutable access path to the statement for the duration of this function
-        // (matches Zig .zig:74 which takes an independent `*MySQLStatement`).
+        // live mutable access path to the statement for the duration of this function.
         let statement = unsafe { &mut *statement };
 
         // Bind before touching the writer so a bind failure (user-triggerable via JS
@@ -276,7 +273,6 @@ impl MySQLQuery {
     }
 
     fn run_simple_query(&mut self, connection: &MySQLConnection) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if self.status != Status::Pending || !connection.can_execute_query() {
             debug!("cannot execute query");
             // cannot execute query
@@ -285,13 +281,11 @@ impl MySQLQuery {
         let query_str = self.query.to_utf8();
         let writer = connection.get_writer();
         if self.statement.is_null() {
-            // Zig: `bun.new(MySQLStatement, .{ .signature = .empty(), .status = .parsing, .ref_count = .initExactRefs(1) })`.
-            // `heap::alloc` yields a heap allocation with intrusive ref_count == 1
-            // (the `Default` impl sets `ref_count = Cell::new(1)`).
-            // FRU (`..Default::default()`) is illegal for `Drop` types; mutate instead.
-            let mut stmt = Box::new(MySQLStatement::default());
-            stmt.signature = Signature::empty();
-            stmt.status = my_sql_statement::Status::Parsing;
+            // `MySQLStatement::new` sets the intrusive ref_count to 1.
+            let stmt = Box::new(MySQLStatement::new(
+                Signature::empty(),
+                my_sql_statement::Status::Parsing,
+            ));
             self.statement = bun_core::heap::into_raw(stmt);
         }
         mysql_request::execute_query(query_str.slice(), writer)?;
@@ -307,7 +301,6 @@ impl MySQLQuery {
         columns_value: JSValue,
         binding_value: JSValue,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut query_str: Option<bun_core::zig_string::Slice> = None;
         // `defer if (query_str) |str| str.deinit()` — deleted: `Utf8Slice` impls `Drop`.
 
@@ -322,8 +315,7 @@ impl MySQLQuery {
                 Ok(s) => s,
                 Err(err) => {
                     if !global_object.has_exception() {
-                        // PORT NOTE: Zig calls `AnyMySQLError.mysqlErrorToJS` here, but the
-                        // Rust `Signature::generate` returns a wider `bun_core::Error`. Use
+                        // `Signature::generate` returns a wider `bun_core::Error`. Use
                         // `throw_error` (which builds an `Error` instance from the error
                         // name + message) instead of forcing into the MySQL enum.
                         let _ = global_object.throw_error(err, "failed to generate signature");
@@ -333,13 +325,15 @@ impl MySQLQuery {
             };
             query_str = Some(query);
             // errdefer signature.deinit() — `Signature: Drop` handles the error path; on the
-            // found_existing success path below we explicitly drop it (Zig calls deinit + reassigns empty).
+            // found_existing success path below we explicitly drop it.
             let entry = match connection
                 .get_statement_from_signature_hash(bun_wyhash::hash(&signature.name))
             {
                 Ok(e) => e,
                 Err(err) => {
-                    let _ = global_object.throw_error(err, "failed to allocate statement");
+                    // `err` is `bun_core::AllocError`; `throw_error` takes
+                    // `bun_core::Error` (`From<AllocError>` → OutOfMemory).
+                    let _ = global_object.throw_error(err.into(), "failed to allocate statement");
                     return Err(bun_core::err!("JSError"));
                 }
             };
@@ -361,20 +355,17 @@ impl MySQLQuery {
                     let _ = global_object.throw_value(error_response);
                     return Err(bun_core::err!("JSError"));
                 }
-                // Zig: `this.#statement = stmt; stmt.ref();`
                 self.statement = stmt;
                 stmt_ref.ref_();
                 drop(signature);
                 signature = Signature::default();
-                let _ = signature; // matches Zig reassign-to-empty; silences unused.
+                let _ = signature; // silences unused.
             } else {
-                // Zig: `bun.new(MySQLStatement, .{ .ref_count = .initExactRefs(2), ... })`
-                // — one ref for `self.statement`, one for the map entry.
-                // FRU (`..Default::default()`) is illegal for `Drop` types; mutate instead.
-                let mut stmt = Box::new(MySQLStatement::default());
-                stmt.signature = signature;
-                stmt.status = my_sql_statement::Status::Pending;
-                stmt.statement_id = 0;
+                // One ref for `self.statement`, one for the map entry.
+                let mut stmt = Box::new(MySQLStatement::new(
+                    signature,
+                    my_sql_statement::Status::Pending,
+                ));
                 stmt.init_exact_refs(2);
                 let stmt = bun_core::heap::into_raw(stmt);
                 self.statement = stmt;
@@ -403,8 +394,7 @@ impl MySQLQuery {
                 if connection.can_pipeline() {
                     debug!("bindAndExecute");
                     let writer = connection.get_writer();
-                    // Pass the raw `*mut MySQLStatement` separately from `&mut self`
-                    // (matches Zig .zig:183/195 which passes an independent `*MySQLStatement`).
+                    // Pass the raw `*mut MySQLStatement` separately from `&mut self`.
                     if let Err(err) = self.bind_and_execute(
                         writer,
                         stmt,
@@ -470,7 +460,6 @@ impl MySQLQuery {
         columns_value: JSValue,
         binding_value: JSValue,
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         if self.flags.simple() {
             debug!("runSimpleQuery");
             return self.run_simple_query(connection);
@@ -521,14 +510,12 @@ impl MySQLQuery {
     }
 
     pub fn cleanup(&mut self) {
-        // Zig: `if (this.#statement) |s| { s.deref(); this.#statement = null; }`
         if !self.statement.is_null() {
             let s = self.statement;
             self.statement = core::ptr::null_mut();
             // SAFETY: `s` is a live boxed `MySQLStatement` we held one intrusive ref on.
             unsafe { MySQLStatement::deref(s) };
         }
-        // Zig: `var q = this.#query; defer q.deref(); this.#query = .empty;`
         // `BunString` is `Copy` (no `Drop`); assigning `empty()` would NOT deref
         // the old value, so release the +1 from `to_bun_string` explicitly.
         let q = core::mem::replace(&mut self.query, BunString::empty());
@@ -599,11 +586,9 @@ impl MySQLQuery {
     #[allow(clippy::mut_from_ref)] // goes through a raw intrusive pointer; see SAFETY note below
     pub fn get_statement(&self) -> Option<&mut MySQLStatement> {
         // SAFETY: when non-null, `self.statement` is a live boxed `MySQLStatement`
-        // kept alive by the intrusive ref we hold. Returning `&mut` mirrors Zig's
-        // `?*MySQLStatement` (shared mutation through the intrusive pointer); the
+        // kept alive by the intrusive ref we hold. Returning `&mut` permits
+        // shared mutation through the intrusive pointer; the
         // lifetime is bounded by `&self`, which owns one ref.
         unsafe { self.statement.as_mut() }
     }
 }
-
-// ported from: src/sql_jsc/mysql/MySQLQuery.zig
diff --git a/src/sql_jsc/mysql/MySQLRequestQueue.rs b/src/sql_jsc/mysql/MySQLRequestQueue.rs
index 60938fea3ea..a1852d5f214 100644
--- a/src/sql_jsc/mysql/MySQLRequestQueue.rs
+++ b/src/sql_jsc/mysql/MySQLRequestQueue.rs
@@ -7,8 +7,7 @@ use core::cell::Cell;
 use core::ptr::NonNull;
 
 use crate::mysql::js_mysql_query::JSMySQLQuery;
-// PORT NOTE: Zig re-exports `MySQLConnection` from JSMySQLConnection.zig — the
-// queue's "connection" param is the JS-wrapper type (it calls
+// The queue's "connection" param is the JS-wrapper type (it calls
 // `reset_connection_timeout`/`on_error` which live on the wrapper, plus
 // `is_able_to_write` which forwards to the inner protocol struct).
 use crate::mysql::js_mysql_connection::JSMySQLConnection as MySQLConnection;
@@ -68,8 +67,8 @@ impl MySQLRequestQueue {
 
     #[inline]
     pub(crate) fn can_pipeline(&self, connection: &MySQLConnection) -> bool {
-        // TODO(port): env_var feature_flag::get() returns Option<bool> until the
-        // non-nullable defaulted-var get() wrapper is restored (see env_var.rs).
+        // Feature flags are unset by default; `unwrap_or(false)` falls back to the
+        // non-nullable defaulted `get()`.
         if bun_core::env_var::feature_flag::BUN_FEATURE_FLAG_DISABLE_SQL_AUTO_PIPELINING
             .get()
             .unwrap_or(false)
@@ -100,7 +99,7 @@ impl MySQLRequestQueue {
         }
     }
 
-    /// PORT NOTE: takes only `connection` (the embedding `JSMySQLConnection`)
+    /// takes only `connection` (the embedding `JSMySQLConnection`)
     /// as a **raw pointer** and derives the queue backref locally. The queue is
     /// a field of `*connection` — but every `MySQLRequestQueue` field is
     /// interior-mutable (`Cell` / `JsCell`), so a `ParentRef<Self>` (yields
@@ -126,8 +125,8 @@ impl MySQLRequestQueue {
         // momentary `Deref` lifetime. All queue mutation below goes through
         // `Cell`/`JsCell` interior mutability — `&Self` is sufficient.
         let queue_ref: ParentRef<Self> = ParentRef::new(&conn_ref.connection.get().queue);
-        // PORT NOTE: reshaped for borrowck — Zig `defer { while ... }` cleanup
-        // became a post-block pass; early `return`s in the Zig loop become
+        // reshaped for borrowck — the cleanup that must run at function exit
+        // became a post-block pass; early returns become
         // `break 'advance` so cleanup always runs at function exit.
         'advance: {
             let mut offset: usize = 0;
@@ -229,7 +228,6 @@ impl MySQLRequestQueue {
             }
         }
 
-        // Zig: defer { while ... } — runs at function exit.
         while queue_ref.requests.get().readable_length() > 0 {
             let request: *mut JSMySQLQuery = queue_ref.requests.get().peek_item(0);
             // Queue holds a ref on every request (taken in `add()`), so the
@@ -321,15 +319,13 @@ impl MySQLRequestQueue {
         self.pipelined_requests.set(0);
         self.nonpipelinable_requests.set(0);
         self.waiting_to_prepare.set(false);
-        // `requests` drops at scope exit (Zig: defer requests.deinit()).
 
         while let Some(request) = requests.read_item() {
             // Queue held a ref on every request; pointer is non-null and live
             // until `deref()`. R-2: `ParentRef` yields `&T` only — every method
             // body reached below is `&self`.
             let req = ParentRef::from(NonNull::new(request).expect("queue item non-null"));
-            // Zig: defer request.deref() — moved to end of loop body; no early
-            // exits between here and there.
+            // Deref each request at the end of the loop body; no early exits between here and there.
             if !req.is_completed() {
                 if let Some(r) = reason {
                     req.reject_with_js_value(queries_array, r);
@@ -345,9 +341,8 @@ impl MySQLRequestQueue {
 
 impl Drop for MySQLRequestQueue {
     fn drop(&mut self) {
-        // PORT NOTE: reshaped for borrowck — Zig iterates readableSlice(0) while
-        // discard(1)'ing, which in Rust would overlap & / &mut borrows on
-        // self.requests. read_item() peeks+discards in one &mut call.
+        // read_item() peeks+discards in one &mut call so the & / &mut
+        // borrows on self.requests never overlap.
         while let Some(request) = self.requests.with_mut(|q| q.read_item()) {
             // Queue held a ref on every request; pointer is non-null and live
             // until `deref()`. R-2: `ParentRef` yields `&T` only.
@@ -360,8 +355,6 @@ impl Drop for MySQLRequestQueue {
         self.pipelined_requests.set(0);
         self.nonpipelinable_requests.set(0);
         self.waiting_to_prepare.set(false);
-        // self.requests drops automatically (Zig: this.#requests.deinit()).
+        // self.requests drops automatically.
     }
 }
-
-// ported from: src/sql_jsc/mysql/MySQLRequestQueue.zig
diff --git a/src/sql_jsc/mysql/MySQLStatement.rs b/src/sql_jsc/mysql/MySQLStatement.rs
index eee302ae2b6..ea0756d5001 100644
--- a/src/sql_jsc/mysql/MySQLStatement.rs
+++ b/src/sql_jsc/mysql/MySQLStatement.rs
@@ -40,8 +40,9 @@ pub struct MySQLStatement {
     pub result_count: u64,
 }
 
-impl Default for MySQLStatement {
-    fn default() -> Self {
+impl MySQLStatement {
+    /// Callers supply the signature and status; every other field takes its default.
+    pub fn new(signature: Signature, status: Status) -> Self {
         Self {
             cached_structure: CachedStructure::default(),
             ref_count: Cell::new(1),
@@ -50,11 +51,8 @@ impl Default for MySQLStatement {
             params_received: 0,
             columns: Vec::new(),
             columns_received: 0,
-            // TODO(port): Signature has no Zig default; callers must supply it. This Default
-            // impl exists only to mirror Zig's per-field defaults — prefer a `new(signature)`
-            // constructor.
-            signature: Signature::default(),
-            status: Status::Parsing,
+            signature,
+            status,
             error_response: ErrorPacket::default(),
             execution_flags: ExecutionFlags::default(),
             fields_flags: DataCellFlags::default(),
@@ -63,6 +61,12 @@ impl Default for MySQLStatement {
     }
 }
 
+impl Default for MySQLStatement {
+    fn default() -> Self {
+        Self::new(Signature::empty(), Status::Parsing)
+    }
+}
+
 bitflags::bitflags! {
     #[repr(transparent)]
     #[derive(Clone, Copy, PartialEq, Eq)]
@@ -75,13 +79,11 @@ bitflags::bitflags! {
         /// been consumed. This prevents the intermediate EOF from being mistakenly
         /// treated as end-of-result-set.
         const COLUMNS_EOF_RECEIVED = 1 << 3;
-        // _: u4 padding in Zig — unused high bits.
     }
 }
 
 impl Default for ExecutionFlags {
     fn default() -> Self {
-        // Zig: header_received=false, needs_duplicate_check=true, need_to_send_params=true, columns_eof_received=false
         ExecutionFlags::NEEDS_DUPLICATE_CHECK | ExecutionFlags::NEED_TO_SEND_PARAMS
     }
 }
@@ -95,7 +97,7 @@ pub enum Status {
 }
 
 impl MySQLStatement {
-    /// Zig `.ref_count = .initExactRefs(n)` — set the initial intrusive
+    /// Set the initial intrusive
     /// refcount at construction time, before any `ref_()`/`deref()`. The
     /// `ref_count` field is private (refcount invariant), so callers building
     /// a statement with >1 owner (query + connection-map entry) go through
@@ -134,14 +136,13 @@ impl MySQLStatement {
             let field: &mut ColumnDefinition41 = &mut self.columns[remaining];
             match &field.name_or_index {
                 ColumnIdentifier::Name(name) => {
-                    // PORT NOTE: reshaped for borrowck — compute `found_existing` before
+                    // reshaped for borrowck — compute `found_existing` before
                     // mutating `field.name_or_index`.
                     let found_existing = seen_fields
                         .get_or_put(name.slice())
                         .expect("OOM")
                         .found_existing;
                     if found_existing {
-                        // Zig: field.name_or_index.deinit(); — Drop on assignment handles this.
                         field.name_or_index = ColumnIdentifier::Duplicate;
                         flags.insert(DataCellFlags::HAS_DUPLICATE_COLUMNS);
                     }
@@ -168,8 +169,8 @@ impl MySQLStatement {
         self.fields_flags = flags;
     }
 
-    // PORT NOTE: Zig returns `CachedStructure` by value (struct copy). Returning `&CachedStructure`
-    // here to avoid moving out of `self`; callers may need `.clone()` if they require
+    // Returning `&CachedStructure`
+    // to avoid moving out of `self`; callers may need `.clone()` if they require
     // an owned copy.
     pub(crate) fn structure(
         &mut self,
@@ -192,14 +193,5 @@ impl MySQLStatement {
 impl Drop for MySQLStatement {
     fn drop(&mut self) {
         bun_core::scoped_log!(MySQLStatement, "MySQLStatement deinit");
-        // Zig deinit body:
-        //   - per-column deinit + free(columns)  → Vec<ColumnDefinition41> Drop
-        //   - free(params)                       → Vec<Param> Drop
-        //   - cached_structure.deinit()          → field Drop
-        //   - error_response.deinit()            → field Drop
-        //   - signature.deinit()                 → field Drop
-        //   - bun.destroy(this)                  → handled by IntrusiveRc when refcount hits 0
     }
 }
-
-// ported from: src/sql_jsc/mysql/MySQLStatement.zig
diff --git a/src/sql_jsc/mysql/MySQLValue.rs b/src/sql_jsc/mysql/MySQLValue.rs
index 3192a5eaffb..692f5e99adc 100644
--- a/src/sql_jsc/mysql/MySQLValue.rs
+++ b/src/sql_jsc/mysql/MySQLValue.rs
@@ -1,6 +1,6 @@
-//! `Value` union + JSC bridges for MySQL type encoding. Split from
-//! `sql/mysql/MySQLTypes.zig` so the protocol layer keeps the pure
-//! `CharacterSet`/`FieldType` enums without `JSValue` references.
+//! `Value` union + JSC bridges for MySQL type encoding. Kept separate so the
+//! protocol layer keeps the pure `CharacterSet`/`FieldType` enums without
+//! `JSValue` references.
 
 use crate::jsc::{
     IntegerRange, JSGlobalObject, JSGlobalObjectSqlExt as _, JSType, JSValue, JsError, JsResult,
@@ -181,8 +181,7 @@ impl Drop for Bytes {
     }
 }
 
-// Value's Zig `deinit` only forwarded to payload deinit; Rust auto-drops enum
-// payloads (ZigStringSlice, Bytes, Data all impl Drop), so no explicit Drop.
+// No explicit Drop for Value: the enum payloads (ZigStringSlice, Bytes, Data) all impl Drop.
 
 impl Value {
     pub fn to_data(&self, field_type: FieldType) -> Result<Data, any_mysql_error::Error> {
@@ -234,10 +233,10 @@ impl Value {
             }
             // Value::Decimal(dec) => return dec.to_binary(field_type),
             Value::StringData(data) | Value::BytesData(data) => {
-                // TODO(port): Zig returned `data` by value (copy of Data union);
-                // `bun_sql::shared::Data` is not `Clone` in the Rust port, so
-                // return a `Temporary` aliasing the same bytes. `to_data` callers
-                // must keep `self` alive until the returned `Data` is consumed.
+                // `bun_sql::shared::Data` is not
+                // `Clone`, so return a `Temporary` aliasing the
+                // same bytes. INVARIANT: `to_data` callers must keep `self`
+                // alive until the returned `Data` is consumed.
                 let s = data.slice();
                 return Ok(if s.is_empty() {
                     Data::Empty
@@ -495,7 +494,6 @@ pub struct DateTime {
 
 impl DateTime {
     pub fn from_data(data: &Data) -> Result<DateTime, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Self::from_binary(data.slice()))
     }
 
@@ -559,7 +557,6 @@ impl DateTime {
                 }
             }
             _ => panic!("Invalid datetime length: {}", val.len()),
-            // TODO(port): Zig used bun.Output.panic; confirm bun_core panic helper
         }
     }
 
@@ -684,7 +681,6 @@ impl DateTime {
     }
 
     pub fn to_js(self, global_object: &JSGlobalObject) -> JSValue {
-        // TODO(port): Zig calls toJSTimestamp() with no args here but the fn takes globalObject and is fallible; preserved bug
         JSValue::from_date_number(
             global_object,
             self.to_js_timestamp(global_object).unwrap_or(f64::NAN),
@@ -711,7 +707,6 @@ impl DateTime {
         value: JSValue,
         global_object: &JSGlobalObject,
     ) -> Result<DateTime, any_mysql_error::Error> {
-        // TODO(port): narrow error set
         if value.is_date() {
             // this is actually ms not seconds
             let total_ms = value.get_unix_timestamp();
@@ -763,7 +758,6 @@ impl Time {
         value: JSValue,
         global_object: &JSGlobalObject,
     ) -> Result<Time, any_mysql_error::Error> {
-        // TODO(port): narrow error set
         if value.is_date() {
             let total_ms = value.get_unix_timestamp();
             let ts: i64 = (total_ms / 1000.0).floor() as i64;
@@ -808,7 +802,6 @@ impl Time {
     }
 
     pub fn from_data(data: &Data) -> Result<Time, bun_core::Error> {
-        // TODO(port): narrow error set
         Ok(Self::from_binary(data.slice()))
     }
 
@@ -884,7 +877,6 @@ pub struct Decimal {
 
 impl Decimal {
     pub fn to_js(&self, global_object: &JSGlobalObject) -> JSValue {
-        // PERF(port): was stack-fallback (std.heap.stackFallback(64, ...)) — profile if it shows up on a hot path.
         let mut str: Vec<u8> = Vec::new();
 
         if self.negative {
@@ -903,10 +895,8 @@ impl Decimal {
     }
 
     pub fn to_binary(&self, _field_type: FieldType) -> Result<Data, bun_core::Error> {
-        // Zig: `bun.todoPanic(@src(), "Decimal.toBinary not implemented", .{});`
-        // Intentional shipped runtime "feature not yet implemented" — not a
-        // porting placeholder. The `Decimal` arm of `Value` is commented out,
-        // so this is unreachable today.
+        // Intentional runtime "feature not yet implemented". The `Decimal` arm
+        // of `Value` is commented out, so this is unreachable today.
         bun_core::todo_panic!("Decimal.toBinary not implemented")
     }
 
@@ -961,7 +951,6 @@ fn gregorian_date(days: i32) -> Date {
     }
 }
 
-// TODO(port): move to sql_jsc_sys (or bun_jsc_sys)
 unsafe extern "C" {
     /// By-value `JSValue`; C++ side null-checks and reads its own heap state.
     /// No caller-side preconditions → `safe fn`.
@@ -976,5 +965,3 @@ unsafe extern "C" {
         out_len: &mut usize,
     ) -> i32;
 }
-
-// ported from: src/sql_jsc/mysql/MySQLValue.zig
diff --git a/src/sql_jsc/mysql/protocol/DecodeBinaryValue.rs b/src/sql_jsc/mysql/protocol/DecodeBinaryValue.rs
index fe0cf0addf2..3d1a04e466c 100644
--- a/src/sql_jsc/mysql/protocol/DecodeBinaryValue.rs
+++ b/src/sql_jsc/mysql/protocol/DecodeBinaryValue.rs
@@ -13,7 +13,6 @@ bun_core::declare_scope!(MySQLDecodeBinaryValue, visible);
 /// with binary collations (e.g., utf8mb4_bin) which have different character_set values.
 pub(crate) const BINARY_CHARSET: u16 = 63;
 
-// TODO(port): narrow error set
 pub fn decode_binary_value<Context: ReaderContext>(
     global_object: &JSGlobalObject,
     field_type: types::FieldType,
@@ -278,7 +277,7 @@ pub fn decode_binary_value<Context: ReaderContext>(
                         let remaining = w.len();
                         break 'brk &buffer[..32 - remaining];
                     };
-                    // PORT NOTE: reshaped for borrowck — compute remaining before re-borrowing buffer
+                    // reshaped for borrowck — compute remaining before re-borrowing buffer
                     Ok(SQLDataCell {
                         tag: CellTag::String,
                         value: CellValue {
@@ -309,7 +308,7 @@ pub fn decode_binary_value<Context: ReaderContext>(
             l @ (11 | 7 | 4) => {
                 let data = reader.read(l as usize)?;
                 let time = DateTime::from_data(&data)?;
-                // PORT NOTE: Zig's `!SQLDataCell` is anyerror; map JsError variants to their
+                // Map JsError variants to their
                 // interned bun_core::Error names so `?` can widen here.
                 let ts = time.to_js_timestamp(global_object).map_err(|e| match e {
                     bun_jsc::JsError::OutOfMemory => bun_core::err!("OutOfMemory"),
@@ -436,11 +435,8 @@ pub fn decode_binary_value<Context: ReaderContext>(
     }
 }
 
-// Zig accesses `bun.String.cloneUTF8(slice).value.WTFStringImpl` directly (union field);
-// `leak_wtf_impl()` is the Rust equivalent — transfers the +1 ref to the cell (`free_value = 1`).
+// `leak_wtf_impl()` transfers the +1 ref to the cell (`free_value = 1`).
 #[inline]
 fn clone_utf8_wtf_impl(slice: &[u8]) -> bun_core::WTFStringImpl {
     bun_core::String::clone_utf8(slice).leak_wtf_impl()
 }
-
-// ported from: src/sql_jsc/mysql/protocol/DecodeBinaryValue.zig
diff --git a/src/sql_jsc/mysql/protocol/ResultSet.rs b/src/sql_jsc/mysql/protocol/ResultSet.rs
index 6fcb599ceae..effb6fd8897 100644
--- a/src/sql_jsc/mysql/protocol/ResultSet.rs
+++ b/src/sql_jsc/mysql/protocol/ResultSet.rs
@@ -41,7 +41,7 @@ impl<'a> Row<'a> {
         structure: JSValue,
         flags: SQLDataCellFlags,
         result_mode: SQLQueryResultMode,
-        // PORT NOTE: Zig `?CachedStructure` is by-value; passed by ref here because CachedStructure is non-Copy (owns Strong + Box).
+        // Passed by ref because CachedStructure is non-Copy (owns Strong + Box).
         cached_structure: Option<&CachedStructure>,
     ) -> crate::jsc::JsResult<JSValue> {
         let mut names: *mut ExternColumnIdentifier = ptr::null_mut();
@@ -144,7 +144,7 @@ impl<'a> Row<'a> {
                         ..SQLDataCell::default()
                     };
                 } else {
-                    // std.math.minInt(i24) == -8_388_608
+                    // -8_388_608 is the minimum value of a signed 24-bit int
                     let val: i32 = parse_int::<i32>(value.slice(), 10).unwrap_or(-8_388_608);
                     *cell = SQLDataCell {
                         tag: Tag::Int4,
@@ -441,7 +441,7 @@ impl<'a> Row<'a> {
         Ok(())
     }
 
-    // Zig `decoderWrap(@This(), ...)` — see Decode trait in src/sql/mysql/protocol/NewReader.rs
+    // See Decode trait in src/sql/mysql/protocol/NewReader.rs
     pub(crate) fn decode<Context: ReaderContext>(
         &mut self,
         reader: NewReader<Context>,
@@ -453,7 +453,9 @@ impl<'a> Row<'a> {
 impl<'a> Drop for Row<'a> {
     fn drop(&mut self) {
         for value in self.values.iter_mut() {
-            // TODO(port): if SQLDataCell gains `impl Drop`, delete this loop and the Drop impl entirely.
+            // SQLDataCell deliberately has no `impl Drop` — it is an FFI struct
+            // whose ownership is normally transferred to C++ — so the cells
+            // still owned by this row must be freed manually here.
             value.deinit();
         }
         // self.columns is intentionally left out.
@@ -464,8 +466,7 @@ impl<'a> Drop for Row<'a> {
 
 #[inline]
 fn clone_wtf_string_or_null(slice: &[u8]) -> bun_core::WTFStringImpl {
-    // Zig: `bun.String.cloneUTF8(slice).value.WTFStringImpl` — extracts the raw
-    // WTFStringImpl* from a freshly-cloned bun.String (ownership transferred to the cell,
+    // Extracts the raw WTFStringImpl* from a freshly-cloned string (ownership transferred to the cell,
     // freed via `free_value = 1`).
     if !slice.is_empty() {
         BunString::clone_utf8(slice).leak_wtf_impl()
@@ -473,5 +474,3 @@ fn clone_wtf_string_or_null(slice: &[u8]) -> bun_core::WTFStringImpl {
         ptr::null_mut()
     }
 }
-
-// ported from: src/sql_jsc/mysql/protocol/ResultSet.zig
diff --git a/src/sql_jsc/mysql/protocol/Signature.rs b/src/sql_jsc/mysql/protocol/Signature.rs
index 4a201300e0e..0b2a032bffa 100644
--- a/src/sql_jsc/mysql/protocol/Signature.rs
+++ b/src/sql_jsc/mysql/protocol/Signature.rs
@@ -25,30 +25,24 @@ impl Signature {
     pub fn hash(&self) -> u64 {
         // Hash `name` followed by each param's `(type, flags)` field-by-field.
         //
-        // This intentionally does NOT reinterpret `&[Param]` as `&[u8]` (the Zig
-        // port originally mirrored `std.mem.sliceAsBytes`): `Param` has default
+        // This intentionally does NOT reinterpret `&[Param]` as `&[u8]`:
+        // `Param` has default
         // `repr(Rust)` with a `u8` enum + `u16` bitflags, leaving one padding
         // byte. Exposing padding through `&[u8]` reads uninitialized memory and
         // is UB. The hash is a process-local prepared-statement cache key, so it
-        // only needs to be self-consistent — byte-for-byte layout parity with Zig
-        // is not required.
+        // only needs to be self-consistent.
         //
-        // PERF(port): Zig fed two slices into a streaming Wyhash; bun_wyhash
-        // currently lacks the std-compatible streaming `Wyhash` type. Concatenate
-        // into a temp Vec until that lands.
-        // TODO(port): bun_wyhash::Wyhash (streaming std-compatible API)
-        const BYTES_PER_PARAM: usize = 1 /* FieldType */ + 2 /* ColumnFlags */;
-        let mut buf: Vec<u8> =
-            Vec::with_capacity(self.name.len() + self.fields.len() * BYTES_PER_PARAM);
-        buf.extend_from_slice(&self.name);
+        // Stream the bytes (minus padding, see above) through `bun_wyhash::Wyhash`.
+        let mut hasher = bun_wyhash::Wyhash::init(0);
+        hasher.update(&self.name);
         for p in self.fields.iter() {
-            buf.push(p.r#type as u8);
-            buf.extend_from_slice(&p.flags.to_int().to_ne_bytes());
+            hasher.update(&[p.r#type as u8]);
+            hasher.update(&p.flags.to_int().to_ne_bytes());
         }
-        bun_wyhash::hash(&buf)
+        hasher.final_()
     }
 
-    // TODO(port): narrow error set (mixes JS errors, alloc, and InvalidQueryBinding)
+    // Errors are collapsed into the crate-wide `bun_core::Error` currency.
     pub fn generate(
         global_object: &JSGlobalObject,
         query: &[u8],
@@ -61,7 +55,6 @@ impl Signature {
         let mut fields: Vec<Param> = Vec::new();
         let mut name: Vec<u8> = Vec::with_capacity(query.len());
 
-        // PERF(port): was appendSliceAssumeCapacity — profile if it shows up on a hot path.
         name.extend_from_slice(query);
 
         // errdefer { fields.deinit(); name.deinit(); } — deleted: `Vec` drops on `?`.
@@ -84,11 +77,6 @@ impl Signature {
                 crate::mysql::my_sql_value::field_type_from_js(global_object, value, &mut unsigned)
                     .map_err(js_error_to_mysql)?;
             if unsigned {
-                // 128 is more than enought right now
-                // PORT NOTE: reshaped — Zig used `std.fmt.bufPrint` into a 128-byte
-                // stack buffer with a `catch @tagName(tag)` fallback on overflow.
-                // "U" + tag name can never exceed 128 bytes, so a direct append is
-                // equivalent and avoids the intermediate buffer.
                 name.push(b'U');
                 name.extend_from_slice(<&'static str>::from(tag).as_bytes());
             } else {
@@ -116,5 +104,3 @@ impl Signature {
         })
     }
 }
-
-// ported from: src/sql_jsc/mysql/protocol/Signature.zig
diff --git a/src/sql_jsc/mysql/protocol/any_mysql_error_jsc.rs b/src/sql_jsc/mysql/protocol/any_mysql_error_jsc.rs
index 0b9743668b6..c3189637b6f 100644
--- a/src/sql_jsc/mysql/protocol/any_mysql_error_jsc.rs
+++ b/src/sql_jsc/mysql/protocol/any_mysql_error_jsc.rs
@@ -5,9 +5,8 @@ use bun_sql::mysql::protocol::error_packet::MySQLErrorOptions;
 use super::error_packet_jsc::create_mysql_error;
 
 /// Coerces the assorted error types callers thread through (`AnyMySQLError`
-/// enum or the interned `bun_core::Error`) into the Zig-style error *name*
-/// that the match below keys on. In Zig both are the same `error.Foo` value;
-/// in Rust we bridge them via name string.
+/// enum or the interned `bun_core::Error`) into the error *name*
+/// that the match below keys on.
 pub(crate) trait IntoAnyMySQLError: Copy {
     fn mysql_error_name(self) -> &'static str;
 }
@@ -26,7 +25,7 @@ impl IntoAnyMySQLError for bun_core::Error {
     }
 }
 
-/// Zig `?[]const u8`. Callers pass either a bare byte-ish value (`&str`,
+/// Callers pass either a bare byte-ish value (`&str`,
 /// `&[u8]`, `&[u8; N]`, `&Vec<u8>`) or the same wrapped in `Option<_>`, so
 /// this trait — rather than `AsRef<[u8]>` directly — lets one signature
 /// accept both shapes without touching every callsite.
@@ -78,7 +77,7 @@ impl<T: MaybeBytes> MaybeBytes for Option<T> {
 
 pub(crate) fn mysql_error_to_js(
     global_object: &JSGlobalObject,
-    // Zig: `?[]const u8` — `message orelse @errorName(err)`.
+    // Falls back to the error name when no message is given.
     message: impl MaybeBytes,
     err: impl IntoAnyMySQLError,
 ) -> JSValue {
@@ -143,5 +142,3 @@ pub(crate) fn mysql_error_to_js(
     )
     .unwrap_or_else(|ex| global_object.take_exception(ex))
 }
-
-// ported from: src/sql_jsc/mysql/protocol/any_mysql_error_jsc.zig
diff --git a/src/sql_jsc/mysql/protocol/error_packet_jsc.rs b/src/sql_jsc/mysql/protocol/error_packet_jsc.rs
index 3a66f4b2ad5..d87f8cafb5e 100644
--- a/src/sql_jsc/mysql/protocol/error_packet_jsc.rs
+++ b/src/sql_jsc/mysql/protocol/error_packet_jsc.rs
@@ -56,5 +56,3 @@ impl ErrorPacketJsc for ErrorPacket {
         .unwrap_or_else(|err| global.take_exception(err))
     }
 }
-
-// ported from: src/sql_jsc/mysql/protocol/error_packet_jsc.zig
diff --git a/src/sql_jsc/postgres.rs b/src/sql_jsc/postgres.rs
index 6b8dcdc4d09..b3ef8eec805 100644
--- a/src/sql_jsc/postgres.rs
+++ b/src/sql_jsc/postgres.rs
@@ -19,8 +19,7 @@ pub fn create_binding(global_object: &JSGlobalObject) -> JSValue {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Submodule tree (files use PascalCase basenames, mirroring the Zig sources;
-// wired via `#[path]`).
+// Submodule tree (files use PascalCase basenames; wired via `#[path]`).
 // ──────────────────────────────────────────────────────────────────────────
 
 #[path = "postgres/SASL.rs"]
@@ -91,8 +90,6 @@ pub mod protocol {
     pub mod notice_response_jsc;
 }
 
-// Re-exports of base-crate protocol/types modules (Zig: thin re-exports).
+// Re-exports of base-crate protocol/types modules.
 pub use bun_sql::postgres::postgres_protocol as base_protocol;
 pub use bun_sql::postgres::postgres_types as base_types;
-
-// ported from: src/sql_jsc/postgres.zig
diff --git a/src/sql_jsc/postgres/AuthenticationState.rs b/src/sql_jsc/postgres/AuthenticationState.rs
index 2e62ca856bb..b4078366fd4 100644
--- a/src/sql_jsc/postgres/AuthenticationState.rs
+++ b/src/sql_jsc/postgres/AuthenticationState.rs
@@ -10,11 +10,8 @@ pub enum AuthenticationState {
 
 impl AuthenticationState {
     pub fn zero(&mut self) {
-        // PORT NOTE: Zig explicitly called sasl.deinit() before reassigning;
-        // in Rust, assigning into *self drops the previous variant (and thus
-        // SASL's Drop impl) automatically.
+        // Assigning into *self drops the previous variant (and thus SASL's
+        // Drop impl) automatically; no explicit deinit is needed.
         *self = AuthenticationState::None;
     }
 }
-
-// ported from: src/sql_jsc/postgres/AuthenticationState.zig
diff --git a/src/sql_jsc/postgres/DataCell.rs b/src/sql_jsc/postgres/DataCell.rs
index 71ab83e6706..054410695bd 100644
--- a/src/sql_jsc/postgres/DataCell.rs
+++ b/src/sql_jsc/postgres/DataCell.rs
@@ -1,5 +1,3 @@
-//! Port of src/sql_jsc/postgres/DataCell.zig
-
 use core::mem::size_of;
 
 use crate::jsc::{JSGlobalObject, JSValue};
@@ -14,14 +12,12 @@ use bun_sql::shared::data::Data;
 use bun_sql::shared::sql_query_result_mode::SQLQueryResultMode as PostgresSQLQueryResultMode;
 
 pub use crate::shared::sql_data_cell::SQLDataCell;
-// Zig nested-type style (`SQLDataCell.Tag.Bytea`) → flat re-exports; see sed
-// rewrite below replacing `SQLDataCell::X` with bare `X`.
 pub use crate::shared::sql_data_cell::{Array, Flags, Raw, Tag, TypedArray, Value};
 use bun_sql::shared::column_identifier::ColumnIdentifier;
 
-// TODO(port): narrow error set — Zig used inferred error sets that flow into
-// AnyPostgresError. Confirm AnyPostgresError covers all variants referenced
-// via `err!(...)` here.
+// Errors here collapse into
+// `AnyPostgresError` (names not in that enum — e.g. `err!("BufferTooSmall")` —
+// fall back to `JSError` via the name-based `From<bun_core::Error>` impl).
 type Result<T, E = AnyPostgresError> = core::result::Result<T, E>;
 
 bun_core::declare_scope!(Postgres, visible);
@@ -106,8 +102,7 @@ fn try_slice(slice: &[u8], count: usize) -> &[u8] {
 
 const MAX_ARRAY_NESTING_DEPTH: usize = 100;
 
-// PERF(port): `array_type` and `is_json_sub_array` were `comptime` in Zig (per-variant
-// monomorphization). Demoted to runtime here because they are only used in value
+// PERF: `array_type` and `is_json_sub_array` are only used in value
 // position (branch selectors), never type position. Profile if it shows up on a hot path.
 fn parse_array(
     bytes: &[u8],
@@ -522,7 +517,7 @@ fn parse_array(
                             let mut has_exponent = false;
                             let mut has_negative_sign = false;
                             let mut has_positive_sign = false;
-                            // PORT NOTE: reshaped for borrowck — Zig mutates `slice` mid-loop while
+                            // reshaped for borrowck — cannot mutate `slice` mid-loop while
                             // iterating it (the Infinity arm). We capture the advance amount and
                             // apply after the loop.
                             let mut advance_after: Option<usize> = None;
@@ -677,7 +672,6 @@ fn parse_array(
                                     array.push(SQLDataCell {
                                         tag: Tag::Int4,
                                         value: Value {
-                                            // @intCast(value) — i32 → i32, identity here
                                             int4: value,
                                         },
                                         ..Default::default()
@@ -739,9 +733,7 @@ fn parse_array(
 }
 
 // Helper: typed-array binary path shared by .int4_array / .float4_array.
-// PORT NOTE: Zig used `inline ... => |tag|` to capture the comptime tag and call
-// `tag.toJSTypedArrayType()` / `tag.byteArrayType()` / `tag.pgArrayType()` in type
-// position. Those return types, so we monomorphize over the element type here.
+// Monomorphized over the element type.
 fn from_bytes_typed_array<Elem: bun_sql::postgres::types::tag::WireByteSwap>(
     tag: types::Tag,
     bytes: &[u8],
@@ -805,9 +797,9 @@ fn from_bytes_typed_array<Elem: bun_sql::postgres::types::tag::WireByteSwap>(
         return Err(AnyPostgresError::InvalidBinaryData);
     }
 
-    // Zig: `tag.pgArrayType().init(bytes).slice()` byte-swaps the wire
-    // header and elements in place inside the recv buffer. The Rust port
-    // cannot soundly mutate through a pointer derived from `bytes: &[u8]`
+    // In-place byte-swapping of the wire header and elements inside the
+    // recv buffer is unsound here: we
+    // cannot mutate through a pointer derived from `bytes: &[u8]`
     // — the `readonly` LLVM parameter attribute lets the optimizer elide
     // those writes, which in the release-asan build left the header `len`
     // un-byte-swapped (3 → 0x03000000) and produced a 192MB OOB memcpy in
@@ -823,7 +815,6 @@ fn from_bytes_typed_array<Elem: bun_sql::postgres::types::tag::WireByteSwap>(
         for i in 0..array_len {
             // Wire layout per element for the 4-byte types this path
             // supports (int4/float4): [elem_size length prefix][elem_size value]
-            // — same stride `slice()` walks in the Zig spec.
             let src_off = 20 + i * element_stride + (element_stride - elem_size);
             // `bytes.len() >= 20 + array_len*element_stride` was validated
             // above; `out` has `array_len*elem_size` bytes. The trait's
@@ -981,7 +972,6 @@ pub(crate) fn from_bytes(
         T::numeric => {
             if binary {
                 // this is probrably good enough for most cases
-                // PERF(port): was stack-fallback (1024-byte stackFallback allocator)
                 let mut numeric_buffer: Vec<u8> = Vec::new();
 
                 // if is binary format lets display as a string because JS cant handle it in a safe way
@@ -1168,8 +1158,7 @@ pub(crate) fn from_bytes(
             }
         }
         // text array types
-        // PERF(port): was `inline` switch — each tag was a comptime arg to parseArray.
-        // Demoted to runtime; see parse_array note.
+        // The tag is passed to parse_array at runtime; see parse_array note.
         tag @ (T::bpchar_array
         | T::varchar_array
         | T::char_array
@@ -1239,9 +1228,7 @@ pub(crate) fn from_bytes(
 // #define pg_ntoh32(x)        (x)
 // #define pg_ntoh64(x)        (x)
 
-// PORT NOTE: Zig's pg_ntoT used @typeInfo to accept either an array or an int and
-// recurse through @bitCast. All call sites pass a uN already, so we drop the
-// reflection and provide direct byte-swap helpers.
+// Direct byte-swap helpers.
 #[inline]
 fn pg_ntoh16(x: u16) -> u16 {
     x.swap_bytes()
@@ -1274,7 +1261,7 @@ fn parse_binary_numeric<'a>(
     if input.len() < 8 {
         return Err(err!("InvalidBuffer"));
     }
-    // PORT NOTE: std.io.fixedBufferStream → manual cursor over &[u8]
+    // Manual cursor over &[u8].
     let mut cursor = input;
     macro_rules! read_be {
         ($ty:ty) => {{
@@ -1325,7 +1312,7 @@ fn parse_binary_numeric<'a>(
     if decimal_pos <= 0 {
         decimal_pos = 1;
     }
-    let _ = decimal_pos; // matches Zig: computed but unused below
+    let _ = decimal_pos; // computed but unused below
     // Output all digits before the decimal point
 
     if weight < 0 {
@@ -1335,7 +1322,7 @@ fn parse_binary_numeric<'a>(
         let mut first_non_zero = false;
 
         while idx <= weight as usize {
-            // PORT NOTE: Zig peer-type-widened `idx < ndigits`; compare in i32 to avoid usize→i16 truncation.
+            // Compare in i32 to avoid usize→i16 truncation.
             let digit: u16 = if i32::try_from(idx).expect("int cast") < i32::from(ndigits) {
                 read_be!(u16)
             } else {
@@ -1394,13 +1381,11 @@ fn parse_binary_numeric<'a>(
             result.truncate(end);
         }
     }
-    // PORT NOTE: reshaped for borrowck — return borrowed slice of `result`
+    // reshaped for borrowck — return borrowed slice of `result`
     Ok(PGNummericString::Dynamic(result.as_slice()))
 }
 
-// PORT NOTE: Zig's `parseBinary(comptime tag, comptime ReturnType, bytes)` returns a
-// type that varies per arm. Rust cannot express that as a single fn without an output
-// trait, so it is split per-tag. Call sites in this file are updated.
+// The binary-parse return type varies per tag, so it is split into per-tag fns.
 pub fn parse_binary_float8(bytes: &[u8]) -> Result<f64, AnyPostgresError> {
     Ok(f64::from_bits(parse_binary_int8(bytes)? as u64))
 }
@@ -1590,7 +1575,6 @@ impl<'a> Putter<'a> {
 }
 
 // External C++ formatting functions
-// TODO(port): move to <area>_sys
 unsafe extern "C" {
     // `&mut [u8; N]` is ABI-identical to `*mut u8` (thin pointer to a `Sized`
     // array == pointer to its first element); the reference type discharges the
@@ -1609,5 +1593,3 @@ unsafe extern "C" {
         buffer_size: usize,
     ) -> usize;
 }
-
-// ported from: src/sql_jsc/postgres/DataCell.zig
diff --git a/src/sql_jsc/postgres/PostgresRequest.rs b/src/sql_jsc/postgres/PostgresRequest.rs
index f62e966b4c1..a6960d01d30 100644
--- a/src/sql_jsc/postgres/PostgresRequest.rs
+++ b/src/sql_jsc/postgres/PostgresRequest.rs
@@ -16,10 +16,9 @@ use crate::shared::QueryBindingIterator;
 
 bun_core::declare_scope!(Postgres, visible);
 
-/// Zig: `comptime MessageType: @Type(.enum_literal)` — the set of backend
-/// message tags `PostgresSQLConnection.on()` dispatches over. Defined here
+/// The set of backend message tags `PostgresSQLConnection.on()` dispatches over. Defined here
 /// (the dispatch site) rather than in `bun_sql::postgres::protocol` because
-/// it is purely a compile-time switch tag in Zig with no wire encoding.
+/// it is purely a dispatch tag with no wire encoding.
 #[derive(Clone, Copy, PartialEq, Eq, Debug, strum::IntoStaticStr)]
 pub enum MessageType {
     DataRow,
@@ -62,8 +61,7 @@ pub fn write_bind<Context: WriterContext>(
     writer.write(b"B")?;
     let length = writer.length()?;
 
-    // Zig `.String` (bun.String) vs `.string` ([]const u8) both snake_case to
-    // `string`; the bun.String overload is `bun_string` on NewWriter.
+    // The bun.String overload is `bun_string` on NewWriter.
     writer.bun_string(&cursor_name)?;
     writer.string(name)?;
 
@@ -519,5 +517,3 @@ pub(crate) type Queue = bun_collections::linear_fifo::LinearFifo<
 >;
 
 use crate::postgres::postgres_sql_connection::{SslMode, TlsStatus};
-
-// ported from: src/sql_jsc/postgres/PostgresRequest.zig
diff --git a/src/sql_jsc/postgres/PostgresSQLConnection.rs b/src/sql_jsc/postgres/PostgresSQLConnection.rs
index 87cab2555b1..b41ab1dfeb6 100644
--- a/src/sql_jsc/postgres/PostgresSQLConnection.rs
+++ b/src/sql_jsc/postgres/PostgresSQLConnection.rs
@@ -11,7 +11,7 @@ use crate::jsc::{
     JsResult, VirtualMachine, VirtualMachineSqlExt as _,
 };
 use bun_boringssl as BoringSSL;
-use bun_collections::{HashMap, OffsetByteList, StringMap};
+use bun_collections::{HashMap, IdentityContext, OffsetByteList, StringMap};
 use bun_core::strings;
 use bun_core::{self};
 use bun_io::KeepAlive;
@@ -42,7 +42,7 @@ use bun_sql::shared::ConnectionFlags;
 use bun_sql::shared::Data;
 use bun_sql::shared::SQLQueryResultMode;
 
-// Aliases for PostgresRequest's `on_data` dispatch (Zig used PascalCase nested types).
+// Aliases for PostgresRequest's `on_data` dispatch.
 pub use bun_sql::postgres::SSLMode as SslMode;
 pub use bun_sql::postgres::TLSStatus as TlsStatus;
 
@@ -52,8 +52,8 @@ bun_core::define_scoped_log!(debug, Postgres, visible);
 
 const MAX_PIPELINE_SIZE: usize = u16::MAX as usize; // about 64KB per connection
 
-// TODO(port): PreparedStatementsMap uses IdentityContext(u64) (key is already a hash) at 80% load.
-type PreparedStatementsMap = HashMap<u64, *mut PostgresSQLStatement>;
+// Keys are already wyhash values, so identity hash avoids re-hashing.
+type PreparedStatementsMap = HashMap<u64, *mut PostgresSQLStatement, IdentityContext<u64>>;
 
 pub mod js {
     pub use crate::jsc::codegen::JSPostgresSQLConnection::*;
@@ -425,7 +425,7 @@ impl PostgresSQLConnection {
         // not `*self` — and stays live across the field reads below.
         let tls_group: &mut bun_uws::SocketGroup = self.vm_mut().postgres_socket_group::<true>();
 
-        // Zig: `this.socket.SocketTCP.socket.connected` — at this point we are
+        // At this point we are
         // a plain TCP socket in the Connected state.
         let Socket::SocketTcp(tcp) = self.socket.get() else {
             self.fail(
@@ -443,7 +443,7 @@ impl PostgresSQLConnection {
         };
 
         // SAFETY: `secure` is set to a live `SSL_CTX*` before `setup_tls` is
-        // reached (Zig: `this.secure.?`).
+        // reached.
         let ssl_ctx = unsafe {
             &mut *self
                 .secure
@@ -457,8 +457,8 @@ impl PostgresSQLConnection {
             // `tls_config` for the connection lifetime.
             Some(unsafe { bun_core::ffi::cstr(server_name) })
         };
-        // Zig: `@sizeOf(?*PostgresSQLConnection)` — `?*T` is an 8-byte null-niche
-        // optional. The Rust layout-equivalent is `Option<NonNull<T>>`; using
+        // The ext slot is an 8-byte null-niche
+        // optional pointer, `Option<NonNull<T>>`; using
         // `Option<*mut T>` here would request 16 bytes (separate discriminant)
         // and desync with the trampoline reader (uws_handlers.rs) which reads
         // the slot as `Option<NonNull<_>>`.
@@ -485,7 +485,7 @@ impl PostgresSQLConnection {
         // SAFETY: `new_socket` is a live us_socket_t freshly returned by
         // `adopt_tls`; ext slot is sized for `Option<NonNull<PostgresSQLConnection>>`
         // above. One `&mut` reborrow drives both safe inherent methods
-        // (`ext` / `start_tls_handshake`). Zig: `ext(?*PostgresSQLConnection).* = this`.
+        // (`ext` / `start_tls_handshake`).
         let sock = unsafe { &mut *new_socket };
         *sock.ext::<Option<core::ptr::NonNull<PostgresSQLConnection>>>() =
             core::ptr::NonNull::new(self.as_ctx_ptr());
@@ -617,7 +617,7 @@ impl PostgresSQLConnection {
         if self.status.get() == status {
             return;
         }
-        // PORT NOTE: reshaped for borrowck — `defer this.updateHasPendingActivity()` moved to explicit calls below.
+        // reshaped for borrowck — `defer this.updateHasPendingActivity()` moved to explicit calls below.
 
         self.status.set(status);
         self.reset_connection_timeout();
@@ -690,8 +690,8 @@ impl PostgresSQLConnection {
     }
 
     pub fn fail_with_js_value(&self, value: JSValue) {
-        // PORT NOTE: reshaped for borrowck — Zig used `defer this.updateHasPendingActivity()` +
-        // `defer this.refAndClose(value)`; expanded inline at each return below.
+        // reshaped for borrowck — `update_has_pending_activity()` + `ref_and_close(value)`
+        // are expanded inline at each return below.
         self.stop_timers();
         if self.status.get() == Status::Failed {
             self.update_has_pending_activity();
@@ -728,7 +728,6 @@ impl PostgresSQLConnection {
     }
 
     pub fn fail_fmt(&self, code: &[u8], args: core::fmt::Arguments<'_>) {
-        // PORT NOTE: Zig used `comptime fmt: [:0]const u8, args: anytype` → collapsed to fmt::Arguments.
         let mut message: Vec<u8> = Vec::new();
         use std::io::Write as _;
         let _ = write!(&mut message, "{}", args);
@@ -795,14 +794,11 @@ impl PostgresSQLConnection {
             options: Data::Temporary(self.options),
         };
         if let Err(err) = msg.write_internal(self.writer()) {
-            self.fail(
-                b"Failed to write startup message",
-                AnyPostgresError::from(err),
-            );
+            self.fail(b"Failed to write startup message", err);
         }
     }
 
-    // PORT NOTE: Zig passed `socket` by value; both call sites have already
+    // Both call sites have already
     // stored it into `self.socket`, so dispatch through `self.socket.get()` instead
     // (avoids moving the non-`Copy` `AnySocket` enum out of `self`).
     fn start_tls(&self) {
@@ -948,7 +944,6 @@ impl PostgresSQLConnection {
         self.update_flags(|f| f.insert(ConnectionFlags::IS_PROCESSING_DATA));
 
         self.disable_connection_timeout();
-        // PORT NOTE: Zig `defer { ... }` block expanded after the body below.
 
         let event_loop = self.event_loop();
         event_loop.enter();
@@ -982,9 +977,7 @@ impl PostgresSQLConnection {
                                 .expect("failed to write to read buffer");
                         });
                     } else {
-                        {
-                            let _ = err; /* TODO(port): bun_crash_handler::handle_error_return_trace */
-                        };
+                        bun_core::handle_error_return_trace(err);
                         self.fail(b"Failed to read data", err);
                     }
                 }
@@ -1006,9 +999,7 @@ impl PostgresSQLConnection {
                 }
                 Err(err) => {
                     if err != AnyPostgresError::ShortRead {
-                        {
-                            let _ = err; /* TODO(port): bun_crash_handler::handle_error_return_trace */
-                        };
+                        bun_core::handle_error_return_trace(err);
                         self.fail(b"Failed to read data", err);
                     } else {
                         #[cfg(debug_assertions)]
@@ -1057,26 +1048,8 @@ impl PostgresSQLConnection {
     }
 }
 
-// comptime { @export(&jsc.toJSHostFn(call), .{ .name = "PostgresSQLConnection__createInstance" }) }
-// TODO(port): the #[crate::jsc::host_fn] attribute on `call` should emit the correct
-// `#[unsafe(no_mangle)]` shim named `PostgresSQLConnection__createInstance`.
-bun_jsc::jsc_host_abi! {
-    #[unsafe(no_mangle)]
-    pub(crate) unsafe fn PostgresSQLConnection__createInstance(
-        // `&T` is ABI-identical to `*const T` and JSC guarantees non-null,
-        // live `JSGlobalObject`/`CallFrame` for every host-fn invocation, so
-        // the reference type discharges the deref precondition at the boundary
-        // instead of inside the body.
-        global: &JSGlobalObject,
-        callframe: &CallFrame,
-    ) -> JSValue {
-        match call(global, callframe) {
-            Ok(v) => v,
-            Err(_) => JSValue::ZERO,
-        }
-    }
-}
-
+// The attribute emits the JSC-callconv shim under the exported symbol.
+#[bun_jsc::host_fn(export = "PostgresSQLConnection__createInstance")]
 pub(crate) fn call(global_object: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
     // `bun_vm()` → `&'static VirtualMachine` (per-thread singleton); `as_mut()`
     // is the canonical safe escape hatch (one audited unsafe in bun_jsc) for
@@ -1132,20 +1105,19 @@ pub(crate) fn call(global_object: &JSGlobalObject, callframe: &CallFrame) -> JsR
             .get_or_create_opts(&tls_config.as_usockets_for_client_verification(), &mut err);
         if secure.is_none() {
             drop(tls_config);
-            // TODO(port): Zig `err.toJS(globalObject)` — `to_js` lives as an extension
-            // in the runtime _jsc crate and isn't reachable from sql_jsc; throw the
-            // static message instead.
-            return Err(global_object.throw(format_args!(
-                "{}",
-                bun_core::fmt::s(err.message().unwrap_or(b"Failed to create SSL context"))
-            )));
+            return Err(
+                global_object.throw_value(crate::jsc::create_bun_socket_error_to_js(
+                    err,
+                    global_object,
+                )),
+            );
         }
     }
     // Covers `try arguments[7/8].toBunString()` and the null-byte rejection
     // below. Ownership passes into `ptr.*` once allocated — `into_inner`
     // recovers them just before the Box is built so the connect-fail path's
     // `ptr.deinit()` is the sole cleanup.
-    // PORT NOTE: guard owns `(secure, tls_config)` by value. Do NOT
+    // guard owns `(secure, tls_config)` by value. Do NOT
     // `drop_in_place` a stack local that Rust would also auto-drop on unwind —
     // that double-frees. The closure's `_tls_config` is dropped exactly once by
     // normal scope-exit drop here.
@@ -1156,7 +1128,7 @@ pub(crate) fn call(global_object: &JSGlobalObject, callframe: &CallFrame) -> JsR
         }
     });
 
-    // PORT NOTE: `StringBuilder::append` takes `&mut self` and returns a borrow
+    // `StringBuilder::append` takes `&mut self` and returns a borrow
     // of the backing buffer, so successive appends can't keep their `&[u8]`
     // results live across each other. The buffer is allocated once and never
     // moved (`move_to_slice` hands back the same allocation), so detach each
@@ -1352,12 +1324,10 @@ pub(crate) fn call(global_object: &JSGlobalObject, callframe: &CallFrame) -> JsR
     this.js_value.set(crate::jsc::JsRef::init_weak(js_value));
     js::onconnect_set_cached(js_value, global_object, on_connect);
     js::onclose_set_cached(js_value, global_object, on_close);
-    /* TODO(port): bun_core::analytics::Features::POSTGRES_CONNECTIONS counter */
+    bun_analytics::features::postgres_connections.fetch_add(1, Ordering::Relaxed);
     Ok(js_value)
 }
 
-/// Referenced by `dispatch.zig` (kind = `.postgres[_tls]`). Now the only
-/// caller — `configure()` is gone.
 pub struct SocketHandler<const SSL: bool>;
 
 // Inherent associated types are unstable; use a free type alias instead.
@@ -1374,10 +1344,8 @@ impl<const SSL: bool> SocketHandler<SSL> {
         }
     }
 
-    /// VM-shutdown guard shared by the 6 socket-event shims below. Mirrors the
-    /// open-coded `if (this.vm.isShuttingDown()) { @branchHint(.unlikely); this.close(); return; }`
-    /// blocks in `PostgresSQLConnection.zig:SocketHandler` (onOpen / onHandshake_ /
-    /// onConnectError / onTimeout / onData / onWritable). `on_close` and `on_end`
+    /// VM-shutdown guard shared by the 6 socket-event shims below
+    /// (on_open / on_handshake / on_connect_error / on_timeout / on_data / on_writable). `on_close` and `on_end`
     /// intentionally do NOT route through this — they forward unconditionally.
     #[inline]
     fn guarded(this: &PostgresSQLConnection, f: impl FnOnce(&PostgresSQLConnection)) {
@@ -1481,7 +1449,7 @@ impl PostgresSQLConnection {
     // argument would carry a Stacked Borrows protector for the whole frame, and freeing
     // the allocation while that protector is live is UB ("deallocating while item is
     // protected"). Taking `*mut Self` and reborrowing per-call keeps each `&mut` scoped
-    // strictly before the dealloc — direct mapping of Zig's `*@This()`.
+    // strictly before the dealloc.
     fn deinit(this: *mut Self) {
         // SAFETY: sole remaining owner; `this` is a live Box-allocated connection.
         unsafe {
@@ -1492,10 +1460,8 @@ impl PostgresSQLConnection {
                 PostgresSQLStatement::deref(*stmt_ptr);
             }
             // statements/requests/write_buffer/read_buffer/backend_parameters dropped below.
-            // PORT NOTE: Zig called .deinit() on each; Rust Drop handles Vec/HashMap/OffsetByteList.
 
-            // PORT NOTE: Zig `freeSensitive(allocator, options_buf)` zeroes then frees the
-            // backing slice. The Rust `free_sensitive` is the C-string variant; here we
+            // `free_sensitive` is the C-string variant; here we
             // volatile-zero the Box<[u8]> in place and let Box::drop free it.
             {
                 let buf = &mut *core::ptr::addr_of_mut!((*this).options_buf);
@@ -1533,9 +1499,7 @@ impl PostgresSQLConnection {
                 // pending we will fail the request and the stmt will be marked as error ConnectionClosed too
                 QueryStatus::Pending => {
                     let Some(stmt) = request.statement_mut() else {
-                        // `continue` in Zig with `orelse continue` — but we still need to deref+discard.
-                        // PORT NOTE: Zig `orelse continue` skips the deref/discard at the bottom too;
-                        // matching that behavior here.
+                        // The deref/discard at the bottom of the loop is intentionally skipped here.
                         continue;
                     };
                     stmt.error_response = Some(StatementError::PostgresError(
@@ -1665,7 +1629,7 @@ impl PostgresSQLConnection {
     }
 }
 
-// PORT NOTE: Zig's `Writer.connection: *PostgresSQLConnection` is a
+// `Writer.connection` is a
 // backref (LIFETIMES.tsv BACKREF). The connection strictly outlives any Writer
 // (Writers are only constructed via `self.writer()` and never stored). R-2:
 // `BackRef` (shared) — `write_buffer` is a `JsCell`, so mutation routes through
@@ -1726,7 +1690,7 @@ impl PostgresSQLConnection {
     }
 }
 
-// PORT NOTE: Zig's `Reader.connection: *PostgresSQLConnection` is a
+// `Reader.connection` is a
 // backref (LIFETIMES.tsv BACKREF). `PostgresRequest::on_data` passes both
 // `&PostgresSQLConnection` and a `NewReader<Reader>` into `on()`. R-2: `BackRef`
 // (shared) — `read_buffer`/`last_message_start` are `JsCell`/`Cell`.
@@ -1775,7 +1739,7 @@ impl Reader {
             return Err(AnyPostgresError::ShortRead);
         }
 
-        // PORT NOTE: reshaped for borrowck — capture as `RawSlice` before calling
+        // reshaped for borrowck — capture as `RawSlice` before calling
         // skip(); the read_buffer backing storage is not reallocated by skip().
         let slice = bun_ptr::RawSlice::new(&remaining[..count]);
         self.skip(count);
@@ -1871,7 +1835,7 @@ impl PostgresSQLConnection {
     fn advance(&self) {
         let mut offset: usize = 0;
         debug!("advance");
-        // PORT NOTE: Zig `defer { while ... }` cleanup loop runs after the main loop returns;
+        // The cleanup loop runs after the main loop returns;
         // expanded as a closure called at every return point below.
         macro_rules! defer_cleanup {
             ($self:ident) => {{
@@ -1966,7 +1930,7 @@ impl PostgresSQLConnection {
                                 StatementStatus::Failed => {
                                     debug!("stmt failed");
                                     debug_assert!(statement.error_response.is_some());
-                                    // PORT NOTE: `postgres_sql_statement::Error` is not Clone (owns
+                                    // `postgres_sql_statement::Error` is not Clone (owns
                                     // protocol::ErrorResponse). Convert to JSValue and forward via
                                     // on_js_error instead of moving the cached error out.
                                     if let Some(ref e) = statement.error_response {
@@ -2379,10 +2343,9 @@ impl PostgresSQLConnection {
         js::queries_get_cached(js_value).unwrap_or(JSValue::UNDEFINED)
     }
 
-    // TODO(port): Zig signature is `on(comptime MessageType: @Type(.enum_literal), comptime Context: type, reader)`.
-    // Const-generic enum params are unstable, so `message_type` is a runtime arg; the match
+    // `message_type` is a runtime arg; the match
     // below still monomorphizes per-Context and the branch is trivially predictable.
-    // PORT NOTE: `reader` is taken by-value as a `NewReaderWrap<&mut Context>`
+    // `reader` is taken by-value as a `NewReaderWrap<&mut Context>`
     // (the dispatch loop in `PostgresRequest::on_data` passes
     // `reader.reborrow()` per-message). Per-arm `decode_internal` calls reborrow
     // again via `reader.reborrow()` (see protocol::NewReaderWrap::reborrow).
@@ -2391,7 +2354,7 @@ impl PostgresSQLConnection {
         message_type: MessageType,
         mut reader: protocol::NewReader<Context>,
     ) -> Result<(), AnyPostgresError> {
-        // PORT NOTE: protocol `decode_internal` returns `bun_core::Error`;
+        // protocol `decode_internal` returns `bun_core::Error`;
         // round-trip through the name-based `From` impl.
         #[inline(always)]
         fn pg_err(e: bun_core::Error) -> AnyPostgresError {
@@ -2407,7 +2370,7 @@ impl PostgresSQLConnection {
                     .statement_mut()
                     .ok_or(AnyPostgresError::ExpectedStatement)?;
                 let mut structure: JSValue = JSValue::UNDEFINED;
-                // PORT NOTE: reshaped for borrowck — `statement.structure()` borrows
+                // reshaped for borrowck — `statement.structure()` borrows
                 // `&mut *statement` and returns `&CachedStructure`; capture it as a
                 // `ParentRef` (lifetime-erased `&T`) so `&statement.fields` below
                 // does not conflict, and `as_deref` for `to_js` at the call site.
@@ -2438,7 +2401,6 @@ impl PostgresSQLConnection {
                 };
 
                 let mut stack_buf = [DataCell::SQLDataCell::default(); 70];
-                // PERF(port): was stack-fallback alloc — profile if it shows up on a hot path.
                 let max_inline = jsc::JSObject::max_inline_capacity() as usize;
                 let mut heap_cells: Vec<DataCell::SQLDataCell>;
                 let mut free_cells = false;
@@ -2465,7 +2427,7 @@ impl PostgresSQLConnection {
                 } else {
                     protocol::DataRow::decode((), &mut reader, |(), i, b| putter.put(i, b))
                 };
-                // PORT NOTE: Zig `defer { for (cells[0..putter.count]) |*cell| cell.deinit(); if (free_cells) free(cells); }`
+                // Cell cleanup (deinit each cell, then free the buffer)
                 // runs on ALL exits (decode error, to_js error, success). `putter.count` is final
                 // after `decode` (the only writer is `Putter::put_impl`, and `to_js` does not
                 // touch it), so capture it by value — no raw-ptr read needed. `cells_ptr` stays
@@ -2515,14 +2477,12 @@ impl PostgresSQLConnection {
                 let _ = free_cells; // heap_cells dropped at scope end; defer! above runs cell.deinit()
             }
             MessageType::CopyData => {
-                let copy_data =
-                    protocol::CopyData::decode_internal(reader.reborrow()).map_err(pg_err)?;
+                let copy_data = protocol::CopyData::decode_internal(reader.reborrow())?;
                 drop(copy_data);
             }
             MessageType::ParameterStatus => {
                 let parameter_status =
-                    protocol::ParameterStatus::decode_internal(reader.reborrow())
-                        .map_err(pg_err)?;
+                    protocol::ParameterStatus::decode_internal(reader.reborrow())?;
                 self.backend_parameters
                     .with_mut(|m| {
                         m.insert(
@@ -2534,8 +2494,7 @@ impl PostgresSQLConnection {
                 // parameter_status dropped at scope end
             }
             MessageType::ReadyForQuery => {
-                let _ready_for_query =
-                    protocol::ReadyForQuery::decode_internal(reader.reborrow()).map_err(pg_err)?;
+                let _ready_for_query = protocol::ReadyForQuery::decode_internal(reader.reborrow())?;
 
                 self.set_status(Status::Connected);
                 self.update_flags(|f| {
@@ -2599,8 +2558,7 @@ impl PostgresSQLConnection {
             }
             MessageType::ParameterDescription => {
                 let description =
-                    protocol::ParameterDescription::decode_internal(reader.reborrow())
-                        .map_err(pg_err)?;
+                    protocol::ParameterDescription::decode_internal(reader.reborrow())?;
                 // errdefer bun.default_allocator.free(description.parameters);
                 let request = match self.current() {
                     Some(r) => r,
@@ -2617,7 +2575,7 @@ impl PostgresSQLConnection {
                     }
                 };
                 if !statement.parameters.is_empty() {
-                    // PORT NOTE: Box<[T]> drop frees old slice.
+                    // Box<[T]> drop frees old slice.
                 }
                 statement.parameters = description.parameters;
                 if statement.status == StatementStatus::Parsing {
@@ -2626,8 +2584,7 @@ impl PostgresSQLConnection {
                 }
             }
             MessageType::RowDescription => {
-                let description =
-                    protocol::RowDescription::decode_internal(reader.reborrow()).map_err(pg_err)?;
+                let description = protocol::RowDescription::decode_internal(reader.reborrow())?;
                 // errdefer description.deinit();
                 let request = match self.current() {
                     Some(r) => r,
@@ -2643,15 +2600,14 @@ impl PostgresSQLConnection {
                 // ReadyForQuery. Free any previous fields before overwriting and
                 // invalidate state derived from them so the next DataRow builds
                 // the correct structure instead of reusing a stale cached one.
-                // PORT NOTE: Vec<FieldDescription> drop runs each field's Drop.
+                // Vec<FieldDescription> drop runs each field's Drop.
                 statement.fields = description.fields.into_vec();
                 statement.cached_structure = Default::default();
                 statement.needs_duplicate_check = true;
                 statement.fields_flags = Default::default();
             }
             MessageType::Authentication => {
-                let auth =
-                    protocol::Authentication::decode_internal(&mut reader).map_err(pg_err)?;
+                let auth = protocol::Authentication::decode_internal(&mut reader)?;
 
                 match &auth {
                     protocol::Authentication::SASL => {
@@ -2682,7 +2638,7 @@ impl PostgresSQLConnection {
                             data: Data::Temporary(bun_ptr::RawSlice::new(mechanism)),
                         };
 
-                        response.write_internal(self.writer()).map_err(pg_err)?;
+                        response.write_internal(self.writer())?;
                         debug!("SASL");
                         self.flush_data();
                     }
@@ -2782,7 +2738,7 @@ impl PostgresSQLConnection {
                             *out = a ^ b;
                         }
 
-                        // base64 of 32 bytes → ceil(32/3)*4 = 44; +4 slack matches Zig encodeLenFromSize.
+                        // base64 of 32 bytes → ceil(32/3)*4 = 44; +4 slack.
                         let mut client_key_xor_base64_buf = [0u8; 48];
                         let xor_base64_len = bun_base64::encode(
                             &mut client_key_xor_base64_buf,
@@ -2805,9 +2761,7 @@ impl PostgresSQLConnection {
                         };
 
                         sasl.status = SASLStatus::Continue;
-                        response
-                            .write_internal(&mut self.writer())
-                            .map_err(pg_err)?;
+                        response.write_internal(&mut self.writer())?;
                         self.flush_data();
                     }
                     protocol::Authentication::SASLFinal { data: final_data } => {
@@ -2886,9 +2840,7 @@ impl PostgresSQLConnection {
                             password: Data::Temporary(self.password),
                         };
 
-                        response
-                            .write_internal(&mut self.writer())
-                            .map_err(pg_err)?;
+                        response.write_internal(&mut self.writer())?;
                         self.flush_data();
                     }
 
@@ -2942,9 +2894,7 @@ impl PostgresSQLConnection {
                         };
 
                         self.authentication_state.set(AuthenticationState::Md5);
-                        response
-                            .write_internal(&mut self.writer())
-                            .map_err(pg_err)?;
+                        response.write_internal(&mut self.writer())?;
                         self.flush_data();
                     }
 
@@ -2966,13 +2916,13 @@ impl PostgresSQLConnection {
                 }
             }
             MessageType::BackendKeyData => {
-                self.backend_key_data.set(
-                    protocol::BackendKeyData::decode_internal(reader.reborrow()).map_err(pg_err)?,
-                );
+                self.backend_key_data
+                    .set(protocol::BackendKeyData::decode_internal(
+                        reader.reborrow(),
+                    )?);
             }
             MessageType::ErrorResponse => {
-                let err =
-                    protocol::ErrorResponse::decode_internal(reader.reborrow()).map_err(pg_err)?;
+                let err = protocol::ErrorResponse::decode_internal(reader.reborrow())?;
 
                 if matches!(
                     self.status.get(),
@@ -2992,8 +2942,7 @@ impl PostgresSQLConnection {
                     debug!("ErrorResponse: {}", err);
                     return Err(AnyPostgresError::ExpectedRequest);
                 };
-                // Convert to JS while we still own `err` — Zig's `request.onError` only ever
-                // calls `err.toJS`, so materialize the JS value once and route through
+                // Convert to JS while we still own `err` — materialize the JS value once and route through
                 // `on_js_error` to avoid double-ownership of the non-Clone ErrorResponse.
                 let js_err =
                     crate::postgres::protocol::error_response_jsc::to_js(&err, self.global());
@@ -3064,7 +3013,7 @@ impl PostgresSQLConnection {
             MessageType::CopyBothResponse => {
                 debug!("TODO CopyBothResponse");
             } // else => @compileError("Unknown message type")
-              // PORT NOTE: const-generic enum match is exhaustive in Rust; no compile error needed.
+              // const-generic enum match is exhaustive in Rust; no compile error needed.
         }
         Ok(())
     }
@@ -3109,5 +3058,3 @@ impl PostgresSQLConnection {
         Some(on_close)
     }
 }
-
-// ported from: src/sql_jsc/postgres/PostgresSQLConnection.zig
diff --git a/src/sql_jsc/postgres/PostgresSQLContext.rs b/src/sql_jsc/postgres/PostgresSQLContext.rs
index 7ca11a44092..896cc050b1f 100644
--- a/src/sql_jsc/postgres/PostgresSQLContext.rs
+++ b/src/sql_jsc/postgres/PostgresSQLContext.rs
@@ -7,17 +7,13 @@ use crate::jsc::{CallFrame, JSGlobalObject, JSValue, StrongOptional, VirtualMach
 #[repr(C)]
 #[derive(Default)]
 pub struct PostgresSQLContext {
-    // Zig: `Strong.Optional = .empty` → `StrongOptional::empty()` (Default).
     pub on_query_resolve_fn: StrongOptional,
     pub on_query_reject_fn: StrongOptional,
 }
 
 impl PostgresSQLContext {
-    // Exported to C++ as `PostgresSQLContext__init` — the Zig used
-    // `comptime { @export(&jsc.toJSHostFn(init), .{ .name = "PostgresSQLContext__init" }) }`.
-    // The #[bun_jsc::host_fn] attribute emits the callconv(jsc.conv) shim; the
-    // `export = "..."` arg gives it the #[unsafe(no_mangle)] symbol name.
-    // TODO(port): bun_jsc::host_fn proc-macro (#[bun_jsc::host_fn(export = "PostgresSQLContext__init")])
+    // Registered directly as `init` via `put_host_functions!` in
+    // `postgres.rs`, so no exported symbol is needed.
     pub fn init(global: &JSGlobalObject, frame: &CallFrame) -> JSValue {
         // `bun_vm()` → `&'static VirtualMachine` (per-thread singleton);
         // `as_mut()` is the canonical safe escape hatch for the shrinking set
@@ -29,5 +25,3 @@ impl PostgresSQLContext {
         JSValue::UNDEFINED
     }
 }
-
-// ported from: src/sql_jsc/postgres/PostgresSQLContext.zig
diff --git a/src/sql_jsc/postgres/PostgresSQLQuery.rs b/src/sql_jsc/postgres/PostgresSQLQuery.rs
index eadefe3c368..ac655840ca9 100644
--- a/src/sql_jsc/postgres/PostgresSQLQuery.rs
+++ b/src/sql_jsc/postgres/PostgresSQLQuery.rs
@@ -54,8 +54,8 @@ pub struct PostgresSQLQuery {
     pub flags: Cell<Flags>,
 }
 
-// Zig `deinit`: `if (this.statement) |s| s.deref()` then deref query/cursor_name,
-// then `destroy(this)`. `BunString` is `Copy` (FFI by-value, NO `Drop`), so the
+// On drop: deref the statement (if any), then deref query/cursor_name.
+// `BunString` is `Copy` (FFI by-value, NO `Drop`), so the
 // +1 ref taken by `to_bun_string` in `call()` must be released here explicitly.
 // `destroy` is `heap::take` in `deref_`.
 impl Drop for PostgresSQLQuery {
@@ -80,10 +80,10 @@ impl Default for PostgresSQLQuery {
     }
 }
 
-// PORT NOTE: Zig used `packed struct(u8)`. Ported as a plain struct with public
+// Note: a plain struct with public
 // fields because `PostgresSQLConnection.rs` reads/writes these directly
 // (`req.flags.simple`, `req.flags.binary = ...`, `req.flags.result_mode`).
-// The packing is not load-bearing on the Rust side.
+// Bit-packing is not load-bearing here.
 #[derive(Clone, Copy)]
 pub struct Flags {
     pub is_done: bool,
@@ -379,8 +379,8 @@ impl PostgresSQLQuery {
         mem::size_of::<PostgresSQLQuery>()
     }
 
-    // comptime { @export(&jsc.toJSHostFn(call), .{ .name = "PostgresSQLQuery__createInstance" }); }
-    // TODO(port): proc-macro emits the PostgresSQLQuery__createInstance export; verify codegen name.
+    // Registered directly as `createQuery` via
+    // `put_host_functions!` in `postgres.rs`, so no exported symbol is needed.
     pub fn call(global_this: &JSGlobalObject, callframe: &CallFrame) -> JsResult<JSValue> {
         let arguments = callframe.arguments();
         let mut args =
@@ -428,8 +428,7 @@ impl PostgresSQLQuery {
         this_value.ensure_still_alive();
 
         // SAFETY: ptr is exclusively owned here until returned to JS.
-        // PORT NOTE: Zig's `ptr.* = .{ ... }` is functional-record-update over a
-        // default; in Rust `PostgresSQLQuery` implements `Drop`, so FRU
+        // Note: `PostgresSQLQuery` implements `Drop`, so functional-record-update
         // (`..Default::default()`) is forbidden (E0509). `ptr` was already
         // `default()`-initialised by `Box::new` above, so just overwrite the
         // three non-default fields in place.
@@ -452,12 +451,6 @@ impl PostgresSQLQuery {
         Ok(this_value)
     }
 
-    pub fn push(&self, global_this: &JSGlobalObject, value: JSValue) {
-        // TODO(port): Zig source references `this.pending_value` which is not a field on this
-        // struct — likely dead/broken code in the original. Preserved as a no-op.
-        let _ = (global_this, value);
-    }
-
     pub fn do_done(
         this: &Self,
         global_object: &JSGlobalObject,
@@ -490,7 +483,6 @@ impl PostgresSQLQuery {
         }
 
         let mode = js_mode.coerce::<i32>(global_object)?;
-        // std.meta.intToEnum — bounds-checked enum cast.
         let result_mode = match mode {
             0 => PostgresSQLQueryResultMode::Objects,
             1 => PostgresSQLQueryResultMode::Values,
@@ -537,7 +529,6 @@ impl PostgresSQLQuery {
         };
         let connection: &PostgresSQLConnection = &connection;
 
-        // Zig: `connection.poll_ref.ref(globalObject.bunVM())`. In the Rust port,
         // `KeepAlive::ref_` takes an `EventLoopCtx` (manual vtable in `bun_io`), not a
         // `*mut VirtualMachine`. `global_object.bun_vm()` and `get_vm_ctx(.Js)` both
         // resolve to the same singleton JS VM, so route through the global hook —
@@ -658,7 +649,7 @@ impl PostgresSQLQuery {
         let has_params = signature.fields.len() > 0;
         let mut did_write = false;
         'enqueue: {
-            // PORT NOTE: `connection_entry_value` is a *mut into connection.statements value slot;
+            // Note: `connection_entry_value` is a *mut into connection.statements value slot;
             // holding a `&mut` across other &mut connection borrows below trips borrowck, so
             // store the raw `*mut *mut PostgresSQLStatement` and re-dereference at use sites.
             let mut connection_entry_value: Option<*mut *mut PostgresSQLStatement> = None;
@@ -872,7 +863,7 @@ impl PostgresSQLQuery {
                     connection
                         .prepared_statement_id
                         .set(connection.prepared_statement_id.get() + 1);
-                    // Zig sets ref_count = .initExactRefs(2) (one for this.statement,
+                    // ref_count starts at 2 (one for this.statement,
                     // one for the connection.statements map).
                     let stmt = {
                         let mut s = PostgresSQLStatement::default();
@@ -941,5 +932,3 @@ impl PostgresSQLQuery {
         Ok(JSValue::UNDEFINED)
     }
 }
-
-// ported from: src/sql_jsc/postgres/PostgresSQLQuery.zig
diff --git a/src/sql_jsc/postgres/PostgresSQLStatement.rs b/src/sql_jsc/postgres/PostgresSQLStatement.rs
index 162733befb8..3dafeec8245 100644
--- a/src/sql_jsc/postgres/PostgresSQLStatement.rs
+++ b/src/sql_jsc/postgres/PostgresSQLStatement.rs
@@ -35,7 +35,7 @@ pub struct PostgresSQLStatement {
 
 impl Default for PostgresSQLStatement {
     fn default() -> Self {
-        // TODO(port): `signature` has no default in Zig; callers must set it. This Default
+        // Callers must set `signature`. This Default
         // exists only to mirror the per-field `= ...` initializers.
         Self {
             cached_structure: PostgresCachedStructure::default(),
@@ -57,7 +57,7 @@ pub enum Error {
 }
 
 impl Error {
-    // Zig `deinit` only forwarded to `ErrorResponse.deinit()`; that is now `Drop` on
+    // Cleanup is handled by `Drop` on
     // `protocol::ErrorResponse`, so no explicit `Drop` impl is needed here.
 
     pub fn to_js(&self, global_object: &JSGlobalObject) -> JsResult<JSValue> {
@@ -86,7 +86,7 @@ impl Status {
 }
 
 impl PostgresSQLStatement {
-    /// Zig `.ref_count = .initExactRefs(n)` — set the initial intrusive
+    /// Set the initial intrusive
     /// refcount at construction time, before any `ref_()`/`deref()`. The
     /// `ref_count` field is private (refcount invariant), so callers building
     /// a statement with >1 owner (query + connection-map entry) go through
@@ -115,11 +115,11 @@ impl PostgresSQLStatement {
             let field: &mut protocol::FieldDescription = &mut self.fields[remaining];
             match &field.name_or_index {
                 ColumnIdentifier::Name(name) => {
-                    // PORT NOTE: reshaped for borrowck — compute `found_existing`
+                    // Note: reshaped for borrowck — compute `found_existing`
                     // before mutating `field.name_or_index`.
-                    // TODO(port): Zig `getOrPut` keys on the borrowed slice;
-                    // StringHashMap clones to an owned `Box<[u8]>` key. Fine for
-                    // a transient dedup set; revisit if profiling flags it.
+                    // StringHashMap
+                    // clones to an owned `Box<[u8]>` key. Fine for a transient
+                    // dedup set.
                     let found_existing = seen_fields
                         .get_or_put(name.slice())
                         .expect("OOM")
@@ -151,7 +151,7 @@ impl PostgresSQLStatement {
         self.fields_flags = flags;
     }
 
-    // PORT NOTE: Zig returns `CachedStructure` by value (struct copy). Returning
+    // Note: returning
     // `&CachedStructure` here to avoid moving out of `self` (CachedStructure owns
     // a `Box<[ExternColumnIdentifier]>` and a `StrongOptional`, neither `Copy`).
     pub fn structure(
@@ -185,5 +185,3 @@ impl Drop for PostgresSQLStatement {
         // not here — Drop must not free `self`'s storage.
     }
 }
-
-// ported from: src/sql_jsc/postgres/PostgresSQLStatement.zig
diff --git a/src/sql_jsc/postgres/SASL.rs b/src/sql_jsc/postgres/SASL.rs
index 1bf54bb9a2e..a993a34903e 100644
--- a/src/sql_jsc/postgres/SASL.rs
+++ b/src/sql_jsc/postgres/SASL.rs
@@ -55,8 +55,8 @@ fn hmac(password: &[u8], data: &[u8]) -> Option<[u8; 32]> {
 }
 
 impl SASL {
-    // PORT NOTE: reshaped for borrowck — Zig passed `*PostgresSQLConnection` but
-    // only read `connection.password`. Taking `&mut PostgresSQLConnection` here
+    // Note: takes the password slice rather than `&mut PostgresSQLConnection` —
+    // only `connection.password` is read, and `&mut PostgresSQLConnection` here
     // would alias the `&mut self.authentication_state` borrow live at the call
     // site in `PostgresSQLConnection::on`. Caller dereferences the
     // self-referential `*const [u8]` and passes the slice directly.
@@ -66,8 +66,7 @@ impl SASL {
         iteration_count: u32,
         password: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // Zig: `jsc.API.Bun.Crypto.EVP.pbkdf2` (src/runtime/api/crypto.zig).
-        // PORT NOTE: `bun_runtime::crypto::EVP::pbkdf2` is a thin wrapper over
+        // Note: `bun_runtime::crypto::EVP::pbkdf2` is a thin wrapper over
         // BoringSSL's `PKCS5_PBKDF2_HMAC` with `EVP_sha256`. Inlined here to
         // avoid the `bun_runtime` dep (which would create a cycle through
         // `bun_jsc`); `bun_boringssl_sys` is already a direct dependency.
@@ -113,7 +112,6 @@ impl SASL {
     }
 
     pub fn compute_server_signature(&mut self, auth_string: &[u8]) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         debug_assert!(self.server_signature_len == 0);
 
         let server_key = hmac(self.salted_password(), b"Server Key")
@@ -135,10 +133,11 @@ impl SASL {
     pub fn client_key_signature(&self, client_key: &[u8], auth_string: &[u8]) -> [u8; 32] {
         use bun_sha_hmac::SHA256;
         let mut sha_digest = [0u8; SHA256::DIGEST];
-        // TODO(port): bun_jsc::VirtualMachine::get / RareData::boring_engine
-        // Zig passes `jsc.VirtualMachine.get().rareData().boringEngine()` here;
-        // `None` falls through to BoringSSL's default engine, which is
-        // functionally equivalent for SHA256. Swap once bun_jsc compiles.
+        // BoringSSL's `EVP_DigestInit_ex` never reads its `ENGINE*`
+        // argument (see vendor/boringssl/crypto/fipsmodule/digest/digest.cc.inc;
+        // the parameter exists only for OpenSSL API compatibility). Passing
+        // null is bit-identical, so the upward hook is intentionally dropped —
+        // same rationale as `s3_signing::credentials::boring_engine`.
         // SAFETY: engine is null (default).
         unsafe { SHA256::hash(client_key, &mut sha_digest, core::ptr::null_mut()) };
         hmac(&sha_digest, auth_string).unwrap()
@@ -155,7 +154,5 @@ impl SASL {
     }
 }
 
-// TODO(port): Zig `deinit` is reset-for-reuse (zeroes scalar state, no owned resources);
-// add `pub fn reset(&mut self)` if callers need it. Not mapped to Drop — no side effects.
-
-// ported from: src/sql_jsc/postgres/SASL.zig
+// The only "deinit" site (`AuthenticationState::zero`) replaces the whole
+// enum variant by assignment, so no `reset()` is needed and nothing maps to Drop.
diff --git a/src/sql_jsc/postgres/Signature.rs b/src/sql_jsc/postgres/Signature.rs
index c49f898b6d3..c0fb19fa6f8 100644
--- a/src/sql_jsc/postgres/Signature.rs
+++ b/src/sql_jsc/postgres/Signature.rs
@@ -19,30 +19,20 @@ impl Signature {
         }
     }
 
-    // PORT NOTE: Zig `deinit` only freed the four owned slices via
-    // `bun.default_allocator.free`. With `Box<[T]>` fields, Rust's `Drop`
-    // handles this automatically — no explicit `Drop` impl needed.
+    // No explicit `Drop` impl needed: the `Box<[T]>` fields free the four owned slices automatically.
 
     pub fn hash(&self) -> u64 {
-        // PORT NOTE: Zig `std.hash.Wyhash.init(0)` + `update` + `final`. The
-        // `bun_wyhash` crate exposes the streaming API as `Wyhash11` (and a
-        // stateless `hash`); for now use the one-shot `bun_wyhash::hash` over
-        // a concatenated byte view.
-        // `Int4` (= u32) is `NoUninit`; safe `&[u32]` → `&[u8]` view (matches
-        // Zig `std.mem.sliceAsBytes`).
+        // `Int4` (= u32) is `NoUninit`; safe `&[u32]` → `&[u8]` view.
         let fields_bytes: &[u8] = bun_core::cast_slice(&self.fields[..]);
-        // PERF(port): Zig fed two slices into a streaming Wyhash; bun_wyhash
-        // currently lacks the std-compatible streaming `Wyhash` type. Concatenate
-        // into a temp Vec until `bun_wyhash::Wyhash` (streaming, seed-0) lands.
-        // TODO(port): bun_wyhash::Wyhash (streaming std-compatible API)
-        let mut buf: Vec<u8> = Vec::with_capacity(self.name.len() + fields_bytes.len());
-        buf.extend_from_slice(&self.name);
-        buf.extend_from_slice(fields_bytes);
-        bun_wyhash::hash(&buf)
+        let mut hasher = bun_wyhash::Wyhash::init(0);
+        hasher.update(&self.name);
+        hasher.update(fields_bytes);
+        hasher.final_()
     }
 
-    // TODO(port): narrow error set — Zig inferred set mixes JSError (from
-    // QueryBindingIterator / Tag::from_js), OOM, and error.InvalidQueryBinding.
+    // JSError (from QueryBindingIterator /
+    // Tag::from_js), OOM, and InvalidQueryBinding are collapsed to the
+    // crate-wide `bun_core::Error`.
     pub fn generate(
         global_object: &JSGlobalObject,
         query: &[u8],
@@ -60,9 +50,6 @@ impl Signature {
         let mut name: Vec<u8> = Vec::with_capacity(query.len());
 
         name.extend_from_slice(query);
-        // PERF(port): was appendSliceAssumeCapacity — profile if it shows up on a hot path.
-
-        // (errdefer { fields.deinit(); name.deinit(); } — handled by Drop on `?`)
 
         let mut iter = QueryBindingIterator::init(array_value, columns, global_object)
             .map_err(js_error_to_postgres)?;
@@ -139,5 +126,3 @@ impl Signature {
         })
     }
 }
-
-// ported from: src/sql_jsc/postgres/Signature.zig
diff --git a/src/sql_jsc/postgres/command_tag_jsc.rs b/src/sql_jsc/postgres/command_tag_jsc.rs
index 0989b9e2672..e27d5145b66 100644
--- a/src/sql_jsc/postgres/command_tag_jsc.rs
+++ b/src/sql_jsc/postgres/command_tag_jsc.rs
@@ -37,5 +37,3 @@ impl<'a> CommandTagJsc for CommandTag<'a> {
         }
     }
 }
-
-// ported from: src/sql_jsc/postgres/command_tag_jsc.zig
diff --git a/src/sql_jsc/postgres/error_jsc.rs b/src/sql_jsc/postgres/error_jsc.rs
index cd029e32e88..5314b05338f 100644
--- a/src/sql_jsc/postgres/error_jsc.rs
+++ b/src/sql_jsc/postgres/error_jsc.rs
@@ -15,10 +15,8 @@ pub(crate) fn create_postgres_error(
         b"code",
         bun_string_jsc::create_utf8_for_js(global, options.code)?,
     );
-    // PORT NOTE: Zig used `inline for (std.meta.fields(PostgresErrorOptions))` + `@typeInfo`
-    // to reflect over every optional field and `put` it by name when `Some`. Rust has no
-    // field reflection; expand by hand. Property names must match the Zig struct field
-    // names verbatim (camelCase: `internalPosition`, `internalQuery`, `dataType`) since
+    // Each optional field is `put` by name when `Some`. Property names must
+    // stay camelCase (`internalPosition`, `internalQuery`, `dataType`) since
     // the JS consumer reads `options.internalPosition` etc.
     let optional_fields: [(&'static [u8], Option<&[u8]>); 16] = [
         (b"errno", options.errno),
@@ -122,7 +120,6 @@ pub(crate) fn postgres_error_to_js(
     let msg: &[u8] = if let Some(m) = message {
         m
     } else {
-        // PORT NOTE: reshaped for borrowck — capture remaining len before re-borrowing buffer.
         use std::io::Write;
         let name: &'static str = <&'static str>::from(err);
         let mut cursor = &mut buffer_message[..];
@@ -147,5 +144,3 @@ pub(crate) fn postgres_error_to_js(
         Err(e) => global.take_error(e),
     }
 }
-
-// ported from: src/sql_jsc/postgres/error_jsc.zig
diff --git a/src/sql_jsc/postgres/protocol/error_response_jsc.rs b/src/sql_jsc/postgres/protocol/error_response_jsc.rs
index 60e4d07f862..bedf0fd59e6 100644
--- a/src/sql_jsc/postgres/protocol/error_response_jsc.rs
+++ b/src/sql_jsc/postgres/protocol/error_response_jsc.rs
@@ -13,7 +13,7 @@ pub(crate) fn to_js(this: &ErrorResponse, global_object: &JSGlobalObject) -> JSV
     let mut b = StringBuilder::default();
 
     for msg in this.messages.iter() {
-        // Zig: `switch (msg.*) { inline else => |m| m.utf8ByteLength() }` — every
+        // Every
         // FieldMessage variant carries a single bun.String payload.
         b.cap += field_message_payload(msg).utf8_byte_length() + 1;
     }
@@ -123,8 +123,7 @@ pub(crate) fn to_js(this: &ErrorResponse, global_object: &JSGlobalObject) -> JSV
     let line_slice = maybe_slice(line);
     let routine_slice = maybe_slice(routine);
 
-    // PORT NOTE: reshaped for borrowck — `b.allocated_slice()` borrows `b`
-    // mutably; capture `b.len` first.
+    // Capture `b.len` first: `b.allocated_slice()` borrows `b` mutably.
     let len = b.len;
     let error_message: &[u8] = if len > 0 {
         &b.allocated_slice()[..len]
@@ -157,5 +156,3 @@ pub(crate) fn to_js(this: &ErrorResponse, global_object: &JSGlobalObject) -> JSV
     )
     .unwrap_or_else(|e| global_object.take_error(e))
 }
-
-// ported from: src/sql_jsc/postgres/protocol/error_response_jsc.zig
diff --git a/src/sql_jsc/postgres/protocol/notice_response_jsc.rs b/src/sql_jsc/postgres/protocol/notice_response_jsc.rs
index 3cc19882dd9..6aa8cbf31e3 100644
--- a/src/sql_jsc/postgres/protocol/notice_response_jsc.rs
+++ b/src/sql_jsc/postgres/protocol/notice_response_jsc.rs
@@ -1,10 +1,9 @@
 use bun_sql::postgres::protocol::field_message::FieldMessage;
 
-/// Zig `switch (msg) { inline else => |m| ... }` — every `FieldMessage` variant
-/// carries a single `bun.String` payload. `bun_sql::FieldMessage` doesn't (yet)
-/// expose a `payload()` accessor, so match locally.
-// TODO(port): bun_sql::postgres::protocol::field_message::FieldMessage::payload
-// — once landed, replace this whole match with `msg.payload()`.
+/// Every `FieldMessage` variant
+/// carries a single `bun.String` payload, so an exhaustive match collapses to
+/// the single binding. The match lives here (not as a `payload()` accessor on
+/// `bun_sql::FieldMessage`) because this is its only consumer.
 pub(crate) fn field_message_payload(msg: &FieldMessage) -> &bun_core::String {
     match msg {
         FieldMessage::Severity(s)
@@ -27,5 +26,3 @@ pub(crate) fn field_message_payload(msg: &FieldMessage) -> &bun_core::String {
         | FieldMessage::Routine(s) => s,
     }
 }
-
-// ported from: src/sql_jsc/postgres/protocol/notice_response_jsc.zig
diff --git a/src/sql_jsc/postgres/types/PostgresString.rs b/src/sql_jsc/postgres/types/PostgresString.rs
index bf178b5f4a6..715d34baef8 100644
--- a/src/sql_jsc/postgres/types/PostgresString.rs
+++ b/src/sql_jsc/postgres/types/PostgresString.rs
@@ -7,7 +7,6 @@ pub trait ToJsWithType {
     fn to_js_with_type(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError>;
 }
 
-// Covers Zig arms `[:0]u8, []u8, []const u8, [:0]const u8` — all collapse to a byte slice.
 impl ToJsWithType for &[u8] {
     fn to_js_with_type(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError> {
         let str = bun_core::String::borrow_utf8(self);
@@ -22,15 +21,13 @@ impl ToJsWithType for bun_core::String {
     }
 }
 
-impl ToJsWithType for &mut Data {
+// Takes owned `Data`; Drop at the
+// end of this fn frees it (same pattern as bytea.rs/json.rs).
+impl ToJsWithType for Data {
     fn to_js_with_type(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError> {
         let str = bun_core::String::borrow_utf8(self.slice());
-        // `defer str.deinit()` → Drop on bun_core::String
-        // TODO(port): Zig calls `value.deinit()` here (consumes the Data). In Rust, Data's
-        // Drop should handle this at the caller's scope; revisit ownership if Data must be
-        // freed before this fn returns.
+        // `defer str.deinit()` → Drop on bun_core::String. `to_js` copies into
+        // a JSC-owned string, so dropping `self` (the Data) on return is safe.
         str.to_js(global).map_err(js_error_to_postgres)
     }
 }
-
-// ported from: src/sql_jsc/postgres/types/PostgresString.zig
diff --git a/src/sql_jsc/postgres/types/bool.rs b/src/sql_jsc/postgres/types/bool.rs
index 29bfa6840da..8b137891791 100644
--- a/src/sql_jsc/postgres/types/bool.rs
+++ b/src/sql_jsc/postgres/types/bool.rs
@@ -1 +1 @@
-// ported from: src/sql_jsc/postgres/types/bool.zig
+
diff --git a/src/sql_jsc/postgres/types/bytea.rs b/src/sql_jsc/postgres/types/bytea.rs
index e6cf20fd7b7..87d2acfa4f2 100644
--- a/src/sql_jsc/postgres/types/bytea.rs
+++ b/src/sql_jsc/postgres/types/bytea.rs
@@ -7,19 +7,15 @@ pub trait ByteaToJs {
     fn bytea_to_js(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError>;
 }
 
-// PORT NOTE: reshaped `value: *Data` + `defer value.deinit()` → owned `Data`;
-// Drop at scope exit replaces the explicit deinit.
+// Takes `Data` by value; Drop at scope exit frees the decode buffer.
 impl ByteaToJs for Data {
     fn bytea_to_js(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError> {
         // var slice = value.slice()[@min(1, value.len)..];
         // _ = slice;
         //
-        // Zig's `JSValue.createBuffer(global, slice, null)` with a null
-        // allocator maps to the copying Buffer constructor: `self.slice()`
+        // Use the copying Buffer constructor: `self.slice()`
         // borrows a transient decode buffer that `Drop` frees on return, so
         // JSC must own its own copy.
         ArrayBuffer::create_buffer(global, self.slice()).map_err(js_error_to_postgres)
     }
 }
-
-// ported from: src/sql_jsc/postgres/types/bytea.zig
diff --git a/src/sql_jsc/postgres/types/date.rs b/src/sql_jsc/postgres/types/date.rs
index 3f43fb6d674..520c16bab64 100644
--- a/src/sql_jsc/postgres/types/date.rs
+++ b/src/sql_jsc/postgres/types/date.rs
@@ -9,7 +9,6 @@ pub const FROM: [Short; 3] = [1082, 1114, 1184];
 // This is a signed 64-bit integer.
 const POSTGRES_EPOCH_DATE: i64 = 946_684_800_000;
 
-// std.time.us_per_ms
 const US_PER_MS: i64 = 1000;
 
 pub fn from_binary(bytes: &[u8]) -> f64 {
@@ -50,7 +49,6 @@ pub fn from_js(global_object: &JSGlobalObject, value: JSValue) -> JsResult<i64>
     } else if value.is_number() {
         value.as_number()
     } else if value.is_string() {
-        // Zig: `catch @panic("unreachable")` → .expect.
         let mut str =
             bun_core::OwnedString::new(value.to_bun_string(global_object).expect("unreachable"));
         crate::jsc::bun_string_jsc::parse_date(&mut str, global_object)?
@@ -62,10 +60,8 @@ pub fn from_js(global_object: &JSGlobalObject, value: JSValue) -> JsResult<i64>
     Ok((unix_timestamp - POSTGRES_EPOCH_DATE) * US_PER_MS)
 }
 
-// Zig `toJS(value: anytype)` dispatches on `@TypeOf(value)` at comptime over a
-// closed set {i64, *Data}. Rust has no comptime type-switch; modeled as a trait
-// with per-type impls so `tag_jsc::to_js_with_type` can dispatch uniformly. The
-// `else => @compileError(...)` arm is the natural "no impl" compile error.
+// Conversion dispatches over a closed set {i64, Data}; modeled as a trait
+// with per-type impls so `tag_jsc::to_js_with_type` can dispatch uniformly.
 pub trait DateToJs {
     fn date_to_js(self, global_object: &JSGlobalObject) -> JSValue;
 }
@@ -99,5 +95,3 @@ pub fn to_js_data(global_object: &JSGlobalObject, value: &Data) -> JSValue {
     let cstr = unsafe { bun_core::ffi::cstr(z.as_ptr()) };
     JSValue::from_date_string(global_object, cstr)
 }
-
-// ported from: src/sql_jsc/postgres/types/date.zig
diff --git a/src/sql_jsc/postgres/types/json.rs b/src/sql_jsc/postgres/types/json.rs
index 67954bb100e..f708717fb15 100644
--- a/src/sql_jsc/postgres/types/json.rs
+++ b/src/sql_jsc/postgres/types/json.rs
@@ -7,17 +7,13 @@ pub trait JsonToJs {
     fn json_to_js(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError>;
 }
 
-// PORT NOTE: reshaped `value: *Data` + `defer value.deinit()` → owned `Data`;
-// Drop at scope exit replaces the explicit deinit.
+// Takes `Data` by value; Drop at scope exit frees the decode buffer.
 impl JsonToJs for Data {
     fn json_to_js(self, global: &JSGlobalObject) -> Result<JSValue, AnyPostgresError> {
         let str = bun_core::String::borrow_utf8(self.slice());
         // `defer str.deref()` — handled by Drop on bun_core::String.
         let js_str = str.to_js(global).map_err(js_error_to_postgres)?;
         let parse_result = js_str.parse_json(global).map_err(js_error_to_postgres)?;
-        // PORT NOTE: Zig `parse_result.AnyPostgresError()` is a typo for
-        // `.isAnyError()` (verified against bun_jsc surface — no `AnyPostgresError`
-        // method exists on JSValue).
         if parse_result.is_any_error() {
             return Err(js_error_to_postgres(global.throw_value(parse_result)));
         }
@@ -25,5 +21,3 @@ impl JsonToJs for Data {
         Ok(parse_result)
     }
 }
-
-// ported from: src/sql_jsc/postgres/types/json.zig
diff --git a/src/sql_jsc/postgres/types/tag_jsc.rs b/src/sql_jsc/postgres/types/tag_jsc.rs
index 7ed044a9026..4514eb48f5b 100644
--- a/src/sql_jsc/postgres/types/tag_jsc.rs
+++ b/src/sql_jsc/postgres/types/tag_jsc.rs
@@ -1,4 +1,4 @@
-//! JSC bridges for `sql/postgres/types/Tag.zig`. The `Tag` OID enum and its
+//! JSC bridges for the postgres `Tag` OID enum. The enum and its
 //! pure helpers stay in `sql/`; only the `JSValue`/`JSGlobalObject`-touching
 //! conversion paths live here.
 
@@ -7,12 +7,13 @@ use bun_sql::postgres::AnyPostgresError;
 use bun_sql::postgres::types::tag::Tag;
 use bun_sql::shared::Data;
 
-// `comptime T: Tag` → const generic per PORTING.md. `Tag` in the Rust port is a
+// `Tag` is a runtime arg rather than a const generic: it is a
 // `#[repr(transparent)] struct Tag(Short)` with associated consts (non-exhaustive
-// OID space), so it can't be `ConstParamTy`. Demoted to a runtime arg; the body
+// OID space), so it can't be `ConstParamTy`. The body
 // is a plain match and the only caller (DataCell) computes the tag at runtime
 // anyway.
-// TODO(port): narrow error set (Zig inferred `error{UnsupportedArrayType}`).
+// `UnsupportedArrayType` is reported via the crate-wide
+// `bun_core::Error`.
 pub(crate) fn to_js_typed_array_type(t: Tag) -> Result<JSType, bun_core::Error> {
     match t {
         Tag::int4_array => Ok(JSType::Int32Array),
@@ -23,8 +24,8 @@ pub(crate) fn to_js_typed_array_type(t: Tag) -> Result<JSType, bun_core::Error>
     }
 }
 
-/// rest may `unreachable!()` (mirroring Zig's per-monomorphization compile
-/// error becoming a runtime impossibility once the `tag` is fixed).
+/// Impls handle only the arms valid for their type; the rest may `unreachable!()`
+/// (a runtime impossibility once the `tag` is fixed).
 pub trait TagToJs: Sized {
     /// `.numeric | .float4 | .float8 | .int4` arms → `JSValue.jsNumber(value)`.
     fn as_js_number(self) -> f64;
@@ -122,5 +123,3 @@ pub fn from_js(global: &JSGlobalObject, value: JSValue) -> JsResult<Tag> {
 
     Ok(Tag::numeric)
 }
-
-// ported from: src/sql_jsc/postgres/types/tag_jsc.zig
diff --git a/src/sql_jsc/shared/CachedStructure.rs b/src/sql_jsc/shared/CachedStructure.rs
index dd1da43410c..f4ef9c72ff1 100644
--- a/src/sql_jsc/shared/CachedStructure.rs
+++ b/src/sql_jsc/shared/CachedStructure.rs
@@ -63,9 +63,9 @@ impl CachedStructure {
             .count();
 
         let max_inline = JSObject::max_inline_capacity() as usize;
-        // PORT NOTE: initialized to empty so the `> max_inline` branch below can
-        // unconditionally `into_boxed_slice()` it; in the `<= max_inline` branch
-        // it stays empty and is never read.
+        // Initialized to empty so the `> max_inline` branch below can
+        // unconditionally `into_boxed_slice()` it; in the `<= max_inline`
+        // branch it stays empty and is never read.
         let mut heap_ids: Vec<ExternColumnIdentifier> = Vec::new();
         let ids: &mut [MaybeUninit<ExternColumnIdentifier>] = if non_duplicated_count <= max_inline
         {
@@ -107,8 +107,8 @@ impl CachedStructure {
             // SAFETY: `heap_ids` has capacity `non_duplicated_count` and every
             // slot in [0..non_duplicated_count] was initialized in the loop above.
             unsafe { heap_ids.set_len(non_duplicated_count) };
-            // Ownership transfer of heap `ids` to CachedStructure (Zig: cached_structure
-            // becomes responsible for freeing the alloc'd slice).
+            // Ownership transfer of heap `ids` to CachedStructure, which
+            // becomes responsible for freeing the alloc'd slice.
             self.set(global_object, None, Some(heap_ids.into_boxed_slice()));
         } else {
             // Every element in `ids[..]` was `.write()`n above; C++ reads them as
@@ -132,10 +132,6 @@ impl CachedStructure {
     }
 }
 
-// PORT NOTE: Zig `deinit` only freed owned fields:
-//   - `structure.deinit()`  → handled by `impl Drop for StrongOptional`
-//   - per-element `name.deinit()` + `default_allocator.free(fields)`
-//     → handled by `Drop` on `Box<[ExternColumnIdentifier]>` (each element drops itself)
-// so no explicit `impl Drop` body is needed.
-
-// ported from: src/sql_jsc/shared/CachedStructure.zig
+// No explicit `impl Drop` is needed: the GC-strong structure handle is freed
+// by `impl Drop for StrongOptional`, and the field array (including each
+// element's owned name) is freed by `Drop` on `Box<[ExternColumnIdentifier]>`.
diff --git a/src/sql_jsc/shared/ObjectIterator.rs b/src/sql_jsc/shared/ObjectIterator.rs
index 5412899ec24..415c7f88a5e 100644
--- a/src/sql_jsc/shared/ObjectIterator.rs
+++ b/src/sql_jsc/shared/ObjectIterator.rs
@@ -1,6 +1,6 @@
 use crate::jsc::{JSGlobalObject, JSObject, JSValue, JsResult};
 
-// PORT NOTE: this iterator holds bare `JSValue` fields and a borrowed
+// Note: this iterator holds bare `JSValue` fields and a borrowed
 // `&JSGlobalObject`; it is only sound when constructed on the stack for the
 // duration of a single bind/iteration pass (conservative GC stack scan keeps
 // `array`/`columns`/`current_row` alive). Never `Box` this.
@@ -50,9 +50,8 @@ impl<'a> ObjectIterator<'a> {
             }
         }
 
-        // PORT NOTE: Zig `defer { if (cell_i >= columns_count) { ... } }` is
-        // lowered to a labeled block whose result is computed first, then the
-        // deferred bookkeeping runs exactly once before returning.
+        // The labeled block computes the result first, then the bookkeeping
+        // below runs exactly once before returning.
         let result: JsResult<Option<JSValue>> = 'out: {
             let property = match JSObject::get_index(self.columns, global_object, cell_i) {
                 Ok(v) => v,
@@ -68,8 +67,9 @@ impl<'a> ObjectIterator<'a> {
                 )));
             }
 
-            // TODO(port): verify `get_own_by_value` return type — Zig site treats it
-            // as `?JSValue` (compares against `.zero` and `null` separately).
+            // `get_own_by_value` maps the C++ empty (zero) return to `None`,
+            // so the `Some(JSValue::ZERO)` comparison below is defensively dead
+            // (an unwrapped value is never zero).
             let value: Option<JSValue> = self.current_row.get_own_by_value(global_object, property);
             if value == Some(JSValue::ZERO) || value.is_some_and(|v| v.is_undefined()) {
                 if !global_object.has_exception() {
@@ -93,5 +93,3 @@ impl<'a> ObjectIterator<'a> {
         result
     }
 }
-
-// ported from: src/sql_jsc/shared/ObjectIterator.zig
diff --git a/src/sql_jsc/shared/QueryBindingIterator.rs b/src/sql_jsc/shared/QueryBindingIterator.rs
index bca1525b528..864706854b7 100644
--- a/src/sql_jsc/shared/QueryBindingIterator.rs
+++ b/src/sql_jsc/shared/QueryBindingIterator.rs
@@ -68,5 +68,3 @@ impl<'a> QueryBindingIterator<'a> {
         }
     }
 }
-
-// ported from: src/sql_jsc/shared/QueryBindingIterator.zig
diff --git a/src/sql_jsc/shared/SQLDataCell.rs b/src/sql_jsc/shared/SQLDataCell.rs
index fb74a8f908e..dd84b710485 100644
--- a/src/sql_jsc/shared/SQLDataCell.rs
+++ b/src/sql_jsc/shared/SQLDataCell.rs
@@ -2,19 +2,17 @@ use core::ptr;
 use core::slice;
 
 use crate::jsc::{ExternColumnIdentifier, JSGlobalObject, JSType, JSValue, JsError, JsResult};
-use bun_sql::shared::Data;
-// `?bun.WTF.StringImpl` in Zig is a nullable thin pointer; the Rust port
-// re-exports it as `WTFStringImpl = *mut WTFStringImplStruct`.
 use bun_core::wtf::WTFStringImpl;
+use bun_sql::shared::Data;
 
-// PORT NOTE: This entire type is `extern struct` in Zig and is passed by pointer
+// Note: This entire type is passed by pointer
 // across FFI to C++ (`JSC__constructObjectFromDataCell`). Field layout is
 // load-bearing. LIFETIMES.tsv classifies several pointer fields as owned/shared/
 // borrowed (Vec / RefPtr / &[u8]), but those Rust types either change size
 // (fat slice ptrs) or add Drop semantics that a `#[repr(C)] union` cannot host
 // without `ManuallyDrop`. Raw thin pointers are kept for FFI fidelity; ownership
 // semantics from LIFETIMES.tsv are noted per-field below and enforced in
-// `deinit`. TODO(refactor): revisit once the C++ side is ported.
+// `deinit`. Revisit only if the C++ side (SQLClient.cpp) is ever ported.
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -84,7 +82,7 @@ pub union Value {
 }
 
 // Clone/Copy: bitwise — `ptr` is logically OWNED (freed by `deinit`), but the
-// type is `#[repr(C)]` POD passed across FFI by value (Zig pattern). Ownership
+// type is `#[repr(C)]` POD passed across FFI by value. Ownership
 // is single-writer by convention; never call `deinit` on more than one copy.
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -125,11 +123,17 @@ impl Array {
             return &mut [];
         }
         // SAFETY: ptr is non-null and the backing allocation spans `cap`
-        // `SQLDataCell`s. Producers (DataCell.zig:461 ArrayList) zero-init the
-        // full capacity before handing it across FFI, so every element — not
-        // just `[..len]` — carries a valid `Tag` discriminant. Genuine FFI:
-        // ptr/len/cap are thin C fields read directly by C++ (SQLClient.cpp),
-        // so this cannot be a `Vec` without breaking ABI.
+        // `SQLDataCell`s, so the pointer arithmetic stays in-bounds. CAUTION:
+        // the only producer (postgres/DataCell.rs `parse_array`) decomposes a
+        // plain `Vec` and does NOT initialize spare capacity, so only
+        // `[..len]` is guaranteed initialized — elements in `len..cap` may be
+        // uninitialized, and materializing `&mut [SQLDataCell]` over them is
+        // UB. This method currently has no callers; before using it, either
+        // restrict the view to `len` (use `slice()`), return
+        // `&mut [MaybeUninit<SQLDataCell>]`, or make every producer init the
+        // full capacity. Genuine FFI: ptr/len/cap are thin C fields read
+        // directly by C++ (SQLClient.cpp), so this cannot be a `Vec` without
+        // breaking ABI.
         unsafe { slice::from_raw_parts_mut(self.ptr, self.cap as usize) }
     }
 
@@ -142,9 +146,9 @@ impl Array {
         if p.is_null() {
             return;
         }
-        // SAFETY: LIFETIMES.tsv evidence — ptr/len/cap originate from
-        // `ArrayList.items.ptr` (DataCell.zig:461), i.e. a Vec-shaped allocation
-        // from the global (mimalloc) allocator. Reconstruct and drop.
+        // SAFETY: ptr/len/cap originate from a `Vec<SQLDataCell>` decomposed
+        // by the producer (postgres/DataCell.rs `parse_array`), i.e. a
+        // Vec-shaped allocation from the global allocator. Reconstruct and drop.
         // Elements were already deinit'd by the caller; SQLDataCell has no Drop.
         unsafe { drop(Vec::from_raw_parts(p, 0, cap)) };
     }
@@ -181,15 +185,14 @@ pub struct TypedArray {
     pub type_: JSType, // `type` is a Rust keyword
 }
 
-// PORT NOTE: Zig's `slice()`/`byteSlice()` accessors are intentionally not
-// ported as `&mut [u8]` getters. `len` is the typed-array *element* count
-// (consumed by SQLClient.cpp), not a byte length, so a `&mut [u8; len]` view
-// would be wrong for elements wider than u8; and the only Rust caller of
-// `byteSlice()` was `deinit`, which now builds the fat pointer with the safe
-// `ptr::slice_from_raw_parts_mut` directly (no intermediate `&mut` reference).
+// Note: no `&mut [u8]` slice getters are provided. `len` is the typed-array
+// *element* count (consumed by SQLClient.cpp), not a byte length, so a
+// `&mut [u8; len]` view would be wrong for elements wider than u8; `deinit`
+// builds the fat pointer with the safe `ptr::slice_from_raw_parts_mut`
+// directly (no intermediate `&mut` reference).
 
 impl SQLDataCell {
-    // PORT NOTE: kept as an explicit method, not `impl Drop` — this type is
+    // Note: kept as an explicit method, not `impl Drop` — this type is
     // #[repr(C)], lives inside a C union, is bulk-passed to C++ by pointer, and
     // freeing is gated on `free_value`. See PORTING.md §Idiom map (FFI types
     // keep explicit destroy).
@@ -221,8 +224,17 @@ impl SQLDataCell {
                 // Build the fat pointer with the safe `ptr::slice_from_raw_parts_mut`
                 // (no `&mut` reference materialized); only `Box::from_raw` is unsafe.
                 // SAFETY: bytea[0]/bytea[1] are ptr/len of a buffer allocated
-                // via the global allocator (Zig: bun.default_allocator).
-                // TODO(port): verify allocation size == len (Zig free() uses slice.len).
+                // via the global allocator. The only `free_value=1` Bytea
+                // producer is `parse_bytea`
+                // (postgres/DataCell.rs), which allocates exactly `hex.len()/2`
+                // bytes and stores `decode_hex_to_bytes`'s return. With that
+                // call-site invariant (`source.len() >= 2 * dest.len()`), the
+                // non-truncating decoder cannot exhaust the input before the
+                // destination fills, so on success it returns `dest.len()` —
+                // hence allocation size == len and the `Box<[u8]>` layout
+                // below matches the allocation. (In general the decoder may
+                // return less than `dest.len()` when the input runs out first;
+                // this proof depends on parse_bytea's allocation size.)
                 unsafe { drop(Box::<[u8]>::from_raw(ptr::slice_from_raw_parts_mut(p, len))) };
             }
             Tag::Array => {
@@ -240,17 +252,17 @@ impl SQLDataCell {
                     // Build the fat pointer with the safe
                     // `ptr::slice_from_raw_parts_mut` (no `&mut` reference
                     // materialized); only `Box::from_raw` is unsafe.
-                    // Zig's spec uses `self.len`, but `len` is the *element*
-                    // count (consumed by SQLClient.cpp as the typed-array
-                    // length); for any element wider than u8 that under-reports
-                    // the allocation size. Mimalloc's `free` ignores size so
-                    // Zig got away with it; Rust's `Box::<[u8]>::from_raw`
-                    // layout must match the allocation, hence `byte_len`.
+                    // `len` is the *element* count (consumed by SQLClient.cpp
+                    // as the typed-array length); for any element wider than u8
+                    // that under-reports the allocation size, and
+                    // `Box::<[u8]>::from_raw`'s layout must match the
+                    // allocation, hence `byte_len`.
                     // SAFETY: head_ptr was allocated via the global allocator
-                    // when free_value != 0.
-                    // TODO(port): LIFETIMES.tsv marks this BORROW (free_value=0
-                    // at all call sites) — this branch may be dead; preserved
-                    // to match Zig.
+                    // when free_value != 0. This branch is live: the postgres
+                    // binary-array path (DataCell.rs `from_bytes_typed_array`)
+                    // produces `free_value=1` cells whose `head_ptr` is
+                    // `Box::into_raw` of a `Box<[u8]>` of exactly `byte_len`
+                    // bytes, so the layout below matches the allocation.
                     unsafe {
                         drop(Box::<[u8]>::from_raw(ptr::slice_from_raw_parts_mut(
                             ta.head_ptr,
@@ -295,21 +307,18 @@ impl SQLDataCell {
         count: u32,
         flags: Flags,
         result_mode: u8,
-        // Zig: `?[*]ExternColumnIdentifier` — nullable many-pointer. Accepts
-        // both a raw `*mut` (null == None) and an explicit `Option<*mut _>` so
-        // callers can mirror the Zig optional directly; collapsed to a raw
-        // pointer for the FFI call below.
+        // Accepts both a raw `*mut` (null == None) and an explicit
+        // `Option<*mut _>`; collapsed to a raw pointer for the FFI call below.
         names_ptr: impl Into<Option<*mut ExternColumnIdentifier>>,
         names_count: u32,
     ) -> JsResult<JSValue> {
         let names_ptr: *mut ExternColumnIdentifier = names_ptr.into().unwrap_or(ptr::null_mut());
-        // Zig spec gates this on `bun.Environment.ci_assert`: open an
-        // `ExceptionValidationScope` so the C++ `DECLARE_THROW_SCOPE` inside
+        // Open an `ExceptionValidationScope` so the C++
+        // `DECLARE_THROW_SCOPE` inside
         // SQLClient.cpp's `toJS` (depth 0 → depth 1) has its post-call
         // `m_needExceptionCheck` satisfied here instead of tripping the next
         // `DECLARE_TOP_EXCEPTION_SCOPE` constructor's verifier. The macro is a
-        // no-op in release (matches the Zig non-ci_assert branch) and a real
-        // C++ scope under debug/ASAN.
+        // no-op in release and a real C++ scope under debug/ASAN.
         bun_jsc::validation_scope!(scope, global_object);
 
         let value = JSC__constructObjectFromDataCell(
@@ -331,8 +340,7 @@ impl SQLDataCell {
     }
 }
 
-/// Coercion helper mirroring Zig's implicit `*const Data` → `?*const Data`
-/// promotion at `raw()` call sites. Lets callers pass `&Data`, `&mut Data`,
+/// Coercion helper for `raw()` call sites. Lets callers pass `&Data`, `&mut Data`,
 /// `Option<&Data>`, or `Option<&mut Data>` without wrapping.
 pub trait IntoOptionalData<'a> {
     fn into_optional_data(self) -> Option<&'a Data>;
@@ -369,11 +377,12 @@ bitflags::bitflags! {
         const HAS_INDEXED_COLUMNS   = 1 << 0;
         const HAS_NAMED_COLUMNS     = 1 << 1;
         const HAS_DUPLICATE_COLUMNS = 1 << 2;
-        // remaining 29 bits: padding (`_: u29 = 0` in Zig)
+        // remaining 29 bits: padding
     }
 }
 
-// TODO(port): move to sql_jsc_sys
+// Declared inline rather than in a dedicated `*_sys` crate: this is the only
+// extern this crate calls and its sole consumer is the wrapper above.
 unsafe extern "C" {
     // `&JSGlobalObject` is ABI-identical to a non-null `*const JSGlobalObject`;
     // remaining params are by-value scalars + raw (ptr,len) slice pairs that
@@ -393,5 +402,3 @@ unsafe extern "C" {
         names_count: u32,
     ) -> JSValue;
 }
-
-// ported from: src/sql_jsc/shared/SQLDataCell.zig
diff --git a/src/standalone_graph/StandaloneModuleGraph.rs b/src/standalone_graph/StandaloneModuleGraph.rs
index b3efb8826b4..244153038a4 100644
--- a/src/standalone_graph/StandaloneModuleGraph.rs
+++ b/src/standalone_graph/StandaloneModuleGraph.rs
@@ -24,8 +24,8 @@ use bun_paths::{OSPathBuffer, WPathBuffer};
 use bun_sourcemap as SourceMap;
 use bun_sys::{self as Syscall, Fd, FdExt as _, Stat};
 
-// TODO(port): bun_webcore::Blob — `cached_blob` is only ever set from
-// `bun_runtime` (higher tier); model as opaque erased pointer here.
+// `bun_webcore::Blob` lives in a higher tier and `cached_blob` is only ever
+// set from `bun_runtime`, so it is modeled as an opaque erased pointer here.
 bun_opaque::opaque_ffi! {
     /// Opaque stand-in for `bun_webcore::Blob`. Only stored as `NonNull<Blob>`.
     pub struct Blob;
@@ -58,10 +58,9 @@ pub const BASE_PATH: &str = "/$bunfs/";
 #[cfg(windows)]
 pub const BASE_PATH: &str = "B:\\~BUN\\";
 
-// TODO(port): Zig version takes `target: Environment.OperatingSystem` + `comptime suffix`
-// and concatenates at comptime. Rust cannot const-concat with a runtime enum branch
-// nor across a `const fn` boundary. Could expose as a `macro_rules!` over
-// `const_format::concatcp!`; for now we materialize the two call-sites directly.
+// Rust cannot const-concat with a runtime enum branch nor across a `const fn`
+// boundary, so the two call-site combinations are materialized directly with
+// `const_format::concatcp!`.
 #[cfg(windows)]
 pub const BASE_PUBLIC_PATH: &str = "B:/~BUN/";
 #[cfg(not(windows))]
@@ -72,12 +71,11 @@ pub const BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX: &str = const_format::concatcp!("
 #[cfg(not(windows))]
 pub const BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX: &str = const_format::concatcp!("/$bunfs/", "root/");
 
-// TODO(port): Zig used a nested `Instance` struct holding a static var. Model
-// as a process-lifetime `OnceLock` (PORTING.md §Concurrency: never `static mut`).
-// `get()` returns a raw `*mut` to mirror Zig's `?*StandaloneModuleGraph`; callers
-// mutate `wtf_string` / `cached_blob` / `sourcemap` lazily. TODO(refactor):
-// push interior mutability down to those per-`File` fields (`UnsafeCell<…>`) so
-// read-only paths (`find`, `entry_point`, `stat`) can take `&self`.
+// A process-lifetime `OnceLock` (PORTING.md §Concurrency: never `static mut`).
+// `get()` returns a raw `*mut`; callers
+// mutate `wtf_string` / `cached_blob` / `sourcemap` lazily. A future reshape
+// could push interior mutability down to those per-`File` fields (`UnsafeCell<…>`)
+// so read-only paths (`find`, `entry_point`, `stat`) can take `&self`.
 struct Instance(core::cell::UnsafeCell<StandaloneModuleGraph>);
 // SAFETY: the graph is populated once at startup before any worker threads;
 // post-init mutation is limited to per-`File` lazy fields. NOTE: `INIT_LOCK`
@@ -90,8 +88,8 @@ static INSTANCE: std::sync::OnceLock<Instance> = std::sync::OnceLock::new();
 
 impl StandaloneModuleGraph {
     pub fn get() -> Option<*mut StandaloneModuleGraph> {
-        // Mirrors Zig's `?*StandaloneModuleGraph`: a raw pointer with no
-        // uniqueness invariant. Do NOT hand out `&'static mut` here — multiple
+        // A raw pointer with no uniqueness invariant. Do NOT hand out
+        // `&'static mut` here — multiple
         // callers (resolver, sourcemap loader, worker threads) may hold the
         // result concurrently, and overlapping `&mut` is UB regardless of
         // whether either side writes.
@@ -104,10 +102,9 @@ impl StandaloneModuleGraph {
     }
 }
 
-// TODO(port): Zig `targetBasePublicPath(target, comptime suffix: [:0]const u8) [:0]const u8`
-// concatenates at comptime via `++`. A runtime `suffix: &[u8]` parameter cannot be
-// const-concatenated. All Zig callers pass either `""` or `"root/"`, so the runtime
-// variant special-cases those two literals.
+// A runtime `suffix: &[u8]` parameter cannot be
+// const-concatenated. All callers pass either `""` or `"root/"`, so the runtime
+// variant special-cases those two literals (`unreachable!` guards anything new).
 pub fn target_base_public_path(
     target: bun_core::Environment::OperatingSystem,
     suffix: &'static [u8],
@@ -145,9 +142,9 @@ pub fn is_bun_standalone_file_path(str_: &[u8]) -> bool {
 }
 
 impl StandaloneModuleGraph {
-    // TODO(port): interior mutability — Zig returns `*File` and callers mutate
-    // `wtf_string` / `cached_blob`. Using `&mut self` here may force callers to
-    // hold `&mut StandaloneModuleGraph`; could switch to `UnsafeCell` fields.
+    // Callers mutate `wtf_string` / `cached_blob`, so these accessors take
+    // `&mut self`. Switching to `UnsafeCell` per-`File`
+    // fields would let read-only paths take `&self`; see the `Instance` note above.
     pub fn entry_point(&mut self) -> &mut File {
         &mut self.files.values_mut()[self.entry_point_id as usize]
     }
@@ -185,10 +182,10 @@ impl StandaloneModuleGraph {
 // startup, never freed). The raw-pointer / `Cell` fields it carries are
 // `bun_runtime`-owned caches (`cached_blob`, `wtf_string`, source-map state)
 // that are only ever touched from the JS main thread under the API lock; the
-// resolver-facing read path below touches none of them. Zig stored this as a
-// plain `*StandaloneModuleGraph` shared across worker threads with no
-// synchronization; mirror that here so the `Send + Sync` supertrait on
-// `bun_resolver::StandaloneModuleGraph` is satisfied.
+// resolver-facing read path below touches none of them. The graph pointer is
+// shared across worker threads through the resolver, which is why the
+// `Send + Sync` supertrait on `bun_resolver::StandaloneModuleGraph` must be
+// satisfied.
 unsafe impl Send for StandaloneModuleGraph {}
 // SAFETY: see `Send` impl — post-init mutation is confined to per-`File` lazy caches on the JS thread.
 unsafe impl Sync for StandaloneModuleGraph {}
@@ -278,9 +275,10 @@ pub enum ModuleFormat {
 
 #[cfg(target_os = "macos")]
 mod macho {
-    // TODO(port): move to standalone_graph_sys
+    // Declared inline rather than in a dedicated `*_sys` crate: this crate is
+    // the symbol's only consumer.
     unsafe extern "C" {
-        pub(super) fn Bun__getStandaloneModuleGraphMachoLength() -> *mut u64; // align(1) in Zig
+        pub(super) fn Bun__getStandaloneModuleGraphMachoLength() -> *mut u64; // possibly unaligned
     }
 
     /// Returns `(base, len)` for the embedded `__BUN` section data. Kept as a
@@ -334,7 +332,8 @@ mod pe {
 
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
 mod elf {
-    // TODO(port): move to standalone_graph_sys
+    // Declared inline rather than in a dedicated `*_sys` crate: this crate is
+    // the symbol's only consumer.
     unsafe extern "C" {
         pub(super) fn Bun__getStandaloneModuleGraphELFVaddr() -> *mut u64; // align(1)
     }
@@ -424,8 +423,6 @@ impl File {
         // We don't want this to free.
         self.wtf_string.dupe_ref()
     }
-
-    // TODO(port): move to *_jsc — `pub const blob = @import("../runtime/api/standalone_graph_jsc.zig").fileBlob;`
 }
 
 pub enum LazySourceMap {
@@ -457,13 +454,13 @@ impl LazySourceMap {
                 let ism = SourceMap::InternalSourceMap {
                     data: blob.as_ptr(),
                 };
-                // PORT NOTE: `from_internal` fills `internal = Some(ism)` +
+                // Note: `from_internal` fills `internal = Some(ism)` +
                 // `input_line_count = ism.input_line_count()` and defaults the rest.
                 let mut stored = SourceMap::ParsedSourceMap::from_internal(ism);
 
                 let source_files_count = serialized.source_files_count();
-                // PERF(port): `external_source_names` is `Vec<Box<[u8]>>` so we
-                // copy the section bytes; Zig held a borrowed slice. Could switch
+                // PERF: `external_source_names` is `Vec<Box<[u8]>>` so we
+                // copy the section bytes. Could switch
                 // the field to `Vec<&'static [u8]>` for the standalone path.
                 let mut file_names: Vec<Box<[u8]>> = Vec::with_capacity(source_files_count);
                 let decompressed_contents_slice: Vec<Option<Vec<u8>>> =
@@ -489,16 +486,15 @@ impl LazySourceMap {
                 });
 
                 stored.external_source_names = file_names;
-                // Zig: `.underlying_provider = .{ .data = @truncate(@intFromPtr(data)) }`
-                // (kind = .zig, load_hint = .none implicit). `from_provider` packs the
-                // same triple into the `SourceContentPtr` bitfield.
+                // `from_provider` packs the pointer (plus implicit kind/load_hint)
+                // into the `SourceContentPtr` bitfield.
                 stored.underlying_provider = SourceMap::SourceContentPtr::from_provider(
                     bun_core::heap::into_raw(data).cast::<SourceMap::SourceProviderMap>(),
                 );
                 stored.is_standalone_module_graph = true;
 
                 let parsed = Arc::new(stored);
-                // PERF(port): Zig did parsed.ref() (intrusive) to never free; Arc clone held in self.
+                // The Arc clone held in self keeps the parsed map alive.
                 *self = LazySourceMap::Parsed(Arc::clone(&parsed));
                 Some(parsed)
             }
@@ -546,9 +542,9 @@ impl StandaloneModuleGraph {
             });
         }
 
-        // Zig's `raw_bytes: []u8` aliases freely — this function hands out read-only subslices
+        // This function hands out read-only subslices
         // (name/contents/sourcemap) AND writable subslices (bytecode/module_info, which JSC
-        // mutates in place) into the same allocation. In Rust we must not derive the writable
+        // mutates in place) into the same allocation. We must not derive the writable
         // ones from a `&[u8]` reborrow (writing through const-derived provenance is UB), and we
         // must not hold a long-lived `&[u8]` that *spans* a writable subrange (a foreign write
         // would invalidate it under Stacked/Tree Borrows). Keep `(raw_ptr, raw_len)` raw and
@@ -559,8 +555,7 @@ impl StandaloneModuleGraph {
         // SAFETY: modules metadata blob is a read-only subrange of `[0, raw_len)` disjoint
         // from bytecode/module_info, serialized by `to_bytes`.
         let modules_list_bytes = unsafe { slice_to(raw_const, raw_len, offsets.modules_ptr) };
-        // PORT NOTE: StandaloneModuleGraph.zig:309 builds `[]align(1) const CompiledModuleGraphFile`
-        // because the modules blob sits at an arbitrary byte offset in the section. In Rust,
+        // Note: the modules blob sits at an arbitrary byte offset in the section, and
         // `&[CompiledModuleGraphFile]` would require natural alignment (StringPointer's u32 fields
         // → 4-byte). We instead iterate by index and `read_unaligned` each fixed-size record into a
         // local (`CompiledModuleGraphFile` is `Copy`/POD), so no `&T` ever points at unaligned memory.
@@ -596,7 +591,6 @@ impl StandaloneModuleGraph {
                     slice_to_z(raw_const, raw_len, module.bytecode_origin_path),
                 )
             };
-            // PERF(port): was putAssumeCapacity
             let _ = modules.put(
                 name.as_bytes(),
                 File {
@@ -605,7 +599,9 @@ impl StandaloneModuleGraph {
                     contents,
                     sourcemap: if module.sourcemap.length > 0 {
                         LazySourceMap::Serialized(SerializedSourceMap {
-                            // TODO(port): @alignCast — alignment of source map bytes
+                            // `&[u8]` is align(1), and every structured read
+                            // from these bytes (header / StringPointer tables)
+                            // goes through `read_unaligned` in SerializedSourceMap.
                             bytes: sourcemap_bytes,
                         })
                     } else {
@@ -713,10 +709,8 @@ pub(crate) fn to_bytes(
     compile_exec_argv: &[u8],
     flags: Flags,
 ) -> Result<Vec<u8>, BunError> {
-    // TODO(port): bun_perf::PerfEvent::StandaloneModuleGraph_serialize — generated
-    // enum is still a `_Stub` placeholder; restore the trace call once the generator emits
-    // real variants.
-    // let _serialize_trace = bun_perf::trace(bun_perf::PerfEvent::StandaloneModuleGraph_serialize);
+    // RAII trace handle ends on drop.
+    let _serialize_trace = bun_perf::trace(bun_perf::PerfEvent::StandaloneModuleGraphSerialize);
 
     let mut entry_point_id: Option<usize> = None;
     let mut string_builder = bun_core::StringBuilder::default();
@@ -768,7 +762,6 @@ pub(crate) fn to_bytes(
 
     let mut source_map_header_list: Vec<u8> = Vec::new();
     let mut source_map_string_list: Vec<u8> = Vec::new();
-    // PERF(port): was arena bulk-free (source_map_arena)
 
     for output_file in output_files {
         if !output_file.output_kind.is_file_in_standalone_mode() {
@@ -856,11 +849,10 @@ pub(crate) fn to_bytes(
             break 'brk StringPointer::default();
         };
 
-        // PORT NOTE: Zig used `bun.sys.File.makeOpen` (open, on-fail mkdir parent +
-        // retry). `src/sys/File.rs` is still cfg-gated upstream, so the
-        // `make_open` body is inlined here against the live `bun_sys` stub
+        // Note: `src/sys/File.rs` is still cfg-gated upstream, so the
+        // `make_open` body (open, on-fail mkdir parent + retry) is inlined here
+        // against the live `bun_sys` stub
         // surface (`openat` / `make_path` / `File::write_all`).
-        // Zig: `if (comptime bun.Environment.is_canary or bun.Environment.isDebug)`
         if Environment::IS_CANARY || Environment::IS_DEBUG {
             if let Some(dump_code_dir) = bun_core::env_var::BUN_FEATURE_FLAG_DUMP_CODE.get() {
                 let mut path_buf = bun_paths::path_buffer_pool::get();
@@ -956,7 +948,6 @@ pub(crate) fn to_bytes(
         };
 
         if output_file.source_map_index != u32::MAX {
-            // PERF(port): Zig used defer clearRetainingCapacity + arena.reset(.retain_capacity)
             serialize_json_source_map_for_standalone(
                 &mut source_map_header_list,
                 &mut source_map_string_list,
@@ -969,13 +960,11 @@ pub(crate) fn to_bytes(
             source_map_header_list.clear();
             source_map_string_list.clear();
         }
-        // PERF(port): was appendAssumeCapacity
         modules.push(module);
     }
 
     // SAFETY: `CompiledModuleGraphFile` is `#[repr(C)]` POD with no padding-dependent
-    // invariants; reinterpreting its backing storage as bytes is the same as Zig's
-    // `std.mem.sliceAsBytes`.
+    // invariants; reinterpreting its backing storage as bytes is sound.
     let modules_as_bytes: &[u8] = unsafe {
         core::slice::from_raw_parts(
             modules.as_ptr().cast::<u8>(),
@@ -997,21 +986,29 @@ pub(crate) fn to_bytes(
     let _ = string_builder.append(offsets_as_bytes);
     let _ = string_builder.append(TRAILER);
 
-    // SAFETY: string_builder.ptr was set by allocate() above.
-    let output_bytes = unsafe {
-        core::slice::from_raw_parts_mut(string_builder.ptr.unwrap().as_ptr(), string_builder.len)
-    };
-
     #[cfg(debug_assertions)]
     {
-        // An expensive sanity check:
-        // TODO(port): from_bytes wants &'static mut; debug-only sanity check elided.
-        // let mut graph = StandaloneModuleGraph::from_bytes(output_bytes, offsets)?;
-        // debug_assert_eq!(graph.files.count(), modules.len());
+        // An expensive sanity check: round-trip
+        // the serialized bytes and verify the module count survives. The graph
+        // only borrows the builder's buffer transiently — it is unlocked and
+        // dropped before the buffer is moved out below.
+        let graph = StandaloneModuleGraph::from_bytes(
+            string_builder.ptr.unwrap().as_ptr(),
+            string_builder.len,
+            offsets,
+        )?;
+        debug_assert_eq!(graph.files.count(), modules.len());
+        graph.files.unlock_pointers();
     }
 
-    // TODO(port): StringBuilder owns the buffer; return it as Vec<u8>.
-    Ok(output_bytes.to_vec())
+    // StringBuilder owns the buffer; hand it back without copying. `cap` may
+    // exceed `len` (sourcemap capacity is over-estimated above), so truncate
+    // the reconstituted Vec down to the written prefix — the `[len, cap)` tail
+    // is never read.
+    let len = string_builder.len;
+    let mut output = string_builder.move_to_slice().into_vec();
+    output.truncate(len);
+    Ok(output)
 }
 
 pub(crate) type InjectOptions = WindowsOptions;
@@ -1070,14 +1067,14 @@ pub(crate) fn inject(
 ) -> Fd {
     let _ = inject_options;
     let mut buf = PathBuffer::uninit();
-    // PORT NOTE: `tmpname` borrows `buf` mutably for the &ZStr it returns. The
+    // Note: `tmpname` borrows `buf` mutably for the &ZStr it returns. The
     // tmpdir-fallback retry below may need to repoint `zname` at a heap-owned
     // buffer instead, so hoist that owner here so it outlives the loop.
     let mut zname_owned: Option<Box<[u8]>> = None;
     let mut zname: &ZStr = match bun_fs::FileSystem::tmpname(
         b"bun-build",
         &mut buf[..],
-        // i64 → u64 bitcast (Zig: `@bitCast`).
+        // i64 → u64 bitcast.
         bun_core::time::milli_timestamp() as u64,
     ) {
         Ok(n) => n,
@@ -1119,9 +1116,8 @@ pub(crate) fn inject(
             // retain the pointers past return.
             if unsafe { w::CopyFileW(in_buf.as_ptr(), out_buf.as_ptr(), w::FALSE) } == w::FALSE {
                 let e = w::Win32Error::get();
-                // Zig prints `@errorName(err)` (e.g. `AccessDenied`); map the
-                // Win32 code through the errno table so users see a name, not
-                // a raw integer.
+                // Map the Win32 code through the errno table so users see a
+                // name, not a raw integer.
                 bun_core::pretty_errorln!(
                     "<r><red>error<r><d>:<r> failed to copy bun executable into temporary file: {:?}",
                     e.to_system_errno()
@@ -1202,8 +1198,7 @@ pub(crate) fn inject(
                                         zname.as_bytes(),
                                         &[0],
                                     ]);
-                                    // PORT NOTE: Zig leaked the concat buffer here. PORTING.md
-                                    // §Forbidden bans `mem::forget`; the buffer is parked in
+                                    // Note: the concat buffer is parked in
                                     // `zname_owned` (declared at fn entry) so it outlives the
                                     // loop and drops at fn exit.
                                     let len = zname_z.len().saturating_sub(1);
@@ -1224,8 +1219,6 @@ pub(crate) fn inject(
                                 _ => break,
                             }
                         }
-                        // PORT NOTE: Zig falls through to `unreachable` on retry == 2; the
-                        // print+return above is dead code in Zig too (kept for diff parity).
                     }
                 }
             }
@@ -1309,8 +1302,6 @@ pub(crate) fn inject(
                 return Fd::INVALID;
             }
 
-            // PERF(port): Zig used writer.adaptToNewApi(&buffer) with a 512KB stack
-            // buffer. `std::io::BufWriter` heap-allocates the buffer instead.
             let mut buffered_writer = std::io::BufWriter::with_capacity(
                 512 * 1024,
                 bun_sys::FileWriter(cloned_executable_fd),
@@ -1519,8 +1510,8 @@ pub(crate) fn inject(
 use bun_core::Environment::OperatingSystem as CompileTargetOs;
 pub use bun_options_types::compile_target::CompileTarget;
 
-/// Port of `CompileTarget.downloadToPath` (CompileTarget.zig). Moved up from
-/// `bun_options_types` (T3) so it can name `bun_http::AsyncHTTP` directly
+/// Moved up from `bun_options_types` (T3) so it can name
+/// `bun_http::AsyncHTTP` directly
 /// instead of routing through `extern "Rust"` shims; the only callers are the
 /// two `download*` fns below in this crate.
 pub(crate) fn download_to_path(
@@ -1548,10 +1539,11 @@ pub(crate) fn download_to_path(
         let url_str_copy: Box<[u8]> = Box::from(url_str);
         let url = bun_url::URL::parse(&url_str_copy);
         {
-            // TODO(port): errdefer progress.end() — `start` returns `&mut Node`
-            // borrowing `refresher`, so a scopeguard capturing it would alias.
-            // Could reshape with a guard that re-borrows on drop.
-            // PORT NOTE: reshaped for borrowck — `get_http_proxy_for` borrows
+            // The unconditional
+            // `progress.end()` below is sufficient: no fallible call sits between
+            // `refresher.start` and it, so every exit path (including the
+            // error returns after it) ends the node exactly once.
+            // Note: reshaped for borrowck — `get_http_proxy_for` borrows
             // `env` for the proxy URL lifetime; read the bool first.
             let reject_unauthorized = env.get_tls_reject_unauthorized();
             let http_proxy: Option<bun_url::URL<'_>> = env.get_http_proxy_for(&url);
@@ -1601,7 +1593,7 @@ pub(crate) fn download_to_path(
             }
 
             {
-                // PORT NOTE: reshaped for borrowck — `refresher.start` borrows
+                // Note: reshaped for borrowck — `refresher.start` borrows
                 // `refresher` mutably; do gunzip work first, drive progress around it.
                 refresher.start(b"Decompressing", 0);
                 let gunzip_result = (|| -> Result<(), BunError> {
@@ -1696,7 +1688,6 @@ pub fn to_executable(
 ) -> Result<CompileResult, BunError> {
     #[cfg(windows)]
     let _ = root_dir;
-    // TODO(port): narrow error set
     let bytes = match to_bytes(
         module_prefix,
         output_files,
@@ -1717,9 +1708,8 @@ pub fn to_executable(
     }
     // bytes drops at end of scope
 
-    // PORT NOTE: Zig tracked `free_self_exe` to decide whether the slice was
-    // allocator-owned. `ZBox` always owns its bytes and drops on scope exit,
-    // so the flag is unnecessary.
+    // `ZBox` always owns its bytes and drops on scope exit, so no
+    // ownership flag is needed.
     let self_exe: bun_core::ZBox = if let Some(path) = self_exe_path {
         bun_core::ZBox::from_vec_with_nul(path.to_vec())
     } else if target.is_default() {
@@ -1781,11 +1771,10 @@ pub fn to_executable(
     };
 
     let fd = inject(&bytes, &self_exe, windows_options, target);
-    // PORT NOTE: Zig's `defer if (fd != invalid) fd.close()` reads `fd` at scope exit
-    // after later reassignments. A scopeguard closure capturing `fd` by value would not
-    // observe those writes; capturing by `&mut` conflicts with later uses. Explicit
+    // Note: a scopeguard closure capturing `fd` by value would not observe
+    // later reassignments; capturing by `&mut` conflicts with later uses. Explicit
     // `if fd != Fd::INVALID { fd.close(); }` calls are inserted at every return below
-    // (both error and success paths) to match Zig behavior.
+    // (both error and success paths).
     debug_assert!(fd.kind() == bun_sys::FdKind::System);
 
     #[cfg(unix)]
@@ -1854,7 +1843,7 @@ pub fn to_executable(
         // SAFETY: NUL-terminated wide strings constructed above. Pass the
         // full-buffer pointer (not a `[..len]` sub-slice) so the pointer's
         // provenance covers the trailing NUL at index `len` that the W-suffix
-        // API will read — matches Zig's `buf[0..len :0].ptr` sentinel slice.
+        // API will read.
         if unsafe {
             windows::kernel32::MoveFileExW(
                 temp_buf_u16.as_ptr(),
@@ -1919,7 +1908,7 @@ pub fn to_executable(
     #[cfg(not(windows))]
     {
         let mut buf2 = PathBuffer::uninit();
-        // PORT NOTE: borrowck — `get_fd_path` returns `&mut [u8]` borrowing `buf2`;
+        // Note: borrowck — `get_fd_path` returns `&mut [u8]` borrowing `buf2`;
         // copy it into an owned buffer so `temp_posix_buf` can also borrow `buf2`'s
         // sibling without overlap.
         let temp_location: Vec<u8> = match bun_sys::get_fd_path(fd, &mut buf2) {
@@ -2112,8 +2101,8 @@ impl StandaloneModuleGraph {
                 let end_unaligned = base as usize + len;
                 let end = (end_unaligned + page - 1) & !(page - 1);
 
-                // std.posix.madvise hits `unreachable` on unexpected errnos; this is a
-                // best-effort hint, so call libc directly and just log on failure.
+                // This is a best-effort hint, so call libc madvise directly and
+                // just log on failure rather than treating errors as fatal.
                 // SAFETY: start..end covers a mapped range of the executable image.
                 let rc = unsafe {
                     libc::madvise(
@@ -2191,8 +2180,7 @@ impl SerializedSourceMap {
         Some(&self.bytes[start..][..head.map_bytes_length as usize])
     }
 
-    // PORT NOTE: Zig types these arrays as `[]align(1) const StringPointer` because the
-    // serialized byte buffer carries no alignment guarantee. Materializing a Rust
+    // Note: the serialized byte buffer carries no alignment guarantee. Materializing a
     // `&[StringPointer]` would require `align_of::<StringPointer>() == 4` alignment
     // (UB otherwise), so expose count + indexed unaligned reads instead.
 
@@ -2230,8 +2218,7 @@ pub(crate) fn serialize_json_source_map_for_standalone(
 ) -> Result<(), BunError> {
     use bun_ast::ExprData as AstData;
 
-    // PERF(port): Zig threaded an arena allocator through; here we own a local
-    // bump arena and drop it on return (matches `defer arena.free`).
+    // We own a local bump arena and drop it on return.
     let arena = bun_alloc::Arena::new();
 
     let json_src = bun_ast::Source::init_path_string("sourcemap.json", json_source);
@@ -2358,5 +2345,3 @@ pub(crate) fn serialize_json_source_map_for_standalone(
     debug_assert!(header_list.len() == string_payload_start_location);
     Ok(())
 }
-
-// ported from: src/standalone_graph/StandaloneModuleGraph.zig
diff --git a/src/sys/Error.rs b/src/sys/Error.rs
index 19b894a31c8..ff5ded7e564 100644
--- a/src/sys/Error.rs
+++ b/src/sys/Error.rs
@@ -34,9 +34,8 @@ pub struct Error {
     pub fd: Fd,
     #[cfg(windows)]
     pub from_libuv: bool,
-    // TODO(port): in Zig these are borrowed `[]const u8` by default and only owned after
-    // `clone()`. Ported as Box<[u8]> per PORTING.md (deinit frees them); `with_path*` now
-    // eagerly clones. Revisit if profiling shows regressions.
+    // Box<[u8]> per PORTING.md; `with_path*` eagerly clones. Revisit if
+    // profiling shows regressions.
     pub path: Box<[u8]>,
     pub syscall: Tag,
     pub dest: Box<[u8]>,
@@ -56,14 +55,10 @@ impl Default for Error {
     }
 }
 
-// Zig `pub fn clone(this, allocator)` → covered by `#[derive(Clone)]` (allocator param dropped;
-// Box<[u8]> deep-copies on Clone, matching `allocator.dupe`).
+// `#[derive(Clone)]` deep-copies the Box<[u8]> fields; Box<[u8]> frees on Drop.
 
-// Zig `pub fn deinit` / `deinitWithAllocator` → dropped; Box<[u8]> frees on Drop. Only valid to
-// rely on this for owned (cloned) Errors — same caveat as the Zig comment.
-
-/// Anything that names an OS errno value. Replaces Zig's `anytype errno` in
-/// `Error.fromCode`/`Error.new`.
+/// Anything that names an OS errno value. Used by
+/// `Error::from_code`/`Error::new`.
 pub trait IntoErrnoInt {
     fn into_errno_int(self) -> Int;
 }
@@ -91,10 +86,9 @@ impl IntoErrnoInt for u16 {
 impl IntoErrnoInt for i32 {
     #[inline]
     fn into_errno_int(self) -> Int {
-        // PORT NOTE: matches Error.zig fromCodeInt:
-        // `@intCast(if (Environment.isWindows) @abs(errno) else errno)` — only Windows
+        // Only Windows
         // (libuv negative codes) takes the absolute value; on POSIX a negative errno is
-        // a caller bug and `@intCast` would trap in safe builds, so panic here too.
+        // a caller bug, so panic.
         #[cfg(windows)]
         {
             self.unsigned_abs() as Int
@@ -107,9 +101,7 @@ impl IntoErrnoInt for i32 {
 }
 
 impl Error {
-    /// `Error::new(errno, tag)` — Windows-only call sites in `sys/lib.rs` and
-    /// `sys_uv.rs` were ported from `Maybe(T).errEnum`/`.errno`, which in Zig
-    /// accept `anytype` for the code. Dispatch via `IntoErrnoInt` so a single
+    /// `Error::new(errno, tag)` — dispatches via `IntoErrnoInt` so a single
     /// constructor covers `E`, `SystemErrno`, raw `u16` (libuv `ReturnCode::errno`)
     /// and `i32`.
     #[inline]
@@ -123,8 +115,7 @@ impl Error {
 
     /// `Some(err)` when a libuv `ReturnCode` is negative; `None` on success.
     /// `ReturnCode::errno()` already maps the `UV_E*` code to the POSIX `E`
-    /// discriminant, so `from_libuv` stays at its default `false` (matches Zig
-    /// `ReturnCode.toError`, libuv.zig).
+    /// discriminant, so `from_libuv` stays at its default `false`.
     #[cfg(windows)]
     #[inline]
     pub fn from_uv_rc(rc: crate::windows::libuv::ReturnCode, syscall_tag: Tag) -> Option<Error> {
@@ -136,8 +127,7 @@ impl Error {
     }
 
     /// `Some(err)` when a libuv `ReturnCodeI64` is negative; `None` on success.
-    /// Matches Zig `ReturnCodeI64.toError` (libuv.zig): `from_libuv` left at
-    /// default `false`.
+    /// `from_libuv` left at default `false`.
     #[cfg(windows)]
     #[inline]
     pub fn from_uv_rc64(
@@ -159,7 +149,7 @@ impl Error {
         }
     }
 
-    // TODO(port): Zig took `errno: anytype`; narrowed to c_int (covers all call sites in practice).
+    // c_int covers all call sites in practice.
     pub fn from_code_int(errno: c_int, syscall_tag: Tag) -> Error {
         #[cfg(windows)]
         let n = Int::try_from(errno.unsigned_abs()).unwrap();
@@ -174,13 +164,13 @@ impl Error {
 
     #[inline]
     pub fn get_errno(&self) -> E {
-        // Zig `@enumFromInt` is unchecked, but in Rust transmuting an out-of-range discriminant
+        // Transmuting an out-of-range discriminant
         // (e.g. TODO_ERRNO = u16::MAX-1) into a #[repr(u16)] enum is immediate UB. Use the checked
         // discriminant constructor and fall back to SUCCESS for unmapped values.
         #[cfg(windows)]
         {
-            // `self.errno` already stores an E/SystemErrno *discriminant* (set via `E as Int`).
-            // Zig does `@as(E, @enumFromInt(this.errno))` — a direct discriminant cast. Do NOT
+            // `self.errno` already stores an E/SystemErrno *discriminant* (set via `E as Int`),
+            // so a direct discriminant cast is what's wanted. Do NOT
             // route through `SystemErrno::init`: on Windows its u16/i32 entry points are the
             // Win32/WSA/uv-error→errno *mapper*, not a discriminant validator, and would
             // corrupt the value (e.g. EPERM=1 → Win32 INVALID_FUNCTION → EISDIR).
@@ -197,8 +187,8 @@ impl Error {
         self.get_errno() == E::EAGAIN
     }
 
-    // TODO(port): was `pub const oom` in Zig; Box<[u8]> fields prevent a true `const` item.
-    /// `bun.sys.Error.oom` — `ENOMEM` with no syscall context.
+    /// `bun.sys.Error.oom` — `ENOMEM` with no syscall context. (The `Box<[u8]>`
+    /// fields prevent a true `const` item.)
     #[inline]
     pub fn oom() -> Error {
         Error {
@@ -208,7 +198,8 @@ impl Error {
         }
     }
 
-    // TODO(port): was `pub const retry` in Zig; Box<[u8]> fields prevent a true `const` item.
+    /// `bun.sys.Error.retry`. (The `Box<[u8]>`
+    /// fields prevent a true `const` item.)
     #[inline]
     pub fn retry() -> Error {
         Error {
@@ -229,14 +220,13 @@ impl Error {
         }
     }
 
-    // Zig accepted `path: anytype` (slice or `[*:0]const u8`) and ran `bun.span`; the
-    // `@compileError` rejecting `u16` paths is enforced here by the `&[u8]` parameter type.
+    // The `&[u8]` parameter type rejects `u16` paths at compile time.
     #[inline]
     pub fn with_path(&self, path: &[u8]) -> Error {
         Error {
             errno: self.errno,
             syscall: self.syscall,
-            // PERF(port): Zig borrowed the slice; we clone into Box — profile if hot.
+            // PERF: clones the slice into a Box — profile if hot.
             path: Box::from(path),
             ..Default::default()
         }
@@ -247,14 +237,14 @@ impl Error {
         Error {
             errno: self.errno,
             syscall: syscall_,
-            // PERF(port): Zig borrowed the slice; we clone into Box — profile if hot.
+            // PERF: clones the slice into a Box — profile if hot.
             path: Box::from(path),
             ..Default::default()
         }
     }
 
-    /// Rust-only (no Zig `withDest`). Unlike `with_path`/`with_path_dest` (which
-    /// match Zig and reset `fd`/`from_libuv`), this only overlays `dest` and
+    /// Unlike `with_path`/`with_path_dest` (which
+    /// reset `fd`/`from_libuv`), this only overlays `dest` and
     /// preserves every other field — chained on a libuv-sourced error
     /// (`from_libuv=true`, errno in the 4000-range) it must keep `from_libuv`
     /// so `name()`/`msg()` still route through the uv→errno mapper.
@@ -276,7 +266,7 @@ impl Error {
         Error {
             errno: self.errno,
             syscall: self.syscall,
-            // PERF(port): Zig borrowed the slices; we clone into Box — profile if hot.
+            // PERF: clones the slices into Boxes — profile if hot.
             path: Box::from(path),
             dest: Box::from(dest),
             ..Default::default()
@@ -300,8 +290,7 @@ impl Error {
     }
 
     /// Decode `self.errno` (+ `from_libuv` on Windows) into a validated `SystemErrno`.
-    /// Shared by `name()` / `get_error_code_tag_name()`; replaces Zig's unchecked
-    /// `@setRuntimeSafety(false) + @enumFromInt` with a fallible discriminant lookup.
+    /// Shared by `name()` / `get_error_code_tag_name()`; a fallible discriminant lookup.
     #[inline]
     fn resolve_system_errno(&self) -> Option<SystemErrno> {
         #[cfg(windows)]
@@ -309,7 +298,7 @@ impl Error {
             if self.from_libuv {
                 // `self.errno` is the positive `UV_E*` magnitude; negate back to the signed
                 // uv code, map to `E`, then to `SystemErrno` via the shared #[repr(u16)]
-                // discriminant table (Zig: `@enumFromInt(@intFromEnum(...))`).
+                // discriminant table.
                 let translated = crate::windows::translate_uv_error_to_e(-c_int::from(self.errno));
                 return Some(SystemErrno::from_raw(translated as u16));
             }
@@ -349,9 +338,8 @@ impl Error {
 
     pub fn msg(&self) -> Option<&'static [u8]> {
         let (_code, system_errno) = self.get_error_code_tag_name()?;
-        // PORT NOTE: Zig wraps this in `if (map.get(e)) |label|` with a `return code`
-        // fallback, but both error maps are `initFull("unknown error")` so `.get()`
-        // never returns null; the fallback is dead code in Zig too.
+        // Both error maps are total (`initFull("unknown error")`), so the
+        // lookup always yields a label.
         Some(coreutils_error_map::COREUTILS_ERROR_MAP[system_errno].as_bytes())
     }
 
@@ -370,8 +358,7 @@ impl Error {
             ..Default::default()
         };
 
-        // PORT NOTE: both maps are total (`initFull("unknown error")`); Zig's optional
-        // unwrap on `.get()` is never null.
+        // both maps are total (`initFull("unknown error")`).
         let looked_up = self.get_error_code_tag_name().map(|(code, system_errno)| {
             err.code = BunString::static_(code.as_bytes());
             (code, map[system_errno])
@@ -505,10 +492,8 @@ impl fmt::Display for Error {
     }
 }
 
-// Zig re-exported `toJS` / `toJSWithAsyncStack` / `TestingAPIs` from `../sys_jsc/error_jsc.zig`.
-// Per PORTING.md these become extension-trait methods in the `bun_sys_jsc` crate; deleted here.
-
-// ported from: src/sys/Error.zig
+// `toJS` / `toJSWithAsyncStack` / `TestingAPIs` live as extension-trait
+// methods in the `bun_sys_jsc` crate per PORTING.md.
 
 // ──────────────────────────────────────────────────────────────────────────
 // `bun_core::output::ErrName` impls — orphan rule lets the higher tier (sys)
@@ -527,8 +512,7 @@ impl bun_core::output::ErrName for Error {
     }
 }
 // `&Error` — lets callers print-then-propagate without a clone
-// (`Output::err(&e, …); return Err(e.into())`), matching Zig's
-// `Output.err(err, …); return err` where `err` is Copy.
+// (`Output::err(&e, …); return Err(e.into())`).
 impl bun_core::output::ErrName for &Error {
     fn name(&self) -> &[u8] {
         Error::name(self)
@@ -539,18 +523,17 @@ impl bun_core::output::ErrName for &Error {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `ReturnCodeExt` — Zig's `ReturnCode::toError(.tag) ?Error` lives here (not
+// `ReturnCodeExt` — `ReturnCode::to_error(tag) -> Option<Error>` lives here (not
 // in `bun_libuv_sys`) because `Error`/`Tag` are higher-tier types.
 // ──────────────────────────────────────────────────────────────────────────
 #[cfg(windows)]
 pub trait ReturnCodeExt: Sized {
-    /// `Some(err)` when negative; `None` on success. Mirrors Zig
-    /// `ReturnCode.toError` — `from_libuv` stays at default `false`.
+    /// `Some(err)` when negative; `None` on success.
+    /// `from_libuv` stays at default `false`.
     fn to_error(self, syscall_tag: Tag) -> Option<Error>;
-    /// `Maybe(void)`-shape adapter: `Ok(())` on success, `Err` on negative rc.
-    /// Mirrors Zig's libuv wrappers (`Pipe.init` etc.) that hand back
-    /// `bun.sys.Maybe(void)` directly — `bun_libuv_sys` returns the raw
-    /// `ReturnCode` for layering, this trait promotes it.
+    /// `Ok(())` on success, `Err` on negative rc.
+    /// `bun_libuv_sys` returns the raw
+    /// `ReturnCode` for layering; this trait promotes it.
     #[inline]
     fn to_result(self, syscall_tag: Tag) -> crate::Result<()> {
         match self.to_error(syscall_tag) {
@@ -558,16 +541,14 @@ pub trait ReturnCodeExt: Sized {
             None => Ok(()),
         }
     }
-    /// Alias for [`to_error`]; spelling used by call sites that mirror Zig's
-    /// `Maybe(void).asErr()`.
+    /// Alias for [`to_error`].
     #[inline]
     fn as_err(self, syscall_tag: Tag) -> Option<Error> {
         self.to_error(syscall_tag)
     }
-    /// Zig: `rc.errEnum()` — translate the negative libuv errno to `bun.sys.E`.
+    /// Translate the negative libuv errno to `bun.sys.E`.
     /// `bun_libuv_sys::ReturnCode::err_enum()` only yields the raw `u16`
-    /// (layering: it can't name `E`); this overlay is what call sites that
-    /// mirror Zig's `req.result.errEnum()` actually want.
+    /// (layering: it can't name `E`); this overlay yields the typed enum.
     fn err_enum_e(self) -> Option<crate::E>;
 }
 #[cfg(windows)]
diff --git a/src/sys/PosixStat.rs b/src/sys/PosixStat.rs
index a8c583c8119..96ec1d31e82 100644
--- a/src/sys/PosixStat.rs
+++ b/src/sys/PosixStat.rs
@@ -42,8 +42,7 @@ mod to_u64_impl {
         impl ToU64 for $t {
             #[inline]
             fn to_u64(self) -> u64 {
-                // SAFETY-equivalent of Zig `@bitCast(@as(i64, value))`:
-                // sign-extend to i64, then reinterpret bits as u64.
+                // Sign-extend to i64, then reinterpret bits as u64.
                 self as i64 as u64
             }
         }
@@ -66,15 +65,14 @@ fn to_u64<T: to_u64_impl::ToU64>(value: T) -> u64 {
     to_u64_impl::ToU64::to_u64(value)
 }
 
-/// Platform-specific accessors over `libc::stat` mirroring Zig's
-/// `Stat.atime()` / `.mtime()` / `.ctime()` / `.birthtime()` helpers.
+/// Platform-specific accessors over `libc::stat`:
+/// atime / mtime / ctime / birthtime helpers.
 /// Exported so callers (e.g. `bunx_command.rs`) can read times off the bare
 /// `bun_sys::Stat` (= `libc::stat`) without re-deriving the per-platform field
 /// names.
 // NOTE: the `libc` crate flattens Darwin/BSD `st_*timespec` into `st_*time` +
 // `st_*time_nsec` (matching Linux), so the field access is uniform across all
-// `unix` targets. The Zig std uses the nested `timespec` form; this is a
-// deliberate divergence at the libc-crate layer, not a port bug.
+// `unix` targets.
 #[inline]
 pub fn stat_atime(s: &Stat) -> Timespec {
     #[cfg(unix)]
@@ -128,7 +126,7 @@ pub fn stat_ctime(s: &Stat) -> Timespec {
 }
 #[inline]
 pub fn stat_birthtime(s: &Stat) -> Timespec {
-    // Zig spec: `if (Environment.isLinux) bun.timespec.epoch else stat_.birthtime()`.
+    // Linux gets the epoch arm; everything else reads the real birthtime.
     // Windows `Stat` is `uv_stat_t` and libuv fills `birthtim` from NTFS
     // CreationTime, so it must NOT fall into the epoch arm.
     #[cfg(windows)]
@@ -233,5 +231,3 @@ impl PosixStat {
         self.birthtim
     }
 }
-
-// ported from: src/sys/PosixStat.zig
diff --git a/src/sys/SignalCode.rs b/src/sys/SignalCode.rs
index f94c90b092a..eaa05427550 100644
--- a/src/sys/SignalCode.rs
+++ b/src/sys/SignalCode.rs
@@ -2,9 +2,9 @@ use core::fmt;
 
 use bun_core::output;
 
-// PORT NOTE: Zig `enum(u8) { ..., _ }` is non-exhaustive — any u8 is a valid
+// Any u8 is a valid
 // inhabitant. A Rust `#[repr(u8)] enum` with only the named variants would be
-// UB for the `from()` path (which accepts arbitrary bytes), so this is ported
+// UB for the `from()` path (which accepts arbitrary bytes), so this is modeled
 // as a transparent newtype with associated consts.
 #[repr(transparent)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
@@ -81,11 +81,11 @@ impl SignalCode {
     }
 
     pub fn from<T: bytemuck::NoUninit>(value: T) -> SignalCode {
-        // Zig `std.mem.asBytes(&value)[0]` — view `value` as bytes and read the
+        // View `value` as bytes and read the
         // first one. `NoUninit` guarantees `T` is `Copy` with no padding/uninit
         // bytes, so `bytemuck::bytes_of` is the safe equivalent of the raw
         // `*(&raw const value).cast::<u8>()` reinterpret. A ZST `T` panics on
-        // the `[0]` index (was UB before); all callers pass integer types.
+        // the `[0]` index; all callers pass integer types.
         SignalCode(bytemuck::bytes_of(&value)[0])
     }
 
@@ -112,11 +112,8 @@ pub struct Fmt {
 impl fmt::Display for Fmt {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let signal = self.signal;
-        // PERF(port): was comptime bool dispatch (`switch inline else`) — profile if it shows up on a hot path
         if let Some(str_) = signal.name() {
             if let Some(desc) = signal.description() {
-                // TODO(port): Output.prettyFmt("{s} <d>({s})<r>", enable_ansi_colors) —
-                // use bun_core::output's pretty-fmt helper once available.
                 if self.enable_ansi_colors {
                     return write!(f, "{} {}({}){}", str_, output::DIM, desc, output::RESET);
                 } else {
@@ -128,8 +125,4 @@ impl fmt::Display for Fmt {
     }
 }
 
-// NOTE: `pub const fromJS = @import("../sys_jsc/signal_code_jsc.zig").fromJS;`
-// deleted per porting guide — `from_js` lives as an extension-trait method in
-// the `bun_sys_jsc` crate.
-
-// ported from: src/sys/SignalCode.zig
+// NOTE: `from_js` lives as an extension-trait method in the `bun_sys_jsc` crate.
diff --git a/src/sys/copy_file.rs b/src/sys/copy_file.rs
index 60ec803c55f..843fea1298d 100644
--- a/src/sys/copy_file.rs
+++ b/src/sys/copy_file.rs
@@ -10,13 +10,11 @@ use crate::Fd;
 #[cfg(not(any(target_os = "linux", target_os = "android")))]
 use crate::Tag;
 
-// PORT NOTE: Zig was `const debug = bun.Output.scoped(.copy_file, .hidden)`.
 // `declare_scope!` uses the ident as both static name AND tag string, but
 // `copy_file` would shadow `pub fn copy_file()` below. Hand-expand with the
-// correct env-var tag and a non-colliding static name.
-// TODO(port): `scoped_log!` stringifies its scope ident for the `[tag]`
-// prefix, so log lines show `[debug]` instead of `[copy_file]`; fix when
-// `scoped_log!` grows a path/expr arm.
+// correct env-var tag and a non-colliding static name. (`scoped_log!` reads
+// the `[tag]` prefix from `ScopedLogger::tagname` at runtime, so log lines
+// still show `[copy_file]`.)
 static debug: bun_core::output::ScopedLogger =
     bun_core::output::ScopedLogger::new("copy_file", bun_core::output::Visibility::Hidden);
 
@@ -24,7 +22,7 @@ static debug: bun_core::output::ScopedLogger =
 pub type InputType<'a> = &'a bun_core::WStr; // bun.OSPathSliceZ == [:0]const u16
 #[cfg(not(windows))]
 pub type InputType<'a> = Fd;
-// PORT NOTE: lifetime param is unused on posix (Fd is Copy); kept so callers
+// lifetime param is unused on posix (Fd is Copy); kept so callers
 // can write `InputType<'_>` uniformly across platforms.
 
 // In a `bun install` with prisma, this reduces the system call count from ~18,000 to ~12,000
@@ -47,7 +45,7 @@ pub type InputType<'a> = Fd;
 //
 // on macOS and other platforms, sendfile() only works when one of the ends is a socket
 // and in general on macOS, it doesn't seem to have much performance impact.
-// PORT NOTE: `packed struct(u8)` with all-bool fields → bitflags!; field reads/writes
+// `packed struct(u8)` with all-bool fields → bitflags!; field reads/writes
 // reshaped to `.contains()`/`.insert()` below.
 bitflags::bitflags! {
     #[derive(Clone, Copy, PartialEq, Eq)]
@@ -131,7 +129,7 @@ pub fn copy_file_with_state(
                 // Don't worry about EINTR here.
                 E::EINTR => {}
 
-                // PORT NOTE: Zig matched .OPNOTSUPP; on Linux EOPNOTSUPP == ENOTSUP.
+                // On Linux EOPNOTSUPP == ENOTSUP.
                 E::EACCES | E::EBADF | E::EINVAL | E::ENOTSUP | E::ENOSYS | E::EPERM => {
                     bun_core::scoped_log!(debug, "ioctl_ficlonerange is NOT supported");
                     CAN_USE_IOCTL_FICLONE_.store(-1, Ordering::Relaxed);
@@ -266,7 +264,6 @@ pub fn can_use_copy_file_range_syscall() -> bool {
             return false;
         }
 
-        // Zig: `kernel.orderWithoutTag(.{ .major = 4, .minor = 5 }).compare(.gte)`
         if kernel_at_least(4, 5) {
             bun_core::scoped_log!(debug, "copy_file_range is supported");
             CAN_USE_COPY_FILE_RANGE.store(1, Ordering::Relaxed);
@@ -309,7 +306,6 @@ pub fn can_use_ioctl_ficlone() -> bool {
             return false;
         }
 
-        // Zig: `kernel.orderWithoutTag(.{ .major = 4, .minor = 5 }).compare(.gte)`
         if kernel_at_least(4, 5) {
             bun_core::scoped_log!(debug, "ioctl_ficlonerange is supported");
             CAN_USE_IOCTL_FICLONE_.store(1, Ordering::Relaxed);
@@ -324,7 +320,7 @@ pub fn can_use_ioctl_ficlone() -> bool {
     result == 1
 }
 
-// TODO(port): `fd_t` is `std.posix.fd_t` (c_int on posix, HANDLE on windows). Only the
+// Only the
 // posix paths call the fns below, so c_int is sufficient here.
 #[allow(non_camel_case_types)]
 type fd_t = core::ffi::c_int;
@@ -367,7 +363,7 @@ pub fn copy_file_range(
                     copy_file_state.insert(LinuxCopyFileState::HAS_COPY_FILE_RANGE_FAILED);
                 }
                 // syscall added in Linux 4.5, use fallback
-                // PORT NOTE: Zig matched .OPNOTSUPP; on Linux EOPNOTSUPP == ENOTSUP.
+                // On Linux EOPNOTSUPP == ENOTSUP.
                 E::ENOTSUP | E::ENOSYS => {
                     copy_file_state.insert(LinuxCopyFileState::HAS_COPY_FILE_RANGE_FAILED);
                     bun_core::scoped_log!(debug, "copy_file_range is NOT supported");
@@ -400,7 +396,7 @@ pub fn copy_file_range(
                 copy_file_state.insert(LinuxCopyFileState::HAS_SENDFILE_FAILED);
             }
             // they might not support it
-            // PORT NOTE: Zig matched .OPNOTSUPP; on Linux EOPNOTSUPP == ENOTSUP.
+            // On Linux EOPNOTSUPP == ENOTSUP.
             E::ENOTSUP | E::ENOSYS => {
                 copy_file_state.insert(LinuxCopyFileState::HAS_SENDFILE_FAILED);
             }
@@ -416,7 +412,7 @@ pub fn copy_file_range(
 }
 
 pub fn copy_file_read_write_loop(in_: fd_t, out: fd_t, len: usize) -> crate::Result<usize> {
-    // PERF(port): Zig used `undefined` (uninitialized) 32 KiB stack buffer — profile if it shows up on a hot path
+    // PERF: 32 KiB stack buffer is zero-initialized — profile if it shows up on a hot path
     let mut buf = [0u8; 8 * 4096];
     let adjusted_count = buf.len().min(len);
     match crate::read(Fd::from_native(in_ as _), &mut buf[0..adjusted_count]) {
@@ -447,15 +443,13 @@ pub fn copy_file_read_write_loop(in_: fd_t, out: fd_t, len: usize) -> crate::Res
 }
 
 /// `Platform.kernelVersion().orderWithoutTag(.{ major, minor }).compare(.gte)`.
-/// PORT NOTE: `bun_analytics::generate_header::Platform` (T6) is the canonical
+/// `bun_analytics::generate_header::Platform` (T6) is the canonical
 /// source; T1 routes through `bun_core::linux_kernel_version()` (TYPE_ONLY
-/// move-down) so this crate stays leaf. Compare matches Zig
-/// `std.SemanticVersion.orderWithoutTag` (lexicographic on major→minor→patch,
-/// patch defaults to 0 in the comparand).
+/// move-down) so this crate stays leaf. Compare is
+/// lexicographic on major→minor→patch,
+/// with patch defaulting to 0 in the comparand.
 #[inline]
 fn kernel_at_least(major: u32, minor: u32) -> bool {
     let v = bun_core::linux_kernel_version();
     (v.major, v.minor, v.patch) >= (major, minor, 0)
 }
-
-// ported from: src/sys/copy_file.zig
diff --git a/src/sys/coreutils_error_map.rs b/src/sys/coreutils_error_map.rs
index 74a89626a2d..8a1ccefb1d2 100644
--- a/src/sys/coreutils_error_map.rs
+++ b/src/sys/coreutils_error_map.rs
@@ -7,14 +7,12 @@ use crate::SystemErrno;
 /// This map is derived off of what coreutils uses in printing errors. This is
 /// equivalent to `strerror`, but as strings with constant lifetime.
 //
-// PORT NOTE: Zig builds this at comptime via `@hasField`/`@field` reflection over
-// `SystemErrno`. Rust has no struct-field reflection, so we build it once at first
-// access via `LazyLock`. The per-OS (name → message) string tables themselves
-// live canonically in `bun_core::coreutils_error_map` (a `phf::Map` keyed by
-// errno *name*); here we just project that table onto the platform's typed
-// `SystemErrno` enum so callers get an O(1) `EnumMap` index. Variants whose
-// names have no entry in the bun_core table fall back to `UNKNOWN`, matching
-// the Zig `@hasField` filter.
+// Built once at first access via `LazyLock`. The per-OS (name → message)
+// string tables themselves live canonically in
+// `bun_core::coreutils_error_map` (a `phf::Map` keyed by errno *name*); here
+// we just project that table onto the platform's typed `SystemErrno` enum so
+// callers get an O(1) `EnumMap` index. Variants whose names have no entry in
+// the bun_core table fall back to `UNKNOWN`.
 pub(crate) static COREUTILS_ERROR_MAP: LazyLock<EnumMap<SystemErrno, &'static str>> =
     LazyLock::new(|| {
         let map = EnumMap::from_fn(|errno: SystemErrno| {
@@ -33,9 +31,9 @@ pub(crate) static COREUTILS_ERROR_MAP: LazyLock<EnumMap<SystemErrno, &'static st
 /// from a real entry.
 pub(crate) const UNKNOWN: &str = "unknown error";
 
-/// Spec: Zig `coreutils_error_map.get(errno)` returns `?[]const u8`. The Rust
-/// `EnumMap` is total, so we treat the `UNKNOWN` sentinel as `None` to preserve
-/// the Zig fallthrough behaviour (callers format `"unknown error {errno}"`).
+/// The
+/// `EnumMap` is total, so we treat the `UNKNOWN` sentinel as `None` so callers
+/// can fall through (they format `"unknown error {errno}"`).
 #[inline]
 pub fn get(errno: SystemErrno) -> Option<&'static str> {
     let s = COREUTILS_ERROR_MAP[errno];
@@ -45,5 +43,3 @@ pub fn get(errno: SystemErrno) -> Option<&'static str> {
         Some(s)
     }
 }
-
-// ported from: src/sys/coreutils_error_map.zig
diff --git a/src/sys/dir.rs b/src/sys/dir.rs
index c3c1dc95c53..1b63424ae09 100644
--- a/src/sys/dir.rs
+++ b/src/sys/dir.rs
@@ -1,5 +1,4 @@
-//! `bun.sys.Dir` — directory handle + helpers. Port of the `Dir` half of
-//! `src/sys/sys.zig` (Zig: `bun.sys.Dir` ≈ `std.fs.Dir`).
+//! `bun.sys.Dir` — directory handle + helpers.
 //!
 //! Owns the descriptor; closes it on Drop (skipping `Fd::INVALID` and the
 //! `AT_FDCWD` sentinel). Use [`Dir::into_raw`] to hand the fd off,
@@ -21,15 +20,15 @@ impl Drop for Dir {
     }
 }
 
-/// Options for `Dir::copy_file` (Zig: `std.fs.Dir.CopyFileOptions`).
+/// Options for `Dir::copy_file`.
 #[derive(Clone, Copy, Default)]
 pub struct CopyFileOptions {
     /// When set, the destination is created with this mode instead of the
-    /// source file's mode (Zig: `override_mode: ?File.Mode`).
+    /// source file's mode.
     pub override_mode: Option<Mode>,
 }
 
-/// Options for `Dir::make_open_path` (Zig: `std.fs.Dir.OpenOptions`).
+/// Options for `Dir::make_open_path`.
 #[derive(Clone, Copy, Default)]
 pub struct OpenDirOptions {
     pub iterate: bool,
@@ -83,7 +82,7 @@ impl Dir {
         get_fd_path(self.fd, buf)
     }
     /// Close now. Equivalent to dropping `self` but discards the syscall
-    /// result (matches Zig's `Dir.close()`).
+    /// result.
     #[inline]
     pub fn close(self) {
         drop(self);
@@ -101,13 +100,13 @@ impl Dir {
         unsafe { &*(core::ptr::from_ref(fd).cast::<Dir>()) }
     }
 
-    /// `std.fs.Dir.makePath` — `mkdir -p` relative to this dir.
+    /// `mkdir -p` relative to this dir.
     #[inline]
     pub fn make_path(&self, sub_path: &[u8]) -> core::result::Result<(), bun_core::Error> {
         mkdir_recursive_at(self.fd, sub_path).map_err(Into::into)
     }
-    /// `std.fs.Dir.makeOpenPath` — try `openDir` first; on ENOENT, `makePath`
-    /// then `openDir` (Zig: vendor/zig/lib/std/fs/Dir.zig `makeOpenPath`).
+    /// Try opening the directory first; on ENOENT, `make_path`
+    /// then open it.
     pub fn make_open_path(
         &self,
         sub_path: &[u8],
@@ -124,10 +123,10 @@ impl Dir {
             Err(e) => Err(e.into()),
         }
     }
-    /// `std.fs.Dir.deleteTree` — recursive `rm -rf`. Port of Zig
-    /// `std.fs.Dir.deleteTree` (stack-based depth-first walk; std/fs/Dir.zig).
+    /// Recursive `rm -rf`
+    /// (stack-based depth-first walk).
     pub fn delete_tree(&self, sub_path: &[u8]) -> core::result::Result<(), bun_core::Error> {
-        // `deleteTreeOpenInitialSubpath` — try unlinking as a file first; if
+        // `delete_tree_open_initial_subpath` — try unlinking as a file first; if
         // that yields IsDir/EPERM, open it as an iterable directory.
         let initial = match self.delete_tree_open_initial_subpath(sub_path)? {
             Some(d) => d,
@@ -139,8 +138,7 @@ impl Dir {
             parent_dir: Fd,
             iter: dir_iterator::WrappedIterator,
         }
-        // Ensure every still-open iterator dir is closed on early return
-        // (Zig: `defer StackItem.closeAll(stack.items)`).
+        // Ensure every still-open iterator dir is closed on early return.
         let mut stack = scopeguard::guard(Vec::<StackItem>::with_capacity(16), |mut s| {
             for item in s.drain(..) {
                 let _ = close(item.iter.dir());
@@ -175,10 +173,7 @@ impl Dir {
                             },
                         };
                         let parent = top.iter.dir();
-                        // PORT NOTE: Zig caps the stack at 16 and falls back to
-                        // `deleteTreeMinStackSizeWithKindHint` past that depth. The
-                        // Rust `Vec` grows, so the capacity check is dropped — same
-                        // semantics, no fixed-depth limit.
+                        // The `Vec` grows as needed, so no fixed-depth limit.
                         stack.push(StackItem {
                             name: entry.name.slice_u8().to_vec(),
                             parent_dir: parent,
@@ -208,7 +203,7 @@ impl Dir {
             let parent_dir = top.parent_dir;
             let name = core::mem::take(&mut top.name);
             // Pop before closing so the cleanup guard doesn't double-close on
-            // an error from `unlinkat_a` (Zig: `stack.items.len -= 1`).
+            // an error from `unlinkat_a`.
             stack.pop();
             let _ = close(dir_fd);
 
@@ -259,7 +254,7 @@ impl Dir {
         Ok(())
     }
 
-    /// Port of `std.fs.Dir.deleteTreeOpenInitialSubpath` — try removing
+    /// Try removing
     /// `sub_path` as a file; on `EISDIR`/`EPERM` open it as an iterable
     /// directory and return the fd. Returns `None` when removal succeeded or
     /// the path doesn't exist.
@@ -306,7 +301,7 @@ pub const AT_REMOVEDIR: i32 = libc::AT_REMOVEDIR;
 #[cfg(windows)]
 pub const AT_REMOVEDIR: i32 = 0x200;
 
-/// sys.zig:2928 `rmdirat` — `unlinkat(dir, path, AT_REMOVEDIR)`.
+/// `rmdirat` — `unlinkat(dir, path, AT_REMOVEDIR)`.
 #[inline]
 pub fn rmdirat(dirfd: impl AsFd, path: &ZStr) -> Maybe<()> {
     let dirfd = dirfd.as_fd();
@@ -324,17 +319,17 @@ fn unlinkat_a(dirfd: Fd, path: &[u8], flags: i32) -> Maybe<()> {
     unlinkat_with_flags(dirfd, z, flags)
 }
 
-/// `std.fs.File.CreateFlags` — subset used by `Dir::createFileZ` callers
-/// (e.g. `repository.zig:649`, `PackageManagerDirectories.zig`).
+/// File-creation flags — subset used by `create_file_z` callers
+/// (e.g. the package-manager repository/directories code).
 #[derive(Clone, Copy, Default)]
 pub struct CreateFlags {
     pub truncate: bool,
-    /// Open for reading as well as writing (Zig: `read: bool = false`).
+    /// Open for reading as well as writing (defaults to false).
     pub read: bool,
 }
 
 impl Dir {
-    /// `std.fs.Dir.makeDir` — single-level `mkdirat` (mode 0o755) relative to
+    /// Single-level `mkdirat` (mode 0o755) relative to
     /// this dir. Unlike `make_path`, does NOT create intermediate directories
     /// and surfaces `error.PathAlreadyExists` for callers to branch on.
     pub fn make_dir(&self, sub_path: &[u8]) -> core::result::Result<(), bun_core::Error> {
@@ -351,9 +346,9 @@ impl Dir {
         }
     }
 
-    /// `std.fs.Dir.symLink` — `symlinkat(target, self.fd, link)`. The
-    /// `is_directory` flag is a no-op on POSIX (kept for parity with Zig's
-    /// `SymLinkFlags`); on Windows it selects junction vs. file-symlink and
+    /// `symlinkat(target, self.fd, link)`. The
+    /// `is_directory` flag is a no-op on POSIX;
+    /// on Windows it selects junction vs. file-symlink and
     /// callers route through `sys_uv::symlink_uv` instead.
     pub fn sym_link(
         &self,
@@ -378,8 +373,8 @@ impl Dir {
         symlinkat(tz, self.fd, lz).map_err(Into::into)
     }
 
-    /// `std.fs.Dir.createFileZ` — create (or truncate) `sub_path` relative to
-    /// this dir and return a `File` handle. Zig stdlib semantics: `O_CREAT`,
+    /// Create (or truncate) `sub_path` relative to
+    /// this dir and return a `File` handle: `O_CREAT`,
     /// `O_WRONLY` (or `O_RDWR` if `flags.read`), `O_TRUNC` if `flags.truncate`.
     pub fn create_file_z(
         &self,
@@ -395,18 +390,18 @@ impl Dir {
         Ok(File::from_fd(fd))
     }
 
-    /// `std.fs.Dir.deleteFileZ` — `unlinkat(self.fd, sub_path, 0)`.
+    /// `unlinkat(self.fd, sub_path, 0)`.
     #[inline]
     pub fn delete_file_z(&self, sub_path: &ZStr) -> core::result::Result<(), bun_core::Error> {
         unlinkat(self.fd, sub_path).map_err(Into::into)
     }
 
-    /// `std.fs.Dir.copyFile` — open `source_path` (relative to `self`), create
+    /// Open `source_path` (relative to `self`), create
     /// `dest_path` (relative to `dest_dir`) with `O_CREAT|O_TRUNC`, then stream
     /// the contents via [`copy_file`]. Mode is taken from the source's `fstat`
-    /// unless `options.override_mode` is set (Zig stdlib semantics, minus the
-    /// `AtomicFile` rename — Bun's only call site is `gitignore` → `.gitignore`
-    /// where atomicity isn't required).
+    /// unless `options.override_mode` is set. No atomic-rename step —
+    /// Bun's only call site is `gitignore` → `.gitignore`
+    /// where atomicity isn't required.
     pub fn copy_file(
         &self,
         source_path: &[u8],
@@ -443,8 +438,8 @@ impl Dir {
         r.map_err(Into::into)
     }
 
-    /// `std.fs.Dir.openDirZ` — open `sub_path` (NUL-terminated) relative to
-    /// this dir as a `Dir` handle. Zig stdlib semantics: `O_DIRECTORY |
+    /// Open `sub_path` (NUL-terminated) relative to
+    /// this dir as a `Dir` handle: `O_DIRECTORY |
     /// O_RDONLY | O_CLOEXEC` (handled by `open_dir_at`).
     #[inline]
     pub fn open_dir_z(&self, sub_path: &ZStr) -> core::result::Result<Dir, bun_core::Error> {
@@ -453,13 +448,15 @@ impl Dir {
             .map_err(Into::into)
     }
 
-    /// `std.fs.Dir.openDir(sub_path, .{ .iterate, .no_follow, .access_sub_paths = true })`.
+    /// Open `sub_path` as an iterable, no-follow `Dir` handle with sub-path
+    /// access.
     ///
-    /// On POSIX, `iterate` / `access_sub_paths` are advisory (stdlib opens with
-    /// `O_DIRECTORY | O_RDONLY | O_CLOEXEC` regardless). On Windows the flags
-    /// select the access mask: `iterate` adds `FILE_LIST_DIRECTORY`, and the
-    /// handle is opened **without** `read_only` so the caller may create/rename
-    /// children — matching `std.fs.Dir.openDir`, *not* `bun.openDir`.
+    /// On POSIX, `iterate` / `access_sub_paths` are advisory (the handle is
+    /// opened with `O_DIRECTORY | O_RDONLY | O_CLOEXEC` regardless). On Windows
+    /// the flags select the access mask: `iterate` adds `FILE_LIST_DIRECTORY`,
+    /// and the handle is opened **without** `read_only` so the caller may
+    /// create/rename children — unlike the read-only `open_dir_*` iteration
+    /// helpers.
     #[inline]
     pub fn open_dir(
         &self,
diff --git a/src/sys/fd.rs b/src/sys/fd.rs
index 38e74fd73e5..22ac4f10b0e 100644
--- a/src/sys/fd.rs
+++ b/src/sys/fd.rs
@@ -7,17 +7,16 @@ use core::fmt;
 // bun_core. This file adds the syscall-touching surface as an extension trait.
 pub use bun_core::{Fd, FdKind, FdNative, FdOptional as Optional, Stdio, fd};
 /// Platform-native fd integer (`c_int` on POSIX, `HANDLE` on Windows). Alias
-/// for callers porting Zig's `std.posix.fd_t` / `bun.FD.native()`.
+/// for callers that want the `bun.FD.native()` shape.
 pub type RawFd = FdNative;
 #[cfg(windows)]
 pub use bun_core::DecodeWindows;
 
 use crate as sys;
 
-// `log` in the Zig is `bun.sys.syslog`
 bun_core::define_scoped_log!(log, SYS, visible);
 
-/// `std.posix.fd_t` — `c_int` on POSIX, `HANDLE` on Windows. Same as `FdNative`.
+/// Native fd backing int — `c_int` on POSIX, `HANDLE` on Windows. Same as `FdNative`.
 pub type FdT = FdNative;
 /// `bun.windows.libuv.uv_file` (c-runtime file descriptor); on POSIX this is also `c_int`.
 pub type UvFile = c_int;
@@ -38,8 +37,7 @@ bun_core::named_error_set!(MakeLibUvOwnedError);
 // ──────────────────────────────────────────────────────────────────────────
 // FdExt — syscall-touching methods on `bun_core::Fd`.
 //
-// In Zig these were inherent methods on `bun.FD` (Zig allows `pub const close
-// = bun.sys.close` aliasing). Rust can't impl inherent methods on a foreign
+// Rust can't impl inherent methods on a foreign
 // type, so they live behind an extension trait. Import via
 // `use bun_sys::FdExt;` at call sites; or call `bun_sys::close(fd)` directly.
 // ──────────────────────────────────────────────────────────────────────────
@@ -102,7 +100,7 @@ impl FdExt for Fd {
         let mut fd_fmt_buf = [0u8; 1050];
         #[cfg(debug_assertions)]
         let fd_fmt: &[u8] = {
-            // Zig: `std.fmt.bufPrint(&buf, "{f}", .{fd})` — stack slice, no heap.
+            // Stack slice, no heap.
             use std::io::Write as _;
             let mut cursor = std::io::Cursor::new(&mut fd_fmt_buf[..]);
             let _ = write!(cursor, "{}", self);
@@ -115,7 +113,7 @@ impl FdExt for Fd {
             {
                 debug_assert!(self.native() >= 0);
                 // Raw `SYS_close` via rustix — no glibc wrapper (which is a
-                // pthread cancellation point). fd.zig:266: never retry on EINTR.
+                // pthread cancellation point). Never retry on EINTR.
                 match sys::linux_syscall::close(self.native()) {
                     Err(e) if e == libc::EBADF => Some(sys::Error {
                         errno: sys::E::EBADF as _,
@@ -163,7 +161,7 @@ impl FdExt for Fd {
                         let rc = unsafe {
                             uv::uv_fs_close(uv::Loop::get(), &mut req, file_number, None)
                         };
-                        // Zig: `defer req.deinit();` — fs_t has no Drop impl, so cleanup
+                        // fs_t has no Drop impl, so cleanup
                         // must be explicit (uv_fs_req_cleanup).
                         req.deinit();
                         if let Some(errno) = rc.errno() {
@@ -252,7 +250,6 @@ impl FdExt for Fd {
 
     fn make_lib_uv_owned_for_syscall(
         self,
-        // PERF(port): was comptime monomorphization — profile if it shows up on a hot path
         syscall_tag: sys::Tag,
         error_case: ErrorCase,
     ) -> sys::Result<Fd> {
@@ -292,7 +289,7 @@ impl FdExt for Fd {
     #[inline]
     fn as_socket_fd(self) -> sys::SocketT {
         #[cfg(windows)]
-        // SAFETY: HANDLE → SOCKET pointer reinterpretation; matches Zig @ptrCast.
+        // SAFETY: HANDLE → SOCKET pointer reinterpretation; both are pointer-sized.
         {
             self.native() as sys::SocketT
         }
@@ -320,13 +317,12 @@ impl FdOptionalExt for Optional {
 // `*_jsc` aliases — deleted per PORTING.md; they live as extension-trait
 // methods in `bun_sys_jsc`.
 
-// `fromStdFile` / `fromStdDir` / `stdFile` / `stdDir` wrap `std.fs.File`/`Dir`.
-// TODO(port): no Rust equivalent (std::fs is banned). Callers use
+// There are deliberately no `std::fs::File`/`Dir` conversion helpers
+// (std::fs is banned). Callers use
 // `Fd::from_native(handle)` / `fd.native()` directly.
 
 // The following functions are from bun.sys but with the 'f' prefix dropped
-// where it is relevant. In Zig they are aliased onto `FD` as inherent methods.
-// In Rust, callers use the free fns in `bun_sys` directly:
+// where it is relevant. Callers use the free fns in `bun_sys` directly:
 //   chmod→fchmod, chmodat→fchmodat, chown→fchown, directoryExistsAt, dup,
 //   dupWithFlags, existsAt, existsAtType, fcntl, getFcntlFlags, getFileSize,
 //   linkat, linkatTmpfile, lseek, mkdirat, mkdiratA, mkdiratW, mkdiratZ,
@@ -336,10 +332,10 @@ impl FdOptionalExt for Optional {
 //   unlinkat, updateNonblocking, write, writeNonblocking, writev,
 //   getFdPath, getFdPathW, getFdPathZ.
 // TODO: move these methods defined in bun.sys.File to bun.sys, then delete
-// bun.sys.File. (Zig comment carried over.)
+// bun.sys.File.
 
 // ──────────────────────────────────────────────────────────────────────────
-// HashMapContext — identity hash for Fd keys (matches Zig).
+// HashMapContext — identity hash for Fd keys.
 // ──────────────────────────────────────────────────────────────────────────
 pub struct HashMapContext;
 impl HashMapContext {
@@ -378,7 +374,6 @@ impl Prehashed {
         if fd == self.input {
             return self.value;
         }
-        // Zig: `return fd;` — implicit coercion of FD (packed struct) to u64.
         HashMapContext::hash(fd)
     }
     #[inline]
@@ -516,5 +511,3 @@ pub(crate) fn uv_open_osfhandle(in_: *mut c_void) -> Result<c_int, MakeLibUvOwne
 // only; PORTING.md "move storage down"). `bun_sys` keeps the richer
 // `get_fd_path[_w]` returning `Maybe<&mut [u8/u16]>` for callers that want
 // `bun_sys::Error` with a syscall tag.
-
-// ported from: src/sys/fd.zig
diff --git a/src/sys/file.rs b/src/sys/file.rs
index 3c02a99a087..52b439639d2 100644
--- a/src/sys/file.rs
+++ b/src/sys/file.rs
@@ -1,4 +1,4 @@
-//! `bun.sys.File` — high-level file handle. Port of `src/sys/File.zig`.
+//! `bun.sys.File` — high-level file handle.
 //!
 //! Owns the descriptor; closes it on Drop (skipping `Fd::INVALID` and stdio
 //! so `File::stdin()`/`stdout()`/`stderr()` and default-constructed handles
@@ -23,9 +23,8 @@ impl Drop for File {
     }
 }
 
-/// Port of `bun.sys.File.ReadToEndResult` — `{ bytes, err? }` pair so
-/// callers can recover the partially-read buffer even on error (Zig
-/// returns the buffer regardless and tags `.err`).
+/// `{ bytes, err? }` pair so callers can recover the partially-read
+/// buffer even on error.
 #[derive(Default)]
 pub struct ReadToEndResult {
     pub bytes: Vec<u8>,
@@ -42,11 +41,9 @@ impl ReadToEndResult {
 }
 
 // `File` high-level helpers — wrap the syscall surface above.
-// Single consolidated `impl` block (Zig: src/sys/File.zig).
 impl File {
     // ── construction / identity ──────────────────────────────────────────
-    /// `File.from(fd)` — wrap an existing fd. Zig's `from(anytype)` overload
-    /// set collapses to this + the `From` impls below in Rust.
+    /// Wrap an existing fd. See also the `From` impls below.
     #[inline]
     pub fn from_fd(fd: Fd) -> Self {
         Self { handle: fd }
@@ -96,30 +93,28 @@ impl File {
     pub fn open(path: &ZStr, flags: i32, mode: Mode) -> Maybe<Self> {
         open(path, flags, mode).map(Self::from_fd)
     }
-    /// File.zig `openat` — accepts a non-sentinel `&[u8]` (Zig: `path: anytype`
-    /// dispatches to `openatA` for non-sentinel slices). `&ZStr` callers
+    /// `openat` accepting a non-sentinel `&[u8]`; `&ZStr` callers
     /// deref-coerce to `&[u8]`.
     pub fn openat(dir: impl AsFd, path: &[u8], flags: i32, mode: Mode) -> Maybe<Self> {
         let dir = dir.as_fd();
         openat_a(dir, path, flags, mode).map(Self::from_fd)
     }
-    /// snake_case alias (Zig: `File.openat`).
+    /// snake_case alias for [`File::openat`].
     #[inline]
     pub fn open_at(dir: impl AsFd, path: &[u8], flags: i32, mode: Mode) -> Maybe<Self> {
         let dir = dir.as_fd();
         Self::openat(dir, path, flags, mode)
     }
-    /// File.zig `makeOpen` — `openat` against cwd, auto-creating parent
+    /// `openat` against cwd, auto-creating parent
     /// directories on the first failure (mkdir -p of `dirname(path)`, then
     /// retry once).
     #[inline]
     pub fn make_open(path: &[u8], flags: i32, mode: Mode) -> Maybe<Self> {
         Self::make_openat(Fd::cwd(), path, flags, mode)
     }
-    /// File.zig `makeOpenat` — `openat`; on failure, `bun.makePath(dir, dirname(path))`
-    /// (errors from `makePath` are swallowed, matching `catch {}` in Zig) then
-    /// retry the open once. If `path` has no dirname, the original error is
-    /// returned.
+    /// `openat`; on failure, recursively create `dirname(path)` (errors from
+    /// the mkdir are swallowed) then retry the open once. If `path` has no
+    /// dirname, the original error is returned.
     pub fn make_openat(dir: impl AsFd, path: &[u8], flags: i32, mode: Mode) -> Maybe<Self> {
         let dir = dir.as_fd();
         match openat_a(dir, path, flags, mode) {
@@ -133,21 +128,20 @@ impl File {
             }
         }
     }
-    /// `std.fs.cwd().createFile(path, .{ .truncate })` replacement.
+    /// Create a file at `path` relative to `dir`, optionally truncating.
     pub fn create(dir: impl AsFd, path: &[u8], truncate: bool) -> Maybe<Self> {
         let dir = dir.as_fd();
         let flags = O::WRONLY | O::CREAT | O::CLOEXEC | if truncate { O::TRUNC } else { 0 };
         openat_a(dir, path, flags, 0o666).map(Self::from_fd)
     }
-    /// `std.fs.cwd().createFileW(path, .{})` replacement (Windows wide-path).
-    /// Default `.{}` in Zig means `.truncate = true, .read = false`.
+    /// Windows wide-path variant of [`File::create`] (truncating, write-only).
     #[cfg(windows)]
     pub fn create_w(dir: impl AsFd, path: &[u16]) -> Maybe<Self> {
         let dir = dir.as_fd();
         let flags = O::WRONLY | O::CREAT | O::CLOEXEC | O::TRUNC;
         openat_windows(dir, path, flags, 0o666).map(Self::from_fd)
     }
-    /// Port of `bun.sys.File.openatOSPath` (File.zig:65) — `openat` accepting
+    /// `openat` accepting
     /// the platform-native NUL-terminated path type (`ZStr` POSIX / `WStr`
     /// Windows). Returns a `File` wrapper around the opened fd.
     #[inline]
@@ -171,7 +165,6 @@ impl File {
     pub fn write_all(&self, mut buf: &[u8]) -> Maybe<()> {
         while !buf.is_empty() {
             let n = write(self.handle, buf)?;
-            // File.zig:118-133 — `if (amt == 0) return .success;` (matches Zig).
             if n == 0 {
                 return Ok(());
             }
@@ -179,8 +172,8 @@ impl File {
         }
         Ok(())
     }
-    /// `File.readAll(buf: []u8)` — loop `read()` into a **fixed** caller-owned
-    /// slice until EOF or full. Returns total bytes read (sys.zig `readAll`).
+    /// Loop `read()` into a **fixed** caller-owned slice until EOF or full.
+    /// Returns total bytes read.
     pub fn read_all(&self, buf: &mut [u8]) -> Maybe<usize> {
         let mut rest = &mut *buf;
         let mut total_read: usize = 0;
@@ -201,12 +194,12 @@ impl File {
     }
     pub fn read_to_end(&self) -> Maybe<Vec<u8>> {
         let mut v = Vec::new();
-        // File.zig `readToEnd` — fstat-presized, pread-from-0; not a cursor read.
+        // fstat-presized, pread-from-0; not a cursor read.
         self.read_to_end_with_array_list(&mut v, SizeHint::UnknownSize)?;
         Ok(v)
     }
-    /// File.zig `readToEndSmall` — `readToEndWithArrayList(.probably_small)`.
-    /// Reserves only 64 bytes initially instead of fstat-presizing; for files
+    /// Like [`File::read_to_end`] but
+    /// reserves only 64 bytes initially instead of fstat-presizing; for files
     /// callers expect to be tiny (`.bun-tag`, lockfile markers, etc.).
     pub fn read_to_end_small(&self) -> Maybe<Vec<u8>> {
         let mut v = Vec::new();
@@ -215,8 +208,8 @@ impl File {
     }
     /// `File.readToEndWithArrayList(buf, hint)` — like `read_all` but takes a
     /// `SizeHint` so callers can pre-reserve. Returns total bytes appended.
-    /// File.zig:298 — `probably_small` reserves 64; `unknown_size` fstats and
-    /// reserves `size+16`.
+    /// `ProbablySmall` reserves 64; `UnknownSize` fstats and reserves
+    /// `size+16`.
     pub fn read_to_end_with_array_list(&self, list: &mut Vec<u8>, hint: SizeHint) -> Maybe<usize> {
         match hint {
             SizeHint::ProbablySmall => list.reserve(64),
@@ -236,13 +229,13 @@ impl File {
             }
         })
     }
-    /// Port of `bun.sys.File.readFillBuf` (src/sys/File.zig). Reads until
+    /// Reads until
     /// `buf` is full or EOF; returns the filled prefix.
     pub fn read_fill_buf<'b>(&self, buf: &'b mut [u8]) -> Maybe<&'b mut [u8]> {
         let mut read_amount: usize = 0;
         while read_amount < buf.len() {
-            // PORT NOTE: File.zig:278 — POSIX uses pread() from offset 0 so a
-            // pre-advanced cursor doesn't truncate; Windows falls back to read().
+            // POSIX uses pread() from offset 0 so a pre-advanced cursor
+            // doesn't truncate; Windows falls back to read().
             #[cfg(unix)]
             let rc = pread(self.handle, &mut buf[read_amount..], read_amount as i64);
             #[cfg(not(unix))]
@@ -266,7 +259,7 @@ impl File {
         }
         Ok(())
     }
-    /// `std.fs.File.preadAll` — loop `pread()` from `offset` until `buf` is
+    /// Loop `pread()` from `offset` until `buf` is
     /// full or EOF. Returns total bytes read (may be `< buf.len()` on EOF).
     pub fn pread_all(&self, buf: &mut [u8], offset: u64) -> Maybe<usize> {
         let mut off = offset as i64;
@@ -283,19 +276,19 @@ impl File {
     }
 
     // ── seek / stat / kind ───────────────────────────────────────────────
-    /// `std.fs.File.seekTo` — `lseek(SEEK_SET)`.
+    /// `lseek(SEEK_SET)`.
     #[inline]
     pub fn seek_to(&self, offset: u64) -> Maybe<()> {
         set_file_offset(self.handle, offset)
     }
-    /// `std.fs.File.getPos` — current file position via `lseek(0, SEEK_CUR)`.
+    /// Current file position via `lseek(0, SEEK_CUR)`.
     /// On Windows this routes through `SetFilePointerEx(.., FILE_CURRENT)` (whence
     /// values match: `SEEK_CUR == FILE_CURRENT == 1`).
     #[inline]
     pub fn get_pos(&self) -> Maybe<u64> {
         lseek(self.handle, 0, libc::SEEK_CUR).map(|p| p as u64)
     }
-    /// `File.getEndPos()` (File.zig:209) — `getFileSize(self.handle)`.
+    /// The file's size in bytes.
     /// On Windows that's `GetFileSizeEx` directly on the HANDLE (NOT via
     /// libuv `fstat`, which would require a uv-kind fd).
     pub fn get_end_pos(&self) -> Maybe<usize> {
@@ -304,8 +297,6 @@ impl File {
     pub fn stat(&self) -> Maybe<Stat> {
         fstat(self.handle)
     }
-    /// Port of `bun.sys.File.kind` (File.zig:220).
-    ///
     /// Be careful about using this on Linux or macOS — calls `fstat()`
     /// internally there. On Windows it routes through `GetFileType`.
     pub fn kind(&self) -> Maybe<FileKind> {
@@ -329,9 +320,9 @@ impl File {
         #[cfg(not(windows))]
         {
             let st = self.stat()?;
-            // Zig spec (File.zig:258): unrecognized `st_mode & IFMT` falls back to
-            // `.file`, not `.unknown`. `kind_from_mode` returns `Unknown` for that
-            // case, so post-process here to match the spec's else arm.
+            // An unrecognized `st_mode & IFMT` falls back to `File`, not
+            // `Unknown`. `kind_from_mode` returns `Unknown` for that case, so
+            // post-process here.
             let k = kind_from_mode(st.st_mode as Mode);
             Ok(if matches!(k, FileKind::Unknown) {
                 FileKind::File
@@ -352,10 +343,10 @@ impl File {
     /// `File.closeAndMoveTo` — atomically rename `src` → `dest` (cwd-relative),
     /// closing the handle after the rename so `move_file_z_with_handle`'s
     /// EXDEV fallback (fstat/lseek/copy on `from_handle`) sees a live handle.
-    /// (Zig closes first on Windows because its rename uses `MoveFileExW`; the
-    /// Rust port goes through `rename_at_w` → `NtSetInformationFile` which
-    /// opens its own source handle, so keeping `self` open across the call is
-    /// fine and avoids passing a closed handle into the EXDEV fallback.)
+    /// (On Windows the rename goes through `rename_at_w` →
+    /// `NtSetInformationFile`, which opens its own source handle, so keeping
+    /// `self` open across the call is fine and avoids passing a closed handle
+    /// into the EXDEV fallback.)
     pub fn close_and_move_to(
         self,
         src: &ZStr,
@@ -363,7 +354,7 @@ impl File {
     ) -> core::result::Result<(), bun_core::Error> {
         let cwd = Fd::cwd();
         let result = move_file_z_with_handle(self.handle, cwd, src, cwd, dest);
-        let _ = self.close(); // close error is non-actionable (Zig parity: discarded)
+        let _ = self.close(); // close error is non-actionable; discarded
         result
     }
     /// `bun.sys.File.getPath` — `getFdPath(self.handle, buf)`.
@@ -378,16 +369,14 @@ impl File {
     }
 
     // ── one-shot path helpers (open + io + close) ───────────────────────
-    /// `bun.sys.File.readFrom` — open + read + close. Accepts `&[u8]` (Zig:
-    /// `path: anytype`); `&ZStr` callers deref-coerce.
+    /// Open + read + close. Accepts `&[u8]`; `&ZStr` callers deref-coerce.
     pub fn read_from(dir: impl AsFd, path: &[u8]) -> Maybe<Vec<u8>> {
         let dir = dir.as_fd();
         let f = Self::openat(dir, path, O::RDONLY, 0)?;
-        // File.zig: closes the fd on the error path too (no leak on read
-        // failure). `Drop` covers all paths.
+        // `Drop` closes the fd on all paths (no leak on read failure).
         f.read_to_end()
     }
-    /// `bun.sys.File.readFileFrom` (File.zig:381) — open + read; returns BOTH
+    /// Open + read; returns BOTH
     /// the open `File` handle and the bytes. Caller owns the fd and must
     /// `close()` it. On read error the fd is closed before returning (no leak).
     pub fn read_file_from(
@@ -402,14 +391,12 @@ impl File {
             Err(e) => Err(e.into()),
         }
     }
-    /// `bun.sys.File.readFromUserInput` (File.zig:367) — normalize a
+    /// Normalize a
     /// user-provided relative path against the resolver's cached
     /// `top_level_dir` (NOT a fresh `getcwd()`), then `readFrom`.
     ///
-    /// Zig reads `bun.fs.FileSystem.instance.top_level_dir` directly; in the
-    /// Rust crate map that lives in `bun_resolver::fs` (T5) which `bun_sys`
-    /// (T1) must not depend on (PORTING.md §Forbidden: no fn-ptr hooks to
-    /// break dep cycles). Callers pass `top_level_dir` explicitly instead.
+    /// The cached `top_level_dir` lives in `bun_resolver::fs` (T5), which
+    /// `bun_sys` (T1) must not depend on, so callers pass it explicitly.
     pub fn read_from_user_input(
         dir: impl AsFd,
         top_level_dir: &[u8],
@@ -427,13 +414,11 @@ impl File {
     /// `bun.sys.File.writeFile` — open + write + close.
     pub fn write_file(dir: impl AsFd, path: &ZStr, data: &[u8]) -> Maybe<()> {
         let dir = dir.as_fd();
-        // File.zig:141 — mode 0o664; `defer file.close()`. `Drop` covers all
-        // paths.
+        // `Drop` closes the fd on all paths.
         let f = Self::openat(dir, path, O::WRONLY | O::CREAT | O::TRUNC, 0o664)?;
         f.write_all(data)
     }
-    /// Port of `bun.sys.File.writeFileWithPathBuffer` (File.zig) Windows arm —
-    /// like [`write_file`] but takes the platform-native path type so Windows
+    /// Like [`File::write_file`] but takes the platform-native path type so Windows
     /// callers can pass a `&WStr` without round-tripping through UTF-8.
     pub fn write_file_os_path(
         dir: impl AsFd,
@@ -456,7 +441,7 @@ impl File {
     pub fn reader(&self) -> FileReader {
         FileReader(self.handle)
     }
-    /// `File.bufferedWriter()` — `std.io.BufferedWriter` wrapping this fd.
+    /// Buffered writer (`std::io::BufWriter`) wrapping this fd.
     pub fn buffered_writer(&self) -> std::io::BufWriter<FileWriter> {
         std::io::BufWriter::new(FileWriter(self.handle))
     }
diff --git a/src/sys/lib.rs b/src/sys/lib.rs
index a8013244d88..bda5fb865ce 100644
--- a/src/sys/lib.rs
+++ b/src/sys/lib.rs
@@ -4,12 +4,12 @@
 // IS the bun_sys::File the lint routes everyone else through.
 #![allow(clippy::disallowed_types, clippy::disallowed_methods)]
 #![warn(unused_must_use)]
-//! `bun_sys` — syscall wrappers (port of `src/sys/sys.zig`).
+//! `bun_sys` — syscall wrappers.
 
 // `Fd` struct + pure-data accessors are hoisted to `bun_core::Fd`
 // (canonical T0). `fd.rs` is `pub trait FdExt` over that.
 
-// `bun_str` is the historical Zig namespace name; keep a public alias to
+// `bun_str` is a historical namespace name; keep a public alias to
 // `bun_core` so any external `bun_sys::bun_core::…` paths continue to resolve.
 #[cfg(windows)]
 pub extern crate bun_core as bun_str;
@@ -26,9 +26,8 @@ pub use error::Error;
 #[cfg(windows)]
 pub use error::ReturnCodeExt;
 // `bun_sys::Error` is the rich syscall error (errno+tag+path); `bun_core::Error`
-// is the lightweight NonZeroU16 code. They are distinct types (matching Zig:
-// `bun.sys.Error` vs `anyerror`). Downstream that just wants "an error" gets the
-// code via `From`.
+// is the lightweight NonZeroU16 code. They are distinct types. Downstream that
+// just wants "an error" gets the code via `From`.
 impl From<Error> for bun_core::Error {
     #[inline]
     fn from(e: Error) -> bun_core::Error {
@@ -36,11 +35,11 @@ impl From<Error> for bun_core::Error {
         bun_core::Error::from_errno(e.errno as i32)
     }
 }
-/// Port of `SystemError` (src/jsc/SystemError.zig) — the JS-facing rich error
+/// The JS-facing rich error
 /// (path/dest/syscall as `bun.String`). The data side has no JSC dependency:
 /// the `*JSGlobalObject`-taking conversion methods (`toErrorInstance` etc.)
 /// live in `bun_jsc` as inherent extensions. `#[repr(C)]` and field order
-/// match the Zig `extern struct` exactly so the C++ `SystemError__*` externs
+/// are fixed so the C++ `SystemError__*` externs
 /// (BunObject.cpp) read the same layout.
 #[repr(C)]
 pub struct SystemError {
@@ -71,13 +70,11 @@ impl Default for SystemError {
     }
 }
 impl SystemError {
-    /// Zig: `SystemError.getErrno` — `@enumFromInt(this.errno * -1)`.
     /// (`Error::to_system_error` stores `errno` negated to match Node.)
     #[inline]
     pub fn get_errno(&self) -> E {
         e_from_negated(self.errno)
     }
-    /// Zig: `SystemError.deref`.
     pub fn deref(&self) {
         self.path.deref();
         self.code.deref();
@@ -86,7 +83,6 @@ impl SystemError {
         self.hostname.deref();
         self.dest.deref();
     }
-    /// Zig: `SystemError.ref`.
     pub fn ref_(&self) {
         self.path.ref_();
         self.code.ref_();
@@ -97,10 +93,8 @@ impl SystemError {
     }
 }
 impl core::fmt::Display for SystemError {
-    /// Port of `SystemError.format` (SystemError.zig:85). Zig forks on
-    /// `Output.enable_ansi_colors_stderr` to inject ANSI escapes via
-    /// `prettyFmt`; the Rust port emits the colorless variant
-    /// (`prettyFmt(..., false)` collapses `<r>/<red>/<d>/<b>` to nothing) so
+    /// Emits the colorless variant
+    /// (`<r>/<red>/<d>/<b>` markup collapsed to nothing) so
     /// `Display` stays side-effect-free. The colored path is handled by
     /// `bun_core::Output::pretty*` at the call site that prints the error.
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -119,23 +113,22 @@ impl core::fmt::Display for SystemError {
 }
 pub mod walker_skippable;
 // `copy_file.rs` — full ioctl_ficlone / copy_file_range / sendfile / r-w-loop
-// state machine (port of `src/sys/copy_file.zig`). Raw kernel
+// state machine. Raw kernel
 // thunks live in `crate::linux`, errno tags use the prefixed `E::E*` form,
 // kernel-version probe goes through `bun_core::linux_kernel_version()`.
 #[path = "copy_file.rs"]
 pub mod copy_file;
 
-// `std.fs.Dir.Entry.Kind` — same set as `bun_core::FileKind`.
+// Directory-entry kind — same set as `bun_core::FileKind`.
 pub use bun_core::FileKind as EntryKind;
 
-// `bun.DirIterator` — ported from `src/runtime/node/dir_iterator.zig`.
+// `bun.DirIterator`.
 //
-// This is copied from std.fs.Dir.Iterator. Differences:
+// A readdir-style directory iterator. Notable behaviors:
 // - returns errors in `bun_sys::Result` (preserves errno + syscall tag)
 // - doesn't mark BADF as unreachable
 // - entry name (`Name`) is a lifetime-erased borrow into the iterator's inline
-//   `buf` on POSIX (Zig: `PathString`), owned `Vec` on Windows
-// - Windows uses the `.u16` path (`NewWrappedIterator(.u16)` in Zig)
+//   `buf` on POSIX, owned `Vec` on Windows
 //
 // The high-tier `bun_runtime::node::dir_iterator` shares this surface; the
 // readdir loop lives here so `walker_skippable` / `bun_glob` / resolver can
@@ -148,7 +141,7 @@ pub mod dir_iterator {
 
     /// Native-encoding directory entry returned by `WrappedIterator::next()`.
     ///
-    /// Zig parity: `IteratorResult { name: PathString, kind }` — `name` is a
+    /// `name` is a
     /// *borrow* into the iterator's internal `buf`. It is invalidated by the
     /// next call to `next()` and by moving/dropping the iterator. Copy it out
     /// (`.slice_u8().to_vec()` etc.) if you need it to outlive the iteration
@@ -162,15 +155,12 @@ pub mod dir_iterator {
     ///
     /// **POSIX**: lifetime-erased borrow (raw pointer + length) into the
     /// iterator's `getdents`/`getdirentries` buffer. The kernel writes
-    /// `d_name` NUL-terminated, so `as_zstr()` needs no copy. Same contract
-    /// as Zig's `PathString.init(name)` (dir_iterator.zig:225) — the slice is
+    /// `d_name` NUL-terminated, so `as_zstr()` needs no copy. The slice is
     /// only valid until the next `next()` call or until the iterator is
     /// moved/dropped. No heap allocation per entry.
     ///
     /// **Windows**: `FILE_DIRECTORY_INFORMATION.FileName` is length-prefixed
-    /// (no NUL) and UTF-16; the Zig `.u8` `NewWrappedIterator` eagerly
-    /// transcodes via `strings.fromWPath` into an iterator-owned `name_data`
-    /// scratch buffer. Here we keep an owning `Vec` per entry (cold path —
+    /// (no NUL) and UTF-16; we keep an owning `Vec` per entry (cold path —
     /// the install hot loop is POSIX-only) so `slice_u8()` can hand out a
     /// borrowed `&[u8]` on every platform.
     #[cfg(not(windows))]
@@ -213,12 +203,11 @@ pub mod dir_iterator {
             let mut v = Vec::with_capacity(s.len() + 1);
             v.extend_from_slice(s);
             v.push(0);
-            // Zig: `strings.fromWPath(self.name_data[0..], dir_info_name)` —
-            // "Trust that Windows gives us valid UTF-16LE".
+            // Trust that Windows gives us valid UTF-16LE.
             let utf8 = bun_core::strings::convert_utf16_to_utf8(Vec::new(), s);
             Name { native: v, utf8 }
         }
-        /// Zig: `name.slice()` — borrow the name as `&[OSPathChar]` (no NUL).
+        /// Borrow the name as `&[OSPathChar]` (no NUL).
         #[cfg(not(windows))]
         #[inline]
         pub fn slice(&self) -> &[OSPathChar] {
@@ -247,7 +236,6 @@ pub mod dir_iterator {
         pub fn slice_u8(&self) -> &[u8] {
             &self.utf8
         }
-        /// Zig: `name.sliceAssumeZ()` — `[:0]const u8` on POSIX.
         #[cfg(not(windows))]
         #[inline]
         pub fn as_zstr(&self) -> &bun_core::ZStr {
@@ -266,8 +254,8 @@ pub mod dir_iterator {
     // 8-byte alignment matches `@alignOf(linux.dirent64)` / Darwin dirent /
     // FILE_DIRECTORY_INFORMATION's LONGLONG-boundary requirement.
     //
-    // Zig: `buf: [8192]u8 align(...)` — *inline*, *uninitialised*. We mirror
-    // that with `MaybeUninit` to skip the 8 KiB `memset` per directory (perf:
+    // `buf` is inline and uninitialised:
+    // `MaybeUninit` skips the 8 KiB `memset` per directory (perf:
     // ~1.4K dirs/install → ~11 MB zalloc churn dropped) and store it inline in
     // `State` so the per-dir heap allocation is gone too. The kernel fills
     // `[0..rc]` before we read; we never index past `end_index`.
@@ -340,8 +328,7 @@ pub mod dir_iterator {
         fn next(&mut self, dir: Fd) -> Result<Option<IteratorResult>> {
             loop {
                 if self.index >= self.end_index {
-                    // glibc doesn't expose getdents64; go straight to the syscall
-                    // (matches Zig's `linux.getdents64` raw-syscall path).
+                    // glibc doesn't expose getdents64; go straight to the syscall.
                     // SAFETY: buf is valid for BUF_SIZE bytes; fd is a plain c_int.
                     let rc = unsafe {
                         super::linux_syscall::getdents64(
@@ -370,7 +357,7 @@ pub mod dir_iterator {
                 self.index = base + reclen;
 
                 // d_name is NUL-terminated within the record. Use a SIMD-vectorized
-                // scan for the terminator (mirrors Zig's `indexOfScalar`); a scalar
+                // scan for the terminator; a scalar
                 // byte loop here showed up in startup profiles on large directories.
                 let name_field = &buf[base + 19..base + reclen];
                 let nul = memchr::memchr(0, name_field).unwrap_or(name_field.len());
@@ -412,7 +399,7 @@ pub mod dir_iterator {
         }
         fn next(&mut self, dir: Fd) -> Result<Option<IteratorResult>> {
             unsafe extern "C" {
-                // Private libsystem symbol; same one Zig's `posix.system.__getdirentries64` hits.
+                // Private libsystem symbol.
                 fn __getdirentries64(
                     fd: libc::c_int,
                     buf: *mut u8,
@@ -584,8 +571,7 @@ pub mod dir_iterator {
     }
 
     // ── Windows ──────────────────────────────────────────────────────────
-    // dir_iterator.zig:233-417 — `NtQueryDirectoryFile` +
-    // `FILE_DIRECTORY_INFORMATION` walk.
+    // `NtQueryDirectoryFile` + `FILE_DIRECTORY_INFORMATION` walk.
     #[cfg(windows)]
     struct State {
         // > This structure must be aligned on a LONGLONG (8-byte) boundary. If
@@ -775,7 +761,7 @@ pub mod dir_iterator {
         dir: Fd,
         // Windows: NtQueryDirectoryFile filter (UNICODE_STRING). On POSIX,
         // ignored (kernel readdir has no name filter; callers post-filter).
-        // PORT NOTE: stored on `State` on Windows so `next()` can pass it.
+        // stored on `State` on Windows so `next()` can pass it.
         #[cfg(not(windows))]
         name_filter: Option<Vec<u16>>,
         state: State,
@@ -803,7 +789,7 @@ pub mod dir_iterator {
         /// iterator is moved or dropped.
         ///
         /// On POSIX `IteratorResult::name` is a lifetime-erased borrow into
-        /// this iterator's inline `buf` (Zig parity: `PathString.init(d_name)`).
+        /// this iterator's inline `buf`.
         /// Copy it out before pushing the iterator into a `Vec` etc.
         #[inline]
         pub fn next(&mut self) -> Result<Option<IteratorResult>> {
@@ -835,10 +821,8 @@ pub mod dir_iterator {
 pub fn open_dir_for_iteration_os_path(dir: Fd, path: &bun_paths::OSPathSlice) -> Result<Fd> {
     #[cfg(not(windows))]
     {
-        // PORT NOTE: Zig `openDirForIterationOSPath` uses
-        // `O_DIRECTORY | O_RDONLY | O_CLOEXEC` (`| O_NONBLOCK` on Linux).
         let mut buf = bun_paths::PathBuffer::default();
-        // bun.zig:883 → `sys.openatA` → `std.posix.toPosixPath`: ENAMETOOLONG on
+        // ENAMETOOLONG on
         // overflow, never silently truncate (would open the wrong directory).
         if path.len() >= buf.len() {
             return Err(Error::from_code_int(libc::ENAMETOOLONG, Tag::open).with_path(path));
@@ -848,14 +832,11 @@ pub fn open_dir_for_iteration_os_path(dir: Fd, path: &bun_paths::OSPathSlice) ->
         buf[len] = 0;
         // SAFETY: NUL-terminated above.
         let z = ZStr::from_buf(&buf[..], len);
-        // bun.zig:883 — exactly `O_DIRECTORY | O_CLOEXEC | O_RDONLY` (no NONBLOCK).
         let flags = libc::O_DIRECTORY | libc::O_RDONLY | libc::O_CLOEXEC;
         openat(dir, z, flags, 0)
     }
     #[cfg(windows)]
     {
-        // bun.zig:884 → `sys.openDirAtWindowsA(dir, path, .{ .iterable = true,
-        // .read_only = true })`.
         open_dir_at_windows(
             dir,
             path,
@@ -872,20 +853,17 @@ pub fn lstatat(fd: impl AsFd, path: &ZStr) -> Result<Stat> {
     let fd = fd.as_fd();
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
-        // sys.zig:874 — `bun.invalid_fd` means cwd-relative.
         let dirfd = if fd.is_valid() {
             fd.native()
         } else {
             libc::AT_FDCWD
         };
-        // sys.zig:877 — `lstatat` tags as `.fstatat`.
         linux_syscall::fstatat(dirfd, path, libc::AT_SYMLINK_NOFOLLOW)
             .map_err(|e| Error::from_code_int(e, Tag::fstatat).with_path(path.as_bytes()))
     }
     #[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
     {
         let mut st = core::mem::MaybeUninit::<libc::stat>::uninit();
-        // sys.zig:874 — `bun.invalid_fd` means cwd-relative.
         let dirfd = if fd.is_valid() {
             fd.native()
         } else {
@@ -904,13 +882,12 @@ pub fn lstatat(fd: impl AsFd, path: &ZStr) -> Result<Stat> {
             // SAFETY: rc == 0 ⇒ kernel populated `st`.
             Ok(unsafe { st.assume_init() })
         } else {
-            // sys.zig:877 — `lstatat` tags as `.fstatat`.
             Err(Error::from_code_int(last_errno(), Tag::fstatat).with_path(path.as_bytes()))
         }
     }
     #[cfg(windows)]
     {
-        // sys.zig:879 — open with `O.NOFOLLOW` (→ `FILE_OPEN_REPARSE_POINT`),
+        // Open with `O.NOFOLLOW` (→ `FILE_OPEN_REPARSE_POINT`),
         // `fstat` the handle, then close.
         match openat_windows_a(fd, path.as_bytes(), O::NOFOLLOW, 0) {
             Ok(file) => {
@@ -922,7 +899,7 @@ pub fn lstatat(fd: impl AsFd, path: &ZStr) -> Result<Stat> {
         }
     }
 }
-/// `bun.getcwdAlloc(allocator)` (bun.zig:1256) — read cwd into a stack
+/// Read cwd into a stack
 /// `PathBuffer`, then duplicate into a heap-owned NUL-terminated `ZBox`.
 pub fn getcwd_alloc() -> Maybe<bun_core::ZBox> {
     let mut buf = [0u8; bun_core::MAX_PATH_BYTES];
@@ -930,7 +907,7 @@ pub fn getcwd_alloc() -> Maybe<bun_core::ZBox> {
     Ok(bun_core::ZBox::from_bytes(&buf[..len]))
 }
 
-/// `bun.sys.getcwdZ(buf)` (sys.zig:349) — `getcwd` returning a NUL-terminated
+/// `getcwd` returning a NUL-terminated
 /// borrow into `buf`. POSIX `getcwd(3)` already NUL-terminates; on Windows
 /// the libuv path does too.
 pub fn getcwd_z(buf: &mut bun_paths::PathBuffer) -> Maybe<&ZStr> {
@@ -960,7 +937,7 @@ use core::ffi::{c_char, c_void};
 // ──────────────────────────────────────────────────────────────────────────
 // Re-exports from lower-tier crates (PORTING.md crate map).
 // ──────────────────────────────────────────────────────────────────────────
-/// Zig: `bun.errnoToZigErr(errno)` (bun.zig) — re-exported here so callers
+/// Re-exported here so callers
 /// that already depend on `bun_sys` (e.g. `bun_install` Windows paths) can
 /// write `bun_sys::errno_to_zig_err(..)` without also importing `bun_core`.
 pub use bun_core::errno_to_zig_err;
@@ -1006,12 +983,11 @@ impl AsFd for &Dir {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub(crate) mod linux_syscall;
 
-/// Zig: `bun.isRegularFile(mode)` (bun.zig) — `S.ISREG(@intCast(mode))`.
 #[inline]
 pub fn is_regular_file(mode: Mode) -> bool {
     kind_from_mode(mode) == FileKind::File
 }
-/// `std.posix.socket_t` — `c_int` on POSIX, `SOCKET` (`usize`) on Windows.
+/// Native socket type — `c_int` on POSIX, `SOCKET` (`usize`) on Windows.
 #[cfg(not(windows))]
 pub type SocketT = core::ffi::c_int;
 #[cfg(windows)]
@@ -1037,7 +1013,7 @@ pub extern "C" fn Bun__errnoName(err: core::ffi::c_int) -> *const core::ffi::c_c
         return core::ptr::null();
     };
     // strum's `IntoStaticStr` yields a `&str` without a NUL terminator, but the
-    // Zig contract is `?[*:0]const u8` and C++ callers pass it to `fprintf` /
+    // exported contract is `?[*:0]const u8` and C++ callers pass it to `fprintf` /
     // `String::fromLatin1`. Copy into a small thread-local buffer and append
     // the NUL ourselves.
     let name = <&'static str>::from(e).as_bytes();
@@ -1058,7 +1034,7 @@ pub extern "C" fn Bun__errnoName(err: core::ffi::c_int) -> *const core::ffi::c_c
 }
 
 /// Small "fire and forget" wrapper around unlink for C usage that handles
-/// EINTR, Windows path conversion, etc. Zig: `export fn Bun__unlink(ptr, len)`.
+/// EINTR, Windows path conversion, etc.
 ///
 /// # Safety
 /// `ptr[0..=len]` must be a valid NUL-terminated path slice for the call.
@@ -1072,22 +1048,22 @@ pub unsafe extern "C" fn Bun__unlink(ptr: *const u8, len: usize) {
 
 // libuv-style error constants (negated errno on posix, UV_* on Windows). The
 // per-platform `bun_errno` module defines this as `mod uv_e`; re-export under
-// the canonical Zig name so callers can write `bun_sys::UV_E::NOENT`.
+// the canonical name so callers can write `bun_sys::UV_E::NOENT`.
 pub use bun_errno::uv_e as UV_E;
 // `bun_errno::posix` is the small move-down stub (mode_t/E/S/errno). The full
 // `std.posix` surface dependents need (`Sigaction`, `getrlimit`, `tcgetattr`,
 // raw `read`/`write`/`poll`, …) is widened below in this crate's own `posix`
 // module which re-exports the errno stub and layers libc on top.
 
-/// `Maybe(T)` — Zig's `union(enum) { result: T, err: Error }`. In Rust this is
-/// just `Result<T, Error>`; keep the alias so ported call sites type-check.
+/// `Maybe(T)` is just `Result<T, Error>`; keep the alias so existing call
+/// sites type-check.
 pub type Maybe<T> = core::result::Result<T, Error>;
 pub type Result<T> = core::result::Result<T, Error>;
 
-/// Zig `Maybe(T)` static helpers — `.success()`, `.errno(e, tag)`,
-/// `.errnoSys(rc, tag)`. Ported as a trait over `Result<T, Error>` so call
-/// sites can keep writing `bun_sys::Result::<()>::errno_sys(rc, tag)` exactly
-/// as the Zig spells it. Windows-only paths in `windows/mod.rs` lean on these
+/// `Maybe(T)` static helpers — `.success()`, `.errno(e, tag)`,
+/// `.errnoSys(rc, tag)`, as a trait over `Result<T, Error>` so call
+/// sites can write `bun_sys::Result::<()>::errno_sys(rc, tag)`.
+/// Windows-only paths in `windows/mod.rs` lean on these
 /// for the NTSTATUS → `E` mapping.
 pub trait MaybeExt: Sized {
     type T;
@@ -1133,7 +1109,7 @@ impl error::IntoErrnoInt for bun_windows_sys::NTSTATUS {
     }
 }
 
-/// Flags for [`renameat2`]. Port of `bun.sys.RenameAt2Flags` (sys.zig:2472).
+/// Flags for [`renameat2`].
 /// On Linux maps to `RENAME_EXCHANGE`/`RENAME_NOREPLACE`; on macOS maps to
 /// `RENAME_SWAP`/`RENAME_EXCL`/`RENAME_NOFOLLOW_ANY`.
 #[derive(Clone, Copy, Default)]
@@ -1184,9 +1160,9 @@ impl Renameat2Flags {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Syscall tag — `enum(u8)` in spec (sys.zig:218-326). Newtype-over-u8 here so
-// the discriminants match Zig's positional ordinals 1:1 for FFI / cross-lang
-// comparison. PORTING.md §Forbidden flags wrong-discriminants as a logic-bug.
+// Syscall tag. Newtype-over-u8; the discriminants are part of the FFI /
+// cross-lang comparison surface and must stay stable.
+// PORTING.md §Forbidden flags wrong-discriminants as a logic-bug.
 // ──────────────────────────────────────────────────────────────────────────
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
@@ -1202,8 +1178,8 @@ pub mod O {
     pub const RDONLY: i32 = libc::O_RDONLY;
     pub const WRONLY: i32 = libc::O_WRONLY;
     pub const RDWR: i32 = libc::O_RDWR;
-    // sys.zig:193-197 — on Windows the `O.*` constants are the Zig spec values
-    // (octal, Linux-shaped), NOT MSVCRT `_O_*`. `uv::O::from_bun_o` bit-tests
+    // On Windows the `O.*` constants are fixed octal, Linux-shaped values,
+    // NOT MSVCRT `_O_*`. `uv::O::from_bun_o` bit-tests
     // against these exact values, so re-using `libc::O_CREAT` (0x100) etc.
     // silently dropped CREAT/EXCL/APPEND on Windows.
     #[cfg(unix)]
@@ -1235,7 +1211,7 @@ pub mod O {
     pub const CLOEXEC: i32 = 0o2000000;
     #[cfg(unix)]
     pub const DIRECTORY: i32 = libc::O_DIRECTORY;
-    // sys.zig:202 — non-zero on Windows so `(flags & O::DIRECTORY) != 0`
+    // Non-zero on Windows so `(flags & O::DIRECTORY) != 0`
     // routes `openat_windows_impl` to the directory NtCreateFile path.
     #[cfg(windows)]
     pub const DIRECTORY: i32 = 0o200000;
@@ -1245,7 +1221,7 @@ pub mod O {
     pub const NOATIME: i32 = libc::O_NOATIME;
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub const TMPFILE: i32 = libc::O_TMPFILE;
-    // sys.zig:209-212 — Windows defines these (non-zero) so the `O.PATH` /
+    // Windows defines these (non-zero) so the `O.PATH` /
     // `O.NOATIME` bit-tests in `openat_windows_impl` are meaningful.
     #[cfg(windows)]
     pub const PATH: i32 = 0o10000000;
@@ -1259,7 +1235,7 @@ pub mod O {
     pub const NOATIME: i32 = 0;
     #[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
     pub const TMPFILE: i32 = 0;
-    // sys.zig:66-216 — defined for every platform; Darwin-only flags map to 0
+    // Defined for every platform; Darwin-only flags map to 0
     // elsewhere so `flags & O.EVTONLY` etc. compile and are no-ops.
     #[cfg(unix)]
     pub const NOFOLLOW: i32 = libc::O_NOFOLLOW;
@@ -1297,15 +1273,14 @@ pub mod O {
     pub const NOFOLLOW_ANY: i32 = 0;
 }
 // ──────────────────────────────────────────────────────────────────────────
-// `File` / `Dir` — high-level handles. Extracted to file.rs / dir.rs
-// (matching Zig's File.zig / module shape).
+// `File` / `Dir` — high-level handles. Extracted to file.rs / dir.rs.
 // ──────────────────────────────────────────────────────────────────────────
 pub mod file;
 pub use file::{File, ReadToEndResult};
 pub mod dir;
 pub use dir::*;
 
-/// `std.fs.cwd()` — Zig callers do `bun_sys::cwd()` for the process cwd `Dir`.
+/// `bun_sys::cwd()` returns the process cwd `Dir`.
 #[inline]
 pub fn cwd() -> Dir {
     Dir::cwd()
@@ -1313,19 +1288,18 @@ pub fn cwd() -> Dir {
 
 #[cfg(unix)]
 pub type Stat = libc::stat;
-/// On Windows `bun.Stat` is libuv's `uv_stat_t` (sys.zig: `bun.Stat == uv.uv_stat_t`).
+/// On Windows `bun.Stat` is libuv's `uv_stat_t`.
 #[cfg(windows)]
 pub type Stat = bun_libuv_sys::uv_stat_t;
 
 // ──────────────────────────────────────────────────────────────────────────
 // Syscall surface — real posix libc FFI. Windows path lives in
-// `windows_impl` (NT/kernel32/libuv triad) below; these `#[cfg(unix)]` impls
-// match `src/sys/sys.zig` posix arms 1:1.
+// `windows_impl` (NT/kernel32/libuv triad) below.
 // ──────────────────────────────────────────────────────────────────────────
 use bun_core::ZStr;
 
 /// Read thread-local libc errno (set by the failing syscall).
-/// Zig: `std.c._errno().*` (sys.zig). On Windows this reads the CRT's
+/// On Windows this reads the CRT's
 /// thread-local `_errno()`; libuv-backed paths that need Win32
 /// `GetLastError()` go through `bun_sys::windows::get_last_errno` instead.
 #[inline]
@@ -1333,8 +1307,8 @@ pub fn last_errno() -> i32 {
     bun_core::ffi::errno()
 }
 
-/// `std.c._errno()` — pointer to thread-local errno. Prefer `last_errno()`
-/// for the value; this exists for callers that match the Zig `*_errno()` API
+/// Pointer to thread-local errno. Prefer `last_errno()`
+/// for the value; this exists for callers that want the `*_errno()` API
 /// shape (`unsafe { *bun_sys::errno() }`).
 #[cfg(unix)]
 #[inline]
@@ -1345,7 +1319,7 @@ pub fn errno() -> *mut i32 {
     bun_core::ffi::errno_ptr()
 }
 
-/// `std.posix.toPosixPath` — copy `path` into a NUL-terminated buffer.
+/// Copy `path` into a NUL-terminated buffer.
 /// Returns `NameTooLong` if `path` contains an interior NUL.
 #[inline]
 pub fn to_posix_path(path: &[u8]) -> core::result::Result<std::ffi::CString, bun_core::Error> {
@@ -1363,8 +1337,7 @@ fn err_with_path(tag: Tag, path: &ZStr) -> Error {
     err_with(tag).with_path(path.as_bytes())
 }
 
-// Syscall tags — discriminants MUST match `sys.zig:218-326` positional
-// ordinals exactly (FFI-observable). Do not reorder; append-only.
+// Syscall tags — discriminants are FFI-observable. Do not reorder; append-only.
 impl Tag {
     pub const TODO: Tag = Tag(0);
     pub const dup: Tag = Tag(1);
@@ -1467,21 +1440,20 @@ impl Tag {
     pub const CloseHandle: Tag = Tag(98);
     pub const SetFilePointerEx: Tag = Tag(99);
     pub const SetEndOfFile: Tag = Tag(100);
-    // ── PORT NOTE: tags below this line are Rust-port-only (no Zig ordinal).
-    // They sit above the Zig range so a Zig-produced `Tag` never collides.
+    // ── later additions — appended above the frozen range so existing
+    // discriminants never shift.
     pub const dup2: Tag = Tag(101);
     pub const fchdir: Tag = Tag(102);
     pub const fchownat: Tag = Tag(103);
     pub const ioctl: Tag = Tag(104);
     pub const getrlimit: Tag = Tag(105);
     pub const setrlimit: Tag = Tag(106);
-    // PORT NOTE: sys.zig folds `inotify_init1`/`inotify_add_watch` under the
-    // generic `.watch` tag; `INotifyWatcher.rs` was ported against the
-    // draft-b1 enum that had a distinct `.inotify` variant. Alias to `.watch`
+    // `inotify_init1`/`inotify_add_watch` fold under the generic `.watch`
+    // tag; `INotifyWatcher.rs` spells it `.inotify`. Alias to `.watch`
     // so the JS-facing `err.syscall == "watch"` string stays node-compatible.
     pub const inotify: Tag = Tag::watch;
 
-    /// `@tagName(self)` — must match sys.zig spelling exactly (JS-facing
+    /// The tag name — spelling is frozen (JS-facing
     /// `err.syscall` string; node-compat code matches on it).
     pub fn name(self) -> &'static str {
         const NAMES: [&str; 107] = [
@@ -1597,10 +1569,10 @@ impl Tag {
         NAMES.get(self.0 as usize).copied().unwrap_or("unknown")
     }
 
-    /// sys.zig:327-329 — `Tag.isWindows`: tags strictly above `WriteFile`
+    /// Tags strictly above `WriteFile`
     /// belong to the Windows-only block. Bounded by `SetEndOfFile` so the
-    /// Rust-port-only POSIX tags (`dup2`/`fchdir`/`fchownat`/`ioctl`) parked
-    /// above the Zig range don't read as Windows.
+    /// later-added POSIX tags (`dup2`/`fchdir`/`fchownat`/`ioctl`) parked
+    /// above that range don't read as Windows.
     #[inline]
     pub const fn is_windows(self) -> bool {
         self.0 > Self::WriteFile.0 && self.0 <= Self::SetEndOfFile.0
@@ -1613,7 +1585,7 @@ impl From<Tag> for &'static str {
     }
 }
 
-/// Max single read/write count (sys.zig:1832): Linux caps at 0x7ffff000;
+/// Max single read/write count: Linux caps at 0x7ffff000;
 /// Darwin/BSD use signed 32-bit byte counts.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub const MAX_COUNT: usize = 0x7ffff000;
@@ -1695,7 +1667,7 @@ pub(crate) mod safe_libc {
     }
 }
 
-// ── Darwin `$NOCANCEL` syscall variants (sys.zig:1708,1853,2077,2139,2253,2297)
+// ── Darwin `$NOCANCEL` syscall variants
 // — the plain libc symbols are pthread cancellation points; a cancelled thread
 // torn down mid-syscall leaks fds / corrupts state. Bun always uses the
 // non-cancellable variants on macOS (`bun.darwin.nocancel`).
@@ -1709,7 +1681,7 @@ mod nocancel {
         // STACK, not in registers; a non-variadic 4-arg decl would pass `mode`
         // in a register libc never reads → freshly-created files get a garbage
         // mode (every `Bun.write` / `fs.writeFileSync` / extracted-archive file
-        // came out unreadable). Must be `...` (matches Zig's `std.c.open`).
+        // came out unreadable). Must be `...`.
         // x86-64-macOS and the Linux syscall path tolerate the non-variadic
         // form; arm64-macOS does not.
         #[link_name = "openat$NOCANCEL"]
@@ -1770,8 +1742,7 @@ mod nocancel {
         ) -> isize;
         #[link_name = "poll$NOCANCEL"]
         pub(crate) fn poll(fds: *mut libc::pollfd, nfds: libc::nfds_t, timeout: c_int) -> c_int;
-        // darwin.zig:12-17 + fd.zig:273 — remaining `$NOCANCEL` variants Bun
-        // links against (close via Zig's std.c on Darwin).
+        // Remaining `$NOCANCEL` variants Bun links against.
         // safe: by-value `c_int` fd; bad fd → -1/EBADF, no UB.
         #[link_name = "close$NOCANCEL"]
         pub(crate) safe fn close(fd: c_int) -> c_int;
@@ -1782,8 +1753,8 @@ mod nocancel {
 mod posix_impl {
     use super::*;
     // Per-platform raw syscall dispatch — macOS uses `$NOCANCEL`; Linux goes
-    // through rustix's linux_raw backend (no libc trampoline, matching Zig's
-    // `std.os.linux`); other POSIX falls back to libc. The Linux hot paths
+    // through rustix's linux_raw backend (no libc trampoline);
+    // other POSIX falls back to libc. The Linux hot paths
     // (open/openat/read/write/close/pread/pwrite/fstat) bypass these `sys_*`
     // dispatchers entirely — see the `#[cfg(target_os = "linux")]` arms on
     // each public fn below — because rustix returns the errno in-band and we
@@ -1907,12 +1878,11 @@ mod posix_impl {
             unsafe { libc::send(fd, buf, n, flags) }
         }
     }
-    // EINTR-retry: most sys.zig wrappers loop `while (true) { …; if errno ==
-    // .INTR continue; }`. NOT all — the macOS `$NOCANCEL` arms for open/openat/
-    // read/write/recv/send (sys.zig:1706-1712,1851-1860,2138-2147,2252-2262,
-    // 2294-2306) issue exactly one call and surface EINTR to the caller without
-    // looping. `check!` keeps the retry for the common path; `check_once!`
-    // matches the spec's single-shot Darwin arms.
+    // EINTR-retry: most wrappers loop on EINTR. NOT all — the macOS
+    // `$NOCANCEL` arms for open/openat/read/write/recv/send issue exactly one
+    // call and surface EINTR to the caller without looping. `check!` keeps the
+    // retry for the common path; `check_once!` is the single-shot variant for
+    // the Darwin arms.
     macro_rules! check {
         ($rc:expr, $tag:expr) => {{
             loop {
@@ -1943,7 +1913,7 @@ mod posix_impl {
             }
         }};
     }
-    // `errnoSysFP` (runtime/node.zig:296) — attaches BOTH `.fd` and `.path`.
+    // Attaches BOTH `.fd` and `.path`.
     macro_rules! check_fp {
         ($rc:expr, $tag:expr, $fd:expr, $path:expr) => {{
             loop {
@@ -1985,15 +1955,14 @@ mod posix_impl {
 
     #[inline]
     pub fn open(path: &ZStr, flags: i32, mode: Mode) -> Maybe<Fd> {
-        // sys.zig:1820 — `open()` is `openat(.cwd(), ..)` on every POSIX target
-        // ("this is what open() does anyway"). Delegating keeps the strace/SYS
-        // shape identical to Zig: `openat(AT_FDCWD, ..)` on Linux/FreeBSD,
-        // `openat$NOCANCEL(AT_FDCWD, ..)` on Darwin.
+        // `open()` is `openat(.cwd(), ..)` on every POSIX target
+        // ("this is what open() does anyway"): `openat(AT_FDCWD, ..)` on
+        // Linux/FreeBSD, `openat$NOCANCEL(AT_FDCWD, ..)` on Darwin.
         openat(Fd::cwd(), path, flags, mode)
     }
     pub fn openat(dir: impl AsFd, path: &ZStr, flags: i32, mode: Mode) -> Maybe<Fd> {
         let dir = dir.as_fd();
-        // sys.zig:1706-1712 — .mac arm: single `openat$NOCANCEL`, no EINTR retry.
+        // macOS: single `openat$NOCANCEL`, no EINTR retry.
         #[cfg(target_os = "macos")]
         {
             let rc = check_once_p!(
@@ -2027,9 +1996,9 @@ mod posix_impl {
             .map_err(|e| Error::from_code_int(e, Tag::open).with_path(path.as_bytes()))
     }
     pub fn close(fd: Fd) -> Maybe<()> {
-        // fd.zig:266 — call close ONCE; never retry on EINTR (Linux may have already
+        // Call close ONCE; never retry on EINTR (Linux may have already
         // released the fd, retrying would close someone else's). Only EBADF surfaces.
-        // fd.zig:273 — Darwin uses `close$NOCANCEL` (avoid pthread cancellation point).
+        // Darwin uses `close$NOCANCEL` (avoid pthread cancellation point).
         #[cfg(any(target_os = "linux", target_os = "android"))]
         {
             return match super::linux_syscall::close(fd.native()) {
@@ -2053,7 +2022,7 @@ mod posix_impl {
     }
     pub fn read(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
         let len = buf.len().min(MAX_COUNT);
-        // sys.zig:2138-2147 — .mac arm: single `read$NOCANCEL`, no EINTR retry.
+        // macOS: single `read$NOCANCEL`, no EINTR retry.
         #[cfg(target_os = "macos")]
         {
             let n = check_once!(
@@ -2079,7 +2048,7 @@ mod posix_impl {
     }
     pub fn write(fd: Fd, buf: &[u8]) -> Maybe<usize> {
         let len = buf.len().min(MAX_COUNT);
-        // sys.zig:1851-1860 — .mac arm: single `write$NOCANCEL`, no EINTR retry.
+        // macOS: single `write$NOCANCEL`, no EINTR retry.
         #[cfg(target_os = "macos")]
         {
             let n = check_once!(
@@ -2195,11 +2164,10 @@ mod posix_impl {
     }
 
     // ──────────────────────────────────────────────────────────────────────
-    // statx (Linux ≥4.11) — sys.zig:614-791. Exposes `birthtime` for node:fs
+    // statx (Linux ≥4.11). Exposes `birthtime` for node:fs
     // `Stats`. On non-Linux these are absent (callers gate on `cfg(linux)`).
     //
-    // Zig went through `std.os.linux.statx` (a raw `syscall5`), so it works on
-    // every Linux ABI. The Rust port uses `libc::statx`, which the `libc` crate
+    // We use `libc::statx`, which the `libc` crate
     // only exposes for glibc/Android (and musl behind the build-time
     // `musl_v1_2_3` cfg the cross-compile build never sets). The `linux_statx`
     // shim below smooths that over: glibc re-exports `libc`; musl and Android
@@ -2219,8 +2187,8 @@ mod posix_impl {
         // musl/Android: `libc` gates `statx`/`STATX_*` behind a build-script
         // `musl_v1_2_3` cfg that cross-compiles can't trigger, and bionic's
         // `statx()` wrapper requires API 30. Define the kernel-ABI struct +
-        // bits ourselves and dispatch via raw `syscall`, matching what Zig's
-        // `std.os.linux.statx` does on every Linux ABI.
+        // bits ourselves and dispatch via raw `syscall` — works on every
+        // Linux ABI.
         #[cfg(any(target_env = "musl", target_os = "android"))]
         mod raw {
             #![allow(non_camel_case_types)]
@@ -2308,8 +2276,7 @@ mod posix_impl {
         core::sync::atomic::AtomicBool::new(true);
 
     /// `STATX_*` request mask covering every field `node:fs Stats` consumes
-    /// (sys.zig:614 `StatxField` — all variants OR'd, the only mask the Zig
-    /// callers ever pass).
+    /// (all field bits OR'd — the only mask callers ever pass).
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub const STATX_MASK_FOR_STATS: u32 = lx::STATX_TYPE
         | lx::STATX_MODE
@@ -2460,7 +2427,7 @@ mod posix_impl {
     }
     pub fn mkdirat(dir: impl AsFd, path: &ZStr, mode: Mode) -> Maybe<()> {
         let dir = dir.as_fd();
-        // sys.zig:809 — `mkdiratZ` tags errors as `.mkdir` (not `.mkdirat`).
+        // Tag errors as `.mkdir` (not `.mkdirat`).
         check_p!(
             // SAFETY: `dir` is a live fd (or AT_FDCWD); `ZStr::as_ptr()` is a
             // valid NUL-terminated C string.
@@ -2471,7 +2438,6 @@ mod posix_impl {
         Ok(())
     }
     /// `bun.makePath` — `mkdirat` walking up parents on ENOENT, like `mkdir -p`.
-    /// Port of std.fs.Dir.makePath (Zig std/fs/Dir.zig).
     #[inline]
     pub fn mkdir_recursive_at(dir: impl AsFd, sub_path: &[u8]) -> Maybe<()> {
         let dir = dir.as_fd();
@@ -2486,7 +2452,7 @@ mod posix_impl {
         let mut buf = [0u8; bun_core::MAX_PATH_BYTES];
         bun_paths::make_path_with(it, |p| {
             if p.len() >= buf.len() {
-                // sys.zig:809 — `mkdiratZ` tags as `.mkdir`; keep consistent here.
+                // Tag as `.mkdir`; keep consistent with `mkdirat`.
                 return Err(
                     Error::from_code_int(E::ENAMETOOLONG as _, Tag::mkdir).with_path(sub_path)
                 );
@@ -2535,8 +2501,7 @@ mod posix_impl {
         Ok(())
     }
     /// `renameat2(2)` (Linux) / `renameatx_np` (macOS). FreeBSD and any other
-    /// unix without an atomic-exchange rename get `ENOSYS` when flags are set,
-    /// matching `bun.sys.renameat2` (sys.zig:2503).
+    /// unix without an atomic-exchange rename get `ENOSYS` when flags are set.
     pub fn renameat2(
         from_dir: Fd,
         from: &ZStr,
@@ -2601,9 +2566,8 @@ mod posix_impl {
             renameat(from_dir, from, to_dir, to)
         }
     }
-    /// sys.zig:2884 `unlinkatWithFlags` — explicit `flags` (e.g. `AT_REMOVEDIR`).
-    /// Zig builds the error via `errnoSysFP(.., .unlink, dirfd, to)` so the
-    /// surfaced `SystemError` carries BOTH the dirfd and the path.
+    /// `unlinkat` with explicit `flags` (e.g. `AT_REMOVEDIR`). The error is
+    /// built so the surfaced `SystemError` carries BOTH the dirfd and the path.
     pub fn unlinkat_with_flags(dir: Fd, path: &ZStr, flags: i32) -> Maybe<()> {
         check_fp!(
             // SAFETY: `dir` is a live fd (or AT_FDCWD); `ZStr::as_ptr()` is a
@@ -2615,8 +2579,7 @@ mod posix_impl {
         );
         Ok(())
     }
-    /// sys.zig:2912 `unlinkat` — 2-arg form (`flags = 0`). Zig's surface is
-    /// 2-arg; the 3-arg variant is `unlinkatWithFlags`.
+    /// 2-arg form (`flags = 0`); the 3-arg variant is `unlinkat_with_flags`.
     #[inline]
     pub fn unlinkat(dir: impl AsFd, path: &ZStr) -> Maybe<()> {
         let dir = dir.as_fd();
@@ -2640,7 +2603,7 @@ mod posix_impl {
             path
         );
         let n = n as usize;
-        // sys.zig:2368 — truncation guard + NUL-terminate.
+        // Truncation guard + NUL-terminate.
         if n >= buf.len() {
             return Err(
                 Error::from_code_int(libc::ENAMETOOLONG, Tag::readlink).with_path(path.as_bytes())
@@ -2649,10 +2612,10 @@ mod posix_impl {
         buf[n] = 0;
         Ok(n)
     }
-    /// sys.zig:3897 — `fcntl(F_DUPFD_CLOEXEC, 0)` so the dup'd fd doesn't leak
+    /// `fcntl(F_DUPFD_CLOEXEC, 0)` so the dup'd fd doesn't leak
     /// to children. NOT `dup(2)` (which lacks CLOEXEC).
     pub fn dup(fd: Fd) -> Maybe<Fd> {
-        // sys.zig:959 `errnoSysFd(.., .fcntl, fd)` — attach the fd on error.
+        // Attach the fd on error.
         loop {
             // SAFETY: `fd` is a live descriptor; `F_DUPFD_CLOEXEC` with arg `0`
             // takes no pointer arguments.
@@ -2693,7 +2656,7 @@ mod posix_impl {
         Ok(unsafe { libc::strlen(p) })
     }
 
-    // ── link/perm/time/access group (sys.zig:406-3973 posix arms) ──
+    // ── link/perm/time/access group ──
     pub fn link(src: &ZStr, dest: &ZStr) -> Maybe<()> {
         check_p!(
             // SAFETY: both `ZStr`s are valid NUL-terminated C strings.
@@ -2706,7 +2669,7 @@ mod posix_impl {
     pub fn linkat(src_dir: impl AsFd, src: &ZStr, dest_dir: impl AsFd, dest: &ZStr) -> Maybe<()> {
         let src_dir = src_dir.as_fd();
         let dest_dir = dest_dir.as_fd();
-        // sys.zig:3963 — `linkatZ` tags as `.link`.
+        // Tags as `.link`.
         check_p!(
             // SAFETY: both dir fds are live (or AT_FDCWD); both `ZStr`s are
             // valid NUL-terminated C strings.
@@ -2724,10 +2687,10 @@ mod posix_impl {
         );
         Ok(())
     }
-    /// `linkatTmpfile` (sys.zig:3973): materialize an `O_TMPFILE` fd. Fast path
+    /// Materialize an `O_TMPFILE` fd. Fast path
     /// uses `linkat(tmpfd, "", dirfd, name, AT_EMPTY_PATH)` (requires
     /// CAP_DAC_READ_SEARCH); falls back to `/proc/self/fd/N` + AT_SYMLINK_FOLLOW.
-    /// Linux-only; on other unix this errors with EOPNOTSUPP (Zig same).
+    /// Linux-only; on other unix this errors with EOPNOTSUPP.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub fn linkat_tmpfile(tmpfd: Fd, dirfd: Fd, name: &ZStr) -> Maybe<()> {
         // 0=unknown, 1=have CAP_DAC_READ_SEARCH, -1=no cap → use /proc fallback.
@@ -2772,7 +2735,7 @@ mod posix_impl {
                     libc::EISDIR | libc::ENOENT | libc::EOPNOTSUPP | libc::EPERM | libc::EINVAL
                         if status == 0 =>
                     {
-                        // sys.zig:4013 — first failure on AT_EMPTY_PATH ⇒ no cap; retry via /proc.
+                        // First failure on AT_EMPTY_PATH ⇒ no cap; retry via /proc.
                         CAP_STATUS.store(-1, core::sync::atomic::Ordering::Relaxed);
                         continue;
                     }
@@ -2787,7 +2750,7 @@ mod posix_impl {
     }
     #[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
     pub fn linkat_tmpfile(_tmpfd: Fd, _dirfd: Fd, name: &ZStr) -> Maybe<()> {
-        // sys.zig:4010 — `linkatTmpfile` tags as `.link` (matches Linux arm).
+        // Tags as `.link` (matches Linux arm).
         Err(Error::from_code_int(libc::EOPNOTSUPP, Tag::link).with_path(name.as_bytes()))
     }
     pub fn symlinkat(target: &ZStr, dirfd: impl AsFd, dest: &ZStr) -> Maybe<()> {
@@ -2803,7 +2766,7 @@ mod posix_impl {
     }
     pub fn readlinkat(fd: impl AsFd, path: &ZStr, buf: &mut [u8]) -> Maybe<usize> {
         let fd = fd.as_fd();
-        // sys.zig:2390 — tags as `.readlink`.
+        // Tags as `.readlink`.
         let n = check_p!(
             // SAFETY: `fd` is a live dir fd; `path` is NUL-terminated (`ZStr`);
             // `readlinkat` writes at most `buf.len()` bytes into `buf`.
@@ -2847,13 +2810,13 @@ mod posix_impl {
         );
         Ok(())
     }
-    /// `lchmod` is BSD/Darwin-only; Linux: `fchmodat(.., AT_SYMLINK_NOFOLLOW)` (sys.zig:434).
+    /// `lchmod` is BSD/Darwin-only; Linux: `fchmodat(.., AT_SYMLINK_NOFOLLOW)`.
     pub fn lchmod(path: &ZStr, mode: Mode) -> Maybe<()> {
         #[cfg(any(target_os = "macos", target_os = "freebsd"))]
         {
             // The `libc` crate omits the `lchmod` binding on both Darwin
             // (libSystem since 10.5) and FreeBSD (libc since 3.0). Declare
-            // locally — matches sys.zig:434.
+            // locally.
             unsafe extern "C" {
                 fn lchmod(path: *const libc::c_char, mode: libc::mode_t) -> libc::c_int;
             }
@@ -2924,7 +2887,6 @@ mod posix_impl {
     }
     pub fn fstatat(fd: impl AsFd, path: &ZStr) -> Maybe<Stat> {
         let fd = fd.as_fd();
-        // sys.zig:848 — `bun.invalid_fd` means cwd-relative.
         let dirfd = if fd.is_valid() {
             fd.native()
         } else {
@@ -2958,7 +2920,7 @@ mod posix_impl {
         );
         Ok(())
     }
-    /// sys.zig:3504 — never returns `.err`; any non-zero rc → `Ok(false)`.
+    /// Never errors; any non-zero rc → `Ok(false)`.
     pub fn faccessat(dir: impl AsFd, sub: &ZStr) -> Maybe<bool> {
         let dir = dir.as_fd();
         // SAFETY: `dir` is a live fd (or AT_FDCWD); `ZStr::as_ptr()` is a
@@ -3005,7 +2967,7 @@ mod posix_impl {
         );
         Ok(())
     }
-    /// sys.zig:1748 — Windows uses `GetFileAttributesW`; posix is plain `access`.
+    /// Windows uses `GetFileAttributesW`; posix is plain `access`.
     pub fn exists_z(path: &ZStr) -> bool {
         // SAFETY: `ZStr::as_ptr()` yields a valid NUL-terminated C string.
         unsafe { libc::access(path.as_ptr(), libc::F_OK) == 0 }
@@ -3016,8 +2978,7 @@ mod posix_impl {
         // valid NUL-terminated C string.
         unsafe { libc::faccessat(dir.native(), sub.as_ptr(), libc::F_OK, 0) == 0 }
     }
-    /// sys.zig:3767 — calls extern C `is_executable_file` (c-bindings.cpp:72-89).
-    /// We FFI to the same symbol so the behaviour is identical.
+    /// Calls extern C `is_executable_file` (c-bindings.cpp:72-89) via FFI.
     pub fn is_executable_file_path(path: &ZStr) -> bool {
         unsafe extern "C" {
             // `c_char`, not `i8` — `char` is unsigned on aarch64/arm/ppc, so
@@ -3029,12 +2990,12 @@ mod posix_impl {
         // SAFETY: `ZStr::as_ptr()` yields a valid NUL-terminated C string.
         unsafe { is_executable_file(path.as_ptr()) }
     }
-    /// sys.zig:4152 — `fstat` then `@max(st_size, 0)` (clamp negative).
+    /// `fstat`, then clamp a negative `st_size` to 0.
     pub fn get_file_size(fd: Fd) -> Maybe<u64> {
         Ok(fstat(fd)?.st_size.max(0) as u64)
     }
     /// `realpath` — `realpath$DARWIN_EXTSN` on macOS for proper symlink resolution
-    /// (Zig: `bun.c.realpath`). Writes into `buf` and returns the written slice.
+    /// Writes into `buf` and returns the written slice.
     pub fn realpath<'a>(path: &ZStr, buf: &'a mut bun_core::PathBuffer) -> Maybe<&'a [u8]> {
         #[cfg(target_os = "macos")]
         unsafe extern "C" {
@@ -3058,7 +3019,7 @@ mod posix_impl {
     // ── fcntl/dup/pipe/io group ──
     pub type FcntlInt = isize;
     pub fn fcntl(fd: Fd, cmd: i32, arg: isize) -> Maybe<FcntlInt> {
-        // sys.zig:959-971 — `errnoSysFd(result, .fcntl, fd)`: attach the fd to the error.
+        // Attach the fd to the error.
         loop {
             // SAFETY: `fd` is a live descriptor; `arg` is passed by value and
             // interpreted per `cmd` (no pointer commands flow through here).
@@ -3077,8 +3038,8 @@ mod posix_impl {
         let rc = check!(safe_libc::dup2(old.native(), new.native()), Tag::dup2);
         Ok(Fd::from_native(rc))
     }
-    /// sys.zig:3839 — plain `pipe(&fds)`, NO CLOEXEC. Callers that want CLOEXEC
-    /// set it themselves (matches Zig).
+    /// Plain `pipe(&fds)`, NO CLOEXEC. Callers that want CLOEXEC
+    /// set it themselves.
     pub fn pipe() -> Maybe<[Fd; 2]> {
         let mut fds = [0i32; 2];
         check!(safe_libc::pipe(&mut fds), Tag::pipe);
@@ -3092,7 +3053,7 @@ mod posix_impl {
         Ok(())
     }
     pub fn fdatasync(fd: Fd) -> Maybe<()> {
-        // node_fs.zig:3921 — calls `system.fdatasync` directly on all Unix
+        // `fdatasync` is available on all Unix
         // (macOS has had fdatasync(2) since 10.7). The libc crate omits the
         // Apple binding; `safe_libc::fdatasync` declares it locally.
         check!(safe_libc::fdatasync(fd.native()), Tag::fdatasync);
@@ -3119,10 +3080,10 @@ mod posix_impl {
 
     // ── socket primitives (recv/send/socketpair) ──
     // Full networking lives in `bun_uws_sys`; these are the bare libc wrappers
-    // sys.zig exposes for shell/pipe IPC.
+    // exposed for shell/pipe IPC.
     pub fn recv(fd: Fd, buf: &mut [u8], flags: i32) -> Maybe<usize> {
         let len = buf.len().min(MAX_COUNT);
-        // sys.zig:2252-2262 — isMac arm: single `recvfrom$NOCANCEL`, no EINTR retry.
+        // macOS: single `recvfrom$NOCANCEL`, no EINTR retry.
         #[cfg(target_os = "macos")]
         let n = check_once!(
             // SAFETY: `fd` is a live socket; `buf` is valid for `len` writes.
@@ -3139,9 +3100,9 @@ mod posix_impl {
         Ok(n as usize)
     }
     pub fn send(fd: Fd, buf: &[u8], flags: i32) -> Maybe<usize> {
-        // sys.zig:2294-2322 — passes `buf.len` un-clamped (only `recv` clamps via
-        // `adjusted_len`); forward the full length and let the kernel decide.
-        // isMac arm: single `sendto$NOCANCEL`, no EINTR retry.
+        // `buf.len` is passed un-clamped (only `recv` clamps);
+        // forward the full length and let the kernel decide.
+        // macOS: single `sendto$NOCANCEL`, no EINTR retry.
         #[cfg(target_os = "macos")]
         let n = check_once!(
             // SAFETY: `fd` is a live socket; `buf` is valid for `buf.len()` reads.
@@ -3160,25 +3121,25 @@ mod posix_impl {
     pub fn recv_non_block(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
         recv(fd, buf, MSG_DONTWAIT)
     }
-    /// sys.zig:2205 — `MSG_DONTWAIT | MSG_NOSIGNAL` so a broken-pipe write
+    /// `MSG_DONTWAIT | MSG_NOSIGNAL` so a broken-pipe write
     /// returns EPIPE instead of raising SIGPIPE.
     pub fn send_non_block(fd: Fd, buf: &[u8]) -> Maybe<usize> {
         send(fd, buf, SEND_FLAGS_NONBLOCK)
     }
     #[cfg(unix)]
     pub const MSG_DONTWAIT: i32 = libc::MSG_DONTWAIT;
-    // sys.zig:2205 — `MSG_DONTWAIT | MSG_NOSIGNAL` on all Unix including macOS
-    // (Darwin defines MSG_NOSIGNAL=0x80000; std/c/darwin.zig:1591).
+    // `MSG_DONTWAIT | MSG_NOSIGNAL` on all Unix including macOS
+    // (Darwin defines MSG_NOSIGNAL=0x80000).
     #[cfg(unix)]
     pub const SEND_FLAGS_NONBLOCK: i32 = libc::MSG_DONTWAIT | libc::MSG_NOSIGNAL;
-    /// sys.zig:3054 `setCloseOnExec` — `fcntl(F_GETFD)` then OR in `FD_CLOEXEC`.
+    /// `fcntl(F_GETFD)` then OR in `FD_CLOEXEC`.
     pub fn set_close_on_exec(fd: Fd) -> Maybe<()> {
         let fl = fcntl(fd, libc::F_GETFD, 0)?;
         fcntl(fd, libc::F_SETFD, fl | libc::FD_CLOEXEC as isize)?;
         Ok(())
     }
 
-    /// sys.zig:3103 `socketpair` — `socketpairImpl(.., for_shell = false)`.
+    /// `socketpair_impl(.., for_shell = false)`.
     /// Linux uses `SOCK_CLOEXEC|SOCK_NONBLOCK` type flags; non-Linux sets
     /// CLOEXEC + nonblock + (Darwin) `SO_NOSIGPIPE` per-fd, closing both on
     /// any post-step error.
@@ -3186,7 +3147,7 @@ mod posix_impl {
         socketpair_impl(domain, ty, proto, nonblock, false)
     }
 
-    /// sys.zig:3125 `socketpairForShell` — `socketpairImpl(.., for_shell = true)`.
+    /// `socketpair_impl(.., for_shell = true)`.
     /// On macOS this skips `SO_NOSIGPIPE` (so the child's writes get SIGPIPE
     /// when the read end closes — required for `yes | head`-style pipelines)
     /// and bumps `SO_RCVBUF`/`SO_SNDBUF` to 128 KB instead. On Linux/other
@@ -3200,7 +3161,6 @@ mod posix_impl {
         socketpair_impl(domain, ty, proto, nonblock, true)
     }
 
-    /// sys.zig:3138 `socketpairImpl`.
     fn socketpair_impl(
         domain: i32,
         ty: i32,
@@ -3229,14 +3189,14 @@ mod posix_impl {
                 safe_libc::close(fds[1]);
                 Err::<[Fd; 2], _>(e)
             };
-            // CLOEXEC first (sys.zig:3173).
+            // CLOEXEC first.
             for &fd in &fds {
                 if let Err(e) = set_close_on_exec(Fd::from_native(fd)) {
                     return close_both(e);
                 }
             }
             // Darwin: SO_NOSIGPIPE on both fds — unless `for_shell`, in which
-            // case bump RCVBUF/SNDBUF instead (sys.zig:3180-3199).
+            // case bump RCVBUF/SNDBUF instead.
             #[cfg(target_os = "macos")]
             {
                 if for_shell {
@@ -3411,7 +3371,7 @@ mod posix_impl {
 
     /// `bun.sys.mmapFile` — open `path` RDWR, fstat for size, mmap [offset, offset+len).
     /// Returns a process-lifetime mmap slice; caller is responsible for
-    /// `munmap`. Mirrors Zig `mmapFile` (sys.zig).
+    /// `munmap`.
     pub fn mmap_file(
         path: &ZStr,
         flags: libc::c_int,
@@ -3447,8 +3407,8 @@ mod posix_impl {
         }
     }
 
-    // ── memfd (Linux only) — sys.zig:3237-3296 ──
-    /// `bun.sys.MemfdFlags` (Zig: `enum(u32)`).
+    // ── memfd (Linux only) ──
+    /// `bun.sys.MemfdFlags`.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     #[derive(Clone, Copy, PartialEq, Eq)]
     #[repr(u32)]
@@ -3478,12 +3438,18 @@ mod posix_impl {
     static MEMFD_ENOSYS: core::sync::atomic::AtomicBool =
         core::sync::atomic::AtomicBool::new(false);
 
-    /// `bun.sys.canUseMemfd()` — false on non-Linux; on Linux, false once
-    /// `memfd_create` has returned ENOSYS/EPERM/EACCES.
+    /// `bun.sys.canUseMemfd()` — false on non-Linux; on Linux, false when
+    /// `BUN_FEATURE_FLAG_DISABLE_MEMFD` is set or once `memfd_create` has
+    /// returned ENOSYS/EPERM/EACCES.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     #[inline]
     pub fn can_use_memfd() -> bool {
-        // TODO(port): also gate on `BUN_FEATURE_FLAG_DISABLE_MEMFD`.
+        if bun_core::env_var::feature_flag::BUN_FEATURE_FLAG_DISABLE_MEMFD
+            .get()
+            .unwrap_or(false)
+        {
+            return false;
+        }
         !MEMFD_ENOSYS.load(core::sync::atomic::Ordering::Relaxed)
     }
     #[cfg(not(any(target_os = "linux", target_os = "android")))]
@@ -3529,9 +3495,8 @@ mod posix_impl {
         }
     }
 
-    /// sys.zig:504 — `sendfile(src, dest, len)`. Clamps `len` (avoid EINVAL on
-    /// >2GB), EINTR-retries, and attaches the *source* fd to the error
-    /// (sys.zig:513 `errnoSysFd(rc, .sendfile, src)`).
+    /// `sendfile(src, dest, len)`. Clamps `len` (avoid EINVAL on
+    /// >2GB), EINTR-retries, and attaches the *source* fd to the error.
     #[cfg(any(target_os = "linux", target_os = "android"))]
     pub fn sendfile(src: Fd, dest: Fd, len: usize) -> Maybe<usize> {
         let len = len.min(i32::MAX as usize - 1);
@@ -3552,7 +3517,7 @@ mod posix_impl {
     }
     #[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
     pub fn sendfile(src: Fd, _dest: Fd, _len: usize) -> Maybe<usize> {
-        // sys.zig:513 `errnoSysFd(rc, .sendfile, src)` — attach the *source* fd.
+        // Attach the *source* fd.
         Err(Error::from_code_int(libc::ENOSYS, Tag::sendfile).with_fd(src))
     }
 }
@@ -3564,7 +3529,7 @@ pub use posix_impl::*;
 pub use bun_alloc::page_size;
 
 /// `bun.jsc.Node.TimeLike` — `timespec` shape, decoupled from JSC (T6).
-/// sys.zig takes this for futimens/utimens; the JSC binding constructs it from
+/// futimens/utimens take this; the JSC binding constructs it from
 /// JS Date/number. T1 owns the data shape.
 #[derive(Clone, Copy, Debug, Default)]
 #[repr(C)]
@@ -3602,7 +3567,6 @@ pub const UTIME_OMIT: i64 = -2;
 #[path = "sys_uv.rs"]
 pub mod sys_uv;
 
-/// Zig: `pub const sys_uv = if (Environment.isWindows) @import("./sys_uv.zig") else sys;`
 /// On non-Windows, `sys_uv` is just an alias for the regular syscall surface so
 /// callers (e.g. `pack_command`) can write `bun_sys::sys_uv::fstat(fd)` portably.
 #[cfg(not(windows))]
@@ -3614,14 +3578,14 @@ pub mod sys_uv {
 
 #[cfg(windows)]
 mod windows_impl {
-    // PORT: NT/kernel32/libuv triad (sys.zig + sys_uv.zig). The libuv-backed ops
-    // delegate to `crate::sys_uv`; the rest are the windows arms of `sys.zig`.
+    // NT/kernel32/libuv triad. The libuv-backed ops
+    // delegate to `crate::sys_uv`; the rest call NT/kernel32 directly.
     use super::windows as w;
     use super::windows::libuv as uv;
     use super::*;
     use bun_paths::WPathBuffer;
 
-    // ── libuv-backed (sys_uv.zig) ────────────────────────────────────────
+    // ── libuv-backed ─────────────────────────────────────────────────────
     pub fn open(path: &ZStr, flags: i32, mode: Mode) -> Maybe<Fd> {
         sys_uv::open(path, flags, mode)
     }
@@ -3632,21 +3596,17 @@ mod windows_impl {
         }
     }
     pub fn read(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
-        // sys.zig:2161-2183 — `.windows => if (fd.kind == .uv) sys_uv.read(fd,
-        // buf) else { kernel32.ReadFile(fd.native(), …) }`. The libuv path
+        // libuv for uv-kind fds, kernel32 `ReadFile` otherwise. The libuv path
         // requires a CRT fd via `fd.uv()`, which PANICS for HANDLE-backed
         // (`FdKind::System`) Fds — i.e. anything from `openat()`/NtCreateFile.
         if fd.kind() == FdKind::Uv {
             return sys_uv::read(fd, buf);
         }
         let adjusted_len = buf.len().min(MAX_COUNT) as w::DWORD;
-        // PORT NOTE: the Zig spec for `bun.sys.read` returns the raw error, but
-        // every Zig stdin caller (`run_command.zig`, `prompt.zig`, `init`, …)
-        // routes through `std.fs.File.readerStreaming` → `std.os.windows.ReadFile`,
-        // which maps BROKEN_PIPE/HANDLE_EOF → 0 (EOF) and retries on
-        // OPERATION_ABORTED. The Rust port consolidated those callers onto this
-        // function (via `File::stdin().read_to_end_into` / `output_sink().read`),
-        // so the stdlib-ReadFile EOF handling lives here.
+        // Stdin callers route through this function (via
+        // `File::stdin().read_to_end_into` / `output_sink().read`), so the
+        // BROKEN_PIPE/HANDLE_EOF → 0 (EOF) mapping and the OPERATION_ABORTED
+        // retry live here.
         loop {
             let mut amount_read: w::DWORD = 0;
             // SAFETY: FFI; `fd.cast()` is a valid HANDLE, buf valid for `adjusted_len`.
@@ -3671,12 +3631,12 @@ mod windows_impl {
         }
     }
     pub fn write(fd: Fd, buf: &[u8]) -> Maybe<usize> {
-        // sys.zig:1876-1909 — `.windows => { kernel32.WriteFile(fd.cast(), …) }`
+        // kernel32 `WriteFile` directly
         // (NOT via libuv — sys_uv::write → fd.uv() panics for HANDLE-backed
-        // Fds). Spec also remaps `ERROR_ACCESS_DENIED → EBADF` (a write to a
+        // Fds). Also remaps `ERROR_ACCESS_DENIED → EBADF` (a write to a
         // read-only-opened HANDLE yields ACCESS_DENIED, which POSIX surfaces
         // as EBADF "fd not open for writing").
-        debug_assert!(!buf.is_empty()); // Zig: `bun.assert(bytes.len > 0)`
+        debug_assert!(!buf.is_empty());
         let adjusted_len = buf.len().min(MAX_COUNT) as w::DWORD;
         let mut bytes_written: w::DWORD = 0;
         // SAFETY: FFI; `fd.cast()` is a valid HANDLE, buf valid for `adjusted_len`.
@@ -3701,14 +3661,9 @@ mod windows_impl {
         Ok(bytes_written as usize)
     }
     pub fn pread(fd: Fd, buf: &mut [u8], off: i64) -> Maybe<usize> {
-        // sys.zig:2083 — `pread_sym = syscall.pread` (`@compileError` on
-        // Windows), so `bun.sys.pread` itself is uncallable there. The Zig
-        // call sites that need positioned I/O on a HANDLE-backed fd go via
-        // `fd.stdFile().preadAll()` → `std.os.windows.ReadFile` with an
-        // `OVERLAPPED.Offset`. The Rust port has no `stdFile()` escape hatch
-        // (`File::pread_all` routes back here), so do that lowering inline:
+        // Positioned-I/O lowering:
         // libuv path for uv-kind fds, kernel32 ReadFile+OVERLAPPED for system
-        // (HANDLE) fds — matching `std.os.windows.ReadFile`'s error mapping.
+        // (HANDLE) fds.
         if fd.kind() == FdKind::Uv {
             return sys_uv::pread(fd, buf, off);
         }
@@ -3738,7 +3693,7 @@ mod windows_impl {
             if rc == 0 {
                 let er = w::Win32Error::get();
                 match er {
-                    // std.os.windows.ReadFile: BROKEN_PIPE/HANDLE_EOF → 0.
+                    // BROKEN_PIPE/HANDLE_EOF map to EOF (0 bytes read).
                     w::Win32Error::BROKEN_PIPE | w::Win32Error::HANDLE_EOF => return Ok(0),
                     w::Win32Error::OPERATION_ABORTED => continue,
                     _ => return Err(Error::new(er.to_e(), Tag::pread).with_fd(fd)),
@@ -3748,10 +3703,8 @@ mod windows_impl {
         }
     }
     pub fn pwrite(fd: Fd, buf: &[u8], off: i64) -> Maybe<usize> {
-        // sys.zig:2108 — same `@compileError` story as `pread`. Zig callers
-        // (e.g. updatePackageJSONAndInstall.zig:426 `…stdFile().pwriteAll()`)
-        // reach `std.os.windows.WriteFile` with an `OVERLAPPED.Offset`; do
-        // that here for HANDLE-kind fds since `File::pwrite_all` routes back.
+        // Same lowering as `pread`: kernel32 WriteFile with an
+        // `OVERLAPPED.Offset` for HANDLE-kind fds.
         if fd.kind() == FdKind::Uv {
             return sys_uv::pwrite(fd, buf, off);
         }
@@ -3779,8 +3732,8 @@ mod windows_impl {
         };
         if rc == 0 {
             let er = w::Win32Error::get();
-            // std.os.windows.WriteFile maps INVALID_HANDLE → NotOpenForWriting;
-            // keep parity with `write()` above and surface the raw errno.
+            // Keep parity with `write()` above and surface the raw errno
+            // (no INVALID_HANDLE → NotOpenForWriting remapping).
             let errno = if er == w::Win32Error::ACCESS_DENIED {
                 E::EBADF
             } else {
@@ -3794,13 +3747,10 @@ mod windows_impl {
         sys_uv::stat(path)
     }
     pub fn fstat(fd: Fd) -> Maybe<Stat> {
-        // sys.zig:589-594 — `const uvfd = fd.makeLibUVOwned() catch return
-        // .err(.MFILE, .uv_open_osfhandle); return sys_uv.fstat(uvfd);`.
         // sys_uv::fstat does `fd.uv()` which PANICS for HANDLE-backed
-        // (`FdKind::System`) Fds — i.e. the result of `openat()`. The spec
-        // converts via `_open_osfhandle` first (acknowledged CRT-fd leak; see
-        // the `// TODO: this is a bad usage of makeLibUVOwned` in sys.zig —
-        // a leak is strictly better than the previous guaranteed panic).
+        // (`FdKind::System`) Fds — i.e. the result of `openat()`. Convert
+        // via `_open_osfhandle` first (acknowledged CRT-fd leak —
+        // a leak is strictly better than a guaranteed panic).
         let uvfd = fd
             .make_libuv_owned()
             .map_err(|_| Error::new(E::EMFILE, Tag::uv_open_osfhandle).with_fd(fd))?;
@@ -3819,7 +3769,6 @@ mod windows_impl {
         sys_uv::rename(from, to)
     }
     pub fn symlink(target: &ZStr, link: &ZStr) -> Maybe<()> {
-        // sys.zig:2629 — windows uses `sys_uv.symlinkUV(target, dest, 0)`.
         sys_uv::symlink_uv(target, link, 0)
     }
     pub fn readlink(path: &ZStr, buf: &mut [u8]) -> Maybe<usize> {
@@ -3832,7 +3781,7 @@ mod windows_impl {
         sys_uv::fchown(fd, uid as _, gid as _)
     }
     pub fn ftruncate(fd: Fd, len: i64) -> Maybe<()> {
-        // sys.zig:2403-2419 — windows arm calls `NtSetInformationFile(..,
+        // Calls `NtSetInformationFile(..,
         // FileEndOfFileInformation)` directly on the HANDLE (NOT via libuv —
         // sys_uv::ftruncate requires a CRT fd via `fd.uv()`, which fails for
         // HANDLE-backed `Fd`s that have no uv mapping).
@@ -3849,7 +3798,6 @@ mod windows_impl {
             )
         };
         if rc != bun_windows_sys::NTSTATUS::SUCCESS {
-            // sys.zig:2487 `Maybe(void).errnoSysFd(rc, .ftruncate, fd)` —
             // `errnoSys` for `NTSTATUS` routes through the curated
             // `translateNTStatusToErrno` table, NOT `RtlNtStatusToDosError`.
             let errno = w::translate_nt_status_to_errno(rc);
@@ -3873,11 +3821,10 @@ mod windows_impl {
         sys_uv::fdatasync(fd)
     }
 
-    // ── kernel32 / ntdll arms (sys.zig windows branches) ─────────────────
+    // ── kernel32 / ntdll arms ────────────────────────────────────────────
     pub fn openat(dir: impl AsFd, path: &ZStr, flags: i32, mode: Mode) -> Maybe<Fd> {
         let dir = dir.as_fd();
-        // sys.zig:1773 — `if (Environment.isWindows) return openatWindowsT(u8,
-        // dirfd, file_path, flags, perm)`. Route through the NtCreateFile path
+        // Route through the NtCreateFile path
         // (normalize → `open_file_at_windows_nt_path`) so the result is a
         // HANDLE-backed `Fd` and `O::DIRECTORY`/`O::NOFOLLOW`/`O::PATH` are
         // honoured. Do NOT fall back to libuv `open()` here — that returns a
@@ -3885,7 +3832,7 @@ mod windows_impl {
         super::openat_windows_a(dir, path.as_bytes(), flags, mode)
     }
     pub fn dup(fd: Fd) -> Maybe<Fd> {
-        // sys.zig:3911 — DuplicateHandle on the underlying HANDLE.
+        // DuplicateHandle on the underlying HANDLE.
         let process = w::kernel32::GetCurrentProcess();
         let mut target: w::HANDLE = core::ptr::null_mut();
         let out = unsafe {
@@ -3905,13 +3852,13 @@ mod windows_impl {
         Ok(Fd::from_native(target as _))
     }
     pub fn dup2(old: Fd, new: Fd) -> Maybe<Fd> {
-        // No POSIX dup2 on Windows; sys.zig only dispatches via libuv c-runtime fds.
+        // No POSIX dup2 on Windows.
         // Return ENOTSUP so callers that branch on platform fall back.
         let _ = (old, new);
         Err(Error::new(E::ENOTSUP, Tag::dup2))
     }
     pub fn getcwd(buf: &mut [u8]) -> Maybe<usize> {
-        // sys.zig:349 — GetCurrentDirectoryW + WTF16→UTF8.
+        // GetCurrentDirectoryW + WTF16→UTF8.
         let mut wbuf = WPathBuffer::default();
         let len =
             unsafe { w::kernel32::GetCurrentDirectoryW(wbuf.len() as u32, wbuf.as_mut_ptr()) };
@@ -3930,9 +3877,8 @@ mod windows_impl {
     }
     pub fn mkdirat(dir: impl AsFd, path: &ZStr, _mode: Mode) -> Maybe<()> {
         let dir = dir.as_fd();
-        // sys.zig:829 mkdiratW — `openDirAtWindowsNtPath(dir, path,
-        // .{ .iterable = false, .can_rename_or_delete = true, .op = .only_create })`
-        // then close the resulting handle on success.
+        // Open with `op = OnlyCreate`, then close the resulting handle on
+        // success.
         let mut wbuf = WPathBuffer::default();
         let wpath = bun_paths::string_paths::to_nt_path(&mut wbuf, path.as_bytes());
         let made = super::open_dir_at_windows_nt_path(
@@ -3951,7 +3897,6 @@ mod windows_impl {
     pub fn renameat(from_dir: impl AsFd, from: &ZStr, to_dir: impl AsFd, to: &ZStr) -> Maybe<()> {
         let from_dir = from_dir.as_fd();
         let to_dir = to_dir.as_fd();
-        // sys.zig:2572 — windows arm goes through renameAtW.
         let mut wf = WPathBuffer::default();
         let mut wt = WPathBuffer::default();
         let from_w = bun_paths::string_paths::to_nt_path(&mut wf, from.as_bytes());
@@ -3965,16 +3910,15 @@ mod windows_impl {
         to: &ZStr,
         flags: Renameat2Flags,
     ) -> Maybe<()> {
-        // sys.zig:2538 — `renameat2` collapses to `renameat` on windows; the
+        // `renameat2` collapses to `renameat` on windows; the
         // `noreplace`/`exchange` flags are not honored by NTFS rename.
         let _ = flags;
         renameat(from_dir, from, to_dir, to)
     }
     pub fn unlinkat_with_flags(dir: Fd, path: &ZStr, flags: i32) -> Maybe<()> {
-        // sys.zig:2884-2896 `unlinkatWithFlags` windows arm: convert to NT path
-        // and call `DeleteFileBun` with `.dir = if (dirfd != bun.invalid_fd)
-        // dirfd.cast() else null` and `.remove_dir = flags & AT.REMOVEDIR != 0`.
-        // `std.posix.AT.REMOVEDIR` on Windows = 0x200 (std/c.zig).
+        // Convert to NT path and call `DeleteFileBun`;
+        // `remove_dir = flags & AT_REMOVEDIR != 0`.
+        // AT_REMOVEDIR on Windows = 0x200.
         const AT_REMOVEDIR: i32 = 0x200;
         let mut wbuf = WPathBuffer::default();
         let wpath = bun_paths::string_paths::to_nt_path(&mut wbuf, path.as_bytes());
@@ -3990,7 +3934,7 @@ mod windows_impl {
             },
         )
     }
-    /// sys.zig:2912 `unlinkat` — 2-arg form (`flags = 0`).
+    /// 2-arg form (`flags = 0`).
     #[inline]
     pub fn unlinkat(dir: impl AsFd, path: &ZStr) -> Maybe<()> {
         let dir = dir.as_fd();
@@ -4002,23 +3946,19 @@ mod windows_impl {
         mkdir_recursive_at_mode(dir, sub, 0o777)
     }
     pub fn mkdir_recursive_at_mode(dir: Fd, sub: &[u8], mode: Mode) -> Maybe<()> {
-        // Port of `bun.makePath` (bun.zig:2288). The component-splitting and
+        // `bun.makePath`. The component-splitting and
         // back-then-forward walk live in `bun_paths::{ComponentIterator,
-        // make_path_with}` (faithful `std.fs.path.ComponentIterator` port — it
+        // make_path_with}` (`ComponentIterator`
         // never yields a bare `"C:"` / `"\\server\share"` root, which is what
         // broke the old forward-split impl for absolute paths fed by
         // `bin::Linker::create_windows_shim`).
         //
-        // What stays here is a `.`/`..` *pre-normalize* pass: Zig's
-        // `std.fs.Dir.makePath` calls `std.posix.mkdirat`, which on Windows
-        // normalizes each prefix through `sliceToPrefixedFileW` →
-        // `removeDotDirsSanitized` / `RtlGetFullPathName_U`, collapsing every
-        // `.` and `..` before `NtCreateFile`. Our `mkdirat` below routes
+        // What stays here is a `.`/`..` *pre-normalize* pass: our `mkdirat` below routes
         // through bun's `to_nt_path` which only flips slashes, so a literal
         // `"."`/`".."` ObjectName reaches `NtCreateFile` un-normalized — `.`
         // → `OBJECT_NAME_NOT_FOUND` (ENOENT, not the EEXIST the walk expects)
-        // and `a\..\b` live-locks the walk. Normalizing here matches the
-        // stdlib's effective behavior (compile-outfile-subdirs.test.ts
+        // and `a\..\b` live-locks the walk. Normalizing here preserves the
+        // expected behavior (compile-outfile-subdirs.test.ts
         // "works with . and .. in paths", outfile
         // `./output/../output/./app.exe`).
         use bun_paths::{ComponentIterator, MakePathStep, PathFormat, is_sep_any as is_sep};
@@ -4145,12 +4085,11 @@ mod windows_impl {
         link(s_abs, d_abs)
     }
     pub fn linkat_tmpfile(_tmpfd: Fd, _dirfd: Fd, _name: &ZStr) -> Maybe<()> {
-        // sys.zig:3973 — `if (!Environment.isLinux) @compileError("Linux only")`.
         Err(Error::new(E::ENOTSUP, Tag::link))
     }
     pub fn symlinkat(target: &ZStr, dirfd: impl AsFd, dest: &ZStr) -> Maybe<()> {
         let dirfd = dirfd.as_fd();
-        // sys.zig:2641 — windows: resolve `dest` against `dirfd`, then symlinkUV.
+        // Resolve `dest` against `dirfd`, then symlink via libuv.
         let mut db = bun_core::PathBuffer::default();
         let d = super::get_fd_path(dirfd, &mut db)?;
         let mut dj = bun_core::PathBuffer::default();
@@ -4198,22 +4137,22 @@ mod windows_impl {
     }
     pub fn fstatat(fd: impl AsFd, path: &ZStr) -> Maybe<Stat> {
         let fd = fd.as_fd();
-        // sys.zig:838-846 — windows arm: `openatWindowsA(fd, path, 0, 0)` (flags=0
+        // `openat(fd, path, 0, 0)` (flags=0
         // → FOLLOWS reparse points) then `fstat(file)`. Do NOT use `lstat` here —
-        // that's the `lstatat` (sys.zig:863) no-follow variant.
+        // that's the `lstatat` no-follow variant.
         let file = openat(fd, path, 0, 0)?;
         let r = fstat(file);
         let _ = close(file);
         r
     }
     pub fn access(path: &ZStr, mode: i32) -> Maybe<()> {
-        // sys.zig:1748-1768 — windows arm: GetFileAttributesW, then if
+        // GetFileAttributesW, then if
         // `(mode & W_OK) != 0` AND the file is read-only AND it is NOT a
         // directory, return `.err = EPERM`.
         const W_OK: i32 = 2;
         // Longer than any path NT can address — reject up front instead of
         // letting the wide conversion below fail-safe to a prefix-only path
-        // (mirrors `PathLikeExt` and the Zig-side fix in oven-sh/bun#27775,
+        // (mirrors `PathLikeExt`; see oven-sh/bun#27775,
         // which handled `access` as one of its call sites). `path` may
         // already carry a `\\?\` prefix (NodeFS::access routes through
         // `slice_z`, which prepends it) — check the unprefixed form so the
@@ -4239,9 +4178,8 @@ mod windows_impl {
     }
     pub fn faccessat(dir: impl AsFd, sub: &ZStr) -> Maybe<bool> {
         let dir = dir.as_fd();
-        // sys.zig:3504-3531 — `faccessat` NEVER returns `.err`: rc==0 → `.result
-        // = true`, else → `.result = false` regardless of errno. There is no
-        // dedicated windows arm in the spec; collapse all errors to `Ok(false)`.
+        // `faccessat` NEVER errors: success → `Ok(true)`, else `Ok(false)`
+        // regardless of errno; collapse all errors to `Ok(false)`.
         match openat(dir, sub, O::RDONLY, 0) {
             Ok(fd) => {
                 let _ = close(fd);
@@ -4251,8 +4189,7 @@ mod windows_impl {
         }
     }
     pub fn futimens(fd: Fd, atime: TimeLike, mtime: TimeLike) -> Maybe<()> {
-        // sys.zig:3612 has `@compileError("TODO: futimens")` on Windows; the
-        // libuv path here predates the spec port. `uv_fs_futime` takes a CRT
+        // `uv_fs_futime` takes a CRT
         // fd, and `fd.uv()` PANICS for HANDLE-backed (`FdKind::System`) Fds.
         // Convert via `make_libuv_owned()` first (passes uv-backed Fds through
         // unchanged) so an `openat()` result no longer crashes.
@@ -4264,7 +4201,7 @@ mod windows_impl {
         let mut req = uv::fs_t::uninitialized();
         let rc =
             unsafe { uv::uv_fs_futime(core::ptr::null_mut(), &mut req, uvfd.uv(), a, m, None) };
-        // Zig: `defer req.deinit()` — fs_t has no Drop impl; uv_fs_req_cleanup
+        // fs_t has no Drop impl; uv_fs_req_cleanup
         // must run before any return (fd-based, so no path buffer is captured,
         // but keep the pattern uniform with utimens/lutimens below).
         req.deinit();
@@ -4287,7 +4224,7 @@ mod windows_impl {
                 None,
             )
         };
-        // Zig: `defer req.deinit()` — uv_fs_utime runs fs__capture_path which
+        // uv_fs_utime runs fs__capture_path which
         // uv__malloc's the WTF-16 path into the req even for sync (cb=NULL)
         // calls; only uv_fs_req_cleanup frees it. fs_t has no Drop impl, so
         // call it explicitly before any return.
@@ -4311,7 +4248,7 @@ mod windows_impl {
                 None,
             )
         };
-        // Zig: `defer req.deinit()` — same fs__capture_path leak as utimens.
+        // Same fs__capture_path leak as utimens.
         req.deinit();
         if let Some(err) = Error::from_uv_rc(rc, Tag::lutime) {
             return Err(err.with_path(path.as_bytes()));
@@ -4319,12 +4256,12 @@ mod windows_impl {
         Ok(())
     }
     pub fn exists_z(path: &ZStr) -> bool {
-        // sys.zig:3482 — windows arm: GetFileAttributesW != INVALID.
+        // GetFileAttributesW != INVALID.
         access(path, 0).is_ok()
     }
     pub fn exists_at(dir: impl AsFd, sub: &ZStr) -> bool {
         let dir = dir.as_fd();
-        // sys.zig:3726-3731 — windows arm: `existsAtType(fd, subpath) == .file`.
+        // `exists_at_type(fd, subpath) == File`.
         // Directories yield `false` (resolver/install code uses `existsAt` to
         // mean "a *file* exists here").
         matches!(
@@ -4333,11 +4270,10 @@ mod windows_impl {
         )
     }
     pub fn is_executable_file_path(path: &ZStr) -> bool {
-        // sys.zig:3779-3784 — windows arm: convert to wide and call
-        // `bun.windows.SaferiIsExecutableFileType(path, FALSE)`. Honors the
+        // Convert to wide and call
+        // `SaferiIsExecutableFileType(path, FALSE)`. Honors the
         // system security policy and recognizes `.js/.lnk/.pif/.pl/.shs/.url/
-        // .vbs/...` in addition to `.exe/.cmd/.bat/.com` (per the comment block
-        // at sys.zig:3744-3761). Do NOT hand-roll an extension whitelist —
+        // .vbs/...` in addition to `.exe/.cmd/.bat/.com` . Do NOT hand-roll an extension whitelist —
         // PORTING.md §Forbidden bars re-implementing linked OS API surface.
         let mut wbuf = WPathBuffer::default();
         let wpath = bun_paths::string_paths::to_w_path(&mut wbuf, path.as_bytes());
@@ -4347,13 +4283,13 @@ mod windows_impl {
         unsafe { w::SaferiIsExecutableFileType(wpath.as_ptr(), 0) != w::FALSE }
     }
     pub fn get_file_size(fd: Fd) -> Maybe<u64> {
-        // sys.zig:4140 — GetFileSizeEx.
+        // GetFileSizeEx.
         let mut size: i64 = 0;
         let ok = unsafe { w::kernel32::GetFileSizeEx(fd.native() as w::HANDLE, &mut size) };
         if ok == 0 {
             return Err(Error::new(w::get_last_errno(), Tag::fstat).with_fd(fd));
         }
-        // sys.zig:4217 `@intCast(@max(size, 0))` — clamp defensively so a
+        // Clamp defensively so a
         // negative LARGE_INTEGER never becomes ~18 EB after the i64→u64 cast.
         Ok(size.max(0) as u64)
     }
@@ -4366,11 +4302,10 @@ mod windows_impl {
         r.map(|s| &*s)
     }
     pub fn fcntl(_fd: Fd, _cmd: i32, _arg: isize) -> Maybe<isize> {
-        // sys.zig:959 — `if (Environment.isWindows) @compileError("not implemented")`.
         Err(Error::new(E::ENOTSUP, Tag::fcntl))
     }
     pub fn pipe() -> Maybe<[Fd; 2]> {
-        // sys.zig:3839 — windows: uv_pipe(fds, 0, 0).
+        // uv_pipe(fds, 0, 0).
         let mut fds: [uv::uv_file; 2] = [-1, -1];
         let rc = unsafe { uv::uv_pipe(&mut fds, 0, 0) };
         if let Some(err) = Error::from_uv_rc(rc, Tag::pipe) {
@@ -4390,7 +4325,7 @@ mod windows_impl {
         }
     }
     pub fn lseek(fd: Fd, offset: i64, whence: i32) -> Maybe<i64> {
-        // sys.zig:2339 — windows: SetFilePointerEx.
+        // SetFilePointerEx.
         let mut new: i64 = 0;
         let ok = unsafe {
             w::SetFilePointerEx(fd.native() as w::HANDLE, offset, &mut new, whence as u32)
@@ -4400,7 +4335,7 @@ mod windows_impl {
         }
         Ok(new)
     }
-    /// sys.zig:3822 `setFileOffsetToEndWindows` — `SetFilePointerEx(.., FILE_END)`
+    /// `SetFilePointerEx(.., FILE_END)`
     /// returning the new offset as `usize`.
     pub fn set_file_offset_to_end_windows(fd: Fd) -> Maybe<usize> {
         let mut new: i64 = 0;
@@ -4412,7 +4347,7 @@ mod windows_impl {
         Ok(usize::try_from(new).expect("int cast"))
     }
     pub fn chdir(path: &ZStr) -> Maybe<()> {
-        // sys.zig:452-455 — windows: `SetCurrentDirectoryW(toWDirPath(..))`.
+        // `SetCurrentDirectoryW(toWDirPath(..))`.
         // `toWDirPath` appends a trailing backslash so e.g. `"C:"` is treated
         // as the drive root, not the drive's saved cwd.
         let mut wbuf = WPathBuffer::default();
@@ -4432,14 +4367,13 @@ mod windows_impl {
         chdir(ZStr::from_buf(&zb.0[..], p.len()))
     }
     pub fn umask(mode: Mode) -> Mode {
-        // sys.zig: `_umask` (msvcrt).
         unsafe extern "C" {
             safe fn _umask(m: core::ffi::c_int) -> core::ffi::c_int;
         }
         _umask(mode as core::ffi::c_int) as Mode
     }
     pub fn recv(fd: Fd, buf: &mut [u8], flags: i32) -> Maybe<usize> {
-        // sys.zig:2243-2244 — windows: winsock `recv`. Winsock's `len` is a
+        // Winsock `recv`. Winsock's `len` is a
         // signed `int`, so clamp to `i32::MAX` (NOT `MAX_COUNT == u32::MAX`)
         // before the `usize → i32` cast — otherwise ≥2 GiB buffers wrap to a
         // negative length and Winsock fails with WSAEFAULT.
@@ -4454,7 +4388,7 @@ mod windows_impl {
         Ok(rc as usize)
     }
     pub fn send(fd: Fd, buf: &[u8], flags: i32) -> Maybe<usize> {
-        // sys.zig:2294 — windows: winsock `send`. Clamp to `i32::MAX` so the
+        // Winsock `send`. Clamp to `i32::MAX` so the
         // `usize → i32` cast can't wrap to a negative length on huge buffers.
         let len = buf.len().min(i32::MAX as usize) as i32;
         let rc = unsafe { w::ws2_32::send(fd.native() as _, buf.as_ptr().cast::<_>(), len, flags) };
@@ -4472,7 +4406,7 @@ mod windows_impl {
         send(fd, buf, 0)
     }
     pub fn socketpair(_domain: i32, _ty: i32, _proto: i32, _nonblock: bool) -> Maybe<[Fd; 2]> {
-        // sys.zig:3103 — `if (Environment.isWindows) @compileError("use spawnIPCSocket on Windows")`.
+        // Use spawnIPCSocket on Windows instead.
         Err(Error::new(E::ENOTSUP, Tag::socketpair))
     }
     pub fn mmap(
@@ -4483,17 +4417,15 @@ mod windows_impl {
         _fd: Fd,
         _off: i64,
     ) -> Maybe<*mut u8> {
-        // sys.zig:3006 — `if (Environment.isWindows) @compileError("not implemented")`.
         Err(Error::new(E::ENOTSUP, Tag::mmap))
     }
     pub fn munmap(_ptr: *mut u8, _len: usize) -> Maybe<()> {
-        // sys.zig:3231 — `if (Environment.isWindows) @compileError("not implemented")`.
         Err(Error::new(E::ENOTSUP, Tag::munmap))
     }
     pub fn sendfile(src: Fd, _dest: Fd, _len: usize) -> Maybe<usize> {
-        // sys.zig:504 has NO Windows arm — `bun.sys.sendfile` is Linux-only
-        // (`std.os.linux.sendfile` with a *null* offset so the kernel advances
-        // the source fd's file position). The previous port called
+        // `bun.sys.sendfile` is Linux-only
+        // (`sendfile(2)` with a *null* offset so the kernel advances
+        // the source fd's file position). An earlier implementation called
         // `uv_fs_sendfile(..., in_offset=0, ...)`, which (a) re-reads byte 0
         // on every iteration of a chunked copy loop and (b) returned the int
         // rc (always `0` on success) instead of `req.result`. Surface ENOSYS
@@ -4538,7 +4470,7 @@ fn read_fill_vec(
 // ──────────────────────────────────────────────────────────────────────────
 // `bun.PlatformIOVecConst` / `bun.platformIOVecConstCreate` — POSIX
 // `iovec_const` (= `struct iovec` with the writev contract that `base` is
-// not written through). On Windows the Zig original aliases `uv_buf_t`;
+// not written through). On Windows this aliases `uv_buf_t`;
 // that arm lives in `windows_impl` below.
 // Layout matches `libc::iovec` (`{ *void, usize }`) so a `&[PlatformIoVecConst]`
 // can be passed straight to `pwritev(2)`.
@@ -4575,10 +4507,10 @@ pub fn pwritev(fd: Fd, vecs: &[PlatformIoVecConst], offset: i64) -> Maybe<usize>
     {
         // SAFETY: `PlatformIoVecConst` is layout-compatible with `libc::iovec`
         // (asserted above); `pwritev(2)` only reads through `iov_base`.
-        // sys.zig:2064 — Darwin uses `pwritev$NOCANCEL` (avoid cancellation point).
+        // Darwin uses `pwritev$NOCANCEL` (avoid cancellation point).
         #[cfg(target_os = "macos")]
         {
-            // sys.zig:1955-1964 — `.mac` arm: single `pwritev$NOCANCEL`, no
+            // macOS: single `pwritev$NOCANCEL`, no
             // EINTR retry (surfaces EINTR to caller).
             // SAFETY: `fd` is a live descriptor; `vecs` gives an exact
             // (ptr, len) pair of layout-compatible iovecs (asserted above).
@@ -4625,7 +4557,6 @@ pub fn pwritev(fd: Fd, vecs: &[PlatformIoVecConst], offset: i64) -> Maybe<usize>
     }
     #[cfg(windows)]
     {
-        // sys.zig:1953 — `if (Environment.isWindows) return sys_uv.pwritev(...)`.
         // `PlatformIoVecConst` is layout-identical to `uv_buf_t` on Windows
         // (asserted below), so the slice forwards as-is.
         sys_uv::pwritev(fd, vecs, offset)
@@ -4641,8 +4572,8 @@ pub fn pwritev(fd: Fd, vecs: &[PlatformIoVecConst], offset: i64) -> Maybe<usize>
 pub type PlatformIoVec = libc::iovec;
 #[cfg(windows)]
 pub type PlatformIoVec = bun_libuv_sys::uv_buf_t;
-// Zig spells these `PlatformIOVec` / `PlatformIOVecConst`; provide both
-// casings so ported call sites (`sys_uv.rs`) compile without churn.
+// Both casings of `PlatformIOVec` / `PlatformIOVecConst` are provided so
+// existing call sites (`sys_uv.rs`) compile without churn.
 pub use PlatformIoVec as PlatformIOVec;
 pub use PlatformIoVecConst as PlatformIOVecConst;
 
@@ -4658,7 +4589,7 @@ pub fn platform_iovec_create(buf: &mut [u8]) -> PlatformIoVec {
     #[cfg(windows)]
     {
         // `uv_buf_t` on Windows is `{ ULONG len; char* base; }` — order-swapped vs
-        // POSIX iovec. Zig: `comptime bun.assert(bun.PlatformIOVec == uv.uv_buf_t)`.
+        // POSIX iovec.
         PlatformIoVec {
             len: buf.len() as bun_libuv_sys::ULONG,
             base: buf.as_mut_ptr(),
@@ -4695,14 +4626,14 @@ pub fn platform_iovec_const_create(buf: &[u8]) -> PlatformIoVecConst {
 }
 
 /// `bun.sys.writev` — gather-write. macOS uses `writev$NOCANCEL` with no
-/// EINTR retry (sys.zig:1923-1934); other POSIX retries on EINTR.
+/// EINTR retry; other POSIX retries on EINTR.
 pub fn writev(fd: Fd, vecs: &[PlatformIoVec]) -> Maybe<usize> {
     #[cfg(unix)]
     {
         #[cfg(target_os = "macos")]
         {
             // SAFETY: `PlatformIoVec` is `libc::iovec`; writev(2) only reads
-            // the descriptor table. sys.zig:1925 — single shot, surfaces EINTR.
+            // the descriptor table. Single shot, surfaces EINTR.
             let rc = unsafe {
                 nocancel::writev(fd.native(), vecs.as_ptr(), vecs.len() as core::ffi::c_int)
             };
@@ -4741,7 +4672,7 @@ pub fn writev(fd: Fd, vecs: &[PlatformIoVec]) -> Maybe<usize> {
 }
 
 /// `bun.sys.readv` — scatter-read. macOS uses `readv$NOCANCEL` with no
-/// EINTR retry (sys.zig:1982-2014); other POSIX retries on EINTR.
+/// EINTR retry; other POSIX retries on EINTR.
 pub fn readv(fd: Fd, vecs: &[PlatformIoVec]) -> Maybe<usize> {
     #[cfg(debug_assertions)]
     if vecs.is_empty() {
@@ -4752,7 +4683,7 @@ pub fn readv(fd: Fd, vecs: &[PlatformIoVec]) -> Maybe<usize> {
         #[cfg(target_os = "macos")]
         {
             // SAFETY: vecs.ptr is `*const iovec`; the kernel writes through
-            // each `iov_base`, never the array itself. sys.zig:1991 — single shot.
+            // each `iov_base`, never the array itself. Single shot.
             let rc = unsafe {
                 nocancel::readv(fd.native(), vecs.as_ptr(), vecs.len() as core::ffi::c_int)
             };
@@ -4790,7 +4721,7 @@ pub fn readv(fd: Fd, vecs: &[PlatformIoVec]) -> Maybe<usize> {
 }
 
 /// `bun.sys.preadv` — scatter-read at `position`. macOS uses
-/// `preadv$NOCANCEL` with no EINTR retry (sys.zig:2016-2048).
+/// `preadv$NOCANCEL` with no EINTR retry.
 pub fn preadv(fd: Fd, vecs: &[PlatformIoVec], position: i64) -> Maybe<usize> {
     #[cfg(debug_assertions)]
     if vecs.is_empty() {
@@ -4800,7 +4731,7 @@ pub fn preadv(fd: Fd, vecs: &[PlatformIoVec], position: i64) -> Maybe<usize> {
     {
         #[cfg(target_os = "macos")]
         {
-            // SAFETY: see `readv`. sys.zig:2025 — single shot.
+            // SAFETY: see `readv`. Single shot.
             let rc = unsafe {
                 nocancel::preadv(
                     fd.native(),
@@ -4849,7 +4780,7 @@ pub fn preadv(fd: Fd, vecs: &[PlatformIoVec], position: i64) -> Maybe<usize> {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `bun.StatFS` / `bun.sys.statfs` — sys.zig:547-571.
+// `bun.StatFS` / `bun.sys.statfs`.
 // On POSIX `bun.StatFS` aliases `struct statfs` (Linux/macOS/FreeBSD); on
 // Windows it is `uv_statfs_t` populated from `GetDiskFreeSpace` (handled in
 // `sys_uv`).
@@ -4902,18 +4833,16 @@ pub fn statfs(path: &ZStr) -> Maybe<StatFS> {
 }
 
 /// `bun.timespec` — re-exported from `bun_core` so `PosixStat.rs` can spell
-/// `crate::Timespec` (matching the Zig `bun.timespec` namespacing).
+/// `crate::Timespec` (matching the `bun.timespec` namespacing).
 pub use bun_core::Timespec;
 /// `std.time` shim — re-exported from `bun_core` so callers that wrote
-/// `bun_sys::time::timestamp()` (matching Zig's `std.time` import via bun.sys)
-/// resolve without an extra dep.
+/// `bun_sys::time::timestamp()` resolve without an extra dep.
 pub use bun_core::time;
 
 /// `bun.sys.selfProcessMemoryUsage()` — returns the resident set size of the
 /// current process in bytes, or `None` on failure. Thin wrapper around the
 /// C++ `getRSS` shim (lives in `src/jsc/bindings/memory.cpp`).
 pub fn self_process_memory_usage() -> Option<usize> {
-    // TODO(port): move to <area>_sys
     unsafe extern "C" {
         // safe: out-param is `&mut usize` (non-null, valid for write); C++ side
         // only writes the slot and returns a status code — no other preconditions.
@@ -4926,9 +4855,9 @@ pub fn self_process_memory_usage() -> Option<usize> {
     Some(rss)
 }
 
-/// `bun.sys.PosixStat` — uv-shaped stat struct (`src/sys/PosixStat.zig`).
+/// `bun.sys.PosixStat` — uv-shaped stat struct.
 /// Re-exported here so dependents (`node_fs.rs`, `Stat.rs`) can spell
-/// `bun_sys::PosixStat` exactly as the Zig source spells `bun.sys.PosixStat`.
+/// `bun_sys::PosixStat`.
 #[path = "PosixStat.rs"]
 pub mod posix_stat;
 pub use posix_stat::PosixStat;
@@ -4956,21 +4885,20 @@ impl std::io::Read for FileReader {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Additional surface unblocked for dependents.
-// Symbols are real posix wrappers (sys.zig posix arms 1:1); Windows arms route
+// Symbols are real posix wrappers; Windows arms route
 // through the libuv/kernel32 layer in `windows_impl` above.
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun.sys.Error.Int` — backing integer for `errno`.
 pub type ErrorInt = error::Int;
-/// `std.posix.E` — un-prefixed errno enum (`.SUCCESS`, `.AGAIN`, ...).
-/// PORT NOTE: aliased to `bun_errno::E` (= `SystemErrno`); variants currently
+/// Errno enum,
+/// aliased to `bun_errno::E` (= `SystemErrno`); variants currently
 /// keep the `E` prefix (`EAGAIN` not `AGAIN`). Unprefixed associated consts
 /// live on `SystemErrno` directly (errno crate); callers comparing against
 /// `Errno::AGAIN`/`Errno::EXIST` rely on those.
 pub type Errno = E;
 
 /// `bun.sys.File.SizeHint` — pre-reserve hint for `read_to_end_with_array_list`.
-/// Mirrors Zig's `enum { probably_small, unknown_size }` (File.zig:298).
 #[derive(Clone, Copy, Debug)]
 pub enum SizeHint {
     /// Reserve a small fixed buffer (64B).
@@ -4979,15 +4907,15 @@ pub enum SizeHint {
     UnknownSize,
 }
 
-/// `std.process.EnvMap` — owned `KEY → VALUE` map of environment variables.
-/// Minimal real def (no Zig hash-map semantics needed; Rust callers iterate).
+/// Owned `KEY → VALUE` map of environment variables.
+/// Minimal real def (no hash-map semantics needed; callers iterate).
 pub type EnvMap = std::collections::HashMap<String, String>;
 
-/// `bun.sys.syslog` — debug-scoped log under `SYS` (Zig: `Output.scoped(.SYS)`).
-/// PORT NOTE: `bun_core::scoped_log!` only accepts a bare `$scope:ident`, so we
+/// `bun.sys.syslog` — debug-scoped log under `SYS`.
+/// `bun_core::scoped_log!` only accepts a bare `$scope:ident`, so we
 /// re-expand its body verbatim here with the qualified `$crate::fd::SYS` path
 /// and `::bun_core::` helpers — keeping the `[sys] ` tag prefix, trailing-`\n`
-/// append, and `pretty_fmt!` ANSI rewrite (output.zig:893-933) that
+/// append, and `pretty_fmt!` ANSI rewrite that
 /// `ScopedLogger::log()` does *not* add on its own.
 #[macro_export]
 macro_rules! syslog {
@@ -4998,7 +4926,7 @@ macro_rules! syslog {
             const __NL: &str =
                 ::bun_core::output::_needs_nl(::bun_core::pretty_fmt!($fmt, false));
             // Branch on ANSI *before* `format_args!` so each `$arg` evaluates
-            // exactly once (Zig builds the args tuple once — output.zig:922-933).
+            // exactly once.
             if ::bun_core::output::_scoped_use_ansi() {
                 $crate::fd::SYS.log(::core::format_args!(
                     concat!(
@@ -5055,7 +4983,7 @@ pub mod c {
         target_os = "openbsd"
     ))]
     pub use libc::{getloadavg, sockaddr_dl, sysctlbyname};
-    /// `std.c.fd_t` / `std.posix.fd_t` — native fd backing int (c_int on POSIX,
+    /// Native fd backing int (c_int on POSIX,
     /// HANDLE on Windows). Use `bun_sys::Fd` everywhere else; this raw alias
     /// exists only for direct libc FFI (e.g. `socketpair`).
     #[cfg(unix)]
@@ -5065,7 +4993,7 @@ pub mod c {
     #[allow(non_camel_case_types)]
     pub type fd_t = bun_core::FdNative;
     /// `bun.c.struct_statfs` — raw `struct statfs` (POSIX) / `uv_statfs_t` (Windows).
-    /// Aliased here so `bun.StatFS` (bun.zig:1703) resolves through `bun_sys::c`.
+    /// Aliased here so `bun.StatFS` resolves through `bun_sys::c`.
     pub use super::StatFS as struct_statfs;
 
     /// libc `dlsym` (RTLD_DEFAULT when `handle` is null).
@@ -5086,7 +5014,7 @@ pub mod c {
         // no caller precondition (dereferencing it is what requires care).
         bun_core::ffi::errno_ptr()
     }
-    // Win32 file APIs frequently spelled `bun.C.*` in Zig (windows.zig flattens
+    // Win32 file APIs frequently spelled `bun.C.*` (the namespace flattens
     // a slice of `kernel32` into `bun.C`). Re-export the handful node_fs.rs
     // reaches via `sys::c::*` so the call sites stay target-neutral.
     #[cfg(windows)]
@@ -5098,10 +5026,10 @@ pub mod c {
         FlushFileBuffers, GetFileAttributesW, SetConsoleCtrlHandler,
     };
 
-    // ── `bun.c` Darwin surface — translate-c symbols Zig picks up via
+    // ── `bun.c` Darwin surface — C symbols picked up via
     // `@cImport` of system headers. The `libc` crate already binds all of
     // these; re-export so callers (`node_os.rs`, `node_fs.rs`, …) keep a
-    // single `bun_sys::c::*` import path matching the Zig namespacing.
+    // single `bun_sys::c::*` import path matching the `bun.c` namespacing.
     #[cfg(target_os = "macos")]
     pub use libc::{
         _NSGetEnviron,
@@ -5209,7 +5137,7 @@ pub mod c {
 
     // ── <mach/mach_init.h> / <mach-o/dyld.h> — declared directly because the
     // `libc` crate has deprecated these in favour of the `mach2` crate. We
-    // bind the C symbols ourselves (as Zig's `std.c` does) so the workspace
+    // bind the C symbols ourselves so the workspace
     // stays free of an extra dependency and of deprecation noise.
     #[cfg(target_os = "macos")]
     unsafe extern "C" {
@@ -5236,8 +5164,7 @@ pub mod c {
         mach_task_self_
     }
     /// `_dyld_get_image_header(i)` — on 64-bit Darwin every loaded image is
-    /// 64-bit, so present it as `*const mach_header_64` (Zig's std does the
-    /// same cast).
+    /// 64-bit, so present it as `*const mach_header_64`.
     #[cfg(target_os = "macos")]
     #[inline]
     pub fn _dyld_get_image_header(image_index: u32) -> *const super::macho::mach_header_64 {
@@ -5266,7 +5193,7 @@ pub mod c {
     }
 
     /// Darwin `sendfile(fd, s, off, *len, *hdtr, flags)`.
-    /// NOTE (SendFile.zig:67): on `EINTR`/`EAGAIN` the kernel still writes the
+    /// NOTE: on `EINTR`/`EAGAIN` the kernel still writes the
     /// bytes-sent count back through `*len` before returning -1 — callers MUST
     /// advance their offset by `*len` even on error. This wrapper is raw (no
     /// EINTR retry); the caller owns the offset bookkeeping.
@@ -5370,11 +5297,10 @@ pub mod c {
     }
 }
 
-// ── `bun.linux` / `std.os.linux` — raw kernel syscalls (Linux + Android). ──
+// ── `linux` — raw kernel syscalls (Linux + Android). ──
 // Android: same kernel ABI; bionic exposes all the libc wrappers used here
-// (`inotify_*`, `ppoll`, `epoll_*`, `IN_*`, `EPOLL*`, `FUTEX_*`). Zig kept this
-// surface under `Environment.isLinux` (true on Android); list both `target_os`
-// values to mirror that.
+// (`inotify_*`, `ppoll`, `epoll_*`, `IN_*`, `EPOLL*`, `FUTEX_*`); list both
+// `target_os` values.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub mod linux {
     use core::ffi::{c_char, c_int};
@@ -5393,7 +5319,7 @@ pub mod linux {
     #[cfg(not(target_env = "musl"))]
     type time_t = libc::time_t;
 
-    /// `std.os.linux.timespec` — Zig-shape (`sec`/`nsec`, no `tv_` prefix).
+    /// kernel-shaped timespec (`sec`/`nsec`, no `tv_` prefix).
     /// Layout-identical to `libc::timespec` so a `*const timespec` can be
     /// passed straight to `syscall(SYS_futex, ..)`.
     #[repr(C)]
@@ -5407,14 +5333,14 @@ pub mod linux {
             && core::mem::align_of::<timespec>() == core::mem::align_of::<libc::timespec>()
     );
 
-    /// `std.os.linux.E` — errno; aliased to `bun_errno::E`.
+    /// Errno; aliased to `bun_errno::E`.
     pub type Errno = super::E;
     #[inline]
     pub fn errno() -> c_int {
         super::last_errno()
     }
 
-    /// `std.os.linux.E` — kernel errno enum with unprefixed variants and
+    /// Kernel errno enum with unprefixed variants and
     /// `init(rc)` decoding the `-errno`-in-return-value Linux raw-syscall ABI.
     /// Newtype (not an alias of `bun_errno::E`) because callers match on
     /// `E::AGAIN`/`E::INTR` (no `E` prefix).
@@ -5435,7 +5361,6 @@ pub mod linux {
         /// Decode a raw Linux syscall return (`-errno` on failure, ≥0 on success).
         #[inline]
         pub fn init(rc: isize) -> E {
-            // Zig: `if (rc > -4096) @enumFromInt(-rc) else .SUCCESS`.
             let u = rc as usize;
             if u > (-4096isize) as usize {
                 E((u.wrapping_neg()) as u16)
@@ -5453,7 +5378,7 @@ pub mod linux {
     }
 
     // ── epoll ──
-    /// `std.os.linux.EPOLL` — flag/op constants. Exposed both as a module
+    /// epoll flag/op constants. Exposed both as a module
     /// (`linux::EPOLL::IN`) and flat (`linux::EPOLL_IN`) since callers use both.
     pub mod EPOLL {
         pub const IN: u32 = libc::EPOLLIN as u32;
@@ -5479,7 +5404,7 @@ pub mod linux {
     pub const EPOLL_CTL_DEL: i32 = EPOLL::CTL_DEL;
 
     // ── futex ──
-    /// `std.os.linux.FUTEX` op (cmd + private flag), packed as Zig does.
+    /// futex op (cmd + private flag), packed.
     #[derive(Clone, Copy)]
     pub struct FutexOp {
         pub cmd: FutexCmd,
@@ -5507,8 +5432,8 @@ pub mod linux {
     }
     /// `syscall(SYS_futex, uaddr, op, val)` — 3-arg form (WAKE).
     /// Returns the raw kernel rc (decode with `E::init`).
-    // PORT NOTE: Zig's `std.os.linux.futex_*` invoke the kernel directly and
-    // return `-errno` on failure. `libc::syscall()` is the *glibc* wrapper —
+    // The kernel futex ABI returns `-errno` on
+    // failure. `libc::syscall()` is the *glibc* wrapper —
     // it returns `-1` and sets thread-local errno instead. Translate back to
     // the kernel convention so callers can decode with `E::init(rc)`; without
     // this, every EAGAIN/EINTR from FUTEX_WAIT mis-decodes as EPERM and the
@@ -5542,7 +5467,7 @@ pub mod linux {
         }
     }
 
-    /// inotify mask flags (`std.os.linux.IN`).
+    /// inotify mask flags (`IN_*`).
     pub mod IN {
         pub const ACCESS: u32 = libc::IN_ACCESS;
         pub const MODIFY: u32 = libc::IN_MODIFY;
@@ -5585,7 +5510,7 @@ pub mod linux {
         // declares it `c_int`, which is ABI-correct on every Linux libc.
         crate::safe_libc::inotify_rm_watch(fd, wd)
     }
-    /// Raw `read(2)` returning kernel `usize` (Zig: `std.os.linux.read`).
+    /// Raw `read(2)` returning kernel `usize`.
     #[inline]
     pub unsafe fn read(fd: c_int, buf: *mut u8, count: usize) -> isize {
         // Raw syscall via rustix; libc-convention return preserved for callers
@@ -5593,7 +5518,7 @@ pub mod linux {
         // SAFETY: caller contract — `buf` points to `count` writable bytes.
         unsafe { super::linux_syscall::read_raw(fd, buf, count) }
     }
-    /// Raw `sendfile(out, in, *offset, count)` (Zig: `std.os.linux.sendfile`).
+    /// Raw `sendfile(out, in, *offset, count)`.
     #[inline]
     pub unsafe fn sendfile(out_fd: c_int, in_fd: c_int, offset: *mut i64, count: usize) -> isize {
         // SAFETY: caller contract — `offset` is null or points to a live `i64`
@@ -5619,8 +5544,8 @@ pub mod linux {
         unsafe { super::linux_syscall::epoll_ctl(epfd, op, fd, event) }
     }
 
-    // ── `std.os.linux.*` syscall thunks ──
-    // PORT NOTE: Zig's `std.os.linux.ioctl`/`copy_file_range` are *true* raw
+    // ── raw syscall thunks ──
+    // `ioctl`/`copy_file_range` here are *true* raw
     // syscalls returning the kernel `-errno`-in-`usize` ABI. glibc's
     // `libc::syscall()` is NOT — it returns `-1` and sets thread-local errno
     // on failure. Returning `isize` here routes callers through the
@@ -5628,11 +5553,11 @@ pub mod linux {
     // the kernel-convention `GetErrno for usize` impl which would mis-decode
     // every failure as EPERM (`-1 as usize` → errno 1).
 
-    /// `bun.linux.ioctl_ficlone` (platform/linux.zig:71): raw FICLONE ioctl.
+    /// `bun.linux.ioctl_ficlone`: raw FICLONE ioctl.
     /// Support for FICLONE is dependent on the filesystem driver.
     #[inline]
     pub fn ioctl_ficlone(dest_fd: super::Fd, src_fd: super::Fd) -> isize {
-        // FICLONE = _IOW(0x94, 9, c_int). Value matches Zig's `bun.c.FICLONE`.
+        // FICLONE = _IOW(0x94, 9, c_int).
         const FICLONE: libc::c_ulong = 0x40049409;
         // SAFETY: raw `ioctl(2)`; both fds owned by caller.
         unsafe {
@@ -5645,7 +5570,7 @@ pub mod linux {
         }
     }
 
-    /// `std.os.linux.copy_file_range` raw syscall.
+    /// `copy_file_range` raw syscall.
     #[inline]
     pub unsafe fn copy_file_range(
         in_: c_int,
@@ -5659,7 +5584,7 @@ pub mod linux {
         unsafe { super::linux_syscall::copy_file_range(in_, off_in, out, off_out, len, flags) }
     }
 
-    // `std.os.linux.sendfile` — use the existing `linux::sendfile` (libc
+    // sendfile — use the existing `linux::sendfile` (libc
     // wrapper, isize return) defined above; `get_errno::<isize>` decodes it.
 
     /// `bun.linux.RWFFlagSupport` — runtime probe for `RWF_NOWAIT` (kernel ≥ 4.14).
@@ -5672,7 +5597,7 @@ pub mod linux {
         pub fn is_maybe_supported() -> bool {
             match RWF_STATE.load(core::sync::atomic::Ordering::Relaxed) {
                 0 => {
-                    // platform/linux.zig:44 — kernels 5.9/5.10 have a buggy
+                    // Kernels 5.9/5.10 have a buggy
                     // RWF_NOWAIT (returns EAGAIN spuriously); disable on those.
                     let v = bun_core::linux_kernel_version();
                     let buggy = v.major == 5 && (v.minor == 9 || v.minor == 10);
@@ -5729,7 +5654,7 @@ pub mod darwin {
             os_log::Signpost { log: self, name }
         }
     }
-    /// `std.c.EVFILT` — kqueue filter constants.
+    /// kqueue filter constants.
     pub mod EVFILT {
         pub const READ: i16 = libc::EVFILT_READ;
         pub const WRITE: i16 = libc::EVFILT_WRITE;
@@ -5740,7 +5665,7 @@ pub mod darwin {
         pub const USER: i16 = libc::EVFILT_USER;
         pub const MACHPORT: i16 = libc::EVFILT_MACHPORT;
     }
-    /// `std.c.EV` — kqueue event flags (Darwin).
+    /// kqueue event flags (Darwin).
     pub mod EV {
         pub const ADD: u16 = libc::EV_ADD;
         pub const DELETE: u16 = libc::EV_DELETE;
@@ -5753,7 +5678,7 @@ pub mod darwin {
         pub const EOF: u16 = libc::EV_EOF;
         pub const ERROR: u16 = libc::EV_ERROR;
     }
-    /// `std.c.NOTE` — kqueue fflags (Darwin).
+    /// kqueue fflags (Darwin).
     pub mod NOTE {
         pub const EXIT: u32 = libc::NOTE_EXIT;
         pub const EXITSTATUS: u32 = libc::NOTE_EXITSTATUS;
@@ -5777,9 +5702,9 @@ pub mod darwin {
     /// sites (blob/copy_file.rs) resolve without a direct `libc` dep.
     pub use libc::{ftruncate, truncate};
 
-    /// `bun.darwin.COPYFILE` — Zig `packed struct(u32)` of <copyfile.h> flags.
+    /// `bun.darwin.COPYFILE` — packed-u32 set of <copyfile.h> flags.
     /// Kept as a plain struct + `.bits()` so call sites can use field-init
-    /// syntax (matching the Zig); convert to `u32` at the FFI boundary.
+    /// syntax; convert to `u32` at the FFI boundary.
     #[derive(Clone, Copy, Default)]
     #[allow(non_snake_case)]
     pub struct COPYFILE {
@@ -5818,10 +5743,10 @@ pub mod darwin {
         }
     }
 
-    // ── `std.c.UL` / `std.c.ULOp` — Darwin private __ulock_* flags ──
-    // <xnu/bsd/sys/ulock.h>. Zig models this as `packed struct(u32)`; we keep
-    // a plain struct + `.bits()` so Futex.rs can use field-init syntax (matching
-    // the Zig call sites) while the FFI boundary gets the packed u32.
+    // ── Darwin private __ulock_* flags ──
+    // <xnu/bsd/sys/ulock.h>. Kept as
+    // a plain struct + `.bits()` so Futex.rs can use field-init syntax
+    // while the FFI boundary gets the packed u32.
     #[repr(u8)]
     #[derive(Clone, Copy, Default)]
     pub enum ULOp {
@@ -5952,8 +5877,8 @@ pub mod darwin {
 #[cfg(not(target_os = "macos"))]
 pub mod darwin {}
 
-// ── `std.macho` — Mach-O header parsing (subset). ────────────────────────
-// Port of the slice of Zig std/macho.zig that `crash_handler.zig` uses to
+// ── Mach-O header parsing (subset). ──────────────────────────────────────
+// Just the slice that the crash handler uses to
 // walk dyld load commands and resolve a stable (ASLR-unslid) address for
 // `addr2line`. Only the 64-bit forms are present; Bun does not ship 32-bit
 // Darwin binaries.
@@ -5971,7 +5896,7 @@ pub mod macho {
     pub const LC_SEGMENT_64: u32 = 0x19;
 
     /// `<mach-o/loader.h> mach_header_64`. Layout matches libc's
-    /// `mach_header_64` and Zig std's `std.macho.mach_header_64`.
+    /// `mach_header_64`.
     #[repr(C)]
     #[derive(Clone, Copy)]
     pub struct mach_header_64 {
@@ -6011,7 +5936,7 @@ pub mod macho {
         pub flags: u32,
     }
     impl segment_command_64 {
-        /// Zig: `segName()` — segment name with trailing NULs trimmed.
+        /// Segment name with trailing NULs trimmed.
         #[inline]
         pub fn seg_name(&self) -> &[u8] {
             bun_core::slice_to_nul(&self.segname)
@@ -6020,8 +5945,8 @@ pub mod macho {
 
     /// Raw `(*const u8, len)` pair so [`LoadCommandIterator`] does not hold a
     /// Rust borrow of its backing buffer. `bun_exe_format::macho` interleaves
-    /// iterator reads with in-place mutation of the same `Vec<u8>` (matching
-    /// the Zig original, which has no borrow checker); a `&'a [u8]` here would
+    /// iterator reads with in-place mutation of the same `Vec<u8>`;
+    /// a `&'a [u8]` here would
     /// force a structural rewrite of that consumer.
     #[derive(Clone, Copy)]
     pub struct RawSlice {
@@ -6054,7 +5979,7 @@ pub mod macho {
         pub fn cmdsize(&self) -> u32 {
             self.hdr.cmdsize
         }
-        /// Zig: `cast(comptime T: type) ?T` — reinterpret the command bytes
+        /// Reinterpret the command bytes
         /// as `T` if large enough. Returns an owned `Copy` value (via
         /// `read_unaligned`) rather than `&T`: the backing buffer may be a
         /// heap `Vec<u8>` with arbitrary alignment, so materialising a typed
@@ -6066,12 +5991,12 @@ pub mod macho {
             // SAFETY: `data.ptr` points into a live Mach-O image buffer with
             // at least `size_of::<T>()` bytes (checked above); `T` is
             // `#[repr(C)]` POD per all callers. `read_unaligned` tolerates any
-            // alignment (mirrors Zig `*align(1) const T`).
+            // alignment.
             Some(unsafe { core::ptr::read_unaligned(self.data.ptr.cast::<T>()) })
         }
     }
 
-    /// Zig: `std.macho.LoadCommandIterator` — walks the load-command region
+    /// Walks the load-command region
     /// that immediately follows a `mach_header_64`.
     ///
     /// SAFETY contract: callers must not reallocate, shrink, or free the
@@ -6168,7 +6093,7 @@ impl DynLib {
         // `transmute_copy` is used over `transmute` because `T` is generic and
         // its size cannot be checked at the definition site; the `const` assert
         // above enforces `size_of::<T>() == size_of::<*mut c_void>()` at
-        // monomorphisation. Same contract as Zig `bun.cast(T, ptr)`.
+        // monomorphisation.
         Some(unsafe { core::mem::transmute_copy::<*mut c_void, T>(&p) })
     }
     pub fn close(self) {
@@ -6179,7 +6104,7 @@ impl DynLib {
             libc::dlclose(self.handle);
         }
         // Windows: FreeLibrary via windows mod; intentionally leaked here
-        // (Zig `DynLib.close` on Windows is a no-op in our usage).
+        // (close is a no-op on Windows in our usage).
     }
     #[inline]
     pub fn handle(&self) -> *mut c_void {
@@ -6187,7 +6112,7 @@ impl DynLib {
     }
 }
 
-/// `std.c.RTLD` flags for `dlopen`.
+/// `RTLD_*` flags for `dlopen`.
 #[cfg(unix)]
 pub mod RTLD {
     pub const LAZY: i32 = libc::RTLD_LAZY;
@@ -6205,7 +6130,7 @@ pub mod RTLD {
     pub const LOCAL: i32 = 0;
 }
 
-/// sys.zig:4557 — `dlopen(filename, flags)`. Windows → `LoadLibraryA`.
+/// `dlopen(filename, flags)`. Windows → `LoadLibraryA`.
 pub fn dlopen(filename: &ZStr, flags: i32) -> Option<*mut c_void> {
     #[cfg(unix)]
     {
@@ -6221,7 +6146,7 @@ pub fn dlopen(filename: &ZStr, flags: i32) -> Option<*mut c_void> {
         if p.is_null() { None } else { Some(p.cast()) }
     }
 }
-/// sys.zig:4565 — `dlsym(handle, name)`.
+/// `dlsym(handle, name)`.
 pub fn dlsym_impl(handle: Option<*mut c_void>, name: &ZStr) -> Option<*mut c_void> {
     #[cfg(unix)]
     {
@@ -6232,13 +6157,13 @@ pub fn dlsym_impl(handle: Option<*mut c_void>, name: &ZStr) -> Option<*mut c_voi
     }
     #[cfg(windows)]
     {
-        // sys.zig:4565 — Windows arm calls `GetProcAddressA` (which widens
+        // The Windows arm calls `GetProcAddressA` (which widens
         // `name` to UTF-16 and forwards to kernel32 `GetProcAddress`).
         windows::GetProcAddressA(handle, name)
     }
 }
-/// `bun.c.dlsymWithHandle` — once-cached typed lookup. The Zig version
-/// monomorphises per `(Type, name, handle_getter)`; in Rust this is a macro.
+/// `bun.c.dlsymWithHandle` — once-cached typed lookup; one expansion per
+/// `(Type, name, handle_getter)` triple.
 #[macro_export]
 macro_rules! dlsym_with_handle {
     ($T:ty, $name:literal, $handle:expr) => {{
@@ -6264,7 +6189,6 @@ macro_rules! dlsym_with_handle {
         // below) and was obtained from `dlsym`, so it is a valid code address;
         // `Once` provides happens-before for the store. The `const` assert above
         // enforces `size_of::<$T>() == size_of::<*mut c_void>()` at expansion.
-        // Same as Zig `bun.cast($T, ptr)`.
         let p = PTR.load(::core::sync::atomic::Ordering::Relaxed);
         if p.is_null() {
             None
@@ -6274,7 +6198,7 @@ macro_rules! dlsym_with_handle {
     }};
 }
 
-// ── open helpers (sys.zig posix arms) ──
+// ── open helpers (posix arms) ──
 
 /// `openA` — like `open` but takes a non-NUL-terminated slice.
 pub fn open_a(path: &[u8], flags: i32, perm: Mode) -> Maybe<Fd> {
@@ -6293,7 +6217,7 @@ pub fn openat_a(dir: impl AsFd, path: &[u8], flags: i32, perm: Mode) -> Maybe<Fd
     let z = ZStr::from_buf(&buf.0[..], path.len());
     openat(dir, z, flags, perm)
 }
-/// sys.zig:1705 `openatOSPath` — `openat` taking a platform-native path
+/// `openatOSPath` — `openat` taking a platform-native path
 /// (`OSPathSliceZ` = `ZStr` on POSIX, `WStr` on Windows). On POSIX this is
 /// identical to `openat`; on Windows it routes through the NT openat path.
 #[cfg(not(windows))]
@@ -6322,16 +6246,16 @@ pub fn mkdirat_z(dir: impl AsFd, path: &ZStr, mode: Mode) -> Maybe<()> {
     let dir = dir.as_fd();
     mkdirat(dir, path, mode)
 }
-/// bun.zig:879 `openDirA` — open a path as an iterable directory fd.
+/// `openDirA` — open a path as an iterable directory fd.
 pub fn open_dir_at(dir: impl AsFd, path: &[u8]) -> Maybe<Fd> {
     let dir = dir.as_fd();
     openat_a(dir, path, O::DIRECTORY | O::CLOEXEC | O::RDONLY, 0)
 }
-/// bun.zig:890 `openDirAbsolute`. PORT NOTE: returns `Fd`, not `std.fs.Dir`.
+/// `openDirAbsolute`. Returns an `Fd`.
 pub fn open_dir_absolute(path: &[u8]) -> Maybe<Fd> {
     open_a(path, O::DIRECTORY | O::CLOEXEC | O::RDONLY, 0)
 }
-/// sys.zig:2615 `symlinkRunningExecutable` — same as `symlink`, except it
+/// `symlinkRunningExecutable` — same as `symlink`, except it
 /// handles ETXTBSY/EBUSY by unlinking the destination and retrying once.
 pub fn symlink_running_executable(target: &ZStr, dest: &ZStr) -> Maybe<()> {
     match symlink(target, dest) {
@@ -6345,13 +6269,13 @@ pub fn symlink_running_executable(target: &ZStr, dest: &ZStr) -> Maybe<()> {
         Ok(()) => Ok(()),
     }
 }
-/// `std.fs.deleteTreeAbsolute` — best-effort recursive delete of an absolute
+/// Best-effort recursive delete of an absolute
 /// path. Routes through `Dir::delete_tree` on the parent directory.
 pub fn delete_tree_absolute(path: &[u8]) -> core::result::Result<(), bun_core::Error> {
     let parent = bun_paths::resolve_path::dirname::<bun_paths::platform::Auto>(path);
     let base = bun_paths::basename(path);
     if parent.is_empty() || base.is_empty() {
-        // Nothing sensible to do (root or empty); mirror Zig's silent success on ENOENT.
+        // Nothing sensible to do (root or empty); silent success.
         return Ok(());
     }
     let dir = open_dir_absolute(parent)
@@ -6359,11 +6283,11 @@ pub fn delete_tree_absolute(path: &[u8]) -> core::result::Result<(), bun_core::E
         .map_err(bun_core::Error::from)?;
     dir.delete_tree(base)
 }
-/// bun.zig:899 — Windows variant skips `DELETE` access; on POSIX identical.
+/// Windows variant skips `DELETE` access; on POSIX identical.
 pub fn open_dir_absolute_not_for_deleting_or_renaming(path: &[u8]) -> Maybe<Fd> {
     open_dir_absolute(path)
 }
-/// bun.zig:887 `openDirNoRenamingOrDeletingWindows` — open `path` relative to
+/// `openDirNoRenamingOrDeletingWindows` — open `path` relative to
 /// `dir` for iteration only (no `DELETE` access). Windows-only; callers gate.
 #[cfg(windows)]
 pub fn open_dir_no_renaming_or_deleting_windows(dir: Fd, path: &[u8]) -> Maybe<Fd> {
@@ -6387,9 +6311,9 @@ pub fn openat_read_only(dir: Fd, path: &[u8]) -> Maybe<Fd> {
     openat_a(dir, path, O::RDONLY | O::CLOEXEC, 0)
 }
 // ──────────────────────────────────────────────────────────────────────────
-// `openatWindows` family — sys.zig:1217-1490. Maps POSIX-style `O::*` flags
+// `openatWindows` family. Maps POSIX-style `O::*` flags
 // onto an `NtCreateFile` call (or `openDirAtWindows` when `O_DIRECTORY` is
-// set). On POSIX this is a `@compileError` in Zig; the surface is gated.
+// set). The surface is gated to Windows.
 // ──────────────────────────────────────────────────────────────────────────
 
 #[cfg(windows)]
@@ -6397,7 +6321,6 @@ const FILE_SHARE: u32 = bun_windows_sys::FILE_SHARE_READ
     | bun_windows_sys::FILE_SHARE_WRITE
     | bun_windows_sys::FILE_SHARE_DELETE;
 
-/// sys.zig:1217 `WindowsOpenDirOptions`.
 #[cfg(windows)]
 #[derive(Clone, Copy, Default)]
 pub struct WindowsOpenDirOptions {
@@ -6416,7 +6339,6 @@ pub enum WindowsOpenDirOp {
     OpenOrCreate,
 }
 
-/// sys.zig:1457 `NtCreateFileOptions`.
 #[cfg(windows)]
 #[derive(Clone, Copy)]
 pub struct NtCreateFileOptions {
@@ -6439,7 +6361,7 @@ impl Default for NtCreateFileOptions {
     }
 }
 
-/// sys.zig:985 `normalizePathWindows` options.
+/// `normalizePathWindows` options.
 #[cfg(windows)]
 #[derive(Copy, Clone)]
 pub struct NormalizePathWindowsOpts {
@@ -6454,9 +6376,9 @@ impl Default for NormalizePathWindowsOpts {
     }
 }
 
-/// sys.zig:1129 `normalizePathWindows` — convert a (possibly relative) path
+/// `normalizePathWindows` — convert a (possibly relative) path
 /// into an NT object path suitable for `NtCreateFile` against `dir_fd`.
-/// PORT NOTE: u16-only here; the u8 entry points pre-convert via
+/// u16-only here; the u8 entry points pre-convert via
 /// `bun_paths::string_paths::to_nt_path` and call this with the resulting wide slice.
 #[cfg(windows)]
 pub fn normalize_path_windows<'a>(
@@ -6479,7 +6401,7 @@ pub fn normalize_path_windows_opts<'a>(
 
     let mut path = path;
     if bun_paths::is_absolute_windows_wtf16(path) {
-        // sys.zig:1019-1048 — three special-cases that must run BEFORE
+        // Three special-cases that must run BEFORE
         // `normalizeStringGenericTZ`, otherwise device paths get mangled:
         if path.len() >= 4 {
             // (a) `…\nul` / `…\NUL` → literal NT object path `\??\NUL`.
@@ -6530,8 +6452,8 @@ pub fn normalize_path_windows_opts<'a>(
         if opts.add_nt_prefix {
             // Absolute → add `\??\` (idempotent if already present), normalize
             // separators/`.`/`..` and NUL-terminate.
-            // sys.zig:1001/1052 — `nt_prefix_headroom = 8`; `if (path.len >
-            // buf.len -| nt_prefix_headroom) return name_too_long;`.
+            // `nt_prefix_headroom = 8`: reject when `path.len >
+            // buf.len - nt_prefix_headroom`.
             // `normalizeStringGenericTZ` performs no bounds checking of its
             // own, so reserve room for `\??\` + trailing-`\` growth + NUL
             // before calling it. NOTE: `to_nt_path16` is NOT a substitute here
@@ -6552,7 +6474,7 @@ pub fn normalize_path_windows_opts<'a>(
             // SAFETY: ZERO_TERMINATE wrote NUL at buf[len].
             return Ok(unsafe { WStr::from_raw(norm.as_ptr(), len) });
         }
-        // sys.zig:1056 `.{ .add_nt_prefix = false }` — produce a Win32 path
+        // `add_nt_prefix = false` — produce a Win32 path
         // (no `\??\` object prefix) for callers that feed kernel32 APIs
         // (CreateDirectoryW / CopyFileW). With .add_nt_prefix = false the
         // normalizer can still grow the input by one u16 (trailing `\` after a
@@ -6597,12 +6519,12 @@ pub fn normalize_path_windows_opts<'a>(
     let base =
         match windows::GetFinalPathNameByHandle(base_fd, Default::default(), &mut base_buf.0[..]) {
             Ok(p) => p,
-            // sys.zig:1080 — `E.BADFD` (errno 77 'file descriptor in bad state'),
+            // `E.BADFD` (errno 77 'file descriptor in bad state'),
             // not `EBADF` (9).
             Err(_) => return Err(Error::from_code(E::BADFD, Tag::open)),
         };
 
-    // Strip a leading drive letter (`C:`) on the relative part (sys.zig:1204).
+    // Strip a leading drive letter (`C:`) on the relative part.
     let mut rel = path;
     if rel.len() >= 2
         && bun_paths::resolve_path::is_drive_letter_t::<u16>(rel[0])
@@ -6613,8 +6535,7 @@ pub fn normalize_path_windows_opts<'a>(
 
     let mut joined = bun_paths::w_path_buffer_pool::get();
     let joined_len = base.len() + 1 + rel.len();
-    // sys.zig:1092 — `if (joined_len > buf1.len -| nt_prefix_headroom) return
-    // name_too_long;`. Reserve 8 u16 for the `\??\` prefix + NUL that
+    // Reserve 8 u16 for the `\??\` prefix + NUL that
     // `normalizeStringGenericTZ` writes into `buf` (same length as `joined`).
     if joined_len > joined.0.len().saturating_sub(8) {
         return Err(too_long());
@@ -6622,8 +6543,7 @@ pub fn normalize_path_windows_opts<'a>(
     joined.0[..base.len()].copy_from_slice(base);
     joined.0[base.len()] = b'\\' as u16;
     joined.0[base.len() + 1..joined_len].copy_from_slice(rel);
-    // sys.zig:1095 — `normalizeStringGenericTZ(u16, joined, buf,
-    // .{ .add_nt_prefix = true, .zero_terminate = true })`. Must collapse
+    // `normalizeStringGenericTZ` with `add_nt_prefix` + `zero_terminate`. Must collapse
     // `.`/`..` segments here: the relative input may be `"."` (e.g.
     // `bun build entry.js` → dirname → `"."`), and the joined `…\.` is
     // rejected by `NtCreateFile` if passed through verbatim.
@@ -6644,7 +6564,7 @@ pub fn normalize_path_windows_opts<'a>(
     Ok(unsafe { WStr::from_raw(norm.as_ptr(), len) })
 }
 
-/// sys.zig:1382 — open a `\\.\…` device path via kernel32 `CreateFileW`
+/// Open a `\\.\…` device path via kernel32 `CreateFileW`
 /// (NtCreateFile cannot open device paths).
 #[cfg(windows)]
 fn open_windows_device_path(
@@ -6673,7 +6593,7 @@ fn open_windows_device_path(
     Ok(Fd::from_system(rc))
 }
 
-/// sys.zig:1231 `openDirAtWindowsNtPath` — `NtCreateFile` with
+/// `openDirAtWindowsNtPath` — `NtCreateFile` with
 /// `FILE_DIRECTORY_FILE`.
 #[cfg(windows)]
 pub fn open_dir_at_windows_nt_path(
@@ -6784,7 +6704,6 @@ pub fn open_dir_at_windows_nt_path(
     }
 }
 
-/// sys.zig:1467 `openFileAtWindowsNtPath`.
 ///
 /// For this function to open an absolute path, it must start with `\??\`.
 /// Otherwise you need a reference file descriptor; the "invalid_fd" file
@@ -6893,7 +6812,7 @@ pub fn open_file_at_windows_nt_path(
     }
 }
 
-/// sys.zig:1003-1012 — `normalizePathWindows(u8, …)` length-checks before
+/// `normalizePathWindows(u8, …)` length-checks before
 /// `convertUTF8toUTF16InBuffer` because simdutf forwards only `output.ptr`
 /// (no output bounds checking). UTF-16 output length ≤ UTF-8 input byte
 /// length, so use `path.len()` as a cheap upper bound; on overflow compute
@@ -6923,8 +6842,8 @@ pub fn open_dir_at_windows_a(
     options: WindowsOpenDirOptions,
 ) -> Maybe<Fd> {
     let dir_fd = dir_fd.as_fd();
-    // sys.zig:1262 `openDirAtWindowsT(u8, …)` → `normalizePathWindows(u8, dirFd,
-    // path, wbuf, .{})` does the UTF-8→UTF-16 conversion internally and THEN
+    // `normalizePathWindows(u8, dirFd, path, wbuf, ..)`
+    // does the UTF-8→UTF-16 conversion internally and THEN
     // applies the absolute/relative/device-path logic. Do the plain transcode
     // here (no NT-prefix, no normalization) so relative inputs stay relative
     // and resolve against `dir_fd`'s `RootDirectory`.
@@ -6940,7 +6859,7 @@ pub fn open_file_at_windows(dir_fd: Fd, path: &[u16], opts: NtCreateFileOptions)
     let norm = normalize_path_windows(dir_fd, path, &mut wbuf.0[..])?;
     open_file_at_windows_nt_path(dir_fd, norm, opts)
 }
-/// sys.zig `openFileAtWindowsA` — UTF-8 entry point: convert to UTF-16 (no
+/// `openFileAtWindowsA` — UTF-8 entry point: convert to UTF-16 (no
 /// NT-prefix yet — `normalize_path_windows` adds that) then defer to
 /// [`open_file_at_windows`].
 #[cfg(windows)]
@@ -6955,7 +6874,7 @@ pub fn open_file_at_windows_a(
     open_file_at_windows(dir_fd, wide, opts)
 }
 
-/// sys.zig:1608 `openatWindowsTMaybeNormalize` — POSIX-flag → NtCreateFile
+/// POSIX-flag → NtCreateFile
 /// translation.
 #[cfg(windows)]
 fn openat_windows_impl(dir: Fd, norm: &bun_core::WStr, flags: i32, perm: Mode) -> Maybe<Fd> {
@@ -7036,19 +6955,19 @@ fn openat_windows_impl(dir: Fd, norm: &bun_core::WStr, flags: i32, perm: Mode) -
     )
 }
 
-/// sys.zig:1685 `openatWindows` — UTF-16 input.
+/// `openatWindows` — UTF-16 input.
 #[cfg(windows)]
 pub fn openat_windows(dir: Fd, path: &[u16], flags: i32, perm: Mode) -> Maybe<Fd> {
     let mut wbuf = bun_paths::w_path_buffer_pool::get();
     let norm = normalize_path_windows(dir, path, &mut wbuf.0[..])?;
     openat_windows_impl(dir, norm, flags, perm)
 }
-/// sys.zig:1690 `openatWindowsA` — UTF-8 input.
+/// `openatWindowsA` — UTF-8 input.
 #[cfg(windows)]
 #[inline(never)]
 pub fn openat_windows_a(dir: impl AsFd, path: &[u8], flags: i32, perm: Mode) -> Maybe<Fd> {
     let dir = dir.as_fd();
-    // sys.zig `openatWindowsT(u8, …)` — `normalizePathWindows` does the
+    // `normalizePathWindows` does the
     // UTF-8→UTF-16 conversion internally; mirror that with a plain transcode
     // (no NT-prefix) so relative paths stay relative against `dir`.
     let mut wbuf = bun_paths::w_path_buffer_pool::get();
@@ -7060,9 +6979,9 @@ pub fn openat_windows_a(dir: impl AsFd, path: &[u8], flags: i32, perm: Mode) ->
 
 // ── existence checks ──
 
-/// Port of sys.zig `WindowsFileAttributes` — view over the `DWORD` returned
+/// `WindowsFileAttributes` — view over the `DWORD` returned
 /// by `GetFileAttributesW`. Only the two bits the resolver inspects are
-/// surfaced as fields (matching the Zig packed-struct field names) so callers
+/// surfaced as fields so callers
 /// can write `attrs.is_directory` / `attrs.is_reparse_point`.
 #[cfg(windows)]
 #[derive(Clone, Copy)]
@@ -7073,7 +6992,7 @@ pub struct WindowsFileAttributes {
     pub raw: u32,
 }
 
-/// Port of sys.zig:3424 `getFileAttributes`. Accepts a UTF-8 path (the
+/// `getFileAttributes`. Accepts a UTF-8 path (the
 /// resolver only ever calls it with one); the wide-path arm is the
 /// `GetFileAttributesW` body inlined. Returns `None` on
 /// `INVALID_FILE_ATTRIBUTES`.
@@ -7095,7 +7014,7 @@ pub fn get_file_attributes(path: &ZStr) -> Option<WindowsFileAttributes> {
     })
 }
 
-/// sys.zig:3447 — `access(path, F_OK) == 0`. `file_only` ignored on POSIX.
+/// `access(path, F_OK) == 0`. `file_only` ignored on POSIX.
 pub fn exists_os_path(path: &bun_paths::OSPathSliceZ, file_only: bool) -> bool {
     #[cfg(not(windows))]
     {
@@ -7106,7 +7025,7 @@ pub fn exists_os_path(path: &bun_paths::OSPathSliceZ, file_only: bool) -> bool {
     #[cfg(windows)]
     {
         use bun_windows_sys::externs as w;
-        // sys.zig:3454 — `getFileAttributes(path)`; if `file_only` reject dirs;
+        // `getFileAttributes(path)`; if `file_only` reject dirs;
         // if reparse point, open the target with `OPEN_EXISTING` to follow.
         // SAFETY: path is NUL-terminated UTF-16.
         let attrs = unsafe { w::GetFileAttributesW(path.as_ptr()) };
@@ -7142,17 +7061,16 @@ pub fn exists_os_path(path: &bun_paths::OSPathSliceZ, file_only: bool) -> bool {
         true
     }
 }
-/// sys.zig:3636 `ExistsAtType`.
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum ExistsAtType {
     File,
     Directory,
 }
-/// sys.zig:3648 Windows tail — `NtQueryAttributesFile` against an
+/// Windows tail — `NtQueryAttributesFile` against an
 /// OBJECT_ATTRIBUTES built from an already NT-prefixed wide path. Shared by the
 /// UTF-8 (`exists_at_type`) and UTF-16 (`exists_at_type_w`) entry points so the
-/// `anytype` width-dispatch in Zig's `existsAtType` is preserved without
-/// duplicating the syscall body.
+/// width dispatch does not
+/// duplicate the syscall body.
 #[cfg(windows)]
 fn exists_at_type_nt(dir: Fd, mut path: &[u16]) -> Maybe<ExistsAtType> {
     use bun_windows_sys::externs as w;
@@ -7185,7 +7103,7 @@ fn exists_at_type_nt(dir: Fd, mut path: &[u16]) -> Maybe<ExistsAtType> {
     // SAFETY: FFI; attr/basic_info valid for the call duration.
     let rc = unsafe { w::ntdll::NtQueryAttributesFile(&attr, &mut basic_info) };
     if rc != w::NTSTATUS::SUCCESS {
-        // sys.zig:3744 `Maybe(bool).errnoSys(rc, .access)` — `errnoSys` for
+        // `errnoSys` for
         // `NTSTATUS` routes through the curated `translateNTStatusToErrno`
         // table, NOT `RtlNtStatusToDosError`. `directory_exists_at()` then
         // branches on `ENOENT`, so the mapping must match the spec table.
@@ -7211,7 +7129,7 @@ fn exists_at_type_nt(dir: Fd, mut path: &[u16]) -> Maybe<ExistsAtType> {
         Err(Error::from_code(E::EUNKNOWN, Tag::access))
     }
 }
-/// sys.zig:3640 — `fstatat` then `S_ISDIR`.
+/// `fstatat` then `S_ISDIR`.
 pub fn exists_at_type(dir: Fd, sub: &ZStr) -> Maybe<ExistsAtType> {
     #[cfg(unix)]
     {
@@ -7224,15 +7142,15 @@ pub fn exists_at_type(dir: Fd, sub: &ZStr) -> Maybe<ExistsAtType> {
     }
     #[cfg(windows)]
     {
-        // sys.zig:3648 — `NtQueryAttributesFile` against an OBJECT_ATTRIBUTES
+        // `NtQueryAttributesFile` against an OBJECT_ATTRIBUTES
         // built from the (optionally NT-prefixed) wide path.
         let mut wbuf = bun_paths::w_path_buffer_pool::get();
         let path = bun_paths::string_paths::to_nt_path(&mut wbuf.0[..], sub.as_bytes()).as_slice();
         exists_at_type_nt(dir, path)
     }
 }
-/// sys.zig:3712 `existsAtType` — the `std.meta.Child(@TypeOf(subpath)) == u16`
-/// arm. Takes an already-wide path (Windows `OSPathSliceZ`) and routes through
+/// Wide-path arm of `exists_at_type`. Takes an already-wide path (Windows
+/// `OSPathSliceZ`) and routes through
 /// `toNTPath16` instead of re-widening from UTF-8.
 #[cfg(windows)]
 pub fn exists_at_type_w(dir: Fd, sub: &[u16]) -> Maybe<ExistsAtType> {
@@ -7240,7 +7158,7 @@ pub fn exists_at_type_w(dir: Fd, sub: &[u16]) -> Maybe<ExistsAtType> {
     let path = bun_paths::string_paths::to_nt_path16(&mut wbuf.0[..], sub).as_slice();
     exists_at_type_nt(dir, path)
 }
-/// sys.zig:3533 — `directoryExistsAt(dir, sub)`. ENOENT → `Ok(false)`.
+/// `directoryExistsAt(dir, sub)`. ENOENT → `Ok(false)`.
 pub fn directory_exists_at(dir: impl AsFd, sub: &ZStr) -> Maybe<bool> {
     let dir = dir.as_fd();
     match exists_at_type(dir, sub) {
@@ -7249,9 +7167,9 @@ pub fn directory_exists_at(dir: impl AsFd, sub: &ZStr) -> Maybe<bool> {
         Err(e) => Err(e),
     }
 }
-/// sys.zig:3533 `directoryExistsAt` — wide-path (`u16`) overload for Windows
-/// `OSPathSliceZ` callers (mkdir-recursive, cpSync auto-detect). Mirrors the
-/// `anytype` dispatch instead of forcing a UTF-16 → UTF-8 → UTF-16 round-trip.
+/// `directoryExistsAt` — wide-path (`u16`) overload for Windows
+/// `OSPathSliceZ` callers (mkdir-recursive, cpSync auto-detect). Avoids
+/// a UTF-16 → UTF-8 → UTF-16 round-trip.
 #[cfg(windows)]
 pub fn directory_exists_at_w(dir: Fd, sub: &[u16]) -> Maybe<bool> {
     match exists_at_type_w(dir, sub) {
@@ -7263,7 +7181,7 @@ pub fn directory_exists_at_w(dir: Fd, sub: &[u16]) -> Maybe<bool> {
 
 // ── fcntl / nonblocking / dup ──
 
-/// sys.zig:3599 — `fcntl(fd, F_GETFL, 0)`.
+/// `fcntl(fd, F_GETFL, 0)`.
 #[cfg(unix)]
 pub fn get_fcntl_flags(fd: Fd) -> Maybe<FcntlInt> {
     fcntl(fd, libc::F_GETFL, 0)
@@ -7272,12 +7190,11 @@ pub fn get_fcntl_flags(fd: Fd) -> Maybe<FcntlInt> {
 pub fn get_fcntl_flags(_fd: Fd) -> Maybe<FcntlInt> {
     Err(Error::from_code_int(libc::ENOSYS, Tag::fcntl))
 }
-/// sys.zig:3614.
 #[inline]
 pub fn set_nonblocking(fd: Fd) -> Maybe<()> {
     update_nonblocking(fd, true)
 }
-/// sys.zig:3618 — GETFL → toggle O_NONBLOCK → SETFL (only if changed).
+/// GETFL → toggle O_NONBLOCK → SETFL (only if changed).
 pub fn update_nonblocking(fd: Fd, nonblocking: bool) -> Maybe<()> {
     #[cfg(unix)]
     {
@@ -7298,8 +7215,8 @@ pub fn update_nonblocking(fd: Fd, nonblocking: bool) -> Maybe<()> {
         Ok(())
     }
 }
-/// sys.zig:3873 — `fcntl(F_DUPFD_CLOEXEC)` (POSIX) / `DuplicateHandle` (Win).
-/// `_flags` is ignored (Zig signature parity).
+/// `fcntl(F_DUPFD_CLOEXEC)` (POSIX) / `DuplicateHandle` (Win).
+/// `_flags` is ignored.
 #[inline]
 pub fn dup_with_flags(fd: Fd, _flags: i32) -> Maybe<Fd> {
     dup(fd)
@@ -7314,13 +7231,13 @@ unsafe extern "C" {
     #[cfg(not(windows))]
     safe fn Bun__disableSOLinger(fd: i32);
 }
-/// sys.zig:3835 `disableLinger` — set `SO_LINGER {1,0}` so close sends RST.
+/// `disableLinger` — set `SO_LINGER {1,0}` so close sends RST.
 #[inline]
 pub fn disable_linger(fd: Fd) {
     Bun__disableSOLinger(fd.native());
 }
 
-/// sys.zig:3788 — `lseek(fd, offset, SEEK_SET)`; result discarded.
+/// `lseek(fd, offset, SEEK_SET)`; result discarded.
 pub fn set_file_offset(fd: Fd, offset: u64) -> Maybe<()> {
     lseek(fd, offset as i64, libc::SEEK_SET).map(|_| ())
 }
@@ -7347,7 +7264,7 @@ unsafe extern "C" {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const RWF_NOWAIT: u32 = 0x00000008;
 
-/// sys.zig:4046 — Linux: `preadv2(.., RWF_NOWAIT)`; else plain `read`.
+/// Linux: `preadv2(.., RWF_NOWAIT)`; else plain `read`.
 pub fn read_nonblocking(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     while linux::RWFFlagSupport::is_maybe_supported() {
@@ -7362,7 +7279,7 @@ pub fn read_nonblocking(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
             match e {
                 libc::EOPNOTSUPP | libc::ENOSYS | libc::EPERM | libc::EACCES => {
                     linux::RWFFlagSupport::disable();
-                    // sys.zig:4070 — only fall through to BLOCKING read if the fd is
+                    // Only fall through to BLOCKING read if the fd is
                     // actually readable now; otherwise return retry (EAGAIN).
                     return match bun_core::is_readable(fd) {
                         bun_core::Pollable::Ready | bun_core::Pollable::Hup => read(fd, buf),
@@ -7377,7 +7294,7 @@ pub fn read_nonblocking(fd: Fd, buf: &mut [u8]) -> Maybe<usize> {
     }
     read(fd, buf)
 }
-/// sys.zig:4099 — Linux: `pwritev2(.., RWF_NOWAIT)`; else plain `write`.
+/// Linux: `pwritev2(.., RWF_NOWAIT)`; else plain `write`.
 pub fn write_nonblocking(fd: Fd, buf: &[u8]) -> Maybe<usize> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     while linux::RWFFlagSupport::is_maybe_supported() {
@@ -7392,7 +7309,7 @@ pub fn write_nonblocking(fd: Fd, buf: &[u8]) -> Maybe<usize> {
             match e {
                 libc::EOPNOTSUPP | libc::ENOSYS | libc::EPERM | libc::EACCES => {
                     linux::RWFFlagSupport::disable();
-                    // sys.zig:4123 — poll before issuing a blocking write.
+                    // Poll before issuing a blocking write.
                     return match bun_core::is_writable(fd) {
                         bun_core::Pollable::Ready | bun_core::Pollable::Hup => write(fd, buf),
                         _ => {
@@ -7411,7 +7328,7 @@ pub fn write_nonblocking(fd: Fd, buf: &[u8]) -> Maybe<usize> {
     write(fd, buf)
 }
 
-/// sys.zig:4536 — `fallocate(fd, 0, offset, len)` on Linux, result discarded; no-op elsewhere.
+/// `fallocate(fd, 0, offset, len)` on Linux, result discarded; no-op elsewhere.
 pub fn preallocate_file(
     fd: FdNative,
     offset: i64,
@@ -7419,7 +7336,7 @@ pub fn preallocate_file(
 ) -> core::result::Result<(), bun_core::Error> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
-        // Result intentionally discarded (Zig: `_ = std.os.linux.fallocate(...)`)
+        // Result intentionally discarded
         // — preallocation is best-effort.
         let _ = safe_libc::fallocate(fd, 0, offset, len);
     }
@@ -7437,7 +7354,7 @@ pub fn kqueue() -> Maybe<Fd> {
     Ok(Fd::from_native(rc))
 }
 
-/// `kevent()` — slice-wrapped Maybe form (sys.zig:2278). Retries on EINTR.
+/// `kevent()` — slice-wrapped Maybe form. Retries on EINTR.
 /// Returns the number of events written into `eventlist`.
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
 pub fn kevent(
@@ -7487,14 +7404,14 @@ pub fn clonefileat(_from_dir: impl AsFd, from: &ZStr, _to_dir: impl AsFd, to: &Z
 
 // ── getFdPath ──
 
-/// sys.zig:632 `LinuxKernel` — cached probe of `/proc/version` for "freebsd"
+/// Cached probe of `/proc/version` for "freebsd"
 /// (linprocfs hardcodes "des@freebsd.org"). Under FreeBSD's Linuxulator
 /// `/proc/self/fd/*` doesn't readlink, but `/dev/fd/*` does.
 /// 0=unknown, 1=linux, 2=freebsd.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 static LINUX_KERNEL_CACHED: core::sync::atomic::AtomicU8 = core::sync::atomic::AtomicU8::new(0);
 
-/// sys.zig:3032 `LinuxKernel.cached.load(.acquire) == .freebsd` — non-probing
+/// Non-probing
 /// fast-path check. Returns `true` only when a previous probe already proved
 /// FreeBSD's Linuxulator; never triggers the `/proc/version` read itself.
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -7503,7 +7420,7 @@ fn linux_kernel_cached_is_freebsd() -> bool {
     LINUX_KERNEL_CACHED.load(core::sync::atomic::Ordering::Acquire) == 2
 }
 
-/// sys.zig:659 `LinuxKernel.get()` — probing variant: reads `/proc/version`
+/// Probing variant: reads `/proc/version`
 /// once (memoized) and returns whether this is FreeBSD's Linuxulator.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn linux_kernel_is_freebsd() -> bool {
@@ -7534,7 +7451,7 @@ fn linux_kernel_is_freebsd() -> bool {
     detected == 2
 }
 
-/// sys.zig:2999 `getFdPathFreeBSDLinuxulator` — readlink `/dev/fd/N` (fdescfs).
+/// readlink `/dev/fd/N` (fdescfs).
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn get_fd_path_freebsd_linuxulator<'a>(
     fd: Fd,
@@ -7553,12 +7470,12 @@ fn get_fd_path_freebsd_linuxulator<'a>(
     Ok(&mut out.0[..len])
 }
 
-/// sys.zig:2940 — fd → absolute path. Linux: readlink `/proc/self/fd/N`;
+/// fd → absolute path. Linux: readlink `/proc/self/fd/N`;
 /// macOS: `fcntl(F_GETPATH)`; Windows: `GetFinalPathNameByHandle`.
 pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a mut [u8]> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
-        // sys.zig:3032 — fast path: a previous call already proved this is
+        // Fast path: a previous call already proved this is
         // FreeBSD's Linuxulator. Skip the doomed `/proc/self/fd/N` readlink.
         if linux_kernel_cached_is_freebsd() {
             return get_fd_path_freebsd_linuxulator(fd, out);
@@ -7575,7 +7492,7 @@ pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a
         match readlink(z, &mut out.0) {
             Ok(len) => return Ok(&mut out.0[..len]),
             Err(e) => {
-                // sys.zig:3046 — under FreeBSD Linuxulator, fall back to
+                // Under FreeBSD Linuxulator, fall back to
                 // `getFdPathFreeBSDLinuxulator` (`/dev/fd/N`). Probing variant
                 // (memoized read of `/proc/version`); only taken once.
                 if linux_kernel_is_freebsd() {
@@ -7595,7 +7512,7 @@ pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a
     }
     #[cfg(windows)]
     {
-        // sys.zig:3008-3018 — `GetFinalPathNameByHandle` into a wide buffer,
+        // `GetFinalPathNameByHandle` into a wide buffer,
         // then transcode WTF-16 → UTF-8 into `out`.
         let mut wide_buf = bun_paths::w_path_buffer_pool::get();
         let wide_slice = match crate::windows::GetFinalPathNameByHandle(
@@ -7612,7 +7529,7 @@ pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a
     }
     #[cfg(target_os = "freebsd")]
     {
-        // sys.zig:3054-3066 — FreeBSD: F_KINFO returns a `struct kinfo_file`
+        // FreeBSD: F_KINFO returns a `struct kinfo_file`
         // with `kf_path`. The /dev/fd readlink trick used for the Linuxulator
         // path doesn't resolve to an absolute path on native FreeBSD, so go
         // via fcntl. Mirrors `bun_core::util::fd_path_raw` (T0 sibling).
@@ -7644,7 +7561,7 @@ pub fn get_fd_path<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a
     }
 }
 
-/// sys.zig:2992 — fd → absolute wide path (Windows `GetFinalPathNameByHandleW`).
+/// fd → absolute wide path (Windows `GetFinalPathNameByHandleW`).
 /// `\\?\` prefix and `\\?\UNC\` are stripped. Higher-tier callers
 /// (`bun.getFdPathW`) re-export this. A libc/kernel32-only sibling lives at
 /// `bun_core::fd_path_raw_w` for T0/T1 callers that cannot depend on this
@@ -7669,7 +7586,7 @@ pub fn get_fd_path_w(_fd: Fd, _out: &mut [u16]) -> Maybe<&mut [u16]> {
 
 // ── environ ──
 
-/// `std.os.environ` — borrowed slice of `KEY=VALUE\0` C strings.
+/// Borrowed slice of the process's `KEY=VALUE\0` C strings.
 /// SAFETY note: the returned slice borrows the libc `environ` global; do not
 /// mutate the environment concurrently.
 pub fn environ() -> &'static [*const c_char] {
@@ -7691,7 +7608,7 @@ pub fn environ() -> &'static [*const c_char] {
     #[cfg(windows)]
     {
         // Populated by `windows::env::convert_env_to_wtf8()` at startup
-        // (main.zig:47 → bun_bin/lib.rs). The slice is NUL-terminated WTF-8
+        // (bun_bin/lib.rs). The slice is NUL-terminated WTF-8
         // C strings; the underlying allocation is `Box::leak`'d for the
         // process lifetime so `'static` here is sound.
         // SAFETY: written exactly once at startup before any reader runs.
@@ -7703,7 +7620,7 @@ pub fn environ() -> &'static [*const c_char] {
     }
 }
 
-/// `std.os.environ.ptr` — raw NULL-terminated `**c_char` for FFI envp args
+/// Raw NULL-terminated `**c_char` environment pointer for FFI envp args
 /// (e.g. `posix_spawn`). Unlike [`environ()`] this returns the raw libc
 /// global pointer (already NULL-terminated) rather than a length-bounded
 /// borrowed slice, so it is suitable to pass directly as `envp`.
@@ -7722,7 +7639,7 @@ pub fn environ_ptr() -> *const *const c_char {
     }
 }
 
-// ── moveFileZWithHandle (sys.zig:4266) ──
+// ── moveFileZWithHandle ──
 
 /// `renameat`; on EISDIR removes the dest dir and retries; on EXDEV falls back
 /// to copy-then-unlink. Port of `bun.sys.moveFileZWithHandle`.
@@ -7744,7 +7661,7 @@ pub fn move_file_z_with_handle(
             renameat(from_dir, filename, to_dir, destination).map_err(Into::into)
         }
         Err(e) if e.get_errno() == E::EXDEV => {
-            // Cross-device: full `copyFileZSlowWithHandle` (sys.zig:4305).
+            // Cross-device: full `copyFileZSlowWithHandle`.
             #[cfg(unix)]
             let st = fstat(from_handle).map_err(bun_core::Error::from)?;
             // Unlink dest first — fixes ETXTBUSY on Linux.
@@ -7764,7 +7681,7 @@ pub fn move_file_z_with_handle(
             // Seek input to 0 — caller may have left offset at EOF after writing.
             let _ = lseek(from_handle, 0, libc::SEEK_SET);
             let r = copy_file(from_handle, dst);
-            // sys.zig:4349 — only stamp mode/owner on success; on copy error
+            // Only stamp mode/owner on success; on copy error
             // the partially-written dest keeps its openat() defaults.
             #[cfg(unix)]
             if r.is_ok() {
@@ -7813,12 +7730,10 @@ pub fn copy_file(in_: Fd, out: Fd) -> Maybe<()> {
 pub fn mkdir_recursive(sub_path: &[u8]) -> Maybe<()> {
     mkdir_recursive_at(Fd::cwd(), sub_path)
 }
-/// bun.zig:2319 — Windows-only `makePath` over UTF-16. On POSIX, transcodes
+/// Windows-only `makePath` over UTF-16. On POSIX, transcodes
 /// to UTF-8 and delegates to `mkdir_recursive_at`.
 pub fn make_path_w(dir: Fd, sub_path: &[u16]) -> Maybe<()> {
-    // bun.zig:2319-2324 — "was going to copy/paste makePath and use all W
-    // versions but they didn't all exist and this buffer was needed anyway":
-    // transcode UTF-16 → UTF-8, then call `makePath` (`mkdir_recursive_at`).
+    // Transcode UTF-16 → UTF-8, then call `makePath` (`mkdir_recursive_at`).
     let mut buf = bun_paths::PathBuffer::default();
     let utf8 = bun_paths::strings::from_w_path(&mut buf.0[..], sub_path);
     mkdir_recursive_at(dir, utf8.as_bytes())
@@ -7837,7 +7752,7 @@ pub mod posix {
     #[cfg(not(windows))]
     use core::ffi::c_void;
 
-    // ── BSD sysctl(3) family (Zig: `std.posix.sysctlbynameZ`) ──
+    // ── BSD sysctl(3) family ──
     // macOS/FreeBSD only — Linux dropped sysctl(2) and uses procfs instead.
     #[cfg(any(
         target_os = "macos",
@@ -7975,7 +7890,7 @@ pub mod posix {
         Ok(info)
     }
 
-    // ── address families (Zig: `std.posix.AF`) ──
+    // ── address families ──
     // `libc` does not expose `AF_*` on `x86_64-pc-windows-msvc`; route through
     // ws2def.h values there. INET6 is *not* portable (10 on Linux, 30 on
     // Darwin/BSD, 23 on Windows) — keep the `libc` symbol on POSIX.
@@ -8001,14 +7916,14 @@ pub mod posix {
         pub const INET6: c_int = libc::AF_INET6;
     }
 
-    // ── INET6_ADDRSTRLEN (Zig: `std.c.INET6_ADDRSTRLEN` / `ws2ipdef.h`) ──
+    // ── INET6_ADDRSTRLEN (<netinet/in.h> / `ws2ipdef.h`) ──
     // POSIX `netinet/in.h` = 46; Windows `ws2ipdef.h` = 65.
     #[cfg(windows)]
     pub const INET6_ADDRSTRLEN: usize = 65;
     #[cfg(not(windows))]
     pub const INET6_ADDRSTRLEN: usize = 46;
 
-    // ── sockaddr family (Zig: `std.posix.sockaddr`) ──
+    // ── sockaddr family ──
     #[cfg(unix)]
     pub use libc::{sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage};
     // Route through `bun_libuv_sys` (not `bun_windows_sys::ws2_32`) so types
@@ -8018,7 +7933,7 @@ pub mod posix {
     #[cfg(windows)]
     pub use bun_libuv_sys::{sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage};
 
-    // ── access(2) mode bits (Zig: `std.posix.F_OK` etc.) ──
+    // ── access(2) mode bits ──
     // POSIX-standard values; libuv re-uses the same numbers on Windows
     // (`uv/win.h`), so these are target-invariant.
     pub const F_OK: c_int = 0;
@@ -8026,7 +7941,7 @@ pub mod posix {
     pub const W_OK: c_int = 2;
     pub const X_OK: c_int = 1;
 
-    // ── stat mode-kind tests (Zig: `std.posix.S.ISLNK` etc.) ──
+    // ── stat mode-kind tests ──
     // `libc::S_IF*` is `mode_t` (u32 on Linux, u16 on Darwin/FreeBSD); widen to
     // `u32` so the `m: u32` (== `bun_core::Mode`) comparison is uniform.
     #[cfg(unix)]
@@ -8052,7 +7967,7 @@ pub mod posix {
     pub use libc::siginfo_t;
     #[cfg(unix)]
     pub use libc::sigset_t;
-    /// `std.posix.sigaction(sig, &act, *oact)`.
+    /// `sigaction(sig, &act, *oact)`.
     #[cfg(unix)]
     #[inline]
     pub unsafe fn sigaction(sig: c_int, act: *const Sigaction, oact: *mut Sigaction) -> c_int {
@@ -8075,7 +7990,7 @@ pub mod posix {
         pub tv_nsec: i64,
     }
 
-    // ── raw I/O (no `Maybe` wrapping; Zig: `std.posix.read/write`) ──
+    // ── raw I/O (no `Maybe` wrapping) ──
     #[cfg(unix)]
     #[inline]
     pub unsafe fn read(fd: c_int, buf: *mut u8, count: usize) -> isize {
@@ -8106,7 +8021,7 @@ pub mod posix {
     }
 
     // ── poll ──
-    /// `std.posix.pollfd`.
+    /// `struct pollfd`.
     #[cfg(unix)]
     #[repr(C)]
     #[derive(Clone, Copy)]
@@ -8119,7 +8034,7 @@ pub mod posix {
     pub const POLL_IN: i16 = libc::POLLIN;
     #[cfg(unix)]
     pub const POLL_OUT: i16 = libc::POLLOUT;
-    /// `bun.sys.poll` (sys.zig:2211-2225) — `poll$NOCANCEL` on Darwin,
+    /// `bun.sys.poll` — `poll$NOCANCEL` on Darwin,
     /// EINTR-retried, tagged `.poll` (NOT `.ppoll`).
     #[cfg(unix)]
     pub fn poll(
@@ -8229,7 +8144,7 @@ pub mod posix {
     }
 
     // ── dynamic loading (Linux/FreeBSD) ──
-    /// `std.posix.dl_iterate_phdr` — iterate loaded ELF objects.
+    /// `dl_iterate_phdr` — iterate loaded ELF objects.
     #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
     #[inline]
     pub unsafe fn dl_iterate_phdr(
@@ -8243,7 +8158,7 @@ pub mod posix {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// `std.net` — socket address. Minimal port of Zig's `std.net.Address`
+// Socket address
 // (just the sockaddr union + a couple of constructors; full resolver lives in
 // `bun_dns`). Dependents only need the data shape + Display.
 // ──────────────────────────────────────────────────────────────────────────
@@ -8269,9 +8184,9 @@ pub mod net {
     use sock::*;
 
     // ──────────────────────────────────────────────────────────────────────
-    // Zig `std.posix.sockaddr.in` / `.in6` — un-prefixed field names
+    // `sockaddr_in` / `sockaddr_in6` with un-prefixed field names
     // (`family`/`port`/`addr`/`flowinfo`/`scope_id`) so call sites written
-    // against the Zig shape stay target-agnostic.
+    // against this shape stay target-agnostic.
     //
     // Layout-identical to the C-named ground truth re-exported at
     // `crate::posix::sockaddr_in[6]` (= `libc` on Unix, `ws2_32` via
@@ -8280,8 +8195,8 @@ pub mod net {
     // `in_addr`/`in6_addr`; Rust won't structurally unify.
     //
     // BSD targets carry a leading `len: u8` and `sa_family_t == u8`; the
-    // `ZEROED` const pre-fills `len = size_of::<Self>()` to mirror Zig's
-    // field default so struct-update initializers (`..sockaddr_in::ZEROED`)
+    // `ZEROED` const pre-fills `len = size_of::<Self>()`
+    // so struct-update initializers (`..sockaddr_in::ZEROED`)
     // work uniformly on all targets and in `const` context.
     // ──────────────────────────────────────────────────────────────────────
     #[cfg(unix)]
@@ -8353,14 +8268,14 @@ pub mod net {
             == core::mem::align_of::<crate::posix::sockaddr_in6>()
     );
 
-    /// `std.net.Address` — tagged union over sockaddr_in/in6/un.
+    /// Tagged union over sockaddr_in/in6/un.
     #[derive(Clone, Copy)]
     pub struct Address {
         /// Generic storage; `family()` discriminates.
         pub any: sockaddr_storage,
     }
     impl Address {
-        /// Construct from a borrowed `*const sockaddr` (Zig: `Address.initPosix`).
+        /// Construct from a borrowed `*const sockaddr`.
         /// SAFETY: `addr` must point at a valid sockaddr of the family it declares.
         pub unsafe fn init_posix(addr: *const sockaddr) -> Self {
             // SAFETY: `sockaddr_storage` is a POD C struct; all-zeros is valid.
@@ -8445,7 +8360,6 @@ pub mod net {
     }
     impl fmt::Display for Address {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            // PORT NOTE: Zig's std.net.Address.format prints "ip:port"/"[ip6]:port".
             // Minimal: print family for now; full impl in `bun_dns::address_to_string`.
             match self.as_in4() {
                 Some(v4) => {
@@ -8494,7 +8408,7 @@ pub mod elf {
         pub name: Box<[u8]>,
     }
 
-    /// Port of Zig `std.debug.DebugInfo.lookupModuleDl`: walk loaded ELF objects
+    /// Walk loaded ELF objects
     /// via `dl_iterate_phdr`, returning the one whose `PT_LOAD` segment contains
     /// `address`. Shared by `bun_crash_handler::StackLine::from_address` and
     /// `bun_jsc::btjs::SelfInfo::lookup_module_dl` / `lookup_module_name_dl`.
@@ -8572,7 +8486,7 @@ pub mod freebsd {
     use core::ffi::c_int;
     /// `struct kevent` (FreeBSD).
     pub type Kevent = libc::kevent;
-    /// `std.c.EVFILT` — kqueue filter constants (FreeBSD).
+    /// kqueue filter constants (FreeBSD).
     pub mod EVFILT {
         pub const READ: i16 = libc::EVFILT_READ;
         pub const WRITE: i16 = libc::EVFILT_WRITE;
@@ -8582,7 +8496,7 @@ pub mod freebsd {
         pub const TIMER: i16 = libc::EVFILT_TIMER;
         pub const USER: i16 = libc::EVFILT_USER;
     }
-    /// `std.c.EV` — kqueue event flags (FreeBSD).
+    /// kqueue event flags (FreeBSD).
     pub mod EV {
         pub const ADD: u16 = libc::EV_ADD;
         pub const DELETE: u16 = libc::EV_DELETE;
@@ -8595,7 +8509,7 @@ pub mod freebsd {
         pub const EOF: u16 = libc::EV_EOF;
         pub const ERROR: u16 = libc::EV_ERROR;
     }
-    /// `std.c.NOTE` — kqueue fflags (FreeBSD).
+    /// kqueue fflags (FreeBSD).
     pub mod NOTE {
         pub const EXIT: u32 = libc::NOTE_EXIT;
         pub const FORK: u32 = libc::NOTE_FORK;
@@ -8622,7 +8536,7 @@ pub mod freebsd {
     ) -> c_int {
         unsafe { libc::kevent(kq, changelist, nchanges, eventlist, nevents, timeout) }
     }
-    /// `std.c.copy_file_range` (FreeBSD 13+). Thin re-export so callers don't
+    /// `copy_file_range` (FreeBSD 13+). Thin re-export so callers don't
     /// need a direct `libc` dep. Offset pointers may be null — when null the
     /// kernel uses (and advances) the fd's seek position.
     /// SAFETY: raw `copy_file_range(2)`; caller owns fds and any non-null
@@ -8667,8 +8581,7 @@ impl Drop for CloseOnDrop {
     }
 }
 
-/// `std.fs.Dir.makeOpenPath` reachable as a module (Zig callers do
-/// `bun.makePath` / `bun.makeOpenPath`).
+/// `make_path` / `make_open_path` helpers reachable as a module.
 pub mod make_path {
     use super::*;
     #[inline]
@@ -8681,7 +8594,7 @@ pub mod make_path {
     }
 
     /// Dispatch trait for `make_path::<T>` over `u8` (POSIX) / `u16` (Windows).
-    /// Mirrors Zig's `std.fs.Dir.makePath` taking `OSPathSlice`. Extends the
+    /// `makePath` taking `OSPathSlice`. Extends the
     /// canonical [`bun_paths::PathChar`] with the one syscall-dispatch hook.
     pub trait MakePathUnit: bun_paths::PathChar {
         fn make_path_at(dir: Fd, sub: &[Self]) -> core::result::Result<(), bun_core::Error>;
@@ -8713,7 +8626,7 @@ pub mod make_path {
         make_path_w(dir.fd, sub_path).map_err(Into::into)
     }
 }
-/// Port of `WindowsSymlinkOptions` (sys.zig:2653) — Windows-only flag struct
+/// `WindowsSymlinkOptions` — Windows-only flag struct
 /// plus a process-global "symlink creation has failed once" sticky bit. The
 /// flag is checked by the install linker to decide whether to fall back to
 /// junctions; on POSIX the flag is harmless dead state. Only the sticky bit
@@ -8723,7 +8636,6 @@ pub mod make_path {
 pub struct WindowsSymlinkOptions {
     pub directory: bool,
 }
-/// Zig: `pub var has_failed_to_create_symlink = false;` (sys.zig:2669).
 pub static WINDOWS_SYMLINK_HAS_FAILED: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
 impl WindowsSymlinkOptions {
@@ -8738,9 +8650,9 @@ impl WindowsSymlinkOptions {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Port of `sys.zig:2653-2902` — Windows-only `symlinkW` / `symlinkOrJunction`
+// Windows-only `symlinkW` / `symlinkOrJunction`
 // / `unlinkW` / `rmdir` / `mkdir` (CreateDirectoryW path). Compiled on
-// Windows; on POSIX these names are absent (matches `@compileError` in spec).
+// Windows; on POSIX these names are absent.
 // ──────────────────────────────────────────────────────────────────────────
 #[cfg(windows)]
 mod win_symlink_impl {
@@ -8756,19 +8668,16 @@ mod win_symlink_impl {
     const SYMBOLIC_LINK_FLAG_DIRECTORY: u32 = 0x1;
     const SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE: u32 = 0x2;
 
-    /// Zig: `WindowsSymlinkOptions.symlink_flags` — process-global, starts
+    /// `WindowsSymlinkOptions.symlink_flags` — process-global, starts
     /// with `ALLOW_UNPRIVILEGED_CREATE` and is cleared on `INVALID_PARAMETER`
     /// (older Windows).
     ///
-    /// PORT NOTE (deliberate divergence): Zig's `flags()` (sys.zig:2657) does
-    /// `symlink_flags |= DIRECTORY; return symlink_flags;`, which permanently
-    /// stickies the `DIRECTORY` bit into the global after the first directory
-    /// symlink — a Zig bug (a later `directory=false` call still passes
-    /// `SYMBOLIC_LINK_FLAG_DIRECTORY`, so `CreateSymbolicLinkW` creates a
-    /// broken directory symlink for a file target). We do **not** mirror that:
-    /// the global only carries `ALLOW_UNPRIVILEGED_CREATE` (cleared on
-    /// `INVALID_PARAMETER`), and `DIRECTORY` is OR'd into a *local* on each
-    /// call. Upstream fix tracked in sys.zig.
+    /// The global only carries `ALLOW_UNPRIVILEGED_CREATE` (cleared on
+    /// `INVALID_PARAMETER`); `DIRECTORY` is OR'd into a *local* on each call.
+    /// Stickying `DIRECTORY` into the global would make a later
+    /// `directory=false` call still pass `SYMBOLIC_LINK_FLAG_DIRECTORY`, so
+    /// `CreateSymbolicLinkW` would create a broken directory symlink for a
+    /// file target.
     static SYMLINK_FLAGS: AtomicU32 = AtomicU32::new(SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE);
 
     impl WindowsSymlinkOptions {
@@ -8786,7 +8695,7 @@ mod win_symlink_impl {
         }
     }
 
-    /// Port of `sys.zig:2717 symlinkW`. `dest` is the link path, `target` is
+    /// `symlinkW`. `dest` is the link path, `target` is
     /// the path the link points to. Retries once with `flags = 0` if the
     /// kernel rejects `ALLOW_UNPRIVILEGED_CREATE` (`INVALID_PARAMETER`).
     pub fn symlink_w(dest: &WStr, target: &WStr, options: WindowsSymlinkOptions) -> Maybe<()> {
@@ -8804,7 +8713,7 @@ mod win_symlink_impl {
                 }
                 if let Some(sys_errno) = win_err.to_system_errno() {
                     let e: E = sys_errno.to_e();
-                    // Zig: only ENOENT/EEXIST keep `has_failed_to_create_symlink`
+                    // Only ENOENT/EEXIST keep `has_failed_to_create_symlink`
                     // unset; every other failure flips the sticky bit so
                     // `symlinkOrJunction` falls through to junctions next time.
                     if !matches!(e, E::NOENT | E::EXIST) {
@@ -8812,14 +8721,14 @@ mod win_symlink_impl {
                     }
                     return Err(Error::from_code(e, Tag::symlink));
                 }
-                // Win32 error without an errno mapping — Zig falls through to
-                // `return .success` (the `if let` yields `null`). Mirror that.
+                // Win32 error without an errno mapping — treat as success
+                // (the `if let` yields `null`).
             }
             return Ok(());
         }
     }
 
-    /// Port of `sys.zig:2675 symlinkOrJunction`. Tries `CreateSymbolicLinkW`
+    /// `symlinkOrJunction`. Tries `CreateSymbolicLinkW`
     /// (directory flavour) first; on failure other than ENOENT/EEXIST falls
     /// back to a libuv junction. `abs_fallback_junction_target = None` says
     /// `target` is already absolute and reusable for the junction.
@@ -8861,7 +8770,7 @@ mod win_symlink_impl {
         )
     }
 
-    /// Port of `sys.zig:2846 unlinkW` — `DeleteFileW` with errno mapping.
+    /// `unlinkW` — `DeleteFileW` with errno mapping.
     pub fn unlink_w(from: &WStr) -> Maybe<()> {
         // SAFETY: `from` is NUL-terminated.
         let rc = unsafe { windows::DeleteFileW(from.as_ptr()) };
@@ -8871,7 +8780,7 @@ mod win_symlink_impl {
         Ok(())
     }
 
-    /// Port of `sys.zig:mkdirOSPath` (Windows arm) — `CreateDirectoryW` with
+    /// `mkdirOSPath` (Windows arm) — `CreateDirectoryW` with
     /// errno mapping. Named `mkdir_w` for parity with `unlink_w`/`symlink_w`.
     pub fn mkdir_w(path: &WStr) -> Maybe<()> {
         // SAFETY: `path` is NUL-terminated; null security attributes.
@@ -8885,7 +8794,7 @@ mod win_symlink_impl {
 #[cfg(windows)]
 pub use win_symlink_impl::{mkdir_w, symlink_or_junction, symlink_w, unlink_w};
 
-/// Port of `sys.zig:3915 link(u16, ...)` Windows arm — `CreateHardLinkW` with
+/// `link(u16, ...)` Windows arm — `CreateHardLinkW` with
 /// errno mapping. The u8/ZStr overload (`link`) routes through `sys_uv::link`.
 #[cfg(windows)]
 pub fn link_w(src: &bun_core::WStr, dest: &bun_core::WStr) -> Maybe<()> {
@@ -8895,7 +8804,7 @@ pub fn link_w(src: &bun_core::WStr, dest: &bun_core::WStr) -> Maybe<()> {
     Ok(())
 }
 
-/// Port of `sys.zig:2876 rmdir` — `rmdirat(FD.cwd(), to)`. Exposed on all
+/// `rmdir` — `rmdirat(FD.cwd(), to)`. Exposed on all
 /// platforms (POSIX `unlinkat(.., AT_REMOVEDIR)`; Windows `DeleteFileBun`).
 #[inline]
 pub fn rmdir(to: &ZStr) -> Maybe<()> {
@@ -8903,7 +8812,7 @@ pub fn rmdir(to: &ZStr) -> Maybe<()> {
 }
 
 /// Type-style alias so callers can write `bun_sys::MakePath::make_path::<T>(..)`
-/// (Zig: `bun.MakePath` namespace re-export).
+/// (the `bun.MakePath` namespace re-export).
 pub use make_path as MakePath;
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -8911,7 +8820,7 @@ pub use make_path as MakePath;
 // ──────────────────────────────────────────────────────────────────────────
 
 bitflags::bitflags! {
-    /// `std.fs.File.OpenFlags` — convenience flagset for `open_file*` helpers.
+    /// Convenience flagset for `open_file*` helpers.
     #[derive(Clone, Copy, Default)]
     pub struct OpenFlags: i32 {
         const READ_ONLY  = O::RDONLY;
@@ -8924,22 +8833,22 @@ bitflags::bitflags! {
     }
 }
 
-/// `std.fs.openFileAbsoluteZ` — open an absolute, NUL-terminated path.
+/// Open an absolute, NUL-terminated path.
 #[inline]
 pub fn open_file_absolute_z(path: &ZStr, flags: OpenFlags) -> Maybe<File> {
     open(path, flags.bits() | O::CLOEXEC, 0).map(File::from_fd)
 }
-/// `std.fs.cwd().openFile` — non-NUL-terminated convenience.
+/// Open a path relative to the cwd — non-NUL-terminated convenience.
 #[inline]
 pub fn open_file(path: &[u8], flags: OpenFlags) -> Maybe<File> {
     open_a(path, flags.bits() | O::CLOEXEC, 0).map(File::from_fd)
 }
-/// bun.zig:883 — `openDirForIteration(dir, sub)`.
+/// `openDirForIteration(dir, sub)`.
 #[inline]
 pub fn open_dir_for_iteration(dir: Fd, path: &[u8]) -> Maybe<Fd> {
     open_dir_at(dir, path)
 }
-/// bun.zig:1303 — `bun.getFdPathZ(fd, buf)`. Wraps [`get_fd_path`] then
+/// `bun.getFdPathZ(fd, buf)`. Wraps [`get_fd_path`] then
 /// NUL-terminates in-place so callers receive a `&ZStr`.
 pub fn get_fd_path_z<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'a ZStr> {
     let len = get_fd_path(fd, out)?.len();
@@ -8949,7 +8858,7 @@ pub fn get_fd_path_z<'a>(fd: Fd, out: &'a mut bun_paths::PathBuffer) -> Maybe<&'
 }
 
 /// `&[u8]`-taking convenience over [`renameat_concurrently`] — Z-terminates both
-/// paths into stack buffers (Zig signature is `[:0]const u8`).
+/// paths into stack buffers.
 pub fn renameat_concurrently_a(
     from_dir_fd: Fd,
     from: &[u8],
@@ -8957,7 +8866,7 @@ pub fn renameat_concurrently_a(
     to: &[u8],
     opts: RenameatConcurrentlyOptions,
 ) -> Maybe<()> {
-    // Z-terminate both paths into stack buffers (Zig signature is `[:0]const u8`).
+    // Z-terminate both paths into stack buffers.
     let mut from_buf = bun_paths::PathBuffer::default();
     let from_len = from.len().min(from_buf.0.len() - 1);
     from_buf.0[..from_len].copy_from_slice(&from[..from_len]);
@@ -8979,13 +8888,12 @@ pub fn renameat_concurrently_a(
 pub fn iterate_dir(dir: Fd) -> dir_iterator::WrappedIterator {
     dir_iterator::iterate(dir)
 }
-/// sys.zig:3482 — `bun.sys.exists`. Non-NUL-terminated convenience over
+/// `bun.sys.exists`. Non-NUL-terminated convenience over
 /// [`exists_z`]: copies into a stack `PathBuffer`, NUL-terminates, then
 /// `access(path, F_OK)` (POSIX) / `GetFileAttributesW` (Windows).
 pub fn exists(path: &[u8]) -> bool {
     let mut buf = bun_paths::PathBuffer::default();
     if path.len() >= buf.0.len() {
-        // Zig: `std.posix.toPosixPath(path) catch return false`
         return false;
     }
     buf.0[..path.len()].copy_from_slice(path);
@@ -8994,19 +8902,20 @@ pub fn exists(path: &[u8]) -> bool {
     let z = ZStr::from_buf(&buf.0[..], path.len());
     exists_z(z)
 }
-/// sys.zig:4246 — `moveFileZ`. Tries the rename first (no source open on the
-/// hot path); on EISDIR removes the dest dir and retries; on EXDEV falls back
-/// to the slow open+copy path. Only opens the source inside the EXDEV branch.
+/// `moveFileZ`. Routes through
+/// [`renameat_concurrently_without_fallback`] (renameat2 NOREPLACE → EXCHANGE →
+/// delete-tree + rename); on EISDIR removes the dest dir and
+/// retries; on EXDEV falls back to the slow open+copy path. Only opens the
+/// source inside the EXDEV branch.
 pub fn move_file_z(
     from_dir: Fd,
     filename: &ZStr,
     to_dir: Fd,
     destination: &ZStr,
 ) -> core::result::Result<(), bun_core::Error> {
-    // TODO(port): renameatConcurrentlyWithoutFallback (renameat2 NOREPLACE →
-    // EXCHANGE → deleteTree) — sys.zig:2480. Plain `renameat` for now.
-    match renameat(from_dir, filename, to_dir, destination) {
+    match renameat_concurrently_without_fallback(from_dir, filename, to_dir, destination) {
         Ok(()) => Ok(()),
+        // allow over-writing an empty directory
         Err(e) if e.get_errno() == E::EISDIR => {
             #[cfg(unix)]
             // SAFETY: destination is NUL-terminated.
@@ -9021,7 +8930,7 @@ pub fn move_file_z(
         Err(e) => Err(e.into()),
     }
 }
-/// sys.zig:4291 — `moveFileZSlow`: open source, unlink, copy to dest.
+/// `moveFileZSlow`: open source, unlink, copy to dest.
 pub fn move_file_z_slow(
     from_dir: Fd,
     filename: &ZStr,
@@ -9039,7 +8948,7 @@ pub fn move_file_z_slow(
     let _ = close(in_handle);
     r
 }
-/// sys.zig:4305 — `copyFileZSlowWithHandle` (POSIX read/write fallback arm).
+/// `copyFileZSlowWithHandle` (POSIX read/write fallback arm).
 pub fn copy_file_z_slow_with_handle(in_handle: Fd, to_dir: Fd, destination: &ZStr) -> Maybe<()> {
     #[cfg(unix)]
     let st = fstat(in_handle)?;
@@ -9058,7 +8967,7 @@ pub fn copy_file_z_slow_with_handle(in_handle: Fd, to_dir: Fd, destination: &ZSt
     }
     let _ = lseek(in_handle, 0, libc::SEEK_SET);
     let r = copy_file(in_handle, dst);
-    // sys.zig:4349 — only stamp mode/owner on success; on copy error the
+    // Only stamp mode/owner on success; on copy error the
     // partially-written dest keeps its openat() defaults.
     #[cfg(unix)]
     if r.is_ok() {
@@ -9076,9 +8985,8 @@ pub fn renameat_z(from_dir: impl AsFd, from: &ZStr, to_dir: impl AsFd, to: &ZStr
     renameat(from_dir, from, to_dir, to)
 }
 
-/// sys.zig:2461 — option struct for [`renameat_concurrently`]. Zig used a
-/// `comptime` anonymous struct param `{ move_fallback: bool = false }`; Rust
-/// surfaces it as a runtime options struct so callers can build it inline.
+/// Option struct for [`renameat_concurrently`];
+/// callers can build it inline.
 #[derive(Default, Clone, Copy)]
 pub struct RenameatConcurrentlyOptions {
     pub move_fallback: bool,
@@ -9086,8 +8994,8 @@ pub struct RenameatConcurrentlyOptions {
 /// Alias: `bun_install` call sites spell this `RenameOptions`.
 pub type RenameOptions = RenameatConcurrentlyOptions;
 
-/// sys.zig:4296 — `moveFileZSlowMaybe`. Thin wrapper kept for source parity
-/// with Zig callers (`renameatConcurrently` falls back through here).
+/// `moveFileZSlowMaybe`. Thin wrapper
+/// (`renameatConcurrently` falls back through here).
 #[inline]
 pub fn move_file_z_slow_maybe(
     from_dir: Fd,
@@ -9098,7 +9006,7 @@ pub fn move_file_z_slow_maybe(
     move_file_z_slow(from_dir, filename, to_dir, destination)
 }
 
-/// sys.zig:2461 — `renameatConcurrently`. Tries an atomic NOREPLACE rename,
+/// `renameatConcurrently`. Tries an atomic NOREPLACE rename,
 /// then EXCHANGE, then a racy delete-tree + rename. With `move_fallback` set,
 /// an EXDEV result falls through to a slow open/copy.
 pub fn renameat_concurrently(
@@ -9122,7 +9030,7 @@ pub fn renameat_concurrently(
     }
 }
 
-/// sys.zig:2480 — `renameatConcurrentlyWithoutFallback`.
+/// `renameatConcurrentlyWithoutFallback`.
 pub fn renameat_concurrently_without_fallback(
     from_dir_fd: Fd,
     from: &ZStr,
@@ -9243,7 +9151,7 @@ impl Default for PathOrFileDescriptor<'_> {
         PathOrFileDescriptor::Fd(Fd::INVALID)
     }
 }
-/// Args struct (Zig: anon-struct init at call sites).
+/// Args struct.
 pub struct WriteFileArgs<'a> {
     pub data: WriteFileData<'a>,
     pub encoding: WriteFileEncoding,
@@ -9296,7 +9204,7 @@ pub fn write_file_with_path_buffer(
 
 /// `bun.fetchCacheDirectoryPath` — resolve `$BUN_INSTALL_CACHE_DIR` /
 /// `$XDG_CACHE_HOME/.bun/install/cache` / `$HOME/.bun/install/cache`.
-/// PORT NOTE: full env-override chain lives in `bun_install`; this is the
+/// full env-override chain lives in `bun_install`; this is the
 /// fallback so the symbol resolves at T1. Returns an owned path (caller frees).
 pub fn fetch_cache_directory_path() -> Vec<u8> {
     if let Some(v) = bun_core::getenv_z(bun_core::zstr!("BUN_INSTALL_CACHE_DIR")) {
@@ -9315,9 +9223,8 @@ pub fn fetch_cache_directory_path() -> Vec<u8> {
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `bun_core::output::QuietWriter` is an opaque `[*mut (); 4]`. We stash the
-/// raw fd in slot 0 and ignore the rest. (Zig's `QuietWriter` is `{ context:
-/// File { handle: Fd } }`; the buffering layer in Zig is the std-adapter, which
-/// we route to `QuietWriterAdapter` below.)
+/// raw fd in slot 0 and ignore the rest. (The buffering layer is routed to
+/// `QuietWriterAdapter` below.)
 #[inline]
 fn qw_fd(qw: &bun_core::output::QuietWriter) -> Fd {
     // SAFETY: `QuietWriter` is `#[repr(C)] { _opaque: [*mut (); 4] }` (asserted
@@ -9343,7 +9250,7 @@ fn qw_set_fd(qw: &mut bun_core::output::QuietWriter, fd: Fd) {
 fn fd_write_all_quiet(fd: Fd, mut bytes: &[u8]) -> bool {
     while !bytes.is_empty() {
         match write(fd, bytes) {
-            Ok(0) => return false, // short write → give up (matches Zig quiet semantics)
+            Ok(0) => return false, // short write → give up
             Ok(n) => bytes = &bytes[n..],
             Err(_) => return false,
         }
diff --git a/src/sys/libuv_error_map.rs b/src/sys/libuv_error_map.rs
index 2d4ce926e8e..be899d07ed5 100644
--- a/src/sys/libuv_error_map.rs
+++ b/src/sys/libuv_error_map.rs
@@ -4,19 +4,16 @@ use crate::SystemErrno;
 
 /// This map is derived off of uv.h's definitions, and is what Node.js uses in printing errors.
 //
-// PORT NOTE: Zig builds this at comptime via a labeled block + `@hasField`/`@field` reflection
-// over `SystemErrno` (whose variant set differs per target OS). Rust has no comptime enum-variant
-// reflection, so the per-OS `@hasField` filter is expressed as `#[cfg]` guards on the few entries
-// whose variants are not present on every target. The `EAI_*` and `UNKNOWN` rows from uv.h are
-// dropped: no `SystemErrno` on any target carries them, so Zig's `@hasField` skipped them too.
+// `SystemErrno`'s variant set differs per target OS, so the per-OS filter is
+// expressed as `#[cfg]` guards on the few entries whose variants are not
+// present on every target. The `EAI_*` and `UNKNOWN` rows from uv.h are
+// dropped: no `SystemErrno` on any target carries them.
 //
 // Built at const-eval time so the whole `[&str; N]` payload lives in `.rodata` with no `Once`
-// guard or init code on the startup path (matches Zig `std.EnumArray` comptime init).
+// guard or init code on the startup path.
 pub(crate) static LIBUV_ERROR_MAP: EnumMap<SystemErrno, &'static str> = build_libuv_error_map();
 
 const fn build_libuv_error_map() -> EnumMap<SystemErrno, &'static str> {
-    // std.EnumMap(SystemErrno, [:0]const u8).initFull("unknown error")
-    //
     // Indexing relies on `SystemErrno`'s dense `0..N` discriminants matching the `enum_map::Enum`
     // declaration-order index for every variant referenced below (true on all four targets — see
     // `bun_errno::*_errno`). The Windows `UV_*` tail variants are never written here; their slots
@@ -73,8 +70,7 @@ const fn build_libuv_error_map() -> EnumMap<SystemErrno, &'static str> {
     arr[SystemErrno::ENOTDIR as usize] = "not a directory";
     arr[SystemErrno::ENOTEMPTY as usize] = "directory not empty";
     arr[SystemErrno::ENOTSOCK as usize] = "socket operation on non-socket";
-    // FreeBSD has no real `ENOTSUP` variant (it aliases `EOPNOTSUPP` via an associated const);
-    // Zig's `@hasField` skipped it there, so match that.
+    // FreeBSD has no real `ENOTSUP` variant (it aliases `EOPNOTSUPP` via an associated const).
     #[cfg(not(target_os = "freebsd"))]
     {
         arr[SystemErrno::ENOTSUP as usize] = "operation not supported on socket";
@@ -136,5 +132,3 @@ fn enoent_label() {
         "connection timed out"
     );
 }
-
-// ported from: src/sys/libuv_error_map.zig
diff --git a/src/sys/linux_syscall.rs b/src/sys/linux_syscall.rs
index 9244839ef93..433cbb830ab 100644
--- a/src/sys/linux_syscall.rs
+++ b/src/sys/linux_syscall.rs
@@ -1,6 +1,6 @@
 //! Raw Linux syscalls via `rustix` (linux_raw backend — no libc trampoline).
 //!
-//! Mirrors Zig's `std.os.linux.*`: every function here issues the kernel
+//! Every function here issues the kernel
 //! syscall directly (inline asm via rustix's `linux_raw` backend) instead of
 //! going through glibc's `open(3)`/`read(3)`/etc wrappers. This eliminates the
 //! PLT hop, the `errno` TLS write, and the pthread cancellation-point check
@@ -11,12 +11,10 @@
 //! `bun_sys::Error::from_code_int(e, tag)` — same shape as the existing
 //! `Maybe<T>` plumbing, just without the `last_errno()` round-trip.
 //!
-//! EINTR retry is handled here (matching the sys.zig Linux arms) so callers
-//! don't need to loop.
+//! EINTR retry is handled here so callers don't need to loop.
 //!
 //! Android: bionic is just another userspace libc on the same Linux kernel —
-//! every raw syscall here is identical (Zig's `std.os.linux.*` makes no
-//! gnu/musl/bionic distinction). Rust splits `target_os` into
+//! every raw syscall here is identical. Rust splits `target_os` into
 //! `linux`/`android`, so the gate must list both.
 #![cfg(any(target_os = "linux", target_os = "android"))]
 
@@ -59,8 +57,7 @@ fn errno() -> i32 {
     bun_core::ffi::errno()
 }
 
-/// EINTR-retry a rustix call. Matches the `while (true) { ...; if .INTR continue }`
-/// loop in the sys.zig Linux arms.
+/// EINTR-retry a rustix call.
 #[inline(always)]
 fn retry<T>(mut f: impl FnMut() -> rustix::io::Result<T>) -> Result<T, i32> {
     loop {
@@ -72,8 +69,8 @@ fn retry<T>(mut f: impl FnMut() -> rustix::io::Result<T>) -> Result<T, i32> {
     }
 }
 
-/// Single-shot (no EINTR retry). Used for `close` and any path where the Zig
-/// surfaces EINTR to the caller.
+/// Single-shot (no EINTR retry). Used for `close` and any path where EINTR
+/// is surfaced to the caller.
 #[inline(always)]
 #[cfg(target_os = "linux")]
 fn once<T>(r: rustix::io::Result<T>) -> Result<T, i32> {
@@ -135,7 +132,7 @@ pub(crate) fn pwrite(fd: Fd, buf: &[u8], off: i64) -> Result<usize, i32> {
 
 /// `close(2)` — single shot, never retried (Linux may have already released
 /// the fd on EINTR; retrying could close a racing thread's new fd). Returns
-/// `Err(EBADF)` etc. on failure; callers only surface `EBADF` (fd.zig:266).
+/// `Err(EBADF)` etc. on failure; callers only surface `EBADF`.
 #[inline]
 pub(crate) fn close(fd: i32) -> Result<(), i32> {
     // rustix's safe `io::close(OwnedFd)` is infallible by design (it swallows
@@ -150,7 +147,7 @@ pub(crate) fn close(fd: i32) -> Result<(), i32> {
     // glibc still translates the kernel `-errno` return into `-1`+TLS-errno,
     // so decode via `last_errno`-equivalent here.
     //
-    // PERF(port): replace with inline-asm `syscall` (or rustix fallible close
+    // PERF: replace with inline-asm `syscall` (or rustix fallible close
     // once it lands) to drop the last libc touch on this path.
     // SAFETY: raw `close(2)`; `fd` is caller-owned (or already invalid, which
     // is exactly the EBADF case we want to detect).
@@ -195,8 +192,7 @@ pub(crate) fn fstatat(dir: i32, path: &ZStr, flags: i32) -> Result<libc::stat, i
 /// libc on those arches defines its userspace `struct stat` as a verbatim
 /// copy of the kernel layout so the syscall can write into it directly. The
 /// conversion is therefore a no-op `transmute` — no `zeroed()` memset, no
-/// 16-field move chain — matching Zig's single `fstat(fd, &out)` with zero
-/// post-processing. The const assert turns any future layout divergence into
+/// 16-field move chain. The const assert turns any future layout divergence into
 /// a compile error rather than silent field corruption.
 ///
 /// (Perf: the previous field-by-field copy showed up in `bun install` profiles
@@ -254,8 +250,8 @@ fn stat_to_libc(s: rustix::fs::Stat) -> libc::stat {
 // hand us `vecs.as_ptr()` derived from a *shared* `&[PlatformIoVec]` —
 // fabricating a `&mut` slice from that pointer is UB under Stacked/Tree
 // Borrows regardless of whether rustix actually writes to the iovec array.
-// Instead pass the raw pointer straight to the kernel via `libc::syscall`,
-// exactly as the Zig `std.os.linux.readv` path does. `syscall(2)` is a thin
+// Instead pass the raw pointer straight to the kernel via `libc::syscall`.
+// `syscall(2)` is a thin
 // register-shuffle (no PLT entry per call, no pthread cancellation point);
 // glibc translates the kernel `-errno` to `-1`+TLS-errno, which `sys_retry`
 // decodes.
@@ -407,8 +403,7 @@ pub(crate) unsafe fn write_raw(fd: i32, buf: *const u8, count: usize) -> isize {
 ///       depends on `EventData`/`EventFlags` having no invalid bit-patterns;
 ///   (c) synthesizing EINVAL for unknown `op` values ourselves rather than
 ///       letting the kernel reject them.
-/// Passing the raw quad straight through avoids all three and matches Zig's
-/// `std.os.linux.epoll_ctl` 1:1.
+/// Passing the raw quad straight through avoids all three.
 #[inline]
 pub(crate) unsafe fn epoll_ctl(epfd: i32, op: i32, fd: i32, event: *mut libc::epoll_event) -> i32 {
     // SAFETY: raw `epoll_ctl(2)`; kernel validates `epfd`/`op`/`fd`; `event`
@@ -421,13 +416,11 @@ pub(crate) unsafe fn epoll_ctl(epfd: i32, op: i32, fd: i32, event: *mut libc::ep
 /// Routed via `libc::syscall(SYS_sendfile, ..)` rather than rustix's
 /// `fs::sendfile` so that (a) `out_fd`/`in_fd == -1` yield EBADF instead of
 /// constructing a niche-invalid `BorrowedFd`, and (b) `offset` stays a raw
-/// `*mut loff_t` with no `&mut u64` type-pun. Matches Zig's
-/// `std.os.linux.sendfile` 1:1.
+/// `*mut loff_t` with no `&mut u64` type-pun.
 #[inline]
 pub(crate) unsafe fn sendfile(out_fd: i32, in_fd: i32, offset: *mut i64, count: usize) -> isize {
     // libc 0.2.186 omits `SYS_sendfile` from its aarch64 syscall tables (gnu,
-    // musl, *and* android — every other arch has it). Zig didn't hit this
-    // because `std.os.linux.SYS` is a complete kernel-derived table. The
+    // musl, *and* android — every other arch has it). The
     // generic-syscall ABI (aarch64/riscv64/loongarch64) places `sendfile` at
     // 71; the legacy ABIs that *do* have the constant differ, so the polyfill
     // is aarch64-only and the rest still come from `libc`.
@@ -444,9 +437,8 @@ pub(crate) unsafe fn sendfile(out_fd: i32, in_fd: i32, offset: *mut i64, count:
 ///
 /// Routed via `libc::syscall(SYS_copy_file_range, ..)` rather than rustix's
 /// `fs::copy_file_range` because the rustix wrapper hard-codes `flags = 0`.
-/// The Zig `std.os.linux.copy_file_range` and the pre-refactor path both
-/// forward `flags` verbatim so the kernel can EINVAL future flag bits;
-/// preserve that behavior exactly. Also avoids the `BorrowedFd` niche hazard
+/// The pre-refactor path forwarded `flags` verbatim so the kernel can EINVAL
+/// future flag bits; preserve that behavior exactly. Also avoids the `BorrowedFd` niche hazard
 /// and `*mut i64 → &mut u64` type-pun on the offset pointers.
 #[inline]
 pub(crate) unsafe fn copy_file_range(
@@ -509,9 +501,8 @@ pub(crate) unsafe fn getdents64(fd: i32, buf: *mut u8, len: usize) -> isize {
     // rustix only exposes `RawDir` (which owns the parse loop). We need the
     // raw byte fill to keep the existing record parser, so issue the syscall
     // via `libc::syscall(SYS_getdents64, ..)`. This is a thin trampoline (no
-    // errno-on-return mangling beyond the standard `-1`/errno convention) and
-    // is what the Zig path compiles to as well.
-    // PERF(port): switch to `rustix::fs::RawDir` once `WrappedIterator` is
+    // errno-on-return mangling beyond the standard `-1`/errno convention).
+    // PERF: switch to `rustix::fs::RawDir` once `WrappedIterator` is
     // reworked to consume `RawDirEntry` instead of hand-parsing bytes.
     // SAFETY: raw `getdents64(2)`; caller guarantees `buf[..len]` is writable;
     // kernel validates `fd`.
diff --git a/src/sys/sys_uv.rs b/src/sys/sys_uv.rs
index 047309ff73d..29bbb1ca8df 100644
--- a/src/sys/sys_uv.rs
+++ b/src/sys/sys_uv.rs
@@ -11,13 +11,11 @@ use bun_core::ZStr;
 use crate::Tag;
 use crate::windows::libuv as uv;
 use crate::{E, Fd, FdExt, Mode, PlatformIOVec, PlatformIOVecConst, Stat, StatFS};
-// `ReturnCodeExt::err_enum_e` overlays the libuv→POSIX errno translation that
-// Zig's `ReturnCode::errno()` does inline; without it the raw `UV_E*` magnitude
-// (e.g. 4058 for UV_ENOENT) would land in `Error.errno` and break callers that
-// compare against `E::NOENT as _`.
+// `ReturnCodeExt::err_enum_e` overlays the libuv→POSIX errno translation;
+// without it the raw `UV_E*` magnitude (e.g. 4058 for UV_ENOENT) would land
+// in `Error.errno` and break callers that compare against `E::NOENT as _`.
 use crate::ReturnCodeExt;
 
-/// `Maybe(T)` from Zig.
 type Result<T> = crate::Result<T>;
 
 // `pub const log = bun.sys.syslog;`
@@ -34,21 +32,19 @@ pub use crate::get_fd_path;
 pub use crate::openat;
 pub use crate::openat_os_path;
 pub use crate::set_file_offset;
-// sys_uv.zig re-exports the bun.sys versions of these (libuv has no
+// Re-export the bun.sys versions of these (libuv has no
 // equivalent or `bun.sys` already routes through Win32 directly).
 pub use crate::lseek;
 pub use crate::symlink;
 pub use crate::unlinkat;
 pub use crate::unlinkat_with_flags;
-// Zig: `pub const mkdirOSPath = bun.sys.mkdirOSPath;` — on Windows that's the
-// WTF-16 `CreateDirectoryW` wrapper (handles unpaired surrogates / `\\?\` long
-// paths). Wrap the real port (`mkdir_w`), NOT the UTF-8 `mkdir`, so callers
-// passing an `OSPathSlice` keep WTF-16 semantics.
+// On Windows this is the WTF-16 `CreateDirectoryW` wrapper (handles unpaired
+// surrogates / `\\?\` long paths). Wrap `mkdir_w`, NOT the UTF-8 `mkdir`, so
+// callers passing an `OSPathSlice` keep WTF-16 semantics.
 //
-// Spec: `pub fn mkdirOSPath(file_path: bun.OSPathSliceZ, flags: mode_t) Maybe(void)`
-// (sys.zig:939). The `flags` param is ignored on Windows (`_ = flags;`) but is
-// part of the public 2-arg signature, so we cannot `pub use mkdir_w as ...` —
-// that would drop the second arg and break Zig-ported callers that pass a mode.
+// The `flags` param is ignored on Windows but is part of the public 2-arg
+// signature, so we cannot `pub use mkdir_w as ...` — that would drop the
+// second arg and break callers that pass a mode.
 #[inline]
 pub fn mkdir_os_path(file_path: &bun_core::WStr, flags: Mode) -> Result<()> {
     let _ = flags;
@@ -104,7 +100,7 @@ impl core::ops::DerefMut for FsReq {
 }
 
 pub fn open(file_path: &ZStr, c_flags: i32, perm_: Mode) -> Result<Fd> {
-    // Zig: `defer req.deinit();` — libuv heap-allocates the WCHAR path copy
+    // libuv heap-allocates the WCHAR path copy
     // (`fs__capture_path`) and only `uv_fs_req_cleanup` frees it. `FsReq`'s
     // `Drop` runs cleanup in place on every return path (see `FsReq` doc for
     // why a by-value scopeguard is unsound here).
@@ -144,7 +140,6 @@ pub fn open(file_path: &ZStr, c_flags: i32, perm_: Mode) -> Result<Fd> {
 }
 
 pub fn mkdir(file_path: &ZStr, flags: Mode) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe {
@@ -171,7 +166,6 @@ pub fn mkdir(file_path: &ZStr, flags: Mode) -> Result<()> {
 }
 
 pub fn chmod(file_path: &ZStr, flags: Mode) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
 
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
@@ -200,7 +194,6 @@ pub fn chmod(file_path: &ZStr, flags: Mode) -> Result<()> {
 
 pub fn fchmod(fd: Fd, flags: Mode) -> Result<()> {
     let uv_fd = fd.uv();
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_fchmod(uv::Loop::get(), &mut *req, uv_fd, flags as c_int, None) };
@@ -214,7 +207,7 @@ pub fn fchmod(fd: Fd, flags: Mode) -> Result<()> {
 }
 
 pub fn statfs(file_path: &ZStr) -> Result<StatFS> {
-    // Zig: `defer req.deinit();` — `uv_fs_statfs` heap-allocates the
+    // `uv_fs_statfs` heap-allocates the
     // `uv_statfs_t` result into `req.ptr` (plus the WCHAR path copy); only
     // `uv_fs_req_cleanup` frees them. Guard so both success and error paths
     // free.
@@ -230,21 +223,19 @@ pub fn statfs(file_path: &ZStr) -> Result<StatFS> {
     if let Some(errno) = rc.err_enum_e() {
         Result::Err(Error::new(errno, Tag::statfs).with_path(file_path.as_bytes()))
     } else {
-        // SAFETY: on success, req.ptr points to a uv_statfs_t (layout-compatible with StatFS).
-        // Zig used `*align(1)` — read_unaligned to match.
-        // PORT: on Windows `StatFS == uv_statfs_t`, so the libuv result *is* the
-        // public type — no Zig-side `.init(*align(1) StatFS)` wrapper to call.
+        // On Windows `StatFS == uv_statfs_t`, so the libuv result *is* the
+        // public type.
         // SAFETY: libuv guarantees `req.ptr` points to a valid `uv_statfs_t`
-        // on success; we read it by value (Zig used `*align(1)` → unaligned).
-        // The value is copied out *before* `FsReq::drop` runs `uv_fs_req_cleanup`
-        // and frees the backing allocation.
+        // on success; the pointer carries no alignment guarantee for `StatFS`,
+        // so read it by value via `read_unaligned`. The value is copied out
+        // *before* `FsReq::drop` runs `uv_fs_req_cleanup` and frees the
+        // backing allocation.
         let p = unsafe { req.ptr_as::<StatFS>() };
         Result::Ok(unsafe { core::ptr::read_unaligned(p) })
     }
 }
 
 pub fn chown(file_path: &ZStr, uid: uv::uv_uid_t, gid: uv::uv_uid_t) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe {
@@ -275,7 +266,6 @@ pub fn chown(file_path: &ZStr, uid: uv::uv_uid_t, gid: uv::uv_uid_t) -> Result<(
 pub fn fchown(fd: Fd, uid: uv::uv_uid_t, gid: uv::uv_uid_t) -> Result<()> {
     let uv_fd = fd.uv();
 
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_fchown(uv::Loop::get(), &mut *req, uv_fd, uid, gid, None) };
@@ -289,7 +279,6 @@ pub fn fchown(fd: Fd, uid: uv::uv_uid_t, gid: uv::uv_uid_t) -> Result<()> {
 }
 
 pub fn rmdir(file_path: &ZStr) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_rmdir(uv::Loop::get(), &mut *req, file_path.as_ptr(), None) };
@@ -307,7 +296,6 @@ pub fn rmdir(file_path: &ZStr) -> Result<()> {
 }
 
 pub fn unlink(file_path: &ZStr) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_unlink(uv::Loop::get(), &mut *req, file_path.as_ptr(), None) };
@@ -325,7 +313,7 @@ pub fn unlink(file_path: &ZStr) -> Result<()> {
 }
 
 pub fn readlink<'a>(file_path: &ZStr, buf: &'a mut [u8]) -> Result<&'a mut ZStr> {
-    // Zig: `defer req.deinit();` — `uv_fs_readlink` heap-allocates the target
+    // `uv_fs_readlink` heap-allocates the target
     // string into `req.ptr` (plus the WCHAR path copy); only `uv_fs_req_cleanup`
     // frees them. The guard covers all four return paths below; the bytes are
     // copied into `buf` *before* the guard runs.
@@ -380,7 +368,6 @@ pub fn readlink<'a>(file_path: &ZStr, buf: &'a mut [u8]) -> Result<&'a mut ZStr>
 }
 
 pub fn rename(from: &ZStr, to: &ZStr) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc =
@@ -401,7 +388,6 @@ pub fn rename(from: &ZStr, to: &ZStr) -> Result<()> {
 }
 
 pub fn link(from: &ZStr, to: &ZStr) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc =
@@ -425,7 +411,6 @@ pub fn link(from: &ZStr, to: &ZStr) -> Result<()> {
 }
 
 pub fn symlink_uv(target: &ZStr, new_path: &ZStr, flags: c_int) -> Result<()> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe {
@@ -453,11 +438,9 @@ pub fn symlink_uv(target: &ZStr, new_path: &ZStr, flags: c_int) -> Result<()> {
 }
 
 pub fn ftruncate(fd: Fd, size: i64) -> Result<()> {
-    // Zig spec types `size: isize` (= i64 on every supported Windows target);
-    // accept `i64` directly so this matches the cross-platform `bun_sys::ftruncate`
+    // Accept `i64` directly so this matches the cross-platform `bun_sys::ftruncate`
     // signature and callers don't need a per-platform `as isize` cast.
     let uv_fd = fd.uv();
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_ftruncate(uv::Loop::get(), &mut *req, uv_fd, size, None) };
@@ -472,7 +455,6 @@ pub fn ftruncate(fd: Fd, size: i64) -> Result<()> {
 
 pub fn fstat(fd: Fd) -> Result<Stat> {
     let uv_fd = fd.uv();
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_fstat(uv::Loop::get(), &mut *req, uv_fd, None) };
@@ -488,7 +470,6 @@ pub fn fstat(fd: Fd) -> Result<Stat> {
 
 pub fn fdatasync(fd: Fd) -> Result<()> {
     let uv_fd = fd.uv();
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_fdatasync(uv::Loop::get(), &mut *req, uv_fd, None) };
@@ -503,7 +484,6 @@ pub fn fdatasync(fd: Fd) -> Result<()> {
 
 pub fn fsync(fd: Fd) -> Result<()> {
     let uv_fd = fd.uv();
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_fsync(uv::Loop::get(), &mut *req, uv_fd, None) };
@@ -517,7 +497,6 @@ pub fn fsync(fd: Fd) -> Result<()> {
 }
 
 pub fn stat(path: &ZStr) -> Result<Stat> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_stat(uv::Loop::get(), &mut *req, path.as_ptr(), None) };
@@ -532,7 +511,6 @@ pub fn stat(path: &ZStr) -> Result<Stat> {
 }
 
 pub fn lstat(path: &ZStr) -> Result<Stat> {
-    // Zig: `defer req.deinit();`
     let mut req = FsReq::new();
     // SAFETY: synchronous libuv fs call; req lives on the stack for the duration.
     let rc = unsafe { uv::uv_fs_lstat(uv::Loop::get(), &mut *req, path.as_ptr(), None) };
@@ -547,12 +525,10 @@ pub fn lstat(path: &ZStr) -> Result<Stat> {
 }
 
 pub fn close(fd: Fd) -> Option<Error> {
-    // TODO(port): @returnAddress() — Rust has no stable equivalent; pass None for now.
     fd.close_allowing_bad_file_descriptor(None)
 }
 
 pub fn close_allowing_stdout_and_stderr(fd: Fd) -> Option<Error> {
-    // TODO(port): @returnAddress() — Rust has no stable equivalent; pass None for now.
     fd.close_allowing_standard_io(None)
 }
 
@@ -590,7 +566,7 @@ pub fn preadv(fd: Fd, bufs: &[PlatformIOVec], position: i64) -> Result<usize> {
         let chunk_len = remaining_bufs.len().min(MAX_IOVEC_COUNT);
         let chunk_bufs = &remaining_bufs[0..chunk_len];
 
-        // Zig: `defer req.deinit();` — `uv_fs_read` heap-allocates
+        // `uv_fs_read` heap-allocates
         // `req->fs.info.bufs` when `nbufs > 4` and self-points it at
         // `req->fs.info.bufsml` when `nbufs <= 4`; `FsReq::drop` runs
         // `uv_fs_req_cleanup` in place every iteration (early-return included).
@@ -663,7 +639,7 @@ pub fn pwritev(fd: Fd, bufs: &[PlatformIOVecConst], position: i64) -> Result<usi
         let chunk_len = remaining_bufs.len().min(MAX_IOVEC_COUNT);
         let chunk_bufs = &remaining_bufs[0..chunk_len];
 
-        // Zig: `defer req.deinit();` — `uv_fs_write` heap-allocates
+        // `uv_fs_write` heap-allocates
         // `req->fs.info.bufs` when `nbufs > 4` and self-points it at
         // `req->fs.info.bufsml` when `nbufs <= 4`; `FsReq::drop` runs
         // `uv_fs_req_cleanup` in place every iteration (early-return included).
@@ -796,8 +772,6 @@ pub fn read(fd: Fd, buf: &mut [u8]) -> Result<usize> {
 
 #[inline]
 pub fn writev(fd: Fd, bufs: &[PlatformIOVec]) -> Result<usize> {
-    // TODO(port): Zig signature is `[]bun.PlatformIOVec` (mutable) but pwritev takes
-    // `[]const bun.PlatformIOVecConst`; on Windows both alias uv_buf_t. Reconcile the two.
     // SAFETY: `PlatformIOVec` (= `uv_buf_t`) and `PlatformIOVecConst` are
     // layout-identical on Windows (size/align asserted in lib.rs); the
     // fat-pointer cast preserves the original slice's (ptr, len) metadata
@@ -876,13 +850,10 @@ pub fn write(fd: Fd, buf: &[u8]) -> Result<usize> {
     Result::Ok(total_written)
 }
 
-// PORT NOTE: Zig's `write()` builds a `[1]PlatformIOVecConst` and calls `writev` (which
-// takes `[]PlatformIOVec`). The two types alias on Windows so Zig coerces silently. Rust
-// can't, so route through pwritev directly with position = -1. TODO(refactor): unify the
-// iovec types on Windows.
+// `write()` builds a `[1]PlatformIOVecConst`, but `writev` takes
+// `&[PlatformIOVec]`; route through pwritev directly with position = -1.
+// TODO(refactor): unify the iovec types on Windows.
 #[inline]
 fn writev_const(fd: Fd, bufs: &[PlatformIOVecConst]) -> Result<usize> {
     pwritev(fd, bufs, -1)
 }
-
-// ported from: src/sys/sys_uv.zig
diff --git a/src/sys/tmp.rs b/src/sys/tmp.rs
index a2f70ffe131..6c72bd48702 100644
--- a/src/sys/tmp.rs
+++ b/src/sys/tmp.rs
@@ -9,8 +9,7 @@ const ALLOW_TMPFILE: bool = false;
 // not folders!
 pub struct Tmpfile<'a> {
     pub destination_dir: Fd,
-    // BORROW_PARAM (Tmpfile.zig:5): caller-supplied tmp name, valid for the
-    // lifetime of the Tmpfile.
+    // Caller-supplied tmp name, valid for the lifetime of the Tmpfile.
     pub tmpfilename: &'a ZStr,
     pub fd: Fd,
     pub using_tmpfile: bool,
@@ -27,9 +26,8 @@ impl<'a> Tmpfile<'a> {
         };
 
         'open: {
-            // ALLOW_TMPFILE = false (Zig comment: O_TMPFILE doesn't seem to work
-            // very well). Dead in Zig too, but Zig comptime drops it; Rust still
-            // type-checks `if false` bodies, so the body must resolve.
+            // ALLOW_TMPFILE = false: dead branch, but Rust still type-checks
+            // `if false` bodies, so the body must resolve.
             if ALLOW_TMPFILE {
                 // SAFETY: literal is NUL-terminated; len excludes the NUL.
                 let dot = ZStr::from_static(b".\0");
@@ -44,7 +42,6 @@ impl<'a> Tmpfile<'a> {
                             fd.make_lib_uv_owned_for_syscall(Tag::open, ErrorCase::CloseOnFail)?;
                         break 'open;
                     }
-                    // PORT NOTE: Zig matched .OPNOTSUPP; on Linux that aliases ENOTSUP.
                     Err(err) => match err.get_errno() {
                         E::EINVAL | E::ENOTSUP | E::ENOSYS => {
                             tmpfile.using_tmpfile = false;
@@ -66,7 +63,6 @@ impl<'a> Tmpfile<'a> {
         Ok(tmpfile)
     }
 
-    // TODO(port): narrow error set
     pub fn finish(&mut self, destname: &ZStr) -> Result<(), bun_core::Error> {
         // ALLOW_TMPFILE = false dead branch — see `create()` note above.
         if ALLOW_TMPFILE && self.using_tmpfile {
@@ -98,5 +94,3 @@ impl<'a> Tmpfile<'a> {
         )
     }
 }
-
-// ported from: src/sys/tmp.zig
diff --git a/src/sys/walker_skippable.rs b/src/sys/walker_skippable.rs
index 8dd09b78faa..cf798ae9d17 100644
--- a/src/sys/walker_skippable.rs
+++ b/src/sys/walker_skippable.rs
@@ -18,9 +18,9 @@ type NameBufferList = Vec<OSPathChar>;
 pub struct Walker {
     stack: Vec<StackItem>,
     name_buffer: NameBufferList,
-    // PORT NOTE: reshaped for borrowck — Zig stored `skip_filenames`/`skip_dirnames` as
-    // sub-slices borrowed from `skip_all`. Rust stores index ranges into `skip_all` instead
-    // (self-referential slices are not expressible without raw pointers).
+    // `skip_filenames`/`skip_dirnames` are index ranges into `skip_all` rather
+    // than sub-slices: self-referential slices are not expressible without raw
+    // pointers.
     skip_filenames: Range<usize>,
     skip_dirnames: Range<usize>,
     skip_all: Box<[u64]>,
@@ -35,8 +35,6 @@ pub struct WalkerEntry<'a> {
     pub dir: Fd,
     pub basename: &'a OSPathSliceZ,
     pub path: &'a OSPathSliceZ,
-    // PORT NOTE: Zig used `std.fs.Dir.Entry.Kind`; mapped to `bun_core::FileKind`
-    // (re-exported as `crate::EntryKind`).
     pub kind: sys::EntryKind,
 }
 
@@ -51,8 +49,8 @@ impl Walker {
     /// a reference to the path.
     pub fn next(&mut self) -> sys::Result<Option<WalkerEntry<'_>>> {
         while !self.stack.is_empty() {
-            // `top` becomes invalid after appending to `self.stack`
-            // PORT NOTE: reshaped for borrowck — use index instead of holding `&mut` across push.
+            // Use an index instead of holding `&mut` to the top item: it would
+            // be invalidated by appending to `self.stack` below.
             let top_idx = self.stack.len() - 1;
             let mut dirname_len = self.stack[top_idx].dirname_len;
             match self.stack[top_idx].iter.next() {
@@ -185,8 +183,6 @@ impl Drop for Walker {
     fn drop(&mut self) {
         if !self.stack.is_empty() {
             for item in &mut self.stack[1..] {
-                // Zig had `if (self.stack.items.len != 0)` here, which is always true inside
-                // this branch — preserved as-is.
                 item.iter.dir().close();
             }
             // `self.stack` Vec drops itself.
@@ -240,5 +236,3 @@ pub fn walk(
         resolve_unknown_entry_types: false,
     })
 }
-
-// ported from: src/sys/walker_skippable.zig
diff --git a/src/sys/windows/env.rs b/src/sys/windows/env.rs
index a6adc07f2f2..65e95743daa 100644
--- a/src/sys/windows/env.rs
+++ b/src/sys/windows/env.rs
@@ -2,12 +2,12 @@ use core::ffi::c_char;
 
 use bun_alloc::AllocError;
 
-/// After running `convert_env_to_wtf8`, the pointers in `std.os.environ` will point into this buffer.
+/// After running `convert_env_to_wtf8`, the pointers in the process environment block will point into this buffer.
 // PORTING.md §Global mutable state: written exactly once at program startup
 // before any threads are spawned. RacyCell — startup-only.
 pub(crate) static WTF8_ENV_BUF: bun_core::RacyCell<Option<&'static [u8]>> =
     bun_core::RacyCell::new(None);
-/// `convert_env_to_wtf8` will set this to the original value of `std.os.environ`.
+/// `convert_env_to_wtf8` will set this to the original environment block.
 // SAFETY: written exactly once at program startup before any threads are
 // spawned. Stored as a raw (ptr, len) pair (no `&mut` aliasing assertion);
 // `None` means "unset".
@@ -16,7 +16,7 @@ pub(crate) static ORIG_ENVIRON: bun_core::RacyCell<Option<(*mut *mut c_char, usi
 
 static ENV_CONVERTED: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);
 
-/// Converts all strings in `std.os.environ` to WTF-8.
+/// Converts all strings in the process environment block to WTF-8.
 ///
 /// This function should be called only once, at program startup, before any code that needs to
 /// access the environment runs.
@@ -51,16 +51,14 @@ pub fn convert_env_to_wtf8() -> Result<(), AllocError> {
         }
         // SAFETY: we just measured `len` u16 elements (including terminators) within the OS-owned block.
         let wtf16_slice = unsafe { bun_core::ffi::slice(wtf16_buf, len) };
-        // Zig: `bun.strings.toUTF8AllocWithType(allocator, []u16, slice) catch oom()`.
-        // Rust `bun_core::strings::to_utf8_alloc` is infallible (panics on OOM)
+        // `bun_core::strings::to_utf8_alloc` is infallible (panics on OOM)
         // and returns `Vec<u8>` directly — no `?` here.
         break 'blk bun_core::strings::to_utf8_alloc(wtf16_slice);
     };
     // Stacked Borrows: leak FIRST as a *shared* `&'static [u8]`, then derive every interior
     // pointer from that one shared borrow. Shared reborrows (`&wtf8_buf[len..]`) push
     // SharedReadOnly tags that coexist — unlike `&mut wtf8_buf[len..]`, a later sibling
-    // reborrow does not invalidate previously-pushed `str_ptr`s. Zig has no equivalent
-    // aliasing model so the spec's `@ptrCast(wtf8_buf[len..].ptr)` is fine there.
+    // reborrow does not invalidate previously-pushed `str_ptr`s.
     let wtf8_buf: &'static [u8] = Box::leak(wtf8_buf.into_boxed_slice());
     let mut len: usize = 0;
 
@@ -91,5 +89,3 @@ pub fn convert_env_to_wtf8() -> Result<(), AllocError> {
     let _ = scopeguard::ScopeGuard::into_inner(env_guard);
     Ok(())
 }
-
-// ported from: src/sys/windows/env.zig
diff --git a/src/sys/windows/mod.rs b/src/sys/windows/mod.rs
index 3b52c8d0484..e00a3b57b02 100644
--- a/src/sys/windows/mod.rs
+++ b/src/sys/windows/mod.rs
@@ -22,7 +22,7 @@ pub use bun_windows_sys::kernel32::GetLastError;
 pub use bun_windows_sys::ntdll;
 pub use bun_windows_sys::ws2_32;
 
-/// `std.os.windows.kernel32` — re-exports the tier-0 `bun_windows_sys::kernel32`
+/// Re-exports the tier-0 `bun_windows_sys::kernel32`
 /// surface and layers the additional externs higher-tier crates reach for
 /// (`ReadDirectoryChangesW`, IOCP, SRW locks, `CreateProcessW`, …). Declared
 /// locally so adding an extern doesn't require touching `bun_windows_sys`.
@@ -103,8 +103,8 @@ pub use bun_windows_sys::LPVOID;
 pub use bun_windows_sys::MAX_PATH;
 pub use bun_windows_sys::PATH_MAX_WIDE;
 pub use bun_windows_sys::WORD;
-/// `PVOID` (winnt.h) — alias of `LPVOID`. Zig's `std.os.windows` exposes both;
-/// keep the alias so ported callers (`bun_shim_impl`) don't need rewriting.
+/// `PVOID` (winnt.h) — alias of `LPVOID`. Keep the alias so existing
+/// callers (`bun_shim_impl`) don't need rewriting.
 pub type PVOID = LPVOID;
 pub use bun_windows_sys::COORD;
 pub use bun_windows_sys::FALSE;
@@ -188,20 +188,18 @@ pub use bun_core::windows_sys::{
     GetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
 };
 
-/// `std.os.windows.fromSysTime` — convert a 64-bit Windows `FILETIME`
+/// Convert a 64-bit Windows `FILETIME`
 /// (100-ns intervals since 1601-01-01 UTC, as projected in
 /// `FILE_BASIC_INFORMATION`'s `LARGE_INTEGER` time fields) into nanoseconds
 /// since the **POSIX epoch** (1970-01-01 UTC), matching the clock
 /// `bun_core::time::nano_timestamp()` reports.
 ///
-/// Spec (vendor/zig std/os/windows.zig `fromSysTime`):
-/// `(hns + epoch.windows * (ns_per_s/100)) * 100` where `epoch.windows` is
-/// `-11_644_473_600` seconds (1601→1970 shift). The shift is required:
+/// Computed as `(hns + epoch_shift * (ns_per_s/100)) * 100` where `epoch_shift`
+/// is `-11_644_473_600` seconds (1601→1970 shift). The shift is required:
 /// `nano_timestamp()` uses `SystemTime::UNIX_EPOCH`, not raw FILETIME.
 #[inline]
 pub const fn from_sys_time(nt_time: i64) -> i128 {
-    /// `std.time.epoch.windows * (std.time.ns_per_s / 100)` — the
-    /// 1601-01-01 → 1970-01-01 offset expressed in 100-ns ticks.
+    /// The 1601-01-01 → 1970-01-01 offset expressed in 100-ns ticks.
     const WINDOWS_EPOCH_TO_UNIX_EPOCH_100NS: i128 = -11_644_473_600 * 10_000_000;
     (nt_time as i128 + WINDOWS_EPOCH_TO_UNIX_EPOCH_100NS) * 100
 }
@@ -298,7 +296,7 @@ pub const FILE_ACTION_RENAMED_OLD_NAME: DWORD = 0x0000_0004;
 pub const FILE_ACTION_RENAMED_NEW_NAME: DWORD = 0x0000_0005;
 
 bitflags::bitflags! {
-    /// `std.os.windows.FileNotifyChangeFilter` — `dwNotifyFilter` for
+    /// `dwNotifyFilter` flags for
     /// `ReadDirectoryChangesW` (`winnt.h` `FILE_NOTIFY_CHANGE_*`).
     ///
     /// `#[repr(transparent)]` is required: this newtype is passed by value
@@ -340,8 +338,8 @@ pub use bun_windows_sys::{PROCESS_INFORMATION, STARTUPINFOEXW, STARTUPINFOW};
 // `Zeroable for {OVERLAPPED, PROCESS_INFORMATION}` lives in `bun_core::ffi`
 // (orphan rule — trait owned by bun_core, type owned by bun_windows_sys).
 
-/// `std.os.windows.CreateIoCompletionPort` — wraps the kernel32 call and
-/// returns `Err` on `NULL` (matching Zig's `error.Unexpected`).
+/// Wraps the kernel32 `CreateIoCompletionPort` call and returns `Err` on
+/// `NULL`.
 pub fn CreateIoCompletionPort(
     file_handle: HANDLE,
     existing_completion_port: HANDLE,
@@ -369,7 +367,6 @@ pub use bun_windows_sys::externs::OPEN_EXISTING;
 
 pub use bun_windows_sys::externs::CommandLineToArgvW;
 
-// TODO(port): move to windows_sys
 unsafe extern "system" {
     // safe: `HANDLE` is a by-value opaque; bad handle → FILE_TYPE_UNKNOWN +
     // GetLastError, no UB.
@@ -419,7 +416,7 @@ pub use bun_windows_sys::Win32Error;
 /// newtype).
 pub use bun_errno::Win32ErrorExt;
 
-/// `Win32Error::unwrap()` from windows.zig — extension trait because
+/// `Win32Error::unwrap()` — extension trait because
 /// `Win32Error` is a foreign type and `bun_core::Error` is unavailable in
 /// `bun_errno` (orphan rule + layering).
 pub trait Win32ErrorUnwrap: Copy {
@@ -438,7 +435,7 @@ impl Win32ErrorUnwrap for Win32Error {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// DEAD: full 1188-variant MS-ERREF const table from Zig std. Kept gated for
+// DEAD: full 1188-variant MS-ERREF const table. Kept gated for
 // reference; move individual consts up into `bun_windows_sys::Win32Error`
 // if a new caller needs one. (Inherent impl on a foreign type is illegal,
 // so this block cannot be un-gated as-is.)
@@ -3266,7 +3263,6 @@ pub fn GetProcAddressA(ptr: Option<*mut c_void>, utf8: &bun_core::ZStr) -> Optio
 
 pub use bun_windows_sys::externs::LoadLibraryA;
 
-// TODO(port): move to windows_sys
 unsafe extern "system" {
     #[link_name = "CreateHardLinkW"]
     fn CreateHardLinkW_raw(
@@ -3319,7 +3315,7 @@ pub fn get_last_error() -> bun_core::Error {
     bun_core::errno_to_zig_err(get_last_errno() as i32)
 }
 
-/// Zig: `std.os.windows.kernel32.GetLastError()` as `Win32Error` — raw
+/// `kernel32.GetLastError()` as `Win32Error` — raw
 /// `DWORD` error truncated to the documented 16-bit code space. Callers that
 /// want the POSIX-style `bun_core::Error` should use [`get_last_error`].
 #[inline]
@@ -3327,7 +3323,7 @@ pub fn get_last_win32_error() -> Win32Error {
     Win32Error(kernel32::GetLastError() as u16)
 }
 
-/// Zig: `@tagName(bun.windows.getLastError())` — for `Output.debug` only.
+/// Printable Win32 error name — for `Output.debug` only.
 #[inline]
 pub fn get_last_error_tag() -> impl core::fmt::Display {
     // `Win32Error` derives `Debug`; route through that for a printable token.
@@ -3340,7 +3336,7 @@ pub fn get_last_error_tag() -> impl core::fmt::Display {
     D(get_last_win32_error())
 }
 
-/// `bun.windows.Error` — Zig alias for `Win32Error`.
+/// `bun.windows.Error` — alias for `Win32Error`.
 pub type Error = Win32Error;
 
 /// `bun.windows.translateNTStatusToErrno` — thin wrapper over the canonical
@@ -3462,7 +3458,7 @@ pub use bun_windows_sys::{
     MENU_EVENT_RECORD, MOUSE_EVENT_RECORD, WINDOW_BUFFER_SIZE_EVENT,
 };
 
-// Bun__UVSignalHandle__{init,close}: see src/runtime/node/uv_signal_handle_windows.zig
+// Bun__UVSignalHandle__{init,close}: see src/runtime/node/uv_signal_handle_windows.rs
 
 /// Is not the actual UID of the user, but just a hash of username.
 pub fn user_unique_id() -> u32 {
@@ -3601,12 +3597,10 @@ pub fn win_sock_error_to_zig_error(
 }
 
 pub fn WSAGetLastError() -> Option<E> {
-    // Spec note (windows.zig:3303): Zig returns `?SystemErrno`; this port
-    // intentionally re-types to `Option<E>` because all Rust callers consume
-    // `E`. The `as u32` cast mirrors Zig's infallible `@intFromEnum` —
-    // `WSAGetLastError()` is documented to return non-negative values, so a
-    // checked `try_from().expect()` would only add a panic path the spec
-    // never had.
+    // Returns `Option<E>` because all callers consume `E`.
+    // `WSAGetLastError()` is documented to return non-negative values, so the
+    // `as u32` cast is fine; a checked `try_from().expect()` would only add a
+    // panic path.
     SystemErrno::init(win32::ws2_32::WSAGetLastError() as u32).map(SystemErrno::to_e)
 }
 
@@ -3693,8 +3687,7 @@ pub fn get_module_handle_from_address(addr: usize) -> Option<HMODULE> {
             // module's reference count unless this flag is set. Callers only
             // inspect the returned HMODULE (crash-handler symbolication) and
             // never FreeLibrary it, so omitting the flag leaks one refcount
-            // per call. (The Zig spec at windows.zig:3355 has the same
-            // omission — fixed here intentionally.)
+            // per call.
             GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
             // Docs: when FROM_ADDRESS is set, lpModuleName is "an address in
             // the module" — typed as LPCWSTR but really an opaque pointer.
@@ -3761,11 +3754,9 @@ pub fn DeleteFileBun(sub_path_w: &[u16], options: DeleteFileOptions) -> bun_sys:
         windows::FILE_NON_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT // would we ever want to delete the target instead?
     };
 
-    // UNICODE_STRING.Length is `u16` (bytes). Zig's `@intCast` here
-    // (windows.zig:3402) is unchecked-in-release; in Rust the equivalent
-    // `try_from().expect()` would panic on any path ≥ 32768 wide chars.
-    // Surface NAMETOOLONG instead so NtCreateFile's caller gets a recoverable
-    // error rather than an abort.
+    // UNICODE_STRING.Length is `u16` (bytes). A `try_from().expect()` would
+    // panic on any path ≥ 32768 wide chars; surface NAMETOOLONG instead so
+    // NtCreateFile's caller gets a recoverable error rather than an abort.
     let path_len_bytes = match u16::try_from(sub_path_w.len() * 2) {
         Ok(n) => n,
         Err(_) => return bun_sys::Result::errno(E::NAMETOOLONG, bun_sys::Tag::open),
@@ -3777,11 +3768,9 @@ pub fn DeleteFileBun(sub_path_w: &[u16], options: DeleteFileOptions) -> bun_sys:
         Buffer: sub_path_w.as_ptr().cast_mut().cast::<u16>(),
     };
 
-    // Guard len ≥ 2: Zig's `sub_path_w[0] == '.' and sub_path_w[1] == 0`
-    // (windows.zig:3410) is unguarded and reads garbage in ReleaseFast for
-    // len < 2; Rust would hard-panic on the bounds check instead. In practice
-    // callers pass converted NT paths (always ≥ 2 elems), but make the
-    // contract explicit so release-build behavior matches.
+    // Guard len ≥ 2: in practice callers pass converted NT paths (always
+    // ≥ 2 elems), but make the contract explicit rather than rely on the
+    // bounds check panicking.
     if sub_path_w.len() >= 2 && sub_path_w[0] == b'.' as u16 && sub_path_w[1] == 0 {
         // Windows does not recognize this, but it does work with empty string.
         nt_name.Length = 0;
@@ -3822,13 +3811,11 @@ pub fn DeleteFileBun(sub_path_w: &[u16], options: DeleteFileOptions) -> bun_sys:
         bun_core::fmt::fmt_path_u16(sub_path_w, Default::default()),
         rc
     );
-    // Zig stdlib `std.os.windows.DeleteFile` (which this is documented as a copy
-    // of) treats `STATUS_DELETE_PENDING`/`STATUS_FILE_DELETED` from the open as
-    // success — the target is already (being) deleted, which is what the caller
-    // wanted. `zigDeleteTree` (node_fs) goes through the stdlib `Dir.deleteFile`
-    // in Zig but through this function (via `Syscall::unlinkat`) in the Rust
-    // port, so without this short-circuit recursive `rmSync` on Windows fails
-    // with `EBUSY`/`UNKNOWN`→`EFAULT` whenever it races a still-open handle
+    // Treat `STATUS_DELETE_PENDING`/`STATUS_FILE_DELETED` from the open as
+    // success — the target is already (being) deleted, which is what the
+    // caller wanted. Recursive `rmSync` on Windows reaches this function via
+    // `Syscall::unlinkat`; without this short-circuit it fails with
+    // `EBUSY`/`UNKNOWN`→`EFAULT` whenever it races a still-open handle
     // (e.g. node test `tmpdir.refresh()` after a stream-heavy test).
     if rc == windows::ntstatus::DELETE_PENDING || rc == windows::ntstatus::FILE_DELETED {
         return bun_sys::Result::success();
@@ -3934,10 +3921,9 @@ pub struct EXCEPTION_POINTERS {
     pub ContextRecord: *mut core::ffi::c_void,
 }
 
-/// Zig `windows_c.zig::detectRuntimeVersion` — best-effort `major.build`
-/// string from `RtlGetVersion`. Zig writes into a static buffer (zero-alloc);
-/// mirror that with a `OnceLock<String>` so the per-call allocation goes away
-/// after the first call.
+/// Best-effort `major.build` string from `RtlGetVersion`. Cached in a
+/// `OnceLock<String>` so the per-call allocation goes away after the first
+/// call.
 pub fn detect_runtime_version() -> &'static str {
     #[repr(C)]
     struct OSVERSIONINFOW {
@@ -4012,10 +3998,8 @@ pub fn edit_win32_binary_subsystem(
     {
         return Err(bun_core::err!("Win32Error"));
     }
-    // Zig: `fd.reader().readInt(u32, .little)` — std.io.Reader loops until
-    // exactly 4 bytes are read (read-exact semantics). Use `read_all` (which
-    // retries on short reads) rather than a single `read()` syscall, so a
-    // short read isn't mis-reported as EndOfStream.
+    // Use `read_all` (which retries on short reads) rather than a single
+    // `read()` syscall, so a short read isn't mis-reported as EndOfStream.
     let mut off_bytes = [0u8; 4];
     let n = fd.read_all(&mut off_bytes).map_err(bun_core::Error::from)?;
     if n != 4 {
@@ -4031,10 +4015,8 @@ pub fn edit_win32_binary_subsystem(
     {
         return Err(bun_core::err!("Win32Error"));
     }
-    // Zig: `fd.writer().writeInt(u16, ..., .little)` — std.io.Writer loops
-    // until all bytes are written (write-all semantics). Use `write_all`
-    // rather than a single `write()` + length check so a short write is
-    // retried instead of failing.
+    // Use `write_all` rather than a single `write()` + length check so a
+    // short write is retried instead of failing.
     let sub_bytes = (subsystem as u16).to_le_bytes();
     fd.write_all(&sub_bytes).map_err(bun_core::Error::from)?;
     Ok(())
@@ -4043,7 +4025,6 @@ pub fn edit_win32_binary_subsystem(
 pub mod rescle {
     use super::*;
 
-    // TODO(port): move to windows_sys
     unsafe extern "C" {
         fn rescle__setIcon(exe_path: *const u16, icon_path: *const u16) -> c_int;
         fn rescle__setWindowsMetadata(
@@ -4225,7 +4206,7 @@ pub struct PROCESS_MEMORY_COUNTERS {
     pub PeakPagefileUsage: usize,
 }
 
-/// `std.os.windows.GetProcessMemoryInfo` — psapi `K32GetProcessMemoryInfo`
+/// psapi `K32GetProcessMemoryInfo`
 /// (kernel32 hosts the K32* shims since Windows 7, no separate psapi.lib).
 pub fn GetProcessMemoryInfo(process: HANDLE) -> Result<PROCESS_MEMORY_COUNTERS, Win32Error> {
     unsafe extern "system" {
@@ -4274,12 +4255,10 @@ pub fn update_stdio_mode_flags(
 }
 
 /// RAII guard: applies [`update_stdio_mode_flags`] to **stdin** on construction
-/// and restores the original console mode on `Drop`. Replaces the Zig
-/// `defer SetConsoleMode(stdin, original_mode)` pattern at call sites.
+/// and restores the original console mode on `Drop`.
 ///
 /// If the underlying `GetConsoleMode`/`SetConsoleMode` fails (e.g. stdin is not
-/// a console), the guard is inert and `Drop` is a no-op — matching the Zig
-/// callers' `catch null` behaviour.
+/// a console), the guard is inert and `Drop` is a no-op.
 pub struct StdinModeGuard {
     original: Option<DWORD>,
 }
@@ -4331,8 +4310,7 @@ pub fn become_watcher_manager() -> ! {
     // SAFETY: null args allowed
     let job = unsafe { externs::CreateJobObjectA(ptr::null_mut(), ptr::null()) };
     if job.is_null() {
-        // Zig (windows.zig:3696): `@tagName(GetLastError())` — print the
-        // Win32 error name, not the raw DWORD.
+        // Print the Win32 error name, not the raw DWORD.
         let err = Win32Error(kernel32::GetLastError() as u16);
         bun_core::Output::panic(format_args!(
             "Could not create watcher Job Object: {:?}",
@@ -4365,14 +4343,12 @@ pub fn become_watcher_manager() -> ! {
         if let Err(err) = spawn_watcher_child(&mut procinfo, job) {
             bun_core::handle_error_return_trace(err);
             if err == bun_core::err!("Win32Error") {
-                // Zig (windows.zig:3721): `@tagName(GetLastError())`. Note:
-                // this read is best-effort — Drop guards inside
+                // This read is best-effort — Drop guards inside
                 // `spawn_watcher_child` (FreeEnvironmentStringsW, Vec drops
                 // via HeapFree) may have clobbered the thread's last-error
-                // before we get here. The Zig spec has the same ordering
-                // hazard (`defer` runs before `catch`); a proper fix would
-                // thread the captured Win32 code through the error payload,
-                // which requires changing `spawn_watcher_child`'s return type.
+                // before we get here. A proper fix would thread the captured
+                // Win32 code through the error payload, which requires
+                // changing `spawn_watcher_child`'s return type.
                 let last = Win32Error(GetLastError() as u16);
                 bun_core::Output::panic(format_args!("Failed to spawn process: {:?}\n", last));
             }
@@ -4445,8 +4421,7 @@ pub fn spawn_watcher_child(
         return Err(bun_core::err!("Win32Error"));
     }
 
-    // Zig used a packed bitflag struct (`win32.CreateProcessFlags`); the Rust
-    // win32 layer exposes these as DWORD constants — assemble the raw mask.
+    // The win32 layer exposes these as DWORD constants — assemble the raw mask.
     const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
     let flags: DWORD = CREATE_UNICODE_ENVIRONMENT | EXTENDED_STARTUPINFO_PRESENT;
 
@@ -4549,7 +4524,7 @@ pub fn spawn_watcher_child(
 }
 
 /// Returns null on error. Use windows API to lookup the actual error.
-/// The reason this function is in zig is so that we can use our own utf16-conversion functions.
+/// Implemented here so that we can use our own utf16-conversion functions.
 ///
 /// Using characters16() does not seem to always have the sentinel. or something else
 /// broke when I just used it. Not sure. ... but this works!
@@ -4572,7 +4547,7 @@ pub extern "C" fn Bun__LoadLibraryBunString(str_: &bun_core::String) -> *mut c_v
             &buf.as_slice()[0..src.len()]
         }
         EncodingNonAscii::Latin1 => {
-            // Zig: bun.strings.copyU8IntoU16 — straight zero-extend per byte.
+            // Straight zero-extend per byte.
             let src = str_.latin1();
             let dst = &mut buf.as_mut_slice()[..src.len()];
             // zip avoids the per-iteration bounds check an indexed loop would
@@ -4598,7 +4573,7 @@ pub use bun_windows_sys::externs::windows_enable_stdio_inheritance;
 ///
 /// NOTE: THE FILE MUST BE OPENED WITH ACCESS_MASK "DELETE" OR THIS WILL FAIL
 pub fn delete_opened_file(fd: Fd) -> bun_sys::Result<()> {
-    // TODO(port): comptime bun.assert(builtin.target.os.version_range.windows.min.isAtLeast(.win10_rs5));
+    // Relies on Bun's minimum supported Windows version being >= win10_rs5.
     let mut info = win32::FILE_DISPOSITION_INFORMATION_EX {
         Flags: FILE_DISPOSITION_DELETE
             | FILE_DISPOSITION_POSIX_SEMANTICS
@@ -4644,19 +4619,16 @@ pub fn move_opened_file_at(
     // supported in order to avoid either (1) using a redundant call that we can know in advance will return
     // STATUS_NOT_SUPPORTED or (2) only setting IGNORE_READONLY_ATTRIBUTE when >= rs5
     // and therefore having different behavior when the Windows version is >= rs1 but < rs5.
-    // TODO(port): comptime bun.assert(builtin.target.os.version_range.windows.min.isAtLeast(.win10_rs5));
+    // Bun's minimum supported Windows version is >= win10_rs5.
 
     if cfg!(debug_assertions) {
         debug_assert!(!new_file_name.contains(&(b'/' as u16))); // Call moveOpenedFileAtLoose
     }
 
-    // Zig (windows.zig:3933) sizes this against `bun.MAX_PATH_BYTES`
-    // (≈98 KB on Windows: PATH_MAX_WIDE*3+1, the UTF-8 worst case). The
-    // FileName tail here is UTF-16, so the correct cap is `PATH_MAX_WIDE * 2`
-    // bytes — using the UTF-8 multiplier just wastes ~32 KB of stack on a
-    // function called from already-deep install/bundler call chains. This
-    // intentionally diverges from the Zig constant (which has the same
-    // over-allocation) without shrinking the accepted path length: any
+    // The FileName tail here is UTF-16, so the correct cap is
+    // `PATH_MAX_WIDE * 2` bytes — sizing against the UTF-8 worst case
+    // (PATH_MAX_WIDE*3+1, ≈98 KB) would just waste ~32 KB of stack on a
+    // function called from already-deep install/bundler call chains. Any
     // `new_file_name.len() <= PATH_MAX_WIDE` still fits.
     const STRUCT_BUF_LEN: usize =
         size_of::<win32::FILE_RENAME_INFORMATION_EX>() + (bun_paths::PATH_MAX_WIDE * 2 - 1);
@@ -4766,12 +4738,11 @@ pub fn move_opened_file_at_loose(
             new_path
         };
 
-    // Search the *stripped* path for the directory separator. The Zig spec
-    // (windows.zig:3987) searches `new_path` here, which for input ".\\foo"
-    // finds the leading-dot-slash backslash and yields dirname="." → rejected
-    // by NtCreateFile. Searching `without_leading_dot_slash` lets ".\\foo"
-    // fall through to the easy-mode branch below as intended. (Upstream Zig
-    // has the same latent bug; fixed here intentionally.)
+    // Search the *stripped* path for the directory separator. Searching
+    // `new_path` instead would, for input ".\\foo", find the leading-dot-slash
+    // backslash and yield dirname="." → rejected by NtCreateFile. Searching
+    // `without_leading_dot_slash` lets ".\\foo" fall through to the easy-mode
+    // branch below as intended.
     if let Some(last_slash) = without_leading_dot_slash
         .iter()
         .rposition(|&c| c == b'\\' as u16)
@@ -4805,8 +4776,9 @@ pub fn move_opened_file_at_loose(
     )
 }
 
-/// Derived from std.os.windows.renameAtW
-/// Allows more errors
+/// Rename `old_path_w` (relative to `old_dir_fd`) to `new_path_w` (relative to
+/// `new_dir_fd`) via NT file-information rename. Surfaces more error cases
+/// than typical rename wrappers.
 pub fn rename_at_w(
     old_dir_fd: Fd,
     old_path_w: &[u16],
@@ -4855,7 +4827,6 @@ pub fn rename_at_w(
 
 mod kernel32_2 {
     use super::*;
-    // TODO(port): move to windows_sys
     unsafe extern "system" {
         /// No preconditions; allocates and returns the env block (or null).
         pub(super) safe fn GetEnvironmentStringsW() -> LPWSTR;
@@ -4967,8 +4938,7 @@ pub fn translate_ntstatus_to_errno(status: NTSTATUS) -> E {
 ///
 /// SAFETY CONTRACT: `name` MUST be NUL-terminated (last element == `0`).
 /// `GetEnvironmentVariableW` takes `LPCWSTR` and reads until it hits a NUL
-/// WCHAR; the Zig spec this ports (`std.process.getenvW`) encodes that in the
-/// type system as `[:0]const u16`, which Rust's `&[u16]` does not. Passing a
+/// WCHAR — Rust's `&[u16]` does not encode that in the type. Passing a
 /// non-terminated slice causes Win32 to read past the buffer.
 pub fn getenv_w(name: &[u16]) -> Option<Vec<u16>> {
     debug_assert!(
@@ -4999,5 +4969,3 @@ pub fn getenv_w(name: &[u16]) -> Option<Vec<u16>> {
 bun_core::declare_scope!(windowsUserUniqueId, visible);
 
 // SetFilePointerEx referenced via the `pub use` at the top of this module.
-
-// ported from: src/sys/windows/windows.zig
diff --git a/src/sys_jsc/error_jsc.rs b/src/sys_jsc/error_jsc.rs
index 1e9db142725..c01fc377390 100644
--- a/src/sys_jsc/error_jsc.rs
+++ b/src/sys_jsc/error_jsc.rs
@@ -4,9 +4,6 @@ use bun_sys::Error;
 
 use crate::{CallFrame, JSGlobalObject, JSPromise, JSValue, JsResult, SystemErrorJsc};
 
-// PORT NOTE: In Rust, `to_js`/`from_js` live as extension-trait methods in the
-// `*_jsc` crate (per PORTING.md). The Zig free fns `toJS`/`toJSWithAsyncStack`
-// become methods on this trait, impl'd for `bun_sys::Error`.
 pub trait ErrorJsc {
     fn to_js(&self, global: &JSGlobalObject) -> JsResult<JSValue>;
 
@@ -37,17 +34,16 @@ impl ErrorJsc for Error {
     }
 }
 
-// PORT NOTE: Zig `pub const TestingAPIs = struct { ... }` is a fieldless namespace
-// struct. Mapped to a module (not `struct + impl`) because `#[bun_jsc::host_fn]`'s
+// `TestingAPIs` is a module (not `struct + impl`) because `#[bun_jsc::host_fn]`'s
 // Free-kind shim emits `#fn_name(__g, __f)` without a `Self::` qualifier — the
 // wrapped fn must resolve unqualified at module scope (same constraint as
 // `install_jsc::install_binding::js_parse_lockfile`).
 pub mod TestingAPIs {
     use super::*;
 
-    /// Exercises Error.name() with from_libuv=true so tests can feed the
-    /// negated-UV-code errno values that node_fs.zig stores and verify the
-    /// integer overflow at translateUVErrorToE(-code) is fixed. Windows-only.
+    /// Exercises Error.name() with from_libuv=true so tests can feed
+    /// negated-UV-code errno values and verify the integer overflow at
+    /// translateUVErrorToE(-code) is fixed. Windows-only.
     #[bun_jsc::host_fn]
     pub fn sys_error_name_from_libuv(
         global: &JSGlobalObject,
@@ -66,7 +62,7 @@ pub mod TestingAPIs {
         #[cfg(windows)]
         {
             let err = Error {
-                // @intCast → checked narrowing; target is Error.errno's int type.
+                // Checked narrowing into Error.errno's int type.
                 errno: arguments[0]
                     .to_int32()
                     .try_into()
@@ -114,7 +110,7 @@ pub mod TestingAPIs {
     /// (regression test for the bionic LP64 layout fix). The Rust port uses the
     /// `libc` crate's `sigaction`/`sigset_t` directly, which already has the
     /// correct per-target layout (bionic included), so this is a sanity check
-    /// rather than a fix-carrier — the layout bug was Zig-stdlib-specific.
+    /// rather than a fix-carrier.
     #[bun_jsc::host_fn]
     pub fn sigaction_layout(global: &JSGlobalObject, _frame: &CallFrame) -> JsResult<JSValue> {
         #[cfg(not(unix))]
@@ -187,5 +183,3 @@ pub mod TestingAPIs {
         }
     }
 }
-
-// ported from: src/sys_jsc/error_jsc.zig
diff --git a/src/sys_jsc/fd_jsc.rs b/src/sys_jsc/fd_jsc.rs
index 75c22f3b2b9..0b65338951c 100644
--- a/src/sys_jsc/fd_jsc.rs
+++ b/src/sys_jsc/fd_jsc.rs
@@ -8,9 +8,8 @@ use bun_sys::{Fd, FdExt};
 
 use crate::{JSGlobalObject, JSValue, JsResult, RangeErrorOptions};
 
-/// Extension trait wiring `to_js` / `from_js` onto `bun_sys::Fd`.
-/// In Zig these are free functions re-exported onto `bun.FD` via the
-/// `*_jsc` alias; in Rust the `*_jsc` crate provides them as trait methods.
+/// Extension trait wiring `to_js` / `from_js` onto `bun_sys::Fd`;
+/// the `*_jsc` crate provides them as trait methods.
 pub trait FdJsc: Sized {
     fn from_js(value: JSValue) -> Option<Self>;
     fn from_js_validated(value: JSValue, global: &JSGlobalObject) -> JsResult<Option<Self>>;
@@ -88,9 +87,6 @@ impl FdJsc for Fd {
                     ..Default::default()
                 })
                 .to_error_instance(global);
-                // Zig: `return global.vm().throwError(global, err_instance) catch .zero;`
-                // — `throwError` always returns the error type, so `catch .zero`
-                // makes the expression evaluate to JSValue.zero.
                 let _ = global.vm().throw_error(global, err_instance);
                 return JSValue::ZERO;
             }
@@ -109,8 +105,6 @@ impl FdJsc for Fd {
         }
         #[cfg(windows)]
         {
-            // PORT NOTE: Zig accessed `any_fd.value.as_system` / `.as_uv` directly.
-            // `bun_core::Fd` exposes `kind()` / `native()` / `uv()` instead.
             return match self.kind() {
                 FdKind::System => JSValue::js_number_from_uint64(self.native() as u64),
                 FdKind::Uv => JSValue::js_number_from_int32(self.uv()),
@@ -122,5 +116,3 @@ impl FdJsc for Fd {
         }
     }
 }
-
-// ported from: src/sys_jsc/fd_jsc.zig
diff --git a/src/sys_jsc/lib.rs b/src/sys_jsc/lib.rs
index 08ce4d97b87..fcdd9685f84 100644
--- a/src/sys_jsc/lib.rs
+++ b/src/sys_jsc/lib.rs
@@ -24,18 +24,16 @@ pub use bun_jsc::{
 // ──────────────────────────────────────────────────────────────────────────
 // SystemErrorJsc — JSC bridge for the T1 `bun_sys::SystemError` data struct.
 //
-// In Zig there is one `jsc.SystemError` with `.toErrorInstance()`. The Rust
-// port split the *data* (`bun_sys::SystemError`, NOT `#[repr(C)]`) from the
-// FFI struct (`bun_jsc::SystemError`, `#[repr(C)]` field-order = C++). This
-// trait marshals the former into the latter and forwards to
+// The *data* struct (`bun_sys::SystemError`, NOT `#[repr(C)]`) is split from
+// the FFI struct (`bun_jsc::SystemError`, `#[repr(C)]` field-order = C++).
+// This trait marshals the former into the latter and forwards to
 // `bun_jsc::SystemError::to_error_instance{,_with_async_stack}`.
 //
-// Ref-count contract: `bun_jsc::SystemError::to_error_instance` does
-// `defer this.deref()` (matching SystemError.zig), so the marshalled struct
-// must hold exactly the refs `self` held — i.e. a bitwise field copy with NO
-// extra `ref_()`. The caller's `bun_sys::SystemError` is consumed (its strings
-// reach refcount-0) just as in Zig where `Error.toSystemError()` builds a
-// temporary that `.toErrorInstance()` consumes.
+// Ref-count contract: `bun_jsc::SystemError::to_error_instance` derefs each
+// field exactly once, so the marshalled struct must hold exactly the refs
+// `self` held — i.e. a bitwise field copy with NO extra `ref_()`. The
+// caller's `bun_sys::SystemError` is consumed (its strings reach
+// refcount-0).
 // ──────────────────────────────────────────────────────────────────────────
 pub trait SystemErrorJsc {
     fn to_error_instance(&self, global: &JSGlobalObject) -> JSValue;
@@ -64,12 +62,12 @@ fn marshal(e: &bun_sys::SystemError) -> bun_jsc::SystemError {
 }
 
 impl SystemErrorJsc for bun_sys::SystemError {
-    /// `SystemError.toErrorInstance(global)` (SystemError.zig).
+    /// `SystemError.toErrorInstance(global)`.
     fn to_error_instance(&self, global: &JSGlobalObject) -> JSValue {
         marshal(self).to_error_instance(global)
     }
-    /// `SystemError.toErrorInstanceWithAsyncStack(global, promise)`
-    /// (SystemError.zig) — `toErrorInstance` then attach the promise's await
+    /// `SystemError.toErrorInstanceWithAsyncStack(global, promise)` —
+    /// `toErrorInstance` then attach the promise's await
     /// chain as async stack frames so threadpool-rejected promises get a
     /// useful trace.
     fn to_error_instance_with_async_stack(
@@ -80,5 +78,3 @@ impl SystemErrorJsc for bun_sys::SystemError {
         marshal(self).to_error_instance_with_async_stack(global, promise)
     }
 }
-
-// ported from: src/sys_jsc/{signal_code,error,fd}_jsc.zig
diff --git a/src/sys_jsc/signal_code_jsc.rs b/src/sys_jsc/signal_code_jsc.rs
index fe108aa6269..509dbeb8d46 100644
--- a/src/sys_jsc/signal_code_jsc.rs
+++ b/src/sys_jsc/signal_code_jsc.rs
@@ -28,8 +28,8 @@ pub fn from_js(arg: JSValue, global_this: &JSGlobalObject) -> JsResult<SignalCod
             );
         }
 
-        // PORT NOTE: SignalCode is `#[repr(transparent)] struct(u8)` (non-exhaustive
-        // Zig enum), so the public ctor is used instead of transmute.
+        // SignalCode is non-exhaustive over `u8`, so construct via the public
+        // ctor instead of a transmute.
         return Ok(SignalCode(sig64 as u8));
     } else if arg.is_string() {
         // SAFETY: `is_string()` ⇒ `as_string()` returns a non-null JSString cell;
@@ -47,5 +47,3 @@ pub fn from_js(arg: JSValue, global_this: &JSGlobalObject) -> JsResult<SignalCod
 
     Ok(SignalCode::DEFAULT)
 }
-
-// ported from: src/sys_jsc/signal_code_jsc.zig
diff --git a/src/tcc_sys/tcc.rs b/src/tcc_sys/tcc.rs
index 52769da1d25..8d233756785 100644
--- a/src/tcc_sys/tcc.rs
+++ b/src/tcc_sys/tcc.rs
@@ -9,17 +9,13 @@ pub use State as TCCState;
 pub type TCCErrorFunc = Option<unsafe extern "C" fn(opaque: *mut c_void, msg: *const c_char)>;
 
 /// Typed error callback signature for a given context type.
-///
-/// Zig: `fn ErrorFunc(Ctx: type) type { return fn (ctx: ?*Ctx, msg: [*:0]const u8) callconv(.c) void; }`
 pub type ErrorFunc<Ctx> = unsafe extern "C" fn(ctx: *mut Ctx, msg: *const c_char);
 
 // `libtcc.a` is only built where `cfg.tinycc` is true (`scripts/build/config.ts`):
 // not Windows/aarch64 (TinyCC has no aarch64-pe-coff backend), not Android, not
 // FreeBSD (the vendored fork doesn't support those targets). On those platforms
-// these `extern "C"` decls would be undefined at link. Zig's `comptime
-// !Environment.enable_tinycc` early-returns in `ffi.zig` keep the *Zig*
-// callers off the analysis graph, so the Zig externs never get emitted; Rust
-// has no lazy analysis — `bun_runtime::ffi::ffi_body::{Source::add,
+// these `extern "C"` decls would be undefined at link:
+// `bun_runtime::ffi::ffi_body::{Source::add,
 // CompileC::compile}` are reachable from `extern "C"` JS bindings and the
 // monomorphized refs land in `libbun_rust.a` regardless of any
 // `if !ENABLE_TINYCC { return }` runtime guard. Swap the `extern` block for
@@ -55,8 +51,8 @@ tcc_externs! {
     fn tcc_set_lib_path(s: *mut TCCState, path: *const c_char);
     fn tcc_set_error_func(s: *mut TCCState, error_opaque: *mut c_void, error_func: TCCErrorFunc);
     // NOTE: tcc_get_error_func / tcc_get_error_opaque were removed from the libtcc public API
-    // (not present in vendor/tinycc/libtcc.h). tcc.zig:10-11 only escapes a link error via lazy
-    // analysis. Do not declare them here — referencing them would fail to link.
+    // (not present in vendor/tinycc/libtcc.h). Do not declare them here —
+    // referencing them would fail to link.
     fn tcc_set_options(s: *mut TCCState, str_: *const c_char) -> c_int;
     fn tcc_add_include_path(s: *mut TCCState, pathname: *const c_char) -> c_int;
     fn tcc_add_sysinclude_path(s: *mut TCCState, pathname: *const c_char) -> c_int;
@@ -81,8 +77,8 @@ tcc_externs! {
 
 const TCC_OUTPUT_MEMORY: c_int = 1;
 const TCC_OUTPUT_EXE: c_int = 2;
-// NOTE: vendor/tinycc/libtcc.h defines OBJ=3, DLL=4 (Bun's fork swapped vs upstream).
-// tcc.zig:30-31 has these reversed — that is a latent spec bug; match libtcc.h here.
+// NOTE: vendor/tinycc/libtcc.h defines OBJ=3, DLL=4 (Bun's fork swapped vs upstream);
+// match libtcc.h here.
 const TCC_OUTPUT_OBJ: c_int = 3;
 const TCC_OUTPUT_DLL: c_int = 4;
 const TCC_OUTPUT_PREPROCESS: c_int = 5;
@@ -109,16 +105,14 @@ pub enum Error {
     /// Could not get a symbol for some reason
     #[error("RelocationError")]
     RelocationError,
-    // TODO(port): `OutputError` is returned by `output_file` in the Zig source but is NOT a
-    // member of the Zig `Error` set — latent bug only unobserved because Zig analysis is lazy
-    // and `outputFile` has no callers. Kept here so `output_file` type-checks.
+    // Returned by `output_file`.
     #[error("OutputError")]
     OutputError,
 }
 
 bun_core::named_error_set!(Error);
 
-#[repr(i32)] // Zig: enum(c_int) — c_int == i32 on all Bun targets
+#[repr(i32)] // c_int == i32 on all Bun targets
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum OutputFormat {
     /// Output will be run in memory
@@ -138,7 +132,6 @@ pub enum OutputFormat {
 // allowing for interop with other APIs taking `*mut c_void` pointers.
 bun_opaque::opaque_ffi! { pub struct Symbol; }
 
-/// Zig: `Symbol.Callback = fn (?*anyopaque, [*:0]const u8, ?*const Symbol) void`
 pub type SymbolCallback =
     unsafe extern "C" fn(ctx: *mut c_void, name: *const c_char, val: *const Symbol);
 
@@ -147,16 +140,14 @@ bun_opaque::opaque_ffi! {
     pub struct State;
 }
 
-/// Zig: `State.Config(ErrCtx).err` anonymous struct.
 pub struct ConfigErr<ErrCtx> {
     pub ctx: Option<*mut ErrCtx>,
     pub handler: unsafe extern "C" fn(*mut ErrCtx, *const c_char),
 }
 
-/// Zig: `fn Config(ErrCtx: type) type { return struct { ... } }`
 pub struct Config<ErrCtx> {
-    // TODO(port): lifetime — call sites pass both literals (default_tcc_options) and runtime
-    // strings (CompileC.flags / BUN_TCC_OPTIONS); kept as a raw ptr, revisit as a borrow.
+    // Call sites pass both literals (default_tcc_options) and runtime strings
+    // (CompileC.flags / BUN_TCC_OPTIONS); kept as a raw ptr rather than a borrow.
     pub options: Option<NonNull<ZStr>>,
     pub output_type: OutputFormat,
     pub err: ConfigErr<ErrCtx>,
@@ -167,8 +158,8 @@ where
     ConfigErr<ErrCtx>: Default,
 {
     fn default() -> Self {
-        // TODO(port): Zig field defaults are `options = null, output_type = .Memory`; `err.handler`
-        // has no default so a literal `.{}` is invalid in Zig too. This Default impl is best-effort.
+        // `err.handler` has no default, so this Default impl exists only for
+        // `ErrCtx` types whose `ConfigErr` provides a handler default.
         Self {
             options: None,
             output_type: OutputFormat::Memory,
@@ -188,7 +179,6 @@ impl State {
     pub fn init<ErrCtx, const VALIDATE_OPTIONS: bool>(
         config: &Config<ErrCtx>,
     ) -> Result<NonNull<State>, bun_core::Error> {
-        // TODO(port): narrow error set to (AllocError | Error)
         let state_ptr = State::new()?;
         // errdefer state.destroy() — State is an FFI handle without Drop, so use scopeguard.
         let guard = scopeguard::guard(state_ptr, |p| {
@@ -236,7 +226,7 @@ impl State {
     /// # Safety
     /// `s` must have been returned by [`State::new`]/[`State::init`] and not yet freed.
     pub unsafe fn destroy(s: *mut State) {
-        // PORT NOTE: opaque FFI handle — kept as explicit destroy fn, not `impl Drop`.
+        // opaque FFI handle — kept as explicit destroy fn, not `impl Drop`.
         // SAFETY: caller's contract guarantees `s` is a live `tcc_new` handle not yet deleted.
         unsafe { tcc_delete(s) }
     }
@@ -255,7 +245,7 @@ impl State {
     ) {
         // SAFETY: ErrorFunc<Context> is ABI-identical to the untyped TCCErrorFunc inner fn
         // (both `extern "C" fn(*mut _, *const c_char)`, differing only in the opaque
-        // pointee type); mirrors Zig `@ptrCast(errorFunc)`.
+        // pointee type).
         let erased: TCCErrorFunc = Some(unsafe {
             bun_ptr::cast_fn_ptr::<
                 ErrorFunc<Context>,
@@ -269,14 +259,12 @@ impl State {
 
     // NOTE: get_error_func / get_error_opaque wrappers removed — the underlying
     // tcc_get_error_func / tcc_get_error_opaque symbols were dropped from the vendored
-    // libtcc.h and would fail to link if referenced. (tcc.zig:125-131 carries the same
-    // dead wrappers, surviving only via lazy analysis.)
+    // libtcc.h and would fail to link if referenced.
 
     /// Set options as from command line (multiple supported)
     pub fn set_options(&mut self, str_: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; str_ is NUL-terminated.
         if unsafe { tcc_set_options(self, str_.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidOptions);
         }
         Ok(())
@@ -288,7 +276,6 @@ impl State {
     pub fn add_include_path(&mut self, pathname: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; pathname is NUL-terminated.
         if unsafe { tcc_add_include_path(self, pathname.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidIncludePath);
         }
         Ok(())
@@ -298,7 +285,6 @@ impl State {
     pub fn add_sys_include_path(&mut self, pathname: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; pathname is NUL-terminated.
         if unsafe { tcc_add_sysinclude_path(self, pathname.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidIncludePath);
         }
         Ok(())
@@ -316,29 +302,20 @@ impl State {
 
     /// Define multiple preprocessor symbols with integer values.
     ///
-    /// Zig: `defineSymbolsComptime(s, symbols: anytype)` — iterated anonymous-struct fields via
-    /// `@typeInfo`/`@field` and dispatched on field type at comptime. Per PORTING.md §Comptime
-    /// reflection, homogenized to a slice + plain `for` since every call site passes ints (the
-    /// Zig `.pointer` arm at tcc.zig:192 is dead and itself buggy — it passes `s` twice).
-    ///
     /// ## Example
     /// ```ignore
     /// state.define_symbols(&[("foo", 1), ("baz", 42)]);
     /// ```
     pub fn define_symbols(&mut self, symbols: &[(&str, i64)]) {
-        // Zig: `var buf: [256]u8 = undefined;`
         let mut buf = [0u8; 256];
         for &(name, value) in symbols {
-            // Zig field names are `[:0]const u8` (comptime NUL-terminated); copy into the stack
-            // buffer to recover that invariant for the C ABI.
-            // PERF(port): was comptime monomorphization (zero-copy name) — profile if hot.
+            // Copy the name into the stack buffer to NUL-terminate it for the C ABI.
             let name_len = name.len();
             debug_assert!(name_len < buf.len());
             buf[..name_len].copy_from_slice(name.as_bytes());
             buf[name_len] = 0;
             let sym_ptr = buf.as_ptr().cast::<c_char>();
 
-            // Zig: `std.fmt.bufPrintZ(&buf, "{d}", .{value}) catch unreachable`
             let mut ibuf = bun_core::fmt::ItoaBuf::new();
             let digits = bun_core::fmt::itoa(&mut ibuf, value);
             let val_off = name_len + 1;
@@ -374,7 +351,6 @@ impl State {
     pub fn add_file(&mut self, filename: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; filename is NUL-terminated.
         if unsafe { tcc_add_file(self, filename.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::CompileError);
         }
         Ok(())
@@ -384,7 +360,6 @@ impl State {
     pub fn compile_string(&mut self, buf: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; buf is NUL-terminated.
         if unsafe { tcc_compile_string(self, buf.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::CompileError);
         }
         Ok(())
@@ -396,7 +371,6 @@ impl State {
     pub fn set_output_type(&mut self, output_type: OutputFormat) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState.
         if unsafe { tcc_set_output_type(self, output_type as c_int) } == -1 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidOutputType);
         }
         Ok(())
@@ -406,7 +380,6 @@ impl State {
     pub fn add_library_path(&mut self, pathname: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; pathname is NUL-terminated.
         if unsafe { tcc_add_library_path(self, pathname.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidLibraryPath);
         }
         Ok(())
@@ -416,7 +389,6 @@ impl State {
     pub fn add_library(&mut self, libraryname: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; libraryname is NUL-terminated.
         if unsafe { tcc_add_library(self, libraryname.as_ptr()) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidLibraryPath);
         }
         Ok(())
@@ -429,7 +401,6 @@ impl State {
     pub fn add_symbol(&mut self, name: &ZStr, val: *const c_void) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; name is NUL-terminated; val is an opaque address.
         if unsafe { tcc_add_symbol(self, name.as_ptr(), val) } != 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::InvalidSymbol);
         }
         Ok(())
@@ -437,11 +408,6 @@ impl State {
 
     /// Add multiple symbols to the compiled program.
     ///
-    /// Zig: `addSymbolsComptime(s, symbols: anytype)` — iterated anonymous-struct fields via
-    /// `@typeInfo`/`@field` at comptime. Per PORTING.md §Comptime reflection, homogenized to a
-    /// slice of `(name, *const c_void)` + plain `for` since every call site passes opaque
-    /// function/data pointers.
-    ///
     /// ## Example
     /// ```ignore
     /// state.add_symbols(&[
@@ -450,20 +416,16 @@ impl State {
     /// ])?;
     /// ```
     pub fn add_symbols(&mut self, symbols: &[(&str, *const c_void)]) -> Result<(), Error> {
-        // Zig field names are `[:0]const u8` (comptime NUL-terminated); copy into a stack buffer
-        // to recover that invariant for the C ABI.
-        // PERF(port): was comptime monomorphization (zero-copy name) — profile if hot.
+        // Copy each name into a stack buffer to NUL-terminate it for the C ABI.
         let mut buf = [0u8; 256];
         for &(name, val) in symbols {
             let len = name.len();
             debug_assert!(len < buf.len());
             buf[..len].copy_from_slice(name.as_bytes());
             buf[len] = 0;
-            // Zig: `try s.addSymbol(field.name, value);`
             // SAFETY: self is a valid *mut TCCState; buf[..=len] is NUL-terminated and outlives
             // the FFI call (tcc_add_symbol copies the name); val is an opaque address.
             if unsafe { tcc_add_symbol(self, buf.as_ptr().cast::<c_char>(), val) } != 0 {
-                // PERF(port): @branchHint(.unlikely)
                 return Err(Error::InvalidSymbol);
             }
         }
@@ -474,9 +436,6 @@ impl State {
     pub fn output_file(&mut self, filename: &ZStr) -> Result<(), Error> {
         // SAFETY: self is a valid *mut TCCState; filename is NUL-terminated.
         if unsafe { tcc_output_file(self, filename.as_ptr()) } == -1 {
-            // PERF(port): @branchHint(.unlikely)
-            // TODO(port): Zig source returns `error.OutputError` here, which is NOT in the Zig
-            // `Error` set (latent compile error masked by lazy analysis). See enum note above.
             return Err(Error::OutputError);
         }
         Ok(())
@@ -486,8 +445,7 @@ impl State {
     /// Returns the status code returned by the program's `main()` function.
     pub fn run(&mut self, argc: c_int, argv: *const *const c_char) -> c_int {
         // SAFETY: self is a valid *mut TCCState; argv points to argc NUL-terminated C strings.
-        // Zig signature is `[*:0]const [*:0]const u8` but the extern takes `[*c][*c]u8`; cast
-        // const away to match the C ABI (tcc does not mutate argv).
+        // Cast const away to match the C ABI (tcc does not mutate argv).
         unsafe { tcc_run(self, argc, argv as *mut *mut c_char) }
     }
 
@@ -498,7 +456,6 @@ impl State {
         // SAFETY: self is a valid *mut TCCState.
         let ret = unsafe { tcc_relocate(self) };
         if ret < 0 {
-            // PERF(port): @branchHint(.unlikely)
             return Err(Error::RelocationError);
         }
         Ok(())
@@ -516,7 +473,7 @@ impl State {
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn list_symbols(&mut self, ctx: *mut c_void, symbol_cb: Option<SymbolCallback>) {
         // SAFETY: SymbolCallback is ABI-identical to the extern's callback type
-        // (`*const Symbol` vs `*const c_void` in the last param); mirrors Zig's implicit ptrcast.
+        // (`*const Symbol` vs `*const c_void` in the last param).
         let erased = symbol_cb.map(|f| unsafe {
             bun_ptr::cast_fn_ptr::<
                 SymbolCallback,
@@ -527,5 +484,3 @@ impl State {
         unsafe { tcc_list_symbols(self, ctx, erased) }
     }
 }
-
-// ported from: src/tcc_sys/tcc.zig
diff --git a/src/threading/Condition.rs b/src/threading/Condition.rs
index 751c1165b78..a8c7006a192 100644
--- a/src/threading/Condition.rs
+++ b/src/threading/Condition.rs
@@ -1,5 +1,4 @@
-//! Copy of std.Thread.Condition, but uses Bun's Mutex and Futex.
-//! Synchronized with std as of Zig 0.14.1.
+//! Condition variable built on Bun's Mutex and Futex.
 //!
 //! Condition variables are used with a Mutex to efficiently wait for an arbitrary condition to occur.
 //! It does this by atomically unlocking the mutex, blocking the thread until notified, and finally re-locking the mutex.
@@ -58,7 +57,6 @@ use crate::guarded::GuardedLock;
 
 #[derive(Default)]
 pub struct Condition {
-    // PORT NOTE: Zig field name `impl` is a Rust keyword; renamed to `impl_`.
     impl_: Impl,
 }
 
@@ -79,7 +77,7 @@ impl From<TimeoutError> for bun_core::Error {
 }
 
 impl Condition {
-    /// Const-init an empty condition variable (Zig: `.{}`). Required for
+    /// Const-init an empty condition variable. Required for
     /// `static` items — this is the `parking_lot::Condvar::new()` parity that
     /// `std::sync::Condvar` lacks.
     pub const fn new() -> Self {
@@ -142,9 +140,8 @@ impl Condition {
 
     // ── parking_lot::Condvar parity (guard-style API) ─────────────────────
     //
-    // Zig's `Condition.wait` takes a bare `*Mutex` (the caller writes
-    // `mutex.lock(); defer mutex.unlock(); cond.wait(&mutex)`). Rust callers
-    // hold a `GuardedLock<'_, T>` instead, so these overloads peel the inner
+    // The base `wait` takes a bare `&Mutex`. Callers that hold a
+    // `GuardedLock<'_, T>` instead use these overloads, which peel the inner
     // `&Mutex` out of the guard and forward. The mutex is unlocked for the
     // duration of the OS wait and re-locked before return, so the guard's
     // `Drop` (which unlocks once) remains balanced.
@@ -185,9 +182,9 @@ type Impl = WindowsImpl;
 #[cfg(not(windows))]
 type Impl = FutexImpl;
 
-// PORT NOTE: Zig passed `comptime notify: Notify`. Stable Rust forbids enum
-// const-generic params (`adt_const_params`), so `wake()` takes it at runtime;
-// the two-variant match optimizes equivalently.
+// Stable Rust forbids enum const-generic params (`adt_const_params`), so
+// `wake()` takes the notify mode at runtime; the two-variant match optimizes
+// equivalently.
 #[derive(PartialEq, Eq, Clone, Copy)]
 enum Notify {
     One, // wake up only one thread
@@ -257,7 +254,6 @@ mod windows_impl {
             #[cfg(debug_assertions)]
             {
                 // The internal state of the DebugMutex needs to be handled here as well.
-                // TODO(port): Mutex internals — Zig: mutex.impl.locking_thread.store(0, .unordered)
                 mutex.impl_.locking_thread.store(0, Ordering::Relaxed);
             }
             // SAFETY: `condition` and `srwlock` are UnsafeCell-wrapped OS sync primitives;
@@ -266,7 +262,7 @@ mod windows_impl {
             let rc = unsafe {
                 kernel32::SleepConditionVariableSRW(
                     self.condition.get(),
-                    // TODO(port): Mutex internals — debug build wraps an inner impl with `srwlock`.
+                    // The debug build's DebugMutex wraps an inner impl holding `srwlock`.
                     #[cfg(debug_assertions)]
                     {
                         mutex.impl_.impl_.srwlock.get()
@@ -349,7 +345,7 @@ impl FutexImpl {
         state += Self::ONE_WAITER;
 
         mutex.unlock();
-        // PORT NOTE: Zig `defer mutex.lock()` — re-acquire on every exit path (Ok and Err).
+        // Re-acquire on every exit path (Ok and Err).
         // Condvar wait semantics (unlock, block, re-lock) are the inverse of MutexGuard,
         // so the re-lock is expressed as a one-off defer rather than an RAII guard type.
         scopeguard::defer! { mutex.lock(); }
@@ -462,5 +458,3 @@ impl FutexImpl {
         }
     }
 }
-
-// ported from: src/threading/Condition.zig
diff --git a/src/threading/Futex.rs b/src/threading/Futex.rs
index 556381d24c6..1099b70df40 100644
--- a/src/threading/Futex.rs
+++ b/src/threading/Futex.rs
@@ -1,6 +1,3 @@
-//! This is a copy-pasta of std.Thread.Futex, except without `unreachable`
-//! Synchronized with std as of Zig 0.14.1
-//!
 //! A mechanism used to block (`wait`) and unblock (`wake`) threads using a
 //! 32bit memory address as hints.
 //!
@@ -76,8 +73,8 @@ pub fn wake(ptr: &AtomicU32, max_waiters: u32) {
 use darwin_impl as imp;
 #[cfg(target_os = "freebsd")]
 use freebsd_impl as imp;
-// PORT NOTE: Zig's `builtin.os.tag == .linux` covers Android (Android uses the .linux OS tag with
-// the android ABI). Rust splits these into distinct target_os values, so we must list both.
+// Android is the same Linux kernel; Rust splits it into a distinct target_os
+// value, so we must list both.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use linux_impl as imp;
 #[cfg(not(any(
@@ -120,8 +117,8 @@ mod unsupported_impl {
     }
 
     fn unsupported() -> ! {
-        // PORT NOTE: Zig used @compileError here; Rust cfg already gates this module,
-        // so reaching this at runtime means the cfg ladder above is incomplete.
+        // The cfg ladder above already gates this module, so reaching this at
+        // runtime means the ladder is incomplete.
         unreachable!("Unsupported operating system for Futex");
     }
 }
@@ -346,7 +343,6 @@ mod linux_impl {
             linux::E::INVAL => Ok(()), // possibly timeout overflow
             linux::E::FAULT => panic!("futex_wait() returned EFAULT unexpectedly"), // ptr was invalid
             err => {
-                // TODO(port): bun.Output.panic — using core panic! for now.
                 panic!(
                     "Unexpected futex_wait() return code: {} - {}",
                     rc,
@@ -519,9 +515,8 @@ impl Deadline {
     /// Create the deadline to expire after the given amount of time in nanoseconds passes.
     /// Pass in `null` to have the deadline call `Futex.wait()` and never expire.
     pub(crate) fn init(expires_in_ns: Option<u64>) -> Deadline {
-        // std.time.Timer is required to be supported for somewhat accurate reportings of error.Timeout.
-        // PORT NOTE: Zig only initialized `started` when timeout != null; Instant::now() is
-        // infallible and cheap, so we always initialize it to avoid MaybeUninit gymnastics.
+        // `Instant::now()` is infallible and cheap, so always initialize
+        // `started` (even when timeout is None) to avoid MaybeUninit gymnastics.
         Deadline {
             timeout: expires_in_ns,
             started: std::time::Instant::now(),
@@ -550,5 +545,3 @@ impl Deadline {
         wait(ptr, expect, Some(until_timeout_ns))
     }
 }
-
-// ported from: src/threading/Futex.zig
diff --git a/src/threading/Mutex.rs b/src/threading/Mutex.rs
index 47eaf25f89f..4fbb1699a3d 100644
--- a/src/threading/Mutex.rs
+++ b/src/threading/Mutex.rs
@@ -1,7 +1,6 @@
 //! This is a copy-pasta of std.Thread.Mutex with some changes.
 //! - No assert with unreachable
 //! - uses bun.Futex instead of std.Thread.Futex
-//! Synchronized with std as of Zig 0.14.1
 //!
 //! Mutex is a synchronization primitive which enforces atomic access to a shared region of code known as the "critical section".
 //! It does this by blocking ensuring only one thread is in the critical section at any given point in time by blocking the others.
@@ -37,12 +36,12 @@ use crate::Futex;
 #[derive(Default)]
 pub struct Mutex {
     // `pub(crate)` so `Condition` can reach `srwlock` / `locking_thread` for
-    // `SleepConditionVariableSRW` (mirrors Zig's same-module field access).
+    // `SleepConditionVariableSRW`.
     pub(crate) impl_: Impl,
 }
 
 impl Mutex {
-    /// Const-init an unlocked mutex (Zig: `.{}`). Required for `static` items.
+    /// Const-init an unlocked mutex. Required for `static` items.
     pub const fn new() -> Self {
         Self { impl_: Impl::new() }
     }
@@ -86,15 +85,13 @@ impl Mutex {
 
     /// Acquires the mutex and returns an RAII guard that releases it on `Drop`.
     ///
-    /// This is the idiomatic Rust spelling of Zig's `m.lock(); defer m.unlock();`
-    /// — prefer it over a bare [`lock`]/[`unlock`] pair so the critical section
+    /// Prefer this over a bare [`lock`]/[`unlock`] pair so the critical section
     /// is released on every return path (including `?`).
     ///
     /// The returned [`MutexGuard`] holds the mutex by raw pointer rather than a
     /// borrowed `&'a Mutex`, so holding the guard does **not** keep a borrow of
-    /// the owning struct alive. This matches the Zig pattern where the mutex is
-    /// a plain field and the rest of `self` remains freely accessible while
-    /// locked. Caller must ensure the `Mutex` outlives the guard (trivially
+    /// the owning struct alive: the rest of `self` remains freely accessible
+    /// while locked. Caller must ensure the `Mutex` outlives the guard (trivially
     /// true for `'static`/singleton mutexes and for guards that drop before the
     /// owning `self` does).
     #[inline]
@@ -130,8 +127,6 @@ impl Drop for MutexGuard {
     }
 }
 
-// Zig: `pub const deinit = void;` — no-op; Drop is implicit and there is nothing to free.
-
 #[cfg(debug_assertions)]
 type Impl = DebugImpl;
 #[cfg(not(debug_assertions))]
@@ -173,7 +168,6 @@ impl DebugImpl {
     fn try_lock(&self) -> bool {
         let locking = self.impl_.try_lock();
         if locking {
-            // PORT NOTE: Zig uses .unordered; Rust's weakest is Relaxed.
             self.locking_thread
                 .store(current_thread_id(), Ordering::Relaxed);
         }
@@ -274,7 +268,7 @@ pub(crate) struct OsUnfairLock {
     _opaque: u32,
 }
 
-// TODO(port): move to bun_sys (darwin libc externs)
+// Darwin libc externs.
 // `&UnsafeCell<OsUnfairLock>` is ABI-identical to `os_unfair_lock_t` (thin
 // non-null pointer to a `#[repr(C)]` u32; `UnsafeCell` is `#[repr(transparent)]`).
 // The type encodes the only pointer-validity precondition, and Apple's runtime
@@ -340,8 +334,8 @@ impl FutexImpl {
         #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
         {
             let locked_bit: u32 = Self::LOCKED.trailing_zeros();
-            // PERF(port): Zig emits `lock bts` via atomic bitSet; fetch_or is the closest stable
-            // Rust atomic — profile if it shows up on a hot path and consider inline asm if needed.
+            // PERF: a `lock bts` would be tighter; fetch_or is the closest stable Rust
+            // atomic — profile if it shows up on a hot path and consider inline asm if needed.
             return (self.state.fetch_or(1 << locked_bit, Ordering::Acquire) & (1 << locked_bit))
                 == 0;
         }
@@ -416,5 +410,3 @@ pub(crate) unsafe extern "C" fn Bun__unlock(ptr: *mut ReleaseImpl) {
 
 #[unsafe(no_mangle)]
 pub(crate) static Bun__lock__size: usize = core::mem::size_of::<ReleaseImpl>();
-
-// ported from: src/threading/Mutex.zig
diff --git a/src/threading/ResetEvent.rs b/src/threading/ResetEvent.rs
index 32fc1f9f35d..404acb5aa4b 100644
--- a/src/threading/ResetEvent.rs
+++ b/src/threading/ResetEvent.rs
@@ -1,5 +1,3 @@
-//! Port of `std.Thread.ResetEvent` (Zig 0.14.1) on top of Bun's `Futex`.
-//!
 //! A `ResetEvent` is a thread-safe bool that threads can block on until it
 //! becomes "set". Statically initializable, at most `size_of::<u32>()` of
 //! state. Replaces the hand-rolled `Mutex<bool> + Condvar` shim in
@@ -28,7 +26,7 @@ const WAITING: u32 = 1;
 const IS_SET: u32 = 2;
 
 impl ResetEvent {
-    /// Const-init in the unset state (Zig: `.{}`).
+    /// Const-init in the unset state.
     pub const fn new() -> Self {
         Self {
             state: AtomicU32::new(UNSET),
@@ -130,5 +128,3 @@ impl ResetEvent {
         self.state.store(UNSET, Ordering::Relaxed);
     }
 }
-
-// ported from: vendor/zig/lib/std/Thread/ResetEvent.zig (FutexImpl)
diff --git a/src/threading/RwLock.rs b/src/threading/RwLock.rs
index 8c6b6fcaff2..d5022c0537a 100644
--- a/src/threading/RwLock.rs
+++ b/src/threading/RwLock.rs
@@ -1,22 +1,20 @@
 //! A lock that supports one writer or many readers.
 //!
-//! Port of `std.Thread.RwLock.DefaultRwLock` (Zig 0.14.1) on top of Bun's
-//! `Mutex` + `Semaphore`, wrapped in a data-owning `RwLock<T>` with RAII
+//! Built on top of Bun's `Mutex` + `Semaphore`, wrapped in a data-owning `RwLock<T>` with RAII
 //! guards so it drops in for `parking_lot::RwLock<T>`:
 //!
 //! - `const fn new(T)` — usable in `static`.
 //! - `.read()` / `.write()` return guards with `Deref` / `DerefMut`.
 //! - `.try_read()` / `.try_write()` return `Option<guard>`.
-//! - No poisoning (Zig has none; matches `parking_lot`).
+//! - No poisoning (matches `parking_lot`).
 //!
 //! Writer-preferring: a pending writer blocks new readers from acquiring on
 //! the CAS fast path (they fall through to the mutex, which the writer holds).
 //! Fairness beyond that is whatever the underlying `Mutex`/Futex provides.
 //!
-//! The `PthreadRwLock` and `SingleThreadedRwLock` variants from Zig std are
-//! intentionally omitted — Bun never builds single-threaded, and the
-//! `DefaultRwLock` algorithm is portable across all Bun targets while keeping
-//! `const fn new` (which `pthread_rwlock_t` cannot guarantee).
+//! `pthread_rwlock_t` is intentionally not used — this algorithm is portable
+//! across all Bun targets while keeping `const fn new` (which
+//! `pthread_rwlock_t` cannot guarantee).
 
 use core::cell::UnsafeCell;
 use core::marker::PhantomData;
@@ -25,7 +23,7 @@ use core::sync::atomic::{AtomicUsize, Ordering};
 
 use crate::{Mutex, Semaphore};
 
-// ── raw state machine (Zig: `DefaultRwLock`) ──────────────────────────────
+// ── raw state machine ──────────────────────────────────────────────────────
 
 struct RawRwLock {
     state: AtomicUsize,
@@ -33,7 +31,7 @@ struct RawRwLock {
     semaphore: Semaphore,
 }
 
-// Bit layout of `state` (matches Zig exactly):
+// Bit layout of `state`:
 //
 //   bit 0                : IS_WRITING — a writer holds the lock
 //   bits 1..=COUNT_BITS  : pending-writer count (WRITER_MASK)
@@ -77,8 +75,8 @@ impl RawRwLock {
         let _ = self.state.fetch_add(WRITER, Ordering::SeqCst);
         self.mutex.lock();
 
-        // Zig: `IS_WRITING -% WRITER` — wrapping sub so the single fetch_add
-        // both sets IS_WRITING and clears the pending-writer reservation.
+        // Wrapping sub so the single fetch_add both sets IS_WRITING and clears
+        // the pending-writer reservation.
         let state = self
             .state
             .fetch_add(IS_WRITING.wrapping_sub(WRITER), Ordering::SeqCst);
@@ -95,7 +93,6 @@ impl RawRwLock {
     fn try_lock_shared(&self) -> bool {
         let state = self.state.load(Ordering::SeqCst);
         if state & (IS_WRITING | WRITER_MASK) == 0 {
-            // Zig: `@cmpxchgStrong(...) orelse return true`
             if self
                 .state
                 .compare_exchange(state, state + READER, Ordering::SeqCst, Ordering::SeqCst)
@@ -117,7 +114,6 @@ impl RawRwLock {
     fn lock_shared(&self) {
         let mut state = self.state.load(Ordering::SeqCst);
         while state & (IS_WRITING | WRITER_MASK) == 0 {
-            // Zig: `@cmpxchgWeak(...) orelse return`
             match self.state.compare_exchange_weak(
                 state,
                 state + READER,
@@ -339,13 +335,10 @@ mod tests {
 
     #[test]
     fn raw_internal_state() {
-        // Zig: "DefaultRwLock - internal state" — regression for ziglang #13163,
-        // where the WRITER flag was subtracted instead of cleared by lock().
+        // Regression test: the WRITER flag must be cleared (not subtracted) by lock().
         let raw = RawRwLock::new();
         raw.lock();
         raw.unlock();
         assert_eq!(raw.state.load(Ordering::SeqCst), 0);
     }
 }
-
-// ported from: vendor/zig/lib/std/Thread/RwLock.zig (DefaultRwLock)
diff --git a/src/threading/Semaphore.rs b/src/threading/Semaphore.rs
index 01c4fe63507..02ca371b318 100644
--- a/src/threading/Semaphore.rs
+++ b/src/threading/Semaphore.rs
@@ -1,6 +1,5 @@
-//! Port of `std.Thread.Semaphore` (Zig 0.14.1) on top of Bun's `Mutex` +
-//! `Condition`. A semaphore is an unsigned integer that blocks the calling
-//! thread when it would go negative.
+//! A semaphore on top of Bun's `Mutex` + `Condition`: an unsigned integer
+//! that blocks the calling thread when it would go negative.
 //!
 //! Supports `const fn new()` static initialization and needs no `deinit`.
 //! Only the subset Bun uses is ported (`wait`/`post`); `timedWait` is omitted
@@ -31,12 +30,12 @@ impl Default for Semaphore {
 }
 
 impl Semaphore {
-    /// Const-init with zero permits (Zig: `.{}`).
+    /// Const-init with zero permits.
     pub const fn new() -> Self {
         Self::with_permits(0)
     }
 
-    /// Const-init with `permits` available (Zig: `.{ .permits = n }`).
+    /// Const-init with `permits` available.
     pub const fn with_permits(permits: usize) -> Self {
         Self {
             mutex: Mutex::new(),
@@ -48,7 +47,6 @@ impl Semaphore {
     /// Blocks until a permit is available, then consumes one.
     pub fn wait(&self) {
         self.mutex.lock();
-        // Zig: `defer sem.mutex.unlock()`
         scopeguard::defer! { self.mutex.unlock(); }
 
         // SAFETY: `mutex` is held for every access to `permits` below.
@@ -74,5 +72,3 @@ impl Semaphore {
         self.cond.signal();
     }
 }
-
-// ported from: vendor/zig/lib/std/Thread/Semaphore.zig
diff --git a/src/threading/ThreadPool.rs b/src/threading/ThreadPool.rs
index 3f9dfbfc41f..bc4919b28d5 100644
--- a/src/threading/ThreadPool.rs
+++ b/src/threading/ThreadPool.rs
@@ -60,8 +60,7 @@ struct PoolStats {
     last_dump_ns: AtomicU64,
 }
 
-// PORT NOTE: Zig's `packed struct(u32)` named `Sync` is kept as `Sync` here for
-// diffability with the .zig. It shadows `core::marker::Sync` within this module;
+// `Sync` shadows `core::marker::Sync` within this module;
 // no `T: Sync` bounds are written in this file.
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -83,7 +82,7 @@ enum SyncState {
 }
 
 impl Sync {
-    // Bit layout (LSB-first, matching Zig packed struct field order):
+    // Bit layout (LSB-first):
     //   idle:     u14  bits 0..14
     //   spawned:  u14  bits 14..28
     //   unused:   bool bit  28
@@ -156,7 +155,7 @@ impl AtomicSync {
     fn load(&self, order: Ordering) -> Sync {
         Sync(self.0.load(order))
     }
-    /// Returns `None` on success, `Some(current)` on failure (matches Zig `cmpxchgWeak`).
+    /// Returns `None` on success, `Some(current)` on failure.
     #[inline]
     fn cmpxchg_weak(
         &self,
@@ -305,8 +304,8 @@ impl ThreadPool {
 }
 
 impl Default for ThreadPool {
-    /// Zig: `var instance: ThreadPool = .{};` — default-initialised pool with
-    /// zero `max_threads` (`init()` clamps to ≥1 when actually started).
+    /// Default-initialised pool with zero `max_threads` (`init()` clamps to
+    /// ≥1 when actually started).
     fn default() -> Self {
         Self::init(Config::default())
     }
@@ -317,7 +316,6 @@ impl Drop for ThreadPool {
     fn drop(&mut self) {
         self.shutdown();
         self.join();
-        // Zig: `self.* = undefined;` — no-op in Rust.
     }
 }
 
@@ -333,15 +331,13 @@ pub struct Task {
 // the intrusive `node.next` raw pointer is only dereferenced under the pool's
 // internal synchronization (lock-free `Node.Queue` / `Node.Buffer` below). The
 // auto-trait opt-out is purely from the raw `*mut Node`, not a real !Send
-// invariant. (Zig had no auto-trait notion; this matches `ThreadPool.zig`'s
-// cross-thread `*Task` usage.)
+// invariant.
 unsafe impl Send for Task {}
 
 impl Default for Task {
     /// Placeholder for fields where the callback is installed later
     /// (e.g. by [`crate::work_pool::WorkPool::schedule_owned`]). The
-    /// `unreachable` callback panics if scheduled un-initialized — same
-    /// failure mode as Zig's `.callback = undefined`.
+    /// `unreachable` callback panics if scheduled un-initialized.
     #[inline]
     fn default() -> Self {
         // Body has no unsafe op; a safe fn item coerces to the `callback`
@@ -385,8 +381,7 @@ pub struct Batch {
 
 impl Batch {
     pub fn pop(&mut self) -> Option<NonNull<Task>> {
-        // SAFETY: `len` is only read here for the fast-path zero check; the
-        // atomic load mirrors Zig's `@atomicLoad(usize, &this.len, .monotonic)`.
+        // SAFETY: `len` is only read here for the fast-path zero check.
         let len = unsafe { (*(&raw const self.len).cast::<AtomicUsize>()).load(Ordering::Relaxed) };
         if len == 0 {
             return None;
@@ -442,8 +437,7 @@ impl Batch {
     }
 }
 
-/// Dispatch trait for `each_impl`: erases the by-value vs by-pointer comptime
-/// branch from Zig's `eachImpl(..., comptime as_ptr: bool)` into two impls.
+/// Dispatch trait for `each_impl`: the by-value vs by-pointer branch as two impls.
 trait EachCall<Ctx, V>: core::marker::Sync {
     /// SAFETY: `value` must point to a live `V` exclusively owned by this call.
     unsafe fn call(&self, ctx: &Ctx, value: *mut V, i: usize);
@@ -481,10 +475,9 @@ impl ThreadPool {
     /// `V: Send` is required because each `values[i]` is handed (by copy or by
     /// `*mut V`) to an arbitrary worker thread; the raw-pointer round-trip
     /// through the intrusive `Task` callback would otherwise smuggle `!Send`
-    /// data across threads with no compiler check (Zig's `anytype` had none).
+    /// data across threads with no compiler check.
     pub fn each<Ctx, V, F>(&self, ctx: Ctx, run_fn: F, values: &mut [V])
     where
-        // TODO(port): narrow bounds — Zig used `anytype` + comptime fn
         F: Fn(&Ctx, V, usize) + core::marker::Sync,
         Ctx: core::marker::Sync,
         V: Copy + core::marker::Sync + core::marker::Send,
@@ -531,9 +524,8 @@ impl ThreadPool {
             i: usize,
         }
 
-        // PORT NOTE: `run_fn` was `comptime` in Zig (monomorphized into `call`).
-        // Here it is stored in WaitContext and dispatched via the `EachCall` trait,
-        // which encodes the `comptime as_ptr` branch (ByValue vs ByPtr).
+        // `run_fn` is stored in WaitContext and dispatched via the `EachCall`
+        // trait (ByValue vs ByPtr).
         unsafe fn call<Ctx, V, F: EachCall<Ctx, V>>(task: *mut Task) {
             // SAFETY: task points to RunnerTask.task (offset 0, repr(C)).
             let runner_task =
@@ -553,7 +545,6 @@ impl ThreadPool {
             run_fn,
         };
 
-        // PERF(port): was allocator.alloc(RunnerTask, values.len) — using Vec; profile if hot.
         let mut tasks: Vec<RunnerTask<Ctx, V, F>> = Vec::with_capacity(values.len());
         let mut batch = Batch::default();
         let mut offset = values.len();
@@ -569,9 +560,8 @@ impl ThreadPool {
                 ctx: bun_ptr::BackRef::new(&wait_context),
             });
         }
-        // PORT NOTE: reshaped for borrowck — Zig wrote into pre-allocated slots and
-        // pushed in the same loop. Here we push to Vec first (no realloc: capacity
-        // reserved) then take stable addresses.
+        // Push to the Vec first (no realloc: capacity reserved), then take
+        // stable addresses.
         for runner_task in tasks.iter_mut() {
             batch.push(Batch::from(ptr::addr_of_mut!(runner_task.task)));
         }
@@ -606,9 +596,8 @@ impl ThreadPool {
         if self.is_running.load(Ordering::Relaxed) {
             self.wait_group.add(len);
         } else {
-            // PERF(port): Zig used `add_unsynchronized` (non-atomic `+=`) when the
-            // pool isn't running yet. `&self` precludes `&mut WaitGroup` here, so
-            // fall back to the relaxed atomic add — semantically identical.
+            // `&self` precludes `&mut WaitGroup` here, so use the relaxed
+            // atomic add even though the pool isn't running yet.
             self.wait_group.add(len);
         }
 
@@ -693,19 +682,16 @@ pub const DEFAULT_THREAD_STACK_SIZE: u32 = {
     const DEFAULT: u32 = 4 * 1024 * 1024;
     #[cfg(windows)]
     {
-        // PORT NOTE: Zig's `std.Thread.spawn` on Windows calls `CreateThread`
-        // with `dwCreationFlags = 0`, so `dwStackSize` sets the *commit* size
-        // and the thread inherits the executable's *reserve* size from the PE
-        // header (`/STACK:0x1200000` = 18 MB — see scripts/build/flags.ts).
-        // Rust's `std::thread::Builder::stack_size` instead passes
-        // `STACK_SIZE_PARAM_IS_A_RESERVATION`, so the value here *is* the
-        // reserve. Passing 4 MB therefore gave Rust worker threads 4 MB of
-        // stack vs Zig's 18 MB, and the deeply-nested-AST stress tests
-        // (`lots-of-for-loop.js`, 15k nested `for`) overflow on the 4 MB
+        // `std::thread::Builder::stack_size` passes
+        // `STACK_SIZE_PARAM_IS_A_RESERVATION` to `CreateThread`, so the value
+        // here is the *reserve* size, not the commit size. A 4 MB reserve is
+        // not enough: the deeply-nested-AST stress tests
+        // (`lots-of-for-loop.js`, 15k nested `for`) overflow on a 4 MB
         // worker stack before the parser's `StackCheck` can fire (each
         // `parse_stmt`→`t_for` cycle is small enough that 15k levels fit, but
-        // the visit/print passes that follow do not). Match Zig parity by
-        // reserving the same 18 MB the PE header would have given us.
+        // the visit/print passes that follow do not). Reserve the same 18 MB
+        // the PE header gives the main thread (`/STACK:0x1200000` — see
+        // scripts/build/flags.ts).
         let _ = DEFAULT;
         0x1200000
     }
@@ -715,7 +701,8 @@ pub const DEFAULT_THREAD_STACK_SIZE: u32 = {
     }
     #[cfg(target_os = "macos")]
     {
-        // TODO(port): Zig used `std.heap.page_size_max`; using 16384 (arm64 macOS).
+        // 16384 is the page size on arm64
+        // macOS and a safe multiple of the 4096-byte x64 page size.
         const PAGE_SIZE_MAX: u32 = 16384;
         let size = DEFAULT - (DEFAULT % PAGE_SIZE_MAX);
         // stack size must be a multiple of page_size
@@ -739,7 +726,7 @@ impl ThreadPool {
     /// Warm the thread pool up to the given number of threads.
     /// https://www.youtube.com/watch?v=ys3qcbO5KWw
     pub fn warm(&self, count: u16) {
-        // PORT NOTE: Zig used u14; Rust has no u14, using u16 and truncating to 14 bits.
+        // Thread counts are 14-bit fields in `Sync`; truncate to 14 bits.
         self.is_running.store(true, Ordering::Relaxed);
         let target = count.min((self.max_threads & 0x3FFF) as u16);
         let mut sync = self.sync.load(Ordering::Relaxed);
@@ -762,7 +749,7 @@ impl ThreadPool {
                 .spawn(move || Thread::run(pool))
             {
                 Ok(_handle) => {
-                    // Dropping JoinHandle detaches the thread (matches Zig `thread.detach()`).
+                    // Dropping JoinHandle detaches the thread.
                 }
                 Err(_) => {
                     // SAFETY: `&self` keeps the pool live; `null` thread makes
@@ -1048,12 +1035,12 @@ enum WaitError {
     Shutdown,
 }
 
-// `repr(C)` pins field order to match the Zig layout: the work-steal loop in
+// `repr(C)` pins field order: the work-steal loop in
 // `Thread::pop` chases `(*target).next`, and keeping `next`/`target` at offsets
 // 0/8 means that load hits the same cache line that already holds the
 // `run_queue` header it reads immediately after. With the default `repr(Rust)`
 // the compiler is free to reorder fields (the 4-byte `Event` invites it),
-// which profiled ~43% hotter on the steal traversal vs the Zig build.
+// which profiled ~43% hotter on the steal traversal.
 #[repr(C)]
 pub struct Thread {
     next: *mut Thread,
@@ -1071,7 +1058,7 @@ thread_local! {
 
 /// RAII scope for a worker thread's active lifetime: publishes `thread` as
 /// `CURRENT` and registers it with `pool` on construction; on drop, unregisters
-/// from the pool and clears `CURRENT` (matching the Zig `defer` order).
+/// from the pool and clears `CURRENT`.
 ///
 /// `pool` is a [`BackRef`]: the pool's `join()` blocks on every registered
 /// worker, so it strictly outlives this guard.
@@ -1164,7 +1151,7 @@ impl Thread {
         {
             let mut counter_buf = [0u8; 100];
             let int = COUNTER.fetch_add(1, Ordering::SeqCst);
-            // PORT NOTE: Zig used bufPrintZ; format into the buffer, track written
+            // Format into the buffer, track written
             // length via the advancing &mut [u8] cursor, then NUL-terminate.
             use std::io::Write;
             let len = {
@@ -1426,7 +1413,7 @@ impl Event {
             // who will either exit on SHUTDOWN or acquire with WAITING again, ensuring all threads are awoken.
             // This unfortunately results in the last notify() or shutdown() doing an extra futex wake but that's fine.
             let timeout_ns: Option<u64> = if !has_shrunk_memory {
-                Some(10_000_000_000) // std.time.ns_per_s * 10
+                Some(10_000_000_000) // 10 seconds
             } else {
                 None
             };
@@ -1492,7 +1479,7 @@ pub mod node {
     /// An unbounded multi-producer-(non blocking)-multi-consumer queue of Node pointers.
     pub(crate) struct Queue {
         stack: AtomicUsize,
-        // PORT NOTE: Zig's plain `?*Node` is mutated through `&self` while
+        // `cache` is only mutated through `&self` while
         // `IS_CONSUMING` is held. `Cell` gives interior mutability without an
         // atomic — the `stack` Acquire/Release barriers order accesses, and the
         // `unsafe impl Sync` below is where that synchronization promise lives.
@@ -1616,7 +1603,7 @@ pub mod node {
     }
 
     /// RAII handle for the `IS_CONSUMING` bit on a [`Queue`]. Owns the local
-    /// cache pointer (Zig's `var consumer: ?*Node`) directly so the hot
+    /// cache pointer directly so the hot
     /// `pop()` fast path is a plain field read/write that LLVM can keep in a
     /// register — the previous `scopeguard::guard` + `&mut *consumer` pattern
     /// forced the cache pointer through a stack slot via `DerefMut` on every
@@ -1680,8 +1667,8 @@ pub mod node {
 
     /// A bounded single-producer, multi-consumer ring buffer for node pointers.
     // `repr(C)` keeps `head`/`tail` in the first cache line ahead of the 2 KB
-    // `array`, matching the Zig layout the steal/consume fast paths were tuned
-    // against. `repr(Rust)` is free to reorder these.
+    // `array`; the steal/consume fast paths were tuned against this layout.
+    // `repr(Rust)` is free to reorder these.
     #[repr(C)]
     pub(crate) struct Buffer {
         head: AtomicU32,
@@ -1701,7 +1688,6 @@ pub mod node {
             Buffer {
                 head: AtomicU32::new(0),
                 tail: AtomicU32::new(0),
-                // PORT NOTE: Zig left this `undefined`; we zero-init.
                 array: [const { AtomicPtr::new(ptr::null_mut()) }; CAPACITY],
             }
         }
@@ -1713,9 +1699,8 @@ pub mod node {
     }
 
     impl Buffer {
-        // PORT NOTE: Zig's `.raw` field access (non-atomic) on Atomic(T) is mapped to
-        // Relaxed loads here; Rust does not expose unsynchronized access on atomics.
-        // PERF(port): was non-atomic raw read — profile if hot.
+        // Relaxed loads; Rust does not expose unsynchronized access on
+        // atomics. PERF: profile if hot.
         #[inline]
         fn tail_raw(&self) -> Index {
             self.tail.load(Ordering::Relaxed)
@@ -1745,7 +1730,6 @@ pub mod node {
                         nodes = unsafe { (*node).next };
 
                         // Array written atomically with weakest ordering since it could be getting atomically read by steal().
-                        // PORT NOTE: Zig .unordered → Relaxed (Rust has no Unordered).
                         self.array[(tail as usize) % CAPACITY].store(node, Ordering::Relaxed);
                         tail = tail.wrapping_add(1);
                         size += 1;
@@ -1854,7 +1838,6 @@ pub mod node {
                 let Some(node) = consumer.pop() else {
                     break;
                 };
-                // PORT NOTE: Zig .unordered → Relaxed (same `mov` on x86).
                 self.array[(tail.wrapping_add(pushed) as usize) % CAPACITY]
                     .store(node, Ordering::Relaxed);
                 pushed += 1;
@@ -1916,7 +1899,6 @@ pub mod node {
                 // Atomically load from the target buffer array as it may be pushing and atomically storing to it.
                 // Atomic store to our array as other steal() threads may be atomically loading from it as above.
                 for i in 0..steal_size {
-                    // PORT NOTE: Zig .unordered → Relaxed.
                     let node = buffer.array[(buffer_head.wrapping_add(i) as usize) % CAPACITY]
                         .load(Ordering::Relaxed);
                     self.array[(tail.wrapping_add(i) as usize) % CAPACITY]
@@ -1958,5 +1940,3 @@ pub mod node {
         }
     }
 }
-
-// ported from: src/threading/ThreadPool.zig
diff --git a/src/threading/WaitGroup.rs b/src/threading/WaitGroup.rs
index 16b9b107a3e..584fea64aaa 100644
--- a/src/threading/WaitGroup.rs
+++ b/src/threading/WaitGroup.rs
@@ -65,8 +65,8 @@ impl WaitGroup {
 
     pub fn wait(&self) {
         self.mutex.lock();
-        // PORT NOTE: Zig `defer self.mutex.unlock()`. crate::Mutex is a raw lock/unlock
-        // wrapper (no RAII guard), so unlock is called explicitly at scope exit below.
+        // crate::Mutex is a raw lock/unlock wrapper (no RAII guard), so unlock
+        // is called explicitly at scope exit below.
 
         while self.raw_count.load(Ordering::Acquire) > 0 {
             self.cond.wait(&self.mutex);
@@ -75,5 +75,3 @@ impl WaitGroup {
         self.mutex.unlock();
     }
 }
-
-// ported from: src/threading/WaitGroup.zig
diff --git a/src/threading/channel.rs b/src/threading/channel.rs
index 84ab85ada8c..075fa622404 100644
--- a/src/threading/channel.rs
+++ b/src/threading/channel.rs
@@ -22,16 +22,11 @@ bun_core::oom_from_alloc!(ChannelError);
 
 bun_core::named_error_set!(ChannelError);
 
-// PORT NOTE: reshaped for borrowck / thread-safety. In Zig all methods take
-// `*Self` and the mutex guards `buffer`/`is_closed`. In Rust we need `&self`
-// (Channel is shared across threads), so `buffer` is wrapped in `UnsafeCell`
-// and `is_closed` in `Cell`, both accessed only while `mutex` is held.
-//
-// PORT NOTE: Zig's `comptime buffer_type: LinearFifoBufferType` const-enum
-// param is unstable in Rust (`adt_const_params`). `bun_collections::LinearFifo`
-// already lowers it to a `LinearFifoBuffer<T>` trait param, so `Channel`
-// follows the same shape: `Channel<T, B: LinearFifoBuffer<T>>`. The original
-// `init` switch becomes per-buffer inherent constructors below.
+// Channel is shared across threads through `&self`, so `buffer` is wrapped in
+// `UnsafeCell` and `is_closed` in `Cell`, both accessed only while `mutex` is
+// held. The buffer strategy is a `LinearFifoBuffer<T>` trait param
+// (`Channel<T, B: LinearFifoBuffer<T>>`) with per-buffer inherent constructors
+// below.
 pub struct Channel<T, B: LinearFifoBuffer<T> = DynamicBuffer<T>> {
     mutex: Mutex,
     putters: Condition,
@@ -48,7 +43,6 @@ unsafe impl<T: Send, B: LinearFifoBuffer<T>> Send for Channel<T, B> {}
 // SAFETY: all interior-mutable state is guarded by `mutex`.
 unsafe impl<T: Send, B: LinearFifoBuffer<T>> Sync for Channel<T, B> {}
 
-// Zig: `pub const init = switch (buffer_type) { .Static => initStatic, ... }`
 // Rust cannot dispatch a single `init` ident to different signatures based on
 // a type-level discriminant. Callers pick the matching constructor directly.
 
@@ -69,15 +63,13 @@ impl<'a, T: Copy> Channel<T, SliceBuffer<'a, T>> {
 impl<T: Copy> Channel<T, DynamicBuffer<T>> {
     #[inline]
     pub fn init_dynamic() -> Self {
-        // PORT NOTE: Zig took `std.mem.Allocator param`; dropped per
-        // §Allocators (non-AST crate uses global mimalloc).
+        // No allocator param; this non-AST crate uses the global mimalloc.
         Self::with_buffer(LinearFifo::<T, DynamicBuffer<T>>::init())
     }
 }
 
-// PORT NOTE: `T: Copy` because `LinearFifo::write`/`read` are slice-copy
-// based (mirrors Zig's `[]const T` semantics for POD payloads). All in-tree
-// channel payloads are POD; revisit if a non-`Copy` T appears.
+// `T: Copy` because `LinearFifo::write`/`read` are slice-copy based. All
+// in-tree channel payloads are POD; revisit if a non-`Copy` T appears.
 impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
     fn with_buffer(buffer: LinearFifo<T, B>) -> Self {
         Self {
@@ -89,9 +81,6 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         }
     }
 
-    // Zig `deinit` only freed `self.buffer` and poisoned `self.*`. Rust drops
-    // fields automatically, so no explicit `Drop` impl is needed.
-
     pub fn close(&self) {
         let _guard = self.mutex.lock_guard();
         if self.is_closed.get() {
@@ -102,23 +91,19 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         self.getters.broadcast();
     }
 
-    // TODO(port): narrow error set
     pub fn try_write_item(&self, item: T) -> Result<bool, ChannelError> {
         let wrote = self.write(core::slice::from_ref(&item))?;
         Ok(wrote == 1)
     }
 
-    // TODO(port): narrow error set
     pub fn write_item(&self, item: T) -> Result<(), ChannelError> {
         self.write_all(core::slice::from_ref(&item))
     }
 
-    // TODO(port): narrow error set
     pub fn write(&self, items: &[T]) -> Result<usize, ChannelError> {
         self.write_items(items, false)
     }
 
-    // TODO(port): narrow error set
     pub fn try_read_item(&self) -> Result<Option<T>, ChannelError> {
         let mut items: [MaybeUninit<T>; 1] = [MaybeUninit::uninit()];
         // SAFETY: `read` only writes initialized `T` into the first `n` slots
@@ -131,7 +116,6 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         Ok(Some(unsafe { items[0].assume_init_read() }))
     }
 
-    // TODO(port): narrow error set
     pub fn read_item(&self) -> Result<T, ChannelError> {
         let mut items: [MaybeUninit<T>; 1] = [MaybeUninit::uninit()];
         // SAFETY: see try_read_item.
@@ -141,26 +125,22 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         Ok(unsafe { items[0].assume_init_read() })
     }
 
-    // TODO(port): narrow error set
     pub fn read(&self, items: &mut [T]) -> Result<usize, ChannelError> {
         self.read_items(items, false)
     }
 
-    // TODO(port): narrow error set
     pub fn write_all(&self, items: &[T]) -> Result<(), ChannelError> {
         let n = self.write_items(items, true)?;
         debug_assert!(n == items.len());
         Ok(())
     }
 
-    // TODO(port): narrow error set
     pub fn read_all(&self, items: &mut [T]) -> Result<(), ChannelError> {
         let n = self.read_items(items, true)?;
         debug_assert!(n == items.len());
         Ok(())
     }
 
-    // TODO(port): narrow error set
     fn write_items(&self, items: &[T], should_block: bool) -> Result<usize, ChannelError> {
         let _guard = self.mutex.lock_guard();
 
@@ -204,7 +184,6 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         Ok(pushed)
     }
 
-    // TODO(port): narrow error set
     fn read_items(&self, items: &mut [T], should_block: bool) -> Result<usize, ChannelError> {
         let _guard = self.mutex.lock_guard();
 
@@ -241,5 +220,3 @@ impl<T: Copy, B: LinearFifoBuffer<T>> Channel<T, B> {
         Ok(popped)
     }
 }
-
-// ported from: src/threading/channel.zig
diff --git a/src/threading/guarded.rs b/src/threading/guarded.rs
index caae56ac7ee..180b4936ada 100644
--- a/src/threading/guarded.rs
+++ b/src/threading/guarded.rs
@@ -106,12 +106,8 @@ impl<Value, M: RawMutex> GuardedBy<Value, M> {
     }
 }
 
-// Zig `deinit` only calls `bun.memory.deinit` on both fields and writes `undefined`.
-// Rust drops `Value` and `M` fields automatically — no explicit `Drop` impl needed.
-
 /// RAII guard returned by [`GuardedBy::lock`]. Dereferences to the protected value and releases
-/// the underlying mutex when dropped — the Rust-native replacement for Zig's split
-/// `lock()`/`defer unlock()` pair.
+/// the underlying mutex when dropped.
 pub struct GuardedLock<'a, Value, M: RawMutex> {
     guarded: &'a GuardedBy<Value, M>,
 }
@@ -156,8 +152,6 @@ impl<'a, Value, M: RawMutex> Drop for GuardedLock<'a, Value, M> {
 }
 
 /// Trait for the `M` parameter of `GuardedBy`: a raw mutex with `lock`/`unlock`.
-// TODO(port): move to bun_threading if not already there; both `bun_threading::Mutex`
-// and `bun_safety::ThreadLock` must impl this.
 pub trait RawMutex {
     fn lock(&self);
     fn unlock(&self);
@@ -174,4 +168,13 @@ impl RawMutex for Mutex {
     }
 }
 
-// ported from: src/threading/guarded.zig
+impl RawMutex for ThreadLock {
+    #[inline]
+    fn lock(&self) {
+        ThreadLock::lock(self)
+    }
+    #[inline]
+    fn unlock(&self) {
+        ThreadLock::unlock(self)
+    }
+}
diff --git a/src/threading/lib.rs b/src/threading/lib.rs
index ea7abd9496e..4808d10f51a 100644
--- a/src/threading/lib.rs
+++ b/src/threading/lib.rs
@@ -1,4 +1,4 @@
-//! bun_threading crate root — thin re-exports mirroring `src/threading/threading.zig`.
+//! bun_threading crate root — thin re-exports.
 
 pub mod channel;
 #[path = "Condition.rs"]
@@ -27,7 +27,7 @@ pub mod wait_group;
 pub use channel::Channel;
 pub use condition::{Condition, Condvar};
 /// `Futex` re-exported as a capitalized module alias so callers can write
-/// `Futex::wait`, `Futex::wake`, `Futex::Deadline` matching the Zig namespace.
+/// `Futex::wait`, `Futex::wake`, `Futex::Deadline`.
 pub use futex as Futex;
 pub use guarded::Debug as DebugGuarded;
 pub use guarded::RawMutex;
@@ -36,28 +36,25 @@ pub use mutex::{Mutex, MutexGuard};
 pub use reset_event::ResetEvent;
 pub use rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 pub use semaphore::Semaphore;
-/// `parking_lot::Once` parity. Bun has no custom `Once` (Zig also uses
-/// `std.once` directly), and `std::sync::Once` has no poisoning concern, so
+/// `parking_lot::Once` parity. Bun has no custom `Once`,
+/// and `std::sync::Once` has no poisoning concern, so
 /// just re-export it for callers migrating off `parking_lot::Once`.
 pub use std::sync::Once;
 pub use thread_pool::ThreadPool;
 pub use unbounded_queue::{Link, Linked, UnboundedQueue};
 pub use wait_group::WaitGroup;
-/// Zig: `bun.jsc.WorkPoolTask` = `ThreadPool.Task` (work_pool.zig:2).
 pub use work_pool::Task as WorkPoolTask;
 pub use work_pool::{IntrusiveWorkTask, OwnedTask, WorkPool};
 
-/// Port of `std.Thread.getCurrentId()` — returns a non-zero OS thread id.
+/// Returns a non-zero OS thread id.
 /// Used by `Mutex` debug deadlock detection and `Condition` (Windows).
 ///
-/// Delegates to the spec-faithful tier-0 implementation in
+/// Delegates to the tier-0 implementation in
 /// [`bun_safety::thread_id::current`] (which uses `pthread_threadid_np` on
-/// Darwin / `pthread_getthreadid_np` on FreeBSD / `gettid` on Linux, matching
-/// Zig `std.Thread.getCurrentId()`), widened to `u64` so callers can store it
+/// Darwin / `pthread_getthreadid_np` on FreeBSD / `gettid` on Linux),
+/// widened to `u64` so callers can store it
 /// in an `AtomicU64` regardless of the platform's native `ThreadId` width.
 #[inline]
 pub fn current_thread_id() -> u64 {
     bun_safety::thread_id::current() as u64
 }
-
-// ported from: src/threading/threading.zig
diff --git a/src/threading/unbounded_queue.rs b/src/threading/unbounded_queue.rs
index dac26ac66a8..540fcfd4683 100644
--- a/src/threading/unbounded_queue.rs
+++ b/src/threading/unbounded_queue.rs
@@ -4,28 +4,19 @@ use core::sync::atomic::{AtomicPtr, Ordering};
 
 /// Intrusive next-pointer accessors for `UnboundedQueue<T>` nodes.
 ///
-/// Zig's `UnboundedQueue(T, next_field)` is parametric on the *field name* and
-/// uses `@field` / `@hasDecl` to branch at comptime between (a) a plain `?*T`
-/// field and (b) a packed-pointer field exposing `getPtr`/`setPtr`/
-/// `atomicLoadPtr`/`atomicStorePtr`. Rust cannot name a field generically, so
-/// both shapes collapse into this trait: implement it for each node type and
-/// route to the appropriate field.
+/// Implement this trait for each node type and route to the appropriate
+/// intrusive link field — either a plain pointer field or a packed-pointer
+/// field with atomic accessors.
 ///
 /// # Safety
 /// Implementors must guarantee that the four methods access the *same*
 /// intrusive link field, and that `atomic_*` variants are truly atomic with
 /// the given ordering. `item` is always a valid, non-null, properly aligned
 /// pointer when called by `UnboundedQueue`.
-// TODO(port): the Zig `has_custom_accessors` comptime branch is folded into
-// this trait — verify each concrete `T` picks the right impl.
 pub unsafe trait Node: Sized {
-    /// Zig: `getNext(item: *T) ?*T`
     unsafe fn get_next(item: *mut Self) -> *mut Self;
-    /// Zig: `setNext(item: *T, ptr: ?*T) void`
     unsafe fn set_next(item: *mut Self, ptr: *mut Self);
-    /// Zig: `atomicLoadNext(item: *T, ordering) ?*T`
     unsafe fn atomic_load_next(item: *mut Self, ordering: Ordering) -> *mut Self;
-    /// Zig: `atomicStoreNext(item: *T, ptr: ?*T, ordering) void`
     unsafe fn atomic_store_next(item: *mut Self, ptr: *mut Self, ordering: Ordering);
 }
 
@@ -82,8 +73,8 @@ pub unsafe trait Linked: Sized {
 // SAFETY: all four accessors route through `T::link(item)`, which by `Linked`'s
 // contract returns the same embedded `Link<Self>` field every time; `Link` is a
 // `#[repr(transparent)]` `AtomicPtr`, so atomic ops are truly atomic at the
-// requested ordering and the non-atomic get/set degrade to Relaxed (matching
-// Zig's plain `?*T` field access — never concurrent with the atomic path).
+// requested ordering and the non-atomic get/set degrade to Relaxed (never
+// concurrent with the atomic path).
 unsafe impl<T: Linked> Node for T {
     #[inline]
     unsafe fn get_next(item: *mut Self) -> *mut Self {
@@ -140,7 +131,7 @@ impl<T: Node> BatchIterator<T> {
             return ptr::null_mut();
         }
         let front = self.batch.front;
-        debug_assert!(!front.is_null()); // Zig: `orelse unreachable`
+        debug_assert!(!front.is_null());
         // SAFETY: `front` is non-null (count > 0 invariant) and points to a
         // live node previously linked into this batch by `pop_batch`.
         self.batch.front = unsafe { T::get_next(front) };
@@ -155,8 +146,8 @@ impl<T: Node> Batch<T> {
     }
 }
 
-/// Per-arch cache-half-line aligned wrapper — Zig's `align(queue_padding_length)`
-/// on `UnboundedQueue.back`/`.front`. Rust cannot express per-field alignment
+/// Per-arch cache-half-line aligned wrapper for `UnboundedQueue.back`/`.front`.
+/// Rust cannot express per-field alignment
 /// with a non-literal const, so this newtype is `#[repr(align(N))]`-cfg'd to
 /// half the target's cache-line size, keeping producer (CAS on `back`)
 /// and consumer (swap on `front`) on separate cache halves.
@@ -327,7 +318,7 @@ impl<T: Node> UnboundedQueue<T> {
         // pushed *after* `first`, because the Acquire load of `self.front` synchronizes-with
         // the Release store in push/push_batch. So we know it's reachable from `first`.
         let last = self.back.0.swap(ptr::null_mut(), Ordering::Relaxed);
-        debug_assert!(!last.is_null()); // Zig: `.?`
+        debug_assert!(!last.is_null());
         let mut next_item = first;
         while next_item != last {
             next_item = loop {
@@ -352,5 +343,3 @@ impl<T: Node> UnboundedQueue<T> {
         self.back.0.load(Ordering::Acquire).is_null()
     }
 }
-
-// ported from: src/threading/unbounded_queue.zig
diff --git a/src/threading/work_pool.rs b/src/threading/work_pool.rs
index ad57d643eee..8980a815497 100644
--- a/src/threading/work_pool.rs
+++ b/src/threading/work_pool.rs
@@ -9,8 +9,7 @@ pub struct WorkPool;
 
 /// A type that embeds an intrusive `task: Task` field. Declares the byte
 /// offset of that field once and provides the canonical container-of recovery
-/// used by every `fn(task: *mut Task)` thread-pool trampoline (the Rust
-/// equivalent of Zig's per-site `@fieldParentPtr("task", task)`).
+/// used by every `fn(task: *mut Task)` thread-pool trampoline.
 ///
 /// Implement via [`intrusive_work_task!`]; the trait carries the safety
 /// contract so call sites need only assert "scheduled via this field".
@@ -50,7 +49,7 @@ pub unsafe trait IntrusiveWorkTask: bun_core::IntrusiveField<Task> {
 /// `Send` bound).
 pub unsafe trait OwnedTask: IntrusiveWorkTask + Send + 'static {
     /// Run the task. Receives ownership of the heap allocation; dropping
-    /// `self` frees it (Zig: `bun.destroy(this)` at end of callback).
+    /// `self` frees it.
     fn run(self: Box<Self>);
 
     /// The C-ABI thread-pool callback shim. Generic over `Self`; recovers the
@@ -102,9 +101,9 @@ macro_rules! intrusive_work_task {
 /// inherent `fn run_owned(self: Box<Self>)`.
 ///
 /// The `Send` impl is part of the macro because every `OwnedTask` is *by
-/// construction* sent to a worker thread — Zig's `WorkPool.schedule` had no
-/// such bound and the per-type fields (raw `*mut EventLoop`, `*const
-/// JSGlobalObject`) are auto-`!Send` only nominally. The safety obligation
+/// construction* sent to a worker thread — the per-type fields (raw `*mut
+/// EventLoop`, `*const JSGlobalObject`) are auto-`!Send` only nominally. The
+/// safety obligation
 /// ("all fields are sound to move across threads") is restated once here
 /// rather than at every `WorkPool::schedule(addr_of_mut!((*p).task))` site.
 #[macro_export]
@@ -131,9 +130,6 @@ macro_rules! owned_task {
     };
 }
 
-// PORT NOTE: Zig used `bun.once` (a `Lock`+bool+data lazy-init pattern). Per
-// PORTING.md §Concurrency, that maps to `std::sync::OnceLock<T>` — std handles
-// the double-checked locking and gives a `&'static ThreadPool` directly.
 static POOL: OnceLock<ThreadPool> = OnceLock::new();
 
 #[cold]
@@ -165,8 +161,7 @@ impl WorkPool {
     pub fn schedule_owned<T: OwnedTask>(mut task: Box<T>) {
         // Install the monomorphized shim via the safe accessor — no raw
         // byte-offset write. `node` is left as the caller initialized it
-        // (always `Node::default()`); the Zig path never reset it at schedule
-        // time either.
+        // (always `Node::default()`).
         task.task_mut().callback = T::__callback;
         // The single into_raw for every OwnedTask scheduler call. Derive the
         // intrusive `*mut Task` *after* into_raw so provenance covers the full
@@ -185,8 +180,8 @@ impl WorkPool {
     }
 
     pub fn go<C: Send + 'static>(context: C, function: fn(C)) -> Result<(), bun_alloc::AllocError> {
-        // PERF(port): `function` was a comptime param in Zig (monomorphized into the
-        // callback); stored as a runtime field here — profile if it shows up on a hot path.
+        // PERF: `function` is stored as a runtime field rather than
+        // monomorphized into the callback — profile if it shows up on a hot path.
         #[repr(C)]
         struct TaskType<C> {
             task: Task,
@@ -217,5 +212,3 @@ impl WorkPool {
         Ok(())
     }
 }
-
-// ported from: src/threading/work_pool.zig
diff --git a/src/transpiler/lib.rs b/src/transpiler/lib.rs
index 0a38b88aeab..59ac811b324 100644
--- a/src/transpiler/lib.rs
+++ b/src/transpiler/lib.rs
@@ -1,6 +1,6 @@
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 #![warn(unused_must_use)]
-// `Transpiler` (Zig: `src/transpiler.zig`) is implemented in
+// `Transpiler` is implemented in
 // `bun_bundler::transpiler` because it shares the bundler's
 // resolver/options/cache plumbing. This crate re-exports it under the
 // `bun_transpiler` name so install/CLI tiers don't have to depend on
diff --git a/src/url/lib.rs b/src/url/lib.rs
index b9b1e46b537..12c404b1cb3 100644
--- a/src/url/lib.rs
+++ b/src/url/lib.rs
@@ -19,7 +19,7 @@ use bun_core::io::Write as _;
 
 // ── route_param (moved from bun_router) ───────────────────────────────────
 pub mod route_param {
-    // PORT NOTE: name/value borrow from the route template + the live request
+    // name/value borrow from the route template + the live request
     // path; lifetime-generic so `bun_router` (the only producer) can fill them
     // from non-'static buffers. Downstream that only stores literals can use
     // `Param<'static>`.
@@ -28,14 +28,14 @@ pub mod route_param {
         pub name: &'a [u8],
         pub value: &'a [u8],
     }
-    // TODO(port): bun_collections::MultiArrayList — derive(MultiArrayElement)
-    // proc-macro not yet available. Using Vec; SoA layout is a perf concern only.
+    // SoA (`MultiArrayList`) layout would be a perf optimization only; a plain
+    // Vec is semantically identical.
     pub type List<'a> = Vec<Param<'a>>;
 }
 pub use route_param::List as ParamsList;
 
 // ── whatwg (WTF::URL FFI shim, MOVE_DOWN from bun_jsc) ────────────────────
-// Ground truth: src/jsc/URL.zig. The JS-value entry points (`hrefFromJS`, `fromJS`)
+// The JS-value entry points (`hrefFromJS`, `fromJS`)
 // stay in tier-6 `bun_jsc` as extension methods — they need JSValue/JSGlobalObject.
 // Everything else is a thin extern-"C" wrapper around WTF::URL and is JSC-agnostic.
 pub mod whatwg {
@@ -49,8 +49,7 @@ pub mod whatwg {
         _opaque: [u8; 0],
     }
 
-    // TODO(port): move to <area>_sys
-    // PORT NOTE: getters take `*const URL` — the C++ side (BunString.cpp) never mutates the
+    // Getters take `*const URL` — the C++ side (BunString.cpp) never mutates the
     // WTF::URL on read. `URL__deinit` keeps `*mut` (it `delete`s). `BunString*` inputs stay
     // `*mut` to match the C ABI; callers pass a mutable local copy (see below).
     // SAFETY (safe fn): `URL` is an opaque ZST handle (never null when behind `&`);
@@ -79,10 +78,9 @@ pub mod whatwg {
         fn URL__originLength(latin1_slice: *const u8, len: usize) -> u32;
     }
 
-    // PORT NOTE: Zig takes `bun.String` by value then `var input = str; f(&input)` to
-    // obtain a mutable address for C ABI. We take `&String` (matching existing call sites
+    // The C ABI wants a mutable address. We take `&String` (matching existing call sites
     // in this crate) and — since `bun_core::String: Copy` — bit-copy into a mutable
-    // local and pass `&mut local`. This mirrors the Zig spec exactly and avoids casting
+    // local and pass `&mut local`. This avoids casting
     // a shared-ref-derived pointer to `*mut` (read-only provenance). The C++ side
     // (`BunString::toWTFString() const`) does not mutate, but the local-copy form is
     // sound regardless.
@@ -195,9 +193,8 @@ pub use whatwg::{
     file_url_from_string, href_from_string, join, origin_from_slice, path_from_file_url,
 };
 
-// PORT NOTE: URL is a pure view struct — every field is a slice into `href` (or a
-// literal default). Zig expresses this with `[]const u8` fields borrowing the
-// caller-provided `base`.
+// URL is a pure view struct — every field is a slice into `href` (or a
+// literal default).
 #[derive(Clone)]
 pub struct URL<'a> {
     pub hash: &'a [u8],
@@ -240,10 +237,7 @@ impl<'a> Default for URL<'a> {
 }
 
 /// An owning URL — holds the normalized `href` buffer that the borrowed
-/// `URL<'_>` view slices into. Port of `URL.fromString`'s ownership model:
-/// Zig returned a `URL` borrowing from a fresh allocation the caller had to
-/// `allocator.free(url.href)`; in Rust, `OwnedURL` owns that buffer and
-/// `Drop` frees it.
+/// `URL<'_>` view slices into; `Drop` frees it.
 #[derive(Default, Clone)]
 pub struct OwnedURL {
     href: Box<[u8]>,
@@ -252,9 +246,9 @@ pub struct OwnedURL {
 impl OwnedURL {
     /// Borrow as a parsed `URL` view. All slices in the returned `URL` borrow
     /// `self.href`.
-    // PERF(port): re-parses on each call. Zig parsed once into a borrowing
-    // struct the caller held alongside the buffer; Rust cannot express that
-    // self-reference without unsafe lifetime extension (PORTING.md §Forbidden).
+    // PERF: re-parses on each call. Storing a parsed view alongside the
+    // buffer would be a self-reference, which Rust cannot express without
+    // unsafe lifetime extension.
     // Callers in practice call this once and hold the borrow — if this shows
     // up on a hot path, store component `(u32, u32)` offsets here instead.
     #[inline]
@@ -360,17 +354,14 @@ impl<'a> URL<'a> {
         self.href.len() == Self::BLOB_SPECIFIER_LEN && self.href.starts_with(b"blob:")
     }
 
-    // PORT NOTE: ownership — Zig returns a `URL` borrowing from a freshly-allocated
-    // owned slice (`href.toOwnedSlice`); caller frees `url.href` later. Per
-    // PORTING.md §Forbidden (no Box::leak / mem::forget / unsafe lifetime
-    // extension), Rust returns an `OwnedURL` that owns the buffer; callers borrow
+    // Ownership: returns an `OwnedURL` that owns the buffer; callers borrow
     // via `.url()` and Drop frees it.
     pub fn from_string(input: &BunString) -> Result<OwnedURL, bun_core::Error> {
         let href = whatwg::href_from_string(input);
         if href.tag() == BunStringTag::Dead {
             return Err(bun_core::err!("InvalidURL"));
         }
-        // Zig: `defer href.deref()` — `to_owned_slice` is infallible so explicit
+        // `to_owned_slice` is infallible so explicit
         // ordering suffices (no error path between alloc and deref).
         let owned = href.to_owned_slice().into_boxed_slice();
         href.deref();
@@ -449,9 +440,7 @@ impl<'a> URL<'a> {
         }
     }
 
-    /// Zig: `std.fmt.allocPrint(alloc, "{s}://{f}/{s}/", .{
-    ///     url.displayProtocol(), url.displayHost(),
-    ///     std.mem.trim(u8, url.pathname, "/") })`.
+    /// Formats `<displayProtocol>://<displayHost>/<trimmed pathname>/`.
     ///
     /// `display_host()` yields a `bun_core::fmt::HostFormatter` (impls
     /// `Display`); the other two pieces are raw byte slices, so we assemble
@@ -550,7 +539,6 @@ impl<'a> URL<'a> {
             buf[buf_i..buf_i + part.len()].copy_from_slice(part);
             buf_i += part.len();
         }
-        // Zig: resolve_path.normalizeStringBuf(buf[0..buf_i], out, false, .loose, false)
         resolve_path::normalize_string_buf::<false, platform::Loose, false>(&buf[0..buf_i], out)
     }
 
@@ -562,11 +550,9 @@ impl<'a> URL<'a> {
         basename: &[u8],
         extname: &[u8],
     ) -> Result<(), bun_core::Error> {
-        // TODO(port): narrow error set
         let mut out = [0u8; 2048];
         let normalized_path = Self::join_normalize(&mut out, prefix, dirname, basename, extname);
 
-        // Zig: writer.print("{s}/{s}", .{ this.origin, normalized_path })
         writer.write_all(self.origin)?;
         writer.write_all(b"/")?;
         writer.write_all(normalized_path)?;
@@ -581,11 +567,9 @@ impl<'a> URL<'a> {
         extname: &[u8],
         absolute_path: &[u8],
     ) -> Result<Box<[u8]>, bun_core::Error> {
-        // TODO(port): narrow error set
         let has_uplevels = strings::index_of(dirname, b"../").is_some();
 
         if has_uplevels {
-            // std.fmt.allocPrint("{s}/abs:{s}")
             let mut v = Vec::with_capacity(self.origin.len() + 5 + absolute_path.len());
             v.extend_from_slice(self.origin);
             v.extend_from_slice(b"/abs:");
@@ -611,7 +595,6 @@ impl<'a> URL<'a> {
             href: base,
             ..Default::default()
         };
-        // PORT NOTE: Zig uses u31; Rust has no u31 — using u32 (values never approach 2^31).
         let mut offset: u32 = 0;
         match base[0] {
             b'@' => {
@@ -901,17 +884,13 @@ pub struct Param {
     pub value: api::StringPointer,
 }
 
-// PERF(port): Zig uses `std.MultiArrayList(Param)` for SoA cache-friendly column
-// scans. bun_collections::MultiArrayList exists but requires `MultiArrayElement`
-// (no derive macro yet). Using Vec<Param> (AoS) for now — semantically identical;
-// revisit once `` lands.
-// TODO(port): bun_collections::MultiArrayList derive
+// Vec<Param> (AoS); SoA would be a perf optimization only.
 pub(crate) type ParamList = Vec<Param>;
 
 /// QueryString array-backed hash table that does few allocations and preserves the original order
 pub struct QueryStringMap {
-    // PORT NOTE: allocator field dropped — global mimalloc per PORTING.md.
-    // TODO(port): `slice` is self-referential (points into `buffer`) when decoding
+    // Allocator field dropped — global mimalloc per PORTING.md.
+    // `slice` is self-referential (points into `buffer`) when decoding
     // happened, otherwise borrows the caller's query_string. Stored as raw fat ptr.
     slice: *const [u8],
     pub buffer: Vec<u8>,
@@ -947,7 +926,7 @@ impl Clone for QueryStringMap {
 }
 
 thread_local! {
-    // PORT NOTE: unused in current code (commented-out path in get_name_count)
+    // Unused in current code (commented-out path in get_name_count).
     static NAME_COUNT_BUF: RefCell<[*const [u8]; 8]> = const { RefCell::new([std::ptr::from_ref::<[u8]>(&[]); 8]) };
 }
 
@@ -993,7 +972,6 @@ impl QueryStringMap {
 
     pub fn get_all<'s>(&'s self, input: &[u8], target: &mut [&'s [u8]]) -> usize {
         let hash = wyhash(input);
-        // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
         self.get_all_with_hash_from_offset(target, hash, 0)
     }
 
@@ -1051,7 +1029,7 @@ impl QueryStringMap {
             return Ok(None);
         }
 
-        list.reserve(count.min(MAX_QUERY_STRING_PARAMS)); // PERF(port): was ensureTotalCapacity
+        list.reserve(count.min(MAX_QUERY_STRING_PARAMS));
         scanner.reset();
 
         // this over-allocates
@@ -1084,7 +1062,6 @@ impl QueryStringMap {
             value.offset = buf_writer_pos;
             buf_writer_pos += value.length;
 
-            // PERF(port): was appendAssumeCapacity
             list.push(Param {
                 name,
                 value,
@@ -1145,7 +1122,6 @@ impl QueryStringMap {
             value.offset = buf_writer_pos;
             buf_writer_pos += value.length;
 
-            // PERF(port): was appendAssumeCapacity
             list.push(Param {
                 name,
                 value,
@@ -1188,7 +1164,7 @@ impl QueryStringMap {
         }
 
         scanner = Scanner::init(query_string);
-        list.reserve(count); // PERF(port): was ensureTotalCapacity
+        list.reserve(count);
 
         if nothing_needs_decoding {
             scanner = Scanner::init(query_string);
@@ -1202,7 +1178,6 @@ impl QueryStringMap {
                 let name = result.name;
                 let value = result.value;
                 let name_hash: u64 = wyhash(result.raw_name(query_string));
-                // PERF(port): was appendAssumeCapacity
                 list.push(Param {
                     name,
                     value,
@@ -1213,7 +1188,7 @@ impl QueryStringMap {
             return Ok(Some(QueryStringMap {
                 list,
                 buffer: Vec::new(),
-                // TODO(port): borrows external query_string; lifetime not tracked here
+                // `slice` borrows the caller's query_string; lifetime not tracked here
                 slice: std::ptr::from_ref::<[u8]>(query_string),
                 name_count: None,
             }));
@@ -1222,8 +1197,7 @@ impl QueryStringMap {
         let mut buf: Vec<u8> = Vec::with_capacity(estimated_str_len);
         let mut buf_writer_pos: u32 = 0;
 
-        // PORT NOTE: reshaped for borrowck — Zig captured `list.slice()` once outside
-        // the loop; here we re-slice per iteration to avoid holding a borrow across push().
+        // Re-slice per iteration to avoid holding a borrow across push().
         while let Some(result) = scanner.next() {
             if list.len() >= MAX_QUERY_STRING_PARAMS {
                 break;
@@ -1269,7 +1243,6 @@ impl QueryStringMap {
             value.offset = buf_writer_pos;
             buf_writer_pos += value.length;
 
-            // PERF(port): was appendAssumeCapacity
             list.push(Param {
                 name,
                 value,
@@ -1288,7 +1261,6 @@ impl QueryStringMap {
 }
 
 // Browsers typically limit URL lengths to around 64k
-// PORT NOTE: Zig `StaticBitSet(2048)` resolves to `ArrayBitSet(usize, 2048)`.
 // bun_collections::StaticBitSet currently aliases IntegerBitSet (≤64 bits), so
 // pick ArrayBitSet directly. 2048 / 64 == 32 masks.
 /// Hard cap on parsed query-string parameters, enforced in `init` /
@@ -1318,7 +1290,7 @@ impl<'a> Iterator<'a> {
         }
     }
 
-    // TODO(port): lifetime on `target`/return — values borrow target, name borrows map.slice
+    // Lifetimes: values borrow `target` ('t), name borrows `map.slice` ('a).
     pub fn next<'t>(&mut self, target: &'t mut [&'a [u8]]) -> Option<IteratorResult<'a, 't>>
     where
         'a: 't,
@@ -1407,7 +1379,6 @@ impl From<DecodeError> for bun_core::Error {
 
 impl PercentEncoding {
     pub fn decode(writer: &mut impl bun_core::io::Write, input: &[u8]) -> Result<u32, DecodeError> {
-        // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
         Self::decode_fault_tolerant::<_, false>(writer, input, None)
     }
 
@@ -1501,10 +1472,8 @@ impl PercentEncoding {
     }
 }
 
-// TODO(port): FormData re-export removed — bun_runtime (T6) is upward.
-// Callers should import from bun_runtime::webcore::form_data
-// directly (or move-in pass relocates FormData here if it belongs at T2).
-// pub use bun_runtime::webcore::form_data::FormData;
+// FormData intentionally not re-exported here: bun_runtime (T6) is upward of
+// this crate. Callers import from bun_runtime::webcore::form_data directly.
 
 // ══════════════════════════════════════════════════════════════════════════
 // Scanners
@@ -1667,8 +1636,7 @@ impl<'a> Scanner<'a> {
     /// Get the next query string parameter without allocating memory.
     pub fn next(&mut self) -> Option<ScannerResult> {
         let mut relative_i: usize = 0;
-        // PORT NOTE: Zig used `defer this.i += relative_i;` — emulated by applying
-        // the deferred add at every return point.
+        // `relative_i` is added to `this.i` at every return point.
 
         // reuse stack space
         // otherwise we'd recursively call the function
@@ -1768,5 +1736,3 @@ impl<'a> Scanner<'a> {
         }
     }
 }
-
-// ported from: src/url/url.zig
diff --git a/src/uws/lib.rs b/src/uws/lib.rs
index 1b9fb6ee9f2..37be10ccad8 100644
--- a/src/uws/lib.rs
+++ b/src/uws/lib.rs
@@ -16,9 +16,6 @@ use bun_core::ZStr;
 // `InternalSocket`, `AnySocket`, `ConnectError`, `CloseKind`, owned
 // `SocketAddress`) stay defined here; `bun_uws_sys::socket` has lifetime-
 // bearing variants of the same names that are not yet reconciled.
-//
-// `bun_runtime::*` items (dispatch, WindowsNamedPipe, UpgradedDuplex) are
-// upward refs into a higher tier and intentionally remain local stub modules.
 
 pub use bun_uws_sys::{
     AnyWebSocket, BodyReaderMixin, ConnectingSocket, ListenSocket, NewApp, RawWebSocket, Request,
@@ -35,12 +32,6 @@ pub use bun_uws_sys::response::State;
 pub use bun_uws_sys::{h3 as H3, quic, udp, vtable};
 pub type Socket = us_socket_t;
 
-// Upward refs into `bun_runtime` (higher tier) — kept as empty namespace stubs.
-// TODO(port): bun_runtime::socket::{uws_dispatch, windows_named_pipe, upgraded_duplex}
-pub mod dispatch {}
-pub mod WindowsNamedPipe {}
-pub mod UpgradedDuplex {}
-
 /// Bare BoringSSL `SSL_CTX`. `SSL_CTX_up_ref`/`SSL_CTX_free` is the refcount;
 /// policy (verify mode, reneg limits) is encoded on the SSL_CTX itself via
 /// `us_ssl_ctx_from_options`, so there's no wrapper struct. `Option<*mut SslCtx>`
@@ -65,7 +56,6 @@ pub enum ResponseKind {
 }
 
 impl ResponseKind {
-    // PERF(port): was comptime monomorphization — profile if hot.
     pub const fn from(ssl: bool, http3: bool) -> ResponseKind {
         if http3 {
             ResponseKind::H3
@@ -99,8 +89,8 @@ pub use bun_uws_sys::{
 };
 
 // Re-export the `_sys` definitions so higher tiers see one type. `to_js`
-// (Zig: `@import("../runtime/socket/uws_jsc.zig").createBunSocketErrorToJS` and
-// `verifyErrorToJS`) live as extension traits in the *_jsc crate per PORTING.md.
+// (`createBunSocketErrorToJS` / `verifyErrorToJS`) live as extension traits
+// in the *_jsc crate.
 pub use bun_uws_sys::{Opcode, SendStatus, create_bun_socket_error_t, us_bun_verify_error_t};
 
 /// Owned socket-address shape (boxed IP). Distinct from the sys type by
@@ -112,15 +102,7 @@ pub struct SocketAddress {
     pub is_ipv6: bool,
 }
 
-// TODO(port): move to uws_sys
-unsafe extern "C" {
-    // safe: no args; clears thread-local loop pointer — no preconditions.
-    safe fn bun_clear_loop_at_thread_exit();
-}
-
-pub fn on_thread_exit() {
-    bun_clear_loop_at_thread_exit()
-}
+pub use bun_uws_sys::loop_::on_thread_exit;
 
 /// # Safety
 /// `filename` and `error_msg` must be valid NUL-terminated C strings.
@@ -162,7 +144,6 @@ pub fn get_default_ciphers() -> &'static ZStr {
 
 // ═══════════════════════════════════════════════════════════════════════════
 // MOVE-IN: ssl_wrapper (MOVE_DOWN bun_runtime::socket::ssl_wrapper → bun_uws)
-// Ground truth: src/runtime/socket/ssl_wrapper.zig
 // Requested by: http_jsc
 // ═══════════════════════════════════════════════════════════════════════════
 // `bun_boringssl_sys` is currently empty (bindgen not yet run), so every fn
@@ -241,8 +222,8 @@ pub mod ssl_wrapper {
         pub renegotiation_window_start: Option<std::time::Instant>,
     }
 
-    /// CamelCase alias for callers that imported the Zig name through the
-    /// snake_case→CamelCase rewriter (e.g. `http_jsc`).
+    /// CamelCase alias for callers that use the alternate spelling
+    /// (e.g. `http_jsc`).
     pub type SslWrapper<T> = SSLWrapper<T>;
 
     /// `Cell`-backed bitfield so the R-2 noalias-laundered self-backref (see
@@ -256,7 +237,7 @@ pub mod ssl_wrapper {
     #[derive(Default)]
     pub struct Flags(core::cell::Cell<u8>);
 
-    // packed struct(u8) layout (Zig packs LSB-first):
+    // Bit layout (LSB-first):
     //   bits 0-1: handshake_state (u2)
     //   bit  2:   received_ssl_shutdown
     //   bit  3:   sent_ssl_shutdown
@@ -286,9 +267,8 @@ pub mod ssl_wrapper {
         #[inline]
         pub fn handshake_state(&self) -> HandshakeState {
             // bits 0-1 are always written via set_handshake_state with a valid
-            // discriminant in range 0..=2; the 4th bit-state traps (matches
-            // Zig's safety-checked `@enumFromInt`) rather than silently
-            // folding bitfield corruption to a valid variant.
+            // discriminant in range 0..=2; the 4th bit-state traps rather than
+            // silently folding bitfield corruption to a valid variant.
             match self.bits() & Self::HANDSHAKE_MASK {
                 0 => HandshakeState::HandshakePending,
                 1 => HandshakeState::HandshakeCompleted,
@@ -511,7 +491,7 @@ pub mod ssl_wrapper {
             })
         }
 
-        /// Tier-neutral form of Zig `init(ssl_options: jsc.API.ServerConfig.SSLConfig, ...)`.
+        /// Tier-neutral constructor.
         /// Higher-tier callers convert their `SSLConfig` via `.as_usockets()` and pass the
         /// resulting `BunSocketContextOptions` here, so this crate stays free of the
         /// `jsc`/`http_types` dependency. The original `SSLConfig`-taking `init` lives as
@@ -1130,7 +1110,7 @@ pub mod ssl_wrapper {
             // always handle the handshake first
             if Self::r(this).update_handshake_state() {
                 // shared stack buffer for reading and writing
-                // PERF(port): 64KiB on-stack array — was Zig stack array; verify Rust stack-size headroom.
+                // PERF: 64KiB on-stack array — verify stack-size headroom.
                 let mut buffer = [0u8; BUFFER_SIZE];
                 // drain the input BIO first
                 Self::r(this).handle_writing(&mut buffer);
@@ -1168,12 +1148,10 @@ pub mod ssl_wrapper {
         /// CTX. Returns null if root loading fails (treated as "no roots").
         // safe: no args; idempotent lazy init reading a process global — no preconditions.
         safe fn us_get_shared_default_ca_store() -> *mut boring_sys::X509_STORE;
-        /// Zig `BoringSSL.SSL.getVerifyError` — implemented in uSockets C; reads
+        /// Implemented in uSockets C; reads
         /// `SSL_get_verify_result` and maps it onto the C `us_bun_verify_error_t`.
         fn us_ssl_socket_verify_error_from_ssl(ssl: *mut boring_sys::SSL) -> us_bun_verify_error_t;
     }
-
-    // ported from: src/runtime/socket/ssl_wrapper.zig
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1208,7 +1186,7 @@ pub trait InternalLoopDataExt {
 }
 
 impl InternalLoopDataExt for InternalLoopData {
-    /// Zig: `setParentEventLoop(this, parent: jsc.EventLoopHandle)`. Tag 1 = JS
+    /// Tag 1 = JS
     /// event loop, tag 2 = mini event loop. Generic over the handle so this
     /// crate stays free of the `jsc` dependency.
     #[inline]
@@ -1217,7 +1195,7 @@ impl InternalLoopDataExt for InternalLoopData {
         self.set_parent_raw(tag, ptr);
     }
 
-    /// Zig: `getParent() jsc.EventLoopHandle`. Low tier returns the (tag, ptr)
+    /// Low tier returns the (tag, ptr)
     /// pair; the typed enum wrapper lives in the higher-tier crate that can
     /// name `jsc::EventLoop` / `jsc::MiniEventLoop`.
     #[inline]
@@ -1249,7 +1227,7 @@ pub mod SocketContext {
     /// (callers in higher tiers pass values to `_sys` constructors directly).
     pub use bun_uws_sys::BunSocketContextOptions;
 }
-/// Snake-case module alias for the porting tooling that lowercases Zig namespaces.
+/// Snake-case module alias.
 pub use SocketContext as socket_context;
 
 /// C-name alias for `SocketContext::BunSocketContextOptions` — what
@@ -1262,7 +1240,7 @@ pub type us_bun_socket_context_options_t = SocketContext::BunSocketContextOption
 // ═══════════════════════════════════════════════════════════════════════════
 
 /// Re-exported from `bun_uws_sys` so dispatch tables in both crates agree on
-/// one `#[repr(u8)]` enum. Source of truth: `src/uws_sys/SocketKind.zig`.
+/// one `#[repr(u8)]` enum.
 pub use bun_uws_sys::SocketKind;
 
 /// Alias used by some callers (`websocket_client`, `sql_jsc`) that named
@@ -1278,8 +1256,8 @@ pub type CloseKind = CloseCode;
 // ═══════════════════════════════════════════════════════════════════════════
 // Socket handlers (NewSocketHandler / SocketHandler / AnySocket)
 // ═══════════════════════════════════════════════════════════════════════════
-// Re-exported from `bun_uws_sys::socket` — that is the ONE canonical port of
-// `socket.zig`. Do NOT add a parallel `InternalSocket` / `NewSocketHandler`
+// Re-exported from `bun_uws_sys::socket` — that is the ONE canonical
+// definition. Do NOT add a parallel `InternalSocket` / `NewSocketHandler`
 // here again; an earlier "thin placeholder" that grew full bodies has been
 // deleted.
 pub use bun_uws_sys::socket::{
@@ -1359,5 +1337,3 @@ pub type Response<const SSL: bool> = bun_uws_sys::response::Response<SSL>;
 pub use bun_uws_sys::AnyResponse;
 
 pub use bun_uws_sys::response::WriteResult;
-
-// ported from: src/uws/uws.zig
diff --git a/src/uws_sys/App.rs b/src/uws_sys/App.rs
index d7fe145cd20..c5d79e47d17 100644
--- a/src/uws_sys/App.rs
+++ b/src/uws_sys/App.rs
@@ -52,7 +52,7 @@ pub struct App<const SSL: bool> {
     _m: PhantomData<(*mut u8, PhantomPinned)>,
 }
 
-/// Zig name compatibility (`uws.NewApp(ssl)`).
+/// Legacy name alias.
 pub type NewApp<const SSL: bool> = App<SSL>;
 
 /// Stamps one `pub fn $name(&mut self, pattern, handler, user_data)` per HTTP
@@ -116,7 +116,7 @@ impl<const SSL: bool> App<SSL> {
 
     /// # Safety
     /// `this` must be a live app handle from [`App::create`]. Caller must not use it after.
-    // TODO(port): FFI destroy — caller must not use after; opaque #[repr(C)] handle, not Drop.
+    /// (FFI destroy on an opaque C-owned handle — intentionally not `Drop`.)
     pub unsafe fn destroy(this: *mut Self) {
         // SAFETY: caller contract — `this` is a valid *mut uws_app_s; ssl flag matches construction.
         unsafe { c::uws_app_destroy(Self::SSL_FLAG, this.cast::<uws_app_t>()) }
@@ -164,12 +164,7 @@ impl<const SSL: bool> App<SSL> {
     // ─────────────────────────────────────────────────────────────────────
     // RouteHandler
     //
-    // Zig's `RouteHandler(comptime UserDataType, comptime handler)` generated a
-    // unique `extern "C" fn handle(...)` per (UserDataType, handler) pair at
-    // comptime, downcasting `user_data: ?*anyopaque` and calling `handler` with
-    // `.always_inline`.
-    //
-    // Rust cannot accept a `fn` as a const-generic parameter, so the type-safe
+    // Rust cannot accept a `fn` as a const-generic parameter, so a type-safe
     // shim cannot be monomorphized here without a macro. We expose the raw
     // C handler type directly; callers supply their own `extern "C" fn` (or a
     // future `route_handler!` macro generates one). The shape of that shim is:
@@ -182,9 +177,6 @@ impl<const SSL: bool> App<SSL> {
     //       let user_data = unsafe { &mut *(user_data as *mut U) };
     //       HANDLER(user_data, unsafe { &mut *req }, unsafe { &mut *(res as *mut Response<SSL>) });
     //   }
-    //
-    // TODO(port): proc-macro or trait-based comptime handler dispatch (RouteHandler).
-    // PERF(port): was @call(.always_inline) on the user handler — profile if hot.
     // ─────────────────────────────────────────────────────────────────────
 
     uws_app_route_methods! {
@@ -249,9 +241,7 @@ impl<const SSL: bool> App<SSL> {
         handler: extern "C" fn(*mut UwsListenSocket, *mut c_void),
         user_data: *mut c_void,
     ) {
-        // TODO(port): Zig generated a type-safe Wrapper.handle per (UserData, handler) at
-        // comptime, casting user_data and ListenSocket. Macro-generate the shim.
-        // PERF(port): was @call(.always_inline) on the user handler.
+        // Callers supply the C-ABI shim directly (see the RouteHandler note above).
         c::uws_app_listen(
             Self::SSL_FLAG,
             self.as_raw(),
@@ -266,9 +256,7 @@ impl<const SSL: bool> App<SSL> {
         handler: extern "C" fn(*mut c_void, c_int, *mut us_socket_t, u8, *mut u8, c_int),
         user_data: *mut c_void,
     ) {
-        // TODO(port): Zig wrapped the C callback to slice raw_packet[0..max(len,0)] and pass
-        // a typed UserData. Macro-generate the shim; for now callers slice manually.
-        // PERF(port): was @call(.always_inline) on the user handler.
+        // Callers receive the raw C args and slice raw_packet manually.
         c::uws_app_set_on_clienterror(Self::SSL_FLAG, self.as_raw(), handler, user_data)
     }
 
@@ -278,9 +266,7 @@ impl<const SSL: bool> App<SSL> {
         user_data: *mut c_void,
         config: c::uws_app_listen_config_t,
     ) {
-        // TODO(port): Zig generated a type-safe Wrapper.handle per (UserData, handler) at
-        // comptime. Macro-generate the shim.
-        // PERF(port): was @call(.always_inline) on the user handler.
+        // Callers supply the C-ABI shim directly.
         // SAFETY: self is a valid app; config.host (if non-null) is NUL-terminated and outlives the call.
         unsafe {
             c::uws_app_listen_with_config(
@@ -302,9 +288,7 @@ impl<const SSL: bool> App<SSL> {
         domain_name: &ZStr,
         flags: i32,
     ) {
-        // TODO(port): Zig generated a type-safe Wrapper.handle per (UserData, handler) at
-        // comptime (ignoring domain/flags args, casting socket). Macro-generate the shim.
-        // PERF(port): was @call(.always_inline) on the user handler.
+        // Callers supply the C-ABI shim directly.
         // SAFETY: self is a valid app; domain_name is NUL-terminated.
         unsafe {
             c::uws_app_listen_domain_with_options(
@@ -453,10 +437,9 @@ impl<const SSL: bool> App<SSL> {
     // - Cork/uncork functionality for efficient batched writes
     // - Automatic handling of Connection: close semantics
     //
-    // TODO(port): Zig exposed `Response` and `WebSocket` as nested associated types
-    // (App<SSL>::Response). Rust inherent associated types are unstable; callers use
+    // Rust inherent associated types are unstable; callers name
     // `crate::response::Response<{SSL as i32}>` / `crate::web_socket::WebSocket<{SSL as i32}>`
-    // directly until a stable encoding (trait assoc type or type alias) is picked.
+    // directly.
 }
 
 /// Opaque listen socket handle, parameterized by SSL to match `App<SSL>`.
@@ -484,7 +467,7 @@ impl<const SSL: bool> ListenSocket<SSL> {
 
     pub fn socket(&mut self) -> crate::socket::NewSocketHandler<SSL> {
         // SAFETY: ListenSocket<SSL> is layout-identical to us_socket_t on the C side
-        // (a listen socket IS a us_socket_t); Zig does `.from(@ptrCast(this))`.
+        // (a listen socket IS a us_socket_t).
         crate::socket::NewSocketHandler::<SSL>::from(std::ptr::from_mut::<Self>(self).cast())
     }
 }
@@ -708,7 +691,6 @@ pub mod c {
     }
 
     impl uws_app_listen_config_t {
-        // Zig has no default for `port` (only `host = null`, `options = 0`); `.{}` is illegal there.
         // Provide a required-port constructor instead of `Default` to avoid inventing port=0.
         pub const fn new(port: c_int) -> Self {
             Self {
@@ -719,5 +701,3 @@ pub mod c {
         }
     }
 }
-
-// ported from: src/uws_sys/App.zig
diff --git a/src/uws_sys/BodyReaderMixin.rs b/src/uws_sys/BodyReaderMixin.rs
index 58a27228281..838f621da24 100644
--- a/src/uws_sys/BodyReaderMixin.rs
+++ b/src/uws_sys/BodyReaderMixin.rs
@@ -5,8 +5,7 @@ use crate::AnyResponse;
 use crate::response::Response;
 
 /// Response types that can drive a `BodyReaderMixin`: must support registering
-/// data/abort callbacks and converting to `AnyResponse`. Stands in for the Zig
-/// `anytype` parameter on `readBody`.
+/// data/abort callbacks and converting to `AnyResponse`.
 ///
 /// Only `Response<SSL>` is wired today (DevServer's only consumer is HTTP/1.x);
 /// `h3::Response` can be added once its callback signatures are unified.
@@ -38,8 +37,7 @@ impl<const SSL: bool> BodyResponse for Response<SSL> {
     #[inline]
     fn to_any(&mut self) -> AnyResponse {
         // `From<*mut Response<{true,false}>>` exist as two concrete impls, not a
-        // const-generic one, so dispatch on `SSL` here. Same shape as Zig's
-        // `AnyResponse.init` switching on @TypeOf.
+        // const-generic one, so dispatch on `SSL` here.
         if SSL {
             AnyResponse::SSL(std::ptr::from_mut::<Self>(self).cast())
         } else {
@@ -54,19 +52,16 @@ impl<const SSL: bool> BodyResponse for Response<SSL> {
 ///
 /// See `DevServer`'s `ErrorReportRequest` for an example.
 ///
-/// In Zig this was a `fn(...) type` taking a comptime `field` name and two
-/// comptime fn pointers (`onBody`, `onError`). In Rust those are expressed as
-/// a trait the wrapper type implements; the comptime `field` name used by
-/// `@fieldParentPtr` is the [`bun_core::IntrusiveField`] supertrait (implement
-/// via `bun_core::intrusive_field!`).
+/// The wrapper type implements this trait; the intrusive field is declared
+/// via the [`bun_core::IntrusiveField`] supertrait (implement via
+/// `bun_core::intrusive_field!`).
 pub trait BodyReaderHandler: bun_core::IntrusiveField<BodyReaderMixin<Self>> + 'static {
     /// `body` is freed after this function returns.
     ///
     /// Receives the original `heap::alloc`'d pointer (full-allocation
     /// provenance) rather than `&mut self`: implementors typically free `Self`
     /// (`heap::take`) on the success path, and doing so through a
-    /// `&mut self`-derived pointer is UB under Stacked/Tree Borrows. This
-    /// mirrors Zig's `fn(*Wrap, ...)` callback shape exactly.
+    /// `&mut self`-derived pointer is UB under Stacked/Tree Borrows.
     ///
     /// SAFETY: `this` is the pointer previously passed to
     /// `BodyReaderMixin::read_body`; it is live and uniquely owned by the
@@ -102,8 +97,7 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
     ///
     /// Takes `*mut Wrap` (not `&mut self`) so the registered C user_data carries
     /// provenance for the *entire* enclosing `Wrap`, not just the mixin field.
-    /// Zig used `@fieldParentPtr(field, ctx)` which has no provenance/aliasing
-    /// restriction; in Rust, deriving the parent by `.byte_sub(OFFSET)` from a
+    /// Deriving the parent by `.byte_sub(OFFSET)` from a
     /// `&mut self`-sourced pointer is out-of-provenance under Stacked Borrows
     /// and the resulting `&mut Wrap` would overlap a live `&mut Self`. Callers
     /// pass the `heap::alloc`'d wrapper pointer directly; trampolines below
@@ -115,7 +109,7 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
     }
 
     /// Forward offset `Wrap` → its embedded mixin field, materialised as `&mut`.
-    /// Inverse direction of Zig's `@fieldParentPtr` — we go parent→field because
+    /// We go parent→field because
     /// the stored user_data is the parent (full provenance), never the field.
     ///
     /// Single nonnull-asref accessor for the set-once `wrap` user-data.
@@ -140,7 +134,7 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
         let any = r.to_any();
         match Self::on_data(wrap, any, chunk, last) {
             Ok(()) => {}
-            // Match Zig's `error.OutOfMemory => onOOM, else => onInvalid` by error
+            // Dispatch OutOfMemory → onOOM, anything else → onInvalid, by error
             // *kind* only — `bun_core::Error`'s derived `PartialEq` compares all
             // fields (syscall/fd/path), and `err!("OutOfMemory")` is currently a
             // TODO sentinel, so a full-struct compare would invert the branch.
@@ -175,8 +169,11 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
                 if body.len().saturating_add(chunk.len()) > MAX_BODY_SIZE {
                     return Err(bun_core::err!(RequestBodyTooLarge));
                 }
-                // TODO(port): Zig handled OOM gracefully here; Vec::extend_from_slice aborts.
-                // Consider try_reserve if graceful 500 on OOM is required.
+                // Handle OOM gracefully here (error → 500); use try_reserve so
+                // allocation failure surfaces as an error instead of an abort.
+                if body.try_reserve(chunk.len()).is_err() {
+                    return Err(bun_core::err!(OutOfMemory));
+                }
                 body.extend_from_slice(chunk);
                 // SAFETY: wrap is the original heap-allocated pointer; the &mut to
                 // mixin.body has ended, so on_body receives sole ownership of the
@@ -191,13 +188,19 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
                 // allocation and may heap::take it on success.
                 unsafe { Wrap::on_body(wrap, chunk, resp)? };
             }
-            // `body` drops here (was `defer body.deinit()` in Zig)
+            // `body` drops here
             Ok(())
         } else {
             let body = &mut Self::mixin_of(wrap).body;
             if body.len().saturating_add(chunk.len()) > MAX_BODY_SIZE {
                 return Err(bun_core::err!(RequestBodyTooLarge));
             }
+            // Propagate OOM here too
+            // (error → 500); use try_reserve so allocation failure surfaces as an
+            // error instead of an abort.
+            if body.try_reserve(chunk.len()).is_err() {
+                return Err(bun_core::err!(OutOfMemory));
+            }
             body.extend_from_slice(chunk);
             Ok(())
         }
@@ -236,5 +239,3 @@ impl<Wrap: BodyReaderHandler> BodyReaderMixin<Wrap> {
         unsafe { Wrap::on_error(wrap) };
     }
 }
-
-// ported from: src/uws_sys/BodyReaderMixin.zig
diff --git a/src/uws_sys/ConnectingSocket.rs b/src/uws_sys/ConnectingSocket.rs
index f0c282e74ff..b44d76f8163 100644
--- a/src/uws_sys/ConnectingSocket.rs
+++ b/src/uws_sys/ConnectingSocket.rs
@@ -14,7 +14,7 @@ impl ConnectingSocket {
     }
 
     /// Returns the owning `SocketGroup`. Raw pointer because the group is
-    /// shared by every socket it owns (Zig `*SocketGroup` freely aliases);
+    /// shared by every socket it owns;
     /// materializing `&mut SocketGroup` here would alias with other sockets'
     /// borrows of the same group.
     pub fn group(&mut self) -> *mut SocketGroup {
@@ -29,8 +29,8 @@ impl ConnectingSocket {
     }
 
     /// Returns the owning `Loop`. Raw pointer because the loop is a shared
-    /// singleton referenced by every group/socket/timer (Zig `*Loop` freely
-    /// aliases); materializing `&mut Loop` here would be aliased UB.
+    /// singleton referenced by every group/socket/timer;
+    /// materializing `&mut Loop` here would be aliased UB.
     pub fn r#loop(&mut self) -> *mut Loop {
         us_connecting_socket_get_loop(self)
     }
@@ -98,5 +98,3 @@ unsafe extern "C" {
     pub(crate) safe fn us_connecting_socket_timeout(s: &mut ConnectingSocket, seconds: c_uint);
     pub(crate) safe fn us_connecting_socket_get_loop(s: &mut ConnectingSocket) -> *mut Loop;
 }
-
-// ported from: src/uws_sys/ConnectingSocket.zig
diff --git a/src/uws_sys/InternalLoopData.rs b/src/uws_sys/InternalLoopData.rs
index f0b40114cf5..74df8437d99 100644
--- a/src/uws_sys/InternalLoopData.rs
+++ b/src/uws_sys/InternalLoopData.rs
@@ -91,5 +91,3 @@ impl InternalLoopData {
         (self.parent_tag, self.parent_ptr)
     }
 }
-
-// ported from: src/uws_sys/InternalLoopData.zig
diff --git a/src/uws_sys/ListenSocket.rs b/src/uws_sys/ListenSocket.rs
index 4fa67b02f91..a3beacd122e 100644
--- a/src/uws_sys/ListenSocket.rs
+++ b/src/uws_sys/ListenSocket.rs
@@ -19,7 +19,6 @@ impl ListenSocket {
         &mut self,
         buf: &'a mut [u8],
     ) -> Result<&'a [u8], bun_core::Error> {
-        // TODO(port): narrow error set
         self.get_socket().local_address(buf)
     }
 
@@ -29,7 +28,7 @@ impl ListenSocket {
 
     pub fn get_socket(&mut self) -> &mut us_socket_t {
         // SAFETY: ListenSocket is layout-compatible with us_socket_t on the C side
-        // (a listen socket IS a us_socket_t); Zig does `@ptrCast(this)`. The returned
+        // (a listen socket IS a us_socket_t). The returned
         // borrow reborrows `&mut self` exclusively — no alias is live while it exists.
         unsafe { &mut *std::ptr::from_mut::<ListenSocket>(self).cast::<us_socket_t>() }
     }
@@ -49,7 +48,7 @@ impl ListenSocket {
 
     pub fn ext<T>(&mut self) -> &mut T {
         // SAFETY: caller guarantees the ext storage was sized/aligned for T at
-        // group creation time (mirrors Zig `@ptrCast(@alignCast(...))`).
+        // group creation time.
         unsafe { &mut *us_listen_socket_ext(self).cast::<T>() }
     }
 
@@ -100,14 +99,13 @@ impl ListenSocket {
     /// Returns the raw userdata pointer registered via `add_server_name` for
     /// `hostname`, cast to `*mut T`. Returned as `NonNull<T>` (not `&mut T`)
     /// because the pointee is caller-owned external storage — materializing a
-    /// `&mut T` here could alias the caller's own live reference to it. Mirrors
-    /// Zig's `?*T` return (Zig pointers freely alias).
+    /// `&mut T` here could alias the caller's own live reference to it.
     pub fn find_server_name_userdata<T>(
         &mut self,
         hostname: &core::ffi::CStr,
     ) -> Option<NonNull<T>> {
         // SAFETY: self and hostname valid; caller guarantees the stored userdata
-        // is a *T (mirrors Zig `@ptrCast(@alignCast(...))`).
+        // is a *T.
         let p = unsafe { us_listen_socket_find_server_name_userdata(self, hostname.as_ptr()) };
         NonNull::new(p.cast::<T>())
     }
@@ -142,5 +140,3 @@ unsafe extern "C" {
         cb: extern "C" fn(*mut ListenSocket, *const c_char),
     );
 }
-
-// ported from: src/uws_sys/ListenSocket.zig
diff --git a/src/uws_sys/Loop.rs b/src/uws_sys/Loop.rs
index b3ec2028e66..8a6a20a8320 100644
--- a/src/uws_sys/Loop.rs
+++ b/src/uws_sys/Loop.rs
@@ -10,10 +10,14 @@ bun_core::declare_scope!(Loop, visible);
 
 // ───────────────────────────── PosixLoop ─────────────────────────────
 
-// TODO(port): Zig has field-level `align(16)` on `internal_loop_data` and
-// `ready_polls`. Rust cannot align individual fields directly; `#[repr(C, align(16))]`
-// covers the struct head, but `ready_polls` may need explicit padding to match
-// the C layout in usockets. Verify with a static size/offset assertion.
+// Mirrors C `struct us_loop_t` (packages/bun-usockets/src/internal/eventing/
+// epoll_kqueue.h). The C struct has `alignas(LIBUS_EXT_ALIGNMENT /* 16 */)` on
+// both `data` and `ready_polls`; Rust cannot align individual fields, so the
+// struct head gets `#[repr(C, align(16))]` and `ready_polls` is preceded by a
+// zero-sized align(16) field that forces the same offset rounding the C
+// `alignas` performs (`libc::epoll_event` is `packed`/align(1) on x86-64
+// Linux, so the element type alone would not pad). Layout is verified by the
+// static assertions below the struct.
 #[repr(C, align(16))]
 pub struct PosixLoop {
     pub internal_loop_data: InternalLoopData,
@@ -37,10 +41,47 @@ pub struct PosixLoop {
     /// If non-zero, the event loop will return immediately so we can skip the GC safepoint.
     pub pending_wakeups: u32,
 
+    /// Forces `ready_polls` to the next 16-byte boundary, matching the C
+    /// `alignas(LIBUS_EXT_ALIGNMENT)` on `us_loop_t::ready_polls`.
+    _ready_polls_align: ReadyPollsAlign,
+
     /// The list of ready polls
     pub ready_polls: [EventType; 1024],
 }
 
+/// Zero-sized, 16-byte-aligned marker field type (see `_ready_polls_align`).
+/// The zero-length array member keeps `improper_ctypes` satisfied (a
+/// field-less struct is rejected in `extern` signatures) without changing
+/// size (still 0) or alignment.
+#[repr(C, align(16))]
+struct ReadyPollsAlign {
+    _unused: [u8; 0],
+}
+
+// Static layout verification against the C `us_loop_t` rules: scalar fields
+// packed after `data`, `ready_polls` at the next 16-byte boundary, struct size
+// padded to its 16-byte alignment.
+#[cfg(not(windows))]
+const _: () = {
+    use core::mem::{align_of, offset_of, size_of};
+    assert!(align_of::<PosixLoop>() == 16);
+    assert!(offset_of!(PosixLoop, num_polls) == size_of::<InternalLoopData>());
+    assert!(offset_of!(PosixLoop, num_ready_polls) == offset_of!(PosixLoop, num_polls) + 4);
+    assert!(offset_of!(PosixLoop, current_ready_poll) == offset_of!(PosixLoop, num_polls) + 8);
+    assert!(offset_of!(PosixLoop, fd) == offset_of!(PosixLoop, num_polls) + 12);
+    assert!(offset_of!(PosixLoop, active) == offset_of!(PosixLoop, num_polls) + 16);
+    assert!(offset_of!(PosixLoop, pending_wakeups) == offset_of!(PosixLoop, num_polls) + 20);
+    assert!(
+        offset_of!(PosixLoop, ready_polls)
+            == (offset_of!(PosixLoop, pending_wakeups) + 4).next_multiple_of(16)
+    );
+    assert!(
+        size_of::<PosixLoop>()
+            == (offset_of!(PosixLoop, ready_polls) + 1024 * size_of::<EventType>())
+                .next_multiple_of(16)
+    );
+};
+
 // Android shares the Linux kernel's epoll ABI (uSockets' `epoll_kqueue.h` only
 // branches on `LIBUS_USE_EPOLL` vs `LIBUS_USE_KQUEUE`, not on libc).
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -55,8 +96,8 @@ pub type EventType = libc::kevent;
 #[cfg(windows)]
 pub type EventType = *mut c_void;
 
-/// Trait replacing Zig's `comptime Handler: anytype` with `@hasDecl` checks for
-/// optional `pre`/`post`. Implementors override `PRE`/`POST` if they have them.
+/// Loop handler trait with optional `pre`/`post` hooks. Implementors override
+/// `PRE`/`POST` if they have them.
 pub trait LoopHandler {
     const WAKEUP: unsafe extern "C" fn(*mut Loop);
     const PRE: Option<unsafe extern "C" fn(*mut Loop)> = None;
@@ -170,7 +211,6 @@ impl PosixLoop {
     }
 
     pub fn get() -> *mut Loop {
-        // TODO(port): wrap in a safe handle type in bun_uws (higher-level crate)
         c::uws_get_loop()
     }
 
@@ -192,7 +232,6 @@ impl PosixLoop {
         };
         assert!(!p.is_null(), "us_create_loop returned null");
         p
-        // TODO(port): wrap in a safe handle type in bun_uws (higher-level crate)
     }
 
     pub fn wakeup(&mut self) {
@@ -241,8 +280,6 @@ impl PosixLoop {
         unsafe { c::us_loop_close_all_groups(self) != 0 }
     }
 
-    // PORT NOTE: Zig `nextTick` took a `comptime deferCallback: fn(UserType) void` and
-    // synthesized a per-callsite `extern "C"` trampoline that casts `*anyopaque` → `UserType`.
     // Rust cannot monomorphize an `extern "C"` fn over a fn-pointer const generic on stable,
     // so callers provide the C-ABI trampoline directly.
     pub fn next_tick(
@@ -254,14 +291,14 @@ impl PosixLoop {
         unsafe { c::uws_loop_defer(self, user_data, defer_callback) };
     }
 
-    // TODO(port): same trampoline-synthesis limitation as `next_tick` — callers pass the
+    // Same trampoline-synthesis limitation as `next_tick` — callers pass the
     // C-ABI callback directly. The returned `Handler` stores it for later removal.
     //
     // Takes `this: *mut Self` (not `&mut self`) so the stored `Handler.loop_` inherits the
     // long-lived raw-pointer provenance from `us_create_loop`/`uws_get_loop`. Routing through
     // a `&mut self` reborrow would bound the stored pointer's provenance to this call, and any
     // subsequent `&mut`/`&` to the C-owned singleton would invalidate it under Stacked Borrows,
-    // making the later FFI write in `Handler::remove_*` UB. Mirrors Zig's `this: *PosixLoop`.
+    // making the later FFI write in `Handler::remove_*` UB.
     /// # Safety
     /// `this` must be the live C-allocated loop pointer returned by
     /// `us_create_loop`/`uws_get_loop` (not derived from a `&mut` reborrow).
@@ -318,10 +355,9 @@ impl PosixLoop {
     }
 }
 
-/// Replaces Zig `fn NewHandler(comptime UserType, comptime callback_fn) type`.
 /// Stores the loop ref and the C-ABI callback so it can be unregistered later.
 ///
-/// Stores `*mut Loop` (not `&Loop`) to mirror Zig's freely-aliasing `loop: *Loop`
+/// Stores `*mut Loop` (not `&Loop`)
 /// — the loop is C-owned/heap-allocated and the FFI remove calls mutate it, so a
 /// shared `&Loop` would make the `*const → *mut` cast UB when written through.
 pub struct Handler {
@@ -339,8 +375,8 @@ impl Handler {
     }
 
     pub fn remove_pre(&self) {
-        // PORT NOTE: Zig also called `uws_loop_removePostHandler` here (likely a bug
-        // upstream); preserving behavior verbatim.
+        // Intentionally calls `uws_loop_removePostHandler` here (likely an
+        // upstream bug); preserving longstanding behavior verbatim.
         // SAFETY: `loop_` is the original C-allocated raw pointer (from
         // `us_create_loop`/`uws_get_loop`) stored by `add_*_handler`, with provenance
         // that outlives this Handler and permits mutation; callback was previously registered.
@@ -374,7 +410,6 @@ impl WindowsLoop {
 
     pub fn get() -> *mut WindowsLoop {
         // SAFETY: uv::Loop::get() returns the libuv default loop; uws wraps it
-        // TODO(port): wrap in a safe handle type in bun_uws (higher-level crate)
         unsafe { c::uws_get_loop_with_native(uv::Loop::get() as *mut c_void) }
     }
 
@@ -456,7 +491,6 @@ impl WindowsLoop {
         };
         assert!(!p.is_null(), "us_create_loop returned null");
         p
-        // TODO(port): wrap in a safe handle type in bun_uws (higher-level crate)
     }
 
     pub fn run(&mut self) {
@@ -501,7 +535,7 @@ impl WindowsLoop {
         unsafe { c::us_loop_close_all_groups(self) != 0 }
     }
 
-    // TODO(port): see PosixLoop::next_tick — same trampoline-synthesis limitation.
+    // See PosixLoop::next_tick — same trampoline-synthesis limitation.
     pub fn next_tick(
         &mut self,
         user_data: *mut c_void,
@@ -524,11 +558,11 @@ impl WindowsLoop {
         unsafe { c::us_loop_free(this) };
     }
 
-    // TODO(port): see PosixLoop::add_post_handler — same trampoline-synthesis limitation.
+    // See PosixLoop::add_post_handler — same trampoline-synthesis limitation.
     // Takes `this: *mut Self` (not `&mut self`) so the stored `Handler.loop_` inherits the
     // long-lived raw-pointer provenance from `us_create_loop`/`uws_get_loop_with_native`
     // rather than a transient `&mut` reborrow (which Stacked Borrows would invalidate on the
-    // next access to the C-owned singleton). Mirrors Zig's `this: *WindowsLoop`.
+    // next access to the C-owned singleton).
     /// # Safety
     /// `this` must be the live C-allocated loop pointer returned by
     /// `us_create_loop`/`uws_get_loop_with_native` (not derived from a `&mut` reborrow).
@@ -626,4 +660,13 @@ mod c {
 // receiver would create two live `&mut Loop` to the same singleton (UB).
 pub use c::{us_loop_run, us_wakeup_loop};
 
-// ported from: src/uws_sys/Loop.zig
+unsafe extern "C" {
+    // safe: no args; clears the C side's thread-local loop pointer — no preconditions.
+    safe fn bun_clear_loop_at_thread_exit();
+}
+
+/// Clears the C side's thread-local loop pointer. Call when a thread that ran
+/// a uws loop (e.g. a Worker thread) exits.
+pub fn on_thread_exit() {
+    bun_clear_loop_at_thread_exit()
+}
diff --git a/src/uws_sys/Request.rs b/src/uws_sys/Request.rs
index cc5d5d6a5c5..122d9484f6d 100644
--- a/src/uws_sys/Request.rs
+++ b/src/uws_sys/Request.rs
@@ -2,12 +2,6 @@ use core::ffi::c_ushort;
 
 use crate::h3::Request as H3Request;
 
-// PORT NOTE: `dateForHeader` (Request.zig:62) is NOT ported here. Parsing an
-// HTTP date needs `bun_jsc::VirtualMachine` (T6); rather than hook upward, the
-// sole caller (`bun_runtime::server::FileRoute`) does
-// `req.header(name).and_then(parse_http_date)` itself — call site moved UP per
-// docs/PORTING.md §"Low crate needs to call high crate" option (a).
-
 /// Transport-agnostic request handle. Static/file routes (and RangeRequest)
 /// take this so the same handler body serves HTTP/1.1 and HTTP/3 without
 /// `anytype` — `inline else` keeps dispatch monomorphic.
@@ -136,5 +130,3 @@ mod c {
         ) -> usize;
     }
 }
-
-// ported from: src/uws_sys/Request.zig
diff --git a/src/uws_sys/Response.rs b/src/uws_sys/Response.rs
index ad7900e1ca9..6d51812af92 100644
--- a/src/uws_sys/Response.rs
+++ b/src/uws_sys/Response.rs
@@ -22,8 +22,7 @@ use bun_core::{BoundedArray, Fd};
 /// Remote socket address as returned by uWS. The IP text is copied into
 /// inline storage at construction.
 ///
-/// Canonical definition moved down from `bun_uws`
-/// (Zig: `uws.SocketAddress = struct { ip: []const u8, port: i32, is_ipv6: bool }`).
+/// Canonical definition moved down from `bun_uws`.
 /// Higher tiers (`bun_uws`, `bun_runtime`) re-export this as
 /// `pub use bun_uws_sys::SocketAddress;`.
 pub struct SocketAddress {
@@ -71,8 +70,7 @@ bun_opaque::opaque_ffi! {
 
 /// Opaque handle for `uws::Response<SSL>`.
 ///
-/// In Zig this is `pub fn NewResponse(ssl_flag: i32) type { return opaque { ... } }`.
-/// Rust models the comptime `ssl_flag` as a `const SSL: bool` parameter on an opaque
+/// The SSL flag is modeled as a `const SSL: bool` parameter on an opaque
 /// extern type (Nomicon pattern).
 #[repr(C)]
 pub struct Response<const SSL: bool> {
@@ -352,8 +350,7 @@ impl<const SSL: bool> Response<SSL> {
 
     /// Register an on-writable callback.
     ///
-    /// Zig takes `comptime handler` and bakes it into the trampoline at
-    /// monomorphization time. Rust models this by requiring `H` to be a
+    /// `H` must be a
     /// zero-sized type (function item or capture-less closure): the trampoline
     /// is monomorphized over `H` and conjures the ZST inside, so the user
     /// handler is baked in with no runtime storage.
@@ -520,17 +517,13 @@ impl<const SSL: bool> Response<SSL> {
         c::uws_res_end_stream(Self::ssl_flag(), self.as_raw(), close_connection)
     }
 
-    /// Run `handler` while the response is corked. Zig signature took
-    /// `comptime handler: anytype, args_tuple: ArgsTuple(@TypeOf(handler))`;
-    /// in Rust callers pass a closure capturing what would have been the args tuple.
-    // PORT NOTE: reshaped — `(handler, args_tuple)` collapsed to `FnOnce()`.
+    /// Run `handler` while the response is corked.
     pub fn corked<F: FnOnce()>(&mut self, f: F) {
         // Safe fn item: nested local thunk, only coerced to the C-ABI
         // fn-pointer type passed to C; body wraps its raw-ptr op explicitly.
         extern "C" fn handle<F: FnOnce()>(user_data: *mut c_void) {
             // SAFETY: user_data points at a stack `ManuallyDrop<F>` valid for this synchronous call.
             let f = unsafe { core::ptr::read(user_data.cast::<F>()) };
-            // PERF(port): was @call(.always_inline)
             f();
         }
         let mut f = core::mem::ManuallyDrop::new(f);
@@ -552,7 +545,6 @@ impl<const SSL: bool> Response<SSL> {
         extern "C" fn handle<U>(user_data: *mut c_void) {
             // SAFETY: user_data points at a stack Ctx<U> valid for this synchronous call.
             let ctx = unsafe { &*user_data.cast::<Ctx<U>>() };
-            // PERF(port): was @call(.always_inline)
             (ctx.0)(ctx.1);
         }
         let mut ctx: Ctx<U> = (handler, optional_data);
@@ -609,8 +601,7 @@ pub enum AnyResponse {
 }
 
 // Helper: dispatch to the underlying response, calling the same-named method on each
-// variant. The Zig `switch (this) { inline else => |resp| resp.method(args...) }`
-// monomorphizes per variant; we write the three arms out by hand.
+// variant. The three arms are written out by hand.
 //
 // The per-variant `*mut → &mut` deref is internalized via `OpaqueHandle`
 // (S019): each variant payload is a ZST opaque, so the deref is sound by
@@ -635,9 +626,8 @@ macro_rules! any_dispatch {
 }
 
 /// Stamp the per-variant ZST adapter triplet and register it via the matching
-/// `Response<SSL>` / `H3Response` `$method`. Mirrors Zig's hand-rolled
-/// `wrapper` structs in `Response.zig` (`onData`/`onWritable`/`onTimeout`/
-/// `onAborted`): each arm is a generic fn *item* monomorphized over `<U, H>`,
+/// `Response<SSL>` / `H3Response` `$method`.
+/// Each arm is a generic fn *item* monomorphized over `<U, H>`,
 /// so it is itself a ZST satisfying both the `Response<SSL>` bound
 /// (`Fn(*mut U, …)`) and the `H3Response` bound (`Fn(&mut U, …)`). The H3 arm
 /// bridges its `&mut U` to the body's uniform `*mut U` via `ptr::from_mut`.
@@ -757,8 +747,7 @@ impl AnyResponse {
         any_dispatch!(self, |r| r.state())
     }
 
-    // Zig: `pub inline fn init(response: anytype) AnyResponse` switching on @TypeOf.
-    // Rust models this as `From` impls below; keep `init` as a thin alias for diff parity.
+    // Thin alias for the `From` impls below.
     #[inline]
     pub fn init<T>(response: T) -> AnyResponse
     where
@@ -975,7 +964,7 @@ impl From<*mut H3Response> for AnyResponse {
 pub(crate) type H3Response = crate::h3::Response;
 
 bitflags::bitflags! {
-    /// Non-exhaustive bitset (`enum(u8) { ..., _ }` in Zig) — values may carry
+    /// Non-exhaustive bitset — values may carry
     /// unnamed bit combinations.
     #[repr(transparent)]
     #[derive(Clone, Copy, PartialEq, Eq)]
@@ -1186,5 +1175,3 @@ pub mod c {
         );
     }
 }
-
-// ported from: src/uws_sys/Response.zig
diff --git a/src/uws_sys/SocketContext.rs b/src/uws_sys/SocketContext.rs
index 9878da7d98d..6da8e2b317c 100644
--- a/src/uws_sys/SocketContext.rs
+++ b/src/uws_sys/SocketContext.rs
@@ -10,8 +10,7 @@ use bun_boringssl_sys::SSL_CTX;
 
 use crate::create_bun_socket_error_t;
 
-/// `[mtime_sec, mtime_nsec, size]` for the SSL cache-key digest (spec
-/// `SocketContext.zig:81`: `bun.sys.stat(path)` → `st.mtime() ++ st.size`).
+/// `[mtime_sec, mtime_nsec, size]` for the SSL cache-key digest.
 /// Body moved DOWN from `bun_sys` — it only needs `libc::stat`, which this
 /// crate already links, so the former link-time hook bought nothing. Returns
 /// `None` on stat failure (digest feeds zeros — `create_ssl_context` will then
@@ -84,8 +83,8 @@ fn stat_for_digest(path: &bun_core::ZStr) -> Option<[i64; 3]> {
     // `[sec_field, nsec_field, size]` — the digest only needs *some*
     // deterministic encoding of mtime, not the libuv POSIX-epoch split the
     // deleted `__bun_uws_stat_file` produced. The SSL-context cache keyed on
-    // this digest is in-memory process-lifetime only (spec `SocketContext.zig`
-    // — no on-disk persistence), so cross-version byte-compat of the key is
+    // this digest is in-memory process-lifetime only (no on-disk
+    // persistence), so cross-version byte-compat of the key is
     // irrelevant; only stability *within* a process matters.
     let ticks = (u64::from(ft.dwHighDateTime) << 32) | u64::from(ft.dwLowDateTime);
     let size = (u64::from(data.nFileSizeHigh) << 32) | u64::from(data.nFileSizeLow);
@@ -267,8 +266,7 @@ impl BunSocketContextOptions {
     }
 }
 
-/// Thin SHA-256 wrapper over the raw `bun_boringssl_sys` FFI so `digest()`
-/// reads the same as the Zig (`Sha256.init`/`update`/`final`). No higher-tier
+/// Thin SHA-256 wrapper over the raw `bun_boringssl_sys` FFI. No higher-tier
 /// `bun_boringssl::Sha256` exists yet; this stays local until one does.
 struct Sha256(core::mem::MaybeUninit<bun_boringssl_sys::SHA256_CTX>);
 impl Sha256 {
@@ -308,5 +306,3 @@ pub mod c {
         pub safe fn us_ssl_ctx_live_count() -> c_long;
     }
 }
-
-// ported from: src/uws_sys/SocketContext.zig
diff --git a/src/uws_sys/SocketGroup.rs b/src/uws_sys/SocketGroup.rs
index c597800defa..d1c4841aafa 100644
--- a/src/uws_sys/SocketGroup.rs
+++ b/src/uws_sys/SocketGroup.rs
@@ -97,10 +97,7 @@ impl SocketGroup {
     /// Initialise an embedded group. `owner_ptr` is what `group.owner::<T>()`
     /// recovers inside handlers — pass the embedding struct so dispatch can
     /// find it from a raw `*us_socket_t`.
-    // TODO(port): Zig accepted `owner_ptr: anytype` (any single-item pointer or
-    // null) with comptime @typeInfo validation. Rust callers cast at the call
-    // site; consider a typed `init_with_owner<T>(&mut self, ..., owner: &mut T)`
-    // helper if ergonomics warrant.
+    // Callers cast to `*mut c_void` at the call site.
     pub fn init(&mut self, loop_: *mut Loop, vt: Option<&'static VTable>, owner_ptr: *mut c_void) {
         // SAFETY: C initializes all fields of `self` in-place; `self` is a valid
         // `#[repr(C)]` slot embedded in the caller.
@@ -117,7 +114,7 @@ impl SocketGroup {
         }
     }
 
-    // PORT NOTE: not `impl Drop`. SocketGroup is `#[repr(C)]`, embedded
+    // Not `impl Drop`. SocketGroup is `#[repr(C)]`, embedded
     // by-value in its owner, and its lifecycle is FFI-managed (C unlinks it
     // from the loop). PORTING.md's #[repr(C)]-across-FFI exception applies:
     // expose `unsafe fn destroy(*mut Self)` and have the owner call it
@@ -380,5 +377,3 @@ unsafe extern "C" {
         fds: *mut [LIBUS_SOCKET_DESCRIPTOR; 2],
     ) -> *mut us_socket_t;
 }
-
-// ported from: src/uws_sys/SocketGroup.zig
diff --git a/src/uws_sys/SocketKind.rs b/src/uws_sys/SocketKind.rs
index 8ef12d9cc60..fa2babc2061 100644
--- a/src/uws_sys/SocketKind.rs
+++ b/src/uws_sys/SocketKind.rs
@@ -26,7 +26,7 @@ pub enum SocketKind {
     /// only known at runtime (uWS C++ via per-App vtable, tests).
     Dynamic,
 
-    // ── Bun.connect / Bun.listen (src/runtime/api/bun/socket.zig) ──────────
+    // ── Bun.connect / Bun.listen ───────────────────────────────────────────
     BunSocketTcp,
     BunSocketTls,
     /// Server-accepted socket; ext is the `*Listener` so onCreate can attach
@@ -34,7 +34,7 @@ pub enum SocketKind {
     BunListenerTcp,
     BunListenerTls,
 
-    // ── HTTP client thread (src/http/HTTPContext.zig) ─────────────────────
+    // ── HTTP client thread (src/http/HTTPContext.rs) ──────────────────────
     HttpClient,
     HttpClientTls,
 
@@ -65,8 +65,7 @@ pub enum SocketKind {
 
 impl SocketKind {
     /// Checked conversion from the raw `u8` returned by C (`us_socket_kind`).
-    /// Mirrors Zig's `@enumFromInt`, which traps on out-of-range values in
-    /// safe builds. An invalid discriminant in a `#[repr(u8)]` enum is
+    /// An invalid discriminant in a `#[repr(u8)]` enum is
     /// immediate UB in Rust, so this is an exhaustive match — LLVM folds the
     /// contiguous arms to a single range-check + reinterpret.
     #[inline]
@@ -118,8 +117,7 @@ impl SocketKind {
 }
 
 // `unsigned char kind` on us_socket_t — full byte, not the flags bitfield.
-// Zig: `comptime bun.assert(@typeInfo(SocketKind).@"enum".fields.len <= 256)`.
-// In Rust, `#[repr(u8)]` already refuses to compile with >256 variants, so the
+// `#[repr(u8)]` already refuses to compile with >256 variants, so the
 // invariant is enforced by the type system; no explicit assert needed.
 
 /// The four kinds whose handlers live in C++ are also referenced from C++
@@ -136,5 +134,3 @@ pub(crate) static BUN_SOCKET_KIND_UWS_HTTP_TLS: u8 = SocketKind::UwsHttpTls as u
 pub(crate) static BUN_SOCKET_KIND_UWS_WS: u8 = SocketKind::UwsWs as u8;
 #[unsafe(no_mangle)]
 pub(crate) static BUN_SOCKET_KIND_UWS_WS_TLS: u8 = SocketKind::UwsWsTls as u8;
-
-// ported from: src/uws_sys/SocketKind.zig
diff --git a/src/uws_sys/Timer.rs b/src/uws_sys/Timer.rs
index 8e21c9fda2f..0dcfa09ca71 100644
--- a/src/uws_sys/Timer.rs
+++ b/src/uws_sys/Timer.rs
@@ -30,7 +30,6 @@ impl Timer {
             )
         };
         NonNull::new(t).unwrap_or_else(|| {
-            // TODO(port): use bun_sys errno accessor instead of std::io
             panic!(
                 "us_create_timer: returned null: {}",
                 std::io::Error::last_os_error().raw_os_error().unwrap_or(0)
@@ -51,7 +50,6 @@ impl Timer {
             )
         };
         NonNull::new(t).unwrap_or_else(|| {
-            // TODO(port): use bun_sys errno accessor instead of std::io
             panic!(
                 "us_create_timer: returned null: {}",
                 std::io::Error::last_os_error().raw_os_error().unwrap_or(0)
@@ -67,7 +65,7 @@ impl Timer {
         repeat_ms: i32,
     ) {
         // SAFETY: ext storage was allocated with size_of::<T>() in create();
-        // @setRuntimeSafety(false) in Zig — caller guarantees T matches.
+        // caller guarantees T matches.
         unsafe {
             us_timer_set(self, cb, ms, repeat_ms);
             let value_ptr = us_timer_ext(self);
@@ -75,7 +73,7 @@ impl Timer {
         }
     }
 
-    // PORT NOTE: not `impl Drop` — FFI opaque handle with a const-generic param;
+    // Not `impl Drop` — FFI opaque handle with a const-generic param;
     // destruction is an explicit C call and Drop cannot take parameters. Per PORTING.md
     // FFI-handle exception, expose `unsafe fn close(*mut Self)` instead of `deinit(&mut self)`.
     pub unsafe fn close<const FALLTHROUGH: bool>(this: *mut Self) {
@@ -95,17 +93,15 @@ impl Timer {
         }
     }
 
-    // PORT NOTE: Zig name is `as`, which is a Rust keyword.
+    // Named `as_` because `as` is a Rust keyword.
     pub fn as_<T>(&mut self) -> T {
         unsafe {
-            // SAFETY: @setRuntimeSafety(false) in Zig — reinterpret the ext slot
-            // (`*?*anyopaque`) as `*?T`, deref, unwrap. The slot was allocated
-            // with `size_of::<T>()` and written via [`set`] as a bare `T`, so
-            // read it as `T` directly. Zig's `?*T` is one word with a null
-            // niche, but Rust's `Option<*mut T>` is two words — wrapping in
-            // `Option<T>` here over-reads and misinterprets the bytes. Callers
-            // pass pointer-ish `T` and tolerate a (debug-asserted) null read
-            // exactly as Zig's `.?` would.
+            // SAFETY: the ext slot was allocated with `size_of::<T>()` and
+            // written via [`set`] as a bare `T`, so read it as `T` directly.
+            // Wrapping in `Option<T>` here would over-read and misinterpret
+            // the bytes (`Option<*mut T>` has no niche, so it is two words
+            // while the slot is one). Callers pass pointer-ish `T` and
+            // tolerate a (debug-asserted) null read.
             let slot: *mut T = us_timer_ext(self).cast();
             slot.read()
         }
@@ -130,5 +126,3 @@ unsafe extern "C" {
     );
     pub safe fn us_timer_loop(t: &mut Timer) -> *mut Loop;
 }
-
-// ported from: src/uws_sys/Timer.zig
diff --git a/src/uws_sys/WebSocket.rs b/src/uws_sys/WebSocket.rs
index e73c1f24975..21bb0da8756 100644
--- a/src/uws_sys/WebSocket.rs
+++ b/src/uws_sys/WebSocket.rs
@@ -7,11 +7,11 @@ use crate::thunk;
 use crate::{Opcode, Request, SendStatus, Socket, WebSocketUpgradeContext, uws_res};
 
 // ─────────────────────────────────────────────────────────────────────────────
-// NewWebSocket(comptime ssl_flag) type → opaque handle, monomorphized on SSL
+// WebSocket — opaque handle, monomorphized on the SSL flag
 // ─────────────────────────────────────────────────────────────────────────────
 
 /// Opaque uWS WebSocket handle, parameterized by the SSL flag passed to the C
-/// shims. In Zig this is `NewWebSocket(ssl_flag)` returning `opaque {}`.
+/// shims.
 #[repr(C)]
 pub struct NewWebSocket<const SSL_FLAG: i32> {
     _p: core::cell::UnsafeCell<[u8; 0]>,
@@ -36,8 +36,8 @@ impl<const SSL_FLAG: i32> NewWebSocket<SSL_FLAG> {
     /// Caller must guarantee the user data was set to a `*mut T` for this socket.
     #[inline]
     pub unsafe fn as_<T>(&mut self) -> Option<&mut T> {
-        // SAFETY: mirrors Zig `@setRuntimeSafety(false)` + ptrCast/alignCast of
-        // the opaque user-data pointer. Caller upholds the type invariant.
+        // SAFETY: casts the opaque user-data pointer to `*mut T`; caller
+        // upholds the type invariant.
         unsafe {
             let p = c::uws_ws_get_user_data(SSL_FLAG, self.raw());
             p.cast::<T>().as_mut()
@@ -106,12 +106,8 @@ impl<const SSL_FLAG: i32> NewWebSocket<SSL_FLAG> {
 
     /// Run `callback(ctx)` while the socket is corked.
     ///
-    /// Zig: `cork(ctx: anytype, comptime callback: anytype)` — the callback is
-    /// monomorphized into an `extern "C"` trampoline. Rust cannot const-generic
-    /// over a fn value, so we tunnel `(ctx, callback)` through the user-data
-    /// pointer instead.
-    // TODO(perf): comptime-callback monomorphization — a per-callsite
-    // `extern "C" fn` would avoid the indirect call.
+    /// Rust cannot const-generic over a fn value, so we tunnel
+    /// `(ctx, callback)` through the user-data pointer.
     pub fn cork<C>(&mut self, ctx: &mut C, callback: fn(&mut C)) {
         // Safe fn item: nested local thunk, only coerced to the C-ABI
         // fn-pointer type passed to C; body wraps its raw-ptr ops explicitly.
@@ -119,7 +115,6 @@ impl<const SSL_FLAG: i32> NewWebSocket<SSL_FLAG> {
             // SAFETY: user_data is &mut (ptr, fn) on the caller's stack frame,
             // which outlives the synchronous uws_ws_cork call.
             let data = unsafe { bun_core::callback_ctx::<(*mut C, fn(&mut C))>(user_data) };
-            // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
             // SAFETY: `data.0` was set from `&mut C` on the enclosing `cork`
             // stack frame, which outlives this synchronous callback.
             (data.1)(unsafe { &mut *data.0 });
@@ -188,10 +183,10 @@ impl<const SSL_FLAG: i32> NewWebSocket<SSL_FLAG> {
         }
     }
 
-    pub fn get_buffered_amount(&mut self) -> u32 {
-        // TODO(port): C decl returns usize but Zig wrapper types this as u32 —
-        // verify which is correct.
-        u32::try_from(c::uws_ws_get_buffered_amount(SSL_FLAG, self.raw())).unwrap()
+    pub fn get_buffered_amount(&mut self) -> usize {
+        // The C shim returns `size_t` (libuwsockets.cpp `uws_ws_get_buffered_amount`);
+        // pass it through untruncated, matching `AnyWebSocket::get_buffered_amount`.
+        c::uws_ws_get_buffered_amount(SSL_FLAG, self.raw())
     }
 
     pub fn get_remote_address<'a>(&mut self, buf: &'a mut [u8]) -> &'a mut [u8] {
@@ -244,22 +239,10 @@ impl AnyWebSocket {
         }
     }
 
-    /// # Safety
-    /// Caller must guarantee the user data was set to a `*mut T` for this socket.
-    #[inline]
-    pub unsafe fn as_<T>(self) -> Option<&'static mut T> {
-        let (ssl, ws) = self.split();
-        // SAFETY: see NewWebSocket::as_. Lifetime is tied to the C-owned socket
-        // (effectively 'static from Rust's view; uWS frees on close).
-        // TODO(port): lifetime — returning an unbounded `&mut` is a placeholder; Phase
-        // B should scope this to the callback frame or return *mut T.
-        unsafe { c::uws_ws_get_user_data(ssl, ws).cast::<T>().as_mut() }
-    }
-
     /// Raw user-data pointer cast to `*mut T` (NULL if unset).
     ///
-    /// PORT NOTE (noalias re-entrancy): the `WebSocketHandler` dispatch
-    /// trampolines use this instead of `as_::<T>()` so the handler frame holds
+    /// Noalias re-entrancy: the `WebSocketHandler` dispatch
+    /// trampolines use this (not a `&mut`-returning accessor) so the handler frame holds
     /// a raw `*mut T`, not a `noalias` `&mut T`. A JS callback fired from inside
     /// the handler can re-derive `&mut T` via the JS wrapper's `m_ptr` (e.g.
     /// `ws.close()` → `on_close` → `flags.set_closed(true)`); a live `noalias`
@@ -329,7 +312,7 @@ impl AnyWebSocket {
         unsafe { c::uws_ws_end(ssl, ws, code, message.as_ptr(), message.len()) }
     }
 
-    // TODO(port): comptime-callback monomorphization — see NewWebSocket::cork.
+    // See NewWebSocket::cork — same fn-pointer tunneling.
     pub fn cork<C>(self, ctx: &mut C, callback: fn(&mut C)) {
         // Safe fn item: nested local thunk, only coerced to the C-ABI
         // fn-pointer type passed to C; body wraps its raw-ptr ops explicitly.
@@ -337,7 +320,6 @@ impl AnyWebSocket {
             // SAFETY: user_data points at a stack tuple alive for the duration
             // of the synchronous uws_ws_cork call.
             let data = unsafe { bun_core::callback_ctx::<(*mut C, fn(&mut C))>(user_data) };
-            // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
             // SAFETY: `data.0` was set from `&mut C` on the enclosing `cork`
             // stack frame, which outlives this synchronous callback.
             (data.1)(unsafe { &mut *data.0 });
@@ -400,7 +382,6 @@ impl AnyWebSocket {
         opcode: Opcode,
         compress: bool,
     ) -> bool {
-        // Zig: switch (ssl) { inline else => |tls| uws.NewApp(tls).publishWithOptions(...) }
         // S012: `NewApp<SSL>` is a ZST opaque — route the `*mut → &mut` deref
         // through `bun_opaque::opaque_deref_mut` (caller still vouches that
         // `app` is the matching `uws_app_t*`; the `ssl` flag selects the
@@ -502,12 +483,12 @@ impl Default for WebSocketBehavior {
     }
 }
 
-/// User-data type stored on a uWS WebSocket. Replaces Zig's `comptime Type`
-/// parameter to `WebSocketBehavior.Wrap`.
+/// User-data type stored on a uWS WebSocket.
 ///
 /// `HAS_ON_*` consts replace `@hasDecl(Type, "...")` — set to `false` to leave
 /// the corresponding C callback `null`.
-/// PORT NOTE (noalias re-entrancy): the `on_*` methods take `this: *mut Self`,
+///
+/// Noalias re-entrancy: the `on_*` methods take `this: *mut Self`,
 /// NOT `&mut self`. The handler body re-enters JS (`ws.send()`, `ws.close()`,
 /// promise callbacks…); JS can call back into this same socket via the wrapper
 /// object's `m_ptr`, re-deriving a `&mut Self` and mutating its fields. A live
@@ -542,8 +523,7 @@ pub trait WebSocketHandler: Sized + 'static {
     unsafe fn on_close(this: *mut Self, ws: AnyWebSocket, code: i32, message: &[u8]);
 }
 
-/// Server type that handles the HTTP→WS upgrade. Replaces Zig's
-/// `comptime ServerType` parameter to `WebSocketBehavior.Wrap`.
+/// Server type that handles the HTTP→WS upgrade.
 pub trait WebSocketUpgradeServer<const SSL: bool>: Sized + 'static {
     /// # Safety
     /// `this` is the raw user-data pointer passed to `uws_ws()` at registration
@@ -563,7 +543,6 @@ pub trait WebSocketUpgradeServer<const SSL: bool>: Sized + 'static {
     );
 }
 
-/// Zig: `WebSocketBehavior.Wrap(ServerType, Type, ssl)` — a type containing
 /// `extern "C"` trampolines that downcast user-data and forward to `Type`'s
 /// methods, plus `apply()` to fill a `WebSocketBehavior`.
 pub struct Wrap<Server, T, const SSL: bool>(PhantomData<(Server, T)>);
@@ -575,7 +554,6 @@ where
 {
     #[inline(always)]
     fn make_ws(raw_ws: *mut RawWebSocket) -> AnyWebSocket {
-        // Zig: @unionInit(AnyWebSocket, if (ssl) "ssl" else "tcp", @ptrCast(raw_ws))
         if SSL {
             AnyWebSocket::Ssl(raw_ws)
         } else {
@@ -595,7 +573,6 @@ where
         if this.is_null() {
             return;
         }
-        // PERF(port): was @call(bun.callmod_inline, ...) — profile if hot.
         // SAFETY: user data was set to *mut T at upgrade time.
         unsafe { T::on_open(this, ws) };
     }
@@ -872,5 +849,3 @@ pub mod c {
         ) -> usize;
     }
 }
-
-// ported from: src/uws_sys/WebSocket.zig
diff --git a/src/uws_sys/h3.rs b/src/uws_sys/h3.rs
index 6f3e3867836..1e454c92610 100644
--- a/src/uws_sys/h3.rs
+++ b/src/uws_sys/h3.rs
@@ -1,6 +1,6 @@
-//! HTTP/3 bindings. Method names mirror NewApp/NewResponse 1:1 so the
-//! comptime callers in server.zig and the `inline else` arms in AnyResponse
-//! see the same surface regardless of transport.
+//! HTTP/3 bindings. Method names mirror NewApp/NewResponse 1:1 so callers
+//! (including the AnyResponse dispatch arms) see the same surface regardless
+//! of transport.
 
 use core::ffi::{c_char, c_int, c_void};
 use core::ptr;
@@ -93,8 +93,7 @@ impl Request {
     }
     /// Iterate all request headers.
     ///
-    /// Zig takes `comptime cb` and bakes it into the trampoline at
-    /// monomorphization time. Rust models this by requiring `H` to be a
+    /// `H` must be a
     /// zero-sized type (function item or capture-less closure): the trampoline
     /// is monomorphized over `H` and conjures the ZST inside, so the user
     /// handler is baked in with no runtime storage.
@@ -353,7 +352,7 @@ impl Response {
         c::uws_h3_res_on_data(self, None, ptr::null_mut())
     }
     pub fn corked(&mut self, handler: impl FnOnce()) {
-        // H3 has no corking; the Zig version just calls the handler immediately.
+        // H3 has no corking; call the handler immediately.
         let _ = self;
         handler();
     }
@@ -367,7 +366,6 @@ impl Response {
         extern "C" fn cb<UD>(p: *mut c_void) {
             // SAFETY: p points at a stack Ctx<UD> valid for this synchronous call.
             let ctx = unsafe { &*p.cast::<Ctx<UD>>() };
-            // PERF(port): was @call(.always_inline)
             (ctx.0)(ctx.1);
         }
         let mut ctx: Ctx<UD> = (handler, ud);
@@ -404,7 +402,7 @@ bun_core::impl_tag_error!(AddServerNameError);
 /// Stamps one `pub fn $name<UD, H>(&mut self, p, ud, h)` per HTTP verb,
 /// each forwarding to [`App::route`] with the matching [`RouteKind`].
 /// `connect`/`trace` are intentionally omitted — h3 exposes those only via
-/// [`App::method`], matching h3.zig.
+/// [`App::method`].
 macro_rules! h3_route_methods {
     ($($name:ident => $kind:ident),* $(,)?) => {$(
         pub fn $name<UD, H>(&mut self, p: &[u8], ud: *mut UD, h: H)
@@ -466,7 +464,6 @@ impl App {
                 thunk::zst::<H>()(ud, thunk::handle_mut(req), thunk::handle_mut(res));
             }
         }
-        // PERF(port): was comptime enum dispatch — profile if it shows up on a hot path
         let f = match which {
             RouteKind::Get => c::uws_h3_app_get,
             RouteKind::Post => c::uws_h3_app_post,
@@ -807,5 +804,3 @@ mod c {
         );
     }
 }
-
-// ported from: src/uws_sys/h3.zig
diff --git a/src/uws_sys/lib.rs b/src/uws_sys/lib.rs
index 35aa9b2c219..8f80078957b 100644
--- a/src/uws_sys/lib.rs
+++ b/src/uws_sys/lib.rs
@@ -36,7 +36,7 @@ pub type SslCtx = bun_boringssl_sys::SSL_CTX;
 
 /// `struct us_bun_verify_error_t` — TLS handshake verification result.
 ///
-/// Field is named `error_no` (mirrors the Zig `error_no`) so the Node-compat
+/// Field is named `error_no` so the Node-compat
 /// `verifyError`/`authorizationError` paths read naturally; the C struct's
 /// first member is `int error` and the layout is identical.
 #[repr(C)]
@@ -139,7 +139,7 @@ impl Opcode {
     pub const Close: Opcode = Opcode(8);
     pub const Ping: Opcode = Opcode(9);
     pub const Pong: Opcode = Opcode(10);
-    // Upper-case aliases for callers that ported the Zig screaming-snake names
+    // Upper-case aliases for callers that use the screaming-snake names
     // (`uWS::OpCode::TEXT` etc.). Same bit values; both spellings are accepted
     // so the merge of `bun_uws::Opcode` into this type doesn't ripple.
     pub const CONTINUATION: Opcode = Opcode(0);
@@ -179,7 +179,7 @@ bun_core::opaque_extern!(
 // `extern "C"` symbols which the runtime crate exports with `#[no_mangle]`.
 // This is the same link-time-dispatch pattern as other `*_sys` crates use for
 // their C backends — only here the "backend" is Rust in a higher tier.
-// PORT NOTE: signatures mirror `src/runtime/socket/UpgradedDuplex.rs`.
+// Signatures must stay in sync with `src/runtime/socket/UpgradedDuplex.rs`.
 // SAFETY (safe fn): `UpgradedDuplex` is an `opaque_extern!` ZST handle (`!Freeze`
 // via `UnsafeCell`), so `&`/`&mut` carry no `readonly`/`noalias` and are
 // ABI-identical to non-null `*const`/`*mut`. Shims taking only the handle +
@@ -264,7 +264,7 @@ impl UpgradedDuplex {
 // Same link-time-dispatch as `UpgradedDuplex` above: the real
 // `WindowsNamedPipe` lives in `bun_runtime::socket`; this opaque handle
 // forwards to `extern "C"` symbols that the runtime crate exports with
-// `#[no_mangle]`. Surface mirrors `src/jsc/api/bun/socket.zig WindowsNamedPipe`.
+// `#[no_mangle]`.
 #[cfg(windows)]
 unsafe extern "C" {
     safe fn WindowsNamedPipe__ssl_error(this: &WindowsNamedPipe) -> us_bun_verify_error_t;
@@ -420,7 +420,7 @@ pub use socket_group::SocketGroup;
 pub use us_socket::{CloseCode, us_socket_stream_buffer_t, us_socket_t};
 pub use web_socket::{AnyWebSocket, RawWebSocket, WebSocketBehavior};
 
-/// Zig `NewApp(ssl)` / `NewApp(ssl).Response` aliases.
+/// Legacy aliases for `App<SSL>` / `Response<SSL>`.
 pub type NewApp<const SSL: bool> = app::App<SSL>;
 pub type NewAppResponse<const SSL: bool> = response::Response<SSL>;
 pub type Socket = us_socket::us_socket_t;
diff --git a/src/uws_sys/libuwsockets_h3.cpp b/src/uws_sys/libuwsockets_h3.cpp
index c1838fbdbb5..a84d7da66de 100644
--- a/src/uws_sys/libuwsockets_h3.cpp
+++ b/src/uws_sys/libuwsockets_h3.cpp
@@ -1,5 +1,5 @@
-// HTTP/3 C ABI for Zig. Mirrors the uws_* surface in libuwsockets.cpp 1:1
-// (same parameter shapes, same callback signatures) so the Zig side can
+// HTTP/3 C ABI. Mirrors the uws_* surface in libuwsockets.cpp 1:1
+// (same parameter shapes, same callback signatures) so the caller can
 // pattern-match NewApp/NewResponse without protocol-specific branches.
 // Kept in its own TU so HTTP/1.1 and HTTP/3 stay file-level separable.
 
@@ -223,7 +223,7 @@ bool uws_h3_res_is_corked(uws_h3_res_t*) { return false; }
 uint64_t uws_h3_res_get_remote_address_info(uws_h3_res_t* res, const char** dest, int* port, bool* is_ipv6)
 {
     /* Mirror uws_res_get_remote_address_info: stringify with inet_ntop so the
-     * Zig side gets a text slice, not raw in_addr bytes. */
+     * caller gets a text slice, not raw in_addr bytes. */
     static thread_local char b[64];
     int len = 0, ipv6 = 0;
     us_quic_socket_t* qs = us_quic_stream_socket((us_quic_stream_t*)res);
@@ -257,7 +257,7 @@ bool uws_h3_req_is_ancient(uws_h3_req_t*) { return false; }
 bool uws_h3_req_get_yield(uws_h3_req_t* req) { return ((Http3Request*)req)->getYield(); }
 void uws_h3_req_set_yield(uws_h3_req_t* req, bool y) { ((Http3Request*)req)->setYield(y); }
 
-/* Zig declares these as [*]const u8 (non-null many-pointer); a default-
+/* The FFI contract requires a non-null pointer; a default-
  * constructed string_view has data() == nullptr, so normalise empties. */
 static inline size_t ffi_sv(std::string_view v, const char** dest)
 {
diff --git a/src/uws_sys/quic.rs b/src/uws_sys/quic.rs
index 617eec7e2f1..53adc9c8ae6 100644
--- a/src/uws_sys/quic.rs
+++ b/src/uws_sys/quic.rs
@@ -1,7 +1,7 @@
 //! Rust bindings for the lsquic-backed QUIC transport in
 //! `packages/bun-usockets/src/quic.{c,h}`. One opaque per C handle; the
 //! HTTP/3 server uses these via the C++ uWS layer (`uws.H3`), the HTTP/3
-//! fetch client (`src/http/H3Client.zig`) uses them directly.
+//! fetch client (`src/http/H3Client.rs`) uses them directly.
 //!
 //! Lifetimes: a `Context` outlives every `Socket` on it; a `Socket`
 //! outlives every `Stream` on it. `Socket`/`Stream` pointers are valid
@@ -36,5 +36,3 @@ unsafe extern "C" {
 pub fn global_init() {
     us_quic_global_init()
 }
-
-// ported from: src/uws_sys/quic.zig
diff --git a/src/uws_sys/quic/Context.rs b/src/uws_sys/quic/Context.rs
index 5f7880ddb8b..880c6091783 100644
--- a/src/uws_sys/quic/Context.rs
+++ b/src/uws_sys/quic/Context.rs
@@ -80,9 +80,9 @@ pub enum ConnectResult {
 impl Context {
     /// # Safety
     /// `loop_` must point to a live `us_loop_t`. Takes a raw pointer (not `&mut Loop`)
-    /// because the Loop is shared across every context/socket/timer on the thread —
-    /// Zig `*uws.Loop` freely aliases — so requiring `&mut` would force callers to
-    /// assert uniqueness that does not hold.
+    /// because the Loop is shared across every context/socket/timer on the thread,
+    /// so requiring `&mut` would force callers to assert uniqueness that does not
+    /// hold.
     #[inline]
     pub unsafe fn create_client(
         loop_: *mut Loop,
@@ -98,7 +98,7 @@ impl Context {
     #[inline]
     pub fn r#loop(&mut self) -> *mut Loop {
         // Returns a raw pointer because the Loop is shared across every
-        // context/socket/timer on the thread (Zig `*uws.Loop` freely aliases) —
+        // context/socket/timer on the thread —
         // materializing `&mut Loop` here would assert uniqueness we cannot
         // guarantee.
         us_quic_socket_context_loop(self)
@@ -170,5 +170,3 @@ impl Context {
         us_quic_socket_context_on_stream_close(self, cb)
     }
 }
-
-// ported from: src/uws_sys/quic/Context.zig
diff --git a/src/uws_sys/quic/Header.rs b/src/uws_sys/quic/Header.rs
index ba8efc0f67d..c293c7242a4 100644
--- a/src/uws_sys/quic/Header.rs
+++ b/src/uws_sys/quic/Header.rs
@@ -53,10 +53,11 @@ impl Header {
 }
 
 /// `enum lsqpack_tnv`. Only the entries a request encoder actually emits are
-/// named; the rest are still reachable via `Qpack::from_raw`.
-// TODO(port): Zig `enum(u8) { ... _ }` is non-exhaustive — unnamed u8 values
-// are valid. If callers ever construct unnamed indices, switch to
-// `#[repr(transparent)] pub struct Qpack(u8)` with associated consts.
+/// named (the C enum has more). This closed enum is only ever converted *to*
+/// the C value (`idx as c_int` in [`Header::init`]), never constructed from a
+/// raw `u8`, so the unnamed indices being unrepresentable is fine. If a
+/// decoder ever needs to construct arbitrary indices, switch to
+/// `#[repr(transparent)] pub struct Qpack(u8)` with associated consts.
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum Qpack {
@@ -120,7 +121,7 @@ impl Qpack {
         // key is ≤ 19 bytes, so anything longer is a guaranteed miss.
         let (buf, len) = bun_core::strings::ascii_lowercase_buf::<19>(name)?;
         let lower = &buf[..len];
-        // PERF(port): length-gated match instead of phf::Map. 34 keys spread
+        // PERF: length-gated match instead of phf::Map. 34 keys spread
         // over 14 distinct lengths (max 5 per bucket, first bytes mostly
         // unique within a bucket), so the outer length dispatch rejects most
         // misses on a single usize compare and the inner byte-slice match
@@ -340,5 +341,3 @@ mod classify_tests {
         }
     }
 }
-
-// ported from: src/uws_sys/quic/Header.zig
diff --git a/src/uws_sys/quic/PendingConnect.rs b/src/uws_sys/quic/PendingConnect.rs
index 892c2cea215..aa3f6f096d6 100644
--- a/src/uws_sys/quic/PendingConnect.rs
+++ b/src/uws_sys/quic/PendingConnect.rs
@@ -36,5 +36,3 @@ impl PendingConnect {
         us_quic_pending_connect_cancel(self)
     }
 }
-
-// ported from: src/uws_sys/quic/PendingConnect.zig
diff --git a/src/uws_sys/quic/Socket.rs b/src/uws_sys/quic/Socket.rs
index 66881e0fa92..692510ffec0 100644
--- a/src/uws_sys/quic/Socket.rs
+++ b/src/uws_sys/quic/Socket.rs
@@ -57,7 +57,7 @@ impl Socket {
     pub fn ext<T>(&mut self) -> &mut Option<NonNull<T>> {
         // SAFETY: us_quic_socket_ext returns conn_ext_size bytes co-allocated with
         // the socket, sized and aligned for a single nullable-pointer slot.
-        // Option<NonNull<T>> is niche-optimized to the same layout as Zig's `?*T`.
+        // Option<NonNull<T>> is niche-optimized to a single nullable pointer.
         // Uniqueness: the ext bytes are caller-only storage that the C library
         // never reads or writes, and every Rust access goes through this method
         // behind `&mut self`; the elided return lifetime reborrows `self`, so the
@@ -65,5 +65,3 @@ impl Socket {
         unsafe { &mut *us_quic_socket_ext(self).cast::<Option<NonNull<T>>>() }
     }
 }
-
-// ported from: src/uws_sys/quic/Socket.zig
diff --git a/src/uws_sys/quic/Stream.rs b/src/uws_sys/quic/Stream.rs
index a986ed37db3..4157d2c22f8 100644
--- a/src/uws_sys/quic/Stream.rs
+++ b/src/uws_sys/quic/Stream.rs
@@ -39,8 +39,7 @@ impl Stream {
         // connection shared by every stream on it* — two live &mut Stream on the
         // same conn calling .socket() (or a conn-level callback already holding
         // &mut Socket) would otherwise yield aliasing &mut Socket, which is UB.
-        // Mirrors Zig's `?*Socket`; callers reborrow locally under their own
-        // SAFETY proof.
+        // Callers reborrow locally under their own SAFETY proof.
         NonNull::new(us_quic_stream_socket(self))
     }
 
@@ -67,7 +66,7 @@ impl Stream {
 
     pub fn ext<T>(&mut self) -> &mut Option<NonNull<T>> {
         // SAFETY: self is a valid us_quic_stream_t; ext slot is pointer-sized & pointer-aligned,
-        // and Option<NonNull<T>> has the same layout as Zig's `?*T` (nullable pointer).
+        // and Option<NonNull<T>> has nullable-pointer layout.
         // Aliasing: the ext slot is disjoint storage returned by C (not overlapping the
         // zero-sized opaque `Stream` handle), and the returned &mut borrows from &mut self
         // so no second &mut to the slot can be obtained while this one is live.
@@ -101,5 +100,3 @@ impl Stream {
         }
     }
 }
-
-// ported from: src/uws_sys/quic/Stream.zig
diff --git a/src/uws_sys/socket.rs b/src/uws_sys/socket.rs
index 9ad6723baab..356b8f32271 100644
--- a/src/uws_sys/socket.rs
+++ b/src/uws_sys/socket.rs
@@ -1,13 +1,13 @@
 //! High-level socket wrapper over `us_socket_t` / `ConnectingSocket` /
 //! `UpgradedDuplex` / `WindowsNamedPipe`.
 //!
-//! THIS IS THE ONE CANONICAL PORT of `src/uws_sys/socket.zig`. `bun_uws`
+//! THIS IS THE ONE CANONICAL IMPLEMENTATION. `bun_uws`
 //! re-exports everything here; do NOT add a parallel `InternalSocket` /
 //! `NewSocketHandler` in `bun_uws` again — the earlier "thin placeholder"
 //! that grew full bodies there has been deleted.
 //!
-//! Shape: `InternalSocket` is a `Copy` tagged raw pointer (Zig passed
-//! `ThisSocket` by value through the entire HTTP-client state machine), all
+//! Shape: `InternalSocket` is a `Copy` tagged raw pointer (passed by value
+//! through the entire HTTP-client state machine), all
 //! `NewSocketHandler` methods take `&self`, and the `#[cfg(windows)]` Pipe
 //! split is owned exactly once by the `on_socket!` macro below.
 
@@ -30,7 +30,7 @@ bun_core::declare_scope!(uws, visible);
 // ──────────────────────────────────────────────────────────────────────────
 // CloseCode PascalCase aliases
 // ──────────────────────────────────────────────────────────────────────────
-// `bun_uws_sys::CloseCode` (us_socket_t.rs) keeps the Zig snake-case variant
+// `bun_uws_sys::CloseCode` (us_socket_t.rs) keeps the snake-case variant
 // names (`normal`/`failure`/`fast_shutdown`). The deleted `bun_uws::CloseKind`
 // duplicate used PascalCase. Expose both spellings via associated consts so
 // every existing call site (`CloseCode::Normal`, `CloseKind::Failure`, …)
@@ -46,7 +46,7 @@ impl CloseCode {
 // InternalSocket
 // ──────────────────────────────────────────────────────────────────────────
 
-/// State of a single connection. `Copy` — Zig passed `ThisSocket` by value
+/// State of a single connection. `Copy` — passed by value
 /// through the entire HTTP-client / Bun.Socket state machines, so the handle
 /// is a trivially-copyable tagged pointer. The `UpgradedDuplex` / `Pipe`
 /// payloads are raw `*mut` (NOT `&mut`): they are stored in long-lived
@@ -64,11 +64,10 @@ pub enum InternalSocket {
     Pipe,
 }
 
-// Zig `InternalSocket.eq` — variant + pointer-identity equality.
-// PORT NOTE: Zig's `.pipe` arm returns `false` even for `(pipe, pipe)` on
-// non-Windows (the variant carries no payload there, so identity is
-// meaningless). Mirrored exactly so debug-asserts that compare sockets behave
-// identically to the Zig build.
+// Variant + pointer-identity equality. The `Pipe` arm intentionally returns
+// `false` even for `(Pipe, Pipe)` on non-Windows (the variant carries no
+// payload there, so identity is meaningless) — debug-asserts that compare
+// sockets rely on this matching the original `InternalSocket.eq` semantics.
 impl PartialEq for InternalSocket {
     fn eq(&self, other: &Self) -> bool {
         match (*self, *other) {
@@ -88,7 +87,7 @@ impl PartialEq for InternalSocket {
 }
 
 impl InternalSocket {
-    /// Zig `InternalSocket.get()` — `Some` only for `.connected`.
+    /// `Some` only for `.connected`.
     #[inline]
     pub fn get(&self) -> Option<*mut us_socket_t> {
         match *self {
@@ -188,7 +187,7 @@ macro_rules! on_socket {
 // NewSocketHandler<IS_SSL>
 // ──────────────────────────────────────────────────────────────────────────
 
-/// Zig `NewSocketHandler(comptime is_ssl: bool)`. The const generic only
+/// The const generic only
 /// selects `*SSL` vs fd for `get_native_handle`; it is NOT forwarded to C —
 /// TLS is per-socket there.
 #[derive(Copy, Clone)]
@@ -209,7 +208,7 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
         socket: InternalSocket::Detached,
     };
 
-    /// Zig `pub const detached` — lower-case constructor form.
+    /// Constructor form of [`Self::DETACHED`].
     #[inline]
     pub const fn detached() -> Self {
         Self::DETACHED
@@ -367,8 +366,8 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
             InternalSocket::Connected(s) => {
                 sock(s).write_fd(data, Fd::from_native(file_descriptor))
             }
-            // Mirror Zig `socket.writeFd`: duplex/pipe fall back to a plain
-            // write (the fd is silently dropped).
+            // Duplex/pipe fall back to a plain write (the fd is silently
+            // dropped).
             InternalSocket::UpgradedDuplex(_) | InternalSocket::Pipe => self.write(data),
             InternalSocket::Connecting(_) | InternalSocket::Detached => 0,
         }
@@ -395,7 +394,7 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
 
     // ── timeouts ────────────────────────────────────────────────────────────
 
-    /// Direct seconds timeout (no long-timeout split). Mirrors Zig `timeout`.
+    /// Direct seconds timeout (no long-timeout split).
     pub fn timeout(&self, seconds: c_uint) {
         on_socket!(self.socket;
             connected s => s.set_timeout(seconds),
@@ -595,7 +594,6 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
     }
 
     pub fn mark_needs_more_for_sendfile(&self) {
-        // Zig: `if (comptime is_ssl) @compileError(...)` — keep as a const assert.
         const { assert!(!IS_SSL, "SSL sockets do not support sendfile yet") };
         if let InternalSocket::Connected(s) = self.socket {
             sock(s).send_file_needs_more();
@@ -643,9 +641,9 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
         this: *mut This,
         is_ipc: bool,
     ) -> Option<Self> {
-        // Zig `?*This` is null-niche optimized (8 bytes); the dispatch
-        // trampolines read the ext slot as `Option<NonNull<_>>`, so size and
-        // write must match that layout — NOT `Option<*mut This>` (16 bytes).
+        // The dispatch trampolines read the ext slot as `Option<NonNull<_>>`
+        // (8 bytes, null-niche optimized), so size and write must match that
+        // layout — NOT `Option<*mut This>` (16 bytes).
         let ext_size = size_of::<Option<NonNull<This>>>() as c_int;
         let raw = g.from_fd(
             k,
@@ -707,11 +705,10 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
             ZStr::from_slice_with_nul(&heap).as_cstr()
         };
 
-        // Zig `?*Owner` is null-niche optimized (8 bytes); the dispatch
-        // trampolines read the ext slot as `Option<NonNull<_>>`, so size and
-        // write must match that layout — NOT `Option<*mut Owner>` (16 bytes,
-        // discriminant-first), which would hand the trampoline `1` instead of
-        // the owner pointer.
+        // The dispatch trampolines read the ext slot as `Option<NonNull<_>>`
+        // (8 bytes, null-niche optimized), so size and write must match that
+        // layout — NOT `Option<*mut Owner>` (16 bytes, discriminant-first),
+        // which would hand the trampoline `1` instead of the owner pointer.
         let ext_size = size_of::<Option<NonNull<Owner>>>() as c_int;
         match g.connect(kind, ssl_ctx, host_z, port, opts, ext_size) {
             ConnectResult::Failed => Err(ConnectError::FailedToOpenSocket),
@@ -743,7 +740,7 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
         } else {
             0
         };
-        // Zig `?*Owner` — see connect_group above for layout rationale.
+        // See connect_group above for the ext-slot layout rationale.
         let ext_size = size_of::<Option<NonNull<Owner>>>() as c_int;
         let s = g.connect_unix(kind, ssl_ctx, path, opts, ext_size);
         if s.is_null() {
@@ -758,8 +755,7 @@ impl<const IS_SSL: bool> NewSocketHandler<IS_SSL> {
     /// Move an open socket into a new group/kind, stashing `owner` in the ext.
     /// Replaces `Socket.adoptPtr`.
     ///
-    /// `set_socket_field` replaces Zig's `comptime field: []const u8` +
-    /// `@field(owner, field)` reflection — the closure writes the resulting
+    /// `set_socket_field` — the closure writes the resulting
     /// `Self` into the owner's socket field via the raw `*mut Owner` (passing
     /// `&mut Owner` here would alias any live `&mut` the caller already holds).
     pub fn adopt_group<Owner>(
@@ -839,7 +835,6 @@ pub enum AnySocket {
 }
 
 /// Stamp out `AnySocket::$m` as a two-arm forward to `NewSocketHandler<SSL>::$m`.
-/// Mirrors Zig `switch (this) { inline else => |s| s.$m(...) }` (socket.zig:532-628).
 macro_rules! any_socket_forward {
     ($( fn $name:ident(&self $(, $arg:ident : $ty:ty)* ) $(-> $ret:ty)? ; )*) => {$(
         #[inline]
@@ -877,7 +872,6 @@ impl AnySocket {
     }
     #[inline]
     pub fn group(&self) -> *mut SocketGroup {
-        // Zig had `@setRuntimeSafety(true)` — Rust always panics on `.unwrap()`.
         match self {
             AnySocket::SocketTcp(s) => s.group(),
             AnySocket::SocketTls(s) => s.group(),
@@ -898,5 +892,3 @@ impl AnySocket {
         fn get_native_handle(&self) -> Option<*mut c_void>;
     }
 }
-
-// ported from: src/uws_sys/socket.zig
diff --git a/src/uws_sys/thunk.rs b/src/uws_sys/thunk.rs
index e9d360d73f9..3cd127969d0 100644
--- a/src/uws_sys/thunk.rs
+++ b/src/uws_sys/thunk.rs
@@ -10,8 +10,8 @@
 //!
 //! Centralising here means each invariant is documented and audited **once**:
 //!
-//! * `zst::<H>()`         — conjure a ZST handler value (the
-//!   `comptime handler` → monomorphised-ZST trick).
+//! * `zst::<H>()`         — conjure a ZST handler value (handlers are
+//!   monomorphised zero-sized types, so no runtime data is needed).
 //! * `user_mut`           — null-checked `*mut c_void → Option<&mut U>`.
 //! * `handle_mut`         — `*mut Opaque → &mut Opaque` for uWS handles.
 //! * `c_slice`            — `(ptr,len) → &[u8]` (empty when len==0 / null).
@@ -138,9 +138,9 @@ pub(crate) unsafe fn c_slice<'a>(ptr: *const u8, len: usize) -> &'a [u8] {
     }
 }
 
-/// Dereference the `Option<NonNull<T>>` stored in a socket's ext slot
-/// (`socket.ext(**T).*` in Zig). `None` covers the calloc'd-but-not-yet-
-/// stamped window during connect/accept.
+/// Dereference the `Option<NonNull<T>>` stored in a socket's ext slot.
+/// `None` covers the calloc'd-but-not-yet-stamped window during
+/// connect/accept.
 ///
 /// # Safety
 /// The pointee, when present, must be live and uniquely borrowed for `'a`
diff --git a/src/uws_sys/udp.rs b/src/uws_sys/udp.rs
index d113bbab297..8a69b996fe4 100644
--- a/src/uws_sys/udp.rs
+++ b/src/uws_sys/udp.rs
@@ -235,5 +235,3 @@ unsafe extern "C" {
     safe fn us_udp_packet_buffer_payload_length(buf: &mut PacketBuffer, index: c_int) -> c_int;
     safe fn us_udp_packet_buffer_truncated(buf: &mut PacketBuffer, index: c_int) -> c_int;
 }
-
-// ported from: src/uws_sys/udp.zig
diff --git a/src/uws_sys/us_socket_t.rs b/src/uws_sys/us_socket_t.rs
index e508e7bd86b..edb5fff344e 100644
--- a/src/uws_sys/us_socket_t.rs
+++ b/src/uws_sys/us_socket_t.rs
@@ -107,7 +107,6 @@ impl us_socket_t {
     }
 
     /// Returned slice is a view into `buf`.
-    // TODO(port): narrow error set
     pub fn local_address<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8], bun_core::Error> {
         let mut length: i32 = i32::try_from(buf.len().min(MAX_I32)).expect("int cast");
         unsafe {
@@ -124,7 +123,6 @@ impl us_socket_t {
     }
 
     /// Returned slice is a view into `buf`. On error, `errno` should be set.
-    // TODO(port): narrow error set
     pub fn remote_address<'a>(&self, buf: &'a mut [u8]) -> Result<&'a [u8], bun_core::Error> {
         let mut length: i32 = i32::try_from(buf.len().min(MAX_I32)).expect("int cast");
         unsafe {
@@ -197,7 +195,6 @@ impl us_socket_t {
             &mut *c::us_socket_group(self)
         }
     }
-    // Zig: `pub const rawGroup = group;`
     #[inline]
     pub fn raw_group(&mut self) -> &mut SocketGroup {
         self.group()
@@ -216,7 +213,7 @@ impl us_socket_t {
 
     /// Move this socket to a new group/kind, optionally resizing its ext.
     /// Returns the (possibly relocated) socket; `self` is invalid after.
-    // TODO(port): lifetime — self is consumed/invalidated; returned ptr may be a different allocation
+    // TODO: take `self` by value — it is consumed/invalidated; the returned ptr may be a different allocation
     pub fn adopt(
         &mut self,
         g: &mut SocketGroup,
@@ -233,7 +230,7 @@ impl us_socket_t {
     /// caller must repoint `ext` first (so any dispatch lands in the new
     /// owner) and then call `start_tls_handshake`. Replaces
     /// `us_socket_upgrade_to_tls` / `wrapTLS`.
-    // TODO(port): lifetime — self is consumed/invalidated; returned ptr may be a different allocation
+    // TODO: take `self` by value — it is consumed/invalidated; the returned ptr may be a different allocation
     pub fn adopt_tls(
         &mut self,
         g: &mut SocketGroup,
@@ -307,10 +304,9 @@ impl us_socket_t {
     }
     #[cfg(windows)]
     pub fn write_fd(&mut self, _data: &[u8], _file_descriptor: Fd) -> i32 {
-        // Zig: `if (Environment.isWindows) @compileError(...)` — that fires only
-        // on call (lazy semantics). Rust evaluates `compile_error!` at item
-        // definition, so this would brick the windows build even with no callers.
-        // Mirror Zig intent with a runtime trap; no current Windows call site.
+        // A `compile_error!` here would brick the windows build even with no
+        // callers (it is evaluated at item definition), so use a runtime trap
+        // instead; no current Windows call site.
         unreachable!("us_socket_t::write_fd is not implemented on Windows")
     }
 
@@ -579,5 +575,3 @@ pub(crate) extern "C" fn us_socket_free_stream_buffer(buffer: *mut us_socket_str
     unsafe { us_socket_stream_buffer_t::destroy(buffer) };
 }
 // us_socket_buffered_js_write moved to src/runtime/socket/uws_jsc.rs
-
-// ported from: src/uws_sys/us_socket_t.zig
diff --git a/src/uws_sys/vtable.rs b/src/uws_sys/vtable.rs
index 7173928d446..f8947ea9fe6 100644
--- a/src/uws_sys/vtable.rs
+++ b/src/uws_sys/vtable.rs
@@ -38,7 +38,7 @@ use crate::{ConnectingSocket, us_bun_verify_error_t, us_socket_t};
 pub trait Handler: 'static {
     /// What `us_socket_ext` holds. Ignored when `HAS_EXT == false`.
     type Ext;
-    /// Zig: `@hasDecl(H, "Ext")`. When false, handlers take `(s, …)` instead
+    /// When false, handlers take `(s, …)` instead
     /// of `(ext, s, …)` and recover their owner from `s.group().owner::<T>()`.
     const HAS_EXT: bool = true;
 
@@ -206,9 +206,8 @@ impl<H: Handler> Make<H> {
 pub(crate) struct Trampolines<H>(core::marker::PhantomData<H>);
 
 impl<H: Handler> Trampolines<H> {
-    // Zig: `inline fn call(s, comptime f, extra)` — conditionally prepends
-    // `s.ext(@typeInfo(E).pointer.child)` to the arg tuple. Rust can't splat
-    // tuples into a call, so each trampoline inlines the HAS_EXT branch.
+    // Rust can't splat tuples into a call, so each trampoline inlines the
+    // HAS_EXT branch.
     #[inline(always)]
     fn ext(s: *mut us_socket_t) -> &'static mut H::Ext {
         // S008: `us_socket_t` is an `opaque_ffi!` ZST — `opaque_mut` is the
@@ -343,5 +342,3 @@ impl<H: Handler> Trampolines<H> {
         }
     }
 }
-
-// ported from: src/uws_sys/vtable.zig
diff --git a/src/valkey/valkey_protocol.rs b/src/valkey/valkey_protocol.rs
index 9eb99b5879e..527f98ff460 100644
--- a/src/valkey/valkey_protocol.rs
+++ b/src/valkey/valkey_protocol.rs
@@ -42,7 +42,7 @@ bun_core::named_error_set!(RedisError);
 impl From<bun_core::Error> for RedisError {
     /// Reverse of the `RedisError → bun_core::Error` interning above so the
     /// `JSValkeyClient::send` → `valkey_error_to_js` path round-trips through
-    /// `bun_core::Error` (Zig's open `!` set) without losing the variant.
+    /// `bun_core::Error` without losing the variant.
     /// Unknown names collapse to `ConnectionClosed` — the only non-`RedisError`
     /// producer on the `send` path is the offline-queue OOM, which `OutOfMemory`
     /// already covers.
@@ -234,8 +234,7 @@ impl<'a> ValkeyReader<'a> {
 
     /// Current read offset into the underlying buffer.
     ///
-    /// Mirrors the public `pos` field on the Zig `ValkeyReader` struct; callers
-    /// use this to compute how many bytes a `read_value` call consumed.
+    /// Callers use this to compute how many bytes a `read_value` call consumed.
     #[inline]
     pub fn pos(&self) -> usize {
         self.pos
@@ -803,12 +802,11 @@ pub enum SubscriptionPushMessage {
 }
 
 impl SubscriptionPushMessage {
-    // PERF(port): Zig's `bun.ComptimeStringMap` lowers this 3-entry table to a
-    // length-then-bytes switch at compile time. An earlier port used
-    // `phf::Map`, which pays a SipHash + indirect probe per lookup — overkill
-    // for three keys whose lengths are all distinct (7/9/11). A length-gated
-    // match rejects the miss case on a single `usize` compare and confirms the
-    // hit with one fixed-size byte compare, matching the Zig codegen.
+    // An earlier version used `phf::Map`, which pays a SipHash + indirect
+    // probe per lookup — overkill for three keys whose lengths are all
+    // distinct (7/9/11). A length-gated match rejects the miss case on a
+    // single `usize` compare and confirms the hit with one fixed-size byte
+    // compare.
     #[inline]
     pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
         match bytes.len() {
@@ -819,5 +817,3 @@ impl SubscriptionPushMessage {
         }
     }
 }
-
-// ported from: src/valkey/valkey_protocol.zig
diff --git a/src/watcher/INotifyWatcher.rs b/src/watcher/INotifyWatcher.rs
index a3fa274cf23..7ba9ebe00c7 100644
--- a/src/watcher/INotifyWatcher.rs
+++ b/src/watcher/INotifyWatcher.rs
@@ -62,8 +62,6 @@ impl Default for INotifyWatcher {
         Self {
             fd: Fd::INVALID,
             loaded: false,
-            // PERF(port): Zig left these `undefined` until init(); Box::default() zero-allocates eagerly.
-            // TODO(port): consider MaybeUninit<Box<EventListBytes>> to defer allocation to init().
             eventlist_bytes: bun_core::boxed_zeroed(),
             eventlist_ptrs: [core::ptr::null(); max_count],
             read_ptr: None,
@@ -96,13 +94,13 @@ impl Event {
     const LARGEST_SIZE: usize = {
         let n = size_of::<Event>() + MAX_PATH_BYTES;
         let a = align_of::<Event>();
-        // std.mem.alignForward
+        // round up to a multiple of the alignment
         (n + a - 1) & !(a - 1)
     };
 
-    // TODO(port): Zig uses *align(1) Event everywhere. The kernel pads names so
-    // subsequent events are 4-byte aligned, but Zig is defensive. If unaligned
-    // reads are observed, switch these to take `*const Event` + read_unaligned.
+    // The kernel pads names so subsequent events are 4-byte aligned. If
+    // unaligned reads are ever observed, switch these to take `*const Event`
+    // + read_unaligned.
 
     pub fn name(&self) -> &ZStr {
         #[cfg(debug_assertions)]
@@ -184,7 +182,7 @@ impl INotifyWatcher {
         result
     }
 
-    // PORT NOTE: kept as in-place &mut self init (not `-> Result<Self, _>`) because
+    // kept as in-place &mut self init (not `-> Result<Self, _>`) because
     // INotifyWatcher is embedded as `Watcher.platform` with field defaults already set.
     pub(crate) fn init(&mut self, _root: &[u8]) -> Result<(), bun_core::Error> {
         use bun_sys::linux::IN;
@@ -196,14 +194,14 @@ impl INotifyWatcher {
             .and_then(|v| isize::try_from(v).ok())
             .unwrap_or(100_000);
 
-        // TODO: convert to bun.sys.Error
         let raw = bun_sys::linux::inotify_init1(IN::CLOEXEC);
-        if raw < 0 {
-            // TODO(port): narrow error set — Zig propagated the std.posix error union here.
-            return Err(bun_core::err!("InotifyInitFailed"));
+        let errno = bun_sys::get_errno(raw);
+        if errno != bun_sys::E::SUCCESS {
+            // Surface the errno name (e.g. EMFILE) instead of a generic
+            // init-failed tag.
+            return Err(bun_core::errno_to_zig_err(errno as i32));
         }
         self.fd = Fd::from_native(raw);
-        // PERF(port): Zig used alignedAlloc here; eager Box in Default already allocated.
         bun_core::scoped_log!(watcher, "{} init", self.fd);
         Ok(())
     }
@@ -222,7 +220,7 @@ impl INotifyWatcher {
         use bun_sys::linux as system;
         use bun_sys::{E, get_errno};
         let mut i: u32 = 0;
-        // PORT NOTE: reshaped for borrowck — track length instead of borrowing a sub-slice
+        // reshaped for borrowck — track length instead of borrowing a sub-slice
         // of self.eventlist_bytes across the whole function.
         let read_len: usize = if let Some(ptr) = self.read_ptr {
             Futex::wait_forever(&self.watch_count, 0);
@@ -255,7 +253,6 @@ impl INotifyWatcher {
                         if read_len < DOUBLE_READ_THRESHOLD {
                             let mut fds = [system::pollfd {
                                 fd: self.fd.native(),
-                                // `std.posix.POLL.IN | std.posix.POLL.ERR`
                                 events: (libc::POLLIN | libc::POLLERR) as _,
                                 revents: 0,
                             }];
@@ -264,7 +261,6 @@ impl INotifyWatcher {
                                 tv_nsec: self.coalesce_interval as _,
                             };
                             // SAFETY: fds and timespec are valid stack locals; sigmask is null.
-                            // Zig: `(std.posix.ppoll(&fds, &timespec, null) catch 0) > 0`.
                             let poll_n = unsafe {
                                 system::ppoll(
                                     fds.as_mut_ptr(),
@@ -383,22 +379,18 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
         return Ok(());
     }
 
-    // PORT NOTE: reshaped for borrowck — copy raw event pointers to a local buffer so
+    // reshaped for borrowck — copy raw event pointers to a local buffer so
     // `this.platform` borrow ends before we mutably borrow other `this` fields below.
-    // PERF(port): Zig used the platform's eventlist_ptrs slice directly.
     let events_len = events.len();
     let mut events_buf: [*const Event; max_count] = [core::ptr::null(); max_count];
     events_buf[..events_len].copy_from_slice(events);
     let events = &events_buf[..events_len];
 
-    // Zig: `this.watchlist.items(.eventlist_index)`.
-    // PORT NOTE: reshaped for borrowck — copy the (small) column to a local Vec
+    // reshaped for borrowck — copy the (small) column to a local Vec
     // so the borrow of `this.watchlist` ends before we mutably borrow other
     // `this` fields inside the batching loop below.
-    // PERF(port): Zig used the column slice directly.
     //
-    // PORT NOTE: locked — diverges from Zig spec (which reads this column
-    // unlocked). `on_file_update` may evict watchlist entries via
+    // The snapshot is taken locked. `on_file_update` may evict watchlist entries via
     // `remove_at_index` + `flush_evictions` (the dir-event path appends *and*
     // evicts the matched file watch). The enqueued reload then re-imports the
     // module on the JS thread, whose `add_file` re-appends the entry under
@@ -418,10 +410,9 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
 
     if events_processed < events.len() {
         let mut name_off: u8 = 0;
-        // PERF(port): Zig left this `undefined`; we zero-init for safety.
         let mut temp_name_list: [Option<&ZStr>; 128] = [None; 128];
         let mut temp_name_off: u8 = 0;
-        let _ = name_off; // matches Zig: declared but only reset, never read here
+        let _ = name_off; // declared but only reset, never read here
 
         // Process events one by one, batching when we hit limits
         while events_processed < events.len() {
@@ -504,7 +495,6 @@ fn process_inotify_event_batch(
 
     let mut name_off: u8 = 0;
     let watch_events = &mut this.watch_events[..event_count];
-    // std.sort.pdq → slice::sort_unstable_by (pdqsort under the hood)
     watch_events.sort_unstable_by(|a, b| WatchEvent::sort_by_index(*a, *b));
 
     let mut last_event_index: usize = 0;
@@ -524,7 +514,7 @@ fn process_inotify_event_batch(
         }
 
         if watch_events[i].index == last_event_id {
-            // PORT NOTE: reshaped for borrowck — split_at_mut to get two disjoint &mut.
+            // reshaped for borrowck — split_at_mut to get two disjoint &mut.
             let (head, tail) = watch_events.split_at_mut(i);
             head[last_event_index].merge(tail[0]);
             continue;
@@ -542,8 +532,8 @@ fn process_inotify_event_batch(
     let _guard = this.mutex.lock_guard();
     if this.running.load() {
         // watch_events.len == 0 is checked above, so last_event_index + 1 is safe.
-        // PORT NOTE: reshaped for borrowck — split disjoint field borrows so we can
-        // pass `&mut watch_events[..]` in place (matching Zig's `all_events[0..]`)
+        // reshaped for borrowck — split disjoint field borrows so we can
+        // pass `&mut watch_events[..]` in place
         // without a gratuitous `.to_vec()`/`.clone()`.
         let deduped = &mut this.watch_events[..last_event_index + 1];
         let changed = &this.changed_filepaths[..name_off as usize];
@@ -578,5 +568,3 @@ pub(crate) fn watch_event_from_inotify_event(event: &Event, index: WatchItemInde
         ..Default::default()
     }
 }
-
-// ported from: src/watcher/INotifyWatcher.zig
diff --git a/src/watcher/KEventWatcher.rs b/src/watcher/KEventWatcher.rs
index b61941f6f86..719a91d49b4 100644
--- a/src/watcher/KEventWatcher.rs
+++ b/src/watcher/KEventWatcher.rs
@@ -19,7 +19,6 @@ pub struct KEventWatcher {
 const CHANGELIST_COUNT: usize = 128;
 
 impl KEventWatcher {
-    // TODO(port): narrow error set
     pub fn init(&mut self, _: &[u8]) -> Result<(), bun_core::Error> {
         let fd = bun_sys::kqueue()?;
         if fd.native() == 0 {
@@ -107,8 +106,8 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
 
     let changes_len = usize::try_from(count.max(0)).expect("int cast");
     let changes = &changelist[0..changes_len];
-    // PORT NOTE: reshaped for borrowck — Zig re-slices `watchevents` in place; Rust tracks out_len
-    // and slices once at the end to avoid overlapping &mut borrows of `this`.
+    // Track out_len and slice once at the end to avoid overlapping &mut
+    // borrows of `this`.
     let watchevents = &mut this.watch_events[0..changes_len];
     let mut out_len: usize = 0;
     if changes_len > 0 {
@@ -129,10 +128,10 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
     }
 
     // RAII: `MutexGuard` holds the mutex by raw pointer (no borrow of `this`)
-    // and unlocks on Drop — Zig: `this.mutex.lock(); defer this.mutex.unlock();`.
+    // and unlocks on Drop.
     let _guard = this.mutex.lock_guard();
     if this.running.load() {
-        // PORT NOTE: reshaped for borrowck — copy the (small, ≤128) deduped slice
+        // reshaped for borrowck — copy the (small, ≤128) deduped slice
         // into a local so `this` is no longer mutably borrowed via `watch_events`
         // when calling `write_trace_events(&self, …)`.
         let mut deduped: Vec<WatchEvent> = this.watch_events[0..out_len].to_vec();
@@ -141,10 +140,8 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
         (this.on_file_update)(this.ctx, &mut deduped, changed, &this.watchlist);
     }
 
-    // Zig: `defer Output.flush()`. No early returns above, so flush once at the
-    // single exit point instead of via scopeguard.
+    // No early returns above, so flush once at the single exit point instead
+    // of via scopeguard.
     Output::flush();
     Ok(())
 }
-
-// ported from: src/watcher/KEventWatcher.zig
diff --git a/src/watcher/Watcher.rs b/src/watcher/Watcher.rs
index 51796ecd1ab..0c7edc5e83c 100644
--- a/src/watcher/Watcher.rs
+++ b/src/watcher/Watcher.rs
@@ -11,8 +11,7 @@ use bun_threading::Mutex;
 use crate::Loader;
 use crate::watcher_trace as WatcherTrace;
 
-// Android: same kernel inotify ABI as glibc/musl Linux. Zig kept these under
-// `Environment.isLinux`; Rust splits `target_os`, so list both.
+// Android: same kernel inotify ABI as glibc/musl Linux, so list both.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use crate::inotify_watcher as platform;
 #[cfg(any(target_os = "macos", target_os = "freebsd"))]
@@ -66,7 +65,6 @@ pub struct PackageJSON {
 /// Manual vtable for resolver→watcher directory-watch callbacks.
 /// Was `bun_resolver::AnyResolveWatcher` (T5); defined here so the low-tier
 /// crate owns the shape and `bun_resolver` re-imports it (move-in pass).
-// PERF(port): was inline switch (Zig comptime ResolveWatcher generator).
 #[derive(Clone, Copy)]
 pub struct AnyResolveWatcher {
     pub context: *mut (),
@@ -110,8 +108,7 @@ pub struct Watcher {
     pub watched_count: usize,
     pub mutex: Mutex,
 
-    // PORT NOTE: Zig stored `fs: *Fs.FileSystem` but only ever read
-    // `fs.top_level_dir`. Storing the slice directly avoids a forward-decl
+    // Storing the `top_level_dir` slice directly avoids a forward-decl
     // dependency on the higher-tier `bun_resolver::fs::FileSystem` type.
     // allocator field dropped — global mimalloc (see §Allocators)
     /// Whether `thread_main` is running. Written by the watcher thread, read
@@ -138,8 +135,7 @@ pub struct Watcher {
 }
 
 /// Context types passed to `Watcher::init` implement this trait.
-/// Replaces Zig's `@hasDecl(T, "onWatchError")` structural check with a
-/// trait bound; the default `on_watch_error` forwards to `on_error`.
+/// The default `on_watch_error` forwards to `on_error`.
 pub trait WatcherContext {
     fn on_file_update(
         &mut self,
@@ -225,8 +221,8 @@ impl Watcher {
 
     pub fn start(&mut self) -> Result<(), bun_core::Error> {
         debug_assert!(!self.watchloop_handle.load());
-        // TODO(port): thread spawn — Watcher must be Send across the spawned
-        // thread boundary; Zig passed *Watcher. Using raw ptr + manual safety.
+        // Watcher must be Send across the spawned thread boundary; we pass a
+        // raw pointer (as usize) and uphold the safety contract manually.
         let this = std::ptr::from_mut::<Watcher>(self) as usize;
         // SAFETY: Watcher outlives the thread; shutdown() coordinates teardown
         // via `running`/`close_descriptors` and the thread frees the Box.
@@ -234,7 +230,6 @@ impl Watcher {
             std::thread::Builder::new()
                 .name("FileWatcher".into())
                 .spawn(move || unsafe {
-                    // TODO(port): narrow error set
                     let _ = Watcher::thread_main(this as *mut Watcher);
                 })
                 .expect("spawn FileWatcher thread"),
@@ -242,13 +237,12 @@ impl Watcher {
         Ok(())
     }
 
-    // PORT NOTE: not `impl Drop` — takes a flag and conditionally hands
+    // not `impl Drop` — takes a flag and conditionally hands
     // ownership to the watcher thread (which frees self in thread_main).
     // Per PORTING.md, `pub fn deinit` is never the public name; renamed to
     // `shutdown` (not `close(self)` because ownership may transfer to the
     // watcher thread instead of dropping here).
-    // TODO(port): ownership model — Zig allocator.destroy(this); Rust needs
-    // heap::take or an Arc to make this sound.
+    // TODO: ownership model — needs heap::take or an Arc to make this sound.
     /// # Safety
     /// `this` must be the unique heap pointer returned from `init()`; ownership
     /// transfers here on the no-thread path (the Box is reclaimed).
@@ -328,8 +322,8 @@ impl Watcher {
 
         // SAFETY: `this` is the heap allocation from init(); the watcher thread
         // owns it now and no `&`/`&mut` borrow of it remains live (the scoped
-        // `me` above has ended). Matches Zig's `allocator.destroy(this)`.
-        // TODO(port): ownership model — see shutdown()
+        // `me` above has ended).
+        // TODO: ownership model — see shutdown()
         drop(unsafe { bun_core::heap::take(this) });
         Ok(())
     }
@@ -363,7 +357,7 @@ impl Watcher {
         // So if we just sort the list by the biggest index first, that should be fine
         self.evict_list[0..evict_list_i].sort_by(|a, b| b.cmp(a));
 
-        // PORT NOTE: reshaped for borrowck — capture fds.len() before loop
+        // reshaped for borrowck — capture fds.len() before loop
         let slice = self.watchlist.slice();
         let fds = slice.items_fd();
         let fds_len = fds.len();
@@ -441,7 +435,9 @@ impl Watcher {
     /// Does not propagate kevent registration errors.
     #[cfg(any(target_os = "macos", target_os = "freebsd"))]
     pub fn add_file_descriptor_to_kqueue_without_checks(&mut self, fd: Fd, watchlist_id: usize) {
-        // TODO(port): move to watcher_sys
+        // Raw libc::kevent on purpose:
+        // this is a registration-only call (nevents = 0) whose return value
+        // is intentionally ignored.
         use libc::{EV_ADD, EV_CLEAR, EV_ENABLE, EVFILT_VNODE, kevent as KEvent};
         use libc::{NOTE_DELETE, NOTE_RENAME, NOTE_WRITE};
 
@@ -507,16 +503,15 @@ impl Watcher {
         #[cfg(any(target_os = "macos", target_os = "freebsd"))]
         let watchlist_id = self.watchlist.len();
 
-        // Zig: `if (clone_file_path) bun.asByteSlice(bun.handleOom(allocator.dupeZ(u8, file_path))) else file_path`.
-        // `WatchItem.file_path` is now an owning `Cow<'static, [u8]>` column so the
-        // CLONE_FILE_PATH=true arm heap-dups (matching Zig's `dupeZ`) instead of
+        // `WatchItem.file_path` is an owning `Cow<'static, [u8]>` column so the
+        // CLONE_FILE_PATH=true arm heap-dups instead of
         // dangling once the caller's buffer is freed.
         let file_path_: Cow<'static, [u8]> = if CLONE_FILE_PATH {
             Cow::Owned(file_path.to_vec())
         } else {
             // SAFETY: when CLONE_FILE_PATH is false the caller passes a path
             // interned in `bun.fs.FileSystem` (process-lifetime); the borrow is
-            // truly `'static`. Matches Zig's `else file_path` arm.
+            // truly `'static`.
             Cow::Borrowed(unsafe { bun_collections::detach_lifetime(file_path) })
         };
 
@@ -524,8 +519,7 @@ impl Watcher {
         self.add_file_descriptor_to_kqueue_without_checks(fd, watchlist_id);
         #[cfg(any(target_os = "linux", target_os = "android"))]
         let eventlist_index = {
-            // Zig builds the `[:0]const u8` from `file_path_` (the dupeZ'd copy when
-            // clone_file_path=true), guaranteeing a trailing NUL for inotify. When
+            // inotify needs a trailing NUL. When
             // CLONE_FILE_PATH is true the caller's `file_path` is NOT NUL-terminated,
             // so we must copy into a NUL-terminated scratch buffer (mirrors the
             // directory branch below) instead of pointing at the caller's slice.
@@ -537,14 +531,12 @@ impl Watcher {
                 ZStr::from_buf(&buf[..], file_path.len())
             } else {
                 // SAFETY: when CLONE_FILE_PATH is false the caller passes a path
-                // interned in `bun.fs.FileSystem` with a NUL sentinel at [len];
-                // Zig's `buf[0..file_path_.len :0]` assumed the same.
+                // interned in `bun.fs.FileSystem` with a NUL sentinel at [len].
                 unsafe { ZStr::from_raw(file_path.as_ptr(), file_path.len()) }
             };
             self.platform.watch_path(slice)?
         };
 
-        // PERF(port): was assume_capacity
         self.watchlist.append_assume_capacity(WatchItem {
             file_path: file_path_,
             fd,
@@ -584,16 +576,15 @@ impl Watcher {
             bun_sys::open_a(file_path, 0, 0)?
         };
 
-        // Zig: `if (clone_file_path) bun.asByteSlice(bun.handleOom(allocator.dupeZ(u8, file_path))) else file_path`.
-        // `WatchItem.file_path` is now an owning `Cow<'static, [u8]>` column so the
-        // CLONE_FILE_PATH=true arm heap-dups (matching Zig's `dupeZ`) instead of
+        // `WatchItem.file_path` is an owning `Cow<'static, [u8]>` column so the
+        // CLONE_FILE_PATH=true arm heap-dups instead of
         // dangling once the caller's buffer is freed.
         let file_path_: Cow<'static, [u8]> = if CLONE_FILE_PATH {
             Cow::Owned(file_path.to_vec())
         } else {
             // SAFETY: when CLONE_FILE_PATH is false the caller passes a path
             // interned in `bun.fs.FileSystem` (process-lifetime); the borrow is
-            // truly `'static`. Matches Zig's `else file_path` arm.
+            // truly `'static`.
             Cow::Borrowed(unsafe { bun_collections::detach_lifetime(file_path) })
         };
 
@@ -631,7 +622,6 @@ impl Watcher {
                 .map_err(|e| e.with_path(file_path))?
         };
 
-        // PERF(port): was assume_capacity
         self.watchlist.append_assume_capacity(WatchItem {
             file_path: file_path_,
             fd,
@@ -658,12 +648,10 @@ impl Watcher {
         dir_fd: Fd,
         package_json: Option<&'static PackageJSON>,
     ) -> sys::Result<()> {
-        if LOCK {
-            self.mutex.lock();
-        }
-        // TODO(port): errdefer — defer-unlock captures &mut self; needs RAII
-        // MutexGuard. Until then, each early-return below hand-inlines
-        // `if LOCK { self.mutex.unlock() }`.
+        // RAII guard: `lock_guard()` holds the
+        // mutex by `BackRef`, not a borrow of `self`, so the `&mut self` calls
+        // below are fine and every return path unlocks.
+        let _guard = LOCK.then(|| self.mutex.lock_guard());
 
         debug_assert!(file_path.len() > 1);
         let pathname = bun_paths::fs::PathName::init(file_path);
@@ -691,7 +679,7 @@ impl Watcher {
                 }
             }
         }
-        // Zig: `bun.handleOom(this.watchlist.ensureUnusedCapacity(...))` — abort on OOM.
+        // Abort on OOM:
         // `MultiArrayList::ensure_unused_capacity` returns `Err(AllocError)` on
         // allocation failure (does NOT abort), so discarding it would let the
         // following `append_assume_capacity` write past capacity.
@@ -708,9 +696,6 @@ impl Watcher {
                     parent_dir_hash,
                 ) {
                     Err(err) => {
-                        if LOCK {
-                            self.mutex.unlock();
-                        }
                         return Err(err.with_path(parent_dir));
                     }
                     Ok(r) => r,
@@ -728,9 +713,6 @@ impl Watcher {
             package_json,
         ) {
             Err(err) => {
-                if LOCK {
-                    self.mutex.unlock();
-                }
                 return Err(err.with_path(file_path));
             }
             Ok(()) => {}
@@ -754,9 +736,6 @@ impl Watcher {
             );
         }
 
-        if LOCK {
-            self.mutex.unlock();
-        }
         Ok(())
     }
 
@@ -795,20 +774,15 @@ impl Watcher {
         file_path: &[u8],
         hash: HashType,
     ) -> sys::Result<WatchItemIndex> {
-        self.mutex.lock();
-        // TODO(port): use RAII guard for mutex
-        let result = (|| {
-            if let Some(idx) = self.index_of(hash) {
-                return Ok(idx as WatchItemIndex);
-            }
-            // Zig: `bun.handleOom(this.watchlist.ensureUnusedCapacity(this.allocator, 1))`.
-            self.watchlist
-                .ensure_unused_capacity(1)
-                .unwrap_or_else(|_| bun_core::out_of_memory());
-            self.append_directory_assume_capacity::<CLONE_FILE_PATH>(fd, file_path, hash)
-        })();
-        self.mutex.unlock();
-        result
+        // RAII guard; see append_file_maybe_lock.
+        let _guard = self.mutex.lock_guard();
+        if let Some(idx) = self.index_of(hash) {
+            return Ok(idx as WatchItemIndex);
+        }
+        self.watchlist
+            .ensure_unused_capacity(1)
+            .unwrap_or_else(|_| bun_core::out_of_memory());
+        self.append_directory_assume_capacity::<CLONE_FILE_PATH>(fd, file_path, hash)
     }
 
     /// Lazily watch a file by path (slow path).
@@ -940,7 +914,7 @@ impl Watcher {
         self.mutex.unlock();
     }
 
-    // PORT NOTE: Zig used a comptime `kind: Kind` param. Rust const-generic
+    // Const-generic
     // enum params need `adt_const_params` (nightly); the value is only
     // compared to `.Directory`, so a plain runtime parameter is fine.
     pub fn remove_at_index(
@@ -1038,7 +1012,7 @@ impl Op {
     }
 }
 
-/// Lowercase Zig-field-name mapping for `Op` (matches `std.meta.fields(Op)` output).
+/// Lowercase name mapping for `Op` flags (used for trace output).
 pub(crate) const OP_NAMES: &[(Op, &str)] = &[
     (Op::DELETE, "delete"),
     (Op::METADATA, "metadata"),
@@ -1151,5 +1125,3 @@ impl WatchItemColumns for bun_collections::multi_array_list::Slice<WatchItem> {
         self.items::<"eventlist_index", platform::EventListIndex>()
     }
 }
-
-// ported from: src/watcher/Watcher.zig
diff --git a/src/watcher/WatcherTrace.rs b/src/watcher/WatcherTrace.rs
index ce6f9aff565..0179333fdac 100644
--- a/src/watcher/WatcherTrace.rs
+++ b/src/watcher/WatcherTrace.rs
@@ -7,9 +7,7 @@ use bun_threading::Guarded;
 use crate::watcher_impl::{ChangedFilePath, WatchEvent, WatchList};
 
 /// Optional trace file for debugging watcher events.
-// PORTING.md §Concurrency: Zig used a bare `var trace_file: ?File = null` plus
-// the implicit single-threaded init/watcher-thread/deinit ordering. Rust
-// `static mut` is forbidden — wrap in `bun_threading::Guarded` (cheap when
+// Wrapped in `bun_threading::Guarded` (cheap when
 // uncontended; only the watcher thread touches this after init).
 static TRACE_FILE: Guarded<Option<File>> = Guarded::new(None);
 
@@ -45,34 +43,24 @@ pub fn write_events(
         return;
     };
 
-    // PORT NOTE: Zig passed a stack `[4096]u8` to `bufferedWriter(&buffer)`;
     // `bun_sys::File::buffered_writer()` wraps `std::io::BufWriter` which
-    // owns its own heap buffer. Same observable behaviour.
+    // owns its own heap buffer.
     let buffered = file.buffered_writer();
     // `defer buffered.flush() catch |err| { Output.err(...) }`
     let mut writer = scopeguard::guard(buffered, |mut w| {
         if let Err(err) = w.flush() {
-            // PORT NOTE: Zig passed the error-union tag (`@errorName`). The
-            // BufWriter wrapper surfaces a `std::io::Error`; print its display
-            // as the tag — same observable text minus the `error.` prefix.
-            // TODO(port): map io::Error → bun_sys::Error once a helper exists.
-            let mut name_buf = [0u8; 64];
-            let name = {
-                use std::io::Write as _;
-                let mut c = std::io::Cursor::new(&mut name_buf[..]);
-                let _ = write!(c, "{}", err.kind());
-                let n = c.position() as usize;
-                // SAFETY: `write!(.., "{}", io::ErrorKind)` emits an ASCII variant
-                // name (`NotFound`, `PermissionDenied`, …) — pure-ASCII output.
-                unsafe { core::str::from_utf8_unchecked(&name_buf[..n]) }
-            };
-            output::err(name, "Failed to flush watcher trace file", ());
+            // Map the `std::io::Error` to the interned errno-name code, so an
+            // errno name (e.g. `ENOSPC`) renders — debug-trace-only path.
+            output::err(
+                bun_core::Error::from(err),
+                "Failed to flush watcher trace file",
+                (),
+            );
         }
     });
 
-    // Get current timestamp
-    // PORT NOTE: std.time.milliTimestamp() — std::time is not in the banned
-    // I/O set; revisit if a `bun_core::time` helper exists.
+    // Get current timestamp. `std::time` is not in the banned I/O set;
+    // revisit if a `bun_core::time` helper exists.
     let timestamp: i64 = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
         .map(|d| i64::try_from(d.as_millis()).expect("int cast"))
@@ -123,9 +111,8 @@ pub fn write_events(
         }
 
         // Write array of event types.
-        // PORT NOTE: Zig walks `std.meta.fields(Op)` (lowercase field names).
         // bitflags `iter_names()` yields SCREAMING_CASE const names; use the
-        // shared lowercase OP_NAMES table so trace JSON matches Zig exactly.
+        // shared lowercase OP_NAMES table so trace JSON keys stay lowercase.
         let mut first = true;
         for &(flag, name) in crate::watcher_impl::OP_NAMES {
             if !event.op.contains(flag) {
@@ -192,10 +179,8 @@ pub fn write_events(
 }
 
 /// Close the trace file if open
-// PORT NOTE: free-function `deinit` (no `self`), so this stays a plain fn
+// free-function `deinit` (no `self`), so this stays a plain fn
 // rather than `impl Drop`.
 pub(crate) fn deinit() {
     let _ = TRACE_FILE.lock().take();
 }
-
-// ported from: src/watcher/WatcherTrace.zig
diff --git a/src/watcher/WindowsWatcher.rs b/src/watcher/WindowsWatcher.rs
index b006fe0f0b6..31f96579288 100644
--- a/src/watcher/WindowsWatcher.rs
+++ b/src/watcher/WindowsWatcher.rs
@@ -62,8 +62,7 @@ pub enum Action {
 
 pub(crate) struct FileEvent {
     pub action: Action,
-    // BACKREF: Zig `[]u16` borrows `DirWatcher.buf`. [`RawSlice`] (not a
-    // lifetime-carrying `&'a [u16]`) so `FileEvent` carries no lifetime param;
+    // [`RawSlice`] (not a lifetime-carrying `&'a [u16]`) so `FileEvent` carries no lifetime param;
     // the buffer is live until the next `prepare()` — encapsulated by the
     // `RawSlice` outlives-holder invariant so callers read via safe `.slice()`.
     pub filename: RawSlice<u16>,
@@ -74,7 +73,6 @@ pub struct DirWatcher {
     /// must be initialized to zero (even though it's never read or written in our code),
     /// otherwise ReadDirectoryChangesW will fail with INVALID_HANDLE
     pub overlapped: w::OVERLAPPED,
-    /// Zig had `align(@alignOf(w.FILE_NOTIFY_INFORMATION))` on this field.
     /// `FILE_NOTIFY_INFORMATION` is DWORD-aligned (4); the preceding
     /// `OVERLAPPED` (32 bytes, align 8) guarantees `buf` lands at offset 32,
     /// which the `assert_ffi_layout!` below locks in (and `32 % 4 == 0` is the
@@ -86,7 +84,7 @@ pub struct DirWatcher {
 
 // `OVERLAPPED` = 32 bytes / align 8 on Win64; `buf` must be ≥ 4-aligned for
 // the `*FILE_NOTIFY_INFORMATION` cast. Asserting the offset (not just the
-// total size) is what discharges the dropped Zig `align(...)` annotation.
+// total size) is what proves that alignment requirement.
 bun_core::assert_ffi_layout!(
     DirWatcher,
     32 + 64 * 1024 + ::core::mem::size_of::<HANDLE>(),
@@ -124,13 +122,12 @@ impl DirWatcher {
         {
             let err = w::Win32Error::get();
             bun_core::scoped_log!(watcher, "failed to start watching directory: {}", err.0);
-            // TODO(port): bun_sys::Tag::watch — full syscall enum not yet in subset.
             return Err(bun_sys::Error {
                 // Route the raw code through the `u32` `SystemErrnoInit` impl
                 // (same Win32→errno table as `Win32ErrorExt::to_system_errno`).
                 errno: bun_sys::SystemErrno::init(err.0 as u32)
                     .unwrap_or(bun_sys::SystemErrno::EINVAL) as _,
-                syscall: bun_sys::Tag::TODO,
+                syscall: bun_sys::Tag::watch,
                 ..Default::default()
             });
         }
@@ -141,7 +138,7 @@ impl DirWatcher {
 
 /// Iterates `FILE_NOTIFY_INFORMATION` records out of a `DirWatcher`'s buffer.
 ///
-/// PORT NOTE: holds a [`BackRef<DirWatcher>`] instead of a lifetime-carrying
+/// holds a [`BackRef<DirWatcher>`] instead of a lifetime-carrying
 /// `&'a DirWatcher` so `WindowsWatcher::next` does not keep `&mut Watcher.platform`
 /// borrowed across `watch_loop_cycle`'s inner loop (which mutates sibling
 /// fields). The `BackRef` invariant — pointee outlives holder — is upheld
@@ -159,13 +156,12 @@ impl EventIterator {
         if !self.has_next {
             return None;
         }
-        // PORT NOTE: Zig std's FILE_NOTIFY_INFORMATION omits the flexible FileName member
-        // (so `@sizeOf` == 12 == offset of FileName); the Rust binding includes
-        // `FileName: [WCHAR; 1]`, so `size_of` == 16. Use the field offset, not the struct
+        // The Rust binding includes `FileName: [WCHAR; 1]`, so `size_of` == 16
+        // while the fixed record header is 12 bytes. Use the field offset, not the struct
         // size, to locate the variable-length filename.
         let name_offset = core::mem::offset_of!(w::FILE_NOTIFY_INFORMATION, FileName);
         // `self.watcher` is a `BackRef<DirWatcher>` — pointee live until the
-        // next `prepare()` (see struct PORT NOTE) — so reading `buf` is safe.
+        // next `prepare()` (see the struct-level note) — so reading `buf` is safe.
         let buf_ptr = self.watcher.buf.as_ptr();
         // SAFETY: `buf` was filled by ReadDirectoryChangesW with a sequence of
         // FILE_NOTIFY_INFORMATION records; `offset` is advanced only by
@@ -188,8 +184,7 @@ impl EventIterator {
         let name_bytes = &self.watcher.buf[name_start..name_start + info.FileNameLength as usize];
         let filename: RawSlice<u16> = RawSlice::new(bun_core::cast_slice::<u8, u16>(name_bytes));
 
-        // PORT NOTE: Zig `@enumFromInt` is safety-checked in debug; Rust `transmute`
-        // into an exhaustive #[repr(u32)] enum is immediate UB on an unlisted
+        // `transmute` into an exhaustive #[repr(u32)] enum is immediate UB on an unlisted
         // discriminant. Use a checked match — kernel docs guarantee 1..=5 today.
         let action: Action = match info.Action {
             w::FILE_ACTION_ADDED => Action::Added,
@@ -276,9 +271,7 @@ impl WindowsWatcher {
             let _ = w::CloseHandle(h);
         });
 
-        // PORT NOTE: Zig's `this.watcher = .{ .dirHandle = handle }` writes via result-location
-        // semantics with `buf: ... = undefined` (well-defined "unspecified bytes" in Zig). In Rust,
-        // materializing an uninit `[u8; N]` by value is immediate UB, and constructing a 64KiB
+        // Materializing an uninit `[u8; N]` by value is immediate UB, and constructing a 64KiB
         // `DirWatcher` temporary on the stack defeats the in-place-init intent. Assign fields in
         // place instead — `buf` was already zero-initialised by `Default` and is an output buffer
         // filled by ReadDirectoryChangesW before any read.
@@ -296,7 +289,7 @@ impl WindowsWatcher {
             root.len()
         };
 
-        // disarm errdefer guards on success
+        // disarm the cleanup scopeguards on success
         scopeguard::ScopeGuard::into_inner(iocp_guard);
         scopeguard::ScopeGuard::into_inner(handle_guard);
         Ok(())
@@ -330,12 +323,11 @@ impl WindowsWatcher {
                     return Ok(None);
                 } else {
                     bun_core::scoped_log!(watcher, "GetQueuedCompletionStatus failed: {}", err.0);
-                    // TODO(port): bun_sys::Tag::watch
                     return Err(bun_sys::Error {
                         errno: bun_sys::SystemErrno::init(err.0 as u32)
                             .unwrap_or(bun_sys::SystemErrno::EINVAL)
                             as _,
-                        syscall: bun_sys::Tag::TODO,
+                        syscall: bun_sys::Tag::watch,
                         ..Default::default()
                     });
                 }
@@ -377,7 +369,7 @@ impl WindowsWatcher {
                 );
                 return Err(bun_sys::Error {
                     errno: bun_sys::SystemErrno::EINVAL as _,
-                    syscall: bun_sys::Tag::TODO,
+                    syscall: bun_sys::Tag::watch,
                     ..Default::default()
                 });
             }
@@ -401,8 +393,8 @@ pub(crate) enum Timeout {
 }
 
 pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
-    // PORT NOTE: reshaped for borrowck — Zig held `&this.platform.buf` across the loop while
-    // also calling `this.platform.next()`. We re-borrow buf inside the inner loop instead.
+    // We re-borrow buf inside the inner loop instead of holding `&this.platform.buf`
+    // across calls to `this.platform.next()`.
     let base_idx = this.platform.base_idx;
 
     let mut event_id: usize = 0;
@@ -449,7 +441,7 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
 
             let n_items = this.watchlist.items_file_path().len();
             for item_idx in 0..n_items {
-                // PORT NOTE: reshaped for borrowck — `rel` is computed in a scoped
+                // reshaped for borrowck — `rel` is computed in a scoped
                 // block so the borrows of `this.watchlist` / `this.platform.buf`
                 // are released before we touch `this.watch_events` or hand the
                 // whole `&mut Watcher` to `process_watch_event_batch`.
@@ -479,14 +471,13 @@ pub(crate) fn watch_loop_cycle(this: &mut Watcher) -> bun_sys::Result<()> {
                 if event_id >= this.watch_events.len() {
                     // Process current batch of events
                     process_watch_event_batch(this, event_id)?;
-                    // PORT NOTE: passing `this: &mut Watcher` above materialises a fresh Unique
+                    // passing `this: &mut Watcher` above materialises a fresh Unique
                     // borrow over the whole `Watcher`, which under Stacked Borrows pops the
                     // SharedReadOnly tag that `iter.watcher` (a `*const DirWatcher` derived from
                     // an earlier `&this.platform.watcher`) carries. The next `iter.next()` would
                     // then dereference a pointer with invalidated provenance — UB that MIRI flags.
                     // The callee never touches `platform.watcher`, so re-deriving the pointer
-                    // here from the now-current `&mut Watcher` restores valid provenance. (Zig
-                    // has no aliasing model so the spec at WindowsWatcher.zig:245 is sound.)
+                    // here from the now-current `&mut Watcher` restores valid provenance.
                     iter.watcher = BackRef::new(&this.platform.watcher);
                     // Reset event_id to start a new batch
                     event_id = 0;
@@ -518,13 +509,13 @@ fn process_watch_event_batch(this: &mut Watcher, event_count: usize) -> bun_sys:
     all_events.sort_unstable_by(|a, b| WatchEvent::sort_by_index(*a, *b));
 
     let mut last_event_index: usize = 0;
-    // Zig: `var last_event_id: u32 = std.math.maxInt(u32);` — sentinel must be wider than
+    // The sentinel must be wider than
     // WatchItemIndex (u16) so it can never collide with a real index (incl. no_watch_item=65535).
     let mut last_event_id: u32 = u32::MAX;
 
     for i in 0..all_events.len() {
         if all_events[i].index as u32 == last_event_id {
-            // PORT NOTE: reshaped for borrowck — copy then merge to avoid two &mut into all_events.
+            // reshaped for borrowck — copy then merge to avoid two &mut into all_events.
             let ev = all_events[i];
             all_events[last_event_index].merge(ev);
             continue;
@@ -535,7 +526,7 @@ fn process_watch_event_batch(this: &mut Watcher, event_count: usize) -> bun_sys:
     if all_events.is_empty() {
         return Ok(());
     }
-    // PORT NOTE: reshaped for borrowck — copy the (small) deduped slice into a
+    // reshaped for borrowck — copy the (small) deduped slice into a
     // local so `this` is no longer mutably borrowed via `watch_events` when we
     // call `write_trace_events` / `on_file_update`. Mirrors INotifyWatcher.
     let mut deduped: Vec<WatchEvent> = all_events[..last_event_index + 1].to_vec();
@@ -551,8 +542,6 @@ fn process_watch_event_batch(this: &mut Watcher, event_count: usize) -> bun_sys:
     // defer `flush_evictions()`, which assumes the lock is held to serialize
     // its close+swap_remove against the JS thread's
     // `snapshot_fd_and_package_json` / `append_file_maybe_lock<true>`.
-    // Intentionally diverges from Zig spec (`WindowsWatcher.zig` does not
-    // lock here); same EBADF race exists there.
     let _guard = this.mutex.lock_guard();
     if !this.running.load() {
         return Ok(());
@@ -581,5 +570,3 @@ pub(crate) fn create_watch_event(event: &FileEvent, index: WatchItemIndex) -> Wa
         ..Default::default()
     }
 }
-
-// ported from: src/watcher/WindowsWatcher.zig
diff --git a/src/watcher/lib.rs b/src/watcher/lib.rs
index 866a0ed8977..3a98dbec286 100644
--- a/src/watcher/lib.rs
+++ b/src/watcher/lib.rs
@@ -2,10 +2,6 @@
 #![warn(unused_must_use)]
 #![allow(unexpected_cfgs)]
 //! Bun's cross-platform filesystem watcher.
-//!
-//! Function bodies that depend on crate surface that hasn't landed yet
-//! (e.g. `bun_sys::linux` raw inotify syscalls, `bun_collections::MultiArrayElement`
-//! derive, `bun_fs`) are individually gated with `// TODO(port): bun_X::Y` markers.
 
 // ─── platform impls ───────────────────────────────────────────────────────
 //
@@ -45,11 +41,16 @@ pub use watcher_impl::{
 // These belong to higher-tier crates that don't yet expose a usable surface
 // to depend on. Watcher only stores/passes them through; never dereferenced.
 
-// TODO(port): bun_ast::Loader
-/// Opaque forward-decl of `bun_ast::Loader`. Watcher only stores
-/// the value in `WatchItem.loader` and passes it through.
+/// Opaque forward-decl of `bun_ast::Loader` (cycle-break: bun_watcher sits
+/// below bun_ast in the crate graph). Watcher only stores the value in
+/// `WatchItem.loader` and passes it through; callers construct it via
+/// `Loader(bun_ast::Loader as u8)` at the boundary.
 #[derive(Clone, Copy, Default)]
 pub struct Loader(pub u8);
 impl Loader {
-    pub const File: Loader = Loader(0);
+    /// Mirrors `bun_ast::Loader::File as u8`;
+    /// keep the discriminant in sync with `src/ast/loader.rs`. A compile-time
+    /// drift guard lives in `src/jsc/hot_reloader.rs` (a crate that sees both
+    /// types).
+    pub const File: Loader = Loader(5);
 }
diff --git a/src/which/lib.rs b/src/which/lib.rs
index 3641da8e95c..7d62510b6d5 100644
--- a/src/which/lib.rs
+++ b/src/which/lib.rs
@@ -59,7 +59,7 @@ pub fn which<'a>(buf: &'a mut PathBuffer, path: &[u8], cwd: &[u8], bin: &[u8]) -
         let result = which_win(&mut *convert_buf, path, cwd, bin)?;
         let result_converted =
             bun_core::strings::convert_utf16_to_utf8_in_buffer(&mut buf[..], result);
-        // PORT NOTE: reshaped for borrowck — capture len/ptr before re-borrowing buf
+        // Capture len/ptr before re-borrowing buf (borrowck).
         let result_converted_len = result_converted.len();
         let result_converted_ptr = result_converted.as_ptr();
         buf[result_converted_len] = 0;
@@ -89,7 +89,7 @@ pub fn which<'a>(buf: &'a mut PathBuffer, path: &[u8], cwd: &[u8], bin: &[u8]) -
 
         if strings::index_of_char(bin, b'/').is_some() {
             if !cwd.is_empty() {
-                // PORT NOTE: std.mem.trimRight(u8, cwd, sep_str) — strip trailing SEP bytes.
+                // Strip trailing SEP bytes from cwd.
                 let mut cwd_trimmed = cwd;
                 while cwd_trimmed.last() == Some(&SEP) {
                     cwd_trimmed = &cwd_trimmed[..cwd_trimmed.len() - 1];
@@ -131,7 +131,7 @@ pub fn ends_with_extension(str: &[u8]) -> bool {
     }
     let file_ext = &str[str.len() - 3..];
     for ext in WIN_EXTENSIONS {
-        // comptime assert ext.len == 3 — all literals above are 3 bytes
+        // all WIN_EXTENSIONS literals are 3 bytes
         if strings::eql_case_insensitive_asciii_check_length(file_ext, ext) {
             return true;
         }
@@ -182,10 +182,8 @@ fn search_bin(
     path_size: usize,
     check_windows_extensions: bool,
 ) -> Option<&mut [u16]> {
-    // PORT NOTE: Zig `existsOSPath` takes `bun.OSPathSliceZ`, which is `[:0]const u16`
-    // on Windows and `[:0]const u8` on POSIX. `searchBin` only ever runs on Windows
-    // (whichWin is dead-by-lazy-eval elsewhere); the POSIX arm here is just to keep
-    // the public `which_win` symbol type-checking on all targets.
+    // `search_bin` only ever runs on Windows; the POSIX arm here exists solely
+    // so the public `which_win` symbol type-checks on all targets.
     #[cfg(windows)]
     {
         if !check_windows_extensions {
@@ -240,8 +238,8 @@ fn search_bin_in_path<'a>(
     } else {
         path
     };
-    // PORT NOTE: PosixToWinNormalizer is a no-op on posix; resolve_cwd_with_external_buf
-    // takes `&mut ()` there, so just pass through (matches Zig lazy-eval behaviour).
+    // PosixToWinNormalizer is a no-op on posix; resolve_cwd_with_external_buf
+    // takes `&mut ()` there, so just pass through.
     #[cfg(not(windows))]
     let segment: &[u8] = {
         let _ = path_buf;
@@ -261,7 +259,7 @@ fn search_bin_in_path<'a>(
         &mut buf[..],
         bun_core::strings::without_trailing_slash(segment),
     );
-    // PORT NOTE: reshaped for borrowck — capture len before re-borrowing buf
+    // Capture len before re-borrowing buf (borrowck).
     let segment_utf16_len = segment_utf16.len();
 
     buf[segment_utf16_len] = SEP as u16;
@@ -302,7 +300,7 @@ pub fn which_win<'a>(
         let normalized_bin = bin;
         let bin_utf16 =
             bun_core::strings::convert_utf8_to_utf16_in_buffer(&mut buf[..], normalized_bin);
-        // PORT NOTE: reshaped for borrowck — capture len before re-borrowing buf
+        // Capture len before re-borrowing buf (borrowck).
         let bin_utf16_len = bin_utf16.len();
         buf[bin_utf16_len] = 0;
         return search_bin(buf, bin_utf16_len, check_windows_extensions).map(|w| &*w);
@@ -310,8 +308,8 @@ pub fn which_win<'a>(
 
     // check if bin is in cwd
     if strings::index_of_char(bin, b'/').is_some() || strings::index_of_char(bin, b'\\').is_some() {
-        // PORT NOTE: NLL Polonius limitation — raw-ptr reborrow so the None
-        // branch can fall through without `buf` appearing borrowed.
+        // NLL/Polonius limitation — raw-ptr reborrow so the None branch can
+        // fall through without `buf` appearing borrowed.
         // SAFETY: bin_path borrow does not escape this block on the None path.
         let buf_reborrow: &'a mut WPathBuffer =
             unsafe { &mut *std::ptr::from_mut::<WPathBuffer>(buf) };
@@ -331,8 +329,8 @@ pub fn which_win<'a>(
 
     // iterate over system path delimiter
     for segment_part in path.split(|b| *b == b';').filter(|s| !s.is_empty()) {
-        // PORT NOTE: NLL Polonius limitation — re-borrowing `buf` across loop
-        // iterations when returning a reference tied to its lifetime.
+        // NLL/Polonius limitation — re-borrowing `buf` across loop iterations
+        // when returning a reference tied to its lifetime.
         // SAFETY: on None the borrow ends; on Some we return immediately.
         let buf_reborrow: &'a mut WPathBuffer =
             unsafe { &mut *std::ptr::from_mut::<WPathBuffer>(buf) };
@@ -349,5 +347,3 @@ pub fn which_win<'a>(
 
     None
 }
-
-// ported from: src/which/which.zig
diff --git a/src/windows_sys/externs.rs b/src/windows_sys/externs.rs
index f6c0770a6fc..bba668861d6 100644
--- a/src/windows_sys/externs.rs
+++ b/src/windows_sys/externs.rs
@@ -1,12 +1,11 @@
-//! Raw Win32 extern fn declarations + tier-0 Win32 typedefs split from
-//! sys/windows/windows.zig. `bun_sys::windows` re-exports FROM here (see
-//! the layering doc). This crate is a tier-0 leaf: it depends on nothing above
+//! Raw Win32 extern fn declarations + tier-0 Win32 typedefs.
+//! `bun_sys::windows` re-exports FROM here (see the layering doc). This crate is a tier-0 leaf: it depends on nothing above
 //! `libuv_sys`.
 
 use core::ffi::{c_char, c_int, c_long, c_short, c_uint, c_ulong, c_ushort, c_void};
 
 // ──────────────────────────────────────────────────────────────────────────
-// Basic Win32 typedefs (owned here; mirror std.os.windows / winnt.h)
+// Basic Win32 typedefs (owned here; mirror winnt.h)
 // ──────────────────────────────────────────────────────────────────────────
 
 pub type BOOL = c_int;
@@ -75,7 +74,7 @@ pub struct FILETIME {
 
 // ──────────────────────────────────────────────────────────────────────────
 // Win32 POD structs shared by `bun_libuv_sys` (uv/win.h embeds) and
-// `bun_sys::windows`. Single source of truth ≙ Zig's `std.os.windows`.
+// `bun_sys::windows`. Single source of truth.
 // All derive Clone+Copy: libuv embeds them in `uv_req_s`/`uv_tty_s`/
 // `uv_fs_s` which themselves derive Copy, so non-Copy here would break
 // the derive chain.
@@ -228,7 +227,7 @@ pub type GET_FILEEX_INFO_LEVELS = u32;
 pub const GetFileExInfoStandard: GET_FILEEX_INFO_LEVELS = 0;
 pub const GetFileExMaxInfoLevel: GET_FILEEX_INFO_LEVELS = 1;
 
-/// Mirrors `std.os.windows.FILE_INFO_BY_HANDLE_CLASS` (`enum(u32)`).
+/// `FILE_INFO_BY_HANDLE_CLASS` (`winbase.h`), as a bare `u32`.
 pub type FILE_INFO_BY_HANDLE_CLASS = u32;
 
 #[repr(C)]
@@ -261,7 +260,7 @@ pub struct IO_STATUS_BLOCK {
     pub Information: usize,
 }
 
-// `std.os.windows` path-length constants.
+// Path-length constants.
 pub const MAX_PATH: usize = 260;
 pub const PATH_MAX_WIDE: usize = 32767;
 
@@ -381,8 +380,7 @@ pub struct FILE_DIRECTORY_INFORMATION {
 }
 
 /// `FILE_INFORMATION_CLASS` (`wdm.h`) — selector for `NtQuery*` /
-/// `NtSetInformationFile`. Newtype-over-u32 to keep parity with Zig's
-/// non-exhaustive enum.
+/// `NtSetInformationFile`. Newtype-over-u32 so unmapped values round-trip.
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct FILE_INFORMATION_CLASS(pub u32);
@@ -402,7 +400,7 @@ pub struct FILE_END_OF_FILE_INFORMATION {
     pub EndOfFile: LARGE_INTEGER,
 }
 
-/// Zig spells it `FileInformationClass` (camel) at use sites; alias.
+/// CamelCase alias used at some call sites.
 pub type FileInformationClass = FILE_INFORMATION_CLASS;
 
 /// `FILE_DISPOSITION_INFORMATION` (`ntifs.h`).
@@ -445,7 +443,6 @@ pub const VOLUME_NAME_GUID: DWORD = 0x1;
 pub const VOLUME_NAME_NT: DWORD = 0x2;
 pub const VOLUME_NAME_NONE: DWORD = 0x4;
 
-/// Zig `std.os.windows.GetFinalPathNameByHandleOptions.VolumeName`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
 pub enum VolumeName {
     #[default]
@@ -453,7 +450,6 @@ pub enum VolumeName {
     Nt,
 }
 
-/// Zig `std.os.windows.GetFinalPathNameByHandleOptions`.
 #[derive(Copy, Clone, Debug, Default)]
 pub struct GetFinalPathNameByHandleFormat {
     pub volume_name: VolumeName,
@@ -464,7 +460,7 @@ impl FILE_INFORMATION_CLASS {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// ntdll namespace (subset). Zig: `pub const ntdll = std.os.windows.ntdll`
+// ntdll namespace (subset).
 // ──────────────────────────────────────────────────────────────────────────
 pub mod ntdll {
     use super::*;
@@ -570,9 +566,9 @@ pub mod ntdll {
 }
 pub use ntdll::NtClose;
 
-/// `std.os.windows.user32` (subset placeholder; fill in as needed).
+/// `user32` namespace (subset placeholder; fill in as needed).
 pub mod user32 {}
-/// `std.os.windows.advapi32` (subset placeholder; fill in as needed).
+/// `advapi32` namespace (subset placeholder; fill in as needed).
 pub mod advapi32 {}
 
 // `bun.windows.libuv` is exposed from the higher-tier `bun_sys::windows`
@@ -580,7 +576,7 @@ pub mod advapi32 {}
 // must not depend on `bun_libuv_sys` (would invert the tier ordering).
 
 // ──────────────────────────────────────────────────────────────────────────
-// kernel32 namespace (subset). Zig: `pub const kernel32 = windows.kernel32`
+// kernel32 namespace (subset).
 // ──────────────────────────────────────────────────────────────────────────
 pub mod kernel32 {
     use super::*;
@@ -718,8 +714,7 @@ pub mod kernel32 {
         /// `RemoveVectoredExceptionHandler` (`errhandlingapi.h`).
         pub fn RemoveVectoredExceptionHandler(Handle: *mut c_void) -> u32;
     }
-    // Re-export externs declared at the crate root so `kernel32::Foo` resolves
-    // for callers porting Zig's `std.os.windows.kernel32.*` 1:1.
+    // Re-export externs declared at the crate root so `kernel32::Foo` resolves.
     pub use super::{
         CreateFileW, GetCurrentDirectoryW, GetFileAttributesW, GetSystemInfo, SYSTEM_INFO,
         SetCurrentDirectoryW, SetFilePointerEx,
@@ -731,8 +726,6 @@ pub mod kernel32 {
 }
 pub use kernel32::{GetCurrentProcess, GetExitCodeProcess, GetLastError};
 
-// `std.os.windows.WaitForSingleObject` — Zig's wrapper returns `error.WaitFailed`
-// on `WAIT_FAILED`; provide that shape so `if let Err(..)` callers compile.
 pub const INFINITE: DWORD = 0xFFFF_FFFF;
 pub const WAIT_OBJECT_0: DWORD = 0;
 pub const WAIT_TIMEOUT: DWORD = 258;
@@ -757,8 +750,7 @@ pub unsafe fn WaitForSingleObject(handle: HANDLE, ms: DWORD) -> Result<DWORD, Wi
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// NTSTATUS — Zig `std.os.windows.NTSTATUS` is `enum(u32) { ..., _ }`.
-// Ported as a transparent newtype so unmapped codes round-trip.
+// NTSTATUS — a transparent newtype so unmapped codes round-trip.
 // ──────────────────────────────────────────────────────────────────────────
 #[repr(transparent)]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
@@ -812,12 +804,11 @@ pub const STATUS_SUCCESS: NTSTATUS = NTSTATUS::SUCCESS;
 
 #[link(name = "ntdll")]
 unsafe extern "system" {
-    /// Zig: `pub extern "ntdll" fn RtlNtStatusToDosError(win32.NTSTATUS) callconv(.winapi) Win32Error`
     /// Total over `NTSTATUS`; no preconditions.
     pub safe fn RtlNtStatusToDosError(status: NTSTATUS) -> DWORD;
 }
 
-/// `std.os.windows.ws2_32` — Winsock2 surface (subset).
+/// `ws2_32` — Winsock2 surface (subset).
 pub mod ws2_32 {
     use super::*;
 
@@ -926,9 +917,9 @@ pub mod ws2_32 {
         pub s6_addr: [u8; 16],
     }
 
-    /// `std.os.windows.ws2_32.WinsockError` — `WSAE*` codes (`WSABASEERR` = 10000).
-    /// Newtype so `bun_sys::windows::winsock_error_to_zig_err` can `match` on
-    /// associated consts. Values from `winsock2.h` / Zig `lib/std/os/windows/ws2_32.zig`.
+    /// Winsock error codes — `WSAE*` (`WSABASEERR` = 10000).
+    /// Newtype so `bun_sys::windows::win_sock_error_to_zig_error` can `match` on
+    /// associated consts. Values from `winsock2.h`.
     #[repr(transparent)]
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
     pub struct WinsockError(pub u16);
@@ -1036,7 +1027,7 @@ pub mod ws2_32 {
 
     #[link(name = "ws2_32")]
     unsafe extern "system" {
-        /// Raw `WSAGetLastError`. The Zig wrapper (`?SystemErrno`) lives in `errno`
+        /// Raw `WSAGetLastError`. The `Option<SystemErrno>` wrapper lives in `errno`
         /// because `SystemErrno` is a higher-tier type. No preconditions; reads
         /// thread-local Winsock error slot.
         pub safe fn WSAGetLastError() -> c_int;
@@ -1059,15 +1050,14 @@ pub mod ws2_32 {
         pub revents: i16,
     }
     pub const SOCKET_ERROR: c_int = -1;
-    /// `POLLWRNORM` (`winsock2.h`) — `std.posix.POLL.WRNORM` on Windows.
+    /// `POLLWRNORM` (`winsock2.h`).
     pub const POLLWRNORM: i16 = 0x0010;
 }
 pub use ws2_32::WSAGetLastError;
 
 // ──────────────────────────────────────────────────────────────────────────
-// Win32Error — Zig `enum(u16) { ..., _ }`. Ported as a transparent newtype
-// with associated consts so unmapped codes round-trip and `match` on consts
-// works (structural equality). Only the subset referenced by lower-tier
+// Win32Error — a transparent newtype with associated consts so unmapped
+// codes round-trip and `match` on consts works (structural equality). Only the subset referenced by lower-tier
 // crates (errno) is named here; the full 1188-variant table can be extended
 // without ABI change.
 // ──────────────────────────────────────────────────────────────────────────
@@ -1076,7 +1066,7 @@ pub use ws2_32::WSAGetLastError;
 pub struct Win32Error(pub u16);
 
 impl Win32Error {
-    // — core enum variants (values from MS-ERREF / std.os.windows.Win32Error) —
+    // — core enum variants (values from MS-ERREF) —
     pub const SUCCESS: Win32Error = Win32Error(0);
     pub const INVALID_FUNCTION: Win32Error = Win32Error(1);
     pub const FILE_NOT_FOUND: Win32Error = Win32Error(2);
@@ -1157,7 +1147,7 @@ impl Win32Error {
     pub const IO_REISSUE_AS_CACHED: Win32Error = Win32Error(3950);
     pub const INVALID_REPARSE_DATA: Win32Error = Win32Error(4392);
 
-    // — WSA pseudo-variants (Zig: `pub const WSAE*: Win32Error = @enumFromInt(N)`) —
+    // — WSA pseudo-variants —
     pub const WSA_INVALID_HANDLE: Win32Error = Win32Error(6);
     pub const WSA_NOT_ENOUGH_MEMORY: Win32Error = Win32Error(8);
     pub const WSA_INVALID_PARAMETER: Win32Error = Win32Error(87);
@@ -1228,7 +1218,6 @@ impl Win32Error {
     pub const WSANO_DATA: Win32Error = Win32Error(11004);
     pub const WSA_QOS_RESERVED_PETYPE: Win32Error = Win32Error(11031);
 
-    /// Zig: `pub fn get() Win32Error { @enumFromInt(@intFromEnum(kernel32.GetLastError())) }`
     #[inline]
     pub fn get() -> Win32Error {
         Win32Error(kernel32::GetLastError() as u16)
@@ -1244,7 +1233,6 @@ impl Win32Error {
         self.0
     }
 
-    /// Zig: `pub fn fromNTStatus(status) Win32Error { RtlNtStatusToDosError(status) }`
     #[inline]
     pub fn from_ntstatus(status: NTSTATUS) -> Win32Error {
         Win32Error(RtlNtStatusToDosError(status) as u16)
@@ -1328,9 +1316,9 @@ unsafe extern "system" {
     pub fn SaferiIsExecutableFileType(szFullPathname: LPCWSTR, bFromShellExecute: BOOLEAN) -> BOOL;
 }
 
-// PORT NOTE: the Zig declared these without an explicit library/callconv (defaults to .c on x64).
 // `GetProcAddress`/`LoadLibraryA` are kernel32 stdcall — use `extern "system"` so the
-// callconv is correct on all targets. `GetProcAddress` takes `LPCSTR` (narrow), not wide.
+// callconv is correct on all targets (winapi == C only on x64). `GetProcAddress`
+// takes `LPCSTR` (narrow), not wide.
 #[link(name = "kernel32")]
 unsafe extern "system" {
     pub fn GetProcAddress(ptr: *mut c_void, name: *const c_char) -> *mut c_void;
@@ -1338,8 +1326,8 @@ unsafe extern "system" {
     pub fn LoadLibraryA(name: *const c_char) -> *mut c_void;
 }
 
-// PORT NOTE: the following kernel32 fns lacked `callconv(.winapi)` in the Zig (works on
-// x64 where winapi == C). Declared here as "system" for correctness on all targets.
+// Declared as `extern "system"` so the callconv is correct on all targets
+// (winapi == C only on x64).
 #[link(name = "kernel32")]
 unsafe extern "system" {
     pub fn CopyFileW(source: LPCWSTR, dest: LPCWSTR, bFailIfExists: BOOL) -> BOOL;
@@ -1454,7 +1442,7 @@ pub struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
 }
 
 // ──────────────────────────────────────────────────────────────────────────
-// Process creation POD (`processthreadsapi.h`). Mirrors std.os.windows.
+// Process creation POD (`processthreadsapi.h`).
 // ──────────────────────────────────────────────────────────────────────────
 
 /// `STARTUPINFOW` (`processthreadsapi.h`).
@@ -1498,8 +1486,8 @@ pub struct PROCESS_INFORMATION {
 
 // ──────────────────────────────────────────────────────────────────────────
 // TEB → PEB → RTL_USER_PROCESS_PARAMETERS chain (`winternl.h` / phnt).
-// Mirrors `std.os.windows.{teb, peb, TEB, PEB, RTL_USER_PROCESS_PARAMETERS,
-// CURDIR}` so the three former duplicators (`bun_core::windows_sys`,
+// `teb`/`peb` accessors plus the `TEB`, `PEB`, `RTL_USER_PROCESS_PARAMETERS`,
+// and `CURDIR` structs live here so the three former duplicators (`bun_core::windows_sys`,
 // `bun_sys::windows`, the freestanding `bun_shim_impl` shim) all re-export
 // from this tier-0 leaf. Only fields actually dereferenced by Bun are
 // modelled; `offset_of!` asserts pin them to the documented x64 offsets so a
@@ -1512,7 +1500,7 @@ pub struct CURDIR {
     pub DosPath: UNICODE_STRING,
     pub Handle: HANDLE,
 }
-/// Zig-style camelCase alias (`bun_core` callers).
+/// CamelCase alias (`bun_core` callers).
 pub type Curdir = CURDIR;
 
 /// `RTL_USER_PROCESS_PARAMETERS` (`winternl.h`) — minimal view.
@@ -1525,17 +1513,16 @@ pub struct RTL_USER_PROCESS_PARAMETERS {
     pub hStdInput: HANDLE,
     pub hStdOutput: HANDLE,
     pub hStdError: HANDLE,
-    /// `CURDIR` — `{ UNICODE_STRING DosPath; HANDLE Handle; }`. The handle
-    /// is what Zig's `std.fs.cwd().fd` returns on Windows; `Fd::cwd()` reads
-    /// it so `openat(Fd::cwd(), …)` resolves relative paths against the live
-    /// process cwd via `NtCreateFile`'s `RootDirectory`.
+    /// `CURDIR` — `{ UNICODE_STRING DosPath; HANDLE Handle; }`. `Fd::cwd()`
+    /// reads the handle so `openat(Fd::cwd(), …)` resolves relative paths
+    /// against the live process cwd via `NtCreateFile`'s `RootDirectory`.
     pub CurrentDirectory: CURDIR,
     pub DllPath: UNICODE_STRING,
     pub ImagePathName: UNICODE_STRING,
     pub CommandLine: UNICODE_STRING,
     // (fields beyond CommandLine are not read by Bun)
 }
-/// Zig-style camelCase alias (`bun_core` callers).
+/// CamelCase alias (`bun_core` callers).
 pub type ProcessParameters = RTL_USER_PROCESS_PARAMETERS;
 // `RTL_USER_PROCESS_PARAMETERS` places `StandardInput` at 0x20,
 // `CurrentDirectory.Handle` at 0x48, and `ImagePathName` at 0x60 on x64.
@@ -1584,7 +1571,7 @@ pub struct TEB {
 #[cfg(target_pointer_width = "64")]
 const _: () = assert!(core::mem::offset_of!(TEB, ProcessEnvironmentBlock) == 0x60);
 
-/// `std.os.windows.teb()` — `gs:[0x30]` (x64) / `x18` (ARM64).
+/// Reads the TEB pointer — `gs:[0x30]` (x64) / `x18` (ARM64).
 ///
 /// Safe fn: the only precondition — that the segment register / `x18`
 /// reservation is the OS thread-block pointer — is guaranteed by the Windows
@@ -1610,7 +1597,7 @@ pub fn teb() -> *mut TEB {
     }
 }
 
-/// `std.os.windows.peb()` — reads `gs:[0x60]` (x64) / `TEB+0x60` (ARM64).
+/// Reads the PEB pointer — `gs:[0x60]` (x64) / `TEB+0x60` (ARM64).
 ///
 /// Returns a raw pointer (NOT `&'static PEB`): the PEB is owned and mutated
 /// by the OS/CRT behind Rust's back (`SetStdHandle`, debugger toggling
@@ -1770,5 +1757,3 @@ unsafe extern "system" {
 unsafe extern "C" {
     pub fn windows_enable_stdio_inheritance();
 }
-
-// ported from: src/windows_sys/externs.zig
diff --git a/src/windows_sys/lib.rs b/src/windows_sys/lib.rs
index 81af45bc8d3..e640e926603 100644
--- a/src/windows_sys/lib.rs
+++ b/src/windows_sys/lib.rs
@@ -1,7 +1,6 @@
 // Tier-0 leaf crate: pure Win32 typedefs/consts/externs over `core` only.
 // `no_std` so the standalone `bun_shim_impl.exe` (which depends on nothing
-// else from the workspace) links without the Rust runtime / CRT — matching
-// Zig's freestanding `bun_shim_impl.zig` build (no libc, ~13 KiB).
+// else from the workspace) links without the Rust runtime / CRT (no libc).
 #![no_std]
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 #![warn(unused_must_use)]
@@ -14,7 +13,7 @@ pub use externs::*;
 // externs crate and must stay leaf. The `bun.windows.libuv` alias lives in the
 // higher-tier `bun_sys::windows` module (`pub use bun_libuv_sys as libuv`).
 
-/// `std.os.windows.NTSTATUS` value namespace. The `NTSTATUS` newtype carries
+/// `NTSTATUS` value namespace (`ntstatus.h`). The `NTSTATUS` newtype carries
 /// these as associated consts, but `bun_sys::windows` glob-imports them as
 /// bare match patterns (`use bun_windows_sys::ntstatus::*`); associated consts
 /// can't be glob-re-exported, so mirror them as free consts here.
diff --git a/src/wyhash/lib.rs b/src/wyhash/lib.rs
index 8c0e974e8b3..c55b72f62b0 100644
--- a/src/wyhash/lib.rs
+++ b/src/wyhash/lib.rs
@@ -1,9 +1,8 @@
 //
-// `Wyhash11` is a copy of Wyhash from the zig standard library, version v0.11.0-dev.2609+5e19250a1
-// (the older 32-byte-round, 5-prime variant kept in src/wyhash/wyhash.zig).
+// `Wyhash11` is an older wyhash variant (32-byte rounds, 5 primes).
 //
-// `Wyhash` is the current `std.hash.Wyhash` (final4 variant, 48-byte rounds, 4 secrets) ported
-// from vendor/zig/lib/std/hash/wyhash.zig — used by RuntimeTranspilerCache, `bun.hash()`, router.
+// `Wyhash` is the current wyhash (final4 variant, 48-byte rounds, 4 secrets) —
+// used by RuntimeTranspilerCache, `bun.hash()`, router.
 //
 // THESE ARE DIFFERENT ALGORITHMS. They produce different outputs for the same input.
 //
@@ -21,8 +20,7 @@ const PRIMES: [u64; 5] = [
     0x1d8e4e27c47d124f,
 ];
 
-// Zig: `inline fn read(comptime T, data) { mem.readInt(T, data[0..@sizeOf(T)], .little) }`
-// — a single unaligned load. Mirrors the `Wyhash::read4`/`read8` treatment
+// A single unaligned load. Mirrors the `Wyhash::read4`/`read8` treatment
 // below (~lib.rs:600): the per-byte `[data[0], data[1], ...]` spelling left a
 // cmp/je-to-panic ladder per byte in `WyhashStateless::final_`/`round`, and
 // `final_` is the `StringHashMap` short-key hash — hit on every parser /
@@ -30,11 +28,10 @@ const PRIMES: [u64; 5] = [
 // keys are <32B so `aligned_len == 0` and the whole key goes through `final_`).
 // Every caller proves the length first (the `1..=31` arms of `final_` slice
 // `rem_key = &b[0..rem_len]` with `rem_len` == the match scrutinee; `round`
-// takes a `&[u8]` it `debug_assert!`s == 32), so match Zig's codegen exactly.
+// takes a `&[u8]` it `debug_assert!`s == 32), so a single unaligned load is sound.
 #[inline(always)]
 fn read_bytes<const BYTES: u8>(data: &[u8]) -> u64 {
     debug_assert!(data.len() >= usize::from(BYTES));
-    // Zig: const T = std.meta.Int(.unsigned, 8 * bytes); mem.readInt(T, data[0..bytes], .little)
     // Rust cannot mint an integer type from a const generic; dispatch on the only values used.
     match BYTES {
         1 => u64::from(data[0]),
@@ -64,8 +61,7 @@ fn read_8bytes_swapped(data: &[u8]) -> u64 {
 // bun_collections / bun_js_parser crate boundary, leaving an out-of-line `mum`
 // (and a `call` per mix step) inside the hashbrown probe loop. Force the 4 mix
 // steps to fold in with no call/ret — same reasoning the surrounding `final_*`
-// helpers are `#[inline(always)]` / `#[cold]`-split for. Zig force-inlines the
-// equivalent `mum`/`mix0`/`mix1` via `@call(bun.callmod_inline, ...)`.
+// helpers are `#[inline(always)]` / `#[cold]`-split for.
 #[inline(always)]
 fn mum(a: u64, b: u64) -> u64 {
     let mut r = (a as u128) * (b as u128);
@@ -183,7 +179,7 @@ impl WyhashStateless {
         WyhashStateless { seed, msg_len: 0 }
     }
 
-    #[inline(always)] // Zig: `@call(bun.callmod_inline, self.round, ...)`
+    #[inline(always)]
     fn round(&mut self, b: &[u8]) {
         debug_assert!(b.len() == 32);
 
@@ -198,14 +194,13 @@ impl WyhashStateless {
         );
     }
 
-    #[inline(always)] // Zig: `@call(bun.callmod_inline, c.update, ...)`
+    #[inline(always)]
     pub(crate) fn update(&mut self, b: &[u8]) {
         debug_assert!(b.len().is_multiple_of(32));
 
         let mut off: usize = 0;
         while off < b.len() {
             self.round(&b[off..off + 32]);
-            // @call(bun.callmod_inline, self.round, .{b[off .. off + 32]});
             off += 32;
         }
 
@@ -219,13 +214,11 @@ impl WyhashStateless {
     // almost always <17B, so split the cold `17..=31` tail into a separate
     // `#[cold] #[inline(never)] final_long`, leaving `final_` with just the
     // `0..=16` arms — small enough to inline cleanly into every hashbrown probe.
-    // Zig spells the call as `@call(bun.callmod_inline, c.final, ...)`.
     #[inline(always)]
     pub(crate) fn final_(&mut self, b: &[u8]) -> u64 {
         debug_assert!(b.len() < 32);
 
         let seed = self.seed;
-        // Zig: @as(u5, @intCast(b.len)) — Rust has no u5; b.len() < 32 is asserted above.
         let rem_len = b.len();
         let rem_key = &b[0..rem_len];
 
@@ -312,17 +305,14 @@ impl WyhashStateless {
     // standalone symbol (91 self-samples) and `call`ed from
     // `find_symbol_with_record_usage` and every `StringHashMap`/hashbrown probe
     // — `#[inline]` (hint) was being declined across the bun_wyhash →
-    // bun_js_parser/bun_collections crate boundary. Zig force-inlines the whole
-    // hash into the caller via `@call(bun.callmod_inline, ...)`; match that.
+    // bun_js_parser/bun_collections crate boundary; force it.
     #[inline(always)]
     pub(crate) fn hash(seed: u64, input: &[u8]) -> u64 {
         let aligned_len = input.len() - (input.len() % 32);
 
         let mut c = WyhashStateless::init(seed);
         c.update(&input[0..aligned_len]);
-        // @call(bun.callmod_inline, c.update, .{input[0..aligned_len]});
         c.final_(&input[aligned_len..])
-        // return @call(bun.callmod_inline, c.final, .{input[aligned_len..]});
     }
 }
 
@@ -340,7 +330,7 @@ impl Wyhash11 {
     pub fn init(seed: u64) -> Wyhash11 {
         Wyhash11 {
             state: WyhashStateless::init(seed),
-            buf: [0; 32], // Zig: undefined
+            buf: [0; 32],
             buf_len: 0,
         }
     }
@@ -381,8 +371,7 @@ impl Wyhash11 {
 }
 
 // Allow `Wyhash11` to be used with `core::hash::Hash::hash` (e.g., as the
-// state for std/HashMap-style hashing). Mirrors how Zig's `std.hash_map`
-// AutoContext drives a Wyhash state.
+// state for std/HashMap-style hashing).
 impl core::hash::Hasher for Wyhash11 {
     #[inline]
     fn write(&mut self, bytes: &[u8]) {
@@ -398,12 +387,11 @@ impl core::hash::Hasher for Wyhash11 {
 }
 
 // ════════════════════════════════════════════════════════════════════════════
-// Wyhash (std.hash.Wyhash — final4 variant, 48-byte rounds, 4 secrets)
-// Ported from vendor/zig/lib/std/hash/wyhash.zig
+// Wyhash (final4 variant, 48-byte rounds, 4 secrets)
 // ════════════════════════════════════════════════════════════════════════════
 
-/// `std.hash.Wyhash` — the wyhash final4 variant. Used by `bun.hash()`,
-/// `RuntimeTranspilerCache`, the router, and Zig's std `HashMap` autocontext.
+/// The wyhash final4 variant. Used by `bun.hash()`,
+/// `RuntimeTranspilerCache`, and the router.
 ///
 /// NOT interchangeable with [`Wyhash11`].
 #[derive(Clone, Copy)]
@@ -429,11 +417,11 @@ impl Wyhash {
     pub fn init(seed: u64) -> Wyhash {
         let s0 = seed ^ Self::mix(seed ^ Self::SECRET[0], Self::SECRET[1]);
         Wyhash {
-            a: 0, // Zig: undefined
-            b: 0, // Zig: undefined
+            a: 0,
+            b: 0,
             state: [s0, s0, s0],
             total_len: 0,
-            buf: [0; 48], // Zig: undefined
+            buf: [0; 48],
             buf_len: 0,
         }
     }
@@ -513,12 +501,12 @@ impl Wyhash {
             b: self.b,
             state: self.state,
             total_len: self.total_len,
-            buf: [0; 48], // Zig: undefined
-            buf_len: 0,   // Zig: undefined
+            buf: [0; 48],
+            buf_len: 0,
         }
     }
 
-    #[inline(always)] // Zig: `inline fn smallKey`
+    #[inline(always)]
     fn small_key(&mut self, input: &[u8]) {
         debug_assert!(input.len() <= 16);
 
@@ -540,7 +528,7 @@ impl Wyhash {
 
     #[inline]
     fn round(&mut self, input: &[u8; 48]) {
-        // Zig: inline for (0..3) |i| — manually unrolled.
+        // Manually unrolled.
         let a0 = Self::read8(&input[0..]);
         let b0 = Self::read8(&input[8..]);
         self.state[0] = Self::mix(a0 ^ Self::SECRET[1], b0 ^ self.state[0]);
@@ -554,13 +542,12 @@ impl Wyhash {
         self.state[2] = Self::mix(a2 ^ Self::SECRET[3], b2 ^ self.state[2]);
     }
 
-    // Zig: `inline fn read(comptime T, data) { mem.readInt(T, data[0..@sizeOf(T)], .little) }`
-    // — a single unaligned load. The previous per-byte `[data[0], data[1], ...]`
+    // A single unaligned load. The previous per-byte `[data[0], data[1], ...]`
     // spelling left a cmp/je-to-panic ladder per byte in the `small_key` disasm
     // (8 bounds checks for the 4× `read4` at len∈[4,16]). All call sites slice
     // from a buffer whose length is already proven ≥4/≥8 by the enclosing
     // branch (`small_key`: `len >= 4`; `round`: `&[u8; 48]`; `final1`:
-    // `i + 16 < len` / `len - 16` / `len - 8`), so match Zig's codegen exactly.
+    // `i + 16 < len` / `len - 16` / `len - 8`), so a single unaligned load is sound.
     #[inline(always)]
     fn read4(data: &[u8]) -> u64 {
         debug_assert!(data.len() >= 4);
@@ -600,8 +587,7 @@ impl Wyhash {
     }
 
     // input_lb must be at least 16-bytes long (in shorter key cases the small_key function will be
-    // used instead). We use an index into a slice for comptime processing as opposed to if we
-    // used pointers.
+    // used instead). Indexes into a slice rather than offsetting raw pointers.
     #[inline]
     fn final1(&mut self, input_lb: &[u8], start_pos: usize) {
         debug_assert!(input_lb.len() >= 16);
@@ -621,7 +607,7 @@ impl Wyhash {
         self.b = Self::read8(&input_lb[input_lb.len() - 8..]);
     }
 
-    #[inline(always)] // Zig: `inline fn final2`
+    #[inline(always)]
     fn final2(&mut self) -> u64 {
         self.a ^= Self::SECRET[1];
         self.b ^= self.state[0];
@@ -633,9 +619,8 @@ impl Wyhash {
     }
 
     // perf on build/create-next showed `Wyhash::hash` out-lined and `call`ed
-    // from every wyhash-backed hashbrown probe; Zig's `std.hash.Wyhash.hash`
-    // inlines fully into its caller. `#[inline]` (hint) is declined across the
-    // crate boundary for this body size — force it.
+    // from every wyhash-backed hashbrown probe. `#[inline]` (hint) is declined
+    // across the crate boundary for this body size — force it.
     #[inline(always)]
     pub fn hash(seed: u64, input: &[u8]) -> u64 {
         let mut this = Wyhash::init(seed);
@@ -645,25 +630,21 @@ impl Wyhash {
         } else {
             let mut i: usize = 0;
             if input.len() >= 48 {
-                // Hot path for `Bun.hash` over large buffers. Zig spells the
-                // body as `inline fn round` calling `inline fn read`/`mix`/
-                // `mum`, all of which are *force*-inlined; Rust's `#[inline]`
-                // is a hint that opt-level 0 ignores, so the helper-function
-                // shape costs ~12 callee frames per 48-byte block. Instead,
-                // hoist state into locals and open-code one round per
-                // iteration (3× 128-bit multiply, 6× le-u64 read).
+                // Hot path for `Bun.hash` over large buffers. Rust's
+                // `#[inline]` is a hint that opt-level 0 ignores, so a
+                // helper-function shape costs ~12 callee frames per 48-byte
+                // block. Instead, hoist state into locals and open-code one
+                // round per iteration (3× 128-bit multiply, 6× le-u64 read).
                 let [mut s0, mut s1, mut s2] = this.state;
                 let (k1, k2, k3) = (Self::SECRET[1], Self::SECRET[2], Self::SECRET[3]);
-                // Six little-endian u64 reads per round. Zig's
-                // `std.mem.readInt(u64, p, .little)` is a single unaligned
-                // load (`@bitCast` of `*const [8]u8`). The previous safe-Rust
-                // spellings here — `input[i..i+48].try_into()` plus per-byte
-                // shift-or — left a slice bounds-check + panic edge per
-                // iteration and 48 scalar byte loads per round, which made
+                // Six little-endian u64 reads per round. The previous
+                // safe-Rust spellings here — `input[i..i+48].try_into()` plus
+                // per-byte shift-or — left a slice bounds-check + panic edge
+                // per iteration and 48 scalar byte loads per round, which made
                 // `Wyhash::hash` the #1 self-time symbol when
-                // `RuntimeTranspilerCache` hashes multi-MB sources. Match the
-                // Zig codegen exactly: take the base pointer once and issue
-                // six `read_unaligned::<u64>` per round.
+                // `RuntimeTranspilerCache` hashes multi-MB sources. Take the
+                // base pointer once and issue six `read_unaligned::<u64>` per
+                // round.
                 //
                 // `i + 48 < len` ⇔ `i < len - 48`; len ≥ 48 is guaranteed
                 // by the enclosing branch, so the subtraction is safe and we
@@ -704,7 +685,7 @@ impl Wyhash {
 }
 
 // Allow `Wyhash` to be used with `core::hash::Hash::hash` (e.g., as the state
-// for std/HashMap-style hashing). Mirrors Zig's `std.hash_map` AutoContext.
+// for std/HashMap-style hashing).
 impl core::hash::Hasher for Wyhash {
     #[inline]
     fn write(&mut self, bytes: &[u8]) {
@@ -726,13 +707,11 @@ impl Default for Wyhash {
 
 /// One-shot `Hasher` for `std::collections::HashMap`. Unlike [`Wyhash`]'s
 /// streaming `Hasher` impl (which buffers into a 48-byte scratch and re-zeroes
-/// it on every `init`/`shallow_copy` — a measurable zero-fill cost the Zig
-/// `= undefined` avoids), this folds each `write` through the stateless
-/// one-shot path seeded by the running hash. Matches Zig's
-/// `std.hash_map.getAutoHashFn` shape: no buffering, no per-key allocation.
+/// it on every `init`/`shallow_copy` — a measurable zero-fill cost), this folds
+/// each `write` through the stateless one-shot path seeded by the running
+/// hash: no buffering, no per-key allocation.
 ///
-/// Hash values are deterministic across runs (seed 0) but are NOT
-/// bit-identical to Zig's `Wyhash.hash(0, key)` because Rust's `Hash for [T]`
+/// Hash values are deterministic across runs (seed 0). Rust's `Hash for [T]`
 /// prepends a length prefix; that's fine — these are in-memory tables only
 /// (lockfile/on-disk hashes go through [`Wyhash11`] / [`hash`] directly).
 #[derive(Default, Clone, Copy)]
@@ -744,8 +723,7 @@ impl core::hash::Hasher for OneShotHasher {
     // perf on build/create-next: `OneShotHasher::write` showed up as a
     // standalone 58-self-sample symbol `call`ed from hashbrown's probe loop —
     // `#[inline]` was being declined across the bun_wyhash → bun_collections
-    // crate boundary. Force-inline so the whole hash collapses into the caller
-    // (matches Zig's `getAutoHashFn`, which is fully comptime-inlined).
+    // crate boundary. Force-inline so the whole hash collapses into the caller.
     #[inline(always)]
     fn write(&mut self, bytes: &[u8]) {
         // Each chunk re-seeds from the previous output, so multi-`write` keys
@@ -775,8 +753,7 @@ impl core::hash::Hasher for OneShotHasher {
     /// No-op: keys hashed through this hasher are never cross-type, so the
     /// prefix-freedom guarantee `<[T] as Hash>` buys is unused. Skipping it
     /// makes `<[u8] as Hash>` collapse to a single `write(bytes)` →
-    /// `Wyhash11::hash(0, bytes)` — the exact shape of Zig's
-    /// `bun.StringHashMapContext.hash`. perf showed `hashbrown::make_hash`
+    /// `Wyhash11::hash(0, bytes)`. perf showed `hashbrown::make_hash`
     /// outlined with the extra `mum` from the length prefix as dead weight.
     #[inline(always)]
     fn write_length_prefix(&mut self, _len: usize) {}
@@ -792,7 +769,7 @@ impl core::hash::Hasher for OneShotHasher {
 
 /// Hash any `K: Hash` through [`OneShotHasher`] — the `Hash` → wyhash thunk
 /// shared by both auto-context map types. See the [`OneShotHasher`] doc-comment
-/// for the length-prefix divergence from Zig's `Wyhash.hash(0, asBytes(&k))`.
+/// for the length-prefix note.
 #[inline]
 pub fn auto_hash<K: core::hash::Hash + ?Sized>(key: &K) -> u64 {
     let mut h = OneShotHasher::default();
@@ -805,7 +782,7 @@ pub fn auto_hash<K: core::hash::Hash + ?Sized>(key: &K) -> u64 {
 /// the short identifier keys the parser/printer/renamer churn.
 pub type BuildHasher = core::hash::BuildHasherDefault<OneShotHasher>;
 
-/// `bun.hash(bytes)` — `std.hash.Wyhash` with seed 0.
+/// `bun.hash(bytes)` — wyhash with seed 0.
 #[inline]
 pub fn hash(bytes: &[u8]) -> u64 {
     Wyhash::hash(0, bytes)
@@ -813,16 +790,16 @@ pub fn hash(bytes: &[u8]) -> u64 {
 
 #[inline]
 pub fn hash32(bytes: &[u8]) -> u32 {
-    hash(bytes) as u32 // @truncate
+    hash(bytes) as u32 // truncating cast
 }
 
-/// `bun.hashWithSeed(seed, bytes)` — `std.hash.Wyhash` with explicit seed.
+/// `bun.hashWithSeed(seed, bytes)` — wyhash with explicit seed.
 #[inline]
 pub fn hash_with_seed(seed: u64, bytes: &[u8]) -> u64 {
     Wyhash::hash(seed, bytes)
 }
 
-/// `std.hash.Wyhash` over the ASCII-lowercased view of `bytes`, streamed
+/// Wyhash over the ASCII-lowercased view of `bytes`, streamed
 /// through a 48-byte stack scratch so no heap allocation occurs regardless of
 /// input length. ASCII-only (`b'A'..=b'Z' → b'a'..=b'z'`); non-ASCII bytes
 /// pass through unchanged.
@@ -832,8 +809,7 @@ pub fn hash_with_seed(seed: u64, bytes: &[u8]) -> u64 {
 /// to the hasher are identical either way — so this collapses the three
 /// open-coded copies in `http::hash_header_name`,
 /// `s3_signing::S3Credentials::hash_const`, and
-/// `collections::CaseInsensitiveAsciiStringContext::hash_bytes` (Zig has the
-/// same triplication: http.zig:828, credentials.zig:23, bun.zig:1011).
+/// `collections::CaseInsensitiveAsciiStringContext::hash_bytes`.
 #[inline]
 pub fn hash_ascii_lowercase(seed: u64, bytes: &[u8]) -> u64 {
     let mut buf = [0u8; 48];
@@ -860,17 +836,17 @@ pub fn hash_ascii_lowercase(seed: u64, bytes: &[u8]) -> u64 {
     h.final_()
 }
 
-/// `std.hash.Wyhash.hash(seed, input)` as a `const fn`.
+/// [`Wyhash::hash`]`(seed, input)` as a `const fn`.
 ///
-/// This is a parallel one-shot port of [`Wyhash::hash`] for compile-time
-/// evaluation (e.g. `generated_symbol_name!` in `js_parser`, which must match
-/// Zig's `comptime std.hash.Wyhash.hash(0, name)` byte-for-byte). The runtime
+/// This is a parallel one-shot version of [`Wyhash::hash`] for compile-time
+/// evaluation (e.g. `generated_symbol_name!` in `js_parser`, which needs the
+/// hash at compile time). The runtime
 /// [`Wyhash::hash`] is intentionally NOT `const fn` — its perf-tuned hot loop
 /// uses `slice.try_into()` (trait call) and the streaming API uses
 /// `copy_from_slice`, neither of which is const-compatible. Keep the two in
 /// lock-step; `tests::hash_const_matches_runtime` guards drift.
 pub const fn hash_const(seed: u64, input: &[u8]) -> u64 {
-    // ── std.hash.Wyhash (final4 variant) — const-fn re-port. ──
+    // ── wyhash final4 variant — const-fn re-implementation. ──
     const SECRET: [u64; 4] = Wyhash::SECRET;
 
     #[inline]
@@ -955,9 +931,9 @@ pub const fn hash_const(seed: u64, input: &[u8]) -> u64 {
     )
 }
 
-/// `std.hash.int` — integer-to-integer hashing (same width in, same width out).
-/// Zig's version is `anytype`-generic; we cover the dedicated widths (16/32/64)
-/// via a sealed trait. All current callers pass `u32`.
+/// Integer-to-integer hashing (same width in, same width out).
+/// We cover the dedicated widths (16/32/64) via a sealed trait.
+/// All current callers pass `u32`.
 #[inline]
 pub fn hash_int<T: HashInt>(input: T) -> T {
     T::hash_int(input)
@@ -1095,9 +1071,9 @@ mod tests {
 
     #[test]
     fn hash_const_matches_runtime() {
-        // `hash_const` is a parallel const-fn re-port of `Wyhash::hash`; it
-        // produces compile-time symbol suffixes that must match Zig's
-        // `comptime std.hash.Wyhash.hash(0, name)` byte-for-byte. Guard drift.
+        // `hash_const` is a parallel const-fn re-implementation of
+        // `Wyhash::hash`; it produces compile-time symbol suffixes that must
+        // match the runtime hash byte-for-byte. Guard drift.
         for s in [
             &b""[..],
             b"a",
@@ -1201,5 +1177,3 @@ mod tests {
         assert_ne!(Wyhash::hash(0, b"abc"), Wyhash11::hash(0, b"abc"));
     }
 }
-
-// ported from: src/wyhash/wyhash.zig
diff --git a/src/zlib/lib.rs b/src/zlib/lib.rs
index 5674d4855b7..76be3eb8871 100644
--- a/src/zlib/lib.rs
+++ b/src/zlib/lib.rs
@@ -5,7 +5,8 @@ use core::mem::size_of;
 
 use bun_collections::VecExt as _;
 
-// TODO(port): move externs to zlib_sys crate
+// Externs stay in this crate per PORTING.md §FFI: "If your file has externs
+// and isn't already *_sys, leave them in place".
 
 pub const MIN_WBITS: c_int = 8;
 pub const MAX_WBITS: c_int = 15;
@@ -141,14 +142,13 @@ unsafe extern "C" {
     pub fn crc32(crc: uLong, buf: *const Bytef, len: uInt) -> uLong;
 }
 
-// Zig: `pub fn NewZlibReader(comptime Writer: type, comptime buffer_size: usize) type`
 // `W: bun_io::Write` bound is applied on `read_all` (the only method that touches `context`).
 pub struct ZlibReader<'a, W, const BUFFER_SIZE: usize> {
     pub context: W,
     pub input: &'a [u8],
     pub buf: [u8; BUFFER_SIZE],
     pub zlib: zStream_struct,
-    // PORT NOTE: allocator field dropped (global mimalloc)
+    // allocator field dropped (global mimalloc)
     pub state: ZlibReaderState,
 }
 
@@ -232,7 +232,6 @@ impl<'a, W, const BUFFER_SIZE: usize> ZlibReader<'a, W, BUFFER_SIZE> {
         None
     }
 
-    // TODO(port): narrow error set — Zig inferred error union includes Writer's error set.
     pub fn read_all(&mut self, is_done: bool) -> Result<(), bun_core::Error>
     where
         W: bun_io::Write,
@@ -267,9 +266,6 @@ impl<'a, W, const BUFFER_SIZE: usize> ZlibReader<'a, W, BUFFER_SIZE> {
             //   flush parameter).
 
             if self.zlib.avail_out == 0 {
-                // PORT NOTE: Zig did `var written = try ctx.write(&buf); while (written < avail_out) ...`
-                // but avail_out == 0 here so the loop never ran; bun_io::Write::write_all is the
-                // canonical full-buffer write and subsumes the partial-write retry loop.
                 self.context.write_all(&self.buf)?;
                 self.zlib.avail_out = BUFFER_SIZE as uInt;
                 self.zlib.next_out = self.buf.as_mut_ptr();
@@ -284,7 +280,6 @@ impl<'a, W, const BUFFER_SIZE: usize> ZlibReader<'a, W, BUFFER_SIZE> {
                 ReturnCode::StreamEnd => {
                     self.state = ZlibReaderState::End;
                     let remainder = &self.buf[0..BUFFER_SIZE - self.zlib.avail_out as usize];
-                    // PORT NOTE: Zig's partial-write retry loop collapses to write_all under bun_io::Write.
                     self.context.write_all(remainder)?;
                     self.end();
                     return Ok(());
@@ -324,7 +319,6 @@ impl<'a, W, const BUFFER_SIZE: usize> ZlibReader<'a, W, BUFFER_SIZE> {
 
 impl<'a, W, const BUFFER_SIZE: usize> Drop for ZlibReader<'a, W, BUFFER_SIZE> {
     fn drop(&mut self) {
-        // Zig deinit: end() then allocator.destroy(this) — destroy is implicit Box drop.
         self.end();
     }
 }
@@ -342,7 +336,7 @@ bun_core::impl_tag_error!(ZlibError);
 bun_core::named_error_set!(ZlibError);
 
 // zlib `alloc_func`/`free_func` thunks → mimalloc. Shared by `ZlibReader` and
-// `ZlibCompressorArrayList`. Mirrors zlib.zig:138 / :779 — intentionally
+// `ZlibCompressorArrayList`. Intentionally
 // `mi_malloc`, NOT `mi_calloc` (see `ZlibAllocator::alloc` for the zeroing
 // heap-breakdown variant used by `ZlibReaderArrayList`).
 pub(crate) use bun_alloc::c_thunks::{
@@ -357,13 +351,10 @@ mod ZlibAllocator {
 
 pub struct ZlibReaderArrayList<'a> {
     pub input: &'a [u8],
-    // PORT NOTE: reshaped for borrowck — Zig kept a shallow copy of the
-    // ArrayListUnmanaged header in `list` and synced it back to `*list_ptr`.
-    // In Rust we operate directly through `list_ptr` (a `&'a mut Vec<u8>`).
-    // The `list` and `list_allocator` fields are dropped.
+    // We operate directly through `list_ptr` (a `&'a mut Vec<u8>`).
     pub list_ptr: &'a mut Vec<u8>,
     pub zlib: zStream_struct,
-    // PORT NOTE: allocator field dropped (global mimalloc)
+    // allocator field dropped (global mimalloc)
     pub state: ZlibReaderArrayListState,
     /// Decompression-bomb guard: `read_all` errors instead of growing the
     /// output past this many bytes. Defaults to unbounded.
@@ -372,7 +363,6 @@ pub struct ZlibReaderArrayList<'a> {
 
 impl<'a> Drop for ZlibReaderArrayList<'a> {
     fn drop(&mut self) {
-        // Zig deinit: end() then allocator.destroy(this) — destroy is implicit Box drop.
         self.end();
     }
 }
@@ -404,7 +394,7 @@ impl<'a> ZlibReaderArrayList<'a> {
         Self::init_with_options_and_list_allocator(input, list, options)
     }
 
-    // PORT NOTE: list_allocator/allocator params dropped (global mimalloc).
+    // list_allocator/allocator params dropped (global mimalloc).
     pub fn init_with_options_and_list_allocator(
         input: &'a [u8],
         list: &'a mut Vec<u8>,
@@ -477,10 +467,9 @@ impl<'a> ZlibReaderArrayList<'a> {
     }
 
     pub fn read_all(&mut self, is_done: bool) -> Result<(), ZlibError> {
-        // Zig `defer { ...; this.list_ptr.* = this.list; }` — sync output length back.
-        // PORT NOTE: reshaped for borrowck — we mutate list_ptr directly, so the
-        // sync-back is just truncate/set_len. Unconditional `defer` is implemented as
-        // an IIFE for the body + a manual epilogue that runs before returning `result`.
+        // We mutate list_ptr directly, so the output-length sync-back is just
+        // truncate/set_len. The unconditional epilogue is implemented as an
+        // IIFE for the body + a manual epilogue that runs before returning `result`.
         let result = (|| -> Result<(), ZlibError> {
             while self.state == ZlibReaderArrayListState::Uninitialized
                 || self.state == ZlibReaderArrayListState::Inflating
@@ -881,13 +870,10 @@ impl NodeMode {
 /// Not for streaming!
 pub struct ZlibCompressorArrayList<'a> {
     pub input: &'a [u8],
-    // PORT NOTE: reshaped for borrowck — Zig kept a shallow copy of the
-    // ArrayListUnmanaged header in `list` and synced it back to `*list_ptr`.
-    // In Rust we operate directly through `list_ptr` (a `&'a mut Vec<u8>`).
-    // The `list` and `list_allocator` fields are dropped.
+    // We operate directly through `list_ptr` (a `&'a mut Vec<u8>`).
     pub list_ptr: &'a mut Vec<u8>,
     pub zlib: zStream_struct,
-    // PORT NOTE: allocator field dropped (global mimalloc)
+    // allocator field dropped (global mimalloc)
     pub state: ZlibCompressorArrayListState,
 }
 
@@ -908,7 +894,7 @@ impl<'a> ZlibCompressorArrayList<'a> {
         Self::init_with_list_allocator(input, list, options)
     }
 
-    // PORT NOTE: allocator/list_allocator params dropped (global mimalloc).
+    // allocator/list_allocator params dropped (global mimalloc).
     pub fn init_with_list_allocator(
         input: &'a [u8],
         list: &'a mut Vec<u8>,
@@ -971,7 +957,6 @@ impl<'a> ZlibCompressorArrayList<'a> {
                 // ensureTotalCapacityPrecise → reserve_exact
                 let need = (bound as usize).saturating_sub(zlib_reader.list_ptr.len());
                 zlib_reader.list_ptr.reserve_exact(need);
-                // PORT NOTE: Zig caught alloc OOM here; Rust Vec aborts on OOM.
                 zlib_reader.zlib.avail_out = zlib_reader.list_ptr.capacity() as uInt;
                 zlib_reader.zlib.next_out = zlib_reader.list_ptr.as_mut_ptr();
 
@@ -1078,8 +1063,7 @@ impl<'a> ZlibCompressorArrayList<'a> {
             Ok(())
         })();
 
-        // defer epilogue (runs unconditionally):
-        // Zig: this.list.shrinkRetainingCapacity(this.zlib.total_out); this.list_ptr.* = this.list;
+        // epilogue (runs unconditionally): sync the output length back.
         self.list_ptr.truncate(self.zlib.total_out as usize);
 
         result
@@ -1088,13 +1072,11 @@ impl<'a> ZlibCompressorArrayList<'a> {
 
 impl<'a> Drop for ZlibCompressorArrayList<'a> {
     fn drop(&mut self) {
-        // Zig deinit: end() then allocator.destroy(this) — destroy is implicit Box drop.
         self.end();
     }
 }
 
-// Zig: `@import("zlib-internal")` → `src/zlib_sys/{posix,win32}.zig` (see build.zig).
-// Re-export from bun_zlib_sys, platform-selected to match build.zig.
+// Re-export from bun_zlib_sys, platform-selected.
 mod internal {
     #[cfg(not(windows))]
     pub(super) use bun_zlib_sys::posix::{DataType, zStream_struct};
@@ -1105,5 +1087,3 @@ mod internal {
     #[cfg(windows)]
     pub use bun_zlib_sys::win32::{FlushValue, ReturnCode, z_stream, z_streamp};
 }
-
-// ported from: src/zlib/zlib.zig
diff --git a/src/zlib_sys/posix.rs b/src/zlib_sys/posix.rs
index 6ca6e3fc0f8..57f4919febd 100644
--- a/src/zlib_sys/posix.rs
+++ b/src/zlib_sys/posix.rs
@@ -41,5 +41,3 @@ unsafe extern "C" {
         stream_size: c_int,
     ) -> ReturnCode;
 }
-
-// ported from: src/zlib_sys/posix.zig
diff --git a/src/zlib_sys/shared.rs b/src/zlib_sys/shared.rs
index 2ea151ab0f7..f940ababe8f 100644
--- a/src/zlib_sys/shared.rs
+++ b/src/zlib_sys/shared.rs
@@ -86,8 +86,8 @@ pub type z_free_func = free_func;
 // ---------------------------------------------------------------------------
 // zconf.h scalar typedefs — single source of truth.
 //
-// Previously duplicated in win32.rs (translate-c output) and bun_zlib::lib.rs
-// (hand-port of zlib.zig). All resolve to ABI-identical primitives on every
+// Previously duplicated in win32.rs and bun_zlib::lib.rs.
+// All resolve to ABI-identical primitives on every
 // target Bun ships; `uLong` = `unsigned long` (4B on LLP64 Windows, 8B on LP64
 // Unix) for the same reason zStream_struct above uses `c_ulong` directly.
 // ---------------------------------------------------------------------------
@@ -166,7 +166,7 @@ pub struct zStream_struct {
 
 pub type z_stream = zStream_struct;
 pub type z_streamp = *mut z_stream;
-// translate-c spellings (win32.rs historically used these).
+// Alternate spellings (win32.rs historically used these).
 pub type struct_z_stream_s = zStream_struct;
 pub type z_stream_s = zStream_struct;
 
@@ -174,5 +174,3 @@ pub type z_stream_s = zStream_struct;
 // allocators, and `DataType` (a `#[repr(C)]` enum with `Binary = 0`). All-zero
 // is the documented pre-`inflateInit`/`deflateInit` state (S021).
 unsafe impl bun_core::ffi::Zeroable for zStream_struct {}
-
-// ported from: src/zlib_sys/shared.zig
diff --git a/src/zlib_sys/win32.rs b/src/zlib_sys/win32.rs
index 91291d296c9..fe7423daf77 100644
--- a/src/zlib_sys/win32.rs
+++ b/src/zlib_sys/win32.rs
@@ -1,4 +1,3 @@
-//  zig translate-c -I${VCPKG_ROOT}/installed/x64-windows/include/  ${VCPKG_ROOT}/current/installed/x64-windows/include/zlib.h -target x86_64-windows-msvc -lc > src/zlib_sys/win32.zig
 #![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 
 use core::ffi::{c_char, c_int, c_long, c_uint, c_ulong, c_ushort, c_void};
@@ -309,5 +308,3 @@ pub unsafe fn inflate_back_init(
 }
 
 pub type gz_header_s = struct_gz_header_s;
-
-// ported from: src/zlib_sys/win32.zig
diff --git a/src/zstd/lib.rs b/src/zstd/lib.rs
index 4a380d3a99c..5be7a5a2129 100644
--- a/src/zstd/lib.rs
+++ b/src/zstd/lib.rs
@@ -4,8 +4,8 @@ use core::ffi::{c_ulonglong, c_void};
 use bun_core::ZStr;
 
 // ─── FFI bindings ─────────────────────────────────────────────────────────
-// TODO(port): move to zstd_sys once that crate exists. PORTING.md §FFI:
-// "If your file has externs and isn't already *_sys, leave them in place".
+// Externs stay in this crate per PORTING.md §FFI: "If your file has externs
+// and isn't already *_sys, leave them in place".
 #[allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 pub mod c {
     use core::ffi::{c_char, c_int, c_uint, c_ulonglong, c_void};
@@ -169,7 +169,7 @@ pub mod c {
 
 pub enum Result {
     Success(usize),
-    // Zig `[:0]const u8` field, always assigned from ZSTD_getErrorName (static C string).
+    // Always assigned from ZSTD_getErrorName (static C string).
     Err(&'static ZStr),
 }
 
@@ -258,7 +258,6 @@ pub fn decompress(dest: &mut [u8], src: &[u8]) -> Result {
 /// Handles both frames with known and unknown content sizes.
 /// For safety, if the reported decompressed size exceeds 16MB, streaming decompression is used instead.
 pub fn decompress_alloc(src: &[u8]) -> core::result::Result<Vec<u8>, ZstdError> {
-    // TODO(port): narrow error set
     let size = get_decompressed_size(src);
 
     const ZSTD_CONTENTSIZE_UNKNOWN: usize = c_ulonglong::MAX as usize; // 0ULL - 1
@@ -274,18 +273,15 @@ pub fn decompress_alloc(src: &[u8]) -> core::result::Result<Vec<u8>, ZstdError>
     // 2. Reported size exceeds safety limit (to prevent malicious inputs claiming huge sizes)
     if size == ZSTD_CONTENTSIZE_UNKNOWN || size > MAX_PREALLOCATE_SIZE {
         let mut list: Vec<u8> = Vec::new();
-        // PORT NOTE: Zig's `errdefer list.deinit(allocator)` is implicit — `list` drops on `?`.
         let mut reader = ZstdReaderArrayList::init(src, &mut list)?;
 
         reader.read_all(true)?;
         drop(reader);
         return Ok(list);
-        // PORT NOTE: Zig `.toOwnedSlice()` → just return the Vec; caller owns it.
     }
 
     // Fast path: size is known and within reasonable limits
     let mut output = vec![0u8; size];
-    // PORT NOTE: `errdefer allocator.free(output)` is implicit via Vec Drop.
 
     match decompress(&mut output, src) {
         Result::Success(actual_size) => {
@@ -306,12 +302,9 @@ pub use bun_core::compress::State;
 
 pub struct ZstdReaderArrayList<'a> {
     pub input: &'a [u8],
-    // PORT NOTE: reshaped for borrowck — Zig kept a by-value copy of the
-    // ArrayListUnmanaged in `list` and wrote it back through `list_ptr` at the
-    // end of `readAll`. In Rust we operate on the caller's Vec directly via
-    // the `&mut` borrow; the redundant `list` cache field is dropped.
+    // We operate on the caller's Vec directly via the `&mut` borrow.
     pub list_ptr: &'a mut Vec<u8>,
-    // PORT NOTE: `list_allocator` / `allocator` params deleted — global mimalloc.
+    // `list_allocator` / `allocator` params deleted — global mimalloc.
     pub zstd: *mut c::ZSTD_DStream,
     pub state: State,
     pub total_out: usize,
@@ -322,7 +315,7 @@ pub struct ZstdReaderArrayList<'a> {
 }
 
 impl<'a> ZstdReaderArrayList<'a> {
-    // PORT NOTE: `pub const new = bun.TrivialNew(...)` → Box::new; no associated const needed.
+    // `pub const new = bun.TrivialNew(...)` → Box::new; no associated const needed.
 
     pub fn init(
         input: &'a [u8],
@@ -334,7 +327,7 @@ impl<'a> ZstdReaderArrayList<'a> {
     pub fn init_with_list_allocator(
         input: &'a [u8],
         list: &'a mut Vec<u8>,
-        // PORT NOTE: list_allocator / allocator params deleted (global mimalloc).
+        // list_allocator / allocator params deleted (global mimalloc).
     ) -> core::result::Result<Box<ZstdReaderArrayList<'a>>, ZstdError> {
         let zstd = c::ZSTD_createDStream();
         if zstd.is_null() {
@@ -364,9 +357,6 @@ impl<'a> ZstdReaderArrayList<'a> {
     }
 
     pub fn read_all(&mut self, is_done: bool) -> core::result::Result<(), ZstdError> {
-        // PORT NOTE: Zig's `defer this.list_ptr.* = this.list;` is unnecessary —
-        // we mutate the caller's Vec through `list_ptr` directly.
-
         if self.state == State::End || self.state == State::Error {
             return Ok(());
         }
@@ -478,9 +468,6 @@ impl<'a> ZstdReaderArrayList<'a> {
 
 impl Drop for ZstdReaderArrayList<'_> {
     fn drop(&mut self) {
-        // Zig `deinit`: end() then allocator.destroy(this). Box handles the destroy.
         self.end();
     }
 }
-
-// ported from: src/zstd/zstd.zig